From 245141e00a6fe2e72da701a72be6e72ad116154f Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Tue, 18 Jul 2023 21:46:42 +0800
Subject: [PATCH 001/749] GH-35942: [C++] Improve Decimal ToReal accuracy
 (#36667)

### Rationale for this change

The current implementation of `Decimal::ToReal` can be naively represented as the following pseudocode:
```
Real v = static_cast<Real>(decimal.as_int128/256())
return v * (10.0**-scale)
```
It stores the intermediate unscaled int128/256 value as a float/double. The unscaled int128/256 value can be very large when the decimal has a large scale, which causes precision issues such as in #36602.

### What changes are included in this PR?

Avoid storing the unscaled large int as float if the representation is not precise, by spliting the decimal into integral and fractional parts and dealing with them separately. This algorithm guarantees that:
1. If the decimal is an integer, the conversion is exact.
2. If the number of fractional digits is <= RealTraits<Real>::kMantissaDigits (e.g. 8 for float and 16 for double), the conversion is within 1 ULP of the exact value. For example Decimal128::ToReal<float>(9999.999) falls into this category because the integer 9999999 is precisely representable by float, whereas 9999.9999 would be in the next category.
3. Otherwise, the conversion is within 2^(-RealTraits<Real>::kMantissaDigits+1) (e.g. 2^-23 for float and 2^-52 for double) of the exact value.

Here "exact value" means the closest representable value by Real.

I believe this algorithm is good enough, because an"exact" algorithm would require iterative multiplication and subtraction of decimals to determain the binary representation of its fractional part. Yet the result would still almost always be inaccurate because float/double can only accurately represent powers of two. IMHO It's not worth it to spend that many expensive operations just to improve the result by one ULP.

### Are these changes tested?

Yes.

### Are there any user-facing changes?
 No.

* Closes: #35942

Lead-authored-by: Jin Shang <shangjin1997@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../arrow/compute/kernels/scalar_cast_test.cc |   3 +-
 cpp/src/arrow/util/basic_decimal.cc           |  10 ++
 cpp/src/arrow/util/basic_decimal.h            |   4 +
 cpp/src/arrow/util/decimal.cc                 |  58 ++++++-
 cpp/src/arrow/util/decimal_internal.h         |   4 +
 cpp/src/arrow/util/decimal_test.cc            | 148 +++++++++++++-----
 6 files changed, 183 insertions(+), 44 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
index 083a85eb346c5..1db06a762544b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
@@ -1025,7 +1025,8 @@ TEST(Cast, DecimalToFloating) {
     }
   }
 
-  // Edge cases are tested for Decimal128::ToReal() and Decimal256::ToReal()
+  // Edge cases are tested for Decimal128::ToReal() and Decimal256::ToReal() in
+  // decimal_test.cc
 }
 
 TEST(Cast, DecimalToString) {
diff --git a/cpp/src/arrow/util/basic_decimal.cc b/cpp/src/arrow/util/basic_decimal.cc
index f2fd39d6f37ad..0835ab9074a48 100644
--- a/cpp/src/arrow/util/basic_decimal.cc
+++ b/cpp/src/arrow/util/basic_decimal.cc
@@ -969,6 +969,16 @@ bool BasicDecimal256::FitsInPrecision(int32_t precision) const {
   return BasicDecimal256::Abs(*this) < kDecimal256PowersOfTen[precision];
 }
 
+void BasicDecimal256::GetWholeAndFraction(int scale, BasicDecimal256* whole,
+                                          BasicDecimal256* fraction) const {
+  DCHECK_GE(scale, 0);
+  DCHECK_LE(scale, 76);
+
+  BasicDecimal256 multiplier(kDecimal256PowersOfTen[scale]);
+  auto s = Divide(multiplier, whole, fraction);
+  DCHECK_EQ(s, DecimalStatus::kSuccess);
+}
+
 const BasicDecimal256& BasicDecimal256::GetScaleMultiplier(int32_t scale) {
   DCHECK_GE(scale, 0);
   DCHECK_LE(scale, 76);
diff --git a/cpp/src/arrow/util/basic_decimal.h b/cpp/src/arrow/util/basic_decimal.h
index b263bb234a795..d8a91ea76b390 100644
--- a/cpp/src/arrow/util/basic_decimal.h
+++ b/cpp/src/arrow/util/basic_decimal.h
@@ -366,6 +366,10 @@ class ARROW_EXPORT BasicDecimal256 : public GenericBasicDecimal<BasicDecimal256,
   /// \brief Get the lowest bits of the two's complement representation of the number.
   uint64_t low_bits() const { return bit_util::little_endian::Make(array_)[0]; }
 
+  /// \brief separate the integer and fractional parts for the given scale.
+  void GetWholeAndFraction(int32_t scale, BasicDecimal256* whole,
+                           BasicDecimal256* fraction) const;
+
   /// \brief Scale multiplier for given scale value.
   static const BasicDecimal256& GetScaleMultiplier(int32_t scale);
   /// \brief Half-scale multiplier for given scale value.
diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index 1f8447059f633..704b6bb9d491d 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -305,12 +305,39 @@ struct Decimal128RealConversion
   }
 
   template <typename Real>
-  static Real ToRealPositive(const Decimal128& decimal, int32_t scale) {
+  static Real ToRealPositiveNoSplit(const Decimal128& decimal, int32_t scale) {
     Real x = RealTraits<Real>::two_to_64(static_cast<Real>(decimal.high_bits()));
     x += static_cast<Real>(decimal.low_bits());
     x *= LargePowerOfTen<Real>(-scale);
     return x;
   }
+
+  /// An appoximate conversion from Decimal128 to Real that guarantees:
+  /// 1. If the decimal is an integer, the conversion is exact.
+  /// 2. If the number of fractional digits is <= RealTraits<Real>::kMantissaDigits (e.g.
+  ///    8 for float and 16 for double), the conversion is within 1 ULP of the exact
+  ///    value.
+  /// 3. Otherwise, the conversion is within 2^(-RealTraits<Real>::kMantissaDigits+1)
+  ///    (e.g. 2^-23 for float and 2^-52 for double) of the exact value.
+  /// Here "exact value" means the closest representable value by Real.
+  template <typename Real>
+  static Real ToRealPositive(const Decimal128& decimal, int32_t scale) {
+    if (scale <= 0 || (decimal.high_bits() == 0 &&
+                       decimal.low_bits() <= RealTraits<Real>::kMaxPreciseInteger)) {
+      // No need to split the decimal if it is already an integer (scale <= 0) or if it
+      // can be precisely represented by Real
+      return ToRealPositiveNoSplit<Real>(decimal, scale);
+    }
+
+    // Split decimal into whole and fractional parts to avoid precision loss
+    BasicDecimal128 whole_decimal, fraction_decimal;
+    decimal.GetWholeAndFraction(scale, &whole_decimal, &fraction_decimal);
+
+    Real whole = ToRealPositiveNoSplit<Real>(whole_decimal, 0);
+    Real fraction = ToRealPositiveNoSplit<Real>(fraction_decimal, scale);
+
+    return whole + fraction;
+  }
 };
 
 }  // namespace
@@ -967,7 +994,7 @@ struct Decimal256RealConversion
   }
 
   template <typename Real>
-  static Real ToRealPositive(const Decimal256& decimal, int32_t scale) {
+  static Real ToRealPositiveNoSplit(const Decimal256& decimal, int32_t scale) {
     DCHECK_GE(decimal, 0);
     Real x = 0;
     const auto parts_le = bit_util::little_endian::Make(decimal.native_endian_array());
@@ -978,6 +1005,33 @@ struct Decimal256RealConversion
     x *= LargePowerOfTen<Real>(-scale);
     return x;
   }
+
+  /// An appoximate conversion from Decimal256 to Real that guarantees:
+  /// 1. If the decimal is an integer, the conversion is exact.
+  /// 2. If the number of fractional digits is <= RealTraits<Real>::kMantissaDigits (e.g.
+  ///    8 for float and 16 for double), the conversion is within 1 ULP of the exact
+  ///    value.
+  /// 3. Otherwise, the conversion is within 2^(-RealTraits<Real>::kMantissaDigits+1)
+  ///    (e.g. 2^-23 for float and 2^-52 for double) of the exact value.
+  /// Here "exact value" means the closest representable value by Real.
+  template <typename Real>
+  static Real ToRealPositive(const Decimal256& decimal, int32_t scale) {
+    const auto parts_le = decimal.little_endian_array();
+    if (scale <= 0 || (parts_le[3] == 0 && parts_le[2] == 0 && parts_le[1] == 0 &&
+                       parts_le[0] < RealTraits<Real>::kMaxPreciseInteger)) {
+      // No need to split the decimal if it is already an integer (scale <= 0) or if it
+      // can be precisely represented by Real
+      return ToRealPositiveNoSplit<Real>(decimal, scale);
+    }
+
+    // Split the decimal into whole and fractional parts to avoid precision loss
+    BasicDecimal256 whole_decimal, fraction_decimal;
+    decimal.GetWholeAndFraction(scale, &whole_decimal, &fraction_decimal);
+
+    Real whole = ToRealPositiveNoSplit<Real>(whole_decimal, 0);
+    Real fraction = ToRealPositiveNoSplit<Real>(fraction_decimal, scale);
+    return whole + fraction;
+  }
 };
 
 }  // namespace
diff --git a/cpp/src/arrow/util/decimal_internal.h b/cpp/src/arrow/util/decimal_internal.h
index 041aac4ef860d..51a7229ab6678 100644
--- a/cpp/src/arrow/util/decimal_internal.h
+++ b/cpp/src/arrow/util/decimal_internal.h
@@ -451,6 +451,8 @@ struct RealTraits<float> {
   static constexpr int kMantissaBits = 24;
   // ceil(log10(2 ^ kMantissaBits))
   static constexpr int kMantissaDigits = 8;
+  // Integers between zero and kMaxPreciseInteger can be precisely represented
+  static constexpr uint64_t kMaxPreciseInteger = (1ULL << kMantissaBits) - 1;
 };
 
 template <>
@@ -464,6 +466,8 @@ struct RealTraits<double> {
   static constexpr int kMantissaBits = 53;
   // ceil(log10(2 ^ kMantissaBits))
   static constexpr int kMantissaDigits = 16;
+  // Integers between zero and kMaxPreciseInteger can be precisely represented
+  static constexpr uint64_t kMaxPreciseInteger = (1ULL << kMantissaBits) - 1;
 };
 
 template <typename DecimalType>
diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index 1401750ce76d6..6376a9545a0f8 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -1050,6 +1050,24 @@ void CheckDecimalToReal(const std::string& decimal_value, int32_t scale, Real ex
       << "Decimal value: " << decimal_value << " Scale: " << scale;
 }
 
+template <typename Decimal, typename Real>
+void CheckDecimalToRealWithinOneULP(const std::string& decimal_value, int32_t scale,
+                                    Real expected) {
+  Decimal dec(decimal_value);
+  auto result = dec.template ToReal<Real>(scale);
+  ASSERT_TRUE(result == expected || result == std::nextafter(expected, expected + 1) ||
+              result == std::nextafter(expected, expected - 1))
+      << "Decimal value: " << decimal_value << " Scale: " << scale;
+}
+
+template <typename Decimal, typename Real>
+void CheckDecimalToRealWithinEpsilon(const std::string& decimal_value, int32_t scale,
+                                     Real epsilon, Real expected) {
+  Decimal dec(decimal_value);
+  ASSERT_TRUE(std::abs(dec.template ToReal<Real>(scale) - expected) <= epsilon)
+      << "Decimal value: " << decimal_value << " Scale: " << scale;
+}
+
 template <typename Decimal>
 void CheckDecimalToRealApprox(const std::string& decimal_value, int32_t scale,
                               float expected) {
@@ -1110,59 +1128,79 @@ class TestDecimalToReal : public ::testing::Test {
       }
     }
   }
+};
 
-  // Test precision of conversions to float values
-  void TestPrecision() {
-    // 2**63 + 2**40 (exactly representable in a float's 24 bits of precision)
-    CheckDecimalToReal<Decimal, Real>("9223373136366403584", 0, 9.223373e+18f);
-    CheckDecimalToReal<Decimal, Real>("-9223373136366403584", 0, -9.223373e+18f);
-    // 2**64 + 2**41 (exactly representable in a float)
-    CheckDecimalToReal<Decimal, Real>("18446746272732807168", 0, 1.8446746e+19f);
-    CheckDecimalToReal<Decimal, Real>("-18446746272732807168", 0, -1.8446746e+19f);
-  }
+TYPED_TEST_SUITE(TestDecimalToReal, RealTypes);
+TYPED_TEST(TestDecimalToReal, TestSuccess) { this->TestSuccess(); }
+
+// Custom test for Decimal::ToReal<float>
+template <typename DecimalType>
+class TestDecimalToRealFloat : public TestDecimalToReal<std::pair<DecimalType, float>> {};
+TYPED_TEST_SUITE(TestDecimalToRealFloat, DecimalTypes);
 
-  // Test conversions with a range of scales
-  void TestLargeValues(int32_t max_scale) {
-    // Note that exact comparisons would succeed on some platforms (Linux, macOS).
-    // Nevertheless, power-of-ten factors are not all exactly representable
-    // in binary floating point.
-    for (int32_t scale = -max_scale; scale <= max_scale; scale++) {
+TYPED_TEST(TestDecimalToRealFloat, LargeValues) {
+  auto max_scale = TypeParam::kMaxScale;
+  // Note that exact comparisons would succeed on some platforms (Linux, macOS).
+  // Nevertheless, power-of-ten factors are not all exactly representable
+  // in binary floating point.
+  for (int32_t scale = -max_scale; scale <= max_scale; scale++) {
 #ifdef _WIN32
-      // MSVC gives pow(10.f, -45.f) == 0 even though 1e-45f is nonzero
-      if (scale == 45) continue;
+    // MSVC gives pow(10.f, -45.f) == 0 even though 1e-45f is nonzero
+    if (scale == 45) continue;
 #endif
-      CheckDecimalToRealApprox<Decimal>("1", scale, Pow10(-scale));
-    }
-    for (int32_t scale = -max_scale; scale <= max_scale - 2; scale++) {
+    CheckDecimalToRealApprox<TypeParam>("1", scale, this->Pow10(-scale));
+  }
+  for (int32_t scale = -max_scale; scale <= max_scale - 2; scale++) {
 #ifdef _WIN32
-      // MSVC gives pow(10.f, -45.f) == 0 even though 1e-45f is nonzero
-      if (scale == 45) continue;
+    // MSVC gives pow(10.f, -45.f) == 0 even though 1e-45f is nonzero
+    if (scale == 45) continue;
 #endif
-      const Real factor = static_cast<Real>(123);
-      CheckDecimalToRealApprox<Decimal>("123", scale, factor * Pow10(-scale));
-    }
+    const auto factor = static_cast<float>(123);
+    CheckDecimalToRealApprox<TypeParam>("123", scale, factor * this->Pow10(-scale));
   }
-};
-
-TYPED_TEST_SUITE(TestDecimalToReal, RealTypes);
-
-TYPED_TEST(TestDecimalToReal, TestSuccess) { this->TestSuccess(); }
+}
 
-// Custom test for Decimal128::ToReal<float>
-class TestDecimal128ToRealFloat : public TestDecimalToReal<std::pair<Decimal128, float>> {
-};
-TEST_F(TestDecimal128ToRealFloat, LargeValues) { TestLargeValues(/*max_scale=*/38); }
-TEST_F(TestDecimal128ToRealFloat, Precision) { this->TestPrecision(); }
-// Custom test for Decimal256::ToReal<float>
-class TestDecimal256ToRealFloat : public TestDecimalToReal<std::pair<Decimal256, float>> {
-};
-TEST_F(TestDecimal256ToRealFloat, LargeValues) { TestLargeValues(/*max_scale=*/76); }
-TEST_F(TestDecimal256ToRealFloat, Precision) { this->TestPrecision(); }
+TYPED_TEST(TestDecimalToRealFloat, Precision) {
+  // 2**63 + 2**40 (exactly representable in a float's 24 bits of precision)
+  CheckDecimalToReal<TypeParam, float>("9223373136366403584", 0, 9.223373e+18f);
+  CheckDecimalToReal<TypeParam, float>("-9223373136366403584", 0, -9.223373e+18f);
+  // 2**64 + 2**41 (exactly representable in a float)
+  CheckDecimalToReal<TypeParam, float>("18446746272732807168", 0, 1.8446746e+19f);
+  CheckDecimalToReal<TypeParam, float>("-18446746272732807168", 0, -1.8446746e+19f);
+
+  // Integers are always exact
+  auto scale = TypeParam::kMaxScale - 1;
+  std::string seven = "7.";
+  seven.append(scale, '0');  // pad with trailing zeros
+  CheckDecimalToReal<TypeParam, float>(seven, scale, 7.0f);
+  CheckDecimalToReal<TypeParam, float>("-" + seven, scale, -7.0f);
+
+  CheckDecimalToReal<TypeParam, float>("99999999999999999999.0000000000000000", 16,
+                                       99999999999999999999.0f);
+  CheckDecimalToReal<TypeParam, float>("-99999999999999999999.0000000000000000", 16,
+                                       -99999999999999999999.0f);
+
+  // Small fractions are within one ULP
+  CheckDecimalToRealWithinOneULP<TypeParam, float>("9999999.9", 1, 9999999.9f);
+  CheckDecimalToRealWithinOneULP<TypeParam, float>("-9999999.9", 1, -9999999.9f);
+  CheckDecimalToRealWithinOneULP<TypeParam, float>("9999999.999999", 6, 9999999.999999f);
+  CheckDecimalToRealWithinOneULP<TypeParam, float>("-9999999.999999", 6,
+                                                   -9999999.999999f);
+
+  // Large fractions are within 2^-23
+  constexpr float epsilon = 1.1920928955078125e-07f;  // 2^-23
+  CheckDecimalToRealWithinEpsilon<TypeParam, float>(
+      "112334829348925.99070703983306884765625", 23, epsilon,
+      112334829348925.99070703983306884765625f);
+  CheckDecimalToRealWithinEpsilon<TypeParam, float>(
+      "1.987748987892758765582589910934859345", 36, epsilon,
+      1.987748987892758765582589910934859345f);
+}
 
 // ToReal<double> tests are disabled on MinGW because of precision issues in results
 #ifndef __MINGW32__
 
-// Custom test for Decimal128::ToReal<double>
+// Custom test for Decimal::ToReal<double>
 template <typename DecimalType>
 class TestDecimalToRealDouble : public TestDecimalToReal<std::pair<DecimalType, double>> {
 };
@@ -1209,6 +1247,34 @@ TYPED_TEST(TestDecimalToRealDouble, Precision) {
                                         9.999999999999998e+47);
   CheckDecimalToReal<TypeParam, double>("-99999999999999978859343891977453174784", -10,
                                         -9.999999999999998e+47);
+  // Integers are always exact
+  auto scale = TypeParam::kMaxScale - 1;
+  std::string seven = "7.";
+  seven.append(scale, '0');
+  CheckDecimalToReal<TypeParam, double>(seven, scale, 7.0);
+  CheckDecimalToReal<TypeParam, double>("-" + seven, scale, -7.0);
+
+  CheckDecimalToReal<TypeParam, double>("99999999999999999999.0000000000000000", 16,
+                                        99999999999999999999.0);
+  CheckDecimalToReal<TypeParam, double>("-99999999999999999999.0000000000000000", 16,
+                                        -99999999999999999999.0);
+
+  // Small fractions are within one ULP
+  CheckDecimalToRealWithinOneULP<TypeParam, double>("9999999.9", 1, 9999999.9);
+  CheckDecimalToRealWithinOneULP<TypeParam, double>("-9999999.9", 1, -9999999.9);
+  CheckDecimalToRealWithinOneULP<TypeParam, double>("9999999.999999999999999", 15,
+                                                    9999999.999999999999999);
+  CheckDecimalToRealWithinOneULP<TypeParam, double>("-9999999.999999999999999", 15,
+                                                    -9999999.999999999999999);
+
+  // Large fractions are within 2^-52
+  constexpr double epsilon = 2.220446049250313080847263336181640625e-16;  // 2^-52
+  CheckDecimalToRealWithinEpsilon<TypeParam, double>(
+      "112334829348925.99070703983306884765625", 23, epsilon,
+      112334829348925.99070703983306884765625);
+  CheckDecimalToRealWithinEpsilon<TypeParam, double>(
+      "1.987748987892758765582589910934859345", 36, epsilon,
+      1.987748987892758765582589910934859345);
 }
 
 #endif  // __MINGW32__

From de8df23a8cd9737b4df5bb1b68fc12a54f252d0d Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Tue, 18 Jul 2023 16:41:55 +0200
Subject: [PATCH 002/749] GH-36744: [Python][Packaging] Add upper pin for
 cython<3 to pyarrow build dependencies (#36743)

### Rationale for this change

Although we already fixed some cython 3 build issues (https://github.com/apache/arrow/pull/34726), some new have been introduced, which we are seeing now cython 3 is released (https://github.com/apache/arrow/issues/36730)

Adding an upper pin (<3) for the release, so we have more time (the full 14.0 release cycle) to iron out issues.
* Closes: #36744

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .github/workflows/dev.yml           | 2 +-
 ci/conda_env_python.txt             | 2 +-
 python/pyproject.toml               | 2 +-
 python/requirements-build.txt       | 2 +-
 python/requirements-wheel-build.txt | 2 +-
 python/setup.py                     | 7 ++++---
 6 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index 7c2437f6edfb5..119d11d9a399a 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -103,7 +103,7 @@ jobs:
         shell: bash
         run: |
           gem install test-unit
-          pip install cython setuptools six pytest jira
+          pip install "cython<3" setuptools six pytest jira
       - name: Run Release Test
         env:
           ARROW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/ci/conda_env_python.txt b/ci/conda_env_python.txt
index 04f985c94bb2c..4ae5c3614a1dc 100644
--- a/ci/conda_env_python.txt
+++ b/ci/conda_env_python.txt
@@ -18,7 +18,7 @@
 # don't add pandas here, because it is not a mandatory test dependency
 boto3  # not a direct dependency of s3fs, but needed for our s3fs fixture
 cffi
-cython
+cython<3
 cloudpickle
 fsspec
 hypothesis
diff --git a/python/pyproject.toml b/python/pyproject.toml
index fe8c938a9ce4f..7e61304585809 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -17,7 +17,7 @@
 
 [build-system]
 requires = [
-    "cython >= 0.29.31",
+    "cython >= 0.29.31,<3",
     "oldest-supported-numpy>=0.14",
     "setuptools_scm",
     "setuptools >= 40.1.0",
diff --git a/python/requirements-build.txt b/python/requirements-build.txt
index 507e9081373e2..6378d1b94e1bb 100644
--- a/python/requirements-build.txt
+++ b/python/requirements-build.txt
@@ -1,4 +1,4 @@
-cython>=0.29.31
+cython>=0.29.31,<3
 oldest-supported-numpy>=0.14
 setuptools_scm
 setuptools>=38.6.0
diff --git a/python/requirements-wheel-build.txt b/python/requirements-wheel-build.txt
index 6043d2ffb2c6e..e4f5243fbc2fe 100644
--- a/python/requirements-wheel-build.txt
+++ b/python/requirements-wheel-build.txt
@@ -1,4 +1,4 @@
-cython>=0.29.31
+cython>=0.29.31,<3
 oldest-supported-numpy>=0.14
 setuptools_scm
 setuptools>=58
diff --git a/python/setup.py b/python/setup.py
index f06cb5a627562..dc529679c7f90 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -40,8 +40,9 @@
 # Check if we're running 64-bit Python
 is_64_bit = sys.maxsize > 2**32
 
-if Cython.__version__ < '0.29.31':
-    raise Exception('Please upgrade to Cython 0.29.31 or newer')
+if Cython.__version__ < '0.29.31' or Cython.__version__ >= '3.0':
+    raise Exception(
+        'Please update your Cython version. Supported Cython >= 0.29.31, < 3.0')
 
 setup_dir = os.path.abspath(os.path.dirname(__file__))
 
@@ -491,7 +492,7 @@ def has_ext_modules(foo):
                                  'pyarrow/_generated_version.py'),
         'version_scheme': guess_next_dev_version
     },
-    setup_requires=['setuptools_scm', 'cython >= 0.29.31'] + setup_requires,
+    setup_requires=['setuptools_scm', 'cython >= 0.29.31,<3'] + setup_requires,
     install_requires=install_requires,
     tests_require=['pytest', 'pandas', 'hypothesis'],
     python_requires='>=3.8',

From f9904063b163c4ad44bef61e84a1e4a90b600d34 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 19 Jul 2023 00:32:34 +0800
Subject: [PATCH 003/749] GH-35934:[C++][Parquet] PageIndex Read benchmark
 (#36702)

### Rationale for this change

Add benchmark for read page index

### What changes are included in this PR?

Just a benchmark in `cpp/src/parquet/bloom_filter_benchmark.cc`

### Are these changes tested?

No

### Are there any user-facing changes?

No

* Closes: #35934

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/dataset/dataset.h               |   2 +-
 cpp/src/parquet/CMakeLists.txt                |   5 +-
 cpp/src/parquet/benchmark_util.cc             | 126 ++++++++++++++++++
 cpp/src/parquet/benchmark_util.h              |  47 +++++++
 cpp/src/parquet/bloom_filter_benchmark.cc     |  69 ++--------
 cpp/src/parquet/level_conversion_benchmark.cc |   2 +-
 cpp/src/parquet/page_index_benchmark.cc       | 107 +++++++++++++++
 cpp/src/parquet/test_util.h                   |   2 +-
 8 files changed, 296 insertions(+), 64 deletions(-)
 create mode 100644 cpp/src/parquet/benchmark_util.cc
 create mode 100644 cpp/src/parquet/benchmark_util.h
 create mode 100644 cpp/src/parquet/page_index_benchmark.cc

diff --git a/cpp/src/arrow/dataset/dataset.h b/cpp/src/arrow/dataset/dataset.h
index 1db230b16e9c2..39936fbd7b5b2 100644
--- a/cpp/src/arrow/dataset/dataset.h
+++ b/cpp/src/arrow/dataset/dataset.h
@@ -82,7 +82,7 @@ class ARROW_DS_EXPORT FragmentSelection {
 
 /// \brief Instructions for scanning a particular fragment
 ///
-/// The fragment scan request is dervied from ScanV2Options.  The main
+/// The fragment scan request is derived from ScanV2Options.  The main
 /// difference is that the scan options are based on the dataset schema
 /// while the fragment request is based on the fragment schema.
 struct ARROW_DS_EXPORT FragmentScanRequest {
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index e6aad7cee2a3e..eb2e2d8fed88f 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -401,11 +401,14 @@ endif()
 add_parquet_test(file_deserialize_test SOURCES file_deserialize_test.cc test_util.cc)
 add_parquet_test(schema_test)
 
-add_parquet_benchmark(bloom_filter_benchmark)
+add_parquet_benchmark(bloom_filter_benchmark SOURCES bloom_filter_benchmark.cc
+                      benchmark_util.cc)
 add_parquet_benchmark(column_reader_benchmark)
 add_parquet_benchmark(column_io_benchmark)
 add_parquet_benchmark(encoding_benchmark)
 add_parquet_benchmark(level_conversion_benchmark)
+add_parquet_benchmark(page_index_benchmark SOURCES page_index_benchmark.cc
+                      benchmark_util.cc)
 add_parquet_benchmark(arrow/reader_writer_benchmark PREFIX "parquet-arrow")
 
 if(ARROW_WITH_BROTLI)
diff --git a/cpp/src/parquet/benchmark_util.cc b/cpp/src/parquet/benchmark_util.cc
new file mode 100644
index 0000000000000..6220336e1c39e
--- /dev/null
+++ b/cpp/src/parquet/benchmark_util.cc
@@ -0,0 +1,126 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "parquet/benchmark_util.h"
+
+#include <random>
+
+namespace parquet::benchmark {
+
+namespace {
+
+void GenerateRandomString(uint32_t length, uint32_t seed, std::vector<uint8_t>* heap) {
+  // Character set used to generate random string
+  const std::string charset =
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+  std::default_random_engine gen(seed);
+  std::uniform_int_distribution<uint32_t> dist(0, static_cast<int>(charset.size() - 1));
+
+  for (uint32_t i = 0; i < length; i++) {
+    heap->emplace_back(charset[dist(gen)]);
+  }
+}
+
+template <typename T>
+void GenerateBenchmarkDataIntegerImpl(uint32_t size, uint32_t seed, T* data,
+                                      std::vector<uint8_t>* heap, uint32_t) {
+  static_assert(std::is_integral_v<T>);
+  heap->clear();
+  std::default_random_engine gen(seed);
+  std::uniform_int_distribution<T> d(std::numeric_limits<T>::min(),
+                                     std::numeric_limits<T>::max());
+  for (uint32_t i = 0; i < size; ++i) {
+    data[i] = d(gen);
+  }
+}
+
+template <typename T>
+void GenerateBenchmarkDataFloatImpl(uint32_t size, uint32_t seed, T* data,
+                                    std::vector<uint8_t>* heap, uint32_t) {
+  static_assert(std::is_floating_point_v<T>);
+  heap->clear();
+  std::default_random_engine gen(seed);
+  std::uniform_real_distribution<T> d(std::numeric_limits<T>::lowest(),
+                                      std::numeric_limits<T>::max());
+  for (uint32_t i = 0; i < size; ++i) {
+    data[i] = d(gen);
+  }
+}
+
+}  // namespace
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, int32_t* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  GenerateBenchmarkDataIntegerImpl<int32_t>(size, seed, data, heap, data_string_length);
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, int64_t* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  GenerateBenchmarkDataIntegerImpl<int64_t>(size, seed, data, heap, data_string_length);
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, float* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  GenerateBenchmarkDataFloatImpl<float>(size, seed, data, heap, data_string_length);
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, double* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  GenerateBenchmarkDataFloatImpl<double>(size, seed, data, heap, data_string_length);
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, Int96* data,
+                           std::vector<uint8_t>* heap, uint32_t) {
+  heap->clear();
+  std::default_random_engine gen(seed);
+  std::uniform_int_distribution<int> d(std::numeric_limits<int>::min(),
+                                       std::numeric_limits<int>::max());
+  for (uint32_t i = 0; i < size; ++i) {
+    data[i].value[0] = d(gen);
+    data[i].value[1] = d(gen);
+    data[i].value[2] = d(gen);
+  }
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, FLBA* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  heap->clear();
+  GenerateRandomString(data_string_length * size, seed, heap);
+  for (uint32_t i = 0; i < size; ++i) {
+    data[i].ptr = heap->data() + i * data_string_length;
+  }
+}
+
+template <>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, ByteArray* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length) {
+  heap->clear();
+  GenerateRandomString(data_string_length * size, seed, heap);
+  for (uint32_t i = 0; i < size; ++i) {
+    data[i].ptr = heap->data() + i * data_string_length;
+    data[i].len = data_string_length;
+  }
+}
+
+}  // namespace parquet::benchmark
diff --git a/cpp/src/parquet/benchmark_util.h b/cpp/src/parquet/benchmark_util.h
new file mode 100644
index 0000000000000..7996f7f85e898
--- /dev/null
+++ b/cpp/src/parquet/benchmark_util.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <random>
+#include <string>
+#include <vector>
+
+#include "parquet/types.h"
+
+namespace parquet::benchmark {
+
+template <typename T>
+void GenerateBenchmarkData(uint32_t size, uint32_t seed, T* data,
+                           std::vector<uint8_t>* heap, uint32_t data_string_length);
+
+#define _GENERATE_BENCHMARK_DATA_DECL(KLASS)                            \
+  template <>                                                           \
+  void GenerateBenchmarkData(uint32_t size, uint32_t seed, KLASS* data, \
+                             std::vector<uint8_t>* heap, uint32_t data_string_length);
+
+_GENERATE_BENCHMARK_DATA_DECL(int32_t)
+_GENERATE_BENCHMARK_DATA_DECL(int64_t)
+_GENERATE_BENCHMARK_DATA_DECL(float)
+_GENERATE_BENCHMARK_DATA_DECL(double)
+_GENERATE_BENCHMARK_DATA_DECL(ByteArray)
+_GENERATE_BENCHMARK_DATA_DECL(FLBA)
+_GENERATE_BENCHMARK_DATA_DECL(Int96)
+
+#undef _GENERATE_BENCHMARK_DATA_DECL
+
+}  // namespace parquet::benchmark
diff --git a/cpp/src/parquet/bloom_filter_benchmark.cc b/cpp/src/parquet/bloom_filter_benchmark.cc
index fa934b1d5290a..13c731d975b2c 100644
--- a/cpp/src/parquet/bloom_filter_benchmark.cc
+++ b/cpp/src/parquet/bloom_filter_benchmark.cc
@@ -18,13 +18,13 @@
 #include "benchmark/benchmark.h"
 
 #include "arrow/util/logging.h"
+#include "parquet/benchmark_util.h"
 #include "parquet/bloom_filter.h"
 #include "parquet/properties.h"
 
 #include <random>
 
-namespace parquet {
-namespace benchmark {
+namespace parquet::benchmark {
 
 constexpr static uint32_t kNumBloomFilterInserts = 16 * 1024;
 // The sample string length for FLBA and ByteArray benchmarks
@@ -40,63 +40,11 @@ std::unique_ptr<BloomFilter> CreateBloomFilter(uint32_t num_values) {
   return bloom_filter;
 }
 
-void GenerateRandomString(uint32_t length, uint32_t seed, std::vector<uint8_t>* heap) {
-  // Character set used to generate random string
-  const std::string charset =
-      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-
-  std::default_random_engine gen(seed);
-  std::uniform_int_distribution<uint32_t> dist(0, static_cast<int>(charset.size() - 1));
-
-  for (uint32_t i = 0; i < length; i++) {
-    heap->push_back(charset[dist(gen)]);
-  }
-}
-
-template <typename T>
-void GenerateBenchmarkData(uint32_t size, uint32_t seed, T* data,
-                           [[maybe_unused]] std::vector<uint8_t>* heap = nullptr) {
-  if constexpr (std::is_integral_v<T>) {
-    std::default_random_engine gen(seed);
-    std::uniform_int_distribution<T> d(std::numeric_limits<T>::min(),
-                                       std::numeric_limits<T>::max());
-    for (uint32_t i = 0; i < size; ++i) {
-      data[i] = d(gen);
-    }
-  } else if constexpr (std::is_floating_point_v<T>) {
-    std::default_random_engine gen(seed);
-    std::uniform_real_distribution<T> d(std::numeric_limits<T>::lowest(),
-                                        std::numeric_limits<T>::max());
-    for (uint32_t i = 0; i < size; ++i) {
-      data[i] = d(gen);
-    }
-  } else if constexpr (std::is_same_v<FLBA, T>) {
-    GenerateRandomString(kDataStringLength * size, seed, heap);
-    for (uint32_t i = 0; i < size; ++i) {
-      data[i].ptr = heap->data() + i * kDataStringLength;
-    }
-  } else if constexpr (std::is_same_v<ByteArray, T>) {
-    GenerateRandomString(kDataStringLength * size, seed, heap);
-    for (uint32_t i = 0; i < size; ++i) {
-      data[i].ptr = heap->data() + i * kDataStringLength;
-      data[i].len = kDataStringLength;
-    }
-  } else if constexpr (std::is_same_v<Int96, T>) {
-    std::default_random_engine gen(seed);
-    std::uniform_int_distribution<int> d(std::numeric_limits<int>::min(),
-                                         std::numeric_limits<int>::max());
-    for (uint32_t i = 0; i < size; ++i) {
-      data[i].value[0] = d(gen);
-      data[i].value[1] = d(gen);
-      data[i].value[2] = d(gen);
-    }
-  }
-}
-
 std::vector<uint64_t> GetHashValues(uint32_t num_values, uint32_t seed) {
   // Generate sample data values
   std::vector<int64_t> values(num_values);
-  GenerateBenchmarkData(num_values, seed, values.data());
+  std::vector<uint8_t> heap;
+  GenerateBenchmarkData(num_values, seed, values.data(), &heap, kDataStringLength);
   // Create a temp filter to compute hash values
   auto filter = CreateBloomFilter(/*num_values=*/8);
   std::vector<uint64_t> hashes(num_values);
@@ -109,7 +57,8 @@ static void BM_ComputeHash(::benchmark::State& state) {
   using T = typename DType::c_type;
   std::vector<T> values(kNumBloomFilterInserts);
   std::vector<uint8_t> heap;
-  GenerateBenchmarkData(kNumBloomFilterInserts, /*seed=*/0, values.data(), &heap);
+  GenerateBenchmarkData(kNumBloomFilterInserts, /*seed=*/0, values.data(), &heap,
+                        kDataStringLength);
   auto filter = CreateBloomFilter(kNumBloomFilterInserts);
   for (auto _ : state) {
     uint64_t total = 0;
@@ -136,7 +85,8 @@ static void BM_BatchComputeHash(::benchmark::State& state) {
   using T = typename DType::c_type;
   std::vector<T> values(kNumBloomFilterInserts);
   std::vector<uint8_t> heap;
-  GenerateBenchmarkData(kNumBloomFilterInserts, /*seed=*/0, values.data(), &heap);
+  GenerateBenchmarkData(kNumBloomFilterInserts, /*seed=*/0, values.data(), &heap,
+                        kDataStringLength);
   auto filter = CreateBloomFilter(kNumBloomFilterInserts);
   std::vector<uint64_t> hashes(kNumBloomFilterInserts);
   for (auto _ : state) {
@@ -231,5 +181,4 @@ BENCHMARK(BM_BatchInsertHash);
 BENCHMARK(BM_FindExistingHash);
 BENCHMARK(BM_FindNonExistingHash);
 
-}  // namespace benchmark
-}  // namespace parquet
+}  // namespace parquet::benchmark
diff --git a/cpp/src/parquet/level_conversion_benchmark.cc b/cpp/src/parquet/level_conversion_benchmark.cc
index f9e91c4820f68..f3a4f8095e3a1 100644
--- a/cpp/src/parquet/level_conversion_benchmark.cc
+++ b/cpp/src/parquet/level_conversion_benchmark.cc
@@ -29,7 +29,7 @@ constexpr int16_t kMissingDefLevel = 0;
 // Definition Level indicating the values has an entry in the leaf element.
 constexpr int16_t kPresentDefLevel = 2;
 
-// A repition level that indicates a repeated element.
+// A repetition level that indicates a repeated element.
 constexpr int16_t kHasRepeatedElements = 1;
 
 std::vector<uint8_t> RunDefinitionLevelsToBitmap(const std::vector<int16_t>& def_levels,
diff --git a/cpp/src/parquet/page_index_benchmark.cc b/cpp/src/parquet/page_index_benchmark.cc
new file mode 100644
index 0000000000000..5631034105056
--- /dev/null
+++ b/cpp/src/parquet/page_index_benchmark.cc
@@ -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.
+
+#include <cstdint>
+#include <vector>
+
+#include "benchmark/benchmark.h"
+
+#include "parquet/benchmark_util.h"
+#include "parquet/metadata.h"
+#include "parquet/page_index.h"
+#include "parquet/schema.h"
+#include "parquet/test_util.h"
+#include "parquet/thrift_internal.h"
+
+namespace parquet::benchmark {
+
+void PageIndexSetArgs(::benchmark::internal::Benchmark* bench) {
+  bench->ArgNames({"num_pages"});
+  bench->Range(8, 1024);
+}
+
+void BM_ReadOffsetIndex(::benchmark::State& state) {
+  auto builder = OffsetIndexBuilder::Make();
+  const int num_pages = static_cast<int>(state.range(0));
+  constexpr int64_t page_size = 1024;
+  constexpr int64_t first_row_index = 10000;
+  for (int i = 0; i < num_pages; ++i) {
+    builder->AddPage(page_size * i, page_size, first_row_index * i);
+  }
+  constexpr int64_t final_position = 4096;
+  builder->Finish(final_position);
+  auto sink = CreateOutputStream();
+  builder->WriteTo(sink.get());
+  auto buffer = sink->Finish().ValueOrDie();
+  ReaderProperties properties;
+  for (auto _ : state) {
+    auto offset_index = OffsetIndex::Make(
+        buffer->data() + 0, static_cast<uint32_t>(buffer->size()), properties);
+    ::benchmark::DoNotOptimize(offset_index);
+  }
+  state.SetBytesProcessed(state.iterations() * buffer->size());
+  state.SetItemsProcessed(state.iterations() * num_pages);
+}
+
+BENCHMARK(BM_ReadOffsetIndex)->Apply(PageIndexSetArgs);
+
+// The sample string length for FLBA and ByteArray benchmarks
+constexpr static uint32_t kDataStringLength = 8;
+
+template <typename DType>
+void BM_ReadColumnIndex(::benchmark::State& state) {
+  schema::NodePtr type = ::parquet::schema::PrimitiveNode::Make(
+      "b", Repetition::OPTIONAL, DType::type_num, ConvertedType::NONE, 8);
+  auto descr_ptr =
+      std::make_unique<ColumnDescriptor>(type, /*def_level=*/1, /*rep_level=*/0);
+  auto descr = descr_ptr.get();
+
+  const int num_pages = static_cast<int>(state.range(0));
+  auto builder = ColumnIndexBuilder::Make(descr);
+
+  const size_t values_per_page = 100;
+  for (int i = 0; i < num_pages; ++i) {
+    auto stats = MakeStatistics<DType>(descr);
+    std::vector<uint8_t> heap;
+    std::vector<typename DType::c_type> values;
+    values.resize(values_per_page);
+    GenerateBenchmarkData(values_per_page, /*seed=*/0, values.data(), &heap,
+                          kDataStringLength);
+    stats->Update(values.data(), values_per_page, /*null_count=*/0);
+    builder->AddPage(stats->Encode());
+  }
+
+  builder->Finish();
+  auto sink = CreateOutputStream();
+  builder->WriteTo(sink.get());
+  auto buffer = sink->Finish().ValueOrDie();
+  ReaderProperties properties;
+  for (auto _ : state) {
+    auto column_index = ColumnIndex::Make(*descr, buffer->data() + 0,
+                                          static_cast<int>(buffer->size()), properties);
+    ::benchmark::DoNotOptimize(column_index);
+  }
+  state.SetBytesProcessed(state.iterations() * buffer->size());
+  state.SetItemsProcessed(state.iterations() * num_pages);
+}
+
+BENCHMARK_TEMPLATE(BM_ReadColumnIndex, Int64Type)->Apply(PageIndexSetArgs);
+BENCHMARK_TEMPLATE(BM_ReadColumnIndex, DoubleType)->Apply(PageIndexSetArgs);
+BENCHMARK_TEMPLATE(BM_ReadColumnIndex, FLBAType)->Apply(PageIndexSetArgs);
+BENCHMARK_TEMPLATE(BM_ReadColumnIndex, ByteArrayType)->Apply(PageIndexSetArgs);
+
+}  // namespace parquet::benchmark
diff --git a/cpp/src/parquet/test_util.h b/cpp/src/parquet/test_util.h
index dfb4b5d0fbf4a..b0aafa037ead1 100644
--- a/cpp/src/parquet/test_util.h
+++ b/cpp/src/parquet/test_util.h
@@ -556,7 +556,7 @@ static inline int MakePages(const ColumnDescriptor* d, int num_pages, int levels
   } else {
     num_values = num_levels;
   }
-  // Create repitition levels
+  // Create repetition levels
   if (max_rep_level > 0 && num_levels != 0) {
     rep_levels.resize(num_levels);
     // Using a different seed so that def_levels and rep_levels are different.

From e8214734459eff5cfc9e67e8b1fdef46f6d8c2ea Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 18 Jul 2023 13:07:26 -0400
Subject: [PATCH 004/749] GH-36734: [MATLAB] template
 arrow::matlab::proxy::NumericArray on ArrowType instead of CType (#36738)

### Rationale for this change

We decided to change the template parameter on `arrow::matlab::proxy::NumericArray` to `ArrowType` from `CType` to avoid writing duplicate code. If `proxy::NumericArray` is templated on `ArrowType`, we can use it to implement the proxies for `Date64Array`, `Date32Array`, `Time32Array`, `Time64Array`, and `TimestampArray`. This will help us avoid duplicating code.

### What changes are included in this PR?

1. Changed the template on `proxy::NumericArray` from `CType` to `ArrowType`
2. Re-implemented the C++ proxy object used for `TimestampArray` in terms of `proxy::NumericArray<arrow::TimestampType>`
3. Defined a template specialization for `NumericArray::make` when the template parameter is `arrow::TimestampType`
4. Defined a `proxy::Traits` `struct` that is templated on `ArrowType`. Specializations of  `Traits` define a`TypeProxy` typedef that can be used at compile-time to get the proxy class that is used to wrap an `ArrowType`.

### Are these changes tested?

Existing tests used.

### Are there any user-facing changes?

No.

* Closes: #36734

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/array/proxy/numeric_array.h  | 66 +++++++++++--
 .../matlab/array/proxy/timestamp_array.cc     | 99 -------------------
 .../matlab/array/proxy/timestamp_array.h      | 43 --------
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  | 23 +++--
 .../src/cpp/arrow/matlab/type/proxy/traits.h  | 90 +++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |  1 -
 6 files changed, 158 insertions(+), 164 deletions(-)
 delete mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/traits.h

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index c66c1d044fc12..f358e05db6318 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -24,7 +24,7 @@
 #include "arrow/type_traits.h"
 
 #include "arrow/matlab/array/proxy/array.h"
-#include "arrow/matlab/type/proxy/primitive_ctype.h"
+#include "arrow/matlab/type/proxy/traits.h"
 
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/bit/pack.h"
@@ -33,20 +33,23 @@
 
 #include "libmexclass/proxy/Proxy.h"
 
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/util/utf8.h"
+
 namespace arrow::matlab::array::proxy {
 
-template<typename CType>
+template<typename ArrowType>
 class NumericArray : public arrow::matlab::array::proxy::Array {
     public:
-        using ArrowType = typename arrow::CTypeTraits<CType>::ArrowType;
 
         NumericArray(const std::shared_ptr<arrow::NumericArray<ArrowType>> numeric_array)
             : arrow::matlab::array::proxy::Array{std::move(numeric_array)} {}
 
         static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {            
             using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+            using CType = typename arrow::TypeTraits<ArrowType>::CType;
             using NumericArray = arrow::NumericArray<ArrowType>;
-            using NumericArrayProxy = typename arrow::matlab::array::proxy::NumericArray<CType>;
+            using NumericArrayProxy = typename proxy::NumericArray<ArrowType>;
 
             ::matlab::data::StructArray opts = constructor_arguments[0];
 
@@ -68,10 +71,11 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
 
     protected:
         void toMATLAB(libmexclass::proxy::method::Context& context) override {
-            using ArrowArrayType = typename arrow::CTypeTraits<CType>::ArrayType;
+           using CType = typename arrow::TypeTraits<ArrowType>::CType;
+           using NumericArray = arrow::NumericArray<ArrowType>;
 
             const auto num_elements = static_cast<size_t>(array->length());
-            const auto numeric_array = std::static_pointer_cast<ArrowArrayType>(array);
+            const auto numeric_array = std::static_pointer_cast<NumericArray>(array);
             const CType* const data_begin = numeric_array->raw_values();
             const CType* const data_end = data_begin + num_elements;
 
@@ -83,11 +87,55 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
         }
 
         std::shared_ptr<type::proxy::Type> typeProxy() override {
-          using ArrowTypeProxy = type::proxy::PrimitiveCType<CType>;
+          using TypeProxy = typename type::proxy::Traits<ArrowType>::TypeProxy;
           auto type = std::static_pointer_cast<ArrowType>(array->type());
-          return std::make_shared<ArrowTypeProxy>(std::move(type));
+          return std::make_shared<TypeProxy>(std::move(type));
         }
-
 };
 
+     // Specialization of NumericArray::Make for arrow::TimestampType.
+    template <>
+    libmexclass::proxy::MakeResult NumericArray<arrow::TimestampType>::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+        using TimestampArray = arrow::TimestampArray;
+        using TimestampArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>;
+
+        mda::StructArray opts = constructor_arguments[0];
+
+        // Get the mxArray from constructor arguments
+        const mda::TypedArray<int64_t> timestamp_mda = opts[0]["MatlabArray"];
+        const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+        
+        const mda::TypedArray<mda::MATLABString> timezone_mda = opts[0]["TimeZone"];
+        const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
+
+        // extract the time zone string
+        const std::u16string& u16_timezone = timezone_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto timezone, 
+                               arrow::util::UTF16StringToUTF8(u16_timezone),
+                               error::UNICODE_CONVERSION_ERROR_ID);
+
+        // extract the time unit
+        const std::u16string& u16_timeunit = units_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto time_unit, 
+                               arrow::matlab::type::timeUnitFromString(u16_timeunit),
+                               error::UKNOWN_TIME_UNIT_ERROR_ID)
+
+        // create the timestamp_type
+        auto data_type = arrow::timestamp(time_unit, timezone);
+        auto array_length = static_cast<int64_t>(timestamp_mda.getNumberOfElements()); // cast size_t to int64_t
+
+        auto data_buffer = std::make_shared<MatlabBuffer>(timestamp_mda);
+
+        // Pack the validity bitmap values.
+        MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap, 
+                               bit::packValid(validity_bitmap_mda), 
+                               error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+        auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
+        auto timestamp_array = std::static_pointer_cast<TimestampArray>(arrow::MakeArray(array_data));
+        return std::make_shared<TimestampArrayProxy>(std::move(timestamp_array));
+    }
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
deleted file mode 100644
index b9bbf3d7e7942..0000000000000
--- a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
+++ /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.
-
-#include "arrow/matlab/array/proxy/timestamp_array.h"
-#include "arrow/matlab/type/proxy/timestamp_type.h"
-
-#include "arrow/matlab/error/error.h"
-#include "arrow/matlab/bit/pack.h"
-#include "arrow/matlab/bit/unpack.h"
-#include "arrow/matlab/buffer/matlab_buffer.h"
-
-#include "arrow/matlab/type/time_unit.h"
-#include "arrow/util/utf8.h"
-#include "arrow/type.h"
-
-namespace arrow::matlab::array::proxy {
-
-    TimestampArray::TimestampArray(std::shared_ptr<arrow::TimestampArray> array)
-        : arrow::matlab::array::proxy::Array{std::move(array)} {}
-
-    libmexclass::proxy::MakeResult TimestampArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
-        namespace mda = ::matlab::data;
-        using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
-        using TimestampArray = arrow::TimestampArray;
-        using TimestampArrayProxy = arrow::matlab::array::proxy::TimestampArray;
-
-        mda::StructArray opts = constructor_arguments[0];
-
-        // Get the mxArray from constructor arguments
-        const mda::TypedArray<int64_t> timestamp_mda = opts[0]["MatlabArray"];
-        const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
-        
-        const mda::TypedArray<mda::MATLABString> timezone_mda = opts[0]["TimeZone"];
-        const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
-
-        // extract the time zone string
-        const std::u16string& u16_timezone = timezone_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto timezone, 
-                               arrow::util::UTF16StringToUTF8(u16_timezone),
-                               error::UNICODE_CONVERSION_ERROR_ID);
-
-        // extract the time unit
-        const std::u16string& u16_timeunit = units_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto time_unit, 
-                               arrow::matlab::type::timeUnitFromString(u16_timeunit),
-                               error::UKNOWN_TIME_UNIT_ERROR_ID)
-
-        // create the timestamp_type
-        auto data_type = arrow::timestamp(time_unit, timezone);
-        auto array_length = static_cast<int64_t>(timestamp_mda.getNumberOfElements()); // cast size_t to int64_t
-
-        auto data_buffer = std::make_shared<MatlabBuffer>(timestamp_mda);
-
-        // Pack the validity bitmap values.
-        MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap, 
-                               bit::packValid(validity_bitmap_mda), 
-                               error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
-
-        auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
-        auto timestamp_array = std::static_pointer_cast<TimestampArray>(arrow::MakeArray(array_data));
-        return std::make_shared<TimestampArrayProxy>(std::move(timestamp_array));
-    }
-
-    void TimestampArray::toMATLAB(libmexclass::proxy::method::Context& context) {
-        namespace mda = ::matlab::data;
-
-        const auto num_elements = static_cast<size_t>(array->length());
-        const auto timestamp_array = std::static_pointer_cast<arrow::TimestampArray>(array);
-        const int64_t* const data_begin = timestamp_array->raw_values();
-        const int64_t* const data_end = data_begin + num_elements;
-
-        mda::ArrayFactory factory;
-
-        // Constructs a TypedArray from the raw values. Makes a copy.
-        mda::TypedArray<int64_t> result = factory.createArray({num_elements, 1}, data_begin, data_end);
-        context.outputs[0] = result;
-    }
-
-    std::shared_ptr<type::proxy::Type> TimestampArray::typeProxy() {
-        using TimestampProxyType = type::proxy::TimestampType;
-        auto type = std::static_pointer_cast<arrow::TimestampType>(array->type());
-        return std::make_shared<TimestampProxyType>(std::move(type));
-
-    }
-}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h
deleted file mode 100644
index a312a129a21c2..0000000000000
--- a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h
+++ /dev/null
@@ -1,43 +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.
-
-#pragma once
-
-#include "arrow/array.h"
-
-#include "arrow/matlab/array/proxy/array.h"
-
-#include "libmexclass/proxy/Proxy.h"
-
-#include "arrow/type_fwd.h"
-
-namespace arrow::matlab::array::proxy {
-
-class TimestampArray : public arrow::matlab::array::proxy::Array {
-    public:
-        TimestampArray(std::shared_ptr<arrow::TimestampArray> array);
-
-        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
-
-    protected:
-        void toMATLAB(libmexclass::proxy::method::Context& context) override;
-
-        std::shared_ptr<type::proxy::Type> typeProxy() override;
-
-};
-
-}
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 0f7751035a052..2fb3207e590c6 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -18,7 +18,6 @@
 #include "arrow/matlab/array/proxy/boolean_array.h"
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
-#include "arrow/matlab/array/proxy/timestamp_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
@@ -30,19 +29,19 @@
 namespace arrow::matlab::proxy {
 
 libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name, const FunctionArguments& constructor_arguments) {
-    REGISTER_PROXY(arrow.array.proxy.Float32Array  , arrow::matlab::array::proxy::NumericArray<float>);
-    REGISTER_PROXY(arrow.array.proxy.Float64Array  , arrow::matlab::array::proxy::NumericArray<double>);
-    REGISTER_PROXY(arrow.array.proxy.UInt8Array    , arrow::matlab::array::proxy::NumericArray<uint8_t>);
-    REGISTER_PROXY(arrow.array.proxy.UInt16Array   , arrow::matlab::array::proxy::NumericArray<uint16_t>);
-    REGISTER_PROXY(arrow.array.proxy.UInt32Array   , arrow::matlab::array::proxy::NumericArray<uint32_t>);
-    REGISTER_PROXY(arrow.array.proxy.UInt64Array   , arrow::matlab::array::proxy::NumericArray<uint64_t>);
-    REGISTER_PROXY(arrow.array.proxy.Int8Array     , arrow::matlab::array::proxy::NumericArray<int8_t>);
-    REGISTER_PROXY(arrow.array.proxy.Int16Array    , arrow::matlab::array::proxy::NumericArray<int16_t>);
-    REGISTER_PROXY(arrow.array.proxy.Int32Array    , arrow::matlab::array::proxy::NumericArray<int32_t>);
-    REGISTER_PROXY(arrow.array.proxy.Int64Array    , arrow::matlab::array::proxy::NumericArray<int64_t>);
+    REGISTER_PROXY(arrow.array.proxy.Float32Array  , arrow::matlab::array::proxy::NumericArray<arrow::FloatType>);
+    REGISTER_PROXY(arrow.array.proxy.Float64Array  , arrow::matlab::array::proxy::NumericArray<arrow::DoubleType>);
+    REGISTER_PROXY(arrow.array.proxy.UInt8Array    , arrow::matlab::array::proxy::NumericArray<arrow::UInt8Type>);
+    REGISTER_PROXY(arrow.array.proxy.UInt16Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt16Type>);
+    REGISTER_PROXY(arrow.array.proxy.UInt32Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt32Type>);
+    REGISTER_PROXY(arrow.array.proxy.UInt64Array   , arrow::matlab::array::proxy::NumericArray<arrow::UInt64Type>);
+    REGISTER_PROXY(arrow.array.proxy.Int8Array     , arrow::matlab::array::proxy::NumericArray<arrow::Int8Type>);
+    REGISTER_PROXY(arrow.array.proxy.Int16Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int16Type>);
+    REGISTER_PROXY(arrow.array.proxy.Int32Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int32Type>);
+    REGISTER_PROXY(arrow.array.proxy.Int64Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int64Type>);
     REGISTER_PROXY(arrow.array.proxy.BooleanArray  , arrow::matlab::array::proxy::BooleanArray);
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
-    REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::TimestampArray);
+    REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.type.proxy.Float32Type    , arrow::matlab::type::proxy::PrimitiveCType<float>);
     REGISTER_PROXY(arrow.type.proxy.Float64Type    , arrow::matlab::type::proxy::PrimitiveCType<double>);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
new file mode 100644
index 0000000000000..3d9a957a5e3dc
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/type_fwd.h"
+
+#include "arrow/matlab/type/proxy/primitive_ctype.h"
+#include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/string_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    template <typename ArrowType>
+    struct Traits;
+
+    template <>
+    struct Traits<arrow::FloatType> {
+        using TypeProxy = PrimitiveCType<float>;
+    };
+
+    template <>
+    struct Traits<arrow::DoubleType> {
+        using TypeProxy = PrimitiveCType<double>;
+    };
+
+    template <>
+    struct Traits<arrow::Int8Type> {
+        using TypeProxy = PrimitiveCType<int8_t>;
+    };
+
+    template <>
+    struct Traits<arrow::Int16Type> {
+        using TypeProxy = PrimitiveCType<int16_t>;
+    };
+
+    template <>
+    struct Traits<arrow::Int32Type> {
+        using TypeProxy = PrimitiveCType<int32_t>;
+    };
+
+    template <>
+    struct Traits<arrow::Int64Type> {
+        using TypeProxy = PrimitiveCType<int64_t>;
+    };
+
+    template <>
+    struct Traits<arrow::UInt8Type> {
+        using TypeProxy = PrimitiveCType<uint8_t>;
+    };
+
+    template <>
+    struct Traits<arrow::UInt16Type> {
+        using TypeProxy = PrimitiveCType<uint16_t>;
+    };
+
+    template <>
+    struct Traits<arrow::UInt32Type> {
+        using TypeProxy = PrimitiveCType<uint32_t>;
+    };
+
+    template <>
+    struct Traits<arrow::UInt64Type> {
+        using TypeProxy = PrimitiveCType<uint64_t>;
+    };
+
+    template <>
+    struct Traits<arrow::StringType> {
+        using TypeProxy = StringType;
+    };
+
+    template <>
+    struct Traits<arrow::TimestampType> {
+        using TypeProxy = TimestampType;
+    };
+}
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 253632d221040..c10ce07280fa6 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -44,7 +44,6 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/c
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/boolean_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/pack.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/unpack.cc"

From c7741fb4e633222346269e80b35b5df48051b585 Mon Sep 17 00:00:00 2001
From: Junming Chen <junming.chen.r@outlook.com>
Date: Wed, 19 Jul 2023 07:41:07 +0800
Subject: [PATCH 005/749] GH-34588:[C++][Python] Add a MetaFunction for
 "dictionary_decode" (#35356)

**Rationale for this change**
This PR is for [Issue-34588](https://github.com/apache/arrow/issues/34588). Discussing with @ westonpace, a MetaFunction for "dictionary_decode" is implemented instead of adding a compute kernel.

**What changes are included in this PR?**
C++: Meta Function of dictionary_decode.
Python: Test

**Are these changes tested?**
One test in tests/test_compute.py

* Closes: #34588

Lead-authored-by: Junming Chen <junming.chen.r@outlook.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 cpp/src/arrow/compute/kernels/vector_hash.cc | 37 ++++++++++++++++++++
 cpp/src/arrow/compute/registry.cc            |  1 +
 cpp/src/arrow/compute/registry_internal.h    |  1 +
 python/pyarrow/tests/test_compute.py         | 11 ++++++
 4 files changed, 50 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/vector_hash.cc b/cpp/src/arrow/compute/kernels/vector_hash.cc
index 2eab7ae8afaf2..a7bb2d88c291b 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash.cc
@@ -27,6 +27,7 @@
 #include "arrow/array/dict_internal.h"
 #include "arrow/array/util.h"
 #include "arrow/compute/api_vector.h"
+#include "arrow/compute/cast.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/hashing.h"
@@ -762,6 +763,38 @@ const FunctionDoc dictionary_encode_doc(
     ("Return a dictionary-encoded version of the input array."), {"array"},
     "DictionaryEncodeOptions");
 
+// ----------------------------------------------------------------------
+// This function does not use any hashing utilities
+// but is kept in this file to be near dictionary_encode
+// Dictionary decode implementation
+
+const FunctionDoc dictionary_decode_doc{
+    "Decodes a DictionaryArray to an Array",
+    ("Return a plain-encoded version of the array input\n"
+     "This function does nothing if the input is not a dictionary."),
+    {"dictionary_array"}};
+
+class DictionaryDecodeMetaFunction : public MetaFunction {
+ public:
+  DictionaryDecodeMetaFunction()
+      : MetaFunction("dictionary_decode", Arity::Unary(), dictionary_decode_doc) {}
+
+  Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
+                            const FunctionOptions* options,
+                            ExecContext* ctx) const override {
+    if (args[0].type() == nullptr || args[0].type()->id() != Type::DICTIONARY) {
+      return args[0];
+    }
+
+    if (args[0].is_array() || args[0].is_chunked_array()) {
+      DictionaryType* dict_type = checked_cast<DictionaryType*>(args[0].type().get());
+      CastOptions cast_options = CastOptions::Safe(dict_type->value_type());
+      return CallFunction("cast", args, &cast_options, ctx);
+    } else {
+      return Status::TypeError("Expected an Array or a Chunked Array");
+    }
+  }
+};
 }  // namespace
 
 void RegisterVectorHash(FunctionRegistry* registry) {
@@ -819,6 +852,10 @@ void RegisterVectorHash(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(dict_encode)));
 }
 
+void RegisterDictionaryDecode(FunctionRegistry* registry) {
+  DCHECK_OK(registry->AddFunction(std::make_shared<DictionaryDecodeMetaFunction>()));
+}
+
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/registry.cc b/cpp/src/arrow/compute/registry.cc
index a4b484a2069ea..7a54f78a03736 100644
--- a/cpp/src/arrow/compute/registry.cc
+++ b/cpp/src/arrow/compute/registry.cc
@@ -275,6 +275,7 @@ static std::unique_ptr<FunctionRegistry> CreateBuiltInRegistry() {
 
   // Register core kernels
   RegisterScalarCast(registry.get());
+  RegisterDictionaryDecode(registry.get());
   RegisterVectorHash(registry.get());
   RegisterVectorSelection(registry.get());
 
diff --git a/cpp/src/arrow/compute/registry_internal.h b/cpp/src/arrow/compute/registry_internal.h
index b4239701d9573..cdc9f804e72f1 100644
--- a/cpp/src/arrow/compute/registry_internal.h
+++ b/cpp/src/arrow/compute/registry_internal.h
@@ -28,6 +28,7 @@ namespace internal {
 void RegisterScalarArithmetic(FunctionRegistry* registry);
 void RegisterScalarBoolean(FunctionRegistry* registry);
 void RegisterScalarCast(FunctionRegistry* registry);
+void RegisterDictionaryDecode(FunctionRegistry* registry);
 void RegisterScalarComparison(FunctionRegistry* registry);
 void RegisterScalarIfElse(FunctionRegistry* registry);
 void RegisterScalarNested(FunctionRegistry* registry);
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index e47e5d3f3eb3b..98ab84c03900f 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1756,6 +1756,17 @@ def test_logical():
     assert pc.invert(a) == pa.array([False, True, True, None])
 
 
+def test_dictionary_decode():
+    array = pa.array(["a", "a", "b", "c", "b"])
+    dictionary_array = array.dictionary_encode()
+    dictionary_array_decode = pc.dictionary_decode(dictionary_array)
+
+    assert array != dictionary_array
+
+    assert array == dictionary_array_decode
+    assert array == pc.dictionary_decode(array)
+
+
 def test_cast():
     arr = pa.array([1, 2, 3, 4], type='int64')
     options = pc.CastOptions(pa.int8())

From 1640a90e93a5e5abc72910186e649355c3affc99 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 19 Jul 2023 12:49:26 +0800
Subject: [PATCH 006/749] MINOR: [Dev] Add js8544 as collaborator (#36764)

### Rationale for this change

Add @ js8544 as github collaborator

### What changes are included in this PR?

Add in `.asf.yaml`

### Are these changes tested?

no

### Are there any user-facing changes?

no

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .asf.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.asf.yaml b/.asf.yaml
index 9bd4e0ef42b7f..1e7fcf1e07ece 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -24,6 +24,7 @@ github:
     - danepitkin
     - davisusanibar
     - felipecrv
+    - js8544
     - mapleFU
 
 notifications:

From 3ce9e1df3203b841c8e7815cc10e055ca97760cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 19 Jul 2023 09:34:04 +0200
Subject: [PATCH 007/749] GH-36756: [CI][Python] Install Cython < 3.0 on
 verify-release-candidate script (#36757)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Some of our verification tasks fail for 13.0.0

### What changes are included in this PR?

Pin Cython to be less than 3.0

### Are these changes tested?

Archery

### Are there any user-facing changes?

No
* Closes: #36756

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 dev/release/verify-release-candidate.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 8c5de9bda85aa..ce31b497c1fab 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -665,7 +665,7 @@ test_python() {
   show_header "Build and test Python libraries"
 
   # Build and test Python
-  maybe_setup_virtualenv cython numpy setuptools_scm setuptools || exit 1
+  maybe_setup_virtualenv "cython<3" numpy setuptools_scm setuptools || exit 1
   maybe_setup_conda --file ci/conda_env_python.txt || exit 1
 
   if [ "${USE_CONDA}" -gt 0 ]; then

From c3c20ce221a0233af8305a4eaedb75694ea40d56 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 19 Jul 2023 17:25:51 +0900
Subject: [PATCH 008/749] GH-36663: [C++] Fix the default value information for
 enum options (#36684)

### Rationale for this change

The default for `ARROW_SIMD_LEVEL` is described as `NONE` but it's actually `DEFAULT`.
The default for `ARROW_RUNTIME_SIMD_LEVEL` is described as `NONE` but it's actually `MAX`.

### What changes are included in this PR?

Reorder possible values to put the default value as the first element.

Before:

    --   ARROW_SIMD_LEVEL=SSE4_2 [default=NONE|SSE4_2|AVX2|AVX512|NEON|SVE|SVE128|SVE256|SVE512|DEFAULT]
    --   ARROW_RUNTIME_SIMD_LEVEL=MAX [default=NONE|SSE4_2|AVX2|AVX512|MAX]

After:

    --   ARROW_SIMD_LEVEL=SSE4_2 [default=DEFAULT|NONE|SSE4_2|AVX2|AVX512|NEON|SVE|SVE128|SVE256|SVE512]
    --   ARROW_RUNTIME_SIMD_LEVEL=MAX [default=MAX|NONE|SSE4_2|AVX2|AVX512]

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #36663

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/cmake_modules/DefineOptions.cmake | 30 +++++++--------------------
 1 file changed, 8 insertions(+), 22 deletions(-)

diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index d20af060453b0..f32bb2bcf7290 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -31,24 +31,6 @@ function(check_description_length name description)
   endforeach()
 endfunction()
 
-function(list_join lst glue out)
-  if("${${lst}}" STREQUAL "")
-    set(${out}
-        ""
-        PARENT_SCOPE)
-    return()
-  endif()
-
-  list(GET ${lst} 0 joined)
-  list(REMOVE_AT ${lst} 0)
-  foreach(item ${${lst}})
-    set(joined "${joined}${glue}${item}")
-  endforeach()
-  set(${out}
-      ${joined}
-      PARENT_SCOPE)
-endfunction()
-
 macro(define_option name description default)
   set(options)
   set(one_value_args)
@@ -63,7 +45,7 @@ macro(define_option name description default)
   endif()
 
   check_description_length(${name} ${description})
-  list_join(description "\n" multiline_description)
+  list(JOIN description "\n" multiline_description)
 
   option(${name} "${multiline_description}" ${default})
 
@@ -76,7 +58,7 @@ endmacro()
 
 macro(define_option_string name description default)
   check_description_length(${name} ${description})
-  list_join(description "\n" multiline_description)
+  list(JOIN description "\n" multiline_description)
 
   set(${name}
       ${default}
@@ -87,8 +69,12 @@ macro(define_option_string name description default)
   set("${name}_OPTION_DEFAULT" "\"${default}\"")
   set("${name}_OPTION_TYPE" "string")
   set("${name}_OPTION_POSSIBLE_VALUES" ${ARGN})
-
-  list_join("${name}_OPTION_POSSIBLE_VALUES" "|" "${name}_OPTION_ENUM")
+  list(FIND ${name}_OPTION_POSSIBLE_VALUES "${default}" default_value_index)
+  if(NOT ${default_value_index} EQUAL -1)
+    list(REMOVE_AT ${name}_OPTION_POSSIBLE_VALUES ${default_value_index})
+    list(PREPEND ${name}_OPTION_POSSIBLE_VALUES "${default}")
+  endif()
+  list(JOIN "${name}_OPTION_POSSIBLE_VALUES" "|" "${name}_OPTION_ENUM")
   if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
     set_property(CACHE ${name} PROPERTY STRINGS "${name}_OPTION_POSSIBLE_VALUES")
   endif()

From 7ad300390e8a193f242a7776b941a1d5fc160c06 Mon Sep 17 00:00:00 2001
From: Jinpeng <zjpzlz@163.com>
Date: Wed, 19 Jul 2023 04:29:27 -0400
Subject: [PATCH 009/749] PARQUET-2323: [C++] Use bitmap to store pre-buffered
 column chunks (#36649)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

In https://issues.apache.org/jira/browse/PARQUET-2316 we allow partial buffer in parquet File Reader by storing prebuffered column chunk index in a hash set, and make a copy of this hash set for each rowgroup reader.

In extreme conditions where numerous columns are prebuffered and multiple rowgroup readers are created for the same row group , the hash set would incur significant overhead. 

Using a bitmap instead (with one bit per column chunk indicating whether it's prebuffered or not) would be a reasonsable mitigation, taking 4KB for 32K columns.

### What changes are included in this PR?

Switch from a hash set to a bitmap buffer.

### Are these changes tested?

Yes, passed unit tests on partial prebuffer.

### Are there any user-facing changes?

No.

Lead-authored-by: jp0317 <zjpzlz@gmail.com>
Co-authored-by: Jinpeng <zjpzlz@163.com>
Co-authored-by: Gang Wu <ustcwg@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../parquet/arrow/arrow_reader_writer_test.cc |  4 +--
 cpp/src/parquet/file_reader.cc                | 33 +++++++++++--------
 2 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 69827d5c464b9..8585b1ccf11aa 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -2413,9 +2413,9 @@ TEST(TestArrowReadWrite, CoalescedReadsAndNonCoalescedReads) {
 
   ASSERT_EQ(2, reader->num_row_groups());
 
-  // Pre-buffer 3 columns in the 2nd row group.
+  // Pre-buffer column 0 and column 3 in the 2nd row group.
   const std::vector<int> row_groups = {1};
-  const std::vector<int> column_indices = {0, 1, 4};
+  const std::vector<int> column_indices = {0, 3};
   reader->parquet_reader()->PreBuffer(row_groups, column_indices,
                                       ::arrow::io::IOContext(),
                                       ::arrow::io::CacheOptions::Defaults());
diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index fc30ddb43f29c..adda9a027bded 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -29,6 +29,7 @@
 #include "arrow/io/caching.h"
 #include "arrow/io/file.h"
 #include "arrow/io/memory.h"
+#include "arrow/util/bit_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/future.h"
 #include "arrow/util/int_util_overflow.h"
@@ -179,7 +180,7 @@ class SerializedRowGroup : public RowGroupReader::Contents {
                      std::shared_ptr<::arrow::io::internal::ReadRangeCache> cached_source,
                      int64_t source_size, FileMetaData* file_metadata,
                      int row_group_number, const ReaderProperties& props,
-                     std::unordered_set<int> prebuffered_column_chunks,
+                     std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap,
                      std::shared_ptr<InternalFileDecryptor> file_decryptor = nullptr)
       : source_(std::move(source)),
         cached_source_(std::move(cached_source)),
@@ -187,7 +188,7 @@ class SerializedRowGroup : public RowGroupReader::Contents {
         file_metadata_(file_metadata),
         properties_(props),
         row_group_ordinal_(row_group_number),
-        prebuffered_column_chunks_(std::move(prebuffered_column_chunks)),
+        prebuffered_column_chunks_bitmap_(std::move(prebuffered_column_chunks_bitmap)),
         file_decryptor_(file_decryptor) {
     row_group_metadata_ = file_metadata->RowGroup(row_group_number);
   }
@@ -203,8 +204,8 @@ class SerializedRowGroup : public RowGroupReader::Contents {
     ::arrow::io::ReadRange col_range =
         ComputeColumnChunkRange(file_metadata_, source_size_, row_group_ordinal_, i);
     std::shared_ptr<ArrowInputStream> stream;
-    if (cached_source_ &&
-        prebuffered_column_chunks_.find(i) != prebuffered_column_chunks_.end()) {
+    if (cached_source_ && prebuffered_column_chunks_bitmap_ != nullptr &&
+        ::arrow::bit_util::GetBit(prebuffered_column_chunks_bitmap_->data(), i)) {
       // PARQUET-1698: if read coalescing is enabled, read from pre-buffered
       // segments.
       PARQUET_ASSIGN_OR_THROW(auto buffer, cached_source_->Read(col_range));
@@ -272,7 +273,7 @@ class SerializedRowGroup : public RowGroupReader::Contents {
   std::unique_ptr<RowGroupMetaData> row_group_metadata_;
   ReaderProperties properties_;
   int row_group_ordinal_;
-  const std::unordered_set<int> prebuffered_column_chunks_;
+  const std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap_;
   std::shared_ptr<InternalFileDecryptor> file_decryptor_;
 };
 
@@ -302,17 +303,17 @@ class SerializedFile : public ParquetFileReader::Contents {
   }
 
   std::shared_ptr<RowGroupReader> GetRowGroup(int i) override {
-    std::unordered_set<int> prebuffered_column_chunks;
-    // Avoid updating the map as this function can be called concurrently. The map can
-    // only be updated within Prebuffer().
+    std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap;
+    // Avoid updating the bitmap as this function can be called concurrently. The bitmap
+    // can only be updated within Prebuffer().
     auto prebuffered_column_chunks_iter = prebuffered_column_chunks_.find(i);
     if (prebuffered_column_chunks_iter != prebuffered_column_chunks_.end()) {
-      prebuffered_column_chunks = prebuffered_column_chunks_iter->second;
+      prebuffered_column_chunks_bitmap = prebuffered_column_chunks_iter->second;
     }
 
     std::unique_ptr<SerializedRowGroup> contents = std::make_unique<SerializedRowGroup>(
         source_, cached_source_, source_size_, file_metadata_.get(), i, properties_,
-        std::move(prebuffered_column_chunks), file_decryptor_);
+        std::move(prebuffered_column_chunks_bitmap), file_decryptor_);
     return std::make_shared<RowGroupReader>(std::move(contents));
   }
 
@@ -366,9 +367,12 @@ class SerializedFile : public ParquetFileReader::Contents {
     std::vector<::arrow::io::ReadRange> ranges;
     prebuffered_column_chunks_.clear();
     for (int row : row_groups) {
-      std::unordered_set<int>& prebuffered = prebuffered_column_chunks_[row];
+      std::shared_ptr<Buffer>& col_bitmap = prebuffered_column_chunks_[row];
+      int num_cols = file_metadata_->num_columns();
+      PARQUET_THROW_NOT_OK(
+          AllocateEmptyBitmap(num_cols, properties_.memory_pool()).Value(&col_bitmap));
       for (int col : column_indices) {
-        prebuffered.insert(col);
+        ::arrow::bit_util::SetBit(col_bitmap->mutable_data(), col);
         ranges.push_back(
             ComputeColumnChunkRange(file_metadata_.get(), source_size_, row, col));
       }
@@ -578,8 +582,9 @@ class SerializedFile : public ParquetFileReader::Contents {
   ReaderProperties properties_;
   std::shared_ptr<PageIndexReader> page_index_reader_;
   std::unique_ptr<BloomFilterReader> bloom_filter_reader_;
-  // Maps a row group to its column chunks that are cached via Prebuffer().
-  std::unordered_map<int, std::unordered_set<int>> prebuffered_column_chunks_;
+  // Maps row group ordinal and prebuffer status of its column chunks in the form of a
+  // bitmap buffer.
+  std::unordered_map<int, std::shared_ptr<Buffer>> prebuffered_column_chunks_;
   std::shared_ptr<InternalFileDecryptor> file_decryptor_;
 
   // \return The true length of the metadata in bytes

From a7958d9a68ed1fc502199bcccf948b34110b8e33 Mon Sep 17 00:00:00 2001
From: Ben Harkins <60872452+benibus@users.noreply.github.com>
Date: Wed, 19 Jul 2023 04:45:54 -0400
Subject: [PATCH 010/749] GH-36326: [C++] Remove APIs deprecated in v9.0 or
 earlier (#36675)

### Rationale for this change

General cleanup of C++ APIs deprecated for at least a year.

### What changes are included in this PR?

Removes any APIs annotated with `ARROW_DEPRECATED` and an included version `<=9.0`. In a few cases, tests needed to be removed or slightly altered.

### Are these changes tested?

Yes (covered by existing tests) when applicable.

### Are there any user-facing changes?

Yes

* Closes: #36326

Authored-by: benibus <bpharks@gmx.com>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
---
 cpp/src/arrow/array/array_test.cc             | 19 +---
 cpp/src/arrow/array/builder_adaptive.h        |  2 -
 cpp/src/arrow/array/builder_base.cc           |  8 --
 cpp/src/arrow/array/builder_base.h            |  9 --
 cpp/src/arrow/compute/api_scalar.cc           | 28 ------
 cpp/src/arrow/compute/api_scalar.h            | 18 ----
 cpp/src/arrow/compute/api_vector.cc           |  7 --
 cpp/src/arrow/compute/api_vector.h            |  8 --
 cpp/src/arrow/csv/reader.cc                   | 21 -----
 cpp/src/arrow/csv/reader.h                    | 13 ---
 cpp/src/arrow/flight/client.cc                | 78 ----------------
 cpp/src/arrow/flight/client.h                 | 93 -------------------
 cpp/src/arrow/flight/flight_internals_test.cc | 21 -----
 cpp/src/arrow/flight/server.h                 |  8 --
 cpp/src/arrow/flight/types.cc                 | 78 ----------------
 cpp/src/arrow/flight/types.h                  | 60 ------------
 cpp/src/arrow/io/interfaces.h                 |  4 -
 cpp/src/arrow/record_batch.cc                 |  8 --
 cpp/src/arrow/record_batch.h                  |  6 --
 cpp/src/arrow/record_batch_test.cc            | 28 ------
 cpp/src/arrow/table_builder.cc                | 24 -----
 cpp/src/arrow/table_builder.h                 | 31 -------
 cpp/src/parquet/arrow/reader.cc               | 10 --
 cpp/src/parquet/arrow/reader.h                | 27 ++----
 24 files changed, 11 insertions(+), 598 deletions(-)

diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 555e40b7b308a..0b82a82fbdb26 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -1727,21 +1727,6 @@ TYPED_TEST(TestPrimitiveBuilder, TestAppendValuesStdBool) {
   this->Check(this->builder_nn_, false);
 }
 
-TYPED_TEST(TestPrimitiveBuilder, TestAdvance) {
-  ARROW_SUPPRESS_DEPRECATION_WARNING
-  int64_t n = 1000;
-  ASSERT_OK(this->builder_->Reserve(n));
-
-  ASSERT_OK(this->builder_->Advance(100));
-  ASSERT_EQ(100, this->builder_->length());
-
-  ASSERT_OK(this->builder_->Advance(900));
-
-  int64_t too_many = this->builder_->capacity() - 1000 + 1;
-  ASSERT_RAISES(Invalid, this->builder_->Advance(too_many));
-  ARROW_UNSUPPRESS_DEPRECATION_WARNING
-}
-
 TYPED_TEST(TestPrimitiveBuilder, TestResize) {
   int64_t cap = kMinBuilderCapacity * 2;
 
@@ -1757,9 +1742,7 @@ TYPED_TEST(TestPrimitiveBuilder, TestReserve) {
   ASSERT_OK(this->builder_->Reserve(100));
   ASSERT_EQ(0, this->builder_->length());
   ASSERT_GE(100, this->builder_->capacity());
-  ARROW_SUPPRESS_DEPRECATION_WARNING
-  ASSERT_OK(this->builder_->Advance(100));
-  ARROW_UNSUPPRESS_DEPRECATION_WARNING
+  ASSERT_OK(this->builder_->AppendEmptyValues(100));
   ASSERT_EQ(100, this->builder_->length());
   ASSERT_GE(100, this->builder_->capacity());
 
diff --git a/cpp/src/arrow/array/builder_adaptive.h b/cpp/src/arrow/array/builder_adaptive.h
index 382c35789c4e0..0cea571be3e32 100644
--- a/cpp/src/arrow/array/builder_adaptive.h
+++ b/cpp/src/arrow/array/builder_adaptive.h
@@ -142,7 +142,6 @@ class ARROW_EXPORT AdaptiveUIntBuilder : public internal::AdaptiveIntBuilderBase
   explicit AdaptiveUIntBuilder(MemoryPool* pool = default_memory_pool())
       : AdaptiveUIntBuilder(sizeof(uint8_t), pool) {}
 
-  using ArrayBuilder::Advance;
   using internal::AdaptiveIntBuilderBase::Reset;
 
   /// Scalar append
@@ -182,7 +181,6 @@ class ARROW_EXPORT AdaptiveIntBuilder : public internal::AdaptiveIntBuilderBase
                               int64_t alignment = kDefaultBufferAlignment)
       : AdaptiveIntBuilder(sizeof(uint8_t), pool, alignment) {}
 
-  using ArrayBuilder::Advance;
   using internal::AdaptiveIntBuilderBase::Reset;
 
   /// Scalar append
diff --git a/cpp/src/arrow/array/builder_base.cc b/cpp/src/arrow/array/builder_base.cc
index 70da1fbb2966a..3000aea3e189a 100644
--- a/cpp/src/arrow/array/builder_base.cc
+++ b/cpp/src/arrow/array/builder_base.cc
@@ -91,14 +91,6 @@ Status ArrayBuilder::Resize(int64_t capacity) {
   return null_bitmap_builder_.Resize(capacity);
 }
 
-Status ArrayBuilder::Advance(int64_t elements) {
-  if (length_ + elements > capacity_) {
-    return Status::Invalid("Builder must be expanded");
-  }
-  length_ += elements;
-  return null_bitmap_builder_.Advance(elements);
-}
-
 namespace {
 
 template <typename ConstIterator>
diff --git a/cpp/src/arrow/array/builder_base.h b/cpp/src/arrow/array/builder_base.h
index abbd61be80359..05af850fd149c 100644
--- a/cpp/src/arrow/array/builder_base.h
+++ b/cpp/src/arrow/array/builder_base.h
@@ -180,15 +180,6 @@ class ARROW_EXPORT ArrayBuilder {
     return Status::NotImplemented("AppendArraySlice for builder for ", *type());
   }
 
-  /// For cases where raw data was memcpy'd into the internal buffers, allows us
-  /// to advance the length of the builder. It is your responsibility to use
-  /// this function responsibly.
-  ARROW_DEPRECATED(
-      "Deprecated in 6.0.0. ArrayBuilder::Advance is poorly supported and mostly "
-      "untested.\nFor low-level control over buffer construction, use BufferBuilder "
-      "or TypedBufferBuilder directly.")
-  Status Advance(int64_t elements);
-
   /// \brief Return result of builder as an internal generic ArrayData
   /// object. Resets builder except for dictionary builder
   ///
diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index ae7e82fb2f9e4..d7a61d0a55985 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -775,34 +775,6 @@ SCALAR_EAGER_BINARY(Or, "or")
 SCALAR_EAGER_BINARY(Xor, "xor")
 SCALAR_EAGER_UNARY(Invert, "invert")
 
-// ----------------------------------------------------------------------
-
-Result<Datum> Compare(const Datum& left, const Datum& right, CompareOptions options,
-                      ExecContext* ctx) {
-  std::string func_name;
-  switch (options.op) {
-    case CompareOperator::EQUAL:
-      func_name = "equal";
-      break;
-    case CompareOperator::NOT_EQUAL:
-      func_name = "not_equal";
-      break;
-    case CompareOperator::GREATER:
-      func_name = "greater";
-      break;
-    case CompareOperator::GREATER_EQUAL:
-      func_name = "greater_equal";
-      break;
-    case CompareOperator::LESS:
-      func_name = "less";
-      break;
-    case CompareOperator::LESS_EQUAL:
-      func_name = "less_equal";
-      break;
-  }
-  return CallFunction(func_name, {left, right}, nullptr, ctx);
-}
-
 // ----------------------------------------------------------------------
 // Validity functions
 
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 10a2b4bffde6d..0a06a2829f0da 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -970,24 +970,6 @@ Result<Datum> RoundTemporal(
     const Datum& arg, RoundTemporalOptions options = RoundTemporalOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
-/// \brief Compare a numeric array with a scalar.
-///
-/// \param[in] left datum to compare, must be an Array
-/// \param[in] right datum to compare, must be a Scalar of the same type than
-///            left Datum.
-/// \param[in] options compare options
-/// \param[in] ctx the function execution context, optional
-/// \return resulting datum
-///
-/// Note on floating point arrays, this uses ieee-754 compare semantics.
-///
-/// \since 1.0.0
-/// \note API not yet finalized
-ARROW_DEPRECATED("Deprecated in 5.0.0. Use each compare function directly")
-ARROW_EXPORT
-Result<Datum> Compare(const Datum& left, const Datum& right, CompareOptions options,
-                      ExecContext* ctx = NULLPTR);
-
 /// \brief Invert the values of a boolean datum
 /// \param[in] value datum to invert
 /// \param[in] ctx the function execution context, optional
diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index 67595c3308f9b..f73b10e11edd7 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -417,12 +417,5 @@ Result<Datum> CumulativeMin(const Datum& values, const CumulativeOptions& option
   return CallFunction("cumulative_min", {Datum(values)}, &options, ctx);
 }
 
-// ----------------------------------------------------------------------
-// Deprecated functions
-
-Result<std::shared_ptr<Array>> SortToIndices(const Array& values, ExecContext* ctx) {
-  return SortIndices(values, SortOrder::Ascending, ctx);
-}
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index c85db1aa3ba88..4f226ac00788a 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -683,13 +683,5 @@ Result<std::shared_ptr<Array>> PairwiseDiff(const Array& array,
                                             bool check_overflow = false,
                                             ExecContext* ctx = NULLPTR);
 
-// ----------------------------------------------------------------------
-// Deprecated functions
-
-ARROW_DEPRECATED("Deprecated in 3.0.0. Use SortIndices()")
-ARROW_EXPORT
-Result<std::shared_ptr<Array>> SortToIndices(const Array& values,
-                                             ExecContext* ctx = NULLPTR);
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/csv/reader.cc b/cpp/src/arrow/csv/reader.cc
index fdc7fcb1380e5..bf703b6c6ba28 100644
--- a/cpp/src/arrow/csv/reader.cc
+++ b/cpp/src/arrow/csv/reader.cc
@@ -1246,27 +1246,6 @@ Result<std::shared_ptr<TableReader>> TableReader::Make(
                          parse_options, convert_options);
 }
 
-Result<std::shared_ptr<TableReader>> TableReader::Make(
-    MemoryPool* pool, io::IOContext io_context, std::shared_ptr<io::InputStream> input,
-    const ReadOptions& read_options, const ParseOptions& parse_options,
-    const ConvertOptions& convert_options) {
-  return MakeTableReader(pool, io_context, std::move(input), read_options, parse_options,
-                         convert_options);
-}
-
-Result<std::shared_ptr<StreamingReader>> StreamingReader::Make(
-    MemoryPool* pool, std::shared_ptr<io::InputStream> input,
-    const ReadOptions& read_options, const ParseOptions& parse_options,
-    const ConvertOptions& convert_options) {
-  auto io_context = io::IOContext(pool);
-  auto cpu_executor = arrow::internal::GetCpuThreadPool();
-  auto reader_fut = MakeStreamingReader(io_context, std::move(input), cpu_executor,
-                                        read_options, parse_options, convert_options);
-  auto reader_result = reader_fut.result();
-  ARROW_ASSIGN_OR_RAISE(auto reader, reader_result);
-  return reader;
-}
-
 Result<std::shared_ptr<StreamingReader>> StreamingReader::Make(
     io::IOContext io_context, std::shared_ptr<io::InputStream> input,
     const ReadOptions& read_options, const ParseOptions& parse_options,
diff --git a/cpp/src/arrow/csv/reader.h b/cpp/src/arrow/csv/reader.h
index 03b953d0055e5..bae301dc14815 100644
--- a/cpp/src/arrow/csv/reader.h
+++ b/cpp/src/arrow/csv/reader.h
@@ -52,13 +52,6 @@ class ARROW_EXPORT TableReader {
                                                    const ReadOptions&,
                                                    const ParseOptions&,
                                                    const ConvertOptions&);
-
-  ARROW_DEPRECATED(
-      "Deprecated in 4.0.0. "
-      "Use MemoryPool-less variant (the IOContext holds a pool already)")
-  static Result<std::shared_ptr<TableReader>> Make(
-      MemoryPool* pool, io::IOContext io_context, std::shared_ptr<io::InputStream> input,
-      const ReadOptions&, const ParseOptions&, const ConvertOptions&);
 };
 
 /// \brief A class that reads a CSV file incrementally
@@ -105,12 +98,6 @@ class ARROW_EXPORT StreamingReader : public RecordBatchReader {
   static Result<std::shared_ptr<StreamingReader>> Make(
       io::IOContext io_context, std::shared_ptr<io::InputStream> input,
       const ReadOptions&, const ParseOptions&, const ConvertOptions&);
-
-  ARROW_DEPRECATED("Deprecated in 4.0.0. Use IOContext-based overload")
-  static Result<std::shared_ptr<StreamingReader>> Make(
-      MemoryPool* pool, std::shared_ptr<io::InputStream> input,
-      const ReadOptions& read_options, const ParseOptions& parse_options,
-      const ConvertOptions& convert_options);
 };
 
 /// \brief Count the logical rows of data in a CSV file (i.e. the
diff --git a/cpp/src/arrow/flight/client.cc b/cpp/src/arrow/flight/client.cc
index e5e9f141aa62b..ec5377b7c11dc 100644
--- a/cpp/src/arrow/flight/client.cc
+++ b/cpp/src/arrow/flight/client.cc
@@ -79,16 +79,6 @@ arrow::Result<std::shared_ptr<Table>> FlightStreamReader::ToTable(
   return Table::FromRecordBatches(schema, std::move(batches));
 }
 
-Status FlightStreamReader::ReadAll(std::vector<std::shared_ptr<RecordBatch>>* batches,
-                                   const StopToken& stop_token) {
-  return ToRecordBatches(stop_token).Value(batches);
-}
-
-Status FlightStreamReader::ReadAll(std::shared_ptr<Table>* table,
-                                   const StopToken& stop_token) {
-  return ToTable(stop_token).Value(table);
-}
-
 /// \brief An ipc::MessageReader adapting the Flight ClientDataStream interface.
 ///
 /// In order to support app_metadata and reuse the existing IPC
@@ -520,11 +510,6 @@ arrow::Result<std::unique_ptr<FlightClient>> FlightClient::Connect(
   return Connect(location, FlightClientOptions::Defaults());
 }
 
-Status FlightClient::Connect(const Location& location,
-                             std::unique_ptr<FlightClient>* client) {
-  return Connect(location, FlightClientOptions::Defaults()).Value(client);
-}
-
 arrow::Result<std::unique_ptr<FlightClient>> FlightClient::Connect(
     const Location& location, const FlightClientOptions& options) {
   flight::transport::grpc::InitializeFlightGrpcClient();
@@ -538,11 +523,6 @@ arrow::Result<std::unique_ptr<FlightClient>> FlightClient::Connect(
   return client;
 }
 
-Status FlightClient::Connect(const Location& location, const FlightClientOptions& options,
-                             std::unique_ptr<FlightClient>* client) {
-  return Connect(location, options).Value(client);
-}
-
 Status FlightClient::Authenticate(const FlightCallOptions& options,
                                   std::unique_ptr<ClientAuthHandler> auth_handler) {
   RETURN_NOT_OK(CheckOpen());
@@ -564,11 +544,6 @@ arrow::Result<std::unique_ptr<ResultStream>> FlightClient::DoAction(
   return results;
 }
 
-Status FlightClient::DoAction(const FlightCallOptions& options, const Action& action,
-                              std::unique_ptr<ResultStream>* results) {
-  return DoAction(options, action).Value(results);
-}
-
 arrow::Result<CancelFlightInfoResult> FlightClient::CancelFlightInfo(
     const FlightCallOptions& options, const CancelFlightInfoRequest& request) {
   ARROW_ASSIGN_OR_RAISE(auto body, request.SerializeToString());
@@ -601,11 +576,6 @@ arrow::Result<std::vector<ActionType>> FlightClient::ListActions(
   return actions;
 }
 
-Status FlightClient::ListActions(const FlightCallOptions& options,
-                                 std::vector<ActionType>* actions) {
-  return ListActions(options).Value(actions);
-}
-
 arrow::Result<std::unique_ptr<FlightInfo>> FlightClient::GetFlightInfo(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   std::unique_ptr<FlightInfo> info;
@@ -614,32 +584,16 @@ arrow::Result<std::unique_ptr<FlightInfo>> FlightClient::GetFlightInfo(
   return info;
 }
 
-Status FlightClient::GetFlightInfo(const FlightCallOptions& options,
-                                   const FlightDescriptor& descriptor,
-                                   std::unique_ptr<FlightInfo>* info) {
-  return GetFlightInfo(options, descriptor).Value(info);
-}
-
 arrow::Result<std::unique_ptr<SchemaResult>> FlightClient::GetSchema(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   RETURN_NOT_OK(CheckOpen());
   return transport_->GetSchema(options, descriptor);
 }
 
-Status FlightClient::GetSchema(const FlightCallOptions& options,
-                               const FlightDescriptor& descriptor,
-                               std::unique_ptr<SchemaResult>* schema_result) {
-  return GetSchema(options, descriptor).Value(schema_result);
-}
-
 arrow::Result<std::unique_ptr<FlightListing>> FlightClient::ListFlights() {
   return ListFlights({}, {});
 }
 
-Status FlightClient::ListFlights(std::unique_ptr<FlightListing>* listing) {
-  return ListFlights({}, {}).Value(listing);
-}
-
 arrow::Result<std::unique_ptr<FlightListing>> FlightClient::ListFlights(
     const FlightCallOptions& options, const Criteria& criteria) {
   std::unique_ptr<FlightListing> listing;
@@ -648,12 +602,6 @@ arrow::Result<std::unique_ptr<FlightListing>> FlightClient::ListFlights(
   return listing;
 }
 
-Status FlightClient::ListFlights(const FlightCallOptions& options,
-                                 const Criteria& criteria,
-                                 std::unique_ptr<FlightListing>* listing) {
-  return ListFlights(options, criteria).Value(listing);
-}
-
 arrow::Result<std::unique_ptr<FlightStreamReader>> FlightClient::DoGet(
     const FlightCallOptions& options, const Ticket& ticket) {
   RETURN_NOT_OK(CheckOpen());
@@ -668,11 +616,6 @@ arrow::Result<std::unique_ptr<FlightStreamReader>> FlightClient::DoGet(
   return stream_reader;
 }
 
-Status FlightClient::DoGet(const FlightCallOptions& options, const Ticket& ticket,
-                           std::unique_ptr<FlightStreamReader>* stream) {
-  return DoGet(options, ticket).Value(stream);
-}
-
 arrow::Result<FlightClient::DoPutResult> FlightClient::DoPut(
     const FlightCallOptions& options, const FlightDescriptor& descriptor,
     const std::shared_ptr<Schema>& schema) {
@@ -689,17 +632,6 @@ arrow::Result<FlightClient::DoPutResult> FlightClient::DoPut(
   return result;
 }
 
-Status FlightClient::DoPut(const FlightCallOptions& options,
-                           const FlightDescriptor& descriptor,
-                           const std::shared_ptr<Schema>& schema,
-                           std::unique_ptr<FlightStreamWriter>* writer,
-                           std::unique_ptr<FlightMetadataReader>* reader) {
-  ARROW_ASSIGN_OR_RAISE(auto result, DoPut(options, descriptor, schema));
-  *writer = std::move(result.writer);
-  *reader = std::move(result.reader);
-  return Status::OK();
-}
-
 arrow::Result<FlightClient::DoExchangeResult> FlightClient::DoExchange(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   RETURN_NOT_OK(CheckOpen());
@@ -717,16 +649,6 @@ arrow::Result<FlightClient::DoExchangeResult> FlightClient::DoExchange(
   return result;
 }
 
-Status FlightClient::DoExchange(const FlightCallOptions& options,
-                                const FlightDescriptor& descriptor,
-                                std::unique_ptr<FlightStreamWriter>* writer,
-                                std::unique_ptr<FlightStreamReader>* reader) {
-  ARROW_ASSIGN_OR_RAISE(auto result, DoExchange(options, descriptor));
-  *writer = std::move(result.writer);
-  *reader = std::move(result.reader);
-  return Status::OK();
-}
-
 Status FlightClient::Close() {
   if (!closed_) {
     closed_ = true;
diff --git a/cpp/src/arrow/flight/client.h b/cpp/src/arrow/flight/client.h
index ba9f688dce8b7..7204b469a6127 100644
--- a/cpp/src/arrow/flight/client.h
+++ b/cpp/src/arrow/flight/client.h
@@ -139,17 +139,9 @@ class ARROW_FLIGHT_EXPORT FlightStreamReader : public MetadataRecordBatchReader
   virtual arrow::Result<std::vector<std::shared_ptr<RecordBatch>>> ToRecordBatches(
       const StopToken& stop_token) = 0;
 
-  using MetadataRecordBatchReader::ReadAll;
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToRecordBatches instead.")
-  Status ReadAll(std::vector<std::shared_ptr<RecordBatch>>* batches,
-                 const StopToken& stop_token);
-
   using MetadataRecordBatchReader::ToTable;
   /// \brief Consume entire stream as a Table
   arrow::Result<std::shared_ptr<Table>> ToTable(const StopToken& stop_token);
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToTable instead.")
-  Status ReadAll(std::shared_ptr<Table>* table, const StopToken& stop_token);
 };
 
 // Silence warning
@@ -196,9 +188,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   /// the connection was successful
   static arrow::Result<std::unique_ptr<FlightClient>> Connect(const Location& location);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Connect(const Location& location, std::unique_ptr<FlightClient>* client);
-
   /// \brief Connect to an unauthenticated flight service
   /// \param[in] location the URI
   /// \param[in] options Other options for setting up the client
@@ -207,10 +196,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   static arrow::Result<std::unique_ptr<FlightClient>> Connect(
       const Location& location, const FlightClientOptions& options);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Connect(const Location& location, const FlightClientOptions& options,
-                        std::unique_ptr<FlightClient>* client);
-
   /// \brief Authenticate to the server using the given handler.
   /// \param[in] options Per-RPC options
   /// \param[in] auth_handler The authentication mechanism to use
@@ -239,14 +224,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return DoAction({}, action);
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoAction(const FlightCallOptions& options, const Action& action,
-                  std::unique_ptr<ResultStream>* results);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoAction(const Action& action, std::unique_ptr<ResultStream>* results) {
-    return DoAction({}, action).Value(results);
-  }
-
   /// \brief Perform the CancelFlightInfo action, returning a
   /// CancelFlightInfoResult
   ///
@@ -281,13 +258,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return ListActions(FlightCallOptions());
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status ListActions(const FlightCallOptions& options, std::vector<ActionType>* actions);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status ListActions(std::vector<ActionType>* actions) {
-    return ListActions().Value(actions);
-  }
-
   /// \brief Request access plan for a single flight, which may be an existing
   /// dataset or a command to be executed
   /// \param[in] options Per-RPC options
@@ -301,16 +271,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return GetFlightInfo({}, descriptor);
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetFlightInfo(const FlightCallOptions& options,
-                       const FlightDescriptor& descriptor,
-                       std::unique_ptr<FlightInfo>* info);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetFlightInfo(const FlightDescriptor& descriptor,
-                       std::unique_ptr<FlightInfo>* info) {
-    return GetFlightInfo({}, descriptor).Value(info);
-  }
-
   /// \brief Request schema for a single flight, which may be an existing
   /// dataset or a command to be executed
   /// \param[in] options Per-RPC options
@@ -320,27 +280,15 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   arrow::Result<std::unique_ptr<SchemaResult>> GetSchema(
       const FlightCallOptions& options, const FlightDescriptor& descriptor);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetSchema(const FlightCallOptions& options, const FlightDescriptor& descriptor,
-                   std::unique_ptr<SchemaResult>* schema_result);
-
   arrow::Result<std::unique_ptr<SchemaResult>> GetSchema(
       const FlightDescriptor& descriptor) {
     return GetSchema({}, descriptor);
   }
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetSchema(const FlightDescriptor& descriptor,
-                   std::unique_ptr<SchemaResult>* schema_result) {
-    return GetSchema({}, descriptor).Value(schema_result);
-  }
 
   /// \brief List all available flights known to the server
   /// \return Arrow result with an iterator that returns a FlightInfo for each flight
   arrow::Result<std::unique_ptr<FlightListing>> ListFlights();
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status ListFlights(std::unique_ptr<FlightListing>* listing);
-
   /// \brief List available flights given indicated filter criteria
   /// \param[in] options Per-RPC options
   /// \param[in] criteria the filter criteria (opaque)
@@ -348,10 +296,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   arrow::Result<std::unique_ptr<FlightListing>> ListFlights(
       const FlightCallOptions& options, const Criteria& criteria);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status ListFlights(const FlightCallOptions& options, const Criteria& criteria,
-                     std::unique_ptr<FlightListing>* listing);
-
   /// \brief Given a flight ticket and schema, request to be sent the
   /// stream. Returns record batch stream reader
   /// \param[in] options Per-RPC options
@@ -363,14 +307,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return DoGet({}, ticket);
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoGet(const FlightCallOptions& options, const Ticket& ticket,
-               std::unique_ptr<FlightStreamReader>* stream);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoGet(const Ticket& ticket, std::unique_ptr<FlightStreamReader>* stream) {
-    return DoGet({}, ticket).Value(stream);
-  }
-
   /// \brief DoPut return value
   struct DoPutResult {
     /// \brief a writer to write record batches to
@@ -399,21 +335,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return DoPut({}, descriptor, schema);
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoPut(const FlightCallOptions& options, const FlightDescriptor& descriptor,
-               const std::shared_ptr<Schema>& schema,
-               std::unique_ptr<FlightStreamWriter>* writer,
-               std::unique_ptr<FlightMetadataReader>* reader);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoPut(const FlightDescriptor& descriptor, const std::shared_ptr<Schema>& schema,
-               std::unique_ptr<FlightStreamWriter>* writer,
-               std::unique_ptr<FlightMetadataReader>* reader) {
-    ARROW_ASSIGN_OR_RAISE(auto output, DoPut({}, descriptor, schema));
-    *writer = std::move(output.writer);
-    *reader = std::move(output.reader);
-    return Status::OK();
-  }
-
   struct DoExchangeResult {
     std::unique_ptr<FlightStreamWriter> writer;
     std::unique_ptr<FlightStreamReader> reader;
@@ -424,20 +345,6 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return DoExchange({}, descriptor);
   }
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoExchange(const FlightCallOptions& options, const FlightDescriptor& descriptor,
-                    std::unique_ptr<FlightStreamWriter>* writer,
-                    std::unique_ptr<FlightStreamReader>* reader);
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status DoExchange(const FlightDescriptor& descriptor,
-                    std::unique_ptr<FlightStreamWriter>* writer,
-                    std::unique_ptr<FlightStreamReader>* reader) {
-    ARROW_ASSIGN_OR_RAISE(auto output, DoExchange({}, descriptor));
-    *writer = std::move(output.writer);
-    *reader = std::move(output.reader);
-    return Status::OK();
-  }
-
   /// \brief Explicitly shut down and clean up the client.
   ///
   /// For backwards compatibility, this will be implicitly called by
diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index 87cd1ca887d5f..27c13ff949836 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -381,27 +381,6 @@ TEST(FlightTypes, LocationConstruction) {
   ASSERT_EQ(location.ToString(), "grpc+unix:///tmp/test.sock");
 }
 
-ARROW_SUPPRESS_DEPRECATION_WARNING
-TEST(FlightTypes, DeprecatedLocationConstruction) {
-  Location location;
-  ASSERT_RAISES(Invalid, Location::Parse("This is not an URI", &location));
-  ASSERT_RAISES(Invalid,
-                Location::ForGrpcTcp("This is not a hostname", 12345, &location));
-  ASSERT_RAISES(Invalid,
-                Location::ForGrpcTls("This is not a hostname", 12345, &location));
-  ASSERT_RAISES(Invalid, Location::ForGrpcUnix("This is not a filename", &location));
-
-  ASSERT_OK(Location::Parse("s3://test", &location));
-  ASSERT_EQ(location.ToString(), "s3://test");
-  ASSERT_OK(Location::ForGrpcTcp("localhost", 12345, &location));
-  ASSERT_EQ(location.ToString(), "grpc+tcp://localhost:12345");
-  ASSERT_OK(Location::ForGrpcTls("localhost", 12345, &location));
-  ASSERT_EQ(location.ToString(), "grpc+tls://localhost:12345");
-  ASSERT_OK(Location::ForGrpcUnix("/tmp/test.sock", &location));
-  ASSERT_EQ(location.ToString(), "grpc+unix:///tmp/test.sock");
-}
-ARROW_UNSUPPRESS_DEPRECATION_WARNING
-
 // ----------------------------------------------------------------------
 // Cookie authentication/middleware
 
diff --git a/cpp/src/arrow/flight/server.h b/cpp/src/arrow/flight/server.h
index 6fb8ab1213117..5c15d8d5645d1 100644
--- a/cpp/src/arrow/flight/server.h
+++ b/cpp/src/arrow/flight/server.h
@@ -53,18 +53,10 @@ class ARROW_FLIGHT_EXPORT FlightDataStream {
   /// \brief Compute FlightPayload containing serialized RecordBatch schema
   virtual arrow::Result<FlightPayload> GetSchemaPayload() = 0;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetSchemaPayload(FlightPayload* payload) {
-    return GetSchemaPayload().Value(payload);
-  }
-
   // When the stream is completed, the last payload written will have null
   // metadata
   virtual arrow::Result<FlightPayload> Next() = 0;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status Next(FlightPayload* payload) { return Next().Value(payload); }
-
   virtual Status Close();
 };
 
diff --git a/cpp/src/arrow/flight/types.cc b/cpp/src/arrow/flight/types.cc
index 44c0c6547cbb1..7c72595ed624b 100644
--- a/cpp/src/arrow/flight/types.cc
+++ b/cpp/src/arrow/flight/types.cc
@@ -158,11 +158,6 @@ arrow::Result<std::unique_ptr<SchemaResult>> SchemaResult::Make(const Schema& sc
   return std::make_unique<SchemaResult>(std::move(schema_in));
 }
 
-Status SchemaResult::GetSchema(ipc::DictionaryMemo* dictionary_memo,
-                               std::shared_ptr<Schema>* out) const {
-  return GetSchema(dictionary_memo).Value(out);
-}
-
 std::string SchemaResult::ToString() const {
   return "<SchemaResult raw_schema=(serialized)>";
 }
@@ -206,10 +201,6 @@ arrow::Result<std::string> FlightDescriptor::SerializeToString() const {
   return out;
 }
 
-Status FlightDescriptor::SerializeToString(std::string* out) const {
-  return SerializeToString().Value(out);
-}
-
 arrow::Result<FlightDescriptor> FlightDescriptor::Deserialize(
     std::string_view serialized) {
   pb::FlightDescriptor pb_descriptor;
@@ -226,11 +217,6 @@ arrow::Result<FlightDescriptor> FlightDescriptor::Deserialize(
   return out;
 }
 
-Status FlightDescriptor::Deserialize(const std::string& serialized,
-                                     FlightDescriptor* out) {
-  return Deserialize(serialized).Value(out);
-}
-
 std::string Ticket::ToString() const {
   std::stringstream ss;
   ss << "<Ticket ticket='" << ticket << "'>";
@@ -250,10 +236,6 @@ arrow::Result<std::string> Ticket::SerializeToString() const {
   return out;
 }
 
-Status Ticket::SerializeToString(std::string* out) const {
-  return SerializeToString().Value(out);
-}
-
 arrow::Result<Ticket> Ticket::Deserialize(std::string_view serialized) {
   pb::Ticket pb_ticket;
   if (serialized.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
@@ -269,10 +251,6 @@ arrow::Result<Ticket> Ticket::Deserialize(std::string_view serialized) {
   return out;
 }
 
-Status Ticket::Deserialize(const std::string& serialized, Ticket* out) {
-  return Deserialize(serialized).Value(out);
-}
-
 arrow::Result<FlightInfo> FlightInfo::Make(const Schema& schema,
                                            const FlightDescriptor& descriptor,
                                            const std::vector<FlightEndpoint>& endpoints,
@@ -299,11 +277,6 @@ arrow::Result<std::shared_ptr<Schema>> FlightInfo::GetSchema(
   return schema_;
 }
 
-Status FlightInfo::GetSchema(ipc::DictionaryMemo* dictionary_memo,
-                             std::shared_ptr<Schema>* out) const {
-  return GetSchema(dictionary_memo).Value(out);
-}
-
 arrow::Result<std::string> FlightInfo::SerializeToString() const {
   pb::FlightInfo pb_info;
   RETURN_NOT_OK(internal::ToProto(*this, &pb_info));
@@ -315,10 +288,6 @@ arrow::Result<std::string> FlightInfo::SerializeToString() const {
   return out;
 }
 
-Status FlightInfo::SerializeToString(std::string* out) const {
-  return SerializeToString().Value(out);
-}
-
 arrow::Result<std::unique_ptr<FlightInfo>> FlightInfo::Deserialize(
     std::string_view serialized) {
   pb::FlightInfo pb_info;
@@ -335,11 +304,6 @@ arrow::Result<std::unique_ptr<FlightInfo>> FlightInfo::Deserialize(
   return std::make_unique<FlightInfo>(std::move(data));
 }
 
-Status FlightInfo::Deserialize(const std::string& serialized,
-                               std::unique_ptr<FlightInfo>* out) {
-  return Deserialize(serialized).Value(out);
-}
-
 std::string FlightInfo::ToString() const {
   std::stringstream ss;
   ss << "<FlightInfo schema=";
@@ -412,50 +376,30 @@ arrow::Result<CancelFlightInfoRequest> CancelFlightInfoRequest::Deserialize(
 
 Location::Location() { uri_ = std::make_shared<arrow::internal::Uri>(); }
 
-Status FlightListing::Next(std::unique_ptr<FlightInfo>* info) {
-  return Next().Value(info);
-}
-
 arrow::Result<Location> Location::Parse(const std::string& uri_string) {
   Location location;
   RETURN_NOT_OK(location.uri_->Parse(uri_string));
   return location;
 }
 
-Status Location::Parse(const std::string& uri_string, Location* location) {
-  return Parse(uri_string).Value(location);
-}
-
 arrow::Result<Location> Location::ForGrpcTcp(const std::string& host, const int port) {
   std::stringstream uri_string;
   uri_string << "grpc+tcp://" << host << ':' << port;
   return Location::Parse(uri_string.str());
 }
 
-Status Location::ForGrpcTcp(const std::string& host, const int port, Location* location) {
-  return ForGrpcTcp(host, port).Value(location);
-}
-
 arrow::Result<Location> Location::ForGrpcTls(const std::string& host, const int port) {
   std::stringstream uri_string;
   uri_string << "grpc+tls://" << host << ':' << port;
   return Location::Parse(uri_string.str());
 }
 
-Status Location::ForGrpcTls(const std::string& host, const int port, Location* location) {
-  return ForGrpcTls(host, port).Value(location);
-}
-
 arrow::Result<Location> Location::ForGrpcUnix(const std::string& path) {
   std::stringstream uri_string;
   uri_string << "grpc+unix://" << path;
   return Location::Parse(uri_string.str());
 }
 
-Status Location::ForGrpcUnix(const std::string& path, Location* location) {
-  return ForGrpcUnix(path).Value(location);
-}
-
 arrow::Result<Location> Location::ForScheme(const std::string& scheme,
                                             const std::string& host, const int port) {
   std::stringstream uri_string;
@@ -808,8 +752,6 @@ std::ostream& operator<<(std::ostream& os, CancelStatus status) {
   return os;
 }
 
-Status ResultStream::Next(std::unique_ptr<Result>* info) { return Next().Value(info); }
-
 Status ResultStream::Drain() {
   while (true) {
     ARROW_ASSIGN_OR_RAISE(auto result, Next());
@@ -818,10 +760,6 @@ Status ResultStream::Drain() {
   return Status::OK();
 }
 
-Status MetadataRecordBatchReader::Next(FlightStreamChunk* next) {
-  return Next().Value(next);
-}
-
 arrow::Result<std::vector<std::shared_ptr<RecordBatch>>>
 MetadataRecordBatchReader::ToRecordBatches() {
   std::vector<std::shared_ptr<RecordBatch>> batches;
@@ -833,21 +771,12 @@ MetadataRecordBatchReader::ToRecordBatches() {
   return batches;
 }
 
-Status MetadataRecordBatchReader::ReadAll(
-    std::vector<std::shared_ptr<RecordBatch>>* batches) {
-  return ToRecordBatches().Value(batches);
-}
-
 arrow::Result<std::shared_ptr<Table>> MetadataRecordBatchReader::ToTable() {
   ARROW_ASSIGN_OR_RAISE(auto batches, ToRecordBatches());
   ARROW_ASSIGN_OR_RAISE(auto schema, GetSchema());
   return Table::FromRecordBatches(schema, std::move(batches));
 }
 
-Status MetadataRecordBatchReader::ReadAll(std::shared_ptr<Table>* table) {
-  return ToTable().Value(table);
-}
-
 Status MetadataRecordBatchWriter::Begin(const std::shared_ptr<Schema>& schema) {
   return Begin(schema, ipc::IpcWriteOptions::Defaults());
 }
@@ -934,10 +863,6 @@ arrow::Result<BasicAuth> BasicAuth::Deserialize(std::string_view serialized) {
   return out;
 }
 
-Status BasicAuth::Deserialize(const std::string& serialized, BasicAuth* out) {
-  return Deserialize(serialized).Value(out);
-}
-
 arrow::Result<std::string> BasicAuth::SerializeToString() const {
   pb::BasicAuth pb_result;
   RETURN_NOT_OK(internal::ToProto(*this, &pb_result));
@@ -948,8 +873,5 @@ arrow::Result<std::string> BasicAuth::SerializeToString() const {
   return out;
 }
 
-Status BasicAuth::Serialize(const BasicAuth& basic_auth, std::string* out) {
-  return basic_auth.SerializeToString().Value(out);
-}
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/types.h b/cpp/src/arrow/flight/types.h
index 3cca774314017..ca86c27e86976 100644
--- a/cpp/src/arrow/flight/types.h
+++ b/cpp/src/arrow/flight/types.h
@@ -311,12 +311,6 @@ struct ARROW_FLIGHT_EXPORT BasicAuth {
   static arrow::Result<BasicAuth> Deserialize(std::string_view serialized);
   /// \brief Serialize this message to its wire-format representation.
   arrow::Result<std::string> SerializeToString() const;
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Deserialize(const std::string& serialized, BasicAuth* out);
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Serialize(const BasicAuth& basic_auth, std::string* out);
 };
 
 /// \brief A request to retrieve or generate a dataset
@@ -349,18 +343,12 @@ struct ARROW_FLIGHT_EXPORT FlightDescriptor {
   /// services) that may want to return Flight types.
   arrow::Result<std::string> SerializeToString() const;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status SerializeToString(std::string* out) const;
-
   /// \brief Parse the wire-format representation of this type.
   ///
   /// Useful when interoperating with non-Flight systems (e.g. REST
   /// services) that may want to return Flight types.
   static arrow::Result<FlightDescriptor> Deserialize(std::string_view serialized);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Deserialize(const std::string& serialized, FlightDescriptor* out);
-
   // Convenience factory functions
 
   static FlightDescriptor Command(const std::string& c) {
@@ -400,17 +388,11 @@ struct ARROW_FLIGHT_EXPORT Ticket {
   /// services) that may want to return Flight types.
   arrow::Result<std::string> SerializeToString() const;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status SerializeToString(std::string* out) const;
-
   /// \brief Parse the wire-format representation of this type.
   ///
   /// Useful when interoperating with non-Flight systems (e.g. REST
   /// services) that may want to return Flight types.
   static arrow::Result<Ticket> Deserialize(std::string_view serialized);
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Deserialize(const std::string& serialized, Ticket* out);
 };
 
 class FlightClient;
@@ -434,9 +416,6 @@ struct ARROW_FLIGHT_EXPORT Location {
   /// \brief Initialize a location by parsing a URI string
   static arrow::Result<Location> Parse(const std::string& uri_string);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Parse(const std::string& uri_string, Location* location);
-
   /// \brief Initialize a location for a non-TLS, gRPC-based Flight
   /// service from a host and port
   /// \param[in] host The hostname to connect to
@@ -444,9 +423,6 @@ struct ARROW_FLIGHT_EXPORT Location {
   /// \return Arrow result with the resulting location
   static arrow::Result<Location> ForGrpcTcp(const std::string& host, const int port);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status ForGrpcTcp(const std::string& host, const int port, Location* location);
-
   /// \brief Initialize a location for a TLS-enabled, gRPC-based Flight
   /// service from a host and port
   /// \param[in] host The hostname to connect to
@@ -454,18 +430,12 @@ struct ARROW_FLIGHT_EXPORT Location {
   /// \return Arrow result with the resulting location
   static arrow::Result<Location> ForGrpcTls(const std::string& host, const int port);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status ForGrpcTls(const std::string& host, const int port, Location* location);
-
   /// \brief Initialize a location for a domain socket-based Flight
   /// service
   /// \param[in] path The path to the domain socket
   /// \return Arrow result with the resulting location
   static arrow::Result<Location> ForGrpcUnix(const std::string& path);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status ForGrpcUnix(const std::string& path, Location* location);
-
   /// \brief Initialize a location based on a URI scheme
   static arrow::Result<Location> ForScheme(const std::string& scheme,
                                            const std::string& host, const int port);
@@ -576,10 +546,6 @@ struct ARROW_FLIGHT_EXPORT SchemaResult {
   arrow::Result<std::shared_ptr<Schema>> GetSchema(
       ipc::DictionaryMemo* dictionary_memo) const;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetSchema(ipc::DictionaryMemo* dictionary_memo,
-                   std::shared_ptr<Schema>* out) const;
-
   const std::string& serialized_schema() const { return raw_schema_; }
 
   std::string ToString() const;
@@ -633,10 +599,6 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
   arrow::Result<std::shared_ptr<Schema>> GetSchema(
       ipc::DictionaryMemo* dictionary_memo) const;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status GetSchema(ipc::DictionaryMemo* dictionary_memo,
-                   std::shared_ptr<Schema>* out) const;
-
   const std::string& serialized_schema() const { return data_.schema; }
 
   /// The descriptor associated with this flight, may not be set
@@ -661,9 +623,6 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
   /// services) that may want to return Flight types.
   arrow::Result<std::string> SerializeToString() const;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status SerializeToString(std::string* out) const;
-
   /// \brief Parse the wire-format representation of this type.
   ///
   /// Useful when interoperating with non-Flight systems (e.g. REST
@@ -671,10 +630,6 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
   static arrow::Result<std::unique_ptr<FlightInfo>> Deserialize(
       std::string_view serialized);
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  static Status Deserialize(const std::string& serialized,
-                            std::unique_ptr<FlightInfo>* out);
-
   std::string ToString() const;
 
   /// Compare two FlightInfo for equality. This will compare the
@@ -727,9 +682,6 @@ class ARROW_FLIGHT_EXPORT FlightListing {
   /// \return Arrow result with a single FlightInfo. Set to \a nullptr if there
   /// are none left.
   virtual arrow::Result<std::unique_ptr<FlightInfo>> Next() = 0;
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status Next(std::unique_ptr<FlightInfo>* info);
 };
 
 /// \brief An iterator to Result instances returned by DoAction.
@@ -741,9 +693,6 @@ class ARROW_FLIGHT_EXPORT ResultStream {
   /// \return Arrow result with a single Result. Set to \a nullptr if there are none left.
   virtual arrow::Result<std::unique_ptr<Result>> Next() = 0;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status Next(std::unique_ptr<Result>* info);
-
   /// \brief Read and drop the remaining messages to get the error (if any) from a server.
   /// \return Status OK if this is no error from a server, any other status if a
   /// server returns an error.
@@ -770,20 +719,11 @@ class ARROW_FLIGHT_EXPORT MetadataRecordBatchReader {
   /// nullptr.
   virtual arrow::Result<FlightStreamChunk> Next() = 0;
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use Result-returning overload instead.")
-  Status Next(FlightStreamChunk* next);
-
   /// \brief Consume entire stream as a vector of record batches
   virtual arrow::Result<std::vector<std::shared_ptr<RecordBatch>>> ToRecordBatches();
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToRecordBatches instead.")
-  Status ReadAll(std::vector<std::shared_ptr<RecordBatch>>* batches);
-
   /// \brief Consume entire stream as a Table
   virtual arrow::Result<std::shared_ptr<Table>> ToTable();
-
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToTable instead.")
-  Status ReadAll(std::shared_ptr<Table>* table);
 };
 
 /// \brief Convert a MetadataRecordBatchReader to a regular RecordBatchReader.
diff --git a/cpp/src/arrow/io/interfaces.h b/cpp/src/arrow/io/interfaces.h
index c5355c9422756..dcbe4feb261fb 100644
--- a/cpp/src/arrow/io/interfaces.h
+++ b/cpp/src/arrow/io/interfaces.h
@@ -96,10 +96,6 @@ struct ARROW_EXPORT IOContext {
   StopToken stop_token_;
 };
 
-struct ARROW_DEPRECATED("renamed to IOContext in 4.0.0") AsyncContext : public IOContext {
-  using IOContext::IOContext;
-};
-
 class ARROW_EXPORT FileInterface {
  public:
   virtual ~FileInterface() = 0;
diff --git a/cpp/src/arrow/record_batch.cc b/cpp/src/arrow/record_batch.cc
index 3ce99d6f84a40..683e72878b9b1 100644
--- a/cpp/src/arrow/record_batch.cc
+++ b/cpp/src/arrow/record_batch.cc
@@ -348,19 +348,11 @@ Result<RecordBatchVector> RecordBatchReader::ToRecordBatches() {
   return batches;
 }
 
-Status RecordBatchReader::ReadAll(RecordBatchVector* batches) {
-  return ToRecordBatches().Value(batches);
-}
-
 Result<std::shared_ptr<Table>> RecordBatchReader::ToTable() {
   ARROW_ASSIGN_OR_RAISE(auto batches, ToRecordBatches());
   return Table::FromRecordBatches(schema(), std::move(batches));
 }
 
-Status RecordBatchReader::ReadAll(std::shared_ptr<Table>* table) {
-  return ToTable().Value(table);
-}
-
 class SimpleRecordBatchReader : public RecordBatchReader {
  public:
   SimpleRecordBatchReader(Iterator<std::shared_ptr<RecordBatch>> it,
diff --git a/cpp/src/arrow/record_batch.h b/cpp/src/arrow/record_batch.h
index 8f9b5882d93ac..d728d5eb0da2f 100644
--- a/cpp/src/arrow/record_batch.h
+++ b/cpp/src/arrow/record_batch.h
@@ -326,15 +326,9 @@ class ARROW_EXPORT RecordBatchReader {
   /// \brief Consume entire stream as a vector of record batches
   Result<RecordBatchVector> ToRecordBatches();
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToRecordBatches instead.")
-  Status ReadAll(RecordBatchVector* batches);
-
   /// \brief Read all batches and concatenate as arrow::Table
   Result<std::shared_ptr<Table>> ToTable();
 
-  ARROW_DEPRECATED("Deprecated in 8.0.0. Use ToTable instead.")
-  Status ReadAll(std::shared_ptr<Table>* table);
-
   /// \brief Create a RecordBatchReader from a vector of RecordBatch.
   ///
   /// \param[in] batches the vector of RecordBatch to read from
diff --git a/cpp/src/arrow/record_batch_test.cc b/cpp/src/arrow/record_batch_test.cc
index def6dbc54edcb..4975e94325d32 100644
--- a/cpp/src/arrow/record_batch_test.cc
+++ b/cpp/src/arrow/record_batch_test.cc
@@ -496,32 +496,4 @@ TEST_F(TestRecordBatchReader, ToTable) {
   ASSERT_EQ(table->column(0)->chunks().size(), 0);
 }
 
-ARROW_SUPPRESS_DEPRECATION_WARNING
-TEST_F(TestRecordBatchReader, DeprecatedReadAllToRecordBatches) {
-  RecordBatchVector batches;
-  ASSERT_OK(reader_->ReadAll(&batches));
-  ASSERT_EQ(batches.size(), batches_.size());
-  for (size_t index = 0; index < batches.size(); index++) {
-    AssertBatchesEqual(*batches[index], *batches_[index]);
-  }
-
-  ASSERT_OK(reader_->ReadAll(&batches));
-  ASSERT_EQ(batches.size(), 0);
-}
-
-TEST_F(TestRecordBatchReader, DeprecatedReadAllToTable) {
-  std::shared_ptr<Table> table;
-
-  ASSERT_OK(reader_->ReadAll(&table));
-  const auto& chunks = table->column(0)->chunks();
-  ASSERT_EQ(chunks.size(), batches_.size());
-  for (size_t index = 0; index < batches_.size(); index++) {
-    AssertArraysEqual(*chunks[index], *batches_[index]->column(0));
-  }
-
-  ASSERT_OK(reader_->ReadAll(&table));
-  ASSERT_EQ(table->column(0)->chunks().size(), 0);
-}
-ARROW_UNSUPPRESS_DEPRECATION_WARNING
-
 }  // namespace arrow
diff --git a/cpp/src/arrow/table_builder.cc b/cpp/src/arrow/table_builder.cc
index 414aa263cc7f0..19ca151ac200f 100644
--- a/cpp/src/arrow/table_builder.cc
+++ b/cpp/src/arrow/table_builder.cc
@@ -36,19 +36,6 @@ RecordBatchBuilder::RecordBatchBuilder(const std::shared_ptr<Schema>& schema,
                                        MemoryPool* pool, int64_t initial_capacity)
     : schema_(schema), initial_capacity_(initial_capacity), pool_(pool) {}
 
-Status RecordBatchBuilder::Make(const std::shared_ptr<Schema>& schema, MemoryPool* pool,
-                                std::unique_ptr<RecordBatchBuilder>* builder) {
-  ARROW_ASSIGN_OR_RAISE(*builder, Make(schema, pool, kMinBuilderCapacity))
-  return Status::OK();
-}
-
-Status RecordBatchBuilder::Make(const std::shared_ptr<Schema>& schema, MemoryPool* pool,
-                                int64_t initial_capacity,
-                                std::unique_ptr<RecordBatchBuilder>* builder) {
-  ARROW_ASSIGN_OR_RAISE(*builder, Make(schema, pool, initial_capacity))
-  return Status::OK();
-}
-
 Result<std::unique_ptr<RecordBatchBuilder>> RecordBatchBuilder::Make(
     const std::shared_ptr<Schema>& schema, MemoryPool* pool) {
   return Make(schema, pool, kMinBuilderCapacity);
@@ -63,17 +50,6 @@ Result<std::unique_ptr<RecordBatchBuilder>> RecordBatchBuilder::Make(
   return std::move(builder);
 }
 
-Status RecordBatchBuilder::Flush(bool reset_builders,
-                                 std::shared_ptr<RecordBatch>* batch) {
-  ARROW_ASSIGN_OR_RAISE(*batch, Flush(reset_builders));
-  return Status::OK();
-}
-
-Status RecordBatchBuilder::Flush(std::shared_ptr<RecordBatch>* batch) {
-  ARROW_ASSIGN_OR_RAISE(*batch, Flush(true));
-  return Status::OK();
-}
-
 Result<std::shared_ptr<RecordBatch>> RecordBatchBuilder::Flush(bool reset_builders) {
   std::vector<std::shared_ptr<Array>> fields;
   fields.resize(this->num_fields());
diff --git a/cpp/src/arrow/table_builder.h b/cpp/src/arrow/table_builder.h
index 65ebd86ea416e..671cc4ab97996 100644
--- a/cpp/src/arrow/table_builder.h
+++ b/cpp/src/arrow/table_builder.h
@@ -38,24 +38,6 @@ class RecordBatch;
 /// schema
 class ARROW_EXPORT RecordBatchBuilder {
  public:
-  /// \brief Create and initialize a RecordBatchBuilder
-  /// \param[in] schema The schema for the record batch
-  /// \param[in] pool A MemoryPool to use for allocations
-  /// \param[in] builder the created builder instance
-  ARROW_DEPRECATED("Deprecated in 9.0.0. Use Result-returning variant.")
-  static Status Make(const std::shared_ptr<Schema>& schema, MemoryPool* pool,
-                     std::unique_ptr<RecordBatchBuilder>* builder);
-
-  /// \brief Create and initialize a RecordBatchBuilder
-  /// \param[in] schema The schema for the record batch
-  /// \param[in] pool A MemoryPool to use for allocations
-  /// \param[in] initial_capacity The initial capacity for the builders
-  /// \param[in] builder the created builder instance
-  ARROW_DEPRECATED("Deprecated in 9.0.0. Use Result-returning variant.")
-  static Status Make(const std::shared_ptr<Schema>& schema, MemoryPool* pool,
-                     int64_t initial_capacity,
-                     std::unique_ptr<RecordBatchBuilder>* builder);
-
   /// \brief Create and initialize a RecordBatchBuilder
   /// \param[in] schema The schema for the record batch
   /// \param[in] pool A MemoryPool to use for allocations
@@ -84,19 +66,6 @@ class ARROW_EXPORT RecordBatchBuilder {
     return internal::checked_cast<T*>(raw_field_builders_[i]);
   }
 
-  /// \brief Finish current batch and optionally reset
-  /// \param[in] reset_builders the resulting RecordBatch
-  /// \param[out] batch the resulting RecordBatch
-  /// \return Status
-  ARROW_DEPRECATED("Deprecated in 9.0.0. Use Result-returning variant.")
-  Status Flush(bool reset_builders, std::shared_ptr<RecordBatch>* batch);
-
-  /// \brief Finish current batch and reset
-  /// \param[out] batch the resulting RecordBatch
-  /// \return Status
-  ARROW_DEPRECATED("Deprecated in 9.0.0. Use Result-returning variant.")
-  Status Flush(std::shared_ptr<RecordBatch>* batch);
-
   /// \brief Finish current batch and optionally reset
   /// \param[in] reset_builders the resulting RecordBatch
   /// \return the resulting RecordBatch
diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc
index 855fb5a5a4882..142119b770b8c 100644
--- a/cpp/src/parquet/arrow/reader.cc
+++ b/cpp/src/parquet/arrow/reader.cc
@@ -259,16 +259,6 @@ class FileReaderImpl : public FileReader {
                              reader_->metadata()->key_value_metadata(), out);
   }
 
-  Status ReadSchemaField(int i, std::shared_ptr<ChunkedArray>* out) override {
-    auto included_leaves = VectorToSharedSet(Iota(reader_->metadata()->num_columns()));
-    std::vector<int> row_groups = Iota(reader_->metadata()->num_row_groups());
-
-    std::unique_ptr<ColumnReaderImpl> reader;
-    RETURN_NOT_OK(GetFieldReader(i, included_leaves, row_groups, &reader));
-
-    return ReadColumn(i, row_groups, reader.get(), out);
-  }
-
   Status ReadColumn(int i, const std::vector<int>& row_groups, ColumnReader* reader,
                     std::shared_ptr<ChunkedArray>* out) {
     BEGIN_PARQUET_CATCH_EXCEPTIONS
diff --git a/cpp/src/parquet/arrow/reader.h b/cpp/src/parquet/arrow/reader.h
index 2cbd36176f5e3..6e46ca43f7b18 100644
--- a/cpp/src/parquet/arrow/reader.h
+++ b/cpp/src/parquet/arrow/reader.h
@@ -141,26 +141,19 @@ class PARQUET_EXPORT FileReader {
 
   /// \brief Read column as a whole into a chunked array.
   ///
-  /// The indicated column index is relative to the schema
+  /// The index i refers the index of the top level schema field, which may
+  /// be nested or flat - e.g.
+  ///
+  /// 0 foo.bar
+  ///   foo.bar.baz
+  ///   foo.qux
+  /// 1 foo2
+  /// 2 foo3
+  ///
+  /// i=0 will read the entire foo struct, i=1 the foo2 primitive column etc
   virtual ::arrow::Status ReadColumn(int i,
                                      std::shared_ptr<::arrow::ChunkedArray>* out) = 0;
 
-  // NOTE: Experimental API
-  // Reads a specific top level schema field into an Array
-  // The index i refers the index of the top level schema field, which may
-  // be nested or flat - e.g.
-  //
-  // 0 foo.bar
-  //   foo.bar.baz
-  //   foo.qux
-  // 1 foo2
-  // 2 foo3
-  //
-  // i=0 will read the entire foo struct, i=1 the foo2 primitive column etc
-  ARROW_DEPRECATED("Deprecated in 9.0.0. Use ReadColumn instead.")
-  virtual ::arrow::Status ReadSchemaField(
-      int i, std::shared_ptr<::arrow::ChunkedArray>* out) = 0;
-
   /// \brief Return a RecordBatchReader of all row groups and columns.
   virtual ::arrow::Status GetRecordBatchReader(
       std::unique_ptr<::arrow::RecordBatchReader>* out) = 0;

From 80f77d1371ef93c946b08c3c2a05d269c8548c74 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Wed, 19 Jul 2023 16:52:53 +0800
Subject: [PATCH 011/749] GH-36762: [Dev] Remove only component labels when an
 issue is updated (#36763)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

A follow-up of https://github.com/apache/arrow/pull/36723#issuecomment-1640816772.

### What changes are included in this PR?

Non-component labels should be kept when the issue is updated.

### Are these changes tested?

It is tested on my fork. See https://github.com/js8544/arrow/issues/2
### Are there any user-facing changes?
 No.

* Closes: #36762

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .github/workflows/issue_bot.yml | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/issue_bot.yml b/.github/workflows/issue_bot.yml
index 7a62f2149662e..ae344a4c1eba9 100644
--- a/.github/workflows/issue_bot.yml
+++ b/.github/workflows/issue_bot.yml
@@ -39,6 +39,20 @@ jobs:
             let split_body = context.payload.issue.body.split('### Component(s)');
             if (split_body.length != 2) throw new Error('No components found!');
 
+            let current_labels = await github.rest.issues.listLabelsOnIssue({
+              "owner": context.repo.owner,
+              "repo": context.repo.repo,
+              "per_page": 100,
+              "issue_number": context.payload.issue.number,
+            });
+
+            let current_label_names = current_labels.data.map(label => label.name);
+
+            // keep non-component labels
+            let non_component_labels = current_label_names.filter(
+              label => !label.startsWith("Component: ")
+            );
+
             let component_labels = split_body[1]
               .split(',')
               .map(component => component.trim())
@@ -61,5 +75,5 @@ jobs:
               "owner": context.repo.owner,
               "repo": context.repo.repo,
               "issue_number": context.payload.issue.number,
-              "labels": component_labels,
+              "labels": component_labels.concat(non_component_labels),
             });

From 366e8083a2bd6d24ad371548699ef936fb7bb468 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 19 Jul 2023 11:19:49 +0200
Subject: [PATCH 012/749] GH-35116: [CI][C++] Enable compile-time AVX2 on some
 CI platforms (#36662)

AVX2 became mainline on Intel and AMD server CPUs around 2015, so it's unlikely to be unavailable on current cloud platforms:
https://en.wikipedia.org/wiki/Advanced_Vector_Extensions#CPUs_with_AVX2

Enable it at least on one Windows and one Linux CI platform.

x86 macOS is a legacy platform, so less interesting to exercise there (and I'm not sure the old CPUs in x86 Macs actually support AVX2).

Also, fix the buggy AVX2 activation logic in Acero and avoid force-testing AVX2 on incompatible systems.

* Closes: #35116

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .github/workflows/cpp.yml                     | 14 ++-
 ci/scripts/cpp_build.sh                       |  1 +
 cpp/cmake_modules/SetupCxxFlags.cmake         | 49 +++++-----
 cpp/src/arrow/CMakeLists.txt                  | 22 ++---
 cpp/src/arrow/acero/CMakeLists.txt            |  6 +-
 cpp/src/arrow/acero/bloom_filter.cc           |  8 +-
 cpp/src/arrow/acero/bloom_filter.h            |  5 +-
 cpp/src/arrow/acero/bloom_filter_avx2.cc      |  5 +-
 cpp/src/arrow/acero/bloom_filter_test.cc      | 85 ++++++++---------
 cpp/src/arrow/acero/swiss_join_avx2.cc        |  4 -
 cpp/src/arrow/acero/swiss_join_internal.h     |  2 +-
 cpp/src/arrow/acero/test_util_internal.cc     |  9 ++
 cpp/src/arrow/acero/test_util_internal.h      | 12 ++-
 cpp/src/arrow/compute/kernels/CMakeLists.txt  | 54 ++++++++---
 cpp/src/arrow/compute/key_hash.cc             |  6 +-
 cpp/src/arrow/compute/key_hash.h              |  4 +-
 cpp/src/arrow/compute/key_hash_avx2.cc        |  4 -
 cpp/src/arrow/compute/key_hash_test.cc        | 92 ++++++++++---------
 cpp/src/arrow/compute/key_map.cc              |  4 +-
 cpp/src/arrow/compute/key_map.h               |  2 +-
 cpp/src/arrow/compute/key_map_avx2.cc         |  4 -
 cpp/src/arrow/compute/row/compare_internal.cc |  8 +-
 cpp/src/arrow/compute/row/compare_internal.h  |  2 +-
 .../compute/row/compare_internal_avx2.cc      |  4 -
 cpp/src/arrow/compute/row/encode_internal.cc  | 10 +-
 cpp/src/arrow/compute/row/encode_internal.h   |  6 +-
 .../arrow/compute/row/encode_internal_avx2.cc |  4 -
 cpp/src/arrow/compute/util.cc                 | 10 +-
 cpp/src/arrow/compute/util.h                  |  2 +-
 cpp/src/arrow/compute/util_avx2.cc            |  8 +-
 cpp/src/arrow/testing/util.cc                 | 15 +++
 cpp/src/arrow/testing/util.h                  |  6 ++
 cpp/src/arrow/util/byte_stream_split.h        | 28 +++---
 docker-compose.yml                            | 30 +++---
 34 files changed, 289 insertions(+), 236 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 67435566ce305..63a16c8c114ba 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -67,7 +67,8 @@ jobs:
             image: conda-cpp
             llvm: "14"
             runs-on: ubuntu-latest
-            title: AMD64 Conda C++
+            simd-level: AVX2
+            title: AMD64 Conda C++ AVX2
             ubuntu: "22.04"
           - arch: amd64
             clang-tools: "14"
@@ -85,6 +86,7 @@ jobs:
             ubuntu: "20.04"
     env:
       ARCH: ${{ matrix.arch }}
+      ARROW_SIMD_LEVEL: ${{ matrix.simd-level }}
       CLANG_TOOLS: ${{ matrix.clang-tools }}
       LLVM: ${{ matrix.llvm }}
       UBUNTU: ${{ matrix.ubuntu }}
@@ -175,6 +177,10 @@ jobs:
       ARROW_WITH_ZSTD: ON
       GTest_SOURCE: BUNDLED
     steps:
+      - name: CPU Info
+        run: |
+          sysctl -a | grep cpu
+          sysctl -a | grep "hw.optional"
       - name: Checkout Arrow
         uses: actions/checkout@v3
         with:
@@ -220,7 +226,7 @@ jobs:
           ci/scripts/cpp_test.sh $(pwd) $(pwd)/build
 
   windows:
-    name: AMD64 ${{ matrix.name }} C++17
+    name: ${{ matrix.title }}
     runs-on: ${{ matrix.os }}
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     timeout-minutes: 60
@@ -231,7 +237,8 @@ jobs:
           - windows-2019
         include:
           - os: windows-2019
-            name: Windows 2019
+            simd-level: AVX2
+            title: AMD64 Windows 2019 C++17 AVX2
     env:
       ARROW_BOOST_USE_SHARED: OFF
       ARROW_BUILD_BENCHMARKS: ON
@@ -246,6 +253,7 @@ jobs:
       ARROW_MIMALLOC: ON
       ARROW_ORC: ON
       ARROW_PARQUET: ON
+      ARROW_SIMD_LEVEL: ${{ matrix.simd-level }}
       ARROW_USE_GLOG: OFF
       ARROW_VERBOSE_THIRDPARTY_BUILD: OFF
       ARROW_WITH_BROTLI: OFF
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index f0f893c419616..e53b3fa460915 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -126,6 +126,7 @@ cmake \
   -DARROW_PARQUET=${ARROW_PARQUET:-OFF} \
   -DARROW_RUNTIME_SIMD_LEVEL=${ARROW_RUNTIME_SIMD_LEVEL:-MAX} \
   -DARROW_S3=${ARROW_S3:-OFF} \
+  -DARROW_SIMD_LEVEL=${ARROW_SIMD_LEVEL:-DEFAULT} \
   -DARROW_SKYHOOK=${ARROW_SKYHOOK:-OFF} \
   -DARROW_SUBSTRAIT=${ARROW_SUBSTRAIT:-ON} \
   -DARROW_TEST_LINKAGE=${ARROW_TEST_LINKAGE:-shared} \
diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 076c2e7450798..6b47fcb717287 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -62,29 +62,32 @@ if(ARROW_CPU_FLAG STREQUAL "x86")
         "${ARROW_AVX512_FLAG} -mavx512f -mavx512cd -mavx512vl -mavx512dq -mavx512bw")
     check_cxx_compiler_flag(${ARROW_SSE4_2_FLAG} CXX_SUPPORTS_SSE4_2)
   endif()
-  check_cxx_compiler_flag(${ARROW_AVX2_FLAG} CXX_SUPPORTS_AVX2)
-  if(MINGW)
-    # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65782
-    message(STATUS "Disable AVX512 support on MINGW for now")
-  else()
-    # Check for AVX512 support in the compiler.
-    set(OLD_CMAKE_REQURED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${ARROW_AVX512_FLAG}")
-    check_cxx_source_compiles("
-      #ifdef _MSC_VER
-      #include <intrin.h>
-      #else
-      #include <immintrin.h>
-      #endif
-
-      int main() {
-        __m512i mask = _mm512_set1_epi32(0x1);
-        char out[32];
-        _mm512_storeu_si512(out, mask);
-        return 0;
-      }"
-                              CXX_SUPPORTS_AVX512)
-    set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQURED_FLAGS})
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    # Check for AVX extensions on 64-bit systems only, as 32-bit support seems iffy
+    check_cxx_compiler_flag(${ARROW_AVX2_FLAG} CXX_SUPPORTS_AVX2)
+    if(MINGW)
+      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65782
+      message(STATUS "Disable AVX512 support on MINGW for now")
+    else()
+      # Check for AVX512 support in the compiler.
+      set(OLD_CMAKE_REQURED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${ARROW_AVX512_FLAG}")
+      check_cxx_source_compiles("
+        #ifdef _MSC_VER
+        #include <intrin.h>
+        #else
+        #include <immintrin.h>
+        #endif
+
+        int main() {
+          __m512i mask = _mm512_set1_epi32(0x1);
+          char out[32];
+          _mm512_storeu_si512(out, mask);
+          return 0;
+        }"
+                                CXX_SUPPORTS_AVX512)
+      set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQURED_FLAGS})
+    endif()
   endif()
   # Runtime SIMD level it can get from compiler and ARROW_RUNTIME_SIMD_LEVEL
   if(CXX_SUPPORTS_SSE4_2 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index fccff6c8cf1a9..a398e790de14b 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -119,7 +119,7 @@ function(ADD_ARROW_BENCHMARK REL_TEST_NAME)
                 ${ARG_UNPARSED_ARGUMENTS})
 endfunction()
 
-macro(append_avx2_src SRC)
+macro(append_runtime_avx2_src SRC)
   if(ARROW_HAVE_RUNTIME_AVX2)
     list(APPEND ARROW_SRCS ${SRC})
     set_source_files_properties(${SRC} PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
@@ -127,7 +127,7 @@ macro(append_avx2_src SRC)
   endif()
 endmacro()
 
-macro(append_avx512_src SRC)
+macro(append_runtime_avx512_src SRC)
   if(ARROW_HAVE_RUNTIME_AVX512)
     list(APPEND ARROW_SRCS ${SRC})
     set_source_files_properties(${SRC} PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
@@ -254,8 +254,8 @@ if(ARROW_JEMALLOC)
                               PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 endif()
 
-append_avx2_src(util/bpacking_avx2.cc)
-append_avx512_src(util/bpacking_avx512.cc)
+append_runtime_avx2_src(util/bpacking_avx2.cc)
+append_runtime_avx512_src(util/bpacking_avx512.cc)
 
 if(ARROW_HAVE_NEON)
   list(APPEND ARROW_SRCS util/bpacking_neon.cc)
@@ -425,11 +425,11 @@ list(APPEND
      compute/row/row_internal.cc
      compute/util.cc)
 
-append_avx2_src(compute/key_hash_avx2.cc)
-append_avx2_src(compute/key_map_avx2.cc)
-append_avx2_src(compute/row/compare_internal_avx2.cc)
-append_avx2_src(compute/row/encode_internal_avx2.cc)
-append_avx2_src(compute/util_avx2.cc)
+append_runtime_avx2_src(compute/key_hash_avx2.cc)
+append_runtime_avx2_src(compute/key_map_avx2.cc)
+append_runtime_avx2_src(compute/row/compare_internal_avx2.cc)
+append_runtime_avx2_src(compute/row/encode_internal_avx2.cc)
+append_runtime_avx2_src(compute/util_avx2.cc)
 
 if(ARROW_COMPUTE)
   # Include the remaining kernels
@@ -464,8 +464,8 @@ if(ARROW_COMPUTE)
        compute/kernels/vector_select_k.cc
        compute/kernels/vector_sort.cc)
 
-  append_avx2_src(compute/kernels/aggregate_basic_avx2.cc)
-  append_avx512_src(compute/kernels/aggregate_basic_avx512.cc)
+  append_runtime_avx2_src(compute/kernels/aggregate_basic_avx2.cc)
+  append_runtime_avx512_src(compute/kernels/aggregate_basic_avx512.cc)
 endif()
 
 if(ARROW_FILESYSTEM)
diff --git a/cpp/src/arrow/acero/CMakeLists.txt b/cpp/src/arrow/acero/CMakeLists.txt
index 287884432b9fe..c2c91db58d38a 100644
--- a/cpp/src/arrow/acero/CMakeLists.txt
+++ b/cpp/src/arrow/acero/CMakeLists.txt
@@ -19,7 +19,7 @@ add_custom_target(arrow_acero)
 
 arrow_install_all_headers("arrow/acero")
 
-macro(append_acero_avx2_src SRC)
+macro(append_acero_runtime_avx2_src SRC)
   if(ARROW_HAVE_RUNTIME_AVX2)
     list(APPEND ARROW_ACERO_SRCS ${SRC})
     set_source_files_properties(${SRC} PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
@@ -56,8 +56,8 @@ set(ARROW_ACERO_SRCS
     union_node.cc
     util.cc)
 
-append_acero_avx2_src(bloom_filter_avx2.cc)
-append_acero_avx2_src(swiss_join_avx2.cc)
+append_acero_runtime_avx2_src(bloom_filter_avx2.cc)
+append_acero_runtime_avx2_src(swiss_join_avx2.cc)
 
 set(ARROW_ACERO_SHARED_LINK_LIBS)
 set(ARROW_ACERO_STATIC_LINK_LIBS)
diff --git a/cpp/src/arrow/acero/bloom_filter.cc b/cpp/src/arrow/acero/bloom_filter.cc
index ad5e66ded0613..b9855ee506d27 100644
--- a/cpp/src/arrow/acero/bloom_filter.cc
+++ b/cpp/src/arrow/acero/bloom_filter.cc
@@ -123,7 +123,7 @@ void BlockedBloomFilter::InsertImp(int64_t num_rows, const T* hashes) {
 void BlockedBloomFilter::Insert(int64_t hardware_flags, int64_t num_rows,
                                 const uint32_t* hashes) {
   int64_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     num_processed = Insert_avx2(num_rows, hashes);
   }
@@ -134,7 +134,7 @@ void BlockedBloomFilter::Insert(int64_t hardware_flags, int64_t num_rows,
 void BlockedBloomFilter::Insert(int64_t hardware_flags, int64_t num_rows,
                                 const uint64_t* hashes) {
   int64_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     num_processed = Insert_avx2(num_rows, hashes);
   }
@@ -181,7 +181,7 @@ void BlockedBloomFilter::Find(int64_t hardware_flags, int64_t num_rows,
                               bool enable_prefetch) const {
   int64_t num_processed = 0;
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (!(enable_prefetch && UsePrefetch()) &&
       (hardware_flags & arrow::internal::CpuInfo::AVX2)) {
     num_processed = Find_avx2(num_rows, hashes, result_bit_vector);
@@ -202,7 +202,7 @@ void BlockedBloomFilter::Find(int64_t hardware_flags, int64_t num_rows,
                               bool enable_prefetch) const {
   int64_t num_processed = 0;
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (!(enable_prefetch && UsePrefetch()) &&
       (hardware_flags & arrow::internal::CpuInfo::AVX2)) {
     num_processed = Find_avx2(num_rows, hashes, result_bit_vector);
diff --git a/cpp/src/arrow/acero/bloom_filter.h b/cpp/src/arrow/acero/bloom_filter.h
index b8f7f8cd256b1..50d07bfd948e0 100644
--- a/cpp/src/arrow/acero/bloom_filter.h
+++ b/cpp/src/arrow/acero/bloom_filter.h
@@ -17,13 +17,14 @@
 
 #pragma once
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
 #include <immintrin.h>
 #endif
 
 #include <atomic>
 #include <cstdint>
 #include <memory>
+
 #include "arrow/acero/partition_util.h"
 #include "arrow/acero/util.h"
 #include "arrow/memory_pool.h"
@@ -203,7 +204,7 @@ class ARROW_ACERO_EXPORT BlockedBloomFilter {
 
   void SingleFold(int num_folds);
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   inline __m256i mask_avx2(__m256i hash) const;
   inline __m256i block_id_avx2(__m256i hash) const;
   int64_t Insert_avx2(int64_t num_rows, const uint32_t* hashes);
diff --git a/cpp/src/arrow/acero/bloom_filter_avx2.cc b/cpp/src/arrow/acero/bloom_filter_avx2.cc
index b6c281276db8d..5816bb4fc0a32 100644
--- a/cpp/src/arrow/acero/bloom_filter_avx2.cc
+++ b/cpp/src/arrow/acero/bloom_filter_avx2.cc
@@ -16,14 +16,13 @@
 // under the License.
 
 #include <immintrin.h>
+
 #include "arrow/acero/bloom_filter.h"
 #include "arrow/util/bit_util.h"
 
 namespace arrow {
 namespace acero {
 
-#if defined(ARROW_HAVE_AVX2)
-
 inline __m256i BlockedBloomFilter::mask_avx2(__m256i hash) const {
   // AVX2 translation of mask() method
   //
@@ -132,7 +131,5 @@ int64_t BlockedBloomFilter::Insert_avx2(int64_t num_rows, const uint64_t* hashes
   return InsertImp_avx2(num_rows, hashes);
 }
 
-#endif
-
 }  // namespace acero
 }  // namespace arrow
diff --git a/cpp/src/arrow/acero/bloom_filter_test.cc b/cpp/src/arrow/acero/bloom_filter_test.cc
index de433ac68c11a..95375e277e2b8 100644
--- a/cpp/src/arrow/acero/bloom_filter_test.cc
+++ b/cpp/src/arrow/acero/bloom_filter_test.cc
@@ -22,13 +22,13 @@
 #include <condition_variable>
 #include <thread>
 #include <unordered_set>
+
 #include "arrow/acero/bloom_filter.h"
 #include "arrow/acero/task_util.h"
 #include "arrow/acero/test_util_internal.h"
 #include "arrow/acero/util.h"
 #include "arrow/compute/key_hash.h"
 #include "arrow/util/bitmap_ops.h"
-#include "arrow/util/cpu_info.h"
 
 namespace arrow {
 
@@ -171,9 +171,7 @@ void TestBloomSmallHashHelper(int64_t num_input_hashes, const T* input_hashes,
 // Output FPR and build and probe cost.
 //
 void TestBloomSmall(BloomFilterBuildStrategy strategy, int64_t num_build,
-                    int num_build_copies, bool use_simd, bool enable_prefetch) {
-  int64_t hardware_flags = use_simd ? ::arrow::internal::CpuInfo::AVX2 : 0;
-
+                    int num_build_copies, int64_t hardware_flags, bool enable_prefetch) {
   // Generate input keys
   //
   int64_t num_probe = 4 * num_build;
@@ -324,10 +322,8 @@ void TestBloomLargeHashHelper(int64_t hardware_flags, int64_t block,
 // Test with larger size Bloom filters (use large prime with arithmetic
 // sequence modulo 2^64).
 //
-void TestBloomLarge(BloomFilterBuildStrategy strategy, int64_t num_build, bool use_simd,
-                    bool enable_prefetch) {
-  int64_t hardware_flags = use_simd ? ::arrow::internal::CpuInfo::AVX2 : 0;
-
+void TestBloomLarge(BloomFilterBuildStrategy strategy, int64_t num_build,
+                    int64_t hardware_flags, bool enable_prefetch) {
   // Largest 63-bit prime
   constexpr uint64_t prime = 0x7FFFFFFFFFFFFFE7ULL;
 
@@ -458,42 +454,40 @@ TEST(BloomFilter, Basic) {
   num_build.push_back(1LL << log_large);
 #endif
 
-  constexpr int num_param_sets = 3;
-  struct {
-    bool use_avx2;
+  struct TestParam {
+    int64_t hardware_flags;
     bool enable_prefetch;
     bool insert_multiple_copies;
-  } params[num_param_sets];
-  for (int i = 0; i < num_param_sets; ++i) {
-    params[i].use_avx2 = (i == 1);
-    params[i].enable_prefetch = (i == 2);
-    params[i].insert_multiple_copies = (i == 3);
+  };
+  std::vector<TestParam> test_params;
+  for (const auto hardware_flags : HardwareFlagsForTesting()) {
+    test_params.push_back({hardware_flags, false, false});
   }
+  test_params.push_back({0, true, false});
+  test_params.push_back({0, false, true});
 
-  std::vector<BloomFilterBuildStrategy> strategy;
-  strategy.push_back(BloomFilterBuildStrategy::SINGLE_THREADED);
+  std::vector<BloomFilterBuildStrategy> strategies;
+  strategies.push_back(BloomFilterBuildStrategy::SINGLE_THREADED);
 #ifndef ARROW_VALGRIND
-  strategy.push_back(BloomFilterBuildStrategy::PARALLEL);
+  strategies.push_back(BloomFilterBuildStrategy::PARALLEL);
 #endif
 
   static constexpr int64_t min_rows_for_large = 2 * 1024 * 1024;
 
-  for (size_t istrategy = 0; istrategy < strategy.size(); ++istrategy) {
-    for (int iparam_set = 0; iparam_set < num_param_sets; ++iparam_set) {
-      ARROW_SCOPED_TRACE("%s ", params[iparam_set].use_avx2                 ? "AVX2"
-                                : params[iparam_set].enable_prefetch        ? "PREFETCH"
-                                : params[iparam_set].insert_multiple_copies ? "FOLDING"
-                                                                            : "REGULAR");
-      for (size_t inum_build = 0; inum_build < num_build.size(); ++inum_build) {
-        ARROW_SCOPED_TRACE("num_build ", static_cast<int>(num_build[inum_build]));
-        if (num_build[inum_build] >= min_rows_for_large) {
-          TestBloomLarge(strategy[istrategy], num_build[inum_build],
-                         params[iparam_set].use_avx2, params[iparam_set].enable_prefetch);
+  for (const auto& strategy : strategies) {
+    for (const auto& test_param : test_params) {
+      ARROW_SCOPED_TRACE("hardware_flags = ", test_param.hardware_flags,
+                         test_param.enable_prefetch ? " PREFETCH" : "",
+                         test_param.insert_multiple_copies ? " FOLDING" : "REGULAR");
+      for (const auto n : num_build) {
+        ARROW_SCOPED_TRACE("num_build ", n);
+        if (n >= min_rows_for_large) {
+          TestBloomLarge(strategy, n, test_param.hardware_flags,
+                         test_param.enable_prefetch);
 
         } else {
-          TestBloomSmall(strategy[istrategy], num_build[inum_build],
-                         params[iparam_set].insert_multiple_copies ? 8 : 1,
-                         params[iparam_set].use_avx2, params[iparam_set].enable_prefetch);
+          TestBloomSmall(strategy, n, test_param.insert_multiple_copies ? 8 : 1,
+                         test_param.hardware_flags, test_param.enable_prefetch);
         }
       }
     }
@@ -506,19 +500,18 @@ TEST(BloomFilter, Scaling) {
   num_build.push_back(1000000);
   num_build.push_back(4000000);
 
-  std::vector<BloomFilterBuildStrategy> strategy;
-  strategy.push_back(BloomFilterBuildStrategy::PARALLEL);
-
-  for (bool use_avx2 : {false, true}) {
-    for (size_t istrategy = 0; istrategy < strategy.size(); ++istrategy) {
-      for (size_t inum_build = 0; inum_build < num_build.size(); ++inum_build) {
-        ARROW_SCOPED_TRACE("num_build = ", static_cast<int>(num_build[inum_build]));
-        ARROW_SCOPED_TRACE("strategy = ",
-                           strategy[istrategy] == BloomFilterBuildStrategy::PARALLEL
-                               ? "PARALLEL"
-                               : "SINGLE_THREADED");
-        ARROW_SCOPED_TRACE("avx2 = ", use_avx2 ? "AVX2" : "SCALAR");
-        TestBloomLarge(strategy[istrategy], num_build[inum_build], use_avx2,
+  std::vector<BloomFilterBuildStrategy> strategies;
+  strategies.push_back(BloomFilterBuildStrategy::PARALLEL);
+
+  for (const auto hardware_flags : HardwareFlagsForTesting()) {
+    for (const auto& strategy : strategies) {
+      for (const auto n : num_build) {
+        ARROW_SCOPED_TRACE("num_build = ", n);
+        ARROW_SCOPED_TRACE("strategy = ", strategy == BloomFilterBuildStrategy::PARALLEL
+                                              ? "PARALLEL"
+                                              : "SINGLE_THREADED");
+        ARROW_SCOPED_TRACE("hardware_flags = ", hardware_flags);
+        TestBloomLarge(strategy, n, hardware_flags,
                        /*enable_prefetch=*/false);
       }
     }
diff --git a/cpp/src/arrow/acero/swiss_join_avx2.cc b/cpp/src/arrow/acero/swiss_join_avx2.cc
index d5c0b7817f55f..0888dd8938455 100644
--- a/cpp/src/arrow/acero/swiss_join_avx2.cc
+++ b/cpp/src/arrow/acero/swiss_join_avx2.cc
@@ -23,8 +23,6 @@
 namespace arrow {
 namespace acero {
 
-#if defined(ARROW_HAVE_AVX2)
-
 template <class PROCESS_8_VALUES_FN>
 int RowArrayAccessor::Visit_avx2(const RowTableImpl& rows, int column_id, int num_rows,
                                  const uint32_t* row_ids,
@@ -191,7 +189,5 @@ int RowArrayAccessor::VisitNulls_avx2(const RowTableImpl& rows, int column_id,
   return num_rows - (num_rows % unroll);
 }
 
-#endif
-
 }  // namespace acero
 }  // namespace arrow
diff --git a/cpp/src/arrow/acero/swiss_join_internal.h b/cpp/src/arrow/acero/swiss_join_internal.h
index cd12b34a0c6dc..88b80f06f57f2 100644
--- a/cpp/src/arrow/acero/swiss_join_internal.h
+++ b/cpp/src/arrow/acero/swiss_join_internal.h
@@ -80,7 +80,7 @@ class RowArrayAccessor {
                          const uint32_t* row_ids, PROCESS_VALUE_FN process_value_fn);
 
  private:
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   // This is equivalent to Visit method, but processing 8 rows at a time in a
   // loop.
   // Returns the number of processed rows, which may be less than requested (up
diff --git a/cpp/src/arrow/acero/test_util_internal.cc b/cpp/src/arrow/acero/test_util_internal.cc
index 2042650be6acb..f50ca92238dc4 100644
--- a/cpp/src/arrow/acero/test_util_internal.cc
+++ b/cpp/src/arrow/acero/test_util_internal.cc
@@ -45,8 +45,10 @@
 #include "arrow/testing/builder.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/random.h"
+#include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/util/async_generator.h"
+#include "arrow/util/cpu_info.h"
 #include "arrow/util/iterator.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/unreachable.h"
@@ -54,6 +56,7 @@
 
 namespace arrow {
 
+using arrow::internal::CpuInfo;
 using arrow::internal::Executor;
 
 using compute::SortKey;
@@ -62,6 +65,7 @@ using compute::Take;
 namespace acero {
 
 namespace {
+
 void ValidateOutputImpl(const ArrayData& output) {
   ASSERT_OK(::arrow::internal::ValidateArrayFull(output));
   TestInitialized(output);
@@ -116,6 +120,11 @@ void ValidateOutput(const Datum& output) {
   }
 }
 
+std::vector<int64_t> HardwareFlagsForTesting() {
+  // Acero currently only has AVX2 optimizations
+  return arrow::GetSupportedHardwareFlags({CpuInfo::AVX2});
+}
+
 namespace {
 
 struct DummyNode : ExecNode {
diff --git a/cpp/src/arrow/acero/test_util_internal.h b/cpp/src/arrow/acero/test_util_internal.h
index 03f417028650b..569fb1254db4a 100644
--- a/cpp/src/arrow/acero/test_util_internal.h
+++ b/cpp/src/arrow/acero/test_util_internal.h
@@ -20,6 +20,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/vector.h"
 
+#include <cstdint>
 #include <functional>
 #include <random>
 #include <string>
@@ -33,12 +34,14 @@
 #include "arrow/util/async_generator.h"
 #include "arrow/util/pcg_random.h"
 
-namespace arrow {
-
-namespace acero {
+namespace arrow::acero {
 
 void ValidateOutput(const Datum& output);
 
+// Enumerate all hardware flags that can be tested on this platform
+// and would lead to different code paths being tested in Acero.
+std::vector<int64_t> HardwareFlagsForTesting();
+
 using StartProducingFunc = std::function<Status(ExecNode*)>;
 using StopProducingFunc = std::function<void(ExecNode*)>;
 
@@ -204,5 +207,4 @@ struct TableGenerationProperties {
 Result<std::shared_ptr<Table>> MakeRandomTimeSeriesTable(
     const TableGenerationProperties& properties);
 
-}  // namespace acero
-}  // namespace arrow
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index a17d6275a763a..0bd6fe86134ab 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -18,11 +18,20 @@
 # ----------------------------------------------------------------------
 # Tests that don't require the full kernel library
 
+# Define arrow_compute_testing object library for common test files
+if(ARROW_TESTING)
+  add_library(arrow_compute_kernels_testing OBJECT test_util.cc)
+  # Even though this is still just an object library we still need to "link" our
+  # dependencies so that include paths are configured correctly
+  target_link_libraries(arrow_compute_kernels_testing ${ARROW_GTEST_GTEST})
+endif()
+
 add_arrow_test(scalar_cast_test
                ${ARROW_COMPUTE_TEST_ARGS}
                SOURCES
                scalar_cast_test.cc
-               test_util.cc)
+               EXTRA_LINK_LIBS
+               arrow_compute_kernels_testing)
 
 # ----------------------------------------------------------------------
 # Scalar kernels
@@ -32,25 +41,36 @@ add_arrow_compute_test(scalar_type_test
                        scalar_boolean_test.cc
                        scalar_nested_test.cc
                        scalar_string_test.cc
-                       test_util.cc)
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
-add_arrow_compute_test(scalar_if_else_test SOURCES scalar_if_else_test.cc test_util.cc)
+add_arrow_compute_test(scalar_if_else_test
+                       SOURCES
+                       scalar_if_else_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
-add_arrow_compute_test(scalar_temporal_test SOURCES scalar_temporal_test.cc test_util.cc)
+add_arrow_compute_test(scalar_temporal_test
+                       SOURCES
+                       scalar_temporal_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
 add_arrow_compute_test(scalar_math_test
                        SOURCES
                        scalar_arithmetic_test.cc
                        scalar_compare_test.cc
                        scalar_round_arithmetic_test.cc
-                       test_util.cc)
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
 add_arrow_compute_test(scalar_utility_test
                        SOURCES
                        scalar_random_test.cc
                        scalar_set_lookup_test.cc
                        scalar_validity_test.cc
-                       test_util.cc)
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
 add_arrow_benchmark(scalar_arithmetic_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(scalar_boolean_benchmark PREFIX "arrow-compute")
@@ -75,12 +95,20 @@ add_arrow_compute_test(vector_test
                        vector_replace_test.cc
                        vector_run_end_encode_test.cc
                        select_k_test.cc
-                       test_util.cc)
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
-add_arrow_compute_test(vector_sort_test SOURCES vector_sort_test.cc test_util.cc)
+add_arrow_compute_test(vector_sort_test
+                       SOURCES
+                       vector_sort_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
-add_arrow_compute_test(vector_selection_test SOURCES vector_selection_test.cc
-                       test_util.cc)
+add_arrow_compute_test(vector_selection_test
+                       SOURCES
+                       vector_selection_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
 add_arrow_benchmark(vector_hash_benchmark PREFIX "arrow-compute")
 add_arrow_benchmark(vector_sort_benchmark PREFIX "arrow-compute")
@@ -94,7 +122,11 @@ add_arrow_benchmark(vector_selection_benchmark PREFIX "arrow-compute")
 
 # Aggregates
 
-add_arrow_compute_test(aggregate_test SOURCES aggregate_test.cc test_util.cc)
+add_arrow_compute_test(aggregate_test
+                       SOURCES
+                       aggregate_test.cc
+                       EXTRA_LINK_LIBS
+                       arrow_compute_kernels_testing)
 
 # ----------------------------------------------------------------------
 # Utilities
diff --git a/cpp/src/arrow/compute/key_hash.cc b/cpp/src/arrow/compute/key_hash.cc
index 3fcfbf3d8312d..f5867b405ec71 100644
--- a/cpp/src/arrow/compute/key_hash.cc
+++ b/cpp/src/arrow/compute/key_hash.cc
@@ -236,7 +236,7 @@ void Hashing32::HashVarLen(int64_t hardware_flags, bool combine_hashes, uint32_t
                            const uint32_t* offsets, const uint8_t* concatenated_keys,
                            uint32_t* hashes, uint32_t* hashes_temp_for_combine) {
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     num_processed = HashVarLen_avx2(combine_hashes, num_rows, offsets, concatenated_keys,
                                     hashes, hashes_temp_for_combine);
@@ -255,7 +255,7 @@ void Hashing32::HashVarLen(int64_t hardware_flags, bool combine_hashes, uint32_t
                            const uint64_t* offsets, const uint8_t* concatenated_keys,
                            uint32_t* hashes, uint32_t* hashes_temp_for_combine) {
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     num_processed = HashVarLen_avx2(combine_hashes, num_rows, offsets, concatenated_keys,
                                     hashes, hashes_temp_for_combine);
@@ -361,7 +361,7 @@ void Hashing32::HashFixed(int64_t hardware_flags, bool combine_hashes, uint32_t
   }
 
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     num_processed = HashFixedLen_avx2(combine_hashes, num_rows, length, keys, hashes,
                                       hashes_temp_for_combine);
diff --git a/cpp/src/arrow/compute/key_hash.h b/cpp/src/arrow/compute/key_hash.h
index e43d7b8df523d..b193716c9bdfd 100644
--- a/cpp/src/arrow/compute/key_hash.h
+++ b/cpp/src/arrow/compute/key_hash.h
@@ -17,7 +17,7 @@
 
 #pragma once
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
 #include <immintrin.h>
 #endif
 
@@ -115,7 +115,7 @@ class ARROW_EXPORT Hashing32 {
   static void HashInt(bool combine_hashes, uint32_t num_keys, uint64_t length_key,
                       const uint8_t* keys, uint32_t* hashes);
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   static inline __m256i Avalanche_avx2(__m256i hash);
   static inline __m256i CombineHashesImp_avx2(__m256i previous_hash, __m256i hash);
   template <bool T_COMBINE_HASHES>
diff --git a/cpp/src/arrow/compute/key_hash_avx2.cc b/cpp/src/arrow/compute/key_hash_avx2.cc
index f30c3460bda60..1b444b576784f 100644
--- a/cpp/src/arrow/compute/key_hash_avx2.cc
+++ b/cpp/src/arrow/compute/key_hash_avx2.cc
@@ -23,8 +23,6 @@
 namespace arrow {
 namespace compute {
 
-#if defined(ARROW_HAVE_AVX2)
-
 inline __m256i Hashing32::Avalanche_avx2(__m256i hash) {
   hash = _mm256_xor_si256(hash, _mm256_srli_epi32(hash, 15));
   hash = _mm256_mullo_epi32(hash, _mm256_set1_epi32(PRIME32_2));
@@ -315,7 +313,5 @@ uint32_t Hashing32::HashVarLen_avx2(bool combine_hashes, uint32_t num_rows,
   }
 }
 
-#endif
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/key_hash_test.cc b/cpp/src/arrow/compute/key_hash_test.cc
index d10645391b413..3e6d41525cf44 100644
--- a/cpp/src/arrow/compute/key_hash_test.cc
+++ b/cpp/src/arrow/compute/key_hash_test.cc
@@ -21,18 +21,26 @@
 #include <map>
 #include <random>
 #include <unordered_set>
+
 #include "arrow/array/builder_binary.h"
 #include "arrow/compute/key_hash.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/testing/util.h"
 #include "arrow/util/cpu_info.h"
 #include "arrow/util/pcg_random.h"
 
 namespace arrow {
 
 using internal::checked_pointer_cast;
+using internal::CpuInfo;
 
 namespace compute {
 
+std::vector<int64_t> HardwareFlagsForTesting() {
+  // Our key-hash and key-map routines currently only have AVX2 optimizations
+  return GetSupportedHardwareFlags({CpuInfo::AVX2});
+}
+
 class TestVectorHash {
  private:
   template <typename Type, typename ArrayType = typename TypeTraits<Type>::ArrayType>
@@ -131,85 +139,79 @@ class TestVectorHash {
     const offset_t* key_offsets =
         reinterpret_cast<const offset_t*>(keys_array->raw_value_offsets());
 
-    std::vector<uint32_t> hashes_scalar32;
-    std::vector<uint64_t> hashes_scalar64;
-    hashes_scalar32.resize(num_rows);
-    hashes_scalar64.resize(num_rows);
-    std::vector<uint32_t> hashes_simd32;
-    std::vector<uint64_t> hashes_simd64;
-    hashes_simd32.resize(num_rows);
-    hashes_simd64.resize(num_rows);
-
-    int64_t hardware_flags_scalar = 0LL;
-    int64_t hardware_flags_simd = ::arrow::internal::CpuInfo::AVX2;
+    // For each tested hardware flags, we will compute the hashes and check
+    // them for consistency.
+    const auto hardware_flags_for_testing = HardwareFlagsForTesting();
+    ASSERT_GT(hardware_flags_for_testing.size(), 0);
+    std::vector<std::vector<uint32_t>> hashes32(hardware_flags_for_testing.size());
+    std::vector<std::vector<uint64_t>> hashes64(hardware_flags_for_testing.size());
+    for (auto& h : hashes32) {
+      h.resize(num_rows);
+    }
+    for (auto& h : hashes64) {
+      h.resize(num_rows);
+    }
 
     constexpr int mini_batch_size = 1024;
     std::vector<uint32_t> temp_buffer;
     temp_buffer.resize(mini_batch_size * 4);
 
-    for (bool use_simd : {false, true}) {
+    for (int i = 0; i < static_cast<int>(hardware_flags_for_testing.size()); ++i) {
+      const auto hardware_flags = hardware_flags_for_testing[i];
       if (use_32bit_hash) {
         if (!use_varlen_input) {
-          Hashing32::HashFixed(use_simd ? hardware_flags_simd : hardware_flags_scalar,
+          Hashing32::HashFixed(hardware_flags,
                                /*combine_hashes=*/false, num_rows, fixed_length, keys,
-                               use_simd ? hashes_simd32.data() : hashes_scalar32.data(),
-                               temp_buffer.data());
+                               hashes32[i].data(), temp_buffer.data());
         } else {
           for (int first_row = 0; first_row < num_rows;) {
             int batch_size_next = std::min(num_rows - first_row, mini_batch_size);
 
-            Hashing32::HashVarLen(
-                use_simd ? hardware_flags_simd : hardware_flags_scalar,
-                /*combine_hashes=*/false, batch_size_next, key_offsets + first_row, keys,
-                (use_simd ? hashes_simd32.data() : hashes_scalar32.data()) + first_row,
-                temp_buffer.data());
+            Hashing32::HashVarLen(hardware_flags,
+                                  /*combine_hashes=*/false, batch_size_next,
+                                  key_offsets + first_row, keys,
+                                  hashes32[i].data() + first_row, temp_buffer.data());
 
             first_row += batch_size_next;
           }
         }
+        for (int j = 0; j < num_rows; ++j) {
+          hashes64[i][j] = hashes32[i][j];
+        }
       } else {
         if (!use_varlen_input) {
           Hashing64::HashFixed(
-              /*combine_hashes=*/false, num_rows, fixed_length, keys,
-              use_simd ? hashes_simd64.data() : hashes_scalar64.data());
+              /*combine_hashes=*/false, num_rows, fixed_length, keys, hashes64[i].data());
         } else {
           Hashing64::HashVarLen(
-              /*combine_hashes=*/false, num_rows, key_offsets, keys,
-              use_simd ? hashes_simd64.data() : hashes_scalar64.data());
+              /*combine_hashes=*/false, num_rows, key_offsets, keys, hashes64[i].data());
         }
       }
     }
 
-    if (use_32bit_hash) {
-      for (int i = 0; i < num_rows; ++i) {
-        hashes_scalar64[i] = hashes_scalar32[i];
-        hashes_simd64[i] = hashes_simd32[i];
-      }
-    }
-
-    // Verify that both scalar and AVX2 implementations give the same hashes
+    // Verify that all implementations (scalar, SIMD) give the same hashes
     //
-    for (int i = 0; i < num_rows; ++i) {
-      ASSERT_EQ(hashes_scalar64[i], hashes_simd64[i])
-          << "scalar and simd approaches yielded different hashes";
+    const auto& hashes_scalar64 = hashes64[0];
+    for (int i = 0; i < static_cast<int>(hardware_flags_for_testing.size()); ++i) {
+      for (int j = 0; j < num_rows; ++j) {
+        ASSERT_EQ(hashes64[i][j], hashes_scalar64[j])
+            << "scalar and simd approaches yielded different hashes";
+      }
     }
 
     // Verify that the same key appearing multiple times generates the same hash
     // each time. Measure the number of unique hashes and compare to the number
     // of unique keys.
     //
-    std::map<int, uint64_t> unique_key_to_hash;
-    std::set<uint64_t> unique_hashes;
+    std::unordered_map<int, uint64_t> unique_key_to_hash;
+    std::unordered_set<uint64_t> unique_hashes;
     for (int i = 0; i < num_rows; ++i) {
-      std::map<int, uint64_t>::iterator iter = unique_key_to_hash.find(row_ids[i]);
-      if (iter == unique_key_to_hash.end()) {
-        unique_key_to_hash.insert(std::make_pair(row_ids[i], hashes_scalar64[i]));
-      } else {
-        ASSERT_EQ(iter->second, hashes_scalar64[i]);
-      }
-      if (unique_hashes.find(hashes_scalar64[i]) == unique_hashes.end()) {
-        unique_hashes.insert(hashes_scalar64[i]);
+      auto [it, inserted] =
+          unique_key_to_hash.try_emplace(row_ids[i], hashes_scalar64[i]);
+      if (!inserted) {
+        ASSERT_EQ(it->second, hashes_scalar64[i]);
       }
+      unique_hashes.insert(hashes_scalar64[i]);
     }
     float percent_hash_collisions =
         100.0f * static_cast<float>(num_unique - unique_hashes.size()) /
diff --git a/cpp/src/arrow/compute/key_map.cc b/cpp/src/arrow/compute/key_map.cc
index fd5c404a07f8d..71ca56c91a9ff 100644
--- a/cpp/src/arrow/compute/key_map.cc
+++ b/cpp/src/arrow/compute/key_map.cc
@@ -133,7 +133,7 @@ void SwissTable::extract_group_ids(const int num_keys, const uint16_t* optional_
 
   // Optimistically use simplified lookup involving only a start block to find
   // a single group id candidate for every input.
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   int num_group_id_bytes = num_group_id_bits / 8;
   if ((hardware_flags_ & arrow::internal::CpuInfo::AVX2) && !optional_selection) {
     num_processed = extract_group_ids_avx2(num_keys, hashes, local_slots, out_group_ids,
@@ -301,7 +301,7 @@ void SwissTable::early_filter(const int num_keys, const uint32_t* hashes,
   // Optimistically use simplified lookup involving only a start block to find
   // a single group id candidate for every input.
   int num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags_ & arrow::internal::CpuInfo::AVX2) {
     if (log_blocks_ <= 4) {
       num_processed = early_filter_imp_avx2_x32(num_keys, hashes, out_match_bitvector,
diff --git a/cpp/src/arrow/compute/key_map.h b/cpp/src/arrow/compute/key_map.h
index 7ab48470f21e4..95fb3be274288 100644
--- a/cpp/src/arrow/compute/key_map.h
+++ b/cpp/src/arrow/compute/key_map.h
@@ -163,7 +163,7 @@ class ARROW_EXPORT SwissTable {
   //
   void early_filter_imp(const int num_keys, const uint32_t* hashes,
                         uint8_t* out_match_bitvector, uint8_t* out_local_slots) const;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   int early_filter_imp_avx2_x8(const int num_hashes, const uint32_t* hashes,
                                uint8_t* out_match_bitvector,
                                uint8_t* out_local_slots) const;
diff --git a/cpp/src/arrow/compute/key_map_avx2.cc b/cpp/src/arrow/compute/key_map_avx2.cc
index eb318ff188fbb..731553511044f 100644
--- a/cpp/src/arrow/compute/key_map_avx2.cc
+++ b/cpp/src/arrow/compute/key_map_avx2.cc
@@ -23,8 +23,6 @@
 namespace arrow {
 namespace compute {
 
-#if defined(ARROW_HAVE_AVX2)
-
 // This is more or less translation of equivalent scalar code, adjusted for a
 // different instruction set (e.g. missing leading zero count instruction).
 //
@@ -412,7 +410,5 @@ int SwissTable::extract_group_ids_avx2(const int num_keys, const uint32_t* hashe
   return num_keys - (num_keys % unroll);
 }
 
-#endif
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/row/compare_internal.cc b/cpp/src/arrow/compute/row/compare_internal.cc
index 39ac33932b548..7c402e7a2384d 100644
--- a/cpp/src/arrow/compute/row/compare_internal.cc
+++ b/cpp/src/arrow/compute/row/compare_internal.cc
@@ -42,7 +42,7 @@ void KeyCompare::NullUpdateColumnToRow(uint32_t id_col, uint32_t num_rows_to_com
     return;
   }
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2()) {
     num_processed = NullUpdateColumnToRow_avx2(use_selection, id_col, num_rows_to_compare,
                                                sel_left_maybe_null, left_to_right_map,
@@ -130,7 +130,7 @@ void KeyCompare::CompareBinaryColumnToRow(uint32_t offset_within_row,
                                           const RowTableImpl& rows,
                                           uint8_t* match_bytevector) {
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2()) {
     num_processed = CompareBinaryColumnToRow_avx2(
         use_selection, offset_within_row, num_rows_to_compare, sel_left_maybe_null,
@@ -297,7 +297,7 @@ void KeyCompare::CompareVarBinaryColumnToRow(uint32_t id_varbinary_col,
                                              const RowTableImpl& rows,
                                              uint8_t* match_bytevector) {
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2()) {
     num_processed = CompareVarBinaryColumnToRow_avx2(
         use_selection, is_first_varbinary_col, id_varbinary_col, num_rows_to_compare,
@@ -313,7 +313,7 @@ void KeyCompare::CompareVarBinaryColumnToRow(uint32_t id_varbinary_col,
 void KeyCompare::AndByteVectors(LightContext* ctx, uint32_t num_elements,
                                 uint8_t* bytevector_A, const uint8_t* bytevector_B) {
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2()) {
     num_processed = AndByteVectors_avx2(num_elements, bytevector_A, bytevector_B);
   }
diff --git a/cpp/src/arrow/compute/row/compare_internal.h b/cpp/src/arrow/compute/row/compare_internal.h
index 638b8c2ec721f..db953fbe11271 100644
--- a/cpp/src/arrow/compute/row/compare_internal.h
+++ b/cpp/src/arrow/compute/row/compare_internal.h
@@ -86,7 +86,7 @@ class ARROW_EXPORT KeyCompare {
   static void AndByteVectors(LightContext* ctx, uint32_t num_elements,
                              uint8_t* bytevector_A, const uint8_t* bytevector_B);
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
 
   template <bool use_selection>
   static uint32_t NullUpdateColumnToRowImp_avx2(
diff --git a/cpp/src/arrow/compute/row/compare_internal_avx2.cc b/cpp/src/arrow/compute/row/compare_internal_avx2.cc
index 95f37ab617db5..ff407c51b83cb 100644
--- a/cpp/src/arrow/compute/row/compare_internal_avx2.cc
+++ b/cpp/src/arrow/compute/row/compare_internal_avx2.cc
@@ -24,8 +24,6 @@
 namespace arrow {
 namespace compute {
 
-#if defined(ARROW_HAVE_AVX2)
-
 inline __m256i set_first_n_bytes_avx2(int n) {
   constexpr uint64_t kByteSequence0To7 = 0x0706050403020100ULL;
   constexpr uint64_t kByteSequence8To15 = 0x0f0e0d0c0b0a0908ULL;
@@ -670,7 +668,5 @@ uint32_t KeyCompare::CompareVarBinaryColumnToRow_avx2(
   return num_rows_to_compare;
 }
 
-#endif
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/row/encode_internal.cc b/cpp/src/arrow/compute/row/encode_internal.cc
index 3a6a85b0272f8..01d552ef8270f 100644
--- a/cpp/src/arrow/compute/row/encode_internal.cc
+++ b/cpp/src/arrow/compute/row/encode_internal.cc
@@ -455,7 +455,7 @@ void EncoderBinary::Decode(uint32_t start_row, uint32_t num_rows,
 
     bool is_row_fixed_length = rows.metadata().is_fixed_length;
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
     if (ctx->has_avx2()) {
       DecodeHelper_avx2(is_row_fixed_length, start_row, num_rows, offset_within_row, rows,
                         col);
@@ -466,7 +466,7 @@ void EncoderBinary::Decode(uint32_t start_row, uint32_t num_rows,
       } else {
         DecodeImp<false>(start_row, num_rows, offset_within_row, rows, col);
       }
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
     }
 #endif
 
@@ -524,7 +524,7 @@ void EncoderBinaryPair::Decode(uint32_t start_row, uint32_t num_rows,
   bool is_row_fixed_length = rows.metadata().is_fixed_length;
 
   uint32_t num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2() && col_width1 == col_width2) {
     num_processed =
         DecodeHelper_avx2(is_row_fixed_length, col_width1, start_row, num_rows,
@@ -772,7 +772,7 @@ void EncoderVarBinary::Decode(uint32_t start_row, uint32_t num_rows,
                               KeyColumnArray* col, LightContext* ctx) {
   // Output column varbinary buffer needs an extra 32B
   // at the end in avx2 version and 8B otherwise.
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (ctx->has_avx2()) {
     DecodeHelper_avx2(start_row, num_rows, varbinary_col_id, rows, col);
   } else {
@@ -782,7 +782,7 @@ void EncoderVarBinary::Decode(uint32_t start_row, uint32_t num_rows,
     } else {
       DecodeImp<false>(start_row, num_rows, varbinary_col_id, rows, col);
     }
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   }
 #endif
 }
diff --git a/cpp/src/arrow/compute/row/encode_internal.h b/cpp/src/arrow/compute/row/encode_internal.h
index b83767b694cfd..6091fb66982af 100644
--- a/cpp/src/arrow/compute/row/encode_internal.h
+++ b/cpp/src/arrow/compute/row/encode_internal.h
@@ -187,7 +187,7 @@ class EncoderBinary {
   template <bool is_row_fixed_length>
   static void DecodeImp(uint32_t start_row, uint32_t num_rows, uint32_t offset_within_row,
                         const RowTableImpl& rows, KeyColumnArray* col);
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   static void DecodeHelper_avx2(bool is_row_fixed_length, uint32_t start_row,
                                 uint32_t num_rows, uint32_t offset_within_row,
                                 const RowTableImpl& rows, KeyColumnArray* col);
@@ -213,7 +213,7 @@ class EncoderBinaryPair {
   static void DecodeImp(uint32_t num_rows_to_skip, uint32_t start_row, uint32_t num_rows,
                         uint32_t offset_within_row, const RowTableImpl& rows,
                         KeyColumnArray* col1, KeyColumnArray* col2);
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   static uint32_t DecodeHelper_avx2(bool is_row_fixed_length, uint32_t col_width,
                                     uint32_t start_row, uint32_t num_rows,
                                     uint32_t offset_within_row, const RowTableImpl& rows,
@@ -300,7 +300,7 @@ class EncoderVarBinary {
   template <bool first_varbinary_col>
   static void DecodeImp(uint32_t start_row, uint32_t num_rows, uint32_t varbinary_col_id,
                         const RowTableImpl& rows, KeyColumnArray* col);
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   static void DecodeHelper_avx2(uint32_t start_row, uint32_t num_rows,
                                 uint32_t varbinary_col_id, const RowTableImpl& rows,
                                 KeyColumnArray* col);
diff --git a/cpp/src/arrow/compute/row/encode_internal_avx2.cc b/cpp/src/arrow/compute/row/encode_internal_avx2.cc
index 02ba310bded20..50969c7bd6034 100644
--- a/cpp/src/arrow/compute/row/encode_internal_avx2.cc
+++ b/cpp/src/arrow/compute/row/encode_internal_avx2.cc
@@ -22,8 +22,6 @@
 namespace arrow {
 namespace compute {
 
-#if defined(ARROW_HAVE_AVX2)
-
 void EncoderBinary::DecodeHelper_avx2(bool is_row_fixed_length, uint32_t start_row,
                                       uint32_t num_rows, uint32_t offset_within_row,
                                       const RowTableImpl& rows, KeyColumnArray* col) {
@@ -230,7 +228,5 @@ void EncoderVarBinary::DecodeImp_avx2(uint32_t start_row, uint32_t num_rows,
       });
 }
 
-#endif
-
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/util.cc b/cpp/src/arrow/compute/util.cc
index f69f60a5af434..faf3e0c87e4d2 100644
--- a/cpp/src/arrow/compute/util.cc
+++ b/cpp/src/arrow/compute/util.cc
@@ -118,7 +118,7 @@ void bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
   // 64 bits at a time
   constexpr int unroll = 64;
   int tail = num_bits % unroll;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     if (filter_input_indexes) {
       avx2::bits_filter_indexes_avx2(bit_to_search, num_bits - tail, bits, input_indexes,
@@ -141,7 +141,7 @@ void bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
         bits_to_indexes_helper(word, i * 64 + base_index, num_indexes, indexes);
       }
     }
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   }
 #endif
   // Optionally process the last partial word with masking out bits outside range
@@ -253,7 +253,7 @@ void bits_to_bytes(int64_t hardware_flags, const int num_bits, const uint8_t* bi
   }
 
   int num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     // The function call below processes whole 32 bit chunks together.
     num_processed = num_bits - (num_bits % 32);
@@ -309,7 +309,7 @@ void bytes_to_bits(int64_t hardware_flags, const int num_bits, const uint8_t* by
   }
 
   int num_processed = 0;
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     // The function call below processes whole 32 bit chunks together.
     num_processed = num_bits - (num_bits % 32);
@@ -339,7 +339,7 @@ void bytes_to_bits(int64_t hardware_flags, const int num_bits, const uint8_t* by
 
 bool are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
                         uint32_t num_bytes) {
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
   if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
     return avx2::are_all_bytes_zero_avx2(bytes, num_bytes);
   }
diff --git a/cpp/src/arrow/compute/util.h b/cpp/src/arrow/compute/util.h
index 489139eab87f2..730e59f346a52 100644
--- a/cpp/src/arrow/compute/util.h
+++ b/cpp/src/arrow/compute/util.h
@@ -168,7 +168,7 @@ ARROW_EXPORT void bytes_to_bits(int64_t hardware_flags, const int num_bits,
 ARROW_EXPORT bool are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
                                      uint32_t num_bytes);
 
-#if defined(ARROW_HAVE_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2)
 
 namespace avx2 {
 ARROW_EXPORT void bits_filter_indexes_avx2(int bit_to_search, const int num_bits,
diff --git a/cpp/src/arrow/compute/util_avx2.cc b/cpp/src/arrow/compute/util_avx2.cc
index 89ec6aa97a608..0191ab06f9532 100644
--- a/cpp/src/arrow/compute/util_avx2.cc
+++ b/cpp/src/arrow/compute/util_avx2.cc
@@ -21,9 +21,7 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/logging.h"
 
-#if defined(ARROW_HAVE_AVX2)
-
-namespace arrow::util::avx2 {
+namespace arrow::util::bit_util::avx2 {
 
 template <int bit_to_search>
 void bits_to_indexes_imp_avx2(const int num_bits, const uint8_t* bits, int* num_indexes,
@@ -211,6 +209,4 @@ bool are_all_bytes_zero_avx2(const uint8_t* bytes, uint32_t num_bytes) {
   return result_or32 == 0;
 }
 
-}  // namespace arrow::util::avx2
-
-#endif  // ARROW_HAVE_AVX2
+}  // namespace arrow::util::bit_util::avx2
diff --git a/cpp/src/arrow/testing/util.cc b/cpp/src/arrow/testing/util.cc
index b59854480765b..e8a782575e278 100644
--- a/cpp/src/arrow/testing/util.cc
+++ b/cpp/src/arrow/testing/util.cc
@@ -43,6 +43,7 @@
 #include "arrow/table.h"
 #include "arrow/testing/random.h"
 #include "arrow/type.h"
+#include "arrow/util/cpu_info.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/pcg_random.h"
@@ -211,4 +212,18 @@ const std::vector<std::shared_ptr<DataType>>& all_dictionary_index_types() {
   return types;
 }
 
+std::vector<int64_t> GetSupportedHardwareFlags(
+    const std::vector<int64_t>& candidate_flags) {
+  std::vector<int64_t> hardware_flags;
+  // Always test fallback codepaths
+  hardware_flags.push_back(0);
+  for (const int64_t candidate_flag : candidate_flags) {
+    if (candidate_flag != 0 &&
+        internal::CpuInfo::GetInstance()->IsSupported(candidate_flag)) {
+      hardware_flags.push_back(candidate_flag);
+    }
+  }
+  return hardware_flags;
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/testing/util.h b/cpp/src/arrow/testing/util.h
index 4f4b03438fd58..b4b2785a36292 100644
--- a/cpp/src/arrow/testing/util.h
+++ b/cpp/src/arrow/testing/util.h
@@ -131,4 +131,10 @@ ARROW_TESTING_EXPORT std::string GetListenAddress();
 ARROW_TESTING_EXPORT
 const std::vector<std::shared_ptr<DataType>>& all_dictionary_index_types();
 
+// Get a list of supported hardware flags from the given candidates.
+// The result will always contain 0, meaning no optional CPU feature enabled at all.
+ARROW_TESTING_EXPORT
+std::vector<int64_t> GetSupportedHardwareFlags(
+    const std::vector<int64_t>& candidate_flags);
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/byte_stream_split.h b/cpp/src/arrow/util/byte_stream_split.h
index 28dcce52bb8fc..d428df0659b28 100644
--- a/cpp/src/arrow/util/byte_stream_split.h
+++ b/cpp/src/arrow/util/byte_stream_split.h
@@ -39,9 +39,9 @@ void ByteStreamSplitDecodeSse2(const uint8_t* data, int64_t num_values, int64_t
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m128i) * kNumStreams;
 
   const int64_t size = num_values * sizeof(T);
-  constexpr int64_t kBlockSize = sizeof(__m128i) * kNumStreams;
   const int64_t num_blocks = size / kBlockSize;
   uint8_t* output_data = reinterpret_cast<uint8_t*>(out);
 
@@ -92,11 +92,12 @@ void ByteStreamSplitEncodeSse2(const uint8_t* raw_values, const size_t num_value
                                uint8_t* output_buffer_raw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
+  constexpr size_t kBlockSize = sizeof(__m128i) * kNumStreams;
+
   __m128i stage[3][kNumStreams];
   __m128i final_result[kNumStreams];
 
   const size_t size = num_values * sizeof(T);
-  constexpr size_t kBlockSize = sizeof(__m128i) * kNumStreams;
   const size_t num_blocks = size / kBlockSize;
   const __m128i* raw_values_sse = reinterpret_cast<const __m128i*>(raw_values);
   __m128i* output_buffer_streams[kNumStreams];
@@ -143,7 +144,7 @@ void ByteStreamSplitEncodeSse2(const uint8_t* raw_values, const size_t num_value
             _mm_unpackhi_epi8(stage[stage_lvl][i * 2], stage[stage_lvl][i * 2 + 1]);
       }
     }
-    if (kNumStreams == 8U) {
+    if constexpr (kNumStreams == 8U) {
       // This is the path for double.
       __m128i tmp[8];
       for (size_t i = 0; i < 4; ++i) {
@@ -181,9 +182,9 @@ void ByteStreamSplitDecodeAvx2(const uint8_t* data, int64_t num_values, int64_t
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m256i) * kNumStreams;
 
   const int64_t size = num_values * sizeof(T);
-  constexpr int64_t kBlockSize = sizeof(__m256i) * kNumStreams;
   if (size < kBlockSize)  // Back to SSE for small size
     return ByteStreamSplitDecodeSse2(data, num_values, stride, out);
   const int64_t num_blocks = size / kBlockSize;
@@ -220,7 +221,7 @@ void ByteStreamSplitDecodeAvx2(const uint8_t* data, int64_t num_values, int64_t
       }
     }
 
-    if (kNumStreams == 8U) {
+    if constexpr (kNumStreams == 8U) {
       // path for double, 128i index:
       //   {0x00, 0x08}, {0x01, 0x09}, {0x02, 0x0A}, {0x03, 0x0B},
       //   {0x04, 0x0C}, {0x05, 0x0D}, {0x06, 0x0E}, {0x07, 0x0F},
@@ -266,11 +267,12 @@ void ByteStreamSplitEncodeAvx2(const uint8_t* raw_values, const size_t num_value
                                uint8_t* output_buffer_raw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
-  if (kNumStreams == 8U)  // Back to SSE, currently no path for double.
+  constexpr size_t kBlockSize = sizeof(__m256i) * kNumStreams;
+
+  if constexpr (kNumStreams == 8U)  // Back to SSE, currently no path for double.
     return ByteStreamSplitEncodeSse2<T>(raw_values, num_values, output_buffer_raw);
 
   const size_t size = num_values * sizeof(T);
-  constexpr size_t kBlockSize = sizeof(__m256i) * kNumStreams;
   if (size < kBlockSize)  // Back to SSE for small size
     return ByteStreamSplitEncodeSse2<T>(raw_values, num_values, output_buffer_raw);
   const size_t num_blocks = size / kBlockSize;
@@ -339,9 +341,9 @@ void ByteStreamSplitDecodeAvx512(const uint8_t* data, int64_t num_values, int64_
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
   constexpr size_t kNumStreamsLog2 = (kNumStreams == 8U ? 3U : 2U);
+  constexpr int64_t kBlockSize = sizeof(__m512i) * kNumStreams;
 
   const int64_t size = num_values * sizeof(T);
-  constexpr int64_t kBlockSize = sizeof(__m512i) * kNumStreams;
   if (size < kBlockSize)  // Back to AVX2 for small size
     return ByteStreamSplitDecodeAvx2(data, num_values, stride, out);
   const int64_t num_blocks = size / kBlockSize;
@@ -379,7 +381,7 @@ void ByteStreamSplitDecodeAvx512(const uint8_t* data, int64_t num_values, int64_
       }
     }
 
-    if (kNumStreams == 8U) {
+    if constexpr (kNumStreams == 8U) {
       // path for double, 128i index:
       // {0x00, 0x04, 0x08, 0x0C}, {0x10, 0x14, 0x18, 0x1C},
       // {0x01, 0x05, 0x09, 0x0D}, {0x11, 0x15, 0x19, 0x1D},
@@ -442,8 +444,10 @@ void ByteStreamSplitEncodeAvx512(const uint8_t* raw_values, const size_t num_val
                                  uint8_t* output_buffer_raw) {
   constexpr size_t kNumStreams = sizeof(T);
   static_assert(kNumStreams == 4U || kNumStreams == 8U, "Invalid number of streams.");
-  const size_t size = num_values * sizeof(T);
   constexpr size_t kBlockSize = sizeof(__m512i) * kNumStreams;
+
+  const size_t size = num_values * sizeof(T);
+
   if (size < kBlockSize)  // Back to AVX2 for small size
     return ByteStreamSplitEncodeAvx2<T>(raw_values, num_values, output_buffer_raw);
 
@@ -469,7 +473,7 @@ void ByteStreamSplitEncodeAvx512(const uint8_t* raw_values, const size_t num_val
   __m512i unpack[KNumUnpack + 1][kNumStreams];
   __m512i permutex[kNumStreams];
   __m512i permutex_mask;
-  if (kNumStreams == 8U) {
+  if constexpr (kNumStreams == 8U) {
     // use _mm512_set_epi32, no _mm512_set_epi16 for some old gcc version.
     permutex_mask = _mm512_set_epi32(0x001F0017, 0x000F0007, 0x001E0016, 0x000E0006,
                                      0x001D0015, 0x000D0005, 0x001C0014, 0x000C0004,
@@ -494,7 +498,7 @@ void ByteStreamSplitEncodeAvx512(const uint8_t* raw_values, const size_t num_val
       }
     }
 
-    if (kNumStreams == 8U) {
+    if constexpr (kNumStreams == 8U) {
       // path for double
       // 1. unpack to epi16 block
       // 2. permutexvar_epi16 to 128i block
diff --git a/docker-compose.yml b/docker-compose.yml
index fbb879b2bc54b..8727aded2c825 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -72,6 +72,10 @@ x-sccache: &sccache
   SCCACHE_REGION:
   SCCACHE_S3_KEY_PREFIX: ${SCCACHE_S3_KEY_PREFIX:-sccache}
 
+x-cpp: &cpp
+  ARROW_RUNTIME_SIMD_LEVEL:
+  ARROW_SIMD_LEVEL:
+
 # CPU/memory limit presets to pass to Docker.
 #
 # Usage: archery docker run --resource-limit=github <image>
@@ -227,7 +231,7 @@ services:
     ulimits: &ulimits
       core: ${ULIMIT_CORE}
     environment:
-      <<: [*common, *ccache]
+      <<: [*common, *ccache, *cpp]
       ARROW_ENABLE_TIMING_TESTS:  # inherit
       ARROW_MIMALLOC: "ON"
     volumes: &alpine-linux-volumes
@@ -278,7 +282,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_BUILD_BENCHMARKS: "ON"
       ARROW_BUILD_EXAMPLES: "ON"
       ARROW_ENABLE_TIMING_TESTS:  # inherit
@@ -313,7 +317,7 @@ services:
         arch: ${ARCH}
     shm_size: *shm-size
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       # Shrink test runtime by enabling minimal optimizations
       ARROW_C_FLAGS_DEBUG: "-g1 -Og"
       ARROW_CXX_FLAGS_DEBUG: "-g1 -Og"
@@ -349,7 +353,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_ENABLE_TIMING_TESTS:  # inherit
       ARROW_MIMALLOC: "ON"
     volumes: &debian-volumes
@@ -390,7 +394,7 @@ services:
       - apparmor:unconfined
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_ENABLE_TIMING_TESTS:  # inherit
       ARROW_MIMALLOC: "ON"
     volumes: &ubuntu-volumes
@@ -426,7 +430,7 @@ services:
       - apparmor:unconfined
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_HOME: /arrow
       ARROW_DEPENDENCY_SOURCE: BUNDLED
       LIBARROW_MINIMAL: "false"
@@ -448,7 +452,7 @@ services:
     volumes:
       - .:/arrow:delegated
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_DEPENDENCY_SOURCE: BUNDLED
       ARROW_HOME: /arrow
       LIBARROW_MINIMAL: "false"
@@ -470,7 +474,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_DEPENDENCY_SOURCE: BUNDLED
       CMAKE_GENERATOR: "Unix Makefiles"
     volumes: *ubuntu-volumes
@@ -491,7 +495,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_BUILD_UTILITIES: "OFF"
       ARROW_COMPUTE: "OFF"
       ARROW_CSV: "OFF"
@@ -538,7 +542,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_BUILD_UTILITIES: "OFF"
       ARROW_COMPUTE: "OFF"
       ARROW_CSV: "OFF"
@@ -588,7 +592,7 @@ services:
     shm_size: *shm-size
     volumes: *ubuntu-volumes
     environment:
-      <<: [*common, *ccache]
+      <<: [*common, *ccache, *cpp]
       CC: clang-${CLANG_TOOLS}
       CXX: clang++-${CLANG_TOOLS}
       # Avoid creating huge static libraries
@@ -630,7 +634,7 @@ services:
     shm_size: *shm-size
     volumes: *ubuntu-volumes
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       CC: clang-${CLANG_TOOLS}
       CXX: clang++-${CLANG_TOOLS}
       ARROW_BUILD_STATIC: "OFF"
@@ -662,7 +666,7 @@ services:
     shm_size: *shm-size
     ulimits: *ulimits
     environment:
-      <<: [*common, *ccache, *sccache]
+      <<: [*common, *ccache, *sccache, *cpp]
       ARROW_ENABLE_TIMING_TESTS:  # inherit
       ARROW_MIMALLOC: "ON"
       Protobuf_SOURCE: "BUNDLED"  # Need Protobuf >= 3.15

From be2014a9ebfb9570b016a5f0beda11022ace45d1 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 19 Jul 2023 12:32:27 +0200
Subject: [PATCH 013/749] GH-36767: [C++][CI] Fix test failure on i386 (#36769)

### Rationale for this change

Our nightly build on i386 Debian (a 32-bit x86 build) fails with an error in decimal-to-read tests:
https://github.com/ursacomputing/crossbow/actions/runs/5593823296/jobs/10227952675#step:6:3255

### What changes are included in this PR?

Improve error messages by displaying the actual and expected values.

A side effect of this error message improvement is to... fix the test failure, as storing the computation result in a local variable seems to change the computed absolute difference.

This is probably due to x86 FPU rounding shenanigans, as explained here: https://stackoverflow.com/questions/37626687/c-fundamentals-double-variable-not-equal-to-double-expression

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #36767

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/util/decimal_test.cc | 33 +++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/util/decimal_test.cc b/cpp/src/arrow/util/decimal_test.cc
index 6376a9545a0f8..0a8b7a09730bf 100644
--- a/cpp/src/arrow/util/decimal_test.cc
+++ b/cpp/src/arrow/util/decimal_test.cc
@@ -1046,42 +1046,51 @@ using ToDoubleTestParam = ToRealTestParam<double>;
 template <typename Decimal, typename Real>
 void CheckDecimalToReal(const std::string& decimal_value, int32_t scale, Real expected) {
   Decimal dec(decimal_value);
-  ASSERT_EQ(dec.template ToReal<Real>(scale), expected)
-      << "Decimal value: " << decimal_value << " Scale: " << scale;
+  Real actual = dec.template ToReal<Real>(scale);
+  ASSERT_EQ(actual, expected) << "Decimal value: " << decimal_value
+                              << ", scale: " << scale << ", expected: " << expected
+                              << ", actual: " << actual;
 }
 
 template <typename Decimal, typename Real>
 void CheckDecimalToRealWithinOneULP(const std::string& decimal_value, int32_t scale,
                                     Real expected) {
   Decimal dec(decimal_value);
-  auto result = dec.template ToReal<Real>(scale);
-  ASSERT_TRUE(result == expected || result == std::nextafter(expected, expected + 1) ||
-              result == std::nextafter(expected, expected - 1))
-      << "Decimal value: " << decimal_value << " Scale: " << scale;
+  Real actual = dec.template ToReal<Real>(scale);
+  ASSERT_TRUE(actual == expected || actual == std::nextafter(expected, expected + 1) ||
+              actual == std::nextafter(expected, expected - 1))
+      << "Decimal value: " << decimal_value << ", scale: " << scale
+      << ", expected: " << expected << ", actual: " << actual;
 }
 
 template <typename Decimal, typename Real>
 void CheckDecimalToRealWithinEpsilon(const std::string& decimal_value, int32_t scale,
                                      Real epsilon, Real expected) {
   Decimal dec(decimal_value);
-  ASSERT_TRUE(std::abs(dec.template ToReal<Real>(scale) - expected) <= epsilon)
-      << "Decimal value: " << decimal_value << " Scale: " << scale;
+  Real actual = dec.template ToReal<Real>(scale);
+  ASSERT_LE(std::abs(actual - expected), epsilon)
+      << "Decimal value: " << decimal_value << ", scale: " << scale
+      << ", expected: " << expected << ", actual: " << actual;
 }
 
 template <typename Decimal>
 void CheckDecimalToRealApprox(const std::string& decimal_value, int32_t scale,
                               float expected) {
   Decimal dec(decimal_value);
-  ASSERT_FLOAT_EQ(dec.template ToReal<float>(scale), expected)
-      << "Decimal value: " << decimal_value << " Scale: " << scale;
+  float actual = dec.template ToReal<float>(scale);
+  ASSERT_FLOAT_EQ(actual, expected)
+      << "Decimal value: " << decimal_value << ", scale: " << scale
+      << ", expected: " << expected << ", actual: " << actual;
 }
 
 template <typename Decimal>
 void CheckDecimalToRealApprox(const std::string& decimal_value, int32_t scale,
                               double expected) {
   Decimal dec(decimal_value);
-  ASSERT_DOUBLE_EQ(dec.template ToReal<double>(scale), expected)
-      << "Decimal value: " << decimal_value << " Scale: " << scale;
+  double actual = dec.template ToReal<double>(scale);
+  ASSERT_DOUBLE_EQ(actual, expected)
+      << "Decimal value: " << decimal_value << ", scale: " << scale
+      << ", expected: " << expected << ", actual: " << actual;
 }
 
 // Common tests for Decimal128::ToReal<T> and Decimal256::ToReal<T>

From bebd2bf693901b56d54cd3c0dfd0d48a7ed3c0bf Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Wed, 19 Jul 2023 11:45:18 -0700
Subject: [PATCH 014/749] GH-34620: [C#] Support DateOnly and TimeOnly on .NET
 6.0+ (#36125)

### What changes are included in this PR?

Date32Array and Date64Array now support DateOnly values for construction and reading on .NET 6.0 and later.
Time32Array and Time64Array now support TimeOnly values for construction and reading on .NET 6.0 and later.
A new TimeArrayBuilder type is used to share logic between Time32Array.Builder and Time64Array.Builder just as the DateArrayBuilder does for the date array types.

### Are these changes tested?

Yes
* Closes: #34620

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 csharp/src/Apache.Arrow/Arrays/Date32Array.cs |  26 +++
 csharp/src/Apache.Arrow/Arrays/Date64Array.cs |  23 +++
 .../Apache.Arrow/Arrays/DateArrayBuilder.cs   |  70 ++++++++
 csharp/src/Apache.Arrow/Arrays/Time32Array.cs |  61 +++++--
 csharp/src/Apache.Arrow/Arrays/Time64Array.cs |  65 +++++++-
 .../Apache.Arrow/Arrays/TimeArrayBuilder.cs   | 152 ++++++++++++++++++
 .../Apache.Arrow.Tests.csproj                 |   6 +-
 .../Apache.Arrow.Tests/ArrayBuilderTests.cs   |   8 +-
 .../Apache.Arrow.Tests/ArrowArrayTests.cs     |   8 +-
 .../Apache.Arrow.Tests/Date32ArrayTests.cs    |  32 ++++
 .../Apache.Arrow.Tests/Date64ArrayTests.cs    |  33 ++++
 .../Apache.Arrow.Tests/TestDateAndTimeData.cs |   5 +
 .../test/Apache.Arrow.Tests/TimeOnlyTests.cs  | 111 +++++++++++++
 13 files changed, 574 insertions(+), 26 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
 create mode 100644 csharp/test/Apache.Arrow.Tests/TimeOnlyTests.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/Date32Array.cs b/csharp/src/Apache.Arrow/Arrays/Date32Array.cs
index 35c0065e11907..23ad7356eb322 100644
--- a/csharp/src/Apache.Arrow/Arrays/Date32Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Date32Array.cs
@@ -25,6 +25,9 @@ namespace Apache.Arrow
     public class Date32Array : PrimitiveArray<int>
     {
         private static readonly DateTime _epochDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
+#if NET6_0_OR_GREATER
+        private static readonly int _epochDayNumber = new DateOnly(1970, 1, 1).DayNumber;
+#endif
 
         /// <summary>
         /// The <see cref="Builder"/> class can be used to fluently build <see cref="Date32Array"/> objects.
@@ -57,6 +60,13 @@ protected override int Convert(DateTimeOffset dateTimeOffset)
                 // DateTimeOffset.Date property.
                 return (int)(dateTimeOffset.UtcDateTime.Date - _epochDate).TotalDays;
             }
+
+#if NET6_0_OR_GREATER
+            protected override int Convert(DateOnly date)
+            {
+                return (int)(date.DayNumber - _epochDayNumber);
+            }
+#endif
         }
 
         public Date32Array(
@@ -108,5 +118,21 @@ public Date32Array(ArrayData data)
                 ? new DateTimeOffset(_epochDate.AddDays(value.Value), TimeSpan.Zero)
                 : default(DateTimeOffset?);
         }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Get the date at the specified index
+        /// </summary>
+        /// <param name="index">Index at which to get the date.</param>
+        /// <returns>Returns a <see cref="DateOnly" />, or <c>null</c> if there is no object at that index.
+        /// </returns>
+        public DateOnly? GetDateOnly(int index)
+        {
+            int? value = GetValue(index);
+            return value.HasValue
+                ? DateOnly.FromDayNumber(_epochDayNumber + value.Value)
+                : default(DateOnly?);
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/Date64Array.cs b/csharp/src/Apache.Arrow/Arrays/Date64Array.cs
index cf977b2e4969a..b0d42e27bbd23 100644
--- a/csharp/src/Apache.Arrow/Arrays/Date64Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Date64Array.cs
@@ -69,6 +69,13 @@ protected override long Convert(DateTimeOffset dateTimeOffset)
                 long days = millis / MillisecondsPerDay;
                 return (millis < 0 ? days - 1 : days) * MillisecondsPerDay;
             }
+
+#if NET6_0_OR_GREATER
+            protected override long Convert(DateOnly date)
+            {
+                return ((long)date.DayNumber - _epochDayNumber) * MillisecondsPerDay;
+            }
+#endif
         }
 
         public Date64Array(ArrayData data)
@@ -113,5 +120,21 @@ public Date64Array(ArrayData data)
                 ? DateTimeOffset.FromUnixTimeMilliseconds(value.Value)
                 : default(DateTimeOffset?);
         }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Get the date at the specified index
+        /// </summary>
+        /// <param name="index">Index at which to get the date.</param>
+        /// <returns>Returns a <see cref="DateOnly" />, or <c>null</c> if there is no object at that index.
+        /// </returns>
+        public DateOnly? GetDateOnly(int index)
+        {
+            long? value = GetValue(index);
+            return value.HasValue
+                ? DateOnly.FromDateTime(DateTimeOffset.FromUnixTimeMilliseconds(value.Value).UtcDateTime)
+                : default(DateOnly?);
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
index 4e69f6fe3e7e1..dcbb76930b6d3 100644
--- a/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
@@ -28,9 +28,16 @@ public abstract class DateArrayBuilder<TUnderlying, TArray, TBuilder> :
         DelegatingArrayBuilder<TUnderlying, TArray, TBuilder>,
         IArrowArrayBuilder<DateTime, TArray, TBuilder>,
         IArrowArrayBuilder<DateTimeOffset, TArray, TBuilder>
+#if NET6_0_OR_GREATER
+        , IArrowArrayBuilder<DateOnly, TArray, TBuilder>
+#endif
         where TArray : IArrowArray
         where TBuilder : class, IArrowArrayBuilder<TArray>
     {
+#if NET6_0_OR_GREATER
+        protected static readonly long _epochDayNumber = new DateOnly(1970, 1, 1).DayNumber;
+#endif
+
         /// <summary>
         /// Construct a new instance of the <see cref="DateArrayBuilder{TUnderlying,TArray,TBuilder}"/> class.
         /// </summary>
@@ -72,6 +79,20 @@ public TBuilder Append(DateTimeOffset value)
             return this as TBuilder;
         }
 
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a date from a <see cref="DateOnly"/> object to the array.
+        /// </summary>
+        /// </remarks>
+        /// <param name="value">Date to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Append(DateOnly value)
+        {
+            InnerBuilder.Append(Convert(value));
+            return this as TBuilder;
+        }
+#endif
+
         /// <summary>
         /// Append a span of dates in the form of <see cref="DateTime"/> objects to the array.
         /// </summary>
@@ -114,6 +135,24 @@ public TBuilder Append(ReadOnlySpan<DateTimeOffset> span)
             return this as TBuilder;
         }
 
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a span of dates in the form of <see cref="DateOnly"/> objects to the array.
+        /// </summary>
+        /// <param name="span">Span of dates to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Append(ReadOnlySpan<DateOnly> span)
+        {
+            InnerBuilder.Reserve(span.Length);
+            foreach (var item in span)
+            {
+                InnerBuilder.Append(Convert(item));
+            }
+
+            return this as TBuilder;
+        }
+#endif
+
         /// <summary>
         /// Append a null date to the array.
         /// </summary>
@@ -156,6 +195,19 @@ public TBuilder AppendRange(IEnumerable<DateTimeOffset> values)
             return this as TBuilder;
         }
 
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a collection of dates in the form of <see cref="DateOnly"/> objects to the array.
+        /// </summary>
+        /// <param name="values">Collection of dates to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder AppendRange(IEnumerable<DateOnly> values)
+        {
+            InnerBuilder.AppendRange(values.Select(Convert));
+            return this as TBuilder;
+        }
+#endif
+
         /// <summary>
         /// Set the value of a date in the form of a <see cref="DateTime"/> object at the specified index.
         /// </summary>
@@ -190,6 +242,20 @@ public TBuilder Set(int index, DateTimeOffset value)
             return this as TBuilder;
         }
 
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Set the value of a date in the form of a <see cref="DateOnly"/> object at the specified index.
+        /// </summary>
+        /// <param name="index">Index at which to set value.</param>
+        /// <param name="value">Date to set.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Set(int index, DateOnly value)
+        {
+            InnerBuilder.Set(index, Convert(value));
+            return this as TBuilder;
+        }
+#endif
+
         /// <summary>
         /// Swap the values of the dates at the specified indices.
         /// </summary>
@@ -205,5 +271,9 @@ public TBuilder Swap(int i, int j)
         protected abstract TUnderlying Convert(DateTime dateTime);
 
         protected abstract TUnderlying Convert(DateTimeOffset dateTimeOffset);
+
+#if NET6_0_OR_GREATER
+        protected abstract TUnderlying Convert(DateOnly date);
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/Time32Array.cs b/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
index bdaf64d5561c7..31d17d06a1e40 100644
--- a/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 using Apache.Arrow.Types;
+using System;
 using System.IO;
 
 namespace Apache.Arrow
@@ -27,14 +28,19 @@ public class Time32Array : PrimitiveArray<int>
         /// <summary>
         /// The <see cref="Builder"/> class can be used to fluently build <see cref="Time32Array"/> objects.
         /// </summary>
-        public class Builder : PrimitiveArrayBuilder<int, Time32Array, Builder>
+        public class Builder : TimeArrayBuilder<int, Time32Array, Builder>
         {
-            protected override Time32Array Build(
-                ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
-                int length, int nullCount, int offset) =>
-                new Time32Array(DataType, valueBuffer, nullBitmapBuffer, length, nullCount, offset);
-            
-            protected Time32Type DataType { get; }
+            private class TimeBuilder : PrimitiveArrayBuilder<int, Time32Array, TimeBuilder>
+            {
+                public Time32Type DataType { get; }
+
+                public TimeBuilder(Time32Type dataType) => DataType = dataType;
+
+                protected override Time32Array Build(
+                    ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
+                    int length, int nullCount, int offset) =>
+                    new Time32Array(DataType, valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+            }
 
             public Builder()
                 : this(Time32Type.Default) { }
@@ -46,10 +52,22 @@ public Builder(TimeUnit unit)
             /// Construct a new instance of the <see cref="Builder"/> class.
             /// </summary>
             public Builder(Time32Type type)
-                : base()
+                : base(new TimeBuilder(type))
+            {
+            }
+
+#if NET6_0_OR_GREATER
+            protected override int Convert(TimeOnly time)
             {
-                DataType = type;
+                var unit = ((TimeBuilder)InnerBuilder).DataType.Unit;
+                return unit switch
+                {
+                    TimeUnit.Second => (int)(time.Ticks / TimeSpan.TicksPerSecond),
+                    TimeUnit.Millisecond => (int)(time.Ticks / TimeSpan.TicksPerMillisecond),
+                    _ => throw new InvalidDataException($"Unsupported time unit for Time32Type: {unit}")
+                };
             }
+#endif
         }
 
         public Time32Array(
@@ -113,5 +131,30 @@ public Time32Array(ArrayData data)
                 _ => throw new InvalidDataException($"Unsupported time unit for Time32Type: {unit}")
             };
         }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Get the time at the specified index as <see cref="TimeOnly"/>
+        /// </summary>
+        /// <param name="index">Index at which to get the time.</param>
+        /// <returns>Returns a <see cref="TimeOnly" />, or <c>null</c> if there is no object at that index.
+        /// </returns>
+        public TimeOnly? GetTime(int index)
+        {
+            int? value = GetValue(index);
+            if (value == null)
+            {
+                return null;
+            }
+
+            var unit = ((Time32Type)Data.DataType).Unit;
+            return unit switch
+            {
+                TimeUnit.Second => new TimeOnly(value.Value * TimeSpan.TicksPerSecond),
+                TimeUnit.Millisecond => new TimeOnly(value.Value * TimeSpan.TicksPerMillisecond),
+                _ => throw new InvalidDataException($"Unsupported time unit for Time32Type: {unit}")
+            };
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
index 127db63a7e09d..95faf18fe9e61 100644
--- a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 using Apache.Arrow.Types;
+using System;
 using System.IO;
 
 namespace Apache.Arrow
@@ -24,17 +25,25 @@ namespace Apache.Arrow
     /// </summary>
     public class Time64Array : PrimitiveArray<long>
     {
+        private const long TicksPerMicrosecond = 10;
+        private const long NanosecondsPerTick = 100;
+
         /// <summary>
         /// The <see cref="Builder"/> class can be used to fluently build <see cref="Time64Array"/> objects.
         /// </summary>
-        public class Builder : PrimitiveArrayBuilder<long, Time64Array, Builder>
+        public class Builder : TimeArrayBuilder<long, Time64Array, Builder>
         {
-            protected override Time64Array Build(
-                ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
-                int length, int nullCount, int offset) =>
-                new Time64Array(DataType, valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+            private class TimeBuilder : PrimitiveArrayBuilder<long, Time64Array, TimeBuilder>
+            {
+                public Time64Type DataType { get; }
 
-            protected Time64Type DataType { get; }
+                public TimeBuilder(Time64Type dataType) => DataType = dataType;
+
+                protected override Time64Array Build(
+                    ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
+                    int length, int nullCount, int offset) =>
+                    new Time64Array(DataType, valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+            }
 
             public Builder()
                 : this(Time64Type.Default) { }
@@ -46,10 +55,22 @@ public Builder(TimeUnit unit)
             /// Construct a new instance of the <see cref="Builder"/> class.
             /// </summary>
             public Builder(Time64Type type)
-                : base()
+                : base(new TimeBuilder(type))
+            {
+            }
+
+#if NET6_0_OR_GREATER
+            protected override long Convert(TimeOnly time)
             {
-                DataType = type;
+                var unit = ((TimeBuilder)InnerBuilder).DataType.Unit;
+                return unit switch
+                {
+                    TimeUnit.Microsecond => (long)(time.Ticks / TicksPerMicrosecond),
+                    TimeUnit.Nanosecond => (long)(time.Ticks * NanosecondsPerTick),
+                    _ => throw new InvalidDataException($"Unsupported time unit for Time32Type: {unit}")
+                };
             }
+#endif
         }
 
         public Time64Array(
@@ -113,5 +134,33 @@ public Time64Array(ArrayData data)
                 _ => throw new InvalidDataException($"Unsupported time unit for Time64Type: {unit}")
             };
         }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Get the time at the specified index as <see cref="TimeOnly"/>
+        /// </summary>
+        /// <remarks>
+        /// This may cause truncation of nanosecond values, as the resolution of TimeOnly is in 100-ns increments.
+        /// </remarks>
+        /// <param name="index">Index at which to get the time.</param>
+        /// <returns>Returns a <see cref="TimeOnly" />, or <c>null</c> if there is no object at that index.
+        /// </returns>
+        public TimeOnly? GetTime(int index)
+        {
+            long? value = GetValue(index);
+            if (value == null)
+            {
+                return null;
+            }
+
+            var unit = ((Time64Type)Data.DataType).Unit;
+            return unit switch
+            {
+                TimeUnit.Microsecond => new TimeOnly(value.Value * TicksPerMicrosecond),
+                TimeUnit.Nanosecond => new TimeOnly(value.Value / NanosecondsPerTick),
+                _ => throw new InvalidDataException($"Unsupported time unit for Time64Type: {unit}")
+            };
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
new file mode 100644
index 0000000000000..da93db84717da
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
@@ -0,0 +1,152 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Apache.Arrow
+{
+    public abstract class TimeArrayBuilder<TUnderlying, TArray, TBuilder> :
+        DelegatingArrayBuilder<TUnderlying, TArray, TBuilder>
+#if NET6_0_OR_GREATER
+        , IArrowArrayBuilder<TimeOnly, TArray, TBuilder>
+#endif
+        where TArray : IArrowArray
+        where TBuilder : class, IArrowArrayBuilder<TArray>
+    {
+        /// <summary>
+        /// Construct a new instance of the <see cref="TimeArrayBuilder{TUnderlying,TArray,TBuilder}"/> class.
+        /// </summary>
+        /// <param name="innerBuilder">Inner builder that will produce arrays of type <typeparamref name="TArray"/>.
+        /// </param>
+        protected TimeArrayBuilder(IArrowArrayBuilder<TUnderlying, TArray, IArrowArrayBuilder<TArray>> innerBuilder)
+            : base(innerBuilder)
+        { }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a time in the form of a <see cref="TimeOnly"/> object to the array.
+        /// </summary>
+        /// <param name="value">Time to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Append(TimeOnly value)
+        {
+            InnerBuilder.Append(Convert(value));
+            return this as TBuilder;
+        }
+#endif
+
+        /// <summary>
+        /// Append a time
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public TBuilder Append(TUnderlying value)
+        {
+            InnerBuilder.Append(value);
+            return this as TBuilder;
+        }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a span of times in the form of <see cref="TimeOnly"/> objects to the array.
+        /// </summary>
+        /// <param name="span">Span of times to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Append(ReadOnlySpan<TimeOnly> span)
+        {
+            InnerBuilder.Reserve(span.Length);
+            foreach (var item in span)
+            {
+                InnerBuilder.Append(Convert(item));
+            }
+
+            return this as TBuilder;
+        }
+#endif
+
+        public TBuilder Append(ReadOnlySpan<TUnderlying> values)
+        {
+            InnerBuilder.Append(values);
+            return this as TBuilder;
+        }
+
+        /// <summary>
+        /// Append a null time to the array.
+        /// </summary>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder AppendNull()
+        {
+            InnerBuilder.AppendNull();
+            return this as TBuilder;
+        }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Append a collection of times in the form of <see cref="TimeOnly"/> objects to the array.
+        /// </summary>
+        /// <param name="values">Collection of times to add.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder AppendRange(IEnumerable<TimeOnly> values)
+        {
+            InnerBuilder.AppendRange(values.Select(Convert));
+            return this as TBuilder;
+        }
+#endif
+
+        public TBuilder AppendRange(IEnumerable<TUnderlying> values)
+        {
+            InnerBuilder.AppendRange(values);
+            return this as TBuilder;
+        }
+
+#if NET6_0_OR_GREATER
+        /// <summary>
+        /// Set the value of a time in the form of a <see cref="TimeOnly"/> object at the specified index.
+        /// </summary>
+        /// <param name="index">Index at which to set value.</param>
+        /// <param name="value">Time to set.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Set(int index, TimeOnly value)
+        {
+            InnerBuilder.Set(index, Convert(value));
+            return this as TBuilder;
+        }
+#endif
+
+        public TBuilder Set(int index, TUnderlying value)
+        {
+            InnerBuilder.Set(index, value);
+            return this as TBuilder;
+        }
+
+        /// <summary>
+        /// Swap the values of the times at the specified indices.
+        /// </summary>
+        /// <param name="i">First index.</param>
+        /// <param name="j">Second index.</param>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public TBuilder Swap(int i, int j)
+        {
+            InnerBuilder.Swap(i, j);
+            return this as TBuilder;
+        }
+
+#if NET6_0_OR_GREATER
+        protected abstract TUnderlying Convert(TimeOnly time);
+#endif
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index cdbfe479470a4..55005a91c74a1 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
@@ -21,4 +21,8 @@
     <ProjectReference Include="..\..\src\Apache.Arrow\Apache.Arrow.csproj" />
   </ItemGroup>
 
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible($(TargetFramework), 'net6.0'))">
+    <Compile Remove="TimeOnlyTests.cs" />
+  </ItemGroup>
+  
 </Project>
\ No newline at end of file
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
index 9ac2f779a6f69..0c40fd82af7ce 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
@@ -40,8 +40,8 @@ public void PrimitiveArrayBuildersProduceExpectedArray()
             Test<Half, HalfFloatArray, HalfFloatArray.Builder>();
             Test<float, FloatArray, FloatArray.Builder>();
             Test<double, DoubleArray, DoubleArray.Builder>();
-            Test<int, Time32Array, Time32Array.Builder>();
-            Test<long, Time64Array, Time64Array.Builder>();
+            TestArrayBuilder<Time32Array, Time32Array.Builder>(x => x.Append(10).Append(20).Append(30));
+            TestArrayBuilder<Time64Array, Time64Array.Builder>(x => x.Append(10).Append(20).Append(30));
 
             static void Test<T, TArray, TBuilder>()
                 where T : struct, INumber<T>
@@ -64,8 +64,8 @@ public void PrimitiveArrayBuildersProduceExpectedArrayWithNulls()
             Test<Half, HalfFloatArray, HalfFloatArray.Builder>();
             Test<float, FloatArray, FloatArray.Builder>();
             Test<double, DoubleArray, DoubleArray.Builder>();
-            Test<int, Time32Array, Time32Array.Builder>();
-            Test<long, Time64Array, Time64Array.Builder>();
+            TestArrayBuilder<Time32Array, Time32Array.Builder>(x => x.Append(123).AppendNull().AppendNull().Append(127), 4, 2, 0x9);
+            TestArrayBuilder<Time64Array, Time64Array.Builder>(x => x.Append(123).AppendNull().AppendNull().Append(127), 4, 2, 0x9);
 
             static void Test<T, TArray, TBuilder>()
                 where T : struct, INumber<T>
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
index af3e0f80e6473..16fca684ff5ec 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
@@ -109,8 +109,8 @@ public void SliceArray()
             TestNumberSlice<double, DoubleArray, DoubleArray.Builder>();
             TestSlice<Date32Array, Date32Array.Builder>(x => x.Append(new DateTime(2019, 1, 1)).Append(new DateTime(2019, 1, 2)).Append(new DateTime(2019, 1, 3)));
             TestSlice<Date64Array, Date64Array.Builder>(x => x.Append(new DateTime(2019, 1, 1)).Append(new DateTime(2019, 1, 2)).Append(new DateTime(2019, 1, 3)));
-            TestNumberSlice<int, Time32Array, Time32Array.Builder>();
-            TestNumberSlice<long, Time64Array, Time64Array.Builder>();
+            TestSlice<Time32Array, Time32Array.Builder>(x => x.Append(10).Append(20).Append(30));
+            TestSlice<Time64Array, Time64Array.Builder>(x => x.Append(10).Append(20).Append(30));
             TestSlice<StringArray, StringArray.Builder>(x => x.Append("10").Append("20").Append("30"));
 
             static void TestNumberSlice<T, TArray, TBuilder>()
@@ -136,8 +136,8 @@ public void SlicePrimitiveArrayWithNulls()
             TestNumberSlice<double, DoubleArray, DoubleArray.Builder>();
             TestSlice<Date32Array, Date32Array.Builder>(x => x.Append(new DateTime(2019, 1, 1)).Append(new DateTime(2019, 1, 2)).AppendNull().Append(new DateTime(2019, 1, 3)));
             TestSlice<Date64Array, Date64Array.Builder>(x => x.Append(new DateTime(2019, 1, 1)).Append(new DateTime(2019, 1, 2)).AppendNull().Append(new DateTime(2019, 1, 3)));
-            TestNumberSlice<int, Time32Array, Time32Array.Builder>();
-            TestNumberSlice<long, Time64Array, Time64Array.Builder>();
+            TestSlice<Time32Array, Time32Array.Builder>(x => x.Append(10).Append(20).AppendNull().Append(30));
+            TestSlice<Time64Array, Time64Array.Builder>(x => x.Append(10).Append(20).AppendNull().Append(30));
 
             static void TestNumberSlice<T, TArray, TBuilder>()
                 where T : struct, INumber<T>
diff --git a/csharp/test/Apache.Arrow.Tests/Date32ArrayTests.cs b/csharp/test/Apache.Arrow.Tests/Date32ArrayTests.cs
index 0d6aad96e5dfd..2a674b942c17b 100644
--- a/csharp/test/Apache.Arrow.Tests/Date32ArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/Date32ArrayTests.cs
@@ -31,6 +31,11 @@ public static IEnumerable<object[]> GetDateTimesData() =>
         public static IEnumerable<object[]> GetDateTimeOffsetsData() =>
             TestDateAndTimeData.ExampleDateTimeOffsets.Select(dto => new object[] { dto });
 
+#if NET6_0_OR_GREATER
+        public static IEnumerable<object[]> GetDateOnlyData() =>
+            TestDateAndTimeData.ExampleDates.Select(d => new object[] { DateOnly.FromDateTime(d) });
+#endif
+
         public class AppendNull
         {
             [Fact]
@@ -121,5 +126,32 @@ public void AppendGivesUtcDate(DateTimeOffset dateTimeOffset)
                 Assert.Equal(expectedValue, array.GetValue(0));
             }
         }
+
+#if NET6_0_OR_GREATER
+        public class AppendDateOnly
+        {
+            [Theory]
+            [MemberData(nameof(GetDateOnlyData), MemberType = typeof(Date64ArrayTests))]
+            public void AppendDateGivesSameDate(DateOnly date)
+            {
+                // Arrange
+                var builder = new Date32Array.Builder();
+                var expectedDateTime = date.ToDateTime(TimeOnly.MinValue);
+                var expectedDateTimeOffset = new DateTimeOffset(expectedDateTime, TimeSpan.Zero);
+                int expectedValue = date.DayNumber - new DateOnly(1970, 1, 1).DayNumber;
+
+                // Act
+                builder = builder.Append(date);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(date, array.GetDateOnly(0));
+                Assert.Equal(expectedDateTime, array.GetDateTime(0));
+                Assert.Equal(expectedDateTimeOffset, array.GetDateTimeOffset(0));
+                Assert.Equal(expectedValue, array.GetValue(0));
+            }
+        }
+#endif
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/Date64ArrayTests.cs b/csharp/test/Apache.Arrow.Tests/Date64ArrayTests.cs
index 65cffc84e5555..22ae08a617c48 100644
--- a/csharp/test/Apache.Arrow.Tests/Date64ArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/Date64ArrayTests.cs
@@ -33,6 +33,11 @@ public static IEnumerable<object[]> GetDateTimesData() =>
         public static IEnumerable<object[]> GetDateTimeOffsetsData() =>
             TestDateAndTimeData.ExampleDateTimeOffsets.Select(dto => new object[] { dto });
 
+#if NET6_0_OR_GREATER
+        public static IEnumerable<object[]> GetDateOnlyData() =>
+            TestDateAndTimeData.ExampleDates.Select(d => new object[] { DateOnly.FromDateTime(d) });
+#endif
+
         public class AppendNull
         {
             [Fact]
@@ -129,5 +134,33 @@ public void AppendGivesUtcDate(DateTimeOffset dateTimeOffset)
                 Assert.Equal(0, array.GetValue(0).Value % MillisecondsPerDay);
             }
         }
+
+#if NET6_0_OR_GREATER
+        public class AppendDateOnly
+        {
+            [Theory]
+            [MemberData(nameof(GetDateOnlyData), MemberType = typeof(Date64ArrayTests))]
+            public void AppendDateGivesSameDate(DateOnly date)
+            {
+                // Arrange
+                var builder = new Date64Array.Builder();
+                var expectedDateTime = date.ToDateTime(TimeOnly.MinValue);
+                var expectedDateTimeOffset = new DateTimeOffset(expectedDateTime, TimeSpan.Zero);
+                long expectedValue = (date.DayNumber - new DateOnly(1970, 1, 1).DayNumber) * MillisecondsPerDay;
+
+                // Act
+                builder = builder.Append(date);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(date, array.GetDateOnly(0));
+                Assert.Equal(expectedDateTime, array.GetDateTime(0));
+                Assert.Equal(expectedDateTimeOffset, array.GetDateTimeOffset(0));
+                Assert.Equal(expectedValue, array.GetValue(0));
+                Assert.Equal(0, array.GetValue(0).Value % MillisecondsPerDay);
+            }
+        }
+#endif
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/TestDateAndTimeData.cs b/csharp/test/Apache.Arrow.Tests/TestDateAndTimeData.cs
index 1f2eae45b039c..c258fdd2d6988 100644
--- a/csharp/test/Apache.Arrow.Tests/TestDateAndTimeData.cs
+++ b/csharp/test/Apache.Arrow.Tests/TestDateAndTimeData.cs
@@ -59,6 +59,11 @@ from date in _exampleDates
             from kind in _exampleKinds
             select DateTime.SpecifyKind(date, kind);
 
+        /// <summary>
+        /// Gets a collection of example times
+        /// </summary>
+        public static IEnumerable<TimeSpan> ExampleTimes => _exampleTimes;
+
         /// <summary>
         /// Gets a collection of example date/times, of all different kinds.
         /// </summary>
diff --git a/csharp/test/Apache.Arrow.Tests/TimeOnlyTests.cs b/csharp/test/Apache.Arrow.Tests/TimeOnlyTests.cs
new file mode 100644
index 0000000000000..cd66530a0e935
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/TimeOnlyTests.cs
@@ -0,0 +1,111 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Apache.Arrow.Types;
+using Xunit;
+
+namespace Apache.Arrow.Tests
+{
+    public class TimeOnlyTests
+    {
+        private static IEnumerable<object[]> GetTimeOnlyData(params TimeUnit[] units) =>
+            from time in TestDateAndTimeData.ExampleTimes
+            from unit in units
+            select new object[] { TimeOnly.FromTimeSpan(time), unit };
+
+        public class Time32
+        {
+            public static IEnumerable<object[]> GetTestData => GetTimeOnlyData(TimeUnit.Second, TimeUnit.Millisecond);
+
+            [Fact]
+            public void AppendThenGetGivesNull()
+            {
+                // Arrange
+                var builder = new Time32Array.Builder();
+
+                // Act
+                builder = builder.AppendNull();
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Null(array.GetTime(0));
+                Assert.Null(array.GetValue(0));
+            }
+
+            [Theory]
+            [MemberData(nameof(GetTestData))]
+            public void AppendTimeGivesSameTime(TimeOnly time, TimeUnit timeUnit)
+            {
+                // Arrange
+                var builder = new Time32Array.Builder(timeUnit);
+                var expectedTime = time;
+                int expectedMilliseconds = (int)(time.Ticks / TimeSpan.TicksPerMillisecond);
+
+                // Act
+                builder = builder.Append(time);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(expectedTime, array.GetTime(0));
+                Assert.Equal(expectedMilliseconds, array.GetMilliSeconds(0));
+            }
+        }
+
+        public class Time64
+        {
+            public static IEnumerable<object[]> GetTestData => GetTimeOnlyData(TimeUnit.Microsecond, TimeUnit.Nanosecond);
+
+            [Fact]
+            public void AppendThenGetGivesNull()
+            {
+                // Arrange
+                var builder = new Time64Array.Builder();
+
+                // Act
+                builder = builder.AppendNull();
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Null(array.GetTime(0));
+                Assert.Null(array.GetValue(0));
+            }
+
+            [Theory]
+            [MemberData(nameof(GetTestData))]
+            public void AppendTimeGivesSameTime(TimeOnly time, TimeUnit timeUnit)
+            {
+                // Arrange
+                var builder = new Time64Array.Builder(timeUnit);
+                var expectedTime = time;
+                long expectedNanoseconds = time.Ticks * TimeSpan.NanosecondsPerTick;
+
+                // Act
+                builder = builder.Append(time);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(expectedTime, array.GetTime(0));
+                Assert.Equal(expectedNanoseconds, array.GetNanoSeconds(0));
+            }
+        }
+    }
+}

From 3f0b62038d7ddac090db316722f5a1695e85701b Mon Sep 17 00:00:00 2001
From: Ivan Chesnov <xxxlaykxxx@gmail.com>
Date: Wed, 19 Jul 2023 23:40:47 +0300
Subject: [PATCH 015/749] GH-36433: [C++] Update fast_float version to 3.10.1
 (#36434)

### Rationale for this change

Need this for parsing Infinity values with + sign.

### What changes are included in this PR?

updated version of fast_float to version 3.10.1 (used this version because in higher versions c++ 20 started using that cause a lot of build errors)

### Are these changes tested?

in scope of fast_float.

### Are there any user-facing changes?
no

* Closes: #36433

Lead-authored-by: Ivan Chesnov <ivan.chesnov@dremio.com>
Co-authored-by: Ivan Chesnov <xxxlaykxxx@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/value_parsing.cc           |    2 +
 cpp/src/arrow/util/value_parsing_test.cc      |    6 +
 cpp/src/arrow/vendored/fast_float/README.md   |    4 +-
 .../arrow/vendored/fast_float/ascii_number.h  |   15 +-
 cpp/src/arrow/vendored/fast_float/bigint.h    |  144 +-
 .../fast_float/constexpr_feature_detect.h     |   40 +
 .../vendored/fast_float/decimal_to_binary.h   |   17 +-
 .../vendored/fast_float/digit_comparison.h    |   37 +-
 .../arrow/vendored/fast_float/fast_float.h    |    2 +-
 .../arrow/vendored/fast_float/fast_table.h    | 1313 +++++++++--------
 .../arrow/vendored/fast_float/float_common.h  |  179 ++-
 .../arrow/vendored/fast_float/parse_number.h  |   32 +
 cpp/src/arrow/vendored/fast_float/update.sh   |    2 +-
 13 files changed, 991 insertions(+), 802 deletions(-)
 create mode 100644 cpp/src/arrow/vendored/fast_float/constexpr_feature_detect.h

diff --git a/cpp/src/arrow/util/value_parsing.cc b/cpp/src/arrow/util/value_parsing.cc
index 92495612a7df8..f6a24ac1467f8 100644
--- a/cpp/src/arrow/util/value_parsing.cc
+++ b/cpp/src/arrow/util/value_parsing.cc
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#define FASTFLOAT_ALLOWS_LEADING_PLUS 1
+
 #include "arrow/util/value_parsing.h"
 
 #include <string>
diff --git a/cpp/src/arrow/util/value_parsing_test.cc b/cpp/src/arrow/util/value_parsing_test.cc
index 6f83b6dfa6592..30c5e6aae74ba 100644
--- a/cpp/src/arrow/util/value_parsing_test.cc
+++ b/cpp/src/arrow/util/value_parsing_test.cc
@@ -119,6 +119,9 @@ TEST(StringConversion, ToFloat) {
   AssertConversion<FloatType>("0", 0.0f);
   AssertConversion<FloatType>("-0.0", -0.0f);
   AssertConversion<FloatType>("-1e20", -1e20f);
+  AssertConversion<FloatType>("+Infinity", std::numeric_limits<float>::infinity());
+  AssertConversion<FloatType>("-Infinity", -std::numeric_limits<float>::infinity());
+  AssertConversion<FloatType>("Infinity", std::numeric_limits<float>::infinity());
 
   AssertConversionFails<FloatType>("");
   AssertConversionFails<FloatType>("e");
@@ -135,6 +138,9 @@ TEST(StringConversion, ToDouble) {
   AssertConversion<DoubleType>("0", 0);
   AssertConversion<DoubleType>("-0.0", -0.0);
   AssertConversion<DoubleType>("-1e100", -1e100);
+  AssertConversion<DoubleType>("+Infinity", std::numeric_limits<double>::infinity());
+  AssertConversion<DoubleType>("-Infinity", -std::numeric_limits<double>::infinity());
+  AssertConversion<DoubleType>("Infinity", std::numeric_limits<double>::infinity());
 
   AssertConversionFails<DoubleType>("");
   AssertConversionFails<DoubleType>("e");
diff --git a/cpp/src/arrow/vendored/fast_float/README.md b/cpp/src/arrow/vendored/fast_float/README.md
index 6d44654f2a721..b07c280e0ad44 100644
--- a/cpp/src/arrow/vendored/fast_float/README.md
+++ b/cpp/src/arrow/vendored/fast_float/README.md
@@ -20,7 +20,7 @@
 # fast_float
 
 The files in this directory are vendored from fast_float
-git tag `v3.8.1`.
+git tag `v3.10.1`.
 
 See https://github.com/fastfloat/fast_float
 
@@ -31,7 +31,7 @@ See https://github.com/fastfloat/fast_float
 ## How to update
 
 You must replace `VERSION` in the command lines with suitable version
-such as `3.8.1`.
+such as `3.10.1`.
 
 ```bash
 cpp/src/arrow/vendoered/fast_float/update.sh VERSION
diff --git a/cpp/src/arrow/vendored/fast_float/ascii_number.h b/cpp/src/arrow/vendored/fast_float/ascii_number.h
index 24ec813174a7a..6d825ccfb5a48 100644
--- a/cpp/src/arrow/vendored/fast_float/ascii_number.h
+++ b/cpp/src/arrow/vendored/fast_float/ascii_number.h
@@ -13,9 +13,11 @@ namespace fast_float {
 
 // Next function can be micro-optimized, but compilers are entirely
 // able to optimize it well.
-fastfloat_really_inline bool is_integer(char c)  noexcept  { return c >= '0' && c <= '9'; }
+fastfloat_really_inline constexpr bool is_integer(char c) noexcept {
+  return c >= '0' && c <= '9';
+}
 
-fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+fastfloat_really_inline constexpr uint64_t byteswap(uint64_t val) {
   return (val & 0xFF00000000000000) >> 56
     | (val & 0x00FF000000000000) >> 40
     | (val & 0x0000FF0000000000) >> 24
@@ -45,7 +47,8 @@ fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
 }
 
 // credit  @aqrit
-fastfloat_really_inline uint32_t  parse_eight_digits_unrolled(uint64_t val) {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+uint32_t parse_eight_digits_unrolled(uint64_t val) {
   const uint64_t mask = 0x000000FF000000FF;
   const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
   const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
@@ -60,7 +63,7 @@ fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)
 }
 
 // credit @aqrit
-fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
+fastfloat_really_inline constexpr bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
   return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
      0x8080808080808080));
 }
@@ -94,7 +97,11 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
   answer.valid = false;
   answer.too_many_digits = false;
   answer.negative = (*p == '-');
+#if FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if ((*p == '-') || (*p == '+')) {
+#else
   if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+#endif
     ++p;
     if (p == pend) {
       return answer;
diff --git a/cpp/src/arrow/vendored/fast_float/bigint.h b/cpp/src/arrow/vendored/fast_float/bigint.h
index b733c7b64ba6a..bc083893ac4ca 100644
--- a/cpp/src/arrow/vendored/fast_float/bigint.h
+++ b/cpp/src/arrow/vendored/fast_float/bigint.h
@@ -51,27 +51,27 @@ struct stackvec {
   stackvec &operator=(stackvec &&other) = delete;
 
   // create stack vector from existing limb span.
-  stackvec(limb_span s) {
+  FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) {
     FASTFLOAT_ASSERT(try_extend(s));
   }
 
-  limb& operator[](size_t index) noexcept {
+  FASTFLOAT_CONSTEXPR14 limb& operator[](size_t index) noexcept {
     FASTFLOAT_DEBUG_ASSERT(index < length);
     return data[index];
   }
-  const limb& operator[](size_t index) const noexcept {
+  FASTFLOAT_CONSTEXPR14 const limb& operator[](size_t index) const noexcept {
     FASTFLOAT_DEBUG_ASSERT(index < length);
     return data[index];
   }
   // index from the end of the container
-  const limb& rindex(size_t index) const noexcept {
+  FASTFLOAT_CONSTEXPR14 const limb& rindex(size_t index) const noexcept {
     FASTFLOAT_DEBUG_ASSERT(index < length);
     size_t rindex = length - index - 1;
     return data[rindex];
   }
 
   // set the length, without bounds checking.
-  void set_len(size_t len) noexcept {
+  FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept {
     length = uint16_t(len);
   }
   constexpr size_t len() const noexcept {
@@ -84,12 +84,12 @@ struct stackvec {
     return size;
   }
   // append item to vector, without bounds checking
-  void push_unchecked(limb value) noexcept {
+  FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept {
     data[length] = value;
     length++;
   }
   // append item to vector, returning if item was added
-  bool try_push(limb value) noexcept {
+  FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept {
     if (len() < capacity()) {
       push_unchecked(value);
       return true;
@@ -98,13 +98,13 @@ struct stackvec {
     }
   }
   // add items to the vector, from a span, without bounds checking
-  void extend_unchecked(limb_span s) noexcept {
+  FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept {
     limb* ptr = data + length;
-    ::memcpy((void*)ptr, (const void*)s.ptr, sizeof(limb) * s.len());
+    std::copy_n(s.ptr, s.len(), ptr);
     set_len(len() + s.len());
   }
   // try to add items to the vector, returning if items were added
-  bool try_extend(limb_span s) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept {
     if (len() + s.len() <= capacity()) {
       extend_unchecked(s);
       return true;
@@ -115,6 +115,7 @@ struct stackvec {
   // resize the vector, without bounds checking
   // if the new size is longer than the vector, assign value to each
   // appended item.
+  FASTFLOAT_CONSTEXPR20
   void resize_unchecked(size_t new_len, limb value) noexcept {
     if (new_len > len()) {
       size_t count = new_len - len();
@@ -127,7 +128,7 @@ struct stackvec {
     }
   }
   // try to resize the vector, returning if the vector was resized.
-  bool try_resize(size_t new_len, limb value) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept {
     if (new_len > capacity()) {
       return false;
     } else {
@@ -138,7 +139,7 @@ struct stackvec {
   // check if any limbs are non-zero after the given index.
   // this needs to be done in reverse order, since the index
   // is relative to the most significant limbs.
-  bool nonzero(size_t index) const noexcept {
+  FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept {
     while (index < len()) {
       if (rindex(index) != 0) {
         return true;
@@ -148,27 +149,27 @@ struct stackvec {
     return false;
   }
   // normalize the big integer, so most-significant zero limbs are removed.
-  void normalize() noexcept {
+  FASTFLOAT_CONSTEXPR14 void normalize() noexcept {
     while (len() > 0 && rindex(0) == 0) {
       length--;
     }
   }
 };
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
 uint64_t empty_hi64(bool& truncated) noexcept {
   truncated = false;
   return 0;
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept {
   truncated = false;
   int shl = leading_zeroes(r0);
   return r0 << shl;
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
   int shl = leading_zeroes(r0);
   if (shl == 0) {
@@ -181,19 +182,19 @@ uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
   }
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept {
   return uint64_hi64(r0, truncated);
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept {
   uint64_t x0 = r0;
   uint64_t x1 = r1;
   return uint64_hi64((x0 << 32) | x1, truncated);
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept {
   uint64_t x0 = r0;
   uint64_t x1 = r1;
@@ -205,15 +206,16 @@ uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noe
 // we want an efficient operation. for msvc, where
 // we don't have built-in intrinsics, this is still
 // pretty fast.
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 limb scalar_add(limb x, limb y, bool& overflow) noexcept {
   limb z;
-
 // gcc and clang
 #if defined(__has_builtin)
   #if __has_builtin(__builtin_add_overflow)
-    overflow = __builtin_add_overflow(x, y, &z);
-    return z;
+    if (!cpp20_and_in_constexpr()) {
+      overflow = __builtin_add_overflow(x, y, &z);
+      return z;
+    }
   #endif
 #endif
 
@@ -224,7 +226,7 @@ limb scalar_add(limb x, limb y, bool& overflow) noexcept {
 }
 
 // multiply two small integers, getting both the high and low bits.
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
 limb scalar_mul(limb x, limb y, limb& carry) noexcept {
 #ifdef FASTFLOAT_64BIT_LIMB
   #if defined(__SIZEOF_INT128__)
@@ -252,7 +254,8 @@ limb scalar_mul(limb x, limb y, limb& carry) noexcept {
 // add scalar value to bigint starting from offset.
 // used in grade school multiplication
 template <uint16_t size>
-inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
+inline FASTFLOAT_CONSTEXPR20
+bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
   size_t index = start;
   limb carry = y;
   bool overflow;
@@ -269,13 +272,15 @@ inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
 
 // add scalar value to bigint.
 template <uint16_t size>
-fastfloat_really_inline bool small_add(stackvec<size>& vec, limb y) noexcept {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
+bool small_add(stackvec<size>& vec, limb y) noexcept {
   return small_add_from(vec, y, 0);
 }
 
 // multiply bigint by scalar value.
 template <uint16_t size>
-inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
+inline FASTFLOAT_CONSTEXPR20
+bool small_mul(stackvec<size>& vec, limb y) noexcept {
   limb carry = 0;
   for (size_t index = 0; index < vec.len(); index++) {
     vec[index] = scalar_mul(vec[index], y, carry);
@@ -289,6 +294,7 @@ inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
 // add bigint to bigint starting from index.
 // used in grade school multiplication
 template <uint16_t size>
+FASTFLOAT_CONSTEXPR20
 bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
   // the effective x buffer is from `xstart..x.len()`, so exit early
   // if we can't get that current range.
@@ -319,12 +325,14 @@ bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
 
 // add bigint to bigint.
 template <uint16_t size>
-fastfloat_really_inline bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
+bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
   return large_add_from(x, y, 0);
 }
 
 // grade-school multiplication algorithm
 template <uint16_t size>
+FASTFLOAT_CONSTEXPR20
 bool long_mul(stackvec<size>& x, limb_span y) noexcept {
   limb_span xs = limb_span(x.data, x.len());
   stackvec<size> z(xs);
@@ -353,6 +361,7 @@ bool long_mul(stackvec<size>& x, limb_span y) noexcept {
 
 // grade-school multiplication algorithm
 template <uint16_t size>
+FASTFLOAT_CONSTEXPR20
 bool large_mul(stackvec<size>& x, limb_span y) noexcept {
   if (y.len() == 1) {
     FASTFLOAT_TRY(small_mul(x, y[0]));
@@ -362,21 +371,52 @@ bool large_mul(stackvec<size>& x, limb_span y) noexcept {
   return true;
 }
 
+template <typename = void>
+struct pow5_tables {
+  static constexpr uint32_t large_step = 135;
+  static constexpr uint64_t small_power_of_5[] = {
+    1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
+    1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
+    6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
+    3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
+    2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
+    298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
+  };
+#ifdef FASTFLOAT_64BIT_LIMB
+  constexpr static limb large_power_of_5[] = {
+    1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+    10482974169319127550UL, 198276706040285095UL};
+#else
+  constexpr static limb large_power_of_5[] = {
+    4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
+    1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
+#endif
+};
+
+template <typename T>
+constexpr uint32_t pow5_tables<T>::large_step;
+
+template <typename T>
+constexpr uint64_t pow5_tables<T>::small_power_of_5[];
+
+template <typename T>
+constexpr limb pow5_tables<T>::large_power_of_5[];
+
 // big integer type. implements a small subset of big integer
 // arithmetic, using simple algorithms since asymptotically
 // faster algorithms are slower for a small number of limbs.
 // all operations assume the big-integer is normalized.
-struct bigint {
+struct bigint : pow5_tables<> {
   // storage of the limbs, in little-endian order.
   stackvec<bigint_limbs> vec;
 
-  bigint(): vec() {}
+  FASTFLOAT_CONSTEXPR20 bigint(): vec() {}
   bigint(const bigint &) = delete;
   bigint &operator=(const bigint &) = delete;
   bigint(bigint &&) = delete;
   bigint &operator=(bigint &&other) = delete;
 
-  bigint(uint64_t value): vec() {
+  FASTFLOAT_CONSTEXPR20 bigint(uint64_t value): vec() {
 #ifdef FASTFLOAT_64BIT_LIMB
     vec.push_unchecked(value);
 #else
@@ -388,7 +428,7 @@ struct bigint {
 
   // get the high 64 bits from the vector, and if bits were truncated.
   // this is to get the significant digits for the float.
-  uint64_t hi64(bool& truncated) const noexcept {
+  FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool& truncated) const noexcept {
 #ifdef FASTFLOAT_64BIT_LIMB
     if (vec.len() == 0) {
       return empty_hi64(truncated);
@@ -420,7 +460,7 @@ struct bigint {
   // positive, this is larger, otherwise they are equal.
   // the limbs are stored in little-endian order, so we
   // must compare the limbs in ever order.
-  int compare(const bigint& other) const noexcept {
+  FASTFLOAT_CONSTEXPR20 int compare(const bigint& other) const noexcept {
     if (vec.len() > other.vec.len()) {
       return 1;
     } else if (vec.len() < other.vec.len()) {
@@ -441,7 +481,7 @@ struct bigint {
 
   // shift left each limb n bits, carrying over to the new limb
   // returns true if we were able to shift all the digits.
-  bool shl_bits(size_t n) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept {
     // Internally, for each item, we shift left by n, and add the previous
     // right shifted limb-bits.
     // For example, we transform (for u8) shifted left 2, to:
@@ -467,7 +507,7 @@ struct bigint {
   }
 
   // move the limbs left by `n` limbs.
-  bool shl_limbs(size_t n) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept {
     FASTFLOAT_DEBUG_ASSERT(n != 0);
     if (n + vec.len() > vec.capacity()) {
       return false;
@@ -488,7 +528,7 @@ struct bigint {
   }
 
   // move the limbs left by `n` bits.
-  bool shl(size_t n) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept {
     size_t rem = n % limb_bits;
     size_t div = n / limb_bits;
     if (rem != 0) {
@@ -501,7 +541,7 @@ struct bigint {
   }
 
   // get the number of leading zeros in the bigint.
-  int ctlz() const noexcept {
+  FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept {
     if (vec.is_empty()) {
       return 0;
     } else {
@@ -516,45 +556,27 @@ struct bigint {
   }
 
   // get the number of bits in the bigint.
-  int bit_length() const noexcept {
+  FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept {
     int lz = ctlz();
     return int(limb_bits * vec.len()) - lz;
   }
 
-  bool mul(limb y) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept {
     return small_mul(vec, y);
   }
 
-  bool add(limb y) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept {
     return small_add(vec, y);
   }
 
   // multiply as if by 2 raised to a power.
-  bool pow2(uint32_t exp) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept {
     return shl(exp);
   }
 
   // multiply as if by 5 raised to a power.
-  bool pow5(uint32_t exp) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept {
     // multiply by a power of 5
-    static constexpr uint32_t large_step = 135;
-    static constexpr uint64_t small_power_of_5[] = {
-      1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
-      1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
-      6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
-      3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
-      2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
-      298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
-    };
-#ifdef FASTFLOAT_64BIT_LIMB
-    constexpr static limb large_power_of_5[] = {
-      1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
-      10482974169319127550UL, 198276706040285095UL};
-#else
-    constexpr static limb large_power_of_5[] = {
-      4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
-      1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
-#endif
     size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
     limb_span large = limb_span(large_power_of_5, large_length);
     while (exp >= large_step) {
@@ -580,7 +602,7 @@ struct bigint {
   }
 
   // multiply as if by 10 raised to a power.
-  bool pow10(uint32_t exp) noexcept {
+  FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept {
     FASTFLOAT_TRY(pow5(exp));
     return pow2(exp);
   }
diff --git a/cpp/src/arrow/vendored/fast_float/constexpr_feature_detect.h b/cpp/src/arrow/vendored/fast_float/constexpr_feature_detect.h
new file mode 100644
index 0000000000000..ba8b65c64a160
--- /dev/null
+++ b/cpp/src/arrow/vendored/fast_float/constexpr_feature_detect.h
@@ -0,0 +1,40 @@
+#ifndef FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+#define FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
+
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
+// Testing for https://wg21.link/N3652, adopted in C++14
+#if __cpp_constexpr >= 201304
+#define FASTFLOAT_CONSTEXPR14 constexpr
+#else
+#define FASTFLOAT_CONSTEXPR14
+#endif
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L
+#define FASTFLOAT_HAS_BIT_CAST 1
+#else
+#define FASTFLOAT_HAS_BIT_CAST 0
+#endif
+
+#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1
+#else
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0
+#endif
+
+// Testing for relevant C++20 constexpr library features
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED \
+    && FASTFLOAT_HAS_BIT_CAST \
+    && __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/
+#define FASTFLOAT_CONSTEXPR20 constexpr
+#define FASTFLOAT_IS_CONSTEXPR 1
+#else
+#define FASTFLOAT_CONSTEXPR20
+#define FASTFLOAT_IS_CONSTEXPR 0
+#endif
+
+#endif // FASTFLOAT_CONSTEXPR_FEATURE_DETECT_H
diff --git a/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h b/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
index 8ae481d323865..9390228c3946a 100644
--- a/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
+++ b/cpp/src/arrow/vendored/fast_float/decimal_to_binary.h
@@ -64,7 +64,7 @@ namespace detail {
 // create an adjusted mantissa, biased by the invalid power2
 // for significant digits already multiplied by 10 ** q.
 template <typename binary>
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
 adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept  {
   int hilz = int(w >> 63) ^ 1;
   adjusted_mantissa answer;
@@ -118,16 +118,11 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w)  noexcept  {
   // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
 
   value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
-  if(product.low == 0xFFFFFFFFFFFFFFFF) { //  could guard it further
-    // In some very rare cases, this could happen, in which case we might need a more accurate
-    // computation that what we can provide cheaply. This is very, very unlikely.
-    //
-    const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0, 
-    // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
-    if(!inside_safe_exponent) {
-      return compute_error_scaled<binary>(q, product.high, lz);
-    }
-  }
+  // The computed 'product' is always sufficient.
+  // Mathematical proof:
+  // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to appear)
+  // See script/mushtak_lemire.py
+
   // The "compute_product_approximation" function can be slightly slower than a branchless approach:
   // value128 product = compute_product(q, w);
   // but in practice, we can win big with the compute_product_approximation if its additional branch
diff --git a/cpp/src/arrow/vendored/fast_float/digit_comparison.h b/cpp/src/arrow/vendored/fast_float/digit_comparison.h
index 5cb01a93648fd..b27348a1fcc7e 100644
--- a/cpp/src/arrow/vendored/fast_float/digit_comparison.h
+++ b/cpp/src/arrow/vendored/fast_float/digit_comparison.h
@@ -24,7 +24,8 @@ constexpr static uint64_t powers_of_ten_uint64[] = {
 // this algorithm is not even close to optimized, but it has no practical
 // effect on performance: in order to have a faster algorithm, we'd need
 // to slow down performance for faster algorithms, and this is still fast.
-fastfloat_really_inline int32_t scientific_exponent(parsed_number_string& num) noexcept {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+int32_t scientific_exponent(parsed_number_string& num) noexcept {
   uint64_t mantissa = num.mantissa;
   int32_t exponent = int32_t(num.exponent);
   while (mantissa >= 10000) {
@@ -82,7 +83,8 @@ fastfloat_really_inline adjusted_mantissa to_extended_halfway(T value) noexcept
 
 // round an extended-precision float to the nearest machine float.
 template <typename T, typename callback>
-fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+void round(adjusted_mantissa& am, callback cb) noexcept {
   int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
   if (-am.power2 >= mantissa_shift) {
     // have a denormal float
@@ -111,23 +113,19 @@ fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept
 }
 
 template <typename callback>
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
 void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept {
-  uint64_t mask;
-  uint64_t halfway;
-  if (shift == 64) {
-    mask = UINT64_MAX;
-  } else {
-    mask = (uint64_t(1) << shift) - 1;
-  }
-  if (shift == 0) {
-    halfway = 0;
-  } else {
-    halfway = uint64_t(1) << (shift - 1);
-  }
+  const uint64_t mask
+  = (shift == 64)
+    ? UINT64_MAX
+    : (uint64_t(1) << shift) - 1;
+  const uint64_t halfway
+  = (shift == 0)
+    ? 0
+    : uint64_t(1) << (shift - 1);
   uint64_t truncated_bits = am.mantissa & mask;
-  uint64_t is_above = truncated_bits > halfway;
-  uint64_t is_halfway = truncated_bits == halfway;
+  bool is_above = truncated_bits > halfway;
+  bool is_halfway = truncated_bits == halfway;
 
   // shift digits into position
   if (shift == 64) {
@@ -141,7 +139,8 @@ void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) n
   am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
 }
 
-fastfloat_really_inline void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
   if (shift == 64) {
     am.mantissa = 0;
   } else {
@@ -200,7 +199,7 @@ void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& co
   count += 8;
 }
 
-fastfloat_really_inline
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
 void parse_one_digit(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
   value = value * 10 + limb(*p - '0');
   p++;
diff --git a/cpp/src/arrow/vendored/fast_float/fast_float.h b/cpp/src/arrow/vendored/fast_float/fast_float.h
index b379efdd9e409..7942fe35ad1d3 100644
--- a/cpp/src/arrow/vendored/fast_float/fast_float.h
+++ b/cpp/src/arrow/vendored/fast_float/fast_float.h
@@ -59,7 +59,7 @@ template<typename T>
 from_chars_result from_chars_advanced(const char *first, const char *last,
                                       T &value, parse_options options)  noexcept;
 
-}
+} // namespace fast_float
 } // namespace arrow_vendored
 #include "parse_number.h"
 #endif // FASTFLOAT_FAST_FLOAT_H
diff --git a/cpp/src/arrow/vendored/fast_float/fast_table.h b/cpp/src/arrow/vendored/fast_float/fast_table.h
index 4861cab3a0d84..2c637d85c8fb0 100644
--- a/cpp/src/arrow/vendored/fast_float/fast_table.h
+++ b/cpp/src/arrow/vendored/fast_float/fast_table.h
@@ -18,11 +18,11 @@ namespace fast_float {
  */
 
 /**
- * The smallest non-zero float (binary64) is 2^−1074.
+ * The smallest non-zero float (binary64) is 2^-1074.
  * We take as input numbers of the form w x 10^q where w < 2^64.
  * We have that w * 10^-343  <  2^(64-344) 5^-343 < 2^-1076.
  * However, we have that
- * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^−1074.
+ * (2^64-1) * 10^-342 =  (2^64-1) * 2^-342 * 5^-342 > 2^-1074.
  * Thus it is possible for a number of the form w * 10^-342 where
  * w is a 64-bit value to be a non-zero floating-point number.
  *********
@@ -37,665 +37,666 @@ constexpr static int smallest_power_of_five = binary_format<double>::smallest_po
 constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
 constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
 // Powers of five from 5^-342 all the way to 5^308 rounded toward one.
-static const uint64_t power_of_five_128[number_of_entries];
+constexpr static uint64_t power_of_five_128[number_of_entries] = {
+    0xeef453d6923bd65a,0x113faa2906a13b3f,
+    0x9558b4661b6565f8,0x4ac7ca59a424c507,
+    0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
+    0xe95a99df8ace6f53,0xf4d82c2c107973dc,
+    0x91d8a02bb6c10594,0x79071b9b8a4be869,
+    0xb64ec836a47146f9,0x9748e2826cdee284,
+    0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
+    0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
+    0xb208ef855c969f4f,0xbdbd2d335e51a935,
+    0xde8b2b66b3bc4723,0xad2c788035e61382,
+    0x8b16fb203055ac76,0x4c3bcb5021afcc31,
+    0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
+    0xd953e8624b85dd78,0xd71d6dad34a2af0d,
+    0x87d4713d6f33aa6b,0x8672648c40e5ad68,
+    0xa9c98d8ccb009506,0x680efdaf511f18c2,
+    0xd43bf0effdc0ba48,0x212bd1b2566def2,
+    0x84a57695fe98746d,0x14bb630f7604b57,
+    0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
+    0xcf42894a5dce35ea,0x52064cac828675b9,
+    0x818995ce7aa0e1b2,0x7343efebd1940993,
+    0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
+    0xca66fa129f9b60a6,0xd41a26e077774ef6,
+    0xfd00b897478238d0,0x8920b098955522b4,
+    0x9e20735e8cb16382,0x55b46e5f5d5535b0,
+    0xc5a890362fddbc62,0xeb2189f734aa831d,
+    0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
+    0x9a6bb0aa55653b2d,0x47b233c92125366e,
+    0xc1069cd4eabe89f8,0x999ec0bb696e840a,
+    0xf148440a256e2c76,0xc00670ea43ca250d,
+    0x96cd2a865764dbca,0x380406926a5e5728,
+    0xbc807527ed3e12bc,0xc605083704f5ecf2,
+    0xeba09271e88d976b,0xf7864a44c633682e,
+    0x93445b8731587ea3,0x7ab3ee6afbe0211d,
+    0xb8157268fdae9e4c,0x5960ea05bad82964,
+    0xe61acf033d1a45df,0x6fb92487298e33bd,
+    0x8fd0c16206306bab,0xa5d3b6d479f8e056,
+    0xb3c4f1ba87bc8696,0x8f48a4899877186c,
+    0xe0b62e2929aba83c,0x331acdabfe94de87,
+    0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
+    0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
+    0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
+    0x892731ac9faf056e,0xbe311c083a225cd2,
+    0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
+    0xd64d3d9db981787d,0x92cbbccdad5b108,
+    0x85f0468293f0eb4e,0x25bbf56008c58ea5,
+    0xa76c582338ed2621,0xaf2af2b80af6f24e,
+    0xd1476e2c07286faa,0x1af5af660db4aee1,
+    0x82cca4db847945ca,0x50d98d9fc890ed4d,
+    0xa37fce126597973c,0xe50ff107bab528a0,
+    0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
+    0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
+    0x9faacf3df73609b1,0x77b191618c54e9ac,
+    0xc795830d75038c1d,0xd59df5b9ef6a2417,
+    0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
+    0x9becce62836ac577,0x4ee367f9430aec32,
+    0xc2e801fb244576d5,0x229c41f793cda73f,
+    0xf3a20279ed56d48a,0x6b43527578c1110f,
+    0x9845418c345644d6,0x830a13896b78aaa9,
+    0xbe5691ef416bd60c,0x23cc986bc656d553,
+    0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
+    0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
+    0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
+    0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
+    0x91376c36d99995be,0x23100809b9c21fa1,
+    0xb58547448ffffb2d,0xabd40a0c2832a78a,
+    0xe2e69915b3fff9f9,0x16c90c8f323f516c,
+    0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
+    0xb1442798f49ffb4a,0x99cd11cfdf41779c,
+    0xdd95317f31c7fa1d,0x40405643d711d583,
+    0x8a7d3eef7f1cfc52,0x482835ea666b2572,
+    0xad1c8eab5ee43b66,0xda3243650005eecf,
+    0xd863b256369d4a40,0x90bed43e40076a82,
+    0x873e4f75e2224e68,0x5a7744a6e804a291,
+    0xa90de3535aaae202,0x711515d0a205cb36,
+    0xd3515c2831559a83,0xd5a5b44ca873e03,
+    0x8412d9991ed58091,0xe858790afe9486c2,
+    0xa5178fff668ae0b6,0x626e974dbe39a872,
+    0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
+    0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
+    0xa139029f6a239f72,0x1c1fffc1ebc44e80,
+    0xc987434744ac874e,0xa327ffb266b56220,
+    0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
+    0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
+    0xc4ce17b399107c22,0xcb550fb4384d21d3,
+    0xf6019da07f549b2b,0x7e2a53a146606a48,
+    0x99c102844f94e0fb,0x2eda7444cbfc426d,
+    0xc0314325637a1939,0xfa911155fefb5308,
+    0xf03d93eebc589f88,0x793555ab7eba27ca,
+    0x96267c7535b763b5,0x4bc1558b2f3458de,
+    0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
+    0xea9c227723ee8bcb,0x465e15a979c1cadc,
+    0x92a1958a7675175f,0xbfacd89ec191ec9,
+    0xb749faed14125d36,0xcef980ec671f667b,
+    0xe51c79a85916f484,0x82b7e12780e7401a,
+    0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
+    0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
+    0xdfbdcece67006ac9,0x67a791e093e1d49a,
+    0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
+    0xaecc49914078536d,0x58fae9f773886e18,
+    0xda7f5bf590966848,0xaf39a475506a899e,
+    0x888f99797a5e012d,0x6d8406c952429603,
+    0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
+    0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
+    0x855c3be0a17fcd26,0x5cf2eea09a55067f,
+    0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
+    0xd0601d8efc57b08b,0xf13b94daf124da26,
+    0x823c12795db6ce57,0x76c53d08d6b70858,
+    0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
+    0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
+    0xfe5d54150b090b02,0xd3f93b35435d7c4c,
+    0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
+    0xc6b8e9b0709f109a,0x359ab6419ca1091b,
+    0xf867241c8cc6d4c0,0xc30163d203c94b62,
+    0x9b407691d7fc44f8,0x79e0de63425dcf1d,
+    0xc21094364dfb5636,0x985915fc12f542e4,
+    0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
+    0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
+    0xbd8430bd08277231,0x50c6ff782a838353,
+    0xece53cec4a314ebd,0xa4f8bf5635246428,
+    0x940f4613ae5ed136,0x871b7795e136be99,
+    0xb913179899f68584,0x28e2557b59846e3f,
+    0xe757dd7ec07426e5,0x331aeada2fe589cf,
+    0x9096ea6f3848984f,0x3ff0d2c85def7621,
+    0xb4bca50b065abe63,0xfed077a756b53a9,
+    0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
+    0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
+    0xb080392cc4349dec,0xbd8d794d96aacfb3,
+    0xdca04777f541c567,0xecf0d7a0fc5583a0,
+    0x89e42caaf9491b60,0xf41686c49db57244,
+    0xac5d37d5b79b6239,0x311c2875c522ced5,
+    0xd77485cb25823ac7,0x7d633293366b828b,
+    0x86a8d39ef77164bc,0xae5dff9c02033197,
+    0xa8530886b54dbdeb,0xd9f57f830283fdfc,
+    0xd267caa862a12d66,0xd072df63c324fd7b,
+    0x8380dea93da4bc60,0x4247cb9e59f71e6d,
+    0xa46116538d0deb78,0x52d9be85f074e608,
+    0xcd795be870516656,0x67902e276c921f8b,
+    0x806bd9714632dff6,0xba1cd8a3db53b6,
+    0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
+    0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
+    0xfad2a4b13d1b5d6c,0x796b805720085f81,
+    0x9cc3a6eec6311a63,0xcbe3303674053bb0,
+    0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
+    0xf4f1b4d515acb93b,0xee92fb5515482d44,
+    0x991711052d8bf3c5,0x751bdd152d4d1c4a,
+    0xbf5cd54678eef0b6,0xd262d45a78a0635d,
+    0xef340a98172aace4,0x86fb897116c87c34,
+    0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
+    0xbae0a846d2195712,0x8974836059cca109,
+    0xe998d258869facd7,0x2bd1a438703fc94b,
+    0x91ff83775423cc06,0x7b6306a34627ddcf,
+    0xb67f6455292cbf08,0x1a3bc84c17b1d542,
+    0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
+    0x8e938662882af53e,0x547eb47b7282ee9c,
+    0xb23867fb2a35b28d,0xe99e619a4f23aa43,
+    0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
+    0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
+    0xae0b158b4738705e,0x9624ab50b148d445,
+    0xd98ddaee19068c76,0x3badd624dd9b0957,
+    0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
+    0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
+    0xd47487cc8470652b,0x7647c3200069671f,
+    0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
+    0xa5fb0a17c777cf09,0xf468107100525890,
+    0xcf79cc9db955c2cc,0x7182148d4066eeb4,
+    0x81ac1fe293d599bf,0xc6f14cd848405530,
+    0xa21727db38cb002f,0xb8ada00e5a506a7c,
+    0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
+    0xfd442e4688bd304a,0x908f4a166d1da663,
+    0x9e4a9cec15763e2e,0x9a598e4e043287fe,
+    0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
+    0xf7549530e188c128,0xd12bee59e68ef47c,
+    0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
+    0xc13a148e3032d6e7,0xe36a52363c1faf01,
+    0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
+    0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
+    0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
+    0xebdf661791d60f56,0x111b495b3464ad21,
+    0x936b9fcebb25c995,0xcab10dd900beec34,
+    0xb84687c269ef3bfb,0x3d5d514f40eea742,
+    0xe65829b3046b0afa,0xcb4a5a3112a5112,
+    0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
+    0xb3f4e093db73a093,0x59ed216765690f56,
+    0xe0f218b8d25088b8,0x306869c13ec3532c,
+    0x8c974f7383725573,0x1e414218c73a13fb,
+    0xafbd2350644eeacf,0xe5d1929ef90898fa,
+    0xdbac6c247d62a583,0xdf45f746b74abf39,
+    0x894bc396ce5da772,0x6b8bba8c328eb783,
+    0xab9eb47c81f5114f,0x66ea92f3f326564,
+    0xd686619ba27255a2,0xc80a537b0efefebd,
+    0x8613fd0145877585,0xbd06742ce95f5f36,
+    0xa798fc4196e952e7,0x2c48113823b73704,
+    0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
+    0x82ef85133de648c4,0x9a984d73dbe722fb,
+    0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
+    0xcc963fee10b7d1b3,0x318df905079926a8,
+    0xffbbcfe994e5c61f,0xfdf17746497f7052,
+    0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
+    0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
+    0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
+    0x9c1661a651213e2d,0x6bea10ca65c084e,
+    0xc31bfa0fe5698db8,0x486e494fcff30a62,
+    0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
+    0x986ddb5c6b3a76b7,0xf89629465a75e01c,
+    0xbe89523386091465,0xf6bbb397f1135823,
+    0xee2ba6c0678b597f,0x746aa07ded582e2c,
+    0x94db483840b717ef,0xa8c2a44eb4571cdc,
+    0xba121a4650e4ddeb,0x92f34d62616ce413,
+    0xe896a0d7e51e1566,0x77b020baf9c81d17,
+    0x915e2486ef32cd60,0xace1474dc1d122e,
+    0xb5b5ada8aaff80b8,0xd819992132456ba,
+    0xe3231912d5bf60e6,0x10e1fff697ed6c69,
+    0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
+    0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
+    0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
+    0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
+    0xad4ab7112eb3929d,0x86c16c98d2c953c6,
+    0xd89d64d57a607744,0xe871c7bf077ba8b7,
+    0x87625f056c7c4a8b,0x11471cd764ad4972,
+    0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
+    0xd389b47879823479,0x4aff1d108d4ec2c3,
+    0x843610cb4bf160cb,0xcedf722a585139ba,
+    0xa54394fe1eedb8fe,0xc2974eb4ee658828,
+    0xce947a3da6a9273e,0x733d226229feea32,
+    0x811ccc668829b887,0x806357d5a3f525f,
+    0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
+    0xc9bcff6034c13052,0xfc89b393dd02f0b5,
+    0xfc2c3f3841f17c67,0xbbac2078d443ace2,
+    0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
+    0xc5029163f384a931,0xa9e795e65d4df11,
+    0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
+    0x99ea0196163fa42e,0x504bced1bf8e4e45,
+    0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
+    0xf07da27a82c37088,0x5d767327bb4e5a4c,
+    0x964e858c91ba2655,0x3a6a07f8d510f86f,
+    0xbbe226efb628afea,0x890489f70a55368b,
+    0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
+    0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
+    0xb77ada0617e3bbcb,0x9ce6ebb40173744,
+    0xe55990879ddcaabd,0xcc420a6a101d0515,
+    0x8f57fa54c2a9eab6,0x9fa946824a12232d,
+    0xb32df8e9f3546564,0x47939822dc96abf9,
+    0xdff9772470297ebd,0x59787e2b93bc56f7,
+    0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
+    0xaefae51477a06b03,0xede622920b6b23f1,
+    0xdab99e59958885c4,0xe95fab368e45eced,
+    0x88b402f7fd75539b,0x11dbcb0218ebb414,
+    0xaae103b5fcd2a881,0xd652bdc29f26a119,
+    0xd59944a37c0752a2,0x4be76d3346f0495f,
+    0x857fcae62d8493a5,0x6f70a4400c562ddb,
+    0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
+    0xd097ad07a71f26b2,0x7e2000a41346a7a7,
+    0x825ecc24c873782f,0x8ed400668c0c28c8,
+    0xa2f67f2dfa90563b,0x728900802f0f32fa,
+    0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
+    0xfea126b7d78186bc,0xe2f610c84987bfa8,
+    0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
+    0xc6ede63fa05d3143,0x91503d1c79720dbb,
+    0xf8a95fcf88747d94,0x75a44c6397ce912a,
+    0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
+    0xc24452da229b021b,0xfbe85badce996168,
+    0xf2d56790ab41c2a2,0xfae27299423fb9c3,
+    0x97c560ba6b0919a5,0xdccd879fc967d41a,
+    0xbdb6b8e905cb600f,0x5400e987bbc1c920,
+    0xed246723473e3813,0x290123e9aab23b68,
+    0x9436c0760c86e30b,0xf9a0b6720aaf6521,
+    0xb94470938fa89bce,0xf808e40e8d5b3e69,
+    0xe7958cb87392c2c2,0xb60b1d1230b20e04,
+    0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
+    0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
+    0xe2280b6c20dd5232,0x25c6da63c38de1b0,
+    0x8d590723948a535f,0x579c487e5a38ad0e,
+    0xb0af48ec79ace837,0x2d835a9df0c6d851,
+    0xdcdb1b2798182244,0xf8e431456cf88e65,
+    0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
+    0xac8b2d36eed2dac5,0xe272467e3d222f3f,
+    0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
+    0x86ccbb52ea94baea,0x98e947129fc2b4e9,
+    0xa87fea27a539e9a5,0x3f2398d747b36224,
+    0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
+    0x83a3eeeef9153e89,0x1953cf68300424ac,
+    0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
+    0xcdb02555653131b6,0x3792f412cb06794d,
+    0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
+    0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
+    0xc8de047564d20a8b,0xf245825a5a445275,
+    0xfb158592be068d2e,0xeed6e2f0f0d56712,
+    0x9ced737bb6c4183d,0x55464dd69685606b,
+    0xc428d05aa4751e4c,0xaa97e14c3c26b886,
+    0xf53304714d9265df,0xd53dd99f4b3066a8,
+    0x993fe2c6d07b7fab,0xe546a8038efe4029,
+    0xbf8fdb78849a5f96,0xde98520472bdd033,
+    0xef73d256a5c0f77c,0x963e66858f6d4440,
+    0x95a8637627989aad,0xdde7001379a44aa8,
+    0xbb127c53b17ec159,0x5560c018580d5d52,
+    0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
+    0x9226712162ab070d,0xcab3961304ca70e8,
+    0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
+    0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
+    0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
+    0xb267ed1940f1c61c,0x55f038b237591ed3,
+    0xdf01e85f912e37a3,0x6b6c46dec52f6688,
+    0x8b61313bbabce2c6,0x2323ac4b3b3da015,
+    0xae397d8aa96c1b77,0xabec975e0a0d081a,
+    0xd9c7dced53c72255,0x96e7bd358c904a21,
+    0x881cea14545c7575,0x7e50d64177da2e54,
+    0xaa242499697392d2,0xdde50bd1d5d0b9e9,
+    0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
+    0x84ec3c97da624ab4,0xbd5af13bef0b113e,
+    0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
+    0xcfb11ead453994ba,0x67de18eda5814af2,
+    0x81ceb32c4b43fcf4,0x80eacf948770ced7,
+    0xa2425ff75e14fc31,0xa1258379a94d028d,
+    0xcad2f7f5359a3b3e,0x96ee45813a04330,
+    0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
+    0x9e74d1b791e07e48,0x775ea264cf55347e,
+    0xc612062576589dda,0x95364afe032a819e,
+    0xf79687aed3eec551,0x3a83ddbd83f52205,
+    0x9abe14cd44753b52,0xc4926a9672793543,
+    0xc16d9a0095928a27,0x75b7053c0f178294,
+    0xf1c90080baf72cb1,0x5324c68b12dd6339,
+    0x971da05074da7bee,0xd3f6fc16ebca5e04,
+    0xbce5086492111aea,0x88f4bb1ca6bcf585,
+    0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
+    0x9392ee8e921d5d07,0x3aff322e62439fd0,
+    0xb877aa3236a4b449,0x9befeb9fad487c3,
+    0xe69594bec44de15b,0x4c2ebe687989a9b4,
+    0x901d7cf73ab0acd9,0xf9d37014bf60a11,
+    0xb424dc35095cd80f,0x538484c19ef38c95,
+    0xe12e13424bb40e13,0x2865a5f206b06fba,
+    0x8cbccc096f5088cb,0xf93f87b7442e45d4,
+    0xafebff0bcb24aafe,0xf78f69a51539d749,
+    0xdbe6fecebdedd5be,0xb573440e5a884d1c,
+    0x89705f4136b4a597,0x31680a88f8953031,
+    0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
+    0xd6bf94d5e57a42bc,0x3d32907604691b4d,
+    0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
+    0xa7c5ac471b478423,0xfcf80dc33721d54,
+    0xd1b71758e219652b,0xd3c36113404ea4a9,
+    0x83126e978d4fdf3b,0x645a1cac083126ea,
+    0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
+    0xcccccccccccccccc,0xcccccccccccccccd,
+    0x8000000000000000,0x0,
+    0xa000000000000000,0x0,
+    0xc800000000000000,0x0,
+    0xfa00000000000000,0x0,
+    0x9c40000000000000,0x0,
+    0xc350000000000000,0x0,
+    0xf424000000000000,0x0,
+    0x9896800000000000,0x0,
+    0xbebc200000000000,0x0,
+    0xee6b280000000000,0x0,
+    0x9502f90000000000,0x0,
+    0xba43b74000000000,0x0,
+    0xe8d4a51000000000,0x0,
+    0x9184e72a00000000,0x0,
+    0xb5e620f480000000,0x0,
+    0xe35fa931a0000000,0x0,
+    0x8e1bc9bf04000000,0x0,
+    0xb1a2bc2ec5000000,0x0,
+    0xde0b6b3a76400000,0x0,
+    0x8ac7230489e80000,0x0,
+    0xad78ebc5ac620000,0x0,
+    0xd8d726b7177a8000,0x0,
+    0x878678326eac9000,0x0,
+    0xa968163f0a57b400,0x0,
+    0xd3c21bcecceda100,0x0,
+    0x84595161401484a0,0x0,
+    0xa56fa5b99019a5c8,0x0,
+    0xcecb8f27f4200f3a,0x0,
+    0x813f3978f8940984,0x4000000000000000,
+    0xa18f07d736b90be5,0x5000000000000000,
+    0xc9f2c9cd04674ede,0xa400000000000000,
+    0xfc6f7c4045812296,0x4d00000000000000,
+    0x9dc5ada82b70b59d,0xf020000000000000,
+    0xc5371912364ce305,0x6c28000000000000,
+    0xf684df56c3e01bc6,0xc732000000000000,
+    0x9a130b963a6c115c,0x3c7f400000000000,
+    0xc097ce7bc90715b3,0x4b9f100000000000,
+    0xf0bdc21abb48db20,0x1e86d40000000000,
+    0x96769950b50d88f4,0x1314448000000000,
+    0xbc143fa4e250eb31,0x17d955a000000000,
+    0xeb194f8e1ae525fd,0x5dcfab0800000000,
+    0x92efd1b8d0cf37be,0x5aa1cae500000000,
+    0xb7abc627050305ad,0xf14a3d9e40000000,
+    0xe596b7b0c643c719,0x6d9ccd05d0000000,
+    0x8f7e32ce7bea5c6f,0xe4820023a2000000,
+    0xb35dbf821ae4f38b,0xdda2802c8a800000,
+    0xe0352f62a19e306e,0xd50b2037ad200000,
+    0x8c213d9da502de45,0x4526f422cc340000,
+    0xaf298d050e4395d6,0x9670b12b7f410000,
+    0xdaf3f04651d47b4c,0x3c0cdd765f114000,
+    0x88d8762bf324cd0f,0xa5880a69fb6ac800,
+    0xab0e93b6efee0053,0x8eea0d047a457a00,
+    0xd5d238a4abe98068,0x72a4904598d6d880,
+    0x85a36366eb71f041,0x47a6da2b7f864750,
+    0xa70c3c40a64e6c51,0x999090b65f67d924,
+    0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
+    0x82818f1281ed449f,0xbff8f10e7a8921a4,
+    0xa321f2d7226895c7,0xaff72d52192b6a0d,
+    0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
+    0xfee50b7025c36a08,0x2f236d04753d5b4,
+    0x9f4f2726179a2245,0x1d762422c946590,
+    0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
+    0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
+    0x9b934c3b330c8577,0x63cc55f49f88eb2f,
+    0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
+    0xf316271c7fc3908a,0x8bef464e3945ef7a,
+    0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
+    0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
+    0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
+    0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
+    0xb975d6b6ee39e436,0xb3e2fd538e122b44,
+    0xe7d34c64a9c85d44,0x60dbbca87196b616,
+    0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
+    0xb51d13aea4a488dd,0x6babab6398bdbe41,
+    0xe264589a4dcdab14,0xc696963c7eed2dd1,
+    0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
+    0xb0de65388cc8ada8,0x3b25a55f43294bcb,
+    0xdd15fe86affad912,0x49ef0eb713f39ebe,
+    0x8a2dbf142dfcc7ab,0x6e3569326c784337,
+    0xacb92ed9397bf996,0x49c2c37f07965404,
+    0xd7e77a8f87daf7fb,0xdc33745ec97be906,
+    0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
+    0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
+    0xd2d80db02aabd62b,0xf50a3fa490c30190,
+    0x83c7088e1aab65db,0x792667c6da79e0fa,
+    0xa4b8cab1a1563f52,0x577001b891185938,
+    0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
+    0x80b05e5ac60b6178,0x544f8158315b05b4,
+    0xa0dc75f1778e39d6,0x696361ae3db1c721,
+    0xc913936dd571c84c,0x3bc3a19cd1e38e9,
+    0xfb5878494ace3a5f,0x4ab48a04065c723,
+    0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
+    0xc45d1df942711d9a,0x3ba5d0bd324f8394,
+    0xf5746577930d6500,0xca8f44ec7ee36479,
+    0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
+    0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
+    0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
+    0x95d04aee3b80ece5,0xbba1f1d158724a12,
+    0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
+    0xea1575143cf97226,0xf52d09d71a3293bd,
+    0x924d692ca61be758,0x593c2626705f9c56,
+    0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
+    0xe498f455c38b997a,0xb6dfb9c0f956447,
+    0x8edf98b59a373fec,0x4724bd4189bd5eac,
+    0xb2977ee300c50fe7,0x58edec91ec2cb657,
+    0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
+    0x8b865b215899f46c,0xbd79e0d20082ee74,
+    0xae67f1e9aec07187,0xecd8590680a3aa11,
+    0xda01ee641a708de9,0xe80e6f4820cc9495,
+    0x884134fe908658b2,0x3109058d147fdcdd,
+    0xaa51823e34a7eede,0xbd4b46f0599fd415,
+    0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
+    0x850fadc09923329e,0x3e2cf6bc604ddb0,
+    0xa6539930bf6bff45,0x84db8346b786151c,
+    0xcfe87f7cef46ff16,0xe612641865679a63,
+    0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
+    0xa26da3999aef7749,0xe3be5e330f38f09d,
+    0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
+    0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
+    0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
+    0xc646d63501a1511d,0xb281e1fd541501b8,
+    0xf7d88bc24209a565,0x1f225a7ca91a4226,
+    0x9ae757596946075f,0x3375788de9b06958,
+    0xc1a12d2fc3978937,0x52d6b1641c83ae,
+    0xf209787bb47d6b84,0xc0678c5dbd23a49a,
+    0x9745eb4d50ce6332,0xf840b7ba963646e0,
+    0xbd176620a501fbff,0xb650e5a93bc3d898,
+    0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
+    0x93ba47c980e98cdf,0xc66f336c36b10137,
+    0xb8a8d9bbe123f017,0xb80b0047445d4184,
+    0xe6d3102ad96cec1d,0xa60dc059157491e5,
+    0x9043ea1ac7e41392,0x87c89837ad68db2f,
+    0xb454e4a179dd1877,0x29babe4598c311fb,
+    0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
+    0x8ce2529e2734bb1d,0x1899e4a65f58660c,
+    0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
+    0xdc21a1171d42645d,0x76707543f4fa1f73,
+    0x899504ae72497eba,0x6a06494a791c53a8,
+    0xabfa45da0edbde69,0x487db9d17636892,
+    0xd6f8d7509292d603,0x45a9d2845d3c42b6,
+    0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
+    0xa7f26836f282b732,0x8e6cac7768d7141e,
+    0xd1ef0244af2364ff,0x3207d795430cd926,
+    0x8335616aed761f1f,0x7f44e6bd49e807b8,
+    0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
+    0xcd036837130890a1,0x36dba887c37a8c0f,
+    0x802221226be55a64,0xc2494954da2c9789,
+    0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
+    0xc83553c5c8965d3d,0x6f92829494e5acc7,
+    0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
+    0x9c69a97284b578d7,0xff2a760414536efb,
+    0xc38413cf25e2d70d,0xfef5138519684aba,
+    0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
+    0x98bf2f79d5993802,0xef2f773ffbd97a61,
+    0xbeeefb584aff8603,0xaafb550ffacfd8fa,
+    0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
+    0x952ab45cfa97a0b2,0xdd945a747bf26183,
+    0xba756174393d88df,0x94f971119aeef9e4,
+    0xe912b9d1478ceb17,0x7a37cd5601aab85d,
+    0x91abb422ccb812ee,0xac62e055c10ab33a,
+    0xb616a12b7fe617aa,0x577b986b314d6009,
+    0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
+    0x8e41ade9fbebc27d,0x14588f13be847307,
+    0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
+    0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
+    0x8aec23d680043bee,0x25de7bb9480d5854,
+    0xada72ccc20054ae9,0xaf561aa79a10ae6a,
+    0xd910f7ff28069da4,0x1b2ba1518094da04,
+    0x87aa9aff79042286,0x90fb44d2f05d0842,
+    0xa99541bf57452b28,0x353a1607ac744a53,
+    0xd3fa922f2d1675f2,0x42889b8997915ce8,
+    0x847c9b5d7c2e09b7,0x69956135febada11,
+    0xa59bc234db398c25,0x43fab9837e699095,
+    0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
+    0x8161afb94b44f57d,0x1d1be0eebac278f5,
+    0xa1ba1ba79e1632dc,0x6462d92a69731732,
+    0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
+    0xfcb2cb35e702af78,0x5cda735244c3d43e,
+    0x9defbf01b061adab,0x3a0888136afa64a7,
+    0xc56baec21c7a1916,0x88aaa1845b8fdd0,
+    0xf6c69a72a3989f5b,0x8aad549e57273d45,
+    0x9a3c2087a63f6399,0x36ac54e2f678864b,
+    0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
+    0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
+    0x969eb7c47859e743,0x9f644ae5a4b1b325,
+    0xbc4665b596706114,0x873d5d9f0dde1fee,
+    0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
+    0x9316ff75dd87cbd8,0x9a7f12442d588f2,
+    0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
+    0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
+    0x8fa475791a569d10,0xf96e017d694487bc,
+    0xb38d92d760ec4455,0x37c981dcc395a9ac,
+    0xe070f78d3927556a,0x85bbe253f47b1417,
+    0x8c469ab843b89562,0x93956d7478ccec8e,
+    0xaf58416654a6babb,0x387ac8d1970027b2,
+    0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
+    0x88fcf317f22241e2,0x441fece3bdf81f03,
+    0xab3c2fddeeaad25a,0xd527e81cad7626c3,
+    0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
+    0x85c7056562757456,0xf6872d5667844e49,
+    0xa738c6bebb12d16c,0xb428f8ac016561db,
+    0xd106f86e69d785c7,0xe13336d701beba52,
+    0x82a45b450226b39c,0xecc0024661173473,
+    0xa34d721642b06084,0x27f002d7f95d0190,
+    0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
+    0xff290242c83396ce,0x7e67047175a15271,
+    0x9f79a169bd203e41,0xf0062c6e984d386,
+    0xc75809c42c684dd1,0x52c07b78a3e60868,
+    0xf92e0c3537826145,0xa7709a56ccdf8a82,
+    0x9bbcc7a142b17ccb,0x88a66076400bb691,
+    0xc2abf989935ddbfe,0x6acff893d00ea435,
+    0xf356f7ebf83552fe,0x583f6b8c4124d43,
+    0x98165af37b2153de,0xc3727a337a8b704a,
+    0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
+    0xeda2ee1c7064130c,0x1162def06f79df73,
+    0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
+    0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
+    0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
+    0x910ab1d4db9914a0,0x1d9c9892400a22a2,
+    0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
+    0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
+    0x8da471a9de737e24,0x5ceaecfed289e5d2,
+    0xb10d8e1456105dad,0x7425a83e872c5f47,
+    0xdd50f1996b947518,0xd12f124e28f77719,
+    0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
+    0xace73cbfdc0bfb7b,0x636cc64d1001550b,
+    0xd8210befd30efa5a,0x3c47f7e05401aa4e,
+    0x8714a775e3e95c78,0x65acfaec34810a71,
+    0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
+    0xd31045a8341ca07c,0x1ede48111209a050,
+    0x83ea2b892091e44d,0x934aed0aab460432,
+    0xa4e4b66b68b65d60,0xf81da84d5617853f,
+    0xce1de40642e3f4b9,0x36251260ab9d668e,
+    0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
+    0xa1075a24e4421730,0xb24cf65b8612f81f,
+    0xc94930ae1d529cfc,0xdee033f26797b627,
+    0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
+    0x9d412e0806e88aa5,0x8e1f289560ee864e,
+    0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
+    0xf5b5d7ec8acb58a2,0xae10af696774b1db,
+    0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
+    0xbff610b0cc6edd3f,0x17fd090a58d32af3,
+    0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
+    0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
+    0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
+    0xea53df5fd18d5513,0x84c86189216dc5ed,
+    0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
+    0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
+    0xe4d5e82392a40515,0xfabaf3feaa5334a,
+    0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
+    0xb2c71d5bca9023f8,0x743e20e9ef511012,
+    0xdf78e4b2bd342cf6,0x914da9246b255416,
+    0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
+    0xae9672aba3d0c320,0xa184ac2473b529b1,
+    0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
+    0x8865899617fb1871,0x7e2fa67c7a658892,
+    0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
+    0xd51ea6fa85785631,0x552a74227f3ea565,
+    0x8533285c936b35de,0xd53a88958f87275f,
+    0xa67ff273b8460356,0x8a892abaf368f137,
+    0xd01fef10a657842c,0x2d2b7569b0432d85,
+    0x8213f56a67f6b29b,0x9c3b29620e29fc73,
+    0xa298f2c501f45f42,0x8349f3ba91b47b8f,
+    0xcb3f2f7642717713,0x241c70a936219a73,
+    0xfe0efb53d30dd4d7,0xed238cd383aa0110,
+    0x9ec95d1463e8a506,0xf4363804324a40aa,
+    0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
+    0xf81aa16fdc1b81da,0xdd94b7868e94050a,
+    0x9b10a4e5e9913128,0xca7cf2b4191c8326,
+    0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
+    0xf24a01a73cf2dccf,0xbc633b39673c8cec,
+    0x976e41088617ca01,0xd5be0503e085d813,
+    0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
+    0xec9c459d51852ba2,0xddf8e7d60ed1219e,
+    0x93e1ab8252f33b45,0xcabb90e5c942b503,
+    0xb8da1662e7b00a17,0x3d6a751f3b936243,
+    0xe7109bfba19c0c9d,0xcc512670a783ad4,
+    0x906a617d450187e2,0x27fb2b80668b24c5,
+    0xb484f9dc9641e9da,0xb1f9f660802dedf6,
+    0xe1a63853bbd26451,0x5e7873f8a0396973,
+    0x8d07e33455637eb2,0xdb0b487b6423e1e8,
+    0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
+    0xdc5c5301c56b75f7,0x7641a140cc7810fb,
+    0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
+    0xac2820d9623bf429,0x546345fa9fbdcd44,
+    0xd732290fbacaf133,0xa97c177947ad4095,
+    0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
+    0xa81f301449ee8c70,0x5c68f256bfff5a74,
+    0xd226fc195c6a2f8c,0x73832eec6fff3111,
+    0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
+    0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
+    0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
+    0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
+    0xa0555e361951c366,0xd7e105bcc332621f,
+    0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
+    0xfa856334878fc150,0xb14f98f6f0feb951,
+    0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
+    0xc3b8358109e84f07,0xa862f80ec4700c8,
+    0xf4a642e14c6262c8,0xcd27bb612758c0fa,
+    0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
+    0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
+    0xeeea5d5004981478,0x1858ccfce06cac74,
+    0x95527a5202df0ccb,0xf37801e0c43ebc8,
+    0xbaa718e68396cffd,0xd30560258f54e6ba,
+    0xe950df20247c83fd,0x47c6b82ef32a2069,
+    0x91d28b7416cdd27e,0x4cdc331d57fa5441,
+    0xb6472e511c81471d,0xe0133fe4adf8e952,
+    0xe3d8f9e563a198e5,0x58180fddd97723a6,
+    0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
 };
 
 template <class unused>
-const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
-        0xeef453d6923bd65a,0x113faa2906a13b3f,
-        0x9558b4661b6565f8,0x4ac7ca59a424c507,
-        0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
-        0xe95a99df8ace6f53,0xf4d82c2c107973dc,
-        0x91d8a02bb6c10594,0x79071b9b8a4be869,
-        0xb64ec836a47146f9,0x9748e2826cdee284,
-        0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
-        0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
-        0xb208ef855c969f4f,0xbdbd2d335e51a935,
-        0xde8b2b66b3bc4723,0xad2c788035e61382,
-        0x8b16fb203055ac76,0x4c3bcb5021afcc31,
-        0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
-        0xd953e8624b85dd78,0xd71d6dad34a2af0d,
-        0x87d4713d6f33aa6b,0x8672648c40e5ad68,
-        0xa9c98d8ccb009506,0x680efdaf511f18c2,
-        0xd43bf0effdc0ba48,0x212bd1b2566def2,
-        0x84a57695fe98746d,0x14bb630f7604b57,
-        0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
-        0xcf42894a5dce35ea,0x52064cac828675b9,
-        0x818995ce7aa0e1b2,0x7343efebd1940993,
-        0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
-        0xca66fa129f9b60a6,0xd41a26e077774ef6,
-        0xfd00b897478238d0,0x8920b098955522b4,
-        0x9e20735e8cb16382,0x55b46e5f5d5535b0,
-        0xc5a890362fddbc62,0xeb2189f734aa831d,
-        0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
-        0x9a6bb0aa55653b2d,0x47b233c92125366e,
-        0xc1069cd4eabe89f8,0x999ec0bb696e840a,
-        0xf148440a256e2c76,0xc00670ea43ca250d,
-        0x96cd2a865764dbca,0x380406926a5e5728,
-        0xbc807527ed3e12bc,0xc605083704f5ecf2,
-        0xeba09271e88d976b,0xf7864a44c633682e,
-        0x93445b8731587ea3,0x7ab3ee6afbe0211d,
-        0xb8157268fdae9e4c,0x5960ea05bad82964,
-        0xe61acf033d1a45df,0x6fb92487298e33bd,
-        0x8fd0c16206306bab,0xa5d3b6d479f8e056,
-        0xb3c4f1ba87bc8696,0x8f48a4899877186c,
-        0xe0b62e2929aba83c,0x331acdabfe94de87,
-        0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
-        0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
-        0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
-        0x892731ac9faf056e,0xbe311c083a225cd2,
-        0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
-        0xd64d3d9db981787d,0x92cbbccdad5b108,
-        0x85f0468293f0eb4e,0x25bbf56008c58ea5,
-        0xa76c582338ed2621,0xaf2af2b80af6f24e,
-        0xd1476e2c07286faa,0x1af5af660db4aee1,
-        0x82cca4db847945ca,0x50d98d9fc890ed4d,
-        0xa37fce126597973c,0xe50ff107bab528a0,
-        0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
-        0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
-        0x9faacf3df73609b1,0x77b191618c54e9ac,
-        0xc795830d75038c1d,0xd59df5b9ef6a2417,
-        0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
-        0x9becce62836ac577,0x4ee367f9430aec32,
-        0xc2e801fb244576d5,0x229c41f793cda73f,
-        0xf3a20279ed56d48a,0x6b43527578c1110f,
-        0x9845418c345644d6,0x830a13896b78aaa9,
-        0xbe5691ef416bd60c,0x23cc986bc656d553,
-        0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
-        0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
-        0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
-        0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
-        0x91376c36d99995be,0x23100809b9c21fa1,
-        0xb58547448ffffb2d,0xabd40a0c2832a78a,
-        0xe2e69915b3fff9f9,0x16c90c8f323f516c,
-        0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
-        0xb1442798f49ffb4a,0x99cd11cfdf41779c,
-        0xdd95317f31c7fa1d,0x40405643d711d583,
-        0x8a7d3eef7f1cfc52,0x482835ea666b2572,
-        0xad1c8eab5ee43b66,0xda3243650005eecf,
-        0xd863b256369d4a40,0x90bed43e40076a82,
-        0x873e4f75e2224e68,0x5a7744a6e804a291,
-        0xa90de3535aaae202,0x711515d0a205cb36,
-        0xd3515c2831559a83,0xd5a5b44ca873e03,
-        0x8412d9991ed58091,0xe858790afe9486c2,
-        0xa5178fff668ae0b6,0x626e974dbe39a872,
-        0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
-        0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
-        0xa139029f6a239f72,0x1c1fffc1ebc44e80,
-        0xc987434744ac874e,0xa327ffb266b56220,
-        0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
-        0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
-        0xc4ce17b399107c22,0xcb550fb4384d21d3,
-        0xf6019da07f549b2b,0x7e2a53a146606a48,
-        0x99c102844f94e0fb,0x2eda7444cbfc426d,
-        0xc0314325637a1939,0xfa911155fefb5308,
-        0xf03d93eebc589f88,0x793555ab7eba27ca,
-        0x96267c7535b763b5,0x4bc1558b2f3458de,
-        0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
-        0xea9c227723ee8bcb,0x465e15a979c1cadc,
-        0x92a1958a7675175f,0xbfacd89ec191ec9,
-        0xb749faed14125d36,0xcef980ec671f667b,
-        0xe51c79a85916f484,0x82b7e12780e7401a,
-        0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
-        0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
-        0xdfbdcece67006ac9,0x67a791e093e1d49a,
-        0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
-        0xaecc49914078536d,0x58fae9f773886e18,
-        0xda7f5bf590966848,0xaf39a475506a899e,
-        0x888f99797a5e012d,0x6d8406c952429603,
-        0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
-        0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
-        0x855c3be0a17fcd26,0x5cf2eea09a55067f,
-        0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
-        0xd0601d8efc57b08b,0xf13b94daf124da26,
-        0x823c12795db6ce57,0x76c53d08d6b70858,
-        0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
-        0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
-        0xfe5d54150b090b02,0xd3f93b35435d7c4c,
-        0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
-        0xc6b8e9b0709f109a,0x359ab6419ca1091b,
-        0xf867241c8cc6d4c0,0xc30163d203c94b62,
-        0x9b407691d7fc44f8,0x79e0de63425dcf1d,
-        0xc21094364dfb5636,0x985915fc12f542e4,
-        0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
-        0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
-        0xbd8430bd08277231,0x50c6ff782a838353,
-        0xece53cec4a314ebd,0xa4f8bf5635246428,
-        0x940f4613ae5ed136,0x871b7795e136be99,
-        0xb913179899f68584,0x28e2557b59846e3f,
-        0xe757dd7ec07426e5,0x331aeada2fe589cf,
-        0x9096ea6f3848984f,0x3ff0d2c85def7621,
-        0xb4bca50b065abe63,0xfed077a756b53a9,
-        0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
-        0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
-        0xb080392cc4349dec,0xbd8d794d96aacfb3,
-        0xdca04777f541c567,0xecf0d7a0fc5583a0,
-        0x89e42caaf9491b60,0xf41686c49db57244,
-        0xac5d37d5b79b6239,0x311c2875c522ced5,
-        0xd77485cb25823ac7,0x7d633293366b828b,
-        0x86a8d39ef77164bc,0xae5dff9c02033197,
-        0xa8530886b54dbdeb,0xd9f57f830283fdfc,
-        0xd267caa862a12d66,0xd072df63c324fd7b,
-        0x8380dea93da4bc60,0x4247cb9e59f71e6d,
-        0xa46116538d0deb78,0x52d9be85f074e608,
-        0xcd795be870516656,0x67902e276c921f8b,
-        0x806bd9714632dff6,0xba1cd8a3db53b6,
-        0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
-        0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
-        0xfad2a4b13d1b5d6c,0x796b805720085f81,
-        0x9cc3a6eec6311a63,0xcbe3303674053bb0,
-        0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
-        0xf4f1b4d515acb93b,0xee92fb5515482d44,
-        0x991711052d8bf3c5,0x751bdd152d4d1c4a,
-        0xbf5cd54678eef0b6,0xd262d45a78a0635d,
-        0xef340a98172aace4,0x86fb897116c87c34,
-        0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
-        0xbae0a846d2195712,0x8974836059cca109,
-        0xe998d258869facd7,0x2bd1a438703fc94b,
-        0x91ff83775423cc06,0x7b6306a34627ddcf,
-        0xb67f6455292cbf08,0x1a3bc84c17b1d542,
-        0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
-        0x8e938662882af53e,0x547eb47b7282ee9c,
-        0xb23867fb2a35b28d,0xe99e619a4f23aa43,
-        0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
-        0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
-        0xae0b158b4738705e,0x9624ab50b148d445,
-        0xd98ddaee19068c76,0x3badd624dd9b0957,
-        0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
-        0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
-        0xd47487cc8470652b,0x7647c3200069671f,
-        0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
-        0xa5fb0a17c777cf09,0xf468107100525890,
-        0xcf79cc9db955c2cc,0x7182148d4066eeb4,
-        0x81ac1fe293d599bf,0xc6f14cd848405530,
-        0xa21727db38cb002f,0xb8ada00e5a506a7c,
-        0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
-        0xfd442e4688bd304a,0x908f4a166d1da663,
-        0x9e4a9cec15763e2e,0x9a598e4e043287fe,
-        0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
-        0xf7549530e188c128,0xd12bee59e68ef47c,
-        0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
-        0xc13a148e3032d6e7,0xe36a52363c1faf01,
-        0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
-        0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
-        0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
-        0xebdf661791d60f56,0x111b495b3464ad21,
-        0x936b9fcebb25c995,0xcab10dd900beec34,
-        0xb84687c269ef3bfb,0x3d5d514f40eea742,
-        0xe65829b3046b0afa,0xcb4a5a3112a5112,
-        0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
-        0xb3f4e093db73a093,0x59ed216765690f56,
-        0xe0f218b8d25088b8,0x306869c13ec3532c,
-        0x8c974f7383725573,0x1e414218c73a13fb,
-        0xafbd2350644eeacf,0xe5d1929ef90898fa,
-        0xdbac6c247d62a583,0xdf45f746b74abf39,
-        0x894bc396ce5da772,0x6b8bba8c328eb783,
-        0xab9eb47c81f5114f,0x66ea92f3f326564,
-        0xd686619ba27255a2,0xc80a537b0efefebd,
-        0x8613fd0145877585,0xbd06742ce95f5f36,
-        0xa798fc4196e952e7,0x2c48113823b73704,
-        0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
-        0x82ef85133de648c4,0x9a984d73dbe722fb,
-        0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
-        0xcc963fee10b7d1b3,0x318df905079926a8,
-        0xffbbcfe994e5c61f,0xfdf17746497f7052,
-        0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
-        0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
-        0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
-        0x9c1661a651213e2d,0x6bea10ca65c084e,
-        0xc31bfa0fe5698db8,0x486e494fcff30a62,
-        0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
-        0x986ddb5c6b3a76b7,0xf89629465a75e01c,
-        0xbe89523386091465,0xf6bbb397f1135823,
-        0xee2ba6c0678b597f,0x746aa07ded582e2c,
-        0x94db483840b717ef,0xa8c2a44eb4571cdc,
-        0xba121a4650e4ddeb,0x92f34d62616ce413,
-        0xe896a0d7e51e1566,0x77b020baf9c81d17,
-        0x915e2486ef32cd60,0xace1474dc1d122e,
-        0xb5b5ada8aaff80b8,0xd819992132456ba,
-        0xe3231912d5bf60e6,0x10e1fff697ed6c69,
-        0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
-        0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
-        0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
-        0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
-        0xad4ab7112eb3929d,0x86c16c98d2c953c6,
-        0xd89d64d57a607744,0xe871c7bf077ba8b7,
-        0x87625f056c7c4a8b,0x11471cd764ad4972,
-        0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
-        0xd389b47879823479,0x4aff1d108d4ec2c3,
-        0x843610cb4bf160cb,0xcedf722a585139ba,
-        0xa54394fe1eedb8fe,0xc2974eb4ee658828,
-        0xce947a3da6a9273e,0x733d226229feea32,
-        0x811ccc668829b887,0x806357d5a3f525f,
-        0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
-        0xc9bcff6034c13052,0xfc89b393dd02f0b5,
-        0xfc2c3f3841f17c67,0xbbac2078d443ace2,
-        0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
-        0xc5029163f384a931,0xa9e795e65d4df11,
-        0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
-        0x99ea0196163fa42e,0x504bced1bf8e4e45,
-        0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
-        0xf07da27a82c37088,0x5d767327bb4e5a4c,
-        0x964e858c91ba2655,0x3a6a07f8d510f86f,
-        0xbbe226efb628afea,0x890489f70a55368b,
-        0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
-        0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
-        0xb77ada0617e3bbcb,0x9ce6ebb40173744,
-        0xe55990879ddcaabd,0xcc420a6a101d0515,
-        0x8f57fa54c2a9eab6,0x9fa946824a12232d,
-        0xb32df8e9f3546564,0x47939822dc96abf9,
-        0xdff9772470297ebd,0x59787e2b93bc56f7,
-        0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
-        0xaefae51477a06b03,0xede622920b6b23f1,
-        0xdab99e59958885c4,0xe95fab368e45eced,
-        0x88b402f7fd75539b,0x11dbcb0218ebb414,
-        0xaae103b5fcd2a881,0xd652bdc29f26a119,
-        0xd59944a37c0752a2,0x4be76d3346f0495f,
-        0x857fcae62d8493a5,0x6f70a4400c562ddb,
-        0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
-        0xd097ad07a71f26b2,0x7e2000a41346a7a7,
-        0x825ecc24c873782f,0x8ed400668c0c28c8,
-        0xa2f67f2dfa90563b,0x728900802f0f32fa,
-        0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
-        0xfea126b7d78186bc,0xe2f610c84987bfa8,
-        0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
-        0xc6ede63fa05d3143,0x91503d1c79720dbb,
-        0xf8a95fcf88747d94,0x75a44c6397ce912a,
-        0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
-        0xc24452da229b021b,0xfbe85badce996168,
-        0xf2d56790ab41c2a2,0xfae27299423fb9c3,
-        0x97c560ba6b0919a5,0xdccd879fc967d41a,
-        0xbdb6b8e905cb600f,0x5400e987bbc1c920,
-        0xed246723473e3813,0x290123e9aab23b68,
-        0x9436c0760c86e30b,0xf9a0b6720aaf6521,
-        0xb94470938fa89bce,0xf808e40e8d5b3e69,
-        0xe7958cb87392c2c2,0xb60b1d1230b20e04,
-        0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
-        0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
-        0xe2280b6c20dd5232,0x25c6da63c38de1b0,
-        0x8d590723948a535f,0x579c487e5a38ad0e,
-        0xb0af48ec79ace837,0x2d835a9df0c6d851,
-        0xdcdb1b2798182244,0xf8e431456cf88e65,
-        0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
-        0xac8b2d36eed2dac5,0xe272467e3d222f3f,
-        0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
-        0x86ccbb52ea94baea,0x98e947129fc2b4e9,
-        0xa87fea27a539e9a5,0x3f2398d747b36224,
-        0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
-        0x83a3eeeef9153e89,0x1953cf68300424ac,
-        0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
-        0xcdb02555653131b6,0x3792f412cb06794d,
-        0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
-        0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
-        0xc8de047564d20a8b,0xf245825a5a445275,
-        0xfb158592be068d2e,0xeed6e2f0f0d56712,
-        0x9ced737bb6c4183d,0x55464dd69685606b,
-        0xc428d05aa4751e4c,0xaa97e14c3c26b886,
-        0xf53304714d9265df,0xd53dd99f4b3066a8,
-        0x993fe2c6d07b7fab,0xe546a8038efe4029,
-        0xbf8fdb78849a5f96,0xde98520472bdd033,
-        0xef73d256a5c0f77c,0x963e66858f6d4440,
-        0x95a8637627989aad,0xdde7001379a44aa8,
-        0xbb127c53b17ec159,0x5560c018580d5d52,
-        0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
-        0x9226712162ab070d,0xcab3961304ca70e8,
-        0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
-        0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
-        0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
-        0xb267ed1940f1c61c,0x55f038b237591ed3,
-        0xdf01e85f912e37a3,0x6b6c46dec52f6688,
-        0x8b61313bbabce2c6,0x2323ac4b3b3da015,
-        0xae397d8aa96c1b77,0xabec975e0a0d081a,
-        0xd9c7dced53c72255,0x96e7bd358c904a21,
-        0x881cea14545c7575,0x7e50d64177da2e54,
-        0xaa242499697392d2,0xdde50bd1d5d0b9e9,
-        0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
-        0x84ec3c97da624ab4,0xbd5af13bef0b113e,
-        0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
-        0xcfb11ead453994ba,0x67de18eda5814af2,
-        0x81ceb32c4b43fcf4,0x80eacf948770ced7,
-        0xa2425ff75e14fc31,0xa1258379a94d028d,
-        0xcad2f7f5359a3b3e,0x96ee45813a04330,
-        0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
-        0x9e74d1b791e07e48,0x775ea264cf55347e,
-        0xc612062576589dda,0x95364afe032a819e,
-        0xf79687aed3eec551,0x3a83ddbd83f52205,
-        0x9abe14cd44753b52,0xc4926a9672793543,
-        0xc16d9a0095928a27,0x75b7053c0f178294,
-        0xf1c90080baf72cb1,0x5324c68b12dd6339,
-        0x971da05074da7bee,0xd3f6fc16ebca5e04,
-        0xbce5086492111aea,0x88f4bb1ca6bcf585,
-        0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
-        0x9392ee8e921d5d07,0x3aff322e62439fd0,
-        0xb877aa3236a4b449,0x9befeb9fad487c3,
-        0xe69594bec44de15b,0x4c2ebe687989a9b4,
-        0x901d7cf73ab0acd9,0xf9d37014bf60a11,
-        0xb424dc35095cd80f,0x538484c19ef38c95,
-        0xe12e13424bb40e13,0x2865a5f206b06fba,
-        0x8cbccc096f5088cb,0xf93f87b7442e45d4,
-        0xafebff0bcb24aafe,0xf78f69a51539d749,
-        0xdbe6fecebdedd5be,0xb573440e5a884d1c,
-        0x89705f4136b4a597,0x31680a88f8953031,
-        0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
-        0xd6bf94d5e57a42bc,0x3d32907604691b4d,
-        0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
-        0xa7c5ac471b478423,0xfcf80dc33721d54,
-        0xd1b71758e219652b,0xd3c36113404ea4a9,
-        0x83126e978d4fdf3b,0x645a1cac083126ea,
-        0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
-        0xcccccccccccccccc,0xcccccccccccccccd,
-        0x8000000000000000,0x0,
-        0xa000000000000000,0x0,
-        0xc800000000000000,0x0,
-        0xfa00000000000000,0x0,
-        0x9c40000000000000,0x0,
-        0xc350000000000000,0x0,
-        0xf424000000000000,0x0,
-        0x9896800000000000,0x0,
-        0xbebc200000000000,0x0,
-        0xee6b280000000000,0x0,
-        0x9502f90000000000,0x0,
-        0xba43b74000000000,0x0,
-        0xe8d4a51000000000,0x0,
-        0x9184e72a00000000,0x0,
-        0xb5e620f480000000,0x0,
-        0xe35fa931a0000000,0x0,
-        0x8e1bc9bf04000000,0x0,
-        0xb1a2bc2ec5000000,0x0,
-        0xde0b6b3a76400000,0x0,
-        0x8ac7230489e80000,0x0,
-        0xad78ebc5ac620000,0x0,
-        0xd8d726b7177a8000,0x0,
-        0x878678326eac9000,0x0,
-        0xa968163f0a57b400,0x0,
-        0xd3c21bcecceda100,0x0,
-        0x84595161401484a0,0x0,
-        0xa56fa5b99019a5c8,0x0,
-        0xcecb8f27f4200f3a,0x0,
-        0x813f3978f8940984,0x4000000000000000,
-        0xa18f07d736b90be5,0x5000000000000000,
-        0xc9f2c9cd04674ede,0xa400000000000000,
-        0xfc6f7c4045812296,0x4d00000000000000,
-        0x9dc5ada82b70b59d,0xf020000000000000,
-        0xc5371912364ce305,0x6c28000000000000,
-        0xf684df56c3e01bc6,0xc732000000000000,
-        0x9a130b963a6c115c,0x3c7f400000000000,
-        0xc097ce7bc90715b3,0x4b9f100000000000,
-        0xf0bdc21abb48db20,0x1e86d40000000000,
-        0x96769950b50d88f4,0x1314448000000000,
-        0xbc143fa4e250eb31,0x17d955a000000000,
-        0xeb194f8e1ae525fd,0x5dcfab0800000000,
-        0x92efd1b8d0cf37be,0x5aa1cae500000000,
-        0xb7abc627050305ad,0xf14a3d9e40000000,
-        0xe596b7b0c643c719,0x6d9ccd05d0000000,
-        0x8f7e32ce7bea5c6f,0xe4820023a2000000,
-        0xb35dbf821ae4f38b,0xdda2802c8a800000,
-        0xe0352f62a19e306e,0xd50b2037ad200000,
-        0x8c213d9da502de45,0x4526f422cc340000,
-        0xaf298d050e4395d6,0x9670b12b7f410000,
-        0xdaf3f04651d47b4c,0x3c0cdd765f114000,
-        0x88d8762bf324cd0f,0xa5880a69fb6ac800,
-        0xab0e93b6efee0053,0x8eea0d047a457a00,
-        0xd5d238a4abe98068,0x72a4904598d6d880,
-        0x85a36366eb71f041,0x47a6da2b7f864750,
-        0xa70c3c40a64e6c51,0x999090b65f67d924,
-        0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
-        0x82818f1281ed449f,0xbff8f10e7a8921a4,
-        0xa321f2d7226895c7,0xaff72d52192b6a0d,
-        0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
-        0xfee50b7025c36a08,0x2f236d04753d5b4,
-        0x9f4f2726179a2245,0x1d762422c946590,
-        0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
-        0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
-        0x9b934c3b330c8577,0x63cc55f49f88eb2f,
-        0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
-        0xf316271c7fc3908a,0x8bef464e3945ef7a,
-        0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
-        0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
-        0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
-        0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
-        0xb975d6b6ee39e436,0xb3e2fd538e122b44,
-        0xe7d34c64a9c85d44,0x60dbbca87196b616,
-        0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
-        0xb51d13aea4a488dd,0x6babab6398bdbe41,
-        0xe264589a4dcdab14,0xc696963c7eed2dd1,
-        0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
-        0xb0de65388cc8ada8,0x3b25a55f43294bcb,
-        0xdd15fe86affad912,0x49ef0eb713f39ebe,
-        0x8a2dbf142dfcc7ab,0x6e3569326c784337,
-        0xacb92ed9397bf996,0x49c2c37f07965404,
-        0xd7e77a8f87daf7fb,0xdc33745ec97be906,
-        0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
-        0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
-        0xd2d80db02aabd62b,0xf50a3fa490c30190,
-        0x83c7088e1aab65db,0x792667c6da79e0fa,
-        0xa4b8cab1a1563f52,0x577001b891185938,
-        0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
-        0x80b05e5ac60b6178,0x544f8158315b05b4,
-        0xa0dc75f1778e39d6,0x696361ae3db1c721,
-        0xc913936dd571c84c,0x3bc3a19cd1e38e9,
-        0xfb5878494ace3a5f,0x4ab48a04065c723,
-        0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
-        0xc45d1df942711d9a,0x3ba5d0bd324f8394,
-        0xf5746577930d6500,0xca8f44ec7ee36479,
-        0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
-        0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
-        0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
-        0x95d04aee3b80ece5,0xbba1f1d158724a12,
-        0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
-        0xea1575143cf97226,0xf52d09d71a3293bd,
-        0x924d692ca61be758,0x593c2626705f9c56,
-        0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
-        0xe498f455c38b997a,0xb6dfb9c0f956447,
-        0x8edf98b59a373fec,0x4724bd4189bd5eac,
-        0xb2977ee300c50fe7,0x58edec91ec2cb657,
-        0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
-        0x8b865b215899f46c,0xbd79e0d20082ee74,
-        0xae67f1e9aec07187,0xecd8590680a3aa11,
-        0xda01ee641a708de9,0xe80e6f4820cc9495,
-        0x884134fe908658b2,0x3109058d147fdcdd,
-        0xaa51823e34a7eede,0xbd4b46f0599fd415,
-        0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
-        0x850fadc09923329e,0x3e2cf6bc604ddb0,
-        0xa6539930bf6bff45,0x84db8346b786151c,
-        0xcfe87f7cef46ff16,0xe612641865679a63,
-        0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
-        0xa26da3999aef7749,0xe3be5e330f38f09d,
-        0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
-        0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
-        0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
-        0xc646d63501a1511d,0xb281e1fd541501b8,
-        0xf7d88bc24209a565,0x1f225a7ca91a4226,
-        0x9ae757596946075f,0x3375788de9b06958,
-        0xc1a12d2fc3978937,0x52d6b1641c83ae,
-        0xf209787bb47d6b84,0xc0678c5dbd23a49a,
-        0x9745eb4d50ce6332,0xf840b7ba963646e0,
-        0xbd176620a501fbff,0xb650e5a93bc3d898,
-        0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
-        0x93ba47c980e98cdf,0xc66f336c36b10137,
-        0xb8a8d9bbe123f017,0xb80b0047445d4184,
-        0xe6d3102ad96cec1d,0xa60dc059157491e5,
-        0x9043ea1ac7e41392,0x87c89837ad68db2f,
-        0xb454e4a179dd1877,0x29babe4598c311fb,
-        0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
-        0x8ce2529e2734bb1d,0x1899e4a65f58660c,
-        0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
-        0xdc21a1171d42645d,0x76707543f4fa1f73,
-        0x899504ae72497eba,0x6a06494a791c53a8,
-        0xabfa45da0edbde69,0x487db9d17636892,
-        0xd6f8d7509292d603,0x45a9d2845d3c42b6,
-        0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
-        0xa7f26836f282b732,0x8e6cac7768d7141e,
-        0xd1ef0244af2364ff,0x3207d795430cd926,
-        0x8335616aed761f1f,0x7f44e6bd49e807b8,
-        0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
-        0xcd036837130890a1,0x36dba887c37a8c0f,
-        0x802221226be55a64,0xc2494954da2c9789,
-        0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
-        0xc83553c5c8965d3d,0x6f92829494e5acc7,
-        0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
-        0x9c69a97284b578d7,0xff2a760414536efb,
-        0xc38413cf25e2d70d,0xfef5138519684aba,
-        0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
-        0x98bf2f79d5993802,0xef2f773ffbd97a61,
-        0xbeeefb584aff8603,0xaafb550ffacfd8fa,
-        0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
-        0x952ab45cfa97a0b2,0xdd945a747bf26183,
-        0xba756174393d88df,0x94f971119aeef9e4,
-        0xe912b9d1478ceb17,0x7a37cd5601aab85d,
-        0x91abb422ccb812ee,0xac62e055c10ab33a,
-        0xb616a12b7fe617aa,0x577b986b314d6009,
-        0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
-        0x8e41ade9fbebc27d,0x14588f13be847307,
-        0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
-        0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
-        0x8aec23d680043bee,0x25de7bb9480d5854,
-        0xada72ccc20054ae9,0xaf561aa79a10ae6a,
-        0xd910f7ff28069da4,0x1b2ba1518094da04,
-        0x87aa9aff79042286,0x90fb44d2f05d0842,
-        0xa99541bf57452b28,0x353a1607ac744a53,
-        0xd3fa922f2d1675f2,0x42889b8997915ce8,
-        0x847c9b5d7c2e09b7,0x69956135febada11,
-        0xa59bc234db398c25,0x43fab9837e699095,
-        0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
-        0x8161afb94b44f57d,0x1d1be0eebac278f5,
-        0xa1ba1ba79e1632dc,0x6462d92a69731732,
-        0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
-        0xfcb2cb35e702af78,0x5cda735244c3d43e,
-        0x9defbf01b061adab,0x3a0888136afa64a7,
-        0xc56baec21c7a1916,0x88aaa1845b8fdd0,
-        0xf6c69a72a3989f5b,0x8aad549e57273d45,
-        0x9a3c2087a63f6399,0x36ac54e2f678864b,
-        0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
-        0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
-        0x969eb7c47859e743,0x9f644ae5a4b1b325,
-        0xbc4665b596706114,0x873d5d9f0dde1fee,
-        0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
-        0x9316ff75dd87cbd8,0x9a7f12442d588f2,
-        0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
-        0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
-        0x8fa475791a569d10,0xf96e017d694487bc,
-        0xb38d92d760ec4455,0x37c981dcc395a9ac,
-        0xe070f78d3927556a,0x85bbe253f47b1417,
-        0x8c469ab843b89562,0x93956d7478ccec8e,
-        0xaf58416654a6babb,0x387ac8d1970027b2,
-        0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
-        0x88fcf317f22241e2,0x441fece3bdf81f03,
-        0xab3c2fddeeaad25a,0xd527e81cad7626c3,
-        0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
-        0x85c7056562757456,0xf6872d5667844e49,
-        0xa738c6bebb12d16c,0xb428f8ac016561db,
-        0xd106f86e69d785c7,0xe13336d701beba52,
-        0x82a45b450226b39c,0xecc0024661173473,
-        0xa34d721642b06084,0x27f002d7f95d0190,
-        0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
-        0xff290242c83396ce,0x7e67047175a15271,
-        0x9f79a169bd203e41,0xf0062c6e984d386,
-        0xc75809c42c684dd1,0x52c07b78a3e60868,
-        0xf92e0c3537826145,0xa7709a56ccdf8a82,
-        0x9bbcc7a142b17ccb,0x88a66076400bb691,
-        0xc2abf989935ddbfe,0x6acff893d00ea435,
-        0xf356f7ebf83552fe,0x583f6b8c4124d43,
-        0x98165af37b2153de,0xc3727a337a8b704a,
-        0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
-        0xeda2ee1c7064130c,0x1162def06f79df73,
-        0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
-        0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
-        0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
-        0x910ab1d4db9914a0,0x1d9c9892400a22a2,
-        0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
-        0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
-        0x8da471a9de737e24,0x5ceaecfed289e5d2,
-        0xb10d8e1456105dad,0x7425a83e872c5f47,
-        0xdd50f1996b947518,0xd12f124e28f77719,
-        0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
-        0xace73cbfdc0bfb7b,0x636cc64d1001550b,
-        0xd8210befd30efa5a,0x3c47f7e05401aa4e,
-        0x8714a775e3e95c78,0x65acfaec34810a71,
-        0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
-        0xd31045a8341ca07c,0x1ede48111209a050,
-        0x83ea2b892091e44d,0x934aed0aab460432,
-        0xa4e4b66b68b65d60,0xf81da84d5617853f,
-        0xce1de40642e3f4b9,0x36251260ab9d668e,
-        0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
-        0xa1075a24e4421730,0xb24cf65b8612f81f,
-        0xc94930ae1d529cfc,0xdee033f26797b627,
-        0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
-        0x9d412e0806e88aa5,0x8e1f289560ee864e,
-        0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
-        0xf5b5d7ec8acb58a2,0xae10af696774b1db,
-        0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
-        0xbff610b0cc6edd3f,0x17fd090a58d32af3,
-        0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
-        0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
-        0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
-        0xea53df5fd18d5513,0x84c86189216dc5ed,
-        0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
-        0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
-        0xe4d5e82392a40515,0xfabaf3feaa5334a,
-        0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
-        0xb2c71d5bca9023f8,0x743e20e9ef511012,
-        0xdf78e4b2bd342cf6,0x914da9246b255416,
-        0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
-        0xae9672aba3d0c320,0xa184ac2473b529b1,
-        0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
-        0x8865899617fb1871,0x7e2fa67c7a658892,
-        0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
-        0xd51ea6fa85785631,0x552a74227f3ea565,
-        0x8533285c936b35de,0xd53a88958f87275f,
-        0xa67ff273b8460356,0x8a892abaf368f137,
-        0xd01fef10a657842c,0x2d2b7569b0432d85,
-        0x8213f56a67f6b29b,0x9c3b29620e29fc73,
-        0xa298f2c501f45f42,0x8349f3ba91b47b8f,
-        0xcb3f2f7642717713,0x241c70a936219a73,
-        0xfe0efb53d30dd4d7,0xed238cd383aa0110,
-        0x9ec95d1463e8a506,0xf4363804324a40aa,
-        0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
-        0xf81aa16fdc1b81da,0xdd94b7868e94050a,
-        0x9b10a4e5e9913128,0xca7cf2b4191c8326,
-        0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
-        0xf24a01a73cf2dccf,0xbc633b39673c8cec,
-        0x976e41088617ca01,0xd5be0503e085d813,
-        0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
-        0xec9c459d51852ba2,0xddf8e7d60ed1219e,
-        0x93e1ab8252f33b45,0xcabb90e5c942b503,
-        0xb8da1662e7b00a17,0x3d6a751f3b936243,
-        0xe7109bfba19c0c9d,0xcc512670a783ad4,
-        0x906a617d450187e2,0x27fb2b80668b24c5,
-        0xb484f9dc9641e9da,0xb1f9f660802dedf6,
-        0xe1a63853bbd26451,0x5e7873f8a0396973,
-        0x8d07e33455637eb2,0xdb0b487b6423e1e8,
-        0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
-        0xdc5c5301c56b75f7,0x7641a140cc7810fb,
-        0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
-        0xac2820d9623bf429,0x546345fa9fbdcd44,
-        0xd732290fbacaf133,0xa97c177947ad4095,
-        0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
-        0xa81f301449ee8c70,0x5c68f256bfff5a74,
-        0xd226fc195c6a2f8c,0x73832eec6fff3111,
-        0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
-        0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
-        0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
-        0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
-        0xa0555e361951c366,0xd7e105bcc332621f,
-        0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
-        0xfa856334878fc150,0xb14f98f6f0feb951,
-        0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
-        0xc3b8358109e84f07,0xa862f80ec4700c8,
-        0xf4a642e14c6262c8,0xcd27bb612758c0fa,
-        0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
-        0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
-        0xeeea5d5004981478,0x1858ccfce06cac74,
-        0x95527a5202df0ccb,0xf37801e0c43ebc8,
-        0xbaa718e68396cffd,0xd30560258f54e6ba,
-        0xe950df20247c83fd,0x47c6b82ef32a2069,
-        0x91d28b7416cdd27e,0x4cdc331d57fa5441,
-        0xb6472e511c81471d,0xe0133fe4adf8e952,
-        0xe3d8f9e563a198e5,0x58180fddd97723a6,
-        0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
+constexpr uint64_t powers_template<unused>::power_of_five_128[number_of_entries];
+
 using powers = powers_template<>;
 
-}
+} // namespace fast_float
 } // namespace arrow_vendored
 
 #endif
diff --git a/cpp/src/arrow/vendored/fast_float/float_common.h b/cpp/src/arrow/vendored/fast_float/float_common.h
index 0d6bfe7efb88b..717320126750c 100644
--- a/cpp/src/arrow/vendored/fast_float/float_common.h
+++ b/cpp/src/arrow/vendored/fast_float/float_common.h
@@ -7,6 +7,25 @@
 #include <cstring>
 #include <type_traits>
 
+#ifdef __has_include
+#if __has_include(<version>)
+#include <version>
+#endif
+#endif
+
+#if __cpp_lib_bit_cast >= 201806L
+#include <bit>
+#define FASTFLOAT_HAS_BIT_CAST 1
+#else
+#define FASTFLOAT_HAS_BIT_CAST 0
+#endif
+
+#if __cpp_lib_is_constant_evaluated >= 201811L
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 1
+#else
+#define FASTFLOAT_HAS_IS_CONSTANT_EVALUATED 0
+#endif
+
 #if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64)   \
        || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
        || defined(__MINGW64__)                                          \
@@ -14,7 +33,7 @@
        || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) )
 #define FASTFLOAT_64BIT 1
 #elif (defined(__i386) || defined(__i386__) || defined(_M_IX86)   \
-     || defined(__arm__) || defined(_M_ARM)                   \
+     || defined(__arm__) || defined(_M_ARM) || defined(__ppc__)   \
      || defined(__MINGW32__) || defined(__EMSCRIPTEN__))
 #define FASTFLOAT_32BIT 1
 #else
@@ -50,7 +69,11 @@
 #elif defined(sun) || defined(__sun)
 #include <sys/byteorder.h>
 #else
+#ifdef __has_include
+#if __has_include(<endian.h>)
 #include <endian.h>
+#endif //__has_include(<endian.h>)
+#endif //__has_include
 #endif
 #
 #ifndef __BYTE_ORDER__
@@ -77,23 +100,46 @@
 #endif
 
 #ifndef FASTFLOAT_ASSERT
-#define FASTFLOAT_ASSERT(x)  { if (!(x)) abort(); }
+#define FASTFLOAT_ASSERT(x)  { ((void)(x)); }
 #endif
 
 #ifndef FASTFLOAT_DEBUG_ASSERT
-#include <cassert>
-#define FASTFLOAT_DEBUG_ASSERT(x) assert(x)
+#define FASTFLOAT_DEBUG_ASSERT(x) { ((void)(x)); }
 #endif
 
 // rust style `try!()` macro, or `?` operator
 #define FASTFLOAT_TRY(x) { if (!(x)) return false; }
 
+// Testing for https://wg21.link/N3652, adopted in C++14
+#if __cpp_constexpr >= 201304
+#define FASTFLOAT_CONSTEXPR14 constexpr
+#else
+#define FASTFLOAT_CONSTEXPR14
+#endif
+
+// Testing for relevant C++20 constexpr library features
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED \
+    && FASTFLOAT_HAS_BIT_CAST \
+    && __cpp_lib_constexpr_algorithms >= 201806L /*For std::copy and std::fill*/
+#define FASTFLOAT_CONSTEXPR20 constexpr
+#else
+#define FASTFLOAT_CONSTEXPR20
+#endif
+
 namespace arrow_vendored {
 namespace fast_float {
 
+fastfloat_really_inline constexpr bool cpp20_and_in_constexpr() {
+#if FASTFLOAT_HAS_IS_CONSTANT_EVALUATED
+  return std::is_constant_evaluated();
+#else
+  return false;
+#endif
+}
+
 // Compares two ASCII strings in a case insensitive manner.
-inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
-                                  size_t length) {
+inline FASTFLOAT_CONSTEXPR14 bool
+fastfloat_strncasecmp(const char *input1, const char *input2, size_t length) {
   char running_diff{0};
   for (size_t i = 0; i < length; i++) {
     running_diff |= (input1[i] ^ input2[i]);
@@ -110,14 +156,14 @@ template <typename T>
 struct span {
   const T* ptr;
   size_t length;
-  span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
-  span() : ptr(nullptr), length(0) {}
+  constexpr span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
+  constexpr span() : ptr(nullptr), length(0) {}
 
   constexpr size_t len() const noexcept {
     return length;
   }
 
-  const T& operator[](size_t index) const noexcept {
+  FASTFLOAT_CONSTEXPR14 const T& operator[](size_t index) const noexcept {
     FASTFLOAT_DEBUG_ASSERT(index < length);
     return ptr[index];
   }
@@ -126,13 +172,31 @@ struct span {
 struct value128 {
   uint64_t low;
   uint64_t high;
-  value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
-  value128() : low(0), high(0) {}
+  constexpr value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+  constexpr value128() : low(0), high(0) {}
 };
 
+/* Helper C++11 constexpr generic implementation of leading_zeroes */
+fastfloat_really_inline constexpr
+int leading_zeroes_generic(uint64_t input_num, int last_bit = 0) {
+  return (
+    ((input_num & uint64_t(0xffffffff00000000)) && (input_num >>= 32, last_bit |= 32)),
+    ((input_num & uint64_t(        0xffff0000)) && (input_num >>= 16, last_bit |= 16)),
+    ((input_num & uint64_t(            0xff00)) && (input_num >>=  8, last_bit |=  8)),
+    ((input_num & uint64_t(              0xf0)) && (input_num >>=  4, last_bit |=  4)),
+    ((input_num & uint64_t(               0xc)) && (input_num >>=  2, last_bit |=  2)),
+    ((input_num & uint64_t(               0x2)) && (input_num >>=  1, last_bit |=  1)),
+    63 - last_bit
+  );
+}
+
 /* result might be undefined when input_num is zero */
-fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
+int leading_zeroes(uint64_t input_num) {
   assert(input_num > 0);
+  if (cpp20_and_in_constexpr()) {
+    return leading_zeroes_generic(input_num);
+  }
 #ifdef FASTFLOAT_VISUAL_STUDIO
   #if defined(_M_X64) || defined(_M_ARM64)
   unsigned long leading_zero = 0;
@@ -141,31 +205,20 @@ fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
   _BitScanReverse64(&leading_zero, input_num);
   return (int)(63 - leading_zero);
   #else
-  int last_bit = 0;
-  if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
-  if(input_num & uint64_t(        0xffff0000)) input_num >>= 16, last_bit |= 16;
-  if(input_num & uint64_t(            0xff00)) input_num >>=  8, last_bit |=  8;
-  if(input_num & uint64_t(              0xf0)) input_num >>=  4, last_bit |=  4;
-  if(input_num & uint64_t(               0xc)) input_num >>=  2, last_bit |=  2;
-  if(input_num & uint64_t(               0x2)) input_num >>=  1, last_bit |=  1;
-  return 63 - last_bit;
+  return leading_zeroes_generic(input_num);
   #endif
 #else
   return __builtin_clzll(input_num);
 #endif
 }
 
-#ifdef FASTFLOAT_32BIT
-
 // slow emulation routine for 32-bit
-fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
+fastfloat_really_inline constexpr uint64_t emulu(uint32_t x, uint32_t y) {
     return x * (uint64_t)y;
 }
 
-// slow emulation routine for 32-bit
-#if !defined(__MINGW64__)
-fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
-                                          uint64_t *hi) {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+uint64_t umul128_generic(uint64_t ab, uint64_t cd, uint64_t *hi) {
   uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
   uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
   uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
@@ -175,14 +228,28 @@ fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
         (adbc_carry << 32) + !!(lo < bd);
   return lo;
 }
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline FASTFLOAT_CONSTEXPR14
+uint64_t _umul128(uint64_t ab, uint64_t cd, uint64_t *hi) {
+  return umul128_generic(ab, cd, hi);
+}
 #endif // !__MINGW64__
 
 #endif // FASTFLOAT_32BIT
 
 
 // compute 64-bit a*b
-fastfloat_really_inline value128 full_multiplication(uint64_t a,
-                                                     uint64_t b) {
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
+value128 full_multiplication(uint64_t a, uint64_t b) {
+  if (cpp20_and_in_constexpr()) {
+    value128 answer;
+    answer.low = umul128_generic(a, b, &answer.high);
+    return answer;
+  }
   value128 answer;
 #if defined(_M_ARM64) && !defined(__MINGW32__)
   // ARM64 has native support for 64-bit multiplications, no need to emulate
@@ -196,7 +263,7 @@ fastfloat_really_inline value128 full_multiplication(uint64_t a,
   answer.low = uint64_t(r);
   answer.high = uint64_t(r >> 64);
 #else
-  #error Not implemented
+  answer.low = umul128_generic(a, b, &answer.high);
 #endif
   return answer;
 }
@@ -205,10 +272,10 @@ struct adjusted_mantissa {
   uint64_t mantissa{0};
   int32_t power2{0}; // a negative value indicates an invalid result
   adjusted_mantissa() = default;
-  bool operator==(const adjusted_mantissa &o) const {
+  constexpr bool operator==(const adjusted_mantissa &o) const {
     return mantissa == o.mantissa && power2 == o.power2;
   }
-  bool operator!=(const adjusted_mantissa &o) const {
+  constexpr bool operator!=(const adjusted_mantissa &o) const {
     return mantissa != o.mantissa || power2 != o.power2;
   }
 };
@@ -219,8 +286,8 @@ constexpr static int32_t invalid_am_bias = -0x8000;
 constexpr static double powers_of_ten_double[] = {
     1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,  1e8,  1e9,  1e10, 1e11,
     1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
-                                                1e6, 1e7, 1e8, 1e9, 1e10};
+constexpr static float powers_of_ten_float[] = {1e0f, 1e1f, 1e2f, 1e3f, 1e4f, 1e5f,
+                                                1e6f, 1e7f, 1e8f, 1e9f, 1e10f};
 // used for max_mantissa_double and max_mantissa_float
 constexpr uint64_t constant_55555 = 5 * 5 * 5 * 5 * 5;
 // Largest integer value v so that (5**index * v) <= 1<<53.
@@ -433,23 +500,41 @@ template <> inline constexpr binary_format<double>::equiv_uint
 }
 
 template<typename T>
-fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
-  uint64_t word = am.mantissa;
-  word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
-  word = negative
-  ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
-#if FASTFLOAT_IS_BIG_ENDIAN == 1
-   if (std::is_same<T, float>::value) {
-     ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
-   } else {
-     ::memcpy(&value, &word, sizeof(T));
-   }
+fastfloat_really_inline FASTFLOAT_CONSTEXPR20
+void to_float(bool negative, adjusted_mantissa am, T &value) {
+  using uint = typename binary_format<T>::equiv_uint;
+  uint word = (uint)am.mantissa;
+  word |= uint(am.power2) << binary_format<T>::mantissa_explicit_bits();
+  word |= uint(negative) << binary_format<T>::sign_index();
+#if FASTFLOAT_HAS_BIT_CAST
+  value = std::bit_cast<T>(word);
 #else
-   // For little-endian systems:
-   ::memcpy(&value, &word, sizeof(T));
+  ::memcpy(&value, &word, sizeof(T));
 #endif
 }
 
+#if FASTFLOAT_SKIP_WHITE_SPACE // disabled by default
+template <typename = void>
+struct space_lut {
+  static constexpr bool value[] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+};
+
+template <typename T>
+constexpr bool space_lut<T>::value[];
+
+inline constexpr bool is_space(uint8_t c) { return space_lut<>::value[c]; }
+#endif
 } // namespace fast_float
 } // namespace arrow_vendored
 
diff --git a/cpp/src/arrow/vendored/fast_float/parse_number.h b/cpp/src/arrow/vendored/fast_float/parse_number.h
index e1c9603aeaa94..905d614c9db29 100644
--- a/cpp/src/arrow/vendored/fast_float/parse_number.h
+++ b/cpp/src/arrow/vendored/fast_float/parse_number.h
@@ -30,6 +30,11 @@ from_chars_result parse_infnan(const char *first, const char *last, T &value)  n
       minusSign = true;
       ++first;
   }
+#if FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default
+  if (*first == '+') {
+      ++first;
+  }
+#endif
   if (last - first >= 3) {
     if (fastfloat_strncasecmp(first, "nan", 3)) {
       answer.ptr = (first += 3);
@@ -67,6 +72,10 @@ from_chars_result parse_infnan(const char *first, const char *last, T &value)  n
  * Credit : @mwalcott3
  */
 fastfloat_really_inline bool rounds_to_nearest() noexcept {
+  // https://lemire.me/blog/2020/06/26/gcc-not-nearest/
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+  return false;
+#endif
   // See
   // A fast function to check your floating-point rounding mode
   // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/
@@ -100,7 +109,25 @@ fastfloat_really_inline bool rounds_to_nearest() noexcept {
   //
   // Note: This may fail to be accurate if fast-math has been
   // enabled, as rounding conventions may not apply.
+  #if FASTFLOAT_VISUAL_STUDIO
+  #   pragma warning(push)
+  //  todo: is there a VS warning?
+  //  see https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013
+  #elif defined(__clang__)
+  #   pragma clang diagnostic push
+  #   pragma clang diagnostic ignored "-Wfloat-equal"
+  #elif defined(__GNUC__)
+  #   pragma GCC diagnostic push
+  #   pragma GCC diagnostic ignored "-Wfloat-equal"
+  #endif
   return (fmini + 1.0f == 1.0f - fmini);
+  #if FASTFLOAT_VISUAL_STUDIO
+  #   pragma warning(pop)
+  #elif defined(__clang__)
+  #   pragma clang diagnostic pop
+  #elif defined(__GNUC__)
+  #   pragma GCC diagnostic pop
+  #endif
 }
 
 } // namespace detail
@@ -119,6 +146,11 @@ from_chars_result from_chars_advanced(const char *first, const char *last,
 
 
   from_chars_result answer;
+#if FASTFLOAT_SKIP_WHITE_SPACE  // disabled by default
+  while ((first != last) && fast_float::is_space(uint8_t(*first))) {
+    first++;
+  }
+#endif
   if (first == last) {
     answer.ec = std::errc::invalid_argument;
     answer.ptr = first;
diff --git a/cpp/src/arrow/vendored/fast_float/update.sh b/cpp/src/arrow/vendored/fast_float/update.sh
index ab6e9515da5d8..f0e2d3dc508c5 100755
--- a/cpp/src/arrow/vendored/fast_float/update.sh
+++ b/cpp/src/arrow/vendored/fast_float/update.sh
@@ -23,7 +23,7 @@ source_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 if [ "$#" -ne 1 ]; then
   echo "Usage: $0 VERSION"
-  echo " e.g.: $0 3.8.1"
+  echo " e.g.: $0 3.10.1"
   exit 1
 fi
 

From b9a647023de40a670ec8d9c32ff6e205debfaa8d Mon Sep 17 00:00:00 2001
From: abandy <abandy@live.com>
Date: Wed, 19 Jul 2023 19:55:47 -0400
Subject: [PATCH 016/749] GH-36546: [Swift] The initial implementation for
 swift arrow flight (#36547)

The initial implementation for swift arrow flight.

This change depends on PR GH-36544.
* Closes: #36546

Authored-by: Alva Bandy <abandy@live.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/swift_test.sh                      |    5 +
 swift/ArrowFlight/.gitignore                  |    9 +
 swift/ArrowFlight/Package.swift               |   53 +
 .../Sources/ArrowFlight/Flight.grpc.swift     | 1343 ++++++++++++++++
 .../Sources/ArrowFlight/Flight.pb.swift       | 1366 +++++++++++++++++
 .../Sources/ArrowFlight/FlightAction.swift    |   39 +
 .../ArrowFlight/FlightActionType.swift        |   38 +
 .../Sources/ArrowFlight/FlightClient.swift    |  144 ++
 .../Sources/ArrowFlight/FlightCriteria.swift  |   37 +
 .../Sources/ArrowFlight/FlightData.swift      |   46 +
 .../ArrowFlight/FlightDescriptor.swift        |   56 +
 .../Sources/ArrowFlight/FlightEndpoint.swift  |   38 +
 .../Sources/ArrowFlight/FlightInfo.swift      |   55 +
 .../Sources/ArrowFlight/FlightLocation.swift  |   36 +
 .../Sources/ArrowFlight/FlightPutResult.swift |   35 +
 .../Sources/ArrowFlight/FlightResult.swift    |   35 +
 .../ArrowFlight/FlightSchemaResult.swift      |   37 +
 .../Sources/ArrowFlight/FlightServer.swift    |  162 ++
 .../Sources/ArrowFlight/FlightTicket.swift    |   35 +
 .../ArrowFlight/RecordBatchStreamReader.swift |   67 +
 .../ArrowFlight/RecordBatchStreamWriter.swift |   91 ++
 .../Tests/ArrowFlightTests/FlightTest.swift   |  302 ++++
 swift/gen-protobuffers.sh                     |   44 +
 23 files changed, 4073 insertions(+)
 create mode 100644 swift/ArrowFlight/.gitignore
 create mode 100644 swift/ArrowFlight/Package.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/Flight.pb.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
 create mode 100644 swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
 create mode 100755 swift/gen-protobuffers.sh

diff --git a/ci/scripts/swift_test.sh b/ci/scripts/swift_test.sh
index eac13c5d68ef4..b7ab37fd489c9 100755
--- a/ci/scripts/swift_test.sh
+++ b/ci/scripts/swift_test.sh
@@ -30,3 +30,8 @@ source_dir=${1}/swift/Arrow
 pushd ${source_dir}
 swift test
 popd
+
+source_dir=${1}/swift/ArrowFlight
+pushd ${source_dir}
+swift test
+popd
diff --git a/swift/ArrowFlight/.gitignore b/swift/ArrowFlight/.gitignore
new file mode 100644
index 0000000000000..d561187385c2d
--- /dev/null
+++ b/swift/ArrowFlight/.gitignore
@@ -0,0 +1,9 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/
+.netrc
+Package.resolved
\ No newline at end of file
diff --git a/swift/ArrowFlight/Package.swift b/swift/ArrowFlight/Package.swift
new file mode 100644
index 0000000000000..f3caa83486764
--- /dev/null
+++ b/swift/ArrowFlight/Package.swift
@@ -0,0 +1,53 @@
+// swift-tools-version:5.7
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 PackageDescription
+
+let package = Package(
+    name: "ArrowFlight",
+    platforms: [
+        .macOS(.v10_15)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "ArrowFlight",
+            targets: ["ArrowFlight"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/grpc/grpc-swift.git", from: "1.15.0"),
+        .package(url: "https://github.com/apple/swift-protobuf.git", from: "1.6.0"),
+        .package(path: "../Arrow")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        .target(
+            name: "ArrowFlight",
+            dependencies: [
+                .product(name: "Arrow", package: "Arrow"),
+                .product(name: "GRPC", package: "grpc-swift"),
+                .product(name: "SwiftProtobuf", package: "swift-protobuf")
+            ]),
+        .testTarget(
+            name: "ArrowFlightTests",
+            dependencies: ["ArrowFlight"]),
+    ]
+)
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift b/swift/ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
new file mode 100644
index 0000000000000..8daaa19f07b50
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
@@ -0,0 +1,1343 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the protocol buffer compiler.
+// Source: Flight.proto
+//
+import GRPC
+import NIO
+import NIOConcurrencyHelpers
+import SwiftProtobuf
+
+
+///
+/// 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.
+///
+/// Usage: instantiate `Arrow_Flight_Protocol_FlightServiceClient`, then call methods of this protocol to make API calls.
+internal protocol Arrow_Flight_Protocol_FlightServiceClientProtocol: GRPCClient {
+  var serviceName: String { get }
+  var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? { get }
+
+  func handshake(
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_HandshakeResponse) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse>
+
+  func listFlights(
+    _ request: Arrow_Flight_Protocol_Criteria,
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_FlightInfo) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo>
+
+  func getFlightInfo(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo>
+
+  func getSchema(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions?
+  ) -> UnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult>
+
+  func doGet(
+    _ request: Arrow_Flight_Protocol_Ticket,
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_FlightData) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData>
+
+  func doPut(
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_PutResult) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult>
+
+  func doExchange(
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_FlightData) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData>
+
+  func doAction(
+    _ request: Arrow_Flight_Protocol_Action,
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_Result) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result>
+
+  func listActions(
+    _ request: Arrow_Flight_Protocol_Empty,
+    callOptions: CallOptions?,
+    handler: @escaping (Arrow_Flight_Protocol_ActionType) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType>
+}
+
+extension Arrow_Flight_Protocol_FlightServiceClientProtocol {
+  internal var serviceName: String {
+    return "arrow.flight.protocol.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.
+  ///
+  /// Callers should use the `send` method on the returned object to send messages
+  /// to the server. The caller should send an `.end` after the final message has been sent.
+  ///
+  /// - Parameters:
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ClientStreamingCall` with futures for the metadata and status.
+  internal func handshake(
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_HandshakeResponse) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse> {
+    return self.makeBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.handshake.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeHandshakeInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to ListFlights.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func listFlights(
+    _ request: Arrow_Flight_Protocol_Criteria,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_FlightInfo) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo> {
+    return self.makeServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listFlights.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListFlightsInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to GetFlightInfo.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func getFlightInfo(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo> {
+    return self.makeUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getFlightInfo.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetFlightInfoInterceptors() ?? []
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to GetSchema.
+  ///   - callOptions: Call options.
+  /// - Returns: A `UnaryCall` with futures for the metadata, status and response.
+  internal func getSchema(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) -> UnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult> {
+    return self.makeUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getSchema.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetSchemaInterceptors() ?? []
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to DoGet.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func doGet(
+    _ request: Arrow_Flight_Protocol_Ticket,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_FlightData) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData> {
+    return self.makeServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doGet.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoGetInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// Callers should use the `send` method on the returned object to send messages
+  /// to the server. The caller should send an `.end` after the final message has been sent.
+  ///
+  /// - Parameters:
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ClientStreamingCall` with futures for the metadata and status.
+  internal func doPut(
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_PutResult) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult> {
+    return self.makeBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doPut.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoPutInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// Callers should use the `send` method on the returned object to send messages
+  /// to the server. The caller should send an `.end` after the final message has been sent.
+  ///
+  /// - Parameters:
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ClientStreamingCall` with futures for the metadata and status.
+  internal func doExchange(
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_FlightData) -> Void
+  ) -> BidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData> {
+    return self.makeBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doExchange.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to DoAction.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func doAction(
+    _ request: Arrow_Flight_Protocol_Action,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_Result) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result> {
+    return self.makeServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doAction.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoActionInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  ///
+  /// 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.
+  ///
+  /// - Parameters:
+  ///   - request: Request to send to ListActions.
+  ///   - callOptions: Call options.
+  ///   - handler: A closure called when each response is received from the server.
+  /// - Returns: A `ServerStreamingCall` with futures for the metadata and status.
+  internal func listActions(
+    _ request: Arrow_Flight_Protocol_Empty,
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Arrow_Flight_Protocol_ActionType) -> Void
+  ) -> ServerStreamingCall<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType> {
+    return self.makeServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listActions.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListActionsInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+@available(*, deprecated)
+extension Arrow_Flight_Protocol_FlightServiceClient: @unchecked Sendable {}
+
+@available(*, deprecated, renamed: "Arrow_Flight_Protocol_FlightServiceNIOClient")
+internal final class Arrow_Flight_Protocol_FlightServiceClient: Arrow_Flight_Protocol_FlightServiceClientProtocol {
+  private let lock = Lock()
+  private var _defaultCallOptions: CallOptions
+  private var _interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol?
+  internal let channel: GRPCChannel
+  internal var defaultCallOptions: CallOptions {
+    get { self.lock.withLock { return self._defaultCallOptions } }
+    set { self.lock.withLockVoid { self._defaultCallOptions = newValue } }
+  }
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? {
+    get { self.lock.withLock { return self._interceptors } }
+    set { self.lock.withLockVoid { self._interceptors = newValue } }
+  }
+
+  /// Creates a client for the arrow.flight.protocol.FlightService service.
+  ///
+  /// - Parameters:
+  ///   - channel: `GRPCChannel` to the service host.
+  ///   - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
+  ///   - interceptors: A factory providing interceptors for each RPC.
+  internal init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self._defaultCallOptions = defaultCallOptions
+    self._interceptors = interceptors
+  }
+}
+
+internal struct Arrow_Flight_Protocol_FlightServiceNIOClient: Arrow_Flight_Protocol_FlightServiceClientProtocol {
+  internal var channel: GRPCChannel
+  internal var defaultCallOptions: CallOptions
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol?
+
+  /// Creates a client for the arrow.flight.protocol.FlightService service.
+  ///
+  /// - Parameters:
+  ///   - channel: `GRPCChannel` to the service host.
+  ///   - defaultCallOptions: Options to use for each service call if the user doesn't provide them.
+  ///   - interceptors: A factory providing interceptors for each RPC.
+  internal init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+///
+/// 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.
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+internal protocol Arrow_Flight_Protocol_FlightServiceAsyncClientProtocol: GRPCClient {
+  static var serviceDescriptor: GRPCServiceDescriptor { get }
+  var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? { get }
+
+  func makeHandshakeCall(
+    callOptions: CallOptions?
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse>
+
+  func makeListFlightsCall(
+    _ request: Arrow_Flight_Protocol_Criteria,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo>
+
+  func makeGetFlightInfoCall(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncUnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo>
+
+  func makeGetSchemaCall(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncUnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult>
+
+  func makeDoGetCall(
+    _ request: Arrow_Flight_Protocol_Ticket,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData>
+
+  func makeDoPutCall(
+    callOptions: CallOptions?
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult>
+
+  func makeDoExchangeCall(
+    callOptions: CallOptions?
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData>
+
+  func makeDoActionCall(
+    _ request: Arrow_Flight_Protocol_Action,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result>
+
+  func makeListActionsCall(
+    _ request: Arrow_Flight_Protocol_Empty,
+    callOptions: CallOptions?
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType>
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+extension Arrow_Flight_Protocol_FlightServiceAsyncClientProtocol {
+  internal static var serviceDescriptor: GRPCServiceDescriptor {
+    return Arrow_Flight_Protocol_FlightServiceClientMetadata.serviceDescriptor
+  }
+
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? {
+    return nil
+  }
+
+  internal func makeHandshakeCall(
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse> {
+    return self.makeAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.handshake.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeHandshakeInterceptors() ?? []
+    )
+  }
+
+  internal func makeListFlightsCall(
+    _ request: Arrow_Flight_Protocol_Criteria,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo> {
+    return self.makeAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listFlights.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListFlightsInterceptors() ?? []
+    )
+  }
+
+  internal func makeGetFlightInfoCall(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncUnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo> {
+    return self.makeAsyncUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getFlightInfo.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetFlightInfoInterceptors() ?? []
+    )
+  }
+
+  internal func makeGetSchemaCall(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncUnaryCall<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult> {
+    return self.makeAsyncUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getSchema.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetSchemaInterceptors() ?? []
+    )
+  }
+
+  internal func makeDoGetCall(
+    _ request: Arrow_Flight_Protocol_Ticket,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData> {
+    return self.makeAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doGet.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoGetInterceptors() ?? []
+    )
+  }
+
+  internal func makeDoPutCall(
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult> {
+    return self.makeAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doPut.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoPutInterceptors() ?? []
+    )
+  }
+
+  internal func makeDoExchangeCall(
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncBidirectionalStreamingCall<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData> {
+    return self.makeAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doExchange.path,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? []
+    )
+  }
+
+  internal func makeDoActionCall(
+    _ request: Arrow_Flight_Protocol_Action,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result> {
+    return self.makeAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doAction.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoActionInterceptors() ?? []
+    )
+  }
+
+  internal func makeListActionsCall(
+    _ request: Arrow_Flight_Protocol_Empty,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncServerStreamingCall<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType> {
+    return self.makeAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listActions.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListActionsInterceptors() ?? []
+    )
+  }
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+extension Arrow_Flight_Protocol_FlightServiceAsyncClientProtocol {
+  internal func handshake<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_HandshakeResponse> where RequestStream: Sequence, RequestStream.Element == Arrow_Flight_Protocol_HandshakeRequest {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.handshake.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeHandshakeInterceptors() ?? []
+    )
+  }
+
+  internal func handshake<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_HandshakeResponse> where RequestStream: AsyncSequence & Sendable, RequestStream.Element == Arrow_Flight_Protocol_HandshakeRequest {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.handshake.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeHandshakeInterceptors() ?? []
+    )
+  }
+
+  internal func listFlights(
+    _ request: Arrow_Flight_Protocol_Criteria,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_FlightInfo> {
+    return self.performAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listFlights.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListFlightsInterceptors() ?? []
+    )
+  }
+
+  internal func getFlightInfo(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) async throws -> Arrow_Flight_Protocol_FlightInfo {
+    return try await self.performAsyncUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getFlightInfo.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetFlightInfoInterceptors() ?? []
+    )
+  }
+
+  internal func getSchema(
+    _ request: Arrow_Flight_Protocol_FlightDescriptor,
+    callOptions: CallOptions? = nil
+  ) async throws -> Arrow_Flight_Protocol_SchemaResult {
+    return try await self.performAsyncUnaryCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getSchema.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetSchemaInterceptors() ?? []
+    )
+  }
+
+  internal func doGet(
+    _ request: Arrow_Flight_Protocol_Ticket,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_FlightData> {
+    return self.performAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doGet.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoGetInterceptors() ?? []
+    )
+  }
+
+  internal func doPut<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_PutResult> where RequestStream: Sequence, RequestStream.Element == Arrow_Flight_Protocol_FlightData {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doPut.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoPutInterceptors() ?? []
+    )
+  }
+
+  internal func doPut<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_PutResult> where RequestStream: AsyncSequence & Sendable, RequestStream.Element == Arrow_Flight_Protocol_FlightData {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doPut.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoPutInterceptors() ?? []
+    )
+  }
+
+  internal func doExchange<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_FlightData> where RequestStream: Sequence, RequestStream.Element == Arrow_Flight_Protocol_FlightData {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doExchange.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? []
+    )
+  }
+
+  internal func doExchange<RequestStream>(
+    _ requests: RequestStream,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_FlightData> where RequestStream: AsyncSequence & Sendable, RequestStream.Element == Arrow_Flight_Protocol_FlightData {
+    return self.performAsyncBidirectionalStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doExchange.path,
+      requests: requests,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? []
+    )
+  }
+
+  internal func doAction(
+    _ request: Arrow_Flight_Protocol_Action,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_Result> {
+    return self.performAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doAction.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeDoActionInterceptors() ?? []
+    )
+  }
+
+  internal func listActions(
+    _ request: Arrow_Flight_Protocol_Empty,
+    callOptions: CallOptions? = nil
+  ) -> GRPCAsyncResponseStream<Arrow_Flight_Protocol_ActionType> {
+    return self.performAsyncServerStreamingCall(
+      path: Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listActions.path,
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeListActionsInterceptors() ?? []
+    )
+  }
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+internal struct Arrow_Flight_Protocol_FlightServiceAsyncClient: Arrow_Flight_Protocol_FlightServiceAsyncClientProtocol {
+  internal var channel: GRPCChannel
+  internal var defaultCallOptions: CallOptions
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol?
+
+  internal init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+internal protocol Arrow_Flight_Protocol_FlightServiceClientInterceptorFactoryProtocol: Sendable {
+
+  /// - Returns: Interceptors to use when invoking 'handshake'.
+  func makeHandshakeInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse>]
+
+  /// - Returns: Interceptors to use when invoking 'listFlights'.
+  func makeListFlightsInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo>]
+
+  /// - Returns: Interceptors to use when invoking 'getFlightInfo'.
+  func makeGetFlightInfoInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo>]
+
+  /// - Returns: Interceptors to use when invoking 'getSchema'.
+  func makeGetSchemaInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult>]
+
+  /// - Returns: Interceptors to use when invoking 'doGet'.
+  func makeDoGetInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData>]
+
+  /// - Returns: Interceptors to use when invoking 'doPut'.
+  func makeDoPutInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult>]
+
+  /// - Returns: Interceptors to use when invoking 'doExchange'.
+  func makeDoExchangeInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData>]
+
+  /// - Returns: Interceptors to use when invoking 'doAction'.
+  func makeDoActionInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result>]
+
+  /// - Returns: Interceptors to use when invoking 'listActions'.
+  func makeListActionsInterceptors() -> [ClientInterceptor<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType>]
+}
+
+internal enum Arrow_Flight_Protocol_FlightServiceClientMetadata {
+  internal static let serviceDescriptor = GRPCServiceDescriptor(
+    name: "FlightService",
+    fullName: "arrow.flight.protocol.FlightService",
+    methods: [
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.handshake,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listFlights,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getFlightInfo,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.getSchema,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doGet,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doPut,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doExchange,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.doAction,
+      Arrow_Flight_Protocol_FlightServiceClientMetadata.Methods.listActions,
+    ]
+  )
+
+  internal enum Methods {
+    internal static let handshake = GRPCMethodDescriptor(
+      name: "Handshake",
+      path: "/arrow.flight.protocol.FlightService/Handshake",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let listFlights = GRPCMethodDescriptor(
+      name: "ListFlights",
+      path: "/arrow.flight.protocol.FlightService/ListFlights",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let getFlightInfo = GRPCMethodDescriptor(
+      name: "GetFlightInfo",
+      path: "/arrow.flight.protocol.FlightService/GetFlightInfo",
+      type: GRPCCallType.unary
+    )
+
+    internal static let getSchema = GRPCMethodDescriptor(
+      name: "GetSchema",
+      path: "/arrow.flight.protocol.FlightService/GetSchema",
+      type: GRPCCallType.unary
+    )
+
+    internal static let doGet = GRPCMethodDescriptor(
+      name: "DoGet",
+      path: "/arrow.flight.protocol.FlightService/DoGet",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let doPut = GRPCMethodDescriptor(
+      name: "DoPut",
+      path: "/arrow.flight.protocol.FlightService/DoPut",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let doExchange = GRPCMethodDescriptor(
+      name: "DoExchange",
+      path: "/arrow.flight.protocol.FlightService/DoExchange",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let doAction = GRPCMethodDescriptor(
+      name: "DoAction",
+      path: "/arrow.flight.protocol.FlightService/DoAction",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let listActions = GRPCMethodDescriptor(
+      name: "ListActions",
+      path: "/arrow.flight.protocol.FlightService/ListActions",
+      type: GRPCCallType.serverStreaming
+    )
+  }
+}
+
+///
+/// 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.
+///
+/// To build a server, implement a class that conforms to this protocol.
+internal protocol Arrow_Flight_Protocol_FlightServiceProvider: CallHandlerProvider {
+  var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? { get }
+
+  ///
+  /// 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.
+  func handshake(context: StreamingResponseCallContext<Arrow_Flight_Protocol_HandshakeResponse>) -> EventLoopFuture<(StreamEvent<Arrow_Flight_Protocol_HandshakeRequest>) -> Void>
+
+  ///
+  /// 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.
+  func listFlights(request: Arrow_Flight_Protocol_Criteria, context: StreamingResponseCallContext<Arrow_Flight_Protocol_FlightInfo>) -> EventLoopFuture<GRPCStatus>
+
+  ///
+  /// 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.
+  func getFlightInfo(request: Arrow_Flight_Protocol_FlightDescriptor, context: StatusOnlyCallContext) -> EventLoopFuture<Arrow_Flight_Protocol_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.
+  func getSchema(request: Arrow_Flight_Protocol_FlightDescriptor, context: StatusOnlyCallContext) -> EventLoopFuture<Arrow_Flight_Protocol_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.
+  func doGet(request: Arrow_Flight_Protocol_Ticket, context: StreamingResponseCallContext<Arrow_Flight_Protocol_FlightData>) -> EventLoopFuture<GRPCStatus>
+
+  ///
+  /// 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.
+  func doPut(context: StreamingResponseCallContext<Arrow_Flight_Protocol_PutResult>) -> EventLoopFuture<(StreamEvent<Arrow_Flight_Protocol_FlightData>) -> Void>
+
+  ///
+  /// 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.
+  func doExchange(context: StreamingResponseCallContext<Arrow_Flight_Protocol_FlightData>) -> EventLoopFuture<(StreamEvent<Arrow_Flight_Protocol_FlightData>) -> Void>
+
+  ///
+  /// 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.
+  func doAction(request: Arrow_Flight_Protocol_Action, context: StreamingResponseCallContext<Arrow_Flight_Protocol_Result>) -> EventLoopFuture<GRPCStatus>
+
+  ///
+  /// 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.
+  func listActions(request: Arrow_Flight_Protocol_Empty, context: StreamingResponseCallContext<Arrow_Flight_Protocol_ActionType>) -> EventLoopFuture<GRPCStatus>
+}
+
+extension Arrow_Flight_Protocol_FlightServiceProvider {
+  internal var serviceName: Substring {
+    return Arrow_Flight_Protocol_FlightServiceServerMetadata.serviceDescriptor.fullName[...]
+  }
+
+  /// Determines, calls and returns the appropriate request handler, depending on the request's method.
+  /// Returns nil for methods not handled by this service.
+  internal func handle(
+    method name: Substring,
+    context: CallHandlerContext
+  ) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "Handshake":
+      return BidirectionalStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_HandshakeRequest>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_HandshakeResponse>(),
+        interceptors: self.interceptors?.makeHandshakeInterceptors() ?? [],
+        observerFactory: self.handshake(context:)
+      )
+
+    case "ListFlights":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Criteria>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightInfo>(),
+        interceptors: self.interceptors?.makeListFlightsInterceptors() ?? [],
+        userFunction: self.listFlights(request:context:)
+      )
+
+    case "GetFlightInfo":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightDescriptor>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightInfo>(),
+        interceptors: self.interceptors?.makeGetFlightInfoInterceptors() ?? [],
+        userFunction: self.getFlightInfo(request:context:)
+      )
+
+    case "GetSchema":
+      return UnaryServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightDescriptor>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_SchemaResult>(),
+        interceptors: self.interceptors?.makeGetSchemaInterceptors() ?? [],
+        userFunction: self.getSchema(request:context:)
+      )
+
+    case "DoGet":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Ticket>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightData>(),
+        interceptors: self.interceptors?.makeDoGetInterceptors() ?? [],
+        userFunction: self.doGet(request:context:)
+      )
+
+    case "DoPut":
+      return BidirectionalStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightData>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_PutResult>(),
+        interceptors: self.interceptors?.makeDoPutInterceptors() ?? [],
+        observerFactory: self.doPut(context:)
+      )
+
+    case "DoExchange":
+      return BidirectionalStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightData>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightData>(),
+        interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? [],
+        observerFactory: self.doExchange(context:)
+      )
+
+    case "DoAction":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Action>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_Result>(),
+        interceptors: self.interceptors?.makeDoActionInterceptors() ?? [],
+        userFunction: self.doAction(request:context:)
+      )
+
+    case "ListActions":
+      return ServerStreamingServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Empty>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_ActionType>(),
+        interceptors: self.interceptors?.makeListActionsInterceptors() ?? [],
+        userFunction: self.listActions(request:context:)
+      )
+
+    default:
+      return nil
+    }
+  }
+}
+
+///
+/// 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.
+///
+/// To implement a server, implement an object which conforms to this protocol.
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+internal protocol Arrow_Flight_Protocol_FlightServiceAsyncProvider: CallHandlerProvider, Sendable {
+  static var serviceDescriptor: GRPCServiceDescriptor { get }
+  var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? { get }
+
+  ///
+  /// 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.
+  func handshake(
+    requestStream: GRPCAsyncRequestStream<Arrow_Flight_Protocol_HandshakeRequest>,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_HandshakeResponse>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func listFlights(
+    request: Arrow_Flight_Protocol_Criteria,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func getFlightInfo(
+    request: Arrow_Flight_Protocol_FlightDescriptor,
+    context: GRPCAsyncServerCallContext
+  ) async throws -> Arrow_Flight_Protocol_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.
+  func getSchema(
+    request: Arrow_Flight_Protocol_FlightDescriptor,
+    context: GRPCAsyncServerCallContext
+  ) async throws -> Arrow_Flight_Protocol_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.
+  func doGet(
+    request: Arrow_Flight_Protocol_Ticket,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func doPut(
+    requestStream: GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func doExchange(
+    requestStream: GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func doAction(
+    request: Arrow_Flight_Protocol_Action,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+
+  ///
+  /// 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.
+  func listActions(
+    request: Arrow_Flight_Protocol_Empty,
+    responseStream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>,
+    context: GRPCAsyncServerCallContext
+  ) async throws
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+extension Arrow_Flight_Protocol_FlightServiceAsyncProvider {
+  internal static var serviceDescriptor: GRPCServiceDescriptor {
+    return Arrow_Flight_Protocol_FlightServiceServerMetadata.serviceDescriptor
+  }
+
+  internal var serviceName: Substring {
+    return Arrow_Flight_Protocol_FlightServiceServerMetadata.serviceDescriptor.fullName[...]
+  }
+
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? {
+    return nil
+  }
+
+  internal func handle(
+    method name: Substring,
+    context: CallHandlerContext
+  ) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "Handshake":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_HandshakeRequest>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_HandshakeResponse>(),
+        interceptors: self.interceptors?.makeHandshakeInterceptors() ?? [],
+        wrapping: { try await self.handshake(requestStream: $0, responseStream: $1, context: $2) }
+      )
+
+    case "ListFlights":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Criteria>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightInfo>(),
+        interceptors: self.interceptors?.makeListFlightsInterceptors() ?? [],
+        wrapping: { try await self.listFlights(request: $0, responseStream: $1, context: $2) }
+      )
+
+    case "GetFlightInfo":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightDescriptor>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightInfo>(),
+        interceptors: self.interceptors?.makeGetFlightInfoInterceptors() ?? [],
+        wrapping: { try await self.getFlightInfo(request: $0, context: $1) }
+      )
+
+    case "GetSchema":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightDescriptor>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_SchemaResult>(),
+        interceptors: self.interceptors?.makeGetSchemaInterceptors() ?? [],
+        wrapping: { try await self.getSchema(request: $0, context: $1) }
+      )
+
+    case "DoGet":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Ticket>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightData>(),
+        interceptors: self.interceptors?.makeDoGetInterceptors() ?? [],
+        wrapping: { try await self.doGet(request: $0, responseStream: $1, context: $2) }
+      )
+
+    case "DoPut":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightData>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_PutResult>(),
+        interceptors: self.interceptors?.makeDoPutInterceptors() ?? [],
+        wrapping: { try await self.doPut(requestStream: $0, responseStream: $1, context: $2) }
+      )
+
+    case "DoExchange":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_FlightData>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_FlightData>(),
+        interceptors: self.interceptors?.makeDoExchangeInterceptors() ?? [],
+        wrapping: { try await self.doExchange(requestStream: $0, responseStream: $1, context: $2) }
+      )
+
+    case "DoAction":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Action>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_Result>(),
+        interceptors: self.interceptors?.makeDoActionInterceptors() ?? [],
+        wrapping: { try await self.doAction(request: $0, responseStream: $1, context: $2) }
+      )
+
+    case "ListActions":
+      return GRPCAsyncServerHandler(
+        context: context,
+        requestDeserializer: ProtobufDeserializer<Arrow_Flight_Protocol_Empty>(),
+        responseSerializer: ProtobufSerializer<Arrow_Flight_Protocol_ActionType>(),
+        interceptors: self.interceptors?.makeListActionsInterceptors() ?? [],
+        wrapping: { try await self.listActions(request: $0, responseStream: $1, context: $2) }
+      )
+
+    default:
+      return nil
+    }
+  }
+}
+
+internal protocol Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol: Sendable {
+
+  /// - Returns: Interceptors to use when handling 'handshake'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeHandshakeInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_HandshakeRequest, Arrow_Flight_Protocol_HandshakeResponse>]
+
+  /// - Returns: Interceptors to use when handling 'listFlights'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeListFlightsInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_Criteria, Arrow_Flight_Protocol_FlightInfo>]
+
+  /// - Returns: Interceptors to use when handling 'getFlightInfo'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetFlightInfoInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_FlightInfo>]
+
+  /// - Returns: Interceptors to use when handling 'getSchema'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetSchemaInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_FlightDescriptor, Arrow_Flight_Protocol_SchemaResult>]
+
+  /// - Returns: Interceptors to use when handling 'doGet'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeDoGetInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_Ticket, Arrow_Flight_Protocol_FlightData>]
+
+  /// - Returns: Interceptors to use when handling 'doPut'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeDoPutInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_PutResult>]
+
+  /// - Returns: Interceptors to use when handling 'doExchange'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeDoExchangeInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_FlightData, Arrow_Flight_Protocol_FlightData>]
+
+  /// - Returns: Interceptors to use when handling 'doAction'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeDoActionInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_Action, Arrow_Flight_Protocol_Result>]
+
+  /// - Returns: Interceptors to use when handling 'listActions'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeListActionsInterceptors() -> [ServerInterceptor<Arrow_Flight_Protocol_Empty, Arrow_Flight_Protocol_ActionType>]
+}
+
+internal enum Arrow_Flight_Protocol_FlightServiceServerMetadata {
+  internal static let serviceDescriptor = GRPCServiceDescriptor(
+    name: "FlightService",
+    fullName: "arrow.flight.protocol.FlightService",
+    methods: [
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.handshake,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.listFlights,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.getFlightInfo,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.getSchema,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.doGet,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.doPut,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.doExchange,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.doAction,
+      Arrow_Flight_Protocol_FlightServiceServerMetadata.Methods.listActions,
+    ]
+  )
+
+  internal enum Methods {
+    internal static let handshake = GRPCMethodDescriptor(
+      name: "Handshake",
+      path: "/arrow.flight.protocol.FlightService/Handshake",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let listFlights = GRPCMethodDescriptor(
+      name: "ListFlights",
+      path: "/arrow.flight.protocol.FlightService/ListFlights",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let getFlightInfo = GRPCMethodDescriptor(
+      name: "GetFlightInfo",
+      path: "/arrow.flight.protocol.FlightService/GetFlightInfo",
+      type: GRPCCallType.unary
+    )
+
+    internal static let getSchema = GRPCMethodDescriptor(
+      name: "GetSchema",
+      path: "/arrow.flight.protocol.FlightService/GetSchema",
+      type: GRPCCallType.unary
+    )
+
+    internal static let doGet = GRPCMethodDescriptor(
+      name: "DoGet",
+      path: "/arrow.flight.protocol.FlightService/DoGet",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let doPut = GRPCMethodDescriptor(
+      name: "DoPut",
+      path: "/arrow.flight.protocol.FlightService/DoPut",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let doExchange = GRPCMethodDescriptor(
+      name: "DoExchange",
+      path: "/arrow.flight.protocol.FlightService/DoExchange",
+      type: GRPCCallType.bidirectionalStreaming
+    )
+
+    internal static let doAction = GRPCMethodDescriptor(
+      name: "DoAction",
+      path: "/arrow.flight.protocol.FlightService/DoAction",
+      type: GRPCCallType.serverStreaming
+    )
+
+    internal static let listActions = GRPCMethodDescriptor(
+      name: "ListActions",
+      path: "/arrow.flight.protocol.FlightService/ListActions",
+      type: GRPCCallType.serverStreaming
+    )
+  }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/Flight.pb.swift b/swift/ArrowFlight/Sources/ArrowFlight/Flight.pb.swift
new file mode 100644
index 0000000000000..b50d4062529c2
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/Flight.pb.swift
@@ -0,0 +1,1366 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: Flight.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// <p>
+// http://www.apache.org/licenses/LICENSE-2.0
+// <p>
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT 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 Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+///
+/// The result of a cancel operation.
+///
+/// This is used by CancelFlightInfoResult.status.
+enum Arrow_Flight_Protocol_CancelStatus: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+
+  /// 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.
+  case unspecified // = 0
+
+  /// The cancellation request is complete. Subsequent requests with
+  /// the same payload may return CANCELLED or a NOT_FOUND error.
+  case cancelled // = 1
+
+  /// The cancellation request is in progress. The client may retry
+  /// the cancellation request.
+  case cancelling // = 2
+
+  /// The query is not cancellable. The client should not retry the
+  /// cancellation request.
+  case notCancellable // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .unspecified
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .unspecified
+    case 1: self = .cancelled
+    case 2: self = .cancelling
+    case 3: self = .notCancellable
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .unspecified: return 0
+    case .cancelled: return 1
+    case .cancelling: return 2
+    case .notCancellable: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_CancelStatus: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_CancelStatus] = [
+    .unspecified,
+    .cancelled,
+    .cancelling,
+    .notCancellable,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///
+/// The request that a client provides to a server on handshake.
+struct Arrow_Flight_Protocol_HandshakeRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// A defined protocol version
+  var protocolVersion: UInt64 = 0
+
+  ///
+  /// Arbitrary auth/handshake info.
+  var payload: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Arrow_Flight_Protocol_HandshakeResponse {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// A defined protocol version
+  var protocolVersion: UInt64 = 0
+
+  ///
+  /// Arbitrary auth/handshake info.
+  var payload: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// A message for doing simple auth.
+struct Arrow_Flight_Protocol_BasicAuth {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var username: String = String()
+
+  var password: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+struct Arrow_Flight_Protocol_Empty {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Describes an available action, including both the name used for execution
+/// along with a short description of the purpose of the action.
+struct Arrow_Flight_Protocol_ActionType {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var type: String = String()
+
+  var description_p: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// A service specific expression that can be used to return a limited set
+/// of available Arrow Flight streams.
+struct Arrow_Flight_Protocol_Criteria {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var expression: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// An opaque action specific for the service.
+struct Arrow_Flight_Protocol_Action {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var type: String = String()
+
+  var body: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// The request of the CancelFlightInfo action.
+///
+/// The request should be stored in Action.body.
+struct Arrow_Flight_Protocol_CancelFlightInfoRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var info: Arrow_Flight_Protocol_FlightInfo {
+    get {return _info ?? Arrow_Flight_Protocol_FlightInfo()}
+    set {_info = newValue}
+  }
+  /// Returns true if `info` has been explicitly set.
+  var hasInfo: Bool {return self._info != nil}
+  /// Clears the value of `info`. Subsequent reads from it will return its default value.
+  mutating func clearInfo() {self._info = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _info: Arrow_Flight_Protocol_FlightInfo? = nil
+}
+
+///
+/// The request of the RenewFlightEndpoint action.
+///
+/// The request should be stored in Action.body.
+struct Arrow_Flight_Protocol_RenewFlightEndpointRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var endpoint: Arrow_Flight_Protocol_FlightEndpoint {
+    get {return _endpoint ?? Arrow_Flight_Protocol_FlightEndpoint()}
+    set {_endpoint = newValue}
+  }
+  /// Returns true if `endpoint` has been explicitly set.
+  var hasEndpoint: Bool {return self._endpoint != nil}
+  /// Clears the value of `endpoint`. Subsequent reads from it will return its default value.
+  mutating func clearEndpoint() {self._endpoint = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _endpoint: Arrow_Flight_Protocol_FlightEndpoint? = nil
+}
+
+///
+/// An opaque result returned after executing an action.
+struct Arrow_Flight_Protocol_Result {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var body: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// The result of the CancelFlightInfo action.
+///
+/// The result should be stored in Result.body.
+struct Arrow_Flight_Protocol_CancelFlightInfoResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var status: Arrow_Flight_Protocol_CancelStatus = .unspecified
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Wrap the result of a getSchema call
+struct Arrow_Flight_Protocol_SchemaResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// 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
+  var schema: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_FlightDescriptor {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var type: Arrow_Flight_Protocol_FlightDescriptor.DescriptorType = .unknown
+
+  ///
+  /// Opaque value used to express a command. Should only be defined when
+  /// type = CMD.
+  var cmd: Data = Data()
+
+  ///
+  /// List of strings identifying a particular dataset. Should only be defined
+  /// when type = PATH.
+  var path: [String] = []
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  ///
+  /// Describes what type of descriptor is defined.
+  enum DescriptorType: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+
+    /// Protobuf pattern, not used.
+    case 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.
+    case path // = 1
+
+    ///
+    /// An opaque command to generate a dataset.
+    case cmd // = 2
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unknown
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unknown
+      case 1: self = .path
+      case 2: self = .cmd
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unknown: return 0
+      case .path: return 1
+      case .cmd: return 2
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_FlightDescriptor.DescriptorType: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_FlightDescriptor.DescriptorType] = [
+    .unknown,
+    .path,
+    .cmd,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///
+/// The access coordinates for retrieval of a dataset. With a FlightInfo, a
+/// consumer is able to determine how to retrieve a dataset.
+struct Arrow_Flight_Protocol_FlightInfo {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// 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
+  var schema: Data = Data()
+
+  ///
+  /// The descriptor associated with this info.
+  var flightDescriptor: Arrow_Flight_Protocol_FlightDescriptor {
+    get {return _flightDescriptor ?? Arrow_Flight_Protocol_FlightDescriptor()}
+    set {_flightDescriptor = newValue}
+  }
+  /// Returns true if `flightDescriptor` has been explicitly set.
+  var hasFlightDescriptor: Bool {return self._flightDescriptor != nil}
+  /// Clears the value of `flightDescriptor`. Subsequent reads from it will return its default value.
+  mutating func clearFlightDescriptor() {self._flightDescriptor = nil}
+
+  ///
+  /// 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.
+  var endpoint: [Arrow_Flight_Protocol_FlightEndpoint] = []
+
+  /// Set these to -1 if unknown.
+  var totalRecords: Int64 = 0
+
+  var totalBytes: Int64 = 0
+
+  ///
+  /// FlightEndpoints are in the same order as the data.
+  var ordered: Bool = false
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _flightDescriptor: Arrow_Flight_Protocol_FlightDescriptor? = nil
+}
+
+///
+/// A particular stream or split associated with a flight.
+struct Arrow_Flight_Protocol_FlightEndpoint {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// Token used to retrieve this stream.
+  var ticket: Arrow_Flight_Protocol_Ticket {
+    get {return _ticket ?? Arrow_Flight_Protocol_Ticket()}
+    set {_ticket = newValue}
+  }
+  /// Returns true if `ticket` has been explicitly set.
+  var hasTicket: Bool {return self._ticket != nil}
+  /// Clears the value of `ticket`. Subsequent reads from it will return its default value.
+  mutating func clearTicket() {self._ticket = nil}
+
+  ///
+  /// 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.
+  var location: [Arrow_Flight_Protocol_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.
+  var expirationTime: SwiftProtobuf.Google_Protobuf_Timestamp {
+    get {return _expirationTime ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
+    set {_expirationTime = newValue}
+  }
+  /// Returns true if `expirationTime` has been explicitly set.
+  var hasExpirationTime: Bool {return self._expirationTime != nil}
+  /// Clears the value of `expirationTime`. Subsequent reads from it will return its default value.
+  mutating func clearExpirationTime() {self._expirationTime = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _ticket: Arrow_Flight_Protocol_Ticket? = nil
+  fileprivate var _expirationTime: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
+}
+
+///
+/// A location where a Flight service will accept retrieval of a particular
+/// stream given a ticket.
+struct Arrow_Flight_Protocol_Location {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var uri: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Ticket {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var ticket: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// A batch of Arrow data as part of a stream of batches.
+struct Arrow_Flight_Protocol_FlightData {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// The descriptor of the data. This is only relevant when a client is
+  /// starting a new DoPut stream.
+  var flightDescriptor: Arrow_Flight_Protocol_FlightDescriptor {
+    get {return _flightDescriptor ?? Arrow_Flight_Protocol_FlightDescriptor()}
+    set {_flightDescriptor = newValue}
+  }
+  /// Returns true if `flightDescriptor` has been explicitly set.
+  var hasFlightDescriptor: Bool {return self._flightDescriptor != nil}
+  /// Clears the value of `flightDescriptor`. Subsequent reads from it will return its default value.
+  mutating func clearFlightDescriptor() {self._flightDescriptor = nil}
+
+  ///
+  /// Header for message data as described in Message.fbs::Message.
+  var dataHeader: Data = Data()
+
+  ///
+  /// Application-defined metadata.
+  var appMetadata: Data = Data()
+
+  ///
+  /// 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).
+  var dataBody: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _flightDescriptor: Arrow_Flight_Protocol_FlightDescriptor? = nil
+}
+
+///*
+/// The response message associated with the submission of a DoPut.
+struct Arrow_Flight_Protocol_PutResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var appMetadata: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Arrow_Flight_Protocol_CancelStatus: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_HandshakeRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_HandshakeResponse: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_BasicAuth: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Empty: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_ActionType: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Criteria: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Action: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_CancelFlightInfoRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_RenewFlightEndpointRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Result: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_CancelFlightInfoResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_SchemaResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_FlightDescriptor: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_FlightDescriptor.DescriptorType: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_FlightInfo: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_FlightEndpoint: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Location: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Ticket: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_FlightData: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_PutResult: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "arrow.flight.protocol"
+
+extension Arrow_Flight_Protocol_CancelStatus: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "CANCEL_STATUS_UNSPECIFIED"),
+    1: .same(proto: "CANCEL_STATUS_CANCELLED"),
+    2: .same(proto: "CANCEL_STATUS_CANCELLING"),
+    3: .same(proto: "CANCEL_STATUS_NOT_CANCELLABLE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_HandshakeRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".HandshakeRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "protocol_version"),
+    2: .same(proto: "payload"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.protocolVersion) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.payload) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.protocolVersion != 0 {
+      try visitor.visitSingularUInt64Field(value: self.protocolVersion, fieldNumber: 1)
+    }
+    if !self.payload.isEmpty {
+      try visitor.visitSingularBytesField(value: self.payload, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_HandshakeRequest, rhs: Arrow_Flight_Protocol_HandshakeRequest) -> Bool {
+    if lhs.protocolVersion != rhs.protocolVersion {return false}
+    if lhs.payload != rhs.payload {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_HandshakeResponse: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".HandshakeResponse"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "protocol_version"),
+    2: .same(proto: "payload"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.protocolVersion) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.payload) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.protocolVersion != 0 {
+      try visitor.visitSingularUInt64Field(value: self.protocolVersion, fieldNumber: 1)
+    }
+    if !self.payload.isEmpty {
+      try visitor.visitSingularBytesField(value: self.payload, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_HandshakeResponse, rhs: Arrow_Flight_Protocol_HandshakeResponse) -> Bool {
+    if lhs.protocolVersion != rhs.protocolVersion {return false}
+    if lhs.payload != rhs.payload {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_BasicAuth: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".BasicAuth"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    2: .same(proto: "username"),
+    3: .same(proto: "password"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 2: try { try decoder.decodeSingularStringField(value: &self.username) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.password) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.username.isEmpty {
+      try visitor.visitSingularStringField(value: self.username, fieldNumber: 2)
+    }
+    if !self.password.isEmpty {
+      try visitor.visitSingularStringField(value: self.password, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_BasicAuth, rhs: Arrow_Flight_Protocol_BasicAuth) -> Bool {
+    if lhs.username != rhs.username {return false}
+    if lhs.password != rhs.password {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Empty: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Empty"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Empty, rhs: Arrow_Flight_Protocol_Empty) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_ActionType: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionType"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "type"),
+    2: .same(proto: "description"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.type) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.description_p) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.type.isEmpty {
+      try visitor.visitSingularStringField(value: self.type, fieldNumber: 1)
+    }
+    if !self.description_p.isEmpty {
+      try visitor.visitSingularStringField(value: self.description_p, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_ActionType, rhs: Arrow_Flight_Protocol_ActionType) -> Bool {
+    if lhs.type != rhs.type {return false}
+    if lhs.description_p != rhs.description_p {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Criteria: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Criteria"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "expression"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.expression) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.expression.isEmpty {
+      try visitor.visitSingularBytesField(value: self.expression, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Criteria, rhs: Arrow_Flight_Protocol_Criteria) -> Bool {
+    if lhs.expression != rhs.expression {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Action: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Action"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "type"),
+    2: .same(proto: "body"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.type) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.body) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.type.isEmpty {
+      try visitor.visitSingularStringField(value: self.type, fieldNumber: 1)
+    }
+    if !self.body.isEmpty {
+      try visitor.visitSingularBytesField(value: self.body, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Action, rhs: Arrow_Flight_Protocol_Action) -> Bool {
+    if lhs.type != rhs.type {return false}
+    if lhs.body != rhs.body {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_CancelFlightInfoRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CancelFlightInfoRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "info"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._info) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._info {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_CancelFlightInfoRequest, rhs: Arrow_Flight_Protocol_CancelFlightInfoRequest) -> Bool {
+    if lhs._info != rhs._info {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_RenewFlightEndpointRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".RenewFlightEndpointRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "endpoint"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._endpoint) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._endpoint {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_RenewFlightEndpointRequest, rhs: Arrow_Flight_Protocol_RenewFlightEndpointRequest) -> Bool {
+    if lhs._endpoint != rhs._endpoint {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Result: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Result"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "body"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.body) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.body.isEmpty {
+      try visitor.visitSingularBytesField(value: self.body, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Result, rhs: Arrow_Flight_Protocol_Result) -> Bool {
+    if lhs.body != rhs.body {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_CancelFlightInfoResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CancelFlightInfoResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "status"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self.status) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.status != .unspecified {
+      try visitor.visitSingularEnumField(value: self.status, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_CancelFlightInfoResult, rhs: Arrow_Flight_Protocol_CancelFlightInfoResult) -> Bool {
+    if lhs.status != rhs.status {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_SchemaResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SchemaResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "schema"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.schema) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.schema.isEmpty {
+      try visitor.visitSingularBytesField(value: self.schema, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_SchemaResult, rhs: Arrow_Flight_Protocol_SchemaResult) -> Bool {
+    if lhs.schema != rhs.schema {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_FlightDescriptor: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FlightDescriptor"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "type"),
+    2: .same(proto: "cmd"),
+    3: .same(proto: "path"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self.type) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.cmd) }()
+      case 3: try { try decoder.decodeRepeatedStringField(value: &self.path) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.type != .unknown {
+      try visitor.visitSingularEnumField(value: self.type, fieldNumber: 1)
+    }
+    if !self.cmd.isEmpty {
+      try visitor.visitSingularBytesField(value: self.cmd, fieldNumber: 2)
+    }
+    if !self.path.isEmpty {
+      try visitor.visitRepeatedStringField(value: self.path, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_FlightDescriptor, rhs: Arrow_Flight_Protocol_FlightDescriptor) -> Bool {
+    if lhs.type != rhs.type {return false}
+    if lhs.cmd != rhs.cmd {return false}
+    if lhs.path != rhs.path {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_FlightDescriptor.DescriptorType: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "UNKNOWN"),
+    1: .same(proto: "PATH"),
+    2: .same(proto: "CMD"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_FlightInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FlightInfo"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "schema"),
+    2: .standard(proto: "flight_descriptor"),
+    3: .same(proto: "endpoint"),
+    4: .standard(proto: "total_records"),
+    5: .standard(proto: "total_bytes"),
+    6: .same(proto: "ordered"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.schema) }()
+      case 2: try { try decoder.decodeSingularMessageField(value: &self._flightDescriptor) }()
+      case 3: try { try decoder.decodeRepeatedMessageField(value: &self.endpoint) }()
+      case 4: try { try decoder.decodeSingularInt64Field(value: &self.totalRecords) }()
+      case 5: try { try decoder.decodeSingularInt64Field(value: &self.totalBytes) }()
+      case 6: try { try decoder.decodeSingularBoolField(value: &self.ordered) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    if !self.schema.isEmpty {
+      try visitor.visitSingularBytesField(value: self.schema, fieldNumber: 1)
+    }
+    try { if let v = self._flightDescriptor {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
+    } }()
+    if !self.endpoint.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.endpoint, fieldNumber: 3)
+    }
+    if self.totalRecords != 0 {
+      try visitor.visitSingularInt64Field(value: self.totalRecords, fieldNumber: 4)
+    }
+    if self.totalBytes != 0 {
+      try visitor.visitSingularInt64Field(value: self.totalBytes, fieldNumber: 5)
+    }
+    if self.ordered != false {
+      try visitor.visitSingularBoolField(value: self.ordered, fieldNumber: 6)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_FlightInfo, rhs: Arrow_Flight_Protocol_FlightInfo) -> Bool {
+    if lhs.schema != rhs.schema {return false}
+    if lhs._flightDescriptor != rhs._flightDescriptor {return false}
+    if lhs.endpoint != rhs.endpoint {return false}
+    if lhs.totalRecords != rhs.totalRecords {return false}
+    if lhs.totalBytes != rhs.totalBytes {return false}
+    if lhs.ordered != rhs.ordered {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_FlightEndpoint: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FlightEndpoint"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "ticket"),
+    2: .same(proto: "location"),
+    3: .standard(proto: "expiration_time"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._ticket) }()
+      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.location) }()
+      case 3: try { try decoder.decodeSingularMessageField(value: &self._expirationTime) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._ticket {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    if !self.location.isEmpty {
+      try visitor.visitRepeatedMessageField(value: self.location, fieldNumber: 2)
+    }
+    try { if let v = self._expirationTime {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_FlightEndpoint, rhs: Arrow_Flight_Protocol_FlightEndpoint) -> Bool {
+    if lhs._ticket != rhs._ticket {return false}
+    if lhs.location != rhs.location {return false}
+    if lhs._expirationTime != rhs._expirationTime {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Location: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Location"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "uri"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.uri) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.uri.isEmpty {
+      try visitor.visitSingularStringField(value: self.uri, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Location, rhs: Arrow_Flight_Protocol_Location) -> Bool {
+    if lhs.uri != rhs.uri {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Ticket: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".Ticket"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "ticket"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.ticket) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.ticket.isEmpty {
+      try visitor.visitSingularBytesField(value: self.ticket, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Ticket, rhs: Arrow_Flight_Protocol_Ticket) -> Bool {
+    if lhs.ticket != rhs.ticket {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_FlightData: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".FlightData"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "flight_descriptor"),
+    2: .standard(proto: "data_header"),
+    3: .standard(proto: "app_metadata"),
+    1000: .standard(proto: "data_body"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._flightDescriptor) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.dataHeader) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.appMetadata) }()
+      case 1000: try { try decoder.decodeSingularBytesField(value: &self.dataBody) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._flightDescriptor {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    if !self.dataHeader.isEmpty {
+      try visitor.visitSingularBytesField(value: self.dataHeader, fieldNumber: 2)
+    }
+    if !self.appMetadata.isEmpty {
+      try visitor.visitSingularBytesField(value: self.appMetadata, fieldNumber: 3)
+    }
+    if !self.dataBody.isEmpty {
+      try visitor.visitSingularBytesField(value: self.dataBody, fieldNumber: 1000)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_FlightData, rhs: Arrow_Flight_Protocol_FlightData) -> Bool {
+    if lhs._flightDescriptor != rhs._flightDescriptor {return false}
+    if lhs.dataHeader != rhs.dataHeader {return false}
+    if lhs.appMetadata != rhs.appMetadata {return false}
+    if lhs.dataBody != rhs.dataBody {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_PutResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".PutResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "app_metadata"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.appMetadata) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.appMetadata.isEmpty {
+      try visitor.visitSingularBytesField(value: self.appMetadata, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_PutResult, rhs: Arrow_Flight_Protocol_PutResult) -> Bool {
+    if lhs.appMetadata != rhs.appMetadata {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
new file mode 100644
index 0000000000000..04e917d474cff
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+
+public class FlightAction {
+    public let type: String
+    public let body: Data
+    init(_ action: Arrow_Flight_Protocol_Action) {
+        self.type = action.type
+        self.body = action.body
+    }
+    
+    public init(_ type: String, body: Data = Data()) {
+        self.type = type;
+        self.body = body;
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_Action {
+        var flight_action = Arrow_Flight_Protocol_Action()
+        flight_action.type = self.type
+        flight_action.body = self.body
+        return flight_action
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
new file mode 100644
index 0000000000000..b3b06793feade
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+public class FlightActionType {
+    public let type: String
+    public let description: String
+    init(_ actionType: Arrow_Flight_Protocol_ActionType) {
+        self.type = actionType.type
+        self.description = actionType.description_p
+        
+    }
+    public init(_ type: String, description: String) {
+        self.type = type
+        self.description = description
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_ActionType {
+        var actionType = Arrow_Flight_Protocol_ActionType()
+        actionType.type  = self.type
+        actionType.description_p = self.description
+        return actionType
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
new file mode 100644
index 0000000000000..f7b8564af31d7
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
@@ -0,0 +1,144 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 struct Foundation.Data
+import struct Foundation.URL
+import GRPC
+import NIOCore
+import NIOPosix
+import Arrow
+
+public class FlightClient {
+    let client: Arrow_Flight_Protocol_FlightServiceAsyncClient
+    public init(channel: GRPCChannel) {
+        client = Arrow_Flight_Protocol_FlightServiceAsyncClient(channel: channel)
+    }
+    
+    public func listActions(_ closure: (FlightActionType) -> Void) async throws {
+        let listActions = client.makeListActionsCall(Arrow_Flight_Protocol_Empty())
+        for try await data in listActions.responseStream {
+            closure(FlightActionType(data))
+        }
+    }
+    
+    public func listFlights(_ criteria :FlightCriteria, closure: (FlightInfo) throws -> Void) async throws {
+        let listFlights = client.makeListFlightsCall(criteria.toProtocol())
+        for try await data in listFlights.responseStream {
+            try closure(FlightInfo(data));
+        }
+    }
+    
+    
+    public func doAction(_ action: FlightAction, closure: (FlightResult) throws -> Void) async throws {
+        let actionResponse = client.makeDoActionCall(action.toProtocol())
+        for try await data in actionResponse.responseStream {
+            try closure(FlightResult(data));
+        }
+    }
+    
+    public func getSchema(_ descriptor: FlightDescriptor) async throws -> FlightSchemaResult {
+        let schemaResultResponse = client.makeGetSchemaCall(descriptor.toProtocol())
+        return FlightSchemaResult(try await schemaResultResponse.response)
+    }
+    
+    public func doGet(_ ticket: FlightTicket, readerResultClosure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
+        let getResult = client.makeDoGetCall(ticket.toProtocol())
+        let reader = ArrowReader()
+        for try await data in getResult.responseStream {
+            switch reader.fromStream(data.dataBody) {
+            case .success(let rb):
+                try readerResultClosure(rb)
+            case .failure(let error):
+                throw error
+            }
+        }
+    }
+
+    public func doGet(_ ticket: FlightTicket, flightDataClosure: (FlightData) throws -> Void) async throws {
+        let getResult = client.makeDoGetCall(ticket.toProtocol())
+        for try await data in getResult.responseStream {
+            try flightDataClosure(FlightData(data))
+        }
+    }
+
+    public func doPut(_ recordBatchs: [RecordBatch], closure: (FlightPutResult) throws -> Void) async throws {
+        if recordBatchs.isEmpty {
+            throw ArrowFlightError.EmptyCollection
+        }
+        
+        let putCall = client.makeDoPutCall()
+        let writer = ArrowWriter()
+        let writerInfo = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
+        switch writer.toStream(writerInfo) {
+        case .success(let data):
+            try await putCall.requestStream.send(FlightData(data).toProtocol())
+            putCall.requestStream.finish()
+            for try await response in putCall.responseStream {
+                try closure(FlightPutResult(response))
+            }
+        case .failure(let error):
+            throw error
+        }
+    }
+
+    public func doPut(flightData: FlightData, closure: (FlightPutResult) throws -> Void) async throws {
+        let putCall = client.makeDoPutCall()
+        try await putCall.requestStream.send(flightData.toProtocol())
+        putCall.requestStream.finish()
+        for try await response in putCall.responseStream {
+            try closure(FlightPutResult(response))
+        }
+    }
+
+    public func doExchange(_ recordBatchs: [RecordBatch], closure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
+        if recordBatchs.isEmpty {
+            throw ArrowFlightError.EmptyCollection
+        }
+        
+        let exchangeCall = client.makeDoExchangeCall()
+        let writer = ArrowWriter()
+        let info = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
+        switch writer.toStream(info) {
+        case .success(let data):
+            let request = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataBody = data
+            }
+            try await exchangeCall.requestStream.send(request)
+            exchangeCall.requestStream.finish()
+            let reader = ArrowReader()
+            for try await response in exchangeCall.responseStream {
+                switch reader.fromStream(response.dataBody) {
+                case .success(let rbResult):
+                    try closure(rbResult)
+                case .failure(let error):
+                    throw error
+                }
+            }
+        case .failure(let error):
+            throw error
+        }
+    }
+
+    public func doExchange(fligthData: FlightData, closure: (FlightData) throws -> Void) async throws {
+        let exchangeCall = client.makeDoExchangeCall()
+        try await exchangeCall.requestStream.send(fligthData.toProtocol())
+        exchangeCall.requestStream.finish()
+        for try await response in exchangeCall.responseStream {
+            try closure(FlightData(response))
+        }
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
new file mode 100644
index 0000000000000..a887a22ad1737
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
@@ -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.
+
+import Foundation
+
+public class FlightCriteria {
+    let criteria: Arrow_Flight_Protocol_Criteria
+    
+    public var expression: Data { criteria.expression }
+    public init(_ expression: Data = Data()) {
+        criteria = Arrow_Flight_Protocol_Criteria.with {
+            $0.expression = expression
+        }
+    }
+    
+    init(_ criteria: Arrow_Flight_Protocol_Criteria) {
+        self.criteria = criteria
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_Criteria {
+        return criteria
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
new file mode 100644
index 0000000000000..004fb785f0c11
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
@@ -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.
+
+import Foundation
+
+public class FlightData {
+    let flight_data: Arrow_Flight_Protocol_FlightData
+    public var flightDescriptor: FlightDescriptor? {
+        get { return flight_data.hasFlightDescriptor ? FlightDescriptor(flight_data.flightDescriptor) : nil }
+    }
+    
+    public var dataBody: Data { flight_data.dataBody }
+    
+    init(_ flight_data: Arrow_Flight_Protocol_FlightData) {
+        self.flight_data = flight_data
+    }
+    
+    public init(_ dataBody: Data, flightDescriptor: FlightDescriptor? = nil) {
+        if flightDescriptor != nil {
+            self.flight_data = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataBody = dataBody
+                $0.flightDescriptor = flightDescriptor!.toProtocol()
+            }
+        } else {
+            self.flight_data = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataBody = dataBody
+            }
+        }
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_FlightData { self.flight_data }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
new file mode 100644
index 0000000000000..68bc91a3deda1
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
@@ -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.
+
+import Foundation
+
+public class FlightDescriptor {
+    public enum type {
+        case unknown
+        case path
+        case cmd
+    }
+    
+    public let type: FlightDescriptor.type
+    public let cmd: Data
+    public let paths: [String]
+    
+    init(_ descriptor: Arrow_Flight_Protocol_FlightDescriptor) {
+        self.type = descriptor.type == .cmd ? .cmd : .path
+        self.cmd = descriptor.cmd
+        self.paths = descriptor.path
+    }
+    
+    public init(cmd: Data) {
+        self.type = .cmd
+        self.cmd = cmd
+        self.paths = [String]()
+    }
+
+    public init(paths: [String]) {
+        self.type = .path
+        self.cmd = Data()
+        self.paths = paths
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_FlightDescriptor {
+        var descriptor = Arrow_Flight_Protocol_FlightDescriptor()
+        descriptor.type = self.type == .cmd ? .cmd : .path
+        descriptor.cmd = self.cmd
+        descriptor.path = self.paths
+        return descriptor
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
new file mode 100644
index 0000000000000..7c40a2a157ae8
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+public class FlightEndpoint {
+    let ticket: FlightTicket;
+    let locations: [FlightLocation]
+    init(_ endpoint: Arrow_Flight_Protocol_FlightEndpoint) {
+        self.ticket = FlightTicket(endpoint.ticket.ticket)
+        self.locations = endpoint.location.map {return FlightLocation($0)}
+    }
+    
+    public init(_ ticket: FlightTicket, locations: [FlightLocation]) {
+        self.ticket = ticket
+        self.locations = locations;
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_FlightEndpoint {
+        var endpoint = Arrow_Flight_Protocol_FlightEndpoint()
+        endpoint.ticket = self.ticket.toProtocol()
+        endpoint.location = self.locations.map { $0.toProtocol() }
+        return endpoint
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
new file mode 100644
index 0000000000000..b370c00db3d42
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+import Arrow
+
+public class FlightInfo {
+    let flight_info: Arrow_Flight_Protocol_FlightInfo
+    public var flightDescriptor: FlightDescriptor? {
+        get { return flight_info.hasFlightDescriptor ? FlightDescriptor(flight_info.flightDescriptor) : nil }
+    }
+    
+    public var endpoints: [FlightEndpoint] {
+        return self.flight_info.endpoint.map { FlightEndpoint($0) }
+    }
+    public var schema: Data { flight_info.schema }
+    
+    var endpoint: [Arrow_Flight_Protocol_FlightEndpoint] = []
+    init(_ flight_info: Arrow_Flight_Protocol_FlightInfo) {
+        self.flight_info = flight_info
+    }
+    
+    public init(_ schema: Data, endpoints: [FlightEndpoint] = [FlightEndpoint](), descriptor: FlightDescriptor? = nil) {
+        if let localDescriptor = descriptor {
+            self.flight_info = Arrow_Flight_Protocol_FlightInfo.with {
+                $0.schema = schema
+                $0.flightDescriptor = localDescriptor.toProtocol()
+                $0.endpoint = endpoints.map { $0.toProtocol() }
+            }
+        } else {
+            self.flight_info = Arrow_Flight_Protocol_FlightInfo.with {
+                $0.schema = schema
+                $0.endpoint = endpoints.map { $0.toProtocol() }
+            }
+        }
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_FlightInfo {
+        return self.flight_info
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
new file mode 100644
index 0000000000000..b87671c903d44
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+
+public class FlightLocation {
+    public let uri: String
+    
+    init(_ location: Arrow_Flight_Protocol_Location) {
+        self.uri = location.uri
+    }
+    
+    public init(_ uri: String) {
+        self.uri = uri;
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_Location {
+        var location = Arrow_Flight_Protocol_Location()
+        location.uri = uri
+        return location
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
new file mode 100644
index 0000000000000..bf73c716e39c0
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
@@ -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.
+
+import Foundation
+
+public class FlightPutResult {
+    public let appMetadata: Data
+    public init(_ appMetadata: Data = Data()) {
+        self.appMetadata = appMetadata
+    }
+    
+    init(_ putResult: Arrow_Flight_Protocol_PutResult) {
+        self.appMetadata = putResult.appMetadata
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_PutResult {
+        var putResult = Arrow_Flight_Protocol_PutResult()
+        putResult.appMetadata = self.appMetadata
+        return putResult
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
new file mode 100644
index 0000000000000..ba55bede7c70c
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
@@ -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.
+
+import Foundation
+
+public class FlightResult {
+    public let body: Data
+    init(_ result: Arrow_Flight_Protocol_Result) {
+        self.body = result.body
+    }
+    
+    public init(_ body: Data) {
+        self.body = body
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_Result {
+        var result = Arrow_Flight_Protocol_Result()
+        result.body = self.body
+        return result
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
new file mode 100644
index 0000000000000..8d5323b731ea8
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
@@ -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.
+
+import Foundation
+
+public class FlightSchemaResult {
+    let schemaResult: Arrow_Flight_Protocol_SchemaResult
+    
+    public var schema: Data { schemaResult.schema }
+    public init(_ schema: Data) {
+        self.schemaResult = Arrow_Flight_Protocol_SchemaResult.with {
+            $0.schema = schema
+        }
+    }
+    
+    init(_ schemaResult: Arrow_Flight_Protocol_SchemaResult) {
+        self.schemaResult = schemaResult
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_SchemaResult {
+        return schemaResult
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
new file mode 100644
index 0000000000000..f67f612b0bcb4
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
@@ -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.
+
+import Foundation
+import GRPC
+import NIO
+import NIOConcurrencyHelpers
+import SwiftProtobuf
+import Arrow
+
+public enum ArrowFlightError: Error {
+    case Unknown(String?)
+    case NotImplemented(String? = nil)
+    case EmptyCollection
+    case IOError(String? = nil)
+}
+
+public func schemaToArrowStream(_ schema: ArrowSchema) throws -> Data {
+    let arrowWriter = ArrowWriter()
+    switch arrowWriter.toStream(ArrowWriter.Info(.schema, schema: schema)) {
+    case .success(let result):
+        return result
+    case .failure(let error):
+        throw error
+    }
+}
+
+public func streamToArrowSchema(_ schema: Data) throws -> ArrowSchema {
+    let schemaResult = ArrowReader().fromStream(schema)
+    switch schemaResult {
+    case .success(let result):
+        if let retSchema = result.schema {
+            return retSchema
+        }
+        
+        throw ArrowFlightError.IOError("Schema not found")
+    case .failure(let error):
+        throw error
+    }
+}
+
+public protocol ArrowFlightServer : Sendable {
+    func listFlights(_ criteria: FlightCriteria, writer: FlightInfoStreamWriter) async throws
+    func getFlightInfo(_ request: FlightDescriptor) async throws -> FlightInfo
+    func getSchema(_ request: FlightDescriptor) async throws -> ArrowFlight.FlightSchemaResult
+    func listActions(_ writer: ActionTypeStreamWriter) async throws
+    func doAction(_ action: FlightAction, writer: ResultStreamWriter) async throws
+    func doGet(_ ticket: FlightTicket, writer: RecordBatchStreamWriter) async throws;
+    func doPut(_ reader: RecordBatchStreamReader, writer: PutResultDataStreamWriter) async throws
+    func doExchange(_ reader: RecordBatchStreamReader, writer: RecordBatchStreamWriter) async throws
+}
+
+public func MakeFlightServer(_ handler: ArrowFlightServer) -> CallHandlerProvider {
+  return InternalFlightServer(handler)
+}
+
+internal final class InternalFlightServer : Arrow_Flight_Protocol_FlightServiceAsyncProvider {
+    let arrowFlightServer: ArrowFlightServer?
+    
+    init(_ arrowFlightServer: ArrowFlightServer?) {
+        self.arrowFlightServer = arrowFlightServer
+    }
+    
+    func handshake(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_HandshakeRequest>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_HandshakeResponse>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func listFlights(request: Arrow_Flight_Protocol_Criteria, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            let writer = FlightInfoStreamWriter(responseStream)
+            try await server.listFlights(FlightCriteria(request), writer: writer)
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func getFlightInfo(request: Arrow_Flight_Protocol_FlightDescriptor, context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_FlightInfo {
+        if let server = arrowFlightServer {
+            return try await server.getFlightInfo(FlightDescriptor(request)).toProtocol()
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func getSchema(request: Arrow_Flight_Protocol_FlightDescriptor, context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_SchemaResult {
+        if let server = arrowFlightServer {
+            return try await server.getSchema(FlightDescriptor(request)).toProtocol()
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func doGet(request: Arrow_Flight_Protocol_Ticket, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            let writer = RecordBatchStreamWriter(responseStream)
+            let ticket = FlightTicket(request)
+            try await server.doGet(ticket, writer: writer)
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()        
+    }
+    
+    func doPut(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            let reader = RecordBatchStreamReader(requestStream)
+            let writer = PutResultDataStreamWriter(responseStream)
+            try await server.doPut(reader, writer: writer)
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func doExchange(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            let reader = RecordBatchStreamReader(requestStream)
+            let writer = RecordBatchStreamWriter(responseStream)
+            try await server.doExchange(reader, writer: writer)
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func doAction(request: Arrow_Flight_Protocol_Action, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            try await server.doAction(FlightAction(request), writer: ResultStreamWriter(responseStream))
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+    func listActions(request: Arrow_Flight_Protocol_Empty, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+        if let server = arrowFlightServer {
+            let writer = ActionTypeStreamWriter(responseStream)
+            try await server.listActions(writer)
+            return
+        }
+        
+        throw ArrowFlightError.NotImplemented()
+    }
+    
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? { get { return nil } }
+
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
new file mode 100644
index 0000000000000..f77fc3545af5c
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
@@ -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.
+
+import Foundation
+
+public class FlightTicket {
+    public let data: Data
+    init(_ ticket: Arrow_Flight_Protocol_Ticket) {
+        self.data = ticket.ticket
+    }
+    
+    public init(_ data: Data) {
+        self.data = data
+    }
+    
+    func toProtocol() -> Arrow_Flight_Protocol_Ticket {
+        var ticket = Arrow_Flight_Protocol_Ticket()
+        ticket.ticket = self.data
+        return ticket
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
new file mode 100644
index 0000000000000..a6b9ce93a9acd
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+import Arrow
+import GRPC
+
+public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
+    public typealias AsyncIterator = RecordBatchStreamReader
+    public typealias Element = RecordBatch
+    let reader = ArrowReader()
+    var batches = [RecordBatch]()
+    var batchIndex = 0
+    var streamIterator: any AsyncIteratorProtocol
+    let stream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>
+    init(_ stream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>) {
+        self.stream = stream
+        self.streamIterator = self.stream.makeAsyncIterator()
+    }
+    
+    public func next() async throws -> Arrow.RecordBatch? {
+        guard !Task.isCancelled else {
+            return nil
+        }
+
+        if batchIndex < batches.count {
+            let batch = batches[batchIndex]
+            batchIndex += 1
+            return batch
+        }
+         
+        while true {
+            let flightData = try await self.streamIterator.next()
+            if flightData == nil {
+                return nil
+            }
+            
+            let data = (flightData as! Arrow_Flight_Protocol_FlightData).dataBody
+            switch reader.fromStream(data) {
+            case .success(let rbResult):
+                batches = rbResult.batches
+                batchIndex = 1
+                return batches[0]
+            case .failure(let error):
+                throw error
+            }
+        }
+    }
+
+    public func makeAsyncIterator() -> RecordBatchStreamReader {
+        self
+    }
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
new file mode 100644
index 0000000000000..1efeba5310369
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 Foundation
+import Arrow
+import GRPC
+
+public class ActionTypeStreamWriter {
+    let stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>
+    init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>) {
+        self.stream = stream
+    }
+    
+    public func write(_ actionType: FlightActionType) async throws {
+        try await self.stream.send(actionType.toProtocol())
+    }
+}
+
+public class ResultStreamWriter {
+    let stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>
+    init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>) {
+        self.stream = stream
+    }
+    
+    public func write(_ result: FlightResult) async throws {
+        try await self.stream.send(result.toProtocol())
+    }
+}
+
+public class FlightInfoStreamWriter {
+    let stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>
+    init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>) {
+        self.stream = stream
+    }
+    
+    public func write(_ result: FlightInfo) async throws {
+        try await self.stream.send(result.toProtocol())
+    }
+}
+
+public class PutResultDataStreamWriter {
+    let stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>
+    init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>) {
+        self.stream = stream
+    }
+    
+    public func write(_ result: FlightPutResult) async throws {
+        try await self.stream.send(result.toProtocol())
+    }
+}
+
+public class RecordBatchStreamWriter {
+    let writer = ArrowWriter()
+    let stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>
+    init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>) {
+        self.stream = stream
+    }
+    
+    public func write(_ rb: RecordBatch) async throws {
+        let info = ArrowWriter.Info(.recordbatch,
+                                    schema: rb.schema,
+                                    batches: [rb]
+        )
+
+        let result = writer.toStream(info)
+        switch result {
+        case .success(let rbResult):
+            let data = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataBody = rbResult
+            }
+            
+            try await self.stream.send(data)
+        case .failure(let error):
+            throw error
+        }
+    }
+}
diff --git a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
new file mode 100644
index 0000000000000..d0db593b10304
--- /dev/null
+++ b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
@@ -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.
+
+import XCTest
+import struct Foundation.Data
+import struct Foundation.URL
+import GRPC
+import NIOCore
+import NIOPosix
+import Arrow
+
+@testable import ArrowFlight
+
+func makeSchema() -> ArrowSchema {
+    let schemaBuilder = ArrowSchema.Builder()
+    return schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowUInt8), isNullable: true)
+        .addField("col2", type: ArrowType(ArrowType.ArrowString), isNullable: false)
+        .addField("col3", type: ArrowType(ArrowType.ArrowDate32), isNullable: false)
+        .finish()
+}
+
+func makeRecordBatch() throws -> RecordBatch {
+    let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
+    uint8Builder.append(10)
+    uint8Builder.append(22)
+    uint8Builder.append(33)
+    uint8Builder.append(44)
+    let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
+    stringBuilder.append("test10")
+    stringBuilder.append("test22")
+    stringBuilder.append("test33")
+    stringBuilder.append("test44")
+    let date32Builder = try ArrowArrayBuilders.loadDate32ArrayBuilder()
+    let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
+    let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
+    date32Builder.append(date1)
+    date32Builder.append(date2)
+    date32Builder.append(date1)
+    date32Builder.append(date2)
+    let intHolder = ArrowArrayHolder(try uint8Builder.finish())
+    let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
+    let date32Holder = ArrowArrayHolder(try date32Builder.finish())
+    let result = RecordBatch.Builder()
+        .addColumn("col1", arrowArray: intHolder)
+        .addColumn("col2", arrowArray: stringHolder)
+        .addColumn("col3", arrowArray: date32Holder)
+        .finish()
+    switch result {
+    case .success(let recordBatch):
+        return recordBatch
+    case .failure(let error):
+        throw error
+    }
+}
+
+final class MyFlightServer : ArrowFlightServer {
+    func doExchange(_ reader: ArrowFlight.RecordBatchStreamReader, writer: ArrowFlight.RecordBatchStreamWriter) async throws {
+        do {
+            for try await rb in reader {
+                XCTAssertEqual(rb.schema.fields.count, 3)
+                XCTAssertEqual(rb.length, 4)
+            }
+            
+            let rb = try makeRecordBatch()
+            try await writer.write(rb)
+        } catch {
+            print("Unknown error: \(error)")
+        }
+    }
+    
+    func doPut(_ reader: ArrowFlight.RecordBatchStreamReader, writer: ArrowFlight.PutResultDataStreamWriter) async throws {
+        for try await rb in reader {
+            XCTAssertEqual(rb.schema.fields.count, 3)
+            XCTAssertEqual(rb.length, 4)
+            try await writer.write(FlightPutResult())
+        }
+    }
+    
+    func doGet(_ ticket: ArrowFlight.FlightTicket, writer: ArrowFlight.RecordBatchStreamWriter) async throws {
+        try await writer.write(try makeRecordBatch())
+    }
+    
+    func getSchema(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightSchemaResult {
+        XCTAssertEqual(String(bytes: request.cmd, encoding: .utf8)!, "schema info")
+        XCTAssertEqual(request.type, .cmd)
+        return try ArrowFlight.FlightSchemaResult(schemaToArrowStream(makeSchema()))
+    }
+    
+    func getFlightInfo(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightInfo {
+        return ArrowFlight.FlightInfo(Data())
+    }
+    
+    func listFlights(_ criteria: ArrowFlight.FlightCriteria, writer: ArrowFlight.FlightInfoStreamWriter) async throws {
+        XCTAssertEqual(String(bytes: criteria.expression, encoding: .utf8), "flight criteria expression")
+        let flight_info = try ArrowFlight.FlightInfo(schemaToArrowStream(makeSchema()))
+        try await writer.write(flight_info)
+    }
+    
+    func listActions(_ writer: ArrowFlight.ActionTypeStreamWriter) async throws {
+        try await writer.write(FlightActionType("type1", description: "desc1"))
+        try await writer.write(FlightActionType("type2", description: "desc2"))
+    }
+    
+    func doAction(_ action: FlightAction, writer: ResultStreamWriter) async throws {
+        XCTAssertEqual(action.type, "test_action")
+        XCTAssertEqual(String(bytes: action.body, encoding: .utf8)!, "test_action body")
+        try await writer.write(FlightResult("test_action result".data(using: .utf8)!))
+    }
+}
+
+struct FlightServerImpl {
+    var port = 1234
+    static var server: Server?
+    static var group: MultiThreadedEventLoopGroup?
+    static func run() async throws {
+        do {
+            // Create an event loop group for the server to run on.
+            let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
+            // Create a provider using the features we read.
+            let provider = ArrowFlight.MakeFlightServer(MyFlightServer())
+            
+            // Start the server and print its address once it has started.
+            FlightServerImpl.server = try await Server.insecure(group: group)
+                .withServiceProviders([provider])
+                .bind(host: "localhost", port: 8088)
+                .get()
+            
+            print("server started on port \(server!.channel.localAddress!.port!)")
+
+            // Wait on the server's `onClose` future to stop the program from exiting.
+        } catch {
+            print("Unknown server error: \(error)")
+        }
+    }
+}
+
+public class FlightClientTester {
+    var client: FlightClient?
+    var group: MultiThreadedEventLoopGroup?
+    var channel: GRPCChannel?
+    
+    init() async throws {
+        // Load the features.
+        let group = PlatformSupport.makeEventLoopGroup(loopCount: 1)
+        let channel = try GRPCChannelPool.with(
+            target: .host("localhost", port: 8088),
+            transportSecurity: .plaintext,
+            eventLoopGroup: group
+        )
+
+        client = FlightClient(channel: channel)
+    }
+    
+    deinit {
+        try? group?.syncShutdownGracefully()
+        try? channel?.close().wait()
+    }
+    
+    func listActionTest() async throws {
+        var actionTypes = [FlightActionType]()
+        try await client?.listActions( { action in
+            actionTypes.append(action)
+        })
+        
+        XCTAssertEqual(actionTypes.count, 2)
+        XCTAssertEqual(actionTypes[0].type, "type1")
+        XCTAssertEqual(actionTypes[0].description, "desc1")
+        XCTAssertEqual(actionTypes[1].type, "type2")
+        XCTAssertEqual(actionTypes[1].description, "desc2")
+    }
+    
+    func listFlightsTest() async throws {
+        let flightCriteria = FlightCriteria("flight criteria expression".data(using: .utf8)!)
+        var num_calls = 0
+        try await client?.listFlights(flightCriteria, closure: { data in
+            num_calls += 1
+            let schema = try streamToArrowSchema(data.schema)
+            XCTAssertEqual(schema.fields.count, 3)
+        })
+        
+        XCTAssertEqual(num_calls, 1)
+    }
+    
+    func doActionTest() async throws {
+        let action = FlightAction("test_action", body: "test_action body".data(using: .utf8)!)
+        var actionResults = [FlightResult]()
+        try await client?.doAction(action, closure: { result in
+            actionResults.append(result)
+        })
+        
+        XCTAssertEqual(actionResults.count, 1)
+        XCTAssertEqual(String(bytes:actionResults[0].body, encoding: .utf8), "test_action result")
+    }
+    
+    func getSchemaTest() async throws {
+        let descriptor = FlightDescriptor(cmd: "schema info".data(using: .utf8)!)
+        let schemaResult = try await client?.getSchema(descriptor)
+        let schema = try streamToArrowSchema(schemaResult!.schema)
+        XCTAssertEqual(schema.fields.count, 3)
+    }
+    
+    func doGetTest() async throws {
+        let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
+        var num_call = 0
+        try await client?.doGet(ticket, readerResultClosure: { rb in
+            num_call += 1
+            XCTAssertEqual(rb.schema!.fields.count, 3)
+            XCTAssertEqual(rb.batches[0].length, 4)
+        })
+        
+        XCTAssertEqual(num_call, 1)
+    }
+    
+    func doPutTest() async throws {
+        let rb = try makeRecordBatch()
+        var num_call = 0
+        try await client?.doPut([rb], closure: { result in
+            num_call += 1
+        })
+        
+        XCTAssertEqual(num_call, 1)
+    }
+
+    func doExchangeTest() async throws {
+        let rb = try makeRecordBatch()
+        var num_call = 0
+        try await client?.doExchange([rb], closure: { result in
+            num_call += 1
+            XCTAssertEqual(result.schema?.fields.count, 3)
+            XCTAssertEqual(result.batches[0].length, 4)
+        })
+        
+        XCTAssertEqual(num_call, 1)
+    }
+}
+
+actor FlightServerData {
+    public var serverup = false
+    func SetServerUp(_ serverUp: Bool) {
+        self.serverup = serverUp
+    }
+    
+    func IsServerUp() -> Bool {
+        return serverup
+    }
+}
+
+final class FlightTest: XCTestCase {
+    let serverData = FlightServerData()
+    
+    func testFlightServer() async throws {
+        let basicTask = Task {
+            try await FlightServerImpl.run()
+            defer {
+                print("server shutting down")
+                try! FlightServerImpl.group?.syncShutdownGracefully()
+            }
+            
+            await serverData.SetServerUp(true)
+            try await FlightServerImpl.server?.onClose.get()
+            return "done"
+        }
+
+        let secondTask = Task {
+            defer {
+                _ = FlightServerImpl.server?.close()
+            }
+            
+            while await !serverData.IsServerUp() {
+                try await Task.sleep(nanoseconds: 1_000_000)
+            }
+            
+            let clientImpl = try await FlightClientTester()
+            try await clientImpl.listActionTest()
+            try await clientImpl.listFlightsTest()
+            try await clientImpl.doActionTest()
+            try await clientImpl.getSchemaTest()
+            try await clientImpl.doGetTest()
+            try await clientImpl.doPutTest()
+            try await clientImpl.doExchangeTest()
+            
+            return "done"
+        }
+                
+        let _ = try await [basicTask.value, secondTask.value]
+        print("done running")
+    }
+}
diff --git a/swift/gen-protobuffers.sh b/swift/gen-protobuffers.sh
new file mode 100755
index 0000000000000..383a7a2f3195e
--- /dev/null
+++ b/swift/gen-protobuffers.sh
@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -eu
+protoc --swift_out=./ArrowFlight/Sources/ArrowFlight --proto_path=../format Flight.proto
+protoc --grpc-swift_out=./ArrowFlight/Sources/ArrowFlight --proto_path=../format Flight.proto
+cat <<HEADER > header.swift
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+HEADER
+mv ./ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift ./ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift.orig
+cat header.swift ./ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift.orig > ./ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
+rm ./ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift.orig
+rm header.swift
\ No newline at end of file

From 819b7d5ce7febb4af9ea6f69947244f46403ce53 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 20 Jul 2023 12:37:44 +0100
Subject: [PATCH 017/749] GH-36720: [R] stringr modifier functions cannot be
 called with namespace prefix (#36758)

### Rationale for this change

Bug in implementation of string modified functions caused them to be swallowed when prefixed with stringr namespace

### What changes are included in this PR?

Strips out the `stringr::` prefix when expressions contain `stringr::fixed`, `stringr::coll`, `string::boundary` or `stringr::regex`

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes
* Closes: #36720

Lead-authored-by: Nic Crane <thisisnic@gmail.com>
Co-authored-by: Dewey Dunnington <dewey@dunnington.ca>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                                |  1 +
 r/R/arrow-package.R                        |  2 +-
 r/R/dplyr-funcs-string.R                   | 18 +++++++++++++
 r/tests/testthat/test-dplyr-funcs-string.R | 30 ++++++++++++++++++++++
 4 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/r/NAMESPACE b/r/NAMESPACE
index aa7b30252bbc0..7eaa51bc5771f 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -443,6 +443,7 @@ importFrom(rlang,as_label)
 importFrom(rlang,as_quosure)
 importFrom(rlang,call2)
 importFrom(rlang,call_args)
+importFrom(rlang,call_name)
 importFrom(rlang,caller_env)
 importFrom(rlang,check_dots_empty)
 importFrom(rlang,check_dots_empty0)
diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R
index 79871d8735c96..8f44f8936bdd3 100644
--- a/r/R/arrow-package.R
+++ b/r/R/arrow-package.R
@@ -27,7 +27,7 @@
 #' @importFrom rlang is_list call2 is_empty as_function as_label arg_match is_symbol is_call call_args
 #' @importFrom rlang quo_set_env quo_get_env is_formula quo_is_call f_rhs parse_expr f_env new_quosure
 #' @importFrom rlang new_quosures expr_text caller_env check_dots_empty check_dots_empty0 dots_list is_string inform
-#' @importFrom rlang is_bare_list
+#' @importFrom rlang is_bare_list call_name
 #' @importFrom tidyselect vars_pull eval_select eval_rename
 #' @importFrom glue glue
 #' @useDynLib arrow, .registration = TRUE
diff --git a/r/R/dplyr-funcs-string.R b/r/R/dplyr-funcs-string.R
index 436083d9de455..b4becb4081bcb 100644
--- a/r/R/dplyr-funcs-string.R
+++ b/r/R/dplyr-funcs-string.R
@@ -56,15 +56,33 @@ get_stringr_pattern_options <- function(pattern) {
       )
     }
   }
+
   ensure_opts <- function(opts) {
     if (is.character(opts)) {
       opts <- list(pattern = opts, fixed = FALSE, ignore_case = FALSE)
     }
     opts
   }
+
+  pattern <- clean_pattern_namespace(pattern)
+
   ensure_opts(eval(pattern))
 }
 
+# Ensure that e.g. stringr::regex and regex both work within patterns
+clean_pattern_namespace <- function(pattern) {
+  modifier_funcs <- c("fixed", "regex", "coll", "boundary")
+  if (is_call(pattern, modifier_funcs, ns = "stringr")) {
+    function_called <- call_name(pattern[1])
+
+    if (function_called %in% modifier_funcs) {
+      pattern[1] <- call2(function_called)
+    }
+  }
+
+  pattern
+}
+
 #' Does this string contain regex metacharacters?
 #'
 #' @param string String to be tested
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 0dc834dbfea16..fc202bfb3a99e 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -1466,3 +1466,33 @@ test_that("str_remove and str_remove_all", {
     df
   )
 })
+
+test_that("GH-36720: stringr modifier functions can be called with namespace prefix", {
+  df <- tibble(x = c("Foo", "bar"))
+  compare_dplyr_binding(
+    .input %>%
+      transmute(x = str_replace_all(x, stringr::regex("^f", ignore_case = TRUE), "baz")) %>%
+      collect(),
+    df
+  )
+
+  compare_dplyr_binding(
+    .input %>%
+      filter(str_detect(x, stringr::fixed("f", ignore_case = TRUE), negate = TRUE)) %>%
+      collect(),
+    df
+  )
+
+  x <- Expression$field_ref("x")
+
+  expect_error(
+    call_binding("str_detect", x, stringr::boundary(type = "character")),
+    "Pattern modifier `boundary()` not supported in Arrow",
+    fixed = TRUE
+  )
+  expect_error(
+    call_binding("str_replace_all", x, stringr::coll("o", locale = "en"), "ó"),
+    "Pattern modifier `coll()` not supported in Arrow",
+    fixed = TRUE
+  )
+})

From f9d8edda36acbd83a552a34392d0df926646d849 Mon Sep 17 00:00:00 2001
From: Mark Wolfe <mark@wolfe.id.au>
Date: Fri, 21 Jul 2023 00:40:33 +1000
Subject: [PATCH 018/749] =?UTF-8?q?GH-36698:=20[Go][Parquet]=20Add=20a=20T?=
 =?UTF-8?q?imestampLogicalType=20creation=20function=20=E2=80=A6=20(#36699?=
 =?UTF-8?q?)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…with more options

This change introduces a more flexible creation function for TimestampLogicalType which will enable changes to all the flags provided by this type, but without requiring a lot of parameters.

Following on from other great examples in arrow it uses the functional options pattern.

### Rationale for this change

Add a `TimestampLogicalType` creation function with more options, in particular an option to set `fromConverted` as I can't see another way to set this private struct property after creation.

### What changes are included in this PR?

This change introduces a more flexible creation function for `TimestampLogicalType` which will enable changes to all the flags provided by this type, but without requiring a lot of parameters.

### Are these changes tested?

Yes I have updated one of the existing tests.

### Are there any user-facing changes?

* Closes: #36698

Authored-by: Mark Wolfe <mark@wolfe.id.au>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/schema/logical_types.go      | 49 +++++++++++++++++++++++++
 go/parquet/schema/logical_types_test.go |  1 +
 2 files changed, 50 insertions(+)

diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index ade6e750adacb..4075edc1e9402 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -616,6 +616,55 @@ func NewTimestampLogicalTypeForce(isAdjustedToUTC bool, unit TimeUnitType) Logic
 	}
 }
 
+// TimestampOpt options used with New Timestamp Logical Type
+type TimestampOpt func(*TimestampLogicalType)
+
+// WithTSIsAdjustedToUTC sets the IsAdjustedToUTC field of the timestamp type.
+func WithTSIsAdjustedToUTC() TimestampOpt {
+	return func(t *TimestampLogicalType) {
+		t.typ.IsAdjustedToUTC = true
+	}
+}
+
+// WithTSTimeUnitType sets the time unit for the timestamp type
+func WithTSTimeUnitType(unit TimeUnitType) TimestampOpt {
+	return func(t *TimestampLogicalType) {
+		t.typ.Unit = createTimeUnit(unit)
+	}
+}
+
+// WithTSForceConverted enable force converted mode
+func WithTSForceConverted() TimestampOpt {
+	return func(t *TimestampLogicalType) {
+		t.forceConverted = true
+	}
+}
+
+// WithTSFromConverted enable the timestamp logical type to be
+// constructed from a converted type.
+func WithTSFromConverted() TimestampOpt {
+	return func(t *TimestampLogicalType) {
+		t.fromConverted = true
+	}
+}
+
+// NewTimestampLogicalTypeWithOpts creates a new TimestampLogicalType with the provided options.
+//
+// TimestampType Unit defaults to milliseconds (TimeUnitMillis)
+func NewTimestampLogicalTypeWithOpts(opts ...TimestampOpt) LogicalType {
+	ts := &TimestampLogicalType{
+		typ: &format.TimestampType{
+			Unit: createTimeUnit(TimeUnitMillis), // default to milliseconds
+		},
+	}
+
+	for _, o := range opts {
+		o(ts)
+	}
+
+	return ts
+}
+
 // TimestampLogicalType represents an int64 number that can be decoded
 // into a year, month, day, hour, minute, second, and subsecond
 type TimestampLogicalType struct {
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 540899d79a02a..117157f95ef83 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -93,6 +93,7 @@ func TestConvertedTypeCompatibility(t *testing.T) {
 		{"time_micro", schema.NewTimeLogicalType(true /* adjutedToUTC */, schema.TimeUnitMicros), schema.ConvertedTypes.TimeMicros},
 		{"timestamp_milli", schema.NewTimestampLogicalType(true /* adjutedToUTC */, schema.TimeUnitMillis), schema.ConvertedTypes.TimestampMillis},
 		{"timestamp_micro", schema.NewTimestampLogicalType(true /* adjutedToUTC */, schema.TimeUnitMicros), schema.ConvertedTypes.TimestampMicros},
+		{"timestamp_milli_opts", schema.NewTimestampLogicalTypeWithOpts(schema.WithTSIsAdjustedToUTC(), schema.WithTSTimeUnitType(schema.TimeUnitMillis)), schema.ConvertedTypes.TimestampMillis},
 		{"uint8", schema.NewIntLogicalType(8 /* bitWidth */, false /* signed */), schema.ConvertedTypes.Uint8},
 		{"uint16", schema.NewIntLogicalType(16 /* bitWidth */, false /* signed */), schema.ConvertedTypes.Uint16},
 		{"uint32", schema.NewIntLogicalType(32 /* bitWidth */, false /* signed */), schema.ConvertedTypes.Uint32},

From fca6a6633300694ae9089e92b736ce7d95fd7ed7 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 20 Jul 2023 18:03:12 +0100
Subject: [PATCH 019/749] GH-36787: [R] lintr update leads to failing tests on
 main (#36788)

### What changes are included in this PR?

Turning off the newly introduced indentation linter as it causes test failures, and isn't in sync with styler which we use to style our code.

### Are these changes tested?

No, is linter config.

### Are there any user-facing changes?

No
* Closes: #36787

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/.lintr | 1 +
 1 file changed, 1 insertion(+)

diff --git a/r/.lintr b/r/.lintr
index 1bd80aff4c62d..085ff45123411 100644
--- a/r/.lintr
+++ b/r/.lintr
@@ -15,6 +15,7 @@ license:  #  Licensed to the Apache Software Foundation (ASF) under one
   #  specific language governing permissions and limitations
   #  under the License.
 linters: linters_with_defaults(
+  indentation_linter = NULL,
   line_length_linter = line_length_linter(120),
   object_name_linter = NULL,
   # Even with a liberal definition of name styles, some of our names cause issues due to `.`s for s3 classes or NA in the name

From 15ee52111b5ee6c1623e8d1826b850b54c6de6a5 Mon Sep 17 00:00:00 2001
From: Mark Wolfe <mark@wolfe.id.au>
Date: Fri, 21 Jul 2023 05:02:24 +1000
Subject: [PATCH 020/749] GH-36696: [Go] Improve the MapOf and ListOf helpers
 (#36697)

### Rationale for this change

The aim is to improve the MapOf and ListOf helper functions without breaking anything. I have added a `ListOfWithName` which matches the `MapOf` function in that it takes a name, rather than deriving it from the elements name, which should actually be `element`.

This just seems clearer to me as an interface, and makes construction a bit more obvious.

### What changes are included in this PR?

* Removed references to panics I can't find
* Updated error messages for list and map to be clearer with validation errors
* Added a ListOfWithName to provide a clearer matching method to MapOf which takes a name

Closes #36696

### Are these changes tested?

Yes, I added a test for the new `ListOfWithName` function.

### Are there any user-facing changes?

* Closes: #36696

Authored-by: Mark Wolfe <mark@wolfe.id.au>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/schema/helpers.go      | 62 ++++++++++++++++++++-----------
 go/parquet/schema/helpers_test.go | 19 ++++++++++
 2 files changed, 60 insertions(+), 21 deletions(-)

diff --git a/go/parquet/schema/helpers.go b/go/parquet/schema/helpers.go
index 7cc89efca6e8e..1198b0b926ac8 100644
--- a/go/parquet/schema/helpers.go
+++ b/go/parquet/schema/helpers.go
@@ -24,43 +24,62 @@ import (
 // ListOf is a convenience helper function to create a properly structured
 // list structure according to the Parquet Spec.
 //
-// <list-repetition> group <name> (LIST) {
-//   repeated group list {
-//     <element-repetition> <element-type> element;
-//   }
-// }
+//	<list-repetition> group <name> (LIST) {
+//	  repeated group list {
+//	    <element-repetition> <element-type> element;
+//	  }
+//	}
 //
-// <list-repetition> can only be optional or required. panics if repeated.
-// <element-repetition> can only be optional or required. panics if repeated.
+// <list-repetition> can only be optional or required.
+// <element-repetition> can only be optional or required.
 func ListOf(n Node, rep parquet.Repetition, fieldID int32) (*GroupNode, error) {
-	if rep == parquet.Repetitions.Repeated || n.RepetitionType() == parquet.Repetitions.Repeated {
-		return nil, xerrors.New("parquet: listof repetition and element repetition must not be repeated.")
+	return ListOfWithName(n.Name(), n, rep, fieldID)
+}
+
+// ListOf is a convenience helper function to create a properly structured
+// list structure according to the Parquet Spec.
+//
+//	<list-repetition> group <name> (LIST) {
+//	  repeated group list {
+//	    <element-repetition> <element-type> element;
+//	  }
+//	}
+//
+// <list-repetition> can only be optional or required.
+// <element-repetition> can only be optional or required.
+func ListOfWithName(listName string, element Node, rep parquet.Repetition, fieldID int32) (*GroupNode, error) {
+	if rep == parquet.Repetitions.Repeated {
+		return nil, xerrors.Errorf("parquet: listof repetition must not be repeated, got :%s", rep)
 	}
-	listName := n.Name()
 
-	switch n := n.(type) {
+	if element.RepetitionType() == parquet.Repetitions.Repeated {
+		return nil, xerrors.Errorf("parquet: element repetition must not be repeated, got: %s", element.RepetitionType())
+	}
+
+	switch n := element.(type) {
 	case *PrimitiveNode:
 		n.name = "element"
 	case *GroupNode:
 		n.name = "element"
 	}
 
-	list, err := NewGroupNode("list" /* name */, parquet.Repetitions.Repeated, FieldList{n}, -1 /* fieldID */)
+	list, err := NewGroupNode("list" /* name */, parquet.Repetitions.Repeated, FieldList{element}, -1 /* fieldID */)
 	if err != nil {
 		return nil, err
 	}
+
 	return NewGroupNodeLogical(listName, rep, FieldList{list}, ListLogicalType{}, fieldID)
 }
 
 // MapOf is a convenience helper function to create a properly structured
 // parquet map node setup according to the Parquet Spec.
 //
-// <map-repetition> group <name> (MAP) {
-// 	 repeated group key_value {
-// 	   required <key-type> key;
-//     <value-repetition> <value-type> value;
-//   }
-// }
+//	<map-repetition> group <name> (MAP) {
+//		 repeated group key_value {
+//		   required <key-type> key;
+//	    <value-repetition> <value-type> value;
+//	  }
+//	}
 //
 // key node will be renamed to "key", value node if not nil will be renamed to "value"
 //
@@ -69,14 +88,15 @@ func ListOf(n Node, rep parquet.Repetition, fieldID int32) (*GroupNode, error) {
 // the key node *must* be required repetition. panics if optional or repeated
 //
 // value node can be nil (omitted) or have a repetition of required or optional *only*.
-// panics if value node is not nil and has a repetition of repeated.
 func MapOf(name string, key Node, value Node, mapRep parquet.Repetition, fieldID int32) (*GroupNode, error) {
 	if mapRep == parquet.Repetitions.Repeated {
-		return nil, xerrors.New("parquet: map repetition cannot be Repeated")
+		return nil, xerrors.Errorf("parquet: map repetition cannot be Repeated, got: %s", mapRep)
 	}
+
 	if key.RepetitionType() != parquet.Repetitions.Required {
-		return nil, xerrors.New("parquet: map key repetition must be Required")
+		return nil, xerrors.Errorf("parquet: map key repetition must be Required, got: %s", key.RepetitionType())
 	}
+
 	if value != nil {
 		if value.RepetitionType() == parquet.Repetitions.Repeated {
 			return nil, xerrors.New("parquet: map value cannot have repetition Repeated")
diff --git a/go/parquet/schema/helpers_test.go b/go/parquet/schema/helpers_test.go
index 055fe7f46d127..b4f0b684003db 100644
--- a/go/parquet/schema/helpers_test.go
+++ b/go/parquet/schema/helpers_test.go
@@ -62,6 +62,25 @@ func TestListOfNested(t *testing.T) {
 }`, strings.TrimSpace(buf.String()))
 }
 
+func TestListOfWithNameNested(t *testing.T) {
+	n, err := schema.ListOfWithName("arrays", schema.NewInt32Node("element", parquet.Repetitions.Required, -1), parquet.Repetitions.Required, -1)
+	assert.NoError(t, err)
+	final, err := schema.ListOf(n, parquet.Repetitions.Required, -1)
+	assert.NoError(t, err)
+
+	var buf bytes.Buffer
+	schema.PrintSchema(final, &buf, 4)
+	assert.Equal(t,
+		`required group field_id=-1 arrays (List) {
+    repeated group field_id=-1 list {
+        required group field_id=-1 element (List) {
+            repeated group field_id=-1 list {
+                required int32 field_id=-1 element;
+            }
+        }
+    }
+}`, strings.TrimSpace(buf.String()))
+}
 func TestMapOfNestedTypes(t *testing.T) {
 	n, err := schema.NewGroupNode("student", parquet.Repetitions.Required, schema.FieldList{
 		schema.NewByteArrayNode("name", parquet.Repetitions.Required, -1),

From d98b3a18a1985c59295e54c635060caf8a0bbd42 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Thu, 20 Jul 2023 17:58:29 -0300
Subject: [PATCH 021/749] GH-36750: [R] Fix test-r-devdocs on MacOS (#36751)

### Rationale for this change

The test-r-devdocs job is failing. It is failing because we are pinning a version of R that is so old that CRAN no longer serves binaries (#31757), so some of the package builds are failing.

### What changes are included in this PR?

Use the `setup-r-dependencies` action which either installs the correct build dependencies or uses older binary versions to avoid building from source (or both).

### Are these changes tested?

Yes, as part of the test-r-devdocs job.

### Are there any user-facing changes?

No.
* Closes: #36750

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/r/github.devdocs.yml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/dev/tasks/r/github.devdocs.yml b/dev/tasks/r/github.devdocs.yml
index 7126b1418253f..0839e7fc6afcf 100644
--- a/dev/tasks/r/github.devdocs.yml
+++ b/dev/tasks/r/github.devdocs.yml
@@ -38,10 +38,9 @@ jobs:
           # remove after https://issues.apache.org/jira/browse/ARROW-16376
           r-version: '4.1'
       - uses: r-lib/actions/setup-pandoc@v2
-      - name: Install knitr, rmarkdown
-        run: |
-          install.packages(c("rmarkdown", "knitr", "sessioninfo"))
-        shell: Rscript {0}
+      - uses: r-lib/actions/setup-r-dependencies@v2
+        with:
+          packages: "rmarkdown, knitr, sessioninfo"
       - name: Session info
         run: |
           options(width = 100)

From f43bfd69e97408d06a5de4851aec77f8754bd72f Mon Sep 17 00:00:00 2001
From: lambda <1wei@live.com>
Date: Fri, 21 Jul 2023 15:38:32 +0800
Subject: [PATCH 022/749] GH-36770: [C++] Use custom endpoint for s3 using
 environment variable AWS_ENDPOINT_URL (#36791)

### Rationale for this change
we need a way to read custom object storage (such as minio host or other s3-like storage).
use environment variable `AWS_ENDPOINT_URL `

### What changes are included in this PR?
set variable endpoint_override according the environment variable

### Are these changes tested?
unittest and tested on pyarrow

### Are there any user-facing changes?
No

* Closes: #36770

Authored-by: yiwei.wang <yiwei.wang@weride.ai>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/filesystem/s3fs.cc      | 5 +++++
 cpp/src/arrow/filesystem/s3fs_test.cc | 7 +++++++
 2 files changed, 12 insertions(+)

diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index c57fc7f291c68..29b45e1dc9abe 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -127,6 +127,7 @@ using internal::ToAwsString;
 using internal::ToURLEncodedAwsString;
 
 static const char kSep = '/';
+constexpr char kAwsEndpointUrlEnvVar[] = "AWS_ENDPOINT_URL";
 
 // -----------------------------------------------------------------------
 // S3ProxyOptions implementation
@@ -337,6 +338,10 @@ Result<S3Options> S3Options::FromUri(const Uri& uri, std::string* out_path) {
   } else {
     options.ConfigureDefaultCredentials();
   }
+  auto endpoint_env = arrow::internal::GetEnvVar(kAwsEndpointUrlEnvVar);
+  if (endpoint_env.ok()) {
+    options.endpoint_override = *endpoint_env;
+  }
 
   bool region_set = false;
   for (const auto& kv : options_map) {
diff --git a/cpp/src/arrow/filesystem/s3fs_test.cc b/cpp/src/arrow/filesystem/s3fs_test.cc
index 1426fe324b720..718304abaed63 100644
--- a/cpp/src/arrow/filesystem/s3fs_test.cc
+++ b/cpp/src/arrow/filesystem/s3fs_test.cc
@@ -297,6 +297,13 @@ TEST_F(S3OptionsTest, FromUri) {
 
   // Invalid option
   ASSERT_RAISES(Invalid, S3Options::FromUri("s3://mybucket/?xxx=zzz", &path));
+
+  // Endpoint from environment variable
+  {
+    EnvVarGuard endpoint_guard("AWS_ENDPOINT_URL", "http://127.0.0.1:9000");
+    ASSERT_OK_AND_ASSIGN(options, S3Options::FromUri("s3://mybucket/", &path));
+    ASSERT_EQ(options.endpoint_override, "http://127.0.0.1:9000");
+  }
 }
 
 TEST_F(S3OptionsTest, FromAccessKey) {

From b557e85679d7020cd1317262a91f0ee73a6e92e5 Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Fri, 21 Jul 2023 12:48:59 -0700
Subject: [PATCH 023/749] GH-36812: [C#] Fix C API support to work with .NET
 desktop framework (#36813)

### What changes are included in this PR?

The C API support in the C# library has been modified to work correctly on .NET 4.7.2.
The tests have been modified to work correctly on .NET 4.7.2, though that platform is disabled by default as the Python interop seem to cause a hang when unloading the xUnit AppDomain.

**This PR contains a "Critical Fix".**
* Closes: #36812

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 csharp/src/Apache.Arrow/C/CArrowArray.cs      | 14 ++++--
 .../src/Apache.Arrow/C/CArrowArrayExporter.cs |  8 ++--
 .../src/Apache.Arrow/C/CArrowArrayImporter.cs | 11 +++--
 .../src/Apache.Arrow/C/CArrowArrayStream.cs   | 39 ++++++++-------
 .../C/CArrowArrayStreamExporter.cs            | 24 ++++------
 .../C/CArrowArrayStreamImporter.cs            | 25 ++++++++--
 csharp/src/Apache.Arrow/C/CArrowSchema.cs     | 14 ++++--
 .../Apache.Arrow/C/CArrowSchemaExporter.cs    |  8 ++--
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |  8 +++-
 .../Apache.Arrow.Tests.csproj                 | 11 ++++-
 .../Apache.Arrow.Tests/ArrayBuilderTests.cs   |  2 +
 .../Apache.Arrow.Tests/ArrowArrayTests.cs     |  6 +++
 .../Apache.Arrow.Tests/ArrowReaderVerifier.cs |  4 ++
 .../ArrowStreamReaderTests.cs                 | 12 +++++
 .../CDataInterfaceDataTests.cs                | 10 ++--
 .../CDataInterfacePythonTests.cs              | 48 +++++++++++--------
 .../CDataInterfaceSchemaTests.cs              | 10 ++--
 .../Extensions/Net472Extensions.cs            | 34 +++++++++++++
 18 files changed, 200 insertions(+), 88 deletions(-)
 create mode 100644 csharp/test/Apache.Arrow.Tests/Extensions/Net472Extensions.cs

diff --git a/csharp/src/Apache.Arrow/C/CArrowArray.cs b/csharp/src/Apache.Arrow/C/CArrowArray.cs
index a8a084d1d767d..fc609f10fdfa5 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArray.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArray.cs
@@ -38,11 +38,11 @@ public unsafe struct CArrowArray
         public byte** buffers;
         public CArrowArray** children;
         public CArrowArray* dictionary;
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged<CArrowArray*, void> release;
+#else
+        internal IntPtr release;
 #endif
-            <CArrowArray*, void> release;
         public void* private_data;
 
         /// <summary>
@@ -68,10 +68,14 @@ internal delegate* unmanaged
         /// </remarks>
         public static void Free(CArrowArray* array)
         {
-            if (array->release != null)
+            if (array->release != default)
             {
                 // Call release if not already called.
+#if NET5_0_OR_GREATER
                 array->release(array);
+#else
+                Marshal.GetDelegateForFunctionPointer<CArrowArrayExporter.ReleaseArrowArray>(array->release)(array);
+#endif
             }
             Marshal.FreeHGlobal((IntPtr)array);
         }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
index 5a793c177e0a6..16aaa3874b370 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
@@ -26,9 +26,9 @@ public static class CArrowArrayExporter
 #if NET5_0_OR_GREATER
         private static unsafe delegate* unmanaged<CArrowArray*, void> ReleaseArrayPtr => &ReleaseArray;
 #else
-        private unsafe delegate void ReleaseArrowArray(CArrowArray* cArray);
+        internal unsafe delegate void ReleaseArrowArray(CArrowArray* cArray);
         private static unsafe readonly NativeDelegate<ReleaseArrowArray> s_releaseArray = new NativeDelegate<ReleaseArrowArray>(ReleaseArray);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowArray*, void> ReleaseArrayPtr => (delegate* unmanaged[Cdecl]<CArrowArray*, void>)s_releaseArray.Pointer;
+        private static IntPtr ReleaseArrayPtr => s_releaseArray.Pointer;
 #endif
         /// <summary>
         /// Export an <see cref="IArrowArray"/> to a <see cref="CArrowArray"/>. Whether or not the
@@ -93,7 +93,7 @@ public static unsafe void ExportRecordBatch(RecordBatch batch, CArrowArray* cArr
             {
                 throw new ArgumentNullException(nameof(cArray));
             }
-            if (cArray->release != null)
+            if (cArray->release != default)
             {
                 throw new ArgumentException("Cannot export array to a struct that is already initialized.", nameof(cArray));
             }
@@ -191,7 +191,7 @@ private unsafe static void ConvertRecordBatch(ExportedAllocationOwner sharedOwne
         private unsafe static void ReleaseArray(CArrowArray* cArray)
         {
             Dispose(&cArray->private_data);
-            cArray->release = null;
+            cArray->release = default;
         }
 
         private unsafe static void* FromDisposable(IDisposable disposable)
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
index e1314e5a62253..2f4ebed4b0cf1 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
@@ -17,6 +17,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using Apache.Arrow.Memory;
 using Apache.Arrow.Types;
 
@@ -104,21 +105,25 @@ public ImportedArrowArray(CArrowArray* cArray)
                 {
                     throw new ArgumentNullException(nameof(cArray));
                 }
-                if (cArray->release == null)
+                if (cArray->release == default)
                 {
                     throw new ArgumentException("Tried to import an array that has already been released.", nameof(cArray));
                 }
                 _cArray = *cArray;
-                cArray->release = null;
+                cArray->release = default;
             }
 
             protected override void FinalRelease()
             {
-                if (_cArray.release != null)
+                if (_cArray.release != default)
                 {
                     fixed (CArrowArray* cArray = &_cArray)
                     {
+#if NET5_0_OR_GREATER
                         cArray->release(cArray);
+#else
+                        Marshal.GetDelegateForFunctionPointer<CArrowArrayExporter.ReleaseArrowArray>(cArray->release)(cArray);
+#endif
                     }
                 }
             }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayStream.cs b/csharp/src/Apache.Arrow/C/CArrowArrayStream.cs
index a900a6895a097..9cc9984c6ec8f 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayStream.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayStream.cs
@@ -35,11 +35,11 @@ public unsafe struct CArrowArrayStream
         ///
         /// Return value: 0 if successful, an `errno`-compatible error code otherwise.
         ///</summary>
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged <CArrowArrayStream*, CArrowSchema*, int> get_schema;
+#else
+        internal IntPtr get_schema;
 #endif
-            <CArrowArrayStream*, CArrowSchema*, int> get_schema;
 
         /// <summary>
         /// Callback to get the next array. If no error and the array is released, the stream has ended.
@@ -47,11 +47,11 @@ internal delegate* unmanaged
         /// 
         /// Return value: 0 if successful, an `errno`-compatible error code otherwise.
         /// </summary>
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged<CArrowArrayStream*, CArrowArray*, int> get_next;
+#else
+        internal IntPtr get_next;
 #endif
-            <CArrowArrayStream*, CArrowArray*, int> get_next;
 
         /// <summary>
         /// Callback to get optional detailed error information. This must only
@@ -62,21 +62,21 @@ internal delegate* unmanaged
         /// Return value: pointer to a null-terminated character array describing the last
         /// error, or NULL if no description is available.
         ///</summary>
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged<CArrowArrayStream*, byte*> get_last_error;
+#else
+        internal IntPtr get_last_error;
 #endif
-            <CArrowArrayStream*, byte*> get_last_error;
 
         /// <summary>
         /// Release callback: release the stream's own resources. Note that arrays returned by
         /// get_next must be individually released.
         /// </summary>
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged <CArrowArrayStream*, void> release;
+#else
+        internal IntPtr release;
 #endif
-            <CArrowArrayStream*, void> release;
 
         public void* private_data;
 
@@ -103,10 +103,15 @@ internal delegate* unmanaged
         /// </remarks>
         public static void Free(CArrowArrayStream* arrayStream)
         {
-            if (arrayStream->release != null)
+            if (arrayStream->release != default)
             {
                 // Call release if not already called.
+#if NET5_0_OR_GREATER
+
                 arrayStream->release(arrayStream);
+#else
+                Marshal.GetDelegateForFunctionPointer<CArrowArrayStreamExporter.ReleaseArrayStream>(arrayStream->release)(arrayStream);
+#endif
             }
             Marshal.FreeHGlobal((IntPtr)arrayStream);
         }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
index c748eed915d89..0a0f1cc837459 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
@@ -29,22 +29,18 @@ public static class CArrowArrayStreamExporter
         private static unsafe delegate* unmanaged<CArrowArrayStream*, byte*> GetLastErrorPtr => &GetLastError;
         private static unsafe delegate* unmanaged<CArrowArrayStream*, void> ReleasePtr => &Release;
 #else
-        private unsafe delegate int GetSchemaArrayStream(CArrowArrayStream* cArrayStream, CArrowSchema* cSchema);
+        internal unsafe delegate int GetSchemaArrayStream(CArrowArrayStream* cArrayStream, CArrowSchema* cSchema);
         private static unsafe NativeDelegate<GetSchemaArrayStream> s_getSchemaArrayStream = new NativeDelegate<GetSchemaArrayStream>(GetSchema);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowArrayStream*, CArrowSchema*, int> GetSchemaPtr =>
-            (delegate* unmanaged[Cdecl]<CArrowArrayStream*, CArrowSchema*, int>)s_getSchemaArrayStream.Pointer;
-        private unsafe delegate int GetNextArrayStream(CArrowArrayStream* cArrayStream, CArrowArray* cArray);
+        private static unsafe IntPtr GetSchemaPtr => s_getSchemaArrayStream.Pointer;
+        internal unsafe delegate int GetNextArrayStream(CArrowArrayStream* cArrayStream, CArrowArray* cArray);
         private static unsafe NativeDelegate<GetNextArrayStream> s_getNextArrayStream = new NativeDelegate<GetNextArrayStream>(GetNext);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowArrayStream*, CArrowArray*, int> GetNextPtr =>
-            (delegate* unmanaged[Cdecl]<CArrowArrayStream*, CArrowArray*, int>)s_getNextArrayStream.Pointer;
-        private unsafe delegate byte* GetLastErrorArrayStream(CArrowArrayStream* cArrayStream);
+        private static unsafe IntPtr GetNextPtr => s_getNextArrayStream.Pointer;
+        internal unsafe delegate byte* GetLastErrorArrayStream(CArrowArrayStream* cArrayStream);
         private static unsafe NativeDelegate<GetLastErrorArrayStream> s_getLastErrorArrayStream = new NativeDelegate<GetLastErrorArrayStream>(GetLastError);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowArrayStream*, byte*> GetLastErrorPtr =>
-            (delegate* unmanaged[Cdecl]<CArrowArrayStream*, byte*>)s_getLastErrorArrayStream.Pointer;
-        private unsafe delegate void ReleaseArrayStream(CArrowArrayStream* cArrayStream);
+        private static unsafe IntPtr GetLastErrorPtr => s_getLastErrorArrayStream.Pointer;
+        internal unsafe delegate void ReleaseArrayStream(CArrowArrayStream* cArrayStream);
         private static unsafe NativeDelegate<ReleaseArrayStream> s_releaseArrayStream = new NativeDelegate<ReleaseArrayStream>(Release);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowArrayStream*, void> ReleasePtr =>
-            (delegate* unmanaged[Cdecl]<CArrowArrayStream*, void>)s_releaseArrayStream.Pointer;
+        private static unsafe IntPtr ReleasePtr => s_releaseArrayStream.Pointer;
 #endif
 
         /// <summary>
@@ -103,7 +99,7 @@ private unsafe static int GetNext(CArrowArrayStream* cArrayStream, CArrowArray*
             ExportedArrayStream arrayStream = null;
             try
             {
-                cArray->release = null;
+                cArray->release = default;
                 arrayStream = ExportedArrayStream.FromPointer(cArrayStream->private_data);
                 RecordBatch recordBatch = arrayStream.ArrowArrayStream.ReadNextRecordBatchAsync().Result;
                 if (recordBatch != null)
@@ -140,7 +136,7 @@ private unsafe static int GetNext(CArrowArrayStream* cArrayStream, CArrowArray*
         private unsafe static void Release(CArrowArrayStream* cArrayStream)
         {
             ExportedArrayStream.Free(&cArrayStream->private_data);
-            cArrayStream->release = null;
+            cArrayStream->release = default;
         }
 
         sealed unsafe class ExportedArrayStream : IDisposable
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayStreamImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayStreamImporter.cs
index 7e70632bf82fc..fe0a307c9b26c 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayStreamImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayStreamImporter.cs
@@ -16,6 +16,7 @@
 // under the License.
 
 using System;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Apache.Arrow.Ipc;
@@ -57,7 +58,11 @@ private sealed unsafe class ImportedArrowArrayStream : IArrowArrayStream
 
             internal static string GetLastError(CArrowArrayStream* arrayStream, int errno)
             {
+#if NET5_0_OR_GREATER
                 byte* error = arrayStream->get_last_error(arrayStream);
+#else
+                byte* error = Marshal.GetDelegateForFunctionPointer<CArrowArrayStreamExporter.GetLastErrorArrayStream>(arrayStream->get_last_error)(arrayStream);
+#endif
                 if (error == null)
                 {
                     return $"Array stream operation failed with no message. Error code: {errno}";
@@ -71,13 +76,17 @@ public ImportedArrowArrayStream(CArrowArrayStream* cArrayStream)
                 {
                     throw new ArgumentNullException(nameof(cArrayStream));
                 }
-                if (cArrayStream->release == null)
+                if (cArrayStream->release == default)
                 {
                     throw new ArgumentException("Tried to import an array stream that has already been released.", nameof(cArrayStream));
                 }
 
                 CArrowSchema cSchema = new CArrowSchema();
+#if NET5_0_OR_GREATER
                 int errno = cArrayStream->get_schema(cArrayStream, &cSchema);
+#else
+                int errno = Marshal.GetDelegateForFunctionPointer<CArrowArrayStreamExporter.GetSchemaArrayStream>(cArrayStream->get_schema)(cArrayStream, &cSchema);
+#endif
                 if (errno != 0)
                 {
                     throw new Exception(GetLastError(cArrayStream, errno));
@@ -85,7 +94,7 @@ public ImportedArrowArrayStream(CArrowArrayStream* cArrayStream)
                 _schema = CArrowSchemaImporter.ImportSchema(&cSchema);
 
                 _cArrayStream = *cArrayStream;
-                cArrayStream->release = null;
+                cArrayStream->release = default;
             }
 
             ~ImportedArrowArrayStream()
@@ -111,12 +120,16 @@ public ValueTask<RecordBatch> ReadNextRecordBatchAsync(CancellationToken cancell
                 CArrowArray cArray = new CArrowArray();
                 fixed (CArrowArrayStream* cArrayStream = &_cArrayStream)
                 {
+#if NET5_0_OR_GREATER
                     int errno = cArrayStream->get_next(cArrayStream, &cArray);
+#else
+                    int errno = Marshal.GetDelegateForFunctionPointer<CArrowArrayStreamExporter.GetNextArrayStream>(cArrayStream->get_next)(cArrayStream, &cArray);
+#endif
                     if (errno != 0)
                     {
                         return new(Task.FromException<RecordBatch>(new Exception(GetLastError(cArrayStream, errno))));
                     }
-                    if (cArray.release != null)
+                    if (cArray.release != default)
                     {
                         result = CArrowArrayImporter.ImportRecordBatch(&cArray, _schema);
                     }
@@ -127,12 +140,16 @@ public ValueTask<RecordBatch> ReadNextRecordBatchAsync(CancellationToken cancell
 
             public void Dispose()
             {
-                if (!_disposed && _cArrayStream.release != null)
+                if (!_disposed && _cArrayStream.release != default)
                 {
                     _disposed = true;
                     fixed (CArrowArrayStream* cArrayStream = &_cArrayStream)
                     {
+#if NET5_0_OR_GREATER
                         cArrayStream->release(cArrayStream);
+#else
+                        Marshal.GetDelegateForFunctionPointer<CArrowArrayStreamExporter.ReleaseArrayStream>(cArrayStream->release)(cArrayStream);
+#endif
                     }
                 }
                 GC.SuppressFinalize(this);
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchema.cs b/csharp/src/Apache.Arrow/C/CArrowSchema.cs
index 64761dbd0d095..50c363b07720f 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchema.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchema.cs
@@ -39,11 +39,11 @@ public unsafe struct CArrowSchema
         public long n_children;
         public CArrowSchema** children;
         public CArrowSchema* dictionary;
-        internal delegate* unmanaged
-#if !NET5_0_OR_GREATER
-            [Cdecl]
+#if NET5_0_OR_GREATER
+        internal delegate* unmanaged<CArrowSchema*, void> release;
+#else
+        internal IntPtr release;
 #endif
-            <CArrowSchema*, void> release;
         public void* private_data;
 
         /// <summary>
@@ -69,10 +69,14 @@ internal delegate* unmanaged
         /// </remarks>
         public static void Free(CArrowSchema* schema)
         {
-            if (schema->release != null)
+            if (schema->release != default)
             {
                 // Call release if not already called.
+#if NET5_0_OR_GREATER
                 schema->release(schema);
+#else
+                Marshal.GetDelegateForFunctionPointer<CArrowSchemaExporter.ReleaseArrowSchema>(schema->release)(schema);
+#endif
             }
             Marshal.FreeHGlobal((IntPtr)schema);
         }
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
index 9053e80664e31..696212eda36c7 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
@@ -30,9 +30,9 @@ public static class CArrowSchemaExporter
 #if NET5_0_OR_GREATER
         private static unsafe delegate* unmanaged<CArrowSchema*, void> ReleaseSchemaPtr => &ReleaseCArrowSchema;
 #else
-        private unsafe delegate void ReleaseArrowSchema(CArrowSchema* cArray);
+        internal unsafe delegate void ReleaseArrowSchema(CArrowSchema* cArray);
         private static unsafe readonly NativeDelegate<ReleaseArrowSchema> s_releaseSchema = new NativeDelegate<ReleaseArrowSchema>(ReleaseCArrowSchema);
-        private static unsafe delegate* unmanaged[Cdecl]<CArrowSchema*, void> ReleaseSchemaPtr => (delegate* unmanaged[Cdecl]<CArrowSchema*, void>)s_releaseSchema.Pointer;
+        private static IntPtr ReleaseSchemaPtr => s_releaseSchema.Pointer;
 #endif
 
         /// <summary>
@@ -297,7 +297,7 @@ private unsafe static void WriteMetadataString(ref byte* ptr, int length, string
         private static unsafe void ReleaseCArrowSchema(CArrowSchema* schema)
         {
             if (schema == null) return;
-            if (schema->release == null) return;
+            if (schema->release == default) return;
 
             Marshal.FreeHGlobal((IntPtr)schema->format);
             Marshal.FreeHGlobal((IntPtr)schema->name);
@@ -324,7 +324,7 @@ private static unsafe void ReleaseCArrowSchema(CArrowSchema* schema)
             schema->n_children = 0;
             schema->dictionary = null;
             schema->children = null;
-            schema->release = null;
+            schema->release = default;
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index 89c9481270c79..b21f24edba9af 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -113,7 +113,7 @@ public ImportedArrowSchema(CArrowSchema* cSchema)
                     throw new ArgumentException("Passed null pointer for cSchema.");
                 }
                 _cSchema = cSchema;
-                if (_cSchema->release == null)
+                if (_cSchema->release == default)
                 {
                     throw new ArgumentException("Tried to import a schema that has already been released.");
                 }
@@ -128,9 +128,13 @@ public ImportedArrowSchema(CArrowSchema* handle, bool isRoot) : this(handle)
             public void Dispose()
             {
                 // We only call release on a root-level schema, not child ones.
-                if (_isRoot && _cSchema->release != null)
+                if (_isRoot && _cSchema->release != default)
                 {
+#if NET5_0_OR_GREATER
                     _cSchema->release(_cSchema);
+#else
+                    Marshal.GetDelegateForFunctionPointer<CArrowSchemaExporter.ReleaseArrowSchema>(_cSchema->release)(_cSchema);
+#endif
                 }
             }
 
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 55005a91c74a1..805fb5ab3acce 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -3,6 +3,9 @@
 
   <PropertyGroup>
     <TargetFrameworks>net7.0</TargetFrameworks>
+    <!-- TODO: CI can't run with net472 on non-Windows platforms
+    <TargetFrameworks>net7.0;net472</TargetFrameworks>
+    -->
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
@@ -24,5 +27,9 @@
   <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible($(TargetFramework), 'net6.0'))">
     <Compile Remove="TimeOnlyTests.cs" />
   </ItemGroup>
-  
-</Project>
\ No newline at end of file
+
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible($(TargetFramework), 'net5.0'))">
+    <Compile Remove="Extensions\Net472Extensions.cs" />
+  </ItemGroup>
+
+</Project>
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
index 0c40fd82af7ce..2568e5e8bdab8 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
@@ -26,6 +26,7 @@ public class ArrayBuilderTests
     {
         // TODO: Test various builder invariants (Append, AppendRange, Clear, Resize, Reserve, etc)
 
+#if NET5_0_OR_GREATER
         [Fact]
         public void PrimitiveArrayBuildersProduceExpectedArray()
         {
@@ -73,6 +74,7 @@ static void Test<T, TArray, TBuilder>()
                 where TBuilder : PrimitiveArrayBuilder<T, TArray, TBuilder>, new() =>
                 TestArrayBuilder<TArray, TBuilder>(x => x.Append(T.CreateChecked(123)).AppendNull().AppendNull().Append(T.CreateChecked(127)), 4, 2, 0x09);
         }
+#endif
 
         [Fact]
         public void BooleanArrayBuilderProducersExpectedArray()
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
index 16fca684ff5ec..d4f0d8dfd0383 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
@@ -93,6 +93,7 @@ void TestIsValid(ArrowBuffer valueBuf, ArrowBuffer nullBitmapBuf, int length, in
             }
         }
 
+#if NET5_0_OR_GREATER
         [Fact]
         public void SliceArray()
         {
@@ -145,6 +146,7 @@ static void TestNumberSlice<T, TArray, TBuilder>()
                 where TBuilder : PrimitiveArrayBuilder<T, TArray, TBuilder>, new() =>
                 TestSlice<TArray, TBuilder>(x => x.AppendNull().Append(T.CreateChecked(10)).Append(T.CreateChecked(20)).AppendNull().Append(T.CreateChecked(30)));
         }
+#endif
 
         [Fact]
         public void SliceBooleanArray()
@@ -198,7 +200,9 @@ private class ArraySliceValidator :
             IArrowArrayVisitor<Date64Array>,
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
+#if NET5_0_OR_GREATER
             IArrowArrayVisitor<HalfFloatArray>,
+#endif
             IArrowArrayVisitor<FloatArray>,
             IArrowArrayVisitor<DoubleArray>,
             IArrowArrayVisitor<BooleanArray>,
@@ -240,7 +244,9 @@ public void Visit(Date64Array array)
             public void Visit(Time32Array array) => ValidateArrays(array);
             public void Visit(Time64Array array) => ValidateArrays(array);
 
+#if NET5_0_OR_GREATER
             public void Visit(HalfFloatArray array) => ValidateArrays(array);
+#endif
             public void Visit(FloatArray array) => ValidateArrays(array);
             public void Visit(DoubleArray array) => ValidateArrays(array);
             public void Visit(StringArray array) => ValidateArrays(array);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
index acfe72f83195e..543b446bba876 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
@@ -74,7 +74,9 @@ private class ArrayComparer :
             IArrowArrayVisitor<UInt16Array>,
             IArrowArrayVisitor<UInt32Array>,
             IArrowArrayVisitor<UInt64Array>,
+#if NET5_0_OR_GREATER
             IArrowArrayVisitor<HalfFloatArray>,
+#endif
             IArrowArrayVisitor<FloatArray>,
             IArrowArrayVisitor<DoubleArray>,
             IArrowArrayVisitor<BooleanArray>,
@@ -112,7 +114,9 @@ public ArrayComparer(IArrowArray expectedArray, bool strictCompare)
             public void Visit(UInt16Array array) => CompareArrays(array);
             public void Visit(UInt32Array array) => CompareArrays(array);
             public void Visit(UInt64Array array) => CompareArrays(array);
+#if NET5_0_OR_GREATER
             public void Visit(HalfFloatArray array) => CompareArrays(array);
+#endif
             public void Visit(FloatArray array) => CompareArrays(array);
             public void Visit(DoubleArray array) => CompareArrays(array);
             public void Visit(BooleanArray array) => CompareArrays(array);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowStreamReaderTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowStreamReaderTests.cs
index 0e8c9d6687a02..ed030cc6ace11 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowStreamReaderTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowStreamReaderTests.cs
@@ -224,6 +224,7 @@ private class PartialReadStream : MemoryStream
             // by default return 20 bytes at a time
             public int PartialReadLength { get; set; } = 20;
 
+#if NET5_0_OR_GREATER
             public override int Read(Span<byte> destination)
             {
                 if (destination.Length > PartialReadLength)
@@ -243,6 +244,17 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT
 
                 return base.ReadAsync(destination, cancellationToken);
             }
+#else
+            public override int Read(byte[] buffer, int offset, int length)
+            {
+                return base.Read(buffer, offset, Math.Min(length, PartialReadLength));
+            }
+
+            public override Task<int> ReadAsync(byte[] buffer, int offset, int length, CancellationToken cancellationToken = default)
+            {
+                return base.ReadAsync(buffer, offset, Math.Min(length, PartialReadLength), cancellationToken);
+            }
+#endif
         }
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfaceDataTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfaceDataTests.cs
index a430e140cfc2a..2bd4d4d661942 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfaceDataTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfaceDataTests.cs
@@ -47,7 +47,7 @@ public unsafe void InitializeArrayZeroed()
             Assert.True(cArray->buffers == null);
             Assert.True(cArray->children == null);
             Assert.True(cArray->dictionary == null);
-            Assert.True(cArray->release == null);
+            Assert.True(cArray->release == default);
             Assert.True(cArray->private_data == null);
 
             CArrowArray.Free(cArray);
@@ -59,12 +59,13 @@ public unsafe void CallsReleaseForValid()
             IArrowArray array = GetTestArray();
             CArrowArray* cArray = CArrowArray.Create();
             CArrowArrayExporter.ExportArray(array, cArray);
-            Assert.False(cArray->release == null);
+            Assert.False(cArray->release == default);
             CArrowArrayImporter.ImportArray(cArray, array.Data.DataType).Dispose();
-            Assert.True(cArray->release == null);
+            Assert.True(cArray->release == default);
             CArrowArray.Free(cArray);
         }
 
+#if NET5_0_OR_GREATER
         [Fact]
         public unsafe void CallsReleaseForInvalid()
         {
@@ -75,7 +76,7 @@ public unsafe void CallsReleaseForInvalid()
             var releaseCallback = (CArrowArray* cArray) =>
             {
                 wasCalled = true;
-                cArray->release = null;
+                cArray->release = default;
             };
             cArray->release = (delegate* unmanaged<CArrowArray*, void>)Marshal.GetFunctionPointerForDelegate(
                 releaseCallback);
@@ -90,5 +91,6 @@ public unsafe void CallsReleaseForInvalid()
 
             GC.KeepAlive(releaseCallback);
         }
+#endif
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 084d7bfb014cc..4c53b98e3d9f1 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -28,31 +28,39 @@
 
 namespace Apache.Arrow.Tests
 {
-    public class CDataSchemaPythonTest
+    public class CDataSchemaPythonTest : IClassFixture<CDataSchemaPythonTest.PythonNet>
     {
-        public CDataSchemaPythonTest()
+        class PythonNet : IDisposable
         {
-            bool inCIJob = Environment.GetEnvironmentVariable("GITHUB_ACTIONS") == "true";
-            bool inVerificationJob = Environment.GetEnvironmentVariable("TEST_CSHARP") == "1";
-            bool pythonSet = Environment.GetEnvironmentVariable("PYTHONNET_PYDLL") != null;
-            // We only skip if this is not in CI
-            if (inCIJob && !inVerificationJob && !pythonSet)
+            public PythonNet()
             {
-                throw new Exception("PYTHONNET_PYDLL not set; skipping C Data Interface tests.");
-            }
-            else
-            {
-                Skip.If(!pythonSet, "PYTHONNET_PYDLL not set; skipping C Data Interface tests.");
-            }
+                bool inCIJob = Environment.GetEnvironmentVariable("GITHUB_ACTIONS") == "true";
+                bool inVerificationJob = Environment.GetEnvironmentVariable("TEST_CSHARP") == "1";
+                bool pythonSet = Environment.GetEnvironmentVariable("PYTHONNET_PYDLL") != null;
+                // We only skip if this is not in CI
+                if (inCIJob && !inVerificationJob && !pythonSet)
+                {
+                    throw new Exception("PYTHONNET_PYDLL not set; skipping C Data Interface tests.");
+                }
+                else
+                {
+                    Skip.If(!pythonSet, "PYTHONNET_PYDLL not set; skipping C Data Interface tests.");
+                }
+
 
+                PythonEngine.Initialize();
 
-            PythonEngine.Initialize();
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
+                    PythonEngine.PythonPath.IndexOf("dlls", StringComparison.OrdinalIgnoreCase) < 0)
+                {
+                    dynamic sys = Py.Import("sys");
+                    sys.path.append(Path.Combine(Path.GetDirectoryName(Environment.GetEnvironmentVariable("PYTHONNET_PYDLL")), "DLLs"));
+                }
+            }
 
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
-                !PythonEngine.PythonPath.Contains("dlls", StringComparison.OrdinalIgnoreCase))
+            public void Dispose()
             {
-                dynamic sys = Py.Import("sys");
-                sys.path.append(Path.Combine(Path.GetDirectoryName(Environment.GetEnvironmentVariable("PYTHONNET_PYDLL")), "DLLs"));
+                PythonEngine.Shutdown();
             }
         }
 
@@ -360,7 +368,7 @@ public unsafe void ExportType()
                 }
 
                 // Python should have called release once `exportedPyType` went out-of-scope.
-                Assert.True(cSchema->release == null);
+                Assert.True(cSchema->release == default);
                 Assert.True(cSchema->format == null);
                 Assert.Equal(0, cSchema->flags);
                 Assert.Equal(0, cSchema->n_children);
@@ -395,7 +403,7 @@ public unsafe void ExportField()
 
                 // Python should have called release once `exportedPyField` went out-of-scope.
                 Assert.True(cSchema->name == null);
-                Assert.True(cSchema->release == null);
+                Assert.True(cSchema->release == default);
                 Assert.True(cSchema->format == null);
 
                 // Since we allocated, we are responsible for freeing the pointer.
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfaceSchemaTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfaceSchemaTests.cs
index dfd6f9912cd4d..4aa5eb6b4d7ed 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfaceSchemaTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfaceSchemaTests.cs
@@ -35,7 +35,7 @@ public unsafe void InitializeZeroed()
             Assert.Equal(0, cSchema->n_children);
             Assert.True(cSchema->children == null);
             Assert.True(cSchema->dictionary == null);
-            Assert.True(cSchema->release == null);
+            Assert.True(cSchema->release == default);
             Assert.True(cSchema->private_data == null);
 
             CArrowSchema.Free(cSchema);
@@ -86,12 +86,13 @@ public unsafe void CallsReleaseForValid()
         {
             CArrowSchema* cSchema = CArrowSchema.Create();
             CArrowSchemaExporter.ExportType(Int32Type.Default, cSchema);
-            Assert.False(cSchema->release == null);
+            Assert.False(cSchema->release == default);
             CArrowSchemaImporter.ImportType(cSchema);
-            Assert.True(cSchema->release == null);
+            Assert.True(cSchema->release == default);
             CArrowSchema.Free(cSchema);
         }
 
+#if NET5_0_OR_GREATER // can't round-trip marshaled delegate
         [Fact]
         public unsafe void CallsReleaseForInvalid()
         {
@@ -103,7 +104,7 @@ public unsafe void CallsReleaseForInvalid()
             var releaseCallback = (CArrowSchema* cSchema) =>
             {
                 wasCalled = true;
-                cSchema->release = null;
+                cSchema->release = default;
             };
             cSchema->release = (delegate* unmanaged<CArrowSchema*, void>)Marshal.GetFunctionPointerForDelegate(
                 releaseCallback);
@@ -117,5 +118,6 @@ public unsafe void CallsReleaseForInvalid()
 
             GC.KeepAlive(releaseCallback);
         }
+#endif
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/Extensions/Net472Extensions.cs b/csharp/test/Apache.Arrow.Tests/Extensions/Net472Extensions.cs
new file mode 100644
index 0000000000000..0b298dec414c0
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/Extensions/Net472Extensions.cs
@@ -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.
+
+using System.Collections.Generic;
+
+namespace Apache.Arrow.Tests
+{
+    internal static class Net472Extensions
+    {
+        public static IEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)
+        {
+            using (var enumerator1 = first.GetEnumerator())
+            using (var enumerator2 = second.GetEnumerator())
+            {
+                while (enumerator1.MoveNext() && enumerator2.MoveNext())
+                {
+                    yield return (enumerator1.Current, enumerator2.Current);
+                }
+            }
+        }
+    }
+}

From a2a3b9580d66cf40c5df8358f260fdaf5ccc301f Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Sat, 22 Jul 2023 02:16:16 -0300
Subject: [PATCH 024/749] GH-36708: [C++] Fully calculate null-counts so the
 REE allocations make sense (#36740)

### Rationale for this change

When `has_validity_buffer` is true, we expect validity buffers to be allocated, but if null_count is calculated and ends up being 0, `ArrayData::Make()` will sneakily remove the validity buffer from the physical array for us and the assumption that it exists stops holding and causes a crash.

Forcing `null_count` calculation with `input.GetNullCount()` ensures `has_validity_buffer` won't be `true` if the `null_count` on the input ends up being 0.

### What changes are included in this PR?

The fix and tests to reproduce it.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36708

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../compute/kernels/ree_util_internal.cc      |  18 ++--
 .../arrow/compute/kernels/ree_util_internal.h |  27 ++++-
 .../compute/kernels/vector_run_end_encode.cc  |  25 +++--
 .../kernels/vector_run_end_encode_test.cc     | 102 +++++++++++-------
 4 files changed, 113 insertions(+), 59 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/ree_util_internal.cc b/cpp/src/arrow/compute/kernels/ree_util_internal.cc
index 00c885f6fa9db..d35c000678ba4 100644
--- a/cpp/src/arrow/compute/kernels/ree_util_internal.cc
+++ b/cpp/src/arrow/compute/kernels/ree_util_internal.cc
@@ -59,7 +59,7 @@ Result<std::shared_ptr<ArrayData>> PreallocateRunEndsArray(
 
 Result<std::shared_ptr<ArrayData>> PreallocateValuesArray(
     const std::shared_ptr<DataType>& value_type, bool has_validity_buffer, int64_t length,
-    int64_t null_count, MemoryPool* pool, int64_t data_buffer_size) {
+    MemoryPool* pool, int64_t data_buffer_size) {
   std::vector<std::shared_ptr<Buffer>> values_data_buffers;
   std::shared_ptr<Buffer> validity_buffer = NULLPTR;
   if (has_validity_buffer) {
@@ -79,20 +79,22 @@ Result<std::shared_ptr<ArrayData>> PreallocateValuesArray(
   } else {
     values_data_buffers = {std::move(validity_buffer), std::move(values_buffer)};
   }
-  return ArrayData::Make(value_type, length, std::move(values_data_buffers), null_count);
+  auto data = ArrayData::Make(value_type, length, std::move(values_data_buffers),
+                              kUnknownNullCount);
+  DCHECK(!(has_validity_buffer && length > 0) || data->buffers[0]);
+  return data;
 }
 
 Result<std::shared_ptr<ArrayData>> PreallocateREEArray(
     std::shared_ptr<RunEndEncodedType> ree_type, bool has_validity_buffer,
-    int64_t logical_length, int64_t physical_length, int64_t physical_null_count,
-    MemoryPool* pool, int64_t data_buffer_size) {
+    int64_t logical_length, int64_t physical_length, MemoryPool* pool,
+    int64_t data_buffer_size) {
   ARROW_ASSIGN_OR_RAISE(
       auto run_ends_data,
       PreallocateRunEndsArray(ree_type->run_end_type(), physical_length, pool));
-  ARROW_ASSIGN_OR_RAISE(
-      auto values_data,
-      PreallocateValuesArray(ree_type->value_type(), has_validity_buffer, physical_length,
-                             physical_null_count, pool, data_buffer_size));
+  ARROW_ASSIGN_OR_RAISE(auto values_data, PreallocateValuesArray(
+                                              ree_type->value_type(), has_validity_buffer,
+                                              physical_length, pool, data_buffer_size));
 
   return ArrayData::Make(std::move(ree_type), logical_length, {NULLPTR},
                          {std::move(run_ends_data), std::move(values_data)},
diff --git a/cpp/src/arrow/compute/kernels/ree_util_internal.h b/cpp/src/arrow/compute/kernels/ree_util_internal.h
index 080d23c06a1f9..3293e754d3b65 100644
--- a/cpp/src/arrow/compute/kernels/ree_util_internal.h
+++ b/cpp/src/arrow/compute/kernels/ree_util_internal.h
@@ -333,18 +333,39 @@ Result<std::shared_ptr<ArrayData>> PreallocateRunEndsArray(
     const std::shared_ptr<DataType>& run_end_type, int64_t physical_length,
     MemoryPool* pool);
 
+/// \brief Preallocate the physical values array for a run-end encoded array
+///
+/// data_buffer_size is passed here pre-calculated so this function doesn't have
+/// to be template-specialized for each type.
+///
+/// The null_count is left as kUnknownNullCount (or 0 if length is 0) and, if
+/// after writing the values, the caller knows the null count, it can be set.
+///
+/// \post if has_validity_buffer and length > 0, then data.buffer[0] != NULLPTR
+///
+/// \param has_validity_buffer a validity buffer must be allocated
+/// \param length the length of the values array
+/// \param data_buffer_size the size of the data buffer for string and binary types
 Result<std::shared_ptr<ArrayData>> PreallocateValuesArray(
     const std::shared_ptr<DataType>& value_type, bool has_validity_buffer, int64_t length,
-    int64_t null_count, MemoryPool* pool, int64_t data_buffer_size);
+    MemoryPool* pool, int64_t data_buffer_size);
 
 /// \brief Preallocate the ArrayData for the run-end encoded version
 /// of the flat input array
 ///
+/// The top-level null_count is set to 0 (REEs keep all the data in child
+/// arrays). The null_count of the values array (child_data[1]) is left as
+/// kUnknownNullCount (or 0 if physical_length is 0) and, if after writing
+/// the values, the caller knows the null count, it can be set.
+///
+/// \post if has_validity_buffer and physical_length > 0, then
+/// data.child_data[1].buffer[0] != NULLPTR
+///
 /// \param data_buffer_size the size of the data buffer for string and binary types
 Result<std::shared_ptr<ArrayData>> PreallocateREEArray(
     std::shared_ptr<RunEndEncodedType> ree_type, bool has_validity_buffer,
-    int64_t logical_length, int64_t physical_length, int64_t physical_null_count,
-    MemoryPool* pool, int64_t data_buffer_size);
+    int64_t logical_length, int64_t physical_length, MemoryPool* pool,
+    int64_t data_buffer_size);
 
 /// \brief Writes a single run-end to the first slot of the pre-allocated
 /// run-end encoded array in out
diff --git a/cpp/src/arrow/compute/kernels/vector_run_end_encode.cc b/cpp/src/arrow/compute/kernels/vector_run_end_encode.cc
index eef816a149c93..943fdcd6b147f 100644
--- a/cpp/src/arrow/compute/kernels/vector_run_end_encode.cc
+++ b/cpp/src/arrow/compute/kernels/vector_run_end_encode.cc
@@ -179,7 +179,9 @@ class RunEndEncodeImpl {
       ARROW_ASSIGN_OR_RAISE(
           auto output_array_data,
           ree_util::PreallocateREEArray(std::move(ree_type), has_validity_buffer,
-                                        input_length, 0, 0, ctx_->memory_pool(), 0));
+                                        /*logical_length=*/input_length,
+                                        /*physical_length=*/0, ctx_->memory_pool(),
+                                        /*data_buffer_size=*/0));
       output_->value = std::move(output_array_data);
       return Status::OK();
     }
@@ -196,17 +198,22 @@ class RunEndEncodeImpl {
         /*output_run_ends=*/NULLPTR);
     std::tie(num_valid_runs, num_output_runs, data_buffer_size) =
         counting_loop.CountNumberOfRuns();
+    const auto physical_null_count = num_output_runs - num_valid_runs;
+    DCHECK(!has_validity_buffer || physical_null_count > 0)
+        << "has_validity_buffer is expected to imply physical_null_count > 0";
 
     ARROW_ASSIGN_OR_RAISE(
         auto output_array_data,
         ree_util::PreallocateREEArray(
-            std::move(ree_type), has_validity_buffer, input_length, num_output_runs,
-            num_output_runs - num_valid_runs, ctx_->memory_pool(), data_buffer_size));
+            std::move(ree_type), has_validity_buffer, /*logical_length=*/input_length,
+            /*physical_length=*/num_output_runs, ctx_->memory_pool(), data_buffer_size));
 
     // Initialize the output pointers
     auto* output_run_ends =
         output_array_data->child_data[0]->template GetMutableValues<RunEndCType>(1, 0);
     auto* output_values_array_data = output_array_data->child_data[1].get();
+    // Set the null_count on the physical array
+    output_values_array_data->null_count = physical_null_count;
 
     // Second pass: write the runs
     RunEndEncodingLoop<RunEndType, ValueType, has_validity_buffer> writing_loop(
@@ -254,7 +261,7 @@ struct RunEndEncodeExec {
       return RunEndEncodeNullArray(TypeTraits<RunEndType>::type_singleton(), ctx,
                                    input_array, result);
     } else {
-      const bool has_validity_buffer = input_array.MayHaveNulls();
+      const bool has_validity_buffer = input_array.GetNullCount() > 0;
       if (has_validity_buffer) {
         return RunEndEncodeImpl<RunEndType, ValueType, true>(ctx, input_array, result)
             .Exec();
@@ -398,10 +405,10 @@ class RunEndDecodeImpl {
       }
     }
 
-    ARROW_ASSIGN_OR_RAISE(auto output_array_data,
-                          ree_util::PreallocateValuesArray(
-                              ree_type->value_type(), has_validity_buffer, length,
-                              kUnknownNullCount, ctx_->memory_pool(), data_buffer_size));
+    ARROW_ASSIGN_OR_RAISE(
+        auto output_array_data,
+        ree_util::PreallocateValuesArray(ree_type->value_type(), has_validity_buffer,
+                                         length, ctx_->memory_pool(), data_buffer_size));
 
     int64_t output_null_count = 0;
     if (length > 0) {
@@ -435,7 +442,7 @@ struct RunEndDecodeExec {
       return RunEndDecodeNullREEArray(ctx, input_array, result);
     } else {
       const bool has_validity_buffer =
-          arrow::ree_util::ValuesArray(input_array).MayHaveNulls();
+          arrow::ree_util::ValuesArray(input_array).GetNullCount() > 0;
       if (has_validity_buffer) {
         return RunEndDecodeImpl<RunEndType, ValueType, true>(ctx, input_array, result)
             .Exec();
diff --git a/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc b/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
index f718d82774dcd..0bd8e3386e7cc 100644
--- a/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_run_end_encode_test.cc
@@ -72,11 +72,19 @@ struct REETestData {
                                  std::vector<std::string> inputs_json,
                                  std::vector<std::string> expected_values_json,
                                  std::vector<std::string> expected_run_ends_json,
-                                 int64_t input_offset = 0) {
+                                 int64_t input_offset = 0,
+                                 bool force_validity_bitmap = false) {
     std::vector<std::shared_ptr<Array>> inputs;
     inputs.reserve(inputs_json.size());
     for (const auto& input_json : inputs_json) {
-      inputs.push_back(ArrayFromJSON(data_type, input_json));
+      auto chunk = ArrayFromJSON(data_type, input_json);
+      auto& data = chunk->data();
+      if (force_validity_bitmap && !data->HasValidityBitmap()) {
+        EXPECT_OK_AND_ASSIGN(auto validity, AllocateBitmap(data->length));
+        memset(validity->mutable_data(), 0xFF, validity->size());
+        data->buffers[0] = std::move(validity);
+      }
+      inputs.push_back(std::move(chunk));
     }
     auto chunked_input = std::make_shared<ChunkedArray>(std::move(inputs));
 
@@ -165,47 +173,52 @@ class TestRunEndEncodeDecode : public ::testing::TestWithParam<
     DCHECK(datum.is_chunked_array());
     return datum.chunked_array();
   }
-};
-
-TEST_P(TestRunEndEncodeDecode, EncodeDecodeArray) {
-  auto [data, run_end_type] = GetParam();
 
-  ASSERT_OK_AND_ASSIGN(
-      Datum encoded_datum,
-      RunEndEncode(data.InputDatum(), RunEndEncodeOptions{run_end_type}));
-
-  auto encoded = AsChunkedArray(encoded_datum);
-  ASSERT_OK(encoded->ValidateFull());
-  ASSERT_EQ(data.input->length(), encoded->length());
+  void TestEncodeDecodeArray(REETestData& data,
+                             const std::shared_ptr<DataType>& run_end_type) {
+    ASSERT_OK_AND_ASSIGN(
+        Datum encoded_datum,
+        RunEndEncode(data.InputDatum(), RunEndEncodeOptions{run_end_type}));
+
+    auto encoded = AsChunkedArray(encoded_datum);
+    ASSERT_OK(encoded->ValidateFull());
+    ASSERT_EQ(data.input->length(), encoded->length());
+
+    for (int i = 0; i < encoded->num_chunks(); i++) {
+      auto& chunk = encoded->chunk(i);
+      auto run_ends_array = MakeArray(chunk->data()->child_data[0]);
+      auto values_array = MakeArray(chunk->data()->child_data[1]);
+      ASSERT_OK(chunk->ValidateFull());
+      ASSERT_ARRAYS_EQUAL(*ArrayFromJSON(run_end_type, data.expected_run_ends_json[i]),
+                          *run_ends_array);
+      ASSERT_ARRAYS_EQUAL(*values_array, *data.expected_values[i]);
+      ASSERT_EQ(chunk->data()->buffers.size(), 1);
+      ASSERT_EQ(chunk->data()->buffers[0], NULLPTR);
+      ASSERT_EQ(chunk->data()->child_data.size(), 2);
+      ASSERT_EQ(run_ends_array->data()->buffers[0], NULLPTR);
+      ASSERT_EQ(run_ends_array->length(), data.expected_values[i]->length());
+      ASSERT_EQ(run_ends_array->offset(), 0);
+      ASSERT_EQ(chunk->data()->length, data.input->chunk(i)->length());
+      ASSERT_EQ(chunk->data()->offset, 0);
+      ASSERT_EQ(*chunk->data()->type,
+                RunEndEncodedType(run_end_type, data.input->type()));
+      ASSERT_EQ(chunk->data()->null_count, 0);
+    }
 
-  for (int i = 0; i < encoded->num_chunks(); i++) {
-    auto& chunk = encoded->chunk(i);
-    auto run_ends_array = MakeArray(chunk->data()->child_data[0]);
-    auto values_array = MakeArray(chunk->data()->child_data[1]);
-    ASSERT_OK(chunk->ValidateFull());
-    ASSERT_ARRAYS_EQUAL(*ArrayFromJSON(run_end_type, data.expected_run_ends_json[i]),
-                        *run_ends_array);
-    ASSERT_ARRAYS_EQUAL(*values_array, *data.expected_values[i]);
-    ASSERT_EQ(chunk->data()->buffers.size(), 1);
-    ASSERT_EQ(chunk->data()->buffers[0], NULLPTR);
-    ASSERT_EQ(chunk->data()->child_data.size(), 2);
-    ASSERT_EQ(run_ends_array->data()->buffers[0], NULLPTR);
-    ASSERT_EQ(run_ends_array->length(), data.expected_values[i]->length());
-    ASSERT_EQ(run_ends_array->offset(), 0);
-    ASSERT_EQ(chunk->data()->length, data.input->chunk(i)->length());
-    ASSERT_EQ(chunk->data()->offset, 0);
-    ASSERT_EQ(*chunk->data()->type, RunEndEncodedType(run_end_type, data.input->type()));
-    ASSERT_EQ(chunk->data()->null_count, 0);
+    ASSERT_OK_AND_ASSIGN(Datum decoded_datum, data.chunked
+                                                  ? RunEndDecode(encoded)
+                                                  : RunEndDecode(encoded->chunk(0)));
+    auto decoded = AsChunkedArray(decoded_datum);
+    ASSERT_OK(decoded->ValidateFull());
+    for (int i = 0; i < decoded->num_chunks(); i++) {
+      ASSERT_ARRAYS_EQUAL(*decoded->chunk(i), *data.input->chunk(i));
+    }
   }
+};
 
-  ASSERT_OK_AND_ASSIGN(Datum decoded_datum, data.chunked
-                                                ? RunEndDecode(encoded)
-                                                : RunEndDecode(encoded->chunk(0)));
-  auto decoded = AsChunkedArray(decoded_datum);
-  ASSERT_OK(decoded->ValidateFull());
-  for (int i = 0; i < decoded->num_chunks(); i++) {
-    ASSERT_ARRAYS_EQUAL(*decoded->chunk(i), *data.input->chunk(i));
-  }
+TEST_P(TestRunEndEncodeDecode, EncodeDecodeArray) {
+  auto [data, run_end_type] = GetParam();
+  TestEncodeDecodeArray(data, run_end_type);
 }
 
 // Encoding an input with an offset results in a completely new encoded array without an
@@ -254,6 +267,17 @@ TEST_P(TestRunEndEncodeDecode, DecodeWithOffset) {
   }
 }
 
+// GH-36708
+TEST_P(TestRunEndEncodeDecode, InputWithValidityAndNoNulls) {
+  auto data =
+      REETestData::JSONChunked(int32(),
+                               /*inputs=*/{"[1, 1, 2, 2, 2, 3]", "[4, 5, 5, 5, 6, 6]"},
+                               /*expected_values=*/{"[1, 2, 3]", "[4, 5, 6]"},
+                               /*expected_run_ends=*/{"[2, 5, 6]", "[1, 4, 6]"},
+                               /*input_offset=*/0, /*force_validity_bitmap=*/true);
+  TestEncodeDecodeArray(data, int32());
+}
+
 // This test creates an run-end encoded array with an offset in the child array, which
 // removes the first run in the test data. It's no-op for chunked input.
 TEST_P(TestRunEndEncodeDecode, DecodeWithOffsetInChildArray) {

From de1e40f5270e819191a319678653d0a4c0749181 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Mon, 24 Jul 2023 09:36:11 +0800
Subject: [PATCH 025/749] MINOR: [Doc] Fix columnar.rst buffer layout table
 inconsistencies (#36822)

### Rationale for this change

1. Some buffer layouts write out "padding" explicitly while some don't. I believe writing it out is help to distinguish paddings and null values.
2. Most cells start with a space while some don't.

### What changes are included in this PR?

Fixed the above two inconsistencies.
### Are these changes tested?
No need.

### Are there any user-facing changes?
No.

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/format/Columnar.rst | 132 ++++++++++++++++----------------
 1 file changed, 66 insertions(+), 66 deletions(-)

diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst
index b90e2c97ade73..3390f1b7b5f2c 100644
--- a/docs/source/format/Columnar.rst
+++ b/docs/source/format/Columnar.rst
@@ -256,15 +256,15 @@ Would look like: ::
     * Length: 5, Null count: 1
     * Validity bitmap buffer:
 
-      |Byte 0 (validity bitmap) | Bytes 1-63            |
-      |-------------------------|-----------------------|
-      | 00011101                | 0 (padding)           |
+      | Byte 0 (validity bitmap) | Bytes 1-63            |
+      |--------------------------|-----------------------|
+      | 00011101                 | 0 (padding)           |
 
     * Value Buffer:
 
-      |Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63 |
-      |------------|-------------|-------------|-------------|-------------|-------------|
-      | 1          | unspecified | 2           | 4           | 8           | unspecified |
+      | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63           |
+      |-------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 1           | unspecified | 2           | 4           | 8           | unspecified (padding) |
 
 **Example Layout: Non-null int32 Array**
 
@@ -279,9 +279,9 @@ Would look like: ::
 
     * Value Buffer:
 
-      |Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | bytes 12-15 | bytes 16-19 | Bytes 20-63 |
-      |------------|-------------|-------------|-------------|-------------|-------------|
-      | 1          | 2           | 3           | 4           | 8           | unspecified |
+      | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63           |
+      |-------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 1           | 2           | 3           | 4           | 8           | unspecified (padding) |
 
 or with the bitmap elided: ::
 
@@ -289,9 +289,9 @@ or with the bitmap elided: ::
     * Validity bitmap buffer: Not required
     * Value Buffer:
 
-      |Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | bytes 12-15 | bytes 16-19 | Bytes 20-63 |
-      |------------|-------------|-------------|-------------|-------------|-------------|
-      | 1          | 2           | 3           | 4           | 8           | unspecified |
+      | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | bytes 12-15 | bytes 16-19 | Bytes 20-63           |
+      |-------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 1           | 2           | 3           | 4           | 8           | unspecified (padding) |
 
 Variable-size Binary Layout
 ---------------------------
@@ -342,13 +342,13 @@ will be represented as follows: ::
 
     | Bytes 0-19     | Bytes 20-63           |
     |----------------|-----------------------|
-    | 0, 3, 3, 3, 7  | unspecified           |
+    | 0, 3, 3, 3, 7  | unspecified (padding) |
 
    * Value buffer:
 
-    | Bytes 0-6      | Bytes 7-63           |
-    |----------------|----------------------|
-    | joemark        | unspecified          |
+    | Bytes 0-6      | Bytes 7-63            |
+    |----------------|-----------------------|
+    | joemark        | unspecified (padding) |
 
 .. _variable-size-list-layout:
 
@@ -388,18 +388,18 @@ will have the following representation: ::
 
     * Offsets buffer (int32)
 
-      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63 |
-      |------------|-------------|-------------|-------------|-------------|-------------|
-      | 0          | 3           | 3           | 7           | 7           | unspecified |
+      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63           |
+      |------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 0          | 3           | 3           | 7           | 7           | unspecified (padding) |
 
     * Values array (Int8array):
       * Length: 7,  Null count: 0
       * Validity bitmap buffer: Not required
       * Values buffer (int8)
 
-        | Bytes 0-6                    | Bytes 7-63  |
-        |------------------------------|-------------|
-        | 12, -7, 25, 0, -127, 127, 50 | unspecified |
+        | Bytes 0-6                    | Bytes 7-63            |
+        |------------------------------|-----------------------|
+        | 12, -7, 25, 0, -127, 127, 50 | unspecified (padding) |
 
 **Example Layout: ``List<List<Int8>>``**
 
@@ -412,9 +412,9 @@ will be represented as follows: ::
     * Validity bitmap buffer: Not required
     * Offsets buffer (int32)
 
-      | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 | Bytes 16-63 |
-      |------------|------------|------------|-------------|-------------|
-      | 0          |  2         |  5         |  6          | unspecified |
+      | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 | Bytes 16-63           |
+      |------------|------------|------------|-------------|-----------------------|
+      | 0          |  2         |  5         |  6          | unspecified (padding) |
 
     * Values array (`List<Int8>`)
       * Length: 6, Null count: 1
@@ -426,17 +426,17 @@ will be represented as follows: ::
 
       * Offsets buffer (int32)
 
-        | Bytes 0-27           | Bytes 28-63 |
-        |----------------------|-------------|
-        | 0, 2, 4, 7, 7, 8, 10 | unspecified |
+        | Bytes 0-27           | Bytes 28-63           |
+        |----------------------|-----------------------|
+        | 0, 2, 4, 7, 7, 8, 10 | unspecified (padding) |
 
       * Values array (Int8):
         * Length: 10, Null count: 0
         * Validity bitmap buffer: Not required
 
-          | Bytes 0-9                     | Bytes 10-63 |
-          |-------------------------------|-------------|
-          | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | unspecified |
+          | Bytes 0-9                     | Bytes 10-63           |
+          |-------------------------------|-----------------------|
+          | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | unspecified (padding) |
 
 Fixed-Size List Layout
 ----------------------
@@ -511,9 +511,9 @@ The layout for ``[{'joe', 1}, {null, 2}, null, {'mark', 4}]`` would be: ::
     * Length: 4, Null count: 1
     * Validity bitmap buffer:
 
-      |Byte 0 (validity bitmap) | Bytes 1-63            |
-      |-------------------------|-----------------------|
-      | 00001011                | 0 (padding)           |
+      | Byte 0 (validity bitmap) | Bytes 1-63            |
+      |--------------------------|-----------------------|
+      | 00001011                 | 0 (padding)           |
 
     * Children arrays:
       * field-0 array (`VarBinary`):
@@ -528,13 +528,13 @@ The layout for ``[{'joe', 1}, {null, 2}, null, {'mark', 4}]`` would be: ::
 
           | Bytes 0-19     | Bytes 20-63           |
           |----------------|-----------------------|
-          | 0, 3, 3, 3, 7  | unspecified           |
+          | 0, 3, 3, 3, 7  | unspecified (padding) |
 
          * Value buffer:
 
           | Bytes 0-6      | Bytes 7-63            |
           |----------------|-----------------------|
-          | joemark        | unspecified           |
+          | joemark        | unspecified (padding) |
 
       * field-1 array (int32 array):
         * Length: 4, Null count: 1
@@ -546,9 +546,9 @@ The layout for ``[{'joe', 1}, {null, 2}, null, {'mark', 4}]`` would be: ::
 
         * Value Buffer:
 
-          |Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-63 |
-          |------------|-------------|-------------|-------------|-------------|
-          | 1          | 2           | unspecified | 4           | unspecified |
+          | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-63           |
+          |-------------|-------------|-------------|-------------|-----------------------|
+          | 1           | 2           | unspecified | 4           | unspecified (padding) |
 
 Struct Validity
 ~~~~~~~~~~~~~~~
@@ -610,15 +610,15 @@ will have the following layout: ::
     * Length: 4, Null count: 0
     * Types buffer:
 
-      |Byte 0   | Byte 1      | Byte 2   | Byte 3   | Bytes 4-63  |
-      |---------|-------------|----------|----------|-------------|
-      | 0       | 0           | 0        | 1        | unspecified |
+      | Byte 0   | Byte 1      | Byte 2   | Byte 3   | Bytes 4-63            |
+      |----------|-------------|----------|----------|-----------------------|
+      | 0        | 0           | 0        | 1        | unspecified (padding) |
 
     * Offset buffer:
 
-      |Bytes 0-3 | Bytes 4-7   | Bytes 8-11 | Bytes 12-15 | Bytes 16-63 |
-      |----------|-------------|------------|-------------|-------------|
-      | 0        | 1           | 2          | 0           | unspecified |
+      | Bytes 0-3 | Bytes 4-7   | Bytes 8-11 | Bytes 12-15 | Bytes 16-63           |
+      |-----------|-------------|------------|-------------|-----------------------|
+      | 0         | 1           | 2          | 0           | unspecified (padding) |
 
     * Children arrays:
       * Field-0 array (f: Float32):
@@ -627,9 +627,9 @@ will have the following layout: ::
 
         * Value Buffer:
 
-          | Bytes 0-11     | Bytes 12-63  |
-          |----------------|-------------|
-          | 1.2, null, 3.4 | unspecified |
+          | Bytes 0-11     | Bytes 12-63           |
+          |----------------|-----------------------|
+          | 1.2, null, 3.4 | unspecified (padding) |
 
 
       * Field-1 array (i: Int32):
@@ -638,9 +638,9 @@ will have the following layout: ::
 
         * Value Buffer:
 
-          | Bytes 0-3 | Bytes 4-63  |
-          |-----------|-------------|
-          | 5         | unspecified |
+          | Bytes 0-3 | Bytes 4-63            |
+          |-----------|-----------------------|
+          | 5         | unspecified (padding) |
 
 Sparse Union
 ~~~~~~~~~~~~
@@ -677,29 +677,29 @@ will have the following layout: ::
         * Length: 6, Null count: 4
         * Validity bitmap buffer:
 
-          |Byte 0 (validity bitmap) | Bytes 1-63            |
-          |-------------------------|-----------------------|
-          |00010001                 | 0 (padding)           |
+          | Byte 0 (validity bitmap) | Bytes 1-63            |
+          |--------------------------|-----------------------|
+          | 00010001                 | 0 (padding)           |
 
         * Value buffer:
 
-          |Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23  | Bytes 24-63           |
-          |------------|-------------|-------------|-------------|-------------|--------------|-----------------------|
-          | 5          | unspecified | unspecified | unspecified | 4           |  unspecified | unspecified (padding) |
+          | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23  | Bytes 24-63           |
+          |-------------|-------------|-------------|-------------|-------------|--------------|-----------------------|
+          | 5           | unspecified | unspecified | unspecified | 4           |  unspecified | unspecified (padding) |
 
       * f (Float32):
         * Length: 6, Null count: 4
         * Validity bitmap buffer:
 
-          |Byte 0 (validity bitmap) | Bytes 1-63            |
-          |-------------------------|-----------------------|
-          | 00001010                | 0 (padding)           |
+          | Byte 0 (validity bitmap) | Bytes 1-63            |
+          |--------------------------|-----------------------|
+          | 00001010                 | 0 (padding)           |
 
         * Value buffer:
 
-          |Bytes 0-3    | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23  | Bytes 24-63           |
-          |-------------|-------------|-------------|-------------|-------------|--------------|-----------------------|
-          | unspecified |  1.2        | unspecified | 3.4         | unspecified |  unspecified | unspecified (padding) |
+          | Bytes 0-3    | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23 | Bytes 24-63           |
+          |--------------|-------------|-------------|-------------|-------------|-------------|-----------------------|
+          | unspecified  | 1.2         | unspecified | 3.4         | unspecified | unspecified | unspecified (padding) |
 
       * s (`VarBinary`)
         * Length: 6, Null count: 4
@@ -711,9 +711,9 @@ will have the following layout: ::
 
         * Offsets buffer (Int32)
 
-          | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23 | Bytes 24-27 | Bytes 28-63 |
-          |------------|-------------|-------------|-------------|-------------|-------------|-------------|-------------|
-          | 0          | 0           | 0           | 3           | 3           | 3           | 7           | unspecified |
+          | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-23 | Bytes 24-27 | Bytes 28-63            |
+          |------------|-------------|-------------|-------------|-------------|-------------|-------------|------------------------|
+          | 0          | 0           | 0           | 3           | 3           | 3           | 7           | unspecified (padding)  |
 
         * Values buffer:
 

From 22339a28ea0c736d18e43ae7e238e2ea580be2d2 Mon Sep 17 00:00:00 2001
From: lambda <1wei@live.com>
Date: Mon, 24 Jul 2023 09:38:33 +0800
Subject: [PATCH 026/749] MINOR: [Docs] Update document for AWS_ENDPOINT_URL
 environment variable (#36826)

### Rationale for this change
update document for AWS_ENDPOINT_URL environment variable

### What changes are included in this PR?
update document for AWS_ENDPOINT_URL environment variable

### Are these changes tested?

### Are there any user-facing changes?
No

Authored-by: yiwei.wang <yiwei.wang@weride.ai>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/cpp/env_vars.rst | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/source/cpp/env_vars.rst b/docs/source/cpp/env_vars.rst
index e8490735926c1..8d10fd2cc2e40 100644
--- a/docs/source/cpp/env_vars.rst
+++ b/docs/source/cpp/env_vars.rst
@@ -138,6 +138,10 @@ that changing their value later will have an effect.
       SIGILL (Illegal Instruction).  User must rebuild Arrow and PyArrow from
       scratch by setting cmake option ``ARROW_SIMD_LEVEL=NONE``.
 
+.. envvar:: AWS_ENDPOINT_URL
+
+   Endpoint URL used for S3-like storage, for example Minio or s3.scality.
+
 .. envvar:: GANDIVA_CACHE_SIZE
 
    The number of entries to keep in the Gandiva JIT compilation cache.

From 78bbe7676c1437a123f0ce3f4ba4089917f2be0a Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 24 Jul 2023 17:05:51 +0800
Subject: [PATCH 027/749] GH-36828: [C++][Parquet] Make buffered
 RowGroupSerializer using BufferedPageWriter (#36829)

### Rationale for this change

See https://github.com/apache/arrow/issues/36828

### What changes are included in this PR?

Add `buffered` argument when building `PageWriter`

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #36828

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
---
 cpp/src/parquet/file_writer.cc | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/cpp/src/parquet/file_writer.cc b/cpp/src/parquet/file_writer.cc
index ef86e742362b8..2a6a88df2dd0a 100644
--- a/cpp/src/parquet/file_writer.cc
+++ b/cpp/src/parquet/file_writer.cc
@@ -310,17 +310,17 @@ class RowGroupSerializer : public RowGroupWriter::Contents {
 
       std::unique_ptr<PageWriter> pager;
       if (!codec_options) {
-        pager = PageWriter::Open(sink_, properties_->compression(path), col_meta,
-                                 row_group_ordinal_, static_cast<int16_t>(column_ordinal),
-                                 properties_->memory_pool(), false, meta_encryptor,
-                                 data_encryptor, properties_->page_checksum_enabled(),
-                                 ci_builder, oi_builder, CodecOptions());
+        pager = PageWriter::Open(
+            sink_, properties_->compression(path), col_meta, row_group_ordinal_,
+            static_cast<int16_t>(column_ordinal), properties_->memory_pool(),
+            buffered_row_group_, meta_encryptor, data_encryptor,
+            properties_->page_checksum_enabled(), ci_builder, oi_builder, CodecOptions());
       } else {
-        pager = PageWriter::Open(sink_, properties_->compression(path), col_meta,
-                                 row_group_ordinal_, static_cast<int16_t>(column_ordinal),
-                                 properties_->memory_pool(), false, meta_encryptor,
-                                 data_encryptor, properties_->page_checksum_enabled(),
-                                 ci_builder, oi_builder, *codec_options);
+        pager = PageWriter::Open(
+            sink_, properties_->compression(path), col_meta, row_group_ordinal_,
+            static_cast<int16_t>(column_ordinal), properties_->memory_pool(),
+            buffered_row_group_, meta_encryptor, data_encryptor,
+            properties_->page_checksum_enabled(), ci_builder, oi_builder, *codec_options);
       }
       column_writers_.push_back(
           ColumnWriter::Make(col_meta, std::move(pager), properties_));

From fdf392d48e79253838c4ff2e1d2bd127cdf8fead Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 24 Jul 2023 12:09:22 +0100
Subject: [PATCH 028/749] MINOR: [R] Bump versions following 12.0.1.1 release
 (#36801)

### Rationale for this change

Bumping version numbers after 12.0.1.1 release (this is a manual process for CRAN-only releases)

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/pkgdown/assets/versions.html | 5 +++--
 r/pkgdown/assets/versions.json | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/r/pkgdown/assets/versions.html b/r/pkgdown/assets/versions.html
index 9c80c32735a85..31f393a27785d 100644
--- a/r/pkgdown/assets/versions.html
+++ b/r/pkgdown/assets/versions.html
@@ -1,7 +1,8 @@
 <!DOCTYPE html>
 <html>
-<body><p><a href="../dev/r/">11.0.0.9000 (dev)</a></p>
-<p><a href="../r/">11.0.0 (release)</a></p>
+<body><p><a href="../dev/r/">12.0.1.9000 (dev)</a></p>
+<p><a href="../r/">12.0.1.1 (release)</a></p>
+<p><a href="../11.0/r/">11.0.0.3</a></p>
 <p><a href="../10.0/r/">10.0.1</a></p>
 <p><a href="../9.0/r/">9.0.0</a></p>
 <p><a href="../8.0/r/">8.0.0</a></p>
diff --git a/r/pkgdown/assets/versions.json b/r/pkgdown/assets/versions.json
index c7500309b22df..4d7658e6e5e25 100644
--- a/r/pkgdown/assets/versions.json
+++ b/r/pkgdown/assets/versions.json
@@ -4,7 +4,7 @@
         "version": "dev/"
     },
     {
-        "name": "12.0.1 (release)",
+        "name": "12.0.1.1 (release)",
         "version": ""
     },
     {

From a9f100c690ed8608142ec3d9af043b66a41543e0 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 24 Jul 2023 12:16:40 +0100
Subject: [PATCH 029/749] GH-36805: [R] Update NEWS.md for 13.0.0 (#36806)

### Rationale for this change

Update NEWS.md for 13.0.0
* Closes: #36805

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NEWS.md | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/r/NEWS.md b/r/NEWS.md
index 45730a7b36018..6d09355170a67 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -19,6 +19,36 @@
 
 # arrow 12.0.1.9000
 
+## New features
+
+* `open_dataset()` now works with ND-JSON files (#35055)
+* Calling `schema()` on multiple Arrow objects now returns the object's schema (#35543)
+* dplyr `.by`/`by` argument now supported in arrow implementation of dplyr verbs  (@eitsupi, #35667)
+
+## Minor improvements and fixes
+
+* Convenience function `arrow_array()` can be used to create Arrow Arrays (#36381)
+* Convenience function `scalar()` can be used to create Arrow Scalars  (#36265)
+* Prevent crashed when passing data between arrow and duckdb by always calling `RecordBatchReader::ReadNext()` from DuckDB from the main R thread (#36307)
+* Issue a warning for `set_io_thread_count()` with `num_threads` < 2 (#36304)
+* Ensure missing grouping variables are added to the beginning of the variable list (#36305)
+* CSV File reader options class objects can print the selected values (#35955)
+* Schema metadata can be set as a named character vector (#35954)
+* Ensure that the RStringViewer helper class does not own any Array references (#35812)
+* `strptime()` in arrow will return a timezone-aware timestamp if `%z` is part of the format string (#35671)
+* Column ordering when combining `group_by()` and `across()` now matches dplyr (@eitsupi, #35473)
+
+## Installation
+
+* Link to correct version of OpenSSL when using autobrew (#36551)
+* Require cmake 3.16 in bundled build script (#36321)
+
+## Docs
+
+* Split out R6 classes and convenience functions to improve readability (#36394)
+* Enable pkgdown built-in search (@eitsupi, #36374)
+* Re-organise reference page on pkgdown site to improve readability (#36171)
+
 # arrow 12.0.1.1
 
 * Update a package version reference to be text only instead of numeric due to CRAN update requiring this (#36353, #36364)

From c5444126b3470bab06658ceea9978e9da6e4b9c6 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 24 Jul 2023 12:41:39 -0300
Subject: [PATCH 030/749] GH-36824: [C++] Improve the test tracing of
 CheckWithDifferentShapes in the if-else kernel tests (#36825)

### Rationale for this change

The traces might show that a call is being made with a conditional scalar, but then a call is made with an array. If there is a bug in the kernel, it's hard to know which specialization is to blame given the trace.

### What changes are included in this PR?

A simplification of the `CheckWithDifferentShapes` and addition of a bit more tracing information.

### Are these changes tested?

Yes. The changes are only made to test code and I verified that bugs in the implementation get caught by the new code.

### Are there any user-facing changes?

No.
* Closes: #36824

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../compute/kernels/scalar_if_else_test.cc    | 168 +++++++++++-------
 1 file changed, 104 insertions(+), 64 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc b/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
index 879d6285f3441..ded73f0371435 100644
--- a/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
@@ -126,75 +126,115 @@ TYPED_TEST(TestIfElsePrimitive, IfElseFixedSizeRand) {
   CheckIfElseOutput(cond, left, right, expected_data);
 }
 
-void CheckWithDifferentShapes(const std::shared_ptr<Array>& cond,
-                              const std::shared_ptr<Array>& left,
-                              const std::shared_ptr<Array>& right,
-                              const std::shared_ptr<Array>& expected) {
-  // this will check for whole arrays, every scalar at i'th index and slicing (offset)
-  CheckScalar("if_else", {cond, left, right}, expected);
-
-  auto len = left->length();
-  std::vector<int64_t> array_indices = {-1};  // sentinel for make_input
-  std::vector<int64_t> scalar_indices(len);
-  std::iota(scalar_indices.begin(), scalar_indices.end(), 0);
-  auto make_input = [&](const std::shared_ptr<Array>& array, int64_t index, Datum* input,
-                        Datum* input_broadcast, std::string* trace) {
-    if (index >= 0) {
-      // Use scalar from array[index] as input; broadcast scalar for computing expected
-      // result
-      ASSERT_OK_AND_ASSIGN(auto scalar, array->GetScalar(index));
-      *trace += "@" + std::to_string(index) + "=" + scalar->ToString();
-      *input = std::move(scalar);
-      ASSERT_OK_AND_ASSIGN(*input_broadcast, MakeArrayFromScalar(*input->scalar(), len));
+Datum ArrayOrBroadcastScalar(const Datum& input, int64_t length) {
+  if (input.is_scalar()) {
+    EXPECT_OK_AND_ASSIGN(auto array, MakeArrayFromScalar(*input.scalar(), length));
+    return array;
+  }
+  EXPECT_TRUE(input.is_array());
+  return input;
+}
+
+Result<Datum> ExpectedFromIfElse(
+    const Datum& cond, const Datum& left, const Datum& right,
+    std::shared_ptr<DataType> type,
+    const std::shared_ptr<Array>& expected_if_all_operands_are_arrays) {
+  if (cond.is_scalar() && left.is_scalar() && right.is_scalar()) {
+    const auto& scalar = cond.scalar_as<BooleanScalar>();
+    Datum expected;
+    if (scalar.is_valid) {
+      expected = scalar.value ? left : right;
     } else {
-      // Use array as input
-      *trace += "=Array";
-      *input = *input_broadcast = array;
+      expected = MakeNullScalar(left.type());
     }
-  };
-
-  enum { COND_SCALAR = 1, LEFT_SCALAR = 2, RIGHT_SCALAR = 4 };
-  for (int mask = 1; mask <= (COND_SCALAR | LEFT_SCALAR | RIGHT_SCALAR); ++mask) {
-    for (int64_t cond_idx : (mask & COND_SCALAR) ? scalar_indices : array_indices) {
-      Datum cond_in, cond_bcast;
-      std::string trace_cond = "Cond";
-      make_input(cond, cond_idx, &cond_in, &cond_bcast, &trace_cond);
-
-      for (int64_t left_idx : (mask & LEFT_SCALAR) ? scalar_indices : array_indices) {
-        Datum left_in, left_bcast;
-        std::string trace_left = "Left";
-        make_input(left, left_idx, &left_in, &left_bcast, &trace_left);
-
-        for (int64_t right_idx : (mask & RIGHT_SCALAR) ? scalar_indices : array_indices) {
-          Datum right_in, right_bcast;
-          std::string trace_right = "Right";
-          make_input(right, right_idx, &right_in, &right_bcast, &trace_right);
-
-          SCOPED_TRACE(trace_right);
-          SCOPED_TRACE(trace_left);
-          SCOPED_TRACE(trace_cond);
-
-          Datum expected;
-          ASSERT_OK_AND_ASSIGN(auto actual, IfElse(cond_in, left_in, right_in));
-          if (mask == (COND_SCALAR | LEFT_SCALAR | RIGHT_SCALAR)) {
-            const auto& scalar = cond_in.scalar_as<BooleanScalar>();
-            if (scalar.is_valid) {
-              expected = scalar.value ? left_in : right_in;
-            } else {
-              expected = MakeNullScalar(left_in.type());
-            }
-            if (!left_in.type()->Equals(*right_in.type())) {
-              ASSERT_OK_AND_ASSIGN(expected,
-                                   Cast(expected, CastOptions::Safe(actual.type())));
-            }
-          } else {
-            ASSERT_OK_AND_ASSIGN(expected, IfElse(cond_bcast, left_bcast, right_bcast));
-          }
-          AssertDatumsEqual(expected, actual, /*verbose=*/true);
+    if (!left.type()->Equals(*right.type())) {
+      return Cast(expected, CastOptions::Safe(std::move(type)));
+    }
+    return expected;
+  }
+  if (cond.is_array() && left.is_array() && right.is_array()) {
+    return expected_if_all_operands_are_arrays;
+  }
+  // When at least one of the inputs is an array, we expect the output
+  // to be the same as if all the scalars were broadcast to arrays.
+  const auto expected_length =
+      std::max(cond.length(), std::max(left.length(), right.length()));
+  SCOPED_TRACE("IfElseAAACall");
+  return IfElse(ArrayOrBroadcastScalar(cond, expected_length),
+                ArrayOrBroadcastScalar(left, expected_length),
+                ArrayOrBroadcastScalar(right, expected_length));
+}
+
+bool NextScalarOrWholeArray(const std::shared_ptr<Array>& array, int* index, Datum* out) {
+  if (*index <= array->length()) {
+    if (*index < array->length()) {
+      EXPECT_OK_AND_ASSIGN(auto scalar, array->GetScalar(*index));
+      *out = std::move(scalar);
+    } else {
+      *out = array;
+    }
+    *index += 1;
+    return true;
+  }
+  return false;
+}
+
+std::string CodedCallName(const Datum& cond, const Datum& left, const Datum& right) {
+  std::string coded = "IfElse";
+  coded += cond.is_scalar() ? "S" : "A";
+  coded += left.is_scalar() ? "S" : "A";
+  coded += right.is_scalar() ? "S" : "A";
+  coded += "Call";
+  return coded;
+}
+
+void DoCheckWithDifferentShapes(const std::shared_ptr<Array>& cond,
+                                const std::shared_ptr<Array>& left,
+                                const std::shared_ptr<Array>& right,
+                                const std::shared_ptr<Array>& expected) {
+  auto make_trace([&](const char* name, const Datum& datum, int index) {
+    std::string trace = name;
+    trace += " : ";
+    if (datum.is_scalar()) {
+      trace += "Scalar@" + std::to_string(index) + " = " + datum.scalar()->ToString();
+    } else {
+      EXPECT_TRUE(datum.is_array());
+      trace += "Array = [...]";
+    }
+    return trace;
+  });
+  Datum cond_in;
+  Datum left_in;
+  Datum right_in;
+  int cond_index = 0;
+  int left_index = 0;
+  int right_index = 0;
+  while (NextScalarOrWholeArray(cond, &cond_index, &cond_in)) {
+    SCOPED_TRACE(make_trace("Cond", cond_in, cond_index));
+    while (NextScalarOrWholeArray(left, &left_index, &left_in)) {
+      SCOPED_TRACE(make_trace("Left", left_in, left_index));
+      while (NextScalarOrWholeArray(right, &right_index, &right_in)) {
+        SCOPED_TRACE(make_trace("Right", right_in, right_index));
+        Datum actual;
+        {
+          SCOPED_TRACE(CodedCallName(cond_in, left_in, right_in));
+          ASSERT_OK_AND_ASSIGN(actual, IfElse(cond_in, left_in, right_in));
         }
+        ASSERT_OK_AND_ASSIGN(
+            auto adjusted_expected,
+            ExpectedFromIfElse(cond_in, left_in, right_in, actual.type(), expected));
+        AssertDatumsEqual(adjusted_expected, actual, /*verbose=*/true);
       }
     }
-  }  // for (mask)
+  }
+}
+
+void CheckWithDifferentShapes(const std::shared_ptr<Array>& cond,
+                              const std::shared_ptr<Array>& left,
+                              const std::shared_ptr<Array>& right,
+                              const std::shared_ptr<Array>& expected) {
+  CheckScalar("if_else", {cond, left, right}, expected);
+  DoCheckWithDifferentShapes(cond, left, right, expected);
 }
 
 TYPED_TEST(TestIfElsePrimitive, IfElseFixedSize) {

From b31977fd22afdb44cc8344f7814d1f6cd507a964 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 24 Jul 2023 23:55:55 +0800
Subject: [PATCH 031/749] GH-36773: [C++][Parquet] Avoid calculating prebuffer
 column bitmap multiple times (#36774)

### Rationale for this change

According to https://github.com/apache/arrow/pull/36192 and https://github.com/apache/arrow/pull/36649 . RowGroupReader using a bitmap to control a column-level prebuffer.

However, if all columns are selected, this will be a heavy overhead for building a bitmap multiple times.

### What changes are included in this PR?

Build `Prebuffer` Bitmap once, and reuse that vector.

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #36773

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/file_reader.cc | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index adda9a027bded..08d493b0bca2f 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -179,17 +179,17 @@ class SerializedRowGroup : public RowGroupReader::Contents {
   SerializedRowGroup(std::shared_ptr<ArrowInputFile> source,
                      std::shared_ptr<::arrow::io::internal::ReadRangeCache> cached_source,
                      int64_t source_size, FileMetaData* file_metadata,
-                     int row_group_number, const ReaderProperties& props,
+                     int row_group_number, ReaderProperties props,
                      std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap,
                      std::shared_ptr<InternalFileDecryptor> file_decryptor = nullptr)
       : source_(std::move(source)),
         cached_source_(std::move(cached_source)),
         source_size_(source_size),
         file_metadata_(file_metadata),
-        properties_(props),
+        properties_(std::move(props)),
         row_group_ordinal_(row_group_number),
         prebuffered_column_chunks_bitmap_(std::move(prebuffered_column_chunks_bitmap)),
-        file_decryptor_(file_decryptor) {
+        file_decryptor_(std::move(file_decryptor)) {
     row_group_metadata_ = file_metadata->RowGroup(row_group_number);
   }
 
@@ -273,7 +273,7 @@ class SerializedRowGroup : public RowGroupReader::Contents {
   std::unique_ptr<RowGroupMetaData> row_group_metadata_;
   ReaderProperties properties_;
   int row_group_ordinal_;
-  const std::shared_ptr<Buffer> prebuffered_column_chunks_bitmap_;
+  const std::shared_ptr<const Buffer> prebuffered_column_chunks_bitmap_;
   std::shared_ptr<InternalFileDecryptor> file_decryptor_;
 };
 
@@ -366,13 +366,19 @@ class SerializedFile : public ParquetFileReader::Contents {
         std::make_shared<::arrow::io::internal::ReadRangeCache>(source_, ctx, options);
     std::vector<::arrow::io::ReadRange> ranges;
     prebuffered_column_chunks_.clear();
+    int num_cols = file_metadata_->num_columns();
+    // a bitmap for buffered columns.
+    std::shared_ptr<Buffer> buffer_columns;
+    if (!row_groups.empty()) {
+      PARQUET_THROW_NOT_OK(AllocateEmptyBitmap(num_cols, properties_.memory_pool())
+                               .Value(&buffer_columns));
+      for (int col : column_indices) {
+        ::arrow::bit_util::SetBit(buffer_columns->mutable_data(), col);
+      }
+    }
     for (int row : row_groups) {
-      std::shared_ptr<Buffer>& col_bitmap = prebuffered_column_chunks_[row];
-      int num_cols = file_metadata_->num_columns();
-      PARQUET_THROW_NOT_OK(
-          AllocateEmptyBitmap(num_cols, properties_.memory_pool()).Value(&col_bitmap));
+      prebuffered_column_chunks_[row] = buffer_columns;
       for (int col : column_indices) {
-        ::arrow::bit_util::SetBit(col_bitmap->mutable_data(), col);
         ranges.push_back(
             ComputeColumnChunkRange(file_metadata_.get(), source_size_, row, col));
       }

From 8b7457e85926e0e7ba91e4ca92982aeff6a26ec4 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 24 Jul 2023 19:26:57 +0100
Subject: [PATCH 032/749] MINOR: [R] Add NEWS gathering instructions (#36804)

### Rationale for this change

Add instructions on how to find relevant commits to use as basis of updating NEWS.md during a release

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/PACKAGING.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/PACKAGING.md b/r/PACKAGING.md
index 6cfa903650729..ef996c88cf2cf 100644
--- a/r/PACKAGING.md
+++ b/r/PACKAGING.md
@@ -31,7 +31,7 @@ For a high-level overview of the release process see the
 - [ ] Ensure the contents of the README are accurate and up to date.
 - [ ] Run `urlchecker::url_check()` on the R directory at the release candidate.
   commit. Ignore any errors with badges as they will be removed in the CRAN release branch.
-- [ ] [Polish NEWS](https://style.tidyverse.org/news.html#news-release) but do **not** update version numbers (this is done automatically later).
+- [ ] [Polish NEWS](https://style.tidyverse.org/news.html#news-release) but do **not** update version numbers (this is done automatically later). You can find commits by, for example, `git log --oneline aa057d0..HEAD | grep "\[R\]"`
 - [ ] Run preliminary reverse dependency checks using `archery docker run r-revdepcheck`.
 - [ ] For major releases, prepare tweet thread highlighting new features.
 

From 362387a3e2e63d5f9f15634a0ebc85b03def3759 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 24 Jul 2023 19:27:23 +0100
Subject: [PATCH 033/749] MINOR: [R] Update instructions for bumping NEWS.md
 (#36803)

### Rationale for this change

Update for release instructions to make things more clear, based on my experience doing a release recently.

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/PACKAGING.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/PACKAGING.md b/r/PACKAGING.md
index ef996c88cf2cf..edfca651e9d38 100644
--- a/r/PACKAGING.md
+++ b/r/PACKAGING.md
@@ -126,7 +126,7 @@ Wait for CRAN...
 - [ ] Tag the tip of the CRAN-specific release branch
 - [ ] Add a new line to the matrix in the [backwards compatability job](https://github.com/apache/arrow/blob/main/dev/tasks/r/github.linux.arrow.version.back.compat.yml)
 - [ ] (patch releases only) Update the package version in `ci/scripts/PKGBUILD`, `dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb`, `r/DESCRIPTION`, and `r/NEWS.md`
-- [ ] (CRAN-only releases) Rebuild the docs with `pkgdown::build_site(examples = FALSE, lazy = TRUE, install = FALSE)` and submit a PR to [the `asf-site` branch of the docs site](https://github.com/apache/arrow-site) with the contents of `r/docs/news/index.html`.
+- [ ] (CRAN-only releases) Rebuild news page with `pkgdown::build_news()` and submit a PR to the asf-site branch of the docs site with the contents of `arrow/r/docs/news/index.html` replacing the current contents of `arrow-site/docs/r/news/index.html`
 - [ ] (CRAN-only releases) Bump the version number in `r/pkgdown/assets/versions.json`, and update this on the [the `asf-site` branch of the docs site](https://github.com/apache/arrow-site) too.
 - [ ] Update the packaging checklist template to reflect any new realities of the
   packaging process.

From 6695d18eb2d7b8eada68e80f0fb030c12b70aabb Mon Sep 17 00:00:00 2001
From: Chelsea Jones <129552306+chelseajonesr@users.noreply.github.com>
Date: Mon, 24 Jul 2023 11:29:24 -0700
Subject: [PATCH 034/749] GH-36793: [Go] Allow NewSchemaFromStruct to skip
 fields if tagged with parquet:"-" (#36794)

### Rationale for this change

Allow skipping Go struct fields when serializing to Parquet by using a tag `parquet:"-"`, similarly to the standard Go JSON implementation.

### What changes are included in this PR?

Add `Exclude` to the taggedInfo struct, which is used by `typeToNode` to skip the  associated struct field.

### Are these changes tested?

Yes, I modified an existing test to add a new excluded field.  (I'm also using this change locally to read and write parquet files with existing Go structs.)

### Are there any user-facing changes?

Yes, this modifies usage of the `parquet` tag.  I couldn't find any relevant documentation that needs to be updated though; if there is any please let me know and I will do so.
* Closes: #36793

Authored-by: Chelsea Jones <chelseajones@rivian.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/schema/reflection.go      | 13 +++++++++++--
 go/parquet/schema/reflection_test.go |  3 ++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index f1e204a171712..b85c1c28c781a 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -64,6 +64,8 @@ type taggedInfo struct {
 	LogicalType      LogicalType
 	KeyLogicalType   LogicalType
 	ValueLogicalType LogicalType
+
+	Exclude bool
 }
 
 func (t *taggedInfo) CopyForKey() (ret taggedInfo) {
@@ -186,6 +188,7 @@ func newTaggedInfo() taggedInfo {
 		LogicalType:        NoLogicalType{},
 		KeyLogicalType:     NoLogicalType{},
 		ValueLogicalType:   NoLogicalType{},
+		Exclude:            false,
 	}
 }
 
@@ -232,6 +235,10 @@ func infoFromTags(f reflect.StructTag) *taggedInfo {
 
 	if ptags, ok := f.Lookup("parquet"); ok {
 		info := newTaggedInfo()
+		if ptags == "-" {
+			info.Exclude = true
+			return &info
+		}
 		for _, tag := range strings.Split(strings.Replace(ptags, "\t", "", -1), ",") {
 			tag = strings.TrimSpace(tag)
 			kv := strings.SplitN(tag, "=", 2)
@@ -370,8 +377,10 @@ func typeToNode(name string, typ reflect.Type, repType parquet.Repetition, info
 		fields := make(FieldList, 0)
 		for i := 0; i < typ.NumField(); i++ {
 			f := typ.Field(i)
-
-			fields = append(fields, typeToNode(f.Name, f.Type, parquet.Repetitions.Required, infoFromTags(f.Tag)))
+			tags := infoFromTags(f.Tag)
+			if tags == nil || !tags.Exclude {
+				fields = append(fields, typeToNode(f.Name, f.Type, parquet.Repetitions.Required, tags))
+			}
 		}
 		// group nodes don't have a physical type
 		if physical != parquet.Types.Undefined {
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index 7be1475513c52..4a029d058155a 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -309,7 +309,8 @@ func TestStructFromSchema(t *testing.T) {
 
 func TestStructFromSchemaWithNesting(t *testing.T) {
 	type Other struct {
-		List *[]*float32
+		List     *[]*float32
+		Excluded int32 `parquet:"-"`
 	}
 
 	type Nested struct {

From 651c875c3f853bc7439a10cca2cf6e04e59c5fdd Mon Sep 17 00:00:00 2001
From: Ian Cook <ianmcook@gmail.com>
Date: Mon, 24 Jul 2023 18:07:41 -0400
Subject: [PATCH 035/749] GH-35800: [Docs] Link to GeoArrow from canonical
 extension types docs (#36810)

Adds a new section to the Canonical Extension Types docs listing
"Community Extension Types" and explains that these have not been
formally adopted by the Arrow developers. Lists GeoArrow as one of these
and links to the GeoArrow repo.
* Closes: #35800
---
 docs/source/format/CanonicalExtensions.rst | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/docs/source/format/CanonicalExtensions.rst b/docs/source/format/CanonicalExtensions.rst
index 5dd269ee5c675..9f7948cbfe980 100644
--- a/docs/source/format/CanonicalExtensions.rst
+++ b/docs/source/format/CanonicalExtensions.rst
@@ -147,3 +147,21 @@ Fixed shape tensor
   This structure has no relationship with the Fixed shape tensor extension type defined
   by this specification. Instead, this extension type lets one use fixed shape tensors
   as elements in a field of a RecordBatch or a Table.
+
+=========================
+Community Extension Types
+=========================
+
+In addition to the canonical extension types listed above, there exist Arrow
+extension types that have been established as standards within specific domain
+areas. These have not been officially designated as canonical through a
+discussion and vote on the Arrow development mailing list but are well known
+within subcommunities of Arrow developers.
+
+GeoArrow
+========
+
+`GeoArrow <https://github.com/geoarrow/geoarrow>`_ defines a collection of
+Arrow extension types for representing vector geometries. It is well known
+within the Arrow geospatial subcommunity. The GeoArrow specification is not yet
+finalized.

From 06deded47a4571c40bee06fd28749bfd5633a823 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 25 Jul 2023 02:42:23 +0200
Subject: [PATCH 036/749] GH-36839: [CI][Docs] Update test-ubuntu-default-docs
 to use GitHub actions instead of Azure (#36840)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Currently `test-ubuntu-default-docs` has been failing on Azure for the 13.0.0 RC0 and we had to use GitHub actions to generate the documentation.
Using the same base action for both preview-docs, test and packaging will improve maintainability.

### What changes are included in this PR?

Move `test-ubuntu-default-docs` to use GH actions instead of Azure.

### Are these changes tested?

Yes, with archery related tasks.

### Are there any user-facing changes?

No
* Closes: #36839

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/docs/github.linux.yml | 12 ++++++++++--
 dev/tasks/tasks.yml             | 13 +++++--------
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/dev/tasks/docs/github.linux.yml b/dev/tasks/docs/github.linux.yml
index f9b2e111e8f3e..0938ac74adc46 100644
--- a/dev/tasks/docs/github.linux.yml
+++ b/dev/tasks/docs/github.linux.yml
@@ -21,7 +21,7 @@
 
 jobs:
   test:
-    name: Docs Preview
+    name: Build Docs
     runs-on: ubuntu-latest
 {{ macros.github_set_env(env) }}
     steps:
@@ -44,7 +44,8 @@ jobs:
           ref: {{ default_branch|default("main") }}
           path: crossbow
           fetch-depth: 1
-      - name: Prepare docs
+      {% if  publish %}
+      - name: Prepare Docs Preview
         run: |
           # build files are created by the docker user
           sudo chown -R ${USER}: build
@@ -61,3 +62,10 @@ jobs:
         run: |
           aws s3 cp build/docs/ $BUCKET/pr_docs/{{ pr_number }}/ --recursive
           echo ":open_book: You can find the preview here: http://crossbow.voltrondata.com/pr_docs/{{ pr_number }}" >> $GITHUB_STEP_SUMMARY
+      {% endif %}
+      - name: Prepare Docs artifacts
+        run: |
+          cd build
+          sudo chown -R ${USER}: .
+          tar cvzf docs.tar.gz docs
+      {{ macros.github_upload_releases("build/docs.tar.gz")|indent }}
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 879c2246b41ee..cca770438574a 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1435,16 +1435,13 @@ tasks:
   {% endfor %}
 
   test-ubuntu-default-docs:
-    ci: azure
-    template: docker-tests/azure.linux.yml
+    ci: github
+    template: docs/github.linux.yml
     params:
-      artifacts: "build/docs.tar.gz"
+      pr_number: Unset
       flags: "-v $PWD/build/:/build/"
       image: ubuntu-docs
-      post_script: |
-        cd build
-        sudo chown -R ${USER}: .
-        tar cvzf docs.tar.gz docs
+      publish: false
     artifacts:
       - docs.tar.gz
 
@@ -1565,6 +1562,6 @@ tasks:
     template: docs/github.linux.yml
     params:
       pr_number: Unset
-      artifacts: "build/docs.tar.gz"
       flags: "-v $PWD/build/:/build/"
       image: ubuntu-docs
+      publish: true

From 9bf514a874baf8a19ef4a5a2fb2fea676e57b2ed Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 25 Jul 2023 17:18:43 +0900
Subject: [PATCH 037/749] GH-35292: [Release] Retry "apt install" (#36836)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Timeout is still happen on my local environment.

### What changes are included in this PR?

Retry `apt install`.

This is just a workaround. We should not close GH-35292 by this.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #35292

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/release/verify-apt.sh | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/dev/release/verify-apt.sh b/dev/release/verify-apt.sh
index 187482cbf52d2..49671f01cc7e8 100755
--- a/dev/release/verify-apt.sh
+++ b/dev/release/verify-apt.sh
@@ -45,7 +45,21 @@ echo "::group::Prepare repository"
 
 export DEBIAN_FRONTEND=noninteractive
 
-APT_INSTALL="apt install -y -V --no-install-recommends"
+retry()
+{
+  local n_retries=0
+  local max_n_retries=3
+  while ! "$@"; do
+    n_retries=$((n_retries + 1))
+    if [ ${n_retries} -eq ${max_n_retries} ]; then
+      echo "Failed: $@"
+      return 1
+    fi
+    echo "Retry: $@"
+  done
+}
+
+APT_INSTALL="retry apt install -y -V --no-install-recommends"
 
 apt update
 ${APT_INSTALL} \

From 20bbe3e0966309a775bac0ef056b74b2b06fc75a Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 25 Jul 2023 17:26:41 +0900
Subject: [PATCH 038/749] GH-36832: [Packaging][RPM] Remove needless Requires
 (#36833)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

`arrowXX-libs` doesn't use `gflags` but it depends on `gflags`.

### What changes are included in this PR?

Remove needless explicit `Requires`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #36832

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .../apache-arrow/yum/arrow.spec.in            | 21 -------------------
 1 file changed, 21 deletions(-)

diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 67e0f8db8a4dd..46c6d91b2d5dc 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -238,27 +238,11 @@ cd -
 %package -n %{name}%{major_version}-libs
 Summary:	Runtime libraries for Apache Arrow C++
 License:	Apache-2.0
-Requires:	brotli
-%if %{use_gflags}
-Requires:	gflags
-%endif
-%if %{use_glog}
-Requires:	glog
-%endif
-Requires:	libzstd
 %if %{have_lz4_libs}
 Requires:	lz4-libs %{lz4_requirement}
 %else
 Requires:	lz4 %{lz4_requirement}
 %endif
-%if %{have_re2}
-Requires:	re2
-%endif
-Requires:	snappy
-%if %{have_utf8proc}
-Requires:	utf8proc
-%endif
-Requires:	zlib
 
 %description -n %{name}%{major_version}-libs
 This package contains the libraries for Apache Arrow C++.
@@ -414,8 +398,6 @@ Libraries and header files for Apache Arrow dataset.
 Summary:	C++ library for fast data transport.
 License:	Apache-2.0
 Requires:	%{name}%{major_version}-libs = %{version}-%{release}
-Requires:	c-ares
-Requires:	openssl
 
 %description -n %{name}%{major_version}-flight-libs
 This package contains the libraries for Apache Arrow Flight.
@@ -485,7 +467,6 @@ Libraries and header files for Apache Arrow Flight SQL.
 Summary:	C++ library for compiling and evaluating expressions on Apache Arrow data.
 License:	Apache-2.0
 Requires:	%{name}%{major_version}-libs = %{version}-%{release}
-Requires:	ncurses-libs
 
 %description -n gandiva%{major_version}-libs
 This package contains the libraries for Gandiva.
@@ -521,7 +502,6 @@ Libraries and header files for Gandiva.
 Summary:	Runtime libraries for Apache Parquet C++
 License:	Apache-2.0
 Requires:	%{name}%{major_version}-libs = %{version}-%{release}
-Requires:	openssl
 
 %description -n parquet%{major_version}-libs
 This package contains the libraries for Apache Parquet C++.
@@ -570,7 +550,6 @@ Libraries and header files for Apache Parquet C++.
 Summary:	Runtime libraries for Apache Arrow GLib
 License:	Apache-2.0
 Requires:	%{name}%{major_version}-libs = %{version}-%{release}
-Requires:	glib2
 
 %description -n %{name}%{major_version}-glib-libs
 This package contains the libraries for Apache Arrow GLib.

From dbae5f07b62ccc4be6ab1f47d72eaf054d24ae05 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Tue, 25 Jul 2023 16:43:14 +0800
Subject: [PATCH 039/749] GH-36789: [C++] Support divide(duration, duration)
 (#36800)

### Rationale for this change

Support divide(duration, duration), as pandas and numpy already do.

### What changes are included in this PR?

Add kernels divide(duration, duration)->float64 and divide_checked(duration, duration)->float64

### Are these changes tested?

Yes

### Are there any user-facing changes?

No

* Closes: #36789

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../compute/kernels/scalar_arithmetic.cc      | 16 +++++++++++++++
 .../compute/kernels/scalar_temporal_test.cc   | 20 +++++++++++++++++++
 2 files changed, 36 insertions(+)

diff --git a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
index 2c7363b3ca486..c305028be19c9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_arithmetic.cc
@@ -30,6 +30,7 @@
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
 #include "arrow/type.h"
+#include "arrow/type_fwd.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
 #include "arrow/util/int_util_overflow.h"
@@ -1509,6 +1510,13 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
     DCHECK_OK(
         divide->AddKernel({duration(unit), int64()}, duration(unit), std::move(exec)));
   }
+
+  // Add divide(duration, duration) -> float64
+  for (auto unit : TimeUnit::values()) {
+    auto exec = ScalarBinaryNotNull<DoubleType, DoubleType, DoubleType, Divide>::Exec;
+    DCHECK_OK(
+        divide->AddKernel({duration(unit), duration(unit)}, float64(), std::move(exec)));
+  }
   DCHECK_OK(registry->AddFunction(std::move(divide)));
 
   // ----------------------------------------------------------------------
@@ -1523,6 +1531,14 @@ void RegisterScalarArithmetic(FunctionRegistry* registry) {
                                         std::move(exec)));
   }
 
+  // Add divide_checked(duration, duration) -> float64
+  for (auto unit : TimeUnit::values()) {
+    auto exec =
+        ScalarBinaryNotNull<DoubleType, DoubleType, DoubleType, DivideChecked>::Exec;
+    DCHECK_OK(divide_checked->AddKernel({duration(unit), duration(unit)}, float64(),
+                                        std::move(exec)));
+  }
+
   DCHECK_OK(registry->AddFunction(std::move(divide_checked)));
 
   // ----------------------------------------------------------------------
diff --git a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
index cd8abf6e923c8..4c7975add0308 100644
--- a/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_temporal_test.cc
@@ -26,6 +26,7 @@
 #include "arrow/testing/matchers.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
+#include "arrow/type_fwd.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/formatting.h"
@@ -1695,6 +1696,7 @@ TEST_F(ScalarTemporalTest, TestTemporalMultiplyDuration) {
 }
 
 TEST_F(ScalarTemporalTest, TestTemporalDivideDuration) {
+  // div(duration, integer) -> integer
   for (auto u : TimeUnit::values()) {
     for (auto numeric : NumericTypes()) {
       if (!is_integer(numeric->id())) continue;
@@ -1718,6 +1720,24 @@ TEST_F(ScalarTemporalTest, TestTemporalDivideDuration) {
                                       CallFunction("divide_checked", {durations, zeros}));
     }
   }
+
+  // div(duration, duration) -> float64
+  auto left = ArrayFromJSON(duration(TimeUnit::SECOND), "[1, 2, 3, 4]");
+  auto right = ArrayFromJSON(duration(TimeUnit::MILLI), "[4000, 300, 20, 1]");
+  auto expected_left_by_right =
+      ArrayFromJSON(float64(), "[0.25, 6.666666666666667, 150, 4000]");
+  auto expected_right_by_left =
+      ArrayFromJSON(float64(), "[4, 0.15, 0.006666666666666667, 0.00025]");
+  CheckScalarBinary("divide", left, right, expected_left_by_right);
+  CheckScalarBinary("divide_checked", left, right, expected_left_by_right);
+  CheckScalarBinary("divide", right, left, expected_right_by_left);
+  CheckScalarBinary("divide_checked", right, left, expected_right_by_left);
+
+  // Check dispatching
+  CheckDispatchBest("divide", {duration(TimeUnit::SECOND), duration(TimeUnit::MILLI)},
+                    {duration(TimeUnit::MILLI), duration(TimeUnit::MILLI)});
+  CheckDispatchBest("divide", {duration(TimeUnit::NANO), duration(TimeUnit::MILLI)},
+                    {duration(TimeUnit::NANO), duration(TimeUnit::NANO)});
 }
 
 TEST_F(ScalarTemporalTest, TestTemporalDifferenceWeeks) {

From 16806a1486f644093b9578243cc55ac051c60056 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Tue, 25 Jul 2023 10:56:09 -0300
Subject: [PATCH 040/749] GH-36776: [C++] Make ListArray::FromArrays() handle
 sliced offsets Arrays containing nulls (#36780)

### Rationale for this change

It fixes the issue described in #36776

### What changes are included in this PR?

The fix and a simplifications of the interaction between `ListArrayFromArrays` and `CleanOffsets` which is rather involved.

### Are these changes tested?

Yes. I added a test that reproduces the issue before adding the fixes.
* Closes: #36776

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/array/array_list_test.cc | 57 +++++++++++++++++
 cpp/src/arrow/array/array_nested.cc    | 87 +++++++++++++++-----------
 2 files changed, 106 insertions(+), 38 deletions(-)

diff --git a/cpp/src/arrow/array/array_list_test.cc b/cpp/src/arrow/array/array_list_test.cc
index 2a00cadcab9aa..a3a2f99851b55 100644
--- a/cpp/src/arrow/array/array_list_test.cc
+++ b/cpp/src/arrow/array/array_list_test.cc
@@ -215,17 +215,20 @@ class TestListArray : public ::testing::Test {
     // Offsets with nulls will match.
     ASSERT_OK_AND_ASSIGN(auto result,
                          ArrayType::FromArrays(*offsets_w_nulls, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
     AssertArraysEqual(*result, *expected);
 
     // Offets without nulls, will replace null with empty list
     ASSERT_OK_AND_ASSIGN(result,
                          ArrayType::FromArrays(*offsets_wo_nulls, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
     AssertArraysEqual(*result, *std::dynamic_pointer_cast<ArrayType>(
                                    ArrayFromJSON(type, "[[0], [], [0, null], [0]]")));
 
     // Specify non-null offsets with null_bitmap
     ASSERT_OK_AND_ASSIGN(result, ArrayType::FromArrays(*offsets_wo_nulls, *values, pool_,
                                                        expected->null_bitmap()));
+    ASSERT_OK(result->ValidateFull());
     AssertArraysEqual(*result, *expected);
 
     // Cannot specify both null offsets with null_bitmap
@@ -233,6 +236,58 @@ class TestListArray : public ::testing::Test {
                                                  expected->null_bitmap()));
   }
 
+  void TestFromArraysWithSlicedOffsets() {
+    std::vector<offset_type> offsets = {-1, -1, 0, 1, 2, 4};
+
+    std::shared_ptr<Array> offsets_wo_nulls;
+    ArrayFromVector<OffsetType, offset_type>(offsets, &offsets_wo_nulls);
+
+    auto type = std::make_shared<T>(int32());
+    auto expected = std::dynamic_pointer_cast<ArrayType>(
+        ArrayFromJSON(type, "[[0], [1], [0, null]]"));
+    auto values = expected->values();
+
+    // Apply an offset to the offsets array
+    auto sliced_offsets = offsets_wo_nulls->Slice(2, 4);
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         ArrayType::FromArrays(*sliced_offsets, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
+    AssertArraysEqual(*result, *expected);
+
+    // Non-zero starter offset
+    sliced_offsets = offsets_wo_nulls->Slice(3, 3);
+    ASSERT_OK_AND_ASSIGN(result, ArrayType::FromArrays(*sliced_offsets, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
+    AssertArraysEqual(*result, *expected->Slice(1, 2));
+  }
+
+  void TestFromArraysWithSlicedNullOffsets() {
+    std::vector<offset_type> offsets = {-1, -1, 0, 1, 1, 3};
+    std::vector<bool> offsets_w_nulls_is_valid = {true, true, true, false, true, true};
+
+    std::shared_ptr<Array> offsets_w_nulls;
+    ArrayFromVector<OffsetType, offset_type>(offsets_w_nulls_is_valid, offsets,
+                                             &offsets_w_nulls);
+
+    auto type = std::make_shared<T>(int32());
+    auto expected = std::dynamic_pointer_cast<ArrayType>(
+        ArrayFromJSON(type, "[[0], null, [0, null]]"));
+    auto values = expected->values();
+
+    // Apply an offset to the offsets array with nulls (GH-36776)
+    auto sliced_offsets = offsets_w_nulls->Slice(2, 4);
+    ASSERT_OK_AND_ASSIGN(auto result,
+                         ArrayType::FromArrays(*sliced_offsets, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
+    AssertArraysEqual(*result, *expected);
+
+    // Non-zero starter offset
+    sliced_offsets = offsets_w_nulls->Slice(3, 3);
+    ASSERT_OK_AND_ASSIGN(result, ArrayType::FromArrays(*sliced_offsets, *values, pool_));
+    ASSERT_OK(result->ValidateFull());
+    AssertArraysEqual(*result, *expected->Slice(1, 2));
+  }
+
   void TestFromArrays() {
     std::shared_ptr<Array> offsets1, offsets2, offsets3, offsets4, offsets5, values;
 
@@ -586,6 +641,8 @@ TYPED_TEST(TestListArray, FromArrays) { this->TestFromArrays(); }
 
 TYPED_TEST(TestListArray, FromArraysWithNullBitMap) {
   this->TestFromArraysWithNullBitMap();
+  this->TestFromArraysWithSlicedOffsets();
+  this->TestFromArraysWithSlicedNullOffsets();
 }
 
 TYPED_TEST(TestListArray, AppendNull) { this->TestAppendNull(); }
diff --git a/cpp/src/arrow/array/array_nested.cc b/cpp/src/arrow/array/array_nested.cc
index 61eeb496e5a5b..df60074c78470 100644
--- a/cpp/src/arrow/array/array_nested.cc
+++ b/cpp/src/arrow/array/array_nested.cc
@@ -52,6 +52,9 @@ using internal::CopyBitmap;
 
 namespace {
 
+/// \brief Clean offsets when their null_count is greater than 0
+///
+/// \pre offsets.null_count() > 0
 template <typename TYPE>
 Result<BufferVector> CleanListOffsets(const std::shared_ptr<Buffer>& validity_buffer,
                                       const Array& offsets, MemoryPool* pool) {
@@ -59,43 +62,36 @@ Result<BufferVector> CleanListOffsets(const std::shared_ptr<Buffer>& validity_bu
   using OffsetArrowType = typename CTypeTraits<offset_type>::ArrowType;
   using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
 
-  const auto& typed_offsets = checked_cast<const OffsetArrayType&>(offsets);
+  DCHECK_GT(offsets.null_count(), 0);
   const int64_t num_offsets = offsets.length();
 
-  DCHECK(validity_buffer == nullptr || offsets.null_count() == 0)
-      << "When a validity_buffer is passed, offsets must have no nulls";
+  if (!offsets.IsValid(num_offsets - 1)) {
+    return Status::Invalid("Last list offset should be non-null");
+  }
 
-  if (offsets.null_count() > 0) {
-    if (!offsets.IsValid(num_offsets - 1)) {
-      return Status::Invalid("Last list offset should be non-null");
-    }
+  ARROW_ASSIGN_OR_RAISE(auto clean_offsets,
+                        AllocateBuffer(num_offsets * sizeof(offset_type), pool));
 
-    ARROW_ASSIGN_OR_RAISE(auto clean_offsets,
-                          AllocateBuffer(num_offsets * sizeof(offset_type), pool));
+  // Copy valid bits, ignoring the final offset (since for a length N list array,
+  // we have N + 1 offsets)
+  ARROW_ASSIGN_OR_RAISE(
+      auto clean_validity_buffer,
+      CopyBitmap(pool, offsets.null_bitmap()->data(), offsets.offset(), num_offsets - 1));
 
-    // Copy valid bits, ignoring the final offset (since for a length N list array,
-    // we have N + 1 offsets)
-    ARROW_ASSIGN_OR_RAISE(
-        auto clean_validity_buffer,
-        offsets.null_bitmap()->CopySlice(0, bit_util::BytesForBits(num_offsets - 1)));
-
-    const offset_type* raw_offsets = typed_offsets.raw_values();
-    auto clean_raw_offsets =
-        reinterpret_cast<offset_type*>(clean_offsets->mutable_data());
-
-    // Must work backwards so we can tell how many values were in the last non-null value
-    offset_type current_offset = raw_offsets[num_offsets - 1];
-    for (int64_t i = num_offsets - 1; i >= 0; --i) {
-      if (offsets.IsValid(i)) {
-        current_offset = raw_offsets[i];
-      }
-      clean_raw_offsets[i] = current_offset;
-    }
+  const offset_type* raw_offsets =
+      checked_cast<const OffsetArrayType&>(offsets).raw_values();
+  auto clean_raw_offsets = reinterpret_cast<offset_type*>(clean_offsets->mutable_data());
 
-    return BufferVector({std::move(clean_validity_buffer), std::move(clean_offsets)});
+  // Must work backwards so we can tell how many values were in the last non-null value
+  offset_type current_offset = raw_offsets[num_offsets - 1];
+  for (int64_t i = num_offsets - 1; i >= 0; --i) {
+    if (offsets.IsValid(i)) {
+      current_offset = raw_offsets[i];
+    }
+    clean_raw_offsets[i] = current_offset;
   }
 
-  return BufferVector({validity_buffer, typed_offsets.values()});
+  return BufferVector({std::move(clean_validity_buffer), std::move(clean_offsets)});
 }
 
 template <typename TYPE>
@@ -124,14 +120,21 @@ Result<std::shared_ptr<typename TypeTraits<TYPE>::ArrayType>> ListArrayFromArray
     return Status::NotImplemented("Null bitmap with offsets slice not supported.");
   }
 
-  std::shared_ptr<Buffer> offset_buf, validity_buf;
-  ARROW_ASSIGN_OR_RAISE(auto buffers, CleanListOffsets<TYPE>(null_bitmap, offsets, pool));
-  int64_t null_count_ = null_bitmap ? null_count : offsets.null_count();
+  // Clean the offsets if they contain nulls.
+  if (offsets.null_count() > 0) {
+    ARROW_ASSIGN_OR_RAISE(auto buffers,
+                          CleanListOffsets<TYPE>(null_bitmap, offsets, pool));
+    auto data = ArrayData::Make(type, offsets.length() - 1, std::move(buffers),
+                                {values.data()}, offsets.null_count(), /*offset=*/0);
+    return std::make_shared<ArrayType>(std::move(data));
+  }
 
-  std::shared_ptr<arrow::ArrayData> internal_data = ArrayData::Make(
-      type, offsets.length() - 1, std::move(buffers), null_count_, offsets.offset());
-  internal_data->child_data.push_back(values.data());
-  return std::make_shared<ArrayType>(internal_data);
+  using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
+  const auto& typed_offsets = checked_cast<const OffsetArrayType&>(offsets);
+  auto buffers = BufferVector({std::move(null_bitmap), typed_offsets.values()});
+  auto data = ArrayData::Make(type, offsets.length() - 1, std::move(buffers),
+                              {values.data()}, null_count, offsets.offset());
+  return std::make_shared<ArrayType>(std::move(data));
 }
 
 static std::shared_ptr<Array> SliceArrayWithOffsets(const Array& array, int64_t begin,
@@ -374,10 +377,18 @@ Result<std::shared_ptr<Array>> MapArray::FromArraysInternal(
     return Status::Invalid("Map key and item arrays must be equal length");
   }
 
-  ARROW_ASSIGN_OR_RAISE(auto buffers, CleanListOffsets<MapType>(NULLPTR, *offsets, pool));
+  if (offsets->null_count() > 0) {
+    ARROW_ASSIGN_OR_RAISE(auto buffers,
+                          CleanListOffsets<MapType>(NULLPTR, *offsets, pool));
+    return std::make_shared<MapArray>(type, offsets->length() - 1, std::move(buffers),
+                                      keys, items, offsets->null_count(), 0);
+  }
 
+  using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
+  const auto& typed_offsets = checked_cast<const OffsetArrayType&>(*offsets);
+  auto buffers = BufferVector({nullptr, typed_offsets.values()});
   return std::make_shared<MapArray>(type, offsets->length() - 1, std::move(buffers), keys,
-                                    items, offsets->null_count(), offsets->offset());
+                                    items, /*null_count=*/0, offsets->offset());
 }
 
 Result<std::shared_ptr<Array>> MapArray::FromArrays(const std::shared_ptr<Array>& offsets,

From 7b1e8348793924a1d95a66e200a4c33daaaa76cd Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 25 Jul 2023 10:25:43 -0400
Subject: [PATCH 041/749] GH-36852: [MATLAB] Add `arrow.type.Field` class
 (#36855)

### Rationale for this change

Now that the MATLAB interface supports creating `Type` objects - like `arrow.type.Int64Type`, we can add support for `Field` objects (i.e. name + type).

This mirrors the `Field` type in other Arrow interfaces, [like PyArrow](https://arrow.apache.org/docs/python/generated/pyarrow.field.html).

### What changes are included in this PR?

Two new user-facing APIs have been added:

1. `arrow.field(name, type)` constructor function
2. `arrow.type.Field` class (returned by the `arrow.field` constructor function).

**Example**:

```matlab
>> field = arrow.field("Speed", arrow.type.uint64)

field =

Speed: uint64

>> field.Type

ans =

  UInt64Type with properties:

    ID: UInt64

>> field.Name

ans =

    "Speed"
```

### Are these changes tested?

Yes.

1. Added new `tField.m` MATLAB test class.

### Are there any user-facing changes?

Yes.

Two new user-facing APIs have been added:

1. `arrow.field(name, type)` constructor function
2. `arrow.type.Field` class (returned by the `arrow.field` constructor function)

### Future Directions

1. We intentionally placed `arrow.field` in the top-level `arrow` package, rather than under a nested `arrow.type` package (where the corresponding class `arrow.type.Field` is). This is to avoid naming conflicts between `arrow.type.field` and `arrow.type.Field` and also to make it easier to use the recommended public/user-facing APIs with less typing (i.e. without needing to type nested package names). While working on this change, we realized that it would make sense to move the "type constructor functions" (e.g. `arrow.type.boolean`, `arrow.type.uint64`, etc.) into the top-level `arrow` package, as well (i.e. `arrow.boolean`, `arrow.uint64`, etc.). In other words, moving forward, the recommended APIs for the MATLAB interface will be placed directly under the top-level `arrow` package. This should hopefully result in a simplified public interface, as well as make it easier to use multiple language bindings (e.g. MATLAB and PyArrow) together, with less context switching.

### Notes

1. @ sgilmore10 is working on a follow up PR (to address #36853) for simplifying the `switch` statement code in `makeTypeProxy`. Her solution will be more generic, so that we can re-use it elsewhere across the code base of the MATLAB interface.
2. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #36852

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Kevin Gurney <kevin.p.gurney@gmail.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../src/cpp/arrow/matlab/type/proxy/field.cc  | 129 +++++++++++++++++
 .../src/cpp/arrow/matlab/type/proxy/field.h   |  44 ++++++
 matlab/src/matlab/+arrow/+type/Field.m        |  67 +++++++++
 matlab/src/matlab/+arrow/field.m              |  27 ++++
 matlab/test/arrow/type/tField.m               | 131 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   3 +-
 8 files changed, 403 insertions(+), 1 deletion(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/field.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/field.h
 create mode 100644 matlab/src/matlab/+arrow/+type/Field.m
 create mode 100644 matlab/src/matlab/+arrow/field.m
 create mode 100644 matlab/test/arrow/type/tField.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index b1b7b75b8c84a..b253e6c20ed27 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -171,4 +171,5 @@ namespace arrow::matlab::error {
     static const char* STRING_BUILDER_APPEND_FAILED = "arrow:matlab:array:string:StringBuilderAppendFailed";
     static const char* STRING_BUILDER_FINISH_FAILED = "arrow:matlab:array:string:StringBuilderFinishFailed";
     static const char* UKNOWN_TIME_UNIT_ERROR_ID = "arrow:matlab:UnknownTimeUnit";
+    static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
 }
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 2fb3207e590c6..ac9a595a45852 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -23,6 +23,7 @@
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/field.h"
 
 #include "factory.h"
 
@@ -43,6 +44,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
+    REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
     REGISTER_PROXY(arrow.type.proxy.Float32Type    , arrow::matlab::type::proxy::PrimitiveCType<float>);
     REGISTER_PROXY(arrow.type.proxy.Float64Type    , arrow::matlab::type::proxy::PrimitiveCType<double>);
     REGISTER_PROXY(arrow.type.proxy.UInt8Type      , arrow::matlab::type::proxy::PrimitiveCType<uint8_t>);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
new file mode 100644
index 0000000000000..4a43d813f0567
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
@@ -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.
+
+#include "arrow/util/utf8.h"
+
+#include "arrow/matlab/type/proxy/field.h"
+#include "arrow/matlab/error/error.h"
+
+#include "arrow/matlab/type/proxy/primitive_ctype.h"
+#include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/string_type.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::type::proxy {
+
+    Field::Field(std::shared_ptr<arrow::Field> field) : field{std::move(field)} {
+        REGISTER_METHOD(Field, name);
+        REGISTER_METHOD(Field, type);
+        REGISTER_METHOD(Field, toString);
+    }
+
+    std::shared_ptr<arrow::Field> Field::unwrap() {
+        return field;
+    }
+
+    void Field::name(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto& str_utf8 = field->name();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
+        auto str_mda = factory.createScalar(str_utf16);
+        context.outputs[0] = str_mda;
+    }
+
+    arrow::Result<std::shared_ptr<libmexclass::proxy::Proxy>> makeTypeProxy(const std::shared_ptr<arrow::DataType>& datatype) {
+        using arrow_type = arrow::Type::type;
+        namespace type_proxy = arrow::matlab::type::proxy;
+        switch (datatype->id()) {
+            case arrow_type::UINT8:
+                return std::make_shared<type_proxy::PrimitiveCType<uint8_t>>(std::static_pointer_cast<arrow::UInt8Type>(datatype));
+            case arrow_type::UINT16:
+                return std::make_shared<type_proxy::PrimitiveCType<uint16_t>>(std::static_pointer_cast<arrow::UInt16Type>(datatype));
+            case arrow_type::UINT32:
+                return std::make_shared<type_proxy::PrimitiveCType<uint32_t>>(std::static_pointer_cast<arrow::UInt32Type>(datatype));
+            case arrow_type::UINT64:
+                return std::make_shared<type_proxy::PrimitiveCType<uint64_t>>(std::static_pointer_cast<arrow::UInt64Type>(datatype));
+            case arrow_type::INT8:
+                return std::make_shared<type_proxy::PrimitiveCType<int8_t>>(std::static_pointer_cast<arrow::Int8Type>(datatype));
+            case arrow_type::INT16:
+                return std::make_shared<type_proxy::PrimitiveCType<int16_t>>(std::static_pointer_cast<arrow::Int16Type>(datatype));
+            case arrow_type::INT32:
+                return std::make_shared<type_proxy::PrimitiveCType<int32_t>>(std::static_pointer_cast<arrow::Int32Type>(datatype));
+            case arrow_type::INT64:
+                return std::make_shared<type_proxy::PrimitiveCType<int64_t>>(std::static_pointer_cast<arrow::Int64Type>(datatype));
+            case arrow_type::FLOAT:
+                return std::make_shared<type_proxy::PrimitiveCType<float>>(std::static_pointer_cast<arrow::FloatType>(datatype));
+            case arrow_type::DOUBLE:
+                return std::make_shared<type_proxy::PrimitiveCType<double>>(std::static_pointer_cast<arrow::DoubleType>(datatype));
+            case arrow_type::BOOL:
+                return std::make_shared<type_proxy::PrimitiveCType<bool>>(std::static_pointer_cast<arrow::BooleanType>(datatype));
+            case arrow_type::STRING:
+                return std::make_shared<type_proxy::StringType>(std::static_pointer_cast<arrow::StringType>(datatype));
+            case arrow_type::TIMESTAMP:
+                return std::make_shared<type_proxy::TimestampType>(std::static_pointer_cast<arrow::TimestampType>(datatype));
+            default:
+                return arrow::Status::NotImplemented("Unsupported DataType: " + datatype->ToString());
+        }
+    }
+
+
+    void Field::type(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        auto datatype = field->type();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto proxy, makeTypeProxy(datatype), context, "arrow:field:FailedToCreateTypeProxy");
+        const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(proxy);
+
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(proxy_id);
+        context.outputs[1] = factory.createScalar(static_cast<uint64_t>(datatype->id()));
+    }
+
+    void Field::toString(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto str_utf8 = field->ToString();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
+        auto str_mda = factory.createScalar(str_utf16);
+        context.outputs[0] = str_mda;
+    }
+
+    libmexclass::proxy::MakeResult Field::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using FieldProxy = arrow::matlab::type::proxy::Field;
+
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::StringArray name_mda = opts[0]["Name"];
+        const mda::TypedArray<uint64_t> type_proxy_id_mda = opts[0]["TypeProxyID"];
+
+        const std::u16string& name_utf16 = name_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto name,
+                arrow::util::UTF16StringToUTF8(name_utf16),
+                error::UNICODE_CONVERSION_ERROR_ID);
+
+        auto proxy = std::static_pointer_cast<type::proxy::Type>(libmexclass::proxy::ProxyManager::getProxy(type_proxy_id_mda[0]));
+        auto type = proxy->unwrap();
+        auto field = arrow::field(name, type);
+        return std::make_shared<FieldProxy>(std::move(field));
+    }
+
+}
+
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.h b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
new file mode 100644
index 0000000000000..8df73aa8af3a2
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
@@ -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.
+
+#pragma once
+
+#include "arrow/type.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::type::proxy {
+
+class Field : public libmexclass::proxy::Proxy {
+    public:
+        Field(std::shared_ptr<arrow::Field> field);
+
+        virtual ~Field() {}
+
+        std::shared_ptr<arrow::Field> unwrap();
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+        void name(libmexclass::proxy::method::Context& context);
+        void type(libmexclass::proxy::method::Context& context);
+        void toString(libmexclass::proxy::method::Context& context);
+
+        std::shared_ptr<arrow::Field> field;
+};
+
+}
diff --git a/matlab/src/matlab/+arrow/+type/Field.m b/matlab/src/matlab/+arrow/+type/Field.m
new file mode 100644
index 0000000000000..aaab36b048e37
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/Field.m
@@ -0,0 +1,67 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Field < matlab.mixin.CustomDisplay
+%FIELD A class representing a name and a type.
+% Fields are often used in tabular schemas for describing a column's
+% name and type.
+
+    properties (GetAccess=public, SetAccess=private, Hidden)
+        Proxy
+    end
+
+    properties (Dependent)
+        % Name of the field
+        Name
+        % Arrow type of the field
+        Type
+    end
+
+    methods
+        function obj = Field(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Field")}
+            end
+            import arrow.internal.proxy.validate
+
+            obj.Proxy = proxy;
+        end
+
+        function type = get.Type(obj)
+            [proxyID, typeID] = obj.Proxy.type();
+            traits = arrow.type.traits.traits(arrow.type.ID(typeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=proxyID);
+            type = traits.TypeConstructor(proxy);
+        end
+
+        function name = get.Name(obj)
+            name = obj.Proxy.name();
+        end
+
+    end
+
+    methods (Access = private)
+        function str = toString(obj)
+            str = obj.Proxy.toString();
+        end
+    end
+
+    methods (Access=protected)
+        function displayScalarObject(obj)
+            disp(obj.toString());
+        end
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/field.m b/matlab/src/matlab/+arrow/field.m
new file mode 100644
index 0000000000000..a14ed2268bd35
--- /dev/null
+++ b/matlab/src/matlab/+arrow/field.m
@@ -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.
+
+function f = field(name, type)
+%FIELD Creates an arrow.type.Field object
+    arguments
+        name(1, 1) string {mustBeNonmissing}
+        type(1, 1) arrow.type.Type
+    end
+
+    typeProxyID = type.Proxy.ID;
+    args = struct(Name=name, TypeProxyID=typeProxyID);
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.Field", args);
+    f = arrow.type.Field(proxy);
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
new file mode 100644
index 0000000000000..9f0a8851591ee
--- /dev/null
+++ b/matlab/test/arrow/type/tField.m
@@ -0,0 +1,131 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tField < matlab.unittest.TestCase
+% Test class for arrow.type.Field and arrow.field.
+
+    methods(Test)
+        function TestBasic(testCase)
+            name = "A";
+            type = arrow.type.uint64;
+            field = arrow.field(name, type);
+
+            testCase.verifyEqual(field.Name, name);
+            testCase.verifyEqual(field.Type.ID, type.ID);
+        end
+
+        function TestSupportedTypes(testCase)
+            name = "name";
+            supportedTypes = { ...
+                                 arrow.type.uint8, ...
+                                 arrow.type.uint16, ...
+                                 arrow.type.uint32, ...
+                                 arrow.type.uint64, ...
+                                 arrow.type.int8, ...
+                                 arrow.type.int16, ...
+                                 arrow.type.int32, ...
+                                 arrow.type.int64, ...
+                                 arrow.type.boolean, ...
+                                 arrow.type.float32, ...
+                                 arrow.type.float64, ...
+                                 arrow.type.string, ...
+                                 arrow.type.timestamp, ...
+                             };
+            for ii = 1:numel(supportedTypes)
+                supportedType = supportedTypes{ii};
+                field = arrow.field(name, supportedType);
+                testCase.verifyEqual(field.Name, name);
+                testCase.verifyEqual(field.Type.ID, supportedType.ID);
+            end
+        end
+
+        function TestNameUnicode(testCase)
+            smiley = "😀";
+            tree =  "🌲";
+            mango = "🥭";
+
+            type = arrow.type.uint64;
+            field = arrow.field(smiley, type);
+
+            testCase.verifyEqual(field.Name, smiley);
+            testCase.verifyEqual(field.Type.ID, type.ID);
+
+            field = arrow.field(tree, type);
+
+            testCase.verifyEqual(field.Name, tree);
+            testCase.verifyEqual(field.Type.ID, type.ID);
+
+            field = arrow.field(mango, type);
+
+            testCase.verifyEqual(field.Name, mango);
+            testCase.verifyEqual(field.Type.ID, type.ID);
+        end
+
+        function TestErrorIfNameStringMissing(testCase)
+            name = string(missing);
+            type = arrow.type.uint64;
+            testCase.verifyError(@() arrow.field(name, type), "MATLAB:validators:mustBeNonmissing");
+        end
+
+        function TestNameEmptyString(testCase)
+            name = "";
+            type = arrow.type.uint64;
+            field = arrow.field(name, type);
+
+            testCase.verifyEqual(field.Name, name);
+            testCase.verifyEqual(field.Type.ID, type.ID);
+        end
+
+        function TestNameCharVector(testCase)
+            name = 'ABC';
+            type = arrow.type.uint64;
+            field = arrow.field(name, type);
+
+            testCase.verifyEqual(field.Name, string(name));
+            testCase.verifyEqual(field.Type.ID, type.ID);
+        end
+
+        function TestNameNumber(testCase)
+            name = 123;
+            type = arrow.type.uint64;
+            field = arrow.field(name, type);
+
+            testCase.verifyEqual(field.Name, string(123));
+            testCase.verifyEqual(field.Type.ID, type.ID);
+        end
+
+        function TestArrowTypeUnsupportedInput(testCase)
+            name = "A";
+            type = { 123 };
+            testCase.verifyError(@() arrow.field(name, type), "MATLAB:validation:UnableToConvert");
+        end
+
+        function TestNameUnsupportedInput(testCase)
+            name = table();
+            type = arrow.type.uint64;
+            testCase.verifyError(@() arrow.field(name, type), "MATLAB:validation:UnableToConvert");
+        end
+
+        function TestImmutableProperties(testCase)
+            name = "A";
+            type = arrow.type.uint64;
+            field = arrow.field(name, type);
+
+            testCase.verifyError(@() setfield(field, "Name", "NewValue"), "MATLAB:class:noSetMethod")
+            testCase.verifyError(@() setfield(field, "Type", arrow.type.boolean), "MATLAB:class:noSetMethod")
+        end
+
+    end
+end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index c10ce07280fa6..c5a7c08aa5c10 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -51,7 +51,8 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc")
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc")
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy/factory.cc")

From 969f4b439c8dd9052372fe6c652dbd2459678042 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 25 Jul 2023 10:33:56 -0400
Subject: [PATCH 042/749] GH-36488: [C++] Import/Export ArrowDeviceArray
 (#36489)

### Rationale for this change
With the addition of the `ArrowDeviceArray` we should provide import/export functions just like we have for `ArrowArray`.

### What changes are included in this PR?
Adding Import/Export functions to the `bridge.h/.cc` files for C Data Non-CPU data.

This requires adding a device type to buffers and memory managers to propagate through.

### Are these changes tested?
Yes.

(Still need to add tests to `bridge_test.cc` but I wanted to get eyes on this first)

### Are there any user-facing changes?
No.

* Closes: #36488

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/buffer.h            |  22 +-
 cpp/src/arrow/buffer_test.cc      |  14 ++
 cpp/src/arrow/c/bridge.cc         | 192 +++++++++++++-
 cpp/src/arrow/c/bridge.h          | 130 ++++++++++
 cpp/src/arrow/c/bridge_test.cc    | 404 ++++++++++++++++++++++++++++++
 cpp/src/arrow/device.h            |  28 +++
 cpp/src/arrow/gpu/cuda_context.cc |   3 +-
 cpp/src/arrow/gpu/cuda_context.h  |   4 +
 cpp/src/arrow/gpu/cuda_memory.cc  |  21 ++
 cpp/src/arrow/gpu/cuda_memory.h   |   8 +-
 cpp/src/arrow/gpu/cuda_test.cc    |   4 +
 11 files changed, 823 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/buffer.h b/cpp/src/arrow/buffer.h
index ad2496aeeb5a6..08a3bd749e25d 100644
--- a/cpp/src/arrow/buffer.h
+++ b/cpp/src/arrow/buffer.h
@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -58,18 +59,31 @@ class ARROW_EXPORT Buffer {
   ///
   /// \note The passed memory must be kept alive through some other means
   Buffer(const uint8_t* data, int64_t size)
-      : is_mutable_(false), is_cpu_(true), data_(data), size_(size), capacity_(size) {
+      : is_mutable_(false),
+        is_cpu_(true),
+        data_(data),
+        size_(size),
+        capacity_(size),
+        device_type_(DeviceAllocationType::kCPU) {
     SetMemoryManager(default_cpu_memory_manager());
   }
 
   Buffer(const uint8_t* data, int64_t size, std::shared_ptr<MemoryManager> mm,
-         std::shared_ptr<Buffer> parent = NULLPTR)
+         std::shared_ptr<Buffer> parent = NULLPTR,
+         std::optional<DeviceAllocationType> device_type = std::nullopt)
       : is_mutable_(false),
         data_(data),
         size_(size),
         capacity_(size),
         parent_(std::move(parent)) {
+    // SetMemoryManager will also set device_type_
     SetMemoryManager(std::move(mm));
+    // if a device type is specified, use that instead. for example:
+    // CUDA_HOST. The CudaMemoryManager will set device_type_ to CUDA,
+    // but you can specify CUDA_HOST as the device type to override it.
+    if (device_type != std::nullopt) {
+      device_type_ = device_type;
+    }
   }
 
   Buffer(uintptr_t address, int64_t size, std::shared_ptr<MemoryManager> mm,
@@ -282,6 +296,8 @@ class ARROW_EXPORT Buffer {
 
   const std::shared_ptr<MemoryManager>& memory_manager() const { return memory_manager_; }
 
+  std::optional<DeviceAllocationType> device_type() const { return device_type_; }
+
   std::shared_ptr<Buffer> parent() const { return parent_; }
 
   /// \brief Get a RandomAccessFile for reading a buffer
@@ -336,6 +352,7 @@ class ARROW_EXPORT Buffer {
   const uint8_t* data_;
   int64_t size_;
   int64_t capacity_;
+  std::optional<DeviceAllocationType> device_type_;
 
   // null by default, but may be set
   std::shared_ptr<Buffer> parent_;
@@ -353,6 +370,7 @@ class ARROW_EXPORT Buffer {
   void SetMemoryManager(std::shared_ptr<MemoryManager> mm) {
     memory_manager_ = std::move(mm);
     is_cpu_ = memory_manager_->is_cpu();
+    device_type_ = memory_manager_->device()->device_type();
   }
 };
 
diff --git a/cpp/src/arrow/buffer_test.cc b/cpp/src/arrow/buffer_test.cc
index ce8bab846d586..3dd95cb8af5c6 100644
--- a/cpp/src/arrow/buffer_test.cc
+++ b/cpp/src/arrow/buffer_test.cc
@@ -41,6 +41,7 @@ using internal::checked_cast;
 using internal::checked_pointer_cast;
 
 static const char kMyDeviceTypeName[] = "arrowtest::MyDevice";
+static const DeviceAllocationType kMyDeviceType = DeviceAllocationType::kEXT_DEV;
 
 static const int kMyDeviceAllowCopy = 1;
 static const int kMyDeviceAllowView = 2;
@@ -70,6 +71,8 @@ class MyDevice : public Device {
     return checked_cast<const MyDevice&>(other).value_ == value_;
   }
 
+  DeviceAllocationType device_type() const override { return kMyDeviceType; }
+
   std::shared_ptr<MemoryManager> default_memory_manager() override;
 
   int value() const { return value_; }
@@ -256,6 +259,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
@@ -263,6 +267,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
@@ -271,6 +276,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), my_copy_device_);
   ASSERT_FALSE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), kMyDeviceType);
 #ifdef NDEBUG
   ASSERT_EQ(buffer->data(), nullptr);
 #endif
@@ -280,6 +286,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), my_copy_device_);
   ASSERT_FALSE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), kMyDeviceType);
 #ifdef NDEBUG
   ASSERT_EQ(buffer->data(), nullptr);
 #endif
@@ -290,6 +297,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), my_copy_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
@@ -297,6 +305,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), my_copy_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
@@ -305,6 +314,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), my_copy_device_);
   ASSERT_FALSE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), my_copy_src_->address());
+  ASSERT_EQ(buffer->device_type(), kMyDeviceType);
 #ifdef NDEBUG
   ASSERT_EQ(buffer->data(), nullptr);
 #endif
@@ -315,6 +325,7 @@ TEST_F(TestDevice, Copy) {
   ASSERT_EQ(buffer->device(), my_copy_device_);
   ASSERT_FALSE(buffer->is_cpu());
   ASSERT_NE(buffer->address(), my_copy_src_->address());
+  ASSERT_EQ(buffer->device_type(), kMyDeviceType);
 #ifdef NDEBUG
   ASSERT_EQ(buffer->data(), nullptr);
 #endif
@@ -330,6 +341,7 @@ TEST_F(TestDevice, View) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_EQ(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
@@ -338,6 +350,7 @@ TEST_F(TestDevice, View) {
   ASSERT_EQ(buffer->device(), my_view_device_);
   ASSERT_FALSE(buffer->is_cpu());
   ASSERT_EQ(buffer->address(), cpu_src_->address());
+  ASSERT_EQ(buffer->device_type(), kMyDeviceType);
 #ifdef NDEBUG
   ASSERT_EQ(buffer->data(), nullptr);
 #endif
@@ -348,6 +361,7 @@ TEST_F(TestDevice, View) {
   ASSERT_EQ(buffer->device(), cpu_device_);
   ASSERT_TRUE(buffer->is_cpu());
   ASSERT_EQ(buffer->address(), my_copy_src_->address());
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCPU);
   ASSERT_NE(buffer->data(), nullptr);
   AssertBufferEqual(*buffer, "some data");
 
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index 85a5156d11db2..13355dd6d05ae 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -522,6 +522,8 @@ struct ExportedArrayPrivateData : PoolAllocationMixin<ExportedArrayPrivateData>
 
   std::shared_ptr<ArrayData> data_;
 
+  RawSyncEvent sync_event_;
+
   ExportedArrayPrivateData() = default;
   ARROW_DEFAULT_MOVE_AND_ASSIGN(ExportedArrayPrivateData);
   ARROW_DISALLOW_COPY_AND_ASSIGN(ExportedArrayPrivateData);
@@ -544,7 +546,12 @@ void ReleaseExportedArray(struct ArrowArray* array) {
         << "Dictionary release callback should have marked it released";
   }
   DCHECK_NE(array->private_data, nullptr);
-  delete reinterpret_cast<ExportedArrayPrivateData*>(array->private_data);
+  auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(array->private_data);
+  if (pdata->sync_event_.sync_event != nullptr &&
+      pdata->sync_event_.release_func != nullptr) {
+    pdata->sync_event_.release_func(pdata->sync_event_.sync_event);
+  }
+  delete pdata;
 
   ArrowArrayMarkReleased(array);
 }
@@ -584,6 +591,7 @@ struct ArrayExporter {
     // Store owning pointer to ArrayData
     export_.data_ = data;
 
+    export_.sync_event_ = RawSyncEvent();
     return Status::OK();
   }
 
@@ -663,6 +671,118 @@ Status ExportRecordBatch(const RecordBatch& batch, struct ArrowArray* out,
   return Status::OK();
 }
 
+//////////////////////////////////////////////////////////////////////////
+// C device arrays
+
+Status ValidateDeviceInfo(const ArrayData& data,
+                          std::optional<DeviceAllocationType>* device_type,
+                          int64_t* device_id) {
+  for (const auto& buf : data.buffers) {
+    if (!buf) {
+      continue;
+    }
+
+    if (*device_type == std::nullopt) {
+      *device_type = buf->device_type();
+      *device_id = buf->device()->device_id();
+      continue;
+    }
+
+    if (buf->device_type() != *device_type) {
+      return Status::Invalid(
+          "Exporting device array with buffers on more than one device.");
+    }
+
+    if (buf->device()->device_id() != *device_id) {
+      return Status::Invalid(
+          "Exporting device array with buffers on multiple device ids.");
+    }
+  }
+
+  for (const auto& child : data.child_data) {
+    RETURN_NOT_OK(ValidateDeviceInfo(*child, device_type, device_id));
+  }
+
+  return Status::OK();
+}
+
+Result<std::pair<std::optional<DeviceAllocationType>, int64_t>> ValidateDeviceInfo(
+    const ArrayData& data) {
+  std::optional<DeviceAllocationType> device_type;
+  int64_t device_id = -1;
+  RETURN_NOT_OK(ValidateDeviceInfo(data, &device_type, &device_id));
+  return std::make_pair(device_type, device_id);
+}
+
+Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
+                         struct ArrowDeviceArray* out, struct ArrowSchema* out_schema) {
+  if (sync_event.sync_event != nullptr && sync_event.release_func) {
+    return Status::Invalid(
+        "Must provide a release event function if providing a non-null event");
+  }
+
+  SchemaExportGuard guard(out_schema);
+  if (out_schema != nullptr) {
+    RETURN_NOT_OK(ExportType(*array.type(), out_schema));
+  }
+
+  ARROW_ASSIGN_OR_RAISE(auto device_info, ValidateDeviceInfo(*array.data()));
+  if (!device_info.first) {
+    out->device_type = ARROW_DEVICE_CPU;
+  } else {
+    out->device_type = static_cast<ArrowDeviceType>(*device_info.first);
+  }
+  out->device_id = device_info.second;
+
+  ArrayExporter exporter;
+  RETURN_NOT_OK(exporter.Export(array.data()));
+  exporter.Finish(&out->array);
+
+  auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(out->array.private_data);
+  pdata->sync_event_ = sync_event;
+  out->sync_event = sync_event.sync_event;
+
+  guard.Detach();
+  return Status::OK();
+}
+
+Status ExportDeviceRecordBatch(const RecordBatch& batch, RawSyncEvent sync_event,
+                               struct ArrowDeviceArray* out,
+                               struct ArrowSchema* out_schema) {
+  if (sync_event.sync_event != nullptr && sync_event.release_func == nullptr) {
+    return Status::Invalid(
+        "Must provide a release event function if providing a non-null event");
+  }
+
+  // XXX perhaps bypass ToStructArray for speed?
+  ARROW_ASSIGN_OR_RAISE(auto array, batch.ToStructArray());
+
+  SchemaExportGuard guard(out_schema);
+  if (out_schema != nullptr) {
+    // Export the schema, not the struct type, so as not to lose top-level metadata
+    RETURN_NOT_OK(ExportSchema(*batch.schema(), out_schema));
+  }
+
+  ARROW_ASSIGN_OR_RAISE(auto device_info, ValidateDeviceInfo(*array->data()));
+  if (!device_info.first) {
+    out->device_type = ARROW_DEVICE_CPU;
+  } else {
+    out->device_type = static_cast<ArrowDeviceType>(*device_info.first);
+  }
+  out->device_id = device_info.second;
+
+  ArrayExporter exporter;
+  RETURN_NOT_OK(exporter.Export(array->data()));
+  exporter.Finish(&out->array);
+
+  auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(out->array.private_data);
+  pdata->sync_event_ = sync_event;
+  out->sync_event = sync_event.sync_event;
+
+  guard.Detach();
+  return Status::OK();
+}
+
 //////////////////////////////////////////////////////////////////////////
 // C schema import
 
@@ -1242,6 +1362,7 @@ namespace {
 // The ArrowArray is released on destruction.
 struct ImportedArrayData {
   struct ArrowArray array_;
+  void* sync_event_;
 
   ImportedArrayData() {
     ArrowArrayMarkReleased(&array_);  // Initially released
@@ -1267,6 +1388,11 @@ class ImportedBuffer : public Buffer {
                  std::shared_ptr<ImportedArrayData> import)
       : Buffer(data, size), import_(std::move(import)) {}
 
+  ImportedBuffer(const uint8_t* data, int64_t size, std::shared_ptr<MemoryManager> mm,
+                 DeviceAllocationType device_type,
+                 std::shared_ptr<ImportedArrayData> import)
+      : Buffer(data, size, mm, nullptr, device_type), import_(std::move(import)) {}
+
   ~ImportedBuffer() override {}
 
  protected:
@@ -1275,7 +1401,20 @@ class ImportedBuffer : public Buffer {
 
 struct ArrayImporter {
   explicit ArrayImporter(const std::shared_ptr<DataType>& type)
-      : type_(type), zero_size_buffer_(std::make_shared<Buffer>(kZeroSizeArea, 0)) {}
+      : type_(type),
+        zero_size_buffer_(std::make_shared<Buffer>(kZeroSizeArea, 0)),
+        device_type_(DeviceAllocationType::kCPU) {}
+
+  Status Import(struct ArrowDeviceArray* src, const DeviceMemoryMapper& mapper) {
+    ARROW_ASSIGN_OR_RAISE(memory_mgr_, mapper(src->device_type, src->device_id));
+    device_type_ = static_cast<DeviceAllocationType>(src->device_type);
+    RETURN_NOT_OK(Import(&src->array));
+    import_->sync_event_ = src->sync_event;
+    // reset internal state before next import
+    memory_mgr_.reset();
+    device_type_ = DeviceAllocationType::kCPU;
+    return Status::OK();
+  }
 
   Status Import(struct ArrowArray* src) {
     if (ArrowArrayIsReleased(src)) {
@@ -1588,7 +1727,12 @@ struct ArrayImporter {
     std::shared_ptr<Buffer>* out = &data_->buffers[buffer_id];
     auto data = reinterpret_cast<const uint8_t*>(c_struct_->buffers[buffer_id]);
     if (data != nullptr) {
-      *out = std::make_shared<ImportedBuffer>(data, buffer_size, import_);
+      if (memory_mgr_) {
+        *out = std::make_shared<ImportedBuffer>(data, buffer_size, memory_mgr_,
+                                                device_type_, import_);
+      } else {
+        *out = std::make_shared<ImportedBuffer>(data, buffer_size, import_);
+      }
     } else if (is_null_bitmap) {
       out->reset();
     } else {
@@ -1613,6 +1757,9 @@ struct ArrayImporter {
 
   // For imported null buffer pointers
   std::shared_ptr<Buffer> zero_size_buffer_;
+
+  std::shared_ptr<MemoryManager> memory_mgr_;
+  DeviceAllocationType device_type_;
 };
 
 }  // namespace
@@ -1652,6 +1799,45 @@ Result<std::shared_ptr<RecordBatch>> ImportRecordBatch(struct ArrowArray* array,
   return ImportRecordBatch(array, *maybe_schema);
 }
 
+Result<std::shared_ptr<Array>> ImportDeviceArray(struct ArrowDeviceArray* array,
+                                                 std::shared_ptr<DataType> type,
+                                                 const DeviceMemoryMapper& mapper) {
+  ArrayImporter importer(type);
+  RETURN_NOT_OK(importer.Import(array, mapper));
+  return importer.MakeArray();
+}
+
+Result<std::shared_ptr<Array>> ImportDeviceArray(struct ArrowDeviceArray* array,
+                                                 struct ArrowSchema* type,
+                                                 const DeviceMemoryMapper& mapper) {
+  auto maybe_type = ImportType(type);
+  if (!maybe_type.ok()) {
+    ArrowArrayRelease(&array->array);
+    return maybe_type.status();
+  }
+  return ImportDeviceArray(array, *maybe_type, mapper);
+}
+
+Result<std::shared_ptr<RecordBatch>> ImportDeviceRecordBatch(
+    struct ArrowDeviceArray* array, std::shared_ptr<Schema> schema,
+    const DeviceMemoryMapper& mapper) {
+  auto type = struct_(schema->fields());
+  ArrayImporter importer(type);
+  RETURN_NOT_OK(importer.Import(array, mapper));
+  return importer.MakeRecordBatch(std::move(schema));
+}
+
+Result<std::shared_ptr<RecordBatch>> ImportDeviceRecordBatch(
+    struct ArrowDeviceArray* array, struct ArrowSchema* schema,
+    const DeviceMemoryMapper& mapper) {
+  auto maybe_schema = ImportSchema(schema);
+  if (!maybe_schema.ok()) {
+    ArrowArrayRelease(&array->array);
+    return maybe_schema.status();
+  }
+  return ImportDeviceRecordBatch(array, *maybe_schema, mapper);
+}
+
 //////////////////////////////////////////////////////////////////////////
 // C stream export
 
diff --git a/cpp/src/arrow/c/bridge.h b/cpp/src/arrow/c/bridge.h
index 3b1a013d20dbf..92707a59729fc 100644
--- a/cpp/src/arrow/c/bridge.h
+++ b/cpp/src/arrow/c/bridge.h
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -166,6 +167,135 @@ Result<std::shared_ptr<RecordBatch>> ImportRecordBatch(struct ArrowArray* array,
 
 /// @}
 
+/// \defgroup c-data-device-interface Functions for working with the C data device
+/// interface.
+///
+/// @{
+
+/// \brief EXPERIMENTAL: Type for freeing a sync event
+///
+/// If synchronization is necessary for accessing the data on a device,
+/// a pointer to an event needs to be passed when exporting the device
+/// array. It's the responsibility of the release function for the array
+/// to release the event. Both can be null if no sync'ing is necessary.
+struct RawSyncEvent {
+  void* sync_event = NULL;
+  std::function<void(void*)> release_func;
+};
+
+/// \brief EXPERIMENTAL: Export C++ Array as an ArrowDeviceArray.
+///
+/// The resulting ArrowDeviceArray struct keeps the array data and buffers alive
+/// until its release callback is called by the consumer. All buffers in
+/// the provided array MUST have the same device_type, otherwise an error
+/// will be returned.
+///
+/// If a non-null sync_event is provided, then the sync_release func must also be
+/// non-null. If the sync_event is null, then the sync_release parameter is not called.
+///
+/// \param[in] array Array object to export
+/// \param[in] sync_event A struct containing what is needed for syncing if necessary
+/// \param[out] out C struct to export the array to
+/// \param[out] out_schema optional C struct to export the array type to
+ARROW_EXPORT
+Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
+                         struct ArrowDeviceArray* out,
+                         struct ArrowSchema* out_schema = NULLPTR);
+
+/// \brief EXPERIMENTAL: Export C++ RecordBatch as an ArrowDeviceArray.
+///
+/// The record batch is exported as if it were a struct array.
+/// The resulting ArrowDeviceArray struct keeps the record batch data and buffers alive
+/// until its release callback is called by the consumer.
+///
+/// All buffers of all columns in the record batch must have the same device_type
+/// otherwise an error will be returned. If columns are on different devices,
+/// they should be exported using different ArrowDeviceArray instances.
+///
+/// If a non-null sync_event is provided, then the sync_release func must also be
+/// non-null. If the sync_event is null, then the sync_release parameter is ignored.
+///
+/// \param[in] batch Record batch to export
+/// \param[in] sync_event A struct containing what is needed for syncing if necessary
+/// \param[out] out C struct where to export the record batch
+/// \param[out] out_schema optional C struct where to export the record batch schema
+ARROW_EXPORT
+Status ExportDeviceRecordBatch(const RecordBatch& batch, RawSyncEvent sync_event,
+                               struct ArrowDeviceArray* out,
+                               struct ArrowSchema* out_schema = NULLPTR);
+
+using DeviceMemoryMapper =
+    std::function<Result<std::shared_ptr<MemoryManager>>(ArrowDeviceType, int64_t)>;
+
+/// \brief EXPERIMENTAL: Import C++ device array from the C data interface.
+///
+/// The ArrowArray struct has its contents moved (as per the C data interface
+/// specification) to a private object held alive by the resulting array. The
+/// buffers of the Array are located on the device indicated by the device_type.
+///
+/// \param[in,out] array C data interface struct holding the array data
+/// \param[in] type type of the imported array
+/// \param[in] mapper A function to map device + id to memory manager
+/// \return Imported array object
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> ImportDeviceArray(struct ArrowDeviceArray* array,
+                                                 std::shared_ptr<DataType> type,
+                                                 const DeviceMemoryMapper& mapper);
+
+/// \brief EXPERIMENTAL: Import C++ device array and its type from the C data interface.
+///
+/// The ArrowArray struct has its contents moved (as per the C data interface
+/// specification) to a private object held alive by the resulting array.
+/// The ArrowSchema struct is released, even if this function fails. The
+/// buffers of the Array are located on the device indicated by the device_type.
+///
+/// \param[in,out] array C data interface struct holding the array data
+/// \param[in,out] type C data interface struct holding the array type
+/// \param[in] mapper A function to map device + id to memory manager
+/// \return Imported array object
+ARROW_EXPORT
+Result<std::shared_ptr<Array>> ImportDeviceArray(struct ArrowDeviceArray* array,
+                                                 struct ArrowSchema* type,
+                                                 const DeviceMemoryMapper& mapper);
+
+/// \brief EXPERIMENTAL: Import C++ record batch with buffers on a device from the C data
+/// interface.
+///
+/// The ArrowArray struct has its contents moved (as per the C data interface
+/// specification) to a private object held alive by the resulting record batch.
+/// The buffers of all columns of the record batch are located on the device
+/// indicated by the device type.
+///
+/// \param[in,out] array C data interface struct holding the record batch data
+/// \param[in] schema schema of the imported record batch
+/// \param[in] mapper A function to map device + id to memory manager
+/// \return Imported record batch object
+ARROW_EXPORT
+Result<std::shared_ptr<RecordBatch>> ImportDeviceRecordBatch(
+    struct ArrowDeviceArray* array, std::shared_ptr<Schema> schema,
+    const DeviceMemoryMapper& mapper);
+
+/// \brief EXPERIMENTAL: Import C++ record batch with buffers on a device and its schema
+/// from the C data interface.
+///
+/// The type represented by the ArrowSchema struct must be a struct type array.
+/// The ArrowArray struct has its contents moved (as per the C data interface
+/// specification) to a private object held alive by the resulting record batch.
+/// The ArrowSchema struct is released, even if this function fails. The buffers
+/// of all columns of the record batch are located on the device indicated by the
+/// device type.
+///
+/// \param[in,out] array C data interface struct holding the record batch data
+/// \param[in,out] schema C data interface struct holding the record batch schema
+/// \param[in] mapper A function to map device + id to memory manager
+/// \return Imported record batch object
+ARROW_EXPORT
+Result<std::shared_ptr<RecordBatch>> ImportDeviceRecordBatch(
+    struct ArrowDeviceArray* array, struct ArrowSchema* schema,
+    const DeviceMemoryMapper& mapper);
+
+/// @}
+
 /// \defgroup c-stream-interface Functions for working with the C data interface.
 ///
 /// @{
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 5fe7b653c8970..5c7de8e4a0783 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -565,6 +565,15 @@ struct ArrayExportChecker {
       ASSERT_EQ(c_export->children, nullptr);
     }
   }
+
+  void operator()(struct ArrowDeviceArray* c_export, const ArrayData& expected_data,
+                  const ArrowDeviceType device_type, const int64_t device_id,
+                  const void* sync_event) {
+    ASSERT_EQ(c_export->device_type, device_type);
+    ASSERT_EQ(c_export->device_id, device_id);
+    ASSERT_EQ(c_export->sync_event, sync_event);
+    this->operator()(&c_export->array, expected_data);
+  }
 };
 
 struct RecordBatchExportChecker {
@@ -592,6 +601,15 @@ struct RecordBatchExportChecker {
       ASSERT_EQ(c_export->children, nullptr);
     }
   }
+
+  void operator()(struct ArrowDeviceArray* c_export, const RecordBatch& expected_data,
+                  const ArrowDeviceType device_type, const int64_t device_id,
+                  const void* sync_event) {
+    ASSERT_EQ(c_export->device_type, device_type);
+    ASSERT_EQ(c_export->device_id, device_id);
+    ASSERT_EQ(c_export->sync_event, sync_event);
+    this->operator()(&c_export->array, expected_data);
+  }
 };
 
 class TestArrayExport : public ::testing::Test {
@@ -1112,6 +1130,392 @@ TEST_F(TestArrayExport, ExportRecordBatch) {
   }
 }
 
+////////////////////////////////////////////////////////////////////////////
+// Device Array Export Tests
+
+static const char kMyDeviceTypeName[] = "arrowtest::MyDevice";
+static const ArrowDeviceType kMyDeviceType = ARROW_DEVICE_EXT_DEV;
+
+class MyBuffer final : public MutableBuffer {
+ public:
+  using MutableBuffer::MutableBuffer;
+
+  ~MyBuffer() { default_memory_pool()->Free(const_cast<uint8_t*>(data_), size_); }
+};
+
+class MyMemoryManager : public CPUMemoryManager {
+ public:
+  explicit MyMemoryManager(const std::shared_ptr<Device>& device)
+      : CPUMemoryManager(device, default_memory_pool()) {}
+
+  Result<std::unique_ptr<Buffer>> AllocateBuffer(int64_t size) override {
+    uint8_t* data;
+    RETURN_NOT_OK(pool_->Allocate(size, &data));
+    return std::make_unique<MyBuffer>(data, size, shared_from_this());
+  }
+
+ protected:
+  Result<std::shared_ptr<Buffer>> CopyBufferFrom(
+      const std::shared_ptr<Buffer>& buf,
+      const std::shared_ptr<MemoryManager>& from) override {
+    return CopyNonOwnedFrom(*buf, from);
+  }
+  Result<std::unique_ptr<Buffer>> CopyNonOwnedFrom(
+      const Buffer& buf, const std::shared_ptr<MemoryManager>& from) override {
+    if (!from->is_cpu()) {
+      return nullptr;
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto dest, AllocateBuffer(buf.size()));
+    if (buf.size() > 0) {
+      memcpy(dest->mutable_data(), buf.data(), static_cast<size_t>(buf.size()));
+    }
+    return std::move(dest);
+  }
+};
+
+class MyDevice : public Device {
+ public:
+  explicit MyDevice(int value) : Device(true), value_(value) {}
+  const char* type_name() const override { return kMyDeviceTypeName; }
+  std::string ToString() const override { return kMyDeviceTypeName; }
+  bool Equals(const Device& other) const override {
+    if (other.type_name() != kMyDeviceTypeName || other.device_type() != device_type()) {
+      return false;
+    }
+    return checked_cast<const MyDevice&>(other).value_ == value_;
+  }
+  DeviceAllocationType device_type() const override {
+    return static_cast<DeviceAllocationType>(kMyDeviceType);
+  }
+  int64_t device_id() const override { return value_; }
+  std::shared_ptr<MemoryManager> default_memory_manager() override {
+    return std::make_shared<MyMemoryManager>(shared_from_this());
+  }
+
+ protected:
+  int value_;
+};
+
+class TestDeviceArrayExport : public ::testing::Test {
+ public:
+  void SetUp() override { pool_ = default_memory_pool(); }
+
+  static Result<std::shared_ptr<ArrayData>> ToDeviceData(
+      const std::shared_ptr<MemoryManager>& mm, const ArrayData& data) {
+    arrow::BufferVector buffers;
+    for (const auto& buf : data.buffers) {
+      if (buf) {
+        ARROW_ASSIGN_OR_RAISE(auto dest, mm->CopyBuffer(buf, mm));
+        buffers.push_back(dest);
+      } else {
+        buffers.push_back(nullptr);
+      }
+    }
+
+    arrow::ArrayDataVector children;
+    for (const auto& child : data.child_data) {
+      ARROW_ASSIGN_OR_RAISE(auto dest, ToDeviceData(mm, *child));
+      children.push_back(dest);
+    }
+
+    return ArrayData::Make(data.type, data.length, buffers, children, data.null_count,
+                           data.offset);
+  }
+
+  static Result<std::shared_ptr<Array>> ToDevice(const std::shared_ptr<MemoryManager>& mm,
+                                                 const ArrayData& data) {
+    ARROW_ASSIGN_OR_RAISE(auto result, ToDeviceData(mm, data));
+    return MakeArray(result);
+  }
+
+  template <typename ArrayFactory>
+  static std::function<Result<std::shared_ptr<Array>>()> ToDeviceFactory(
+      const std::shared_ptr<MemoryManager>& mm, ArrayFactory&& factory) {
+    return [&]() { return ToDevice(mm, *factory()->data()); };
+  }
+
+  static std::function<Result<std::shared_ptr<Array>>()> JSONArrayFactory(
+      const std::shared_ptr<MemoryManager>& mm, std::shared_ptr<DataType> type,
+      const char* json) {
+    return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
+  }
+
+  template <typename ArrayFactory, typename ExportCheckFunc>
+  void TestWithArrayFactory(ArrayFactory&& factory, ExportCheckFunc&& check_func) {
+    auto orig_bytes = pool_->bytes_allocated();
+
+    std::shared_ptr<Array> arr;
+    ASSERT_OK_AND_ASSIGN(arr, ToResult(factory()));
+    ARROW_SCOPED_TRACE("type = ", arr->type()->ToString(),
+                       ", array data = ", arr->ToString());
+    const ArrayData& data = *arr->data();  // non-owning reference
+    struct ArrowDeviceArray c_export;
+    ASSERT_OK(ExportDeviceArray(*arr, {nullptr, nullptr}, &c_export));
+
+    ArrayExportGuard guard(&c_export.array);
+    auto new_bytes = pool_->bytes_allocated();
+    ASSERT_GT(new_bytes, orig_bytes);
+
+    // Release the shared_ptr<Array>, underlying data should be held alive
+    arr.reset();
+    ASSERT_EQ(pool_->bytes_allocated(), new_bytes);
+    check_func(&c_export, data, kMyDeviceType, 1, nullptr);
+
+    // Release the ArrowArray, underlying data should be destroyed
+    guard.Release();
+    ASSERT_EQ(pool_->bytes_allocated(), orig_bytes);
+  }
+
+  template <typename ArrayFactory>
+  void TestNested(ArrayFactory&& factory) {
+    ArrayExportChecker checker;
+    TestWithArrayFactory(std::forward<ArrayFactory>(factory), checker);
+  }
+
+  void TestNested(const std::shared_ptr<MemoryManager>& mm,
+                  const std::shared_ptr<DataType>& type, const char* json) {
+    TestNested(JSONArrayFactory(mm, type, json));
+  }
+
+  template <typename ArrayFactory>
+  void TestPrimitive(ArrayFactory&& factory) {
+    TestNested(std::forward<ArrayFactory>(factory));
+  }
+
+  void TestPrimitive(const std::shared_ptr<MemoryManager>& mm,
+                     const std::shared_ptr<DataType>& type, const char* json) {
+    TestNested(mm, type, json);
+  }
+
+ protected:
+  MemoryPool* pool_;
+};
+
+TEST_F(TestDeviceArrayExport, Primitive) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  TestPrimitive(mm, int8(), "[1, 2, null, -3]");
+  TestPrimitive(mm, int16(), "[1, 2, -3]");
+  TestPrimitive(mm, int32(), "[1, 2, null, -3]");
+  TestPrimitive(mm, int64(), "[1, 2, -3]");
+  TestPrimitive(mm, uint8(), "[1, 2, 3]");
+  TestPrimitive(mm, uint16(), "[1, 2, null, 3]");
+  TestPrimitive(mm, uint32(), "[1, 2, 3]");
+  TestPrimitive(mm, uint64(), "[1, 2, null, 3]");
+
+  TestPrimitive(mm, boolean(), "[true, false, null]");
+
+  TestPrimitive(mm, float32(), "[1.5, null]");
+  TestPrimitive(mm, float64(), "[1.5, null]");
+
+  TestPrimitive(mm, fixed_size_binary(3), R"(["foo", "bar", null])");
+  TestPrimitive(mm, binary(), R"(["foo", "bar", null])");
+  TestPrimitive(mm, large_binary(), R"(["foo", "bar", null])");
+  TestPrimitive(mm, utf8(), R"(["foo", "bar", null])");
+  TestPrimitive(mm, large_utf8(), R"(["foo", "bar", null])");
+
+  TestPrimitive(mm, decimal(16, 4), R"(["1234.5670", null])");
+  TestPrimitive(mm, decimal256(16, 4), R"(["1234.5670", null])");
+
+  TestPrimitive(mm, month_day_nano_interval(), R"([[-1, 5, 20], null])");
+}
+
+TEST_F(TestDeviceArrayExport, PrimitiveSliced) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  auto factory = [=]() {
+    return (*ToDevice(mm, *ArrayFromJSON(int16(), "[1, 2, null, -3]")->data()))
+        ->Slice(1, 2);
+  };
+  TestPrimitive(factory);
+}
+
+TEST_F(TestDeviceArrayExport, Temporal) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  const char* json = "[1, 2, null, 42]";
+  TestPrimitive(mm, date32(), json);
+  TestPrimitive(mm, date64(), json);
+  TestPrimitive(mm, time32(TimeUnit::SECOND), json);
+  TestPrimitive(mm, time32(TimeUnit::MILLI), json);
+  TestPrimitive(mm, time64(TimeUnit::MICRO), json);
+  TestPrimitive(mm, time64(TimeUnit::NANO), json);
+  TestPrimitive(mm, duration(TimeUnit::SECOND), json);
+  TestPrimitive(mm, duration(TimeUnit::MILLI), json);
+  TestPrimitive(mm, duration(TimeUnit::MICRO), json);
+  TestPrimitive(mm, duration(TimeUnit::NANO), json);
+  TestPrimitive(mm, month_interval(), json);
+
+  TestPrimitive(mm, day_time_interval(), "[[7, 600], null]");
+
+  json = R"(["1970-01-01","2000-02-29","1900-02-28"])";
+  TestPrimitive(mm, timestamp(TimeUnit::SECOND), json);
+  TestPrimitive(mm, timestamp(TimeUnit::SECOND, "Europe/Paris"), json);
+  TestPrimitive(mm, timestamp(TimeUnit::MILLI), json);
+  TestPrimitive(mm, timestamp(TimeUnit::MILLI, "Europe/Paris"), json);
+  TestPrimitive(mm, timestamp(TimeUnit::MICRO), json);
+  TestPrimitive(mm, timestamp(TimeUnit::MICRO, "Europe/Paris"), json);
+  TestPrimitive(mm, timestamp(TimeUnit::NANO), json);
+  TestPrimitive(mm, timestamp(TimeUnit::NANO, "Europe/Paris"), json);
+}
+
+TEST_F(TestDeviceArrayExport, List) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  TestNested(mm, list(int8()), "[[1, 2], [3, null], null]");
+  TestNested(mm, large_list(uint16()), "[[1, 2], [3, null], null]");
+  TestNested(mm, fixed_size_list(int64(), 2), "[[1, 2], [3, null], null]");
+
+  TestNested(mm, list(large_list(int32())), "[[[1, 2], [3], null], null]");
+}
+
+TEST_F(TestDeviceArrayExport, ListSliced) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  {
+    auto factory = [=]() {
+      return (*ToDevice(
+                  mm, *ArrayFromJSON(list(int8()), "[[1, 2], [3, null], [4, 5, 6], null]")
+                           ->data()))
+          ->Slice(1, 2);
+    };
+    TestNested(factory);
+  }
+  {
+    auto factory = [=]() {
+      auto values =
+          (*ToDevice(mm,
+                     *ArrayFromJSON(int16(), "[1, 2, 3, 4, null, 5, 6, 7, 8]")->data()))
+              ->Slice(1, 6);
+      auto offsets = (*ToDevice(mm, *ArrayFromJSON(int32(), "[0, 2, 3, 5, 6]")->data()))
+                         ->Slice(2, 4);
+      return ListArray::FromArrays(*offsets, *values);
+    };
+    TestNested(factory);
+  }
+}
+
+TEST_F(TestDeviceArrayExport, Struct) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  const char* data = R"([[1, "foo"], [2, null]])";
+  auto type = struct_({field("a", int8()), field("b", utf8())});
+  TestNested(mm, type, data);
+}
+
+TEST_F(TestDeviceArrayExport, Map) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  const char* json = R"([[[1, "foo"], [2, null]], [[3, "bar"]]])";
+  TestNested(mm, map(int8(), utf8()), json);
+  TestNested(mm, map(int8(), utf8(), /*keys_sorted=*/true), json);
+}
+
+TEST_F(TestDeviceArrayExport, Union) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  const char* data = "[null, [42, 1], [43, true], [42, null], [42, 2]]";
+  // Dense
+  auto field_a = field("a", int8());
+  auto field_b = field("b", boolean(), /*nullable=*/false);
+  auto type = dense_union({field_a, field_b}, {42, 43});
+  TestNested(mm, type, data);
+  // Sparse
+  field_a = field("a", int8(), /*nullable=*/false);
+  field_b = field("b", boolean());
+  type = sparse_union({field_a, field_b}, {42, 43});
+  TestNested(mm, type, data);
+}
+
+TEST_F(TestDeviceArrayExport, Extension) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  TestPrimitive(ToDeviceFactory(mm, ExampleUuid));
+  TestPrimitive(ToDeviceFactory(mm, ExampleSmallint));
+  TestPrimitive(ToDeviceFactory(mm, ExampleComplex128));
+}
+
+TEST_F(TestDeviceArrayExport, ExportArrayAndType) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  struct ArrowSchema c_schema {};
+  struct ArrowDeviceArray c_array {};
+  SchemaExportGuard schema_guard(&c_schema);
+  ArrayExportGuard array_guard(&c_array.array);
+
+  auto array = ToDevice(mm, *ArrayFromJSON(int8(), "[1, 2, 3]")->data()).ValueOrDie();
+  ASSERT_OK(ExportDeviceArray(*array, {nullptr, nullptr}, &c_array, &c_schema));
+  const ArrayData& data = *array->data();
+  array.reset();
+  ASSERT_FALSE(ArrowSchemaIsReleased(&c_schema));
+  ASSERT_FALSE(ArrowArrayIsReleased(&c_array.array));
+  ASSERT_EQ(c_schema.format, std::string("c"));
+  ASSERT_EQ(c_schema.n_children, 0);
+  ArrayExportChecker checker{};
+  checker(&c_array, data, kMyDeviceType, 1, nullptr);
+}
+
+TEST_F(TestDeviceArrayExport, ExportRecordBatch) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  struct ArrowSchema c_schema {};
+  struct ArrowDeviceArray c_array {};
+
+  auto schema = ::arrow::schema(
+      {field("ints", int16()), field("bools", boolean(), /*nullable=*/false)});
+  schema = schema->WithMetadata(key_value_metadata(kMetadataKeys2, kMetadataValues2));
+  auto arr0 = ToDevice(mm, *ArrayFromJSON(int16(), "[1, 2, null]")->data()).ValueOrDie();
+  auto arr1 = ToDevice(mm, *ArrayFromJSON(boolean(), "[false, true, false]")->data())
+                  .ValueOrDie();
+
+  auto batch_factory = [&]() { return RecordBatch::Make(schema, 3, {arr0, arr1}); };
+
+  {
+    auto batch = batch_factory();
+
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, {nullptr, nullptr}, &c_array, &c_schema));
+    SchemaExportGuard schema_guard(&c_schema);
+    ArrayExportGuard array_guard(&c_array.array);
+    RecordBatchExportChecker checker{};
+    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+
+    // create batch anew, with the same buffer pointers
+    batch = batch_factory();
+    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+  }
+  {
+    // Check one can export both schema and record batch at once
+    auto batch = batch_factory();
+
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, {nullptr, nullptr}, &c_array, &c_schema));
+    SchemaExportGuard schema_guard(&c_schema);
+    ArrayExportGuard array_guard(&c_array.array);
+    ASSERT_EQ(c_schema.format, std::string("+s"));
+    ASSERT_EQ(c_schema.n_children, 2);
+    ASSERT_NE(c_schema.metadata, nullptr);
+    ASSERT_EQ(kEncodedMetadata2,
+              std::string(c_schema.metadata, kEncodedMetadata2.size()));
+    RecordBatchExportChecker checker{};
+    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+
+    // Create batch anew, with the same buffer pointers
+    batch = batch_factory();
+    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////
 // Schema import tests
 
diff --git a/cpp/src/arrow/device.h b/cpp/src/arrow/device.h
index 67c62a5181f28..9cc68fe8c82ce 100644
--- a/cpp/src/arrow/device.h
+++ b/cpp/src/arrow/device.h
@@ -29,6 +29,24 @@
 
 namespace arrow {
 
+/// \brief EXPERIMENTAL: Device type enum which matches up with C Data Device types
+enum class DeviceAllocationType : char {
+  kCPU = 1,
+  kCUDA = 2,
+  kCUDA_HOST = 3,
+  kOPENCL = 4,
+  kVULKAN = 7,
+  kMETAL = 8,
+  kVPI = 9,
+  kROCM = 10,
+  kROCM_HOST = 11,
+  kEXT_DEV = 12,
+  kCUDA_MANAGED = 13,
+  kONEAPI = 14,
+  kWEBGPU = 15,
+  kHEXAGON = 16,
+};
+
 class MemoryManager;
 
 /// \brief EXPERIMENTAL: Abstract interface for hardware devices
@@ -58,6 +76,12 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
   /// \brief Whether this instance points to the same device as another one.
   virtual bool Equals(const Device&) const = 0;
 
+  /// \brief A device ID to identify this device if there are multiple of this type.
+  ///
+  /// If there is no "device_id" equivalent (such as for the main CPU device on
+  /// non-numa systems) returns -1.
+  virtual int64_t device_id() const { return -1; }
+
   /// \brief Whether this device is the main CPU device.
   ///
   /// This shorthand method is very useful when deciding whether a memory address
@@ -71,6 +95,9 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
   /// MemoryManager instances with non-default parameters.
   virtual std::shared_ptr<MemoryManager> default_memory_manager() = 0;
 
+  /// \brief Return the DeviceAllocationType of this device
+  virtual DeviceAllocationType device_type() const = 0;
+
  protected:
   ARROW_DISALLOW_COPY_AND_ASSIGN(Device);
   explicit Device(bool is_cpu = false) : is_cpu_(is_cpu) {}
@@ -172,6 +199,7 @@ class ARROW_EXPORT CPUDevice : public Device {
   const char* type_name() const override;
   std::string ToString() const override;
   bool Equals(const Device&) const override;
+  DeviceAllocationType device_type() const override { return DeviceAllocationType::kCPU; }
 
   std::shared_ptr<MemoryManager> default_memory_manager() override;
 
diff --git a/cpp/src/arrow/gpu/cuda_context.cc b/cpp/src/arrow/gpu/cuda_context.cc
index f754c07d13c89..869ea6453ccda 100644
--- a/cpp/src/arrow/gpu/cuda_context.cc
+++ b/cpp/src/arrow/gpu/cuda_context.cc
@@ -384,7 +384,8 @@ Result<std::shared_ptr<Buffer>> CudaMemoryManager::ViewBufferTo(
   if (to->is_cpu()) {
     // Device-on-CPU view
     ARROW_ASSIGN_OR_RAISE(auto address, GetHostAddress(buf->address()));
-    return std::make_shared<Buffer>(address, buf->size(), to, buf);
+    return std::make_shared<Buffer>(address, buf->size(), to, buf,
+                                    DeviceAllocationType::kCUDA_HOST);
   }
   return nullptr;
 }
diff --git a/cpp/src/arrow/gpu/cuda_context.h b/cpp/src/arrow/gpu/cuda_context.h
index 0115ed19a103d..a1b95c7b4181d 100644
--- a/cpp/src/arrow/gpu/cuda_context.h
+++ b/cpp/src/arrow/gpu/cuda_context.h
@@ -92,6 +92,10 @@ class ARROW_EXPORT CudaDevice : public Device {
   std::string ToString() const override;
   bool Equals(const Device&) const override;
   std::shared_ptr<MemoryManager> default_memory_manager() override;
+  DeviceAllocationType device_type() const override {
+    return DeviceAllocationType::kCUDA;
+  }
+  int64_t device_id() const override { return device_number(); }
 
   /// \brief Return a CudaDevice instance for a particular device
   /// \param[in] device_number the CUDA device number
diff --git a/cpp/src/arrow/gpu/cuda_memory.cc b/cpp/src/arrow/gpu/cuda_memory.cc
index 297e4dcf71e44..860c6311d7b2f 100644
--- a/cpp/src/arrow/gpu/cuda_memory.cc
+++ b/cpp/src/arrow/gpu/cuda_memory.cc
@@ -198,6 +198,11 @@ Result<std::shared_ptr<CudaIpcMemHandle>> CudaBuffer::ExportForIpc() {
   return handle;
 }
 
+CudaHostBuffer::CudaHostBuffer(uint8_t* data, const int64_t size)
+    : MutableBuffer(data, size) {
+  device_type_ = DeviceAllocationType::kCUDA_HOST;
+}
+
 CudaHostBuffer::~CudaHostBuffer() {
   auto maybe_manager = CudaDeviceManager::Instance();
   ARROW_CHECK_OK(maybe_manager.status());
@@ -480,5 +485,21 @@ Result<uint8_t*> GetHostAddress(uintptr_t device_ptr) {
   return static_cast<uint8_t*>(ptr);
 }
 
+Result<std::shared_ptr<MemoryManager>> DefaultMemoryMapper(ArrowDeviceType device_type,
+                                                           int64_t device_id) {
+  switch (device_type) {
+    case ARROW_DEVICE_CPU:
+      return default_cpu_memory_manager();
+    case ARROW_DEVICE_CUDA:
+    case ARROW_DEVICE_CUDA_HOST:
+    case ARROW_DEVICE_CUDA_MANAGED: {
+      ARROW_ASSIGN_OR_RAISE(auto device, arrow::cuda::CudaDevice::Make(device_id));
+      return device->default_memory_manager();
+    }
+    default:
+      return Status::NotImplemented("memory manager not implemented for device");
+  }
+}
+
 }  // namespace cuda
 }  // namespace arrow
diff --git a/cpp/src/arrow/gpu/cuda_memory.h b/cpp/src/arrow/gpu/cuda_memory.h
index 18c23a507805a..d323bef03494e 100644
--- a/cpp/src/arrow/gpu/cuda_memory.h
+++ b/cpp/src/arrow/gpu/cuda_memory.h
@@ -21,6 +21,7 @@
 #include <memory>
 
 #include "arrow/buffer.h"
+#include "arrow/c/abi.h"
 #include "arrow/io/concurrency.h"
 #include "arrow/type_fwd.h"
 
@@ -110,7 +111,8 @@ class ARROW_EXPORT CudaBuffer : public Buffer {
 /// \brief Device-accessible CPU memory created using cudaHostAlloc
 class ARROW_EXPORT CudaHostBuffer : public MutableBuffer {
  public:
-  using MutableBuffer::MutableBuffer;
+  CudaHostBuffer(uint8_t* data, const int64_t size);
+
   ~CudaHostBuffer();
 
   /// \brief Return a device address the GPU can read this memory from.
@@ -258,5 +260,9 @@ Result<uintptr_t> GetDeviceAddress(const uint8_t* cpu_data,
 ARROW_EXPORT
 Result<uint8_t*> GetHostAddress(uintptr_t device_ptr);
 
+ARROW_EXPORT
+Result<std::shared_ptr<MemoryManager>> DefaultMemoryMapper(ArrowDeviceType device_type,
+                                                           int64_t device_id);
+
 }  // namespace cuda
 }  // namespace arrow
diff --git a/cpp/src/arrow/gpu/cuda_test.cc b/cpp/src/arrow/gpu/cuda_test.cc
index aac45d13831e5..6d392213e231f 100644
--- a/cpp/src/arrow/gpu/cuda_test.cc
+++ b/cpp/src/arrow/gpu/cuda_test.cc
@@ -364,6 +364,7 @@ TEST_F(TestCudaHostBuffer, AllocateGlobal) {
 
   ASSERT_TRUE(host_buffer->is_cpu());
   ASSERT_EQ(host_buffer->memory_manager(), cpu_mm_);
+  ASSERT_EQ(host_buffer->device_type(), DeviceAllocationType::kCUDA_HOST);
 
   ASSERT_OK_AND_ASSIGN(auto device_address, host_buffer->GetDeviceAddress(context_));
   ASSERT_NE(device_address, 0);
@@ -376,6 +377,7 @@ TEST_F(TestCudaHostBuffer, ViewOnDevice) {
 
   ASSERT_TRUE(host_buffer->is_cpu());
   ASSERT_EQ(host_buffer->memory_manager(), cpu_mm_);
+  ASSERT_EQ(host_buffer->device_type(), DeviceAllocationType::kCUDA_HOST);
 
   // Try to view the host buffer on the device.  This should correspond to
   // GetDeviceAddress() in the previous test.
@@ -385,6 +387,7 @@ TEST_F(TestCudaHostBuffer, ViewOnDevice) {
   ASSERT_NE(device_buffer->address(), 0);
   ASSERT_EQ(device_buffer->size(), host_buffer->size());
   ASSERT_EQ(device_buffer->parent(), host_buffer);
+  ASSERT_EQ(device_buffer->device_type(), DeviceAllocationType::kCUDA);
 
   // View back the device buffer on the CPU.  This should roundtrip.
   ASSERT_OK_AND_ASSIGN(auto buffer, Buffer::View(device_buffer, cpu_mm_));
@@ -393,6 +396,7 @@ TEST_F(TestCudaHostBuffer, ViewOnDevice) {
   ASSERT_EQ(buffer->address(), host_buffer->address());
   ASSERT_EQ(buffer->size(), host_buffer->size());
   ASSERT_EQ(buffer->parent(), device_buffer);
+  ASSERT_EQ(buffer->device_type(), DeviceAllocationType::kCUDA_HOST);
 }
 
 // ------------------------------------------------------------------------

From 724ba6cd2391a856b72636385c56d664f74b577e Mon Sep 17 00:00:00 2001
From: Thor <8681572+thorfour@users.noreply.github.com>
Date: Tue, 25 Jul 2023 09:55:57 -0500
Subject: [PATCH 043/749] GH-36858: [Go] Fix dictionary builder leak (#36859)

### Rationale for this change

This fixes a potential leak when using a memory allocator that can panic.

### What changes are included in this PR?

This moves the `Retain` call to happen after the last potential allocation in `newWithDictOffset` to prevent a leak.

### Are these changes tested?

A unit test was added that causes the builder to panic on the `GetDictArrayData` step.

### Are there any user-facing changes?

* Closes: #36858

Authored-by: thorfour <me@thor-hansen.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/dictionary.go      |  2 +-
 go/arrow/array/dictionary_test.go | 46 +++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index 8c3ffb5247fe0..da1aea50b24f8 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -814,11 +814,11 @@ func (b *dictionaryBuilder) newWithDictOffset(offset int) (indices, dict *Data,
 	defer idxarr.Release()
 
 	indices = idxarr.Data().(*Data)
-	indices.Retain()
 
 	b.deltaOffset = b.memoTable.Size()
 	dict, err = GetDictArrayData(b.mem, b.dt.ValueType, b.memoTable, offset)
 	b.reset()
+	indices.Retain()
 	return
 }
 
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index cc252e26855db..8bb9edebf89bc 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -1800,3 +1800,49 @@ func TestDictionaryAppendIndices(t *testing.T) {
 		})
 	}
 }
+
+type panicAllocator struct {
+	n       int
+	paniced bool
+	memory.Allocator
+}
+
+func (p *panicAllocator) Allocate(size int) []byte {
+	if size > p.n {
+		p.paniced = true
+		panic("panic allocator")
+	}
+	return p.Allocator.Allocate(size)
+}
+
+func (p *panicAllocator) Reallocate(size int, b []byte) []byte {
+	return p.Allocator.Reallocate(size, b)
+}
+
+func (p *panicAllocator) Free(b []byte) {
+	p.Allocator.Free(b)
+}
+
+func TestBinaryDictionaryPanic(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(t, 0)
+
+	allocator := &panicAllocator{
+		n:         400,
+		Allocator: mem,
+	}
+
+	expectedType := &arrow.DictionaryType{IndexType: &arrow.Int8Type{}, ValueType: arrow.BinaryTypes.String}
+	bldr := array.NewDictionaryBuilder(allocator, expectedType)
+	defer bldr.Release()
+
+	bldr.AppendNull()
+	allocator.n = 0 // force panic
+	func() {
+		defer func() {
+			recover()
+		}()
+		bldr.NewArray()
+	}()
+	assert.True(t, allocator.paniced)
+}

From 3ac880df2e0fc3ce364ca37073e1bb0779896d46 Mon Sep 17 00:00:00 2001
From: Weston Pace <weston.pace@gmail.com>
Date: Tue, 25 Jul 2023 09:37:21 -0700
Subject: [PATCH 044/749] GH-34213: [C++] Use recursive calls without a
 delimiter if the user is doing a recursive GetFileInfo (#35440)

### Rationale for this change

The old model of "walk"ing the directory could lead to a large number of calls.  If someone is fully listing a bucket they will need to make one S3 API call for every single directory in the bucket.  With this approach there is only 1 call made for every 1000 files, regardless of how they are spread across directories.

The only potential regression would be if max_recursion was set to something > 1.  For example, if a user had:

```
bucket/foo/bar/<10000 files here>
```

Then if they make a request for `bucket` with `max_recursion=2` the new approach will list all 10,000 files and then eliminate the files that don't match.

However, I believe these cases (using max_recursion) to be rarer and less common than the typical case of listing all files (which dataset discovery does).

### What changes are included in this PR?

The algorithm behind GetFileInfo and DeleteDirContents in S3FileSystem has changed.

### Are these changes tested?

Yes, there should be no behavior change.  All of the existing filesystem tests will test this change.

### Are there any user-facing changes?

No, other than (hopefully) better performance.
* Closes: #34213

Lead-authored-by: Weston Pace <weston.pace@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/filesystem/filesystem_test.cc |  41 +
 cpp/src/arrow/filesystem/path_util.cc       |  37 +
 cpp/src/arrow/filesystem/path_util.h        |  20 +-
 cpp/src/arrow/filesystem/s3fs.cc            | 828 ++++++++++----------
 cpp/src/arrow/filesystem/s3fs_test.cc       |  86 +-
 cpp/src/arrow/util/async_util.cc            |   6 +-
 cpp/src/arrow/util/async_util_test.cc       |  23 +
 7 files changed, 638 insertions(+), 403 deletions(-)

diff --git a/cpp/src/arrow/filesystem/filesystem_test.cc b/cpp/src/arrow/filesystem/filesystem_test.cc
index b450a69913135..c76c3d27e8f8e 100644
--- a/cpp/src/arrow/filesystem/filesystem_test.cc
+++ b/cpp/src/arrow/filesystem/filesystem_test.cc
@@ -87,6 +87,34 @@ TEST(PathUtil, SplitAbstractPath) {
   AssertPartsEqual(parts, {"abc", "def.ghi"});
 }
 
+TEST(PathUtil, SliceAbstractPath) {
+  std::string path = "abc";
+  ASSERT_EQ("abc", SliceAbstractPath(path, 0, 1));
+  ASSERT_EQ("abc", SliceAbstractPath(path, 0, 2));
+  ASSERT_EQ("", SliceAbstractPath(path, 0, 0));
+  ASSERT_EQ("", SliceAbstractPath(path, 1, 0));
+
+  path = "abc/def\\x/y.ext";
+  ASSERT_EQ("abc/def\\x/y.ext", SliceAbstractPath(path, 0, 4));
+  ASSERT_EQ("abc/def\\x/y.ext", SliceAbstractPath(path, 0, 3));
+  ASSERT_EQ("abc/def\\x", SliceAbstractPath(path, 0, 2));
+  ASSERT_EQ("abc", SliceAbstractPath(path, 0, 1));
+  ASSERT_EQ("def\\x/y.ext", SliceAbstractPath(path, 1, 2));
+  ASSERT_EQ("def\\x/y.ext", SliceAbstractPath(path, 1, 3));
+  ASSERT_EQ("def\\x", SliceAbstractPath(path, 1, 1));
+  ASSERT_EQ("y.ext", SliceAbstractPath(path, 2, 1));
+  ASSERT_EQ("", SliceAbstractPath(path, 3, 1));
+
+  path = "x/y\\z";
+  ASSERT_EQ("x", SliceAbstractPath(path, 0, 1));
+  ASSERT_EQ("x/y", SliceAbstractPath(path, 0, 1, /*sep=*/'\\'));
+
+  // Invalid cases but we shouldn't crash
+  ASSERT_EQ("", SliceAbstractPath(path, -1, 1));
+  ASSERT_EQ("", SliceAbstractPath(path, 0, -1));
+  ASSERT_EQ("", SliceAbstractPath(path, -1, -1));
+}
+
 TEST(PathUtil, GetAbstractPathExtension) {
   ASSERT_EQ(GetAbstractPathExtension("abc.txt"), "txt");
   ASSERT_EQ(GetAbstractPathExtension("dir/abc.txt"), "txt");
@@ -98,6 +126,19 @@ TEST(PathUtil, GetAbstractPathExtension) {
   ASSERT_EQ(GetAbstractPathExtension("/run.d/abc"), "");
 }
 
+TEST(PathUtil, GetAbstractPathDepth) {
+  ASSERT_EQ(0, GetAbstractPathDepth(""));
+  ASSERT_EQ(0, GetAbstractPathDepth("/"));
+  ASSERT_EQ(1, GetAbstractPathDepth("foo"));
+  ASSERT_EQ(1, GetAbstractPathDepth("foo/"));
+  ASSERT_EQ(1, GetAbstractPathDepth("/foo"));
+  ASSERT_EQ(1, GetAbstractPathDepth("/foo/"));
+  ASSERT_EQ(2, GetAbstractPathDepth("/foo/bar"));
+  ASSERT_EQ(2, GetAbstractPathDepth("/foo/bar/"));
+  ASSERT_EQ(2, GetAbstractPathDepth("foo/bar"));
+  ASSERT_EQ(2, GetAbstractPathDepth("foo/bar/"));
+}
+
 TEST(PathUtil, GetAbstractPathParent) {
   std::pair<std::string, std::string> pair;
 
diff --git a/cpp/src/arrow/filesystem/path_util.cc b/cpp/src/arrow/filesystem/path_util.cc
index e25e544f0341f..90af3c66ff8d4 100644
--- a/cpp/src/arrow/filesystem/path_util.cc
+++ b/cpp/src/arrow/filesystem/path_util.cc
@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <regex>
+#include <sstream>
 
 #include "arrow/filesystem/path_util.h"
 #include "arrow/filesystem/util_internal.h"
@@ -66,6 +67,42 @@ std::vector<std::string> SplitAbstractPath(const std::string& path, char sep) {
   return parts;
 }
 
+std::string SliceAbstractPath(const std::string& s, int offset, int length, char sep) {
+  if (offset < 0 || length < 0) {
+    return "";
+  }
+  std::vector<std::string> components = SplitAbstractPath(s, sep);
+  std::stringstream combined;
+  if (offset >= static_cast<int>(components.size())) {
+    return "";
+  }
+  int end = offset + length;
+  if (end > static_cast<int>(components.size())) {
+    end = static_cast<int>(components.size());
+  }
+  for (int i = offset; i < end; i++) {
+    combined << components[i];
+    if (i < end - 1) {
+      combined << sep;
+    }
+  }
+  return combined.str();
+}
+
+int GetAbstractPathDepth(std::string_view path) {
+  if (path.empty()) {
+    return 0;
+  }
+  int depth = static_cast<int>(std::count(path.begin(), path.end(), kSep)) + 1;
+  if (path.back() == kSep) {
+    depth -= 1;
+  }
+  if (path.front() == kSep) {
+    depth -= 1;
+  }
+  return depth;
+}
+
 std::pair<std::string, std::string> GetAbstractPathParent(const std::string& s) {
   // XXX should strip trailing slash?
 
diff --git a/cpp/src/arrow/filesystem/path_util.h b/cpp/src/arrow/filesystem/path_util.h
index b821e79338490..13a74b7fa12c8 100644
--- a/cpp/src/arrow/filesystem/path_util.h
+++ b/cpp/src/arrow/filesystem/path_util.h
@@ -38,9 +38,25 @@ constexpr char kSep = '/';
 ARROW_EXPORT
 std::vector<std::string> SplitAbstractPath(const std::string& path, char sep = kSep);
 
-// Return the extension of the file
+// Slice the individual components of an abstract path and combine them
+//
+// If offset or length are negative then an empty string is returned
+// If offset is >= the number of components then an empty string is returned
+// If offset + length is >= the number of components then length is truncated
 ARROW_EXPORT
-std::string GetAbstractPathExtension(const std::string& s);
+std::string SliceAbstractPath(const std::string& path, int offset, int length,
+                              char sep = kSep);
+
+// Return the extension of the file
+ARROW_EXPORT std::string GetAbstractPathExtension(const std::string& s);
+
+// Return the depth (number of components) of an abstract path
+//
+// Trailing slashes do not count towards depth
+// Leading slashes do not count towards depth
+//
+// The root path ("/") has depth 0
+ARROW_EXPORT int GetAbstractPathDepth(std::string_view path);
 
 // Return the parent directory and basename of an abstract path.  Both values may be
 // empty.
diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index 29b45e1dc9abe..c67f7668ffa4d 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -29,6 +29,7 @@
 #include <sstream>
 #include <thread>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 
 #ifdef _WIN32
@@ -59,6 +60,7 @@
 #endif
 #include <aws/identity-management/auth/STSAssumeRoleCredentialsProvider.h>
 #include <aws/s3/S3Client.h>
+#include <aws/s3/S3Errors.h>
 #include <aws/s3/model/AbortMultipartUploadRequest.h>
 #include <aws/s3/model/CompleteMultipartUploadRequest.h>
 #include <aws/s3/model/CompletedMultipartUpload.h>
@@ -91,6 +93,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/async_generator.h"
+#include "arrow/util/async_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/future.h"
 #include "arrow/util/io_util.h"
@@ -734,8 +737,12 @@ class S3ClientLock {
   // with a shared mutex locked in shared mode.
   // The reason is that locking again in shared mode can block while
   // there are threads waiting to take the lock in exclusive mode.
-  // Therefore, we should avoid to keep the S3ClientLock taken
-  // before is it taken again. This methods helps doing that.
+  // Therefore, we should avoid obtaining the S3ClientLock when
+  // we already have it locked.
+  //
+  // This methods helps by moving the S3ClientLock into a temporary
+  // that is immediately destroyed so the lock will be released as
+  // soon as we are done making the call to the underlying client.
   //
   // (see GH-36523)
   S3ClientLock Move() { return std::move(*this); }
@@ -1702,147 +1709,6 @@ void FileObjectToInfo(const S3Model::Object& obj, FileInfo* info) {
   info->set_mtime(FromAwsDatetime(obj.GetLastModified()));
 }
 
-struct TreeWalker : public std::enable_shared_from_this<TreeWalker> {
-  using ResultHandler = std::function<Status(const std::string& prefix,
-                                             const S3Model::ListObjectsV2Result&)>;
-  using ErrorHandler = std::function<Status(const AWSError<S3Errors>& error)>;
-  using RecursionHandler = std::function<Result<bool>(int32_t nesting_depth)>;
-
-  std::shared_ptr<S3ClientHolder> holder_;
-  io::IOContext io_context_;
-  const std::string bucket_;
-  const std::string base_dir_;
-  const int32_t max_keys_;
-  const ResultHandler result_handler_;
-  const ErrorHandler error_handler_;
-  const RecursionHandler recursion_handler_;
-
-  template <typename... Args>
-  static Status Walk(Args&&... args) {
-    return WalkAsync(std::forward<Args>(args)...).status();
-  }
-
-  template <typename... Args>
-  static Future<> WalkAsync(Args&&... args) {
-    auto self = std::make_shared<TreeWalker>(std::forward<Args>(args)...);
-    return self->DoWalk();
-  }
-
-  TreeWalker(std::shared_ptr<S3ClientHolder> holder, io::IOContext io_context,
-             std::string bucket, std::string base_dir, int32_t max_keys,
-             ResultHandler result_handler, ErrorHandler error_handler,
-             RecursionHandler recursion_handler)
-      : holder_(std::move(holder)),
-        io_context_(io_context),
-        bucket_(std::move(bucket)),
-        base_dir_(std::move(base_dir)),
-        max_keys_(max_keys),
-        result_handler_(std::move(result_handler)),
-        error_handler_(std::move(error_handler)),
-        recursion_handler_(std::move(recursion_handler)) {}
-
- private:
-  std::shared_ptr<TaskGroup> task_group_;
-  std::mutex mutex_;
-
-  Future<> DoWalk() {
-    task_group_ =
-        TaskGroup::MakeThreaded(io_context_.executor(), io_context_.stop_token());
-    WalkChild(base_dir_, /*nesting_depth=*/0);
-    // When this returns, ListObjectsV2 tasks either have finished or will exit early
-    return task_group_->FinishAsync();
-  }
-
-  bool ok() const { return task_group_->ok(); }
-
-  struct ListObjectsV2Handler {
-    std::shared_ptr<TreeWalker> walker;
-    std::string prefix;
-    int32_t nesting_depth;
-    S3Model::ListObjectsV2Request req;
-
-    Status operator()(const Result<S3Model::ListObjectsV2Outcome>& result) {
-      // Serialize calls to operation-specific handlers
-      if (!walker->ok()) {
-        // Early exit: avoid executing handlers if DoWalk() returned
-        return Status::OK();
-      }
-      if (!result.ok()) {
-        return result.status();
-      }
-      const auto& outcome = *result;
-      if (!outcome.IsSuccess()) {
-        {
-          std::lock_guard<std::mutex> guard(walker->mutex_);
-          return walker->error_handler_(outcome.GetError());
-        }
-      }
-      return HandleResult(outcome.GetResult());
-    }
-
-    void SpawnListObjectsV2() {
-      auto cb = *this;
-      walker->task_group_->Append([cb]() mutable {
-        ARROW_ASSIGN_OR_RAISE(auto client_lock, cb.walker->holder_->Lock());
-        Result<S3Model::ListObjectsV2Outcome> result =
-            client_lock.Move()->ListObjectsV2(cb.req);
-        return cb(std::move(result));
-      });
-    }
-
-    Status HandleResult(const S3Model::ListObjectsV2Result& result) {
-      bool recurse;
-      {
-        // Only one thread should be running result_handler_/recursion_handler_ at a time
-        std::lock_guard<std::mutex> guard(walker->mutex_);
-        recurse = result.GetCommonPrefixes().size() > 0;
-        if (recurse) {
-          ARROW_ASSIGN_OR_RAISE(auto maybe_recurse,
-                                walker->recursion_handler_(nesting_depth + 1));
-          recurse &= maybe_recurse;
-        }
-        RETURN_NOT_OK(walker->result_handler_(prefix, result));
-      }
-      if (recurse) {
-        walker->WalkChildren(result, nesting_depth + 1);
-      }
-      // If the result was truncated, issue a continuation request to get
-      // further directory entries.
-      if (result.GetIsTruncated()) {
-        DCHECK(!result.GetNextContinuationToken().empty());
-        req.SetContinuationToken(result.GetNextContinuationToken());
-        SpawnListObjectsV2();
-      }
-      return Status::OK();
-    }
-
-    void Start() {
-      req.SetBucket(ToAwsString(walker->bucket_));
-      if (!prefix.empty()) {
-        req.SetPrefix(ToAwsString(prefix) + kSep);
-      }
-      req.SetDelimiter(Aws::String() + kSep);
-      req.SetMaxKeys(walker->max_keys_);
-      SpawnListObjectsV2();
-    }
-  };
-
-  void WalkChild(std::string key, int32_t nesting_depth) {
-    ListObjectsV2Handler handler{shared_from_this(), std::move(key), nesting_depth, {}};
-    handler.Start();
-  }
-
-  void WalkChildren(const S3Model::ListObjectsV2Result& result, int32_t nesting_depth) {
-    for (const auto& prefix : result.GetCommonPrefixes()) {
-      const auto child_key =
-          internal::RemoveTrailingSlash(FromAwsString(prefix.GetPrefix()));
-      WalkChild(std::string{child_key}, nesting_depth);
-    }
-  }
-
-  friend struct ListObjectsV2Handler;
-};
-
 }  // namespace
 
 // -----------------------------------------------------------------------
@@ -1855,11 +1721,9 @@ class S3FileSystem::Impl : public std::enable_shared_from_this<S3FileSystem::Imp
   std::shared_ptr<S3ClientHolder> holder_;
   std::optional<S3Backend> backend_;
 
-  const int32_t kListObjectsMaxKeys = 1000;
+  static constexpr int32_t kListObjectsMaxKeys = 1000;
   // At most 1000 keys per multiple-delete request
-  const int32_t kMultipleDeleteMaxKeys = 1000;
-  // Limit recursing depth, since a recursion bomb can be created
-  const int32_t kMaxNestingDepth = 100;
+  static constexpr int32_t kMultipleDeleteMaxKeys = 1000;
 
   explicit Impl(S3Options options, io::IOContext io_context)
       : builder_(std::move(options)), io_context_(io_context) {}
@@ -2073,197 +1937,303 @@ class S3FileSystem::Impl : public std::enable_shared_from_this<S3FileSystem::Imp
         "ListObjectsV2", outcome.GetError());
   }
 
-  Status CheckNestingDepth(int32_t nesting_depth) {
-    if (nesting_depth >= kMaxNestingDepth) {
-      return Status::IOError("S3 filesystem tree exceeds maximum nesting depth (",
-                             kMaxNestingDepth, ")");
+  static FileInfo MakeDirectoryInfo(std::string dirname) {
+    FileInfo dir;
+    dir.set_type(FileType::Directory);
+    dir.set_path(std::move(dirname));
+    return dir;
+  }
+
+  static std::vector<FileInfo> MakeDirectoryInfos(std::vector<std::string> dirnames) {
+    std::vector<FileInfo> dir_infos;
+    for (auto& dirname : dirnames) {
+      dir_infos.push_back(MakeDirectoryInfo(std::move(dirname)));
     }
-    return Status::OK();
+    return dir_infos;
   }
 
-  // A helper class for Walk and WalkAsync
-  struct FileInfoCollector {
-    FileInfoCollector(std::string bucket, std::string key, const FileSelector& select)
-        : bucket(std::move(bucket)),
-          key(std::move(key)),
-          allow_not_found(select.allow_not_found) {}
+  using FileInfoSink = PushGenerator<std::vector<FileInfo>>::Producer;
 
-    Status Collect(const std::string& prefix, const S3Model::ListObjectsV2Result& result,
-                   std::vector<FileInfo>* out) {
-      // Walk "directories"
-      for (const auto& child_prefix : result.GetCommonPrefixes()) {
-        is_empty = false;
-        const auto child_key =
-            internal::RemoveTrailingSlash(FromAwsString(child_prefix.GetPrefix()));
-        std::stringstream child_path;
-        child_path << bucket << kSep << child_key;
-        FileInfo info;
-        info.set_path(child_path.str());
-        info.set_type(FileType::Directory);
-        out->push_back(std::move(info));
+  struct FileListerState {
+    FileInfoSink files_queue;
+    const bool allow_not_found;
+    const int max_recursion;
+    const bool include_implicit_dirs;
+    const io::IOContext io_context;
+    S3ClientHolder* const holder;
+
+    S3Model::ListObjectsV2Request req;
+    std::unordered_set<std::string> directories;
+    bool empty = true;
+
+    FileListerState(PushGenerator<std::vector<FileInfo>>::Producer files_queue,
+                    FileSelector select, const std::string& bucket,
+                    const std::string& key, bool include_implicit_dirs,
+                    io::IOContext io_context, S3ClientHolder* holder)
+        : files_queue(std::move(files_queue)),
+          allow_not_found(select.allow_not_found),
+          max_recursion(select.max_recursion),
+          include_implicit_dirs(include_implicit_dirs),
+          io_context(std::move(io_context)),
+          holder(holder) {
+      req.SetBucket(bucket);
+      req.SetMaxKeys(kListObjectsMaxKeys);
+      if (!key.empty()) {
+        req.SetPrefix(key + kSep);
       }
-      // Walk "files"
-      for (const auto& obj : result.GetContents()) {
-        is_empty = false;
-        FileInfo info;
-        const auto child_key = internal::RemoveTrailingSlash(FromAwsString(obj.GetKey()));
-        if (child_key == std::string_view(prefix)) {
-          // Amazon can return the "directory" key itself as part of the results, skip
-          continue;
-        }
-        std::stringstream child_path;
-        child_path << bucket << kSep << child_key;
-        info.set_path(child_path.str());
-        FileObjectToInfo(obj, &info);
-        out->push_back(std::move(info));
+      if (!select.recursive) {
+        req.SetDelimiter(Aws::String() + kSep);
       }
-      return Status::OK();
     }
 
-    Status Finish(Impl* impl) {
-      // If no contents were found, perhaps it's an empty "directory",
-      // or perhaps it's a nonexistent entry.  Check.
-      if (is_empty && !allow_not_found) {
-        ARROW_ASSIGN_OR_RAISE(bool is_actually_empty,
-                              impl->IsEmptyDirectory(bucket, key));
-        if (!is_actually_empty) {
-          return PathNotFound(bucket, key);
-        }
+    void Finish() {
+      // `empty` means that we didn't get a single file info back from S3.  This may be
+      // a situation that we should consider as PathNotFound.
+      //
+      // * If the prefix is empty then we were querying the contents of an entire bucket
+      //   and this is not a PathNotFound case because if the bucket didn't exist then
+      //   we would have received an error and not an empty set of results.
+      //
+      // * If the prefix is not empty then we asked for all files under a particular
+      //   directory.  S3 will also return the directory itself, if it exists.  So if
+      //   we get zero results then we know that there are no files under the directory
+      //   and the directory itself doesn't exist.  This should be considered PathNotFound
+      if (empty && !allow_not_found && !req.GetPrefix().empty()) {
+        files_queue.Push(PathNotFound(req.GetBucket(), req.GetPrefix()));
       }
-      return Status::OK();
     }
 
-    std::string bucket;
-    std::string key;
-    bool allow_not_found;
-    bool is_empty = true;
+    // Given a path, iterate through all possible sub-paths and, if we haven't
+    // seen that sub-path before, return it.
+    //
+    // For example, given A/B/C we might return A/B and A if we have not seen
+    // those paths before.  This allows us to consider "implicit" directories which
+    // don't exist as objects in S3 but can be inferred.
+    std::vector<std::string> GetNewDirectories(const std::string_view& path) {
+      std::string current(path);
+      std::string base = req.GetBucket();
+      if (!req.GetPrefix().empty()) {
+        base = base + kSep + std::string(internal::RemoveTrailingSlash(req.GetPrefix()));
+      }
+      std::vector<std::string> new_directories;
+      while (true) {
+        const std::string parent_dir = internal::GetAbstractPathParent(current).first;
+        if (parent_dir.empty()) {
+          break;
+        }
+        current = parent_dir;
+        if (current == base) {
+          break;
+        }
+        if (directories.insert(parent_dir).second) {
+          new_directories.push_back(std::move(parent_dir));
+        }
+      }
+      return new_directories;
+    }
   };
 
-  // Workhorse for GetFileInfo(FileSelector...)
-  Status Walk(const FileSelector& select, const std::string& bucket,
-              const std::string& key, std::vector<FileInfo>* out) {
-    RETURN_NOT_OK(CheckS3Initialized());
+  struct FileListerTask : public util::AsyncTaskScheduler::Task {
+    std::shared_ptr<FileListerState> state;
+    util::AsyncTaskScheduler* scheduler;
 
-    FileInfoCollector collector(bucket, key, select);
+    FileListerTask(std::shared_ptr<FileListerState> state,
+                   util::AsyncTaskScheduler* scheduler)
+        : state(std::move(state)), scheduler(scheduler) {}
 
-    auto handle_error = [&](const AWSError<S3Errors>& error) -> Status {
-      if (select.allow_not_found && IsNotFound(error)) {
-        return Status::OK();
+    std::vector<FileInfo> ToFileInfos(const std::string& bucket,
+                                      const std::string& prefix,
+                                      const S3Model::ListObjectsV2Result& result) {
+      std::vector<FileInfo> file_infos;
+      // If this is a non-recursive listing we may see "common prefixes" which represent
+      // directories we did not recurse into.  We will add those as directories.
+      for (const auto& child_prefix : result.GetCommonPrefixes()) {
+        const auto child_key =
+            internal::RemoveTrailingSlash(FromAwsString(child_prefix.GetPrefix()));
+        std::stringstream child_path_ss;
+        child_path_ss << bucket << kSep << child_key;
+        FileInfo info;
+        info.set_path(child_path_ss.str());
+        info.set_type(FileType::Directory);
+        file_infos.push_back(std::move(info));
       }
-      return ErrorToStatus(std::forward_as_tuple("When listing objects under key '", key,
-                                                 "' in bucket '", bucket, "': "),
-                           "ListObjectsV2", error);
-    };
-
-    auto handle_recursion = [&](int32_t nesting_depth) -> Result<bool> {
-      RETURN_NOT_OK(CheckNestingDepth(nesting_depth));
-      return select.recursive && nesting_depth <= select.max_recursion;
-    };
-
-    auto handle_results = [&](const std::string& prefix,
-                              const S3Model::ListObjectsV2Result& result) -> Status {
-      return collector.Collect(prefix, result, out);
-    };
-
-    RETURN_NOT_OK(TreeWalker::Walk(holder_, io_context_, bucket, key, kListObjectsMaxKeys,
-                                   handle_results, handle_error, handle_recursion));
-
-    // If no contents were found, perhaps it's an empty "directory",
-    // or perhaps it's a nonexistent entry.  Check.
-    RETURN_NOT_OK(collector.Finish(this));
-    // Sort results for convenience, since they can come massively out of order
-    std::sort(out->begin(), out->end(), FileInfo::ByPath{});
-    return Status::OK();
-  }
-
-  // Workhorse for GetFileInfoGenerator(FileSelector...)
-  FileInfoGenerator WalkAsync(const FileSelector& select, const std::string& bucket,
-                              const std::string& key) {
-    PushGenerator<std::vector<FileInfo>> gen;
-    auto producer = gen.producer();
-    auto collector = std::make_shared<FileInfoCollector>(bucket, key, select);
-    auto self = shared_from_this();
+      // S3 doesn't have any concept of "max depth" and so we emulate it by counting the
+      // number of '/' characters.  E.g. if the user is searching bucket/subdirA/subdirB
+      // then the starting depth is 2.
+      // A file subdirA/subdirB/somefile will have a child depth of 2 and a "depth" of 0.
+      // A file subdirA/subdirB/subdirC/somefile will have a child depth of 3 and a
+      //   "depth" of 1
+      int base_depth = internal::GetAbstractPathDepth(prefix);
+      for (const auto& obj : result.GetContents()) {
+        if (obj.GetKey() == prefix) {
+          // S3 will return the basedir itself (if it is a file / empty file).  We don't
+          // want that.  But this is still considered "finding the basedir" and so we mark
+          // it "not empty".
+          state->empty = false;
+          continue;
+        }
+        std::string child_key =
+            std::string(internal::RemoveTrailingSlash(FromAwsString(obj.GetKey())));
+        bool had_trailing_slash = child_key.size() != obj.GetKey().size();
+        int child_depth = internal::GetAbstractPathDepth(child_key);
+        // Recursion depth is 1 smaller because a path with depth 1 (e.g. foo) is
+        // considered to have a "recursion" of 0
+        int recursion_depth = child_depth - base_depth - 1;
+        if (recursion_depth > state->max_recursion) {
+          // If we have A/B/C/D and max_recursion is 2 then we ignore this (don't add it
+          // to file_infos) but we still want to potentially add A and A/B as directories.
+          // So we "pretend" like we have a file A/B/C for the call to GetNewDirectories
+          // below
+          int to_trim = recursion_depth - state->max_recursion - 1;
+          if (to_trim > 0) {
+            child_key = bucket + kSep +
+                        internal::SliceAbstractPath(child_key, 0, child_depth - to_trim);
+          } else {
+            child_key = bucket + kSep + child_key;
+          }
+        } else {
+          // If the file isn't beyond our max recursion then count it as a file
+          // unless it's empty and then it depends on whether or not the file ends
+          // with a trailing slash
+          std::stringstream child_path_ss;
+          child_path_ss << bucket << kSep << child_key;
+          child_key = child_path_ss.str();
+          if (obj.GetSize() > 0 || !had_trailing_slash) {
+            // We found a real file
+            FileInfo info;
+            info.set_path(child_key);
+            FileObjectToInfo(obj, &info);
+            file_infos.push_back(std::move(info));
+          } else {
+            // We found an empty file and we want to treat it like a directory.  Only
+            // add it if we haven't seen this directory before.
+            if (state->directories.insert(child_key).second) {
+              file_infos.push_back(MakeDirectoryInfo(child_key));
+            }
+          }
+        }
 
-    auto handle_error = [select, bucket, key](const AWSError<S3Errors>& error) -> Status {
-      if (select.allow_not_found && IsNotFound(error)) {
-        return Status::OK();
+        if (state->include_implicit_dirs) {
+          // Now that we've dealt with the file itself we need to look at each of the
+          // parent paths and potentially add them as directories.  For example, after
+          // finding a file A/B/C/D we want to consider adding directories A, A/B, and
+          // A/B/C.
+          for (const auto& newdir : state->GetNewDirectories(child_key)) {
+            file_infos.push_back(MakeDirectoryInfo(newdir));
+          }
+        }
       }
-      return ErrorToStatus(std::forward_as_tuple("When listing objects under key '", key,
-                                                 "' in bucket '", bucket, "': "),
-                           "ListObjectsV2", error);
-    };
-
-    auto handle_recursion = [producer, select,
-                             self](int32_t nesting_depth) -> Result<bool> {
-      if (producer.is_closed()) {
-        return false;
+      if (file_infos.size() > 0) {
+        state->empty = false;
       }
-      RETURN_NOT_OK(self->CheckNestingDepth(nesting_depth));
-      return select.recursive && nesting_depth <= select.max_recursion;
-    };
+      return file_infos;
+    }
 
-    auto handle_results =
-        [collector, producer](
-            const std::string& prefix,
-            const S3Model::ListObjectsV2Result& result) mutable -> Status {
-      std::vector<FileInfo> out;
-      RETURN_NOT_OK(collector->Collect(prefix, result, &out));
-      if (!out.empty()) {
-        producer.Push(std::move(out));
+    void Run() {
+      // We are on an I/O thread now so just synchronously make the call and interpret the
+      // results.
+      Result<S3ClientLock> client_lock = state->holder->Lock();
+      if (!client_lock.ok()) {
+        state->files_queue.Push(client_lock.status());
+        return;
       }
-      return Status::OK();
-    };
-
-    TreeWalker::WalkAsync(holder_, io_context_, bucket, key, kListObjectsMaxKeys,
-                          handle_results, handle_error, handle_recursion)
-        .AddCallback([collector, producer, self](const Status& status) mutable {
-          auto st = collector->Finish(self.get());
-          if (!st.ok()) {
-            producer.Push(st);
-          }
-          producer.Close();
-        });
-    return gen;
-  }
-
-  struct WalkResult {
-    std::vector<std::string> file_keys;
-    std::vector<std::string> dir_keys;
-  };
-  Future<std::shared_ptr<WalkResult>> WalkForDeleteDirAsync(const std::string& bucket,
-                                                            const std::string& key) {
-    auto state = std::make_shared<WalkResult>();
-
-    auto handle_results = [state](const std::string& prefix,
-                                  const S3Model::ListObjectsV2Result& result) -> Status {
-      // Walk "files"
-      state->file_keys.reserve(state->file_keys.size() + result.GetContents().size());
-      for (const auto& obj : result.GetContents()) {
-        state->file_keys.emplace_back(FromAwsString(obj.GetKey()));
+      S3Model::ListObjectsV2Outcome outcome =
+          client_lock->Move()->ListObjectsV2(state->req);
+      if (!outcome.IsSuccess()) {
+        const auto& err = outcome.GetError();
+        if (state->allow_not_found && IsNotFound(err)) {
+          return;
+        }
+        state->files_queue.Push(
+            ErrorToStatus(std::forward_as_tuple("When listing objects under key '",
+                                                state->req.GetPrefix(), "' in bucket '",
+                                                state->req.GetBucket(), "': "),
+                          "ListObjectsV2", err));
+        return;
       }
-      // Walk "directories"
-      state->dir_keys.reserve(state->dir_keys.size() + result.GetCommonPrefixes().size());
-      for (const auto& prefix : result.GetCommonPrefixes()) {
-        state->dir_keys.emplace_back(FromAwsString(prefix.GetPrefix()));
+      const S3Model::ListObjectsV2Result& result = outcome.GetResult();
+      // We could immediately schedule the continuation (if there are enough results to
+      // trigger paging) but that would introduce race condition complexity for arguably
+      // little benefit.
+      std::vector<FileInfo> file_infos =
+          ToFileInfos(state->req.GetBucket(), state->req.GetPrefix(), result);
+      if (file_infos.size() > 0) {
+        state->files_queue.Push(std::move(file_infos));
       }
-      return Status::OK();
-    };
 
-    auto handle_error = [=](const AWSError<S3Errors>& error) -> Status {
-      return ErrorToStatus(std::forward_as_tuple("When listing objects under key '", key,
-                                                 "' in bucket '", bucket, "': "),
-                           "ListObjectsV2", error);
-    };
+      // If there are enough files to warrant a continuation then go ahead and schedule
+      // that now.
+      if (result.GetIsTruncated()) {
+        DCHECK(!result.GetNextContinuationToken().empty());
+        state->req.SetContinuationToken(result.GetNextContinuationToken());
+        scheduler->AddTask(std::make_unique<FileListerTask>(state, scheduler));
+      } else {
+        // Otherwise, we have finished listing all the files
+        state->Finish();
+      }
+    }
 
-    auto self = shared_from_this();
-    auto handle_recursion = [self](int32_t nesting_depth) -> Result<bool> {
-      RETURN_NOT_OK(self->CheckNestingDepth(nesting_depth));
-      return true;  // Recurse
-    };
+    Result<Future<>> operator()() override {
+      return state->io_context.executor()->Submit([this] {
+        Run();
+        return Status::OK();
+      });
+    }
+    std::string_view name() const override { return "S3ListFiles"; }
+  };
 
-    return TreeWalker::WalkAsync(holder_, io_context_, bucket, key, kListObjectsMaxKeys,
-                                 handle_results, handle_error, handle_recursion)
-        .Then([state]() { return state; });
+  // Lists all file, potentially recursively, in a bucket
+  //
+  // include_implicit_dirs controls whether or not implicit directories should be
+  // included. These are directories that are not actually file objects but instead are
+  // inferred from other objects.
+  //
+  // For example, if a file exists with path A/B/C then implicit directories A/ and A/B/
+  // will exist even if there are no file objects with these paths.
+  void ListAsync(const FileSelector& select, const std::string& bucket,
+                 const std::string& key, bool include_implicit_dirs,
+                 util::AsyncTaskScheduler* scheduler, FileInfoSink sink) {
+    // We can only fetch kListObjectsMaxKeys files at a time and so we create a
+    // scheduler and schedule a task to grab the first batch.  Once that's done we
+    // schedule a new task for the next batch.  All of these tasks share the same
+    // FileListerState object but none of these tasks run in parallel so there is
+    // no need to worry about mutexes
+    auto state = std::make_shared<FileListerState>(sink, select, bucket, key,
+                                                   include_implicit_dirs, io_context_,
+                                                   this->holder_.get());
+
+    // Create the first file lister task (it may spawn more)
+    auto file_lister_task = std::make_unique<FileListerTask>(state, scheduler);
+    scheduler->AddTask(std::move(file_lister_task));
+  }
+
+  // Fully list all files from all buckets
+  void FullListAsync(bool include_implicit_dirs, util::AsyncTaskScheduler* scheduler,
+                     FileInfoSink sink, bool recursive) {
+    scheduler->AddSimpleTask(
+        [this, scheduler, sink, include_implicit_dirs, recursive]() mutable {
+          return ListBucketsAsync().Then(
+              [this, scheduler, sink, include_implicit_dirs,
+               recursive](const std::vector<std::string>& buckets) mutable {
+                // Return the buckets themselves as directories
+                std::vector<FileInfo> buckets_as_directories =
+                    MakeDirectoryInfos(buckets);
+                sink.Push(std::move(buckets_as_directories));
+
+                if (recursive) {
+                  // Recursively list each bucket (these will run in parallel but sink
+                  // should be thread safe and so this is ok)
+                  for (const auto& bucket : buckets) {
+                    FileSelector select;
+                    select.allow_not_found = true;
+                    select.recursive = true;
+                    select.base_dir = bucket;
+                    ListAsync(select, bucket, "", include_implicit_dirs, scheduler, sink);
+                  }
+                }
+              });
+        },
+        std::string_view("FullListBucketScan"));
   }
 
   // Delete multiple objects at once
@@ -2297,12 +2267,14 @@ class S3FileSystem::Impl : public std::enable_shared_from_this<S3FileSystem::Imp
     const DeleteCallback delete_cb{bucket};
 
     std::vector<Future<>> futures;
-    futures.reserve(keys.size() / chunk_size + 1);
+    futures.reserve(bit_util::CeilDiv(keys.size(), chunk_size));
 
     for (size_t start = 0; start < keys.size(); start += chunk_size) {
       S3Model::DeleteObjectsRequest req;
       S3Model::Delete del;
-      for (size_t i = start; i < std::min(keys.size(), chunk_size); ++i) {
+      size_t remaining = keys.size() - start;
+      size_t next_chunk_size = std::min(remaining, chunk_size);
+      for (size_t i = start; i < start + next_chunk_size; ++i) {
         del.AddObjects(S3Model::ObjectIdentifier().WithKey(ToAwsString(keys[i])));
       }
       req.SetBucket(ToAwsString(bucket));
@@ -2317,37 +2289,151 @@ class S3FileSystem::Impl : public std::enable_shared_from_this<S3FileSystem::Imp
       futures.push_back(std::move(fut));
     }
 
-    return AllComplete(futures);
+    return AllFinished(futures);
   }
 
   Status DeleteObjects(const std::string& bucket, const std::vector<std::string>& keys) {
     return DeleteObjectsAsync(bucket, keys).status();
   }
 
+  // Check to make sure the given path is not a file
+  //
+  // Returns true if the path seems to be a directory, false if it is a file
+  Future<bool> EnsureIsDirAsync(const std::string& bucket, const std::string& key) {
+    if (key.empty()) {
+      // There is no way for a bucket to be a file
+      return Future<bool>::MakeFinished(true);
+    }
+    auto self = shared_from_this();
+    return DeferNotOk(
+        SubmitIO(io_context_, [self, bucket, key]() mutable -> Result<bool> {
+          S3Model::HeadObjectRequest req;
+          req.SetBucket(ToAwsString(bucket));
+          req.SetKey(ToAwsString(key));
+
+          ARROW_ASSIGN_OR_RAISE(auto client_lock, self->holder_->Lock());
+          auto outcome = client_lock.Move()->HeadObject(req);
+          if (outcome.IsSuccess()) {
+            const auto& result = outcome.GetResult();
+            // A directory should be empty and have a trailing slash.  Anything else
+            // we can consider a file
+            return result.GetContentLength() <= 0 && key[key.size() - 1] == '/';
+          }
+          if (IsNotFound(outcome.GetError())) {
+            // If we can't find it then it isn't a file.
+            return true;
+          } else {
+            return ErrorToStatus(
+                std::forward_as_tuple("When getting information for key '", key,
+                                      "' in bucket '", bucket, "': "),
+                "HeadObject", outcome.GetError());
+          }
+        }));
+  }
+
+  // Some operations require running multiple S3 calls, either in parallel or serially. We
+  // need to ensure that the S3 filesystem instance stays valid and that S3 isn't
+  // finalized.  We do this by wrapping all the tasks in a scheduler which keeps the
+  // resources alive
+  Future<> RunInScheduler(
+      std::function<Status(util::AsyncTaskScheduler*, S3FileSystem::Impl*)> callable) {
+    auto self = shared_from_this();
+    FnOnce<Status(util::AsyncTaskScheduler*)> initial_task =
+        [callable = std::move(callable),
+         this](util::AsyncTaskScheduler* scheduler) mutable {
+          return callable(scheduler, this);
+        };
+    Future<> scheduler_fut = util::AsyncTaskScheduler::Make(
+        std::move(initial_task),
+        /*abort_callback=*/
+        [](const Status& st) {
+          // No need for special abort logic.
+        },
+        io_context_.stop_token());
+    // Keep self alive until all tasks finish
+    return scheduler_fut.Then([self]() { return Status::OK(); });
+  }
+
+  Future<> DoDeleteDirContentsAsync(const std::string& bucket, const std::string& key) {
+    return RunInScheduler(
+        [bucket, key](util::AsyncTaskScheduler* scheduler, S3FileSystem::Impl* self) {
+          scheduler->AddSimpleTask(
+              [=] {
+                FileSelector select;
+                select.base_dir = bucket + kSep + key;
+                select.recursive = true;
+                select.allow_not_found = false;
+
+                FileInfoGenerator file_infos = self->GetFileInfoGenerator(select);
+
+                auto handle_file_infos = [=](const std::vector<FileInfo>& file_infos) {
+                  std::vector<std::string> file_paths;
+                  for (const auto& file_info : file_infos) {
+                    DCHECK_GT(file_info.path().size(), bucket.size());
+                    file_paths.push_back(file_info.path().substr(bucket.size() + 1));
+                  }
+                  scheduler->AddSimpleTask(
+                      [=, file_paths = std::move(file_paths)] {
+                        return self->DeleteObjectsAsync(bucket, file_paths);
+                      },
+                      std::string_view("DeleteDirContentsDeleteTask"));
+                  return Status::OK();
+                };
+
+                return VisitAsyncGenerator(
+                    AsyncGenerator<std::vector<FileInfo>>(std::move(file_infos)),
+                    std::move(handle_file_infos));
+              },
+              std::string_view("ListFilesForDelete"));
+          return Status::OK();
+        });
+  }
+
   Future<> DeleteDirContentsAsync(const std::string& bucket, const std::string& key) {
     auto self = shared_from_this();
-    return WalkForDeleteDirAsync(bucket, key)
-        .Then([bucket, key,
-               self](const std::shared_ptr<WalkResult>& discovered) -> Future<> {
-          if (discovered->file_keys.empty() && discovered->dir_keys.empty() &&
-              !key.empty()) {
-            // No contents found, is it an empty directory?
-            ARROW_ASSIGN_OR_RAISE(bool exists, self->IsEmptyDirectory(bucket, key));
-            if (!exists) {
-              return PathNotFound(bucket, key);
-            }
+    return EnsureIsDirAsync(bucket, key)
+        .Then([self, bucket, key](bool is_dir) -> Future<> {
+          if (!is_dir) {
+            return Status::IOError("Cannot delete directory contents at ", bucket, kSep,
+                                   key, " because it is a file");
           }
-          // First delete all "files", then delete all child "directories"
-          return self->DeleteObjectsAsync(bucket, discovered->file_keys)
-              .Then([bucket, discovered, self]() {
-                // Delete directories in reverse lexicographic order, to ensure children
-                // are deleted before their parents (Minio).
-                std::sort(discovered->dir_keys.rbegin(), discovered->dir_keys.rend());
-                return self->DeleteObjectsAsync(bucket, discovered->dir_keys);
-              });
+          return self->DoDeleteDirContentsAsync(bucket, key);
         });
   }
 
+  FileInfoGenerator GetFileInfoGenerator(const FileSelector& select) {
+    auto maybe_base_path = S3Path::FromString(select.base_dir);
+    if (!maybe_base_path.ok()) {
+      return MakeFailingGenerator<FileInfoVector>(maybe_base_path.status());
+    }
+    auto base_path = *std::move(maybe_base_path);
+
+    PushGenerator<std::vector<FileInfo>> generator;
+    Future<> scheduler_fut = RunInScheduler(
+        [select, base_path, sink = generator.producer()](
+            util::AsyncTaskScheduler* scheduler, S3FileSystem::Impl* self) {
+          if (base_path.empty()) {
+            bool should_recurse = select.recursive && select.max_recursion > 0;
+            self->FullListAsync(/*include_implicit_dirs=*/true, scheduler, sink,
+                                should_recurse);
+          } else {
+            self->ListAsync(select, base_path.bucket, base_path.key,
+                            /*include_implicit_dirs=*/true, scheduler, sink);
+          }
+          return Status::OK();
+        });
+
+    // Mark the generator done once all tasks are finished
+    scheduler_fut.AddCallback([sink = generator.producer()](const Status& st) mutable {
+      if (!st.ok()) {
+        sink.Push(st);
+      }
+      sink.Close();
+    });
+
+    return generator;
+  }
+
   Status EnsureDirectoryExists(const S3Path& path) {
     if (!path.key.empty()) {
       return CreateEmptyDir(path.bucket, path.key);
@@ -2381,13 +2467,13 @@ class S3FileSystem::Impl : public std::enable_shared_from_this<S3FileSystem::Imp
     return ProcessListBuckets(client_lock.Move()->ListBuckets());
   }
 
-  Future<std::vector<std::string>> ListBucketsAsync(io::IOContext ctx) {
+  Future<std::vector<std::string>> ListBucketsAsync() {
     auto deferred =
         [self = shared_from_this()]() mutable -> Result<std::vector<std::string>> {
       ARROW_ASSIGN_OR_RAISE(auto client_lock, self->holder_->Lock());
       return self->ProcessListBuckets(client_lock.Move()->ListBuckets());
     };
-    return DeferNotOk(SubmitIO(ctx, std::move(deferred)));
+    return DeferNotOk(SubmitIO(io_context_, std::move(deferred)));
   }
 
   Result<std::shared_ptr<ObjectInputFile>> OpenInputFile(const std::string& s,
@@ -2527,73 +2613,19 @@ Result<FileInfo> S3FileSystem::GetFileInfo(const std::string& s) {
 }
 
 Result<FileInfoVector> S3FileSystem::GetFileInfo(const FileSelector& select) {
-  ARROW_ASSIGN_OR_RAISE(auto base_path, S3Path::FromString(select.base_dir));
-
-  FileInfoVector results;
-
-  if (base_path.empty()) {
-    // List all buckets
-    ARROW_ASSIGN_OR_RAISE(auto buckets, impl_->ListBuckets());
-    for (const auto& bucket : buckets) {
-      FileInfo info;
-      info.set_path(bucket);
-      info.set_type(FileType::Directory);
-      results.push_back(std::move(info));
-      if (select.recursive) {
-        RETURN_NOT_OK(impl_->Walk(select, bucket, "", &results));
-      }
-    }
-    return results;
+  Future<std::vector<FileInfoVector>> file_infos_fut =
+      CollectAsyncGenerator(GetFileInfoGenerator(select));
+  ARROW_ASSIGN_OR_RAISE(std::vector<FileInfoVector> file_infos, file_infos_fut.result());
+  FileInfoVector combined_file_infos;
+  for (const auto& file_info_vec : file_infos) {
+    combined_file_infos.insert(combined_file_infos.end(), file_info_vec.begin(),
+                               file_info_vec.end());
   }
-
-  // Nominal case -> walk a single bucket
-  RETURN_NOT_OK(impl_->Walk(select, base_path.bucket, base_path.key, &results));
-  return results;
+  return combined_file_infos;
 }
 
 FileInfoGenerator S3FileSystem::GetFileInfoGenerator(const FileSelector& select) {
-  auto maybe_base_path = S3Path::FromString(select.base_dir);
-  if (!maybe_base_path.ok()) {
-    return MakeFailingGenerator<FileInfoVector>(maybe_base_path.status());
-  }
-  auto base_path = *std::move(maybe_base_path);
-
-  if (base_path.empty()) {
-    // List all buckets, then possibly recurse
-    PushGenerator<AsyncGenerator<FileInfoVector>> gen;
-    auto producer = gen.producer();
-
-    auto fut = impl_->ListBucketsAsync(io_context());
-    auto impl = impl_->shared_from_this();
-    fut.AddCallback(
-        [producer, select, impl](const Result<std::vector<std::string>>& res) mutable {
-          if (!res.ok()) {
-            producer.Push(res.status());
-            producer.Close();
-            return;
-          }
-          FileInfoVector buckets;
-          for (const auto& bucket : *res) {
-            buckets.push_back(FileInfo{bucket, FileType::Directory});
-          }
-          // Generate all bucket infos
-          auto buckets_fut = Future<FileInfoVector>::MakeFinished(std::move(buckets));
-          producer.Push(MakeSingleFutureGenerator(buckets_fut));
-          if (select.recursive) {
-            // Generate recursive walk for each bucket in turn
-            for (const auto& bucket : *buckets_fut.result()) {
-              producer.Push(impl->WalkAsync(select, bucket.path(), ""));
-            }
-          }
-          producer.Close();
-        });
-
-    return MakeConcatenatedGenerator(
-        AsyncGenerator<AsyncGenerator<FileInfoVector>>{std::move(gen)});
-  }
-
-  // Nominal case -> walk a single bucket
-  return impl_->WalkAsync(select, base_path.bucket, base_path.key);
+  return impl_->GetFileInfoGenerator(select);
 }
 
 Status S3FileSystem::CreateDir(const std::string& s, bool recursive) {
diff --git a/cpp/src/arrow/filesystem/s3fs_test.cc b/cpp/src/arrow/filesystem/s3fs_test.cc
index 718304abaed63..e9f14fde72316 100644
--- a/cpp/src/arrow/filesystem/s3fs_test.cc
+++ b/cpp/src/arrow/filesystem/s3fs_test.cc
@@ -66,13 +66,17 @@
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
+#include "arrow/util/range.h"
+#include "arrow/util/string.h"
 
 namespace arrow {
 namespace fs {
 
 using ::arrow::internal::checked_pointer_cast;
 using ::arrow::internal::PlatformFilename;
+using ::arrow::internal::ToChars;
 using ::arrow::internal::UriEscape;
+using ::arrow::internal::Zip;
 
 using ::arrow::fs::internal::ConnectRetryStrategy;
 using ::arrow::fs::internal::ErrorToStatus;
@@ -459,16 +463,19 @@ class TestS3FS : public S3TestMixin {
     }
   }
 
-  void MakeFileSystem() {
+  Result<std::shared_ptr<S3FileSystem>> MakeNewFileSystem(
+      io::IOContext io_context = io::default_io_context()) {
     options_.ConfigureAccessKey(minio_->access_key(), minio_->secret_key());
     options_.scheme = "http";
     options_.endpoint_override = minio_->connect_string();
     if (!options_.retry_strategy) {
       options_.retry_strategy = std::make_shared<ShortRetryStrategy>();
     }
-    ASSERT_OK_AND_ASSIGN(fs_, S3FileSystem::Make(options_));
+    return S3FileSystem::Make(options_, io_context);
   }
 
+  void MakeFileSystem() { ASSERT_OK_AND_ASSIGN(fs_, MakeNewFileSystem()); }
+
   template <typename Matcher>
   void AssertMetadataRoundtrip(const std::string& path,
                                const std::shared_ptr<const KeyValueMetadata>& metadata,
@@ -787,6 +794,81 @@ TEST_F(TestS3FS, GetFileInfoGenerator) {
   // Non-root dir case is tested by generic tests
 }
 
+TEST_F(TestS3FS, GetFileInfoGeneratorStress) {
+  // This test is slow because it needs to create a bunch of seed files.  However, it is
+  // the only test that stresses listing and deleting when there are more than 1000 files
+  // and paging is required.
+  constexpr int32_t kNumDirs = 4;
+  constexpr int32_t kNumFilesPerDir = 512;
+  FileInfoVector expected_infos;
+
+  ASSERT_OK(fs_->CreateDir("stress"));
+  for (int32_t i = 0; i < kNumDirs; i++) {
+    const std::string dir_path = "stress/" + ToChars(i);
+    ASSERT_OK(fs_->CreateDir(dir_path));
+    expected_infos.emplace_back(dir_path, FileType::Directory);
+
+    std::vector<Future<>> tasks;
+    for (int32_t j = 0; j < kNumFilesPerDir; j++) {
+      // Create the files in parallel in hopes of speeding up this process as much as
+      // possible
+      const std::string file_name = ToChars(j);
+      const std::string file_path = dir_path + "/" + file_name;
+      expected_infos.emplace_back(file_path, FileType::File);
+      ASSERT_OK_AND_ASSIGN(Future<> task,
+                           ::arrow::internal::GetCpuThreadPool()->Submit(
+                               [fs = fs_, file_name, file_path]() -> Status {
+                                 ARROW_ASSIGN_OR_RAISE(
+                                     std::shared_ptr<io::OutputStream> out_str,
+                                     fs->OpenOutputStream(file_path));
+                                 ARROW_RETURN_NOT_OK(out_str->Write(file_name));
+                                 return out_str->Close();
+                               }));
+      tasks.push_back(std::move(task));
+    }
+    ASSERT_FINISHES_OK(AllFinished(tasks));
+  }
+  SortInfos(&expected_infos);
+
+  FileSelector select;
+  FileInfoVector infos;
+  select.base_dir = "stress";
+  select.recursive = true;
+
+  // 32 is pretty fast, listing is much faster than the create step above
+  constexpr int32_t kNumTasks = 32;
+  for (int i = 0; i < kNumTasks; i++) {
+    CollectFileInfoGenerator(fs_->GetFileInfoGenerator(select), &infos);
+    SortInfos(&infos);
+    // One info for each directory and one info for each file
+    ASSERT_EQ(infos.size(), expected_infos.size());
+    for (const auto&& [info, expected] : Zip(infos, expected_infos)) {
+      AssertFileInfo(info, expected.path(), expected.type());
+    }
+  }
+
+  ASSERT_OK(fs_->DeleteDirContents("stress"));
+
+  CollectFileInfoGenerator(fs_->GetFileInfoGenerator(select), &infos);
+  ASSERT_EQ(infos.size(), 0);
+}
+
+TEST_F(TestS3FS, GetFileInfoGeneratorCancelled) {
+  FileSelector select;
+  FileInfoVector infos;
+  select.base_dir = "bucket";
+  select.recursive = true;
+
+  StopSource stop_source;
+  io::IOContext cancellable_context(stop_source.token());
+  ASSERT_OK_AND_ASSIGN(std::shared_ptr<S3FileSystem> cancellable_fs,
+                       MakeNewFileSystem(cancellable_context));
+  stop_source.RequestStop();
+  FileInfoGenerator generator = cancellable_fs->GetFileInfoGenerator(select);
+  auto file_infos = CollectAsyncGenerator(std::move(generator));
+  ASSERT_FINISHES_AND_RAISES(Cancelled, file_infos);
+}
+
 TEST_F(TestS3FS, CreateDir) {
   FileInfo st;
 
diff --git a/cpp/src/arrow/util/async_util.cc b/cpp/src/arrow/util/async_util.cc
index 55627eb43bbcf..63e27bfbe5773 100644
--- a/cpp/src/arrow/util/async_util.cc
+++ b/cpp/src/arrow/util/async_util.cc
@@ -201,10 +201,14 @@ class AsyncTaskSchedulerImpl : public AsyncTaskScheduler {
     }
     // Capture `task` to keep it alive until finished
     if (!submit_result->TryAddCallback([this, task_inner = std::move(task)]() mutable {
-          return [this, task_inner2 = std::move(task_inner)](const Status& st) {
+          return [this, task_inner2 = std::move(task_inner)](const Status& st) mutable {
 #ifdef ARROW_WITH_OPENTELEMETRY
             TraceTaskFinished(task_inner2.get());
 #endif
+            // OnTaskFinished might trigger the scheduler to end.  We want to ensure that
+            // is the very last thing that happens after all task destructors have run so
+            // we eagerly destroy the task first.
+            task_inner2.reset();
             OnTaskFinished(st);
           };
         })) {
diff --git a/cpp/src/arrow/util/async_util_test.cc b/cpp/src/arrow/util/async_util_test.cc
index 7734b84c9ebaf..313ca91912335 100644
--- a/cpp/src/arrow/util/async_util_test.cc
+++ b/cpp/src/arrow/util/async_util_test.cc
@@ -204,6 +204,29 @@ TEST(AsyncTaskScheduler, InitialTaskFails) {
   ASSERT_FINISHES_AND_RAISES(Invalid, finished);
 }
 
+TEST(AsyncTaskScheduler, TaskDestroyedBeforeSchedulerEnds) {
+  bool my_task_destroyed = false;
+  Future<> task_fut = Future<>::Make();
+  struct DestroyTrackingTask : public AsyncTaskScheduler::Task {
+    DestroyTrackingTask(bool& my_task_destroyed, Future<> task_fut)
+        : my_task_destroyed(my_task_destroyed), task_fut(std::move(task_fut)) {}
+    ~DestroyTrackingTask() override { my_task_destroyed = true; }
+    std::string_view name() const override { return "DestroyTrackingTask"; }
+    Result<Future<>> operator()() override { return task_fut; }
+    bool& my_task_destroyed;
+    Future<> task_fut;
+  };
+  Future<> finished = AsyncTaskScheduler::Make([&](AsyncTaskScheduler* scheduler) {
+                        scheduler->AddTask(std::make_unique<DestroyTrackingTask>(
+                            my_task_destroyed, task_fut));
+                        return Status::OK();
+                      }).Then([&] { ASSERT_TRUE(my_task_destroyed); });
+  ASSERT_FALSE(my_task_destroyed);
+  task_fut.MarkFinished();
+  ASSERT_FINISHES_OK(finished);
+  ASSERT_TRUE(my_task_destroyed);
+}
+
 TEST(AsyncTaskScheduler, TaskGroup) {
   Future<> task = Future<>::Make();
   bool finish_callback_ran = false;

From ec2bc346b85b0ffd49dff49bf29552e45e02ca98 Mon Sep 17 00:00:00 2001
From: Thor <8681572+thorfour@users.noreply.github.com>
Date: Tue, 25 Jul 2023 11:42:26 -0500
Subject: [PATCH 045/749] GH-36850: [Go] Arrow Concatenate fix, ensure
 allocations are Free'd (#36854)

### Rationale for this change

The Concatenate function would capture panic's and return errors, however it wouldn't ensure that any allocations that happened in the `concat` sub function were cleaned up upon doing so.

This change moves the `recover()` step into the `concat` function and will call `Release()` on the data object in the case of panic or error.

### What changes are included in this PR?

### Are these changes tested?

A test called `TestConcatPanic` was added that causes the allocator to throw a panic part way during a concatenation, and ensures that the checked allocator still returns 0.

### Are there any user-facing changes?

* Closes: #36850

Authored-by: thorfour <me@thor-hansen.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/concat.go      | 28 ++++++++++++------------
 go/arrow/array/concat_test.go | 40 +++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 838fe91d0accc..5d3d2e005d488 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -41,17 +41,6 @@ func Concatenate(arrs []arrow.Array, mem memory.Allocator) (result arrow.Array,
 		return nil, errors.New("array/concat: must pass at least one array")
 	}
 
-	defer func() {
-		if pErr := recover(); pErr != nil {
-			switch e := pErr.(type) {
-			case error:
-				err = fmt.Errorf("arrow/concat: %w", e)
-			default:
-				err = fmt.Errorf("arrow/concat: %v", pErr)
-			}
-		}
-	}()
-
 	// gather Data of inputs
 	data := make([]arrow.ArrayData, len(arrs))
 	for i, ar := range arrs {
@@ -368,8 +357,21 @@ func concatOffsets(buffers []*memory.Buffer, byteWidth int, mem memory.Allocator
 
 // concat is the implementation for actually performing the concatenation of the arrow.ArrayData
 // objects that we can call internally for nested types.
-func concat(data []arrow.ArrayData, mem memory.Allocator) (arrow.ArrayData, error) {
+func concat(data []arrow.ArrayData, mem memory.Allocator) (arr arrow.ArrayData, err error) {
 	out := &Data{refCount: 1, dtype: data[0].DataType(), nulls: 0}
+	defer func() {
+		if pErr := recover(); pErr != nil {
+			switch e := pErr.(type) {
+			case error:
+				err = fmt.Errorf("arrow/concat: %w", e)
+			default:
+				err = fmt.Errorf("arrow/concat: %v", pErr)
+			}
+		}
+		if err != nil {
+			out.Release()
+		}
+	}()
 	for _, d := range data {
 		out.length += d.Len()
 		if out.nulls == UnknownNullCount || d.NullN() == UnknownNullCount {
@@ -445,8 +447,8 @@ func concat(data []arrow.ArrayData, mem memory.Allocator) (arrow.ArrayData, erro
 		if err != nil {
 			return nil, err
 		}
-		out.buffers[2] = concatBuffers(gatherBufferRanges(data, 2, valueRanges), mem)
 		out.buffers[1] = offsetBuffer
+		out.buffers[2] = concatBuffers(gatherBufferRanges(data, 2, valueRanges), mem)
 	case *arrow.ListType:
 		offsetWidth := dt.Layout().Buffers[1].ByteWidth
 		offsetBuffer, valueRanges, err := concatOffsets(gatherFixedBuffers(data, 1, offsetWidth), offsetWidth, mem)
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index 6cf86883d1520..3c1cb4c3d0812 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -743,3 +743,43 @@ func TestConcatOverflowRunEndEncoding(t *testing.T) {
 		})
 	}
 }
+
+type panicAllocator struct {
+	n int
+	memory.Allocator
+}
+
+func (p *panicAllocator) Allocate(size int) []byte {
+	if size > p.n {
+		panic("panic allocator")
+	}
+	return p.Allocator.Allocate(size)
+}
+
+func (p *panicAllocator) Reallocate(size int, b []byte) []byte {
+	return p.Allocator.Reallocate(size, b)
+}
+
+func (p *panicAllocator) Free(b []byte) {
+	p.Allocator.Free(b)
+}
+
+func TestConcatPanic(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(t, 0)
+
+	allocator := &panicAllocator{
+		n:         400,
+		Allocator: mem,
+	}
+
+	g := gen.NewRandomArrayGenerator(0, memory.DefaultAllocator)
+	ar1 := g.ArrayOf(arrow.STRING, 32, 0)
+	defer ar1.Release()
+	ar2 := g.ArrayOf(arrow.STRING, 32, 0)
+	defer ar2.Release()
+
+	concat, err := array.Concatenate([]arrow.Array{ar1, ar2}, allocator)
+	assert.Error(t, err)
+	assert.Nil(t, concat)
+}

From d9b90035ddf273fa547d34ad2f4b04c15af3704a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 25 Jul 2023 18:49:26 +0200
Subject: [PATCH 046/749] GH-36863: [C#][Packaging] Do not shutdown
 PythonEngine on CDataInterfacePythonTests if .NET is > 5.0 (#36868)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Tests are failing on maintenance branch to generate Nuget packages. This has been tested on the maintenance branch and it solves the issue.

### What changes are included in this PR?

Only Shutdown if `#if !NET5_0_OR_GREATER`

### Are these changes tested?

Locally and via archery.

### Are there any user-facing changes?

No
* Closes: #36863

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 4c53b98e3d9f1..86d7ff52cdf09 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -60,7 +60,9 @@ public PythonNet()
 
             public void Dispose()
             {
+#if !NET5_0_OR_GREATER
                 PythonEngine.Shutdown();
+#endif
             }
         }
 

From adfd482518cf2c7ff620cc1986ad38e51b378e1f Mon Sep 17 00:00:00 2001
From: Thor <8681572+thorfour@users.noreply.github.com>
Date: Tue, 25 Jul 2023 14:09:49 -0500
Subject: [PATCH 047/749] GH-36671: [Go] BinaryMemoTable optimize allocations
 of GetOrInsert (#36811)

### Rationale for this change

The hashing.MemoTable provides an interface with

    GetOrInsert(val interface{}) (idx int, existed bool, err error)

This can cause a costly allocation for binary dictionaries as is detailed in issue https://github.com/apache/arrow/issues/36671

If we expand the MemoTable interface to include:


    GetOrInsertBytes(val []byte) (idx int, existed bool, err error)

We can avoid the allocations at runtime to convert from `[]byte` to `interface{}`

### What changes are included in this PR?

No logic was changed with the BinaryMemoTable but instead the same API for `GetOrInsert` was copied to a type specific API of `GetOrInsertBytes`.

The `BinaryDictionaryBuilder` now simple calls these bytes methods instead of the generic `interface{}` ones.

### Are these changes tested?

No additional tests were included as the current tests exercise this code.

### Are there any user-facing changes?

* Closes: #36671

Authored-by: thorfour <me@thor-hansen.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/dictionary.go                  | 20 ++++++--
 go/arrow/array/dictionary_test.go             | 19 +++++++
 go/internal/hashing/xxh3_memo_table.gen.go    | 50 +++++++++++++++++++
 .../hashing/xxh3_memo_table.gen.go.tmpl       |  6 +++
 go/internal/hashing/xxh3_memo_table.go        | 22 ++++++++
 5 files changed, 114 insertions(+), 3 deletions(-)

diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index da1aea50b24f8..ccb6f32321496 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -842,6 +842,11 @@ func (b *dictionaryBuilder) insertDictValue(val interface{}) error {
 	return err
 }
 
+func (b *dictionaryBuilder) insertDictBytes(val []byte) error {
+	_, _, err := b.memoTable.GetOrInsertBytes(val)
+	return err
+}
+
 func (b *dictionaryBuilder) appendValue(val interface{}) error {
 	idx, _, err := b.memoTable.GetOrInsert(val)
 	b.idxBuilder.Append(idx)
@@ -849,6 +854,13 @@ func (b *dictionaryBuilder) appendValue(val interface{}) error {
 	return err
 }
 
+func (b *dictionaryBuilder) appendBytes(val []byte) error {
+	idx, _, err := b.memoTable.GetOrInsertBytes(val)
+	b.idxBuilder.Append(idx)
+	b.length += 1
+	return err
+}
+
 func getvalFn(arr arrow.Array) func(i int) interface{} {
 	switch typedarr := arr.(type) {
 	case *Int8:
@@ -1285,16 +1297,18 @@ func (b *BinaryDictionaryBuilder) Append(v []byte) error {
 		b.AppendNull()
 		return nil
 	}
-	return b.appendValue(v)
+
+	return b.appendBytes(v)
 }
-func (b *BinaryDictionaryBuilder) AppendString(v string) error { return b.appendValue(v) }
+
+func (b *BinaryDictionaryBuilder) AppendString(v string) error { return b.appendBytes([]byte(v)) }
 func (b *BinaryDictionaryBuilder) InsertDictValues(arr *Binary) (err error) {
 	if !arrow.TypeEqual(arr.DataType(), b.dt.ValueType) {
 		return fmt.Errorf("dictionary insert type mismatch: cannot insert values of type %T to dictionary type %T", arr.DataType(), b.dt.ValueType)
 	}
 
 	for i := 0; i < arr.Len(); i++ {
-		if err = b.insertDictValue(arr.Value(i)); err != nil {
+		if err = b.insertDictBytes(arr.Value(i)); err != nil {
 			break
 		}
 	}
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index 8bb9edebf89bc..99c8e6ffcd47b 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -19,6 +19,7 @@ package array_test
 import (
 	"fmt"
 	"math"
+	"math/rand"
 	"reflect"
 	"strings"
 	"testing"
@@ -1846,3 +1847,21 @@ func TestBinaryDictionaryPanic(t *testing.T) {
 	}()
 	assert.True(t, allocator.paniced)
 }
+
+func BenchmarkBinaryDictionaryBuilder(b *testing.B) {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(b, 0)
+
+	dictType := &arrow.DictionaryType{IndexType: &arrow.Int32Type{}, ValueType: arrow.BinaryTypes.String}
+	bldr := array.NewDictionaryBuilder(mem, dictType)
+	defer bldr.Release()
+
+	randString := func() string {
+		return fmt.Sprintf("test-%d", rand.Intn(30))
+	}
+
+	builder := bldr.(*array.BinaryDictionaryBuilder)
+	for i := 0; i < b.N; i++ {
+		assert.NoError(b, builder.AppendString(randString()))
+	}
+}
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go b/go/internal/hashing/xxh3_memo_table.gen.go
index 0c36aee950f83..f561c5f30f895 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go
+++ b/go/internal/hashing/xxh3_memo_table.gen.go
@@ -298,6 +298,11 @@ func (s *Int8MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err e
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Int8MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadUint8 struct {
 	val     uint8
 	memoIdx int32
@@ -570,6 +575,11 @@ func (s *Uint8MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Uint8MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadInt16 struct {
 	val     int16
 	memoIdx int32
@@ -842,6 +852,11 @@ func (s *Int16MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Int16MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadUint16 struct {
 	val     uint16
 	memoIdx int32
@@ -1114,6 +1129,11 @@ func (s *Uint16MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Uint16MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadInt32 struct {
 	val     int32
 	memoIdx int32
@@ -1386,6 +1406,11 @@ func (s *Int32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Int32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadInt64 struct {
 	val     int64
 	memoIdx int32
@@ -1658,6 +1683,11 @@ func (s *Int64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Int64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadUint32 struct {
 	val     uint32
 	memoIdx int32
@@ -1930,6 +1960,11 @@ func (s *Uint32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Uint32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadUint64 struct {
 	val     uint64
 	memoIdx int32
@@ -2202,6 +2237,11 @@ func (s *Uint64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, err
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Uint64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadFloat32 struct {
 	val     float32
 	memoIdx int32
@@ -2493,6 +2533,11 @@ func (s *Float32MemoTable) GetOrInsert(val interface{}) (idx int, found bool, er
 	return
 }
 
+// GetOrInsertBytes is unimplemented
+func (s *Float32MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
+
 type payloadFloat64 struct {
 	val     float64
 	memoIdx int32
@@ -2781,3 +2826,8 @@ func (s *Float64MemoTable) GetOrInsert(val interface{}) (idx int, found bool, er
 	}
 	return
 }
+
+// GetOrInsertBytes is unimplemented
+func (s *Float64MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	panic("unimplemented")
+}
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
index 94c893b94b314..10127c43cc6b1 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
+++ b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
@@ -340,4 +340,10 @@ func (s *{{.Name}}MemoTable) GetOrInsert(val interface{}) (idx int, found bool,
   }
   return
 }
+
+
+// GetOrInsertBytes is unimplemented
+func (s *{{.Name}}MemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+    panic("unimplemented")
+}
 {{end}}
diff --git a/go/internal/hashing/xxh3_memo_table.go b/go/internal/hashing/xxh3_memo_table.go
index 67e2aef380488..81994f0a88541 100644
--- a/go/internal/hashing/xxh3_memo_table.go
+++ b/go/internal/hashing/xxh3_memo_table.go
@@ -53,6 +53,12 @@ type MemoTable interface {
 	// the table (if false, the value was inserted). An error is returned
 	// if val is not the appropriate type for the table.
 	GetOrInsert(val interface{}) (idx int, existed bool, err error)
+	// GetOrInsertBytes returns the index of the table the specified value is,
+	// and a boolean indicating whether or not the value was found in
+	// the table (if false, the value was inserted). An error is returned
+	// if val is not the appropriate type for the table. This function is intended to be used by
+	// the BinaryMemoTable to prevent uncessary allocations of the data when converting from a []byte to interface{}.
+	GetOrInsertBytes(val []byte) (idx int, existed bool, err error)
 	// GetOrInsertNull returns the index of the null value in the table,
 	// inserting one if it hasn't already been inserted. It returns a boolean
 	// indicating if the null value already existed or not in the table.
@@ -231,6 +237,22 @@ func (b *BinaryMemoTable) Get(val interface{}) (int, bool) {
 	return KeyNotFound, false
 }
 
+// GetOrInsertBytes returns the index of the given value in the table, if not found
+// it is inserted into the table. The return value 'found' indicates whether the value
+// was found in the table (true) or inserted (false) along with any possible error.
+func (b *BinaryMemoTable) GetOrInsertBytes(val []byte) (idx int, found bool, err error) {
+	h := Hash(val, 0)
+	p, found := b.lookup(h, val)
+	if found {
+		idx = int(p.payload.val)
+	} else {
+		idx = b.Size()
+		b.builder.Append(val)
+		b.tbl.Insert(p, h, int32(idx), -1)
+	}
+	return
+}
+
 // GetOrInsert returns the index of the given value in the table, if not found
 // it is inserted into the table. The return value 'found' indicates whether the value
 // was found in the table (true) or inserted (false) along with any possible error.

From 5a9240fd28e1d7261a10a4816301d22995cfb8e0 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 25 Jul 2023 16:14:51 -0400
Subject: [PATCH 048/749] MINOR: Fix build double declaration (#36876)

### Rationale for this change
#36811 and #36854 both introduced a helper in their tests, but the result after merge was a collision causing it to be declared twice which made the Go build fail. By removing one of the duplicate declarations the build is fixed.

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/concat_test.go | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index 3c1cb4c3d0812..a74166541e856 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -744,26 +744,6 @@ func TestConcatOverflowRunEndEncoding(t *testing.T) {
 	}
 }
 
-type panicAllocator struct {
-	n int
-	memory.Allocator
-}
-
-func (p *panicAllocator) Allocate(size int) []byte {
-	if size > p.n {
-		panic("panic allocator")
-	}
-	return p.Allocator.Allocate(size)
-}
-
-func (p *panicAllocator) Reallocate(size int, b []byte) []byte {
-	return p.Allocator.Reallocate(size, b)
-}
-
-func (p *panicAllocator) Free(b []byte) {
-	p.Allocator.Free(b)
-}
-
 func TestConcatPanic(t *testing.T) {
 	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
 	defer mem.AssertSize(t, 0)

From 2f039f1e0d53b793c634078379ac031c6c55d53d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 26 Jul 2023 10:05:58 +0200
Subject: [PATCH 049/749] GH-36863: [C#] Remove unnecessary applied fix to not
 shutdown PythonEngine on CDataInterfacePythonTests if .NET is > 5.0 (#36872)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Maintenance branch fix is not necessary.

### What changes are included in this PR?

Remove unnecessary patch

### Are these changes tested?

Yes, on CI

### Are there any user-facing changes?

No
* Closes: #36863

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 86d7ff52cdf09..4c53b98e3d9f1 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -60,9 +60,7 @@ public PythonNet()
 
             public void Dispose()
             {
-#if !NET5_0_OR_GREATER
                 PythonEngine.Shutdown();
-#endif
             }
         }
 

From 52ac7185e32f395927d5b7f2aee102ceb8485a98 Mon Sep 17 00:00:00 2001
From: 0x26res <arthur.andres@gmail.com>
Date: Wed, 26 Jul 2023 14:27:16 +0100
Subject: [PATCH 050/749] GH-36809: [Python] MapScalar.as_py with custom field
 name (#36830)

### Rationale for this change

`MapScalar.as_py` doesn't take into account custom key/value field names

### What changes are included in this PR?

Fix and tests

### Are these changes tested?

Simple unit test

### Are there any user-facing changes?

No API changes.
* Closes: #36809

Authored-by: aandres <aandres@tradewelltech.co>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/scalar.pxi            |  4 ++--
 python/pyarrow/tests/test_scalars.py | 23 +++++++++++++++++++++++
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/python/pyarrow/scalar.pxi b/python/pyarrow/scalar.pxi
index f438c8847bb02..74f5aa4213ca0 100644
--- a/python/pyarrow/scalar.pxi
+++ b/python/pyarrow/scalar.pxi
@@ -785,7 +785,7 @@ cdef class MapScalar(ListScalar):
         if arr is None:
             raise IndexError(i)
         dct = arr[_normalize_index(i, len(arr))]
-        return (dct['key'], dct['value'])
+        return (dct[self.type.key_field.name], dct[self.type.item_field.name])
 
     def __iter__(self):
         """
@@ -794,7 +794,7 @@ cdef class MapScalar(ListScalar):
         arr = self.values
         if array is None:
             raise StopIteration
-        for k, v in zip(arr.field('key'), arr.field('value')):
+        for k, v in zip(arr.field(self.type.key_field.name), arr.field(self.type.item_field.name)):
             yield (k.as_py(), v.as_py())
 
     def as_py(self):
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index b7180e5250fdf..2aaefe16ae469 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -791,3 +791,26 @@ def test_union():
     assert arr[0].as_py() == b'a'
     assert arr[5].type_code == 1
     assert arr[5].as_py() == 3
+
+
+def test_map_scalar_as_py_with_custom_field_name():
+    """
+    Check we can call `MapScalar.as_py` with custom field names
+
+    See https://github.com/apache/arrow/issues/36809
+    """
+    assert pa.scalar(
+        [("foo", "bar")],
+        pa.map_(
+            pa.string(),
+            pa.string()
+        ),
+    ).as_py() == [("foo", "bar")]
+
+    assert pa.scalar(
+        [("foo", "bar")],
+        pa.map_(
+            pa.field("custom_key", pa.string(), nullable=False),
+            pa.field("custom_value", pa.string()),
+        ),
+    ).as_py() == [("foo", "bar")]

From 8503c869fa80090bc849bae0b4e68a84605ea82e Mon Sep 17 00:00:00 2001
From: h-vetinari <h.vetinari@gmx.com>
Date: Thu, 27 Jul 2023 00:45:29 +1100
Subject: [PATCH 051/749] GH-35658: [Packaging] Sync conda recipes with
 feedstocks (#35637)

Corresponds to https://github.com/conda-forge/arrow-cpp-feedstock/pull/1053 for pyarrow (one failing test on our infra that needs debugging), as well as the state of the feedstock for r-arrow after https://github.com/conda-forge/r-arrow-feedstock/pull/65
* Closes: #35658

Authored-by: H. Vetinari <h.vetinari@gmx.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ...> linux_64_cuda_compiler_version11.2.yaml} |  33 +++--
 .../linux_64_cuda_compiler_versionNone.yaml   |  29 ++--
 ...nux_aarch64_cuda_compiler_version11.2.yaml |  91 ++++++++++++
 ...nux_aarch64_cuda_compiler_versionNone.yaml |  29 ++--
 ...nux_ppc64le_cuda_compiler_version11.2.yaml |  87 ++++++++++++
 ...nux_ppc64le_cuda_compiler_versionNone.yaml |  29 ++--
 .../conda-recipes/.ci_support/osx_64_.yaml    |  24 ++--
 .../conda-recipes/.ci_support/osx_arm64_.yaml |  24 ++--
 .../.ci_support/r/linux_64_r_base4.1.yaml     |  27 ++++
 .../.ci_support/r/linux_64_r_base4.2.yaml     |   4 +-
 .../r/linux_aarch64_r_base4.1.yaml            |  31 ++++
 .../r/linux_aarch64_r_base4.2.yaml            |   4 +-
 .../.ci_support/r/osx_64_r_base4.1.yaml       |  27 ++++
 .../.ci_support/r/osx_64_r_base4.2.yaml       |   4 +-
 .../.ci_support/r/osx_arm64_r_base4.1.yaml    |  27 ++++
 .../.ci_support/r/osx_arm64_r_base4.2.yaml    |   4 +-
 ... => win_64_cuda_compiler_version11.2.yaml} |  26 ++--
 .../win_64_cuda_compiler_versionNone.yaml     |  26 ++--
 dev/tasks/conda-recipes/arrow-cpp/activate.sh |  74 ++++++++--
 .../{bld-arrow.bat => build-arrow.bat}        |  14 +-
 .../conda-recipes/arrow-cpp/build-arrow.sh    |  43 +++---
 .../{bld-pyarrow.bat => build-pyarrow.bat}    |  14 +-
 .../conda-recipes/arrow-cpp/build-pyarrow.sh  |   5 +-
 dev/tasks/conda-recipes/arrow-cpp/meta.yaml   | 134 +++++++++++-------
 dev/tasks/conda-recipes/azure.linux.yml       |  23 +++
 dev/tasks/conda-recipes/r-arrow/configure.win |   4 +-
 dev/tasks/conda-recipes/r-arrow/meta.yaml     |   2 -
 dev/tasks/tasks.yml                           |  68 ++++++++-
 28 files changed, 687 insertions(+), 220 deletions(-)
 rename dev/tasks/conda-recipes/.ci_support/{linux_64_cuda_compiler_version10.2.yaml => linux_64_cuda_compiler_version11.2.yaml} (79%)
 create mode 100644 dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
 create mode 100644 dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
 create mode 100644 dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml
 create mode 100644 dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml
 create mode 100644 dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml
 create mode 100644 dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml
 rename dev/tasks/conda-recipes/.ci_support/{win_64_cuda_compiler_version10.2.yaml => win_64_cuda_compiler_version11.2.yaml} (78%)
 rename dev/tasks/conda-recipes/arrow-cpp/{bld-arrow.bat => build-arrow.bat} (89%)
 rename dev/tasks/conda-recipes/arrow-cpp/{bld-pyarrow.bat => build-pyarrow.bat} (54%)

diff --git a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version10.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
similarity index 79%
rename from dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version10.2.yaml
rename to dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
index 5d80a17c4dfd7..1cdcec199e7ba 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version10.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
@@ -1,17 +1,15 @@
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - gcc
 c_compiler_version:
-- '7'
+- '10'
 cdt_name:
-- cos6
+- cos7
 channel_sources:
 - conda-forge
 channel_targets:
@@ -19,38 +17,40 @@ channel_targets:
 cuda_compiler:
 - nvcc
 cuda_compiler_version:
-- '10.2'
+- '11.2'
 cuda_compiler_version_min:
-- '10.2'
+- '11.2'
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '7'
+- '10'
 docker_image:
-- quay.io/condaforge/linux-anvil-cos7-cuda:10.2
+- quay.io/condaforge/linux-anvil-cuda:11.2
 gflags:
 - '2.2'
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -61,7 +61,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -73,9 +73,12 @@ ucx:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+  - cuda_compiler
   - cuda_compiler_version
   - cdt_name
   - docker_image
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
index 39b25b44690d7..5be5b58a73932 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
@@ -1,15 +1,13 @@
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - gcc
 c_compiler_version:
-- '11'
+- '12'
 cdt_name:
 - cos6
 channel_sources:
@@ -17,15 +15,15 @@ channel_sources:
 channel_targets:
 - conda-forge main
 cuda_compiler:
-- nvcc
+- None
 cuda_compiler_version:
 - None
 cuda_compiler_version_min:
-- '10.2'
+- '11.2'
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '11'
+- '12'
 docker_image:
 - quay.io/condaforge/linux-anvil-cos7-x86_64
 gflags:
@@ -33,24 +31,26 @@ gflags:
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -61,7 +61,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -73,9 +73,12 @@ ucx:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+  - cuda_compiler
   - cuda_compiler_version
   - cdt_name
   - docker_image
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
new file mode 100644
index 0000000000000..1677b03564c08
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
@@ -0,0 +1,91 @@
+BUILD:
+- aarch64-conda_cos7-linux-gnu
+aws_crt_cpp:
+- 0.20.3
+aws_sdk_cpp:
+- 1.10.57
+bzip2:
+- '1'
+c_compiler:
+- gcc
+c_compiler_version:
+- '10'
+cdt_arch:
+- aarch64
+cdt_name:
+- cos7
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cuda_compiler:
+- nvcc
+cuda_compiler_version:
+- '11.2'
+cuda_compiler_version_min:
+- '11.2'
+cxx_compiler:
+- gxx
+cxx_compiler_version:
+- '10'
+docker_image:
+- quay.io/condaforge/linux-anvil-cuda:11.2
+gflags:
+- '2.2'
+glog:
+- '0.6'
+google_cloud_cpp:
+- '2.12'
+libabseil:
+- '20230125'
+libgrpc:
+- '1.54'
+- '1.56'
+libprotobuf:
+- '3.21'
+- 4.23.3
+lz4_c:
+- 1.9.3
+numpy:
+- '1.21'
+- '1.23'
+- '1.21'
+- '1.21'
+openssl:
+- '3'
+orc:
+- 1.9.0
+pin_run_as_build:
+  python:
+    min_pin: x.x
+    max_pin: x.x
+python:
+- 3.10.* *_cpython
+- 3.11.* *_cpython
+- 3.8.* *_cpython
+- 3.9.* *_cpython
+re2:
+- 2023.03.02
+snappy:
+- '1'
+target_platform:
+- linux-aarch64
+thrift_cpp:
+- 0.18.1
+ucx:
+- 1.14.0
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
+  - cuda_compiler
+  - cuda_compiler_version
+  - cdt_name
+  - docker_image
+- - libgrpc
+  - libprotobuf
+- - python
+  - numpy
+zlib:
+- '1.2'
+zstd:
+- '1.5'
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
index af0fc2dcd255e..88fdf1254e661 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
@@ -1,17 +1,15 @@
 BUILD:
 - aarch64-conda_cos7-linux-gnu
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - gcc
 c_compiler_version:
-- '11'
+- '12'
 cdt_arch:
 - aarch64
 cdt_name:
@@ -20,12 +18,16 @@ channel_sources:
 - conda-forge
 channel_targets:
 - conda-forge main
+cuda_compiler:
+- None
 cuda_compiler_version:
 - None
+cuda_compiler_version_min:
+- '11.2'
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '11'
+- '12'
 docker_image:
 - quay.io/condaforge/linux-anvil-cos7-x86_64
 gflags:
@@ -33,24 +35,26 @@ gflags:
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -61,7 +65,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -73,9 +77,12 @@ ucx:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+  - cuda_compiler
   - cuda_compiler_version
   - cdt_name
   - docker_image
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
new file mode 100644
index 0000000000000..3585db7b99baa
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
@@ -0,0 +1,87 @@
+aws_crt_cpp:
+- 0.20.3
+aws_sdk_cpp:
+- 1.10.57
+bzip2:
+- '1'
+c_compiler:
+- gcc
+c_compiler_version:
+- '10'
+cdt_name:
+- cos7
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cuda_compiler:
+- nvcc
+cuda_compiler_version:
+- '11.2'
+cuda_compiler_version_min:
+- '11.2'
+cxx_compiler:
+- gxx
+cxx_compiler_version:
+- '10'
+docker_image:
+- quay.io/condaforge/linux-anvil-cuda:11.2
+gflags:
+- '2.2'
+glog:
+- '0.6'
+google_cloud_cpp:
+- '2.12'
+libabseil:
+- '20230125'
+libgrpc:
+- '1.54'
+- '1.56'
+libprotobuf:
+- '3.21'
+- 4.23.3
+lz4_c:
+- 1.9.3
+numpy:
+- '1.21'
+- '1.23'
+- '1.21'
+- '1.21'
+openssl:
+- '3'
+orc:
+- 1.9.0
+pin_run_as_build:
+  python:
+    min_pin: x.x
+    max_pin: x.x
+python:
+- 3.10.* *_cpython
+- 3.11.* *_cpython
+- 3.8.* *_cpython
+- 3.9.* *_cpython
+re2:
+- 2023.03.02
+snappy:
+- '1'
+target_platform:
+- linux-ppc64le
+thrift_cpp:
+- 0.18.1
+ucx:
+- 1.14.0
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
+  - cuda_compiler
+  - cuda_compiler_version
+  - cdt_name
+  - docker_image
+- - libgrpc
+  - libprotobuf
+- - python
+  - numpy
+zlib:
+- '1.2'
+zstd:
+- '1.5'
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
index 83a1f7f740092..c13a522254286 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
@@ -1,27 +1,29 @@
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - gcc
 c_compiler_version:
-- '11'
+- '12'
 cdt_name:
 - cos7
 channel_sources:
 - conda-forge
 channel_targets:
 - conda-forge main
+cuda_compiler:
+- None
 cuda_compiler_version:
 - None
+cuda_compiler_version_min:
+- '11.2'
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '11'
+- '12'
 docker_image:
 - quay.io/condaforge/linux-anvil-cos7-x86_64
 gflags:
@@ -29,24 +31,26 @@ gflags:
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -57,7 +61,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -69,9 +73,12 @@ ucx:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+  - cuda_compiler
   - cuda_compiler_version
   - cdt_name
   - docker_image
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml b/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
index 0cf990cc113f2..dd4a230760ef2 100644
--- a/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
@@ -1,17 +1,15 @@
 MACOSX_DEPLOYMENT_TARGET:
 - '10.9'
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - clang
 c_compiler_version:
-- '14'
+- '15'
 channel_sources:
 - conda-forge
 channel_targets:
@@ -21,19 +19,21 @@ cuda_compiler_version:
 cxx_compiler:
 - clangxx
 cxx_compiler_version:
-- '14'
+- '15'
 gflags:
 - '2.2'
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 macos_machine:
@@ -41,12 +41,12 @@ macos_machine:
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -57,7 +57,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -67,6 +67,8 @@ thrift_cpp:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml b/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
index 3faa6278e81e2..6a6713a54fe86 100644
--- a/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
@@ -1,17 +1,15 @@
 MACOSX_DEPLOYMENT_TARGET:
 - '11.0'
 aws_crt_cpp:
-- 0.19.8
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - clang
 c_compiler_version:
-- '14'
+- '15'
 channel_sources:
 - conda-forge
 channel_targets:
@@ -21,19 +19,21 @@ cuda_compiler_version:
 cxx_compiler:
 - clangxx
 cxx_compiler_version:
-- '14'
+- '15'
 gflags:
 - '2.2'
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 macos_machine:
@@ -41,12 +41,12 @@ macos_machine:
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -57,7 +57,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -67,6 +67,8 @@ thrift_cpp:
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml
new file mode 100644
index 0000000000000..e63767cbe9771
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml
@@ -0,0 +1,27 @@
+c_compiler:
+- gcc
+c_compiler_version:
+- '12'
+cdt_name:
+- cos6
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cxx_compiler:
+- gxx
+cxx_compiler_version:
+- '12'
+docker_image:
+- quay.io/condaforge/linux-anvil-cos7-x86_64
+pin_run_as_build:
+  r-base:
+    min_pin: x.x
+    max_pin: x.x
+r_base:
+- '4.1'
+target_platform:
+- linux-64
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.2.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.2.yaml
index 38753baa7ed09..6e661e1357d22 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.2.yaml
@@ -1,7 +1,7 @@
 c_compiler:
 - gcc
 c_compiler_version:
-- '11'
+- '12'
 cdt_name:
 - cos6
 channel_sources:
@@ -11,7 +11,7 @@ channel_targets:
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '11'
+- '12'
 docker_image:
 - quay.io/condaforge/linux-anvil-cos7-x86_64
 pin_run_as_build:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml
new file mode 100644
index 0000000000000..2b80b020fdc0b
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml
@@ -0,0 +1,31 @@
+BUILD:
+- aarch64-conda_cos7-linux-gnu
+c_compiler:
+- gcc
+c_compiler_version:
+- '12'
+cdt_arch:
+- aarch64
+cdt_name:
+- cos7
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cxx_compiler:
+- gxx
+cxx_compiler_version:
+- '12'
+docker_image:
+- quay.io/condaforge/linux-anvil-cos7-x86_64
+pin_run_as_build:
+  r-base:
+    min_pin: x.x
+    max_pin: x.x
+r_base:
+- '4.1'
+target_platform:
+- linux-aarch64
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.2.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.2.yaml
index 2913bbb4f141f..9dcd0c34c851c 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.2.yaml
@@ -3,7 +3,7 @@ BUILD:
 c_compiler:
 - gcc
 c_compiler_version:
-- '11'
+- '12'
 cdt_arch:
 - aarch64
 cdt_name:
@@ -15,7 +15,7 @@ channel_targets:
 cxx_compiler:
 - gxx
 cxx_compiler_version:
-- '11'
+- '12'
 docker_image:
 - quay.io/condaforge/linux-anvil-cos7-x86_64
 pin_run_as_build:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml
new file mode 100644
index 0000000000000..6be6c2f5462c5
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml
@@ -0,0 +1,27 @@
+MACOSX_DEPLOYMENT_TARGET:
+- '10.9'
+c_compiler:
+- clang
+c_compiler_version:
+- '15'
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cxx_compiler:
+- clangxx
+cxx_compiler_version:
+- '15'
+macos_machine:
+- x86_64-apple-darwin13.4.0
+pin_run_as_build:
+  r-base:
+    min_pin: x.x
+    max_pin: x.x
+r_base:
+- '4.1'
+target_platform:
+- osx-64
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.2.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.2.yaml
index 25437ee4adcfe..2116eaf7b8b21 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.2.yaml
@@ -3,7 +3,7 @@ MACOSX_DEPLOYMENT_TARGET:
 c_compiler:
 - clang
 c_compiler_version:
-- '14'
+- '15'
 channel_sources:
 - conda-forge
 channel_targets:
@@ -11,7 +11,7 @@ channel_targets:
 cxx_compiler:
 - clangxx
 cxx_compiler_version:
-- '14'
+- '15'
 macos_machine:
 - x86_64-apple-darwin13.4.0
 pin_run_as_build:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml
new file mode 100644
index 0000000000000..0ce856fcccf5c
--- /dev/null
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml
@@ -0,0 +1,27 @@
+MACOSX_DEPLOYMENT_TARGET:
+- '11.0'
+c_compiler:
+- clang
+c_compiler_version:
+- '15'
+channel_sources:
+- conda-forge
+channel_targets:
+- conda-forge main
+cxx_compiler:
+- clangxx
+cxx_compiler_version:
+- '15'
+macos_machine:
+- arm64-apple-darwin20.0.0
+pin_run_as_build:
+  r-base:
+    min_pin: x.x
+    max_pin: x.x
+r_base:
+- '4.1'
+target_platform:
+- osx-arm64
+zip_keys:
+- - c_compiler_version
+  - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.2.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.2.yaml
index 1557b23ff96af..af8a07c42208e 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.2.yaml
@@ -3,7 +3,7 @@ MACOSX_DEPLOYMENT_TARGET:
 c_compiler:
 - clang
 c_compiler_version:
-- '14'
+- '15'
 channel_sources:
 - conda-forge
 channel_targets:
@@ -11,7 +11,7 @@ channel_targets:
 cxx_compiler:
 - clangxx
 cxx_compiler_version:
-- '14'
+- '15'
 macos_machine:
 - arm64-apple-darwin20.0.0
 pin_run_as_build:
diff --git a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version10.2.yaml b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
similarity index 78%
rename from dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version10.2.yaml
rename to dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
index 6ea00e3bd0d3f..f75d92e276d9e 100644
--- a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version10.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
@@ -1,3 +1,5 @@
+aws_crt_cpp:
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
@@ -13,9 +15,9 @@ channel_targets:
 cuda_compiler:
 - nvcc
 cuda_compiler_version:
-- '10.2'
+- '11.2'
 cuda_compiler_version_min:
-- '10.2'
+- '11.2'
 cxx_compiler:
 - vs2019
 gflags:
@@ -23,28 +25,30 @@ gflags:
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libcrc32c:
 - '1.1'
 libcurl:
-- '7'
+- '8'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -55,7 +59,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -63,6 +67,10 @@ target_platform:
 thrift_cpp:
 - 0.18.1
 zip_keys:
+- - cuda_compiler
+  - cuda_compiler_version
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
index 183356662c648..6d8fb15b15a2a 100644
--- a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
@@ -1,3 +1,5 @@
+aws_crt_cpp:
+- 0.20.3
 aws_sdk_cpp:
 - 1.10.57
 bzip2:
@@ -11,11 +13,11 @@ channel_sources:
 channel_targets:
 - conda-forge main
 cuda_compiler:
-- nvcc
+- None
 cuda_compiler_version:
 - None
 cuda_compiler_version_min:
-- '10.2'
+- '11.2'
 cxx_compiler:
 - vs2019
 gflags:
@@ -23,28 +25,30 @@ gflags:
 glog:
 - '0.6'
 google_cloud_cpp:
-- 2.8.0
+- '2.12'
 libabseil:
 - '20230125'
 libcrc32c:
 - '1.1'
 libcurl:
-- '7'
+- '8'
 libgrpc:
-- '1.52'
+- '1.54'
+- '1.56'
 libprotobuf:
 - '3.21'
+- 4.23.3
 lz4_c:
 - 1.9.3
 numpy:
 - '1.21'
 - '1.23'
-- '1.20'
-- '1.20'
+- '1.21'
+- '1.21'
 openssl:
 - '3'
 orc:
-- 1.8.3
+- 1.9.0
 pin_run_as_build:
   python:
     min_pin: x.x
@@ -55,7 +59,7 @@ python:
 - 3.8.* *_cpython
 - 3.9.* *_cpython
 re2:
-- 2023.02.02
+- 2023.03.02
 snappy:
 - '1'
 target_platform:
@@ -63,6 +67,10 @@ target_platform:
 thrift_cpp:
 - 0.18.1
 zip_keys:
+- - cuda_compiler
+  - cuda_compiler_version
+- - libgrpc
+  - libprotobuf
 - - python
   - numpy
 zlib:
diff --git a/dev/tasks/conda-recipes/arrow-cpp/activate.sh b/dev/tasks/conda-recipes/arrow-cpp/activate.sh
index 90210fac0a034..8757612781bbe 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/activate.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/activate.sh
@@ -7,24 +7,70 @@
 # doesn't come with a deactivate script, because the symlink
 # is benign and doesn't need to be deleted.
 
-# where the GDB wrappers get installed
-GDB_PREFIX=$CONDA_PREFIX/share/gdb/auto-load
+_la_log() {
+    if [ "${CF_LIBARROW_ACTIVATE_LOGGING:-}" = "1" ]; then
+        # The following loop is necessary to handle multi-line strings
+        # like for the output of `ls -al`.
+        printf '%s\n' "$*" | while IFS= read -r line
+        do
+            echo "$CONDA_PREFIX/etc/conda/activate.d/libarrow_activate.sh DEBUG: $line"
+        done
+    fi
+}
+
+_la_log "Beginning libarrow activation."
 
-# If the directory is not writable, nothing can be done
-if [ ! -w $GDB_PREFIX ]; then
-    return
-fi
+# where the GDB wrappers get installed
+_la_gdb_prefix="$CONDA_PREFIX/share/gdb/auto-load"
 
-# this needs to be in sync with the respective patch
-PLACEHOLDER=replace_this_section_with_absolute_slashed_path_to_CONDA_PREFIX
+# this needs to be in sync with ARROW_GDB_INSTALL_DIR in build.sh
+_la_placeholder="replace_this_section_with_absolute_slashed_path_to_CONDA_PREFIX"
 # the paths here are intentionally stacked, see #935, resp.
 # https://github.com/apache/arrow/blob/master/docs/source/cpp/gdb.rst#manual-loading
-WRAPPER_DIR=$GDB_PREFIX/$CONDA_PREFIX/lib
+_la_symlink_dir="$_la_gdb_prefix/$CONDA_PREFIX/lib"
+_la_orig_install_dir="$_la_gdb_prefix/$_la_placeholder/lib"
 
-mkdir -p $WRAPPER_DIR
-# there's only one lib in that folder, but the libname changes
+_la_log "          _la_gdb_prefix: $_la_gdb_prefix"
+_la_log "         _la_placeholder: $_la_placeholder"
+_la_log "         _la_symlink_dir: $_la_symlink_dir"
+_la_log "    _la_orig_install_dir: $_la_orig_install_dir"
+_la_log "  content of that folder:"
+_la_log "$(ls -al "$_la_orig_install_dir" | sed 's/^/      /')"
+
+# there's only one lib in the _la_orig_install_dir folder, but the libname changes
 # based on the version so use a loop instead of hardcoding it.
-for f in $GDB_PREFIX/$PLACEHOLDER/lib/*.py; do
-    # overwrite, because we don't have deactivation (i.e. symlink remains)
-    ln -sf $f $WRAPPER_DIR/$(basename $f)
+for _la_target in "$_la_orig_install_dir/"*.py; do
+    if [ ! -e "$_la_target" ]; then
+        # If the file doesn't exist, skip this iteration of the loop.
+        # (This happens when no files are found, in which case the
+        # loop runs with target equal to the pattern itself.)
+        _la_log 'Folder $_la_orig_install_dir seems to not contain .py files, skipping'
+        continue
+    fi
+    _la_symlink="$_la_symlink_dir/$(basename "$_la_target")"
+    _la_log "   _la_target: $_la_target"
+    _la_log "  _la_symlink: $_la_symlink"
+    if [ -L "$_la_symlink" ] && [ "$(readlink "$_la_symlink")" = "$_la_target" ]; then
+        _la_log 'symlink $_la_symlink already exists and points to $_la_target, skipping.'
+        continue
+    fi
+    _la_log 'Creating symlink $_la_symlink pointing to $_la_target'
+    mkdir -p "$_la_symlink_dir" || true
+    # this check also creates the symlink; if it fails, we enter the if-branch.
+    if ! ln -sf "$_la_target" "$_la_symlink"; then
+        echo -n "${BASH_SOURCE[0]} ERROR: Failed to create symlink from "
+        echo -n "'$_la_target' to '$_la_symlink'"
+        echo
+        continue
+    fi
 done
+
+_la_log "Libarrow activation complete."
+
+unset _la_gdb_prefix
+unset _la_log
+unset _la_orig_install_dir
+unset _la_placeholder
+unset _la_symlink
+unset _la_symlink_dir
+unset _la_target
diff --git a/dev/tasks/conda-recipes/arrow-cpp/bld-arrow.bat b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.bat
similarity index 89%
rename from dev/tasks/conda-recipes/arrow-cpp/bld-arrow.bat
rename to dev/tasks/conda-recipes/arrow-cpp/build-arrow.bat
index 60c81be741128..1268771643d4f 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/bld-arrow.bat
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.bat
@@ -1,16 +1,12 @@
 @echo on
 
-mkdir "%SRC_DIR%"\cpp\build
-pushd "%SRC_DIR%"\cpp\build
+mkdir cpp\build
+pushd cpp\build
 
 :: Enable CUDA support
 if "%cuda_compiler_version%"=="None" (
     set "EXTRA_CMAKE_ARGS=-DARROW_CUDA=OFF"
 ) else (
-    REM this should move to nvcc-feedstock
-    set "CUDA_PATH=%CUDA_PATH:\=/%"
-    set "CUDA_HOME=%CUDA_HOME:\=/%"
-
     set "EXTRA_CMAKE_ARGS=-DARROW_CUDA=ON"
 )
 
@@ -18,8 +14,9 @@ if "%cuda_compiler_version%"=="None" (
 set "READ_RECIPE_META_YAML_WHY_NOT=OFF"
 
 :: for available switches see
-:: https://github.com/apache/arrow/blame/apache-arrow-11.0.0/cpp/cmake_modules/DefineOptions.cmake
+:: https://github.com/apache/arrow/blame/apache-arrow-12.0.0/cpp/cmake_modules/DefineOptions.cmake
 cmake -G "Ninja" ^
+      -DARROW_ACERO=ON ^
       -DARROW_BOOST_USE_SHARED:BOOL=ON ^
       -DARROW_BUILD_STATIC:BOOL=OFF ^
       -DARROW_BUILD_TESTS:BOOL=OFF ^
@@ -69,3 +66,6 @@ cmake --build . --target install --config Release
 if %ERRORLEVEL% neq 0 exit 1
 
 popd
+
+:: clean up between builds (and to save space)
+rmdir /s /q cpp\build
diff --git a/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
index fb8cbade86568..dc588f9473870 100755
--- a/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
@@ -30,27 +30,21 @@ fi
 # Enable CUDA support
 if [[ ! -z "${cuda_compiler_version+x}" && "${cuda_compiler_version}" != "None" ]]
 then
-    if [[ -z "${CUDA_HOME+x}" ]]
-    then
-        echo "cuda_compiler_version=${cuda_compiler_version} CUDA_HOME=$CUDA_HOME"
-        CUDA_GDB_EXECUTABLE=$(which cuda-gdb || exit 0)
-        if [[ -n "$CUDA_GDB_EXECUTABLE" ]]
-        then
-            CUDA_HOME=$(dirname $(dirname $CUDA_GDB_EXECUTABLE))
-        else
-            echo "Cannot determine CUDA_HOME: cuda-gdb not in PATH"
-            return 1
-        fi
-    fi
-    EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=ON -DCUDA_TOOLKIT_ROOT_DIR=${CUDA_HOME} -DCMAKE_LIBRARY_PATH=${CUDA_HOME}/lib64/stubs"
+    EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=ON -DCUDA_TOOLKIT_ROOT_DIR=${CUDA_HOME} -DCMAKE_LIBRARY_PATH=${CONDA_BUILD_SYSROOT}/lib"
 else
     EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=OFF"
 fi
 
-if [[ "${target_platform}" == "osx-arm64" ]]; then
-    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DCLANG_EXECUTABLE=${BUILD_PREFIX}/bin/clang -DLLVM_LINK_EXECUTABLE=${BUILD_PREFIX}/bin/llvm-link"
+if [[ "${build_platform}" != "${target_platform}" ]]; then
+    # point to a usable protoc/grpc_cpp_plugin if we're cross-compiling
+    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DProtobuf_PROTOC_EXECUTABLE=$BUILD_PREFIX/bin/protoc"
+    if [[ ! -f ${BUILD_PREFIX}/bin/${CONDA_TOOLCHAIN_HOST}-clang ]]; then
+        ln -sf ${BUILD_PREFIX}/bin/clang ${BUILD_PREFIX}/bin/${CONDA_TOOLCHAIN_HOST}-clang
+    fi
+    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DCLANG_EXECUTABLE=${BUILD_PREFIX}/bin/${CONDA_TOOLCHAIN_HOST}-clang"
+    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DLLVM_LINK_EXECUTABLE=${BUILD_PREFIX}/bin/llvm-link"
     sed -ie "s;protoc-gen-grpc.*$;protoc-gen-grpc=${BUILD_PREFIX}/bin/grpc_cpp_plugin\";g" ../src/arrow/flight/CMakeLists.txt
-    sed -ie 's;"--with-jemalloc-prefix\=je_arrow_";"--with-jemalloc-prefix\=je_arrow_" "--with-lg-page\=14";g' ../cmake_modules/ThirdpartyToolchain.cmake
+    sed -ie 's;"--with-jemalloc-prefix\=je_arrow_";"--with-jemalloc-prefix\=je_arrow_" "--with-lg-page\=16";g' ../cmake_modules/ThirdpartyToolchain.cmake
 fi
 
 # disable -fno-plt, which causes problems with GCC on PPC
@@ -59,23 +53,19 @@ if [[ "$target_platform" == "linux-ppc64le" ]]; then
   CXXFLAGS="$(echo $CXXFLAGS | sed 's/-fno-plt //g')"
 fi
 
-# Limit number of threads used to avoid hardware oversubscription
 if [[ "${target_platform}" == "linux-aarch64" ]] || [[ "${target_platform}" == "linux-ppc64le" ]]; then
-     export CMAKE_BUILD_PARALLEL_LEVEL=3
-fi
-
-# point to a usable protoc if we're running on a different architecture than the target
-if [[ "${build_platform}" != "${target_platform}" ]]; then
-    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DProtobuf_PROTOC_EXECUTABLE=$BUILD_PREFIX/bin/protoc"
+    # Limit number of threads used to avoid hardware oversubscription
+    export CMAKE_BUILD_PARALLEL_LEVEL=3
 fi
 
 # reusable variable for dependencies we cannot yet unvendor
 export READ_RECIPE_META_YAML_WHY_NOT=OFF
 
 # for available switches see
-# https://github.com/apache/arrow/blame/apache-arrow-11.0.0/cpp/cmake_modules/DefineOptions.cmake
-# placeholder in ARROW_GDB_INSTALL_DIR must match what's used for replacement in activate.sh
+# https://github.com/apache/arrow/blame/apache-arrow-12.0.0/cpp/cmake_modules/DefineOptions.cmake
+# placeholder in ARROW_GDB_INSTALL_DIR must match _la_placeholder in activate.sh
 cmake -GNinja \
+    -DARROW_ACERO=ON \
     -DARROW_BOOST_USE_SHARED=ON \
     -DARROW_BUILD_BENCHMARKS=OFF \
     -DARROW_BUILD_STATIC=OFF \
@@ -129,3 +119,6 @@ cmake -GNinja \
 cmake --build . --target install --config Release
 
 popd
+
+# clean up between builds (and to save space)
+rm -rf cpp/build
diff --git a/dev/tasks/conda-recipes/arrow-cpp/bld-pyarrow.bat b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.bat
similarity index 54%
rename from dev/tasks/conda-recipes/arrow-cpp/bld-pyarrow.bat
rename to dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.bat
index 084faf74e4a10..e3eaa32bcf848 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/bld-pyarrow.bat
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.bat
@@ -2,22 +2,10 @@
 
 pushd "%SRC_DIR%"\python
 
-@rem the symlinks for cmake modules don't work here
-@rem NOTE: In contrast to conda-forge, they work here as we clone from git.
-@rem del cmake_modules\BuildUtils.cmake
-@rem del cmake_modules\SetupCxxFlags.cmake
-@rem del cmake_modules\CompilerInfo.cmake
-@rem del cmake_modules\FindNumPy.cmake
-@rem del cmake_modules\FindPythonLibsNew.cmake
-@rem copy /Y "%SRC_DIR%\cpp\cmake_modules\BuildUtils.cmake" cmake_modules\
-@rem copy /Y "%SRC_DIR%\cpp\cmake_modules\SetupCxxFlags.cmake" cmake_modules\
-@rem copy /Y "%SRC_DIR%\cpp\cmake_modules\CompilerInfo.cmake" cmake_modules\
-@rem copy /Y "%SRC_DIR%\cpp\cmake_modules\FindNumPy.cmake" cmake_modules\
-@rem copy /Y "%SRC_DIR%\cpp\cmake_modules\FindPythonLibsNew.cmake" cmake_modules\
-
 SET ARROW_HOME=%LIBRARY_PREFIX%
 SET SETUPTOOLS_SCM_PRETEND_VERSION=%PKG_VERSION%
 SET PYARROW_BUILD_TYPE=release
+SET PYARROW_WITH_ACERO=1
 SET PYARROW_WITH_DATASET=1
 SET PYARROW_WITH_FLIGHT=1
 SET PYARROW_WITH_GANDIVA=1
diff --git a/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
index 14c67ede6324e..9c12321a1c115 100755
--- a/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
@@ -6,6 +6,7 @@ export ARROW_HOME=$PREFIX
 export PARQUET_HOME=$PREFIX
 export SETUPTOOLS_SCM_PRETEND_VERSION=$PKG_VERSION
 export PYARROW_BUILD_TYPE=release
+export PYARROW_WITH_ACERO=1
 export PYARROW_WITH_DATASET=1
 export PYARROW_WITH_FLIGHT=1
 export PYARROW_WITH_GANDIVA=1
@@ -37,9 +38,9 @@ if [[ "${target_platform}" == osx-* ]]; then
     CXXFLAGS="${CXXFLAGS} -D_LIBCPP_DISABLE_AVAILABILITY"
 fi
 
-# Limit number of threads used to avoid hardware oversubscription
 if [[ "${target_platform}" == "linux-aarch64" ]] || [[ "${target_platform}" == "linux-ppc64le" ]]; then
-     export CMAKE_BUILD_PARALLEL_LEVEL=4
+    # Limit number of threads used to avoid hardware oversubscription
+    export CMAKE_BUILD_PARALLEL_LEVEL=4
 fi
 
 cd python
diff --git a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
index 2f79bbe958c07..e61034c3075b3 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
+++ b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
@@ -4,7 +4,7 @@
 {% set build_ext_version = ARROW_VERSION %}
 {% set build_ext = "cuda" if cuda_enabled else "cpu" %}
 {% set proc_build_number = "0" %}
-{% set llvm_version = "14" %}
+{% set llvm_version = "15" %}
 
 # see https://github.com/apache/arrow/blob/apache-arrow-10.0.1/cpp/CMakeLists.txt#L88-L90
 {% set so_version = (version.split(".")[0] | int * 100 + version.split(".")[1] | int) ~ "." ~ version.split(".")[2] ~ ".0" %}
@@ -21,11 +21,9 @@ build:
   # for cuda support, building with one version is enough to be compatible with
   # all later versions, since arrow is only using libcuda, and not libcudart.
   skip: true  # [cuda_compiler_version not in ("None", cuda_compiler_version_min)]
-  # temporary: skip CUDA on aarch/ppc until cross-compilation works, see
-  # https://github.com/conda-forge/conda-forge-ci-setup-feedstock/pull/210
-  skip: true  # [(aarch64 or ppc64le) and (cuda_compiler_version != "None")]
+  # arrow promises API- & ABI-compatibility along SemVer, see #1096
   run_exports:
-    - {{ pin_subpackage("libarrow", max_pin="x.x.x") }}
+    - {{ pin_subpackage("libarrow", max_pin="x") }}
 
 outputs:
   - name: apache-arrow-proc
@@ -57,30 +55,38 @@ outputs:
         - exit 0
 
   - name: libarrow
-    script: build-arrow.sh  # [not win]
-    script: bld-arrow.bat   # [win]
+    script: build-arrow.sh   # [unix]
+    script: build-arrow.bat  # [win]
     version: {{ version }}
     build:
       string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
       run_exports:
         - {{ pin_subpackage("libarrow", max_pin="x.x.x") }}
+      ignore_run_exports_from:
+        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
+        # arrow only uses headers, apparently
+        - gflags
+        # shared lib linked on unix, not on win
+        - glog                                   # [win]
       ignore_run_exports:
-        - cudatoolkit
+        # we don't need all of brotli's run-exports
+        - libbrotlicommon
       track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
       missing_dso_whitelist:
-        - "*/libcuda.so.*"    # [linux]
-        - "*/nvcuda.dll"      # [win]
+        - '*/libcuda.so.*'    # [linux]
+        - '*/nvcuda.dll'      # [win]
     requirements:
       build:
         - {{ compiler("c") }}
         - {{ compiler("cxx") }}
         - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
-        - clangdev {{ llvm_version }}            # [osx and arm64]
-        - llvmdev {{ llvm_version }}             # [osx and arm64]
-        - gnuconfig                              # [osx and arm64]
         # needs to run protoc & grpc_cpp_plugin
         - libgrpc                                # [build_platform != target_platform]
         - libprotobuf                            # [build_platform != target_platform]
+        # needed for gandiva
+        - clangdev {{ llvm_version }}            # [build_platform != target_platform]
+        - llvmdev {{ llvm_version }}             # [build_platform != target_platform]
+        - gnuconfig                              # [build_platform != target_platform]
         - cmake
         - ninja
         # necessary for vendored jemalloc
@@ -91,12 +97,11 @@ outputs:
         # https://github.com/apache/arrow/blob/apache-arrow-11.0.0/cpp/cmake_modules/ThirdpartyToolchain.cmake#L46-L75
         - clangdev {{ llvm_version }}
         - llvmdev {{ llvm_version }}
-        - aws-crt-cpp  # [unix]
+        - aws-crt-cpp
         - aws-sdk-cpp
         - boost-cpp >=1.70
         - brotli
         - bzip2
-        - c-ares
         # not yet: https://github.com/conda-forge/cpp-opentelemetry-sdk-feedstock/issues/38
         # - cpp-opentelemetry-sdk
         # - proto-opentelemetry-proto =={{ cpp_opentelemetry_sdk }}
@@ -106,11 +111,6 @@ outputs:
         # arrow uses a customized jemalloc, see #944
         # - jemalloc
         - libabseil
-        # since libgoogle-cloud is static on windows, see
-        # https://github.com/conda-forge/google-cloud-cpp-feedstock/pull/108,
-        # its dependencies leak into the build here
-        - libcrc32c  # [win]
-        - libcurl    # [win]
         - libgrpc
         - libprotobuf
         - libutf8proc
@@ -127,17 +127,26 @@ outputs:
         - xsimd
         - zlib
         - zstd
+        - __cuda >={{ cuda_compiler_version_min }}  # [cuda_compiler_version != "None"]
+        # since libgoogle-cloud is static on windows, see
+        # https://github.com/conda-forge/google-cloud-cpp-feedstock/pull/108,
+        # its host deps (which aren't yet covered above) leak into the build here
+        - libcrc32c  # [win]
+        - libcurl    # [win]
+        # same for libgrpc (before 1.55.0, which is coupled with libprotobuf 4.23.x)
+        - c-ares     # [win and libprotobuf == "3.21"]
       run_constrained:
         - apache-arrow-proc =*={{ build_ext }}
-        - cudatoolkit >={{ cuda_compiler_version_min }}  # [cuda_compiler_version != "None"]
         # make sure we don't co-install with old version of old package name
         - arrow-cpp ={{ version }}
+        # old parquet lib output, now part of this feedstock
+        - parquet-cpp <0.0a0
 
     test:
       commands:
         {% set headers = [
-            "arrow/api.h", "arrow/flight/types.h", "arrow/flight/sql/api.h",
-            "gandiva/engine.h", "parquet/api/reader.h"
+            "arrow/api.h", "arrow/acero/api.h", "arrow/flight/types.h",
+            "arrow/flight/sql/api.h", "gandiva/engine.h", "parquet/api/reader.h"
         ] %}
         {% for each_header in headers %}
         # headers
@@ -146,8 +155,8 @@ outputs:
         {% endfor %}
 
         {% set libs = (cuda_compiler_version != "None") * ["arrow_cuda"] + [
-            "arrow", "arrow_dataset", "arrow_flight", "arrow_flight_sql",
-            "arrow_substrait", "gandiva", "parquet"
+            "arrow", "arrow_acero", "arrow_dataset", "arrow_flight",
+            "arrow_flight_sql", "arrow_substrait", "gandiva", "parquet"
         ] %}
         {% for each_lib in libs %}
         # shared
@@ -189,6 +198,8 @@ outputs:
     requirements:
       host:
         - {{ pin_subpackage('libarrow', exact=True) }}
+        # avoid wrappers for different builds colliding due to identical hashes
+        - libprotobuf
       run:
         - {{ pin_subpackage('libarrow', exact=True) }}
     test:
@@ -196,21 +207,21 @@ outputs:
         - exit 0
 
   - name: pyarrow
-    script: build-pyarrow.sh  # [not win]
-    script: bld-pyarrow.bat   # [win]
+    script: build-pyarrow.sh   # [unix]
+    script: build-pyarrow.bat  # [win]
     version: {{ version }}
     build:
       string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
-      ignore_run_exports:
-        - cudatoolkit
+      ignore_run_exports_from:
+        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
       track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
       rpaths:
         - lib/
         - {{ SP_DIR }}/pyarrow
       missing_dso_whitelist:
         # not actually missing, but installed into SP_DIR, see tests
-        - "*/arrow_python.dll"                # [win]
-        - "*/arrow_python_flight.dll"         # [win]
+        - '*/arrow_python.dll'                # [win]
+        - '*/arrow_python_flight.dll'         # [win]
     requirements:
       build:
         - {{ compiler("c") }}
@@ -219,29 +230,28 @@ outputs:
         - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
         - python                                 # [build_platform != target_platform]
         - cross-python_{{ target_platform }}     # [build_platform != target_platform]
-        - cython                                 # [build_platform != target_platform]
+        - cython <3                              # [build_platform != target_platform]
         - numpy                                  # [build_platform != target_platform]
         - cmake
         - ninja
       host:
-        - {{ pin_subpackage('libarrow', exact=True) }}
+        # we're building for two protobuf versions, cannot pin exactly
+        # - {{ pin_subpackage('libarrow', exact=True) }}
+        - libarrow ={{ version }}=*_{{ PKG_BUILDNUM }}_{{ build_ext }}
         - clangdev {{ llvm_version }}
         - llvmdev {{ llvm_version }}
-        - cython
-        - gflags  # [unix]
+        - cython <3
         - numpy
         - python
         - setuptools
         - setuptools_scm
       run:
-        - {{ pin_subpackage('libarrow', exact=True) }}
+        # - {{ pin_subpackage('libarrow', exact=True) }}
+        - libarrow ={{ version }}=*_{{ PKG_BUILDNUM }}_{{ build_ext }}
         - {{ pin_compatible('numpy') }}
-        # empty parquet-cpp metapackage, force old versions to be uninstalled
-        - parquet-cpp 1.5.1.*
         - python
       run_constrained:
         - apache-arrow-proc =*={{ build_ext }}
-        - cudatoolkit >={{ cuda_compiler_version_min }}  # [cuda_compiler_version != "None"]
 
     test:
       files:
@@ -288,13 +298,13 @@ outputs:
       summary: Python libraries for Apache Arrow
 
   - name: pyarrow-tests
-    script: build-pyarrow.sh  # [not win]
-    script: bld-pyarrow.bat   # [win]
+    script: build-pyarrow.sh   # [unix]
+    script: build-pyarrow.bat  # [win]
     version: {{ version }}
     build:
       string: py{{ CONDA_PY }}h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
-      ignore_run_exports:
-        - cudatoolkit
+      ignore_run_exports_from:
+        - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
       track_features: {{ "[arrow-cuda]" if cuda_enabled else "" }}
     requirements:
       build:
@@ -304,7 +314,7 @@ outputs:
         - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
         - python                                 # [build_platform != target_platform]
         - cross-python_{{ target_platform }}     # [build_platform != target_platform]
-        - cython                                 # [build_platform != target_platform]
+        - cython <3                              # [build_platform != target_platform]
         - numpy                                  # [build_platform != target_platform]
         - cmake
         - ninja
@@ -313,7 +323,7 @@ outputs:
         - {{ pin_subpackage('pyarrow', exact=True) }}
         - clangdev {{ llvm_version }}
         - llvmdev {{ llvm_version }}
-        - cython
+        - cython <3
         - numpy
         - python
         - setuptools
@@ -323,27 +333,36 @@ outputs:
         - python
       run_constrained:
         - apache-arrow-proc =*={{ build_ext }}
-        - cudatoolkit >={{ cuda_compiler_version_min }}  # [cuda_compiler_version != "None"]
 
+    # crossbow CI: reduce to one python version, except on (unemulated) linux, where it's fast enough
+    {% if linux64 or py == 311 %}
+    # {% if not (aarch64 or ppc64le) or py in (310, 311) %}
+    # only run the full test suite for one python version when in emulation (each run takes ~45min);
+    # there's essentially zero divergence in behaviour across python versions anyway, and otherwise
+    # CUDA builds for aarch/ppc consistently run out of disk space on azure for some reason
     test:
       requires:
+        # vary protobuf version in test suite (historically, test failures only have a very
+        # weak dependency on python version, so we don't lose coverage by doing half & half)
+        - libprotobuf <4         # [py % 2 == 0]
         # test_cpp_extension_in_python requires a compiler
         - {{ compiler("cxx") }}  # [linux]
-        - pytest
+        # temporary pin due to missing fixture
+        - pytest <7.4.0
         - pytest-lazy-fixture
         - backports.zoneinfo     # [py<39]
         - cffi
         - cloudpickle
-        - cython
+        - cython <3
         - fastparquet
         - fsspec
         - hypothesis
         - pandas
         - scipy
-        # not all OSes/arches available in conda-forge
-        - pytorch *           # [unix and not ppc64le]
-        # not yet rebuilt for libabseil 20230125
-        # - tensorflow          # [unix and x86_64 and py<311]
+        # these are generally (far) behind on migrating abseil/grpc/protobuf,
+        # and using them as test dependencies blocks the migrator unnecessarily
+        # - pytorch
+        # - tensorflow
         # we're not building java bindings
         # - jpype1
         # doesn't get picked up correctly
@@ -364,6 +383,8 @@ outputs:
         # skip tests that raise SIGINT and crash the test suite
         {% set tests_to_skip = tests_to_skip + " or (test_csv and test_cancellation)" %}  # [linux]
         {% set tests_to_skip = tests_to_skip + " or (test_flight and test_interrupt)" %}  # [linux]
+        # tests that may crash the agent due to out-of-bound memory writes or other risky stuff
+        {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool" %}            # [aarch64 or ppc64le]
         # cannot pass -D_LIBCPP_DISABLE_AVAILABILITY to test suite for our older macos sdk
         {% set tests_to_skip = tests_to_skip + " or test_cpp_extension_in_python" %}      # [osx]
         # skip tests that make invalid(-for-conda) assumptions about the compilers setup
@@ -373,6 +394,7 @@ outputs:
         {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool_disabled" %}   # [aarch64 or ppc64le]
         {% set tests_to_skip = tests_to_skip + " or test_env_var_io_thread_count" %}      # [aarch64 or ppc64le]
         # vvvvvvv TESTS THAT SHOULDN'T HAVE TO BE SKIPPED vvvvvvv
+        {% set tests_to_skip = tests_to_skip + " or test_extension_to_pandas_storage_type" %}
         # segfaults on OSX: to investigate ASAP
         {% set tests_to_skip = tests_to_skip + " or test_flight" %}                       # [osx]
         # gandiva tests are segfaulting on ppc
@@ -385,10 +407,12 @@ outputs:
         {% set tests_to_skip = tests_to_skip + " or (test_memory and test_env_var)" %}    # [unix]
         # test is broken; header is in $PREFIX, not $SP_DIR
         {% set tests_to_skip = tests_to_skip + " or (test_misc and test_get_include)" %}  # [unix]
+        # flaky tests that fail occasionally
+        {% set tests_to_skip = tests_to_skip + " or test_total_bytes_allocated " %}       # [linux]
+        {% set tests_to_skip = tests_to_skip + " or test_feather_format " %}              # [linux]
         # ^^^^^^^ TESTS THAT SHOULDN'T HAVE TO BE SKIPPED ^^^^^^^
-
-        # crossbow CI: reduce to one python version, except on (unemulated) linux, where it's fast enough
-        - pytest -v -rfEs -k "not ({{ tests_to_skip }})"  # [linux64 or (py==310 and build_platform==target_platform)]
+        - pytest -rfEs -k "not ({{ tests_to_skip }})"
+    {% endif %}
 
     about:
       home: http://github.com/apache/arrow
diff --git a/dev/tasks/conda-recipes/azure.linux.yml b/dev/tasks/conda-recipes/azure.linux.yml
index b9a54647cc525..279ffb48ccd60 100755
--- a/dev/tasks/conda-recipes/azure.linux.yml
+++ b/dev/tasks/conda-recipes/azure.linux.yml
@@ -13,6 +13,29 @@ jobs:
     UPLOAD_PACKAGES: False
 
   steps:
+  - script: |
+         sudo mkdir -p /opt/empty_dir || true
+         for d in \
+                  /opt/ghc \
+                  /opt/hostedtoolcache \
+                  /usr/lib/jvm \
+                  /usr/local/.ghcup \
+                  /usr/local/lib/android \
+                  /usr/local/share/powershell \
+                  /usr/share/dotnet \
+                  /usr/share/swift \
+                  ; do
+           sudo rsync --stats -a --delete /opt/empty_dir/ $d || true
+         done
+         sudo apt-get purge -y -f firefox \
+                                  google-chrome-stable \
+                                  microsoft-edge-stable
+         sudo apt-get autoremove -y >& /dev/null
+         sudo apt-get autoclean -y >& /dev/null
+         sudo docker image prune --all --force
+         df -h
+    displayName: Manage disk space
+
   # configure qemu binfmt-misc running.  This allows us to run docker containers
   # embedded qemu-static
   - script: |
diff --git a/dev/tasks/conda-recipes/r-arrow/configure.win b/dev/tasks/conda-recipes/r-arrow/configure.win
index fb16a810b8f22..0fc96576bde74 100755
--- a/dev/tasks/conda-recipes/r-arrow/configure.win
+++ b/dev/tasks/conda-recipes/r-arrow/configure.win
@@ -2,7 +2,7 @@
 
 set -euxo pipefail
 
-echo "PKG_CPPFLAGS=-DNDEBUG -I\"${LIBRARY_PREFIX}/include\" -I\"${PREFIX}/include\" -DARROW_R_WITH_PARQUET -DARROW_R_WITH_DATASET -DARROW_R_WITH_S3 -DARROW_R_WITH_JSON" > src/Makevars.win
+echo "PKG_CPPFLAGS=-DNDEBUG -I\"${LIBRARY_PREFIX}/include\" -I\"${PREFIX}/include\" -DARROW_R_WITH_ACERO -DARROW_R_WITH_PARQUET -DARROW_R_WITH_DATASET -DARROW_R_WITH_S3 -DARROW_R_WITH_JSON" > src/Makevars.win
 echo "PKG_CXXFLAGS=\$(CXX_VISIBILITY)" >> src/Makevars.win
 echo 'CXX_STD=CXX17' >> src/Makevars.win
-echo "PKG_LIBS=-L\"${LIBRARY_PREFIX}/lib\" -larrow_dataset -lparquet -larrow" >> src/Makevars.win
+echo "PKG_LIBS=-L\"${LIBRARY_PREFIX}/lib\" -larrow_dataset -larrow_acero -lparquet -larrow" >> src/Makevars.win
diff --git a/dev/tasks/conda-recipes/r-arrow/meta.yaml b/dev/tasks/conda-recipes/r-arrow/meta.yaml
index 28ee8eb92c921..e8b834254f41c 100644
--- a/dev/tasks/conda-recipes/r-arrow/meta.yaml
+++ b/dev/tasks/conda-recipes/r-arrow/meta.yaml
@@ -10,8 +10,6 @@ source:
   path: ../../../../
 
 build:
-  # 4.1 not usable anymore unless https://github.com/conda-forge/r-base-feedstock/pull/236 gets merged
-  skip: true  # [unix and (r_base == "4.1")]
   merge_build_host: true  # [win]
   number: 0
   rpaths:
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index cca770438574a..05dafade97434 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -246,6 +246,16 @@ tasks:
   #   generated and to be synced regularly from the feedstock. We have no way
   #   yet to generate them inside the arrow repository automatically.
 
+  conda-linux-x64-cpu-r41:
+    ci: azure
+    template: conda-recipes/azure.linux.yml
+    params:
+      config: linux_64_cuda_compiler_versionNone
+      r_config: linux_64_r_base4.1
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
+      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+
   conda-linux-x64-cpu-r42:
     ci: azure
     template: conda-recipes/azure.linux.yml
@@ -272,7 +282,7 @@ tasks:
     ci: azure
     template: conda-recipes/azure.linux.yml
     params:
-      config: linux_64_cuda_compiler_version10.2
+      config: linux_64_cuda_compiler_version11.2
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cuda.conda
       - pyarrow-{no_rc_version}-py38(h[a-z0-9]+)_0_cuda.conda
@@ -282,6 +292,16 @@ tasks:
 
   ########################### Conda Linux (aarch64) ###########################
 
+  conda-linux-aarch64-cpu-r41:
+    ci: azure
+    template: conda-recipes/azure.linux.yml
+    params:
+      config: linux_aarch64_cuda_compiler_versionNone
+      r_config: linux_aarch64_r_base4.1
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
+      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+
   conda-linux-aarch64-cpu-r42:
     ci: azure
     template: conda-recipes/azure.linux.yml
@@ -304,6 +324,18 @@ tasks:
       - pyarrow-{no_rc_version}-py310(h[a-z0-9]+)_0_cpu.conda
       - pyarrow-{no_rc_version}-py311(h[a-z0-9]+)_0_cpu.conda
 
+  conda-linux-aarch64-cuda-py3:
+    ci: azure
+    template: conda-recipes/azure.linux.yml
+    params:
+      config: linux_aarch64_cuda_compiler_version11.2
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py38(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py39(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py310(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py311(h[a-z0-9]+)_0_cuda.conda
+
   ########################### Conda Linux (ppc64le) ###########################
 
   conda-linux-ppc64le-cpu-py3:
@@ -318,8 +350,30 @@ tasks:
       - pyarrow-{no_rc_version}-py310(h[a-z0-9]+)_0_cpu.conda
       - pyarrow-{no_rc_version}-py311(h[a-z0-9]+)_0_cpu.conda
 
+  conda-linux-ppc64le-cuda-py3:
+    ci: azure
+    template: conda-recipes/azure.linux.yml
+    params:
+      config: linux_ppc64le_cuda_compiler_version11.2
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py38(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py39(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py310(h[a-z0-9]+)_0_cuda.conda
+      - pyarrow-{no_rc_version}-py311(h[a-z0-9]+)_0_cuda.conda
+
   ############################## Conda OSX (x64) ##############################
 
+  conda-osx-x64-cpu-r41:
+    ci: azure
+    template: conda-recipes/azure.osx.yml
+    params:
+      config: osx_64_
+      r_config: osx_64_r_base4.1
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
+      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+
   conda-osx-x64-cpu-r42:
     ci: azure
     template: conda-recipes/azure.osx.yml
@@ -344,6 +398,16 @@ tasks:
 
   ############################# Conda OSX (arm64) #############################
 
+  conda-osx-arm64-cpu-r41:
+    ci: azure
+    template: conda-recipes/azure.osx.yml
+    params:
+      config: osx_arm64_
+      r_config: osx_arm64_r_base4.1
+    artifacts:
+      - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
+      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+
   conda-osx-arm64-cpu-r42:
     ci: azure
     template: conda-recipes/azure.osx.yml
@@ -396,7 +460,7 @@ tasks:
     ci: azure
     template: conda-recipes/azure.win.yml
     params:
-      config: win_64_cuda_compiler_versionNone
+      config: win_64_cuda_compiler_version11.2
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cuda.conda
       - pyarrow-{no_rc_version}-py38(h[a-z0-9]+)_0_cuda.conda

From 9fe23dac68504ae99b0bf182a412c776fce227cb Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 26 Jul 2023 10:50:54 -0400
Subject: [PATCH 052/749] GH-36853: [MATLAB] Add utility to create proxies from
 existing `arrow::DataType` objects (#36873)

### Rationale for this change

There will be many places in the MATLAB interface code base in which we will have to wrap an `arrow::DataType` object within a subclass of `arrow::matlab::type::proxy::Type`. To avoid code duplicaiton, we should add a  utility function called `wrap` that accepts a pointer to an `arrow::DataType` object and returns a pointer to a  `arrow::matlab::type::proxy::Type` object.

### What changes are included in this PR?

1. Added a new function with the following signature:

```cpp
arrow::Result<std::shared_ptr<arrow::matlab::type::proxy::Type>> wrap(const std::shared_ptr<arrow::DataType>& datatype);
```

2.  Updated the `type` methods of `arrow::matlab::type::proxy::Field` and `arrow::matlab::array::proxy::Array` to use `wrap`.

### Are these changes tested?

No new tests needed.

### Are there any user-facing changes?

No

* Closes: #36853

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc | 11 ++--
 .../src/cpp/arrow/matlab/array/proxy/array.h  |  2 -
 .../arrow/matlab/array/proxy/boolean_array.cc |  7 ---
 .../arrow/matlab/array/proxy/boolean_array.h  |  3 -
 .../arrow/matlab/array/proxy/numeric_array.h  |  6 --
 .../arrow/matlab/array/proxy/string_array.cc  |  8 ---
 .../arrow/matlab/array/proxy/string_array.h   |  3 -
 matlab/src/cpp/arrow/matlab/error/error.h     |  1 +
 .../src/cpp/arrow/matlab/type/proxy/field.cc  | 41 +------------
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   | 59 +++++++++++++++++++
 matlab/src/cpp/arrow/matlab/type/proxy/wrap.h | 28 +++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |  4 +-
 12 files changed, 101 insertions(+), 72 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/wrap.h

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index c2d0330b5f78e..8520cf1f21fdd 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -20,8 +20,8 @@
 #include "arrow/matlab/array/proxy/array.h"
 #include "arrow/matlab/bit/unpack.h"
 #include "arrow/matlab/error/error.h"
+#include "arrow/matlab/type/proxy/wrap.h"
 #include "arrow/type_traits.h"
-#include "arrow/visit_array_inline.h"
 
 #include "libmexclass/proxy/ProxyManager.h"
 
@@ -80,12 +80,15 @@ namespace arrow::matlab::array::proxy {
 
         mda::ArrayFactory factory;
 
-        auto type_proxy = typeProxy();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto type_proxy,
+                                            type::proxy::wrap(array->type()),
+                                            context,
+                                            error::ARRAY_FAILED_TO_CREATE_TYPE_PROXY);
+
         auto type_id = type_proxy->unwrap()->id();
         auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(type_proxy);
 
         context.outputs[0] = factory.createScalar(proxy_id);
         context.outputs[1] = factory.createScalar(static_cast<int64_t>(type_id));
-
     }
-}
\ No newline at end of file
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index 55d48c26eff6f..90199767258e2 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -44,8 +44,6 @@ class Array : public libmexclass::proxy::Proxy {
 
         virtual void toMATLAB(libmexclass::proxy::method::Context& context) = 0;
 
-        virtual std::shared_ptr<type::proxy::Type> typeProxy() = 0;
-
         std::shared_ptr<arrow::Array> array;
 };
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
index 281a0f732d73a..5be0cfb5a3d13 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
@@ -54,11 +54,4 @@ namespace arrow::matlab::array::proxy {
             auto logical_array_mda = bit::unpack(packed_logical_data_buffer, array_length);
             context.outputs[0] = logical_array_mda;
         }
-
-        std::shared_ptr<type::proxy::Type> BooleanArray::typeProxy() {
-            using BooleanTypeProxy = type::proxy::PrimitiveCType<bool>;
-
-            auto type = std::static_pointer_cast<arrow::BooleanType>(array->type());
-            return std::make_shared<BooleanTypeProxy>(std::move(type));
-        }
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
index 5e6e51f0bc8ff..775673c29eada 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
@@ -32,9 +32,6 @@ namespace arrow::matlab::array::proxy {
 
         protected:
             void toMATLAB(libmexclass::proxy::method::Context& context) override;
-
-            std::shared_ptr<type::proxy::Type> typeProxy() override;
-
     };
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index f358e05db6318..6893079c78b95 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -85,12 +85,6 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
             ::matlab::data::TypedArray<CType> result = factory.createArray({num_elements, 1}, data_begin, data_end);
             context.outputs[0] = result;
         }
-
-        std::shared_ptr<type::proxy::Type> typeProxy() override {
-          using TypeProxy = typename type::proxy::Traits<ArrowType>::TypeProxy;
-          auto type = std::static_pointer_cast<ArrowType>(array->type());
-          return std::make_shared<TypeProxy>(std::move(type));
-        }
 };
 
      // Specialization of NumericArray::Make for arrow::TimestampType.
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
index 16331f6195a22..c583e8851a3ac 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
@@ -81,12 +81,4 @@ namespace arrow::matlab::array::proxy {
             auto array_mda = factory.createArray({array_length, 1}, strings.begin(), strings.end());
             context.outputs[0] = array_mda;
         }
-
-        std::shared_ptr<type::proxy::Type> StringArray::typeProxy() {
-            using StringTypeProxy = type::proxy::StringType;
-
-            auto type = std::static_pointer_cast<arrow::StringType>(array->type());
-            return std::make_shared<StringTypeProxy>(std::move(type));
-        }
-
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
index abb2322edbd20..bdcfedd7cdda3 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
@@ -33,9 +33,6 @@ namespace arrow::matlab::array::proxy {
 
         protected:
             void toMATLAB(libmexclass::proxy::method::Context& context) override;
-
-            std::shared_ptr<type::proxy::Type> typeProxy() override;
-
     };
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index b253e6c20ed27..3d134d169e7af 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -172,4 +172,5 @@ namespace arrow::matlab::error {
     static const char* STRING_BUILDER_FINISH_FAILED = "arrow:matlab:array:string:StringBuilderFinishFailed";
     static const char* UKNOWN_TIME_UNIT_ERROR_ID = "arrow:matlab:UnknownTimeUnit";
     static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
+    static const char* ARRAY_FAILED_TO_CREATE_TYPE_PROXY = "arrow:array:FailedToCreateTypeProxy";
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
index 4a43d813f0567..0cf7c995fb275 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
@@ -23,6 +23,7 @@
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
+#include "arrow/matlab/type/proxy/wrap.h"
 
 #include "libmexclass/proxy/ProxyManager.h"
 
@@ -48,47 +49,11 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = str_mda;
     }
 
-    arrow::Result<std::shared_ptr<libmexclass::proxy::Proxy>> makeTypeProxy(const std::shared_ptr<arrow::DataType>& datatype) {
-        using arrow_type = arrow::Type::type;
-        namespace type_proxy = arrow::matlab::type::proxy;
-        switch (datatype->id()) {
-            case arrow_type::UINT8:
-                return std::make_shared<type_proxy::PrimitiveCType<uint8_t>>(std::static_pointer_cast<arrow::UInt8Type>(datatype));
-            case arrow_type::UINT16:
-                return std::make_shared<type_proxy::PrimitiveCType<uint16_t>>(std::static_pointer_cast<arrow::UInt16Type>(datatype));
-            case arrow_type::UINT32:
-                return std::make_shared<type_proxy::PrimitiveCType<uint32_t>>(std::static_pointer_cast<arrow::UInt32Type>(datatype));
-            case arrow_type::UINT64:
-                return std::make_shared<type_proxy::PrimitiveCType<uint64_t>>(std::static_pointer_cast<arrow::UInt64Type>(datatype));
-            case arrow_type::INT8:
-                return std::make_shared<type_proxy::PrimitiveCType<int8_t>>(std::static_pointer_cast<arrow::Int8Type>(datatype));
-            case arrow_type::INT16:
-                return std::make_shared<type_proxy::PrimitiveCType<int16_t>>(std::static_pointer_cast<arrow::Int16Type>(datatype));
-            case arrow_type::INT32:
-                return std::make_shared<type_proxy::PrimitiveCType<int32_t>>(std::static_pointer_cast<arrow::Int32Type>(datatype));
-            case arrow_type::INT64:
-                return std::make_shared<type_proxy::PrimitiveCType<int64_t>>(std::static_pointer_cast<arrow::Int64Type>(datatype));
-            case arrow_type::FLOAT:
-                return std::make_shared<type_proxy::PrimitiveCType<float>>(std::static_pointer_cast<arrow::FloatType>(datatype));
-            case arrow_type::DOUBLE:
-                return std::make_shared<type_proxy::PrimitiveCType<double>>(std::static_pointer_cast<arrow::DoubleType>(datatype));
-            case arrow_type::BOOL:
-                return std::make_shared<type_proxy::PrimitiveCType<bool>>(std::static_pointer_cast<arrow::BooleanType>(datatype));
-            case arrow_type::STRING:
-                return std::make_shared<type_proxy::StringType>(std::static_pointer_cast<arrow::StringType>(datatype));
-            case arrow_type::TIMESTAMP:
-                return std::make_shared<type_proxy::TimestampType>(std::static_pointer_cast<arrow::TimestampType>(datatype));
-            default:
-                return arrow::Status::NotImplemented("Unsupported DataType: " + datatype->ToString());
-        }
-    }
-
-
     void Field::type(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
 
-        auto datatype = field->type();
-        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto proxy, makeTypeProxy(datatype), context, "arrow:field:FailedToCreateTypeProxy");
+        const auto& datatype = field->type();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto proxy, type::proxy::wrap(datatype), context, error::FIELD_FAILED_TO_CREATE_TYPE_PROXY); 
         const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(proxy);
 
         mda::ArrayFactory factory;
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
new file mode 100644
index 0000000000000..b01148fe1c0a9
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/wrap.h"
+
+#include "arrow/matlab/type/proxy/primitive_ctype.h"
+#include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/string_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    arrow::Result<std::shared_ptr<type::proxy::Type>> wrap(const std::shared_ptr<arrow::DataType>& type) {
+        using ID = arrow::Type::type;
+        switch (type->id()) {
+            case ID::BOOL:
+                return std::make_shared<PrimitiveCType<bool>>(std::static_pointer_cast<arrow::BooleanType>(type));
+            case ID::UINT8:
+                return std::make_shared<PrimitiveCType<uint8_t>>(std::static_pointer_cast<arrow::UInt8Type>(type));
+            case ID::UINT16:
+                return std::make_shared<PrimitiveCType<uint16_t>>(std::static_pointer_cast<arrow::UInt16Type>(type));
+            case ID::UINT32:
+                return std::make_shared<PrimitiveCType<uint32_t>>(std::static_pointer_cast<arrow::UInt32Type>(type));
+            case ID::UINT64:
+                return std::make_shared<PrimitiveCType<uint64_t>>(std::static_pointer_cast<arrow::UInt64Type>(type));
+            case ID::INT8:
+                return std::make_shared<PrimitiveCType<int8_t>>(std::static_pointer_cast<arrow::Int8Type>(type));
+            case ID::INT16:
+                return std::make_shared<PrimitiveCType<int16_t>>(std::static_pointer_cast<arrow::Int16Type>(type));
+            case ID::INT32:
+                return std::make_shared<PrimitiveCType<int32_t>>(std::static_pointer_cast<arrow::Int32Type>(type));
+            case ID::INT64:
+                return std::make_shared<PrimitiveCType<int64_t>>(std::static_pointer_cast<arrow::Int64Type>(type));
+            case ID::FLOAT:
+                return std::make_shared<PrimitiveCType<float>>(std::static_pointer_cast<arrow::FloatType>(type));
+            case ID::DOUBLE:
+                return std::make_shared<PrimitiveCType<double>>(std::static_pointer_cast<arrow::DoubleType>(type));
+            case ID::TIMESTAMP:
+                return std::make_shared<TimestampType>(std::static_pointer_cast<arrow::TimestampType>(type));
+            case ID::STRING:
+                return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
+            default:
+                return arrow::Status::NotImplemented("Unsupported DataType: " + type->ToString());
+        }
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h
new file mode 100644
index 0000000000000..f5e2d30f8f4ec
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/type.h"
+#include "arrow/result.h"
+
+#include "arrow/matlab/type/proxy/type.h"
+
+namespace arrow::matlab::type::proxy {
+
+arrow::Result<std::shared_ptr<Type>> wrap(const std::shared_ptr<arrow::DataType>& type);
+
+
+}
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index c5a7c08aa5c10..530799c15c172 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -52,7 +52,9 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc")
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc")
+
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy/factory.cc")

From 32659a2d0e939bf853129f814fab9bcdec01a3bc Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 26 Jul 2023 11:08:24 -0400
Subject: [PATCH 053/749] GH-36874: [MATLAB] Move type constructor functions
 from the `arrow.type` package to `arrow` package (#36875)

### Rationale for this change

When working on PR #36855, we realized it would be better to place all recommended public/user-facing APIs in the top-level `arrow` package. That's why we added the function `arrow.field` in the top-level `arrow` package instead of under `arrow.type`, even though the `Field` class is within `arrow.type` package.

### What changes are included in this PR?

1. Moved the type constructor functions (`arrow.type.int8()`, `arrow.type.timestamp()`, etc) from the `arrow.type` package to the `arrow package`.

**Example: Old Way to Create a `Timestamp` Object:**

```matlab
>> type = arrow.type.timestmap(TimeUnit="nanosecond");
```

**Example: New Way to Create a `Timestamp` Object:**

```matlab
>> type = arrow.timestmap(TimeUnit="nanosecond");
```

### Are these changes tested?

Changes are covered by existing tests.

### Are there any user-facing changes?

Yes.

NOTE: This is a breaking change, but the MATLAB interface is not yet stable.
* Closes: #36874

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/matlab/+arrow/{+type => }/boolean.m   |  0
 .../src/matlab/+arrow/{+type => }/float32.m   |  0
 .../src/matlab/+arrow/{+type => }/float64.m   |  0
 matlab/src/matlab/+arrow/{+type => }/int16.m  |  0
 matlab/src/matlab/+arrow/{+type => }/int32.m  |  0
 matlab/src/matlab/+arrow/{+type => }/int64.m  |  0
 matlab/src/matlab/+arrow/{+type => }/int8.m   |  0
 matlab/src/matlab/+arrow/{+type => }/string.m |  0
 .../src/matlab/+arrow/{+type => }/timestamp.m |  0
 matlab/src/matlab/+arrow/{+type => }/uint16.m |  0
 matlab/src/matlab/+arrow/{+type => }/uint32.m |  0
 matlab/src/matlab/+arrow/{+type => }/uint64.m |  0
 matlab/src/matlab/+arrow/{+type => }/uint8.m  |  0
 matlab/test/arrow/array/tBooleanArray.m       |  2 +-
 matlab/test/arrow/array/tFloat32Array.m       |  2 +-
 matlab/test/arrow/array/tFloat64Array.m       |  2 +-
 matlab/test/arrow/array/tInt16Array.m         |  2 +-
 matlab/test/arrow/array/tInt32Array.m         |  2 +-
 matlab/test/arrow/array/tInt64Array.m         |  2 +-
 matlab/test/arrow/array/tInt8Array.m          |  2 +-
 matlab/test/arrow/array/tStringArray.m        |  2 +-
 matlab/test/arrow/array/tUInt16Array.m        |  2 +-
 matlab/test/arrow/array/tUInt32Array.m        |  2 +-
 matlab/test/arrow/array/tUInt64Array.m        |  2 +-
 matlab/test/arrow/array/tUInt8Array.m         |  2 +-
 matlab/test/arrow/type/tBooleanType.m         |  2 +-
 matlab/test/arrow/type/tField.m               | 44 +++++++++----------
 matlab/test/arrow/type/tFloat32Type.m         |  2 +-
 matlab/test/arrow/type/tFloat64Type.m         |  2 +-
 matlab/test/arrow/type/tInt16Type.m           |  2 +-
 matlab/test/arrow/type/tInt32Type.m           |  2 +-
 matlab/test/arrow/type/tInt64Type.m           |  2 +-
 matlab/test/arrow/type/tInt8Type.m            |  2 +-
 matlab/test/arrow/type/tStringType.m          |  4 +-
 matlab/test/arrow/type/tTimestampType.m       | 24 +++++-----
 matlab/test/arrow/type/tUInt16Type.m          |  2 +-
 matlab/test/arrow/type/tUInt32Type.m          |  2 +-
 matlab/test/arrow/type/tUInt64Type.m          |  2 +-
 matlab/test/arrow/type/tUInt8Type.m           |  2 +-
 39 files changed, 59 insertions(+), 59 deletions(-)
 rename matlab/src/matlab/+arrow/{+type => }/boolean.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/float32.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/float64.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/int16.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/int32.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/int64.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/int8.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/string.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/timestamp.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/uint16.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/uint32.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/uint64.m (100%)
 rename matlab/src/matlab/+arrow/{+type => }/uint8.m (100%)

diff --git a/matlab/src/matlab/+arrow/+type/boolean.m b/matlab/src/matlab/+arrow/boolean.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/boolean.m
rename to matlab/src/matlab/+arrow/boolean.m
diff --git a/matlab/src/matlab/+arrow/+type/float32.m b/matlab/src/matlab/+arrow/float32.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/float32.m
rename to matlab/src/matlab/+arrow/float32.m
diff --git a/matlab/src/matlab/+arrow/+type/float64.m b/matlab/src/matlab/+arrow/float64.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/float64.m
rename to matlab/src/matlab/+arrow/float64.m
diff --git a/matlab/src/matlab/+arrow/+type/int16.m b/matlab/src/matlab/+arrow/int16.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/int16.m
rename to matlab/src/matlab/+arrow/int16.m
diff --git a/matlab/src/matlab/+arrow/+type/int32.m b/matlab/src/matlab/+arrow/int32.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/int32.m
rename to matlab/src/matlab/+arrow/int32.m
diff --git a/matlab/src/matlab/+arrow/+type/int64.m b/matlab/src/matlab/+arrow/int64.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/int64.m
rename to matlab/src/matlab/+arrow/int64.m
diff --git a/matlab/src/matlab/+arrow/+type/int8.m b/matlab/src/matlab/+arrow/int8.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/int8.m
rename to matlab/src/matlab/+arrow/int8.m
diff --git a/matlab/src/matlab/+arrow/+type/string.m b/matlab/src/matlab/+arrow/string.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/string.m
rename to matlab/src/matlab/+arrow/string.m
diff --git a/matlab/src/matlab/+arrow/+type/timestamp.m b/matlab/src/matlab/+arrow/timestamp.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/timestamp.m
rename to matlab/src/matlab/+arrow/timestamp.m
diff --git a/matlab/src/matlab/+arrow/+type/uint16.m b/matlab/src/matlab/+arrow/uint16.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/uint16.m
rename to matlab/src/matlab/+arrow/uint16.m
diff --git a/matlab/src/matlab/+arrow/+type/uint32.m b/matlab/src/matlab/+arrow/uint32.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/uint32.m
rename to matlab/src/matlab/+arrow/uint32.m
diff --git a/matlab/src/matlab/+arrow/+type/uint64.m b/matlab/src/matlab/+arrow/uint64.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/uint64.m
rename to matlab/src/matlab/+arrow/uint64.m
diff --git a/matlab/src/matlab/+arrow/+type/uint8.m b/matlab/src/matlab/+arrow/uint8.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+type/uint8.m
rename to matlab/src/matlab/+arrow/uint8.m
diff --git a/matlab/test/arrow/array/tBooleanArray.m b/matlab/test/arrow/array/tBooleanArray.m
index ad6126b77fe51..e27ca11285a50 100644
--- a/matlab/test/arrow/array/tBooleanArray.m
+++ b/matlab/test/arrow/array/tBooleanArray.m
@@ -22,7 +22,7 @@
         MatlabArrayFcn = @logical
         MatlabConversionFcn = @logical
         NullSubstitutionValue = false
-        ArrowType = arrow.type.boolean
+        ArrowType = arrow.boolean
     end
 
     methods(TestClassSetup)
diff --git a/matlab/test/arrow/array/tFloat32Array.m b/matlab/test/arrow/array/tFloat32Array.m
index e8655c7781ceb..f007e2b422d6e 100644
--- a/matlab/test/arrow/array/tFloat32Array.m
+++ b/matlab/test/arrow/array/tFloat32Array.m
@@ -24,7 +24,7 @@
         MaxValue = realmax("single")
         MinValue = realmin("single")
         NullSubstitutionValue = single(NaN)
-        ArrowType = arrow.type.float32
+        ArrowType = arrow.float32
     end
 
     methods(Test)
diff --git a/matlab/test/arrow/array/tFloat64Array.m b/matlab/test/arrow/array/tFloat64Array.m
index a01eef73883b6..9b30ec8f25d49 100755
--- a/matlab/test/arrow/array/tFloat64Array.m
+++ b/matlab/test/arrow/array/tFloat64Array.m
@@ -24,7 +24,7 @@
         MaxValue = realmax("double")
         MinValue = realmin("double")
         NullSubstitutionValue = NaN
-        ArrowType = arrow.type.float64
+        ArrowType = arrow.float64
     end
 
     methods(Test)
diff --git a/matlab/test/arrow/array/tInt16Array.m b/matlab/test/arrow/array/tInt16Array.m
index 466dfaf9c4d7f..9cb5fdc1d1049 100644
--- a/matlab/test/arrow/array/tInt16Array.m
+++ b/matlab/test/arrow/array/tInt16Array.m
@@ -24,7 +24,7 @@
         MaxValue = intmax("int16")
         MinValue = intmin("int16")
         NullSubstitutionValue = int16(0)
-        ArrowType = arrow.type.int16
+        ArrowType = arrow.int16
     end
 
 end
diff --git a/matlab/test/arrow/array/tInt32Array.m b/matlab/test/arrow/array/tInt32Array.m
index b8334e97ccb9a..b45705592d714 100644
--- a/matlab/test/arrow/array/tInt32Array.m
+++ b/matlab/test/arrow/array/tInt32Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("int32")
         MinValue = intmin("int32")
         NullSubstitutionValue = int32(0)
-        ArrowType = arrow.type.int32
+        ArrowType = arrow.int32
     end
 end
diff --git a/matlab/test/arrow/array/tInt64Array.m b/matlab/test/arrow/array/tInt64Array.m
index a877cb2564fe9..0b38f58547cce 100644
--- a/matlab/test/arrow/array/tInt64Array.m
+++ b/matlab/test/arrow/array/tInt64Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("int64")
         MinValue = intmin("int64")
         NullSubstitutionValue = int64(0)
-        ArrowType = arrow.type.int64
+        ArrowType = arrow.int64
     end
 end
diff --git a/matlab/test/arrow/array/tInt8Array.m b/matlab/test/arrow/array/tInt8Array.m
index dbd6e74ea7f8f..8ce8e4e9b2d14 100644
--- a/matlab/test/arrow/array/tInt8Array.m
+++ b/matlab/test/arrow/array/tInt8Array.m
@@ -24,7 +24,7 @@
         MaxValue = intmax("int8")
         MinValue = intmin("int8")
         NullSubstitutionValue = int8(0)
-        ArrowType = arrow.type.int8
+        ArrowType = arrow.int8
     end
 
 end
diff --git a/matlab/test/arrow/array/tStringArray.m b/matlab/test/arrow/array/tStringArray.m
index 792d7599816d5..dbb2adca0ce5b 100644
--- a/matlab/test/arrow/array/tStringArray.m
+++ b/matlab/test/arrow/array/tStringArray.m
@@ -22,7 +22,7 @@
         MatlabArrayFcn = @string
         MatlabConversionFcn = @string
         NullSubstitutionValue = string(missing)
-        ArrowType = arrow.type.string
+        ArrowType = arrow.string
     end
 
     methods(TestClassSetup)
diff --git a/matlab/test/arrow/array/tUInt16Array.m b/matlab/test/arrow/array/tUInt16Array.m
index eed53c7882b47..705d6eabc0b7b 100644
--- a/matlab/test/arrow/array/tUInt16Array.m
+++ b/matlab/test/arrow/array/tUInt16Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("uint16")
         MinValue = intmin("uint16")
         NullSubstitutionValue = uint16(0)
-        ArrowType = arrow.type.uint16
+        ArrowType = arrow.uint16
     end
 end
diff --git a/matlab/test/arrow/array/tUInt32Array.m b/matlab/test/arrow/array/tUInt32Array.m
index b5e1970cbcc96..267a687738e44 100644
--- a/matlab/test/arrow/array/tUInt32Array.m
+++ b/matlab/test/arrow/array/tUInt32Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("uint32")
         MinValue = intmin("uint32")
         NullSubstitutionValue = uint32(0)
-        ArrowType = arrow.type.uint32
+        ArrowType = arrow.uint32
     end
 end
diff --git a/matlab/test/arrow/array/tUInt64Array.m b/matlab/test/arrow/array/tUInt64Array.m
index 6cd2c9cba6911..b1a23a004de69 100644
--- a/matlab/test/arrow/array/tUInt64Array.m
+++ b/matlab/test/arrow/array/tUInt64Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("uint64")
         MinValue = intmin("uint64")
         NullSubstitutionValue = uint64(0)
-        ArrowType = arrow.type.uint64
+        ArrowType = arrow.uint64
     end
 end
diff --git a/matlab/test/arrow/array/tUInt8Array.m b/matlab/test/arrow/array/tUInt8Array.m
index 68365958bc683..3db79f8c0b16d 100644
--- a/matlab/test/arrow/array/tUInt8Array.m
+++ b/matlab/test/arrow/array/tUInt8Array.m
@@ -24,6 +24,6 @@
         MaxValue = intmax("uint8")
         MinValue = intmin("uint8")
         NullSubstitutionValue = uint8(0)
-        ArrowType = arrow.type.uint8
+        ArrowType = arrow.uint8
     end
 end
diff --git a/matlab/test/arrow/type/tBooleanType.m b/matlab/test/arrow/type/tBooleanType.m
index 94de09a3e58f1..eaa1c280d5355 100644
--- a/matlab/test/arrow/type/tBooleanType.m
+++ b/matlab/test/arrow/type/tBooleanType.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.BooleanType
 
     properties
-        ArrowType = arrow.type.boolean
+        ArrowType = arrow.boolean
         TypeID = arrow.type.ID.Boolean
         BitWidth = int32(1)
         ClassName = "arrow.type.BooleanType"
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
index 9f0a8851591ee..77a05bbe39513 100644
--- a/matlab/test/arrow/type/tField.m
+++ b/matlab/test/arrow/type/tField.m
@@ -19,7 +19,7 @@
     methods(Test)
         function TestBasic(testCase)
             name = "A";
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(name, type);
 
             testCase.verifyEqual(field.Name, name);
@@ -29,19 +29,19 @@ function TestBasic(testCase)
         function TestSupportedTypes(testCase)
             name = "name";
             supportedTypes = { ...
-                                 arrow.type.uint8, ...
-                                 arrow.type.uint16, ...
-                                 arrow.type.uint32, ...
-                                 arrow.type.uint64, ...
-                                 arrow.type.int8, ...
-                                 arrow.type.int16, ...
-                                 arrow.type.int32, ...
-                                 arrow.type.int64, ...
-                                 arrow.type.boolean, ...
-                                 arrow.type.float32, ...
-                                 arrow.type.float64, ...
-                                 arrow.type.string, ...
-                                 arrow.type.timestamp, ...
+                                 arrow.uint8, ...
+                                 arrow.uint16, ...
+                                 arrow.uint32, ...
+                                 arrow.uint64, ...
+                                 arrow.int8, ...
+                                 arrow.int16, ...
+                                 arrow.int32, ...
+                                 arrow.int64, ...
+                                 arrow.boolean, ...
+                                 arrow.float32, ...
+                                 arrow.float64, ...
+                                 arrow.string, ...
+                                 arrow.timestamp, ...
                              };
             for ii = 1:numel(supportedTypes)
                 supportedType = supportedTypes{ii};
@@ -56,7 +56,7 @@ function TestNameUnicode(testCase)
             tree =  "🌲";
             mango = "🥭";
 
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(smiley, type);
 
             testCase.verifyEqual(field.Name, smiley);
@@ -75,13 +75,13 @@ function TestNameUnicode(testCase)
 
         function TestErrorIfNameStringMissing(testCase)
             name = string(missing);
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             testCase.verifyError(@() arrow.field(name, type), "MATLAB:validators:mustBeNonmissing");
         end
 
         function TestNameEmptyString(testCase)
             name = "";
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(name, type);
 
             testCase.verifyEqual(field.Name, name);
@@ -90,7 +90,7 @@ function TestNameEmptyString(testCase)
 
         function TestNameCharVector(testCase)
             name = 'ABC';
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(name, type);
 
             testCase.verifyEqual(field.Name, string(name));
@@ -99,7 +99,7 @@ function TestNameCharVector(testCase)
 
         function TestNameNumber(testCase)
             name = 123;
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(name, type);
 
             testCase.verifyEqual(field.Name, string(123));
@@ -114,17 +114,17 @@ function TestArrowTypeUnsupportedInput(testCase)
 
         function TestNameUnsupportedInput(testCase)
             name = table();
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             testCase.verifyError(@() arrow.field(name, type), "MATLAB:validation:UnableToConvert");
         end
 
         function TestImmutableProperties(testCase)
             name = "A";
-            type = arrow.type.uint64;
+            type = arrow.uint64;
             field = arrow.field(name, type);
 
             testCase.verifyError(@() setfield(field, "Name", "NewValue"), "MATLAB:class:noSetMethod")
-            testCase.verifyError(@() setfield(field, "Type", arrow.type.boolean), "MATLAB:class:noSetMethod")
+            testCase.verifyError(@() setfield(field, "Type", arrow.boolean), "MATLAB:class:noSetMethod")
         end
 
     end
diff --git a/matlab/test/arrow/type/tFloat32Type.m b/matlab/test/arrow/type/tFloat32Type.m
index c54fcfd32809b..1837c39a72ed8 100644
--- a/matlab/test/arrow/type/tFloat32Type.m
+++ b/matlab/test/arrow/type/tFloat32Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Float32Type
 
     properties
-        ArrowType = arrow.type.float32
+        ArrowType = arrow.float32
         TypeID = arrow.type.ID.Float32
         BitWidth = int32(32)
         ClassName = "arrow.type.Float32Type"
diff --git a/matlab/test/arrow/type/tFloat64Type.m b/matlab/test/arrow/type/tFloat64Type.m
index 6b5648dfc10e3..8387a4bf5807b 100644
--- a/matlab/test/arrow/type/tFloat64Type.m
+++ b/matlab/test/arrow/type/tFloat64Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Float64Type
 
     properties
-        ArrowType = arrow.type.float64
+        ArrowType = arrow.float64
         TypeID = arrow.type.ID.Float64
         BitWidth = int32(64)
         ClassName = "arrow.type.Float64Type"
diff --git a/matlab/test/arrow/type/tInt16Type.m b/matlab/test/arrow/type/tInt16Type.m
index a929ba688b5cd..9b741a32956f5 100644
--- a/matlab/test/arrow/type/tInt16Type.m
+++ b/matlab/test/arrow/type/tInt16Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Int16Type
 
     properties
-        ArrowType = arrow.type.int16
+        ArrowType = arrow.int16
         TypeID = arrow.type.ID.Int16
         BitWidth = int32(16)
         ClassName = "arrow.type.Int16Type"
diff --git a/matlab/test/arrow/type/tInt32Type.m b/matlab/test/arrow/type/tInt32Type.m
index 6d59b5454e7fc..9724f9a4a6a96 100644
--- a/matlab/test/arrow/type/tInt32Type.m
+++ b/matlab/test/arrow/type/tInt32Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Int32Type
 
     properties
-        ArrowType = arrow.type.int32
+        ArrowType = arrow.int32
         TypeID = arrow.type.ID.Int32
         BitWidth = int32(32)
         ClassName = "arrow.type.Int32Type"
diff --git a/matlab/test/arrow/type/tInt64Type.m b/matlab/test/arrow/type/tInt64Type.m
index 6ff0d2b07cbac..2acb5fd2d3f1f 100644
--- a/matlab/test/arrow/type/tInt64Type.m
+++ b/matlab/test/arrow/type/tInt64Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Int64Type
 
     properties
-        ArrowType = arrow.type.int64
+        ArrowType = arrow.int64
         TypeID = arrow.type.ID.Int64
         BitWidth = int32(64)
         ClassName = "arrow.type.Int64Type"
diff --git a/matlab/test/arrow/type/tInt8Type.m b/matlab/test/arrow/type/tInt8Type.m
index 396be3a3f715a..15e2629bc4d68 100644
--- a/matlab/test/arrow/type/tInt8Type.m
+++ b/matlab/test/arrow/type/tInt8Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.Int8Type
 
     properties
-        ArrowType = arrow.type.int8
+        ArrowType = arrow.int8
         TypeID = arrow.type.ID.Int8
         BitWidth = int32(8)
         ClassName = "arrow.type.Int8Type"
diff --git a/matlab/test/arrow/type/tStringType.m b/matlab/test/arrow/type/tStringType.m
index 057ffd5426345..e52c2cb1cba0b 100644
--- a/matlab/test/arrow/type/tStringType.m
+++ b/matlab/test/arrow/type/tStringType.m
@@ -19,14 +19,14 @@
     methods (Test)
 
         function Basic(tc)
-            type = arrow.type.string;
+            type = arrow.string;
             className = string(class(type));
             tc.verifyEqual(className, "arrow.type.StringType");
             tc.verifyEqual(type.ID, arrow.type.ID.String);
         end
 
         function NumFields(tc)
-            type = arrow.type.string;
+            type = arrow.string;
             tc.verifyEqual(type.NumFields, int32(0));
         end
 
diff --git a/matlab/test/arrow/type/tTimestampType.m b/matlab/test/arrow/type/tTimestampType.m
index fa893d2d930de..8fd78854acb06 100644
--- a/matlab/test/arrow/type/tTimestampType.m
+++ b/matlab/test/arrow/type/tTimestampType.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.TimestampType
 
     properties
-        ArrowType = arrow.type.timestamp
+        ArrowType = arrow.timestamp
         TypeID = arrow.type.ID.Timestamp
         BitWidth = int32(64)
         ClassName = "arrow.type.TimestampType"
@@ -32,7 +32,7 @@ function TestClass(testCase)
 
         function DefaultTimeUnit(testCase)
         % Verify the default TimeUnit is Microsecond
-            type = arrow.type.timestamp;
+            type = arrow.timestamp;
             actualUnit = type.TimeUnit;
             expectedUnit = arrow.type.TimeUnit.Microsecond; 
             testCase.verifyEqual(actualUnit, expectedUnit);
@@ -40,7 +40,7 @@ function DefaultTimeUnit(testCase)
 
         function DefaultTimeZone(testCase)
         % Verify the default TimeZone is ""
-            type = arrow.type.timestamp;
+            type = arrow.timestamp;
             actualTimezone = type.TimeZone;
             expectedTimezone = "";
             testCase.verifyEqual(actualTimezone, expectedTimezone);
@@ -53,7 +53,7 @@ function SupplyTimeUnitEnum(testCase)
                             TimeUnit.Microsecond, TimeUnit.Nanosecond];
 
             for unit = expectedUnit
-                type = timestamp(TimeUnit=unit);
+                type = arrow.timestamp(TimeUnit=unit);
                 testCase.verifyEqual(type.TimeUnit, unit);
             end
         end
@@ -67,42 +67,42 @@ function SupplyTimeUnitString(testCase)
                             TimeUnit.Microsecond, TimeUnit.Nanosecond];
             
             for ii = 1:numel(unitString)
-                type = timestamp(TimeUnit=unitString(ii));
+                type = arrow.timestamp(TimeUnit=unitString(ii));
                 testCase.verifyEqual(type.TimeUnit, expectedUnit(ii));
             end
         end
 
         function SupplyTimeZone(testCase)
         % Supply the TimeZone. 
-            type = arrow.type.timestamp(TimeZone="America/New_York");
+            type = arrow.timestamp(TimeZone="America/New_York");
             testCase.verifyEqual(type.TimeZone, "America/New_York");
         end
 
         function ErrorIfMissingStringTimeZone(testCase)
-            fcn = @() arrow.type.timestamp(TimeZone=string(missing));
+            fcn = @() arrow.timestamp(TimeZone=string(missing));
             testCase.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
         end
 
         function ErrorIfTimeZoneIsNonScalar(testCase)
-            fcn = @() arrow.type.timestamp(TimeZone=["a", "b"]);
+            fcn = @() arrow.timestamp(TimeZone=["a", "b"]);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
 
-              fcn = @() arrow.type.timestamp(TimeZone=strings(0, 0));
+              fcn = @() arrow.timestamp(TimeZone=strings(0, 0));
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
         function ErrorIfAmbiguousTimeUnit(testCase)
-            fcn = @() arrow.type.timestamp(TimeUnit="mi");
+            fcn = @() arrow.timestamp(TimeUnit="mi");
             testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
         end
 
         function ErrorIfTimeUnitIsNonScalar(testCase)
             units = [arrow.type.TimeUnit.Second; arrow.type.TimeUnit.Millisecond];
-            fcn = @() arrow.type.timestamp(TimeZone=units);
+            fcn = @() arrow.timestamp(TimeZone=units);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
 
             units = ["second" "millisecond"];
-            fcn = @() arrow.type.timestamp(TimeZone=units);
+            fcn = @() arrow.timestamp(TimeZone=units);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
     end
diff --git a/matlab/test/arrow/type/tUInt16Type.m b/matlab/test/arrow/type/tUInt16Type.m
index ede66f6324691..8a803dc0a7888 100644
--- a/matlab/test/arrow/type/tUInt16Type.m
+++ b/matlab/test/arrow/type/tUInt16Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.UInt16Type
 
     properties
-        ArrowType = arrow.type.uint16
+        ArrowType = arrow.uint16
         TypeID = arrow.type.ID.UInt16
         BitWidth = int32(16)
         ClassName = "arrow.type.UInt16Type"
diff --git a/matlab/test/arrow/type/tUInt32Type.m b/matlab/test/arrow/type/tUInt32Type.m
index def24c76ceb76..019b8ce26929d 100644
--- a/matlab/test/arrow/type/tUInt32Type.m
+++ b/matlab/test/arrow/type/tUInt32Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.UInt32Type
 
     properties
-        ArrowType = arrow.type.uint32
+        ArrowType = arrow.uint32
         TypeID = arrow.type.ID.UInt32
         BitWidth = int32(32)
         ClassName = "arrow.type.UInt32Type"
diff --git a/matlab/test/arrow/type/tUInt64Type.m b/matlab/test/arrow/type/tUInt64Type.m
index 9228e1cc504d6..8287bb40d0052 100644
--- a/matlab/test/arrow/type/tUInt64Type.m
+++ b/matlab/test/arrow/type/tUInt64Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.UInt64Type
 
     properties
-        ArrowType = arrow.type.uint64
+        ArrowType = arrow.uint64
         TypeID = arrow.type.ID.UInt64
         BitWidth = int32(64)
         ClassName = "arrow.type.UInt64Type"
diff --git a/matlab/test/arrow/type/tUInt8Type.m b/matlab/test/arrow/type/tUInt8Type.m
index eec3aa5fdec25..1ff203c862aeb 100644
--- a/matlab/test/arrow/type/tUInt8Type.m
+++ b/matlab/test/arrow/type/tUInt8Type.m
@@ -17,7 +17,7 @@
 % Test class for arrow.type.UInt64Type
 
     properties
-        ArrowType = arrow.type.uint8
+        ArrowType = arrow.uint8
         TypeID = arrow.type.ID.UInt8
         BitWidth = int32(8)
         ClassName = "arrow.type.UInt8Type"

From 0513097ca311550b70ab91e7d1cbc07e3b64ba34 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 26 Jul 2023 12:16:56 -0400
Subject: [PATCH 054/749] GH-36735 : Add `TimeUnit` and `TimeZone` to the
 `arrow.type.TimestampType` display (#36871)

### Rationale for this change

The `arrow.type.TimestampType` display should include the `TimeUnit` and `TimeZone` properties. Right now we only display the `ID` property:

```matlab
>> type = arrow.type.timestamp(TimeUnit="Second", TimeZone="America/Anchorage")

type =

  TimestampType with properties:

    ID: Timestamp
```
We should show the other two properties in the display.

### What changes are included in this PR?

Modified the display of `TimestampType`:

```matlab
>> type = arrow.type.timestamp(TimeUnit="Second", TimeZone="America/Anchorage")

type =

  TimestampType with properties:

          ID: Timestamp
    TimeUnit: Second
    TimeZone: "America/Anchorage"

```
Now `TimeUnit` and `TimeZone` are included.

### Are these changes tested?

Added a test case to `tTimestampType` called `Display`. It verifies `TimestampType` objects are displayed correctly in the Command Window.

### Are there any user-facing changes?

Yes, users will see the new display.

* Closes: #36735

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/matlab/+arrow/+type/TimestampType.m   |  7 +++++
 matlab/test/arrow/type/tTimestampType.m       | 27 +++++++++++++++++--
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+type/TimestampType.m b/matlab/src/matlab/+arrow/+type/TimestampType.m
index a5a376f8bc3b3..b3d34f31b7d1e 100644
--- a/matlab/src/matlab/+arrow/+type/TimestampType.m
+++ b/matlab/src/matlab/+arrow/+type/TimestampType.m
@@ -39,4 +39,11 @@
             tz = obj.Proxy.timeZone();
         end
     end
+
+    methods (Access=protected)
+        function group = getPropertyGroups(~)
+          targets = ["ID" "TimeUnit" "TimeZone"];
+          group = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tTimestampType.m b/matlab/test/arrow/type/tTimestampType.m
index 8fd78854acb06..deee984e4b911 100644
--- a/matlab/test/arrow/type/tTimestampType.m
+++ b/matlab/test/arrow/type/tTimestampType.m
@@ -87,7 +87,7 @@ function ErrorIfTimeZoneIsNonScalar(testCase)
             fcn = @() arrow.timestamp(TimeZone=["a", "b"]);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
 
-              fcn = @() arrow.timestamp(TimeZone=strings(0, 0));
+            fcn = @() arrow.timestamp(TimeZone=strings(0, 0));
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
@@ -105,5 +105,28 @@ function ErrorIfTimeUnitIsNonScalar(testCase)
             fcn = @() arrow.timestamp(TimeZone=units);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
+
+        function Display(testCase)
+        % Verify the display of TimestampType objects.
+        %
+        % Example:
+        %
+        %  TimestampType with properties:
+        %
+        %          ID: Timestamp
+        %    TimeUnit: Second
+        %    TimeZone: "America/Anchorage"
+        %
+            type = arrow.timestamp(TimeUnit="Second", TimeZone="America/Anchorage"); %#ok<NASGU>
+            classnameLink = "<a href=""matlab:helpPopup arrow.type.TimestampType"" style=""font-weight:bold"">TimestampType</a>";
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "TimeUnit:"; "TimeZone:"]));
+            body = body + " " + ["Timestamp"; "Second"; """America/Anchorage"""];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
     end
-end
\ No newline at end of file
+end

From 7c0451c71ef68840b4642e53857b522160c075f4 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Wed, 26 Jul 2023 12:49:53 -0400
Subject: [PATCH 055/749] GH-36893: [Go][Flight] Expose underlying protobuf
 definitions (#36895)

### What changes are included in this PR?
Shifting generated protobuf code for flight/flightsql to have the path `arrow/flight/gen/flight` rather than `arrow/flight/internal/flight` so that they are exposed and exported.

* Closes: #36893

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 dev/release/rat_exclude_files.txt             |   3 +-
 format/Flight.proto                           |   2 +-
 format/FlightSql.proto                        |   2 +-
 go/arrow/flight/client.go                     |   2 +-
 go/arrow/flight/flightsql/client.go           |   2 +-
 go/arrow/flight/flightsql/client_test.go      |   2 +-
 go/arrow/flight/flightsql/server.go           |   2 +-
 go/arrow/flight/flightsql/server_test.go      |   2 +-
 go/arrow/flight/flightsql/types.go            |   2 +-
 go/arrow/flight/gen.go                        |   4 +-
 .../{internal => gen}/flight/Flight.pb.go     |  71 ++-
 .../{internal => gen}/flight/FlightSql.pb.go  | 575 ++++++++++--------
 .../flight/Flight_grpc.pb.go                  |  46 +-
 go/arrow/flight/server.go                     |   2 +-
 14 files changed, 430 insertions(+), 287 deletions(-)
 rename go/arrow/flight/{internal => gen}/flight/Flight.pb.go (98%)
 rename go/arrow/flight/{internal => gen}/flight/FlightSql.pb.go (94%)
 rename go/arrow/flight/{internal => gen}/flight/Flight_grpc.pb.go (93%)

diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index f61c217760f61..7bdb692d048e9 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -63,8 +63,7 @@ docs/requirements.txt
 go.work.sum
 go/go.sum
 go/arrow/Gopkg.lock
-go/arrow/flight/internal/flight/Flight.pb.go
-go/arrow/flight/internal/flight/Flight_grpc.pb.go
+go/arrow/flight/gen/flight/*.pb.go
 go/arrow/internal/cpu/*
 go/arrow/type_string.go
 go/arrow/cdata/test/go.sum
diff --git a/format/Flight.proto b/format/Flight.proto
index 107e95765406e..b5d23f6f7e6d2 100644
--- a/format/Flight.proto
+++ b/format/Flight.proto
@@ -20,7 +20,7 @@ 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/internal/flight";
+option go_package = "github.com/apache/arrow/go/arrow/flight/gen/flight";
 option csharp_namespace = "Apache.Arrow.Flight.Protocol";
 
 package arrow.flight.protocol;
diff --git a/format/FlightSql.proto b/format/FlightSql.proto
index 48c2d94a11f42..3c9a719f1275f 100644
--- a/format/FlightSql.proto
+++ b/format/FlightSql.proto
@@ -20,7 +20,7 @@ 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/internal/flight";
+option go_package = "github.com/apache/arrow/go/arrow/flight/gen/flight";
 package arrow.flight.protocol.sql;
 
 /*
diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index 31ffc26cfd35a..1de5fc47f5f28 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	"github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/flightsql/client.go b/go/arrow/flight/flightsql/client.go
index 76c9f6fb01d32..f4cd6ee7ce56f 100644
--- a/go/arrow/flight/flightsql/client.go
+++ b/go/arrow/flight/flightsql/client.go
@@ -25,7 +25,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/flight"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"github.com/apache/arrow/go/v13/arrow/ipc"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index 2b57596fb188c..1532ef5f32f54 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/flight"
 	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/flight/flightsql/server.go b/go/arrow/flight/flightsql/server.go
index ee457ad7a8bca..48c0314fa6490 100644
--- a/go/arrow/flight/flightsql/server.go
+++ b/go/arrow/flight/flightsql/server.go
@@ -24,7 +24,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/flight"
 	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/ipc"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/flight/flightsql/server_test.go b/go/arrow/flight/flightsql/server_test.go
index 9ced8e0ed6cdf..43a23bb7e9ac6 100644
--- a/go/arrow/flight/flightsql/server_test.go
+++ b/go/arrow/flight/flightsql/server_test.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/flight"
 	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/types.go b/go/arrow/flight/flightsql/types.go
index 72de81115a77a..34db36b44df2a 100644
--- a/go/arrow/flight/flightsql/types.go
+++ b/go/arrow/flight/flightsql/types.go
@@ -17,7 +17,7 @@
 package flightsql
 
 import (
-	pb "github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
diff --git a/go/arrow/flight/gen.go b/go/arrow/flight/gen.go
index 4109059af8ed1..cfdd0e036703a 100644
--- a/go/arrow/flight/gen.go
+++ b/go/arrow/flight/gen.go
@@ -16,5 +16,5 @@
 
 package flight
 
-//go:generate protoc -I../../../format --go_out=./internal/flight --go-grpc_out=./internal/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative Flight.proto
-//go:generate protoc --experimental_allow_proto3_optional -I../../../format --go_out=./internal/flight --go-grpc_out=./internal/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative FlightSql.proto
+//go:generate protoc -I../../../format --go_out=./gen/flight --go-grpc_out=./gen/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative Flight.proto
+//go:generate protoc --experimental_allow_proto3_optional -I../../../format --go_out=./gen/flight --go-grpc_out=./gen/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative FlightSql.proto
diff --git a/go/arrow/flight/internal/flight/Flight.pb.go b/go/arrow/flight/gen/flight/Flight.pb.go
similarity index 98%
rename from go/arrow/flight/internal/flight/Flight.pb.go
rename to go/arrow/flight/gen/flight/Flight.pb.go
index 7b4d1e2fd9298..f91d762014603 100644
--- a/go/arrow/flight/internal/flight/Flight.pb.go
+++ b/go/arrow/flight/gen/flight/Flight.pb.go
@@ -18,15 +18,15 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.21.12
+// 	protoc        v3.12.4
 // source: Flight.proto
 
 package flight
 
 import (
+	timestamp "github.com/golang/protobuf/ptypes/timestamp"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
 	reflect "reflect"
 	sync "sync"
 )
@@ -38,6 +38,7 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+//
 // The result of a cancel operation.
 //
 // This is used by CancelFlightInfoResult.status.
@@ -102,17 +103,19 @@ func (CancelStatus) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{0}
 }
 
+//
 // Describes what type of descriptor is defined.
 type FlightDescriptor_DescriptorType int32
 
 const (
 	// Protobuf pattern, not used.
 	FlightDescriptor_UNKNOWN FlightDescriptor_DescriptorType = 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.
+	//  similar to a path inside a filesystem.
 	FlightDescriptor_PATH FlightDescriptor_DescriptorType = 1
+	//
 	// An opaque command to generate a dataset.
 	FlightDescriptor_CMD FlightDescriptor_DescriptorType = 2
 )
@@ -158,14 +161,17 @@ func (FlightDescriptor_DescriptorType) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{12, 0}
 }
 
+//
 // The request that a client provides to a server on handshake.
 type HandshakeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
+	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -221,8 +227,10 @@ type HandshakeResponse struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
+	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -273,6 +281,7 @@ func (x *HandshakeResponse) GetPayload() []byte {
 	return nil
 }
 
+//
 // A message for doing simple auth.
 type BasicAuth struct {
 	state         protoimpl.MessageState
@@ -367,6 +376,7 @@ func (*Empty) Descriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{3}
 }
 
+//
 // Describes an available action, including both the name used for execution
 // along with a short description of the purpose of the action.
 type ActionType struct {
@@ -424,6 +434,7 @@ func (x *ActionType) GetDescription() string {
 	return ""
 }
 
+//
 // A service specific expression that can be used to return a limited set
 // of available Arrow Flight streams.
 type Criteria struct {
@@ -473,6 +484,7 @@ func (x *Criteria) GetExpression() []byte {
 	return nil
 }
 
+//
 // An opaque action specific for the service.
 type Action struct {
 	state         protoimpl.MessageState
@@ -529,6 +541,7 @@ func (x *Action) GetBody() []byte {
 	return nil
 }
 
+//
 // The request of the CancelFlightInfo action.
 //
 // The request should be stored in Action.body.
@@ -579,6 +592,7 @@ func (x *CancelFlightInfoRequest) GetInfo() *FlightInfo {
 	return nil
 }
 
+//
 // The request of the RenewFlightEndpoint action.
 //
 // The request should be stored in Action.body.
@@ -629,6 +643,7 @@ func (x *RenewFlightEndpointRequest) GetEndpoint() *FlightEndpoint {
 	return nil
 }
 
+//
 // An opaque result returned after executing an action.
 type Result struct {
 	state         protoimpl.MessageState
@@ -677,6 +692,7 @@ func (x *Result) GetBody() []byte {
 	return nil
 }
 
+//
 // The result of the CancelFlightInfo action.
 //
 // The result should be stored in Result.body.
@@ -727,6 +743,7 @@ func (x *CancelFlightInfoResult) GetStatus() CancelStatus {
 	return CancelStatus_CANCEL_STATUS_UNSPECIFIED
 }
 
+//
 // Wrap the result of a getSchema call
 type SchemaResult struct {
 	state         protoimpl.MessageState
@@ -734,10 +751,9 @@ type SchemaResult struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
+	//   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//   4 bytes - the byte length of the payload
+	//   a flatbuffer Message whose header is the Schema
 	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
 }
 
@@ -780,6 +796,7 @@ func (x *SchemaResult) GetSchema() []byte {
 	return nil
 }
 
+//
 // 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.
 type FlightDescriptor struct {
@@ -788,9 +805,11 @@ type FlightDescriptor struct {
 	unknownFields protoimpl.UnknownFields
 
 	Type FlightDescriptor_DescriptorType `protobuf:"varint,1,opt,name=type,proto3,enum=arrow.flight.protocol.FlightDescriptor_DescriptorType" json:"type,omitempty"`
+	//
 	// Opaque value used to express a command. Should only be defined when
 	// type = CMD.
 	Cmd []byte `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
+	//
 	// List of strings identifying a particular dataset. Should only be defined
 	// when type = PATH.
 	Path []string `protobuf:"bytes,3,rep,name=path,proto3" json:"path,omitempty"`
@@ -849,6 +868,7 @@ func (x *FlightDescriptor) GetPath() []string {
 	return nil
 }
 
+//
 // The access coordinates for retrieval of a dataset. With a FlightInfo, a
 // consumer is able to determine how to retrieve a dataset.
 type FlightInfo struct {
@@ -857,13 +877,14 @@ type FlightInfo struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
+	//   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//   4 bytes - the byte length of the payload
+	//   a flatbuffer Message whose header is the Schema
 	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
+	//
 	// The descriptor associated with this info.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,2,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	//
 	// 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.
@@ -883,13 +904,14 @@ type FlightInfo struct {
 	// 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.
+	// * An application requires that all clients must read data in
+	//   returned endpoints order.
+	// * An application must return the all data in a single endpoint.
 	Endpoint []*FlightEndpoint `protobuf:"bytes,3,rep,name=endpoint,proto3" json:"endpoint,omitempty"`
 	// Set these to -1 if unknown.
 	TotalRecords int64 `protobuf:"varint,4,opt,name=total_records,json=totalRecords,proto3" json:"total_records,omitempty"`
 	TotalBytes   int64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`
+	//
 	// FlightEndpoints are in the same order as the data.
 	Ordered bool `protobuf:"varint,6,opt,name=ordered,proto3" json:"ordered,omitempty"`
 }
@@ -968,14 +990,17 @@ func (x *FlightInfo) GetOrdered() bool {
 	return false
 }
 
+//
 // A particular stream or split associated with a flight.
 type FlightEndpoint struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// Token used to retrieve this stream.
 	Ticket *Ticket `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
+	//
 	// 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
@@ -991,10 +1016,11 @@ type FlightEndpoint struct {
 	// In other words, an application can use multiple locations to
 	// represent redundant and/or load balanced services.
 	Location []*Location `protobuf:"bytes,2,rep,name=location,proto3" json:"location,omitempty"`
+	//
 	// 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.
-	ExpirationTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
+	ExpirationTime *timestamp.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
 }
 
 func (x *FlightEndpoint) Reset() {
@@ -1043,13 +1069,14 @@ func (x *FlightEndpoint) GetLocation() []*Location {
 	return nil
 }
 
-func (x *FlightEndpoint) GetExpirationTime() *timestamppb.Timestamp {
+func (x *FlightEndpoint) GetExpirationTime() *timestamp.Timestamp {
 	if x != nil {
 		return x.ExpirationTime
 	}
 	return nil
 }
 
+//
 // A location where a Flight service will accept retrieval of a particular
 // stream given a ticket.
 type Location struct {
@@ -1099,6 +1126,7 @@ func (x *Location) GetUri() string {
 	return ""
 }
 
+//
 // An opaque identifier that the service can use to retrieve a particular
 // portion of a stream.
 //
@@ -1151,19 +1179,24 @@ func (x *Ticket) GetTicket() []byte {
 	return nil
 }
 
+//
 // A batch of Arrow data as part of a stream of batches.
 type FlightData struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// The descriptor of the data. This is only relevant when a client is
 	// starting a new DoPut stream.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,1,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	//
 	// Header for message data as described in Message.fbs::Message.
 	DataHeader []byte `protobuf:"bytes,2,opt,name=data_header,json=dataHeader,proto3" json:"data_header,omitempty"`
+	//
 	// Application-defined metadata.
 	AppMetadata []byte `protobuf:"bytes,3,opt,name=app_metadata,json=appMetadata,proto3" json:"app_metadata,omitempty"`
+	//
 	// 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
@@ -1231,7 +1264,7 @@ func (x *FlightData) GetDataBody() []byte {
 	return nil
 }
 
-// *
+//*
 // The response message associated with the submission of a DoPut.
 type PutResult struct {
 	state         protoimpl.MessageState
@@ -1502,7 +1535,7 @@ var file_Flight_proto_goTypes = []interface{}{
 	(*Ticket)(nil),                       // 18: arrow.flight.protocol.Ticket
 	(*FlightData)(nil),                   // 19: arrow.flight.protocol.FlightData
 	(*PutResult)(nil),                    // 20: arrow.flight.protocol.PutResult
-	(*timestamppb.Timestamp)(nil),        // 21: google.protobuf.Timestamp
+	(*timestamp.Timestamp)(nil),          // 21: google.protobuf.Timestamp
 }
 var file_Flight_proto_depIdxs = []int32{
 	15, // 0: arrow.flight.protocol.CancelFlightInfoRequest.info:type_name -> arrow.flight.protocol.FlightInfo
diff --git a/go/arrow/flight/internal/flight/FlightSql.pb.go b/go/arrow/flight/gen/flight/FlightSql.pb.go
similarity index 94%
rename from go/arrow/flight/internal/flight/FlightSql.pb.go
rename to go/arrow/flight/gen/flight/FlightSql.pb.go
index b61ac29066836..3b1ba232d3d12 100644
--- a/go/arrow/flight/internal/flight/FlightSql.pb.go
+++ b/go/arrow/flight/gen/flight/FlightSql.pb.go
@@ -18,15 +18,15 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.21.12
+// 	protoc        v3.12.4
 // source: FlightSql.proto
 
 package flight
 
 import (
+	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
 	reflect "reflect"
 	sync "sync"
 )
@@ -48,27 +48,33 @@ const (
 	SqlInfo_FLIGHT_SQL_SERVER_VERSION SqlInfo = 1
 	// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
 	SqlInfo_FLIGHT_SQL_SERVER_ARROW_VERSION SqlInfo = 2
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
 	//
 	// Returns:
 	// - false: if read-write
 	// - true: if read only
 	SqlInfo_FLIGHT_SQL_SERVER_READ_ONLY SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_SQL SqlInfo = 4
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
 	// Substrait plans.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT SqlInfo = 5
+	//
 	// Retrieves a string value indicating the minimum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION SqlInfo = 6
+	//
 	// Retrieves a string value indicating the maximum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION SqlInfo = 7
+	//
 	// Retrieves an int32 indicating whether the Flight SQL Server supports the
 	// BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
 	//
@@ -78,51 +84,61 @@ const (
 	//
 	// The possible values are listed in `SqlSupportedTransaction`.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION SqlInfo = 8
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
 	// query cancellation (the CancelQuery action).
 	SqlInfo_FLIGHT_SQL_SERVER_CANCEL SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT SqlInfo = 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.
 	SqlInfo_SQL_DDL_CATALOG SqlInfo = 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.
 	SqlInfo_SQL_DDL_SCHEMA SqlInfo = 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.
 	SqlInfo_SQL_DDL_TABLE SqlInfo = 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`.
 	SqlInfo_SQL_IDENTIFIER_CASE SqlInfo = 503
 	// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
 	SqlInfo_SQL_IDENTIFIER_QUOTE_CHAR SqlInfo = 504
+	//
 	// Retrieves a int32 describing the case sensitivity of quoted identifiers.
 	//
 	// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
 	SqlInfo_SQL_QUOTED_IDENTIFIER_CASE SqlInfo = 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.
 	SqlInfo_SQL_ALL_TABLES_ARE_SELECTABLE SqlInfo = 506
+	//
 	// Retrieves the null ordering.
 	//
 	// Returns a int32 ordinal for the null ordering being used, as described in
@@ -138,15 +154,18 @@ const (
 	SqlInfo_SQL_SYSTEM_FUNCTIONS SqlInfo = 511
 	// Retrieves a UTF-8 string list with values of the supported datetime functions.
 	SqlInfo_SQL_DATETIME_FUNCTIONS SqlInfo = 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.
 	SqlInfo_SQL_SEARCH_STRING_ESCAPE SqlInfo = 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 _).
 	SqlInfo_SQL_EXTRA_NAME_CHARACTERS SqlInfo = 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.
@@ -155,6 +174,7 @@ const (
 	// - false: if column aliasing is unsupported;
 	// - true: if column aliasing is supported.
 	SqlInfo_SQL_SUPPORTS_COLUMN_ALIASING SqlInfo = 515
+	//
 	// Retrieves a boolean value indicating whether concatenations between null and non-null values being
 	// null are supported.
 	//
@@ -162,11 +182,13 @@ const (
 	// - 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.
 	SqlInfo_SQL_NULL_PLUS_NULL_IS_NULL SqlInfo = 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>>
 	SqlInfo_SQL_SUPPORTS_CONVERT SqlInfo = 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.
 	//
@@ -174,6 +196,7 @@ const (
 	// - false: if table correlation names are unsupported;
 	// - true: if table correlation names are supported.
 	SqlInfo_SQL_SUPPORTS_TABLE_CORRELATION_NAMES SqlInfo = 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.
 	//
@@ -181,12 +204,14 @@ const (
 	// - false: if different table correlation names are unsupported;
 	// - true: if different table correlation names are supported
 	SqlInfo_SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES SqlInfo = 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;
 	SqlInfo_SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY SqlInfo = 520
+	//
 	// Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
 	// clause is supported.
 	//
@@ -194,6 +219,7 @@ const (
 	// - 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.
 	SqlInfo_SQL_SUPPORTS_ORDER_BY_UNRELATED SqlInfo = 521
+	//
 	// Retrieves the supported GROUP BY commands;
 	//
 	// Returns an int32 bitmask value representing the supported commands.
@@ -206,18 +232,21 @@ const (
 	// - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
 	// Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
 	SqlInfo_SQL_SUPPORTED_GROUP_BY SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_NON_NULLABLE_COLUMNS SqlInfo = 524
+	//
 	// Retrieves the supported SQL grammar level as per the ODBC specification.
 	//
 	// Returns an int32 bitmask value representing the supported SQL grammar level.
@@ -234,6 +263,7 @@ const (
 	// - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
 	// Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
 	SqlInfo_SQL_SUPPORTED_GRAMMAR SqlInfo = 525
+	//
 	// Retrieves the supported ANSI92 SQL grammar level.
 	//
 	// Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
@@ -250,12 +280,14 @@ const (
 	// - 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`.
 	SqlInfo_SQL_ANSI92_SUPPORTED_LEVEL SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY SqlInfo = 527
+	//
 	// Retrieves the support level for SQL OUTER JOINs.
 	//
 	// Returns a int32 ordinal for the SQL ordering being used, as described in
@@ -265,14 +297,17 @@ const (
 	SqlInfo_SQL_SCHEMA_TERM SqlInfo = 529
 	// Retrieves a UTF-8 string with the preferred term for "procedure".
 	SqlInfo_SQL_PROCEDURE_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_AT_START SqlInfo = 532
+	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL schema.
@@ -289,6 +324,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SCHEMAS_SUPPORTED_ACTIONS SqlInfo = 533
+	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL catalog.
@@ -305,6 +341,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_CATALOGS_SUPPORTED_ACTIONS SqlInfo = 534
+	//
 	// Retrieves the supported SQL positioned commands.
 	//
 	// Returns an int32 bitmask value representing the supported SQL positioned commands.
@@ -317,12 +354,14 @@ const (
 	// - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
 	SqlInfo_SQL_SUPPORTED_POSITIONED_COMMANDS SqlInfo = 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.
 	SqlInfo_SQL_SELECT_FOR_UPDATE_SUPPORTED SqlInfo = 536
+	//
 	// Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
 	// are supported.
 	//
@@ -330,6 +369,7 @@ const (
 	// - 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.
 	SqlInfo_SQL_STORED_PROCEDURES_SUPPORTED SqlInfo = 537
+	//
 	// Retrieves the supported SQL subqueries.
 	//
 	// Returns an int32 bitmask value representing the supported SQL subqueries.
@@ -355,12 +395,14 @@ const (
 	// - ...
 	// Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
 	SqlInfo_SQL_SUPPORTED_SUBQUERIES SqlInfo = 538
+	//
 	// Retrieves a boolean value indicating whether correlated subqueries are supported.
 	//
 	// Returns:
 	// - false: if correlated subqueries are unsupported;
 	// - true: if correlated subqueries are supported.
 	SqlInfo_SQL_CORRELATED_SUBQUERIES_SUPPORTED SqlInfo = 539
+	//
 	// Retrieves the supported SQL UNIONs.
 	//
 	// Returns an int32 bitmask value representing the supported SQL UNIONs.
@@ -393,6 +435,7 @@ const (
 	SqlInfo_SQL_MAX_CONNECTIONS SqlInfo = 549
 	// Retrieves a int64 value the maximum number of characters allowed in a cursor name.
 	SqlInfo_SQL_MAX_CURSOR_NAME_LENGTH SqlInfo = 550
+	//
 	// Retrieves a int64 value representing the maximum number of bytes allowed for an index,
 	// including all of the parts of the index.
 	SqlInfo_SQL_MAX_INDEX_LENGTH SqlInfo = 551
@@ -404,15 +447,17 @@ const (
 	SqlInfo_SQL_MAX_CATALOG_NAME_LENGTH SqlInfo = 554
 	// Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
 	SqlInfo_SQL_MAX_ROW_SIZE SqlInfo = 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.
+	// - 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.
 	SqlInfo_SQL_MAX_ROW_SIZE_INCLUDES_BLOBS SqlInfo = 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.
 	SqlInfo_SQL_MAX_STATEMENT_LENGTH SqlInfo = 557
@@ -424,11 +469,13 @@ const (
 	SqlInfo_SQL_MAX_TABLES_IN_SELECT SqlInfo = 560
 	// Retrieves a int64 value representing the maximum number of characters allowed in a user name.
 	SqlInfo_SQL_MAX_USERNAME_LENGTH SqlInfo = 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.
 	SqlInfo_SQL_DEFAULT_TRANSACTION_ISOLATION SqlInfo = 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`.
 	//
@@ -436,6 +483,7 @@ const (
 	// - false: if transactions are unsupported;
 	// - true: if transactions are supported.
 	SqlInfo_SQL_TRANSACTIONS_SUPPORTED SqlInfo = 563
+	//
 	// Retrieves the supported transactions isolation levels.
 	//
 	// Returns an int32 bitmask value representing the supported transactions isolation levels.
@@ -462,6 +510,7 @@ const (
 	// - ...
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
 	SqlInfo_SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS SqlInfo = 564
+	//
 	// Retrieves a boolean value indicating whether a data definition statement within a transaction forces
 	// the transaction to commit.
 	//
@@ -469,12 +518,14 @@ const (
 	// - 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.
 	SqlInfo_SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT SqlInfo = 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.
 	SqlInfo_SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED SqlInfo = 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.
 	//
@@ -491,6 +542,7 @@ const (
 	// - ...
 	// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
 	SqlInfo_SQL_SUPPORTED_RESULT_SET_TYPES SqlInfo = 567
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
 	//
@@ -505,6 +557,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED SqlInfo = 568
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
 	//
@@ -519,6 +572,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY SqlInfo = 569
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
 	//
@@ -533,6 +587,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE SqlInfo = 570
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
 	//
@@ -547,29 +602,34 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE SqlInfo = 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.
 	SqlInfo_SQL_BATCH_UPDATES_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_SAVEPOINTS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_NAMED_PARAMETERS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_LOCATORS_UPDATE_COPY SqlInfo = 575
+	//
 	// Retrieves a boolean value indicating whether invoking user-defined or vendor functions
 	// using the stored procedure escape syntax is supported.
 	//
@@ -1642,7 +1702,7 @@ func (SqlSupportsConvert) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{16}
 }
 
-// *
+//*
 // The JDBC/ODBC-defined type of any object.
 // All the values here are the sames as in the JDBC and ODBC specs.
 type XdbcDataType int32
@@ -1757,7 +1817,7 @@ func (XdbcDataType) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{17}
 }
 
-// *
+//*
 // Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
 type XdbcDatetimeSubcode int32
 
@@ -1898,13 +1958,13 @@ func (XdbcDatetimeSubcode) EnumDescriptor() ([]byte, []int) {
 type Nullable int32
 
 const (
-	// *
+	//*
 	// Indicates that the fields does not allow the use of null values.
 	Nullable_NULLABILITY_NO_NULLS Nullable = 0
-	// *
+	//*
 	// Indicates that the fields allow the use of null values.
 	Nullable_NULLABILITY_NULLABLE Nullable = 1
-	// *
+	//*
 	// Indicates that nullability of the fields can not be determined.
 	Nullable_NULLABILITY_UNKNOWN Nullable = 2
 )
@@ -1953,21 +2013,21 @@ func (Nullable) EnumDescriptor() ([]byte, []int) {
 type Searchable int32
 
 const (
-	// *
+	//*
 	// Indicates that column can not be used in a WHERE clause.
 	Searchable_SEARCHABLE_NONE Searchable = 0
-	// *
+	//*
 	// Indicates that the column can be used in a WHERE clause if it is using a
 	// LIKE operator.
 	Searchable_SEARCHABLE_CHAR Searchable = 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.
+	// - Allowed operators: comparison, quantified comparison, BETWEEN,
+	//                      DISTINCT, IN, MATCH, and UNIQUE.
 	Searchable_SEARCHABLE_BASIC Searchable = 2
-	// *
+	//*
 	// Indicates that the column can be used in a WHERE clause using any operator.
 	Searchable_SEARCHABLE_FULL Searchable = 3
 )
@@ -2233,23 +2293,22 @@ func (ActionCancelQueryResult_CancelResult) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{29, 0}
 }
 
+//
 // 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.
+//  - 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>>
-//
+//  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.
 type CommandGetSqlInfo struct {
@@ -2257,6 +2316,7 @@ type CommandGetSqlInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
@@ -2316,62 +2376,61 @@ func (x *CommandGetSqlInfo) GetInfo() []uint32 {
 	return nil
 }
 
+//
 // 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.
+//  - 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).
-//
+//   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.
 type CommandGetXdbcTypeInfo struct {
@@ -2379,6 +2438,7 @@ type CommandGetXdbcTypeInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// Specifies the data type to search for the info.
 	DataType *int32 `protobuf:"varint,1,opt,name=data_type,json=dataType,proto3,oneof" json:"data_type,omitempty"`
 }
@@ -2422,17 +2482,16 @@ func (x *CommandGetXdbcTypeInfo) GetDataType() int32 {
 	return 0
 }
 
+//
 // 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.
+//  - 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
-//
+//  catalog_name: utf8 not null
 // >
 // The returned data should be ordered by catalog_name.
 type CommandGetCatalogs struct {
@@ -2473,18 +2532,17 @@ func (*CommandGetCatalogs) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{2}
 }
 
+//
 // 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.
+//  - 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
-//
+//  catalog_name: utf8,
+//  db_schema_name: utf8 not null
 // >
 // The returned data should be ordered by catalog_name, then db_schema_name.
 type CommandGetDbSchemas struct {
@@ -2492,15 +2550,17 @@ type CommandGetDbSchemas struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
 }
 
@@ -2550,56 +2610,58 @@ func (x *CommandGetDbSchemas) GetDbSchemaFilterPattern() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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.)
-//
+//  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.
-//
+//  - 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.
 type CommandGetTables struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	TableNameFilterPattern *string `protobuf:"bytes,3,opt,name=table_name_filter_pattern,json=tableNameFilterPattern,proto3,oneof" json:"table_name_filter_pattern,omitempty"`
+	//
 	// 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.
@@ -2675,18 +2737,17 @@ func (x *CommandGetTables) GetIncludeSchema() bool {
 	return false
 }
 
+//
 // 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.
+//  - 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
-//
+//  table_type: utf8 not null
 // >
 // The returned data should be ordered by table_type.
 type CommandGetTableTypes struct {
@@ -2727,21 +2788,20 @@ func (*CommandGetTableTypes) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{5}
 }
 
+//
 // 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.
+//  - 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
-//
+//  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.
 type CommandGetPrimaryKeys struct {
@@ -2749,10 +2809,12 @@ type CommandGetPrimaryKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -2814,29 +2876,28 @@ func (x *CommandGetPrimaryKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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.
@@ -2845,10 +2906,12 @@ type CommandGetExportedKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -2910,45 +2973,46 @@ func (x *CommandGetExportedKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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
+//    - 0 = CASCADE
+//    - 1 = RESTRICT
+//    - 2 = SET NULL
+//    - 3 = NO ACTION
+//    - 4 = SET DEFAULT
 type CommandGetImportedKeys struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -3010,67 +3074,66 @@ func (x *CommandGetImportedKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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
+//    - 0 = CASCADE
+//    - 1 = RESTRICT
+//    - 2 = SET NULL
+//    - 3 = NO ACTION
+//    - 4 = SET DEFAULT
 type CommandGetCrossReference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	// *
+	//*
 	// 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.
 	PkCatalog *string `protobuf:"bytes,1,opt,name=pk_catalog,json=pkCatalog,proto3,oneof" json:"pk_catalog,omitempty"`
-	// *
+	//*
 	// 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.
 	PkDbSchema *string `protobuf:"bytes,2,opt,name=pk_db_schema,json=pkDbSchema,proto3,oneof" json:"pk_db_schema,omitempty"`
-	// *
+	//*
 	// The parent table name. It cannot be null.
 	PkTable string `protobuf:"bytes,3,opt,name=pk_table,json=pkTable,proto3" json:"pk_table,omitempty"`
-	// *
+	//*
 	// 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.
 	FkCatalog *string `protobuf:"bytes,4,opt,name=fk_catalog,json=fkCatalog,proto3,oneof" json:"fk_catalog,omitempty"`
-	// *
+	//*
 	// 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.
 	FkDbSchema *string `protobuf:"bytes,5,opt,name=fk_db_schema,json=fkDbSchema,proto3,oneof" json:"fk_db_schema,omitempty"`
-	// *
+	//*
 	// The foreign table name. It cannot be null.
 	FkTable string `protobuf:"bytes,6,opt,name=fk_table,json=fkTable,proto3" json:"fk_table,omitempty"`
 }
@@ -3149,6 +3212,7 @@ func (x *CommandGetCrossReference) GetFkTable() string {
 	return ""
 }
 
+//
 // Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
 type ActionCreatePreparedStatementRequest struct {
 	state         protoimpl.MessageState
@@ -3208,6 +3272,7 @@ func (x *ActionCreatePreparedStatementRequest) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // An embedded message describing a Substrait plan to execute.
 type SubstraitPlan struct {
 	state         protoimpl.MessageState
@@ -3271,6 +3336,7 @@ func (x *SubstraitPlan) GetVersion() string {
 	return ""
 }
 
+//
 // Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
 type ActionCreatePreparedSubstraitPlanRequest struct {
 	state         protoimpl.MessageState
@@ -3330,6 +3396,7 @@ func (x *ActionCreatePreparedSubstraitPlanRequest) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
 //
 // The resultant PreparedStatement can be closed either:
@@ -3405,6 +3472,7 @@ func (x *ActionCreatePreparedStatementResult) GetParameterSchema() []byte {
 	return nil
 }
 
+//
 // Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
 // Closes server resources associated with the prepared statement handle.
 type ActionClosePreparedStatementRequest struct {
@@ -3455,6 +3523,7 @@ func (x *ActionClosePreparedStatementRequest) GetPreparedStatementHandle() []byt
 	return nil
 }
 
+//
 // Request message for the "BeginTransaction" action.
 // Begins a transaction.
 type ActionBeginTransactionRequest struct {
@@ -3495,6 +3564,7 @@ func (*ActionBeginTransactionRequest) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{15}
 }
 
+//
 // Request message for the "BeginSavepoint" action.
 // Creates a savepoint within a transaction.
 //
@@ -3557,6 +3627,7 @@ func (x *ActionBeginSavepointRequest) GetName() string {
 	return ""
 }
 
+//
 // The result of a "BeginTransaction" action.
 //
 // The transaction can be manipulated with the "EndTransaction" action, or
@@ -3612,6 +3683,7 @@ func (x *ActionBeginTransactionResult) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // The result of a "BeginSavepoint" action.
 //
 // The transaction can be manipulated with the "EndSavepoint" action.
@@ -3667,6 +3739,7 @@ func (x *ActionBeginSavepointResult) GetSavepointId() []byte {
 	return nil
 }
 
+//
 // Request message for the "EndTransaction" action.
 //
 // Commit (COMMIT) or rollback (ROLLBACK) the transaction.
@@ -3730,6 +3803,7 @@ func (x *ActionEndTransactionRequest) GetAction() ActionEndTransactionRequest_En
 	return ActionEndTransactionRequest_END_TRANSACTION_UNSPECIFIED
 }
 
+//
 // Request message for the "EndSavepoint" action.
 //
 // Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
@@ -3795,21 +3869,22 @@ func (x *ActionEndSavepointRequest) GetAction() ActionEndSavepointRequest_EndSav
 	return ActionEndSavepointRequest_END_SAVEPOINT_UNSPECIFIED
 }
 
+//
 // 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.
+//  - 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.
 type CommandStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3867,22 +3942,23 @@ func (x *CommandStatementQuery) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // 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.
+//  - 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.
 type CommandStatementSubstraitPlan struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3940,7 +4016,7 @@ func (x *CommandStatementSubstraitPlan) GetTransactionId() []byte {
 	return nil
 }
 
-// *
+//*
 // 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.
 type TicketStatementQuery struct {
@@ -3991,22 +4067,23 @@ func (x *TicketStatementQuery) GetStatementHandle() []byte {
 	return nil
 }
 
+//
 // 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.
-//   - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
-//   - GetFlightInfo: execute the prepared statement instance.
+//  - 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.
+//  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+//  - GetFlightInfo: execute the prepared statement instance.
 type CommandPreparedStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -4055,6 +4132,7 @@ func (x *CommandPreparedStatementQuery) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
+//
 // 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.
 type CommandStatementUpdate struct {
@@ -4114,6 +4192,7 @@ func (x *CommandStatementUpdate) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // 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.
@@ -4165,6 +4244,7 @@ func (x *CommandPreparedStatementUpdate) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
+//
 // Returned from the RPC call DoPut when a CommandStatementUpdate
 // CommandPreparedStatementUpdate was in the request, containing
 // results from the update.
@@ -4217,6 +4297,7 @@ func (x *DoPutUpdateResult) GetRecordCount() int64 {
 	return 0
 }
 
+//
 // Request message for the "CancelQuery" action.
 //
 // Explicitly cancel a running query.
@@ -4285,10 +4366,14 @@ func (x *ActionCancelQueryRequest) GetInfo() []byte {
 	return nil
 }
 
+//
 // 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.
+//
 // Deprecated: Do not use.
 type ActionCancelQueryResult struct {
 	state         protoimpl.MessageState
@@ -4339,7 +4424,7 @@ func (x *ActionCancelQueryResult) GetResult() ActionCancelQueryResult_CancelResu
 
 var file_FlightSql_proto_extTypes = []protoimpl.ExtensionInfo{
 	{
-		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
+		ExtendedType:  (*descriptor.MessageOptions)(nil),
 		ExtensionType: (*bool)(nil),
 		Field:         1000,
 		Name:          "arrow.flight.protocol.sql.experimental",
@@ -4348,7 +4433,7 @@ var file_FlightSql_proto_extTypes = []protoimpl.ExtensionInfo{
 	},
 }
 
-// Extension fields to descriptorpb.MessageOptions.
+// Extension fields to descriptor.MessageOptions.
 var (
 	// optional bool experimental = 1000;
 	E_Experimental = &file_FlightSql_proto_extTypes[0]
@@ -5163,7 +5248,7 @@ var file_FlightSql_proto_goTypes = []interface{}{
 	(*DoPutUpdateResult)(nil),                        // 52: arrow.flight.protocol.sql.DoPutUpdateResult
 	(*ActionCancelQueryRequest)(nil),                 // 53: arrow.flight.protocol.sql.ActionCancelQueryRequest
 	(*ActionCancelQueryResult)(nil),                  // 54: arrow.flight.protocol.sql.ActionCancelQueryResult
-	(*descriptorpb.MessageOptions)(nil),              // 55: google.protobuf.MessageOptions
+	(*descriptor.MessageOptions)(nil),                // 55: google.protobuf.MessageOptions
 }
 var file_FlightSql_proto_depIdxs = []int32{
 	36, // 0: arrow.flight.protocol.sql.ActionCreatePreparedSubstraitPlanRequest.plan:type_name -> arrow.flight.protocol.sql.SubstraitPlan
diff --git a/go/arrow/flight/internal/flight/Flight_grpc.pb.go b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
similarity index 93%
rename from go/arrow/flight/internal/flight/Flight_grpc.pb.go
rename to go/arrow/flight/gen/flight/Flight_grpc.pb.go
index 10fd285a5c10b..9613114448796 100644
--- a/go/arrow/flight/internal/flight/Flight_grpc.pb.go
+++ b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
@@ -1,4 +1,8 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.2.0
+// - protoc             v3.12.4
+// source: Flight.proto
 
 package flight
 
@@ -11,17 +15,20 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 
 // FlightServiceClient is the client API for FlightService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type FlightServiceClient interface {
+	//
 	// 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.
 	Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error)
+	//
 	// 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
@@ -29,6 +36,7 @@ type FlightServiceClient interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error)
+	//
 	// 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
@@ -40,16 +48,19 @@ type FlightServiceClient interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*FlightInfo, error)
+	//
 	// 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.
 	GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error)
+	//
 	// 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.
 	DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error)
+	//
 	// 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
@@ -57,12 +68,14 @@ type FlightServiceClient interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error)
+	//
 	// 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.
 	DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error)
+	//
 	// 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
@@ -70,6 +83,7 @@ type FlightServiceClient interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error)
+	//
 	// 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.
@@ -85,7 +99,7 @@ func NewFlightServiceClient(cc grpc.ClientConnInterface) FlightServiceClient {
 }
 
 func (c *flightServiceClient) Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -116,7 +130,7 @@ func (x *flightServiceHandshakeClient) Recv() (*HandshakeResponse, error) {
 }
 
 func (c *flightServiceClient) ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -166,7 +180,7 @@ func (c *flightServiceClient) GetSchema(ctx context.Context, in *FlightDescripto
 }
 
 func (c *flightServiceClient) DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -198,7 +212,7 @@ func (x *flightServiceDoGetClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -229,7 +243,7 @@ func (x *flightServiceDoPutClient) Recv() (*PutResult, error) {
 }
 
 func (c *flightServiceClient) DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -260,7 +274,7 @@ func (x *flightServiceDoExchangeClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -292,7 +306,7 @@ func (x *flightServiceDoActionClient) Recv() (*Result, error) {
 }
 
 func (c *flightServiceClient) ListActions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (FlightService_ListActionsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -327,11 +341,13 @@ func (x *flightServiceListActionsClient) Recv() (*ActionType, error) {
 // All implementations must embed UnimplementedFlightServiceServer
 // for forward compatibility
 type FlightServiceServer interface {
+	//
 	// 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.
 	Handshake(FlightService_HandshakeServer) error
+	//
 	// 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
@@ -339,6 +355,7 @@ type FlightServiceServer interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(*Criteria, FlightService_ListFlightsServer) error
+	//
 	// 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
@@ -350,16 +367,19 @@ type FlightServiceServer interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error)
+	//
 	// 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.
 	GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error)
+	//
 	// 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.
 	DoGet(*Ticket, FlightService_DoGetServer) error
+	//
 	// 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
@@ -367,12 +387,14 @@ type FlightServiceServer interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(FlightService_DoPutServer) error
+	//
 	// 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.
 	DoExchange(FlightService_DoExchangeServer) error
+	//
 	// 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
@@ -380,6 +402,7 @@ type FlightServiceServer interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(*Action, FlightService_DoActionServer) error
+	//
 	// 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.
@@ -427,8 +450,8 @@ type UnsafeFlightServiceServer interface {
 	mustEmbedUnimplementedFlightServiceServer()
 }
 
-func RegisterFlightServiceServer(s *grpc.Server, srv FlightServiceServer) {
-	s.RegisterService(&_FlightService_serviceDesc, srv)
+func RegisterFlightServiceServer(s grpc.ServiceRegistrar, srv FlightServiceServer) {
+	s.RegisterService(&FlightService_ServiceDesc, srv)
 }
 
 func _FlightService_Handshake_Handler(srv interface{}, stream grpc.ServerStream) error {
@@ -629,7 +652,10 @@ func (x *flightServiceListActionsServer) Send(m *ActionType) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-var _FlightService_serviceDesc = grpc.ServiceDesc{
+// FlightService_ServiceDesc is the grpc.ServiceDesc for FlightService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var FlightService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "arrow.flight.protocol.FlightService",
 	HandlerType: (*FlightServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index 1dd02d0defaed..c5e64986d5f78 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -22,7 +22,7 @@ import (
 	"os"
 	"os/signal"
 
-	"github.com/apache/arrow/go/v13/arrow/flight/internal/flight"
+	"github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 )
 

From eed5fe41a734da2d9806e369cbadc7894ba7f321 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Wed, 26 Jul 2023 21:10:32 -0400
Subject: [PATCH 056/749] GH-36885: [Java][Docs] Add substrait dependency to
 maven build profiles (#36899)

### Rationale for this change

The Java JNI dataset module recently included the Substrait module as a dependency. The dependency was added to the CI scripts, but not added to the build profiles and documentation yet.

### What changes are included in this PR?

- Update maven build profiles
- Update Java build documentation

### Are these changes tested?

I tested locally on MacOS and was able to reproduce + fix with this change.

### Are there any user-facing changes?

No
* Closes: #36885

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/java/building.rst | 2 ++
 java/pom.xml                             | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/docs/source/developers/java/building.rst b/docs/source/developers/java/building.rst
index 5b525d467731e..9d773f051451e 100644
--- a/docs/source/developers/java/building.rst
+++ b/docs/source/developers/java/building.rst
@@ -219,6 +219,7 @@ CMake
           -DARROW_ORC=ON \
           -DARROW_PARQUET=ON \
           -DARROW_S3=ON \
+          -DARROW_SUBSTRAIT=ON \
           -DARROW_USE_CCACHE=ON \
           -DCMAKE_BUILD_TYPE=Release \
           -DCMAKE_INSTALL_LIBDIR=lib/<your system's architecture> \
@@ -258,6 +259,7 @@ CMake
           -DARROW_ORC=OFF ^
           -DARROW_PARQUET=ON ^
           -DARROW_S3=ON ^
+          -DARROW_SUBSTRAIT=ON ^
           -DARROW_USE_CCACHE=ON ^
           -DARROW_WITH_BROTLI=ON ^
           -DARROW_WITH_LZ4=ON ^
diff --git a/java/pom.xml b/java/pom.xml
index ccb2a2b72d5e6..e997406f0238d 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -1022,6 +1022,7 @@
                     -DARROW_ORC=${ARROW_ORC}
                     -DARROW_PARQUET=${ARROW_PARQUET}
                     -DARROW_S3=ON
+                    -DARROW_SUBSTRAIT=${ARROW_DATASET}
                     -DARROW_USE_CCACHE=ON
                     -DCMAKE_BUILD_TYPE=Release
                     -DCMAKE_INSTALL_LIBDIR=lib/${os.detected.arch}
@@ -1131,6 +1132,7 @@
                     -DARROW_ORC=${ARROW_ORC}
                     -DARROW_PARQUET=${ARROW_PARQUET}
                     -DARROW_S3=ON
+                    -DARROW_SUBSTRAIT=${ARROW_DATASET}
                     -DARROW_USE_CCACHE=ON
                     -DARROW_WITH_BROTLI=ON
                     -DARROW_WITH_LZ4=ON

From 5e1c112e93092bcbf62c45b51fd6629463332c4d Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Wed, 26 Jul 2023 18:13:43 -0800
Subject: [PATCH 057/749] MINOR: [FlightRPC][C++][Python][Docs] Minor tweaks to
 docstrings (#36900)

### Rationale for this change

Improves language surrounding Flight Shutdown/Wait/Serve.

### What changes are included in this PR?

Just docstring tweaks.

### Are these changes tested?

No tests, just docstrings.

### Are there any user-facing changes?

n/a

Authored-by: Bryce Mecum <petridish@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/server.h | 20 +++++++++++++-------
 python/pyarrow/_flight.pyx    |  4 +++-
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/flight/server.h b/cpp/src/arrow/flight/server.h
index 5c15d8d5645d1..76f1a317068e6 100644
--- a/cpp/src/arrow/flight/server.h
+++ b/cpp/src/arrow/flight/server.h
@@ -202,8 +202,10 @@ class ARROW_FLIGHT_EXPORT FlightServerBase {
   Status SetShutdownOnSignals(const std::vector<int> sigs);
 
   /// \brief Start serving.
-  /// This method blocks until either Shutdown() is called or one of the signals
-  /// registered in SetShutdownOnSignals() is received.
+  /// This method blocks until the server shuts down.
+  ///
+  /// The server will start to shut down when either Shutdown() is called
+  /// or one of the signals registered in SetShutdownOnSignals() is received.
   Status Serve();
 
   /// \brief Query whether Serve() was interrupted by a signal.
@@ -212,14 +214,18 @@ class ARROW_FLIGHT_EXPORT FlightServerBase {
   /// \return int the signal number that interrupted Serve(), if any, otherwise 0
   int GotSignal() const;
 
-  /// \brief Shut down the server. Can be called from signal handler or another
-  /// thread while Serve() blocks. Optionally a deadline can be set. Once the
-  /// the deadline expires server will wait until remaining running calls
-  /// complete.
+  /// \brief Shut down the server, blocking until current requests finish.
+  ///
+  /// Can be called from a signal handler or another thread while Serve()
+  /// blocks. Optionally a deadline can be set. Once the the deadline expires
+  /// server will wait until remaining running calls complete.
   ///
+  /// Should only be called once.
   Status Shutdown(const std::chrono::system_clock::time_point* deadline = NULLPTR);
 
-  /// \brief Block until server is terminated with Shutdown.
+  /// \brief Block until server shuts down with Shutdown.
+  ///
+  /// Does not respond to signals like Serve().
   Status Wait();
 
   // Implement these methods to create your own server. The default
diff --git a/python/pyarrow/_flight.pyx b/python/pyarrow/_flight.pyx
index 6f5cd03cd56bf..c9f5526754e3d 100644
--- a/python/pyarrow/_flight.pyx
+++ b/python/pyarrow/_flight.pyx
@@ -3016,7 +3016,7 @@ cdef class FlightServerBase(_Weakrefable):
     def serve(self):
         """Block until the server shuts down.
 
-        This method only returns if shutdown() is called or a signal a
+        This method only returns if shutdown() is called or a signal is
         received.
         """
         if self.server.get() == nullptr:
@@ -3041,6 +3041,8 @@ cdef class FlightServerBase(_Weakrefable):
         method, as then the server will block forever waiting for that
         request to finish. Instead, call this method from a background
         thread.
+
+        This method should only be called once.
         """
         # Must not hold the GIL: shutdown waits for pending RPCs to
         # complete. Holding the GIL means Python-implemented Flight

From 0f291473650ac0fa5f95bccb8af0d0b8029c4be2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 27 Jul 2023 22:13:29 +0900
Subject: [PATCH 058/749] GH-36860: [C++] Report CMake error when system
 Protobuf exists but system gRPC doesn't exist (#36904)

### Rationale for this change

We require system gRPC when system Protobuf is found to avoid underlying library (Abseil) mismatch. We should report it as an error on `cmake...` time instead of build time.

### What changes are included in this PR?

Always call `find_package_handle_standard_args()` to report an error for the case.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #36860

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/cmake_modules/FindgRPCAlt.cmake | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/cpp/cmake_modules/FindgRPCAlt.cmake b/cpp/cmake_modules/FindgRPCAlt.cmake
index 81d8cf7ca68ee..2ff10dbc23dd2 100644
--- a/cpp/cmake_modules/FindgRPCAlt.cmake
+++ b/cpp/cmake_modules/FindgRPCAlt.cmake
@@ -57,13 +57,15 @@ if(GRPCPP_PC_FOUND)
                HINTS ${GRPCPP_PC_PREFIX}
                NO_DEFAULT_PATH
                PATH_SUFFIXES "bin")
-  set(gRPCAlt_FIND_PACKAGE_ARGS gRPCAlt REQUIRED_VARS GRPCPP_IMPORTED_LOCATION
-                                GRPC_CPP_PLUGIN)
-  if(gRPCAlt_VERSION)
-    list(APPEND gRPCAlt_FIND_PACKAGE_ARGS VERSION_VAR gRPCAlt_VERSION)
-  endif()
-  find_package_handle_standard_args(${gRPCAlt_FIND_PACKAGE_ARGS})
+endif()
+set(gRPCAlt_FIND_PACKAGE_ARGS gRPCAlt REQUIRED_VARS GRPCPP_IMPORTED_LOCATION
+                              GRPC_CPP_PLUGIN)
+if(gRPCAlt_VERSION)
+  list(APPEND gRPCAlt_FIND_PACKAGE_ARGS VERSION_VAR gRPCAlt_VERSION)
+endif()
+find_package_handle_standard_args(${gRPCAlt_FIND_PACKAGE_ARGS})
 
+if(gRPCAlt_FOUND)
   # gRPC does not expose the reflection library via pkg-config, but it should be alongside the main library
   get_filename_component(GRPCPP_IMPORTED_DIRECTORY ${GRPCPP_IMPORTED_LOCATION} DIRECTORY)
   if(ARROW_GRPC_USE_SHARED)
@@ -77,11 +79,7 @@ if(GRPCPP_PC_FOUND)
                NAMES grpc++_reflection ${GRPCPP_REFLECTION_LIB_NAME}
                PATHS ${GRPCPP_IMPORTED_DIRECTORY}
                NO_DEFAULT_PATH)
-else()
-  set(gRPCAlt_FOUND FALSE)
-endif()
 
-if(gRPCAlt_FOUND)
   add_library(gRPC::grpc++ UNKNOWN IMPORTED)
   set_target_properties(gRPC::grpc++
                         PROPERTIES IMPORTED_LOCATION "${GRPCPP_IMPORTED_LOCATION}"

From bedc1e7cbb5d07469dd976350763ab4e93ed64ad Mon Sep 17 00:00:00 2001
From: Elliott Brossard <64754120+sfc-gh-ebrossard@users.noreply.github.com>
Date: Thu, 27 Jul 2023 10:48:26 -0700
Subject: [PATCH 059/749] GH-36913: [C++] Skip empty buffer concatenation to
 fix UBSan error (#36914)

### Rationale for this change

This is a trivial fix for a UBSan error in calls to `ConcatenateBuffers` with an empty buffer that has a null data pointer.

### What changes are included in this PR?

Conditional call to `std::memcpy` based on whether the buffer's length is 0.

### Are these changes tested?

Test added in buffer_test.cc.

### Are there any user-facing changes?

No
* Closes: #36913

Lead-authored-by: Elliott Brossard <elliott.brossard@snowflake.com>
Co-authored-by: Elliott Brossard <64754120+sfc-gh-ebrossard@users.noreply.github.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/buffer.cc      | 7 +++++--
 cpp/src/arrow/buffer_test.cc | 9 +++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/buffer.cc b/cpp/src/arrow/buffer.cc
index 135aa0c5328ad..99dc29cfe5296 100644
--- a/cpp/src/arrow/buffer.cc
+++ b/cpp/src/arrow/buffer.cc
@@ -213,8 +213,11 @@ Result<std::shared_ptr<Buffer>> ConcatenateBuffers(
   ARROW_ASSIGN_OR_RAISE(auto out, AllocateBuffer(out_length, pool));
   auto out_data = out->mutable_data();
   for (const auto& buffer : buffers) {
-    std::memcpy(out_data, buffer->data(), buffer->size());
-    out_data += buffer->size();
+    // Passing nullptr to std::memcpy is undefined behavior, so skip empty buffers
+    if (buffer->size() != 0) {
+      std::memcpy(out_data, buffer->data(), buffer->size());
+      out_data += buffer->size();
+    }
   }
   return std::move(out);
 }
diff --git a/cpp/src/arrow/buffer_test.cc b/cpp/src/arrow/buffer_test.cc
index 3dd95cb8af5c6..13f6ea63b5e62 100644
--- a/cpp/src/arrow/buffer_test.cc
+++ b/cpp/src/arrow/buffer_test.cc
@@ -1014,4 +1014,13 @@ TYPED_TEST(TypedTestBuffer, ResizeOOM) {
 #endif
 }
 
+TEST(TestBufferConcatenation, EmptyBuffer) {
+  // GH-36913: UB shouldn't be triggered by copying from a null pointer
+  const std::string contents = "hello, world";
+  auto buffer = std::make_shared<Buffer>(contents);
+  auto empty_buffer = std::make_shared<Buffer>(/*data=*/nullptr, /*size=*/0);
+  ASSERT_OK_AND_ASSIGN(auto result, ConcatenateBuffers({buffer, empty_buffer}));
+  AssertMyBufferEqual(*result, contents);
+}
+
 }  // namespace arrow

From 5b744ab0e854f494f8df145b27dc30236df13221 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 28 Jul 2023 09:50:29 +0900
Subject: [PATCH 060/749] GH-36922: [CI][C++][Windows] Search OpenSSL from PATH
 (#36923)

### Rationale for this change

It seems that OpenSSL install script adds the OpenSSL install folder to `PATH`:
https://github.com/actions/runner-images/blob/665e71067ff126acea71e7d93715c83db038597f/images/win/scripts/Installers/Install-OpenSSL.ps1#L37

If OpenSSL install folder exists in `PATH`, we don't need to specify `OPENSSL_ROOT_DIR` explicitly. Because `find_*` such as [`find_library()`](https://cmake.org/cmake/help/latest/command/find_library.html) searches path in `PATH` by default:

> On Windows hosts: `<prefix>/lib/<arch>` if [`CMAKE_LIBRARY_ARCHITECTURE`](https://cmake.org/cmake/help/latest/variable/CMAKE_LIBRARY_ARCHITECTURE.html#variable:CMAKE_LIBRARY_ARCHITECTURE) is set, and `<prefix>/lib` for each `<prefix>/[s]bin` in `PATH`, and `<entry>/lib` for other entries in `PATH`.

### What changes are included in this PR?

Remove `OPENSSL_ROOT_DIR`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36922

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/cpp.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 63a16c8c114ba..cd12be11488bb 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -269,8 +269,6 @@ jobs:
       CMAKE_INSTALL_LIBDIR: bin
       CMAKE_INSTALL_PREFIX: /usr
       CMAKE_UNITY_BUILD: ON
-      OPENSSL_ROOT_DIR: >-
-        C:\Program Files\OpenSSL-Win64
       NPROC: 3
     steps:
       - name: Disable Crash Dialogs

From e53a2e08a820c76aacfc6331855fd32a3073629c Mon Sep 17 00:00:00 2001
From: Fokko Driesprong <fokko@apache.org>
Date: Fri, 28 Jul 2023 03:08:10 +0200
Subject: [PATCH 061/749] GH-36843: [Python][Docs] Add dict to docstring
 (#36842)

### Rationale for this change

We can pass `dict[str, Expression]` as columns too.

### What changes are included in this PR?

Add `dic[str, Expression]`.

### Are these changes tested?

No.

### Are there any user-facing changes?

Yes.

* Closes: #36843

Lead-authored-by: Fokko Driesprong <fokko@tabular.io>
Co-authored-by: Fokko Driesprong <fokko@apache.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/_dataset.pyx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/python/pyarrow/_dataset.pyx b/python/pyarrow/_dataset.pyx
index 925565804f63e..badf6e4a4c5dc 100644
--- a/python/pyarrow/_dataset.pyx
+++ b/python/pyarrow/_dataset.pyx
@@ -3337,7 +3337,7 @@ cdef class Scanner(_Weakrefable):
         ----------
         dataset : Dataset
             Dataset to scan.
-        columns : list of str, default None
+        columns : list[str] or dict[str, Expression], default None
             The columns to project. This can be a list of column names to
             include (order and duplicates will be preserved), or a dictionary
             with {new_column_name: expression} values for more advanced
@@ -3416,7 +3416,7 @@ cdef class Scanner(_Weakrefable):
             fragment to scan.
         schema : Schema, optional
             The schema of the fragment.
-        columns : list of str, default None
+        columns : list[str] or dict[str, Expression], default None
             The columns to project. This can be a list of column names to
             include (order and duplicates will be preserved), or a dictionary
             with {new_column_name: expression} values for more advanced
@@ -3502,7 +3502,7 @@ cdef class Scanner(_Weakrefable):
             The iterator of Batches.
         schema : Schema
             The schema of the batches.
-        columns : list of str, default None
+        columns : list[str] or dict[str, Expression], default None
             The columns to project. This can be a list of column names to
             include (order and duplicates will be preserved), or a dictionary
             with {new_column_name: expression} values for more advanced

From 40debb2149dbecf7e4bd94c3c77c6d5451b76b03 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 27 Jul 2023 21:28:02 -0400
Subject: [PATCH 062/749] GH-36920: [Java][Docs] Add ARROW_JSON var to maven
 build profile (#36921)

### Rationale for this change

JSON support in the datasets module was recently introduced. Update the maven build profile and build documentation to reflect this. Similar to https://github.com/apache/arrow/pull/36899

### What changes are included in this PR?

* update maven build profile
* update build docs

### Are these changes tested?

Yes, tested locally on M1 Mac.

### Are there any user-facing changes?

No
* Closes: #36920

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/java/building.rst | 2 ++
 java/pom.xml                             | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/docs/source/developers/java/building.rst b/docs/source/developers/java/building.rst
index 9d773f051451e..5dd3a979d8293 100644
--- a/docs/source/developers/java/building.rst
+++ b/docs/source/developers/java/building.rst
@@ -216,6 +216,7 @@ CMake
           -DARROW_FILESYSTEM=ON \
           -DARROW_GANDIVA=ON \
           -DARROW_GANDIVA_STATIC_LIBSTDCPP=ON \
+          -DARROW_JSON=ON \
           -DARROW_ORC=ON \
           -DARROW_PARQUET=ON \
           -DARROW_S3=ON \
@@ -256,6 +257,7 @@ CMake
           -DARROW_DATASET=ON ^
           -DARROW_DEPENDENCY_USE_SHARED=OFF ^
           -DARROW_FILESYSTEM=ON ^
+          -DARROW_JSON=ON ^
           -DARROW_ORC=OFF ^
           -DARROW_PARQUET=ON ^
           -DARROW_S3=ON ^
diff --git a/java/pom.xml b/java/pom.xml
index e997406f0238d..7f8de003a3355 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -1019,6 +1019,7 @@
                     -DARROW_FILESYSTEM=ON
                     -DARROW_GANDIVA=${ARROW_GANDIVA}
                     -DARROW_GANDIVA_STATIC_LIBSTDCPP=ON
+                    -DARROW_JSON=${ARROW_DATASET}
                     -DARROW_ORC=${ARROW_ORC}
                     -DARROW_PARQUET=${ARROW_PARQUET}
                     -DARROW_S3=ON
@@ -1129,6 +1130,7 @@
                     -DARROW_DATASET=ON
                     -DARROW_DEPENDENCY_USE_SHARED=OFF
                     -DARROW_FILESYSTEM=ON
+                    -DARROW_JSON=${ARROW_DATASET}
                     -DARROW_ORC=${ARROW_ORC}
                     -DARROW_PARQUET=${ARROW_PARQUET}
                     -DARROW_S3=ON

From 47e438adf74d0c38068d9fd31fca083c650209c8 Mon Sep 17 00:00:00 2001
From: h-vetinari <h.vetinari@gmx.com>
Date: Fri, 28 Jul 2023 13:31:01 +1100
Subject: [PATCH 063/749] GH-15017: [Python] Harden test_memory.py for use with
 ARROW_USE_GLOG=ON (#36901)

Accept output pattern for ARROW_USE_GLOG=ON too.

* Closes: #15017

Lead-authored-by: H. Vetinari <h.vetinari@gmx.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/conda-recipes/arrow-cpp/meta.yaml |  2 --
 python/pyarrow/tests/test_memory.py         | 10 ++++++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
index e61034c3075b3..ac4b29eb5ee7e 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
+++ b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
@@ -403,8 +403,6 @@ outputs:
         {% set tests_to_skip = tests_to_skip + " or test_safe_cast_from_float_with_nans_to_int" %}  # [ppc64le]
         # gandiva tests are segfaulting on ppc
         {% set tests_to_skip = tests_to_skip + " or test_float_with_null_as_integer" %}   # [ppc64le]
-        # "Unsupported backend 'nonexistent' specified in ARROW_DEFAULT_MEMORY_POOL"
-        {% set tests_to_skip = tests_to_skip + " or (test_memory and test_env_var)" %}    # [unix]
         # test is broken; header is in $PREFIX, not $SP_DIR
         {% set tests_to_skip = tests_to_skip + " or (test_misc and test_get_include)" %}  # [unix]
         # flaky tests that fail occasionally
diff --git a/python/pyarrow/tests/test_memory.py b/python/pyarrow/tests/test_memory.py
index 092c50de33b90..d9fdeb152c35e 100644
--- a/python/pyarrow/tests/test_memory.py
+++ b/python/pyarrow/tests/test_memory.py
@@ -134,8 +134,14 @@ def check_env_var(name, expected, *, expect_warning=False):
         res.check_returncode()  # fail
     errlines = res.stderr.splitlines()
     if expect_warning:
-        assert len(errlines) == 1
-        assert f"Unsupported backend '{name}'" in errlines[0]
+        assert len(errlines) in (1, 2)
+        if len(errlines) == 1:
+            # ARROW_USE_GLOG=OFF
+            assert f"Unsupported backend '{name}'" in errlines[0]
+        else:
+            # ARROW_USE_GLOG=ON
+            assert "InitGoogleLogging()" in errlines[0]
+            assert f"Unsupported backend '{name}'" in errlines[1]
     else:
         assert len(errlines) == 0
 

From 8c4941b879670ec9dc3608b77637f44fddf32178 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 28 Jul 2023 09:34:29 +0100
Subject: [PATCH 064/749] GH-36883: [R] Remove version number which triggers
 CRAN warning (#36884)

### What changes are included in this PR?

Updates package version number to be character not numeric

### Are these changes tested?

No, is configure scripts

### Are there any user-facing changes?

No
* Closes: #36883

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tools/nixlibs.R | 2 +-
 r/tools/winlibs.R | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 8b353fd09bb5a..90ea868ea3491 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -30,7 +30,7 @@ if (test_mode && is.na(VERSION)) {
 dev_version <- package_version(VERSION)[1, 4]
 
 # Small dev versions are added for R-only changes during CRAN submission.
-if (is.na(dev_version) || dev_version < 100) {
+if (is.na(dev_version) || dev_version < "100") {
   VERSION <- package_version(VERSION)[1, 1:3]
   arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
 } else {
diff --git a/r/tools/winlibs.R b/r/tools/winlibs.R
index d941da4baa61f..b554770e40c9b 100644
--- a/r/tools/winlibs.R
+++ b/r/tools/winlibs.R
@@ -53,7 +53,7 @@ if (!file.exists(sprintf("windows/arrow-%s/include/arrow/api.h", VERSION))) {
     dev_version <- package_version(VERSION)[1, 4]
 
     # Small dev versions are added for R-only changes during CRAN submission.
-    if (is.na(dev_version) || dev_version < 100) {
+    if (is.na(dev_version) || dev_version < "100") {
       VERSION <- package_version(VERSION)[1, 1:3]
       get_file(rwinlib, VERSION)
 

From 6b1c7234f7e7fd1d0b543a0513deb3f79f1af131 Mon Sep 17 00:00:00 2001
From: panbingkun <84731559@qq.com>
Date: Fri, 28 Jul 2023 22:47:42 +0800
Subject: [PATCH 065/749] GH-36928: [Java] Make it run well with the netty
 newest version 4.1.96 (#36926)

When I used `netty arrow memory 13.0.0` and `netty 4.1.96.Final` in Spark, the following error occurred,
Because `netty 4.1.96.Final` version has revert some modifications, in order to ensure that `netty arrow memory 13.0.0` works well with ``netty 4.1.96.Final`` version, I suggest making similar modifications here.
1.Compilation errors are as follows:
https://ci.appveyor.com/project/ApacheSoftwareFoundation/spark/builds/47657403
<img width="955" alt="image" src="https://github.com/apache/arrow/assets/15246973/e7ee2da9-97c0-474c-a62d-5821858e361f">

2.Some modifications have been reverted in `netty 4.1.96.Final` as follows:
<img width="884" alt="image" src="https://github.com/apache/arrow/assets/15246973/0226685a-cfa3-4b8b-b114-23ad8d027c05">
<img width="907" alt="image" src="https://github.com/apache/arrow/assets/15246973/a6ea21a0-8531-42b6-ab9d-25eaab1c7fde">
https://netty.io/news/2023/07/27/4-1-96-Final.html
https://github.com/netty/netty/pull/13510
* Closes: #36928

Authored-by: panbingkun <pbk1982@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../src/main/java/io/netty/buffer/PooledByteBufAllocatorL.java  | 2 +-
 java/pom.xml                                                    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/java/memory/memory-netty/src/main/java/io/netty/buffer/PooledByteBufAllocatorL.java b/java/memory/memory-netty/src/main/java/io/netty/buffer/PooledByteBufAllocatorL.java
index 870114d7db1b5..06c6669cfd162 100644
--- a/java/memory/memory-netty/src/main/java/io/netty/buffer/PooledByteBufAllocatorL.java
+++ b/java/memory/memory-netty/src/main/java/io/netty/buffer/PooledByteBufAllocatorL.java
@@ -161,7 +161,7 @@ public InnerAllocator() {
     }
 
     private UnsafeDirectLittleEndian newDirectBufferL(int initialCapacity, int maxCapacity) {
-      PoolArenasCache cache = threadCache();
+      PoolThreadCache cache = threadCache();
       PoolArena<ByteBuffer> directArena = cache.directArena;
 
       if (directArena != null) {
diff --git a/java/pom.xml b/java/pom.xml
index 7f8de003a3355..d6b37c7df969d 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -33,7 +33,7 @@
     <dep.junit.jupiter.version>5.9.0</dep.junit.jupiter.version>
     <dep.slf4j.version>1.7.25</dep.slf4j.version>
     <dep.guava-bom.version>31.1-jre</dep.guava-bom.version>
-    <dep.netty-bom.version>4.1.94.Final</dep.netty-bom.version>
+    <dep.netty-bom.version>4.1.96.Final</dep.netty-bom.version>
     <dep.grpc-bom.version>1.56.0</dep.grpc-bom.version>
     <dep.protobuf-bom.version>3.23.1</dep.protobuf-bom.version>
     <dep.jackson-bom.version>2.15.1</dep.jackson-bom.version>

From 2a9c8b1bda41cb87fb211ad209347ca2259253aa Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 31 Jul 2023 06:11:06 +0900
Subject: [PATCH 066/749] GH-36837: [CI][RPM] Use multi-cores to install gems
 (#36838)

### Rationale for this change

We may reduce test time by using multi-cores to install gems.

### What changes are included in this PR?

`gem install` with `MAKEFLAGS=-j$(nproc)` uses multi-cores when building extension libraries.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36837

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/verify-yum.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/release/verify-yum.sh b/dev/release/verify-yum.sh
index 03aa8e9dccc75..55fc0c1735931 100755
--- a/dev/release/verify-yum.sh
+++ b/dev/release/verify-yum.sh
@@ -234,7 +234,7 @@ if [ "${have_glib}" = "yes" ]; then
 
   if [ "${have_ruby}" = "yes" ]; then
     ${install_command} "${ruby_devel_packages[@]}"
-    gem install gobject-introspection
+    MAKEFLAGS="-j$(nproc)" gem install gobject-introspection
     ruby -r gi -e "p GI.load('Arrow')"
   fi
   echo "::endgroup::"

From af23f6a2e8ece6211b087b0e4f24b9daaffbb8a9 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 31 Jul 2023 06:11:32 +0900
Subject: [PATCH 067/749] GH-36685: [R][C++] Fix illegal opcode failure with
 Homebrew (#36705)

### Rationale for this change

Summary of this problem: https://github.com/apache/arrow/issues/31132#issuecomment-1378082076

Why this problem is happen again? Because I removed `ENV["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"` in #36583. The solution we chose by #14342 was forcing to use `-O2` for SIMD related code. It works for `-DCMAKE_BUILD_TYPE=MinSizeRel` but it doesn't work for Homebrew.

Because Homebrew's CC https://github.com/Homebrew/brew/blob/master/Library/Homebrew/shims/super/cc forces to use the same `-O` flag. The default is `-Os`. If we specify `-O2`, Homebrew's CC replaces it to `-Os`. If we use  `ENV["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"`, Homebrew's CC always use `-O2`. So the solution we chose by #14342 isn't used for Homebrew.

But Homebrew thinks that `ENV["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"` is a workaround. So we need another solution for Homebrew.

Here are candidate solutions:
1. `-DARROW_RUNTIME_SIMD_LEVEL=NONE`
2. Remove `ENV.runtime_cpu_detection if Hardware::CPU.intel?`

"1. `-DARROW_RUNTIME_SIMD_LEVEL=NONE`" works because we don't use the runtime SIMD dispatch feature (the problematic feature) entirely.

"2. Remove `ENV.runtime_cpu_detection if Hardware::CPU.intel?`" works but I don't know why... If `ENV.runtime_cpu_detection` is called, Homebrew's CC stops replacing `-march=*`. If we call `ENV.runtime_cpu_detection`, `-march=haswell` is used for AVX2 related code and `-march=skylake-avx512` is used for AVX512 including BMI2 related code. If we don't call `ENV.runtime_cpu_detection`, `-march=nehalem` is always used. (Note that SIMD related flags such as `-mbmi2` aren't removed by Homebrew's CC. So I think that SIMD is enabled.) I don't know why but "the one-definition-rule violation" (see the summary for details: https://github.com/apache/arrow/issues/31132#issuecomment-1378082076 ) isn't happen.

FYI: CPU info for GitHub Actions macOS hosted-runner:

```console
$ sysctl hw.optional machdep.cpu
hw.optional.adx: 0
hw.optional.aes: 1
hw.optional.avx1_0: 1
hw.optional.avx2_0: 0
hw.optional.avx512bw: 0
hw.optional.avx512cd: 0
hw.optional.avx512dq: 0
hw.optional.avx512f: 0
hw.optional.avx512ifma: 0
hw.optional.avx512vbmi: 0
hw.optional.avx512vl: 0
hw.optional.bmi1: 0
hw.optional.bmi2: 0
hw.optional.enfstrg: 0
hw.optional.f16c: 1
hw.optional.floatingpoint: 1
hw.optional.fma: 0
hw.optional.hle: 0
hw.optional.mmx: 1
hw.optional.mpx: 0
hw.optional.rdrand: 1
hw.optional.rtm: 0
hw.optional.sgx: 0
hw.optional.sse: 1
hw.optional.sse2: 1
hw.optional.sse3: 1
hw.optional.sse4_1: 1
hw.optional.sse4_2: 1
hw.optional.supplementalsse3: 1
hw.optional.x86_64: 1
machdep.cpu.address_bits.physical: 43
machdep.cpu.address_bits.virtual: 48
machdep.cpu.arch_perf.events: 127
machdep.cpu.arch_perf.events_number: 7
machdep.cpu.arch_perf.fixed_number: 0
machdep.cpu.arch_perf.fixed_width: 0
machdep.cpu.arch_perf.number: 4
machdep.cpu.arch_perf.version: 1
machdep.cpu.arch_perf.width: 48
machdep.cpu.cache.L2_associativity: 8
machdep.cpu.cache.linesize: 64
machdep.cpu.cache.size: 256
machdep.cpu.mwait.extensions: 3
machdep.cpu.mwait.linesize_max: 4096
machdep.cpu.mwait.linesize_min: 64
machdep.cpu.mwait.sub_Cstates: 16
machdep.cpu.thermal.ACNT_MCNT: 0
machdep.cpu.thermal.core_power_limits: 0
machdep.cpu.thermal.dynamic_acceleration: 0
machdep.cpu.thermal.energy_policy: 0
machdep.cpu.thermal.fine_grain_clock_mod: 0
machdep.cpu.thermal.hardware_feedback: 0
machdep.cpu.thermal.invariant_APIC_timer: 1
machdep.cpu.thermal.package_thermal_intr: 0
machdep.cpu.thermal.sensor: 0
machdep.cpu.thermal.thresholds: 0
machdep.cpu.tlb.data.small: 64
machdep.cpu.tlb.inst.large: 8
machdep.cpu.tlb.inst.small: 64
machdep.cpu.tlb.shared: 512
machdep.cpu.tsc_ccc.denominator: 0
machdep.cpu.tsc_ccc.numerator: 0
machdep.cpu.xsave.extended_state: 7 832 832 0
machdep.cpu.xsave.extended_state1: 0 0 0 0
machdep.cpu.brand: 0
machdep.cpu.brand_string: Intel(R) Xeon(R) CPU E5-1650 v2 @ 3.50GHz
machdep.cpu.core_count: 3
machdep.cpu.cores_per_package: 4
machdep.cpu.extfamily: 0
machdep.cpu.extfeature_bits: 4967106816
machdep.cpu.extfeatures: SYSCALL XD EM64T LAHF RDTSCP TSCI
machdep.cpu.extmodel: 3
machdep.cpu.family: 6
machdep.cpu.feature_bits: 18427078393948011519
machdep.cpu.features: FPU VME DE PSE TSC MSR PAE MCE CX8 APIC SEP MTRR PGE MCA CMOV PAT PSE36 CLFSH MMX FXSR SSE SSE2 SS HTT SSE3 PCLMULQDQ MON VMX SSSE3 CX16 SSE4.1 SSE4.2 x2APIC POPCNT AES VMM PCID XSAVE OSXSAVE TSCTMR AVX1.0 RDRAND F16C
machdep.cpu.leaf7_feature_bits: 643 0
machdep.cpu.leaf7_feature_bits_edx: 3154117632
machdep.cpu.leaf7_features: RDWRFSGS TSC_THREAD_OFFSET SMEP ERMS MDCLEAR IBRS STIBP L1DF ACAPMSR SSBD
machdep.cpu.logical_per_package: 4
machdep.cpu.max_basic: 13
machdep.cpu.max_ext: 2147483656
machdep.cpu.microcode_version: 1070
machdep.cpu.model: 58
machdep.cpu.processor_flag: 0
machdep.cpu.signature: 198313
machdep.cpu.stepping: 9
machdep.cpu.thread_count: 3
machdep.cpu.vendor: GenuineIntel
```

### What changes are included in this PR?

"1. `-DARROW_RUNTIME_SIMD_LEVEL=NONE`" because it's straightforward and  "2. Remove `ENV.runtime_cpu_detection if Hardware::CPU.intel?`" may also disable runtime SIMD dispatch implicitly.

This also adds the following debug information for easy to debug in future:
* CPU information for GitHub Actions runner
* Homebrew's build logs

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #36685

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/homebrew-formulae/apache-arrow.rb |  8 +++++++-
 dev/tasks/macros.jinja                      |  4 +++-
 dev/tasks/r/github.macos.brew.yml           | 20 ++++++++++++++++----
 3 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index 9086fdaae4ab4..f5d7ff36ea041 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -57,7 +57,8 @@ class ApacheArrow < Formula
   fails_with gcc: "5"
 
   def install
-    # https://github.com/Homebrew/homebrew-core/issues/76537
+    # This isn't for https://github.com/Homebrew/homebrew-core/issues/76537 .
+    # This may improve performance.
     ENV.runtime_cpu_detection if Hardware::CPU.intel?
 
     # link against system libc++ instead of llvm provided libc++
@@ -90,6 +91,11 @@ def install
       -DARROW_WITH_ZSTD=ON
       -DPARQUET_BUILD_EXECUTABLES=ON
     ]
+    # Disable runtime SIMD dispatch. It may cause "illegal opcode"
+    # error on Intel Mac because of one-definition-rule violation.
+    #
+    # https://github.com/apache/arrow/issues/36685
+    args << "-DARROW_RUNTIME_SIMD_LEVEL=NONE" if OS.mac? and Hardware::CPU.intel?
 
     system "cmake", "-S", "cpp", "-B", "build", *args, *std_cmake_args
     system "cmake", "--build", "build"
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 475494af18ce6..1f2f9a72975eb 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -214,6 +214,7 @@ on:
       # see https://github.com/actions/runner-images/issues/6868
       brew install --overwrite python@3.11 python@3.10
 
+      set -x
       ARROW_GLIB_FORMULA=$(echo ${ARROW_FORMULA} | sed -e 's/\.rb/-glib.rb/')
       echo "ARROW_GLIB_FORMULA=${ARROW_GLIB_FORMULA}" >> ${GITHUB_ENV}
       for formula in ${ARROW_FORMULA} ${ARROW_GLIB_FORMULA}; do
@@ -223,11 +224,12 @@ on:
         # Pin the current commit in the formula to test so that
         # we're not always pulling from the tip of the default branch
         sed -i '' -E \
-          -e 's@https://github.com/apache/arrow.git"$@{{ arrow.remote }}.git", revision: "{{ arrow.head }}"@' \
+          -e 's@https://github.com/apache/arrow.git", branch: "main"$@{{ arrow.remote }}.git", revision: "{{ arrow.head }}"@' \
           ${formula}
         # Sometimes crossbow gives a remote URL with .git and sometimes not.
         # Make sure there's only one
         sed -i '' -E -e 's@.git.git@.git@' ${formula}
+        cat ${formula}
         cp ${formula} $(brew --repository homebrew/core)/Formula/
       done
 {% endmacro %}
diff --git a/dev/tasks/r/github.macos.brew.yml b/dev/tasks/r/github.macos.brew.yml
index dea7564c5f80f..8a0e6f6bb96e3 100644
--- a/dev/tasks/r/github.macos.brew.yml
+++ b/dev/tasks/r/github.macos.brew.yml
@@ -24,21 +24,33 @@ jobs:
     name: "Homebrew + R package"
     runs-on: macOS-11
     steps:
+      - name: Show system information
+        run: |
+          sysctl hw.optional machdep.cpu
+
       {{ macros.github_checkout_arrow()|indent }}
 
       {{ macros.configure_homebrew_arrow(formula)|indent }}
       - name: Install apache-arrow
         env:
-        {{ macros.github_set_sccache_envvars()|indent(8)}}  
+        {{ macros.github_set_sccache_envvars()|indent(8)}}
         run: |
-          
           brew install sccache
           # for testing
           brew install minio
-          
+
           # TODO(ARROW-16907): apache/arrow@main seems to be installed already
           # so this does nothing on a branch/PR
-          brew install -v --HEAD apache-arrow
+          brew install -v --HEAD {{ '$(brew --repository homebrew/core)/Formula/apache-arrow.rb' }}
+
+          mkdir -p homebrew-logs
+          cp -a ~/Library/Logs/Homebrew/apache-arrow homebrew-logs/
+      - name: Save logs
+        if: always()
+        uses: actions/upload-artifact@v2
+        with:
+          name: homebrew-logs
+          path: homebrew-logs
 
       - uses: r-lib/actions/setup-r@v2
       - name: Install dependencies

From eddb2b960024c1c8f1c384755bcb2488f116dca2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 31 Jul 2023 14:06:45 +0900
Subject: [PATCH 068/749] GH-36944: [C++] Unify OpenSSL detection for building
 GCS (#36945)

### Rationale for this change

`build_google_cloud_cpp_storage()` calls `resolve_dependency(OpenSSL)` but it should not be here. We should have only one `resolve_dependency(OpenSSL)` for easy to maintain.

### What changes are included in this PR?

Don't call `resolve_dependency(OpenSSL)` from `build_google_cloud_cpp_storage()`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36944

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 635bc1684e6f2..1e7840cf92e08 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -1368,8 +1368,9 @@ set(ARROW_OPENSSL_REQUIRED_VERSION "1.0.2")
 set(ARROW_USE_OPENSSL OFF)
 if(PARQUET_REQUIRE_ENCRYPTION
    OR ARROW_FLIGHT
-   OR ARROW_S3
-   OR ARROW_GANDIVA)
+   OR ARROW_GANDIVA
+   OR ARROW_GCS
+   OR ARROW_S3)
   set(OpenSSL_SOURCE "SYSTEM")
   resolve_dependency(OpenSSL
                      HAVE_ALT
@@ -4106,10 +4107,6 @@ macro(build_google_cloud_cpp_storage)
   # Curl is required on all platforms, but building it internally might also trip over S3's copy.
   # For now, force its inclusion from the underlying system or fail.
   find_curl()
-  if(NOT OpenSSL_FOUND)
-    resolve_dependency(OpenSSL HAVE_ALT REQUIRED_VERSION
-                       ${ARROW_OPENSSL_REQUIRED_VERSION})
-  endif()
 
   # Build google-cloud-cpp, with only storage_client
 

From a06b2618420ef89431373a9e8f07a5da64d546a5 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 31 Jul 2023 15:27:33 +0900
Subject: [PATCH 069/749] GH-36941: [CI][Docs] Use system Protobuf (#36943)

### Rationale for this change

We can reduce disk usage by using system Protobuf and gRPC.

### What changes are included in this PR?

Use system Protobuf.

We can use Protobuf 3.12.0 or later by #35962.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36941

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/tasks.yml | 8 ++++++--
 docker-compose.yml  | 1 -
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 05dafade97434..25bda38809e3b 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -64,7 +64,7 @@ groups:
     - r-binary-packages
     - ubuntu-*
     - wheel-*
-    - test-ubuntu-default-docs
+    - test-ubuntu-*-docs
 
 {############################# Testing tasks #################################}
 
@@ -1498,10 +1498,12 @@ tasks:
       image: debian-go
   {% endfor %}
 
-  test-ubuntu-default-docs:
+  test-ubuntu-22.04-docs:
     ci: github
     template: docs/github.linux.yml
     params:
+      env:
+        UBUNTU: 22.04
       pr_number: Unset
       flags: "-v $PWD/build/:/build/"
       image: ubuntu-docs
@@ -1625,6 +1627,8 @@ tasks:
     ci: github
     template: docs/github.linux.yml
     params:
+      env:
+        UBUNTU: 22.04
       pr_number: Unset
       flags: "-v $PWD/build/:/build/"
       image: ubuntu-docs
diff --git a/docker-compose.yml b/docker-compose.yml
index 8727aded2c825..fe98a30d0b92b 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1745,7 +1745,6 @@ services:
       BUILD_DOCS_JS: "ON"
       BUILD_DOCS_PYTHON: "ON"
       BUILD_DOCS_R: "ON"
-      Protobuf_SOURCE: "BUNDLED"  # Need Protobuf >= 3.15
     volumes: *ubuntu-volumes
     command: &docs-command >
       /bin/bash -c "

From 37cb59240b1fa4c5b8e596afdaebf9435c415cec Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Mon, 31 Jul 2023 16:33:28 -0400
Subject: [PATCH 070/749] GH-36952: [C++][FlightRPC][Python] Add methods to
 send headers (#36956)

### Rationale for this change

Sending headers/trailers is required for services, but you couldn't do this before.

### What changes are included in this PR?

Add new methods to directly send headers/trailers.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes (new APIs)

* Closes: #36952

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/client_middleware.h      |  5 ++
 cpp/src/arrow/flight/server.h                 |  9 ++
 cpp/src/arrow/flight/test_definitions.cc      | 87 +++++++++++++++++--
 cpp/src/arrow/flight/test_definitions.h       |  9 +-
 .../flight/transport/grpc/grpc_client.cc      | 18 +---
 .../flight/transport/grpc/grpc_server.cc      |  9 ++
 .../ucx/flight_transport_ucx_test.cc          |  2 +
 .../arrow/flight/transport/ucx/ucx_server.cc  |  3 +
 python/pyarrow/_flight.pyx                    |  8 ++
 python/pyarrow/includes/libarrow_flight.pxd   |  2 +
 python/pyarrow/tests/test_flight.py           | 44 +++++++++-
 11 files changed, 174 insertions(+), 22 deletions(-)

diff --git a/cpp/src/arrow/flight/client_middleware.h b/cpp/src/arrow/flight/client_middleware.h
index 5b67e784b9eda..8e3126553a953 100644
--- a/cpp/src/arrow/flight/client_middleware.h
+++ b/cpp/src/arrow/flight/client_middleware.h
@@ -42,6 +42,11 @@ class ARROW_FLIGHT_EXPORT ClientMiddleware {
   virtual void SendingHeaders(AddCallHeaders* outgoing_headers) = 0;
 
   /// \brief A callback when headers are received from the server.
+  ///
+  /// This may be called more than once, since servers send both
+  /// headers and trailers.  Some implementations (e.g. gRPC-Java, and
+  /// hence Arrow Flight in Java) may consolidate headers into
+  /// trailers if the RPC errored.
   virtual void ReceivedHeaders(const CallHeaders& incoming_headers) = 0;
 
   /// \brief A callback after the call has completed.
diff --git a/cpp/src/arrow/flight/server.h b/cpp/src/arrow/flight/server.h
index 76f1a317068e6..049c6cee3ffcf 100644
--- a/cpp/src/arrow/flight/server.h
+++ b/cpp/src/arrow/flight/server.h
@@ -122,6 +122,15 @@ class ARROW_FLIGHT_EXPORT ServerCallContext {
   virtual const std::string& peer_identity() const = 0;
   /// \brief The peer address (not validated)
   virtual const std::string& peer() const = 0;
+  /// \brief Add a response header.  This is only valid before the server
+  /// starts sending the response; generally this isn't an issue unless you
+  /// are implementing FlightDataStream, ResultStream, or similar interfaces
+  /// yourself, or during a DoExchange or DoPut.
+  virtual void AddHeader(const std::string& key, const std::string& value) const = 0;
+  /// \brief Add a response trailer.  This is only valid before the server
+  /// sends the final status; generally this isn't an issue unless your RPC
+  /// handler launches a thread or similar.
+  virtual void AddTrailer(const std::string& key, const std::string& value) const = 0;
   /// \brief Look up a middleware by key. Do not maintain a reference
   /// to the object beyond the request body.
   /// \return The middleware, or nullptr if not found.
diff --git a/cpp/src/arrow/flight/test_definitions.cc b/cpp/src/arrow/flight/test_definitions.cc
index 507c5ef40421c..4e137380044f3 100644
--- a/cpp/src/arrow/flight/test_definitions.cc
+++ b/cpp/src/arrow/flight/test_definitions.cc
@@ -18,17 +18,22 @@
 #include "arrow/flight/test_definitions.h"
 
 #include <chrono>
+#include <memory>
+#include <mutex>
 
 #include "arrow/array/array_base.h"
 #include "arrow/array/array_dict.h"
 #include "arrow/array/util.h"
 #include "arrow/flight/api.h"
+#include "arrow/flight/client_middleware.h"
 #include "arrow/flight/test_util.h"
 #include "arrow/table.h"
 #include "arrow/testing/generator.h"
+#include "arrow/testing/gtest_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/config.h"
 #include "arrow/util/logging.h"
+#include "gmock/gmock.h"
 
 #if defined(ARROW_CUDA)
 #include "arrow/gpu/cuda_api.h"
@@ -1438,20 +1443,26 @@ class ErrorHandlingTestServer : public FlightServerBase {
  public:
   Status GetFlightInfo(const ServerCallContext& context, const FlightDescriptor& request,
                        std::unique_ptr<FlightInfo>* info) override {
-    if (request.path.size() >= 2) {
+    if (request.path.size() == 1 && request.path[0] == "metadata") {
+      context.AddHeader("x-header", "header-value");
+      context.AddHeader("x-header-bin", "header\x01value");
+      context.AddTrailer("x-trailer", "trailer-value");
+      context.AddTrailer("x-trailer-bin", "trailer\x01value");
+      return Status::Invalid("Expected");
+    } else if (request.path.size() >= 2) {
       const int raw_code = std::atoi(request.path[0].c_str());
       ARROW_ASSIGN_OR_RAISE(StatusCode code, TryConvertStatusCode(raw_code));
 
       if (request.path.size() == 2) {
-        return Status(code, request.path[1]);
+        return {code, request.path[1]};
       } else if (request.path.size() == 3) {
-        return Status(code, request.path[1], std::make_shared<TestStatusDetail>());
+        return {code, request.path[1], std::make_shared<TestStatusDetail>()};
       } else {
         const int raw_code = std::atoi(request.path[2].c_str());
         ARROW_ASSIGN_OR_RAISE(FlightStatusCode flight_code,
                               TryConvertFlightStatusCode(raw_code));
-        return Status(code, request.path[1],
-                      std::make_shared<FlightStatusDetail>(flight_code, request.path[3]));
+        return {code, request.path[1],
+                std::make_shared<FlightStatusDetail>(flight_code, request.path[3])};
       }
     }
     return Status::NotImplemented("NYI");
@@ -1469,20 +1480,70 @@ class ErrorHandlingTestServer : public FlightServerBase {
     return MakeFlightError(FlightStatusCode::Unauthorized, "Unauthorized", "extra info");
   }
 };
+
+class MetadataRecordingClientMiddleware : public ClientMiddleware {
+ public:
+  explicit MetadataRecordingClientMiddleware(
+      std::mutex& mutex, std::vector<std::pair<std::string, std::string>>& headers)
+      : mutex_(mutex), headers_(headers) {}
+  void SendingHeaders(AddCallHeaders*) override {}
+  void ReceivedHeaders(const CallHeaders& incoming_headers) override {
+    std::lock_guard<std::mutex> guard(mutex_);
+    for (const auto& [key, value] : incoming_headers) {
+      headers_.emplace_back(key, value);
+    }
+  }
+  void CallCompleted(const Status&) override {}
+
+ private:
+  std::mutex& mutex_;
+  std::vector<std::pair<std::string, std::string>>& headers_;
+};
+
+class MetadataRecordingClientMiddlewareFactory : public ClientMiddlewareFactory {
+ public:
+  void StartCall(const CallInfo&,
+                 std::unique_ptr<ClientMiddleware>* middleware) override {
+    *middleware = std::make_unique<MetadataRecordingClientMiddleware>(mutex_, headers_);
+  }
+
+  std::vector<std::pair<std::string, std::string>> GetHeaders() const {
+    std::lock_guard<std::mutex> guard(mutex_);
+    // Take copy
+    return headers_;
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  std::vector<std::pair<std::string, std::string>> headers_;
+};
 }  // namespace
 
+struct ErrorHandlingTest::Impl {
+  std::shared_ptr<MetadataRecordingClientMiddlewareFactory> metadata =
+      std::make_shared<MetadataRecordingClientMiddlewareFactory>();
+};
+
 void ErrorHandlingTest::SetUpTest() {
+  impl_ = std::make_shared<Impl>();
   ASSERT_OK_AND_ASSIGN(auto location, Location::ForScheme(transport(), "127.0.0.1", 0));
   ASSERT_OK(MakeServer<ErrorHandlingTestServer>(
       location, &server_, &client_,
       [](FlightServerOptions* options) { return Status::OK(); },
-      [](FlightClientOptions* options) { return Status::OK(); }));
+      [&](FlightClientOptions* options) {
+        options->middleware.emplace_back(impl_->metadata);
+        return Status::OK();
+      }));
 }
 void ErrorHandlingTest::TearDownTest() {
   ASSERT_OK(client_->Close());
   ASSERT_OK(server_->Shutdown());
 }
 
+std::vector<std::pair<std::string, std::string>> ErrorHandlingTest::GetHeaders() {
+  return impl_->metadata->GetHeaders();
+}
+
 void ErrorHandlingTest::TestGetFlightInfo() {
   std::unique_ptr<FlightInfo> info;
   for (const auto code : kStatusCodes) {
@@ -1518,6 +1579,20 @@ void ErrorHandlingTest::TestGetFlightInfo() {
   }
 }
 
+void ErrorHandlingTest::TestGetFlightInfoMetadata() {
+  auto descr = FlightDescriptor::Path({"metadata"});
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, ::testing::HasSubstr("Expected"),
+                                  client_->GetFlightInfo(descr));
+  // This is janky because we don't/can't expose grpc::CallContext.
+  // See https://github.com/apache/arrow/issues/34607
+  ASSERT_THAT(GetHeaders(), ::testing::IsSupersetOf({
+                                std::make_pair("x-header", "header-value"),
+                                std::make_pair("x-header-bin", "header\x01value"),
+                                std::make_pair("x-trailer", "trailer-value"),
+                                std::make_pair("x-trailer-bin", "trailer\x01value"),
+                            }));
+}
+
 void CheckErrorDetail(const Status& status) {
   auto detail = FlightStatusDetail::UnwrapStatus(status);
   ASSERT_NE(detail, nullptr) << status.ToString();
diff --git a/cpp/src/arrow/flight/test_definitions.h b/cpp/src/arrow/flight/test_definitions.h
index 7a7f905f3e97c..c73bc264b4966 100644
--- a/cpp/src/arrow/flight/test_definitions.h
+++ b/cpp/src/arrow/flight/test_definitions.h
@@ -265,10 +265,16 @@ class ARROW_FLIGHT_EXPORT ErrorHandlingTest : public FlightTest {
 
   // Test methods
   void TestGetFlightInfo();
+  void TestGetFlightInfoMetadata();
   void TestDoPut();
   void TestDoExchange();
 
- private:
+ protected:
+  struct Impl;
+
+  std::vector<std::pair<std::string, std::string>> GetHeaders();
+
+  std::shared_ptr<Impl> impl_;
   std::unique_ptr<FlightClient> client_;
   std::unique_ptr<FlightServerBase> server_;
 };
@@ -277,6 +283,7 @@ class ARROW_FLIGHT_EXPORT ErrorHandlingTest : public FlightTest {
   static_assert(std::is_base_of<ErrorHandlingTest, FIXTURE>::value,               \
                 ARROW_STRINGIFY(FIXTURE) " must inherit from ErrorHandlingTest"); \
   TEST_F(FIXTURE, TestGetFlightInfo) { TestGetFlightInfo(); }                     \
+  TEST_F(FIXTURE, TestGetFlightInfoMetadata) { TestGetFlightInfoMetadata(); }     \
   TEST_F(FIXTURE, TestDoPut) { TestDoPut(); }                                     \
   TEST_F(FIXTURE, TestDoExchange) { TestDoExchange(); }
 
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
index 89f088638320e..9b40015f9f729 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
@@ -107,9 +107,9 @@ class GrpcClientInterceptorAdapter : public ::grpc::experimental::Interceptor {
  public:
   explicit GrpcClientInterceptorAdapter(
       std::vector<std::unique_ptr<ClientMiddleware>> middleware)
-      : middleware_(std::move(middleware)), received_headers_(false) {}
+      : middleware_(std::move(middleware)) {}
 
-  void Intercept(::grpc::experimental::InterceptorBatchMethods* methods) {
+  void Intercept(::grpc::experimental::InterceptorBatchMethods* methods) override {
     using InterceptionHookPoints = ::grpc::experimental::InterceptionHookPoints;
     if (methods->QueryInterceptionHookPoint(
             InterceptionHookPoints::PRE_SEND_INITIAL_METADATA)) {
@@ -142,10 +142,6 @@ class GrpcClientInterceptorAdapter : public ::grpc::experimental::Interceptor {
  private:
   void ReceivedHeaders(
       const std::multimap<::grpc::string_ref, ::grpc::string_ref>& metadata) {
-    if (received_headers_) {
-      return;
-    }
-    received_headers_ = true;
     CallHeaders headers;
     for (const auto& entry : metadata) {
       headers.insert({std::string_view(entry.first.data(), entry.first.length()),
@@ -157,20 +153,14 @@ class GrpcClientInterceptorAdapter : public ::grpc::experimental::Interceptor {
   }
 
   std::vector<std::unique_ptr<ClientMiddleware>> middleware_;
-  // When communicating with a gRPC-Java server, the server may not
-  // send back headers if the call fails right away. Instead, the
-  // headers will be consolidated into the trailers. We don't want to
-  // call the client middleware callback twice, so instead track
-  // whether we saw headers - if not, then we need to check trailers.
-  bool received_headers_;
 };
 
 class GrpcClientInterceptorAdapterFactory
     : public ::grpc::experimental::ClientInterceptorFactoryInterface {
  public:
-  GrpcClientInterceptorAdapterFactory(
+  explicit GrpcClientInterceptorAdapterFactory(
       std::vector<std::shared_ptr<ClientMiddlewareFactory>> middleware)
-      : middleware_(middleware) {}
+      : middleware_(std::move(middleware)) {}
 
   ::grpc::experimental::Interceptor* CreateClientInterceptor(
       ::grpc::experimental::ClientRpcInfo* info) override {
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
index 2c7a1d5e99234..50d4ffe002c7e 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
@@ -111,6 +111,7 @@ class GrpcServerAuthSender : public ServerAuthSender {
 };
 
 class GrpcServerCallContext : public ServerCallContext {
+ public:
   explicit GrpcServerCallContext(::grpc::ServerContext* context)
       : context_(context), peer_(context_->peer()) {
     for (const auto& entry : context->client_metadata()) {
@@ -143,6 +144,14 @@ class GrpcServerCallContext : public ServerCallContext {
     return ToGrpcStatus(status, context_);
   }
 
+  void AddHeader(const std::string& key, const std::string& value) const override {
+    context_->AddInitialMetadata(key, value);
+  }
+
+  void AddTrailer(const std::string& key, const std::string& value) const override {
+    context_->AddTrailingMetadata(key, value);
+  }
+
   ServerMiddleware* GetMiddleware(const std::string& key) const override {
     const auto& instance = middleware_map_.find(key);
     if (instance == middleware_map_.end()) {
diff --git a/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc b/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc
index 3ac02bf7183a3..c3481d834f6ea 100644
--- a/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc
+++ b/cpp/src/arrow/flight/transport/ucx/flight_transport_ucx_test.cc
@@ -103,6 +103,8 @@ class UcxErrorHandlingTest : public ErrorHandlingTest, public ::testing::Test {
   std::string transport() const override { return "ucx"; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
+
+  void TestGetFlightInfoMetadata() { GTEST_SKIP() << "Middleware not implemented"; }
 };
 ARROW_FLIGHT_TEST_ERROR_HANDLING(UcxErrorHandlingTest);
 
diff --git a/cpp/src/arrow/flight/transport/ucx/ucx_server.cc b/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
index 4a573d742929a..8bbac34705c23 100644
--- a/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
+++ b/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
@@ -72,6 +72,9 @@ class UcxServerCallContext : public flight::ServerCallContext {
  public:
   const std::string& peer_identity() const override { return peer_; }
   const std::string& peer() const override { return peer_; }
+  // Not supported
+  void AddHeader(const std::string& key, const std::string& value) const override {}
+  void AddTrailer(const std::string& key, const std::string& value) const override {}
   ServerMiddleware* GetMiddleware(const std::string& key) const override {
     return nullptr;
   }
diff --git a/python/pyarrow/_flight.pyx b/python/pyarrow/_flight.pyx
index c9f5526754e3d..0572ed77b40ef 100644
--- a/python/pyarrow/_flight.pyx
+++ b/python/pyarrow/_flight.pyx
@@ -1756,6 +1756,14 @@ cdef class ServerCallContext(_Weakrefable):
         """Check if the current RPC call has been canceled by the client."""
         return self.context.is_cancelled()
 
+    def add_header(self, key, value):
+        """Add a response header."""
+        self.context.AddHeader(tobytes(key), tobytes(value))
+
+    def add_trailer(self, key, value):
+        """Add a response trailer."""
+        self.context.AddTrailer(tobytes(key), tobytes(value))
+
     def get_middleware(self, key):
         """
         Get a middleware instance by key.
diff --git a/python/pyarrow/includes/libarrow_flight.pxd b/python/pyarrow/includes/libarrow_flight.pxd
index 34ba809438e2c..624904ed77a69 100644
--- a/python/pyarrow/includes/libarrow_flight.pxd
+++ b/python/pyarrow/includes/libarrow_flight.pxd
@@ -257,6 +257,8 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
         c_string& peer_identity()
         c_string& peer()
         c_bool is_cancelled()
+        void AddHeader(const c_string& key, const c_string& value)
+        void AddTrailer(const c_string& key, const c_string& value)
         CServerMiddleware* GetMiddleware(const c_string& key)
 
     cdef cppclass CTimeoutDuration" arrow::flight::TimeoutDuration":
diff --git a/python/pyarrow/tests/test_flight.py b/python/pyarrow/tests/test_flight.py
index 930523b9f5442..6c1c582dceb21 100644
--- a/python/pyarrow/tests/test_flight.py
+++ b/python/pyarrow/tests/test_flight.py
@@ -833,7 +833,7 @@ def sending_headers(self):
     def received_headers(self, headers):
         # Let the test code know what the last set of headers we
         # received were.
-        self.factory.last_headers = headers
+        self.factory.last_headers.update(headers)
 
 
 class MultiHeaderServerMiddlewareFactory(ServerMiddlewareFactory):
@@ -2323,3 +2323,45 @@ def test_do_put_does_not_crash_when_schema_is_none():
     with pytest.raises(TypeError, match=msg):
         client.do_put(flight.FlightDescriptor.for_command('foo'),
                       schema=None)
+
+
+def test_headers_trailers():
+    """Ensure that server-sent headers/trailers make it through."""
+
+    class HeadersTrailersFlightServer(FlightServerBase):
+        def get_flight_info(self, context, descriptor):
+            context.add_header("x-header", "header-value")
+            context.add_header("x-header-bin", "header\x01value")
+            context.add_trailer("x-trailer", "trailer-value")
+            context.add_trailer("x-trailer-bin", "trailer\x01value")
+            return flight.FlightInfo(
+                pa.schema([]),
+                descriptor,
+                [],
+                -1, -1
+            )
+
+    class HeadersTrailersMiddlewareFactory(ClientMiddlewareFactory):
+        def __init__(self):
+            self.headers = []
+
+        def start_call(self, info):
+            return HeadersTrailersMiddleware(self)
+
+    class HeadersTrailersMiddleware(ClientMiddleware):
+        def __init__(self, factory):
+            self.factory = factory
+
+        def received_headers(self, headers):
+            for key, values in headers.items():
+                for value in values:
+                    self.factory.headers.append((key, value))
+
+    factory = HeadersTrailersMiddlewareFactory()
+    with HeadersTrailersFlightServer() as server, \
+            FlightClient(("localhost", server.port), middleware=[factory]) as client:
+        client.get_flight_info(flight.FlightDescriptor.for_path(""))
+        assert ("x-header", "header-value") in factory.headers
+        assert ("x-header-bin", b"header\x01value") in factory.headers
+        assert ("x-trailer", "trailer-value") in factory.headers
+        assert ("x-trailer-bin", b"trailer\x01value") in factory.headers

From 112f94971882750731fabebd499ab0f817ca3839 Mon Sep 17 00:00:00 2001
From: Ashish Bailkeri <47304318+aboss123@users.noreply.github.com>
Date: Mon, 31 Jul 2023 16:57:01 -0400
Subject: [PATCH 071/749] GH-36323: [Python] Fix Timestamp scalar repr error on
 values outside datetime range (#36942)

### Rationale for this change

https://github.com/apache/arrow/issues/36323

### What changes are included in this PR?

Changed the way repr is handled for TimestampScalar

### Are these changes tested?

I have added a very basic test for this change to see whether it will error or not if outside the range.

### Are there any user-facing changes?

The functionality of TimestampScalar's repr now uses the `strftime` function.

* Closes: #36323

Lead-authored-by: Ashish Bailkeri <ashishbailkeri123@gmail.com>
Co-authored-by: Ashish Bailkeri <47304318+aboss123@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/scalar.pxi                    | 17 +++++++++++++++++
 python/pyarrow/tests/test_convert_builtin.py |  2 +-
 python/pyarrow/tests/test_scalars.py         | 12 ++++++++++++
 python/pyarrow/types.pxi                     |  4 ++--
 4 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/python/pyarrow/scalar.pxi b/python/pyarrow/scalar.pxi
index 74f5aa4213ca0..aff1c311abbfb 100644
--- a/python/pyarrow/scalar.pxi
+++ b/python/pyarrow/scalar.pxi
@@ -522,6 +522,23 @@ cdef class TimestampScalar(Scalar):
 
         return _datetime_from_int(sp.value, unit=dtype.unit(), tzinfo=tzinfo)
 
+    def __repr__(self):
+        """
+        Return the representation of TimestampScalar using `strftime` to avoid
+        original repr datetime values being out of range.
+        """
+        cdef:
+            CTimestampScalar* sp = <CTimestampScalar*> self.wrapped.get()
+            CTimestampType* dtype = <CTimestampType*> sp.type.get()
+
+        if not dtype.timezone().empty():
+            type_format = str(_pc().strftime(self, format="%Y-%m-%dT%H:%M:%S%z"))
+        else:
+            type_format = str(_pc().strftime(self))
+        return '<pyarrow.{}: {!r}>'.format(
+            self.__class__.__name__, type_format
+        )
+
 
 cdef class DurationScalar(Scalar):
     """
diff --git a/python/pyarrow/tests/test_convert_builtin.py b/python/pyarrow/tests/test_convert_builtin.py
index af4c91a89459d..cf2535a3c62d1 100644
--- a/python/pyarrow/tests/test_convert_builtin.py
+++ b/python/pyarrow/tests/test_convert_builtin.py
@@ -1353,7 +1353,7 @@ def test_sequence_timestamp_from_int_with_unit():
     assert len(arr_s) == 1
     assert arr_s.type == s
     assert repr(arr_s[0]) == (
-        "<pyarrow.TimestampScalar: datetime.datetime(1970, 1, 1, 0, 0, 1)>"
+        "<pyarrow.TimestampScalar: '1970-01-01T00:00:01'>"
     )
     assert str(arr_s[0]) == "1970-01-01 00:00:01"
 
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index 2aaefe16ae469..a989301fe5735 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -154,6 +154,18 @@ def test_hashing_struct_scalar():
     assert hash1 == hash2
 
 
+def test_timestamp_scalar():
+    a = repr(pa.scalar("0000-01-01").cast(pa.timestamp("s")))
+    assert a == "<pyarrow.TimestampScalar: '0000-01-01T00:00:00'>"
+    b = repr(pa.scalar(datetime.datetime(2015, 1, 1), type=pa.timestamp('s', tz='UTC')))
+    assert b == "<pyarrow.TimestampScalar: '2015-01-01T00:00:00+0000'>"
+    c = repr(pa.scalar(datetime.datetime(2015, 1, 1), type=pa.timestamp('us')))
+    assert c == "<pyarrow.TimestampScalar: '2015-01-01T00:00:00.000000'>"
+    d = repr(pc.assume_timezone(
+        pa.scalar("2000-01-01").cast(pa.timestamp("s")), "America/New_York"))
+    assert d == "<pyarrow.TimestampScalar: '2000-01-01T00:00:00-0500'>"
+
+
 def test_bool():
     false = pa.scalar(False)
     true = pa.scalar(True)
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index fbd4f8a94b64c..12ad2fc4b6f60 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -3605,9 +3605,9 @@ def timestamp(unit, tz=None):
 
     >>> from datetime import datetime
     >>> pa.scalar(datetime(2012, 1, 1), type=pa.timestamp('s', tz='UTC'))
-    <pyarrow.TimestampScalar: datetime.datetime(2012, 1, 1, 0, 0, tzinfo=<UTC>)>
+    <pyarrow.TimestampScalar: '2012-01-01T00:00:00+0000'>
     >>> pa.scalar(datetime(2012, 1, 1), type=pa.timestamp('us'))
-    <pyarrow.TimestampScalar: datetime.datetime(2012, 1, 1, 0, 0)>
+    <pyarrow.TimestampScalar: '2012-01-01T00:00:00.000000'>
 
     Returns
     -------

From 334b46d349af897ba03d7d72be86d23aa5ee8b43 Mon Sep 17 00:00:00 2001
From: Kevin Liu <kevinjqliu@users.noreply.github.com>
Date: Mon, 31 Jul 2023 22:14:27 -0700
Subject: [PATCH 072/749] GH-35409: [Python][Docs] Clarify S3FileSystem
 Credentials chain for EC2 (#35312)

### Rationale for this change

When resolving AWS credentials on EC2 hosts, the underlying AWS SDK also looks at the EC2 Instance Metadata Service.

I want to document this behavior for `pyarrow`.  The [`s3fs` documentation](https://s3fs.readthedocs.io/en/latest/#credentials) mention this specific case for EC2.

### What changes are included in this PR?

Documentation for the behavior described above.

#### Technical Details
`S3FileSystem` uses the [`CS3Options.Defaults()`](https://github.com/apache/arrow/blob/5de56928e0fe43f02005552eee058de57ffb2682/python/pyarrow/_s3fs.pyx#L317) option when no credentials are passed into the constructor.  It utilizes the [`Aws::Auth::DefaultAWSCredentialsProviderChain`](https://github.com/apache/arrow/blob/1de159d0f6763766c19b183dd309b8757723b43a/cpp/src/arrow/filesystem/s3fs.cc#L213)

The C++ implementation of [`DefaultAWSCredentialsProviderChain`](https://sdk.amazonaws.com/cpp/api/0.14.3/class_aws_1_1_auth_1_1_default_a_w_s_credentials_provider_chain.html) not only [reads the environment variable](https://sdk.amazonaws.com/cpp/api/0.14.3/class_aws_1_1_auth_1_1_environment_a_w_s_credentials_provider.html) when trying to resolve AWS credentials, but also [looks at profile config](https://sdk.amazonaws.com/cpp/api/0.14.3/class_aws_1_1_auth_1_1_profile_config_file_a_w_s_credentials_provider.html) and the [EC2 Instance Metadata Service](https://sdk.amazonaws.com/cpp/api/0.14.3/class_aws_1_1_auth_1_1_instance_profile_credentials_provider.html).

### Are these changes tested?

No, just documentation changes

### Are there any user-facing changes?

Yes, changing public documentation

* Closes: #35409

### Render Changes
Render the changes locally via [Building the doc](https://arrow.apache.org/docs/developers/documentation.html#building-docs):
`docs/source/python/filesystems.rst`:
![Screenshot 2023-07-30 at 6 22 02 PM](https://github.com/apache/arrow/assets/9057843/6af053a3-e7a7-4a68-a5b5-02c50e9290c6)

`python/pyarrow/_s3fs.pyx`:
![Screenshot 2023-07-31 at 3 31 30 PM](https://github.com/apache/arrow/assets/9057843/d79768be-67ce-46c0-88ed-a833e540f77d)

Lead-authored-by: Kevin Liu <kevinjqliu@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/python/filesystems.rst |  5 +++--
 python/pyarrow/_s3fs.pyx           | 12 +++++++++---
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/docs/source/python/filesystems.rst b/docs/source/python/filesystems.rst
index 40656f6b76f43..3fc10dc7718d3 100644
--- a/docs/source/python/filesystems.rst
+++ b/docs/source/python/filesystems.rst
@@ -153,8 +153,9 @@ PyArrow implements natively a S3 filesystem for S3 compatible storage.
 The :class:`S3FileSystem` constructor has several options to configure the S3
 connection (e.g. credentials, the region, an endpoint override, etc). In
 addition, the constructor will also inspect configured S3 credentials as
-supported by AWS (for example the ``AWS_ACCESS_KEY_ID`` and
-``AWS_SECRET_ACCESS_KEY`` environment variables).
+supported by AWS (such as the ``AWS_ACCESS_KEY_ID`` and
+``AWS_SECRET_ACCESS_KEY`` environment variables, AWS configuration files,
+and EC2 Instance Metadata Service for EC2 nodes).
 
 
 Example how you can read contents from a S3 bucket::
diff --git a/python/pyarrow/_s3fs.pyx b/python/pyarrow/_s3fs.pyx
index e76c7b9ffa730..51c248d147828 100644
--- a/python/pyarrow/_s3fs.pyx
+++ b/python/pyarrow/_s3fs.pyx
@@ -140,14 +140,20 @@ cdef class S3FileSystem(FileSystem):
     """
     S3-backed FileSystem implementation
 
-    If neither access_key nor secret_key are provided, and role_arn is also not
-    provided, then attempts to initialize from AWS environment variables,
-    otherwise both access_key and secret_key must be provided.
+    AWS access_key and secret_key can be provided explicitly.
 
     If role_arn is provided instead of access_key and secret_key, temporary
     credentials will be fetched by issuing a request to STS to assume the
     specified role.
 
+    If neither access_key nor secret_key are provided, and role_arn is also not
+    provided, then attempts to establish the credentials automatically.
+    S3FileSystem will try the following methods, in order:
+
+    * ``AWS_ACCESS_KEY_ID``, ``AWS_SECRET_ACCESS_KEY``, and ``AWS_SESSION_TOKEN`` environment variables
+    * configuration files such as ``~/.aws/credentials`` and ``~/.aws/config``
+    * for nodes on Amazon EC2, the EC2 Instance Metadata Service
+
     Note: S3 buckets are special and the operations available on them may be
     limited or more expensive than desired.
 

From 8273f7abd44d4ed582650166de1c6ea59ed759b6 Mon Sep 17 00:00:00 2001
From: david dali susanibar arce <davi.sarces@gmail.com>
Date: Tue, 1 Aug 2023 04:05:54 -0500
Subject: [PATCH 073/749] GH-36927: [Java][Docs] Enable Gandiva build as part
 of Java maven commands (#36929)

### Rationale for this change

To close: https://github.com/apache/arrow/issues/36927

### What changes are included in this PR?

- Enable MacOS Gandiva build as part of Java maven commands
- Enable Windows ORC build as part of Java maven commands

### Are these changes tested?

Yes:
- Gandiva: mvn generate-resources -Pgenerate-libs-jni-macos-linux -N
- ORC: mvn generate-resources -Pgenerate-libs-jni-windows -N

### Are there any user-facing changes?

No
* Closes: #36927

Lead-authored-by: david dali susanibar arce <davi.sarces@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/java/building.rst | 17 +++++++++--------
 java/pom.xml                             | 24 ++++++++++++++----------
 2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/docs/source/developers/java/building.rst b/docs/source/developers/java/building.rst
index 5dd3a979d8293..061c616d4b971 100644
--- a/docs/source/developers/java/building.rst
+++ b/docs/source/developers/java/building.rst
@@ -132,11 +132,7 @@ Maven
       $ cd arrow/java
       $ export JAVA_HOME=<absolute path to your java home>
       $ java --version
-      $ mvn generate-resources \
-          -Pgenerate-libs-jni-macos-linux \
-          -DARROW_GANDIVA=ON \
-          -DARROW_JAVA_JNI_ENABLE_GANDIVA=ON \
-          -N
+      $ mvn generate-resources -Pgenerate-libs-jni-macos-linux -N
       $ ls -latr java-dist/lib/<your system's architecture>/*_{jni,java}.*
       |__ libarrow_dataset_jni.dylib
       |__ libarrow_orc_jni.dylib
@@ -236,7 +232,9 @@ CMake
           -DCMAKE_BUILD_TYPE=Release \
           -DCMAKE_INSTALL_LIBDIR=lib/<your system's architecture> \
           -DCMAKE_INSTALL_PREFIX=java-dist \
-          -DCMAKE_PREFIX_PATH=$PWD/java-dist
+          -DCMAKE_PREFIX_PATH=$PWD/java-dist \
+          -DProtobuf_ROOT=$PWD/../cpp-jni/protobuf_ep-install \
+          -DProtobuf_USE_STATIC_LIBS=ON
       $ cmake --build java-jni --target install --config Release
       $ ls -latr java-dist/lib/<your system's architecture>/*_{jni,java}.*
       |__ libarrow_dataset_jni.dylib
@@ -257,8 +255,9 @@ CMake
           -DARROW_DATASET=ON ^
           -DARROW_DEPENDENCY_USE_SHARED=OFF ^
           -DARROW_FILESYSTEM=ON ^
+          -DARROW_GANDIVA=OFF ^
           -DARROW_JSON=ON ^
-          -DARROW_ORC=OFF ^
+          -DARROW_ORC=ON ^
           -DARROW_PARQUET=ON ^
           -DARROW_S3=ON ^
           -DARROW_SUBSTRAIT=ON ^
@@ -280,9 +279,10 @@ CMake
           -S java ^
           -B java-jni ^
           -DARROW_JAVA_JNI_ENABLE_C=OFF ^
+          -DARROW_JAVA_JNI_ENABLE_DATASET=ON ^
           -DARROW_JAVA_JNI_ENABLE_DEFAULT=ON ^
           -DARROW_JAVA_JNI_ENABLE_GANDIVA=OFF ^
-          -DARROW_JAVA_JNI_ENABLE_ORC=OFF ^
+          -DARROW_JAVA_JNI_ENABLE_ORC=ON ^
           -DBUILD_TESTING=OFF ^
           -DCMAKE_BUILD_TYPE=Release ^
           -DCMAKE_INSTALL_LIBDIR=lib/x86_64 ^
@@ -290,6 +290,7 @@ CMake
           -DCMAKE_PREFIX_PATH=$PWD/java-dist
       $ cmake --build java-jni --target install --config Release
       $ dir "java-dist/bin"
+      |__ arrow_orc_jni.dll
       |__ arrow_dataset_jni.dll
 
 Archery
diff --git a/java/pom.xml b/java/pom.xml
index d6b37c7df969d..f6837cd82c7b5 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -984,13 +984,13 @@
       <properties>
         <arrow.dataset.jni.dist.dir>java-dist</arrow.dataset.jni.dist.dir>
         <cpp.dependencies.builded>false</cpp.dependencies.builded>
-        <ARROW_CSV>ON</ARROW_CSV>
+        <ARROW_DATASET>ON</ARROW_DATASET>
+        <ARROW_GANDIVA>ON</ARROW_GANDIVA>
         <ARROW_ORC>ON</ARROW_ORC>
         <ARROW_PARQUET>ON</ARROW_PARQUET>
-        <ARROW_GANDIVA>OFF</ARROW_GANDIVA>
         <ARROW_JAVA_JNI_ENABLE_C>OFF</ARROW_JAVA_JNI_ENABLE_C>
         <ARROW_JAVA_JNI_ENABLE_DATASET>ON</ARROW_JAVA_JNI_ENABLE_DATASET>
-        <ARROW_JAVA_JNI_ENABLE_GANDIVA>OFF</ARROW_JAVA_JNI_ENABLE_GANDIVA>
+        <ARROW_JAVA_JNI_ENABLE_GANDIVA>ON</ARROW_JAVA_JNI_ENABLE_GANDIVA>
         <ARROW_JAVA_JNI_ENABLE_ORC>ON</ARROW_JAVA_JNI_ENABLE_ORC>
       </properties>
       <build>
@@ -1012,8 +1012,8 @@
                     -S cpp
                     -B cpp-jni
                     -DARROW_BUILD_SHARED=OFF
-                    -DARROW_CSV=${ARROW_CSV}
-                    -DARROW_DATASET=ON
+                    -DARROW_CSV=${ARROW_DATASET}
+                    -DARROW_DATASET=${ARROW_DATASET}
                     -DARROW_DEPENDENCY_SOURCE=BUNDLED
                     -DARROW_DEPENDENCY_USE_SHARED=OFF
                     -DARROW_FILESYSTEM=ON
@@ -1070,6 +1070,8 @@
                     -DCMAKE_INSTALL_LIBDIR=lib/${os.detected.arch}
                     -DCMAKE_INSTALL_PREFIX=${arrow.dataset.jni.dist.dir}
                     -DCMAKE_PREFIX_PATH=${project.basedir}/../java-dist/lib/${os.detected.arch}/cmake
+                    -DProtobuf_USE_STATIC_LIBS=ON
+                    -DProtobuf_ROOT=${project.basedir}/../cpp-jni/protobuf_ep-install
                   </commandlineArgs>
                   <workingDirectory>../</workingDirectory>
                 </configuration>
@@ -1099,13 +1101,14 @@
       <properties>
         <arrow.dataset.jni.dist.dir>java-dist</arrow.dataset.jni.dist.dir>
         <cpp.dependencies.builded>false</cpp.dependencies.builded>
-        <ARROW_CSV>ON</ARROW_CSV>
-        <ARROW_ORC>OFF</ARROW_ORC>
+        <ARROW_DATASET>ON</ARROW_DATASET>
+        <ARROW_GANDIVA>OFF</ARROW_GANDIVA>
+        <ARROW_ORC>ON</ARROW_ORC>
         <ARROW_PARQUET>ON</ARROW_PARQUET>
         <ARROW_JAVA_JNI_ENABLE_C>OFF</ARROW_JAVA_JNI_ENABLE_C>
         <ARROW_JAVA_JNI_ENABLE_DATASET>ON</ARROW_JAVA_JNI_ENABLE_DATASET>
         <ARROW_JAVA_JNI_ENABLE_GANDIVA>OFF</ARROW_JAVA_JNI_ENABLE_GANDIVA>
-        <ARROW_JAVA_JNI_ENABLE_ORC>OFF</ARROW_JAVA_JNI_ENABLE_ORC>
+        <ARROW_JAVA_JNI_ENABLE_ORC>ON</ARROW_JAVA_JNI_ENABLE_ORC>
       </properties>
       <build>
         <plugins>
@@ -1126,10 +1129,11 @@
                     -S cpp
                     -B cpp-jni
                     -DARROW_BUILD_SHARED=OFF
-                    -DARROW_CSV=${ARROW_CSV}
-                    -DARROW_DATASET=ON
+                    -DARROW_CSV=${ARROW_DATASET}
+                    -DARROW_DATASET=${ARROW_DATASET}
                     -DARROW_DEPENDENCY_USE_SHARED=OFF
                     -DARROW_FILESYSTEM=ON
+                    -DARROW_GANDIVA=${ARROW_GANDIVA}
                     -DARROW_JSON=${ARROW_DATASET}
                     -DARROW_ORC=${ARROW_ORC}
                     -DARROW_PARQUET=${ARROW_PARQUET}

From 66a6136c02ad471585a5c38589ba6d779ad28d16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 1 Aug 2023 14:27:25 +0200
Subject: [PATCH 074/749] GH-36947: [CI] Move free up disk space to the Jinja
 macros to be able to reuse it on docs job (#36948)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Try to get rid of some failures on docs generation on release and reuse existing code.

### What changes are included in this PR?

Move step to a macro to be able to reuse it

### Are these changes tested?

Archery tasks

### Are there any user-facing changes?

No
* Closes: #36947

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/tasks/docs/github.linux.yml           |  1 +
 dev/tasks/linux-packages/github.linux.yml | 50 +--------------------
 dev/tasks/macros.jinja                    | 54 +++++++++++++++++++++++
 3 files changed, 56 insertions(+), 49 deletions(-)

diff --git a/dev/tasks/docs/github.linux.yml b/dev/tasks/docs/github.linux.yml
index 0938ac74adc46..6de297b663e01 100644
--- a/dev/tasks/docs/github.linux.yml
+++ b/dev/tasks/docs/github.linux.yml
@@ -26,6 +26,7 @@ jobs:
 {{ macros.github_set_env(env) }}
     steps:
       {{ macros.github_checkout_arrow(fetch_depth=fetch_depth|default(1))|indent }}
+      {{ macros.github_free_space()|indent }}
       {{ macros.github_install_archery()|indent }}
 
       - name: Execute Docker Build
diff --git a/dev/tasks/linux-packages/github.linux.yml b/dev/tasks/linux-packages/github.linux.yml
index bf28cf10e9ecf..6de3edfce07e1 100644
--- a/dev/tasks/linux-packages/github.linux.yml
+++ b/dev/tasks/linux-packages/github.linux.yml
@@ -32,56 +32,8 @@ jobs:
     steps:
       {{ macros.github_checkout_arrow()|indent }}
       {{ macros.github_login_dockerhub()|indent }}
+      {{ macros.github_free_space()|indent }}
 
-      - name: Free up disk space
-        if: |
-          env.ARCHITECTURE == 'amd64'
-        run: |
-          df -h
-          echo "::group::/usr/local/*"
-          du -hsc /usr/local/*
-          echo "::endgroup::"
-          echo "::group::/usr/local/bin/*"
-          du -hsc /usr/local/bin/*
-          echo "::endgroup::"
-          # ~1GB (From 1.2GB to 214MB)
-          sudo rm -rf \
-            /usr/local/bin/aliyun \
-            /usr/local/bin/azcopy \
-            /usr/local/bin/bicep \
-            /usr/local/bin/cmake-gui \
-            /usr/local/bin/cpack \
-            /usr/local/bin/helm \
-            /usr/local/bin/hub \
-            /usr/local/bin/kubectl \
-            /usr/local/bin/minikube \
-            /usr/local/bin/node \
-            /usr/local/bin/packer \
-            /usr/local/bin/pulumi* \
-            /usr/local/bin/stack \
-            /usr/local/bin/terraform || :
-          echo "::group::/usr/local/share/*"
-          du -hsc /usr/local/share/*
-          echo "::endgroup::"
-          # 1.3GB
-          sudo rm -rf /usr/local/share/powershell || :
-          echo "::group::/opt/*"
-          du -hsc /opt/*
-          echo "::endgroup::"
-          echo "::group::/opt/hostedtoolcache/*"
-          du -hsc /opt/hostedtoolcache/*
-          echo "::endgroup::"
-          # 5.3GB
-          sudo rm -rf /opt/hostedtoolcache/CodeQL || :
-          # 1.4GB
-          sudo rm -rf /opt/hostedtoolcache/go || :
-          # 489MB
-          sudo rm -rf /opt/hostedtoolcache/PyPy || :
-          # 1.2GB
-          sudo rm -rf /opt/hostedtoolcache/Python || :
-          # 376MB
-          sudo rm -rf /opt/hostedtoolcache/node || :
-          df -h
       - name: Set up Ruby
         run: |
           sudo apt update
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 1f2f9a72975eb..5948b663d915b 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -72,6 +72,60 @@ on:
     run: pip install -e arrow/dev/archery[all]
 {% endmacro %}
 
+{%- macro github_free_space() -%}
+  - name: Free up disk space
+    if: runner.os == 'Linux' && runner.arch == 'X64'
+    shell: bash
+    run: |
+      df -h
+      echo "::group::/usr/local/*"
+      du -hsc /usr/local/*
+      echo "::endgroup::"
+      echo "::group::/usr/local/bin/*"
+      du -hsc /usr/local/bin/*
+      echo "::endgroup::"
+      # ~1GB (From 1.2GB to 214MB)
+      sudo rm -rf \
+        /usr/local/bin/aliyun \
+        /usr/local/bin/azcopy \
+        /usr/local/bin/bicep \
+        /usr/local/bin/cmake-gui \
+        /usr/local/bin/cpack \
+        /usr/local/bin/helm \
+        /usr/local/bin/hub \
+        /usr/local/bin/kubectl \
+        /usr/local/bin/minikube \
+        /usr/local/bin/node \
+        /usr/local/bin/packer \
+        /usr/local/bin/pulumi* \
+        /usr/local/bin/stack \
+        /usr/local/bin/terraform || :
+      echo "::group::/usr/local/share/*"
+      du -hsc /usr/local/share/*
+      echo "::endgroup::"
+      # 1.3GB
+      sudo rm -rf /usr/local/share/powershell || :
+      echo "::group::/opt/*"
+      du -hsc /opt/*
+      echo "::endgroup::"
+      echo "::group::/opt/hostedtoolcache/*"
+      du -hsc /opt/hostedtoolcache/*
+      echo "::endgroup::"
+      # 5.3GB
+      sudo rm -rf /opt/hostedtoolcache/CodeQL || :
+      # 1.4GB
+      sudo rm -rf /opt/hostedtoolcache/go || :
+      # 489MB
+      sudo rm -rf /opt/hostedtoolcache/PyPy || :
+      # 376MB
+      sudo rm -rf /opt/hostedtoolcache/node || :
+      # Remove Web browser packages
+      sudo apt-get purge -y -f firefox \
+              google-chrome-stable \
+              microsoft-edge-stable
+      df -h
+{% endmacro %}
+
 {%- macro github_upload_releases(pattern) -%}
   - name: Set up Python by actions/setup-python
     if: runner.arch == 'X64'

From 943bf4887648bd14a7acc071497a4e4c39788bbe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 1 Aug 2023 16:44:10 +0200
Subject: [PATCH 075/749] GH-36692: [CI][Packaging] Pin gemfury to 0.12.0 due
 to issue with faraday dependency (#36693)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Some nightly wheel jobs have failed to upload.

### What changes are included in this PR?

Install required gem dependency.

### Are these changes tested?

Yes, crossbow tasks

### Are there any user-facing changes?

No
* Closes: #36692

Lead-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/tasks/macros.jinja | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 5948b663d915b..757c15c937ce5 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -191,11 +191,25 @@ on:
     run: |
       sudo apt update
       sudo apt install -y ruby-full
+  - name: Set up Ruby by GitHub Actions
+    if: runner.arch == 'X64' && runner.os != 'macOS'
+    uses: ruby/setup-ruby@v1
+    with:
+      ruby-version: "ruby"
+  - name: Install gemfury client on ARM self-hosted
+    if: runner.arch != 'X64'
+    run: |
+      # GH-36692: Pin gemfury due to wrong faraday dependency declaration.
+      gem install --user-install gemfury -v 0.12.0
+      ruby -r rubygems -e 'puts("#{Gem.user_dir}/bin")' >> $GITHUB_PATH
+  - name: Install gemfury client
+    if: runner.arch == 'X64'
+    run: |
+      # GH-36692: Pin gemfury due to wrong faraday dependency declaration.
+      gem install gemfury -v 0.12.0
   - name: Upload package to Gemfury
     shell: bash
     run: |
-      PATH=$(echo $(ruby -r rubygems -e 'puts Gem.user_dir') | sed "s/C:\//\/c\//")/bin:$PATH
-      gem install --user-install gemfury
       fury push \
         --api-token=${CROSSBOW_GEMFURY_TOKEN} \
         --as=${CROSSBOW_GEMFURY_ORG} \

From 5bb53c7ffc9c7ca21d5d415bf8fde4d6b0034b47 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Tue, 1 Aug 2023 11:36:15 -0400
Subject: [PATCH 076/749] GH-36973: [CI][Python] Archery linter integrated with
 flake8==6.1.0 (#36976)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Fix archery lint issues with new version of flake8 dependency.

### What changes are included in this PR?

* Lint errors.

### Are these changes tested?

Yes.

```
$ flake8 --version
6.1.0 (mccabe: 0.7.0, pycodestyle: 2.11.0, pyflakes: 3.1.0) CPython 3.11.4 on Darwin
$ archery lint --python
INFO:archery:Running Python formatter (autopep8)
INFO:archery:Running Python linter (flake8)
INFO:archery:Running Cython linter (cython-lint)
$
```

### Are there any user-facing changes?

No
* Closes: #36973

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .pre-commit-config.yaml                     |  2 +-
 dev/archery/setup.py                        |  5 ++---
 python/pyarrow/tests/test_array.py          |  2 +-
 python/pyarrow/tests/test_csv.py            |  2 +-
 python/pyarrow/tests/test_dataset.py        |  8 ++++----
 python/pyarrow/tests/test_extension_type.py | 16 ++++++++--------
 python/pyarrow/tests/test_flight.py         |  2 +-
 python/pyarrow/tests/test_table.py          |  4 ++--
 8 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index e95778ce1cbfd..d3c7624f63e71 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -37,7 +37,7 @@ repos:
         entry: --entrypoint /bin/hadolint hadolint/hadolint:latest -
         exclude: ^dev/.*$
   - repo: https://github.com/pycqa/flake8
-    rev: 5.0.3
+    rev: 6.1.0
     hooks:
       - id: flake8
         name: Python Format
diff --git a/dev/archery/setup.py b/dev/archery/setup.py
index 7dbfe47d6eeb5..627e576fb6f59 100755
--- a/dev/archery/setup.py
+++ b/dev/archery/setup.py
@@ -28,9 +28,8 @@
 jinja_req = 'jinja2>=2.11'
 
 extras = {
-    'lint': [
-        'numpydoc==1.1.0', 'autopep8', 'flake8', 'cython-lint', 'cmake_format==0.6.13'
-    ],
+    'lint': ['numpydoc==1.1.0', 'autopep8', 'flake8==6.1.0', 'cython-lint',
+             'cmake_format==0.6.13'],
     'benchmark': ['pandas'],
     'docker': ['ruamel.yaml', 'python-dotenv'],
     'release': ['pygithub', jinja_req, 'jira', 'semver', 'gitpython'],
diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py
index 77eaca3dd1d54..0546830a661de 100644
--- a/python/pyarrow/tests/test_array.py
+++ b/python/pyarrow/tests/test_array.py
@@ -301,7 +301,7 @@ def test_asarray():
     np_arr = np.asarray([_ for _ in arr])
     assert np_arr.tolist() == [0, 1, 2, 3]
     assert np_arr.dtype == np.dtype('O')
-    assert type(np_arr[0]) == pa.lib.Int64Value
+    assert isinstance(np_arr[0], pa.lib.Int64Value)
 
     # Calling with the arrow array gives back an array with 'int64' dtype
     np_arr = np.asarray(arr)
diff --git a/python/pyarrow/tests/test_csv.py b/python/pyarrow/tests/test_csv.py
index e92afce035275..81c31d98ac7ec 100644
--- a/python/pyarrow/tests/test_csv.py
+++ b/python/pyarrow/tests/test_csv.py
@@ -1936,7 +1936,7 @@ def test_write_quoting_style():
             except Exception as e:
                 # This will trigger when we try to write a comma (,)
                 # without quotes, which is invalid
-                assert type(e) == res
+                assert isinstance(e, res)
                 break
         assert buf.getvalue() == res
         buf.seek(0)
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index a70cf2fbc72af..f92317c0f223e 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -5021,8 +5021,8 @@ def test_dataset_filter(tempdir, dstype):
 
     # Ensure chained filtering works.
     result = ds1.filter(pc.field("colA") < 3).filter(pc.field("col2") == "a")
-    assert type(result) == (ds.FileSystemDataset if dstype ==
-                            "fs" else ds.InMemoryDataset)
+    expected = ds.FileSystemDataset if dstype == "fs" else ds.InMemoryDataset
+    assert isinstance(result, expected)
 
     assert result.to_table() == pa.table({
         "colA": [1],
@@ -5181,9 +5181,9 @@ def test_read_table_nested_columns(tempdir, format):
                       "a.dotted.field": [1, 2],
                       "interaction": [
         {"type": None, "element": "button",
-         "values": [1, 2], "structs":[{"foo": "bar"}, None]},
+         "values": [1, 2], "structs": [{"foo": "bar"}, None]},
         {"type": "scroll", "element": "window",
-         "values": [None, 3, 4], "structs":[{"fizz": "buzz"}]}
+         "values": [None, 3, 4], "structs": [{"fizz": "buzz"}]}
     ]})
     ds.write_dataset(table, tempdir / "table", format=format)
     ds1 = ds.dataset(tempdir / "table", format=format)
diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py
index 009896fd67e40..973aa29c7583f 100644
--- a/python/pyarrow/tests/test_extension_type.py
+++ b/python/pyarrow/tests/test_extension_type.py
@@ -340,8 +340,8 @@ def test_ext_scalar_from_array():
     assert len(scalars_a) == 4
 
     assert ty1.__arrow_ext_scalar_class__() == UuidScalarType
-    assert type(a[0]) == UuidScalarType
-    assert type(scalars_a[0]) == UuidScalarType
+    assert isinstance(a[0], UuidScalarType)
+    assert isinstance(scalars_a[0], UuidScalarType)
 
     for s, val in zip(scalars_a, data):
         assert isinstance(s, pa.ExtensionScalar)
@@ -737,7 +737,7 @@ def __arrow_ext_deserialize__(cls, storage_type, serialized):
 
     def __eq__(self, other):
         if isinstance(other, pa.BaseExtensionType):
-            return (type(self) == type(other) and
+            return (isinstance(self, type(other)) and
                     self.freq == other.freq)
         else:
             return NotImplemented
@@ -799,7 +799,7 @@ def test_generic_ext_type_ipc(registered_period_type):
     arr = pa.ExtensionArray.from_storage(period_type, storage)
     batch = pa.RecordBatch.from_arrays([arr], ["ext"])
     # check the built array has exactly the expected clss
-    assert type(arr) == period_class
+    assert isinstance(arr, period_class)
 
     buf = ipc_write_batch(batch)
     del batch
@@ -807,7 +807,7 @@ def test_generic_ext_type_ipc(registered_period_type):
 
     result = batch.column(0)
     # check the deserialized array class is the expected one
-    assert type(result) == period_class
+    assert isinstance(result, period_class)
     assert result.type.extension_name == "test.period"
     assert arr.storage.to_pylist() == [1, 2, 3, 4]
 
@@ -830,7 +830,7 @@ def test_generic_ext_type_ipc(registered_period_type):
     result = batch.column(0)
     assert isinstance(result.type, PeriodType)
     assert result.type.freq == 'H'
-    assert type(result) == period_class
+    assert isinstance(result, period_class)
 
 
 def test_generic_ext_type_ipc_unknown(registered_period_type):
@@ -1261,7 +1261,7 @@ def test_tensor_type_ipc(tensor_type):
 
     # check the built array has exactly the expected clss
     tensor_class = tensor_type.__arrow_ext_class__()
-    assert type(arr) == tensor_class
+    assert isinstance(arr, tensor_class)
 
     buf = ipc_write_batch(batch)
     del batch
@@ -1269,7 +1269,7 @@ def test_tensor_type_ipc(tensor_type):
 
     result = batch.column(0)
     # check the deserialized array class is the expected one
-    assert type(result) == tensor_class
+    assert isinstance(result, tensor_class)
     assert result.type.extension_name == "arrow.fixed_shape_tensor"
     assert arr.storage.to_pylist() == [[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]]
 
diff --git a/python/pyarrow/tests/test_flight.py b/python/pyarrow/tests/test_flight.py
index 6c1c582dceb21..bf15ad0bc4d65 100644
--- a/python/pyarrow/tests/test_flight.py
+++ b/python/pyarrow/tests/test_flight.py
@@ -1495,7 +1495,7 @@ def test_tls_override_hostname():
     """Check that incorrectly overriding the hostname fails."""
     certs = example_tls_certs()
 
-    with ConstantFlightServer(tls_certificates=certs["certificates"]) as s,\
+    with ConstantFlightServer(tls_certificates=certs["certificates"]) as s, \
         flight.connect(('localhost', s.port),
                        tls_root_certs=certs["root_cert"],
                        override_hostname="fakehostname") as client:
diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py
index 61cfb1af587a7..e28256e91f0a6 100644
--- a/python/pyarrow/tests/test_table.py
+++ b/python/pyarrow/tests/test_table.py
@@ -511,7 +511,7 @@ def test_recordbatch_basics():
         ('c0', [0, 1, 2, 3, 4]),
         ('c1', [-10, -5, 0, None, 10])
     ])
-    assert type(pydict) == dict
+    assert isinstance(pydict, dict)
 
     with pytest.raises(IndexError):
         # bounds checking
@@ -949,7 +949,7 @@ def test_table_basics():
         ('a', [0, 1, 2, 3, 4]),
         ('b', [-10, -5, 0, 5, 10])
     ])
-    assert type(pydict) == dict
+    assert isinstance(pydict, dict)
 
     columns = []
     for col in table.itercolumns():

From 0fb744cb6029a9b7c8faa38205d73f94118ec7c5 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 1 Aug 2023 11:57:02 -0400
Subject: [PATCH 077/749] GH-36935: [Go] Fix Timestamp to Time dates (#36964)

### Rationale for this change
The previous solution converted everything to nanoseconds first but you end up with overflowing `int64` potentially. Since we've bumped the minimum version of the library to using go1.17+ we can use the newer `UnixMicro` and `UnixMilli` functions to make this easy.

### Are these changes tested?
Yes, unit test is added.

* Closes: #36935

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/datatype_fixedwidth.go      | 12 ++++++++++--
 go/arrow/datatype_fixedwidth_test.go |  7 +++++++
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index d6550c1cf896d..4b6ca55291537 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -192,10 +192,16 @@ func TimestampFromString(val string, unit TimeUnit) (Timestamp, error) {
 }
 
 func (t Timestamp) ToTime(unit TimeUnit) time.Time {
-	if unit == Second {
+	switch unit {
+	case Second:
 		return time.Unix(int64(t), 0).UTC()
+	case Millisecond:
+		return time.UnixMilli(int64(t)).UTC()
+	case Microsecond:
+		return time.UnixMicro(int64(t)).UTC()
+	default:
+		return time.Unix(0, int64(t)).UTC()
 	}
-	return time.Unix(0, int64(t)*int64(unit.Multiplier())).UTC()
 }
 
 // TimestampFromTime allows converting time.Time to Timestamp
@@ -327,6 +333,8 @@ const (
 
 var TimeUnitValues = []TimeUnit{Second, Millisecond, Microsecond, Nanosecond}
 
+// Multiplier returns a time.Duration value to multiply by in order to
+// convert the value into nanoseconds
 func (u TimeUnit) Multiplier() time.Duration {
 	return [...]time.Duration{time.Second, time.Millisecond, time.Microsecond, time.Nanosecond}[uint(u)&3]
 }
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index 50747366a255e..669c7f9ca87ad 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -159,6 +159,13 @@ func TestTimestampType(t *testing.T) {
 	}
 }
 
+func TestTimestampToTime(t *testing.T) {
+	ts := arrow.Timestamp(11865225600000)
+	tm := ts.ToTime(arrow.Millisecond)
+
+	assert.Equal(t, "2345-12-30 00:00:00", tm.Format("2006-01-02 15:04:05.999"))
+}
+
 func TestTime32Type(t *testing.T) {
 	for _, tc := range []struct {
 		unit arrow.TimeUnit

From f44e28fa03a64ae5b3d9352d21aee2cc84f9af6c Mon Sep 17 00:00:00 2001
From: Thor <8681572+thorfour@users.noreply.github.com>
Date: Tue, 1 Aug 2023 12:00:13 -0500
Subject: [PATCH 078/749] GH-36981: [Go] Fix ipc reader leak (#36982)

### Rationale for this change

Previously the ipc reader was leaking allocations.

### What changes are included in this PR?

Call `Clear()` on the memo table on final release of the ipc reader.

### Are these changes tested?

Yes

### Are there any user-facing changes?

* Closes: #36981

Authored-by: thorfour <me@thor-hansen.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/ipc/reader.go      |  1 +
 go/arrow/ipc/reader_test.go | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/go/arrow/ipc/reader.go b/go/arrow/ipc/reader.go
index 99aab597ce950..bee48cf965682 100644
--- a/go/arrow/ipc/reader.go
+++ b/go/arrow/ipc/reader.go
@@ -159,6 +159,7 @@ func (r *Reader) Release() {
 			r.r.Release()
 			r.r = nil
 		}
+		r.memo.Clear()
 	}
 }
 
diff --git a/go/arrow/ipc/reader_test.go b/go/arrow/ipc/reader_test.go
index a8930984fbf37..7bcf737af0d6d 100644
--- a/go/arrow/ipc/reader_test.go
+++ b/go/arrow/ipc/reader_test.go
@@ -56,3 +56,40 @@ func TestReaderCatchPanic(t *testing.T) {
 		assert.Contains(t, err.Error(), "arrow/ipc: unknown error while reading")
 	}
 }
+
+func TestReaderCheckedAllocator(t *testing.T) {
+	alloc := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer alloc.AssertSize(t, 0)
+	schema := arrow.NewSchema([]arrow.Field{
+		{
+			Name: "s",
+			Type: &arrow.DictionaryType{
+				ValueType: arrow.BinaryTypes.String,
+				IndexType: arrow.PrimitiveTypes.Int32,
+			},
+		},
+	}, nil)
+
+	b := array.NewRecordBuilder(alloc, schema)
+	defer b.Release()
+
+	bldr := b.Field(0).(*array.BinaryDictionaryBuilder)
+	bldr.Append([]byte("foo"))
+	bldr.Append([]byte("bar"))
+	bldr.Append([]byte("baz"))
+
+	rec := b.NewRecord()
+	defer rec.Release()
+
+	buf := new(bytes.Buffer)
+	writer := NewWriter(buf, WithSchema(schema), WithAllocator(alloc))
+	defer writer.Close()
+	require.NoError(t, writer.Write(rec))
+
+	reader, err := NewReader(buf, WithAllocator(alloc))
+	require.NoError(t, err)
+	defer reader.Release()
+
+	_, err = reader.Read()
+	require.NoError(t, err)
+}

From e34d4c93761d4761f0df2626114927c80a81a87f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 2 Aug 2023 00:20:00 +0200
Subject: [PATCH 079/749] GH-36199: [Python][CI][Spark] Update spark versions
 used on our nightly tests (#36347)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

We are currently testing with very old or deprecated spark versions.

### What changes are included in this PR?

Update the spark versions to be tested.

### Are these changes tested?

They will via archery

### Are there any user-facing changes?

No
* Closes: #36199

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/tasks/tasks.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 25bda38809e3b..73b793162d959 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1588,9 +1588,9 @@ tasks:
       image: conda-python-hdfs
 {% endfor %}
 
-{% for python_version, spark_version, test_pyarrow_only, numpy_version in [("3.8", "v3.1.2", "false", "latest"),
-                                                                           ("3.9", "v3.2.0", "false", "1.23"),
-                                                                           ("3.10", "master", "false", "latest")] %}
+{% for python_version, spark_version, test_pyarrow_only, numpy_version in [("3.8", "v3.4.1", "false", "latest"),
+                                                                           ("3.10", "v3.4.1", "false", "1.23"),
+                                                                           ("3.11", "master", "false", "latest")] %}
   test-conda-python-{{ python_version }}-spark-{{ spark_version }}:
     ci: github
     template: docker-tests/github.linux.yml

From 7325a0160acd0f4c708d5abfd34cc8eb6df6c8eb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 2 Aug 2023 00:25:28 +0200
Subject: [PATCH 080/749] MINOR: [C#] Bump Grpc.Tools from 2.42.0 to 2.56.2 in
 /csharp (#36727)

Bumps [Grpc.Tools](https://github.com/grpc/grpc) from 2.42.0 to 2.56.2.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/grpc/grpc/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Tools&package-manager=nuget&previous-version=2.42.0&new-version=2.56.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index d9956ed49cc44..0bcd6c87b0d06 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.19.3" />
     <PackageReference Include="Grpc.Net.Client" Version="2.52.0" />
-    <PackageReference Include="Grpc.Tools" Version="2.42.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.56.2" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">

From b8e450347ab111a4f8b2fe5134c59235bcd50b20 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 2 Aug 2023 06:27:12 +0800
Subject: [PATCH 081/749] MINOR: [C++] Acero tiny typo fix (#36938)

### Rationale for this change

1. Some typo fix in acero
2. move `std::shared_ptr<Schema>` rather than copy

### What changes are included in this PR?

1. Some typo fix in acero
2. move `std::shared_ptr<Schema>` rather than copy

### Are these changes tested?

no

### Are there any user-facing changes?

no

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 cpp/src/arrow/acero/exec_plan.h |  2 +-
 cpp/src/arrow/acero/options.h   | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/acero/exec_plan.h b/cpp/src/arrow/acero/exec_plan.h
index 04303aa9512b1..dba6c64ddc837 100644
--- a/cpp/src/arrow/acero/exec_plan.h
+++ b/cpp/src/arrow/acero/exec_plan.h
@@ -739,7 +739,7 @@ DeclarationToBatchesAsync(Declaration declaration, ExecContext exec_context);
 /// \brief Utility method to run a declaration and return results as a RecordBatchReader
 ///
 /// If an exec context is not provided then a default exec context will be used based
-/// on the value of `use_threads`.  If `use_threads` is false then the CPU exeuctor will
+/// on the value of `use_threads`.  If `use_threads` is false then the CPU executor will
 /// be a serial executor and all CPU work will be done on the calling thread.  I/O tasks
 /// will still happen on the I/O executor and may be multi-threaded.
 ///
diff --git a/cpp/src/arrow/acero/options.h b/cpp/src/arrow/acero/options.h
index bb94bdaa4a628..1ede3fbfc8ed0 100644
--- a/cpp/src/arrow/acero/options.h
+++ b/cpp/src/arrow/acero/options.h
@@ -80,7 +80,7 @@ class ARROW_ACERO_EXPORT ExecNodeOptions {
 ///
 /// For each batch received a new task will be created to push that batch downstream.
 /// This task will slice smaller units of size `ExecPlan::kMaxBatchSize` from the
-/// parent batch and call InputRecieved.  Thus, if the `generator` yields a large
+/// parent batch and call InputReceived.  Thus, if the `generator` yields a large
 /// batch it may result in several calls to InputReceived.
 ///
 /// The SourceNode will, by default, assign an implicit ordering to outgoing batches.
@@ -115,7 +115,7 @@ class ARROW_ACERO_EXPORT TableSourceNodeOptions : public ExecNodeOptions {
   /// Create an instance from values
   TableSourceNodeOptions(std::shared_ptr<Table> table,
                          int64_t max_batch_size = kDefaultMaxBatchSize)
-      : table(table), max_batch_size(max_batch_size) {}
+      : table(std::move(table)), max_batch_size(max_batch_size) {}
 
   /// \brief a table which acts as the data source
   std::shared_ptr<Table> table;
@@ -135,7 +135,7 @@ class ARROW_ACERO_EXPORT NamedTableNodeOptions : public ExecNodeOptions {
  public:
   /// Create an instance from values
   NamedTableNodeOptions(std::vector<std::string> names, std::shared_ptr<Schema> schema)
-      : names(std::move(names)), schema(schema) {}
+      : names(std::move(names)), schema(std::move(schema)) {}
 
   /// \brief the names to put in the serialized plan
   std::vector<std::string> names;
@@ -156,7 +156,7 @@ class ARROW_ACERO_EXPORT SchemaSourceNodeOptions : public ExecNodeOptions {
   /// Create an instance that will create a new task on io_executor for each iteration
   SchemaSourceNodeOptions(std::shared_ptr<Schema> schema, ItMaker it_maker,
                           arrow::internal::Executor* io_executor)
-      : schema(schema),
+      : schema(std::move(schema)),
         it_maker(std::move(it_maker)),
         io_executor(io_executor),
         requires_io(true) {}
@@ -165,7 +165,7 @@ class ARROW_ACERO_EXPORT SchemaSourceNodeOptions : public ExecNodeOptions {
   /// executor
   SchemaSourceNodeOptions(std::shared_ptr<Schema> schema, ItMaker it_maker,
                           bool requires_io = false)
-      : schema(schema),
+      : schema(std::move(schema)),
         it_maker(std::move(it_maker)),
         io_executor(NULLPTR),
         requires_io(requires_io) {}

From a046b882676c7b7826ac7b09f200622c80952cba Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 2 Aug 2023 08:23:39 +0900
Subject: [PATCH 082/749] MINOR: [C#] Bump Grpc.Net.Client from 2.52.0 to
 2.55.0 in /csharp (#36729)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.Net.Client](https://github.com/grpc/grpc-dotnet) from 2.52.0 to 2.55.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.Net.Client's releases</a>.</em></p>
<blockquote>
<h2>Release v2.55.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Upgrade version to v2.55.0 (on v2.55.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2184">grpc/grpc-dotnet#2184</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0-pre1...v2.55.0">https://github.com/grpc/grpc-dotnet/compare/v2.55.0-pre1...v2.55.0</a></p>
<h2>Release v2.55.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix flaky streaming test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2134">grpc/grpc-dotnet#2134</a></li>
<li>Update Google.Protobuf to 3.23.1 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2136">grpc/grpc-dotnet#2136</a></li>
<li>Refactor healthchecks service mapping to support filtering on check by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2142">grpc/grpc-dotnet#2142</a></li>
<li>Fix client factory extension method validation issues by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2159">grpc/grpc-dotnet#2159</a></li>
<li>WriteAsync cancellation throws an error with the calls completed status if possible by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2170">grpc/grpc-dotnet#2170</a></li>
<li>Update Grpc.Tools to 2.55 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2171">grpc/grpc-dotnet#2171</a></li>
<li>Update 2.55 branch to 2.55-pre1 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2176">grpc/grpc-dotnet#2176</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.54.0...v2.55.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.54.0...v2.55.0-pre1</a></p>
<h2>Release v2.54.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Bump v2.54.x to v2.54.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2166">grpc/grpc-dotnet#2166</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.54.0-pre1...v2.54.0">https://github.com/grpc/grpc-dotnet/compare/v2.54.0-pre1...v2.54.0</a></p>
<h2>Release v2.54.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Update version to 2.54.0-dev (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2096">grpc/grpc-dotnet#2096</a></li>
<li>Enable NRTs throughout by <a href="https://github.com/mgravell"><code>@​mgravell</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2102">grpc/grpc-dotnet#2102</a></li>
<li>Change some gRPC client error logs to debug level by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2106">grpc/grpc-dotnet#2106</a></li>
<li>Add remove method to balancer attributes collection by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2110">grpc/grpc-dotnet#2110</a></li>
<li>Make CancellationToken available in call credentials interceptor by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2107">grpc/grpc-dotnet#2107</a></li>
<li>Remove host override from container sample by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2109">grpc/grpc-dotnet#2109</a></li>
<li>Fix missing port from DnsResolver host override value by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2111">grpc/grpc-dotnet#2111</a></li>
<li>Fix bugs related to channel dispose while there are active calls by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2120">grpc/grpc-dotnet#2120</a></li>
<li>Update Grpc.Tools to 2.54.0 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2127">grpc/grpc-dotnet#2127</a></li>
<li>Add IReadOnlyDictionary to BalancerAttributes collection by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2121">grpc/grpc-dotnet#2121</a></li>
<li>Fix capturing ExecutionContext by timers and background tasks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2129">grpc/grpc-dotnet#2129</a></li>
<li>Final PRs and fix gRPC-Web on v2.54.x by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2131">grpc/grpc-dotnet#2131</a></li>
<li>Update to 2.54.0.pre1 on v2.54.x release branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2130">grpc/grpc-dotnet#2130</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/mgravell"><code>@​mgravell</code></a> made their first contribution in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2102">grpc/grpc-dotnet#2102</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.53.0...v2.54.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.53.0...v2.54.0-pre1</a></p>
<h2>Release v2.53.0</h2>
<h2>What's Changed</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/8ca08ebf05b0c81c15cb68baf5196ffe5ed7b5a3"><code>8ca08eb</code></a> Upgrade version to v2.55.0 (on v2.55.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2184">#2184</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/76824eaeffbd4caa0fed8df37b3c391135e2d195"><code>76824ea</code></a> Update 2.55 branch to 2.55-pre1 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2176">#2176</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c72ada62e626afe5bf546486fe7f703edf41ca3e"><code>c72ada6</code></a> Update Grpc.Tools to 2.55 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2171">#2171</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/2be676ad3bb784a876c0f681d95565bd85d509dc"><code>2be676a</code></a> WriteAsync cancellation throws an error with the calls completed status if po...</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/73c726bf4e3ef4cac0e81e1edb7987afbddccd42"><code>73c726b</code></a> Fix client factory extension method validation issues (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2159">#2159</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/697f3492f28c8d2e4c66019a199aaef821f772ec"><code>697f349</code></a> Refactor healthchecks service mapping to support filtering on check (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2142">#2142</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/ff1a07b90c498f259e6d9f4a50cdad7c89ecd3c0"><code>ff1a07b</code></a> Update Google.Protobuf to 3.23.1 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2136">#2136</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6bc44e97d73244de9da410e6cccc7409b7c173df"><code>6bc44e9</code></a> Fix flaky streaming test (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2134">#2134</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/f9a00bc490e25ce3bec9ed0eb0474fef4487447e"><code>f9a00bc</code></a> Fix capturing ExecutionContext by timers and background tasks (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2129">#2129</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/2dc971e013645afe3d3ef387f3d743c63c5acb2a"><code>2dc971e</code></a> Add IReadOnlyDictionary to BalancerAttributes collection (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2121">#2121</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.52.0...v2.55.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Net.Client&package-manager=nuget&previous-version=2.52.0&new-version=2.55.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 0bcd6c87b0d06..ed33d88861415 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -6,7 +6,7 @@
   
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.19.3" />
-    <PackageReference Include="Grpc.Net.Client" Version="2.52.0" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
     <PackageReference Include="Grpc.Tools" Version="2.56.2" PrivateAssets="All" />
   </ItemGroup>
 

From 0edef8c90797ba5dcadd0daf5009dc2d91ecd099 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Tue, 1 Aug 2023 19:39:39 -0400
Subject: [PATCH 083/749] GH-36975: [C++][FlightRPC] Skip unknown fields, don't
 crash (#36979)

### Rationale for this change

We should skip unknown fields instead of crashing, for forwards compatibility.

### What changes are included in this PR?

Skip unknown fields in the FlightData deserializer.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #36975

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/flight_internals_test.cc | 35 +++++++++++++++++++
 .../transport/grpc/serialization_internal.cc  | 34 ++++++++++--------
 2 files changed, 54 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index 27c13ff949836..e56bab6db2092 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -34,6 +34,9 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/string.h"
 
+// Include after Flight headers
+#include <grpc/slice.h>
+
 namespace arrow {
 namespace flight {
 
@@ -651,6 +654,38 @@ TEST_F(TestCookieParsing, CookieCache) {
   AddCookieVerifyCache({"id0=0;", "id1=1;", "id2=2"}, "id0=0; id1=1; id2=2");
 }
 
+// ----------------------------------------------------------------------
+// Protobuf tests
+
+TEST(GrpcTransport, FlightDataDeserialize) {
+#ifndef _WIN32
+  pb::FlightData raw;
+  // Tack on known and unknown fields by hand here
+  raw.GetReflection()->MutableUnknownFields(&raw)->AddFixed32(900, 1024);
+  raw.GetReflection()->MutableUnknownFields(&raw)->AddFixed64(901, 1024);
+  raw.GetReflection()->MutableUnknownFields(&raw)->AddVarint(902, 1024);
+  raw.GetReflection()->MutableUnknownFields(&raw)->AddLengthDelimited(903, "foobar");
+  // Known field comes at end
+  raw.GetReflection()->MutableUnknownFields(&raw)->AddLengthDelimited(
+      pb::FlightData::kDataBodyFieldNumber, "data");
+
+  auto serialized = raw.SerializeAsString();
+
+  grpc_slice slice = grpc_slice_from_copied_buffer(serialized.data(), serialized.size());
+  // gRPC requires that grpc_slice and grpc::Slice have the same representation
+  grpc::ByteBuffer buffer(reinterpret_cast<const grpc::Slice*>(&slice), /*nslices=*/1);
+
+  flight::internal::FlightData out;
+  auto status = flight::transport::grpc::FlightDataDeserialize(&buffer, &out);
+  ASSERT_TRUE(status.ok());
+  ASSERT_EQ("data", out.body->ToString());
+
+  grpc_slice_unref(slice);
+#else
+  GTEST_SKIP() << "Can't use Protobuf symbols on Windows";
+#endif
+}
+
 // ----------------------------------------------------------------------
 // Transport abstraction tests
 
diff --git a/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc b/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc
index cff111d64df91..372dca7a2c4c8 100644
--- a/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc
+++ b/cpp/src/arrow/flight/transport/grpc/serialization_internal.cc
@@ -21,6 +21,7 @@
 
 #include <cstdint>
 #include <limits>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -297,7 +298,7 @@ ::grpc::Status FlightDataSerialize(const FlightPayload& msg, ByteBuffer* out,
         const auto remainder = static_cast<int>(
             bit_util::RoundUpToMultipleOf8(buffer->size()) - buffer->size());
         if (remainder) {
-          slices.push_back(::grpc::Slice(kPaddingBytes, remainder));
+          slices.emplace_back(kPaddingBytes, remainder);
         }
       }
     }
@@ -316,7 +317,7 @@ ::grpc::Status FlightDataSerialize(const FlightPayload& msg, ByteBuffer* out,
 ::grpc::Status FlightDataDeserialize(ByteBuffer* buffer,
                                      arrow::flight::internal::FlightData* out) {
   if (!buffer) {
-    return ::grpc::Status(::grpc::StatusCode::INTERNAL, "No payload");
+    return {::grpc::StatusCode::INTERNAL, "No payload"};
   }
 
   // Reset fields in case the caller reuses a single allocation
@@ -342,42 +343,45 @@ ::grpc::Status FlightDataDeserialize(ByteBuffer* buffer,
         pb::FlightDescriptor pb_descriptor;
         uint32_t length;
         if (!pb_stream.ReadVarint32(&length)) {
-          return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                                "Unable to parse length of FlightDescriptor");
+          return {::grpc::StatusCode::INTERNAL,
+                  "Unable to parse length of FlightDescriptor"};
         }
         // Can't use ParseFromCodedStream as this reads the entire
         // rest of the stream into the descriptor command field.
         std::string buffer;
         pb_stream.ReadString(&buffer, length);
         if (!pb_descriptor.ParseFromString(buffer)) {
-          return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                                "Unable to parse FlightDescriptor");
+          return {::grpc::StatusCode::INTERNAL, "Unable to parse FlightDescriptor"};
         }
         arrow::flight::FlightDescriptor descriptor;
         GRPC_RETURN_NOT_OK(
             arrow::flight::internal::FromProto(pb_descriptor, &descriptor));
-        out->descriptor.reset(new arrow::flight::FlightDescriptor(descriptor));
+        out->descriptor = std::make_unique<arrow::flight::FlightDescriptor>(descriptor);
       } break;
       case pb::FlightData::kDataHeaderFieldNumber: {
         if (!ReadBytesZeroCopy(wrapped_buffer, &pb_stream, &out->metadata)) {
-          return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                                "Unable to read FlightData metadata");
+          return {::grpc::StatusCode::INTERNAL, "Unable to read FlightData metadata"};
         }
       } break;
       case pb::FlightData::kAppMetadataFieldNumber: {
         if (!ReadBytesZeroCopy(wrapped_buffer, &pb_stream, &out->app_metadata)) {
-          return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                                "Unable to read FlightData application metadata");
+          return {::grpc::StatusCode::INTERNAL,
+                  "Unable to read FlightData application metadata"};
         }
       } break;
       case pb::FlightData::kDataBodyFieldNumber: {
         if (!ReadBytesZeroCopy(wrapped_buffer, &pb_stream, &out->body)) {
-          return ::grpc::Status(::grpc::StatusCode::INTERNAL,
-                                "Unable to read FlightData body");
+          return {::grpc::StatusCode::INTERNAL, "Unable to read FlightData body"};
         }
       } break;
-      default:
-        DCHECK(false) << "cannot happen";
+      default: {
+        // Unknown field. We should skip it for compatibility.
+        if (!WireFormatLite::SkipField(&pb_stream, tag)) {
+          return {::grpc::StatusCode::INTERNAL,
+                  "Could not skip unknown field tag in FlightData"};
+        }
+        break;
+      }
     }
   }
   buffer->Clear();

From 836aa1e5ccaa20fb5d3b4b7f44adc84642ff0e56 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 2 Aug 2023 11:23:44 +0800
Subject: [PATCH 084/749] GH-36970: [C++][Parquet] Minor style fix for parquet
 metadata (#36971)

### Rationale for this change

Minor style fix

### What changes are included in this PR?

1. Change `new` to `make_unique` or `make_shared`
2. Add a reserve for `column_order`

### Are these changes tested?

Not required.

### Are there any user-facing changes?

no

* Closes: #36970

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
---
 cpp/src/parquet/metadata.cc       | 15 ++++++++-------
 cpp/src/parquet/thrift_internal.h |  3 +--
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc
index 541bcc18b8bc3..8aedf5b926add 100644
--- a/cpp/src/parquet/metadata.cc
+++ b/cpp/src/parquet/metadata.cc
@@ -593,13 +593,13 @@ class FileMetaData::FileMetaDataImpl {
   FileMetaDataImpl() = default;
 
   explicit FileMetaDataImpl(
-      const void* metadata, uint32_t* metadata_len, const ReaderProperties& properties,
+      const void* metadata, uint32_t* metadata_len, ReaderProperties properties,
       std::shared_ptr<InternalFileDecryptor> file_decryptor = nullptr)
-      : properties_(properties), file_decryptor_(file_decryptor) {
-    metadata_.reset(new format::FileMetaData);
+      : properties_(std::move(properties)), file_decryptor_(std::move(file_decryptor)) {
+    metadata_ = std::make_unique<format::FileMetaData>();
 
     auto footer_decryptor =
-        file_decryptor_ != nullptr ? file_decryptor->GetFooterDecryptor() : nullptr;
+        file_decryptor_ != nullptr ? file_decryptor_->GetFooterDecryptor() : nullptr;
 
     ThriftDeserializer deserializer(properties_);
     deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(metadata),
@@ -779,8 +779,8 @@ class FileMetaData::FileMetaDataImpl {
     }
 
     std::shared_ptr<FileMetaData> out(new FileMetaData());
-    out->impl_.reset(new FileMetaDataImpl());
-    out->impl_->metadata_.reset(new format::FileMetaData());
+    out->impl_ = std::make_unique<FileMetaDataImpl>();
+    out->impl_->metadata_ = std::make_unique<format::FileMetaData>();
 
     auto metadata = out->impl_->metadata_.get();
     metadata->version = metadata_->version;
@@ -834,6 +834,7 @@ class FileMetaData::FileMetaDataImpl {
     // update ColumnOrder
     std::vector<parquet::ColumnOrder> column_orders;
     if (metadata_->__isset.column_orders) {
+      column_orders.reserve(metadata_->column_orders.size());
       for (auto column_order : metadata_->column_orders) {
         if (column_order.__isset.TYPE_ORDER) {
           column_orders.push_back(ColumnOrder::type_defined_);
@@ -865,7 +866,7 @@ std::shared_ptr<FileMetaData> FileMetaData::Make(
     std::shared_ptr<InternalFileDecryptor> file_decryptor) {
   // This FileMetaData ctor is private, not compatible with std::make_shared
   return std::shared_ptr<FileMetaData>(
-      new FileMetaData(metadata, metadata_len, properties, file_decryptor));
+      new FileMetaData(metadata, metadata_len, properties, std::move(file_decryptor)));
 }
 
 std::shared_ptr<FileMetaData> FileMetaData::Make(
diff --git a/cpp/src/parquet/thrift_internal.h b/cpp/src/parquet/thrift_internal.h
index e9b859541b759..5824a82d5b86d 100644
--- a/cpp/src/parquet/thrift_internal.h
+++ b/cpp/src/parquet/thrift_internal.h
@@ -435,8 +435,7 @@ class ThriftDeserializer {
 #if PARQUET_THRIFT_VERSION_MAJOR > 0 || PARQUET_THRIFT_VERSION_MINOR >= 14
     auto conf = std::make_shared<apache::thrift::TConfiguration>();
     conf->setMaxMessageSize(std::numeric_limits<int>::max());
-    return std::shared_ptr<ThriftBuffer>(
-        new ThriftBuffer(buf, len, ThriftBuffer::OBSERVE, conf));
+    return std::make_shared<ThriftBuffer>(buf, len, ThriftBuffer::OBSERVE, conf);
 #else
     return std::make_shared<ThriftBuffer>(buf, len);
 #endif

From 35019647b672e9a03e6b69aa6f1ad285be1c2aee Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Wed, 2 Aug 2023 15:20:08 -0400
Subject: [PATCH 085/749] GH-36069: [Java] Ensure S3 is finalized on shutdown
 (#36934)

### Rationale for this change

Java datasets can implicitly create an S3 filesystem, which will initialize S3 APIs. There is currently no explicit call to shutdown S3 APIs in Java, which results in a warning message being printed at runtime:

`arrow::fs::FinalizeS3 was not called even though S3 was initialized. This could lead to a segmentation fault at exit`

### What changes are included in this PR?

* Add a Java runtime shutdown hook that calls `EnsureS3Finalized()` via JNI. This is a noop if S3 is uninitialized or already finalized.

### Are these changes tested?

Yes, reproduced with:

```
import org.apache.arrow.dataset.file.FileFormat;
import org.apache.arrow.dataset.file.FileSystemDatasetFactory;
import org.apache.arrow.dataset.jni.NativeMemoryPool;
import org.apache.arrow.dataset.source.DatasetFactory;
import org.apache.arrow.memory.BufferAllocator;
import org.apache.arrow.memory.RootAllocator;

public class DatasetModule {
    public static void main(String[] args) {
        String uri = "s3://voltrondata-labs-datasets/nyc-taxi-tiny/year=2022/month=2/part-0.parquet";
        try (
            BufferAllocator allocator = new RootAllocator();
            DatasetFactory datasetFactory = new FileSystemDatasetFactory(allocator, NativeMemoryPool.getDefault(), FileFormat.PARQUET, uri);
        ) {
            // S3 is initialized
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

I didn't think a unit test was worth adding. Let me know if you think otherwise. Reasoning:
* We can't test the actual shutdown since thats a JVM thing.
* We could test to see if the hook is registered, but that involves exposing the API and having access to the thread object registered with the hook. Or using reflection to obtain it. Not worth it IMO.
* No need to test the functionality inside the hook, its just a wrapper around a single C++ API with no params/retval.

### Are there any user-facing changes?

No
* Closes: #36069

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/dataset/src/main/cpp/jni_wrapper.cc            | 13 +++++++++++++
 .../org/apache/arrow/dataset/jni/JniLoader.java     |  5 +++++
 .../org/apache/arrow/dataset/jni/JniWrapper.java    |  6 ++++++
 3 files changed, 24 insertions(+)

diff --git a/java/dataset/src/main/cpp/jni_wrapper.cc b/java/dataset/src/main/cpp/jni_wrapper.cc
index 871a2e95b94ec..5640bc4349670 100644
--- a/java/dataset/src/main/cpp/jni_wrapper.cc
+++ b/java/dataset/src/main/cpp/jni_wrapper.cc
@@ -27,6 +27,7 @@
 #include "arrow/dataset/file_base.h"
 #include "arrow/filesystem/localfs.h"
 #include "arrow/filesystem/path_util.h"
+#include "arrow/filesystem/s3fs.h"
 #include "arrow/engine/substrait/util.h"
 #include "arrow/ipc/api.h"
 #include "arrow/util/iterator.h"
@@ -569,6 +570,18 @@ JNIEXPORT void JNICALL Java_org_apache_arrow_dataset_jni_JniWrapper_releaseBuffe
   JNI_METHOD_END()
 }
 
+/*
+ * Class:     org_apache_arrow_dataset_jni_JniWrapper
+ * Method:    ensureS3Finalized
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_org_apache_arrow_dataset_jni_JniWrapper_ensureS3Finalized(
+    JNIEnv* env, jobject) {
+  JNI_METHOD_START
+  JniAssertOkOrThrow(arrow::fs::EnsureS3Finalized());
+  JNI_METHOD_END()
+}
+
 /*
  * Class:     org_apache_arrow_dataset_file_JniWrapper
  * Method:    makeFileSystemDatasetFactory
diff --git a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniLoader.java b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniLoader.java
index 7ada21c058280..a3b31c73e8540 100644
--- a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniLoader.java
+++ b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniLoader.java
@@ -59,6 +59,7 @@ public void ensureLoaded() {
       return;
     }
     loadRemaining();
+    ensureS3FinalizedOnShutdown();
   }
 
   private synchronized void loadRemaining() {
@@ -109,4 +110,8 @@ private String getNormalizedArch() {
     }
     return arch;
   }
+
+  private void ensureS3FinalizedOnShutdown() {
+    Runtime.getRuntime().addShutdownHook(new Thread(() -> { JniWrapper.get().ensureS3Finalized(); }));
+  }
 }
diff --git a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
index 1a9d4188c168f..93cc5d7a37040 100644
--- a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
+++ b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
@@ -108,4 +108,10 @@ private JniWrapper() {
    * @param bufferId the native pointer of the arrow::Buffer instance.
    */
   public native void releaseBuffer(long bufferId);
+
+  /**
+   * Ensure the S3 APIs are shutdown, but only if not already done. If the S3 APIs are unintialized,
+   * then this is a noop.
+   */
+  public native void ensureS3Finalized();
 }

From 0de6673e34f453fadd3841690bd14aa703a17001 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 2 Aug 2023 22:22:51 +0200
Subject: [PATCH 086/749] MINOR: [Doc][Release] Update wrong reference from
 JIRA to GitHub issues (#36989)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Some stray doc references from the JIRA to GitHub migration.

### What changes are included in this PR?

A couple of docs changes on the mail and the Archery release curate report.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/archery/archery/templates/release_curation.txt.j2 | 2 +-
 dev/release/02-source-test.rb                         | 2 +-
 dev/release/02-source.sh                              | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dev/archery/archery/templates/release_curation.txt.j2 b/dev/archery/archery/templates/release_curation.txt.j2
index 0796f451625f1..8e72290366bdd 100644
--- a/dev/archery/archery/templates/release_curation.txt.j2
+++ b/dev/archery/archery/templates/release_curation.txt.j2
@@ -39,7 +39,7 @@
 {% for commit in noissue -%}
  - {{ commit.url }} {{ commit.title }}
 {% endfor %}
-### JIRA issues in version {{ release.version }} without a linked patch: {{ nopatch|length }}
+### GitHub issues in version {{ release.version }} without a linked patch: {{ nopatch|length }}
 {% for issue in nopatch -%}
  - https://github.com/apache/arrow/issues/{{ issue.key }}
 {% endfor %}
diff --git a/dev/release/02-source-test.rb b/dev/release/02-source-test.rb
index 1d0fd19d01b84..b9e6a8505b72b 100644
--- a/dev/release/02-source-test.rb
+++ b/dev/release/02-source-test.rb
@@ -134,7 +134,7 @@ def test_vote
 
 I would like to propose the following release candidate (RC0) of Apache
 Arrow version #{@release_version}. This is a release consisting of #{n_resolved_issues}
-resolved JIRA issues[1].
+resolved GitHub issues[1].
 
 This release candidate is based on commit:
 #{@current_commit} [2]
diff --git a/dev/release/02-source.sh b/dev/release/02-source.sh
index 1e54d6d10db76..e9cd7126361cd 100755
--- a/dev/release/02-source.sh
+++ b/dev/release/02-source.sh
@@ -168,7 +168,7 @@ Hi,
 
 I would like to propose the following release candidate (RC${rc}) of Apache
 Arrow version ${version}. This is a release consisting of ${n_resolved_issues}
-resolved JIRA issues[1].
+resolved GitHub issues[1].
 
 This release candidate is based on commit:
 ${release_hash} [2]

From 710f96069f9f036338a0dd99202f0486bb7d1984 Mon Sep 17 00:00:00 2001
From: KarateSnowMachine <KarateSnowMachine@users.noreply.github.com>
Date: Thu, 3 Aug 2023 05:32:52 -0400
Subject: [PATCH 087/749] GH-36189: [C++][Parquet] StreamReader::SkipRows()
 skips to incorrect place in multi-row-group files (#36191)

### Rationale for this change

The behavior of Parquet `StreamReader::SkipRows()` is wrong due to an error in calculating the row offset from the current row group.

### What changes are included in this PR?

A unit test case demonstrating the failure and a trivial fix.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No

I am not sure if this bug is critical given how long it has existed in the code and no one has seemed to notice. There are two manifestations of this bug that might give the user the wrong impression about what is in their data:

* sometimes a negative return value is returned, which is unexpected given the nature of the API, so the user should know something is up (this is how I discovered the bug)
* the `SkipRows()` call leads to setting of the `eof` flag prematurely, which might lead the user to think there is less data in the file than there is.
* Closes: #36189

Lead-authored-by: Paul Rosenfeld <prosenfeld@gmail.com>
Co-authored-by: Gang Wu <ustcwg@gmail.com>
Co-authored-by: KarateSnowMachine <KarateSnowMachine@users.noreply.github.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
---
 cpp/src/parquet/stream_reader.cc      |   2 +-
 cpp/src/parquet/stream_reader_test.cc | 112 +++++++++++++++++++++++---
 2 files changed, 101 insertions(+), 13 deletions(-)

diff --git a/cpp/src/parquet/stream_reader.cc b/cpp/src/parquet/stream_reader.cc
index 0fecb1bf24615..d3353aa334256 100644
--- a/cpp/src/parquet/stream_reader.cc
+++ b/cpp/src/parquet/stream_reader.cc
@@ -441,7 +441,7 @@ int64_t StreamReader::SkipRows(int64_t num_rows_to_skip) {
   while (!eof_ && (num_rows_remaining_to_skip > 0)) {
     int64_t num_rows_in_row_group = row_group_reader_->metadata()->num_rows();
     int64_t num_rows_remaining_in_row_group =
-        num_rows_in_row_group - current_row_ - row_group_row_offset_;
+        num_rows_in_row_group - (current_row_ - row_group_row_offset_);
 
     if (num_rows_remaining_in_row_group > num_rows_remaining_to_skip) {
       for (auto reader : column_readers_) {
diff --git a/cpp/src/parquet/stream_reader_test.cc b/cpp/src/parquet/stream_reader_test.cc
index fed036bca546a..04140f6ad0c3a 100644
--- a/cpp/src/parquet/stream_reader_test.cc
+++ b/cpp/src/parquet/stream_reader_test.cc
@@ -17,13 +17,11 @@
 
 #include "parquet/stream_reader.h"
 
-#include <fcntl.h>
 #include <gtest/gtest.h>
 
 #include <chrono>
 #include <ctime>
 #include <memory>
-#include <utility>
 
 #include "arrow/io/file.h"
 #include "arrow/util/decimal.h"
@@ -38,7 +36,7 @@ using optional = StreamReader::optional<T>;
 using ::std::nullopt;
 
 struct TestData {
-  static void init() { std::time(&ts_offset_); }
+  static void Init() { std::time(&ts_offset_); }
 
   static constexpr int num_rows = 2000;
 
@@ -145,18 +143,18 @@ constexpr int TestData::num_rows;
 
 class TestStreamReader : public ::testing::Test {
  public:
-  TestStreamReader() { createTestFile(); }
+  TestStreamReader() { CreateTestFile(); }
 
  protected:
   const char* GetDataFile() const { return "stream_reader_test.parquet"; }
 
-  void SetUp() {
+  void SetUp() override {
     PARQUET_ASSIGN_OR_THROW(auto infile, ::arrow::io::ReadableFile::Open(GetDataFile()));
     auto file_reader = parquet::ParquetFileReader::Open(infile);
     reader_ = StreamReader{std::move(file_reader)};
   }
 
-  void TearDown() { reader_ = StreamReader{}; }
+  void TearDown() override { reader_ = StreamReader{}; }
 
   std::shared_ptr<schema::GroupNode> GetSchema() {
     schema::NodeVector fields;
@@ -201,7 +199,7 @@ class TestStreamReader : public ::testing::Test {
         schema::GroupNode::Make("schema", Repetition::REQUIRED, fields));
   }
 
-  void createTestFile() {
+  void CreateTestFile() {
     PARQUET_ASSIGN_OR_THROW(auto outfile,
                             ::arrow::io::FileOutputStream::Open(GetDataFile()));
 
@@ -209,7 +207,7 @@ class TestStreamReader : public ::testing::Test {
 
     StreamWriter os{std::move(file_writer)};
 
-    TestData::init();
+    TestData::Init();
 
     for (auto i = 0; i < TestData::num_rows; ++i) {
       os << TestData::GetBool(i);
@@ -586,7 +584,7 @@ TEST_F(TestStreamReader, SkipColumns) {
 
 class TestOptionalFields : public ::testing::Test {
  public:
-  TestOptionalFields() { createTestFile(); }
+  TestOptionalFields() { CreateTestFile(); }
 
  protected:
   const char* GetDataFile() const { return "stream_reader_test_optional_fields.parquet"; }
@@ -644,13 +642,13 @@ class TestOptionalFields : public ::testing::Test {
         schema::GroupNode::Make("schema", Repetition::REQUIRED, fields));
   }
 
-  void createTestFile() {
+  void CreateTestFile() {
     PARQUET_ASSIGN_OR_THROW(auto outfile,
                             ::arrow::io::FileOutputStream::Open(GetDataFile()));
 
     StreamWriter os{ParquetFileWriter::Open(outfile, GetSchema())};
 
-    TestData::init();
+    TestData::Init();
 
     for (auto i = 0; i < TestData::num_rows; ++i) {
       os << TestData::GetOptBool(i);
@@ -732,7 +730,7 @@ TEST_F(TestOptionalFields, ReadOptionalFieldAsRequiredField) {
     _provided_ that the optional value is available.
 
     This can be useful if a schema is changed such that a required
-    field beomes optional.  Applications can continue reading the
+    field becomes optional.  Applications can continue reading the
     field as if it were mandatory and do not need to be changed if the
     field value is always provided.
 
@@ -947,5 +945,95 @@ TEST_F(TestReadingDataFiles, ByteArrayDecimal) {
   EXPECT_EQ(i, 25);
 }
 
+class TestMultiRowGroupStreamReader : public ::testing::Test {
+ protected:
+  const char* GetDataFile() const { return "stream_reader_multirowgroup_test.parquet"; }
+
+  void SetUp() override {
+    CreateTestFile();
+    PARQUET_ASSIGN_OR_THROW(auto infile, ::arrow::io::ReadableFile::Open(GetDataFile()));
+    auto file_reader = parquet::ParquetFileReader::Open(infile);
+    reader_ = StreamReader{std::move(file_reader)};
+  }
+
+  void TearDown() override { reader_ = StreamReader{}; }
+
+  std::shared_ptr<schema::GroupNode> GetSchema() {
+    schema::NodeVector fields;
+    fields.push_back(schema::PrimitiveNode::Make("row_group_number", Repetition::REQUIRED,
+                                                 Type::INT32, ConvertedType::UINT_16));
+
+    fields.push_back(schema::PrimitiveNode::Make("row_number", Repetition::REQUIRED,
+                                                 Type::INT64, ConvertedType::UINT_64));
+
+    return std::static_pointer_cast<schema::GroupNode>(
+        schema::GroupNode::Make("schema", Repetition::REQUIRED, fields));
+  }
+
+  void CreateTestFile() {
+    PARQUET_ASSIGN_OR_THROW(auto outfile,
+                            ::arrow::io::FileOutputStream::Open(GetDataFile()));
+
+    auto file_writer = ParquetFileWriter::Open(outfile, GetSchema());
+
+    StreamWriter os{std::move(file_writer)};
+
+    int nrows = 0;
+    for (auto group = 0; group < kNumGroups; ++group) {
+      for (auto i = 0; i < kNumRowsPerGroup; ++i) {
+        os << static_cast<uint16_t>(group);
+        os << static_cast<uint64_t>(nrows);
+        os << EndRow;
+        nrows++;
+      }
+      os.EndRowGroup();
+    }
+  }
+
+  void ReadRowAndAssertPosition(uint64_t expected_row_num) {
+    const auto expected_group_num =
+        static_cast<uint16_t>(expected_row_num / kNumRowsPerGroup);
+    ASSERT_FALSE(reader_.eof());
+    uint16_t group_num = 0;
+    uint64_t row_num = 0;
+    reader_ >> group_num >> row_num >> EndRow;
+    ASSERT_EQ(group_num, expected_group_num);
+    ASSERT_EQ(row_num, expected_row_num);
+  }
+
+  StreamReader reader_;
+  static constexpr int kNumGroups = 5;
+  static constexpr int kNumRowsPerGroup = 10;
+};
+
+TEST_F(TestMultiRowGroupStreamReader, SkipRows) {
+  // skip somewhere into the middle of a row group somewhere in the middle of the file
+  auto current_row = 33;
+
+  auto retval = reader_.SkipRows(current_row);
+  ASSERT_EQ(retval, current_row);
+  ReadRowAndAssertPosition(current_row);
+  // reading the row advances by 1
+  current_row += 1;  // row=34
+
+  // skip a few more but stay inside the row group
+  retval = reader_.SkipRows(4);
+  current_row += 4;  // row=38
+  ASSERT_EQ(retval, 4);
+  ReadRowAndAssertPosition(current_row);
+  current_row += 1;  // row=39
+
+  // skip one more row to get to a group boundary
+  retval = reader_.SkipRows(1);
+  current_row += 1;  // row=40
+  ASSERT_EQ(retval, 1);
+  ReadRowAndAssertPosition(current_row);
+
+  // finally, skip off the end of the file
+  retval = reader_.SkipRows(10);
+  ASSERT_EQ(retval, 9);  // requested to skip 10 but only 9 rows left in file
+  EXPECT_TRUE(reader_.eof());
+}
+
 }  // namespace test
 }  // namespace parquet

From 36ddbb531cac9b9e512dfa3776d1d64db588209f Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 3 Aug 2023 12:28:27 -0400
Subject: [PATCH 088/749] GH-36953: [MATLAB] Add gateway `arrow.array` function
 to create Arrow Arrays from MATLAB data (#36978)

### Rationale for this change

As discussed in #36855, we think it would be better to move the recommended APIs for the MATLAB Interface directly under the top-level `arrow.*` package. This should help simplify the interface, and will make it easier for users to switch between multiple language bindings. We have already moved the `type` convenience constructors to the `arrow` package.  Now we want to add a gateway function that creates arrays to mirror `PyArrow`. As part of this change, we will modify the array constructors to accept `libmexclass.proxy.Proxy` objects - similar to how the `arrow.type.<Type>` constructors accept  `libmexclass.proxy.Proxy` objects.

### What changes are included in this PR?

1. Added `arrow.array()` gateway function that can be used to construct arrays:

```matlab
>> arrowArray = arrow.array([1 2 3 4]);
>> class(arrowArray)

ans =

    'arrow.array.Float64Array'

>> arrowArray = arrow.array(["A" "B" "C"]);
>> class(arrowArray)

ans =

    'arrow.array.StringArray'

```

2. Added a static `fromMATLAB()` method to all  subclasses of`arrow.array.Array`.

```matlab
>> array = arrow.array.StringArray.fromMATLAB(["A" "B" "C"])

array =

[
  "A",
  "B",
  "C"
]

>> array = arrow.array.TimestampArray.fromMATLAB(datetime(2023, 8, 1))

array =

[
  2023-08-01 00:00:00.000000
]

```

As part of this change, users can no longer use the `arrow.array.Array` subclass constructors to create arrays. Instead, they can use either `arrow.array()` or the static `fromMATLAB` method.

### Are these changes tested?

Updated the existing tests to account for the API changes and added the following new test classes:

1. arrow/internal/validate/tType.m
2. arrow/internal/validate/tShape.m
3. arrow/internal/validate/tRealNumeric.m
4. arrow/internal/validate/tNonsparse.m
5. arrow/internal/validate/tNumeric.m
6. arrow/array/tArray.m

### Are there any user-facing changes?

Yes, we changed the signature of all `arrow.array.Array` subclasses to accept scalar `libmexclass.proxy.Proxy` classes. NOTE: The MATLAB interface is still under active development.

### Future Directions

1. In a followup PR, we plan on adding a new name-value pair to `arrow.array()` called `Type`, which can be set to an `arrow.type.Type` object. This will let users specify what kind of arrow array they would like to create from MATLAB data.

* Closes: #36953

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+array/Array.m       |  7 +-
 .../src/matlab/+arrow/+array/BooleanArray.m   | 33 +++++--
 .../src/matlab/+arrow/+array/Float32Array.m   | 16 +++-
 .../src/matlab/+arrow/+array/Float64Array.m   | 16 +++-
 matlab/src/matlab/+arrow/+array/Int16Array.m  | 16 +++-
 matlab/src/matlab/+arrow/+array/Int32Array.m  | 16 +++-
 matlab/src/matlab/+arrow/+array/Int64Array.m  | 16 +++-
 matlab/src/matlab/+arrow/+array/Int8Array.m   | 16 +++-
 .../src/matlab/+arrow/+array/NumericArray.m   | 30 ++++---
 matlab/src/matlab/+arrow/+array/StringArray.m | 43 ++++++---
 .../src/matlab/+arrow/+array/TimestampArray.m | 38 +++++---
 matlab/src/matlab/+arrow/+array/UInt16Array.m | 16 +++-
 matlab/src/matlab/+arrow/+array/UInt32Array.m | 16 +++-
 matlab/src/matlab/+arrow/+array/UInt64Array.m | 16 +++-
 matlab/src/matlab/+arrow/+array/UInt8Array.m  | 16 +++-
 .../+arrow/+internal/+validate/nonsparse.m    | 25 ++++++
 .../+arrow/+internal/+validate/numeric.m      | 24 +++++
 .../+validate}/parseValidElements.m           |  0
 .../+arrow/+internal/+validate/realnumeric.m  | 25 ++++++
 .../matlab/+arrow/+internal/+validate/shape.m | 26 ++++++
 .../matlab/+arrow/+internal/+validate/type.m  | 25 ++++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 41 +--------
 matlab/src/matlab/+arrow/array.m              | 67 ++++++++++++++
 matlab/test/arrow/array/hNumericArray.m       | 43 ++++-----
 matlab/test/arrow/array/tArray.m              | 88 +++++++++++++++++++
 matlab/test/arrow/array/tBooleanArray.m       | 49 ++++++-----
 matlab/test/arrow/array/tFloat32Array.m       | 24 ++---
 matlab/test/arrow/array/tFloat64Array.m       | 28 +++---
 matlab/test/arrow/array/tInt16Array.m         |  2 +-
 matlab/test/arrow/array/tInt32Array.m         |  2 +-
 matlab/test/arrow/array/tInt64Array.m         |  2 +-
 matlab/test/arrow/array/tInt8Array.m          |  2 +-
 matlab/test/arrow/array/tStringArray.m        | 65 +++++++-------
 matlab/test/arrow/array/tTimestampArray.m     | 64 ++++++++------
 matlab/test/arrow/array/tUInt16Array.m        |  2 +-
 matlab/test/arrow/array/tUInt32Array.m        |  2 +-
 matlab/test/arrow/array/tUInt64Array.m        |  2 +-
 matlab/test/arrow/array/tUInt8Array.m         |  2 +-
 .../test/arrow/internal/validate/tNonsparse.m | 44 ++++++++++
 .../test/arrow/internal/validate/tNumeric.m   | 56 ++++++++++++
 .../validate}/tParseValidElements.m           |  2 +-
 .../arrow/internal/validate/tRealNumeric.m    | 43 +++++++++
 matlab/test/arrow/internal/validate/tShape.m  | 69 +++++++++++++++
 .../arrow/internal/validate/tType.m}          | 34 ++++---
 44 files changed, 893 insertions(+), 276 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/nonsparse.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/numeric.m
 rename matlab/src/matlab/+arrow/{+args => +internal/+validate}/parseValidElements.m (100%)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/realnumeric.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/shape.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/type.m
 create mode 100644 matlab/src/matlab/+arrow/array.m
 create mode 100644 matlab/test/arrow/array/tArray.m
 create mode 100644 matlab/test/arrow/internal/validate/tNonsparse.m
 create mode 100644 matlab/test/arrow/internal/validate/tNumeric.m
 rename matlab/test/arrow/{args => internal/validate}/tParseValidElements.m (99%)
 create mode 100644 matlab/test/arrow/internal/validate/tRealNumeric.m
 create mode 100644 matlab/test/arrow/internal/validate/tShape.m
 rename matlab/{src/matlab/+arrow/+args/validateTypeAndShape.m => test/arrow/internal/validate/tType.m} (55%)

diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 7426052764166..46b46660e7cf3 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -31,8 +31,11 @@
     end
     
     methods
-        function obj = Array(varargin)
-            obj.Proxy = libmexclass.proxy.Proxy(varargin{:}); 
+        function obj = Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy
+            end
+            obj.Proxy = proxy;
         end
 
         function numElements = get.Length(obj)
diff --git a/matlab/src/matlab/+arrow/+array/BooleanArray.m b/matlab/src/matlab/+arrow/+array/BooleanArray.m
index f4d341efce9d3..b9ef36b5a70c9 100644
--- a/matlab/src/matlab/+arrow/+array/BooleanArray.m
+++ b/matlab/src/matlab/+arrow/+array/BooleanArray.m
@@ -21,16 +21,12 @@
     end
 
     methods
-        function obj = BooleanArray(data, opts)
-            arguments
-                data
-                opts.InferNulls(1,1) logical = true
-                opts.Valid
+        function obj = BooleanArray(proxy)
+             arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.BooleanArray")}
             end
-            arrow.args.validateTypeAndShape(data, "logical");
-            validElements = arrow.args.parseValidElements(data, opts);
-            opts = struct(MatlabArray=data, Valid=validElements);
-            obj@arrow.array.Array("Name", "arrow.array.proxy.BooleanArray", "ConstructorArguments", {opts});
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
         end
 
         function data = logical(obj)
@@ -42,4 +38,23 @@
             matlabArray(~obj.Valid) = obj.NullSubstitionValue;
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            arrow.internal.validate.type(data, "logical");
+            arrow.internal.validate.shape(data);
+            arrow.internal.validate.nonsparse(data);
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            
+            args = struct(MatlabArray=data, Valid=validElements);
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.BooleanArray", args);
+            array = arrow.array.BooleanArray(proxy);
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Float32Array.m b/matlab/src/matlab/+arrow/+array/Float32Array.m
index c6be563d8621f..fe90db335b5aa 100644
--- a/matlab/src/matlab/+arrow/+array/Float32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Float32Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Float32Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "single", ...
-                "arrow.array.proxy.Float32Array", varargin{:});
+        function obj = Float32Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Float32Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = single(obj)
             data = obj.toMATLAB();
         end
     end
+    
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Float32Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Float64Array.m b/matlab/src/matlab/+arrow/+array/Float64Array.m
index ff43ebc0536c0..ecf91e28954b5 100644
--- a/matlab/src/matlab/+arrow/+array/Float64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Float64Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Float64Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "double", ...
-                "arrow.array.proxy.Float64Array", varargin{:});
+        function obj = Float64Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Float64Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = double(obj)
             data = obj.toMATLAB();
         end
     end
+    
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Float64Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Int16Array.m b/matlab/src/matlab/+arrow/+array/Int16Array.m
index 533f0c9ef549d..53c96c6eeb85c 100644
--- a/matlab/src/matlab/+arrow/+array/Int16Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int16Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Int16Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "int16", ...
-                "arrow.array.proxy.Int16Array", varargin{:});
+        function obj = Int16Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Int16Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = int16(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Int16Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Int32Array.m b/matlab/src/matlab/+arrow/+array/Int32Array.m
index 0f977fb90f808..d85bcaf627f7b 100644
--- a/matlab/src/matlab/+arrow/+array/Int32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int32Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Int32Array(data, varargin)
-              obj@arrow.array.NumericArray(data, "int32", ...
-                "arrow.array.proxy.Int32Array", varargin{:});
+        function obj = Int32Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Int32Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = int32(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Int32Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Int64Array.m b/matlab/src/matlab/+arrow/+array/Int64Array.m
index 94cad56519b11..72199df88ded1 100644
--- a/matlab/src/matlab/+arrow/+array/Int64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int64Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Int64Array(data, varargin)
-          obj@arrow.array.NumericArray(data, "int64", ...
-                "arrow.array.proxy.Int64Array", varargin{:});
+        function obj = Int64Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Int64Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = int64(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Int64Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/Int8Array.m b/matlab/src/matlab/+arrow/+array/Int8Array.m
index 83a14caa27287..0e9d8eec0edf5 100644
--- a/matlab/src/matlab/+arrow/+array/Int8Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int8Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = Int8Array(data, varargin)
-             obj@arrow.array.NumericArray(data, "int8", ...
-                "arrow.array.proxy.Int8Array", varargin{:});
+        function obj = Int8Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Int8Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = int8(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.Int8Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/NumericArray.m b/matlab/src/matlab/+arrow/+array/NumericArray.m
index fb2fc1d333939..8f465ce425e23 100644
--- a/matlab/src/matlab/+arrow/+array/NumericArray.m
+++ b/matlab/src/matlab/+arrow/+array/NumericArray.m
@@ -21,18 +21,11 @@
     end
 
     methods
-        function obj = NumericArray(data, type, proxyName, opts)
+        function obj = NumericArray(proxy)
             arguments
-                data
-                type(1, 1) string
-                proxyName(1, 1) string
-                opts.InferNulls(1, 1) logical = true
-                opts.Valid
+                proxy(1, 1) libmexclass.proxy.Proxy
             end
-            arrow.args.validateTypeAndShape(data, type);
-            validElements = arrow.args.parseValidElements(data, opts);
-            opts = struct(MatlabArray=data, Valid=validElements);
-            obj@arrow.array.Array("Name", proxyName, "ConstructorArguments", {opts});
+            obj@arrow.array.Array(proxy);
         end
 
         function matlabArray = toMATLAB(obj)
@@ -40,5 +33,22 @@
             matlabArray(~obj.Valid) = obj.NullSubstitutionValue;
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, traits, opts)
+            arguments
+                data
+                traits(1, 1) arrow.type.traits.TypeTraits
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            arrow.internal.validate.numeric(data, traits.MatlabClassName);
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            args = struct(MatlabArray=data, Valid=validElements);
+            proxy = arrow.internal.proxy.create(traits.ArrayProxyClassName, args);
+            array = traits.ArrayConstructor(proxy);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+array/StringArray.m b/matlab/src/matlab/+arrow/+array/StringArray.m
index ec2d53b371fe2..18fdec9ac70c3 100644
--- a/matlab/src/matlab/+arrow/+array/StringArray.m
+++ b/matlab/src/matlab/+arrow/+array/StringArray.m
@@ -21,21 +21,12 @@
     end
 
     methods
-        function obj = StringArray(data, opts)
-            arguments
-                data
-                opts.InferNulls(1,1) logical = true
-                opts.Valid
+        function obj = StringArray(proxy)
+         arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.StringArray")}
             end
-            % Support constructing a StringArray from a cell array of strings (i.e. cellstr),
-            % or a string array, but not a char array.
-            if ~ischar(data)
-                data = convertCharsToStrings(data);
-            end
-            arrow.args.validateTypeAndShape(data, "string");
-            validElements = arrow.args.parseValidElements(data, opts);
-            opts = struct(MatlabArray=data, Valid=validElements);
-            obj@arrow.array.Array("Name", "arrow.array.proxy.StringArray", "ConstructorArguments", {opts});
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
         end
 
         function data = string(obj)
@@ -47,4 +38,28 @@
             matlabArray(~obj.Valid) = obj.NullSubstitionValue;
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+            
+            % Support constructing a StringArray from a cell array of strings
+            % (i.e. cellstr), or a string array, but not a char array.
+            if ~ischar(data)
+                data = convertCharsToStrings(data);
+            end
+
+            arrow.internal.validate.type(data, "string");
+            arrow.internal.validate.shape(data);
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            
+            args = struct(MatlabArray=data, Valid=validElements);
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.StringArray", args);
+            array = arrow.array.StringArray(proxy);
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/TimestampArray.m b/matlab/src/matlab/+arrow/+array/TimestampArray.m
index 0f0da4e82130c..3b05903bb13ea 100644
--- a/matlab/src/matlab/+arrow/+array/TimestampArray.m
+++ b/matlab/src/matlab/+arrow/+array/TimestampArray.m
@@ -21,20 +21,12 @@
     end
 
     methods
-        function obj = TimestampArray(data, opts)
+        function obj = TimestampArray(proxy)
             arguments
-                data
-                opts.TimeUnit(1, 1) arrow.type.TimeUnit = arrow.type.TimeUnit.Microsecond
-                opts.InferNulls(1, 1) logical = true
-                opts.Valid
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.TimestampArray")}
             end
-            arrow.args.validateTypeAndShape(data, "datetime");
-            validElements = arrow.args.parseValidElements(data, opts);
-            ptime = arrow.array.TimestampArray.convertToEpochTime(data, opts.TimeUnit);
-            timezone = string(data.TimeZone);
-
-            args = struct(MatlabArray=ptime, Valid=validElements, TimeZone=timezone, TimeUnit=string(opts.TimeUnit));
-            obj@arrow.array.Array("Name", "arrow.array.proxy.TimestampArray", "ConstructorArguments", {args});
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
         end
 
         function dates = toMATLAB(obj)
@@ -70,4 +62,26 @@
             time(indices) = convertTo(dates(indices), "epochtime", TicksPerSecond=ticksPerSecond(units));
         end
     end
+
+    methods(Static)
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.TimeUnit(1, 1) arrow.type.TimeUnit = arrow.type.TimeUnit.Microsecond
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+            
+            arrow.internal.validate.type(data, "datetime");
+            arrow.internal.validate.shape(data);
+
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            epochTime = arrow.array.TimestampArray.convertToEpochTime(data, opts.TimeUnit);
+            timezone = string(data.TimeZone);
+
+            args = struct(MatlabArray=epochTime, Valid=validElements, TimeZone=timezone, TimeUnit=string(opts.TimeUnit));
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.TimestampArray", args);
+            array = arrow.array.TimestampArray(proxy);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/UInt16Array.m b/matlab/src/matlab/+arrow/+array/UInt16Array.m
index 4862ca20b9f88..9d3f33c279175 100644
--- a/matlab/src/matlab/+arrow/+array/UInt16Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt16Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = UInt16Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "uint16", ...
-                "arrow.array.proxy.UInt16Array", varargin{:});
+        function obj = UInt16Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.UInt16Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = uint16(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.UInt16Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/UInt32Array.m b/matlab/src/matlab/+arrow/+array/UInt32Array.m
index 782b0010997fc..5235d4fb15576 100644
--- a/matlab/src/matlab/+arrow/+array/UInt32Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt32Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = UInt32Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "uint32", ...
-                "arrow.array.proxy.UInt32Array", varargin{:});
+        function obj = UInt32Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.UInt32Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = uint32(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.UInt32Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/UInt64Array.m b/matlab/src/matlab/+arrow/+array/UInt64Array.m
index 9e25ce4987bc1..2d69bd031ac31 100644
--- a/matlab/src/matlab/+arrow/+array/UInt64Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt64Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = UInt64Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "uint64", ...
-                "arrow.array.proxy.UInt64Array", varargin{:});
+        function obj = UInt64Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.UInt64Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = uint64(obj)
             data = obj.toMATLAB();
         end
     end
+
+    methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.UInt64Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+array/UInt8Array.m b/matlab/src/matlab/+arrow/+array/UInt8Array.m
index 8bad2401bd429..3d007376bc89a 100644
--- a/matlab/src/matlab/+arrow/+array/UInt8Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt8Array.m
@@ -21,13 +21,23 @@
     end
 
     methods
-        function obj = UInt8Array(data, varargin)
-            obj@arrow.array.NumericArray(data, "uint8", ...
-                "arrow.array.proxy.UInt8Array", varargin{:});
+        function obj = UInt8Array(proxy)
+          arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.UInt8Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.NumericArray(proxy);
         end
 
         function data = uint8(obj)
             data = obj.toMATLAB();
         end
     end
+
+        methods (Static)
+        function array = fromMATLAB(data, varargin)
+            traits = arrow.type.traits.UInt8Traits;
+            array = arrow.array.NumericArray.fromMATLAB(data, traits, varargin{:});
+        end
+    end
 end
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/nonsparse.m b/matlab/src/matlab/+arrow/+internal/+validate/nonsparse.m
new file mode 100644
index 0000000000000..8f7557c18b658
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/nonsparse.m
@@ -0,0 +1,25 @@
+%NONSPARESE Verifies data is nonsparse. Otherwise throws an error with the 
+% identifier "arrrow:array:Sparse".
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function nonsparse(data)
+    if issparse(data)
+        errid = "arrow:array:Sparse";
+        msg = "Sparse arrays are not supported.";
+        error(errid, msg);
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/numeric.m b/matlab/src/matlab/+arrow/+internal/+validate/numeric.m
new file mode 100644
index 0000000000000..9dfe6dfada2de
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/numeric.m
@@ -0,0 +1,24 @@
+%NUMERIC Validates data is a real, nonsparse, numeric array that is
+%either a vector or an empty array.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function numeric(data, type)
+    arrow.internal.validate.type(data, type);
+    arrow.internal.validate.shape(data);
+    arrow.internal.validate.nonsparse(data);
+    arrow.internal.validate.realnumeric(data);
+end
+
diff --git a/matlab/src/matlab/+arrow/+args/parseValidElements.m b/matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+args/parseValidElements.m
rename to matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/realnumeric.m b/matlab/src/matlab/+arrow/+internal/+validate/realnumeric.m
new file mode 100644
index 0000000000000..1f57cee4d8622
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/realnumeric.m
@@ -0,0 +1,25 @@
+%REALNUMERIC Verifies the numeric array data is real. Otherwise throws an 
+% error with the identifier "arrrow:array:ComplexNumeric".
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function realnumeric(data)
+    if ~isreal(data)
+        errid = "arrow:array:ComplexNumeric";
+        msg = "Complex numeric arrays are not supported.";
+        error(errid, msg);
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/shape.m b/matlab/src/matlab/+arrow/+internal/+validate/shape.m
new file mode 100644
index 0000000000000..d9a8e29076893
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/shape.m
@@ -0,0 +1,26 @@
+%SHAPE Verifies data is either a vector or empty. Otherwise throws an error
+% with the identifier "arrrow:array:InvalidShape".
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function shape(data)
+    if ~isvector(data) && ~isempty(data)
+        errid = "arrow:array:InvalidShape";
+        msg = "Expected input array to be a vector or empty.";
+        error(errid, msg);
+    end
+end
+
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/type.m b/matlab/src/matlab/+arrow/+internal/+validate/type.m
new file mode 100644
index 0000000000000..7977d812adbf6
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/type.m
@@ -0,0 +1,25 @@
+%TYPE Verifies data has the expected class type. Otherwise throws an 
+% error with the identifier "arrrow:array:InvalidType".
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function type(data, classtype)
+    if ~isa(data, classtype)
+        errid = "arrow:array:InvalidType";
+        msg = join(["Expected data to be a", classtype, "array"]);
+        error(errid, msg);
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index a7feb0c0a3bd7..9af09702e1cf5 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -89,49 +89,10 @@
             % Convert each MATLAB array into a corresponding
             % arrow.array.Array.
             for ii = 1:numColumns
-                arrowArrays{ii} = arrow.tabular.RecordBatch.makeArray(T{:, ii});
+                arrowArrays{ii} = arrow.array(T{:, ii});
             end
         end
 
-        function arrowArray = makeArray(matlabArray)
-            % Decompose the input MATLAB table
-            % input a cell array of equivalent arrow.array.Array
-            % instances.
-
-            switch class(matlabArray)
-                case "single"
-                    arrowArray = arrow.array.Float32Array(matlabArray);
-                case "double"
-                    arrowArray = arrow.array.Float64Array(matlabArray);
-                case "uint8"
-                    arrowArray = arrow.array.UInt8Array(matlabArray);
-                case "uint16"
-                    arrowArray = arrow.array.UInt16Array(matlabArray);
-                case "uint32"
-                    arrowArray = arrow.array.UInt32Array(matlabArray);
-                case "uint64"
-                    arrowArray = arrow.array.UInt64Array(matlabArray);
-                case "int8"
-                    arrowArray = arrow.array.Int8Array(matlabArray);
-                case "int16"
-                    arrowArray = arrow.array.Int16Array(matlabArray);
-                case "int32"
-                    arrowArray = arrow.array.Int32Array(matlabArray);
-                case "int64"
-                    arrowArray = arrow.array.Int64Array(matlabArray);
-                case "logical"
-                    arrowArray = arrow.array.BooleanArray(matlabArray);
-                case "string"
-                    arrowArray = arrow.array.StringArray(matlabArray);
-                case "datetime"
-                    arrowArray = arrow.array.TimestampArray(matlabArray);
-                otherwise
-                    error("arrow:tabular:recordbatch:UnsupportedMatlabArrayType", ...
-                          "RecordBatch cannot be constructed from a MATLAB array of type '" + class(matlabArray) + "'.");
-            end
-
-        end
-
         function proxyIDs = getArrowProxyIDs(arrowArrays)
             % Extract the Proxy IDs underlying a cell array of 
             % arrow.array.Array instances.
diff --git a/matlab/src/matlab/+arrow/array.m b/matlab/src/matlab/+arrow/array.m
new file mode 100644
index 0000000000000..a2d0ecd2e8f76
--- /dev/null
+++ b/matlab/src/matlab/+arrow/array.m
@@ -0,0 +1,67 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function arrowArray = array(data, opts)
+    arguments
+        data
+        opts.InferNulls(1, 1) logical = true
+        opts.Valid
+    end
+
+    data = convertCellstrToString(data);
+    classname = string(class(data));
+    args = namedargs2cell(opts);
+
+    switch (classname)
+        case "logical"
+            arrowArray = arrow.array.BooleanArray.fromMATLAB(data, args{:});
+        case "uint8"
+            arrowArray = arrow.array.UInt8Array.fromMATLAB(data, args{:});
+        case "uint16"
+            arrowArray = arrow.array.UInt16Array.fromMATLAB(data, args{:});
+        case "uint32"
+            arrowArray = arrow.array.UInt32Array.fromMATLAB(data, args{:});
+        case "uint64"
+            arrowArray = arrow.array.UInt64Array.fromMATLAB(data, args{:});
+        case "int8"
+            arrowArray = arrow.array.Int8Array.fromMATLAB(data, args{:});
+        case "int16"
+            arrowArray = arrow.array.Int16Array.fromMATLAB(data, args{:});
+        case "int32"
+            arrowArray = arrow.array.Int32Array.fromMATLAB(data, args{:});
+        case "int64"
+            arrowArray = arrow.array.Int64Array.fromMATLAB(data, args{:});
+        case "single"
+            arrowArray = arrow.array.Float32Array.fromMATLAB(data, args{:});
+        case "double"
+            arrowArray = arrow.array.Float64Array.fromMATLAB(data, args{:});
+        case "string"
+            arrowArray = arrow.array.StringArray.fromMATLAB(data, args{:});
+        case "datetime"
+            arrowArray = arrow.array.TimestampArray.fromMATLAB(data, args{:});
+        otherwise
+            errid = "arrow:array:UnsupportedMATLABType";
+            msg = join(["Unable to convert MATLAB type" classname "to arrow array."]);
+            error(errid, msg);
+    end
+end
+
+function data = convertCellstrToString(data)
+    % Support constructing a StringArray from a cell array of strings
+    % (i.e. cellstr), or a string array, but not a char array.
+    if ~ischar(data)
+        data = convertCharsToStrings(data);
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/hNumericArray.m b/matlab/test/arrow/array/hNumericArray.m
index f9f5f1d9e4ee3..fc5f5a05998ed 100644
--- a/matlab/test/arrow/array/hNumericArray.m
+++ b/matlab/test/arrow/array/hNumericArray.m
@@ -18,7 +18,7 @@
 
     properties (Abstract)
         ArrowArrayClassName(1, 1) string
-        ArrowArrayConstructor
+        ArrowArrayConstructorFcn
         MatlabArrayFcn
         MatlabConversionFcn
         MaxValue (1, 1)
@@ -38,24 +38,24 @@ function verifyOnMatlabPath(tc)
 
     methods(Test)
         function BasicTest(tc)
-            A = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([1 2 3]));
+            A = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([1 2 3]));
             className = string(class(A));
             tc.verifyEqual(className, tc.ArrowArrayClassName);
         end
 
         function ToMATLAB(tc)
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(100));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(100));
             data = toMATLAB(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn(100));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([1 2 3]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([1 2 3]));
             data = toMATLAB(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn([1 2 3]'));
 
             % Create a Float64Array from an empty double vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([]));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([]));
             data = toMATLAB(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
@@ -65,54 +65,55 @@ function MatlabConversion(tc)
         % arrow.array.Float32Array, double for array.array.Float64Array
 
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(100));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(100));
             data = tc.MatlabConversionFcn(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn(100));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([1 2 3]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([1 2 3]));
             data = tc.MatlabConversionFcn(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn([1 2 3]'));
 
             % Create an array from an empty vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([]));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([]));
             data = tc.MatlabConversionFcn(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
 
         function MinValueTest(tc)
-            A = tc.ArrowArrayConstructor(tc.MinValue);
+            A = tc.ArrowArrayConstructorFcn(tc.MinValue);
             tc.verifyEqual(toMATLAB(A), tc.MinValue);
         end
 
         function MaxValueTest(tc)
-            A1 = tc.ArrowArrayConstructor(tc.MaxValue);
+            A1 = tc.ArrowArrayConstructorFcn(tc.MaxValue);
             tc.verifyEqual(toMATLAB(A1), tc.MaxValue);
         end
 
         function ErrorIfComplex(tc)
-            fcn = @() tc.ArrowArrayConstructor(tc.MatlabArrayFcn([10 + 1i, 4]));
-            tc.verifyError(fcn, "MATLAB:expectedReal");
+            fcn = @() tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([10 + 1i, 4]));
+            tc.verifyError(fcn, "arrow:array:ComplexNumeric");
         end
 
         function ErrorIfNonVector(tc)
             data = tc.MatlabArrayFcn([1 2 3 4 5 6 7 8 9]);
             data = reshape(data, 3, 1, 3);
-            fcn = @() tc.ArrowArrayConstructor(tc.MatlabArrayFcn(data));
-            tc.verifyError(fcn, "MATLAB:expectedVector");
+            fcn = @() tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(data));
+            tc.verifyError(fcn, "arrow:array:InvalidShape");
         end
 
-        function ErrorIfEmptyArrayIsNotTwoDimensional(tc)
+        function AllowNDimensionalEmptyArray(tc)
             data = tc.MatlabArrayFcn(reshape([], [1 0 0]));
-            fcn = @() tc.ArrowArrayConstructor(data);
-            tc.verifyError(fcn, "MATLAB:expected2D");
+            A = tc.ArrowArrayConstructorFcn(data);
+            tc.verifyEqual(A.Length, int64(0));
+            tc.verifyEqual(toMATLAB(A), tc.MatlabArrayFcn(reshape([], [0 1])));
         end
 
         function LogicalValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a logical array
             data = tc.MatlabArrayFcn([1 2 3 4]);
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[false true true false]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[false true true false]);
         
             expectedData = data';
             expectedData([1 4]) = tc.NullSubstitutionValue;
@@ -125,7 +126,7 @@ function NumericValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a array of indices
             data = tc.MatlabArrayFcn([1 2 3 4]);
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[2 4]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[2 4]);
         
             expectedData = data';
             expectedData([1 3]) = tc.NullSubstitutionValue;
@@ -136,7 +137,7 @@ function NumericValidNVPair(tc)
             % Make sure the optimization where the valid-bitmap is stored
             % as a nullptr works as expected.
             expectedData = data';
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[1, 2, 3, 4]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[1, 2, 3, 4]);
             tc.verifyEqual(tc.MatlabConversionFcn(arrowArray), expectedData);
             tc.verifyEqual(toMATLAB(arrowArray), expectedData);
             tc.verifyEqual(arrowArray.Valid, [true; true; true; true]);
@@ -145,7 +146,7 @@ function NumericValidNVPair(tc)
         function TestArrowType(tc)
         % Verify the array has the expected arrow.type.Type object
             data = tc.MatlabArrayFcn([1 2 3 4]);
-            arrowArray = tc.ArrowArrayConstructor(data);
+            arrowArray = tc.ArrowArrayConstructorFcn(data);
             tc.verifyEqual(arrowArray.Type.ID, tc.ArrowType.ID);
         end
     end
diff --git a/matlab/test/arrow/array/tArray.m b/matlab/test/arrow/array/tArray.m
new file mode 100644
index 0000000000000..4a476696bfacf
--- /dev/null
+++ b/matlab/test/arrow/array/tArray.m
@@ -0,0 +1,88 @@
+%TARRAY Unit tests for arrow.array function. 
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tArray < matlab.unittest.TestCase
+
+    properties(TestParameter)
+        MATLABDataArrayTypePair = { ...
+            {[true false],         "arrow.array.BooleanArray"}, ...
+            {int8([1 2]),          "arrow.array.Int8Array"}, ...
+            {uint8([1 2]),         "arrow.array.UInt8Array"}, ...
+            {int16([1 2]),         "arrow.array.Int16Array"}, ...
+            {uint16([1 2]),        "arrow.array.UInt16Array"}, ...
+            {int32([1 2]),         "arrow.array.Int32Array"}, ...
+            {uint32([1 2]),        "arrow.array.UInt32Array"}, ...
+            {int64([1 2]),         "arrow.array.Int64Array"}, ...
+            {uint64([1 2]),        "arrow.array.UInt64Array"}, ...
+            {single([1 2]),        "arrow.array.Float32Array"}, ...
+            {[1 2],                "arrow.array.Float64Array"}, ...
+            {datetime(2022, 1, 1), "arrow.array.TimestampArray"}, ...
+            {["A" "B"],            "arrow.array.StringArray"}};
+    end
+
+    methods(Test)        
+        function ArrowArrayOutputType(testCase, MATLABDataArrayTypePair)
+        % Verify arrow.array returns the expected arrow.array.<Type>Array
+        % with respect to the input data array's MATLAB class type.
+            matlabArray = MATLABDataArrayTypePair{1};
+            expectedClassName = MATLABDataArrayTypePair{2};
+            arrowArray = arrow.array(matlabArray);
+            actualClassName = string(class(arrowArray));
+            testCase.verifyEqual(actualClassName, expectedClassName);
+        end
+
+        function UnsupportedMATLABTypeError(testCase)
+        % Verify arrow.array throws an error with the identifier
+        % "arrow:array:UnsupportedMATLABType" if the input array is not one
+        % we support converting into an Arrow array.
+            matlabArray = table;
+            fcn = @() arrow.array(matlabArray);
+            errID = "arrow:array:UnsupportedMATLABType";
+            testCase.verifyError(fcn, errID);
+        end
+
+        function InferNullsDefault(testCase)
+        % Verify InferNulls is true by default.
+            matlabArray = [1 2 NaN 3];
+            arrowArray = arrow.array(matlabArray);
+            testCase.verifyEqual(arrowArray.Valid, [true; true; false; true]);
+        end
+
+        function InferNullsTrue(testCase)
+        % Verify InferNulls is true by default.
+            matlabArray = [1 2 NaN 3];
+            arrowArray = arrow.array(matlabArray, InferNulls=true);
+            testCase.verifyEqual(arrowArray.Valid, [true; true; false; true]);
+        end
+
+        function InferNullsFalse(testCase)
+        % Verify Valid is the expected logical vector when
+        % InferNulls=false.
+            matlabArray = [1 2 NaN 3];
+            arrowArray = arrow.array(matlabArray, InferNulls=false);
+            testCase.verifyEqual(arrowArray.Valid, [true; true; true; true]);
+        end
+
+        function ValidNameValuePair(testCase)
+        % Verify Valid is the expected vector when the Valid
+        % name-value pair is supplied.
+            matlabArray = [1 NaN NaN 3];
+            arrowArray = arrow.array(matlabArray, Valid=[1 2]);
+            testCase.verifyEqual(arrowArray.Valid, [true; true; false; false]);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/tBooleanArray.m b/matlab/test/arrow/array/tBooleanArray.m
index e27ca11285a50..df7f052597075 100644
--- a/matlab/test/arrow/array/tBooleanArray.m
+++ b/matlab/test/arrow/array/tBooleanArray.m
@@ -18,7 +18,7 @@
 
       properties
         ArrowArrayClassName(1, 1) string = "arrow.array.BooleanArray"
-        ArrowArrayConstructor = @arrow.array.BooleanArray
+        ArrowArrayConstructorFcn = @arrow.array.BooleanArray.fromMATLAB
         MatlabArrayFcn = @logical
         MatlabConversionFcn = @logical
         NullSubstitutionValue = false
@@ -36,34 +36,34 @@ function verifyOnMatlabPath(tc)
 
     methods(Test)
         function BasicTest(tc)
-            A = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([true false true]));
+            A = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([true false true]));
             className = string(class(A));
             tc.verifyEqual(className, tc.ArrowArrayClassName);
         end
 
         function ToMATLAB(tc)
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(true));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(true));
             data = toMATLAB(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn(true));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([true false true]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([true false true]));
             data = toMATLAB(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn([true false true]'));
 
             % Create a BooleanArray from an empty 0x0 logical vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 0)));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 0)));
             data = toMATLAB(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a BooleanArray from an empty 0x1 logical vector
-            A4= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 1)));
+            A4= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 1)));
             data = toMATLAB(A4);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a BooleanArray from an empty 1x0 logical vector
-            A5= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 1)));
+            A5= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 1)));
             data = toMATLAB(A5);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
@@ -72,27 +72,27 @@ function MatlabConversion(tc)
         % Tests the type-specific conversion method (i.e. logical)
 
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(true));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(true));
             data = tc.MatlabConversionFcn(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn(true));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn([true false true]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn([true false true]));
             data = tc.MatlabConversionFcn(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn([true false true]'));
 
             % Create a BooleanArray from an empty 0x0 logical vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 0)));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 0)));
             data = tc.MatlabConversionFcn(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a BooleanArray from an empty 0x1 logical vector
-            A4= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 1)));
+            A4= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 1)));
             data = tc.MatlabConversionFcn(A4);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a BooleanArray from an empty 1x0 logical vector
-            A5= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(logical.empty(0, 1)));
+            A5= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(logical.empty(0, 1)));
             data = tc.MatlabConversionFcn(A5);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
@@ -101,7 +101,7 @@ function LogicalValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a logical array
             data = tc.MatlabArrayFcn([true false true]');
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[false true true]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[false true true]);
 
             expectedData = data;
             expectedData(1) = tc.NullSubstitutionValue;
@@ -114,7 +114,7 @@ function NumericValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a array of indices
             data = tc.MatlabArrayFcn([true false true]');
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[1, 2]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[1, 2]);
 
             expectedData = data;
             expectedData(3) = tc.NullSubstitutionValue;
@@ -126,7 +126,7 @@ function NumericValidNVPair(tc)
             % Make sure the optimization where the valid-bitmap is stored as
             % a nullptr works as expected.
             expectedData = data;
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[1, 2, 3]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[1, 2, 3]);
             tc.verifyEqual(tc.MatlabConversionFcn(arrowArray), expectedData);
             tc.verifyEqual(toMATLAB(arrowArray), expectedData);
             tc.verifyEqual(arrowArray.Valid, [true; true; true]);
@@ -135,26 +135,27 @@ function NumericValidNVPair(tc)
         function ErrorIfNonVector(tc)
             data = tc.MatlabArrayFcn([true false true false true false true false true]);
             data = reshape(data, 3, 1, 3);
-            fcn = @() tc.ArrowArrayConstructor(tc.MatlabArrayFcn(data));
-            tc.verifyError(fcn, "MATLAB:expectedVector");
+            fcn = @() tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(data));
+            tc.verifyError(fcn, "arrow:array:InvalidShape");
         end
 
-        function ErrorIfEmptyArrayIsNotTwoDimensional(tc)
-            data = tc.MatlabArrayFcn(reshape(logical.empty(0, 0), [1 0 0]));
-            fcn = @() tc.ArrowArrayConstructor(data);
-            tc.verifyError(fcn, "MATLAB:expected2D");
+        function AllowNDimensionalEmptyArray(tc)
+            data = tc.MatlabArrayFcn(reshape([], [1 0 0]));
+            A = tc.ArrowArrayConstructorFcn(data);
+            tc.verifyEqual(A.Length, int64(0));
+            tc.verifyEqual(toMATLAB(A), tc.MatlabArrayFcn(reshape([], [0 1])));
         end
 
         function ErrorIfSparseArray(tc)
             data = tc.MatlabArrayFcn(sparse([true false true]));
-            fcn = @() tc.ArrowArrayConstructor(data);
-            tc.verifyError(fcn, "MATLAB:expectedNonsparse");
+            fcn = @() tc.ArrowArrayConstructorFcn(data);
+            tc.verifyError(fcn, "arrow:array:Sparse");
         end
 
         function TestArrowType(tc)
         % Verify the array has the expected arrow.type.Type object
             data = tc.MatlabArrayFcn([true false]);
-            arrowArray = tc.ArrowArrayConstructor(data);
+            arrowArray = tc.ArrowArrayConstructorFcn(data);
             tc.verifyEqual(arrowArray.Type.ID, tc.ArrowType.ID);
         end
     end
diff --git a/matlab/test/arrow/array/tFloat32Array.m b/matlab/test/arrow/array/tFloat32Array.m
index f007e2b422d6e..2ec9b90b4d277 100644
--- a/matlab/test/arrow/array/tFloat32Array.m
+++ b/matlab/test/arrow/array/tFloat32Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.Float32Array"
-        ArrowArrayConstructor = @arrow.array.Float32Array
+        ArrowArrayConstructorFcn = @arrow.array.Float32Array.fromMATLAB
         MatlabConversionFcn = @single % single method on class
         MatlabArrayFcn = @single % single function
         MaxValue = realmax("single")
@@ -29,7 +29,7 @@
 
     methods(Test)
         function InfValues(testCase)
-            A1 = arrow.array.Float32Array(single([Inf -Inf]));
+            A1 = testCase.ArrowArrayConstructorFcn(single([Inf -Inf]));
             data = single(A1);
             testCase.verifyEqual(data, single([Inf -Inf]'));
         end
@@ -38,7 +38,7 @@ function ValidBasic(testCase)
             % Create a MATLAB array with one null value (i.e. one NaN).
             % Verify NaN is considered a null value by default.
             matlabArray = single([1, NaN, 3]');
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [true, false, true]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -47,13 +47,13 @@ function InferNulls(testCase)
             matlabArray = single([1, NaN, 3]);
 
             % Verify NaN is treated as a null value when InferNulls=true.
-            arrowArray1 = arrow.array.Float32Array(matlabArray, InferNulls=true);
+            arrowArray1 = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=true);
             expectedValid1 = [true false true]';
             testCase.verifyEqual(arrowArray1.Valid, expectedValid1);
             testCase.verifyEqual(toMATLAB(arrowArray1), matlabArray');
 
             % Verify NaN is not treated as a null value when InferNulls=false.
-            arrowArray2 = arrow.array.Float32Array(matlabArray, InferNulls=false);
+            arrowArray2 = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=false);
             expectedValid2 = [true true true]';
             testCase.verifyEqual(arrowArray2.Valid, expectedValid2);
             testCase.verifyEqual(toMATLAB(arrowArray2), matlabArray');
@@ -62,7 +62,7 @@ function InferNulls(testCase)
         function ValidNoNulls(testCase)
             % Create a MATLAB array with no null values (i.e. no NaNs).
             matlabArray = single([1, 2, 3]');
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [true, true, true]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -70,7 +70,7 @@ function ValidNoNulls(testCase)
         function ValidAllNulls(testCase)
             % Create a MATLAB array with all null values (i.e. all NaNs).
             matlabArray = single([NaN, NaN, NaN]');
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [false, false, false]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -78,18 +78,18 @@ function ValidAllNulls(testCase)
         function EmptyArrayValidBitmap(testCase)
             % Create an empty 0x0 MATLAB array.
             matlabArray = single.empty(0, 0);
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = logical.empty(0, 1);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
 
             % Create an empty 0x1 MATLAB array.
             matlabArray = single.empty(0, 1);
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
 
             % Create an empty 1x0 MATLAB array.
             matlabArray = single.empty(1, 0);
-            arrowArray = arrow.array.Float32Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
 
@@ -97,7 +97,7 @@ function LogicalValidNVPair(testCase)
             matlabArray = single([1 2 3]); 
 
             % Supply a logical vector for Valid
-            arrowArray = arrow.array.Float32Array(matlabArray, Valid=[false; true; true]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, Valid=[false; true; true]);
             testCase.verifyEqual(arrowArray.Valid, [false; true; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), single([NaN; 2; 3]));
         end
@@ -106,7 +106,7 @@ function NumericlValidNVPair(testCase)
             matlabArray = single([1 2 3]); 
 
             % Supply a numeric vector for Valid 
-            arrowArray = arrow.array.Float32Array(matlabArray, Valid=[1 3]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, Valid=[1 3]);
             testCase.verifyEqual(arrowArray.Valid, [true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), single([1; NaN; 3]));
         end
diff --git a/matlab/test/arrow/array/tFloat64Array.m b/matlab/test/arrow/array/tFloat64Array.m
index 9b30ec8f25d49..a39a3d1e62cb4 100755
--- a/matlab/test/arrow/array/tFloat64Array.m
+++ b/matlab/test/arrow/array/tFloat64Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.Float64Array"
-        ArrowArrayConstructor = @arrow.array.Float64Array
+        ArrowArrayConstructorFcn = @arrow.array.Float64Array.fromMATLAB
         MatlabConversionFcn = @double % double method on class
         MatlabArrayFcn = @double % double function
         MaxValue = realmax("double")
@@ -29,21 +29,21 @@
 
     methods(Test)
         function InfValues(testCase)
-            A1 = arrow.array.Float64Array([Inf -Inf]);
+            A1 = testCase.ArrowArrayConstructorFcn([Inf -Inf]);
             data = double(A1);
             testCase.verifyEqual(data, [Inf -Inf]');
         end
 
         function ErrorIfSparse(testCase)
-            fcn = @() arrow.array.Float64Array(sparse(ones([10 1])));
-            testCase.verifyError(fcn, "MATLAB:expectedNonsparse");
+            fcn = @() testCase.ArrowArrayConstructorFcn(sparse(ones([10 1])));
+            testCase.verifyError(fcn, "arrow:array:Sparse");
         end
 
         function ValidBasic(testCase)
             % Create a MATLAB array with one null value (i.e. one NaN).
             % Verify NaN is considered a null value by default.
             matlabArray = [1, NaN, 3]';
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [true, false, true]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -52,13 +52,13 @@ function InferNulls(testCase)
             matlabArray = [1, NaN, 3];
 
             % Verify NaN is treated as a null value when InferNulls=true.
-            arrowArray1 = arrow.array.Float64Array(matlabArray, InferNulls=true);
+            arrowArray1 = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=true);
             expectedValid1 = [true false true]';
             testCase.verifyEqual(arrowArray1.Valid, expectedValid1);
             testCase.verifyEqual(toMATLAB(arrowArray1), matlabArray');
 
             % Verify NaN is not treated as a null value when InferNulls=false.
-            arrowArray2 = arrow.array.Float64Array(matlabArray, InferNulls=false);
+            arrowArray2 = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=false);
             expectedValid2 = [true true true]';
             testCase.verifyEqual(arrowArray2.Valid, expectedValid2);
             testCase.verifyEqual(toMATLAB(arrowArray2), matlabArray');
@@ -67,7 +67,7 @@ function InferNulls(testCase)
         function ValidNoNulls(testCase)
             % Create a MATLAB array with no null values (i.e. no NaNs).
             matlabArray = [1, 2, 3]';
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [true, true, true]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -75,7 +75,7 @@ function ValidNoNulls(testCase)
         function ValidAllNulls(testCase)
             % Create a MATLAB array with all null values (i.e. all NaNs).
             matlabArray = [NaN, NaN, NaN]';
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = [false, false, false]';
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
@@ -83,18 +83,18 @@ function ValidAllNulls(testCase)
         function EmptyArrayValidBitmap(testCase)
             % Create an empty 0x0 MATLAB array.
             matlabArray = double.empty(0, 0);
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             expectedValid = logical.empty(0, 1);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
 
             % Create an empty 0x1 MATLAB array.
             matlabArray = double.empty(0, 1);
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
 
             % Create an empty 1x0 MATLAB array.
             matlabArray = double.empty(1, 0);
-            arrowArray = arrow.array.Float64Array(matlabArray);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray);
             testCase.verifyEqual(arrowArray.Valid, expectedValid);
         end
 
@@ -102,7 +102,7 @@ function LogicalValidNVPair(testCase)
             matlabArray = [1 2 3]; 
 
             % Supply a logical vector for Valid
-            arrowArray = arrow.array.Float64Array(matlabArray, Valid=[false; true; true]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, Valid=[false; true; true]);
             testCase.verifyEqual(arrowArray.Valid, [false; true; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), [NaN; 2; 3]);
         end
@@ -111,7 +111,7 @@ function NumericlValidNVPair(testCase)
             matlabArray = [1 2 3]; 
 
             % Supply a numeric vector for Valid 
-            arrowArray = arrow.array.Float64Array(matlabArray, Valid=[1 3]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, Valid=[1 3]);
             testCase.verifyEqual(arrowArray.Valid, [true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), [1; NaN; 3]);
         end
diff --git a/matlab/test/arrow/array/tInt16Array.m b/matlab/test/arrow/array/tInt16Array.m
index 9cb5fdc1d1049..391c8ccb6243b 100644
--- a/matlab/test/arrow/array/tInt16Array.m
+++ b/matlab/test/arrow/array/tInt16Array.m
@@ -18,7 +18,7 @@
     
     properties
         ArrowArrayClassName = "arrow.array.Int16Array"
-        ArrowArrayConstructor = @arrow.array.Int16Array
+        ArrowArrayConstructorFcn = @arrow.array.Int16Array.fromMATLAB
         MatlabConversionFcn = @int16 % int16 method on class
         MatlabArrayFcn = @int16 % int16 function
         MaxValue = intmax("int16")
diff --git a/matlab/test/arrow/array/tInt32Array.m b/matlab/test/arrow/array/tInt32Array.m
index b45705592d714..accf70735915f 100644
--- a/matlab/test/arrow/array/tInt32Array.m
+++ b/matlab/test/arrow/array/tInt32Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.Int32Array"
-        ArrowArrayConstructor = @arrow.array.Int32Array
+        ArrowArrayConstructorFcn = @arrow.array.Int32Array.fromMATLAB
         MatlabConversionFcn = @int32 % int32 method on class
         MatlabArrayFcn = @int32 % int32 function
         MaxValue = intmax("int32")
diff --git a/matlab/test/arrow/array/tInt64Array.m b/matlab/test/arrow/array/tInt64Array.m
index 0b38f58547cce..909e9af866e0f 100644
--- a/matlab/test/arrow/array/tInt64Array.m
+++ b/matlab/test/arrow/array/tInt64Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.Int64Array"
-        ArrowArrayConstructor = @arrow.array.Int64Array
+        ArrowArrayConstructorFcn = @arrow.array.Int64Array.fromMATLAB
         MatlabConversionFcn = @int64 % int64 method on class
         MatlabArrayFcn = @int64 % int64 function
         MaxValue = intmax("int64")
diff --git a/matlab/test/arrow/array/tInt8Array.m b/matlab/test/arrow/array/tInt8Array.m
index 8ce8e4e9b2d14..2817b7b61f31e 100644
--- a/matlab/test/arrow/array/tInt8Array.m
+++ b/matlab/test/arrow/array/tInt8Array.m
@@ -18,7 +18,7 @@
     
     properties
         ArrowArrayClassName = "arrow.array.Int8Array"
-        ArrowArrayConstructor = @arrow.array.Int8Array
+        ArrowArrayConstructorFcn = @arrow.array.Int8Array.fromMATLAB
         MatlabConversionFcn = @int8 % int8 method on class
         MatlabArrayFcn = @int8 % int8 function
         MaxValue = intmax("int8")
diff --git a/matlab/test/arrow/array/tStringArray.m b/matlab/test/arrow/array/tStringArray.m
index dbb2adca0ce5b..85628ce4216dd 100644
--- a/matlab/test/arrow/array/tStringArray.m
+++ b/matlab/test/arrow/array/tStringArray.m
@@ -18,7 +18,7 @@
 
       properties
         ArrowArrayClassName(1, 1) string = "arrow.array.StringArray"
-        ArrowArrayConstructor = @arrow.array.StringArray
+        ArrowArrayConstructorFcn = @arrow.array.StringArray.fromMATLAB
         MatlabArrayFcn = @string
         MatlabConversionFcn = @string
         NullSubstitutionValue = string(missing)
@@ -36,34 +36,34 @@ function verifyOnMatlabPath(tc)
 
     methods(Test)
         function BasicTest(tc)
-            A = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(["A", "B", "C"]));
+            A = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(["A", "B", "C"]));
             className = string(class(A));
             tc.verifyEqual(className, tc.ArrowArrayClassName);
         end
 
         function ToMATLAB(tc)
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn("A"));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn("A"));
             data = toMATLAB(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn("A"));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(["A", "B", "C"]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(["A", "B", "C"]));
             data = toMATLAB(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn(["A", "B", "C"]'));
 
             % Create a StringArray from an empty 0x0 string vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 0)));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 0)));
             data = toMATLAB(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a StringArray from an empty 0x1 string vector
-            A4= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 1)));
+            A4= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 1)));
             data = toMATLAB(A4);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a StringArray from an empty 1x0 string vector
-            A5= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 1)));
+            A5= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 1)));
             data = toMATLAB(A5);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
@@ -72,27 +72,27 @@ function MatlabConversion(tc)
             % Tests the type-specific conversion method (i.e. string)
 
             % Create array from a scalar
-            A1 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn("A"));
+            A1 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn("A"));
             data = tc.MatlabConversionFcn(A1);
             tc.verifyEqual(data, tc.MatlabArrayFcn("A"));
 
             % Create array from a vector
-            A2 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(["A", "B", "C"]));
+            A2 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(["A", "B", "C"]));
             data = tc.MatlabConversionFcn(A2);
             tc.verifyEqual(data, tc.MatlabArrayFcn(["A", "B", "C"]'));
 
             % Create a StringArray from an empty 0x0 string vector
-            A3 = tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 0)));
+            A3 = tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 0)));
             data = tc.MatlabConversionFcn(A3);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a StringArray from an empty 0x1 string vector
-            A4= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 1)));
+            A4= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 1)));
             data = tc.MatlabConversionFcn(A4);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
 
             % Create a StringArray from an empty 1x0 string vector
-            A5= tc.ArrowArrayConstructor(tc.MatlabArrayFcn(string.empty(0, 1)));
+            A5= tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(string.empty(0, 1)));
             data = tc.MatlabConversionFcn(A5);
             tc.verifyEqual(data, tc.MatlabArrayFcn(reshape([], 0, 1)));
         end
@@ -101,7 +101,7 @@ function LogicalValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a logical array
             data = tc.MatlabArrayFcn(["A", "B", "C"]');
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[false true true]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[false true true]);
 
             expectedData = data;
             expectedData(1) = tc.NullSubstitutionValue;
@@ -114,7 +114,7 @@ function NumericValidNVPair(tc)
             % Verify the expected elements are treated as null when Valid
             % is provided as a array of indices
             data = tc.MatlabArrayFcn(["A", "B", "C"]');
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[1, 2]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[1, 2]);
 
             expectedData = data;
             expectedData(3) = tc.NullSubstitutionValue;
@@ -126,7 +126,7 @@ function NumericValidNVPair(tc)
             % Make sure the optimization where the valid-bitmap is stored as
             % a nullptr works as expected.
             expectedData = data;
-            arrowArray = tc.ArrowArrayConstructor(data, Valid=[1, 2, 3]);
+            arrowArray = tc.ArrowArrayConstructorFcn(data, Valid=[1, 2, 3]);
             tc.verifyEqual(tc.MatlabConversionFcn(arrowArray), expectedData);
             tc.verifyEqual(toMATLAB(arrowArray), expectedData);
             tc.verifyEqual(arrowArray.Valid, [true; true; true]);
@@ -135,20 +135,21 @@ function NumericValidNVPair(tc)
         function ErrorIfNonVector(tc)
             data = tc.MatlabArrayFcn(["A", "B", "A", "B", "A", "B", "A", "B", "A"]);
             data = reshape(data, 3, 1, 3);
-            fcn = @() tc.ArrowArrayConstructor(tc.MatlabArrayFcn(data));
-            tc.verifyError(fcn, "MATLAB:expectedVector");
+            fcn = @() tc.ArrowArrayConstructorFcn(tc.MatlabArrayFcn(data));
+            tc.verifyError(fcn, "arrow:array:InvalidShape");
         end
 
-        function ErrorIfEmptyArrayIsNotTwoDimensional(tc)
+        function AllowNDimensionalEmptyArray(tc)
             data = tc.MatlabArrayFcn(reshape(string.empty(0, 0), [1 0 0]));
-            fcn = @() tc.ArrowArrayConstructor(data);
-            tc.verifyError(fcn, "MATLAB:expected2D");
+            arrowArray = tc.ArrowArrayConstructorFcn(data);
+            tc.verifyEqual(arrowArray.Length, int64(0));
+            tc.verifyEqual(toMATLAB(arrowArray), string.empty(0, 1));
         end
 
         function TestArrowType(tc)
             % Verify the array has the expected arrow.type.Type object
             data = tc.MatlabArrayFcn(["A", "B"]);
-            arrowArray = tc.ArrowArrayConstructor(data);
+            arrowArray = tc.ArrowArrayConstructorFcn(data);
             tc.verifyEqual(arrowArray.Type.ID, tc.ArrowType.ID);
         end
 
@@ -160,7 +161,7 @@ function Unicode(tc)
             mango = "🥭";
             
             matlabArray = tc.MatlabArrayFcn([smiley; tree; mango]);
-            arrowArray = tc.ArrowArrayConstructor(matlabArray);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, matlabArray);
         end
@@ -169,7 +170,7 @@ function Missing(tc)
             % Verify that string(missing) values get mapped to the empty
             % string value when InferNulls=false.
             matlabArray = tc.MatlabArrayFcn(["A"; string(missing); string(missing)]);
-            arrowArray = tc.ArrowArrayConstructor(matlabArray, InferNulls=false);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray, InferNulls=false);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, ["A"; ""; ""]);
         end
@@ -180,25 +181,25 @@ function CellStr(tc)
 
             % Row vector
             matlabArray = {'A', 'B', 'C'};
-            arrowArray = tc.ArrowArrayConstructor(matlabArray);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, string(matlabArray'));
 
             % Column vector
             matlabArray = {'A'; 'B'; 'C'};
-            arrowArray = tc.ArrowArrayConstructor(matlabArray);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, string(matlabArray));
 
             % One element cellstr
             matlabArray = {''};
-            arrowArray = tc.ArrowArrayConstructor(matlabArray);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, string(matlabArray));
 
             % Empty cell
             matlabArray = {};
-            arrowArray = tc.ArrowArrayConstructor(matlabArray);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabArray);
             matlabArrayConverted = toMATLAB(arrowArray);
             tc.verifyEqual(matlabArrayConverted, string.empty(0, 1));
         end
@@ -209,23 +210,23 @@ function ErrorIfChar(tc)
 
             % Row vector
             matlabArray = 'abc';
-            tc.verifyError(@() tc.ArrowArrayConstructor(matlabArray), "MATLAB:invalidType");
+            tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
 
             % Column vector
             matlabArray = ['a';'b';'c'];
-            tc.verifyError(@() tc.ArrowArrayConstructor(matlabArray), "MATLAB:invalidType");
+            tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
 
             % Empty char (0x0)
             matlabArray = '';
-            tc.verifyError(@() tc.ArrowArrayConstructor(matlabArray), "MATLAB:invalidType");
+            tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
 
             % Empty char (0x1)
             matlabArray = char.empty(0, 1);
-            tc.verifyError(@() tc.ArrowArrayConstructor(matlabArray), "MATLAB:invalidType");
+            tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
 
             % Empty char (1x0)
             matlabArray = char.empty(1, 0);
-            tc.verifyError(@() tc.ArrowArrayConstructor(matlabArray), "MATLAB:invalidType");
+            tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
         end
     end
 end
diff --git a/matlab/test/arrow/array/tTimestampArray.m b/matlab/test/arrow/array/tTimestampArray.m
index b0a902f319bf1..5b7182c386c25 100644
--- a/matlab/test/arrow/array/tTimestampArray.m
+++ b/matlab/test/arrow/array/tTimestampArray.m
@@ -16,6 +16,10 @@
 classdef tTimestampArray < matlab.unittest.TestCase
 % Tests for arrow.array.TimestampArray
 
+    properties
+        ArrowArrayConstructorFcn = @arrow.array.TimestampArray.fromMATLAB
+    end
+
     properties(TestParameter)
         TimeZone = {"" "America/New_York"}
         TimeUnit = {arrow.type.TimeUnit.Second arrow.type.TimeUnit.Millisecond
@@ -25,26 +29,25 @@
     methods(Test)
         function Basic(tc, TimeZone)
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
-            arrowArray = arrow.array.TimestampArray(dates);
+            arrowArray = tc.ArrowArrayConstructorFcn(dates);
             className = string(class(arrowArray));
             tc.verifyEqual(className, "arrow.array.TimestampArray");
         end
 
         function TestLength(testCase, TimeZone)
         % Verify the Length property.
-            import arrow.array.TimestampArray
 
             dates = datetime.empty(0, 1);
             dates.TimeZone = TimeZone;
-            arrowArray = TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyEqual(arrowArray.Length, int64(0));
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone);
-            arrowArray = TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyEqual(arrowArray.Length, int64(1));
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
-            arrowArray = TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyEqual(arrowArray.Length, int64(5));
         end
 
@@ -54,76 +57,72 @@ function TestDefaultTimestampType(testCase, TimeZone)
             import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
-            arrowArray = TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyTimestampType(arrowArray.Type, arrow.type.TimeUnit.Microsecond, TimeZone);
         end
 
         function TestSupplyTimeUnit(testCase, TimeZone)
         % Supply the TimeUnit name-value pair at construction.
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
 
-            arrowArray = TimestampArray(dates, TimeUnit="Second");
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit="Second");
             testCase.verifyTimestampType(arrowArray.Type, arrow.type.TimeUnit.Second, TimeZone);
 
-            arrowArray = TimestampArray(dates, TimeUnit="Millisecond");
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit="Millisecond");
             testCase.verifyTimestampType(arrowArray.Type, arrow.type.TimeUnit.Millisecond, TimeZone);
 
-            arrowArray = TimestampArray(dates, TimeUnit="Microsecond");
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit="Microsecond");
             testCase.verifyTimestampType(arrowArray.Type, arrow.type.TimeUnit.Microsecond, TimeZone);
 
-            arrowArray = TimestampArray(dates, TimeUnit="Nanosecond");
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit="Nanosecond");
             testCase.verifyTimestampType(arrowArray.Type, arrow.type.TimeUnit.Nanosecond, TimeZone);
         end
 
         function TestToMATLAB(testCase, TimeUnit, TimeZone)
         % Verify toMATLAB() round-trips the original datetime array.
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
 
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit);
             values = toMATLAB(arrowArray);
             testCase.verifyEqual(values, dates');
         end
 
         function TestDatetime(testCase, TimeUnit, TimeZone)
         % Verify datetime() round-trips the original datetime array.
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit);
             values = datetime(arrowArray);
             testCase.verifyEqual(values, dates');
         end
 
         function TestValid(testCase, TimeZone)
         % Verify the Valid property returns the expected logical vector.
-            import arrow.array.TimestampArray
+
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
             dates([2 4]) = NaT;
-            arrowArray = arrow.array.TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyEqual(arrowArray.Valid, [true; false; true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), dates');
             testCase.verifyEqual(datetime(arrowArray), dates');
         end
 
         function TestInferNulls(testCase, TimeUnit, TimeZone)
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
             dates([2 4]) = NaT;
 
             % Verify NaT is treated as a null value if InferNulls=true.
             expectedDates = dates';
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit, InferNulls=true);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit, InferNulls=true);
             testCase.verifyEqual(arrowArray.Valid, [true; false; true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), expectedDates);
 
             % Verify NaT is not treated as a null value if InferNulls=false.
             % The NaT values are mapped to int64(0).
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit, InferNulls=false);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit, InferNulls=false);
             testCase.verifyEqual(arrowArray.Valid, [true; true; true; true; true]);
             
             % If the TimestampArray is zoned, int64(0) may not correspond
@@ -134,13 +133,12 @@ function TestInferNulls(testCase, TimeUnit, TimeZone)
         end
 
         function TestValidNVPair(testCase, TimeUnit, TimeZone)
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
             dates([2 4]) = NaT;
             
             % Supply the Valid name-value pair as vector of indices.
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit, Valid=[1 2 5]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit, Valid=[1 2 5]);
             testCase.verifyEqual(arrowArray.Valid, [true; true; false; false; true]);
             expectedDates = dates';
             expectedDates(2) = getFillValue(TimeZone);
@@ -148,33 +146,41 @@ function TestValidNVPair(testCase, TimeUnit, TimeZone)
             testCase.verifyEqual(toMATLAB(arrowArray), expectedDates);
 
             % Supply the Valid name-value pair as a logical scalar.
-            arrowArray = arrow.array.TimestampArray(dates, TimeUnit=TimeUnit, Valid=false);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates, TimeUnit=TimeUnit, Valid=false);
             testCase.verifyEqual(arrowArray.Valid, [false; false; false; false; false]);
             expectedDates(:) = NaT;
             testCase.verifyEqual(toMATLAB(arrowArray), expectedDates);
         end
 
         function ErrorIfNonVector(testCase)
-            import arrow.array.TimestampArray
 
             dates = datetime(2023, 6, 2) + days(0:11);
             dates = reshape(dates, 2, 6);
-            fcn = @() TimestampArray(dates);
-            testCase.verifyError(fcn, "MATLAB:expectedVector");
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
 
             dates = reshape(dates, 3, 2, 2);
-            fcn = @() TimestampArray(dates);
-            testCase.verifyError(fcn, "MATLAB:expectedVector");
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
         end
 
         function EmptyDatetimeVector(testCase)
             import arrow.array.TimestampArray
 
             dates = datetime.empty(0, 0);
-            arrowArray = TimestampArray(dates);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(arrowArray.Length, int64(0));
+            testCase.verifyEqual(arrowArray.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(arrowArray), datetime.empty(0, 1));
+
+            % test with NDimensional empty array
+            dates = datetime.empty(0, 1, 0);
+            arrowArray = testCase.ArrowArrayConstructorFcn(dates);
             testCase.verifyEqual(arrowArray.Length, int64(0));
             testCase.verifyEqual(arrowArray.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(arrowArray), datetime.empty(0, 1));
+
+
         end
     end
 
diff --git a/matlab/test/arrow/array/tUInt16Array.m b/matlab/test/arrow/array/tUInt16Array.m
index 705d6eabc0b7b..c3445b7c7c6ea 100644
--- a/matlab/test/arrow/array/tUInt16Array.m
+++ b/matlab/test/arrow/array/tUInt16Array.m
@@ -18,7 +18,7 @@
     
     properties
         ArrowArrayClassName = "arrow.array.UInt16Array"
-        ArrowArrayConstructor = @arrow.array.UInt16Array
+        ArrowArrayConstructorFcn = @arrow.array.UInt16Array.fromMATLAB
         MatlabConversionFcn = @uint16 % uint16 method on class
         MatlabArrayFcn = @uint16 % uint16 function
         MaxValue = intmax("uint16")
diff --git a/matlab/test/arrow/array/tUInt32Array.m b/matlab/test/arrow/array/tUInt32Array.m
index 267a687738e44..e6372b8db79f4 100644
--- a/matlab/test/arrow/array/tUInt32Array.m
+++ b/matlab/test/arrow/array/tUInt32Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.UInt32Array"
-        ArrowArrayConstructor = @arrow.array.UInt32Array
+        ArrowArrayConstructorFcn = @arrow.array.UInt32Array.fromMATLAB
         MatlabConversionFcn = @uint32 % uint32 method on class
         MatlabArrayFcn = @uint32 % uint32 function
         MaxValue = intmax("uint32")
diff --git a/matlab/test/arrow/array/tUInt64Array.m b/matlab/test/arrow/array/tUInt64Array.m
index b1a23a004de69..16c3cc81cdef0 100644
--- a/matlab/test/arrow/array/tUInt64Array.m
+++ b/matlab/test/arrow/array/tUInt64Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.UInt64Array"
-        ArrowArrayConstructor = @arrow.array.UInt64Array
+        ArrowArrayConstructorFcn = @arrow.array.UInt64Array.fromMATLAB
         MatlabConversionFcn = @uint64 % uint64 method on class
         MatlabArrayFcn = @uint64 % uint64 function
         MaxValue = intmax("uint64")
diff --git a/matlab/test/arrow/array/tUInt8Array.m b/matlab/test/arrow/array/tUInt8Array.m
index 3db79f8c0b16d..a27e3442eda89 100644
--- a/matlab/test/arrow/array/tUInt8Array.m
+++ b/matlab/test/arrow/array/tUInt8Array.m
@@ -18,7 +18,7 @@
 
     properties
         ArrowArrayClassName = "arrow.array.UInt8Array"
-        ArrowArrayConstructor = @arrow.array.UInt8Array
+        ArrowArrayConstructorFcn = @arrow.array.UInt8Array.fromMATLAB
         MatlabConversionFcn = @uint8 % uint8 method on class
         MatlabArrayFcn = @uint8 % uint8 function
         MaxValue = intmax("uint8")
diff --git a/matlab/test/arrow/internal/validate/tNonsparse.m b/matlab/test/arrow/internal/validate/tNonsparse.m
new file mode 100644
index 0000000000000..e2eb363fca316
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/tNonsparse.m
@@ -0,0 +1,44 @@
+%TNONSPARSE Unit tests for arrow.internal.validate.nonsparse.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tNonsparse < matlab.unittest.TestCase
+    
+    methods(Test)
+        % Test methods
+        function ErrorIfSparseDouble(testCase)
+            fcn = @() arrow.internal.validate.nonsparse(sparse(ones([10 1])));
+            errid = "arrow:array:Sparse";
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ErrorIfSparseLogical(testCase)
+            fcn = @() arrow.internal.validate.nonsparse(sparse(true([10 1])));
+            errid = "arrow:array:Sparse";
+            testCase.verifyError(fcn, errid);
+        end
+
+        function NoErrorIfNonSparseDouble(testCase)
+            fcn = @() arrow.internal.validate.nonsparse(ones([10 1]));
+            testCase.verifyWarningFree(fcn); 
+        end
+
+        function NoErrorIfNonSparseLogical(testCase)
+            fcn = @() arrow.internal.validate.nonsparse(true([10 1]));
+            testCase.verifyWarningFree(fcn); 
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/tNumeric.m b/matlab/test/arrow/internal/validate/tNumeric.m
new file mode 100644
index 0000000000000..91c94233ded0b
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/tNumeric.m
@@ -0,0 +1,56 @@
+%TNUMERIC Unit tests for arrow.internal.validate.numeric.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tNumeric < matlab.unittest.TestCase
+    
+    methods(Test)
+        
+        function ErrorIfWrongType(testCase)
+            data = [1 2 2 4];
+            fcn = @() arrow.internal.validate.numeric(data, "single");
+            errid = "arrow:array:InvalidType";            
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ErrorIfNonVector(testCase)
+            data = [1 2; 2 4];
+            fcn = @() arrow.internal.validate.numeric(data, "double");
+            errid = "arrow:array:InvalidShape";            
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ErrorIfNonsparse(testCase)
+            data = sparse([1 1 2 2]);
+            fcn = @() arrow.internal.validate.numeric(data, "double");
+            errid = "arrow:array:Sparse";            
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ErrorIfComplex(testCase)
+            data = [10 + 3i 11 + 4i];
+            fcn = @() arrow.internal.validate.numeric(data, "double");
+            errid = "arrow:array:ComplexNumeric";            
+            testCase.verifyError(fcn, errid);
+        end
+
+        function NoErrorIfRealNonsparseNumericVector(testCase)
+            data = [10 11 12 13];
+            fcn = @() arrow.internal.validate.numeric(data, "double");
+            testCase.verifyWarningFree(fcn);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/args/tParseValidElements.m b/matlab/test/arrow/internal/validate/tParseValidElements.m
similarity index 99%
rename from matlab/test/arrow/args/tParseValidElements.m
rename to matlab/test/arrow/internal/validate/tParseValidElements.m
index 9d7586db9536a..9751327adc6f7 100644
--- a/matlab/test/arrow/args/tParseValidElements.m
+++ b/matlab/test/arrow/internal/validate/tParseValidElements.m
@@ -186,5 +186,5 @@ function AllElementsAreValid(testCase)
         opts.InferNulls = true;
         opts.Valid
     end
-    validElements = arrow.args.parseValidElements(data, opts);
+    validElements = arrow.internal.validate.parseValidElements(data, opts);
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/tRealNumeric.m b/matlab/test/arrow/internal/validate/tRealNumeric.m
new file mode 100644
index 0000000000000..9b45a6e0b561c
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/tRealNumeric.m
@@ -0,0 +1,43 @@
+%TREALNUMERIC Unit tests for arrow.internal.validate.realnumeric.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tRealNumeric < matlab.unittest.TestCase
+
+    properties(TestParameter)
+        NumericType = struct(uint8=@uint8, ...
+                             uint16=@uint16, ...
+                             uint32=@uint32, ...
+                             uint64=@uint64, ...
+                             int8=@int8,...
+                             int16=@int16, ...
+                             int32=@int32, ... 
+                             int64=@int64, ...
+                             single=@single, ...
+                             double=@double);
+    end
+    
+
+    methods(Test)
+        function ErrorIfComplex(testCase, NumericType)
+            complexValue = NumericType(10 + 1i);
+            fcn = @() arrow.internal.validate.realnumeric(complexValue);
+            errID = "arrow:array:ComplexNumeric";
+            testCase.verifyError(fcn, errID);
+        end
+    end
+    
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/tShape.m b/matlab/test/arrow/internal/validate/tShape.m
new file mode 100644
index 0000000000000..52720a5e2508e
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/tShape.m
@@ -0,0 +1,69 @@
+%TSHAPE Unit tests for arrow.internal.validate.shape.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tShape < matlab.unittest.TestCase
+    
+    methods(Test)
+        function ErrorIf2DimensionalMatrix(testCase)
+            data = [1 2; 4 5];
+            fcn = @() arrow.internal.validate.shape(data);
+            errID = "arrow:array:InvalidShape";
+            testCase.verifyError(fcn, errID);
+        end
+
+        function ErrorIfNDMatrix(testCase)
+            data = ones([2 2 3]);
+            fcn = @() arrow.internal.validate.shape(data);
+            errID = "arrow:array:InvalidShape";
+            testCase.verifyError(fcn, errID);
+        end
+
+        function NoErrorIfRowVector(testCase)
+            data = [1 2 4 5];
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function NoErrorIfColumnVector(testCase)
+            data = [1 2 4 5]';
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+        end
+    
+        function NoErrorIfEmpty(testCase)
+            data = double.empty(0, 0);
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+
+            data = double.empty(0, 1);
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+
+            data = double.empty(1, 0);
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+
+            data = double.empty(0, 1, 0);
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+
+             data = double.empty(0, 0, 5);
+            fcn = @() arrow.internal.validate.shape(data);
+            testCase.verifyWarningFree(fcn);
+        end
+    end    
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+args/validateTypeAndShape.m b/matlab/test/arrow/internal/validate/tType.m
similarity index 55%
rename from matlab/src/matlab/+arrow/+args/validateTypeAndShape.m
rename to matlab/test/arrow/internal/validate/tType.m
index 78e8dd1efe4dd..38ec58c3afffb 100644
--- a/matlab/src/matlab/+arrow/+args/validateTypeAndShape.m
+++ b/matlab/test/arrow/internal/validate/tType.m
@@ -1,3 +1,5 @@
+%TTYPE Unit tests for arrow.internal.validate.type.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,24 +15,20 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-function validateTypeAndShape(data, type)
-% Validates data has the expected type and is a vector or empty 2D
-% matrix. If data is numeric, validates is real and nonsparse.
-
-    arguments
-        data
-        type(1, 1) string
-    end
-
-    % If data is empty, only require it's shape to be 2D to support 0x0 
-    % arrays. Otherwise, require data to be a vector.
-    %
-    % TODO: Consider supporting nonvector 2D arrays. We chould reshape them
-    % to column vectors if needed.
+classdef tType < matlab.unittest.TestCase
     
-    expectedShape = "vector";
-    if isempty(data)
-        expectedShape = "2d";
+    methods(Test)        
+        function ErrorIfWrongType(testCase)
+            data = uint64([1 2 3]);
+            fcn = @() arrow.internal.validate.type(data, "double");
+            errid = "arrow:array:InvalidType";
+            testCase.verifyError(fcn, errid);
+        end
+
+        function NoErrorIfRightType(testCase)
+            data = uint64([1 2 3]);
+            fcn = @() arrow.internal.validate.type(data, "uint64");
+            testCase.verifyWarningFree(fcn);
+        end
     end
-    validateattributes(data, type, [expectedShape, "nonsparse", "real"]);
 end
\ No newline at end of file

From 4b70fd4b1eac29cd8ac20083ad644b60fe6483ab Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 4 Aug 2023 05:50:50 +0900
Subject: [PATCH 089/749] GH-36856: [C++] Remove needless braces from
 BasicDecimal256FromLE() arguments (#36987)

### Rationale for this change

BasicDecimal256FromLE() requires 4 arguments. So we should not use BasicDecimal256FromLE({X, X, X, X}) form.

I don't know why the current form works on amd64 but doesn't work on s390x.

### What changes are included in this PR?

Removed needless "{" and "}".

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #36856

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/decimal_internal.h | 447 +++++++++++++-------------
 1 file changed, 220 insertions(+), 227 deletions(-)

diff --git a/cpp/src/arrow/util/decimal_internal.h b/cpp/src/arrow/util/decimal_internal.h
index 51a7229ab6678..89f755af88316 100644
--- a/cpp/src/arrow/util/decimal_internal.h
+++ b/cpp/src/arrow/util/decimal_internal.h
@@ -197,235 +197,228 @@ constexpr BasicDecimal128 kDecimal128HalfPowersOfTen[] = {
 #endif
 
 constexpr BasicDecimal256 kDecimal256PowersOfTen[76 + 1] = {
-    BasicDecimal256FromLE({1ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({100000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1000000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10000000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({7766279631452241920ULL, 5ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({3875820019684212736ULL, 54ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1864712049423024128ULL, 542ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({200376420520689664ULL, 5421ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({2003764205206896640ULL, 54210ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1590897978359414784ULL, 542101ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({15908979783594147840ULL, 5421010ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({11515845246265065472ULL, 54210108ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({4477988020393345024ULL, 542101086ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({7886392056514347008ULL, 5421010862ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5076944270305263616ULL, 54210108624ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({13875954555633532928ULL, 542101086242ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({9632337040368467968ULL, 5421010862427ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({4089650035136921600ULL, 54210108624275ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({4003012203950112768ULL, 542101086242752ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({3136633892082024448ULL, 5421010862427522ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({12919594847110692864ULL, 54210108624275221ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({68739955140067328ULL, 542101086242752217ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({687399551400673280ULL, 5421010862427522170ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({6873995514006732800ULL, 17316620476856118468ULL, 2ULL, 0ULL}),
-    BasicDecimal256FromLE({13399722918938673152ULL, 7145508105175220139ULL, 29ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {4870020673419870208ULL, 16114848830623546549ULL, 293ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {11806718586779598848ULL, 13574535716559052564ULL, 2938ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {7386721425538678784ULL, 6618148649623664334ULL, 29387ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {80237960548581376ULL, 10841254275107988496ULL, 293873ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {802379605485813760ULL, 16178822382532126880ULL, 2938735ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {8023796054858137600ULL, 14214271235644855872ULL, 29387358ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {6450984253743169536ULL, 13015503840481697412ULL, 293873587ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {9169610316303040512ULL, 1027829888850112811ULL, 2938735877ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {17909126868192198656ULL, 10278298888501128114ULL, 29387358770ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {13070572018536022016ULL, 10549268516463523069ULL, 293873587705ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {1578511669393358848ULL, 13258964796087472617ULL, 2938735877055ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {15785116693933588480ULL, 3462439444907864858ULL, 29387358770557ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {10277214349659471872ULL, 16177650375369096972ULL, 293873587705571ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {10538423128046960640ULL, 14202551164014556797ULL, 2938735877055718ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {13150510911921848320ULL, 12898303124178706663ULL, 29387358770557187ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {2377900603251621888ULL, 18302566799529756941ULL, 293873587705571876ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {5332261958806667264ULL, 17004971331911604867ULL, 2938735877055718769ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {16429131440647569408ULL, 4029016655730084128ULL, 10940614696847636083ULL, 1ULL}),
-    BasicDecimal256FromLE({16717361816799281152ULL, 3396678409881738056ULL,
-                           17172426599928602752ULL, 15ULL}),
-    BasicDecimal256FromLE({1152921504606846976ULL, 15520040025107828953ULL,
-                           5703569335900062977ULL, 159ULL}),
-    BasicDecimal256FromLE({11529215046068469760ULL, 7626447661401876602ULL,
-                           1695461137871974930ULL, 1593ULL}),
-    BasicDecimal256FromLE({4611686018427387904ULL, 2477500319180559562ULL,
-                           16954611378719749304ULL, 15930ULL}),
-    BasicDecimal256FromLE({9223372036854775808ULL, 6328259118096044006ULL,
-                           3525417123811528497ULL, 159309ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 7942358959831785217ULL, 16807427164405733357ULL, 1593091ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 5636613303479645706ULL, 2053574980671369030ULL, 15930919ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 1025900813667802212ULL, 2089005733004138687ULL, 159309191ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 10259008136678022120ULL, 2443313256331835254ULL, 1593091911ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 10356360998232463120ULL, 5986388489608800929ULL, 15930919111ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 11329889613776873120ULL, 4523652674959354447ULL, 159309191113ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 2618431695511421504ULL, 8343038602174441244ULL, 1593091911132ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 7737572881404663424ULL, 9643409726906205977ULL, 15930919111324ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 3588752519208427776ULL, 4200376900514301694ULL, 159309191113245ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 17440781118374726144ULL, 5110280857723913709ULL, 1593091911132452ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 8387114520361296896ULL, 14209320429820033867ULL, 15930919111324522ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 10084168908774762496ULL, 12965995782233477362ULL, 159309191113245227ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 8607968719199866880ULL, 532749306367912313ULL, 1593091911132452277ULL})};
+    BasicDecimal256FromLE(1ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(100000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1000000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10000000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(7766279631452241920ULL, 5ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(3875820019684212736ULL, 54ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1864712049423024128ULL, 542ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(200376420520689664ULL, 5421ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(2003764205206896640ULL, 54210ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1590897978359414784ULL, 542101ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(15908979783594147840ULL, 5421010ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(11515845246265065472ULL, 54210108ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(4477988020393345024ULL, 542101086ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(7886392056514347008ULL, 5421010862ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5076944270305263616ULL, 54210108624ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(13875954555633532928ULL, 542101086242ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(9632337040368467968ULL, 5421010862427ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(4089650035136921600ULL, 54210108624275ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(4003012203950112768ULL, 542101086242752ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(3136633892082024448ULL, 5421010862427522ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(12919594847110692864ULL, 54210108624275221ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(68739955140067328ULL, 542101086242752217ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(687399551400673280ULL, 5421010862427522170ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(6873995514006732800ULL, 17316620476856118468ULL, 2ULL, 0ULL),
+    BasicDecimal256FromLE(13399722918938673152ULL, 7145508105175220139ULL, 29ULL, 0ULL),
+    BasicDecimal256FromLE(4870020673419870208ULL, 16114848830623546549ULL, 293ULL, 0ULL),
+    BasicDecimal256FromLE(11806718586779598848ULL, 13574535716559052564ULL, 2938ULL,
+                          0ULL),
+    BasicDecimal256FromLE(7386721425538678784ULL, 6618148649623664334ULL, 29387ULL, 0ULL),
+    BasicDecimal256FromLE(80237960548581376ULL, 10841254275107988496ULL, 293873ULL, 0ULL),
+    BasicDecimal256FromLE(802379605485813760ULL, 16178822382532126880ULL, 2938735ULL,
+                          0ULL),
+    BasicDecimal256FromLE(8023796054858137600ULL, 14214271235644855872ULL, 29387358ULL,
+                          0ULL),
+    BasicDecimal256FromLE(6450984253743169536ULL, 13015503840481697412ULL, 293873587ULL,
+                          0ULL),
+    BasicDecimal256FromLE(9169610316303040512ULL, 1027829888850112811ULL, 2938735877ULL,
+                          0ULL),
+    BasicDecimal256FromLE(17909126868192198656ULL, 10278298888501128114ULL,
+                          29387358770ULL, 0ULL),
+    BasicDecimal256FromLE(13070572018536022016ULL, 10549268516463523069ULL,
+                          293873587705ULL, 0ULL),
+    BasicDecimal256FromLE(1578511669393358848ULL, 13258964796087472617ULL,
+                          2938735877055ULL, 0ULL),
+    BasicDecimal256FromLE(15785116693933588480ULL, 3462439444907864858ULL,
+                          29387358770557ULL, 0ULL),
+    BasicDecimal256FromLE(10277214349659471872ULL, 16177650375369096972ULL,
+                          293873587705571ULL, 0ULL),
+    BasicDecimal256FromLE(10538423128046960640ULL, 14202551164014556797ULL,
+                          2938735877055718ULL, 0ULL),
+    BasicDecimal256FromLE(13150510911921848320ULL, 12898303124178706663ULL,
+                          29387358770557187ULL, 0ULL),
+    BasicDecimal256FromLE(2377900603251621888ULL, 18302566799529756941ULL,
+                          293873587705571876ULL, 0ULL),
+    BasicDecimal256FromLE(5332261958806667264ULL, 17004971331911604867ULL,
+                          2938735877055718769ULL, 0ULL),
+    BasicDecimal256FromLE(16429131440647569408ULL, 4029016655730084128ULL,
+                          10940614696847636083ULL, 1ULL),
+    BasicDecimal256FromLE(16717361816799281152ULL, 3396678409881738056ULL,
+                          17172426599928602752ULL, 15ULL),
+    BasicDecimal256FromLE(1152921504606846976ULL, 15520040025107828953ULL,
+                          5703569335900062977ULL, 159ULL),
+    BasicDecimal256FromLE(11529215046068469760ULL, 7626447661401876602ULL,
+                          1695461137871974930ULL, 1593ULL),
+    BasicDecimal256FromLE(4611686018427387904ULL, 2477500319180559562ULL,
+                          16954611378719749304ULL, 15930ULL),
+    BasicDecimal256FromLE(9223372036854775808ULL, 6328259118096044006ULL,
+                          3525417123811528497ULL, 159309ULL),
+    BasicDecimal256FromLE(0ULL, 7942358959831785217ULL, 16807427164405733357ULL,
+                          1593091ULL),
+    BasicDecimal256FromLE(0ULL, 5636613303479645706ULL, 2053574980671369030ULL,
+                          15930919ULL),
+    BasicDecimal256FromLE(0ULL, 1025900813667802212ULL, 2089005733004138687ULL,
+                          159309191ULL),
+    BasicDecimal256FromLE(0ULL, 10259008136678022120ULL, 2443313256331835254ULL,
+                          1593091911ULL),
+    BasicDecimal256FromLE(0ULL, 10356360998232463120ULL, 5986388489608800929ULL,
+                          15930919111ULL),
+    BasicDecimal256FromLE(0ULL, 11329889613776873120ULL, 4523652674959354447ULL,
+                          159309191113ULL),
+    BasicDecimal256FromLE(0ULL, 2618431695511421504ULL, 8343038602174441244ULL,
+                          1593091911132ULL),
+    BasicDecimal256FromLE(0ULL, 7737572881404663424ULL, 9643409726906205977ULL,
+                          15930919111324ULL),
+    BasicDecimal256FromLE(0ULL, 3588752519208427776ULL, 4200376900514301694ULL,
+                          159309191113245ULL),
+    BasicDecimal256FromLE(0ULL, 17440781118374726144ULL, 5110280857723913709ULL,
+                          1593091911132452ULL),
+    BasicDecimal256FromLE(0ULL, 8387114520361296896ULL, 14209320429820033867ULL,
+                          15930919111324522ULL),
+    BasicDecimal256FromLE(0ULL, 10084168908774762496ULL, 12965995782233477362ULL,
+                          159309191113245227ULL),
+    BasicDecimal256FromLE(0ULL, 8607968719199866880ULL, 532749306367912313ULL,
+                          1593091911132452277ULL)};
 
 constexpr BasicDecimal256 kDecimal256HalfPowersOfTen[] = {
-    BasicDecimal256FromLE({0ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({50000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({500000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5000000000000000000ULL, 0ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({13106511852580896768ULL, 2ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1937910009842106368ULL, 27ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({932356024711512064ULL, 271ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({9323560247115120640ULL, 2710ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1001882102603448320ULL, 27105ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({10018821026034483200ULL, 271050ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({7954489891797073920ULL, 2710505ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({5757922623132532736ULL, 27105054ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({2238994010196672512ULL, 271050543ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({3943196028257173504ULL, 2710505431ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({2538472135152631808ULL, 27105054312ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({6937977277816766464ULL, 271050543121ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({14039540557039009792ULL, 2710505431213ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({11268197054423236608ULL, 27105054312137ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({2001506101975056384ULL, 271050543121376ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({1568316946041012224ULL, 2710505431213761ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({15683169460410122240ULL, 27105054312137610ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({9257742014424809472ULL, 271050543121376108ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({343699775700336640ULL, 2710505431213761085ULL, 0ULL, 0ULL}),
-    BasicDecimal256FromLE({3436997757003366400ULL, 8658310238428059234ULL, 1ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {15923233496324112384ULL, 12796126089442385877ULL, 14ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {11658382373564710912ULL, 17280796452166549082ULL, 146ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {5903359293389799424ULL, 6787267858279526282ULL, 1469ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {3693360712769339392ULL, 12532446361666607975ULL, 14693ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {40118980274290688ULL, 14643999174408770056ULL, 146936ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {401189802742906880ULL, 17312783228120839248ULL, 1469367ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {4011898027429068800ULL, 7107135617822427936ULL, 14693679ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {3225492126871584768ULL, 15731123957095624514ULL, 146936793ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {13808177195006296064ULL, 9737286981279832213ULL, 1469367938ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {8954563434096099328ULL, 5139149444250564057ULL, 14693679385ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {15758658046122786816ULL, 14498006295086537342ULL, 146936793852ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {10012627871551455232ULL, 15852854434898512116ULL, 1469367938527ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {7892558346966794240ULL, 10954591759308708237ULL, 14693679385278ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {5138607174829735936ULL, 17312197224539324294ULL, 146936793852785ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {14492583600878256128ULL, 7101275582007278398ULL, 1469367938527859ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {15798627492815699968ULL, 15672523598944129139ULL, 14693679385278593ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {10412322338480586752ULL, 9151283399764878470ULL, 146936793852785938ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {11889503016258109440ULL, 17725857702810578241ULL, 1469367938527859384ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {8214565720323784704ULL, 11237880364719817872ULL, 14693679385278593849ULL, 0ULL}),
-    BasicDecimal256FromLE(
-        {8358680908399640576ULL, 1698339204940869028ULL, 17809585336819077184ULL, 7ULL}),
-    BasicDecimal256FromLE({9799832789158199296ULL, 16983392049408690284ULL,
-                           12075156704804807296ULL, 79ULL}),
-    BasicDecimal256FromLE({5764607523034234880ULL, 3813223830700938301ULL,
-                           10071102605790763273ULL, 796ULL}),
-    BasicDecimal256FromLE({2305843009213693952ULL, 1238750159590279781ULL,
-                           8477305689359874652ULL, 7965ULL}),
-    BasicDecimal256FromLE({4611686018427387904ULL, 12387501595902797811ULL,
-                           10986080598760540056ULL, 79654ULL}),
-    BasicDecimal256FromLE({9223372036854775808ULL, 13194551516770668416ULL,
-                           17627085619057642486ULL, 796545ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 2818306651739822853ULL, 10250159527190460323ULL, 7965459ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 9736322443688676914ULL, 10267874903356845151ULL, 79654595ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 5129504068339011060ULL, 10445028665020693435ULL, 796545955ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 14401552535971007368ULL, 12216566281659176272ULL, 7965459555ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 14888316843743212368ULL, 11485198374334453031ULL, 79654595556ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 1309215847755710752ULL, 4171519301087220622ULL, 796545955566ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 13092158477557107520ULL, 4821704863453102988ULL, 7965459555662ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 1794376259604213888ULL, 11323560487111926655ULL, 79654595556622ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 17943762596042138880ULL, 2555140428861956854ULL, 796545955566226ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 13416929297035424256ULL, 7104660214910016933ULL, 7965459555662261ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 5042084454387381248ULL, 15706369927971514489ULL, 79654595556622613ULL}),
-    BasicDecimal256FromLE(
-        {0ULL, 13527356396454709248ULL, 9489746690038731964ULL, 796545955566226138ULL})};
+    BasicDecimal256FromLE(0ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(50000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(500000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5000000000000000000ULL, 0ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(13106511852580896768ULL, 2ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1937910009842106368ULL, 27ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(932356024711512064ULL, 271ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(9323560247115120640ULL, 2710ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1001882102603448320ULL, 27105ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(10018821026034483200ULL, 271050ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(7954489891797073920ULL, 2710505ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(5757922623132532736ULL, 27105054ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(2238994010196672512ULL, 271050543ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(3943196028257173504ULL, 2710505431ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(2538472135152631808ULL, 27105054312ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(6937977277816766464ULL, 271050543121ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(14039540557039009792ULL, 2710505431213ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(11268197054423236608ULL, 27105054312137ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(2001506101975056384ULL, 271050543121376ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(1568316946041012224ULL, 2710505431213761ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(15683169460410122240ULL, 27105054312137610ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(9257742014424809472ULL, 271050543121376108ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(343699775700336640ULL, 2710505431213761085ULL, 0ULL, 0ULL),
+    BasicDecimal256FromLE(3436997757003366400ULL, 8658310238428059234ULL, 1ULL, 0ULL),
+    BasicDecimal256FromLE(15923233496324112384ULL, 12796126089442385877ULL, 14ULL, 0ULL),
+    BasicDecimal256FromLE(11658382373564710912ULL, 17280796452166549082ULL, 146ULL, 0ULL),
+    BasicDecimal256FromLE(5903359293389799424ULL, 6787267858279526282ULL, 1469ULL, 0ULL),
+    BasicDecimal256FromLE(3693360712769339392ULL, 12532446361666607975ULL, 14693ULL,
+                          0ULL),
+    BasicDecimal256FromLE(40118980274290688ULL, 14643999174408770056ULL, 146936ULL, 0ULL),
+    BasicDecimal256FromLE(401189802742906880ULL, 17312783228120839248ULL, 1469367ULL,
+                          0ULL),
+    BasicDecimal256FromLE(4011898027429068800ULL, 7107135617822427936ULL, 14693679ULL,
+                          0ULL),
+    BasicDecimal256FromLE(3225492126871584768ULL, 15731123957095624514ULL, 146936793ULL,
+                          0ULL),
+    BasicDecimal256FromLE(13808177195006296064ULL, 9737286981279832213ULL, 1469367938ULL,
+                          0ULL),
+    BasicDecimal256FromLE(8954563434096099328ULL, 5139149444250564057ULL, 14693679385ULL,
+                          0ULL),
+    BasicDecimal256FromLE(15758658046122786816ULL, 14498006295086537342ULL,
+                          146936793852ULL, 0ULL),
+    BasicDecimal256FromLE(10012627871551455232ULL, 15852854434898512116ULL,
+                          1469367938527ULL, 0ULL),
+    BasicDecimal256FromLE(7892558346966794240ULL, 10954591759308708237ULL,
+                          14693679385278ULL, 0ULL),
+    BasicDecimal256FromLE(5138607174829735936ULL, 17312197224539324294ULL,
+                          146936793852785ULL, 0ULL),
+    BasicDecimal256FromLE(14492583600878256128ULL, 7101275582007278398ULL,
+                          1469367938527859ULL, 0ULL),
+    BasicDecimal256FromLE(15798627492815699968ULL, 15672523598944129139ULL,
+                          14693679385278593ULL, 0ULL),
+    BasicDecimal256FromLE(10412322338480586752ULL, 9151283399764878470ULL,
+                          146936793852785938ULL, 0ULL),
+    BasicDecimal256FromLE(11889503016258109440ULL, 17725857702810578241ULL,
+                          1469367938527859384ULL, 0ULL),
+    BasicDecimal256FromLE(8214565720323784704ULL, 11237880364719817872ULL,
+                          14693679385278593849ULL, 0ULL),
+    BasicDecimal256FromLE(8358680908399640576ULL, 1698339204940869028ULL,
+                          17809585336819077184ULL, 7ULL),
+    BasicDecimal256FromLE(9799832789158199296ULL, 16983392049408690284ULL,
+                          12075156704804807296ULL, 79ULL),
+    BasicDecimal256FromLE(5764607523034234880ULL, 3813223830700938301ULL,
+                          10071102605790763273ULL, 796ULL),
+    BasicDecimal256FromLE(2305843009213693952ULL, 1238750159590279781ULL,
+                          8477305689359874652ULL, 7965ULL),
+    BasicDecimal256FromLE(4611686018427387904ULL, 12387501595902797811ULL,
+                          10986080598760540056ULL, 79654ULL),
+    BasicDecimal256FromLE(9223372036854775808ULL, 13194551516770668416ULL,
+                          17627085619057642486ULL, 796545ULL),
+    BasicDecimal256FromLE(0ULL, 2818306651739822853ULL, 10250159527190460323ULL,
+                          7965459ULL),
+    BasicDecimal256FromLE(0ULL, 9736322443688676914ULL, 10267874903356845151ULL,
+                          79654595ULL),
+    BasicDecimal256FromLE(0ULL, 5129504068339011060ULL, 10445028665020693435ULL,
+                          796545955ULL),
+    BasicDecimal256FromLE(0ULL, 14401552535971007368ULL, 12216566281659176272ULL,
+                          7965459555ULL),
+    BasicDecimal256FromLE(0ULL, 14888316843743212368ULL, 11485198374334453031ULL,
+                          79654595556ULL),
+    BasicDecimal256FromLE(0ULL, 1309215847755710752ULL, 4171519301087220622ULL,
+                          796545955566ULL),
+    BasicDecimal256FromLE(0ULL, 13092158477557107520ULL, 4821704863453102988ULL,
+                          7965459555662ULL),
+    BasicDecimal256FromLE(0ULL, 1794376259604213888ULL, 11323560487111926655ULL,
+                          79654595556622ULL),
+    BasicDecimal256FromLE(0ULL, 17943762596042138880ULL, 2555140428861956854ULL,
+                          796545955566226ULL),
+    BasicDecimal256FromLE(0ULL, 13416929297035424256ULL, 7104660214910016933ULL,
+                          7965459555662261ULL),
+    BasicDecimal256FromLE(0ULL, 5042084454387381248ULL, 15706369927971514489ULL,
+                          79654595556622613ULL),
+    BasicDecimal256FromLE(0ULL, 13527356396454709248ULL, 9489746690038731964ULL,
+                          796545955566226138ULL)};
 
 #undef BasicDecimal256FromLE
 

From 9b3bf08f78f690605394ad3815177ece931f06d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Thu, 3 Aug 2023 23:04:15 +0200
Subject: [PATCH 090/749] GH-36752: [Python] Remove AWS SDK bundling when
 building wheels (#36925)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

In https://github.com/apache/arrow/pull/12227 we decided to use a bundled version of the AWS SDK when compiling Python wheels, in order to downgrade the AWS SDK version.

Now that we have fixed S3 finalization issues (https://github.com/apache/arrow/pull/36442), it should be ok to rely on the vcpkg-installed version of the AWS SDK again.

### What changes are included in this PR?

Remove use of bundled AWS SDK and use S3 vcpkg feature for requirements.

### Are these changes tested?

On CI and via crossbow

### Are there any user-facing changes?

No
* Closes: #36752

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .env                                             | 2 +-
 ci/docker/python-wheel-manylinux.dockerfile      | 3 ++-
 ci/docker/python-wheel-windows-vs2017.dockerfile | 3 ++-
 ci/scripts/java_jni_macos_build.sh               | 1 -
 ci/scripts/python_wheel_manylinux_build.sh       | 4 ----
 ci/scripts/python_wheel_windows_build.bat        | 4 ----
 6 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/.env b/.env
index 25b2743f6542f..c9cd6c8094ed8 100644
--- a/.env
+++ b/.env
@@ -98,7 +98,7 @@ VCPKG="501db0f17ef6df184fcdbfbe0f87cde2313b6ab1"    # 2023.04.15 Release
 # ci/docker/python-wheel-windows-vs2017.dockerfile.
 # This is a workaround for our CI problem that "archery docker build" doesn't
 # use pulled built images in dev/tasks/python-wheels/github.windows.yml.
-PYTHON_WHEEL_WINDOWS_IMAGE_REVISION=2022-06-12
+PYTHON_WHEEL_WINDOWS_IMAGE_REVISION=2023-08-02
 
 # Use conanio/${CONAN} for "docker-compose run --rm conan". See
 # https://github.com/conan-io/conan-docker-tools#readme for available
diff --git a/ci/docker/python-wheel-manylinux.dockerfile b/ci/docker/python-wheel-manylinux.dockerfile
index ed329ecdef6de..0f7779c878505 100644
--- a/ci/docker/python-wheel-manylinux.dockerfile
+++ b/ci/docker/python-wheel-manylinux.dockerfile
@@ -84,7 +84,8 @@ RUN vcpkg install \
         --x-feature=flight \
         --x-feature=gcs \
         --x-feature=json \
-        --x-feature=parquet
+        --x-feature=parquet \
+        --x-feature=s3
 
 # Configure Python for applications running in the bash shell of this Dockerfile
 ARG python=3.8
diff --git a/ci/docker/python-wheel-windows-vs2017.dockerfile b/ci/docker/python-wheel-windows-vs2017.dockerfile
index 01152dae232d8..531c4e678fafe 100644
--- a/ci/docker/python-wheel-windows-vs2017.dockerfile
+++ b/ci/docker/python-wheel-windows-vs2017.dockerfile
@@ -66,7 +66,8 @@ RUN vcpkg install \
         --x-feature=flight \
         --x-feature=gcs \
         --x-feature=json \
-        --x-feature=parquet
+        --x-feature=parquet \
+        --x-feature=s3
 
 # Remove previous installations of python from the base image
 # NOTE: a more recent base image (tried with 2.12.1) comes with python 3.9.7
diff --git a/ci/scripts/java_jni_macos_build.sh b/ci/scripts/java_jni_macos_build.sh
index 4a6f9444ec25f..d66c39a37c5bd 100755
--- a/ci/scripts/java_jni_macos_build.sh
+++ b/ci/scripts/java_jni_macos_build.sh
@@ -81,7 +81,6 @@ cmake \
   -DARROW_PARQUET=${ARROW_PARQUET} \
   -DARROW_S3=${ARROW_S3} \
   -DARROW_USE_CCACHE=${ARROW_USE_CCACHE} \
-  -DAWSSDK_SOURCE=BUNDLED \
   -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
   -DCMAKE_INSTALL_LIBDIR=lib \
   -DCMAKE_INSTALL_PREFIX=${install_dir} \
diff --git a/ci/scripts/python_wheel_manylinux_build.sh b/ci/scripts/python_wheel_manylinux_build.sh
index cb5c2fbb7cc62..58e42fea88088 100755
--- a/ci/scripts/python_wheel_manylinux_build.sh
+++ b/ci/scripts/python_wheel_manylinux_build.sh
@@ -85,9 +85,6 @@ fi
 mkdir /tmp/arrow-build
 pushd /tmp/arrow-build
 
-# ARROW-17501: We can remove -DAWSSDK_SOURCE=BUNDLED once
-# https://github.com/aws/aws-sdk-cpp/issues/1809 is fixed and vcpkg
-# ships the fix.
 cmake \
     -DARROW_ACERO=${ARROW_ACERO} \
     -DARROW_BUILD_SHARED=ON \
@@ -120,7 +117,6 @@ cmake \
     -DARROW_WITH_SNAPPY=${ARROW_WITH_SNAPPY} \
     -DARROW_WITH_ZLIB=${ARROW_WITH_ZLIB} \
     -DARROW_WITH_ZSTD=${ARROW_WITH_ZSTD} \
-    -DAWSSDK_SOURCE=BUNDLED \
     -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
     -DCMAKE_INSTALL_LIBDIR=lib \
     -DCMAKE_INSTALL_PREFIX=/tmp/arrow-dist \
diff --git a/ci/scripts/python_wheel_windows_build.bat b/ci/scripts/python_wheel_windows_build.bat
index ee879c7050dad..ffb43b3481e55 100644
--- a/ci/scripts/python_wheel_windows_build.bat
+++ b/ci/scripts/python_wheel_windows_build.bat
@@ -49,9 +49,6 @@ set ARROW_WITH_LZ4=ON
 set ARROW_WITH_SNAPPY=ON
 set ARROW_WITH_ZLIB=ON
 set ARROW_WITH_ZSTD=ON
-@rem Workaround for https://github.com/aws/aws-sdk-cpp/issues/1809 .
-@rem Use (old) bundled AWS SDK C++ instead of (newer) AWS SDK C++.
-set AWSSDK_SOURCE=BUNDLED
 set CMAKE_UNITY_BUILD=ON
 set CMAKE_GENERATOR=Visual Studio 15 2017 Win64
 set VCPKG_ROOT=C:\vcpkg
@@ -90,7 +87,6 @@ cmake ^
     -DARROW_WITH_SNAPPY=%ARROW_WITH_SNAPPY% ^
     -DARROW_WITH_ZLIB=%ARROW_WITH_ZLIB% ^
     -DARROW_WITH_ZSTD=%ARROW_WITH_ZSTD% ^
-    -DAWSSDK_SOURCE=%AWSSDK_SOURCE% ^
     -DCMAKE_BUILD_TYPE=%CMAKE_BUILD_TYPE% ^
     -DCMAKE_CXX_COMPILER=clcache ^
     -DCMAKE_INSTALL_PREFIX=C:\arrow-dist ^

From fefd96d4f8917a59f1f72c8e0d9f73583b82bf43 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Fri, 4 Aug 2023 14:02:00 -0400
Subject: [PATCH 091/749] GH-36961: [MATLAB] Add `arrow.tabular.Schema` class
 and associated `arrow.schema` construction function (#37013)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

To continue building out the tabular APIs for the MATLAB interface, this PR adds a new `arrow.tabular.Schema` class which wraps one or more `arrow.type.Field` objects and semantically describes the names and types of the columns of a tabular Arrow data structure.

To construct an `arrow.tabular.Schema` object, client code can call an associated `arrow.schema` construction function (similar to the `arrow.field` construction function).

This mirrors the tabular APIs in other Arrow bindings, like `pyarrow`.

### What changes are included in this PR?

1. New `arrow.tabular.Schema` class.
2. New `arrow.schema(fields)` construction function for creating instances of `arrow.tabular.Schema`.

**Example**:

```matlab
>> fieldA = arrow.field("A", arrow.uint8);
>> fieldB = arrow.field("B", arrow.string);
>> fieldC = arrow.field("C", arrow.timestamp);

>> fields = [fieldA, fieldB, fieldC];

>> schema = arrow.schema(fields)

schema =

A: uint8
B: string
C: timestamp[us]

>> schema.NumFields

ans =

  int32

   3

>> schema.FieldNames

ans =

  1×3 string array

    "A"    "B"    "C"

>> f = schema.field(3)

f =

C: timestamp[us]

>> f = schema.field("B")

f =

B: string
```

### Are these changes tested?

Yes.

1. Added a new test class `tSchema.m` which contains tests for `arrow.schema` and `arrow.tabular.Schema`.

### Are there any user-facing changes?

Yes.

1. New public `arrow.tabular.Schema` class.
    1.1 **Properties**
                1.1.1 `NumFields`
        1.1.2 `FieldNames`
        1.1.3 `Fields`
    1.2 **Methods**
        1.2.1 `field(index)` where index is a valid numeric index or field name.
2. New public `arrow.schema(fields)` construction function.

### Future Directions

1. @ sgilmore10 introduced some new input validation functions that are generic and reusable in #36978. To avoid using multiple different approaches to input validation across the MATLAB code base, it would be a good idea to re-implement the input validation for `Schema` methods (e.g. `field`) to use these validation functions consistently.
4. Error handling in some edge cases is less than ideal right now for `Schema`. We should consider doing a more thorough review of error handling and error messages across the MATLAB code base now that we have more APIs and have seen several similar error states appear in different parts of the code base (e.g. indexing errors).
5. We may want to consider alternative construction syntaxes beyond just `arrow.schema(fields)`. For example, `arrow.schema(fieldName_1, fieldType_1, ..., fieldName_i, fieldType_i, ... fieldName_n, fieldType_n)` might be another convenient syntax that we could consider supporting.
6. We should add a `Schema` property to `RecordBatch`.
7. Consider adding a `toMATLAB` method for `Schema` which returns an empty MATLAB `table` with corresponding variable names and MATLAB types.
* Closes: #36961

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Kevin Gurney <kevin.p.gurney@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |   4 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../cpp/arrow/matlab/tabular/proxy/schema.cc  | 184 +++++++
 .../cpp/arrow/matlab/tabular/proxy/schema.h   |  47 ++
 matlab/src/matlab/+arrow/+tabular/Schema.m    |  96 ++++
 matlab/src/matlab/+arrow/schema.m             |  34 ++
 matlab/test/arrow/tabular/tSchema.m           | 473 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 8 files changed, 841 insertions(+)
 create mode 100644 matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
 create mode 100644 matlab/src/matlab/+arrow/+tabular/Schema.m
 create mode 100644 matlab/src/matlab/+arrow/schema.m
 create mode 100644 matlab/test/arrow/tabular/tSchema.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 3d134d169e7af..590cccfb9d6bf 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -173,4 +173,8 @@ namespace arrow::matlab::error {
     static const char* UKNOWN_TIME_UNIT_ERROR_ID = "arrow:matlab:UnknownTimeUnit";
     static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
     static const char* ARRAY_FAILED_TO_CREATE_TYPE_PROXY = "arrow:array:FailedToCreateTypeProxy";
+    static const char* ARROW_TABULAR_SCHEMA_INVALID_NUMERIC_FIELD_INDEX = "arrow:tabular:schema:InvalidNumericFieldIndex";
+    static const char* ARROW_TABULAR_SCHEMA_UNKNOWN_FIELD_NAME = "arrow:tabular:schema:UnknownFieldName";
+    static const char* ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME = "arrow:tabular:schema:AmbiguousFieldName";
+    static const char* ARROW_TABULAR_SCHEMA_NUMERIC_FIELD_INDEX_WITH_EMPTY_SCHEMA = "arrow:tabular:schema:NumericFieldIndexWithEmptySchema";
 }
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index ac9a595a45852..7d18c6c6b62a8 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -19,6 +19,7 @@
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
+#include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/string_type.h"
@@ -44,6 +45,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
+    REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
     REGISTER_PROXY(arrow.type.proxy.Float32Type    , arrow::matlab::type::proxy::PrimitiveCType<float>);
     REGISTER_PROXY(arrow.type.proxy.Float64Type    , arrow::matlab::type::proxy::PrimitiveCType<double>);
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
new file mode 100644
index 0000000000000..62fe863ca8b5f
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
@@ -0,0 +1,184 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/tabular/proxy/schema.h"
+#include "arrow/matlab/type/proxy/field.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+#include "libmexclass/error/Error.h"
+
+#include "arrow/util/utf8.h"
+
+#include <sstream>
+
+namespace arrow::matlab::tabular::proxy {
+
+    namespace {
+
+        libmexclass::error::Error makeUnknownFieldNameError(const std::string& name) {
+            using namespace libmexclass::error;
+            std::stringstream error_message_stream;
+            error_message_stream << "Unknown field name: '";
+            error_message_stream << name;
+            error_message_stream << "'.";
+            return Error{error::ARROW_TABULAR_SCHEMA_UNKNOWN_FIELD_NAME, error_message_stream.str()};
+        }
+
+        libmexclass::error::Error makeEmptySchemaError() {
+            using namespace libmexclass::error;
+            return Error{error::ARROW_TABULAR_SCHEMA_NUMERIC_FIELD_INDEX_WITH_EMPTY_SCHEMA,
+                         "Numeric indexing using the field method is not supported for schemas with no fields."};
+        }
+
+    }
+
+    Schema::Schema(std::shared_ptr<arrow::Schema> schema) : schema{std::move(schema)} {
+        REGISTER_METHOD(Schema, getFieldByIndex);
+        REGISTER_METHOD(Schema, getFieldByName);
+        REGISTER_METHOD(Schema, getNumFields);
+        REGISTER_METHOD(Schema, getFieldNames);
+        REGISTER_METHOD(Schema, toString);
+    }
+
+    libmexclass::proxy::MakeResult Schema::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using SchemaProxy = arrow::matlab::tabular::proxy::Schema;
+
+        mda::StructArray args = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> field_proxy_ids_mda = args[0]["FieldProxyIDs"];
+
+        std::vector<std::shared_ptr<arrow::Field>> fields;
+        for (const auto proxy_id : field_proxy_ids_mda) {
+            using namespace libmexclass::proxy;
+            auto proxy = std::static_pointer_cast<arrow::matlab::type::proxy::Field>(ProxyManager::getProxy(proxy_id));
+            auto field = proxy->unwrap();
+            fields.push_back(field);
+        }
+        auto schema = arrow::schema(fields);
+        return std::make_shared<SchemaProxy>(std::move(schema));
+    }
+
+    std::shared_ptr<arrow::Schema> Schema::unwrap() {
+        return schema;
+    }
+
+    void Schema::getFieldByIndex(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using FieldProxy = arrow::matlab::type::proxy::Field;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::Schema::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
+        const auto num_fields = schema->num_fields();
+
+        if (num_fields == 0) {
+            const auto& error = makeEmptySchemaError();
+            context.error = error;
+            return;
+        }
+
+        if (matlab_index < 1 || matlab_index > num_fields) {
+            using namespace libmexclass::error;
+            const std::string& error_message_id = std::string{error::ARROW_TABULAR_SCHEMA_INVALID_NUMERIC_FIELD_INDEX};
+            std::stringstream error_message_stream;
+            error_message_stream << "Invalid field index: ";
+            error_message_stream << matlab_index;
+            error_message_stream << ". Field index must be between 1 and the number of fields (";
+            error_message_stream << num_fields;
+            error_message_stream << ").";
+            const std::string& error_message = error_message_stream.str();
+            context.error = Error{error_message_id, error_message}; 
+            return;
+        }
+
+        const auto& field = schema->field(index);
+        auto field_proxy = std::make_shared<FieldProxy>(field);
+        const auto field_proxy_id = ProxyManager::manageProxy(field_proxy);
+        const auto field_proxy_id_mda = factory.createScalar(field_proxy_id);
+
+        context.outputs[0] = field_proxy_id_mda;
+    }
+
+    void Schema::getFieldByName(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using FieldProxy = arrow::matlab::type::proxy::Field;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::StringArray name_mda = args[0]["Name"];
+        const auto name_utf16 = std::u16string(name_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto name, arrow::util::UTF16StringToUTF8(name_utf16), context, error::UNICODE_CONVERSION_ERROR_ID);
+        const std::vector<std::string> names = {name};
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(schema->CanReferenceFieldsByNames(names), context, error::ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME);
+
+        const auto field = schema->GetFieldByName(name);
+        auto field_proxy = std::make_shared<FieldProxy>(field);
+        const auto field_proxy_id = ProxyManager::manageProxy(field_proxy);
+        const auto field_proxy_id_mda = factory.createScalar(field_proxy_id);
+
+        context.outputs[0] = field_proxy_id_mda;
+    }
+
+    void Schema::getNumFields(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto num_fields = schema->num_fields();
+        const auto num_fields_mda = factory.createScalar(num_fields);
+
+        context.outputs[0] = num_fields_mda;
+    }
+
+    void Schema::getFieldNames(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto field_names_utf8 = schema->field_names();
+        const auto num_fields = static_cast<size_t>(schema->num_fields());
+
+        std::vector<std::u16string> field_names_utf16;
+        field_names_utf16.reserve(num_fields);
+
+        // Conver the field names from UTF-8 to UTF-16.
+        for (const auto& field_name_utf8 : field_names_utf8) {
+            MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto field_name_utf16, arrow::util::UTF8StringToUTF16(field_name_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
+            field_names_utf16.push_back(field_name_utf16);
+        }
+
+        const auto field_names_mda = factory.createArray({1, num_fields}, field_names_utf16.cbegin(), field_names_utf16.cend());
+
+        context.outputs[0] = field_names_mda;
+    }
+
+    void Schema::toString(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto str_utf8 = schema->ToString();
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
+        auto str_mda = factory.createScalar(str_utf16);
+        context.outputs[0] = str_mda;
+    }
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
new file mode 100644
index 0000000000000..30883bc2a85ac
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+// arrow::Schema is defined in type.h.
+#include "arrow/type.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::tabular::proxy {
+
+    class Schema : public libmexclass::proxy::Proxy {
+        public:
+            Schema(std::shared_ptr<arrow::Schema> Schema);
+
+            virtual ~Schema() {}
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+            std::shared_ptr<arrow::Schema> unwrap();
+
+        protected:
+            void getFieldByIndex(libmexclass::proxy::method::Context& context);
+            void getFieldByName(libmexclass::proxy::method::Context& context);
+            void getNumFields(libmexclass::proxy::method::Context& context);
+            void getFieldNames(libmexclass::proxy::method::Context& context);
+            void toString(libmexclass::proxy::method::Context& context);
+
+            std::shared_ptr<arrow::Schema> schema;
+    };
+
+}
diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
new file mode 100644
index 0000000000000..3d75e6c44a2df
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -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.
+
+classdef Schema < matlab.mixin.CustomDisplay
+%SCHEMA A tabular schema which semantically describes
+% the names and types of the columns of an associated tabular
+% Arrow data type.
+
+    properties (GetAccess=public, SetAccess=private, Hidden)
+        Proxy
+    end
+
+    properties (Dependent, SetAccess=private, GetAccess=public)
+        % Underlying array of Fields that the Schema wraps.
+        Fields
+        % Names of the columns in the associated tabular type.
+        FieldNames
+        % Number of fields in the schema
+        NumFields
+    end
+
+    methods
+
+        function obj = Schema(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.tabular.proxy.Schema")}
+            end
+            import arrow.internal.proxy.validate
+
+            obj.Proxy = proxy;
+        end
+        
+        function F = field(obj, idx)
+            idx = convertCharsToStrings(idx);
+            if ~isempty(idx) && isscalar(idx) && isnumeric(idx) && idx >= 1
+                args = struct(Index=int32(idx));
+                proxyID = obj.Proxy.getFieldByIndex(args);
+            elseif isscalar(idx) && isstring(idx)
+                name = idx;
+                args = struct(Name=name);
+                proxyID = obj.Proxy.getFieldByName(args);
+            else
+                error("arrow:tabular:schema:UnsupportedFieldIndexType", ...
+                      "Index must be a positive scalar integer or a valid field name.");
+            end
+
+            proxy = libmexclass.proxy.Proxy(Name="arrow.type.proxy.Field", ID=proxyID);
+            F = arrow.type.Field(proxy);
+        end
+
+        function fields = get.Fields(obj)
+            fields = arrow.type.Field.empty(0, obj.NumFields);
+            for ii = 1:obj.NumFields
+                fields(ii) = obj.field(ii);
+            end
+        end
+
+        function fieldNames = get.FieldNames(obj)
+            fieldNames = obj.Proxy.getFieldNames();
+        end
+
+        function numFields = get.NumFields(obj)
+            numFields = obj.Proxy.getNumFields();
+        end
+        
+    end
+
+    methods (Access = private)
+
+        function str = toString(obj)
+            str = obj.Proxy.toString();
+        end
+
+    end
+
+    methods (Access=protected)
+
+        function displayScalarObject(obj)
+            disp(obj.toString());
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/schema.m b/matlab/src/matlab/+arrow/schema.m
new file mode 100644
index 0000000000000..b61fcabe69f28
--- /dev/null
+++ b/matlab/src/matlab/+arrow/schema.m
@@ -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.
+
+function s = schema(fields)
+%SCHEMA Constructs an arrow.tabular.Schema object
+    arguments
+        fields(1, :) arrow.type.Field
+    end
+
+    % Extract the corresponding Proxy IDs from each of the
+    % supplied arrow.type.Field objects.
+    numFields = numel(fields);
+    fieldProxyIDs = zeros(1, numFields, "uint64");
+    for ii = 1:numFields
+        fieldProxyIDs(ii) = fields(ii).Proxy.ID;
+    end
+
+    % Construct an Arrow Schema Proxy in C++ from the supplied Field Proxy IDs.
+    args = struct(FieldProxyIDs=fieldProxyIDs);
+    proxy = arrow.internal.proxy.create("arrow.tabular.proxy.Schema", args);
+    s = arrow.tabular.Schema(proxy);
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
new file mode 100644
index 0000000000000..d550c488fd86d
--- /dev/null
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -0,0 +1,473 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tSchema < matlab.unittest.TestCase
+% Tests for the arrow.tabular.Schema class and the associated arrow.schema
+% construction function.
+
+    methods(Test)
+
+        function ErrorIfUnsupportedInputType(testCase)
+            % Verify that an error is thrown by arrow.schema if an
+            % unsupported input argument is supplied.
+            testCase.verifyError(@() arrow.schema("test"), "MATLAB:validation:UnableToConvert");
+        end
+
+        function ErrorIfUnsupportedConstructorInputs(testCase)
+            % Verify that an error is thrown by the constructor of
+            % arrow.tabular.Schema if unsupported arguments are passed to
+            % the constructor.
+            testCase.verifyError(@() arrow.tabular.Schema("test"), "MATLAB:validation:UnableToConvert");
+        end
+
+        function ErrorIfTooFewInputs(testCase)
+            % Verify that an error is thrown by arrow.schema if too few
+            % input arguments are supplied.
+            testCase.verifyError(@() arrow.schema(), "MATLAB:minrhs");
+        end
+
+        function ErrorIfTooManyInputs(testCase)
+            % Verify that an error is thrown by arrow.schema if too many
+            % input arguments are supplied.
+            testCase.verifyError(@() arrow.schema("a", "b", "c"), "MATLAB:TooManyInputs");
+        end
+
+        function ClassType(testCase)
+            % Verify that the class type of the object returned by a call
+            % to arrow.schema is "arrow.tabular.Schema".
+            schema = arrow.schema(arrow.field("A", arrow.uint8));
+            testCase.verifyInstanceOf(schema, "arrow.tabular.Schema");
+        end
+
+        function ConstructSchemaFromProxy(testCase)
+            % Verify that an arrow.tabular.Schema instance can be
+            % constructred directly from an existing
+            % arrow.tabular.proxy.Schema Proxy instance.
+            schema1 = arrow.schema(arrow.field("a", arrow.uint8));
+            % Construct an instance of arrow.tabular.Schema directly from a
+            % Proxy of type "arrow.tabular.proxy.Schema".
+            schema2 = arrow.tabular.Schema(schema1.Proxy);
+            testCase.verifyEqual(schema1.FieldNames, schema2.FieldNames);
+            testCase.verifyEqual(schema1.NumFields, schema2.NumFields);
+        end
+
+        function Fields(testCase)
+            % Verify that the Fields property returns an expected array of
+            % Field objects.
+            f1 = arrow.field("A", arrow.uint8);
+            f2 = arrow.field("B", arrow.uint16);
+            f3 = arrow.field("C", arrow.uint32);
+            expectedFields = [f1, f2, f3];
+            schema = arrow.schema(expectedFields);
+
+            actualFields = schema.Fields;
+
+            testCase.verifyEqual(actualFields(1).Name, expectedFields(1).Name);
+            testCase.verifyEqual(actualFields(1).Type.ID, expectedFields(1).Type.ID);
+            testCase.verifyEqual(actualFields(2).Name, expectedFields(2).Name);
+            testCase.verifyEqual(actualFields(2).Type.ID, expectedFields(2).Type.ID);
+            testCase.verifyEqual(actualFields(3).Name, expectedFields(3).Name);
+            testCase.verifyEqual(actualFields(3).Type.ID, expectedFields(3).Type.ID);
+        end
+
+        function FieldNames(testCase)
+            % Verify that the FieldNames property returns an expected
+            % string array of field names.
+            expectedFieldNames = ["A"        , "B"          , "C"];
+            schema = arrow.schema([...
+                arrow.field(expectedFieldNames(1), arrow.uint8), ...
+                arrow.field(expectedFieldNames(2), arrow.uint16), ...
+                arrow.field(expectedFieldNames(3), arrow.uint32) ...
+            ]);
+            actualFieldNames = schema.FieldNames;
+            testCase.verifyEqual(actualFieldNames, expectedFieldNames);
+        end
+
+        function FieldNamesNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the FieldNames property.
+            schema = arrow.schema(arrow.field("A", arrow.uint8));
+            testCase.verifyError(@() setfield(schema, "FieldNames", "B"), "MATLAB:class:SetProhibited");
+        end
+
+        function NumFieldsNoSetter(testCase)
+            % Verify than an error is thrown when trying to set the value
+            % of the NumFields property.
+            schema = arrow.schema(arrow.field("A", arrow.uint8));
+            testCase.verifyError(@() setfield(schema, "NumFields", 123), "MATLAB:class:SetProhibited");
+        end
+
+        function FieldsNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the Fields property.
+            schema = arrow.schema(arrow.field("A", arrow.uint8));
+            testCase.verifyError(@() setfield(schema, "Fields", arrow.field("B", arrow.uint8)), "MATLAB:class:SetProhibited");
+        end
+
+        function NumFields(testCase)
+            % Verify that the NumFields property returns an execpted number
+            % of fields.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+            expectedNumFields = int32(3);
+            actualNumFields = schema.NumFields;
+            testCase.verifyEqual(actualNumFields, expectedNumFields);
+        end
+
+        function ErrorIfUnsupportedFieldIndex(testCase)
+            % Verify that an error is thrown if an invalid field index is
+            % supplied to the field method (e.g. -1.1, NaN, {1}, etc.).
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            index = [];
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = 0;
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = -1;
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = -1.23;
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = NaN;
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = {1};
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            index = [1; 1];
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+        end
+
+        function GetFieldByIndex(testCase)
+            % Verify that Fields can be accessed using a numeric index.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            field = schema.field(1);
+            testCase.verifyEqual(field.Name, "A");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            field = schema.field(2);
+            testCase.verifyEqual(field.Name, "B");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
+
+            field = schema.field(3);
+            testCase.verifyEqual(field.Name, "C");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt32);
+        end
+
+        function GetFieldByName(testCase)
+            % Verify that Fields can be accessed using a field name.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            field = schema.field("A");
+            testCase.verifyEqual(field.Name, "A");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            field = schema.field("B");
+            testCase.verifyEqual(field.Name, "B");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
+
+            field = schema.field("C");
+            testCase.verifyEqual(field.Name, "C");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt32);
+        end
+
+        function GetFieldByNameWithEmptyString(testCase)
+            % Verify that a Field whose name is the empty string ("")
+            % can be accessed using the field() method.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            field = schema.field("");
+
+            testCase.verifyEqual(field.Name, "");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
+        end
+
+        function GetFieldByNameWithWhitespace(testCase)
+            % Verify that a Field whose name contains only whitespace
+            % characters can be accessed using the field() method.
+            schema = arrow.schema([...
+                arrow.field(" ", arrow.uint8), ...
+                arrow.field("  ", arrow.uint16), ...
+                arrow.field("   ", arrow.uint32) ...
+            ]);
+
+            field = schema.field(" ");
+            testCase.verifyEqual(field.Name, " ");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            field = schema.field("  ");
+            testCase.verifyEqual(field.Name, "  ");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
+
+            field = schema.field("   ");
+            testCase.verifyEqual(field.Name, "   ");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt32);
+        end
+
+        function ErrorIfInvalidNumericFieldIndex(testCase)
+            % Verify that an error is thrown when trying to access a field
+            % with an invalid numeric index (e.g. greater than NumFields).
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            % Index is greater than NumFields.
+            index = 100;
+            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:InvalidNumericFieldIndex");
+        end
+
+        function ErrorIfFieldNameDoesNotExist(testCase)
+            % Verify that an error is thrown when trying to access a field
+            % with a name that is not part of the schema.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32) ...
+            ]);
+
+            % Matching should be case sensitive.
+            fieldName = "a";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+
+            fieldName = "aA";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+
+            fieldName = "D";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+
+            fieldName = "";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+
+            fieldName = " ";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function ErrorIfAmbiguousFieldName(testCase)
+            % Verify that an error is thrown when trying to access a field
+            % with a name that is ambiguous / occurs more than once in the
+            % schema.
+            schema = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("A", arrow.uint16), ...
+                arrow.field("B", arrow.uint32), ...
+                arrow.field("B", arrow.uint32)
+            ]);
+
+            fieldName = "A";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+
+            fieldName = "B";
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function SupportedFieldTypes(testCase)
+            % Verify that a Schema can be created from Fields with any
+            % supported Type.
+            fields = [ ...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32), ...
+                arrow.field("D", arrow.uint64), ...
+                arrow.field("E", arrow.int8), ...
+                arrow.field("F", arrow.int16), ...
+                arrow.field("G", arrow.int32), ...
+                arrow.field("H", arrow.int64), ...
+                arrow.field("I", arrow.float32), ...
+                arrow.field("J", arrow.float64), ...
+                arrow.field("K", arrow.boolean), ...
+                arrow.field("L", arrow.string), ...
+                arrow.field("M", arrow.timestamp), ...
+            ];
+
+            schema = arrow.schema(fields);
+
+            testCase.verifyEqual(schema.field("A").Type.ID, arrow.type.ID.UInt8);
+            testCase.verifyEqual(schema.field("B").Type.ID, arrow.type.ID.UInt16);
+            testCase.verifyEqual(schema.field("C").Type.ID, arrow.type.ID.UInt32);
+            testCase.verifyEqual(schema.field("D").Type.ID, arrow.type.ID.UInt64);
+            testCase.verifyEqual(schema.field("E").Type.ID, arrow.type.ID.Int8);
+            testCase.verifyEqual(schema.field("F").Type.ID, arrow.type.ID.Int16);
+            testCase.verifyEqual(schema.field("G").Type.ID, arrow.type.ID.Int32);
+            testCase.verifyEqual(schema.field("H").Type.ID, arrow.type.ID.Int64);
+            testCase.verifyEqual(schema.field("I").Type.ID, arrow.type.ID.Float32);
+            testCase.verifyEqual(schema.field("J").Type.ID, arrow.type.ID.Float64);
+            testCase.verifyEqual(schema.field("K").Type.ID, arrow.type.ID.Boolean);
+            testCase.verifyEqual(schema.field("L").Type.ID, arrow.type.ID.String);
+            testCase.verifyEqual(schema.field("M").Type.ID, arrow.type.ID.Timestamp);
+        end
+
+        function UnicodeFieldNames(testCase)
+            % Verify that Field names containing Unicode characters are 
+            % preserved with the FieldNames property.
+            smiley = "😀";
+            tree =  "🌲";
+            mango = "🥭";
+            expectedFieldNames = [smiley, tree, mango];
+
+            f1 = arrow.field(expectedFieldNames(1), arrow.uint8);
+            f2 = arrow.field(expectedFieldNames(2), arrow.uint16);
+            f3 = arrow.field(expectedFieldNames(3), arrow.uint32);
+            fields = [f1, f2, f3];
+
+            schema = arrow.schema(fields);
+
+            actualFieldNames = schema.FieldNames;
+
+            testCase.verifyEqual(actualFieldNames, expectedFieldNames);
+        end
+
+        function EmptyFieldNames(testCase)
+            % Verify that Field names which are the empty string are 
+            % preserved with the FieldNames property.
+            expectedFieldNames = ["", "B", "C"];
+            schema = arrow.schema([...
+                arrow.field("", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("C", arrow.uint32)
+            ]);
+            actualFieldNames = schema.FieldNames;
+            testCase.verifyEqual(actualFieldNames, expectedFieldNames);
+        end
+
+        function EmptySchema(testCase)
+            % Verify that a Schema with no Fields can be created.
+
+            % 0x0 empty Field array.
+            fields = arrow.type.Field.empty(0, 0);
+            schema = arrow.schema(fields);
+            testCase.verifyEqual(schema.NumFields, int32(0));
+            testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
+            testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
+            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+
+            % 0x1 empty Field array.
+            fields = arrow.type.Field.empty(0, 1);
+            schema = arrow.schema(fields);
+            testCase.verifyEqual(schema.NumFields, int32(0));
+            testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
+            testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
+            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+
+            % 1x0 empty Field array.
+            fields = arrow.type.Field.empty(1, 0);
+            schema = arrow.schema(fields);
+            testCase.verifyEqual(schema.NumFields, int32(0));
+            testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
+            testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
+            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+        end
+
+        function GetFieldByNameWithChar(testCase)
+            % Verify that the field method works when supplied a char
+            % vector as input.
+            schema = arrow.schema([...
+                arrow.field("", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+
+            % Should match the first field whose name is the
+            % empty string ("").
+            fieldName = char.empty(0, 0);
+            field = schema.field(fieldName);
+            testCase.verifyEqual(field.Name, "");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            fieldName = char.empty(0, 1);
+            field = schema.field(fieldName);
+            testCase.verifyEqual(field.Name, "");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            fieldName = char.empty(1, 0);
+            field = schema.field(fieldName);
+            testCase.verifyEqual(field.Name, "");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt8);
+
+            % Should match the second field whose name is "B".
+            fieldName = 'B';
+            field = schema.field(fieldName);
+            testCase.verifyEqual(field.Name, "B");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
+
+            % Should match the second field whose name is "123".
+            fieldName = '123';
+            field = schema.field(fieldName);
+            testCase.verifyEqual(field.Name, "123");
+            testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt32);
+        end
+
+        function ErrorIfNumericIndexIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar numeric index
+            % is supplied to the field method.
+            schema = arrow.schema([...
+                arrow.field("", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+
+            fieldName = [1, 2, 3];
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            fieldName = [1; 2; 3];
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+        end
+
+        function ErrorIfFieldNameIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar string array is
+            % specified as a field name to the field method.
+            schema = arrow.schema([...
+                arrow.field("", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+
+            fieldName = ["A", "B", "C"];
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+
+            fieldName = ["A";  "B"; "C"];
+            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+        end
+
+    end
+
+end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 530799c15c172..a316a27e55d2b 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -45,6 +45,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/boolean_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/pack.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/unpack.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/time_unit.cc"

From 6dc6af48cc92640fabdc3662f2b87193c4cb6fe2 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 4 Aug 2023 14:44:15 -0400
Subject: [PATCH 092/749] GH-37012:  [MATLAB] Remove the private property
 `ArrowArrays` from `arrow.tabular.RecordBatch` (#37015)

### Rationale for this change

In our initial implementation of the MATLAB class `arrow.tabular.RecordBatch`, we included a property property called `ArrowArrays`, which is a `cell` array whose elements are scalar `arrow.array.Array` objects.  These arrays correspond to the columns in the `arrow::RecordBatch` that the MATLAB class wraps.  The purpose of `ArrowArrays` was to enable  zero-copy construction of the `arrow::Array` objects backing the `arrow::RecordBatch` from MATLAB arrays. The `ArrowArrays` property was necessary to ensure the MATLAB data from which the `arrow::Array` columns were constructed don't get deallocated before they are done being used.

However, we no longer need the `ArrowArrays` property on `arrow.tabular.RecordBatch` because of #36615, in which we implemented `arrow::matlab::buffer::MatlabBuffer`. This class inherits from `arrow::Buffer` and  stores a reference to the MATLAB data it wraps, ensuring that the wrapped MATLAB data is kept alive as long as the buffer is around.

We now only create `arrow::Array` objects from `arrow::matlab::buffer::MatlabBuffer` objects - instead of `arrow::Buffer` objects. As a result, the `ArrowArrays` property is no longer necessary on `arrow.tabular.RecordBatch` because the `arrow::Array` columns within the `arrow::RecordBatch` are all backed by `arrow::matlab::buffer::MatlabBuffer` objects. The backing MATLAB data is kept alive as long as the arrays and their buffers are kept alive.

### What changes are included in this PR?

1. Removed the `ArrowArrays` property from `arrow.tabular.RecordBatch`.
2. Because `ArrowArrays` is no longer a property, we had to add a new method to `arrow::matlab::tabular::proxy::RecordBatch` called `getColumnByIndex()`. This method creates a proxy object around the specified `arrrow::Array`. The MATLAB method `RecordBatch/column(index)` uses `getColumnByIndex()`.
3. Added a new function called `wrap`, which accepts an `arrow::Array` and returns an `arrow::matlab::array::proxy::Array`. While working on `getColumnByIndex()`, we realized there would be multiple places in the interface where we will need to create proxies around `arrow::Array` objects. We wrote the `wrap` utility function to reduce duplicated code in the future. Currently, only `getColumnByIndex()` utilizes `wrap`.

### Are these changes tested?

Yes.

1. The existing unit tests in `tRecordBatch.m` cover these changes.
2. Added a few more test cases to `tRecordBatch.m` to cover error conditions when a bad `index` value is provided to `arrow.tabular.RecordBatch/column(index)`.

### Are there any user-facing changes?

No.

### Future Directions

1. In a followup PR, we will add support for indexing columns by names (similar to `Schema.field(fieldName)` - #37013).
2. We also plan on adding an index validation function within the `arrow.internal.validate` package.
3. We also plan on adding a convenience constructor `arrow.recordbatch()` and changing the constructor of `arrow.tabular.RecordBatch` to expect a `libmexclass.proxy.Proxy` object.

* Closes: #37012

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/array/proxy/numeric_array.h  |  2 +-
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  | 60 ++++++++++++++++++
 .../src/cpp/arrow/matlab/array/proxy/wrap.h   | 29 +++++++++
 matlab/src/cpp/arrow/matlab/error/error.h     |  3 +
 .../matlab/tabular/proxy/record_batch.cc      | 63 +++++++++++++++++++
 .../arrow/matlab/tabular/proxy/record_batch.h |  3 +-
 matlab/src/cpp/arrow/matlab/type/proxy/wrap.h |  2 +
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 28 ++++++---
 matlab/test/arrow/tabular/tRecordBatch.m      | 23 ++++++-
 .../cmake/BuildMatlabArrowInterface.cmake     |  1 +
 10 files changed, 201 insertions(+), 13 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/wrap.h

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index 6893079c78b95..6bfdad1f5db55 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -89,7 +89,7 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
 
      // Specialization of NumericArray::Make for arrow::TimestampType.
     template <>
-    libmexclass::proxy::MakeResult NumericArray<arrow::TimestampType>::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+    inline libmexclass::proxy::MakeResult NumericArray<arrow::TimestampType>::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
         namespace mda = ::matlab::data;
         using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
         using TimestampArray = arrow::TimestampArray;
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
new file mode 100644
index 0000000000000..dab09359598d4
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -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.
+
+
+#include "arrow/matlab/array/proxy/wrap.h"
+#include "arrow/matlab/array/proxy/array.h"
+#include "arrow/matlab/array/proxy/boolean_array.h"
+#include "arrow/matlab/array/proxy/numeric_array.h"
+#include "arrow/matlab/array/proxy/string_array.h"
+
+namespace arrow::matlab::array::proxy {
+
+    arrow::Result<std::shared_ptr<proxy::Array>> wrap(const std::shared_ptr<arrow::Array>& array) {
+        using ID = arrow::Type::type;
+        switch (array->type_id()) {
+            case ID::BOOL:
+                return std::make_shared<proxy::BooleanArray>(std::static_pointer_cast<arrow::BooleanArray>(array));
+            case ID::UINT8:
+                return std::make_shared<proxy::NumericArray<arrow::UInt8Type>>(std::static_pointer_cast<arrow::UInt8Array>(array));
+            case ID::UINT16:
+                return std::make_shared<proxy::NumericArray<arrow::UInt16Type>>(std::static_pointer_cast<arrow::UInt16Array>(array));
+            case ID::UINT32:
+                return std::make_shared<proxy::NumericArray<arrow::UInt32Type>>(std::static_pointer_cast<arrow::UInt32Array>(array));
+            case ID::UINT64:
+                return std::make_shared<proxy::NumericArray<arrow::UInt64Type>>(std::static_pointer_cast<arrow::UInt64Array>(array));
+            case ID::INT8:
+                return std::make_shared<proxy::NumericArray<arrow::Int8Type>>(std::static_pointer_cast<arrow::Int8Array>(array));
+            case ID::INT16:
+                return std::make_shared<proxy::NumericArray<arrow::Int16Type>>(std::static_pointer_cast<arrow::Int16Array>(array));
+            case ID::INT32:
+                return std::make_shared<proxy::NumericArray<arrow::Int32Type>>(std::static_pointer_cast<arrow::Int32Array>(array));
+            case ID::INT64:
+                return std::make_shared<proxy::NumericArray<arrow::Int64Type>>(std::static_pointer_cast<arrow::Int64Array>(array));
+            case ID::FLOAT:
+                return std::make_shared<proxy::NumericArray<arrow::FloatType>>(std::static_pointer_cast<arrow::FloatArray>(array));
+            case ID::DOUBLE:
+                return std::make_shared<proxy::NumericArray<arrow::DoubleType>>(std::static_pointer_cast<arrow::DoubleArray>(array));
+            case ID::TIMESTAMP:
+                return std::make_shared<proxy::NumericArray<arrow::TimestampType>>(std::static_pointer_cast<arrow::TimestampArray>(array));
+            case ID::STRING:
+                return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
+            default:
+                return arrow::Status::NotImplemented("Unsupported DataType: " + array->type()->ToString());
+        }
+    }
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.h b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.h
new file mode 100644
index 0000000000000..5ccb498f7689a
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.h
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/array.h"
+#include "arrow/result.h"
+
+#include "arrow/matlab/array/proxy/array.h"
+
+namespace arrow::matlab::array::proxy {
+
+    arrow::Result<std::shared_ptr<proxy::Array>> wrap(const std::shared_ptr<arrow::Array>& array);
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 590cccfb9d6bf..b7c0d7d696d65 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -177,4 +177,7 @@ namespace arrow::matlab::error {
     static const char* ARROW_TABULAR_SCHEMA_UNKNOWN_FIELD_NAME = "arrow:tabular:schema:UnknownFieldName";
     static const char* ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME = "arrow:tabular:schema:AmbiguousFieldName";
     static const char* ARROW_TABULAR_SCHEMA_NUMERIC_FIELD_INDEX_WITH_EMPTY_SCHEMA = "arrow:tabular:schema:NumericFieldIndexWithEmptySchema";
+    static const char* UNKNOWN_PROXY_FOR_ARRAY_TYPE = "arrow:array:UnknownProxyForArrayType";
+    static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
+    static const char* RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:recordbatch:InvalidNumericColumnIndex";
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index c0b73833e5a0f..ed30472f6c4a2 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -18,17 +18,42 @@
 #include "libmexclass/proxy/ProxyManager.h"
 
 #include "arrow/matlab/array/proxy/array.h"
+#include "arrow/matlab/array/proxy/wrap.h"
+
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/type.h"
 #include "arrow/util/utf8.h"
 
+#include "libmexclass/proxy/ProxyManager.h"
+#include "libmexclass/error/Error.h"
+
+#include <sstream>
+
 namespace arrow::matlab::tabular::proxy {
 
+    namespace {
+        libmexclass::error::Error makeEmptyRecordBatchError() {
+            const std::string error_msg =  "Numeric indexing using the column method is not supported for record batches with no columns.";
+            return libmexclass::error::Error{error::RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH, error_msg};
+        }
+
+        libmexclass::error::Error makeInvalidNumericIndexError(const int32_t matlab_index, const int32_t num_columns) {
+            std::stringstream error_message_stream;
+            error_message_stream << "Invalid column index: ";
+            error_message_stream << matlab_index;
+            error_message_stream << ". Column index must be between 1 and the number of columns (";
+            error_message_stream << num_columns;
+            error_message_stream << ").";
+            return libmexclass::error::Error{error::RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX, error_message_stream.str()};
+        }
+    }
+
     RecordBatch::RecordBatch(std::shared_ptr<arrow::RecordBatch> record_batch) : record_batch{record_batch} {
         REGISTER_METHOD(RecordBatch, toString);
         REGISTER_METHOD(RecordBatch, numColumns);
         REGISTER_METHOD(RecordBatch, columnNames);
+        REGISTER_METHOD(RecordBatch, getColumnByIndex);
     }
 
     void RecordBatch::toString(libmexclass::proxy::method::Context& context) {
@@ -96,4 +121,42 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = column_names_mda;
     }
 
+    void RecordBatch::getColumnByIndex(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+        
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::Schema::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
+        const auto num_columns = record_batch->num_columns();
+        
+        if (num_columns == 0) {
+            context.error = makeEmptyRecordBatchError();
+            return;
+        }
+        
+        if (matlab_index < 1 || matlab_index > num_columns) {
+            context.error = makeInvalidNumericIndexError(matlab_index, num_columns);
+            return;
+        }
+
+        const auto array = record_batch->column(index);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto array_proxy,
+                                            arrow::matlab::array::proxy::wrap(array),
+                                            context,
+                                            error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+        
+        
+        const auto array_proxy_id = ProxyManager::manageProxy(array_proxy);
+        const auto array_proxy_id_mda = factory.createScalar(array_proxy_id);
+        const auto array_type_id_mda = factory.createScalar(static_cast<int32_t>(array->type_id()));
+        
+        context.outputs[0] = array_proxy_id_mda;
+        context.outputs[1] = array_type_id_mda;
+    }
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index 9561080d02276..b5d741060a15d 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -35,7 +35,8 @@ namespace arrow::matlab::tabular::proxy {
             void toString(libmexclass::proxy::method::Context& context);
             void numColumns(libmexclass::proxy::method::Context& context);
             void columnNames(libmexclass::proxy::method::Context& context);
-    
+            void getColumnByIndex(libmexclass::proxy::method::Context& context);
+
             std::shared_ptr<arrow::RecordBatch> record_batch;
     };
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h
index f5e2d30f8f4ec..f93240757c4c1 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.h
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#pragma once
+
 #include "arrow/type.h"
 #include "arrow/result.h"
 
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 9af09702e1cf5..796f2f0c7a645 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -18,10 +18,6 @@
 %arrow.tabular.RecordBatch A tabular data structure representing
 % a set of arrow.array.Array objects with a fixed schema.
 
-    properties (Access=private)
-        ArrowArrays = {};
-    end
-
     properties (Dependent, SetAccess=private, GetAccess=public)
         NumColumns
         ColumnNames
@@ -42,23 +38,35 @@
         end
 
         function arrowArray = column(obj, idx)
-            arrowArray = obj.ArrowArrays{idx};
+            if ~isempty(idx) && isscalar(idx) && isnumeric(idx) && idx >= 1
+                args = struct(Index=int32(idx));
+                [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);
+                traits = arrow.type.traits.traits(arrow.type.ID(typeID));
+                proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=proxyID);
+                arrowArray = traits.ArrayConstructor(proxy);
+            else
+                errid = "arrow:tabular:recordbatch:UnsupportedColumnIndexType";
+                msg = "Index must be a positive scalar integer.";
+                error(errid, msg);
+            end
         end
 
         function obj = RecordBatch(T)
-            obj.ArrowArrays = arrow.tabular.RecordBatch.decompose(T);
+            arrowArrays = arrow.tabular.RecordBatch.decompose(T);
             columnNames = string(T.Properties.VariableNames);
-            arrayProxyIDs = arrow.tabular.RecordBatch.getArrowProxyIDs(obj.ArrowArrays);
+            arrayProxyIDs = arrow.tabular.RecordBatch.getArrowProxyIDs(arrowArrays);
             opts = struct("ArrayProxyIDs", arrayProxyIDs, ...
                           "ColumnNames", columnNames);
             obj.Proxy = libmexclass.proxy.Proxy("Name", "arrow.tabular.proxy.RecordBatch", "ConstructorArguments", {opts});
         end
 
         function T = table(obj)
-            matlabArrays = cell(1, numel(obj.ArrowArrays));
+            numColumns = obj.NumColumns;
+            matlabArrays = cell(1, numColumns);
             
-            for ii = 1:numel(obj.ArrowArrays)
-                matlabArrays{ii} = toMATLAB(obj.ArrowArrays{ii});
+            for ii = 1:numColumns
+                arrowArray = obj.column(ii);
+                matlabArrays{ii} = toMATLAB(arrowArray);
             end
 
             variableNames = matlab.lang.makeUniqueStrings(obj.ColumnNames);
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 89175c43dad7a..78bfe7c090697 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -46,6 +46,8 @@ function SupportedTypes(tc)
             for ii = 1:arrowRecordBatch.NumColumns
                 column = arrowRecordBatch.column(ii);
                 tc.verifyEqual(column.toMATLAB(), TOriginal{:, ii});
+                traits = arrow.type.traits.traits(string(class(TOriginal{:, ii})));
+                tc.verifyInstanceOf(column, traits.ArrayClassName);
             end
         end
 
@@ -99,6 +101,25 @@ function EmptyTable(tc)
             tc.verifyEqual(TOriginal, TConverted);
         end
 
-    end
+        function EmptyRecordBatchColumnIndexError(tc)
+            TOriginal = table();
+            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            fcn = @() arrowRecordBatch.column(1);
+            tc.verifyError(fcn, "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch");
+        end
+
+        function InvalidNumericIndexError(tc)
+            TOriginal = table(1, 2, 3);
+            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            fcn = @() arrowRecordBatch.column(4);
+            tc.verifyError(fcn, "arrow:tabular:recordbatch:InvalidNumericColumnIndex");
+        end
 
+        function UnsupportedColumnIndexType(tc)
+            TOriginal = table(1, 2, 3);
+            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            fcn = @() arrowRecordBatch.column(datetime(2022, 1, 3));
+            tc.verifyError(fcn, "arrow:tabular:recordbatch:UnsupportedColumnIndexType");
+        end
+    end
 end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index a316a27e55d2b..f4696cfad26ee 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -44,6 +44,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/c
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/boolean_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/pack.cc"

From 19d0daf40c2db5164a6bfefc91019253d8db7157 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 4 Aug 2023 15:19:57 -0400
Subject: [PATCH 093/749] GH-36984: [MATLAB] Create `arrow.recordbatch`
 convenience constructor function (#37025)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
For parity with how `arrow.array.Array` objects are constructed (i.e. via `arrow.array`), we should create a construction function called `arrow.recordbatch()` for `arrow.tabular.RecordBatch`:

```matlab
>> t = table(["A"; "B"; "C"], [1; 2; 3])

t =

  3×2 table

    Var1    Var2
    ____    ____

    "A"      1
    "B"      2
    "C"      3

>> rb = arrow.recordbatch(t)

rb =

Var1:   [
    "A",
    "B",
    "C"
  ]
Var2:   [
    1,
    2,
    3
  ]

>> class(rb)

ans =

    'arrow.tabular.RecordBatch'
```

The `arrow.tabular.RecordBatch` constructor will accept a scalar `libmexclass.proxy.Proxy` object instead of a MATLAB `table` (although, client code is not expected to call the constructor directly - similar to the other classes).

### What changes are included in this PR?

1. Added the convenience constructor function  `arrow.recordbatch()`. It accepts a MATLAB `table` as input.
2. Modified `arrow.tabular.RecordBatch`'s constructor to expect a scalar `libmexclass.proxy.Proxy` object as input instead of a `table`.

### Are these changes tested?

Yes, updated the test cases in `tRecordBatch.m` to use the new convenience constructor  `arrow.recordbatch()` .

### Are there any user-facing changes?

Yes, users are now encouraged to use `arrow.recordbatch()` when constructing a record batch from a MATLAB `table` instead of  `arrow.tabular.RecordBatch`'s constructor.

* Closes: #36984

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+arrow/+tabular/+internal/decompose.m     | 27 ++++++++++
 .../+tabular/+internal/getArrayProxyIDs.m     | 26 +++++++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 53 +++----------------
 matlab/src/matlab/+arrow/recordbatch.m        | 31 +++++++++++
 matlab/test/arrow/tabular/tRecordBatch.m      | 22 ++++----
 5 files changed, 102 insertions(+), 57 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/decompose.m
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m
 create mode 100644 matlab/src/matlab/+arrow/recordbatch.m

diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/decompose.m b/matlab/src/matlab/+arrow/+tabular/+internal/decompose.m
new file mode 100644
index 0000000000000..2d8ec581304bd
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/decompose.m
@@ -0,0 +1,27 @@
+%DECOMPOSE Decompose the input MATLAB table input a cell array of 
+% equivalent arrow.array.Array instances.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function arrowArrays = decompose(T)
+    numColumns = width(T);
+    arrowArrays = cell(1, numColumns);
+
+    % Convert each MATLAB array into a corresponding
+    % arrow.array.Array.
+    for ii = 1:numColumns
+        arrowArrays{ii} = arrow.array(T{:, ii});
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m b/matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m
new file mode 100644
index 0000000000000..8a1f88158953c
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m
@@ -0,0 +1,26 @@
+%GETARRAYPROXYIDS Extract the Proxy IDs underlying a cell array of 
+% arrow.array.Array instances.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function proxyIDs = getArrayProxyIDs(arrowArrays)
+    proxyIDs = zeros(1, numel(arrowArrays), "uint64");
+
+    % Convert each MATLAB array into a corresponding
+    % arrow.array.Array.
+    for ii = 1:numel(arrowArrays)
+        proxyIDs(ii) = arrowArrays{ii}.Proxy.ID;
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 796f2f0c7a645..0d002797f0121 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -28,6 +28,13 @@
     end
 
     methods
+        function obj = RecordBatch(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.tabular.proxy.RecordBatch")}
+            end
+            import arrow.internal.proxy.validate
+            obj.Proxy = proxy;
+        end
 
         function numColumns = get.NumColumns(obj)
             numColumns = obj.Proxy.numColumns();
@@ -51,15 +58,6 @@
             end
         end
 
-        function obj = RecordBatch(T)
-            arrowArrays = arrow.tabular.RecordBatch.decompose(T);
-            columnNames = string(T.Properties.VariableNames);
-            arrayProxyIDs = arrow.tabular.RecordBatch.getArrowProxyIDs(arrowArrays);
-            opts = struct("ArrayProxyIDs", arrayProxyIDs, ...
-                          "ColumnNames", columnNames);
-            obj.Proxy = libmexclass.proxy.Proxy("Name", "arrow.tabular.proxy.RecordBatch", "ConstructorArguments", {opts});
-        end
-
         function T = table(obj)
             numColumns = obj.NumColumns;
             matlabArrays = cell(1, numColumns);
@@ -78,41 +76,6 @@
         function T = toMATLAB(obj)
             T = obj.table();
         end
-        
-    end
-
-    methods (Static)
-
-        function arrowArrays = decompose(T)
-            % Decompose the input MATLAB table
-            % input a cell array of equivalent arrow.array.Array
-            % instances.
-            arguments
-                T table
-            end
-
-            numColumns = width(T);
-            arrowArrays = cell(1, numColumns);
-
-            % Convert each MATLAB array into a corresponding
-            % arrow.array.Array.
-            for ii = 1:numColumns
-                arrowArrays{ii} = arrow.array(T{:, ii});
-            end
-        end
-
-        function proxyIDs = getArrowProxyIDs(arrowArrays)
-            % Extract the Proxy IDs underlying a cell array of 
-            % arrow.array.Array instances.
-            proxyIDs = zeros(1, numel(arrowArrays), "uint64");
-
-            % Convert each MATLAB array into a corresponding
-            % arrow.array.Array.
-            for ii = 1:numel(arrowArrays)
-                proxyIDs(ii) = arrowArrays{ii}.Proxy.ID;
-            end
-        end
-
     end
 
     methods (Access = private)
@@ -126,6 +89,4 @@ function displayScalarObject(obj)
             disp(obj.toString());
         end
     end
-
 end
-
diff --git a/matlab/src/matlab/+arrow/recordbatch.m b/matlab/src/matlab/+arrow/recordbatch.m
new file mode 100644
index 0000000000000..1fb25347f1a7d
--- /dev/null
+++ b/matlab/src/matlab/+arrow/recordbatch.m
@@ -0,0 +1,31 @@
+%RECORDBATCH Creates an arrow.tabular.RecordBatch from a table.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function rb = recordbatch(T)
+    arguments
+        T table
+    end
+
+    arrowArrays = arrow.tabular.internal.decompose(T);
+    arrayProxyIDs = arrow.tabular.internal.getArrayProxyIDs(arrowArrays);
+
+    columnNames = string(T.Properties.VariableNames);
+    args = struct(ArrayProxyIDs=arrayProxyIDs, ColumnNames=columnNames);
+    proxyName = "arrow.tabular.proxy.RecordBatch";
+    proxy = arrow.internal.proxy.create(proxyName, args);
+
+    rb = arrow.tabular.RecordBatch(proxy);
+end
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 78bfe7c090697..025f15320ade4 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -20,7 +20,7 @@
 
         function Basic(tc)
             T = table([1, 2, 3]');
-            arrowRecordBatch = arrow.tabular.RecordBatch(T);
+            arrowRecordBatch = arrow.recordbatch(T);
             className = string(class(arrowRecordBatch));
             tc.verifyEqual(className, "arrow.tabular.RecordBatch");
         end
@@ -40,7 +40,7 @@ function SupportedTypes(tc)
                               double ([1, 2, 3]'), ...
                               string (["A", "B", "C"]'), ...
                               datetime(2023, 6, 28) + days(0:2)');
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
             for ii = 1:arrowRecordBatch.NumColumns
@@ -53,14 +53,14 @@ function SupportedTypes(tc)
 
         function ToMATLAB(tc)
             TOriginal = table([1, 2, 3]');
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
         end
 
         function Table(tc)
             TOriginal = table([1, 2, 3]');
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             TConverted = table(arrowRecordBatch);
             tc.verifyEqual(TOriginal, TConverted);
         end
@@ -68,7 +68,7 @@ function Table(tc)
         function ColumnNames(tc)
             columnNames = ["A", "B", "C"];
             TOriginal = table(1, 2, 3, VariableNames=columnNames);
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             tc.verifyEqual(arrowRecordBatch.ColumnNames, columnNames);
         end
 
@@ -77,7 +77,7 @@ function NumColumns(tc)
 
             for nc = numColumns
                 T = array2table(ones(1, nc));
-                arrowRecordBatch = arrow.tabular.RecordBatch(T);
+                arrowRecordBatch = arrow.recordbatch(T);
                 tc.verifyEqual(arrowRecordBatch.NumColumns, nc);
             end
         end
@@ -88,7 +88,7 @@ function UnicodeColumnNames(tc)
             mango = "🥭";
             columnNames = [smiley, tree, mango];
             TOriginal = table(1, 2, 3, VariableNames=columnNames);
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             tc.verifyEqual(arrowRecordBatch.ColumnNames, columnNames);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
@@ -96,28 +96,28 @@ function UnicodeColumnNames(tc)
 
         function EmptyTable(tc)
             TOriginal = table();
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
         end
 
         function EmptyRecordBatchColumnIndexError(tc)
             TOriginal = table();
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             fcn = @() arrowRecordBatch.column(1);
             tc.verifyError(fcn, "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch");
         end
 
         function InvalidNumericIndexError(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             fcn = @() arrowRecordBatch.column(4);
             tc.verifyError(fcn, "arrow:tabular:recordbatch:InvalidNumericColumnIndex");
         end
 
         function UnsupportedColumnIndexType(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.tabular.RecordBatch(TOriginal);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
             fcn = @() arrowRecordBatch.column(datetime(2022, 1, 3));
             tc.verifyError(fcn, "arrow:tabular:recordbatch:UnsupportedColumnIndexType");
         end

From 839ea601d5241dde43ee59f667eaceec963977b5 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 7 Aug 2023 08:41:41 +0800
Subject: [PATCH 094/749] MINOR: [C++] async_until typo fix (#37029)

### Rationale for this change

Fix typo in `cpp/src/arrow/acero/source_node.cc` and  `cpp/src/arrow/util/async_util.h`.

### What changes are included in this PR?

Fix typo in `cpp/src/arrow/acero/source_node.cc` and  `cpp/src/arrow/util/async_util.h`.

### Are these changes tested?

no

### Are there any user-facing changes?

no

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/acero/source_node.cc | 4 ++--
 cpp/src/arrow/util/async_util.h    | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/acero/source_node.cc b/cpp/src/arrow/acero/source_node.cc
index ddb062ac005ff..8060e01f074f8 100644
--- a/cpp/src/arrow/acero/source_node.cc
+++ b/cpp/src/arrow/acero/source_node.cc
@@ -99,7 +99,7 @@ struct SourceNode : ExecNode, public TracedNode {
       : ExecNode(plan, {}, {}, std::move(output_schema)),
         TracedNode(this),
         generator_(std::move(generator)),
-        ordering_(ordering) {}
+        ordering_(std::move(ordering)) {}
 
   static Result<ExecNode*> Make(ExecPlan* plan, std::vector<ExecNode*> inputs,
                                 const ExecNodeOptions& options) {
@@ -177,7 +177,7 @@ struct SourceNode : ExecNode, public TracedNode {
 
     CallbackOptions options;
     // These options will transfer execution to the desired Executor if necessary.
-    // This can happen for in-memory scans where batches didn't require
+    // This can happen for in-memory scans where batches don't require
     // any CPU work to decode. Otherwise, parsing etc should have already
     // been placed us on the desired Executor and no queues will be pushed to.
     options.executor = plan()->query_context()->executor();
diff --git a/cpp/src/arrow/util/async_util.h b/cpp/src/arrow/util/async_util.h
index 2668ae222609b..db03719f5e84c 100644
--- a/cpp/src/arrow/util/async_util.h
+++ b/cpp/src/arrow/util/async_util.h
@@ -58,7 +58,7 @@ namespace util {
 /// finish.  Note, it is not an error to add additional tasks after a scheduler has
 /// aborted. These tasks will be ignored and never submitted.  The scheduler returns a
 /// future which will complete when all submitted tasks have finished executing.  Once all
-/// tasks have been finsihed the scheduler is invalid and should no longer be used.
+/// tasks have been finished the scheduler is invalid and should no longer be used.
 ///
 /// Task failure (either the synchronous portion or the asynchronous portion) will cause
 /// the scheduler to enter an aborted state.  The first such failure will be reported in
@@ -117,7 +117,7 @@ class ARROW_EXPORT AsyncTaskScheduler {
   ///
   /// A task's name must remain valid for the duration of the task.  It is used for
   /// debugging (e.g. when debugging a deadlock to see which tasks still remain) and for
-  /// traceability (the name will be used for spans asigned to the task)
+  /// traceability (the name will be used for spans assigned to the task)
   ///
   /// \return true if the task was submitted or queued, false if the task was ignored
   virtual bool AddTask(std::unique_ptr<Task> task) = 0;
@@ -262,7 +262,7 @@ class ARROW_EXPORT ThrottledAsyncTaskScheduler : public AsyncTaskScheduler {
     virtual void Pause() = 0;
     /// Resume the throttle
     ///
-    /// Allows taks to be submitted again.  If there is a max_concurrent_cost limit then
+    /// Allows task to be submitted again.  If there is a max_concurrent_cost limit then
     /// it will still apply.
     virtual void Resume() = 0;
   };
@@ -274,7 +274,7 @@ class ARROW_EXPORT ThrottledAsyncTaskScheduler : public AsyncTaskScheduler {
   virtual void Pause() = 0;
   /// Resume the throttle
   ///
-  /// Allows taks to be submitted again.  If there is a max_concurrent_cost limit then
+  /// Allows task to be submitted again.  If there is a max_concurrent_cost limit then
   /// it will still apply.
   virtual void Resume() = 0;
 

From 311e8668be5edd029df292a7f0a033bc40db9b8d Mon Sep 17 00:00:00 2001
From: Ikko Eltociear Ashimine <eltociear@gmail.com>
Date: Mon, 7 Aug 2023 09:42:53 +0900
Subject: [PATCH 095/749] MINOR: [Docs] Fix a typo in env_vars.rst (#37030)

### Rationale for this change

### What changes are included in this PR?
accross -> across

### Are these changes tested?

### Are there any user-facing changes?

Authored-by: Ikko Eltociear Ashimine <eltociear@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/cpp/env_vars.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/env_vars.rst b/docs/source/cpp/env_vars.rst
index 8d10fd2cc2e40..b4d93c7eadd9b 100644
--- a/docs/source/cpp/env_vars.rst
+++ b/docs/source/cpp/env_vars.rst
@@ -145,7 +145,7 @@ that changing their value later will have an effect.
 .. envvar:: GANDIVA_CACHE_SIZE
 
    The number of entries to keep in the Gandiva JIT compilation cache.
-   The cache is in-memory and does not persist accross processes.
+   The cache is in-memory and does not persist across processes.
 
 .. envvar:: HADOOP_HOME
 

From 3bb13da316e4ddd4a7aab26a0f099763f1d32b1f Mon Sep 17 00:00:00 2001
From: SGZW <shuguangzw@gmail.com>
Date: Mon, 7 Aug 2023 08:45:53 +0800
Subject: [PATCH 096/749] MINOR: [C++] Fix a typo in Acero agg description
 (#37031)

### Rationale for this change

### What changes are included in this PR?

fix acero agg node typo

### Are these changes tested?

### Are there any user-facing changes?

Authored-by: SGZW <shuguangzw@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/acero/aggregate_internal.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/acero/aggregate_internal.h b/cpp/src/arrow/acero/aggregate_internal.h
index 01861f0242f34..744acb124505a 100644
--- a/cpp/src/arrow/acero/aggregate_internal.h
+++ b/cpp/src/arrow/acero/aggregate_internal.h
@@ -52,7 +52,7 @@
 // segment-keys is used to refine the partitioning. However, segment-keys are different in
 // that they partition only consecutive rows into a single group. Such a partition of
 // consecutive rows is called a segment group. For example, consider a column X with
-// values [A, A, B, A] at row-indices [0, 1, 2]. A regular group-by aggregation with keys
+// values [A, A, B, A] at row-indices [0, 1, 2, 3]. A regular group-by aggregation with keys
 // [X] yields a row-index partitioning [[0, 1, 3], [2]] whereas a segmented-group-by
 // aggregation with segment-keys [X] yields [[0, 1], [2], [3]].
 //

From 2b36521e52f61f6a68e58e7c8c2f7bf2ed805cdc Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Sun, 6 Aug 2023 23:38:14 -0400
Subject: [PATCH 097/749] GH-36642: [Python][CI] Configure warnings as errors
 during pytest (#37018)

### Rationale for this change

Warnings are constantly being introduced into the pyarrow tests. Let's try enforcing them as errors in an effort to keep the codebase healthy.

### What changes are included in this PR?

* Fixed existing warnings
* Set warnings as errors in CI

### Are these changes tested?

Yes, ran pytests locally w/o warnings.

### Are there any user-facing changes?

No
* Closes: #36642

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/tasks.yml                          |  3 ++-
 docker-compose.yml                           |  1 +
 python/pyarrow/tests/parquet/conftest.py     | 15 +++++++------
 python/pyarrow/tests/parquet/test_dataset.py |  2 +-
 python/pyarrow/tests/strategies.py           | 22 +++++++++++---------
 python/pyarrow/tests/test_pandas.py          |  5 ++++-
 python/pyarrow/tests/test_tensor.py          |  7 +++++--
 7 files changed, 34 insertions(+), 21 deletions(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 73b793162d959..941506b9c2abc 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1253,6 +1253,7 @@ tasks:
     params:
       env:
         PYTHON: "{{ python_version }}"
+        PYTEST_ARGS: "-W error"
       image: conda-python
 {% endfor %}
 
@@ -1265,7 +1266,7 @@ tasks:
         HYPOTHESIS_PROFILE: ci
         PYARROW_TEST_HYPOTHESIS: ON
         # limit to execute hypothesis tests only
-        PYTEST_ARGS: "-m hypothesis"
+        PYTEST_ARGS: "-m hypothesis -W error"
       image: conda-python-pandas
 
   test-conda-python-3.10-substrait:
diff --git a/docker-compose.yml b/docker-compose.yml
index fe98a30d0b92b..3bf346ef94173 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -835,6 +835,7 @@ services:
     shm_size: *shm-size
     environment:
       <<: [*common, *ccache, *sccache]
+      PYTEST_ARGS:  # inherit
     volumes: *conda-volumes
     command: &python-conda-command
       ["
diff --git a/python/pyarrow/tests/parquet/conftest.py b/python/pyarrow/tests/parquet/conftest.py
index 1e75493cdae03..461c24af22aa9 100644
--- a/python/pyarrow/tests/parquet/conftest.py
+++ b/python/pyarrow/tests/parquet/conftest.py
@@ -29,9 +29,10 @@ def datadir(base_datadir):
 def s3_bucket(s3_server):
     boto3 = pytest.importorskip('boto3')
     botocore = pytest.importorskip('botocore')
+    s3_bucket_name = 'test-s3fs'
 
     host, port, access_key, secret_key = s3_server['connection']
-    s3 = boto3.resource(
+    s3_client = boto3.client(
         's3',
         endpoint_url='http://{}:{}'.format(host, port),
         aws_access_key_id=access_key,
@@ -39,13 +40,15 @@ def s3_bucket(s3_server):
         config=botocore.client.Config(signature_version='s3v4'),
         region_name='us-east-1'
     )
-    bucket = s3.Bucket('test-s3fs')
+
     try:
-        bucket.create()
+        s3_client.create_bucket(Bucket=s3_bucket_name)
     except Exception:
-        # we get BucketAlreadyOwnedByYou error with fsspec handler
-        pass
-    return 'test-s3fs'
+        pass  # we get BucketAlreadyOwnedByYou error with fsspec handler
+    finally:
+        s3_client.close()
+
+    return s3_bucket_name
 
 
 @pytest.fixture
diff --git a/python/pyarrow/tests/parquet/test_dataset.py b/python/pyarrow/tests/parquet/test_dataset.py
index cd991617c9fa8..3e6ff49265c32 100644
--- a/python/pyarrow/tests/parquet/test_dataset.py
+++ b/python/pyarrow/tests/parquet/test_dataset.py
@@ -1316,7 +1316,7 @@ def _test_write_to_dataset_with_partitions(base_path,
         output_df[col] = output_df[col].astype('category')
 
     if schema:
-        expected_date_type = schema.field_by_name('date').type.to_pandas_dtype()
+        expected_date_type = schema.field('date').type.to_pandas_dtype()
         output_df["date"] = output_df["date"].astype(expected_date_type)
 
     tm.assert_frame_equal(output_df, input_df)
diff --git a/python/pyarrow/tests/strategies.py b/python/pyarrow/tests/strategies.py
index 48f7e5381724a..bb88a4dcb7b2a 100644
--- a/python/pyarrow/tests/strategies.py
+++ b/python/pyarrow/tests/strategies.py
@@ -182,15 +182,17 @@ def struct_types(draw, item_strategy=primitive_types):
 
 
 def dictionary_types(key_strategy=None, value_strategy=None):
-    key_strategy = key_strategy or signed_integer_types
-    value_strategy = value_strategy or st.one_of(
-        bool_type,
-        integer_types,
-        st.sampled_from([pa.float32(), pa.float64()]),
-        binary_type,
-        string_type,
-        fixed_size_binary_type,
-    )
+    if key_strategy is None:
+        key_strategy = signed_integer_types
+    if value_strategy is None:
+        value_strategy = st.one_of(
+            bool_type,
+            integer_types,
+            st.sampled_from([pa.float32(), pa.float64()]),
+            binary_type,
+            string_type,
+            fixed_size_binary_type,
+        )
     return st.builds(pa.dictionary, key_strategy, value_strategy)
 
 
@@ -368,7 +370,7 @@ def record_batches(draw, type, rows=None, max_fields=None):
     children = [draw(arrays(field.type, size=rows)) for field in schema]
     # TODO(kszucs): the names and schema arguments are not consistent with
     #               Table.from_array's arguments
-    return pa.RecordBatch.from_arrays(children, names=schema)
+    return pa.RecordBatch.from_arrays(children, schema=schema)
 
 
 @st.composite
diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index 8bdc7253a4837..ef6ddd09933c9 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -2913,7 +2913,10 @@ def test_strided_data_import(self):
                           'f4', 'f8']
 
         for type_name in numeric_dtypes:
-            cases.append(random_numbers.astype(type_name))
+            # Casting np.float64 -> uint32 or uint64 throws a RuntimeWarning
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                cases.append(random_numbers.astype(type_name))
 
         # strings
         cases.append(np.array([random_ascii(10) for i in range(N * K)],
diff --git a/python/pyarrow/tests/test_tensor.py b/python/pyarrow/tests/test_tensor.py
index aee46bc93690c..3e6a4ca8ed222 100644
--- a/python/pyarrow/tests/test_tensor.py
+++ b/python/pyarrow/tests/test_tensor.py
@@ -18,6 +18,7 @@
 import os
 import sys
 import pytest
+import warnings
 import weakref
 
 import numpy as np
@@ -82,8 +83,10 @@ def test_tensor_base_object():
 @pytest.mark.parametrize('dtype_str,arrow_type', tensor_type_pairs)
 def test_tensor_numpy_roundtrip(dtype_str, arrow_type):
     dtype = np.dtype(dtype_str)
-    data = (100 * np.random.randn(10, 4)).astype(dtype)
-
+    # Casting np.float64 -> uint32 or uint64 throws a RuntimeWarning
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        data = (100 * np.random.randn(10, 4)).astype(dtype)
     tensor = pa.Tensor.from_numpy(data)
     assert tensor.type == arrow_type
 

From 7cbbd3ee95bc0f7d20bb358e2978e2eb18a05304 Mon Sep 17 00:00:00 2001
From: Anja Kefala <anja@voltrondata.com>
Date: Sun, 6 Aug 2023 20:55:25 -0700
Subject: [PATCH 098/749] MINOR: [Docs] add note about how comment bot assigns
 users (#36362)

### Rationale for this change

Each time I wanted to use it, I had to look up the syntax in the github workflows. Most new users wouldn't know about it existing.

https://github.com/apache/arrow/blob/e5de6a59f410a3255cc84138b44fc5802b627afc/.github/workflows/comment_bot.yml#L182

### What changes are included in this PR?

Doc addition of text teaching about "take".

### Are there any user-facing changes?

Nope

Authored-by: anjakefala <anja@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/guide/step_by_step/finding_issues.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/source/developers/guide/step_by_step/finding_issues.rst b/docs/source/developers/guide/step_by_step/finding_issues.rst
index 89c5a81b73dde..a3af1640a3b1d 100644
--- a/docs/source/developers/guide/step_by_step/finding_issues.rst
+++ b/docs/source/developers/guide/step_by_step/finding_issues.rst
@@ -69,6 +69,7 @@ in the comments.
    When you find a GitHub issue you would like to work on, please mention
    your interest in the comment section of that issue; that way we will know
    you are working on it.
+   Consider assigning yourself to the issue (:ref:`issue-assignment`) when the work starts.
 
 Also, do not hesitate to ask questions in the comment. You can get some
 pointers about where to start and similar issues already solved.

From 3c00b08046be6549cc05714959ddcb993051ac45 Mon Sep 17 00:00:00 2001
From: Kuba Martin <jakub.wit.martin@gmail.com>
Date: Mon, 7 Aug 2023 18:27:26 +0200
Subject: [PATCH 099/749] GH-36936: [Go] Make it possible to register custom
 functions. (#36959)

### Rationale for this change

As discussed in the issue #36936 , this change makes it possible for the consumers of the module to register custom functions, while taking advantage of the existing infrastructure for matching types and choosing kernels.

### What changes are included in this PR?

Just moving the package one level higher, so that it's module-exported.

### Are these changes tested?

There's no actual code changes other than moving files around and updating imports - existing tests still pass.

### Are there any user-facing changes?

The `compute/exec` is now exported.

* Closes: #36936

Authored-by: Jakub Martin <jakub.wit.martin@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/compute/arithmetic.go                |  2 +-
 go/arrow/compute/arithmetic_test.go           |  2 +-
 go/arrow/compute/cast.go                      |  2 +-
 go/arrow/compute/example_test.go              | 91 +++++++++++++++++++
 go/arrow/compute/exec.go                      |  2 +-
 .../compute/{internal => }/exec/hash_util.go  |  0
 .../compute/{internal => }/exec/kernel.go     |  0
 .../{internal => }/exec/kernel_test.go        |  2 +-
 go/arrow/compute/{internal => }/exec/span.go  |  0
 .../compute/{internal => }/exec/span_test.go  |  2 +-
 go/arrow/compute/{internal => }/exec/utils.go |  0
 .../compute/{internal => }/exec/utils_test.go |  2 +-
 go/arrow/compute/exec_internals_test.go       |  2 +-
 go/arrow/compute/exec_test.go                 |  2 +-
 go/arrow/compute/executor.go                  |  2 +-
 go/arrow/compute/expression.go                |  2 +-
 go/arrow/compute/exprs/exec.go                |  2 +-
 go/arrow/compute/functions.go                 |  2 +-
 .../internal/kernels/base_arithmetic.go       |  2 +-
 .../internal/kernels/base_arithmetic_amd64.go |  2 +-
 .../kernels/basic_arithmetic_noasm.go         |  2 +-
 .../compute/internal/kernels/boolean_cast.go  |  2 +-
 go/arrow/compute/internal/kernels/cast.go     |  2 +-
 .../compute/internal/kernels/cast_temporal.go |  2 +-
 go/arrow/compute/internal/kernels/helpers.go  |  2 +-
 .../compute/internal/kernels/numeric_cast.go  |  2 +-
 go/arrow/compute/internal/kernels/rounding.go |  2 +-
 .../internal/kernels/scalar_arithmetic.go     |  2 +-
 .../internal/kernels/scalar_boolean.go        |  2 +-
 .../kernels/scalar_comparison_amd64.go        |  2 +-
 .../kernels/scalar_comparison_noasm.go        |  2 +-
 .../internal/kernels/scalar_comparisons.go    |  2 +-
 .../compute/internal/kernels/string_casts.go  |  2 +-
 go/arrow/compute/internal/kernels/types.go    |  2 +-
 .../compute/internal/kernels/vector_hash.go   |  2 +-
 .../internal/kernels/vector_run_end_encode.go |  2 +-
 .../internal/kernels/vector_selection.go      |  2 +-
 go/arrow/compute/registry_test.go             |  2 +-
 go/arrow/compute/scalar_bool.go               |  2 +-
 go/arrow/compute/scalar_compare.go            |  2 +-
 go/arrow/compute/scalar_compare_test.go       |  2 +-
 go/arrow/compute/selection.go                 |  2 +-
 go/arrow/compute/utils.go                     |  2 +-
 go/arrow/compute/vector_hash_test.go          |  2 +-
 go/arrow/compute/vector_run_end_test.go       |  2 +-
 go/arrow/compute/vector_selection_test.go     |  2 +-
 46 files changed, 132 insertions(+), 41 deletions(-)
 create mode 100644 go/arrow/compute/example_test.go
 rename go/arrow/compute/{internal => }/exec/hash_util.go (100%)
 rename go/arrow/compute/{internal => }/exec/kernel.go (100%)
 rename go/arrow/compute/{internal => }/exec/kernel_test.go (99%)
 rename go/arrow/compute/{internal => }/exec/span.go (100%)
 rename go/arrow/compute/{internal => }/exec/span_test.go (99%)
 rename go/arrow/compute/{internal => }/exec/utils.go (100%)
 rename go/arrow/compute/{internal => }/exec/utils_test.go (98%)

diff --git a/go/arrow/compute/arithmetic.go b/go/arrow/compute/arithmetic.go
index 2df547e5b4fa4..046cb3f2d9e13 100644
--- a/go/arrow/compute/arithmetic.go
+++ b/go/arrow/compute/arithmetic.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
diff --git a/go/arrow/compute/arithmetic_test.go b/go/arrow/compute/arithmetic_test.go
index c4e0c591cbf54..d9dd799b7cfce 100644
--- a/go/arrow/compute/arithmetic_test.go
+++ b/go/arrow/compute/arithmetic_test.go
@@ -29,7 +29,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
diff --git a/go/arrow/compute/cast.go b/go/arrow/compute/cast.go
index aad07413bf3ff..d77273f539595 100644
--- a/go/arrow/compute/cast.go
+++ b/go/arrow/compute/cast.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 )
 
diff --git a/go/arrow/compute/example_test.go b/go/arrow/compute/example_test.go
new file mode 100644
index 0000000000000..8d0f25e4c4372
--- /dev/null
+++ b/go/arrow/compute/example_test.go
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build go1.18
+
+package compute_test
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v13/arrow/compute"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v13/arrow/memory"
+)
+
+// This example demonstrates how to register a custom scalar function.
+func Example_customFunction() {
+	pool := memory.NewGoAllocator()
+
+	ctx := context.Background()
+	execCtx := compute.DefaultExecCtx()
+	ctx = compute.SetExecCtx(ctx, execCtx)
+
+	add42 := compute.NewScalarFunction("add_42", compute.Arity{
+		NArgs: 1,
+	}, compute.FunctionDoc{
+		Summary:  "Returns the input values plus 42",
+		ArgNames: []string{"input"},
+	})
+
+	if err := add42.AddNewKernel(
+		[]exec.InputType{
+			// We accept a single argument (array) of Int8 type.
+			{
+				Kind: exec.InputExact,
+				Type: arrow.PrimitiveTypes.Int8,
+			},
+		},
+		// We'll return a single Int8 array.
+		exec.NewOutputType(arrow.PrimitiveTypes.Int8),
+		func(ctx *exec.KernelCtx, span *exec.ExecSpan, result *exec.ExecResult) error {
+			// The second buffer contains the values. Both for the input and the output arrays.
+			for i, x := range span.Values[0].Array.Buffers[1].Buf {
+				result.Buffers[1].Buf[i] = x + 42
+			}
+			return nil
+		},
+		nil,
+	); err != nil {
+		log.Fatal(err)
+	}
+	execCtx.Registry.AddFunction(add42, true)
+
+	inputArrayBuilder := array.NewInt8Builder(pool)
+	for i := 0; i < 16; i++ {
+		inputArrayBuilder.Append(int8(i))
+	}
+	inputArray := inputArrayBuilder.NewArray()
+
+	outputArrayDatum, err := compute.CallFunction(
+		compute.SetExecCtx(context.Background(), execCtx),
+		"add_42",
+		nil,
+		&compute.ArrayDatum{Value: inputArray.Data()},
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(array.NewInt8Data(outputArrayDatum.(*compute.ArrayDatum).Value).Int8Values())
+
+	// Output:
+	// [42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57]
+}
diff --git a/go/arrow/compute/exec.go b/go/arrow/compute/exec.go
index 6dbef8cdfbbd9..c478a1dcdef7d 100644
--- a/go/arrow/compute/exec.go
+++ b/go/arrow/compute/exec.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 )
 
diff --git a/go/arrow/compute/internal/exec/hash_util.go b/go/arrow/compute/exec/hash_util.go
similarity index 100%
rename from go/arrow/compute/internal/exec/hash_util.go
rename to go/arrow/compute/exec/hash_util.go
diff --git a/go/arrow/compute/internal/exec/kernel.go b/go/arrow/compute/exec/kernel.go
similarity index 100%
rename from go/arrow/compute/internal/exec/kernel.go
rename to go/arrow/compute/exec/kernel.go
diff --git a/go/arrow/compute/internal/exec/kernel_test.go b/go/arrow/compute/exec/kernel_test.go
similarity index 99%
rename from go/arrow/compute/internal/exec/kernel_test.go
rename to go/arrow/compute/exec/kernel_test.go
index 827ac97e63a01..65fc41e4e4d56 100644
--- a/go/arrow/compute/internal/exec/kernel_test.go
+++ b/go/arrow/compute/exec/kernel_test.go
@@ -25,7 +25,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
 	"github.com/stretchr/testify/assert"
diff --git a/go/arrow/compute/internal/exec/span.go b/go/arrow/compute/exec/span.go
similarity index 100%
rename from go/arrow/compute/internal/exec/span.go
rename to go/arrow/compute/exec/span.go
diff --git a/go/arrow/compute/internal/exec/span_test.go b/go/arrow/compute/exec/span_test.go
similarity index 99%
rename from go/arrow/compute/internal/exec/span_test.go
rename to go/arrow/compute/exec/span_test.go
index 2423824bbe5a7..3cbd54f0d4094 100644
--- a/go/arrow/compute/internal/exec/span_test.go
+++ b/go/arrow/compute/exec/span_test.go
@@ -26,7 +26,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/endian"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/compute/internal/exec/utils.go b/go/arrow/compute/exec/utils.go
similarity index 100%
rename from go/arrow/compute/internal/exec/utils.go
rename to go/arrow/compute/exec/utils.go
diff --git a/go/arrow/compute/internal/exec/utils_test.go b/go/arrow/compute/exec/utils_test.go
similarity index 98%
rename from go/arrow/compute/internal/exec/utils_test.go
rename to go/arrow/compute/exec/utils_test.go
index 40b98b26e7d1e..4f908bb2057b1 100644
--- a/go/arrow/compute/internal/exec/utils_test.go
+++ b/go/arrow/compute/exec/utils_test.go
@@ -23,7 +23,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/arrow/compute/exec_internals_test.go b/go/arrow/compute/exec_internals_test.go
index 4d259aa27394a..3247becd969a3 100644
--- a/go/arrow/compute/exec_internals_test.go
+++ b/go/arrow/compute/exec_internals_test.go
@@ -27,7 +27,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
diff --git a/go/arrow/compute/exec_test.go b/go/arrow/compute/exec_test.go
index fb97c3c803f6b..308e30aac7316 100644
--- a/go/arrow/compute/exec_test.go
+++ b/go/arrow/compute/exec_test.go
@@ -25,7 +25,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index d3f1a1fd41d4c..962f41019dac2 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -28,7 +28,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/compute/expression.go b/go/arrow/compute/expression.go
index b01c3b67133ad..04128bef7738c 100644
--- a/go/arrow/compute/expression.go
+++ b/go/arrow/compute/expression.go
@@ -30,7 +30,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/ipc"
diff --git a/go/arrow/compute/exprs/exec.go b/go/arrow/compute/exprs/exec.go
index 97b16ede11464..7683587478bf2 100644
--- a/go/arrow/compute/exprs/exec.go
+++ b/go/arrow/compute/exprs/exec.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/endian"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
diff --git a/go/arrow/compute/functions.go b/go/arrow/compute/functions.go
index 3943fbca3597f..887346f7f5d06 100644
--- a/go/arrow/compute/functions.go
+++ b/go/arrow/compute/functions.go
@@ -24,7 +24,7 @@ import (
 	"strings"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 )
 
 type Function interface {
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic.go b/go/arrow/compute/internal/kernels/base_arithmetic.go
index 5da1b29a63dc8..bfdb7b8f2103e 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic.go
@@ -25,7 +25,7 @@ import (
 
 	"github.com/JohnCGriffin/overflow"
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
index 432acc3d81f8b..9683ac9420fdd 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/sys/cpu"
diff --git a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
index 1a2874df704f2..767425d61e221 100644
--- a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
+++ b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
@@ -19,7 +19,7 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/boolean_cast.go b/go/arrow/compute/internal/kernels/boolean_cast.go
index 7e1ff50c816df..b0ca7c2d9157a 100644
--- a/go/arrow/compute/internal/kernels/boolean_cast.go
+++ b/go/arrow/compute/internal/kernels/boolean_cast.go
@@ -24,7 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 )
 
 func isNonZero[T exec.FixedWidthTypes](ctx *exec.KernelCtx, in []T, out []byte) error {
diff --git a/go/arrow/compute/internal/kernels/cast.go b/go/arrow/compute/internal/kernels/cast.go
index 80be6ca15cc25..50cf775d2985e 100644
--- a/go/arrow/compute/internal/kernels/cast.go
+++ b/go/arrow/compute/internal/kernels/cast.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 )
 
 type CastOptions struct {
diff --git a/go/arrow/compute/internal/kernels/cast_temporal.go b/go/arrow/compute/internal/kernels/cast_temporal.go
index dbc92d2a3df0e..8201119a4edbc 100644
--- a/go/arrow/compute/internal/kernels/cast_temporal.go
+++ b/go/arrow/compute/internal/kernels/cast_temporal.go
@@ -26,7 +26,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 )
 
diff --git a/go/arrow/compute/internal/kernels/helpers.go b/go/arrow/compute/internal/kernels/helpers.go
index fe91676f3bbc0..99816bc9bd43a 100644
--- a/go/arrow/compute/internal/kernels/helpers.go
+++ b/go/arrow/compute/internal/kernels/helpers.go
@@ -24,7 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
diff --git a/go/arrow/compute/internal/kernels/numeric_cast.go b/go/arrow/compute/internal/kernels/numeric_cast.go
index a7258f235418e..f0e469f15f338 100644
--- a/go/arrow/compute/internal/kernels/numeric_cast.go
+++ b/go/arrow/compute/internal/kernels/numeric_cast.go
@@ -25,7 +25,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
diff --git a/go/arrow/compute/internal/kernels/rounding.go b/go/arrow/compute/internal/kernels/rounding.go
index ad385e4dce8e6..93f5829018f67 100644
--- a/go/arrow/compute/internal/kernels/rounding.go
+++ b/go/arrow/compute/internal/kernels/rounding.go
@@ -23,7 +23,7 @@ import (
 	"math"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
diff --git a/go/arrow/compute/internal/kernels/scalar_arithmetic.go b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
index 01622e0a4df94..3f6832cbbc583 100644
--- a/go/arrow/compute/internal/kernels/scalar_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
@@ -24,7 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
diff --git a/go/arrow/compute/internal/kernels/scalar_boolean.go b/go/arrow/compute/internal/kernels/scalar_boolean.go
index 3c4916a1d94fe..59ea7627a204f 100644
--- a/go/arrow/compute/internal/kernels/scalar_boolean.go
+++ b/go/arrow/compute/internal/kernels/scalar_boolean.go
@@ -20,7 +20,7 @@ package kernels
 
 import (
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
index 7d1db042cadae..a4cecb80bbd2f 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
@@ -22,7 +22,7 @@ import (
 	"unsafe"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
index e877610b372cf..204eaa6d448ea 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
@@ -18,7 +18,7 @@
 
 package kernels
 
-import "github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+import "github.com/apache/arrow/go/v13/arrow/compute/exec"
 
 func genCompareKernel[T exec.NumericTypes](op CompareOperator) *CompareData {
 	return genGoCompareKernel(getCmpOp[T](op))
diff --git a/go/arrow/compute/internal/kernels/scalar_comparisons.go b/go/arrow/compute/internal/kernels/scalar_comparisons.go
index 5e905b514c9e0..8d4ae244397d3 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparisons.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparisons.go
@@ -25,7 +25,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
diff --git a/go/arrow/compute/internal/kernels/string_casts.go b/go/arrow/compute/internal/kernels/string_casts.go
index 344b10364c138..db278fd853d1d 100644
--- a/go/arrow/compute/internal/kernels/string_casts.go
+++ b/go/arrow/compute/internal/kernels/string_casts.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/float16"
 	"github.com/apache/arrow/go/v13/internal/bitutils"
 )
diff --git a/go/arrow/compute/internal/kernels/types.go b/go/arrow/compute/internal/kernels/types.go
index 7743b076397c9..b1d0fa0403229 100644
--- a/go/arrow/compute/internal/kernels/types.go
+++ b/go/arrow/compute/internal/kernels/types.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
 )
diff --git a/go/arrow/compute/internal/kernels/vector_hash.go b/go/arrow/compute/internal/kernels/vector_hash.go
index abae8e1b0b287..ee592b98b87a5 100644
--- a/go/arrow/compute/internal/kernels/vector_hash.go
+++ b/go/arrow/compute/internal/kernels/vector_hash.go
@@ -23,7 +23,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/internal/bitutils"
diff --git a/go/arrow/compute/internal/kernels/vector_run_end_encode.go b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
index 3c5b673f657a8..e5ea93a3ebc47 100644
--- a/go/arrow/compute/internal/kernels/vector_run_end_encode.go
+++ b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
@@ -26,7 +26,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/float16"
diff --git a/go/arrow/compute/internal/kernels/vector_selection.go b/go/arrow/compute/internal/kernels/vector_selection.go
index 8edefe2453997..73b54fdeb5420 100644
--- a/go/arrow/compute/internal/kernels/vector_selection.go
+++ b/go/arrow/compute/internal/kernels/vector_selection.go
@@ -25,7 +25,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/internal/bitutils"
diff --git a/go/arrow/compute/registry_test.go b/go/arrow/compute/registry_test.go
index e06bd47a7cab3..c447364359287 100644
--- a/go/arrow/compute/registry_test.go
+++ b/go/arrow/compute/registry_test.go
@@ -25,7 +25,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/scalar_bool.go b/go/arrow/compute/scalar_bool.go
index e47830ebc96b7..5678a1fb6943e 100644
--- a/go/arrow/compute/scalar_bool.go
+++ b/go/arrow/compute/scalar_bool.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 )
 
diff --git a/go/arrow/compute/scalar_compare.go b/go/arrow/compute/scalar_compare.go
index dc4d807e3d671..14c0a4d25d0da 100644
--- a/go/arrow/compute/scalar_compare.go
+++ b/go/arrow/compute/scalar_compare.go
@@ -22,7 +22,7 @@ import (
 	"context"
 
 	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 )
 
diff --git a/go/arrow/compute/scalar_compare_test.go b/go/arrow/compute/scalar_compare_test.go
index 460f856e28d47..4643e26ce1873 100644
--- a/go/arrow/compute/scalar_compare_test.go
+++ b/go/arrow/compute/scalar_compare_test.go
@@ -28,7 +28,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/compute/selection.go b/go/arrow/compute/selection.go
index 2ce749a053b1f..4593ba0daf4df 100644
--- a/go/arrow/compute/selection.go
+++ b/go/arrow/compute/selection.go
@@ -24,7 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"golang.org/x/sync/errgroup"
 )
diff --git a/go/arrow/compute/utils.go b/go/arrow/compute/utils.go
index b22b26b2ac7d1..5b3aef1691848 100644
--- a/go/arrow/compute/utils.go
+++ b/go/arrow/compute/utils.go
@@ -26,7 +26,7 @@ import (
 
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/compute/vector_hash_test.go b/go/arrow/compute/vector_hash_test.go
index c3aae265c7c51..e83687b12700d 100644
--- a/go/arrow/compute/vector_hash_test.go
+++ b/go/arrow/compute/vector_hash_test.go
@@ -26,7 +26,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/decimal128"
 	"github.com/apache/arrow/go/v13/arrow/decimal256"
 	"github.com/apache/arrow/go/v13/arrow/memory"
diff --git a/go/arrow/compute/vector_run_end_test.go b/go/arrow/compute/vector_run_end_test.go
index e00990577ae72..62ea7dba015a2 100644
--- a/go/arrow/compute/vector_run_end_test.go
+++ b/go/arrow/compute/vector_run_end_test.go
@@ -29,7 +29,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/vector_selection_test.go b/go/arrow/compute/vector_selection_test.go
index eec403fc90e73..2a97f4c1301bb 100644
--- a/go/arrow/compute/vector_selection_test.go
+++ b/go/arrow/compute/vector_selection_test.go
@@ -27,7 +27,7 @@ import (
 	"github.com/apache/arrow/go/v13/arrow"
 	"github.com/apache/arrow/go/v13/arrow/array"
 	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/exec"
+	"github.com/apache/arrow/go/v13/arrow/compute/exec"
 	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
 	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
 	"github.com/apache/arrow/go/v13/arrow/memory"

From 71329ce33a18a53e322514d0e463677ebad648c9 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 7 Aug 2023 15:22:03 -0400
Subject: [PATCH 100/749] GH-37042: [MATLAB] Implement Feather V1 Writer using
 new MATLAB Interface APIs (#37043)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Now that we've have the basic building blocks for tabular IO in the MATLAB Interface (`Array`, `Schema`, `RecordBatch`), we can implement a Feather V1 writer in terms of the new APIs.

This is the first in a series of pull requests in which we will work on replacing the legacy feather V1 infrastructure with a new implementation that use the MATLAB Interface APIs. A side effect of doing this work is that we can eventually delete a lot of legacy build infrastructure and code.

### What changes are included in this PR?

1. Added a new class called `arrow.internal.io.feather.Writer` which can be used to write feather V1 files. It has one public property named `Filename` and one public method `write`.

Below is an example of its usage:

```matlab
>> T = table([1; 2; 3], single([10; 11; 12]));

T =

  3×2 table

    Var1    Var2
    ____    ____

     1       10
     2       11
     3       12

>> filename = "/tmp/table.feather";
>> writer = arrow.internal.io.feather.Writer(filename)

writer =

  Writer with properties:

    Filename: "/tmp/table.feather"

>> writer.write(T);

```

2. Added an `unwrap` method to `proxy::RecordBatch` so that the `FeatherWriter::write` method can access the underlying `RecordBatch` from the proxy.
3.  Changed the `SetAccess` and `GetAccess` of the `Proxy` property on `arrow.tabular.RecordBatch` to `private` and `public`, respectively.

### Are these changes tested?

Yes, added a new test file called `tRoundTrip.m` in the `matlab/test/arrow/io/feather` folder.

### Are there any user-facing changes?

No.

### Future Directions

1. Add a new class for reading feather V1 files (See #37041).
2. Integrate this class in the public `featherwrite` function.
5. Once this class is integrated with `featherwrite`, we can delete the legacy build infrastructure and source code.
* Closes: #37042

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |  4 +
 .../matlab/io/feather/proxy/feather_writer.cc | 90 +++++++++++++++++++
 .../matlab/io/feather/proxy/feather_writer.h  | 41 +++++++++
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |  2 +
 .../matlab/tabular/proxy/record_batch.cc      |  4 +
 .../arrow/matlab/tabular/proxy/record_batch.h |  2 +
 .../+arrow/+internal/+io/+feather/Writer.m    | 48 ++++++++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  2 +-
 matlab/test/arrow/io/feather/tRoundTrip.m     | 52 +++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |  4 +-
 10 files changed, 247 insertions(+), 2 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h
 create mode 100644 matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
 create mode 100644 matlab/test/arrow/io/feather/tRoundTrip.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index b7c0d7d696d65..e1d2982f282dd 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -180,4 +180,8 @@ namespace arrow::matlab::error {
     static const char* UNKNOWN_PROXY_FOR_ARRAY_TYPE = "arrow:array:UnknownProxyForArrayType";
     static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
     static const char* RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:recordbatch:InvalidNumericColumnIndex";
+    static const char* FAILED_TO_OPEN_FILE_FOR_WRITE = "arrow:io:FailedToOpenFileForWrite";
+    static const char* FEATHER_FAILED_TO_WRITE_TABLE = "arrow:io:feather:FailedToWriteTable";
+    static const char* TABLE_FROM_RECORD_BATCH = "arrow:table:FromRecordBatch";
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc b/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc
new file mode 100644
index 0000000000000..a27e1fb0e623a
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/io/feather/proxy/feather_writer.h"
+#include "arrow/matlab/tabular/proxy/record_batch.h"
+#include "arrow/matlab/error/error.h"
+
+#include "arrow/result.h"
+#include "arrow/table.h"
+#include "arrow/util/utf8.h"
+
+#include "arrow/io/file.h"
+#include "arrow/ipc/feather.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::io::feather::proxy {
+
+    FeatherWriter::FeatherWriter(const std::string& filename) : filename{filename} {
+        REGISTER_METHOD(FeatherWriter, getFilename);
+        REGISTER_METHOD(FeatherWriter, write);
+    }
+
+    libmexclass::proxy::MakeResult FeatherWriter::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::StringArray filename_mda = opts[0]["Filename"];
+
+        const auto filename_utf16 = std::u16string(filename_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR(const auto filename_utf8,
+                               arrow::util::UTF16StringToUTF8(filename_utf16),
+                               error::UNICODE_CONVERSION_ERROR_ID);
+        
+        return std::make_shared<FeatherWriter>(filename_utf8);
+    }
+
+    void FeatherWriter::getFilename(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto utf16_filename,
+                                            arrow::util::UTF8StringToUTF16(filename), 
+                                            context,
+                                            error::UNICODE_CONVERSION_ERROR_ID);
+        mda::ArrayFactory factory;
+        auto str_mda = factory.createScalar(utf16_filename);
+        context.outputs[0] = str_mda;
+    }
+
+    void FeatherWriter::write(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::StructArray opts = context.inputs[0];
+        const mda::TypedArray<uint64_t> record_batch_proxy_id_mda = opts[0]["RecordBatchProxyID"];
+        const uint64_t record_batch_proxy_id = record_batch_proxy_id_mda[0]; 
+
+        auto proxy = libmexclass::proxy::ProxyManager::getProxy(record_batch_proxy_id);
+        auto record_batch_proxy = std::static_pointer_cast<arrow::matlab::tabular::proxy::RecordBatch>(proxy);
+        auto record_batch = record_batch_proxy->unwrap();
+        
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto table, 
+                                            arrow::Table::FromRecordBatches({record_batch}),
+                                            context,
+                                            error::TABLE_FROM_RECORD_BATCH);
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(std::shared_ptr<arrow::io::OutputStream> output_stream,
+                                            arrow::io::FileOutputStream::Open(filename),
+                                            context,
+                                            error::FAILED_TO_OPEN_FILE_FOR_WRITE);
+
+         // Specify the feather file format version as V1
+        arrow::ipc::feather::WriteProperties write_props;
+        write_props.version = arrow::ipc::feather::kFeatherV1Version;
+
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(ipc::feather::WriteTable(*table, output_stream.get(), write_props),
+                                            context,
+                                            error::FEATHER_FAILED_TO_WRITE_TABLE);
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h b/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h
new file mode 100644
index 0000000000000..dadb479887891
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h
@@ -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.
+
+#pragma once
+
+#include "arrow/status.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::io::feather::proxy {
+
+    class FeatherWriter : public libmexclass::proxy::Proxy {
+        public:
+            FeatherWriter(const std::string& filename);
+        
+            ~FeatherWriter() {}
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);  
+        
+        protected:
+            void getFilename(libmexclass::proxy::method::Context& context);
+            void write(libmexclass::proxy::method::Context& context);
+
+        private:
+            const std::string filename; 
+    };
+}
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 7d18c6c6b62a8..7a2a4f3192fa1 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -25,6 +25,7 @@
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/field.h"
+#include "arrow/matlab/io/feather/proxy/feather_writer.h"
 
 #include "factory.h"
 
@@ -60,6 +61,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
     REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
     REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
+    REGISTER_PROXY(arrow.io.feather.proxy.FeatherWriter  , arrow::matlab::io::feather::proxy::FeatherWriter);
 
     return libmexclass::error::Error{error::UNKNOWN_PROXY_ERROR_ID, "Did not find matching C++ proxy for " + class_name};
 };
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index ed30472f6c4a2..e159e926ec5ae 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -56,6 +56,10 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
     }
 
+    std::shared_ptr<arrow::RecordBatch> RecordBatch::unwrap() {
+        return record_batch;
+    }
+
     void RecordBatch::toString(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto utf16_string, arrow::util::UTF8StringToUTF16(record_batch->ToString()), context, error::UNICODE_CONVERSION_ERROR_ID);
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index b5d741060a15d..b8c038816b34e 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -29,6 +29,8 @@ namespace arrow::matlab::tabular::proxy {
         
             virtual ~RecordBatch() {}
 
+            std::shared_ptr<arrow::RecordBatch> unwrap();
+
             static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
     
         protected:
diff --git a/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
new file mode 100644
index 0000000000000..470c41fd5b23c
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
@@ -0,0 +1,48 @@
+%WRITER Class for writing feather V1 files.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef Writer < matlab.mixin.Scalar
+
+    properties(Hidden, SetAccess=private, GetAccess=public)
+        Proxy
+    end
+
+    properties(Dependent)
+        Filename
+    end
+
+    methods
+        function obj = Writer(filename)
+            arguments
+                filename(1, 1) {mustBeNonmissing, mustBeNonzeroLengthText}
+            end
+
+            args = struct(Filename=filename);
+            proxyName = "arrow.io.feather.proxy.FeatherWriter";
+            obj.Proxy = arrow.internal.proxy.create(proxyName, args);
+        end
+
+        function write(obj, T)
+            rb = arrow.recordbatch(T);
+            args = struct(RecordBatchProxyID=rb.Proxy.ID);
+            obj.Proxy.write(args);
+        end
+
+        function filename = get.Filename(obj)
+            filename = obj.Proxy.getFilename();
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 0d002797f0121..be5eee7d89c35 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -23,7 +23,7 @@
         ColumnNames
     end
 
-    properties (Access=protected)
+    properties (Hidden, SetAccess=private, GetAccess=public)
         Proxy
     end
 
diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
new file mode 100644
index 0000000000000..d56152be6d1c8
--- /dev/null
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -0,0 +1,52 @@
+%TROUNDTRIP Round trip tests for feather.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tRoundTrip < matlab.unittest.TestCase
+
+    methods(TestClassSetup)
+        % Delete once arrow.internal.io.feather.Reader is submitted.
+        function addFeatherFunctionsToMATLABPath(testCase)
+            import matlab.unittest.fixtures.PathFixture
+            % Add Feather test utilities to the MATLAB path.
+            testCase.applyFixture(PathFixture('../../../util'));
+            % arrow.cpp.call must be on the MATLAB path.
+            testCase.assertTrue(~isempty(which('arrow.cpp.call')), ...
+                '''arrow.cpp.call'' must be on the MATLAB path. Use ''addpath'' to add folders to the MATLAB path.');
+        end
+    end
+
+    methods(Test)
+        function Basic(testCase)
+            import matlab.unittest.fixtures.TemporaryFolderFixture
+            
+            fixture = testCase.applyFixture(TemporaryFolderFixture);
+            filename = fullfile(fixture.Folder, "temp.feather");
+
+            DoubleVar = [10; 20; 30; 40];
+            SingleVar = single([10; 15; 20; 25]);
+            tWrite = table(DoubleVar, SingleVar);
+            
+            featherwrite(tWrite, filename);
+            tRead = featherread(filename);
+            testCase.verifyEqual(tWrite, tRead);
+        end
+    end
+end
+
+function featherwrite(T, filename)
+    writer = arrow.internal.io.feather.Writer(filename);
+    writer.write(T);
+end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index f4696cfad26ee..1d57999417664 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -55,7 +55,9 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc")
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc")
+
 
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")

From 152be67100cdd367a3e6064988085e3b327ad0fe Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 7 Aug 2023 16:26:16 -0400
Subject: [PATCH 101/749] GH-37041: [MATLAB] Implement Feather V1 Reader using
 new MATLAB Interface APIs (#37044)

### Rationale for this change

Now that we've have the basic building blocks for tabular IO in the MATLAB Interface (Array, Schema, RecordBatch), we can implement a Feather V1 reader in terms of the new APIs.

This is a follow up to #37043, where a new Feather V1 internal `Writer` object was added.

### What changes are included in this PR?

1. Added a new class called arrow.internal.io.feather.Reader which can be used to read Feather V1 files. It has one public property named `Filename` and one public method named `read`.

**Example Usage:**

```matlab
>> T = array2table(rand(3))

T =

  3x3 table

     Var1        Var2       Var3
    _______    ________    _______

    0.79221    0.035712    0.67874
    0.95949     0.84913    0.75774
    0.65574     0.93399    0.74313

>> filename = "test.feather";

>> featherwrite(filename, T)

>> reader = arrow.internal.io.feather.Reader(filename)

reader =

  Reader with properties:

    Filename: "test.feather"

>> T = reader.read()

T =

  3x3 table

     Var1        Var2       Var3
    _______    ________    _______

    0.79221    0.035712    0.67874
    0.95949     0.84913    0.75774
    0.65574     0.93399    0.74313
```

### Are these changes tested?

Yes.

1. Added `Reader` to `feather/tRoundTrip.m`.

### Are there any user-facing changes?

No.

These are only internal objects right now.

### Future Directions

1. Re-implement `featherread` in terms of the new `Reader` object.
2. Remove legacy feather code and infrastructure.

### Notes

1. For conciseness, I renamed the C++ Proxy class `FeatherWriter` to `Writer` since it is already inside of a `feather` namespace / "package".
* Closes: #37041

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |  6 ++
 .../arrow/matlab/io/feather/proxy/reader.cc   | 98 +++++++++++++++++++
 .../arrow/matlab/io/feather/proxy/reader.h    | 39 ++++++++
 .../proxy/{feather_writer.cc => writer.cc}    | 16 +--
 .../proxy/{feather_writer.h => writer.h}      |  6 +-
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |  6 +-
 .../+arrow/+internal/+io/+feather/Reader.m    | 52 ++++++++++
 .../+arrow/+internal/+io/+feather/Writer.m    |  4 +-
 matlab/test/arrow/io/feather/tRoundTrip.m     |  5 +
 .../cmake/BuildMatlabArrowInterface.cmake     |  4 +-
 10 files changed, 219 insertions(+), 17 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.h
 rename matlab/src/cpp/arrow/matlab/io/feather/proxy/{feather_writer.cc => writer.cc} (86%)
 rename matlab/src/cpp/arrow/matlab/io/feather/proxy/{feather_writer.h => writer.h} (89%)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index e1d2982f282dd..deac5e26fc1c0 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -181,7 +181,13 @@ namespace arrow::matlab::error {
     static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
     static const char* RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:recordbatch:InvalidNumericColumnIndex";
     static const char* FAILED_TO_OPEN_FILE_FOR_WRITE = "arrow:io:FailedToOpenFileForWrite";
+    static const char* FAILED_TO_OPEN_FILE_FOR_READ = "arrow:io:FailedToOpenFileForRead";
     static const char* FEATHER_FAILED_TO_WRITE_TABLE = "arrow:io:feather:FailedToWriteTable";
     static const char* TABLE_FROM_RECORD_BATCH = "arrow:table:FromRecordBatch";
+    static const char* FEATHER_FAILED_TO_CREATE_READER = "arrow:io:feather:FailedToCreateReader";
+    static const char* FEATHER_VERSION_2 = "arrow:io:feather:FeatherVersion2";
+    static const char* FEATHER_VERSION_UNKNOWN = "arrow:io:feather:FeatherVersionUnknown";
+    static const char* FEATHER_FAILED_TO_READ_TABLE = "arrow:io:feather:FailedToReadTable";
+    static const char* FEATHER_FAILED_TO_READ_RECORD_BATCH = "arrow:io:feather:FailedToReadRecordBatch";
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
new file mode 100644
index 0000000000000..a264d24ecb1bd
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
@@ -0,0 +1,98 @@
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/io/feather/proxy/reader.h"
+#include "arrow/matlab/tabular/proxy/record_batch.h"
+
+#include "arrow/util/utf8.h"
+
+#include "arrow/result.h"
+
+#include "arrow/io/file.h"
+#include "arrow/ipc/feather.h"
+#include "arrow/table.h"
+
+namespace arrow::matlab::io::feather::proxy {
+
+    Reader::Reader(const std::string& filename) : filename{filename} {
+        REGISTER_METHOD(Reader, read);
+        REGISTER_METHOD(Reader, getFilename);
+    }
+
+    libmexclass::proxy::MakeResult Reader::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using ReaderProxy = arrow::matlab::io::feather::proxy::Reader;
+
+        mda::StructArray args = constructor_arguments[0];
+        const mda::StringArray filename_utf16_mda = args[0]["Filename"];
+        const auto filename_utf16 = std::u16string(filename_utf16_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR(const auto filename, arrow::util::UTF16StringToUTF8(filename_utf16), error::UNICODE_CONVERSION_ERROR_ID);
+
+        return std::make_shared<ReaderProxy>(filename);
+    }
+
+    void Reader::read(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using RecordBatchProxy = arrow::matlab::tabular::proxy::RecordBatch;
+
+        mda::ArrayFactory factory;
+
+        // Create a file input stream.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto source, arrow::io::ReadableFile::Open(filename, arrow::default_memory_pool()), context, error::FAILED_TO_OPEN_FILE_FOR_READ);
+
+        // Create a Reader from the file input stream.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto reader, arrow::ipc::feather::Reader::Open(source), context, error::FEATHER_FAILED_TO_CREATE_READER);
+
+        // Error if not Feather V1.
+        const auto version = reader->version();
+        if (version == ipc::feather::kFeatherV2Version) {
+            MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(Status::NotImplemented("Support for Feather V2 has not been implemented."), context, error::FEATHER_VERSION_2);
+        } else if (version != ipc::feather::kFeatherV1Version) {
+            MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(Status::Invalid("Unknown Feather format version."), context, error::FEATHER_VERSION_UNKNOWN);
+        }
+
+        // Read a Table from the file.
+        std::shared_ptr<arrow::Table> table = nullptr;
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(reader->Read(&table), context, error::FEATHER_FAILED_TO_READ_TABLE);
+
+        // Get the first RecordBatch from the Table.
+        arrow::TableBatchReader table_batch_reader{table};
+        std::shared_ptr<arrow::RecordBatch> record_batch = nullptr;
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(table_batch_reader.ReadNext(&record_batch), context, error::FEATHER_FAILED_TO_READ_RECORD_BATCH);
+
+        // Create a Proxy from the first RecordBatch.
+        auto record_batch_proxy = std::make_shared<RecordBatchProxy>(record_batch);
+        const auto record_batch_proxy_id = ProxyManager::manageProxy(record_batch_proxy);
+
+        const auto record_batch_proxy_id_mda = factory.createScalar(record_batch_proxy_id);
+
+        context.outputs[0] = record_batch_proxy_id_mda;
+    }
+
+    void Reader::getFilename(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto filename_utf16, arrow::util::UTF8StringToUTF16(filename), context, error::UNICODE_CONVERSION_ERROR_ID);
+        auto filename_utf16_mda = factory.createScalar(filename_utf16);
+        context.outputs[0] = filename_utf16_mda;
+    }
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.h b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.h
new file mode 100644
index 0000000000000..fb6c06de8638d
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::io::feather::proxy {
+
+    class Reader : public libmexclass::proxy::Proxy {
+        public:
+            Reader(const std::string& filename);
+
+            virtual ~Reader() {}
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+        protected:
+            void read(libmexclass::proxy::method::Context& context);
+            void getFilename(libmexclass::proxy::method::Context& context);
+
+            const std::string filename;
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc b/matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.cc
similarity index 86%
rename from matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc
rename to matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.cc
index a27e1fb0e623a..c71c9ae7a514e 100644
--- a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/matlab/io/feather/proxy/feather_writer.h"
+#include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/error/error.h"
 
@@ -30,12 +30,12 @@
 
 namespace arrow::matlab::io::feather::proxy {
 
-    FeatherWriter::FeatherWriter(const std::string& filename) : filename{filename} {
-        REGISTER_METHOD(FeatherWriter, getFilename);
-        REGISTER_METHOD(FeatherWriter, write);
+    Writer::Writer(const std::string& filename) : filename{filename} {
+        REGISTER_METHOD(Writer, getFilename);
+        REGISTER_METHOD(Writer, write);
     }
 
-    libmexclass::proxy::MakeResult FeatherWriter::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+    libmexclass::proxy::MakeResult Writer::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
         namespace mda = ::matlab::data;
         mda::StructArray opts = constructor_arguments[0];
         const mda::StringArray filename_mda = opts[0]["Filename"];
@@ -45,10 +45,10 @@ namespace arrow::matlab::io::feather::proxy {
                                arrow::util::UTF16StringToUTF8(filename_utf16),
                                error::UNICODE_CONVERSION_ERROR_ID);
         
-        return std::make_shared<FeatherWriter>(filename_utf8);
+        return std::make_shared<Writer>(filename_utf8);
     }
 
-    void FeatherWriter::getFilename(libmexclass::proxy::method::Context& context) {
+    void Writer::getFilename(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto utf16_filename,
                                             arrow::util::UTF8StringToUTF16(filename), 
@@ -59,7 +59,7 @@ namespace arrow::matlab::io::feather::proxy {
         context.outputs[0] = str_mda;
     }
 
-    void FeatherWriter::write(libmexclass::proxy::method::Context& context) {
+    void Writer::write(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::StructArray opts = context.inputs[0];
         const mda::TypedArray<uint64_t> record_batch_proxy_id_mda = opts[0]["RecordBatchProxyID"];
diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h b/matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.h
similarity index 89%
rename from matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h
rename to matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.h
index dadb479887891..21dc70f432a55 100644
--- a/matlab/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.h
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/writer.h
@@ -23,11 +23,11 @@
 
 namespace arrow::matlab::io::feather::proxy {
 
-    class FeatherWriter : public libmexclass::proxy::Proxy {
+    class Writer : public libmexclass::proxy::Proxy {
         public:
-            FeatherWriter(const std::string& filename);
+            Writer(const std::string& filename);
         
-            ~FeatherWriter() {}
+            ~Writer() {}
 
             static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);  
         
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 7a2a4f3192fa1..bce875bb9f184 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -25,7 +25,8 @@
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/field.h"
-#include "arrow/matlab/io/feather/proxy/feather_writer.h"
+#include "arrow/matlab/io/feather/proxy/writer.h"
+#include "arrow/matlab/io/feather/proxy/reader.h"
 
 #include "factory.h"
 
@@ -61,7 +62,8 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
     REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
     REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
-    REGISTER_PROXY(arrow.io.feather.proxy.FeatherWriter  , arrow::matlab::io::feather::proxy::FeatherWriter);
+    REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
+    REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
 
     return libmexclass::error::Error{error::UNKNOWN_PROXY_ERROR_ID, "Did not find matching C++ proxy for " + class_name};
 };
diff --git a/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m b/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m
new file mode 100644
index 0000000000000..80da7294d2d8d
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m
@@ -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.
+
+classdef Reader
+%READER An internal Reader object for reading Feather files.
+
+    properties (GetAccess=public, SetAccess=private, Hidden)
+        Proxy
+    end
+
+    properties (Dependent, SetAccess=private, GetAccess=public)
+        % Name of the file to read.
+        Filename
+    end
+
+    methods
+
+        function obj = Reader(filename)
+            arguments
+                filename(1, 1) {mustBeNonmissing, mustBeNonzeroLengthText}
+            end
+
+            args = struct(Filename=filename);
+            obj.Proxy = arrow.internal.proxy.create("arrow.io.feather.proxy.Reader", args);
+        end
+
+        function T = read(obj)
+            recordBatchProxyID = obj.Proxy.read();
+            proxy = libmexclass.proxy.Proxy(Name="arrow.tabular.proxy.RecordBatch", ID=recordBatchProxyID);
+            recordBatch = arrow.tabular.RecordBatch(proxy);
+            T = recordBatch.toMATLAB();
+        end
+
+        function filename = get.Filename(obj)
+            filename = obj.Proxy.getFilename();
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
index 470c41fd5b23c..37c785f10a5e3 100644
--- a/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
+++ b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
@@ -31,7 +31,7 @@
             end
 
             args = struct(Filename=filename);
-            proxyName = "arrow.io.feather.proxy.FeatherWriter";
+            proxyName = "arrow.io.feather.proxy.Writer";
             obj.Proxy = arrow.internal.proxy.create(proxyName, args);
         end
 
@@ -45,4 +45,4 @@ function write(obj, T)
             filename = obj.Proxy.getFilename();
         end
     end
-end
\ No newline at end of file
+end
diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
index d56152be6d1c8..e735d196c1875 100644
--- a/matlab/test/arrow/io/feather/tRoundTrip.m
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -49,4 +49,9 @@ function Basic(testCase)
 function featherwrite(T, filename)
     writer = arrow.internal.io.feather.Writer(filename);
     writer.write(T);
+end
+
+function T = featherread(filename)
+    reader = arrow.internal.io.feather.Reader(filename);
+    T = reader.read();
 end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 1d57999417664..c19740f181444 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -56,8 +56,8 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/feather_writer.cc")
-
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/reader.cc")
 
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")

From f549bf52d55228298e9007fe0f3640daa70f5dd6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 05:30:13 +0900
Subject: [PATCH 102/749] MINOR: [C#] Bump xunit.runner.visualstudio from 2.4.0
 to 2.5.0 in /csharp (#36728)

Bumps [xunit.runner.visualstudio](https://github.com/xunit/visualstudio.xunit) from 2.4.0 to 2.5.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/xunit/visualstudio.xunit/releases">xunit.runner.visualstudio's releases</a>.</em></p>
<blockquote>
<h2>v2.4.5</h2>
<h2>Changes:</h2>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/308">#308</a>: Downgrade xunit.runner.vs to net462</li>
</ul>
<p>This list of changes was <a href="https://dev.azure.com/dotnet/fe18572b-d1ba-496a-9e95-1af3bc3df99b/_release?releaseId=178&amp;_a=release-summary">auto generated</a>.</p>
<h2>v2.4.4</h2>
<h2>Changes:</h2>
<h3>Bugs:</h3>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/292">#292</a>: Fixing a hang in test discovery</li>
</ul>
<h3>Others:</h3>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/304">#304</a>: Update xunit version to 2.4.2-pre.12</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/297">#297</a>: Bump NSubstitute from 4.2.2 to 4.3.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/294">#294</a>: Bump Microsoft.NET.Test.Sdk from 16.10.0 to 17.0.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/293">#293</a>: Bump Nerdbank.GitVersioning from 3.4.231 to 3.4.255</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/296">#296</a>: Bump Microsoft.NETCore.UniversalWindowsPlatform from 6.2.12 to 6.2.13</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/299">#299</a>: Bump MSBuild.Sdk.Extras from 3.0.23 to 3.0.44</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/270">#270</a>: Upgrade to GitHub-native Dependabot</li>
</ul>

<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/281">#281</a>: Bump Nerdbank.GitVersioning from 3.4.228 to 3.4.231</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/280">#280</a>: Bump Nerdbank.GitVersioning from 3.4.220 to 3.4.228</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/277">#277</a>: Bump Nerdbank.GitVersioning from 3.4.216 to 3.4.220</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/275">#275</a>: Bump Nerdbank.GitVersioning from 3.4.205 to 3.4.216</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/274">#274</a>: Bump Nerdbank.GitVersioning from 3.4.203 to 3.4.205</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/273">#273</a>: Bump Microsoft.NET.Test.Sdk from 16.9.4 to 16.10.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/272">#272</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.9.4 to 16.10.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/271">#271</a>: Bump Nerdbank.GitVersioning from 3.4.194 to 3.4.203</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/268">#268</a>: Bump Nerdbank.GitVersioning from 3.4.190 to 3.4.194</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/267">#267</a>: Bump Nerdbank.GitVersioning from 3.3.37 to 3.4.190</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/265">#265</a>: Bump Microsoft.NET.Test.Sdk from 16.9.1 to 16.9.4</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/264">#264</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.9.1 to 16.9.4</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/260">#260</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.8.3 to 16.9.1</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/261">#261</a>: Bump Microsoft.NET.Test.Sdk from 16.8.3 to 16.9.1</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/258">#258</a>: Bump Microsoft.NETCore.UniversalWindowsPlatform from 6.2.11 to 6.2.12</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/256">#256</a>: Bump MSBuild.Sdk.Extras from 3.0.22 to 3.0.23</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/255">#255</a>: Bump MSBuild.Sdk.Extras from 2.1.2 to 3.0.22</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/254">#254</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.8.0 to 16.8.3</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/xunit/visualstudio.xunit/commits/2.5.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit.runner.visualstudio&package-manager=nuget&previous-version=2.4.0&new-version=2.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 7c1f3a77a4c18..145865a2df46a 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 2b150955d02b7..cd42bc9d1724e 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="1.2.0" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 805fb5ab3acce..981c359cab174 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -12,7 +12,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
     <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

From e90c3160301351d68e19c5f76f001ba5cc71bdfb Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 7 Aug 2023 16:38:43 -0400
Subject: [PATCH 103/749] GH-37045: [MATLAB] Implement featherwrite in terms of
 arrow.internal.io.feather.Writer (#37047)

### Rationale for this change

Now that #37043 is merged, we can re-implement `featherwrite` in terms of the new `arrow.internal.io.feather.Writer` class. Once this change is made, we can delete the legacy build infrastructure and featherwrite MEX code.

### What changes are included in this PR?

1. Re-implemented `featherwrite` using `arrow.internal.io.feather.Writer`.

### Are these changes tested?

1. Yes, the existing tests in `tfeather.m` cover these changes.
2. I had to update some of the expected error message IDs in `tfeather.m` because the new implementation throws errors with different IDs.
3. `featherwrite` used to export the real part of MATLAB complex numeric arrays. The new version of `featherwrite` now errors if the input table contains complex data because feather/Arrow itself does not support complex numeric data. We think this is the right decision. Writing out only the real part is lossy.

### Are there any user-facing changes?

Yes, `featherwrite` no longer supports writing complex numeric arrays.

### Future Directions

1. Once this PR is merged, we will remove the legacy build infrastructure and MEX code.
* Closes: #37045

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/featherwrite.m | 22 ++++++----------------
 matlab/test/tfeather.m           | 11 +++++------
 2 files changed, 11 insertions(+), 22 deletions(-)

diff --git a/matlab/src/matlab/featherwrite.m b/matlab/src/matlab/featherwrite.m
index c59f7f42368eb..cc3f45e954ad8 100644
--- a/matlab/src/matlab/featherwrite.m
+++ b/matlab/src/matlab/featherwrite.m
@@ -23,21 +23,11 @@ function featherwrite(filename, t)
 % specific language governing permissions and limitations
 % under the License.
 
-import arrow.util.table2mlarrow;
+    arguments
+        filename(1, 1) string {mustBeNonmissing, mustBeNonzeroLengthText}
+        t table
+    end
 
-% Validate input arguments.
-narginchk(2, 2);
-filename = convertStringsToChars(filename);
-if ~ischar(filename)
-    error('MATLAB:arrow:InvalidFilenameDatatype', ...
-        'Filename must be a character vector or string scalar.');
-end
-if ~istable(t)
-    error('MATLAB:arrow:InvalidInputTable', 't must be a table.');
-end
-
-[variables, metadata] = table2mlarrow(t);
-
-% Write the table to a Feather file.
-arrow.cpp.call('featherwrite', filename, variables, metadata);
+    writer = arrow.internal.io.feather.Writer(filename);
+    writer.write(t);
 end
diff --git a/matlab/test/tfeather.m b/matlab/test/tfeather.m
index a32b78fdcd671..e4c988e1dda49 100755
--- a/matlab/test/tfeather.m
+++ b/matlab/test/tfeather.m
@@ -164,7 +164,7 @@ function ErrorIfInvalidFilenameDatatype(testCase)
             
             t = createTable;
             
-            testCase.verifyError(@() featherwrite({filename}, t), 'MATLAB:arrow:InvalidFilenameDatatype');
+            testCase.verifyError(@() featherwrite({table}, t), 'MATLAB:validation:UnableToConvert');
             testCase.verifyError(@() featherread({filename}), 'MATLAB:arrow:InvalidFilenameDatatype');
         end
 
@@ -178,7 +178,7 @@ function ErrorIfTooManyInputs(testCase)
         end
 
         function ErrorIfTooFewInputs(testCase)
-            testCase.verifyError(@() featherwrite(), 'MATLAB:narginchk:notEnoughInputs');
+            testCase.verifyError(@() featherwrite(), 'MATLAB:minrhs');
             testCase.verifyError(@() featherread(), 'MATLAB:narginchk:notEnoughInputs');
         end
         
@@ -193,7 +193,7 @@ function ErrorIfMultiColVarExist(testCase)
             
             t = table(age, smoker, height, weight, bloodPressure);
             
-            testCase.verifyError(@() featherwrite(filename, t), 'MATLAB:arrow:UnsupportedVariableType');
+            testCase.verifyError(@() featherwrite(filename, t), 'arrow:array:InvalidShape');
         end
         
         function UnsupportedMATLABDatatypes(testCase)
@@ -205,7 +205,7 @@ function UnsupportedMATLABDatatypes(testCase)
                                         calendarDuration(5, 3, 2)];
             actualTable = addvars(actualTable, calendarDurationVariable);
 
-            testCase.verifyError(@() featherwrite(filename, actualTable) ,'MATLAB:arrow:UnsupportedVariableType');
+            testCase.verifyError(@() featherwrite(filename, actualTable) ,'arrow:array:UnsupportedMATLABType');
         end
         
         function NumericComplexUnsupported(testCase)
@@ -216,8 +216,7 @@ function NumericComplexUnsupported(testCase)
             actualTable.double(2) = exp(9) + 5i;
             actualTable.int64(2) = 1.0418e+03;
            
-            expectedTable = featherRoundTrip(filename, actualTable);
-            testCase.verifyNotEqual(actualTable, expectedTable);
+            testCase.verifyError(@() featherwrite(filename, actualTable) ,'arrow:array:ComplexNumeric');
         end
     end
 end

From f055f5e554020c10c343249e95b940a751eb3239 Mon Sep 17 00:00:00 2001
From: Thomas Newton <thomas.w.newton@gmail.com>
Date: Mon, 7 Aug 2023 21:48:29 +0100
Subject: [PATCH 104/749] GH-36886: [C++] Configure `azurite` in preparation
 for testing Azure C++ filesystem (#36988)

### Rationale for this change
We need to write tests for https://github.com/apache/arrow/issues/18014. azurite is like a fake Azure blob storage so it can be used to write integration tests

### What changes are included in this PR?
Extract the `azurite` related changes from https://github.com/apache/arrow/pull/12914 to create a smaller PR that's easier to review. I have made very minimal changes compared to that PR.

Currently `azurite` is configured for all the environments where `ARROW_AZURE` was enabled by https://github.com/apache/arrow/pull/35701. I assume its deliberate that its not enabled yet for windows, alpine, conda, debian or fedora builds.

### Are these changes tested?
Its tested by there aren't really any good tests in this PR. I used this `azurite` config in https://github.com/apache/arrow/pull/36835 to make an integration test that uses the Azure C++ SDK. On its own we can't really write tests for this `azurite` setup PR.

### Are there any user-facing changes?
No

* Closes: #36886

Lead-authored-by: Thomas Newton <thomas.w.newton@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/cpp.yml                |  4 ++
 ci/docker/ubuntu-20.04-cpp.dockerfile    |  4 ++
 ci/docker/ubuntu-22.04-cpp.dockerfile    |  4 ++
 ci/scripts/install_azurite.sh            | 37 +++++++++++
 cpp/Brewfile                             |  1 +
 cpp/src/arrow/filesystem/azurefs_test.cc | 82 +++++++++++++++++++++++-
 6 files changed, 131 insertions(+), 1 deletion(-)
 create mode 100755 ci/scripts/install_azurite.sh

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index cd12be11488bb..eaccf25403eba 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -23,6 +23,7 @@ on:
       - '.github/workflows/cpp.yml'
       - 'ci/docker/**'
       - 'ci/scripts/cpp_*'
+      - 'ci/scripts/install_azurite.sh'
       - 'ci/scripts/install_gcs_testbench.sh'
       - 'ci/scripts/install_minio.sh'
       - 'ci/scripts/msys2_*'
@@ -34,6 +35,7 @@ on:
       - '.github/workflows/cpp.yml'
       - 'ci/docker/**'
       - 'ci/scripts/cpp_*'
+      - 'ci/scripts/install_azurite.sh'
       - 'ci/scripts/install_gcs_testbench.sh'
       - 'ci/scripts/install_minio.sh'
       - 'ci/scripts/msys2_*'
@@ -201,6 +203,8 @@ jobs:
             ci/scripts/install_minio.sh latest /usr/local
       - name: Install Google Cloud Storage Testbench
         run: ci/scripts/install_gcs_testbench.sh default
+      - name: Install Azurite Storage Emulator
+        run: ci/scripts/install_azurite.sh
       - name: Setup ccache
         run: |
           ci/scripts/ccache_setup.sh
diff --git a/ci/docker/ubuntu-20.04-cpp.dockerfile b/ci/docker/ubuntu-20.04-cpp.dockerfile
index f94494177e8ee..125f1f48d482e 100644
--- a/ci/docker/ubuntu-20.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp.dockerfile
@@ -103,6 +103,7 @@ RUN apt-get update -y -q && \
         make \
         ninja-build \
         nlohmann-json3-dev \
+        npm \
         pkg-config \
         protobuf-compiler \
         python3-dev \
@@ -123,6 +124,9 @@ RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
+COPY ci/scripts/install_azurite.sh /arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_azurite.sh
+
 COPY ci/scripts/install_ceph.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_ceph.sh
 
diff --git a/ci/docker/ubuntu-22.04-cpp.dockerfile b/ci/docker/ubuntu-22.04-cpp.dockerfile
index e773c6f1ee659..0840b3fa5c68d 100644
--- a/ci/docker/ubuntu-22.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-22.04-cpp.dockerfile
@@ -102,6 +102,7 @@ RUN apt-get update -y -q && \
         make \
         ninja-build \
         nlohmann-json3-dev \
+        npm \
         pkg-config \
         protobuf-compiler \
         protobuf-compiler-grpc \
@@ -153,6 +154,9 @@ RUN /arrow/ci/scripts/install_minio.sh latest /usr/local
 COPY ci/scripts/install_gcs_testbench.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_gcs_testbench.sh default
 
+COPY ci/scripts/install_azurite.sh /arrow/ci/scripts/
+RUN /arrow/ci/scripts/install_azurite.sh
+
 COPY ci/scripts/install_sccache.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_sccache.sh unknown-linux-musl /usr/local/bin
 
diff --git a/ci/scripts/install_azurite.sh b/ci/scripts/install_azurite.sh
new file mode 100755
index 0000000000000..2e7008360fdc3
--- /dev/null
+++ b/ci/scripts/install_azurite.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -e
+
+case "$(uname)" in
+  Darwin)
+    npm install -g azurite
+    which azurite
+    ;;
+  MINGW*)
+    choco install nodejs.install
+    npm install -g azurite
+    ;;
+  Linux)
+    npm install -g azurite
+    which azurite
+    ;;
+esac
+echo "node version = $(node --version)"
+echo "azurite version = $(azurite --version)"
\ No newline at end of file
diff --git a/cpp/Brewfile b/cpp/Brewfile
index 580e8d3f115d5..58015d2121b5b 100644
--- a/cpp/Brewfile
+++ b/cpp/Brewfile
@@ -30,6 +30,7 @@ brew "grpc"
 brew "llvm@14"
 brew "lz4"
 brew "ninja"
+brew "node"
 brew "openssl@3"
 brew "protobuf"
 brew "python"
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index 0f03e88393aeb..e940c5bd1bc32 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -15,7 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <algorithm>  // Missing include in boost/process
+
+// This boost/asio/io_context.hpp include is needless for no MinGW
+// build.
+//
+// This is for including boost/asio/detail/socket_types.hpp before any
+// "#include <windows.h>". boost/asio/detail/socket_types.hpp doesn't
+// work if windows.h is already included. boost/process.h ->
+// boost/process/args.hpp -> boost/process/detail/basic_cmd.hpp
+// includes windows.h. boost/process/args.hpp is included before
+// boost/process/async.h that includes
+// boost/asio/detail/socket_types.hpp implicitly is included.
+#include <boost/asio/io_context.hpp>
+// We need BOOST_USE_WINDOWS_H definition with MinGW when we use
+// boost/process.hpp. See BOOST_USE_WINDOWS_H=1 in
+// cpp/cmake_modules/ThirdpartyToolchain.cmake for details.
+#include <boost/process.hpp>
+
 #include "arrow/filesystem/azurefs.h"
+#include "arrow/util/io_util.h"
 
 #include <gmock/gmock-matchers.h>
 #include <gmock/gmock-more-matchers.h>
@@ -27,15 +46,76 @@
 #include "arrow/testing/util.h"
 
 namespace arrow {
+using internal::TemporaryDir;
 namespace fs {
 namespace {
+namespace bp = boost::process;
 
 using ::testing::IsEmpty;
 using ::testing::Not;
 using ::testing::NotNull;
 
-// Placeholder test for file structure
+class AzuriteEnv : public ::testing::Environment {
+ public:
+  AzuriteEnv() {
+    account_name_ = "devstoreaccount1";
+    account_key_ =
+        "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/"
+        "KBHBeksoGMGw==";
+    auto exe_path = bp::search_path("azurite");
+    if (exe_path.empty()) {
+      auto error = std::string("Could not find Azurite emulator.");
+      status_ = Status::Invalid(error);
+      return;
+    }
+    auto temp_dir_ = *TemporaryDir::Make("azurefs-test-");
+    server_process_ = bp::child(boost::this_process::environment(), exe_path, "--silent",
+                                "--location", temp_dir_->path().ToString(), "--debug",
+                                temp_dir_->path().ToString() + "/debug.log");
+    if (!(server_process_.valid() && server_process_.running())) {
+      auto error = "Could not start Azurite emulator.";
+      server_process_.terminate();
+      server_process_.wait();
+      status_ = Status::Invalid(error);
+      return;
+    }
+    status_ = Status::OK();
+  }
+
+  ~AzuriteEnv() override {
+    server_process_.terminate();
+    server_process_.wait();
+  }
+
+  const std::string& account_name() const { return account_name_; }
+  const std::string& account_key() const { return account_key_; }
+  const Status status() const { return status_; }
+
+ private:
+  std::string account_name_;
+  std::string account_key_;
+  bp::child server_process_;
+  Status status_;
+  std::unique_ptr<TemporaryDir> temp_dir_;
+};
+
+auto* azurite_env = ::testing::AddGlobalTestEnvironment(new AzuriteEnv);
+
+AzuriteEnv* GetAzuriteEnv() {
+  return ::arrow::internal::checked_cast<AzuriteEnv*>(azurite_env);
+}
+
+// Placeholder tests for file structure
 // TODO: GH-18014 Remove once a proper test is added
+TEST(AzureFileSystem, InitialiseAzurite) {
+  const std::string& account_name = GetAzuriteEnv()->account_name();
+  const std::string& account_key = GetAzuriteEnv()->account_key();
+  EXPECT_EQ(account_name, "devstoreaccount1");
+  EXPECT_EQ(account_key,
+            "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/"
+            "K1SZFPTOtr/KBHBeksoGMGw==");
+}
+
 TEST(AzureFileSystem, OptionsCompare) {
   AzureOptions options;
   EXPECT_TRUE(options.Equals(options));

From 3937fdb5eefdf0b987dd4672a6051a1837c5fd05 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 05:51:37 +0900
Subject: [PATCH 105/749] MINOR: [C#] Bump BenchmarkDotNet.Diagnostics.Windows
 from 0.13.5 to 0.13.7 in /csharp (#37035)

Bumps [BenchmarkDotNet.Diagnostics.Windows](https://github.com/dotnet/BenchmarkDotNet) from 0.13.5 to 0.13.7.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet.Diagnostics.Windows's releases</a>.</em></p>
<blockquote>
<h2>BenchmarkDotNet v0.13.7</h2>
<p>This release contains a bunch of important bug fixes.</p>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.7.html">https://benchmarkdotnet.org/changelog/v0.13.7.html</a></p>
<h2>BenchmarkDotNet v0.13.6</h2>
<h2>Highlights</h2>
<ul>
<li>New <a href="https://www.nuget.org/packages/BenchmarkDotNet.Diagnostics.dotTrace">BenchmarkDotNet.Diagnostics.dotTrace</a> NuGet package. Once this package is installed, you can annotate your benchmarks with the <code>[DotTraceDiagnoser]</code> and get a <a href="https://www.jetbrains.com/profiler/">dotTrace</a> performance snapshot at the end of the benchmark run. <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2328">#2328</a></li>
<li>Updated documentation website. We migrated to <a href="https://dotnet.github.io/docfx/">docfx</a> 2.67 and got the refreshed modern template based on bootstrap 5 with dark/light theme switcher.</li>
<li>Updated <a href="https://www.nuget.org/packages/BenchmarkDotNet.Templates">BenchmarkDotNet.Templates</a>. Multiple issues were resolved, now you can create new benchmark projects from terminal or your favorite IDE. <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/1658">#1658</a> <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/1881">#1881</a> <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2149">#2149</a> <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2338">#2338</a></li>
<li>Response file support. Now it's possible to pass additional arguments to BenchmarkDotNet using <code>@ filename</code> syntax. <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2320">#2320</a> <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2348">#2348</a></li>
<li>Custom runtime support. <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2285">#2285</a></li>
<li>Introduce CategoryDiscoverer, see <a href="https://github.com/dotnet/BenchmarkDotNet/blob/HEAD/xref:BenchmarkDotNet.Samples.IntroCategoryDiscoverer"><code>IntroCategoryDiscoverer</code></a>. <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2306">#2306</a> <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2307">#2307</a></li>
<li>Multiple bug fixes.</li>
</ul>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.6.html">https://benchmarkdotnet.org/changelog/v0.13.6.html</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c02aeaa23cc4a7d4c3bda367a659580d5340ee93"><code>c02aeaa</code></a> Prepare v0.13.7 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/fd5b76691505d53f3e934f8502629c006539e82c"><code>fd5b766</code></a> Fix PlatformNotSupportedException thrown on Android in ConsoleTitler (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2390">#2390</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/914ee7187340761594728497a9f0163a1ecddf67"><code>914ee71</code></a> perfcollect: don't restore symbols for local builds (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2384">#2384</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/90ef2aecd0bd0c2b935975999053e20d9cdaae74"><code>90ef2ae</code></a> Fix debug build (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2385">#2385</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/657342284766bbf72bd3fa91eec5aca12b73bf27"><code>6573422</code></a> Bump xUnit: 2.4.2-&gt;2.5.0</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/da02fdc4da2799d0a6ba520a97bbb3a7f234420a"><code>da02fdc</code></a> Upgrade setup-node in spellcheck-docs workflow</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/a89ad265c107dd4fd9a7eba1b020ad6d48d87094"><code>a89ad26</code></a> Fix path in dotnet nuget push command</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/dc365e1cf06089d8cca7b4cb7c98b4b402c14681"><code>dc365e1</code></a> Add snupkg to nightly workflow artifacts</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/b912a8e70273761fd468a35c9176be0e50f7ed31"><code>b912a8e</code></a> Code cleanup</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/f8ab51870b9a3d5493a861bc395fea9a0a6ace27"><code>f8ab518</code></a> Enable nullable annotations for the whole solution</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.5...v0.13.7">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet.Diagnostics.Windows&package-manager=nuget&previous-version=0.13.5&new-version=0.13.7)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Lead-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index 06f42ac1c66ee..a81fc15bae861 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -6,8 +6,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.5" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.7" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.7" />
   </ItemGroup>
 
   <ItemGroup>

From 3fdd78d7be4678e0806f688de518f508210da1cb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 05:52:16 +0900
Subject: [PATCH 106/749] MINOR: [C#] Bump coverlet.collector from 1.2.0 to
 6.0.0 in /csharp (#36596)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [coverlet.collector](https://github.com/coverlet-coverage/coverlet) from 1.2.0 to 6.0.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/coverlet-coverage/coverlet/releases">coverlet.collector's releases</a>.</em></p>
<blockquote>
<h2>v6.0.0</h2>
<p>Fixed
-Could not write lines to file CoverletSourceRootsMapping - in use by another process <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1155">coverlet-coverage/coverlet#1155</a><br />
-Incorrect coverage for methods returning IAsyncEnumerable in generic classes <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1383">coverlet-coverage/coverlet#1383</a><br />
-Wrong branch coverage for async methods .NET Standard 1.x <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1376">coverlet-coverage/coverlet#1376</a><br />
-Empty path exception in visual basic projects <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/775">coverlet-coverage/coverlet#775</a><br />
-Align published nuget package version to github release version <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1413">coverlet-coverage/coverlet#1413</a><br />
-Sync nuget and github release versions <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1122">coverlet-coverage/coverlet#1122</a></p>
<p>Improvements
-Migration of the project to .NET 6.0 <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1473">coverlet-coverage/coverlet#1473</a></p>
<p>Breaking changes
New parameter ExcludeAssembliesWithoutSources to control automatic assembly exclusion <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1164">coverlet-coverage/coverlet#1164</a>. The parameter InstrumentModulesWithoutLocalSources has been removed. since it can be handled by setting ExcludeAssembliesWithoutSources to None.
The default heuristics for determining whether to instrument an assembly has been changed. In previous versions any missing source file was taken as a signal that it was a third-party project that shouldn't be instrumented, with exceptions for some common file name patterns for source generators. Now only assemblies where no source files at all can be found are excluded from instrumentation, and the code for detecting source generator files have been removed. To get back to the behaviour that at least one missing file is sufficient to exclude an assembly, set ExcludeAssembliesWithoutSources to MissingAny, or use assembly exclusion filters for more fine-grained control.</p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.2...v6.0.0">Diff between 3.2.0 and 6.0.0</a></p>
<h2>v5.8.0</h2>
<h3>Fixed</h3>
<p>-Fix TypeLoadException when referencing Microsoft.Extensions.DependencyInjection v6.0.1 <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1390">#1390</a><br />
-Source Link for code generators fails <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1322">#1322</a><br />
-Await foreach has wrong branch coverage when method is generic <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1210">#1210</a><br />
-ExcludeFromCodeCoverage attribute on local functions ignores lambda expression <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1302">#1302</a></p>
<h3>Added</h3>
<p>-Added InstrumentModulesWithoutLocalSources setting <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1360">#1360</a> by <a href="https://github.com/TFTomSun"><code>@​TFTomSun</code></a></p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.2...v5.8.0">Diff between 3.1.2 and 3.2.0</a></p>
<h2>v5.7.2</h2>
<p>Fixed
-Fix CoreLib's coverage measurement is broken <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1286">#1286</a>
-Fix UnloadModule injection <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1291">1291</a></p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.1...v5.7.2">Diff between 3.1.1 and 3.1.2</a></p>
<h2>v5.7.1</h2>
<p>Fixed
-Fix wrong branch coverage with EnumeratorCancellation attribute <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1275">#1275</a> -Fix negative coverage exceeding int.MaxValue <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1266">#1266</a>
-Fix summary output format for culture de-DE <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1263">#1263</a>
-Fix branch coverage issue for finally block with await <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1233">#1233</a>
-Fix threshold doesn't work when coverage empty <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1205">#1205</a>
-Fix branch coverage issue for il switch <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1177">#1177</a>
-Fix branch coverage with using statement and several awaits#1176
-Fix CopyCoverletDataCollectorFiles to avoid to override user dlls for dotnet publish scenario <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1243">#1243</a></p>
<p>Improvements
-Improve logging in case of exception inside static ctor of NetstandardAwareAssemblyResolver <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1230">#1230</a>
-When collecting open the hitfile with read access <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1214">#1214</a> by <a href="https://github.com/JamesWTruher">https://github.com/JamesWTruher</a></p>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/6427ae3c87494fc04e576bd367c22153f92699fd"><code>6427ae3</code></a> Rebrand for next version 6.0.1 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1478">#1478</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/b288808ee73c87f34b2e4b0871931674be729ea8"><code>b288808</code></a> Prepare release 6.0.0 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1477">#1477</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/4e58654ee6ec406ca8a46b0f3bc7a2f699616e19"><code>4e58654</code></a> Bump Mono.Cecil (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1476">#1476</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/98b84d207558a08f60dff58f99b2afe69ca72b64"><code>98b84d2</code></a> migration to .net 6.0 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1473">#1473</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/d93613826b1a33f894b9c80f6ae893643a8b7254"><code>d936138</code></a> Fixes CoverletSourceRootsMapping issue (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1456">#1456</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/3bbe50284571b9ae4f3a0f8a08bd66013adb2177"><code>3bbe502</code></a> Update collector docs with info about passing format without runsettings file...</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/a014bf0cd0fdb5a65a24df393d254ae98f7f45f9"><code>a014bf0</code></a> Path is empty for VB My namespace (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1073">#1073</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/1ff097d22c640a45b65e52156d4a1e3202a53f4a"><code>1ff097d</code></a> Wrong branch coverage for async methods .NET Standard 1.x  (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1433">#1433</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/04b82c23d8e2f5a37ff3f0648dc1aea120859332"><code>04b82c2</code></a> Incorrect coverage for methods returning IAsyncEnumerable in generic classes ...</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/72d5ee289f859f18c20e70885e52797af09ccd63"><code>72d5ee2</code></a> Large CC XML error (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1428">#1428</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/coverlet-coverage/coverlet/compare/v1.2.0...v6.0.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=coverlet.collector&package-manager=nuget&previous-version=1.2.0&new-version=6.0.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index cd42bc9d1724e..26ab18ca7d6ae 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -9,7 +9,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
     <PackageReference Include="xunit" Version="2.4.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
-    <PackageReference Include="coverlet.collector" Version="1.2.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
 
   <ItemGroup>

From ceef8bbad4206af187ef2843254c135722076e32 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 05:53:50 +0900
Subject: [PATCH 107/749] MINOR: [C#] Bump Microsoft.SourceLink.GitHub from
 1.0.0 to 1.1.1 in /csharp (#37037)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.SourceLink.GitHub](https://github.com/dotnet/sourcelink) from 1.0.0 to 1.1.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/sourcelink/releases">Microsoft.SourceLink.GitHub's releases</a>.</em></p>
<blockquote>
<h2>1.1.1</h2>
<h2>Notable Changes</h2>
<ul>
<li>Feature: GitWeb Source Link provider by <a href="https://github.com/Glen-Nicol-Garmin"><code>@​Glen-Nicol-Garmin</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/505">dotnet/sourcelink#505</a></li>
<li>Use submodule.name.url to determine the URL of a submodule by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/587">dotnet/sourcelink#587</a></li>
<li>Add Microsoft.SourceLink.Tools source package implementing SourceLinkMap by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/663">dotnet/sourcelink#663</a></li>
<li>Added support for gitea by <a href="https://github.com/Mik4sa"><code>@​Mik4sa</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/674">dotnet/sourcelink#674</a></li>
<li>Enable source-build with Arcade SDK fixes by <a href="https://github.com/dagood"><code>@​dagood</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/692">dotnet/sourcelink#692</a></li>
<li>Add netstandard2.0 target to tools package by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/702">dotnet/sourcelink#702</a></li>
<li>Update license to MIT by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/730">dotnet/sourcelink#730</a></li>
<li>Allow using .git directory instead of gitdir redirect in submodules. by <a href="https://github.com/crummel"><code>@​crummel</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/653">dotnet/sourcelink#653</a></li>
<li>Fix discovery of working directory for worktrees by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/734">dotnet/sourcelink#734</a></li>
<li>Add support for the new GitLab raw url by <a href="https://github.com/rgl"><code>@​rgl</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/713">dotnet/sourcelink#713</a></li>
<li>Target netcoreapp3.1 by <a href="https://github.com/tmat"><code>@​tmat</code></a> in <a href="https://redirect.github.com/dotnet/sourcelink/pull/767">dotnet/sourcelink#767</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/Glen-Nicol-Garmin"><code>@​Glen-Nicol-Garmin</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/505">dotnet/sourcelink#505</a></li>
<li><a href="https://github.com/IgorKustov-ChathamFinancial"><code>@​IgorKustov-ChathamFinancial</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/592">dotnet/sourcelink#592</a></li>
<li><a href="https://github.com/v-chmart"><code>@​v-chmart</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/604">dotnet/sourcelink#604</a></li>
<li><a href="https://github.com/0xced"><code>@​0xced</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/668">dotnet/sourcelink#668</a></li>
<li><a href="https://github.com/nycdotnet"><code>@​nycdotnet</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/672">dotnet/sourcelink#672</a></li>
<li><a href="https://github.com/Mik4sa"><code>@​Mik4sa</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/674">dotnet/sourcelink#674</a></li>
<li><a href="https://github.com/rgl"><code>@​rgl</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/713">dotnet/sourcelink#713</a></li>
<li><a href="https://github.com/adiaaida"><code>@​adiaaida</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/sourcelink/pull/737">dotnet/sourcelink#737</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/dotnet/sourcelink/compare/1.0.0...1.1.1">https://github.com/dotnet/sourcelink/compare/1.0.0...1.1.1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/sourcelink/commit/3539d92ff8bd5ddc3277f94bf3d1e04818c3d0ab"><code>3539d92</code></a> Target netcoreapp3.1 (<a href="https://redirect.github.com/dotnet/sourcelink/issues/767">#767</a>)</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/5a04f8357081dd8516ae94001854389291de12b1"><code>5a04f83</code></a> Update to dotnet 6.0.100 (<a href="https://redirect.github.com/dotnet/sourcelink/issues/762">#762</a>)</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/2f44d40f8741b3cef2ca41dc8e3aa3fd725faa29"><code>2f44d40</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20211105.2 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/02a36d32650b2dbeabb3f5fb318461557c89014d"><code>02a36d3</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20211029.1 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/f1c51e30ad82be66c94f623d660bb0a6451970c2"><code>f1c51e3</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20211024.1 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/437c4a745607a91e6f5e7801fd2949ffbef4e992"><code>437c4a7</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20211018.1 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/a3b0464ac52e6f435a4323ceabdd9107a13d8283"><code>a3b0464</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20211008.1 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/8031e5220baf2acad991e661d8308b783d2acf3e"><code>8031e52</code></a> Switch to 1ES R&amp;D pools on main (<a href="https://redirect.github.com/dotnet/sourcelink/issues/754">#754</a>)</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/91411fc2c299817f7fdaccebae49cb516ea93bb6"><code>91411fc</code></a> Update dependencies from <a href="https://github.com/dotnet/arcade">https://github.com/dotnet/arcade</a> build 20210924.2 (#...</li>
<li><a href="https://github.com/dotnet/sourcelink/commit/76dead04f4f2774e23e70b093a4fd618fc01b7ff"><code>76dead0</code></a> Update README.md (<a href="https://redirect.github.com/dotnet/sourcelink/issues/752">#752</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/sourcelink/compare/1.0.0...1.1.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.SourceLink.GitHub&package-manager=nuget&previous-version=1.0.0&new-version=1.1.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow/Apache.Arrow.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow/Apache.Arrow.csproj b/csharp/src/Apache.Arrow/Apache.Arrow.csproj
index 43d60ba0012ac..b05533c26b22c 100644
--- a/csharp/src/Apache.Arrow/Apache.Arrow.csproj
+++ b/csharp/src/Apache.Arrow/Apache.Arrow.csproj
@@ -16,7 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>

From 56c1f3e14e4e77c927b6227291cfb794df0a0655 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 05:55:16 +0900
Subject: [PATCH 108/749] MINOR: [JS] Bump word-wrap from 1.2.3 to 1.2.4 in /js
 (#36761)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [word-wrap](https://github.com/jonschlinkert/word-wrap) from 1.2.3 to 1.2.4.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/jonschlinkert/word-wrap/releases">word-wrap's releases</a>.</em></p>
<blockquote>
<h2>1.2.4</h2>
<h2>What's Changed</h2>
<ul>
<li>Remove default indent by <a href="https://github.com/mohd-akram"><code>@​mohd-akram</code></a> in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/24">jonschlinkert/word-wrap#24</a></li>
<li>🔒fix: CVE 2023 26115 (2) by <a href="https://github.com/OlafConijn"><code>@​OlafConijn</code></a> in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/41">jonschlinkert/word-wrap#41</a></li>
<li>:lock: fix: CVE-2023-26115 by <a href="https://github.com/aashutoshrathi"><code>@​aashutoshrathi</code></a> in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/33">jonschlinkert/word-wrap#33</a></li>
<li>chore: publish workflow by <a href="https://github.com/OlafConijn"><code>@​OlafConijn</code></a> in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/42">jonschlinkert/word-wrap#42</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/mohd-akram"><code>@​mohd-akram</code></a> made their first contribution in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/24">jonschlinkert/word-wrap#24</a></li>
<li><a href="https://github.com/OlafConijn"><code>@​OlafConijn</code></a> made their first contribution in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/41">jonschlinkert/word-wrap#41</a></li>
<li><a href="https://github.com/aashutoshrathi"><code>@​aashutoshrathi</code></a> made their first contribution in <a href="https://redirect.github.com/jonschlinkert/word-wrap/pull/33">jonschlinkert/word-wrap#33</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/jonschlinkert/word-wrap/compare/1.2.3...1.2.4">https://github.com/jonschlinkert/word-wrap/compare/1.2.3...1.2.4</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/f64b188c7261d26b99e1e2075d6b12f21798e83a"><code>f64b188</code></a> run verb to generate README</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/03ea08256ba0c8e8b02b1b304f0f5bd2b1863207"><code>03ea082</code></a> Merge pull request <a href="https://redirect.github.com/jonschlinkert/word-wrap/issues/42">#42</a> from jonschlinkert/chore/publish-workflow</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/420dce9a2412b21881202b73a3c34f0edc53cb2e"><code>420dce9</code></a> Merge pull request <a href="https://redirect.github.com/jonschlinkert/word-wrap/issues/41">#41</a> from jonschlinkert/fix/CVE-2023-26115-2</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/bfa694edf55bb84ff84512f13da6d68bf7593f06"><code>bfa694e</code></a> Update .github/workflows/publish.yml</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/ace0b3c78f81aaf43040bab3bc91d3c5546d3fd2"><code>ace0b3c</code></a> chore: bump version to 1.2.4</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/6fd727594676f3e1b196b08a320908bec2f4ca02"><code>6fd7275</code></a> chore: add publish workflow</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/30d6daf60fce429f5f559252fa86ee78200652c4"><code>30d6daf</code></a> chore: fix test</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/655929cabea6299dddf3b4a21fc3713fca701b48"><code>655929c</code></a> chore: remove package-lock</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/49e08bbc32a84da5d79e6b7e0fa74ff6217f6d81"><code>49e08bb</code></a> chore: added an additional testcase</li>
<li><a href="https://github.com/jonschlinkert/word-wrap/commit/9f626935f3fac6ec0f3c4b26baea4eb9740d9645"><code>9f62693</code></a> fix: cve 2023-26115</li>
<li>Additional commits viewable in <a href="https://github.com/jonschlinkert/word-wrap/compare/1.2.3...1.2.4">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=word-wrap&package-manager=npm_and_yarn&previous-version=1.2.3&new-version=1.2.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/apache/arrow/network/alerts).

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/yarn.lock | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/js/yarn.lock b/js/yarn.lock
index 512dd7e07a9ea..0343bc56f8e3f 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -9429,9 +9429,9 @@ wide-align@^1.1.5:
     string-width "^1.0.2 || 2 || 3 || 4"
 
 word-wrap@^1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
-  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.4.tgz#cb4b50ec9aca570abd1f52f33cd45b6c61739a9f"
+  integrity sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==
 
 wordwrap@^1.0.0:
   version "1.0.0"
@@ -9444,6 +9444,7 @@ wordwrapjs@^5.1.0:
   integrity sha512-JNjcULU2e4KJwUNv6CHgI46UvDGitb6dGryHajXTDiLgg1/RiGoPSDw4kZfYnwGtEXf2ZMeIewDQgFGzkCB2Sg==
 
 "wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
+  name wrap-ansi-cjs
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==

From feb10f357d824a1bdadbed59b82403da13b42d28 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 7 Aug 2023 17:19:33 -0400
Subject: [PATCH 109/749] GH-37049: [MATLAB] Update feather `Reader` and
 `Writer` objects to work directly with `arrow.tabular.RecordBatch`s instead
 of MATLAB `table`s (#37052)

### Rationale for this change

After thinking about how to re-implement `featherread` and `featherwrite`, we realized it would be better if the `Reader` and `Writer` classes worked directly with `arrow.tabular.RecordBatch`s instead of MATLAB `table`s.

### What changes are included in this PR?

1. Updated `read` method of `arrow.internal.io.feather.Reader` to return an `arrow.tabular.RecordBatch` rather than a MATLAB `table`.
2. Updated `write` method of `arrow.internal.io.feather.Writer` to accept an `arrow.tabular.RecordBatch` rather than a MATLAB `table`.

### Are these changes tested?

Yes.

1. Updated `feather/tRoundTrip.m` to reflect the changes to the `Reader` and `Writer` classes.

### Are there any user-facing changes?

1. No

These are internal APIs.
* Closes: #37049

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+arrow/+internal/+io/+feather/Reader.m    |  3 +-
 .../+arrow/+internal/+io/+feather/Writer.m    |  5 ++--
 matlab/src/matlab/featherwrite.m              |  3 +-
 matlab/test/arrow/io/feather/tRoundTrip.m     | 30 +++++++++----------
 4 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m b/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m
index 80da7294d2d8d..6cd78646767a7 100644
--- a/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m
+++ b/matlab/src/matlab/+arrow/+internal/+io/+feather/Reader.m
@@ -36,11 +36,10 @@
             obj.Proxy = arrow.internal.proxy.create("arrow.io.feather.proxy.Reader", args);
         end
 
-        function T = read(obj)
+        function recordBatch = read(obj)
             recordBatchProxyID = obj.Proxy.read();
             proxy = libmexclass.proxy.Proxy(Name="arrow.tabular.proxy.RecordBatch", ID=recordBatchProxyID);
             recordBatch = arrow.tabular.RecordBatch(proxy);
-            T = recordBatch.toMATLAB();
         end
 
         function filename = get.Filename(obj)
diff --git a/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
index 37c785f10a5e3..64872ba4a023c 100644
--- a/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
+++ b/matlab/src/matlab/+arrow/+internal/+io/+feather/Writer.m
@@ -35,9 +35,8 @@
             obj.Proxy = arrow.internal.proxy.create(proxyName, args);
         end
 
-        function write(obj, T)
-            rb = arrow.recordbatch(T);
-            args = struct(RecordBatchProxyID=rb.Proxy.ID);
+        function write(obj, recordBatch)
+            args = struct(RecordBatchProxyID=recordBatch.Proxy.ID);
             obj.Proxy.write(args);
         end
 
diff --git a/matlab/src/matlab/featherwrite.m b/matlab/src/matlab/featherwrite.m
index cc3f45e954ad8..879edd8afc68e 100644
--- a/matlab/src/matlab/featherwrite.m
+++ b/matlab/src/matlab/featherwrite.m
@@ -28,6 +28,7 @@ function featherwrite(filename, t)
         t table
     end
 
+    recordBatch = arrow.recordbatch(t);
     writer = arrow.internal.io.feather.Writer(filename);
-    writer.write(t);
+    writer.write(recordBatch);
 end
diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
index e735d196c1875..f361a4543b8e4 100644
--- a/matlab/test/arrow/io/feather/tRoundTrip.m
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -31,27 +31,27 @@ function addFeatherFunctionsToMATLABPath(testCase)
     methods(Test)
         function Basic(testCase)
             import matlab.unittest.fixtures.TemporaryFolderFixture
-            
+            import arrow.internal.io.feather.*
+
             fixture = testCase.applyFixture(TemporaryFolderFixture);
             filename = fullfile(fixture.Folder, "temp.feather");
 
             DoubleVar = [10; 20; 30; 40];
             SingleVar = single([10; 15; 20; 25]);
-            tWrite = table(DoubleVar, SingleVar);
-            
-            featherwrite(tWrite, filename);
-            tRead = featherread(filename);
-            testCase.verifyEqual(tWrite, tRead);
+
+            tableWrite = table(DoubleVar, SingleVar);
+            recordBatchWrite = arrow.recordbatch(tableWrite);
+
+            writer = Writer(filename);
+            writer.write(recordBatchWrite);
+
+            reader = arrow.internal.io.feather.Reader(filename);
+            recordBatchRead = reader.read();
+
+            tableRead = table(recordBatchRead);
+
+            testCase.verifyEqual(tableWrite, tableRead);
         end
     end
-end
-
-function featherwrite(T, filename)
-    writer = arrow.internal.io.feather.Writer(filename);
-    writer.write(T);
-end
 
-function T = featherread(filename)
-    reader = arrow.internal.io.feather.Reader(filename);
-    T = reader.read();
 end
\ No newline at end of file

From 178b055464f35f4aeef8d5ddf34fdc15ab5be264 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 8 Aug 2023 09:31:12 +0900
Subject: [PATCH 110/749] MINOR: [C++] Fix a lint failure (#37048)

### Rationale for this change

GH-37031 had the following lint failure but I merged it. Sorry.

```text
FAILED: CMakeFiles/check-format
cd /tmp/arrow-lint-3lmfc4qt/cpp-build && /usr/local/bin/python /arrow/cpp/build-support/run_clang_format.py --clang_format_binary /usr/bin/clang-format-14 --exclude_globs /arrow/cpp/build-support/lint_exclusions.txt --source_dir /arrow/cpp/src --source_dir /arrow/cpp/examples --source_dir /arrow/cpp/tools --quiet

--- /arrow/cpp/src/arrow/acero/aggregate_internal.h
+++ /arrow/cpp/src/arrow/acero/aggregate_internal.h (after clang format)
@@ -52,8 +52,8 @@
 // segment-keys is used to refine the partitioning. However, segment-keys are different in
 // that they partition only consecutive rows into a single group. Such a partition of
 // consecutive rows is called a segment group. For example, consider a column X with
-// values [A, A, B, A] at row-indices [0, 1, 2, 3]. A regular group-by aggregation with keys
-// [X] yields a row-index partitioning [[0, 1, 3], [2]] whereas a segmented-group-by
+// values [A, A, B, A] at row-indices [0, 1, 2, 3]. A regular group-by aggregation with
+// keys [X] yields a row-index partitioning [[0, 1, 3], [2]] whereas a segmented-group-by
 // aggregation with segment-keys [X] yields [[0, 1], [2], [3]].
 //
 // The implementation first segments the input using the segment-keys, then groups by the
/arrow/cpp/src/arrow/acero/aggregate_internal.h had clang-format style issues
```

### What changes are included in this PR?

I've fixed it by `ninja format`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/acero/aggregate_internal.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/acero/aggregate_internal.h b/cpp/src/arrow/acero/aggregate_internal.h
index 744acb124505a..72537a7f7e3fe 100644
--- a/cpp/src/arrow/acero/aggregate_internal.h
+++ b/cpp/src/arrow/acero/aggregate_internal.h
@@ -52,8 +52,8 @@
 // segment-keys is used to refine the partitioning. However, segment-keys are different in
 // that they partition only consecutive rows into a single group. Such a partition of
 // consecutive rows is called a segment group. For example, consider a column X with
-// values [A, A, B, A] at row-indices [0, 1, 2, 3]. A regular group-by aggregation with keys
-// [X] yields a row-index partitioning [[0, 1, 3], [2]] whereas a segmented-group-by
+// values [A, A, B, A] at row-indices [0, 1, 2, 3]. A regular group-by aggregation with
+// keys [X] yields a row-index partitioning [[0, 1, 3], [2]] whereas a segmented-group-by
 // aggregation with segment-keys [X] yields [[0, 1], [2], [3]].
 //
 // The implementation first segments the input using the segment-keys, then groups by the

From e51ea4014fe3d3b97c07e697a30aac5f396c187a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 09:33:21 +0900
Subject: [PATCH 111/749] MINOR: [C#] Bump xunit from 2.4.0 to 2.5.0 in /csharp
 (#37036)

Bumps [xunit](https://github.com/xunit/xunit) from 2.4.0 to 2.5.0.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/12ec6b87aea7ad0496aa053e11b84d4c928f90a8"><code>12ec6b8</code></a> Bump up to v2.5.1-pre</li>
<li><a href="https://github.com/xunit/xunit/commit/92f31c4c3a4adf391a19e6c9b531f4195636f132"><code>92f31c4</code></a> v2.5.0</li>
<li><a href="https://github.com/xunit/xunit/commit/188216b64a3bb9a141cb2851fce47264f29593bf"><code>188216b</code></a> Ensure both failed tests and error cause error return codes (and cancel for s...</li>
<li><a href="https://github.com/xunit/xunit/commit/c97317920dcd10e88264adf6c81a303aca7bfc06"><code>c973179</code></a> Latest analyzers</li>
<li><a href="https://github.com/xunit/xunit/commit/f93d52dbf743957131287690bef34a518c402eae"><code>f93d52d</code></a> Propagate StopOnFail from config file =&gt; execution options</li>
<li><a href="https://github.com/xunit/xunit/commit/5e70f54cab281f0d19ababd6dea9832518137a4d"><code>5e70f54</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2737">#2737</a>: Restore XunitException constructor (breaking change) (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/028866f82155319ffa583503245aa5ec438f7804"><code>028866f</code></a> Add PackageDownload for Microsoft.NETFramework.ReferenceAssemblies.net452 to ...</li>
<li><a href="https://github.com/xunit/xunit/commit/aeba1bbfc354d24ce2ddb17e1d248bf5ddf7b4cc"><code>aeba1bb</code></a> Remove UAP/UWP support</li>
<li><a href="https://github.com/xunit/xunit/commit/530802128e5acd624406f35869ab61d73d6c0514"><code>5308021</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/1857">#1857</a>: Add overload to Assert.Contains for ConcurrentDictionary (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/5fbaa0a34994a5293589c47935bfbfe49b29357c"><code>5fbaa0a</code></a> Incorrect type restriction on obsoleted Assert.ThrowsAny&lt;T&gt; for Func&lt;Task&gt; an...</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/xunit/compare/2.4...2.5.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.4.0&new-version=2.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 145865a2df46a..b0a844972f33d 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 26ab18ca7d6ae..81848a735f559 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 981c359cab174..d77863dad9b71 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -11,7 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

From 55dcd65582c29cca6951790f29f5905f3b6ec3e2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 09:34:09 +0900
Subject: [PATCH 112/749] MINOR: [JS] Bump semver from 5.7.1 to 5.7.2 in /js
 (#36603)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [semver](https://github.com/npm/node-semver) from 5.7.1 to 5.7.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/npm/node-semver/releases">semver's releases</a>.</em></p>
<blockquote>
<h2>v5.7.2</h2>
<h2><a href="https://github.com/npm/node-semver/compare/v5.7.1...v5.7.2">5.7.2</a> (2023-07-10)</h2>
<h3>Bug Fixes</h3>
<ul>
<li><a href="https://github.com/npm/node-semver/commit/2f8fd41487acf380194579ecb6f8b1bbfe116be0"><code>2f8fd41</code></a> <a href="https://redirect.github.com/npm/node-semver/pull/585">#585</a> better handling of whitespace (<a href="https://redirect.github.com/npm/node-semver/issues/585">#585</a>) (<a href="https://github.com/joaomoreno"><code>@​joaomoreno</code></a>, <a href="https://github.com/lukekarrys"><code>@​lukekarrys</code></a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/npm/node-semver/blob/v5.7.2/CHANGELOG.md">semver's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/npm/node-semver/compare/v5.7.1...v5.7.2">5.7.2</a> (2023-07-10)</h2>
<h3>Bug Fixes</h3>
<ul>
<li><a href="https://github.com/npm/node-semver/commit/2f8fd41487acf380194579ecb6f8b1bbfe116be0"><code>2f8fd41</code></a> <a href="https://redirect.github.com/npm/node-semver/pull/585">#585</a> better handling of whitespace (<a href="https://redirect.github.com/npm/node-semver/issues/585">#585</a>) (<a href="https://github.com/joaomoreno"><code>@​joaomoreno</code></a>, <a href="https://github.com/lukekarrys"><code>@​lukekarrys</code></a>)</li>
</ul>
<h2>5.7</h2>
<ul>
<li>Add <code>minVersion</code> method</li>
</ul>
<h2>5.6</h2>
<ul>
<li>Move boolean <code>loose</code> param to an options object, with
backwards-compatibility protection.</li>
<li>Add ability to opt out of special prerelease version handling with
the <code>includePrerelease</code> option flag.</li>
</ul>
<h2>5.5</h2>
<ul>
<li>Add version coercion capabilities</li>
</ul>
<h2>5.4</h2>
<ul>
<li>Add intersection checking</li>
</ul>
<h2>5.3</h2>
<ul>
<li>Add <code>minSatisfying</code> method</li>
</ul>
<h2>5.2</h2>
<ul>
<li>Add <code>prerelease(v)</code> that returns prerelease components</li>
</ul>
<h2>5.1</h2>
<ul>
<li>Add Backus-Naur for ranges</li>
<li>Remove excessively cute inspection methods</li>
</ul>
<h2>5.0</h2>
<ul>
<li>Remove AMD/Browserified build artifacts</li>
<li>Fix ltr and gtr when using the <code>*</code> range</li>
<li>Fix for range <code>*</code> with a prerelease identifier</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/npm/node-semver/commit/f8cc313550691a50d9662d8c94f0c033717efd7d"><code>f8cc313</code></a> chore: release 5.7.2</li>
<li><a href="https://github.com/npm/node-semver/commit/2f8fd41487acf380194579ecb6f8b1bbfe116be0"><code>2f8fd41</code></a> fix: better handling of whitespace (<a href="https://redirect.github.com/npm/node-semver/issues/585">#585</a>)</li>
<li><a href="https://github.com/npm/node-semver/commit/deb5ad51bf58868fa243c1683775305fe9e0e365"><code>deb5ad5</code></a> chore: <code>@​npmcli/template-oss</code><a href="https://github.com/4"><code>@​4</code></a>.16.0</li>
<li>See full diff in <a href="https://github.com/npm/node-semver/compare/v5.7.1...v5.7.2">compare view</a></li>
</ul>
</details>
<details>
<summary>Maintainer changes</summary>
<p>This version was pushed to npm by <a href="https://www.npmjs.com/~lukekarrys">lukekarrys</a>, a new releaser for semver since your current version.</p>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=semver&package-manager=npm_and_yarn&previous-version=5.7.1&new-version=5.7.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/apache/arrow/network/alerts).

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/yarn.lock | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/js/yarn.lock b/js/yarn.lock
index 0343bc56f8e3f..bda4faa3b17cb 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -8079,9 +8079,9 @@ semver-greatest-satisfied-range@^1.1.0:
     sver-compat "^1.5.0"
 
 "semver@2 || 3 || 4 || 5", semver@^5.6.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
-  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
+  version "5.7.2"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
+  integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
 
 semver@7.3.4:
   version "7.3.4"
@@ -8091,16 +8091,16 @@ semver@7.3.4:
     lru-cache "^6.0.0"
 
 semver@7.x, semver@^7.0.0, semver@^7.1.1, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.3.8:
-  version "7.5.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.1.tgz#c90c4d631cf74720e46b21c1d37ea07edfab91ec"
-  integrity sha512-Wvss5ivl8TMRZXXESstBA4uR5iXgEN/VC5/sOcuXdVLzcdkz4HWetIoRfG5gb5X+ij/G9rw9YoGn3QoQ8OCSpw==
+  version "7.5.4"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
+  integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
   dependencies:
     lru-cache "^6.0.0"
 
 semver@^6.0.0, semver@^6.3.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
-  integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
+  version "6.3.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
+  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
 
 serialize-javascript@^6.0.1:
   version "6.0.1"

From 21e1e00ab89870e5010d4aaaf91e689821035e81 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 8 Aug 2023 14:02:35 +0900
Subject: [PATCH 113/749] MINOR: [C#] Bump Microsoft.NET.Test.Sdk from 15.8.0
 to 17.7.0 in /csharp (#37038)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 15.8.0 to 17.7.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/releases">Microsoft.NET.Test.Sdk's releases</a>.</em></p>
<blockquote>
<h2>v17.7.0</h2>
<h3>Issues Fixed</h3>
<ul>
<li>RTM build fix</li>
<li>[rel/17.7] Fix branding on 17.7-release <a href="https://redirect.github.com/microsoft/vstest/pull/4615">#4615</a></li>
<li>Externals final 17.7 upgrade <a href="https://redirect.github.com/microsoft/vstest/pull/4565">#4565</a></li>
<li>&quot;Snap&quot; main to rel/17.7 <a href="https://redirect.github.com/microsoft/vstest/pull/4558">#4558</a></li>
<li>Disable pre-start of testhosts <a href="https://redirect.github.com/microsoft/vstest/pull/4554">#4554</a></li>
<li>Downgrade Nuget.Frameworks to 6.5.0 <a href="https://redirect.github.com/microsoft/vstest/pull/4512">#4512</a></li>
<li>Update Nuget.Frameworks <a href="https://redirect.github.com/microsoft/vstest/pull/4500">#4500</a></li>
<li>Fix hangdump running into crashdump <a href="https://redirect.github.com/microsoft/vstest/pull/4480">#4480</a></li>
<li>Fix no-suitable provider found <a href="https://redirect.github.com/microsoft/vstest/pull/4474">#4474</a></li>
<li>Fix Newtonsoft versions in testhost.deps.json <a href="https://redirect.github.com/microsoft/vstest/pull/4372">#4372</a></li>
<li>Bumped TP version to 17.7.0 (<a href="https://redirect.github.com/microsoft/vstest/issues/4346">#4346</a>)</li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.6.3...v17.7.0">here</a></p>
<h3>Drops</h3>
<ul>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.7.0">v17.7.0</a></li>
</ul>
<h2>v17.7.0-preview-23364-03</h2>
<h3>Issues Fixed</h3>
<ul>
<li>Trim away netframework targets in source-build <a href="https://redirect.github.com/microsoft/vstest/pull/4357">#4357</a></li>
<li>Re-enable publishing nugets, don't continue on error <a href="https://redirect.github.com/microsoft/vstest/pull/4356">#4356</a></li>
<li>Merged PR 30352: arcade into main</li>
<li>Merged PR 29591: Onboard to arcade</li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/before-arcade...v17.7.0-preview-23364-03">here</a></p>
<h3>Drops</h3>
<ul>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.7.0-preview.23280.1">17.7.0-preview-23364-03</a></li>
</ul>
<h2>v17.7.0-preview.23280.1</h2>
<blockquote>
<p>⚠️ This version of Microsoft.TestPlatform nuget was unlisted on Nuget.org, because it causes issues when running tests in AzureDevOps, when VSTest installer is used, and configured to pick up the latest preview version (<a href="https://redirect.github.com/microsoft/vstest/issues/4544">#4544</a>).</p>
</blockquote>

<h1>What is new since 17.6.0?</h1>
<p>Version 17.7.0 was filled with moving our infrastructure to build via <a href="https://github.com/dotnet/arcade">Arcade</a>, which brought us a more unified build experience and better cooperation with other teams in dotnet organization.</p>
<p>This migration brought a major change to our versioning of preview packages, which will no longer follow the <code>17.6.0-preview-20230223-05</code> (<code>&lt;version&gt;-preview&lt;date&gt;-&lt;build&gt;</code>).</p>
<h2>Fixes</h2>
<ul>
<li>Don't print socket transport error in console by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4493">microsoft/vstest#4493</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/blob/main/docs/releases.md">Microsoft.NET.Test.Sdk's changelog</a>.</em></p>
<blockquote>
<h1>Release Notes</h1>
<h2>17.6.1 and newer</h2>
<p>Please see release notes directly in the release page: <a href="https://github.com/microsoft/vstest/releases">https://github.com/microsoft/vstest/releases</a></p>
<h2>17.6.0</h2>
<h3>Issues Fixed</h3>
<ul>
<li>Add legacy feeds</li>
<li>[rel/17.6] Fix Newtonsoft versions in testhost.deps.json <a href="https://redirect.github.com/microsoft/vstest/pull/4372">#4372</a></li>
<li>Revert &quot;Revert &quot;Fix signature verification&quot; (<a href="https://redirect.github.com/microsoft/vstest/issues/4333">#4333</a>&quot; <a href="https://redirect.github.com/microsoft/vstest/pull/4345">#4345</a></li>
<li>Revert &quot;Fix signature verification&quot; <a href="https://redirect.github.com/microsoft/vstest/pull/4333">#4333</a></li>
<li>Fix signature verification <a href="https://redirect.github.com/microsoft/vstest/pull/4331">#4331</a></li>
<li>Pre-start testhosts <a href="https://redirect.github.com/microsoft/vstest/pull/3666">#3666</a></li>
<li>Add <code>dotnet vstest</code> deprecation message <a href="https://redirect.github.com/microsoft/vstest/pull/4297">#4297</a></li>
<li>Catch unhandled exception and avoid crash on test host exit <a href="https://redirect.github.com/microsoft/vstest/pull/4291">#4291</a></li>
<li>Remove chutzpah <a href="https://redirect.github.com/microsoft/vstest/pull/4249">#4249</a></li>
<li>Fix string conversion of <code>Microsoft.TestPlatform.Extensions.TrxLogger.ObjectMode.TestOutcome</code> <a href="https://redirect.github.com/microsoft/vstest/pull/4243">#4243</a></li>
<li>Fix potential trx logger NRE <a href="https://redirect.github.com/microsoft/vstest/pull/4240">#4240</a></li>
<li>handle object disposed exception <a href="https://redirect.github.com/microsoft/vstest/pull/4221">#4221</a></li>
<li>Added support for checking testhost compatibility with test sessions <a href="https://redirect.github.com/microsoft/vstest/pull/4199">#4199</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.5.0...v17.6.0">here</a></p>
<h3>Artifacts</h3>
<ul>
<li>TestPlatform vsix: <a href="https://vsdrop.corp.microsoft.com/file/v1/Products/DevDiv/microsoft/vstest/17.6/20230515-01;/TestPlatform.vsix">17.6.0</a></li>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.6.0">17.6.0</a></li>
</ul>
<h2>17.3.3</h2>
<h3>Issues Fixed</h3>
<ul>
<li>[rel/17.3] Update Newtonsoft.Json to 13.0.1 <a href="https://redirect.github.com/microsoft/vstest/pull/4299">#4299</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.3.2...v17.3.3">here</a></p>
<h3>Drops</h3>
<ul>
<li>TestPlatform vsix: <a href="https://vsdrop.corp.microsoft.com/file/v1/Products/DevDiv/microsoft/vstest/17.3/20230324-03;/TestPlatform.vsix">17.3.3</a></li>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.3.3">17.3.3</a></li>
</ul>
<h2>17.2.1</h2>
<h3>Issues Fixed</h3>
<ul>
<li>[rel/17.2] Update Newtonsoft.Json to 13.0.1 <a href="https://redirect.github.com/microsoft/vstest/pull/4310">#4310</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.2.0...v17.2.1">here</a></p>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/vstest/commit/246832ceaa77ef978eebaeac5199bc56731747a1"><code>246832c</code></a> RTM build fix</li>
<li><a href="https://github.com/microsoft/vstest/commit/f6bfa29dc08ae44ab27a9cf2d98ad18c4e62dbe7"><code>f6bfa29</code></a> [rel/17.7] Fix branding on 17.7-release (<a href="https://redirect.github.com/microsoft/vstest/issues/4615">#4615</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/bc17bb9693cfc4778ded51aa0ab7f1065433f989"><code>bc17bb9</code></a> [rel/17.7] Update dependencies from devdiv/DevDiv/vs-code-coverage (<a href="https://redirect.github.com/microsoft/vstest/issues/4602">#4602</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/f0bc50efe4379126b49b24123f247cce0cf83f04"><code>f0bc50e</code></a> Revert &quot;Fix yml to generate RTM/stable version &amp; fix symbol check issues (<a href="https://redirect.github.com/microsoft/vstest/issues/46">#46</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/fab9246e637e863a1c4311eff462035168ce7907"><code>fab9246</code></a> Fix yml to generate RTM/stable version &amp; fix symbol check issues (<a href="https://redirect.github.com/microsoft/vstest/issues/4600">#4600</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/d7f4faa42b22ba20d697b530dd6809a0c02e6278"><code>d7f4faa</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/132324c9f65e0dc9e6b76fe0d34a13227e2d3b36"><code>132324c</code></a> Consume localized resources in source-build (<a href="https://redirect.github.com/microsoft/vstest/issues/4564">#4564</a>) (<a href="https://redirect.github.com/microsoft/vstest/issues/4567">#4567</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/18e0eaa980b569c039332054d52d2f1f6ba70823"><code>18e0eaa</code></a> Externals final 17.7 upgrade (<a href="https://redirect.github.com/microsoft/vstest/issues/4565">#4565</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/3d3375aaa35de7cf4ee7bf040501f931d5ff1d5f"><code>3d3375a</code></a> &quot;Snap&quot; main to rel/17.7 (<a href="https://redirect.github.com/microsoft/vstest/issues/4558">#4558</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/b98693475c6da4ce648099eed3e77b61dcb3ca61"><code>b986934</code></a> Merge main in rel/17.7 (<a href="https://redirect.github.com/microsoft/vstest/issues/4540">#4540</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/microsoft/vstest/compare/v15.8.0...v17.7.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.NET.Test.Sdk&package-manager=nuget&previous-version=15.8.0&new-version=17.7.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index b0a844972f33d..d0294ac3b44a5 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 81848a735f559..ebb622c9334fe 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index d77863dad9b71..a66f6fd6e305a 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>

From c6c21c0056675b5137fd902022c24980fac726b4 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Tue, 8 Aug 2023 09:24:45 -0400
Subject: [PATCH 114/749] MINOR: [Go] Add gRPC status details to sample Flight
 SQL server (#37026)

### Rationale for this change

Needed to test apache/arrow-adbc#963.

### What changes are included in this PR?

Have the SQLite Flight SQL server sample emit a gRPC status detail.

### Are these changes tested?

No.

### Are there any user-facing changes?

No.

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../flight/flightsql/example/sql_batch_reader.go     | 12 +++++++++++-
 go/arrow/flight/flightsql/example/sqlite_server.go   |  5 +++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/go/arrow/flight/flightsql/example/sql_batch_reader.go b/go/arrow/flight/flightsql/example/sql_batch_reader.go
index ae70406693e25..a8735de48a5e6 100644
--- a/go/arrow/flight/flightsql/example/sql_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sql_batch_reader.go
@@ -31,6 +31,9 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
 	"github.com/apache/arrow/go/v13/arrow/internal/debug"
 	"github.com/apache/arrow/go/v13/arrow/memory"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/wrapperspb"
 )
 
 func getArrowTypeFromString(dbtype string) arrow.DataType {
@@ -257,12 +260,19 @@ func (r *SqlBatchReader) Next() bool {
 	rows := 0
 	for rows < maxBatchSize && r.rows.Next() {
 		if err := r.rows.Scan(r.rowdest...); err != nil {
-			r.err = err
+			// Not really useful except for testing Flight SQL clients
+			detail := wrapperspb.StringValue{Value: r.schema.String()}
+			if st, sterr := status.New(codes.Unknown, err.Error()).WithDetails(&detail); sterr != nil {
+				r.err = err
+			} else {
+				r.err = st.Err()
+			}
 			return false
 		}
 
 		for i, v := range r.rowdest {
 			fb := r.bldr.Field(i)
+
 			switch v := v.(type) {
 			case *uint8:
 				fb.(*array.Uint8Builder).Append(*v)
diff --git a/go/arrow/flight/flightsql/example/sqlite_server.go b/go/arrow/flight/flightsql/example/sqlite_server.go
index 34093079d72a4..2f8ff99b3155f 100644
--- a/go/arrow/flight/flightsql/example/sqlite_server.go
+++ b/go/arrow/flight/flightsql/example/sqlite_server.go
@@ -52,7 +52,9 @@ import (
 	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
 	"github.com/apache/arrow/go/v13/arrow/memory"
 	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 	_ "modernc.org/sqlite"
 )
@@ -462,6 +464,9 @@ type dbQueryCtx interface {
 func doGetQuery(ctx context.Context, mem memory.Allocator, db dbQueryCtx, query string, schema *arrow.Schema, args ...interface{}) (*arrow.Schema, <-chan flight.StreamChunk, error) {
 	rows, err := db.QueryContext(ctx, query, args...)
 	if err != nil {
+		// Not really useful except for testing Flight SQL clients
+		trailers := metadata.Pairs("afsql-sqlite-query", query)
+		grpc.SetTrailer(ctx, trailers)
 		return nil, nil, err
 	}
 

From 59f30f089879196910c4eca0f0530ec1d039cc71 Mon Sep 17 00:00:00 2001
From: Ben Harkins <60872452+benibus@users.noreply.github.com>
Date: Tue, 8 Aug 2023 13:40:08 -0400
Subject: [PATCH 115/749] GH-36892: [C++] Fix performance regressions in
 `FieldPath::Get` (#37032)

### Rationale for this change

https://github.com/apache/arrow/pull/35197 appears to have introduced significant performance regressions in `FieldPath::Get` - indicated [here](https://conbench.ursa.dev/compare/runs/9cf73ac83f0a44179e6538b2c1c7babd...3d76cb5ffb8849bf8c3ea9b32d08b3b7/), in a benchmark that uses a wide (10K column) dataframe.

### What changes are included in this PR?

- Adds basic benchmarks for `FieldPath::Get` across various input types, as they didn't previously exist
- Addresses several performance issues. These came in the form of extremely high upfront costs for the `RecordBatch` and `ArrayData` overloads specifically
- Some minor refactoring of `NestedSelector`

### Are these changes tested?

Yes (covered by existing tests)

### Are there any user-facing changes?

No

* Closes: #36892

Lead-authored-by: benibus <bpharks@gmx.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/type.cc           | 102 +++++++++++++++++---------
 cpp/src/arrow/type_benchmark.cc | 125 ++++++++++++++++++++++++++++++++
 2 files changed, 191 insertions(+), 36 deletions(-)

diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 68dc2aabe96ad..9267f1e499720 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -1066,17 +1066,29 @@ std::string FieldPath::ToString() const {
   return repr;
 }
 
-static Status NonStructError() {
-  return Status::NotImplemented("Get child data of non-struct array");
-}
+struct NestedSelectorUtil {
+  static Status NonStructError() {
+    return Status::NotImplemented("Get child data of non-struct array");
+  }
+
+  template <typename T>
+  static const DataType* GetType(const T& input) {
+    if constexpr (std::is_same_v<T, ArrayData>) {
+      return input.type.get();
+    } else {
+      return input.type().get();
+    }
+  }
+};
 
-// Utility class for retrieving a child field/column from a top-level Field, Array, or
-// ChunkedArray. The "root" value can either be a single parent or a vector of its
-// children.
+// Utility class for retrieving a child field/column from a top-level Field, Array,
+// ArrayData, or ChunkedArray. The "root" value can either be a single parent or a vector
+// of its children.
 template <typename T, bool IsFlattening = false>
 class NestedSelector {
  public:
   using ArrowType = T;
+  using Util = NestedSelectorUtil;
 
   explicit NestedSelector(const std::vector<std::shared_ptr<T>>& children)
       : parent_or_children_(&children) {}
@@ -1095,7 +1107,18 @@ class NestedSelector {
   Result<NestedSelector> GetChild(int i) const {
     std::shared_ptr<T> child;
     if (auto parent = get_parent()) {
-      ARROW_ASSIGN_OR_RAISE(child, GetChild(*parent, i, pool_));
+      const DataType* type = Util::GetType(*parent);
+      // We avoid this check for schema fields since it's inconsequential (plus there are
+      // tests elsewhere that rely on it not happening)
+      if constexpr (!std::is_same_v<T, Field>) {
+        if (ARROW_PREDICT_FALSE(type->id() != Type::STRUCT)) {
+          return Util::NonStructError();
+        }
+      }
+      // Bounds-check the index *once* using the parent's type
+      if (ARROW_PREDICT_TRUE(i >= 0 && i < type->num_fields())) {
+        ARROW_ASSIGN_OR_RAISE(child, GetChild(*parent, i, pool_));
+      }
     } else if (auto children = get_children()) {
       if (ARROW_PREDICT_TRUE(i >= 0 && static_cast<size_t>(i) < children->size())) {
         child = (*children)[i];
@@ -1129,10 +1152,10 @@ class NestedSelector {
     *os << "column types: { ";
     if (auto children = get_children()) {
       for (const auto& child : *children) {
-        *os << *child->type() << ", ";
+        *os << *Util::GetType(*child) << ", ";
       }
     } else if (auto parent = get_parent()) {
-      for (const auto& field : parent->type()->fields()) {
+      for (const auto& field : Util::GetType(*parent)->fields()) {
         *os << *field->type() << ", ";
       }
     }
@@ -1155,21 +1178,33 @@ class NestedSelector {
   }
 
   static Result<std::shared_ptr<Field>> GetChild(const Field& field, int i, MemoryPool*) {
-    if (ARROW_PREDICT_FALSE(i < 0 || i >= field.type()->num_fields())) {
-      return nullptr;
-    }
     return field.type()->field(i);
   }
 
-  static Result<std::shared_ptr<Array>> GetChild(const Array& array, int i,
-                                                 MemoryPool* pool) {
-    if (ARROW_PREDICT_FALSE(array.type_id() != Type::STRUCT)) {
-      return NonStructError();
-    }
-    if (ARROW_PREDICT_FALSE(i < 0 || i >= array.num_fields())) {
-      return nullptr;
+  static Result<std::shared_ptr<ArrayData>> GetChild(const ArrayData& data, int i,
+                                                     MemoryPool* pool) {
+    std::shared_ptr<ArrayData> child_data;
+    if constexpr (IsFlattening) {
+      // First, convert to an Array so we can use StructArray::GetFlattenedField
+      auto array = MakeArray(data.Copy());
+      ARROW_ASSIGN_OR_RAISE(auto child_array, GetChild(*array, i, pool));
+      child_data = child_array->data();
+    } else {
+      // We could achieve the same result by converting to an Array (via MakeArray),
+      // calling StructArray::field(i), and pulling out the new ArrayData. However, this
+      // process can be very expensive when there are many columns - so we just
+      // reimplement the functionality that we need
+      child_data = data.child_data[i];
+      if (data.offset != 0 || data.child_data[i]->length != data.length) {
+        child_data = child_data->Slice(data.offset, data.length);
+      }
     }
 
+    return std::move(child_data);
+  }
+
+  static Result<std::shared_ptr<Array>> GetChild(const Array& array, int i,
+                                                 MemoryPool* pool) {
     const auto& struct_array = checked_cast<const StructArray&>(array);
     if constexpr (IsFlattening) {
       return struct_array.GetFlattenedField(i, pool);
@@ -1181,22 +1216,15 @@ class NestedSelector {
   static Result<std::shared_ptr<ChunkedArray>> GetChild(const ChunkedArray& chunked_array,
                                                         int i, MemoryPool* pool) {
     const auto& type = *chunked_array.type();
-    if (ARROW_PREDICT_FALSE(type.id() != Type::STRUCT)) {
-      return NonStructError();
-    }
-    if (ARROW_PREDICT_FALSE(i < 0 || i >= type.num_fields())) {
-      return nullptr;
-    }
 
     ArrayVector chunks;
     chunks.reserve(chunked_array.num_chunks());
     for (const auto& parent_chunk : chunked_array.chunks()) {
       ARROW_ASSIGN_OR_RAISE(auto chunk, GetChild(*parent_chunk, i, pool));
-      if (!chunk) return nullptr;
       chunks.push_back(std::move(chunk));
     }
 
-    return ChunkedArray::Make(std::move(chunks), type.field(i)->type());
+    return std::make_shared<ChunkedArray>(std::move(chunks), type.field(i)->type());
   }
 
   std::shared_ptr<T> owned_parent_;
@@ -1289,7 +1317,11 @@ Result<std::shared_ptr<Schema>> FieldPath::GetAll(const Schema& schm,
 }
 
 Result<std::shared_ptr<Array>> FieldPath::Get(const RecordBatch& batch) const {
-  return FieldPathGetImpl::Get(this, ZeroCopySelector<Array>(batch.columns()));
+  // Deliberately calling `column_data` here because `RecordBatch::columns` is nontrivial
+  ARROW_ASSIGN_OR_RAISE(
+      auto data,
+      FieldPathGetImpl::Get(this, ZeroCopySelector<ArrayData>(batch.column_data())));
+  return MakeArray(data);
 }
 
 Result<std::shared_ptr<ChunkedArray>> FieldPath::Get(const Table& table) const {
@@ -1301,11 +1333,7 @@ Result<std::shared_ptr<Array>> FieldPath::Get(const Array& array) const {
 }
 
 Result<std::shared_ptr<ArrayData>> FieldPath::Get(const ArrayData& data) const {
-  // We indirect from ArrayData to Array rather than vice-versa because, when selecting a
-  // nested column, the StructArray::field method does the work of adjusting the data's
-  // offset/length if necessary.
-  ARROW_ASSIGN_OR_RAISE(auto array, Get(*MakeArray(data.Copy())));
-  return array->data();
+  return FieldPathGetImpl::Get(this, ZeroCopySelector<ArrayData>(data));
 }
 
 Result<std::shared_ptr<ChunkedArray>> FieldPath::Get(
@@ -1320,8 +1348,7 @@ Result<std::shared_ptr<Array>> FieldPath::GetFlattened(const Array& array,
 
 Result<std::shared_ptr<ArrayData>> FieldPath::GetFlattened(const ArrayData& data,
                                                            MemoryPool* pool) const {
-  ARROW_ASSIGN_OR_RAISE(auto array, GetFlattened(*MakeArray(data.Copy()), pool));
-  return array->data();
+  return FieldPathGetImpl::Get(this, FlatteningSelector<ArrayData>(data, pool));
 }
 
 Result<std::shared_ptr<ChunkedArray>> FieldPath::GetFlattened(
@@ -1332,7 +1359,10 @@ Result<std::shared_ptr<ChunkedArray>> FieldPath::GetFlattened(
 
 Result<std::shared_ptr<Array>> FieldPath::GetFlattened(const RecordBatch& batch,
                                                        MemoryPool* pool) const {
-  return FieldPathGetImpl::Get(this, FlatteningSelector<Array>(batch.columns(), pool));
+  ARROW_ASSIGN_OR_RAISE(
+      auto data, FieldPathGetImpl::Get(
+                     this, FlatteningSelector<ArrayData>(batch.column_data(), pool)));
+  return MakeArray(data);
 }
 
 Result<std::shared_ptr<ChunkedArray>> FieldPath::GetFlattened(const Table& table,
diff --git a/cpp/src/arrow/type_benchmark.cc b/cpp/src/arrow/type_benchmark.cc
index de90577ffdf64..17dccfcb33138 100644
--- a/cpp/src/arrow/type_benchmark.cc
+++ b/cpp/src/arrow/type_benchmark.cc
@@ -18,15 +18,19 @@
 #include <algorithm>
 #include <cstdint>
 #include <exception>
+#include <optional>
 #include <random>
 #include <string>
 #include <vector>
 
 #include "benchmark/benchmark.h"
 
+#include "arrow/array.h"
 #include "arrow/result.h"
 #include "arrow/status.h"
+#include "arrow/table.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
 #include "arrow/type.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/macros.h"
@@ -418,6 +422,120 @@ static void ErrorSchemeExceptionNoInline(
   state.SetItemsProcessed(state.iterations() * integers.size());
 }
 
+// ----------------------------------------------------------------------
+// FieldPath::Get benchmarks
+
+static std::shared_ptr<Schema> GenerateTestSchema(int num_columns) {
+  FieldVector fields(num_columns);
+  for (int i = 0; i < num_columns; ++i) {
+    auto name = std::string("f") + std::to_string(i);
+    fields[i] = field(std::move(name), int64());
+  }
+  return schema(std::move(fields));
+}
+
+static std::shared_ptr<Array> GenerateTestArray(int num_columns) {
+  constexpr int64_t kLength = 100;
+
+  auto rand = random::RandomArrayGenerator(0xbeef);
+  auto schm = GenerateTestSchema(num_columns);
+
+  ArrayVector columns(num_columns);
+  for (auto& column : columns) {
+    column = rand.Int64(kLength, 0, std::numeric_limits<int64_t>::max());
+  }
+
+  return *StructArray::Make(columns, schm->fields());
+}
+
+static std::shared_ptr<RecordBatch> ToBatch(const std::shared_ptr<Array>& array) {
+  return *RecordBatch::FromStructArray(array);
+}
+
+static std::shared_ptr<ChunkedArray> ToChunked(const std::shared_ptr<Array>& array,
+                                               double chunk_proportion = 1.0) {
+  auto struct_array = internal::checked_pointer_cast<StructArray>(array);
+  const auto num_rows = struct_array->length();
+  const auto chunk_length = static_cast<int64_t>(std::ceil(num_rows * chunk_proportion));
+
+  ArrayVector chunks;
+  for (int64_t offset = 0; offset < num_rows;) {
+    int64_t slice_length = std::min(chunk_length, num_rows - offset);
+    chunks.push_back(*struct_array->SliceSafe(offset, slice_length));
+    offset += slice_length;
+  }
+
+  return *ChunkedArray::Make(std::move(chunks));
+}
+
+static std::shared_ptr<Table> ToTable(const std::shared_ptr<Array>& array,
+                                      double chunk_proportion = 1.0) {
+  return *Table::FromChunkedStructArray(ToChunked(array, chunk_proportion));
+}
+
+template <typename T>
+static void BenchmarkFieldPathGet(benchmark::State& state,  // NOLINT non-const reference
+                                  const T& input, int num_columns,
+                                  std::optional<int> num_chunks = {}) {
+  // Reassigning a single FieldPath var within each iteration's scope seems to be costly
+  // enough to influence the timings, so we preprocess them.
+  std::vector<FieldPath> paths(num_columns);
+  for (int i = 0; i < num_columns; ++i) {
+    paths[i] = {i};
+  }
+
+  for (auto _ : state) {
+    for (const auto& path : paths) {
+      benchmark::DoNotOptimize(path.Get(input).ValueOrDie());
+    }
+  }
+
+  state.SetItemsProcessed(state.iterations() * num_columns);
+  state.counters["num_columns"] = num_columns;
+  if (num_chunks.has_value()) {
+    state.counters["num_chunks"] = num_chunks.value();
+  }
+}
+
+static void FieldPathGetFromWideArray(
+    benchmark::State& state) {  // NOLINT non-const reference
+  constexpr int kNumColumns = 10000;
+  auto array = GenerateTestArray(kNumColumns);
+  BenchmarkFieldPathGet(state, *array, kNumColumns);
+}
+
+static void FieldPathGetFromWideArrayData(
+    benchmark::State& state) {  // NOLINT non-const reference
+  constexpr int kNumColumns = 10000;
+  auto array = GenerateTestArray(kNumColumns);
+  BenchmarkFieldPathGet(state, *array->data(), kNumColumns);
+}
+
+static void FieldPathGetFromWideBatch(
+    benchmark::State& state) {  // NOLINT non-const reference
+  constexpr int kNumColumns = 10000;
+  auto batch = ToBatch(GenerateTestArray(kNumColumns));
+  BenchmarkFieldPathGet(state, *batch, kNumColumns);
+}
+
+static void FieldPathGetFromWideChunkedArray(
+    benchmark::State& state) {  // NOLINT non-const reference
+  constexpr int kNumColumns = 10000;
+  // Percentage representing the size of each chunk relative to the total length (smaller
+  // proportion means more chunks)
+  const double chunk_proportion = state.range(0) / 100.0;
+  auto chunked_array = ToChunked(GenerateTestArray(kNumColumns), chunk_proportion);
+  BenchmarkFieldPathGet(state, *chunked_array, kNumColumns, chunked_array->num_chunks());
+}
+
+static void FieldPathGetFromWideTable(
+    benchmark::State& state) {  // NOLINT non-const reference
+  constexpr int kNumColumns = 10000;
+  const double chunk_proportion = state.range(0) / 100.0;
+  auto table = ToTable(GenerateTestArray(kNumColumns), chunk_proportion);
+  BenchmarkFieldPathGet(state, *table, kNumColumns, table->column(0)->num_chunks());
+}
+
 BENCHMARK(TypeEqualsSimple);
 BENCHMARK(TypeEqualsComplex);
 BENCHMARK(TypeEqualsWithMetadata);
@@ -436,4 +554,11 @@ BENCHMARK(ErrorSchemeStatusNoInline);
 BENCHMARK(ErrorSchemeResultNoInline);
 BENCHMARK(ErrorSchemeExceptionNoInline);
 
+BENCHMARK(FieldPathGetFromWideArray);
+BENCHMARK(FieldPathGetFromWideArrayData);
+BENCHMARK(FieldPathGetFromWideBatch);
+
+BENCHMARK(FieldPathGetFromWideChunkedArray)->Arg(2)->Arg(10)->Arg(25)->Arg(100);
+BENCHMARK(FieldPathGetFromWideTable)->Arg(2)->Arg(10)->Arg(25)->Arg(100);
+
 }  // namespace arrow

From b1e85a6d0cd7a57f93b97d74bb13e89517e3d92e Mon Sep 17 00:00:00 2001
From: Li Jin <ice.xelloss@gmail.com>
Date: Tue, 8 Aug 2023 18:25:06 -0400
Subject: [PATCH 116/749] GH-36672: [Python][C++] Add support for vector
 function UDF (#36673)

### Rationale for this change
In Arrow compute, there are four main types of functions: Scalar, Vector, ScalarAggregate and HashAggregate.

Some of the previous work added support for Scalar, ScalarAggregate(https://github.com/apache/arrow/issues/35515) and HashAggregate(https://github.com/apache/arrow/issues/36252). I think it makes sense to add support for vector function as well to complete all non-decomposable UDF kernel support.

Internally, we plan to extend Acero to implement a "SegmentVectorNode" which would use this API to invoke vector on a segment by segment basis, which will allow to use constant memory to compute things like "rank the value across all rows per segment using a python UDF".

### What changes are included in this PR?
The change includes is very similar to the support for aggregate function, which includes code to register the vector UDF, and a kernel that invokes the vector UDF on given inputs.

### Are these changes tested?
Yes. Added new test.

### Are there any user-facing changes?
Yes. This adds an user-facing API to register the vector function.

* Closes: #36672

Authored-by: Li Jin <ice.xelloss@gmail.com>
Signed-off-by: Li Jin <ice.xelloss@gmail.com>
---
 python/pyarrow/_compute.pyx            | 84 +++++++++++++++++++++++++-
 python/pyarrow/compute.py              |  1 +
 python/pyarrow/includes/libarrow.pxd   |  4 ++
 python/pyarrow/src/arrow/python/udf.cc | 41 ++++++++-----
 python/pyarrow/src/arrow/python/udf.h  |  5 ++
 python/pyarrow/tests/test_udf.py       | 70 +++++++++++++++++++++
 6 files changed, 188 insertions(+), 17 deletions(-)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index ac7efeff41aba..bc3b9e8c558e0 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1964,7 +1964,7 @@ class CumulativeOptions(_CumulativeOptions):
     Parameters
     ----------
     start : Scalar, default None
-        Starting value for the cumulative operation. If none is given, 
+        Starting value for the cumulative operation. If none is given,
         a default value depending on the operation and input type is used.
     skip_nulls : bool, default False
         When false, the first encountered null is propagated.
@@ -2707,6 +2707,11 @@ cdef get_register_aggregate_function():
     reg.register_func = RegisterAggregateFunction
     return reg
 
+cdef get_register_vector_function():
+    cdef RegisterUdf reg = RegisterUdf.__new__(RegisterUdf)
+    reg.register_func = RegisterVectorFunction
+    return reg
+
 
 def register_scalar_function(func, function_name, function_doc, in_types, out_type,
                              func_registry=None):
@@ -2789,6 +2794,83 @@ def register_scalar_function(func, function_name, function_doc, in_types, out_ty
                                            out_type, func_registry)
 
 
+def register_vector_function(func, function_name, function_doc, in_types, out_type,
+                             func_registry=None):
+    """
+    Register a user-defined vector function.
+
+    This API is EXPERIMENTAL.
+
+    A vector function is a function that executes vector
+    operations on arrays. Vector function is often used
+    when compute doesn't fit other more specific types of
+    functions (e.g., scalar and aggregate).
+
+    Parameters
+    ----------
+    func : callable
+        A callable implementing the user-defined function.
+        The first argument is the context argument of type
+        UdfContext.
+        Then, it must take arguments equal to the number of
+        in_types defined. It must return an Array or Scalar
+        matching the out_type. It must return a Scalar if
+        all arguments are scalar, else it must return an Array.
+
+        To define a varargs function, pass a callable that takes
+        *args. The last in_type will be the type of all varargs
+        arguments.
+    function_name : str
+        Name of the function. There should only be one function
+        registered with this name in the function registry.
+    function_doc : dict
+        A dictionary object with keys "summary" (str),
+        and "description" (str).
+    in_types : Dict[str, DataType]
+        A dictionary mapping function argument names to
+        their respective DataType.
+        The argument names will be used to generate
+        documentation for the function. The number of
+        arguments specified here determines the function
+        arity.
+    out_type : DataType
+        Output type of the function.
+    func_registry : FunctionRegistry
+        Optional function registry to use instead of the default global one.
+
+    Examples
+    --------
+    >>> import pyarrow as pa
+    >>> import pyarrow.compute as pc
+    >>>
+    >>> func_doc = {}
+    >>> func_doc["summary"] = "percent rank"
+    >>> func_doc["description"] = "compute percent rank"
+    >>>
+    >>> def list_flatten_udf(ctx, x):
+    ...     return pc.list_flatten(x)
+    >>>
+    >>> func_name = "list_flatten_udf"
+    >>> in_types = {"array": pa.list_(pa.int64())}
+    >>> out_type = pa.int64()
+    >>> pc.register_vector_function(list_flatten_udf, func_name, func_doc,
+    ...                   in_types, out_type)
+    >>>
+    >>> answer = pc.call_function(func_name, [pa.array([[1, 2], [3, 4]])])
+    >>> answer
+    <pyarrow.lib.Int64Array object at ...>
+    [
+      1,
+      2,
+      3,
+      4
+    ]
+    """
+    return _register_user_defined_function(get_register_vector_function(),
+                                           func, function_name, function_doc, in_types,
+                                           out_type, func_registry)
+
+
 def register_aggregate_function(func, function_name, function_doc, in_types, out_type,
                                 func_registry=None):
     """
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 0fefa18dd1136..7b8983cbb98d2 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -87,6 +87,7 @@
     register_scalar_function,
     register_tabular_function,
     register_aggregate_function,
+    register_vector_function,
     UdfContext,
     # Expressions
     Expression,
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index da46cdcb750d5..f4d6541fa724c 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2815,5 +2815,9 @@ cdef extern from "arrow/python/udf.h" namespace "arrow::py" nogil:
                                       function[CallbackUdf] wrapper, const CUdfOptions& options,
                                       CFunctionRegistry* registry)
 
+    CStatus RegisterVectorFunction(PyObject* function,
+                                   function[CallbackUdf] wrapper, const CUdfOptions& options,
+                                   CFunctionRegistry* registry)
+
     CResult[shared_ptr[CRecordBatchReader]] CallTabularFunction(
         const c_string& func_name, const vector[CDatum]& args, CFunctionRegistry* registry)
diff --git a/python/pyarrow/src/arrow/python/udf.cc b/python/pyarrow/src/arrow/python/udf.cc
index 435c89f596d48..f7761a9277f0e 100644
--- a/python/pyarrow/src/arrow/python/udf.cc
+++ b/python/pyarrow/src/arrow/python/udf.cc
@@ -292,14 +292,14 @@ struct PythonUdfHashAggregatorImpl : public HashUdfAggregator {
     return out;
   }
 
-  Status Resize(KernelContext* ctx, int64_t new_num_groups) {
+  Status Resize(KernelContext* ctx, int64_t new_num_groups) override {
     // We only need to change num_groups in resize
     // similar to other hash aggregate kernels
     num_groups = new_num_groups;
     return Status::OK();
   }
 
-  Status Consume(KernelContext* ctx, const ExecSpan& batch) {
+  Status Consume(KernelContext* ctx, const ExecSpan& batch) override {
     ARROW_ASSIGN_OR_RAISE(
         std::shared_ptr<RecordBatch> rb,
         batch.ToExecBatch().ToRecordBatch(input_schema, ctx->memory_pool()));
@@ -316,7 +316,7 @@ struct PythonUdfHashAggregatorImpl : public HashUdfAggregator {
     return Status::OK();
   }
   Status Merge(KernelContext* ctx, KernelState&& other_state,
-               const ArrayData& group_id_mapping) {
+               const ArrayData& group_id_mapping) override {
     // This is similar to GroupedListImpl
     auto& other = checked_cast<PythonUdfHashAggregatorImpl&>(other_state);
     auto& other_values = other.values;
@@ -336,7 +336,7 @@ struct PythonUdfHashAggregatorImpl : public HashUdfAggregator {
     return Status::OK();
   }
 
-  Status Finalize(KernelContext* ctx, Datum* out) {
+  Status Finalize(KernelContext* ctx, Datum* out) override {
     // Exclude the last column which is the group id
     const int num_args = input_schema->num_fields() - 1;
 
@@ -484,24 +484,25 @@ Status PythonUdfExec(compute::KernelContext* ctx, const compute::ExecSpan& batch
   return SafeCallIntoPython([&]() -> Status { return udf->Exec(ctx, batch, out); });
 }
 
-Status RegisterUdf(PyObject* user_function, compute::KernelInit kernel_init,
-                   UdfWrapperCallback wrapper, const UdfOptions& options,
+template <class Function, class Kernel>
+Status RegisterUdf(PyObject* function, compute::KernelInit kernel_init,
+                   UdfWrapperCallback cb, const UdfOptions& options,
                    compute::FunctionRegistry* registry) {
-  if (!PyCallable_Check(user_function)) {
+  if (!PyCallable_Check(function)) {
     return Status::TypeError("Expected a callable Python object.");
   }
-  auto scalar_func = std::make_shared<compute::ScalarFunction>(
-      options.func_name, options.arity, options.func_doc);
-  Py_INCREF(user_function);
+  auto scalar_func =
+      std::make_shared<Function>(options.func_name, options.arity, options.func_doc);
+  Py_INCREF(function);
   std::vector<compute::InputType> input_types;
   for (const auto& in_dtype : options.input_types) {
     input_types.emplace_back(in_dtype);
   }
   compute::OutputType output_type(options.output_type);
   auto udf_data = std::make_shared<PythonUdf>(
-      std::make_shared<OwnedRefNoGIL>(user_function), wrapper,
+      std::make_shared<OwnedRefNoGIL>(function), cb,
       TypeHolder::FromTypes(options.input_types), options.output_type);
-  compute::ScalarKernel kernel(
+  Kernel kernel(
       compute::KernelSignature::Make(std::move(input_types), std::move(output_type),
                                      options.arity.is_varargs),
       PythonUdfExec, kernel_init);
@@ -522,9 +523,17 @@ Status RegisterUdf(PyObject* user_function, compute::KernelInit kernel_init,
 Status RegisterScalarFunction(PyObject* function, UdfWrapperCallback cb,
                               const UdfOptions& options,
                               compute::FunctionRegistry* registry) {
-  return RegisterUdf(function,
-                     PythonUdfKernelInit{std::make_shared<OwnedRefNoGIL>(function)}, cb,
-                     options, registry);
+  return RegisterUdf<compute::ScalarFunction, compute::ScalarKernel>(
+      function, PythonUdfKernelInit{std::make_shared<OwnedRefNoGIL>(function)}, cb,
+      options, registry);
+}
+
+Status RegisterVectorFunction(PyObject* function, UdfWrapperCallback cb,
+                              const UdfOptions& options,
+                              compute::FunctionRegistry* registry) {
+  return RegisterUdf<compute::VectorFunction, compute::VectorKernel>(
+      function, PythonUdfKernelInit{std::make_shared<OwnedRefNoGIL>(function)}, cb,
+      options, registry);
 }
 
 Status RegisterTabularFunction(PyObject* function, UdfWrapperCallback cb,
@@ -536,7 +545,7 @@ Status RegisterTabularFunction(PyObject* function, UdfWrapperCallback cb,
   if (options.output_type->id() != Type::type::STRUCT) {
     return Status::Invalid("tabular function with non-struct output");
   }
-  return RegisterUdf(
+  return RegisterUdf<compute::ScalarFunction, compute::ScalarKernel>(
       function, PythonTableUdfKernelInit{std::make_shared<OwnedRefNoGIL>(function), cb},
       cb, options, registry);
 }
diff --git a/python/pyarrow/src/arrow/python/udf.h b/python/pyarrow/src/arrow/python/udf.h
index 682cbb2ffe8d5..d8c4e430e53d4 100644
--- a/python/pyarrow/src/arrow/python/udf.h
+++ b/python/pyarrow/src/arrow/python/udf.h
@@ -67,6 +67,11 @@ Status ARROW_PYTHON_EXPORT RegisterAggregateFunction(
     PyObject* user_function, UdfWrapperCallback wrapper, const UdfOptions& options,
     compute::FunctionRegistry* registry = NULLPTR);
 
+/// \brief register a Vector user-defined-function from Python
+Status ARROW_PYTHON_EXPORT RegisterVectorFunction(
+    PyObject* user_function, UdfWrapperCallback wrapper, const UdfOptions& options,
+    compute::FunctionRegistry* registry = NULLPTR);
+
 Result<std::shared_ptr<RecordBatchReader>> ARROW_PYTHON_EXPORT
 CallTabularFunction(const std::string& func_name, const std::vector<Datum>& args,
                     compute::FunctionRegistry* registry = NULLPTR);
diff --git a/python/pyarrow/tests/test_udf.py b/python/pyarrow/tests/test_udf.py
index 5631e19455c06..62d1eb5bafd4f 100644
--- a/python/pyarrow/tests/test_udf.py
+++ b/python/pyarrow/tests/test_udf.py
@@ -299,6 +299,44 @@ def raising_func(ctx):
     return raising_func, func_name
 
 
+@pytest.fixture(scope="session")
+def unary_vector_func_fixture():
+    """
+    Reigster a vector function
+    """
+    def pct_rank(ctx, x):
+        # copy here to get around pandas 1.0 issue
+        return pa.array(x.to_pandas().copy().rank(pct=True))
+
+    func_name = "y=pct_rank(x)"
+    doc = empty_udf_doc
+    pc.register_vector_function(pct_rank, func_name, doc, {
+                                'x': pa.float64()}, pa.float64())
+
+    return pct_rank, func_name
+
+
+@pytest.fixture(scope="session")
+def struct_vector_func_fixture():
+    """
+    Reigster a vector function that returns a struct array
+    """
+    def pivot(ctx, k, v, c):
+        df = pa.RecordBatch.from_arrays([k, v, c], names=['k', 'v', 'c']).to_pandas()
+        df_pivot = df.pivot(columns='c', values='v', index='k').reset_index()
+        return pa.RecordBatch.from_pandas(df_pivot).to_struct_array()
+
+    func_name = "y=pivot(x)"
+    doc = empty_udf_doc
+    pc.register_vector_function(
+        pivot, func_name, doc,
+        {'k': pa.int64(), 'v': pa.float64(), 'c': pa.utf8()},
+        pa.struct([('k', pa.int64()), ('v1', pa.float64()), ('v2', pa.float64())])
+    )
+
+    return pivot, func_name
+
+
 def check_scalar_function(func_fixture,
                           inputs, *,
                           run_in_dataset=True,
@@ -797,3 +835,35 @@ def test_hash_agg_random(sum_agg_func_fixture):
         [("value", "sum")]).rename_columns(['id', 'value_sum_udf'])
 
     assert result.sort_by('id') == expected.sort_by('id')
+
+
+@pytest.mark.pandas
+def test_vector_basic(unary_vector_func_fixture):
+    arr = pa.array([10.0, 20.0, 30.0, 40.0, 50.0], pa.float64())
+    result = pc.call_function("y=pct_rank(x)", [arr])
+    expected = unary_vector_func_fixture[0](None, arr)
+    assert result == expected
+
+
+@pytest.mark.pandas
+def test_vector_empty(unary_vector_func_fixture):
+    arr = pa.array([1], pa.float64())
+    result = pc.call_function("y=pct_rank(x)", [arr])
+    expected = unary_vector_func_fixture[0](None, arr)
+    assert result == expected
+
+
+@pytest.mark.pandas
+def test_vector_struct(struct_vector_func_fixture):
+    k = pa.array(
+        [1, 1, 2, 2], pa.int64()
+    )
+    v = pa.array(
+        [1.0, 2.0, 3.0, 4.0], pa.float64()
+    )
+    c = pa.array(
+        ['v1', 'v2', 'v1', 'v2']
+    )
+    result = pc.call_function("y=pivot(x)", [k, v, c])
+    expected = struct_vector_func_fixture[0](None, k, v, c)
+    assert result == expected

From 77d87a97275c075e05835d6ac08be1d1c65c5c26 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 9 Aug 2023 09:12:07 +0900
Subject: [PATCH 117/749] GH-37051: [Dev][JS] Add Dependabot configuration for
 npm (#37053)

### Rationale for this change

We can add `MINOR: [JS] ` prefix to PRs from Dependabot automatically.

### What changes are included in this PR?

Add a configuration for npm.

### Are these changes tested?

No. I want to test this by merging this to main.

### Are there any user-facing changes?

No.
* Closes: #37051

Lead-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/dependabot.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 538482f96c0ee..795e1fbba9216 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -23,6 +23,12 @@ updates:
       interval: "weekly"
     commit-message:
       prefix: "MINOR: [CI] "
+  - package-ecosystem: "npm"
+    directory: "/js/"
+    schedule:
+      interval: "monthly"
+    commit-message:
+      prefix: "MINOR: [JS] "
   - package-ecosystem: "nuget"
     directory: "/csharp/"
     schedule:

From 56b6051c467447c3a6278150823b445e378192a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 9 Aug 2023 09:53:35 +0900
Subject: [PATCH 118/749] MINOR: [C#] Bump
 System.Runtime.CompilerServices.Unsafe from 4.5.3 to 4.7.1 in /csharp
 (#37074)

Bumps [System.Runtime.CompilerServices.Unsafe](https://github.com/dotnet/corefx) from 4.5.3 to 4.7.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/corefx/releases">System.Runtime.CompilerServices.Unsafe's releases</a>.</em></p>
<blockquote>
<h2>.NET Core 2.1.0 RC1</h2>
<ul>
<li><a href="https://github.com/dotnet/core/blob/master/release-notes/2.1/Preview/2.1.0-rc1.md">Release Notes</a></li>
<li><a href="https://github.com/dotnet/core/blob/master/release-notes/2.1/Preview/2.1.0-rc1-known-issues.md">Known Issues</a></li>
<li><a href="https://github.com/dotnet/core/blob/master/release-notes/download-archives/2.1.0-rc1-download.md">Download and Install</a></li>
</ul>
<h2>Repos</h2>
<ul>
<li><a href="https://github.com/dotnet/coreclr/releases/tag/v2.1-rc1">CoreCLR</a></li>
<li><a href="https://github.com/dotnet/corefx/releases/tag/v2.1-rc1">CoreFX</a></li>
<li><a href="https://github.com/dotnet/core-setup/releases/tag/v2.1-rc1">Core-Setup</a></li>
<li><a href="https://github.com/dotnet/cli/releases/tag/v2.1.300-rc1-008673">CLI</a></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/dotnet/corefx/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=System.Runtime.CompilerServices.Unsafe&package-manager=nuget&previous-version=4.5.3&new-version=4.7.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow/Apache.Arrow.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow/Apache.Arrow.csproj b/csharp/src/Apache.Arrow/Apache.Arrow.csproj
index b05533c26b22c..1eec449077479 100644
--- a/csharp/src/Apache.Arrow/Apache.Arrow.csproj
+++ b/csharp/src/Apache.Arrow/Apache.Arrow.csproj
@@ -11,7 +11,7 @@
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard'">
     <PackageReference Include="System.Buffers" Version="4.5.1" />
     <PackageReference Include="System.Memory" Version="4.5.5" />
-    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.3" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.7.1" />
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
   </ItemGroup>
 

From af94a42df82f1411e44b9163c926c2f3a9615d6f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 9 Aug 2023 09:56:02 +0900
Subject: [PATCH 119/749] MINOR: [C#] Bump ZstdSharp.Port from 0.6.7 to 0.7.2
 in /csharp (#37075)

Bumps [ZstdSharp.Port](https://github.com/oleg-st/ZstdSharp) from 0.6.7 to 0.7.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/oleg-st/ZstdSharp/releases">ZstdSharp.Port's releases</a>.</em></p>
<blockquote>
<h2>0.7.2</h2>
<p>IL2CPP compatibility (Unity)</p>
<h2>0.7.1</h2>
<p>Ported zstd v1.5.5</p>
<h2>0.7.0</h2>
<p>Ported zstd v1.5.4
Improved decompression speed (~5-10%)</p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/5bd8080e555c5efd47b5de7e9725d4be47a4c438"><code>5bd8080</code></a> 0.7.2</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/f3949372f831255002107fc85eeda9074298cb93"><code>f394937</code></a> IL2CPP compatibility</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/314fbc4c7e87c4eec503090c23d93329d25e4b59"><code>314fbc4</code></a> 0.7.1</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/8b5177c6dc59104b8f880d3920fd999b848c5ed3"><code>8b5177c</code></a> Ported zstd v1.5.5</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/e5860f6533a97aac12bb4b243ee2816a33cc4e5b"><code>e5860f6</code></a> Added some tests</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/fd8a0b67b55b8ede0d77e38fa6f58bfae294b505"><code>fd8a0b6</code></a> Update README.md</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/fe1e9e99511c44362c9233b3813dd6ac33279e64"><code>fe1e9e9</code></a> 0.7.0</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/2b79e09d8b1dcd070a09ef6a6bac7fb757cbfa7a"><code>2b79e09</code></a> Improved decompression speed</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/4cfe92fe03609ff4646e383e1e9520596dceb151"><code>4cfe92f</code></a> Fixed &quot;Invalid IL detected&quot; warnings in .NET Native (1.5.4)</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/efc49873eb164bc58e1f7356cbe9cba778d546fd"><code>efc4987</code></a> Optimized fast c loop functions</li>
<li>Additional commits viewable in <a href="https://github.com/oleg-st/ZstdSharp/compare/0.6.7...0.7.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=ZstdSharp.Port&package-manager=nuget&previous-version=0.6.7&new-version=0.7.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression/Apache.Arrow.Compression.csproj    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
index 7795d24778985..70e12835f1821 100644
--- a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
+++ b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.5" />
-    <PackageReference Include="ZstdSharp.Port" Version="0.6.7" />
+    <PackageReference Include="ZstdSharp.Port" Version="0.7.2" />
   </ItemGroup>
 
   <ItemGroup>

From f8a45482822ed75133d385ffa5e99e74daa5e2a5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 9 Aug 2023 09:57:36 +0900
Subject: [PATCH 120/749] MINOR: [C#] Bump Google.Protobuf from 3.19.3 to
 3.24.0 in /csharp (#37077)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.19.3 to 3.24.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/protocolbuffers/protobuf/releases">Google.Protobuf's releases</a>.</em></p>
<blockquote>
<h2>Protocol Buffers v3.20.3</h2>
<h1>Java</h1>
<ul>
<li>Refactoring java full runtime to reuse sub-message builders and prepare to
migrate parsing logic from parse constructor to builder.</li>
<li>Move proto wireformat parsing functionality from the private &quot;parsing
constructor&quot; to the Builder class.</li>
<li>Change the Lite runtime to prefer merging from the wireformat into mutable
messages rather than building up a new immutable object before merging. This
way results in fewer allocations and copy operations.</li>
<li>Make message-type extensions merge from wire-format instead of building up
instances and merging afterwards. This has much better performance.</li>
<li>Fix TextFormat parser to build up recurring (but supposedly not repeated)
sub-messages directly from text rather than building a new sub-message and
merging the fully formed message into the existing field.</li>
<li>This release addresses a <a href="https://github.com/protocolbuffers/protobuf/security/advisories/GHSA-h4h5-3hr4-j3g2">Security Advisory for Java users</a></li>
</ul>
<h2>Protocol Buffers v3.20.2</h2>
<h1>C++</h1>
<ul>
<li>Reduce memory consumption of MessageSet parsing</li>
<li>This release addresses a <a href="https://github.com/protocolbuffers/protobuf/security/advisories/GHSA-8gq9-2x98-w8hf">Security Advisory for C++ and Python users</a></li>
</ul>
<h2>Protocol Buffers v3.20.1</h2>
<h1>PHP</h1>
<ul>
<li>Fix building packaged PHP extension (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9727">#9727</a>)</li>
<li>Fixed composer.json to only advertise compatibility with PHP 7.0+.  (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9819">#9819</a>)</li>
</ul>
<h1>Ruby</h1>
<ul>
<li>Disable the aarch64 build on macOS until it can be fixed. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9816">#9816</a>)</li>
</ul>
<h1>Other</h1>
<ul>
<li>Fix versioning issues in 3.20.0</li>
</ul>
<h2>Protocol Buffers v3.20.1-rc1</h2>
<h1>PHP</h1>
<ul>
<li>Fix building packaged PHP extension (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9727">#9727</a>)</li>
</ul>
<h1>Other</h1>
<ul>
<li>Fix versioning issues in 3.20.0</li>
</ul>
<h2>Protocol Buffers v3.20.0</h2>
<p>2022-03-25 version 3.20.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)</p>
<h1>Ruby</h1>
<ul>
<li>Dropped Ruby 2.3 and 2.4 support for CI and releases. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9311">#9311</a>)</li>
<li>Added Ruby 3.1 support for CI and releases (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9566">#9566</a>).</li>
<li>Message.decode/encode: Add recursion_limit option (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9218">#9218</a>/<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9486">#9486</a>)</li>
<li>Allocate with xrealloc()/xfree() so message allocation is visible to the
Ruby GC.  In certain tests this leads to much lower memory usage due to more
frequent GC runs (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9586">#9586</a>).</li>
<li>Fix conversion of singleton classes in Ruby (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/9342">#9342</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/093e258a71caacc053cf5ce86977ba3131361a9a"><code>093e258</code></a> Updating version.json and repo version numbers to: 24.0</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/e48f6f75a72ae466e1012ab7e39acabdcd2f5aef"><code>e48f6f7</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13430">#13430</a> from protocolbuffers/24.x-202308011841</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/e82fc05571ad03112fa36e656a76a3128944111e"><code>e82fc05</code></a> Updating version.json to: 24.0-dev</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/3487ae0c01af9130d2ee6436de142cfff9311aba"><code>3487ae0</code></a> Updating version.json and repo version numbers to: 24.0-rc3</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/e916bf6bca6ee8f109f3ec6e2d25221490ed7fb5"><code>e916bf6</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13421">#13421</a> from zhangskz/update-24-x-dep</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/fce87eb250c2ecf7174ec2d92df8de058a0bcc65"><code>fce87eb</code></a> Update protobuf repo's upb dependency to latest 24.x commit</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/64d9df70c60b02ab7c4d869973cd49cdee4c24c8"><code>64d9df7</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13418">#13418</a> from protocolbuffers/bazel6</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/ad916a91e5eff8d22ea4f9d50832911cdebb1483"><code>ad916a9</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13417">#13417</a> from mkruskal-google/bazel6</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/bc9002ec75b80c7bc170c2339d0486c002789d69"><code>bc9002e</code></a> bazel: Get rid of exec_tools. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13401">#13401</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/fff490558816802c5b3d51169f797046f369453f"><code>fff4905</code></a> Drop support for Bazel 5.</li>
<li>Additional commits viewable in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.19.3...v3.24.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.19.3&new-version=3.24.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index ed33d88861415..8d447e5babbc2 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.19.3" />
+    <PackageReference Include="Google.Protobuf" Version="3.24.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
     <PackageReference Include="Grpc.Tools" Version="2.56.2" PrivateAssets="All" />
   </ItemGroup>

From f2b1c145dae63c1741c564b29ee29575c343ec0b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 9 Aug 2023 11:36:09 +0900
Subject: [PATCH 121/749] MINOR: [JS] Bump memfs from 3.5.3 to 4.2.1 in /js
 (#37078)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [memfs](https://github.com/streamich/memfs) from 3.5.3 to 4.2.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/streamich/memfs/releases">memfs's releases</a>.</em></p>
<blockquote>
<h2>v4.2.1</h2>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.0...v4.2.1">4.2.1</a> (2023-08-07)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>don't error when watched directory gets renamed (<a href="https://redirect.github.com/streamich/memfs/issues/939">#939</a>) (<a href="https://github.com/streamich/memfs/commit/b431b089636619113e2dd39e9dc4a2c02048270a">b431b08</a>)</li>
</ul>
<h2>memfs v4</h2>
<p><code>memfs</code> v4 has been released, install <code>4.2.0</code> NPM package.</p>
<h2>File System Access API</h2>
<p><code>memfs</code> added adapters for <a href="https://developer.mozilla.org/en-US/docs/Web/API/File_System_Access_API">File System Access</a> (FAS) API, which is a file system API available in browsers. FSA can write to a real user folder, which user picks; or without any permissions can write to a virtual file system, called OPFS (Origin Private File System). <code>memfs</code> implements adapters, which:</p>
<ul>
<li>Construct a Node's <code>fs</code>-like API out of the FSA API.
<ul>
<li>In browser, support for synchronous <code>fs</code> methods is also available using a WebWorker.</li>
</ul>
</li>
<li>Also, the other way around, <code>memfs</code> can provide FSA API on top of any <code>fs</code>-like file system.</li>
</ul>
<h2>Other notable changes</h2>
<ul>
<li>In-memory <code>fs</code> changes
<ul>
<li>A number of in-memory <code>fs</code> bugs were fixed.</li>
<li>Type interfaces of methods and options objects for in-memory <code>fs</code> were improved.</li>
<li><code>mkdirp</code> and <code>mkdripSync</code> were removed, they were deprecated before. (You can pass the <code>&quot;recursive&quot;</code> flag to <code>mkdir</code> and <code>mkdirSync</code>, instead.)</li>
<li>Many re-usable Node.js <code>fs</code> utilities now live in the <code>/src/node</code> folder.</li>
<li>Promises API methods are now bound by default to their <code>this</code> object, just like in native <code>fs</code> module.</li>
</ul>
</li>
<li><code>crudfs</code> and <code>casfs</code>
<ul>
<li><code>crudfs</code> implementation on top of Node <code>fs</code> was added.</li>
<li><code>crudfs</code> implementation on top of File System Access API was added.</li>
<li><code>casfs</code> implementation on top of <code>crudfs</code> was added.</li>
</ul>
</li>
<li><code>print</code> utility was added which allows to recursively print a directory tree to terminal.</li>
<li><code>snapshot</code> utility was added which allows to create recursive binary snapshots of folders and then load them back into some folder.</li>
<li>The <code>/demo</code> folder now contains multiple Webpack demos.</li>
<li>Build changes and deprecations
<ul>
<li>TypeScript was upgraded from version 4 to 5.</li>
<li><code>tslib</code> is now included as peer dependency, instead of TypeScript helpers being emitted into distributable.</li>
<li>TypeScript build target of the distributable is no <code>es2017</code>, instead of previously <code>es5</code>.</li>
<li>The library is now tested on Node v18+ versions.</li>
<li><code>BigInt</code> shim is no longer shipped, <code>memfs</code> will rely on the <code>BigInt</code> provided by the JavaScript environment. You can shim that global, if necessary.</li>
<li><code>fs-monkey</code> dependency was removed.</li>
</ul>
</li>
<li>New features in this major release are marked as <code>experimental</code>, which means those APIs are in preview, their public interface may have breaking changes even across minor releases.</li>
<li>CircleCI was removed, now GitHub Actions power all builds and releases.</li>
<li>The <code>next</code> branch was tested, which deploys pre-releases.</li>
</ul>
<h3>Bug Fixes</h3>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/streamich/memfs/blob/master/CHANGELOG.md">memfs's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.0...v4.2.1">4.2.1</a> (2023-08-07)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>don't error when watched directory gets renamed (<a href="https://redirect.github.com/streamich/memfs/issues/939">#939</a>) (<a href="https://github.com/streamich/memfs/commit/b431b089636619113e2dd39e9dc4a2c02048270a">b431b08</a>)</li>
</ul>
<h1><a href="https://github.com/streamich/memfs/compare/v4.0.0...v4.1.0">4.1.0</a> (2023-06-26)</h1>
<h3>Bug Fixes</h3>
<ul>
<li>🐛 add support for unknown nodes (<a href="https://github.com/streamich/memfs/commit/77786f16ca77a2658d73c3bdb29d5018a1fe9ecc">77786f1</a>)</li>
<li>🐛 allow readin into various kinds of buffers (<a href="https://github.com/streamich/memfs/commit/361812dc7d05b2c8ed1f52cb2181d0f71d9c2f4f">361812d</a>)</li>
<li>🐛 allow readin into various kinds of buffers (<a href="https://github.com/streamich/memfs/commit/e9c70e97dc2e063848baf7e3d307cd30491116a2">e9c70e9</a>)</li>
<li>🐛 allow to seek in file (<a href="https://github.com/streamich/memfs/commit/c04895b50b18996e2b7c9c4ba389baaede57fc1f">c04895b</a>)</li>
<li>🐛 allow to seek in file (<a href="https://github.com/streamich/memfs/commit/b3636899c8091a8ee1443b148fc23ebb1895ce18">b363689</a>)</li>
<li>🐛 correctly handle directory paths (<a href="https://github.com/streamich/memfs/commit/ea909e805781d19f7c3749dab65155f67b119344">ea909e8</a>)</li>
<li>🐛 do not allow empty children names (<a href="https://github.com/streamich/memfs/commit/f014fd8e19aec12163c717eed429c2a6ddc95437">f014fd8</a>)</li>
<li>🐛 do not allow empty children names (<a href="https://github.com/streamich/memfs/commit/43da1d6279e4c32543ebfd0780bf149d27a07265">43da1d6</a>)</li>
<li>🐛 handle root folder better (<a href="https://github.com/streamich/memfs/commit/89bbffde3fc2bd1e41b2c292888023b9b72cf41d">89bbffd</a>)</li>
<li>🐛 handle root folder better (<a href="https://github.com/streamich/memfs/commit/76de78002fa4ae613308227fd03ee2f643c41671">76de780</a>)</li>
<li>🐛 improve file opening and closing logic (<a href="https://github.com/streamich/memfs/commit/403c27140536b27b1137d68d493851d360b7c90f">403c271</a>)</li>
<li>🐛 throw &quot;ENOENT&quot; and &quot;ENOTDIR&quot; when folder or file 404 (<a href="https://github.com/streamich/memfs/commit/5de4faa305748006a45817f6fa8446ed7e4df5b1">5de4faa</a>)</li>
<li>🐛 throw &quot;ENOENT&quot; and &quot;ENOTDIR&quot; when folder or file 404 (<a href="https://github.com/streamich/memfs/commit/ddd5d565b33009959e32e77db8e1705809c4c29a">ddd5d56</a>)</li>
</ul>
<h3>Features</h3>
<ul>
<li>🎸 add .toTree() to Volume (<a href="https://github.com/streamich/memfs/commit/2d5c4cb8097f7b09b223d980efe9e14a2576ed6f">2d5c4cb</a>)</li>
<li>🎸 add .truncate() method (<a href="https://github.com/streamich/memfs/commit/038ab36d1ac8b24428a11135fe9affe95c99e587">038ab36</a>)</li>
<li>🎸 add .truncate() method (<a href="https://github.com/streamich/memfs/commit/085335ca8736b67db05c02bbd11cccf5b9bf000b">085335c</a>)</li>
<li>🎸 add ability to close files (<a href="https://github.com/streamich/memfs/commit/0db56becb255d4fce72fce16fa8cc120c07ed41a">0db56be</a>)</li>
<li>🎸 add ability to close files (<a href="https://github.com/streamich/memfs/commit/d3828a8058808ebdcd055493f4c2f72e3bcb58e7">d3828a8</a>)</li>
<li>🎸 add ability to create sub directories (<a href="https://github.com/streamich/memfs/commit/8f15bd9dd4f6e00360a000aaaf865af984ca2559">8f15bd9</a>)</li>
<li>🎸 add ability to create sub directories (<a href="https://github.com/streamich/memfs/commit/528c807281a0f920d4c819eebef942cd250b4479">528c807</a>)</li>
<li>🎸 add ability to remove all files (<a href="https://github.com/streamich/memfs/commit/76cabc763c280bc23abb8d873f5fa304ce8fcef6">76cabc7</a>)</li>
<li>🎸 add ability to remove all files (<a href="https://github.com/streamich/memfs/commit/566e29b543825e6bc71c9b881ce05e93ee657eca">566e29b</a>)</li>
<li>🎸 add appendFileSync() method (<a href="https://github.com/streamich/memfs/commit/57192fe98112970fcda201fcf240c57da071cdae">57192fe</a>)</li>
<li>🎸 add appendFileSync() method (<a href="https://github.com/streamich/memfs/commit/27411e40125d8fb86e13977735d9122166d55961">27411e4</a>)</li>
<li>🎸 add basenem() utility (<a href="https://github.com/streamich/memfs/commit/8b276956876c270dda1e5f7930392daa9a97acf5">8b27695</a>)</li>
<li>🎸 add basenem() utility (<a href="https://github.com/streamich/memfs/commit/43354e5a024c8be28a897c53e1d4ea5b46b66d39">43354e5</a>)</li>
<li>🎸 add binary serialization to snapshots (<a href="https://github.com/streamich/memfs/commit/c1cd615d7172023c2c7a40b61767d8a3470c9b33">c1cd615</a>)</li>
<li>🎸 add copyFile() method (<a href="https://github.com/streamich/memfs/commit/de2bb0aae0c5380dde78689ac1376862f26c6af9">de2bb0a</a>)</li>
<li>🎸 add copyFile() method (<a href="https://github.com/streamich/memfs/commit/5e207c4a60019f4df187510682d83a0597df2468">5e207c4</a>)</li>
<li>🎸 add copyFileSync() method (<a href="https://github.com/streamich/memfs/commit/7e0137c23c4b0254e1cf40fcad0349f282d4a556">7e0137c</a>)</li>
<li>🎸 add copyFileSync() method (<a href="https://github.com/streamich/memfs/commit/5fc1bacf4a337ca25d0207a0e9f94768c2976528">5fc1bac</a>)</li>
<li>🎸 add createSwapFile() method (<a href="https://github.com/streamich/memfs/commit/dfdb90893bf67b035337fc059b44f7ad9dfba6a7">dfdb908</a>)</li>
<li>🎸 add createSwapFile() method (<a href="https://github.com/streamich/memfs/commit/b07ce795e757cab67ab4b81e50c397486e32ba40">b07ce79</a>)</li>
<li>🎸 add crudfs types (<a href="https://github.com/streamich/memfs/commit/18c0658124a83e7819022ccb415d163b88e7abbb">18c0658</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/streamich/memfs/commit/a16834f7c9a8a24985473f5dab638f60d1410174"><code>a16834f</code></a> chore(release): 4.2.1 [skip ci]</li>
<li><a href="https://github.com/streamich/memfs/commit/b431b089636619113e2dd39e9dc4a2c02048270a"><code>b431b08</code></a> fix: don't error when watched directory gets renamed (<a href="https://redirect.github.com/streamich/memfs/issues/939">#939</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/cd6c25698536aab8845774c4a0036376a0fd599f"><code>cd6c256</code></a> chore(deps): bump semver from 5.7.1 to 5.7.2 (<a href="https://redirect.github.com/streamich/memfs/issues/935">#935</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/3356138893ac68619cb671abd10654b63c570ba9"><code>3356138</code></a> Merge pull request <a href="https://redirect.github.com/streamich/memfs/issues/903">#903</a> from streamich/renovate/rimraf-5.x</li>
<li><a href="https://github.com/streamich/memfs/commit/af1e9d1f4d8df206dc5670893a7a390a4bb326f4"><code>af1e9d1</code></a> Release 4.2.0</li>
<li><a href="https://github.com/streamich/memfs/commit/75e60a50621649f4f303427cc5b6d1a9942ffcf5"><code>75e60a5</code></a> docs: remove v4 notice</li>
<li><a href="https://github.com/streamich/memfs/commit/7556e5be4c40b9abd41c25fb687e6efe34f2cbb7"><code>7556e5b</code></a> chore(release): 4.1.0 [skip ci]</li>
<li><a href="https://github.com/streamich/memfs/commit/51c40524034bd4a6180acc6a4e8b9ed8393f6324"><code>51c4052</code></a> chore(deps): update dependency rimraf to v5</li>
<li><a href="https://github.com/streamich/memfs/commit/32dd55af51e8374f98bb6818c9688233d15cc60f"><code>32dd55a</code></a> Merge pull request <a href="https://redirect.github.com/streamich/memfs/issues/926">#926</a> from streamich/next</li>
<li><a href="https://github.com/streamich/memfs/commit/491272bcc0179b005694d59a6dd437445f49ead2"><code>491272b</code></a> chore: 🤖 bump compile target to es2017</li>
<li>Additional commits viewable in <a href="https://github.com/streamich/memfs/compare/v3.5.3...v4.2.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=memfs&package-manager=npm_and_yarn&previous-version=3.5.3&new-version=4.2.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 39 +++++++++++++++++++++++++++++----------
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/js/package.json b/js/package.json
index bcb43e8bd0e31..510d1afd9a659 100644
--- a/js/package.json
+++ b/js/package.json
@@ -100,7 +100,7 @@
     "jest": "29.5.0",
     "jest-silent-reporter": "0.5.0",
     "lerna": "7.0.0",
-    "memfs": "3.5.3",
+    "memfs": "4.2.1",
     "mkdirp": "3.0.1",
     "multistream": "4.1.0",
     "randomatic": "3.1.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index bda4faa3b17cb..eae220fc84f72 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -2030,6 +2030,11 @@ arg@^4.1.0:
   resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
   integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
 
+arg@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
+  integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
+
 argparse@^1.0.7:
   version "1.0.10"
   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
@@ -4162,11 +4167,6 @@ fs-mkdirp-stream@^1.0.0:
     graceful-fs "^4.1.11"
     through2 "^2.0.3"
 
-fs-monkey@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/fs-monkey/-/fs-monkey-1.0.4.tgz#ee8c1b53d3fe8bb7e5d2c5c5dfc0168afdd2f747"
-  integrity sha512-INM/fWAxMICjttnD0DX1rBvinKskj5G1w+oy/pnm9u/tSlnBrzFonJMcalKJ30P8RRsPzKcCG7Q8l0jx5Fh9YQ==
-
 fs.realpath@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
@@ -4827,6 +4827,11 @@ humanize-ms@^1.2.1:
   dependencies:
     ms "^2.0.0"
 
+hyperdyperid@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/hyperdyperid/-/hyperdyperid-1.2.0.tgz#59668d323ada92228d2a869d3e474d5a33b69e6b"
+  integrity sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==
+
 iconv-lite@^0.4.24:
   version "0.4.24"
   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
@@ -5793,6 +5798,14 @@ json-bignum@^0.0.3:
   resolved "https://registry.yarnpkg.com/json-bignum/-/json-bignum-0.0.3.tgz#41163b50436c773d82424dbc20ed70db7604b8d7"
   integrity sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==
 
+json-joy@^9.2.0:
+  version "9.5.1"
+  resolved "https://registry.yarnpkg.com/json-joy/-/json-joy-9.5.1.tgz#056683b4db4b0e279451a563a756b70b9fd97fa3"
+  integrity sha512-XMSpdxaiWUZlc+CAUbPS3G2MZbGxm6clFatqjta/DLrq5V4Y5JU4cx7Qvy7l+XTVPvmRWaYuzzAuCf9uUc40IA==
+  dependencies:
+    arg "^5.0.2"
+    hyperdyperid "^1.2.0"
+
 json-parse-better-errors@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
@@ -6339,12 +6352,13 @@ math-random@^1.0.1:
   resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
   integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==
 
-memfs@3.5.3:
-  version "3.5.3"
-  resolved "https://registry.yarnpkg.com/memfs/-/memfs-3.5.3.tgz#d9b40fe4f8d5788c5f895bda804cd0d9eeee9f3b"
-  integrity sha512-UERzLsxzllchadvbPs5aolHh65ISpKpM+ccLbOJ8/vvpBKmAWf+la7dXFy7Mr0ySHbdHrFv5kGFCUHHe6GFEmw==
+memfs@4.2.1:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-4.2.1.tgz#8c5a48707a460dde8e734b15e405e8377db2bec5"
+  integrity sha512-CINEB6cNAAhLUfRGrB4lj2Pj47ygerEmw3jxPb6R1gkD6Jfp484gJLteQ6MzqIjGWtFWuVzDl+KN7HiipMuKSw==
   dependencies:
-    fs-monkey "^1.0.4"
+    json-joy "^9.2.0"
+    thingies "^1.11.1"
 
 memoizee@0.4.X:
   version "0.4.15"
@@ -8703,6 +8717,11 @@ textextensions@^3.2.0:
   resolved "https://registry.yarnpkg.com/textextensions/-/textextensions-3.3.0.tgz#03530d5287b86773c08b77458589148870cc71d3"
   integrity sha512-mk82dS8eRABNbeVJrEiN5/UMSCliINAuz8mkUwH4SwslkNP//gbEzlWNS5au0z5Dpx40SQxzqZevZkn+WYJ9Dw==
 
+thingies@^1.11.1:
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/thingies/-/thingies-1.12.0.tgz#a815c224482d607aa70f563d3cbb351a338e4710"
+  integrity sha512-AiGqfYC1jLmJagbzQGuoZRM48JPsr9yB734a7K6wzr34NMhjUPrWSQrkF7ZBybf3yCerCL2Gcr02kMv4NmaZfA==
+
 through2-filter@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/through2-filter/-/through2-filter-3.0.0.tgz#700e786df2367c2c88cd8aa5be4cf9c1e7831254"

From b668595dda38beb7bfd5b5528c3200402590c1eb Mon Sep 17 00:00:00 2001
From: Joe Marshall <joe.marshall@nottingham.ac.uk>
Date: Wed, 9 Aug 2023 03:50:03 +0100
Subject: [PATCH 122/749] GH-35176: [C++] Add support for disabling threading
 for emscripten (#35672)

As previously discussed in #35176 this is a patch that adds an option `ARROW_ENABLE_THREADING`. When it is turned off, arrow threadpool and serial executors don't spawn threads, and instead run tasks in the main thread when futures are waited for.

It doesn't mess with threading in projects included as dependencies, e.g. multithreaded malloc implementations because if you're building for a non threaded environment, you can't use those anyway.

Basically where this is at is that it runs the test suite okay, and I think should work well enough to be a backend for pandas on emscripten/pyodide.

What this means is:
1) It is possible to use arrow in non-threaded emscripten/webassembly environments (with some build patches specific to emscripten which I'll put in once this is in)
2) Most of arrow just works, albeit slower in parts.

Things that don't work and probably won't:
1) Server stuff that relies on threads. Not a massive problem I think because environments with threading restrictions are currently typically also restricted from making servers anyway (i.e. they are web browsers)
2) Anything that relies on actually doing two things at once (for obvious reasons)

Things that don't work yet and could be fixed in future:
1) use of asynchronous file/network APIs in emscripten which would mean I/O could work efficiently in one thread.
2) asofjoin - right now the implementation relies on std::thread - it needs refactoring to work with threadpool like everything else in arrow, but I'm not sure I am expert enough in the codebase to do it well.
* Closes: #35176

Lead-authored-by: Joe Marshall <joe.marshall@nottingham.ac.uk>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/cpp_build.sh                       |   1 +
 cpp/cmake_modules/DefineOptions.cmake         |   2 +
 cpp/src/arrow/acero/CMakeLists.txt            |  21 +-
 cpp/src/arrow/acero/asof_join_node.cc         |   5 +
 cpp/src/arrow/acero/bloom_filter.cc           |   4 +
 cpp/src/arrow/acero/bloom_filter_test.cc      |   7 +-
 cpp/src/arrow/acero/plan_test.cc              |   4 +
 cpp/src/arrow/acero/task_util.cc              |   5 +
 cpp/src/arrow/acero/task_util.h               |   1 +
 cpp/src/arrow/acero/task_util_test.cc         |   7 +
 cpp/src/arrow/dataset/dataset_writer_test.cc  |  10 +
 cpp/src/arrow/engine/substrait/serde_test.cc  |  11 +
 cpp/src/arrow/io/memory_test.cc               |   4 +
 cpp/src/arrow/testing/gtest_util.cc           |  89 ++++++
 cpp/src/arrow/util/async_generator_test.cc    |  11 +
 cpp/src/arrow/util/config.h.cmake             |   1 +
 cpp/src/arrow/util/future.cc                  |  33 ++-
 cpp/src/arrow/util/future_test.cc             |   7 +-
 cpp/src/arrow/util/iterator_test.cc           |   2 +
 cpp/src/arrow/util/task_group.cc              |   8 +
 cpp/src/arrow/util/thread_pool.cc             | 257 +++++++++++++++++-
 cpp/src/arrow/util/thread_pool.h              | 103 ++++++-
 cpp/src/arrow/util/thread_pool_test.cc        |  41 +++
 .../parquet/encryption/key_management_test.cc |   6 +
 dev/tasks/tasks.yml                           |   9 +
 25 files changed, 629 insertions(+), 20 deletions(-)

diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index e53b3fa460915..f71724cf61eb4 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -106,6 +106,7 @@ cmake \
   -DARROW_C_FLAGS_RELWITHDEBINFO="${ARROW_C_FLAGS_RELWITHDEBINFO:-}" \
   -DARROW_DATASET=${ARROW_DATASET:-ON} \
   -DARROW_DEPENDENCY_SOURCE=${ARROW_DEPENDENCY_SOURCE:-AUTO} \
+  -DARROW_ENABLE_THREADING=${ARROW_ENABLE_THREADING:-ON} \
   -DARROW_ENABLE_TIMING_TESTS=${ARROW_ENABLE_TIMING_TESTS:-ON} \
   -DARROW_EXTRA_ERROR_CONTEXT=${ARROW_EXTRA_ERROR_CONTEXT:-OFF} \
   -DARROW_FILESYSTEM=${ARROW_FILESYSTEM:-ON} \
diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index f32bb2bcf7290..29517567ce6e5 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -196,6 +196,8 @@ takes precedence over ccache if a storage backend is configured" ON)
 
   define_option(ARROW_WITH_MUSL "Whether the system libc is musl or not" OFF)
 
+  define_option(ARROW_ENABLE_THREADING "Enable threading in Arrow core" ON)
+
   #----------------------------------------------------------------------
   set_option_category("Test and benchmark")
 
diff --git a/cpp/src/arrow/acero/CMakeLists.txt b/cpp/src/arrow/acero/CMakeLists.txt
index c2c91db58d38a..44fbb26f0814d 100644
--- a/cpp/src/arrow/acero/CMakeLists.txt
+++ b/cpp/src/arrow/acero/CMakeLists.txt
@@ -173,7 +173,14 @@ add_arrow_acero_test(hash_join_node_test SOURCES hash_join_node_test.cc
                      bloom_filter_test.cc)
 add_arrow_acero_test(pivot_longer_node_test SOURCES pivot_longer_node_test.cc
                      test_nodes.cc)
-add_arrow_acero_test(asof_join_node_test SOURCES asof_join_node_test.cc test_nodes.cc)
+
+# asof_join_node uses std::thread internally
+# and doesn't use ThreadPool so it will
+# be broken if threading is turned off
+if(ARROW_ENABLE_THREADING)
+  add_arrow_acero_test(asof_join_node_test SOURCES asof_join_node_test.cc test_nodes.cc)
+endif()
+
 add_arrow_acero_test(tpch_node_test SOURCES tpch_node_test.cc)
 add_arrow_acero_test(union_node_test SOURCES union_node_test.cc)
 add_arrow_acero_test(aggregate_node_test SOURCES aggregate_node_test.cc)
@@ -221,7 +228,9 @@ if(ARROW_BUILD_BENCHMARKS)
   add_arrow_acero_benchmark(project_benchmark SOURCES benchmark_util.cc
                             project_benchmark.cc)
 
-  add_arrow_acero_benchmark(asof_join_benchmark SOURCES asof_join_benchmark.cc)
+  if(ARROW_ENABLE_THREADING)
+    add_arrow_acero_benchmark(asof_join_benchmark SOURCES asof_join_benchmark.cc)
+  endif()
 
   add_arrow_acero_benchmark(tpch_benchmark SOURCES tpch_benchmark.cc)
 
@@ -244,7 +253,9 @@ if(ARROW_BUILD_BENCHMARKS)
     target_link_libraries(arrow-acero-expression-benchmark PUBLIC arrow_acero_static)
     target_link_libraries(arrow-acero-filter-benchmark PUBLIC arrow_acero_static)
     target_link_libraries(arrow-acero-project-benchmark PUBLIC arrow_acero_static)
-    target_link_libraries(arrow-acero-asof-join-benchmark PUBLIC arrow_acero_static)
+    if(ARROW_ENABLE_THREADING)
+      target_link_libraries(arrow-acero-asof-join-benchmark PUBLIC arrow_acero_static)
+    endif()
     target_link_libraries(arrow-acero-tpch-benchmark PUBLIC arrow_acero_static)
     if(ARROW_BUILD_OPENMP_BENCHMARKS)
       target_link_libraries(arrow-acero-hash-join-benchmark PUBLIC arrow_acero_static)
@@ -253,7 +264,9 @@ if(ARROW_BUILD_BENCHMARKS)
     target_link_libraries(arrow-acero-expression-benchmark PUBLIC arrow_acero_shared)
     target_link_libraries(arrow-acero-filter-benchmark PUBLIC arrow_acero_shared)
     target_link_libraries(arrow-acero-project-benchmark PUBLIC arrow_acero_shared)
-    target_link_libraries(arrow-acero-asof-join-benchmark PUBLIC arrow_acero_shared)
+    if(ARROW_ENABLE_THREADING)
+      target_link_libraries(arrow-acero-asof-join-benchmark PUBLIC arrow_acero_shared)
+    endif()
     target_link_libraries(arrow-acero-tpch-benchmark PUBLIC arrow_acero_shared)
     if(ARROW_BUILD_OPENMP_BENCHMARKS)
       target_link_libraries(arrow-acero-hash-join-benchmark PUBLIC arrow_acero_shared)
diff --git a/cpp/src/arrow/acero/asof_join_node.cc b/cpp/src/arrow/acero/asof_join_node.cc
index b7f5d878e5881..23c07b8acb95f 100644
--- a/cpp/src/arrow/acero/asof_join_node.cc
+++ b/cpp/src/arrow/acero/asof_join_node.cc
@@ -49,6 +49,7 @@
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/future.h"
 #include "arrow/util/string.h"
 
@@ -1707,6 +1708,10 @@ class AsofJoinNode : public ExecNode {
   }
 
   Status StartProducing() override {
+#ifndef ARROW_ENABLE_THREADING
+    return Status::NotImplemented("ASOF join requires threading enabled");
+#endif
+
     ARROW_ASSIGN_OR_RAISE(process_task_, plan_->query_context()->BeginExternalTask(
                                              "AsofJoinNode::ProcessThread"));
     if (!process_task_.is_valid()) {
diff --git a/cpp/src/arrow/acero/bloom_filter.cc b/cpp/src/arrow/acero/bloom_filter.cc
index b9855ee506d27..db39ad1a83cab 100644
--- a/cpp/src/arrow/acero/bloom_filter.cc
+++ b/cpp/src/arrow/acero/bloom_filter.cc
@@ -20,6 +20,7 @@
 #include "arrow/acero/util.h"       // PREFETCH
 #include "arrow/util/bit_util.h"    // Log2
 #include "arrow/util/bitmap_ops.h"  // CountSetBits
+#include "arrow/util/config.h"
 
 namespace arrow {
 namespace acero {
@@ -426,6 +427,9 @@ void BloomFilterBuilder_Parallel::CleanUp() {
 
 std::unique_ptr<BloomFilterBuilder> BloomFilterBuilder::Make(
     BloomFilterBuildStrategy strategy) {
+#ifndef ARROW_ENABLE_THREADING
+  strategy = BloomFilterBuildStrategy::SINGLE_THREADED;
+#endif
   switch (strategy) {
     case BloomFilterBuildStrategy::SINGLE_THREADED: {
       std::unique_ptr<BloomFilterBuilder> impl{new BloomFilterBuilder_SingleThreaded()};
diff --git a/cpp/src/arrow/acero/bloom_filter_test.cc b/cpp/src/arrow/acero/bloom_filter_test.cc
index 95375e277e2b8..bad331cfd99d1 100644
--- a/cpp/src/arrow/acero/bloom_filter_test.cc
+++ b/cpp/src/arrow/acero/bloom_filter_test.cc
@@ -29,6 +29,8 @@
 #include "arrow/acero/util.h"
 #include "arrow/compute/key_hash.h"
 #include "arrow/util/bitmap_ops.h"
+#include "arrow/util/config.h"
+#include "arrow/util/cpu_info.h"
 
 namespace arrow {
 
@@ -468,7 +470,7 @@ TEST(BloomFilter, Basic) {
 
   std::vector<BloomFilterBuildStrategy> strategies;
   strategies.push_back(BloomFilterBuildStrategy::SINGLE_THREADED);
-#ifndef ARROW_VALGRIND
+#if defined(ARROW_ENABLE_THREADING) && !defined(ARROW_VALGRIND)
   strategies.push_back(BloomFilterBuildStrategy::PARALLEL);
 #endif
 
@@ -501,7 +503,10 @@ TEST(BloomFilter, Scaling) {
   num_build.push_back(4000000);
 
   std::vector<BloomFilterBuildStrategy> strategies;
+#ifdef ARROW_ENABLE_THREADING
   strategies.push_back(BloomFilterBuildStrategy::PARALLEL);
+#endif
+  strategies.push_back(BloomFilterBuildStrategy::SINGLE_THREADED);
 
   for (const auto hardware_flags : HardwareFlagsForTesting()) {
     for (const auto& strategy : strategies) {
diff --git a/cpp/src/arrow/acero/plan_test.cc b/cpp/src/arrow/acero/plan_test.cc
index ff7d2d7eca1a6..03e10483ebf00 100644
--- a/cpp/src/arrow/acero/plan_test.cc
+++ b/cpp/src/arrow/acero/plan_test.cc
@@ -36,6 +36,7 @@
 #include "arrow/testing/matchers.h"
 #include "arrow/testing/random.h"
 #include "arrow/util/async_generator.h"
+#include "arrow/util/config.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/thread_pool.h"
@@ -1619,6 +1620,9 @@ TEST(ExecPlan, SourceEnforcesBatchLimit) {
 }
 
 TEST(ExecPlanExecution, SegmentedAggregationWithMultiThreading) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading enabled";
+#endif
   BatchesWithSchema data;
   data.batches = {ExecBatchFromJSON({int32()}, "[[1]]")};
   data.schema = schema({field("i32", int32())});
diff --git a/cpp/src/arrow/acero/task_util.cc b/cpp/src/arrow/acero/task_util.cc
index 8127902e69e94..4d8e9ecf76597 100644
--- a/cpp/src/arrow/acero/task_util.cc
+++ b/cpp/src/arrow/acero/task_util.cc
@@ -20,6 +20,7 @@
 #include <algorithm>
 #include <mutex>
 
+#include "arrow/util/config.h"
 #include "arrow/util/logging.h"
 
 namespace arrow {
@@ -316,7 +317,11 @@ Status TaskSchedulerImpl::StartScheduling(size_t thread_id, ScheduleImpl schedul
                                           int num_concurrent_tasks,
                                           bool use_sync_execution) {
   schedule_impl_ = std::move(schedule_impl);
+#ifdef ARROW_ENABLE_THREADING
   use_sync_execution_ = use_sync_execution;
+#else
+  use_sync_execution_ = true;
+#endif
   num_concurrent_tasks_ = num_concurrent_tasks;
   num_tasks_to_schedule_.value += num_concurrent_tasks;
   return ScheduleMore(thread_id);
diff --git a/cpp/src/arrow/acero/task_util.h b/cpp/src/arrow/acero/task_util.h
index bc19396bd243b..fbd4af699d127 100644
--- a/cpp/src/arrow/acero/task_util.h
+++ b/cpp/src/arrow/acero/task_util.h
@@ -24,6 +24,7 @@
 
 #include "arrow/acero/visibility.h"
 #include "arrow/status.h"
+#include "arrow/util/config.h"
 #include "arrow/util/logging.h"
 
 namespace arrow {
diff --git a/cpp/src/arrow/acero/task_util_test.cc b/cpp/src/arrow/acero/task_util_test.cc
index dafb6b24b4cdd..d5196ad4e0a03 100644
--- a/cpp/src/arrow/acero/task_util_test.cc
+++ b/cpp/src/arrow/acero/task_util_test.cc
@@ -27,6 +27,7 @@
 
 #include "arrow/acero/util.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/util/config.h"
 #include "arrow/util/thread_pool.h"
 
 namespace arrow {
@@ -101,6 +102,9 @@ TaskScheduler::TaskGroupContinuationImpl MakeFinalContinuation(
 // concurrently.  When all groups in that stage finish the next
 // stage is started.
 TEST(TaskScheduler, Stress) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   constexpr int kNumThreads = 8;
   constexpr int kNumGroups = 8;
   constexpr int kGroupsPerStage = 3;
@@ -176,6 +180,9 @@ TEST(TaskScheduler, Stress) {
 // thread starts a task group while another thread is finishing
 // the last of its tasks.
 TEST(TaskScheduler, StressTwo) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   constexpr int kNumThreads = 16;
   constexpr int kNumGroups = 8;
   constexpr int kTasksPerGroup = 1;
diff --git a/cpp/src/arrow/dataset/dataset_writer_test.cc b/cpp/src/arrow/dataset/dataset_writer_test.cc
index d2480cd482fc6..c76e79d79b449 100644
--- a/cpp/src/arrow/dataset/dataset_writer_test.cc
+++ b/cpp/src/arrow/dataset/dataset_writer_test.cc
@@ -31,6 +31,7 @@
 #include "arrow/table.h"
 #include "arrow/testing/future_util.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/util/config.h"
 #include "gtest/gtest.h"
 
 using namespace std::string_view_literals;  // NOLINT
@@ -380,6 +381,9 @@ TEST_F(DatasetWriterTestFixture, MinRowGroupBackpressure) {
 }
 
 TEST_F(DatasetWriterTestFixture, ConcurrentWritesSameFile) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Concurrent writes tests need threads";
+#endif
   // Use a gated filesystem to queue up many writes behind a file open to make sure the
   // file isn't opened multiple times.
   auto gated_fs = UseGatedFs();
@@ -394,6 +398,9 @@ TEST_F(DatasetWriterTestFixture, ConcurrentWritesSameFile) {
 }
 
 TEST_F(DatasetWriterTestFixture, ConcurrentWritesDifferentFiles) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Concurrent writes tests need threads";
+#endif
   // NBATCHES must be less than I/O executor concurrency to avoid deadlock / test failure
   constexpr int NBATCHES = 6;
   auto gated_fs = UseGatedFs();
@@ -412,6 +419,9 @@ TEST_F(DatasetWriterTestFixture, ConcurrentWritesDifferentFiles) {
 }
 
 TEST_F(DatasetWriterTestFixture, MaxOpenFiles) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Concurrent writes tests need threads";
+#endif
   auto gated_fs = UseGatedFs();
   std::atomic<bool> paused = false;
   write_options_.max_open_files = 2;
diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc
index 6342388744f39..efe1f702b4868 100644
--- a/cpp/src/arrow/engine/substrait/serde_test.cc
+++ b/cpp/src/arrow/engine/substrait/serde_test.cc
@@ -71,6 +71,7 @@
 #include "arrow/type_fwd.h"
 #include "arrow/util/async_generator_fwd.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/decimal.h"
 #include "arrow/util/future.h"
 #include "arrow/util/hash_util.h"
@@ -4458,6 +4459,9 @@ TEST(Substrait, SetRelationBasic) {
 }
 
 TEST(Substrait, PlanWithAsOfJoinExtension) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "ASOF join requires threading";
+#endif
   // This demos an extension relation
   std::string substrait_json = R"({
     "extensionUris": [],
@@ -5477,6 +5481,10 @@ TEST(Substrait, MixedSort) {
 }
 
 TEST(Substrait, PlanWithExtension) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "ASOF join requires threading";
+#endif
+
   // This demos an extension relation
   std::string substrait_json = R"({
     "extensionUris": [],
@@ -5665,6 +5673,9 @@ TEST(Substrait, PlanWithExtension) {
 }
 
 TEST(Substrait, AsOfJoinDefaultEmit) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "ASOF join requires threading";
+#endif
   std::string substrait_json = R"({
     "extensionUris": [],
     "extensions": [],
diff --git a/cpp/src/arrow/io/memory_test.cc b/cpp/src/arrow/io/memory_test.cc
index 216d75f65ebb0..22f9a02fdbec8 100644
--- a/cpp/src/arrow/io/memory_test.cc
+++ b/cpp/src/arrow/io/memory_test.cc
@@ -42,6 +42,7 @@
 #include "arrow/testing/util.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/future.h"
 #include "arrow/util/iterator.h"
 #include "arrow/util/logging.h"
@@ -918,6 +919,9 @@ TEST(CacheOptions, Basics) {
 }
 
 TEST(IOThreadPool, Capacity) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading enabled";
+#endif
   // Simple sanity check
   auto pool = internal::GetIOThreadPool();
   int capacity = pool->GetCapacity();
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index 6fc709874e710..c6de6b02fc8ef 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -55,6 +55,7 @@
 #include "arrow/table.h"
 #include "arrow/type.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/future.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging.h"
@@ -725,8 +726,25 @@ void TestInitialized(const ArrayData& array) {
 }
 
 void SleepFor(double seconds) {
+#ifdef ARROW_ENABLE_THREADING
   std::this_thread::sleep_for(
       std::chrono::nanoseconds(static_cast<int64_t>(seconds * 1e9)));
+#else
+  using Clock = std::chrono::steady_clock;
+  using DurationDouble = std::chrono::duration<double>;
+
+  auto secs_left = DurationDouble(seconds);
+  auto start_time = Clock::now();
+  auto end_time = start_time + secs_left;
+  while (Clock::now() < end_time) {
+    bool run_task = arrow::internal::SerialExecutor::RunTasksOnAllExecutors();
+    if (!run_task) {
+      // all executors are empty, just sleep for the rest of the time
+      std::this_thread::sleep_for(end_time - Clock::now());
+    }
+    // run one task then check time
+  }
+#endif
 }
 
 #ifdef _WIN32
@@ -1036,7 +1054,57 @@ class GatingTask::Impl : public std::enable_shared_from_this<GatingTask::Impl> {
     return unlocked_future_;
   }
 
+  void WaitForEndOrUnlocked(std::chrono::time_point<std::chrono::steady_clock> end_time,
+                            arrow::internal::Executor* executor, Future<> future) {
+    if (unlocked_) {
+      num_finished_++;
+      future.MarkFinished(Status::OK());
+      return;
+    }
+    if (std::chrono::steady_clock::now() > end_time) {
+      num_finished_++;
+      future.MarkFinished(
+          Status::Invalid("Task unlock never happened - if threads are disabled you "
+                          "can't wait on gatedtask"));
+      return;
+    }
+
+    SleepABit();
+    auto spawn_status = executor->Spawn([this, end_time, executor, future]() {
+      WaitForEndOrUnlocked(end_time, executor, future);
+    });
+    if (!spawn_status.ok()) {
+      status_ &= Status::Invalid("Couldn't spawn gating task unlock waiter");
+    }
+  }
+
+  Future<> RunTaskFuture() {
+    num_running_++;
+    // post the unlock check as a separate task
+    // otherwise we'll never let anything else run
+    // so nothing can unlock us
+    using Clock = std::chrono::steady_clock;
+    using DurationDouble = std::chrono::duration<double>;
+    using DurationClock = std::chrono::steady_clock::duration;
+
+    auto start_time = Clock::now();
+    auto secs_left = DurationDouble(timeout_seconds_);
+    auto end_time = std::chrono::time_point_cast<DurationClock, Clock, DurationDouble>(
+        start_time + secs_left);
+    auto executor = arrow::internal::GetCpuThreadPool();
+    auto future = Future<>::Make();
+    auto spawn_status = executor->Spawn([this, end_time, executor, future]() {
+      WaitForEndOrUnlocked(end_time, executor, future);
+    });
+    if (!spawn_status.ok()) {
+      status_ &= Status::Invalid("Couldn't spawn gating task unlock waiter");
+      future.MarkFinished(Status::Invalid(""));
+    }
+    return future;
+  }
+
   void RunTask() {
+#ifdef ARROW_ENABLE_THREADING
     std::unique_lock<std::mutex> lk(mx_);
     num_running_++;
     running_cv_.notify_all();
@@ -1048,9 +1116,16 @@ class GatingTask::Impl : public std::enable_shared_from_this<GatingTask::Impl> {
                                  " seconds) waiting for the gating task to be unlocked");
     }
     num_finished_++;
+#else
+    // can't wait here for anything, so make a future to do the waiting
+    num_running_++;
+    auto future = RunTaskFuture();
+    future.Wait();
+#endif
   }
 
   Status WaitForRunning(int count) {
+#ifdef ARROW_ENABLE_THREADING
     std::unique_lock<std::mutex> lk(mx_);
     if (running_cv_.wait_for(
             lk, std::chrono::nanoseconds(static_cast<int64_t>(timeout_seconds_ * 1e9)),
@@ -1058,6 +1133,14 @@ class GatingTask::Impl : public std::enable_shared_from_this<GatingTask::Impl> {
       return Status::OK();
     }
     return Status::Invalid("Timed out waiting for tasks to launch");
+#else
+    BusyWait(timeout_seconds_, [this, count] { return num_running_ >= count; });
+    if (num_running_ >= count) {
+      return Status::OK();
+    } else {
+      return Status::Invalid("Timed out waiting for tasks to launch");
+    }
+#endif
   }
 
   Status Unlock() {
@@ -1067,6 +1150,12 @@ class GatingTask::Impl : public std::enable_shared_from_this<GatingTask::Impl> {
       unlocked_cv_.notify_all();
     }
     unlocked_future_.MarkFinished();
+#ifndef ARROW_ENABLE_THREADING
+    while (num_finished_ != num_running_) {
+      arrow::internal::SerialExecutor::RunTasksOnAllExecutors();
+    }
+#endif
+
     return status_;
   }
 
diff --git a/cpp/src/arrow/util/async_generator_test.cc b/cpp/src/arrow/util/async_generator_test.cc
index 37718f743fffc..7fb99f167c605 100644
--- a/cpp/src/arrow/util/async_generator_test.cc
+++ b/cpp/src/arrow/util/async_generator_test.cc
@@ -32,6 +32,7 @@
 #include "arrow/type_fwd.h"
 #include "arrow/util/async_generator.h"
 #include "arrow/util/async_util.h"
+#include "arrow/util/config.h"
 #include "arrow/util/test_common.h"
 #include "arrow/util/vector.h"
 
@@ -994,6 +995,9 @@ TEST(TestAsyncUtil, GeneratorIterator) {
 }
 
 TEST(TestAsyncUtil, MakeTransferredGenerator) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   std::mutex mutex;
   std::condition_variable cv;
   std::atomic<bool> finished(false);
@@ -1478,6 +1482,10 @@ TEST(TestAsyncUtil, ReadaheadMove) {
 }
 
 TEST(TestAsyncUtil, ReadaheadFailed) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
+
   ASSERT_OK_AND_ASSIGN(auto thread_pool, internal::ThreadPool::Make(20));
   std::atomic<int32_t> counter(0);
   auto gating_task = GatingTask::Make();
@@ -1512,6 +1520,9 @@ TEST(TestAsyncUtil, ReadaheadFailed) {
 }
 
 TEST(TestAsyncUtil, ReadaheadFailedWaitForInFlight) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   ASSERT_OK_AND_ASSIGN(auto thread_pool, internal::ThreadPool::Make(20));
   // If a failure causes an early end then we should not emit that failure
   // until all in-flight futures have completed.  This is to prevent tasks from
diff --git a/cpp/src/arrow/util/config.h.cmake b/cpp/src/arrow/util/config.h.cmake
index 1008b9c6b9a05..f7125cfd8a235 100644
--- a/cpp/src/arrow/util/config.h.cmake
+++ b/cpp/src/arrow/util/config.h.cmake
@@ -51,6 +51,7 @@
 #cmakedefine ARROW_PARQUET
 #cmakedefine ARROW_SUBSTRAIT
 
+#cmakedefine ARROW_ENABLE_THREADING
 #cmakedefine ARROW_GCS
 #cmakedefine ARROW_S3
 #cmakedefine ARROW_USE_NATIVE_INT128
diff --git a/cpp/src/arrow/util/future.cc b/cpp/src/arrow/util/future.cc
index c430ad1fc738f..a5426f949e721 100644
--- a/cpp/src/arrow/util/future.cc
+++ b/cpp/src/arrow/util/future.cc
@@ -25,6 +25,7 @@
 #include <numeric>
 
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/thread_pool.h"
 #include "arrow/util/tracing_internal.h"
@@ -89,7 +90,7 @@ class ConcreteFutureImpl : public FutureImpl {
       case ShouldSchedule::IfUnfinished:
         return !in_add_callback;
       case ShouldSchedule::IfDifferentExecutor:
-        return !callback_record.options.executor->OwnsThisThread();
+        return !(callback_record.options.executor->IsCurrentExecutor());
       default:
         DCHECK(false) << "Unrecognized ShouldSchedule option";
         return false;
@@ -149,17 +150,47 @@ class ConcreteFutureImpl : public FutureImpl {
   }
 
   void DoWait() {
+#ifdef ARROW_ENABLE_THREADING
     std::unique_lock<std::mutex> lock(mutex_);
 
     cv_.wait(lock, [this] { return IsFutureFinished(state_); });
+#else
+    auto last_processed_time = std::chrono::steady_clock::now();
+    while (true) {
+      if (IsFutureFinished(state_)) {
+        return;
+      }
+      if (arrow::internal::SerialExecutor::RunTasksOnAllExecutors() == false) {
+        auto this_time = std::chrono::steady_clock::now();
+        if (this_time - last_processed_time < std::chrono::seconds(10)) {
+          ARROW_LOG(WARNING) << "Waiting for future, but no executors have had any tasks "
+                                "pending for last 10 seconds";
+          last_processed_time = std::chrono::steady_clock::now();
+        }
+      }
+    }
+#endif
   }
 
   bool DoWait(double seconds) {
+#ifdef ARROW_ENABLE_THREADING
     std::unique_lock<std::mutex> lock(mutex_);
 
     cv_.wait_for(lock, std::chrono::duration<double>(seconds),
                  [this] { return IsFutureFinished(state_); });
     return IsFutureFinished(state_);
+#else
+    auto start = std::chrono::steady_clock::now();
+    auto fsec = std::chrono::duration<double>(seconds);
+    while (std::chrono::steady_clock::now() - start < fsec) {
+      // run one task then check time
+      if (IsFutureFinished(state_)) {
+        return true;
+      }
+      arrow::internal::SerialExecutor::RunTasksOnAllExecutors();
+    }
+    return IsFutureFinished(state_);
+#endif
   }
 
   std::mutex mutex_;
diff --git a/cpp/src/arrow/util/future_test.cc b/cpp/src/arrow/util/future_test.cc
index 689b7c3df62dd..87891e48efa5e 100644
--- a/cpp/src/arrow/util/future_test.cc
+++ b/cpp/src/arrow/util/future_test.cc
@@ -1073,7 +1073,7 @@ TEST_F(FutureSchedulingTest, ScheduleIfDifferentExecutor) {
   struct : internal::Executor {
     int GetCapacity() override { return pool_->GetCapacity(); }
 
-    bool OwnsThisThread() override { return pool_->OwnsThisThread(); }
+    bool IsCurrentExecutor() override { return pool_->IsCurrentExecutor(); }
 
     Status SpawnReal(internal::TaskHints hints, internal::FnOnce<void()> task,
                      StopToken stop_token, StopCallback&& stop_callback) override {
@@ -1100,8 +1100,7 @@ TEST_F(FutureSchedulingTest, ScheduleIfDifferentExecutor) {
   auto fut0_done = fut0.Then(
       [&] {
         // marked finished on main thread -> must be scheduled to executor
-        fut0_on_executor.store(executor.OwnsThisThread());
-
+        fut0_on_executor.store(executor.IsCurrentExecutor());
         fut1.MarkFinished();
       },
       pass_err, options);
@@ -1109,7 +1108,7 @@ TEST_F(FutureSchedulingTest, ScheduleIfDifferentExecutor) {
   auto fut1_done = fut1.Then(
       [&] {
         // marked finished on executor -> no need to schedule
-        fut1_on_executor.store(executor.OwnsThisThread());
+        fut1_on_executor.store(executor.IsCurrentExecutor());
       },
       pass_err, options);
 
diff --git a/cpp/src/arrow/util/iterator_test.cc b/cpp/src/arrow/util/iterator_test.cc
index ab62fcb7034b7..ba21ddcced209 100644
--- a/cpp/src/arrow/util/iterator_test.cc
+++ b/cpp/src/arrow/util/iterator_test.cc
@@ -438,10 +438,12 @@ TEST(ReadaheadIterator, Trace) {
     ASSERT_EQ(values[i], TestInt());
   }
 
+#ifdef ARROW_ENABLE_THREADING
   // Values were all emitted from the same thread, and it's not this thread
   const auto& thread_ids = tracing->thread_ids();
   ASSERT_EQ(thread_ids.size(), 1);
   ASSERT_NE(*thread_ids.begin(), std::this_thread::get_id());
+#endif
 }
 
 TEST(ReadaheadIterator, NextError) {
diff --git a/cpp/src/arrow/util/task_group.cc b/cpp/src/arrow/util/task_group.cc
index 932f642041d4e..0f08e7bde9cb6 100644
--- a/cpp/src/arrow/util/task_group.cc
+++ b/cpp/src/arrow/util/task_group.cc
@@ -24,6 +24,7 @@
 #include <utility>
 
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/config.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/thread_pool.h"
 
@@ -128,12 +129,19 @@ class ThreadedTaskGroup : public TaskGroup {
   bool ok() const override { return ok_.load(); }
 
   Status Finish() override {
+#ifdef ARROW_ENABLE_THREADING
     std::unique_lock<std::mutex> lock(mutex_);
     if (!finished_) {
       cv_.wait(lock, [&]() { return nremaining_.load() == 0; });
       // Current tasks may start other tasks, so only set this when done
       finished_ = true;
     }
+#else
+    while (!finished_ && nremaining_.load() != 0) {
+      arrow::internal::SerialExecutor::RunTasksOnAllExecutors();
+    }
+    finished_ = true;
+#endif
     return status_;
   }
 
diff --git a/cpp/src/arrow/util/thread_pool.cc b/cpp/src/arrow/util/thread_pool.cc
index daffe8f077a2f..d82934c9bec01 100644
--- a/cpp/src/arrow/util/thread_pool.cc
+++ b/cpp/src/arrow/util/thread_pool.cc
@@ -27,6 +27,7 @@
 #include <vector>
 
 #include "arrow/util/atfork_internal.h"
+#include "arrow/util/config.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/mutex.h"
@@ -60,11 +61,53 @@ struct SerialExecutor::State {
   std::thread::id current_thread;
   bool paused{false};
   bool finished{false};
+#ifndef ARROW_ENABLE_THREADING
+  int max_tasks_running{1};
+  int tasks_running{0};
+#endif
+};
+
+#ifndef ARROW_ENABLE_THREADING
+// list of all SerialExecutor objects - as we need to run tasks from all pools at once in
+// Run()
+struct SerialExecutorGlobalState {
+  // a set containing all the executors that currently exist
+  std::unordered_set<SerialExecutor*> all_executors;
+
+  // this is the executor which is currently running a task
+  SerialExecutor* current_executor = NULL;
+
+  // in RunTasksOnAllExecutors we run tasks on executors in turn
+  // this is used to keep track of the last fired task so that it
+  // doesn't always run tasks on the first executor
+  // in case of nested calls to RunTasksOnAllExecutors
+  SerialExecutor* last_called_executor = NULL;
 };
 
-SerialExecutor::SerialExecutor() : state_(std::make_shared<State>()) {}
+static SerialExecutorGlobalState* GetSerialExecutorGlobalState() {
+  static SerialExecutorGlobalState state;
+  return &state;
+}
+
+SerialExecutor* SerialExecutor::GetCurrentExecutor() {
+  return GetSerialExecutorGlobalState()->current_executor;
+}
+
+bool SerialExecutor::IsCurrentExecutor() { return GetCurrentExecutor() == this; }
+
+#endif
+
+SerialExecutor::SerialExecutor() : state_(std::make_shared<State>()) {
+#ifndef ARROW_ENABLE_THREADING
+  GetSerialExecutorGlobalState()->all_executors.insert(this);
+  state_->max_tasks_running = 1;
+#endif
+}
 
 SerialExecutor::~SerialExecutor() {
+#ifndef ARROW_ENABLE_THREADING
+  GetSerialExecutorGlobalState()->all_executors.erase(this);
+#endif
   auto state = state_;
   std::unique_lock<std::mutex> lk(state->mutex);
   if (!state->task_queue.empty()) {
@@ -77,6 +120,12 @@ SerialExecutor::~SerialExecutor() {
   }
 }
 
+int SerialExecutor::GetNumTasks() {
+  auto state = state_;
+  return static_cast<int>(state_->task_queue.size());
+}
+
+#ifdef ARROW_ENABLE_THREADING
 Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce<void()> task,
                                  StopToken stop_token, StopCallback&& stop_callback) {
 #ifdef ARROW_WITH_OPENTELEMETRY
@@ -111,21 +160,55 @@ Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce<void()> task,
   return Status::OK();
 }
 
-void SerialExecutor::Pause() {
-  // Same comment as SpawnReal above
+void SerialExecutor::Finish() {
   auto state = state_;
   {
     std::lock_guard<std::mutex> lk(state->mutex);
-    state->paused = true;
+    state->finished = true;
   }
   state->wait_for_tasks.notify_one();
 }
 
+#else  // ARROW_ENABLE_THREADING
+Status SerialExecutor::SpawnReal(TaskHints hints, FnOnce<void()> task,
+                                 StopToken stop_token, StopCallback&& stop_callback) {
+#ifdef ARROW_WITH_OPENTELEMETRY
+  // Wrap the task to propagate a parent tracing span to it
+  // XXX should there be a generic utility in tracing_internal.h for this?
+  task = [func = std::move(task),
+          active_span =
+              ::arrow::internal::tracing::GetTracer()->GetCurrentSpan()]() mutable {
+    auto scope = ::arrow::internal::tracing::GetTracer()->WithActiveSpan(active_span);
+    std::move(func)();
+  };
+#endif  // ARROW_WITH_OPENTELEMETRY
+
+  if (state_->finished) {
+    return Status::Invalid(
+        "Attempt to schedule a task on a serial executor that has already finished or "
+        "been abandoned");
+  }
+
+  state_->task_queue.push_back(
+      Task{std::move(task), std::move(stop_token), std::move(stop_callback)});
+
+  return Status::OK();
+}
+
 void SerialExecutor::Finish() {
+  auto state = state_;
+  { state->finished = true; }
+  // empty any tasks from the loop on finish
+  RunLoop();
+}
+
+#endif  // ARROW_ENABLE_THREADING
+void SerialExecutor::Pause() {
+  // Same comment as SpawnReal above
   auto state = state_;
   {
     std::lock_guard<std::mutex> lk(state->mutex);
-    state->finished = true;
+    state->paused = true;
   }
   state->wait_for_tasks.notify_one();
 }
@@ -147,6 +230,7 @@ bool SerialExecutor::OwnsThisThread() {
   std::lock_guard lk(state_->mutex);
   return std::this_thread::get_id() == state_->current_thread;
 }
+#ifdef ARROW_ENABLE_THREADING
 
 void SerialExecutor::RunLoop() {
   // This is called from the SerialExecutor's main thread, so the
@@ -183,6 +267,110 @@ void SerialExecutor::RunLoop() {
   }
   state_->current_thread = {};
 }
+#else   // ARROW_ENABLE_THREADING
+bool SerialExecutor::RunTasksOnAllExecutors() {
+  auto globalState = GetSerialExecutorGlobalState();
+  // if the previously called executor was deleted, ignore last_called_executor
+  if (globalState->last_called_executor != NULL &&
+      globalState->all_executors.count(globalState->last_called_executor) == 0) {
+    globalState->last_called_executor = NULL;
+  }
+  bool run_task = true;
+  bool keep_going = true;
+  while (keep_going) {
+    run_task = false;
+    keep_going = false;
+    for (auto it = globalState->all_executors.begin();
+         it != globalState->all_executors.end(); ++it) {
+      if (globalState->last_called_executor != NULL) {
+        // always rerun loop if we have a last_called_executor, otherwise
+        // we may drop out before every executor has been checked
+        keep_going = true;
+        if (globalState->all_executors.count(globalState->last_called_executor) == 0 ||
+            globalState->last_called_executor == *it) {
+          // found the last one (or it doesn't exist ih the set any more)
+          // now we can start running things
+          globalState->last_called_executor = NULL;
+        }
+        // skip until after we have seen the last executor we called
+        // so that we do things nicely in turn
+        continue;
+      }
+      auto exe = *it;
+      // don't make more reentrant calls inside an
+      // executor than the number of concurrent tasks set on a threadpool, or
+      // 1 in the case of a serialexecutor -
+      // this is because users will expect a serial executor not to be able to
+      // run the next task until the current one is finished (and a threadpool
+      // only to be able to run a certain number of tasks concurrently)
+      if (exe->state_->tasks_running >= exe->state_->max_tasks_running) {
+        continue;
+      }
+      if (exe->state_->paused == false && exe->state_->task_queue.empty() == false) {
+        SerialExecutor* old_exe = globalState->current_executor;
+        globalState->current_executor = exe;
+        Task task = std::move(exe->state_->task_queue.front());
+        exe->state_->task_queue.pop_front();
+        run_task = true;
+        exe->state_->tasks_running += 1;
+        if (!task.stop_token.IsStopRequested()) {
+          std::move(task.callable)();
+        } else {
+          if (task.stop_callback) {
+            std::move(task.stop_callback)(task.stop_token.Poll());
+          }
+        }
+        exe->state_->tasks_running -= 1;
+        globalState->current_executor = old_exe;
+
+        globalState->last_called_executor = exe;
+        keep_going = false;
+        break;
+      }
+    }
+  }
+  return run_task;
+}
+
+// run tasks in this thread and queue things from other executors if required
+// (e.g. when a compute task depends on an IO request)
+void SerialExecutor::RunLoop() {
+  auto globalState = GetSerialExecutorGlobalState();
+  // If paused we break out immediately.  If finished we only break out
+  // when all work is done.
+  while (!state_->paused && !(state_->finished && state_->task_queue.empty())) {
+    // first empty us until paused or empty
+    // if we're already running as many tasks as possible then
+    // we can't run any more until something else drops off the queue
+    if (state_->tasks_running <= state_->max_tasks_running) {
+      while (!state_->paused && !state_->task_queue.empty()) {
+        Task task = std::move(state_->task_queue.front());
+        state_->task_queue.pop_front();
+        auto last_executor = globalState->current_executor;
+        globalState->current_executor = this;
+        state_->tasks_running += 1;
+        if (!task.stop_token.IsStopRequested()) {
+          std::move(task.callable)();
+        } else {
+          if (task.stop_callback) {
+            std::move(task.stop_callback)(task.stop_token.Poll());
+          }
+        }
+        state_->tasks_running -= 1;
+        globalState->current_executor = last_executor;
+      }
+      if (state_->paused || (state_->finished && state_->task_queue.empty())) {
+        break;
+      }
+    }
+    // now wait for anything on other executors (unless we're finished in which case it
+    // will drop out of the outer loop
+    RunTasksOnAllExecutors();
+  }
+}
+#endif  // ARROW_ENABLE_THREADING
+
+#ifdef ARROW_ENABLE_THREADING
 
 struct ThreadPool::State {
   State() = default;
@@ -532,6 +720,65 @@ int ThreadPool::DefaultCapacity() {
   return capacity;
 }
 
+#else  // ARROW_ENABLE_THREADING
+ThreadPool::ThreadPool() {
+  // default to max 'concurrency' of 8
+  // if threading is disabled
+  state_->max_tasks_running = 8;
+}
+
+Status ThreadPool::Shutdown(bool wait) {
+  state_->finished = true;
+  if (wait) {
+    RunLoop();
+  } else {
+    // clear any pending tasks so that we behave
+    // the same as threadpool on fast shutdown
+    state_->task_queue.clear();
+  }
+  return Status::OK();
+}
+
+// Wait for the 'thread pool' to become idle
+// including running tasks from other pools if
+// needed
+void ThreadPool::WaitForIdle() {
+  while (!state_->task_queue.empty()) {
+    RunTasksOnAllExecutors();
+  }
+}
+
+Status ThreadPool::SetCapacity(int threads) {
+  state_->max_tasks_running = threads;
+  return Status::OK();
+}
+
+int ThreadPool::GetCapacity() { return state_->max_tasks_running; }
+
+int ThreadPool::GetActualCapacity() { return state_->max_tasks_running; }
+
+Result<std::shared_ptr<ThreadPool>> ThreadPool::Make(int threads) {
+  auto pool = std::shared_ptr<ThreadPool>(new ThreadPool());
+  RETURN_NOT_OK(pool->SetCapacity(threads));
+  return pool;
+}
+
+Result<std::shared_ptr<ThreadPool>> ThreadPool::MakeEternal(int threads) {
+  ARROW_ASSIGN_OR_RAISE(auto pool, Make(threads));
+  // On Windows, the ThreadPool destructor may be called after non-main threads
+  // have been killed by the OS, and hang in a condition variable.
+  // On Unix, we want to avoid leak reports by Valgrind.
+  return pool;
+}
+
+ThreadPool::~ThreadPool() {
+  // clear threadpool, otherwise ~SerialExecutor will
+  // run any tasks left (which isn't threadpool behaviour)
+  state_->task_queue.clear();
+}
+
+#endif  // ARROW_ENABLE_THREADING
+
 // Helper for the singleton pattern
 std::shared_ptr<ThreadPool> ThreadPool::MakeCpuThreadPool() {
   auto maybe_pool = ThreadPool::MakeEternal(ThreadPool::DefaultCapacity());
diff --git a/cpp/src/arrow/util/thread_pool.h b/cpp/src/arrow/util/thread_pool.h
index 4e0fd84068c91..eba79fc05d7e0 100644
--- a/cpp/src/arrow/util/thread_pool.h
+++ b/cpp/src/arrow/util/thread_pool.h
@@ -21,11 +21,13 @@
 #include <memory>
 #include <queue>
 #include <type_traits>
+#include <unordered_set>
 #include <utility>
 
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/util/cancel.h"
+#include "arrow/util/config.h"
 #include "arrow/util/functional.h"
 #include "arrow/util/future.h"
 #include "arrow/util/iterator.h"
@@ -194,6 +196,11 @@ class ARROW_EXPORT Executor {
   // Executor. Returns false if this Executor does not support this property.
   virtual bool OwnsThisThread() { return false; }
 
+  // Return true if this is the current executor being called
+  // n.b. this defaults to just calling OwnsThisThread
+  // unless the threadpool is disabled
+  virtual bool IsCurrentExecutor() { return OwnsThisThread(); }
+
   /// \brief An interface to represent something with a custom destructor
   ///
   /// \see KeepAlive
@@ -276,6 +283,9 @@ class ARROW_EXPORT SerialExecutor : public Executor {
   Status SpawnReal(TaskHints hints, FnOnce<void()> task, StopToken,
                    StopCallback&&) override;
 
+  // Return the number of tasks either running or in the queue.
+  int GetNumTasks();
+
   /// \brief Runs the TopLevelTask and any scheduled tasks
   ///
   /// The TopLevelTask (or one of the tasks it schedules) must either return an invalid
@@ -347,8 +357,13 @@ class ARROW_EXPORT SerialExecutor : public Executor {
           // the next call.
           executor->Pause();
         });
+#ifdef ARROW_ENABLE_THREADING
+        // future must run on this thread
         // Borrow this thread and run tasks until the future is finished
         executor->RunLoop();
+#else
+        next_fut.Wait();
+#endif
         if (!next_fut.is_finished()) {
           // Not clear this is possible since RunLoop wouldn't generally exit
           // unless we paused/finished which would imply next_fut has been
@@ -367,14 +382,26 @@ class ARROW_EXPORT SerialExecutor : public Executor {
     return Iterator<T>(SerialIterator{std::move(serial_executor), std::move(generator)});
   }
 
- private:
-  SerialExecutor();
+#ifndef ARROW_ENABLE_THREADING
+  // run a pending task from loop
+  // returns true if any tasks were run in the last go round the loop (i.e. if it
+  // returns false, all executors are waiting)
+  static bool RunTasksOnAllExecutors();
+  static SerialExecutor* GetCurrentExecutor();
+
+  bool IsCurrentExecutor() override;
+
+#endif
+
+ protected:
+  virtual void RunLoop();
 
   // State uses mutex
   struct State;
   std::shared_ptr<State> state_;
 
-  void RunLoop();
+  SerialExecutor();
+
   // We mark the serial executor "finished" when there should be
   // no more tasks scheduled on it.  It's not strictly needed but
   // can help catch bugs where we are trying to use the executor
@@ -393,8 +420,23 @@ class ARROW_EXPORT SerialExecutor : public Executor {
     RunLoop();
     return final_fut;
   }
+
+#ifndef ARROW_ENABLE_THREADING
+  // we have to run tasks from all live executors
+  // during RunLoop if we don't have threading
+  static std::unordered_set<SerialExecutor*> all_executors;
+  // a pointer to the last one called by the loop
+  // so all tasks get spawned equally
+  // on multiple calls to RunTasksOnAllExecutors
+  static SerialExecutor* last_called_executor;
+  // without threading we can't tell which executor called the
+  // current process - so we set it in spawning the task
+  static SerialExecutor* current_executor;
+#endif  // ARROW_ENABLE_THREADING
 };
 
+#ifdef ARROW_ENABLE_THREADING
+
 /// An Executor implementation spawning tasks in FIFO manner on a fixed-size
 /// pool of worker threads.
 ///
@@ -418,11 +460,10 @@ class ARROW_EXPORT ThreadPool : public Executor {
   // match this value.
   int GetCapacity() override;
 
-  bool OwnsThisThread() override;
-
   // Return the number of tasks either running or in the queue.
   int GetNumTasks();
 
+  bool OwnsThisThread() override;
   // Dynamically change the number of worker threads.
   //
   // This function always returns immediately.
@@ -475,6 +516,58 @@ class ARROW_EXPORT ThreadPool : public Executor {
   State* state_;
   bool shutdown_on_destroy_;
 };
+#else  // ARROW_ENABLE_THREADING
+// an executor implementation which pretends to be a thread pool but runs everything
+// on the main thread using a static queue (shared between all thread pools, otherwise
+// cross-threadpool dependencies will break everything)
+class ARROW_EXPORT ThreadPool : public SerialExecutor {
+ public:
+  ARROW_FRIEND_EXPORT friend ThreadPool* GetCpuThreadPool();
+
+  static Result<std::shared_ptr<ThreadPool>> Make(int threads);
+
+  // Like Make(), but takes care that the returned ThreadPool is compatible
+  // with destruction late at process exit.
+  static Result<std::shared_ptr<ThreadPool>> MakeEternal(int threads);
+
+  // Destroy thread pool; the pool will first be shut down
+  ~ThreadPool() override;
+
+  // Return the desired number of worker threads.
+  // The actual number of workers may lag a bit before being adjusted to
+  // match this value.
+  int GetCapacity() override;
+
+  virtual int GetActualCapacity();
+
+  bool OwnsThisThread() override { return true; }
+
+  // Dynamically change the number of worker threads.
+  // without threading this is equal to the
+  // number of tasks that can be running at once
+  // (inside each other)
+  Status SetCapacity(int threads);
+
+  static int DefaultCapacity() { return 8; }
+
+  // Shutdown the pool.  Once the pool starts shutting down, new tasks
+  // cannot be submitted anymore.
+  // If "wait" is true, shutdown waits for all pending tasks to be finished.
+  // If "wait" is false, workers are stopped as soon as currently executing
+  // tasks are finished.
+  Status Shutdown(bool wait = true);
+
+  // Wait for the thread pool to become idle
+  //
+  // This is useful for sequencing tests
+  void WaitForIdle();
+
+ protected:
+  static std::shared_ptr<ThreadPool> MakeCpuThreadPool();
+  ThreadPool();
+};
+
+#endif  // ARROW_ENABLE_THREADING
 
 // Return the process-global thread pool for CPU-bound tasks.
 ARROW_EXPORT ThreadPool* GetCpuThreadPool();
diff --git a/cpp/src/arrow/util/thread_pool_test.cc b/cpp/src/arrow/util/thread_pool_test.cc
index bce07d6908a11..ad30ca2e8052d 100644
--- a/cpp/src/arrow/util/thread_pool_test.cc
+++ b/cpp/src/arrow/util/thread_pool_test.cc
@@ -37,6 +37,7 @@
 #include "arrow/testing/executor_util.h"
 #include "arrow/testing/future_util.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/util/config.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
@@ -583,6 +584,9 @@ TEST_F(TestThreadPool, StressSpawn) {
 }
 
 TEST_F(TestThreadPool, OwnsCurrentThread) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   auto pool = this->MakeThreadPool(30);
   std::atomic<bool> one_failed{false};
 
@@ -600,6 +604,10 @@ TEST_F(TestThreadPool, OwnsCurrentThread) {
 }
 
 TEST_F(TestThreadPool, StressSpawnThreaded) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
+
   auto pool = this->MakeThreadPool(30);
   SpawnAddsThreaded(pool.get(), 20, 100, task_add<int>);
 }
@@ -616,6 +624,9 @@ TEST_F(TestThreadPool, StressSpawnSlow) {
 }
 
 TEST_F(TestThreadPool, StressSpawnSlowThreaded) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   auto pool = this->MakeThreadPool(30);
   SpawnAddsThreaded(pool.get(), 20, 100, task_slow_add<int>{/*seconds=*/0.002});
 }
@@ -627,6 +638,9 @@ TEST_F(TestThreadPool, SpawnWithStopToken) {
 }
 
 TEST_F(TestThreadPool, StressSpawnThreadedWithStopToken) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   StopSource stop_source;
   auto pool = this->MakeThreadPool(30);
   SpawnAddsThreaded(pool.get(), 20, 100, task_add<int>, stop_source.token());
@@ -639,6 +653,9 @@ TEST_F(TestThreadPool, SpawnWithStopTokenCancelled) {
 }
 
 TEST_F(TestThreadPool, StressSpawnThreadedWithStopTokenCancelled) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   StopSource stop_source;
   auto pool = this->MakeThreadPool(30);
   SpawnAddsThreadedAndCancel(pool.get(), 20, 100, task_slow_add<int>{/*seconds=*/0.02},
@@ -656,6 +673,7 @@ TEST_F(TestThreadPool, QuickShutdown) {
   add_tester.CheckNotAllComputed();
 }
 
+#ifdef ARROW_ENABLE_THREADING
 TEST_F(TestThreadPool, SetCapacity) {
   auto pool = this->MakeThreadPool(5);
 
@@ -717,7 +735,17 @@ TEST_F(TestThreadPool, SetCapacity) {
   // Ensure nothing got stuck
   ASSERT_OK(pool->Shutdown());
 }
+#else  // ARROW_ENABLE_THREADING
+TEST_F(TestThreadPool, SetCapacity) {
+  auto pool = this->MakeThreadPool(5);
+
+  ASSERT_EQ(pool->GetCapacity(), 5);
+  ASSERT_EQ(pool->GetActualCapacity(), 5);
 
+  ASSERT_OK(pool->SetCapacity(7));
+  ASSERT_EQ(pool->GetCapacity(), 7);
+}
+#endif
 // Test Submit() functionality
 
 TEST_F(TestThreadPool, Submit) {
@@ -802,6 +830,10 @@ class TestThreadPoolForkSafety : public TestThreadPool {};
 
 TEST_F(TestThreadPoolForkSafety, Basics) {
   {
+#ifndef ARROW_ENABLE_THREADING
+    GTEST_SKIP() << "Test requires threading support";
+#endif
+
     // Fork after task submission
     auto pool = this->MakeThreadPool(3);
     ASSERT_OK_AND_ASSIGN(auto fut, pool->Submit(add<int>, 4, 5));
@@ -845,6 +877,9 @@ TEST_F(TestThreadPoolForkSafety, Basics) {
 }
 
 TEST_F(TestThreadPoolForkSafety, MultipleChildThreads) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   // ARROW-15593: race condition in after-fork ThreadPool reinitialization
   // when SpawnReal() was called from multiple threads in a forked child.
   auto run_in_child = [](ThreadPool* pool) {
@@ -894,6 +929,9 @@ TEST_F(TestThreadPoolForkSafety, NestedChild) {
   {
 #ifdef __APPLE__
     GTEST_SKIP() << "Nested fork is not supported on macos";
+#endif
+#ifndef ARROW_ENABLE_THREADING
+    GTEST_SKIP() << "Test requires threading support";
 #endif
     auto pool = this->MakeThreadPool(3);
     ASSERT_OK_AND_ASSIGN(auto fut, pool->Submit(add<int>, 4, 5));
@@ -928,6 +966,9 @@ TEST_F(TestThreadPoolForkSafety, NestedChild) {
 #endif
 
 TEST(TestGlobalThreadPool, Capacity) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   // Sanity check
   auto pool = GetCpuThreadPool();
   int capacity = pool->GetCapacity();
diff --git a/cpp/src/parquet/encryption/key_management_test.cc b/cpp/src/parquet/encryption/key_management_test.cc
index f733c43ee1e79..6f80ab42c9a96 100644
--- a/cpp/src/parquet/encryption/key_management_test.cc
+++ b/cpp/src/parquet/encryption/key_management_test.cc
@@ -324,6 +324,9 @@ TEST_F(TestEncryptionKeyManagement, KeyRotationWithInternalMaterial) {
 }
 
 TEST_F(TestEncryptionKeyManagementMultiThread, WrapLocally) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   this->SetupCryptoFactory(true);
 
   this->WriteEncryptedParquetFiles();
@@ -331,6 +334,9 @@ TEST_F(TestEncryptionKeyManagementMultiThread, WrapLocally) {
 }
 
 TEST_F(TestEncryptionKeyManagementMultiThread, WrapOnServer) {
+#ifndef ARROW_ENABLE_THREADING
+  GTEST_SKIP() << "Test requires threading support";
+#endif
   this->SetupCryptoFactory(false);
 
   this->WriteEncryptedParquetFiles();
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 941506b9c2abc..bad5b3c1f8988 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1225,6 +1225,15 @@ tasks:
       image: ubuntu-cpp
 {% endfor %}
 
+  test-ubuntu-22.04-cpp-no-threading:
+    ci: github
+    template: docker-tests/github.linux.yml
+    params:
+      env:
+        UBUNTU: 22.04
+      flags: "-e ARROW_ENABLE_THREADING=OFF"
+      image: ubuntu-cpp
+
   test-ubuntu-20.04-cpp-thread-sanitizer:
     ci: github
     template: docker-tests/github.linux.yml

From 2972e494ff906a2261db5e67b305c5af9d812544 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Wed, 9 Aug 2023 10:52:58 +0100
Subject: [PATCH 123/749] GH-37019: [R] Documentation for read_parquet() et al
 needs updating (#37020)

### Rationale for this change

Docs were out of data with code after previous changes to returned object type

### What changes are included in this PR?

Update docs to reflect correct return type

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37019

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/csv.R                 | 6 +++---
 r/R/dplyr-funcs-doc.R     | 2 +-
 r/R/feather.R             | 2 +-
 r/R/ipc-stream.R          | 4 ++--
 r/R/json.R                | 2 +-
 r/R/parquet.R             | 4 ++--
 r/man/acero.Rd            | 2 +-
 r/man/read_delim_arrow.Rd | 6 +++---
 r/man/read_feather.Rd     | 4 ++--
 r/man/read_ipc_stream.Rd  | 4 ++--
 r/man/read_json_arrow.Rd  | 4 ++--
 r/man/read_parquet.Rd     | 6 +++---
 12 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index c8a13630d2f58..d53dc07b42454 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -17,7 +17,7 @@
 
 #' Read a CSV or other delimited file with Arrow
 #'
-#' These functions uses the Arrow C++ CSV reader to read into a `data.frame`.
+#' These functions uses the Arrow C++ CSV reader to read into a `tibble`.
 #' Arrow C++ options have been mapped to argument names that follow those of
 #' `readr::read_delim()`, and `col_select` was inspired by `vroom::vroom()`.
 #'
@@ -127,10 +127,10 @@
 #' parsing options provided in other arguments (e.g. `delim`, `quote`, etc.).
 #' @param convert_options see [file reader options][CsvReadOptions]
 #' @param read_options see [file reader options][CsvReadOptions]
-#' @param as_data_frame Should the function return a `data.frame` (default) or
+#' @param as_data_frame Should the function return a `tibble` (default) or
 #' an Arrow [Table]?
 #'
-#' @return A `data.frame`, or a Table if `as_data_frame = FALSE`.
+#' @return A `tibble`, or a Table if `as_data_frame = FALSE`.
 #' @export
 #' @examples
 #' tf <- tempfile()
diff --git a/r/R/dplyr-funcs-doc.R b/r/R/dplyr-funcs-doc.R
index a472c572cd9f4..5099e903da670 100644
--- a/r/R/dplyr-funcs-doc.R
+++ b/r/R/dplyr-funcs-doc.R
@@ -34,7 +34,7 @@
 #' to a `dbplyr::tbl_lazy`. This means that the verbs do not eagerly evaluate
 #' the query on the data. To run the query, call either `compute()`,
 #' which returns an `arrow` [Table], or `collect()`, which pulls the resulting
-#' Table into an R `data.frame`.
+#' Table into an R `tibble`.
 #'
 #' * [`anti_join()`][dplyr::anti_join()]: the `copy` and `na_matches` arguments are ignored
 #' * [`arrange()`][dplyr::arrange()]
diff --git a/r/R/feather.R b/r/R/feather.R
index 24971669fc536..3e390018c825f 100644
--- a/r/R/feather.R
+++ b/r/R/feather.R
@@ -157,7 +157,7 @@ write_ipc_file <- function(x,
 #' @inheritParams read_delim_arrow
 #' @inheritParams make_readable_file
 #'
-#' @return A `data.frame` if `as_data_frame` is `TRUE` (the default), or an
+#' @return A `tibble` if `as_data_frame` is `TRUE` (the default), or an
 #' Arrow [Table] otherwise
 #'
 #' @export
diff --git a/r/R/ipc-stream.R b/r/R/ipc-stream.R
index 7144132393446..37ef0bbaf2126 100644
--- a/r/R/ipc-stream.R
+++ b/r/R/ipc-stream.R
@@ -87,11 +87,11 @@ write_to_raw <- function(x, format = c("stream", "file")) {
 #' If a file name or URI, an Arrow [InputStream] will be opened and
 #' closed when finished. If an input stream is provided, it will be left
 #' open.
-#' @param as_data_frame Should the function return a `data.frame` (default) or
+#' @param as_data_frame Should the function return a `tibble` (default) or
 #' an Arrow [Table]?
 #' @param ... extra parameters passed to `read_feather()`.
 #'
-#' @return A `data.frame` if `as_data_frame` is `TRUE` (the default), or an
+#' @return A `tibble` if `as_data_frame` is `TRUE` (the default), or an
 #' Arrow [Table] otherwise
 #' @seealso [write_feather()] for writing IPC files. [RecordBatchReader] for a
 #' lower-level interface.
diff --git a/r/R/json.R b/r/R/json.R
index e8131b37f2584..8936cc3932dcd 100644
--- a/r/R/json.R
+++ b/r/R/json.R
@@ -38,7 +38,7 @@
 #' @param schema [Schema] that describes the table.
 #' @param ... Additional options passed to `JsonTableReader$create()`
 #'
-#' @return A `data.frame`, or a Table if `as_data_frame = FALSE`.
+#' @return A `tibble`, or a Table if `as_data_frame = FALSE`.
 #' @export
 #' @examplesIf arrow_with_json()
 #' tf <- tempfile()
diff --git a/r/R/parquet.R b/r/R/parquet.R
index 1335e85219211..db224a41e4019 100644
--- a/r/R/parquet.R
+++ b/r/R/parquet.R
@@ -24,8 +24,8 @@
 #' @param props [ParquetArrowReaderProperties]
 #' @param ... Additional arguments passed to `ParquetFileReader$create()`
 #'
-#' @return A [arrow::Table][Table], or a `data.frame` if `as_data_frame` is
-#' `TRUE` (the default).
+#' @return A `tibble` if `as_data_frame` is `TRUE` (the default), or an
+#' Arrow [Table] otherwise.
 #' @examplesIf arrow_with_parquet() && !getFromNamespace("on_linux_dev", "arrow")()
 #' tf <- tempfile()
 #' on.exit(unlink(tf))
diff --git a/r/man/acero.Rd b/r/man/acero.Rd
index 0a35bccbc7491..c9fb4d37a1d95 100644
--- a/r/man/acero.Rd
+++ b/r/man/acero.Rd
@@ -21,7 +21,7 @@ Most verb functions return an \code{arrow_dplyr_query} object, similar in spirit
 to a \code{dbplyr::tbl_lazy}. This means that the verbs do not eagerly evaluate
 the query on the data. To run the query, call either \code{compute()},
 which returns an \code{arrow} \link{Table}, or \code{collect()}, which pulls the resulting
-Table into an R \code{data.frame}.
+Table into an R \code{tibble}.
 \itemize{
 \item \code{\link[dplyr:filter-joins]{anti_join()}}: the \code{copy} and \code{na_matches} arguments are ignored
 \item \code{\link[dplyr:arrange]{arrange()}}
diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd
index f15da07afb87d..cd07c8ad07e5f 100644
--- a/r/man/read_delim_arrow.Rd
+++ b/r/man/read_delim_arrow.Rd
@@ -128,7 +128,7 @@ parsing options provided in other arguments (e.g. \code{delim}, \code{quote}, et
 
 \item{read_options}{see \link[=CsvReadOptions]{file reader options}}
 
-\item{as_data_frame}{Should the function return a \code{data.frame} (default) or
+\item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
 
 \item{timestamp_parsers}{User-defined timestamp parsers. If more than one
@@ -141,10 +141,10 @@ starting from the beginning of this vector. Possible values are:
 }}
 }
 \value{
-A \code{data.frame}, or a Table if \code{as_data_frame = FALSE}.
+A \code{tibble}, or a Table if \code{as_data_frame = FALSE}.
 }
 \description{
-These functions uses the Arrow C++ CSV reader to read into a \code{data.frame}.
+These functions uses the Arrow C++ CSV reader to read into a \code{tibble}.
 Arrow C++ options have been mapped to argument names that follow those of
 \code{readr::read_delim()}, and \code{col_select} was inspired by \code{vroom::vroom()}.
 }
diff --git a/r/man/read_feather.Rd b/r/man/read_feather.Rd
index 000aa541aacf6..c3b4a54158c7f 100644
--- a/r/man/read_feather.Rd
+++ b/r/man/read_feather.Rd
@@ -21,13 +21,13 @@ open.}
 \link[tidyselect:eval_select]{tidy selection specification}
 of columns, as used in \code{dplyr::select()}.}
 
-\item{as_data_frame}{Should the function return a \code{data.frame} (default) or
+\item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
 
 \item{mmap}{Logical: whether to memory-map the file (default \code{TRUE})}
 }
 \value{
-A \code{data.frame} if \code{as_data_frame} is \code{TRUE} (the default), or an
+A \code{tibble} if \code{as_data_frame} is \code{TRUE} (the default), or an
 Arrow \link{Table} otherwise
 }
 \description{
diff --git a/r/man/read_ipc_stream.Rd b/r/man/read_ipc_stream.Rd
index 63b50e7c1b002..db930b52bde18 100644
--- a/r/man/read_ipc_stream.Rd
+++ b/r/man/read_ipc_stream.Rd
@@ -13,13 +13,13 @@ If a file name or URI, an Arrow \link{InputStream} will be opened and
 closed when finished. If an input stream is provided, it will be left
 open.}
 
-\item{as_data_frame}{Should the function return a \code{data.frame} (default) or
+\item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
 
 \item{...}{extra parameters passed to \code{read_feather()}.}
 }
 \value{
-A \code{data.frame} if \code{as_data_frame} is \code{TRUE} (the default), or an
+A \code{tibble} if \code{as_data_frame} is \code{TRUE} (the default), or an
 Arrow \link{Table} otherwise
 }
 \description{
diff --git a/r/man/read_json_arrow.Rd b/r/man/read_json_arrow.Rd
index 7231f5a83472f..9230a9a017495 100644
--- a/r/man/read_json_arrow.Rd
+++ b/r/man/read_json_arrow.Rd
@@ -28,7 +28,7 @@ To be recognised as literal data, the input must be wrapped with \code{I()}.}
 \link[tidyselect:eval_select]{tidy selection specification}
 of columns, as used in \code{dplyr::select()}.}
 
-\item{as_data_frame}{Should the function return a \code{data.frame} (default) or
+\item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
 
 \item{schema}{\link{Schema} that describes the table.}
@@ -36,7 +36,7 @@ an Arrow \link{Table}?}
 \item{...}{Additional options passed to \code{JsonTableReader$create()}}
 }
 \value{
-A \code{data.frame}, or a Table if \code{as_data_frame = FALSE}.
+A \code{tibble}, or a Table if \code{as_data_frame = FALSE}.
 }
 \description{
 Wrapper around \link{JsonTableReader} to read a newline-delimited JSON (ndjson) file into a
diff --git a/r/man/read_parquet.Rd b/r/man/read_parquet.Rd
index 68e56903d1485..3bb76cc2e30ca 100644
--- a/r/man/read_parquet.Rd
+++ b/r/man/read_parquet.Rd
@@ -24,7 +24,7 @@ open.}
 \link[tidyselect:eval_select]{tidy selection specification}
 of columns, as used in \code{dplyr::select()}.}
 
-\item{as_data_frame}{Should the function return a \code{data.frame} (default) or
+\item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
 
 \item{props}{\link{ParquetArrowReaderProperties}}
@@ -32,8 +32,8 @@ an Arrow \link{Table}?}
 \item{...}{Additional arguments passed to \code{ParquetFileReader$create()}}
 }
 \value{
-A \link[=Table]{arrow::Table}, or a \code{data.frame} if \code{as_data_frame} is
-\code{TRUE} (the default).
+A \code{tibble} if \code{as_data_frame} is \code{TRUE} (the default), or an
+Arrow \link{Table} otherwise.
 }
 \description{
 '\href{https://parquet.apache.org/}{Parquet}' is a columnar storage file format.

From d3ccc833a61b70a988090cd8065d3e38d7c29a89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B0=A2=E5=A4=A9?= <jsjtxietian@outlook.com>
Date: Wed, 9 Aug 2023 19:33:37 +0800
Subject: [PATCH 124/749] GH-36867: [C++] Add a struct_ and schema overload
 taking a vector of (name, type) pairs (#36915)

### Rationale for this change
Mostly for convenience. It would be nice to be able to write:
```struct_({{"a", int8()}, {"b", utf8()}});```
instead of:
```struct_({field("a", int8()), field("b", utf8())});```
Same with the schema factory.

### What changes are included in this PR?
Add a struct_ overload and two schema overload taking a vector of (name, type) pairs to construct a vector of fields.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
Yes. Add three ARROW_EXPORT functions.

* Closes: #36867

Authored-by: jsjtxietian <jsjtxietian@outlook.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../arrow/engine/substrait/type_internal.cc   |  7 +++--
 cpp/src/arrow/type.cc                         | 28 ++++++++++++++++++
 cpp/src/arrow/type_fwd.h                      | 29 +++++++++++++++++++
 cpp/src/arrow/type_test.cc                    | 13 +++++++++
 cpp/src/parquet/arrow/schema.cc               |  2 +-
 5 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc
index 03d1f999a1491..1f9141f36ba6b 100644
--- a/cpp/src/arrow/engine/substrait/type_internal.cc
+++ b/cpp/src/arrow/engine/substrait/type_internal.cc
@@ -77,9 +77,10 @@ Result<FieldVector> FieldsFromProto(int size, const Types& types,
     if (types.Get(i).has_struct_()) {
       const auto& struct_ = types.Get(i).struct_();
 
-      ARROW_ASSIGN_OR_RAISE(type, FieldsFromProto(struct_.types_size(), struct_.types(),
-                                                  next_name, ext_set, conversion_options)
-                                      .Map(arrow::struct_));
+      ARROW_ASSIGN_OR_RAISE(
+          auto fields, FieldsFromProto(struct_.types_size(), struct_.types(), next_name,
+                                       ext_set, conversion_options));
+      type = ::arrow::struct_(std::move(fields));
 
       nullable = IsNullable(struct_);
     } else {
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 9267f1e499720..86df91268f8b9 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -276,6 +276,17 @@ std::shared_ptr<Field> MaybePromoteNullTypes(const Field& existing, const Field&
   // `other` must be null.
   return existing.WithNullable(true);
 }
+
+std::vector<std::shared_ptr<Field>> MakeFields(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> init_list) {
+  std::vector<std::shared_ptr<Field>> fields;
+  fields.reserve(init_list.size());
+  for (const auto& [name, type] : init_list) {
+    fields.push_back(field(name, type));
+  }
+  return fields;
+}
+
 }  // namespace
 
 Field::~Field() {}
@@ -2125,12 +2136,24 @@ std::shared_ptr<Schema> schema(std::vector<std::shared_ptr<Field>> fields,
   return std::make_shared<Schema>(std::move(fields), std::move(metadata));
 }
 
+std::shared_ptr<Schema> schema(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields,
+    std::shared_ptr<const KeyValueMetadata> metadata) {
+  return std::make_shared<Schema>(MakeFields(fields), std::move(metadata));
+}
+
 std::shared_ptr<Schema> schema(std::vector<std::shared_ptr<Field>> fields,
                                Endianness endianness,
                                std::shared_ptr<const KeyValueMetadata> metadata) {
   return std::make_shared<Schema>(std::move(fields), endianness, std::move(metadata));
 }
 
+std::shared_ptr<Schema> schema(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields,
+    Endianness endianness, std::shared_ptr<const KeyValueMetadata> metadata) {
+  return std::make_shared<Schema>(MakeFields(fields), endianness, std::move(metadata));
+}
+
 Result<std::shared_ptr<Schema>> UnifySchemas(
     const std::vector<std::shared_ptr<Schema>>& schemas,
     const Field::MergeOptions field_merge_options) {
@@ -2641,6 +2664,11 @@ std::shared_ptr<DataType> struct_(const std::vector<std::shared_ptr<Field>>& fie
   return std::make_shared<StructType>(fields);
 }
 
+std::shared_ptr<DataType> struct_(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields) {
+  return std::make_shared<StructType>(MakeFields(fields));
+}
+
 std::shared_ptr<DataType> run_end_encoded(std::shared_ptr<arrow::DataType> run_end_type,
                                           std::shared_ptr<DataType> value_type) {
   return std::make_shared<RunEndEncodedType>(std::move(run_end_type),
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index a8a27139d11bc..d3b41c8158cf7 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -560,6 +560,10 @@ ARROW_EXPORT std::shared_ptr<DataType> time64(TimeUnit::type unit);
 ARROW_EXPORT std::shared_ptr<DataType> struct_(
     const std::vector<std::shared_ptr<Field>>& fields);
 
+/// \brief Create a StructType instance from (name, type) pairs
+ARROW_EXPORT std::shared_ptr<DataType> struct_(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields);
+
 /// \brief Create a RunEndEncodedType instance
 ARROW_EXPORT std::shared_ptr<DataType> run_end_encoded(
     std::shared_ptr<DataType> run_end_type, std::shared_ptr<DataType> value_type);
@@ -629,6 +633,18 @@ std::shared_ptr<Schema> schema(
     std::vector<std::shared_ptr<Field>> fields,
     std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
 
+/// \brief Create a Schema instance from (name, type) pairs
+///
+/// The schema's fields will all be nullable with no associated metadata.
+///
+/// \param fields (name, type) pairs of the schema's fields
+/// \param metadata any custom key-value metadata, default null
+/// \return schema shared_ptr to Schema
+ARROW_EXPORT
+std::shared_ptr<Schema> schema(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields,
+    std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
+
 /// \brief Create a Schema instance
 ///
 /// \param fields the schema's fields
@@ -640,6 +656,19 @@ std::shared_ptr<Schema> schema(
     std::vector<std::shared_ptr<Field>> fields, Endianness endianness,
     std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
 
+/// \brief Create a Schema instance
+///
+/// The schema's fields will all be nullable with no associated metadata.
+///
+/// \param fields (name, type) pairs of the schema's fields
+/// \param endianness the endianness of the data
+/// \param metadata any custom key-value metadata, default null
+/// \return schema shared_ptr to Schema
+ARROW_EXPORT
+std::shared_ptr<Schema> schema(
+    std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> fields,
+    Endianness endianness, std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
+
 /// @}
 
 /// Return the process-wide default memory pool.
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index b008929e87a19..c55b33b4151e4 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -414,6 +414,13 @@ TEST_F(TestSchema, Basics) {
   ASSERT_NE(schema4->fingerprint(), schema7->fingerprint());
   ASSERT_EQ(schema6->fingerprint(), schema7->fingerprint());
 #endif
+
+  auto schema8 = ::arrow::schema({field("f0", int8()), field("f1", int32())});
+  auto schema9 = ::arrow::schema({{"f0", int8()}, {"f1", int32()}});
+  auto schema10 = ::arrow::schema({{"f2", int8()}, {"f1", int32()}});
+
+  AssertSchemaEqual(schema8, schema9);
+  AssertSchemaNotEqual(schema8, schema10);
 }
 
 TEST_F(TestSchema, ToString) {
@@ -1479,6 +1486,12 @@ TEST(TestStructType, Basics) {
 
   ASSERT_EQ(struct_type.ToString(), "struct<f0: int32, f1: string, f2: uint8>");
 
+  auto t1 = struct_({{"a", int8()}, {"b", utf8()}});
+  auto t2 = struct_({field("a", int8()), field("b", utf8())});
+  auto t3 = struct_({field("c", int8()), field("b", utf8())});
+  ASSERT_TRUE(t1->Equals(t2));
+  ASSERT_TRUE(!t1->Equals(t3));
+
   // TODO(wesm): out of bounds for field(...)
 }
 
diff --git a/cpp/src/parquet/arrow/schema.cc b/cpp/src/parquet/arrow/schema.cc
index f713548d05a70..3323b7ff8b608 100644
--- a/cpp/src/parquet/arrow/schema.cc
+++ b/cpp/src/parquet/arrow/schema.cc
@@ -839,7 +839,7 @@ std::function<std::shared_ptr<::arrow::DataType>(FieldVector)> GetNestedFactory(
   switch (inferred_type.id()) {
     case ::arrow::Type::STRUCT:
       if (origin_type.id() == ::arrow::Type::STRUCT) {
-        return ::arrow::struct_;
+        return [](FieldVector fields) { return ::arrow::struct_(std::move(fields)); };
       }
       break;
     case ::arrow::Type::LIST:

From 1a00fecf7dc1d75bfb5d31b6c5fae4b3d646bf1b Mon Sep 17 00:00:00 2001
From: pegasas <616672335@qq.com>
Date: Wed, 9 Aug 2023 22:44:34 +0800
Subject: [PATCH 125/749] GH-36674: [C++] Use anonymous namespace in
 arrow/ipc/reader.cc (#36937)

### Rationale for this change

The following types and functions should be in file scope:

IpcReadConext, BatchDataReadRequest, ArrayLoader,
DecompressBuffer(s), LoadRecordBatch*, GetCompression*,
ReadRecordBatchInternal,
GetInclusionMaskAndOutSchmea, UnpackSchemaMessage,
ReadDictionary, AsyncRecordBatchStreamReaderImpl.

### What changes are included in this PR?

Use anonymous namespace around the aforementioned definitions.

### Are these changes tested?

No

### Are there any user-facing changes?

No

Lead-authored-by: pegasas <616672335@qq.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/ipc/reader.cc | 81 ++++++++++++++++++-------------------
 1 file changed, 40 insertions(+), 41 deletions(-)

diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index eadba69f05612..125a8f2d4158c 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -109,8 +109,6 @@ Status InvalidMessageType(MessageType expected, MessageType actual) {
     }                                                                   \
   } while (0)
 
-}  // namespace
-
 // ----------------------------------------------------------------------
 // Record batch read path
 
@@ -634,8 +632,7 @@ Status GetCompressionExperimental(const flatbuf::Message* message,
   return Status::OK();
 }
 
-static Status ReadContiguousPayload(io::InputStream* file,
-                                    std::unique_ptr<Message>* message) {
+Status ReadContiguousPayload(io::InputStream* file, std::unique_ptr<Message>* message) {
   ARROW_ASSIGN_OR_RAISE(*message, ReadMessage(file));
   if (*message == nullptr) {
     return Status::Invalid("Unable to read metadata at offset");
@@ -643,27 +640,6 @@ static Status ReadContiguousPayload(io::InputStream* file,
   return Status::OK();
 }
 
-Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
-    const std::shared_ptr<Schema>& schema, const DictionaryMemo* dictionary_memo,
-    const IpcReadOptions& options, io::InputStream* file) {
-  std::unique_ptr<Message> message;
-  RETURN_NOT_OK(ReadContiguousPayload(file, &message));
-  CHECK_HAS_BODY(*message);
-  ARROW_ASSIGN_OR_RAISE(auto reader, Buffer::GetReader(message->body()));
-  return ReadRecordBatch(*message->metadata(), schema, dictionary_memo, options,
-                         reader.get());
-}
-
-Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
-    const Message& message, const std::shared_ptr<Schema>& schema,
-    const DictionaryMemo* dictionary_memo, const IpcReadOptions& options) {
-  CHECK_MESSAGE_TYPE(MessageType::RECORD_BATCH, message.type());
-  CHECK_HAS_BODY(message);
-  ARROW_ASSIGN_OR_RAISE(auto reader, Buffer::GetReader(message.body()));
-  return ReadRecordBatch(*message.metadata(), schema, dictionary_memo, options,
-                         reader.get());
-}
-
 Result<RecordBatchWithMetadata> ReadRecordBatchInternal(
     const Buffer& metadata, const std::shared_ptr<Schema>& schema,
     const std::vector<bool>& inclusion_mask, IpcReadContext& context,
@@ -764,22 +740,6 @@ Status UnpackSchemaMessage(const Message& message, const IpcReadOptions& options
                              out_schema, field_inclusion_mask, swap_endian);
 }
 
-Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
-    const Buffer& metadata, const std::shared_ptr<Schema>& schema,
-    const DictionaryMemo* dictionary_memo, const IpcReadOptions& options,
-    io::RandomAccessFile* file) {
-  std::shared_ptr<Schema> out_schema;
-  // Empty means do not use
-  std::vector<bool> inclusion_mask;
-  IpcReadContext context(const_cast<DictionaryMemo*>(dictionary_memo), options, false);
-  RETURN_NOT_OK(GetInclusionMaskAndOutSchema(schema, context.options.included_fields,
-                                             &inclusion_mask, &out_schema));
-  ARROW_ASSIGN_OR_RAISE(
-      auto batch_and_custom_metadata,
-      ReadRecordBatchInternal(metadata, schema, inclusion_mask, context, file));
-  return batch_and_custom_metadata.batch;
-}
-
 Status ReadDictionary(const Buffer& metadata, const IpcReadContext& context,
                       DictionaryKind* kind, io::RandomAccessFile* file) {
   const flatbuf::Message* message = nullptr;
@@ -851,6 +811,45 @@ Status ReadDictionary(const Message& message, const IpcReadContext& context,
   return ReadDictionary(*message.metadata(), context, kind, reader.get());
 }
 
+}  // namespace
+
+Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
+    const Buffer& metadata, const std::shared_ptr<Schema>& schema,
+    const DictionaryMemo* dictionary_memo, const IpcReadOptions& options,
+    io::RandomAccessFile* file) {
+  std::shared_ptr<Schema> out_schema;
+  // Empty means do not use
+  std::vector<bool> inclusion_mask;
+  IpcReadContext context(const_cast<DictionaryMemo*>(dictionary_memo), options, false);
+  RETURN_NOT_OK(GetInclusionMaskAndOutSchema(schema, context.options.included_fields,
+                                             &inclusion_mask, &out_schema));
+  ARROW_ASSIGN_OR_RAISE(
+      auto batch_and_custom_metadata,
+      ReadRecordBatchInternal(metadata, schema, inclusion_mask, context, file));
+  return batch_and_custom_metadata.batch;
+}
+
+Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
+    const std::shared_ptr<Schema>& schema, const DictionaryMemo* dictionary_memo,
+    const IpcReadOptions& options, io::InputStream* file) {
+  std::unique_ptr<Message> message;
+  RETURN_NOT_OK(ReadContiguousPayload(file, &message));
+  CHECK_HAS_BODY(*message);
+  ARROW_ASSIGN_OR_RAISE(auto reader, Buffer::GetReader(message->body()));
+  return ReadRecordBatch(*message->metadata(), schema, dictionary_memo, options,
+                         reader.get());
+}
+
+Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
+    const Message& message, const std::shared_ptr<Schema>& schema,
+    const DictionaryMemo* dictionary_memo, const IpcReadOptions& options) {
+  CHECK_MESSAGE_TYPE(MessageType::RECORD_BATCH, message.type());
+  CHECK_HAS_BODY(message);
+  ARROW_ASSIGN_OR_RAISE(auto reader, Buffer::GetReader(message.body()));
+  return ReadRecordBatch(*message.metadata(), schema, dictionary_memo, options,
+                         reader.get());
+}
+
 // Streaming format decoder
 class StreamDecoderInternal : public MessageDecoderListener {
  public:

From 9f183fc3e38abfd2edc492767280e6e917997e2c Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Wed, 9 Aug 2023 11:01:44 -0400
Subject: [PATCH 126/749] GH-36512: [C++][FlightRPC] Add async GetFlightInfo
 client call (#36517)

### Rationale for this change

Async is a long-requested feature.

### What changes are included in this PR?

Just the C++ implementation of async GetFlightInfo for the client.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes, new APIs.

* Closes: #36512

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/flight/CMakeLists.txt           |   5 +
 cpp/src/arrow/flight/api.h                    |   1 +
 cpp/src/arrow/flight/client.cc                |  58 ++++
 cpp/src/arrow/flight/client.h                 |  28 ++
 cpp/src/arrow/flight/flight_internals_test.cc |   6 +-
 cpp/src/arrow/flight/flight_test.cc           |  25 +-
 .../arrow/flight/serialization_internal.cc    |  24 +-
 cpp/src/arrow/flight/serialization_internal.h |   2 +-
 cpp/src/arrow/flight/test_definitions.cc      | 267 +++++++++++++++++-
 cpp/src/arrow/flight/test_definitions.h       |  26 ++
 cpp/src/arrow/flight/transport.cc             |  16 ++
 cpp/src/arrow/flight/transport.h              |  50 +++-
 .../flight/transport/grpc/grpc_client.cc      | 194 ++++++++++++-
 .../flight/transport/grpc/util_internal.cc    | 107 ++++++-
 .../flight/transport/grpc/util_internal.h     |   8 +
 cpp/src/arrow/flight/type_fwd.h               |   5 +
 cpp/src/arrow/flight/types.cc                 |  92 +++++-
 cpp/src/arrow/flight/types.h                  |  82 +++++-
 cpp/src/arrow/flight/types_async.h            |  80 ++++++
 19 files changed, 1024 insertions(+), 52 deletions(-)
 create mode 100644 cpp/src/arrow/flight/types_async.h

diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt
index 7383a7eec9045..6e76181533459 100644
--- a/cpp/src/arrow/flight/CMakeLists.txt
+++ b/cpp/src/arrow/flight/CMakeLists.txt
@@ -119,6 +119,11 @@ else()
   add_definitions(-DGRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS=grpc_impl::experimental)
 endif()
 
+# Was in a different namespace, or simply not supported, prior to this
+if(ARROW_GRPC_VERSION VERSION_GREATER_EQUAL "1.40")
+  add_definitions(-DGRPC_ENABLE_ASYNC)
+endif()
+
 # </KLUDGE> Restore the CXXFLAGS that were modified above
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_BACKUP}")
 
diff --git a/cpp/src/arrow/flight/api.h b/cpp/src/arrow/flight/api.h
index 61c475dc20473..ed31b5c8fa41f 100644
--- a/cpp/src/arrow/flight/api.h
+++ b/cpp/src/arrow/flight/api.h
@@ -27,3 +27,4 @@
 #include "arrow/flight/server_middleware.h"
 #include "arrow/flight/server_tracing_middleware.h"
 #include "arrow/flight/types.h"
+#include "arrow/flight/types_async.h"
diff --git a/cpp/src/arrow/flight/client.cc b/cpp/src/arrow/flight/client.cc
index ec5377b7c11dc..eb62ec65ffc5f 100644
--- a/cpp/src/arrow/flight/client.cc
+++ b/cpp/src/arrow/flight/client.cc
@@ -32,6 +32,7 @@
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/table.h"
+#include "arrow/util/future.h"
 #include "arrow/util/logging.h"
 
 #include "arrow/flight/client_auth.h"
@@ -39,11 +40,48 @@
 #include "arrow/flight/transport.h"
 #include "arrow/flight/transport/grpc/grpc_client.h"
 #include "arrow/flight/types.h"
+#include "arrow/flight/types_async.h"
 
 namespace arrow {
 
 namespace flight {
 
+namespace {
+template <typename T>
+class UnaryUnaryAsyncListener : public AsyncListener<T> {
+ public:
+  UnaryUnaryAsyncListener() : future_(arrow::Future<T>::Make()) {}
+
+  void OnNext(T result) override {
+    DCHECK(!result_.ok());
+    result_ = std::move(result);
+  }
+
+  void OnFinish(Status status) override {
+    if (status.ok()) {
+      DCHECK(result_.ok());
+    } else {
+      // Default-initialized result is not ok
+      DCHECK(!result_.ok());
+      result_ = std::move(status);
+    }
+    future_.MarkFinished(std::move(result_));
+  }
+
+  static std::pair<std::shared_ptr<AsyncListener<T>>, arrow::Future<T>> Make() {
+    auto self = std::make_shared<UnaryUnaryAsyncListener<T>>();
+    // Keep the listener alive by stashing it in the future
+    self->future_.AddCallback([self](const arrow::Result<T>&) {});
+    auto future = self->future_;
+    return std::make_pair(std::move(self), std::move(future));
+  }
+
+ private:
+  arrow::Result<T> result_;
+  arrow::Future<T> future_;
+};
+}  // namespace
+
 const char* kWriteSizeDetailTypeId = "flight::FlightWriteSizeStatusDetail";
 
 FlightCallOptions::FlightCallOptions()
@@ -584,6 +622,24 @@ arrow::Result<std::unique_ptr<FlightInfo>> FlightClient::GetFlightInfo(
   return info;
 }
 
+void FlightClient::GetFlightInfoAsync(
+    const FlightCallOptions& options, const FlightDescriptor& descriptor,
+    std::shared_ptr<AsyncListener<FlightInfo>> listener) {
+  if (auto status = CheckOpen(); !status.ok()) {
+    listener->OnFinish(std::move(status));
+    return;
+  }
+  transport_->GetFlightInfoAsync(options, descriptor, std::move(listener));
+}
+
+arrow::Future<FlightInfo> FlightClient::GetFlightInfoAsync(
+    const FlightCallOptions& options, const FlightDescriptor& descriptor) {
+  RETURN_NOT_OK(CheckOpen());
+  auto [listener, future] = UnaryUnaryAsyncListener<FlightInfo>::Make();
+  transport_->GetFlightInfoAsync(options, descriptor, std::move(listener));
+  return future;
+}
+
 arrow::Result<std::unique_ptr<SchemaResult>> FlightClient::GetSchema(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   RETURN_NOT_OK(CheckOpen());
@@ -658,6 +714,8 @@ Status FlightClient::Close() {
   return Status::OK();
 }
 
+bool FlightClient::supports_async() const { return transport_->supports_async(); }
+
 Status FlightClient::CheckOpen() const {
   if (closed_) {
     return Status::Invalid("FlightClient is closed");
diff --git a/cpp/src/arrow/flight/client.h b/cpp/src/arrow/flight/client.h
index 7204b469a6127..cc1c35aaebed3 100644
--- a/cpp/src/arrow/flight/client.h
+++ b/cpp/src/arrow/flight/client.h
@@ -271,6 +271,31 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return GetFlightInfo({}, descriptor);
   }
 
+  /// \brief Asynchronous GetFlightInfo.
+  /// \param[in] options Per-RPC options
+  /// \param[in] descriptor the dataset request
+  /// \param[in] listener Callbacks for response and RPC completion
+  ///
+  /// This API is EXPERIMENTAL.
+  void GetFlightInfoAsync(const FlightCallOptions& options,
+                          const FlightDescriptor& descriptor,
+                          std::shared_ptr<AsyncListener<FlightInfo>> listener);
+  void GetFlightInfoAsync(const FlightDescriptor& descriptor,
+                          std::shared_ptr<AsyncListener<FlightInfo>> listener) {
+    return GetFlightInfoAsync({}, descriptor, std::move(listener));
+  }
+
+  /// \brief Asynchronous GetFlightInfo returning a Future.
+  /// \param[in] options Per-RPC options
+  /// \param[in] descriptor the dataset request
+  ///
+  /// This API is EXPERIMENTAL.
+  arrow::Future<FlightInfo> GetFlightInfoAsync(const FlightCallOptions& options,
+                                               const FlightDescriptor& descriptor);
+  arrow::Future<FlightInfo> GetFlightInfoAsync(const FlightDescriptor& descriptor) {
+    return GetFlightInfoAsync({}, descriptor);
+  }
+
   /// \brief Request schema for a single flight, which may be an existing
   /// dataset or a command to be executed
   /// \param[in] options Per-RPC options
@@ -355,6 +380,9 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   /// \since 8.0.0
   Status Close();
 
+  /// \brief Whether this client supports asynchronous methods.
+  bool supports_async() const;
+
  private:
   FlightClient();
   Status CheckOpen() const;
diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index e56bab6db2092..72a25018e8ee8 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -76,9 +76,7 @@ void TestRoundtrip(const std::vector<FlightType>& values,
     ASSERT_OK(internal::ToProto(values[i], &pb_value));
 
     if constexpr (std::is_same_v<FlightType, FlightInfo>) {
-      FlightInfo::Data data;
-      ASSERT_OK(internal::FromProto(pb_value, &data));
-      FlightInfo value(std::move(data));
+      ASSERT_OK_AND_ASSIGN(FlightInfo value, internal::FromProto(pb_value));
       EXPECT_EQ(values[i], value);
     } else if constexpr (std::is_same_v<FlightType, SchemaResult>) {
       std::string data;
@@ -742,5 +740,7 @@ TEST(TransportErrorHandling, ReconstructStatus) {
   ASSERT_EQ(detail->extra_info(), "Binary error details");
 }
 
+// TODO: test TransportStatusDetail
+
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/flight_test.cc b/cpp/src/arrow/flight/flight_test.cc
index 1e7ea9bb002bb..c36c9eee71ba1 100644
--- a/cpp/src/arrow/flight/flight_test.cc
+++ b/cpp/src/arrow/flight/flight_test.cc
@@ -40,6 +40,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
 #include "arrow/util/base64.h"
+#include "arrow/util/future.h"
 #include "arrow/util/logging.h"
 
 #ifdef GRPCPP_GRPCPP_H
@@ -91,9 +92,16 @@ const char kAuthHeader[] = "authorization";
 //------------------------------------------------------------
 // Common transport tests
 
+#ifdef GRPC_ENABLE_ASYNC
+constexpr bool kGrpcSupportsAsync = true;
+#else
+constexpr bool kGrpcSupportsAsync = false;
+#endif
+
 class GrpcConnectivityTest : public ConnectivityTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -102,6 +110,7 @@ ARROW_FLIGHT_TEST_CONNECTIVITY(GrpcConnectivityTest);
 class GrpcDataTest : public DataTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -110,6 +119,7 @@ ARROW_FLIGHT_TEST_DATA(GrpcDataTest);
 class GrpcDoPutTest : public DoPutTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -118,6 +128,7 @@ ARROW_FLIGHT_TEST_DO_PUT(GrpcDoPutTest);
 class GrpcAppMetadataTest : public AppMetadataTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -126,6 +137,7 @@ ARROW_FLIGHT_TEST_APP_METADATA(GrpcAppMetadataTest);
 class GrpcIpcOptionsTest : public IpcOptionsTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -134,6 +146,7 @@ ARROW_FLIGHT_TEST_IPC_OPTIONS(GrpcIpcOptionsTest);
 class GrpcCudaDataTest : public CudaDataTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
@@ -142,11 +155,21 @@ ARROW_FLIGHT_TEST_CUDA_DATA(GrpcCudaDataTest);
 class GrpcErrorHandlingTest : public ErrorHandlingTest, public ::testing::Test {
  protected:
   std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
   void SetUp() override { SetUpTest(); }
   void TearDown() override { TearDownTest(); }
 };
 ARROW_FLIGHT_TEST_ERROR_HANDLING(GrpcErrorHandlingTest);
 
+class GrpcAsyncClientTest : public AsyncClientTest, public ::testing::Test {
+ protected:
+  std::string transport() const override { return "grpc"; }
+  bool supports_async() const override { return kGrpcSupportsAsync; }
+  void SetUp() override { SetUpTest(); }
+  void TearDown() override { TearDownTest(); }
+};
+ARROW_FLIGHT_TEST_ASYNC_CLIENT(GrpcAsyncClientTest);
+
 //------------------------------------------------------------
 // Ad-hoc gRPC-specific tests
 
@@ -443,7 +466,7 @@ class TestTls : public ::testing::Test {
   Location location_;
   std::unique_ptr<FlightClient> client_;
   std::unique_ptr<FlightServerBase> server_;
-  bool server_is_initialized_;
+  bool server_is_initialized_ = false;
 };
 
 // A server middleware that rejects all calls.
diff --git a/cpp/src/arrow/flight/serialization_internal.cc b/cpp/src/arrow/flight/serialization_internal.cc
index b0859e1d9164e..5d09a1a04586c 100644
--- a/cpp/src/arrow/flight/serialization_internal.cc
+++ b/cpp/src/arrow/flight/serialization_internal.cc
@@ -230,20 +230,21 @@ Status ToProto(const FlightDescriptor& descriptor, pb::FlightDescriptor* pb_desc
 
 // FlightInfo
 
-Status FromProto(const pb::FlightInfo& pb_info, FlightInfo::Data* info) {
-  RETURN_NOT_OK(FromProto(pb_info.flight_descriptor(), &info->descriptor));
+arrow::Result<FlightInfo> FromProto(const pb::FlightInfo& pb_info) {
+  FlightInfo::Data info;
+  RETURN_NOT_OK(FromProto(pb_info.flight_descriptor(), &info.descriptor));
 
-  info->schema = pb_info.schema();
+  info.schema = pb_info.schema();
 
-  info->endpoints.resize(pb_info.endpoint_size());
+  info.endpoints.resize(pb_info.endpoint_size());
   for (int i = 0; i < pb_info.endpoint_size(); ++i) {
-    RETURN_NOT_OK(FromProto(pb_info.endpoint(i), &info->endpoints[i]));
+    RETURN_NOT_OK(FromProto(pb_info.endpoint(i), &info.endpoints[i]));
   }
 
-  info->total_records = pb_info.total_records();
-  info->total_bytes = pb_info.total_bytes();
-  info->ordered = pb_info.ordered();
-  return Status::OK();
+  info.total_records = pb_info.total_records();
+  info.total_bytes = pb_info.total_bytes();
+  info.ordered = pb_info.ordered();
+  return FlightInfo(std::move(info));
 }
 
 Status FromProto(const pb::BasicAuth& pb_basic_auth, BasicAuth* basic_auth) {
@@ -291,9 +292,8 @@ Status ToProto(const FlightInfo& info, pb::FlightInfo* pb_info) {
 
 Status FromProto(const pb::CancelFlightInfoRequest& pb_request,
                  CancelFlightInfoRequest* request) {
-  FlightInfo::Data data;
-  RETURN_NOT_OK(FromProto(pb_request.info(), &data));
-  request->info = std::make_unique<FlightInfo>(std::move(data));
+  ARROW_ASSIGN_OR_RAISE(FlightInfo info, FromProto(pb_request.info()));
+  request->info = std::make_unique<FlightInfo>(std::move(info));
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/flight/serialization_internal.h b/cpp/src/arrow/flight/serialization_internal.h
index b0a3491ac261d..30eb0b31819b8 100644
--- a/cpp/src/arrow/flight/serialization_internal.h
+++ b/cpp/src/arrow/flight/serialization_internal.h
@@ -59,7 +59,7 @@ Status FromProto(const pb::FlightDescriptor& pb_descr, FlightDescriptor* descr);
 Status FromProto(const pb::FlightEndpoint& pb_endpoint, FlightEndpoint* endpoint);
 Status FromProto(const pb::RenewFlightEndpointRequest& pb_request,
                  RenewFlightEndpointRequest* request);
-Status FromProto(const pb::FlightInfo& pb_info, FlightInfo::Data* info);
+arrow::Result<FlightInfo> FromProto(const pb::FlightInfo& pb_info);
 Status FromProto(const pb::CancelFlightInfoRequest& pb_request,
                  CancelFlightInfoRequest* request);
 Status FromProto(const pb::SchemaResult& pb_result, std::string* result);
diff --git a/cpp/src/arrow/flight/test_definitions.cc b/cpp/src/arrow/flight/test_definitions.cc
index 4e137380044f3..55be3244fbde4 100644
--- a/cpp/src/arrow/flight/test_definitions.cc
+++ b/cpp/src/arrow/flight/test_definitions.cc
@@ -20,6 +20,7 @@
 #include <chrono>
 #include <memory>
 #include <mutex>
+#include <unordered_map>
 
 #include "arrow/array/array_base.h"
 #include "arrow/array/array_dict.h"
@@ -27,7 +28,11 @@
 #include "arrow/flight/api.h"
 #include "arrow/flight/client_middleware.h"
 #include "arrow/flight/test_util.h"
+#include "arrow/flight/types.h"
+#include "arrow/flight/types_async.h"
+#include "arrow/status.h"
 #include "arrow/table.h"
+#include "arrow/testing/future_util.h"
 #include "arrow/testing/generator.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/checked_cast.h"
@@ -123,6 +128,28 @@ void ConnectivityTest::TestBrokenConnection() {
 //------------------------------------------------------------
 // Tests of data plane methods
 
+namespace {
+class GetFlightInfoListener : public AsyncListener<FlightInfo> {
+ public:
+  void OnNext(FlightInfo message) override {
+    info = std::move(message);
+    counter++;
+  }
+  void OnFinish(Status status) override {
+    ASSERT_FALSE(future.is_finished());
+    if (status.ok()) {
+      future.MarkFinished(std::move(info));
+    } else {
+      future.MarkFinished(std::move(status));
+    }
+  }
+
+  FlightInfo info = FlightInfo(FlightInfo::Data{});
+  int counter = 0;
+  arrow::Future<FlightInfo> future = arrow::Future<FlightInfo>::Make();
+};
+}  // namespace
+
 void DataTest::SetUpTest() {
   server_ = ExampleTestServer();
 
@@ -150,6 +177,14 @@ void DataTest::CheckDoGet(
   ASSERT_OK_AND_ASSIGN(auto info, client_->GetFlightInfo(descr));
   check_endpoints(info->endpoints());
 
+  if (supports_async()) {
+    auto listener = std::make_shared<GetFlightInfoListener>();
+    client_->GetFlightInfoAsync(descr, listener);
+    ASSERT_FINISHES_OK(listener->future);
+    ASSERT_EQ(1, listener->counter);
+    check_endpoints(listener->future.MoveResult()->endpoints());
+  }
+
   ipc::DictionaryMemo dict_memo;
   ASSERT_OK_AND_ASSIGN(auto schema, info->GetSchema(&dict_memo));
   AssertSchemaEqual(*expected_schema, *schema);
@@ -671,11 +706,11 @@ void DoPutTest::SetUpTest() {
 void DoPutTest::TearDownTest() {
   ASSERT_OK(client_->Close());
   ASSERT_OK(server_->Shutdown());
-  reinterpret_cast<DoPutTestServer*>(server_.get())->batches_.clear();
+  checked_cast<DoPutTestServer*>(server_.get())->batches_.clear();
 }
 void DoPutTest::CheckBatches(const FlightDescriptor& expected_descriptor,
                              const RecordBatchVector& expected_batches) {
-  auto* do_put_server = (DoPutTestServer*)server_.get();
+  auto* do_put_server = static_cast<DoPutTestServer*>(server_.get());
   ASSERT_EQ(do_put_server->descriptor_, expected_descriptor);
   ASSERT_EQ(do_put_server->batches_.size(), expected_batches.size());
   for (size_t i = 0; i < expected_batches.size(); ++i) {
@@ -1410,6 +1445,26 @@ static const std::vector<StatusCode> kStatusCodes = {
     StatusCode::AlreadyExists,
 };
 
+// For each Arrow status code, what Flight code do we get?
+static const std::unordered_map<StatusCode, TransportStatusCode> kTransportStatusCodes = {
+    {StatusCode::OutOfMemory, TransportStatusCode::kUnknown},
+    {StatusCode::KeyError, TransportStatusCode::kNotFound},
+    {StatusCode::TypeError, TransportStatusCode::kUnknown},
+    {StatusCode::Invalid, TransportStatusCode::kInvalidArgument},
+    {StatusCode::IOError, TransportStatusCode::kUnknown},
+    {StatusCode::CapacityError, TransportStatusCode::kUnknown},
+    {StatusCode::IndexError, TransportStatusCode::kUnknown},
+    {StatusCode::Cancelled, TransportStatusCode::kCancelled},
+    {StatusCode::UnknownError, TransportStatusCode::kUnknown},
+    {StatusCode::NotImplemented, TransportStatusCode::kUnimplemented},
+    {StatusCode::SerializationError, TransportStatusCode::kUnknown},
+    {StatusCode::RError, TransportStatusCode::kUnknown},
+    {StatusCode::CodeGenError, TransportStatusCode::kUnknown},
+    {StatusCode::ExpressionValidationError, TransportStatusCode::kUnknown},
+    {StatusCode::ExecutionError, TransportStatusCode::kUnknown},
+    {StatusCode::AlreadyExists, TransportStatusCode::kAlreadyExists},
+};
+
 static const std::vector<FlightStatusCode> kFlightStatusCodes = {
     FlightStatusCode::Internal,     FlightStatusCode::TimedOut,
     FlightStatusCode::Cancelled,    FlightStatusCode::Unauthenticated,
@@ -1517,6 +1572,15 @@ class MetadataRecordingClientMiddlewareFactory : public ClientMiddlewareFactory
   mutable std::mutex mutex_;
   std::vector<std::pair<std::string, std::string>> headers_;
 };
+
+class TransportStatusListener : public AsyncListener<FlightInfo> {
+ public:
+  void OnNext(FlightInfo /*message*/) override {}
+  void OnFinish(Status status) override { future.MarkFinished(std::move(status)); }
+
+  arrow::Future<> future = arrow::Future<>::Make();
+};
+
 }  // namespace
 
 struct ErrorHandlingTest::Impl {
@@ -1544,6 +1608,98 @@ std::vector<std::pair<std::string, std::string>> ErrorHandlingTest::GetHeaders()
   return impl_->metadata->GetHeaders();
 }
 
+void ErrorHandlingTest::TestAsyncGetFlightInfo() {
+  if (!supports_async()) {
+    GTEST_SKIP() << "Transport does not support async";
+  }
+  // Server-side still does all the junk around trying to translate Arrow
+  // status codes, so this test is a little indirect
+
+  for (const auto code : kStatusCodes) {
+    ARROW_SCOPED_TRACE("C++ status code: ", static_cast<int>(code), ": ",
+                       Status::CodeAsString(code));
+
+    // Just the status code
+    {
+      auto descr = FlightDescriptor::Path(
+          {std::to_string(static_cast<int>(code)), "Expected message"});
+      auto listener = std::make_shared<TransportStatusListener>();
+
+      client_->GetFlightInfoAsync(descr, listener);
+      EXPECT_FINISHES(listener->future);
+      auto detail = TransportStatusDetail::Unwrap(listener->future.status());
+      ASSERT_TRUE(detail.has_value());
+
+      EXPECT_EQ(detail->get().code(), kTransportStatusCodes.at(code));
+      // Exact equality - should have no extra junk in the message
+      EXPECT_EQ(detail->get().message(), "Expected message");
+    }
+
+    // Custom status detail
+    {
+      auto descr = FlightDescriptor::Path(
+          {std::to_string(static_cast<int>(code)), "Expected message", ""});
+      auto listener = std::make_shared<TransportStatusListener>();
+
+      client_->GetFlightInfoAsync(descr, listener);
+      EXPECT_FINISHES(listener->future);
+      auto detail = TransportStatusDetail::Unwrap(listener->future.status());
+      ASSERT_TRUE(detail.has_value());
+
+      EXPECT_EQ(detail->get().code(), kTransportStatusCodes.at(code));
+      // The server-side arrow::Status-to-TransportStatus conversion puts the
+      // detail into the main error message.
+      EXPECT_EQ(detail->get().message(),
+                "Expected message. Detail: Custom status detail");
+
+      std::string_view arrow_code, arrow_message;
+      for (const auto& [key, value] : detail->get().details()) {
+        if (key == "x-arrow-status") {
+          arrow_code = value;
+        } else if (key == "x-arrow-status-message-bin") {
+          arrow_message = value;
+        }
+      }
+      EXPECT_EQ(arrow_code, std::to_string(static_cast<int>(code)));
+      EXPECT_EQ(arrow_message, "Expected message");
+    }
+
+    // Flight status detail
+    for (const auto flight_code : kFlightStatusCodes) {
+      ARROW_SCOPED_TRACE("Flight status code: ", static_cast<int>(flight_code));
+      auto descr = FlightDescriptor::Path(
+          {std::to_string(static_cast<int>(code)), "Expected message",
+           std::to_string(static_cast<int>(flight_code)), "Expected detail message"});
+      auto listener = std::make_shared<TransportStatusListener>();
+
+      client_->GetFlightInfoAsync(descr, listener);
+      EXPECT_FINISHES(listener->future);
+      auto detail = TransportStatusDetail::Unwrap(listener->future.status());
+      ASSERT_TRUE(detail.has_value());
+
+      // The server-side arrow::Status-to-TransportStatus conversion puts the
+      // detail into the main error message.
+      EXPECT_THAT(detail->get().message(),
+                  ::testing::HasSubstr("Expected message. Detail:"));
+
+      std::string_view arrow_code, arrow_message, binary_detail;
+      for (const auto& [key, value] : detail->get().details()) {
+        if (key == "x-arrow-status") {
+          arrow_code = value;
+        } else if (key == "x-arrow-status-message-bin") {
+          arrow_message = value;
+        } else if (key == "grpc-status-details-bin") {
+          binary_detail = value;
+        }
+      }
+
+      EXPECT_EQ(arrow_code, std::to_string(static_cast<int>(code)));
+      EXPECT_EQ(arrow_message, "Expected message");
+      EXPECT_EQ(binary_detail, "Expected detail message");
+    }
+  }
+}
+
 void ErrorHandlingTest::TestGetFlightInfo() {
   std::unique_ptr<FlightInfo> info;
   for (const auto code : kStatusCodes) {
@@ -1656,5 +1812,112 @@ void ErrorHandlingTest::TestDoExchange() {
   reader_thread.join();
 }
 
+//------------------------------------------------------------
+// Test async clients
+
+void AsyncClientTest::SetUpTest() {
+  if (!supports_async()) {
+    GTEST_SKIP() << "async is not supported";
+  }
+
+  ASSERT_OK_AND_ASSIGN(auto location, Location::ForScheme(transport(), "127.0.0.1", 0));
+
+  server_ = ExampleTestServer();
+  FlightServerOptions server_options(location);
+  ASSERT_OK(server_->Init(server_options));
+
+  std::string uri = location.scheme() + "://127.0.0.1:" + std::to_string(server_->port());
+  ASSERT_OK_AND_ASSIGN(auto real_location, Location::Parse(uri));
+  FlightClientOptions client_options = FlightClientOptions::Defaults();
+  ASSERT_OK_AND_ASSIGN(client_, FlightClient::Connect(real_location, client_options));
+
+  ASSERT_TRUE(client_->supports_async());
+}
+void AsyncClientTest::TearDownTest() {
+  if (supports_async()) {
+    ASSERT_OK(client_->Close());
+    ASSERT_OK(server_->Shutdown());
+  }
+}
+
+void AsyncClientTest::TestGetFlightInfo() {
+  class Listener : public AsyncListener<FlightInfo> {
+   public:
+    void OnNext(FlightInfo info) override {
+      info_ = std::move(info);
+      counter_++;
+    }
+
+    void OnFinish(Status status) override {
+      ASSERT_FALSE(future_.is_finished());
+      if (status.ok()) {
+        future_.MarkFinished(std::move(info_));
+      } else {
+        future_.MarkFinished(std::move(status));
+      }
+    }
+
+    int counter_ = 0;
+    FlightInfo info_ = FlightInfo(FlightInfo::Data());
+    arrow::Future<FlightInfo> future_ = arrow::Future<FlightInfo>::Make();
+  };
+
+  auto descr = FlightDescriptor::Command("status-outofmemory");
+  auto listener = std::make_shared<Listener>();
+  client_->GetFlightInfoAsync(descr, listener);
+
+  ASSERT_FINISHES_AND_RAISES(UnknownError, listener->future_);
+  ASSERT_THAT(listener->future_.status().ToString(), ::testing::HasSubstr("Sentinel"));
+  ASSERT_EQ(0, listener->counter_);
+}
+
+void AsyncClientTest::TestGetFlightInfoFuture() {
+  auto descr = FlightDescriptor::Command("status-outofmemory");
+  auto future = client_->GetFlightInfoAsync(descr);
+  ASSERT_FINISHES_AND_RAISES(UnknownError, future);
+  ASSERT_THAT(future.status().ToString(), ::testing::HasSubstr("Sentinel"));
+
+  descr = FlightDescriptor::Command("my_command");
+  future = client_->GetFlightInfoAsync(descr);
+  ASSERT_FINISHES_OK_AND_ASSIGN(auto info, future);
+  // See test_util.cc:ExampleFlightInfo
+  ASSERT_EQ(descr, info.descriptor());
+  ASSERT_EQ(1000, info.total_records());
+  ASSERT_EQ(100000, info.total_bytes());
+}
+
+void AsyncClientTest::TestListenerLifetime() {
+  arrow::Future<FlightInfo> future = arrow::Future<FlightInfo>::Make();
+
+  class Listener : public AsyncListener<FlightInfo> {
+   public:
+    void OnNext(FlightInfo info) override { info_ = std::move(info); }
+
+    void OnFinish(Status status) override {
+      if (status.ok()) {
+        future_.MarkFinished(std::move(info_));
+      } else {
+        future_.MarkFinished(std::move(status));
+      }
+    }
+
+    FlightInfo info_ = FlightInfo(FlightInfo::Data());
+    arrow::Future<FlightInfo> future_;
+  };
+
+  // Bad client code: don't retain a reference to the listener, which owns the
+  // RPC state. We should still be able to get the result without crashing. (The
+  // RPC state is disposed of in the background via the 'garbage bin' in the
+  // gRPC client implementation.)
+  {
+    auto descr = FlightDescriptor::Command("my_command");
+    auto listener = std::make_shared<Listener>();
+    listener->future_ = future;
+    client_->GetFlightInfoAsync(descr, std::move(listener));
+  }
+
+  ASSERT_FINISHES_OK(future);
+}
+
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/test_definitions.h b/cpp/src/arrow/flight/test_definitions.h
index c73bc264b4966..1e0e8c209ac94 100644
--- a/cpp/src/arrow/flight/test_definitions.h
+++ b/cpp/src/arrow/flight/test_definitions.h
@@ -40,6 +40,7 @@ namespace flight {
 class ARROW_FLIGHT_EXPORT FlightTest {
  protected:
   virtual std::string transport() const = 0;
+  virtual bool supports_async() const { return false; }
   virtual void SetUpTest() {}
   virtual void TearDownTest() {}
 };
@@ -266,6 +267,7 @@ class ARROW_FLIGHT_EXPORT ErrorHandlingTest : public FlightTest {
   // Test methods
   void TestGetFlightInfo();
   void TestGetFlightInfoMetadata();
+  void TestAsyncGetFlightInfo();
   void TestDoPut();
   void TestDoExchange();
 
@@ -282,10 +284,34 @@ class ARROW_FLIGHT_EXPORT ErrorHandlingTest : public FlightTest {
 #define ARROW_FLIGHT_TEST_ERROR_HANDLING(FIXTURE)                                 \
   static_assert(std::is_base_of<ErrorHandlingTest, FIXTURE>::value,               \
                 ARROW_STRINGIFY(FIXTURE) " must inherit from ErrorHandlingTest"); \
+  TEST_F(FIXTURE, TestAsyncGetFlightInfo) { TestAsyncGetFlightInfo(); }           \
   TEST_F(FIXTURE, TestGetFlightInfo) { TestGetFlightInfo(); }                     \
   TEST_F(FIXTURE, TestGetFlightInfoMetadata) { TestGetFlightInfoMetadata(); }     \
   TEST_F(FIXTURE, TestDoPut) { TestDoPut(); }                                     \
   TEST_F(FIXTURE, TestDoExchange) { TestDoExchange(); }
 
+/// \brief Tests of the async client.
+class ARROW_FLIGHT_EXPORT AsyncClientTest : public FlightTest {
+ public:
+  void SetUpTest() override;
+  void TearDownTest() override;
+
+  // Test methods
+  void TestGetFlightInfo();
+  void TestGetFlightInfoFuture();
+  void TestListenerLifetime();
+
+ private:
+  std::unique_ptr<FlightClient> client_;
+  std::unique_ptr<FlightServerBase> server_;
+};
+
+#define ARROW_FLIGHT_TEST_ASYNC_CLIENT(FIXTURE)                                 \
+  static_assert(std::is_base_of<AsyncClientTest, FIXTURE>::value,               \
+                ARROW_STRINGIFY(FIXTURE) " must inherit from AsyncClientTest"); \
+  TEST_F(FIXTURE, TestGetFlightInfo) { TestGetFlightInfo(); }                   \
+  TEST_F(FIXTURE, TestGetFlightInfoFuture) { TestGetFlightInfoFuture(); }       \
+  TEST_F(FIXTURE, TestListenerLifetime) { TestListenerLifetime(); }
+
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/transport.cc b/cpp/src/arrow/flight/transport.cc
index a0281ffd61e60..88228f2503597 100644
--- a/cpp/src/arrow/flight/transport.cc
+++ b/cpp/src/arrow/flight/transport.cc
@@ -24,6 +24,7 @@
 #include "arrow/flight/client_auth.h"
 #include "arrow/flight/transport_server.h"
 #include "arrow/flight/types.h"
+#include "arrow/flight/types_async.h"
 #include "arrow/ipc/message.h"
 #include "arrow/result.h"
 #include "arrow/status.h"
@@ -74,6 +75,11 @@ Status ClientTransport::GetFlightInfo(const FlightCallOptions& options,
                                       std::unique_ptr<FlightInfo>* info) {
   return Status::NotImplemented("GetFlightInfo for this transport");
 }
+void ClientTransport::GetFlightInfoAsync(
+    const FlightCallOptions& options, const FlightDescriptor& descriptor,
+    std::shared_ptr<AsyncListener<FlightInfo>> listener) {
+  listener->OnFinish(Status::NotImplemented("Async GetFlightInfo for this transport"));
+}
 arrow::Result<std::unique_ptr<SchemaResult>> ClientTransport::GetSchema(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   return Status::NotImplemented("GetSchema for this transport");
@@ -95,6 +101,16 @@ Status ClientTransport::DoExchange(const FlightCallOptions& options,
                                    std::unique_ptr<ClientDataStream>* stream) {
   return Status::NotImplemented("DoExchange for this transport");
 }
+void ClientTransport::SetAsyncRpc(AsyncListenerBase* listener,
+                                  std::unique_ptr<AsyncRpc>&& rpc) {
+  listener->rpc_state_ = std::move(rpc);
+}
+AsyncRpc* ClientTransport::GetAsyncRpc(AsyncListenerBase* listener) {
+  return listener->rpc_state_.get();
+}
+std::unique_ptr<AsyncRpc> ClientTransport::ReleaseAsyncRpc(AsyncListenerBase* listener) {
+  return std::move(listener->rpc_state_);
+}
 
 class TransportRegistry::Impl final {
  public:
diff --git a/cpp/src/arrow/flight/transport.h b/cpp/src/arrow/flight/transport.h
index 6406734e6e7e7..69605d2112f1f 100644
--- a/cpp/src/arrow/flight/transport.h
+++ b/cpp/src/arrow/flight/transport.h
@@ -64,7 +64,9 @@
 #include <vector>
 
 #include "arrow/flight/type_fwd.h"
+#include "arrow/flight/types.h"
 #include "arrow/flight/visibility.h"
+#include "arrow/ipc/options.h"
 #include "arrow/type_fwd.h"
 
 namespace arrow {
@@ -182,6 +184,9 @@ class ARROW_FLIGHT_EXPORT ClientTransport {
   virtual Status GetFlightInfo(const FlightCallOptions& options,
                                const FlightDescriptor& descriptor,
                                std::unique_ptr<FlightInfo>* info);
+  virtual void GetFlightInfoAsync(const FlightCallOptions& options,
+                                  const FlightDescriptor& descriptor,
+                                  std::shared_ptr<AsyncListener<FlightInfo>> listener);
   virtual arrow::Result<std::unique_ptr<SchemaResult>> GetSchema(
       const FlightCallOptions& options, const FlightDescriptor& descriptor);
   virtual Status ListFlights(const FlightCallOptions& options, const Criteria& criteria,
@@ -192,6 +197,12 @@ class ARROW_FLIGHT_EXPORT ClientTransport {
                        std::unique_ptr<ClientDataStream>* stream);
   virtual Status DoExchange(const FlightCallOptions& options,
                             std::unique_ptr<ClientDataStream>* stream);
+
+  virtual bool supports_async() const { return false; }
+
+  static void SetAsyncRpc(AsyncListenerBase* listener, std::unique_ptr<AsyncRpc>&& rpc);
+  static AsyncRpc* GetAsyncRpc(AsyncListenerBase* listener);
+  static std::unique_ptr<AsyncRpc> ReleaseAsyncRpc(AsyncListenerBase* listener);
 };
 
 /// A registry of transport implementations.
@@ -223,24 +234,33 @@ ARROW_FLIGHT_EXPORT
 TransportRegistry* GetDefaultTransportRegistry();
 
 //------------------------------------------------------------
-// Error propagation helpers
+// Async APIs
 
-/// \brief Abstract status code as per the Flight specification.
-enum class TransportStatusCode {
-  kOk = 0,
-  kUnknown = 1,
-  kInternal = 2,
-  kInvalidArgument = 3,
-  kTimedOut = 4,
-  kNotFound = 5,
-  kAlreadyExists = 6,
-  kCancelled = 7,
-  kUnauthenticated = 8,
-  kUnauthorized = 9,
-  kUnimplemented = 10,
-  kUnavailable = 11,
+/// \brief Transport-specific state for an async RPC.
+///
+/// Transport implementations may subclass this to store their own
+/// state, and stash an instance in a user-supplied AsyncListener via
+/// ClientTransport::GetAsyncRpc and ClientTransport::SetAsyncRpc.
+///
+/// This API is EXPERIMENTAL.
+class ARROW_FLIGHT_EXPORT AsyncRpc {
+ public:
+  virtual ~AsyncRpc() = default;
+  /// \brief Request cancellation of the RPC.
+  virtual void TryCancel() {}
+
+  /// Only needed for DoPut/DoExchange
+  virtual void Begin(const FlightDescriptor& descriptor, std::shared_ptr<Schema> schema) {
+  }
+  /// Only needed for DoPut/DoExchange
+  virtual void Write(arrow::flight::FlightStreamChunk chunk) {}
+  /// Only needed for DoPut/DoExchange
+  virtual void DoneWriting() {}
 };
 
+//------------------------------------------------------------
+// Error propagation helpers
+
 /// \brief Abstract error status.
 ///
 /// Transport implementations may use side channels (e.g. HTTP
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
index 9b40015f9f729..7108f35549998 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
@@ -17,15 +17,19 @@
 
 #include "arrow/flight/transport/grpc/grpc_client.h"
 
+#include <condition_variable>
+#include <deque>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <sstream>
 #include <string>
+#include <thread>
 #include <unordered_map>
 #include <utility>
 
 #include <grpcpp/grpcpp.h>
+#include <grpcpp/support/client_callback.h>
 #if defined(GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS)
 #include <grpcpp/security/tls_credentials_options.h>
 #endif
@@ -51,6 +55,7 @@
 #include "arrow/flight/transport/grpc/serialization_internal.h"
 #include "arrow/flight/transport/grpc/util_internal.h"
 #include "arrow/flight/types.h"
+#include "arrow/flight/types_async.h"
 
 namespace arrow {
 
@@ -549,6 +554,127 @@ class GrpcResultStream : public ResultStream {
   std::unique_ptr<::grpc::ClientReader<pb::Result>> stream_;
 };
 
+#ifdef GRPC_ENABLE_ASYNC
+/// Force destruction to wait for RPC completion.
+class FinishedFlag {
+ public:
+  ~FinishedFlag() { Wait(); }
+
+  void Finish() {
+    std::lock_guard<std::mutex> guard(mutex_);
+    finished_ = true;
+    cv_.notify_all();
+  }
+  void Wait() const {
+    std::unique_lock<std::mutex> guard(mutex_);
+    cv_.wait(guard, [&]() { return finished_; });
+  }
+
+ private:
+  mutable std::mutex mutex_;
+  mutable std::condition_variable cv_;
+  bool finished_{false};
+};
+
+// XXX: it appears that if we destruct gRPC resources (like a
+// ClientContext) from a gRPC callback, we will be running on a gRPC
+// thread and we may attempt to join ourselves (because gRPC
+// apparently refcounts threads).  Avoid that by transferring gRPC
+// resources to a dedicated thread for destruction.
+class GrpcGarbageBin {
+ public:
+  GrpcGarbageBin() {
+    grpc_destructor_thread_ = std::thread([&]() {
+      while (true) {
+        std::unique_lock<std::mutex> guard(grpc_destructor_mutex_);
+        grpc_destructor_cv_.wait(guard,
+                                 [&]() { return !running_ || !garbage_bin_.empty(); });
+
+        garbage_bin_.clear();
+
+        if (!running_) return;
+      }
+    });
+  }
+
+  void Dispose(std::unique_ptr<internal::AsyncRpc> trash) {
+    std::unique_lock<std::mutex> guard(grpc_destructor_mutex_);
+    if (!running_) return;
+    garbage_bin_.push_back(std::move(trash));
+    grpc_destructor_cv_.notify_all();
+  }
+
+  void Stop() {
+    {
+      std::unique_lock<std::mutex> guard(grpc_destructor_mutex_);
+      running_ = false;
+      grpc_destructor_cv_.notify_all();
+    }
+    grpc_destructor_thread_.join();
+  }
+
+ private:
+  bool running_ = true;
+  std::thread grpc_destructor_thread_;
+  std::mutex grpc_destructor_mutex_;
+  std::condition_variable grpc_destructor_cv_;
+  std::deque<std::unique_ptr<internal::AsyncRpc>> garbage_bin_;
+};
+
+template <typename Result, typename Request, typename Response>
+class UnaryUnaryAsyncCall : public ::grpc::ClientUnaryReactor, public internal::AsyncRpc {
+ public:
+  ClientRpc rpc;
+  std::shared_ptr<AsyncListener<Result>> listener;
+  std::shared_ptr<GrpcGarbageBin> garbage_bin_;
+
+  Request pb_request;
+  Response pb_response;
+  Status client_status;
+
+  // Destruct last
+  FinishedFlag finished;
+
+  explicit UnaryUnaryAsyncCall(const FlightCallOptions& options,
+                               std::shared_ptr<AsyncListener<Result>> listener,
+                               std::shared_ptr<GrpcGarbageBin> garbage_bin)
+      : rpc(options),
+        listener(std::move(listener)),
+        garbage_bin_(std::move(garbage_bin)) {}
+
+  void TryCancel() override { rpc.context.TryCancel(); }
+
+  void OnDone(const ::grpc::Status& status) override {
+    if (status.ok()) {
+      auto result = internal::FromProto(pb_response);
+      client_status = result.status();
+      if (client_status.ok()) {
+        listener->OnNext(std::move(result).MoveValueUnsafe());
+      }
+    }
+    Finish(status);
+  }
+
+  void Finish(const ::grpc::Status& status) {
+    auto listener = std::move(this->listener);
+    listener->OnFinish(
+        CombinedTransportStatus(status, std::move(client_status), &rpc.context));
+    // SetAsyncRpc may trigger destruction, so Finish() first
+    finished.Finish();
+    // Instead of potentially destructing gRPC resources here,
+    // transfer it to a dedicated background thread
+    garbage_bin_->Dispose(
+        flight::internal::ClientTransport::ReleaseAsyncRpc(listener.get()));
+  }
+};
+
+#define LISTENER_NOT_OK(LISTENER, EXPR)                 \
+  if (auto arrow_status = (EXPR); !arrow_status.ok()) { \
+    (LISTENER)->OnFinish(std::move(arrow_status));      \
+    return;                                             \
+  }
+#endif
+
 class GrpcClientImpl : public internal::ClientTransport {
  public:
   static arrow::Result<std::unique_ptr<internal::ClientTransport>> Make() {
@@ -702,14 +828,30 @@ class GrpcClientImpl : public internal::ClientTransport {
     stub_ = pb::FlightService::NewStub(
         ::grpc::experimental::CreateCustomChannelWithInterceptors(
             grpc_uri.str(), creds, args, std::move(interceptors)));
+
+#ifdef GRPC_ENABLE_ASYNC
+    garbage_bin_ = std::make_shared<GrpcGarbageBin>();
+#endif
+
     return Status::OK();
   }
 
   Status Close() override {
-    // TODO(ARROW-15473): if we track ongoing RPCs, we can cancel them first
-    // gRPC does not offer a real Close(). We could reset() the gRPC
-    // client but that can cause gRPC to hang in shutdown
-    // (ARROW-15793).
+#ifdef GRPC_ENABLE_ASYNC
+    // TODO(https://github.com/apache/arrow/issues/30949): if there are async
+    // RPCs running when the client is stopped, then when they go to use the
+    // garbage bin, they'll instead synchronously dispose of resources from
+    // the callback thread, and will likely crash. We could instead cancel
+    // them first and wait for completion before stopping the thread, but
+    // tracking all of the RPCs may be unacceptable overhead for clients that
+    // are making many small concurrent RPC calls, so it remains to be seen
+    // whether there's a pressing need for this.
+    garbage_bin_->Stop();
+#endif
+    // TODO(https://github.com/apache/arrow/issues/30949): if we track ongoing
+    // RPCs, we can cancel them first gRPC does not offer a real Close(). We
+    // could reset() the gRPC client but that can cause gRPC to hang in
+    // shutdown (https://github.com/apache/arrow/issues/31235).
     return Status::OK();
   }
 
@@ -745,8 +887,7 @@ class GrpcClientImpl : public internal::ClientTransport {
 
     pb::FlightInfo pb_info;
     while (!options.stop_token.IsStopRequested() && stream->Read(&pb_info)) {
-      FlightInfo::Data info_data;
-      RETURN_NOT_OK(internal::FromProto(pb_info, &info_data));
+      ARROW_ASSIGN_OR_RAISE(FlightInfo info_data, internal::FromProto(pb_info));
       flights.emplace_back(std::move(info_data));
     }
     if (options.stop_token.IsStopRequested()) rpc.context.TryCancel();
@@ -796,9 +937,8 @@ class GrpcClientImpl : public internal::ClientTransport {
         stub_->GetFlightInfo(&rpc.context, pb_descriptor, &pb_response), &rpc.context);
     RETURN_NOT_OK(s);
 
-    FlightInfo::Data info_data;
-    RETURN_NOT_OK(internal::FromProto(pb_response, &info_data));
-    info->reset(new FlightInfo(std::move(info_data)));
+    ARROW_ASSIGN_OR_RAISE(auto info_data, internal::FromProto(pb_response));
+    *info = std::make_unique<FlightInfo>(std::move(info_data));
     return Status::OK();
   }
 
@@ -855,6 +995,36 @@ class GrpcClientImpl : public internal::ClientTransport {
     return Status::OK();
   }
 
+#ifdef GRPC_ENABLE_ASYNC
+  void GetFlightInfoAsync(const FlightCallOptions& options,
+                          const FlightDescriptor& descriptor,
+                          std::shared_ptr<AsyncListener<FlightInfo>> listener) override {
+    using AsyncCall =
+        UnaryUnaryAsyncCall<FlightInfo, pb::FlightDescriptor, pb::FlightInfo>;
+    auto call = std::make_unique<AsyncCall>(options, listener, garbage_bin_);
+    LISTENER_NOT_OK(listener, internal::ToProto(descriptor, &call->pb_request));
+    LISTENER_NOT_OK(listener, call->rpc.SetToken(auth_handler_.get()));
+
+    stub_->experimental_async()->GetFlightInfo(&call->rpc.context, &call->pb_request,
+                                               &call->pb_response, call.get());
+    ClientTransport::SetAsyncRpc(listener.get(), std::move(call));
+    arrow::internal::checked_cast<AsyncCall*>(
+        ClientTransport::GetAsyncRpc(listener.get()))
+        ->StartCall();
+  }
+
+  bool supports_async() const override { return true; }
+#else
+  void GetFlightInfoAsync(const FlightCallOptions& options,
+                          const FlightDescriptor& descriptor,
+                          std::shared_ptr<AsyncListener<FlightInfo>> listener) override {
+    listener->OnFinish(
+        Status::NotImplemented("gRPC 1.40 or newer is required to use async"));
+  }
+
+  bool supports_async() const override { return false; }
+#endif
+
  private:
   Status AuthenticateInternal(ClientRpc& rpc) {
     std::shared_ptr<
@@ -894,6 +1064,10 @@ class GrpcClientImpl : public internal::ClientTransport {
       ::GRPC_NAMESPACE_FOR_TLS_CREDENTIALS_OPTIONS::TlsServerAuthorizationCheckConfig>
       noop_auth_check_;
 #endif
+
+#ifdef GRPC_ENABLE_ASYNC
+  std::shared_ptr<GrpcGarbageBin> garbage_bin_;
+#endif
 };
 std::once_flag kGrpcClientTransportInitialized;
 }  // namespace
@@ -907,6 +1081,8 @@ void InitializeFlightGrpcClient() {
   });
 }
 
+#undef LISTENER_NOT_OK
+
 }  // namespace grpc
 }  // namespace transport
 }  // namespace flight
diff --git a/cpp/src/arrow/flight/transport/grpc/util_internal.cc b/cpp/src/arrow/flight/transport/grpc/util_internal.cc
index f431fc30ec87a..88ec15bc66e08 100644
--- a/cpp/src/arrow/flight/transport/grpc/util_internal.cc
+++ b/cpp/src/arrow/flight/transport/grpc/util_internal.cc
@@ -20,6 +20,7 @@
 #include <cstdlib>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include <grpcpp/grpcpp.h>
@@ -28,6 +29,7 @@
 #include "arrow/flight/types.h"
 #include "arrow/status.h"
 #include "arrow/util/string.h"
+#include "arrow/util/string_builder.h"
 
 namespace arrow {
 
@@ -37,6 +39,8 @@ namespace flight {
 namespace transport {
 namespace grpc {
 
+using internal::TransportStatus;
+
 const char* kGrpcAuthHeader = "auth-token-bin";
 const char* kGrpcStatusCodeHeader = "x-arrow-status";
 const char* kGrpcStatusMessageHeader = "x-arrow-status-message-bin";
@@ -82,11 +86,106 @@ static bool FromGrpcContext(const ::grpc::ClientContext& ctx,
   return true;
 }
 
+static TransportStatus TransportStatusFromGrpc(const ::grpc::Status& grpc_status) {
+  switch (grpc_status.error_code()) {
+    case ::grpc::StatusCode::OK:
+      return TransportStatus{TransportStatusCode::kOk, ""};
+    case ::grpc::StatusCode::CANCELLED:
+      return TransportStatus{TransportStatusCode::kCancelled,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::UNKNOWN:
+      return TransportStatus{TransportStatusCode::kUnknown, grpc_status.error_message()};
+    case ::grpc::StatusCode::INVALID_ARGUMENT:
+      return TransportStatus{TransportStatusCode::kInvalidArgument,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::DEADLINE_EXCEEDED:
+      return TransportStatus{TransportStatusCode::kTimedOut, grpc_status.error_message()};
+    case ::grpc::StatusCode::NOT_FOUND:
+      return TransportStatus{TransportStatusCode::kNotFound, grpc_status.error_message()};
+    case ::grpc::StatusCode::ALREADY_EXISTS:
+      return TransportStatus{TransportStatusCode::kAlreadyExists,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::PERMISSION_DENIED:
+      return TransportStatus{TransportStatusCode::kUnauthorized,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::RESOURCE_EXHAUSTED:
+      return TransportStatus{TransportStatusCode::kUnavailable,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::FAILED_PRECONDITION:
+      return TransportStatus{TransportStatusCode::kUnavailable,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::ABORTED:
+      return TransportStatus{TransportStatusCode::kUnavailable,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::OUT_OF_RANGE:
+      return TransportStatus{TransportStatusCode::kInvalidArgument,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::UNIMPLEMENTED:
+      return TransportStatus{TransportStatusCode::kUnimplemented,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::INTERNAL:
+      return TransportStatus{TransportStatusCode::kInternal, grpc_status.error_message()};
+    case ::grpc::StatusCode::UNAVAILABLE:
+      return TransportStatus{TransportStatusCode::kUnavailable,
+                             grpc_status.error_message()};
+    case ::grpc::StatusCode::DATA_LOSS:
+      return TransportStatus{TransportStatusCode::kInternal, grpc_status.error_message()};
+    case ::grpc::StatusCode::UNAUTHENTICATED:
+      return TransportStatus{TransportStatusCode::kUnauthenticated,
+                             grpc_status.error_message()};
+    default:
+      return TransportStatus{TransportStatusCode::kUnknown,
+                             util::StringBuilder("(", grpc_status.error_code(), ")",
+                                                 grpc_status.error_message())};
+  }
+}
+
+Status CombinedTransportStatus(const ::grpc::Status& grpc_status,
+                               arrow::Status arrow_status, ::grpc::ClientContext* ctx) {
+  if (grpc_status.ok() && arrow_status.ok()) {
+    return Status::OK();
+  } else if (grpc_status.ok() && !arrow_status.ok()) {
+    return arrow_status;
+  }
+
+  // Can't share with FromGrpcCode because that function sometimes constructs an Arrow
+  // Status directly
+  const TransportStatus base_status = TransportStatusFromGrpc(grpc_status);
+
+  std::vector<std::pair<std::string, std::string>> details;
+  if (!grpc_status.ok() && ctx) {
+    // Attach rich error details
+    const std::multimap<::grpc::string_ref, ::grpc::string_ref>& trailers =
+        ctx->GetServerTrailingMetadata();
+
+    for (const auto key : {
+             // gRPC error details
+             kBinaryErrorDetailsKey,
+             // Sync C++ servers send information about the Arrow status
+             kGrpcStatusCodeHeader,
+             kGrpcStatusMessageHeader,
+             kGrpcStatusDetailHeader,
+         }) {
+      for (auto [it, end] = trailers.equal_range(key); it != end; it++) {
+        details.emplace_back(key, std::string(it->second.data(), it->second.size()));
+      }
+    }
+  }
+
+  if (arrow_status.ok()) {
+    arrow_status = base_status.ToStatus();
+  }
+
+  if (!details.empty()) {
+    return arrow_status.WithDetail(std::make_shared<TransportStatusDetail>(
+        base_status.code, std::move(base_status.message), std::move(details)));
+  }
+  return arrow_status;
+}
+
 /// Convert a gRPC status to an Arrow status, ignoring any
 /// implementation-defined headers that encode further detail.
 static Status FromGrpcCode(const ::grpc::Status& grpc_status) {
-  using internal::TransportStatus;
-  using internal::TransportStatusCode;
   switch (grpc_status.error_code()) {
     case ::grpc::StatusCode::OK:
       return Status::OK();
@@ -169,8 +268,6 @@ Status FromGrpcStatus(const ::grpc::Status& grpc_status, ::grpc::ClientContext*
 
 /// Convert an Arrow status to a gRPC status.
 static ::grpc::Status ToRawGrpcStatus(const Status& arrow_status) {
-  using internal::TransportStatus;
-  using internal::TransportStatusCode;
   if (arrow_status.ok()) return ::grpc::Status::OK;
 
   TransportStatus transport_status = TransportStatus::FromStatus(arrow_status);
@@ -215,7 +312,7 @@ static ::grpc::Status ToRawGrpcStatus(const Status& arrow_status) {
       grpc_code = ::grpc::StatusCode::UNKNOWN;
       break;
   }
-  return ::grpc::Status(grpc_code, std::move(transport_status.message));
+  return {grpc_code, std::move(transport_status.message)};
 }
 
 /// Convert an Arrow status to a gRPC status, and add extra headers to
diff --git a/cpp/src/arrow/flight/transport/grpc/util_internal.h b/cpp/src/arrow/flight/transport/grpc/util_internal.h
index a267e55654467..5687c7a872a4d 100644
--- a/cpp/src/arrow/flight/transport/grpc/util_internal.h
+++ b/cpp/src/arrow/flight/transport/grpc/util_internal.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include "arrow/flight/transport/grpc/protocol_grpc_internal.h"
+#include "arrow/flight/types.h"
 #include "arrow/flight/visibility.h"
 #include "arrow/util/macros.h"
 
@@ -71,6 +72,13 @@ extern const char* kGrpcStatusDetailHeader;
 ARROW_FLIGHT_EXPORT
 extern const char* kBinaryErrorDetailsKey;
 
+/// \brief Combine a gRPC status, possible client-side Arrow status,
+///   and a gRPC ClientContext into a transport status.
+ARROW_FLIGHT_EXPORT
+Status CombinedTransportStatus(const ::grpc::Status& grpc_status,
+                               arrow::Status arrow_status,
+                               ::grpc::ClientContext* ctx = nullptr);
+
 /// Convert a gRPC status to an Arrow status. Optionally, provide a
 /// ClientContext to recover the exact Arrow status if it was passed
 /// over the wire.
diff --git a/cpp/src/arrow/flight/type_fwd.h b/cpp/src/arrow/flight/type_fwd.h
index c82c4e6d8f533..ac2effbc91d96 100644
--- a/cpp/src/arrow/flight/type_fwd.h
+++ b/cpp/src/arrow/flight/type_fwd.h
@@ -24,6 +24,10 @@ class Uri;
 namespace flight {
 struct Action;
 struct ActionType;
+template <typename T>
+class AsyncListener;
+class AsyncListenerBase;
+class AsyncRpc;
 struct BasicAuth;
 class ClientAuthHandler;
 class ClientMiddleware;
@@ -51,6 +55,7 @@ class ServerMiddleware;
 class ServerMiddlewareFactory;
 struct Ticket;
 namespace internal {
+class AsyncRpc;
 class ClientTransport;
 struct FlightData;
 class ServerTransport;
diff --git a/cpp/src/arrow/flight/types.cc b/cpp/src/arrow/flight/types.cc
index 7c72595ed624b..b7cd55325b1f4 100644
--- a/cpp/src/arrow/flight/types.cc
+++ b/cpp/src/arrow/flight/types.cc
@@ -24,12 +24,16 @@
 
 #include "arrow/buffer.h"
 #include "arrow/flight/serialization_internal.h"
+#include "arrow/flight/types_async.h"
 #include "arrow/io/memory.h"
 #include "arrow/ipc/dictionary.h"
 #include "arrow/ipc/reader.h"
 #include "arrow/status.h"
 #include "arrow/table.h"
+#include "arrow/util/base64.h"
 #include "arrow/util/formatting.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/string.h"
 #include "arrow/util/string_builder.h"
 #include "arrow/util/uri.h"
 
@@ -299,9 +303,8 @@ arrow::Result<std::unique_ptr<FlightInfo>> FlightInfo::Deserialize(
   if (!pb_info.ParseFromZeroCopyStream(&input)) {
     return Status::Invalid("Not a valid FlightInfo");
   }
-  FlightInfo::Data data;
-  RETURN_NOT_OK(internal::FromProto(pb_info, &data));
-  return std::make_unique<FlightInfo>(std::move(data));
+  ARROW_ASSIGN_OR_RAISE(FlightInfo info, internal::FromProto(pb_info));
+  return std::make_unique<FlightInfo>(std::move(info));
 }
 
 std::string FlightInfo::ToString() const {
@@ -873,5 +876,88 @@ arrow::Result<std::string> BasicAuth::SerializeToString() const {
   return out;
 }
 
+//------------------------------------------------------------
+// Error propagation helpers
+
+std::string ToString(TransportStatusCode code) {
+  switch (code) {
+    case TransportStatusCode::kOk:
+      return "kOk";
+    case TransportStatusCode::kUnknown:
+      return "kUnknown";
+    case TransportStatusCode::kInternal:
+      return "kInternal";
+    case TransportStatusCode::kInvalidArgument:
+      return "kInvalidArgument";
+    case TransportStatusCode::kTimedOut:
+      return "kTimedOut";
+    case TransportStatusCode::kNotFound:
+      return "kNotFound";
+    case TransportStatusCode::kAlreadyExists:
+      return "kAlreadyExists";
+    case TransportStatusCode::kCancelled:
+      return "kCancelled";
+    case TransportStatusCode::kUnauthenticated:
+      return "kUnauthenticated";
+    case TransportStatusCode::kUnauthorized:
+      return "kUnauthorized";
+    case TransportStatusCode::kUnimplemented:
+      return "kUnimplemented";
+    case TransportStatusCode::kUnavailable:
+      return "kUnavailable";
+  }
+  return "(unknown code)";
+}
+
+std::string TransportStatusDetail::ToString() const {
+  std::string repr = "TransportStatusDetail{";
+  repr += arrow::flight::ToString(code());
+  repr += ", message=\"";
+  repr += message();
+  repr += "\", details={";
+
+  bool first = true;
+  for (const auto& [key, value] : details()) {
+    if (!first) {
+      repr += ", ";
+    }
+    first = false;
+
+    repr += "{\"";
+    repr += key;
+    repr += "\", ";
+    if (arrow::internal::EndsWith(key, "-bin")) {
+      repr += arrow::util::base64_encode(value);
+    } else {
+      repr += "\"";
+      repr += value;
+      repr += "\"";
+    }
+    repr += "}";
+  }
+
+  repr += "}}";
+  return repr;
+}
+
+std::optional<std::reference_wrapper<const TransportStatusDetail>>
+TransportStatusDetail::Unwrap(const Status& status) {
+  std::shared_ptr<StatusDetail> detail = status.detail();
+  if (!detail) return std::nullopt;
+  if (detail->type_id() != kTypeId) return std::nullopt;
+  return std::cref(arrow::internal::checked_cast<const TransportStatusDetail&>(*detail));
+}
+
+//------------------------------------------------------------
+// Async types
+
+AsyncListenerBase::AsyncListenerBase() = default;
+AsyncListenerBase::~AsyncListenerBase() = default;
+void AsyncListenerBase::TryCancel() {
+  if (rpc_state_) {
+    rpc_state_->TryCancel();
+  }
+}
+
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/types.h b/cpp/src/arrow/flight/types.h
index ca86c27e86976..c5d72d5167271 100644
--- a/cpp/src/arrow/flight/types.h
+++ b/cpp/src/arrow/flight/types.h
@@ -24,15 +24,18 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 
+#include "arrow/flight/type_fwd.h"
 #include "arrow/flight/visibility.h"
 #include "arrow/ipc/options.h"
 #include "arrow/ipc/writer.h"
 #include "arrow/result.h"
+#include "arrow/status.h"
 
 namespace arrow {
 
@@ -71,7 +74,8 @@ namespace flight {
 /// > is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
 using Timestamp = std::chrono::system_clock::time_point;
 
-/// \brief A Flight-specific status code.
+/// \brief A Flight-specific status code.  Used to encode some
+///   additional status codes into an Arrow Status.
 enum class FlightStatusCode : int8_t {
   /// An implementation error has occurred.
   Internal,
@@ -774,5 +778,81 @@ class ARROW_FLIGHT_EXPORT SimpleResultStream : public ResultStream {
   size_t position_;
 };
 
+/// \defgroup flight-error Error Handling
+/// Types for handling errors from RPCs.  Flight uses a set of status
+/// codes standardized across Flight implementations, so these types
+/// let applications work directly with those codes instead of having
+/// to translate to and from Arrow Status.
+/// @{
+
+/// \brief Abstract status code for an RPC as per the Flight
+///   specification.
+enum class TransportStatusCode {
+  /// \brief No error.
+  kOk = 0,
+  /// \brief An unknown error occurred.
+  kUnknown = 1,
+  /// \brief An error occurred in the transport implementation, or an
+  ///   error internal to the service implementation occurred.
+  kInternal = 2,
+  /// \brief An argument is invalid.
+  kInvalidArgument = 3,
+  /// \brief The request timed out.
+  kTimedOut = 4,
+  /// \brief An argument is not necessarily invalid, but references
+  ///   some resource that does not exist.  Prefer over
+  ///   kInvalidArgument where applicable.
+  kNotFound = 5,
+  /// \brief The request attempted to create some resource that does
+  ///   not exist.
+  kAlreadyExists = 6,
+  /// \brief The request was explicitly cancelled.
+  kCancelled = 7,
+  /// \brief The client is not authenticated.
+  kUnauthenticated = 8,
+  /// \brief The client is not authorized to perform this request.
+  kUnauthorized = 9,
+  /// \brief The request is not implemented
+  kUnimplemented = 10,
+  /// \brief There is a network connectivity error, or some resource
+  ///   is otherwise unavailable.  Most likely a temporary condition.
+  kUnavailable = 11,
+};
+
+/// \brief Convert a code to a string.
+std::string ToString(TransportStatusCode code);
+
+/// \brief An error from an RPC call, using Flight error codes directly
+///   instead of trying to translate to Arrow Status.
+///
+/// Currently, only attached to the Status passed to AsyncListener::OnFinish.
+///
+/// This API is EXPERIMENTAL.
+class ARROW_FLIGHT_EXPORT TransportStatusDetail : public StatusDetail {
+ public:
+  constexpr static const char* kTypeId = "flight::TransportStatusDetail";
+  explicit TransportStatusDetail(TransportStatusCode code, std::string message,
+                                 std::vector<std::pair<std::string, std::string>> details)
+      : code_(code), message_(std::move(message)), details_(std::move(details)) {}
+  const char* type_id() const override { return kTypeId; }
+  std::string ToString() const override;
+
+  static std::optional<std::reference_wrapper<const TransportStatusDetail>> Unwrap(
+      const Status& status);
+
+  TransportStatusCode code() const { return code_; }
+  std::string_view message() const { return message_; }
+  const std::vector<std::pair<std::string, std::string>>& details() const {
+    return details_;
+  }
+
+ private:
+  TransportStatusCode code_;
+  std::string message_;
+  std::vector<std::pair<std::string, std::string>> details_;
+};
+
+/// @}
+
 }  // namespace flight
 }  // namespace arrow
diff --git a/cpp/src/arrow/flight/types_async.h b/cpp/src/arrow/flight/types_async.h
new file mode 100644
index 0000000000000..a241e64fb4e49
--- /dev/null
+++ b/cpp/src/arrow/flight/types_async.h
@@ -0,0 +1,80 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+
+#include "arrow/flight/type_fwd.h"
+#include "arrow/flight/types.h"
+#include "arrow/ipc/options.h"
+#include "arrow/type_fwd.h"
+
+namespace arrow::flight {
+
+/// \defgroup flight-async Async Flight Types
+/// Common types used for asynchronous Flight APIs.
+/// @{
+
+/// \brief Non-templated state for an async RPC.
+///
+/// This API is EXPERIMENTAL.
+class ARROW_FLIGHT_EXPORT AsyncListenerBase {
+ public:
+  AsyncListenerBase();
+  virtual ~AsyncListenerBase();
+
+  /// \brief Request cancellation of the RPC.
+  ///
+  /// The RPC is not cancelled until AsyncListener::OnFinish is called.
+  void TryCancel();
+
+ private:
+  friend class arrow::flight::internal::ClientTransport;
+
+  /// Transport-specific state for this RPC.  Transport
+  /// implementations may store and retrieve state here via
+  /// ClientTransport::SetAsyncRpc and ClientTransport::GetAsyncRpc.
+  std::unique_ptr<internal::AsyncRpc> rpc_state_;
+};
+
+/// \brief Callbacks for results from async RPCs.
+///
+/// A single listener may not be used for multiple concurrent RPC
+/// calls.  The application MUST hold the listener alive until
+/// OnFinish() is called and has finished.
+///
+/// This API is EXPERIMENTAL.
+template <typename T>
+class ARROW_FLIGHT_EXPORT AsyncListener : public AsyncListenerBase {
+ public:
+  /// \brief Get the next server result.
+  ///
+  /// This will never be called concurrently with itself or OnFinish.
+  virtual void OnNext(T message) = 0;
+  /// \brief Get the final status.
+  ///
+  /// This will never be called concurrently with itself or OnNext.  If the
+  /// error comes from the remote server, then a TransportStatusDetail will be
+  /// attached.  Otherwise, the error is generated by the client-side
+  /// transport and will not have a TransportStatusDetail.
+  virtual void OnFinish(Status status) = 0;
+};
+
+/// @}
+
+}  // namespace arrow::flight

From 6e6e6f0340672ed49fb8e7cddf7bc47f2ca360dd Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Wed, 9 Aug 2023 23:11:15 +0800
Subject: [PATCH 127/749] GH-36931: [C++] Add cumulative_mean function (#36932)

### Rationale for this change

Add `cumulative_mean` function

### What changes are included in this PR?

Implement `cumulative_mean` function. The current cumulative_* kernel generator can only be based on a simple binary arithmetic op and the state can only be a single value. I refactored it to using of a generic state such that it can handle complex operations such as `mean`, `median`, `var` etc.

### Are these changes tested?

Yes

### Are there any user-facing changes?
No

* Closes: #36931

Lead-authored-by: Jin Shang <shangjin1997@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/compute/api_vector.cc           |   5 +
 cpp/src/arrow/compute/api_vector.h            |  11 +
 .../compute/kernels/vector_cumulative_ops.cc  | 195 +++++++++++++-----
 .../kernels/vector_cumulative_ops_test.cc     | 100 ++++++++-
 docs/source/cpp/compute.rst                   |  34 +--
 5 files changed, 268 insertions(+), 77 deletions(-)

diff --git a/cpp/src/arrow/compute/api_vector.cc b/cpp/src/arrow/compute/api_vector.cc
index f73b10e11edd7..d47ee42ebf239 100644
--- a/cpp/src/arrow/compute/api_vector.cc
+++ b/cpp/src/arrow/compute/api_vector.cc
@@ -417,5 +417,10 @@ Result<Datum> CumulativeMin(const Datum& values, const CumulativeOptions& option
   return CallFunction("cumulative_min", {Datum(values)}, &options, ctx);
 }
 
+Result<Datum> CumulativeMean(const Datum& values, const CumulativeOptions& options,
+                             ExecContext* ctx) {
+  return CallFunction("cumulative_mean", {Datum(values)}, &options, ctx);
+}
+
 }  // namespace compute
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/api_vector.h b/cpp/src/arrow/compute/api_vector.h
index 4f226ac00788a..0233090ef6fb9 100644
--- a/cpp/src/arrow/compute/api_vector.h
+++ b/cpp/src/arrow/compute/api_vector.h
@@ -226,6 +226,7 @@ class ARROW_EXPORT CumulativeOptions : public FunctionOptions {
   /// - prod: 1
   /// - min: maximum of the input type
   /// - max: minimum of the input type
+  /// - mean: start is ignored because it has no meaning for mean
   std::optional<std::shared_ptr<Scalar>> start;
 
   /// If true, nulls in the input are ignored and produce a corresponding null output.
@@ -661,6 +662,16 @@ Result<Datum> CumulativeMin(
     const Datum& values, const CumulativeOptions& options = CumulativeOptions::Defaults(),
     ExecContext* ctx = NULLPTR);
 
+/// \brief Compute the cumulative mean of an array-like object
+///
+/// \param[in] values array-like input
+/// \param[in] options configures cumulative mean behavior, `start` is ignored
+/// \param[in] ctx the function execution context, optional
+ARROW_EXPORT
+Result<Datum> CumulativeMean(
+    const Datum& values, const CumulativeOptions& options = CumulativeOptions::Defaults(),
+    ExecContext* ctx = NULLPTR);
+
 /// \brief Return the first order difference of an array.
 ///
 /// Computes the first order difference of an array, i.e.
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
index 82caa3bff59aa..86d2679486726 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops.cc
@@ -25,12 +25,11 @@
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/result.h"
+#include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/visit_type_inline.h"
 
-namespace arrow {
-namespace compute {
-namespace internal {
+namespace arrow::compute::internal {
 
 namespace {
 
@@ -63,19 +62,60 @@ struct CumulativeOptionsWrapper : public OptionsWrapper<OptionsType> {
   }
 };
 
-// The driver kernel for all cumulative compute functions. Op is a compute kernel
-// representing any binary associative operation with an identity element (add, product,
-// min, max, etc.), i.e. ones that form a monoid, and OptionsType the options type
-// corresponding to Op. ArgType and OutType are the input and output types, which will
+// The cumulative value is computed based on a simple arithmetic binary op
+// such as Add, Mul, Min, Max, etc.
+template <typename Op, typename ArgType>
+struct CumulativeBinaryOp {
+  using OutType = ArgType;
+  using OutValue = typename GetOutputType<OutType>::T;
+  using ArgValue = typename GetViewType<ArgType>::T;
+
+  OutValue current_value;
+
+  CumulativeBinaryOp() { current_value = Identity<Op>::template value<OutValue>; }
+
+  explicit CumulativeBinaryOp(const std::shared_ptr<Scalar> start) {
+    current_value = UnboxScalar<OutType>::Unbox(*start);
+  }
+
+  OutValue Call(KernelContext* ctx, ArgValue arg, Status* st) {
+    current_value =
+        Op::template Call<OutValue, ArgValue, ArgValue>(ctx, arg, current_value, st);
+    return current_value;
+  }
+};
+
+template <typename ArgType>
+struct CumulativeMean {
+  using OutType = DoubleType;
+  using ArgValue = typename GetViewType<ArgType>::T;
+  int64_t count = 0;
+  double sum = 0;
+
+  CumulativeMean() = default;
+
+  // start value is ignored for CumulativeMean
+  explicit CumulativeMean(const std::shared_ptr<Scalar> start) {}
+
+  double Call(KernelContext* ctx, ArgValue arg, Status* st) {
+    sum += static_cast<double>(arg);
+    ++count;
+    return sum / count;
+  }
+};
+
+// The driver kernel for all cumulative compute functions.
+// ArgType and OutType are the input and output types, which will
 // normally be the same (e.g. the cumulative sum of an array of Int64Type will result in
-// an array of Int64Type).
-template <typename OutType, typename ArgType, typename Op, typename OptionsType>
+// an array of Int64Type) with the exception of CumulativeMean, which will always return
+// a double.
+template <typename ArgType, typename CumulativeState>
 struct Accumulator {
-  using OutValue = typename GetOutputType<OutType>::T;
+  using OutType = typename CumulativeState::OutType;
   using ArgValue = typename GetViewType<ArgType>::T;
 
   KernelContext* ctx;
-  ArgValue current_value;
+  CumulativeState current_state;
   bool skip_nulls;
   bool encountered_null = false;
   NumericBuilder<OutType> builder;
@@ -88,11 +128,7 @@ struct Accumulator {
     if (skip_nulls || (input.GetNullCount() == 0 && !encountered_null)) {
       VisitArrayValuesInline<ArgType>(
           input,
-          [&](ArgValue v) {
-            current_value = Op::template Call<OutValue, ArgValue, ArgValue>(
-                ctx, v, current_value, &st);
-            builder.UnsafeAppend(current_value);
-          },
+          [&](ArgValue v) { builder.UnsafeAppend(current_state.Call(ctx, v, &st)); },
           [&]() { builder.UnsafeAppendNull(); });
     } else {
       int64_t nulls_start_idx = 0;
@@ -100,9 +136,7 @@ struct Accumulator {
           input,
           [&](ArgValue v) {
             if (!encountered_null) {
-              current_value = Op::template Call<OutValue, ArgValue, ArgValue>(
-                  ctx, v, current_value, &st);
-              builder.UnsafeAppend(current_value);
+              builder.UnsafeAppend(current_state.Call(ctx, v, &st));
               ++nulls_start_idx;
             }
           },
@@ -115,16 +149,17 @@ struct Accumulator {
   }
 };
 
-template <typename OutType, typename ArgType, typename Op, typename OptionsType>
+template <typename ArgType, typename CumulativeState, typename OptionsType>
 struct CumulativeKernel {
+  using OutType = typename CumulativeState::OutType;
   using OutValue = typename GetOutputType<OutType>::T;
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
-    Accumulator<OutType, ArgType, Op, OptionsType> accumulator(ctx);
+    Accumulator<ArgType, CumulativeState> accumulator(ctx);
     if (options.start.has_value()) {
-      accumulator.current_value = UnboxScalar<OutType>::Unbox(*(options.start.value()));
+      accumulator.current_state = CumulativeState(options.start.value());
     } else {
-      accumulator.current_value = Identity<Op>::template value<OutValue>;
+      accumulator.current_state = CumulativeState();
     }
     accumulator.skip_nulls = options.skip_nulls;
 
@@ -138,16 +173,17 @@ struct CumulativeKernel {
   }
 };
 
-template <typename OutType, typename ArgType, typename Op, typename OptionsType>
+template <typename ArgType, typename CumulativeState, typename OptionsType>
 struct CumulativeKernelChunked {
+  using OutType = typename CumulativeState::OutType;
   using OutValue = typename GetOutputType<OutType>::T;
   static Status Exec(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
     const auto& options = CumulativeOptionsWrapper<OptionsType>::Get(ctx);
-    Accumulator<OutType, ArgType, Op, OptionsType> accumulator(ctx);
+    Accumulator<ArgType, CumulativeState> accumulator(ctx);
     if (options.start.has_value()) {
-      accumulator.current_value = UnboxScalar<OutType>::Unbox(*(options.start.value()));
+      accumulator.current_state = CumulativeState(options.start.value());
     } else {
-      accumulator.current_value = Identity<Op>::template value<OutValue>;
+      accumulator.current_state = CumulativeState();
     }
     accumulator.skip_nulls = options.skip_nulls;
 
@@ -217,11 +253,52 @@ const FunctionDoc cumulative_min_doc{
      "start as the new minimum)."),
     {"values"},
     "CumulativeOptions"};
-}  // namespace
 
-template <typename Op, typename OptionsType>
-void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string func_name,
-                                  const FunctionDoc doc) {
+const FunctionDoc cumulative_mean_doc{
+    "Compute the cumulative mean over a numeric input",
+    ("`values` must be numeric. Return an array/chunked array which is the\n"
+     "cumulative mean computed over `values`. CumulativeOptions::start_value is \n"
+     "ignored."),
+    {"values"},
+    "CumulativeOptions"};
+
+// Kernel factory for complex stateful computations.
+template <template <typename ArgType> typename State, typename OptionsType>
+struct CumulativeStatefulKernelFactory {
+  VectorKernel kernel;
+
+  CumulativeStatefulKernelFactory() {
+    kernel.can_execute_chunkwise = false;
+    kernel.null_handling = NullHandling::type::COMPUTED_NO_PREALLOCATE;
+    kernel.mem_allocation = MemAllocation::type::NO_PREALLOCATE;
+    kernel.init = CumulativeOptionsWrapper<OptionsType>::Init;
+  }
+
+  template <typename Type>
+  enable_if_number<Type, Status> Visit(const Type& type) {
+    kernel.signature = KernelSignature::Make(
+        {type.GetSharedPtr()},
+        OutputType(TypeTraits<typename State<Type>::OutType>::type_singleton()));
+    kernel.exec = CumulativeKernel<Type, State<Type>, OptionsType>::Exec;
+    kernel.exec_chunked = CumulativeKernelChunked<Type, State<Type>, OptionsType>::Exec;
+    return arrow::Status::OK();
+  }
+
+  Status Visit(const DataType& type) {
+    return Status::NotImplemented("Cumulative kernel not implemented for type ",
+                                  type.ToString());
+  }
+
+  Result<VectorKernel> Make(const DataType& type) {
+    RETURN_NOT_OK(VisitTypeInline(type, this));
+    return kernel;
+  }
+};
+
+template <template <typename ArgType> typename State, typename OptionsType>
+void MakeVectorCumulativeStatefulFunction(FunctionRegistry* registry,
+                                          const std::string func_name,
+                                          const FunctionDoc doc) {
   static const OptionsType kDefaultOptions = OptionsType::Defaults();
   auto func =
       std::make_shared<VectorFunction>(func_name, Arity::Unary(), doc, &kDefaultOptions);
@@ -229,41 +306,49 @@ void MakeVectorCumulativeFunction(FunctionRegistry* registry, const std::string
   std::vector<std::shared_ptr<DataType>> types;
   types.insert(types.end(), NumericTypes().begin(), NumericTypes().end());
 
+  CumulativeStatefulKernelFactory<State, OptionsType> kernel_factory;
   for (const auto& ty : types) {
-    VectorKernel kernel;
-    kernel.can_execute_chunkwise = false;
-    kernel.null_handling = NullHandling::type::COMPUTED_NO_PREALLOCATE;
-    kernel.mem_allocation = MemAllocation::type::NO_PREALLOCATE;
-    kernel.signature = KernelSignature::Make({ty}, OutputType(ty));
-    kernel.exec =
-        ArithmeticExecFromOp<CumulativeKernel, Op, ArrayKernelExec, OptionsType>(ty);
-    kernel.exec_chunked =
-        ArithmeticExecFromOp<CumulativeKernelChunked, Op, VectorKernel::ChunkedExec,
-                             OptionsType>(ty);
-    kernel.init = CumulativeOptionsWrapper<OptionsType>::Init;
+    auto kernel = kernel_factory.Make(*ty).ValueOrDie();
     DCHECK_OK(func->AddKernel(std::move(kernel)));
   }
 
   DCHECK_OK(registry->AddFunction(std::move(func)));
 }
 
+// A kernel factory that forwards to CumulativeBinaryOp<Op, ...> for the given type.
+// Need to use a struct because template-using declarations cannot appear in
+// function scope.
+template <typename Op, typename OptionsType>
+struct MakeVectorCumulativeBinaryOpFunction {
+  template <typename ArgType>
+  using State = CumulativeBinaryOp<Op, ArgType>;
+
+  static void Call(FunctionRegistry* registry, std::string func_name, FunctionDoc doc) {
+    MakeVectorCumulativeStatefulFunction<State, OptionsType>(
+        registry, std::move(func_name), std::move(doc));
+  }
+};
+
+}  // namespace
+
 void RegisterVectorCumulativeSum(FunctionRegistry* registry) {
-  MakeVectorCumulativeFunction<Add, CumulativeOptions>(registry, "cumulative_sum",
-                                                       cumulative_sum_doc);
-  MakeVectorCumulativeFunction<AddChecked, CumulativeOptions>(
+  MakeVectorCumulativeBinaryOpFunction<Add, CumulativeOptions>::Call(
+      registry, "cumulative_sum", cumulative_sum_doc);
+  MakeVectorCumulativeBinaryOpFunction<AddChecked, CumulativeOptions>::Call(
       registry, "cumulative_sum_checked", cumulative_sum_checked_doc);
 
-  MakeVectorCumulativeFunction<Multiply, CumulativeOptions>(registry, "cumulative_prod",
-                                                            cumulative_prod_doc);
-  MakeVectorCumulativeFunction<MultiplyChecked, CumulativeOptions>(
+  MakeVectorCumulativeBinaryOpFunction<Multiply, CumulativeOptions>::Call(
+      registry, "cumulative_prod", cumulative_prod_doc);
+  MakeVectorCumulativeBinaryOpFunction<MultiplyChecked, CumulativeOptions>::Call(
       registry, "cumulative_prod_checked", cumulative_prod_checked_doc);
 
-  MakeVectorCumulativeFunction<Min, CumulativeOptions>(registry, "cumulative_min",
-                                                       cumulative_min_doc);
-  MakeVectorCumulativeFunction<Max, CumulativeOptions>(registry, "cumulative_max",
-                                                       cumulative_max_doc);
+  MakeVectorCumulativeBinaryOpFunction<Min, CumulativeOptions>::Call(
+      registry, "cumulative_min", cumulative_min_doc);
+  MakeVectorCumulativeBinaryOpFunction<Max, CumulativeOptions>::Call(
+      registry, "cumulative_max", cumulative_max_doc);
+
+  MakeVectorCumulativeStatefulFunction<CumulativeMean, CumulativeOptions>(
+      registry, "cumulative_mean", cumulative_max_doc);
 }
 
-}  // namespace internal
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
index 4ff46eb4acdfd..6760be26fc521 100644
--- a/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_cumulative_ops_test.cc
@@ -37,19 +37,23 @@
 namespace arrow {
 namespace compute {
 
-constexpr static std::array<const char*, 6> kCumulativeFunctionNames{
+static const std::vector<std::string> kCumulativeFunctionNames{
     "cumulative_sum",          "cumulative_sum_checked", "cumulative_prod",
-    "cumulative_prod_checked", "cumulative_min",         "cumulative_max"};
+    "cumulative_prod_checked", "cumulative_min",         "cumulative_max",
+    "cumulative_mean"};
 
 TEST(TestCumulative, Empty) {
   for (auto function : kCumulativeFunctionNames) {
     CumulativeOptions options;
     for (auto ty : NumericTypes()) {
+      auto return_ty = std::string(function) == "cumulative_mean" ? float64() : ty;
       auto empty_arr = ArrayFromJSON(ty, "[]");
+      auto expected_arr = ArrayFromJSON(return_ty, "[]");
       auto empty_chunked = ChunkedArrayFromJSON(ty, {"[]"});
-      CheckVectorUnary(function, empty_arr, empty_arr, &options);
+      auto expected_chunked = ChunkedArrayFromJSON(return_ty, {"[]"});
+      CheckVectorUnary(function, empty_arr, expected_arr, &options);
 
-      CheckVectorUnary(function, empty_chunked, empty_chunked, &options);
+      CheckVectorUnary(function, empty_chunked, expected_chunked, &options);
     }
   }
 }
@@ -58,14 +62,19 @@ TEST(TestCumulative, AllNulls) {
   for (auto function : kCumulativeFunctionNames) {
     CumulativeOptions options;
     for (auto ty : NumericTypes()) {
+      auto return_ty = std::string(function) == "cumulative_mean" ? float64() : ty;
       auto nulls_arr = ArrayFromJSON(ty, "[null, null, null]");
+      auto expected_arr = ArrayFromJSON(return_ty, "[null, null, null]");
       auto nulls_one_chunk = ChunkedArrayFromJSON(ty, {"[null, null, null]"});
+      auto expected_one_chunk = ChunkedArrayFromJSON(return_ty, {"[null, null, null]"});
       auto nulls_three_chunks = ChunkedArrayFromJSON(ty, {"[null]", "[null]", "[null]"});
-      CheckVectorUnary(function, nulls_arr, nulls_arr, &options);
+      auto expected_three_chunks =
+          ChunkedArrayFromJSON(return_ty, {"[null]", "[null]", "[null]"});
+      CheckVectorUnary(function, nulls_arr, expected_arr, &options);
 
-      CheckVectorUnary(function, nulls_one_chunk, nulls_one_chunk, &options);
+      CheckVectorUnary(function, nulls_one_chunk, expected_one_chunk, &options);
 
-      CheckVectorUnary(function, nulls_three_chunks, nulls_one_chunk, &options);
+      CheckVectorUnary(function, nulls_three_chunks, expected_one_chunk, &options);
     }
   }
 }
@@ -810,6 +819,72 @@ TEST(TestCumulativeMin, NoStartDoSkip) {
   }
 }
 
+TEST(TestCumulativeMean, NoSkip) {
+  CumulativeOptions options(false);
+  for (auto ty : NumericTypes()) {
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[5, 6, 4, 2, 3, 1]"),
+                     ArrayFromJSON(float64(), "[5, 5.5, 5, 4.25, 4, 3.5]"), &options);
+
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[5, 6, null, 2, null, 1]"),
+                     ArrayFromJSON(float64(), "[5, 5.5, null, null, null, null]"),
+                     &options);
+
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[null, 6, null, 2, null, 1]"),
+                     ArrayFromJSON(float64(), "[null, null, null, null, null, null]"),
+                     &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[5, 6, 4]", "[2, 3, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[5, 5.5, 5, 4.25, 4, 3.5]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[5, 6, null]", "[2, null, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[5, 5.5, null, null, null, null]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[null, 6, null]", "[2, null, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[null, null, null, null, null, null]"}),
+        &options);
+  }
+}
+
+TEST(TestCumulativeMean, DoSkip) {
+  CumulativeOptions options(true);
+  for (auto ty : NumericTypes()) {
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[5, 6, 4, 2, 3, 1]"),
+                     ArrayFromJSON(float64(), "[5, 5.5, 5, 4.25, 4, 3.5]"), &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ArrayFromJSON(ty, "[5, 6, null, 2, null, 1]"),
+        ArrayFromJSON(float64(), "[5, 5.5, null, 4.333333333333333, null, 3.5]"),
+        &options);
+
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[null, 6, null, 2, null, 1]"),
+                     ArrayFromJSON(float64(), "[null, 6, null, 4, null, 3]"), &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[5, 6, 4]", "[2, 3, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[5, 5.5, 5, 4.25, 4, 3.5]"}), &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[5, 6, null]", "[2, null, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[5, 5.5, null, 4.333333333333333, null, 3.5]"}),
+        &options);
+
+    CheckVectorUnary(
+        "cumulative_mean", ChunkedArrayFromJSON(ty, {"[null, 6, null]", "[2, null, 1]"}),
+        ChunkedArrayFromJSON(float64(), {"[null, 6, null, 4, null, 3]"}), &options);
+  }
+}
+
+TEST(TestCumulativeMean, StartValue) {
+  CumulativeOptions options(3, true);  // start should be ignored
+  for (auto ty : NumericTypes()) {
+    CheckVectorUnary("cumulative_mean", ArrayFromJSON(ty, "[5, 6, 4, 2, 3, 1]"),
+                     ArrayFromJSON(float64(), "[5, 5.5, 5, 4.25, 4, 3.5]"), &options);
+  }
+}
+
 TEST(TestCumulativeSum, ConvenienceFunctionCheckOverflow) {
   ASSERT_ARRAYS_EQUAL(*CumulativeSum(ArrayFromJSON(int8(), "[127, 1]"),
                                      CumulativeOptions::Defaults(), false)
@@ -846,6 +921,13 @@ TEST(TestCumulativeMin, ConvenienceFunction) {
       *ArrayFromJSON(int8(), "[-1, -2, -3]"));
 }
 
+TEST(TestCumulativeMean, ConvenienceFunction) {
+  ASSERT_ARRAYS_EQUAL(*CumulativeMean(ArrayFromJSON(int8(), "[-1, -2, -3]"),
+                                      CumulativeOptions::Defaults())
+                           ->make_array(),
+                      *ArrayFromJSON(float64(), "[-1, -1.5, -2]"));
+}
+
 TEST(TestCumulative, NaN) {
   // addition with NaN is always NaN
   CheckVectorUnary("cumulative_sum", ArrayFromJSON(float64(), "[1, 2, NaN, 4, 5]"),
@@ -862,6 +944,10 @@ TEST(TestCumulative, NaN) {
   // min with NaN is always ignored because Nan < a always returns false
   CheckVectorUnary("cumulative_min", ArrayFromJSON(float64(), "[5, 4, NaN, 2, 1]"),
                    ArrayFromJSON(float64(), "[5, 4, 4, 2, 1]"));
+
+  // mean with NaN is always Nan
+  CheckVectorUnary("cumulative_mean", ArrayFromJSON(float64(), "[5, 4, NaN, 2, 1]"),
+                   ArrayFromJSON(float64(), "[5, 4.5, NaN, NaN, NaN]"));
 }
 }  // namespace compute
 }  // namespace arrow
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 55e29588129b8..f8e371314631e 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1621,21 +1621,23 @@ do not detect overflow. They are alsoavailable in an overflow-checking variant,
 suffixed ``_checked``, which returns an ``Invalid`` :class:`Status` when 
 overflow is detected.
 
-+------------------------+-------+-------------+-------------+--------------------------------+-------+
-| Function name           | Arity | Input types | Output type | Options class                  | Notes |
-+=========================+=======+=============+=============+================================+=======+
-| cumulative_sum          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
-| cumulative_sum_checked  | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
-| cumulative_prod         | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
-| cumulative_prod_checked | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
-| cumulative_max          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
-| cumulative_min          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)  |
-+-------------------------+-------+-------------+-------------+--------------------------------+-------+
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| Function name           | Arity | Input types | Output type | Options class                  | Notes     |
++=========================+=======+=============+=============+================================+===========+
+| cumulative_sum          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_sum_checked  | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_prod         | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_prod_checked | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_max          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_min          | Unary | Numeric     | Numeric     | :struct:`CumulativeOptions`    | \(1)      |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
+| cumulative_mean         | Unary | Numeric     | Float64     | :struct:`CumulativeOptions`    | \(1) \(2) |
++-------------------------+-------+-------------+-------------+--------------------------------+-----------+
 
 * \(1) CumulativeOptions has two optional parameters. The first parameter
   :member:`CumulativeOptions::start` is a starting value for the running
@@ -1647,6 +1649,8 @@ overflow is detected.
   true, each null in the input produces a corresponding null in the output and
   doesn't affect the accumulation forward.
 
+* \(2) :member:`CumulativeOptions::start` is ignored.
+
 Associative transforms
 ~~~~~~~~~~~~~~~~~~~~~~
 

From 7c8f398f32ba5d2685093a010002f729a01a4242 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Wed, 9 Aug 2023 23:52:50 +0800
Subject: [PATCH 128/749] GH-35273: [C++] Add integer round kernels (#36289)

### Rationale for this change

Currently `round` casts integers to floats which causes undesired behavior.

### What changes are included in this PR?

Add round kernels for integer types.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #35273

Lead-authored-by: Jin Shang <shangjin1997@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../arrow/compute/kernels/codegen_internal.h  |   5 +
 cpp/src/arrow/compute/kernels/scalar_round.cc | 758 ++++++++++++------
 .../kernels/scalar_round_arithmetic_test.cc   | 344 +++++++-
 .../arrow/engine/substrait/function_test.cc   |   2 +-
 docs/source/cpp/compute.rst                   |  42 +-
 python/pyarrow/tests/test_compute.py          |   4 +-
 6 files changed, 872 insertions(+), 283 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.h b/cpp/src/arrow/compute/kernels/codegen_internal.h
index 3c6c0d63fbe38..72b29057b82e0 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.h
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.h
@@ -199,6 +199,11 @@ template <typename T>
 using is_signed_integer_value =
     std::integral_constant<bool, std::is_integral<T>::value && std::is_signed<T>::value>;
 
+template <typename T>
+using is_integer_value =
+    std::integral_constant<bool, is_signed_integer_value<T>::value ||
+                                     is_unsigned_integer_value<T>::value>;
+
 template <typename T, typename R = T>
 using enable_if_signed_integer_value = enable_if_t<is_signed_integer_value<T>::value, R>;
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_round.cc b/cpp/src/arrow/compute/kernels/scalar_round.cc
index fc2cb5b8a6ee1..5dc628f8d95c5 100644
--- a/cpp/src/arrow/compute/kernels/scalar_round.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_round.cc
@@ -25,7 +25,9 @@
 #include "arrow/compare.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/cast.h"
+#include "arrow/compute/kernel.h"
 #include "arrow/compute/kernels/base_arithmetic_internal.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
 #include "arrow/type.h"
@@ -34,6 +36,7 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/macros.h"
 #include "arrow/visit_scalar_inline.h"
+#include "arrow/visit_type_inline.h"
 
 namespace arrow {
 
@@ -43,8 +46,7 @@ using internal::MultiplyWithOverflow;
 using internal::NegateWithOverflow;
 using internal::SubtractWithOverflow;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 using applicator::ScalarBinary;
 using applicator::ScalarBinaryEqualTypes;
@@ -56,6 +58,9 @@ using applicator::ScalarUnaryNotNullStateful;
 
 namespace {
 
+// ----------------------------------------------------------------------
+// Begin utility structs for round kernels
+
 // Convenience visitor to detect if a numeric Scalar is positive.
 struct IsPositiveVisitor {
   bool result = false;
@@ -79,12 +84,9 @@ bool IsPositive(const Scalar& scalar) {
   return visitor.result;
 }
 
-// N.B. take care not to conflict with type_traits.h as that can cause surprises in a
-// unity build
-
 struct RoundUtil {
   // Calculate powers of ten with arbitrary integer exponent
-  template <typename T = double>
+  template <typename T>
   static enable_if_floating_value<T> Pow10(int64_t power) {
     static constexpr T lut[] = {1e0F, 1e1F, 1e2F,  1e3F,  1e4F,  1e5F,  1e6F,  1e7F,
                                 1e8F, 1e9F, 1e10F, 1e11F, 1e12F, 1e13F, 1e14F, 1e15F};
@@ -96,8 +98,44 @@ struct RoundUtil {
     }
     return (power >= 0) ? pow10 : (1 / pow10);
   }
+
+  // Calculate powers of ten with arbitrary integer exponent
+  template <typename T>
+  static enable_if_integer_value<T> Pow10(int64_t power) {
+    DCHECK_GE(power, 0);
+    DCHECK_LE(power, std::numeric_limits<T>::digits10);
+    static constexpr uint64_t lut[] = {
+        // clang-format off
+        1ULL,
+        10ULL,
+        100ULL,
+        1000ULL,
+        10000ULL,
+        100000ULL,
+        1000000ULL,
+        10000000ULL,
+        100000000ULL,
+        1000000000ULL,
+        10000000000ULL,
+        100000000000ULL,
+        1000000000000ULL,
+        10000000000000ULL,
+        100000000000000ULL,
+        1000000000000000ULL,
+        10000000000000000ULL,
+        100000000000000000ULL,
+        1000000000000000000ULL
+        // clang-format on
+    };
+
+    return static_cast<T>(lut[power]);
+  }
 };
 
+// End utility structs for round kernels
+// ----------------------------------------------------------------------
+// Begin round implementations for single scalar
+
 // Specializations of rounding implementations for round kernels
 template <typename Type, RoundMode>
 struct RoundImpl;
@@ -117,6 +155,21 @@ struct RoundImpl<Type, RoundMode::DOWN> {
       (*val) -= pow10;
     }
   }
+
+  template <typename T = Type>
+  static enable_if_integer_value<T> Round(const T val, const T floor, const T multiple,
+                                          Status* st) {
+    if constexpr (is_signed_integer_value<T>::value) {
+      if (ARROW_PREDICT_FALSE(val < 0 &&
+                              std::numeric_limits<T>::min() + multiple > floor)) {
+        *st = Status::Invalid("Rounding ", val, " down to multiple of ", multiple,
+                              " would overflow");
+        return val;
+      }
+      return val < 0 ? floor - multiple : floor;
+    }
+    return floor;
+  }
 };
 
 template <typename Type>
@@ -134,6 +187,18 @@ struct RoundImpl<Type, RoundMode::UP> {
       (*val) += pow10;
     }
   }
+
+  template <typename T = Type>
+  static enable_if_integer_value<T> Round(const T val, const T floor, const T multiple,
+                                          Status* st) {
+    if (ARROW_PREDICT_FALSE(val > 0 &&
+                            std::numeric_limits<T>::max() - multiple < floor)) {
+      *st = Status::Invalid("Rounding ", val, " up to multiple of ", multiple,
+                            " would overflow");
+      return val;
+    }
+    return val > 0 ? floor + multiple : floor;
+  }
 };
 
 template <typename Type>
@@ -148,6 +213,12 @@ struct RoundImpl<Type, RoundMode::TOWARDS_ZERO> {
                                                 const T& pow10, const int32_t scale) {
     (*val) -= remainder;
   }
+
+  template <typename T = Type>
+  static enable_if_integer_value<T> Round(const T val, const T floor, const T pow10,
+                                          Status* st) {
+    return floor;
+  }
 };
 
 template <typename Type>
@@ -167,6 +238,32 @@ struct RoundImpl<Type, RoundMode::TOWARDS_INFINITY> {
       (*val) += pow10;
     }
   }
+
+  template <typename T = Type>
+  static enable_if_integer_value<T> Round(const T val, const T floor, const T multiple,
+                                          Status* st) {
+    if constexpr (is_signed_integer_value<T>::value) {
+      if (ARROW_PREDICT_FALSE(val < 0 &&
+                              std::numeric_limits<T>::min() + multiple > floor)) {
+        *st = Status::Invalid("Rounding ", val, " down to multiple of ", multiple,
+                              " would overflow");
+        return val;
+      }
+    }
+
+    if (ARROW_PREDICT_FALSE(val > 0 &&
+                            std::numeric_limits<T>::max() - multiple < floor)) {
+      *st = Status::Invalid("Rounding ", val, " up to multiple of ", multiple,
+                            " would overflow");
+      return val;
+    }
+
+    if constexpr (is_signed_integer_value<T>::value) {
+      return val < 0 ? floor - multiple : floor + multiple;
+    }
+
+    return floor + multiple;
+  }
 };
 
 // NOTE: RoundImpl variants for the HALF_* rounding modes are only
@@ -185,6 +282,12 @@ struct RoundImpl<Type, RoundMode::HALF_DOWN> {
                                                 const T& pow10, const int32_t scale) {
     RoundImpl<T, RoundMode::DOWN>::Round(val, remainder, pow10, scale);
   }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    return RoundImpl<T, RoundMode::DOWN>::Round(val, floor, multiple, st);
+  }
 };
 
 template <typename Type>
@@ -199,6 +302,12 @@ struct RoundImpl<Type, RoundMode::HALF_UP> {
                                                 const T& pow10, const int32_t scale) {
     RoundImpl<T, RoundMode::UP>::Round(val, remainder, pow10, scale);
   }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    return RoundImpl<T, RoundMode::UP>::Round(val, floor, multiple, st);
+  }
 };
 
 template <typename Type>
@@ -213,6 +322,12 @@ struct RoundImpl<Type, RoundMode::HALF_TOWARDS_ZERO> {
                                                 const T& pow10, const int32_t scale) {
     RoundImpl<T, RoundMode::TOWARDS_ZERO>::Round(val, remainder, pow10, scale);
   }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    return RoundImpl<T, RoundMode::TOWARDS_ZERO>::Round(val, floor, multiple, st);
+  }
 };
 
 template <typename Type>
@@ -224,8 +339,14 @@ struct RoundImpl<Type, RoundMode::HALF_TOWARDS_INFINITY> {
 
   template <typename T = Type>
   static enable_if_decimal_value<T, void> Round(T* val, const T& remainder,
-                                                const T& pow10, const int32_t scale) {
-    RoundImpl<T, RoundMode::TOWARDS_INFINITY>::Round(val, remainder, pow10, scale);
+                                                const T& multiple, const int32_t scale) {
+    RoundImpl<T, RoundMode::TOWARDS_INFINITY>::Round(val, remainder, multiple, scale);
+  }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    return RoundImpl<T, RoundMode::TOWARDS_INFINITY>::Round(val, floor, multiple, st);
   }
 };
 
@@ -245,6 +366,15 @@ struct RoundImpl<Type, RoundMode::HALF_TO_EVEN> {
     }
     *val = scaled.IncreaseScaleBy(scale);
   }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    if ((floor / multiple) % 2 == 0) {
+      return floor;
+    }
+    return RoundImpl<T, RoundMode::TOWARDS_INFINITY>::Round(val, floor, multiple, st);
+  }
 };
 
 template <typename Type>
@@ -263,28 +393,49 @@ struct RoundImpl<Type, RoundMode::HALF_TO_ODD> {
     }
     *val = scaled.IncreaseScaleBy(scale);
   }
+
+  template <typename T = Type>
+  static constexpr enable_if_integer_value<T> Round(const T val, const T floor,
+                                                    const T multiple, Status* st) {
+    if ((floor / multiple) % 2 != 0) {
+      return floor;
+    }
+    return RoundImpl<T, RoundMode::TOWARDS_INFINITY>::Round(val, floor, multiple, st);
+  }
 };
 
+// End round implementations for single scalar
+// ----------------------------------------------------------------------
+// Begin round options wrappers
+
 // Specializations of kernel state for round kernels
-template <typename OptionsType>
+// CType is the physical type used to store pow10
+template <typename OptionsType, typename CType>
 struct RoundOptionsWrapper;
 
-template <>
-struct RoundOptionsWrapper<RoundOptions> : public OptionsWrapper<RoundOptions> {
+template <typename CType>
+struct RoundOptionsWrapper<RoundOptions, CType> : public OptionsWrapper<RoundOptions> {
   using OptionsType = RoundOptions;
-  double pow10;
+  CType pow10;
 
   explicit RoundOptionsWrapper(OptionsType options) : OptionsWrapper(std::move(options)) {
     // Only positive exponents for powers of 10 are used because combining
     // multiply and division operations produced more stable rounding than
     // using multiply-only.  Refer to NumPy's round implementation:
     // https://github.com/numpy/numpy/blob/7b2f20b406d27364c812f7a81a9c901afbd3600c/numpy/core/src/multiarray/calculation.c#L589
-    pow10 = RoundUtil::Pow10(std::abs(options.ndigits));
+    pow10 = RoundUtil::Pow10<CType>(std::abs(options.ndigits));
   }
 
   static Result<std::unique_ptr<KernelState>> Init(KernelContext* ctx,
                                                    const KernelInitArgs& args) {
     if (auto options = static_cast<const OptionsType*>(args.options)) {
+      if constexpr (is_integer_value<CType>::value) {
+        if (-options->ndigits > std::numeric_limits<CType>::digits10) {
+          return Status::Invalid("Rounding to ", options->ndigits,
+                                 " digits is out of range for type ",
+                                 args.inputs[0].ToString());
+        }
+      }
       return std::make_unique<RoundOptionsWrapper>(*options);
     }
     return Status::Invalid(
@@ -292,8 +443,8 @@ struct RoundOptionsWrapper<RoundOptions> : public OptionsWrapper<RoundOptions> {
   }
 };
 
-template <>
-struct RoundOptionsWrapper<RoundBinaryOptions>
+template <typename CType>
+struct RoundOptionsWrapper<RoundBinaryOptions, CType>
     : public OptionsWrapper<RoundBinaryOptions> {
   using OptionsType = RoundBinaryOptions;
 
@@ -310,8 +461,8 @@ struct RoundOptionsWrapper<RoundBinaryOptions>
   }
 };
 
-template <>
-struct RoundOptionsWrapper<RoundToMultipleOptions>
+template <typename CType>
+struct RoundOptionsWrapper<RoundToMultipleOptions, CType>
     : public OptionsWrapper<RoundToMultipleOptions> {
   using OptionsType = RoundToMultipleOptions;
   using OptionsWrapper::OptionsWrapper;
@@ -333,14 +484,8 @@ struct RoundOptionsWrapper<RoundToMultipleOptions>
       return Status::Invalid("Rounding multiple must be positive");
     }
 
-    // Ensure the rounding multiple option matches the kernel's output type.
-    // The output type is not available here so we use the following rule:
-    // If `multiple` is neither a floating-point nor a decimal type, then
-    // cast to float64, else cast to the kernel's input type.
-    std::shared_ptr<DataType> to_type =
-        (!is_floating(multiple->type->id()) && !is_decimal(multiple->type->id()))
-            ? float64()
-            : args.inputs[0].GetSharedPtr();
+    // Ensure the rounding multiple option matches the kernel's input type.
+    std::shared_ptr<DataType> to_type = args.inputs[0].GetSharedPtr();
     if (!multiple->type->Equals(to_type)) {
       ARROW_ASSIGN_OR_RAISE(
           auto casted_multiple,
@@ -355,11 +500,231 @@ struct RoundOptionsWrapper<RoundToMultipleOptions>
   }
 };
 
+template <typename ArrowType, typename Enable = void>
+struct RoundOptionsTrait;
+
+template <typename ArrowType>
+struct RoundOptionsTrait<ArrowType, enable_if_floating_point<ArrowType>> {
+  using CType = double;
+};
+
+template <typename ArrowType>
+struct RoundOptionsTrait<ArrowType, enable_if_decimal<ArrowType>> {
+  using CType = double;
+};
+
+template <typename ArrowType>
+struct RoundOptionsTrait<ArrowType, enable_if_integer<ArrowType>> {
+  using CType = typename ArrowType::c_type;
+};
+
+// End round options wrappers
+// ----------------------------------------------------------------------
+// Begin round op implementations
+
+template <typename ArrowType, RoundMode kRoundMode, typename Enable = void>
+struct RoundToMultiple {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using State = RoundOptionsWrapper<RoundToMultipleOptions,
+                                    typename RoundOptionsTrait<ArrowType>::CType>;
+
+  CType multiple;
+
+  explicit RoundToMultiple(const State& state, const DataType& out_ty)
+      : multiple(UnboxScalar<ArrowType>::Unbox(*state.options.multiple)) {
+    const auto& options = state.options;
+    DCHECK(options.multiple);
+    DCHECK(options.multiple->is_valid);
+    DCHECK(is_floating(options.multiple->type->id()));
+  }
+
+  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
+  enable_if_floating_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
+    // Do not process Inf or NaN because they will trigger the overflow error at end of
+    // function.
+    if (!std::isfinite(arg)) {
+      return arg;
+    }
+    auto round_val = arg / multiple;
+    auto frac = round_val - std::floor(round_val);
+    if (frac != T(0)) {
+      // Use std::round() if in tie-breaking mode and scaled value is not 0.5.
+      if ((kRoundMode >= RoundMode::HALF_DOWN) && (frac != T(0.5))) {
+        round_val = std::round(round_val);
+      } else {
+        round_val = RoundImpl<CType, kRoundMode>::Round(round_val);
+      }
+      round_val *= multiple;
+      if (!std::isfinite(round_val)) {
+        *st = Status::Invalid("overflow occurred during rounding");
+        return arg;
+      }
+    } else {
+      // If scaled value is an integer, then no rounding is needed.
+      round_val = arg;
+    }
+    return round_val;
+  }
+};
+
+template <typename ArrowType, RoundMode kRoundMode>
+struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using State = RoundOptionsWrapper<RoundToMultipleOptions, double>;
+  const ArrowType& ty;
+  CType multiple, half_multiple, neg_half_multiple;
+  bool has_halfway_point;
+
+  explicit RoundToMultiple(const State& state, const DataType& out_ty)
+      : ty(checked_cast<const ArrowType&>(out_ty)),
+        multiple(UnboxScalar<ArrowType>::Unbox(*state.options.multiple)),
+        half_multiple(multiple / 2),
+        neg_half_multiple(-half_multiple),
+        has_halfway_point(multiple.low_bits() % 2 == 0) {
+    const auto& options = state.options;
+    DCHECK(options.multiple);
+    DCHECK(options.multiple->is_valid);
+    DCHECK(options.multiple->type->Equals(out_ty));
+  }
+
+  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
+  enable_if_decimal_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
+    std::pair<CType, CType> pair;
+    *st = arg.Divide(multiple).Value(&pair);
+    if (!st->ok()) return arg;
+    const auto& remainder = pair.second;
+    if (remainder == 0) return arg;
+    if (kRoundMode >= RoundMode::HALF_DOWN) {
+      if (has_halfway_point &&
+          (remainder == half_multiple || remainder == neg_half_multiple)) {
+        // On the halfway point, use tiebreaker
+        // Manually implement rounding since we're not actually rounding a
+        // decimal value, but rather manipulating the multiple
+        switch (kRoundMode) {
+          case RoundMode::HALF_DOWN:
+            if (remainder.Sign() < 0) pair.first -= 1;
+            break;
+          case RoundMode::HALF_UP:
+            if (remainder.Sign() >= 0) pair.first += 1;
+            break;
+          case RoundMode::HALF_TOWARDS_ZERO:
+            // Do nothing
+            break;
+          case RoundMode::HALF_TOWARDS_INFINITY:
+            pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            break;
+          case RoundMode::HALF_TO_EVEN:
+            if (pair.first.low_bits() % 2 != 0) {
+              pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            }
+            break;
+          case RoundMode::HALF_TO_ODD:
+            if (pair.first.low_bits() % 2 == 0) {
+              pair.first += remainder.Sign() >= 0 ? 1 : -1;
+            }
+            break;
+          default:
+            DCHECK(false);
+        }
+      } else if (remainder.Sign() >= 0) {
+        // Positive, round up/down
+        if (remainder > half_multiple) {
+          pair.first += 1;
+        }
+      } else {
+        // Negative, round up/down
+        if (remainder < neg_half_multiple) {
+          pair.first -= 1;
+        }
+      }
+    } else {
+      // Manually implement rounding since we're not actually rounding a
+      // decimal value, but rather manipulating the multiple
+      switch (kRoundMode) {
+        case RoundMode::DOWN:
+          if (remainder.Sign() < 0) pair.first -= 1;
+          break;
+        case RoundMode::UP:
+          if (remainder.Sign() >= 0) pair.first += 1;
+          break;
+        case RoundMode::TOWARDS_ZERO:
+          // Do nothing
+          break;
+        case RoundMode::TOWARDS_INFINITY:
+          pair.first += remainder.Sign() >= 0 ? 1 : -1;
+          break;
+        default:
+          DCHECK(false);
+      }
+    }
+    CType round_val = pair.first * multiple;
+    if (!round_val.FitsInPrecision(ty.precision())) {
+      *st = Status::Invalid("Rounded value ", round_val.ToString(ty.scale()),
+                            " does not fit in precision of ", ty);
+      return 0;
+    }
+    return round_val;
+  }
+};
+
+template <typename ArrowType, RoundMode kRoundMode>
+struct RoundToMultiple<ArrowType, kRoundMode, enable_if_integer<ArrowType>> {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using State = RoundOptionsWrapper<RoundToMultipleOptions, CType>;
+  CType multiple;
+
+  explicit RoundToMultiple(const State& state, const DataType& out_ty)
+      : multiple(UnboxScalar<ArrowType>::Unbox(*state.options.multiple)) {
+    const auto& options = state.options;
+    DCHECK(options.multiple);
+    DCHECK(options.multiple->is_valid);
+    DCHECK(is_integer(options.multiple->type->id()));
+  }
+
+  explicit RoundToMultiple(const CType multiple, const DataType& out_ty)
+      : multiple(multiple) {}
+
+  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
+  enable_if_integer_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
+    CType floor = arg / multiple * multiple;
+    CType remainder = arg > floor ? arg - floor : floor - arg;
+
+    if (remainder == 0) {
+      return arg;
+    }
+
+    if (kRoundMode >= RoundMode::HALF_DOWN && remainder * 2 != multiple) {
+      // not half way, round to nearest multiple of multiple like std::round
+      if (remainder * 2 > multiple) {
+        if (arg >= 0) {
+          if (ARROW_PREDICT_FALSE(std::numeric_limits<CType>::max() - multiple < floor)) {
+            *st = Status::Invalid("Rounding ", arg, " up to multiples of ", multiple,
+                                  " would overflow");
+            return arg;
+          }
+          return floor + multiple;
+        } else {
+          if (ARROW_PREDICT_FALSE(std::numeric_limits<CType>::min() + multiple > floor)) {
+            *st = Status::Invalid("Rounding ", arg, " down to multiples of ", multiple,
+                                  " would overflow");
+            return arg;
+          }
+          return floor - multiple;
+        }
+      } else {
+        return floor;
+      }
+    } else {
+      return RoundImpl<CType, kRoundMode>::Round(arg, floor, multiple, st);
+    }
+  }
+};
+
 template <typename ArrowType, RoundMode RndMode, typename Enable = void>
 struct Round {
   using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundOptions>;
-
+  using State =
+      RoundOptionsWrapper<RoundOptions, typename RoundOptionsTrait<ArrowType>::CType>;
   CType pow10;
   int64_t ndigits;
 
@@ -400,8 +765,7 @@ struct Round {
 template <typename ArrowType, RoundMode kRoundMode>
 struct Round<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
   using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundOptions>;
-
+  using State = RoundOptionsWrapper<RoundOptions, double>;
   const ArrowType& ty;
   int64_t ndigits;
   int32_t pow;
@@ -470,10 +834,37 @@ struct Round<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
   }
 };
 
+template <typename ArrowType, RoundMode kRoundMode>
+struct Round<ArrowType, kRoundMode, enable_if_integer<ArrowType>> {
+  using CType = typename TypeTraits<ArrowType>::CType;
+  using State = RoundOptionsWrapper<RoundOptions, CType>;
+  CType pow10;
+  int64_t ndigits;
+  const DataType& out_ty;
+
+  explicit Round(const State& state, const DataType& out_ty)
+      : pow10(static_cast<CType>(state.pow10)),
+        ndigits(state.options.ndigits),
+        out_ty(out_ty) {}
+
+  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
+  enable_if_integer_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
+    // no-op if ndigits is non-negative
+    if (ndigits >= 0) {
+      return arg;
+    }
+
+    // If ndigits is negative, then round to the nearest multiple of 10^ndigits.
+    RoundToMultiple<ArrowType, kRoundMode> round_to_multiple(pow10, out_ty);
+    return round_to_multiple.Call(ctx, arg, st);
+  }
+};
+
 template <typename ArrowType, RoundMode RndMode, typename Enable = void>
 struct RoundBinary {
   using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundBinaryOptions>;
+  using State = RoundOptionsWrapper<RoundBinaryOptions,
+                                    typename RoundOptionsTrait<ArrowType>::CType>;
 
   explicit RoundBinary(const State& state, const DataType& out_ty) {}
 
@@ -491,7 +882,7 @@ struct RoundBinary {
     // multiply and division operations produced more stable rounding than
     // using multiply-only.  Refer to NumPy's round implementation:
     // https://github.com/numpy/numpy/blob/7b2f20b406d27364c812f7a81a9c901afbd3600c/numpy/core/src/multiarray/calculation.c#L589
-    double pow10 = RoundUtil::Pow10(std::abs(arg1));
+    double pow10 = RoundUtil::Pow10<double>(std::abs(arg1));
 
     auto round_val = arg1 >= 0 ? (arg0 * pow10) : (arg0 / pow10);
     auto frac = round_val - std::floor(round_val);
@@ -520,8 +911,7 @@ struct RoundBinary {
 template <typename ArrowType, RoundMode kRoundMode>
 struct RoundBinary<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
   using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundBinaryOptions>;
-
+  using State = RoundOptionsWrapper<RoundBinaryOptions, double>;
   const ArrowType& ty;
   int32_t pow;
   // pow10 is "1" for the given decimal scale. Similarly half_pow10 is "0.5".
@@ -591,156 +981,34 @@ struct RoundBinary<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
   }
 };
 
-template <typename DecimalType, RoundMode kMode, int32_t kDigits>
-Status FixedRoundDecimalExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-  using Op = Round<DecimalType, kMode>;
-  return ScalarUnaryNotNullStateful<DecimalType, DecimalType, Op>(
-             Op(kDigits, *out->type()))
-      .Exec(ctx, batch, out);
-}
-
-template <typename ArrowType, RoundMode kRoundMode, typename Enable = void>
-struct RoundToMultiple {
-  using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundToMultipleOptions>;
-
-  CType multiple;
-
-  explicit RoundToMultiple(const State& state, const DataType& out_ty)
-      : multiple(UnboxScalar<ArrowType>::Unbox(*state.options.multiple)) {
-    const auto& options = state.options;
-    DCHECK(options.multiple);
-    DCHECK(options.multiple->is_valid);
-    DCHECK(is_floating(options.multiple->type->id()));
-  }
-
-  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
-  enable_if_floating_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
-    // Do not process Inf or NaN because they will trigger the overflow error at end of
-    // function.
-    if (!std::isfinite(arg)) {
-      return arg;
-    }
-    auto round_val = arg / multiple;
-    auto frac = round_val - std::floor(round_val);
-    if (frac != T(0)) {
-      // Use std::round() if in tie-breaking mode and scaled value is not 0.5.
-      if ((kRoundMode >= RoundMode::HALF_DOWN) && (frac != T(0.5))) {
-        round_val = std::round(round_val);
-      } else {
-        round_val = RoundImpl<CType, kRoundMode>::Round(round_val);
-      }
-      round_val *= multiple;
-      if (!std::isfinite(round_val)) {
-        *st = Status::Invalid("overflow occurred during rounding");
-        return arg;
-      }
-    } else {
-      // If scaled value is an integer, then no rounding is needed.
-      round_val = arg;
-    }
-    return round_val;
-  }
-};
-
 template <typename ArrowType, RoundMode kRoundMode>
-struct RoundToMultiple<ArrowType, kRoundMode, enable_if_decimal<ArrowType>> {
+struct RoundBinary<ArrowType, kRoundMode, enable_if_integer<ArrowType>> {
   using CType = typename TypeTraits<ArrowType>::CType;
-  using State = RoundOptionsWrapper<RoundToMultipleOptions>;
+  using State = RoundOptionsWrapper<RoundBinaryOptions, CType>;
 
-  const ArrowType& ty;
-  CType multiple, half_multiple, neg_half_multiple;
-  bool has_halfway_point;
+  const DataType& out_ty;
+  explicit RoundBinary(const State& state, const DataType& out_ty) : out_ty(out_ty) {}
 
-  explicit RoundToMultiple(const State& state, const DataType& out_ty)
-      : ty(checked_cast<const ArrowType&>(out_ty)),
-        multiple(UnboxScalar<ArrowType>::Unbox(*state.options.multiple)),
-        half_multiple(multiple / 2),
-        neg_half_multiple(-half_multiple),
-        has_halfway_point(multiple.low_bits() % 2 == 0) {
-    const auto& options = state.options;
-    DCHECK(options.multiple);
-    DCHECK(options.multiple->is_valid);
-    DCHECK(options.multiple->type->Equals(out_ty));
-  }
-
-  template <typename T = ArrowType, typename CType = typename TypeTraits<T>::CType>
-  enable_if_decimal_value<CType> Call(KernelContext* ctx, CType arg, Status* st) const {
-    std::pair<CType, CType> pair;
-    *st = arg.Divide(multiple).Value(&pair);
-    if (!st->ok()) return arg;
-    const auto& remainder = pair.second;
-    if (remainder == 0) return arg;
-    if (kRoundMode >= RoundMode::HALF_DOWN) {
-      if (has_halfway_point &&
-          (remainder == half_multiple || remainder == neg_half_multiple)) {
-        // On the halfway point, use tiebreaker
-        // Manually implement rounding since we're not actually rounding a
-        // decimal value, but rather manipulating the multiple
-        switch (kRoundMode) {
-          case RoundMode::HALF_DOWN:
-            if (remainder.Sign() < 0) pair.first -= 1;
-            break;
-          case RoundMode::HALF_UP:
-            if (remainder.Sign() >= 0) pair.first += 1;
-            break;
-          case RoundMode::HALF_TOWARDS_ZERO:
-            // Do nothing
-            break;
-          case RoundMode::HALF_TOWARDS_INFINITY:
-            pair.first += remainder.Sign() >= 0 ? 1 : -1;
-            break;
-          case RoundMode::HALF_TO_EVEN:
-            if (pair.first.low_bits() % 2 != 0) {
-              pair.first += remainder.Sign() >= 0 ? 1 : -1;
-            }
-            break;
-          case RoundMode::HALF_TO_ODD:
-            if (pair.first.low_bits() % 2 == 0) {
-              pair.first += remainder.Sign() >= 0 ? 1 : -1;
-            }
-            break;
-          default:
-            DCHECK(false);
-        }
-      } else if (remainder.Sign() >= 0) {
-        // Positive, round up/down
-        if (remainder > half_multiple) {
-          pair.first += 1;
-        }
-      } else {
-        // Negative, round up/down
-        if (remainder < neg_half_multiple) {
-          pair.first -= 1;
-        }
-      }
-    } else {
-      // Manually implement rounding since we're not actually rounding a
-      // decimal value, but rather manipulating the multiple
-      switch (kRoundMode) {
-        case RoundMode::DOWN:
-          if (remainder.Sign() < 0) pair.first -= 1;
-          break;
-        case RoundMode::UP:
-          if (remainder.Sign() >= 0) pair.first += 1;
-          break;
-        case RoundMode::TOWARDS_ZERO:
-          // Do nothing
-          break;
-        case RoundMode::TOWARDS_INFINITY:
-          pair.first += remainder.Sign() >= 0 ? 1 : -1;
-          break;
-        default:
-          DCHECK(false);
-      }
+  template <typename T = ArrowType, typename CType0 = typename TypeTraits<T>::CType0,
+            typename CType1 = typename TypeTraits<T>::CType1>
+  enable_if_integer_value<CType> Call(KernelContext* ctx, CType0 arg0, CType1 arg1,
+                                      Status* st) const {
+    // ndigits >= 0 is a no-op
+    if (arg1 >= 0) {
+      return arg0;
     }
-    CType round_val = pair.first * multiple;
-    if (!round_val.FitsInPrecision(ty.precision())) {
-      *st = Status::Invalid("Rounded value ", round_val.ToString(ty.scale()),
-                            " does not fit in precision of ", ty);
-      return 0;
+
+    if (-arg1 > std::numeric_limits<CType>::digits10) {
+      // ndigits is larger than the number of digits CType can hold
+      *st = Status::Invalid("Rounding to ", arg1, " digits is out of range for type ",
+                            out_ty.ToString());
+      return arg0;
     }
-    return round_val;
+
+    // If ndigits is negative, then round to the nearest multiple of 10^ndigits.
+    CType pow10 = RoundUtil::Pow10<CType>(std::abs(arg1));
+    RoundToMultiple<ArrowType, kRoundMode> round_to_multiple(pow10, out_ty);
+    return round_to_multiple.Call(ctx, arg0, st);
   }
 };
 
@@ -748,7 +1016,7 @@ struct Floor {
   template <typename T, typename Arg>
   static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
                                                          Status*) {
-    static_assert(std::is_same<T, Arg>::value, "");
+    static_assert(std::is_same<T, Arg>::value);
     return RoundImpl<T, RoundMode::DOWN>::Round(arg);
   }
 };
@@ -757,7 +1025,7 @@ struct Ceil {
   template <typename T, typename Arg>
   static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
                                                          Status*) {
-    static_assert(std::is_same<T, Arg>::value, "");
+    static_assert(std::is_same<T, Arg>::value);
     return RoundImpl<T, RoundMode::UP>::Round(arg);
   }
 };
@@ -766,11 +1034,15 @@ struct Trunc {
   template <typename T, typename Arg>
   static constexpr enable_if_floating_value<Arg, T> Call(KernelContext*, Arg arg,
                                                          Status*) {
-    static_assert(std::is_same<T, Arg>::value, "");
+    static_assert(std::is_same<T, Arg>::value);
     return RoundImpl<T, RoundMode::TOWARDS_ZERO>::Round(arg);
   }
 };
 
+// End round op implementations
+// ----------------------------------------------------------------------
+// Begin round functions
+
 struct RoundFunction : ScalarFunction {
   using ScalarFunction::ScalarFunction;
 
@@ -782,6 +1054,10 @@ struct RoundFunction : ScalarFunction {
 
     EnsureDictionaryDecoded(types);
 
+    // for binary round functions, the second scalar must be int32
+    if (types->size() == 2 && (*types)[1].id() != Type::INT32) {
+      (*types)[1] = int32();
+    }
     if (auto kernel = DispatchExactImpl(this, *types)) return kernel;
     return arrow::compute::detail::NoMatchingKernel(this, *types);
   }
@@ -862,6 +1138,10 @@ struct RoundFloatingPointFunction : public RoundFunction {
   }
 };
 
+// End round functions
+// ----------------------------------------------------------------------
+// Begin round kernels
+
 #define ROUND_CASE(MODE)                                                       \
   case RoundMode::MODE: {                                                      \
     using Op = OpImpl<Type, RoundMode::MODE>;                                  \
@@ -874,7 +1154,8 @@ template <typename Type, typename OptionsType,
           template <typename, RoundMode, typename...> class OpImpl>
 struct RoundKernel {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-    using State = RoundOptionsWrapper<OptionsType>;
+    using State =
+        RoundOptionsWrapper<OptionsType, typename RoundOptionsTrait<Type>::CType>;
     const auto& state = static_cast<const State&>(*ctx->state());
     switch (state.options.round_mode) {
       ROUND_CASE(DOWN)
@@ -909,7 +1190,8 @@ template <typename Type, typename OptionsType,
           template <typename, RoundMode, typename...> class OpImpl>
 struct RoundBinaryKernel {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-    using State = RoundOptionsWrapper<OptionsType>;
+    using State =
+        RoundOptionsWrapper<OptionsType, typename RoundOptionsTrait<Type>::CType>;
     const auto& state = static_cast<const State&>(*ctx->state());
     switch (state.options.round_mode) {
       ROUND_BINARY_CASE(DOWN)
@@ -931,38 +1213,59 @@ struct RoundBinaryKernel {
 };
 #undef ROUND_BINARY_CASE
 
+template <typename DecimalType, RoundMode kMode, int32_t kDigits>
+Status FixedRoundDecimalExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  using Op = Round<DecimalType, kMode>;
+  return ScalarUnaryNotNullStateful<DecimalType, DecimalType, Op>(
+             Op(kDigits, *out->type()))
+      .Exec(ctx, batch, out);
+}
+
+// End round kernels
+// ----------------------------------------------------------------------
+// Begin round kernel generation and function registration
+
+template <
+    template <typename, RoundMode, typename...> class Op,
+    template <typename, typename, template <typename, RoundMode, typename...> typename>
+    class Kernel,
+    typename OptionsType>
+struct RoundKernelGenerator {
+  template <typename ArrowType>
+  Status Visit(const ArrowType& type, ArrayKernelExec* exec, KernelInit* init) {
+    if constexpr (is_integer_type<ArrowType>::value ||
+                  (is_floating_type<ArrowType>::value &&
+                   !is_half_float_type<ArrowType>::value) ||
+                  is_decimal_type<ArrowType>::value) {
+      *exec = Kernel<ArrowType, OptionsType, Op>::Exec;
+      *init = RoundOptionsWrapper<OptionsType,
+                                  typename RoundOptionsTrait<ArrowType>::CType>::Init;
+    } else {
+      DCHECK(false);
+      return Status::NotImplemented("Round does not support ", type.ToString());
+    }
+    return Status::OK();
+  }
+};
+
 // For unary rounding functions that control kernel dispatch based on RoundMode, only on
 // non-null output.
 template <template <typename, RoundMode, typename...> class Op, typename OptionsType>
 std::shared_ptr<ScalarFunction> MakeUnaryRoundFunction(std::string name,
                                                        FunctionDoc doc) {
-  using State = RoundOptionsWrapper<OptionsType>;
   static const OptionsType kDefaultOptions = OptionsType::Defaults();
-  auto func = std::make_shared<RoundIntegerToFloatingPointFunction>(
-      name, Arity::Unary(), std::move(doc), &kDefaultOptions);
-  for (const auto& ty : {float32(), float64(), decimal128(1, 0), decimal256(1, 0)}) {
-    auto type_id = ty->id();
-    ArrayKernelExec exec = nullptr;
-    switch (type_id) {
-      case Type::FLOAT:
-        exec = RoundKernel<FloatType, OptionsType, Op>::Exec;
-        break;
-      case Type::DOUBLE:
-        exec = RoundKernel<DoubleType, OptionsType, Op>::Exec;
-        break;
-      case Type::DECIMAL128:
-        exec = RoundKernel<Decimal128Type, OptionsType, Op>::Exec;
-        break;
-      case Type::DECIMAL256:
-        exec = RoundKernel<Decimal256Type, OptionsType, Op>::Exec;
-        break;
-      default:
-        DCHECK(false);
-        break;
+  auto func = std::make_shared<RoundFunction>(name, Arity::Unary(), std::move(doc),
+                                              &kDefaultOptions);
+  RoundKernelGenerator<Op, RoundKernel, OptionsType> kernel_generator;
+  for (const auto& tys : {NumericTypes(), {decimal128(1, 0), decimal256(1, 0)}}) {
+    for (const auto& ty : tys) {
+      ArrayKernelExec exec;
+      KernelInit init;
+      DCHECK_OK(VisitTypeInline(*ty, &kernel_generator, &exec, &init));
+      DCHECK_OK(func->AddKernel(
+          {InputType(ty->id())},
+          is_decimal(ty->id()) ? OutputType(FirstType) : OutputType(ty), exec, init));
     }
-    DCHECK_OK(func->AddKernel(
-        {InputType(type_id)},
-        is_decimal(type_id) ? OutputType(FirstType) : OutputType(ty), exec, State::Init));
   }
   AddNullExec(func.get());
   return func;
@@ -971,33 +1274,19 @@ std::shared_ptr<ScalarFunction> MakeUnaryRoundFunction(std::string name,
 template <template <typename, RoundMode, typename...> class Op, typename OptionsType>
 std::shared_ptr<ScalarFunction> MakeBinaryRoundFunction(const std::string& name,
                                                         FunctionDoc doc) {
-  using State = RoundOptionsWrapper<OptionsType>;
   static const OptionsType kDefaultOptions = OptionsType::Defaults();
-  auto func = std::make_shared<RoundIntegerToFloatingPointFunction>(
-      name, Arity::Binary(), std::move(doc), &kDefaultOptions);
-  for (const auto& ty : {float32(), float64(), decimal128(1, 0), decimal256(1, 0)}) {
-    auto type_id = ty->id();
-    ArrayKernelExec exec = nullptr;
-    switch (type_id) {
-      case Type::FLOAT:
-        exec = RoundBinaryKernel<FloatType, OptionsType, Op>::Exec;
-        break;
-      case Type::DOUBLE:
-        exec = RoundBinaryKernel<DoubleType, OptionsType, Op>::Exec;
-        break;
-      case Type::DECIMAL128:
-        exec = RoundBinaryKernel<Decimal128Type, OptionsType, Op>::Exec;
-        break;
-      case Type::DECIMAL256:
-        exec = RoundBinaryKernel<Decimal256Type, OptionsType, Op>::Exec;
-        break;
-      default:
-        DCHECK(false);
-        break;
+  auto func = std::make_shared<RoundFunction>(name, Arity::Binary(), std::move(doc),
+                                              &kDefaultOptions);
+  RoundKernelGenerator<Op, RoundBinaryKernel, OptionsType> kernel_generator;
+  for (const auto& tys : {NumericTypes(), {decimal128(1, 0), decimal256(1, 0)}}) {
+    for (const auto& ty : tys) {
+      ArrayKernelExec exec;
+      KernelInit init;
+      DCHECK_OK(VisitTypeInline(*ty, &kernel_generator, &exec, &init));
+      DCHECK_OK(func->AddKernel(
+          {InputType(ty->id()), Type::INT32},
+          is_decimal(ty->id()) ? OutputType(FirstType) : OutputType(ty), exec, init));
     }
-    DCHECK_OK(func->AddKernel(
-        {ty, Type::INT32}, is_decimal(type_id) ? OutputType(FirstType) : OutputType(ty),
-        exec, State::Init));
   }
   AddNullExec(func.get());
   return func;
@@ -1101,6 +1390,7 @@ void RegisterScalarRoundArithmetic(FunctionRegistry* registry) {
   DCHECK_OK(registry->AddFunction(std::move(round_to_multiple)));
 }
 
-}  // namespace internal
-}  // namespace compute
+// End round kernel generation and function registration
+// ----------------------------------------------------------------------
+}  // namespace compute::internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc b/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
index 6f11421610a34..3d205b0451dc2 100644
--- a/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_round_arithmetic_test.cc
@@ -34,8 +34,7 @@
 
 #include "arrow/testing/gtest_util.h"
 
-namespace arrow {
-namespace compute {
+namespace arrow::compute {
 
 namespace {
 
@@ -481,13 +480,31 @@ TYPED_TEST_SUITE(TestUnaryRoundArithmeticFloating, FloatingTypes);
 
 TEST(TestUnaryRound, DispatchBestRound) {
   // Integer -> Float64
-  for (std::string name : {"floor", "ceil", "trunc", "round", "round_to_multiple"}) {
+  for (std::string name : {"floor", "ceil", "trunc"}) {
     for (const auto& ty :
          {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(), uint64()}) {
       CheckDispatchBest(name, {ty}, {float64()});
       CheckDispatchBest(name, {dictionary(int8(), ty)}, {float64()});
     }
   }
+  // Integer -> Integer
+  for (std::string name : {"round", "round_to_multiple"}) {
+    for (const auto& ty :
+         {int8(), int16(), int32(), int64(), uint8(), uint16(), uint32(), uint64()}) {
+      CheckDispatchBest(name, {ty}, {ty});
+      CheckDispatchBest(name, {dictionary(int8(), ty)}, {ty});
+    }
+  }
+
+  // Any -> Int32
+  for (std::string name : {"round_binary"}) {
+    for (const auto& ty1 : NumericTypes()) {
+      for (const auto& ty2 : NumericTypes()) {
+        CheckDispatchBest(name, {ty1, ty2}, {ty1, int32()});
+        CheckDispatchBest(name, {dictionary(int8(), ty1), ty2}, {ty1, int32()});
+      }
+    }
+  }
 }
 
 class TestUnaryRoundArithmeticDecimal : public TestRoundArithmeticDecimal {};
@@ -1014,13 +1031,13 @@ TYPED_TEST(TestUnaryRoundSigned, Round) {
   this->SetRoundNdigits(0);
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertUnaryOp(Round, values, ArrayFromJSON(float64(), values));
+    this->AssertUnaryOp(Round, values, ArrayFromJSON(this->type_singleton(), values));
   }
 
   // Test different round N-digits for nearest rounding mode
   std::vector<std::pair<int64_t, std::string>> ndigits_and_expected{{
-      {-2, "[0.0, 0.0, -0.0, -100, 100]"},
-      {-1, "[0.0, 0.0, -10, -50, 120]"},
+      {-2, "[0, 0, -0, -100, 100]"},
+      {-1, "[0, 0, -10, -50, 120]"},
       {0, values},
       {1, values},
       {2, values},
@@ -1028,7 +1045,53 @@ TYPED_TEST(TestUnaryRoundSigned, Round) {
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : ndigits_and_expected) {
     this->SetRoundNdigits(pair.first);
-    this->AssertUnaryOp(Round, values, ArrayFromJSON(float64(), pair.second));
+    this->AssertUnaryOp(Round, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  // skip int8 because of its small range
+  if constexpr (!std::is_same_v<TypeParam, Int8Type>) {
+    std::string values("[0, 1, -13, -50, 115, -150, -176, 200, 250]");
+    this->SetRoundNdigits(-2);
+    std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+        {RoundMode::DOWN, "[0, 0, -100, -100, 100, -200, -200, 200, 200]"},
+        {RoundMode::UP, "[0, 100, -0, -0, 200, -100, -100, 200, 300]"},
+        {RoundMode::TOWARDS_ZERO, "[0, 0, -0, -0, 100, -100, -100, 200, 200]"},
+        {RoundMode::TOWARDS_INFINITY, "[0, 100, -100, -100, 200, -200, -200, 200, 300]"},
+        {RoundMode::HALF_DOWN, "[0, 0, -0, -100, 100, -200, -200, 200, 200]"},
+        {RoundMode::HALF_UP, "[0, 0, -0, -0, 100, -100, -200, 200, 300]"},
+        {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, -0, -0, 100, -100, -200, 200, 200]"},
+        {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, -0, -100, 100, -200, -200, 200, 300]"},
+        {RoundMode::HALF_TO_EVEN, "[0, 0, -0, -0, 100, -200, -200, 200, 200]"},
+        {RoundMode::HALF_TO_ODD, "[0, 0, -0, -100, 100, -100, -200, 200, 300]"},
+    }};
+    for (const auto& pair : round_modes_and_expected) {
+      this->SetRoundMode(pair.first);
+      this->AssertUnaryOp(Round, values,
+                          ArrayFromJSON(this->type_singleton(), pair.second));
+    }
+  }
+
+  // An overly large ndigits would cause an error
+  this->SetRoundNdigits(-100);
+  this->SetRoundMode(RoundMode::UP);
+  this->AssertUnaryOpRaises(Round, "[1]", "out of range");
+
+  // Overflow is also treated as error
+  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+    this->SetRoundNdigits(-1);
+    this->SetRoundMode(RoundMode::DOWN);
+    this->AssertUnaryOpRaises(Round, "[-127]", "overflow");
+  }
+
+  // A larger than double int64 should be correctly handled
+  if constexpr (std::is_same_v<TypeParam, Int64Type>) {
+    this->SetRoundNdigits(-2);
+    this->SetRoundMode(RoundMode::UP);
+    auto values = "[1152921504606846976]";  // 2 ^ 60
+    this->AssertUnaryOp(Round, values,
+                        ArrayFromJSON(this->type_singleton(), "[1152921504606847000]"));
   }
 }
 
@@ -1038,7 +1101,7 @@ TYPED_TEST(TestUnaryRoundUnsigned, Round) {
   this->SetRoundNdigits(0);
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertUnaryOp(Round, values, ArrayFromJSON(float64(), values));
+    this->AssertUnaryOp(Round, values, ArrayFromJSON(this->type_singleton(), values));
   }
 
   // Test different round N-digits for nearest rounding mode
@@ -1052,7 +1115,53 @@ TYPED_TEST(TestUnaryRoundUnsigned, Round) {
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : ndigits_and_expected) {
     this->SetRoundNdigits(pair.first);
-    this->AssertUnaryOp(Round, values, ArrayFromJSON(float64(), pair.second));
+    this->AssertUnaryOp(Round, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  // skip uint8 because of its small range
+  if constexpr (!std::is_same_v<TypeParam, UInt8Type>) {
+    std::string values("[0, 1, 13, 50, 115, 150, 176, 200, 250]");
+    this->SetRoundNdigits(-2);
+    std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+        {RoundMode::DOWN, "[0, 0, 0, 0, 100, 100, 100, 200, 200]"},
+        {RoundMode::UP, "[0, 100, 100, 100, 200, 200, 200, 200, 300]"},
+        {RoundMode::TOWARDS_ZERO, "[0, 0, 0, 0, 100, 100, 100, 200, 200]"},
+        {RoundMode::TOWARDS_INFINITY, "[0, 100, 100, 100, 200, 200, 200, 200, 300]"},
+        {RoundMode::HALF_DOWN, "[0, 0, 0, 0, 100, 100, 200, 200, 200]"},
+        {RoundMode::HALF_UP, "[0, 0, 0, 100, 100, 200, 200, 200, 300]"},
+        {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, 0, 0, 100, 100, 200, 200, 200]"},
+        {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, 0, 100, 100, 200, 200, 200, 300]"},
+        {RoundMode::HALF_TO_EVEN, "[0, 0, 0, 0, 100, 200, 200, 200, 200]"},
+        {RoundMode::HALF_TO_ODD, "[0, 0, 0, 100, 100, 100, 200, 200, 300]"},
+    }};
+    for (const auto& pair : round_modes_and_expected) {
+      this->SetRoundMode(pair.first);
+      this->AssertUnaryOp(Round, values,
+                          ArrayFromJSON(this->type_singleton(), pair.second));
+    }
+  }
+
+  // An overly large ndigits would cause an error
+  this->SetRoundNdigits(-100);
+  this->SetRoundMode(RoundMode::UP);
+  this->AssertUnaryOpRaises(Round, "[1]", "out of range");
+
+  // Overflow is also treated as error
+  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+    this->SetRoundNdigits(-1);
+    this->SetRoundMode(RoundMode::UP);
+    this->AssertUnaryOpRaises(Round, "[255]", "overflow");
+  }
+
+  // A larger than double uint64 should be correctly handled
+  if constexpr (std::is_same_v<TypeParam, Int64Type>) {
+    this->SetRoundNdigits(-2);
+    this->SetRoundMode(RoundMode::UP);
+    auto values = "[1152921504606846976]";  // 2 ^ 60
+    this->AssertUnaryOp(Round, values,
+                        ArrayFromJSON(this->type_singleton(), "[1152921504606847000]"));
   }
 }
 
@@ -1108,13 +1217,14 @@ TYPED_TEST(TestBinaryRoundSigned, Round) {
   std::string values("[0, 1, -13, -50, 115]");
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertBinaryOp(RoundBinary, values, 0, ArrayFromJSON(float64(), values));
+    this->AssertBinaryOp(RoundBinary, values, 0,
+                         ArrayFromJSON(this->type_singleton(), values));
   }
 
   // Test different round N-digits for nearest rounding mode
   std::vector<std::pair<int32_t, std::string>> ndigits_and_expected{{
-      {-2, "[0.0, 0.0, -0.0, -100, 100]"},
-      {-1, "[0.0, 0.0, -10, -50, 120]"},
+      {-2, "[0, 0, -0, -100, 100]"},
+      {-1, "[0, 0, -10, -50, 120]"},
       {0, values},
       {1, values},
       {2, values},
@@ -1122,7 +1232,42 @@ TYPED_TEST(TestBinaryRoundSigned, Round) {
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : ndigits_and_expected) {
     this->AssertBinaryOp(RoundBinary, values, pair.first,
-                         ArrayFromJSON(float64(), pair.second));
+                         ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  // skip int8 because of its small range
+  if constexpr (!std::is_same<TypeParam, Int8Type>::value) {
+    std::string values("[0, 1, -13, -50, 115, -176, 200, 250]");
+    std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+        {RoundMode::DOWN, "[0, 0, -100, -100, 100, -200, 200, 200]"},
+        {RoundMode::UP, "[0, 100, -0, -0, 200, -100, 200, 300]"},
+        {RoundMode::TOWARDS_ZERO, "[0, 0, -0, -0, 100, -100, 200, 200]"},
+        {RoundMode::TOWARDS_INFINITY, "[0, 100, -100, -100, 200, -200, 200, 300]"},
+        {RoundMode::HALF_DOWN, "[0, 0, -0, -100, 100, -200, 200, 200]"},
+        {RoundMode::HALF_UP, "[0, 0, -0, -0, 100, -200, 200, 300]"},
+        {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, -0, -0, 100, -200, 200, 200]"},
+        {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, -0, -100, 100, -200, 200, 300]"},
+        {RoundMode::HALF_TO_EVEN, "[0, 0, -0, -0, 100, -200, 200, 200]"},
+        {RoundMode::HALF_TO_ODD, "[0, 0, -0, -100, 100, -200, 200, 300]"},
+    }};
+    for (const auto& pair : round_modes_and_expected) {
+      this->SetRoundMode(pair.first);
+      this->AssertBinaryOp(RoundBinary, values, -2,
+                           ArrayFromJSON(this->type_singleton(), pair.second));
+    }
+  }
+
+  // An overly large ndigits would cause an error
+  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+    this->SetRoundMode(RoundMode::UP);
+    this->AssertBinaryOpRaises(RoundBinary, "[1]", "[-100]", "out of range");
+  }
+
+  // Overflow is also treated as error
+  if constexpr (std::is_same_v<TypeParam, Int8Type>) {
+    this->SetRoundMode(RoundMode::DOWN);
+    this->AssertBinaryOpRaises(RoundBinary, "[-127]", "[-1]", "overflow");
   }
 }
 
@@ -1131,7 +1276,8 @@ TYPED_TEST(TestBinaryRoundUnsigned, Round) {
   std::string values("[0, 1, 13, 50, 115]");
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertBinaryOp(RoundBinary, values, 0, ArrayFromJSON(float64(), values));
+    this->AssertBinaryOp(RoundBinary, values, 0,
+                         ArrayFromJSON(this->type_singleton(), values));
   }
 
   // Test different round N-digits for nearest rounding mode
@@ -1145,7 +1291,42 @@ TYPED_TEST(TestBinaryRoundUnsigned, Round) {
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : ndigits_and_expected) {
     this->AssertBinaryOp(RoundBinary, values, pair.first,
-                         ArrayFromJSON(float64(), pair.second));
+                         ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  // skip uint8 because of its small range
+  if constexpr (!std::is_same<TypeParam, UInt8Type>::value) {
+    std::string values("[0, 1, 13, 50, 115, 176, 200, 250]");
+    std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+        {RoundMode::DOWN, "[0, 0, 0, 0, 100, 100, 200, 200]"},
+        {RoundMode::UP, "[0, 100, 100, 100, 200, 200, 200, 300]"},
+        {RoundMode::TOWARDS_ZERO, "[0, 0, 0, 0, 100, 100, 200, 200]"},
+        {RoundMode::TOWARDS_INFINITY, "[0, 100, 100, 100, 200, 200, 200, 300]"},
+        {RoundMode::HALF_DOWN, "[0, 0, 0, 0, 100, 200, 200, 200]"},
+        {RoundMode::HALF_UP, "[0, 0, 0, 100, 100, 200, 200, 300]"},
+        {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, 0, 0, 100, 200, 200, 200]"},
+        {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, 0, 100, 100, 200, 200, 300]"},
+        {RoundMode::HALF_TO_EVEN, "[0, 0, 0, 0, 100, 200, 200, 200]"},
+        {RoundMode::HALF_TO_ODD, "[0, 0, 0, 100, 100, 200, 200, 300]"},
+    }};
+    for (const auto& pair : round_modes_and_expected) {
+      this->SetRoundMode(pair.first);
+      this->AssertBinaryOp(RoundBinary, values, -2,
+                           ArrayFromJSON(this->type_singleton(), pair.second));
+    }
+  }
+
+  // An overly large ndigits would cause an error
+  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+    this->SetRoundMode(RoundMode::UP);
+    this->AssertBinaryOpRaises(RoundBinary, "[1]", "[-100]", "out of range");
+  }
+
+  // Overflow is also treated as error
+  if constexpr (std::is_same_v<TypeParam, UInt8Type>) {
+    this->SetRoundMode(RoundMode::UP);
+    this->AssertBinaryOpRaises(RoundBinary, "[255]", "[-1]", "overflow");
   }
 }
 
@@ -1203,21 +1384,74 @@ TYPED_TEST(TestUnaryRoundToMultipleSigned, RoundToMultiple) {
   this->SetRoundMultiple(1);
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertUnaryOp(RoundToMultiple, values, ArrayFromJSON(float64(), values));
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), values));
   }
 
+  // Out of range multiple is not allowed
+  this->SetRoundMultiple(
+      static_cast<double>(
+          std::numeric_limits<typename TypeTraits<TypeParam>::CType>::max()) +
+      1e9);
+  this->AssertUnaryOpRaises(RoundToMultiple, values, "Invalid");
+
   // Test different round multiples for nearest rounding mode
-  std::vector<std::pair<double, std::string>> multiple_and_expected{{
-      {2, "[0.0, 2, -14, -50, 116]"},
-      {0.05, "[0.0, 1, -13, -50, 115]"},
-      {0.1, values},
-      {10, "[0.0, 0.0, -10, -50, 120]"},
-      {100, "[0.0, 0.0, -0.0, -100, 100]"},
+  std::vector<std::pair<int, std::string>> multiple_and_expected{{
+      {2, "[0, 2, -14, -50, 116]"},
+      {10, "[0, 0, -10, -50, 120]"},
+      {100, "[0, 0, -0, -100, 100]"},
   }};
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : multiple_and_expected) {
     this->SetRoundMultiple(pair.first);
-    this->AssertUnaryOp(RoundToMultiple, values, ArrayFromJSON(float64(), pair.second));
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  values = "[0, -1, 2, -5, 6, -8]";
+  // Even case is tested by round and round_binary so we test an odd case here
+  this->SetRoundMultiple(3);
+  std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+      {RoundMode::DOWN, "[0, -3, 0, -6, 6, -9]"},
+      {RoundMode::UP, "[0, 0, 3, -3, 6, -6]"},
+      {RoundMode::TOWARDS_ZERO, "[0, 0, 0, -3, 6, -6]"},
+      {RoundMode::TOWARDS_INFINITY, "[0, -3, 3, -6, 6, -9]"},
+      {RoundMode::HALF_DOWN, "[0, 0, 3, -6, 6, -9]"},
+      {RoundMode::HALF_UP, "[0, 0, 3, -6, 6, -9]"},
+      {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, 3, -6, 6, -9]"},
+      {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, 3, -6, 6, -9]"},
+      {RoundMode::HALF_TO_EVEN, "[0, 0, 3, -6, 6, -9]"},
+      {RoundMode::HALF_TO_ODD, "[0, 0, 3, -6, 6, -9]"},
+  }};
+  for (const auto& pair : round_modes_and_expected) {
+    this->SetRoundMode(pair.first);
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  if constexpr (std::is_same_v<TypeParam, Int32Type>) {
+    // Test overflow handling
+    this->SetRoundMultiple(10);
+    auto input = "[-2147483645]";
+    std::vector<RoundMode> invalid_modes{
+        RoundMode::DOWN, RoundMode::TOWARDS_INFINITY, RoundMode::HALF_DOWN,
+        RoundMode::HALF_TOWARDS_INFINITY, RoundMode::HALF_TO_ODD};
+    std::vector<RoundMode> valid_modes{RoundMode::UP, RoundMode::TOWARDS_ZERO,
+                                       RoundMode::HALF_UP, RoundMode::HALF_TOWARDS_ZERO,
+                                       RoundMode::HALF_TO_EVEN};
+    for (auto mode : invalid_modes) {
+      this->SetRoundMode(mode);
+      this->AssertUnaryOpRaises(
+          RoundToMultiple, input,
+          "Rounding -2147483645 down to multiple of 10 would overflow");
+    }
+
+    for (auto mode : valid_modes) {
+      this->SetRoundMode(mode);
+      this->AssertUnaryOp(RoundToMultiple, input,
+                          ArrayFromJSON(int32(), "[-2147483640]"));
+    }
   }
 }
 
@@ -1227,13 +1461,19 @@ TYPED_TEST(TestUnaryRoundToMultipleUnsigned, RoundToMultiple) {
   this->SetRoundMultiple(1);
   for (const auto& round_mode : kRoundModes) {
     this->SetRoundMode(round_mode);
-    this->AssertUnaryOp(RoundToMultiple, values, ArrayFromJSON(float64(), values));
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), values));
   }
 
+  // Out of range multiple is not allowed
+  this->SetRoundMultiple(
+      static_cast<double>(
+          std::numeric_limits<typename TypeTraits<TypeParam>::CType>::max()) +
+      1e9);
+  this->AssertUnaryOpRaises(RoundToMultiple, values, "Invalid");
+
   // Test different round multiples for nearest rounding mode
   std::vector<std::pair<double, std::string>> multiple_and_expected{{
-      {0.05, "[0, 1, 13, 50, 115]"},
-      {0.1, values},
       {2, "[0, 2, 14, 50, 116]"},
       {10, "[0, 0, 10, 50, 120]"},
       {100, "[0, 0, 0, 100, 100]"},
@@ -1241,7 +1481,54 @@ TYPED_TEST(TestUnaryRoundToMultipleUnsigned, RoundToMultiple) {
   this->SetRoundMode(RoundMode::HALF_TOWARDS_INFINITY);
   for (const auto& pair : multiple_and_expected) {
     this->SetRoundMultiple(pair.first);
-    this->AssertUnaryOp(RoundToMultiple, values, ArrayFromJSON(float64(), pair.second));
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  // Test different rounding mode
+  values = "[0, 1, 2, 5, 6, 8]";
+  // Even case is tested by round and round_binary so we test an odd case here
+  this->SetRoundMultiple(3);
+  std::vector<std::pair<RoundMode, std::string>> round_modes_and_expected{{
+      {RoundMode::DOWN, "[0, 0, 0, 3, 6, 6]"},
+      {RoundMode::UP, "[0, 3, 3, 6, 6, 9]"},
+      {RoundMode::TOWARDS_ZERO, "[0, 0, 0, 3, 6, 6]"},
+      {RoundMode::TOWARDS_INFINITY, "[0, 3, 3, 6, 6, 9]"},
+      {RoundMode::HALF_DOWN, "[0, 0, 3, 6, 6, 9]"},
+      {RoundMode::HALF_UP, "[0, 0, 3, 6, 6, 9]"},
+      {RoundMode::HALF_TOWARDS_ZERO, "[0, 0, 3, 6, 6, 9]"},
+      {RoundMode::HALF_TOWARDS_INFINITY, "[0, 0, 3, 6, 6, 9]"},
+      {RoundMode::HALF_TO_EVEN, "[0, 0, 3, 6, 6, 9]"},
+      {RoundMode::HALF_TO_ODD, "[0, 0, 3, 6, 6, 9]"},
+  }};
+  for (const auto& pair : round_modes_and_expected) {
+    this->SetRoundMode(pair.first);
+    this->AssertUnaryOp(RoundToMultiple, values,
+                        ArrayFromJSON(this->type_singleton(), pair.second));
+  }
+
+  if constexpr (std::is_same_v<TypeParam, UInt32Type>) {
+    // Test overflow handling
+    this->SetRoundMultiple(10);
+    auto input = "[4294967295]";
+    std::vector<RoundMode> valid_modes{RoundMode::DOWN, RoundMode::TOWARDS_ZERO,
+                                       RoundMode::HALF_DOWN, RoundMode::HALF_TOWARDS_ZERO,
+                                       RoundMode::HALF_TO_ODD};
+    std::vector<RoundMode> invalid_modes{RoundMode::UP, RoundMode::TOWARDS_INFINITY,
+                                         RoundMode::HALF_UP, RoundMode::TOWARDS_INFINITY,
+                                         RoundMode::HALF_TO_EVEN};
+    for (auto mode : invalid_modes) {
+      this->SetRoundMode(mode);
+      this->AssertUnaryOpRaises(
+          RoundToMultiple, input,
+          "Rounding 4294967295 up to multiple of 10 would overflow");
+    }
+
+    for (auto mode : valid_modes) {
+      this->SetRoundMode(mode);
+      this->AssertUnaryOp(RoundToMultiple, input,
+                          ArrayFromJSON(uint32(), "[4294967290]"));
+    }
   }
 }
 
@@ -1444,5 +1731,4 @@ TYPED_TEST(TestUnaryRoundArithmeticFloating, Trunc) {
 }
 
 }  // namespace
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute
diff --git a/cpp/src/arrow/engine/substrait/function_test.cc b/cpp/src/arrow/engine/substrait/function_test.cc
index eee98ec7199d2..f0d2583e815ae 100644
--- a/cpp/src/arrow/engine/substrait/function_test.cc
+++ b/cpp/src/arrow/engine/substrait/function_test.cc
@@ -490,7 +490,7 @@ TEST(FunctionMapping, ValidCases) {
        {{"rounding", {"TIE_AWAY_FROM_ZERO"}}},
        {int64(), int32()},
        "300",
-       float64()},
+       int64()},
   };
   CheckValidTestCases(valid_test_cases);
 }
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index f8e371314631e..9cc1dd79936b8 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -563,32 +563,40 @@ representation based on the rounding criterion.
 +-------------------+------------+-------------+-------------------------+----------------------------------+--------+
 | floor             | Unary      | Numeric     | Float32/Float64/Decimal |                                  |        |
 +-------------------+------------+-------------+-------------------------+----------------------------------+--------+
-| round             | Unary      | Numeric     | Float32/Float64/Decimal | :struct:`RoundOptions`           | (1)(2) |
+| round             | Unary      | Numeric     | Input Type              | :struct:`RoundOptions`           | (1)(2) |
 +-------------------+------------+-------------+-------------------------+----------------------------------+--------+
-| round_to_multiple | Unary      | Numeric     | Float32/Float64/Decimal | :struct:`RoundToMultipleOptions` | (1)(3) |
+| round_to_multiple | Unary      | Numeric     | Input Type              | :struct:`RoundToMultipleOptions` | (1)(3) |
++-------------------+------------+-------------+-------------------------+----------------------------------+--------+
+| round_binary      | Binary     | Numeric     | Input Type              | :struct:`RoundBinaryOptions`     | (1)(4) |
 +-------------------+------------+-------------+-------------------------+----------------------------------+--------+
 | trunc             | Unary      | Numeric     | Float32/Float64/Decimal |                                  |        |
 +-------------------+------------+-------------+-------------------------+----------------------------------+--------+
 
-* \(1) Output value is a 64-bit floating-point for integral inputs and the
-  retains the same type for floating-point and decimal inputs.  By default
-  rounding functions displace a value to the nearest integer using
-  HALF_TO_EVEN to resolve ties.  Options are available to control the rounding
-  criterion.  Both ``round`` and ``round_to_multiple`` have the ``round_mode``
-  option to set the rounding mode.
+* \(1)  By default rounding functions change a value to the nearest 
+  integer using HALF_TO_EVEN to resolve ties.  Options are available to control 
+  the rounding criterion.  All ``round`` functions have the 
+  ``round_mode`` option to set the rounding mode.
 * \(2) Round to a number of digits where the ``ndigits`` option of
   :struct:`RoundOptions` specifies the rounding precision in terms of number
   of digits.  A negative value corresponds to digits in the non-fractional
   part.  For example, -2 corresponds to rounding to the nearest multiple of
   100 (zeroing the ones and tens digits).  Default value of ``ndigits`` is 0
-  which rounds to the nearest integer.
+  which rounds to the nearest integer. For integer inputs a non-negative 
+  ``ndigits`` value is ignored and the input is returned unchanged. For integer
+  inputs, if ``-ndigits`` is larger than the maximum number of digits the 
+  input type can hold, an error is returned.
 * \(3) Round to a multiple where the ``multiple`` option of
   :struct:`RoundToMultipleOptions` specifies the rounding scale.  The rounding
-  multiple has to be a positive value.  For example, 100 corresponds to
-  rounding to the nearest multiple of 100 (zeroing the ones and tens digits).
-  Default value of ``multiple`` is 1 which rounds to the nearest integer.
-
-For ``round`` and ``round_to_multiple``, the following rounding modes are available.
+  multiple has to be a positive value and can be casted to input type.  
+  For example, 100 corresponds to rounding to the nearest multiple of 100 
+  (zeroing the ones and tens digits). Default value of ``multiple`` is 1 which 
+  rounds to the nearest integer.
+* \(4) Round the first input to multiple of the second input. The rounding
+  multiple has to be a positive value and can be casted to the first input type.  
+  For example, 100 corresponds to rounding to the nearest multiple of 100 
+  (zeroing the ones and tens digits).
+
+For ``round`` functions, the following rounding modes are available.
 Tie-breaking modes are prefixed with HALF and round non-ties to the nearest integer.
 The example values are given for default values of ``ndigits`` and ``multiple``.
 
@@ -626,9 +634,9 @@ The example values are given for default values of ``ndigits`` and ``multiple``.
 |                       |                                                              | -3.5 -> -3, -4.5 -> -5    |
 +-----------------------+--------------------------------------------------------------+---------------------------+
 
-The following table gives examples of how ``ndigits`` (for the ``round``
-function) and ``multiple`` (for ``round_to_multiple``) influence the operance
-performed, respectively.
+The following table gives examples of how ``ndigits`` (for the ``round`` 
+and ``round_binary`` functions) and ``multiple`` (for ``round_to_multiple``) 
+influence the operation performed, respectively.
 
 +--------------------+-------------------+---------------------------+
 | Round ``multiple`` | Round ``ndigits`` | Operation performed       |
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 98ab84c03900f..30a3cdba36d71 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1611,9 +1611,9 @@ def test_round_binary():
     scale = pa.scalar(-1, pa.int32())
 
     assert pc.round_binary(
-        5, scale, round_mode="half_towards_zero") == expect_zero
+        5.0, scale, round_mode="half_towards_zero") == expect_zero
     assert pc.round_binary(
-        5, scale, round_mode="half_towards_infinity") == expect_inf
+        5.0, scale, round_mode="half_towards_infinity") == expect_inf
 
 
 def test_is_null():

From 10df380573b3e4db6d8965195d41c6cfbe130a4d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 10 Aug 2023 06:17:29 +0900
Subject: [PATCH 129/749] MINOR: [JS] Bump eslint-plugin-jest from 27.2.1 to
 27.2.3 in /js (#37079)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [eslint-plugin-jest](https://github.com/jest-community/eslint-plugin-jest) from 27.2.1 to 27.2.3.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/jest-community/eslint-plugin-jest/releases">eslint-plugin-jest's releases</a>.</em></p>
<blockquote>
<h2>v27.2.3</h2>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.2...v27.2.3">27.2.3</a> (2023-07-13)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>allow <code>@ typescript-eslint/eslint-plugin</code> v6 as peer dep (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1400">#1400</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/04b2bf29bf086f8ce8173a9c3bc15ce31915dbe2">04b2bf2</a>), closes <a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1398">#1398</a></li>
</ul>
<h2>v27.2.2</h2>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.1...v27.2.2">27.2.2</a> (2023-06-19)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>add missing (optional) peer dependency on Jest (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1384">#1384</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/34c3d32cab726c88dc385a9e7a8998c727f4720c">34c3d32</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/jest-community/eslint-plugin-jest/blob/main/CHANGELOG.md">eslint-plugin-jest's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.2...v27.2.3">27.2.3</a> (2023-07-13)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>allow <code>@ typescript-eslint/eslint-plugin</code> v6 as peer dep (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1400">#1400</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/04b2bf29bf086f8ce8173a9c3bc15ce31915dbe2">04b2bf2</a>), closes <a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1398">#1398</a></li>
</ul>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.1...v27.2.2">27.2.2</a> (2023-06-19)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>add missing (optional) peer dependency on Jest (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1384">#1384</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/34c3d32cab726c88dc385a9e7a8998c727f4720c">34c3d32</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/4b354862ec828af9f15c47542b4139290e9a78e5"><code>4b35486</code></a> chore(release): 27.2.3 [skip ci]</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/04b2bf29bf086f8ce8173a9c3bc15ce31915dbe2"><code>04b2bf2</code></a> fix: allow <code>@ typescript-eslint/eslint-plugin</code> v6 as peer dep (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1400">#1400</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/a1131ff69c86514f881862c24981250dfa42bb7b"><code>a1131ff</code></a> chore(deps): update yarn to v3.6.1 (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1392">#1392</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/6034de3169d0b4870f3b280e1784ed2c0d46fffc"><code>6034de3</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/6340c2fee6a7c7ecba7d6500dc2074713c03bc5a"><code>6340c2f</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/7daaf898683346afc85441d37994ff563dba9093"><code>7daaf89</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/c29a775db38b34cb3bbc4fe83c60a13b5122e5a3"><code>c29a775</code></a> chore: upgrade <code>@​tsconfig/node14</code> (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1388">#1388</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/9240ecf68f4196cc5da625e1ad64a35958d4b731"><code>9240ecf</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/59e213ab8d0d4a0b56461fca4090fae772fe645e"><code>59e213a</code></a> chore: refer directly to index.js file</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/b161c26176764712328303db5b54824be09a048c"><code>b161c26</code></a> chore: remove test files from published tarball</li>
<li>Additional commits viewable in <a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.1...v27.2.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=eslint-plugin-jest&package-manager=npm_and_yarn&previous-version=27.2.1&new-version=27.2.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json | 2 +-
 js/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/package.json b/js/package.json
index 510d1afd9a659..e042c94fd82ad 100644
--- a/js/package.json
+++ b/js/package.json
@@ -82,7 +82,7 @@
     "esbuild": "0.18.0",
     "esbuild-plugin-alias": "0.2.1",
     "eslint": "8.42.0",
-    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-jest": "27.2.3",
     "eslint-plugin-unicorn": "47.0.0",
     "esm": "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz",
     "glob": "10.2.7",
diff --git a/js/yarn.lock b/js/yarn.lock
index eae220fc84f72..991f1c206e9cb 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -3576,10 +3576,10 @@ escape-string-regexp@^4.0.0:
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
-eslint-plugin-jest@27.2.1:
-  version "27.2.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jest/-/eslint-plugin-jest-27.2.1.tgz#b85b4adf41c682ea29f1f01c8b11ccc39b5c672c"
-  integrity sha512-l067Uxx7ZT8cO9NJuf+eJHvt6bqJyz2Z29wykyEdz/OtmcELQl2MQGQLX8J94O1cSJWAwUSEvCjwjA7KEK3Hmg==
+eslint-plugin-jest@27.2.3:
+  version "27.2.3"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jest/-/eslint-plugin-jest-27.2.3.tgz#6f8a4bb2ca82c0c5d481d1b3be256ab001f5a3ec"
+  integrity sha512-sRLlSCpICzWuje66Gl9zvdF6mwD5X86I4u55hJyFBsxYOsBCmT5+kSUjf+fkFWVMMgpzNEupjW8WzUqi83hJAQ==
   dependencies:
     "@typescript-eslint/utils" "^5.10.0"
 

From c8921e23e3a5c6d48fbcf21732e3a3f00da43daf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 10 Aug 2023 06:18:10 +0900
Subject: [PATCH 130/749] MINOR: [JS] Bump jest and @types/jest in /js (#37080)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

[//]: # (dependabot-start)
⚠️  **Dependabot is rebasing this PR** ⚠️

Rebasing might not happen immediately, so don't worry if this takes some time.

Note: if you make any changes to this PR yourself, they will take precedence over the rebase.

---

[//]: # (dependabot-end)

Bumps [jest](https://github.com/facebook/jest/tree/HEAD/packages/jest) and [@ types/jest](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/jest). These dependencies needed to be updated together.
Updates `jest` from 29.5.0 to 29.6.2
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/facebook/jest/releases">jest's releases</a>.</em></p>
<blockquote>
<h2>v29.6.2</h2>
<h2>Fixes</h2>
<ul>
<li><code>[jest-circus]</code> Fix snapshot matchers in concurrent tests when nr of tests exceeds <code>maxConcurrency</code> (<a href="https://redirect.github.com/jestjs/jest/pull/14335">#14335</a>)</li>
<li><code>[@ jest/core]</code> When running global setup and teardown, do not try to change the <code>message</code> property of the thrown error object when the <code>message</code> property is unwritable (<a href="https://redirect.github.com/jestjs/jest/pull/14113">#14113</a>)</li>
<li><code>[jest-snapshot]</code> Move <code>@ types/prettier</code> from <code>dependencies</code> to <code>devDependencies</code> (<a href="https://redirect.github.com/jestjs/jest/pull/14328">#14328</a>)</li>
<li><code>[jest-snapshot]</code> Throw an explicit error if Prettier v3 is used (<a href="https://redirect.github.com/jestjs/jest/pull/14367">#14367</a>)</li>
<li><code>[jest-reporters]</code> Add &quot;skipped&quot; and &quot;todo&quot; symbols to Github Actions Reporter (<a href="https://redirect.github.com/jestjs/jest/pull/14309">#14309</a>)</li>
</ul>
<h2>Chore &amp; Maintenance</h2>
<ul>
<li><code>[@ jest/core]</code> Use <code>pluralize</code> from <code>jest-util</code> rather than own internal (<a href="https://redirect.github.com/jestjs/jest/pull/14322">#14322</a>)</li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/Kloen"><code>@​Kloen</code></a> made their first contribution in <a href="https://redirect.github.com/jestjs/jest/pull/14328">jestjs/jest#14328</a></li>
<li><a href="https://github.com/eryue0220"><code>@​eryue0220</code></a> made their first contribution in <a href="https://redirect.github.com/jestjs/jest/pull/14322">jestjs/jest#14322</a></li>
<li><a href="https://github.com/david-szabo97"><code>@​david-szabo97</code></a> made their first contribution in <a href="https://redirect.github.com/jestjs/jest/pull/14113">jestjs/jest#14113</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/jestjs/jest/compare/v29.6.1...v29.6.2">https://github.com/jestjs/jest/compare/v29.6.1...v29.6.2</a></p>
<h2>v29.6.1</h2>
<h2>Fixes</h2>
<ul>
<li><code>[jest-circus]</code> Revert <a href="https://redirect.github.com/jestjs/jest/pull/14110">#14110</a> as it was a breaking change (<a href="https://redirect.github.com/jestjs/jest/pull/14304">#14304</a>)</li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/jestjs/jest/compare/v29.6.0...v29.6.1">https://github.com/jestjs/jest/compare/v29.6.0...v29.6.1</a></p>
<h2>v29.6.0</h2>
<h2>Features</h2>
<ul>
<li><code>[jest-circus, jest-snapshot]</code> Add support for snapshot matchers in concurrent tests (<a href="https://redirect.github.com/jestjs/jest/pull/14139">#14139</a>)</li>
<li><code>[jest-cli]</code> Include type definitions to generated config files (<a href="https://redirect.github.com/facebook/jest/pull/14078">#14078</a>)</li>
<li><code>[jest-snapshot]</code> Support arrays as property matchers (<a href="https://redirect.github.com/facebook/jest/pull/14025">#14025</a>)</li>
<li><code>[jest-core, jest-circus, jest-reporter, jest-runner]</code> Added support for reporting about start individual test cases using jest-circus (<a href="https://redirect.github.com/jestjs/jest/pull/14174">#14174</a>)</li>
</ul>
<h2>Fixes</h2>
<ul>
<li><code>[jest-circus]</code> Prevent false test failures caused by promise rejections handled asynchronously (<a href="https://redirect.github.com/jestjs/jest/pull/14110">#14110</a>)</li>
<li><code>[jest-config]</code> Handle frozen config object (<a href="https://redirect.github.com/facebook/jest/pull/14054">#14054</a>)</li>
<li><code>[jest-config]</code> Allow <code>coverageDirectory</code> and <code>collectCoverageFrom</code> in project config (<a href="https://redirect.github.com/jestjs/jest/pull/14180">#14180</a>)</li>
<li><code>[jest-core]</code> Always use workers in watch mode to avoid crashes (<a href="https://redirect.github.com/facebook/jest/pull/14059">#14059</a>).</li>
<li><code>[jest-environment-jsdom, jest-environment-node]</code> Fix assignment of <code>customExportConditions</code> via <code>testEnvironmentOptions</code> when custom env subclass defines a default value (<a href="https://redirect.github.com/facebook/jest/pull/13989">#13989</a>)</li>
<li><code>[jest-matcher-utils]</code> Fix copying value of inherited getters (<a href="https://redirect.github.com/facebook/jest/pull/14007">#14007</a>)</li>
<li><code>[jest-mock]</code> Tweak typings to allow <code>jest.replaceProperty()</code> replace methods (<a href="https://redirect.github.com/facebook/jest/pull/14008">#14008</a>)</li>
<li><code>[jest-mock]</code> Improve user input validation and error messages of <code>spyOn</code> and <code>replaceProperty</code> methods (<a href="https://redirect.github.com/facebook/jest/pull/14087">#14087</a>)</li>
<li><code>[jest-runtime]</code> Bind <code>jest.isolateModulesAsync</code> to <code>this</code> (<a href="https://redirect.github.com/facebook/jest/pull/14083">#14083</a>)</li>
<li><code>[jest-runtime]</code> Forward <code>wrapperLength</code> to the <code>Script</code> constructor as <code>columnOffset</code> for accurate debugging (<a href="https://redirect.github.com/facebook/jest/pull/14148">#14148</a>)</li>
<li><code>[jest-runtime]</code> Guard <code>_isMockFunction</code> access with <code>in</code> (<a href="https://redirect.github.com/facebook/jest/pull/14188">#14188</a>)</li>
<li><code>[jest-snapshot]</code> Fix a potential bug when not using prettier and improve performance (<a href="https://redirect.github.com/facebook/jest/pull/14036">#14036</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/jestjs/jest/blob/main/CHANGELOG.md">jest's changelog</a>.</em></p>
<blockquote>
<h2>29.6.2</h2>
<h3>Fixes</h3>
<ul>
<li><code>[jest-circus]</code> Fix snapshot matchers in concurrent tests when nr of tests exceeds <code>maxConcurrency</code> (<a href="https://redirect.github.com/jestjs/jest/pull/14335">#14335</a>)</li>
<li><code>[@ jest/core]</code> When running global setup and teardown, do not try to change the <code>message</code> property of the thrown error object when the <code>message</code> property is unwritable (<a href="https://redirect.github.com/jestjs/jest/pull/14113">#14113</a>)</li>
<li><code>[jest-snapshot]</code> Move <code>@ types/prettier</code> from <code>dependencies</code> to <code>devDependencies</code> (<a href="https://redirect.github.com/jestjs/jest/pull/14328">#14328</a>)</li>
<li><code>[jest-snapshot]</code> Throw an explicit error if Prettier v3 is used (<a href="https://redirect.github.com/jestjs/jest/pull/14367">#14367</a>)</li>
<li><code>[jest-reporters]</code> Add &quot;skipped&quot; and &quot;todo&quot; symbols to Github Actions Reporter (<a href="https://redirect.github.com/jestjs/jest/pull/14309">#14309</a>)</li>
</ul>
<h3>Chore &amp; Maintenance</h3>
<ul>
<li><code>[@ jest/core]</code> Use <code>pluralize</code> from <code>jest-util</code> rather than own internal (<a href="https://redirect.github.com/jestjs/jest/pull/14322">#14322</a>)</li>
</ul>
<h2>29.6.1</h2>
<h3>Fixes</h3>
<ul>
<li><code>[jest-circus]</code> Revert <a href="https://redirect.github.com/jestjs/jest/pull/14110">#14110</a> as it was a breaking change (<a href="https://redirect.github.com/jestjs/jest/pull/14304">#14304</a>)</li>
</ul>
<h2>29.6.0</h2>
<h3>Features</h3>
<ul>
<li><code>[jest-circus, jest-snapshot]</code> Add support for snapshot matchers in concurrent tests (<a href="https://redirect.github.com/jestjs/jest/pull/14139">#14139</a>)</li>
<li><code>[jest-cli]</code> Include type definitions to generated config files (<a href="https://redirect.github.com/facebook/jest/pull/14078">#14078</a>)</li>
<li><code>[jest-snapshot]</code> Support arrays as property matchers (<a href="https://redirect.github.com/facebook/jest/pull/14025">#14025</a>)</li>
<li><code>[jest-core, jest-circus, jest-reporter, jest-runner]</code> Added support for reporting about start individual test cases using jest-circus (<a href="https://redirect.github.com/jestjs/jest/pull/14174">#14174</a>)</li>
</ul>
<h3>Fixes</h3>
<ul>
<li><code>[jest-circus]</code> Prevent false test failures caused by promise rejections handled asynchronously (<a href="https://redirect.github.com/jestjs/jest/pull/14110">#14110</a>)</li>
<li><code>[jest-config]</code> Handle frozen config object (<a href="https://redirect.github.com/facebook/jest/pull/14054">#14054</a>)</li>
<li><code>[jest-config]</code> Allow <code>coverageDirectory</code> and <code>collectCoverageFrom</code> in project config (<a href="https://redirect.github.com/jestjs/jest/pull/14180">#14180</a>)</li>
<li><code>[jest-core]</code> Always use workers in watch mode to avoid crashes (<a href="https://redirect.github.com/facebook/jest/pull/14059">#14059</a>).</li>
<li><code>[jest-environment-jsdom, jest-environment-node]</code> Fix assignment of <code>customExportConditions</code> via <code>testEnvironmentOptions</code> when custom env subclass defines a default value (<a href="https://redirect.github.com/facebook/jest/pull/13989">#13989</a>)</li>
<li><code>[jest-matcher-utils]</code> Fix copying value of inherited getters (<a href="https://redirect.github.com/facebook/jest/pull/14007">#14007</a>)</li>
<li><code>[jest-mock]</code> Tweak typings to allow <code>jest.replaceProperty()</code> replace methods (<a href="https://redirect.github.com/facebook/jest/pull/14008">#14008</a>)</li>
<li><code>[jest-mock]</code> Improve user input validation and error messages of <code>spyOn</code> and <code>replaceProperty</code> methods (<a href="https://redirect.github.com/facebook/jest/pull/14087">#14087</a>)</li>
<li><code>[jest-runtime]</code> Bind <code>jest.isolateModulesAsync</code> to <code>this</code> (<a href="https://redirect.github.com/facebook/jest/pull/14083">#14083</a>)</li>
<li><code>[jest-runtime]</code> Forward <code>wrapperLength</code> to the <code>Script</code> constructor as <code>columnOffset</code> for accurate debugging (<a href="https://redirect.github.com/facebook/jest/pull/14148">#14148</a>)</li>
<li><code>[jest-runtime]</code> Guard <code>_isMockFunction</code> access with <code>in</code> (<a href="https://redirect.github.com/facebook/jest/pull/14188">#14188</a>)</li>
<li><code>[jest-snapshot]</code> Fix a potential bug when not using prettier and improve performance (<a href="https://redirect.github.com/facebook/jest/pull/14036">#14036</a>)</li>
<li><code>[@ jest/transform]</code> Do not instrument <code>.json</code> modules (<a href="https://redirect.github.com/facebook/jest/pull/14048">#14048</a>)</li>
<li><code>[jest-worker]</code> Restart a shut down worker before sending it a task (<a href="https://redirect.github.com/facebook/jest/pull/14015">#14015</a>)</li>
</ul>
<h3>Chore &amp; Maintenance</h3>
<ul>
<li><code>[*]</code> Update <code>semver</code> dependency to get vulnerability fix (<a href="https://redirect.github.com/jestjs/jest/pull/14262">#14262</a>)</li>
<li><code>[docs]</code> Updated documentation for the <code>--runTestsByPath</code> CLI command (<a href="https://redirect.github.com/facebook/jest/pull/14004">#14004</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/jestjs/jest/commit/0fd5b1c37555f485c56a6ad2d6b010a72204f9f6"><code>0fd5b1c</code></a> v29.6.2</li>
<li><a href="https://github.com/jestjs/jest/commit/1f019afdcdfc54a6664908bb45f343db4e3d0848"><code>1f019af</code></a> v29.6.1</li>
<li><a href="https://github.com/jestjs/jest/commit/c1e5b8a38ef54bb138409f89831942ebf6a7a67e"><code>c1e5b8a</code></a> v29.6.0</li>
<li><a href="https://github.com/jestjs/jest/commit/6ffa48d1cd7d85189f0dbc1e37fd0efafa5c221c"><code>6ffa48d</code></a> chore: upgrade TypeScript to v5 (<a href="https://github.com/facebook/jest/tree/HEAD/packages/jest/issues/14155">#14155</a>)</li>
<li><a href="https://github.com/jestjs/jest/commit/a95eeb6c2c8145a81190149a52a30fc177417ecc"><code>a95eeb6</code></a> chore: update tsd runner (<a href="https://github.com/facebook/jest/tree/HEAD/packages/jest/issues/14020">#14020</a>)</li>
<li>See full diff in <a href="https://github.com/facebook/jest/commits/v29.6.2/packages/jest">compare view</a></li>
</ul>
</details>
<br />

Updates `@ types/jest` from 29.5.2 to 29.5.3
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/jest">compare view</a></li>
</ul>
</details>
<br />

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |   4 +-
 js/yarn.lock    | 674 +++++++++++++++++++++++++-----------------------
 2 files changed, 353 insertions(+), 325 deletions(-)

diff --git a/js/package.json b/js/package.json
index e042c94fd82ad..da1ce744d0334 100644
--- a/js/package.json
+++ b/js/package.json
@@ -70,7 +70,7 @@
     "@rollup/stream": "3.0.0",
     "@types/benchmark": "2.1.2",
     "@types/glob": "8.1.0",
-    "@types/jest": "29.5.2",
+    "@types/jest": "29.5.3",
     "@types/randomatic": "3.1.3",
     "@typescript-eslint/eslint-plugin": "5.59.9",
     "@typescript-eslint/parser": "5.59.9",
@@ -97,7 +97,7 @@
     "gulp-typescript": "5.0.1",
     "gulp-vinyl-size": "1.1.3",
     "ix": "5.0.0",
-    "jest": "29.5.0",
+    "jest": "29.6.2",
     "jest-silent-reporter": "0.5.0",
     "lerna": "7.0.0",
     "memfs": "4.2.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index 991f1c206e9cb..43ba5c3c2f5c1 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -311,7 +311,7 @@
     "@babel/parser" "^7.22.5"
     "@babel/types" "^7.22.5"
 
-"@babel/traverse@^7.22.5", "@babel/traverse@^7.7.2":
+"@babel/traverse@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.22.5.tgz#44bd276690db6f4940fdb84e1cb4abd2f729ccd1"
   integrity sha512-7DuIjPgERaNo6r+PZwItpjCZEa5vyw4eJGufeLxrPdBXBoLcCJCIasvK6pK/9DVNrLZTLFhUGqaC6X/PA007TQ==
@@ -681,28 +681,28 @@
   resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
   integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==
 
-"@jest/console@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/console/-/console-29.5.0.tgz#593a6c5c0d3f75689835f1b3b4688c4f8544cb57"
-  integrity sha512-NEpkObxPwyw/XxZVLPmAGKE89IQRp4puc6IQRPru6JKd1M3fW9v1xM1AnzIJE65hbCkzQAdnL8P47e9hzhiYLQ==
+"@jest/console@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/console/-/console-29.6.2.tgz#bf1d4101347c23e07c029a1b1ae07d550f5cc541"
+  integrity sha512-0N0yZof5hi44HAR2pPS+ikJ3nzKNoZdVu8FffRf3wy47I7Dm7etk/3KetMdRUqzVd16V4O2m2ISpNTbnIuqy1w==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     chalk "^4.0.0"
-    jest-message-util "^29.5.0"
-    jest-util "^29.5.0"
+    jest-message-util "^29.6.2"
+    jest-util "^29.6.2"
     slash "^3.0.0"
 
-"@jest/core@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/core/-/core-29.5.0.tgz#76674b96904484e8214614d17261cc491e5f1f03"
-  integrity sha512-28UzQc7ulUrOQw1IsN/kv1QES3q2kkbl/wGslyhAclqZ/8cMdB5M68BffkIdSJgKBUt50d3hbwJ92XESlE7LiQ==
+"@jest/core@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/core/-/core-29.6.2.tgz#6f2d1dbe8aa0265fcd4fb8082ae1952f148209c8"
+  integrity sha512-Oj+5B+sDMiMWLhPFF+4/DvHOf+U10rgvCLGPHP8Xlsy/7QxS51aU/eBngudHlJXnaWD5EohAgJ4js+T6pa+zOg==
   dependencies:
-    "@jest/console" "^29.5.0"
-    "@jest/reporters" "^29.5.0"
-    "@jest/test-result" "^29.5.0"
-    "@jest/transform" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/console" "^29.6.2"
+    "@jest/reporters" "^29.6.2"
+    "@jest/test-result" "^29.6.2"
+    "@jest/transform" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     ansi-escapes "^4.2.1"
     chalk "^4.0.0"
@@ -710,81 +710,81 @@
     exit "^0.1.2"
     graceful-fs "^4.2.9"
     jest-changed-files "^29.5.0"
-    jest-config "^29.5.0"
-    jest-haste-map "^29.5.0"
-    jest-message-util "^29.5.0"
+    jest-config "^29.6.2"
+    jest-haste-map "^29.6.2"
+    jest-message-util "^29.6.2"
     jest-regex-util "^29.4.3"
-    jest-resolve "^29.5.0"
-    jest-resolve-dependencies "^29.5.0"
-    jest-runner "^29.5.0"
-    jest-runtime "^29.5.0"
-    jest-snapshot "^29.5.0"
-    jest-util "^29.5.0"
-    jest-validate "^29.5.0"
-    jest-watcher "^29.5.0"
+    jest-resolve "^29.6.2"
+    jest-resolve-dependencies "^29.6.2"
+    jest-runner "^29.6.2"
+    jest-runtime "^29.6.2"
+    jest-snapshot "^29.6.2"
+    jest-util "^29.6.2"
+    jest-validate "^29.6.2"
+    jest-watcher "^29.6.2"
     micromatch "^4.0.4"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
     slash "^3.0.0"
     strip-ansi "^6.0.0"
 
-"@jest/environment@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-29.5.0.tgz#9152d56317c1fdb1af389c46640ba74ef0bb4c65"
-  integrity sha512-5FXw2+wD29YU1d4I2htpRX7jYnAyTRjP2CsXQdo9SAM8g3ifxWPSV0HnClSn71xwctr0U3oZIIH+dtbfmnbXVQ==
+"@jest/environment@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-29.6.2.tgz#794c0f769d85e7553439d107d3f43186dc6874a9"
+  integrity sha512-AEcW43C7huGd/vogTddNNTDRpO6vQ2zaQNrttvWV18ArBx9Z56h7BIsXkNFJVOO4/kblWEQz30ckw0+L3izc+Q==
   dependencies:
-    "@jest/fake-timers" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/fake-timers" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
-    jest-mock "^29.5.0"
+    jest-mock "^29.6.2"
 
-"@jest/expect-utils@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/expect-utils/-/expect-utils-29.5.0.tgz#f74fad6b6e20f924582dc8ecbf2cb800fe43a036"
-  integrity sha512-fmKzsidoXQT2KwnrwE0SQq3uj8Z763vzR8LnLBwC2qYWEFpjX8daRsk6rHUM1QvNlEW/UJXNXm59ztmJJWs2Mg==
+"@jest/expect-utils@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/expect-utils/-/expect-utils-29.6.2.tgz#1b97f290d0185d264dd9fdec7567a14a38a90534"
+  integrity sha512-6zIhM8go3RV2IG4aIZaZbxwpOzz3ZiM23oxAlkquOIole+G6TrbeXnykxWYlqF7kz2HlBjdKtca20x9atkEQYg==
   dependencies:
     jest-get-type "^29.4.3"
 
-"@jest/expect@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/expect/-/expect-29.5.0.tgz#80952f5316b23c483fbca4363ce822af79c38fba"
-  integrity sha512-PueDR2HGihN3ciUNGr4uelropW7rqUfTiOn+8u0leg/42UhblPxHkfoh0Ruu3I9Y1962P3u2DY4+h7GVTSVU6g==
+"@jest/expect@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/expect/-/expect-29.6.2.tgz#5a2ad58bb345165d9ce0a1845bbf873c480a4b28"
+  integrity sha512-m6DrEJxVKjkELTVAztTLyS/7C92Y2b0VYqmDROYKLLALHn8T/04yPs70NADUYPrV3ruI+H3J0iUIuhkjp7vkfg==
   dependencies:
-    expect "^29.5.0"
-    jest-snapshot "^29.5.0"
+    expect "^29.6.2"
+    jest-snapshot "^29.6.2"
 
-"@jest/fake-timers@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-29.5.0.tgz#d4d09ec3286b3d90c60bdcd66ed28d35f1b4dc2c"
-  integrity sha512-9ARvuAAQcBwDAqOnglWq2zwNIRUDtk/SCkp/ToGEhFv5r86K21l+VEs0qNTaXtyiY0lEePl3kylijSYJQqdbDg==
+"@jest/fake-timers@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-29.6.2.tgz#fe9d43c5e4b1b901168fe6f46f861b3e652a2df4"
+  integrity sha512-euZDmIlWjm1Z0lJ1D0f7a0/y5Kh/koLFMUBE5SUYWrmy8oNhJpbTBDAP6CxKnadcMLDoDf4waRYCe35cH6G6PA==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     "@sinonjs/fake-timers" "^10.0.2"
     "@types/node" "*"
-    jest-message-util "^29.5.0"
-    jest-mock "^29.5.0"
-    jest-util "^29.5.0"
+    jest-message-util "^29.6.2"
+    jest-mock "^29.6.2"
+    jest-util "^29.6.2"
 
-"@jest/globals@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-29.5.0.tgz#6166c0bfc374c58268677539d0c181f9c1833298"
-  integrity sha512-S02y0qMWGihdzNbUiqSAiKSpSozSuHX5UYc7QbnHP+D9Lyw8DgGGCinrN9uSuHPeKgSSzvPom2q1nAtBvUsvPQ==
+"@jest/globals@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-29.6.2.tgz#74af81b9249122cc46f1eb25793617eec69bf21a"
+  integrity sha512-cjuJmNDjs6aMijCmSa1g2TNG4Lby/AeU7/02VtpW+SLcZXzOLK2GpN2nLqcFjmhy3B3AoPeQVx7BnyOf681bAw==
   dependencies:
-    "@jest/environment" "^29.5.0"
-    "@jest/expect" "^29.5.0"
-    "@jest/types" "^29.5.0"
-    jest-mock "^29.5.0"
+    "@jest/environment" "^29.6.2"
+    "@jest/expect" "^29.6.2"
+    "@jest/types" "^29.6.1"
+    jest-mock "^29.6.2"
 
-"@jest/reporters@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-29.5.0.tgz#985dfd91290cd78ddae4914ba7921bcbabe8ac9b"
-  integrity sha512-D05STXqj/M8bP9hQNSICtPqz97u7ffGzZu+9XLucXhkOFBqKcXe04JLZOgIekOxdb73MAoBUFnqvf7MCpKk5OA==
+"@jest/reporters@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-29.6.2.tgz#524afe1d76da33d31309c2c4a2c8062d0c48780a"
+  integrity sha512-sWtijrvIav8LgfJZlrGCdN0nP2EWbakglJY49J1Y5QihcQLfy7ovyxxjJBRXMNltgt4uPtEcFmIMbVshEDfFWw==
   dependencies:
     "@bcoe/v8-coverage" "^0.2.3"
-    "@jest/console" "^29.5.0"
-    "@jest/test-result" "^29.5.0"
-    "@jest/transform" "^29.5.0"
-    "@jest/types" "^29.5.0"
-    "@jridgewell/trace-mapping" "^0.3.15"
+    "@jest/console" "^29.6.2"
+    "@jest/test-result" "^29.6.2"
+    "@jest/transform" "^29.6.2"
+    "@jest/types" "^29.6.1"
+    "@jridgewell/trace-mapping" "^0.3.18"
     "@types/node" "*"
     chalk "^4.0.0"
     collect-v8-coverage "^1.0.0"
@@ -796,66 +796,66 @@
     istanbul-lib-report "^3.0.0"
     istanbul-lib-source-maps "^4.0.0"
     istanbul-reports "^3.1.3"
-    jest-message-util "^29.5.0"
-    jest-util "^29.5.0"
-    jest-worker "^29.5.0"
+    jest-message-util "^29.6.2"
+    jest-util "^29.6.2"
+    jest-worker "^29.6.2"
     slash "^3.0.0"
     string-length "^4.0.1"
     strip-ansi "^6.0.0"
     v8-to-istanbul "^9.0.1"
 
-"@jest/schemas@^29.4.3":
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.4.3.tgz#39cf1b8469afc40b6f5a2baaa146e332c4151788"
-  integrity sha512-VLYKXQmtmuEz6IxJsrZwzG9NvtkQsWNnWMsKxqWNu3+CnfzJQhp0WDDKWLVV9hLKr0l3SLLFRqcYHjhtyuDVxg==
+"@jest/schemas@^29.6.0":
+  version "29.6.0"
+  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.0.tgz#0f4cb2c8e3dca80c135507ba5635a4fd755b0040"
+  integrity sha512-rxLjXyJBTL4LQeJW3aKo0M/+GkCOXsO+8i9Iu7eDb6KwtP65ayoDsitrdPBtujxQ88k4wI2FNYfa6TOGwSn6cQ==
   dependencies:
-    "@sinclair/typebox" "^0.25.16"
+    "@sinclair/typebox" "^0.27.8"
 
-"@jest/source-map@^29.4.3":
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-29.4.3.tgz#ff8d05cbfff875d4a791ab679b4333df47951d20"
-  integrity sha512-qyt/mb6rLyd9j1jUts4EQncvS6Yy3PM9HghnNv86QBlV+zdL2inCdK1tuVlL+J+lpiw2BI67qXOrX3UurBqQ1w==
+"@jest/source-map@^29.6.0":
+  version "29.6.0"
+  resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-29.6.0.tgz#bd34a05b5737cb1a99d43e1957020ac8e5b9ddb1"
+  integrity sha512-oA+I2SHHQGxDCZpbrsCQSoMLb3Bz547JnM+jUr9qEbuw0vQlWZfpPS7CO9J7XiwKicEz9OFn/IYoLkkiUD7bzA==
   dependencies:
-    "@jridgewell/trace-mapping" "^0.3.15"
+    "@jridgewell/trace-mapping" "^0.3.18"
     callsites "^3.0.0"
     graceful-fs "^4.2.9"
 
-"@jest/test-result@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-29.5.0.tgz#7c856a6ca84f45cc36926a4e9c6b57f1973f1408"
-  integrity sha512-fGl4rfitnbfLsrfx1uUpDEESS7zM8JdgZgOCQuxQvL1Sn/I6ijeAVQWGfXI9zb1i9Mzo495cIpVZhA0yr60PkQ==
+"@jest/test-result@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-29.6.2.tgz#fdd11583cd1608e4db3114e8f0cce277bf7a32ed"
+  integrity sha512-3VKFXzcV42EYhMCsJQURptSqnyjqCGbtLuX5Xxb6Pm6gUf1wIRIl+mandIRGJyWKgNKYF9cnstti6Ls5ekduqw==
   dependencies:
-    "@jest/console" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/console" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/istanbul-lib-coverage" "^2.0.0"
     collect-v8-coverage "^1.0.0"
 
-"@jest/test-sequencer@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-29.5.0.tgz#34d7d82d3081abd523dbddc038a3ddcb9f6d3cc4"
-  integrity sha512-yPafQEcKjkSfDXyvtgiV4pevSeyuA6MQr6ZIdVkWJly9vkqjnFfcfhRQqpD5whjoU8EORki752xQmjaqoFjzMQ==
+"@jest/test-sequencer@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-29.6.2.tgz#585eff07a68dd75225a7eacf319780cb9f6b9bf4"
+  integrity sha512-GVYi6PfPwVejO7slw6IDO0qKVum5jtrJ3KoLGbgBWyr2qr4GaxFV6su+ZAjdTX75Sr1DkMFRk09r2ZVa+wtCGw==
   dependencies:
-    "@jest/test-result" "^29.5.0"
+    "@jest/test-result" "^29.6.2"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.5.0"
+    jest-haste-map "^29.6.2"
     slash "^3.0.0"
 
-"@jest/transform@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-29.5.0.tgz#cf9c872d0965f0cbd32f1458aa44a2b1988b00f9"
-  integrity sha512-8vbeZWqLJOvHaDfeMuoHITGKSz5qWc9u04lnWrQE3VyuSw604PzQM824ZeX9XSjUCeDiE3GuxZe5UKa8J61NQw==
+"@jest/transform@^29.6.2":
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-29.6.2.tgz#522901ebbb211af08835bc3bcdf765ab778094e3"
+  integrity sha512-ZqCqEISr58Ce3U+buNFJYUktLJZOggfyvR+bZMaiV1e8B1SIvJbwZMrYz3gx/KAPn9EXmOmN+uB08yLCjWkQQg==
   dependencies:
     "@babel/core" "^7.11.6"
-    "@jest/types" "^29.5.0"
-    "@jridgewell/trace-mapping" "^0.3.15"
+    "@jest/types" "^29.6.1"
+    "@jridgewell/trace-mapping" "^0.3.18"
     babel-plugin-istanbul "^6.1.1"
     chalk "^4.0.0"
     convert-source-map "^2.0.0"
     fast-json-stable-stringify "^2.1.0"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.5.0"
+    jest-haste-map "^29.6.2"
     jest-regex-util "^29.4.3"
-    jest-util "^29.5.0"
+    jest-util "^29.6.2"
     micromatch "^4.0.4"
     pirates "^4.0.4"
     slash "^3.0.0"
@@ -872,12 +872,12 @@
     "@types/yargs" "^15.0.0"
     chalk "^4.0.0"
 
-"@jest/types@^29.5.0":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.5.0.tgz#f59ef9b031ced83047c67032700d8c807d6e1593"
-  integrity sha512-qbu7kN6czmVRc3xWFQcAN03RAUamgppVUdXrvl1Wr3jlNF93o9mJbGcDWrwGB6ht44u7efB1qCFgVQmca24Uog==
+"@jest/types@^29.5.0", "@jest/types@^29.6.1":
+  version "29.6.1"
+  resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.1.tgz#ae79080278acff0a6af5eb49d063385aaa897bf2"
+  integrity sha512-tPKQNMPuXgvdOn2/Lg9HNfUvjYVGolt04Hp03f5hAk878uwOLikN+JzeLY0HcVgKgFl9Hs3EIqpu3WX27XNhnw==
   dependencies:
-    "@jest/schemas" "^29.4.3"
+    "@jest/schemas" "^29.6.0"
     "@types/istanbul-lib-coverage" "^2.0.0"
     "@types/istanbul-reports" "^3.0.0"
     "@types/node" "*"
@@ -898,7 +898,7 @@
   resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78"
   integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==
 
-"@jridgewell/resolve-uri@^3.0.3":
+"@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0":
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721"
   integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==
@@ -921,7 +921,7 @@
   resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24"
   integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==
 
-"@jridgewell/sourcemap-codec@^1.4.10":
+"@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14":
   version "1.4.15"
   resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
   integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
@@ -934,7 +934,7 @@
     "@jridgewell/resolve-uri" "^3.0.3"
     "@jridgewell/sourcemap-codec" "^1.4.10"
 
-"@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.15", "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9":
+"@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9":
   version "0.3.18"
   resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz#25783b2086daf6ff1dcb53c9249ae480e4dd4cd6"
   integrity sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==
@@ -942,6 +942,14 @@
     "@jridgewell/resolve-uri" "3.1.0"
     "@jridgewell/sourcemap-codec" "1.4.14"
 
+"@jridgewell/trace-mapping@^0.3.18":
+  version "0.3.19"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.19.tgz#f8a3249862f91be48d3127c3cfe992f79b4b8811"
+  integrity sha512-kf37QtfW+Hwx/buWGMPcR60iF9ziHa6r/CZJIHbmcm4+0qrXiVdxegAH0F6yddEVQ7zdkjcGCgCzUu+BcbhQxw==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.1.0"
+    "@jridgewell/sourcemap-codec" "^1.4.14"
+
 "@lerna/child-process@7.0.0":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/@lerna/child-process/-/child-process-7.0.0.tgz#f3b7c04182d5fc05299116f2155a0882a25ee000"
@@ -1314,10 +1322,10 @@
     make-fetch-happen "^11.0.1"
     tuf-js "^1.1.3"
 
-"@sinclair/typebox@^0.25.16":
-  version "0.25.24"
-  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.25.24.tgz#8c7688559979f7079aacaf31aa881c3aa410b718"
-  integrity sha512-XJfwUVUKDHF5ugKwIcxEgc9k8b7HbznCp6eUfWgu710hMPNIO4aw4/zB5RogDQz8nd6gyCDpU9O/m6qYEWY6yQ==
+"@sinclair/typebox@^0.27.8":
+  version "0.27.8"
+  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
+  integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==
 
 "@sinonjs/commons@^3.0.0":
   version "3.0.0"
@@ -1479,10 +1487,10 @@
   dependencies:
     "@types/istanbul-lib-report" "*"
 
-"@types/jest@29.5.2":
-  version "29.5.2"
-  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-29.5.2.tgz#86b4afc86e3a8f3005b297ed8a72494f89e6395b"
-  integrity sha512-mSoZVJF5YzGVCk+FsDxzDuH7s+SCkzrgKZzf0Z0T2WudhBUPoF6ktoTPC4R0ZoCPCV5xUvuU6ias5NvxcBcMMg==
+"@types/jest@29.5.3":
+  version "29.5.3"
+  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-29.5.3.tgz#7a35dc0044ffb8b56325c6802a4781a626b05777"
+  integrity sha512-1Nq7YrO/vJE/FYnqYyw0FS8LdrjExSgIiHyKg7xPpn+yi8Q4huZryKnkJatN1ZRH89Kw2v33/8ZMB7DuZeSLlA==
   dependencies:
     expect "^29.0.0"
     pretty-format "^29.0.0"
@@ -1527,11 +1535,6 @@
   resolved "https://registry.yarnpkg.com/@types/pad-left/-/pad-left-2.1.1.tgz#17d906fc75804e1cc722da73623f1d978f16a137"
   integrity sha512-Xd22WCRBydkGSApl5Bw0PhAOHKSVjNL3E3AwzKaps96IMraPqy5BvZIsBVK6JLwdybUzjHnuWVwpDd0JjTfHXA==
 
-"@types/prettier@^2.1.5":
-  version "2.7.3"
-  resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-2.7.3.tgz#3e51a17e291d01d17d3fc61422015a933af7a08f"
-  integrity sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==
-
 "@types/randomatic@3.1.3":
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/@types/randomatic/-/randomatic-3.1.3.tgz#5475c29e82cb8dab6c94e55e77306c8eedab2d1f"
@@ -2220,12 +2223,12 @@ axios@^1.0.0:
     form-data "^4.0.0"
     proxy-from-env "^1.1.0"
 
-babel-jest@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-29.5.0.tgz#3fe3ddb109198e78b1c88f9ebdecd5e4fc2f50a5"
-  integrity sha512-mA4eCDh5mSo2EcA9xQjVTpmbbNk32Zb3Q3QFQsNhaK56Q+yoXowzFodLux30HRgyOho5rsQ6B0P9QpMkvvnJ0Q==
+babel-jest@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-29.6.2.tgz#cada0a59e07f5acaeb11cbae7e3ba92aec9c1126"
+  integrity sha512-BYCzImLos6J3BH/+HvUCHG1dTf2MzmAB4jaVxHV+29RZLjR29XuYTmsf2sdDwkrb+FczkGo3kOhE7ga6sI0P4A==
   dependencies:
-    "@jest/transform" "^29.5.0"
+    "@jest/transform" "^29.6.2"
     "@types/babel__core" "^7.1.14"
     babel-plugin-istanbul "^6.1.1"
     babel-preset-jest "^29.5.0"
@@ -3169,11 +3172,16 @@ decode-uri-component@^0.2.0:
   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.2.tgz#e69dbe25d37941171dd540e024c444cd5188e1e9"
   integrity sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==
 
-dedent@0.7.0, dedent@^0.7.0:
+dedent@0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
   integrity sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==
 
+dedent@^1.0.0:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/dedent/-/dedent-1.5.1.tgz#4f3fc94c8b711e9bb2800d185cd6ad20f2a90aff"
+  integrity sha512-+LxW+KLWxu3HW3M2w2ympwtqPrqYRzU8fqi6Fhd18fBALe15blJPI/I4+UHveMVG6lJqB4JNd4UG0S5cnVHwIg==
+
 deep-is@^0.1.3:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
@@ -3796,16 +3804,17 @@ expand-tilde@^2.0.0, expand-tilde@^2.0.2:
   dependencies:
     homedir-polyfill "^1.0.1"
 
-expect@^29.0.0, expect@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/expect/-/expect-29.5.0.tgz#68c0509156cb2a0adb8865d413b137eeaae682f7"
-  integrity sha512-yM7xqUrCO2JdpFo4XpM82t+PJBFybdqoQuJLDGeDX2ij8NZzqRHyu3Hp188/JX7SWqud+7t4MUdvcgGBICMHZg==
+expect@^29.0.0, expect@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/expect/-/expect-29.6.2.tgz#7b08e83eba18ddc4a2cf62b5f2d1918f5cd84521"
+  integrity sha512-iAErsLxJ8C+S02QbLAwgSGSezLQK+XXRDt8IuFXFpwCNw2ECmzZSmjKcCaFVp5VRMk+WAvz6h6jokzEzBFZEuA==
   dependencies:
-    "@jest/expect-utils" "^29.5.0"
+    "@jest/expect-utils" "^29.6.2"
+    "@types/node" "*"
     jest-get-type "^29.4.3"
-    jest-matcher-utils "^29.5.0"
-    jest-message-util "^29.5.0"
-    jest-util "^29.5.0"
+    jest-matcher-utils "^29.6.2"
+    jest-message-util "^29.6.2"
+    jest-util "^29.6.2"
 
 ext@^1.1.2:
   version "1.7.0"
@@ -5376,79 +5385,79 @@ jest-changed-files@^29.5.0:
     execa "^5.0.0"
     p-limit "^3.1.0"
 
-jest-circus@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-circus/-/jest-circus-29.5.0.tgz#b5926989449e75bff0d59944bae083c9d7fb7317"
-  integrity sha512-gq/ongqeQKAplVxqJmbeUOJJKkW3dDNPY8PjhJ5G0lBRvu0e3EWGxGy5cI4LAGA7gV2UHCtWBI4EMXK8c9nQKA==
+jest-circus@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-circus/-/jest-circus-29.6.2.tgz#1e6ffca60151ac66cad63fce34f443f6b5bb4258"
+  integrity sha512-G9mN+KOYIUe2sB9kpJkO9Bk18J4dTDArNFPwoZ7WKHKel55eKIS/u2bLthxgojwlf9NLCVQfgzM/WsOVvoC6Fw==
   dependencies:
-    "@jest/environment" "^29.5.0"
-    "@jest/expect" "^29.5.0"
-    "@jest/test-result" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/environment" "^29.6.2"
+    "@jest/expect" "^29.6.2"
+    "@jest/test-result" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     chalk "^4.0.0"
     co "^4.6.0"
-    dedent "^0.7.0"
+    dedent "^1.0.0"
     is-generator-fn "^2.0.0"
-    jest-each "^29.5.0"
-    jest-matcher-utils "^29.5.0"
-    jest-message-util "^29.5.0"
-    jest-runtime "^29.5.0"
-    jest-snapshot "^29.5.0"
-    jest-util "^29.5.0"
+    jest-each "^29.6.2"
+    jest-matcher-utils "^29.6.2"
+    jest-message-util "^29.6.2"
+    jest-runtime "^29.6.2"
+    jest-snapshot "^29.6.2"
+    jest-util "^29.6.2"
     p-limit "^3.1.0"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
     pure-rand "^6.0.0"
     slash "^3.0.0"
     stack-utils "^2.0.3"
 
-jest-cli@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-29.5.0.tgz#b34c20a6d35968f3ee47a7437ff8e53e086b4a67"
-  integrity sha512-L1KcP1l4HtfwdxXNFCL5bmUbLQiKrakMUriBEcc1Vfz6gx31ORKdreuWvmQVBit+1ss9NNR3yxjwfwzZNdQXJw==
+jest-cli@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-29.6.2.tgz#edb381763398d1a292cd1b636a98bfa5644b8fda"
+  integrity sha512-TT6O247v6dCEX2UGHGyflMpxhnrL0DNqP2fRTKYm3nJJpCTfXX3GCMQPGFjXDoj0i5/Blp3jriKXFgdfmbYB6Q==
   dependencies:
-    "@jest/core" "^29.5.0"
-    "@jest/test-result" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/core" "^29.6.2"
+    "@jest/test-result" "^29.6.2"
+    "@jest/types" "^29.6.1"
     chalk "^4.0.0"
     exit "^0.1.2"
     graceful-fs "^4.2.9"
     import-local "^3.0.2"
-    jest-config "^29.5.0"
-    jest-util "^29.5.0"
-    jest-validate "^29.5.0"
+    jest-config "^29.6.2"
+    jest-util "^29.6.2"
+    jest-validate "^29.6.2"
     prompts "^2.0.1"
     yargs "^17.3.1"
 
-jest-config@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-29.5.0.tgz#3cc972faec8c8aaea9ae158c694541b79f3748da"
-  integrity sha512-kvDUKBnNJPNBmFFOhDbm59iu1Fii1Q6SxyhXfvylq3UTHbg6o7j/g8k2dZyXWLvfdKB1vAPxNZnMgtKJcmu3kA==
+jest-config@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-29.6.2.tgz#c68723f06b31ca5e63030686e604727d406cd7c3"
+  integrity sha512-VxwFOC8gkiJbuodG9CPtMRjBUNZEHxwfQXmIudSTzFWxaci3Qub1ddTRbFNQlD/zUeaifLndh/eDccFX4wCMQw==
   dependencies:
     "@babel/core" "^7.11.6"
-    "@jest/test-sequencer" "^29.5.0"
-    "@jest/types" "^29.5.0"
-    babel-jest "^29.5.0"
+    "@jest/test-sequencer" "^29.6.2"
+    "@jest/types" "^29.6.1"
+    babel-jest "^29.6.2"
     chalk "^4.0.0"
     ci-info "^3.2.0"
     deepmerge "^4.2.2"
     glob "^7.1.3"
     graceful-fs "^4.2.9"
-    jest-circus "^29.5.0"
-    jest-environment-node "^29.5.0"
+    jest-circus "^29.6.2"
+    jest-environment-node "^29.6.2"
     jest-get-type "^29.4.3"
     jest-regex-util "^29.4.3"
-    jest-resolve "^29.5.0"
-    jest-runner "^29.5.0"
-    jest-util "^29.5.0"
-    jest-validate "^29.5.0"
+    jest-resolve "^29.6.2"
+    jest-runner "^29.6.2"
+    jest-util "^29.6.2"
+    jest-validate "^29.6.2"
     micromatch "^4.0.4"
     parse-json "^5.2.0"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
     slash "^3.0.0"
     strip-json-comments "^3.1.1"
 
-"jest-diff@>=29.4.3 < 30", jest-diff@^29.5.0:
+"jest-diff@>=29.4.3 < 30":
   version "29.5.0"
   resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.5.0.tgz#e0d83a58eb5451dcc1fa61b1c3ee4e8f5a290d63"
   integrity sha512-LtxijLLZBduXnHSniy0WMdaHjmQnt3g5sa16W4p0HqukYTTsyTW3GD1q41TyGl5YFXj/5B2U6dlh5FM1LIMgxw==
@@ -5458,6 +5467,16 @@ jest-config@^29.5.0:
     jest-get-type "^29.4.3"
     pretty-format "^29.5.0"
 
+jest-diff@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.6.2.tgz#c36001e5543e82a0805051d3ceac32e6825c1c46"
+  integrity sha512-t+ST7CB9GX5F2xKwhwCf0TAR17uNDiaPTZnVymP9lw0lssa9vG+AFyDZoeIHStU3WowFFwT+ky+er0WVl2yGhA==
+  dependencies:
+    chalk "^4.0.0"
+    diff-sequences "^29.4.3"
+    jest-get-type "^29.4.3"
+    pretty-format "^29.6.2"
+
 jest-docblock@^29.4.3:
   version "29.4.3"
   resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-29.4.3.tgz#90505aa89514a1c7dceeac1123df79e414636ea8"
@@ -5465,94 +5484,94 @@ jest-docblock@^29.4.3:
   dependencies:
     detect-newline "^3.0.0"
 
-jest-each@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-29.5.0.tgz#fc6e7014f83eac68e22b7195598de8554c2e5c06"
-  integrity sha512-HM5kIJ1BTnVt+DQZ2ALp3rzXEl+g726csObrW/jpEGl+CDSSQpOJJX2KE/vEg8cxcMXdyEPu6U4QX5eruQv5hA==
+jest-each@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-29.6.2.tgz#c9e4b340bcbe838c73adf46b76817b15712d02ce"
+  integrity sha512-MsrsqA0Ia99cIpABBc3izS1ZYoYfhIy0NNWqPSE0YXbQjwchyt6B1HD2khzyPe1WiJA7hbxXy77ZoUQxn8UlSw==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     chalk "^4.0.0"
     jest-get-type "^29.4.3"
-    jest-util "^29.5.0"
-    pretty-format "^29.5.0"
+    jest-util "^29.6.2"
+    pretty-format "^29.6.2"
 
-jest-environment-node@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-29.5.0.tgz#f17219d0f0cc0e68e0727c58b792c040e332c967"
-  integrity sha512-ExxuIK/+yQ+6PRGaHkKewYtg6hto2uGCgvKdb2nfJfKXgZ17DfXjvbZ+jA1Qt9A8EQSfPnt5FKIfnOO3u1h9qw==
+jest-environment-node@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-29.6.2.tgz#a9ea2cabff39b08eca14ccb32c8ceb924c8bb1ad"
+  integrity sha512-YGdFeZ3T9a+/612c5mTQIllvWkddPbYcN2v95ZH24oWMbGA4GGS2XdIF92QMhUhvrjjuQWYgUGW2zawOyH63MQ==
   dependencies:
-    "@jest/environment" "^29.5.0"
-    "@jest/fake-timers" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/environment" "^29.6.2"
+    "@jest/fake-timers" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
-    jest-mock "^29.5.0"
-    jest-util "^29.5.0"
+    jest-mock "^29.6.2"
+    jest-util "^29.6.2"
 
 jest-get-type@^29.4.3:
   version "29.4.3"
   resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-29.4.3.tgz#1ab7a5207c995161100b5187159ca82dd48b3dd5"
   integrity sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==
 
-jest-haste-map@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-29.5.0.tgz#69bd67dc9012d6e2723f20a945099e972b2e94de"
-  integrity sha512-IspOPnnBro8YfVYSw6yDRKh/TiCdRngjxeacCps1cQ9cgVN6+10JUcuJ1EabrgYLOATsIAigxA0rLR9x/YlrSA==
+jest-haste-map@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-29.6.2.tgz#298c25ea5255cfad8b723179d4295cf3a50a70d1"
+  integrity sha512-+51XleTDAAysvU8rT6AnS1ZJ+WHVNqhj1k6nTvN2PYP+HjU3kqlaKQ1Lnw3NYW3bm2r8vq82X0Z1nDDHZMzHVA==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     "@types/graceful-fs" "^4.1.3"
     "@types/node" "*"
     anymatch "^3.0.3"
     fb-watchman "^2.0.0"
     graceful-fs "^4.2.9"
     jest-regex-util "^29.4.3"
-    jest-util "^29.5.0"
-    jest-worker "^29.5.0"
+    jest-util "^29.6.2"
+    jest-worker "^29.6.2"
     micromatch "^4.0.4"
     walker "^1.0.8"
   optionalDependencies:
     fsevents "^2.3.2"
 
-jest-leak-detector@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-29.5.0.tgz#cf4bdea9615c72bac4a3a7ba7e7930f9c0610c8c"
-  integrity sha512-u9YdeeVnghBUtpN5mVxjID7KbkKE1QU4f6uUwuxiY0vYRi9BUCLKlPEZfDGR67ofdFmDz9oPAy2G92Ujrntmow==
+jest-leak-detector@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-29.6.2.tgz#e2b307fee78cab091c37858a98c7e1d73cdf5b38"
+  integrity sha512-aNqYhfp5uYEO3tdWMb2bfWv6f0b4I0LOxVRpnRLAeque2uqOVVMLh6khnTcE2qJ5wAKop0HcreM1btoysD6bPQ==
   dependencies:
     jest-get-type "^29.4.3"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
 
-jest-matcher-utils@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-29.5.0.tgz#d957af7f8c0692c5453666705621ad4abc2c59c5"
-  integrity sha512-lecRtgm/rjIK0CQ7LPQwzCs2VwW6WAahA55YBuI+xqmhm7LAaxokSB8C97yJeYyT+HvQkH741StzpU41wohhWw==
+jest-matcher-utils@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-29.6.2.tgz#39de0be2baca7a64eacb27291f0bd834fea3a535"
+  integrity sha512-4LiAk3hSSobtomeIAzFTe+N8kL6z0JtF3n6I4fg29iIW7tt99R7ZcIFW34QkX+DuVrf+CUe6wuVOpm7ZKFJzZQ==
   dependencies:
     chalk "^4.0.0"
-    jest-diff "^29.5.0"
+    jest-diff "^29.6.2"
     jest-get-type "^29.4.3"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
 
-jest-message-util@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-29.5.0.tgz#1f776cac3aca332ab8dd2e3b41625435085c900e"
-  integrity sha512-Kijeg9Dag6CKtIDA7O21zNTACqD5MD/8HfIV8pdD94vFyFuer52SigdC3IQMhab3vACxXMiFk+yMHNdbqtyTGA==
+jest-message-util@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-29.6.2.tgz#af7adc2209c552f3f5ae31e77cf0a261f23dc2bb"
+  integrity sha512-vnIGYEjoPSuRqV8W9t+Wow95SDp6KPX2Uf7EoeG9G99J2OVh7OSwpS4B6J0NfpEIpfkBNHlBZpA2rblEuEFhZQ==
   dependencies:
     "@babel/code-frame" "^7.12.13"
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     "@types/stack-utils" "^2.0.0"
     chalk "^4.0.0"
     graceful-fs "^4.2.9"
     micromatch "^4.0.4"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
     slash "^3.0.0"
     stack-utils "^2.0.3"
 
-jest-mock@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-29.5.0.tgz#26e2172bcc71d8b0195081ff1f146ac7e1518aed"
-  integrity sha512-GqOzvdWDE4fAV2bWQLQCkujxYWL7RxjCnj71b5VhDAGOevB3qj3Ovg26A5NI84ZpODxyzaozXLOh2NCgkbvyaw==
+jest-mock@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-29.6.2.tgz#ef9c9b4d38c34a2ad61010a021866dad41ce5e00"
+  integrity sha512-hoSv3lb3byzdKfwqCuT6uTscan471GUECqgNYykg6ob0yiAw3zYc7OrPnI9Qv8Wwoa4lC7AZ9hyS4AiIx5U2zg==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
-    jest-util "^29.5.0"
+    jest-util "^29.6.2"
 
 jest-pnp-resolver@^1.2.2:
   version "1.2.3"
@@ -5564,81 +5583,81 @@ jest-regex-util@^29.4.3:
   resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-29.4.3.tgz#a42616141e0cae052cfa32c169945d00c0aa0bb8"
   integrity sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==
 
-jest-resolve-dependencies@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-29.5.0.tgz#f0ea29955996f49788bf70996052aa98e7befee4"
-  integrity sha512-sjV3GFr0hDJMBpYeUuGduP+YeCRbd7S/ck6IvL3kQ9cpySYKqcqhdLLC2rFwrcL7tz5vYibomBrsFYWkIGGjOg==
+jest-resolve-dependencies@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-29.6.2.tgz#36435269b6672c256bcc85fb384872c134cc4cf2"
+  integrity sha512-LGqjDWxg2fuQQm7ypDxduLu/m4+4Lb4gczc13v51VMZbVP5tSBILqVx8qfWcsdP8f0G7aIqByIALDB0R93yL+w==
   dependencies:
     jest-regex-util "^29.4.3"
-    jest-snapshot "^29.5.0"
+    jest-snapshot "^29.6.2"
 
-jest-resolve@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-29.5.0.tgz#b053cc95ad1d5f6327f0ac8aae9f98795475ecdc"
-  integrity sha512-1TzxJ37FQq7J10jPtQjcc+MkCkE3GBpBecsSUWJ0qZNJpmg6m0D9/7II03yJulm3H/fvVjgqLh/k2eYg+ui52w==
+jest-resolve@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-29.6.2.tgz#f18405fe4b50159b7b6d85e81f6a524d22afb838"
+  integrity sha512-G/iQUvZWI5e3SMFssc4ug4dH0aZiZpsDq9o1PtXTV1210Ztyb2+w+ZgQkB3iOiC5SmAEzJBOHWz6Hvrd+QnNPw==
   dependencies:
     chalk "^4.0.0"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.5.0"
+    jest-haste-map "^29.6.2"
     jest-pnp-resolver "^1.2.2"
-    jest-util "^29.5.0"
-    jest-validate "^29.5.0"
+    jest-util "^29.6.2"
+    jest-validate "^29.6.2"
     resolve "^1.20.0"
     resolve.exports "^2.0.0"
     slash "^3.0.0"
 
-jest-runner@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-29.5.0.tgz#6a57c282eb0ef749778d444c1d758c6a7693b6f8"
-  integrity sha512-m7b6ypERhFghJsslMLhydaXBiLf7+jXy8FwGRHO3BGV1mcQpPbwiqiKUR2zU2NJuNeMenJmlFZCsIqzJCTeGLQ==
+jest-runner@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-29.6.2.tgz#89e8e32a8fef24781a7c4c49cd1cb6358ac7fc01"
+  integrity sha512-wXOT/a0EspYgfMiYHxwGLPCZfC0c38MivAlb2lMEAlwHINKemrttu1uSbcGbfDV31sFaPWnWJPmb2qXM8pqZ4w==
   dependencies:
-    "@jest/console" "^29.5.0"
-    "@jest/environment" "^29.5.0"
-    "@jest/test-result" "^29.5.0"
-    "@jest/transform" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/console" "^29.6.2"
+    "@jest/environment" "^29.6.2"
+    "@jest/test-result" "^29.6.2"
+    "@jest/transform" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     chalk "^4.0.0"
     emittery "^0.13.1"
     graceful-fs "^4.2.9"
     jest-docblock "^29.4.3"
-    jest-environment-node "^29.5.0"
-    jest-haste-map "^29.5.0"
-    jest-leak-detector "^29.5.0"
-    jest-message-util "^29.5.0"
-    jest-resolve "^29.5.0"
-    jest-runtime "^29.5.0"
-    jest-util "^29.5.0"
-    jest-watcher "^29.5.0"
-    jest-worker "^29.5.0"
+    jest-environment-node "^29.6.2"
+    jest-haste-map "^29.6.2"
+    jest-leak-detector "^29.6.2"
+    jest-message-util "^29.6.2"
+    jest-resolve "^29.6.2"
+    jest-runtime "^29.6.2"
+    jest-util "^29.6.2"
+    jest-watcher "^29.6.2"
+    jest-worker "^29.6.2"
     p-limit "^3.1.0"
     source-map-support "0.5.13"
 
-jest-runtime@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-29.5.0.tgz#c83f943ee0c1da7eb91fa181b0811ebd59b03420"
-  integrity sha512-1Hr6Hh7bAgXQP+pln3homOiEZtCDZFqwmle7Ew2j8OlbkIu6uE3Y/etJQG8MLQs3Zy90xrp2C0BRrtPHG4zryw==
-  dependencies:
-    "@jest/environment" "^29.5.0"
-    "@jest/fake-timers" "^29.5.0"
-    "@jest/globals" "^29.5.0"
-    "@jest/source-map" "^29.4.3"
-    "@jest/test-result" "^29.5.0"
-    "@jest/transform" "^29.5.0"
-    "@jest/types" "^29.5.0"
+jest-runtime@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-29.6.2.tgz#692f25e387f982e89ab83270e684a9786248e545"
+  integrity sha512-2X9dqK768KufGJyIeLmIzToDmsN0m7Iek8QNxRSI/2+iPFYHF0jTwlO3ftn7gdKd98G/VQw9XJCk77rbTGZnJg==
+  dependencies:
+    "@jest/environment" "^29.6.2"
+    "@jest/fake-timers" "^29.6.2"
+    "@jest/globals" "^29.6.2"
+    "@jest/source-map" "^29.6.0"
+    "@jest/test-result" "^29.6.2"
+    "@jest/transform" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     chalk "^4.0.0"
     cjs-module-lexer "^1.0.0"
     collect-v8-coverage "^1.0.0"
     glob "^7.1.3"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.5.0"
-    jest-message-util "^29.5.0"
-    jest-mock "^29.5.0"
+    jest-haste-map "^29.6.2"
+    jest-message-util "^29.6.2"
+    jest-mock "^29.6.2"
     jest-regex-util "^29.4.3"
-    jest-resolve "^29.5.0"
-    jest-snapshot "^29.5.0"
-    jest-util "^29.5.0"
+    jest-resolve "^29.6.2"
+    jest-snapshot "^29.6.2"
+    jest-util "^29.6.2"
     slash "^3.0.0"
     strip-bom "^4.0.0"
 
@@ -5650,34 +5669,31 @@ jest-silent-reporter@0.5.0:
     chalk "^4.0.0"
     jest-util "^26.0.0"
 
-jest-snapshot@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-29.5.0.tgz#c9c1ce0331e5b63cd444e2f95a55a73b84b1e8ce"
-  integrity sha512-x7Wolra5V0tt3wRs3/ts3S6ciSQVypgGQlJpz2rsdQYoUKxMxPNaoHMGJN6qAuPJqS+2iQ1ZUn5kl7HCyls84g==
+jest-snapshot@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-29.6.2.tgz#9b431b561a83f2bdfe041e1cab8a6becdb01af9c"
+  integrity sha512-1OdjqvqmRdGNvWXr/YZHuyhh5DeaLp1p/F8Tht/MrMw4Kr1Uu/j4lRG+iKl1DAqUJDWxtQBMk41Lnf/JETYBRA==
   dependencies:
     "@babel/core" "^7.11.6"
     "@babel/generator" "^7.7.2"
     "@babel/plugin-syntax-jsx" "^7.7.2"
     "@babel/plugin-syntax-typescript" "^7.7.2"
-    "@babel/traverse" "^7.7.2"
     "@babel/types" "^7.3.3"
-    "@jest/expect-utils" "^29.5.0"
-    "@jest/transform" "^29.5.0"
-    "@jest/types" "^29.5.0"
-    "@types/babel__traverse" "^7.0.6"
-    "@types/prettier" "^2.1.5"
+    "@jest/expect-utils" "^29.6.2"
+    "@jest/transform" "^29.6.2"
+    "@jest/types" "^29.6.1"
     babel-preset-current-node-syntax "^1.0.0"
     chalk "^4.0.0"
-    expect "^29.5.0"
+    expect "^29.6.2"
     graceful-fs "^4.2.9"
-    jest-diff "^29.5.0"
+    jest-diff "^29.6.2"
     jest-get-type "^29.4.3"
-    jest-matcher-utils "^29.5.0"
-    jest-message-util "^29.5.0"
-    jest-util "^29.5.0"
+    jest-matcher-utils "^29.6.2"
+    jest-message-util "^29.6.2"
+    jest-util "^29.6.2"
     natural-compare "^1.4.0"
-    pretty-format "^29.5.0"
-    semver "^7.3.5"
+    pretty-format "^29.6.2"
+    semver "^7.5.3"
 
 jest-util@^26.0.0:
   version "26.6.2"
@@ -5691,7 +5707,7 @@ jest-util@^26.0.0:
     is-ci "^2.0.0"
     micromatch "^4.0.2"
 
-jest-util@^29.0.0, jest-util@^29.5.0:
+jest-util@^29.0.0:
   version "29.5.0"
   resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.5.0.tgz#24a4d3d92fc39ce90425311b23c27a6e0ef16b8f"
   integrity sha512-RYMgG/MTadOr5t8KdhejfvUU82MxsCu5MF6KuDUHl+NuwzUt+Sm6jJWxTJVrDR1j5M/gJVCPKQEpWXY+yIQ6lQ==
@@ -5703,30 +5719,42 @@ jest-util@^29.0.0, jest-util@^29.5.0:
     graceful-fs "^4.2.9"
     picomatch "^2.2.3"
 
-jest-validate@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-29.5.0.tgz#8e5a8f36178d40e47138dc00866a5f3bd9916ffc"
-  integrity sha512-pC26etNIi+y3HV8A+tUGr/lph9B18GnzSRAkPaaZJIE1eFdiYm6/CewuiJQ8/RlfHd1u/8Ioi8/sJ+CmbA+zAQ==
+jest-util@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.6.2.tgz#8a052df8fff2eebe446769fd88814521a517664d"
+  integrity sha512-3eX1qb6L88lJNCFlEADKOkjpXJQyZRiavX1INZ4tRnrBVr2COd3RgcTLyUiEXMNBlDU/cgYq6taUS0fExrWW4w==
   dependencies:
-    "@jest/types" "^29.5.0"
+    "@jest/types" "^29.6.1"
+    "@types/node" "*"
+    chalk "^4.0.0"
+    ci-info "^3.2.0"
+    graceful-fs "^4.2.9"
+    picomatch "^2.2.3"
+
+jest-validate@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-29.6.2.tgz#25d972af35b2415b83b1373baf1a47bb266c1082"
+  integrity sha512-vGz0yMN5fUFRRbpJDPwxMpgSXW1LDKROHfBopAvDcmD6s+B/s8WJrwi+4bfH4SdInBA5C3P3BI19dBtKzx1Arg==
+  dependencies:
+    "@jest/types" "^29.6.1"
     camelcase "^6.2.0"
     chalk "^4.0.0"
     jest-get-type "^29.4.3"
     leven "^3.1.0"
-    pretty-format "^29.5.0"
+    pretty-format "^29.6.2"
 
-jest-watcher@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-29.5.0.tgz#cf7f0f949828ba65ddbbb45c743a382a4d911363"
-  integrity sha512-KmTojKcapuqYrKDpRwfqcQ3zjMlwu27SYext9pt4GlF5FUgB+7XE1mcCnSm6a4uUpFyQIkb6ZhzZvHl+jiBCiA==
+jest-watcher@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-29.6.2.tgz#77c224674f0620d9f6643c4cfca186d8893ca088"
+  integrity sha512-GZitlqkMkhkefjfN/p3SJjrDaxPflqxEAv3/ik10OirZqJGYH5rPiIsgVcfof0Tdqg3shQGdEIxDBx+B4tuLzA==
   dependencies:
-    "@jest/test-result" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/test-result" "^29.6.2"
+    "@jest/types" "^29.6.1"
     "@types/node" "*"
     ansi-escapes "^4.2.1"
     chalk "^4.0.0"
     emittery "^0.13.1"
-    jest-util "^29.5.0"
+    jest-util "^29.6.2"
     string-length "^4.0.1"
 
 jest-worker@^27.4.5:
@@ -5738,25 +5766,25 @@ jest-worker@^27.4.5:
     merge-stream "^2.0.0"
     supports-color "^8.0.0"
 
-jest-worker@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.5.0.tgz#bdaefb06811bd3384d93f009755014d8acb4615d"
-  integrity sha512-NcrQnevGoSp4b5kg+akIpthoAFHxPBcb5P6mYPY0fUNT+sSvmtu6jlkEle3anczUKIKEbMxFimk9oTP/tpIPgA==
+jest-worker@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.6.2.tgz#682fbc4b6856ad0aa122a5403c6d048b83f3fb44"
+  integrity sha512-l3ccBOabTdkng8I/ORCkADz4eSMKejTYv1vB/Z83UiubqhC1oQ5Li6dWCyqOIvSifGjUBxuvxvlm6KGK2DtuAQ==
   dependencies:
     "@types/node" "*"
-    jest-util "^29.5.0"
+    jest-util "^29.6.2"
     merge-stream "^2.0.0"
     supports-color "^8.0.0"
 
-jest@29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest/-/jest-29.5.0.tgz#f75157622f5ce7ad53028f2f8888ab53e1f1f24e"
-  integrity sha512-juMg3he2uru1QoXX078zTa7pO85QyB9xajZc6bU+d9yEGwrKX6+vGmJQ3UdVZsvTEUARIdObzH68QItim6OSSQ==
+jest@29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/jest/-/jest-29.6.2.tgz#3bd55b9fd46a161b2edbdf5f1d1bd0d1eab76c42"
+  integrity sha512-8eQg2mqFbaP7CwfsTpCxQ+sHzw1WuNWL5UUvjnWP4hx2riGz9fPSzYOaU5q8/GqWn1TfgZIVTqYJygbGbWAANg==
   dependencies:
-    "@jest/core" "^29.5.0"
-    "@jest/types" "^29.5.0"
+    "@jest/core" "^29.6.2"
+    "@jest/types" "^29.6.1"
     import-local "^3.0.2"
-    jest-cli "^29.5.0"
+    jest-cli "^29.6.2"
 
 js-tokens@^4.0.0:
   version "4.0.0"
@@ -7540,12 +7568,12 @@ prelude-ls@^1.2.1:
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
-pretty-format@^29.0.0, pretty-format@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.5.0.tgz#283134e74f70e2e3e7229336de0e4fce94ccde5a"
-  integrity sha512-V2mGkI31qdttvTFX7Mt4efOqHXqJWMu4/r66Xh3Z3BwZaPfPJgp6/gbwoujRpPUtfEF6AUUWx3Jim3GCw5g/Qw==
+pretty-format@^29.0.0, pretty-format@^29.5.0, pretty-format@^29.6.2:
+  version "29.6.2"
+  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.6.2.tgz#3d5829261a8a4d89d8b9769064b29c50ed486a47"
+  integrity sha512-1q0oC8eRveTg5nnBEWMXAU2qpv65Gnuf2eCQzSjxpWFkPaPARwqZZDGuNE0zPAZfTCHzIk3A8dIjwlQKKLphyg==
   dependencies:
-    "@jest/schemas" "^29.4.3"
+    "@jest/schemas" "^29.6.0"
     ansi-styles "^5.0.0"
     react-is "^18.0.0"
 
@@ -8104,7 +8132,7 @@ semver@7.3.4:
   dependencies:
     lru-cache "^6.0.0"
 
-semver@7.x, semver@^7.0.0, semver@^7.1.1, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.3.8:
+semver@7.x, semver@^7.0.0, semver@^7.1.1, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
   version "7.5.4"
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==

From ae43739273547a9266c1e95d152a1eba2ace5429 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 10 Aug 2023 06:18:53 +0900
Subject: [PATCH 131/749] MINOR: [JS] Bump xml2js from 0.6.0 to 0.6.2 in /js
 (#37082)

Bumps [xml2js](https://github.com/Leonidas-from-XIV/node-xml2js) from 0.6.0 to 0.6.2.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/Leonidas-from-XIV/node-xml2js/commit/cf3e061e22e98152b88068c2345bc02581f4d6c7"><code>cf3e061</code></a> New release, 0.6.2</li>
<li><a href="https://github.com/Leonidas-from-XIV/node-xml2js/commit/cb2f77e25c1999fdce952e127d9bed6d87786bb8"><code>cb2f77e</code></a> Fix read-only constraint via mistyped key name</li>
<li><a href="https://github.com/Leonidas-from-XIV/node-xml2js/commit/8e9a1209235406fe10cf96f4d458ce46c94bf412"><code>8e9a120</code></a> Update version number for release 0.6.1</li>
<li><a href="https://github.com/Leonidas-from-XIV/node-xml2js/commit/30f9d61d6fcf42a4361539a81037a3b5bbf2373c"><code>30f9d61</code></a> Replace filtering of names with <code>defineProperty</code></li>
<li><a href="https://github.com/Leonidas-from-XIV/node-xml2js/commit/ba46e543a494eb72eabc8161db135467c4f5394f"><code>ba46e54</code></a> Update package lock</li>
<li>See full diff in <a href="https://github.com/Leonidas-from-XIV/node-xml2js/compare/0.6.0...0.6.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xml2js&package-manager=npm_and_yarn&previous-version=0.6.0&new-version=0.6.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json | 2 +-
 js/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/package.json b/js/package.json
index da1ce744d0334..b1ab023763d34 100644
--- a/js/package.json
+++ b/js/package.json
@@ -117,7 +117,7 @@
     "webpack": "5.86.0",
     "webpack-bundle-analyzer": "4.9.0",
     "webpack-stream": "7.0.0",
-    "xml2js": "0.6.0"
+    "xml2js": "0.6.2"
   },
   "engines": {
     "node": ">=12.0"
diff --git a/js/yarn.lock b/js/yarn.lock
index 43ba5c3c2f5c1..9f8912fab6f0b 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -9582,10 +9582,10 @@ ws@^7.3.1:
   resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
   integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
 
-xml2js@0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/xml2js/-/xml2js-0.6.0.tgz#07afc447a97d2bd6507a1f76eeadddb09f7a8282"
-  integrity sha512-eLTh0kA8uHceqesPqSE+VvO1CDDJWMwlQfB6LuN6T8w6MaDJ8Txm8P7s5cHD0miF0V+GGTZrDQfxPZQVsur33w==
+xml2js@0.6.2:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/xml2js/-/xml2js-0.6.2.tgz#dd0b630083aa09c161e25a4d0901e2b2a929b499"
+  integrity sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==
   dependencies:
     sax ">=0.6.0"
     xmlbuilder "~11.0.0"

From f93929f9b3a0d10f02cc329a092899655c009eda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Wed, 9 Aug 2023 17:48:23 -0400
Subject: [PATCH 132/749] GH-37073: [Java] JDBC: Only use username/pass auth if
 token is not provided (#37083)

### Are these changes tested?

Yes

### Are there any user-facing changes?

Provided token authentication will now take precedence over username/password.
* Closes: #37073

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../client/ArrowFlightSqlClientHandler.java   |  3 +-
 .../arrow/driver/jdbc/ConnectionTest.java     | 30 +++++++++++++++++++
 2 files changed, 32 insertions(+), 1 deletion(-)

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
index dd7adc83d3164..bb1d524aca008 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
@@ -538,7 +538,8 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
       FlightClient client = null;
       try {
         ClientIncomingAuthHeaderMiddleware.Factory authFactory = null;
-        if (username != null) {
+        // Token should take priority since some apps pass in a username/password even when a token is provided
+        if (username != null && token == null) {
           authFactory =
               new ClientIncomingAuthHeaderMiddleware.Factory(new ClientBearerHeaderHandler());
           withMiddlewareFactories(authFactory);
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
index 2472ab8fc581a..bec0ff1e59752 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
@@ -18,6 +18,8 @@
 package org.apache.arrow.driver.jdbc;
 
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 import java.net.URISyntaxException;
 import java.sql.Connection;
@@ -102,6 +104,33 @@ public void testUnencryptedConnectionShouldOpenSuccessfullyWhenProvidedValidCred
     }
   }
 
+  /**
+   * Checks if a token is provided it takes precedence over username/pass. In this case,
+   * the connection should fail if a token is passed in.
+   */
+  @Test
+  public void testTokenOverridesUsernameAndPasswordAuth() {
+    final Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.HOST.camelName(), "localhost");
+    properties.put(ArrowFlightConnectionProperty.PORT.camelName(),
+        FLIGHT_SERVER_TEST_RULE.getPort());
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(),
+        userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(),
+        passTest);
+    properties.put(ArrowFlightConnectionProperty.TOKEN.camelName(), "token");
+    properties.put("useEncryption", false);
+
+    SQLException e = assertThrows(SQLException.class, () ->
+            DriverManager.getConnection(
+                    "jdbc:arrow-flight-sql://" + FLIGHT_SERVER_TEST_RULE.getHost() + ":" +
+                            FLIGHT_SERVER_TEST_RULE.getPort(),
+                    properties));
+    assertTrue(e.getMessage().contains("UNAUTHENTICATED"));
+  }
+
+
   /**
    * Checks if the exception SQLException is thrown when trying to establish a connection without a host.
    *
@@ -136,6 +165,7 @@ public void testGetBasicClientAuthenticatedShouldOpenConnection()
                  .withPassword(passTest)
                  .withBufferAllocator(allocator)
                  .build()) {
+
       assertNotNull(client);
     }
   }

From ebcf7bc25fcd47137523cb934a740cac0fc0fb76 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Thu, 10 Aug 2023 19:53:22 +0800
Subject: [PATCH 133/749] GH-36905: [C++] Add support for SparseUnion to
 selection functions (#36906)

### Rationale for this change

Dense unions are already supported in Take, Filter and DropNull but sparse ones are not.

### What changes are included in this PR?

Add kernels for sparse unions to those functions.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #36905

Lead-authored-by: Jin Shang <shangjin1997@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../vector_selection_filter_internal.cc       | 34 +++++---
 .../kernels/vector_selection_internal.cc      | 73 +++++++++++++++--
 .../kernels/vector_selection_internal.h       | 13 +--
 .../kernels/vector_selection_take_internal.cc |  1 +
 .../compute/kernels/vector_selection_test.cc  | 80 +++++++++----------
 docs/source/cpp/compute.rst                   | 18 ++---
 6 files changed, 144 insertions(+), 75 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
index 13e92ba27ec2d..be6d1653b5722 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
@@ -27,6 +27,7 @@
 #include "arrow/chunked_array.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/exec.h"
+#include "arrow/compute/kernel.h"
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/vector_selection_filter_internal.h"
 #include "arrow/compute/kernels/vector_selection_internal.h"
@@ -49,8 +50,7 @@ using internal::CopyBitmap;
 using internal::CountSetBits;
 using internal::OptionalBitBlockCounter;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 namespace {
 
@@ -863,20 +863,29 @@ Status ExtensionFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult
   return Status::OK();
 }
 
-Status StructFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
-  // Transform filter to selection indices and then use Take.
+// Transform filter to selection indices and then use Take.
+Status FilterWithTakeExec(const ArrayKernelExec& take_exec, KernelContext* ctx,
+                          const ExecSpan& batch, ExecResult* out) {
   std::shared_ptr<ArrayData> indices;
   RETURN_NOT_OK(GetTakeIndices(batch[1].array,
                                FilterState::Get(ctx).null_selection_behavior,
                                ctx->memory_pool())
                     .Value(&indices));
+  KernelContext take_ctx(*ctx);
+  TakeState state{TakeOptions::NoBoundsCheck()};
+  take_ctx.SetState(&state);
+  ExecSpan take_batch({batch[0], ArraySpan(*indices)}, batch.length);
+  return take_exec(&take_ctx, take_batch, out);
+}
 
-  Datum result;
-  RETURN_NOT_OK(Take(batch[0].array.ToArrayData(), Datum(indices),
-                     TakeOptions::NoBoundsCheck(), ctx->exec_context())
-                    .Value(&result));
-  out->value = result.array();
-  return Status::OK();
+// Due to the special treatment with their Take kernels, we filter Struct and SparseUnion
+// arrays by transforming filter to selection indices and call Take.
+Status StructFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  return FilterWithTakeExec(StructTakeExec, ctx, batch, out);
+}
+
+Status SparseUnionFilterExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  return FilterWithTakeExec(SparseUnionTakeExec, ctx, batch, out);
 }
 
 // ----------------------------------------------------------------------
@@ -1047,6 +1056,7 @@ void PopulateFilterKernels(std::vector<SelectionKernelData>* out) {
       {InputType(Type::LARGE_LIST), plain_filter, LargeListFilterExec},
       {InputType(Type::FIXED_SIZE_LIST), plain_filter, FSLFilterExec},
       {InputType(Type::DENSE_UNION), plain_filter, DenseUnionFilterExec},
+      {InputType(Type::SPARSE_UNION), plain_filter, SparseUnionFilterExec},
       {InputType(Type::STRUCT), plain_filter, StructFilterExec},
       {InputType(Type::MAP), plain_filter, MapFilterExec},
 
@@ -1064,12 +1074,12 @@ void PopulateFilterKernels(std::vector<SelectionKernelData>* out) {
       {InputType(Type::LARGE_LIST), ree_filter, LargeListFilterExec},
       {InputType(Type::FIXED_SIZE_LIST), ree_filter, FSLFilterExec},
       {InputType(Type::DENSE_UNION), ree_filter, DenseUnionFilterExec},
+      {InputType(Type::SPARSE_UNION), ree_filter, SparseUnionFilterExec},
       {InputType(Type::STRUCT), ree_filter, StructFilterExec},
       {InputType(Type::MAP), ree_filter, MapFilterExec},
   };
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
index 23b8b75bfa024..98eb37e9c5fd2 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_internal.cc
@@ -45,8 +45,7 @@ namespace arrow {
 
 using internal::CheckIndexBounds;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 void RegisterSelectionFunction(const std::string& name, FunctionDoc doc,
                                VectorKernel base_kernel,
@@ -171,9 +170,6 @@ void VisitPlainxREEFilterOutputSegments(
 
 namespace {
 
-using FilterState = OptionsWrapper<FilterOptions>;
-using TakeState = OptionsWrapper<TakeOptions>;
-
 // ----------------------------------------------------------------------
 // Implement take for other data types where there is less performance
 // sensitivity by visiting the selected indices.
@@ -741,6 +737,66 @@ struct DenseUnionSelectionImpl
   }
 };
 
+// We need a slightly different approach for SparseUnion. For Take, we can
+// invoke Take on each child's data with boundschecking disabled. For
+// Filter on the other hand, if we naively call Filter on each child, then the
+// filter output length will have to be redundantly computed. Thus, for Filter
+// we instead convert the filter to selection indices and then invoke take.
+
+// SparseUnion selection implementation. ONLY used for Take
+struct SparseUnionSelectionImpl
+    : public Selection<SparseUnionSelectionImpl, SparseUnionType> {
+  using Base = Selection<SparseUnionSelectionImpl, SparseUnionType>;
+  LIFT_BASE_MEMBERS();
+
+  TypedBufferBuilder<int8_t> child_id_buffer_builder_;
+  const int8_t type_code_for_null_;
+
+  SparseUnionSelectionImpl(KernelContext* ctx, const ExecSpan& batch,
+                           int64_t output_length, ExecResult* out)
+      : Base(ctx, batch, output_length, out),
+        child_id_buffer_builder_(ctx->memory_pool()),
+        type_code_for_null_(
+            checked_cast<const UnionType&>(*this->values.type).type_codes()[0]) {}
+
+  template <typename Adapter>
+  Status GenerateOutput() {
+    SparseUnionArray typed_values(this->values.ToArrayData());
+    Adapter adapter(this);
+    RETURN_NOT_OK(adapter.Generate(
+        [&](int64_t index) {
+          child_id_buffer_builder_.UnsafeAppend(typed_values.type_code(index));
+          return Status::OK();
+        },
+        [&]() {
+          child_id_buffer_builder_.UnsafeAppend(type_code_for_null_);
+          return Status::OK();
+        }));
+    return Status::OK();
+  }
+
+  Status Init() override {
+    RETURN_NOT_OK(child_id_buffer_builder_.Reserve(output_length));
+    return Status::OK();
+  }
+
+  Status Finish() override {
+    ARROW_ASSIGN_OR_RAISE(auto child_ids_buffer, child_id_buffer_builder_.Finish());
+    SparseUnionArray typed_values(this->values.ToArrayData());
+    auto num_fields = typed_values.num_fields();
+    auto num_rows = child_ids_buffer->size();
+    BufferVector buffers{nullptr, std::move(child_ids_buffer)};
+    *out = ArrayData(typed_values.type(), num_rows, std::move(buffers), 0);
+    out->child_data.reserve(num_fields);
+    for (auto i = 0; i < num_fields; i++) {
+      ARROW_ASSIGN_OR_RAISE(auto child_datum,
+                            Take(*typed_values.field(i), *this->selection.ToArrayData()));
+      out->child_data.emplace_back(std::move(child_datum).array());
+    }
+    return Status::OK();
+  }
+};
+
 struct FSLSelectionImpl : public Selection<FSLSelectionImpl, FixedSizeListType> {
   Int64Builder child_index_builder;
 
@@ -909,6 +965,10 @@ Status DenseUnionTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult*
   return TakeExec<DenseUnionSelectionImpl>(ctx, batch, out);
 }
 
+Status SparseUnionTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+  return TakeExec<SparseUnionSelectionImpl>(ctx, batch, out);
+}
+
 Status StructTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   return TakeExec<StructSelectionImpl>(ctx, batch, out);
 }
@@ -917,6 +977,5 @@ Status MapTakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   return TakeExec<ListSelectionImpl<MapType>>(ctx, batch, out);
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_internal.h b/cpp/src/arrow/compute/kernels/vector_selection_internal.h
index bcffdd820db3c..b9eba6ea6631f 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_internal.h
+++ b/cpp/src/arrow/compute/kernels/vector_selection_internal.h
@@ -26,10 +26,12 @@
 #include "arrow/compute/exec.h"
 #include "arrow/compute/function.h"
 #include "arrow/compute/kernel.h"
+#include "arrow/compute/kernels/codegen_internal.h"
 
-namespace arrow {
-namespace compute {
-namespace internal {
+namespace arrow::compute::internal {
+
+using FilterState = OptionsWrapper<FilterOptions>;
+using TakeState = OptionsWrapper<TakeOptions>;
 
 struct SelectionKernelData {
   InputType value_type;
@@ -82,9 +84,8 @@ Status ListTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status LargeListTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status FSLTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status DenseUnionTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
+Status SparseUnionTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status StructTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 Status MapTakeExec(KernelContext*, const ExecSpan&, ExecResult*);
 
-}  // namespace internal
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
index ab80127731ceb..612de8505d3ab 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_take_internal.cc
@@ -844,6 +844,7 @@ void PopulateTakeKernels(std::vector<SelectionKernelData>* out) {
       {InputType(Type::LARGE_LIST), take_indices, LargeListTakeExec},
       {InputType(Type::FIXED_SIZE_LIST), take_indices, FSLTakeExec},
       {InputType(Type::DENSE_UNION), take_indices, DenseUnionTakeExec},
+      {InputType(Type::SPARSE_UNION), take_indices, SparseUnionTakeExec},
       {InputType(Type::STRUCT), take_indices, StructTakeExec},
       {InputType(Type::MAP), take_indices, MapTakeExec},
   };
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index 5b624911ff5fd..30e85c1f71089 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -282,11 +282,6 @@ class TestFilterKernel : public ::testing::Test {
                     const std::shared_ptr<Array>& expected) {
     DoAssertFilter(values, filter, expected);
 
-    if (values->type_id() == Type::DENSE_UNION) {
-      // Concatenation of dense union not supported
-      return;
-    }
-
     // Check slicing: add M(=3) dummy values at the start and end of `values`,
     // add N(=2) dummy values at the start and end of `filter`.
     ARROW_SCOPED_TRACE("for sliced values and filter");
@@ -759,8 +754,10 @@ TEST_F(TestFilterKernelWithStruct, FilterStruct) {
 class TestFilterKernelWithUnion : public TestFilterKernel {};
 
 TEST_F(TestFilterKernelWithUnion, FilterUnion) {
-  auto union_type = dense_union({field("a", int32()), field("b", utf8())}, {2, 5});
-  auto union_json = R"([
+  for (const auto& union_type :
+       {dense_union({field("a", int32()), field("b", utf8())}, {2, 5}),
+        sparse_union({field("a", int32()), field("b", utf8())}, {2, 5})}) {
+    auto union_json = R"([
       [2, null],
       [2, 222],
       [5, "hello"],
@@ -769,31 +766,21 @@ TEST_F(TestFilterKernelWithUnion, FilterUnion) {
       [2, 111],
       [5, null]
     ])";
-  this->AssertFilter(union_type, union_json, "[0, 0, 0, 0, 0, 0, 0]", "[]");
-  this->AssertFilter(union_type, union_json, "[0, 1, 1, null, 0, 1, 1]", R"([
+    this->AssertFilter(union_type, union_json, "[0, 0, 0, 0, 0, 0, 0]", "[]");
+    this->AssertFilter(union_type, union_json, "[0, 1, 1, null, 0, 1, 1]", R"([
       [2, 222],
       [5, "hello"],
       [2, null],
       [2, 111],
       [5, null]
     ])");
-  this->AssertFilter(union_type, union_json, "[1, 0, 1, 0, 1, 0, 0]", R"([
+    this->AssertFilter(union_type, union_json, "[1, 0, 1, 0, 1, 0, 0]", R"([
       [2, null],
       [5, "hello"],
       [2, null]
     ])");
-  this->AssertFilter(union_type, union_json, "[1, 1, 1, 1, 1, 1, 1]", union_json);
-
-  // Sliced
-  // (check this manually as concatenation of dense unions isn't supported: ARROW-4975)
-  auto values = ArrayFromJSON(union_type, union_json)->Slice(2, 4);
-  auto filter = ArrayFromJSON(boolean(), "[0, 1, 1, null, 0, 1, 1]")->Slice(2, 4);
-  auto expected = ArrayFromJSON(union_type, R"([
-      [5, "hello"],
-      [2, null],
-      [2, 111]
-    ])");
-  this->AssertFilter(values, filter, expected);
+    this->AssertFilter(union_type, union_json, "[1, 1, 1, 1, 1, 1, 1]", union_json);
+  }
 }
 
 class TestFilterKernelWithRecordBatch : public TestFilterKernel {
@@ -1026,13 +1013,11 @@ void CheckTake(const std::shared_ptr<DataType>& type, const std::string& values_
     AssertTakeArrays(values, indices, expected);
 
     // Check sliced values
-    if (type->id() != Type::DENSE_UNION) {
-      ASSERT_OK_AND_ASSIGN(auto values_filler, MakeArrayOfNull(type, 2));
-      ASSERT_OK_AND_ASSIGN(auto values_sliced,
-                           Concatenate({values_filler, values, values_filler}));
-      values_sliced = values_sliced->Slice(2, values->length());
-      AssertTakeArrays(values_sliced, indices, expected);
-    }
+    ASSERT_OK_AND_ASSIGN(auto values_filler, MakeArrayOfNull(type, 2));
+    ASSERT_OK_AND_ASSIGN(auto values_sliced,
+                         Concatenate({values_filler, values, values_filler}));
+    values_sliced = values_sliced->Slice(2, values->length());
+    AssertTakeArrays(values_sliced, indices, expected);
 
     // Check sliced indices
     ASSERT_OK_AND_ASSIGN(auto zero, MakeScalar(index_type, int8_t{0}));
@@ -1477,32 +1462,34 @@ TEST_F(TestTakeKernelWithStruct, TakeStruct) {
 class TestTakeKernelWithUnion : public TestTakeKernelTyped<UnionType> {};
 
 TEST_F(TestTakeKernelWithUnion, TakeUnion) {
-  auto union_type = dense_union({field("a", int32()), field("b", utf8())}, {2, 5});
-  auto union_json = R"([
-      [2, null],
+  for (const auto& union_type :
+       {dense_union({field("a", int32()), field("b", utf8())}, {2, 5}),
+        sparse_union({field("a", int32()), field("b", utf8())}, {2, 5})}) {
+    auto union_json = R"([
       [2, 222],
+      [2, null],
       [5, "hello"],
       [5, "eh"],
       [2, null],
       [2, 111],
       [5, null]
     ])";
-  CheckTake(union_type, union_json, "[]", "[]");
-  CheckTake(union_type, union_json, "[3, 1, 3, 1, 3]", R"([
+    CheckTake(union_type, union_json, "[]", "[]");
+    CheckTake(union_type, union_json, "[3, 0, 3, 0, 3]", R"([
       [5, "eh"],
       [2, 222],
       [5, "eh"],
       [2, 222],
       [5, "eh"]
     ])");
-  CheckTake(union_type, union_json, "[4, 2, 1, 6]", R"([
+    CheckTake(union_type, union_json, "[4, 2, 0, 6]", R"([
       [2, null],
       [5, "hello"],
       [2, 222],
       [5, null]
     ])");
-  CheckTake(union_type, union_json, "[0, 1, 2, 3, 4, 5, 6]", union_json);
-  CheckTake(union_type, union_json, "[0, 2, 2, 2, 2, 2, 2]", R"([
+    CheckTake(union_type, union_json, "[0, 1, 2, 3, 4, 5, 6]", union_json);
+    CheckTake(union_type, union_json, "[1, 2, 2, 2, 2, 2, 2]", R"([
       [2, null],
       [5, "hello"],
       [5, "hello"],
@@ -1511,6 +1498,16 @@ TEST_F(TestTakeKernelWithUnion, TakeUnion) {
       [5, "hello"],
       [5, "hello"]
     ])");
+    CheckTake(union_type, union_json, "[0, null, 1, null, 2, 2, 2]", R"([
+      [2, 222],
+      [2, null],
+      [2, null],
+      [2, null],
+      [5, "hello"],
+      [5, "hello"],
+      [5, "hello"]
+    ])");
+  }
 }
 
 class TestPermutationsWithTake : public ::testing::Test {
@@ -2162,8 +2159,10 @@ TEST_F(TestDropNullKernelWithStruct, DropNullStruct) {
 class TestDropNullKernelWithUnion : public TestDropNullKernelTyped<UnionType> {};
 
 TEST_F(TestDropNullKernelWithUnion, DropNullUnion) {
-  auto union_type = dense_union({field("a", int32()), field("b", utf8())}, {2, 5});
-  auto union_json = R"([
+  for (const auto& union_type :
+       {dense_union({field("a", int32()), field("b", utf8())}, {2, 5}),
+        sparse_union({field("a", int32()), field("b", utf8())}, {2, 5})}) {
+    auto union_json = R"([
       [2, null],
       [2, 222],
       [5, "hello"],
@@ -2172,7 +2171,8 @@ TEST_F(TestDropNullKernelWithUnion, DropNullUnion) {
       [2, 111],
       [5, null]
     ])";
-  CheckDropNull(union_type, union_json, union_json);
+    CheckDropNull(union_type, union_json, union_json);
+  }
 }
 
 class TestDropNullKernelWithRecordBatch : public TestDropNullKernelTyped<RecordBatch> {
diff --git a/docs/source/cpp/compute.rst b/docs/source/cpp/compute.rst
index 9cc1dd79936b8..44f43cbc877ca 100644
--- a/docs/source/cpp/compute.rst
+++ b/docs/source/cpp/compute.rst
@@ -1692,28 +1692,26 @@ These functions select and return a subset of their input.
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
 | Function name | Arity  | Input type 1 | Input type 2 | Output type  | Options class           | Notes     |
 +===============+========+==============+==============+==============+=========================+===========+
-| array_filter  | Binary | Any          | Boolean      | Input type 1 | :struct:`FilterOptions` | \(1) \(3) |
+| array_filter  | Binary | Any          | Boolean      | Input type 1 | :struct:`FilterOptions` | \(2)      |
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
-| array_take    | Binary | Any          | Integer      | Input type 1 | :struct:`TakeOptions`   | \(1) \(4) |
+| array_take    | Binary | Any          | Integer      | Input type 1 | :struct:`TakeOptions`   | \(3)      |
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
-| drop_null     | Unary  | Any          | -            | Input type 1 |                         | \(1) \(2) |
+| drop_null     | Unary  | Any          | -            | Input type 1 |                         | \(1)      |
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
-| filter        | Binary | Any          | Boolean      | Input type 1 | :struct:`FilterOptions` | \(1) \(3) |
+| filter        | Binary | Any          | Boolean      | Input type 1 | :struct:`FilterOptions` | \(2)      |
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
-| take          | Binary | Any          | Integer      | Input type 1 | :struct:`TakeOptions`   | \(1) \(4) |
+| take          | Binary | Any          | Integer      | Input type 1 | :struct:`TakeOptions`   | \(3)      |
 +---------------+--------+--------------+--------------+--------------+-------------------------+-----------+
 
-* \(1) Sparse unions are unsupported.
-
-* \(2) Each element in the input is appended to the output iff it is non-null.
+* \(1) Each element in the input is appended to the output iff it is non-null.
   If the input is a record batch or table, any null value in a column drops
   the entire row.
 
-* \(3) Each element in input 1 (the values) is appended to the output iff
+* \(2) Each element in input 1 (the values) is appended to the output iff
   the corresponding element in input 2 (the filter) is true.  How
   nulls in the filter are handled can be configured using FilterOptions.
 
-* \(4) For each element *i* in input 2 (the indices), the *i*'th element
+* \(3) For each element *i* in input 2 (the indices), the *i*'th element
   in input 1 (the values) is appended to the output.
 
 Containment tests

From 27949b45ac71cd85293d2c2de34591c090a7f95c Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Thu, 10 Aug 2023 23:09:21 +0800
Subject: [PATCH 134/749] GH-36949: [C++] Fix KeyColumnArray's buffers array
 bounds assertion. (#36966)

### Rationale for this change

file: light_array.h

The length of the buffers array is 3 (kMaxBuffers).

- buffers_[kValidityBuffer]
- buffers_[kFixedLengthBuffer]
- buffers_[kVariableLengthBuffer]

So when we do the check, the asserted index should be less than 3, not equal to.

In addition, fix the comment line break format problem.

### What changes are included in this PR?

- KeyColumnArray

data and mutable_data ARROW_DCHECK.

- ResizableArrayData class

Comment line break formatting for mutable_data functions

### Are these changes tested?

no, just change assert bound.

### Are there any user-facing changes?

no
* Closes: #36949

Authored-by: light-city <455954986@qq.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/compute/light_array.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/light_array.h b/cpp/src/arrow/compute/light_array.h
index d617b0aa064ac..3dd328c22eedf 100644
--- a/cpp/src/arrow/compute/light_array.h
+++ b/cpp/src/arrow/compute/light_array.h
@@ -122,12 +122,12 @@ class ARROW_EXPORT KeyColumnArray {
 
   /// \brief Return one of the underlying mutable buffers
   uint8_t* mutable_data(int i) {
-    ARROW_DCHECK(i >= 0 && i <= kMaxBuffers);
+    ARROW_DCHECK(i >= 0 && i < kMaxBuffers);
     return mutable_buffers_[i];
   }
   /// \brief Return one of the underlying read-only buffers
   const uint8_t* data(int i) const {
-    ARROW_DCHECK(i >= 0 && i <= kMaxBuffers);
+    ARROW_DCHECK(i >= 0 && i < kMaxBuffers);
     return buffers_[i];
   }
   /// \brief Return a mutable version of the offsets buffer
@@ -316,8 +316,7 @@ class ARROW_EXPORT ResizableArrayData {
   ///
   /// If i is 0 (kValidityBuffer) then this returns the validity buffer
   /// If i is 1 (kFixedLengthBuffer) then this returns the buffer used for values (if this
-  /// is a fixed
-  ///           length data type) or offsets (if this is a variable binary type)
+  /// is a fixed length data type) or offsets (if this is a variable binary type)
   /// If i is 2 (kVariableLengthBuffer) then this returns the buffer used for variable
   /// length binary data
   uint8_t* mutable_data(int i) { return buffers_[i]->mutable_data(); }

From 9b77edd5c66095d72ade0f71b120792fe2a8f99c Mon Sep 17 00:00:00 2001
From: Ben Harkins <60872452+benibus@users.noreply.github.com>
Date: Thu, 10 Aug 2023 11:33:08 -0400
Subject: [PATCH 135/749] GH-35450: [C++] Return error when
 `RecordBatch::ToStructArray` called with mismatched column lengths (#36654)

### Rationale for this change

If a `RecordBatch` is created with column lengths that don't match the provided `num_rows` (technically invalid), then there are some circumstances where `ToStructArray` will successfully return an array whose length doesn't match `num_rows`. Instead, we should return an error.

### What changes are included in this PR?

* Add a small validation check to `ToStructArray` before constructing the output array
* Add a test

### Are these changes tested?

Yes (tests are included)

### Are there any user-facing changes?

No

* Closes: #35450

Authored-by: benibus <bpharks@gmx.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/record_batch.cc      | 23 ++++++++++++++++++-----
 cpp/src/arrow/record_batch_test.cc | 25 +++++++++++++++++++++++++
 2 files changed, 43 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/record_batch.cc b/cpp/src/arrow/record_batch.cc
index 683e72878b9b1..1c5c8912e5a0b 100644
--- a/cpp/src/arrow/record_batch.cc
+++ b/cpp/src/arrow/record_batch.cc
@@ -218,8 +218,25 @@ Result<std::shared_ptr<RecordBatch>> RecordBatch::FromStructArray(
               array->data()->child_data);
 }
 
+namespace {
+
+Status ValidateColumnLength(const RecordBatch& batch, int i) {
+  const auto& array = *batch.column(i);
+  if (ARROW_PREDICT_FALSE(array.length() != batch.num_rows())) {
+    return Status::Invalid("Number of rows in column ", i,
+                           " did not match batch: ", array.length(), " vs ",
+                           batch.num_rows());
+  }
+  return Status::OK();
+}
+
+}  // namespace
+
 Result<std::shared_ptr<StructArray>> RecordBatch::ToStructArray() const {
   if (num_columns() != 0) {
+    // Only check the first column because `StructArray::Make` already checks that the
+    // child lengths are equal.
+    RETURN_NOT_OK(ValidateColumnLength(*this, 0));
     return StructArray::Make(columns(), schema()->fields());
   }
   return std::make_shared<StructArray>(arrow::struct_({}), num_rows_,
@@ -301,12 +318,8 @@ namespace {
 
 Status ValidateBatch(const RecordBatch& batch, bool full_validation) {
   for (int i = 0; i < batch.num_columns(); ++i) {
+    RETURN_NOT_OK(ValidateColumnLength(batch, i));
     const auto& array = *batch.column(i);
-    if (array.length() != batch.num_rows()) {
-      return Status::Invalid("Number of rows in column ", i,
-                             " did not match batch: ", array.length(), " vs ",
-                             batch.num_rows());
-    }
     const auto& schema_type = batch.schema()->field(i)->type();
     if (!array.type()->Equals(schema_type)) {
       return Status::Invalid("Column ", i,
diff --git a/cpp/src/arrow/record_batch_test.cc b/cpp/src/arrow/record_batch_test.cc
index 4975e94325d32..e8180c6740879 100644
--- a/cpp/src/arrow/record_batch_test.cc
+++ b/cpp/src/arrow/record_batch_test.cc
@@ -413,6 +413,31 @@ TEST_F(TestRecordBatch, MakeEmpty) {
   ASSERT_EQ(empty->num_rows(), 0);
 }
 
+// See: https://github.com/apache/arrow/issues/35450
+TEST_F(TestRecordBatch, ToStructArrayMismatchedColumnLengths) {
+  constexpr int kNumRows = 5;
+  FieldVector fields = {field("x", int64()), field("y", int64())};
+  ArrayVector columns = {
+      ArrayFromJSON(int64(), "[0, 1, 2, 3, 4]"),
+      ArrayFromJSON(int64(), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"),
+  };
+
+  // Sanity check
+  auto batch = RecordBatch::Make(schema({fields[0]}), kNumRows, {columns[0]});
+  ASSERT_OK_AND_ASSIGN(auto array, batch->ToStructArray());
+  ASSERT_EQ(array->length(), kNumRows);
+
+  // One column with a mismatched length
+  batch = RecordBatch::Make(schema({fields[1]}), kNumRows, {columns[1]});
+  ASSERT_RAISES(Invalid, batch->ToStructArray());
+  // Mix of columns with matching and non-matching lengths
+  batch = RecordBatch::Make(schema(fields), kNumRows, columns);
+  ASSERT_RAISES(Invalid, batch->ToStructArray());
+  std::swap(columns[0], columns[1]);
+  batch = RecordBatch::Make(schema(fields), kNumRows, columns);
+  ASSERT_RAISES(Invalid, batch->ToStructArray());
+}
+
 class TestRecordBatchReader : public ::testing::Test {
  public:
   void SetUp() override { MakeBatchesAndReader(100); }

From f0904b3ed0b84c5e1460fe12c4f6c79407b07e4d Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Thu, 10 Aug 2023 23:36:32 +0800
Subject: [PATCH 136/749] GH-37106: [C++] Remove overflowed integer rounding
 benchmarks (#37109)

### Rationale for this change

The valid range of 8 and 16 bit integers is too small, which causes failures on `round` benchmarks.

### What changes are included in this PR?

`Round` benchmarks for <32 bit integers are removed. Arithmetic on small int widths is probably uncommon.

### Are these changes tested?

The benchmark is now running successfully on my machine.

### Are there any user-facing changes?

No.

* Closes: #37106

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc b/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc
index 2e662632cdeec..3c5bb76dc24e9 100644
--- a/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_round_benchmark.cc
@@ -116,12 +116,8 @@ void SetRoundArgs(benchmark::internal::Benchmark* bench) {
 #define DECLARE_BASIC_BENCHMARKS(BENCHMARK, OP)                       \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, Int64Type)->Apply(SetRoundArgs);  \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, Int32Type)->Apply(SetRoundArgs);  \
-  BENCHMARK_TEMPLATE(BENCHMARK, OP, Int16Type)->Apply(SetRoundArgs);  \
-  BENCHMARK_TEMPLATE(BENCHMARK, OP, Int8Type)->Apply(SetRoundArgs);   \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt64Type)->Apply(SetRoundArgs); \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt32Type)->Apply(SetRoundArgs); \
-  BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt16Type)->Apply(SetRoundArgs); \
-  BENCHMARK_TEMPLATE(BENCHMARK, OP, UInt8Type)->Apply(SetRoundArgs);  \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, FloatType)->Apply(SetRoundArgs);  \
   BENCHMARK_TEMPLATE(BENCHMARK, OP, DoubleType)->Apply(SetRoundArgs);
 
@@ -151,12 +147,8 @@ void SetRoundArgs(benchmark::internal::Benchmark* bench) {
 #define DECLARE_ROUND_BENCHMARKS(BENCHMARK, OP)                       \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, Int64Type);  \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, Int32Type);  \
-  DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, Int16Type);  \
-  DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, Int8Type);   \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, UInt64Type); \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, UInt32Type); \
-  DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, UInt16Type); \
-  DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, UInt8Type);  \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, FloatType);  \
   DECLARE_ROUND_BENCHMARKS_WITH_ROUNDMODE(BENCHMARK, OP, DoubleType);
 

From 8ab6484391cb3f560b81d3701fcc2f6f58817725 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 10 Aug 2023 12:17:45 -0400
Subject: [PATCH 137/749] GH-37096: [MATLAB] Add utility which makes valid
 MATLAB table variable names from an arbitrary list of strings (#37098)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

To make it possible to safely convert Arrow Schema field names to corresponding MATLAB `table` variable names, it would be helpful to add a utility which can take an arbitrary list of strings and return a set of valid MATLAB `table` variable names, which are (1) unique, (2) non-empty, and (3) do not conflict with the "reserved" variable names "Properties", "VariableNames", "RowNames", and ":". An additional restriction is that variable names must have 63 or less characters.

### What changes are included in this PR?

1. Added a new function called `arrow.tabular.internal.makeValidVariableNames` that accepts an arbitrary list of strings and returns valid MATLAB `table` variable names.

```matlab
>> originalVarNames = ["", "Properties", ":", "ValidVar", "ValidVar"];
>> validVarNames = arrow.tabular.internal.makeValidVariableNames(originalVarNames)

validVarNames =

  1×5 string array

    "Var1"    "Properties_1"    ":_1"    "ValidVar"    "ValidVar_1"
```

3. Added a new function called `arrow.tabular.internal.makeValidDimensionNames` that returns valid table dimension names with respect to a list of valid variable names. In MATLAB the default `table` dimension names are `"Row"` and `"Variables"`, but they must not conflict with any variables names. In other words, they must be unique with respect to the variable names.

```matlab
>> validVarNames = ["Row" "Test" "Variables"];
>> validDimNames = arrow.tabular.internal.makeValidDimensionNames(validVarNames)

validDimNames =

  1×2 string array

    "Row_1"    "Variables_1"
```

To summarize, MATLAB `table`s cannot have arbitrary variable names. For example, `"Properties"`, `"RowNames"`, `"VariableNames"`, and `":"` are all disallowed. Variable names must also be unique and must be between 1 and 63 characters in length. They also must be unique with respect to each other.

### Are these changes tested?

Yes. Added the following new test classes:

1. `tMakeValidVariableNames.m`
2. `tMakeValidDimensionNames.m`

### Are there any user-facing changes?

No.

### Future Directions

1. In a follow-up PR, we will integrate `makeValidVariableNames` and `makeValidDimensionNames` into the `table()` and `toMATLAB()` methods of `arrow.tabular.RecordBatch`.

### Notes

Thanks to @ kevingurney for help writing the test cases!

* Closes: #37096

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/makeValidDimensionNames.m       |  28 ++
 .../+internal/makeValidVariableNames.m        |  36 +++
 .../arrow/tabular/tMakeValidDimensionNames.m  |  81 ++++++
 .../arrow/tabular/tMakeValidVariableNames.m   | 240 ++++++++++++++++++
 4 files changed, 385 insertions(+)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/makeValidDimensionNames.m
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/makeValidVariableNames.m
 create mode 100644 matlab/test/arrow/tabular/tMakeValidDimensionNames.m
 create mode 100644 matlab/test/arrow/tabular/tMakeValidVariableNames.m

diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/makeValidDimensionNames.m b/matlab/src/matlab/+arrow/+tabular/+internal/makeValidDimensionNames.m
new file mode 100644
index 0000000000000..88f7b10806212
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/makeValidDimensionNames.m
@@ -0,0 +1,28 @@
+%MAKEVALIDDIMENSIONNAMES Makes valid table dimension names with 
+% respect to the variable names.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function dimnames = makeValidDimensionNames(varnames)
+
+    dimnames = ["Row" "Variables"];
+    
+    numvars = numel(varnames);
+    indicesToUniqify = [numvars + 1 numvars + 2];
+
+    strs = matlab.lang.makeUniqueStrings([varnames dimnames], indicesToUniqify);
+    dimnames = strs(indicesToUniqify);
+end
+
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/makeValidVariableNames.m b/matlab/src/matlab/+arrow/+tabular/+internal/makeValidVariableNames.m
new file mode 100644
index 0000000000000..b2abdc55aee8b
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/makeValidVariableNames.m
@@ -0,0 +1,36 @@
+%MAKEVALIDVARIABLENAMES Makes valid table variable names.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function [varnames, modified] = makeValidVariableNames(varnames)
+    arguments
+        varnames(1, :) string
+    end
+
+    reservedNames = ["Properties", "VariableNames", "RowNames", ":"];
+
+    [varnames, replacedVars] = replaceEmptyVariableNames(varnames);
+    [varnames, madeUnique] = matlab.lang.makeUniqueStrings(varnames, reservedNames, 63);
+    
+    modified = replacedVars || any(madeUnique);
+end
+
+function [varnames, modified] = replaceEmptyVariableNames(varnames)
+    emptyIndices = find(varnames == "");
+    modified = any(emptyIndices);
+    if modified
+        varnames(emptyIndices) = compose("Var%d", emptyIndices);
+    end
+end
diff --git a/matlab/test/arrow/tabular/tMakeValidDimensionNames.m b/matlab/test/arrow/tabular/tMakeValidDimensionNames.m
new file mode 100644
index 0000000000000..3e80fec91bc8d
--- /dev/null
+++ b/matlab/test/arrow/tabular/tMakeValidDimensionNames.m
@@ -0,0 +1,81 @@
+%TMAKEVALIDDIMENSIONNAMES Unit tests for
+% arrow.tabular.internal.makeValidDimensionNames.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tMakeValidDimensionNames < matlab.unittest.TestCase
+
+    methods(Test)
+
+        function VariableNamedRow(testCase)
+        % Verify the default dimension name "Row" is replaced with "Row_1"
+        % if one of the variables is named "Row".
+            import arrow.tabular.internal.*
+
+            varnames = ["Row" "Var2"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row_1", "Variables"]); 
+        end
+
+        function VariableNamedVariables(testCase)
+        % Verify the default dimension name "Variables" is replaced with
+        % "Variables_1" if one of the variables is named "Variables".
+            import arrow.tabular.internal.*
+
+            varnames = ["Var1" "Variables"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row", "Variables_1"]); 
+        end
+
+        function VariablesWithConflictingNumericSuffix(testCase)
+            % Verify that conflicting numeric suffixes (e.g. "Variables"
+            % and "Variables_1") are resolved as expected.
+            
+            import arrow.tabular.internal.*
+
+            varnames = ["A" "Variables_1" "Variables"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row", "Variables_2"]); 
+        end
+
+        function RowWithConflictingNumericSuffix(testCase)
+            % Verify that conflicting numeric suffixes (e.g. "Row"
+            % and "Row_1") are resolved as expected.
+            
+            import arrow.tabular.internal.*
+
+            varnames = ["Row_1" "Row" "Row_3" "Test"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row_2", "Variables"]); 
+        end
+
+        function DefaultDimensionNamesOk(testCase)
+            % Verify the dimension names are set to the default values
+            % ("Row" and "Variables") if they are not one of the variable
+            % names.
+
+            import arrow.tabular.internal.*
+
+            varnames = ["row" "variables"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row", "Variables"]); 
+            
+            varnames = ["A" "B" "C"];
+            dimnames = makeValidDimensionNames(varnames);
+            testCase.verifyEqual(dimnames, ["Row", "Variables"]); 
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tMakeValidVariableNames.m b/matlab/test/arrow/tabular/tMakeValidVariableNames.m
new file mode 100644
index 0000000000000..53b4ea67fb4b1
--- /dev/null
+++ b/matlab/test/arrow/tabular/tMakeValidVariableNames.m
@@ -0,0 +1,240 @@
+%TMAKEVALIDVARIABLENAMES Unit tests for
+% arrow.tabular.internal.makeValidVariableNames.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tMakeValidVariableNames < matlab.unittest.TestCase
+
+    methods(Test)
+
+        function Colon(testCase)
+            % Verify that ":" becomes ":_1".
+            import arrow.tabular.internal.*
+
+            original = ":";
+            expected = ":_1";
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function RowNames(testCase)
+            % Verify that "RowNames" becomes "RowNames_1".
+            import arrow.tabular.internal.*
+
+            original = "RowNames";
+            expected = "RowNames_1";
+            [actual, modified] = makeValidVariableNames(original);
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function Properties(testCase)
+            % Verify that "Properties" becomes "Properties_1".
+            import arrow.tabular.internal.*
+
+            original = "Properties";
+            expected = "Properties_1";
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function VariableNames(testCase)
+            % Verify that "VariableNames" becomes VariableNames_1.
+            import arrow.tabular.internal.*
+
+            original = "VariableNames";
+            expected = "VariableNames_1";
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function ValidVariableNames(testCase)
+            % Verify that when all of the input strings
+            % are valid table variable names, that none of them
+            % are modified.
+            import arrow.tabular.internal.*
+
+            original = ["A", "B", "C"];
+            expected = original;
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyFalse(modified);
+        end
+
+        function ValidVariableNamesUnicode(testCase)
+            % Verify that when all of the input strings are valid Unicode
+            % table variable names, that none of them are modified.
+            import arrow.tabular.internal.*
+
+            smiley = "😀";
+            tree =  "🌲";
+            mango = "🥭";
+
+            original = [smiley, tree, mango];
+            expected = original;
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyFalse(modified);
+        end
+
+        function PropertiesWithConflictingNumericSuffix(testCase)
+            % Verify that conflicting numeric suffixes (e.g. "Properties"
+            % and "Properties_1") are resolved as expected.
+            import arrow.tabular.internal.*
+
+            original = ["Properties", "Properties_1"];
+            expected = ["Properties_2", "Properties_1"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = ["Properties_1", "Properties", "Properties_4"];
+            expected = ["Properties_1", "Properties_2", "Properties_4"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function RowNamesWithConflictingNumericSuffix(testCase)
+            % Verify that conflicting numeric suffixes (e.g. "RowNames"
+            % and "RowNames_1") are resolved as expected.
+            import arrow.tabular.internal.*
+
+            original = ["RowNames", "RowNames_1"];
+            expected = ["RowNames_2", "RowNames_1"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = ["RowNames_1", "RowNames", "RowNames_4"];
+            expected = ["RowNames_1", "RowNames_2", "RowNames_4"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function VariableNamesWithConflictingNumericSuffix(testCase)
+            % Verify that conflicting numeric suffixes (e.g. "VariableNames"
+            % and "VariableNames_1") are resolved as expected.
+            import arrow.tabular.internal.*
+
+            original = ["VariableNames", "VariableNames_1"];
+            expected = ["VariableNames_2", "VariableNames_1"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = ["VariableNames_1", "VariableNames", "VariableNames_4"];
+            expected = ["VariableNames_1", "VariableNames_2", "VariableNames_4"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function ColonWithConflictingSuffix(testCase)
+            % Verify that conflicting suffixes (e.g. ":"
+            % and "x_") are resolved as expected.
+            import arrow.tabular.internal.*
+
+            original = [":", ":_1"];
+            expected = [":_2", ":_1"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = [":_1", ":", ":_4"];
+            expected = [":_1", ":_2", ":_4"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function EmptyStrings(testCase)
+            % Verify that empty strings are mapped to Var1, ..., Vari, ...,
+            % VarN as expected and that conflicting names are resolved as
+            % expected.
+            import arrow.tabular.internal.*
+
+            original = "";
+            expected = "Var1";
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = ["", "Var1", ""];
+            expected = ["Var1", "Var1_1", "Var3"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+
+            original = ["", "Var1", "Var1_1"];
+            expected = ["Var1", "Var1_2", "Var1_1"];
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+        function VariableNameLengthMax(testCase)
+            % Verify strings whose character length exceeds 63
+            % are truncated to the max variable name length (63).
+            import arrow.tabular.internal.*
+
+            original = string(repmat('a', [1 64]));
+            expected = extractBefore(original, 64); 
+
+            [actual, modified] = makeValidVariableNames(original);
+
+            testCase.verifyEqual(actual, expected);
+            testCase.verifyTrue(modified);
+        end
+
+    end
+    
+end
\ No newline at end of file

From 529c6bb2eeb14c28a1c005093a2db7d15280f383 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Thu, 10 Aug 2023 12:24:38 -0400
Subject: [PATCH 138/749] GH-37099: [C++] Fix build of Flight-UCX (#37105)

### Rationale for this change

Fix broken build.

### What changes are included in this PR?

Remove an outdated alias.

### Are these changes tested?

N/A

### Are there any user-facing changes?

No.
* Closes: #37099

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/flight/transport/ucx/ucx_internal.cc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/arrow/flight/transport/ucx/ucx_internal.cc b/cpp/src/arrow/flight/transport/ucx/ucx_internal.cc
index 9c6bd182827c4..767a877ece331 100644
--- a/cpp/src/arrow/flight/transport/ucx/ucx_internal.cc
+++ b/cpp/src/arrow/flight/transport/ucx/ucx_internal.cc
@@ -41,7 +41,6 @@ namespace transport {
 namespace ucx {
 
 using internal::TransportStatus;
-using internal::TransportStatusCode;
 
 // Defines to test different implementation strategies
 // Enable the CONTIG path for CPU-only data

From be1b0033a2bee49e262aa243b821883cbd561b2e Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 11 Aug 2023 02:43:51 +0800
Subject: [PATCH 139/749] GH-36939: [C++][Parquet] Direct put of BooleanArray
 is incorrect when called several times (#36972)

### Rationale for this change

This is from a bug in PLAIN encoding with `BooleanArray` input. Boolean will introduce bad length when writing arrow data.

This interface is not widely used.

### What changes are included in this PR?

Rewrite PLAIN boolean encoder to use `TypedBufferBuilder` instead of an incorrect hand-baked implementation.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No.

* Closes: #36939

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc      | 84 +++++-------------------------
 cpp/src/parquet/encoding_test.cc | 87 ++++++++++++++++++++++++++++----
 2 files changed, 90 insertions(+), 81 deletions(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index dda0e7701b1e4..e972a86ccf0ef 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -66,7 +66,6 @@ using ArrowPoolVector = std::vector<T, ::arrow::stl::allocator<T>>;
 namespace parquet {
 namespace {
 
-constexpr int64_t kInMemoryDefaultCapacity = 1024;
 // The Parquet spec isn't very clear whether ByteArray lengths are signed or
 // unsigned, but the Java implementation uses signed ints.
 constexpr size_t kMaxByteArraySize = std::numeric_limits<int32_t>::max();
@@ -307,12 +306,7 @@ template <>
 class PlainEncoder<BooleanType> : public EncoderImpl, virtual public BooleanEncoder {
  public:
   explicit PlainEncoder(const ColumnDescriptor* descr, MemoryPool* pool)
-      : EncoderImpl(descr, Encoding::PLAIN, pool),
-        bits_available_(kInMemoryDefaultCapacity * 8),
-        bits_buffer_(AllocateBuffer(pool, kInMemoryDefaultCapacity)),
-        sink_(pool),
-        bit_writer_(bits_buffer_->mutable_data(),
-                    static_cast<int>(bits_buffer_->size())) {}
+      : EncoderImpl(descr, Encoding::PLAIN, pool), sink_(pool) {}
 
   int64_t EstimatedDataEncodedSize() override;
   std::shared_ptr<Buffer> FlushValues() override;
@@ -340,39 +334,25 @@ class PlainEncoder<BooleanType> : public EncoderImpl, virtual public BooleanEnco
       throw ParquetException("direct put to boolean from " + values.type()->ToString() +
                              " not supported");
     }
-
     const auto& data = checked_cast<const ::arrow::BooleanArray&>(values);
+
     if (data.null_count() == 0) {
-      PARQUET_THROW_NOT_OK(sink_.Reserve(bit_util::BytesForBits(data.length())));
       // no nulls, just dump the data
-      ::arrow::internal::CopyBitmap(data.data()->GetValues<uint8_t>(1), data.offset(),
-                                    data.length(), sink_.mutable_data(), sink_.length());
+      PARQUET_THROW_NOT_OK(sink_.Reserve(data.length()));
+      sink_.UnsafeAppend(data.data()->GetValues<uint8_t>(1, 0), data.offset(),
+                         data.length());
     } else {
-      auto n_valid = bit_util::BytesForBits(data.length() - data.null_count());
-      PARQUET_THROW_NOT_OK(sink_.Reserve(n_valid));
-      ::arrow::internal::FirstTimeBitmapWriter writer(sink_.mutable_data(),
-                                                      sink_.length(), n_valid);
-
+      PARQUET_THROW_NOT_OK(sink_.Reserve(data.length() - data.null_count()));
       for (int64_t i = 0; i < data.length(); i++) {
         if (data.IsValid(i)) {
-          if (data.Value(i)) {
-            writer.Set();
-          } else {
-            writer.Clear();
-          }
-          writer.Next();
+          sink_.UnsafeAppend(data.Value(i));
         }
       }
-      writer.Finish();
     }
-    sink_.UnsafeAdvance(data.length());
   }
 
  private:
-  int bits_available_;
-  std::shared_ptr<ResizableBuffer> bits_buffer_;
-  ::arrow::BufferBuilder sink_;
-  ::arrow::bit_util::BitWriter bit_writer_;
+  ::arrow::TypedBufferBuilder<bool> sink_;
 
   template <typename SequenceType>
   void PutImpl(const SequenceType& src, int num_values);
@@ -380,57 +360,17 @@ class PlainEncoder<BooleanType> : public EncoderImpl, virtual public BooleanEnco
 
 template <typename SequenceType>
 void PlainEncoder<BooleanType>::PutImpl(const SequenceType& src, int num_values) {
-  int bit_offset = 0;
-  if (bits_available_ > 0) {
-    int bits_to_write = std::min(bits_available_, num_values);
-    for (int i = 0; i < bits_to_write; i++) {
-      bit_writer_.PutValue(src[i], 1);
-    }
-    bits_available_ -= bits_to_write;
-    bit_offset = bits_to_write;
-
-    if (bits_available_ == 0) {
-      bit_writer_.Flush();
-      PARQUET_THROW_NOT_OK(
-          sink_.Append(bit_writer_.buffer(), bit_writer_.bytes_written()));
-      bit_writer_.Clear();
-    }
-  }
-
-  int bits_remaining = num_values - bit_offset;
-  while (bit_offset < num_values) {
-    bits_available_ = static_cast<int>(bits_buffer_->size()) * 8;
-
-    int bits_to_write = std::min(bits_available_, bits_remaining);
-    for (int i = bit_offset; i < bit_offset + bits_to_write; i++) {
-      bit_writer_.PutValue(src[i], 1);
-    }
-    bit_offset += bits_to_write;
-    bits_available_ -= bits_to_write;
-    bits_remaining -= bits_to_write;
-
-    if (bits_available_ == 0) {
-      bit_writer_.Flush();
-      PARQUET_THROW_NOT_OK(
-          sink_.Append(bit_writer_.buffer(), bit_writer_.bytes_written()));
-      bit_writer_.Clear();
-    }
+  PARQUET_THROW_NOT_OK(sink_.Reserve(num_values));
+  for (int i = 0; i < num_values; ++i) {
+    sink_.UnsafeAppend(src[i]);
   }
 }
 
 int64_t PlainEncoder<BooleanType>::EstimatedDataEncodedSize() {
-  int64_t position = sink_.length();
-  return position + bit_writer_.bytes_written();
+  return ::arrow::bit_util::BytesForBits(sink_.length());
 }
 
 std::shared_ptr<Buffer> PlainEncoder<BooleanType>::FlushValues() {
-  if (bits_available_ > 0) {
-    bit_writer_.Flush();
-    PARQUET_THROW_NOT_OK(sink_.Append(bit_writer_.buffer(), bit_writer_.bytes_written()));
-    bit_writer_.Clear();
-    bits_available_ = static_cast<int>(bits_buffer_->size()) * 8;
-  }
-
   std::shared_ptr<Buffer> buffer;
   PARQUET_THROW_NOT_OK(sink_.Finish(&buffer));
   return buffer;
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 7a910e4220831..0ac5fd76e79c9 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -26,6 +26,7 @@
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/builder_dict.h"
+#include "arrow/array/concatenate.h"
 #include "arrow/compute/cast.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/random.h"
@@ -580,7 +581,7 @@ TEST(PlainEncodingAdHoc, ArrowBinaryDirectPut) {
     decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
 
     typename EncodingTraits<ByteArrayType>::Accumulator acc;
-    acc.builder.reset(new ::arrow::StringBuilder);
+    acc.builder = std::make_unique<::arrow::StringBuilder>();
     ASSERT_EQ(num_values,
               decoder->DecodeArrow(static_cast<int>(values->length()),
                                    static_cast<int>(values->null_count()),
@@ -597,6 +598,39 @@ TEST(PlainEncodingAdHoc, ArrowBinaryDirectPut) {
   }
 }
 
+// Check that one can put several Arrow arrays into a given encoder
+// and decode to the right values (see GH-36939)
+TEST(PlainBooleanArrayEncoding, AdHocRoundTrip) {
+  std::vector<std::shared_ptr<::arrow::Array>> arrays{
+      ::arrow::ArrayFromJSON(::arrow::boolean(), R"([])"),
+      ::arrow::ArrayFromJSON(::arrow::boolean(), R"([false, null, true])"),
+      ::arrow::ArrayFromJSON(::arrow::boolean(), R"([null, null, null])"),
+      ::arrow::ArrayFromJSON(::arrow::boolean(), R"([true, null, false])"),
+  };
+
+  auto encoder = MakeTypedEncoder<BooleanType>(Encoding::PLAIN,
+                                               /*use_dictionary=*/false);
+  for (const auto& array : arrays) {
+    encoder->Put(*array);
+  }
+  auto buffer = encoder->FlushValues();
+  auto decoder = MakeTypedDecoder<BooleanType>(Encoding::PLAIN);
+  EXPECT_OK_AND_ASSIGN(auto expected, ::arrow::Concatenate(arrays));
+  decoder->SetData(static_cast<int>(expected->length()), buffer->data(),
+                   static_cast<int>(buffer->size()));
+
+  ::arrow::BooleanBuilder builder;
+  ASSERT_EQ(static_cast<int>(expected->length() - expected->null_count()),
+            decoder->DecodeArrow(static_cast<int>(expected->length()),
+                                 static_cast<int>(expected->null_count()),
+                                 expected->null_bitmap_data(), 0, &builder));
+
+  std::shared_ptr<::arrow::Array> result;
+  ASSERT_OK(builder.Finish(&result));
+  ASSERT_EQ(expected->length(), result->length());
+  ::arrow::AssertArraysEqual(*expected, *result, /*verbose=*/true);
+}
+
 template <typename T>
 void GetDictDecoder(DictEncoder<T>* encoder, int64_t num_values,
                     std::shared_ptr<Buffer>* out_values,
@@ -641,27 +675,37 @@ class EncodingAdHocTyped : public ::testing::Test {
 
   static std::shared_ptr<::arrow::DataType> arrow_type();
 
-  void Plain(int seed) {
-    auto values = GetValues(seed);
+  void Plain(int seed, int rounds = 1, int offset = 0) {
+    auto random_array = GetValues(seed)->Slice(offset);
     auto encoder = MakeTypedEncoder<ParquetType>(
         Encoding::PLAIN, /*use_dictionary=*/false, column_descr());
     auto decoder = MakeTypedDecoder<ParquetType>(Encoding::PLAIN, column_descr());
 
-    ASSERT_NO_THROW(encoder->Put(*values));
+    for (int i = 0; i < rounds; ++i) {
+      ASSERT_NO_THROW(encoder->Put(*random_array));
+    }
+    std::shared_ptr<::arrow::Array> values;
+    if (rounds == 1) {
+      values = random_array;
+    } else {
+      ::arrow::ArrayVector arrays(rounds, random_array);
+      EXPECT_OK_AND_ASSIGN(values,
+                           ::arrow::Concatenate(arrays, ::arrow::default_memory_pool()));
+    }
     auto buf = encoder->FlushValues();
 
-    int num_values = static_cast<int>(values->length() - values->null_count());
-    decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+    decoder->SetData(static_cast<int>(values->length()), buf->data(),
+                     static_cast<int>(buf->size()));
 
     BuilderType acc(arrow_type(), ::arrow::default_memory_pool());
-    ASSERT_EQ(num_values,
+    ASSERT_EQ(static_cast<int>(values->length() - values->null_count()),
               decoder->DecodeArrow(static_cast<int>(values->length()),
                                    static_cast<int>(values->null_count()),
                                    values->null_bitmap_data(), values->offset(), &acc));
 
     std::shared_ptr<::arrow::Array> result;
     ASSERT_OK(acc.Finish(&result));
-    ASSERT_EQ(50, result->length());
+    ASSERT_EQ(values->length(), result->length());
     ::arrow::AssertArraysEqual(*values, *result, /*verbose=*/true);
   }
 
@@ -877,9 +921,34 @@ using EncodingAdHocTypedCases =
 TYPED_TEST_SUITE(EncodingAdHocTyped, EncodingAdHocTypedCases);
 
 TYPED_TEST(EncodingAdHocTyped, PlainArrowDirectPut) {
-  for (auto seed : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {
+  for (auto seed : {0, 1, 2, 3, 4}) {
     this->Plain(seed);
   }
+  // Same, but without nulls (this could trigger different code paths)
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Plain(seed, /*rounds=*/3);
+  }
+}
+
+TYPED_TEST(EncodingAdHocTyped, PlainArrowDirectPutMultiRound) {
+  // Check that one can put several Arrow arrays into a given encoder
+  // and decode to the right values (see GH-36939)
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Plain(seed, /*rounds=*/3);
+  }
+  // Same, but without nulls
+  this->null_probability_ = 0.0;
+  for (auto seed : {0, 1, 2, 3, 4}) {
+    this->Plain(seed, /*rounds=*/3);
+  }
+}
+
+TYPED_TEST(EncodingAdHocTyped, PlainArrowDirectPutSliced) {
+  this->Plain(/*seed=*/0, /*rounds=*/1, /*offset=*/3);
+  // Same, but without nulls
+  this->null_probability_ = 0.0;
+  this->Plain(/*seed=*/0, /*rounds=*/1, /*offset=*/3);
 }
 
 TYPED_TEST(EncodingAdHocTyped, ByteStreamSplitArrowDirectPut) {

From 2be31dd30ca249fd34fda07235f3439a5ef0e0c9 Mon Sep 17 00:00:00 2001
From: Kyle Barron <kylebarron2@gmail.com>
Date: Thu, 10 Aug 2023 16:46:09 -0400
Subject: [PATCH 140/749] MINOR: [Docs][JS] Update implementation status table
 (#37108)

### Rationale for this change

Update the table for JS type support

- JS does support Null: https://github.com/apache/arrow/blob/ebcf7bc25fcd47137523cb934a740cac0fc0fb76/js/src/type.ts#L89
- JS does support Float16: https://github.com/apache/arrow/blob/ebcf7bc25fcd47137523cb934a740cac0fc0fb76/js/src/type.ts#L223
- JS does support Unions of either mode: https://github.com/apache/arrow/blob/ebcf7bc25fcd47137523cb934a740cac0fc0fb76/js/src/type.ts#L488-L489
- JS does not currently support Int64 offsets (e.g. LargeList, LargeUtf8, LargeBinary)

Authored-by: Kyle Barron <kylebarron2@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/status.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/source/status.rst b/docs/source/status.rst
index 5c8895b114ae3..fbbe1cede9610 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -32,7 +32,7 @@ Data Types
 | Data type         | C++   | Java  | Go    | JavaScript | C#    | Rust  | Julia | Swift |
 | (primitive)       |       |       |       |            |       |       |       |       |
 +===================+=======+=======+=======+============+=======+=======+=======+=======+
-| Null              | ✓     | ✓     | ✓     |            |  ✓    |  ✓    | ✓     |       |
+| Null              | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Boolean           | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -40,7 +40,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | UInt8/16/32/64    | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Float16           |       |       | ✓     |            |  ✓ (1)|  ✓    | ✓     |       |
+| Float16           |       |       | ✓     | ✓          |  ✓ (1)|  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Float32/64        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -62,11 +62,11 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Binary            | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Large Binary      | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Large Binary      | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Utf8              | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Large Utf8        | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Large Utf8        | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -83,9 +83,9 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Map               | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Dense Union       | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
+| Dense Union       | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Sparse Union      | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
+| Sparse Union      | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+

From 0e4fa8af7b72493ffe05388a7f3fed0d4181e7b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Thu, 10 Aug 2023 17:43:45 -0400
Subject: [PATCH 141/749] GH-37021 [Java][arrow-jdbc] Pluggable getConsumer
 (#37085)

### Rationale for this change

This was discussed in [this thread](https://github.com/apache/arrow/issues/37021#issuecomment-1666169351). The `getConsumer` implementation depends on the implementation for `getArrowTypeFromJdbcType`, especially for timestamp objects. Since we can provide a different implementation for `JdbcToArrowTypeConverter` it follows we should be able to provide a different implementation for `JdbcConsumerGetter`

### What changes are included in this PR?

Adds a way to configure an alternate `JdbcToArrowUtils.getConsumer` function through `JdbcToArrowConfigBuilder.setJdbcConsumerGetter`.

It also throws a more helpful exception from the default implementations when a provided type is not mapped.

### Are these changes tested?

No, the default behavior remains unchanged.
* Related: #37021
* Closes: #37021

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../adapter/jdbc/ArrowVectorIterator.java     |  2 +-
 .../arrow/adapter/jdbc/JdbcToArrowConfig.java | 53 +++++++++++++++++++
 .../jdbc/JdbcToArrowConfigBuilder.java        | 15 ++++++
 .../arrow/adapter/jdbc/JdbcToArrowUtils.java  |  4 +-
 .../flight/sql/example/FlightSqlExample.java  |  9 ++--
 5 files changed, 77 insertions(+), 6 deletions(-)

diff --git a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/ArrowVectorIterator.java b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/ArrowVectorIterator.java
index 6c3e9cf43e758..6e789009dd20a 100644
--- a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/ArrowVectorIterator.java
+++ b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/ArrowVectorIterator.java
@@ -139,7 +139,7 @@ private void initialize(VectorSchemaRoot root) throws SQLException {
     for (int i = 1; i <= consumers.length; i++) {
       final JdbcFieldInfo columnFieldInfo = JdbcToArrowUtils.getJdbcFieldInfoForColumn(rsmd, i, config);
       ArrowType arrowType = config.getJdbcToArrowTypeConverter().apply(columnFieldInfo);
-      consumers[i - 1] = JdbcToArrowUtils.getConsumer(
+      consumers[i - 1] = config.getJdbcConsumerGetter().apply(
           arrowType, i, isColumnNullable(resultSet.getMetaData(), i, columnFieldInfo), root.getVector(i - 1), config);
     }
   }
diff --git a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfig.java b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfig.java
index 012cd95c0b2b6..e23bad54afc14 100644
--- a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfig.java
+++ b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfig.java
@@ -22,8 +22,10 @@
 import java.util.Map;
 import java.util.function.Function;
 
+import org.apache.arrow.adapter.jdbc.consumer.JdbcConsumer;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.FieldVector;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 
 /**
@@ -76,6 +78,7 @@ public final class JdbcToArrowConfig {
   private final int targetBatchSize;
 
   private final Function<JdbcFieldInfo, ArrowType> jdbcToArrowTypeConverter;
+  private final JdbcConsumerFactory jdbcConsumerGetter;
 
   /**
    * Constructs a new configuration from the provided allocator and calendar.  The <code>allocator</code>
@@ -195,6 +198,38 @@ public final class JdbcToArrowConfig {
       Map<String, String> schemaMetadata,
       Map<Integer, Map<String, String>> columnMetadataByColumnIndex,
       RoundingMode bigDecimalRoundingMode) {
+    this(
+        allocator,
+        calendar,
+        includeMetadata,
+        reuseVectorSchemaRoot,
+        arraySubTypesByColumnIndex,
+        arraySubTypesByColumnName,
+        targetBatchSize,
+        jdbcToArrowTypeConverter,
+        null,
+        explicitTypesByColumnIndex,
+        explicitTypesByColumnName,
+        schemaMetadata,
+        columnMetadataByColumnIndex,
+        bigDecimalRoundingMode);
+  }
+
+  JdbcToArrowConfig(
+      BufferAllocator allocator,
+      Calendar calendar,
+      boolean includeMetadata,
+      boolean reuseVectorSchemaRoot,
+      Map<Integer, JdbcFieldInfo> arraySubTypesByColumnIndex,
+      Map<String, JdbcFieldInfo> arraySubTypesByColumnName,
+      int targetBatchSize,
+      Function<JdbcFieldInfo, ArrowType> jdbcToArrowTypeConverter,
+      JdbcConsumerFactory jdbcConsumerGetter,
+      Map<Integer, JdbcFieldInfo> explicitTypesByColumnIndex,
+      Map<String, JdbcFieldInfo> explicitTypesByColumnName,
+      Map<String, String> schemaMetadata,
+      Map<Integer, Map<String, String>> columnMetadataByColumnIndex,
+      RoundingMode bigDecimalRoundingMode) {
     Preconditions.checkNotNull(allocator, "Memory allocator cannot be null");
     this.allocator = allocator;
     this.calendar = calendar;
@@ -212,6 +247,8 @@ public final class JdbcToArrowConfig {
     // set up type converter
     this.jdbcToArrowTypeConverter = jdbcToArrowTypeConverter != null ? jdbcToArrowTypeConverter :
         (jdbcFieldInfo) -> JdbcToArrowUtils.getArrowTypeFromJdbcType(jdbcFieldInfo, calendar);
+
+    this.jdbcConsumerGetter = jdbcConsumerGetter != null ? jdbcConsumerGetter : JdbcToArrowUtils::getConsumer;
   }
 
   /**
@@ -264,6 +301,13 @@ public Function<JdbcFieldInfo, ArrowType> getJdbcToArrowTypeConverter() {
     return jdbcToArrowTypeConverter;
   }
 
+  /**
+   * Gets the JDBC consumer getter.
+   */
+  public JdbcConsumerFactory getJdbcConsumerGetter() {
+    return jdbcConsumerGetter;
+  }
+
   /**
    * Returns the array sub-type {@link JdbcFieldInfo} defined for the provided column index.
    *
@@ -338,4 +382,13 @@ public Map<Integer, Map<String, String>> getColumnMetadataByColumnIndex() {
   public RoundingMode getBigDecimalRoundingMode() {
     return bigDecimalRoundingMode;
   }
+
+  /**
+   * Interface for a function that gets a JDBC consumer for the given values.
+   */
+  @FunctionalInterface
+  public interface JdbcConsumerFactory {
+    JdbcConsumer apply(ArrowType arrowType, int columnIndex, boolean nullable, FieldVector vector,
+                       JdbcToArrowConfig config);
+  }
 }
diff --git a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfigBuilder.java b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfigBuilder.java
index 2fe0492deb71f..7d88c23832067 100644
--- a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfigBuilder.java
+++ b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowConfigBuilder.java
@@ -26,6 +26,7 @@
 
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.FieldVector;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 
 /**
@@ -44,6 +45,7 @@ public class JdbcToArrowConfigBuilder {
   private Map<Integer, Map<String, String>> columnMetadataByColumnIndex;
   private int targetBatchSize;
   private Function<JdbcFieldInfo, ArrowType> jdbcToArrowTypeConverter;
+  private JdbcToArrowConfig.JdbcConsumerFactory jdbcConsumerGetter;
   private RoundingMode bigDecimalRoundingMode;
 
   /**
@@ -221,6 +223,18 @@ public JdbcToArrowConfigBuilder setJdbcToArrowTypeConverter(
     return this;
   }
 
+  /**
+   * Set the function used to get a JDBC consumer for a given type.
+   * <p>
+   * Defaults to wrapping {@link
+   * JdbcToArrowUtils#getConsumer(ArrowType, Integer, Boolean, FieldVector, JdbcToArrowConfig)}.
+   */
+  public JdbcToArrowConfigBuilder setJdbcConsumerGetter(
+      JdbcToArrowConfig.JdbcConsumerFactory jdbcConsumerGetter) {
+    this.jdbcConsumerGetter = jdbcConsumerGetter;
+    return this;
+  }
+
   /**
    * Set whether to use the same {@link org.apache.arrow.vector.VectorSchemaRoot} instance on each iteration,
    * or to allocate a new one.
@@ -274,6 +288,7 @@ public JdbcToArrowConfig build() {
         arraySubTypesByColumnName,
         targetBatchSize,
         jdbcToArrowTypeConverter,
+        jdbcConsumerGetter,
         explicitTypesByColumnIndex,
         explicitTypesByColumnName,
         schemaMetadata,
diff --git a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowUtils.java b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowUtils.java
index dc79f6efff324..f8a13b93b1ed8 100644
--- a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowUtils.java
+++ b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcToArrowUtils.java
@@ -208,7 +208,7 @@ public static ArrowType getArrowTypeFromJdbcType(final JdbcFieldInfo fieldInfo,
         return new ArrowType.Struct();
       default:
         // no-op, shouldn't get here
-        return null;
+        throw new UnsupportedOperationException("Unmapped JDBC type: " + fieldInfo.getJdbcType());
     }
   }
 
@@ -489,7 +489,7 @@ static JdbcConsumer getConsumer(ArrowType arrowType, int columnIndex, boolean nu
         return new NullConsumer((NullVector) vector);
       default:
         // no-op, shouldn't get here
-        throw new UnsupportedOperationException();
+        throw new UnsupportedOperationException("No consumer for Arrow type: " + arrowType);
     }
   }
 }
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/example/FlightSqlExample.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/example/FlightSqlExample.java
index fe1e1445afc6e..3cc8f4a1c1bd5 100644
--- a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/example/FlightSqlExample.java
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/example/FlightSqlExample.java
@@ -299,9 +299,12 @@ private static boolean populateDerbyDatabase() {
   }
 
   private static ArrowType getArrowTypeFromJdbcType(final int jdbcDataType, final int precision, final int scale) {
-    final ArrowType type =
-        JdbcToArrowUtils.getArrowTypeFromJdbcType(new JdbcFieldInfo(jdbcDataType, precision, scale), DEFAULT_CALENDAR);
-    return isNull(type) ? ArrowType.Utf8.INSTANCE : type;
+    try {
+      return JdbcToArrowUtils.getArrowTypeFromJdbcType(new JdbcFieldInfo(jdbcDataType, precision, scale),
+              DEFAULT_CALENDAR);
+    } catch (UnsupportedOperationException ignored) {
+      return ArrowType.Utf8.INSTANCE;
+    }
   }
 
   private static void saveToVector(final Byte data, final UInt1Vector vector, final int index) {

From e51f442a708deb4ee15f932e19e1cb8375f28c18 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 11 Aug 2023 10:05:27 +0900
Subject: [PATCH 142/749] GH-37116: [C++][ORC] Link to
 absl::log_internal_check_op for ABSL_DCHECK*() (#37117)

### Rationale for this change

Recent protoc generates files that use ABSL_DCHECK*(). At least 3.21.12 doesn't use ABSL_DCHECK*() and 23.4 uses ABSL_DCHECK*().

If ABSL_DCHECK*() are used, we need to link to absl::log_internal_check_op.

### What changes are included in this PR?

Link to absl::log_internal_check_op if possible.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37116

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/cpp.yml                   | 3 +--
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 5 +++++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index eaccf25403eba..fb76faa529e5c 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -164,8 +164,7 @@ jobs:
       ARROW_HDFS: ON
       ARROW_HOME: /usr/local
       ARROW_JEMALLOC: ON
-      # TODO(kszucs): link error in the tests
-      ARROW_ORC: OFF
+      ARROW_ORC: ON
       ARROW_PARQUET: ON
       ARROW_S3: ON
       ARROW_WITH_BROTLI: ON
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 1e7840cf92e08..4422e17e85cb6 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -4399,6 +4399,11 @@ macro(build_orc)
                         PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}"
                                    INTERFACE_INCLUDE_DIRECTORIES "${ORC_INCLUDE_DIR}")
   set(ORC_LINK_LIBRARIES LZ4::lz4 ZLIB::ZLIB ${ARROW_ZSTD_LIBZSTD} ${Snappy_TARGET})
+  # Protobuf generated files may use ABSL_DCHECK*() and
+  # absl::log_internal_check_op is needed for them.
+  if(TARGET absl::log_internal_check_op)
+    list(APPEND ORC_LINK_LIBRARIES absl::log_internal_check_op)
+  endif()
   if(NOT MSVC)
     if(NOT APPLE)
       list(APPEND ORC_LINK_LIBRARIES Threads::Threads)

From faf41a9425a532e541c8095cfb37396041e7a1d5 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 11 Aug 2023 16:08:14 +0900
Subject: [PATCH 143/749] GH-37022: [CI][Java] Use the official Maven download
 URL (#37119)

### Rationale for this change

If we use https://dlcdn.apache.org/ instead of
https://www.apache.org/dyn/closer.lua , old source archived can't be downloaded.

### What changes are included in this PR?

Use https://www.apache.org/dyn/closer.lua .

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37022

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/docker/java-jni-manylinux-201x.dockerfile | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/ci/docker/java-jni-manylinux-201x.dockerfile b/ci/docker/java-jni-manylinux-201x.dockerfile
index e9888db7c5332..207bea72b5375 100644
--- a/ci/docker/java-jni-manylinux-201x.dockerfile
+++ b/ci/docker/java-jni-manylinux-201x.dockerfile
@@ -37,7 +37,10 @@ ARG java=1.8.0
 ARG maven=3.9.3
 RUN yum install -y java-$java-openjdk-devel && \
       yum clean all && \
-      curl https://dlcdn.apache.org/maven/maven-3/${maven}/binaries/apache-maven-${maven}-bin.tar.gz | \
+      curl \
+        --fail \
+        --location \
+        "https://www.apache.org/dyn/closer.lua?action=download&filename=maven/maven-3/${maven}/binaries/apache-maven-${maven}-bin.tar.gz" | \
         tar xfz - -C /usr/local && \
       ln -s /usr/local/apache-maven-${maven}/bin/mvn /usr/local/bin
 

From edf283e947acc0a91db488a1fce122cfaf036812 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 11 Aug 2023 16:10:33 +0900
Subject: [PATCH 144/749] GH-37120: [CI][Docs] Ensure removing existing Node.js
 (#37121)

### Rationale for this change

We want to use the specified Node.js and existing Node.js may be conflicted.

### What changes are included in this PR?

We remove existing Node.js explicitly before we install the specified Node.js.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37120

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/docker/linux-apt-docs.dockerfile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/ci/docker/linux-apt-docs.dockerfile b/ci/docker/linux-apt-docs.dockerfile
index 584c31d1f814d..c51600a1e5920 100644
--- a/ci/docker/linux-apt-docs.dockerfile
+++ b/ci/docker/linux-apt-docs.dockerfile
@@ -68,7 +68,9 @@ ENV PATH=/opt/apache-maven-${maven}/bin:$PATH
 RUN mvn -version
 
 ARG node=16
-RUN wget -q -O - https://deb.nodesource.com/setup_${node}.x | bash - && \
+RUN apt-get purge -y npm && \
+    apt-get autoremove -y --purge && \
+    wget -q -O - https://deb.nodesource.com/setup_${node}.x | bash - && \
     apt-get install -y nodejs && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/* && \

From a7d5217937ca8b8be77995910f672c5e61e9d699 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 11 Aug 2023 17:35:36 +0900
Subject: [PATCH 145/749] MINOR: [JS] Bump esbuild from 0.18.0 to 0.19.0 in /js
 (#37081)

Bumps [esbuild](https://github.com/evanw/esbuild) from 0.18.0 to 0.19.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/evanw/esbuild/releases">esbuild's releases</a>.</em></p>
<blockquote>
<h2>v0.19.0</h2>
<p><strong>This release deliberately contains backwards-incompatible changes.</strong> To avoid automatically picking up releases like this, you should either be pinning the exact version of <code>esbuild</code> in your <code>package.json</code> file (recommended) or be using a version range syntax that only accepts patch upgrades such as <code>^0.18.0</code> or <code>~0.18.0</code>. See npm's documentation about <a href="https://docs.npmjs.com/cli/v6/using-npm/semver/">semver</a> for more information.</p>
<ul>
<li>
<p>Handle import paths containing wildcards (<a href="https://redirect.github.com/evanw/esbuild/issues/56">#56</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/700">#700</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/875">#875</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/976">#976</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/2221">#2221</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/2515">#2515</a>)</p>
<p>This release introduces wildcards in import paths in two places:</p>
<ul>
<li>
<p><strong>Entry points</strong></p>
<p>You can now pass a string containing glob-style wildcards such as <code>./src/*.ts</code> as an entry point and esbuild will search the file system for files that match the pattern. This can be used to easily pass esbuild all files with a certain extension on the command line in a cross-platform way. Previously you had to rely on the shell to perform glob expansion, but that is obviously shell-dependent and didn't work at all on Windows. Note that to use this feature on the command line you will have to quote the pattern so it's passed verbatim to esbuild without any expansion by the shell. Here's an example:</p>
<pre lang="sh"><code>esbuild --minify &quot;./src/*.ts&quot; --outdir=out
</code></pre>
<p>Specifically the <code>*</code> character will match any character except for the <code>/</code> character, and the <code>/**/</code> character sequence will match a path separator followed by zero or more path elements. Other wildcard operators found in glob patterns such as <code>?</code> and <code>[...]</code> are not supported.</p>
</li>
<li>
<p><strong>Run-time import paths</strong></p>
<p>Import paths that are evaluated at run-time can now be bundled in certain limited situations. The import path expression must be a form of string concatenation and must start with either <code>./</code> or <code>../</code>. Each non-string expression in the string concatenation chain becomes a wildcard. The <code>*</code> wildcard is chosen unless the previous character is a <code>/</code>, in which case the <code>/**/*</code> character sequence is used. Some examples:</p>
<pre lang="js"><code>// These two forms are equivalent
const json1 = await import('./data/' + kind + '.json')
const json2 = await import(`./data/${kind}.json`)
</code></pre>
<p>This feature works with <code>require(...)</code> and <code>import(...)</code> because these can all accept run-time expressions. It does not work with <code>import</code> and <code>export</code> statements because these cannot accept run-time expressions. If you want to prevent esbuild from trying to bundle these imports, you should move the string concatenation expression outside of the <code>require(...)</code> or <code>import(...)</code>. For example:</p>
<pre lang="js"><code>// This will be bundled
const json1 = await import('./data/' + kind + '.json')
<p>// This will not be bundled
const path = './data/' + kind + '.json'
const json2 = await import(path)
</code></pre></p>
<p>Note that using this feature means esbuild will potentially do a lot of file system I/O to find all possible files that might match the pattern. This is by design, and is not a bug. If this is a concern, I recommend either avoiding the <code>/**/</code> pattern (e.g. by not putting a <code>/</code> before a wildcard) or using this feature only in directory subtrees which do not have many files that don't match the pattern (e.g. making a subdirectory for your JSON files and explicitly including that subdirectory in the pattern).</p>
</li>
</ul>
</li>
<li>
<p>Path aliases in <code>tsconfig.json</code> no longer count as packages (<a href="https://redirect.github.com/evanw/esbuild/issues/2792">#2792</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3003">#3003</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3160">#3160</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3238">#3238</a>)</p>
<p>Setting <code>--packages=external</code> tells esbuild to make all import paths external when they look like a package path. For example, an import of <code>./foo/bar</code> is not a package path and won't be external while an import of <code>foo/bar</code> is a package path and will be external. However, the <a href="https://www.typescriptlang.org/tsconfig#paths"><code>paths</code> field</a> in <code>tsconfig.json</code> allows you to create import paths that look like package paths but that do not resolve to packages. People do not want these paths to count as package paths. So with this release, the behavior of <code>--packages=external</code> has been changed to happen after the <code>tsconfig.json</code> path remapping step.</p>
</li>
<li>
<p>Use the <code>local-css</code> loader for <code>.module.css</code> files by default (<a href="https://redirect.github.com/evanw/esbuild/issues/20">#20</a>)</p>
<p>With this release the <code>css</code> loader is still used for <code>.css</code> files except that <code>.module.css</code> files now use the <code>local-css</code> loader. This is a common convention in the web development community. If you need <code>.module.css</code> files to use the <code>css</code> loader instead, then you can override this behavior with <code>--loader:.module.css=css</code>.</p>
</li>
</ul>
<h2>v0.18.20</h2>
<ul>
<li>Support advanced CSS <code>@ import</code> rules (<a href="https://redirect.github.com/evanw/esbuild/issues/953">#953</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3137">#3137</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/evanw/esbuild/blob/main/CHANGELOG.md">esbuild's changelog</a>.</em></p>
<blockquote>
<h2>0.19.0</h2>
<p><strong>This release deliberately contains backwards-incompatible changes.</strong> To avoid automatically picking up releases like this, you should either be pinning the exact version of <code>esbuild</code> in your <code>package.json</code> file (recommended) or be using a version range syntax that only accepts patch upgrades such as <code>^0.18.0</code> or <code>~0.18.0</code>. See npm's documentation about <a href="https://docs.npmjs.com/cli/v6/using-npm/semver/">semver</a> for more information.</p>
<ul>
<li>
<p>Handle import paths containing wildcards (<a href="https://redirect.github.com/evanw/esbuild/issues/56">#56</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/700">#700</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/875">#875</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/976">#976</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/2221">#2221</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/2515">#2515</a>)</p>
<p>This release introduces wildcards in import paths in two places:</p>
<ul>
<li>
<p><strong>Entry points</strong></p>
<p>You can now pass a string containing glob-style wildcards such as <code>./src/*.ts</code> as an entry point and esbuild will search the file system for files that match the pattern. This can be used to easily pass esbuild all files with a certain extension on the command line in a cross-platform way. Previously you had to rely on the shell to perform glob expansion, but that is obviously shell-dependent and didn't work at all on Windows. Note that to use this feature on the command line you will have to quote the pattern so it's passed verbatim to esbuild without any expansion by the shell. Here's an example:</p>
<pre lang="sh"><code>esbuild --minify &quot;./src/*.ts&quot; --outdir=out
</code></pre>
<p>Specifically the <code>*</code> character will match any character except for the <code>/</code> character, and the <code>/**/</code> character sequence will match a path separator followed by zero or more path elements. Other wildcard operators found in glob patterns such as <code>?</code> and <code>[...]</code> are not supported.</p>
</li>
<li>
<p><strong>Run-time import paths</strong></p>
<p>Import paths that are evaluated at run-time can now be bundled in certain limited situations. The import path expression must be a form of string concatenation and must start with either <code>./</code> or <code>../</code>. Each non-string expression in the string concatenation chain becomes a wildcard. The <code>*</code> wildcard is chosen unless the previous character is a <code>/</code>, in which case the <code>/**/*</code> character sequence is used. Some examples:</p>
<pre lang="js"><code>// These two forms are equivalent
const json1 = await import('./data/' + kind + '.json')
const json2 = await import(`./data/${kind}.json`)
</code></pre>
<p>This feature works with <code>require(...)</code> and <code>import(...)</code> because these can all accept run-time expressions. It does not work with <code>import</code> and <code>export</code> statements because these cannot accept run-time expressions. If you want to prevent esbuild from trying to bundle these imports, you should move the string concatenation expression outside of the <code>require(...)</code> or <code>import(...)</code>. For example:</p>
<pre lang="js"><code>// This will be bundled
const json1 = await import('./data/' + kind + '.json')
<p>// This will not be bundled
const path = './data/' + kind + '.json'
const json2 = await import(path)
</code></pre></p>
<p>Note that using this feature means esbuild will potentially do a lot of file system I/O to find all possible files that might match the pattern. This is by design, and is not a bug. If this is a concern, I recommend either avoiding the <code>/**/</code> pattern (e.g. by not putting a <code>/</code> before a wildcard) or using this feature only in directory subtrees which do not have many files that don't match the pattern (e.g. making a subdirectory for your JSON files and explicitly including that subdirectory in the pattern).</p>
</li>
</ul>
</li>
<li>
<p>Path aliases in <code>tsconfig.json</code> no longer count as packages (<a href="https://redirect.github.com/evanw/esbuild/issues/2792">#2792</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3003">#3003</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3160">#3160</a>, <a href="https://redirect.github.com/evanw/esbuild/issues/3238">#3238</a>)</p>
<p>Setting <code>--packages=external</code> tells esbuild to make all import paths external when they look like a package path. For example, an import of <code>./foo/bar</code> is not a package path and won't be external while an import of <code>foo/bar</code> is a package path and will be external. However, the <a href="https://www.typescriptlang.org/tsconfig#paths"><code>paths</code> field</a> in <code>tsconfig.json</code> allows you to create import paths that look like package paths but that do not resolve to packages. People do not want these paths to count as package paths. So with this release, the behavior of <code>--packages=external</code> has been changed to happen after the <code>tsconfig.json</code> path remapping step.</p>
</li>
<li>
<p>Use the <code>local-css</code> loader for <code>.module.css</code> files by default (<a href="https://redirect.github.com/evanw/esbuild/issues/20">#20</a>)</p>
<p>With this release the <code>css</code> loader is still used for <code>.css</code> files except that <code>.module.css</code> files now use the <code>local-css</code> loader. This is a common convention in the web development community. If you need <code>.module.css</code> files to use the <code>css</code> loader instead, then you can override this behavior with <code>--loader:.module.css=css</code>.</p>
</li>
</ul>
<h2>0.18.20</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/evanw/esbuild/commit/c337498cdad8cac87517ec49c923441b2dc67bf2"><code>c337498</code></a> publish 0.19.0 to npm</li>
<li><a href="https://github.com/evanw/esbuild/commit/0b79ab2bc1716a4206a61a7bb0bb25357e1ac55d"><code>0b79ab2</code></a> this is a breaking change release</li>
<li><a href="https://github.com/evanw/esbuild/commit/cb464592283c63cb25b1707047dcc0f19da64283"><code>cb46459</code></a> fix <a href="https://redirect.github.com/evanw/esbuild/issues/3003">#3003</a>, fix <a href="https://redirect.github.com/evanw/esbuild/issues/3238">#3238</a>: <code>--packages=</code> and <code>tsconfig</code></li>
<li><a href="https://github.com/evanw/esbuild/commit/727e5ff8bcf0459bcc341c64c9af8f6e0563fa4b"><code>727e5ff</code></a> css: use <code>local-css</code> for <code>.module.css</code> files (<a href="https://redirect.github.com/evanw/esbuild/issues/20">#20</a>)</li>
<li><a href="https://github.com/evanw/esbuild/commit/be9f8e5cd6703da9d9b9e4bea07cfc6e42b5856d"><code>be9f8e5</code></a> implement glob-style path resolution</li>
<li><a href="https://github.com/evanw/esbuild/commit/8e14e25f26d00149720484ba340072a714aed772"><code>8e14e25</code></a> add the <code>__glob</code> runtime helper method</li>
<li><a href="https://github.com/evanw/esbuild/commit/c067c5eae69fa42e72a551d6f2ea41ef07b37ed9"><code>c067c5e</code></a> remove an unnecessary argument</li>
<li><a href="https://github.com/evanw/esbuild/commit/6e05434eeeb9b4b257bafd6d96e0bac08af57f76"><code>6e05434</code></a> Update README.md</li>
<li><a href="https://github.com/evanw/esbuild/commit/22f0818cf81024b63752d815c51fe737612b43ec"><code>22f0818</code></a> publish 0.18.20 to npm</li>
<li><a href="https://github.com/evanw/esbuild/commit/89b98d923cf8c08ac30eb3e6b3e59eb5a4cab632"><code>89b98d9</code></a> css: test coverage for some external test cases</li>
<li>Additional commits viewable in <a href="https://github.com/evanw/esbuild/compare/v0.18.0...v0.19.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=esbuild&package-manager=npm_and_yarn&previous-version=0.18.0&new-version=0.19.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |   2 +-
 js/yarn.lock    | 228 ++++++++++++++++++++++++------------------------
 2 files changed, 115 insertions(+), 115 deletions(-)

diff --git a/js/package.json b/js/package.json
index b1ab023763d34..720349e5d1f54 100644
--- a/js/package.json
+++ b/js/package.json
@@ -79,7 +79,7 @@
     "cross-env": "7.0.3",
     "del": "7.0.0",
     "del-cli": "5.0.0",
-    "esbuild": "0.18.0",
+    "esbuild": "0.19.0",
     "esbuild-plugin-alias": "0.2.1",
     "eslint": "8.42.0",
     "eslint-plugin-jest": "27.2.3",
diff --git a/js/yarn.lock b/js/yarn.lock
index 9f8912fab6f0b..99aa2dbf6db3e 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -358,220 +358,220 @@
   resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz#bafb75234a5d3d1b690e7c2956a599345e84a2fd"
   integrity sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==
 
-"@esbuild/android-arm64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.18.0.tgz#7ae5fb784ad198ca62741b0821a39645d3fab5c3"
-  integrity sha512-nAwRCs5+jxi3gBMVkOqmRvsITB/UtfpvkbMwAwJUIbp66NnPbV2KGCFnjNn7IEqabJQXfBLe/QLdjCGpHU+yEw==
+"@esbuild/android-arm64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.19.0.tgz#c5ea635bdbe9b83d1f78a711120814e716439029"
+  integrity sha512-AzsozJnB+RNaDncBCs3Ys5g3kqhPFUueItfEaCpp89JH2naFNX2mYDIvUgPYMqqjm8hiFoo+jklb3QHZyR3ubw==
 
 "@esbuild/android-arm@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.17.19.tgz#5898f7832c2298bc7d0ab53701c57beb74d78b4d"
   integrity sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==
 
-"@esbuild/android-arm@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.18.0.tgz#8410aa4c5fe16426cf53fd26ad3805c679407f7b"
-  integrity sha512-+uLHSiWK3qOeyDYCf/nuvIgCnQsYjXWNa3TlGYLW1pPG7OYMawllU+VyBgHQPjF2aIUVFpfrvz5aAfxGk/0qNg==
+"@esbuild/android-arm@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.19.0.tgz#6eb6e1fbc0dbfafa035aaef8b5ecde25b539fcf9"
+  integrity sha512-GAkjUyHgWTYuex3evPd5V7uV/XS4LMKr1PWHRPW1xNyy/Jx08x3uTrDFRefBYLKT/KpaWM8/YMQcwbp5a3yIDA==
 
 "@esbuild/android-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.17.19.tgz#658368ef92067866d95fb268719f98f363d13ae1"
   integrity sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==
 
-"@esbuild/android-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.18.0.tgz#f6be1abb59ee824c2d4c40a46c2e993704d00eda"
-  integrity sha512-TiOJmHQ8bXCGlYLpBd3Qy7N8dxi4n6q+nOmTzPr5Hb/bUr+PKuP4e5lWaOlpkaKc1Q9wsFt+sHfQpFCrM7SMow==
+"@esbuild/android-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.19.0.tgz#99f154f71f5b92e778468bcf0f425d166c17bf20"
+  integrity sha512-SUG8/qiVhljBDpdkHQ9DvOWbp7hFFIP0OzxOTptbmVsgBgzY6JWowmMd6yJuOhapfxmj/DrvwKmjRLvVSIAKZg==
 
 "@esbuild/darwin-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz#584c34c5991b95d4d48d333300b1a4e2ff7be276"
   integrity sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==
 
-"@esbuild/darwin-arm64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.18.0.tgz#6306ada50ed59d5f83cceb096f59c2c750a62f6f"
-  integrity sha512-5GsFovtGyjMIXJrcCzmI1hX3TneCrmFncFIlo0WrRvWcVU6H094P854ZaP8qoLgevXhggO2dhlEGYY0Zv6/S9Q==
+"@esbuild/darwin-arm64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.19.0.tgz#2fcc11abf95fbabbf9167db6a11d899385bd777b"
+  integrity sha512-HkxZ8k3Jvcw0FORPNTavA8BMgQjLOB6AajT+iXmil7BwY3gU1hWvJJAyWyEogCmA4LdbGvKF8vEykdmJ4xNJJQ==
 
 "@esbuild/darwin-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz#7751d236dfe6ce136cce343dce69f52d76b7f6cb"
   integrity sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==
 
-"@esbuild/darwin-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.18.0.tgz#e9392250ed9701c659914321a9b180efe233af99"
-  integrity sha512-4K/QCksQ8F58rvC1D62Xi4q4E7YWpiyc3zy2H/n1W7y0hjQpOBBxciLn0qycMskP/m/I5h9HNbRlu1aK821sHg==
+"@esbuild/darwin-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.19.0.tgz#b5bbde35468db093fdf994880b0eb4b62613b67c"
+  integrity sha512-9IRWJjqpWFHM9a5Qs3r3bK834NCFuDY5ZaLrmTjqE+10B6w65UMQzeZjh794JcxpHolsAHqwsN/33crUXNCM2Q==
 
 "@esbuild/freebsd-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz#cacd171665dd1d500f45c167d50c6b7e539d5fd2"
   integrity sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==
 
-"@esbuild/freebsd-arm64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.0.tgz#61396db6c6beb74c71088513b733374dac45b766"
-  integrity sha512-DMazN0UGzipD0Fi1O9pRX0xfp+JC3gSnFWxTWq88Dr/odWhZzm8Jqy44LN2veYeipb1fBMxhoEp7eCr902SWqg==
+"@esbuild/freebsd-arm64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.0.tgz#3f64c76dc590f79cc40acef6b22dd5eb89fc2125"
+  integrity sha512-s7i2WcXcK0V1PJHVBe7NsGddsL62a9Vhpz2U7zapPrwKoFuxPP9jybwX8SXnropR/AOj3ppt2ern4ItblU6UQQ==
 
 "@esbuild/freebsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz#0769456eee2a08b8d925d7c00b79e861cb3162e4"
   integrity sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==
 
-"@esbuild/freebsd-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.18.0.tgz#c6a1bd133747de0c687abb137e17a197a2cced03"
-  integrity sha512-GdkJAB3ZBiYnie9iFO9v/CM4ko0dm5SYkUs97lBKNLHw9mo4H9IXwGNKtUztisEsmUP0IWfEi4YTWOJF3DIO4w==
+"@esbuild/freebsd-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.19.0.tgz#14d497e9e858fba2bb9b16130602b7f5944bc09c"
+  integrity sha512-NMdBSSdgwHCqCsucU5k1xflIIRU0qi1QZnM6+vdGy5fvxm1c8rKh50VzsWsIVTFUG3l91AtRxVwoz3Lcvy3I5w==
 
 "@esbuild/linux-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz#38e162ecb723862c6be1c27d6389f48960b68edb"
   integrity sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==
 
-"@esbuild/linux-arm64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.18.0.tgz#ba924b98ed00ab25567e932897b35ead1b3bc525"
-  integrity sha512-Mb3yCN9PXA6G5qf84UF0IEuXP22eyNlquF17Zs2F1vVBM0CtyWLYosC5JaxBxfK6EzWwB2IkPBIjMeK3ek+ItA==
+"@esbuild/linux-arm64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.19.0.tgz#0f2f4d8889f7dc89681c306d7312aa76445a5f65"
+  integrity sha512-I4zvE2srSZxRPapFnNqj+NL3sDJ1wkvEZqt903OZUlBBgigrQMvzUowvP/TTTu2OGYe1oweg5MFilfyrElIFag==
 
 "@esbuild/linux-arm@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz#1a2cd399c50040184a805174a6d89097d9d1559a"
   integrity sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==
 
-"@esbuild/linux-arm@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.18.0.tgz#56aadc2369324c1a70505d296d5037576a0ad026"
-  integrity sha512-A3Ue/oZdb43znNpeY71FrAjZF20MtnBKCGb1vXLIVg5qg8rRM1gRgn6X2ixYwATiw5dE04JnP+aV4OBf8c5ZvQ==
+"@esbuild/linux-arm@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.19.0.tgz#0b0f79dc72884f0ad02c0aabfc969a0bee7f6775"
+  integrity sha512-2F1+lH7ZBcCcgxiSs8EXQV0PPJJdTNiNcXxDb61vzxTRJJkXX1I/ye9mAhfHyScXzHaEibEXg1Jq9SW586zz7w==
 
 "@esbuild/linux-ia32@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz#e28c25266b036ce1cabca3c30155222841dc035a"
   integrity sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==
 
-"@esbuild/linux-ia32@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.18.0.tgz#cce1e382b91802a048b9ddf7c7b96fee0fac4a20"
-  integrity sha512-WNDXgJdfDhN6ZxHU7HgR2BRDVx9iGN8SpmebUUGdENg4MZJndGcaQuf2kCJjMwoK0+es1g61TeJzAMxfgDcmcA==
+"@esbuild/linux-ia32@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.19.0.tgz#dfcece1f5e74d0e7db090475e48b28d9aa270687"
+  integrity sha512-dz2Q7+P92r1Evc8kEN+cQnB3qqPjmCrOZ+EdBTn8lEc1yN8WDgaDORQQiX+mxaijbH8npXBT9GxUqE52Gt6Y+g==
 
 "@esbuild/linux-loong64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz#0f887b8bb3f90658d1a0117283e55dbd4c9dcf72"
   integrity sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==
 
-"@esbuild/linux-loong64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.18.0.tgz#96680acd30221d519be75a65087a8fb801efe6cc"
-  integrity sha512-PBr8Lf+L8amvheTGFVNK/0qionszkOKMq2WyfFlVz8D41v0+uSth6fYYHwtASkMk4xf+oh0vW8NYuav3/3RHuQ==
+"@esbuild/linux-loong64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.19.0.tgz#710f5bd55db3f5d9ebac8773ea49795261a35ca7"
+  integrity sha512-IcVJovJVflih4oFahhUw+N7YgNbuMSVFNr38awb0LNzfaiIfdqIh518nOfYaNQU3aVfiJnOIRVJDSAP4k35WxA==
 
 "@esbuild/linux-mips64el@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz#f5d2a0b8047ea9a5d9f592a178ea054053a70289"
   integrity sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==
 
-"@esbuild/linux-mips64el@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.18.0.tgz#a1e040a758d80dce29368702e6d431a64f9e9ba0"
-  integrity sha512-Lg4ygah5bwfDDCOMFsBJjSVbD1UzNwWt4f7DhpaSIFOrJqoECX1VTByKw3iSDAVRlwl1cljlfy7wlysrRZcdiQ==
+"@esbuild/linux-mips64el@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.19.0.tgz#a918b310f9bf31fced3853ca52fee6e7acc09824"
+  integrity sha512-bZGRAGySMquWsKw0gIdsClwfvgbsSq/7oq5KVu1H1r9Il+WzOcfkV1hguntIuBjRVL8agI95i4AukjdAV2YpUw==
 
 "@esbuild/linux-ppc64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz#876590e3acbd9fa7f57a2c7d86f83717dbbac8c7"
   integrity sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==
 
-"@esbuild/linux-ppc64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.18.0.tgz#5640cbe44466e443cab764b2509325955adf5ce7"
-  integrity sha512-obz/firdtou244DIjHzdKmJChwGseqA3tWGa6xPMfuq54Ca4Pp1a4ANMrqy2IZ67rfpRHcJTlb2h3rSfW6tvAA==
+"@esbuild/linux-ppc64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.19.0.tgz#104771ef6ce2719ac17031f6b9ed8aa98f8e5faf"
+  integrity sha512-3LC6H5/gCDorxoRBUdpLV/m7UthYSdar0XcCu+ypycQxMS08MabZ06y1D1yZlDzL/BvOYliRNRWVG/YJJvQdbg==
 
 "@esbuild/linux-riscv64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz#7f49373df463cd9f41dc34f9b2262d771688bf09"
   integrity sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==
 
-"@esbuild/linux-riscv64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.18.0.tgz#a90b6235f268d23e7cb6d7f25a3bc8cc5fd51519"
-  integrity sha512-UkuBdxQsxi39wWrRLMOkJl//82/hpQw79TD+OBLw3IBYyVQ4Wfvpe56RfEGK/j439sIm79ccnD5RUNQceHvZdQ==
+"@esbuild/linux-riscv64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.19.0.tgz#83beafa472ad4224adcd4d7469e3a17ba1fbd976"
+  integrity sha512-jfvdKjWk+Cp2sgLtEEdSHXO7qckrw2B2eFBaoRdmfhThqZs29GMMg7q/LsQpybA7BxCLLEs4di5ucsWzZC5XPA==
 
 "@esbuild/linux-s390x@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz#e2afd1afcaf63afe2c7d9ceacd28ec57c77f8829"
   integrity sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==
 
-"@esbuild/linux-s390x@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.18.0.tgz#aba0c4e869d709ed564298811434851b9ec8bc33"
-  integrity sha512-MgyuC30oYB465hyAqsb3EH6Y4zTeqqgixRAOpsDNMCelyDiW9ZDPXvMPfBgCZGJlDZFGKDm2I9ou8E3VI+v7pg==
+"@esbuild/linux-s390x@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.19.0.tgz#edc26cb41d8745716bda9c26bac1f0001eaad029"
+  integrity sha512-ofcucfNLkoXmcnJaw9ugdEOf40AWKGt09WBFCkpor+vFJVvmk/8OPjl/qRtks2Z7BuZbG3ztJuK1zS9z5Cgx9A==
 
 "@esbuild/linux-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz#8a0e9738b1635f0c53389e515ae83826dec22aa4"
   integrity sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==
 
-"@esbuild/linux-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.18.0.tgz#8e3623c0d650af6eb84d27b7818b8334596cf2d7"
-  integrity sha512-oLLKU3F4pKWAsNmfi7Rd4qkj0qvg1S923ZjlcISA2IMgHsODA9xzwerqWayI5nOhLGgKXviDofn9exTeA4EUQQ==
+"@esbuild/linux-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.19.0.tgz#80a6b5e55ad454e0c0af5bdb267335287e331007"
+  integrity sha512-Fpf7zNDBti3xrQKQKLdXT0hTyOxgFdRJIMtNy8x1az9ATR9/GJ1brYbB/GLWoXhKiHsoWs+2DLkFVNNMTCLEwA==
 
 "@esbuild/netbsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz#c29fb2453c6b7ddef9a35e2c18b37bda1ae5c462"
   integrity sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==
 
-"@esbuild/netbsd-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.18.0.tgz#a9c72773bf301467e74a05c16251780d2fec4ef3"
-  integrity sha512-BEfJrZsZ/gMtpS2vC+2YoFGxmfLKiYQvj8lZrBfjKzQrwyMpH53CzQJj9ypOx9ldjM/MVxf9i9wi/rS4BWV7WA==
+"@esbuild/netbsd-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.19.0.tgz#2e6e8d869b58aea34bab9c0c47f15ae1bda29a90"
+  integrity sha512-AMQAp/5oENgDOvVhvOlbhVe1pWii7oFAMRHlmTjSEMcpjTpIHtFXhv9uAFgUERHm3eYtNvS9Vf+gT55cwuI6Aw==
 
 "@esbuild/openbsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz#95e75a391403cb10297280d524d66ce04c920691"
   integrity sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==
 
-"@esbuild/openbsd-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.18.0.tgz#3aae07b2854f73d9b1a413ffb03f72af63612393"
-  integrity sha512-eDolHeG3REnEIgwl7Lw2S0znUMY4PFVtCAzLKqdRO0HD+iPKJR8n2MEJJyhPdUjcobo8SEQ2AG6gtYfft9VFHg==
+"@esbuild/openbsd-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.19.0.tgz#ca0817d3ab332afb0d8d96a2eb42b4d8ebaa8715"
+  integrity sha512-fDztEve1QUs3h/Dw2AUmBlWGkNQbhDoD05ppm5jKvzQv+HVuV13so7m5RYeiSMIC2XQy7PAjZh+afkxAnCRZxA==
 
 "@esbuild/sunos-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz#722eaf057b83c2575937d3ffe5aeb16540da7273"
   integrity sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==
 
-"@esbuild/sunos-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.18.0.tgz#1f3ff9aaf941b13cfabbc93f3e213a8d38a0c50f"
-  integrity sha512-kl7vONem2wmRQke015rSrknmc6TYXKVNs2quiVTdvkSufscrjegpNqKyP7v6EHqXtvkzrB92ySjpfzazKG627g==
+"@esbuild/sunos-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.19.0.tgz#8de27de2563cb3eb6c1af066b6d7fcb1229fe3d4"
+  integrity sha512-bKZzJ2/rvUjDzA5Ddyva2tMk89WzNJEibZEaq+wY6SiqPlwgFbqyQLimouxLHiHh1itb5P3SNCIF1bc2bw5H9w==
 
 "@esbuild/win32-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz#9aa9dc074399288bdcdd283443e9aeb6b9552b6f"
   integrity sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==
 
-"@esbuild/win32-arm64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.18.0.tgz#fa32bfa8e716d3fd7d56ee8db831dc73f9fa53f5"
-  integrity sha512-WohArFQ3HStBu9MAsx3JUk2wfC2v8QoadnMoNfx3Y26ac54tD/wQhPzw4QOzQbSqOFqzIMLKWbxindTsko+9OA==
+"@esbuild/win32-arm64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.19.0.tgz#67c2b410ff8862be2cd61145ad21e11be00fb914"
+  integrity sha512-NQJ+4jmnA79saI+sE+QzcEls19uZkoEmdxo7r//PDOjIpX8pmoWtTnWg6XcbnO7o4fieyAwb5U2LvgWynF4diA==
 
 "@esbuild/win32-ia32@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz#95ad43c62ad62485e210f6299c7b2571e48d2b03"
   integrity sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==
 
-"@esbuild/win32-ia32@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.18.0.tgz#8b73a47dff29a2fc5f80ab3672ee232afab1ded8"
-  integrity sha512-SdnpSOxpeoewYCurmfLVepLuhOAphWkGTxWHifFjp37DaUHwF1fpGzyxhZoXMt5MKGuAO5aE3c5668YYtno+9Q==
+"@esbuild/win32-ia32@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.19.0.tgz#cac8992219c6d943bb22226e4afeb3774a29cca1"
+  integrity sha512-uyxiZAnsfu9diHm9/rIH2soecF/HWLXYUhJKW4q1+/LLmNQ+55lRjvSUDhUmsgJtSUscRJB/3S4RNiTb9o9mCg==
 
 "@esbuild/win32-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz#8cfaf2ff603e9aabb910e9c0558c26cf32744061"
   integrity sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==
 
-"@esbuild/win32-x64@0.18.0":
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.18.0.tgz#0303dbc50da2f5f6f86e1847b7db9c6eca497881"
-  integrity sha512-WJxImv0Pehpbo+pgg7Xrn88/b6ZzSweNHTw/2LW95JjeQUIS6ToJeQmjAdud9H3yiHJmhLOmEAOvUdNLhptD0w==
+"@esbuild/win32-x64@0.19.0":
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.19.0.tgz#fa5f12c96811cec3233a53bdbf61d1a05ba9018f"
+  integrity sha512-jl+NXUjK2StMgqnZnqgNjZuerFG8zQqWXMBZdMMv4W/aO1ZKQaYWZBxTrtWKphkCBVEMh0wMVfGgOd2BjOZqUQ==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.4.0":
   version "4.4.0"
@@ -3503,33 +3503,33 @@ esbuild-plugin-alias@0.2.1:
   resolved "https://registry.yarnpkg.com/esbuild-plugin-alias/-/esbuild-plugin-alias-0.2.1.tgz#45a86cb941e20e7c2bc68a2bea53562172494fcb"
   integrity sha512-jyfL/pwPqaFXyKnj8lP8iLk6Z0m099uXR45aSN8Av1XD4vhvQutxxPzgA2bTcAwQpa1zCXDcWOlhFgyP3GKqhQ==
 
-esbuild@0.18.0:
-  version "0.18.0"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.18.0.tgz#fac21a2995733e72d3dc0fda1658c79a80f2c113"
-  integrity sha512-/2sQaWHNX2jkglLu85EjmEAR2ANpKOa1kp2rAE3wjKcuYjEHFlB+D60tn6W9BRgHiAQEKYtl4hEygKWothfDEA==
+esbuild@0.19.0:
+  version "0.19.0"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.19.0.tgz#f187e4ce3bcc7396d13f408a991655efeba65282"
+  integrity sha512-i7i8TP4vuG55bKeLyqqk5sTPu1ZjPH3wkcLvAj/0X/222iWFo3AJUYRKjbOoY6BWFMH3teizxHEdV9Su5ESl0w==
   optionalDependencies:
-    "@esbuild/android-arm" "0.18.0"
-    "@esbuild/android-arm64" "0.18.0"
-    "@esbuild/android-x64" "0.18.0"
-    "@esbuild/darwin-arm64" "0.18.0"
-    "@esbuild/darwin-x64" "0.18.0"
-    "@esbuild/freebsd-arm64" "0.18.0"
-    "@esbuild/freebsd-x64" "0.18.0"
-    "@esbuild/linux-arm" "0.18.0"
-    "@esbuild/linux-arm64" "0.18.0"
-    "@esbuild/linux-ia32" "0.18.0"
-    "@esbuild/linux-loong64" "0.18.0"
-    "@esbuild/linux-mips64el" "0.18.0"
-    "@esbuild/linux-ppc64" "0.18.0"
-    "@esbuild/linux-riscv64" "0.18.0"
-    "@esbuild/linux-s390x" "0.18.0"
-    "@esbuild/linux-x64" "0.18.0"
-    "@esbuild/netbsd-x64" "0.18.0"
-    "@esbuild/openbsd-x64" "0.18.0"
-    "@esbuild/sunos-x64" "0.18.0"
-    "@esbuild/win32-arm64" "0.18.0"
-    "@esbuild/win32-ia32" "0.18.0"
-    "@esbuild/win32-x64" "0.18.0"
+    "@esbuild/android-arm" "0.19.0"
+    "@esbuild/android-arm64" "0.19.0"
+    "@esbuild/android-x64" "0.19.0"
+    "@esbuild/darwin-arm64" "0.19.0"
+    "@esbuild/darwin-x64" "0.19.0"
+    "@esbuild/freebsd-arm64" "0.19.0"
+    "@esbuild/freebsd-x64" "0.19.0"
+    "@esbuild/linux-arm" "0.19.0"
+    "@esbuild/linux-arm64" "0.19.0"
+    "@esbuild/linux-ia32" "0.19.0"
+    "@esbuild/linux-loong64" "0.19.0"
+    "@esbuild/linux-mips64el" "0.19.0"
+    "@esbuild/linux-ppc64" "0.19.0"
+    "@esbuild/linux-riscv64" "0.19.0"
+    "@esbuild/linux-s390x" "0.19.0"
+    "@esbuild/linux-x64" "0.19.0"
+    "@esbuild/netbsd-x64" "0.19.0"
+    "@esbuild/openbsd-x64" "0.19.0"
+    "@esbuild/sunos-x64" "0.19.0"
+    "@esbuild/win32-arm64" "0.19.0"
+    "@esbuild/win32-ia32" "0.19.0"
+    "@esbuild/win32-x64" "0.19.0"
 
 esbuild@^0.17.11:
   version "0.17.19"

From a488b29425c8913e979e71d6814c414e737c7835 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sat, 12 Aug 2023 12:26:07 +0900
Subject: [PATCH 146/749] GH-37129: [CI][Docs] Free up disk space (#37131)

### Rationale for this change

We need many disk space for building docs.

### What changes are included in this PR?

Reuse existing free code.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37129

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/docs.yml    |  3 ++
 ci/scripts/util_free_space.sh | 71 +++++++++++++++++++++++++++++++++++
 dev/tasks/macros.jinja        | 48 +----------------------
 3 files changed, 75 insertions(+), 47 deletions(-)
 create mode 100755 ci/scripts/util_free_space.sh

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 8bef50335ae8a..ac9ca6da25ba1 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -41,6 +41,9 @@ jobs:
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
+      - name: Free up disk space
+        run: |
+          ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
         uses: actions/cache@v3
         with:
diff --git a/ci/scripts/util_free_space.sh b/ci/scripts/util_free_space.sh
new file mode 100755
index 0000000000000..54445d0d49172
--- /dev/null
+++ b/ci/scripts/util_free_space.sh
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -eux
+
+if [ "${GITHUB_ACTIONS}" = "true" ]; then
+  df -h
+  echo "::group::/usr/local/*"
+  du -hsc /usr/local/*
+  echo "::endgroup::"
+  echo "::group::/usr/local/bin/*"
+  du -hsc /usr/local/bin/*
+  echo "::endgroup::"
+  # ~1GB (From 1.2GB to 214MB)
+  sudo rm -rf \
+    /usr/local/bin/aliyun \
+    /usr/local/bin/azcopy \
+    /usr/local/bin/bicep \
+    /usr/local/bin/cmake-gui \
+    /usr/local/bin/cpack \
+    /usr/local/bin/helm \
+    /usr/local/bin/hub \
+    /usr/local/bin/kubectl \
+    /usr/local/bin/minikube \
+    /usr/local/bin/node \
+    /usr/local/bin/packer \
+    /usr/local/bin/pulumi* \
+    /usr/local/bin/stack \
+    /usr/local/bin/terraform || :
+  echo "::group::/usr/local/share/*"
+  du -hsc /usr/local/share/*
+  echo "::endgroup::"
+  # 1.3GB
+  sudo rm -rf /usr/local/share/powershell || :
+  echo "::group::/opt/*"
+  du -hsc /opt/*
+  echo "::endgroup::"
+  echo "::group::/opt/hostedtoolcache/*"
+  du -hsc /opt/hostedtoolcache/*
+  echo "::endgroup::"
+  # 5.3GB
+  sudo rm -rf /opt/hostedtoolcache/CodeQL || :
+  # 1.4GB
+  sudo rm -rf /opt/hostedtoolcache/go || :
+  # 489MB
+  sudo rm -rf /opt/hostedtoolcache/PyPy || :
+  # 376MB
+  sudo rm -rf /opt/hostedtoolcache/node || :
+  # Remove Web browser packages
+  sudo apt purge -y \
+    firefox \
+    google-chrome-stable \
+    microsoft-edge-stable
+  df -h
+fi
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 757c15c937ce5..8ec351a270c74 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -77,53 +77,7 @@ on:
     if: runner.os == 'Linux' && runner.arch == 'X64'
     shell: bash
     run: |
-      df -h
-      echo "::group::/usr/local/*"
-      du -hsc /usr/local/*
-      echo "::endgroup::"
-      echo "::group::/usr/local/bin/*"
-      du -hsc /usr/local/bin/*
-      echo "::endgroup::"
-      # ~1GB (From 1.2GB to 214MB)
-      sudo rm -rf \
-        /usr/local/bin/aliyun \
-        /usr/local/bin/azcopy \
-        /usr/local/bin/bicep \
-        /usr/local/bin/cmake-gui \
-        /usr/local/bin/cpack \
-        /usr/local/bin/helm \
-        /usr/local/bin/hub \
-        /usr/local/bin/kubectl \
-        /usr/local/bin/minikube \
-        /usr/local/bin/node \
-        /usr/local/bin/packer \
-        /usr/local/bin/pulumi* \
-        /usr/local/bin/stack \
-        /usr/local/bin/terraform || :
-      echo "::group::/usr/local/share/*"
-      du -hsc /usr/local/share/*
-      echo "::endgroup::"
-      # 1.3GB
-      sudo rm -rf /usr/local/share/powershell || :
-      echo "::group::/opt/*"
-      du -hsc /opt/*
-      echo "::endgroup::"
-      echo "::group::/opt/hostedtoolcache/*"
-      du -hsc /opt/hostedtoolcache/*
-      echo "::endgroup::"
-      # 5.3GB
-      sudo rm -rf /opt/hostedtoolcache/CodeQL || :
-      # 1.4GB
-      sudo rm -rf /opt/hostedtoolcache/go || :
-      # 489MB
-      sudo rm -rf /opt/hostedtoolcache/PyPy || :
-      # 376MB
-      sudo rm -rf /opt/hostedtoolcache/node || :
-      # Remove Web browser packages
-      sudo apt-get purge -y -f firefox \
-              google-chrome-stable \
-              microsoft-edge-stable
-      df -h
+      arrow/ci/scripts/util_free_space.sh
 {% endmacro %}
 
 {%- macro github_upload_releases(pattern) -%}

From 9f1fdda790de02b250f2c37c5b80f28af21a3ec7 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sat, 12 Aug 2023 12:26:55 +0900
Subject: [PATCH 147/749] MINOR: [CI][C++] Remove needless NPROC from Windows
 job (#37130)

### Rationale for this change

It's not used ci/scripts/cpp_build.sh. NUMBER_OF_PROCESSORS is used instead because uname is MINGW64_NT-10.0-20348.

### What changes are included in this PR?

Remove unused NPROC.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/cpp.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index fb76faa529e5c..401f5dcf8916f 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -272,7 +272,6 @@ jobs:
       CMAKE_INSTALL_LIBDIR: bin
       CMAKE_INSTALL_PREFIX: /usr
       CMAKE_UNITY_BUILD: ON
-      NPROC: 3
     steps:
       - name: Disable Crash Dialogs
         run: |

From 757e0d5cca1124139cd08512882debcb7b4d65d5 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sun, 13 Aug 2023 05:56:20 +0900
Subject: [PATCH 148/749] GH-37129: [CI][Docs] Use Ubuntu 22.04 (#37132)

### Rationale for this change

It also reduces disk usage because we can use system gRPC on Ubuntu 22.04.

### What changes are included in this PR?

Use Ubuntu 22.04.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37129

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/docs.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index ac9ca6da25ba1..a4629001f8e48 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -30,12 +30,12 @@ env:
 jobs:
 
   complete:
-    name: AMD64 Ubuntu 20.04 Complete Documentation
+    name: AMD64 Ubuntu 22.04 Complete Documentation
     runs-on: ubuntu-latest
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     timeout-minutes: 150
     env:
-      UBUNTU: "20.04"
+      UBUNTU: "22.04"
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v3

From 9cabd94af55719a88ea974cc60bb673d09032761 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=B0=A2=E5=A4=A9?= <jsjtxietian@outlook.com>
Date: Mon, 14 Aug 2023 20:09:16 +0800
Subject: [PATCH 149/749] GH-36950: [C++] Change
 std::vector<std::shared_ptr<Field>> to use it's alias: FieldVector (#37101)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Clarity and Maintainability

### What changes are included in this PR?

1. Changed all occurrence of std::vector<std::shared_ptr<Field>> in **type_fwd.h**、**type.h** and **type.cc** to FieldVector for consistency.
2. Use move to eliminate vector copy in sparse and dense union's constructor

### Are these changes tested?

Covered by existing tests

### Are there any user-facing changes?

No

* Closes: #36950

Authored-by: jsjtxietian <jsjtxietian@outlook.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/type.cc    | 85 +++++++++++++++++-----------------------
 cpp/src/arrow/type.h     | 38 ++++++++----------
 cpp/src/arrow/type_fwd.h |  8 ++--
 3 files changed, 57 insertions(+), 74 deletions(-)

diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 86df91268f8b9..21c47e17239cb 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -277,9 +277,9 @@ std::shared_ptr<Field> MaybePromoteNullTypes(const Field& existing, const Field&
   return existing.WithNullable(true);
 }
 
-std::vector<std::shared_ptr<Field>> MakeFields(
+FieldVector MakeFields(
     std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> init_list) {
-  std::vector<std::shared_ptr<Field>> fields;
+  FieldVector fields;
   fields.reserve(init_list.size());
   for (const auto& [name, type] : init_list) {
     fields.push_back(field(name, type));
@@ -357,8 +357,8 @@ Result<std::shared_ptr<Field>> Field::MergeWith(const std::shared_ptr<Field>& ot
   return MergeWith(*other, options);
 }
 
-std::vector<std::shared_ptr<Field>> Field::Flatten() const {
-  std::vector<std::shared_ptr<Field>> flattened;
+FieldVector Field::Flatten() const {
+  FieldVector flattened;
   if (type_->id() == Type::STRUCT) {
     for (const auto& child : type_->fields()) {
       auto flattened_child = child->Copy();
@@ -720,8 +720,7 @@ UnionMode::type UnionType::mode() const {
   return id_ == Type::SPARSE_UNION ? UnionMode::SPARSE : UnionMode::DENSE;
 }
 
-UnionType::UnionType(std::vector<std::shared_ptr<Field>> fields,
-                     std::vector<int8_t> type_codes, Type::type id)
+UnionType::UnionType(FieldVector fields, std::vector<int8_t> type_codes, Type::type id)
     : NestedType(id),
       type_codes_(std::move(type_codes)),
       child_ids_(kMaxTypeCode + 1, kInvalidChildId) {
@@ -733,7 +732,7 @@ UnionType::UnionType(std::vector<std::shared_ptr<Field>> fields,
   }
 }
 
-Status UnionType::ValidateParameters(const std::vector<std::shared_ptr<Field>>& fields,
+Status UnionType::ValidateParameters(const FieldVector& fields,
                                      const std::vector<int8_t>& type_codes,
                                      UnionMode::type mode) {
   if (fields.size() != type_codes.size()) {
@@ -779,24 +778,22 @@ std::string UnionType::ToString() const {
   return s.str();
 }
 
-SparseUnionType::SparseUnionType(std::vector<std::shared_ptr<Field>> fields,
-                                 std::vector<int8_t> type_codes)
-    : UnionType(fields, type_codes, Type::SPARSE_UNION) {}
+SparseUnionType::SparseUnionType(FieldVector fields, std::vector<int8_t> type_codes)
+    : UnionType(std::move(fields), std::move(type_codes), Type::SPARSE_UNION) {}
 
-Result<std::shared_ptr<DataType>> SparseUnionType::Make(
-    std::vector<std::shared_ptr<Field>> fields, std::vector<int8_t> type_codes) {
+Result<std::shared_ptr<DataType>> SparseUnionType::Make(FieldVector fields,
+                                                        std::vector<int8_t> type_codes) {
   RETURN_NOT_OK(ValidateParameters(fields, type_codes, UnionMode::SPARSE));
-  return std::make_shared<SparseUnionType>(fields, type_codes);
+  return std::make_shared<SparseUnionType>(std::move(fields), std::move(type_codes));
 }
 
-DenseUnionType::DenseUnionType(std::vector<std::shared_ptr<Field>> fields,
-                               std::vector<int8_t> type_codes)
-    : UnionType(fields, type_codes, Type::DENSE_UNION) {}
+DenseUnionType::DenseUnionType(FieldVector fields, std::vector<int8_t> type_codes)
+    : UnionType(std::move(fields), std::move(type_codes), Type::DENSE_UNION) {}
 
-Result<std::shared_ptr<DataType>> DenseUnionType::Make(
-    std::vector<std::shared_ptr<Field>> fields, std::vector<int8_t> type_codes) {
+Result<std::shared_ptr<DataType>> DenseUnionType::Make(FieldVector fields,
+                                                       std::vector<int8_t> type_codes) {
   RETURN_NOT_OK(ValidateParameters(fields, type_codes, UnionMode::DENSE));
-  return std::make_shared<DenseUnionType>(fields, type_codes);
+  return std::make_shared<DenseUnionType>(std::move(fields), std::move(type_codes));
 }
 
 // ----------------------------------------------------------------------
@@ -829,7 +826,7 @@ bool RunEndEncodedType::RunEndTypeValid(const DataType& run_end_type) {
 namespace {
 
 std::unordered_multimap<std::string, int> CreateNameToIndexMap(
-    const std::vector<std::shared_ptr<Field>>& fields) {
+    const FieldVector& fields) {
   std::unordered_multimap<std::string, int> name_to_index;
   for (size_t i = 0; i < fields.size(); ++i) {
     name_to_index.emplace(fields[i]->name(), static_cast<int>(i));
@@ -858,13 +855,13 @@ int LookupNameIndex(const std::unordered_multimap<std::string, int>& name_to_ind
 
 class StructType::Impl {
  public:
-  explicit Impl(const std::vector<std::shared_ptr<Field>>& fields)
+  explicit Impl(const FieldVector& fields)
       : name_to_index_(CreateNameToIndexMap(fields)) {}
 
   const std::unordered_multimap<std::string, int> name_to_index_;
 };
 
-StructType::StructType(const std::vector<std::shared_ptr<Field>>& fields)
+StructType::StructType(const FieldVector& fields)
     : NestedType(Type::STRUCT), impl_(new Impl(fields)) {
   children_ = fields;
 }
@@ -906,9 +903,8 @@ std::vector<int> StructType::GetAllFieldIndices(const std::string& name) const {
   return result;
 }
 
-std::vector<std::shared_ptr<Field>> StructType::GetAllFieldsByName(
-    const std::string& name) const {
-  std::vector<std::shared_ptr<Field>> result;
+FieldVector StructType::GetAllFieldsByName(const std::string& name) const {
+  FieldVector result;
   auto p = impl_->name_to_index_.equal_range(name);
   for (auto it = p.first; it != p.second; ++it) {
     result.push_back(children_[it->second]);
@@ -1318,7 +1314,7 @@ Result<std::shared_ptr<Field>> FieldPath::Get(const FieldVector& fields) const {
 
 Result<std::shared_ptr<Schema>> FieldPath::GetAll(const Schema& schm,
                                                   const std::vector<FieldPath>& paths) {
-  std::vector<std::shared_ptr<Field>> fields;
+  FieldVector fields;
   fields.reserve(paths.size());
   for (const auto& path : paths) {
     ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Field> field, path.Get(schm));
@@ -1737,26 +1733,25 @@ std::string EndiannessToString(Endianness endianness) {
 
 class Schema::Impl {
  public:
-  Impl(std::vector<std::shared_ptr<Field>> fields, Endianness endianness,
+  Impl(FieldVector fields, Endianness endianness,
        std::shared_ptr<const KeyValueMetadata> metadata)
       : fields_(std::move(fields)),
         endianness_(endianness),
         name_to_index_(CreateNameToIndexMap(fields_)),
         metadata_(std::move(metadata)) {}
 
-  std::vector<std::shared_ptr<Field>> fields_;
+  FieldVector fields_;
   Endianness endianness_;
   std::unordered_multimap<std::string, int> name_to_index_;
   std::shared_ptr<const KeyValueMetadata> metadata_;
 };
 
-Schema::Schema(std::vector<std::shared_ptr<Field>> fields, Endianness endianness,
+Schema::Schema(FieldVector fields, Endianness endianness,
                std::shared_ptr<const KeyValueMetadata> metadata)
     : detail::Fingerprintable(),
       impl_(new Impl(std::move(fields), endianness, std::move(metadata))) {}
 
-Schema::Schema(std::vector<std::shared_ptr<Field>> fields,
-               std::shared_ptr<const KeyValueMetadata> metadata)
+Schema::Schema(FieldVector fields, std::shared_ptr<const KeyValueMetadata> metadata)
     : detail::Fingerprintable(),
       impl_(new Impl(std::move(fields), Endianness::Native, std::move(metadata))) {}
 
@@ -1781,9 +1776,7 @@ const std::shared_ptr<Field>& Schema::field(int i) const {
   return impl_->fields_[i];
 }
 
-const std::vector<std::shared_ptr<Field>>& Schema::fields() const {
-  return impl_->fields_;
-}
+const FieldVector& Schema::fields() const { return impl_->fields_; }
 
 bool Schema::Equals(const Schema& other, bool check_metadata) const {
   if (this == &other) {
@@ -1865,9 +1858,8 @@ Status Schema::CanReferenceFieldsByNames(const std::vector<std::string>& names)
   return Status::OK();
 }
 
-std::vector<std::shared_ptr<Field>> Schema::GetAllFieldsByName(
-    const std::string& name) const {
-  std::vector<std::shared_ptr<Field>> result;
+FieldVector Schema::GetAllFieldsByName(const std::string& name) const {
+  FieldVector result;
   auto p = impl_->name_to_index_.equal_range(name);
   for (auto it = p.first; it != p.second; ++it) {
     result.push_back(impl_->fields_[it->second]);
@@ -1979,9 +1971,8 @@ class SchemaBuilder::Impl {
   Impl(ConflictPolicy policy, Field::MergeOptions field_merge_options)
       : policy_(policy), field_merge_options_(field_merge_options) {}
 
-  Impl(std::vector<std::shared_ptr<Field>> fields,
-       std::shared_ptr<const KeyValueMetadata> metadata, ConflictPolicy conflict_policy,
-       Field::MergeOptions field_merge_options)
+  Impl(FieldVector fields, std::shared_ptr<const KeyValueMetadata> metadata,
+       ConflictPolicy conflict_policy, Field::MergeOptions field_merge_options)
       : fields_(std::move(fields)),
         name_to_index_(CreateNameToIndexMap(fields_)),
         metadata_(std::move(metadata)),
@@ -2046,7 +2037,7 @@ class SchemaBuilder::Impl {
   }
 
  private:
-  std::vector<std::shared_ptr<Field>> fields_;
+  FieldVector fields_;
   std::unordered_multimap<std::string, int> name_to_index_;
   std::shared_ptr<const KeyValueMetadata> metadata_;
   ConflictPolicy policy_;
@@ -2058,8 +2049,7 @@ SchemaBuilder::SchemaBuilder(ConflictPolicy policy,
   impl_ = std::make_unique<Impl>(policy, field_merge_options);
 }
 
-SchemaBuilder::SchemaBuilder(std::vector<std::shared_ptr<Field>> fields,
-                             ConflictPolicy policy,
+SchemaBuilder::SchemaBuilder(FieldVector fields, ConflictPolicy policy,
                              Field::MergeOptions field_merge_options) {
   impl_ = std::make_unique<Impl>(std::move(fields), nullptr, policy, field_merge_options);
 }
@@ -2087,7 +2077,7 @@ Status SchemaBuilder::AddField(const std::shared_ptr<Field>& field) {
   return impl_->AddField(field);
 }
 
-Status SchemaBuilder::AddFields(const std::vector<std::shared_ptr<Field>>& fields) {
+Status SchemaBuilder::AddFields(const FieldVector& fields) {
   for (const auto& field : fields) {
     RETURN_NOT_OK(AddField(field));
   }
@@ -2131,7 +2121,7 @@ Status SchemaBuilder::AreCompatible(const std::vector<std::shared_ptr<Schema>>&
   return Merge(schemas, policy).status();
 }
 
-std::shared_ptr<Schema> schema(std::vector<std::shared_ptr<Field>> fields,
+std::shared_ptr<Schema> schema(FieldVector fields,
                                std::shared_ptr<const KeyValueMetadata> metadata) {
   return std::make_shared<Schema>(std::move(fields), std::move(metadata));
 }
@@ -2142,8 +2132,7 @@ std::shared_ptr<Schema> schema(
   return std::make_shared<Schema>(MakeFields(fields), std::move(metadata));
 }
 
-std::shared_ptr<Schema> schema(std::vector<std::shared_ptr<Field>> fields,
-                               Endianness endianness,
+std::shared_ptr<Schema> schema(FieldVector fields, Endianness endianness,
                                std::shared_ptr<const KeyValueMetadata> metadata) {
   return std::make_shared<Schema>(std::move(fields), endianness, std::move(metadata));
 }
@@ -2660,7 +2649,7 @@ std::shared_ptr<DataType> fixed_size_list(const std::shared_ptr<Field>& value_fi
   return std::make_shared<FixedSizeListType>(value_field, list_size);
 }
 
-std::shared_ptr<DataType> struct_(const std::vector<std::shared_ptr<Field>>& fields) {
+std::shared_ptr<DataType> struct_(const FieldVector& fields) {
   return std::make_shared<StructType>(fields);
 }
 
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index ccd1ddccf54ce..718540d449226 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -146,7 +146,7 @@ class ARROW_EXPORT DataType : public std::enable_shared_from_this<DataType>,
   const std::shared_ptr<Field>& field(int i) const { return children_[i]; }
 
   /// \brief Return the children fields associated with this type.
-  const std::vector<std::shared_ptr<Field>>& fields() const { return children_; }
+  const FieldVector& fields() const { return children_; }
 
   /// \brief Return the number of children fields associated with this type.
   int num_fields() const { return static_cast<int>(children_.size()); }
@@ -204,7 +204,7 @@ class ARROW_EXPORT DataType : public std::enable_shared_from_this<DataType>,
   std::string ComputeMetadataFingerprint() const override;
 
   Type::type id_;
-  std::vector<std::shared_ptr<Field>> children_;
+  FieldVector children_;
 
  private:
   ARROW_DISALLOW_COPY_AND_ASSIGN(DataType);
@@ -421,7 +421,7 @@ class ARROW_EXPORT Field : public detail::Fingerprintable,
       const std::shared_ptr<Field>& other,
       MergeOptions options = MergeOptions::Defaults()) const;
 
-  std::vector<std::shared_ptr<Field>> Flatten() const;
+  FieldVector Flatten() const;
 
   /// \brief Indicate if fields are equals.
   ///
@@ -1078,7 +1078,7 @@ class ARROW_EXPORT StructType : public NestedType {
 
   static constexpr const char* type_name() { return "struct"; }
 
-  explicit StructType(const std::vector<std::shared_ptr<Field>>& fields);
+  explicit StructType(const FieldVector& fields);
 
   ~StructType() override;
 
@@ -1093,7 +1093,7 @@ class ARROW_EXPORT StructType : public NestedType {
   std::shared_ptr<Field> GetFieldByName(const std::string& name) const;
 
   /// Return all fields having this name
-  std::vector<std::shared_ptr<Field>> GetAllFieldsByName(const std::string& name) const;
+  FieldVector GetAllFieldsByName(const std::string& name) const;
 
   /// Returns -1 if name not found or if there are multiple fields having the
   /// same name
@@ -1125,8 +1125,8 @@ class ARROW_EXPORT UnionType : public NestedType {
   static constexpr int kInvalidChildId = -1;
 
   static Result<std::shared_ptr<DataType>> Make(
-      const std::vector<std::shared_ptr<Field>>& fields,
-      const std::vector<int8_t>& type_codes, UnionMode::type mode = UnionMode::SPARSE) {
+      const FieldVector& fields, const std::vector<int8_t>& type_codes,
+      UnionMode::type mode = UnionMode::SPARSE) {
     if (mode == UnionMode::SPARSE) {
       return sparse_union(fields, type_codes);
     } else {
@@ -1152,10 +1152,9 @@ class ARROW_EXPORT UnionType : public NestedType {
   UnionMode::type mode() const;
 
  protected:
-  UnionType(std::vector<std::shared_ptr<Field>> fields, std::vector<int8_t> type_codes,
-            Type::type id);
+  UnionType(FieldVector fields, std::vector<int8_t> type_codes, Type::type id);
 
-  static Status ValidateParameters(const std::vector<std::shared_ptr<Field>>& fields,
+  static Status ValidateParameters(const FieldVector& fields,
                                    const std::vector<int8_t>& type_codes,
                                    UnionMode::type mode);
 
@@ -1183,12 +1182,11 @@ class ARROW_EXPORT SparseUnionType : public UnionType {
 
   static constexpr const char* type_name() { return "sparse_union"; }
 
-  SparseUnionType(std::vector<std::shared_ptr<Field>> fields,
-                  std::vector<int8_t> type_codes);
+  SparseUnionType(FieldVector fields, std::vector<int8_t> type_codes);
 
   // A constructor variant that validates input parameters
-  static Result<std::shared_ptr<DataType>> Make(
-      std::vector<std::shared_ptr<Field>> fields, std::vector<int8_t> type_codes);
+  static Result<std::shared_ptr<DataType>> Make(FieldVector fields,
+                                                std::vector<int8_t> type_codes);
 
   std::string name() const override { return "sparse_union"; }
 };
@@ -1213,12 +1211,11 @@ class ARROW_EXPORT DenseUnionType : public UnionType {
 
   static constexpr const char* type_name() { return "dense_union"; }
 
-  DenseUnionType(std::vector<std::shared_ptr<Field>> fields,
-                 std::vector<int8_t> type_codes);
+  DenseUnionType(FieldVector fields, std::vector<int8_t> type_codes);
 
   // A constructor variant that validates input parameters
-  static Result<std::shared_ptr<DataType>> Make(
-      std::vector<std::shared_ptr<Field>> fields, std::vector<int8_t> type_codes);
+  static Result<std::shared_ptr<DataType>> Make(FieldVector fields,
+                                                std::vector<int8_t> type_codes);
 
   std::string name() const override { return "dense_union"; }
 };
@@ -2141,8 +2138,7 @@ class ARROW_EXPORT SchemaBuilder {
   /// \brief Construct a SchemaBuilder from a list of fields
   /// `field_merge_options` is only effective when `conflict_policy` == `CONFLICT_MERGE`.
   SchemaBuilder(
-      std::vector<std::shared_ptr<Field>> fields,
-      ConflictPolicy conflict_policy = CONFLICT_APPEND,
+      FieldVector fields, ConflictPolicy conflict_policy = CONFLICT_APPEND,
       Field::MergeOptions field_merge_options = Field::MergeOptions::Defaults());
   /// \brief Construct a SchemaBuilder from a schema, preserving the metadata
   /// `field_merge_options` is only effective when `conflict_policy` == `CONFLICT_MERGE`.
@@ -2167,7 +2163,7 @@ class ARROW_EXPORT SchemaBuilder {
   ///
   /// \param[in] fields to add to the constructed Schema.
   /// \return The first failure encountered, if any.
-  Status AddFields(const std::vector<std::shared_ptr<Field>>& fields);
+  Status AddFields(const FieldVector& fields);
 
   /// \brief Add fields of a Schema to the constructed Schema.
   ///
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index d3b41c8158cf7..db76c581f729e 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -557,8 +557,7 @@ ARROW_EXPORT std::shared_ptr<DataType> time32(TimeUnit::type unit);
 ARROW_EXPORT std::shared_ptr<DataType> time64(TimeUnit::type unit);
 
 /// \brief Create a StructType instance
-ARROW_EXPORT std::shared_ptr<DataType> struct_(
-    const std::vector<std::shared_ptr<Field>>& fields);
+ARROW_EXPORT std::shared_ptr<DataType> struct_(const FieldVector& fields);
 
 /// \brief Create a StructType instance from (name, type) pairs
 ARROW_EXPORT std::shared_ptr<DataType> struct_(
@@ -630,8 +629,7 @@ ARROW_EXPORT std::shared_ptr<Field> field(
 /// \return schema shared_ptr to Schema
 ARROW_EXPORT
 std::shared_ptr<Schema> schema(
-    std::vector<std::shared_ptr<Field>> fields,
-    std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
+    FieldVector fields, std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
 
 /// \brief Create a Schema instance from (name, type) pairs
 ///
@@ -653,7 +651,7 @@ std::shared_ptr<Schema> schema(
 /// \return schema shared_ptr to Schema
 ARROW_EXPORT
 std::shared_ptr<Schema> schema(
-    std::vector<std::shared_ptr<Field>> fields, Endianness endianness,
+    FieldVector fields, Endianness endianness,
     std::shared_ptr<const KeyValueMetadata> metadata = NULLPTR);
 
 /// \brief Create a Schema instance

From cd8830b43fa16d6017ff36282ebeb705a83eb709 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 14 Aug 2023 14:45:11 +0100
Subject: [PATCH 150/749] GH-36990: [R] Expose Parquet ReaderProperties
 (#36992)

### Rationale for this change

Expose the ReaderProperties class in R so that the thrift size settings can be altered.

### What changes are included in this PR?

Add R6 class, link it up to the C++ class, use it when reading Parquet files.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Nope
* Closes: #36990

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                      |   1 +
 r/R/arrowExports.R               |  28 ++++++--
 r/R/dataset-format.R             |  16 ++++-
 r/R/parquet.R                    |  48 +++++++++++++-
 r/_pkgdown.yml                   |   1 +
 r/man/FragmentScanOptions.Rd     |   7 ++
 r/man/ParquetFileReader.Rd       |   1 +
 r/man/ParquetReaderProperties.Rd |  27 ++++++++
 r/src/arrowExports.cpp           | 106 ++++++++++++++++++++++++++++---
 r/src/arrow_types.h              |   1 +
 r/src/dataset.cpp                |   7 +-
 r/src/parquet.cpp                |  34 +++++++++-
 r/tests/testthat/test-dataset.R  |  14 ++++
 r/tests/testthat/test-parquet.R  |  40 ++++++++++++
 14 files changed, 311 insertions(+), 20 deletions(-)
 create mode 100644 r/man/ParquetReaderProperties.Rd

diff --git a/r/NAMESPACE b/r/NAMESPACE
index 7eaa51bc5771f..f4799176425d7 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -246,6 +246,7 @@ export(ParquetFileFormat)
 export(ParquetFileReader)
 export(ParquetFileWriter)
 export(ParquetFragmentScanOptions)
+export(ParquetReaderProperties)
 export(ParquetVersionType)
 export(ParquetWriterProperties)
 export(Partitioning)
diff --git a/r/R/arrowExports.R b/r/R/arrowExports.R
index 10732100cd58a..f4ff3ef894532 100644
--- a/r/R/arrowExports.R
+++ b/r/R/arrowExports.R
@@ -748,8 +748,8 @@ dataset___JsonFragmentScanOptions__Make <- function(parse_options, read_options)
   .Call(`_arrow_dataset___JsonFragmentScanOptions__Make`, parse_options, read_options)
 }
 
-dataset___ParquetFragmentScanOptions__Make <- function(use_buffered_stream, buffer_size, pre_buffer) {
-  .Call(`_arrow_dataset___ParquetFragmentScanOptions__Make`, use_buffered_stream, buffer_size, pre_buffer)
+dataset___ParquetFragmentScanOptions__Make <- function(use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit, thrift_container_size_limit) {
+  .Call(`_arrow_dataset___ParquetFragmentScanOptions__Make`, use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit, thrift_container_size_limit)
 }
 
 dataset___DirectoryPartitioning <- function(schm, segment_encoding) {
@@ -1592,6 +1592,26 @@ parquet___arrow___ArrowReaderProperties__Make <- function(use_threads) {
   .Call(`_arrow_parquet___arrow___ArrowReaderProperties__Make`, use_threads)
 }
 
+parquet___arrow___ReaderProperties__Make <- function() {
+  .Call(`_arrow_parquet___arrow___ReaderProperties__Make`)
+}
+
+parquet___arrow___ReaderProperties__get_thrift_string_size_limit <- function(properties) {
+  .Call(`_arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit`, properties)
+}
+
+parquet___arrow___ReaderProperties__set_thrift_string_size_limit <- function(properties, size) {
+  invisible(.Call(`_arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit`, properties, size))
+}
+
+parquet___arrow___ReaderProperties__get_thrift_container_size_limit <- function(properties) {
+  .Call(`_arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit`, properties)
+}
+
+parquet___arrow___ReaderProperties__set_thrift_container_size_limit <- function(properties, size) {
+  invisible(.Call(`_arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit`, properties, size))
+}
+
 parquet___arrow___ArrowReaderProperties__set_use_threads <- function(properties, use_threads) {
   invisible(.Call(`_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads`, properties, use_threads))
 }
@@ -1616,8 +1636,8 @@ parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit <- func
   .Call(`_arrow_parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit`, properties)
 }
 
-parquet___arrow___FileReader__OpenFile <- function(file, props) {
-  .Call(`_arrow_parquet___arrow___FileReader__OpenFile`, file, props)
+parquet___arrow___FileReader__OpenFile <- function(file, props, reader_props) {
+  .Call(`_arrow_parquet___arrow___FileReader__OpenFile`, file, props, reader_props)
 }
 
 parquet___arrow___FileReader__ReadTable1 <- function(reader) {
diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R
index 8798e0248e0f6..9c7e332f5ea2c 100644
--- a/r/R/dataset-format.R
+++ b/r/R/dataset-format.R
@@ -518,6 +518,13 @@ csv_file_format_read_opts <- function(schema = NULL, ...) {
 #'   * `buffer_size`: Size of buffered stream, if enabled. Default is 8KB.
 #'   * `pre_buffer`: Pre-buffer the raw Parquet data. This can improve performance
 #'                   on high-latency filesystems. Disabled by default.
+#'   * `thrift_string_size_limit`: Maximum string size allocated for decoding thrift
+#'                                 strings. May need to be increased in order to read
+#'                                 files with especially large headers. Default value
+#'                                 100000000.
+#'   * `thrift_container_size_limit`: Maximum size of thrift containers.  May need to be
+#'                                    increased in order to read files with especially large
+#'                                    headers. Default value 1000000.
 #
 #'   `format = "text"`: see [CsvConvertOptions]. Note that options can only be
 #'   specified with the Arrow C++ library naming. Also, "block_size" from
@@ -571,8 +578,13 @@ CsvFragmentScanOptions$create <- function(...,
 ParquetFragmentScanOptions <- R6Class("ParquetFragmentScanOptions", inherit = FragmentScanOptions)
 ParquetFragmentScanOptions$create <- function(use_buffered_stream = FALSE,
                                               buffer_size = 8196,
-                                              pre_buffer = TRUE) {
-  dataset___ParquetFragmentScanOptions__Make(use_buffered_stream, buffer_size, pre_buffer)
+                                              pre_buffer = TRUE,
+                                              thrift_string_size_limit = 100000000,
+                                              thrift_container_size_limit = 1000000) {
+  dataset___ParquetFragmentScanOptions__Make(
+    use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit,
+    thrift_container_size_limit
+  )
 }
 
 #' @usage NULL
diff --git a/r/R/parquet.R b/r/R/parquet.R
index db224a41e4019..a58f7810b6ec7 100644
--- a/r/R/parquet.R
+++ b/r/R/parquet.R
@@ -457,6 +457,7 @@ ParquetFileWriter$create <- function(schema,
 #'    (e.g. `RandomAccessFile`).
 #' - `props` Optional [ParquetArrowReaderProperties]
 #' - `mmap` Logical: whether to memory-map the file (default `TRUE`)
+#' - `reader_props` Optional [ParquetReaderProperties]
 #' - `...` Additional arguments, currently ignored
 #'
 #' @section Methods:
@@ -541,12 +542,13 @@ ParquetFileReader <- R6Class("ParquetFileReader",
 ParquetFileReader$create <- function(file,
                                      props = ParquetArrowReaderProperties$create(),
                                      mmap = TRUE,
+                                     reader_props = ParquetReaderProperties$create(),
                                      ...) {
   file <- make_readable_file(file, mmap)
   assert_is(props, "ParquetArrowReaderProperties")
   assert_is(file, "RandomAccessFile")
 
-  parquet___arrow___FileReader__OpenFile(file, props)
+  parquet___arrow___FileReader__OpenFile(file, props, reader_props)
 }
 
 #' @title ParquetArrowReaderProperties class
@@ -625,3 +627,47 @@ calculate_chunk_size <- function(rows, columns,
 
   chunk_size
 }
+
+#' @title ParquetReaderProperties class
+#' @rdname ParquetReaderProperties
+#' @name ParquetReaderProperties
+#' @docType class
+#' @usage NULL
+#' @format NULL
+#' @description This class holds settings to control how a Parquet file is read
+#' by [ParquetFileReader].
+#'
+#' @section Factory:
+#'
+#' The `ParquetReaderProperties$create()` factory method instantiates the object
+#' and takes no arguments.
+#'
+#' @section Methods:
+#'
+#' - `$thrift_string_size_limit()`
+#' - `$set_thrift_string_size_limit()`
+#' - `$thrift_container_size_limit()`
+#' - `$set_thrift_container_size_limit()`
+#'
+#' @export
+ParquetReaderProperties <- R6Class("ParquetReaderProperties",
+  inherit = ArrowObject,
+  public = list(
+    thrift_string_size_limit = function() {
+      parquet___arrow___ReaderProperties__get_thrift_string_size_limit(self)
+    },
+    set_thrift_string_size_limit = function(size) {
+      parquet___arrow___ReaderProperties__set_thrift_string_size_limit(self, size)
+    },
+    thrift_container_size_limit = function() {
+      parquet___arrow___ReaderProperties__get_thrift_container_size_limit(self)
+    },
+    set_thrift_container_size_limit = function(size) {
+      parquet___arrow___ReaderProperties__set_thrift_container_size_limit(self, size)
+    }
+  )
+)
+
+ParquetReaderProperties$create <- function() {
+  parquet___arrow___ReaderProperties__Make()
+}
diff --git a/r/_pkgdown.yml b/r/_pkgdown.yml
index 9facce9d1b28b..10323a4796602 100644
--- a/r/_pkgdown.yml
+++ b/r/_pkgdown.yml
@@ -278,6 +278,7 @@ reference:
 - title: File read/writer interface
   contents:
   - ParquetFileReader
+  - ParquetReaderProperties
   - ParquetArrowReaderProperties
   - ParquetFileWriter
   - ParquetWriterProperties
diff --git a/r/man/FragmentScanOptions.Rd b/r/man/FragmentScanOptions.Rd
index 79bb3ea3c3158..7b597c2f017be 100644
--- a/r/man/FragmentScanOptions.Rd
+++ b/r/man/FragmentScanOptions.Rd
@@ -29,6 +29,13 @@ to reduce memory overhead. Disabled by default.
 \item \code{buffer_size}: Size of buffered stream, if enabled. Default is 8KB.
 \item \code{pre_buffer}: Pre-buffer the raw Parquet data. This can improve performance
 on high-latency filesystems. Disabled by default.
+\item \code{thrift_string_size_limit}: Maximum string size allocated for decoding thrift
+strings. May need to be increased in order to read
+files with especially large headers. Default value
+100000000.
+\item \code{thrift_container_size_limit}: Maximum size of thrift containers.  May need to be
+increased in order to read files with especially large
+headers. Default value 1000000.
 \code{format = "text"}: see \link{CsvConvertOptions}. Note that options can only be
 specified with the Arrow C++ library naming. Also, "block_size" from
 \link{CsvReadOptions} may be given.
diff --git a/r/man/ParquetFileReader.Rd b/r/man/ParquetFileReader.Rd
index 30d0725a4984f..59ec0d9a3bc55 100644
--- a/r/man/ParquetFileReader.Rd
+++ b/r/man/ParquetFileReader.Rd
@@ -17,6 +17,7 @@ takes the following arguments:
 (e.g. \code{RandomAccessFile}).
 \item \code{props} Optional \link{ParquetArrowReaderProperties}
 \item \code{mmap} Logical: whether to memory-map the file (default \code{TRUE})
+\item \code{reader_props} Optional \link{ParquetReaderProperties}
 \item \code{...} Additional arguments, currently ignored
 }
 }
diff --git a/r/man/ParquetReaderProperties.Rd b/r/man/ParquetReaderProperties.Rd
new file mode 100644
index 0000000000000..1779fffb14805
--- /dev/null
+++ b/r/man/ParquetReaderProperties.Rd
@@ -0,0 +1,27 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/parquet.R
+\docType{class}
+\name{ParquetReaderProperties}
+\alias{ParquetReaderProperties}
+\title{ParquetReaderProperties class}
+\description{
+This class holds settings to control how a Parquet file is read
+by \link{ParquetFileReader}.
+}
+\section{Factory}{
+
+
+The \code{ParquetReaderProperties$create()} factory method instantiates the object
+and takes no arguments.
+}
+
+\section{Methods}{
+
+\itemize{
+\item \verb{$thrift_string_size_limit()}
+\item \verb{$set_thrift_string_size_limit()}
+\item \verb{$thrift_container_size_limit()}
+\item \verb{$set_thrift_container_size_limit()}
+}
+}
+
diff --git a/r/src/arrowExports.cpp b/r/src/arrowExports.cpp
index 1d617b252e284..790207efce1d2 100644
--- a/r/src/arrowExports.cpp
+++ b/r/src/arrowExports.cpp
@@ -2024,17 +2024,19 @@ extern "C" SEXP _arrow_dataset___JsonFragmentScanOptions__Make(SEXP parse_option
 
 // dataset.cpp
 #if defined(ARROW_R_WITH_DATASET)
-std::shared_ptr<ds::ParquetFragmentScanOptions> dataset___ParquetFragmentScanOptions__Make(bool use_buffered_stream, int64_t buffer_size, bool pre_buffer);
-extern "C" SEXP _arrow_dataset___ParquetFragmentScanOptions__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP pre_buffer_sexp){
+std::shared_ptr<ds::ParquetFragmentScanOptions> dataset___ParquetFragmentScanOptions__Make(bool use_buffered_stream, int64_t buffer_size, bool pre_buffer, int64_t thrift_string_size_limit, int64_t thrift_container_size_limit);
+extern "C" SEXP _arrow_dataset___ParquetFragmentScanOptions__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP pre_buffer_sexp, SEXP thrift_string_size_limit_sexp, SEXP thrift_container_size_limit_sexp){
 BEGIN_CPP11
 	arrow::r::Input<bool>::type use_buffered_stream(use_buffered_stream_sexp);
 	arrow::r::Input<int64_t>::type buffer_size(buffer_size_sexp);
 	arrow::r::Input<bool>::type pre_buffer(pre_buffer_sexp);
-	return cpp11::as_sexp(dataset___ParquetFragmentScanOptions__Make(use_buffered_stream, buffer_size, pre_buffer));
+	arrow::r::Input<int64_t>::type thrift_string_size_limit(thrift_string_size_limit_sexp);
+	arrow::r::Input<int64_t>::type thrift_container_size_limit(thrift_container_size_limit_sexp);
+	return cpp11::as_sexp(dataset___ParquetFragmentScanOptions__Make(use_buffered_stream, buffer_size, pre_buffer, thrift_string_size_limit, thrift_container_size_limit));
 END_CPP11
 }
 #else
-extern "C" SEXP _arrow_dataset___ParquetFragmentScanOptions__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP pre_buffer_sexp){
+extern "C" SEXP _arrow_dataset___ParquetFragmentScanOptions__Make(SEXP use_buffered_stream_sexp, SEXP buffer_size_sexp, SEXP pre_buffer_sexp, SEXP thrift_string_size_limit_sexp, SEXP thrift_container_size_limit_sexp){
 	Rf_error("Cannot call dataset___ParquetFragmentScanOptions__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
 }
 #endif
@@ -4062,6 +4064,84 @@ extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__Make(SEXP use_th
 }
 #endif
 
+// parquet.cpp
+#if defined(ARROW_R_WITH_PARQUET)
+std::shared_ptr<parquet::ReaderProperties> parquet___arrow___ReaderProperties__Make();
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__Make(){
+BEGIN_CPP11
+	return cpp11::as_sexp(parquet___arrow___ReaderProperties__Make());
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__Make(){
+	Rf_error("Cannot call parquet___arrow___ReaderProperties__Make(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
+// parquet.cpp
+#if defined(ARROW_R_WITH_PARQUET)
+int parquet___arrow___ReaderProperties__get_thrift_string_size_limit(const std::shared_ptr<parquet::ReaderProperties>& properties);
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit(SEXP properties_sexp){
+BEGIN_CPP11
+	arrow::r::Input<const std::shared_ptr<parquet::ReaderProperties>&>::type properties(properties_sexp);
+	return cpp11::as_sexp(parquet___arrow___ReaderProperties__get_thrift_string_size_limit(properties));
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit(SEXP properties_sexp){
+	Rf_error("Cannot call parquet___arrow___ReaderProperties__get_thrift_string_size_limit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
+// parquet.cpp
+#if defined(ARROW_R_WITH_PARQUET)
+void parquet___arrow___ReaderProperties__set_thrift_string_size_limit(const std::shared_ptr<parquet::ReaderProperties>& properties, int size);
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit(SEXP properties_sexp, SEXP size_sexp){
+BEGIN_CPP11
+	arrow::r::Input<const std::shared_ptr<parquet::ReaderProperties>&>::type properties(properties_sexp);
+	arrow::r::Input<int>::type size(size_sexp);
+	parquet___arrow___ReaderProperties__set_thrift_string_size_limit(properties, size);
+	return R_NilValue;
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit(SEXP properties_sexp, SEXP size_sexp){
+	Rf_error("Cannot call parquet___arrow___ReaderProperties__set_thrift_string_size_limit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
+// parquet.cpp
+#if defined(ARROW_R_WITH_PARQUET)
+int parquet___arrow___ReaderProperties__get_thrift_container_size_limit(const std::shared_ptr<parquet::ReaderProperties>& properties);
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit(SEXP properties_sexp){
+BEGIN_CPP11
+	arrow::r::Input<const std::shared_ptr<parquet::ReaderProperties>&>::type properties(properties_sexp);
+	return cpp11::as_sexp(parquet___arrow___ReaderProperties__get_thrift_container_size_limit(properties));
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit(SEXP properties_sexp){
+	Rf_error("Cannot call parquet___arrow___ReaderProperties__get_thrift_container_size_limit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
+// parquet.cpp
+#if defined(ARROW_R_WITH_PARQUET)
+void parquet___arrow___ReaderProperties__set_thrift_container_size_limit(const std::shared_ptr<parquet::ReaderProperties>& properties, int size);
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit(SEXP properties_sexp, SEXP size_sexp){
+BEGIN_CPP11
+	arrow::r::Input<const std::shared_ptr<parquet::ReaderProperties>&>::type properties(properties_sexp);
+	arrow::r::Input<int>::type size(size_sexp);
+	parquet___arrow___ReaderProperties__set_thrift_container_size_limit(properties, size);
+	return R_NilValue;
+END_CPP11
+}
+#else
+extern "C" SEXP _arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit(SEXP properties_sexp, SEXP size_sexp){
+	Rf_error("Cannot call parquet___arrow___ReaderProperties__set_thrift_container_size_limit(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
+}
+#endif
+
 // parquet.cpp
 #if defined(ARROW_R_WITH_PARQUET)
 void parquet___arrow___ArrowReaderProperties__set_use_threads(const std::shared_ptr<parquet::ArrowReaderProperties>& properties, bool use_threads);
@@ -4163,16 +4243,17 @@ extern "C" SEXP _arrow_parquet___arrow___ArrowReaderProperties__get_coerce_int96
 
 // parquet.cpp
 #if defined(ARROW_R_WITH_PARQUET)
-std::shared_ptr<parquet::arrow::FileReader> parquet___arrow___FileReader__OpenFile(const std::shared_ptr<arrow::io::RandomAccessFile>& file, const std::shared_ptr<parquet::ArrowReaderProperties>& props);
-extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp){
+std::shared_ptr<parquet::arrow::FileReader> parquet___arrow___FileReader__OpenFile(const std::shared_ptr<arrow::io::RandomAccessFile>& file, const std::shared_ptr<parquet::ArrowReaderProperties>& props, const std::shared_ptr<parquet::ReaderProperties>& reader_props);
+extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp, SEXP reader_props_sexp){
 BEGIN_CPP11
 	arrow::r::Input<const std::shared_ptr<arrow::io::RandomAccessFile>&>::type file(file_sexp);
 	arrow::r::Input<const std::shared_ptr<parquet::ArrowReaderProperties>&>::type props(props_sexp);
-	return cpp11::as_sexp(parquet___arrow___FileReader__OpenFile(file, props));
+	arrow::r::Input<const std::shared_ptr<parquet::ReaderProperties>&>::type reader_props(reader_props_sexp);
+	return cpp11::as_sexp(parquet___arrow___FileReader__OpenFile(file, props, reader_props));
 END_CPP11
 }
 #else
-extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp){
+extern "C" SEXP _arrow_parquet___arrow___FileReader__OpenFile(SEXP file_sexp, SEXP props_sexp, SEXP reader_props_sexp){
 	Rf_error("Cannot call parquet___arrow___FileReader__OpenFile(). See https://arrow.apache.org/docs/r/articles/install.html for help installing Arrow C++ libraries. ");
 }
 #endif
@@ -5774,7 +5855,7 @@ static const R_CallMethodDef CallEntries[] = {
 		{ "_arrow_dataset___FragmentScanOptions__type_name", (DL_FUNC) &_arrow_dataset___FragmentScanOptions__type_name, 1}, 
 		{ "_arrow_dataset___CsvFragmentScanOptions__Make", (DL_FUNC) &_arrow_dataset___CsvFragmentScanOptions__Make, 2}, 
 		{ "_arrow_dataset___JsonFragmentScanOptions__Make", (DL_FUNC) &_arrow_dataset___JsonFragmentScanOptions__Make, 2}, 
-		{ "_arrow_dataset___ParquetFragmentScanOptions__Make", (DL_FUNC) &_arrow_dataset___ParquetFragmentScanOptions__Make, 3}, 
+		{ "_arrow_dataset___ParquetFragmentScanOptions__Make", (DL_FUNC) &_arrow_dataset___ParquetFragmentScanOptions__Make, 5}, 
 		{ "_arrow_dataset___DirectoryPartitioning", (DL_FUNC) &_arrow_dataset___DirectoryPartitioning, 2}, 
 		{ "_arrow_dataset___DirectoryPartitioning__MakeFactory", (DL_FUNC) &_arrow_dataset___DirectoryPartitioning__MakeFactory, 2}, 
 		{ "_arrow_dataset___HivePartitioning", (DL_FUNC) &_arrow_dataset___HivePartitioning, 3}, 
@@ -5985,13 +6066,18 @@ static const R_CallMethodDef CallEntries[] = {
 		{ "_arrow_ipc___MessageReader__ReadNextMessage", (DL_FUNC) &_arrow_ipc___MessageReader__ReadNextMessage, 1}, 
 		{ "_arrow_ipc___ReadMessage", (DL_FUNC) &_arrow_ipc___ReadMessage, 1}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__Make", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__Make, 1}, 
+		{ "_arrow_parquet___arrow___ReaderProperties__Make", (DL_FUNC) &_arrow_parquet___arrow___ReaderProperties__Make, 0}, 
+		{ "_arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit", (DL_FUNC) &_arrow_parquet___arrow___ReaderProperties__get_thrift_string_size_limit, 1}, 
+		{ "_arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit", (DL_FUNC) &_arrow_parquet___arrow___ReaderProperties__set_thrift_string_size_limit, 2}, 
+		{ "_arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit", (DL_FUNC) &_arrow_parquet___arrow___ReaderProperties__get_thrift_container_size_limit, 1}, 
+		{ "_arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit", (DL_FUNC) &_arrow_parquet___arrow___ReaderProperties__set_thrift_container_size_limit, 2}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__set_use_threads, 2}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__get_use_threads", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__get_use_threads, 2}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__get_read_dictionary, 2}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__set_read_dictionary, 3}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__set_coerce_int96_timestamp_unit", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__set_coerce_int96_timestamp_unit, 2}, 
 		{ "_arrow_parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit", (DL_FUNC) &_arrow_parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit, 1}, 
-		{ "_arrow_parquet___arrow___FileReader__OpenFile", (DL_FUNC) &_arrow_parquet___arrow___FileReader__OpenFile, 2}, 
+		{ "_arrow_parquet___arrow___FileReader__OpenFile", (DL_FUNC) &_arrow_parquet___arrow___FileReader__OpenFile, 3}, 
 		{ "_arrow_parquet___arrow___FileReader__ReadTable1", (DL_FUNC) &_arrow_parquet___arrow___FileReader__ReadTable1, 1}, 
 		{ "_arrow_parquet___arrow___FileReader__ReadTable2", (DL_FUNC) &_arrow_parquet___arrow___FileReader__ReadTable2, 2}, 
 		{ "_arrow_parquet___arrow___FileReader__ReadRowGroup1", (DL_FUNC) &_arrow_parquet___arrow___FileReader__ReadRowGroup1, 2}, 
diff --git a/r/src/arrow_types.h b/r/src/arrow_types.h
index 5f82275fe9c08..fadc39c75fc06 100644
--- a/r/src/arrow_types.h
+++ b/r/src/arrow_types.h
@@ -270,6 +270,7 @@ R6_CLASS_NAME(arrow::csv::WriteOptions, "CsvWriteOptions");
 
 #if defined(ARROW_R_WITH_PARQUET)
 R6_CLASS_NAME(parquet::ArrowReaderProperties, "ParquetArrowReaderProperties");
+R6_CLASS_NAME(parquet::ReaderProperties, "ParquetReaderProperties");
 R6_CLASS_NAME(parquet::ArrowWriterProperties, "ParquetArrowWriterProperties");
 R6_CLASS_NAME(parquet::WriterProperties, "ParquetWriterProperties");
 R6_CLASS_NAME(parquet::arrow::FileReader, "ParquetFileReader");
diff --git a/r/src/dataset.cpp b/r/src/dataset.cpp
index 3a4958e4cb955..83c430fb634d3 100644
--- a/r/src/dataset.cpp
+++ b/r/src/dataset.cpp
@@ -342,7 +342,9 @@ std::shared_ptr<ds::JsonFragmentScanOptions> dataset___JsonFragmentScanOptions__
 // [[dataset::export]]
 std::shared_ptr<ds::ParquetFragmentScanOptions>
 dataset___ParquetFragmentScanOptions__Make(bool use_buffered_stream, int64_t buffer_size,
-                                           bool pre_buffer) {
+                                           bool pre_buffer,
+                                           int64_t thrift_string_size_limit,
+                                           int64_t thrift_container_size_limit) {
   auto options = std::make_shared<ds::ParquetFragmentScanOptions>();
   if (use_buffered_stream) {
     options->reader_properties->enable_buffered_stream();
@@ -355,6 +357,9 @@ dataset___ParquetFragmentScanOptions__Make(bool use_buffered_stream, int64_t buf
     options->arrow_reader_properties->set_cache_options(
         arrow::io::CacheOptions::LazyDefaults());
   }
+  options->reader_properties->set_thrift_string_size_limit(thrift_string_size_limit);
+  options->reader_properties->set_thrift_container_size_limit(
+      thrift_container_size_limit);
   return options;
 }
 
diff --git a/r/src/parquet.cpp b/r/src/parquet.cpp
index 3a263f6527db8..f9f7b0447c17b 100644
--- a/r/src/parquet.cpp
+++ b/r/src/parquet.cpp
@@ -44,6 +44,35 @@ parquet___arrow___ArrowReaderProperties__Make(bool use_threads) {
   return std::make_shared<parquet::ArrowReaderProperties>(use_threads);
 }
 
+// [[parquet::export]]
+std::shared_ptr<parquet::ReaderProperties> parquet___arrow___ReaderProperties__Make() {
+  return std::make_shared<parquet::ReaderProperties>();
+}
+
+// [[parquet::export]]
+int parquet___arrow___ReaderProperties__get_thrift_string_size_limit(
+    const std::shared_ptr<parquet::ReaderProperties>& properties) {
+  return properties->thrift_string_size_limit();
+}
+
+// [[parquet::export]]
+void parquet___arrow___ReaderProperties__set_thrift_string_size_limit(
+    const std::shared_ptr<parquet::ReaderProperties>& properties, int size) {
+  properties->set_thrift_string_size_limit(size);
+}
+
+// [[parquet::export]]
+int parquet___arrow___ReaderProperties__get_thrift_container_size_limit(
+    const std::shared_ptr<parquet::ReaderProperties>& properties) {
+  return properties->thrift_container_size_limit();
+}
+
+// [[parquet::export]]
+void parquet___arrow___ReaderProperties__set_thrift_container_size_limit(
+    const std::shared_ptr<parquet::ReaderProperties>& properties, int size) {
+  properties->set_thrift_container_size_limit(size);
+}
+
 // [[parquet::export]]
 void parquet___arrow___ArrowReaderProperties__set_use_threads(
     const std::shared_ptr<parquet::ArrowReaderProperties>& properties, bool use_threads) {
@@ -86,10 +115,11 @@ parquet___arrow___ArrowReaderProperties__get_coerce_int96_timestamp_unit(
 // [[parquet::export]]
 std::shared_ptr<parquet::arrow::FileReader> parquet___arrow___FileReader__OpenFile(
     const std::shared_ptr<arrow::io::RandomAccessFile>& file,
-    const std::shared_ptr<parquet::ArrowReaderProperties>& props) {
+    const std::shared_ptr<parquet::ArrowReaderProperties>& props,
+    const std::shared_ptr<parquet::ReaderProperties>& reader_props) {
   std::unique_ptr<parquet::arrow::FileReader> reader;
   parquet::arrow::FileReaderBuilder builder;
-  PARQUET_THROW_NOT_OK(builder.Open(file));
+  PARQUET_THROW_NOT_OK(builder.Open(file, *reader_props));
   PARQUET_THROW_NOT_OK(
       builder.memory_pool(gc_memory_pool())->properties(*props)->Build(&reader));
   return std::move(reader);
diff --git a/r/tests/testthat/test-dataset.R b/r/tests/testthat/test-dataset.R
index b9972901a706e..cbeb081d0bae6 100644
--- a/r/tests/testthat/test-dataset.R
+++ b/r/tests/testthat/test-dataset.R
@@ -1516,3 +1516,17 @@ test_that("can add in augmented fields", {
     list.files(hive_dir, full.names = TRUE, recursive = TRUE)
   )
 })
+
+test_that("can set thrift size string and container limits for datasets", {
+  expect_r6_class(open_dataset(dataset_dir, thrift_string_size_limit = 1000000), "FileSystemDataset")
+  expect_error(
+    open_dataset(dataset_dir, thrift_string_size_limit = 1),
+    "TProtocolException: Exceeded size limit"
+  )
+
+  expect_r6_class(open_dataset(dataset_dir, thrift_container_size_limit = 1000000), "FileSystemDataset")
+  expect_error(
+    open_dataset(dataset_dir, thrift_container_size_limit = 1),
+    "TProtocolException: Exceeded size limit"
+  )
+})
diff --git a/r/tests/testthat/test-parquet.R b/r/tests/testthat/test-parquet.R
index 7c5d9ebef6593..dbc4a0473561f 100644
--- a/r/tests/testthat/test-parquet.R
+++ b/r/tests/testthat/test-parquet.R
@@ -484,3 +484,43 @@ test_that("Can read Parquet files from a URL", {
   expect_true(tibble::is_tibble(pu))
   expect_identical(dim(pu), c(10L, 11L))
 })
+
+test_that("thrift string and container size can be specified when reading Parquet files", {
+
+  tf <- tempfile()
+  on.exit(unlink(tf))
+  table <- arrow_table(example_data)
+  write_parquet(table, tf)
+  file <- make_readable_file(tf)
+  on.exit(file$close())
+
+  # thrift string size
+  reader_props <- ParquetReaderProperties$create()
+  reader_props$set_thrift_string_size_limit(1)
+  expect_identical(reader_props$thrift_string_size_limit(), 1L)
+
+  # We get an error if we set the Thrift string size limit too small
+  expect_error(ParquetFileReader$create(file, reader_props = reader_props), "TProtocolException: Exceeded size limit")
+
+  # Increase the size and we can read successfully
+  reader_props$set_thrift_string_size_limit(10000)
+  reader <- ParquetFileReader$create(file, reader_props = reader_props)
+  data <- reader$ReadTable()
+  expect_identical(collect.ArrowTabular(data), example_data)
+
+  # thrift container size
+  reader_props_container <- ParquetReaderProperties$create()
+  reader_props_container$set_thrift_container_size_limit(1)
+  expect_identical(reader_props_container$thrift_container_size_limit(), 1L)
+
+  expect_error(
+    ParquetFileReader$create(file, reader_props = reader_props_container),
+    "TProtocolException: Exceeded size limit"
+  )
+
+  reader_props_container$set_thrift_container_size_limit(100)
+
+  reader_container <- ParquetFileReader$create(file, reader_props = reader_props_container)
+  data <- reader_container$ReadTable()
+  expect_identical(collect.ArrowTabular(data), example_data)
+})

From b05190e6f1c8bc93df74c26e67c2a7191767e774 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 14 Aug 2023 11:22:49 -0400
Subject: [PATCH 151/749] GH-37151: [MATLAB] Use `makeValidVariableNames` and
 `makeValidDimensionNames` in implementation of `table` method for
 `RecordBatch`  (#37152)

### Rationale for this change

#37098 added utilities for making valid MATLAB `table` `VariableNames` (`makeValidVariableNames`) and `DimensionNames` (`makeValidDimensionNames`) from an arbitrary list of strings.

This pull request uses these utilities to ensure that `RecordBatch` field names are converted to valid MATLAB `table` `VariableNames`/`DimensionNames` when calling the `table`/`toMATLAB` methods.

### What changes are included in this PR?

1. Used `makeValidVariableNames` and `makeValidDimensionNames` utilities in the implementation of the `table` method for the `RecordBatch` class to ensure that column names are converted to valid MATLAB `table` `VariableNames`/`DimensionNames`.

### Are these changes tested?

Yes.

1. The existing tests in `arrow/matlab/test/arrow/tabular/tMakeValidVariableNames.m` and `arrow/matlab/test/arrow/tabular/tMakeValidDimensionNames.m` already test that an arbitrary list of column names are converted into valid MATLAB `table` `VariableNames`/`DimensionNames`.
2. There is currently no straightforward way to create a `RecordBatch` with field names that are invalid MATLAB `VariableNames`/`DimensionNames` using the MATLAB interface. When we have a way to do this in the MATLAB interface, we can add more "integration" tests which verify that a `RecordBatch` with field names that are invalid MATLAB `table` `VariableNames`/`DimensionNames` are converted into valid `VariableNames`/`DimensionNames` when the `table`/`toMATLAB` methods are called.

### Are there any user-facing changes?

Yes.

A `RecordBatch` with field names that are invalid MATLAB `table` `VariableNames`/`DimensionNames` will now be converted into a MATLAB `table` with valid `VariableNames`/`DimensionNames` when calling the `table`/`toMATLAB` methods.

### Future Directions

1. #37046 (this change to the `table` method of the `RecordBatch` class should help preserve the behavior of storing original `RecordBatch` field names in the `VariableDescriptions` property of the output MATLAB `table` returned by `featherread`).
* Closes: #37151

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+tabular/RecordBatch.m | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index be5eee7d89c35..0fd9fb81d413e 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -59,6 +59,8 @@
         end
 
         function T = table(obj)
+            import arrow.tabular.internal.*
+
             numColumns = obj.NumColumns;
             matlabArrays = cell(1, numColumns);
             
@@ -67,10 +69,12 @@
                 matlabArrays{ii} = toMATLAB(arrowArray);
             end
 
-            variableNames = matlab.lang.makeUniqueStrings(obj.ColumnNames);
-            % NOTE: Does not currently handle edge cases like ColumnNames
-            %       matching the table DimensionNames.
-            T = table(matlabArrays{:}, VariableNames=variableNames);
+            validVariableNames = makeValidVariableNames(obj.ColumnNames);
+            validDimensionNames = makeValidDimensionNames(validVariableNames);
+
+            T = table(matlabArrays{:}, ...
+                VariableNames=validVariableNames, ...
+                DimensionNames=validDimensionNames);
         end
 
         function T = toMATLAB(obj)

From baf3eb9d62bea7b76c2d18f40a79a1fbe13a860e Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 14 Aug 2023 23:44:44 +0800
Subject: [PATCH 152/749] GH-37110: [C++] Expression: SmallestTypeFor lost tz
 for Scalar (#37135)

### Rationale for this change

This patch ( https://github.com/apache/arrow/pull/15180 ) adds a `SmallestTypeFor` to handling expression type. However, it lost timezone when handling.

### What changes are included in this PR?

Add `timezone` in `SmallestTypeFor`

### Are these changes tested?

Currently not

### Are there any user-facing changes?

Yeah it's a bugfix

* Closes: #37110

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/compute/expression.cc      | 12 ++++++------
 cpp/src/arrow/compute/expression_test.cc | 13 +++++++++++++
 2 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/expression.cc b/cpp/src/arrow/compute/expression.cc
index 247f4e540872f..b47e0a35525c5 100644
--- a/cpp/src/arrow/compute/expression.cc
+++ b/cpp/src/arrow/compute/expression.cc
@@ -480,26 +480,26 @@ TypeHolder SmallestTypeFor(const arrow::Datum& value) {
           return value.type();
         case TimeUnit::MILLI:
           if (ts % 1000 == 0) {
-            return timestamp(TimeUnit::SECOND);
+            return timestamp(TimeUnit::SECOND, ts_type->timezone());
           }
           return value.type();
         case TimeUnit::MICRO:
           if (ts % 1000000 == 0) {
-            return timestamp(TimeUnit::SECOND);
+            return timestamp(TimeUnit::SECOND, ts_type->timezone());
           }
           if (ts % 1000 == 0) {
-            return timestamp(TimeUnit::MILLI);
+            return timestamp(TimeUnit::MILLI, ts_type->timezone());
           }
           return value.type();
         case TimeUnit::NANO:
           if (ts % 1000000000 == 0) {
-            return timestamp(TimeUnit::SECOND);
+            return timestamp(TimeUnit::SECOND, ts_type->timezone());
           }
           if (ts % 1000000 == 0) {
-            return timestamp(TimeUnit::MILLI);
+            return timestamp(TimeUnit::MILLI, ts_type->timezone());
           }
           if (ts % 1000 == 0) {
-            return timestamp(TimeUnit::MICRO);
+            return timestamp(TimeUnit::MICRO, ts_type->timezone());
           }
           return value.type();
         default:
diff --git a/cpp/src/arrow/compute/expression_test.cc b/cpp/src/arrow/compute/expression_test.cc
index f90e01a2f81bc..b852f6f6b0cdb 100644
--- a/cpp/src/arrow/compute/expression_test.cc
+++ b/cpp/src/arrow/compute/expression_test.cc
@@ -63,6 +63,7 @@ const std::shared_ptr<Schema> kBoringSchema = schema({
     field("ts_ns", timestamp(TimeUnit::NANO)),
     field("ts_s", timestamp(TimeUnit::SECOND)),
     field("binary", binary()),
+    field("ts_s_utc", timestamp(TimeUnit::SECOND, "UTC")),
 });
 
 #define EXPECT_OK ARROW_EXPECT_OK
@@ -630,6 +631,18 @@ TEST(Expression, BindWithImplicitCasts) {
                       literal(std::make_shared<TimestampScalar>(0, TimeUnit::NANO))),
                   cmp(field_ref("ts_s"),
                       literal(std::make_shared<TimestampScalar>(0, TimeUnit::SECOND))));
+    // GH-37110
+    ExpectBindsTo(
+        cmp(field_ref("ts_s_utc"),
+            literal(std::make_shared<TimestampScalar>(0, TimeUnit::NANO, "UTC"))),
+        cmp(field_ref("ts_s_utc"),
+            literal(std::make_shared<TimestampScalar>(0, TimeUnit::SECOND, "UTC"))));
+    ExpectBindsTo(
+        cmp(field_ref("ts_s_utc"),
+            literal(std::make_shared<TimestampScalar>(123000, TimeUnit::NANO, "UTC"))),
+        cmp(field_ref("ts_s_utc"),
+            literal(std::make_shared<TimestampScalar>(123, TimeUnit::MICRO, "UTC"))));
+
     ExpectBindsTo(
         cmp(field_ref("binary"), literal(std::make_shared<LargeBinaryScalar>("foo"))),
         cmp(field_ref("binary"), literal(std::make_shared<BinaryScalar>("foo"))));

From 2e5694c5faa80d20556ffcb67ae0b20b4886dda1 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 14 Aug 2023 11:56:29 -0400
Subject: [PATCH 153/749] GH-37124: [MATLAB] Add utility functions for
 validating numeric and string index values (#37150)

### Rationale for this change

There are multiple functions/methods within the MATLAB interface which accept either numeric or string index values - in particular,  the `field` method of `arrow.tabular.Schema` and the `column` method of `arrow.tabular.RecordBatch`. Rather than writing the same validation code in each method, it would be better if we refactored that code into shared utility functions.

### What changes are included in this PR?

Added the following three new validation functions:

1. `arrow.internal.validate.index.numeric`
2. `arrow.internal.validate.index.string`
3. `arrow.internal.validate.index.numericOrString`

Example Usage:

```matlab
>> index = arrow.internal.validate.index.numeric(0, "int32")
Error using arrow.internal.validate.index.numeric
Numeric indices must be positive integers.

>> index = arrow.internal.validate.index.numeric(5, "int32")

index =

  int32

   5

>>  index = arrow.internal.validate.index.string(string(missing))
Error using arrow.internal.validate.index.string
String indices must be nonmissing

>>  index = arrow.internal.validate.index.string('A')

index =

    "A"

>> index = arrow.internal.validate.index.numericOrString(datetime, "int32")
Error using arrow.internal.validate.index.numericOrString
Indices must be positive integers or nonmissing strings.

>> index = arrow.internal.validate.index.numericOrString(5, "int32")

index =

  int32

   5

>> index = arrow.internal.validate.index.numericOrString('A', "int32")

index =

    "A"
```

### Are these changes tested?

Yes. Added the following three new test classes:

1. `test/arrow/internal/validate/index/tNumeric.m`
2. `test/arrow/internal/validate/index/tString.m`
3. `test/arrow/internal/validate/index/tNumericOrString.m`

### Are there any user-facing changes?

No.

### Future Directions

1. Once this PR is merged, we will change the the `field` method of `arrow.tabular.Schema` and the `column` method of `arrow.tabular.RecordBatch` to use these utilities.
* Closes: #37124

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/+validate/+index/numeric.m      |  57 ++++++
 .../+validate/+index/numericOrString.m        |  31 ++++
 .../+internal/+validate/+index/string.m       |  38 ++++
 .../arrow/internal/validate/index/tNumeric.m  | 165 ++++++++++++++++++
 .../validate/index/tNumericOrString.m         |  64 +++++++
 .../arrow/internal/validate/index/tString.m   | 120 +++++++++++++
 6 files changed, 475 insertions(+)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
 create mode 100644 matlab/test/arrow/internal/validate/index/tNumeric.m
 create mode 100644 matlab/test/arrow/internal/validate/index/tNumericOrString.m
 create mode 100644 matlab/test/arrow/internal/validate/index/tString.m

diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
new file mode 100644
index 0000000000000..99bd109b53016
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
@@ -0,0 +1,57 @@
+%NUMERIC Validates numeric index values. Also validates that the index
+%values do not exceed intmax(intType). 
+% 
+%intType must be  one of the following values: "int8", "int16", "int32", 
+%"int64", "uint8", "uint16", "uint32", or "uint64".
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function index = numeric(index, intType)
+
+    if ~isnumeric(index)
+        errid = "arrow:badsubscript:NonNumeric";
+        msg = "Expected numeric index values.";
+        error(errid, msg);
+    end
+
+     % Convert to full storage if sparse
+    if issparse(index)
+        index = full(index);
+    end
+
+    % Ensure the output is a column vector
+    index = reshape(index, [], 1);
+
+    if any(index < 1)
+        errid = "arrow:badsubscript:NonPositive";
+        msg = "Numeric indices must be positive integers.";
+        error(errid, msg);
+    elseif any(floor(index) ~= index) || any(isinf(index))
+        errid = "arrow:badsubscript:NonInteger";
+        msg = "Numeric indices must be finite positive integers.";
+        error(errid, msg);
+    elseif ~isreal(index)
+        errid = "arrow:badsubscript:NonReal";
+        msg = "Numeric indices must be positive real integers.";
+        error(errid, msg);
+    elseif any(index > intmax(intType))
+        errid = "arrow:badsubscript:ExceedsIntMax";
+        msg = "Index must be between 1 and intmax(""" + intType + """).";
+        error(errid, msg);
+    end
+
+    index = cast(index, intType);
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
new file mode 100644
index 0000000000000..ec4f00503f5d6
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
@@ -0,0 +1,31 @@
+%NUMERICORSTRING Validates index is a valid numeric or string index.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function idx = numericOrString(idx, numericIndexType)
+    import arrow.internal.validate.*
+
+    idx = convertCharsToStrings(idx);
+    if isnumeric(idx)
+        idx = index.numeric(idx, numericIndexType);
+    elseif isstring(idx)
+        idx = index.string(idx);
+    else
+        errid = "arrow:badsubscript:UnsupportedIndexType";
+        msg = "Indices must be positive integers or nonmissing strings.";
+        error(errid, msg);
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
new file mode 100644
index 0000000000000..5f5fe6527e9b6
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
@@ -0,0 +1,38 @@
+%STRING Validates string index values.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function index = string(index)
+
+    index = convertCharsToStrings(index);
+
+    index = reshape(index, [], 1);
+
+    if ~isstring(index)
+        errid = "arrow:badsubscript:NonString";
+        msg = "Expected string index values.";
+        error(errid, msg);
+    end
+
+    if any(ismissing(index))
+        errid = "arrow:badsubscript:MissingString";
+        msg = "String indices must be nonmissing";
+        error(errid, msg);
+    elseif any(strlength(index) == 0)
+        errid = "arrow:badsubscript:ZeroLengthText";
+        msg = "String indices must contain at least one character.";
+        error(errid, msg);
+    end
+end
diff --git a/matlab/test/arrow/internal/validate/index/tNumeric.m b/matlab/test/arrow/internal/validate/index/tNumeric.m
new file mode 100644
index 0000000000000..a2c07bf79ec3a
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/index/tNumeric.m
@@ -0,0 +1,165 @@
+%TNUMERIC Unit tests for arrow.internal.validate.index.numeric
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tNumeric < matlab.unittest.TestCase
+
+    methods (Test)
+
+        function NonPositiveError(testCase)
+            % Verify numeric() throws an error whose idenitifier is 
+            % "arrow:badsubscript:NonPositive" if the index array provided
+            % has non-positive values.
+
+            import arrow.internal.validate.index.numeric
+
+            errid = "arrow:badsubscript:NonPositive";
+
+            fcn = @() numeric(0, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric(-1, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric([1 -1 2], "int32");
+            testCase.verifyError(fcn, errid);
+        end
+
+        function NonIntegerError(testCase)
+            % Verify numeric() throws an error whose idenitifier is 
+            % "arrow:badsubscript:NonInteger" if the index array provided
+            % has non-integer values.
+
+            import arrow.internal.validate.index.numeric
+
+            errid = "arrow:badsubscript:NonInteger";
+
+            fcn = @() numeric(1.1, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric(NaN, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric(inf, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric([1 1.2 2], "int32");
+            testCase.verifyError(fcn, errid);
+        end
+
+        function NonRealError(testCase)
+            % Verify numeric() throws an error whose idenitifier is 
+            % "arrow:badsubscript:NonReal" if the index array is
+            % complex.
+
+            import arrow.internal.validate.index.numeric
+
+            errid = "arrow:badsubscript:NonReal";
+
+            fcn = @() numeric(1 + 1i, "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric([1 2 + 2i], "int32");
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ExceedsIntMaxError(testCase)
+            % Verify numeric() throws an error whose idenitifier is 
+            % "arrow:badsubscript:ExceedsIntMax" if the index array 
+            % provided has values that exceed the intmax(intType).
+
+            import arrow.internal.validate.index.numeric
+
+            errid = "arrow:badsubscript:ExceedsIntMax";
+
+            fcn = @() numeric(flintmax("double"), "int32");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() numeric([1 flintmax("double")], "int32");
+            testCase.verifyError(fcn, errid);
+        end
+
+        function CastToIntType(testCase)
+            % Verify numeric() returns an index array of the provided
+            % intType if the index array is valid.
+            
+            import arrow.internal.validate.index.numeric
+
+            original = [1 2 3 4];
+            expected = int32(original)';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+
+            original = uint32([1 2 3 4]);
+            expected = int64(original)';
+            actual = numeric(original, "int64");
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ConvertSparseToFullStorage(testCase)
+            % Verify numeric() converts sparse index arrays into full
+            % storage arrays.
+            
+            import arrow.internal.validate.index.numeric
+
+            original = sparse([1 2 3 4]);
+            expected = int32(full(original))';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ErrorIfNonNumeric(testCase)
+            % Verify numeric() throws an error whose idenitifer is 
+            % "arrow:badsubscript:NonNumeric" if provided a non-numeric
+            % array as the index.
+
+            import arrow.internal.validate.index.numeric
+
+            fcn = @() numeric(false);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonNumeric");
+        end
+
+        function OutputShape(testCase)
+            % Verify numeric() always returns a column vector.
+
+            import arrow.internal.validate.index.numeric
+
+            % Provide a 2x2 matrix
+            original = int32([1 2; 3 4]);
+            expected = int32([1 3 2 4])';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 1x3 vector
+            original = int32([1 2 3]);
+            expected = int32([1 2 3])';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 3x1 vector
+            original = int32([1 2 3])';
+            expected = int32([1 2 3])';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 2x2x2 N-dimensional array
+            original = int8(reshape(1:8, 2, 2, 2));
+            expected = int32(1:8)';
+            actual = numeric(original, "int32");
+            testCase.verifyEqual(actual, expected);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/index/tNumericOrString.m b/matlab/test/arrow/internal/validate/index/tNumericOrString.m
new file mode 100644
index 0000000000000..1657a1b24a4a5
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/index/tNumericOrString.m
@@ -0,0 +1,64 @@
+%tNUMERICORSTRING Unit tests for
+% arrow.internal.validate.index.numericOrString.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tNumericOrString < matlab.unittest.TestCase
+
+    methods (Test)
+
+        function ValidNumericIndex(testCase)
+            % Verify numericOrString() returns the expected index array
+            % when given a valid numeric index array.
+
+            import arrow.internal.validate.index.numericOrString
+
+            original = 1;
+            expected = int32(1);
+            actual = numericOrString(original, "int32");
+            testCase.verifyEqual(actual, expected);
+
+            original = [1 2 5];
+            expected = int32([1 2 5])';
+            actual = numericOrString(original, "int32");
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function InvalidNumericIndexError(testCase)
+            % Verify numericOrString() errors if given an invalid numeric
+            % index array.
+
+            import arrow.internal.validate.index.numericOrString
+
+            fcn = @() numericOrString(-1.1, "int8");
+            testCase.verifyError(fcn, "arrow:badsubscript:NonPositive");
+
+            fcn = @() numericOrString([2 -1.1], "int8");
+            testCase.verifyError(fcn, "arrow:badsubscript:NonPositive");
+        end
+
+        function ValidStringArray(testCase)
+            % Verify numericOrString() returns the expected index array if
+            % given a valid string index array.
+
+            import arrow.internal.validate.index.numericOrString
+
+            testCase.verifyEqual(numericOrString("A", "int32"), "A");
+
+            testCase.verifyEqual(numericOrString(["B" "A"], "int32"), ["B", "A"]');
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/index/tString.m b/matlab/test/arrow/internal/validate/index/tString.m
new file mode 100644
index 0000000000000..d64e4fdb8dc2e
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/index/tString.m
@@ -0,0 +1,120 @@
+%TSTRING Unit tests for arrow.internal.validate.index.string
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tString < matlab.unittest.TestCase
+
+    methods(Test)
+        
+        function MissingStringError(testCase)
+            % Verify string() throws an error whose idenitifier is 
+            % "arrow:badsubscript:MissingString" if the index array 
+            % provided has mising string values.
+
+            import arrow.internal.validate.*
+
+            errid = "arrow:badsubscript:MissingString";
+
+            fcn = @() index.string(string(missing));
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() index.string(["A" missing "B"]);
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ZeroLengthTextError(testCase)
+            % Verify string() throws an error whose idenitifier is 
+            % "arrow:badsubscript:ZeroLengthText" if the index array 
+            % provided has zero length text values.
+
+            import arrow.internal.validate.*
+
+            errid = "arrow:badsubscript:ZeroLengthText";
+
+            fcn = @() index.string("");
+            testCase.verifyError(fcn, errid);
+
+            fcn = @() index.string(["A" "" "B"]);
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ValidStringIndices(testCase)
+            % Verify string() returns the expected string array if given
+            % a valid string, char, or cellstr as the index array.
+
+            import arrow.internal.validate.*
+
+            idx = index.string("A");
+            testCase.verifyEqual(idx, "A");
+
+            idx = index.string(["A", "B"]);
+            testCase.verifyEqual(idx, ["A"; "B"]);
+
+            idx = index.string('ABC');
+            testCase.verifyEqual(idx, "ABC");
+
+            idx = index.string(['ABC'; 'DEF']);
+            testCase.verifyEqual(idx, "ADBECF");
+
+            idx = index.string({'Var1'});
+            testCase.verifyEqual(idx, "Var1");
+
+            idx = index.string({'Var1', 'A'});
+            testCase.verifyEqual(idx, ["Var1"; "A"]);
+        end
+
+        function ErrorIfNonString(testCase)
+            % Verify string() throws an error whose idenitifer is 
+            % "arrow:badsubscript:NonString" if neither a string array,
+            % char array, nor cellstr array was provided as the index. 
+
+            import arrow.internal.validate.*
+
+            fcn = @() index.string(1);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonString");
+        end
+
+        function OutputShape(testCase)
+            % Verify string() always returns a column vector.
+
+            import arrow.internal.validate.*
+
+            % Provide a 2x2 matrix
+            original = ["A" "B"; "C" "D"];
+            expected = ["A" "C" "B" "D"]';
+            actual = index.string(original);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 1x3 vector
+            original = ["A" "B" "C"];
+            expected = ["A" "B" "C"]';
+            actual = index.string(original);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 3x1 vector
+            original = ["A" "B" "C"]';
+            expected = ["A" "B" "C"]';
+            actual = index.string(original);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a 2x2x2 N-dimensional array
+            original = reshape(string(char(65:72)'), 2, 2, 2);
+            expected = string(char(65:72)');
+            actual = index.string(original);
+            testCase.verifyEqual(actual, expected);
+        end
+    end
+end
\ No newline at end of file

From c9d4685c440d1fc0f2369654bc5076ea29dbb55c Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Mon, 14 Aug 2023 23:59:01 +0800
Subject: [PATCH 154/749] GH-37028: [C++] Add support for duration types to
 if_else functions (#37064)

### Rationale for this change

Support for duration types is missing in if else functions, including if_else, coalesce, choose and case_when.

### What changes are included in this PR?
Add support for duration types to these functions.

### Are these changes tested?
Yes.

### Are there any user-facing changes?

No.

* Closes: #37028

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/compute/kernels/codegen_internal.cc | 10 +++++++++-
 cpp/src/arrow/compute/kernels/scalar_if_else.cc   |  4 ++++
 .../arrow/compute/kernels/scalar_if_else_test.cc  | 15 +++++++++++++--
 cpp/src/arrow/compute/kernels/test_util.h         |  5 ++++-
 4 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.cc b/cpp/src/arrow/compute/kernels/codegen_internal.cc
index e0156caecfa5d..8e2669bd3dfb9 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.cc
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.cc
@@ -250,7 +250,7 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
   const std::string* timezone = nullptr;
   bool saw_date32 = false;
   bool saw_date64 = false;
-
+  bool saw_duration = false;
   const TypeHolder* end = begin + count;
   for (auto it = begin; it != end; it++) {
     auto id = it->type->id();
@@ -271,6 +271,12 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
         finest_unit = std::max(finest_unit, ty.unit());
         continue;
       }
+      case Type::DURATION: {
+        const auto& ty = checked_cast<const DurationType&>(*it->type);
+        finest_unit = std::max(finest_unit, ty.unit());
+        saw_duration = true;
+        continue;
+      }
       default:
         return TypeHolder(nullptr);
     }
@@ -283,6 +289,8 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
     return date64();
   } else if (saw_date32) {
     return date32();
+  } else if (saw_duration) {
+    return duration(finest_unit);
   }
   return TypeHolder(nullptr);
 }
diff --git a/cpp/src/arrow/compute/kernels/scalar_if_else.cc b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
index 0dd176b5d4099..6b4b2339e4afe 100644
--- a/cpp/src/arrow/compute/kernels/scalar_if_else.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_if_else.cc
@@ -2798,6 +2798,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
     AddPrimitiveIfElseKernels(func, NumericTypes());
     AddPrimitiveIfElseKernels(func, TemporalTypes());
     AddPrimitiveIfElseKernels(func, IntervalTypes());
+    AddPrimitiveIfElseKernels(func, DurationTypes());
     AddPrimitiveIfElseKernels(func, {boolean()});
     AddNullIfElseKernel(func);
     AddBinaryIfElseKernels(func, BaseBinaryTypes());
@@ -2813,6 +2814,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
     AddPrimitiveCaseWhenKernels(func, NumericTypes());
     AddPrimitiveCaseWhenKernels(func, TemporalTypes());
     AddPrimitiveCaseWhenKernels(func, IntervalTypes());
+    AddPrimitiveCaseWhenKernels(func, DurationTypes());
     AddPrimitiveCaseWhenKernels(func, {boolean(), null()});
     AddCaseWhenKernel(func, Type::FIXED_SIZE_BINARY,
                       CaseWhenFunctor<FixedSizeBinaryType>::Exec);
@@ -2836,6 +2838,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
     AddPrimitiveCoalesceKernels(func, NumericTypes());
     AddPrimitiveCoalesceKernels(func, TemporalTypes());
     AddPrimitiveCoalesceKernels(func, IntervalTypes());
+    AddPrimitiveCoalesceKernels(func, DurationTypes());
     AddPrimitiveCoalesceKernels(func, {boolean(), null()});
     AddCoalesceKernel(func, Type::FIXED_SIZE_BINARY,
                       CoalesceFunctor<FixedSizeBinaryType>::Exec);
@@ -2861,6 +2864,7 @@ void RegisterScalarIfElse(FunctionRegistry* registry) {
     AddPrimitiveChooseKernels(func, NumericTypes());
     AddPrimitiveChooseKernels(func, TemporalTypes());
     AddPrimitiveChooseKernels(func, IntervalTypes());
+    AddPrimitiveChooseKernels(func, DurationTypes());
     AddPrimitiveChooseKernels(func, {boolean(), null()});
     AddChooseKernel(func, Type::FIXED_SIZE_BINARY,
                     ChooseFunctor<FixedSizeBinaryType>::Exec);
diff --git a/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc b/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
index ded73f0371435..a9c5a1fc3c96f 100644
--- a/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_if_else_test.cc
@@ -73,7 +73,7 @@ class TestIfElsePrimitive : public ::testing::Test {};
 #ifdef ARROW_VALGRIND
 using IfElseNumericBasedTypes =
     ::testing::Types<UInt32Type, FloatType, Date32Type, Time32Type, TimestampType,
-                     MonthIntervalType>;
+                     MonthIntervalType, DurationType>;
 using BaseBinaryArrowTypes = ::testing::Types<BinaryType>;
 using ListArrowTypes = ::testing::Types<ListType>;
 using IntegralArrowTypes = ::testing::Types<Int32Type>;
@@ -81,7 +81,8 @@ using IntegralArrowTypes = ::testing::Types<Int32Type>;
 using IfElseNumericBasedTypes =
     ::testing::Types<UInt8Type, UInt16Type, UInt32Type, UInt64Type, Int8Type, Int16Type,
                      Int32Type, Int64Type, FloatType, DoubleType, Date32Type, Date64Type,
-                     Time32Type, Time64Type, TimestampType, MonthIntervalType>;
+                     Time32Type, Time64Type, TimestampType, MonthIntervalType,
+                     DurationType>;
 #endif
 
 TYPED_TEST_SUITE(TestIfElsePrimitive, IfElseNumericBasedTypes);
@@ -505,6 +506,9 @@ TEST_F(TestIfElseKernel, IfElseDispatchBest) {
                     {boolean(), timestamp(TimeUnit::MILLI), timestamp(TimeUnit::MILLI)});
   CheckDispatchBest(name, {boolean(), date32(), timestamp(TimeUnit::MILLI)},
                     {boolean(), timestamp(TimeUnit::MILLI), timestamp(TimeUnit::MILLI)});
+  CheckDispatchBest(name,
+                    {boolean(), duration(TimeUnit::SECOND), duration(TimeUnit::MILLI)},
+                    {boolean(), duration(TimeUnit::MILLI), duration(TimeUnit::MILLI)});
   CheckDispatchBest(name, {boolean(), date32(), date64()},
                     {boolean(), date64(), date64()});
   CheckDispatchBest(name, {boolean(), date32(), date32()},
@@ -2500,6 +2504,11 @@ TEST(TestCaseWhen, DispatchBest) {
       {struct_({field("", boolean())}), timestamp(TimeUnit::SECOND), date32()},
       {struct_({field("", boolean())}), timestamp(TimeUnit::SECOND),
        timestamp(TimeUnit::SECOND)});
+  CheckDispatchBest("case_when",
+                    {struct_({field("", boolean())}), duration(TimeUnit::SECOND),
+                     duration(TimeUnit::MILLI)},
+                    {struct_({field("", boolean())}), duration(TimeUnit::MILLI),
+                     duration(TimeUnit::MILLI)});
   CheckDispatchBest(
       "case_when", {struct_({field("", boolean())}), decimal128(38, 0), decimal128(1, 1)},
       {struct_({field("", boolean())}), decimal256(39, 1), decimal256(39, 1)});
@@ -3350,6 +3359,8 @@ TEST(TestCoalesce, DispatchBest) {
                     {timestamp(TimeUnit::SECOND), timestamp(TimeUnit::SECOND)});
   CheckDispatchBest("coalesce", {timestamp(TimeUnit::SECOND), timestamp(TimeUnit::MILLI)},
                     {timestamp(TimeUnit::MILLI), timestamp(TimeUnit::MILLI)});
+  CheckDispatchBest("coalesce", {duration(TimeUnit::SECOND), duration(TimeUnit::MILLI)},
+                    {duration(TimeUnit::MILLI), duration(TimeUnit::MILLI)});
   CheckDispatchFails("coalesce", {
                                      sparse_union({field("a", boolean())}),
                                      dense_union({field("a", boolean())}),
diff --git a/cpp/src/arrow/compute/kernels/test_util.h b/cpp/src/arrow/compute/kernels/test_util.h
index 73762a1ac6758..11e77caeff861 100644
--- a/cpp/src/arrow/compute/kernels/test_util.h
+++ b/cpp/src/arrow/compute/kernels/test_util.h
@@ -185,7 +185,10 @@ template <typename T>
 enable_if_decimal<T, std::shared_ptr<DataType>> default_type_instance() {
   return std::make_shared<T>(5, 2);
 }
-
+template <typename T>
+enable_if_duration<T, std::shared_ptr<DataType>> default_type_instance() {
+  return std::make_shared<T>(TimeUnit::type::SECOND);
+}
 // Random Generator Helpers
 class RandomImpl {
  protected:

From b97e5267d703b565875405e860c553dac1744c53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Mon, 14 Aug 2023 12:24:11 -0400
Subject: [PATCH 155/749] GH-35916 [Java][arrow-jdbc] Add extra fields to
 JdbcFieldInfo (#37123)

### Rationale for this change

Existing info is not enough to make completely accurate conversion decisions.

### What changes are included in this PR?

Include the type name reported by the database and the max number of characters as part of the `JdbcFieldInfo`.
* Closes: #35916

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/adapter/jdbc/JdbcFieldInfo.java     | 43 ++++++++++++++++++-
 .../arrow/adapter/jdbc/ResultSetUtility.java  | 32 ++++++++++++++
 2 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcFieldInfo.java b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcFieldInfo.java
index 3237c9bf97be8..97ca8f27ceb49 100644
--- a/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcFieldInfo.java
+++ b/java/adapter/jdbc/src/main/java/org/apache/arrow/adapter/jdbc/JdbcFieldInfo.java
@@ -17,6 +17,7 @@
 
 package org.apache.arrow.adapter.jdbc;
 
+import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Types;
@@ -40,6 +41,8 @@ public class JdbcFieldInfo {
   private final int nullability;
   private final int precision;
   private final int scale;
+  private final String typeName;
+  private final int displaySize;
 
   /**
    * Builds a <code>JdbcFieldInfo</code> using only the {@link java.sql.Types} type.  Do not use this constructor
@@ -53,12 +56,13 @@ public JdbcFieldInfo(int jdbcType) {
     Preconditions.checkArgument(
         (jdbcType != Types.DECIMAL && jdbcType != Types.NUMERIC),
         "DECIMAL and NUMERIC types require a precision and scale; please use another constructor.");
-
     this.column = 0;
     this.jdbcType = jdbcType;
     this.nullability = ResultSetMetaData.columnNullableUnknown;
     this.precision = 0;
     this.scale = 0;
+    this.typeName = "";
+    this.displaySize = 0;
   }
 
   /**
@@ -75,6 +79,8 @@ public JdbcFieldInfo(int jdbcType, int precision, int scale) {
     this.nullability = ResultSetMetaData.columnNullableUnknown;
     this.precision = precision;
     this.scale = scale;
+    this.typeName = "";
+    this.displaySize = 0;
   }
 
   /**
@@ -92,6 +98,8 @@ public JdbcFieldInfo(int jdbcType, int nullability, int precision, int scale) {
     this.nullability = nullability;
     this.precision = precision;
     this.scale = scale;
+    this.typeName = "";
+    this.displaySize = 0;
   }
 
   /**
@@ -115,6 +123,25 @@ public JdbcFieldInfo(ResultSetMetaData rsmd, int column) throws SQLException {
     this.nullability = rsmd.isNullable(column);
     this.precision = rsmd.getPrecision(column);
     this.scale = rsmd.getScale(column);
+    this.typeName = rsmd.getColumnTypeName(column);
+    this.displaySize = rsmd.getColumnDisplaySize(column);
+  }
+
+  /**
+   * Builds a <code>JdbcFieldInfo</code> from the corresponding row from a {@link java.sql.DatabaseMetaData#getColumns}
+   * ResulSet.
+   *
+   * @param rs The {@link java.sql.ResultSet} to get the field information from.
+   * @throws SQLException If the column information cannot be retrieved.
+   */
+  public JdbcFieldInfo(ResultSet rs) throws SQLException {
+    this.column = rs.getInt("ORDINAL_POSITION");
+    this.jdbcType = rs.getInt("DATA_TYPE");
+    this.nullability = rs.getInt("NULLABLE");
+    this.precision = rs.getInt("COLUMN_SIZE");
+    this.scale = rs.getInt("DECIMAL_DIGITS");
+    this.typeName = rs.getString("TYPE_NAME");
+    this.displaySize = rs.getInt("CHAR_OCTET_LENGTH");
   }
 
   /**
@@ -151,4 +178,18 @@ public int getScale() {
   public int getColumn() {
     return column;
   }
+
+  /**
+   * The type name as reported by the database.
+   */
+  public String getTypeName() {
+    return typeName;
+  }
+
+  /**
+   * The max number of characters for the column.
+   */
+  public int getDisplaySize() {
+    return displaySize;
+  }
 }
diff --git a/java/adapter/jdbc/src/test/java/org/apache/arrow/adapter/jdbc/ResultSetUtility.java b/java/adapter/jdbc/src/test/java/org/apache/arrow/adapter/jdbc/ResultSetUtility.java
index 339e120beea76..c712741b51f5b 100644
--- a/java/adapter/jdbc/src/test/java/org/apache/arrow/adapter/jdbc/ResultSetUtility.java
+++ b/java/adapter/jdbc/src/test/java/org/apache/arrow/adapter/jdbc/ResultSetUtility.java
@@ -308,6 +308,16 @@ public int isNullable(int column) throws SQLException {
       return columns.get(column - 1).isNullable();
     }
 
+    @Override
+    public int getColumnDisplaySize(int column) throws SQLException {
+      return columns.get(column - 1).getDisplaySize();
+    }
+
+    @Override
+    public String getColumnTypeName(int column) throws SQLException {
+      return columns.get(column - 1).getTypeName();
+    }
+
     public static MockResultSetMetaData fromRows(ArrayList<MockRow> rows) throws SQLException {
       // Note: This attempts to dynamically construct ResultSetMetaData from the first row in a given result set.
       // If there are now rows, or the result set contains no columns, this cannot be dynamically generated and
@@ -334,6 +344,8 @@ public static class MockColumnMetaData {
       private int scale;
       private int nullable;
       private String label;
+      private String typeName;
+      private int displaySize;
 
 
       private MockColumnMetaData() {}
@@ -362,6 +374,14 @@ private int isNullable() {
         return nullable;
       }
 
+      private String getTypeName() {
+        return typeName;
+      }
+
+      private int getDisplaySize() {
+        return displaySize;
+      }
+
       public static MockColumnMetaData fromDataElement(MockDataElement element, int i) throws SQLException {
         return MockColumnMetaData.builder()
                 .index(i)
@@ -369,6 +389,8 @@ public static MockColumnMetaData fromDataElement(MockDataElement element, int i)
                 .precision(element.getPrecision())
                 .scale(element.getScale())
                 .nullable(element.isNullable())
+                .setTypeName("TYPE")
+                .setDisplaySize(420)
                 .label("col_" + i)
                 .build();
       }
@@ -410,6 +432,16 @@ public Builder nullable(int nullable) {
           return this;
         }
 
+        public Builder setTypeName(String typeName) {
+          this.columnMetaData.typeName = typeName;
+          return this;
+        }
+
+        public Builder setDisplaySize(int displaySize) {
+          this.columnMetaData.displaySize = displaySize;
+          return this;
+        }
+
         public MockColumnMetaData build() {
           return this.columnMetaData;
         }

From 239c23a6bbb8dcd9a54a6994d119177a014bf29e Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Mon, 14 Aug 2023 14:39:22 -0400
Subject: [PATCH 156/749] GH-37128: [Java] Bump CI job from JDK 18 to JDK 20
 (#37125)

### Rationale for this change

Our CI job should be testing the latest Java/Maven combo. It has currently fallen behind by 2 JDK releases (18 -> 20). Also, let's bump the maven version to the latest stable release.

We are also seeing some flaky CI jobs related to CycloneDx that only fails on the Java 18 CI job. Maybe this resolves it? For more details, see https://github.com/apache/arrow/issues/36371

### What changes are included in this PR?

* Bump Java/Maven versions for one CI job

### Are these changes tested?

Relying on CI to test.

### Are there any user-facing changes?

No
* Closes: #37128

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .github/workflows/java.yml                       | 16 ++++++++--------
 docker-compose.yml                               | 14 +++++++-------
 java/flight/flight-sql-jdbc-core/pom.xml         |  4 ++--
 .../utils/ClientAuthenticationUtilsTest.java     |  6 ++++--
 java/flight/flight-sql-jdbc-driver/pom.xml       |  4 ++--
 5 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index c7d7aee19e36f..8a66d7858af37 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -55,7 +55,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [8, 11, 17, 18]
+        jdk: [8, 11, 17, 20]
         include:
         - jdk: 8
           title: AMD64 Debian 9 Java JDK 8 Maven 3.5.4
@@ -66,13 +66,13 @@ jobs:
           maven: 3.6.2
           image: debian-java
         - jdk: 17
-          title: AMD64 Oracle Linux Server 8.5 Java JDK 17 Maven 3.8.5
-          maven: 3.8.5
-          image: oracle-java
-        - jdk: 18
-          title: AMD64 Oracle Linux Server 8.6 Java JDK 18 Maven 3.8.5
-          maven: 3.8.5
-          image: oracle-java
+          title: AMD64 Ubuntu 22.04 Java JDK 17 Maven 3.9.3
+          maven: 3.9.3
+          image: eclipse-java
+        - jdk: 20
+          title: AMD64 Ubuntu 22.04 Java JDK 20 Maven 3.9.3
+          maven: 3.9.3
+          image: eclipse-java
     env:
       JDK: ${{ matrix.jdk }}
       MAVEN: ${{ matrix.maven }}
diff --git a/docker-compose.yml b/docker-compose.yml
index 3bf346ef94173..c193a7d11e0e3 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -136,9 +136,9 @@ x-hierarchy:
     - debian-go-cgo-python
   - debian-java
   - debian-js
+  - eclipse-java
   - fedora-cpp:
     - fedora-python
-  - oracle-java
   - python-sdist
   - ubuntu-cpp:
     - ubuntu-cpp-static
@@ -1665,14 +1665,14 @@ services:
         /arrow/ci/scripts/java_build.sh /arrow /build &&
         /arrow/ci/scripts/java_test.sh /arrow /build"
 
-  oracle-java:
+  eclipse-java:
     # Usage:
-    #   docker-compose build oracle-java
-    #   docker-compose run oracle-java
+    #   docker-compose build eclipse-java
+    #   docker-compose run eclipse-java
     # Parameters:
-    #   MAVEN: 3.8.5
-    #   JDK: 17
-    image: ${ARCH}/maven:${MAVEN}-openjdk-${JDK}
+    #   MAVEN: 3.9.3
+    #   JDK: 17, 20
+    image: ${ARCH}/maven:${MAVEN}-eclipse-temurin-${JDK}
     shm_size: *shm-size
     volumes: *java-volumes
     command: *java-command
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index 4c59596be353d..dbf3efa595757 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -107,14 +107,14 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>3.12.4</version>
+            <version>4.11.0</version>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-inline</artifactId>
-            <version>3.12.4</version>
+            <version>4.11.0</version>
             <scope>test</scope>
         </dependency>
 
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtilsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtilsTest.java
index f073ab660ecf4..27bba64587367 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtilsTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtilsTest.java
@@ -158,7 +158,7 @@ private MockedStatic<KeyStore> createKeyStoreStaticMock() {
           if (method.getName().equals("getInstance")) {
             return invocationOnMock.callRealMethod();
           }
-          return invocationOnMock.getMock();
+          return method.invoke(invocationOnMock.getMock(), invocationOnMock.getArguments());
         }
     );
   }
@@ -169,13 +169,15 @@ private MockedStatic<ClientAuthenticationUtils> createClientAuthenticationUtilsS
       if (method.getName().equals("getCertificateInputStreamFromSystem")) {
         return invocationOnMock.callRealMethod();
       }
-      return invocationOnMock.getMock();
+      return method.invoke(invocationOnMock.getMock(), invocationOnMock.getArguments());
     });
   }
 
   private void setOperatingSystemMock(MockedStatic<ClientAuthenticationUtils> clientAuthenticationUtilsMockedStatic,
                                       boolean isWindows, boolean isMac) {
     clientAuthenticationUtilsMockedStatic.when(ClientAuthenticationUtils::isMac).thenReturn(isMac);
+    Assert.assertEquals(ClientAuthenticationUtils.isMac(), isMac);
     clientAuthenticationUtilsMockedStatic.when(ClientAuthenticationUtils::isWindows).thenReturn(isWindows);
+    Assert.assertEquals(ClientAuthenticationUtils.isWindows(), isWindows);
   }
 }
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 6ba947997dac8..38ebc929efe47 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -68,14 +68,14 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>3.12.4</version>
+            <version>4.11.0</version>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-inline</artifactId>
-            <version>3.12.4</version>
+            <version>4.11.0</version>
             <scope>test</scope>
         </dependency>
 

From 750670e8c7c8b7985323f7866e4aa09be4232169 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 14 Aug 2023 15:07:06 -0400
Subject: [PATCH 157/749] GH-37155: [MATLAB] Use
 `arrow.internal.validate.index.numeric()` in the `column()` method of
 `arrow.tabular.RecordBatch` (#37156)

### Rationale for this change

Now that the PR introducing the `arrow.internal.validate.index.numeric()` function has been merged (#37150), we should use this utility function within the `column()` method of `arrow.tabular.RecordBatch`. Doing so will remove duplicate code from the code base.

### What changes are included in this PR?

1. Updated the `column()` method of `arrow.tabular.RecordBatch` to use `arrow.internal.validate.index.numeric()`.

### Are these changes tested?

Yes, these changes are covered by these two existing test classes:

1. `test/arrow/tabular/tRecordBatch.m`
2. `test/arrow/internal/validate/index/tNumeric.m`

In addition, I added a new test point to `tRecordBatch.m` called `ErrorIfNonPositiveIndex` to verify `arrow.internal.validate.index.numeric` is integrated correctly.

### Are there any user-facing changes?

No.

### Future Directions

1. In a future pull request, we will add support for indexing columns by name. Currently, the `column()` method only supports numeric indexing.
* Closes: #37155

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 24 ++++++++++---------
 matlab/test/arrow/tabular/tRecordBatch.m      | 16 ++++++++++++-
 2 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 0fd9fb81d413e..fb978a09ec878 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -45,17 +45,19 @@
         end
 
         function arrowArray = column(obj, idx)
-            if ~isempty(idx) && isscalar(idx) && isnumeric(idx) && idx >= 1
-                args = struct(Index=int32(idx));
-                [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);
-                traits = arrow.type.traits.traits(arrow.type.ID(typeID));
-                proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=proxyID);
-                arrowArray = traits.ArrayConstructor(proxy);
-            else
-                errid = "arrow:tabular:recordbatch:UnsupportedColumnIndexType";
-                msg = "Index must be a positive scalar integer.";
-                error(errid, msg);
-            end
+            import arrow.internal.validate.*
+
+            idx = index.numeric(idx, "int32");
+            % TODO: Consider vectorizing column() in the future to support
+            % extracting multiple columns at once.
+            validateattributes(idx, "int32", "scalar");
+
+            args = struct(Index=idx);
+            [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);                
+            
+            traits = arrow.type.traits.traits(arrow.type.ID(typeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=proxyID);
+            arrowArray = traits.ArrayConstructor(proxy);
         end
 
         function T = table(obj)
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 025f15320ade4..e4ef649bd04b5 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -119,7 +119,21 @@ function UnsupportedColumnIndexType(tc)
             TOriginal = table(1, 2, 3);
             arrowRecordBatch = arrow.recordbatch(TOriginal);
             fcn = @() arrowRecordBatch.column(datetime(2022, 1, 3));
-            tc.verifyError(fcn, "arrow:tabular:recordbatch:UnsupportedColumnIndexType");
+            tc.verifyError(fcn, "arrow:badsubscript:NonNumeric");
+        end
+
+        function ErrorIfIndexIsNonScalar(tc)
+            TOriginal = table(1, 2, 3);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            fcn = @() arrowRecordBatch.column([1 2]);
+            tc.verifyError(fcn, "MATLAB:expectedScalar");
+        end
+
+        function ErrorIfIndexIsNonPositive(tc)
+            TOriginal = table(1, 2, 3);
+            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            fcn = @() arrowRecordBatch.column(-1);
+            tc.verifyError(fcn, "arrow:badsubscript:NonPositive");
         end
     end
 end

From d279dd8df93109eb38e7a232b039f2c3182e4f30 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 14 Aug 2023 15:44:03 -0400
Subject: [PATCH 158/749] GH-37160: [MATLAB]
 `arrow.internal.validate.index.string()` should not error if given a string
 with zero characters (#37161)

### Rationale for this change

Currently, `arrow.internal.validate.index.string()` throws an error if given a string value with zero characters.

```matlab
>> arrow.internal.validate.index.string("")
Error using arrow.internal.validate.index.string
String indices must contain at least one character.
```

However, it's possible to have a field whose name is `""` in `arrow.tabular.Schema`. Therefore, we should support accessing that field by its name `""`.

### What changes are included in this PR?

1. `arrow.internal.validate.index.string()` no longer errors if given a string value with zero characters.

### Are these changes tested?

Yes. Updated the test cases in `test/arrow/internal/validate/index/tString.m` to verify `""` is accepted as an index value.

### Are there any user-facing changes?

No.

* Closes: #37160

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+arrow/+internal/+validate/+index/string.m    |  4 ----
 .../test/arrow/internal/validate/index/tString.m  | 15 ++++++---------
 2 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
index 5f5fe6527e9b6..e8c713770af52 100644
--- a/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
@@ -30,9 +30,5 @@
         errid = "arrow:badsubscript:MissingString";
         msg = "String indices must be nonmissing";
         error(errid, msg);
-    elseif any(strlength(index) == 0)
-        errid = "arrow:badsubscript:ZeroLengthText";
-        msg = "String indices must contain at least one character.";
-        error(errid, msg);
     end
 end
diff --git a/matlab/test/arrow/internal/validate/index/tString.m b/matlab/test/arrow/internal/validate/index/tString.m
index d64e4fdb8dc2e..2e6bf020d6cf4 100644
--- a/matlab/test/arrow/internal/validate/index/tString.m
+++ b/matlab/test/arrow/internal/validate/index/tString.m
@@ -35,20 +35,17 @@ function MissingStringError(testCase)
             testCase.verifyError(fcn, errid);
         end
 
-        function ZeroLengthTextError(testCase)
-            % Verify string() throws an error whose idenitifier is 
-            % "arrow:badsubscript:ZeroLengthText" if the index array 
+        function ZeroLengthText(testCase)
+            % Verify string() does not throw an error if the index array 
             % provided has zero length text values.
 
             import arrow.internal.validate.*
 
-            errid = "arrow:badsubscript:ZeroLengthText";
-
-            fcn = @() index.string("");
-            testCase.verifyError(fcn, errid);
+            idx = index.string("");
+            testCase.verifyEqual(idx, "");
 
-            fcn = @() index.string(["A" "" "B"]);
-            testCase.verifyError(fcn, errid);
+            idx = index.string(["A" "" "B"]);
+            testCase.verifyEqual(idx, ["A"; ""; "B"]);
         end
 
         function ValidStringIndices(testCase)

From 4dd742c83d76e696f0ae8c2dd2f667d9ab2bf555 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 14 Aug 2023 16:52:17 -0400
Subject: [PATCH 159/749] GH-37157: [MATLAB] Use
 `arrow.internal.validate.index.numericOrString()` in the `field()` method of
 `arrow.tabular.Schema` (#37162)

### Rationale for this change

Now that the PR introducing the `arrow.internal.validate.inex.numericOrString()` function has been merged (#37150), we should use this utility function within the `field()` method of `arrow.tabular.Schema`. Doing so will remove duplicate code from the code base.

### What changes are included in this PR?

1. Updated the `field()` method of `arrow.tabular.Schema` to use `arrow.internal.validate.index.numericOrString()`.

### Are these changes tested?

Yes. Updated the test points in `test/arrow/tabular/tSchema.m` to account for the new error message IDs.

### Are there any user-facing changes?

No.

* Closes: #37157

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+tabular/Schema.m | 23 ++++++++++-------
 matlab/test/arrow/tabular/tSchema.m        | 30 +++++++++++-----------
 2 files changed, 29 insertions(+), 24 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index 3d75e6c44a2df..b613bd650dfc8 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -43,17 +43,22 @@
         end
         
         function F = field(obj, idx)
-            idx = convertCharsToStrings(idx);
-            if ~isempty(idx) && isscalar(idx) && isnumeric(idx) && idx >= 1
-                args = struct(Index=int32(idx));
+            import arrow.internal.validate.*
+            
+            idx = index.numericOrString(idx, "int32");
+
+            if isnumeric(idx)
+                % TODO: Consider vectorizing field() to support extracting
+                % multiple fields at once.
+                validateattributes(idx, "int32", "scalar");
+                args = struct(Index=idx);
                 proxyID = obj.Proxy.getFieldByIndex(args);
-            elseif isscalar(idx) && isstring(idx)
-                name = idx;
-                args = struct(Name=name);
-                proxyID = obj.Proxy.getFieldByName(args);
             else
-                error("arrow:tabular:schema:UnsupportedFieldIndexType", ...
-                      "Index must be a positive scalar integer or a valid field name.");
+                % TODO: Consider vectorizing field() to support extracting
+                % multiple fields at once.
+                validateattributes(idx, "string", "scalar");
+                args = struct(Name=idx);
+                proxyID = obj.Proxy.getFieldByName(args);
             end
 
             proxy = libmexclass.proxy.Proxy(Name="arrow.type.proxy.Field", ID=proxyID);
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index d550c488fd86d..dbeb2db1fd57d 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -139,25 +139,25 @@ function ErrorIfUnsupportedFieldIndex(testCase)
             ]);
 
             index = [];
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "MATLAB:expectedScalar");
 
             index = 0;
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonPositive");
 
             index = -1;
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonPositive");
 
-            index = -1.23;
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            index = 1.23;
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonInteger");
 
             index = NaN;
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonInteger");
 
             index = {1};
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:UnsupportedIndexType");
 
             index = [1; 1];
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(index), "MATLAB:expectedScalar");
         end
 
         function GetFieldByIndex(testCase)
@@ -375,7 +375,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.NumFields, int32(0));
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
-            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
             testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
 
             % 0x1 empty Field array.
@@ -384,7 +384,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.NumFields, int32(0));
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
-            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
             testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
 
             % 1x0 empty Field array.
@@ -393,7 +393,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.NumFields, int32(0));
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
-            testCase.verifyError(@() schema.field(0), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
             testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
         end
 
@@ -446,10 +446,10 @@ function ErrorIfNumericIndexIsNonScalar(testCase)
             ]);
 
             fieldName = [1, 2, 3];
-            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
 
             fieldName = [1; 2; 3];
-            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
         end
 
         function ErrorIfFieldNameIsNonScalar(testCase)
@@ -462,10 +462,10 @@ function ErrorIfFieldNameIsNonScalar(testCase)
             ]);
 
             fieldName = ["A", "B", "C"];
-            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
 
             fieldName = ["A";  "B"; "C"];
-            testCase.verifyError(@() schema.field(fieldName), "arrow:tabular:schema:UnsupportedFieldIndexType");
+            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
         end
 
     end

From 95db0df5f213bb412c0e1c3c53f462c0255f0b1c Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 14 Aug 2023 17:11:20 -0400
Subject: [PATCH 160/749] GH-37046: [MATLAB] Implement `featherread` in terms
 of `arrow.internal.io.feather.Reader` (#37163)

### Rationale for this change

Now that #37044 is merged, we can re-implement `featherread` in terms of the new `arrow.internal.io.feather.Reader` class.

Once this change is made, we can delete the legacy build infrastructure and `featherread` MEX code.

### What changes are included in this PR?

1. Reimplemented `featherread` in terms of the new `arrow.internal.io.feather.Reader` class.
2. We tried to maintain compatibility with the old code as much as possible, but since `featherread` is now implemented in terms of `RecordBatch`, there are some minor changes in behavior and support for some new data types (e.g. `Boolean`, `String`, `Timestamp`) that are introduced by these changes.
3. Updated `arrow/matlab/io/feather/proxy/reader.cc` to prevent a `nullptr` dereference that was occurring when reading a Feather V1 file created from an empty table by using `Table::CombineChunksToBatch` rather than a `TableBatchReader`.

**Example**
```matlab
>> tWrite = table(["A"; "B"; "C"], [true; false; true], [1; 2; 3], VariableNames=["String", "Boolean", "Float64"])

tWrite =

  3x3 table

    String    Boolean    Float64
    ______    _______    _______

     "A"       true         1
     "B"       false        2
     "C"       true         3

>> featherwrite("test.feather", tWrite)

>> tRead = featherread("test.feather")

tRead =

  3x3 table

    String    Boolean    Float64
    ______    _______    _______

     "A"       true         1
     "B"       false        2
     "C"       true         3

>> isequaln(tWrite, tRead)

ans =

  logical

   1
```

### Are these changes tested?

Yes.

1. Updated the existing `tfeather.m` and `tfeathermex.m` tests to reflect the new behavior of `featherread`. This mainly consists of error message ID changes.
2. Added a new test to verify that all MATLAB types supported by `arrow.tabular.RecordBatch` can be round-tripped to a Feather V1 file.
4. Added a new test to verify that a MATLAB `table` with Unicode `Variablenames` can be round-tripped to a Feather V1 file.

### Are there any user-facing changes?

Yes.

1. Now that `featherread` is implemented in terms of `arrow.internal.io.feather.Reader` and `arrow.tabular.RecordBatch`, it supports reading more types like `Boolean`, `String`, `Timestamp`, etc. **Note**: We updated the code to cast `logical`/`Boolean` type columns containing null values to `double` and substitute null values with `NaN`. This mirrors the existing behavior of `featherread` for integer type columns containing null values.
2. There are some minor error message ID changes.
4. Cell arrays of strings with a single element (e.g. `{'filename.feather'}`) are now supported as a valid `filename` for `featherread`.

### Future Directions

1. In the future, we may want to consider no longer casting columns with integer/logical type containing null values to `double` and substituting null values with `NaN`. This behavior isn't ideal in all cases (it can be lossy for types like `uint64`). This change would break compatibility.
2. Delete legacy Feather V1 code and build infrastructure.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!

* Closes: #37046

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/io/feather/proxy/reader.cc   |  6 +-
 matlab/src/matlab/featherread.m               | 85 +++++++------------
 matlab/test/tfeather.m                        | 45 ++++++++--
 matlab/test/tfeathermex.m                     |  6 +-
 4 files changed, 77 insertions(+), 65 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
index a264d24ecb1bd..db33b410f7b92 100644
--- a/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
+++ b/matlab/src/cpp/arrow/matlab/io/feather/proxy/reader.cc
@@ -72,10 +72,8 @@ namespace arrow::matlab::io::feather::proxy {
         std::shared_ptr<arrow::Table> table = nullptr;
         MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(reader->Read(&table), context, error::FEATHER_FAILED_TO_READ_TABLE);
 
-        // Get the first RecordBatch from the Table.
-        arrow::TableBatchReader table_batch_reader{table};
-        std::shared_ptr<arrow::RecordBatch> record_batch = nullptr;
-        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(table_batch_reader.ReadNext(&record_batch), context, error::FEATHER_FAILED_TO_READ_RECORD_BATCH);
+        // Combine all the chunks of the Table into a single RecordBatch.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto record_batch, table->CombineChunksToBatch(arrow::default_memory_pool()), context, error::FEATHER_FAILED_TO_READ_RECORD_BATCH);
 
         // Create a Proxy from the first RecordBatch.
         auto record_batch_proxy = std::make_shared<RecordBatchProxy>(record_batch);
diff --git a/matlab/src/matlab/featherread.m b/matlab/src/matlab/featherread.m
index 5f4952873f9ac..736fe832888c2 100644
--- a/matlab/src/matlab/featherread.m
+++ b/matlab/src/matlab/featherread.m
@@ -23,64 +23,45 @@
 % specific language governing permissions and limitations
 % under the License.
 
-import arrow.util.*;
+    arguments
+        filename(1, 1) string {mustBeNonmissing, mustBeNonzeroLengthText}
+    end
 
-% Validate input arguments.
-narginchk(1, 1);
-filename = convertStringsToChars(filename);
-if ~ischar(filename)
-    error('MATLAB:arrow:InvalidFilenameDatatype', ...
-        'Filename must be a character vector or string scalar.');
-end
+    typesToCast = [arrow.type.ID.UInt8, ...
+                   arrow.type.ID.UInt16, ...
+                   arrow.type.ID.UInt32, ...
+                   arrow.type.ID.UInt64, ...
+                   arrow.type.ID.Int8, ...
+                   arrow.type.ID.Int16, ...
+                   arrow.type.ID.Int32, ...
+                   arrow.type.ID.Int64, ...
+                   arrow.type.ID.Boolean];
 
-% FOPEN can be used to search for files without an extension on the MATLAB
-% path.
-fid = fopen(filename);
-if fid ~= -1
-    filename = fopen(fid);
-    fclose(fid);
-else
-    error('MATLAB:arrow:UnableToOpenFile', ...
-        'Unable to open file %s.', filename);
-end
+    reader = arrow.internal.io.feather.Reader(filename);
+    recordBatch = reader.read();
 
-% Read table variables and metadata from the given Feather file using
-% libarrow.
-[variables, metadata] = arrow.cpp.call('featherread', filename);
+    % Convert RecordBatch to a MATLAB table.
+    t = table(recordBatch);
 
-% Make valid MATLAB table variable names out of any of the
-% Feather table column names that are not valid MATLAB table
-% variable names.
-[variableNames, variableDescriptions] = makeValidMATLABTableVariableNames({variables.Name});
-
-% Iterate over each table variable, handling invalid (null) entries
-% and invalid MATLAB table variable names appropriately.
-% Note: All Arrow arrays can have an associated validity (null) bitmap.
-% The Apache Arrow specification defines 0 (false) to represent an
-% invalid (null) array entry and 1 (true) to represent a valid
-% (non-null) array entry.
-for ii = 1:length(variables)
-    if ~all(variables(ii).Valid)
-        switch variables(ii).Type
-            case {'uint8', 'uint16', 'uint32', 'uint64', 'int8', 'int16', 'int32', 'int64'}
-                % MATLAB does not support missing values for integer types, so
-                % cast to double and set missing values to NaN in this case.
-                variables(ii).Data = double(variables(ii).Data);
+    % Cast integer and boolean columns containing null values
+    % to double. Substitute null values with NaN.
+    for ii = 1:recordBatch.NumColumns
+        array = recordBatch.column(ii);
+        type = array.Type.ID;
+        if any(type == typesToCast) && any(~array.Valid)
+            % Cast to double.
+            t.(ii) = double(t.(ii));
+            % Substitute null values with NaN.
+            t{~array.Valid, ii} = NaN;
         end
-
-        % Set invalid (null) entries to the appropriate MATLAB missing value using
-        % logical indexing.
-        variables(ii).Data(~variables(ii).Valid) = missing;
     end
-end
-
-% Construct a MATLAB table from the Feather file data.
-t = table(variables.Data, 'VariableNames', cellstr(variableNames));
 
-% Store original Feather table column names in the table.Properties.VariableDescriptions
-% property if they were modified to be valid MATLAB table variable names.
-if ~isempty(variableDescriptions)
-    t.Properties.VariableDescriptions = cellstr(variableDescriptions);
-end
+    % Store original Feather table column names in the table.Properties.VariableDescriptions
+    % property if they were modified to be valid MATLAB table variable names.
+    modifiedColumnNameIndices = t.Properties.VariableNames ~= recordBatch.ColumnNames;
+    if any(modifiedColumnNameIndices)
+        originalColumnNames = recordBatch.ColumnNames(modifiedColumnNameIndices);
+        t.Properties.VariableDescriptions(modifiedColumnNameIndices) = compose("Original variable name: '%s'", originalColumnNames);
+    end
 
 end
diff --git a/matlab/test/tfeather.m b/matlab/test/tfeather.m
index e4c988e1dda49..8cdbef27fad80 100755
--- a/matlab/test/tfeather.m
+++ b/matlab/test/tfeather.m
@@ -143,7 +143,7 @@ function zeroByNTable(testCase)
         function ErrorIfUnableToOpenFile(testCase)
             filename = fullfile(pwd, 'temp.feather');
 
-            testCase.verifyError(@() featherread(filename), 'MATLAB:arrow:UnableToOpenFile');
+            testCase.verifyError(@() featherread(filename), 'arrow:io:FailedToOpenFileForRead');
         end
 
         function ErrorIfCorruptedFeatherFile(testCase)
@@ -156,16 +156,13 @@ function ErrorIfCorruptedFeatherFile(testCase)
             fwrite(fileID, [1; 5]);
             fclose(fileID);
             
-            testCase.verifyError(@() featherread(filename), 'MATLAB:arrow:status:Invalid');
+            testCase.verifyError(@() featherread(filename), 'arrow:io:feather:FailedToCreateReader');
         end
         
         function ErrorIfInvalidFilenameDatatype(testCase)
-            filename = fullfile(pwd, 'temp.feather');
-            
             t = createTable;
             
             testCase.verifyError(@() featherwrite({table}, t), 'MATLAB:validation:UnableToConvert');
-            testCase.verifyError(@() featherread({filename}), 'MATLAB:arrow:InvalidFilenameDatatype');
         end
 
         function ErrorIfTooManyInputs(testCase)
@@ -179,7 +176,7 @@ function ErrorIfTooManyInputs(testCase)
 
         function ErrorIfTooFewInputs(testCase)
             testCase.verifyError(@() featherwrite(), 'MATLAB:minrhs');
-            testCase.verifyError(@() featherread(), 'MATLAB:narginchk:notEnoughInputs');
+            testCase.verifyError(@() featherread(), 'MATLAB:minrhs');
         end
         
         function ErrorIfMultiColVarExist(testCase)
@@ -218,5 +215,41 @@ function NumericComplexUnsupported(testCase)
            
             testCase.verifyError(@() featherwrite(filename, actualTable) ,'arrow:array:ComplexNumeric');
         end
+
+        function SupportedTypes(testCase)
+            filename = fullfile(pwd, 'temp.feather');
+
+            % Create a table with all supported MATLAB types.
+            expectedTable = table(int8   ([1, 2, 3]'), ...
+                                  int16  ([1, 2, 3]'), ...
+                                  int32  ([1, 2, 3]'), ...
+                                  int64  ([1, 2, 3]'), ...
+                                  uint8  ([1, 2, 3]'), ...
+                                  uint16 ([1, 2, 3]'), ...
+                                  uint32 ([1, 2, 3]'), ...
+                                  uint64 ([1, 2, 3]'), ...
+                                  logical([1, 0, 1]'), ...
+                                  single ([1, 2, 3]'), ...
+                                  double ([1, 2, 3]'), ...
+                                  string (["A", "B", "C"]'), ...
+                                  datetime(2023, 6, 28) + days(0:2)');
+
+            actualTable = featherRoundTrip(filename, expectedTable);
+            testCase.verifyEqual(actualTable, expectedTable);
+        end
+
+        function UnicodeVariableNames(testCase)
+            filename = fullfile(pwd, 'temp.feather');
+
+            smiley = "😀";
+            tree =  "🌲";
+            mango = "🥭";
+            columnNames = [smiley, tree, mango];
+            expectedTable = table(1, 2, 3, VariableNames=columnNames);
+
+            actualTable = featherRoundTrip(filename, expectedTable);
+            testCase.verifyEqual(actualTable, expectedTable);
+        end
+
     end
 end
diff --git a/matlab/test/tfeathermex.m b/matlab/test/tfeathermex.m
index c0620e9054bf1..8b6b87aab1072 100644
--- a/matlab/test/tfeathermex.m
+++ b/matlab/test/tfeathermex.m
@@ -50,17 +50,17 @@ function InvalidMATLABTableVariableNames(testCase)
             filename = fullfile(pwd, 'temp.feather');
             
             % Create a table with an invalid MATLAB table variable name.
-            invalidVariable = arrow.util.createVariableStruct('double', 1, true, '@');
+            invalidVariable = arrow.util.createVariableStruct('double', 1, true, ':');
             validVariable = arrow.util.createVariableStruct('double', 1, true, 'Valid');
             variables = [invalidVariable, validVariable];
             metadata = arrow.util.createMetadataStruct(1, 2);
             arrow.cpp.call('featherwrite', filename, variables, metadata);
             t = featherread(filename);
             
-            testCase.verifyEqual(t.Properties.VariableNames{1}, 'x_');
+            testCase.verifyEqual(t.Properties.VariableNames{1}, ':_1');
             testCase.verifyEqual(t.Properties.VariableNames{2}, 'Valid');
             
-            testCase.verifyEqual(t.Properties.VariableDescriptions{1}, 'Original variable name: ''@''');
+            testCase.verifyEqual(t.Properties.VariableDescriptions{1}, 'Original variable name: '':''');
             testCase.verifyEqual(t.Properties.VariableDescriptions{2}, '');
         end 
     end

From 107b215faa17e9f7c1c08da4024de59323bb7a36 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 15 Aug 2023 10:51:13 +0900
Subject: [PATCH 161/749] GH-36155: [C++][Go][Java][FlightRPC] Add support for
 long-running queries (#36946)

### Rationale for this change

In Flight RPC, FlightInfo includes addresses of workers alongside result partition info. This lets clients fetch data directly from workers, in parallel or even distributed across multiple machines. But this also comes with tradeoffs.

Queries generally don't complete instantly (as much as we would like them to). So where can we put the 'query evaluation time'?

* In `GetFlightInfo`: block and wait for the query to complete.
  * Con: this is a long-running blocking call, which may fail or time out. Then when the client retries, the server has to redo all the work.
  * Con: parts of the result may be ready before others, but the client can't do anything until everything is ready.
* In `DoGet`: return a fixed number of partitions
  * Con: this makes handling worker failures hard. Systems like Trino support fault-tolerant execution by replacing workers at runtime. But GetFlightInfo has already passed, so we can't notify the client of new workers.
  * Con: we have to know or fix the partitioning up front.

Neither solution is optimal.

### What changes are included in this PR?

We can address this by adding a retryable version of `GetFlightInfo`: `PollFlightInfo(FlightDescriptor)`

`PollFlightInfo` returns `PollInfo`:

```proto
message PollInfo {
  // The currently available results so far.
  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. 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;
}
```

See the documentation changes for details of them:
http://crossbow.voltrondata.com/pr_docs/36946/format/Flight.html#downloading-data-by-running-a-heavy-query

### Are these changes tested?

Yes.

This has C++, Go and Java implementations and an integration test with them.

### Are there any user-facing changes?

Yes.
* Closes: #36155

Lead-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/CMakeLists.txt           |  10 +-
 cpp/src/arrow/flight/client.cc                |   8 +
 cpp/src/arrow/flight/client.h                 |  13 +
 cpp/src/arrow/flight/flight_internals_test.cc |  37 +-
 .../flight_integration_test.cc                |   2 +
 .../integration_tests/test_integration.cc     |  78 ++-
 cpp/src/arrow/flight/middleware.h             |   1 +
 .../arrow/flight/serialization_internal.cc    |  80 ++-
 cpp/src/arrow/flight/serialization_internal.h |   4 +
 cpp/src/arrow/flight/server.cc                |   6 +
 cpp/src/arrow/flight/server.h                 |  14 +-
 cpp/src/arrow/flight/transport.cc             |   5 +
 cpp/src/arrow/flight/transport.h              |   3 +
 .../flight/transport/grpc/grpc_client.cc      |  21 +
 .../flight/transport/grpc/grpc_server.cc      |  26 +
 .../arrow/flight/transport/ucx/ucx_client.cc  |  32 +
 .../arrow/flight/transport/ucx/ucx_internal.h |   1 +
 .../arrow/flight/transport/ucx/ucx_server.cc  |  23 +
 cpp/src/arrow/flight/type_fwd.h               |   1 +
 cpp/src/arrow/flight/types.cc                 |  86 +++
 cpp/src/arrow/flight/types.h                  |  65 ++
 dev/archery/archery/integration/runner.py     |   5 +
 docs/source/format/Flight.rst                 |  64 ++
 docs/source/format/Flight/PollFlightInfo.mmd  |  38 ++
 .../format/Flight/PollFlightInfo.mmd.svg      |   1 +
 format/Flight.proto                           |  71 ++-
 go/arrow/flight/flightsql/client_test.go      |   5 +
 go/arrow/flight/gen/flight/Flight.pb.go       | 512 ++++++++++------
 go/arrow/flight/gen/flight/FlightSql.pb.go    | 580 ++++++++----------
 go/arrow/flight/gen/flight/Flight_grpc.pb.go  | 122 +++-
 go/arrow/flight/server.go                     |   1 +
 .../internal/flight_integration/scenario.go   | 105 ++++
 .../org/apache/arrow/flight/FlightClient.java |  17 +
 .../org/apache/arrow/flight/FlightMethod.java |   3 +
 .../apache/arrow/flight/FlightProducer.java   |  16 +
 .../apache/arrow/flight/FlightService.java    |  15 +
 .../org/apache/arrow/flight/PollInfo.java     | 160 +++++
 .../tests/PollFlightInfoProducer.java         |  56 ++
 .../tests/PollFlightInfoScenario.java         |  62 ++
 .../flight/integration/tests/Scenarios.java   |   1 +
 .../integration/tests/IntegrationTest.java    |   5 +
 41 files changed, 1762 insertions(+), 593 deletions(-)
 create mode 100644 docs/source/format/Flight/PollFlightInfo.mmd
 create mode 100644 docs/source/format/Flight/PollFlightInfo.mmd.svg
 create mode 100644 java/flight/flight-core/src/main/java/org/apache/arrow/flight/PollInfo.java
 create mode 100644 java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoProducer.java
 create mode 100644 java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoScenario.java

diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt
index 6e76181533459..c37d2c56700e0 100644
--- a/cpp/src/arrow/flight/CMakeLists.txt
+++ b/cpp/src/arrow/flight/CMakeLists.txt
@@ -83,11 +83,15 @@ set(FLIGHT_GENERATED_PROTO_FILES
 
 set(PROTO_DEPENDS ${FLIGHT_PROTO} ${ARROW_PROTOBUF_LIBPROTOBUF} gRPC::grpc_cpp_plugin)
 
+set(FLIGHT_PROTOC_COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}")
+if(Protobuf_VERSION VERSION_LESS 3.15)
+  list(APPEND FLIGHT_PROTOC_COMMAND "--experimental_allow_proto3_optional")
+endif()
 add_custom_command(OUTPUT ${FLIGHT_GENERATED_PROTO_FILES}
-                   COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}"
-                           "--cpp_out=${CMAKE_CURRENT_BINARY_DIR}" "${FLIGHT_PROTO}"
                    DEPENDS ${PROTO_DEPENDS} ARGS
-                   COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${FLIGHT_PROTO_PATH}"
+                   COMMAND ${FLIGHT_PROTOC_COMMAND}
+                           "--cpp_out=${CMAKE_CURRENT_BINARY_DIR}" "${FLIGHT_PROTO}"
+                   COMMAND ${FLIGHT_PROTOC_COMMAND}
                            "--grpc_out=${CMAKE_CURRENT_BINARY_DIR}"
                            "--plugin=protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>"
                            "${FLIGHT_PROTO}")
diff --git a/cpp/src/arrow/flight/client.cc b/cpp/src/arrow/flight/client.cc
index eb62ec65ffc5f..f8dd4ba549ff3 100644
--- a/cpp/src/arrow/flight/client.cc
+++ b/cpp/src/arrow/flight/client.cc
@@ -640,6 +640,14 @@ arrow::Future<FlightInfo> FlightClient::GetFlightInfoAsync(
   return future;
 }
 
+arrow::Result<std::unique_ptr<PollInfo>> FlightClient::PollFlightInfo(
+    const FlightCallOptions& options, const FlightDescriptor& descriptor) {
+  std::unique_ptr<PollInfo> info;
+  RETURN_NOT_OK(CheckOpen());
+  RETURN_NOT_OK(transport_->PollFlightInfo(options, descriptor, &info));
+  return info;
+}
+
 arrow::Result<std::unique_ptr<SchemaResult>> FlightClient::GetSchema(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   RETURN_NOT_OK(CheckOpen());
diff --git a/cpp/src/arrow/flight/client.h b/cpp/src/arrow/flight/client.h
index cc1c35aaebed3..705b36c23cebe 100644
--- a/cpp/src/arrow/flight/client.h
+++ b/cpp/src/arrow/flight/client.h
@@ -296,6 +296,19 @@ class ARROW_FLIGHT_EXPORT FlightClient {
     return GetFlightInfoAsync({}, descriptor);
   }
 
+  /// \brief Request and poll a long running query
+  /// \param[in] options Per-RPC options
+  /// \param[in] descriptor the dataset request or a descriptor returned by a
+  /// prioir PollFlightInfo call
+  /// \return Arrow result with the PollInfo describing the status of
+  /// the requested query
+  arrow::Result<std::unique_ptr<PollInfo>> PollFlightInfo(
+      const FlightCallOptions& options, const FlightDescriptor& descriptor);
+  arrow::Result<std::unique_ptr<PollInfo>> PollFlightInfo(
+      const FlightDescriptor& descriptor) {
+    return PollFlightInfo({}, descriptor);
+  }
+
   /// \brief Request schema for a single flight, which may be an existing
   /// dataset or a command to be executed
   /// \param[in] options Per-RPC options
diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index 72a25018e8ee8..b32036a2c973f 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -64,9 +64,12 @@ void TestRoundtrip(const std::vector<FlightType>& values,
 
     ASSERT_OK_AND_ASSIGN(std::string serialized, values[i].SerializeToString());
     ASSERT_OK_AND_ASSIGN(auto deserialized, FlightType::Deserialize(serialized));
-    if constexpr (std::is_same_v<FlightType, FlightInfo>) {
+    if constexpr (std::is_same_v<FlightType, FlightInfo> ||
+                  std::is_same_v<FlightType, PollInfo>) {
+      ARROW_SCOPED_TRACE("Deserialized = ", deserialized->ToString());
       EXPECT_EQ(values[i], *deserialized);
     } else {
+      ARROW_SCOPED_TRACE("Deserialized = ", deserialized.ToString());
       EXPECT_EQ(values[i], deserialized);
     }
 
@@ -255,6 +258,38 @@ TEST(FlightTypes, FlightInfo) {
   ASSERT_NO_FATAL_FAILURE(TestRoundtrip<pb::FlightInfo>(values, reprs));
 }
 
+TEST(FlightTypes, PollInfo) {
+  ASSERT_OK_AND_ASSIGN(auto location, Location::ForGrpcTcp("localhost", 1234));
+  Schema schema({field("ints", int64())});
+  auto desc = FlightDescriptor::Command("foo");
+  auto endpoint = FlightEndpoint{Ticket{"foo"}, {}, std::nullopt};
+  auto info = MakeFlightInfo(schema, desc, {endpoint}, -1, 42, true);
+  // 2023-06-19 03:14:06.004330100
+  // We must use microsecond resolution here for portability.
+  // std::chrono::system_clock::time_point may not provide nanosecond
+  // resolution on some platforms such as Windows.
+  const auto expiration_time_duration =
+      std::chrono::seconds{1687144446} + std::chrono::nanoseconds{4339000};
+  Timestamp expiration_time(
+      std::chrono::duration_cast<Timestamp::duration>(expiration_time_duration));
+  std::vector<PollInfo> values = {
+      PollInfo{std::make_unique<FlightInfo>(info), std::nullopt, std::nullopt,
+               std::nullopt},
+      PollInfo{std::make_unique<FlightInfo>(info), FlightDescriptor::Command("poll"), 0.1,
+               expiration_time},
+  };
+  std::vector<std::string> reprs = {
+      "<PollInfo info=" + info.ToString() +
+          " descriptor=null "
+          "progress=null expiration_time=null>",
+      "<PollInfo info=" + info.ToString() +
+          " descriptor=<FlightDescriptor cmd='poll'> "
+          "progress=0.1 expiration_time=2023-06-19 03:14:06.004339000>",
+  };
+
+  ASSERT_NO_FATAL_FAILURE(TestRoundtrip<pb::PollInfo>(values, reprs));
+}
+
 TEST(FlightTypes, Result) {
   std::vector<Result> values = {
       {Buffer::FromString("")},
diff --git a/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc b/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
index d2f14fb01b0a8..4a49dea31b99d 100644
--- a/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
+++ b/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
@@ -71,6 +71,8 @@ TEST(FlightIntegration, ExpirationTimeRenewFlightEndpoint) {
   ASSERT_OK(RunScenario("expiration_time:renew_flight_endpoint"));
 }
 
+TEST(FlightIntegration, PollFlightInfo) { ASSERT_OK(RunScenario("poll_flight_info")); }
+
 TEST(FlightIntegration, FlightSql) { ASSERT_OK(RunScenario("flight_sql")); }
 
 TEST(FlightIntegration, FlightSqlExtension) {
diff --git a/cpp/src/arrow/flight/integration_tests/test_integration.cc b/cpp/src/arrow/flight/integration_tests/test_integration.cc
index e1d39ae5d7264..03e352ffa6770 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration.cc
@@ -708,9 +708,7 @@ class ExpirationTimeCancelFlightInfoScenario : public Scenario {
 
 /// \brief The expiration time scenario - RenewFlightEndpoint.
 ///
-/// This tests that the client can renew a FlightEndpoint and read
-/// data in renewed expiration time even when the original
-/// expiration time is over.
+/// This tests that the client can renew a FlightEndpoint.
 class ExpirationTimeRenewFlightEndpointScenario : public Scenario {
   Status MakeServer(std::unique_ptr<FlightServerBase>* server,
                     FlightServerOptions* options) override {
@@ -746,6 +744,77 @@ class ExpirationTimeRenewFlightEndpointScenario : public Scenario {
   }
 };
 
+/// \brief The server used for testing PollFlightInfo().
+class PollFlightInfoServer : public FlightServerBase {
+ public:
+  PollFlightInfoServer() : FlightServerBase() {}
+
+  Status PollFlightInfo(const ServerCallContext& context,
+                        const FlightDescriptor& descriptor,
+                        std::unique_ptr<PollInfo>* result) override {
+    auto schema = arrow::schema({arrow::field("number", arrow::uint32(), false)});
+    std::vector<FlightEndpoint> endpoints = {
+        FlightEndpoint{{"long-running query"}, {}, std::nullopt}};
+    ARROW_ASSIGN_OR_RAISE(
+        auto info, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false));
+    if (descriptor == FlightDescriptor::Command("poll")) {
+      *result = std::make_unique<PollInfo>(std::make_unique<FlightInfo>(std::move(info)),
+                                           std::nullopt, 1.0, std::nullopt);
+    } else {
+      *result =
+          std::make_unique<PollInfo>(std::make_unique<FlightInfo>(std::move(info)),
+                                     FlightDescriptor::Command("poll"), 0.1,
+                                     Timestamp::clock::now() + std::chrono::seconds{10});
+    }
+    return Status::OK();
+  }
+};
+
+/// \brief The PollFlightInfo scenario.
+///
+/// This tests that the client can poll a long-running query.
+class PollFlightInfoScenario : public Scenario {
+  Status MakeServer(std::unique_ptr<FlightServerBase>* server,
+                    FlightServerOptions* options) override {
+    *server = std::make_unique<PollFlightInfoServer>();
+    return Status::OK();
+  }
+
+  Status MakeClient(FlightClientOptions* options) override { return Status::OK(); }
+
+  Status RunClient(std::unique_ptr<FlightClient> client) override {
+    ARROW_ASSIGN_OR_RAISE(
+        auto info, client->PollFlightInfo(FlightDescriptor::Command("heavy query")));
+    if (!info->descriptor.has_value()) {
+      return Status::Invalid("Description is missing: ", info->ToString());
+    }
+    if (!info->progress.has_value()) {
+      return Status::Invalid("Progress is missing: ", info->ToString());
+    }
+    if (!(0.0 <= *info->progress && *info->progress <= 1.0)) {
+      return Status::Invalid("Invalid progress: ", info->ToString());
+    }
+    if (!info->expiration_time.has_value()) {
+      return Status::Invalid("Expiration time is missing: ", info->ToString());
+    }
+    ARROW_ASSIGN_OR_RAISE(info, client->PollFlightInfo(*info->descriptor));
+    if (info->descriptor.has_value()) {
+      return Status::Invalid("Retried but not finished yet: ", info->ToString());
+    }
+    if (!info->progress.has_value()) {
+      return Status::Invalid("Progress is missing in finished query: ", info->ToString());
+    }
+    if (fabs(*info->progress - 1.0) > arrow::kDefaultAbsoluteTolerance) {
+      return Status::Invalid("Progress for finished query isn't 1.0: ", info->ToString());
+    }
+    if (info->expiration_time.has_value()) {
+      return Status::Invalid("Expiration time must not be set for finished query: ",
+                             info->ToString());
+    }
+    return Status::OK();
+  }
+};
+
 /// \brief Schema to be returned for mocking the statement/prepared statement results.
 ///
 /// Must be the same across all languages.
@@ -1825,6 +1894,9 @@ Status GetScenario(const std::string& scenario_name, std::shared_ptr<Scenario>*
   } else if (scenario_name == "expiration_time:renew_flight_endpoint") {
     *out = std::make_shared<ExpirationTimeRenewFlightEndpointScenario>();
     return Status::OK();
+  } else if (scenario_name == "poll_flight_info") {
+    *out = std::make_shared<PollFlightInfoScenario>();
+    return Status::OK();
   } else if (scenario_name == "flight_sql") {
     *out = std::make_shared<FlightSqlScenario>();
     return Status::OK();
diff --git a/cpp/src/arrow/flight/middleware.h b/cpp/src/arrow/flight/middleware.h
index e936b9f02020c..84448097ff019 100644
--- a/cpp/src/arrow/flight/middleware.h
+++ b/cpp/src/arrow/flight/middleware.h
@@ -57,6 +57,7 @@ enum class FlightMethod : char {
   DoAction = 7,
   ListActions = 8,
   DoExchange = 9,
+  PollFlightInfo = 10,
 };
 
 /// \brief Get a human-readable name for a Flight method.
diff --git a/cpp/src/arrow/flight/serialization_internal.cc b/cpp/src/arrow/flight/serialization_internal.cc
index 5d09a1a04586c..f85b451dccec3 100644
--- a/cpp/src/arrow/flight/serialization_internal.cc
+++ b/cpp/src/arrow/flight/serialization_internal.cc
@@ -31,6 +31,26 @@ namespace arrow {
 namespace flight {
 namespace internal {
 
+// Timestamp
+
+Status FromProto(const google::protobuf::Timestamp& pb_timestamp, Timestamp* timestamp) {
+  const auto seconds = std::chrono::seconds{pb_timestamp.seconds()};
+  const auto nanoseconds = std::chrono::nanoseconds{pb_timestamp.nanos()};
+  const auto duration =
+      std::chrono::duration_cast<Timestamp::duration>(seconds + nanoseconds);
+  *timestamp = Timestamp(duration);
+  return Status::OK();
+}
+
+Status ToProto(const Timestamp& timestamp, google::protobuf::Timestamp* pb_timestamp) {
+  const auto since_epoch = timestamp.time_since_epoch();
+  const auto since_epoch_ns =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(since_epoch).count();
+  pb_timestamp->set_seconds(since_epoch_ns / std::nano::den);
+  pb_timestamp->set_nanos(since_epoch_ns % std::nano::den);
+  return Status::OK();
+}
+
 // ActionType
 
 Status FromProto(const pb::ActionType& pb_type, ActionType* type) {
@@ -153,13 +173,9 @@ Status FromProto(const pb::FlightEndpoint& pb_endpoint, FlightEndpoint* endpoint
     RETURN_NOT_OK(FromProto(pb_endpoint.location(i), &endpoint->locations[i]));
   }
   if (pb_endpoint.has_expiration_time()) {
-    const auto& pb_expiration_time = pb_endpoint.expiration_time();
-    const auto seconds = std::chrono::seconds{pb_expiration_time.seconds()};
-    const auto nanoseconds = std::chrono::nanoseconds{pb_expiration_time.nanos()};
-    const auto duration =
-        std::chrono::duration_cast<Timestamp::duration>(seconds + nanoseconds);
-    const Timestamp expiration_time(duration);
-    endpoint->expiration_time = expiration_time;
+    Timestamp expiration_time;
+    RETURN_NOT_OK(FromProto(pb_endpoint.expiration_time(), &expiration_time));
+    endpoint->expiration_time = std::move(expiration_time);
   }
   return Status::OK();
 }
@@ -171,13 +187,8 @@ Status ToProto(const FlightEndpoint& endpoint, pb::FlightEndpoint* pb_endpoint)
     RETURN_NOT_OK(ToProto(location, pb_endpoint->add_location()));
   }
   if (endpoint.expiration_time) {
-    const auto expiration_time = endpoint.expiration_time.value();
-    const auto since_epoch = expiration_time.time_since_epoch();
-    const auto since_epoch_ns =
-        std::chrono::duration_cast<std::chrono::nanoseconds>(since_epoch).count();
-    auto pb_expiration_time = pb_endpoint->mutable_expiration_time();
-    pb_expiration_time->set_seconds(since_epoch_ns / std::nano::den);
-    pb_expiration_time->set_nanos(since_epoch_ns % std::nano::den);
+    RETURN_NOT_OK(ToProto(endpoint.expiration_time.value(),
+                          pb_endpoint->mutable_expiration_time()));
   }
   return Status::OK();
 }
@@ -288,6 +299,47 @@ Status ToProto(const FlightInfo& info, pb::FlightInfo* pb_info) {
   return Status::OK();
 }
 
+// PollInfo
+
+Status FromProto(const pb::PollInfo& pb_info, PollInfo* info) {
+  ARROW_ASSIGN_OR_RAISE(auto flight_info, FromProto(pb_info.info()));
+  info->info = std::make_unique<FlightInfo>(std::move(flight_info));
+  if (pb_info.has_flight_descriptor()) {
+    FlightDescriptor descriptor;
+    RETURN_NOT_OK(FromProto(pb_info.flight_descriptor(), &descriptor));
+    info->descriptor = std::move(descriptor);
+  } else {
+    info->descriptor = std::nullopt;
+  }
+  if (pb_info.has_progress()) {
+    info->progress = pb_info.progress();
+  } else {
+    info->progress = std::nullopt;
+  }
+  if (pb_info.has_expiration_time()) {
+    Timestamp expiration_time;
+    RETURN_NOT_OK(FromProto(pb_info.expiration_time(), &expiration_time));
+    info->expiration_time = std::move(expiration_time);
+  } else {
+    info->expiration_time = std::nullopt;
+  }
+  return Status::OK();
+}
+
+Status ToProto(const PollInfo& info, pb::PollInfo* pb_info) {
+  RETURN_NOT_OK(ToProto(*info.info, pb_info->mutable_info()));
+  if (info.descriptor) {
+    RETURN_NOT_OK(ToProto(*info.descriptor, pb_info->mutable_flight_descriptor()));
+  }
+  if (info.progress) {
+    pb_info->set_progress(info.progress.value());
+  }
+  if (info.expiration_time) {
+    RETURN_NOT_OK(ToProto(*info.expiration_time, pb_info->mutable_expiration_time()));
+  }
+  return Status::OK();
+}
+
 // CancelFlightInfoRequest
 
 Status FromProto(const pb::CancelFlightInfoRequest& pb_request,
diff --git a/cpp/src/arrow/flight/serialization_internal.h b/cpp/src/arrow/flight/serialization_internal.h
index 30eb0b31819b8..1ac7de83d1308 100644
--- a/cpp/src/arrow/flight/serialization_internal.h
+++ b/cpp/src/arrow/flight/serialization_internal.h
@@ -45,6 +45,7 @@ Status SchemaToString(const Schema& schema, std::string* out);
 
 // These functions depend on protobuf types which are not exported in the Flight DLL.
 
+Status FromProto(const google::protobuf::Timestamp& pb_timestamp, Timestamp* timestamp);
 Status FromProto(const pb::ActionType& pb_type, ActionType* type);
 Status FromProto(const pb::Action& pb_action, Action* action);
 Status FromProto(const pb::Result& pb_result, Result* result);
@@ -60,16 +61,19 @@ Status FromProto(const pb::FlightEndpoint& pb_endpoint, FlightEndpoint* endpoint
 Status FromProto(const pb::RenewFlightEndpointRequest& pb_request,
                  RenewFlightEndpointRequest* request);
 arrow::Result<FlightInfo> FromProto(const pb::FlightInfo& pb_info);
+Status FromProto(const pb::PollInfo& pb_info, PollInfo* info);
 Status FromProto(const pb::CancelFlightInfoRequest& pb_request,
                  CancelFlightInfoRequest* request);
 Status FromProto(const pb::SchemaResult& pb_result, std::string* result);
 Status FromProto(const pb::BasicAuth& pb_basic_auth, BasicAuth* info);
 
+Status ToProto(const Timestamp& timestamp, google::protobuf::Timestamp* pb_timestamp);
 Status ToProto(const FlightDescriptor& descr, pb::FlightDescriptor* pb_descr);
 Status ToProto(const FlightEndpoint& endpoint, pb::FlightEndpoint* pb_endpoint);
 Status ToProto(const RenewFlightEndpointRequest& request,
                pb::RenewFlightEndpointRequest* pb_request);
 Status ToProto(const FlightInfo& info, pb::FlightInfo* pb_info);
+Status ToProto(const PollInfo& info, pb::PollInfo* pb_info);
 Status ToProto(const CancelFlightInfoRequest& request,
                pb::CancelFlightInfoRequest* pb_request);
 Status ToProto(const ActionType& type, pb::ActionType* pb_type);
diff --git a/cpp/src/arrow/flight/server.cc b/cpp/src/arrow/flight/server.cc
index 66185cfeba5e5..06512bda36a49 100644
--- a/cpp/src/arrow/flight/server.cc
+++ b/cpp/src/arrow/flight/server.cc
@@ -231,6 +231,12 @@ Status FlightServerBase::GetFlightInfo(const ServerCallContext& context,
   return Status::NotImplemented("NYI");
 }
 
+Status FlightServerBase::PollFlightInfo(const ServerCallContext& context,
+                                        const FlightDescriptor& request,
+                                        std::unique_ptr<PollInfo>* info) {
+  return Status::NotImplemented("NYI");
+}
+
 Status FlightServerBase::DoGet(const ServerCallContext& context, const Ticket& request,
                                std::unique_ptr<FlightDataStream>* data_stream) {
   return Status::NotImplemented("NYI");
diff --git a/cpp/src/arrow/flight/server.h b/cpp/src/arrow/flight/server.h
index 049c6cee3ffcf..6eba90c53a754 100644
--- a/cpp/src/arrow/flight/server.h
+++ b/cpp/src/arrow/flight/server.h
@@ -252,16 +252,26 @@ class ARROW_FLIGHT_EXPORT FlightServerBase {
   /// \brief Retrieve the schema and an access plan for the indicated
   /// descriptor
   /// \param[in] context The call context.
-  /// \param[in] request may be null
+  /// \param[in] request the dataset request, whether a named dataset or command
   /// \param[out] info the returned flight info provider
   /// \return Status
   virtual Status GetFlightInfo(const ServerCallContext& context,
                                const FlightDescriptor& request,
                                std::unique_ptr<FlightInfo>* info);
 
+  /// \brief Retrieve the current status of the target query
+  /// \param[in] context The call context.
+  /// \param[in] request the dataset request or a descriptor returned by a
+  /// prioir PollFlightInfo call
+  /// \param[out] info the returned retry info provider
+  /// \return Status
+  virtual Status PollFlightInfo(const ServerCallContext& context,
+                                const FlightDescriptor& request,
+                                std::unique_ptr<PollInfo>* info);
+
   /// \brief Retrieve the schema for the indicated descriptor
   /// \param[in] context The call context.
-  /// \param[in] request may be null
+  /// \param[in] request the dataset request, whether a named dataset or command
   /// \param[out] schema the returned flight schema provider
   /// \return Status
   virtual Status GetSchema(const ServerCallContext& context,
diff --git a/cpp/src/arrow/flight/transport.cc b/cpp/src/arrow/flight/transport.cc
index 88228f2503597..fd74b6d95a59e 100644
--- a/cpp/src/arrow/flight/transport.cc
+++ b/cpp/src/arrow/flight/transport.cc
@@ -80,6 +80,11 @@ void ClientTransport::GetFlightInfoAsync(
     std::shared_ptr<AsyncListener<FlightInfo>> listener) {
   listener->OnFinish(Status::NotImplemented("Async GetFlightInfo for this transport"));
 }
+Status ClientTransport::PollFlightInfo(const FlightCallOptions& options,
+                                       const FlightDescriptor& descriptor,
+                                       std::unique_ptr<PollInfo>* info) {
+  return Status::NotImplemented("PollFlightInfo for this transport");
+}
 arrow::Result<std::unique_ptr<SchemaResult>> ClientTransport::GetSchema(
     const FlightCallOptions& options, const FlightDescriptor& descriptor) {
   return Status::NotImplemented("GetSchema for this transport");
diff --git a/cpp/src/arrow/flight/transport.h b/cpp/src/arrow/flight/transport.h
index 69605d2112f1f..8cb2479d113fc 100644
--- a/cpp/src/arrow/flight/transport.h
+++ b/cpp/src/arrow/flight/transport.h
@@ -187,6 +187,9 @@ class ARROW_FLIGHT_EXPORT ClientTransport {
   virtual void GetFlightInfoAsync(const FlightCallOptions& options,
                                   const FlightDescriptor& descriptor,
                                   std::shared_ptr<AsyncListener<FlightInfo>> listener);
+  virtual Status PollFlightInfo(const FlightCallOptions& options,
+                                const FlightDescriptor& descriptor,
+                                std::unique_ptr<PollInfo>* info);
   virtual arrow::Result<std::unique_ptr<SchemaResult>> GetSchema(
       const FlightCallOptions& options, const FlightDescriptor& descriptor);
   virtual Status ListFlights(const FlightCallOptions& options, const Criteria& criteria,
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
index 7108f35549998..5baf687cd83dc 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
@@ -179,6 +179,8 @@ class GrpcClientInterceptorAdapterFactory
       flight_method = FlightMethod::ListFlights;
     } else if (EndsWith(method, "/GetFlightInfo")) {
       flight_method = FlightMethod::GetFlightInfo;
+    } else if (EndsWith(method, "/PollFlightInfo")) {
+      flight_method = FlightMethod::PollFlightInfo;
     } else if (EndsWith(method, "/GetSchema")) {
       flight_method = FlightMethod::GetSchema;
     } else if (EndsWith(method, "/DoGet")) {
@@ -942,6 +944,25 @@ class GrpcClientImpl : public internal::ClientTransport {
     return Status::OK();
   }
 
+  Status PollFlightInfo(const FlightCallOptions& options,
+                        const FlightDescriptor& descriptor,
+                        std::unique_ptr<PollInfo>* info) override {
+    pb::FlightDescriptor pb_descriptor;
+    pb::PollInfo pb_response;
+
+    RETURN_NOT_OK(internal::ToProto(descriptor, &pb_descriptor));
+
+    ClientRpc rpc(options);
+    RETURN_NOT_OK(rpc.SetToken(auth_handler_.get()));
+    Status s = FromGrpcStatus(
+        stub_->PollFlightInfo(&rpc.context, pb_descriptor, &pb_response), &rpc.context);
+    RETURN_NOT_OK(s);
+
+    info->reset(new PollInfo());
+    RETURN_NOT_OK(internal::FromProto(pb_response, info->get()));
+    return Status::OK();
+  }
+
   arrow::Result<std::unique_ptr<SchemaResult>> GetSchema(
       const FlightCallOptions& options, const FlightDescriptor& descriptor) override {
     pb::FlightDescriptor pb_descriptor;
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
index 50d4ffe002c7e..28c2090c95a9a 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
@@ -412,6 +412,32 @@ class GrpcServiceHandler final : public FlightService::Service {
     RETURN_WITH_MIDDLEWARE(flight_context, ::grpc::Status::OK);
   }
 
+  ::grpc::Status PollFlightInfo(ServerContext* context,
+                                const pb::FlightDescriptor* request,
+                                pb::PollInfo* response) {
+    GrpcServerCallContext flight_context(context);
+    GRPC_RETURN_NOT_GRPC_OK(
+        CheckAuth(FlightMethod::PollFlightInfo, context, flight_context));
+
+    CHECK_ARG_NOT_NULL(flight_context, request, "FlightDescriptor cannot be null");
+
+    FlightDescriptor descr;
+    SERVICE_RETURN_NOT_OK(flight_context, internal::FromProto(*request, &descr));
+
+    std::unique_ptr<PollInfo> info;
+    SERVICE_RETURN_NOT_OK(flight_context,
+                          impl_->base()->PollFlightInfo(flight_context, descr, &info));
+
+    if (!info) {
+      // Treat null listing as no flights available
+      RETURN_WITH_MIDDLEWARE(flight_context, ::grpc::Status(::grpc::StatusCode::NOT_FOUND,
+                                                            "Flight not found"));
+    }
+
+    SERVICE_RETURN_NOT_OK(flight_context, internal::ToProto(*info, response));
+    RETURN_WITH_MIDDLEWARE(flight_context, ::grpc::Status::OK);
+  }
+
   ::grpc::Status GetSchema(ServerContext* context, const pb::FlightDescriptor* request,
                            pb::SchemaResult* response) {
     GrpcServerCallContext flight_context(context);
diff --git a/cpp/src/arrow/flight/transport/ucx/ucx_client.cc b/cpp/src/arrow/flight/transport/ucx/ucx_client.cc
index d11adb54adf93..cd9ddaa85a6f6 100644
--- a/cpp/src/arrow/flight/transport/ucx/ucx_client.cc
+++ b/cpp/src/arrow/flight/transport/ucx/ucx_client.cc
@@ -600,6 +600,38 @@ class UcxClientImpl : public arrow::flight::internal::ClientTransport {
     return MergeStatuses(std::move(status), ReturnConnection(std::move(connection)));
   }
 
+  Status PollFlightInfo(const FlightCallOptions& options,
+                        const FlightDescriptor& descriptor,
+                        std::unique_ptr<PollInfo>* info) override {
+    ARROW_ASSIGN_OR_RAISE(auto connection, CheckoutConnection(options));
+    UcpCallDriver* driver = connection.driver();
+
+    auto impl = [&]() {
+      RETURN_NOT_OK(driver->StartCall(kMethodPollFlightInfo));
+
+      ARROW_ASSIGN_OR_RAISE(std::string payload, descriptor.SerializeToString());
+
+      RETURN_NOT_OK(driver->SendFrame(FrameType::kBuffer,
+                                      reinterpret_cast<const uint8_t*>(payload.data()),
+                                      static_cast<int64_t>(payload.size())));
+
+      ARROW_ASSIGN_OR_RAISE(auto incoming_message, driver->ReadNextFrame());
+      if (incoming_message->type == FrameType::kBuffer) {
+        ARROW_ASSIGN_OR_RAISE(
+            *info, PollInfo::Deserialize(std::string_view(*incoming_message->buffer)));
+        ARROW_ASSIGN_OR_RAISE(incoming_message, driver->ReadNextFrame());
+      }
+      RETURN_NOT_OK(driver->ExpectFrameType(*incoming_message, FrameType::kHeaders));
+      ARROW_ASSIGN_OR_RAISE(auto headers,
+                            HeadersFrame::Parse(std::move(incoming_message->buffer)));
+      Status status;
+      RETURN_NOT_OK(headers.GetStatus(&status));
+      return status;
+    };
+    auto status = impl();
+    return MergeStatuses(std::move(status), ReturnConnection(std::move(connection)));
+  }
+
   Status DoExchange(const FlightCallOptions& options,
                     std::unique_ptr<internal::ClientDataStream>* out) override {
     ARROW_ASSIGN_OR_RAISE(auto connection, CheckoutConnection(options));
diff --git a/cpp/src/arrow/flight/transport/ucx/ucx_internal.h b/cpp/src/arrow/flight/transport/ucx/ucx_internal.h
index d14296db097b4..c46f81eb7498b 100644
--- a/cpp/src/arrow/flight/transport/ucx/ucx_internal.h
+++ b/cpp/src/arrow/flight/transport/ucx/ucx_internal.h
@@ -49,6 +49,7 @@ static constexpr char kMethodDoExchange[] = "DoExchange";
 static constexpr char kMethodDoGet[] = "DoGet";
 static constexpr char kMethodDoPut[] = "DoPut";
 static constexpr char kMethodGetFlightInfo[] = "GetFlightInfo";
+static constexpr char kMethodPollFlightInfo[] = "PollFlightInfo";
 
 /// The header encoding the transport status.
 static constexpr char kHeaderStatus[] = "flight-status";
diff --git a/cpp/src/arrow/flight/transport/ucx/ucx_server.cc b/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
index 8bbac34705c23..b20f8f286e3bc 100644
--- a/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
+++ b/cpp/src/arrow/flight/transport/ucx/ucx_server.cc
@@ -385,6 +385,27 @@ class UcxServerImpl : public arrow::flight::internal::ServerTransport {
     return Status::OK();
   }
 
+  Status HandlePollFlightInfo(UcpCallDriver* driver) {
+    UcxServerCallContext context;
+
+    ARROW_ASSIGN_OR_RAISE(auto frame, driver->ReadNextFrame());
+    SERVER_RETURN_NOT_OK(driver, driver->ExpectFrameType(*frame, FrameType::kBuffer));
+    FlightDescriptor descriptor;
+    SERVER_RETURN_NOT_OK(driver,
+                         FlightDescriptor::Deserialize(std::string_view(*frame->buffer))
+                             .Value(&descriptor));
+
+    std::unique_ptr<PollInfo> info;
+    std::string response;
+    SERVER_RETURN_NOT_OK(driver, base_->PollFlightInfo(context, descriptor, &info));
+    SERVER_RETURN_NOT_OK(driver, info->SerializeToString().Value(&response));
+    RETURN_NOT_OK(driver->SendFrame(FrameType::kBuffer,
+                                    reinterpret_cast<const uint8_t*>(response.data()),
+                                    static_cast<int64_t>(response.size())));
+    RETURN_NOT_OK(SendStatus(driver, Status::OK()));
+    return Status::OK();
+  }
+
   Status HandleDoGet(UcpCallDriver* driver) {
     UcxServerCallContext context;
 
@@ -431,6 +452,8 @@ class UcxServerImpl : public arrow::flight::internal::ServerTransport {
     ARROW_ASSIGN_OR_RAISE(auto method, headers.Get(":method:"));
     if (method == kMethodGetFlightInfo) {
       return HandleGetFlightInfo(driver);
+    } else if (method == kMethodPollFlightInfo) {
+      return HandlePollFlightInfo(driver);
     } else if (method == kMethodDoExchange) {
       return HandleDoExchange(driver);
     } else if (method == kMethodDoGet) {
diff --git a/cpp/src/arrow/flight/type_fwd.h b/cpp/src/arrow/flight/type_fwd.h
index ac2effbc91d96..2f22bbea36dbb 100644
--- a/cpp/src/arrow/flight/type_fwd.h
+++ b/cpp/src/arrow/flight/type_fwd.h
@@ -38,6 +38,7 @@ struct FlightClientOptions;
 struct FlightDescriptor;
 struct FlightEndpoint;
 class FlightInfo;
+class PollInfo;
 class FlightListing;
 class FlightMetadataReader;
 class FlightMetadataWriter;
diff --git a/cpp/src/arrow/flight/types.cc b/cpp/src/arrow/flight/types.cc
index b7cd55325b1f4..8395919e4daeb 100644
--- a/cpp/src/arrow/flight/types.cc
+++ b/cpp/src/arrow/flight/types.cc
@@ -339,6 +339,92 @@ bool FlightInfo::Equals(const FlightInfo& other) const {
          data_.ordered == other.data_.ordered;
 }
 
+arrow::Result<std::string> PollInfo::SerializeToString() const {
+  pb::PollInfo pb_info;
+  RETURN_NOT_OK(internal::ToProto(*this, &pb_info));
+
+  std::string out;
+  if (!pb_info.SerializeToString(&out)) {
+    return Status::IOError("Serialized PollInfo exceeded 2 GiB limit");
+  }
+  return out;
+}
+
+arrow::Result<std::unique_ptr<PollInfo>> PollInfo::Deserialize(
+    std::string_view serialized) {
+  pb::PollInfo pb_info;
+  if (serialized.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
+    return Status::Invalid("Serialized PollInfo size should not exceed 2 GiB");
+  }
+  google::protobuf::io::ArrayInputStream input(serialized.data(),
+                                               static_cast<int>(serialized.size()));
+  if (!pb_info.ParseFromZeroCopyStream(&input)) {
+    return Status::Invalid("Not a valid PollInfo");
+  }
+  PollInfo info;
+  RETURN_NOT_OK(internal::FromProto(pb_info, &info));
+  return std::make_unique<PollInfo>(std::move(info));
+}
+
+std::string PollInfo::ToString() const {
+  std::stringstream ss;
+  ss << "<PollInfo info=" << info->ToString();
+  ss << " descriptor=";
+  if (descriptor) {
+    ss << descriptor->ToString();
+  } else {
+    ss << "null";
+  }
+  ss << " progress=";
+  if (progress) {
+    ss << progress.value();
+  } else {
+    ss << "null";
+  }
+  ss << " expiration_time=";
+  if (expiration_time) {
+    auto type = timestamp(TimeUnit::NANO);
+    arrow::internal::StringFormatter<TimestampType> formatter(type.get());
+    auto expiration_timestamp = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                                    expiration_time->time_since_epoch())
+                                    .count();
+    formatter(expiration_timestamp,
+              [&ss](std::string_view formatted) { ss << formatted; });
+  } else {
+    ss << "null";
+  }
+  ss << '>';
+  return ss.str();
+}
+
+bool PollInfo::Equals(const PollInfo& other) const {
+  if ((info.get() != nullptr) != (other.info.get() != nullptr)) {
+    return false;
+  }
+  if (info && *info != *other.info) {
+    return false;
+  }
+  if (descriptor.has_value() != other.descriptor.has_value()) {
+    return false;
+  }
+  if (descriptor && *descriptor != *other.descriptor) {
+    return false;
+  }
+  if (progress.has_value() != other.progress.has_value()) {
+    return false;
+  }
+  if (progress && fabs(*progress - *other.progress) > arrow::kDefaultAbsoluteTolerance) {
+    return false;
+  }
+  if (expiration_time.has_value() != other.expiration_time.has_value()) {
+    return false;
+  }
+  if (expiration_time && *expiration_time != *other.expiration_time) {
+    return false;
+  }
+  return true;
+}
+
 std::string CancelFlightInfoRequest::ToString() const {
   std::stringstream ss;
   ss << "<CancelFlightInfoRequest info=" << info->ToString() << ">";
diff --git a/cpp/src/arrow/flight/types.h b/cpp/src/arrow/flight/types.h
index c5d72d5167271..70e7c90676b73 100644
--- a/cpp/src/arrow/flight/types.h
+++ b/cpp/src/arrow/flight/types.h
@@ -654,6 +654,71 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
   mutable bool reconstructed_schema_;
 };
 
+/// \brief The information to process a long-running query.
+class ARROW_FLIGHT_EXPORT PollInfo {
+ public:
+  /// The currently available results so far.
+  std::unique_ptr<FlightInfo> info = NULLPTR;
+  /// The descriptor the client should use on the next try. If unset,
+  /// the query is complete.
+  std::optional<FlightDescriptor> descriptor = std::nullopt;
+  /// Query progress. Must be in [0.0, 1.0] but need not be
+  /// monotonic or nondecreasing. If unknown, do not set.
+  std::optional<double> progress = std::nullopt;
+  /// Expiration time for this request. After this passes, the server
+  /// might not accept the poll descriptor anymore (and the query may
+  /// be cancelled). This may be updated on a call to PollFlightInfo.
+  std::optional<Timestamp> expiration_time = std::nullopt;
+
+  PollInfo()
+      : info(NULLPTR),
+        descriptor(std::nullopt),
+        progress(std::nullopt),
+        expiration_time(std::nullopt) {}
+
+  explicit PollInfo(std::unique_ptr<FlightInfo> info,
+                    std::optional<FlightDescriptor> descriptor,
+                    std::optional<double> progress,
+                    std::optional<Timestamp> expiration_time)
+      : info(std::move(info)),
+        descriptor(std::move(descriptor)),
+        progress(progress),
+        expiration_time(expiration_time) {}
+
+  explicit PollInfo(const PollInfo& other)
+      : info(other.info ? std::make_unique<FlightInfo>(*other.info) : NULLPTR),
+        descriptor(other.descriptor),
+        progress(other.progress),
+        expiration_time(other.expiration_time) {}
+
+  /// \brief Get the wire-format representation of this type.
+  ///
+  /// Useful when interoperating with non-Flight systems (e.g. REST
+  /// services) that may want to return Flight types.
+  arrow::Result<std::string> SerializeToString() const;
+
+  /// \brief Parse the wire-format representation of this type.
+  ///
+  /// Useful when interoperating with non-Flight systems (e.g. REST
+  /// services) that may want to return Flight types.
+  static arrow::Result<std::unique_ptr<PollInfo>> Deserialize(
+      std::string_view serialized);
+
+  std::string ToString() const;
+
+  /// Compare two PollInfo for equality. This will compare the
+  /// serialized schema representations, NOT the logical equality of
+  /// the schemas.
+  bool Equals(const PollInfo& other) const;
+
+  friend bool operator==(const PollInfo& left, const PollInfo& right) {
+    return left.Equals(right);
+  }
+  friend bool operator!=(const PollInfo& left, const PollInfo& right) {
+    return !(left == right);
+  }
+};
+
 /// \brief The request of the CancelFlightInfoRequest action.
 struct ARROW_FLIGHT_EXPORT CancelFlightInfoRequest {
   std::unique_ptr<FlightInfo> info;
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index af092b92e89a8..966da84e655b2 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -460,6 +460,11 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
                          "RenewFlightEndpoint are working as expected."),
             skip={"JS", "C#", "Rust"},
         ),
+        Scenario(
+            "poll_flight_info",
+            description="Ensure PollFlightInfo is supported.",
+            skip={"JS", "C#", "Rust"}
+        ),
         Scenario(
             "flight_sql",
             description="Ensure Flight SQL protocol is working as expected.",
diff --git a/docs/source/format/Flight.rst b/docs/source/format/Flight.rst
index 97818a2e17bf7..bea1c8f5e51de 100644
--- a/docs/source/format/Flight.rst
+++ b/docs/source/format/Flight.rst
@@ -153,6 +153,70 @@ A client that wishes to download the data would:
 
 .. _google.protobuf.Timestamp: https://protobuf.dev/reference/protobuf/google.protobuf/#timestamp
 
+Downloading Data by Running a Heavy Query
+-----------------------------------------
+
+A client may need to request a heavy query to download
+data. However, ``GetFlightInfo`` doesn't return until the query
+completes, so the client is blocked. In this situation, the client
+can use ``PollFlightInfo`` instead of ``GetFlightInfo``:
+
+.. figure:: ./Flight/PollFlightInfo.mmd.svg
+
+   Polling a long-running query by ``PollFlightInfo``.
+
+#. Construct or acquire a ``FlightDescriptor``, as before.
+#. Call ``PollFlightInfo(FlightDescriptor)`` to get a ``PollInfo``
+   message.
+
+   A server should respond as quickly as possible on the first
+   call. So the client shouldn't wait for the first ``PollInfo``
+   response.
+
+   If the query isn't finished, ``PollInfo.flight_descriptor`` has a
+   ``FlightDescriptor``. The client should use the descriptor (not the
+   original ``FlightDescriptor``) to call the next
+   ``PollFlightInfo()``.  A server should recognize a
+   ``PollInfo.flight_descriptor`` that is not necessarily the latest
+   in case the client misses an update in between.
+
+   If the query is finished, ``PollInfo.flight_descriptor`` is
+   unset.
+
+   ``PollInfo.info`` is the currently available results so far. It's
+   a complete ``FlightInfo`` each time not just the delta between the
+   previous and current ``FlightInfo``. A server should only append to
+   the endpoints in ``PollInfo.info`` each time. So the client can
+   run ``DoGet(Ticket)`` with the ``Ticket`` in the ``PollInfo.info``
+   even when the query isn't finished yet. ``FlightInfo.ordered`` is
+   also valid.
+
+   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.
+
+   ``PollInfo.progress`` may be set. It represents progress of the
+   query. If it's set, the value must be in ``[0.0, 1.0]``. The value
+   is not necessarily monotonic or nondecreasing. A server may respond by
+   only updating the ``PollInfo.progress`` value, though it shouldn't
+   spam the client with updates.
+
+   ``PollInfo.timestamp`` is the expiration time for this
+   request. After this passes, a server might not accept the poll
+   descriptor anymore and the query may be cancelled. This may be
+   updated on a call to ``PollFlightInfo``. The expiration time is
+   represented as `google.protobuf.Timestamp`_.
+
+   A client may be able to cancel the query by the
+   ``CancelFlightInfo`` action.
+
+   A server should return an error status instead of a response if the
+   query fails. The client should not poll the request except for
+   ``TIMED_OUT`` and ``UNAVAILABLE``, which may not originate from the
+   server.
+#. Consume each endpoint returned by the server, as before.
+
 Uploading Data
 --------------
 
diff --git a/docs/source/format/Flight/PollFlightInfo.mmd b/docs/source/format/Flight/PollFlightInfo.mmd
new file mode 100644
index 0000000000000..5a643654c0c41
--- /dev/null
+++ b/docs/source/format/Flight/PollFlightInfo.mmd
@@ -0,0 +1,38 @@
+%% Licensed to the Apache Software Foundation (ASF) under one
+%% or more contributor license agreements.  See the NOTICE file
+%% distributed with this work for additional information
+%% regarding copyright ownership.  The ASF licenses this file
+%% to you under the Apache License, Version 2.0 (the
+%% "License"); you may not use this file except in compliance
+%% with the License.  You may obtain a copy of the License at
+%%
+%%   http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing,
+%% software distributed under the License is distributed on an
+%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+%% KIND, either express or implied.  See the License for the
+%% specific language governing permissions and limitations
+%% under the License.
+
+%% To generate the diagram, use mermaid-cli
+%% Example: docker run --rm -v $(pwd):/data minlag/mermaid-cli -i /data/PollFlightInfo.mmd
+
+sequenceDiagram
+autonumber
+
+participant Client
+participant Metadata Server
+participant Data Server
+Client->>Metadata Server: PollFlightInfo(FlightDescriptor)
+Metadata Server->>Client: RetryInfo{descriptor: FlightDescriptor', ...}
+Client->>Metadata Server: PollFlightInfo(FlightDescriptor')
+Metadata Server->>Client: RetryInfo{descriptor: FlightDescriptor'', ...}
+Client->>Metadata Server: PollFlightInfo(FlightDescriptor'')
+Metadata Server->>Client: RetryInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}
+Note over Client, Data Server: This may be parallelized
+Note over Client, Data Server: Some endpoints may be processed while polling
+loop for each endpoint in FlightInfo.endpoints
+    Client->>Data Server: DoGet(Ticket)
+    Data Server->>Client: stream of FlightData
+end
diff --git a/docs/source/format/Flight/PollFlightInfo.mmd.svg b/docs/source/format/Flight/PollFlightInfo.mmd.svg
new file mode 100644
index 0000000000000..d7b62f180aa85
--- /dev/null
+++ b/docs/source/format/Flight/PollFlightInfo.mmd.svg
@@ -0,0 +1 @@
+<svg aria-roledescription="sequence" role="graphics-document document" viewBox="-50 -10 1125.5 688" style="max-width: 1125.5px; background-color: white;" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" width="100%" id="mermaid-1690782830274"><style>#mermaid-1690782830274{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-1690782830274 .error-icon{fill:#552222;}#mermaid-1690782830274 .error-text{fill:#552222;stroke:#552222;}#mermaid-1690782830274 .edge-thickness-normal{stroke-width:2px;}#mermaid-1690782830274 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-1690782830274 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-1690782830274 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-1690782830274 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-1690782830274 .marker{fill:#333333;stroke:#333333;}#mermaid-1690782830274 .marker.cross{stroke:#333333;}#mermaid-1690782830274 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-1690782830274 .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 text.actor&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .actor-line{stroke:grey;}#mermaid-1690782830274 .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-1690782830274 .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-1690782830274 #arrowhead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .sequenceNumber{fill:white;}#mermaid-1690782830274 #sequencenumber{fill:#333;}#mermaid-1690782830274 #crosshead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .messageText{fill:#333;stroke:none;}#mermaid-1690782830274 .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .labelText,#mermaid-1690782830274 .labelText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopText,#mermaid-1690782830274 .loopText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-1690782830274 .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-1690782830274 .noteText,#mermaid-1690782830274 .noteText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .actorPopupMenu{position:absolute;}#mermaid-1690782830274 .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-1690782830274 .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .actor-man circle,#mermaid-1690782830274 line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-1690782830274 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g/><defs><symbol height="24" width="24" id="computer"><path d="M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z" transform="scale(.5)"/></symbol></defs><defs><symbol clip-rule="evenodd" fill-rule="evenodd" id="database"><path d="M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z" transform="scale(.5)"/></symbol></defs><defs><symbol height="24" width="24" id="clock"><path d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z" transform="scale(.5)"/></symbol></defs><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="75" y1="5" x1="75" id="actor0"/><g id="root-0"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="736" y1="5" x1="736" id="actor1"/><g id="root-1"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="950.5" y1="5" x1="950.5" id="actor2"/><g id="root-2"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></g><defs><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="9" id="arrowhead"><path d="M 0 0 L 10 5 L 0 10 z"/></marker></defs><defs><marker refY="5" refX="4" orient="auto" markerHeight="8" markerWidth="15" id="crosshead"><path style="stroke-dasharray: 0, 0;" d="M 1,2 L 6,7 M 6,2 L 1,7" stroke-width="1pt" stroke="#000000" fill="none"/></marker></defs><defs><marker orient="auto" markerHeight="28" markerWidth="20" refY="7" refX="18" id="filled-head"><path d="M 18,7 L9,13 L14,7 L9,1 Z"/></marker></defs><defs><marker orient="auto" markerHeight="40" markerWidth="60" refY="15" refX="15" id="sequencenumber"><circle r="6" cy="15" cx="15"/></marker></defs><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="351" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="356" x="513"><tspan x="513">This may be parallelized</tspan></text></g><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="398" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="403" x="513"><tspan x="513">Some endpoints may be processed while polling</tspan></text></g><g><line class="loopLine" y2="445" x2="960.5" y1="445" x1="65"/><line class="loopLine" y2="582" x2="960.5" y1="445" x1="960.5"/><line class="loopLine" y2="582" x2="960.5" y1="582" x1="65"/><line class="loopLine" y2="582" x2="65" y1="445" x1="65"/><polygon class="labelBox" points="65,445 115,445 115,458 106.6,465 65,465"/><text style="font-size: 16px; font-weight: 400;" class="labelText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="458" x="90">loop</text><text style="font-size: 16px; font-weight: 400;" class="loopText" text-anchor="middle" y="463" x="537.75"><tspan x="537.75">[for each endpoint in FlightInfo.endpoints]</tspan></text></g><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="80" x="406">PollFlightInfo(FlightDescriptor)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="111" x2="736" y1="111" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="115" x="75">1</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="126" x="406">RetryInfo{descriptor: FlightDescriptor', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="157" x2="75" y1="157" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="161" x="736">2</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="172" x="406">PollFlightInfo(FlightDescriptor')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="203" x2="736" y1="203" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="207" x="75">3</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="218" x="406">RetryInfo{descriptor: FlightDescriptor'', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="249" x2="75" y1="249" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="253" x="736">4</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="264" x="406">PollFlightInfo(FlightDescriptor'')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="295" x2="736" y1="295" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="299" x="75">5</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="310" x="406">RetryInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="341" x2="75" y1="341" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="345" x="736">6</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="495" x="513">DoGet(Ticket)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="526" x2="950.5" y1="526" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="530" x="75">7</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="541" x="513">stream of FlightData</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="572" x2="75" y1="572" x1="950.5"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="576" x="950.5">8</text><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></svg>
\ No newline at end of file
diff --git a/format/Flight.proto b/format/Flight.proto
index b5d23f6f7e6d2..baf2733d81048 100644
--- a/format/Flight.proto
+++ b/format/Flight.proto
@@ -65,6 +65,32 @@ service FlightService {
    */
   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
@@ -116,7 +142,6 @@ service FlightService {
    * understand the capabilities of the flight service.
    */
   rpc ListActions(Empty) returns (stream ActionType) {}
-
 }
 
 /*
@@ -343,6 +368,50 @@ message FlightInfo {
   bool ordered = 6;
 }
 
+/*
+ * 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.
  */
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index 1532ef5f32f54..fdc08a247f9ff 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -87,6 +87,11 @@ func (m *FlightServiceClientMock) GetFlightInfo(ctx context.Context, in *flight.
 	return args.Get(0).(*flight.FlightInfo), args.Error(1)
 }
 
+func (m *FlightServiceClientMock) PollFlightInfo(ctx context.Context, in *flight.FlightDescriptor, opts ...grpc.CallOption) (*flight.PollInfo, error) {
+	args := m.Called(in.Type, in.Cmd, opts)
+	return args.Get(0).(*flight.PollInfo), args.Error(1)
+}
+
 func (m *FlightServiceClientMock) GetSchema(ctx context.Context, in *flight.FlightDescriptor, opts ...grpc.CallOption) (*flight.SchemaResult, error) {
 	panic("not implemented") // TODO: Implement
 }
diff --git a/go/arrow/flight/gen/flight/Flight.pb.go b/go/arrow/flight/gen/flight/Flight.pb.go
index f91d762014603..861b37d90d088 100644
--- a/go/arrow/flight/gen/flight/Flight.pb.go
+++ b/go/arrow/flight/gen/flight/Flight.pb.go
@@ -18,15 +18,15 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.12.4
+// 	protoc        v3.21.12
 // source: Flight.proto
 
 package flight
 
 import (
-	timestamp "github.com/golang/protobuf/ptypes/timestamp"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
 	reflect "reflect"
 	sync "sync"
 )
@@ -38,7 +38,6 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-//
 // The result of a cancel operation.
 //
 // This is used by CancelFlightInfoResult.status.
@@ -103,19 +102,17 @@ func (CancelStatus) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{0}
 }
 
-//
 // Describes what type of descriptor is defined.
 type FlightDescriptor_DescriptorType int32
 
 const (
 	// Protobuf pattern, not used.
 	FlightDescriptor_UNKNOWN FlightDescriptor_DescriptorType = 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.
-	FlightDescriptor_PATH FlightDescriptor_DescriptorType = 1
 	//
+	//	similar to a path inside a filesystem.
+	FlightDescriptor_PATH FlightDescriptor_DescriptorType = 1
 	// An opaque command to generate a dataset.
 	FlightDescriptor_CMD FlightDescriptor_DescriptorType = 2
 )
@@ -161,17 +158,14 @@ func (FlightDescriptor_DescriptorType) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{12, 0}
 }
 
-//
 // The request that a client provides to a server on handshake.
 type HandshakeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
-	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -227,10 +221,8 @@ type HandshakeResponse struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
-	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -281,7 +273,6 @@ func (x *HandshakeResponse) GetPayload() []byte {
 	return nil
 }
 
-//
 // A message for doing simple auth.
 type BasicAuth struct {
 	state         protoimpl.MessageState
@@ -376,7 +367,6 @@ func (*Empty) Descriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{3}
 }
 
-//
 // Describes an available action, including both the name used for execution
 // along with a short description of the purpose of the action.
 type ActionType struct {
@@ -434,7 +424,6 @@ func (x *ActionType) GetDescription() string {
 	return ""
 }
 
-//
 // A service specific expression that can be used to return a limited set
 // of available Arrow Flight streams.
 type Criteria struct {
@@ -484,7 +473,6 @@ func (x *Criteria) GetExpression() []byte {
 	return nil
 }
 
-//
 // An opaque action specific for the service.
 type Action struct {
 	state         protoimpl.MessageState
@@ -541,7 +529,6 @@ func (x *Action) GetBody() []byte {
 	return nil
 }
 
-//
 // The request of the CancelFlightInfo action.
 //
 // The request should be stored in Action.body.
@@ -592,7 +579,6 @@ func (x *CancelFlightInfoRequest) GetInfo() *FlightInfo {
 	return nil
 }
 
-//
 // The request of the RenewFlightEndpoint action.
 //
 // The request should be stored in Action.body.
@@ -643,7 +629,6 @@ func (x *RenewFlightEndpointRequest) GetEndpoint() *FlightEndpoint {
 	return nil
 }
 
-//
 // An opaque result returned after executing an action.
 type Result struct {
 	state         protoimpl.MessageState
@@ -692,7 +677,6 @@ func (x *Result) GetBody() []byte {
 	return nil
 }
 
-//
 // The result of the CancelFlightInfo action.
 //
 // The result should be stored in Result.body.
@@ -743,7 +727,6 @@ func (x *CancelFlightInfoResult) GetStatus() CancelStatus {
 	return CancelStatus_CANCEL_STATUS_UNSPECIFIED
 }
 
-//
 // Wrap the result of a getSchema call
 type SchemaResult struct {
 	state         protoimpl.MessageState
@@ -751,9 +734,10 @@ type SchemaResult struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
+	//
+	//	4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//	4 bytes - the byte length of the payload
+	//	a flatbuffer Message whose header is the Schema
 	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
 }
 
@@ -796,7 +780,6 @@ func (x *SchemaResult) GetSchema() []byte {
 	return nil
 }
 
-//
 // 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.
 type FlightDescriptor struct {
@@ -805,11 +788,9 @@ type FlightDescriptor struct {
 	unknownFields protoimpl.UnknownFields
 
 	Type FlightDescriptor_DescriptorType `protobuf:"varint,1,opt,name=type,proto3,enum=arrow.flight.protocol.FlightDescriptor_DescriptorType" json:"type,omitempty"`
-	//
 	// Opaque value used to express a command. Should only be defined when
 	// type = CMD.
 	Cmd []byte `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
-	//
 	// List of strings identifying a particular dataset. Should only be defined
 	// when type = PATH.
 	Path []string `protobuf:"bytes,3,rep,name=path,proto3" json:"path,omitempty"`
@@ -868,7 +849,6 @@ func (x *FlightDescriptor) GetPath() []string {
 	return nil
 }
 
-//
 // The access coordinates for retrieval of a dataset. With a FlightInfo, a
 // consumer is able to determine how to retrieve a dataset.
 type FlightInfo struct {
@@ -877,14 +857,13 @@ type FlightInfo struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
-	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
 	//
+	//	4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//	4 bytes - the byte length of the payload
+	//	a flatbuffer Message whose header is the Schema
+	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
 	// The descriptor associated with this info.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,2,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
-	//
 	// 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.
@@ -904,14 +883,13 @@ type FlightInfo struct {
 	// 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.
+	//   - An application requires that all clients must read data in
+	//     returned endpoints order.
+	//   - An application must return the all data in a single endpoint.
 	Endpoint []*FlightEndpoint `protobuf:"bytes,3,rep,name=endpoint,proto3" json:"endpoint,omitempty"`
 	// Set these to -1 if unknown.
 	TotalRecords int64 `protobuf:"varint,4,opt,name=total_records,json=totalRecords,proto3" json:"total_records,omitempty"`
 	TotalBytes   int64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`
-	//
 	// FlightEndpoints are in the same order as the data.
 	Ordered bool `protobuf:"varint,6,opt,name=ordered,proto3" json:"ordered,omitempty"`
 }
@@ -990,17 +968,109 @@ func (x *FlightInfo) GetOrdered() bool {
 	return false
 }
 
-//
+// The information to process a long-running query.
+type PollInfo struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// 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.
+	Info *FlightInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
+	// The descriptor the client should use on the next try.
+	// If unset, the query is complete.
+	FlightDescriptor *FlightDescriptor `protobuf:"bytes,2,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	// Query progress. If known, must be in [0.0, 1.0] but need not be
+	// monotonic or nondecreasing. If unknown, do not set.
+	Progress *float64 `protobuf:"fixed64,3,opt,name=progress,proto3,oneof" json:"progress,omitempty"`
+	// 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.
+	ExpirationTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
+}
+
+func (x *PollInfo) Reset() {
+	*x = PollInfo{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_Flight_proto_msgTypes[14]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *PollInfo) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*PollInfo) ProtoMessage() {}
+
+func (x *PollInfo) ProtoReflect() protoreflect.Message {
+	mi := &file_Flight_proto_msgTypes[14]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use PollInfo.ProtoReflect.Descriptor instead.
+func (*PollInfo) Descriptor() ([]byte, []int) {
+	return file_Flight_proto_rawDescGZIP(), []int{14}
+}
+
+func (x *PollInfo) GetInfo() *FlightInfo {
+	if x != nil {
+		return x.Info
+	}
+	return nil
+}
+
+func (x *PollInfo) GetFlightDescriptor() *FlightDescriptor {
+	if x != nil {
+		return x.FlightDescriptor
+	}
+	return nil
+}
+
+func (x *PollInfo) GetProgress() float64 {
+	if x != nil && x.Progress != nil {
+		return *x.Progress
+	}
+	return 0
+}
+
+func (x *PollInfo) GetExpirationTime() *timestamppb.Timestamp {
+	if x != nil {
+		return x.ExpirationTime
+	}
+	return nil
+}
+
 // A particular stream or split associated with a flight.
 type FlightEndpoint struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// Token used to retrieve this stream.
 	Ticket *Ticket `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
-	//
 	// 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
@@ -1016,17 +1086,16 @@ type FlightEndpoint struct {
 	// In other words, an application can use multiple locations to
 	// represent redundant and/or load balanced services.
 	Location []*Location `protobuf:"bytes,2,rep,name=location,proto3" json:"location,omitempty"`
-	//
 	// 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.
-	ExpirationTime *timestamp.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
+	ExpirationTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
 }
 
 func (x *FlightEndpoint) Reset() {
 	*x = FlightEndpoint{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_Flight_proto_msgTypes[14]
+		mi := &file_Flight_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1039,7 +1108,7 @@ func (x *FlightEndpoint) String() string {
 func (*FlightEndpoint) ProtoMessage() {}
 
 func (x *FlightEndpoint) ProtoReflect() protoreflect.Message {
-	mi := &file_Flight_proto_msgTypes[14]
+	mi := &file_Flight_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1052,7 +1121,7 @@ func (x *FlightEndpoint) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use FlightEndpoint.ProtoReflect.Descriptor instead.
 func (*FlightEndpoint) Descriptor() ([]byte, []int) {
-	return file_Flight_proto_rawDescGZIP(), []int{14}
+	return file_Flight_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *FlightEndpoint) GetTicket() *Ticket {
@@ -1069,14 +1138,13 @@ func (x *FlightEndpoint) GetLocation() []*Location {
 	return nil
 }
 
-func (x *FlightEndpoint) GetExpirationTime() *timestamp.Timestamp {
+func (x *FlightEndpoint) GetExpirationTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.ExpirationTime
 	}
 	return nil
 }
 
-//
 // A location where a Flight service will accept retrieval of a particular
 // stream given a ticket.
 type Location struct {
@@ -1090,7 +1158,7 @@ type Location struct {
 func (x *Location) Reset() {
 	*x = Location{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_Flight_proto_msgTypes[15]
+		mi := &file_Flight_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1103,7 +1171,7 @@ func (x *Location) String() string {
 func (*Location) ProtoMessage() {}
 
 func (x *Location) ProtoReflect() protoreflect.Message {
-	mi := &file_Flight_proto_msgTypes[15]
+	mi := &file_Flight_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1116,7 +1184,7 @@ func (x *Location) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Location.ProtoReflect.Descriptor instead.
 func (*Location) Descriptor() ([]byte, []int) {
-	return file_Flight_proto_rawDescGZIP(), []int{15}
+	return file_Flight_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *Location) GetUri() string {
@@ -1126,7 +1194,6 @@ func (x *Location) GetUri() string {
 	return ""
 }
 
-//
 // An opaque identifier that the service can use to retrieve a particular
 // portion of a stream.
 //
@@ -1143,7 +1210,7 @@ type Ticket struct {
 func (x *Ticket) Reset() {
 	*x = Ticket{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_Flight_proto_msgTypes[16]
+		mi := &file_Flight_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1156,7 +1223,7 @@ func (x *Ticket) String() string {
 func (*Ticket) ProtoMessage() {}
 
 func (x *Ticket) ProtoReflect() protoreflect.Message {
-	mi := &file_Flight_proto_msgTypes[16]
+	mi := &file_Flight_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1169,7 +1236,7 @@ func (x *Ticket) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use Ticket.ProtoReflect.Descriptor instead.
 func (*Ticket) Descriptor() ([]byte, []int) {
-	return file_Flight_proto_rawDescGZIP(), []int{16}
+	return file_Flight_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *Ticket) GetTicket() []byte {
@@ -1179,24 +1246,19 @@ func (x *Ticket) GetTicket() []byte {
 	return nil
 }
 
-//
 // A batch of Arrow data as part of a stream of batches.
 type FlightData struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// The descriptor of the data. This is only relevant when a client is
 	// starting a new DoPut stream.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,1,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
-	//
 	// Header for message data as described in Message.fbs::Message.
 	DataHeader []byte `protobuf:"bytes,2,opt,name=data_header,json=dataHeader,proto3" json:"data_header,omitempty"`
-	//
 	// Application-defined metadata.
 	AppMetadata []byte `protobuf:"bytes,3,opt,name=app_metadata,json=appMetadata,proto3" json:"app_metadata,omitempty"`
-	//
 	// 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
@@ -1207,7 +1269,7 @@ type FlightData struct {
 func (x *FlightData) Reset() {
 	*x = FlightData{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_Flight_proto_msgTypes[17]
+		mi := &file_Flight_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1220,7 +1282,7 @@ func (x *FlightData) String() string {
 func (*FlightData) ProtoMessage() {}
 
 func (x *FlightData) ProtoReflect() protoreflect.Message {
-	mi := &file_Flight_proto_msgTypes[17]
+	mi := &file_Flight_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1233,7 +1295,7 @@ func (x *FlightData) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use FlightData.ProtoReflect.Descriptor instead.
 func (*FlightData) Descriptor() ([]byte, []int) {
-	return file_Flight_proto_rawDescGZIP(), []int{17}
+	return file_Flight_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *FlightData) GetFlightDescriptor() *FlightDescriptor {
@@ -1264,7 +1326,7 @@ func (x *FlightData) GetDataBody() []byte {
 	return nil
 }
 
-//*
+// *
 // The response message associated with the submission of a DoPut.
 type PutResult struct {
 	state         protoimpl.MessageState
@@ -1277,7 +1339,7 @@ type PutResult struct {
 func (x *PutResult) Reset() {
 	*x = PutResult{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_Flight_proto_msgTypes[18]
+		mi := &file_Flight_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1290,7 +1352,7 @@ func (x *PutResult) String() string {
 func (*PutResult) ProtoMessage() {}
 
 func (x *PutResult) ProtoReflect() protoreflect.Message {
-	mi := &file_Flight_proto_msgTypes[18]
+	mi := &file_Flight_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1303,7 +1365,7 @@ func (x *PutResult) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PutResult.ProtoReflect.Descriptor instead.
 func (*PutResult) Descriptor() ([]byte, []int) {
-	return file_Flight_proto_rawDescGZIP(), []int{18}
+	return file_Flight_proto_rawDescGZIP(), []int{19}
 }
 
 func (x *PutResult) GetAppMetadata() []byte {
@@ -1397,106 +1459,129 @@ var file_Flight_proto_rawDesc = []byte{
 	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f,
 	0x74, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x72, 0x64, 0x65,
 	0x72, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72,
-	0x65, 0x64, 0x22, 0xc9, 0x01, 0x0a, 0x0e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x45, 0x6e, 0x64,
-	0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c,
-	0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69,
-	0x63, 0x6b, 0x65, 0x74, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x3b, 0x0a, 0x08,
-	0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f,
-	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78, 0x70,
-	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0e,
-	0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x1c,
-	0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72,
-	0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x22, 0x20, 0x0a, 0x06,
-	0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x22, 0xc4,
-	0x01, 0x0a, 0x0a, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x54, 0x0a,
-	0x11, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
-	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
-	0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f,
-	0x72, 0x52, 0x10, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
-	0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x48, 0x65,
-	0x61, 0x64, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d,
-	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f,
-	0x62, 0x6f, 0x64, 0x79, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x64, 0x61, 0x74,
-	0x61, 0x42, 0x6f, 0x64, 0x79, 0x22, 0x2e, 0x0a, 0x09, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x75,
-	0x6c, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74,
-	0x61, 0x64, 0x61, 0x74, 0x61, 0x2a, 0x8b, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c,
-	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c,
-	0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46,
-	0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f,
-	0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x45, 0x44,
-	0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41,
-	0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x02,
-	0x12, 0x21, 0x0a, 0x1d, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55,
-	0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x41, 0x42, 0x4c,
-	0x45, 0x10, 0x03, 0x32, 0xa7, 0x06, 0x0a, 0x0d, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x53, 0x65,
-	0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61,
-	0x6b, 0x65, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73,
-	0x68, 0x61, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x72,
-	0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x55, 0x0a, 0x0b, 0x4c,
-	0x69, 0x73, 0x74, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x72, 0x72,
-	0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x6f, 0x6c, 0x2e, 0x43, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x1a, 0x21, 0x2e, 0x61, 0x72,
+	0x65, 0x64, 0x22, 0x8a, 0x02, 0x0a, 0x08, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12,
+	0x35, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e,
+	0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
+	0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x66, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x08,
+	0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00,
+	0x52, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x88, 0x01, 0x01, 0x12, 0x43, 0x0a,
+	0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
+	0x6d, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69,
+	0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22,
+	0xc9, 0x01, 0x0a, 0x0e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69,
+	0x6e, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65,
+	0x74, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x3b, 0x0a, 0x08, 0x6c, 0x6f, 0x63,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x72,
 	0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00,
-	0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49,
-	0x6e, 0x66, 0x6f, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67,
-	0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67,
-	0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x21, 0x2e, 0x61,
-	0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22,
-	0x00, 0x12, 0x5b, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x27,
-	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73,
-	0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x23, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
-	0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x12, 0x4d,
-	0x0a, 0x05, 0x44, 0x6f, 0x47, 0x65, 0x74, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
-	0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a,
-	0x05, 0x44, 0x6f, 0x50, 0x75, 0x74, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x20, 0x2e, 0x61, 0x72, 0x72, 0x6f,
-	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
-	0x6c, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x28, 0x01, 0x30,
-	0x01, 0x12, 0x58, 0x0a, 0x0a, 0x44, 0x6f, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12,
-	0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61,
-	0x74, 0x61, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x4c, 0x0a, 0x08, 0x44,
-	0x6f, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
+	0x63, 0x6f, 0x6c, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f,
+	0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x1c, 0x0a, 0x08, 0x4c,
+	0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x22, 0x20, 0x0a, 0x06, 0x54, 0x69, 0x63,
+	0x6b, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x22, 0xc4, 0x01, 0x0a, 0x0a,
+	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
+	0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65,
+	0x72, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+	0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74, 0x61,
+	0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x62, 0x6f, 0x64,
+	0x79, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61, 0x42, 0x6f,
+	0x64, 0x79, 0x22, 0x2e, 0x0a, 0x09, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12,
+	0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x2a, 0x8b, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x53, 0x74, 0x61,
+	0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54,
+	0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44,
+	0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41,
+	0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12,
+	0x1c, 0x0a, 0x18, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53,
+	0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x21, 0x0a,
+	0x1d, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x4e,
+	0x4f, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03,
+	0x32, 0x85, 0x07, 0x0a, 0x0d, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69,
+	0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12,
+	0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
+	0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x55, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74,
+	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
 	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
-	0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x52,
-	0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x0b, 0x4c, 0x69, 0x73,
-	0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1c, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x43, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
 	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
-	0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
-	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x41,
-	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0x76, 0x0a,
-	0x1c, 0x6f, 0x72, 0x67, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x61, 0x72, 0x72, 0x6f,
-	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x37, 0x67,
-	0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65,
-	0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f, 0x67, 0x6f, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0xaa, 0x02, 0x1c, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e,
-	0x41, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x50, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x30, 0x01, 0x12,
+	0x5d, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
+	0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f,
+	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
+	0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x12, 0x5c,
+	0x0a, 0x0e, 0x50, 0x6f, 0x6c, 0x6c, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
+	0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44,
+	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x1f, 0x2e, 0x61, 0x72, 0x72, 0x6f,
+	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
+	0x6c, 0x2e, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x09,
+	0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f,
+	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
+	0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+	0x6f, 0x72, 0x1a, 0x23, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d,
+	0x61, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x12, 0x4d, 0x0a, 0x05, 0x44, 0x6f, 0x47,
+	0x65, 0x74, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65,
+	0x74, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x05, 0x44, 0x6f, 0x50, 0x75,
+	0x74, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x44, 0x61, 0x74, 0x61, 0x1a, 0x20, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x50, 0x75, 0x74,
+	0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x58, 0x0a, 0x0a,
+	0x44, 0x6f, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72,
+	0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x21, 0x2e,
+	0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61,
+	0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x4c, 0x0a, 0x08, 0x44, 0x6f, 0x41, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f,
+	0x6e, 0x1a, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
+	0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69,
+	0x6f, 0x6e, 0x73, 0x12, 0x1c, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+	0x54, 0x79, 0x70, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0x71, 0x0a, 0x1c, 0x6f, 0x72, 0x67, 0x2e,
+	0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
+	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2f, 0x61, 0x72, 0x72, 0x6f,
+	0x77, 0x2f, 0x67, 0x6f, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0xaa, 0x02, 0x1c, 0x41,
+	0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x41, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x46, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1512,7 +1597,7 @@ func file_Flight_proto_rawDescGZIP() []byte {
 }
 
 var file_Flight_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_Flight_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
+var file_Flight_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
 var file_Flight_proto_goTypes = []interface{}{
 	(CancelStatus)(0),                    // 0: arrow.flight.protocol.CancelStatus
 	(FlightDescriptor_DescriptorType)(0), // 1: arrow.flight.protocol.FlightDescriptor.DescriptorType
@@ -1530,47 +1615,53 @@ var file_Flight_proto_goTypes = []interface{}{
 	(*SchemaResult)(nil),                 // 13: arrow.flight.protocol.SchemaResult
 	(*FlightDescriptor)(nil),             // 14: arrow.flight.protocol.FlightDescriptor
 	(*FlightInfo)(nil),                   // 15: arrow.flight.protocol.FlightInfo
-	(*FlightEndpoint)(nil),               // 16: arrow.flight.protocol.FlightEndpoint
-	(*Location)(nil),                     // 17: arrow.flight.protocol.Location
-	(*Ticket)(nil),                       // 18: arrow.flight.protocol.Ticket
-	(*FlightData)(nil),                   // 19: arrow.flight.protocol.FlightData
-	(*PutResult)(nil),                    // 20: arrow.flight.protocol.PutResult
-	(*timestamp.Timestamp)(nil),          // 21: google.protobuf.Timestamp
+	(*PollInfo)(nil),                     // 16: arrow.flight.protocol.PollInfo
+	(*FlightEndpoint)(nil),               // 17: arrow.flight.protocol.FlightEndpoint
+	(*Location)(nil),                     // 18: arrow.flight.protocol.Location
+	(*Ticket)(nil),                       // 19: arrow.flight.protocol.Ticket
+	(*FlightData)(nil),                   // 20: arrow.flight.protocol.FlightData
+	(*PutResult)(nil),                    // 21: arrow.flight.protocol.PutResult
+	(*timestamppb.Timestamp)(nil),        // 22: google.protobuf.Timestamp
 }
 var file_Flight_proto_depIdxs = []int32{
 	15, // 0: arrow.flight.protocol.CancelFlightInfoRequest.info:type_name -> arrow.flight.protocol.FlightInfo
-	16, // 1: arrow.flight.protocol.RenewFlightEndpointRequest.endpoint:type_name -> arrow.flight.protocol.FlightEndpoint
+	17, // 1: arrow.flight.protocol.RenewFlightEndpointRequest.endpoint:type_name -> arrow.flight.protocol.FlightEndpoint
 	0,  // 2: arrow.flight.protocol.CancelFlightInfoResult.status:type_name -> arrow.flight.protocol.CancelStatus
 	1,  // 3: arrow.flight.protocol.FlightDescriptor.type:type_name -> arrow.flight.protocol.FlightDescriptor.DescriptorType
 	14, // 4: arrow.flight.protocol.FlightInfo.flight_descriptor:type_name -> arrow.flight.protocol.FlightDescriptor
-	16, // 5: arrow.flight.protocol.FlightInfo.endpoint:type_name -> arrow.flight.protocol.FlightEndpoint
-	18, // 6: arrow.flight.protocol.FlightEndpoint.ticket:type_name -> arrow.flight.protocol.Ticket
-	17, // 7: arrow.flight.protocol.FlightEndpoint.location:type_name -> arrow.flight.protocol.Location
-	21, // 8: arrow.flight.protocol.FlightEndpoint.expiration_time:type_name -> google.protobuf.Timestamp
-	14, // 9: arrow.flight.protocol.FlightData.flight_descriptor:type_name -> arrow.flight.protocol.FlightDescriptor
-	2,  // 10: arrow.flight.protocol.FlightService.Handshake:input_type -> arrow.flight.protocol.HandshakeRequest
-	7,  // 11: arrow.flight.protocol.FlightService.ListFlights:input_type -> arrow.flight.protocol.Criteria
-	14, // 12: arrow.flight.protocol.FlightService.GetFlightInfo:input_type -> arrow.flight.protocol.FlightDescriptor
-	14, // 13: arrow.flight.protocol.FlightService.GetSchema:input_type -> arrow.flight.protocol.FlightDescriptor
-	18, // 14: arrow.flight.protocol.FlightService.DoGet:input_type -> arrow.flight.protocol.Ticket
-	19, // 15: arrow.flight.protocol.FlightService.DoPut:input_type -> arrow.flight.protocol.FlightData
-	19, // 16: arrow.flight.protocol.FlightService.DoExchange:input_type -> arrow.flight.protocol.FlightData
-	8,  // 17: arrow.flight.protocol.FlightService.DoAction:input_type -> arrow.flight.protocol.Action
-	5,  // 18: arrow.flight.protocol.FlightService.ListActions:input_type -> arrow.flight.protocol.Empty
-	3,  // 19: arrow.flight.protocol.FlightService.Handshake:output_type -> arrow.flight.protocol.HandshakeResponse
-	15, // 20: arrow.flight.protocol.FlightService.ListFlights:output_type -> arrow.flight.protocol.FlightInfo
-	15, // 21: arrow.flight.protocol.FlightService.GetFlightInfo:output_type -> arrow.flight.protocol.FlightInfo
-	13, // 22: arrow.flight.protocol.FlightService.GetSchema:output_type -> arrow.flight.protocol.SchemaResult
-	19, // 23: arrow.flight.protocol.FlightService.DoGet:output_type -> arrow.flight.protocol.FlightData
-	20, // 24: arrow.flight.protocol.FlightService.DoPut:output_type -> arrow.flight.protocol.PutResult
-	19, // 25: arrow.flight.protocol.FlightService.DoExchange:output_type -> arrow.flight.protocol.FlightData
-	11, // 26: arrow.flight.protocol.FlightService.DoAction:output_type -> arrow.flight.protocol.Result
-	6,  // 27: arrow.flight.protocol.FlightService.ListActions:output_type -> arrow.flight.protocol.ActionType
-	19, // [19:28] is the sub-list for method output_type
-	10, // [10:19] is the sub-list for method input_type
-	10, // [10:10] is the sub-list for extension type_name
-	10, // [10:10] is the sub-list for extension extendee
-	0,  // [0:10] is the sub-list for field type_name
+	17, // 5: arrow.flight.protocol.FlightInfo.endpoint:type_name -> arrow.flight.protocol.FlightEndpoint
+	15, // 6: arrow.flight.protocol.PollInfo.info:type_name -> arrow.flight.protocol.FlightInfo
+	14, // 7: arrow.flight.protocol.PollInfo.flight_descriptor:type_name -> arrow.flight.protocol.FlightDescriptor
+	22, // 8: arrow.flight.protocol.PollInfo.expiration_time:type_name -> google.protobuf.Timestamp
+	19, // 9: arrow.flight.protocol.FlightEndpoint.ticket:type_name -> arrow.flight.protocol.Ticket
+	18, // 10: arrow.flight.protocol.FlightEndpoint.location:type_name -> arrow.flight.protocol.Location
+	22, // 11: arrow.flight.protocol.FlightEndpoint.expiration_time:type_name -> google.protobuf.Timestamp
+	14, // 12: arrow.flight.protocol.FlightData.flight_descriptor:type_name -> arrow.flight.protocol.FlightDescriptor
+	2,  // 13: arrow.flight.protocol.FlightService.Handshake:input_type -> arrow.flight.protocol.HandshakeRequest
+	7,  // 14: arrow.flight.protocol.FlightService.ListFlights:input_type -> arrow.flight.protocol.Criteria
+	14, // 15: arrow.flight.protocol.FlightService.GetFlightInfo:input_type -> arrow.flight.protocol.FlightDescriptor
+	14, // 16: arrow.flight.protocol.FlightService.PollFlightInfo:input_type -> arrow.flight.protocol.FlightDescriptor
+	14, // 17: arrow.flight.protocol.FlightService.GetSchema:input_type -> arrow.flight.protocol.FlightDescriptor
+	19, // 18: arrow.flight.protocol.FlightService.DoGet:input_type -> arrow.flight.protocol.Ticket
+	20, // 19: arrow.flight.protocol.FlightService.DoPut:input_type -> arrow.flight.protocol.FlightData
+	20, // 20: arrow.flight.protocol.FlightService.DoExchange:input_type -> arrow.flight.protocol.FlightData
+	8,  // 21: arrow.flight.protocol.FlightService.DoAction:input_type -> arrow.flight.protocol.Action
+	5,  // 22: arrow.flight.protocol.FlightService.ListActions:input_type -> arrow.flight.protocol.Empty
+	3,  // 23: arrow.flight.protocol.FlightService.Handshake:output_type -> arrow.flight.protocol.HandshakeResponse
+	15, // 24: arrow.flight.protocol.FlightService.ListFlights:output_type -> arrow.flight.protocol.FlightInfo
+	15, // 25: arrow.flight.protocol.FlightService.GetFlightInfo:output_type -> arrow.flight.protocol.FlightInfo
+	16, // 26: arrow.flight.protocol.FlightService.PollFlightInfo:output_type -> arrow.flight.protocol.PollInfo
+	13, // 27: arrow.flight.protocol.FlightService.GetSchema:output_type -> arrow.flight.protocol.SchemaResult
+	20, // 28: arrow.flight.protocol.FlightService.DoGet:output_type -> arrow.flight.protocol.FlightData
+	21, // 29: arrow.flight.protocol.FlightService.DoPut:output_type -> arrow.flight.protocol.PutResult
+	20, // 30: arrow.flight.protocol.FlightService.DoExchange:output_type -> arrow.flight.protocol.FlightData
+	11, // 31: arrow.flight.protocol.FlightService.DoAction:output_type -> arrow.flight.protocol.Result
+	6,  // 32: arrow.flight.protocol.FlightService.ListActions:output_type -> arrow.flight.protocol.ActionType
+	23, // [23:33] is the sub-list for method output_type
+	13, // [13:23] is the sub-list for method input_type
+	13, // [13:13] is the sub-list for extension type_name
+	13, // [13:13] is the sub-list for extension extendee
+	0,  // [0:13] is the sub-list for field type_name
 }
 
 func init() { file_Flight_proto_init() }
@@ -1748,7 +1839,7 @@ func file_Flight_proto_init() {
 			}
 		}
 		file_Flight_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FlightEndpoint); i {
+			switch v := v.(*PollInfo); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1760,7 +1851,7 @@ func file_Flight_proto_init() {
 			}
 		}
 		file_Flight_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Location); i {
+			switch v := v.(*FlightEndpoint); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1772,7 +1863,7 @@ func file_Flight_proto_init() {
 			}
 		}
 		file_Flight_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*Ticket); i {
+			switch v := v.(*Location); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1784,7 +1875,7 @@ func file_Flight_proto_init() {
 			}
 		}
 		file_Flight_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*FlightData); i {
+			switch v := v.(*Ticket); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1796,6 +1887,18 @@ func file_Flight_proto_init() {
 			}
 		}
 		file_Flight_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FlightData); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_Flight_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PutResult); i {
 			case 0:
 				return &v.state
@@ -1808,13 +1911,14 @@ func file_Flight_proto_init() {
 			}
 		}
 	}
+	file_Flight_proto_msgTypes[14].OneofWrappers = []interface{}{}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_Flight_proto_rawDesc,
 			NumEnums:      2,
-			NumMessages:   19,
+			NumMessages:   20,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/go/arrow/flight/gen/flight/FlightSql.pb.go b/go/arrow/flight/gen/flight/FlightSql.pb.go
index 3b1ba232d3d12..95faa719a9488 100644
--- a/go/arrow/flight/gen/flight/FlightSql.pb.go
+++ b/go/arrow/flight/gen/flight/FlightSql.pb.go
@@ -18,15 +18,15 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.12.4
+// 	protoc        v3.21.12
 // source: FlightSql.proto
 
 package flight
 
 import (
-	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	descriptorpb "google.golang.org/protobuf/types/descriptorpb"
 	reflect "reflect"
 	sync "sync"
 )
@@ -48,33 +48,27 @@ const (
 	SqlInfo_FLIGHT_SQL_SERVER_VERSION SqlInfo = 1
 	// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
 	SqlInfo_FLIGHT_SQL_SERVER_ARROW_VERSION SqlInfo = 2
-	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
 	//
 	// Returns:
 	// - false: if read-write
 	// - true: if read only
 	SqlInfo_FLIGHT_SQL_SERVER_READ_ONLY SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_SQL SqlInfo = 4
-	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
 	// Substrait plans.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT SqlInfo = 5
-	//
 	// Retrieves a string value indicating the minimum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION SqlInfo = 6
-	//
 	// Retrieves a string value indicating the maximum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION SqlInfo = 7
-	//
 	// Retrieves an int32 indicating whether the Flight SQL Server supports the
 	// BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
 	//
@@ -84,61 +78,51 @@ const (
 	//
 	// The possible values are listed in `SqlSupportedTransaction`.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION SqlInfo = 8
-	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
 	// query cancellation (the CancelQuery action).
 	SqlInfo_FLIGHT_SQL_SERVER_CANCEL SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT SqlInfo = 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.
 	SqlInfo_SQL_DDL_CATALOG SqlInfo = 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.
 	SqlInfo_SQL_DDL_SCHEMA SqlInfo = 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.
 	SqlInfo_SQL_DDL_TABLE SqlInfo = 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`.
 	SqlInfo_SQL_IDENTIFIER_CASE SqlInfo = 503
 	// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
 	SqlInfo_SQL_IDENTIFIER_QUOTE_CHAR SqlInfo = 504
-	//
 	// Retrieves a int32 describing the case sensitivity of quoted identifiers.
 	//
 	// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
 	SqlInfo_SQL_QUOTED_IDENTIFIER_CASE SqlInfo = 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.
 	SqlInfo_SQL_ALL_TABLES_ARE_SELECTABLE SqlInfo = 506
-	//
 	// Retrieves the null ordering.
 	//
 	// Returns a int32 ordinal for the null ordering being used, as described in
@@ -154,18 +138,15 @@ const (
 	SqlInfo_SQL_SYSTEM_FUNCTIONS SqlInfo = 511
 	// Retrieves a UTF-8 string list with values of the supported datetime functions.
 	SqlInfo_SQL_DATETIME_FUNCTIONS SqlInfo = 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.
 	SqlInfo_SQL_SEARCH_STRING_ESCAPE SqlInfo = 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 _).
 	SqlInfo_SQL_EXTRA_NAME_CHARACTERS SqlInfo = 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.
@@ -174,7 +155,6 @@ const (
 	// - false: if column aliasing is unsupported;
 	// - true: if column aliasing is supported.
 	SqlInfo_SQL_SUPPORTS_COLUMN_ALIASING SqlInfo = 515
-	//
 	// Retrieves a boolean value indicating whether concatenations between null and non-null values being
 	// null are supported.
 	//
@@ -182,13 +162,11 @@ const (
 	// - 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.
 	SqlInfo_SQL_NULL_PLUS_NULL_IS_NULL SqlInfo = 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>>
 	SqlInfo_SQL_SUPPORTS_CONVERT SqlInfo = 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.
 	//
@@ -196,7 +174,6 @@ const (
 	// - false: if table correlation names are unsupported;
 	// - true: if table correlation names are supported.
 	SqlInfo_SQL_SUPPORTS_TABLE_CORRELATION_NAMES SqlInfo = 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.
 	//
@@ -204,14 +181,12 @@ const (
 	// - false: if different table correlation names are unsupported;
 	// - true: if different table correlation names are supported
 	SqlInfo_SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES SqlInfo = 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;
 	SqlInfo_SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY SqlInfo = 520
-	//
 	// Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
 	// clause is supported.
 	//
@@ -219,7 +194,6 @@ const (
 	// - 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.
 	SqlInfo_SQL_SUPPORTS_ORDER_BY_UNRELATED SqlInfo = 521
-	//
 	// Retrieves the supported GROUP BY commands;
 	//
 	// Returns an int32 bitmask value representing the supported commands.
@@ -232,21 +206,18 @@ const (
 	// - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
 	// Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
 	SqlInfo_SQL_SUPPORTED_GROUP_BY SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_NON_NULLABLE_COLUMNS SqlInfo = 524
-	//
 	// Retrieves the supported SQL grammar level as per the ODBC specification.
 	//
 	// Returns an int32 bitmask value representing the supported SQL grammar level.
@@ -263,7 +234,6 @@ const (
 	// - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
 	// Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
 	SqlInfo_SQL_SUPPORTED_GRAMMAR SqlInfo = 525
-	//
 	// Retrieves the supported ANSI92 SQL grammar level.
 	//
 	// Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
@@ -280,14 +250,12 @@ const (
 	// - 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`.
 	SqlInfo_SQL_ANSI92_SUPPORTED_LEVEL SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY SqlInfo = 527
-	//
 	// Retrieves the support level for SQL OUTER JOINs.
 	//
 	// Returns a int32 ordinal for the SQL ordering being used, as described in
@@ -297,17 +265,14 @@ const (
 	SqlInfo_SQL_SCHEMA_TERM SqlInfo = 529
 	// Retrieves a UTF-8 string with the preferred term for "procedure".
 	SqlInfo_SQL_PROCEDURE_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_AT_START SqlInfo = 532
-	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL schema.
@@ -324,7 +289,6 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SCHEMAS_SUPPORTED_ACTIONS SqlInfo = 533
-	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL catalog.
@@ -341,7 +305,6 @@ const (
 	// - 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`.
 	SqlInfo_SQL_CATALOGS_SUPPORTED_ACTIONS SqlInfo = 534
-	//
 	// Retrieves the supported SQL positioned commands.
 	//
 	// Returns an int32 bitmask value representing the supported SQL positioned commands.
@@ -354,14 +317,12 @@ const (
 	// - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
 	SqlInfo_SQL_SUPPORTED_POSITIONED_COMMANDS SqlInfo = 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.
 	SqlInfo_SQL_SELECT_FOR_UPDATE_SUPPORTED SqlInfo = 536
-	//
 	// Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
 	// are supported.
 	//
@@ -369,7 +330,6 @@ const (
 	// - 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.
 	SqlInfo_SQL_STORED_PROCEDURES_SUPPORTED SqlInfo = 537
-	//
 	// Retrieves the supported SQL subqueries.
 	//
 	// Returns an int32 bitmask value representing the supported SQL subqueries.
@@ -395,14 +355,12 @@ const (
 	// - ...
 	// Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
 	SqlInfo_SQL_SUPPORTED_SUBQUERIES SqlInfo = 538
-	//
 	// Retrieves a boolean value indicating whether correlated subqueries are supported.
 	//
 	// Returns:
 	// - false: if correlated subqueries are unsupported;
 	// - true: if correlated subqueries are supported.
 	SqlInfo_SQL_CORRELATED_SUBQUERIES_SUPPORTED SqlInfo = 539
-	//
 	// Retrieves the supported SQL UNIONs.
 	//
 	// Returns an int32 bitmask value representing the supported SQL UNIONs.
@@ -435,7 +393,6 @@ const (
 	SqlInfo_SQL_MAX_CONNECTIONS SqlInfo = 549
 	// Retrieves a int64 value the maximum number of characters allowed in a cursor name.
 	SqlInfo_SQL_MAX_CURSOR_NAME_LENGTH SqlInfo = 550
-	//
 	// Retrieves a int64 value representing the maximum number of bytes allowed for an index,
 	// including all of the parts of the index.
 	SqlInfo_SQL_MAX_INDEX_LENGTH SqlInfo = 551
@@ -447,17 +404,15 @@ const (
 	SqlInfo_SQL_MAX_CATALOG_NAME_LENGTH SqlInfo = 554
 	// Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
 	SqlInfo_SQL_MAX_ROW_SIZE SqlInfo = 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.
+	//   - 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.
 	SqlInfo_SQL_MAX_ROW_SIZE_INCLUDES_BLOBS SqlInfo = 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.
 	SqlInfo_SQL_MAX_STATEMENT_LENGTH SqlInfo = 557
@@ -469,13 +424,11 @@ const (
 	SqlInfo_SQL_MAX_TABLES_IN_SELECT SqlInfo = 560
 	// Retrieves a int64 value representing the maximum number of characters allowed in a user name.
 	SqlInfo_SQL_MAX_USERNAME_LENGTH SqlInfo = 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.
 	SqlInfo_SQL_DEFAULT_TRANSACTION_ISOLATION SqlInfo = 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`.
 	//
@@ -483,7 +436,6 @@ const (
 	// - false: if transactions are unsupported;
 	// - true: if transactions are supported.
 	SqlInfo_SQL_TRANSACTIONS_SUPPORTED SqlInfo = 563
-	//
 	// Retrieves the supported transactions isolation levels.
 	//
 	// Returns an int32 bitmask value representing the supported transactions isolation levels.
@@ -510,7 +462,6 @@ const (
 	// - ...
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
 	SqlInfo_SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS SqlInfo = 564
-	//
 	// Retrieves a boolean value indicating whether a data definition statement within a transaction forces
 	// the transaction to commit.
 	//
@@ -518,14 +469,12 @@ const (
 	// - 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.
 	SqlInfo_SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT SqlInfo = 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.
 	SqlInfo_SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED SqlInfo = 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.
 	//
@@ -542,7 +491,6 @@ const (
 	// - ...
 	// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
 	SqlInfo_SQL_SUPPORTED_RESULT_SET_TYPES SqlInfo = 567
-	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
 	//
@@ -557,7 +505,6 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED SqlInfo = 568
-	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
 	//
@@ -572,7 +519,6 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY SqlInfo = 569
-	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
 	//
@@ -587,7 +533,6 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE SqlInfo = 570
-	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
 	//
@@ -602,34 +547,29 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE SqlInfo = 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.
 	SqlInfo_SQL_BATCH_UPDATES_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_SAVEPOINTS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_NAMED_PARAMETERS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_LOCATORS_UPDATE_COPY SqlInfo = 575
-	//
 	// Retrieves a boolean value indicating whether invoking user-defined or vendor functions
 	// using the stored procedure escape syntax is supported.
 	//
@@ -1702,7 +1642,7 @@ func (SqlSupportsConvert) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{16}
 }
 
-//*
+// *
 // The JDBC/ODBC-defined type of any object.
 // All the values here are the sames as in the JDBC and ODBC specs.
 type XdbcDataType int32
@@ -1817,7 +1757,7 @@ func (XdbcDataType) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{17}
 }
 
-//*
+// *
 // Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
 type XdbcDatetimeSubcode int32
 
@@ -1958,13 +1898,13 @@ func (XdbcDatetimeSubcode) EnumDescriptor() ([]byte, []int) {
 type Nullable int32
 
 const (
-	//*
+	// *
 	// Indicates that the fields does not allow the use of null values.
 	Nullable_NULLABILITY_NO_NULLS Nullable = 0
-	//*
+	// *
 	// Indicates that the fields allow the use of null values.
 	Nullable_NULLABILITY_NULLABLE Nullable = 1
-	//*
+	// *
 	// Indicates that nullability of the fields can not be determined.
 	Nullable_NULLABILITY_UNKNOWN Nullable = 2
 )
@@ -2013,21 +1953,21 @@ func (Nullable) EnumDescriptor() ([]byte, []int) {
 type Searchable int32
 
 const (
-	//*
+	// *
 	// Indicates that column can not be used in a WHERE clause.
 	Searchable_SEARCHABLE_NONE Searchable = 0
-	//*
+	// *
 	// Indicates that the column can be used in a WHERE clause if it is using a
 	// LIKE operator.
 	Searchable_SEARCHABLE_CHAR Searchable = 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.
+	//   - Allowed operators: comparison, quantified comparison, BETWEEN,
+	//     DISTINCT, IN, MATCH, and UNIQUE.
 	Searchable_SEARCHABLE_BASIC Searchable = 2
-	//*
+	// *
 	// Indicates that the column can be used in a WHERE clause using any operator.
 	Searchable_SEARCHABLE_FULL Searchable = 3
 )
@@ -2293,22 +2233,23 @@ func (ActionCancelQueryResult_CancelResult) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{29, 0}
 }
 
-//
 // 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.
+//   - 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>>
+//
+//	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.
 type CommandGetSqlInfo struct {
@@ -2316,7 +2257,6 @@ type CommandGetSqlInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
@@ -2376,61 +2316,62 @@ func (x *CommandGetSqlInfo) GetInfo() []uint32 {
 	return nil
 }
 
-//
 // 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.
+//   - 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).
+//
+//	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.
 type CommandGetXdbcTypeInfo struct {
@@ -2438,7 +2379,6 @@ type CommandGetXdbcTypeInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// Specifies the data type to search for the info.
 	DataType *int32 `protobuf:"varint,1,opt,name=data_type,json=dataType,proto3,oneof" json:"data_type,omitempty"`
 }
@@ -2482,16 +2422,17 @@ func (x *CommandGetXdbcTypeInfo) GetDataType() int32 {
 	return 0
 }
 
-//
 // 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.
+//   - 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
+//
+//	catalog_name: utf8 not null
+//
 // >
 // The returned data should be ordered by catalog_name.
 type CommandGetCatalogs struct {
@@ -2532,17 +2473,18 @@ func (*CommandGetCatalogs) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{2}
 }
 
-//
 // 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.
+//   - 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
+//
+//	catalog_name: utf8,
+//	db_schema_name: utf8 not null
+//
 // >
 // The returned data should be ordered by catalog_name, then db_schema_name.
 type CommandGetDbSchemas struct {
@@ -2550,17 +2492,15 @@ type CommandGetDbSchemas struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
-	//
 	// 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.
+	//   - "%" means to match any substring with 0 or more characters.
+	//   - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
 }
 
@@ -2610,58 +2550,56 @@ func (x *CommandGetDbSchemas) GetDbSchemaFilterPattern() string {
 	return ""
 }
 
-//
 // 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.
+//   - 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.)
+//
+//	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.
+//   - 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.
 type CommandGetTables struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
-	//
 	// 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.
+	//   - "%" means to match any substring with 0 or more characters.
+	//   - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
-	//
 	// 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.
+	//   - "%" means to match any substring with 0 or more characters.
+	//   - "_" means to match any one character.
 	TableNameFilterPattern *string `protobuf:"bytes,3,opt,name=table_name_filter_pattern,json=tableNameFilterPattern,proto3,oneof" json:"table_name_filter_pattern,omitempty"`
-	//
 	// 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.
@@ -2737,17 +2675,18 @@ func (x *CommandGetTables) GetIncludeSchema() bool {
 	return false
 }
 
-//
 // 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.
+//   - 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
+//
+//	table_type: utf8 not null
+//
 // >
 // The returned data should be ordered by table_type.
 type CommandGetTableTypes struct {
@@ -2788,20 +2727,21 @@ func (*CommandGetTableTypes) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{5}
 }
 
-//
 // 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.
+//   - 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
+//
+//	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.
 type CommandGetPrimaryKeys struct {
@@ -2809,12 +2749,10 @@ type CommandGetPrimaryKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
-	//
 	// 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.
@@ -2876,28 +2814,29 @@ func (x *CommandGetPrimaryKeys) GetTable() string {
 	return ""
 }
 
-//
 // 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.
+//   - 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
+//
+//	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.
@@ -2906,12 +2845,10 @@ type CommandGetExportedKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
-	//
 	// 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.
@@ -2973,46 +2910,45 @@ func (x *CommandGetExportedKeys) GetTable() string {
 	return ""
 }
 
-//
 // 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.
+//   - 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
+//
+//	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
+//   - 0 = CASCADE
+//   - 1 = RESTRICT
+//   - 2 = SET NULL
+//   - 3 = NO ACTION
+//   - 4 = SET DEFAULT
 type CommandGetImportedKeys struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
-	//
 	// 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.
@@ -3074,66 +3010,67 @@ func (x *CommandGetImportedKeys) GetTable() string {
 	return ""
 }
 
-//
 // 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.
+//   - 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
+//
+//	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
+//   - 0 = CASCADE
+//   - 1 = RESTRICT
+//   - 2 = SET NULL
+//   - 3 = NO ACTION
+//   - 4 = SET DEFAULT
 type CommandGetCrossReference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	//*
+	// *
 	// 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.
 	PkCatalog *string `protobuf:"bytes,1,opt,name=pk_catalog,json=pkCatalog,proto3,oneof" json:"pk_catalog,omitempty"`
-	//*
+	// *
 	// 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.
 	PkDbSchema *string `protobuf:"bytes,2,opt,name=pk_db_schema,json=pkDbSchema,proto3,oneof" json:"pk_db_schema,omitempty"`
-	//*
+	// *
 	// The parent table name. It cannot be null.
 	PkTable string `protobuf:"bytes,3,opt,name=pk_table,json=pkTable,proto3" json:"pk_table,omitempty"`
-	//*
+	// *
 	// 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.
 	FkCatalog *string `protobuf:"bytes,4,opt,name=fk_catalog,json=fkCatalog,proto3,oneof" json:"fk_catalog,omitempty"`
-	//*
+	// *
 	// 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.
 	FkDbSchema *string `protobuf:"bytes,5,opt,name=fk_db_schema,json=fkDbSchema,proto3,oneof" json:"fk_db_schema,omitempty"`
-	//*
+	// *
 	// The foreign table name. It cannot be null.
 	FkTable string `protobuf:"bytes,6,opt,name=fk_table,json=fkTable,proto3" json:"fk_table,omitempty"`
 }
@@ -3212,7 +3149,6 @@ func (x *CommandGetCrossReference) GetFkTable() string {
 	return ""
 }
 
-//
 // Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
 type ActionCreatePreparedStatementRequest struct {
 	state         protoimpl.MessageState
@@ -3272,7 +3208,6 @@ func (x *ActionCreatePreparedStatementRequest) GetTransactionId() []byte {
 	return nil
 }
 
-//
 // An embedded message describing a Substrait plan to execute.
 type SubstraitPlan struct {
 	state         protoimpl.MessageState
@@ -3336,7 +3271,6 @@ func (x *SubstraitPlan) GetVersion() string {
 	return ""
 }
 
-//
 // Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
 type ActionCreatePreparedSubstraitPlanRequest struct {
 	state         protoimpl.MessageState
@@ -3396,7 +3330,6 @@ func (x *ActionCreatePreparedSubstraitPlanRequest) GetTransactionId() []byte {
 	return nil
 }
 
-//
 // Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
 //
 // The resultant PreparedStatement can be closed either:
@@ -3472,7 +3405,6 @@ func (x *ActionCreatePreparedStatementResult) GetParameterSchema() []byte {
 	return nil
 }
 
-//
 // Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
 // Closes server resources associated with the prepared statement handle.
 type ActionClosePreparedStatementRequest struct {
@@ -3523,7 +3455,6 @@ func (x *ActionClosePreparedStatementRequest) GetPreparedStatementHandle() []byt
 	return nil
 }
 
-//
 // Request message for the "BeginTransaction" action.
 // Begins a transaction.
 type ActionBeginTransactionRequest struct {
@@ -3564,7 +3495,6 @@ func (*ActionBeginTransactionRequest) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{15}
 }
 
-//
 // Request message for the "BeginSavepoint" action.
 // Creates a savepoint within a transaction.
 //
@@ -3627,7 +3557,6 @@ func (x *ActionBeginSavepointRequest) GetName() string {
 	return ""
 }
 
-//
 // The result of a "BeginTransaction" action.
 //
 // The transaction can be manipulated with the "EndTransaction" action, or
@@ -3683,7 +3612,6 @@ func (x *ActionBeginTransactionResult) GetTransactionId() []byte {
 	return nil
 }
 
-//
 // The result of a "BeginSavepoint" action.
 //
 // The transaction can be manipulated with the "EndSavepoint" action.
@@ -3739,7 +3667,6 @@ func (x *ActionBeginSavepointResult) GetSavepointId() []byte {
 	return nil
 }
 
-//
 // Request message for the "EndTransaction" action.
 //
 // Commit (COMMIT) or rollback (ROLLBACK) the transaction.
@@ -3803,7 +3730,6 @@ func (x *ActionEndTransactionRequest) GetAction() ActionEndTransactionRequest_En
 	return ActionEndTransactionRequest_END_TRANSACTION_UNSPECIFIED
 }
 
-//
 // Request message for the "EndSavepoint" action.
 //
 // Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
@@ -3869,22 +3795,21 @@ func (x *ActionEndSavepointRequest) GetAction() ActionEndSavepointRequest_EndSav
 	return ActionEndSavepointRequest_END_SAVEPOINT_UNSPECIFIED
 }
 
-//
 // 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.
+//   - 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.
 type CommandStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3942,23 +3867,22 @@ func (x *CommandStatementQuery) GetTransactionId() []byte {
 	return nil
 }
 
-//
 // 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.
+//   - 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.
 type CommandStatementSubstraitPlan struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -4016,7 +3940,7 @@ func (x *CommandStatementSubstraitPlan) GetTransactionId() []byte {
 	return nil
 }
 
-//*
+// *
 // 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.
 type TicketStatementQuery struct {
@@ -4067,23 +3991,22 @@ func (x *TicketStatementQuery) GetStatementHandle() []byte {
 	return nil
 }
 
-//
 // 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.
-//  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
-//  - GetFlightInfo: execute the prepared statement instance.
+//   - 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.
+//   - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+//   - GetFlightInfo: execute the prepared statement instance.
 type CommandPreparedStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -4132,7 +4055,6 @@ func (x *CommandPreparedStatementQuery) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
-//
 // 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.
 type CommandStatementUpdate struct {
@@ -4192,7 +4114,6 @@ func (x *CommandStatementUpdate) GetTransactionId() []byte {
 	return nil
 }
 
-//
 // 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.
@@ -4244,7 +4165,6 @@ func (x *CommandPreparedStatementUpdate) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
-//
 // Returned from the RPC call DoPut when a CommandStatementUpdate
 // CommandPreparedStatementUpdate was in the request, containing
 // results from the update.
@@ -4297,7 +4217,6 @@ func (x *DoPutUpdateResult) GetRecordCount() int64 {
 	return 0
 }
 
-//
 // Request message for the "CancelQuery" action.
 //
 // Explicitly cancel a running query.
@@ -4366,7 +4285,6 @@ func (x *ActionCancelQueryRequest) GetInfo() []byte {
 	return nil
 }
 
-//
 // The result of cancelling a query.
 //
 // The result should be wrapped in a google.protobuf.Any message.
@@ -4424,7 +4342,7 @@ func (x *ActionCancelQueryResult) GetResult() ActionCancelQueryResult_CancelResu
 
 var file_FlightSql_proto_extTypes = []protoimpl.ExtensionInfo{
 	{
-		ExtendedType:  (*descriptor.MessageOptions)(nil),
+		ExtendedType:  (*descriptorpb.MessageOptions)(nil),
 		ExtensionType: (*bool)(nil),
 		Field:         1000,
 		Name:          "arrow.flight.protocol.sql.experimental",
@@ -4433,7 +4351,7 @@ var file_FlightSql_proto_extTypes = []protoimpl.ExtensionInfo{
 	},
 }
 
-// Extension fields to descriptor.MessageOptions.
+// Extension fields to descriptorpb.MessageOptions.
 var (
 	// optional bool experimental = 1000;
 	E_Experimental = &file_FlightSql_proto_extTypes[0]
@@ -5169,13 +5087,13 @@ var file_FlightSql_proto_rawDesc = []byte{
 	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d,
 	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0xe8, 0x07,
 	0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74,
-	0x61, 0x6c, 0x42, 0x5b, 0x0a, 0x20, 0x6f, 0x72, 0x67, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65,
+	0x61, 0x6c, 0x42, 0x56, 0x0a, 0x20, 0x6f, 0x72, 0x67, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65,
 	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x73, 0x71,
-	0x6c, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x37, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
+	0x6c, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
 	0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f,
 	0x67, 0x6f, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2f,
-	0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x67, 0x65, 0x6e, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 }
 
 var (
@@ -5248,7 +5166,7 @@ var file_FlightSql_proto_goTypes = []interface{}{
 	(*DoPutUpdateResult)(nil),                        // 52: arrow.flight.protocol.sql.DoPutUpdateResult
 	(*ActionCancelQueryRequest)(nil),                 // 53: arrow.flight.protocol.sql.ActionCancelQueryRequest
 	(*ActionCancelQueryResult)(nil),                  // 54: arrow.flight.protocol.sql.ActionCancelQueryResult
-	(*descriptor.MessageOptions)(nil),                // 55: google.protobuf.MessageOptions
+	(*descriptorpb.MessageOptions)(nil),              // 55: google.protobuf.MessageOptions
 }
 var file_FlightSql_proto_depIdxs = []int32{
 	36, // 0: arrow.flight.protocol.sql.ActionCreatePreparedSubstraitPlanRequest.plan:type_name -> arrow.flight.protocol.sql.SubstraitPlan
diff --git a/go/arrow/flight/gen/flight/Flight_grpc.pb.go b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
index 9613114448796..150de71a1113b 100644
--- a/go/arrow/flight/gen/flight/Flight_grpc.pb.go
+++ b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
@@ -1,8 +1,4 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-// versions:
-// - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.12.4
-// source: Flight.proto
 
 package flight
 
@@ -15,20 +11,17 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 
 // FlightServiceClient is the client API for FlightService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type FlightServiceClient interface {
-	//
 	// 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.
 	Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error)
-	//
 	// 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
@@ -36,7 +29,6 @@ type FlightServiceClient interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error)
-	//
 	// 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
@@ -48,19 +40,39 @@ type FlightServiceClient interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*FlightInfo, error)
+	// 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.
+	PollFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*PollInfo, error)
 	// 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.
 	GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error)
-	//
 	// 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.
 	DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error)
-	//
 	// 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
@@ -68,14 +80,12 @@ type FlightServiceClient interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error)
-	//
 	// 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.
 	DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error)
-	//
 	// 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
@@ -83,7 +93,6 @@ type FlightServiceClient interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error)
-	//
 	// 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.
@@ -99,7 +108,7 @@ func NewFlightServiceClient(cc grpc.ClientConnInterface) FlightServiceClient {
 }
 
 func (c *flightServiceClient) Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -130,7 +139,7 @@ func (x *flightServiceHandshakeClient) Recv() (*HandshakeResponse, error) {
 }
 
 func (c *flightServiceClient) ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -170,6 +179,15 @@ func (c *flightServiceClient) GetFlightInfo(ctx context.Context, in *FlightDescr
 	return out, nil
 }
 
+func (c *flightServiceClient) PollFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*PollInfo, error) {
+	out := new(PollInfo)
+	err := c.cc.Invoke(ctx, "/arrow.flight.protocol.FlightService/PollFlightInfo", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *flightServiceClient) GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error) {
 	out := new(SchemaResult)
 	err := c.cc.Invoke(ctx, "/arrow.flight.protocol.FlightService/GetSchema", in, out, opts...)
@@ -180,7 +198,7 @@ func (c *flightServiceClient) GetSchema(ctx context.Context, in *FlightDescripto
 }
 
 func (c *flightServiceClient) DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -212,7 +230,7 @@ func (x *flightServiceDoGetClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -243,7 +261,7 @@ func (x *flightServiceDoPutClient) Recv() (*PutResult, error) {
 }
 
 func (c *flightServiceClient) DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -274,7 +292,7 @@ func (x *flightServiceDoExchangeClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -306,7 +324,7 @@ func (x *flightServiceDoActionClient) Recv() (*Result, error) {
 }
 
 func (c *flightServiceClient) ListActions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (FlightService_ListActionsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
+	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -341,13 +359,11 @@ func (x *flightServiceListActionsClient) Recv() (*ActionType, error) {
 // All implementations must embed UnimplementedFlightServiceServer
 // for forward compatibility
 type FlightServiceServer interface {
-	//
 	// 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.
 	Handshake(FlightService_HandshakeServer) error
-	//
 	// 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
@@ -355,7 +371,6 @@ type FlightServiceServer interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(*Criteria, FlightService_ListFlightsServer) error
-	//
 	// 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
@@ -367,19 +382,39 @@ type FlightServiceServer interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error)
+	// 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.
+	PollFlightInfo(context.Context, *FlightDescriptor) (*PollInfo, error)
 	// 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.
 	GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error)
-	//
 	// 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.
 	DoGet(*Ticket, FlightService_DoGetServer) error
-	//
 	// 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
@@ -387,14 +422,12 @@ type FlightServiceServer interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(FlightService_DoPutServer) error
-	//
 	// 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.
 	DoExchange(FlightService_DoExchangeServer) error
-	//
 	// 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
@@ -402,7 +435,6 @@ type FlightServiceServer interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(*Action, FlightService_DoActionServer) error
-	//
 	// 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.
@@ -423,6 +455,9 @@ func (UnimplementedFlightServiceServer) ListFlights(*Criteria, FlightService_Lis
 func (UnimplementedFlightServiceServer) GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetFlightInfo not implemented")
 }
+func (UnimplementedFlightServiceServer) PollFlightInfo(context.Context, *FlightDescriptor) (*PollInfo, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method PollFlightInfo not implemented")
+}
 func (UnimplementedFlightServiceServer) GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetSchema not implemented")
 }
@@ -450,8 +485,8 @@ type UnsafeFlightServiceServer interface {
 	mustEmbedUnimplementedFlightServiceServer()
 }
 
-func RegisterFlightServiceServer(s grpc.ServiceRegistrar, srv FlightServiceServer) {
-	s.RegisterService(&FlightService_ServiceDesc, srv)
+func RegisterFlightServiceServer(s *grpc.Server, srv FlightServiceServer) {
+	s.RegisterService(&_FlightService_serviceDesc, srv)
 }
 
 func _FlightService_Handshake_Handler(srv interface{}, stream grpc.ServerStream) error {
@@ -519,6 +554,24 @@ func _FlightService_GetFlightInfo_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _FlightService_PollFlightInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FlightDescriptor)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(FlightServiceServer).PollFlightInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/arrow.flight.protocol.FlightService/PollFlightInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(FlightServiceServer).PollFlightInfo(ctx, req.(*FlightDescriptor))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _FlightService_GetSchema_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(FlightDescriptor)
 	if err := dec(in); err != nil {
@@ -652,10 +705,7 @@ func (x *flightServiceListActionsServer) Send(m *ActionType) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-// FlightService_ServiceDesc is the grpc.ServiceDesc for FlightService service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var FlightService_ServiceDesc = grpc.ServiceDesc{
+var _FlightService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "arrow.flight.protocol.FlightService",
 	HandlerType: (*FlightServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
@@ -663,6 +713,10 @@ var FlightService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "GetFlightInfo",
 			Handler:    _FlightService_GetFlightInfo_Handler,
 		},
+		{
+			MethodName: "PollFlightInfo",
+			Handler:    _FlightService_PollFlightInfo_Handler,
+		},
 		{
 			MethodName: "GetSchema",
 			Handler:    _FlightService_GetSchema_Handler,
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index c5e64986d5f78..88006b2fe2556 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -42,6 +42,7 @@ type (
 	FlightEndpoint                  = flight.FlightEndpoint
 	Location                        = flight.Location
 	FlightInfo                      = flight.FlightInfo
+	PollInfo                       = flight.PollInfo
 	FlightData                      = flight.FlightData
 	PutResult                       = flight.PutResult
 	Ticket                          = flight.Ticket
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 3e5cc73b98753..6646502ab648f 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"net"
 	"os"
 	"reflect"
@@ -68,6 +69,8 @@ func GetScenario(name string, args ...string) Scenario {
 		return &expirationTimeCancelFlightInfoScenarioTester{}
 	case "expiration_time:renew_flight_endpoint":
 		return &expirationTimeRenewFlightEndpointScenarioTester{}
+	case "poll_flight_info":
+		return &pollFlightInfoScenarioTester{}
 	case "flight_sql":
 		return &flightSqlScenarioTester{}
 	case "flight_sql:extension":
@@ -1131,6 +1134,108 @@ func (tester *expirationTimeRenewFlightEndpointScenarioTester) RunClient(addr st
 	return nil
 }
 
+type pollFlightInfoScenarioTester struct {
+	flight.BaseFlightServer
+}
+
+func (tester *pollFlightInfoScenarioTester) MakeServer(port int) flight.Server {
+	srv := flight.NewServerWithMiddleware(nil)
+	srv.RegisterFlightService(tester)
+	initServer(port, srv)
+	return srv
+}
+
+func (tester *pollFlightInfoScenarioTester) PollFlightInfo(ctx context.Context, desc *flight.FlightDescriptor) (*flight.PollInfo, error) {
+	schema := arrow.NewSchema(
+		[]arrow.Field{
+			{Name: "number", Type: arrow.PrimitiveTypes.Uint32},
+		},
+		nil,
+	)
+	endpoints := []*flight.FlightEndpoint{
+		&flight.FlightEndpoint{
+			Ticket:   &flight.Ticket{Ticket: []byte("long-running query")},
+			Location: []*flight.Location{},
+		},
+	}
+	info := &flight.FlightInfo{
+		Schema:           flight.SerializeSchema(schema, memory.DefaultAllocator),
+		FlightDescriptor: desc,
+		Endpoint:         endpoints,
+		TotalRecords:     -1,
+		TotalBytes:       -1,
+	}
+	pollDesc := flight.FlightDescriptor{
+		Type: flight.DescriptorCMD,
+		Cmd:  []byte("poll"),
+	}
+	if desc.Type == pollDesc.Type && string(desc.Cmd) == string(pollDesc.Cmd) {
+		progress := float64(1.0)
+		return &flight.PollInfo{
+			Info:             info,
+			FlightDescriptor: nil,
+			Progress:         &progress,
+			ExpirationTime:   nil,
+		}, nil
+	} else {
+		progress := float64(0.1)
+		return &flight.PollInfo{
+			Info:             info,
+			FlightDescriptor: &pollDesc,
+			Progress:         &progress,
+			ExpirationTime:   timestamppb.New(time.Now().Add(time.Second * 10)),
+		}, nil
+	}
+}
+
+func (tester *pollFlightInfoScenarioTester) RunClient(addr string, opts ...grpc.DialOption) error {
+	client, err := flight.NewClientWithMiddleware(addr, nil, nil, opts...)
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	ctx := context.Background()
+	desc := flight.FlightDescriptor{
+		Type: flight.DescriptorCMD,
+		Cmd:  []byte("heavy query"),
+	}
+	info, err := client.PollFlightInfo(ctx, &desc)
+	if err != nil {
+		return err
+	}
+	switch {
+	case info.FlightDescriptor == nil:
+		return fmt.Errorf("description is missing: %s", info.String())
+	case info.Progress == nil:
+		return fmt.Errorf("progress is missing: %s", info.String())
+	case !(0.0 <= *info.Progress && *info.Progress <= 1.0):
+		return fmt.Errorf("invalid progress: %s", info.String())
+	case info.ExpirationTime == nil:
+		return fmt.Errorf("expiration time is missing: %s", info.String())
+	}
+
+	info, err = client.PollFlightInfo(ctx, info.FlightDescriptor)
+	if err != nil {
+		return err
+	}
+	switch {
+	case info.FlightDescriptor != nil:
+		return fmt.Errorf("retried but no finished yet: %s", info.String())
+	case info.Progress == nil:
+		return fmt.Errorf("progress is missing in finished query: %s",
+			info.String())
+	case math.Abs(*info.Progress-1.0) > 1e-5:
+		return fmt.Errorf("progress for finished query isn't 1.0: %s",
+			info.String())
+	case info.ExpirationTime != nil:
+		return fmt.Errorf("expiration time must not be set for finished query: %s",
+			info.String())
+	}
+
+	return nil
+}
+
 const (
 	updateStatementExpectedRows                        int64 = 10000
 	updateStatementWithTransactionExpectedRows         int64 = 15000
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
index 155e373bda2f3..422ed01c394d1 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
@@ -287,6 +287,23 @@ public FlightInfo getInfo(FlightDescriptor descriptor, CallOption... options) {
     }
   }
 
+  /**
+   * Start or get info on execution of a long-running query.
+   *
+   * @param descriptor The descriptor for the stream.
+   * @param options RPC-layer hints for this call.
+   * @return Metadata about execution.
+   */
+  public PollInfo pollInfo(FlightDescriptor descriptor, CallOption... options) {
+    try {
+      return new PollInfo(CallOptions.wrapStub(blockingStub, options).pollFlightInfo(descriptor.toProtocol()));
+    } catch (URISyntaxException e) {
+      throw new RuntimeException(e);
+    } catch (StatusRuntimeException sre) {
+      throw StatusUtils.fromGrpcRuntimeException(sre);
+    }
+  }
+
   /**
    * Get schema for a stream.
    * @param descriptor The descriptor for the stream.
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightMethod.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightMethod.java
index 5d2915bb686c4..b1331a8edd60f 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightMethod.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightMethod.java
@@ -32,6 +32,7 @@ public enum FlightMethod {
   DO_ACTION,
   LIST_ACTIONS,
   DO_EXCHANGE,
+  POLL_FLIGHT_INFO,
   ;
 
   /**
@@ -58,6 +59,8 @@ public static FlightMethod fromProtocol(final String methodName) {
       return LIST_ACTIONS;
     } else if (FlightServiceGrpc.getDoExchangeMethod().getFullMethodName().equals(methodName)) {
       return DO_EXCHANGE;
+    } else if (FlightServiceGrpc.getPollFlightInfoMethod().getFullMethodName().equals(methodName)) {
+      return POLL_FLIGHT_INFO;
     }
     throw new IllegalArgumentException("Not a Flight method name in gRPC: " + methodName);
   }
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
index 5e5b265050086..f2ae3db0b50d7 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
@@ -52,6 +52,22 @@ void listFlights(CallContext context, Criteria criteria,
    */
   FlightInfo getFlightInfo(CallContext context, FlightDescriptor descriptor);
 
+  /**
+   * Begin or get an update on execution of a long-running query.
+   *
+   * <p>If the descriptor would begin a query, the server should return a response immediately to not
+   * block the client. Otherwise, the server should not return an update until progress is made to
+   * not spam the client with inactionable updates.
+   *
+   * @param context Per-call context.
+   * @param descriptor The descriptor identifying the data stream.
+   * @return Metadata about execution.
+   */
+  default PollInfo pollFlightInfo(CallContext context, FlightDescriptor descriptor) {
+    FlightInfo info = getFlightInfo(context, descriptor);
+    return new PollInfo(info, null, null, null);
+  }
+
   /**
    * Get schema for a particular data stream.
    *
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightService.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightService.java
index 29a4f2bbd19ea..5231a7aaf76e4 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightService.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightService.java
@@ -258,6 +258,21 @@ public void getFlightInfo(Flight.FlightDescriptor request, StreamObserver<Flight
     responseObserver.onCompleted();
   }
 
+  @Override
+  public void pollFlightInfo(Flight.FlightDescriptor request, StreamObserver<Flight.PollInfo> responseObserver) {
+    final PollInfo info;
+    try {
+      info = producer
+          .pollFlightInfo(makeContext((ServerCallStreamObserver<?>) responseObserver), new FlightDescriptor(request));
+    } catch (Exception ex) {
+      // Don't capture exceptions from onNext or onCompleted with this block - because then we can't call onError
+      responseObserver.onError(StatusUtils.toGrpcException(ex));
+      return;
+    }
+    responseObserver.onNext(info.toProtocol());
+    responseObserver.onCompleted();
+  }
+
   /**
    * Broadcast the given exception to all registered middleware.
    */
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/PollInfo.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/PollInfo.java
new file mode 100644
index 0000000000000..2bb3c6db69569
--- /dev/null
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/PollInfo.java
@@ -0,0 +1,160 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.flight;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.time.Instant;
+import java.util.Objects;
+import java.util.Optional;
+
+import org.apache.arrow.flight.impl.Flight;
+
+import com.google.protobuf.Timestamp;
+
+/**
+ * A POJO representation of the execution of a long-running query.
+ */
+public class PollInfo {
+  private final FlightInfo flightInfo;
+  private final FlightDescriptor flightDescriptor;
+  private final Double progress;
+  private final Instant expirationTime;
+
+  /**
+   * Create a new PollInfo.
+   *
+   * @param flightInfo The FlightInfo (must not be null).
+   * @param flightDescriptor The descriptor used to poll for more information; null if and only if query is finished.
+   * @param progress Optional progress info in [0.0, 1.0].
+   * @param expirationTime An expiration time, after which the server may no longer recognize the descriptor.
+   */
+  public PollInfo(FlightInfo flightInfo, FlightDescriptor flightDescriptor, Double progress, Instant expirationTime) {
+    this.flightInfo = Objects.requireNonNull(flightInfo);
+    this.flightDescriptor = flightDescriptor;
+    this.progress = progress;
+    this.expirationTime = expirationTime;
+  }
+
+  PollInfo(Flight.PollInfo flt) throws URISyntaxException {
+    this.flightInfo = new FlightInfo(flt.getInfo());
+    this.flightDescriptor = flt.hasFlightDescriptor() ? new FlightDescriptor(flt.getFlightDescriptor()) : null;
+    this.progress = flt.hasProgress() ? flt.getProgress() : null;
+    this.expirationTime = flt.hasExpirationTime() ?
+        Instant.ofEpochSecond(flt.getExpirationTime().getSeconds(), flt.getExpirationTime().getNanos()) :
+        null;
+  }
+
+  /**
+   * The FlightInfo describing the result set of the execution of a query.
+   *
+   * <p>This is always present and always contains all endpoints for the query execution so far,
+   * not just new endpoints that completed execution since the last call to
+   * {@link FlightClient#pollInfo(FlightDescriptor, CallOption...)}.
+   */
+  public FlightInfo getFlightInfo() {
+    return flightInfo;
+  }
+
+  /**
+   * The FlightDescriptor that should be used to get further updates on this query.
+   *
+   * <p>It is present if and only if the query is still running.  If present, it should be passed to
+   * {@link FlightClient#pollInfo(FlightDescriptor, CallOption...)} to get an update.
+   */
+  public Optional<FlightDescriptor> getFlightDescriptor() {
+    return Optional.ofNullable(flightDescriptor);
+  }
+
+  /**
+   * The progress of the query.
+   *
+   * <p>If present, should be a value in [0.0, 1.0]. It is not necessarily monotonic or non-decreasing.
+   */
+  public Optional<Double> getProgress() {
+    return Optional.ofNullable(progress);
+  }
+
+  /**
+   * The expiration time of the query execution.
+   *
+   * <p>After this passes, the server may not recognize the descriptor anymore and the client will not
+   * be able to track the query anymore.
+   */
+  public Optional<Instant> getExpirationTime() {
+    return Optional.ofNullable(expirationTime);
+  }
+
+  Flight.PollInfo toProtocol() {
+    Flight.PollInfo.Builder b = Flight.PollInfo.newBuilder();
+    b.setInfo(flightInfo.toProtocol());
+    if (flightDescriptor != null) {
+      b.setFlightDescriptor(flightDescriptor.toProtocol());
+    }
+    if (progress != null) {
+      b.setProgress(progress);
+    }
+    if (expirationTime != null) {
+      b.setExpirationTime(
+          Timestamp.newBuilder()
+              .setSeconds(expirationTime.getEpochSecond())
+              .setNanos(expirationTime.getNano())
+              .build());
+    }
+    return b.build();
+  }
+
+  public ByteBuffer serialize() {
+    return ByteBuffer.wrap(toProtocol().toByteArray());
+  }
+
+  public static PollInfo deserialize(ByteBuffer serialized) throws IOException, URISyntaxException {
+    return new PollInfo(Flight.PollInfo.parseFrom(serialized));
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    PollInfo pollInfo = (PollInfo) o;
+    return Objects.equals(getFlightInfo(), pollInfo.getFlightInfo()) &&
+        Objects.equals(getFlightDescriptor(), pollInfo.getFlightDescriptor()) &&
+        Objects.equals(getProgress(), pollInfo.getProgress()) &&
+        Objects.equals(getExpirationTime(), pollInfo.getExpirationTime());
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(getFlightInfo(), getFlightDescriptor(), getProgress(), getExpirationTime());
+  }
+
+  @Override
+  public String toString() {
+    return "PollInfo{" +
+        "flightInfo=" + flightInfo +
+        ", flightDescriptor=" + flightDescriptor +
+        ", progress=" + progress +
+        ", expirationTime=" + expirationTime +
+        '}';
+  }
+}
diff --git a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoProducer.java b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoProducer.java
new file mode 100644
index 0000000000000..61312db56bc61
--- /dev/null
+++ b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoProducer.java
@@ -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 org.apache.arrow.flight.integration.tests;
+
+import java.nio.charset.StandardCharsets;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightEndpoint;
+import org.apache.arrow.flight.FlightInfo;
+import org.apache.arrow.flight.NoOpFlightProducer;
+import org.apache.arrow.flight.PollInfo;
+import org.apache.arrow.flight.Ticket;
+import org.apache.arrow.vector.types.Types;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+
+/** Test PollFlightInfo. */
+class PollFlightInfoProducer extends NoOpFlightProducer {
+  static final byte[] POLL_DESCRIPTOR = "poll".getBytes(StandardCharsets.UTF_8);
+
+  @Override
+  public PollInfo pollFlightInfo(CallContext context, FlightDescriptor descriptor) {
+    Schema schema = new Schema(
+        Collections.singletonList(Field.notNullable("number", Types.MinorType.UINT4.getType())));
+    List<FlightEndpoint> endpoints = Collections.singletonList(
+        new FlightEndpoint(
+            new Ticket("long-running query".getBytes(StandardCharsets.UTF_8))));
+    FlightInfo info = new FlightInfo(schema, descriptor, endpoints, -1, -1 );
+    if (descriptor.isCommand() && Arrays.equals(descriptor.getCommand(), POLL_DESCRIPTOR)) {
+      return new PollInfo(info, null, 1.0, null);
+    } else {
+      return new PollInfo(
+          info, FlightDescriptor.command(POLL_DESCRIPTOR), 0.1, Instant.now().plus(10, ChronoUnit.SECONDS));
+    }
+  }
+}
diff --git a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoScenario.java b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoScenario.java
new file mode 100644
index 0000000000000..1ffbe3c726216
--- /dev/null
+++ b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/PollFlightInfoScenario.java
@@ -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.
+ */
+
+package org.apache.arrow.flight.integration.tests;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+
+import org.apache.arrow.flight.FlightClient;
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightProducer;
+import org.apache.arrow.flight.FlightServer;
+import org.apache.arrow.flight.Location;
+import org.apache.arrow.flight.PollInfo;
+import org.apache.arrow.memory.BufferAllocator;
+
+/** Test PollFlightInfo. */
+final class PollFlightInfoScenario implements Scenario {
+  @Override
+  public FlightProducer producer(BufferAllocator allocator, Location location) throws Exception {
+    return new PollFlightInfoProducer();
+  }
+
+  @Override
+  public void buildServer(FlightServer.Builder builder) throws Exception {
+  }
+
+  @Override
+  public void client(BufferAllocator allocator, Location location, FlightClient client) throws Exception {
+    PollInfo info = client.pollInfo(FlightDescriptor.command("heavy query".getBytes(StandardCharsets.UTF_8)));
+    IntegrationAssertions.assertNotNull(info.getFlightInfo());
+    Optional<Double> progress = info.getProgress();
+    IntegrationAssertions.assertTrue("progress is missing", progress.isPresent());
+    IntegrationAssertions.assertTrue("progress is invalid", progress.get() >= 0.0 && progress.get() <= 1.0);
+    IntegrationAssertions.assertTrue("expiration is missing", info.getExpirationTime().isPresent());
+    IntegrationAssertions.assertTrue("descriptor is missing",
+        info.getFlightDescriptor().isPresent());
+
+    info = client.pollInfo(info.getFlightDescriptor().get());
+    IntegrationAssertions.assertNotNull(info.getFlightInfo());
+    progress = info.getProgress();
+    IntegrationAssertions.assertTrue("progress is missing in finished query", progress.isPresent());
+    IntegrationAssertions.assertTrue("progress isn't 1.0 in finished query",
+        Math.abs(progress.get() - 1.0) < Math.ulp(1.0));
+    IntegrationAssertions.assertFalse("expiration is set in finished query", info.getExpirationTime().isPresent());
+    IntegrationAssertions.assertFalse("descriptor is set in finished query", info.getFlightDescriptor().isPresent());
+  }
+}
diff --git a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
index da9064c0e9359..26629c650e30f 100644
--- a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
+++ b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
@@ -46,6 +46,7 @@ private Scenarios() {
     scenarios.put("expiration_time:list_actions", ExpirationTimeListActionsScenario::new);
     scenarios.put("middleware", MiddlewareScenario::new);
     scenarios.put("ordered", OrderedScenario::new);
+    scenarios.put("poll_flight_info", PollFlightInfoScenario::new);
     scenarios.put("flight_sql", FlightSqlScenario::new);
     scenarios.put("flight_sql:extension", FlightSqlExtensionScenario::new);
   }
diff --git a/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java b/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
index ab7f04075eecc..cf65e16fac06f 100644
--- a/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
+++ b/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
@@ -63,6 +63,11 @@ void ordered() throws Exception {
     testScenario("ordered");
   }
 
+  @Test
+  void pollFlightInfo() throws Exception {
+    testScenario("poll_flight_info");
+  }
+
   @Test
   void flightSql() throws Exception {
     testScenario("flight_sql");

From 8844d6ad7ac977f5d43f4a181596f94118d697e8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 15 Aug 2023 13:08:48 +0900
Subject: [PATCH 162/749] MINOR: [C#] Bump Grpc.Tools from 2.56.2 to 2.57.0 in
 /csharp (#37154)

Bumps [Grpc.Tools](https://github.com/grpc/grpc) from 2.56.2 to 2.57.0.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/grpc/grpc/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Tools&package-manager=nuget&previous-version=2.56.2&new-version=2.57.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 8d447e5babbc2..e298f5268395b 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
-    <PackageReference Include="Grpc.Tools" Version="2.56.2" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">

From e7ece9ae8cd84ef67e83d50bfd912638a5355838 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Tue, 15 Aug 2023 01:17:15 -0400
Subject: [PATCH 163/749] GH-36991: [Python][Packaging] Skip tests on Win that
 require a tz database (#36996)

### Rationale for this change

Some tests require a tz database, which Windows might not provide at the expected file location. Skip them if the tz db is not found.

### What changes are included in this PR?

* Tests skipped if tz db is not found

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #36991

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/tests/test_convert_builtin.py | 4 ++++
 python/pyarrow/tests/test_scalars.py         | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/python/pyarrow/tests/test_convert_builtin.py b/python/pyarrow/tests/test_convert_builtin.py
index cf2535a3c62d1..49c4f1a6e79d6 100644
--- a/python/pyarrow/tests/test_convert_builtin.py
+++ b/python/pyarrow/tests/test_convert_builtin.py
@@ -21,6 +21,7 @@
 import itertools
 import math
 import re
+import sys
 
 import hypothesis as h
 import numpy as np
@@ -28,6 +29,7 @@
 
 from pyarrow.pandas_compat import _pandas_api  # noqa
 import pyarrow as pa
+from pyarrow.tests import util
 import pyarrow.tests.strategies as past
 
 
@@ -1338,6 +1340,8 @@ def test_sequence_timestamp_nanoseconds():
 
 
 @pytest.mark.pandas
+@pytest.mark.skipif(sys.platform == "win32" and not util.windows_has_tzdata(),
+                    reason="Timezone database is not installed on Windows")
 def test_sequence_timestamp_from_int_with_unit():
     # TODO(wesm): This test might be rewritten to assert the actual behavior
     # when pandas is not installed
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index a989301fe5735..d52edce6d91a8 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -154,6 +154,8 @@ def test_hashing_struct_scalar():
     assert hash1 == hash2
 
 
+@pytest.mark.skipif(sys.platform == "win32" and not util.windows_has_tzdata(),
+                    reason="Timezone database is not installed on Windows")
 def test_timestamp_scalar():
     a = repr(pa.scalar("0000-01-01").cast(pa.timestamp("s")))
     assert a == "<pyarrow.TimestampScalar: '0000-01-01T00:00:00'>"

From 6b810cbc23fb4f73ab8684ff1457888cfa833c5d Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Tue, 15 Aug 2023 22:56:52 +0800
Subject: [PATCH 164/749] GH-37102: [Go][Parquet] Encoding: Make BitWriter
 Reserve when ReserveBytes (#37112)

### Rationale for this change

See https://github.com/apache/arrow/issues/37102. Also fixes #35718

Golang BitWriter didn't reserve when `ReserveBytes` called. So it make it wrong.

### What changes are included in this PR?

Change `ReserveBytes` impl

### Are these changes tested?

Currently not

### Are there any user-facing changes?

bugfix

* Closes: #37102

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 .../internal/encoding/delta_bit_packing.go    |  2 +-
 go/parquet/internal/encoding/encoding_test.go | 24 +++++++++++++++++++
 go/parquet/internal/encoding/levels.go        |  3 +--
 go/parquet/internal/utils/bit_writer.go       | 16 +++++++++----
 go/parquet/internal/utils/rle.go              |  8 ++++---
 5 files changed, 42 insertions(+), 11 deletions(-)

diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index ab542eabb2d3d..d3271506734b7 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -355,7 +355,7 @@ func (enc *deltaBitPackEncoder) flushBlock() {
 
 	enc.bitWriter.WriteZigZagVlqInt(minDelta)
 	// reserve enough bytes to write out our miniblock deltas
-	offset := enc.bitWriter.ReserveBytes(int(enc.numMiniBlocks))
+	offset, _ := enc.bitWriter.SkipBytes(int(enc.numMiniBlocks))
 
 	valuesToWrite := int64(len(enc.deltas))
 	for i := 0; i < int(enc.numMiniBlocks); i++ {
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index de82494325b93..f82d9d75d392e 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -646,6 +646,30 @@ func TestWriteDeltaBitPackedInt64(t *testing.T) {
 			assert.Equalf(t, values[i:j], valueBuf, "indexes %d:%d", i, j)
 		}
 	})
+
+	t.Run("GH-37102", func(t *testing.T) {
+		values := []int64{
+			0, 3000000000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 3000000000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 3000000000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 3000000000000000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0,
+		}
+
+		enc := encoding.NewEncoder(parquet.Types.Int64, parquet.Encodings.DeltaBinaryPacked, false, column, memory.DefaultAllocator)
+		enc.(encoding.Int64Encoder).Put(values)
+		buf, _ := enc.FlushValues()
+		defer buf.Release()
+
+		dec := encoding.NewDecoder(parquet.Types.Int64, parquet.Encodings.DeltaBinaryPacked, column, memory.DefaultAllocator)
+		dec.(encoding.Int64Decoder).SetData(len(values), buf.Bytes())
+
+		valueBuf := make([]int64, len(values))
+
+		decoded, _ := dec.(encoding.Int64Decoder).Decode(valueBuf)
+		assert.Equal(t, len(valueBuf), decoded)
+		assert.Equal(t, values, valueBuf)
+	})
 }
 
 func TestDeltaLengthByteArrayEncoding(t *testing.T) {
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index f0767b4976123..d6a47f3366f66 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
-	"io"
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
@@ -75,7 +74,7 @@ func (l *LevelEncoder) Reset(maxLvl int16) {
 
 // Init is called to set up the desired encoding type, max level and underlying writer for a
 // level encoder to control where the resulting encoded buffer will end up.
-func (l *LevelEncoder) Init(encoding parquet.Encoding, maxLvl int16, w io.WriterAt) {
+func (l *LevelEncoder) Init(encoding parquet.Encoding, maxLvl int16, w utils.WriterAtWithLen) {
 	l.bitWidth = bits.Len64(uint64(maxLvl))
 	l.encoding = format.Encoding(encoding)
 	switch l.encoding {
diff --git a/go/parquet/internal/utils/bit_writer.go b/go/parquet/internal/utils/bit_writer.go
index 110f2326419ed..837a85d5541a0 100644
--- a/go/parquet/internal/utils/bit_writer.go
+++ b/go/parquet/internal/utils/bit_writer.go
@@ -56,16 +56,21 @@ func (w *WriterAtBuffer) WriteAt(p []byte, off int64) (n int, err error) {
 	return
 }
 
+func (w *WriterAtBuffer) Reserve(nbytes int) {
+	// no-op. We should not expand or otherwise modify the underlying buffer
+}
+
 // WriterAtWithLen is an interface for an io.WriterAt with a Len function
 type WriterAtWithLen interface {
 	io.WriterAt
 	Len() int
+	Reserve(int)
 }
 
 // BitWriter is a utility for writing values of specific bit widths to a stream
 // using a uint64 as a buffer to build up between flushing for efficiency.
 type BitWriter struct {
-	wr         io.WriterAt
+	wr         WriterAtWithLen
 	buffer     uint64
 	byteoffset int
 	bitoffset  uint
@@ -74,18 +79,19 @@ type BitWriter struct {
 
 // NewBitWriter initializes a new bit writer to write to the passed in interface
 // using WriteAt to write the appropriate offsets and values.
-func NewBitWriter(w io.WriterAt) *BitWriter {
+func NewBitWriter(w WriterAtWithLen) *BitWriter {
 	return &BitWriter{wr: w}
 }
 
-// ReserveBytes reserves the next aligned nbytes, skipping them and returning
+// SkipBytes reserves the next aligned nbytes, skipping them and returning
 // the offset to use with WriteAt to write to those reserved bytes. Used for
 // RLE encoding to fill in the indicators after encoding.
-func (b *BitWriter) ReserveBytes(nbytes int) int {
+func (b *BitWriter) SkipBytes(nbytes int) (int, error) {
 	b.Flush(true)
 	ret := b.byteoffset
 	b.byteoffset += nbytes
-	return ret
+	b.wr.Reserve(b.byteoffset)
+	return ret, nil
 }
 
 // WriteAt fulfills the io.WriterAt interface to write len(p) bytes from p
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index eed97b6d01fbb..bcb69fa8583cf 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -22,7 +22,6 @@ package utils
 import (
 	"bytes"
 	"encoding/binary"
-	"io"
 	"math"
 
 	"github.com/apache/arrow/go/v13/arrow/bitutil"
@@ -465,7 +464,7 @@ type RleEncoder struct {
 	indicatorBuffer [1]byte
 }
 
-func NewRleEncoder(w io.WriterAt, width int) *RleEncoder {
+func NewRleEncoder(w WriterAtWithLen, width int) *RleEncoder {
 	return &RleEncoder{
 		w:                      NewBitWriter(w),
 		buffer:                 make([]uint64, 0, 8),
@@ -521,7 +520,10 @@ func (r *RleEncoder) flushBuffered(done bool) (err error) {
 
 func (r *RleEncoder) flushLiteral(updateIndicator bool) (err error) {
 	if r.literalIndicatorOffset == -1 {
-		r.literalIndicatorOffset = r.w.ReserveBytes(1)
+		r.literalIndicatorOffset, err = r.w.SkipBytes(1)
+		if err != nil {
+			return
+		}
 	}
 
 	for _, val := range r.buffer {

From dcf913a368b1075111a690ab2c3e7dcb85f758b2 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Tue, 15 Aug 2023 16:14:49 +0100
Subject: [PATCH 165/749] GH-36726: [R] calling read_parquet on S3 connections
 results in error message being ignored (#37024)

### Rationale for this change

Valid error messages were being ignored and incorrect error messages were being displayed

### What changes are included in this PR?

I deleted a `tryCatch()` which was swallowing the error message.  I don't know why it was there, and removing it didn't break any tests, so whatever behaviour it aims to supported is untested, and it may have been unnecessary.

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #36726

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/io.R                           | 15 +++++----------
 r/tests/testthat/test-csv.R        |  9 +++++++++
 r/tests/testthat/test-ipc-stream.R |  9 +++++++++
 3 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/r/R/io.R b/r/R/io.R
index e952d656f8ca5..cde45cb6d35d9 100644
--- a/r/R/io.R
+++ b/r/R/io.R
@@ -249,16 +249,11 @@ make_readable_file <- function(file, mmap = TRUE, random_access = TRUE) {
       on.exit(unlink(tf))
     }
 
-    if (is_url(file)) {
-      file <- tryCatch(
-        {
-          fs_and_path <- FileSystem$from_uri(file)
-          fs_and_path$fs$OpenInputFile(fs_and_path$path)
-        },
-        error = function(e) {
-          MakeRConnectionInputStream(url(file, open = "rb"))
-        }
-      )
+    if (is_http_url(file)) {
+      file <- MakeRConnectionInputStream(url(file, open = "rb"))
+    } else if (is_url(file)) {
+      fs_and_path <- FileSystem$from_uri(file)
+      file <- fs_and_path$fs$OpenInputFile(fs_and_path$path)
     } else if (isTRUE(mmap)) {
       file <- mmap_open(file)
     } else {
diff --git a/r/tests/testthat/test-csv.R b/r/tests/testthat/test-csv.R
index e806a6680110f..38f79c63979f1 100644
--- a/r/tests/testthat/test-csv.R
+++ b/r/tests/testthat/test-csv.R
@@ -724,3 +724,12 @@ test_that("skip_rows and skip_rows_after_names option", {
     tibble::tibble(`1` = 3:4)
   )
 })
+
+test_that("Can read CSV files from a URL", {
+  skip_if_offline()
+  skip_on_cran()
+  csv_url <- "https://raw.githubusercontent.com/apache/arrow-testing/master/data/csv/aggregate_test_100.csv"
+  cu <- read_csv_arrow(csv_url)
+  expect_true(tibble::is_tibble(cu))
+  expect_identical(dim(cu), c(100L, 13L))
+})
diff --git a/r/tests/testthat/test-ipc-stream.R b/r/tests/testthat/test-ipc-stream.R
index c59c39ad90683..b24580213a0cf 100644
--- a/r/tests/testthat/test-ipc-stream.R
+++ b/r/tests/testthat/test-ipc-stream.R
@@ -43,3 +43,12 @@ test_that("write_ipc_stream errors for invalid input type", {
   bad_input <- Array$create(1:5)
   expect_snapshot_error(write_ipc_stream(bad_input, feather_file))
 })
+
+test_that("Can read IPC streams from a URL", {
+  skip_if_offline()
+  skip_on_cran()
+  ipc_url <- "https://github.com/apache/arrow-testing/raw/master/data/arrow-ipc-stream/integration/1.0.0-littleendian/generated_primitive.stream" #nolint
+  ipcu <- read_ipc_stream(ipc_url)
+  expect_true(tibble::is_tibble(ipcu))
+  expect_identical(dim(ipcu), c(37L, 30L))
+})

From 5c2393822233ff0be06a2226d8227df675fff2ef Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 15 Aug 2023 13:51:15 -0400
Subject: [PATCH 166/749] GH-37175: [MATLAB] Support creating
 `arrow.tabular.RecordBatch` instances from a list of `arrow.array.Array`
 values (#37176)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Right now, the only way to construct an `arrow.tabular.RecordBatch` is from a MATLAB `table`:

```matlab
>> t = table([1; 2; 3], ["A"; "B"; "C"], VariableNames=["Numbers", "Letters"]);

t =

  3×2 table

    Numbers    Letters
    _______    _______

       1         "A"
       2         "B"
       3         "C"

>> rb = arrow.recordbatch(t)

rb =

Numbers:   [
    1,
    2,
    3
  ]
Letters:   [
    "A",
    "B",
    "C"
  ]
```

The interface should also support creating `arrow.tabular.RecordBatch` instances from lists of `arrow.array.Array` values.

### What changes are included in this PR?

Added a new static method to `arrow.tabular.RecordBatch` called `fromArrays`. This method accepts a comma-separated list of `arrow.array.Array` values which it uses to construct an  `arrow.tabular.RecordBatch`. It also accepts an optional name-value pair called `ColumnNames`, which can be used to specify the column names in the record batch. If this name-value pair is not supplied, the column names default to `"Column1"`, `"Column2"`, etc.

**Example Usage:**
```matlab
>> a1 = arrow.array([1, 2, 3]);
>> a2 = arrow.array(["A", "B", "C"]);

>> rb1 = arrow.tabular.RecordBatch.fromArrays(a1, a2)

rb1 =

Column1:   [
    1,
    2,
    3
  ]
Column2:   [
    "A",
    "B",
    "C"
  ]

>> rb2 = arrow.tabular.RecordBatch.fromArrays(a1, a2, ColumnNames=["Numbers", "Letters"])

rb2 =

Numbers:   [
    1,
    2,
    3
  ]
Letters:   [
    "A",
    "B",
    "C"
  ]
```

### Are these changes tested?

Yes.

1. Added new test class `arrow/test/tabular/tValidateArrayLengths.m`
2. Added new test class `arrow/test/tabular/tValidateColumnNames.m`
3. Added new test cases to `arrow/test/tabular/tRecordBatch.m`

### Are there any user-facing changes?

Yes, users can now create `arrow.tabular.RecordBatch` instances using the static method `arrow.tabular.RecordBatch.fromArrays`.

* Closes: #37175

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+tabular/+internal/validateArrayLengths.m |  39 ++++++
 .../+tabular/+internal/validateColumnNames.m  |  25 ++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  25 ++++
 matlab/test/arrow/tabular/tRecordBatch.m      | 129 +++++++++++++++---
 .../arrow/tabular/tValidateArrayLengths.m     |  69 ++++++++++
 .../test/arrow/tabular/tValidateColumnNames.m |  56 ++++++++
 6 files changed, 322 insertions(+), 21 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/validateColumnNames.m
 create mode 100644 matlab/test/arrow/tabular/tValidateArrayLengths.m
 create mode 100644 matlab/test/arrow/tabular/tValidateColumnNames.m

diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m b/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
new file mode 100644
index 0000000000000..d891f12a64871
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
@@ -0,0 +1,39 @@
+%VALIDATEARRAYLENGTHS Validates all arrays in the cell array arrowArrays
+%have the same length.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function validateArrayLengths(arrowArrays)
+    
+    numArrays = numel(arrowArrays);
+
+    if numArrays == 0
+        return;
+    end
+
+    expectedLength = arrowArrays{1}.Length;
+
+    for ii = 2:numel(arrowArrays)
+        if arrowArrays{ii}.Length ~= expectedLength
+            errid = "arrow:tabular:UnequalArrayLengths";
+            msg = compose("Expected all arrays to have a length of %d," + ...
+                " but the array at position %d has a length of %d.", ...
+                expectedLength, ii, arrowArrays{ii}.Length);
+            error(errid, msg);
+        end
+    end
+end
+
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/validateColumnNames.m b/matlab/src/matlab/+arrow/+tabular/+internal/validateColumnNames.m
new file mode 100644
index 0000000000000..134533ea3ba38
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/validateColumnNames.m
@@ -0,0 +1,25 @@
+%VAIDATECOLUMNNAMES Validates columnNames has the expected number of
+%elements.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function validateColumnNames(columnNames, numColumns)
+    if numel(columnNames) ~= numColumns
+        errid = "arrow:tabular:WrongNumberColumnNames";
+        msg = compose("Expected ColumnNames to have %d values.", numColumns);
+        error(errid, msg);
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index fb978a09ec878..32d0b196f17ff 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -95,4 +95,29 @@ function displayScalarObject(obj)
             disp(obj.toString());
         end
     end
+
+    methods (Static, Access=public)
+        function recordBatch = fromArrays(arrowArrays, opts)
+            arguments(Repeating)
+                arrowArrays(1, 1) arrow.array.Array
+            end
+            arguments
+                opts.ColumnNames(1, :) string {mustBeNonmissing} = compose("Column%d", 1:numel(arrowArrays))
+            end
+
+            import arrow.tabular.internal.validateArrayLengths
+            import arrow.tabular.internal.validateColumnNames
+            import arrow.tabular.internal.getArrayProxyIDs
+            
+            numColumns = numel(arrowArrays);
+            validateArrayLengths(arrowArrays);
+            validateColumnNames(opts.ColumnNames, numColumns);
+
+            arrayProxyIDs = getArrayProxyIDs(arrowArrays);
+            args = struct(ArrayProxyIDs=arrayProxyIDs, ColumnNames=opts.ColumnNames);
+            proxyName = "arrow.tabular.proxy.RecordBatch";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            recordBatch = arrow.tabular.RecordBatch(proxy);
+        end
+    end
 end
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index e4ef649bd04b5..66c7ca5c4b8c8 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -27,28 +27,10 @@ function Basic(tc)
 
         function SupportedTypes(tc)
             % Create a table all supported MATLAB types.
-            TOriginal = table(int8   ([1, 2, 3]'), ...
-                              int16  ([1, 2, 3]'), ...
-                              int32  ([1, 2, 3]'), ...
-                              int64  ([1, 2, 3]'), ...
-                              uint8  ([1, 2, 3]'), ...
-                              uint16 ([1, 2, 3]'), ...
-                              uint32 ([1, 2, 3]'), ...
-                              uint64 ([1, 2, 3]'), ...
-                              logical([1, 0, 1]'), ...
-                              single ([1, 2, 3]'), ...
-                              double ([1, 2, 3]'), ...
-                              string (["A", "B", "C"]'), ...
-                              datetime(2023, 6, 28) + days(0:2)');
+            TOriginal = createTableWithAllSupportedTypes();
             arrowRecordBatch = arrow.recordbatch(TOriginal);
-            TConverted = arrowRecordBatch.toMATLAB();
-            tc.verifyEqual(TOriginal, TConverted);
-            for ii = 1:arrowRecordBatch.NumColumns
-                column = arrowRecordBatch.column(ii);
-                tc.verifyEqual(column.toMATLAB(), TOriginal{:, ii});
-                traits = arrow.type.traits.traits(string(class(TOriginal{:, ii})));
-                tc.verifyInstanceOf(column, traits.ArrayClassName);
-            end
+            expectedColumnNames = compose("Var%d", 1:13);
+            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
         end
 
         function ToMATLAB(tc)
@@ -135,5 +117,110 @@ function ErrorIfIndexIsNonPositive(tc)
             fcn = @() arrowRecordBatch.column(-1);
             tc.verifyError(fcn, "arrow:badsubscript:NonPositive");
         end
+
+        function FromArraysColumnNamesNotProvided(tc)
+        % Verify arrow.tabular.RecordBatch.fromArrays creates the expected
+        % RecordBatch when given a comma-separated list of
+        % arrow.array.Array values.
+            import arrow.tabular.RecordBatch
+
+            TOriginal = createTableWithAllSupportedTypes();
+
+            arrowArrays = cell([1 width(TOriginal)]);
+            for ii = 1:width(TOriginal)
+                arrowArrays{ii} = arrow.array(TOriginal.(ii));
+            end
+
+            arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:});
+            expectedColumnNames = compose("Column%d", 1:13);
+            TOriginal.Properties.VariableNames = expectedColumnNames;
+            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
+        end
+
+        function FromArraysWithColumnNamesProvided(tc)
+        % Verify arrow.tabular.RecordBatch.fromArrays creates the expected
+        % RecordBatch when given a comma-separated list of
+        % arrow.array.Array values and the ColumnNames nv-pair is provided.
+            import arrow.tabular.RecordBatch
+
+            TOriginal = createTableWithAllSupportedTypes();
+
+            arrowArrays = cell([1 width(TOriginal)]);
+            for ii = 1:width(TOriginal)
+                arrowArrays{ii} = arrow.array(TOriginal.(ii));
+            end
+
+            columnNames = string(char(65:77)')';
+            arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:}, ColumnNames=columnNames);
+            TOriginal.Properties.VariableNames = columnNames;
+            tc.verifyRecordBatch(arrowRecordBatch, columnNames, TOriginal);
+        end
+
+        function FromArraysUnequalArrayLengthsError(tc)
+        % Verify arrow.tabular.RecordBatch.fromArrays throws an error whose
+        % identifier is "arrow:tabular:UnequalArrayLengths" if the arrays
+        % provided don't all have the same length.
+            import arrow.tabular.RecordBatch
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B", "C"]);
+            fcn = @() RecordBatch.fromArrays(A1, A2);
+            tc.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+        end
+
+        function FromArraysWrongNumberColumnNamesError(tc)
+        % Verify arrow.tabular.RecordBatch.fromArrays throws an error whose
+        % identifier is "arrow:tabular:WrongNumberColumnNames" if the 
+        % ColumnNames provided doesn't have one element per array.
+            import arrow.tabular.RecordBatch
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B"]);
+            fcn = @() RecordBatch.fromArrays(A1, A2, columnNames=["A", "B", "C"]);
+            tc.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+        end
+
+        function FromArraysColumnNamesHasMissingString(tc)
+        % Verify arrow.tabular.RecordBatch.fromArrays throws an error whose
+        % identifier is "MATLAB:validators:mustBeNonmissing" if the 
+        % ColumnNames provided has a missing string value.
+            import arrow.tabular.RecordBatch
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B"]);
+            fcn = @() RecordBatch.fromArrays(A1, A2, columnNames=["A", missing]);
+            tc.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
+        end
     end
+
+    methods
+        function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedTable)
+            tc.verifyEqual(recordBatch.NumColumns, int32(width(expectedTable)));
+            tc.verifyEqual(recordBatch.ColumnNames, expectedColumnNames);
+            convertedTable = recordBatch.table();
+            tc.verifyEqual(convertedTable, expectedTable);
+             for ii = 1:recordBatch.NumColumns
+                column = recordBatch.column(ii);
+                tc.verifyEqual(column.toMATLAB(), expectedTable{:, ii});
+                traits = arrow.type.traits.traits(string(class(expectedTable{:, ii})));
+                tc.verifyInstanceOf(column, traits.ArrayClassName);
+             end
+        end
+    end
+end
+
+function T = createTableWithAllSupportedTypes()
+    T = table(int8   ([1, 2, 3]'), ...
+             int16  ([1, 2, 3]'), ...
+             int32  ([1, 2, 3]'), ...
+             int64  ([1, 2, 3]'), ...
+             uint8  ([1, 2, 3]'), ...
+             uint16 ([1, 2, 3]'), ...
+             uint32 ([1, 2, 3]'), ...
+             uint64 ([1, 2, 3]'), ...
+             logical([1, 0, 1]'), ...
+             single ([1, 2, 3]'), ...
+             double ([1, 2, 3]'), ...
+             string (["A", "B", "C"]'), ...
+             datetime(2023, 6, 28) + days(0:2)');
 end
diff --git a/matlab/test/arrow/tabular/tValidateArrayLengths.m b/matlab/test/arrow/tabular/tValidateArrayLengths.m
new file mode 100644
index 0000000000000..9ac62cce6f721
--- /dev/null
+++ b/matlab/test/arrow/tabular/tValidateArrayLengths.m
@@ -0,0 +1,69 @@
+%TVALIDATEARRAYLENGTHS Unit tests for
+%arrow.tabular.internal.validateArrayLengths.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tValidateArrayLengths < matlab.unittest.TestCase
+    
+    methods(Test)        
+        function ArraysWithEqualLength(testCase)
+            % Verify validateArrayLengths() does not error if all the
+            % arrays have the same length.
+
+            import arrow.tabular.internal.validateArrayLengths
+
+            a = arrow.array(["A", "B", "C"]);
+            b = arrow.array([true, false, true]);
+            c = arrow.array([1, 2, 3]);
+
+            % cell array with one element
+            fcn = @() validateArrayLengths({a});
+            testCase.verifyWarningFree(fcn);
+
+            % cell array with two elements
+            fcn = @() validateArrayLengths({a, b});
+            testCase.verifyWarningFree(fcn);
+            
+            % cell array with three elements
+            fcn = @() validateArrayLengths({a, b, c});
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function ArraysWithUnequalLengths(testCase)
+            % Verify validateArrayLengths() throws an error whose
+            % identifier is "arrow:tabular:UnequalArrayLengths" if
+            % all the arrays do not have the same length.
+            
+            import arrow.tabular.internal.validateArrayLengths
+
+            a = arrow.array(["A", "B", "C"]);
+            b = arrow.array([true, false, true, true]);
+            c = arrow.array([1, 2, 3]);
+
+            fcn = @() validateArrayLengths({a, b});
+            testCase.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+            
+            fcn = @() validateArrayLengths({b, a});
+            testCase.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+
+            fcn = @() validateArrayLengths({b, a, c});
+            testCase.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+
+            fcn = @() validateArrayLengths({a, c, b});
+            testCase.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tValidateColumnNames.m b/matlab/test/arrow/tabular/tValidateColumnNames.m
new file mode 100644
index 0000000000000..b21bfbcd63d9b
--- /dev/null
+++ b/matlab/test/arrow/tabular/tValidateColumnNames.m
@@ -0,0 +1,56 @@
+%TVALIDATECOLUMNNAMES Unit tests for
+% arrow.tabular.internal.validateColumnNames.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tValidateColumnNames < matlab.unittest.TestCase
+    
+    methods(Test)        
+        function ValidColumnNames(testCase)
+            % Verify validateColumnNames() does not error if the 
+            % column names array has the expected number of elements.
+
+            import arrow.tabular.internal.validateColumnNames
+
+            columnNames = ["A", "B", "C"];
+            fcn = @() validateColumnNames(columnNames, 3);
+            testCase.verifyWarningFree(fcn);
+
+            columnNames = string.empty(1, 0);
+            fcn = @() validateColumnNames(columnNames, 0);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function WrongNumberColumnNames(testCase)
+            % Verify validateColumnNames() errors if the column names
+            % array provided does not have the correct number of elements.
+            % The error thrown should have the identifier 
+            % "arrow:tabular:WrongNumberColumnNames";
+
+            import arrow.tabular.internal.validateColumnNames
+
+            columnNames = ["A", "B", "C"];
+            fcn = @() validateColumnNames(columnNames, 2);
+            testCase.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+
+            fcn = @() validateColumnNames(columnNames, 4);
+            testCase.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+
+            fcn = @() validateColumnNames(columnNames, 0);
+            testCase.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+        end
+    end
+end
\ No newline at end of file

From f3dec5c46727ff3b3dc6ec9343c97887fe0fc356 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 15 Aug 2023 14:00:44 -0400
Subject: [PATCH 167/749] GH-37181: [MATLAB] Remove outdated test class`
 tArrowCppCall.m` (#37185)

### Rationale for this change

Now that `featherread` and `featherwrite` have been re-implemented in terms of the new APIs (`matlab.internal.io.feather.Reader` in #37046 and `matlab.io.internal.feather.Writer` in #37045), we can start removing the MEX code. To avoid submitting a large pull request, we should break the work down into several smaller, incremental steps.

The first step should involve deleting the outdated test class `tArrowCppCall.m`. This test class will no longer be relevant once the MEX source code is removed.

### What changes are included in this PR?

1. Deleted the outdated test class `tArrowCppCall.m`

### Are these changes tested?

No tests necessary.

### Are there any user-facing changes?

No.

### Future Directions

1. Move the test cases in `test/tfeathermex.m` to `test/arrow/internal/io/feather/tRoundtrip.m`. These test cases directly call the MEX functions, so we will re-write the tests to utilize the `arrow.internal.io.feather.Reader` and `arrow.internal.io.feather.Writer` classes directly.
2. Delete `test/arrow/util/createVariablesAndMetadataStruct.m`
3. Delete `test/arrow/util/createTable.m`
4. Delete `test/arrow/util/featherMEXRoundTrip.m`
5. Delete `test/arrow/util/featherRoundTrip.m`
6. Remove MEX source code.
* Closes: #37181

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/test/tArrowCppCall.m | 61 -------------------------------------
 1 file changed, 61 deletions(-)
 delete mode 100644 matlab/test/tArrowCppCall.m

diff --git a/matlab/test/tArrowCppCall.m b/matlab/test/tArrowCppCall.m
deleted file mode 100644
index dbab0e78a962a..0000000000000
--- a/matlab/test/tArrowCppCall.m
+++ /dev/null
@@ -1,61 +0,0 @@
-classdef tArrowCppCall < matlab.unittest.TestCase
-    % Tests for arrow.cpp.call.
-
-    % Licensed to the Apache Software Foundation (ASF) under one or more
-    % contributor license agreements.  See the NOTICE file distributed with
-    % this work for additional information regarding copyright ownership.
-    % The ASF licenses this file to you under the Apache License, Version
-    % 2.0 (the "License"); you may not use this file except in compliance
-    % with the License.  You may obtain a copy of the License at
-    %
-    %   http://www.apache.org/licenses/LICENSE-2.0
-    %
-    % Unless required by applicable law or agreed to in writing, software
-    % distributed under the License is distributed on an "AS IS" BASIS,
-    % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-    % implied.  See the License for the specific language governing
-    % permissions and limitations under the License.
-
-    methods(TestClassSetup)
-       function addFeatherFunctionsToMATLABPath(testCase)
-            import matlab.unittest.fixtures.PathFixture
-            % Add Feather test utilities to the MATLAB path.
-            testCase.applyFixture(PathFixture('util'));
-            % arrow.cpp.call must be on the MATLAB path.
-            testCase.assertTrue(~isempty(which('arrow.cpp.call')), ...
-                '''arrow.cpp.call'' must be on the MATLAB path. Use ''addpath'' to add folders to the MATLAB path.');
-        end
-    end
-
-    methods(Test)
-        function UnknownCppFunctionError(testCase)
-        % Verifies arrow.cpp.call throws an error if an unkown C++ function name 
-        % is passed to it.
-            errID = "MATLAB:arrow:UnknownCppFunction";
-            fcn = @()arrow.cpp.call('NotAFunction');
-            testCase.verifyError(fcn, errID);
-        end
-
-        function TooFewInputArgumentsError(testCase)
-        % Verifies arrow.cpp.call throws an error if zero input arguments are
-        % passed it.
-            errID = "MATLAB:arrow:minrhs";
-            fcn = @()arrow.cpp.call;
-            testCase.verifyError(fcn, errID);
-        end
-
-        function InvalidFunctionNameDataTypeError(testCase)
-        % Verifies arrow.cpp.call throws an error if the first input argument is
-        % not a character vector.
-            errID = "MATLAB:arrow:FunctionNameDataType";
-            fcn = @()arrow.cpp.call(1);
-            testCase.verifyError(fcn, errID);
-
-            fcn = @()arrow.cpp.call(categorical);
-            testCase.verifyError(fcn, errID);
-
-            fcn = @()arrow.cpp.call(datetime(2021, 9, 10));
-            testCase.verifyError(fcn, errID);
-        end
-    end
-end

From 0432aaed4deae54c6a9f82e3caee949fc9639f97 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 15 Aug 2023 14:43:00 -0400
Subject: [PATCH 168/749] GH-37182: [MATLAB] Add public `Schema` property to
 MATLAB `arrow.tabular.RecordBatch` class (#37184)

### Rationale for this change

To make it possible to query the field types and names of a `RecordBatch`, this pull request adds a public `Schema` property to the MATLAB `arrow.tabular.RecordBatch` class.

### What changes are included in this PR?

1. Added a new public `Schema` property to the `arrow.tabular.RecordBatch` MATLAB class.

```matlab
>> t = table(["A","B","C"]',[1,2,3]',[true,false,true]',VariableNames=["A", "B", "C"])

t =

  3x3 table

     A     B      C
    ___    _    _____

    "A"    1    true
    "B"    2    false
    "C"    3    true

>> rb = arrow.recordbatch(t)

rb =

A:   [
    "A",
    "B",
    "C"
  ]
B:   [
    1,
    2,
    3
  ]
C:   [
    true,
    false,
    true
  ]

>> schema = rb.Schema

schema =

A: string
B: double
C: bool

>> schema.field(2).Name

ans =

    "B"

>> schema.field(2).Type

ans =

  Float64Type with properties:

    ID: Float64
```

### Are these changes tested?

Yes.

1. Added new test cases verifying that the `Schema` property works as expected to `tRecordBatch.m`.

### Are there any user-facing changes?

Yes.

1. There is now a public `Schema` property on the `arrow.tabular.RecordBatch` MATLAB class.
* Closes: #37182

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../matlab/tabular/proxy/record_batch.cc      | 17 +++++++++++
 .../arrow/matlab/tabular/proxy/record_batch.h |  1 +
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  7 +++++
 matlab/test/arrow/tabular/tRecordBatch.m      | 30 ++++++++++++++++++-
 4 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index e159e926ec5ae..c526bfc81d9f7 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -22,6 +22,7 @@
 
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
+#include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/type.h"
 #include "arrow/util/utf8.h"
 
@@ -54,6 +55,7 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(RecordBatch, numColumns);
         REGISTER_METHOD(RecordBatch, columnNames);
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
+        REGISTER_METHOD(RecordBatch, getSchema);
     }
 
     std::shared_ptr<arrow::RecordBatch> RecordBatch::unwrap() {
@@ -163,4 +165,19 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = array_proxy_id_mda;
         context.outputs[1] = array_type_id_mda;
     }
+
+    void RecordBatch::getSchema(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using SchemaProxy = arrow::matlab::tabular::proxy::Schema;
+        mda::ArrayFactory factory;
+
+        const auto schema = record_batch->schema();
+        const auto schema_proxy = std::make_shared<SchemaProxy>(std::move(schema));
+        const auto schema_proxy_id = ProxyManager::manageProxy(schema_proxy);
+        const auto schema_proxy_id_mda = factory.createScalar(schema_proxy_id);
+
+        context.outputs[0] = schema_proxy_id_mda;
+    }
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index b8c038816b34e..3ffb8769a1c2d 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -38,6 +38,7 @@ namespace arrow::matlab::tabular::proxy {
             void numColumns(libmexclass::proxy::method::Context& context);
             void columnNames(libmexclass::proxy::method::Context& context);
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
+            void getSchema(libmexclass::proxy::method::Context& context);
 
             std::shared_ptr<arrow::RecordBatch> record_batch;
     };
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 32d0b196f17ff..8e1fc39ab70ae 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -21,6 +21,7 @@
     properties (Dependent, SetAccess=private, GetAccess=public)
         NumColumns
         ColumnNames
+        Schema
     end
 
     properties (Hidden, SetAccess=private, GetAccess=public)
@@ -44,6 +45,12 @@
             columnNames = obj.Proxy.columnNames();
         end
 
+        function schema = get.Schema(obj)
+            proxyID = obj.Proxy.getSchema();
+            proxy = libmexclass.proxy.Proxy(Name="arrow.tabular.proxy.Schema", ID=proxyID);
+            schema = arrow.tabular.Schema(proxy);
+        end
+
         function arrowArray = column(obj, idx)
             import arrow.internal.validate.*
 
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 66c7ca5c4b8c8..a5ab03f3bb751 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -191,6 +191,34 @@ function FromArraysColumnNamesHasMissingString(tc)
             fcn = @() RecordBatch.fromArrays(A1, A2, columnNames=["A", missing]);
             tc.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
         end
+
+        function Schema(tc)
+        % Verify that the public Schema property returns an approprate
+        % instance of arrow.tabular.Schema.
+            t = table(["A"; "B"; "C"], ...
+                      [1; 2; 3], ...
+                      [true; false; true], ...
+                      VariableNames=["A", "B", "C"]);
+            recordBatch = arrow.recordbatch(t);
+            schema = recordBatch.Schema;
+            tc.verifyEqual(schema.NumFields, int32(3));
+            tc.verifyEqual(schema.field(1).Type.ID, arrow.type.ID.String);
+            tc.verifyEqual(schema.field(1).Name, "A");
+            tc.verifyEqual(schema.field(2).Type.ID, arrow.type.ID.Float64);
+            tc.verifyEqual(schema.field(2).Name, "B");
+            tc.verifyEqual(schema.field(3).Type.ID, arrow.type.ID.Boolean);
+            tc.verifyEqual(schema.field(3).Name, "C");
+        end
+
+        function SchemaNoSetter(tc)
+        % Verify that trying to set the value of the public Schema property
+        % results in an error of type "MATLAB:class:SetProhibited".
+            t = table([1; 2; 3]);
+            recordBatch = arrow.recordbatch(t);
+            tc.verifyError(@() setfield(recordBatch, "Schema", "Value"), ...
+                "MATLAB:class:SetProhibited");
+        end
+
     end
 
     methods
@@ -210,7 +238,7 @@ function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedTable)
 end
 
 function T = createTableWithAllSupportedTypes()
-    T = table(int8   ([1, 2, 3]'), ...
+    T = table(int8  ([1, 2, 3]'), ...
              int16  ([1, 2, 3]'), ...
              int32  ([1, 2, 3]'), ...
              int64  ([1, 2, 3]'), ...

From 7c8c2fb1d7ca487bb52ecd1854e3c6906f21875a Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 15 Aug 2023 16:55:46 -0400
Subject: [PATCH 169/749] GH-37187: [MATLAB] Re-implement `tfeathermex.m` tests
 in terms of new internal Feather Reader and Writer objects (#37189)

### Rationale for this change

Now that we have new internal Feather V1 `arrow.internal.io.feather.Reader` and `arrow.internal.io.feather.Writer` objects, we can re-implement the `tfeathermex.m` tests in terms of calls to these new internal APIs. As part of this change, we can also move these test cases into `matlab/test/arrow/io/feather/tRoundTrip.m` and delete the old `tfeathermex.m` file. Deleting the old Feather MEX tests will allow us to also delete the old Feather MEX code.

### What changes are included in this PR?

1. Moved test cases `NumericDatatypesNulls` and `InvalidMATLABTableVariableNames` from `test/tfeathermex.m` to `test/arrow/internal/io/feather/tRoundTrip.m`
2. Deleted `test/tfeathermex.m`
3. Deleted obsolete test utility `test/util/createVariablesAndMetadataStructs.m`
4. Deleted obsolete test utility `test/util/featherMEXRoundTrip.m`

### Are these changes tested?

Yes. All tests pass.

### Are there any user-facing changes?

No.

### Future Directions

1. Delete the MEX source code from the interface.
2. Move `test/util/createTable.m` and `test/util/featherRoundTrip.m` into package functions underneath `arrow.internal.test.*` (See #37188)
* Closes: #37187

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/test/arrow/io/feather/tRoundTrip.m     | 66 ++++++++++++-
 matlab/test/tfeathermex.m                     | 67 -------------
 .../util/createVariablesAndMetadataStructs.m  | 97 -------------------
 matlab/test/util/featherMEXRoundTrip.m        | 22 -----
 4 files changed, 65 insertions(+), 187 deletions(-)
 delete mode 100644 matlab/test/tfeathermex.m
 delete mode 100644 matlab/test/util/createVariablesAndMetadataStructs.m
 delete mode 100644 matlab/test/util/featherMEXRoundTrip.m

diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
index f361a4543b8e4..457bdc65e5668 100644
--- a/matlab/test/arrow/io/feather/tRoundTrip.m
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -52,6 +52,70 @@ function Basic(testCase)
 
             testCase.verifyEqual(tableWrite, tableRead);
         end
-    end
 
+        function NumericDatatypesNulls(testCase)
+            % Verify integers with null values are roundtripped correctly.
+            import matlab.unittest.fixtures.TemporaryFolderFixture
+            import arrow.internal.io.feather.*
+            import arrow.tabular.RecordBatch
+
+            fixture = testCase.applyFixture(TemporaryFolderFixture);
+            filename = fullfile(fixture.Folder, "temp.feather");
+
+            uint8Array = arrow.array(uint8([1, 2, 3, 4, 5]), Valid=[1, 3, 4]);
+            int16Array = arrow.array(uint8([1, 2, 3, 4, 5]), Valid=[3, 5]);
+            inputRecordBatch = RecordBatch.fromArrays(uint8Array, int16Array);
+
+            writer = Writer(filename);
+            writer.write(inputRecordBatch);
+
+            reader = Reader(filename);
+            outputRecordBatch = reader.read();
+
+            testCase.verifyEqual(outputRecordBatch.NumColumns, inputRecordBatch.NumColumns);
+            testCase.verifyEqual(outputRecordBatch.ColumnNames, inputRecordBatch.ColumnNames);
+            
+            outColumn1 = outputRecordBatch.column(1);
+            testCase.verifyEqual(outColumn1.Valid, uint8Array.Valid);
+            testCase.verifyEqual(toMATLAB(outColumn1), toMATLAB(uint8Array));
+
+            outColumn2 = outputRecordBatch.column(2);
+            testCase.verifyEqual(outColumn2.Valid, int16Array.Valid);
+            testCase.verifyEqual(toMATLAB(outColumn2), toMATLAB(int16Array));
+        end
+
+        function InvalidMATLABTableVariableNames(testCase)
+            import matlab.unittest.fixtures.TemporaryFolderFixture
+            import arrow.internal.io.feather.*
+            import arrow.tabular.RecordBatch
+
+            fixture = testCase.applyFixture(TemporaryFolderFixture);
+            filename = fullfile(fixture.Folder, "temp.feather");
+
+            doubleArray = arrow.array([1, 2, 3, 4, 5]); 
+            stringArray = arrow.array(["A", "B", "C", "D", "E"]);
+
+            % Create a RecordBatch whose first column name is an invalid
+            % variable name for a MATLAB table.
+            inputRecordBatch = RecordBatch.fromArrays(doubleArray, stringArray, ...
+                ColumnNames=[":", "Valid"]);
+
+            writer = Writer(filename);
+            writer.write(inputRecordBatch);
+
+            % Verify the RecordBatch returned by read has the same
+            % ColumnNames as the original RecordBatch.
+            reader = Reader(filename);
+            outputRecordBatch = reader.read();
+            testCase.verifyEqual(outputRecordBatch.ColumnNames, inputRecordBatch.ColumnNames);
+            
+            % Verify the VariableNames property in the table returned by
+            % featherread has been modified and that 
+            % VariableDescriptions is set property.
+            outputTable = featherread(filename);
+            testCase.verifyEqual(outputTable.Properties.VariableNames, {':_1', 'Valid'});
+            testCase.verifyEqual(outputTable.Properties.VariableDescriptions, ...
+                {'Original variable name: '':''', ''});
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/tfeathermex.m b/matlab/test/tfeathermex.m
deleted file mode 100644
index 8b6b87aab1072..0000000000000
--- a/matlab/test/tfeathermex.m
+++ /dev/null
@@ -1,67 +0,0 @@
-classdef tfeathermex < matlab.unittest.TestCase
-    % Tests for MATLAB featherreadmex and featherwritemex.
-    
-    % Licensed to the Apache Software Foundation (ASF) under one or more
-    % contributor license agreements.  See the NOTICE file distributed with
-    % this work for additional information regarding copyright ownership.
-    % The ASF licenses this file to you under the Apache License, Version
-    % 2.0 (the "License"); you may not use this file except in compliance
-    % with the License.  You may obtain a copy of the License at
-    %
-    %   http://www.apache.org/licenses/LICENSE-2.0
-    %
-    % Unless required by applicable law or agreed to in writing, software
-    % distributed under the License is distributed on an "AS IS" BASIS,
-    % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-    % implied.  See the License for the specific language governing
-    % permissions and limitations under the License.
-    
-    methods(TestClassSetup)
-        
-        function addFeatherFunctionsToMATLABPath(testCase)
-            import matlab.unittest.fixtures.PathFixture
-            % Add Feather test utilities to the MATLAB path.
-            testCase.applyFixture(PathFixture('util'));
-            % arrow.cpp.call must be on the MATLAB path.
-            testCase.assertTrue(~isempty(which('arrow.cpp.call')), ...
-                '''arrow.cpp.call'' must be on the MATLAB path. Use ''addpath'' to add folders to the MATLAB path.');
-        end
-    end
-    
-    methods(TestMethodSetup)
-    
-        function setupTempWorkingDirectory(testCase)
-            import matlab.unittest.fixtures.WorkingFolderFixture;
-            testCase.applyFixture(WorkingFolderFixture);
-        end
-    end
-    
-    methods(Test)
-        
-        function NumericDatatypesNulls(testCase)
-            filename = fullfile(pwd, 'temp.feather');
-            
-            [expectedVariables, expectedMetadata] = createVariablesAndMetadataStructs();
-            [actualVariables, ~] = featherMEXRoundTrip(filename, expectedVariables, expectedMetadata);
-            testCase.verifyEqual([actualVariables.Valid], [expectedVariables.Valid]);
-        end
-        
-        function InvalidMATLABTableVariableNames(testCase)
-            filename = fullfile(pwd, 'temp.feather');
-            
-            % Create a table with an invalid MATLAB table variable name.
-            invalidVariable = arrow.util.createVariableStruct('double', 1, true, ':');
-            validVariable = arrow.util.createVariableStruct('double', 1, true, 'Valid');
-            variables = [invalidVariable, validVariable];
-            metadata = arrow.util.createMetadataStruct(1, 2);
-            arrow.cpp.call('featherwrite', filename, variables, metadata);
-            t = featherread(filename);
-            
-            testCase.verifyEqual(t.Properties.VariableNames{1}, ':_1');
-            testCase.verifyEqual(t.Properties.VariableNames{2}, 'Valid');
-            
-            testCase.verifyEqual(t.Properties.VariableDescriptions{1}, 'Original variable name: '':''');
-            testCase.verifyEqual(t.Properties.VariableDescriptions{2}, '');
-        end 
-    end
-end
diff --git a/matlab/test/util/createVariablesAndMetadataStructs.m b/matlab/test/util/createVariablesAndMetadataStructs.m
deleted file mode 100644
index a26bfe45a3e25..0000000000000
--- a/matlab/test/util/createVariablesAndMetadataStructs.m
+++ /dev/null
@@ -1,97 +0,0 @@
-function [variables, metadata] = createVariablesAndMetadataStructs()
-% CREATEVARIABLESANDMETADATASTRUCTS Helper function for creating
-% Feather MEX variables and metadata structs.
-
-% Licensed to the Apache Software Foundation (ASF) under one or more
-% contributor license agreements.  See the NOTICE file distributed with
-% this work for additional information regarding copyright ownership.
-% The ASF licenses this file to you under the Apache License, Version
-% 2.0 (the "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing, software
-% distributed under the License is distributed on an "AS IS" BASIS,
-% WITHOUT 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 arrow.util.*;
-
-type = 'uint8';
-data = uint8([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'uint8';
-uint8Variable = createVariableStruct(type, data, valid, name);
-
-type = 'uint16';
-data = uint16([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'uint16';
-uint16Variable = createVariableStruct(type, data, valid, name);
-
-type = 'uint32';
-data = uint32([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'uint32';
-uint32Variable = createVariableStruct(type, data, valid, name);
-
-type = 'uint64';
-data = uint64([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'uint64';
-uint64Variable = createVariableStruct(type, data, valid, name);
-
-type = 'int8';
-data = int8([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'int8';
-int8Variable = createVariableStruct(type, data, valid, name);
-
-type = 'int16';
-data = int16([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'int16';
-int16Variable = createVariableStruct(type, data, valid, name);
-
-type = 'int32';
-data = int32([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'int32';
-int32Variable = createVariableStruct(type, data, valid, name);
-
-type = 'int64';
-data = int64([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'int64';
-int64Variable = createVariableStruct(type, data, valid, name);
-
-type = 'single';
-data = single([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'single';
-singleVariable = createVariableStruct(type, data, valid, name);
-
-type = 'double';
-data = double([1; 2; 3]);
-valid = logical([0; 1; 0]);
-name = 'double';
-doubleVariable = createVariableStruct(type, data, valid, name);
-
-variables = [uint8Variable, ...
-             uint16Variable, ...
-             uint32Variable, ...
-             uint64Variable, ...
-             int8Variable, ...
-             int16Variable, ...
-             int32Variable, ...
-             int64Variable, ...
-             singleVariable, ...
-             doubleVariable];
-
-numRows = 3;
-numVariables = length(variables);
-
-metadata = createMetadataStruct(numRows, numVariables);
-end
diff --git a/matlab/test/util/featherMEXRoundTrip.m b/matlab/test/util/featherMEXRoundTrip.m
deleted file mode 100644
index 0d40799316cb5..0000000000000
--- a/matlab/test/util/featherMEXRoundTrip.m
+++ /dev/null
@@ -1,22 +0,0 @@
-function [variablesOut, metadataOut] = featherMEXRoundTrip(filename, variablesIn, metadataIn)
-% FEATHERMEXROUNDTRIP Helper function for round tripping variables
-% and metadata structs to a Feather file.
-
-% Licensed to the Apache Software Foundation (ASF) under one or more
-% contributor license agreements.  See the NOTICE file distributed with
-% this work for additional information regarding copyright ownership.
-% The ASF licenses this file to you under the Apache License, Version
-% 2.0 (the "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing, software
-% distributed under the License is distributed on an "AS IS" BASIS,
-% WITHOUT 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.cpp.call('featherwrite', filename, variablesIn, metadataIn);
-[variablesOut, metadataOut] = arrow.cpp.call('featherread', filename);
-end

From 01a9f72727c1ea80564a5a12ea64727774df4be7 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 15 Aug 2023 19:44:58 -0400
Subject: [PATCH 170/749] GH-37179: [MATLAB] Add a test utility that creates a
 MATLAB `table` containing all supported types (#37191)

### Rationale for this change

It would be helpful it we had a test utility that created a MATLAB `table` containing all the supported types. This would help avoid code duplication in our tests.

### What changes are included in this PR?

1. Added a new utility named `arrow.internal.test.tabular.createTableWithSupportedTypes()`
2. Updated `tRecordBatch.m` to use this utility.
3. Updated `tfeather.m` to use this utility.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #37179

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../+tabular/createTableWithSupportedTypes.m  | 54 +++++++++++++++
 matlab/test/arrow/tabular/tRecordBatch.m      | 31 +++------
 matlab/test/tfeather.m                        | 64 +++++++++++------
 matlab/test/util/createTable.m                | 68 -------------------
 4 files changed, 109 insertions(+), 108 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
 delete mode 100644 matlab/test/util/createTable.m

diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
new file mode 100644
index 0000000000000..c69aef35d18b3
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
@@ -0,0 +1,54 @@
+%CREATETABLEWITHSUPPORTEDTYPES Creates a MATLAB table containing all the
+%MATLAB types that can be converted into arrow arrays.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function T = createTableWithSupportedTypes(opts)
+    arguments
+        opts.NumRows(1, 1) {mustBeFinite, mustBeNonnegative} = 3;  
+    end
+
+    numRows = opts.NumRows;
+
+    variableNames = ["uint8", ...
+                     "uint16", ...
+                     "uint32", ...
+                     "uint64", ...
+                     "int8", ...
+                     "int16", ...
+                     "int32", ...
+                     "int64", ...
+                     "logical", ...
+                     "single", ...
+                     "double", ...
+                     "string", ...
+                     "datetime"];
+
+    T = table(uint8   ((1:numRows)'), ...
+              uint16  ((1:numRows)'), ...
+              uint32  ((1:numRows)'), ...
+              uint64  ((1:numRows)'), ...
+              int8    ((1:numRows)'), ...
+              int16   ((1:numRows)'), ...
+              int32   ((1:numRows)'), ...
+              int64   ((1:numRows)'), ...
+              logical ((1:numRows)'), ...
+              single  ((1:numRows)'), ...
+              double  ((1:numRows)'), ...
+              string  ((1:numRows)'), ...
+              datetime(2023, 6, 28) + days(0:numRows-1)', ...
+              VariableNames=variableNames);
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index a5ab03f3bb751..66461b29c1dd6 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -27,9 +27,11 @@ function Basic(tc)
 
         function SupportedTypes(tc)
             % Create a table all supported MATLAB types.
-            TOriginal = createTableWithAllSupportedTypes();
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
+            TOriginal = createTableWithSupportedTypes();
             arrowRecordBatch = arrow.recordbatch(TOriginal);
-            expectedColumnNames = compose("Var%d", 1:13);
+            expectedColumnNames = string(TOriginal.Properties.VariableNames);
             tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
         end
 
@@ -123,8 +125,9 @@ function FromArraysColumnNamesNotProvided(tc)
         % RecordBatch when given a comma-separated list of
         % arrow.array.Array values.
             import arrow.tabular.RecordBatch
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
-            TOriginal = createTableWithAllSupportedTypes();
+            TOriginal = createTableWithSupportedTypes();
 
             arrowArrays = cell([1 width(TOriginal)]);
             for ii = 1:width(TOriginal)
@@ -132,7 +135,7 @@ function FromArraysColumnNamesNotProvided(tc)
             end
 
             arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:});
-            expectedColumnNames = compose("Column%d", 1:13);
+            expectedColumnNames = compose("Column%d", 1:width(TOriginal));
             TOriginal.Properties.VariableNames = expectedColumnNames;
             tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
         end
@@ -142,15 +145,16 @@ function FromArraysWithColumnNamesProvided(tc)
         % RecordBatch when given a comma-separated list of
         % arrow.array.Array values and the ColumnNames nv-pair is provided.
             import arrow.tabular.RecordBatch
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
-            TOriginal = createTableWithAllSupportedTypes();
+            TOriginal = createTableWithSupportedTypes();
 
             arrowArrays = cell([1 width(TOriginal)]);
             for ii = 1:width(TOriginal)
                 arrowArrays{ii} = arrow.array(TOriginal.(ii));
             end
 
-            columnNames = string(char(65:77)')';
+            columnNames = compose("MyVar%d", 1:numel(arrowArrays));
             arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:}, ColumnNames=columnNames);
             TOriginal.Properties.VariableNames = columnNames;
             tc.verifyRecordBatch(arrowRecordBatch, columnNames, TOriginal);
@@ -237,18 +241,3 @@ function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedTable)
     end
 end
 
-function T = createTableWithAllSupportedTypes()
-    T = table(int8  ([1, 2, 3]'), ...
-             int16  ([1, 2, 3]'), ...
-             int32  ([1, 2, 3]'), ...
-             int64  ([1, 2, 3]'), ...
-             uint8  ([1, 2, 3]'), ...
-             uint16 ([1, 2, 3]'), ...
-             uint32 ([1, 2, 3]'), ...
-             uint64 ([1, 2, 3]'), ...
-             logical([1, 0, 1]'), ...
-             single ([1, 2, 3]'), ...
-             double ([1, 2, 3]'), ...
-             string (["A", "B", "C"]'), ...
-             datetime(2023, 6, 28) + days(0:2)');
-end
diff --git a/matlab/test/tfeather.m b/matlab/test/tfeather.m
index 8cdbef27fad80..9d86dff5fd5cc 100755
--- a/matlab/test/tfeather.m
+++ b/matlab/test/tfeather.m
@@ -39,28 +39,34 @@ function setupTempWorkingDirectory(testCase)
     methods(Test)
 
         function NumericDatatypesNoNulls(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             expectedTable = featherRoundTrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NumericDatatypesWithNaNRow(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTable;
+            t = createTableWithSupportedTypes;
+            t = removevars(t, ["logical", "string", "datetime"]);
             
-            variableNames = {'single', ...
-                             'double', ...
+            variableNames = {'uint8', ...
+                             'uint16', ...
+                             'uint32', ...
+                             'uint64', ...
                              'int8', ...
                              'int16', ...
                              'int32', ...
                              'int64', ...
-                             'uint8', ...
-                             'uint16', ...
-                             'uint32', ...
-                             'uint64'};
+                             'single', ...
+                             'double', ...
+                             };
+
             variableTypes = repmat({'double'}, 10, 1)';
             numRows = 1;
             numVariables = 10;
@@ -75,9 +81,11 @@ function NumericDatatypesWithNaNRow(testCase)
         end
 
         function NumericDatatypesWithNaNColumns(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             actualTable.double = [NaN; NaN; NaN];
             actualTable.int64  = [NaN; NaN; NaN];
             
@@ -86,9 +94,11 @@ function NumericDatatypesWithNaNColumns(testCase)
         end
         
         function NumericDatatypesWithExpInfSciNotation(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             actualTable.single(2) = 1.0418e+06;
             
             actualTable.double(1) = Inf;
@@ -101,20 +111,24 @@ function NumericDatatypesWithExpInfSciNotation(testCase)
         end
         
         function IgnoreRowVarNames(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             time = {'day1', 'day2', 'day3'};
             actualTable.Properties.RowNames = time;
             expectedTable = featherRoundTrip(filename, actualTable);
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NotFeatherExtension(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.txt');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             expectedTable = featherRoundTrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
@@ -128,9 +142,11 @@ function EmptyTable(testCase)
         end
 
         function zeroByNTable(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             actualTable([1, 2], :) = [];
             expectedTable = featherRoundTrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
@@ -147,9 +163,11 @@ function ErrorIfUnableToOpenFile(testCase)
         end
 
         function ErrorIfCorruptedFeatherFile(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTable;
+            t = createTableWithSupportedTypes;
             featherwrite(filename, t);
             
             fileID = fopen(filename, 'w');
@@ -160,15 +178,19 @@ function ErrorIfCorruptedFeatherFile(testCase)
         end
         
         function ErrorIfInvalidFilenameDatatype(testCase)
-            t = createTable;
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
+            t = createTableWithSupportedTypes;
             
             testCase.verifyError(@() featherwrite({table}, t), 'MATLAB:validation:UnableToConvert');
         end
 
         function ErrorIfTooManyInputs(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTable;
+            t = createTableWithSupportedTypes;
 
             testCase.verifyError(@() featherwrite(filename, t, 'SomeValue', 'SomeOtherValue'), 'MATLAB:TooManyInputs');
             testCase.verifyError(@() featherread(filename, 'SomeValue', 'SomeOtherValue'), 'MATLAB:TooManyInputs');
@@ -194,9 +216,11 @@ function ErrorIfMultiColVarExist(testCase)
         end
         
         function UnsupportedMATLABDatatypes(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
 
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             calendarDurationVariable = [calendarDuration(1, 7, 9); ...
                                         calendarDuration(2, 1, 1); ...
                                         calendarDuration(5, 3, 2)];
@@ -206,9 +230,11 @@ function UnsupportedMATLABDatatypes(testCase)
         end
         
         function NumericComplexUnsupported(testCase)
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+
             filename = fullfile(pwd, 'temp.feather');
 
-            actualTable = createTable;
+            actualTable = createTableWithSupportedTypes;
             actualTable.single(1) = 1.0418 + 2i;
             actualTable.double(2) = exp(9) + 5i;
             actualTable.int64(2) = 1.0418e+03;
diff --git a/matlab/test/util/createTable.m b/matlab/test/util/createTable.m
deleted file mode 100644
index 2bf67c68c3339..0000000000000
--- a/matlab/test/util/createTable.m
+++ /dev/null
@@ -1,68 +0,0 @@
-function t = createTable()
-% CREATETABLE Helper function for creating test table.
-
-% Licensed to the Apache Software Foundation (ASF) under one or more
-% contributor license agreements.  See the NOTICE file distributed with
-% this work for additional information regarding copyright ownership.
-% The ASF licenses this file to you under the Apache License, Version
-% 2.0 (the "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing, software
-% distributed under the License is distributed on an "AS IS" BASIS,
-% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-% implied.  See the License for the specific language governing
-% permissions and limitations under the License.
-
-variableNames = {'uint8', ...
-                 'uint16', ...
-                 'uint32', ...
-                 'uint64', ...
-                 'int8', ...
-                 'int16', ...
-                 'int32', ...
-                 'int64', ...
-                 'single', ...
-                 'double'};
-
-variableTypes = {'uint8', ...
-                 'uint16', ...
-                 'uint32', ...
-                 'uint64', ...
-                 'int8', ...
-                 'int16', ...
-                 'int32', ...
-                 'int64', ...
-                 'single', ...
-                 'double'};
-
-uint8Data  = uint8([1; 2; 3]);
-uint16Data = uint16([1; 2; 3]);
-uint32Data = uint32([1; 2; 3]);
-uint64Data = uint64([1; 2; 3]);
-int8Data   = int8([1; 2; 3]);
-int16Data  = int16([1; 2; 3]);
-int32Data  = int32([1; 2; 3]);
-int64Data  = int64([1; 2; 3]);
-singleData = single([1/2; 1/4; 1/8]);
-doubleData = double([1/10; 1/100; 1/1000]);
-
-numRows = 3;
-numVariables = 10;
-
-t = table('Size', [numRows, numVariables], 'VariableTypes', variableTypes, 'VariableNames', variableNames);
-
-t.uint8  = uint8Data;
-t.uint16 = uint16Data;
-t.uint32 = uint32Data;
-t.uint64 = uint64Data;
-t.int8   = int8Data;
-t.int16  = int16Data;
-t.int32  = int32Data;
-t.int64  = int64Data;
-t.single = singleData;
-t.double = doubleData;
-
-end
\ No newline at end of file

From 3e7b35bacca776fbf2e3e313e32d872b73635c87 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Tue, 15 Aug 2023 21:09:18 -0300
Subject: [PATCH 171/749] GH-36969: [R] Disable GCS by default when doing a
 bundled build on gcc-13 (#37147)

### Rationale for this change

Currently a naive `install.packages("arrow")` will result in a failed build if gcc-13 is the compiler. This is because we include GCS by default on this type of build (bundled). CRAN's check farm includes at least one system where gcc-13 is the compiler and so we can't error or suggest a user workaround.

### What changes are included in this PR?

This PR explicitly sets the relevant environment variable if the compiler version string contains "g++" and "13.XX.XX". This is admittedly crude; however, the alternative of updating Abseil results in a cascading set of changes that may break other parts of Arrow. Few if any actual users will build the Arrow R package from source using gcc-13, so this has a much lower footprint (and a workaround: you can just set the ARROW_GCS environment variable + custom abseil location yourself before building if you do, in fact, want to attempt this).

### Are these changes tested?

Tested via crossbow (see below).

### Are there any user-facing changes?

No.
* Closes: #36969

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 r/configure | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/r/configure b/r/configure
index a0f75f8ddb5cd..0586cbe071007 100755
--- a/r/configure
+++ b/r/configure
@@ -100,6 +100,21 @@ if [ ! "`${R_HOME}/bin/R CMD config CXX17`" ]; then
   exit 1
 fi
 
+# GH-36969: The version of Abseil used in the bundled build won't build on
+# gcc-13. As a workaround for the 13.0.0 release, explicitly set
+# ARROW_WITH_GOOGLE_CLOUD_CPP to OFF (if not already set)
+if [ -z "$ARROW_GCS" ]; then
+  CXX17=`${R_HOME}/bin/R CMD config CXX17`
+  CXX17_VERSION=`$CXX17 --version`
+  if echo "$CXX17_VERSION" | grep -e "g++" > /dev/null ; then
+    if echo "$CXX17_VERSION" | grep -e "13.[0-9]\+.[0-9]\+" > /dev/null ; then
+      echo "*** Disabling Arrow build with GCS on gcc-13."
+      echo "*** Set ARROW_GCS=ON to explicitly enable."
+      export ARROW_GCS="OFF"
+    fi
+  fi
+fi
+
 # Test if pkg-config is available to use
 if ${PKG_CONFIG} --version >/dev/null 2>&1; then
   PKG_CONFIG_AVAILABLE="true"

From f3010bac94cbd588ecebd6e7839f9d56e97b1a9b Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 16 Aug 2023 11:14:05 +0900
Subject: [PATCH 172/749] GH-37141: [GLib][FlightRPC] Add more
 ArrowFlight::ClientOptions properties (#37142)

### Rationale for this change

ArrowFlight::ClientOptions only has `disable-server-verification` property for now.

### What changes are included in this PR?

Add the following properties:

* `tls-root-certificates`
* `override-host-name`
* `certificate-chain`
* `private-key`
* `write-size-limit-bytes`

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37141

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/arrow-flight-glib/client.cpp       | 128 +++++++++++++++++++++-
 c_glib/test/flight/test-client-options.rb |  30 +++++
 2 files changed, 155 insertions(+), 3 deletions(-)

diff --git a/c_glib/arrow-flight-glib/client.cpp b/c_glib/arrow-flight-glib/client.cpp
index 960449abb9df9..7097195f5f92b 100644
--- a/c_glib/arrow-flight-glib/client.cpp
+++ b/c_glib/arrow-flight-glib/client.cpp
@@ -166,12 +166,17 @@ gaflight_call_options_foreach_header(GAFlightCallOptions *options,
 }
 
 
-typedef struct GAFlightClientOptionsPrivate_ {
+struct GAFlightClientOptionsPrivate {
   arrow::flight::FlightClientOptions options;
-} GAFlightClientOptionsPrivate;
+};
 
 enum {
-  PROP_DISABLE_SERVER_VERIFICATION = 1,
+  PROP_TLS_ROOT_CERTIFICATES = 1,
+  PROP_OVERRIDE_HOST_NAME,
+  PROP_CERTIFICATE_CHAIN,
+  PROP_PRIVATE_KEY,
+  PROP_WRITE_SIZE_LIMIT_BYTES,
+  PROP_DISABLE_SERVER_VERIFICATION,
 };
 
 G_DEFINE_TYPE_WITH_PRIVATE(GAFlightClientOptions,
@@ -202,6 +207,21 @@ gaflight_client_options_set_property(GObject *object,
   auto priv = GAFLIGHT_CLIENT_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
+  case PROP_TLS_ROOT_CERTIFICATES:
+    priv->options.tls_root_certs = g_value_get_string(value);
+    break;
+  case PROP_OVERRIDE_HOST_NAME:
+    priv->options.override_hostname = g_value_get_string(value);
+    break;
+  case PROP_CERTIFICATE_CHAIN:
+    priv->options.cert_chain = g_value_get_string(value);
+    break;
+  case PROP_PRIVATE_KEY:
+    priv->options.private_key = g_value_get_string(value);
+    break;
+  case PROP_WRITE_SIZE_LIMIT_BYTES:
+    priv->options.write_size_limit_bytes = g_value_get_int64(value);
+    break;
   case PROP_DISABLE_SERVER_VERIFICATION:
     priv->options.disable_server_verification = g_value_get_boolean(value);
     break;
@@ -220,6 +240,21 @@ gaflight_client_options_get_property(GObject *object,
   auto priv = GAFLIGHT_CLIENT_OPTIONS_GET_PRIVATE(object);
 
   switch (prop_id) {
+  case PROP_TLS_ROOT_CERTIFICATES:
+    g_value_set_string(value, priv->options.tls_root_certs.c_str());
+    break;
+  case PROP_OVERRIDE_HOST_NAME:
+    g_value_set_string(value, priv->options.override_hostname.c_str());
+    break;
+  case PROP_CERTIFICATE_CHAIN:
+    g_value_set_string(value, priv->options.cert_chain.c_str());
+    break;
+  case PROP_PRIVATE_KEY:
+    g_value_set_string(value, priv->options.private_key.c_str());
+    break;
+  case PROP_WRITE_SIZE_LIMIT_BYTES:
+    g_value_set_int64(value, priv->options.write_size_limit_bytes);
+    break;
   case PROP_DISABLE_SERVER_VERIFICATION:
     g_value_set_boolean(value, priv->options.disable_server_verification);
     break;
@@ -248,6 +283,93 @@ gaflight_client_options_class_init(GAFlightClientOptionsClass *klass)
 
   auto options = arrow::flight::FlightClientOptions::Defaults();
   GParamSpec *spec;
+  /**
+   * GAFlightClientOptions:tls-root-certificates:
+   *
+   * Root certificates to use for validating server certificates.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_string("tls-root-certificates",
+                             nullptr,
+                             nullptr,
+                             options.tls_root_certs.c_str(),
+                             static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class,
+                                  PROP_TLS_ROOT_CERTIFICATES,
+                                  spec);
+
+  /**
+   * GAFlightClientOptions:override-host-name:
+   *
+   * Override the host name checked by TLS. Use with caution.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_string("override-host-name",
+                             nullptr,
+                             nullptr,
+                             options.override_hostname.c_str(),
+                             static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class,
+                                  PROP_OVERRIDE_HOST_NAME,
+                                  spec);
+
+  /**
+   * GAFlightClientOptions:certificate-chain:
+   *
+   * The client certificate to use if using Mutual TLS.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_string("certificate-chain",
+                             nullptr,
+                             nullptr,
+                             options.cert_chain.c_str(),
+                             static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class,
+                                  PROP_CERTIFICATE_CHAIN,
+                                  spec);
+
+  /**
+   * GAFlightClientOptions:private-key:
+   *
+   * The private key associated with the client certificate for Mutual
+   * TLS.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_string("private-key",
+                             nullptr,
+                             nullptr,
+                             options.private_key.c_str(),
+                             static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class,
+                                  PROP_PRIVATE_KEY,
+                                  spec);
+
+  /**
+   * GAFlightClientOptions:write-size-limit-bytes:
+   *
+   * A soft limit on the number of bytes to write in a single batch
+   * when sending Arrow data to a server.
+   *
+   * Used to help limit server memory consumption. Only enabled if
+   * positive. When enabled, @GARROW_ERROR_IO may be yielded.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_int64("write-size-limit-bytes",
+                            nullptr,
+                            nullptr,
+                            INT64_MIN,
+                            INT64_MAX,
+                            options.write_size_limit_bytes,
+                            static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class,
+                                  PROP_WRITE_SIZE_LIMIT_BYTES,
+                                  spec);
+
   /**
    * GAFlightClientOptions:disable-server-verification:
    *
diff --git a/c_glib/test/flight/test-client-options.rb b/c_glib/test/flight/test-client-options.rb
index c8c16a784706a..b1a67c60699c2 100644
--- a/c_glib/test/flight/test-client-options.rb
+++ b/c_glib/test/flight/test-client-options.rb
@@ -21,6 +21,36 @@ def setup
     @options = ArrowFlight::ClientOptions.new
   end
 
+  def test_tls_root_certificates
+    assert_equal("", @options.tls_root_certificates)
+    @options.tls_root_certificates = "root"
+    assert_equal("root", @options.tls_root_certificates)
+  end
+
+  def test_override_host_name
+    assert_equal("", @options.override_host_name)
+    @options.override_host_name = "client.example.com"
+    assert_equal("client.example.com", @options.override_host_name)
+  end
+
+  def test_certificate_chain
+    assert_equal("", @options.certificate_chain)
+    @options.certificate_chain = "chain"
+    assert_equal("chain", @options.certificate_chain)
+  end
+
+  def test_private_key
+    assert_equal("", @options.private_key)
+    @options.private_key = "private"
+    assert_equal("private", @options.private_key)
+  end
+
+  def test_write_size_limit_bytes
+    assert_equal(0, @options.write_size_limit_bytes)
+    @options.write_size_limit_bytes = 100
+    assert_equal(100, @options.write_size_limit_bytes)
+  end
+
   def test_disable_server_verifiation
     assert do
       not @options.disable_server_verification?

From 641201416c1075edfd05d78b539275065daac31d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 16 Aug 2023 12:12:02 +0200
Subject: [PATCH 173/749] GH-37197: [Java][CI][Packaging] Free some disk space
 on the java-jars GitHub job (#37198)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
The java-jars job was failing on the maintenance branch for the release due to disk out of space.

### What changes are included in this PR?

Add a step to do some cleanup for the job.

### Are these changes tested?

Yes, I tested it on the maintenance branch having the job successfully run and via crossbow.

### Are there any user-facing changes?

No
* Closes: #37197

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/tasks/java-jars/github.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dev/tasks/java-jars/github.yml b/dev/tasks/java-jars/github.yml
index 57f595e9db44e..7dc53a35ef402 100644
--- a/dev/tasks/java-jars/github.yml
+++ b/dev/tasks/java-jars/github.yml
@@ -46,6 +46,7 @@ jobs:
             archery_arch_short: "arm64"
     steps:
       {{ macros.github_checkout_arrow()|indent }}
+      {{ macros.github_free_space()|indent }}
       {{ macros.github_install_archery()|indent }}
       - name: Build C++ libraries
         env:

From d330d1b36c87ea43bfd16e1bc43a4ff9876abb4b Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 16 Aug 2023 11:40:50 -0400
Subject: [PATCH 174/749] GH-37188: [MATLAB] Move
 `test/util/featherRoundTrip.m` into a packaged test utility function (#37190)

> **Warning** - Please don't merge this PR. It is still in progress.

### Rationale for this change

To simplify access to the `featherRoundTrip` function that is used in the `tfeather.m` tests this pull request moves the `featherRoundTrip` code into a new packaged test utility function `arrow.internal.test.io.feather.roundtrip`.

This makes it possible to`import` the function, rather than having to manually add the `test/util` folder to the MATLAB Search Path in the test class setup.

### What changes are included in this PR?

1. Moved `test/util/featherRoundTrip.m` code into a new internal packaged test utility function `arrow.internal.test.io.feather.roundtrip`.

### Are these changes tested?

Yes.

1. Updated all `tfeather.m` test cases to use new packaged function `arrow.internal.test.io.feather.roundtrip`.

### Are there any user-facing changes?

No.

This new packaged function is an internal test utility.

### Future Directions

1. Delete the old Feather MEX code.
2. Move more shared test infrastructure into packaged test functions under `arrow.internal.test.*`.
* Closes: #37188

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/+test/+io/+feather/roundtrip.m} | 19 +++++---
 matlab/test/arrow/io/feather/tRoundTrip.m     | 14 +-----
 matlab/test/tfeather.m                        | 45 ++++++++++---------
 3 files changed, 37 insertions(+), 41 deletions(-)
 rename matlab/{test/util/featherRoundTrip.m => src/matlab/+arrow/+internal/+test/+io/+feather/roundtrip.m} (68%)

diff --git a/matlab/test/util/featherRoundTrip.m b/matlab/src/matlab/+arrow/+internal/+test/+io/+feather/roundtrip.m
similarity index 68%
rename from matlab/test/util/featherRoundTrip.m
rename to matlab/src/matlab/+arrow/+internal/+test/+io/+feather/roundtrip.m
index 18f80562d759c..3d5a78c7bda23 100644
--- a/matlab/test/util/featherRoundTrip.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+io/+feather/roundtrip.m
@@ -1,6 +1,7 @@
-function tableOut = featherRoundTrip(filename, tableIn)
-% FEATHERROUNDTRIP Helper function for round tripping a table
-% to a Feather file.
+% ROUNDTRIP Test utility which (1) writes a MATLAB
+% table to a Feather V1 file and then (2) reads the
+% resulting the Feather V1 file back into MATLAB
+% as a table.
 
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
@@ -16,7 +17,11 @@
 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
-
-featherwrite(filename, tableIn);
-tableOut = featherread(filename);
-end
\ No newline at end of file
+function tRead = roundtrip(filename, tWrite)
+    arguments
+        filename (1, 1) string
+        tWrite table
+    end
+    featherwrite(filename, tWrite);
+    tRead = featherread(filename);
+end
diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
index 457bdc65e5668..d33111fb931b2 100644
--- a/matlab/test/arrow/io/feather/tRoundTrip.m
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -16,18 +16,6 @@
 % permissions and limitations under the License.
 classdef tRoundTrip < matlab.unittest.TestCase
 
-    methods(TestClassSetup)
-        % Delete once arrow.internal.io.feather.Reader is submitted.
-        function addFeatherFunctionsToMATLABPath(testCase)
-            import matlab.unittest.fixtures.PathFixture
-            % Add Feather test utilities to the MATLAB path.
-            testCase.applyFixture(PathFixture('../../../util'));
-            % arrow.cpp.call must be on the MATLAB path.
-            testCase.assertTrue(~isempty(which('arrow.cpp.call')), ...
-                '''arrow.cpp.call'' must be on the MATLAB path. Use ''addpath'' to add folders to the MATLAB path.');
-        end
-    end
-
     methods(Test)
         function Basic(testCase)
             import matlab.unittest.fixtures.TemporaryFolderFixture
@@ -118,4 +106,4 @@ function InvalidMATLABTableVariableNames(testCase)
                 {'Original variable name: '':''', ''});
         end
     end
-end
\ No newline at end of file
+end
diff --git a/matlab/test/tfeather.m b/matlab/test/tfeather.m
index 9d86dff5fd5cc..72d2438cee83f 100755
--- a/matlab/test/tfeather.m
+++ b/matlab/test/tfeather.m
@@ -16,17 +16,6 @@
     % implied.  See the License for the specific language governing
     % permissions and limitations under the License.
     
-    methods(TestClassSetup)
-        function addFeatherFunctionsToMATLABPath(testCase)
-            import matlab.unittest.fixtures.PathFixture
-            % Add Feather test utilities to the MATLAB path.
-            testCase.applyFixture(PathFixture('util'));
-            % arrow.cpp.call must be on the MATLAB path.
-            testCase.assertTrue(~isempty(which('arrow.cpp.call')), ...
-                '''arrow.cpp.call'' must be on the MATLAB path. Use ''addpath'' to add folders to the MATLAB path.');
-        end
-    end
-    
     methods(TestMethodSetup)
     
         function setupTempWorkingDirectory(testCase)
@@ -40,15 +29,18 @@ function setupTempWorkingDirectory(testCase)
 
         function NumericDatatypesNoNulls(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
+
             filename = fullfile(pwd, 'temp.feather');
             
             actualTable = createTableWithSupportedTypes;
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NumericDatatypesWithNaNRow(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
@@ -76,12 +68,13 @@ function NumericDatatypesWithNaNRow(testCase)
                            'VariableNames', variableNames);
             addRow(1,:) = {NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN};
             actualTable = [t; addRow];
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NumericDatatypesWithNaNColumns(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
@@ -89,12 +82,13 @@ function NumericDatatypesWithNaNColumns(testCase)
             actualTable.double = [NaN; NaN; NaN];
             actualTable.int64  = [NaN; NaN; NaN];
             
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
         
         function NumericDatatypesWithExpInfSciNotation(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
@@ -106,49 +100,54 @@ function NumericDatatypesWithExpInfSciNotation(testCase)
             
             actualTable.int64(2) = 1.0418e+03;
            
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
         
         function IgnoreRowVarNames(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
             actualTable = createTableWithSupportedTypes;
             time = {'day1', 'day2', 'day3'};
             actualTable.Properties.RowNames = time;
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             actualTable = createTableWithSupportedTypes;
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NotFeatherExtension(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.txt');
             
             actualTable = createTableWithSupportedTypes;
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
         
         function EmptyTable(testCase)
+            import arrow.internal.test.io.feather.roundtrip
+
             filename = fullfile(pwd, 'temp.feather');
             
             actualTable = table;
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function zeroByNTable(testCase)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
             actualTable = createTableWithSupportedTypes;
             actualTable([1, 2], :) = [];
-            expectedTable = featherRoundTrip(filename, actualTable);
+            expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
@@ -243,6 +242,8 @@ function NumericComplexUnsupported(testCase)
         end
 
         function SupportedTypes(testCase)
+            import arrow.internal.test.io.feather.roundtrip
+
             filename = fullfile(pwd, 'temp.feather');
 
             % Create a table with all supported MATLAB types.
@@ -260,11 +261,13 @@ function SupportedTypes(testCase)
                                   string (["A", "B", "C"]'), ...
                                   datetime(2023, 6, 28) + days(0:2)');
 
-            actualTable = featherRoundTrip(filename, expectedTable);
+            actualTable = roundtrip(filename, expectedTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function UnicodeVariableNames(testCase)
+            import arrow.internal.test.io.feather.roundtrip
+
             filename = fullfile(pwd, 'temp.feather');
 
             smiley = "😀";
@@ -273,7 +276,7 @@ function UnicodeVariableNames(testCase)
             columnNames = [smiley, tree, mango];
             expectedTable = table(1, 2, 3, VariableNames=columnNames);
 
-            actualTable = featherRoundTrip(filename, expectedTable);
+            actualTable = roundtrip(filename, expectedTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 

From 12954dc10c81bd4d785774a87551940910541759 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Wed, 16 Aug 2023 13:17:45 -0400
Subject: [PATCH 175/749] MINOR: Add link to ADBC doc site (#37207)

It was pointed out to me that the ADBC documentation on the Arrow docs doesn't actually have a link to the ADBC Documentation site. This is particularly problematic as the Arrow site docs show up as the top result for ADBC on Google rather than the ADBC Documentation page itself. So we should add a link to the full ADBC documentation site to help with discovery and finding the tutorials and quickstart guides.

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 docs/source/format/ADBC.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docs/source/format/ADBC.rst b/docs/source/format/ADBC.rst
index b71c8fe19fbfd..3bf4360a70665 100644
--- a/docs/source/format/ADBC.rst
+++ b/docs/source/format/ADBC.rst
@@ -19,6 +19,8 @@
 ADBC: Arrow Database Connectivity
 =================================
 
+Full Documentation on ADBC can be found at `https://arrow.apache.org/adbc/`_.
+
 Rationale
 =========
 

From 1aa58508e533c1fbe5e4b88dacdaf10fa567f904 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 16 Aug 2023 14:11:03 -0400
Subject: [PATCH 176/749] GH-37203: [MATLAB] Remove unused feather V1 MEX
 infrastructure and code (#37204)

### Rationale for this change

Now that `featherread` and `featherwrite` have been re-implemented in terms of the new MATLAB Interface APIs (#37163 and #37047), we can remove the unused feather V1 MEX infrastructure and code.

### What changes are included in this PR?

1. Deleted the following source and header files that are specific to the feather V1 MEX implementation:
    - `arrow/matlab/src/cpp/arrow/matlab/feather/feather_functions.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/feather/feather_reader.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/feather/feather_writer.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/feather/matlab_traits.h`
    - `arrow/matlab/src/cpp/arrow/matlab/feather/util/handle_status.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/mex/call.cc`
    - `arrow/matlab/src/cpp/arrow/matlab/mex/mex_functions.h`
    - `arrow/matlab/src/cpp/arrow/matlab/mex/mex_util.[cc][h]`
    - `arrow/matlab/src/cpp/arrow/matlab/mex/mex_util_test.cc`
    - `arrow/matlab/src/cpp/arrow/matlab/api/visibility.h`

2. Deleted the following feather V1 MEX-specific build infrastructure files:
    - `arrow/matlab/build_support/common_vars.m`
    - `arrow/matlab/build_support/compile.m`
    - `arrow/matlab/build_support/test.m`

3. Removed all feather V1 MEX-specific logic from the `arrow/matlab/CMakeLists.txt` file.

### Are these changes tested?

No tests are needed. The old feather V1 MEX specific implementation is unused code.

### Are there any user-facing changes?

No.

### Future Directions

1. Review the back-log of stale tasks/issues that are no longer actionable and close them. For example, #27758 has already been implemented and submitted with a different issue attached.
* Closes: #37203

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/CMakeLists.txt                         | 119 +-----
 matlab/build_support/common_vars.m            |  24 --
 matlab/build_support/compile.m                |  41 --
 matlab/build_support/test.m                   |  28 --
 matlab/src/cpp/arrow/matlab/api/visibility.h  |  28 --
 .../arrow/matlab/feather/feather_functions.cc |  55 ---
 .../arrow/matlab/feather/feather_functions.h  |  34 --
 .../arrow/matlab/feather/feather_reader.cc    | 278 -------------
 .../cpp/arrow/matlab/feather/feather_reader.h |  77 ----
 .../arrow/matlab/feather/feather_writer.cc    | 369 ------------------
 .../cpp/arrow/matlab/feather/feather_writer.h |  70 ----
 .../cpp/arrow/matlab/feather/matlab_traits.h  | 101 -----
 .../matlab/feather/util/handle_status.cc      |  93 -----
 .../arrow/matlab/feather/util/handle_status.h |  35 --
 .../matlab/feather/util/unicode_conversion.cc |  65 ---
 .../matlab/feather/util/unicode_conversion.h  |  36 --
 matlab/src/cpp/arrow/matlab/mex/call.cc       |  28 --
 .../src/cpp/arrow/matlab/mex/mex_functions.h  |  40 --
 matlab/src/cpp/arrow/matlab/mex/mex_util.cc   |  53 ---
 matlab/src/cpp/arrow/matlab/mex/mex_util.h    |  42 --
 .../src/cpp/arrow/matlab/mex/mex_util_test.cc |  30 --
 21 files changed, 3 insertions(+), 1643 deletions(-)
 delete mode 100644 matlab/build_support/common_vars.m
 delete mode 100644 matlab/build_support/compile.m
 delete mode 100644 matlab/build_support/test.m
 delete mode 100644 matlab/src/cpp/arrow/matlab/api/visibility.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_functions.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_functions.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_reader.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_reader.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_writer.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/feather_writer.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/matlab_traits.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/util/handle_status.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/util/handle_status.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/mex/call.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/mex/mex_functions.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/mex/mex_util.cc
 delete mode 100644 matlab/src/cpp/arrow/matlab/mex/mex_util.h
 delete mode 100644 matlab/src/cpp/arrow/matlab/mex/mex_util_test.cc

diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index 51aec0c3c143c..c7be74de8a951 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -285,45 +285,6 @@ find_package(Matlab REQUIRED COMPONENTS MAIN_PROGRAM)
 message(STATUS "Mex Library: ${Matlab_MEX_LIBRARY}")
 message(STATUS "Mex Include Folder: ${Matlab_INCLUDE_DIRS}")
 
-set(CPP_SOURCE_DIR ${CMAKE_SOURCE_DIR}/src/cpp)
-set(MATLAB_SOURCE_DIR ${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab)
-
-set(arrow_matlab_sources
-    mex/mex_util.cc
-    feather/feather_reader.cc
-    feather/feather_writer.cc
-    feather/feather_functions.cc
-    feather/util/handle_status.cc
-    feather/util/unicode_conversion.cc)
-list(TRANSFORM arrow_matlab_sources PREPEND ${CPP_SOURCE_DIR}/arrow/matlab/)
-
-add_library(arrow_matlab SHARED ${arrow_matlab_sources})
-
-# Declare a dependency on arrow_shared (libarrow.so/dylib/dll).
-target_link_libraries(arrow_matlab arrow_shared)
-
-# Declare a dependency on the MEX shared library (libmex.so/dylib/dll).
-target_link_libraries(arrow_matlab ${Matlab_MX_LIBRARY})
-target_link_libraries(arrow_matlab ${Matlab_MEX_LIBRARY})
-
-# Include the MATLAB MEX headers.
-target_include_directories(arrow_matlab PRIVATE ${Matlab_INCLUDE_DIRS})
-target_include_directories(arrow_matlab PRIVATE ${CPP_SOURCE_DIR})
-target_include_directories(arrow_matlab PRIVATE ${ARROW_INCLUDE_DIR})
-target_compile_definitions(arrow_matlab PRIVATE ARROW_MATLAB_EXPORTING)
-
-set(mexcall_sources mex/call.cc)
-list(TRANSFORM mexcall_sources PREPEND ${CPP_SOURCE_DIR}/arrow/matlab/)
-
-# Build call MEX binary.
-matlab_add_mex(R2018a
-               NAME mexcall
-               OUTPUT_NAME call
-               SRC ${mexcall_sources}
-               LINK_TO arrow_matlab)
-
-target_include_directories(mexcall PRIVATE ${CPP_SOURCE_DIR})
-
 # ARROW_SHARED_LIB
 # On Windows, this will be ARROW_HOME/bin/arrow.dll and on Linux and macOS, it is the arrow.so/dylib in the newly built arrow_shared library.
 if(NOT Arrow_FOUND)
@@ -379,36 +340,13 @@ if(MATLAB_BUILD_TESTS)
   # Define a test executable target. TODO: Remove the placeholder test. This is
   # just for testing GoogleTest integration.
   add_executable(placeholder_test ${CMAKE_SOURCE_DIR}/src/placeholder_test.cc)
-  add_executable(mex_util_test ${CPP_SOURCE_DIR}/arrow/matlab/mex/mex_util_test.cc)
 
   # Declare a dependency on the GTest::gtest and GTest::gtest_main IMPORTED
   # targets.
   target_link_libraries(placeholder_test GTest::gtest GTest::gtest_main)
 
-  # Declare a dependency on the GTest::gtest and GTest::gtest_main IMPORTED
-  # targets.
-  target_link_libraries(mex_util_test GTest::gtest GTest::gtest_main)
-  target_link_libraries(mex_util_test arrow_matlab)
-
-  # Include the MATLAB MEX headers.
-  target_include_directories(mex_util_test PRIVATE ${Matlab_INCLUDE_DIRS})
-  # Include the C++ source headers.
-  target_include_directories(mex_util_test PRIVATE ${CPP_SOURCE_DIR})
-
   # Add test targets for C++ tests.
   add_test(PlaceholderTestTarget placeholder_test)
-  add_test(CheckNumArgsTestTarget mex_util_test)
-
-  # On macOS, add the directory of libarrow.dylib to the $DYLD_LIBRARY_PATH for
-  # running CheckNumArgsTestTarget.
-  if(APPLE)
-    get_target_property(ARROW_SHARED_LIB arrow_shared IMPORTED_LOCATION)
-    get_filename_component(ARROW_SHARED_LIB_DIR ${ARROW_SHARED_LIB} DIRECTORY)
-
-    set_tests_properties(CheckNumArgsTestTarget
-                         PROPERTIES ENVIRONMENT
-                                    "DYLD_LIBRARY_PATH=${ARROW_SHARED_LIB_DIR}")
-  endif()
 
   # On Windows:
   # Add the directory of gtest.dll and gtest_main.dll to the %PATH% for running
@@ -432,13 +370,6 @@ if(MATLAB_BUILD_TESTS)
 
     get_target_property(ARROW_SHARED_LIB arrow_shared IMPORTED_LOCATION)
     get_filename_component(ARROW_SHARED_LIB_DIR ${ARROW_SHARED_LIB} DIRECTORY)
-
-    set(MATLAB_DLL_DEPENDENCIES_DIR "${Matlab_ROOT_DIR}/bin/win64")
-
-    set_tests_properties(CheckNumArgsTestTarget
-                         PROPERTIES ENVIRONMENT
-                                    "PATH=${ARROW_SHARED_LIB_DIR}\;${MATLAB_DLL_DEPENDENCIES_DIR}\;${GTEST_SHARED_LIB_DIR}\;${GTEST_MAIN_SHARED_LIB_DIR}\;$ENV{PATH}"
-    )
   endif()
 endif()
 
@@ -452,62 +383,15 @@ if(MATLAB_ARROW_INTERFACE)
   include(BuildMatlabArrowInterface)
 endif()
 
-# Create a package hierarchy at CMAKE_INSTALL_PREFIX to install the mex function
-# and dependencies.
-set(CMAKE_PACKAGED_INSTALL_DIR "${CMAKE_INSTALL_DIR}/+arrow/+cpp")
-
 # Install MATLAB source files.
 # On macOS, exclude '.DS_Store' files in the source tree from installation.
 install(DIRECTORY "${CMAKE_SOURCE_DIR}/src/matlab/"
         DESTINATION ${CMAKE_INSTALL_DIR}
         PATTERN ".DS_Store" EXCLUDE)
 
-# Install arrow_matlab and mexcall.
-# Use the RUNTIME output artifact keyword for Windows.
-# Use the LIBRARY output artifact keyword for macOS and Linux.
-install(TARGETS arrow_matlab mexcall
-        RUNTIME DESTINATION ${CMAKE_PACKAGED_INSTALL_DIR}
-        LIBRARY DESTINATION ${CMAKE_PACKAGED_INSTALL_DIR})
-
 get_filename_component(ARROW_SHARED_LIB_DIR ${ARROW_SHARED_LIB} DIRECTORY)
 get_filename_component(ARROW_SHARED_LIB_FILENAME ${ARROW_SHARED_LIB} NAME_WE)
 
-# On macOS, use the RPATH values below for runtime dependency resolution. This enables
-# relocation of the installation directory.
-if(APPLE)
-  # Setting INSTALL_RPATH_USE_LINK_PATH to true will add the paths to external dependencies
-  # to the RPATH of arrow_matlab and mexcall, including the MATLAB dependencies.
-  # If Arrow_FOUND is true, this also includes the path to arrow_shared.
-  set_target_properties(arrow_matlab mexcall PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-  # Add @loader_path to the RPATH of mexcall so that libarrow_matlab.dylib can be found
-  # at runtime.
-  set_target_properties(mexcall PROPERTIES INSTALL_RPATH "@loader_path")
-
-  # Add @loader_path to the RPATH of arrow_matlab so that libarrow.dylib can be found
-  # at runtime.
-  set_target_properties(arrow_matlab PROPERTIES INSTALL_RPATH "@loader_path")
-endif()
-
-# On Linux, use the RUNPATH values below for runtime dependency resolution. This enables
-# relocation of the installation directory.
-if(UNIX
-   AND NOT APPLE
-   AND NOT CYGWIN)
-  # Setting INSTALL_RPATH_USE_LINK_PATH to true will add the paths to external dependencies
-  # to the RUNPATH of arrow_matlab and mexcall, including the MATLAB dependencies.
-  # If Arrow_FOUND is true, this also includes the path to arrow_shared.
-  set_target_properties(arrow_matlab mexcall PROPERTIES INSTALL_RPATH_USE_LINK_PATH TRUE)
-
-  # Add $ORIGIN to the RUNPATH of mexcall so that libarrow_matlab.so can be found
-  # at runtime.
-  set_target_properties(mexcall PROPERTIES INSTALL_RPATH $ORIGIN)
-
-  # Add $ORIGIN to the RUNPATH of arrow_matlab so that libarrow.so can be found
-  # at runtime.
-  set_target_properties(arrow_matlab PROPERTIES INSTALL_RPATH $ORIGIN)
-endif()
-
 if(NOT Arrow_FOUND)
   # If Arrow_FOUND is false, Arrow is built by the arrow_shared target and needs
   # to be copied to CMAKE_PACKAGED_INSTALL_DIR.
@@ -539,6 +423,9 @@ if(NOT Arrow_FOUND)
   # Note: The following CMake Issue suggests enabling an option to exclude all
   # folders that would be empty after installation:
   # https://gitlab.kitware.com/cmake/cmake/-/issues/17122
+
+  set(CMAKE_PACKAGED_INSTALL_DIR "${CMAKE_INSTALL_DIR}/+arrow")
+
   install(DIRECTORY "${ARROW_SHARED_LIB_DIR}/"
           DESTINATION ${CMAKE_PACKAGED_INSTALL_DIR}
           FILES_MATCHING
diff --git a/matlab/build_support/common_vars.m b/matlab/build_support/common_vars.m
deleted file mode 100644
index a7c9d6a32fe0e..0000000000000
--- a/matlab/build_support/common_vars.m
+++ /dev/null
@@ -1,24 +0,0 @@
-function vars = common_vars()
-% Licensed to the Apache Software Foundation (ASF) under one
-% or more contributor license agreements.  See the NOTICE file
-% distributed with this work for additional information
-% regarding copyright ownership.  The ASF licenses this file
-% to you under the Apache License, Version 2.0 (the
-% "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing,
-% software distributed under the License is distributed on an
-% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-% KIND, either express or implied.  See the License for the
-% specific language governing permissions and limitations
-% under the License.
-
-fileDir = fileparts(mfilename("fullpath"));
-
-vars.srcDir = fullfile(fileDir, "..", "src");
-vars.testDir = fullfile(fileDir, "..", "test");
-vars.buildDir = fullfile(fileDir, "..", "build");
-end
\ No newline at end of file
diff --git a/matlab/build_support/compile.m b/matlab/build_support/compile.m
deleted file mode 100644
index d436dadfe8d82..0000000000000
--- a/matlab/build_support/compile.m
+++ /dev/null
@@ -1,41 +0,0 @@
-function compile()
-% Licensed to the Apache Software Foundation (ASF) under one
-% or more contributor license agreements.  See the NOTICE file
-% distributed with this work for additional information
-% regarding copyright ownership.  The ASF licenses this file
-% to you under the Apache License, Version 2.0 (the
-% "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing,
-% software distributed under the License is distributed on an
-% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-% KIND, either express or implied.  See the License for the
-% specific language governing permissions and limitations
-% under the License.
-
-vars = common_vars();
-
-mkdir(vars.buildDir);
-
-ldflags = string.empty;
-if isunix
-    arrowHome = getenv("ARROW_HOME");
-    if isempty(arrowHome)
-        error("The ARROW_HOME environment variable must be set.");
-    end
-    ldflags(end+1) = "-Wl";
-    ldflags(end+1) = "-rpath '" + fullfile(arrowHome, "lib") + "'";
-end
-
-mex(fullfile(vars.srcDir, "featherreadmex.cc"), ...
-    fullfile(vars.srcDir, "feather_reader.cc"), ...
-    fullfile(vars.srcDir, "util", "handle_status.cc"), ...
-    "-L" + fullfile(arrowHome, "lib"), "-larrow", ...
-    "-I" + fullfile(arrowHome, "include"), ...
-    "LDFLAGS=""\$LDFLAGS " + strjoin(ldflags, ",") + """", ...
-    "-outdir", vars.buildDir, ...
-    "-R2018a", "-v");
-end
diff --git a/matlab/build_support/test.m b/matlab/build_support/test.m
deleted file mode 100644
index 990549e3b310f..0000000000000
--- a/matlab/build_support/test.m
+++ /dev/null
@@ -1,28 +0,0 @@
-function test()
-% Licensed to the Apache Software Foundation (ASF) under one
-% or more contributor license agreements.  See the NOTICE file
-% distributed with this work for additional information
-% regarding copyright ownership.  The ASF licenses this file
-% to you under the Apache License, Version 2.0 (the
-% "License"); you may not use this file except in compliance
-% with the License.  You may obtain a copy of the License at
-%
-%   http://www.apache.org/licenses/LICENSE-2.0
-%
-% Unless required by applicable law or agreed to in writing,
-% software distributed under the License is distributed on an
-% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-% KIND, either express or implied.  See the License for the
-% specific language governing permissions and limitations
-% under the License.
-
-vars = common_vars();
-
-compile();
-
-originalPath = addpath(vars.srcDir, vars.buildDir);
-restoreOriginalPath = onCleanup(@()path(originalPath));
-
-results = runtests(vars.testDir, "IncludeSubfolders", true, "OutputDetail", 3);
-assert(all(~[results.Failed]));
-end
diff --git a/matlab/src/cpp/arrow/matlab/api/visibility.h b/matlab/src/cpp/arrow/matlab/api/visibility.h
deleted file mode 100644
index 51efac972ee92..0000000000000
--- a/matlab/src/cpp/arrow/matlab/api/visibility.h
+++ /dev/null
@@ -1,28 +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.
-
-#pragma once
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-#ifdef ARROW_MATLAB_EXPORTING
-#define ARROW_MATLAB_EXPORT __declspec(dllexport)
-#else
-#define ARROW_MATLAB_EXPORT __declspec(dllimport)
-#endif
-#else // Not Windows
-#define ARROW_MATLAB_EXPORT __attribute__((visibility("default")))
-#endif
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_functions.cc b/matlab/src/cpp/arrow/matlab/feather/feather_functions.cc
deleted file mode 100644
index f5b5a394083b2..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_functions.cc
+++ /dev/null
@@ -1,55 +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.
-
-#include "feather_functions.h"
-
-#include <string>
-
-#include "feather_reader.h"
-#include "feather_writer.h"
-#include "util/handle_status.h"
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-
-void featherwrite(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
-  const std::string filename{mxArrayToUTF8String(prhs[0])};
-
-  // Open a Feather file at the provided file path for writing.
-  std::shared_ptr<FeatherWriter> feather_writer{nullptr};
-  util::HandleStatus(FeatherWriter::Open(filename, &feather_writer));
-
-  // Write the Feather file table variables and table metadata from MATLAB.
-  util::HandleStatus(feather_writer->WriteVariables(prhs[1], prhs[2]));
-}
-
-void featherread(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
-  const std::string filename{mxArrayToUTF8String(prhs[0])};
-
-  // Read the given Feather file into memory.
-  std::shared_ptr<FeatherReader> feather_reader{nullptr};
-  util::HandleStatus(FeatherReader::Open(filename, &feather_reader));
-
-  // Return the Feather file table variables and table metadata to MATLAB.
-  plhs[0] = feather_reader->ReadVariables();
-  plhs[1] = feather_reader->ReadMetadata();
-}
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_functions.h b/matlab/src/cpp/arrow/matlab/feather/feather_functions.h
deleted file mode 100644
index c055e9582c037..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_functions.h
+++ /dev/null
@@ -1,34 +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.
-
-#pragma once
-
-#include <mex.h>
-
-#include "arrow/matlab/api/visibility.h"
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-
-ARROW_MATLAB_EXPORT void featherwrite(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]);
-
-ARROW_MATLAB_EXPORT void featherread(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]);
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_reader.cc b/matlab/src/cpp/arrow/matlab/feather/feather_reader.cc
deleted file mode 100644
index 413b7f153e99c..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_reader.cc
+++ /dev/null
@@ -1,278 +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.
-
-#include "feather_reader.h"
-
-#include <arrow/array/array_base.h>
-#include <arrow/array/builder_base.h>
-#include <arrow/array/builder_primitive.h>
-#include <arrow/io/file.h>
-#include <arrow/ipc/feather.h>
-#include <arrow/result.h>
-#include <arrow/status.h>
-#include <arrow/table.h>
-#include <arrow/type.h>
-#include <arrow/type_traits.h>
-#include <arrow/util/bitmap_visit.h>
-#include <mex.h>
-
-#include <algorithm>
-#include <cmath>
-
-#include "matlab_traits.h"
-#include "util/handle_status.h"
-#include "util/unicode_conversion.h"
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace internal {
-
-// Read the name of variable i from the Feather file as a mxArray*.
-mxArray* ReadVariableName(const std::string& column_name) {
-  return util::ConvertUTF8StringToUTF16CharMatrix(column_name);
-}
-
-template <typename ArrowDataType>
-mxArray* ReadNumericVariableData(const std::shared_ptr<Array>& column) {
-  using MatlabType = typename MatlabTraits<ArrowDataType>::MatlabType;
-  using ArrowArrayType = typename TypeTraits<ArrowDataType>::ArrayType;
-
-  const mxClassID matlab_class_id = MatlabTraits<ArrowDataType>::matlab_class_id;
-  // Allocate a numeric mxArray* with the correct mxClassID based on the type of the
-  // arrow::Array.
-  mxArray* variable_data =
-      mxCreateNumericMatrix(column->length(), 1, matlab_class_id, mxREAL);
-
-  auto arrow_numeric_array = std::static_pointer_cast<ArrowArrayType>(column);
-
-  // Get a raw pointer to the Arrow array data.
-  const MatlabType* source = arrow_numeric_array->raw_values();
-
-  // Get a mutable pointer to the MATLAB array data and std::copy the
-  // Arrow array data into it.
-  MatlabType* destination = MatlabTraits<ArrowDataType>::GetData(variable_data);
-  std::copy(source, source + column->length(), destination);
-
-  return variable_data;
-}
-
-// Read the data of variable i from the Feather file as a mxArray*.
-mxArray* ReadVariableData(const std::shared_ptr<Array>& column,
-                          const std::string& column_name) {
-  std::shared_ptr<DataType> type = column->type();
-
-  switch (type->id()) {
-    case Type::FLOAT:
-      return ReadNumericVariableData<FloatType>(column);
-    case Type::DOUBLE:
-      return ReadNumericVariableData<DoubleType>(column);
-    case Type::UINT8:
-      return ReadNumericVariableData<UInt8Type>(column);
-    case Type::UINT16:
-      return ReadNumericVariableData<UInt16Type>(column);
-    case Type::UINT32:
-      return ReadNumericVariableData<UInt32Type>(column);
-    case Type::UINT64:
-      return ReadNumericVariableData<UInt64Type>(column);
-    case Type::INT8:
-      return ReadNumericVariableData<Int8Type>(column);
-    case Type::INT16:
-      return ReadNumericVariableData<Int16Type>(column);
-    case Type::INT32:
-      return ReadNumericVariableData<Int32Type>(column);
-    case Type::INT64:
-      return ReadNumericVariableData<Int64Type>(column);
-    default: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:UnsupportedArrowType",
-                        "Unsupported arrow::Type '%s' for variable '%s'",
-                        type->name().c_str(), column_name.c_str());
-      break;
-    }
-  }
-
-  return nullptr;
-}
-
-// arrow::Buffers are bit-packed, while mxLogical arrays aren't. This utility
-// uses an Arrow utility to copy each bit of an arrow::Buffer into each byte
-// of an mxLogical array.
-void BitUnpackBuffer(const std::shared_ptr<Buffer>& source, int64_t length,
-                     mxLogical* destination) {
-  const uint8_t* source_data = source->data();
-
-  // Call into an Arrow utility to visit each bit in the bitmap.
-  auto visitFcn = [&](mxLogical is_valid) { *destination++ = is_valid; };
-
-  const int64_t start_offset = 0;
-  arrow::internal::VisitBitsUnrolled(source_data, start_offset, length, visitFcn);
-}
-
-// Populates the validity bitmap from an arrow::Array.
-// writes to a zero-initialized destination buffer.
-// Implements a fast path for the fully-valid and fully-invalid cases.
-// Returns true if the destination buffer was successfully populated.
-bool TryBitUnpackFastPath(const std::shared_ptr<Array>& array, mxLogical* destination) {
-  const int64_t null_count = array->null_count();
-  const int64_t length = array->length();
-
-  if (null_count == length) {
-    // The source array is filled with invalid values. Since mxCreateLogicalMatrix
-    // zero-initializes the destination buffer, we can return without changing anything
-    // in the destination buffer.
-    return true;
-  } else if (null_count == 0) {
-    // The source array contains only valid values. Fill the destination buffer
-    // with 'true'.
-    std::fill(destination, destination + length, true);
-    return true;
-  }
-
-  // Return false to indicate that we couldn't fill the entire validity bitmap.
-  return false;
-}
-
-// Read the validity (null) bitmap of variable i from the Feather
-// file as an mxArray*.
-mxArray* ReadVariableValidityBitmap(const std::shared_ptr<Array>& column) {
-  // Allocate an mxLogical array to store the validity (null) bitmap values.
-  // Note: All Arrow arrays can have an associated validity (null) bitmap.
-  // The Apache Arrow specification defines 0 (false) to represent an
-  // invalid (null) array entry and 1 (true) to represent a valid
-  // (non-null) array entry.
-  mxArray* validity_bitmap = mxCreateLogicalMatrix(column->length(), 1);
-  mxLogical* validity_bitmap_unpacked = mxGetLogicals(validity_bitmap);
-
-  if (!TryBitUnpackFastPath(column, validity_bitmap_unpacked)) {
-    // Couldn't fill the full validity bitmap at once. Call an optimized loop-unrolled
-    // implementation instead that goes byte-by-byte and populates the validity bitmap.
-    BitUnpackBuffer(column->null_bitmap(), column->length(), validity_bitmap_unpacked);
-  }
-
-  return validity_bitmap;
-}
-
-// Read the type name of an arrow::Array as an mxChar array.
-mxArray* ReadVariableType(const std::shared_ptr<Array>& column) {
-  return util::ConvertUTF8StringToUTF16CharMatrix(column->type()->name());
-}
-
-// MATLAB arrays cannot be larger than 2^48 elements.
-static constexpr uint64_t MAX_MATLAB_SIZE = static_cast<uint64_t>(0x01) << 48;
-
-}  // namespace internal
-
-Status FeatherReader::Open(const std::string& filename,
-                           std::shared_ptr<FeatherReader>* feather_reader) {
-  *feather_reader = std::shared_ptr<FeatherReader>(new FeatherReader());
-
-  // Open file with given filename as a ReadableFile.
-  ARROW_ASSIGN_OR_RAISE(auto readable_file, io::ReadableFile::Open(filename));
-
-  // Open the Feather file for reading with a TableReader.
-  ARROW_ASSIGN_OR_RAISE(auto reader, ipc::feather::Reader::Open(readable_file));
-
-  // Set the internal reader_ object.
-  (*feather_reader)->reader_ = reader;
-
-  // Check the feather file version
-  auto version = reader->version();
-  if (version == ipc::feather::kFeatherV2Version) {
-    return Status::NotImplemented("Support for Feather V2 has not been implemented.");
-  } else if (version != ipc::feather::kFeatherV1Version) {
-    return Status::Invalid("Unknown Feather format version.");
-  }
-
-  // read the table metadata from the Feather file
-  (*feather_reader)->num_variables_ = reader->schema()->num_fields();
-  return Status::OK();
-}
-
-// Read the table metadata from the Feather file as a mxArray*.
-mxArray* FeatherReader::ReadMetadata() const {
-  const int32_t num_metadata_fields = 3;
-  const char* fieldnames[] = {"NumRows", "NumVariables", "Description"};
-
-  // Create a mxArray struct array containing the table metadata to be passed back to
-  // MATLAB.
-  mxArray* metadata = mxCreateStructMatrix(1, 1, num_metadata_fields, fieldnames);
-
-  // Returning double values to MATLAB since that is the default type.
-
-  // Set the number of rows.
-  mxSetField(metadata, 0, "NumRows",
-             mxCreateDoubleScalar(static_cast<double>(num_rows_)));
-
-  // Set the number of variables.
-  mxSetField(metadata, 0, "NumVariables",
-             mxCreateDoubleScalar(static_cast<double>(num_variables_)));
-
-  return metadata;
-}
-
-// Read the table variables from the Feather file as a mxArray*.
-mxArray* FeatherReader::ReadVariables() {
-  const int32_t num_variable_fields = 4;
-  const char* fieldnames[] = {"Name", "Type", "Data", "Valid"};
-
-  // Create an mxArray* struct array containing the table variables to be passed back to
-  // MATLAB.
-  mxArray* variables =
-      mxCreateStructMatrix(1, num_variables_, num_variable_fields, fieldnames);
-
-  std::shared_ptr<arrow::Table> table;
-  auto status = reader_->Read(&table);
-  if (!status.ok()) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:FeatherReader::FailedToReadTable",
-                      "Failed to read arrow::Table from Feather file. Reason: %s",
-                      status.message().c_str());
-  }
-
-  // Set the number of rows
-  num_rows_ = table->num_rows();
-
-  if (num_rows_ > internal::MAX_MATLAB_SIZE ||
-      num_variables_ > internal::MAX_MATLAB_SIZE) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:SizeTooLarge",
-                      "The table size exceeds MATLAB limits: %u x %u", num_rows_,
-                      num_variables_);
-  }
-
-  auto column_names = table->ColumnNames();
-
-  for (int64_t i = 0; i < num_variables_; ++i) {
-    auto column = table->column(i);
-    if (column->num_chunks() != 1) {
-      mexErrMsgIdAndTxt("MATLAB:arrow:FeatherReader::ReadVariables",
-                        "Chunked columns not yet supported");
-    }
-    std::shared_ptr<Array> chunk = column->chunk(0);
-    const std::string column_name = column_names[i];
-
-    // set the struct fields data
-    mxSetField(variables, i, "Name", internal::ReadVariableName(column_name));
-    mxSetField(variables, i, "Type", internal::ReadVariableType(chunk));
-    mxSetField(variables, i, "Data", internal::ReadVariableData(chunk, column_name));
-    mxSetField(variables, i, "Valid", internal::ReadVariableValidityBitmap(chunk));
-  }
-
-  return variables;
-}
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_reader.h b/matlab/src/cpp/arrow/matlab/feather/feather_reader.h
deleted file mode 100644
index 0e2089d3672a2..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_reader.h
+++ /dev/null
@@ -1,77 +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.
-
-#pragma once
-
-#include <arrow/ipc/feather.h>
-#include <arrow/status.h>
-#include <arrow/type.h>
-#include <matrix.h>
-
-#include <memory>
-#include <string>
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-
-class FeatherReader {
- public:
-  ~FeatherReader() = default;
-
-  /// \brief Read the table metadata as an mxArray* struct from the given
-  ///        Feather file.
-  ///        The returned mxArray* struct contains the following fields:
-  ///         - "Description"  :: Nx1 mxChar array, table-level description
-  ///         - "NumRows"      :: scalar mxDouble array, number of rows in the
-  ///                             table
-  ///         - "NumVariables" :: scalar mxDouble array, number of variables in
-  ///                             the table
-  ///        Clients are responsible for freeing the returned mxArray memory
-  ///        when it is no longer needed, or passing it to MATLAB to be managed.
-  /// \return metadata mxArray* scalar struct containing table level metadata
-  mxArray* ReadMetadata() const;
-
-  /// \brief Read the table variable data as an mxArray* struct array from the
-  ///        given Feather file.
-  ///        The returned mxArray* struct array has the following fields:
-  ///         - "Name"  :: Nx1 mxChar array, name of the variable
-  ///         - "Type"  :: Nx1 mxChar array, the variable's Arrow datatype
-  ///         - "Data"  :: Nx1 mxArray, data for the variable
-  ///         - "Valid" :: Nx1 mxLogical array, validity (null) bitmap
-  ///        Clients are responsible for freeing the returned mxArray memory
-  ///        when it is no longer needed, or passing it to MATLAB to be managed.
-  /// \return variables mxArray* struct array containing table variable data
-  mxArray* ReadVariables();
-
-  /// \brief Initialize a FeatherReader object from a given Feather file.
-  /// \param[in] filename path to a Feather file
-  /// \param[out] feather_reader uninitialized FeatherReader object
-  static Status Open(const std::string& filename,
-                     std::shared_ptr<FeatherReader>* feather_reader);
-
- private:
-  FeatherReader() = default;
-  std::shared_ptr<ipc::feather::Reader> reader_;
-  int64_t num_rows_;
-  int64_t num_variables_;
-  std::string description_;
-};
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_writer.cc b/matlab/src/cpp/arrow/matlab/feather/feather_writer.cc
deleted file mode 100644
index f67d8dc2fbab3..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_writer.cc
+++ /dev/null
@@ -1,369 +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.
-
-#include "feather_writer.h"
-
-#include <arrow/array.h>
-#include <arrow/buffer.h>
-#include <arrow/io/file.h>
-#include <arrow/ipc/feather.h>
-#include <arrow/status.h>
-#include <arrow/table.h>
-#include <arrow/type.h>
-#include <arrow/util/bit_util.h>
-#include <arrow/util/bitmap_generate.h>
-#include <arrow/util/key_value_metadata.h>
-#include <mex.h>
-
-#include <cmath>
-#include <functional> /* for std::multiplies */
-#include <numeric>    /* for std::accumulate */
-
-#include "matlab_traits.h"
-#include "util/handle_status.h"
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace internal {
-
-// Returns the arrow::DataType that corresponds to the input type string
-std::shared_ptr<arrow::DataType> ConvertMatlabTypeStringToArrowDataType(
-    const std::string& t) {
-  if (t == "double") {
-    return arrow::float64();
-  } else if (t == "single") {
-    return arrow::float32();
-  } else if (t == "uint64") {
-    return arrow::uint64();
-  } else if (t == "uint32") {
-    return arrow::uint32();
-  } else if (t == "uint16") {
-    return arrow::uint16();
-  } else if (t == "uint8") {
-    return arrow::uint8();
-  } else if (t == "int64") {
-    return arrow::int64();
-  } else if (t == "int32") {
-    return arrow::int32();
-  } else if (t == "int16") {
-    return arrow::int16();
-  } else if (t == "int8") {
-    return arrow::int8();
-  }
-  mexErrMsgIdAndTxt("MATLAB:arrow:UnsupportedMatlabTypeString",
-                    "Unsupported MATLAB type string: '%s'", t.c_str());
-
-  // mexErrMsgIdAndTxt throws unconditionally so we should never reach this line
-  return nullptr;
-}
-
-// Utility that helps verify the input mxArray struct field name and type.
-// Returns void since any errors will throw and terminate MEX execution.
-void ValidateMxStructField(const mxArray* struct_array, const char* fieldname,
-                           mxClassID expected_class_id, bool can_be_empty) {
-  // Check that the input mxArray is a struct array.
-  if (!mxIsStruct(struct_array)) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:IncorrectDimensionsOrType",
-                      "Input needs to be a struct array");
-  }
-
-  // Return early if an empty table is provided as input.
-  if (mxIsEmpty(struct_array)) {
-    return;
-  }
-
-  mxArray* field = mxGetField(struct_array, 0, fieldname);
-
-  if (!field) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:MissingStructField",
-                      "Missing field '%s' in input struct array", fieldname);
-  }
-
-  mxClassID actual_class_id = mxGetClassID(field);
-
-  // Avoid type check if an mxUNKNOWN_CLASS is provided since the UNKNOWN type is used to
-  // signify genericity in the input type.
-  if (expected_class_id != mxUNKNOWN_CLASS) {
-    if (expected_class_id != actual_class_id) {
-      mexErrMsgIdAndTxt("MATLAB:arrow:MissingStructField",
-                        "Incorrect type '%s' for struct array field '%s'",
-                        mxGetClassName(field), fieldname);
-    }
-  }
-  // Some struct fields (like Data) can be empty, while others
-  // (like NumRows) should never be empty. This conditional helps account for both cases.
-  if (!can_be_empty) {
-    // Ensure that individual mxStructArray fields are non-empty.
-    // We can call mxGetData after this without needing another null check.
-    if (mxIsEmpty(field)) {
-      mexErrMsgIdAndTxt("MATLAB:arrow:EmptyStructField",
-                        "Struct array field '%s' cannot be empty", fieldname);
-    }
-  }
-}
-
-// Utility function to convert mxChar mxArray* to std::string while preserving
-// Unicode code points.
-std::string MxArrayToString(const mxArray* array) {
-  // Return empty std::string if a mxChar array is not passed in.
-  if (!mxIsChar(array)) {
-    return std::string();
-  }
-
-  // Convert mxArray first to a C-style char array, then copy into a std::string.
-  char* utf8_array = mxArrayToUTF8String(array);
-  std::string output(utf8_array);
-
-  // Free the allocated char* from the MEX runtime.
-  mxFree(utf8_array);
-
-  return output;
-}
-
-// Compare number of columns and exit out to the MATLAB layer if incorrect.
-void ValidateNumColumns(int64_t actual, int64_t expected) {
-  if (actual != expected) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:IncorrectNumberOfColumns",
-                      "Received only '%d' columns but expected '%d' columns", actual,
-                      expected);
-  }
-}
-
-// Compare number of rows and exit out to the MATLAB layer if incorrect.
-void ValidateNumRows(int64_t actual, int64_t expected) {
-  if (actual != expected) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:IncorrectNumberOfRows",
-                      "Received only '%d' rows but expected '%d' rows", actual, expected);
-  }
-}
-
-// Calculate the number of bytes required in the bit-packed validity buffer.
-int64_t BitPackedLength(int64_t num_elements) {
-  // Since mxLogicalArray encodes [0, 1] in a full byte, we can compress that byte
-  // down to a bit...therefore dividing the mxLogicalArray length by 8 here.
-  return static_cast<int64_t>(std::ceil(num_elements / 8.0));
-}
-
-// Calculate the total number of elements in an mxArray
-// We have to do this separately since mxGetNumberOfElements only works in numeric arrays
-size_t GetNumberOfElements(const mxArray* array) {
-  // Get the dimensions and the total number of dimensions from the mxArray*.
-  const size_t num_dimensions = mxGetNumberOfDimensions(array);
-  const size_t* dimensions = mxGetDimensions(array);
-
-  // Iterate over the dimensions array and accumulate the total number of elements.
-  return std::accumulate(dimensions, dimensions + num_dimensions, size_t{1},
-                         std::multiplies<size_t>());
-}
-
-// Write an mxLogicalArray* into a bit-packed arrow::MutableBuffer
-void BitPackBuffer(const mxArray* logical_array,
-                   std::shared_ptr<MutableBuffer> packed_buffer) {
-  // Error out if the incorrect type is passed in.
-  if (!mxIsLogical(logical_array)) {
-    mexErrMsgIdAndTxt(
-        "MATLAB:arrow:IncorrectType",
-        "Expected mxLogical array as input but received mxArray of class '%s'",
-        mxGetClassName(logical_array));
-  }
-
-  // Validate that the input arrow::Buffer has sufficient size to store a full bit-packed
-  // representation of the input mxLogicalArray
-  int64_t unpacked_buffer_length = GetNumberOfElements(logical_array);
-  if (BitPackedLength(unpacked_buffer_length) > packed_buffer->capacity()) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:BufferSizeExceeded",
-                      "Buffer of size %d bytes cannot store %d bytes of data",
-                      packed_buffer->capacity(), BitPackedLength(unpacked_buffer_length));
-  }
-
-  // Get pointers to the internal uint8_t arrays behind arrow::Buffer and mxArray
-  uint8_t* packed_buffer_ptr = packed_buffer->mutable_data();
-  mxLogical* unpacked_buffer_ptr = mxGetLogicals(logical_array);
-
-  // Iterate over the mxLogical array and write bit-packed bools to the arrow::Buffer.
-  // Call into a loop-unrolled Arrow utility for better performance when bit-packing.
-  auto generator = [&]() -> bool { return *(unpacked_buffer_ptr++); };
-  const int64_t start_offset = 0;
-  arrow::internal::GenerateBitsUnrolled(packed_buffer_ptr, start_offset,
-                                        unpacked_buffer_length, generator);
-}
-
-// Write numeric datatypes to the Feather file.
-template <typename ArrowDataType>
-std::unique_ptr<Array> WriteNumericData(const mxArray* data,
-                                        const std::shared_ptr<Buffer> validity_bitmap) {
-  // Alias the type name for the underlying MATLAB type.
-  using MatlabType = typename MatlabTraits<ArrowDataType>::MatlabType;
-
-  // Get a pointer to the underlying mxArray data.
-  // We need to (temporarily) cast away const here since the mxGet* functions do not
-  // accept a const input parameter for compatibility reasons.
-  const MatlabType* dt = MatlabTraits<ArrowDataType>::GetData(const_cast<mxArray*>(data));
-
-  // Construct an arrow::Buffer that points to the underlying mxArray without copying.
-  // - The lifetime of the mxArray buffer exceeds that of the arrow::Buffer here since
-  //   MATLAB should only free this region on garbage-collection after the MEX function
-  //   is executed. Therefore it is safe for arrow::Buffer to point to this location.
-  // - However arrow::Buffer must not free this region by itself, since that could cause
-  //   segfaults if the input array is used later in MATLAB.
-  //   - The Doxygen doc for arrow::Buffer's constructor implies that it is not an RAII
-  //     type, so this should be safe from possible double-free here.
-  std::shared_ptr<Buffer> buffer =
-      std::make_shared<Buffer>(reinterpret_cast<const uint8_t*>(dt),
-                               mxGetElementSize(data) * mxGetNumberOfElements(data));
-
-  // Construct arrow::NumericArray specialization using arrow::Buffer.
-  // Pass in nulls information...we could compute and provide the number of nulls here
-  // too, but passing -1 for now so that Arrow recomputes it if necessary.
-  return std::unique_ptr<Array>(new NumericArray<ArrowDataType>(
-      mxGetNumberOfElements(data), buffer, validity_bitmap, -1));
-}
-
-// Dispatch MATLAB column data to the correct arrow::Array converter.
-std::unique_ptr<Array> WriteVariableData(const mxArray* data, const std::string& type,
-                                         const std::shared_ptr<Buffer> validity_bitmap) {
-  // Get the underlying type of the mxArray data.
-  const mxClassID mxclass = mxGetClassID(data);
-
-  switch (mxclass) {
-    case mxSINGLE_CLASS:
-      return WriteNumericData<FloatType>(data, validity_bitmap);
-    case mxDOUBLE_CLASS:
-      return WriteNumericData<DoubleType>(data, validity_bitmap);
-    case mxUINT8_CLASS:
-      return WriteNumericData<UInt8Type>(data, validity_bitmap);
-    case mxUINT16_CLASS:
-      return WriteNumericData<UInt16Type>(data, validity_bitmap);
-    case mxUINT32_CLASS:
-      return WriteNumericData<UInt32Type>(data, validity_bitmap);
-    case mxUINT64_CLASS:
-      return WriteNumericData<UInt64Type>(data, validity_bitmap);
-    case mxINT8_CLASS:
-      return WriteNumericData<Int8Type>(data, validity_bitmap);
-    case mxINT16_CLASS:
-      return WriteNumericData<Int16Type>(data, validity_bitmap);
-    case mxINT32_CLASS:
-      return WriteNumericData<Int32Type>(data, validity_bitmap);
-    case mxINT64_CLASS:
-      return WriteNumericData<Int64Type>(data, validity_bitmap);
-    default: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:UnsupportedArrowType",
-                        "Unsupported arrow::Type '%s' for variable '%s'",
-                        mxGetClassName(data), type.c_str());
-    }
-  }
-
-  // We shouldn't ever reach this branch, but if we do, return nullptr.
-  return nullptr;
-}
-
-}  // namespace internal
-
-Status FeatherWriter::Open(const std::string& filename,
-                           std::shared_ptr<FeatherWriter>* feather_writer) {
-  // Allocate shared_ptr out parameter.
-  *feather_writer = std::shared_ptr<FeatherWriter>(new FeatherWriter());
-
-  // Open a FileOutputStream corresponding to the provided filename.
-  ARROW_ASSIGN_OR_RAISE(
-      (*feather_writer)->file_output_stream_,
-      io::FileOutputStream::Open(filename, &((*feather_writer)->file_output_stream_)));
-  return Status::OK();
-}
-
-// Write mxArrays from MATLAB into a Feather file.
-Status FeatherWriter::WriteVariables(const mxArray* variables, const mxArray* metadata) {
-  // Verify that all required fieldnames are provided.
-  internal::ValidateMxStructField(variables, "Name", mxCHAR_CLASS, true);
-  internal::ValidateMxStructField(variables, "Type", mxCHAR_CLASS, false);
-  internal::ValidateMxStructField(variables, "Data", mxUNKNOWN_CLASS, true);
-  internal::ValidateMxStructField(variables, "Valid", mxLOGICAL_CLASS, true);
-
-  // Verify that all required fieldnames are provided.
-  internal::ValidateMxStructField(metadata, "NumRows", mxDOUBLE_CLASS, false);
-  internal::ValidateMxStructField(metadata, "NumVariables", mxDOUBLE_CLASS, false);
-
-  // Get the number of columns in the struct array.
-  size_t num_columns = internal::GetNumberOfElements(variables);
-
-  // Get the NumRows field in the struct array and set on TableWriter.
-  num_rows_ = static_cast<int64_t>(mxGetScalar(mxGetField(metadata, 0, "NumRows")));
-  // Get the total number of variables. This is checked later for consistency with
-  // the provided number of columns before finishing the file write.
-  num_variables_ =
-      static_cast<int64_t>(mxGetScalar(mxGetField(metadata, 0, "NumVariables")));
-
-  // Verify that we have all the columns required for writing
-  // Currently we need all columns to be passed in together in the WriteVariables method.
-  internal::ValidateNumColumns(static_cast<int64_t>(num_columns), num_variables_);
-
-  arrow::SchemaBuilder schema_builder;
-  std::vector<std::shared_ptr<arrow::Array>> table_columns;
-
-  const int64_t bitpacked_length = internal::BitPackedLength(num_rows_);
-
-  // Iterate over the input columns and generate arrow arrays.
-  for (int idx = 0; idx < num_columns; ++idx) {
-    // Unwrap constituent mxArray*s from the mxStructArray*. This is safe since we
-    // already checked for existence and non-nullness of these types.
-    const mxArray* name = mxGetField(variables, idx, "Name");
-    const mxArray* data = mxGetField(variables, idx, "Data");
-    const mxArray* type = mxGetField(variables, idx, "Type");
-    const mxArray* valid = mxGetField(variables, idx, "Valid");
-
-    // Convert column and type name to a std::string from mxArray*.
-    std::string name_str = internal::MxArrayToString(name);
-    std::string type_str = internal::MxArrayToString(type);
-
-    auto datatype = internal::ConvertMatlabTypeStringToArrowDataType(type_str);
-    auto field = std::make_shared<arrow::Field>(name_str, datatype);
-
-    ARROW_ASSIGN_OR_RAISE(
-        std::shared_ptr<ResizableBuffer> validity_bitmap,
-        arrow::AllocateResizableBuffer(internal::BitPackedLength(num_rows_)));
-
-    // Populate bit-packed arrow::Buffer using validity data in the mxArray*.
-    internal::BitPackBuffer(valid, validity_bitmap);
-
-    // Wrap mxArray data in an arrow::Array of the equivalent type.
-    auto array = internal::WriteVariableData(data, type_str, validity_bitmap);
-
-    // Verify that the arrow::Array has the right number of elements.
-    internal::ValidateNumRows(array->length(), num_rows_);
-
-    // Append the field to the schema builder
-    RETURN_NOT_OK(schema_builder.AddField(field));
-
-    // Store the table column
-    table_columns.push_back(std::move(array));
-  }
-  // Create the table schema
-  ARROW_ASSIGN_OR_RAISE(auto table_schema, schema_builder.Finish());
-
-  // Specify the feather file format version as V1
-  arrow::ipc::feather::WriteProperties write_props;
-  write_props.version = arrow::ipc::feather::kFeatherV1Version;
-
-  std::shared_ptr<arrow::Table> table = arrow::Table::Make(table_schema, table_columns);
-  // Write the Feather file metadata to the end of the file.
-  return ipc::feather::WriteTable(*table, file_output_stream_.get(), write_props);
-}
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/feather/feather_writer.h b/matlab/src/cpp/arrow/matlab/feather/feather_writer.h
deleted file mode 100644
index 0042d4ac69470..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/feather_writer.h
+++ /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.
-
-#pragma once
-
-#include <arrow/ipc/feather.h>
-#include <arrow/status.h>
-#include <arrow/type.h>
-#include <matrix.h>
-
-#include <memory>
-#include <string>
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-
-class FeatherWriter {
- public:
-  ~FeatherWriter() = default;
-
-  /// \brief Write mxArrays to a Feather file. The first input must be a N-by-1 mxStruct
-  ///         array with the following fields:
-  ///         - "Name" :: Nx1 mxChar array, name of the column
-  ///         - "Type" :: Nx1 mxChar array, the variable's MATLAB datatype
-  ///         - "Data" :: Nx1 mxArray, data for this variable
-  ///         - "Valid" :: Nx1 mxLogical array, 0 represents invalid (null) values and
-  ///                                           1 represents valid (non-null) values
-  ///        The second input must be a scalar mxStruct  with the following
-  ///        fields:
-  ///         - "NumRows" :: scalar mxDouble array, number of rows in table
-  ///         - "NumVariables" :: scalar mxDouble array, total number of variables
-  /// \param[in] variables mxArray* struct array containing table variable data
-  /// \param[in] metadata mxArray* scalar struct containing table-level metadata
-  /// \return status
-  Status WriteVariables(const mxArray* variables, const mxArray* metadata);
-
-  /// \brief Initialize a FeatherWriter object that writes to a Feather file
-  /// \param[in] filename path to the new Feather file
-  /// \param[out] feather_writer uninitialized FeatherWriter object
-  /// \return status
-  static Status Open(const std::string& filename,
-                     std::shared_ptr<FeatherWriter>* feather_writer);
-
- private:
-  FeatherWriter() = default;
-
-  int64_t num_rows_;
-  int64_t num_variables_;
-  std::string description_;
-  std::shared_ptr<arrow::io::OutputStream> file_output_stream_;
-};
-
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/feather/matlab_traits.h b/matlab/src/cpp/arrow/matlab/feather/matlab_traits.h
deleted file mode 100644
index 8ef5aea933a10..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/matlab_traits.h
+++ /dev/null
@@ -1,101 +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.
-
-#pragma once
-
-#include <arrow/type.h>
-#include <matrix.h>
-
-namespace arrow {
-namespace matlab {
-
-/// \brief A type traits class mapping Arrow types to MATLAB types.
-template <typename ArrowDataType>
-struct MatlabTraits;
-
-template <>
-struct MatlabTraits<FloatType> {
-  static constexpr mxClassID matlab_class_id = mxSINGLE_CLASS;
-  using MatlabType = mxSingle;
-  static MatlabType* GetData(mxArray* pa) { return mxGetSingles(pa); }
-};
-
-template <>
-struct MatlabTraits<DoubleType> {
-  static constexpr mxClassID matlab_class_id = mxDOUBLE_CLASS;
-  using MatlabType = mxDouble;
-  static MatlabType* GetData(mxArray* pa) { return mxGetDoubles(pa); }
-};
-
-template <>
-struct MatlabTraits<UInt8Type> {
-  static constexpr mxClassID matlab_class_id = mxUINT8_CLASS;
-  using MatlabType = mxUint8;
-  static MatlabType* GetData(mxArray* pa) { return mxGetUint8s(pa); }
-};
-
-template <>
-struct MatlabTraits<UInt16Type> {
-  static constexpr mxClassID matlab_class_id = mxUINT16_CLASS;
-  using MatlabType = mxUint16;
-  static MatlabType* GetData(mxArray* pa) { return mxGetUint16s(pa); }
-};
-
-template <>
-struct MatlabTraits<UInt32Type> {
-  static constexpr mxClassID matlab_class_id = mxUINT32_CLASS;
-  using MatlabType = mxUint32;
-  static MatlabType* GetData(mxArray* pa) { return mxGetUint32s(pa); }
-};
-
-template <>
-struct MatlabTraits<UInt64Type> {
-  static constexpr mxClassID matlab_class_id = mxUINT64_CLASS;
-  using MatlabType = mxUint64;
-  static MatlabType* GetData(mxArray* pa) { return mxGetUint64s(pa); }
-};
-
-template <>
-struct MatlabTraits<Int8Type> {
-  static constexpr mxClassID matlab_class_id = mxINT8_CLASS;
-  using MatlabType = mxInt8;
-  static MatlabType* GetData(mxArray* pa) { return mxGetInt8s(pa); }
-};
-
-template <>
-struct MatlabTraits<Int16Type> {
-  static constexpr mxClassID matlab_class_id = mxINT16_CLASS;
-  using MatlabType = mxInt16;
-  static MatlabType* GetData(mxArray* pa) { return mxGetInt16s(pa); }
-};
-
-template <>
-struct MatlabTraits<Int32Type> {
-  static constexpr mxClassID matlab_class_id = mxINT32_CLASS;
-  using MatlabType = mxInt32;
-  static MatlabType* GetData(mxArray* pa) { return mxGetInt32s(pa); }
-};
-
-template <>
-struct MatlabTraits<Int64Type> {
-  static constexpr mxClassID matlab_class_id = mxINT64_CLASS;
-  using MatlabType = mxInt64;
-  static MatlabType* GetData(mxArray* pa) { return mxGetInt64s(pa); }
-};
-
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/feather/util/handle_status.cc b/matlab/src/cpp/arrow/matlab/feather/util/handle_status.cc
deleted file mode 100644
index 86d6c1c79cf10..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/util/handle_status.cc
+++ /dev/null
@@ -1,93 +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.
-
-#include <arrow/status.h>
-#include <mex.h>
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace util {
-
-void HandleStatus(const Status& status) {
-  const char* arrow_error_message = "Arrow error: %s";
-  switch (status.code()) {
-    case StatusCode::OK: {
-      break;
-    }
-    case StatusCode::OutOfMemory: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:OutOfMemory", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::KeyError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:KeyError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::TypeError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:TypeError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::Invalid: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:Invalid", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::IOError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:IOError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::CapacityError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:CapacityError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::IndexError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:IndexError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::UnknownError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:UnknownError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::NotImplemented: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:NotImplemented", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    case StatusCode::SerializationError: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:SerializationError", arrow_error_message,
-                        status.ToString().c_str());
-      break;
-    }
-    default: {
-      mexErrMsgIdAndTxt("MATLAB:arrow:status:UnknownStatus", arrow_error_message,
-                        "Unknown status");
-      break;
-    }
-  }
-}
-
-}  // namespace util
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/feather/util/handle_status.h b/matlab/src/cpp/arrow/matlab/feather/util/handle_status.h
deleted file mode 100644
index 3025b3b20805e..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/util/handle_status.h
+++ /dev/null
@@ -1,35 +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.
-
-#pragma once
-
-#include <arrow/status.h>
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace util {
-
-// Terminates execution and returns to the MATLAB prompt,
-// displaying an error message if the given status
-// indicates that an error has occurred.
-void HandleStatus(const Status& status);
-
-}  // namespace util
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.cc b/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.cc
deleted file mode 100644
index 623943d0ca672..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.cc
+++ /dev/null
@@ -1,65 +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.
-
-#include "unicode_conversion.h"
-
-#include <codecvt> /* for std::codecvt_utf8_utf16 */
-#include <locale>  /* for std::wstring_convert */
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace util {
-
-mxArray* ConvertUTF8StringToUTF16CharMatrix(const std::string& utf8_string) {
-  // Get pointers to the start and end of the std::string data.
-  const char* string_start = utf8_string.c_str();
-  const char* string_end = string_start + utf8_string.length();
-
-  // Due to this issue on MSVC: https://stackoverflow.com/q/32055357 we cannot
-  // directly use a destination type of char16_t.
-#if _MSC_VER >= 1900
-  using CharType = int16_t;
-#else
-  using CharType = char16_t;
-#endif
-  using ConverterType = std::codecvt_utf8_utf16<CharType>;
-  std::wstring_convert<ConverterType, CharType> code_converter{};
-
-  std::basic_string<CharType> utf16_string;
-  try {
-    utf16_string = code_converter.from_bytes(string_start, string_end);
-  } catch (...) {
-    // In the case that any error occurs, just try returning a string in the
-    // user's current locale instead.
-    return mxCreateString(string_start);
-  }
-
-  // Store the converter UTF-16 string in a mxCharMatrix and return it.
-  const mwSize dimensions[2] = {1, utf16_string.size()};
-  mxArray* character_matrix = mxCreateCharArray(2, dimensions);
-  mxChar* character_matrix_pointer = mxGetChars(character_matrix);
-  std::copy(utf16_string.data(), utf16_string.data() + utf16_string.size(),
-            character_matrix_pointer);
-
-  return character_matrix;
-}
-
-}  // namespace util
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.h b/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.h
deleted file mode 100644
index 8a41f08605abc..0000000000000
--- a/matlab/src/cpp/arrow/matlab/feather/util/unicode_conversion.h
+++ /dev/null
@@ -1,36 +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.
-
-#pragma once
-
-#include <mex.h>
-
-#include <string>
-
-namespace arrow {
-namespace matlab {
-namespace feather {
-namespace util {
-
-// Converts a UTF-8 encoded std::string to a heap-allocated UTF-16 encoded
-// mxCharArray.
-mxArray* ConvertUTF8StringToUTF16CharMatrix(const std::string& utf8_string);
-
-}  // namespace util
-}  // namespace feather
-}  // namespace matlab
-}  // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/mex/call.cc b/matlab/src/cpp/arrow/matlab/mex/call.cc
deleted file mode 100644
index c1205b071c177..0000000000000
--- a/matlab/src/cpp/arrow/matlab/mex/call.cc
+++ /dev/null
@@ -1,28 +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.
-
-#include <mex.h>
-
-#include "mex_util.h"
-
-void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
-  using namespace arrow::matlab::mex;
-
-  checkNumArgs(nrhs);
-  auto fcn = lookup_function(get_function_name(prhs[0]));
-  fcn(nlhs, plhs, nrhs - 1, ++prhs);
-}
diff --git a/matlab/src/cpp/arrow/matlab/mex/mex_functions.h b/matlab/src/cpp/arrow/matlab/mex/mex_functions.h
deleted file mode 100644
index aa09fc863b29f..0000000000000
--- a/matlab/src/cpp/arrow/matlab/mex/mex_functions.h
+++ /dev/null
@@ -1,40 +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.
-
-#include <string>
-#include <functional>
-#include <unordered_map>
-
-#include <mex.h>
-
-#include "arrow/matlab/feather/feather_functions.h"
-
-namespace arrow {
-namespace matlab {
-namespace mex {
-    
-using namespace arrow::matlab::feather;
-
-using mex_fcn_t =
-    std::function<void(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])>;
-
-static const std::unordered_map<std::string, mex_fcn_t> FUNCTION_MAP = {
-    {"featherread", featherread}, {"featherwrite", featherwrite}};
-
-} // namespace mex
-} // namespace matlab
-} // namespace arrow
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/mex/mex_util.cc b/matlab/src/cpp/arrow/matlab/mex/mex_util.cc
deleted file mode 100644
index bc1bb96b08593..0000000000000
--- a/matlab/src/cpp/arrow/matlab/mex/mex_util.cc
+++ /dev/null
@@ -1,53 +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.
-
-#include "mex_util.h"
-
-namespace arrow {
-namespace matlab {
-namespace mex {
-
-void checkNumArgs(int nrhs) {
-  if (nrhs < 1) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:minrhs",
-                      "'arrow.cpp.call' requires at least one input argument, which must be the "
-                      "name of the C++ function to call.");
-  }
-}
-
-std::string get_function_name(const mxArray* input) {
-  std::string opname;
-  if (!mxIsChar(input)) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:FunctionNameDataType",
-                      "The first input argument to 'arrow.cpp.call' must be a character vector.");
-  }
-  const char* c_str = mxArrayToUTF8String(input);
-  return std::string{c_str};
-}
-
-mex_fcn_t lookup_function(const std::string& function_name) {
-  auto kv_pair = FUNCTION_MAP.find(function_name);
-  if (kv_pair == FUNCTION_MAP.end()) {
-    mexErrMsgIdAndTxt("MATLAB:arrow:UnknownCppFunction", "Unrecognized C++ function '%s'",
-                      function_name.c_str());
-  }
-  return kv_pair->second;
-}
-    
-} // namespace mex
-} // namespace matlab
-} // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/mex/mex_util.h b/matlab/src/cpp/arrow/matlab/mex/mex_util.h
deleted file mode 100644
index 8e02084a288c0..0000000000000
--- a/matlab/src/cpp/arrow/matlab/mex/mex_util.h
+++ /dev/null
@@ -1,42 +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.
-
-#pragma once
-
-#include <string>
-#include <functional>
-#include <unordered_map>
-
-#include <mex.h>
-
-#include "mex_functions.h"
-
-#include "arrow/matlab/api/visibility.h"
-
-namespace arrow {
-namespace matlab {
-namespace mex {
-
-ARROW_MATLAB_EXPORT void checkNumArgs(int nrhs);
-    
-ARROW_MATLAB_EXPORT std::string get_function_name(const mxArray* input);
-    
-ARROW_MATLAB_EXPORT mex_fcn_t lookup_function(const std::string& function_name);
-    
-} // namespace mex
-} // namespace matlab
-} // namespace arrow
diff --git a/matlab/src/cpp/arrow/matlab/mex/mex_util_test.cc b/matlab/src/cpp/arrow/matlab/mex/mex_util_test.cc
deleted file mode 100644
index 8f2c65c75f37e..0000000000000
--- a/matlab/src/cpp/arrow/matlab/mex/mex_util_test.cc
+++ /dev/null
@@ -1,30 +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.
-
-#include <gtest/gtest.h>
-
-#include "mex_util.h"
-
-namespace arrow {
-namespace matlab {
-namespace mex {
-TEST(CheckNumArgsTests, TooFewArgsError) {
-    EXPECT_THROW(checkNumArgs(0), std::exception);
-}
-}  // namespace mex
-}  // namespace matlab
-}  // namespace arrow

From 8bdfc8cd09d575b964fef0e8fa7de600bacf7b5b Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Wed, 16 Aug 2023 15:14:33 -0300
Subject: [PATCH 177/749] GH-37148: [C++] Explicitly list the integer values of
 the Type::type enum (#37149)

### Rationale for this change

The enum type in C++ leaves the integer values implicitly defined and let the compiler assign the values to them automatically. This means an insertion of a new entry that is not at the end, causes implementations that rely on specific values (like R) to break with confusing error messages [1].

Assigning the values explicitly can communicate that these enum entry values are relied upon and can allow a more natural ordering of the list that is different from the numeric order the entries receive.

[1] https://github.com/apache/arrow/issues/37091

### What changes are included in this PR?

 - Setting numeric values of the enum entries explicitly
 - Completing an equivalent enum on the R side

### Are these changes tested?

N/A

### Are there any user-facing changes?

No.
* Closes: #37148

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/type_fwd.h | 76 ++++++++++++++++++++--------------------
 r/R/enums.R              |  4 ++-
 2 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index db76c581f729e..499684719feab 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -292,128 +292,128 @@ struct Type {
     NA = 0,
 
     /// Boolean as 1 bit, LSB bit-packed ordering
-    BOOL,
+    BOOL = 1,
 
     /// Unsigned 8-bit little-endian integer
-    UINT8,
+    UINT8 = 2,
 
     /// Signed 8-bit little-endian integer
-    INT8,
+    INT8 = 3,
 
     /// Unsigned 16-bit little-endian integer
-    UINT16,
+    UINT16 = 4,
 
     /// Signed 16-bit little-endian integer
-    INT16,
+    INT16 = 5,
 
     /// Unsigned 32-bit little-endian integer
-    UINT32,
+    UINT32 = 6,
 
     /// Signed 32-bit little-endian integer
-    INT32,
+    INT32 = 7,
 
     /// Unsigned 64-bit little-endian integer
-    UINT64,
+    UINT64 = 8,
 
     /// Signed 64-bit little-endian integer
-    INT64,
+    INT64 = 9,
 
     /// 2-byte floating point value
-    HALF_FLOAT,
+    HALF_FLOAT = 10,
 
     /// 4-byte floating point value
-    FLOAT,
+    FLOAT = 11,
 
     /// 8-byte floating point value
-    DOUBLE,
+    DOUBLE = 12,
 
     /// UTF8 variable-length string as List<Char>
-    STRING,
+    STRING = 13,
 
     /// Variable-length bytes (no guarantee of UTF8-ness)
-    BINARY,
+    BINARY = 14,
 
     /// Fixed-size binary. Each value occupies the same number of bytes
-    FIXED_SIZE_BINARY,
+    FIXED_SIZE_BINARY = 15,
 
     /// int32_t days since the UNIX epoch
-    DATE32,
+    DATE32 = 16,
 
     /// int64_t milliseconds since the UNIX epoch
-    DATE64,
+    DATE64 = 17,
 
     /// Exact timestamp encoded with int64 since UNIX epoch
     /// Default unit millisecond
-    TIMESTAMP,
+    TIMESTAMP = 18,
 
     /// Time as signed 32-bit integer, representing either seconds or
     /// milliseconds since midnight
-    TIME32,
+    TIME32 = 19,
 
     /// Time as signed 64-bit integer, representing either microseconds or
     /// nanoseconds since midnight
-    TIME64,
+    TIME64 = 20,
 
     /// YEAR_MONTH interval in SQL style
-    INTERVAL_MONTHS,
+    INTERVAL_MONTHS = 21,
 
     /// DAY_TIME interval in SQL style
-    INTERVAL_DAY_TIME,
+    INTERVAL_DAY_TIME = 22,
 
     /// Precision- and scale-based decimal type with 128 bits.
-    DECIMAL128,
+    DECIMAL128 = 23,
 
     /// Defined for backward-compatibility.
     DECIMAL = DECIMAL128,
 
     /// Precision- and scale-based decimal type with 256 bits.
-    DECIMAL256,
+    DECIMAL256 = 24,
 
     /// A list of some logical data type
-    LIST,
+    LIST = 25,
 
     /// Struct of logical types
-    STRUCT,
+    STRUCT = 26,
 
     /// Sparse unions of logical types
-    SPARSE_UNION,
+    SPARSE_UNION = 27,
 
     /// Dense unions of logical types
-    DENSE_UNION,
+    DENSE_UNION = 28,
 
     /// Dictionary-encoded type, also called "categorical" or "factor"
     /// in other programming languages. Holds the dictionary value
     /// type but not the dictionary itself, which is part of the
     /// ArrayData struct
-    DICTIONARY,
+    DICTIONARY = 29,
 
     /// Map, a repeated struct logical type
-    MAP,
+    MAP = 30,
 
     /// Custom data type, implemented by user
-    EXTENSION,
+    EXTENSION = 31,
 
     /// Fixed size list of some logical type
-    FIXED_SIZE_LIST,
+    FIXED_SIZE_LIST = 32,
 
     /// Measure of elapsed time in either seconds, milliseconds, microseconds
     /// or nanoseconds.
-    DURATION,
+    DURATION = 33,
 
     /// Like STRING, but with 64-bit offsets
-    LARGE_STRING,
+    LARGE_STRING = 34,
 
     /// Like BINARY, but with 64-bit offsets
-    LARGE_BINARY,
+    LARGE_BINARY = 35,
 
     /// Like LIST, but with 64-bit offsets
-    LARGE_LIST,
+    LARGE_LIST = 36,
 
     /// Calendar interval type with three fields.
-    INTERVAL_MONTH_DAY_NANO,
+    INTERVAL_MONTH_DAY_NANO = 37,
 
     /// Run-end encoded data.
-    RUN_END_ENCODED,
+    RUN_END_ENCODED = 38,
 
     // Leave this at the end
     MAX_ID
diff --git a/r/R/enums.R b/r/R/enums.R
index a68323d356f3e..7dd5f2f858815 100644
--- a/r/R/enums.R
+++ b/r/R/enums.R
@@ -78,7 +78,9 @@ Type <- enum("Type::type",
   DURATION = 33L,
   LARGE_STRING = 34L,
   LARGE_BINARY = 35L,
-  LARGE_LIST = 36L
+  LARGE_LIST = 36L,
+  INTERVAL_MONTH_DAY_NANO = 37L,
+  RUN_END_ENCODED = 38L
 )
 
 TYPES_WITH_NAN <- Type[c("HALF_FLOAT", "FLOAT", "DOUBLE")]

From 0e677d27ae8ed489f2fa6f5e95b0e498319a887e Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Wed, 16 Aug 2023 11:26:00 -0700
Subject: [PATCH 178/749] GH-35698: [C#] Update FlatBuffers (#35699)

### Rationale for this change

The FlatBuffers definitions in the C# code don't seem to have been updated for a while. Adding the latest FlatBuffers code ensures that we're up to date with both the Arrow definitions and the FlatBuffers compiler.

### What changes are included in this PR?

The latest version of the C# FlatBuffers runtime files were copied into the project (with visibility changed from public to internal).
The latest version of the FlatBuffers compiler was used against the latest version of the Arrow .fbs source. The output of the compiler was edited to more closely match the existing code by moving it into the directory structure and namespaces of the existing classes and by changing class visibility from public to internal.
A few small changes were made to the existing source to accommodate changes in the FlatBuffers runtime, most specifically that the files have moved from the namespace "FlatBuffers" to the namespace "Google.FlatBuffers".

### Are these changes tested?

No substantive product changes were made. All tests still pass.

### Are there any user-facing changes?

No.

Resolves #35698
* Closes: #35698

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 .../Internal/FlightDataStream.cs              |   2 +-
 .../Internal/FlightMessageSerializer.cs       |   2 +-
 csharp/src/Apache.Arrow/Flatbuf/Block.cs      |   9 +-
 .../Apache.Arrow/Flatbuf/BodyCompression.cs   |  28 +-
 csharp/src/Apache.Arrow/Flatbuf/Buffer.cs     |  12 +-
 .../Apache.Arrow/Flatbuf/DictionaryBatch.cs   |  29 +-
 .../Flatbuf/DictionaryEncoding.cs             |  42 +-
 .../Flatbuf/Enums/BodyCompressionMethod.cs    |   2 +-
 .../Flatbuf/Enums/DictionaryKind.cs           |  19 +
 .../Flatbuf/Enums/IntervalUnit.cs             |   5 +-
 .../Flatbuf/Enums/MessageHeader.cs            |  42 +-
 csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs | 127 ++-
 csharp/src/Apache.Arrow/Flatbuf/Field.cs      |  75 +-
 csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs  |   9 +-
 .../Apache.Arrow/Flatbuf/FixedSizeBinary.cs   |  24 +-
 .../src/Apache.Arrow/Flatbuf/FixedSizeList.cs |  24 +-
 .../Flatbuf/FlatBuffers/ByteBuffer.cs         | 270 ++++--
 .../Flatbuf/FlatBuffers/ByteBufferUtil.cs     |   2 +-
 .../Flatbuf/FlatBuffers/FlatBufferBuilder.cs  | 243 +++++-
 .../FlatBuffers/FlatBufferConstants.cs        |  10 +-
 .../Flatbuf/FlatBuffers/FlatBufferVerify.cs   | 822 ++++++++++++++++++
 .../Flatbuf/FlatBuffers/IFlatbufferObject.cs  |   2 +-
 .../Flatbuf/FlatBuffers/Offset.cs             |   2 +-
 .../Flatbuf/FlatBuffers/Struct.cs             |  13 +-
 .../Apache.Arrow/Flatbuf/FlatBuffers/Table.cs |  37 +-
 csharp/src/Apache.Arrow/Flatbuf/Footer.cs     |  31 +-
 csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs   |  29 +-
 csharp/src/Apache.Arrow/Flatbuf/Map.cs        |  41 +-
 csharp/src/Apache.Arrow/Flatbuf/Message.cs    |  38 +-
 .../src/Apache.Arrow/Flatbuf/RecordBatch.cs   |  27 +-
 .../src/Apache.Arrow/Flatbuf/RunEndEncoded.cs |  45 +
 csharp/src/Apache.Arrow/Flatbuf/Schema.cs     |  38 +-
 .../Flatbuf/SparseMatrixCompressedAxis.cs     |  15 +
 .../Flatbuf/SparseMatrixIndexCSX.cs           |  95 ++
 .../src/Apache.Arrow/Flatbuf/SparseTensor.cs  | 106 +++
 .../Apache.Arrow/Flatbuf/SparseTensorIndex.cs |  42 +
 .../Flatbuf/SparseTensorIndexCOO.cs           | 107 +++
 .../Flatbuf/SparseTensorIndexCSF.cs           | 155 ++++
 csharp/src/Apache.Arrow/Flatbuf/Tensor.cs     |  63 +-
 csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs  |  27 +-
 .../src/Apache.Arrow/Flatbuf/Types/Binary.cs  |  22 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs |  28 +-
 .../src/Apache.Arrow/Flatbuf/Types/Decimal.cs |  28 +-
 .../Apache.Arrow/Flatbuf/Types/Duration.cs    |  24 +-
 .../Flatbuf/Types/FloatingPoint.cs            |  24 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs  |  25 +-
 .../Apache.Arrow/Flatbuf/Types/Interval.cs    |  24 +-
 .../Apache.Arrow/Flatbuf/Types/LargeBinary.cs |  21 +-
 .../Apache.Arrow/Flatbuf/Types/LargeList.cs   |  21 +-
 .../Apache.Arrow/Flatbuf/Types/LargeUtf8.cs   |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/List.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs |  21 +-
 .../src/Apache.Arrow/Flatbuf/Types/Struct_.cs |  21 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs |  42 +-
 .../Apache.Arrow/Flatbuf/Types/Timestamp.cs   | 160 +++-
 .../src/Apache.Arrow/Flatbuf/Types/Union.cs   |  31 +-
 csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs |  21 +-
 .../src/Apache.Arrow/Ipc/ArrowFileWriter.cs   |  16 +-
 .../Ipc/ArrowMemoryReaderImplementation.cs    |   2 +-
 .../Ipc/ArrowReaderImplementation.cs          |   2 +-
 .../Ipc/ArrowStreamReaderImplementation.cs    |   8 +-
 .../src/Apache.Arrow/Ipc/ArrowStreamWriter.cs |   2 +-
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |   2 +-
 .../Ipc/ReadOnlyMemoryBufferAllocator.cs      |   2 +-
 65 files changed, 2922 insertions(+), 399 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
 create mode 100644 csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs

diff --git a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
index 8658845723222..3211212c99cb9 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
@@ -22,7 +22,7 @@
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Flight.Protocol;
 using Apache.Arrow.Ipc;
-using FlatBuffers;
+using Google.FlatBuffers;
 using Google.Protobuf;
 using Grpc.Core;
 
diff --git a/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs b/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
index 36b13a63d3c0f..9df28b5033c06 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/FlightMessageSerializer.cs
@@ -19,7 +19,7 @@
 using System.IO;
 using System.Text;
 using Apache.Arrow.Ipc;
-using FlatBuffers;
+using Google.FlatBuffers;
 
 namespace Apache.Arrow.Flight
 {
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Block.cs b/csharp/src/Apache.Arrow/Flatbuf/Block.cs
index 89c065b202c3a..8df0159cd6921 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Block.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Block.cs
@@ -6,13 +6,14 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Block : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public Block __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Index to the start of the RecordBlock (note this is past the Message header)
@@ -20,7 +21,7 @@ internal struct Block : IFlatbufferObject
   /// Length of the metadata
   public int MetaDataLength { get { return __p.bb.GetInt(__p.bb_pos + 8); } }
   /// Length of the data (this is aligned so there can be a gap between this and
-  /// the metatdata).
+  /// the metadata).
   public long BodyLength { get { return __p.bb.GetLong(__p.bb_pos + 16); } }
 
   public static Offset<Block> CreateBlock(FlatBufferBuilder builder, long Offset, int MetaDataLength, long BodyLength) {
@@ -31,7 +32,7 @@ public static Offset<Block> CreateBlock(FlatBufferBuilder builder, long Offset,
     builder.PutLong(Offset);
     return new Offset<Block>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs b/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
index dda0dd403518f..bbc0e1e46fd7c 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/BodyCompression.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Optional compression for the memory buffers constituting IPC message
 /// bodies. Intended for use with RecordBatch but could be used for other
@@ -15,12 +16,14 @@ internal struct BodyCompression : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static BodyCompression GetRootAsBodyCompression(ByteBuffer _bb) { return GetRootAsBodyCompression(_bb, new BodyCompression()); }
   public static BodyCompression GetRootAsBodyCompression(ByteBuffer _bb, BodyCompression obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public BodyCompression __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
-  /// Compressor library
+  /// Compressor library.
+  /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
   public CompressionType Codec { get { int o = __p.__offset(4); return o != 0 ? (CompressionType)__p.bb.GetSbyte(o + __p.bb_pos) : CompressionType.LZ4_FRAME; } }
   /// Indicates the way the record batch body was compressed
   public BodyCompressionMethod Method { get { int o = __p.__offset(6); return o != 0 ? (BodyCompressionMethod)__p.bb.GetSbyte(o + __p.bb_pos) : BodyCompressionMethod.BUFFER; } }
@@ -28,20 +31,31 @@ internal struct BodyCompression : IFlatbufferObject
   public static Offset<BodyCompression> CreateBodyCompression(FlatBufferBuilder builder,
       CompressionType codec = CompressionType.LZ4_FRAME,
       BodyCompressionMethod method = BodyCompressionMethod.BUFFER) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     BodyCompression.AddMethod(builder, method);
     BodyCompression.AddCodec(builder, codec);
     return BodyCompression.EndBodyCompression(builder);
   }
 
-  public static void StartBodyCompression(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartBodyCompression(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddCodec(FlatBufferBuilder builder, CompressionType codec) { builder.AddSbyte(0, (sbyte)codec, 0); }
   public static void AddMethod(FlatBufferBuilder builder, BodyCompressionMethod method) { builder.AddSbyte(1, (sbyte)method, 0); }
   public static Offset<BodyCompression> EndBodyCompression(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<BodyCompression>(o);
   }
-};
+}
+
 
+static internal class BodyCompressionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Codec*/, 1 /*CompressionType*/, 1, false)
+      && verifier.VerifyField(tablePos, 6 /*Method*/, 1 /*BodyCompressionMethod*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs b/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
index 7b2315cab4b29..419800d1338e4 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Buffer.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A Buffer represents a single contiguous memory segment
@@ -14,14 +15,17 @@ internal struct Buffer : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public Buffer __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// The relative offset into the shared memory page where the bytes for this
   /// buffer starts
   public long Offset { get { return __p.bb.GetLong(__p.bb_pos + 0); } }
   /// The absolute length (in bytes) of the memory buffer. The memory is found
-  /// from offset (inclusive) to offset + length (non-inclusive).
+  /// from offset (inclusive) to offset + length (non-inclusive). When building
+  /// messages using the encapsulated IPC message, padding bytes may be written
+  /// after a buffer, but such padding bytes do not need to be accounted for in
+  /// the size here.
   public long Length { get { return __p.bb.GetLong(__p.bb_pos + 8); } }
 
   public static Offset<Buffer> CreateBuffer(FlatBufferBuilder builder, long Offset, long Length) {
@@ -30,7 +34,7 @@ public static Offset<Buffer> CreateBuffer(FlatBufferBuilder builder, long Offset
     builder.PutLong(Offset);
     return new Offset<Buffer>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs b/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
index e3afafdd5cb16..180e94108d1a7 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/DictionaryBatch.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// For sending dictionary encoding information. Any Field can be
 /// dictionary-encoded, but in this case none of its children may be
@@ -18,37 +19,51 @@ internal struct DictionaryBatch : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static DictionaryBatch GetRootAsDictionaryBatch(ByteBuffer _bb) { return GetRootAsDictionaryBatch(_bb, new DictionaryBatch()); }
   public static DictionaryBatch GetRootAsDictionaryBatch(ByteBuffer _bb, DictionaryBatch obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public DictionaryBatch __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public RecordBatch? Data { get { int o = __p.__offset(6); return o != 0 ? (RecordBatch?)(new RecordBatch()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
   /// If isDelta is true the values in the dictionary are to be appended to a
-  /// dictionary with the indicated id
+  /// dictionary with the indicated id. If isDelta is false this dictionary
+  /// should replace the existing dictionary.
   public bool IsDelta { get { int o = __p.__offset(8); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
 
   public static Offset<DictionaryBatch> CreateDictionaryBatch(FlatBufferBuilder builder,
       long id = 0,
       Offset<RecordBatch> dataOffset = default(Offset<RecordBatch>),
       bool isDelta = false) {
-    builder.StartObject(3);
+    builder.StartTable(3);
     DictionaryBatch.AddId(builder, id);
     DictionaryBatch.AddData(builder, dataOffset);
     DictionaryBatch.AddIsDelta(builder, isDelta);
     return DictionaryBatch.EndDictionaryBatch(builder);
   }
 
-  public static void StartDictionaryBatch(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDictionaryBatch(FlatBufferBuilder builder) { builder.StartTable(3); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddData(FlatBufferBuilder builder, Offset<RecordBatch> dataOffset) { builder.AddOffset(1, dataOffset.Value, 0); }
   public static void AddIsDelta(FlatBufferBuilder builder, bool isDelta) { builder.AddBool(2, isDelta, false); }
   public static Offset<DictionaryBatch> EndDictionaryBatch(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<DictionaryBatch>(o);
   }
-};
+}
+
 
+static internal class DictionaryBatchVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTable(tablePos, 6 /*Data*/, RecordBatchVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 8 /*IsDelta*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs b/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
index 02a35fdd41b1e..ecf1dd788f468 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/DictionaryEncoding.cs
@@ -6,52 +6,72 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// ----------------------------------------------------------------------
-/// Dictionary encoding metadata
 internal struct DictionaryEncoding : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static DictionaryEncoding GetRootAsDictionaryEncoding(ByteBuffer _bb) { return GetRootAsDictionaryEncoding(_bb, new DictionaryEncoding()); }
   public static DictionaryEncoding GetRootAsDictionaryEncoding(ByteBuffer _bb, DictionaryEncoding obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public DictionaryEncoding __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// 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
   public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  /// The dictionary indices are constrained to be positive integers. If this
-  /// field is null, the indices must be signed int32
+  /// The dictionary indices are constrained to be non-negative integers. If
+  /// this field is null, the indices must be signed int32. To maximize
+  /// cross-language compatibility and performance, implementations are
+  /// recommended to prefer signed integer types over unsigned integer types
+  /// and to avoid uint64 indices unless they are required by an application.
   public Int? IndexType { get { int o = __p.__offset(6); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
   /// By default, dictionaries are not ordered, or the order does not have
   /// semantic meaning. In some statistical, applications, dictionary-encoding
   /// is used to represent ordered categorical data, and we provide a way to
   /// preserve that metadata here
   public bool IsOrdered { get { int o = __p.__offset(8); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public DictionaryKind DictionaryKind { get { int o = __p.__offset(10); return o != 0 ? (DictionaryKind)__p.bb.GetShort(o + __p.bb_pos) : DictionaryKind.DenseArray; } }
 
   public static Offset<DictionaryEncoding> CreateDictionaryEncoding(FlatBufferBuilder builder,
       long id = 0,
       Offset<Int> indexTypeOffset = default(Offset<Int>),
-      bool isOrdered = false) {
-    builder.StartObject(3);
+      bool isOrdered = false,
+      DictionaryKind dictionaryKind = DictionaryKind.DenseArray) {
+    builder.StartTable(4);
     DictionaryEncoding.AddId(builder, id);
     DictionaryEncoding.AddIndexType(builder, indexTypeOffset);
+    DictionaryEncoding.AddDictionaryKind(builder, dictionaryKind);
     DictionaryEncoding.AddIsOrdered(builder, isOrdered);
     return DictionaryEncoding.EndDictionaryEncoding(builder);
   }
 
-  public static void StartDictionaryEncoding(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDictionaryEncoding(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddIndexType(FlatBufferBuilder builder, Offset<Int> indexTypeOffset) { builder.AddOffset(1, indexTypeOffset.Value, 0); }
   public static void AddIsOrdered(FlatBufferBuilder builder, bool isOrdered) { builder.AddBool(2, isOrdered, false); }
+  public static void AddDictionaryKind(FlatBufferBuilder builder, DictionaryKind dictionaryKind) { builder.AddShort(3, (short)dictionaryKind, 0); }
   public static Offset<DictionaryEncoding> EndDictionaryEncoding(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<DictionaryEncoding>(o);
   }
-};
+}
+
 
+static internal class DictionaryEncodingVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
+      && verifier.VerifyTable(tablePos, 6 /*IndexType*/, IntVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 8 /*IsOrdered*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 10 /*DictionaryKind*/, 2 /*DictionaryKind*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
index e9f6b6e831e54..e1f0c8f79ddf4 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/BodyCompressionMethod.cs
@@ -17,7 +17,7 @@ internal enum BodyCompressionMethod : sbyte
   /// 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.
- BUFFER = 0,
+  BUFFER = 0,
 };
 
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
new file mode 100644
index 0000000000000..9a67bc7c5c86f
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/DictionaryKind.cs
@@ -0,0 +1,19 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+/// ----------------------------------------------------------------------
+/// Dictionary encoding metadata
+/// Maintained for forwards compatibility, in the future
+/// Dictionaries might be explicit maps between integers and values
+/// allowing for non-contiguous index values
+internal enum DictionaryKind : short
+{
+  DenseArray = 0,
+};
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
index d1363968df064..ac82c72e24e8b 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/IntervalUnit.cs
@@ -7,8 +7,9 @@ namespace Apache.Arrow.Flatbuf
 
 internal enum IntervalUnit : short
 {
- YEAR_MONTH = 0,
- DAY_TIME = 1,
+  YEAR_MONTH = 0,
+  DAY_TIME = 1,
+  MONTH_DAY_NANO = 2,
 };
 
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
index 94d239bfa9345..1204b1e276e6e 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/MessageHeader.cs
@@ -15,12 +15,44 @@ namespace Apache.Arrow.Flatbuf
 /// it is best to send data using RecordBatch
 internal enum MessageHeader : byte
 {
- NONE = 0,
- Schema = 1,
- DictionaryBatch = 2,
- RecordBatch = 3,
- Tensor = 4,
+  NONE = 0,
+  Schema = 1,
+  DictionaryBatch = 2,
+  RecordBatch = 3,
+  Tensor = 4,
+  SparseTensor = 5,
 };
 
 
+
+static internal class MessageHeaderVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((MessageHeader)typeId)
+    {
+      case MessageHeader.Schema:
+        result = SchemaVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.DictionaryBatch:
+        result = DictionaryBatchVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.RecordBatch:
+        result = RecordBatchVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.Tensor:
+        result = TensorVerify.Verify(verifier, tablePos);
+        break;
+      case MessageHeader.SparseTensor:
+        result = SparseTensorVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs b/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
index e8a7932a70369..10f852efb9b96 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Enums/Type.cs
@@ -10,29 +10,112 @@ namespace Apache.Arrow.Flatbuf
 /// add new logical types to Type without breaking backwards compatibility
 internal enum Type : byte
 {
- NONE = 0,
- Null = 1,
- Int = 2,
- FloatingPoint = 3,
- Binary = 4,
- Utf8 = 5,
- Bool = 6,
- Decimal = 7,
- Date = 8,
- Time = 9,
- Timestamp = 10,
- Interval = 11,
- List = 12,
- Struct_ = 13,
- Union = 14,
- FixedSizeBinary = 15,
- FixedSizeList = 16,
- Map = 17,
- Duration = 18,
- LargeBinary = 19,
- LargeUtf8 = 20,
- LargeList = 21,
+  NONE = 0,
+  Null = 1,
+  Int = 2,
+  FloatingPoint = 3,
+  Binary = 4,
+  Utf8 = 5,
+  Bool = 6,
+  Decimal = 7,
+  Date = 8,
+  Time = 9,
+  Timestamp = 10,
+  Interval = 11,
+  List = 12,
+  Struct_ = 13,
+  Union = 14,
+  FixedSizeBinary = 15,
+  FixedSizeList = 16,
+  Map = 17,
+  Duration = 18,
+  LargeBinary = 19,
+  LargeUtf8 = 20,
+  LargeList = 21,
+  RunEndEncoded = 22,
 };
 
 
+
+static internal class TypeVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((Type)typeId)
+    {
+      case Type.Null:
+        result = NullVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Int:
+        result = IntVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FloatingPoint:
+        result = FloatingPointVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Binary:
+        result = BinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Utf8:
+        result = Utf8Verify.Verify(verifier, tablePos);
+        break;
+      case Type.Bool:
+        result = BoolVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Decimal:
+        result = DecimalVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Date:
+        result = DateVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Time:
+        result = TimeVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Timestamp:
+        result = TimestampVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Interval:
+        result = IntervalVerify.Verify(verifier, tablePos);
+        break;
+      case Type.List:
+        result = ListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Struct_:
+        result = Struct_Verify.Verify(verifier, tablePos);
+        break;
+      case Type.Union:
+        result = UnionVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FixedSizeBinary:
+        result = FixedSizeBinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.FixedSizeList:
+        result = FixedSizeListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Map:
+        result = MapVerify.Verify(verifier, tablePos);
+        break;
+      case Type.Duration:
+        result = DurationVerify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeBinary:
+        result = LargeBinaryVerify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeUtf8:
+        result = LargeUtf8Verify.Verify(verifier, tablePos);
+        break;
+      case Type.LargeList:
+        result = LargeListVerify.Verify(verifier, tablePos);
+        break;
+      case Type.RunEndEncoded:
+        result = RunEndEncodedVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Field.cs b/csharp/src/Apache.Arrow/Flatbuf/Field.cs
index a4f9e3057343e..c5c6c0a165598 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Field.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Field.cs
@@ -6,49 +6,76 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A field represents a named column in a record / row batch or child of a
 /// nested type.
-///
-/// - children is only for nested Arrow arrays
-/// - For primitive types, children will have length 0
-/// - nullable should default to true in general
 internal struct Field : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Field GetRootAsField(ByteBuffer _bb) { return GetRootAsField(_bb, new Field()); }
   public static Field GetRootAsField(ByteBuffer _bb, Field obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Field __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
+  /// Name is not required, in i.e. a List
   public string Name { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameBytes() { return __p.__vector_as_span(4); }
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(4, 1); }
 #else
   public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(4); }
 #endif
   public byte[] GetNameArray() { return __p.__vector_as_array<byte>(4); }
+  /// Whether or not this field can contain nulls. Should be true in general.
   public bool Nullable { get { int o = __p.__offset(6); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-  public Type TypeType { get { int o = __p.__offset(8); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Flatbuf.Type.NONE; } }
-  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public Type TypeType { get { int o = __p.__offset(8); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
+  /// This is the type of the decoded value if the field is dictionary encoded.
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
+  /// Present only if the field is dictionary encoded.
   public DictionaryEncoding? Dictionary { get { int o = __p.__offset(12); return o != 0 ? (DictionaryEncoding?)(new DictionaryEncoding()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// children apply only to nested data types like Struct, List and Union. For
+  /// primitive types children will have length 0.
   public Field? Children(int j) { int o = __p.__offset(14); return o != 0 ? (Field?)(new Field()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int ChildrenLength { get { int o = __p.__offset(14); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// User-defined metadata
   public KeyValue? CustomMetadata(int j) { int o = __p.__offset(16); return o != 0 ? (KeyValue?)(new KeyValue()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int CustomMetadataLength { get { int o = __p.__offset(16); return o != 0 ? __p.__vector_len(o) : 0; } }
 
   public static Offset<Field> CreateField(FlatBufferBuilder builder,
       StringOffset nameOffset = default(StringOffset),
       bool nullable = false,
-      Type type_type = Flatbuf.Type.NONE,
+      Type type_type = Apache.Arrow.Flatbuf.Type.NONE,
       int typeOffset = 0,
       Offset<DictionaryEncoding> dictionaryOffset = default(Offset<DictionaryEncoding>),
       VectorOffset childrenOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(7);
+    builder.StartTable(7);
     Field.AddCustomMetadata(builder, custom_metadataOffset);
     Field.AddChildren(builder, childrenOffset);
     Field.AddDictionary(builder, dictionaryOffset);
@@ -59,7 +86,7 @@ public static Offset<Field> CreateField(FlatBufferBuilder builder,
     return Field.EndField(builder);
   }
 
-  public static void StartField(FlatBufferBuilder builder) { builder.StartObject(7); }
+  public static void StartField(FlatBufferBuilder builder) { builder.StartTable(7); }
   public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(0, nameOffset.Value, 0); }
   public static void AddNullable(FlatBufferBuilder builder, bool nullable) { builder.AddBool(1, nullable, false); }
   public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(2, (byte)typeType, 0); }
@@ -68,16 +95,36 @@ public static Offset<Field> CreateField(FlatBufferBuilder builder,
   public static void AddChildren(FlatBufferBuilder builder, VectorOffset childrenOffset) { builder.AddOffset(5, childrenOffset.Value, 0); }
   public static VectorOffset CreateChildrenVector(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<Field>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateChildrenVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<Field>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartChildrenVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(6, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Field> EndField(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Field>(o);
   }
-};
+}
+
 
+static internal class FieldVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Name*/, false)
+      && verifier.VerifyField(tablePos, 6 /*Nullable*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 8 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 8, 10 /*Type*/, TypeVerify.Verify, false)
+      && verifier.VerifyTable(tablePos, 12 /*Dictionary*/, DictionaryEncodingVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 14 /*Children*/, FieldVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 16 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs b/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
index 811e10ea46bdf..960970d73e0a2 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FieldNode.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Data structures for describing a table row batch (a collection of
@@ -14,14 +15,14 @@ namespace Apache.Arrow.Flatbuf
 /// 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
 internal struct FieldNode : IFlatbufferObject
 {
   private Struct __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
   public FieldNode __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// The number of value slots in the Arrow array at this level of a nested
@@ -38,7 +39,7 @@ public static Offset<FieldNode> CreateFieldNode(FlatBufferBuilder builder, long
     builder.PutLong(Length);
     return new Offset<FieldNode>(builder.Offset);
   }
-};
+}
 
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
index b6414a23b5c2e..babe81f7f1fb5 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeBinary.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FixedSizeBinary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FixedSizeBinary GetRootAsFixedSizeBinary(ByteBuffer _bb) { return GetRootAsFixedSizeBinary(_bb, new FixedSizeBinary()); }
   public static FixedSizeBinary GetRootAsFixedSizeBinary(ByteBuffer _bb, FixedSizeBinary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FixedSizeBinary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Number of bytes per value
@@ -22,18 +24,28 @@ internal struct FixedSizeBinary : IFlatbufferObject
 
   public static Offset<FixedSizeBinary> CreateFixedSizeBinary(FlatBufferBuilder builder,
       int byteWidth = 0) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FixedSizeBinary.AddByteWidth(builder, byteWidth);
     return FixedSizeBinary.EndFixedSizeBinary(builder);
   }
 
-  public static void StartFixedSizeBinary(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFixedSizeBinary(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddByteWidth(FlatBufferBuilder builder, int byteWidth) { builder.AddInt(0, byteWidth, 0); }
   public static Offset<FixedSizeBinary> EndFixedSizeBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FixedSizeBinary>(o);
   }
-};
+}
+
 
+static internal class FixedSizeBinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ByteWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
index 0ca69b7a1960f..6293a7fdd896c 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FixedSizeList.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FixedSizeList : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FixedSizeList GetRootAsFixedSizeList(ByteBuffer _bb) { return GetRootAsFixedSizeList(_bb, new FixedSizeList()); }
   public static FixedSizeList GetRootAsFixedSizeList(ByteBuffer _bb, FixedSizeList obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FixedSizeList __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Number of list items per value
@@ -22,18 +24,28 @@ internal struct FixedSizeList : IFlatbufferObject
 
   public static Offset<FixedSizeList> CreateFixedSizeList(FlatBufferBuilder builder,
       int listSize = 0) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FixedSizeList.AddListSize(builder, listSize);
     return FixedSizeList.EndFixedSizeList(builder);
   }
 
-  public static void StartFixedSizeList(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFixedSizeList(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddListSize(FlatBufferBuilder builder, int listSize) { builder.AddInt(0, listSize, 0); }
   public static Offset<FixedSizeList> EndFixedSizeList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FixedSizeList>(o);
   }
-};
+}
+
 
+static internal class FixedSizeListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*ListSize*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs
index 91cd5cccb647f..e65735c347a6d 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBuffer.cs
@@ -14,24 +14,25 @@
  * limitations under the License.
  */
 
-// There are 3 #defines that have an impact on performance / features of this ByteBuffer implementation
+// There are three conditional compilation symbols that have an impact on performance/features of this ByteBuffer implementation.
 //
-//      UNSAFE_BYTEBUFFER 
+//      UNSAFE_BYTEBUFFER
 //          This will use unsafe code to manipulate the underlying byte array. This
 //          can yield a reasonable performance increase.
 //
 //      BYTEBUFFER_NO_BOUNDS_CHECK
 //          This will disable the bounds check asserts to the byte array. This can
-//          yield a small performance gain in normal code..
+//          yield a small performance gain in normal code.
 //
 //      ENABLE_SPAN_T
-//          This will enable reading and writing blocks of memory with a Span<T> instead if just
+//          This will enable reading and writing blocks of memory with a Span<T> instead of just
 //          T[].  You can also enable writing directly to shared memory or other types of memory
 //          by providing a custom implementation of ByteBufferAllocator.
-//          ENABLE_SPAN_T also requires UNSAFE_BYTEBUFFER to be defined
+//          ENABLE_SPAN_T also requires UNSAFE_BYTEBUFFER to be defined, or .NET
+//          Standard 2.1.
 //
 // Using UNSAFE_BYTEBUFFER and BYTEBUFFER_NO_BOUNDS_CHECK together can yield a
-// performance gain of ~15% for some operations, however doing so is potentially 
+// performance gain of ~15% for some operations, however doing so is potentially
 // dangerous. Do so at your own risk!
 //
 
@@ -42,19 +43,19 @@
 using System.Runtime.InteropServices;
 using System.Text;
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
 using System.Buffers.Binary;
 #endif
 
-#if ENABLE_SPAN_T && !UNSAFE_BYTEBUFFER
-#error ENABLE_SPAN_T requires UNSAFE_BYTEBUFFER to also be defined
+#if ENABLE_SPAN_T && !UNSAFE_BYTEBUFFER && !NETSTANDARD2_1
+#warning ENABLE_SPAN_T requires UNSAFE_BYTEBUFFER to also be defined
 #endif
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     internal abstract class ByteBufferAllocator
     {
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public abstract Span<byte> Span { get; }
         public abstract ReadOnlySpan<byte> ReadOnlySpan { get; }
         public abstract Memory<byte> Memory { get; }
@@ -102,7 +103,7 @@ public override void GrowFront(int newSize)
             InitBuffer();
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public override Span<byte> Span => _buffer;
         public override ReadOnlySpan<byte> ReadOnlySpan => _buffer;
         public override Memory<byte> Memory => _buffer;
@@ -214,7 +215,7 @@ public static bool IsSupportedType<T>()
         }
 
         /// <summary>
-        /// Get the wire-size (in bytes) of a typed array
+        /// Get the wire-size (in bytes) of an typed array
         /// </summary>
         /// <typeparam name="T">The type of the array</typeparam>
         /// <param name="x">The array to get the size of</param>
@@ -224,7 +225,19 @@ public static int ArraySize<T>(T[] x)
             return SizeOf<T>() * x.Length;
         }
 
-#if ENABLE_SPAN_T
+        /// <summary>
+        /// Get the wire-size (in bytes) of an typed array segment, taking only the
+        /// range specified by <paramref name="x"/> into account.
+        /// </summary>
+        /// <typeparam name="T">The type of the array</typeparam>
+        /// <param name="x">The array segment to get the size of</param>
+        /// <returns>The number of bytes the array segment takes on wire</returns>
+        public static int ArraySize<T>(ArraySegment<T> x)
+        {
+            return SizeOf<T>() * x.Count;
+        }
+
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public static int ArraySize<T>(Span<T> x)
         {
             return SizeOf<T>() * x.Length;
@@ -233,7 +246,7 @@ public static int ArraySize<T>(Span<T> x)
 
         // Get a portion of the buffer casted into an array of type T, given
         // the buffer position and length.
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public T[] ToArray<T>(int pos, int len)
             where T : struct
         {
@@ -261,7 +274,7 @@ public byte[] ToFullArray()
             return ToArray<byte>(0, Length);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public ReadOnlyMemory<byte> ToReadOnlyMemory(int pos, int len)
         {
             return _buffer.ReadOnlyMemory.Slice(pos, len);
@@ -289,11 +302,14 @@ public MemoryStream ToMemoryStream(int pos, int len)
 #endif
 
 #if !UNSAFE_BYTEBUFFER
-        // Pre-allocated helper arrays for conversion.
-        private float[] floathelper = new[] { 0.0f };
-        private int[] inthelper = new[] { 0 };
-        private double[] doublehelper = new[] { 0.0 };
-        private ulong[] ulonghelper = new[] { 0UL };
+        // A conversion union where all the members are overlapping. This allows to reinterpret the bytes of one type
+        // as another, without additional copies.
+        [StructLayout(LayoutKind.Explicit)]
+        struct ConversionUnion
+        {
+          [FieldOffset(0)] public int intValue;
+          [FieldOffset(0)] public float floatValue;
+        }
 #endif // !UNSAFE_BYTEBUFFER
 
         // Helper functions for the unsafe version.
@@ -305,8 +321,8 @@ static public ushort ReverseBytes(ushort input)
         static public uint ReverseBytes(uint input)
         {
             return ((input & 0x000000FFU) << 24) |
-                   ((input & 0x0000FF00U) << 8) |
-                   ((input & 0x00FF0000U) >> 8) |
+                   ((input & 0x0000FF00U) <<  8) |
+                   ((input & 0x00FF0000U) >>  8) |
                    ((input & 0xFF000000U) >> 24);
         }
         static public ulong ReverseBytes(ulong input)
@@ -314,14 +330,14 @@ static public ulong ReverseBytes(ulong input)
             return (((input & 0x00000000000000FFUL) << 56) |
                     ((input & 0x000000000000FF00UL) << 40) |
                     ((input & 0x0000000000FF0000UL) << 24) |
-                    ((input & 0x00000000FF000000UL) << 8) |
-                    ((input & 0x000000FF00000000UL) >> 8) |
+                    ((input & 0x00000000FF000000UL) <<  8) |
+                    ((input & 0x000000FF00000000UL) >>  8) |
                     ((input & 0x0000FF0000000000UL) >> 24) |
                     ((input & 0x00FF000000000000UL) >> 40) |
                     ((input & 0xFF00000000000000UL) >> 56));
         }
 
-#if !UNSAFE_BYTEBUFFER
+#if !UNSAFE_BYTEBUFFER && (!ENABLE_SPAN_T || !NETSTANDARD2_1)
         // Helper functions for the safe (but slower) version.
         protected void WriteLittleEndian(int offset, int count, ulong data)
         {
@@ -361,7 +377,46 @@ protected ulong ReadLittleEndian(int offset, int count)
             }
             return r;
         }
-#endif // !UNSAFE_BYTEBUFFER
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        protected void WriteLittleEndian(int offset, int count, ulong data)
+        {
+            if (BitConverter.IsLittleEndian)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    _buffer.Span[offset + i] = (byte)(data >> i * 8);
+                }
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    _buffer.Span[offset + count - 1 - i] = (byte)(data >> i * 8);
+                }
+            }
+        }
+
+        protected ulong ReadLittleEndian(int offset, int count)
+        {
+            AssertOffsetAndLength(offset, count);
+            ulong r = 0;
+            if (BitConverter.IsLittleEndian)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    r |= (ulong)_buffer.Span[offset + i] << i * 8;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    r |= (ulong)_buffer.Span[offset + count - 1 - i] << i * 8;
+                }
+            }
+            return r;
+        }
+#endif
 
         private void AssertOffsetAndLength(int offset, int length)
         {
@@ -372,7 +427,7 @@ private void AssertOffsetAndLength(int offset, int length)
 #endif
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
 
         public void PutSbyte(int offset, sbyte value)
         {
@@ -420,7 +475,7 @@ public void Put(int offset, byte value)
             PutByte(offset, value);
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
         public unsafe void PutStringUTF8(int offset, string value)
         {
             AssertOffsetAndLength(offset, value.Length);
@@ -432,6 +487,13 @@ public unsafe void PutStringUTF8(int offset, string value)
                 }
             }
         }
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        public void PutStringUTF8(int offset, string value)
+        {
+            AssertOffsetAndLength(offset, value.Length);
+            Encoding.UTF8.GetBytes(value.AsSpan().Slice(0, value.Length),
+                _buffer.Span.Slice(offset));
+        }
 #else
         public void PutStringUTF8(int offset, string value)
         {
@@ -451,7 +513,7 @@ public void PutShort(int offset, short value)
         public unsafe void PutUshort(int offset, ushort value)
         {
             AssertOffsetAndLength(offset, sizeof(ushort));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt16LittleEndian(span, value);
 #else
@@ -472,7 +534,7 @@ public void PutInt(int offset, int value)
         public unsafe void PutUint(int offset, uint value)
         {
             AssertOffsetAndLength(offset, sizeof(uint));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt32LittleEndian(span, value);
 #else
@@ -493,7 +555,7 @@ public unsafe void PutLong(int offset, long value)
         public unsafe void PutUlong(int offset, ulong value)
         {
             AssertOffsetAndLength(offset, sizeof(ulong));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             Span<byte> span = _buffer.Span.Slice(offset);
             BinaryPrimitives.WriteUInt64LittleEndian(span, value);
 #else
@@ -509,7 +571,7 @@ public unsafe void PutUlong(int offset, ulong value)
         public unsafe void PutFloat(int offset, float value)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.Span))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -529,7 +591,7 @@ public unsafe void PutFloat(int offset, float value)
         public unsafe void PutDouble(int offset, double value)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.Span))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -586,22 +648,23 @@ public void PutUlong(int offset, ulong value)
         public void PutFloat(int offset, float value)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-            floathelper[0] = value;
-            Buffer.BlockCopy(floathelper, 0, inthelper, 0, sizeof(float));
-            WriteLittleEndian(offset, sizeof(float), (ulong)inthelper[0]);
+            // TODO(derekbailey): use BitConvert.SingleToInt32Bits() whenever flatbuffers upgrades to a .NET version
+            // that contains it.
+            ConversionUnion union;
+            union.intValue = 0;
+            union.floatValue = value;    
+            WriteLittleEndian(offset, sizeof(float), (ulong)union.intValue);
         }
 
         public void PutDouble(int offset, double value)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-            doublehelper[0] = value;
-            Buffer.BlockCopy(doublehelper, 0, ulonghelper, 0, sizeof(double));
-            WriteLittleEndian(offset, sizeof(double), ulonghelper[0]);
+            WriteLittleEndian(offset, sizeof(double), (ulong)BitConverter.DoubleToInt64Bits(value));
         }
 
 #endif // UNSAFE_BYTEBUFFER
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public sbyte GetSbyte(int index)
         {
             AssertOffsetAndLength(index, sizeof(sbyte));
@@ -627,7 +690,7 @@ public byte Get(int index)
         }
 #endif
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
         public unsafe string GetStringUTF8(int startPos, int len)
         {
             fixed (byte* buffer = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan.Slice(startPos)))
@@ -635,6 +698,11 @@ public unsafe string GetStringUTF8(int startPos, int len)
                 return Encoding.UTF8.GetString(buffer, len);
             }
         }
+#elif ENABLE_SPAN_T && NETSTANDARD2_1
+        public string GetStringUTF8(int startPos, int len)
+        {
+            return Encoding.UTF8.GetString(_buffer.Span.Slice(startPos, len));
+        }
 #else
         public string GetStringUTF8(int startPos, int len)
         {
@@ -652,7 +720,7 @@ public short GetShort(int offset)
         public unsafe ushort GetUshort(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(ushort));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt16LittleEndian(span);
 #else
@@ -673,7 +741,7 @@ public int GetInt(int offset)
         public unsafe uint GetUint(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(uint));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt32LittleEndian(span);
 #else
@@ -694,7 +762,7 @@ public long GetLong(int offset)
         public unsafe ulong GetUlong(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(ulong));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             ReadOnlySpan<byte> span = _buffer.ReadOnlySpan.Slice(offset);
             return BinaryPrimitives.ReadUInt64LittleEndian(span);
 #else            
@@ -710,7 +778,7 @@ public unsafe ulong GetUlong(int offset)
         public unsafe float GetFloat(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(float));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -731,7 +799,7 @@ public unsafe float GetFloat(int offset)
         public unsafe double GetDouble(int offset)
         {
             AssertOffsetAndLength(offset, sizeof(double));
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T // && UNSAFE_BYTEBUFFER
             fixed (byte* ptr = &MemoryMarshal.GetReference(_buffer.ReadOnlySpan))
 #else
             fixed (byte* ptr = _buffer.Buffer)
@@ -782,19 +850,17 @@ public ulong GetUlong(int index)
 
         public float GetFloat(int index)
         {
-            int i = (int)ReadLittleEndian(index, sizeof(float));
-            inthelper[0] = i;
-            Buffer.BlockCopy(inthelper, 0, floathelper, 0, sizeof(float));
-            return floathelper[0];
+            // TODO(derekbailey): use BitConvert.Int32BitsToSingle() whenever flatbuffers upgrades to a .NET version
+            // that contains it.
+            ConversionUnion union;
+            union.floatValue = 0;
+            union.intValue = (int)ReadLittleEndian(index, sizeof(float));
+            return union.floatValue;
         }
 
         public double GetDouble(int index)
         {
-            ulong i = ReadLittleEndian(index, sizeof(double));
-            // There's Int64BitsToDouble but it uses unsafe code internally.
-            ulonghelper[0] = i;
-            Buffer.BlockCopy(ulonghelper, 0, doublehelper, 0, sizeof(double));
-            return doublehelper[0];
+            return BitConverter.Int64BitsToDouble((long)ReadLittleEndian(index, sizeof(double)));
         }
 #endif // UNSAFE_BYTEBUFFER
 
@@ -815,7 +881,30 @@ public int Put<T>(int offset, T[] x)
                 throw new ArgumentNullException("Cannot put a null array");
             }
 
-            if (x.Length == 0)
+            return Put(offset, new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="x">The array segment to copy data from</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, ArraySegment<T> x)
+            where T : struct
+        {
+            if (x.Equals(default(ArraySegment<T>)))
+            {
+                throw new ArgumentNullException("Cannot put a uninitialized array segment");
+            }
+
+            if (x.Count == 0)
             {
                 throw new ArgumentException("Cannot put an empty array");
             }
@@ -832,10 +921,71 @@ public int Put<T>(int offset, T[] x)
                 offset -= numBytes;
                 AssertOffsetAndLength(offset, numBytes);
                 // if we are LE, just do a block copy
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
                 MemoryMarshal.Cast<T, byte>(x).CopyTo(_buffer.Span.Slice(offset, numBytes));
 #else
-                Buffer.BlockCopy(x, 0, _buffer.Buffer, offset, numBytes);
+                var srcOffset = ByteBuffer.SizeOf<T>() * x.Offset;
+                Buffer.BlockCopy(x.Array, srcOffset, _buffer.Buffer, offset, numBytes);
+#endif
+            }
+            else
+            {
+                throw new NotImplementedException("Big Endian Support not implemented yet " +
+                    "for putting typed arrays");
+                // if we are BE, we have to swap each element by itself
+                //for(int i = x.Length - 1; i >= 0; i--)
+                //{
+                //  todo: low priority, but need to genericize the Put<T>() functions
+                //}
+            }
+            return offset;
+        }
+
+        /// <summary>
+        /// Copies an array segment of type T into this buffer, ending at the 
+        /// given offset into this buffer. The starting offset is calculated 
+        /// based on the count of the array segment and is the value returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the input data (must be a struct)
+        /// </typeparam>
+        /// <param name="offset">The offset into this buffer where the copy 
+        /// will end</param>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The number of bytes to copy</param>
+        /// <returns>The 'start' location of this buffer now, after the copy 
+        /// completed</returns>
+        public int Put<T>(int offset, IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes <= 0)
+            {
+                throw new ArgumentException("Cannot put an empty array");
+            }
+
+            if (!IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot put an array of type "
+                    + typeof(T) + " into this buffer");
+            }
+
+            if (BitConverter.IsLittleEndian)
+            {
+                offset -= sizeInBytes;
+                AssertOffsetAndLength(offset, sizeInBytes);
+                // if we are LE, just do a block copy
+#if ENABLE_SPAN_T && UNSAFE_BYTEBUFFER
+                unsafe
+                { 
+                    var span = new Span<byte>(ptr.ToPointer(), sizeInBytes);
+                    span.CopyTo(_buffer.Span.Slice(offset, sizeInBytes));
+                }
+#else
+                Marshal.Copy(ptr, _buffer.Buffer, offset, sizeInBytes);
 #endif
             }
             else
@@ -851,7 +1001,7 @@ public int Put<T>(int offset, T[] x)
             return offset;
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         public int Put<T>(int offset, Span<T> x)
             where T : struct
         {
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
index cfba4305e17ad..37c13d6986b42 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/ByteBufferUtil.cs
@@ -16,7 +16,7 @@
 
 using System;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
 	/// <summary>
 	/// Class that collects utility functions around `ByteBuffer`.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
index 65873a6345813..aa17d23867f99 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferBuilder.cs
@@ -16,13 +16,14 @@
 
 
 using System;
+using System.Collections.Generic;
 using System.Text;
 
 /// @file
 /// @addtogroup flatbuffers_csharp_api
 /// @{
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// Responsible for building up and accessing a FlatBuffer formatted byte
@@ -47,6 +48,9 @@ internal class FlatBufferBuilder
         // For the current vector being built.
         private int _vectorNumElems = 0;
 
+        // For CreateSharedString
+        private Dictionary<string, StringOffset> _sharedStringMap = null;
+
         /// <summary>
         /// Create a FlatBufferBuilder with a given initial size.
         /// </summary>
@@ -63,7 +67,7 @@ public FlatBufferBuilder(int initialSize)
         }
 
         /// <summary>
-        /// Create a FlatBufferBuilder backed by the passed in ByteBuffer
+        /// Create a FlatBufferBuilder backed by the pased in ByteBuffer
         /// </summary>
         /// <param name="buffer">The ByteBuffer to write to</param>
         public FlatBufferBuilder(ByteBuffer buffer)
@@ -86,6 +90,10 @@ public void Clear()
             _objectStart = 0;
             _numVtables = 0;
             _vectorNumElems = 0;
+            if (_sharedStringMap != null)
+            {
+                _sharedStringMap.Clear();
+            }
         }
 
         /// <summary>
@@ -191,7 +199,7 @@ public void PutFloat(float x)
         }
 
         /// <summary>
-        /// Puts an array of type T into this builder at the 
+        /// Puts an array of type T into this builder at the
         /// current offset
         /// </summary>
         /// <typeparam name="T">The type of the input data </typeparam>
@@ -202,9 +210,34 @@ public void Put<T>(T[] x)
             _space = _bb.Put(_space, x);
         }
 
-#if ENABLE_SPAN_T
         /// <summary>
-        /// Puts a span of type T into this builder at the 
+        /// Puts an array of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Put<T>(ArraySegment<T> x)
+            where T : struct
+        {
+            _space = _bb.Put(_space, x);
+        }
+
+        /// <summary>
+        /// Puts data of type T into this builder at the
+        /// current offset
+        /// </summary>
+        /// <typeparam name="T">The type of the input data </typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The length of the data in bytes</param>
+        public void Put<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            _space = _bb.Put<T>(_space, ptr, sizeInBytes);
+        }
+
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
+        /// <summary>
+        /// Puts a span of type T into this builder at the
         /// current offset
         /// </summary>
         /// <typeparam name="T">The type of the input data </typeparam>
@@ -289,13 +322,24 @@ public void PutDouble(double x)
         /// <param name="x">The array to copy data from</param>
         public void Add<T>(T[] x)
             where T : struct
+        {
+            Add(new ArraySegment<T>(x));
+        }
+
+        /// <summary>
+        /// Add an array of type T to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="x">The array segment to copy data from</param>
+        public void Add<T>(ArraySegment<T> x)
+            where T : struct
         {
             if (x == null)
             {
                 throw new ArgumentNullException("Cannot add a null array");
             }
 
-            if( x.Length == 0)
+            if( x.Count == 0)
             {
                 // don't do anything if the array is empty
                 return;
@@ -309,11 +353,53 @@ public void Add<T>(T[] x)
             int size = ByteBuffer.SizeOf<T>();
             // Need to prep on size (for data alignment) and then we pass the
             // rest of the length (minus 1) as additional bytes
-            Prep(size, size * (x.Length - 1));
+            Prep(size, size * (x.Count - 1));
             Put(x);
         }
 
-#if ENABLE_SPAN_T
+        /// <summary>
+        /// Adds the data of type T pointed to by the given pointer to the buffer (aligns the data and grows if necessary).
+        /// </summary>
+        /// <typeparam name="T">The type of the input data</typeparam>
+        /// <param name="ptr">The pointer to copy data from</param>
+        /// <param name="sizeInBytes">The data size in bytes</param>
+        public void Add<T>(IntPtr ptr, int sizeInBytes)
+            where T : struct
+        {
+            if(sizeInBytes == 0)
+            {
+                // don't do anything if the array is empty
+                return;
+            }
+
+            if (ptr == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("Cannot add a null pointer");
+            }
+
+            if(sizeInBytes < 0)
+            {
+                throw new ArgumentOutOfRangeException("sizeInBytes", "sizeInBytes cannot be negative");
+            }
+
+            if(!ByteBuffer.IsSupportedType<T>())
+            {
+                throw new ArgumentException("Cannot add this Type array to the builder");
+            }
+
+            int size = ByteBuffer.SizeOf<T>();
+            if((sizeInBytes % size) != 0)
+            {
+                throw new ArgumentException("The given size in bytes " + sizeInBytes + " doesn't match the element size of T ( " + size + ")", "sizeInBytes");
+            }
+
+            // Need to prep on size (for data alignment) and then we pass the
+            // rest of the length (minus 1) as additional bytes
+            Prep(size, sizeInBytes - size);
+            Put<T>(ptr, sizeInBytes);
+        }
+
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Add a span of type T to the buffer (aligns the data and grows if necessary).
         /// </summary>
@@ -352,7 +438,8 @@ public void AddOffset(int off)
             if (off > Offset)
                 throw new ArgumentException();
 
-            off = Offset - off + sizeof(int);
+            if (off != 0)
+                off = Offset - off + sizeof(int);
             PutInt(off);
         }
 
@@ -387,7 +474,7 @@ public VectorOffset CreateVectorOfTables<T>(Offset<T>[] offsets) where T : struc
             return EndVector();
         }
 
-        /// @cond FLATBUFFERS_INTERNAL
+        /// @cond FLATBUFFERS_INTENRAL
         public void Nested(int obj)
         {
             // Structs are always stored inline, so need to be created right
@@ -407,7 +494,7 @@ public void NotNested()
                     "FlatBuffers: object serialization must not be nested.");
         }
 
-        public void StartObject(int numfields)
+        public void StartTable(int numfields)
         {
             if (numfields < 0)
                 throw new ArgumentOutOfRangeException("Flatbuffers: invalid numfields");
@@ -441,6 +528,15 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddBool(int o, bool x, bool d) { if (ForceDefaults || x != d) { AddBool(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Boolean to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable boolean value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>       
+        public void AddBool(int o, bool? x) { if (x.HasValue) { AddBool(x.Value); Slot(o); } }
+
+        
         /// <summary>
         /// Adds a SByte to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -450,6 +546,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddSbyte(int o, sbyte x, sbyte d) { if (ForceDefaults || x != d) { AddSbyte(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a SByte to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable sbyte value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddSbyte(int o, sbyte? x) { if (x.HasValue) { AddSbyte(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a Byte to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -459,6 +563,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddByte(int o, byte x, byte d) { if (ForceDefaults || x != d) { AddByte(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Byte to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable byte value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddByte(int o, byte? x) { if (x.HasValue) { AddByte(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a Int16 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -468,6 +580,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddShort(int o, short x, int d) { if (ForceDefaults || x != d) { AddShort(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Int16 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int16 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddShort(int o, short? x) { if (x.HasValue) { AddShort(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a UInt16 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -477,6 +597,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddUshort(int o, ushort x, ushort d) { if (ForceDefaults || x != d) { AddUshort(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Uint16 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable uint16 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUshort(int o, ushort? x) { if (x.HasValue) { AddUshort(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds an Int32 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -486,6 +614,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddInt(int o, int x, int d) { if (ForceDefaults || x != d) { AddInt(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Int32 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int32 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddInt(int o, int? x) { if (x.HasValue) { AddInt(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a UInt32 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -495,6 +631,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddUint(int o, uint x, uint d) { if (ForceDefaults || x != d) { AddUint(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a UInt32 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable uint32 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUint(int o, uint? x) { if (x.HasValue) { AddUint(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds an Int64 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -504,6 +648,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddLong(int o, long x, long d) { if (ForceDefaults || x != d) { AddLong(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Int64 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddLong(int o, long? x) { if (x.HasValue) { AddLong(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a UInt64 to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -513,6 +665,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddUlong(int o, ulong x, ulong d) { if (ForceDefaults || x != d) { AddUlong(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a UInt64 to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable int64 value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddUlong(int o, ulong? x) { if (x.HasValue) { AddUlong(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a Single to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -522,6 +682,14 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddFloat(int o, float x, double d) { if (ForceDefaults || x != d) { AddFloat(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Single to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable single value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddFloat(int o, float? x) { if (x.HasValue) { AddFloat(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a Double to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
@@ -531,14 +699,22 @@ public void Slot(int voffset)
         /// <param name="d">The default value to compare the value against</param>
         public void AddDouble(int o, double x, double d) { if (ForceDefaults || x != d) { AddDouble(x); Slot(o); } }
 
+        /// <summary>
+        /// Adds a Double to the Table at index `o` in its vtable using the nullable value `x`
+        /// </summary>
+        /// <param name="o">The index into the vtable</param>
+        /// <param name="x">The nullable double value to put into the buffer. If it doesn't have a value
+        /// it will skip writing to the buffer.</param>  
+        public void AddDouble(int o, double? x) { if (x.HasValue) { AddDouble(x.Value); Slot(o); } }
+
         /// <summary>
         /// Adds a buffer offset to the Table at index `o` in its vtable using the value `x` and default `d`
         /// </summary>
         /// <param name="o">The index into the vtable</param>
         /// <param name="x">The value to put into the buffer. If the value is equal to the default
-        /// and <see cref="ForceDefaults"/> is false, the value will be skipped.</param>
+        /// the value will be skipped.</param>
         /// <param name="d">The default value to compare the value against</param>
-        public void AddOffset(int o, int x, int d) { if (ForceDefaults || x != d) { AddOffset(x); Slot(o); } }
+        public void AddOffset(int o, int x, int d) { if (x != d) { AddOffset(x); Slot(o); } }
         /// @endcond
 
         /// <summary>
@@ -550,6 +726,10 @@ public void Slot(int voffset)
         /// </returns>
         public StringOffset CreateString(string s)
         {
+            if (s == null)
+            {
+                return new StringOffset(0);
+            }
             NotNested();
             AddByte(0);
             var utf8StringLen = Encoding.UTF8.GetByteCount(s);
@@ -559,7 +739,7 @@ public StringOffset CreateString(string s)
         }
 
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         /// <summary>
         /// Creates a string in the buffer from a Span containing
         /// a UTF8 string.
@@ -579,6 +759,37 @@ public StringOffset CreateUTF8String(Span<byte> chars)
         }
 #endif
 
+        /// <summary>
+        /// Store a string in the buffer, which can contain any binary data.
+        /// If a string with this exact contents has already been serialized before,
+        /// instead simply returns the offset of the existing string.
+        /// </summary>
+        /// <param name="s">The string to encode.</param>
+        /// <returns>
+        /// The offset in the buffer where the encoded string starts.
+        /// </returns>
+        public StringOffset CreateSharedString(string s)
+        {
+            if (s == null)
+            {
+              return new StringOffset(0);
+            }
+
+            if (_sharedStringMap == null)
+            {
+                _sharedStringMap = new Dictionary<string, StringOffset>();
+            }
+
+            if (_sharedStringMap.ContainsKey(s))
+            {
+                return _sharedStringMap[s];
+            }
+
+            var stringOffset = CreateString(s);
+            _sharedStringMap.Add(s, stringOffset);
+            return stringOffset;
+        }
+
         /// @cond FLATBUFFERS_INTERNAL
         // Structs are stored inline, so nothing additional is being added.
         // `d` is always 0.
@@ -591,11 +802,11 @@ public void AddStruct(int voffset, int x, int d)
             }
         }
 
-        public int EndObject()
+        public int EndTable()
         {
             if (_vtableSize < 0)
                 throw new InvalidOperationException(
-                  "Flatbuffers: calling endObject without a startObject");
+                  "Flatbuffers: calling EndTable without a StartTable");
 
             AddInt((int)0);
             var vtableloc = Offset;
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
index 68a4e9cad0950..c26f1b66d1023 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferConstants.cs
@@ -19,11 +19,19 @@
 using System.Linq;
 using System.Text;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     internal static class FlatBufferConstants
     {
         public const int FileIdentifierLength = 4;
         public const int SizePrefixLength = 4;
+        /** A version identifier to force a compile error if someone
+        accidentally tries to build generated code with a runtime of
+        two mismatched version. Versions need to always match, as
+        the runtime and generated code are modified in sync.
+        Changes to the C# implementation need to be sure to change
+        the version here and in the code generator on every possible
+        incompatible change */
+        public static void FLATBUFFERS_23_5_9() {}
     }
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
new file mode 100644
index 0000000000000..b108aa3e28ec3
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/FlatBufferVerify.cs
@@ -0,0 +1,822 @@
+/*
+ * Copyright 2014 Google Inc. 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.
+ */
+using System;
+using System.Reflection;using System.Collections.Generic;
+using System.IO;
+
+namespace Google.FlatBuffers
+{
+
+  /// <summary>
+  /// The Class of the Verifier Options
+  /// </summary>
+  internal class Options
+  {
+    public const int DEFAULT_MAX_DEPTH = 64;
+    public const int DEFAULT_MAX_TABLES = 1000000;
+
+    private int max_depth = 0;
+    private int max_tables = 0;
+    private bool string_end_check = false;
+    private bool alignment_check = false;
+
+    public Options()
+    {
+      max_depth = DEFAULT_MAX_DEPTH;
+      max_tables = DEFAULT_MAX_TABLES;
+      string_end_check = true;
+      alignment_check = true;
+    }
+
+    public Options(int maxDepth, int maxTables, bool stringEndCheck, bool alignmentCheck)
+    {
+      max_depth = maxDepth;
+      max_tables = maxTables;
+      string_end_check = stringEndCheck;
+      alignment_check = alignmentCheck;
+    }
+    /// <summary> Maximum depth of nested tables allowed in a valid flatbuffer. </summary>
+    public int maxDepth
+    {
+      get { return max_depth; }
+      set { max_depth = value; }
+    }
+    /// <summary> Maximum number of tables allowed in a valid flatbuffer. </summary>
+    public int maxTables
+    {
+      get { return max_tables; }
+      set { max_tables = value; }
+    }
+    /// <summary> Check that string contains its null terminator </summary>
+    public bool stringEndCheck
+    {
+      get { return string_end_check; }
+      set { string_end_check = value; }
+    }
+    /// <summary> Check alignment of elements </summary>
+    public bool alignmentCheck
+    {
+      get { return alignment_check; }
+      set { alignment_check = value; }
+    }
+  }
+
+  internal struct checkElementStruct
+  {
+    public bool elementValid;
+    public uint elementOffset;
+  }
+
+  internal delegate bool VerifyTableAction(Verifier verifier, uint tablePos);
+  internal delegate bool VerifyUnionAction(Verifier verifier, byte typeId, uint tablePos);
+
+  /// <summary>
+  /// The Main Class of the FlatBuffer Verifier
+  /// </summary>
+  internal class Verifier
+  {
+    private ByteBuffer verifier_buffer = null;
+    private Options verifier_options = null;
+    private int depth_cnt = 0;
+    private int num_tables_cnt = 0;
+
+    public const int SIZE_BYTE = 1;
+    public const int SIZE_INT = 4;
+    public const int SIZE_U_OFFSET = 4;
+    public const int SIZE_S_OFFSET = 4;
+    public const int SIZE_V_OFFSET = 2;
+    public const int SIZE_PREFIX_LENGTH = FlatBufferConstants.SizePrefixLength;         // default size = 4
+    public const int FLATBUFFERS_MAX_BUFFER_SIZE = System.Int32.MaxValue;               // default size = 2147483647
+    public const int FILE_IDENTIFIER_LENGTH = FlatBufferConstants.FileIdentifierLength; // default size = 4
+
+    /// <summary> The Base Constructor of the Verifier object </summary>
+    public Verifier()
+    {
+      // Verifier buffer
+      verifier_buffer = null;
+      // Verifier settings 
+      verifier_options = null;
+      // Depth counter
+      depth_cnt = 0;
+      // Tables counter
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> The Constructor of the Verifier object with input parameters: ByteBuffer and/or Options </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type</param>
+    /// <param name="options"> Options object with settings for the coniguration the Verifier </param>
+    public Verifier(ByteBuffer buf, Options options = null)
+    {
+      verifier_buffer = buf;
+      verifier_options = options ?? new Options();
+      depth_cnt = 0;
+      num_tables_cnt = 0;
+    }
+
+    /// <summary> Bytes Buffer for Verify</summary>
+    public ByteBuffer Buf
+    {
+      get { return verifier_buffer; }
+      set { verifier_buffer = value; }
+    }
+    /// <summary> Options of the Verifier </summary>
+    public Options options
+    {
+      get { return verifier_options; }
+      set { verifier_options = value; }
+    }
+    /// <summary> Counter of tables depth in a tested flatbuffer  </summary>
+    public int depth
+    {
+      get { return depth_cnt; }
+      set { depth_cnt = value; }
+    }
+    /// <summary> Counter of tables in a tested flatbuffer </summary>
+    public int numTables
+    {
+      get { return num_tables_cnt; }
+      set { num_tables_cnt = value; }
+    }
+
+
+    /// <summary> Method set maximum tables depth of valid structure</summary>
+    /// <param name="value"> Specify Value of the maximum depth of the structure</param>
+    public Verifier SetMaxDepth(int value)
+    {
+      verifier_options.maxDepth = value;
+      return this;
+    }
+    /// <summary> Specify maximum number of tables in structure </summary>
+    /// <param name="value"> Specify Value of the maximum number of the tables in the structure</param>
+    public Verifier SetMaxTables(int value)
+    {
+      verifier_options.maxTables = value;
+      return this;
+    }
+    /// <summary> Enable/disable buffer content alignment check </summary>
+    /// <param name="value"> Value of the State for buffer content alignment check (Enable = true) </param>
+    public Verifier SetAlignmentCheck(bool value)
+    {
+      verifier_options.alignmentCheck = value;
+      return this;
+    }
+    /// <summary> Enable/disable checking of string termination '0' character </summary>
+    /// <param name="value"> Value of the option for string termination '0' character check (Enable = true)</param>
+    public Verifier SetStringCheck(bool value)
+    {
+      verifier_options.stringEndCheck = value;
+      return this;
+    }
+
+    /// <summary> Check if there is identifier in buffer </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="startPos">Start position of data in the Byte Buffer</param>
+    /// <param name="identifier"> Identifier for the Byte Buffer</param>
+    /// <returns> Return True when the Byte Buffer Identifier is present</returns>
+    private bool BufferHasIdentifier(ByteBuffer buf, uint startPos, string identifier)
+    {
+      if (identifier.Length != FILE_IDENTIFIER_LENGTH)
+      {
+        throw new ArgumentException("FlatBuffers: file identifier must be length" + Convert.ToString(FILE_IDENTIFIER_LENGTH));
+      }
+      for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++)
+      {
+        if ((sbyte)identifier[i] != verifier_buffer.GetSbyte(Convert.ToInt32(SIZE_S_OFFSET + i + startPos)))
+        {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    /// <summary> Get UOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the UOffset Value (Unsigned Integer type - 4 bytes) in pos </returns>
+    private uint ReadUOffsetT(ByteBuffer buf, uint pos)
+    {
+      return buf.GetUint(Convert.ToInt32(pos));
+    }
+    /// <summary> Get SOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the SOffset Value (Signed Integer type - 4 bytes) in pos </returns>
+    private int ReadSOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetInt(pos);
+    }
+    /// <summary> Get VOffsetT from buffer at given position - it must be verified before read </summary>
+    /// <param name="buf"> Input flat byte buffer defined as ByteBuffer type </param>
+    /// <param name="pos"> Position of data in the Byte Buffer</param>
+    /// <returns> Return the VOffset Value (Short type - 2 bytes) in pos </returns>
+    private short ReadVOffsetT(ByteBuffer buf, int pos)
+    {
+      return buf.GetShort(pos);
+    }
+
+    /// <summary> Get table data area relative offset from vtable. Result is relative to table start
+    ///           Fields which are deprecated are ignored by checking against the vtable's length. </summary>
+    /// <param name="pos"> Position of data in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset of value in the Table</param>
+    /// <returns> Return the relative VOffset Value (Short type - 2 bytes) in calculated offset </returns>
+    private short GetVRelOffset(int pos, short vtableOffset)
+    {
+      short VOffset = 0;
+      // Used try/catch because pos typa as int 32bit
+      try
+      {
+        // First, get vtable offset
+        short vtable = Convert.ToInt16(pos - ReadSOffsetT(verifier_buffer, pos));
+        // Check that offset points to vtable area (is smaller than vtable size)
+        if (vtableOffset < ReadVOffsetT(verifier_buffer, vtable))
+        {
+          // Now, we can read offset value - TODO check this value against size of table data
+          VOffset = ReadVOffsetT(verifier_buffer, vtable + vtableOffset);
+        }
+        else
+        {
+          VOffset = 0;
+        }
+      }
+      catch (Exception e)
+      {
+        Console.WriteLine("Exception: {0}", e);
+        return VOffset;
+      }
+      return VOffset;
+
+    }
+    /// <summary> Get table data area absolute offset from vtable. Result is the absolute buffer offset.
+    /// The result value offset cannot be '0' (pointing to itself) so after validation this method returnes '0'
+    /// value as a marker for missing optional entry </summary>
+    /// <param name="tablePos"> Table Position value in the Byte Buffer </param>
+    /// <param name="vtableOffset"> offset value in the Table</param>
+    /// <returns> Return the absolute UOffset Value </returns>
+    private uint GetVOffset(uint tablePos, short vtableOffset)
+    {
+      uint UOffset = 0;
+      // First, get vtable relative offset
+      short relPos = GetVRelOffset(Convert.ToInt32(tablePos), vtableOffset);
+      if (relPos != 0)
+      {
+        // Calculate offset based on table postion
+        UOffset = Convert.ToUInt32(tablePos + relPos);
+      }
+      else
+      {
+        UOffset = 0;
+      }
+      return UOffset;
+    }
+
+    /// <summary> Check flatbuffer complexity (tables depth, elements counter and so on) </summary>
+    /// <returns> If complexity is too high function returns false as verification error </returns>
+    private bool CheckComplexity()
+    {
+      return ((depth <= options.maxDepth) && (numTables <= options.maxTables));
+    }
+
+    /// <summary> Check alignment of element. </summary>
+    /// <returns> Return True when alignment of the element is correct</returns>
+    private bool CheckAlignment(uint element, ulong align)
+    {
+      return (((element & (align - 1)) == 0) || (!options.alignmentCheck));
+    }
+
+    /// <summary> Check if element is valid in buffer area. </summary> 
+    /// <param name="pos"> Value defines the offset/position to element</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Element is correct </returns>
+    private bool CheckElement(uint pos, ulong elementSize)
+    {
+      return ((elementSize < Convert.ToUInt64(verifier_buffer.Length)) && (pos <= (Convert.ToUInt32(verifier_buffer.Length) - elementSize)));
+    }
+    /// <summary> Check if element is a valid scalar. </summary>
+    /// <param name="pos"> Value defines the offset to scalar</param>
+    /// <param name="elementSize"> Size of element</param>
+    /// <returns> Return True when Scalar Element is correct </returns>
+    private bool CheckScalar(uint pos, ulong elementSize)
+    {
+      return ((CheckAlignment(pos, elementSize)) && (CheckElement(pos, elementSize)));
+    }
+    /// <summary> Check offset. It is a scalar with size of UOffsetT. </summary>
+    private bool CheckOffset(uint offset)
+    {
+      return (CheckScalar(offset, SIZE_U_OFFSET));
+    }
+
+    private checkElementStruct CheckVectorOrString(uint pos, ulong elementSize)
+    {
+      var result = new checkElementStruct
+      {
+        elementValid = false,
+        elementOffset = 0
+      };
+
+      uint vectorPos = pos;
+      // Check we can read the vector/string size field (it is of uoffset size)
+      if (!CheckScalar(vectorPos, SIZE_U_OFFSET))
+      {
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+      // Check the whole array. If this is a string, the byte past the array
+      // must be 0.
+      uint size = ReadUOffsetT(verifier_buffer, vectorPos);
+      ulong max_elements = (FLATBUFFERS_MAX_BUFFER_SIZE / elementSize);
+      if (size >= max_elements)
+      {
+        // Protect against byte_size overflowing. 
+        // result.elementValid = false; result.elementOffset = 0;
+        return result;
+      }
+
+      uint bytes_size = SIZE_U_OFFSET + (Convert.ToUInt32(elementSize) * size);
+      uint buffer_end_pos = vectorPos + bytes_size;
+      result.elementValid = CheckElement(vectorPos, bytes_size);
+      result.elementOffset = buffer_end_pos;
+      return (result);
+    }
+
+    /// <summary>Verify a string at given position.</summary>
+    private bool CheckString(uint pos)
+    {
+      var result = CheckVectorOrString(pos, SIZE_BYTE);
+      if (options.stringEndCheck)
+      {
+        result.elementValid = result.elementValid && CheckScalar(result.elementOffset, 1); // Must have terminator
+        result.elementValid = result.elementValid && (verifier_buffer.GetSbyte(Convert.ToInt32(result.elementOffset)) == 0); // Terminating byte must be 0.
+      }
+      return result.elementValid;
+    }
+
+    /// <summary> Verify the vector of elements of given size </summary>
+    private bool CheckVector(uint pos, ulong elementSize)
+    {
+      var result = CheckVectorOrString(pos, elementSize);
+      return result.elementValid;
+    }
+    /// <summary> Verify table content using structure dependent generated function </summary>
+    private bool CheckTable(uint tablePos, VerifyTableAction verifyAction)
+    {
+      return verifyAction(this, tablePos);
+    }
+
+    /// <summary> String check wrapper function to be used in vector of strings check </summary>
+    private bool CheckStringFunc(Verifier verifier, uint pos)
+    {
+      return verifier.CheckString(pos);
+    }
+
+    /// <summary> Check vector of objects. Use generated object verification function </summary>
+    private bool CheckVectorOfObjects(uint pos, VerifyTableAction verifyAction)
+    {
+      if (!CheckVector(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      uint size = ReadUOffsetT(verifier_buffer, pos);
+      // Vector data starts just after vector size/length
+      uint vecStart = pos + SIZE_U_OFFSET;
+      uint vecOff = 0;
+      // Iterate offsets and verify referenced objects
+      for (uint i = 0; i < size; i++)
+      {
+        vecOff = vecStart + (i * SIZE_U_OFFSET);
+        if (!CheckIndirectOffset(vecOff))
+        {
+          return false;
+        }
+        uint objOffset = GetIndirectOffset(vecOff);
+        if (!verifyAction(this, objOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Check if the offset referenced by offsetPos is the valid offset pointing to buffer</summary>
+    //  offsetPos - offset to offset data
+    private bool CheckIndirectOffset(uint pos)
+    {
+      // Check the input offset is valid
+      if(!CheckScalar(pos, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Get indirect offset
+      uint offset = ReadUOffsetT(verifier_buffer, pos);
+      // May not point to itself neither wrap around  (buffers are max 2GB)
+      if ((offset == 0) || (offset >= FLATBUFFERS_MAX_BUFFER_SIZE))
+      {
+        return false;
+      }
+      // Must be inside the buffer
+      return CheckElement(pos + offset, 1);
+    }
+
+    /// <summary> Check flatbuffer content using generated object verification function </summary>
+    private bool CheckBufferFromStart(string identifier, uint startPos, VerifyTableAction verifyAction)
+    {
+      if ((identifier != null) &&
+          (identifier.Length == 0) &&
+          ((verifier_buffer.Length < (SIZE_U_OFFSET + FILE_IDENTIFIER_LENGTH)) || (!BufferHasIdentifier(verifier_buffer, startPos, identifier))))
+      {
+        return false;
+      }
+      if(!CheckIndirectOffset(startPos))
+      {
+        return false;
+      }
+      uint offset = GetIndirectOffset(startPos);
+      return CheckTable(offset, verifyAction); //  && GetComputedSize()
+    }
+
+    /// <summary> Get indirect offset. It is an offset referenced by offset Pos </summary>
+    private uint GetIndirectOffset(uint pos)
+    {
+      // Get indirect offset referenced by offsetPos
+      uint offset = pos + ReadUOffsetT(verifier_buffer, pos);
+      return offset;
+    }
+
+    /// <summary> Verify beginning of table </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <returns> Return True when the verification of the beginning of the table is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableStart(uint tablePos)
+    {
+      // Starting new table verification increases complexity of structure
+      depth_cnt++;
+      num_tables_cnt++;
+
+      if (!CheckScalar(tablePos, SIZE_S_OFFSET))
+      {
+        return false;
+      }
+      uint vtable = (uint)(tablePos - ReadSOffsetT(verifier_buffer, Convert.ToInt32(tablePos)));
+      return ((CheckComplexity()) && (CheckScalar(vtable, SIZE_V_OFFSET)) && (CheckAlignment(Convert.ToUInt32(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))), SIZE_V_OFFSET)) && (CheckElement(vtable, Convert.ToUInt64(ReadVOffsetT(verifier_buffer, Convert.ToInt32(vtable))))));
+    }
+
+    /// <summary> Verify end of table. In practice, this function does not check buffer but handles
+    /// verification statistics update </summary>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTableEnd(uint tablePos)
+    {
+      depth--;
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area field </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the static/inlined data element </param>
+    /// <param name="elementSize"> Size of the element </param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the static/inlined data element is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyField(uint tablePos, short offsetId, ulong elementSize, ulong align, bool required)
+    {
+      uint offset = GetVOffset(tablePos, offsetId);
+      if (offset != 0)
+      {
+        return ((CheckAlignment(offset, align)) && (CheckElement(offset, elementSize)));
+      }
+      return !required; // it is OK if field is not required
+    }
+
+    /// <summary> Verify string </summary> 
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the String element </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the String is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyString(uint tablePos, short vOffset, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var strOffset = GetIndirectOffset(offset);
+      return CheckString(strOffset);
+    }
+
+    /// <summary> Verify vector of fixed size structures and scalars </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="vOffset"> Offset to the Vector of Data </param>
+    /// <param name="elementSize"> Size of the element</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Data passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfData(uint tablePos, short vOffset, ulong elementSize, bool required)
+    {
+      var offset = GetVOffset(tablePos, vOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return  CheckVector(vecOffset, elementSize);
+    }
+
+    /// <summary> Verify array of strings </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of String </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of String passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfStrings(uint tablePos, short offsetId, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, CheckStringFunc); 
+    }
+
+    /// <summary> Verify vector of tables (objects). Tables are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Vector of Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfTables(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var vecOffset = GetIndirectOffset(offset);
+      return CheckVectorOfObjects(vecOffset, verifyAction);
+    }
+
+    /// <summary> Verify table object using generated verification function. </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction"> Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Table passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyTable(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var tabOffset = GetIndirectOffset(offset);
+      return CheckTable(tabOffset, verifyAction);
+    }
+
+    /// <summary> Verify nested buffer object. When verifyObjFunc is provided, it is used to verify object structure. </summary>
+    /// <param name="tablePos"> Position in the Table </param>
+    /// <param name="offsetId"> Offset to the Table </param>
+    /// <param name="verifyAction">  Method used to the verification Table </param>
+    /// <param name="required"> Required Value when the offset == 0  </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyNestedBuffer(uint tablePos, short offsetId, VerifyTableAction verifyAction, bool required)
+    {
+      var offset = GetVOffset(tablePos, offsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      uint vecOffset = GetIndirectOffset(offset);
+      if (!CheckVector(vecOffset, SIZE_BYTE))
+      {
+        return false;
+      }
+      if (verifyAction != null)
+      {
+        var vecLength = ReadUOffsetT(verifier_buffer, vecOffset);
+        // Buffer begins after vector length
+        var vecStart = vecOffset + SIZE_U_OFFSET;
+        // Create and Copy nested buffer bytes from part of Verify Buffer
+        var nestedByteBuffer = new ByteBuffer(verifier_buffer.ToArray(Convert.ToInt32(vecStart), Convert.ToInt32(vecLength)));
+        var nestedVerifyier = new Verifier(nestedByteBuffer, options);
+        // There is no internal identifier - use empty one
+        if (!nestedVerifyier.CheckBufferFromStart("", 0, verifyAction))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    /// <summary> Verifiy static/inlined data area at absolute offset </summary>
+    /// <param name="pos"> Position of static/inlined data area in the Byte Buffer</param>
+    /// <param name="elementSize"> Size of the union data</param>
+    /// <param name="align"> Alignment bool value </param>
+    /// <returns>Return True when the verification of the Union Data is passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionData(uint pos, ulong elementSize, ulong align)
+    {
+      bool result = ((CheckAlignment(pos, align)) && (CheckElement(pos, elementSize)));
+      return result;
+    }
+
+    /// <summary> Verify string referenced by absolute offset value </summary>
+    /// <param name="pos"> Position of Union String in the Byte Buffer</param>
+    /// <returns>Return True when the verification of the Union String is passed</returns> 
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnionString(uint pos)
+    {
+      bool result = CheckString(pos);
+      return result;
+    }
+
+    /// <summary> Method verifies union object using generated verification function </summary>
+    /// <param name="tablePos"> Position in the Table</param>
+    /// <param name="typeIdVOffset"> Offset in the Table</param>
+    /// <param name="valueVOffset"> Offset to Element</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyUnion(uint tablePos, short typeIdVOffset, short valueVOffset, VerifyUnionAction verifyAction, bool required)
+    {
+      // Check the union type index
+      var offset = GetVOffset(tablePos, typeIdVOffset);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!((CheckAlignment(offset, SIZE_BYTE)) && (CheckElement(offset, SIZE_BYTE))))
+      {
+        return false;
+      }
+      // Check union data
+      offset = GetVOffset(tablePos, valueVOffset);
+      // Take type id
+      var typeId = verifier_buffer.Get(Convert.ToInt32(offset));
+      if (offset == 0)
+      {
+        // When value data is not present, allow union verification function to deal with illegal offset
+        return verifyAction(this, typeId, Convert.ToUInt32(verifier_buffer.Length));
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Take value offset and validate union structure
+      uint unionOffset = GetIndirectOffset(offset);
+      return verifyAction(this, typeId, unionOffset);
+    }
+
+    /// <summary> Verify vector of unions (objects). Unions are verified using generated verifyObjFunc </summary>
+    /// <param name="tablePos"> Position of the Table</param>
+    /// <param name="typeOffsetId"> Offset in the Table (Union type id)</param>
+    /// <param name="offsetId"> Offset to vector of Data Stucture offset</param>
+    /// <param name="verifyAction"> Verification Method used for Union</param>
+    /// <param name="required"> Required Value when the offset == 0 </param>
+    /// <returns>Return True when the verification of the Vector of Unions passed</returns>
+    // (this method is used internally by generated verification functions)
+    public bool VerifyVectorOfUnion(uint tablePos, short typeOffsetId, short offsetId, VerifyUnionAction verifyAction, bool required)
+    {
+      // type id offset must be valid
+      var offset = GetVOffset(tablePos, typeOffsetId);
+      if (offset == 0)
+      {
+        return !required;
+      }
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      // Get type id table absolute offset
+      var typeIdVectorOffset = GetIndirectOffset(offset);
+      // values offset must be valid
+      offset = GetVOffset(tablePos, offsetId);
+      if (!CheckIndirectOffset(offset))
+      {
+        return false;
+      }
+      var valueVectorOffset = GetIndirectOffset(offset);
+      // validate referenced vectors
+      if(!CheckVector(typeIdVectorOffset, SIZE_BYTE) ||
+         !CheckVector(valueVectorOffset, SIZE_U_OFFSET))
+      {
+        return false;
+      }
+      // Both vectors should have the same length
+      var typeIdVectorLength = ReadUOffsetT(verifier_buffer, typeIdVectorOffset);
+      var valueVectorLength = ReadUOffsetT(verifier_buffer, valueVectorOffset);
+      if (typeIdVectorLength != valueVectorLength)
+      {
+        return false;
+      }
+      // Verify each union from vectors
+      var typeIdStart = typeIdVectorOffset + SIZE_U_OFFSET;
+      var valueStart = valueVectorOffset + SIZE_U_OFFSET;
+      for (uint i = 0; i < typeIdVectorLength; i++)
+      {
+        // Get type id
+        byte typeId = verifier_buffer.Get(Convert.ToInt32(typeIdStart + i * SIZE_U_OFFSET));
+        // get offset to vector item
+        uint off = valueStart + i * SIZE_U_OFFSET;
+        // Check the vector item has a proper offset
+        if (!CheckIndirectOffset(off))
+        {
+          return false;
+        }
+        uint valueOffset = GetIndirectOffset(off);
+        // Verify object
+        if (!verifyAction(this, typeId, valueOffset))
+        {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    // Method verifies flatbuffer data using generated Table verification function.
+    // The data buffer is already provided when creating [Verifier] object (see [NewVerifier])
+    //
+    //   - identifier - the expected identifier of buffer data.
+    //     When empty identifier is provided the identifier validation is skipped.
+    //   - sizePrefixed - this flag should be true when buffer is prefixed with content size
+    //   - verifyObjFunc - function to be used for verification. This function is generated by compiler and included in each table definition file with name "<Tablename>Verify"
+    //
+    // Example:
+    //
+    //  /* Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix */
+    //  isValid = verifier.verifyBuffer(bb, false, MonsterVerify)
+    //
+    //  /* Verify Monster table. Buffer name is 'MONS' and contains data length prefix */
+    //  isValid = verifier.verifyBuffer("MONS", true, MonsterVerify)
+    /// <summary> Method verifies flatbuffer data using generated Table verification function </summary>
+    /// 
+    /// <param name="identifier"> The expected identifier of buffer data</param>
+    /// <param name="sizePrefixed"> Flag should be true when buffer is prefixed with content size</param>
+    /// <param name="verifyAction"> Function to be used for verification. This function is generated by compiler and included in each table definition file</param>
+    /// <returns> Return True when verification of FlatBuffer passed</returns>
+    /// <example>
+    /// Example 1. Verify Monster table. Ignore buffer name and assume buffer does not contain data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer(bb, false, MonsterVerify)</code>
+    /// Example 2. Verify Monster table. Buffer name is 'MONS' and contains data length prefix 
+    /// <code>  isValid = verifier.VerifyBuffer("MONS", true, MonsterVerify)</code>
+    /// </example>
+    public bool VerifyBuffer(string identifier, bool sizePrefixed, VerifyTableAction verifyAction)
+    {
+      // Reset counters - starting verification from beginning
+      depth = 0;
+      numTables = 0;
+
+      var start = (uint)(verifier_buffer.Position);
+      if (sizePrefixed) 
+      {
+        start = (uint)(verifier_buffer.Position) + SIZE_PREFIX_LENGTH;
+        if(!CheckScalar((uint)(verifier_buffer.Position), SIZE_PREFIX_LENGTH))
+        {
+          return false;
+        }
+        uint size = ReadUOffsetT(verifier_buffer, (uint)(verifier_buffer.Position));
+        if (size != ((uint)(verifier_buffer.Length) - start))
+        {
+          return false;
+        }
+      } 
+      return CheckBufferFromStart(identifier, start, verifyAction);
+    }
+  }
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
index 1be932c9867e9..72073b0e17218 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/IFlatbufferObject.cs
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// This is the base for both structs and tables.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
index 70b75b6de7e51..582bb3b9d5f5f 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Offset.cs
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// Offset class for typesafe assignments.
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
index ca44ff920447a..313aadec5d21d 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Struct.cs
@@ -14,14 +14,21 @@
  * limitations under the License.
  */
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// All structs in the generated code derive from this class, and add their own accessors.
     /// </summary>
     internal struct Struct
     {
-        public int bb_pos;
-        public ByteBuffer bb;
+        public int bb_pos { get; private set; }
+        public ByteBuffer bb { get; private set; }
+
+        // Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
+        public Struct(int _i, ByteBuffer _bb) : this()
+        {
+            bb = _bb;
+            bb_pos = _i;
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
index f809072ba83a0..e2452e40eb8e9 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/FlatBuffers/Table.cs
@@ -16,19 +16,27 @@
 
 using System;
 using System.Text;
+using System.Runtime.InteropServices;
 
-namespace FlatBuffers
+namespace Google.FlatBuffers
 {
     /// <summary>
     /// All tables in the generated code derive from this struct, and add their own accessors.
     /// </summary>
     internal struct Table
     {
-        public int bb_pos;
-        public ByteBuffer bb;
+        public int bb_pos { get; private set; }
+        public ByteBuffer bb { get; private set; }
 
         public ByteBuffer ByteBuffer { get { return bb; } }
 
+        // Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
+        public Table(int _i, ByteBuffer _bb) : this()
+        {
+            bb = _bb;
+            bb_pos = _i;
+        }
+
         // Look up a field in the vtable, return an offset into the object, or 0 if the field is not
         // present.
         public int __offset(int vtableOffset)
@@ -57,7 +65,11 @@ public static int __indirect(int offset, ByteBuffer bb)
         // Create a .NET String from UTF-8 data stored inside the flatbuffer.
         public string __string(int offset)
         {
-            offset += bb.GetInt(offset);
+            int stringOffset = bb.GetInt(offset);
+            if (stringOffset == 0)
+                return null;
+
+            offset += stringOffset;
             var len = bb.GetInt(offset);
             var startPos = offset + sizeof(int);
             return bb.GetStringUTF8(startPos, len);
@@ -78,21 +90,27 @@ public int __vector(int offset)
             return offset + bb.GetInt(offset) + sizeof(int);  // data starts after the length
         }
 
-#if ENABLE_SPAN_T
+#if ENABLE_SPAN_T && (UNSAFE_BYTEBUFFER || NETSTANDARD2_1)
         // Get the data of a vector whoses offset is stored at "offset" in this object as an
         // Spant&lt;byte&gt;. If the vector is not present in the ByteBuffer,
         // then an empty span will be returned.
-        public Span<byte> __vector_as_span(int offset)
+        public Span<T> __vector_as_span<T>(int offset, int elementSize) where T : struct
         {
+            if (!BitConverter.IsLittleEndian)
+            {
+               throw new NotSupportedException("Getting typed span on a Big Endian " +
+                                               "system is not support");
+            }
+
             var o = this.__offset(offset);
             if (0 == o)
             {
-                return new Span<byte>();
+                return new Span<T>();
             }
 
             var pos = this.__vector(o);
             var len = this.__vector_len(o);
-            return bb.ToSpan(pos, len);
+            return MemoryMarshal.Cast<byte, T>(bb.ToSpan(pos, len * elementSize));
         }
 #else
         // Get the data of a vector whoses offset is stored at "offset" in this object as an
@@ -138,9 +156,8 @@ public T[] __vector_as_array<T>(int offset)
         // Initialize any Table-derived type to point to the union at the given offset.
         public T __union<T>(int offset) where T : struct, IFlatbufferObject
         {
-            offset += bb_pos;
             T t = new T();
-            t.__init(offset + bb.GetInt(offset), bb);
+            t.__init(__indirect(offset), bb);
             return t;
         }
 
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Footer.cs b/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
index 37dbfef94093a..6c1530d3de8cf 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Footer.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Arrow File metadata
@@ -15,9 +16,11 @@ internal struct Footer : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Footer GetRootAsFooter(ByteBuffer _bb) { return GetRootAsFooter(_bb, new Footer()); }
   public static Footer GetRootAsFooter(ByteBuffer _bb, Footer obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyFooter(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, FooterVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Footer __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public MetadataVersion Version { get { int o = __p.__offset(4); return o != 0 ? (MetadataVersion)__p.bb.GetShort(o + __p.bb_pos) : MetadataVersion.V1; } }
@@ -36,7 +39,7 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
       VectorOffset dictionariesOffset = default(VectorOffset),
       VectorOffset recordBatchesOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(5);
+    builder.StartTable(5);
     Footer.AddCustomMetadata(builder, custom_metadataOffset);
     Footer.AddRecordBatches(builder, recordBatchesOffset);
     Footer.AddDictionaries(builder, dictionariesOffset);
@@ -45,7 +48,7 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
     return Footer.EndFooter(builder);
   }
 
-  public static void StartFooter(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartFooter(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddVersion(FlatBufferBuilder builder, MetadataVersion version) { builder.AddShort(0, (short)version, 0); }
   public static void AddSchema(FlatBufferBuilder builder, Offset<Schema> schemaOffset) { builder.AddOffset(1, schemaOffset.Value, 0); }
   public static void AddDictionaries(FlatBufferBuilder builder, VectorOffset dictionariesOffset) { builder.AddOffset(2, dictionariesOffset.Value, 0); }
@@ -55,14 +58,30 @@ public static Offset<Footer> CreateFooter(FlatBufferBuilder builder,
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(4, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Footer> EndFooter(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Footer>(o);
   }
   public static void FinishFooterBuffer(FlatBufferBuilder builder, Offset<Footer> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedFooterBuffer(FlatBufferBuilder builder, Offset<Footer> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class FooterVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Version*/, 2 /*MetadataVersion*/, 2, false)
+      && verifier.VerifyTable(tablePos, 6 /*Schema*/, SchemaVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 8 /*Dictionaries*/, 24 /*Block*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*RecordBatches*/, 24 /*Block*/, false)
+      && verifier.VerifyVectorOfTables(tablePos, 12 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs b/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
index 5b8c2efcaac14..3dffb618604fc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/KeyValue.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// user defined key value pairs to add custom metadata to arrow
@@ -15,21 +16,22 @@ internal struct KeyValue : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static KeyValue GetRootAsKeyValue(ByteBuffer _bb) { return GetRootAsKeyValue(_bb, new KeyValue()); }
   public static KeyValue GetRootAsKeyValue(ByteBuffer _bb, KeyValue obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public KeyValue __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public string Key { get { int o = __p.__offset(4); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetKeyBytes() { return __p.__vector_as_span(4); }
+  public Span<byte> GetKeyBytes() { return __p.__vector_as_span<byte>(4, 1); }
 #else
   public ArraySegment<byte>? GetKeyBytes() { return __p.__vector_as_arraysegment(4); }
 #endif
   public byte[] GetKeyArray() { return __p.__vector_as_array<byte>(4); }
   public string Value { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetValueBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetValueBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetValueBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -38,20 +40,31 @@ internal struct KeyValue : IFlatbufferObject
   public static Offset<KeyValue> CreateKeyValue(FlatBufferBuilder builder,
       StringOffset keyOffset = default(StringOffset),
       StringOffset valueOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     KeyValue.AddValue(builder, valueOffset);
     KeyValue.AddKey(builder, keyOffset);
     return KeyValue.EndKeyValue(builder);
   }
 
-  public static void StartKeyValue(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartKeyValue(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddKey(FlatBufferBuilder builder, StringOffset keyOffset) { builder.AddOffset(0, keyOffset.Value, 0); }
   public static void AddValue(FlatBufferBuilder builder, StringOffset valueOffset) { builder.AddOffset(1, valueOffset.Value, 0); }
   public static Offset<KeyValue> EndKeyValue(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<KeyValue>(o);
   }
-};
+}
+
 
+static internal class KeyValueVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyString(tablePos, 4 /*Key*/, false)
+      && verifier.VerifyString(tablePos, 6 /*Value*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Map.cs b/csharp/src/Apache.Arrow/Flatbuf/Map.cs
index 9141f4c932d03..4b4c292482d29 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Map.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Map.cs
@@ -6,28 +6,30 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A Map is a logical nested type that is represented as
 ///
-/// List<entry: Struct<key: K, value: V>>
+/// List<entries: Struct<key: K, value: V>>
 ///
 /// In this layout, the keys and values are each respectively contiguous. We do
 /// not constrain the key and value types, so the application is responsible
 /// for ensuring that the keys are hashable and unique. Whether the keys are sorted
-/// may be set in the metadata for this field
+/// may be set in the metadata for this field.
 ///
-/// In a Field with Map type, the Field has a child Struct field, which then
+/// 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 "entry", "key", and "value", but this is
-/// not enforced
+/// child fields may be respectively "entries", "key", and "value", but this is
+/// not enforced.
 ///
 /// Map
-///   - child[0] entry: Struct
+/// ```text
+///   - child[0] entries: Struct
 ///     - child[0] key: K
 ///     - child[1] value: V
-///
-/// Neither the "entry" field nor the "key" field may be nullable.
+/// ```
+/// Neither the "entries" field nor the "key" field may be nullable.
 ///
 /// The metadata is structured so that Arrow systems without special handling
 /// for Map can make Map an alias for List. The "layout" attribute for the Map
@@ -36,9 +38,10 @@ internal struct Map : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Map GetRootAsMap(ByteBuffer _bb) { return GetRootAsMap(_bb, new Map()); }
   public static Map GetRootAsMap(ByteBuffer _bb, Map obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Map __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Set to true if the keys within each value are sorted
@@ -46,18 +49,28 @@ internal struct Map : IFlatbufferObject
 
   public static Offset<Map> CreateMap(FlatBufferBuilder builder,
       bool keysSorted = false) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Map.AddKeysSorted(builder, keysSorted);
     return Map.EndMap(builder);
   }
 
-  public static void StartMap(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartMap(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddKeysSorted(FlatBufferBuilder builder, bool keysSorted) { builder.AddBool(0, keysSorted, false); }
   public static Offset<Map> EndMap(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Map>(o);
   }
-};
+}
+
 
+static internal class MapVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*KeysSorted*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Message.cs b/csharp/src/Apache.Arrow/Flatbuf/Message.cs
index db54e6ab32c79..5cd469d7e94f3 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Message.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Message.cs
@@ -6,20 +6,28 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Message : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Message GetRootAsMessage(ByteBuffer _bb) { return GetRootAsMessage(_bb, new Message()); }
   public static Message GetRootAsMessage(ByteBuffer _bb, Message obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyMessage(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, MessageVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Message __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public MetadataVersion Version { get { int o = __p.__offset(4); return o != 0 ? (MetadataVersion)__p.bb.GetShort(o + __p.bb_pos) : MetadataVersion.V1; } }
   public MessageHeader HeaderType { get { int o = __p.__offset(6); return o != 0 ? (MessageHeader)__p.bb.Get(o + __p.bb_pos) : MessageHeader.NONE; } }
-  public TTable? Header<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(8); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public TTable? Header<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(8); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Schema HeaderAsSchema() { return Header<Schema>().Value; }
+  public DictionaryBatch HeaderAsDictionaryBatch() { return Header<DictionaryBatch>().Value; }
+  public RecordBatch HeaderAsRecordBatch() { return Header<RecordBatch>().Value; }
+  public Tensor HeaderAsTensor() { return Header<Tensor>().Value; }
+  public SparseTensor HeaderAsSparseTensor() { return Header<SparseTensor>().Value; }
   public long BodyLength { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public KeyValue? CustomMetadata(int j) { int o = __p.__offset(12); return o != 0 ? (KeyValue?)(new KeyValue()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int CustomMetadataLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
@@ -30,7 +38,7 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
       int headerOffset = 0,
       long bodyLength = 0,
       VectorOffset custom_metadataOffset = default(VectorOffset)) {
-    builder.StartObject(5);
+    builder.StartTable(5);
     Message.AddBodyLength(builder, bodyLength);
     Message.AddCustomMetadata(builder, custom_metadataOffset);
     Message.AddHeader(builder, headerOffset);
@@ -39,7 +47,7 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
     return Message.EndMessage(builder);
   }
 
-  public static void StartMessage(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartMessage(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddVersion(FlatBufferBuilder builder, MetadataVersion version) { builder.AddShort(0, (short)version, 0); }
   public static void AddHeaderType(FlatBufferBuilder builder, MessageHeader headerType) { builder.AddByte(1, (byte)headerType, 0); }
   public static void AddHeader(FlatBufferBuilder builder, int headerOffset) { builder.AddOffset(2, headerOffset, 0); }
@@ -47,14 +55,30 @@ public static Offset<Message> CreateMessage(FlatBufferBuilder builder,
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(4, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Message> EndMessage(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Message>(o);
   }
   public static void FinishMessageBuffer(FlatBufferBuilder builder, Offset<Message> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedMessageBuffer(FlatBufferBuilder builder, Offset<Message> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class MessageVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Version*/, 2 /*MetadataVersion*/, 2, false)
+      && verifier.VerifyField(tablePos, 6 /*HeaderType*/, 1 /*MessageHeader*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 6, 8 /*Header*/, MessageHeaderVerify.Verify, false)
+      && verifier.VerifyField(tablePos, 10 /*BodyLength*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfTables(tablePos, 12 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs b/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
index 4c95acde9d85d..9ab9715165ddc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/RecordBatch.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A data header describing the shared memory layout of a "record" or "row"
 /// batch. Some systems call this a "row batch" internally and others a "record
@@ -15,9 +16,10 @@ internal struct RecordBatch : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static RecordBatch GetRootAsRecordBatch(ByteBuffer _bb) { return GetRootAsRecordBatch(_bb, new RecordBatch()); }
   public static RecordBatch GetRootAsRecordBatch(ByteBuffer _bb, RecordBatch obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public RecordBatch __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// number of records / rows. The arrays in the batch should all have this
@@ -42,7 +44,7 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
       VectorOffset nodesOffset = default(VectorOffset),
       VectorOffset buffersOffset = default(VectorOffset),
       Offset<BodyCompression> compressionOffset = default(Offset<BodyCompression>)) {
-    builder.StartObject(4);
+    builder.StartTable(4);
     RecordBatch.AddLength(builder, length);
     RecordBatch.AddCompression(builder, compressionOffset);
     RecordBatch.AddBuffers(builder, buffersOffset);
@@ -50,7 +52,7 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
     return RecordBatch.EndRecordBatch(builder);
   }
 
-  public static void StartRecordBatch(FlatBufferBuilder builder) { builder.StartObject(4); }
+  public static void StartRecordBatch(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddLength(FlatBufferBuilder builder, long length) { builder.AddLong(0, length, 0); }
   public static void AddNodes(FlatBufferBuilder builder, VectorOffset nodesOffset) { builder.AddOffset(1, nodesOffset.Value, 0); }
   public static void StartNodesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
@@ -58,10 +60,23 @@ public static Offset<RecordBatch> CreateRecordBatch(FlatBufferBuilder builder,
   public static void StartBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
   public static void AddCompression(FlatBufferBuilder builder, Offset<BodyCompression> compressionOffset) { builder.AddOffset(3, compressionOffset.Value, 0); }
   public static Offset<RecordBatch> EndRecordBatch(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<RecordBatch>(o);
   }
-};
+}
+
 
+static internal class RecordBatchVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Length*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*Nodes*/, 16 /*FieldNode*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 8 /*Buffers*/, 16 /*Buffer*/, false)
+      && verifier.VerifyTable(tablePos, 10 /*Compression*/, BodyCompressionVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs b/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
new file mode 100644
index 0000000000000..78c602c425bb2
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/RunEndEncoded.cs
@@ -0,0 +1,45 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// 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.
+internal struct RunEndEncoded : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static RunEndEncoded GetRootAsRunEndEncoded(ByteBuffer _bb) { return GetRootAsRunEndEncoded(_bb, new RunEndEncoded()); }
+  public static RunEndEncoded GetRootAsRunEndEncoded(ByteBuffer _bb, RunEndEncoded obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public RunEndEncoded __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void StartRunEndEncoded(FlatBufferBuilder builder) { builder.StartTable(0); }
+  public static Offset<RunEndEncoded> EndRunEndEncoded(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<RunEndEncoded>(o);
+  }
+}
+
+
+static internal class RunEndEncodedVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Schema.cs b/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
index 3764e7ba3a1fa..1d7b3f4f343fe 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Schema.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// A Schema describes the columns in a row batch
@@ -14,9 +15,11 @@ internal struct Schema : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Schema GetRootAsSchema(ByteBuffer _bb) { return GetRootAsSchema(_bb, new Schema()); }
   public static Schema GetRootAsSchema(ByteBuffer _bb, Schema obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifySchema(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, SchemaVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Schema __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// endianness of the buffer
@@ -31,18 +34,18 @@ internal struct Schema : IFlatbufferObject
   public Feature Features(int j) { int o = __p.__offset(10); return o != 0 ? (Feature)__p.bb.GetLong(__p.__vector(o) + j * 8) : (Feature)0; }
   public int FeaturesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetFeaturesBytes() { return __p.__vector_as_span(10); }
+  public Span<Feature> GetFeaturesBytes() { return __p.__vector_as_span<Feature>(10, 8); }
 #else
   public ArraySegment<byte>? GetFeaturesBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
-  public Feature[] GetFeaturesArray() { return __p.__vector_as_array<Feature>(10); }
+  public Feature[] GetFeaturesArray() { int o = __p.__offset(10); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); Feature[] a = new Feature[l]; for (int i = 0; i < l; i++) { a[i] = (Feature)__p.bb.GetLong(p + i * 8); } return a; }
 
   public static Offset<Schema> CreateSchema(FlatBufferBuilder builder,
       Endianness endianness = Endianness.Little,
       VectorOffset fieldsOffset = default(VectorOffset),
       VectorOffset custom_metadataOffset = default(VectorOffset),
       VectorOffset featuresOffset = default(VectorOffset)) {
-    builder.StartObject(4);
+    builder.StartTable(4);
     Schema.AddFeatures(builder, featuresOffset);
     Schema.AddCustomMetadata(builder, custom_metadataOffset);
     Schema.AddFields(builder, fieldsOffset);
@@ -50,27 +53,46 @@ public static Offset<Schema> CreateSchema(FlatBufferBuilder builder,
     return Schema.EndSchema(builder);
   }
 
-  public static void StartSchema(FlatBufferBuilder builder) { builder.StartObject(4); }
+  public static void StartSchema(FlatBufferBuilder builder) { builder.StartTable(4); }
   public static void AddEndianness(FlatBufferBuilder builder, Endianness endianness) { builder.AddShort(0, (short)endianness, 0); }
   public static void AddFields(FlatBufferBuilder builder, VectorOffset fieldsOffset) { builder.AddOffset(1, fieldsOffset.Value, 0); }
   public static VectorOffset CreateFieldsVector(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, Offset<Field>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<Field>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFieldsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<Field>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartFieldsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddCustomMetadata(FlatBufferBuilder builder, VectorOffset customMetadataOffset) { builder.AddOffset(2, customMetadataOffset.Value, 0); }
   public static VectorOffset CreateCustomMetadataVector(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, Offset<KeyValue>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<KeyValue>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateCustomMetadataVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<KeyValue>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartCustomMetadataVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddFeatures(FlatBufferBuilder builder, VectorOffset featuresOffset) { builder.AddOffset(3, featuresOffset.Value, 0); }
   public static VectorOffset CreateFeaturesVector(FlatBufferBuilder builder, Feature[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong((long)data[i]); return builder.EndVector(); }
   public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, Feature[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, ArraySegment<Feature> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateFeaturesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Feature>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartFeaturesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
   public static Offset<Schema> EndSchema(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Schema>(o);
   }
   public static void FinishSchemaBuffer(FlatBufferBuilder builder, Offset<Schema> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedSchemaBuffer(FlatBufferBuilder builder, Offset<Schema> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class SchemaVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Endianness*/, 2 /*Endianness*/, 2, false)
+      && verifier.VerifyVectorOfTables(tablePos, 6 /*Fields*/, FieldVerify.Verify, false)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*CustomMetadata*/, KeyValueVerify.Verify, false)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*Features*/, 8 /*Feature*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
new file mode 100644
index 0000000000000..67bf99271127c
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixCompressedAxis.cs
@@ -0,0 +1,15 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+internal enum SparseMatrixCompressedAxis : short
+{
+  Row = 0,
+  Column = 1,
+};
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
new file mode 100644
index 0000000000000..feea620e7c6b6
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseMatrixIndexCSX.cs
@@ -0,0 +1,95 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// Compressed Sparse format, that is matrix-specific.
+internal struct SparseMatrixIndexCSX : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseMatrixIndexCSX GetRootAsSparseMatrixIndexCSX(ByteBuffer _bb) { return GetRootAsSparseMatrixIndexCSX(_bb, new SparseMatrixIndexCSX()); }
+  public static SparseMatrixIndexCSX GetRootAsSparseMatrixIndexCSX(ByteBuffer _bb, SparseMatrixIndexCSX obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseMatrixIndexCSX __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// Which axis, row or column, is compressed
+  public SparseMatrixCompressedAxis CompressedAxis { get { int o = __p.__offset(4); return o != 0 ? (SparseMatrixCompressedAxis)__p.bb.GetShort(o + __p.bb_pos) : SparseMatrixCompressedAxis.Row; } }
+  /// The type of values in indptrBuffer
+  public Int? IndptrType { get { int o = __p.__offset(6); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indptrBuffer stores the location and size of indptr array that
+  /// represents the range of the rows.
+  /// The i-th row spans from `indptr[i]` to `indptr[i+1]` in the data.
+  /// The length of this array is 1 + (the number of rows), and the type
+  /// of index value is long.
+  ///
+  /// For example, let X be the following 6x4 matrix:
+  /// ```text
+  ///   X := [[0, 1, 2, 0],
+  ///         [0, 0, 3, 0],
+  ///         [0, 4, 0, 5],
+  ///         [0, 0, 0, 0],
+  ///         [6, 0, 7, 8],
+  ///         [0, 9, 0, 0]].
+  /// ```
+  /// The array of non-zero values in X is:
+  /// ```text
+  ///   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
+  /// ```
+  /// And the indptr of X is:
+  /// ```text
+  ///   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
+  /// ```
+  public Buffer? IndptrBuffer { get { int o = __p.__offset(8); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  /// The type of values in indicesBuffer
+  public Int? IndicesType { get { int o = __p.__offset(10); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indicesBuffer stores the location and size of the array that
+  /// contains the column indices of the corresponding non-zero values.
+  /// The type of index value is long.
+  ///
+  /// For example, the indices of the above X is:
+  /// ```text
+  ///   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
+  /// ```
+  /// Note that the indices are sorted in lexicographical order for each row.
+  public Buffer? IndicesBuffer { get { int o = __p.__offset(12); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartSparseMatrixIndexCSX(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddCompressedAxis(FlatBufferBuilder builder, SparseMatrixCompressedAxis compressedAxis) { builder.AddShort(0, (short)compressedAxis, 0); }
+  public static void AddIndptrType(FlatBufferBuilder builder, Offset<Int> indptrTypeOffset) { builder.AddOffset(1, indptrTypeOffset.Value, 0); }
+  public static void AddIndptrBuffer(FlatBufferBuilder builder, Offset<Buffer> indptrBufferOffset) { builder.AddStruct(2, indptrBufferOffset.Value, 0); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(3, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesBuffer(FlatBufferBuilder builder, Offset<Buffer> indicesBufferOffset) { builder.AddStruct(4, indicesBufferOffset.Value, 0); }
+  public static Offset<SparseMatrixIndexCSX> EndSparseMatrixIndexCSX(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // indptrType
+    builder.Required(o, 8);  // indptrBuffer
+    builder.Required(o, 10);  // indicesType
+    builder.Required(o, 12);  // indicesBuffer
+    return new Offset<SparseMatrixIndexCSX>(o);
+  }
+}
+
+
+static internal class SparseMatrixIndexCSXVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*CompressedAxis*/, 2 /*SparseMatrixCompressedAxis*/, 2, false)
+      && verifier.VerifyTable(tablePos, 6 /*IndptrType*/, IntVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 8 /*IndptrBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTable(tablePos, 10 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 12 /*IndicesBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
new file mode 100644
index 0000000000000..3f9e1de7c00a9
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensor.cs
@@ -0,0 +1,106 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+internal struct SparseTensor : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensor GetRootAsSparseTensor(ByteBuffer _bb) { return GetRootAsSparseTensor(_bb, new SparseTensor()); }
+  public static SparseTensor GetRootAsSparseTensor(ByteBuffer _bb, SparseTensor obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public static bool VerifySparseTensor(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, SparseTensorVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensor __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
+  /// The type of data contained in a value cell.
+  /// Currently only fixed-width value types are supported,
+  /// no strings or nested types.
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
+  /// The dimensions of the tensor, optionally named.
+  public TensorDim? Shape(int j) { int o = __p.__offset(8); return o != 0 ? (TensorDim?)(new TensorDim()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int ShapeLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// The number of non-zero values in a sparse tensor.
+  public long NonZeroLength { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SparseTensorIndex SparseIndexType { get { int o = __p.__offset(12); return o != 0 ? (SparseTensorIndex)__p.bb.Get(o + __p.bb_pos) : SparseTensorIndex.NONE; } }
+  /// Sparse tensor index
+  public TTable? SparseIndex<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(14); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public SparseTensorIndexCOO SparseIndexAsSparseTensorIndexCOO() { return SparseIndex<SparseTensorIndexCOO>().Value; }
+  public SparseMatrixIndexCSX SparseIndexAsSparseMatrixIndexCSX() { return SparseIndex<SparseMatrixIndexCSX>().Value; }
+  public SparseTensorIndexCSF SparseIndexAsSparseTensorIndexCSF() { return SparseIndex<SparseTensorIndexCSF>().Value; }
+  /// The location and size of the tensor's data
+  public Buffer? Data { get { int o = __p.__offset(16); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+
+  public static void StartSparseTensor(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(0, (byte)typeType, 0); }
+  public static void AddType(FlatBufferBuilder builder, int typeOffset) { builder.AddOffset(1, typeOffset, 0); }
+  public static void AddShape(FlatBufferBuilder builder, VectorOffset shapeOffset) { builder.AddOffset(2, shapeOffset.Value, 0); }
+  public static VectorOffset CreateShapeVector(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<TensorDim>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<TensorDim>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartShapeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddNonZeroLength(FlatBufferBuilder builder, long nonZeroLength) { builder.AddLong(3, nonZeroLength, 0); }
+  public static void AddSparseIndexType(FlatBufferBuilder builder, SparseTensorIndex sparseIndexType) { builder.AddByte(4, (byte)sparseIndexType, 0); }
+  public static void AddSparseIndex(FlatBufferBuilder builder, int sparseIndexOffset) { builder.AddOffset(5, sparseIndexOffset, 0); }
+  public static void AddData(FlatBufferBuilder builder, Offset<Buffer> dataOffset) { builder.AddStruct(6, dataOffset.Value, 0); }
+  public static Offset<SparseTensor> EndSparseTensor(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // type
+    builder.Required(o, 8);  // shape
+    builder.Required(o, 14);  // sparseIndex
+    builder.Required(o, 16);  // data
+    return new Offset<SparseTensor>(o);
+  }
+  public static void FinishSparseTensorBuffer(FlatBufferBuilder builder, Offset<SparseTensor> offset) { builder.Finish(offset.Value); }
+  public static void FinishSizePrefixedSparseTensorBuffer(FlatBufferBuilder builder, Offset<SparseTensor> offset) { builder.FinishSizePrefixed(offset.Value); }
+}
+
+
+static internal class SparseTensorVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, TypeVerify.Verify, true)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*Shape*/, TensorDimVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 10 /*NonZeroLength*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*SparseIndexType*/, 1 /*SparseTensorIndex*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 12, 14 /*SparseIndex*/, SparseTensorIndexVerify.Verify, true)
+      && verifier.VerifyField(tablePos, 16 /*Data*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
new file mode 100644
index 0000000000000..16bfb2dd173f7
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndex.cs
@@ -0,0 +1,42 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+internal enum SparseTensorIndex : byte
+{
+  NONE = 0,
+  SparseTensorIndexCOO = 1,
+  SparseMatrixIndexCSX = 2,
+  SparseTensorIndexCSF = 3,
+};
+
+
+
+static internal class SparseTensorIndexVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, byte typeId, uint tablePos)
+  {
+    bool result = true;
+    switch((SparseTensorIndex)typeId)
+    {
+      case SparseTensorIndex.SparseTensorIndexCOO:
+        result = SparseTensorIndexCOOVerify.Verify(verifier, tablePos);
+        break;
+      case SparseTensorIndex.SparseMatrixIndexCSX:
+        result = SparseMatrixIndexCSXVerify.Verify(verifier, tablePos);
+        break;
+      case SparseTensorIndex.SparseTensorIndexCSF:
+        result = SparseTensorIndexCSFVerify.Verify(verifier, tablePos);
+        break;
+      default: result = true;
+        break;
+    }
+    return result;
+  }
+}
+
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
new file mode 100644
index 0000000000000..f0cdae226603a
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCOO.cs
@@ -0,0 +1,107 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// ----------------------------------------------------------------------
+/// EXPERIMENTAL: Data structures for sparse tensors
+/// Coordinate (COO) format of sparse tensor index.
+///
+/// COO's index list are represented as a NxM matrix,
+/// where N is the number of non-zero values,
+/// and M is the number of dimensions of a sparse tensor.
+///
+/// indicesBuffer stores the location and size of the data of this indices
+/// matrix.  The value type and the stride of the indices matrix is
+/// specified in indicesType and indicesStrides fields.
+///
+/// For example, let X be a 2x3x4x5 tensor, and it has the following
+/// 6 non-zero values:
+/// ```text
+///   X[0, 1, 2, 0] := 1
+///   X[1, 1, 2, 3] := 2
+///   X[0, 2, 1, 0] := 3
+///   X[0, 1, 3, 0] := 4
+///   X[0, 1, 2, 1] := 5
+///   X[1, 2, 0, 4] := 6
+/// ```
+/// In COO format, the index matrix of X is the following 4x6 matrix:
+/// ```text
+///   [[0, 0, 0, 0, 1, 1],
+///    [1, 1, 1, 2, 1, 2],
+///    [2, 2, 3, 1, 2, 0],
+///    [0, 1, 0, 0, 3, 4]]
+/// ```
+/// When isCanonical is true, the indices is sorted in lexicographical order
+/// (row-major order), and it does not have duplicated entries.  Otherwise,
+/// the indices may not be sorted, or may have duplicated entries.
+internal struct SparseTensorIndexCOO : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensorIndexCOO GetRootAsSparseTensorIndexCOO(ByteBuffer _bb) { return GetRootAsSparseTensorIndexCOO(_bb, new SparseTensorIndexCOO()); }
+  public static SparseTensorIndexCOO GetRootAsSparseTensorIndexCOO(ByteBuffer _bb, SparseTensorIndexCOO obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensorIndexCOO __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// The type of values in indicesBuffer
+  public Int? IndicesType { get { int o = __p.__offset(4); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// Non-negative byte offsets to advance one value cell along each dimension
+  /// If omitted, default to row-major order (C-like).
+  public long IndicesStrides(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int IndicesStridesLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetIndicesStridesBytes() { return __p.__vector_as_span<long>(6, 8); }
+#else
+  public ArraySegment<byte>? GetIndicesStridesBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public long[] GetIndicesStridesArray() { return __p.__vector_as_array<long>(6); }
+  /// The location and size of the indices matrix's data
+  public Buffer? IndicesBuffer { get { int o = __p.__offset(8); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
+  /// This flag is true if and only if the indices matrix is sorted in
+  /// row-major order, and does not have duplicated entries.
+  /// This sort order is the same as of Tensorflow's SparseTensor,
+  /// but it is inverse order of SciPy's canonical coo_matrix
+  /// (SciPy employs column-major order for its coo_matrix).
+  public bool IsCanonical { get { int o = __p.__offset(10); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+
+  public static void StartSparseTensorIndexCOO(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(0, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesStrides(FlatBufferBuilder builder, VectorOffset indicesStridesOffset) { builder.AddOffset(1, indicesStridesOffset.Value, 0); }
+  public static VectorOffset CreateIndicesStridesVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateIndicesStridesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartIndicesStridesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddIndicesBuffer(FlatBufferBuilder builder, Offset<Buffer> indicesBufferOffset) { builder.AddStruct(2, indicesBufferOffset.Value, 0); }
+  public static void AddIsCanonical(FlatBufferBuilder builder, bool isCanonical) { builder.AddBool(3, isCanonical, false); }
+  public static Offset<SparseTensorIndexCOO> EndSparseTensorIndexCOO(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 4);  // indicesType
+    builder.Required(o, 8);  // indicesBuffer
+    return new Offset<SparseTensorIndexCOO>(o);
+  }
+}
+
+
+static internal class SparseTensorIndexCOOVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*IndicesStrides*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 8 /*IndicesBuffer*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyField(tablePos, 10 /*IsCanonical*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs
new file mode 100644
index 0000000000000..1ca54ed83fd5d
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Flatbuf/SparseTensorIndexCSF.cs
@@ -0,0 +1,155 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace Apache.Arrow.Flatbuf
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+/// Compressed Sparse Fiber (CSF) sparse tensor index.
+internal struct SparseTensorIndexCSF : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
+  public static SparseTensorIndexCSF GetRootAsSparseTensorIndexCSF(ByteBuffer _bb) { return GetRootAsSparseTensorIndexCSF(_bb, new SparseTensorIndexCSF()); }
+  public static SparseTensorIndexCSF GetRootAsSparseTensorIndexCSF(ByteBuffer _bb, SparseTensorIndexCSF obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public SparseTensorIndexCSF __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /// CSF is a generalization of compressed sparse row (CSR) index.
+  /// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
+  ///
+  /// CSF index recursively compresses each dimension of a tensor into a set
+  /// of prefix trees. Each path from a root to leaf forms one tensor
+  /// non-zero index. CSF is implemented with two arrays of buffers and one
+  /// arrays of integers.
+  ///
+  /// For example, let X be a 2x3x4x5 tensor and let it have the following
+  /// 8 non-zero values:
+  /// ```text
+  ///   X[0, 0, 0, 1] := 1
+  ///   X[0, 0, 0, 2] := 2
+  ///   X[0, 1, 0, 0] := 3
+  ///   X[0, 1, 0, 2] := 4
+  ///   X[0, 1, 1, 0] := 5
+  ///   X[1, 1, 1, 0] := 6
+  ///   X[1, 1, 1, 1] := 7
+  ///   X[1, 1, 1, 2] := 8
+  /// ```
+  /// As a prefix tree this would be represented as:
+  /// ```text
+  ///         0          1
+  ///        / \         |
+  ///       0   1        1
+  ///      /   / \       |
+  ///     0   0   1      1
+  ///    /|  /|   |    /| |
+  ///   1 2 0 2   0   0 1 2
+  /// ```
+  /// The type of values in indptrBuffers
+  public Int? IndptrType { get { int o = __p.__offset(4); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indptrBuffers stores the sparsity structure.
+  /// Each two consecutive dimensions in a tensor correspond to a buffer in
+  /// indptrBuffers. A pair of consecutive values at `indptrBuffers[dim][i]`
+  /// and `indptrBuffers[dim][i + 1]` signify a range of nodes in
+  /// `indicesBuffers[dim + 1]` who are children of `indicesBuffers[dim][i]` node.
+  ///
+  /// For example, the indptrBuffers for the above X is:
+  /// ```text
+  ///   indptrBuffer(X) = [
+  ///                       [0, 2, 3],
+  ///                       [0, 1, 3, 4],
+  ///                       [0, 2, 4, 5, 8]
+  ///                     ].
+  /// ```
+  public Buffer? IndptrBuffers(int j) { int o = __p.__offset(6); return o != 0 ? (Buffer?)(new Buffer()).__assign(__p.__vector(o) + j * 16, __p.bb) : null; }
+  public int IndptrBuffersLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// The type of values in indicesBuffers
+  public Int? IndicesType { get { int o = __p.__offset(8); return o != 0 ? (Int?)(new Int()).__assign(__p.__indirect(o + __p.bb_pos), __p.bb) : null; } }
+  /// indicesBuffers stores values of nodes.
+  /// Each tensor dimension corresponds to a buffer in indicesBuffers.
+  /// For example, the indicesBuffers for the above X is:
+  /// ```text
+  ///   indicesBuffer(X) = [
+  ///                        [0, 1],
+  ///                        [0, 1, 1],
+  ///                        [0, 0, 1, 1],
+  ///                        [1, 2, 0, 2, 0, 0, 1, 2]
+  ///                      ].
+  /// ```
+  public Buffer? IndicesBuffers(int j) { int o = __p.__offset(10); return o != 0 ? (Buffer?)(new Buffer()).__assign(__p.__vector(o) + j * 16, __p.bb) : null; }
+  public int IndicesBuffersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
+  /// axisOrder stores the sequence in which dimensions were traversed to
+  /// produce the prefix tree.
+  /// For example, the axisOrder for the above X is:
+  /// ```text
+  ///   axisOrder(X) = [0, 1, 2, 3].
+  /// ```
+  public int AxisOrder(int j) { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int AxisOrderLength { get { int o = __p.__offset(12); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<int> GetAxisOrderBytes() { return __p.__vector_as_span<int>(12, 4); }
+#else
+  public ArraySegment<byte>? GetAxisOrderBytes() { return __p.__vector_as_arraysegment(12); }
+#endif
+  public int[] GetAxisOrderArray() { return __p.__vector_as_array<int>(12); }
+
+  public static Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSF(FlatBufferBuilder builder,
+      Offset<Int> indptrTypeOffset = default(Offset<Int>),
+      VectorOffset indptrBuffersOffset = default(VectorOffset),
+      Offset<Int> indicesTypeOffset = default(Offset<Int>),
+      VectorOffset indicesBuffersOffset = default(VectorOffset),
+      VectorOffset axisOrderOffset = default(VectorOffset)) {
+    builder.StartTable(5);
+    SparseTensorIndexCSF.AddAxisOrder(builder, axisOrderOffset);
+    SparseTensorIndexCSF.AddIndicesBuffers(builder, indicesBuffersOffset);
+    SparseTensorIndexCSF.AddIndicesType(builder, indicesTypeOffset);
+    SparseTensorIndexCSF.AddIndptrBuffers(builder, indptrBuffersOffset);
+    SparseTensorIndexCSF.AddIndptrType(builder, indptrTypeOffset);
+    return SparseTensorIndexCSF.EndSparseTensorIndexCSF(builder);
+  }
+
+  public static void StartSparseTensorIndexCSF(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void AddIndptrType(FlatBufferBuilder builder, Offset<Int> indptrTypeOffset) { builder.AddOffset(0, indptrTypeOffset.Value, 0); }
+  public static void AddIndptrBuffers(FlatBufferBuilder builder, VectorOffset indptrBuffersOffset) { builder.AddOffset(1, indptrBuffersOffset.Value, 0); }
+  public static void StartIndptrBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
+  public static void AddIndicesType(FlatBufferBuilder builder, Offset<Int> indicesTypeOffset) { builder.AddOffset(2, indicesTypeOffset.Value, 0); }
+  public static void AddIndicesBuffers(FlatBufferBuilder builder, VectorOffset indicesBuffersOffset) { builder.AddOffset(3, indicesBuffersOffset.Value, 0); }
+  public static void StartIndicesBuffersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(16, numElems, 8); }
+  public static void AddAxisOrder(FlatBufferBuilder builder, VectorOffset axisOrderOffset) { builder.AddOffset(4, axisOrderOffset.Value, 0); }
+  public static VectorOffset CreateAxisOrderVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateAxisOrderVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartAxisOrderVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SparseTensorIndexCSF> EndSparseTensorIndexCSF(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    builder.Required(o, 4);  // indptrType
+    builder.Required(o, 6);  // indptrBuffers
+    builder.Required(o, 8);  // indicesType
+    builder.Required(o, 10);  // indicesBuffers
+    builder.Required(o, 12);  // axisOrder
+    return new Offset<SparseTensorIndexCSF>(o);
+  }
+}
+
+
+static internal class SparseTensorIndexCSFVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTable(tablePos, 4 /*IndptrType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*IndptrBuffers*/, 16 /*Buffer*/, true)
+      && verifier.VerifyTable(tablePos, 8 /*IndicesType*/, IntVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*IndicesBuffers*/, 16 /*Buffer*/, true)
+      && verifier.VerifyVectorOfData(tablePos, 12 /*AxisOrder*/, 4 /*int*/, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs b/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
index 918d7d6ea73f6..f8c213768a3fc 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Tensor.cs
@@ -6,29 +6,55 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Tensor : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Tensor GetRootAsTensor(ByteBuffer _bb) { return GetRootAsTensor(_bb, new Tensor()); }
   public static Tensor GetRootAsTensor(ByteBuffer _bb, Tensor obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public static bool VerifyTensor(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("", false, TensorVerify.Verify); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Tensor __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
-  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Flatbuf.Type.NONE; } }
+  public Type TypeType { get { int o = __p.__offset(4); return o != 0 ? (Type)__p.bb.Get(o + __p.bb_pos) : Apache.Arrow.Flatbuf.Type.NONE; } }
   /// The type of data contained in a value cell. Currently only fixed-width
   /// value types are supported, no strings or nested types
-  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o) : null; }
+  public TTable? Type<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(6); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
+  public Null TypeAsNull() { return Type<Null>().Value; }
+  public Int TypeAsInt() { return Type<Int>().Value; }
+  public FloatingPoint TypeAsFloatingPoint() { return Type<FloatingPoint>().Value; }
+  public Binary TypeAsBinary() { return Type<Binary>().Value; }
+  public Utf8 TypeAsUtf8() { return Type<Utf8>().Value; }
+  public Bool TypeAsBool() { return Type<Bool>().Value; }
+  public Decimal TypeAsDecimal() { return Type<Decimal>().Value; }
+  public Date TypeAsDate() { return Type<Date>().Value; }
+  public Time TypeAsTime() { return Type<Time>().Value; }
+  public Timestamp TypeAsTimestamp() { return Type<Timestamp>().Value; }
+  public Interval TypeAsInterval() { return Type<Interval>().Value; }
+  public List TypeAsList() { return Type<List>().Value; }
+  public Struct_ TypeAsStruct_() { return Type<Struct_>().Value; }
+  public Union TypeAsUnion() { return Type<Union>().Value; }
+  public FixedSizeBinary TypeAsFixedSizeBinary() { return Type<FixedSizeBinary>().Value; }
+  public FixedSizeList TypeAsFixedSizeList() { return Type<FixedSizeList>().Value; }
+  public Map TypeAsMap() { return Type<Map>().Value; }
+  public Duration TypeAsDuration() { return Type<Duration>().Value; }
+  public LargeBinary TypeAsLargeBinary() { return Type<LargeBinary>().Value; }
+  public LargeUtf8 TypeAsLargeUtf8() { return Type<LargeUtf8>().Value; }
+  public LargeList TypeAsLargeList() { return Type<LargeList>().Value; }
+  public RunEndEncoded TypeAsRunEndEncoded() { return Type<RunEndEncoded>().Value; }
   /// The dimensions of the tensor, optionally named
   public TensorDim? Shape(int j) { int o = __p.__offset(8); return o != 0 ? (TensorDim?)(new TensorDim()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
   public int ShapeLength { get { int o = __p.__offset(8); return o != 0 ? __p.__vector_len(o) : 0; } }
   /// Non-negative byte offsets to advance one value cell along each dimension
+  /// If omitted, default to row-major order (C-like).
   public long Strides(int j) { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
   public int StridesLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetStridesBytes() { return __p.__vector_as_span(10); }
+  public Span<long> GetStridesBytes() { return __p.__vector_as_span<long>(10, 8); }
 #else
   public ArraySegment<byte>? GetStridesBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
@@ -36,25 +62,46 @@ internal struct Tensor : IFlatbufferObject
   /// The location and size of the tensor's data
   public Buffer? Data { get { int o = __p.__offset(12); return o != 0 ? (Buffer?)(new Buffer()).__assign(o + __p.bb_pos, __p.bb) : null; } }
 
-  public static void StartTensor(FlatBufferBuilder builder) { builder.StartObject(5); }
+  public static void StartTensor(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddTypeType(FlatBufferBuilder builder, Type typeType) { builder.AddByte(0, (byte)typeType, 0); }
   public static void AddType(FlatBufferBuilder builder, int typeOffset) { builder.AddOffset(1, typeOffset, 0); }
   public static void AddShape(FlatBufferBuilder builder, VectorOffset shapeOffset) { builder.AddOffset(2, shapeOffset.Value, 0); }
   public static VectorOffset CreateShapeVector(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
   public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, Offset<TensorDim>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<TensorDim>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateShapeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<TensorDim>>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartShapeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddStrides(FlatBufferBuilder builder, VectorOffset stridesOffset) { builder.AddOffset(3, stridesOffset.Value, 0); }
   public static VectorOffset CreateStridesVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStridesVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartStridesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
   public static void AddData(FlatBufferBuilder builder, Offset<Buffer> dataOffset) { builder.AddStruct(4, dataOffset.Value, 0); }
   public static Offset<Tensor> EndTensor(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
+    builder.Required(o, 6);  // type
+    builder.Required(o, 8);  // shape
+    builder.Required(o, 12);  // data
     return new Offset<Tensor>(o);
   }
   public static void FinishTensorBuffer(FlatBufferBuilder builder, Offset<Tensor> offset) { builder.Finish(offset.Value); }
   public static void FinishSizePrefixedTensorBuffer(FlatBufferBuilder builder, Offset<Tensor> offset) { builder.FinishSizePrefixed(offset.Value); }
-};
+}
+
 
+static internal class TensorVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*TypeType*/, 1 /*Type*/, 1, false)
+      && verifier.VerifyUnion(tablePos, 4, 6 /*Type*/, TypeVerify.Verify, true)
+      && verifier.VerifyVectorOfTables(tablePos, 8 /*Shape*/, TensorDimVerify.Verify, true)
+      && verifier.VerifyVectorOfData(tablePos, 10 /*Strides*/, 8 /*long*/, false)
+      && verifier.VerifyField(tablePos, 12 /*Data*/, 16 /*Buffer*/, 8, true)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs b/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
index a4c51824b8e51..43d2ef5736224 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/TensorDim.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// ----------------------------------------------------------------------
 /// Data structures for dense tensors
@@ -15,9 +16,10 @@ internal struct TensorDim : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static TensorDim GetRootAsTensorDim(ByteBuffer _bb) { return GetRootAsTensorDim(_bb, new TensorDim()); }
   public static TensorDim GetRootAsTensorDim(ByteBuffer _bb, TensorDim obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public TensorDim __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Length of dimension
@@ -25,7 +27,7 @@ internal struct TensorDim : IFlatbufferObject
   /// Name of the dimension, optional
   public string Name { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -34,20 +36,31 @@ internal struct TensorDim : IFlatbufferObject
   public static Offset<TensorDim> CreateTensorDim(FlatBufferBuilder builder,
       long size = 0,
       StringOffset nameOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     TensorDim.AddSize(builder, size);
     TensorDim.AddName(builder, nameOffset);
     return TensorDim.EndTensorDim(builder);
   }
 
-  public static void StartTensorDim(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTensorDim(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddSize(FlatBufferBuilder builder, long size) { builder.AddLong(0, size, 0); }
   public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(1, nameOffset.Value, 0); }
   public static Offset<TensorDim> EndTensorDim(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<TensorDim>(o);
   }
-};
+}
+
 
+static internal class TensorDimVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Size*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*Name*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
index 0738d11e903a7..1c7b334388b5e 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Binary.cs
@@ -6,24 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
+/// Opaque binary data
 internal struct Binary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Binary GetRootAsBinary(ByteBuffer _bb) { return GetRootAsBinary(_bb, new Binary()); }
   public static Binary GetRootAsBinary(ByteBuffer _bb, Binary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Binary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartBinary(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartBinary(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Binary> EndBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Binary>(o);
   }
-};
+}
+
 
+static internal class BinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
index da488abfe01e4..529ce7dcae8e2 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Bool.cs
@@ -6,24 +6,35 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Bool : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Bool GetRootAsBool(ByteBuffer _bb) { return GetRootAsBool(_bb, new Bool()); }
   public static Bool GetRootAsBool(ByteBuffer _bb, Bool obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Bool __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartBool(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartBool(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Bool> EndBool(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Bool>(o);
   }
-};
+}
+
 
+static internal class BoolVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
index e9b7fb3ccaea0..aef1db96db0f3 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Date.cs
@@ -6,10 +6,11 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// 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
@@ -18,27 +19,38 @@ internal struct Date : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Date GetRootAsDate(ByteBuffer _bb) { return GetRootAsDate(_bb, new Date()); }
   public static Date GetRootAsDate(ByteBuffer _bb, Date obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Date __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public DateUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (DateUnit)__p.bb.GetShort(o + __p.bb_pos) : DateUnit.MILLISECOND; } }
 
   public static Offset<Date> CreateDate(FlatBufferBuilder builder,
       DateUnit unit = DateUnit.MILLISECOND) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Date.AddUnit(builder, unit);
     return Date.EndDate(builder);
   }
 
-  public static void StartDate(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartDate(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, DateUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static Offset<Date> EndDate(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Date>(o);
   }
-};
+}
+
 
+static internal class DateVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*DateUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
index 97f62b6761b24..fd303786b1d55 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Decimal.cs
@@ -6,19 +6,21 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// 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
 /// in the Schema.
-internal struct Decimal: IFlatbufferObject
+internal struct Decimal : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Decimal GetRootAsDecimal(ByteBuffer _bb) { return GetRootAsDecimal(_bb, new Decimal()); }
   public static Decimal GetRootAsDecimal(ByteBuffer _bb, Decimal obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Decimal __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /// Total number of decimal digits
@@ -33,22 +35,34 @@ public static Offset<Decimal> CreateDecimal(FlatBufferBuilder builder,
       int precision = 0,
       int scale = 0,
       int bitWidth = 128) {
-    builder.StartObject(3);
+    builder.StartTable(3);
     Decimal.AddBitWidth(builder, bitWidth);
     Decimal.AddScale(builder, scale);
     Decimal.AddPrecision(builder, precision);
     return Decimal.EndDecimal(builder);
   }
 
-  public static void StartDecimal(FlatBufferBuilder builder) { builder.StartObject(3); }
+  public static void StartDecimal(FlatBufferBuilder builder) { builder.StartTable(3); }
   public static void AddPrecision(FlatBufferBuilder builder, int precision) { builder.AddInt(0, precision, 0); }
   public static void AddScale(FlatBufferBuilder builder, int scale) { builder.AddInt(1, scale, 0); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(2, bitWidth, 128); }
   public static Offset<Decimal> EndDecimal(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Decimal>(o);
   }
-};
+}
+
 
+static internal class DecimalVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Precision*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*Scale*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
index 1f3a9e4109586..28c2a510e5c1a 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Duration.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Duration : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Duration GetRootAsDuration(ByteBuffer _bb) { return GetRootAsDuration(_bb, new Duration()); }
   public static Duration GetRootAsDuration(ByteBuffer _bb, Duration obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Duration __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.MILLISECOND; } }
 
   public static Offset<Duration> CreateDuration(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.MILLISECOND) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Duration.AddUnit(builder, unit);
     return Duration.EndDuration(builder);
   }
 
-  public static void StartDuration(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartDuration(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static Offset<Duration> EndDuration(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Duration>(o);
   }
-};
+}
+
 
+static internal class DurationVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
index 0cb58ecf4efe6..611c130b2ebfb 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/FloatingPoint.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct FloatingPoint : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static FloatingPoint GetRootAsFloatingPoint(ByteBuffer _bb) { return GetRootAsFloatingPoint(_bb, new FloatingPoint()); }
   public static FloatingPoint GetRootAsFloatingPoint(ByteBuffer _bb, FloatingPoint obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public FloatingPoint __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public Precision Precision { get { int o = __p.__offset(4); return o != 0 ? (Precision)__p.bb.GetShort(o + __p.bb_pos) : Precision.HALF; } }
 
   public static Offset<FloatingPoint> CreateFloatingPoint(FlatBufferBuilder builder,
       Precision precision = Precision.HALF) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     FloatingPoint.AddPrecision(builder, precision);
     return FloatingPoint.EndFloatingPoint(builder);
   }
 
-  public static void StartFloatingPoint(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartFloatingPoint(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddPrecision(FlatBufferBuilder builder, Precision precision) { builder.AddShort(0, (short)precision, 0); }
   public static Offset<FloatingPoint> EndFloatingPoint(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<FloatingPoint>(o);
   }
-};
+}
+
 
+static internal class FloatingPointVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Precision*/, 2 /*Precision*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
index 754080279f584..d0cec48f44fe7 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Int.cs
@@ -6,15 +6,17 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Int : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Int GetRootAsInt(ByteBuffer _bb) { return GetRootAsInt(_bb, new Int()); }
   public static Int GetRootAsInt(ByteBuffer _bb, Int obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Int __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public int BitWidth { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
@@ -23,20 +25,31 @@ internal struct Int : IFlatbufferObject
   public static Offset<Int> CreateInt(FlatBufferBuilder builder,
       int bitWidth = 0,
       bool is_signed = false) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Int.AddBitWidth(builder, bitWidth);
     Int.AddIsSigned(builder, is_signed);
     return Int.EndInt(builder);
   }
 
-  public static void StartInt(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartInt(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(0, bitWidth, 0); }
   public static void AddIsSigned(FlatBufferBuilder builder, bool isSigned) { builder.AddBool(1, isSigned, false); }
   public static Offset<Int> EndInt(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Int>(o);
   }
-};
+}
+
 
+static internal class IntVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 6 /*IsSigned*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
index bb92448ac4383..7d31603e29166 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Interval.cs
@@ -6,33 +6,45 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct Interval : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Interval GetRootAsInterval(ByteBuffer _bb) { return GetRootAsInterval(_bb, new Interval()); }
   public static Interval GetRootAsInterval(ByteBuffer _bb, Interval obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Interval __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public IntervalUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (IntervalUnit)__p.bb.GetShort(o + __p.bb_pos) : IntervalUnit.YEAR_MONTH; } }
 
   public static Offset<Interval> CreateInterval(FlatBufferBuilder builder,
       IntervalUnit unit = IntervalUnit.YEAR_MONTH) {
-    builder.StartObject(1);
+    builder.StartTable(1);
     Interval.AddUnit(builder, unit);
     return Interval.EndInterval(builder);
   }
 
-  public static void StartInterval(FlatBufferBuilder builder) { builder.StartObject(1); }
+  public static void StartInterval(FlatBufferBuilder builder) { builder.StartTable(1); }
   public static void AddUnit(FlatBufferBuilder builder, IntervalUnit unit) { builder.AddShort(0, (short)unit, 0); }
   public static Offset<Interval> EndInterval(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Interval>(o);
   }
-};
+}
+
 
+static internal class IntervalVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*IntervalUnit*/, 2, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
index 8ac6aa2cd0328..bcc33842323fe 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeBinary.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as Binary, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeBinary : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeBinary GetRootAsLargeBinary(ByteBuffer _bb) { return GetRootAsLargeBinary(_bb, new LargeBinary()); }
   public static LargeBinary GetRootAsLargeBinary(ByteBuffer _bb, LargeBinary obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeBinary __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeBinary(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeBinary(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeBinary> EndLargeBinary(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeBinary>(o);
   }
-};
+}
+
 
+static internal class LargeBinaryVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
index 49e69a87f9adb..4bd09610ad1ef 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeList.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as List, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeList : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeList GetRootAsLargeList(ByteBuffer _bb) { return GetRootAsLargeList(_bb, new LargeList()); }
   public static LargeList GetRootAsLargeList(ByteBuffer _bb, LargeList obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeList __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeList(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeList(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeList> EndLargeList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeList>(o);
   }
-};
+}
+
 
+static internal class LargeListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
index ebb64390ff49c..21c8c9dd2b313 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/LargeUtf8.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Same as Utf8, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
@@ -14,18 +15,28 @@ internal struct LargeUtf8 : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static LargeUtf8 GetRootAsLargeUtf8(ByteBuffer _bb) { return GetRootAsLargeUtf8(_bb, new LargeUtf8()); }
   public static LargeUtf8 GetRootAsLargeUtf8(ByteBuffer _bb, LargeUtf8 obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public LargeUtf8 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartLargeUtf8(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartLargeUtf8(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<LargeUtf8> EndLargeUtf8(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<LargeUtf8>(o);
   }
-};
+}
+
 
+static internal class LargeUtf8Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
index 8f4985bb53801..37ffee6d88da9 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/List.cs
@@ -6,24 +6,35 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 internal struct List : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static List GetRootAsList(ByteBuffer _bb) { return GetRootAsList(_bb, new List()); }
   public static List GetRootAsList(ByteBuffer _bb, List obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public List __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartList(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartList(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<List> EndList(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<List>(o);
   }
-};
+}
+
 
+static internal class ListVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
index 85fa5bb99199f..82902f35aef25 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Null.cs
@@ -6,25 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// These are stored in the flatbuffer in the Type union below
 internal struct Null : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Null GetRootAsNull(ByteBuffer _bb) { return GetRootAsNull(_bb, new Null()); }
   public static Null GetRootAsNull(ByteBuffer _bb, Null obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Null __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartNull(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartNull(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Null> EndNull(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Null>(o);
   }
-};
+}
+
 
+static internal class NullVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
index 8f3d708cd9a05..a8f29e35b3898 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Struct_.cs
@@ -6,7 +6,8 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
 /// (according to the physical memory layout). We used Struct_ here as
@@ -15,18 +16,28 @@ internal struct Struct_ : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Struct_ GetRootAsStruct_(ByteBuffer _bb) { return GetRootAsStruct_(_bb, new Struct_()); }
   public static Struct_ GetRootAsStruct_(ByteBuffer _bb, Struct_ obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Struct_ __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartStruct_(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartStruct_(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Struct_> EndStruct_(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Struct_>(o);
   }
-};
+}
+
 
+static internal class Struct_Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
index 1d7c0881cca42..4cb330238f4c5 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Time.cs
@@ -6,18 +6,31 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// 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).
 internal struct Time : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Time GetRootAsTime(ByteBuffer _bb) { return GetRootAsTime(_bb, new Time()); }
   public static Time GetRootAsTime(ByteBuffer _bb, Time obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Time __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.MILLISECOND; } }
@@ -26,20 +39,31 @@ internal struct Time : IFlatbufferObject
   public static Offset<Time> CreateTime(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.MILLISECOND,
       int bitWidth = 32) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Time.AddBitWidth(builder, bitWidth);
     Time.AddUnit(builder, unit);
     return Time.EndTime(builder);
   }
 
-  public static void StartTime(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTime(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 1); }
   public static void AddBitWidth(FlatBufferBuilder builder, int bitWidth) { builder.AddInt(1, bitWidth, 32); }
   public static Offset<Time> EndTime(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Time>(o);
   }
-};
+}
+
 
+static internal class TimeVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyField(tablePos, 6 /*BitWidth*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
index c0168b4cbf84f..93620ea577899 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Timestamp.cs
@@ -6,47 +6,138 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
-/// 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.
 ///
-/// The Timestamp metadata supports both "time zone naive" and "time zone
-/// aware" timestamps. Read about the timezone attribute for more detail
+/// 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.
+///
+/// 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.
 internal struct Timestamp : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Timestamp GetRootAsTimestamp(ByteBuffer _bb) { return GetRootAsTimestamp(_bb, new Timestamp()); }
   public static Timestamp GetRootAsTimestamp(ByteBuffer _bb, Timestamp obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Timestamp __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public TimeUnit Unit { get { int o = __p.__offset(4); return o != 0 ? (TimeUnit)__p.bb.GetShort(o + __p.bb_pos) : TimeUnit.SECOND; } }
-  /// 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).
   public string Timezone { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetTimezoneBytes() { return __p.__vector_as_span(6); }
+  public Span<byte> GetTimezoneBytes() { return __p.__vector_as_span<byte>(6, 1); }
 #else
   public ArraySegment<byte>? GetTimezoneBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -55,20 +146,31 @@ internal struct Timestamp : IFlatbufferObject
   public static Offset<Timestamp> CreateTimestamp(FlatBufferBuilder builder,
       TimeUnit unit = TimeUnit.SECOND,
       StringOffset timezoneOffset = default(StringOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Timestamp.AddTimezone(builder, timezoneOffset);
     Timestamp.AddUnit(builder, unit);
     return Timestamp.EndTimestamp(builder);
   }
 
-  public static void StartTimestamp(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartTimestamp(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddUnit(FlatBufferBuilder builder, TimeUnit unit) { builder.AddShort(0, (short)unit, 0); }
   public static void AddTimezone(FlatBufferBuilder builder, StringOffset timezoneOffset) { builder.AddOffset(1, timezoneOffset.Value, 0); }
   public static Offset<Timestamp> EndTimestamp(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Timestamp>(o);
   }
-};
+}
+
 
+static internal class TimestampVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Unit*/, 2 /*TimeUnit*/, 2, false)
+      && verifier.VerifyString(tablePos, 6 /*Timezone*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
index de2a85a17de0a..9657071efa686 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Union.cs
@@ -6,26 +6,28 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// A union is a complex type with children in Field
 /// By default ids in the type vector refer to the offsets in the children
 /// optionally typeIds provides an indirection between the child offset and the type id
-/// for each child typeIds[offset] is the id used in the type vector
+/// for each child `typeIds[offset]` is the id used in the type vector
 internal struct Union : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Union GetRootAsUnion(ByteBuffer _bb) { return GetRootAsUnion(_bb, new Union()); }
   public static Union GetRootAsUnion(ByteBuffer _bb, Union obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Union __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public UnionMode Mode { get { int o = __p.__offset(4); return o != 0 ? (UnionMode)__p.bb.GetShort(o + __p.bb_pos) : UnionMode.Sparse; } }
   public int TypeIds(int j) { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
   public int TypeIdsLength { get { int o = __p.__offset(6); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetTypeIdsBytes() { return __p.__vector_as_span(6); }
+  public Span<int> GetTypeIdsBytes() { return __p.__vector_as_span<int>(6, 4); }
 #else
   public ArraySegment<byte>? GetTypeIdsBytes() { return __p.__vector_as_arraysegment(6); }
 #endif
@@ -34,23 +36,36 @@ internal struct Union : IFlatbufferObject
   public static Offset<Union> CreateUnion(FlatBufferBuilder builder,
       UnionMode mode = UnionMode.Sparse,
       VectorOffset typeIdsOffset = default(VectorOffset)) {
-    builder.StartObject(2);
+    builder.StartTable(2);
     Union.AddTypeIds(builder, typeIdsOffset);
     Union.AddMode(builder, mode);
     return Union.EndUnion(builder);
   }
 
-  public static void StartUnion(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void StartUnion(FlatBufferBuilder builder) { builder.StartTable(2); }
   public static void AddMode(FlatBufferBuilder builder, UnionMode mode) { builder.AddShort(0, (short)mode, 0); }
   public static void AddTypeIds(FlatBufferBuilder builder, VectorOffset typeIdsOffset) { builder.AddOffset(1, typeIdsOffset.Value, 0); }
   public static VectorOffset CreateTypeIdsVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateTypeIdsVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartTypeIdsVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<Union> EndUnion(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Union>(o);
   }
-};
+}
+
 
+static internal class UnionVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*Mode*/, 2 /*UnionMode*/, 2, false)
+      && verifier.VerifyVectorOfData(tablePos, 6 /*TypeIds*/, 4 /*int*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs b/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
index e2b80f4070c93..23c0fb4aa8669 100644
--- a/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
+++ b/csharp/src/Apache.Arrow/Flatbuf/Types/Utf8.cs
@@ -6,25 +6,36 @@ namespace Apache.Arrow.Flatbuf
 {
 
 using global::System;
-using global::FlatBuffers;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
 
 /// Unicode with UTF-8 encoding
 internal struct Utf8 : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_9(); }
   public static Utf8 GetRootAsUtf8(ByteBuffer _bb) { return GetRootAsUtf8(_bb, new Utf8()); }
   public static Utf8 GetRootAsUtf8(ByteBuffer _bb, Utf8 obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
   public Utf8 __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
 
-  public static void StartUtf8(FlatBufferBuilder builder) { builder.StartObject(0); }
+  public static void StartUtf8(FlatBufferBuilder builder) { builder.StartTable(0); }
   public static Offset<Utf8> EndUtf8(FlatBufferBuilder builder) {
-    int o = builder.EndObject();
+    int o = builder.EndTable();
     return new Offset<Utf8>(o);
   }
-};
+}
+
 
+static internal class Utf8Verify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
 
 }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
index 3d81715036e40..4fefb121cb669 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowFileWriter.cs
@@ -144,7 +144,7 @@ private void WriteFooter(Schema schema)
 
             // Serialize the schema
 
-            FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
+            Google.FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
 
             // Serialize all record batches
 
@@ -158,18 +158,18 @@ private void WriteFooter(Schema schema)
                     Builder, recordBatch.Offset, recordBatch.MetadataLength, recordBatch.BodyLength);
             }
 
-            FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
 
             // Serialize all dictionaries
             // NOTE: Currently unsupported.
 
             Flatbuf.Footer.StartDictionariesVector(Builder, 0);
 
-            FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
 
             // Serialize and write the footer flatbuffer
 
-            FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
+            Google.FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
                 schemaOffset, dictionaryBatchesOffset, recordBatchesVectorOffset);
 
             Builder.Finish(footerOffset.Value);
@@ -204,7 +204,7 @@ private async Task WriteFooterAsync(Schema schema, CancellationToken cancellatio
 
             // Serialize the schema
 
-            FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
+            Google.FlatBuffers.Offset<Flatbuf.Schema> schemaOffset = SerializeSchema(schema);
 
             // Serialize all record batches
 
@@ -218,18 +218,18 @@ private async Task WriteFooterAsync(Schema schema, CancellationToken cancellatio
                     Builder, recordBatch.Offset, recordBatch.MetadataLength, recordBatch.BodyLength);
             }
 
-            FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset recordBatchesVectorOffset = Builder.EndVector();
 
             // Serialize all dictionaries
             // NOTE: Currently unsupported.
 
             Flatbuf.Footer.StartDictionariesVector(Builder, 0);
 
-            FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
+            Google.FlatBuffers.VectorOffset dictionaryBatchesOffset = Builder.EndVector();
 
             // Serialize and write the footer flatbuffer
 
-            FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
+            Google.FlatBuffers.Offset<Flatbuf.Footer> footerOffset = Flatbuf.Footer.CreateFooter(Builder, CurrentMetadataVersion,
                 schemaOffset, dictionaryBatchesOffset, recordBatchesVectorOffset);
 
             Builder.Finish(footerOffset.Value);
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
index ce546d422e9b2..af4f963ee520f 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowMemoryReaderImplementation.cs
@@ -14,7 +14,7 @@
 // limitations under the License.
 
 using Apache.Arrow.Flatbuf;
-using FlatBuffers;
+using Google.FlatBuffers;
 using System;
 using System.Buffers.Binary;
 using System.IO;
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
index ed93000736e0b..62616962077b6 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
@@ -13,7 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using FlatBuffers;
 using System;
 using System.Buffers;
 using System.Collections.Generic;
@@ -24,6 +23,7 @@
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Types;
 using Apache.Arrow.Memory;
+using Google.FlatBuffers;
 using Type = System.Type;
 
 namespace Apache.Arrow.Ipc
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
index 8ae8fc49ca5ee..df80ffe1e0fa5 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamReaderImplementation.cs
@@ -86,7 +86,7 @@ await ArrayPool<byte>.Shared.RentReturnAsync(messageLength, async (messageBuff)
                         .ConfigureAwait(false);
                     EnsureFullRead(bodyBuff, bytesRead);
 
-                    FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
+                    Google.FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
                     result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
                 }).ConfigureAwait(false);
             }
@@ -124,7 +124,7 @@ protected RecordBatch ReadRecordBatch()
                     bytesRead = BaseStream.ReadFullBuffer(bodyBuff);
                     EnsureFullRead(bodyBuff, bytesRead);
 
-                    FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
+                    Google.FlatBuffers.ByteBuffer bodybb = CreateByteBuffer(bodyBuff);
                     result = CreateArrowObjectFromMessage(message, bodybb, bodyBuffOwner);
                 });
             }
@@ -149,7 +149,7 @@ await ArrayPool<byte>.Shared.RentReturnAsync(schemaMessageLength, async (buff) =
                 int bytesRead = await BaseStream.ReadFullBufferAsync(buff).ConfigureAwait(false);
                 EnsureFullRead(buff, bytesRead);
 
-                FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
+                Google.FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
                 Schema = MessageSerializer.GetSchema(ReadMessage<Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
             }).ConfigureAwait(false);
         }
@@ -169,7 +169,7 @@ protected virtual void ReadSchema()
                 int bytesRead = BaseStream.ReadFullBuffer(buff);
                 EnsureFullRead(buff, bytesRead);
 
-                FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
+                Google.FlatBuffers.ByteBuffer schemabb = CreateByteBuffer(buff);
                 Schema = MessageSerializer.GetSchema(ReadMessage<Flatbuf.Schema>(schemabb), ref _dictionaryMemo);
             });
         }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
index 5ffda3dfba6f5..ca567b67e95d1 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
@@ -23,7 +23,7 @@
 using System.Threading.Tasks;
 using Apache.Arrow.Arrays;
 using Apache.Arrow.Types;
-using FlatBuffers;
+using Google.FlatBuffers;
 
 namespace Apache.Arrow.Ipc
 {
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index 400937669e309..befd87c2e0ae0 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -16,7 +16,7 @@
 using System;
 using Apache.Arrow.Flatbuf;
 using Apache.Arrow.Types;
-using FlatBuffers;
+using Google.FlatBuffers;
 using DateUnit = Apache.Arrow.Flatbuf.DateUnit;
 using TimeUnit = Apache.Arrow.Types.TimeUnit;
 
diff --git a/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs b/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
index 7e78fcf9ec994..0f968739c56e6 100644
--- a/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ReadOnlyMemoryBufferAllocator.cs
@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using FlatBuffers;
+using Google.FlatBuffers;
 using System;
 
 namespace Apache.Arrow.Ipc

From d0c18a6cc69c4dd9d8bc380df292deffff1e8107 Mon Sep 17 00:00:00 2001
From: Weston Pace <weston.pace@gmail.com>
Date: Wed, 16 Aug 2023 13:50:18 -0700
Subject: [PATCH 179/749] GH-37213: [C#] Updating a reference to FlatBuffers
 missed due to rebase/merge conflict (#37214)

### Rationale for this change

The build was broken

### What changes are included in this PR?

Updated a newly introduced reference to `using FlatBuffers` to be `using Google.FlatBuffers`

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #37213

Authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 csharp/src/Apache.Arrow/Arrays/ArrayData.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayData.cs b/csharp/src/Apache.Arrow/Arrays/ArrayData.cs
index de71a33239805..55d77f598c4e4 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayData.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayData.cs
@@ -15,7 +15,7 @@
 
 using Apache.Arrow.Memory;
 using Apache.Arrow.Types;
-using FlatBuffers;
+using Google.FlatBuffers;
 using System;
 using System.Collections.Generic;
 using System.Linq;

From 4680ca5b20701aadece579510700cef386e6269d Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 16 Aug 2023 20:28:08 -0400
Subject: [PATCH 180/749] GH-37209: [CI][Docs][MATLAB] Remove support for
 `MATLAB_ARROW_INTERFACE` flag from CMake build system and build new MATLAB
 Interface code by default (#37211)

### Rationale for this change

Now that the old Feather V1 code and associated build infrastructure has been removed (#37204), it makes sense to start building the new, experimental MATLAB Interface code by default (without needing to [explicitly specify `-D MATLAB_ARROW_INTERFACE=ON`](https://github.com/apache/arrow/tree/main/matlab#build)).

This pull request removes the `MATLAB_ARROW_INTERFACE` flag entirely, since setting it to `OFF` when we are building the MATLAB Interface code by default would essentially imply that no code should be built.

### What changes are included in this PR?

1. Removed mention of `MATLAB_ARROW_INTERFACE` flag from MATLAB `README.md`.
2. Removed conditional check for `MATLAB_ARROW_INTERFACE` flag from MATLAB `CMakeLists.txt`.
3. Removed `MATLAB_ARROW_INTERFACE` flag from `matlab_build.sh` CI script.

### Are these changes tested?

Yes.

The MATLAB Interface is building as expected by default on my Debian 11 machine.

### Are there any user-facing changes?

Yes.

1. The experimental MATLAB Interface APIs will now be built by default without users explicitly specifying `-D MATLAB_ARROW_INTERFACE=ON` to `cmake`.
2. If users specify a value for `MATLAB_ARROW_INTERFACE`, the value will be ignored by the CMake build system.
* Closes: #37209

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/matlab_build.sh | 1 -
 matlab/CMakeLists.txt      | 5 ++---
 matlab/README.md           | 6 ++----
 3 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/ci/scripts/matlab_build.sh b/ci/scripts/matlab_build.sh
index 4acd4d3b82a50..235002da3afc6 100755
--- a/ci/scripts/matlab_build.sh
+++ b/ci/scripts/matlab_build.sh
@@ -29,7 +29,6 @@ cmake \
   -S ${source_dir} \
   -B ${build_dir} \
   -G Ninja \
-  -D MATLAB_ARROW_INTERFACE=ON \
   -D MATLAB_BUILD_TESTS=ON \
   -D CMAKE_INSTALL_PREFIX=${install_dir} \
   -D MATLAB_ADD_INSTALL_DIR_TO_SEARCH_PATH=OFF
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index c7be74de8a951..5380e4cbe1b60 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -379,9 +379,8 @@ endif()
 # Create a subdirectory at CMAKE_INSTALL_PREFIX to install the interface.
 set(CMAKE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/arrow_matlab")
 
-if(MATLAB_ARROW_INTERFACE)
-  include(BuildMatlabArrowInterface)
-endif()
+# Build the MATLAB Interface to Arrow.
+include(BuildMatlabArrowInterface)
 
 # Install MATLAB source files.
 # On macOS, exclude '.DS_Store' files in the source tree from installation.
diff --git a/matlab/README.md b/matlab/README.md
index 13b27274d8b7d..1e8565ece4e8c 100644
--- a/matlab/README.md
+++ b/matlab/README.md
@@ -76,12 +76,10 @@ $ cd arrow/matlab
 To build the MATLAB interface, use [CMake](https://cmake.org/cmake/help/latest/):
 
 ```console
-$ cmake -S . -B build -D MATLAB_ARROW_INTERFACE=ON
+$ cmake -S . -B build
 $ cmake --build build --config Release
 ```
 
-**NOTE:** To build the experimental MATLAB interface code, `-D MATLAB_ARROW_INTERFACE=ON` must be specified as shown above.
-
 ## Install
 
 To install the MATLAB interface to the default software installation location for the target machine (e.g. `/usr/local` on Linux or `C:\Program Files` on Windows), pass the `--target install` flag to CMake.
@@ -111,7 +109,7 @@ To run the MATLAB tests, start MATLAB in the `arrow/matlab` directory and call t
 To enable the C++ tests, set the `MATLAB_BUILD_TESTS` flag to `ON` at build time: 
 
 ```console
-$ cmake -S . -B build -D MATLAB_ARROW_INTERFACE=ON -D MATLAB_BUILD_TESTS=ON
+$ cmake -S . -B build -D MATLAB_BUILD_TESTS=ON
 $ cmake --build build --config Release
 ```
 

From 4fc2731a3ceaf7dd5b1dce6f29bf7cad0ab2f13e Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 17 Aug 2023 10:10:36 +0900
Subject: [PATCH 181/749] GH-37144: [C++] Add
 RecordBatchFileReader::To{RecordBatches,Table} (#37167)

### Rationale for this change

`RecordBatchReader` has them but `RecordBatchFileReader` doesn't. They are convenient.

### What changes are included in this PR?

Add them.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37144

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/ipc/read_write_test.cc | 28 +++++++++++++++++++++++-----
 cpp/src/arrow/ipc/reader.cc          | 16 ++++++++++++++++
 cpp/src/arrow/ipc/reader.h           |  6 ++++++
 cpp/src/arrow/table.h                |  2 +-
 4 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index ae5fde39d8550..6b4f70763708c 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -1184,6 +1184,13 @@ struct FileWriterHelper {
     return reader->metadata();
   }
 
+  Result<std::shared_ptr<Table>> ReadAll() {
+    auto buf_reader = std::make_shared<io::BufferReader>(buffer_);
+    ARROW_ASSIGN_OR_RAISE(auto reader,
+                          RecordBatchFileReader::Open(buf_reader.get(), footer_offset_));
+    return reader->ToTable();
+  }
+
   std::shared_ptr<ResizableBuffer> buffer_;
   std::unique_ptr<io::BufferOutputStream> sink_;
   std::shared_ptr<RecordBatchWriter> writer_;
@@ -1875,6 +1882,21 @@ TEST(TestIpcFileFormat, FooterMetaData) {
   ASSERT_TRUE(out_metadata->Equals(*metadata));
 }
 
+TEST(TestIpcFileFormat, ReaderToTable) {
+  std::shared_ptr<RecordBatch> batch;
+  ASSERT_OK(MakeIntRecordBatch(&batch));
+
+  FileWriterHelper helper;
+  ASSERT_OK(helper.Init(batch->schema(), IpcWriteOptions::Defaults()));
+  ASSERT_OK(helper.WriteBatch(batch));
+  ASSERT_OK(helper.WriteBatch(batch));
+  ASSERT_OK(helper.Finish());
+
+  ASSERT_OK_AND_ASSIGN(auto out_table, helper.ReadAll());
+  ASSERT_OK_AND_ASSIGN(auto expected_table, Table::FromRecordBatches({batch, batch}));
+  ASSERT_TABLES_EQUAL(*expected_table, *out_table);
+}
+
 TEST_F(TestWriteRecordBatch, RawAndSerializedSizes) {
   // ARROW-8823: Recording total raw and serialized record batch sizes in WriteStats
   FileWriterHelper helper;
@@ -3012,11 +3034,7 @@ class PreBufferingTest : public ::testing::TestWithParam<bool> {
     auto read_options = IpcReadOptions::Defaults();
     EXPECT_OK_AND_ASSIGN(auto reader,
                          RecordBatchFileReader::Open(buffer_reader.get(), read_options));
-    std::vector<std::shared_ptr<RecordBatch>> expected_batches;
-    for (int i = 0; i < reader->num_record_batches(); i++) {
-      EXPECT_OK_AND_ASSIGN(auto expected_batch, reader->ReadRecordBatch(i));
-      expected_batches.push_back(expected_batch);
-    }
+    EXPECT_OK_AND_ASSIGN(auto expected_batches, reader->ToRecordBatches());
     return expected_batches;
   }
 
diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index 125a8f2d4158c..0def0e036e3c1 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -44,6 +44,7 @@
 #include "arrow/record_batch.h"
 #include "arrow/sparse_tensor.h"
 #include "arrow/status.h"
+#include "arrow/table.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
@@ -1865,6 +1866,21 @@ Future<std::shared_ptr<RecordBatchFileReader>> RecordBatchFileReader::OpenAsync(
       .Then([=]() -> Result<std::shared_ptr<RecordBatchFileReader>> { return result; });
 }
 
+Result<RecordBatchVector> RecordBatchFileReader::ToRecordBatches() {
+  RecordBatchVector batches;
+  const auto n = num_record_batches();
+  for (int i = 0; i < n; ++i) {
+    ARROW_ASSIGN_OR_RAISE(auto batch, ReadRecordBatch(i));
+    batches.emplace_back(std::move(batch));
+  }
+  return batches;
+}
+
+Result<std::shared_ptr<Table>> RecordBatchFileReader::ToTable() {
+  ARROW_ASSIGN_OR_RAISE(auto batches, ToRecordBatches());
+  return Table::FromRecordBatches(schema(), std::move(batches));
+}
+
 Future<SelectiveIpcFileRecordBatchGenerator::Item>
 SelectiveIpcFileRecordBatchGenerator::operator()() {
   int index = index_++;
diff --git a/cpp/src/arrow/ipc/reader.h b/cpp/src/arrow/ipc/reader.h
index 1698abd14b48f..9440fcaba92d6 100644
--- a/cpp/src/arrow/ipc/reader.h
+++ b/cpp/src/arrow/ipc/reader.h
@@ -229,6 +229,12 @@ class ARROW_EXPORT RecordBatchFileReader
       const io::IOContext& io_context = io::default_io_context(),
       const io::CacheOptions cache_options = io::CacheOptions::LazyDefaults(),
       arrow::internal::Executor* executor = NULLPTR) = 0;
+
+  /// \brief Collect all batches as a vector of record batches
+  Result<RecordBatchVector> ToRecordBatches();
+
+  /// \brief Collect all batches and concatenate as arrow::Table
+  Result<std::shared_ptr<Table>> ToTable();
 };
 
 /// \brief A general listener class to receive events.
diff --git a/cpp/src/arrow/table.h b/cpp/src/arrow/table.h
index 2171f3331add4..940ff73ae983f 100644
--- a/cpp/src/arrow/table.h
+++ b/cpp/src/arrow/table.h
@@ -75,7 +75,7 @@ class ARROW_EXPORT Table {
 
   /// \brief Construct a Table from a RecordBatchReader.
   ///
-  /// \param[in] reader the arrow::Schema for each batch
+  /// \param[in] reader the arrow::RecordBatchReader that produces batches
   static Result<std::shared_ptr<Table>> FromRecordBatchReader(RecordBatchReader* reader);
 
   /// \brief Construct a Table from RecordBatches, using schema supplied by the first

From 7d8e4b125bae46363fe6af3709166b74cfec3cf7 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Thu, 17 Aug 2023 11:11:06 -0400
Subject: [PATCH 182/749] GH-37210: [Docs][MATLAB] Update MATLAB `README.md` to
 mention support for new MATLAB APIs (e.g. `RecordBatch`, `Field`, `Schema`,
 etc.) (#37215)

### Rationale for this change

Over the last few months, a number of new user-facing APIs have been added or changed in the MATLAB Interface.

## Examples:

### Construction Functions

- `arrow.array`
- `arrow.field`
- `arrow.schema`
- `arrow.recordbatch`
- `arrow.boolean`, `arrow.string`, `arrow.timestamp`, etc. (type construction functions)

### Classes

- `arrow.type.Field`
- `arrow.tabular.Schema`
- `arrow.tabular.RecordBatch`
- `arrow.array.StringArray`
- `arrow.array.TimestampArray`

### Indexing Methods

- `arrow.tabular.Schema.field(i)`
- `arrow.tabular.RecordBatch.column(i)`

### Static Construction Methods

- `arrow.tabular.RecordBatch.fromArrays(a1, ..., aN)`
- `arrow.array.StringArray.fromMATLAB(a)`

---

This pull request updates the [`README.md` for the MATLAB Interface](https://github.com/apache/arrow/blob/main/matlab/README.md) to reflect these changes.

### What changes are included in this PR?

Updated MATLAB `README.md`:

1. Updated **Status** section to mention support for new Arrow types and functionality.
2. Added usage examples for `Type, `Field`, `Schema`, and `RecordBatch`.
3. Updated Feather v1 usage examples to illustrate support for types like `String` and `Boolean`.

### Are these changes tested?

N/A.

This is purely a documentation change. I manually reviewed the visual rendering of the `README.md` Markdown on GitHub.

### Are there any user-facing changes?

Yes.

1. The MATLAB `README.md` now includes more usage examples which illustrate how to use the MATLAB interface.

### Future Directions

1. Add comprehensive documentation for all classes and methods, including supported input argument types and name-value pairs.
2. Add more detailed information on future development plans and development status to the `README.md`.
3. Add a table of contents to the MATLAB `README.md`.
4. Keep the `README.md` up to date more proactively.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
2. My apologies in advance if this is too much documentation content to review at once. We will focus on being more incremental about keeping the MATLAB documentation up to date in the future.
3. #37211 also involves updating the MATLAB `README.md`, so there is a chance we may need to rebase before merging these changes in.
* Closes: #37210

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Kevin Gurney <kevin.p.gurney@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/README.md | 432 +++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 417 insertions(+), 15 deletions(-)

diff --git a/matlab/README.md b/matlab/README.md
index 1e8565ece4e8c..a070984a9e38f 100644
--- a/matlab/README.md
+++ b/matlab/README.md
@@ -27,17 +27,17 @@ This is a very early stage MATLAB interface to the Apache Arrow C++ libraries.
 
 Currently, the MATLAB interface supports:
 
-1. Creating a subset of Arrow `Array` types (e.g. numeric and boolean) from MATLAB data
-2. Reading and writing numeric types from/to Feather v1 files.
+1. Converting between a subset of Arrow `Array` types and MATLAB array types (see table below)
+2. Converting between MATLAB `table`s and `arrow.tabular.RecordBatch`s
+3. Creating Arrow `Field`s, `Schema`s, and `Type`s
+4. Reading and writing Feather V1 files
 
 Supported `arrow.array.Array` types are included in the table below.
 
-**NOTE**: All Arrow `Array` classes are part of the `arrow.array` package (e.g. `arrow.array.Float64Array`).
+**NOTE**: All Arrow `Array` classes listed below are part of the `arrow.array` package (e.g. `arrow.array.Float64Array`).
 
 | MATLAB Array Type | Arrow Array Type |
 | ----------------- | ---------------- |
-| `single`          | `Float32Array`   |
-| `double`          | `Float64Array`   |
 | `uint8`           | `UInt8Array`     |
 | `uint16`          | `UInt16Array`    |
 | `uint32`          | `UInt32Array`    |
@@ -46,7 +46,11 @@ Supported `arrow.array.Array` types are included in the table below.
 | `int16`           | `Int16Array`     |
 | `int32`           | `Int32Array`     |
 | `int64`           | `Int64Array`     |
+| `single`          | `Float32Array`   |
+| `double`          | `Float64Array`   |
 | `logical`         | `BooleanArray`   |
+| `string`          | `StringArray`    |
+| `datetime`        | `TimestampArray` |
 
 ## Prerequisites
 
@@ -134,7 +138,7 @@ matlabArray =
 
      1     2     3
 
->> arrowArray = arrow.array.Float64Array(matlabArray)
+>> arrowArray = arrow.array(matlabArray)
 
 arrowArray = 
 
@@ -148,7 +152,7 @@ arrowArray =
 #### Create a MATLAB `logical` array from an Arrow `BooleanArray`
 
 ```matlab
->> arrowArray = arrow.array.BooleanArray([true, false, true])
+>> arrowArray = arrow.array([true, false, true])
 
 arrowArray = 
 
@@ -190,7 +194,7 @@ validElements =
    1   0   1   0   1
 
 % Specify which values are Null/Valid by supplying a logical validity "mask"
->> arrowArray = arrow.array.Int8Array(matlabArray, Valid=validElements)
+>> arrowArray = arrow.array(matlabArray, Valid=validElements)
 
 arrowArray = 
 
@@ -203,20 +207,418 @@ arrowArray =
 ]
 ```
 
+### Arrow `RecordBatch` class
+
+#### Create an Arrow `RecordBatch` from a MATLAB `table`
+
+```matlab
+>> matlabTable = table(["A"; "B"; "C"], [1; 2; 3], [true; false; true])
+
+matlabTable =
+
+  3x3 table
+
+    Var1    Var2    Var3
+    ____    ____    _____
+
+    "A"      1      true
+    "B"      2      false
+    "C"      3      true
+
+>> arrowRecordBatch = arrow.recordbatch(matlabTable)
+
+arrowRecordBatch =
+
+Var1:   [
+    "A",
+    "B",
+    "C"
+  ]
+Var2:   [
+    1,
+    2,
+    3
+  ]
+Var3:   [
+    true,
+    false,
+    true
+  ]
+```
+
+#### Create a MATLAB `table` from an Arrow `RecordBatch`
+
+```matlab
+>> arrowRecordBatch
+
+arrowRecordBatch =
+
+Var1:   [
+    "A",
+    "B",
+    "C"
+  ]
+Var2:   [
+    1,
+    2,
+    3
+  ]
+Var3:   [
+    true,
+    false,
+    true
+  ]
+
+>> matlabTable = table(arrowRecordBatch)
+
+matlabTable =
+
+  3x3 table
+
+    Var1    Var2    Var3
+    ____    ____    _____
+
+    "A"      1      true
+    "B"      2      false
+    "C"      3      true
+```
+
+#### Create an Arrow `RecordBatch` from multiple Arrow `Array`s
+
+
+```matlab
+>> stringArray = arrow.array(["A", "B", "C"])
+
+stringArray =
+
+[
+  "A",
+  "B",
+  "C"
+]
+
+>> timestampArray = arrow.array([datetime(1997, 01, 01), datetime(1998, 01, 01), datetime(1999, 01, 01)])
+
+timestampArray =
+
+[
+  1997-01-01 00:00:00.000000,
+  1998-01-01 00:00:00.000000,
+  1999-01-01 00:00:00.000000
+]
+
+>> booleanArray = arrow.array([true, false, true])
+
+booleanArray =
+
+[
+  true,
+  false,
+  true
+]
+
+>> arrowRecordBatch = arrow.tabular.RecordBatch.fromArrays(stringArray, timestampArray, booleanArray)
+
+arrowRecordBatch =
+
+Column1:   [
+    "A",
+    "B",
+    "C"
+  ]
+Column2:   [
+    1997-01-01 00:00:00.000000,
+    1998-01-01 00:00:00.000000,
+    1999-01-01 00:00:00.000000
+  ]
+Column3:   [
+    true,
+    false,
+    true
+  ]
+```
+
+#### Extract a column from a `RecordBatch` by index
+
+```matlab
+>> arrowRecordBatch = arrow.tabular.RecordBatch.fromArrays(stringArray, timestampArray, booleanArray)
+
+arrowRecordBatch =
+
+Column1:   [
+    "A",
+    "B",
+    "C"
+  ]
+Column2:   [
+    1997-01-01 00:00:00.000000,
+    1998-01-01 00:00:00.000000,
+    1999-01-01 00:00:00.000000
+  ]
+Column3:   [
+    true,
+    false,
+    true
+  ]
+
+>> timestampArray = arrowRecordBatch.column(2)
+
+timestampArray =
+
+[
+  1997-01-01 00:00:00.000000,
+  1998-01-01 00:00:00.000000,
+  1999-01-01 00:00:00.000000
+]
+```
+
+### Arrow `Type` classes (i.e. `arrow.type.<Type>`)
+
+#### Create an Arrow `Int8Type` object
+
+```matlab
+>> type = arrow.int8()
+
+type =
+
+  Int8Type with properties:
+
+    ID: Int8
+```
+
+#### Create an Arrow `TimestampType` object with a specific `TimeUnit` and `TimeZone`
+
+```matlab
+>> type = arrow.timestamp(TimeUnit="Second", TimeZone="Asia/Kolkata")
+
+type =
+
+  TimestampType with properties:
+
+          ID: Timestamp
+    TimeUnit: Second
+    TimeZone: "Asia/Kolkata"
+```
+
+
+#### Get the type enumeration `ID` for an Arrow `Type` object
+
+```matlab
+>> type.ID
+
+ans =
+
+  ID enumeration
+
+    Timestamp
+
+>> type = arrow.string()
+
+type =
+
+  StringType with properties:
+
+    ID: String
+
+>> type.ID
+
+ans =
+
+  ID enumeration
+
+    String
+```
+
+### Arrow `Field` class
+
+#### Create an Arrow `Field` with type `Int8Type`
+
+```matlab
+>> field = arrow.field("Number", arrow.int8())
+
+field =
+
+Number: int8
+
+>> field.Name
+
+ans =
+
+    "Number"
+
+>> field.Type
+
+ans =
+
+  Int8Type with properties:
+
+    ID: Int8
+
+```
+
+#### Create an Arrow `Field` with type `StringType`
+
+```matlab
+>> field = arrow.field("Letter", arrow.string())
+
+field =
+
+Letter: string
+
+>> field.Name
+
+ans =
+
+    "Letter"
+
+>> field.Type
+
+ans =
+
+  StringType with properties:
+
+    ID: String
+```
+
+#### Extract an Arrow `Field` from an Arrow `Schema` by index
+
+```matlab
+>> arrowSchema
+
+arrowSchema =
+
+Letter: string
+Number: double
+
+% Specify the field to extract by its index (i.e. 2)
+>> field = arrowSchema.field(2)
+
+field =
+
+Number: double
+```
+
+#### Extract an Arrow `Field` from an Arrow `Schema` by name
+
+```matlab
+>> arrowSchema
+
+arrowSchema =
+
+Letter: string
+Number: double
+
+% Specify the field to extract by its name (i.e. "Letter")
+>> field = arrowSchema.field("Letter")
+
+field =
+
+Letter: string
+```
+
+### Arrow `Schema` class
+
+#### Create an Arrow `Schema` from multiple Arrow `Field`s
+
+```matlab
+>> letter = arrow.field("Letter", arrow.string())
+
+letter =
+
+Letter: string
+
+>> number = arrow.field("Number", arrow.int8())
+
+number =
+
+Number: int8
+
+>> schema = arrow.schema([letter, number])
+
+schema =
+
+Letter: string
+Number: int8
+```
+
+#### Get the `Schema` of an Arrow `RecordBatch`
+
+```matlab
+>> matlabTable = table(["A"; "B"; "C"], [1; 2; 3], VariableNames=["Letter", "Number"])
+
+matlabTable =
+
+  3x2 table
+
+    Letter    Number
+    ______    ______
+
+     "A"        1
+     "B"        2
+     "C"        3
+
+>> arrowRecordBatch = arrow.recordbatch(matlabTable)
+
+arrowRecordBatch =
+
+Letter:   [
+    "A",
+    "B",
+    "C"
+  ]
+Number:   [
+    1,
+    2,
+    3
+  ]
+
+>> arrowSchema = arrowRecordBatch.Schema
+
+arrowSchema =
+
+Letter: string
+Number: double
+```
+
 ### Feather V1
 
-#### Write a MATLAB table to a Feather v1 file
+#### Write a MATLAB table to a Feather V1 file
 
 ``` matlab
->> t = array2table(rand(10, 10));
->> filename = 'table.feather';
->> featherwrite(filename,t);
+>> t = table(["A"; "B"; "C"], [1; 2; 3], [true; false; true])
+
+t =
+
+  3×3 table
+
+    Var1    Var2    Var3
+    ____    ____    _____
+
+    "A"      1      true
+    "B"      2      false
+    "C"      3      true
+
+>> filename = "table.feather";
+
+>> featherwrite(filename, t)
 ```
 
-#### Read a Feather v1 file into a MATLAB table
+#### Read a Feather V1 file into a MATLAB table
 
 ``` matlab
->> filename = 'table.feather';
->> t = featherread(filename);
+>> filename = "table.feather";
+
+>> t = featherread(filename)
+
+t =
+
+  3×3 table
+
+    Var1    Var2    Var3
+    ____    ____    _____
+
+    "A"      1      true
+    "B"      2      false
+    "C"      3      true
 ```
 

From e44f5ebeab1ce7cc70dd947f7c976d1a32ef210b Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Thu, 17 Aug 2023 12:14:30 -0400
Subject: [PATCH 183/749] GH-37222: [Docs][MATLAB] Rename `arrow.recordbatch`
 (all lowercase) to `arrow.recordBatch` (camelCase) (#37223)

### Rationale for this change

As @ kou suggested in https://github.com/apache/arrow/pull/37215#discussion_r1296559210, it makes sense to rename `arrow.recordbatch` (all lowercase) to `arrow.recordBatch` (camelCase).

`recordBatch` is the first "two-word" function in the top-level `arrow.*` package, so it makes sense to establish a clear camelCase standard for "multi-word" functions in the MATLAB interface at this point.

One part of the rationale motivating this change is that other language bindings follow a similar pattern (e.g. `pyarrow.record_batch` instead of `pyarrow.recordbatch`).

### What changes are included in this PR?

1. Renamed `arrow.recordbatch` (all lowercase) to `arrow.recordBatch` (camelCase).
2. Updated documentation and tests to reflect `arrow.recordbatch` being renamed to `arrow.recordBatch`.

### Are these changes tested?

Yes.

1. All existing MATLAB tests have been updated to use the new name `arrow.recordbatch` and are passing on my Debian 11 machine.

### Are there any user-facing changes?

Yes.

**This PR includes breaking changes to public APIs.**

The public facing API `arrow.recordbatch` has been renamed to `arrow.recordBatch`. Since the MATLAB interface is still "pre 1.0", we don't expect this change to have a significant impact.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37222

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/README.md                              |  4 +--
 .../+arrow/{recordbatch.m => recordBatch.m}   |  2 +-
 matlab/src/matlab/featherwrite.m              |  2 +-
 matlab/test/arrow/io/feather/tRoundTrip.m     |  2 +-
 matlab/test/arrow/tabular/tRecordBatch.m      | 30 +++++++++----------
 5 files changed, 20 insertions(+), 20 deletions(-)
 rename matlab/src/matlab/+arrow/{recordbatch.m => recordBatch.m} (97%)

diff --git a/matlab/README.md b/matlab/README.md
index a070984a9e38f..e0acb8b748b6d 100644
--- a/matlab/README.md
+++ b/matlab/README.md
@@ -225,7 +225,7 @@ matlabTable =
     "B"      2      false
     "C"      3      true
 
->> arrowRecordBatch = arrow.recordbatch(matlabTable)
+>> arrowRecordBatch = arrow.recordBatch(matlabTable)
 
 arrowRecordBatch =
 
@@ -557,7 +557,7 @@ matlabTable =
      "B"        2
      "C"        3
 
->> arrowRecordBatch = arrow.recordbatch(matlabTable)
+>> arrowRecordBatch = arrow.recordBatch(matlabTable)
 
 arrowRecordBatch =
 
diff --git a/matlab/src/matlab/+arrow/recordbatch.m b/matlab/src/matlab/+arrow/recordBatch.m
similarity index 97%
rename from matlab/src/matlab/+arrow/recordbatch.m
rename to matlab/src/matlab/+arrow/recordBatch.m
index 1fb25347f1a7d..662db9cca940c 100644
--- a/matlab/src/matlab/+arrow/recordbatch.m
+++ b/matlab/src/matlab/+arrow/recordBatch.m
@@ -14,7 +14,7 @@
 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
-function rb = recordbatch(T)
+function rb = recordBatch(T)
     arguments
         T table
     end
diff --git a/matlab/src/matlab/featherwrite.m b/matlab/src/matlab/featherwrite.m
index 879edd8afc68e..27fa5dfbb3898 100644
--- a/matlab/src/matlab/featherwrite.m
+++ b/matlab/src/matlab/featherwrite.m
@@ -28,7 +28,7 @@ function featherwrite(filename, t)
         t table
     end
 
-    recordBatch = arrow.recordbatch(t);
+    recordBatch = arrow.recordBatch(t);
     writer = arrow.internal.io.feather.Writer(filename);
     writer.write(recordBatch);
 end
diff --git a/matlab/test/arrow/io/feather/tRoundTrip.m b/matlab/test/arrow/io/feather/tRoundTrip.m
index d33111fb931b2..6fa88d155d9e8 100644
--- a/matlab/test/arrow/io/feather/tRoundTrip.m
+++ b/matlab/test/arrow/io/feather/tRoundTrip.m
@@ -28,7 +28,7 @@ function Basic(testCase)
             SingleVar = single([10; 15; 20; 25]);
 
             tableWrite = table(DoubleVar, SingleVar);
-            recordBatchWrite = arrow.recordbatch(tableWrite);
+            recordBatchWrite = arrow.recordBatch(tableWrite);
 
             writer = Writer(filename);
             writer.write(recordBatchWrite);
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 66461b29c1dd6..027195d3d8250 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -20,7 +20,7 @@
 
         function Basic(tc)
             T = table([1, 2, 3]');
-            arrowRecordBatch = arrow.recordbatch(T);
+            arrowRecordBatch = arrow.recordBatch(T);
             className = string(class(arrowRecordBatch));
             tc.verifyEqual(className, "arrow.tabular.RecordBatch");
         end
@@ -30,21 +30,21 @@ function SupportedTypes(tc)
             import arrow.internal.test.tabular.createTableWithSupportedTypes
 
             TOriginal = createTableWithSupportedTypes();
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             expectedColumnNames = string(TOriginal.Properties.VariableNames);
             tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
         end
 
         function ToMATLAB(tc)
             TOriginal = table([1, 2, 3]');
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
         end
 
         function Table(tc)
             TOriginal = table([1, 2, 3]');
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             TConverted = table(arrowRecordBatch);
             tc.verifyEqual(TOriginal, TConverted);
         end
@@ -52,7 +52,7 @@ function Table(tc)
         function ColumnNames(tc)
             columnNames = ["A", "B", "C"];
             TOriginal = table(1, 2, 3, VariableNames=columnNames);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             tc.verifyEqual(arrowRecordBatch.ColumnNames, columnNames);
         end
 
@@ -61,7 +61,7 @@ function NumColumns(tc)
 
             for nc = numColumns
                 T = array2table(ones(1, nc));
-                arrowRecordBatch = arrow.recordbatch(T);
+                arrowRecordBatch = arrow.recordBatch(T);
                 tc.verifyEqual(arrowRecordBatch.NumColumns, nc);
             end
         end
@@ -72,7 +72,7 @@ function UnicodeColumnNames(tc)
             mango = "🥭";
             columnNames = [smiley, tree, mango];
             TOriginal = table(1, 2, 3, VariableNames=columnNames);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             tc.verifyEqual(arrowRecordBatch.ColumnNames, columnNames);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
@@ -80,42 +80,42 @@ function UnicodeColumnNames(tc)
 
         function EmptyTable(tc)
             TOriginal = table();
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             TConverted = arrowRecordBatch.toMATLAB();
             tc.verifyEqual(TOriginal, TConverted);
         end
 
         function EmptyRecordBatchColumnIndexError(tc)
             TOriginal = table();
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column(1);
             tc.verifyError(fcn, "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch");
         end
 
         function InvalidNumericIndexError(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column(4);
             tc.verifyError(fcn, "arrow:tabular:recordbatch:InvalidNumericColumnIndex");
         end
 
         function UnsupportedColumnIndexType(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column(datetime(2022, 1, 3));
             tc.verifyError(fcn, "arrow:badsubscript:NonNumeric");
         end
 
         function ErrorIfIndexIsNonScalar(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column([1 2]);
             tc.verifyError(fcn, "MATLAB:expectedScalar");
         end
 
         function ErrorIfIndexIsNonPositive(tc)
             TOriginal = table(1, 2, 3);
-            arrowRecordBatch = arrow.recordbatch(TOriginal);
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column(-1);
             tc.verifyError(fcn, "arrow:badsubscript:NonPositive");
         end
@@ -203,7 +203,7 @@ function Schema(tc)
                       [1; 2; 3], ...
                       [true; false; true], ...
                       VariableNames=["A", "B", "C"]);
-            recordBatch = arrow.recordbatch(t);
+            recordBatch = arrow.recordBatch(t);
             schema = recordBatch.Schema;
             tc.verifyEqual(schema.NumFields, int32(3));
             tc.verifyEqual(schema.field(1).Type.ID, arrow.type.ID.String);
@@ -218,7 +218,7 @@ function SchemaNoSetter(tc)
         % Verify that trying to set the value of the public Schema property
         % results in an error of type "MATLAB:class:SetProhibited".
             t = table([1; 2; 3]);
-            recordBatch = arrow.recordbatch(t);
+            recordBatch = arrow.recordBatch(t);
             tc.verifyError(@() setfield(recordBatch, "Schema", "Value"), ...
                 "MATLAB:class:SetProhibited");
         end

From 43c05c56b37daa93e76b94bc3e6952d56d1ea3f2 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 17 Aug 2023 16:27:24 -0400
Subject: [PATCH 184/749] GH-37228: [MATLAB] Add C++ `ARROW_MATLAB_EXPORT`
 symbol export macro (#37233)

### Rationale for this change

Currently, the main shared library used by the MATLAB interface - `libarrowproxy` - does not explicitly export any symbols.

This hasn't been a major issue so far based on our usage of these symbols - except for in one case - which was being able to define a template specialization of the static make function for `NumericArray<T>` in a C++ source file. To work around this, we decided to inline these template specializations.

However, this isn't an ideal solution because these functions shouldn't need to be inlined (and, in fact, this could have undesirable performance implications).

In addition, to enable the ability to write C++ unit tests for code in the "Proxy layer", we would need to export symbols from `libarrowproxy`.

This is the first in a series of pull requests in which we will export symbols from `libarrowproxy` so we can write C++ unit tests via the GoogleTest framework.

### What changes are included in this PR?

1. Added a C++ `ARROW_MATLAB_EXPORT` macro for exporting symbols in `visibility.h`
2. Added a new header `timestamp_array.h` which declares the template method specialization of the static `make` function for `NumericArray<arrow::TimestampType>`
3. Moved the definition of `NumericArray<arrow::TimestampType>::make` to `timestamp_array.cc`

### Are these changes tested?

New tests points are not needed. These changes are covered by our existing  test suite.

### Are there any user-facing changes?

No.

### Future Directions

1. As mentioned above, this is the first in a series of pull requests. In future PRs we will export more symbols to enable C++ unit testing.
* Closes: #37228

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/api/visibility.h  | 28 ++++++++
 .../arrow/matlab/array/proxy/numeric_array.h  | 49 -------------
 .../matlab/array/proxy/timestamp_array.cc     | 69 +++++++++++++++++++
 .../matlab/array/proxy/timestamp_array.h      | 31 +++++++++
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |  1 +
 .../cmake/BuildMatlabArrowInterface.cmake     |  2 +
 6 files changed, 131 insertions(+), 49 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/api/visibility.h
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h

diff --git a/matlab/src/cpp/arrow/matlab/api/visibility.h b/matlab/src/cpp/arrow/matlab/api/visibility.h
new file mode 100644
index 0000000000000..51efac972ee92
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/api/visibility.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#ifdef ARROW_MATLAB_EXPORTING
+#define ARROW_MATLAB_EXPORT __declspec(dllexport)
+#else
+#define ARROW_MATLAB_EXPORT __declspec(dllimport)
+#endif
+#else // Not Windows
+#define ARROW_MATLAB_EXPORT __attribute__((visibility("default")))
+#endif
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index 6bfdad1f5db55..9c81d5ff6218e 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -33,9 +33,6 @@
 
 #include "libmexclass/proxy/Proxy.h"
 
-#include "arrow/matlab/type/time_unit.h"
-#include "arrow/util/utf8.h"
-
 namespace arrow::matlab::array::proxy {
 
 template<typename ArrowType>
@@ -86,50 +83,4 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
             context.outputs[0] = result;
         }
 };
-
-     // Specialization of NumericArray::Make for arrow::TimestampType.
-    template <>
-    inline libmexclass::proxy::MakeResult NumericArray<arrow::TimestampType>::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
-        namespace mda = ::matlab::data;
-        using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
-        using TimestampArray = arrow::TimestampArray;
-        using TimestampArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>;
-
-        mda::StructArray opts = constructor_arguments[0];
-
-        // Get the mxArray from constructor arguments
-        const mda::TypedArray<int64_t> timestamp_mda = opts[0]["MatlabArray"];
-        const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
-        
-        const mda::TypedArray<mda::MATLABString> timezone_mda = opts[0]["TimeZone"];
-        const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
-
-        // extract the time zone string
-        const std::u16string& u16_timezone = timezone_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto timezone, 
-                               arrow::util::UTF16StringToUTF8(u16_timezone),
-                               error::UNICODE_CONVERSION_ERROR_ID);
-
-        // extract the time unit
-        const std::u16string& u16_timeunit = units_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto time_unit, 
-                               arrow::matlab::type::timeUnitFromString(u16_timeunit),
-                               error::UKNOWN_TIME_UNIT_ERROR_ID)
-
-        // create the timestamp_type
-        auto data_type = arrow::timestamp(time_unit, timezone);
-        auto array_length = static_cast<int64_t>(timestamp_mda.getNumberOfElements()); // cast size_t to int64_t
-
-        auto data_buffer = std::make_shared<MatlabBuffer>(timestamp_mda);
-
-        // Pack the validity bitmap values.
-        MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap, 
-                               bit::packValid(validity_bitmap_mda), 
-                               error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
-
-        auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
-        auto timestamp_array = std::static_pointer_cast<TimestampArray>(arrow::MakeArray(array_data));
-        return std::make_shared<TimestampArrayProxy>(std::move(timestamp_array));
-    }
-
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
new file mode 100644
index 0000000000000..45a5b6ab92239
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc
@@ -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.
+
+#include "arrow/matlab/array/proxy/timestamp_array.h"
+
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/util/utf8.h"
+
+namespace arrow::matlab::array::proxy {
+
+    // Specialization of NumericArray::Make for arrow::TimestampType.
+    template <>
+    libmexclass::proxy::MakeResult TimestampArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+       namespace mda = ::matlab::data;
+       using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+       using TimestampArray = arrow::TimestampArray;
+       using TimestampArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>;
+
+       mda::StructArray opts = constructor_arguments[0];
+
+       // Get the mxArray from constructor arguments
+       const mda::TypedArray<int64_t> timestamp_mda = opts[0]["MatlabArray"];
+       const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+       
+       const mda::TypedArray<mda::MATLABString> timezone_mda = opts[0]["TimeZone"];
+       const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
+
+       // extract the time zone string
+       const std::u16string& u16_timezone = timezone_mda[0];
+       MATLAB_ASSIGN_OR_ERROR(const auto timezone,
+                              arrow::util::UTF16StringToUTF8(u16_timezone),
+                              error::UNICODE_CONVERSION_ERROR_ID);
+
+       // extract the time unit
+       const std::u16string& u16_timeunit = units_mda[0];
+       MATLAB_ASSIGN_OR_ERROR(const auto time_unit,
+                              arrow::matlab::type::timeUnitFromString(u16_timeunit),
+                              error::UKNOWN_TIME_UNIT_ERROR_ID)
+
+       // create the timestamp_type
+       auto data_type = arrow::timestamp(time_unit, timezone);
+       auto array_length = static_cast<int64_t>(timestamp_mda.getNumberOfElements()); // cast size_t to int64_t
+
+       auto data_buffer = std::make_shared<MatlabBuffer>(timestamp_mda);
+
+       // Pack the validity bitmap values.
+       MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap,
+                              bit::packValid(validity_bitmap_mda),
+                              error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+       auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
+       auto timestamp_array = std::static_pointer_cast<TimestampArray>(arrow::MakeArray(array_data));
+       return std::make_shared<TimestampArrayProxy>(std::move(timestamp_array));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h
new file mode 100644
index 0000000000000..0667917f3689a
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/timestamp_array.h
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/array/proxy/numeric_array.h"
+
+#include "arrow/matlab/api/visibility.h"
+
+namespace arrow::matlab::array::proxy {
+
+    using TimestampArray = NumericArray<arrow::TimestampType>;
+
+    // Specialization of NumericArray::Make for arrow::TimestampType
+    template<>
+    ARROW_MATLAB_EXPORT libmexclass::proxy::MakeResult TimestampArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+}
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index bce875bb9f184..1420cd527c158 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -18,6 +18,7 @@
 #include "arrow/matlab/array/proxy/boolean_array.h"
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
+#include "arrow/matlab/array/proxy/timestamp_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index c19740f181444..052f6b5ff2800 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -44,6 +44,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/c
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/boolean_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"
@@ -106,6 +107,7 @@ libmexclass_client_add_proxy_library(
 )
 # Use C++17
 target_compile_features(${MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_LIBRARY_NAME} PRIVATE cxx_std_17)
+target_compile_definitions(${MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_LIBRARY_NAME} PRIVATE ARROW_MATLAB_EXPORTING)
 
 # When building Arrow from source, Arrow must be built before building the client Proxy library.
 if(TARGET arrow_ep)

From ca1a0eb2dde5878275aa433384c38e33b4329260 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 17 Aug 2023 23:03:28 -0400
Subject: [PATCH 185/749] GH-37217: [Python] Add missing docstrings to Cython
 (#37218)

### Rationale for this change

The Cython 3.0.0 upgrade https://github.com/apache/arrow/pull/37097 is triggering numpydoc errors for these missing docstrings.

### What changes are included in this PR?

* Docstrings added to Cython functions that omitted them

### Are these changes tested?

Yes, locally.

### Are there any user-facing changes?

User-facing documentation is added.
* Closes: #37217

Lead-authored-by: Dane Pitkin <dane@voltrondata.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/_compute.pyx         |   9 ++
 python/pyarrow/_csv.pyx             |  27 ++++++
 python/pyarrow/_dataset.pyx         |  74 +++++++++++++++
 python/pyarrow/_dataset_orc.pyx     |   9 ++
 python/pyarrow/_dataset_parquet.pyx |  41 +++++++++
 python/pyarrow/_fs.pyx              |   9 ++
 python/pyarrow/_json.pyx            |  18 ++++
 python/pyarrow/_parquet.pyx         |  92 +++++++++++++++++++
 python/pyarrow/array.pxi            |  33 +++++++
 python/pyarrow/gandiva.pyx          | 135 ++++++++++++++++++++++++++++
 python/pyarrow/io.pxi               |  54 +++++++++++
 python/pyarrow/scalar.pxi           |   9 ++
 python/pyarrow/table.pxi            |  11 +++
 python/pyarrow/tensor.pxi           |  85 ++++++++++++++++++
 python/pyarrow/types.pxi            |  45 ++++++++++
 15 files changed, 651 insertions(+)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index bc3b9e8c558e0..453f487c4de80 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -2345,6 +2345,15 @@ cdef class Expression(_Weakrefable):
         return self.expr
 
     def equals(self, Expression other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.Expression
+
+        Returns
+        -------
+        bool
+        """
         return self.expr.Equals(other.unwrap())
 
     def __str__(self):
diff --git a/python/pyarrow/_csv.pyx b/python/pyarrow/_csv.pyx
index 0b72f5249f9fc..e532d8d8ab22a 100644
--- a/python/pyarrow/_csv.pyx
+++ b/python/pyarrow/_csv.pyx
@@ -290,6 +290,15 @@ cdef class ReadOptions(_Weakrefable):
         check_status(deref(self.options).Validate())
 
     def equals(self, ReadOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.csv.ReadOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.use_threads == other.use_threads and
             self.block_size == other.block_size and
@@ -536,6 +545,15 @@ cdef class ParseOptions(_Weakrefable):
         check_status(deref(self.options).Validate())
 
     def equals(self, ParseOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.csv.ParseOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.delimiter == other.delimiter and
             self.quote_char == other.quote_char and
@@ -1042,6 +1060,15 @@ cdef class ConvertOptions(_Weakrefable):
         check_status(deref(self.options).Validate())
 
     def equals(self, ConvertOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.csv.ConvertOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.check_utf8 == other.check_utf8 and
             self.column_types == other.column_types and
diff --git a/python/pyarrow/_dataset.pyx b/python/pyarrow/_dataset.pyx
index badf6e4a4c5dc..8f5688de29072 100644
--- a/python/pyarrow/_dataset.pyx
+++ b/python/pyarrow/_dataset.pyx
@@ -1992,9 +1992,27 @@ cdef class IpcFileFormat(FileFormat):
         self.init(shared_ptr[CFileFormat](new CIpcFileFormat()))
 
     def equals(self, IpcFileFormat other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.IpcFileFormat
+
+        Returns
+        -------
+        True
+        """
         return True
 
     def make_write_options(self, **kwargs):
+        """
+        Parameters
+        ----------
+        **kwargs : dict
+
+        Returns
+        -------
+        pyarrow.ipc.IpcWriteOptions
+        """
         cdef IpcFileWriteOptions opts = \
             <IpcFileWriteOptions> FileFormat.make_write_options(self)
         opts.write_options = IpcWriteOptions(**kwargs)
@@ -2071,6 +2089,15 @@ cdef class CsvFileFormat(FileFormat):
         self.csv_format = <CCsvFileFormat*> sp.get()
 
     def make_write_options(self, **kwargs):
+        """
+        Parameters
+        ----------
+        **kwargs : dict
+
+        Returns
+        -------
+        pyarrow.csv.WriteOptions
+        """
         cdef CsvFileWriteOptions opts = \
             <CsvFileWriteOptions> FileFormat.make_write_options(self)
         opts.write_options = WriteOptions(**kwargs)
@@ -2093,6 +2120,15 @@ cdef class CsvFileFormat(FileFormat):
             super()._set_default_fragment_scan_options(options)
 
     def equals(self, CsvFileFormat other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.CsvFileFormat
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.parse_options.equals(other.parse_options) and
             self.default_fragment_scan_options ==
@@ -2165,6 +2201,15 @@ cdef class CsvFragmentScanOptions(FragmentScanOptions):
                 make_streamwrap_func(read_options.encoding, 'utf-8'))
 
     def equals(self, CsvFragmentScanOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.CsvFragmentScanOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             other and
             self.convert_options.equals(other.convert_options) and
@@ -2250,6 +2295,15 @@ cdef class JsonFileFormat(FileFormat):
             super()._set_default_fragment_scan_options(options)
 
     def equals(self, JsonFileFormat other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.JsonFileFormat
+
+        Returns
+        -------
+        bool
+        """
         return (other and
                 self.default_fragment_scan_options ==
                 other.default_fragment_scan_options)
@@ -2308,6 +2362,15 @@ cdef class JsonFragmentScanOptions(FragmentScanOptions):
         self.json_options.read_options = read_options.options
 
     def equals(self, JsonFragmentScanOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.JsonFragmentScanOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             other and
             self.read_options.equals(other.read_options) and
@@ -2353,6 +2416,17 @@ cdef class Partitioning(_Weakrefable):
         return False
 
     def parse(self, path):
+        """
+        Parse a path into a partition expression.
+
+        Parameters
+        ----------
+        path : str
+
+        Returns
+        -------
+        pyarrow.dataset.Expression
+        """
         cdef CResult[CExpression] result
         result = self.partitioning.Parse(tobytes(path))
         return Expression.wrap(GetResultValue(result))
diff --git a/python/pyarrow/_dataset_orc.pyx b/python/pyarrow/_dataset_orc.pyx
index 40a21ef5462b9..a8cce3362225a 100644
--- a/python/pyarrow/_dataset_orc.pyx
+++ b/python/pyarrow/_dataset_orc.pyx
@@ -32,6 +32,15 @@ cdef class OrcFileFormat(FileFormat):
         self.init(shared_ptr[CFileFormat](new COrcFileFormat()))
 
     def equals(self, OrcFileFormat other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.OrcFileFormat
+
+        Returns
+        -------
+        True
+        """
         return True
 
     @property
diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx
index 4ad0caec30798..4de396f4f50eb 100644
--- a/python/pyarrow/_dataset_parquet.pyx
+++ b/python/pyarrow/_dataset_parquet.pyx
@@ -178,6 +178,15 @@ cdef class ParquetFileFormat(FileFormat):
         return parquet_read_options
 
     def make_write_options(self, **kwargs):
+        """
+        Parameters
+        ----------
+        **kwargs : dict
+
+        Returns
+        -------
+        pyarrow.dataset.FileWriteOptions
+        """
         opts = FileFormat.make_write_options(self)
         (<ParquetFileWriteOptions> opts).update(**kwargs)
         return opts
@@ -189,6 +198,15 @@ cdef class ParquetFileFormat(FileFormat):
             super()._set_default_fragment_scan_options(options)
 
     def equals(self, ParquetFileFormat other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.ParquetFileFormat
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.read_options.equals(other.read_options) and
             self.default_fragment_scan_options ==
@@ -502,6 +520,15 @@ cdef class ParquetReadOptions(_Weakrefable):
             self._coerce_int96_timestamp_unit = TimeUnit_NANO
 
     def equals(self, ParquetReadOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.ParquetReadOptions
+
+        Returns
+        -------
+        bool
+        """
         return (self.dictionary_columns == other.dictionary_columns and
                 self.coerce_int96_timestamp_unit ==
                 other.coerce_int96_timestamp_unit)
@@ -527,6 +554,11 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
         object _properties
 
     def update(self, **kwargs):
+        """
+        Parameters
+        ----------
+        **kwargs : dict
+        """
         arrow_fields = {
             "use_deprecated_int96_timestamps",
             "coerce_timestamps",
@@ -720,6 +752,15 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
         self.reader_properties().set_thrift_container_size_limit(size)
 
     def equals(self, ParquetFragmentScanOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.dataset.ParquetFragmentScanOptions
+
+        Returns
+        -------
+        bool
+        """
         attrs = (
             self.use_buffered_stream, self.buffer_size, self.pre_buffer,
             self.thrift_string_size_limit, self.thrift_container_size_limit)
diff --git a/python/pyarrow/_fs.pyx b/python/pyarrow/_fs.pyx
index 69105afc2fcc9..dbd7ebe5e4d52 100644
--- a/python/pyarrow/_fs.pyx
+++ b/python/pyarrow/_fs.pyx
@@ -505,6 +505,15 @@ cdef class FileSystem(_Weakrefable):
         return self.wrapped
 
     def equals(self, FileSystem other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.fs.FileSystem
+
+        Returns
+        -------
+        bool
+        """
         return self.fs.Equals(other.unwrap())
 
     def __eq__(self, other):
diff --git a/python/pyarrow/_json.pyx b/python/pyarrow/_json.pyx
index 70cde6e23fed3..d36dad67abbaa 100644
--- a/python/pyarrow/_json.pyx
+++ b/python/pyarrow/_json.pyx
@@ -83,6 +83,15 @@ cdef class ReadOptions(_Weakrefable):
         )
 
     def equals(self, ReadOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.json.ReadOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.use_threads == other.use_threads and
             self.block_size == other.block_size
@@ -212,6 +221,15 @@ cdef class ParseOptions(_Weakrefable):
         self.options.unexpected_field_behavior = v
 
     def equals(self, ParseOptions other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.json.ParseOptions
+
+        Returns
+        -------
+        bool
+        """
         return (
             self.explicit_schema == other.explicit_schema and
             self.newlines_in_values == other.newlines_in_values and
diff --git a/python/pyarrow/_parquet.pyx b/python/pyarrow/_parquet.pyx
index 4448f359ac1aa..50b4ed8e86e65 100644
--- a/python/pyarrow/_parquet.pyx
+++ b/python/pyarrow/_parquet.pyx
@@ -1183,6 +1183,22 @@ cdef class ParquetReader(_Weakrefable):
              FileDecryptionProperties decryption_properties=None,
              thrift_string_size_limit=None,
              thrift_container_size_limit=None):
+        """
+        Open a parquet file for reading.
+
+        Parameters
+        ----------
+        source : str, pathlib.Path, pyarrow.NativeFile, or file-like object
+        use_memory_map : bool, default False
+        read_dictionary : iterable[int or str], optional
+        metadata : FileMetaData, optional
+        buffer_size : int, default 0
+        pre_buffer : bool, default False
+        coerce_int96_timestamp_unit : str, optional
+        decryption_properties : FileDecryptionProperties, optional
+        thrift_string_size_limit : int, optional
+        thrift_container_size_limit : int, optional
+        """
         cdef:
             shared_ptr[CFileMetaData] c_metadata
             CReaderProperties properties = default_reader_properties()
@@ -1285,13 +1301,35 @@ cdef class ParquetReader(_Weakrefable):
         return self.reader.get().num_row_groups()
 
     def set_use_threads(self, bint use_threads):
+        """
+        Parameters
+        ----------
+        use_threads : bool
+        """
         self.reader.get().set_use_threads(use_threads)
 
     def set_batch_size(self, int64_t batch_size):
+        """
+        Parameters
+        ----------
+        batch_size : int64
+        """
         self.reader.get().set_batch_size(batch_size)
 
     def iter_batches(self, int64_t batch_size, row_groups, column_indices=None,
                      bint use_threads=True):
+        """
+        Parameters
+        ----------
+        batch_size : int64
+        row_groups : list[int]
+        column_indices : list[int], optional
+        use_threads : bool, default True
+
+        Yields
+        ------
+        next : RecordBatch
+        """
         cdef:
             vector[int] c_row_groups
             vector[int] c_column_indices
@@ -1336,10 +1374,32 @@ cdef class ParquetReader(_Weakrefable):
 
     def read_row_group(self, int i, column_indices=None,
                        bint use_threads=True):
+        """
+        Parameters
+        ----------
+        i : int
+        column_indices : list[int], optional
+        use_threads : bool, default True
+
+        Returns
+        -------
+        table : pyarrow.Table
+        """
         return self.read_row_groups([i], column_indices, use_threads)
 
     def read_row_groups(self, row_groups not None, column_indices=None,
                         bint use_threads=True):
+        """
+        Parameters
+        ----------
+        row_groups : list[int]
+        column_indices : list[int], optional
+        use_threads : bool, default True
+
+        Returns
+        -------
+        table : pyarrow.Table
+        """
         cdef:
             shared_ptr[CTable] ctable
             vector[int] c_row_groups
@@ -1366,6 +1426,16 @@ cdef class ParquetReader(_Weakrefable):
         return pyarrow_wrap_table(ctable)
 
     def read_all(self, column_indices=None, bint use_threads=True):
+        """
+        Parameters
+        ----------
+        column_indices : list[int], optional
+        use_threads : bool, default True
+
+        Returns
+        -------
+        table : pyarrow.Table
+        """
         cdef:
             shared_ptr[CTable] ctable
             vector[int] c_column_indices
@@ -1387,6 +1457,16 @@ cdef class ParquetReader(_Weakrefable):
         return pyarrow_wrap_table(ctable)
 
     def scan_contents(self, column_indices=None, batch_size=65536):
+        """
+        Parameters
+        ----------
+        column_indices : list[int], optional
+        batch_size : int32, default 65536
+
+        Returns
+        -------
+        num_rows : int64
+        """
         cdef:
             vector[int] c_column_indices
             int32_t c_batch_size
@@ -1434,6 +1514,18 @@ cdef class ParquetReader(_Weakrefable):
         return self._column_idx_map[tobytes(column_name)]
 
     def read_column(self, int column_index):
+        """
+        Read the column at the specified index.
+
+        Parameters
+        ----------
+        column_index : int
+            Index of the column.
+
+        Returns
+        -------
+        column : pyarrow.ChunkedArray
+        """
         cdef shared_ptr[CChunkedArray] out
         with nogil:
             check_status(self.reader.get()
diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index 2f8959cd721ec..ce4eafd8e30fb 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -1265,6 +1265,17 @@ cdef class Array(_PandasConvertible):
         return frombytes(result, safe=True)
 
     def format(self, **kwargs):
+        """
+        DEPRECATED, use pyarrow.Array.to_string
+
+        Parameters
+        ----------
+        **kwargs : dict
+
+        Returns
+        -------
+        str
+        """
         import warnings
         warnings.warn('Array.format is deprecated, use Array.to_string')
         return self.to_string(**kwargs)
@@ -1281,6 +1292,15 @@ cdef class Array(_PandasConvertible):
             return NotImplemented
 
     def equals(Array self, Array other not None):
+        """
+        Parameters
+        ----------
+        other : pyarrow.Array
+
+        Returns
+        -------
+        bool
+        """
         return self.ap.Equals(deref(other.ap))
 
     def __len__(self):
@@ -2336,6 +2356,19 @@ cdef class UnionArray(Array):
     """
 
     def child(self, int pos):
+        """
+        DEPRECATED, use field() instead.
+
+        Parameters
+        ----------
+        pos : int
+            The physical index of the union child field (not its type code).
+
+        Returns
+        -------
+        field : pyarrow.Field
+            The given child field.
+        """
         import warnings
         warnings.warn("child is deprecated, use field", FutureWarning)
         return self.field(pos)
diff --git a/python/pyarrow/gandiva.pyx b/python/pyarrow/gandiva.pyx
index cc46bc760ff94..35bbf5018f08a 100644
--- a/python/pyarrow/gandiva.pyx
+++ b/python/pyarrow/gandiva.pyx
@@ -191,6 +191,19 @@ cdef class Projector(_Weakrefable):
         return self.projector.get().DumpIR().decode()
 
     def evaluate(self, RecordBatch batch, SelectionVector selection=None):
+        """
+        Evaluate the specified record batch and return the arrays at the
+        filtered positions.
+
+        Parameters
+        ----------
+        batch : pyarrow.RecordBatch
+        selection : pyarrow.gandiva.SelectionVector
+
+        Returns
+        -------
+        list[pyarrow.Array]
+        """
         cdef vector[shared_ptr[CArray]] results
         if selection is None:
             check_status(self.projector.get().Evaluate(
@@ -227,6 +240,19 @@ cdef class Filter(_Weakrefable):
         return self.filter.get().DumpIR().decode()
 
     def evaluate(self, RecordBatch batch, MemoryPool pool, dtype='int32'):
+        """
+        Evaluate the specified record batch and return a selection vector.
+
+        Parameters
+        ----------
+        batch : pyarrow.RecordBatch
+        pool : MemoryPool
+        dtype : DataType or str, default int32
+
+        Returns
+        -------
+        pyarrow.gandiva.SelectionVector
+        """
         cdef:
             DataType type = ensure_type(dtype)
             shared_ptr[CSelectionVector] selection
@@ -252,6 +278,18 @@ cdef class Filter(_Weakrefable):
 cdef class TreeExprBuilder(_Weakrefable):
 
     def make_literal(self, value, dtype):
+        """
+        Create a node on a literal.
+
+        Parameters
+        ----------
+        value : a literal value
+        dtype : DataType
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef:
             DataType type = ensure_type(dtype)
             shared_ptr[CNode] r
@@ -289,6 +327,19 @@ cdef class TreeExprBuilder(_Weakrefable):
 
     def make_expression(self, Node root_node not None,
                         Field return_field not None):
+        """
+        Create an expression with the specified root_node,
+        and the result written to result_field.
+
+        Parameters
+        ----------
+        root_node : pyarrow.gandiva.Node
+        return_field : pyarrow.Field
+
+        Returns
+        -------
+        pyarrow.gandiva.Expression
+        """
         cdef shared_ptr[CGandivaExpression] r = TreeExprBuilder_MakeExpression(
             root_node.node, return_field.sp_field)
         cdef Expression expression = Expression()
@@ -296,6 +347,19 @@ cdef class TreeExprBuilder(_Weakrefable):
         return expression
 
     def make_function(self, name, children, DataType return_type):
+        """
+        Create a node with a function.
+
+        Parameters
+        ----------
+        name : str
+        children : pyarrow.gandiva.NodeVector
+        return_type : DataType
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef c_vector[shared_ptr[CNode]] c_children
         cdef Node child
         for child in children:
@@ -307,17 +371,53 @@ cdef class TreeExprBuilder(_Weakrefable):
         return Node.create(r)
 
     def make_field(self, Field field not None):
+        """
+        Create a node with an Arrow field.
+
+        Parameters
+        ----------
+        field : pyarrow.Field
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef shared_ptr[CNode] r = TreeExprBuilder_MakeField(field.sp_field)
         return Node.create(r)
 
     def make_if(self, Node condition not None, Node this_node not None,
                 Node else_node not None, DataType return_type not None):
+        """
+        Create a node with an if-else expression.
+
+        Parameters
+        ----------
+        condition : pyarrow.gandiva.Node
+        this_node : pyarrow.gandiva.Node
+        else_node : pyarrow.gandiva.Node
+        return_type : DataType
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef shared_ptr[CNode] r = TreeExprBuilder_MakeIf(
             condition.node, this_node.node, else_node.node,
             return_type.sp_type)
         return Node.create(r)
 
     def make_and(self, children):
+        """
+        Create a Node with a boolean AND expression.
+
+        Parameters
+        ----------
+        children : list[pyarrow.gandiva.Node]
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef c_vector[shared_ptr[CNode]] c_children
         cdef Node child
         for child in children:
@@ -328,6 +428,17 @@ cdef class TreeExprBuilder(_Weakrefable):
         return Node.create(r)
 
     def make_or(self, children):
+        """
+        Create a Node with a boolean OR expression.
+
+        Parameters
+        ----------
+        children : list[pyarrow.gandiva.Node]
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef c_vector[shared_ptr[CNode]] c_children
         cdef Node child
         for child in children:
@@ -420,6 +531,19 @@ cdef class TreeExprBuilder(_Weakrefable):
         return Node.create(r)
 
     def make_in_expression(self, Node node not None, values, dtype):
+        """
+        Create a Node with an IN expression.
+
+        Parameters
+        ----------
+        node : pyarrow.gandiva.Node
+        values : iterable
+        dtype : DataType
+
+        Returns
+        -------
+        pyarrow.gandiva.Node
+        """
         cdef DataType type = ensure_type(dtype)
 
         if type.id == _Type_INT32:
@@ -444,6 +568,17 @@ cdef class TreeExprBuilder(_Weakrefable):
             raise TypeError("Data type " + str(dtype) + " not supported.")
 
     def make_condition(self, Node condition not None):
+        """
+        Create a condition with the specified node.
+
+        Parameters
+        ----------
+        condition : pyarrow.gandiva.Node
+
+        Returns
+        -------
+        pyarrow.gandiva.Condition
+        """
         cdef shared_ptr[CCondition] r = TreeExprBuilder_MakeCondition(
             condition.node)
         return Condition.create(r)
diff --git a/python/pyarrow/io.pxi b/python/pyarrow/io.pxi
index 2a78f7e795466..e3018ab4704f0 100644
--- a/python/pyarrow/io.pxi
+++ b/python/pyarrow/io.pxi
@@ -575,6 +575,14 @@ cdef class NativeFile(_Weakrefable):
         return line
 
     def read_buffer(self, nbytes=None):
+        """
+        Read from buffer.
+
+        Parameters
+        ----------
+        nbytes : int, optional
+            maximum number of bytes read
+        """
         cdef:
             int64_t c_nbytes
             int64_t bytes_read = 0
@@ -602,6 +610,14 @@ cdef class NativeFile(_Weakrefable):
         raise UnsupportedOperation()
 
     def writelines(self, lines):
+        """
+        Write lines to the file.
+
+        Parameters
+        ----------
+        lines : iterable
+            Iterable of bytes-like objects or exporters of buffer protocol
+        """
         self._assert_writable()
 
         for line in lines:
@@ -865,12 +881,35 @@ cdef class PythonFile(NativeFile):
             self.is_writable = True
 
     def truncate(self, pos=None):
+        """
+        Parameters
+        ----------
+        pos : int, optional
+        """
         self.handle.truncate(pos)
 
     def readline(self, size=None):
+        """
+        Read and return a line of bytes from the file.
+
+        If size is specified, read at most size bytes.
+
+        Parameters
+        ----------
+        size : int
+            Maximum number of bytes read
+        """
         return self.handle.readline(size)
 
     def readlines(self, hint=None):
+        """
+        Read lines of the file.
+
+        Parameters
+        ----------
+        hint : int
+            Maximum number of bytes read until we stop
+        """
         return self.handle.readlines(hint)
 
 
@@ -1146,16 +1185,31 @@ cdef class FixedSizeBufferWriter(NativeFile):
         self.is_writable = True
 
     def set_memcopy_threads(self, int num_threads):
+        """
+        Parameters
+        ----------
+        num_threads : int
+        """
         cdef CFixedSizeBufferWriter* writer = \
             <CFixedSizeBufferWriter*> self.output_stream.get()
         writer.set_memcopy_threads(num_threads)
 
     def set_memcopy_blocksize(self, int64_t blocksize):
+        """
+        Parameters
+        ----------
+        blocksize : int64
+        """
         cdef CFixedSizeBufferWriter* writer = \
             <CFixedSizeBufferWriter*> self.output_stream.get()
         writer.set_memcopy_blocksize(blocksize)
 
     def set_memcopy_threshold(self, int64_t threshold):
+        """
+        Parameters
+        ----------
+        threshold : int64
+        """
         cdef CFixedSizeBufferWriter* writer = \
             <CFixedSizeBufferWriter*> self.output_stream.get()
         writer.set_memcopy_threshold(threshold)
diff --git a/python/pyarrow/scalar.pxi b/python/pyarrow/scalar.pxi
index aff1c311abbfb..e19807ba56ee1 100644
--- a/python/pyarrow/scalar.pxi
+++ b/python/pyarrow/scalar.pxi
@@ -123,6 +123,15 @@ cdef class Scalar(_Weakrefable):
         return str(self.as_py())
 
     def equals(self, Scalar other not None):
+        """
+        Parameters
+        ----------
+        other : pyarrow.Scalar
+
+        Returns
+        -------
+        bool
+        """
         return self.wrapped.get().Equals(other.unwrap().get()[0])
 
     def __eq__(self, other):
diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index f08162089b8fa..2eae38485dca4 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -160,6 +160,17 @@ cdef class ChunkedArray(_PandasConvertible):
         return frombytes(result, safe=True)
 
     def format(self, **kwargs):
+        """
+        DEPRECATED, use pyarrow.ChunkedArray.to_string
+
+        Parameters
+        ----------
+        **kwargs : dict
+
+        Returns
+        -------
+        str
+        """
         import warnings
         warnings.warn('ChunkedArray.format is deprecated, '
                       'use ChunkedArray.to_string')
diff --git a/python/pyarrow/tensor.pxi b/python/pyarrow/tensor.pxi
index ba732879aadca..1afce7f4a1015 100644
--- a/python/pyarrow/tensor.pxi
+++ b/python/pyarrow/tensor.pxi
@@ -316,6 +316,17 @@ shape: {0.shape}""".format(self)
     def from_dense_numpy(cls, obj, dim_names=None):
         """
         Convert numpy.ndarray to arrow::SparseCOOTensor
+
+        Parameters
+        ----------
+        obj : numpy.ndarray
+            Data used to populate the rows.
+        dim_names : list[str], optional
+            Names of the dimensions.
+
+        Returns
+        -------
+        pyarrow.SparseCOOTensor
         """
         return cls.from_tensor(Tensor.from_numpy(obj, dim_names=dim_names))
 
@@ -549,6 +560,18 @@ shape: {0.shape}""".format(self)
         return self.stp.size()
 
     def dim_name(self, i):
+        """
+        Returns the name of the i-th tensor dimension.
+
+        Parameters
+        ----------
+        i : int
+            The physical index of the tensor dimension.
+
+        Returns
+        -------
+        str
+        """
         return frombytes(self.stp.dim_name(i))
 
     @property
@@ -601,6 +624,10 @@ shape: {0.shape}""".format(self)
             The dense numpy array that should be converted.
         dim_names : list, optional
             The names of the dimensions.
+
+        Returns
+        -------
+        pyarrow.SparseCSRMatrix
         """
         return cls.from_tensor(Tensor.from_numpy(obj, dim_names=dim_names))
 
@@ -781,6 +808,18 @@ shape: {0.shape}""".format(self)
         return self.stp.size()
 
     def dim_name(self, i):
+        """
+        Returns the name of the i-th tensor dimension.
+
+        Parameters
+        ----------
+        i : int
+            The physical index of the tensor dimension.
+
+        Returns
+        -------
+        str
+        """
         return frombytes(self.stp.dim_name(i))
 
     @property
@@ -816,6 +855,17 @@ shape: {0.shape}""".format(self)
     def from_dense_numpy(cls, obj, dim_names=None):
         """
         Convert numpy.ndarray to arrow::SparseCSCMatrix
+
+        Parameters
+        ----------
+        obj : numpy.ndarray
+            Data used to populate the rows.
+        dim_names : list[str], optional
+            Names of the dimensions.
+
+        Returns
+        -------
+        pyarrow.SparseCSCMatrix
         """
         return cls.from_tensor(Tensor.from_numpy(obj, dim_names=dim_names))
 
@@ -997,6 +1047,18 @@ shape: {0.shape}""".format(self)
         return self.stp.size()
 
     def dim_name(self, i):
+        """
+        Returns the name of the i-th tensor dimension.
+
+        Parameters
+        ----------
+        i : int
+            The physical index of the tensor dimension.
+
+        Returns
+        -------
+        str
+        """
         return frombytes(self.stp.dim_name(i))
 
     @property
@@ -1040,6 +1102,17 @@ shape: {0.shape}""".format(self)
     def from_dense_numpy(cls, obj, dim_names=None):
         """
         Convert numpy.ndarray to arrow::SparseCSFTensor
+
+        Parameters
+        ----------
+        obj : numpy.ndarray
+            Data used to populate the rows.
+        dim_names : list[str], optional
+            Names of the dimensions.
+
+        Returns
+        -------
+        pyarrow.SparseCSFTensor
         """
         return cls.from_tensor(Tensor.from_numpy(obj, dim_names=dim_names))
 
@@ -1190,6 +1263,18 @@ shape: {0.shape}""".format(self)
         return self.stp.size()
 
     def dim_name(self, i):
+        """
+        Returns the name of the i-th tensor dimension.
+
+        Parameters
+        ----------
+        i : int
+            The physical index of the tensor dimension.
+
+        Returns
+        -------
+        str
+        """
         return frombytes(self.stp.dim_name(i))
 
     @property
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index 12ad2fc4b6f60..f2dd59a0f1ad8 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -199,6 +199,15 @@ cdef class DataType(_Weakrefable):
         self.pep3118_format = _datatype_to_pep3118(self.type)
 
     cpdef Field field(self, i):
+        """
+        Parameters
+        ----------
+        i : int
+
+        Returns
+        -------
+        pyarrow.Field
+        """
         if not isinstance(i, int):
             raise TypeError(f"Expected int index, got type '{type(i)}'")
         cdef int index = <int> _normalize_index(i, self.type.num_fields())
@@ -1886,6 +1895,15 @@ cdef class KeyValueMetadata(_Metadata, Mapping):
         return self.wrapped
 
     def equals(self, KeyValueMetadata other):
+        """
+        Parameters
+        ----------
+        other : pyarrow.KeyValueMetadata
+
+        Returns
+        -------
+        bool
+        """
         return self.metadata.Equals(deref(other.wrapped))
 
     def __repr__(self):
@@ -1925,9 +1943,27 @@ cdef class KeyValueMetadata(_Metadata, Mapping):
         return KeyValueMetadata, (list(self.items()),)
 
     def key(self, i):
+        """
+        Parameters
+        ----------
+        i : int
+
+        Returns
+        -------
+        byte
+        """
         return self.metadata.key(i)
 
     def value(self, i):
+        """
+        Parameters
+        ----------
+        i : int
+
+        Returns
+        -------
+        byte
+        """
         return self.metadata.value(i)
 
     def keys(self):
@@ -1943,6 +1979,15 @@ cdef class KeyValueMetadata(_Metadata, Mapping):
             yield (self.metadata.key(i), self.metadata.value(i))
 
     def get_all(self, key):
+        """
+        Parameters
+        ----------
+        key : str
+
+        Returns
+        -------
+        list[byte]
+        """
         key = tobytes(key)
         return [v for k, v in self.items() if k == key]
 

From 9fea4eedf5ceb06943d6443d08b00bc2fd248226 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 18 Aug 2023 17:10:07 +0900
Subject: [PATCH 186/749] GH-37143: [GLib][FlightSQL] Add support for prepared
 INSERT (#37196)

### Rationale for this change

Prepared INSERT is useful for large INSERT.

### What changes are included in this PR?

Sorry. This is too large I thought.

Core bindings are the followings:

* `GAFLightSQLPreparedStatement`
* `gaflightsql_client_prepare()`

Others are for writing test of them. We need to implement a test server for prepared INSERT. Others are for it.

An exception is `ruby/red-arrow-flight-sql/lib/` change. It's for convenient API for `gaflightsql_client_prepare()`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37143

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/arrow-flight-glib/client.cpp           |  18 +-
 c_glib/arrow-flight-glib/client.hpp           |   4 +-
 c_glib/arrow-flight-glib/common.cpp           |  23 +-
 c_glib/arrow-flight-glib/server.cpp           |  57 ++
 c_glib/arrow-flight-glib/server.h             |  17 +
 c_glib/arrow-flight-glib/server.hpp           |   8 +
 c_glib/arrow-flight-sql-glib/client.cpp       | 383 ++++++++++-
 c_glib/arrow-flight-sql-glib/client.h         |  70 ++
 c_glib/arrow-flight-sql-glib/client.hpp       |  11 +-
 c_glib/arrow-flight-sql-glib/server.cpp       | 611 +++++++++++++++++-
 c_glib/arrow-flight-sql-glib/server.h         | 151 +++++
 c_glib/arrow-flight-sql-glib/server.hpp       |  21 +
 c_glib/arrow-glib/version.h.in                |  23 +
 .../arrow-flight-sql-glib-docs.xml            |   8 +
 c_glib/test/flight-sql/test-client.rb         |  29 +
 .../test-create-prepared-statement-result.rb  |  47 ++
 c_glib/test/helper/buildable.rb               |  10 +
 c_glib/test/helper/flight-sql-server.rb       |  26 +
 .../lib/arrow-flight-sql/client.rb            |  34 +
 .../lib/arrow-flight-sql/loader.rb            |   1 +
 .../test/helper/server.rb                     |  26 +
 ruby/red-arrow-flight-sql/test/test-client.rb |  21 +
 22 files changed, 1574 insertions(+), 25 deletions(-)
 create mode 100644 c_glib/test/flight-sql/test-create-prepared-statement-result.rb
 create mode 100644 ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb

diff --git a/c_glib/arrow-flight-glib/client.cpp b/c_glib/arrow-flight-glib/client.cpp
index 7097195f5f92b..65bc2d56a51f6 100644
--- a/c_glib/arrow-flight-glib/client.cpp
+++ b/c_glib/arrow-flight-glib/client.cpp
@@ -689,16 +689,14 @@ gaflight_client_do_get(GAFlightClient *client,
   if (options) {
     flight_options = gaflight_call_options_get_raw(options);
   }
-  std::unique_ptr<arrow::flight::FlightStreamReader> flight_reader;
   auto result = flight_client->DoGet(*flight_options, *flight_ticket);
-  auto status = std::move(result).Value(&flight_reader);
-  if (garrow::check(error,
-                    status,
-                    "[flight-client][do-get]")) {
-    return gaflight_stream_reader_new_raw(flight_reader.release());
-  } else {
-    return NULL;
+  if (!garrow::check(error,
+                     result,
+                     "[flight-client][do-get]")) {
+    return nullptr;
   }
+  auto flight_reader = std::move(*result);
+  return gaflight_stream_reader_new_raw(flight_reader.release(), TRUE);
 }
 
 
@@ -707,11 +705,13 @@ G_END_DECLS
 
 GAFlightStreamReader *
 gaflight_stream_reader_new_raw(
-  arrow::flight::FlightStreamReader *flight_reader)
+  arrow::flight::FlightStreamReader *flight_reader,
+  gboolean is_owner)
 {
   return GAFLIGHT_STREAM_READER(
     g_object_new(GAFLIGHT_TYPE_STREAM_READER,
                  "reader", flight_reader,
+                 "is-owner", is_owner,
                  NULL));
 }
 
diff --git a/c_glib/arrow-flight-glib/client.hpp b/c_glib/arrow-flight-glib/client.hpp
index 28d15ef2c404f..b6b768b8d3197 100644
--- a/c_glib/arrow-flight-glib/client.hpp
+++ b/c_glib/arrow-flight-glib/client.hpp
@@ -25,7 +25,9 @@
 
 
 GAFlightStreamReader *
-gaflight_stream_reader_new_raw(arrow::flight::FlightStreamReader *flight_reader);
+gaflight_stream_reader_new_raw(
+  arrow::flight::FlightStreamReader *flight_reader,
+  gboolean is_owner);
 
 arrow::flight::FlightCallOptions *
 gaflight_call_options_get_raw(GAFlightCallOptions *options);
diff --git a/c_glib/arrow-flight-glib/common.cpp b/c_glib/arrow-flight-glib/common.cpp
index 952f7ec6bc1fc..5aee3483032ae 100644
--- a/c_glib/arrow-flight-glib/common.cpp
+++ b/c_glib/arrow-flight-glib/common.cpp
@@ -1223,10 +1223,12 @@ gaflight_stream_chunk_get_metadata(GAFlightStreamChunk *chunk)
 
 typedef struct GAFlightRecordBatchReaderPrivate_ {
   arrow::flight::MetadataRecordBatchReader *reader;
+  bool is_owner;
 } GAFlightRecordBatchReaderPrivate;
 
 enum {
   PROP_READER = 1,
+  PROP_IS_OWNER,
 };
 
 G_DEFINE_TYPE_WITH_PRIVATE(GAFlightRecordBatchReader,
@@ -1242,9 +1244,9 @@ static void
 gaflight_record_batch_reader_finalize(GObject *object)
 {
   auto priv = GAFLIGHT_RECORD_BATCH_READER_GET_PRIVATE(object);
-
-  delete priv->reader;
-
+  if (priv->is_owner) {
+    delete priv->reader;
+  }
   G_OBJECT_CLASS(gaflight_info_parent_class)->finalize(object);
 }
 
@@ -1262,6 +1264,9 @@ gaflight_record_batch_reader_set_property(GObject *object,
       static_cast<arrow::flight::MetadataRecordBatchReader *>(
         g_value_get_pointer(value));
     break;
+  case PROP_IS_OWNER:
+    priv->is_owner = g_value_get_boolean(value);
+    break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
     break;
@@ -1283,11 +1288,19 @@ gaflight_record_batch_reader_class_init(GAFlightRecordBatchReaderClass *klass)
 
   GParamSpec *spec;
   spec = g_param_spec_pointer("reader",
-                              "Reader",
-                              "The raw arrow::flight::MetadataRecordBatchReader *",
+                              nullptr,
+                              nullptr,
                               static_cast<GParamFlags>(G_PARAM_WRITABLE |
                                                        G_PARAM_CONSTRUCT_ONLY));
   g_object_class_install_property(gobject_class, PROP_READER, spec);
+
+  spec = g_param_spec_boolean("is-owner",
+                              nullptr,
+                              nullptr,
+                              TRUE,
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_IS_OWNER, spec);
 }
 
 /**
diff --git a/c_glib/arrow-flight-glib/server.cpp b/c_glib/arrow-flight-glib/server.cpp
index 0df710df6f319..53ecbf6e08db5 100644
--- a/c_glib/arrow-flight-glib/server.cpp
+++ b/c_glib/arrow-flight-glib/server.cpp
@@ -41,6 +41,10 @@ G_BEGIN_DECLS
  * IPC payloads to be sent in `FlightData` protobuf messages by
  * #GArrowRecordBatchReader`.
  *
+ * #GAFlightMessageReader is a class for IPC payloads uploaded by a
+ * client. Also allows reading application-defined metadata via the
+ * Flight protocol.
+ *
  * #GAFlightServerAuthSender is a class for sending messages to the
  * client during an authentication handshake.
  *
@@ -258,6 +262,37 @@ gaflight_record_batch_stream_new(GArrowRecordBatchReader *reader,
 }
 
 
+G_DEFINE_TYPE(GAFlightMessageReader,
+              gaflight_message_reader,
+              GAFLIGHT_TYPE_RECORD_BATCH_READER)
+
+static void
+gaflight_message_reader_init(GAFlightMessageReader *object)
+{
+}
+
+static void
+gaflight_message_reader_class_init(GAFlightMessageReaderClass *klass)
+{
+}
+
+/**
+ * gaflight_message_reader_get_descriptor:
+ * @reader: A #GAFlightMessageReader.
+ *
+ * Returns: (transfer full): The descriptor for this upload.
+ *
+ * Since: 14.0.0
+ */
+GAFlightDescriptor *
+gaflight_message_reader_get_descriptor(GAFlightMessageReader *reader)
+{
+  auto flight_reader = gaflight_message_reader_get_raw(reader);
+  const auto &flight_descriptor = flight_reader->descriptor();
+  return gaflight_descriptor_new_raw(&flight_descriptor);
+}
+
+
 typedef struct GAFlightServerCallContextPrivate_ {
   arrow::flight::ServerCallContext *call_context;
 } GAFlightServerCallContextPrivate;
@@ -1215,6 +1250,28 @@ gaflight_data_stream_get_raw(GAFlightDataStream *stream)
   return priv->stream;
 }
 
+
+GAFlightMessageReader *
+gaflight_message_reader_new_raw(
+  arrow::flight::FlightMessageReader *flight_reader,
+  gboolean is_owner)
+{
+  return GAFLIGHT_MESSAGE_READER(
+    g_object_new(GAFLIGHT_TYPE_MESSAGE_READER,
+                 "reader", flight_reader,
+                 "is-owner", is_owner,
+                 NULL));
+}
+
+arrow::flight::FlightMessageReader *
+gaflight_message_reader_get_raw(GAFlightMessageReader *reader)
+{
+  auto flight_reader =
+    gaflight_record_batch_reader_get_raw(GAFLIGHT_RECORD_BATCH_READER(reader));
+  return static_cast<arrow::flight::FlightMessageReader *>(flight_reader);
+}
+
+
 GAFlightServerCallContext *
 gaflight_server_call_context_new_raw(
   const arrow::flight::ServerCallContext *flight_call_context)
diff --git a/c_glib/arrow-flight-glib/server.h b/c_glib/arrow-flight-glib/server.h
index 3ad93d05d28c3..7fa0dcf878000 100644
--- a/c_glib/arrow-flight-glib/server.h
+++ b/c_glib/arrow-flight-glib/server.h
@@ -55,6 +55,23 @@ gaflight_record_batch_stream_new(GArrowRecordBatchReader *reader,
                                  GArrowWriteOptions *options);
 
 
+#define GAFLIGHT_TYPE_MESSAGE_READER            \
+  (gaflight_message_reader_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightMessageReader,
+                         gaflight_message_reader,
+                         GAFLIGHT,
+                         MESSAGE_READER,
+                         GAFlightRecordBatchReader)
+struct _GAFlightMessageReaderClass
+{
+  GAFlightRecordBatchReaderClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+GAFlightDescriptor *
+gaflight_message_reader_get_descriptor(GAFlightMessageReader *reader);
+
+
 #define GAFLIGHT_TYPE_SERVER_CALL_CONTEXT       \
   (gaflight_server_call_context_get_type())
 G_DECLARE_DERIVABLE_TYPE(GAFlightServerCallContext,
diff --git a/c_glib/arrow-flight-glib/server.hpp b/c_glib/arrow-flight-glib/server.hpp
index 4cd9b4cf3444a..6b273dc9e5a8f 100644
--- a/c_glib/arrow-flight-glib/server.hpp
+++ b/c_glib/arrow-flight-glib/server.hpp
@@ -27,6 +27,14 @@
 arrow::flight::FlightDataStream *
 gaflight_data_stream_get_raw(GAFlightDataStream *stream);
 
+GAFlightMessageReader *
+gaflight_message_reader_new_raw(
+  arrow::flight::FlightMessageReader *flight_reader,
+  gboolean is_owner);
+arrow::flight::FlightMessageReader *
+gaflight_message_reader_get_raw(GAFlightMessageReader *reader);
+
+
 GAFlightServerCallContext *
 gaflight_server_call_context_new_raw(
   const arrow::flight::ServerCallContext *flight_call_context);
diff --git a/c_glib/arrow-flight-sql-glib/client.cpp b/c_glib/arrow-flight-sql-glib/client.cpp
index f05319532c215..8e1cf11549710 100644
--- a/c_glib/arrow-flight-sql-glib/client.cpp
+++ b/c_glib/arrow-flight-sql-glib/client.cpp
@@ -32,11 +32,327 @@ G_BEGIN_DECLS
  *
  * #GAFlightSQLClient is a class for Apache Arrow Flight SQL client.
  *
+ * #GAFlightSQLPreparedStatement is a class for prepared statement.
+ *
  * Since: 9.0.0
  */
 
+struct GAFlightSQLPreparedStatementPrivate {
+  std::shared_ptr<arrow::flight::sql::PreparedStatement> statement;
+  GAFlightSQLClient *client;
+};
+
+enum {
+  PROP_STATEMENT = 1,
+  PROP_PREPARED_STATEMENT_CLIENT,
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(GAFlightSQLPreparedStatement,
+                           gaflightsql_prepared_statement,
+                           G_TYPE_OBJECT)
+
+#define GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object)      \
+  static_cast<GAFlightSQLPreparedStatementPrivate *>(           \
+    gaflightsql_prepared_statement_get_instance_private(        \
+      GAFLIGHTSQL_PREPARED_STATEMENT(object)))
+
+static void
+gaflightsql_prepared_statement_dispose(GObject *object)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object);
+
+  if (priv->client) {
+    g_object_unref(priv->client);
+    priv->client = nullptr;
+  }
+
+  G_OBJECT_CLASS(gaflightsql_prepared_statement_parent_class)->dispose(object);
+}
+
+static void
+gaflightsql_prepared_statement_finalize(GObject *object)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object);
+  priv->statement.~shared_ptr();
+  G_OBJECT_CLASS(gaflightsql_prepared_statement_parent_class)->finalize(object);
+}
+
+static void
+gaflightsql_prepared_statement_set_property(GObject *object,
+                                            guint prop_id,
+                                            const GValue *value,
+                                            GParamSpec *pspec)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_STATEMENT:
+    priv->statement =
+      *static_cast<std::shared_ptr<arrow::flight::sql::PreparedStatement> *>(
+        g_value_get_pointer(value));
+    break;
+  case PROP_PREPARED_STATEMENT_CLIENT:
+    priv->client = GAFLIGHTSQL_CLIENT(g_value_dup_object(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+gaflightsql_prepared_statement_get_property(GObject *object,
+                                            guint prop_id,
+                                            GValue *value,
+                                            GParamSpec *pspec)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_PREPARED_STATEMENT_CLIENT:
+    g_value_set_object(value, priv->client);
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+gaflightsql_prepared_statement_init(GAFlightSQLPreparedStatement *object)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(object);
+  new(&priv->statement) std::shared_ptr<arrow::flight::sql::PreparedStatement>;
+}
+
+static void
+gaflightsql_prepared_statement_class_init(
+  GAFlightSQLPreparedStatementClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+
+  gobject_class->dispose = gaflightsql_prepared_statement_dispose;
+  gobject_class->finalize = gaflightsql_prepared_statement_finalize;
+  gobject_class->set_property = gaflightsql_prepared_statement_set_property;
+  gobject_class->get_property = gaflightsql_prepared_statement_get_property;
+
+  GParamSpec *spec;
+  spec = g_param_spec_pointer("statement",
+                              nullptr,
+                              nullptr,
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_STATEMENT, spec);
+
+  /**
+   * GAFlightSQLPreparedStatement:client:
+   *
+   * The underlying Flight SQL client.
+   *
+   * Since: 14.0.0
+   */
+  spec = g_param_spec_object("client",
+                             nullptr,
+                             nullptr,
+                             GAFLIGHTSQL_TYPE_CLIENT,
+                             static_cast<GParamFlags>(G_PARAM_READWRITE |
+                                                      G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class,
+                                  PROP_PREPARED_STATEMENT_CLIENT,
+                                  spec);
+}
+
+/**
+ * gaflightsql_prepared_statement_execute:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ * @options: (nullable): A #GAFlightCallOptions.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: (nullable) (transfer full): The #GAFlightInfo describing
+ *   where to access the dataset on success, %NULL on error.
+ *
+ * Since: 14.0.0
+ */
+GAFlightInfo *
+gaflightsql_prepared_statement_execute(GAFlightSQLPreparedStatement *statement,
+                                       GAFlightCallOptions *options,
+                                       GError **error)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  arrow::flight::FlightCallOptions flight_default_options;
+  auto flight_options = &flight_default_options;
+  if (options) {
+    flight_options = gaflight_call_options_get_raw(options);
+  }
+  auto result = flight_sql_statement->Execute(*flight_options);
+  if (!garrow::check(error,
+                     result,
+                     "[flight-sql-prepared-statement][execute]")) {
+    return nullptr;
+  }
+  auto flight_info = std::move(*result);
+  return gaflight_info_new_raw(flight_info.release());
+}
+
+/**
+ * gaflightsql_prepared_statement_execute_update:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ * @options: (nullable): A #GAFlightCallOptions.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: The number of changed records.
+ *
+ * Since: 14.0.0
+ */
+gint64
+gaflightsql_prepared_statement_execute_update(
+  GAFlightSQLPreparedStatement *statement,
+  GAFlightCallOptions *options,
+  GError **error)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  arrow::flight::FlightCallOptions flight_default_options;
+  auto flight_options = &flight_default_options;
+  if (options) {
+    flight_options = gaflight_call_options_get_raw(options);
+  }
+  auto result = flight_sql_statement->ExecuteUpdate(*flight_options);
+  if (!garrow::check(error,
+                     result,
+                     "[flight-sql-prepared-statement][execute-update]")) {
+    return 0;
+  }
+  return *result;
+}
+
+/**
+ * gaflightsql_prepared_statement_get_parameter_schema:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ *
+ * Returns: (nullable) (transfer full): The #GArrowSchema for parameter.
+ *
+ * Since: 14.0.0
+ */
+GArrowSchema *
+gaflightsql_prepared_statement_get_parameter_schema(
+  GAFlightSQLPreparedStatement *statement)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  auto arrow_schema = flight_sql_statement->parameter_schema();
+  return garrow_schema_new_raw(&arrow_schema);
+}
+
+/**
+ * gaflightsql_prepared_statement_get_dataset_schema:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ *
+ * Returns: (nullable) (transfer full): The #GArrowSchema for dataset.
+ *
+ * Since: 14.0.0
+ */
+GArrowSchema *
+gaflightsql_prepared_statement_get_dataset_schema(
+  GAFlightSQLPreparedStatement *statement)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  auto arrow_schema = flight_sql_statement->dataset_schema();
+  return garrow_schema_new_raw(&arrow_schema);
+}
+
+/**
+ * gaflightsql_prepared_statement_set_record_batch:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ * @record_batch: A #GArrowRecordBatch that contains the parameters that
+ *   will be bound.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE otherwise.
+ *
+ * Since: 14.0.0
+ */
+gboolean
+gaflightsql_prepared_statement_set_record_batch(
+  GAFlightSQLPreparedStatement *statement,
+  GArrowRecordBatch *record_batch,
+  GError **error)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  auto arrow_record_batch = garrow_record_batch_get_raw(record_batch);
+  return garrow::check(error,
+                       flight_sql_statement->SetParameters(arrow_record_batch),
+                       "[flight-sql-prepared-statement][set-record-batch]");
+}
+
+/**
+ * gaflightsql_prepared_statement_set_record_batch_reader:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ * @reader: A #GArrowRecordBatchReader that contains the parameters that
+ *   will be bound.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE otherwise.
+ *
+ * Since: 14.0.0
+ */
+gboolean
+gaflightsql_prepared_statement_set_record_batch_reader(
+  GAFlightSQLPreparedStatement *statement,
+  GArrowRecordBatchReader *reader,
+  GError **error)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  auto arrow_reader = garrow_record_batch_reader_get_raw(reader);
+  return garrow::check(error,
+                       flight_sql_statement->SetParameters(arrow_reader),
+                       "[flight-sql-prepared-statement][set-record-batch-reader]");
+}
+
+/**
+ * gaflightsql_prepared_statement_close:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ * @options: (nullable): A #GAFlightCallOptions.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: %TRUE on success, %FALSE otherwise.
+ *
+ * After this, the prepared statement may not be used anymore.
+ *
+ * Since: 14.0.0
+ */
+gboolean
+gaflightsql_prepared_statement_close(GAFlightSQLPreparedStatement *statement,
+                                     GAFlightCallOptions *options,
+                                     GError **error)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  arrow::flight::FlightCallOptions flight_default_options;
+  auto flight_options = &flight_default_options;
+  if (options) {
+    flight_options = gaflight_call_options_get_raw(options);
+  }
+  return garrow::check(error,
+                       flight_sql_statement->Close(*flight_options),
+                       "[flight-sql-prepared-statement][close]");
+}
+
+/**
+ * gaflightsql_prepared_statement_is_closed:
+ * @statement: A #GAFlightSQLPreparedStatement.
+ *
+ * Returns: Whether the prepared statement is closed or not.
+ *
+ * Since: 14.0.0
+ */
+gboolean
+gaflightsql_prepared_statement_is_closed(GAFlightSQLPreparedStatement *statement)
+{
+  auto flight_sql_statement = gaflightsql_prepared_statement_get_raw(statement);
+  return flight_sql_statement->IsClosed();
+}
+
+
 struct GAFlightSQLClientPrivate {
-  arrow::flight::sql::FlightSqlClient* client;
+  arrow::flight::sql::FlightSqlClient *client;
   GAFlightClient *flight_client;
 };
 
@@ -273,20 +589,68 @@ gaflightsql_client_do_get(GAFlightSQLClient *client,
     return nullptr;
   }
   auto flight_reader = std::move(*result);
-  return gaflight_stream_reader_new_raw(flight_reader.release());
+  return gaflight_stream_reader_new_raw(flight_reader.release(), TRUE);
+}
+
+/**
+ * gaflightsql_client_prepare:
+ * @client: A #GAFlightSQLClient.
+ * @query: A query to be prepared in the UTF-8 format.
+ * @options: (nullable): A #GAFlightCallOptions.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: (nullable) (transfer full): The #GAFlightSQLPreparedStatement
+ *   on success, %NULL on error.
+ *
+ * Since: 14.0.0
+ */
+GAFlightSQLPreparedStatement *
+gaflightsql_client_prepare(GAFlightSQLClient *client,
+                           const gchar *query,
+                           GAFlightCallOptions *options,
+                           GError **error)
+{
+  auto flight_sql_client = gaflightsql_client_get_raw(client);
+  arrow::flight::FlightCallOptions flight_default_options;
+  auto flight_options = &flight_default_options;
+  if (options) {
+    flight_options = gaflight_call_options_get_raw(options);
+  }
+  auto result = flight_sql_client->Prepare(*flight_options, query);
+  if (!garrow::check(error,
+                     result,
+                     "[flight-sql-client][prepare]")) {
+    return nullptr;
+  }
+  auto flight_sql_statement = std::move(*result);
+  return gaflightsql_prepared_statement_new_raw(&flight_sql_statement,
+                                                client);
 }
 
 
 G_END_DECLS
 
 
-arrow::flight::sql::FlightSqlClient *
-gaflightsql_client_get_raw(GAFlightSQLClient *client)
+GAFlightSQLPreparedStatement *
+gaflightsql_prepared_statement_new_raw(
+  std::shared_ptr<arrow::flight::sql::PreparedStatement> *flight_sql_statement,
+  GAFlightSQLClient *client)
 {
-  auto priv = GAFLIGHTSQL_CLIENT_GET_PRIVATE(client);
-  return priv->client;
+  return GAFLIGHTSQL_PREPARED_STATEMENT(
+    g_object_new(GAFLIGHTSQL_TYPE_PREPARED_STATEMENT,
+                 "statement", flight_sql_statement,
+                 "client", client,
+                 nullptr));
+}
+
+std::shared_ptr<arrow::flight::sql::PreparedStatement>
+gaflightsql_prepared_statement_get_raw(GAFlightSQLPreparedStatement *statement)
+{
+  auto priv = GAFLIGHTSQL_PREPARED_STATEMENT_GET_PRIVATE(statement);
+  return priv->statement;
 }
 
+
 GAFlightSQLClient *
 gaflightsql_client_new_raw(
   arrow::flight::sql::FlightSqlClient *flight_sql_client,
@@ -298,3 +662,10 @@ gaflightsql_client_new_raw(
                  "flight_client", client,
                  nullptr));
 }
+
+arrow::flight::sql::FlightSqlClient *
+gaflightsql_client_get_raw(GAFlightSQLClient *client)
+{
+  auto priv = GAFLIGHTSQL_CLIENT_GET_PRIVATE(client);
+  return priv->client;
+}
diff --git a/c_glib/arrow-flight-sql-glib/client.h b/c_glib/arrow-flight-sql-glib/client.h
index 6374fece2209a..f2a025fef099b 100644
--- a/c_glib/arrow-flight-sql-glib/client.h
+++ b/c_glib/arrow-flight-sql-glib/client.h
@@ -24,6 +24,69 @@
 G_BEGIN_DECLS
 
 
+#define GAFLIGHTSQL_TYPE_PREPARED_STATEMENT     \
+  (gaflightsql_prepared_statement_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightSQLPreparedStatement,
+                         gaflightsql_prepared_statement,
+                         GAFLIGHTSQL,
+                         PREPARED_STATEMENT,
+                         GObject)
+struct _GAFlightSQLPreparedStatementClass
+{
+  GObjectClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+GAFlightInfo *
+gaflightsql_prepared_statement_execute(
+  GAFlightSQLPreparedStatement *statement,
+  GAFlightCallOptions *options,
+  GError **error);
+
+GARROW_AVAILABLE_IN_14_0
+gint64
+gaflightsql_prepared_statement_execute_update(
+  GAFlightSQLPreparedStatement *statement,
+  GAFlightCallOptions *options,
+  GError **error);
+
+GARROW_AVAILABLE_IN_14_0
+GArrowSchema *
+gaflightsql_prepared_statement_get_parameter_schema(
+  GAFlightSQLPreparedStatement *statement);
+
+GARROW_AVAILABLE_IN_14_0
+GArrowSchema *
+gaflightsql_prepared_statement_get_dataset_schema(
+  GAFlightSQLPreparedStatement *statement);
+
+GARROW_AVAILABLE_IN_14_0
+gboolean
+gaflightsql_prepared_statement_set_record_batch(
+  GAFlightSQLPreparedStatement *statement,
+  GArrowRecordBatch *record_batch,
+  GError **error);
+
+GARROW_AVAILABLE_IN_14_0
+gboolean
+gaflightsql_prepared_statement_set_record_batch_reader(
+  GAFlightSQLPreparedStatement *statement,
+  GArrowRecordBatchReader *reader,
+  GError **error);
+
+GARROW_AVAILABLE_IN_14_0
+gboolean
+gaflightsql_prepared_statement_close(
+  GAFlightSQLPreparedStatement *statement,
+  GAFlightCallOptions *options,
+  GError **error);
+
+GARROW_AVAILABLE_IN_14_0
+gboolean
+gaflightsql_prepared_statement_is_closed(
+  GAFlightSQLPreparedStatement *statement);
+
+
 #define GAFLIGHTSQL_TYPE_CLIENT (gaflightsql_client_get_type())
 G_DECLARE_DERIVABLE_TYPE(GAFlightSQLClient,
                          gaflightsql_client,
@@ -60,5 +123,12 @@ gaflightsql_client_do_get(GAFlightSQLClient *client,
                           GAFlightCallOptions *options,
                           GError **error);
 
+GARROW_AVAILABLE_IN_14_0
+GAFlightSQLPreparedStatement *
+gaflightsql_client_prepare(GAFlightSQLClient *client,
+                           const gchar *query,
+                           GAFlightCallOptions *options,
+                           GError **error);
+
 
 G_END_DECLS
diff --git a/c_glib/arrow-flight-sql-glib/client.hpp b/c_glib/arrow-flight-sql-glib/client.hpp
index d9c04e51088eb..09136f8819d52 100644
--- a/c_glib/arrow-flight-sql-glib/client.hpp
+++ b/c_glib/arrow-flight-sql-glib/client.hpp
@@ -24,9 +24,16 @@
 #include <arrow-flight-sql-glib/client.h>
 
 
-arrow::flight::sql::FlightSqlClient *
-gaflightsql_client_get_raw(GAFlightSQLClient *client);
+GAFlightSQLPreparedStatement *
+gaflightsql_prepared_statement_new_raw(
+  std::shared_ptr<arrow::flight::sql::PreparedStatement> *flight_sql_statement,
+  GAFlightSQLClient *client);
+std::shared_ptr<arrow::flight::sql::PreparedStatement>
+gaflightsql_prepared_statement_get_raw(GAFlightSQLPreparedStatement *statement);
+
 GAFlightSQLClient *
 gaflightsql_client_new_raw(
   arrow::flight::sql::FlightSqlClient *flight_sql_client,
   GAFlightClient *client);
+arrow::flight::sql::FlightSqlClient *
+gaflightsql_client_get_raw(GAFlightSQLClient *client);
diff --git a/c_glib/arrow-flight-sql-glib/server.cpp b/c_glib/arrow-flight-sql-glib/server.cpp
index 750dff2232c20..518b771732a0f 100644
--- a/c_glib/arrow-flight-sql-glib/server.cpp
+++ b/c_glib/arrow-flight-sql-glib/server.cpp
@@ -33,6 +33,18 @@ G_BEGIN_DECLS
  * @title: Server related classes
  * @include: arrow-flight-sql-glib/arrow-flight-sql-glib.h
  *
+ * #GAFlightSQLPreparedStatementUpdate is a class for a request
+ * that executes an update SQL prepared statement.
+ *
+ * #GAFlightSQLCreatePreparedStatementRequest is a class for a request
+ * that creates a SQL prepared statement.
+ *
+ * #GAFlightSQLCreatePreparedStatementResult is a class for a result
+ * of the request that creates a SQL prepared statement.
+ *
+ * #GAFlightSQLClosePreparedStatementRequest is a class for a request
+ * that closes a SQL prepared statement.
+ *
  * #GAFlightSQLServer is a class to develop an Apache Arrow Flight SQL
  * server.
  *
@@ -156,6 +168,41 @@ gaflightsql_statement_update_get_query(GAFlightSQLStatementUpdate *command)
 }
 
 
+G_DEFINE_TYPE(GAFlightSQLPreparedStatementUpdate,
+              gaflightsql_prepared_statement_update,
+              GAFLIGHTSQL_TYPE_COMMAND)
+
+static void
+gaflightsql_prepared_statement_update_init(
+  GAFlightSQLPreparedStatementUpdate *object)
+{
+}
+
+static void
+gaflightsql_prepared_statement_update_class_init(
+  GAFlightSQLPreparedStatementUpdateClass *klass)
+{
+}
+
+/**
+ * gaflightsql_prepared_statement_update_get_handle:
+ * @command: A #GAFlightSQLPreparedStatementUpdate.
+ *
+ * Returns: (transfer full): The server-generated opaque identifier
+ *   for the statement.
+ *
+ * Since: 14.0.0
+ */
+GBytes *
+gaflightsql_prepared_statement_update_get_handle(
+  GAFlightSQLPreparedStatementUpdate *command)
+{
+  auto update = gaflightsql_prepared_statement_update_get_raw(command);
+  return g_bytes_new_static(update->prepared_statement_handle.data(),
+                            update->prepared_statement_handle.size());
+}
+
+
 G_DEFINE_TYPE(GAFlightSQLStatementQueryTicket,
               gaflightsql_statement_query_ticket,
               GAFLIGHTSQL_TYPE_COMMAND)
@@ -221,6 +268,341 @@ gaflightsql_statement_query_ticket_get_handle(
 }
 
 
+struct GAFlightSQLCreatePreparedStatementRequestPrivate {
+  arrow::flight::sql::ActionCreatePreparedStatementRequest *request;
+};
+
+enum {
+  PROP_REQUEST = 1,
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(GAFlightSQLCreatePreparedStatementRequest,
+                           gaflightsql_create_prepared_statement_request,
+                           G_TYPE_OBJECT)
+
+#define GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(object) \
+  static_cast<GAFlightSQLCreatePreparedStatementRequestPrivate *>(      \
+    gaflightsql_create_prepared_statement_request_get_instance_private( \
+      GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST(object)))
+
+static void
+gaflightsql_create_prepared_statement_request_set_property(GObject *object,
+                                                           guint prop_id,
+                                                           const GValue *value,
+                                                           GParamSpec *pspec)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_REQUEST:
+    priv->request =
+      static_cast<arrow::flight::sql::ActionCreatePreparedStatementRequest *>(
+        g_value_get_pointer(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+gaflightsql_create_prepared_statement_request_init(
+  GAFlightSQLCreatePreparedStatementRequest *object)
+{
+}
+
+static void
+gaflightsql_create_prepared_statement_request_class_init(
+  GAFlightSQLCreatePreparedStatementRequestClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->set_property =
+    gaflightsql_create_prepared_statement_request_set_property;
+
+  GParamSpec *spec;
+  spec = g_param_spec_pointer("request",
+                              nullptr,
+                              nullptr,
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_REQUEST, spec);
+}
+
+/**
+ * gaflightsql_create_prepared_statement_request_get_query:
+ * @request: A #GAFlightSQLCreatePreparedStatementRequest.
+ *
+ * Returns: The SQL query to be prepared.
+ *
+ * Since: 14.0.0
+ */
+const gchar *
+gaflightsql_create_prepared_statement_request_get_query(
+  GAFlightSQLCreatePreparedStatementRequest *request)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(request);
+  return priv->request->query.c_str();
+}
+
+/**
+ * gaflightsql_create_prepared_statement_request_get_transaction_id:
+ * @request: A #GAFlightSQLCreatePreparedStatementRequest.
+ *
+ * Returns: The transaction ID, if specified (else a blank string).
+ *
+ * Since: 14.0.0
+ */
+const gchar *
+gaflightsql_create_prepared_statement_request_get_transaction_id(
+  GAFlightSQLCreatePreparedStatementRequest *request)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(request);
+  return priv->request->transaction_id.c_str();
+}
+
+
+struct GAFlightSQLCreatePreparedStatementResultPrivate {
+  arrow::flight::sql::ActionCreatePreparedStatementResult result;
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(GAFlightSQLCreatePreparedStatementResult,
+                           gaflightsql_create_prepared_statement_result,
+                           G_TYPE_OBJECT)
+
+#define GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(object) \
+  static_cast<GAFlightSQLCreatePreparedStatementResultPrivate *>(       \
+    gaflightsql_create_prepared_statement_result_get_instance_private(  \
+      GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT(object)))
+
+static void
+gaflightsql_create_prepared_statement_result_finalize(GObject *object)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(object);
+  priv->result.~ActionCreatePreparedStatementResult();
+  G_OBJECT_CLASS(gaflightsql_create_prepared_statement_result_parent_class)->finalize(object);
+}
+
+static void
+gaflightsql_create_prepared_statement_result_init(
+  GAFlightSQLCreatePreparedStatementResult *object)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(object);
+  new(&(priv->result)) arrow::flight::sql::ActionCreatePreparedStatementResult();
+}
+
+static void
+gaflightsql_create_prepared_statement_result_class_init(
+  GAFlightSQLCreatePreparedStatementResultClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->finalize =
+    gaflightsql_create_prepared_statement_result_finalize;
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_new:
+ *
+ * Returns:: The newly created #GAFlightSQLCreatePreparedStatementResult.
+ *
+ * Since: 14.0.0
+ */
+GAFlightSQLCreatePreparedStatementResult *
+gaflightsql_create_prepared_statement_result_new(void)
+{
+  return GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT(
+    g_object_new(GAFLIGHTSQL_TYPE_CREATE_PREPARED_STATEMENT_RESULT,
+                 nullptr));
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_set_dataset_schema:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ * @schema: A #GArrowSchema of dataset.
+ *
+ * Since: 14.0.0
+ */
+void
+gaflightsql_create_prepared_statement_result_set_dataset_schema(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GArrowSchema *schema)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  priv->result.dataset_schema = garrow_schema_get_raw(schema);
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_get_dataset_schema:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ *
+ * Returns: (nullable) (transfer full): The current dataset schema.
+ *
+ * Since: 14.0.0
+ */
+GArrowSchema *
+gaflightsql_create_prepared_statement_result_get_dataset_schema(
+  GAFlightSQLCreatePreparedStatementResult *result)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  if (!priv->result.dataset_schema) {
+    return nullptr;
+  }
+  return garrow_schema_new_raw(&(priv->result.dataset_schema));
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_set_parameter_schema:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ * @schema: A #GArrowSchema of parameter.
+ *
+ * Since: 14.0.0
+ */
+void
+gaflightsql_create_prepared_statement_result_set_parameter_schema(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GArrowSchema *schema)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  priv->result.parameter_schema = garrow_schema_get_raw(schema);
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_get_parameter_schema:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ *
+ * Returns: (nullable) (transfer full): The current parameter schema.
+ *
+ * Since: 14.0.0
+ */
+GArrowSchema *
+gaflightsql_create_prepared_statement_result_get_parameter_schema(
+  GAFlightSQLCreatePreparedStatementResult *result)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  if (!priv->result.parameter_schema) {
+    return nullptr;
+  }
+  return garrow_schema_new_raw(&(priv->result.parameter_schema));
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_set_handle:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ * @handle: A #GBytes for server-generated opaque identifier.
+ *
+ * Since: 14.0.0
+ */
+void
+gaflightsql_create_prepared_statement_result_set_handle(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GBytes *handle)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  size_t handle_size;
+  auto handle_data = g_bytes_get_data(handle, &handle_size);
+  priv->result.prepared_statement_handle =
+    std::string(static_cast<const char *>(handle_data), handle_size);
+}
+
+/**
+ * gaflightsql_create_prepared_statement_result_get_handle:
+ * @result: A #GAFlightSQLCreatePreparedStatementResult.
+ *
+ * Returns: (transfer full): The current server-generated opaque
+ *   identifier.
+ *
+ * Since: 14.0.0
+ */
+GBytes *
+gaflightsql_create_prepared_statement_result_get_handle(
+  GAFlightSQLCreatePreparedStatementResult *result)
+{
+  auto priv =
+    GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(result);
+  return g_bytes_new_static(priv->result.prepared_statement_handle.data(),
+                            priv->result.prepared_statement_handle.length());
+}
+
+
+struct GAFlightSQLClosePreparedStatementRequestPrivate {
+  arrow::flight::sql::ActionClosePreparedStatementRequest *request;
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(GAFlightSQLClosePreparedStatementRequest,
+                           gaflightsql_close_prepared_statement_request,
+                           G_TYPE_OBJECT)
+
+#define GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(object) \
+  static_cast<GAFlightSQLClosePreparedStatementRequestPrivate *>(      \
+    gaflightsql_close_prepared_statement_request_get_instance_private( \
+      GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST(object)))
+
+static void
+gaflightsql_close_prepared_statement_request_set_property(GObject *object,
+                                                          guint prop_id,
+                                                          const GValue *value,
+                                                          GParamSpec *pspec)
+{
+  auto priv = GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_REQUEST:
+    priv->request =
+      static_cast<arrow::flight::sql::ActionClosePreparedStatementRequest *>(
+        g_value_get_pointer(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
+
+static void
+gaflightsql_close_prepared_statement_request_init(
+  GAFlightSQLClosePreparedStatementRequest *object)
+{
+}
+
+static void
+gaflightsql_close_prepared_statement_request_class_init(
+  GAFlightSQLClosePreparedStatementRequestClass *klass)
+{
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->set_property =
+    gaflightsql_close_prepared_statement_request_set_property;
+
+  GParamSpec *spec;
+  spec = g_param_spec_pointer("request",
+                              nullptr,
+                              nullptr,
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_REQUEST, spec);
+}
+
+/**
+ * gaflightsql_close_prepared_statement_request_get_handle:
+ * @request: A #GAFlightSQLClosePreparedStatementRequest.
+ *
+ * Returns: (transfer full): The server-generated opaque identifier
+ *   for the statement.
+ *
+ * Since: 14.0.0
+ */
+GBytes *
+gaflightsql_close_prepared_statement_request_get_handle(
+  GAFlightSQLClosePreparedStatementRequest *request)
+{
+  auto priv = GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(request);
+  return g_bytes_new_static(priv->request->prepared_statement_handle.data(),
+                            priv->request->prepared_statement_handle.length());
+}
+
+
 G_END_DECLS
 namespace gaflightsql {
   class Server : public arrow::flight::sql::FlightSqlServerBase {
@@ -283,7 +665,7 @@ namespace gaflightsql {
     arrow::Result<int64_t>
     DoPutCommandStatementUpdate(
       const arrow::flight::ServerCallContext &context,
-      const arrow::flight::sql::StatementUpdate& command) override {
+      const arrow::flight::sql::StatementUpdate &command) override {
       auto gacontext = gaflight_server_call_context_new_raw(&context);
       auto gacommand = gaflightsql_statement_update_new_raw(&command);
       GError *gerror = nullptr;
@@ -303,6 +685,83 @@ namespace gaflightsql {
       return n_changed_records;
     }
 
+    arrow::Result<int64_t>
+    DoPutPreparedStatementUpdate(
+      const arrow::flight::ServerCallContext &context,
+      const arrow::flight::sql::PreparedStatementUpdate &command,
+      arrow::flight::FlightMessageReader *reader) override {
+      auto gacontext = gaflight_server_call_context_new_raw(&context);
+      auto gacommand = gaflightsql_prepared_statement_update_new_raw(&command);
+      auto gareader = gaflight_message_reader_new_raw(reader, FALSE);
+      GError *gerror = nullptr;
+      auto n_changed_records =
+        gaflightsql_server_do_put_prepared_statement_update(gaserver_,
+                                                            gacontext,
+                                                            gacommand,
+                                                            gareader,
+                                                            &gerror);
+      g_object_unref(gareader);
+      g_object_unref(gacommand);
+      g_object_unref(gacontext);
+      if (gerror) {
+        return garrow_error_to_status(
+          gerror,
+          arrow::StatusCode::UnknownError,
+          "[flight-sql-server][do-put-prepared-statement-update]");
+      }
+      return n_changed_records;
+    }
+
+    arrow::Result<arrow::flight::sql::ActionCreatePreparedStatementResult>
+    CreatePreparedStatement(
+      const arrow::flight::ServerCallContext &context,
+      const arrow::flight::sql::ActionCreatePreparedStatementRequest &request) override {
+      auto gacontext = gaflight_server_call_context_new_raw(&context);
+      auto garequest = gaflightsql_create_prepared_statement_request_new_raw(&request);
+      GError *gerror = nullptr;
+      auto garesult =
+        gaflightsql_server_create_prepared_statement(gaserver_,
+                                                     gacontext,
+                                                     garequest,
+                                                     &gerror);
+      g_object_unref(garequest);
+      g_object_unref(gacontext);
+      if (gerror) {
+        return garrow_error_to_status(
+          gerror,
+          arrow::StatusCode::UnknownError,
+          "[flight-sql-server][create-prepared-statement]");
+      }
+      auto garesult_priv =
+        GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_RESULT_GET_PRIVATE(garesult);
+      auto flightsql_result = garesult_priv->result;
+      g_object_unref(garesult);
+      return flightsql_result;
+    }
+
+    arrow::Status
+    ClosePreparedStatement(
+      const arrow::flight::ServerCallContext &context,
+      const arrow::flight::sql::ActionClosePreparedStatementRequest &request) override {
+      auto gacontext = gaflight_server_call_context_new_raw(&context);
+      auto garequest = gaflightsql_close_prepared_statement_request_new_raw(&request);
+      GError *gerror = nullptr;
+      gaflightsql_server_close_prepared_statement(gaserver_,
+                                                  gacontext,
+                                                  garequest,
+                                                  &gerror);
+      g_object_unref(garequest);
+      g_object_unref(gacontext);
+      if (gerror) {
+        return garrow_error_to_status(
+          gerror,
+          arrow::StatusCode::UnknownError,
+          "[flight-sql-server][close-prepared-statement]");
+      } else {
+        return arrow::Status::OK();
+      }
+    }
+
   private:
     GAFlightSQLServer *gaserver_;
   };
@@ -351,7 +810,6 @@ gaflightsql_server_finalize(GObject *object)
 {
   auto priv = GAFLIGHTSQL_SERVER_GET_PRIVATE(object);
   priv->server.~Server();
-
   G_OBJECT_CLASS(gaflightsql_server_parent_class)->finalize(object);
 }
 
@@ -463,6 +921,97 @@ gaflightsql_server_do_put_command_statement_update(
   return klass->do_put_command_statement_update(server, context, command, error);
 }
 
+/**
+ * gaflightsql_server_do_put_prepared_statement_update:
+ * @server: A #GAFlightServer.
+ * @context: A #GAFlightServerCallContext.
+ * @command: A #GAFlightSQLPreparedStatementUpdate.
+ * @reader: A #GAFlightMessageReader that reads uploaded record batches.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: The number of changed records.
+ *
+ * Since: 14.0.0
+ */
+gint64
+gaflightsql_server_do_put_prepared_statement_update(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLPreparedStatementUpdate *command,
+  GAFlightMessageReader *reader,
+  GError **error)
+{
+  auto klass = GAFLIGHTSQL_SERVER_GET_CLASS(server);
+  if (!(klass && klass->do_put_prepared_statement_update)) {
+    g_set_error(error,
+                GARROW_ERROR,
+                GARROW_ERROR_NOT_IMPLEMENTED,
+                "not implemented");
+    return 0;
+  }
+  return klass->do_put_prepared_statement_update(
+    server, context, command, reader, error);
+}
+
+/**
+ * gaflightsql_server_create_prepared_statement:
+ * @server: A #GAFlightServer.
+ * @context: A #GAFlightServerCallContext.
+ * @request: A #GAFlightSQLCreatePreparedStatementRequest.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Returns: (nullable) (transfer full): A
+ *   #GAFlightSQLCreatePreparedStatementResult containing the dataset
+ *   and parameter schemas and a handle for created statement on
+ *   success, %NULL on error.
+ *
+ * Since: 14.0.0
+ */
+GAFlightSQLCreatePreparedStatementResult *
+gaflightsql_server_create_prepared_statement(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLCreatePreparedStatementRequest *request,
+  GError **error)
+{
+  auto klass = GAFLIGHTSQL_SERVER_GET_CLASS(server);
+  if (!(klass && klass->create_prepared_statement)) {
+    g_set_error(error,
+                GARROW_ERROR,
+                GARROW_ERROR_NOT_IMPLEMENTED,
+                "not implemented");
+    return nullptr;
+  }
+  return klass->create_prepared_statement(server, context, request, error);
+}
+
+/**
+ * gaflightsql_server_close_prepared_statement:
+ * @server: A #GAFlightServer.
+ * @context: A #GAFlightServerCallContext.
+ * @request: A #GAFlightSQLClosePreparedStatementRequest.
+ * @error: (nullable): Return location for a #GError or %NULL.
+ *
+ * Since: 14.0.0
+ */
+void
+gaflightsql_server_close_prepared_statement(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLClosePreparedStatementRequest *request,
+  GError **error)
+{
+  auto klass = GAFLIGHTSQL_SERVER_GET_CLASS(server);
+  if (!(klass && klass->close_prepared_statement)) {
+    g_set_error(error,
+                GARROW_ERROR,
+                GARROW_ERROR_NOT_IMPLEMENTED,
+                "not implemented");
+    return;
+  }
+  return klass->close_prepared_statement(server, context, request, error);
+}
+
 
 G_END_DECLS
 
@@ -503,6 +1052,26 @@ gaflightsql_statement_update_get_raw(GAFlightSQLStatementUpdate *command)
 }
 
 
+GAFlightSQLPreparedStatementUpdate *
+gaflightsql_prepared_statement_update_new_raw(
+  const arrow::flight::sql::PreparedStatementUpdate *flight_command)
+{
+  return GAFLIGHTSQL_PREPARED_STATEMENT_UPDATE(
+    g_object_new(GAFLIGHTSQL_TYPE_PREPARED_STATEMENT_UPDATE,
+                 "command", flight_command,
+                 nullptr));
+}
+
+const arrow::flight::sql::PreparedStatementUpdate *
+gaflightsql_prepared_statement_update_get_raw(
+  GAFlightSQLPreparedStatementUpdate *command)
+{
+  auto priv = GAFLIGHTSQL_COMMAND_GET_PRIVATE(command);
+  return static_cast<const arrow::flight::sql::PreparedStatementUpdate *>(
+    priv->command);
+}
+
+
 GAFlightSQLStatementQueryTicket *
 gaflightsql_statement_query_ticket_new_raw(
   const arrow::flight::sql::StatementQueryTicket *flight_command)
@@ -521,3 +1090,41 @@ gaflightsql_statement_query_ticket_get_raw(
   return static_cast<const arrow::flight::sql::StatementQueryTicket *>(
     priv->command);
 }
+
+
+GAFlightSQLCreatePreparedStatementRequest *
+gaflightsql_create_prepared_statement_request_new_raw(
+  const arrow::flight::sql::ActionCreatePreparedStatementRequest *flight_request)
+{
+  return GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST(
+    g_object_new(GAFLIGHTSQL_TYPE_CREATE_PREPARED_STATEMENT_REQUEST,
+                 "request", flight_request,
+                 nullptr));
+}
+
+const arrow::flight::sql::ActionCreatePreparedStatementRequest *
+gaflightsql_create_prepared_statement_request_get_raw(
+  GAFlightSQLCreatePreparedStatementRequest *request)
+{
+  auto priv = GAFLIGHTSQL_CREATE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(request);
+  return priv->request;
+}
+
+
+GAFlightSQLClosePreparedStatementRequest *
+gaflightsql_close_prepared_statement_request_new_raw(
+  const arrow::flight::sql::ActionClosePreparedStatementRequest *flight_request)
+{
+  return GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST(
+    g_object_new(GAFLIGHTSQL_TYPE_CLOSE_PREPARED_STATEMENT_REQUEST,
+                 "request", flight_request,
+                 nullptr));
+}
+
+const arrow::flight::sql::ActionClosePreparedStatementRequest *
+gaflightsql_close_prepared_statement_request_get_raw(
+  GAFlightSQLClosePreparedStatementRequest *request)
+{
+  auto priv = GAFLIGHTSQL_CLOSE_PREPARED_STATEMENT_REQUEST_GET_PRIVATE(request);
+  return priv->request;
+}
diff --git a/c_glib/arrow-flight-sql-glib/server.h b/c_glib/arrow-flight-sql-glib/server.h
index 60e5b300d4e84..106b6e40db38f 100644
--- a/c_glib/arrow-flight-sql-glib/server.h
+++ b/c_glib/arrow-flight-sql-glib/server.h
@@ -68,6 +68,24 @@ const gchar *
 gaflightsql_statement_update_get_query(GAFlightSQLStatementUpdate *command);
 
 
+#define GAFLIGHTSQL_TYPE_PREPARED_STATEMENT_UPDATE      \
+  (gaflightsql_prepared_statement_update_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightSQLPreparedStatementUpdate,
+                         gaflightsql_prepared_statement_update,
+                         GAFLIGHTSQL,
+                         PREPARED_STATEMENT_UPDATE,
+                         GAFlightSQLCommand)
+struct _GAFlightSQLPreparedStatementUpdateClass
+{
+  GAFlightSQLCommandClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+GBytes *
+gaflightsql_prepared_statement_update_get_handle(
+  GAFlightSQLPreparedStatementUpdate *command);
+
+
 #define GAFLIGHTSQL_TYPE_STATEMENT_QUERY_TICKET         \
   (gaflightsql_statement_query_ticket_get_type())
 G_DECLARE_DERIVABLE_TYPE(GAFlightSQLStatementQueryTicket,
@@ -90,6 +108,91 @@ gaflightsql_statement_query_ticket_get_handle(
   GAFlightSQLStatementQueryTicket *command);
 
 
+#define GAFLIGHTSQL_TYPE_CREATE_PREPARED_STATEMENT_REQUEST      \
+  (gaflightsql_create_prepared_statement_request_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightSQLCreatePreparedStatementRequest,
+                         gaflightsql_create_prepared_statement_request,
+                         GAFLIGHTSQL,
+                         CREATE_PREPARED_STATEMENT_REQUEST,
+                         GObject)
+struct _GAFlightSQLCreatePreparedStatementRequestClass
+{
+  GObjectClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+const gchar *
+gaflightsql_create_prepared_statement_request_get_query(
+  GAFlightSQLCreatePreparedStatementRequest *request);
+
+GARROW_AVAILABLE_IN_14_0
+const gchar *
+gaflightsql_create_prepared_statement_request_get_transaction_id(
+  GAFlightSQLCreatePreparedStatementRequest *request);
+
+
+#define GAFLIGHTSQL_TYPE_CREATE_PREPARED_STATEMENT_RESULT       \
+  (gaflightsql_create_prepared_statement_result_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightSQLCreatePreparedStatementResult,
+                         gaflightsql_create_prepared_statement_result,
+                         GAFLIGHTSQL,
+                         CREATE_PREPARED_STATEMENT_RESULT,
+                         GObject)
+struct _GAFlightSQLCreatePreparedStatementResultClass
+{
+  GObjectClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+GAFlightSQLCreatePreparedStatementResult *
+gaflightsql_create_prepared_statement_result_new(void);
+GARROW_AVAILABLE_IN_14_0
+void
+gaflightsql_create_prepared_statement_result_set_dataset_schema(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GArrowSchema *schema);
+GARROW_AVAILABLE_IN_14_0
+GArrowSchema *
+gaflightsql_create_prepared_statement_result_get_dataset_schema(
+  GAFlightSQLCreatePreparedStatementResult *result);
+GARROW_AVAILABLE_IN_14_0
+void
+gaflightsql_create_prepared_statement_result_set_parameter_schema(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GArrowSchema *schema);
+GARROW_AVAILABLE_IN_14_0
+GArrowSchema *
+gaflightsql_create_prepared_statement_result_get_parameter_schema(
+  GAFlightSQLCreatePreparedStatementResult *result);
+GARROW_AVAILABLE_IN_14_0
+void
+gaflightsql_create_prepared_statement_result_set_handle(
+  GAFlightSQLCreatePreparedStatementResult *result,
+  GBytes *handle);
+GARROW_AVAILABLE_IN_14_0
+GBytes *
+gaflightsql_create_prepared_statement_result_get_handle(
+  GAFlightSQLCreatePreparedStatementResult *result);
+
+
+#define GAFLIGHTSQL_TYPE_CLOSE_PREPARED_STATEMENT_REQUEST      \
+  (gaflightsql_close_prepared_statement_request_get_type())
+G_DECLARE_DERIVABLE_TYPE(GAFlightSQLClosePreparedStatementRequest,
+                         gaflightsql_close_prepared_statement_request,
+                         GAFLIGHTSQL,
+                         CLOSE_PREPARED_STATEMENT_REQUEST,
+                         GObject)
+struct _GAFlightSQLClosePreparedStatementRequestClass
+{
+  GObjectClass parent_class;
+};
+
+GARROW_AVAILABLE_IN_14_0
+GBytes *
+gaflightsql_close_prepared_statement_request_get_handle(
+  GAFlightSQLClosePreparedStatementRequest *request);
+
+
 #define GAFLIGHTSQL_TYPE_SERVER (gaflightsql_server_get_type())
 G_DECLARE_DERIVABLE_TYPE(GAFlightSQLServer,
                          gaflightsql_server,
@@ -105,6 +208,13 @@ G_DECLARE_DERIVABLE_TYPE(GAFlightSQLServer,
  *   that gets a #GAFlightDataStream containing the query results.
  * @do_put_command_statement_update: A virtual function to implement
  *   `DoPutCommandStatementUpdate` API that executes an update SQL statement.
+ * @do_put_prepared_statement_update: A virtual function to implement
+ *   `DoPutPreparedStatementUpdate` API that executes an update prepared
+ *   statement.
+ * @create_prepared_statement: A virtual function to implement
+ *   `CreatePreparedStatement` API that creates a prepared statement
+ * @close_prepared_statement: A virtual function to implement
+ *   `ClosePreparedStatement` API that closes a prepared statement.
  *
  * Since: 9.0.0
  */
@@ -128,6 +238,22 @@ struct _GAFlightSQLServerClass
     GAFlightServerCallContext *context,
     GAFlightSQLStatementUpdate *command,
     GError **error);
+  gint64 (*do_put_prepared_statement_update)(
+    GAFlightSQLServer *server,
+    GAFlightServerCallContext *context,
+    GAFlightSQLPreparedStatementUpdate *command,
+    GAFlightMessageReader *reader,
+    GError **error);
+  GAFlightSQLCreatePreparedStatementResult *(*create_prepared_statement)(
+    GAFlightSQLServer *server,
+    GAFlightServerCallContext *context,
+    GAFlightSQLCreatePreparedStatementRequest *request,
+    GError **error);
+  void (*close_prepared_statement)(
+    GAFlightSQLServer *server,
+    GAFlightServerCallContext *context,
+    GAFlightSQLClosePreparedStatementRequest *request,
+    GError **error);
 };
 
 GARROW_AVAILABLE_IN_9_0
@@ -152,5 +278,30 @@ gaflightsql_server_do_put_command_statement_update(
   GAFlightServerCallContext *context,
   GAFlightSQLStatementUpdate *command,
   GError **error);
+/* We can restore this after we bump version to 14.0.0-SNAPSHOT. */
+/* GARROW_AVAILABLE_IN_14_0 */
+gint64
+gaflightsql_server_do_put_prepared_statement_update(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLPreparedStatementUpdate *command,
+  GAFlightMessageReader *reader,
+  GError **error);
+/* We can restore this after we bump version to 14.0.0-SNAPSHOT. */
+/* GARROW_AVAILABLE_IN_14_0 */
+GAFlightSQLCreatePreparedStatementResult *
+gaflightsql_server_create_prepared_statement(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLCreatePreparedStatementRequest *request,
+  GError **error);
+/* We can restore this after we bump version to 14.0.0-SNAPSHOT. */
+/* GARROW_AVAILABLE_IN_14_0 */
+void
+gaflightsql_server_close_prepared_statement(
+  GAFlightSQLServer *server,
+  GAFlightServerCallContext *context,
+  GAFlightSQLClosePreparedStatementRequest *request,
+  GError **error);
 
 G_END_DECLS
diff --git a/c_glib/arrow-flight-sql-glib/server.hpp b/c_glib/arrow-flight-sql-glib/server.hpp
index 9159a6648934c..bdecf054a4d61 100644
--- a/c_glib/arrow-flight-sql-glib/server.hpp
+++ b/c_glib/arrow-flight-sql-glib/server.hpp
@@ -38,9 +38,30 @@ const arrow::flight::sql::StatementUpdate *
 gaflightsql_statement_update_get_raw(
   GAFlightSQLStatementUpdate *command);
 
+GAFlightSQLPreparedStatementUpdate *
+gaflightsql_prepared_statement_update_new_raw(
+  const arrow::flight::sql::PreparedStatementUpdate *flight_command);
+const arrow::flight::sql::PreparedStatementUpdate *
+gaflightsql_prepared_statement_update_get_raw(
+  GAFlightSQLPreparedStatementUpdate *command);
+
 GAFlightSQLStatementQueryTicket *
 gaflightsql_statement_query_ticket_new_raw(
   const arrow::flight::sql::StatementQueryTicket *flight_command);
 const arrow::flight::sql::StatementQueryTicket *
 gaflightsql_statement_query_ticket_get_raw(
   GAFlightSQLStatementQueryTicket *command);
+
+GAFlightSQLCreatePreparedStatementRequest *
+gaflightsql_create_prepared_statement_request_new_raw(
+  const arrow::flight::sql::ActionCreatePreparedStatementRequest *flight_request);
+const arrow::flight::sql::ActionCreatePreparedStatementRequest *
+gaflightsql_create_prepared_statement_request_get_raw(
+  GAFlightSQLCreatePreparedStatementRequest *request);
+
+GAFlightSQLClosePreparedStatementRequest *
+gaflightsql_close_prepared_statement_request_new_raw(
+  const arrow::flight::sql::ActionClosePreparedStatementRequest *flight_request);
+const arrow::flight::sql::ActionClosePreparedStatementRequest *
+gaflightsql_close_prepared_statement_request_get_raw(
+  GAFlightSQLClosePreparedStatementRequest *request);
diff --git a/c_glib/arrow-glib/version.h.in b/c_glib/arrow-glib/version.h.in
index 1d43271a8b607..60c02936193bc 100644
--- a/c_glib/arrow-glib/version.h.in
+++ b/c_glib/arrow-glib/version.h.in
@@ -110,6 +110,15 @@
 #  define GARROW_UNAVAILABLE(major, minor) G_UNAVAILABLE(major, minor)
 #endif
 
+/**
+ * GARROW_VERSION_14_0:
+ *
+ * You can use this macro value for compile time API version check.
+ *
+ * Since: 14.0.0
+ */
+#define GARROW_VERSION_14_0 G_ENCODE_VERSION(14, 0)
+
 /**
  * GARROW_VERSION_13_0:
  *
@@ -337,6 +346,20 @@
 
 #define GARROW_AVAILABLE_IN_ALL
 
+#if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_14_0
+#  define GARROW_DEPRECATED_IN_14_0                GARROW_DEPRECATED
+#  define GARROW_DEPRECATED_IN_14_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
+#else
+#  define GARROW_DEPRECATED_IN_14_0
+#  define GARROW_DEPRECATED_IN_14_0_FOR(function)
+#endif
+
+#if GARROW_VERSION_MAX_ALLOWED < GARROW_VERSION_14_0
+#  define GARROW_AVAILABLE_IN_14_0 GARROW_UNAVAILABLE(14, 0)
+#else
+#  define GARROW_AVAILABLE_IN_14_0
+#endif
+
 #if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_13_0
 #  define GARROW_DEPRECATED_IN_13_0                GARROW_DEPRECATED
 #  define GARROW_DEPRECATED_IN_13_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
diff --git a/c_glib/doc/arrow-flight-sql-glib/arrow-flight-sql-glib-docs.xml b/c_glib/doc/arrow-flight-sql-glib/arrow-flight-sql-glib-docs.xml
index be8c003ea2dba..f87d657461140 100644
--- a/c_glib/doc/arrow-flight-sql-glib/arrow-flight-sql-glib-docs.xml
+++ b/c_glib/doc/arrow-flight-sql-glib/arrow-flight-sql-glib-docs.xml
@@ -54,6 +54,14 @@
     <title>Index of deprecated API</title>
     <xi:include href="xml/api-index-deprecated.xml"><xi:fallback /></xi:include>
   </index>
+  <index id="api-index-14-0-0" role="14.0.0">
+    <title>Index of new symbols in 14.0.0</title>
+    <xi:include href="xml/api-index-14.0.0.xml"><xi:fallback /></xi:include>
+  </index>
+  <index id="api-index-13-0-0" role="13.0.0">
+    <title>Index of new symbols in 13.0.0</title>
+    <xi:include href="xml/api-index-13.0.0.xml"><xi:fallback /></xi:include>
+  </index>
   <index id="api-index-9-0-0" role="9.0.0">
     <title>Index of new symbols in 9.0.0</title>
     <xi:include href="xml/api-index-9.0.0.xml"><xi:fallback /></xi:include>
diff --git a/c_glib/test/flight-sql/test-client.rb b/c_glib/test/flight-sql/test-client.rb
index adfb47fe0bd8b..ab80fc2cb8550 100644
--- a/c_glib/test/flight-sql/test-client.rb
+++ b/c_glib/test/flight-sql/test-client.rb
@@ -16,6 +16,7 @@
 # under the License.
 
 class TestFlightSQLClient < Test::Unit::TestCase
+  include Helper::Buildable
   include Helper::Omittable
 
   def setup
@@ -67,4 +68,32 @@ def test_error
       end
     end
   end
+
+  sub_test_case("#prepare") do
+    def test_success
+      insert_sql = "INSERT INTO page_view_table VALUES (?, true)"
+      statement = @sql_client.prepare(insert_sql)
+      begin
+        assert_equal([
+                       build_schema(count: :uint64, private: :boolean),
+                       build_schema(count: :uint64),
+                     ],
+                     [
+                       statement.dataset_schema,
+                       statement.parameter_schema,
+                     ])
+        parameters = build_record_batch(count: build_uint64_array([1, 2, 3]))
+        statement.set_record_batch(parameters)
+        assert_equal(3, statement.execute_update)
+      ensure
+        statement.close
+      end
+    end
+
+    def test_error
+      assert_raise(Arrow::Error::Invalid) do
+        @sql_client.prepare("INSERT")
+      end
+    end
+  end
 end
diff --git a/c_glib/test/flight-sql/test-create-prepared-statement-result.rb b/c_glib/test/flight-sql/test-create-prepared-statement-result.rb
new file mode 100644
index 0000000000000..bcaeb1dddc93b
--- /dev/null
+++ b/c_glib/test/flight-sql/test-create-prepared-statement-result.rb
@@ -0,0 +1,47 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+class TestFlightSQLCreatePreparedStatementResult < Test::Unit::TestCase
+  include Helper::Buildable
+  include Helper::Omittable
+
+  def setup
+    omit("Arrow Flight SQL is required") unless defined?(ArrowFlightSQL)
+    @result = ArrowFlightSQL::CreatePreparedStatementResult.new
+  end
+
+  def test_dataset_schema
+    assert_nil(@result.dataset_schema)
+    schema = build_schema(text: :string, number: :int32)
+    @result.dataset_schema = schema
+    assert_equal(schema, @result.dataset_schema)
+  end
+
+  def test_parameter_schema
+    assert_nil(@result.parameter_schema)
+    schema = build_schema(text: :string, number: :int32)
+    @result.parameter_schema = schema
+    assert_equal(schema, @result.parameter_schema)
+  end
+
+  def test_handle
+    assert_equal("", @result.handle.to_s)
+    @result.handle = "valid-handle"
+    assert_equal("valid-handle".to_s,
+                 @result.handle.to_s)
+  end
+end
diff --git a/c_glib/test/helper/buildable.rb b/c_glib/test/helper/buildable.rb
index 29d7b6ba03bbe..b0156f9c8e299 100644
--- a/c_glib/test/helper/buildable.rb
+++ b/c_glib/test/helper/buildable.rb
@@ -19,6 +19,16 @@ module Helper
   module Buildable
     def build_schema(fields)
       fields = fields.collect do |name, data_type|
+        if data_type.is_a?(Symbol)
+          data_type_class_name =
+            data_type.
+              to_s.
+              split("_").
+              collect(&:capitalize).
+              join.
+              gsub(/\AUint/, "UInt") + "DataType"
+          data_type = Arrow.const_get(data_type_class_name).new
+        end
         Arrow::Field.new(name, data_type)
       end
       Arrow::Schema.new(fields)
diff --git a/c_glib/test/helper/flight-sql-server.rb b/c_glib/test/helper/flight-sql-server.rb
index 8b664ca112223..8cbba51f84b39 100644
--- a/c_glib/test/helper/flight-sql-server.rb
+++ b/c_glib/test/helper/flight-sql-server.rb
@@ -46,5 +46,31 @@ def virtual_do_do_put_command_statement_update(context, command)
       end
       1
     end
+
+    def virtual_do_create_prepared_statement(context, request)
+      unless request.query == "INSERT INTO page_view_table VALUES (?, true)"
+        raise Arrow::Error::Invalid.new("invalid SQL")
+      end
+      result = ArrowFlightSQL::CreatePreparedStatementResult.new
+      generator = FlightInfoGenerator.new
+      table = generator.page_view_table
+      result.dataset_schema = table.schema
+      result.parameter_schema = table.schema.remove_field(1)
+      result.handle = "valid-handle"
+      result
+    end
+
+    def virtual_do_do_put_prepared_statement_update(context, command, reader)
+      unless command.handle.to_s == "valid-handle"
+        raise Arrow::Error::Invalid.new("invalid handle")
+      end
+      reader.read_all.n_rows
+    end
+
+    def virtual_do_close_prepared_statement(context, request)
+      unless request.handle.to_s == "valid-handle"
+        raise Arrow::Error::Invalid.new("invalid handle")
+      end
+    end
   end
 end
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb
new file mode 100644
index 0000000000000..ff3169d5621b2
--- /dev/null
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb
@@ -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.
+
+module ArrowFlightSQL
+  class Client
+    alias_method :prepare_raw, :prepare
+    def prepare(*args)
+      statement = prepare_raw(*args)
+      if block_given?
+        begin
+          yield(statement)
+        ensure
+          statement.close unless statement.closed?
+        end
+      else
+        statement
+      end
+    end
+  end
+end
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/loader.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/loader.rb
index 3ff71094dbc33..5c920d9780ddf 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/loader.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/loader.rb
@@ -29,6 +29,7 @@ def post_load(repository, namespace)
     end
 
     def require_libraries
+      require_relative "client"
       require_relative "server"
     end
 
diff --git a/ruby/red-arrow-flight-sql/test/helper/server.rb b/ruby/red-arrow-flight-sql/test/helper/server.rb
index ab034996392ce..f7c935fab91fa 100644
--- a/ruby/red-arrow-flight-sql/test/helper/server.rb
+++ b/ruby/red-arrow-flight-sql/test/helper/server.rb
@@ -37,5 +37,31 @@ def virtual_do_do_get_statement(context, command)
       table = generator.page_view_table
       ArrowFlight::RecordBatchStream.new(table)
     end
+
+    def virtual_do_create_prepared_statement(context, request)
+      unless request.query == "INSERT INTO page_view_table VALUES (?, true)"
+        raise Arrow::Error::Invalid.new("invalid SQL")
+      end
+      result = ArrowFlightSQL::CreatePreparedStatementResult.new
+      generator = InfoGenerator.new
+      table = generator.page_view_table
+      result.dataset_schema = table.schema
+      result.parameter_schema = table.schema.remove_field(1)
+      result.handle = "valid-handle"
+      result
+    end
+
+    def virtual_do_do_put_prepared_statement_update(context, command, reader)
+      unless command.handle.to_s == "valid-handle"
+        raise Arrow::Error::Invalid.new("invalid handle")
+      end
+      reader.read_all.n_rows
+    end
+
+    def virtual_do_close_prepared_statement(context, request)
+      unless request.handle.to_s == "valid-handle"
+        raise Arrow::Error::Invalid.new("invalid handle")
+      end
+    end
   end
 end
diff --git a/ruby/red-arrow-flight-sql/test/test-client.rb b/ruby/red-arrow-flight-sql/test/test-client.rb
index de8732898937b..21554c1bdab84 100644
--- a/ruby/red-arrow-flight-sql/test/test-client.rb
+++ b/ruby/red-arrow-flight-sql/test/test-client.rb
@@ -39,4 +39,25 @@ def test_execute
     assert_equal(generator.page_view_table,
                  reader.read_all)
   end
+
+  def test_prepare
+    insert_sql = "INSERT INTO page_view_table VALUES (?, true)"
+    block_called = false
+    @sql_client.prepare(insert_sql) do |statement|
+      block_called = true
+      assert_equal([
+                     Arrow::Schema.new(count: :uint64, private: :boolean),
+                     Arrow::Schema.new(count: :uint64),
+                   ],
+                   [
+                     statement.dataset_schema,
+                     statement.parameter_schema,
+                   ])
+      counts = Arrow::UInt64Array.new([1, 2, 3])
+      parameters = Arrow::RecordBatch.new(count: counts)
+      statement.set_record_batch(parameters)
+      assert_equal(3, statement.execute_update)
+    end
+    assert_true(block_called)
+  end
 end

From 5abdc6e190f8d31ef74869a9269b0e75e993bffe Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 18 Aug 2023 09:51:06 -0400
Subject: [PATCH 187/749] GH-37234: [MATLAB] Create an abstract
 `arrow.type.TemporalType` class (#37236)

### Rationale for this change

To simplify the implementation of `Time32Type`, `Time64Type`, `Date32Type`, and `Date64Type`, it would be helpful to create an abstract `arrow.type.TemporalType` class that the date and time types can inherit from.

As a first step, we can modify the implementation of `TimestampType` to inherit from `TemporalType`.

This mimics the class inheritance hierarchy from the C++ libraries.

### What changes are included in this PR?

1. Added a new MATLAB class called `arrow.type.TemporalType`. It inherits from `arrow.type.FixedWidthType` and defines one read-only property: `TimeUnit`.
2. Modified the MATLAB class `arrow.type.TimestampType` to inherit from `arrow.type.TemporalType` instead of `arrow.type.FixedWidthType`.
3. Renamed the  C++ `proxy::TimestampType` methods `timeUnit()` and `timeZone()` to `getTimeUnit()` and `getTimeZone()`.

### Are these changes tested?

Yes. The existing tests in `tTimetampType.m` cover these changes.

### Are there any user-facing changes?

No.

### Future Directions

1. Add `arrow.type.Time32Type` (#37231)
2. Add `arrow.type.Time64Type` (#37225)
3. Add `arrow.type.Date32Type` (#37229),
4. Add `arrow.type.Time64Type` (#37230).
5. Add `arrow.array.Time32Array`
6. Add `arrow.array.Time64Array`
7. Add `arrow.array.Date32Array`
8. Add `arrow.array.Date64Array`
* Closes: #37234

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/type/proxy/timestamp_type.cc |  8 ++--
 .../arrow/matlab/type/proxy/timestamp_type.h  |  4 +-
 matlab/src/matlab/+arrow/+type/TemporalType.m | 37 +++++++++++++++++++
 .../src/matlab/+arrow/+type/TimestampType.m   | 14 ++-----
 4 files changed, 47 insertions(+), 16 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+type/TemporalType.m

diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc
index b1d35ee4874db..9ae5fcde67937 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc
@@ -23,8 +23,8 @@
 namespace arrow::matlab::type::proxy {
 
     TimestampType::TimestampType(std::shared_ptr<arrow::TimestampType> timestamp_type) : FixedWidthType(std::move(timestamp_type)) {
-        REGISTER_METHOD(TimestampType, timeUnit);
-        REGISTER_METHOD(TimestampType, timeZone);
+        REGISTER_METHOD(TimestampType, getTimeUnit);
+        REGISTER_METHOD(TimestampType, getTimeZone);
     }
 
     libmexclass::proxy::MakeResult TimestampType::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
@@ -55,7 +55,7 @@ namespace arrow::matlab::type::proxy {
         return std::make_shared<TimestampTypeProxy>(std::move(time_type));
     }
 
-    void TimestampType::timeZone(libmexclass::proxy::method::Context& context) {
+    void TimestampType::getTimeZone(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
 
@@ -68,7 +68,7 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = timezone_mda;
     }
 
-    void TimestampType::timeUnit(libmexclass::proxy::method::Context& context) {
+    void TimestampType::getTimeUnit(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.h
index 71005dc3a980d..93a6585311062 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/timestamp_type.h
@@ -33,9 +33,9 @@ class TimestampType : public arrow::matlab::type::proxy::FixedWidthType {
 
     protected:
 
-        void timeZone(libmexclass::proxy::method::Context& context);
+        void getTimeZone(libmexclass::proxy::method::Context& context);
 
-        void timeUnit(libmexclass::proxy::method::Context& context);
+        void getTimeUnit(libmexclass::proxy::method::Context& context);
 };
 
 }
diff --git a/matlab/src/matlab/+arrow/+type/TemporalType.m b/matlab/src/matlab/+arrow/+type/TemporalType.m
new file mode 100644
index 0000000000000..a3d093fb6dad9
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/TemporalType.m
@@ -0,0 +1,37 @@
+%TEMPORALTYPE Parent class of all temporal types.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef TemporalType < arrow.type.FixedWidthType
+
+    properties(Dependent, GetAccess=public, SetAccess=private)
+        TimeUnit
+    end
+
+    methods
+        function obj = TemporalType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy
+            end
+            obj@arrow.type.FixedWidthType(proxy);
+        end
+
+        function timeUnit = get.TimeUnit(obj)
+            timeUnitValue = obj.Proxy.getTimeUnit();
+            timeUnit = arrow.type.TimeUnit(timeUnitValue);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/TimestampType.m b/matlab/src/matlab/+arrow/+type/TimestampType.m
index b3d34f31b7d1e..2333818208eca 100644
--- a/matlab/src/matlab/+arrow/+type/TimestampType.m
+++ b/matlab/src/matlab/+arrow/+type/TimestampType.m
@@ -13,12 +13,11 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef TimestampType < arrow.type.FixedWidthType
+classdef TimestampType < arrow.type.TemporalType
 %TIMESTAMPTYPE Type class for timestamp data.
 
-    properties(Dependent, SetAccess=private, GetAccess=public)
+    properties(Dependent, GetAccess=public, SetAccess=private)
         TimeZone
-        TimeUnit
     end
 
     methods
@@ -27,16 +26,11 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.TimestampType")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-
-        function unit = get.TimeUnit(obj)
-            val = obj.Proxy.timeUnit();
-            unit = arrow.type.TimeUnit(val);
+            obj@arrow.type.TemporalType(proxy);
         end
 
         function tz = get.TimeZone(obj)
-            tz = obj.Proxy.timeZone();
+            tz = obj.Proxy.getTimeZone();
         end
     end
 

From fc96fd2fb5f2e3ca6f8e1dbaa86c095641653920 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 18 Aug 2023 13:59:27 -0400
Subject: [PATCH 188/749] GH-37245: [MATLAB] `arrow.internal.proxy.validate`
 throws `MATLAB:UndefinedFunction` when crafting the message to display when
 throwing the `arrow:proxy:ProxyNameMismatch` error  (#37248)

### Rationale for this change

When constructing the message to display for with the `arrow:proxy:ProxyNameMismatch` error,  we refer to an undefined variable in `arrow.internal.proxy.validate()`. This causes the function to throw a `MATLAB:UndefinedFunction` error instead of the intended one.

Here's an example of this bug:

```matlab
>> a = arrow.array([1 2 3]);
>> arrow.internal.proxy.validate(a.Proxy, "WrongProxyName")
Unrecognized function or variable 'proxyName'.

Error in arrow.internal.proxy.validate (line 26)
        msg = "Proxy class name is " + proxyName + ", but expected " + expectedProxyName;
```

This was the expected error message:

```matlab
>> a = arrow.array([1 2 3]);
>> arrow.internal.proxy.validate(a.Proxy, "WrongProxyName")
Error using arrow.internal.proxy.validate
Proxy class name is arrow.array.proxy.Float64Array, but expected WrongProxyName
```

### What changes are included in this PR?

1. Fixed the typos in `arrow.internal.proxy.validate()` to resolve the `MATLAB:UndefinedFunction` error
2. Added a new test class `test/arrow/internal/proxy/tValidate.m` to test  `arrow.internal.proxy.validate()`
3. Updated the error message to display when throwing an `arrow:proxy:ProxyNameMismatch` error:

```matlab
>> a = arrow.array([1 2 3]);
>> arrow.internal.proxy.validate(a.Proxy, "WrongProxyName")
Error using arrow.internal.proxy.validate
The Name property of the Proxy provided is "arrow.array.proxy.Float64Array", but
expected it to be "WrongProxyName".
```

### Are these changes tested?

Yes, added a new test class `test/arrow/internal/proxy/tValidate.m`.

### Are there any user-facing changes?

No.

* Closes: #37245

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../matlab/+arrow/+internal/+proxy/validate.m |  5 ++-
 matlab/test/arrow/internal/proxy/tValidate.m  | 42 +++++++++++++++++++
 2 files changed, 45 insertions(+), 2 deletions(-)
 create mode 100644 matlab/test/arrow/internal/proxy/tValidate.m

diff --git a/matlab/src/matlab/+arrow/+internal/+proxy/validate.m b/matlab/src/matlab/+arrow/+internal/+proxy/validate.m
index 1b2b3649e42c3..0aeb6074fcb09 100644
--- a/matlab/src/matlab/+arrow/+internal/+proxy/validate.m
+++ b/matlab/src/matlab/+arrow/+internal/+proxy/validate.m
@@ -18,12 +18,13 @@ function validate(proxy, expectedName)
 % proxy.Name and expectedName are not equal.
     arguments
         proxy(1, 1) libmexclass.proxy.Proxy
-        expectedName(1, 1) string
+        expectedName(1, 1) string {mustBeNonmissing, mustBeNonzeroLengthText}
     end
 
     if proxy.Name ~= expectedName
         errid = "arrow:proxy:ProxyNameMismatch";
-        msg = "Proxy class name is " + proxyName + ", but expected " + expectedProxyName;
+        msg = compose("The Name property of the Proxy provided is ""%s"", " + ...
+            "but expected it to be ""%s"".", proxy.Name, expectedName);
         error(errid, msg);
     end
 end
diff --git a/matlab/test/arrow/internal/proxy/tValidate.m b/matlab/test/arrow/internal/proxy/tValidate.m
new file mode 100644
index 0000000000000..268c71f745f8e
--- /dev/null
+++ b/matlab/test/arrow/internal/proxy/tValidate.m
@@ -0,0 +1,42 @@
+%TVALIDATE Unit tests for arrow.internal.proxy.validate
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tValidate < matlab.unittest.TestCase
+
+    methods(Test)
+        function ProxyNameMatches(testCase)
+            % Verify arrow.internal.proxy.validate() does not throw an 
+            % error if the Name property of the Proxy provided matches
+            % the expected proxy name.
+            import arrow.internal.proxy.validate
+            a = arrow.array(1);
+            fcn = @() validate(a.Proxy, a.Proxy.Name);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function ProxyNameMismatchError(testCase)
+            % Verify arrow.internal.proxy.validate() throws an error 
+            % whose identifier is "arrow:proxy:ProxyNameMismatch" if the
+            % Name property of the Proxy provided does not match the 
+            % expected proxy name.
+            import arrow.internal.proxy.validate
+            a = arrow.array(1);
+            fcn = @() validate(a.Proxy, "NotAProxyName");
+            testCase.verifyError(fcn, "arrow:proxy:ProxyNameMismatch");
+        end
+    end
+end
\ No newline at end of file

From 4fa671952895b39a08d8ea1140e96814175f2cc7 Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Fri, 18 Aug 2023 11:55:30 -0700
Subject: [PATCH 189/749] GH-36816: [C#] Reduce allocations (#36817)

### What changes are included in this PR?

A small refactoring to make a small improvement in memory utilization.

### Are these changes tested?

Existing test coverage should be sufficient.

* Closes: #36816

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 csharp/src/Apache.Arrow/Arrays/Time32Array.cs      |  2 +-
 csharp/src/Apache.Arrow/Arrays/Time64Array.cs      |  2 +-
 .../Apache.Arrow/C/CArrowArrayStreamExporter.cs    |  4 ++--
 csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs  | 14 +++++++-------
 csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs   |  6 +++---
 csharp/src/Apache.Arrow/Types/IntervalUnit.cs      | 11 ++++++++++-
 csharp/src/Apache.Arrow/Types/Time32Type.cs        |  2 +-
 csharp/src/Apache.Arrow/Types/Time64Type.cs        |  2 +-
 csharp/src/Apache.Arrow/Types/TimeType.cs          | 11 +++++++++++
 9 files changed, 37 insertions(+), 17 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/Time32Array.cs b/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
index 31d17d06a1e40..824694cd6d04b 100644
--- a/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Time32Array.cs
@@ -46,7 +46,7 @@ public Builder()
                 : this(Time32Type.Default) { }
 
             public Builder(TimeUnit unit)
-                : this(new Time32Type(unit)) { }
+                : this((Time32Type)TimeType.FromTimeUnit(unit)) { }
 
             /// <summary>
             /// Construct a new instance of the <see cref="Builder"/> class.
diff --git a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
index 95faf18fe9e61..9fc2ae4be1563 100644
--- a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
@@ -49,7 +49,7 @@ public Builder()
                 : this(Time64Type.Default) { }
 
             public Builder(TimeUnit unit)
-                : this(new Time64Type(unit)) { }
+                : this((Time64Type)TimeType.FromTimeUnit(unit)) { }
 
             /// <summary>
             /// Construct a new instance of the <see cref="Builder"/> class.
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
index 0a0f1cc837459..17b320f869406 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayStreamExporter.cs
@@ -61,9 +61,9 @@ public static unsafe void ExportArrayStream(IArrowArrayStream arrayStream, CArro
             {
                 throw new ArgumentNullException(nameof(arrayStream));
             }
-            if (arrayStream == null)
+            if (cArrayStream == null)
             {
-                throw new ArgumentNullException(nameof(arrayStream));
+                throw new ArgumentNullException(nameof(cArrayStream));
             }
 
             cArrayStream->private_data = ExportedArrayStream.Export(arrayStream);
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index b21f24edba9af..ec613d59d2cb9 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -268,14 +268,14 @@ public ArrowType GetAsType()
                     // Date and time
                     "tdD" => Date32Type.Default,
                     "tdm" => Date64Type.Default,
-                    "tts" => new Time32Type(TimeUnit.Second),
-                    "ttm" => new Time32Type(TimeUnit.Millisecond),
-                    "ttu" => new Time64Type(TimeUnit.Microsecond),
-                    "ttn" => new Time64Type(TimeUnit.Nanosecond),
+                    "tts" => TimeType.Second,
+                    "ttm" => TimeType.Millisecond,
+                    "ttu" => TimeType.Microsecond,
+                    "ttn" => TimeType.Nanosecond,
                     // TODO: duration not yet implemented
-                    "tiM" => new IntervalType(IntervalUnit.YearMonth),
-                    "tiD" => new IntervalType(IntervalUnit.DayTime),
-                    //"tin" => new IntervalType(IntervalUnit.MonthDayNanosecond), // Not yet implemented
+                    "tiM" => IntervalType.YearMonth,
+                    "tiD" => IntervalType.DayTime,
+                    //"tin" => IntervalType.MonthDayNanosecond, // Not yet implemented
                     _ => throw new NotSupportedException("Data type is not yet supported in import.")
                 };
             }
diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
index 7426ba4e86959..f5031fbfb56a4 100644
--- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
+++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
@@ -165,9 +165,9 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                     switch (timeMeta.BitWidth)
                     {
                         case 32:
-                            return new Types.Time32Type(timeMeta.Unit.ToArrow());
+                            return (Time32Type)TimeType.FromTimeUnit(timeMeta.Unit.ToArrow());
                         case 64:
-                            return new Types.Time64Type(timeMeta.Unit.ToArrow());
+                            return (Time64Type)TimeType.FromTimeUnit(timeMeta.Unit.ToArrow());
                         default:
                             throw new InvalidDataException("Unsupported time bit width");
                     }
@@ -178,7 +178,7 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                     return new Types.TimestampType(unit, timezone);
                 case Flatbuf.Type.Interval:
                     Flatbuf.Interval intervalMetadata = field.Type<Flatbuf.Interval>().Value;
-                    return new Types.IntervalType(intervalMetadata.Unit.ToArrow());
+                    return Types.IntervalType.FromIntervalUnit(intervalMetadata.Unit.ToArrow());
                 case Flatbuf.Type.Utf8:
                     return Types.StringType.Default;
                 case Flatbuf.Type.FixedSizeBinary:
diff --git a/csharp/src/Apache.Arrow/Types/IntervalUnit.cs b/csharp/src/Apache.Arrow/Types/IntervalUnit.cs
index 6dda0cfe94b78..bcd67e112dd2c 100644
--- a/csharp/src/Apache.Arrow/Types/IntervalUnit.cs
+++ b/csharp/src/Apache.Arrow/Types/IntervalUnit.cs
@@ -19,11 +19,15 @@ namespace Apache.Arrow.Types
     public enum IntervalUnit
     {
         YearMonth = 0,
-        DayTime = 1
+        DayTime = 1,
     }
 
     public sealed class IntervalType : FixedWidthType
     {
+        public static readonly IntervalType YearMonth = new IntervalType(IntervalUnit.YearMonth);
+        public static readonly IntervalType DayTime = new IntervalType(IntervalUnit.DayTime);
+        private static readonly IntervalType[] _types = new IntervalType[] { YearMonth, DayTime };
+
         public override ArrowTypeId TypeId => ArrowTypeId.Interval;
         public override string Name => "date";
         public override int BitWidth => 64;
@@ -36,5 +40,10 @@ public IntervalType(IntervalUnit unit = IntervalUnit.YearMonth)
         }
 
         public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor);
+
+        public static IntervalType FromIntervalUnit(IntervalUnit unit)
+        {
+            return _types[(int)unit];
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Types/Time32Type.cs b/csharp/src/Apache.Arrow/Types/Time32Type.cs
index 99c409babdb26..80a23d49344ae 100644
--- a/csharp/src/Apache.Arrow/Types/Time32Type.cs
+++ b/csharp/src/Apache.Arrow/Types/Time32Type.cs
@@ -18,7 +18,7 @@ namespace Apache.Arrow.Types
 {
     public sealed class Time32Type : TimeType
     {
-        public static readonly Time32Type Default = new Time32Type();
+        public static readonly Time32Type Default = Millisecond;
 
         public override ArrowTypeId TypeId => ArrowTypeId.Time32;
         public override string Name => "time32";
diff --git a/csharp/src/Apache.Arrow/Types/Time64Type.cs b/csharp/src/Apache.Arrow/Types/Time64Type.cs
index 2777deb228ed8..e7d911c2772b4 100644
--- a/csharp/src/Apache.Arrow/Types/Time64Type.cs
+++ b/csharp/src/Apache.Arrow/Types/Time64Type.cs
@@ -18,7 +18,7 @@ namespace Apache.Arrow.Types
 {
     public sealed class Time64Type : TimeType
     {
-        public static readonly Time64Type Default = new Time64Type();
+        public static readonly Time64Type Default = Nanosecond;
 
         public override ArrowTypeId TypeId => ArrowTypeId.Time64;
         public override string Name => "time64";
diff --git a/csharp/src/Apache.Arrow/Types/TimeType.cs b/csharp/src/Apache.Arrow/Types/TimeType.cs
index 9afa3fb62cdc7..48c7fdb5f1bea 100644
--- a/csharp/src/Apache.Arrow/Types/TimeType.cs
+++ b/csharp/src/Apache.Arrow/Types/TimeType.cs
@@ -26,11 +26,22 @@ public enum TimeUnit
 
     public abstract class TimeType: FixedWidthType
     {
+        public static readonly Time32Type Second = new Time32Type(TimeUnit.Second);
+        public static readonly Time32Type Millisecond = new Time32Type(TimeUnit.Millisecond);
+        public static readonly Time64Type Microsecond = new Time64Type(TimeUnit.Microsecond);
+        public static readonly Time64Type Nanosecond = new Time64Type(TimeUnit.Nanosecond);
+        private static readonly TimeType[] _types = new TimeType[] { Second, Millisecond, Microsecond, Nanosecond };
+
         public TimeUnit Unit { get; }
 
         protected TimeType(TimeUnit unit)
         {
             Unit = unit;
         }
+
+        public static TimeType FromTimeUnit(TimeUnit unit)
+        {
+            return _types[(int)unit];
+        }
     }
 }

From 61bff28b3692f5399e46505968260fb2660f4290 Mon Sep 17 00:00:00 2001
From: david dali susanibar arce <davi.sarces@gmail.com>
Date: Fri, 18 Aug 2023 14:37:00 -0500
Subject: [PATCH 190/749] GH-37246: [Java] expose VectorAppender class to offer
 support to append vector values (#37247)

### Rationale for this change

- To close #37246

### What changes are included in this PR?

- Expose VectorAppender class to offer support to append vector values

### Are these changes tested?

- By TestVectorAppender

### Are there any user-facing changes?

- No
* Closes: #37246

Authored-by: david dali susanibar arce <davi.sarces@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../java/org/apache/arrow/vector/util/VectorAppender.java     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java b/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
index 823b1df0954f6..9f73732ccfdd3 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
@@ -43,7 +43,7 @@
 /**
  * Utility to append two vectors together.
  */
-class VectorAppender implements VectorVisitor<ValueVector, Void> {
+public class VectorAppender implements VectorVisitor<ValueVector, Void> {
 
   /**
    * The targetVector to be appended.
@@ -56,7 +56,7 @@ class VectorAppender implements VectorVisitor<ValueVector, Void> {
    * Constructs a new targetVector appender, with the given targetVector.
    * @param targetVector the targetVector to be appended.
    */
-  VectorAppender(ValueVector targetVector) {
+  public VectorAppender(ValueVector targetVector) {
     this.targetVector = targetVector;
     typeVisitor = new TypeEqualsVisitor(targetVector, false, true);
   }

From ec1602c671949174f3e3b3b9decb5aef0277cf93 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Fri, 18 Aug 2023 16:04:54 -0400
Subject: [PATCH 191/749] GH-37231: [MATLAB] Add `arrow.type.Time32Type` class
 and `arrow.time32` construction function (#37250)

### Rationale for this change

To support the addition of `arrow.array.Time32Array`, this pull request adds a new `arrow.type.Time32Type` class and associated `arrow.time32` construction function to the MATLAB interface.

### What changes are included in this PR?

1. New `arrow.type.Time32Type` class.
2. New `arrow.time32` construction function that returns an `arrow.type.Time32Type` instance.

**Example**

```matlab
>> type = arrow.time32(TimeUnit="Millisecond")

type =

  Time32Type with properties:

          ID: Time32
    TimeUnit: Millisecond

>> class(type)

ans =

    'arrow.type.Time32Type'
```

### Are these changes tested?

Yes.

1. Added new tests for `Time32` type ID enumeration to `tID`.
2. Added a test class `tTimeUnit` for the new validation function `arrow.internal.validate.temporal.timeUnit`.
4. Added a new test class `tTime32Type`.

### Are there any user-facing changes?

Yes.

There are two new user-facing APIs:

1. `arrow.time32` construction function
2. `arrow.type.Time32Type` class

### Future Directions:

1. #37232
2. #37229
3.  #37230
4. #37251

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37231

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../arrow/matlab/type/proxy/time32_type.cc    |  60 ++++++++
 .../cpp/arrow/matlab/type/proxy/time32_type.h |  39 +++++
 .../+internal/+validate/+temporal/timeUnit.m  |  39 +++++
 matlab/src/matlab/+arrow/+type/ID.m           |   1 +
 matlab/src/matlab/+arrow/+type/Time32Type.m   |  38 +++++
 matlab/src/matlab/+arrow/time32.m             |  25 +++
 .../internal/validate/temporal/tTimeUnit.m    | 133 ++++++++++++++++
 matlab/test/arrow/type/tID.m                  |  29 +++-
 matlab/test/arrow/type/tTime32Type.m          | 145 ++++++++++++++++++
 matlab/test/arrow/type/tTimestampType.m       |   4 +-
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 12 files changed, 507 insertions(+), 9 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/+temporal/timeUnit.m
 create mode 100644 matlab/src/matlab/+arrow/+type/Time32Type.m
 create mode 100644 matlab/src/matlab/+arrow/time32.m
 create mode 100644 matlab/test/arrow/internal/validate/temporal/tTimeUnit.m
 create mode 100644 matlab/test/arrow/type/tTime32Type.m

diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 1420cd527c158..c349962f9c2ce 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -25,6 +25,7 @@
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/field.h"
 #include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/io/feather/proxy/reader.h"
@@ -63,6 +64,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
     REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
     REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
+    REGISTER_PROXY(arrow.type.proxy.Time32Type     , arrow::matlab::type::proxy::Time32Type);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
new file mode 100644
index 0000000000000..30323f4400071
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/time32_type.h"
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/util/utf8.h"
+
+namespace arrow::matlab::type::proxy {
+
+    Time32Type::Time32Type(std::shared_ptr<arrow::Time32Type> time32_type) : FixedWidthType(std::move(time32_type)) {
+        REGISTER_METHOD(Time32Type, getTimeUnit);
+    }
+
+    libmexclass::proxy::MakeResult Time32Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+
+        using Time32TypeProxy = arrow::matlab::type::proxy::Time32Type;
+
+        mda::StructArray opts = constructor_arguments[0];
+
+        const mda::StringArray timeunit_mda = opts[0]["TimeUnit"];
+
+        // extract the time unit
+        const std::u16string& utf16_timeunit = timeunit_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto timeunit,
+                               arrow::matlab::type::timeUnitFromString(utf16_timeunit),
+                               error::UKNOWN_TIME_UNIT_ERROR_ID);
+
+        auto type = arrow::time32(timeunit);
+        auto time_type = std::static_pointer_cast<arrow::Time32Type>(type);
+        return std::make_shared<Time32TypeProxy>(std::move(time_type));
+    }
+
+    void Time32Type::getTimeUnit(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        auto time32_type = std::static_pointer_cast<arrow::Time32Type>(data_type);
+        const auto timeunit = time32_type->unit();
+        // Cast to uint8_t since there are only four supported TimeUnit enumeration values:
+        // Nanosecond, Microsecond, Millisecond, Second
+        auto timeunit_mda = factory.createScalar(static_cast<uint8_t>(timeunit));
+        context.outputs[0] = timeunit_mda;
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
new file mode 100644
index 0000000000000..3c9ba2bc8f8b4
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/fixed_width_type.h"
+#include "arrow/type_traits.h"
+
+namespace arrow::matlab::type::proxy {
+
+class Time32Type : public arrow::matlab::type::proxy::FixedWidthType {
+
+    public:
+        Time32Type(std::shared_ptr<arrow::Time32Type> time32_type);
+
+        ~Time32Type() {}
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+        void getTimeUnit(libmexclass::proxy::method::Context& context);
+};
+
+}
+
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+temporal/timeUnit.m b/matlab/src/matlab/+arrow/+internal/+validate/+temporal/timeUnit.m
new file mode 100644
index 0000000000000..a88d3f02bbfef
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+temporal/timeUnit.m
@@ -0,0 +1,39 @@
+%TIMEUNIT Validates whether the given arrow.type.TimeUnit enumeration
+% value is supported for the specified temporal type.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function timeUnit(temporalType, timeUnit)
+    arguments
+        temporalType (1,1) string {mustBeMember(temporalType, ["Time32", "Time64"])}
+        timeUnit (1,1) arrow.type.TimeUnit
+    end
+    import arrow.type.TimeUnit
+
+    switch temporalType
+        case "Time32"
+            if ~(timeUnit == TimeUnit.Second || timeUnit == TimeUnit.Millisecond)
+                errid = "arrow:validate:temporal:UnsupportedTime32TimeUnit";
+                msg = "Supported TimeUnit values for Time32Type are ""Second"" and ""Millisecond"".";
+                error(errid, msg);
+            end
+        case "Time64"
+            if ~(timeUnit == TimeUnit.Microsecond || timeUnit == TimeUnit.Nanosecond)
+                errid = "arrow:validate:temporal:UnsupportedTime64TimeUnit";
+                msg = "Supported TimeUnit values for Time64Type are ""Microsecond"" and ""Nanosecond"".";
+                error(errid, msg);
+            end
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index 076d79d196a30..0db41ef634368 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -34,5 +34,6 @@
         % Date32 (16)
         % Date64 (17)
         Timestamp (18)
+        Time32    (19)
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/Time32Type.m b/matlab/src/matlab/+arrow/+type/Time32Type.m
new file mode 100644
index 0000000000000..9d2c709ad3d18
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/Time32Type.m
@@ -0,0 +1,38 @@
+%TIME32TYPE Type class for time32 data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time32Type < arrow.type.TemporalType
+
+    methods
+        function obj = Time32Type(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Time32Type")}
+            end
+            import arrow.internal.proxy.validate
+
+            obj@arrow.type.TemporalType(proxy);
+        end
+    end
+
+    methods (Access=protected)
+        function group = getPropertyGroups(~)
+          targets = ["ID" "TimeUnit"];
+          group = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/time32.m b/matlab/src/matlab/+arrow/time32.m
new file mode 100644
index 0000000000000..47066ae35a8b9
--- /dev/null
+++ b/matlab/src/matlab/+arrow/time32.m
@@ -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.
+
+function type = time32(opts)
+%TIME32 Creates an arrow.type.Time32Type object
+    arguments
+        opts.TimeUnit(1, 1) arrow.type.TimeUnit {timeUnit("Time32", opts.TimeUnit)} = arrow.type.TimeUnit.Second
+    end
+    import arrow.internal.validate.temporal.timeUnit
+    args = struct(TimeUnit=string(opts.TimeUnit));
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.Time32Type", args);
+    type = arrow.type.Time32Type(proxy);
+end
diff --git a/matlab/test/arrow/internal/validate/temporal/tTimeUnit.m b/matlab/test/arrow/internal/validate/temporal/tTimeUnit.m
new file mode 100644
index 0000000000000..e72d08f44fff3
--- /dev/null
+++ b/matlab/test/arrow/internal/validate/temporal/tTimeUnit.m
@@ -0,0 +1,133 @@
+%TTIMEUNIT Unit tests for arrow.internal.validate.temporal.timeUnit.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTimeUnit < matlab.unittest.TestCase
+
+    methods(Test)
+
+        function ErrorIfUnsupportedTemporalType(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "abc";
+            unit = TimeUnit.Second;
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validators:mustBeMember";
+            testCase.verifyError(fcn, errid);
+
+            temporalType = 123;
+            unit = TimeUnit.Second;
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validators:mustBeMember";
+            testCase.verifyError(fcn, errid);
+
+            temporalType = [1, 2, 3];
+            unit = TimeUnit.Second;
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validation:IncompatibleSize";
+            testCase.verifyError(fcn, errid);
+        end
+
+        function ErrorIfUnsupportedTimeUnitType(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "Time32";
+            unit = "abc";
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validation:UnableToConvert";
+            testCase.verifyError(fcn, errid);
+
+            temporalType = "Time32";
+            unit = 123;
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validation:UnableToConvert";
+            testCase.verifyError(fcn, errid);
+
+            temporalType = "Time32";
+            unit = [1, 2, 3];
+            fcn = @() timeUnit(temporalType, unit);
+            errid = "MATLAB:validation:IncompatibleSize";
+            testCase.verifyError(fcn, errid);
+        end
+
+        function SupportedTime32TimeUnit(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "Time32";
+
+            unit = TimeUnit.Second;
+            fcn = @() timeUnit(temporalType, unit);
+            testCase.verifyWarningFree(fcn);
+
+            unit = TimeUnit.Millisecond;
+            fcn = @() timeUnit(temporalType, unit);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function SupportedTime64TimeUnit(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "Time64";
+
+            unit = TimeUnit.Microsecond;
+            fcn = @() timeUnit(temporalType, unit);
+            testCase.verifyWarningFree(fcn);
+
+            unit = TimeUnit.Nanosecond;
+            fcn = @() timeUnit(temporalType, unit);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function UnsupportedTime32TimeUnit(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "Time32";
+
+            unit = TimeUnit.Microsecond;
+            fcn = @() timeUnit(temporalType, unit);
+            errorID = "arrow:validate:temporal:UnsupportedTime32TimeUnit";
+            testCase.verifyError(fcn, errorID);
+
+            unit = TimeUnit.Nanosecond;
+            fcn = @() timeUnit(temporalType, unit);
+            errorID = "arrow:validate:temporal:UnsupportedTime32TimeUnit";
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function UnsupportedTime64TimeUnit(testCase)
+            import arrow.internal.validate.temporal.timeUnit
+            import arrow.type.TimeUnit
+
+            temporalType = "Time64";
+
+            unit = TimeUnit.Second;
+            fcn = @() timeUnit(temporalType, unit);
+            errorID = "arrow:validate:temporal:UnsupportedTime64TimeUnit";
+            testCase.verifyError(fcn, errorID);
+
+            unit = TimeUnit.Millisecond;
+            fcn = @() timeUnit(temporalType, unit);
+            errorID = "arrow:validate:temporal:UnsupportedTime64TimeUnit";
+            testCase.verifyError(fcn, errorID);
+        end
+
+    end
+end
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index 344d2dd0f5a96..196ad407aabd1 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -29,14 +29,29 @@ function verifyOnMatlabPath(tc)
         function CastToUInt64(testCase)
             import arrow.type.ID
 
-            typeIDs = [ID.Boolean, ID.UInt8, ID.Int8, ID.UInt16, ...
-                       ID.Int16, ID.UInt32, ID.Int32, ID.UInt64, ...
-                       ID.Int64, ID.Float32, ID.Float64];
+            typeIDs = dictionary( ...
+                ID.Boolean,   1,  ...
+                ID.UInt8,     2,  ...
+                ID.Int8,      3,  ...
+                ID.UInt16,    4,  ...
+                ID.Int16,     5,  ...
+                ID.UInt32,    6,  ...
+                ID.Int32,     7,  ...
+                ID.UInt64,    8,  ...
+                ID.Int64,     9,  ...
+                ID.Float32,   11, ...
+                ID.Float64,   12, ...
+                ID.String,    13, ...
+                ID.Timestamp, 18, ...
+                ID.Time32,    19  ...
+            );
 
-            expectedValues = uint64([1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12]); 
-            for ii = 1:numel(typeIDs)
-                actualValue = uint64(typeIDs(ii)); 
-                expectedValue = expectedValues(ii);
+            enumValues = typeIDs.keys();
+            uint64Values = uint64(typeIDs.values());
+
+            for ii = 1:numel(enumValues)
+                actualValue = uint64(enumValues(ii));
+                expectedValue = uint64Values(ii);
                 testCase.verifyEqual(actualValue, expectedValue);
             end
         end
diff --git a/matlab/test/arrow/type/tTime32Type.m b/matlab/test/arrow/type/tTime32Type.m
new file mode 100644
index 0000000000000..115b8dfe96b52
--- /dev/null
+++ b/matlab/test/arrow/type/tTime32Type.m
@@ -0,0 +1,145 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime32Type < hFixedWidthType
+% Test class for arrow.type.Time32Type and arrow.time32
+
+    properties
+        ConstructionFcn = @arrow.time32
+        ArrowType = arrow.time32
+        TypeID = arrow.type.ID.Time32
+        BitWidth = int32(32)
+        ClassName = "arrow.type.Time32Type"
+    end
+
+    methods(Test)
+        function TestClass(testCase)
+            % Verify ArrowType is an object of the expected class type.
+            name = string(class(testCase.ArrowType));
+            testCase.verifyEqual(name, testCase.ClassName);
+        end
+
+        function DefaultTimeUnit(testCase)
+            % Verify the default TimeUnit is Second.
+            type = testCase.ArrowType;
+            actualUnit = type.TimeUnit;
+            expectedUnit = arrow.type.TimeUnit.Second;
+            testCase.verifyEqual(actualUnit, expectedUnit);
+        end
+
+        function SupplyTimeUnitEnum(testCase)
+            % Verify that TimeUnit can be specified as an enum value.
+            import arrow.type.*
+            expectedUnit = [TimeUnit.Second, TimeUnit.Millisecond];
+
+            for unit = expectedUnit
+                type = testCase.ConstructionFcn(TimeUnit=unit);
+                testCase.verifyEqual(type.TimeUnit, unit);
+            end
+        end
+
+        function SupplyTimeUnitString(testCase)
+            % Supply TimeUnit as a string value. Verify TimeUnit is set to
+            % the appropriate TimeUnit enum value.
+            import arrow.type.*
+            unitString = ["second", "millisecond"];
+            expectedUnit = [TimeUnit.Second, TimeUnit.Millisecond];
+
+            for ii = 1:numel(unitString)
+                type = testCase.ConstructionFcn(TimeUnit=unitString(ii));
+                testCase.verifyEqual(type.TimeUnit, expectedUnit(ii));
+            end
+        end
+
+        function ErrorIfAmbiguousTimeUnit(testCase)
+            % Verify that an error is thrown if an ambiguous value is
+            % provided for the TimeUnit name-value pair.
+            fcn = @() testCase.ConstructionFcn(TimeUnit="mi");
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function ErrorIfTimeUnitIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar value is
+            % provided for the TimeUnit name-value pair.
+            units = [arrow.type.TimeUnit.Second; arrow.type.TimeUnit.Millisecond];
+            fcn = @() testCase.ConstructionFcn(TimeUnit=units);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+
+            units = ["second" "millisecond"];
+            fcn = @() testCase.ConstructionFcn(TimeUnit=units);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+        end
+
+        function Display(testCase)
+            % Verify the display of Time32Type objects.
+            %
+            % Example:
+            %
+            %  Time32Type with properties:
+            %
+            %          ID: Time32
+            %    TimeUnit: Second
+            %
+            type = testCase.ConstructionFcn(TimeUnit="Second"); %#ok<NASGU>
+            classnameLink = "<a href=""matlab:helpPopup arrow.type.Time32Type"" style=""font-weight:bold"">Time32Type</a>";
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "TimeUnit:"]));
+            body = body + " " + ["Time32"; "Second"];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function TimeUnitNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the TimeUnit property.
+            schema = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyError(@() setfield(schema, "TimeUnit", "Second"), "MATLAB:class:SetProhibited");
+        end
+
+        function BitWidthNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the BitWidth property.
+            schema = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyError(@() setfield(schema, "BitWidth", 64), "MATLAB:class:SetProhibited");
+        end
+
+        function IDNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the ID property.
+            schema = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyError(@() setfield(schema, "ID", 15), "MATLAB:class:SetProhibited");
+        end
+
+        function NumFieldsNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the NumFields property.
+            schema = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyError(@() setfield(schema, "NumFields", 2), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidProxy(testCase)
+            % Verify that an error is thrown when a Proxy of an unexpected
+            % type is passed to the arrow.type.Time32Type constructor.
+            array = arrow.array([1, 2, 3]);
+            proxy = array.Proxy;
+            testCase.verifyError(@() arrow.type.Time32Type(proxy), "arrow:proxy:ProxyNameMismatch");
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/tTimestampType.m b/matlab/test/arrow/type/tTimestampType.m
index deee984e4b911..348c4b79da2aa 100644
--- a/matlab/test/arrow/type/tTimestampType.m
+++ b/matlab/test/arrow/type/tTimestampType.m
@@ -98,11 +98,11 @@ function ErrorIfAmbiguousTimeUnit(testCase)
 
         function ErrorIfTimeUnitIsNonScalar(testCase)
             units = [arrow.type.TimeUnit.Second; arrow.type.TimeUnit.Millisecond];
-            fcn = @() arrow.timestamp(TimeZone=units);
+            fcn = @() arrow.timestamp(TimeUnit=units);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
 
             units = ["second" "millisecond"];
-            fcn = @() arrow.timestamp(TimeZone=units);
+            fcn = @() arrow.timestamp(TimeUnit=units);
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 052f6b5ff2800..44fe9e562d4f0 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -55,6 +55,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"

From 6c660a5d5cd5ae5cf41a6a211517ed98911885e3 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sat, 19 Aug 2023 05:28:17 +0900
Subject: [PATCH 192/749] GH-37107: [C++] Suppress an unused variable warning
 with GCC 7 (#37240)

### Rationale for this change

If there is a warning, debug build is failed by default.

### What changes are included in this PR?

Suppress the unused warning explicitly.

### Are these changes tested?

No.

### Are there any user-facing changes?

Yes.
* Closes: #37107

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/ree_util.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/cpp/src/arrow/util/ree_util.h b/cpp/src/arrow/util/ree_util.h
index 5a240240b859f..a3d3d16c0da95 100644
--- a/cpp/src/arrow/util/ree_util.h
+++ b/cpp/src/arrow/util/ree_util.h
@@ -104,6 +104,11 @@ int64_t FindPhysicalLength(const RunEndCType* run_ends, int64_t run_ends_size,
                            int64_t length, int64_t offset) {
   auto [_, physical_length] =
       FindPhysicalRange<RunEndCType>(run_ends, run_ends_size, length, offset);
+  // GH-37107: This is a workaround for GCC 7. GCC 7 doesn't ignore
+  // variables in structured binding automatically from unused
+  // variables when one of these variables are used.
+  // See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81767
+  ARROW_UNUSED(_);
   return physical_length;
 }
 

From 6357c9f2419d5b0717e62adc8233c649e10de34b Mon Sep 17 00:00:00 2001
From: takuya kodama <a.s.takuya1026@gmail.com>
Date: Mon, 21 Aug 2023 04:54:10 +0800
Subject: [PATCH 193/749] GH-37239: [Ruby] Updated documentation for
 ArrowTable#initialize to clarify argument details (#37261)

### What changes are included in this PR?
Fixed the documentation for ArrowTable#initialize about the followings
- initialize(schema, record_batches)
- initialize(schema, raw_records)

* Closes: #37239

Authored-by: otegami <a.s.takuya1026@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ruby/red-arrow/lib/arrow/table.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ruby/red-arrow/lib/arrow/table.rb b/ruby/red-arrow/lib/arrow/table.rb
index da79e94b18052..0ce5962fce6e9 100644
--- a/ruby/red-arrow/lib/arrow/table.rb
+++ b/ruby/red-arrow/lib/arrow/table.rb
@@ -127,7 +127,7 @@ def load(path, options={})
     #     You can also specify schema as primitive Ruby objects.
     #     See {Arrow::Schema#initialize} for details.
     #
-    #   @param arrays [::Array<Arrow::RecordBatch>] The data of the table.
+    #   @param record_batches [::Array<Arrow::RecordBatch>] The data of the table.
     #
     #   @example Create a table from schema and record batches
     #     count_field = Arrow::Field.new("count", :uint32)
@@ -145,7 +145,7 @@ def load(path, options={})
     #     You can also specify schema as primitive Ruby objects.
     #     See {Arrow::Schema#initialize} for details.
     #
-    #   @param arrays [::Array<::Array>] The data of the table as primitive
+    #   @param raw_records [::Array<::Array>] The data of the table as primitive
     #     Ruby objects.
     #
     #   @example Create a table from schema and raw records

From a7e2147ae0af65b361583347707154635db13b22 Mon Sep 17 00:00:00 2001
From: Ray Zhang <m@raycursive.com>
Date: Mon, 21 Aug 2023 10:40:17 -0400
Subject: [PATCH 194/749] GH-36933: [Python] Pointless ellipsis in array repr
 (#37168)

### Rationale for this change

Explained in the issue

### What changes are included in this PR?

Added a check when adding ellipsis to see if the ellipsis is meaningful.
Rewrite some of tests affected by this change.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes, if the window = 2 and the array is [1, 2, 3, 4, 5], its print will be [1, 2, 3, 4, 5] instead of [1, 2, ..., 4, 5]

* Closes: #36933

Authored-by: Ray Zhang <m@raycursive.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/pretty_print.cc      |  4 +++-
 cpp/src/arrow/pretty_print_test.cc | 33 +++++++++++++++++++++---------
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index 0577f0be4dfd8..03e2051c2fb88 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -145,7 +145,9 @@ class ArrayPrinter : public PrettyPrinter {
     int window = is_container ? options_.container_window : options_.window;
     for (int64_t i = 0; i < array.length(); ++i) {
       const bool is_last = (i == array.length() - 1);
-      if ((i >= window) && (i < (array.length() - window))) {
+      // check if `length == 2 * window + 1` to eliminate ellipsis for only one element
+      if ((array.length() != 2 * window + 1) && (i >= window) &&
+          (i < (array.length() - window))) {
         IndentAfterNewline();
         (*sink_) << "...";
         if (!is_last && options_.skip_new_lines) {
diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index bebbc6e82e391..9a6e347c0bdb2 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -123,15 +123,23 @@ TEST_F(TestPrettyPrint, PrimitiveType) {
     null
   ])expected";
   CheckPrimitive<Int32Type, int32_t>({2, 10}, is_valid, values, ex_in2);
+
   static const char* ex_in2_w2 = R"expected(  [
     0,
     1,
-    ...
+    null,
     3,
     null
   ])expected";
   CheckPrimitive<Int32Type, int32_t>({2, 2}, is_valid, values, ex_in2_w2);
 
+  static const char* ex_in2_w1 = R"expected(  [
+    0,
+    ...
+    null
+  ])expected";
+  CheckPrimitive<Int32Type, int32_t>({2, 1}, is_valid, values, ex_in2_w1);
+
   std::vector<double> values2 = {0., 1., 2., 3., 4.};
   static const char* ex2 = R"expected([
   0,
@@ -738,7 +746,7 @@ TEST_F(TestPrettyPrint, ListType) {
     null
   ],
   [],
-  ...
+  null,
   [
     4,
     6,
@@ -790,7 +798,12 @@ TEST_F(TestPrettyPrint, ListTypeNoNewlines) {
   options.window = 2;
   options.container_window = 2;
   CheckArray(*empty_array, options, "[]", false);
-  CheckArray(*array, options, "[[NA],[],...,[4,5,...,7,8],[2,3]]", false);
+  CheckArray(*array, options, "[[NA],[],NA,[4,5,6,7,8],[2,3]]", false);
+
+  options.window = 1;
+  options.container_window = 2;
+  CheckArray(*empty_array, options, "[]", false);
+  CheckArray(*array, options, "[[NA],[],NA,[4,...,8],[2,3]]", false);
 }
 
 TEST_F(TestPrettyPrint, MapType) {
@@ -854,7 +867,7 @@ TEST_F(TestPrettyPrint, FixedSizeListType) {
     3,
     null
   ],
-  ...
+  null,
   [
     4,
     6,
@@ -876,23 +889,23 @@ TEST_F(TestPrettyPrint, FixedSizeListType) {
               R"expected([
   [
     null,
-    ...
+    0,
     1
   ],
   [
     2,
-    ...
+    3,
     null
   ],
   null,
   [
     4,
-    ...
+    6,
     7
   ],
   [
     8,
-    ...
+    9,
     5
   ]
 ])expected");
@@ -901,13 +914,13 @@ TEST_F(TestPrettyPrint, FixedSizeListType) {
               R"expected([
   [
     null,
-    ...
+    0,
     1
   ],
   ...
   [
     8,
-    ...
+    9,
     5
   ]
 ])expected");

From 06b0e4f7db15c4ee88bf31a9238aa28bbf858081 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 21 Aug 2023 11:17:44 -0400
Subject: [PATCH 195/749] GH-37251: [MATLAB] Make `arrow.type.TemporalType` a
 "tag" class  (#37256)

### Rationale for this change

The original motivation for adding the super-class `arrow.type.TemporalType` in #37236 was to define a common implementation for extracting the `Unit` property from `TimestampType`, `Time32Type`, `Time64Type`, `Date32Type`, and `Date64Type`. However, this approach doesn't work because the `Unit` property on `Date32Type` and `Date64Type` is a `DateUnit`, while the `Unit` property on the other three types is a`TimeUnit`. As a result, we cannot define a shared method for extracting the `Unit` property in `TemporalType`.

Instead, we plan on making `arrow.type.TemporalType` a "tag"-class (i.e. it has no properties or methods) so it can be used to group the "temporal" types together to ease authoring conditional logical in client code. In a future PR, we plan on adding functions like `arrow.type.isTemporal`, `arrow.type.isNumeric`, etc. so that clients don't need to query the class type information directly (i.e. call `isa(type, "arrow.type.TemporalType")`).

```matlab
function doStuff(arrowArray)
  import arrow.*

  arrowType = arrowArray.Type;
  if type.isTemporal(arrowType)
      ...
  else if type.isNumeric(arrowType)
      ...
  else
      ...
  end
end
```

### What changes are included in this PR?

1. Removed the `TimeUnit` property from `arrow.type.TemporalType`
2. Added `TimeUnit` back as a property on `arrow.type.TimestampType` and `arrow.type.Time32Type`

### Are these changes tested?

Yes, the existing tests cover these changes.

### Are there any user-facing changes?

No.

### Future Directions
1. #37232
2. #37229
3. #37230

* Closes: #37251

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+type/TemporalType.m  | 9 ---------
 matlab/src/matlab/+arrow/+type/Time32Type.m    | 9 +++++++++
 matlab/src/matlab/+arrow/+type/TimestampType.m | 9 ++++++++-
 3 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+type/TemporalType.m b/matlab/src/matlab/+arrow/+type/TemporalType.m
index a3d093fb6dad9..9c0769c38e24a 100644
--- a/matlab/src/matlab/+arrow/+type/TemporalType.m
+++ b/matlab/src/matlab/+arrow/+type/TemporalType.m
@@ -17,10 +17,6 @@
 
 classdef TemporalType < arrow.type.FixedWidthType
 
-    properties(Dependent, GetAccess=public, SetAccess=private)
-        TimeUnit
-    end
-
     methods
         function obj = TemporalType(proxy)
             arguments
@@ -28,10 +24,5 @@
             end
             obj@arrow.type.FixedWidthType(proxy);
         end
-
-        function timeUnit = get.TimeUnit(obj)
-            timeUnitValue = obj.Proxy.getTimeUnit();
-            timeUnit = arrow.type.TimeUnit(timeUnitValue);
-        end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Time32Type.m b/matlab/src/matlab/+arrow/+type/Time32Type.m
index 9d2c709ad3d18..b03f943b5b57e 100644
--- a/matlab/src/matlab/+arrow/+type/Time32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Time32Type.m
@@ -17,6 +17,10 @@
 
 classdef Time32Type < arrow.type.TemporalType
 
+    properties(Dependent, GetAccess=public, SetAccess=private)
+        TimeUnit
+    end
+
     methods
         function obj = Time32Type(proxy)
             arguments
@@ -26,6 +30,11 @@
 
             obj@arrow.type.TemporalType(proxy);
         end
+
+        function timeUnit = get.TimeUnit(obj)
+            timeUnitValue = obj.Proxy.getTimeUnit();
+            timeUnit = arrow.type.TimeUnit(timeUnitValue);
+        end
     end
 
     methods (Access=protected)
diff --git a/matlab/src/matlab/+arrow/+type/TimestampType.m b/matlab/src/matlab/+arrow/+type/TimestampType.m
index 2333818208eca..cb47743148310 100644
--- a/matlab/src/matlab/+arrow/+type/TimestampType.m
+++ b/matlab/src/matlab/+arrow/+type/TimestampType.m
@@ -1,3 +1,5 @@
+%TIMESTAMPTYPE Type class for timestamp data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -14,9 +16,9 @@
 % permissions and limitations under the License.
 
 classdef TimestampType < arrow.type.TemporalType
-%TIMESTAMPTYPE Type class for timestamp data.
 
     properties(Dependent, GetAccess=public, SetAccess=private)
+        TimeUnit
         TimeZone
     end
 
@@ -29,6 +31,11 @@
             obj@arrow.type.TemporalType(proxy);
         end
 
+        function timeUnit = get.TimeUnit(obj)
+            timeUnitValue = obj.Proxy.getTimeUnit();
+            timeUnit = arrow.type.TimeUnit(timeUnitValue);
+        end
+
         function tz = get.TimeZone(obj)
             tz = obj.Proxy.getTimeZone();
         end

From 49599366f367561a06be66b768ecfa1965895313 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 21 Aug 2023 12:08:25 -0400
Subject: [PATCH 196/749] GH-37262: [MATLAB] Add an abstract class called
 `arrow.type.TimeType` (#37279)

### Rationale for this change

To reduce code duplication within `Time32Type` and `Time64Type`, we should add an abstract class called `arrow.type.TimeType` that implements  the getter method for the `TimeUnit` property. This class hierarchy will mirror the class hierarchy in the C++ arrow implementation.

### What changes are included in this PR?

1. Defined a new C++ proxy class for called `arrow::matlab::type::proxy::TimeType`. This class defines a `getTimeUnit` method.
2. Modified the C++ proxy class `Time32Type` to inherit from `arrow::matlab::type::proxy::TimeType`. Removed the `getTimeUnit` method from this class because it's now defined on `TimeType`.
3. Added a new MATLAB class called `arrow.type.TimeType`. It has one method: `get.TimeUnit`.
4. Modified `arrow.type.Time32Type` to inherit from `arrow.type.TimeType` and removed its `get.TimeUnit` method.

### Are these changes tested?

Yes, the existing tests cover these changes.

### Are there any user-facing changes?

No.

### Future Directions

1. #37232
2. #37229
3. #37230
* Closes: #37262

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/type/proxy/time32_type.cc    | 16 +------
 .../cpp/arrow/matlab/type/proxy/time32_type.h |  7 +--
 .../cpp/arrow/matlab/type/proxy/time_type.cc  | 37 +++++++++++++++
 .../cpp/arrow/matlab/type/proxy/time_type.h   | 35 +++++++++++++++
 matlab/src/matlab/+arrow/+type/Time32Type.m   | 20 +--------
 matlab/src/matlab/+arrow/+type/TimeType.m     | 45 +++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |  1 +
 7 files changed, 123 insertions(+), 38 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/TimeType.m

diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
index 30323f4400071..7b2313d6c312d 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
@@ -22,9 +22,7 @@
 
 namespace arrow::matlab::type::proxy {
 
-    Time32Type::Time32Type(std::shared_ptr<arrow::Time32Type> time32_type) : FixedWidthType(std::move(time32_type)) {
-        REGISTER_METHOD(Time32Type, getTimeUnit);
-    }
+    Time32Type::Time32Type(std::shared_ptr<arrow::Time32Type> time32_type) : TimeType(std::move(time32_type)) {}
 
     libmexclass::proxy::MakeResult Time32Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
         namespace mda = ::matlab::data;
@@ -45,16 +43,4 @@ namespace arrow::matlab::type::proxy {
         auto time_type = std::static_pointer_cast<arrow::Time32Type>(type);
         return std::make_shared<Time32TypeProxy>(std::move(time_type));
     }
-
-    void Time32Type::getTimeUnit(libmexclass::proxy::method::Context& context) {
-        namespace mda = ::matlab::data;
-        mda::ArrayFactory factory;
-
-        auto time32_type = std::static_pointer_cast<arrow::Time32Type>(data_type);
-        const auto timeunit = time32_type->unit();
-        // Cast to uint8_t since there are only four supported TimeUnit enumeration values:
-        // Nanosecond, Microsecond, Millisecond, Second
-        auto timeunit_mda = factory.createScalar(static_cast<uint8_t>(timeunit));
-        context.outputs[0] = timeunit_mda;
-    }
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
index 3c9ba2bc8f8b4..cf1a9c9fa4045 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.h
@@ -17,12 +17,11 @@
 
 #pragma once
 
-#include "arrow/matlab/type/proxy/fixed_width_type.h"
-#include "arrow/type_traits.h"
+#include "arrow/matlab/type/proxy/time_type.h"
 
 namespace arrow::matlab::type::proxy {
 
-class Time32Type : public arrow::matlab::type::proxy::FixedWidthType {
+class Time32Type : public arrow::matlab::type::proxy::TimeType {
 
     public:
         Time32Type(std::shared_ptr<arrow::Time32Type> time32_type);
@@ -31,8 +30,6 @@ class Time32Type : public arrow::matlab::type::proxy::FixedWidthType {
 
         static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
-    protected:
-        void getTimeUnit(libmexclass::proxy::method::Context& context);
 };
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
new file mode 100644
index 0000000000000..1cc92834b9449
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/time_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    TimeType::TimeType(std::shared_ptr<arrow::TimeType> time_type) : FixedWidthType(std::move(time_type)) {
+        REGISTER_METHOD(TimeType, getTimeUnit);
+    }
+
+    void TimeType::getTimeUnit(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        auto time_type = std::static_pointer_cast<arrow::TimeType>(data_type);
+        const auto timeunit = time_type->unit();
+        // Cast to uint8_t since there are only four supported TimeUnit enumeration values:
+        // Nanosecond, Microsecond, Millisecond, Second
+        auto timeunit_mda = factory.createScalar(static_cast<uint8_t>(timeunit));
+        context.outputs[0] = timeunit_mda;
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
new file mode 100644
index 0000000000000..05521b9c36b19
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
@@ -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.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/fixed_width_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+class TimeType : public arrow::matlab::type::proxy::FixedWidthType {
+
+    public:
+        TimeType(std::shared_ptr<arrow::TimeType> time_type);
+
+        ~TimeType() {}
+
+    protected:
+        void getTimeUnit(libmexclass::proxy::method::Context& context);
+};
+
+}
diff --git a/matlab/src/matlab/+arrow/+type/Time32Type.m b/matlab/src/matlab/+arrow/+type/Time32Type.m
index b03f943b5b57e..50253ee6d1f10 100644
--- a/matlab/src/matlab/+arrow/+type/Time32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Time32Type.m
@@ -15,11 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Time32Type < arrow.type.TemporalType
-
-    properties(Dependent, GetAccess=public, SetAccess=private)
-        TimeUnit
-    end
+classdef Time32Type < arrow.type.TimeType
 
     methods
         function obj = Time32Type(proxy)
@@ -28,19 +24,7 @@
             end
             import arrow.internal.proxy.validate
 
-            obj@arrow.type.TemporalType(proxy);
-        end
-
-        function timeUnit = get.TimeUnit(obj)
-            timeUnitValue = obj.Proxy.getTimeUnit();
-            timeUnit = arrow.type.TimeUnit(timeUnitValue);
-        end
-    end
-
-    methods (Access=protected)
-        function group = getPropertyGroups(~)
-          targets = ["ID" "TimeUnit"];
-          group = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.TimeType(proxy);
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+type/TimeType.m b/matlab/src/matlab/+arrow/+type/TimeType.m
new file mode 100644
index 0000000000000..59d938788983f
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/TimeType.m
@@ -0,0 +1,45 @@
+%TIMETYPE Type class for time data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef TimeType < arrow.type.TemporalType
+
+    properties(Dependent, SetAccess=private, GetAccess=public)
+        TimeUnit
+    end
+
+    methods
+        function obj = TimeType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy
+            end
+            obj@arrow.type.TemporalType(proxy);
+        end
+
+        function timeUnit = get.TimeUnit(obj)
+            timeUnitValue = obj.Proxy.getTimeUnit();
+            timeUnit = arrow.type.TimeUnit(timeUnitValue);
+        end
+    end
+
+    methods (Access=protected)
+        function group = getPropertyGroups(~)
+            targets = ["ID" "TimeUnit"];
+            group = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 44fe9e562d4f0..30d942b86b6ef 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -55,6 +55,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"

From 94bd0d27326e8f3bfc0f612fcf604617402888ec Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Mon, 21 Aug 2023 19:02:55 +0200
Subject: [PATCH 197/749] GH-32863: [C++][Parquet] Add DELTA_BYTE_ARRAY encoder
 to Parquet writer (#14341)

This is to add DELTA_BYTE_ARRAY encoder.
* Closes: #32863

Lead-authored-by: Rok Mihevc <rok@mihevc.org>
Co-authored-by: Rok <rok@mihevc.org>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Gang Wu <ustcwg@gmail.com>
Co-authored-by: mwish <1506118561@qq.com>
Co-authored-by: Will Jones <willjones127@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc                | 495 ++++++++++++++++++---
 cpp/src/parquet/encoding.h                 |   2 +-
 cpp/src/parquet/encoding_test.cc           | 298 ++++++++++++-
 cpp/src/parquet/test_util.cc               |  52 +++
 cpp/src/parquet/test_util.h                |  38 +-
 cpp/src/parquet/types.h                    |   5 +
 docs/source/cpp/parquet.rst                |   2 +-
 python/pyarrow/tests/parquet/test_basic.py |  25 +-
 8 files changed, 825 insertions(+), 92 deletions(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index e972a86ccf0ef..a3cef4b4ce856 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -56,6 +56,8 @@ using arrow::Status;
 using arrow::VisitNullBitmapInline;
 using arrow::internal::AddWithOverflow;
 using arrow::internal::checked_cast;
+using arrow::internal::MultiplyWithOverflow;
+using arrow::internal::SubtractWithOverflow;
 using arrow::util::SafeLoad;
 using arrow::util::SafeLoadAs;
 using std::string_view;
@@ -1178,41 +1180,126 @@ int PlainBooleanDecoder::Decode(bool* buffer, int max_values) {
   return max_values;
 }
 
-struct ArrowBinaryHelper {
-  explicit ArrowBinaryHelper(typename EncodingTraits<ByteArrayType>::Accumulator* out) {
-    this->out = out;
-    this->builder = out->builder.get();
-    this->chunk_space_remaining =
-        ::arrow::kBinaryMemoryLimit - this->builder->value_data_length();
+// A helper class to abstract away differences between EncodingTraits<DType>::Accumulator
+// for ByteArrayType and FLBAType.
+template <typename DType>
+struct ArrowBinaryHelper;
+
+template <>
+struct ArrowBinaryHelper<ByteArrayType> {
+  using Accumulator = typename EncodingTraits<ByteArrayType>::Accumulator;
+
+  ArrowBinaryHelper(Accumulator* acc, int64_t length)
+      : acc_(acc),
+        entries_remaining_(length),
+        chunk_space_remaining_(::arrow::kBinaryMemoryLimit -
+                               acc_->builder->value_data_length()) {}
+
+  Status Prepare(std::optional<int64_t> estimated_data_length = {}) {
+    RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
+    if (estimated_data_length.has_value()) {
+      RETURN_NOT_OK(acc_->builder->ReserveData(
+          std::min<int64_t>(*estimated_data_length, ::arrow::kBinaryMemoryLimit)));
+    }
+    return Status::OK();
+  }
+
+  Status PrepareNextInput(int64_t next_value_length,
+                          std::optional<int64_t> estimated_remaining_data_length = {}) {
+    if (ARROW_PREDICT_FALSE(!CanFit(next_value_length))) {
+      // This element would exceed the capacity of a chunk
+      RETURN_NOT_OK(PushChunk());
+      RETURN_NOT_OK(acc_->builder->Reserve(entries_remaining_));
+      if (estimated_remaining_data_length.has_value()) {
+        RETURN_NOT_OK(acc_->builder->ReserveData(
+            std::min<int64_t>(*estimated_remaining_data_length, chunk_space_remaining_)));
+      }
+    }
+    return Status::OK();
+  }
+
+  void UnsafeAppend(const uint8_t* data, int32_t length) {
+    DCHECK(CanFit(length));
+    DCHECK_GT(entries_remaining_, 0);
+    chunk_space_remaining_ -= length;
+    --entries_remaining_;
+    acc_->builder->UnsafeAppend(data, length);
+  }
+
+  Status Append(const uint8_t* data, int32_t length) {
+    DCHECK(CanFit(length));
+    DCHECK_GT(entries_remaining_, 0);
+    chunk_space_remaining_ -= length;
+    --entries_remaining_;
+    return acc_->builder->Append(data, length);
+  }
+
+  void UnsafeAppendNull() {
+    --entries_remaining_;
+    acc_->builder->UnsafeAppendNull();
   }
 
+  Status AppendNull() {
+    --entries_remaining_;
+    return acc_->builder->AppendNull();
+  }
+
+ private:
   Status PushChunk() {
-    std::shared_ptr<::arrow::Array> result;
-    RETURN_NOT_OK(builder->Finish(&result));
-    out->chunks.push_back(result);
-    chunk_space_remaining = ::arrow::kBinaryMemoryLimit;
+    ARROW_ASSIGN_OR_RAISE(auto chunk, acc_->builder->Finish());
+    acc_->chunks.push_back(std::move(chunk));
+    chunk_space_remaining_ = ::arrow::kBinaryMemoryLimit;
     return Status::OK();
   }
 
-  bool CanFit(int64_t length) const { return length <= chunk_space_remaining; }
+  bool CanFit(int64_t length) const { return length <= chunk_space_remaining_; }
 
-  void UnsafeAppend(const uint8_t* data, int32_t length) {
-    chunk_space_remaining -= length;
-    builder->UnsafeAppend(data, length);
+  Accumulator* acc_;
+  int64_t entries_remaining_;
+  int64_t chunk_space_remaining_;
+};
+
+template <>
+struct ArrowBinaryHelper<FLBAType> {
+  using Accumulator = typename EncodingTraits<FLBAType>::Accumulator;
+
+  ArrowBinaryHelper(Accumulator* acc, int64_t length)
+      : acc_(acc), entries_remaining_(length) {}
+
+  Status Prepare(std::optional<int64_t> estimated_data_length = {}) {
+    return acc_->Reserve(entries_remaining_);
   }
 
-  void UnsafeAppendNull() { builder->UnsafeAppendNull(); }
+  Status PrepareNextInput(int64_t next_value_length,
+                          std::optional<int64_t> estimated_remaining_data_length = {}) {
+    return Status::OK();
+  }
+
+  void UnsafeAppend(const uint8_t* data, int32_t length) {
+    DCHECK_GT(entries_remaining_, 0);
+    --entries_remaining_;
+    acc_->UnsafeAppend(data);
+  }
 
   Status Append(const uint8_t* data, int32_t length) {
-    chunk_space_remaining -= length;
-    return builder->Append(data, length);
+    DCHECK_GT(entries_remaining_, 0);
+    --entries_remaining_;
+    return acc_->Append(data);
+  }
+
+  void UnsafeAppendNull() {
+    --entries_remaining_;
+    acc_->UnsafeAppendNull();
   }
 
-  Status AppendNull() { return builder->AppendNull(); }
+  Status AppendNull() {
+    --entries_remaining_;
+    return acc_->AppendNull();
+  }
 
-  typename EncodingTraits<ByteArrayType>::Accumulator* out;
-  ::arrow::BinaryBuilder* builder;
-  int64_t chunk_space_remaining;
+ private:
+  Accumulator* acc_;
+  int64_t entries_remaining_;
 };
 
 template <>
@@ -1313,12 +1400,10 @@ class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
                           int64_t valid_bits_offset,
                           typename EncodingTraits<ByteArrayType>::Accumulator* out,
                           int* out_values_decoded) {
-    ArrowBinaryHelper helper(out);
+    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
     int values_decoded = 0;
 
-    RETURN_NOT_OK(helper.builder->Reserve(num_values));
-    RETURN_NOT_OK(helper.builder->ReserveData(
-        std::min<int64_t>(len_, helper.chunk_space_remaining)));
+    RETURN_NOT_OK(helper.Prepare(len_));
 
     int i = 0;
     RETURN_NOT_OK(VisitNullBitmapInline(
@@ -1335,13 +1420,7 @@ class PlainByteArrayDecoder : public PlainDecoder<ByteArrayType>,
           if (ARROW_PREDICT_FALSE(len_ < increment)) {
             ParquetException::EofException();
           }
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(value_len))) {
-            // This element would exceed the capacity of a chunk
-            RETURN_NOT_OK(helper.PushChunk());
-            RETURN_NOT_OK(helper.builder->Reserve(num_values - i));
-            RETURN_NOT_OK(helper.builder->ReserveData(
-                std::min<int64_t>(len_, helper.chunk_space_remaining)));
-          }
+          RETURN_NOT_OK(helper.PrepareNextInput(value_len, len_));
           helper.UnsafeAppend(data_ + 4, value_len);
           data_ += increment;
           len_ -= increment;
@@ -1421,7 +1500,7 @@ class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
         byte_array_offsets_(AllocateBuffer(pool, 0)),
         indices_scratch_space_(AllocateBuffer(pool, 0)) {}
 
-  // Perform type-specific initiatialization
+  // Perform type-specific initialization
   void SetDict(TypedDecoder<Type>* dictionary) override;
 
   void SetData(int num_values, const uint8_t* data, int len) override {
@@ -1834,7 +1913,8 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
     constexpr int32_t kBufferSize = 1024;
     int32_t indices[kBufferSize];
 
-    ArrowBinaryHelper helper(out);
+    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
+    RETURN_NOT_OK(helper.Prepare());
 
     auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
     int values_decoded = 0;
@@ -1855,9 +1935,7 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
       const auto index = indices[pos_indices++];
       RETURN_NOT_OK(IndexInBounds(index));
       const auto& val = dict_values[index];
-      if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-        RETURN_NOT_OK(helper.PushChunk());
-      }
+      RETURN_NOT_OK(helper.PrepareNextInput(val.len));
       RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
       ++values_decoded;
       return Status::OK();
@@ -1903,20 +1981,21 @@ class DictByteArrayDecoderImpl : public DictDecoderImpl<ByteArrayType>,
     int32_t indices[kBufferSize];
     int values_decoded = 0;
 
-    ArrowBinaryHelper helper(out);
+    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
+    RETURN_NOT_OK(helper.Prepare(len_));
+
     auto dict_values = reinterpret_cast<const ByteArray*>(dictionary_->data());
 
     while (values_decoded < num_values) {
-      int32_t batch_size = std::min<int32_t>(kBufferSize, num_values - values_decoded);
-      int num_indices = idx_decoder_.GetBatch(indices, batch_size);
+      const int32_t batch_size =
+          std::min<int32_t>(kBufferSize, num_values - values_decoded);
+      const int num_indices = idx_decoder_.GetBatch(indices, batch_size);
       if (num_indices == 0) ParquetException::EofException();
       for (int i = 0; i < num_indices; ++i) {
         auto idx = indices[i];
         RETURN_NOT_OK(IndexInBounds(idx));
         const auto& val = dict_values[idx];
-        if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-          RETURN_NOT_OK(helper.PushChunk());
-        }
+        RETURN_NOT_OK(helper.PrepareNextInput(val.len));
         RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
       }
       values_decoded += num_indices;
@@ -2746,7 +2825,8 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
                           int64_t valid_bits_offset,
                           typename EncodingTraits<ByteArrayType>::Accumulator* out,
                           int* out_num_values) {
-    ArrowBinaryHelper helper(out);
+    ArrowBinaryHelper<ByteArrayType> helper(out, num_values);
+    RETURN_NOT_OK(helper.Prepare());
 
     std::vector<ByteArray> values(num_values - null_count);
     const int num_valid_values = Decode(values.data(), num_values - null_count);
@@ -2762,9 +2842,7 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
         valid_bits, valid_bits_offset, num_values, null_count,
         [&]() {
           const auto& val = values_ptr[value_idx];
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-            RETURN_NOT_OK(helper.PushChunk());
-          }
+          RETURN_NOT_OK(helper.PrepareNextInput(val.len));
           RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
           ++value_idx;
           return Status::OK();
@@ -2782,8 +2860,8 @@ class DeltaLengthByteArrayDecoder : public DecoderImpl,
 
   std::shared_ptr<::arrow::bit_util::BitReader> decoder_;
   DeltaBitPackDecoder<Int32Type> len_decoder_;
-  int num_valid_values_;
-  uint32_t length_idx_;
+  int num_valid_values_{0};
+  uint32_t length_idx_{0};
   std::shared_ptr<ResizableBuffer> buffered_length_;
 };
 
@@ -2977,12 +3055,238 @@ class RleBooleanDecoder : public DecoderImpl, virtual public BooleanDecoder {
 // ----------------------------------------------------------------------
 // DELTA_BYTE_ARRAY
 
-class DeltaByteArrayDecoder : public DecoderImpl,
-                              virtual public TypedDecoder<ByteArrayType> {
+/// Delta Byte Array encoding also known as incremental encoding or front compression:
+/// for each element in a sequence of strings, store the prefix length of the previous
+/// entry plus the suffix.
+///
+/// This is stored as a sequence of delta-encoded prefix lengths (DELTA_BINARY_PACKED),
+/// followed by the suffixes encoded as delta length byte arrays
+/// (DELTA_LENGTH_BYTE_ARRAY).
+
+// ----------------------------------------------------------------------
+// DeltaByteArrayEncoder
+
+template <typename DType>
+class DeltaByteArrayEncoder : public EncoderImpl, virtual public TypedEncoder<DType> {
+  static constexpr std::string_view kEmpty = "";
+
  public:
-  explicit DeltaByteArrayDecoder(const ColumnDescriptor* descr,
+  using T = typename DType::c_type;
+
+  explicit DeltaByteArrayEncoder(const ColumnDescriptor* descr,
                                  MemoryPool* pool = ::arrow::default_memory_pool())
+      : EncoderImpl(descr, Encoding::DELTA_BYTE_ARRAY, pool),
+        sink_(pool),
+        prefix_length_encoder_(/*descr=*/nullptr, pool),
+        suffix_encoder_(descr, pool),
+        last_value_(""),
+        empty_(static_cast<uint32_t>(kEmpty.size()),
+               reinterpret_cast<const uint8_t*>(kEmpty.data())) {}
+
+  std::shared_ptr<Buffer> FlushValues() override;
+
+  int64_t EstimatedDataEncodedSize() override {
+    return prefix_length_encoder_.EstimatedDataEncodedSize() +
+           suffix_encoder_.EstimatedDataEncodedSize();
+  }
+
+  using TypedEncoder<DType>::Put;
+
+  void Put(const ::arrow::Array& values) override;
+
+  void Put(const T* buffer, int num_values) override;
+
+  void PutSpaced(const T* src, int num_values, const uint8_t* valid_bits,
+                 int64_t valid_bits_offset) override {
+    if (valid_bits != nullptr) {
+      if (buffer_ == nullptr) {
+        PARQUET_ASSIGN_OR_THROW(buffer_,
+                                ::arrow::AllocateResizableBuffer(num_values * sizeof(T),
+                                                                 this->memory_pool()));
+      } else {
+        PARQUET_THROW_NOT_OK(buffer_->Resize(num_values * sizeof(T), false));
+      }
+      T* data = reinterpret_cast<T*>(buffer_->mutable_data());
+      int num_valid_values = ::arrow::util::internal::SpacedCompress<T>(
+          src, num_values, valid_bits, valid_bits_offset, data);
+      Put(data, num_valid_values);
+    } else {
+      Put(src, num_values);
+    }
+  }
+
+ protected:
+  template <typename VisitorType>
+  void PutInternal(const T* src, int num_values, const VisitorType visitor) {
+    if (num_values == 0) {
+      return;
+    }
+
+    std::string_view last_value_view = last_value_;
+    constexpr int kBatchSize = 256;
+    std::array<int32_t, kBatchSize> prefix_lengths;
+    std::array<ByteArray, kBatchSize> suffixes;
+
+    for (int i = 0; i < num_values; i += kBatchSize) {
+      const int batch_size = std::min(kBatchSize, num_values - i);
+
+      for (int j = 0; j < batch_size; ++j) {
+        const int idx = i + j;
+        const auto view = visitor[idx];
+        const auto len = static_cast<const uint32_t>(view.length());
+
+        uint32_t common_prefix_length = 0;
+        const uint32_t maximum_common_prefix_length =
+            std::min(len, static_cast<uint32_t>(last_value_view.length()));
+        while (common_prefix_length < maximum_common_prefix_length) {
+          if (last_value_view[common_prefix_length] != view[common_prefix_length]) {
+            break;
+          }
+          common_prefix_length++;
+        }
+
+        last_value_view = view;
+        prefix_lengths[j] = common_prefix_length;
+        const uint32_t suffix_length = len - common_prefix_length;
+        const uint8_t* suffix_ptr = src[idx].ptr + common_prefix_length;
+
+        // Convert to ByteArray, so it can be passed to the suffix_encoder_.
+        const ByteArray suffix(suffix_length, suffix_ptr);
+        suffixes[j] = suffix;
+      }
+      suffix_encoder_.Put(suffixes.data(), batch_size);
+      prefix_length_encoder_.Put(prefix_lengths.data(), batch_size);
+    }
+    last_value_ = last_value_view;
+  }
+
+  template <typename ArrayType>
+  void PutBinaryArray(const ArrayType& array) {
+    auto previous_len = static_cast<uint32_t>(last_value_.length());
+    std::string_view last_value_view = last_value_;
+
+    PARQUET_THROW_NOT_OK(::arrow::VisitArraySpanInline<typename ArrayType::TypeClass>(
+        *array.data(),
+        [&](::std::string_view view) {
+          if (ARROW_PREDICT_FALSE(view.size() >= kMaxByteArraySize)) {
+            return Status::Invalid("Parquet cannot store strings with size 2GB or more");
+          }
+          const ByteArray src{view};
+
+          uint32_t common_prefix_length = 0;
+          const uint32_t len = src.len;
+          const uint32_t maximum_common_prefix_length = std::min(previous_len, len);
+          while (common_prefix_length < maximum_common_prefix_length) {
+            if (last_value_view[common_prefix_length] != view[common_prefix_length]) {
+              break;
+            }
+            common_prefix_length++;
+          }
+          previous_len = len;
+          prefix_length_encoder_.Put({static_cast<int32_t>(common_prefix_length)}, 1);
+
+          last_value_view = view;
+          const auto suffix_length = static_cast<uint32_t>(len - common_prefix_length);
+          if (suffix_length == 0) {
+            suffix_encoder_.Put(&empty_, 1);
+            return Status::OK();
+          }
+          const uint8_t* suffix_ptr = src.ptr + common_prefix_length;
+          // Convert to ByteArray, so it can be passed to the suffix_encoder_.
+          const ByteArray suffix(suffix_length, suffix_ptr);
+          suffix_encoder_.Put(&suffix, 1);
+
+          return Status::OK();
+        },
+        []() { return Status::OK(); }));
+    last_value_ = last_value_view;
+  }
+
+  ::arrow::BufferBuilder sink_;
+  DeltaBitPackEncoder<Int32Type> prefix_length_encoder_;
+  DeltaLengthByteArrayEncoder<ByteArrayType> suffix_encoder_;
+  std::string last_value_;
+  const ByteArray empty_;
+  std::unique_ptr<ResizableBuffer> buffer_;
+};
+
+struct ByteArrayVisitor {
+  const ByteArray* src;
+
+  std::string_view operator[](int i) const {
+    if (ARROW_PREDICT_FALSE(src[i].len >= kMaxByteArraySize)) {
+      throw ParquetException("Parquet cannot store strings with size 2GB or more");
+    }
+    return std::string_view{src[i]};
+  }
+
+  uint32_t len(int i) const { return src[i].len; }
+};
+
+struct FLBAVisitor {
+  const FLBA* src;
+  const uint32_t type_length;
+
+  std::string_view operator[](int i) const {
+    return std::string_view{reinterpret_cast<const char*>(src[i].ptr), type_length};
+  }
+
+  uint32_t len(int i) const { return type_length; }
+};
+
+template <>
+void DeltaByteArrayEncoder<ByteArrayType>::Put(const ByteArray* src, int num_values) {
+  auto visitor = ByteArrayVisitor{src};
+  PutInternal<ByteArrayVisitor>(src, num_values, visitor);
+}
+
+template <>
+void DeltaByteArrayEncoder<FLBAType>::Put(const FLBA* src, int num_values) {
+  auto visitor = FLBAVisitor{src, static_cast<uint32_t>(descr_->type_length())};
+  PutInternal<FLBAVisitor>(src, num_values, visitor);
+}
+
+template <typename DType>
+void DeltaByteArrayEncoder<DType>::Put(const ::arrow::Array& values) {
+  if (::arrow::is_binary_like(values.type_id())) {
+    PutBinaryArray(checked_cast<const ::arrow::BinaryArray&>(values));
+  } else if (::arrow::is_large_binary_like(values.type_id())) {
+    PutBinaryArray(checked_cast<const ::arrow::LargeBinaryArray&>(values));
+  } else if (::arrow::is_fixed_size_binary(values.type_id())) {
+    PutBinaryArray(checked_cast<const ::arrow::FixedSizeBinaryArray&>(values));
+  } else {
+    throw ParquetException("Only BaseBinaryArray and subclasses supported");
+  }
+}
+
+template <typename DType>
+std::shared_ptr<Buffer> DeltaByteArrayEncoder<DType>::FlushValues() {
+  PARQUET_THROW_NOT_OK(sink_.Resize(EstimatedDataEncodedSize(), false));
+
+  std::shared_ptr<Buffer> prefix_lengths = prefix_length_encoder_.FlushValues();
+  PARQUET_THROW_NOT_OK(sink_.Append(prefix_lengths->data(), prefix_lengths->size()));
+
+  std::shared_ptr<Buffer> suffixes = suffix_encoder_.FlushValues();
+  PARQUET_THROW_NOT_OK(sink_.Append(suffixes->data(), suffixes->size()));
+
+  std::shared_ptr<Buffer> buffer;
+  PARQUET_THROW_NOT_OK(sink_.Finish(&buffer, true));
+  last_value_.clear();
+  return buffer;
+}
+
+// ----------------------------------------------------------------------
+// DeltaByteArrayDecoder
+
+template <typename DType>
+class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecoder<DType> {
+  using T = typename DType::c_type;
+
+ public:
+  explicit DeltaByteArrayDecoderImpl(const ColumnDescriptor* descr,
+                                     MemoryPool* pool = ::arrow::default_memory_pool())
       : DecoderImpl(descr, Encoding::DELTA_BYTE_ARRAY),
+        pool_(pool),
         prefix_len_decoder_(nullptr, pool),
         suffix_decoder_(nullptr, pool),
         last_value_in_previous_page_(""),
@@ -3017,27 +3321,22 @@ class DeltaByteArrayDecoder : public DecoderImpl,
     last_value_ = "";
   }
 
-  int Decode(ByteArray* buffer, int max_values) override {
-    return GetInternal(buffer, max_values);
-  }
-
   int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
                   int64_t valid_bits_offset,
-                  typename EncodingTraits<ByteArrayType>::Accumulator* out) override {
+                  typename EncodingTraits<DType>::Accumulator* out) override {
     int result = 0;
     PARQUET_THROW_NOT_OK(DecodeArrowDense(num_values, null_count, valid_bits,
                                           valid_bits_offset, out, &result));
     return result;
   }
 
-  int DecodeArrow(
-      int num_values, int null_count, const uint8_t* valid_bits,
-      int64_t valid_bits_offset,
-      typename EncodingTraits<ByteArrayType>::DictAccumulator* builder) override {
+  int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
+                  int64_t valid_bits_offset,
+                  typename EncodingTraits<DType>::DictAccumulator* builder) override {
     ParquetException::NYI("DecodeArrow of DictAccumulator for DeltaByteArrayDecoder");
   }
 
- private:
+ protected:
   int GetInternal(ByteArray* buffer, int max_values) {
     // Decode up to `max_values` strings into an internal buffer
     // and reference them into `buffer`.
@@ -3080,7 +3379,7 @@ class DeltaByteArrayDecoder : public DecoderImpl,
       buffer[i].ptr = data_ptr;
       buffer[i].len += prefix_len_ptr[i];
       data_ptr += buffer[i].len;
-      prefix = string_view{reinterpret_cast<const char*>(buffer[i].ptr), buffer[i].len};
+      prefix = std::string_view{buffer[i]};
     }
     prefix_len_offset_ += max_values;
     this->num_values_ -= max_values;
@@ -3095,9 +3394,10 @@ class DeltaByteArrayDecoder : public DecoderImpl,
 
   Status DecodeArrowDense(int num_values, int null_count, const uint8_t* valid_bits,
                           int64_t valid_bits_offset,
-                          typename EncodingTraits<ByteArrayType>::Accumulator* out,
+                          typename EncodingTraits<DType>::Accumulator* out,
                           int* out_num_values) {
-    ArrowBinaryHelper helper(out);
+    ArrowBinaryHelper<DType> helper(out, num_values);
+    RETURN_NOT_OK(helper.Prepare());
 
     std::vector<ByteArray> values(num_values);
     const int num_valid_values = GetInternal(values.data(), num_values - null_count);
@@ -3110,9 +3410,7 @@ class DeltaByteArrayDecoder : public DecoderImpl,
         valid_bits, valid_bits_offset, num_values, null_count,
         [&]() {
           const auto& val = values_ptr[value_idx];
-          if (ARROW_PREDICT_FALSE(!helper.CanFit(val.len))) {
-            RETURN_NOT_OK(helper.PushChunk());
-          }
+          RETURN_NOT_OK(helper.PrepareNextInput(val.len));
           RETURN_NOT_OK(helper.Append(val.ptr, static_cast<int32_t>(val.len)));
           ++value_idx;
           return Status::OK();
@@ -3128,18 +3426,54 @@ class DeltaByteArrayDecoder : public DecoderImpl,
     return Status::OK();
   }
 
+  MemoryPool* pool_;
+
+ private:
   std::shared_ptr<::arrow::bit_util::BitReader> decoder_;
   DeltaBitPackDecoder<Int32Type> prefix_len_decoder_;
   DeltaLengthByteArrayDecoder suffix_decoder_;
   std::string last_value_;
   // string buffer for last value in previous page
   std::string last_value_in_previous_page_;
-  int num_valid_values_;
-  uint32_t prefix_len_offset_;
+  int num_valid_values_{0};
+  uint32_t prefix_len_offset_{0};
   std::shared_ptr<ResizableBuffer> buffered_prefix_length_;
   std::shared_ptr<ResizableBuffer> buffered_data_;
 };
 
+class DeltaByteArrayDecoder : public DeltaByteArrayDecoderImpl<ByteArrayType> {
+ public:
+  using Base = DeltaByteArrayDecoderImpl<ByteArrayType>;
+  using Base::DeltaByteArrayDecoderImpl;
+
+  int Decode(ByteArray* buffer, int max_values) override {
+    return GetInternal(buffer, max_values);
+  }
+};
+
+class DeltaByteArrayFLBADecoder : public DeltaByteArrayDecoderImpl<FLBAType>,
+                                  virtual public FLBADecoder {
+ public:
+  using Base = DeltaByteArrayDecoderImpl<FLBAType>;
+  using Base::DeltaByteArrayDecoderImpl;
+  using Base::pool_;
+
+  int Decode(FixedLenByteArray* buffer, int max_values) override {
+    // GetInternal currently only support ByteArray.
+    std::vector<ByteArray> decode_byte_array(max_values);
+    const int decoded_values_size = GetInternal(decode_byte_array.data(), max_values);
+    const uint32_t type_length = descr_->type_length();
+
+    for (int i = 0; i < decoded_values_size; i++) {
+      if (ARROW_PREDICT_FALSE(decode_byte_array[i].len != type_length)) {
+        throw ParquetException("Fixed length byte array length mismatch");
+      }
+      buffer[i].ptr = decode_byte_array[i].ptr;
+    }
+    return decoded_values_size;
+  }
+};
+
 // ----------------------------------------------------------------------
 // BYTE_STREAM_SPLIT
 
@@ -3353,6 +3687,16 @@ std::unique_ptr<Encoder> MakeEncoder(Type::type type_num, Encoding::type encodin
       default:
         throw ParquetException("RLE only supports BOOLEAN");
     }
+  } else if (encoding == Encoding::DELTA_BYTE_ARRAY) {
+    switch (type_num) {
+      case Type::BYTE_ARRAY:
+        return std::make_unique<DeltaByteArrayEncoder<ByteArrayType>>(descr, pool);
+      case Type::FIXED_LEN_BYTE_ARRAY:
+        return std::make_unique<DeltaByteArrayEncoder<FLBAType>>(descr, pool);
+      default:
+        throw ParquetException(
+            "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
+    }
   } else {
     ParquetException::NYI("Selected encoding is not supported");
   }
@@ -3404,10 +3748,15 @@ std::unique_ptr<Decoder> MakeDecoder(Type::type type_num, Encoding::type encodin
             "DELTA_BINARY_PACKED decoder only supports INT32 and INT64");
     }
   } else if (encoding == Encoding::DELTA_BYTE_ARRAY) {
-    if (type_num == Type::BYTE_ARRAY) {
-      return std::make_unique<DeltaByteArrayDecoder>(descr, pool);
+    switch (type_num) {
+      case Type::BYTE_ARRAY:
+        return std::make_unique<DeltaByteArrayDecoder>(descr, pool);
+      case Type::FIXED_LEN_BYTE_ARRAY:
+        return std::make_unique<DeltaByteArrayFLBADecoder>(descr, pool);
+      default:
+        throw ParquetException(
+            "DELTA_BYTE_ARRAY only supports BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY");
     }
-    throw ParquetException("DELTA_BYTE_ARRAY only supports BYTE_ARRAY");
   } else if (encoding == Encoding::DELTA_LENGTH_BYTE_ARRAY) {
     if (type_num == Type::BYTE_ARRAY) {
       return std::make_unique<DeltaLengthByteArrayDecoder>(descr, pool);
diff --git a/cpp/src/parquet/encoding.h b/cpp/src/parquet/encoding.h
index 9f9b740ff3424..6cdfe37920200 100644
--- a/cpp/src/parquet/encoding.h
+++ b/cpp/src/parquet/encoding.h
@@ -141,13 +141,13 @@ struct EncodingTraits<ByteArrayType> {
   using Encoder = ByteArrayEncoder;
   using Decoder = ByteArrayDecoder;
 
+  using ArrowType = ::arrow::BinaryType;
   /// \brief Internal helper class for decoding BYTE_ARRAY data where we can
   /// overflow the capacity of a single arrow::BinaryArray
   struct Accumulator {
     std::unique_ptr<::arrow::BinaryBuilder> builder;
     std::vector<std::shared_ptr<::arrow::Array>> chunks;
   };
-  using ArrowType = ::arrow::BinaryType;
   using DictAccumulator = ::arrow::Dictionary32Builder<::arrow::BinaryType>;
 };
 
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 0ac5fd76e79c9..71dc40d33ac47 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -36,6 +36,7 @@
 #include "arrow/util/bitmap_writer.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/span.h"
 #include "arrow/util/string.h"
 #include "parquet/encoding.h"
 #include "parquet/platform.h"
@@ -181,7 +182,7 @@ class TestEncodingBase : public ::testing::Test {
 
   void TearDown() {}
 
-  void InitData(int nvalues, int repeats) {
+  virtual void InitData(int nvalues, int repeats) {
     num_values_ = nvalues * repeats;
     input_bytes_.resize(num_values_ * sizeof(c_type));
     output_bytes_.resize(num_values_ * sizeof(c_type));
@@ -1705,11 +1706,13 @@ class TestDeltaLengthByteArrayEncoding : public TestEncodingBase<Type> {
   using c_type = typename Type::c_type;
   static constexpr int TYPE = Type::type_num;
 
+  virtual Encoding::type GetEncoding() { return Encoding::DELTA_LENGTH_BYTE_ARRAY; }
+
   virtual void CheckRoundtrip() {
-    auto encoder = MakeTypedEncoder<Type>(Encoding::DELTA_LENGTH_BYTE_ARRAY,
+    auto encoding = GetEncoding();
+    auto encoder = MakeTypedEncoder<Type>(encoding,
                                           /*use_dictionary=*/false, descr_.get());
-    auto decoder =
-        MakeTypedDecoder<Type>(Encoding::DELTA_LENGTH_BYTE_ARRAY, descr_.get());
+    auto decoder = MakeTypedDecoder<Type>(encoding, descr_.get());
 
     encoder->Put(draws_, num_values_);
     encode_buffer_ = encoder->FlushValues();
@@ -1722,10 +1725,10 @@ class TestDeltaLengthByteArrayEncoding : public TestEncodingBase<Type> {
   }
 
   void CheckRoundtripSpaced(const uint8_t* valid_bits, int64_t valid_bits_offset) {
-    auto encoder = MakeTypedEncoder<Type>(Encoding::DELTA_LENGTH_BYTE_ARRAY,
+    auto encoding = GetEncoding();
+    auto encoder = MakeTypedEncoder<Type>(encoding,
                                           /*use_dictionary=*/false, descr_.get());
-    auto decoder =
-        MakeTypedDecoder<Type>(Encoding::DELTA_LENGTH_BYTE_ARRAY, descr_.get());
+    auto decoder = MakeTypedDecoder<Type>(encoding, descr_.get());
     int null_count = 0;
     for (auto i = 0; i < num_values_; i++) {
       if (!bit_util::GetBit(valid_bits, valid_bits_offset + i)) {
@@ -1771,6 +1774,19 @@ std::shared_ptr<Buffer> DeltaEncode(std::vector<int32_t> lengths) {
   return encoder->FlushValues();
 }
 
+std::shared_ptr<Buffer> DeltaEncode(::arrow::util::span<const int32_t> lengths) {
+  auto encoder = MakeTypedEncoder<Int32Type>(Encoding::DELTA_BINARY_PACKED);
+  encoder->Put(lengths.data(), static_cast<int>(lengths.size()));
+  return encoder->FlushValues();
+}
+
+std::shared_ptr<Buffer> DeltaEncode(std::shared_ptr<::arrow::Array>& lengths) {
+  auto data = ::arrow::internal::checked_pointer_cast<const ::arrow::Int32Array>(lengths);
+  auto span = ::arrow::util::span<const int32_t>{data->raw_values(),
+                                                 static_cast<size_t>(lengths->length())};
+  return DeltaEncode(span);
+}
+
 TEST(TestDeltaLengthByteArrayEncoding, AdHocRoundTrip) {
   const std::shared_ptr<::arrow::Array> cases[] = {
       ::arrow::ArrayFromJSON(::arrow::utf8(), R"([])"),
@@ -1780,10 +1796,10 @@ TEST(TestDeltaLengthByteArrayEncoding, AdHocRoundTrip) {
   };
 
   std::string expected_encoded_vals[] = {
-      DeltaEncode({})->ToString(),
-      DeltaEncode({3, 2, 0})->ToString() + "abcde",
-      DeltaEncode({0, 0, 0})->ToString(),
-      DeltaEncode({0, 3})->ToString() + "xyz",
+      DeltaEncode(std::vector<int>({}))->ToString(),
+      DeltaEncode(std::vector<int>({3, 2, 0}))->ToString() + "abcde",
+      DeltaEncode(std::vector<int>({0, 0, 0}))->ToString(),
+      DeltaEncode(std::vector<int>({0, 3}))->ToString() + "xyz",
   };
 
   auto encoder = MakeTypedEncoder<ByteArrayType>(Encoding::DELTA_LENGTH_BYTE_ARRAY,
@@ -1894,7 +1910,6 @@ TEST(DeltaLengthByteArrayEncodingAdHoc, ArrowBinaryDirectPut) {
     ASSERT_EQ(values->length(), result->length());
     ASSERT_OK(result->ValidateFull());
 
-    auto upcast_result = CastBinaryTypesHelper(result, values->type());
     ::arrow::AssertArraysEqual(*values, *result);
   };
 
@@ -1977,4 +1992,263 @@ TEST(DeltaLengthByteArrayEncodingAdHoc, ArrowDirectPut) {
   CheckDecode(encoded, ::arrow::ArrayFromJSON(::arrow::large_binary(), values));
 }
 
+// ----------------------------------------------------------------------
+// DELTA_BYTE_ARRAY encode/decode tests.
+
+template <typename Type>
+class TestDeltaByteArrayEncoding : public TestDeltaLengthByteArrayEncoding<Type> {
+ public:
+  using c_type = typename Type::c_type;
+  static constexpr int TYPE = Type::type_num;
+  static constexpr double prefixed_probability = 0.5;
+
+  void InitData(int nvalues, int repeats) override {
+    num_values_ = nvalues * repeats;
+    input_bytes_.resize(num_values_ * sizeof(c_type));
+    output_bytes_.resize(num_values_ * sizeof(c_type));
+    draws_ = reinterpret_cast<c_type*>(input_bytes_.data());
+    decode_buf_ = reinterpret_cast<c_type*>(output_bytes_.data());
+    GeneratePrefixedData<c_type>(nvalues, draws_, &data_buffer_, prefixed_probability);
+
+    // add some repeated values
+    for (int j = 1; j < repeats; ++j) {
+      for (int i = 0; i < nvalues; ++i) {
+        draws_[nvalues * j + i] = draws_[i];
+      }
+    }
+  }
+
+  Encoding::type GetEncoding() override { return Encoding::DELTA_BYTE_ARRAY; }
+
+ protected:
+  USING_BASE_MEMBERS();
+  std::vector<uint8_t> input_bytes_;
+  std::vector<uint8_t> output_bytes_;
+};
+
+using TestDeltaByteArrayEncodingTypes = ::testing::Types<ByteArrayType, FLBAType>;
+TYPED_TEST_SUITE(TestDeltaByteArrayEncoding, TestDeltaByteArrayEncodingTypes);
+
+TYPED_TEST(TestDeltaByteArrayEncoding, BasicRoundTrip) {
+  ASSERT_NO_FATAL_FAILURE(this->Execute(0, /*repeats=*/0));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(250, 5));
+  ASSERT_NO_FATAL_FAILURE(this->Execute(2000, 1));
+  ASSERT_NO_FATAL_FAILURE(this->ExecuteSpaced(
+      /*nvalues*/ 1234, /*repeats*/ 1, /*valid_bits_offset*/ 64, /*null_probability*/
+      0));
+  ASSERT_NO_FATAL_FAILURE(this->ExecuteSpaced(
+      /*nvalues*/ 1234, /*repeats*/ 10, /*valid_bits_offset*/ 64,
+      /*null_probability*/ 0.5));
+}
+
+template <typename Type>
+class TestDeltaByteArrayEncodingDirectPut : public TestEncodingBase<Type> {
+  using ArrowType = typename EncodingTraits<Type>::ArrowType;
+  using Accumulator = typename EncodingTraits<Type>::Accumulator;
+  using BuilderType = typename ::arrow::TypeTraits<ArrowType>::BuilderType;
+
+ public:
+  std::unique_ptr<TypedEncoder<Type>> encoder =
+      MakeTypedEncoder<Type>(Encoding::DELTA_BYTE_ARRAY);
+  std::unique_ptr<TypedDecoder<Type>> decoder =
+      MakeTypedDecoder<Type>(Encoding::DELTA_BYTE_ARRAY);
+
+  void CheckDirectPut(std::shared_ptr<::arrow::Array> array);
+
+  void CheckRoundtrip() override;
+
+ protected:
+  USING_BASE_MEMBERS();
+};
+
+template <>
+void TestDeltaByteArrayEncodingDirectPut<ByteArrayType>::CheckDirectPut(
+    std::shared_ptr<::arrow::Array> array) {
+  ASSERT_NO_THROW(encoder->Put(*array));
+  auto buf = encoder->FlushValues();
+
+  int num_values = static_cast<int>(array->length() - array->null_count());
+  decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+  Accumulator acc;
+  acc.builder = std::make_unique<BuilderType>(array->type(), default_memory_pool());
+
+  ASSERT_EQ(num_values,
+            decoder->DecodeArrow(static_cast<int>(array->length()),
+                                 static_cast<int>(array->null_count()),
+                                 array->null_bitmap_data(), array->offset(), &acc));
+
+  ASSERT_EQ(acc.chunks.size(), 0) << "Accumulator shouldn't have overflowed chunks";
+  ASSERT_OK_AND_ASSIGN(auto result, acc.builder->Finish());
+  ASSERT_EQ(array->length(), result->length());
+  ASSERT_OK(result->ValidateFull());
+
+  ::arrow::AssertArraysEqual(*array, *result);
+}
+
+template <>
+void TestDeltaByteArrayEncodingDirectPut<FLBAType>::CheckDirectPut(
+    std::shared_ptr<::arrow::Array> array) {
+  ASSERT_NO_THROW(encoder->Put(*array));
+  auto buf = encoder->FlushValues();
+
+  int num_values = static_cast<int>(array->length() - array->null_count());
+  decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+  Accumulator acc(array->type(), default_memory_pool());
+
+  ASSERT_EQ(num_values,
+            decoder->DecodeArrow(static_cast<int>(array->length()),
+                                 static_cast<int>(array->null_count()),
+                                 array->null_bitmap_data(), array->offset(), &acc));
+
+  ASSERT_OK_AND_ASSIGN(auto result, acc.Finish());
+  ASSERT_EQ(array->length(), result->length());
+  ASSERT_OK(result->ValidateFull());
+
+  ::arrow::AssertArraysEqual(*array, *result);
+}
+
+template <>
+void TestDeltaByteArrayEncodingDirectPut<ByteArrayType>::CheckRoundtrip() {
+  constexpr int64_t kSize = 500;
+  constexpr int32_t kMinLength = 0;
+  constexpr int32_t kMaxLength = 10;
+  constexpr int32_t kNumUnique = 10;
+  constexpr double kNullProbability = 0.25;
+  constexpr int kSeed = 42;
+  ::arrow::random::RandomArrayGenerator rag{kSeed};
+  std::shared_ptr<::arrow::Array> values = rag.BinaryWithRepeats(
+      /*size=*/1, /*unique=*/1, kMinLength, kMaxLength, kNullProbability);
+  CheckDirectPut(values);
+
+  for (int i = 0; i < 10; ++i) {
+    values = rag.BinaryWithRepeats(kSize, kNumUnique, kMinLength, kMaxLength,
+                                   kNullProbability);
+    CheckDirectPut(values);
+  }
+}
+
+template <>
+void TestDeltaByteArrayEncodingDirectPut<FLBAType>::CheckRoundtrip() {
+  constexpr int64_t kSize = 50;
+  constexpr int kSeed = 42;
+  constexpr int kByteWidth = 4;
+  ::arrow::random::RandomArrayGenerator rag{kSeed};
+  std::shared_ptr<::arrow::Array> values =
+      rag.FixedSizeBinary(/*size=*/0, /*byte_width=*/kByteWidth);
+  CheckDirectPut(values);
+
+  for (auto seed : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) {
+    values = rag.FixedSizeBinary(kSize + seed, kByteWidth);
+    CheckDirectPut(values);
+  }
+}
+
+TYPED_TEST_SUITE(TestDeltaByteArrayEncodingDirectPut, TestDeltaByteArrayEncodingTypes);
+
+TYPED_TEST(TestDeltaByteArrayEncodingDirectPut, DirectPut) {
+  ASSERT_NO_FATAL_FAILURE(this->CheckRoundtrip());
+}
+
+TEST(DeltaByteArrayEncodingAdHoc, ArrowDirectPut) {
+  auto CheckEncode = [](const std::shared_ptr<::arrow::Array>& values,
+                        const std::shared_ptr<Buffer>& encoded) {
+    auto encoder = MakeTypedEncoder<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+    ASSERT_NO_THROW(encoder->Put(*values));
+    auto buf = encoder->FlushValues();
+    ASSERT_TRUE(encoded->Equals(*buf));
+  };
+
+  auto CheckDecode = [](std::shared_ptr<Buffer> buf,
+                        std::shared_ptr<::arrow::Array> values) {
+    int num_values = static_cast<int>(values->length());
+    auto decoder = MakeTypedDecoder<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+    decoder->SetData(num_values, buf->data(), static_cast<int>(buf->size()));
+
+    typename EncodingTraits<ByteArrayType>::Accumulator acc;
+    if (::arrow::is_string(values->type()->id())) {
+      acc.builder = std::make_unique<::arrow::StringBuilder>();
+    } else {
+      acc.builder = std::make_unique<::arrow::BinaryBuilder>();
+    }
+
+    ASSERT_EQ(num_values,
+              decoder->DecodeArrow(static_cast<int>(values->length()),
+                                   static_cast<int>(values->null_count()),
+                                   values->null_bitmap_data(), values->offset(), &acc));
+
+    std::shared_ptr<::arrow::Array> result;
+    ASSERT_OK(acc.builder->Finish(&result));
+    ASSERT_EQ(num_values, result->length());
+    ASSERT_OK(result->ValidateFull());
+
+    auto upcast_result = CastBinaryTypesHelper(result, values->type());
+    ::arrow::AssertArraysEqual(*values, *upcast_result);
+  };
+
+  auto CheckEncodeDecode = [&](std::string_view values,
+                               std::shared_ptr<::arrow::Array> prefix_lengths,
+                               std::shared_ptr<::arrow::Array> suffix_lengths,
+                               std::string_view suffix_data) {
+    auto encoded = ::arrow::ConcatenateBuffers({DeltaEncode(prefix_lengths),
+                                                DeltaEncode(suffix_lengths),
+                                                std::make_shared<Buffer>(suffix_data)})
+                       .ValueOrDie();
+
+    CheckEncode(::arrow::ArrayFromJSON(::arrow::utf8(), values), encoded);
+    CheckEncode(::arrow::ArrayFromJSON(::arrow::large_utf8(), values), encoded);
+    CheckEncode(::arrow::ArrayFromJSON(::arrow::binary(), values), encoded);
+    CheckEncode(::arrow::ArrayFromJSON(::arrow::large_binary(), values), encoded);
+
+    CheckDecode(encoded, ::arrow::ArrayFromJSON(::arrow::utf8(), values));
+    CheckDecode(encoded, ::arrow::ArrayFromJSON(::arrow::large_utf8(), values));
+    CheckDecode(encoded, ::arrow::ArrayFromJSON(::arrow::binary(), values));
+    CheckDecode(encoded, ::arrow::ArrayFromJSON(::arrow::large_binary(), values));
+  };
+
+  {
+    auto values = R"(["axis", "axle", "babble", "babyhood"])";
+    auto prefix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([0, 2, 0, 3])");
+    auto suffix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([4, 2, 6, 5])");
+
+    constexpr std::string_view suffix_data = "axislebabbleyhood";
+    CheckEncodeDecode(values, prefix_lengths, suffix_lengths, suffix_data);
+  }
+
+  {
+    auto values = R"(["axis", "axis", "axis", "axis"])";
+    auto prefix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([0, 4, 4, 4])");
+    auto suffix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([4, 0, 0, 0])");
+
+    constexpr std::string_view suffix_data = "axis";
+    CheckEncodeDecode(values, prefix_lengths, suffix_lengths, suffix_data);
+  }
+
+  {
+    auto values = R"(["axisba", "axis", "axis", "axis"])";
+    auto prefix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([0, 4, 4, 4])");
+    auto suffix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([6, 0, 0, 0])");
+
+    constexpr std::string_view suffix_data = "axisba";
+    CheckEncodeDecode(values, prefix_lengths, suffix_lengths, suffix_data);
+  }
+
+  {
+    auto values = R"(["baaxis", "axis", "axis", "axis"])";
+    auto prefix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([0, 0, 4, 4])");
+    auto suffix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([6, 4, 0, 0])");
+
+    constexpr std::string_view suffix_data = "baaxisaxis";
+    CheckEncodeDecode(values, prefix_lengths, suffix_lengths, suffix_data);
+  }
+
+  {
+    auto values = R"(["καλημέρα", "καμηλιέρη", "καμηλιέρη", "καλημέρα"])";
+    auto prefix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([0, 5, 18, 5])");
+    auto suffix_lengths = ::arrow::ArrayFromJSON(::arrow::int32(), R"([16, 13, 0, 11])");
+    const std::string suffix_data = "καλημέρα\xbcηλιέρη\xbbημέρα";
+    CheckEncodeDecode(values, prefix_lengths, suffix_lengths, suffix_data);
+  }
+}
 }  // namespace parquet::test
diff --git a/cpp/src/parquet/test_util.cc b/cpp/src/parquet/test_util.cc
index 9d104618bfd7e..b65945cc7329f 100644
--- a/cpp/src/parquet/test_util.cc
+++ b/cpp/src/parquet/test_util.cc
@@ -30,6 +30,7 @@
 #include <utility>
 #include <vector>
 
+#include "arrow/testing/uniform_real.h"
 #include "parquet/column_page.h"
 #include "parquet/column_reader.h"
 #include "parquet/column_writer.h"
@@ -132,5 +133,56 @@ void random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out, int m
   random_byte_array(n, seed, buf, out, 0, max_size);
 }
 
+void prefixed_random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out,
+                                int min_size, int max_size, double prefixed_probability) {
+  std::default_random_engine gen(seed);
+  std::uniform_int_distribution<int> dist_size(min_size, max_size);
+  std::uniform_int_distribution<int> dist_byte(0, 255);
+  std::bernoulli_distribution dist_has_prefix(prefixed_probability);
+  std::uniform_real_distribution<double> dist_prefix_length(0, 1);
+
+  for (int i = 0; i < n; ++i) {
+    int len = dist_size(gen);
+    out[i].len = len;
+    out[i].ptr = buf;
+
+    bool do_prefix = dist_has_prefix(gen) && i > 0;
+    int prefix_len = 0;
+    if (do_prefix) {
+      int max_prefix_len = std::min(len, static_cast<int>(out[i - 1].len));
+      prefix_len = static_cast<int>(std::ceil(max_prefix_len * dist_prefix_length(gen)));
+    }
+    for (int j = 0; j < prefix_len; ++j) {
+      buf[j] = out[i - 1].ptr[j];
+    }
+    for (int j = prefix_len; j < len; ++j) {
+      buf[j] = static_cast<uint8_t>(dist_byte(gen));
+    }
+    buf += len;
+  }
+}
+
+void prefixed_random_byte_array(int n, uint32_t seed, uint8_t* buf, int len, FLBA* out,
+                                double prefixed_probability) {
+  std::default_random_engine gen(seed);
+  std::uniform_int_distribution<int> dist_byte(0, 255);
+  std::bernoulli_distribution dist_has_prefix(prefixed_probability);
+  std::uniform_int_distribution<int> dist_size(0, len);
+
+  for (int i = 0; i < n; ++i) {
+    out[i].ptr = buf;
+
+    bool do_prefix = dist_has_prefix(gen) && i > 0;
+    int prefix_len = do_prefix ? dist_size(gen) : 0;
+    for (int j = 0; j < prefix_len; ++j) {
+      buf[j] = out[i - 1].ptr[j];
+    }
+    for (int j = prefix_len; j < len; ++j) {
+      buf[j] = static_cast<uint8_t>(dist_byte(gen));
+    }
+    buf += len;
+  }
+}
+
 }  // namespace test
 }  // namespace parquet
diff --git a/cpp/src/parquet/test_util.h b/cpp/src/parquet/test_util.h
index b0aafa037ead1..c8578609e9b1d 100644
--- a/cpp/src/parquet/test_util.h
+++ b/cpp/src/parquet/test_util.h
@@ -155,6 +155,12 @@ void random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out, int m
 
 void random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out, int max_size);
 
+void prefixed_random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out,
+                                int min_size, int max_size, double prefixed_probability);
+
+void prefixed_random_byte_array(int n, uint32_t seed, uint8_t* buf, int len, FLBA* out,
+                                double prefixed_probability);
+
 template <typename Type, typename Sequence>
 std::shared_ptr<Buffer> EncodeValues(Encoding::type encoding, bool use_dictionary,
                                      const Sequence& values, int length,
@@ -777,18 +783,46 @@ inline void GenerateData<Int96>(int num_values, Int96* out, std::vector<uint8_t>
 template <>
 inline void GenerateData<ByteArray>(int num_values, ByteArray* out,
                                     std::vector<uint8_t>* heap) {
-  // seed the prng so failure is deterministic
   int max_byte_array_len = 12;
   heap->resize(num_values * max_byte_array_len);
+  // seed the prng so failure is deterministic
   random_byte_array(num_values, 0, heap->data(), out, 2, max_byte_array_len);
 }
 
+// Generate ByteArray or FLBA data where there is a given probability
+// for each value to share a common prefix with its predecessor.
+// This is useful to exercise prefix-based encodings such as DELTA_BYTE_ARRAY.
+template <typename T>
+inline void GeneratePrefixedData(int num_values, T* out, std::vector<uint8_t>* heap,
+                                 double prefixed_probability);
+
+template <>
+inline void GeneratePrefixedData(int num_values, ByteArray* out,
+                                 std::vector<uint8_t>* heap,
+                                 double prefixed_probability) {
+  int max_byte_array_len = 12;
+  heap->resize(num_values * max_byte_array_len);
+  // seed the prng so failure is deterministic
+  prefixed_random_byte_array(num_values, /*seed=*/0, heap->data(), out, /*min_size=*/2,
+                             /*max_size=*/max_byte_array_len, prefixed_probability);
+}
+
 static constexpr int kGenerateDataFLBALength = 8;
 
 template <>
-inline void GenerateData<FLBA>(int num_values, FLBA* out, std::vector<uint8_t>* heap) {
+inline void GeneratePrefixedData<FLBA>(int num_values, FLBA* out,
+                                       std::vector<uint8_t>* heap,
+                                       double prefixed_probability) {
+  heap->resize(num_values * kGenerateDataFLBALength);
   // seed the prng so failure is deterministic
+  prefixed_random_byte_array(num_values, /*seed=*/0, heap->data(),
+                             kGenerateDataFLBALength, out, prefixed_probability);
+}
+
+template <>
+inline void GenerateData<FLBA>(int num_values, FLBA* out, std::vector<uint8_t>* heap) {
   heap->resize(num_values * kGenerateDataFLBALength);
+  // seed the prng so failure is deterministic
   random_fixed_byte_array(num_values, 0, heap->data(), kGenerateDataFLBALength, out);
 }
 
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index e81e9de0a1efa..0315376a883e9 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -577,6 +577,11 @@ struct ByteArray {
   ByteArray(::std::string_view view)  // NOLINT implicit conversion
       : ByteArray(static_cast<uint32_t>(view.size()),
                   reinterpret_cast<const uint8_t*>(view.data())) {}
+
+  explicit operator std::string_view() const {
+    return std::string_view{reinterpret_cast<const char*>(ptr), len};
+  }
+
   uint32_t len;
   const uint8_t* ptr;
 };
diff --git a/docs/source/cpp/parquet.rst b/docs/source/cpp/parquet.rst
index 95f2d8d98dc0a..23fca8fd73010 100644
--- a/docs/source/cpp/parquet.rst
+++ b/docs/source/cpp/parquet.rst
@@ -401,7 +401,7 @@ Encodings
 +--------------------------+----------+----------+---------+
 | DELTA_BINARY_PACKED      | ✓        | ✓        |         |
 +--------------------------+----------+----------+---------+
-| DELTA_BYTE_ARRAY         | ✓        |          |         |
+| DELTA_BYTE_ARRAY         | ✓        | ✓        |         |
 +--------------------------+----------+----------+---------+
 | DELTA_LENGTH_BYTE_ARRAY  | ✓        | ✓        |         |
 +--------------------------+----------+----------+---------+
diff --git a/python/pyarrow/tests/parquet/test_basic.py b/python/pyarrow/tests/parquet/test_basic.py
index 9bc59cbcf96eb..dd12a2661656a 100644
--- a/python/pyarrow/tests/parquet/test_basic.py
+++ b/python/pyarrow/tests/parquet/test_basic.py
@@ -392,9 +392,13 @@ def test_byte_stream_split(use_legacy_dataset):
 def test_column_encoding(use_legacy_dataset):
     arr_float = pa.array(list(map(float, range(100))))
     arr_int = pa.array(list(map(int, range(100))))
-    arr_bin = pa.array([str(x) for x in range(100)])
-    mixed_table = pa.Table.from_arrays([arr_float, arr_int, arr_bin],
-                                       names=['a', 'b', 'c'])
+    arr_bin = pa.array([str(x) for x in range(100)], type=pa.binary())
+    arr_flba = pa.array(
+        [str(x).zfill(10) for x in range(100)], type=pa.binary(10))
+    arr_bool = pa.array([False, True, False, False] * 25)
+    mixed_table = pa.Table.from_arrays(
+        [arr_float, arr_int, arr_bin, arr_flba, arr_bool],
+        names=['a', 'b', 'c', 'd', 'e'])
 
     # Check "BYTE_STREAM_SPLIT" for column 'a' and "PLAIN" column_encoding for
     # column 'b' and 'c'.
@@ -426,6 +430,21 @@ def test_column_encoding(use_legacy_dataset):
                                       'c': "DELTA_LENGTH_BYTE_ARRAY"},
                      use_legacy_dataset=use_legacy_dataset)
 
+    # Check "DELTA_BYTE_ARRAY" for byte columns.
+    _check_roundtrip(mixed_table, expected=mixed_table,
+                     use_dictionary=False,
+                     column_encoding={'a': "PLAIN",
+                                      'b': "DELTA_BINARY_PACKED",
+                                      'c': "DELTA_BYTE_ARRAY",
+                                      'd': "DELTA_BYTE_ARRAY"},
+                     use_legacy_dataset=use_legacy_dataset)
+
+    # Check "RLE" for boolean columns.
+    _check_roundtrip(mixed_table, expected=mixed_table,
+                     use_dictionary=False,
+                     column_encoding={'e': "RLE"},
+                     use_legacy_dataset=use_legacy_dataset)
+
     # Try to pass "BYTE_STREAM_SPLIT" column encoding for integer column 'b'.
     # This should throw an error as it is only supports FLOAT and DOUBLE.
     with pytest.raises(IOError,

From 3262debb107599a39c39c78b461029ee5910669b Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 21 Aug 2023 13:49:33 -0400
Subject: [PATCH 198/749] GH-37252: [MATLAB] Add `arrow.type.DateUnit`
 enumeration class (#37280)

### Rationale for this change

In support of adding  `arrow.type.Date32Type` and `arrow.type.Date64Type`, this pull request adds a `arrow.type.DateUnit` enumeration class mirroring the `arrow.type.TimeUnit` enumeration class.

`arrow.type.DateUnit` will have two values: `Day` and `Millisecond`.

### What changes are included in this PR?

1. Added a new enumeration class `arrow.type.DateUnit` which mirrors the `arrow.type.TimeUnit` enumeration class.

**Example**:

```matlab
>> day = arrow.type.DateUnit.Day

day =

  DateUnit enumeration

    Day

>> millisecond = arrow.type.DateUnit.Millisecond

millisecond =

  DateUnit enumeration

    Millisecond
```

### Are these changes tested?

Yes.

1. Added a new test class `tDateUnit` for `arrow.type.DateUnit` tests.
2. Updated code for `tTimeUnit` for consistency with `tDateUnit`.

### Are there any user-facing changes?

Yes.

1. There is now a new user-facing `arrow.type.DateUnit` enumeration class.

### Future Directions

1. Add an `arrow.internal.validate.temporal.dateUnit` helper function that mirrors `arrow.internal.validate.temporal.timeUnit`.
2. #37229
3. #37230
* Closes: #37252

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+type/DateUnit.m | 24 ++++++++++++
 matlab/src/matlab/+arrow/+type/TimeUnit.m |  5 ++-
 matlab/test/arrow/type/tDateUnit.m        | 40 ++++++++++++++++++++
 matlab/test/arrow/type/tTimeUnit.m        | 45 ++++++++++++++---------
 4 files changed, 95 insertions(+), 19 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+type/DateUnit.m
 create mode 100644 matlab/test/arrow/type/tDateUnit.m

diff --git a/matlab/src/matlab/+arrow/+type/DateUnit.m b/matlab/src/matlab/+arrow/+type/DateUnit.m
new file mode 100644
index 0000000000000..bb82de5b02ab3
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/DateUnit.m
@@ -0,0 +1,24 @@
+% Enumeration class representing Date Units.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef DateUnit < uint8
+
+    enumeration
+        Day          (0)
+        Millisecond  (1)
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/TimeUnit.m b/matlab/src/matlab/+arrow/+type/TimeUnit.m
index 358818be985c9..802ff124c21a1 100644
--- a/matlab/src/matlab/+arrow/+type/TimeUnit.m
+++ b/matlab/src/matlab/+arrow/+type/TimeUnit.m
@@ -1,3 +1,5 @@
+% Enumeration class representing Time Units.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -12,8 +14,7 @@
 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
-classdef TimeUnit < int16
-% Enumeration class representing Time Units.
+classdef TimeUnit < uint8
 
     enumeration
         Second       (0)
diff --git a/matlab/test/arrow/type/tDateUnit.m b/matlab/test/arrow/type/tDateUnit.m
new file mode 100644
index 0000000000000..b0108bf4b3b0d
--- /dev/null
+++ b/matlab/test/arrow/type/tDateUnit.m
@@ -0,0 +1,40 @@
+% Tests for the arrow.type.DateUnit enumeration class
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tDateUnit < matlab.unittest.TestCase
+
+    properties (Constant)
+        ClassName = "arrow.type.DateUnit";
+        EnumerationValues = [ ...
+            arrow.type.DateUnit.Day; ...
+            arrow.type.DateUnit.Millisecond ...
+        ];
+    end
+    
+    methods (Test)
+
+        function SupportedValues(testCase)
+            % Verify there are two supported DateUnit enumeration values.
+
+            actualEnumerationValues = enumeration(testCase.ClassName);
+
+            testCase.verifyEqual(actualEnumerationValues, testCase.EnumerationValues);
+        end
+
+    end
+
+end
+
diff --git a/matlab/test/arrow/type/tTimeUnit.m b/matlab/test/arrow/type/tTimeUnit.m
index 0c2432193a3af..4a1a866b23dff 100644
--- a/matlab/test/arrow/type/tTimeUnit.m
+++ b/matlab/test/arrow/type/tTimeUnit.m
@@ -1,3 +1,5 @@
+% Tests for the arrow.type.TimeUnit enumeration class
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,29 +15,38 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 classdef tTimeUnit < matlab.unittest.TestCase
-% Test class for arrow.type.timeUnit
+
+    properties (Constant)
+        ClassName = "arrow.type.TimeUnit";
+        EnumerationValues = [ ...
+            arrow.type.TimeUnit.Second; ...
+            arrow.type.TimeUnit.Millisecond; ...
+            arrow.type.TimeUnit.Microsecond; ...
+            arrow.type.TimeUnit.Nanosecond ...
+        ];
+    end
     
     methods (Test)
-        function Values(testCase)
-        % Verify there are four TimeUnit enum values.
-            import arrow.type.TimeUnit
-            values = enumeration(TimeUnit.Second);
-            expectedValues = [TimeUnit.Second, TimeUnit.Millisecond, ...
-                              TimeUnit.Microsecond, TimeUnit.Nanosecond]';
-            testCase.verifyEqual(values, expectedValues);
+
+        function SupportedValues(testCase)
+            % Verify there are four supported TimeUnit enumeration values.
+
+            actualEnumerationValues = enumeration(testCase.ClassName);
+
+            testCase.verifyEqual(actualEnumerationValues, testCase.EnumerationValues);
         end
 
         function TicksPerSecond(testCase)
-        % Verify the TicksPerSecond property has the right value for each
-        % TimeUnit value.
-            import arrow.type.TimeUnit
-            units = [TimeUnit.Second, TimeUnit.Millisecond, ...
-                              TimeUnit.Microsecond, TimeUnit.Nanosecond]';
-            ticks = [1 1e3 1e6 1e9];
-            for ii = 1:numel(units)
-                testCase.verifyEqual(ticksPerSecond(units(ii)), ticks(ii));
+            % Verify the TicksPerSecond property has the right value for
+            % each TimeUnit enumeration value.
+
+            expectedTicksPerSecond = [1 1e3 1e6 1e9];
+            for ii = 1:numel(testCase.EnumerationValues)
+                actualTicksPerSecond = ticksPerSecond(testCase.EnumerationValues(ii));
+                testCase.verifyEqual(actualTicksPerSecond, expectedTicksPerSecond(ii));
             end
         end
+
     end
-end
 
+end
\ No newline at end of file

From 37a9f27e658474a929f351c89c90159b401fb8ca Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 21 Aug 2023 13:23:45 -0700
Subject: [PATCH 199/749] GH-33032: [C#] Support fixed-size lists (#35716)

### What changes are included in this PR?

Support fixed-size lists in the C# implementation.
Adds Archery support for Lists, Structs and Fixed-size Lists in the C# implementation.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Fixed-size lists are now supported for C#.

* Closes: #33032
* Closes: #32886

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../Arrays/ArrayDataConcatenator.cs           |  10 +
 .../Arrays/ArrayDataTypeComparer.cs           |  11 +
 .../Arrays/ArrowArrayBuilderFactory.cs        |   2 +
 .../Apache.Arrow/Arrays/ArrowArrayFactory.cs  |   2 +
 .../Apache.Arrow/Arrays/DateArrayBuilder.cs   |   2 +-
 .../Arrays/DelegatingArrayBuilder.cs          |   6 +
 .../Apache.Arrow/Arrays/FixedSizeListArray.cs | 190 ++++++++++++++++++
 .../Apache.Arrow/Arrays/TimeArrayBuilder.cs   |   2 +-
 .../src/Apache.Arrow/C/CArrowArrayImporter.cs |  23 ++-
 .../Apache.Arrow/C/CArrowSchemaExporter.cs    |   2 +
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |  21 ++
 csharp/src/Apache.Arrow/Field.cs              |  10 +-
 .../Interfaces/IArrowArrayBuilder.cs          |   4 +-
 .../Ipc/ArrowReaderImplementation.cs          |   2 +-
 .../src/Apache.Arrow/Ipc/ArrowStreamWriter.cs |   8 +
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |   8 +
 .../src/Apache.Arrow/Ipc/MessageSerializer.cs |  16 +-
 .../Apache.Arrow/Types/FixedSizeListType.cs   |  44 ++++
 csharp/src/Apache.Arrow/Types/IArrowType.cs   |   3 +-
 .../IntegrationCommand.cs                     |  80 +++++++-
 .../Apache.Arrow.IntegrationTest/JsonFile.cs  |   3 +
 .../Apache.Arrow.Tests/ArrayBuilderTests.cs   | 126 ++++++++++++
 .../Apache.Arrow.Tests/ArrayTypeComparer.cs   |  11 +
 .../ArrowArrayConcatenatorTests.cs            |  38 ++++
 .../Apache.Arrow.Tests/ArrowReaderVerifier.cs |  20 +-
 .../CDataInterfacePythonTests.cs              |  16 +-
 csharp/test/Apache.Arrow.Tests/TableTests.cs  |   2 +-
 csharp/test/Apache.Arrow.Tests/TestData.cs    |  28 +++
 dev/archery/archery/integration/datagen.py    |   6 +-
 docs/source/status.rst                        |   2 +-
 30 files changed, 667 insertions(+), 31 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Arrays/FixedSizeListArray.cs
 create mode 100644 csharp/src/Apache.Arrow/Types/FixedSizeListType.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
index 2b5e59517cf19..8859ecd7f05b9 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
@@ -48,6 +48,7 @@ private class ArrayDataConcatenationVisitor :
             IArrowTypeVisitor<BinaryType>,
             IArrowTypeVisitor<StringType>,
             IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>
         {
             public ArrayData Result { get; private set; }
@@ -100,6 +101,15 @@ public void Visit(ListType type)
                 Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer }, new[] { child });
             }
 
+            public void Visit(FixedSizeListType type)
+            {
+                CheckData(type, 1);
+                ArrowBuffer validityBuffer = ConcatenateValidityBuffer();
+                ArrayData child = Concatenate(SelectChildren(0), _allocator);
+
+                Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer }, new[] { child });
+            }
+
             public void Visit(StructType type)
             {
                 CheckData(type, 1);
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
index 1e0524e53e309..8a6bfed29abb6 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
@@ -26,6 +26,7 @@ internal sealed class ArrayDataTypeComparer :
         IArrowTypeVisitor<Time64Type>,
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
+        IArrowTypeVisitor<FixedSizeListType>,
         IArrowTypeVisitor<StructType>
     {
         private readonly IArrowType _expectedType;
@@ -102,6 +103,16 @@ public void Visit(ListType actualType)
             }
         }
 
+        public void Visit(FixedSizeListType actualType)
+        {
+            if (_expectedType is FixedSizeListType expectedType
+                && actualType.ListSize == expectedType.ListSize
+                && CompareNested(expectedType, actualType))
+            {
+                _dataTypeMatch = true;
+            }
+        }
+
         public void Visit(StructType actualType)
         {
             if (_expectedType is StructType expectedType
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
index ef80edb838162..1b972d01874ca 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
@@ -68,6 +68,8 @@ internal static IArrowArrayBuilder<IArrowArray, IArrowArrayBuilder<IArrowArray>>
                     return new Time64Array.Builder(dataType as Time64Type);
                 case ArrowTypeId.List:
                     return new ListArray.Builder(dataType as ListType);
+                case ArrowTypeId.FixedSizeList:
+                    return new FixedSizeListArray.Builder(dataType as FixedSizeListType);
                 case ArrowTypeId.Decimal128:
                     return new Decimal128Array.Builder(dataType as Decimal128Type);
                 case ArrowTypeId.Decimal256:
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
index 845cbbd3e56f2..f82037bff47b1 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
@@ -83,6 +83,8 @@ public static IArrowArray BuildArray(ArrayData data)
 #else
                     throw new NotSupportedException("Half-float arrays are not supported by this target framework.");
 #endif
+                case ArrowTypeId.FixedSizeList:
+                    return new FixedSizeListArray(data);
                 case ArrowTypeId.Interval:
                 case ArrowTypeId.Map:
                 default:
diff --git a/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
index dcbb76930b6d3..29246fa250fd2 100644
--- a/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Arrays/DateArrayBuilder.cs
@@ -157,7 +157,7 @@ public TBuilder Append(ReadOnlySpan<DateOnly> span)
         /// Append a null date to the array.
         /// </summary>
         /// <returns>Returns the builder (for fluent-style composition).</returns>
-        public TBuilder AppendNull()
+        public override TBuilder AppendNull()
         {
             InnerBuilder.AppendNull();
             return this as TBuilder;
diff --git a/csharp/src/Apache.Arrow/Arrays/DelegatingArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/DelegatingArrayBuilder.cs
index f2ab3ee13cbf3..827b00c58facb 100644
--- a/csharp/src/Apache.Arrow/Arrays/DelegatingArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Arrays/DelegatingArrayBuilder.cs
@@ -98,5 +98,11 @@ public TBuilder Clear()
             InnerBuilder.Clear();
             return this as TBuilder;
         }
+
+        /// <summary>
+        /// Appends a null value
+        /// </summary>
+        /// <returns>Returns the builder (for fluent-style composition).</returns>
+        public abstract TBuilder AppendNull();
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/FixedSizeListArray.cs b/csharp/src/Apache.Arrow/Arrays/FixedSizeListArray.cs
new file mode 100644
index 0000000000000..f60daedb57091
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/FixedSizeListArray.cs
@@ -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.
+
+using System;
+using Apache.Arrow.Memory;
+using Apache.Arrow.Types;
+
+namespace Apache.Arrow
+{
+    public class FixedSizeListArray : Array
+    {
+        public class Builder : IArrowArrayBuilder<FixedSizeListArray, Builder>
+        {
+            public IArrowArrayBuilder<IArrowArray, IArrowArrayBuilder<IArrowArray>> ValueBuilder { get; }
+
+            public int Length { get; protected set; }
+
+            private ArrowBuffer.BitmapBuilder ValidityBufferBuilder { get; }
+
+            public int NullCount => ValidityBufferBuilder.UnsetBitCount;
+
+            private FixedSizeListType DataType { get; }
+
+            private int ExpectedValueLength => Length * DataType.ListSize;
+
+            public Builder(IArrowType valueDataType, int listSize) : this(new FixedSizeListType(valueDataType, listSize))
+            {
+            }
+
+            public Builder(Field valueField, int listSize) : this(new FixedSizeListType(valueField, listSize))
+            {
+            }
+
+            internal Builder(FixedSizeListType dataType)
+            {
+                ValueBuilder = ArrowArrayBuilderFactory.Build(dataType.ValueDataType);
+                ValidityBufferBuilder = new ArrowBuffer.BitmapBuilder();
+                DataType = dataType;
+            }
+
+            /// <summary>
+            /// Start a new fixed-length list slot
+            ///
+            /// This function should be called before beginning to append elements to the
+            /// value builder
+            /// </summary>
+            /// <returns></returns>
+            public Builder Append()
+            {
+                ValidateChildLength();
+
+                ValidityBufferBuilder.Append(true);
+                Length++;
+
+                return this;
+            }
+
+            public Builder AppendNull()
+            {
+                ValidateChildLength();
+
+                ValidityBufferBuilder.Append(false);
+                for (int i = 0; i < DataType.ListSize; i++)
+                {
+                    ValueBuilder.AppendNull();
+                }
+                Length++;
+
+                return this;
+            }
+
+            public FixedSizeListArray Build(MemoryAllocator allocator = default)
+            {
+                ValidateChildLength();
+
+                int nullCount = NullCount;
+                ArrowBuffer validityBuffer = nullCount > 0
+                                        ? ValidityBufferBuilder.Build(allocator)
+                                        : ArrowBuffer.Empty;
+
+                return new FixedSizeListArray(DataType, Length,
+                    ValueBuilder.Build(allocator),
+                    validityBuffer, nullCount, 0);
+            }
+
+            public Builder Reserve(int capacity)
+            {
+                ValidityBufferBuilder.Reserve(capacity);
+                ValueBuilder.Reserve(DataType.ListSize * capacity);
+                return this;
+            }
+
+            public Builder Resize(int length)
+            {
+                ValidateChildLength();
+
+                ValidityBufferBuilder.Resize(length);
+                ValueBuilder.Resize(DataType.ListSize * length);
+                Length = length;
+                return this;
+            }
+
+            public Builder Clear()
+            {
+                ValueBuilder.Clear();
+                ValidityBufferBuilder.Clear();
+                Length = 0;
+                return this;
+            }
+
+            void ValidateChildLength()
+            {
+                if (ValueBuilder.Length != ExpectedValueLength)
+                {
+                    int actualLength = ValueBuilder.Length - ExpectedValueLength + DataType.ListSize;
+                    throw new ArgumentOutOfRangeException($"Lists of length: {actualLength} do not conform to the fixed size: " + DataType.ListSize);
+                }
+            }
+        }
+
+        public IArrowArray Values { get; }
+
+        public FixedSizeListArray(IArrowType dataType, int length,
+            IArrowArray values, ArrowBuffer nullBitmapBuffer,
+            int nullCount = 0, int offset = 0)
+            : this(new ArrayData(dataType, length, nullCount, offset,
+                new[] { nullBitmapBuffer }, new[] { values.Data }),
+                values)
+        {
+        }
+
+        public FixedSizeListArray(ArrayData data)
+            : this(data, ArrowArrayFactory.BuildArray(data.Children[0]))
+        {
+        }
+
+        private FixedSizeListArray(ArrayData data, IArrowArray values) : base(data)
+        {
+            data.EnsureBufferCount(1);
+            data.EnsureDataType(ArrowTypeId.FixedSizeList);
+            Values = values;
+        }
+
+        public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor);
+
+        public IArrowArray GetSlicedValues(int index)
+        {
+            if (index < 0 || index >= Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+
+            if (IsNull(index))
+            {
+                return null;
+            }
+
+            if (!(Values is Array array))
+            {
+                return default;
+            }
+
+            index += Data.Offset;
+
+            int length = ((FixedSizeListType)Data.DataType).ListSize;
+            return array.Slice(index * length, length);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Values?.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
index da93db84717da..88f8aa8c45159 100644
--- a/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Arrays/TimeArrayBuilder.cs
@@ -88,7 +88,7 @@ public TBuilder Append(ReadOnlySpan<TUnderlying> values)
         /// Append a null time to the array.
         /// </summary>
         /// <returns>Returns the builder (for fluent-style composition).</returns>
-        public TBuilder AppendNull()
+        public override TBuilder AppendNull()
         {
             InnerBuilder.AppendNull();
             return this as TBuilder;
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
index 2f4ebed4b0cf1..9b7bcb7abe5a5 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
@@ -161,6 +161,10 @@ private ArrayData GetAsArrayData(CArrowArray* cArray, IArrowType type)
                         children = ProcessListChildren(cArray, ((ListType)type).ValueDataType);
                         buffers = ImportListBuffers(cArray);
                         break;
+                    case ArrowTypeId.FixedSizeList:
+                        children = ProcessListChildren(cArray, ((FixedSizeListType)type).ValueDataType);
+                        buffers = ImportFixedSizeListBuffers(cArray);
+                        break;
                     case ArrowTypeId.Struct:
                         children = ProcessStructChildren(cArray, ((StructType)type).Fields);
                         buffers = new ArrowBuffer[] { ImportValidityBuffer(cArray) };
@@ -236,7 +240,7 @@ private ArrowBuffer[] ImportByteArrayBuffers(CArrowArray* cArray)
             {
                 if (cArray->n_buffers != 3)
                 {
-                    throw new InvalidOperationException("Byte arrays are expected to have exactly three child arrays");
+                    throw new InvalidOperationException("Byte arrays are expected to have exactly three buffers");
                 }
 
                 int length = checked((int)cArray->length);
@@ -256,7 +260,7 @@ private ArrowBuffer[] ImportListBuffers(CArrowArray* cArray)
             {
                 if (cArray->n_buffers != 2)
                 {
-                    throw new InvalidOperationException("List arrays are expected to have exactly two children");
+                    throw new InvalidOperationException("List arrays are expected to have exactly two buffers");
                 }
 
                 int length = checked((int)cArray->length);
@@ -269,11 +273,24 @@ private ArrowBuffer[] ImportListBuffers(CArrowArray* cArray)
                 return buffers;
             }
 
+            private ArrowBuffer[] ImportFixedSizeListBuffers(CArrowArray* cArray)
+            {
+                if (cArray->n_buffers != 1)
+                {
+                    throw new InvalidOperationException("Fixed-size list arrays are expected to have exactly one buffer");
+                }
+
+                ArrowBuffer[] buffers = new ArrowBuffer[1];
+                buffers[0] = ImportValidityBuffer(cArray);
+
+                return buffers;
+            }
+
             private ArrowBuffer[] ImportFixedWidthBuffers(CArrowArray* cArray, int bitWidth)
             {
                 if (cArray->n_buffers != 2)
                 {
-                    throw new InvalidOperationException("Arrays of fixed-width type are expected to have exactly two children");
+                    throw new InvalidOperationException("Arrays of fixed-width type are expected to have exactly two buffers");
                 }
 
                 // validity, data
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
index 696212eda36c7..66142da331ac8 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
@@ -167,6 +167,8 @@ private static string GetFormat(IArrowType datatype)
                     return String.Format("ts{0}:{1}", FormatTimeUnit(timestampType.Unit), timestampType.Timezone);
                 // Nested
                 case ListType _: return "+l";
+                case FixedSizeListType fixedListType:
+                    return $"+w:{fixedListType.ListSize}";
                 case StructType _: return "+s";
                 // Dictionary
                 case DictionaryType dictionaryType:
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index ec613d59d2cb9..2a750d5e8250d 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -200,6 +200,27 @@ public ArrowType GetAsType()
 
                     return new StructType(childFields);
                 }
+                else if (format.StartsWith("+w:"))
+                {
+                    // Fixed-width list
+                    int width = Int32.Parse(format.Substring(3));
+
+                    if (_cSchema->n_children != 1)
+                    {
+                        throw new InvalidDataException("Expected fixed-length list type to have exactly one child.");
+                    }
+                    ImportedArrowSchema childSchema;
+                    if (_cSchema->GetChild(0) == null)
+                    {
+                        throw new InvalidDataException("Expected fixed-length list type child to be non-null.");
+                    }
+                    childSchema = new ImportedArrowSchema(_cSchema->GetChild(0), isRoot: false);
+
+                    Field childField = childSchema.GetAsField();
+
+                    return new FixedSizeListType(childField, width);
+                }
+
                 // TODO: Map type and large list type
 
                 // Decimals
diff --git a/csharp/src/Apache.Arrow/Field.cs b/csharp/src/Apache.Arrow/Field.cs
index 6e507b642fbae..562b9587bddb9 100644
--- a/csharp/src/Apache.Arrow/Field.cs
+++ b/csharp/src/Apache.Arrow/Field.cs
@@ -35,24 +35,24 @@ public partial class Field
 
         public Field(string name, IArrowType dataType, bool nullable,
             IEnumerable<KeyValuePair<string, string>> metadata = default)
-            : this(name, dataType, nullable)
+            : this(name, dataType, nullable, false)
         {
             Metadata = metadata?.ToDictionary(kv => kv.Key, kv => kv.Value);
 
         }
 
         internal Field(string name, IArrowType dataType, bool nullable,
-            IReadOnlyDictionary<string, string> metadata, bool copyCollections)
-            : this(name, dataType, nullable)
+            IReadOnlyDictionary<string, string> metadata, bool copyCollections, bool allowBlankName)
+            : this(name, dataType, nullable, allowBlankName)
         {
             Debug.Assert(copyCollections == false, "This internal constructor is to not copy the collections.");
 
             Metadata = metadata;
         }
 
-        private Field(string name, IArrowType dataType, bool nullable)
+        private Field(string name, IArrowType dataType, bool nullable, bool allowBlankName)
         {
-            if (string.IsNullOrWhiteSpace(name))
+            if (name == null || (!allowBlankName && string.IsNullOrWhiteSpace(name)))
             {
                 throw new ArgumentNullException(nameof(name));
             }
diff --git a/csharp/src/Apache.Arrow/Interfaces/IArrowArrayBuilder.cs b/csharp/src/Apache.Arrow/Interfaces/IArrowArrayBuilder.cs
index 12f9ec1fd3fe1..b18ff4581a528 100644
--- a/csharp/src/Apache.Arrow/Interfaces/IArrowArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Interfaces/IArrowArrayBuilder.cs
@@ -37,6 +37,7 @@ public interface IArrowArrayBuilder<out TArray, out TBuilder> : IArrowArrayBuild
         TBuilder Reserve(int capacity);
         TBuilder Resize(int length);
         TBuilder Clear();
+        TBuilder AppendNull();
     }
 
 
@@ -47,8 +48,7 @@ public interface IArrowArrayBuilder<T, out TArray, out TBuilder> : IArrowArrayBu
         TBuilder Append(T value);
         TBuilder Append(ReadOnlySpan<T> span);
         TBuilder AppendRange(IEnumerable<T> values);
-        TBuilder AppendNull();
         TBuilder Swap(int i, int j);
         TBuilder Set(int index, T value);
     }
-}
\ No newline at end of file
+}
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
index 62616962077b6..c9c1b21673316 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
@@ -257,7 +257,7 @@ private ArrayData LoadPrimitiveField(
             }
 
             ArrowBuffer[] arrowBuff;
-            if (field.DataType.TypeId == ArrowTypeId.Struct)
+            if (field.DataType.TypeId == ArrowTypeId.Struct || field.DataType.TypeId == ArrowTypeId.FixedSizeList)
             {
                 arrowBuff = new[] { nullArrowBuffer };
             }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
index ca567b67e95d1..a5d8db3f509d7 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
@@ -50,6 +50,7 @@ internal class ArrowRecordBatchFlatBufferBuilder :
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
             IArrowArrayVisitor<ListArray>,
+            IArrowArrayVisitor<FixedSizeListArray>,
             IArrowArrayVisitor<StringArray>,
             IArrowArrayVisitor<BinaryArray>,
             IArrowArrayVisitor<FixedSizeBinaryArray>,
@@ -111,6 +112,13 @@ public void Visit(ListArray array)
                 array.Values.Accept(this);
             }
 
+            public void Visit(FixedSizeListArray array)
+            {
+                _buffers.Add(CreateBuffer(array.NullBitmapBuffer));
+
+                array.Values.Accept(this);
+            }
+
             public void Visit(StringArray array) => Visit(array as BinaryArray);
 
             public void Visit(BinaryArray array)
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index befd87c2e0ae0..203aa72d93ea3 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -60,6 +60,7 @@ class TypeVisitor :
             IArrowTypeVisitor<BinaryType>,
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<UnionType>,
             IArrowTypeVisitor<StructType>,
             IArrowTypeVisitor<Decimal128Type>,
@@ -110,6 +111,13 @@ public void Visit(ListType type)
                     Flatbuf.List.EndList(Builder));
             }
 
+            public void Visit(FixedSizeListType type)
+            {
+                Result = FieldType.Build(
+                    Flatbuf.Type.FixedSizeList,
+                    Flatbuf.FixedSizeList.CreateFixedSizeList(Builder, type.ListSize));
+            }
+
             public void Visit(UnionType type)
             {
                 throw new NotImplementedException();
diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
index f5031fbfb56a4..8ca69b61165bf 100644
--- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
+++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
@@ -59,7 +59,7 @@ internal static Schema GetSchema(Flatbuf.Schema schema, ref DictionaryMemo dicti
             for (int i = 0; i < schema.FieldsLength; i++)
             {
                 Flatbuf.Field field = schema.Fields(i).GetValueOrDefault();
-                fields.Add(FieldFromFlatbuffer(field, ref dictionaryMemo));
+                fields.Add(FieldFromFlatbuffer(field, ref dictionaryMemo, allowBlankName: false));
             }
 
             Dictionary<string, string> metadata = schema.CustomMetadataLength > 0 ? new Dictionary<string, string>() : null;
@@ -73,13 +73,14 @@ internal static Schema GetSchema(Flatbuf.Schema schema, ref DictionaryMemo dicti
             return new Schema(fields, metadata, copyCollections: false);
         }
 
-        private static Field FieldFromFlatbuffer(Flatbuf.Field flatbufField, ref DictionaryMemo dictionaryMemo)
+        private static Field FieldFromFlatbuffer(Flatbuf.Field flatbufField, ref DictionaryMemo dictionaryMemo, bool allowBlankName)
         {
+            bool allowBlankNameChild = flatbufField.ChildrenLength == 1 && flatbufField.TypeType == Flatbuf.Type.FixedSizeList;
             Field[] childFields = flatbufField.ChildrenLength > 0 ? new Field[flatbufField.ChildrenLength] : null;
             for (int i = 0; i < flatbufField.ChildrenLength; i++)
             {
                 Flatbuf.Field? childFlatbufField = flatbufField.Children(i);
-                childFields[i] = FieldFromFlatbuffer(childFlatbufField.Value, ref dictionaryMemo);
+                childFields[i] = FieldFromFlatbuffer(childFlatbufField.Value, ref dictionaryMemo, allowBlankNameChild);
             }
 
             Flatbuf.DictionaryEncoding? dictionaryEncoding = flatbufField.Dictionary;
@@ -103,7 +104,7 @@ private static Field FieldFromFlatbuffer(Flatbuf.Field flatbufField, ref Diction
                 metadata[keyValue.Key] = keyValue.Value;
             }
 
-            var arrowField = new Field(flatbufField.Name, type, flatbufField.Nullable, metadata, copyCollections: false);
+            var arrowField = new Field(flatbufField.Name, type, flatbufField.Nullable, metadata, copyCollections: false, allowBlankName);
 
             if (dictionaryEncoding.HasValue)
             {
@@ -192,6 +193,13 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                         throw new InvalidDataException($"List type must have exactly one child.");
                     }
                     return new Types.ListType(childFields[0]);
+                case Flatbuf.Type.FixedSizeList:
+                    if (childFields == null || childFields.Length != 1)
+                    {
+                        throw new InvalidDataException($"Fixed-size list type must have exactly one child.");
+                    }
+                    Flatbuf.FixedSizeList fixedSizeListMetadata = field.Type<Flatbuf.FixedSizeList>().Value;
+                    return new Types.FixedSizeListType(childFields[0], fixedSizeListMetadata.ListSize);
                 case Flatbuf.Type.Struct_:
                     Debug.Assert(childFields != null);
                     return new Types.StructType(childFields);
diff --git a/csharp/src/Apache.Arrow/Types/FixedSizeListType.cs b/csharp/src/Apache.Arrow/Types/FixedSizeListType.cs
new file mode 100644
index 0000000000000..5a4c70bf3a1e1
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Types/FixedSizeListType.cs
@@ -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.
+
+using System;
+
+namespace Apache.Arrow.Types
+{
+    public sealed class FixedSizeListType : NestedType
+    {
+        public override ArrowTypeId TypeId => ArrowTypeId.FixedSizeList;
+        public override string Name => "fixed_size_list";
+        public int ListSize { get; }
+
+        public Field ValueField => Fields[0];
+
+        public IArrowType ValueDataType => Fields[0].DataType;
+
+        public FixedSizeListType(Field valueField, int listSize)
+           : base(valueField)
+        {
+            if (listSize <= 0)
+                throw new ArgumentOutOfRangeException(nameof(listSize));
+
+            ListSize = listSize;
+        }
+
+        public FixedSizeListType(IArrowType valueDataType, int listSize)
+            : this(new Field("item", valueDataType, true), listSize) { }
+
+        public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor);
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Types/IArrowType.cs b/csharp/src/Apache.Arrow/Types/IArrowType.cs
index 15c9a02445151..447db47329829 100644
--- a/csharp/src/Apache.Arrow/Types/IArrowType.cs
+++ b/csharp/src/Apache.Arrow/Types/IArrowType.cs
@@ -46,7 +46,8 @@ public enum ArrowTypeId
         Struct,
         Union,
         Dictionary,
-        Map
+        Map,
+        FixedSizeList,
     }
 
     public interface IArrowType
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
index 5b1ed98993812..abf7451e5e98c 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
@@ -149,8 +149,20 @@ private static Schema CreateSchema(JsonSchema jsonSchema)
 
         private static void CreateField(Field.Builder builder, JsonField jsonField)
         {
+            Field[] children = null;
+            if (jsonField.Children?.Count > 0)
+            {
+                children = new Field[jsonField.Children.Count];
+                for (int i = 0; i < jsonField.Children.Count; i++)
+                {
+                    Field.Builder field = new Field.Builder();
+                    CreateField(field, jsonField.Children[i]);
+                    children[i] = field.Build();
+                }
+            }
+
             builder.Name(jsonField.Name)
-                .DataType(ToArrowType(jsonField.Type))
+                .DataType(ToArrowType(jsonField.Type, children))
                 .Nullable(jsonField.Nullable);
 
             if (jsonField.Metadata != null)
@@ -159,7 +171,7 @@ private static void CreateField(Field.Builder builder, JsonField jsonField)
             }
         }
 
-        private static IArrowType ToArrowType(JsonArrowType type)
+        private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
         {
             return type.Name switch
             {
@@ -173,6 +185,9 @@ private static IArrowType ToArrowType(JsonArrowType type)
                 "date" => ToDateArrowType(type),
                 "time" => ToTimeArrowType(type),
                 "timestamp" => ToTimestampArrowType(type),
+                "list" => ToListArrowType(type, children),
+                "fixedsizelist" => ToFixedSizeListArrowType(type, children),
+                "struct" => ToStructArrowType(type, children),
                 "null" => NullType.Default,
                 _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}")
             };
@@ -251,6 +266,21 @@ private static IArrowType ToTimestampArrowType(JsonArrowType type)
             };
         }
 
+        private static IArrowType ToListArrowType(JsonArrowType type, Field[] children)
+        {
+            return new ListType(children[0]);
+        }
+
+        private static IArrowType ToFixedSizeListArrowType(JsonArrowType type, Field[] children)
+        {
+            return new FixedSizeListType(children[0], type.ListSize);
+        }
+
+        private static IArrowType ToStructArrowType(JsonArrowType type, Field[] children)
+        {
+            return new StructType(children);
+        }
+
         private class ArrayCreator :
             IArrowTypeVisitor<BooleanType>,
             IArrowTypeVisitor<Int8Type>,
@@ -274,10 +304,11 @@ private class ArrayCreator :
             IArrowTypeVisitor<BinaryType>,
             IArrowTypeVisitor<FixedSizeBinaryType>,
             IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
             IArrowTypeVisitor<NullType>
         {
-            private JsonFieldData JsonFieldData { get; }
+            private JsonFieldData JsonFieldData { get; set; }
             public IArrowArray Array { get; private set; }
 
             public ArrayCreator(JsonFieldData jsonFieldData)
@@ -478,12 +509,51 @@ public void Visit(FixedSizeBinaryType type)
 
             public void Visit(ListType type)
             {
-                throw new NotImplementedException();
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer offsetBuffer = GetOffsetBuffer();
+
+                var data = JsonFieldData;
+                JsonFieldData = data.Children[0];
+                type.ValueDataType.Accept(this);
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer, offsetBuffer }, new[] { Array.Data });
+                Array = new ListArray(arrayData);
+            }
+
+            public void Visit(FixedSizeListType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                var data = JsonFieldData;
+                JsonFieldData = data.Children[0];
+                type.ValueDataType.Accept(this);
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer }, new[] { Array.Data });
+                Array = new FixedSizeListArray(arrayData);
             }
 
             public void Visit(StructType type)
             {
-                throw new NotImplementedException();
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrayData[] children = new ArrayData[type.Fields.Count];
+
+                var data = JsonFieldData;
+                for (int i = 0; i < children.Length; i++)
+                {
+                    JsonFieldData = data.Children[i];
+                    type.Fields[i].DataType.Accept(this);
+                    children[i] = Array.Data;
+                }
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer }, children);
+                Array = new StructArray(arrayData);
             }
 
             private static byte[] ConvertHexStringToByteArray(string hexString)
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
index f074afc010103..f0f63d3e19b8c 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
@@ -68,6 +68,9 @@ public class JsonArrowType
         // FixedSizeBinary fields
         public int ByteWidth { get; set; }
 
+        // FixedSizeList fields
+        public int ListSize { get; set; }
+
         [JsonExtensionData]
         public Dictionary<string, JsonElement> ExtensionData { get; set; }
     }
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
index 2568e5e8bdab8..f789d6a3d325e 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayBuilderTests.cs
@@ -203,6 +203,132 @@ public void NestedListArrayBuilder()
                 ((Int64Array)childList3.GetSlicedValues(0)).ToList());
         }
 
+        [Fact]
+        public void FixedSizeListArrayBuilder()
+        {
+            var listBuilder = new FixedSizeListArray.Builder(StringType.Default, 4);
+            var valueBuilder = listBuilder.ValueBuilder as StringArray.Builder;
+            Assert.NotNull(valueBuilder);
+            listBuilder.Append();
+
+            Assert.Throws<ArgumentOutOfRangeException>(listBuilder.Append);
+
+            valueBuilder.Append("1");
+            valueBuilder.Append("2");
+            valueBuilder.Append("3");
+            valueBuilder.Append("4");
+            listBuilder.AppendNull();
+            listBuilder.Append();
+            valueBuilder.Append("5").Append("6").Append("7").Append("8");
+            listBuilder.Append();
+            valueBuilder.Append("444").AppendNull().Append("555").Append("666");
+
+            var list = listBuilder.Build();
+
+            Assert.Equal(
+                new List<string> { "1", "2", "3", "4" },
+                ConvertStringArrayToList(list.GetSlicedValues(0) as StringArray));
+            Assert.Null(list.GetSlicedValues(1));
+            Assert.Equal(
+                new List<string> { "5", "6", "7", "8" },
+                ConvertStringArrayToList(list.GetSlicedValues(2) as StringArray));
+            Assert.Equal(
+                new List<string> { "444", null, "555", "666" },
+                ConvertStringArrayToList(list.GetSlicedValues(3) as StringArray));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => list.GetSlicedValues(-1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => list.GetSlicedValues(4));
+
+            listBuilder.Resize(3);
+            var truncatedList = listBuilder.Build();
+
+            Assert.Equal(
+                new List<string> { "5", "6", "7", "8" },
+                ConvertStringArrayToList(truncatedList.GetSlicedValues(2) as StringArray));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => truncatedList.GetSlicedValues(-1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => truncatedList.GetSlicedValues(3));
+
+            listBuilder.Clear();
+            var emptyList = listBuilder.Build();
+
+            Assert.Equal(0, emptyList.Length);
+
+            List<string> ConvertStringArrayToList(StringArray array)
+            {
+                var length = array.Length;
+                var resultList = new List<string>(length);
+                for (var index = 0; index < length; index++)
+                {
+                    resultList.Add(array.GetString(index));
+                }
+                return resultList;
+            }
+        }
+
+        [Fact]
+        public void FixedSizeListArrayBuilderValidityBuffer()
+        {
+            FixedSizeListArray.Builder builder = new FixedSizeListArray.Builder(Int64Type.Default, 2).Append();
+            ((Int64Array.Builder)builder.ValueBuilder).Append(1).Append(2);
+            FixedSizeListArray listArray = builder.AppendNull().Build();
+            Assert.False(listArray.IsValid(2));
+        }
+
+        [Fact]
+        public void NestedFixedSizeListArrayBuilder()
+        {
+            var childListType = new FixedSizeListType(Int64Type.Default, 2);
+            var parentListBuilder = new FixedSizeListArray.Builder(childListType, 3);
+            var childListBuilder = parentListBuilder.ValueBuilder as FixedSizeListArray.Builder;
+            Assert.NotNull(childListBuilder);
+            var valueBuilder = childListBuilder.ValueBuilder as Int64Array.Builder;
+            Assert.NotNull(valueBuilder);
+
+            parentListBuilder.Append();
+            childListBuilder.Append();
+            valueBuilder.Append(1);
+            valueBuilder.Append(2);
+            childListBuilder.Append();
+            valueBuilder.Append(3).Append(4);
+            childListBuilder.AppendNull();
+            parentListBuilder.Append();
+            childListBuilder.Append();
+            valueBuilder.Append(4).Append(5);
+            childListBuilder.Append();
+            valueBuilder.Append(6).Append(7);
+            childListBuilder.Append();
+            valueBuilder.Append(8).Append(9);
+            parentListBuilder.Append();
+            childListBuilder.Append();
+            valueBuilder.Append(10).Append(11);
+            childListBuilder.AppendNull();
+            childListBuilder.Append();
+            valueBuilder.Append(12).AppendNull();
+
+            var parentList = parentListBuilder.Build();
+
+            var childList1 = (FixedSizeListArray)parentList.GetSlicedValues(0);
+            var childList2 = (FixedSizeListArray)parentList.GetSlicedValues(1);
+            var childList3 = (FixedSizeListArray)parentList.GetSlicedValues(2);
+
+            Assert.Equal(3, childList1.Length);
+            Assert.Equal(3, childList2.Length);
+            Assert.Equal(3, childList3.Length);
+            Assert.Equal(
+                new List<long?> { 1, 2 },
+                ((Int64Array)childList1.GetSlicedValues(0)).ToList());
+            Assert.Equal(
+                new List<long?> { 3, 4 },
+                ((Int64Array)childList1.GetSlicedValues(1)).ToList());
+            Assert.Equal(
+                new List<long?> { 4, 5 },
+                ((Int64Array)childList2.GetSlicedValues(0)).ToList());
+            Assert.Equal(
+                new List<long?> { 12, null },
+                ((Int64Array)childList3.GetSlicedValues(2)).ToList(includeNulls: true));
+        }
+
         public class TimestampArrayBuilder
         {
             [Fact]
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
index f75111b66d087..77584aefb1bf4 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
@@ -27,6 +27,7 @@ public class ArrayTypeComparer :
         IArrowTypeVisitor<Time64Type>,
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
+        IArrowTypeVisitor<FixedSizeListType>,
         IArrowTypeVisitor<StructType>
     {
         private readonly IArrowType _expectedType;
@@ -95,6 +96,16 @@ public void Visit(ListType actualType)
             CompareNested(expectedType, actualType);
         }
 
+        public void Visit(FixedSizeListType actualType)
+        {
+            Assert.IsAssignableFrom<FixedSizeListType>(_expectedType);
+            var expectedType = (FixedSizeListType)_expectedType;
+
+            Assert.Equal(expectedType.ListSize, actualType.ListSize);
+
+            CompareNested(expectedType, actualType);
+        }
+
         public void Visit(StructType actualType)
         {
             Assert.IsAssignableFrom<StructType>(_expectedType);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
index 6b3277ed572e0..36cffe7eb4da1 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
@@ -76,6 +76,7 @@ private static IEnumerable<Tuple<List<IArrowArray>, IArrowArray>> GenerateTestDa
                         new Field.Builder().Name("Strings").DataType(StringType.Default).Nullable(true).Build(),
                         new Field.Builder().Name("Ints").DataType(Int32Type.Default).Nullable(true).Build()
                     }),
+                    new FixedSizeListType(Int32Type.Default, 1),
                 };
 
             foreach (IArrowType type in targetTypes)
@@ -117,6 +118,7 @@ private class TestDataGenerator :
             IArrowTypeVisitor<Date64Type>,
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>
         {
 
@@ -324,6 +326,42 @@ public void Visit(ListType type)
                 ExpectedArray = resultBuilder.Build();
             }
 
+            public void Visit(FixedSizeListType type)
+            {
+                FixedSizeListArray.Builder resultBuilder = new FixedSizeListArray.Builder(type.ValueDataType, type.ListSize).Reserve(_baseDataTotalElementCount);
+                //Todo : Support various types
+                Int32Array.Builder resultValueBuilder = (Int32Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount);
+
+                for (int i = 0; i < _baseDataListCount; i++)
+                {
+                    List<int?> dataList = _baseData[i];
+
+                    FixedSizeListArray.Builder builder = new FixedSizeListArray.Builder(type.ValueField, type.ListSize).Reserve(dataList.Count);
+                    Int32Array.Builder valueBuilder = (Int32Array.Builder)builder.ValueBuilder.Reserve(dataList.Count);
+
+                    foreach (int? value in dataList)
+                    {
+                        if (value.HasValue)
+                        {
+                            builder.Append();
+                            resultBuilder.Append();
+
+                            valueBuilder.Append(value.Value);
+                            resultValueBuilder.Append(value.Value);
+                        }
+                        else
+                        {
+                            builder.AppendNull();
+                            resultBuilder.AppendNull();
+                        }
+                    }
+
+                    TestTargetArrayList.Add(builder.Build());
+                }
+
+                ExpectedArray = resultBuilder.Build();
+            }
+
             public void Visit(StructType type)
             {
                 // TODO: Make data from type fields.
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
index 543b446bba876..e588eab51e1fc 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
@@ -86,6 +86,7 @@ private class ArrayComparer :
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
             IArrowArrayVisitor<ListArray>,
+            IArrowArrayVisitor<FixedSizeListArray>,
             IArrowArrayVisitor<StringArray>,
             IArrowArrayVisitor<FixedSizeBinaryArray>,
             IArrowArrayVisitor<BinaryArray>,
@@ -126,6 +127,7 @@ public ArrayComparer(IArrowArray expectedArray, bool strictCompare)
             public void Visit(Time32Array array) => CompareArrays(array);
             public void Visit(Time64Array array) => CompareArrays(array);
             public void Visit(ListArray array) => CompareArrays(array);
+            public void Visit(FixedSizeListArray array) => CompareArrays(array);
             public void Visit(FixedSizeBinaryArray array) => CompareArrays(array);
             public void Visit(Decimal128Array array) => CompareArrays(array);
             public void Visit(Decimal256Array array) => CompareArrays(array);
@@ -304,13 +306,29 @@ private void CompareArrays(ListArray actualArray)
                 }
                 else
                 {
-                    int offsetsLength = (expectedArray.Length + 1) * 4;
+                    int offsetsLength = (expectedArray.Length + 1) * sizeof(int);
                     Assert.True(expectedArray.ValueOffsetsBuffer.Span.Slice(0, offsetsLength).SequenceEqual(actualArray.ValueOffsetsBuffer.Span.Slice(0, offsetsLength)));
                 }
 
                 actualArray.Values.Accept(new ArrayComparer(expectedArray.Values, _strictCompare));
             }
 
+            private void CompareArrays(FixedSizeListArray actualArray)
+            {
+                Assert.IsAssignableFrom<FixedSizeListArray>(_expectedArray);
+                FixedSizeListArray expectedArray = (FixedSizeListArray)_expectedArray;
+
+                actualArray.Data.DataType.Accept(_arrayTypeComparer);
+
+                Assert.Equal(expectedArray.Length, actualArray.Length);
+                Assert.Equal(expectedArray.NullCount, actualArray.NullCount);
+                Assert.Equal(expectedArray.Offset, actualArray.Offset);
+
+                CompareValidityBuffer(expectedArray.NullCount, _expectedArray.Length, expectedArray.NullBitmapBuffer, actualArray.NullBitmapBuffer);
+
+                actualArray.Values.Accept(new ArrayComparer(expectedArray.Values, _strictCompare));
+            }
+
             private void CompareValidityBuffer(int nullCount, int arrayLength, ArrowBuffer expectedValidityBuffer, ArrowBuffer actualValidityBuffer)
             {
                 if (_strictCompare)
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 4c53b98e3d9f1..29b1b9e7db74a 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -106,6 +106,8 @@ private static Schema GetTestSchema()
                     .Field(f => f.Name("list_string").DataType(new ListType(StringType.Default)).Nullable(false))
                     .Field(f => f.Name("list_list_i32").DataType(new ListType(new ListType(Int32Type.Default))).Nullable(false))
 
+                    .Field(f => f.Name("fixed_length_list_i64").DataType(new FixedSizeListType(Int64Type.Default, 10)).Nullable(true))
+
                     .Field(f => f.Name("dict_string").DataType(new DictionaryType(Int32Type.Default, StringType.Default, false)).Nullable(false))
                     .Field(f => f.Name("dict_string_ordered").DataType(new DictionaryType(Int32Type.Default, StringType.Default, true)).Nullable(false))
                     .Field(f => f.Name("list_dict_string").DataType(new ListType(new DictionaryType(Int32Type.Default, StringType.Default, false))).Nullable(false))
@@ -164,6 +166,8 @@ private static IEnumerable<dynamic> GetPythonFields()
                 yield return pa.field("list_string", pa.list_(pa.utf8()), false);
                 yield return pa.field("list_list_i32", pa.list_(pa.list_(pa.int32())), false);
 
+                yield return pa.field("fixed_length_list_i64", pa.list_(pa.int64(), 10), true);
+
                 yield return pa.field("dict_string", pa.dictionary(pa.int32(), pa.utf8(), false), false);
                 yield return pa.field("dict_string_ordered", pa.dictionary(pa.int32(), pa.utf8(), true), false);
                 yield return pa.field("list_dict_string", pa.list_(pa.dictionary(pa.int32(), pa.utf8(), false)), false);
@@ -492,8 +496,11 @@ public unsafe void ImportRecordBatch()
                             pa.array(List(1, 0, 1, 1, null)),
                             pa.array(List("foo", "bar"))
                             ),
+                        pa.FixedSizeListArray.from_arrays(
+                            pa.array(List(1, 2, 3, 4, null, 6, 7, null, null, null)),
+                            2),
                     }),
-                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7" });
+                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8" });
 
                 dynamic batch = table.to_batches()[0];
 
@@ -554,6 +561,13 @@ public unsafe void ImportRecordBatch()
             Assert.Equal(2, col7b.Length);
             Assert.Equal("foo", col7b.GetString(0));
             Assert.Equal("bar", col7b.GetString(1));
+
+            FixedSizeListArray col8 = (FixedSizeListArray)recordBatch.Column("col8");
+            Assert.Equal(5, col8.Length);
+            Int64Array col8a = (Int64Array)col8.Values;
+            Assert.Equal(new long[] { 1, 2, 3, 4, 0, 6, 7, 0, 0, 0 }, col8a.Values.ToArray());
+            Assert.True(col8a.IsValid(3));
+            Assert.False(col8a.IsValid(9));
         }
 
         [SkippableFact]
diff --git a/csharp/test/Apache.Arrow.Tests/TableTests.cs b/csharp/test/Apache.Arrow.Tests/TableTests.cs
index 45a14cc25616e..b4c4b1faed190 100644
--- a/csharp/test/Apache.Arrow.Tests/TableTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/TableTests.cs
@@ -60,7 +60,7 @@ public void TestTableFromRecordBatches()
 
             Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches);
             Assert.Equal(20, table1.RowCount);
-            Assert.Equal(23, table1.ColumnCount);
+            Assert.Equal(24, table1.ColumnCount);
 
             FixedSizeBinaryType type = new FixedSizeBinaryType(17);
             Field newField1 = new Field(type.Name, type, false);
diff --git a/csharp/test/Apache.Arrow.Tests/TestData.cs b/csharp/test/Apache.Arrow.Tests/TestData.cs
index 96c6fafee270c..41507311f6a04 100644
--- a/csharp/test/Apache.Arrow.Tests/TestData.cs
+++ b/csharp/test/Apache.Arrow.Tests/TestData.cs
@@ -59,6 +59,7 @@ public static RecordBatch CreateSampleRecordBatch(int length, int columnSetCount
                 {
                     builder.Field(CreateField(new DictionaryType(Int32Type.Default, StringType.Default, false), i));
                     builder.Field(CreateField(new FixedSizeBinaryType(16), i));
+                    builder.Field(CreateField(new FixedSizeListType(Int32Type.Default, 3), i));
                 }
 
                 //builder.Field(CreateField(HalfFloatType.Default));
@@ -122,6 +123,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<StringType>,
             IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
             IArrowTypeVisitor<Decimal128Type>,
             IArrowTypeVisitor<Decimal256Type>,
@@ -270,6 +272,32 @@ public void Visit(ListType type)
                 Array = builder.Build();
             }
 
+            public void Visit(FixedSizeListType type)
+            {
+                var builder = new FixedSizeListArray.Builder(type.ValueField, type.ListSize).Reserve(Length);
+
+                //Todo : Support various types
+                var valueBuilder = (Int32Array.Builder)builder.ValueBuilder;
+
+                for (var i = 0; i < Length; i++)
+                {
+                    if (type.Fields[0].IsNullable && (i % 3) == 0)
+                    {
+                        builder.AppendNull();
+                    }
+                    else
+                    {
+                        builder.Append();
+                        for (var j = 0; j < type.ListSize; j++)
+                        {
+                            valueBuilder.Append(i * type.ListSize + j);
+                        }
+                    }
+                }
+
+                Array = builder.Build();
+            }
+
             public void Visit(StructType type)
             {
                 IArrowArray[] childArrays = new IArrowArray[type.Fields.Count];
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 11cb02a9f4ebc..99aeda52488db 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1702,11 +1702,9 @@ def _temp_path():
         .skip_category('Java')   # TODO(ARROW-8715)
         .skip_category('JS'),     # TODO(ARROW-8716)
 
-        generate_nested_case()
-        .skip_category('C#'),
+        generate_nested_case(),
 
-        generate_recursive_nested_case()
-        .skip_category('C#'),
+        generate_recursive_nested_case(),
 
         generate_nested_large_offsets_case()
         .skip_category('C#')
diff --git a/docs/source/status.rst b/docs/source/status.rst
index fbbe1cede9610..6d7f674932a9c 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -73,7 +73,7 @@ Data Types
 | Data type         | C++   | Java  | Go    | JavaScript | C#    | Rust  | Julia | Swift |
 | (nested)          |       |       |       |            |       |       |       |       |
 +===================+=======+=======+=======+============+=======+=======+=======+=======+
-| Fixed Size List   | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Fixed Size List   | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | List              | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+

From a0ffa91bf4ae97eee9fcca843147cefbd857965c Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 21 Aug 2023 16:29:37 -0400
Subject: [PATCH 200/749] GH-37232: [MATLAB] Add `arrow.type.Time64Type` class
 and `arrow.time64` construction function  (#37287)

### Rationale for this change

To add support for `arrow.array.Time64Array`, we will need to add support for a `arrow.type.Time64Type` class and associated `arrow.time64` construction function to the MATLAB interface.

### What changes are included in this PR?

1. New `arrow.type.Time64Type` class.
2. New `arrow.time64` construction function that returns an `arrow.type.Time64Type` instance.

**Example**

```matlab
>> type = arrow.time64(TimeUnit="Nanosecond")

type =

  Time64Type with properties:

          ID: Time64
    TimeUnit: Nanosecond

>> class(type)

ans =

    'arrow.type.Time64Type'
```

### Are these changes tested?

Yes.

1. Added a new test class `tTime64Type`.
2. Added new tests for `Time64` type ID enumeration to `tID`.

### Are there any user-facing changes?

Yes.

1. `arrow.time64` construction function
3. `arrow.type.Time64Type` class

### Future Directions

1. #37229
2. #37230
3. Add `arrow.array.Time64Array` class

* Closes: #37232

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../arrow/matlab/type/proxy/time64_type.cc    |  46 ++++++
 .../cpp/arrow/matlab/type/proxy/time64_type.h |  36 +++++
 matlab/src/matlab/+arrow/+type/ID.m           |   4 +-
 matlab/src/matlab/+arrow/+type/Time64Type.m   |  30 ++++
 matlab/src/matlab/+arrow/time64.m             |  26 ++++
 matlab/test/arrow/type/tID.m                  |   3 +-
 matlab/test/arrow/type/tTime64Type.m          | 146 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 9 files changed, 292 insertions(+), 2 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/time64_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/Time64Type.m
 create mode 100644 matlab/src/matlab/+arrow/time64.m
 create mode 100644 matlab/test/arrow/type/tTime64Type.m

diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index c349962f9c2ce..ec6a544c4fac9 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -26,6 +26,7 @@
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
+#include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/field.h"
 #include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/io/feather/proxy/reader.h"
@@ -64,6 +65,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
     REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
     REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
+    REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
     REGISTER_PROXY(arrow.type.proxy.Time32Type     , arrow::matlab::type::proxy::Time32Type);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
new file mode 100644
index 0000000000000..0ec58337622a7
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/time64_type.h"
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/util/utf8.h"
+
+namespace arrow::matlab::type::proxy {
+
+    Time64Type::Time64Type(std::shared_ptr<arrow::Time64Type> time64_type) : TimeType(std::move(time64_type)) {}
+
+    libmexclass::proxy::MakeResult Time64Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+
+        using Time64TypeProxy = arrow::matlab::type::proxy::Time64Type;
+
+        mda::StructArray opts = constructor_arguments[0];
+
+        const mda::StringArray timeunit_mda = opts[0]["TimeUnit"];
+
+        // extract the time unit
+        const std::u16string& utf16_timeunit = timeunit_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto timeunit,
+                               arrow::matlab::type::timeUnitFromString(utf16_timeunit),
+                               error::UKNOWN_TIME_UNIT_ERROR_ID);
+
+        auto type = arrow::time64(timeunit);
+        auto time_type = std::static_pointer_cast<arrow::Time64Type>(type);
+        return std::make_shared<Time64TypeProxy>(std::move(time_type));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.h
new file mode 100644
index 0000000000000..fff92aa2a14e8
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/time_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+class Time64Type : public arrow::matlab::type::proxy::TimeType {
+
+    public:
+        Time64Type(std::shared_ptr<arrow::Time64Type> time64_type);
+
+        ~Time64Type() {}
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+};
+
+}
+
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index 0db41ef634368..e5b53cfa655bf 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -1,3 +1,5 @@
+%ID Data type enumeration
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -14,7 +16,6 @@
 % permissions and limitations under the License.
 
 classdef ID < uint64
-%ID Data type enumeration
     enumeration
         Boolean (1)
         UInt8   (2)
@@ -35,5 +36,6 @@
         % Date64 (17)
         Timestamp (18)
         Time32    (19)
+        Time64    (20)
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/Time64Type.m b/matlab/src/matlab/+arrow/+type/Time64Type.m
new file mode 100644
index 0000000000000..cdc4f8bf82b06
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/Time64Type.m
@@ -0,0 +1,30 @@
+%TIME64TYPE Type class for time64 data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time64Type < arrow.type.TimeType
+
+    methods
+        function obj = Time64Type(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Time64Type")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.type.TimeType(proxy);
+        end
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/time64.m b/matlab/src/matlab/+arrow/time64.m
new file mode 100644
index 0000000000000..8b4ef90a9002f
--- /dev/null
+++ b/matlab/src/matlab/+arrow/time64.m
@@ -0,0 +1,26 @@
+%TIME64 Creates an arrow.type.Time64Type object
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function type = time64(opts)
+    arguments
+        opts.TimeUnit(1, 1) arrow.type.TimeUnit {timeUnit("Time64", opts.TimeUnit)} = arrow.type.TimeUnit.Microsecond
+    end
+    import arrow.internal.validate.temporal.timeUnit
+    args = struct(TimeUnit=string(opts.TimeUnit));
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.Time64Type", args);
+    type = arrow.type.Time64Type(proxy);
+end
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index 196ad407aabd1..f0014718e3a50 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -43,7 +43,8 @@ function CastToUInt64(testCase)
                 ID.Float64,   12, ...
                 ID.String,    13, ...
                 ID.Timestamp, 18, ...
-                ID.Time32,    19  ...
+                ID.Time32,    19, ...
+                ID.Time64,    20  ...
             );
 
             enumValues = typeIDs.keys();
diff --git a/matlab/test/arrow/type/tTime64Type.m b/matlab/test/arrow/type/tTime64Type.m
new file mode 100644
index 0000000000000..1b3998c5171f5
--- /dev/null
+++ b/matlab/test/arrow/type/tTime64Type.m
@@ -0,0 +1,146 @@
+%TTIME64TYPE Test class for arrow.type.Time64Type and arrow.time64
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime64Type < hFixedWidthType
+
+    properties
+        ConstructionFcn = @arrow.time64
+        ArrowType = arrow.time64
+        TypeID = arrow.type.ID.Time64
+        BitWidth = int32(64)
+        ClassName = "arrow.type.Time64Type"
+    end
+
+    methods(Test)
+        function TestClass(testCase)
+            % Verify ArrowType is an object of the expected class type.
+            name = string(class(testCase.ArrowType));
+            testCase.verifyEqual(name, testCase.ClassName);
+        end
+
+        function DefaultTimeUnit(testCase)
+            % Verify the default TimeUnit is Microsecond.
+            type = testCase.ArrowType;
+            actualUnit = type.TimeUnit;
+            expectedUnit = arrow.type.TimeUnit.Microsecond;
+            testCase.verifyEqual(actualUnit, expectedUnit);
+        end
+
+        function SupplyTimeUnitEnum(testCase)
+            % Verify that TimeUnit can be specified as an enum value.
+            import arrow.type.*
+            expectedUnit = [TimeUnit.Microsecond, TimeUnit.Nanosecond];
+
+            for unit = expectedUnit
+                type = testCase.ConstructionFcn(TimeUnit=unit);
+                testCase.verifyEqual(type.TimeUnit, unit);
+            end
+        end
+
+        function SupplyTimeUnitString(testCase)
+            % Supply TimeUnit as a string value. Verify TimeUnit is set to
+            % the appropriate TimeUnit enum value.
+            import arrow.type.*
+            unitString = ["Microsecond", "Nanosecond"];
+            expectedUnit = [TimeUnit.Microsecond, TimeUnit.Nanosecond];
+
+            for ii = 1:numel(unitString)
+                type = testCase.ConstructionFcn(TimeUnit=unitString(ii));
+                testCase.verifyEqual(type.TimeUnit, expectedUnit(ii));
+            end
+        end
+
+        function ErrorIfAmbiguousTimeUnit(testCase)
+            % Verify that an error is thrown if an ambiguous value is
+            % provided for the TimeUnit name-value pair.
+            fcn = @() testCase.ConstructionFcn(TimeUnit="mi");
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function ErrorIfTimeUnitIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar value is
+            % provided for the TimeUnit name-value pair.
+            units = [arrow.type.TimeUnit.Microsecond; arrow.type.TimeUnit.Nanosecond];
+            fcn = @() testCase.ConstructionFcn(TimeUnit=units);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+
+            units = ["Microsecond" "Nanosecond"];
+            fcn = @() testCase.ConstructionFcn(TimeUnit=units);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+        end
+
+        function Display(testCase)
+            % Verify the display of Time64Type objects.
+            %
+            % Example:
+            %
+            %  Time64Type with properties:
+            %
+            %          ID: Time64
+            %    TimeUnit: Microsecond
+            %
+            type = testCase.ConstructionFcn(TimeUnit="Microsecond"); %#ok<NASGU>
+            classnameLink = "<a href=""matlab:helpPopup arrow.type.Time64Type"" style=""font-weight:bold"">Time64Type</a>";
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "TimeUnit:"]));
+            body = body + " " + ["Time64"; "Microsecond"];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function TimeUnitNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the TimeUnit property.
+            schema = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyError(@() setfield(schema, "TimeUnit", "Microsecond"), "MATLAB:class:SetProhibited");
+        end
+
+        function BitWidthNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the BitWidth property.
+            schema = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyError(@() setfield(schema, "BitWidth", 32), "MATLAB:class:SetProhibited");
+        end
+
+        function IDNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the ID property.
+            schema = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyError(@() setfield(schema, "ID", 15), "MATLAB:class:SetProhibited");
+        end
+
+        function NumFieldsNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the NumFields property.
+            schema = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyError(@() setfield(schema, "NumFields", 2), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidProxy(testCase)
+            % Verify that an error is thrown when a Proxy of an unexpected
+            % type is passed to the arrow.type.Time64Type constructor.
+            array = arrow.array([1, 2, 3]);
+            proxy = array.Proxy;
+            testCase.verifyError(@() arrow.type.Time64Type(proxy), "arrow:proxy:ProxyNameMismatch");
+        end
+
+    end
+
+end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 30d942b86b6ef..c421cb904e607 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -57,6 +57,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time64_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"

From 55534a4b04382e5547583c151555cbc924ec4367 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 22 Aug 2023 09:18:05 +0900
Subject: [PATCH 201/749] MINOR: [C#] Bump Google.Protobuf from 3.24.0 to
 3.24.1 in /csharp (#37283)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.24.0 to 3.24.1.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/b256412ba0c37c54247731aec9daa9592627ad5c"><code>b256412</code></a> Updating version.json and repo version numbers to: 24.1</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/d5ed61d6749522f3462a00958b0efe393fa5ba46"><code>d5ed61d</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13597">#13597</a> from zhangskz/revert-absl-bump</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/6051ad19a4dc8863c7e794a08703b6c668c35958"><code>6051ad1</code></a> Revert absl bump</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/a669cac4daaaac778ed3736f203be4763a576eab"><code>a669cac</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13595">#13595</a> from protocolbuffers/kfm-24.x-dev</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/1c846304aebfa1f917c60828d3912cff9d1fda56"><code>1c84630</code></a> update upb dep to 24.x latest</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/3094b492468caafcdb61c132dab636cc3c87773f"><code>3094b49</code></a> ruby: Fix object cache lookups on 32-bit platforms (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13494">#13494</a>) (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13580">#13580</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/7520effdeb30a4d049b819fae834f6a42cb75a80"><code>7520eff</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13534">#13534</a> from zhangskz/backport-24-x</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/63cbb637213cc2683c75953c0eefa97fa534e2e0"><code>63cbb63</code></a> Update absl submodule and dep to latest 20230802.0 LTS (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13515">#13515</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/2ea7c05576c5a79989024bb146dac2ab4cae1c48"><code>2ea7c05</code></a> Remove editions test proto from setup.py.</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/d0c2a74c8340f23721d462dc2505d6d2a36cf25c"><code>d0c2a74</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13510">#13510</a> from zhangskz/update-24-x-dep</li>
<li>Additional commits viewable in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.24.0...v3.24.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.24.0&new-version=3.24.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index e298f5268395b..6550271f32093 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.24.0" />
+    <PackageReference Include="Google.Protobuf" Version="3.24.1" />
     <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
     <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>

From 54988372c608bd6b6f6e4647b5ff6f71f60c342a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 22 Aug 2023 09:18:37 +0900
Subject: [PATCH 202/749] MINOR: [C#] Bump Microsoft.NET.Test.Sdk from 17.7.0
 to 17.7.1 in /csharp (#37284)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.7.0 to 17.7.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/releases">Microsoft.NET.Test.Sdk's releases</a>.</em></p>
<blockquote>
<h2>v17.7.1</h2>
<h2>What's Changed</h2>
<ul>
<li>Take System dlls from testhost folder to fix running .NET Framework dlls on mono and under VS on Mac in <a href="https://redirect.github.com/microsoft/vstest/issues/4610">#4610</a> by <a href="https://github.com/Evangelink"><code>@​Evangelink</code></a></li>
<li>Fix hangs in parallel execution and discovery in <a href="https://redirect.github.com/microsoft/vstest/issues/4629">#4629</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a></li>
<li>Fix executable bitness for testhost.x86 in <a href="https://redirect.github.com/microsoft/vstest/issues/4654">#4654</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.7.0...v17.7.1">https://github.com/microsoft/vstest/compare/v17.7.0...v17.7.1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/vstest/commit/76fea143ffe5e3883dcd04e0923b4b8e1e158145"><code>76fea14</code></a> Fix executable bitness for testhost.x86 (<a href="https://redirect.github.com/microsoft/vstest/issues/4652">#4652</a>) (<a href="https://redirect.github.com/microsoft/vstest/issues/4654">#4654</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/c59bb292a6a72ca9268439f50931dd5d1cc4ded2"><code>c59bb29</code></a> RTM build fix (<a href="https://redirect.github.com/microsoft/vstest/issues/4643">#4643</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/52b57f08f0c7860f087f2a02ba9fc360c52f8644"><code>52b57f0</code></a> Backport recent fixes (<a href="https://redirect.github.com/microsoft/vstest/issues/4632">#4632</a>)</li>
<li>See full diff in <a href="https://github.com/microsoft/vstest/compare/v17.7.0...v17.7.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.NET.Test.Sdk&package-manager=nuget&previous-version=17.7.0&new-version=17.7.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index d0294ac3b44a5..0ae95a7b3690d 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index ebb622c9334fe..30b97738d540e 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index a66f6fd6e305a..044f1563035d7 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>

From 9ecd0f2a5fb76cca859269a6ff13eaf315abac62 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 22 Aug 2023 09:19:08 +0900
Subject: [PATCH 203/749] MINOR: [C#] Bump K4os.Compression.LZ4.Streams from
 1.3.5 to 1.3.6 in /csharp (#37285)

Bumps [K4os.Compression.LZ4.Streams](https://github.com/MiloszKrajewski/K4os.Compression.LZ4) from 1.3.5 to 1.3.6.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/releases">K4os.Compression.LZ4.Streams's releases</a>.</em></p>
<blockquote>
<h2>1.3.6</h2>
<p>FIXED: Issue <a href="https://redirect.github.com/MiloszKrajewski/K4os.Compression.LZ4/issues/85">#85</a> (sync operation in DisposeAsync)</p>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/blob/master/CHANGES.md">K4os.Compression.LZ4.Streams's changelog</a>.</em></p>
<blockquote>
<h2>1.3.6 (2023/08/15)</h2>
<ul>
<li>FIXED <a href="https://redirect.github.com/MiloszKrajewski/K4os.Compression.LZ4/issues/85">#85</a>: removed call to Dispose from DisposeAsync in LZ4EncoderStream</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/commit/ccc115ccb9d8bf61ade02bed15cf927b29e2fc71"><code>ccc115c</code></a> Issue <a href="https://redirect.github.com/MiloszKrajewski/K4os.Compression.LZ4/issues/85">#85</a></li>
<li><a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/commit/fa8b8e038b500d565efe12769db097852a28ddf7"><code>fa8b8e0</code></a> typos</li>
<li><a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/commit/cacc3068347f379ed9112eac6435694765c5a419"><code>cacc306</code></a> simpler perf comparison</li>
<li>See full diff in <a href="https://github.com/MiloszKrajewski/K4os.Compression.LZ4/compare/1.3.5...1.3.6">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=K4os.Compression.LZ4.Streams&package-manager=nuget&previous-version=1.3.5&new-version=1.3.6)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression/Apache.Arrow.Compression.csproj    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
index 70e12835f1821..47c99436ba604 100644
--- a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
+++ b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.5" />
+    <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.6" />
     <PackageReference Include="ZstdSharp.Port" Version="0.7.2" />
   </ItemGroup>
 

From 369bb318b016e26db1c9933418a8855975eeab01 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 22 Aug 2023 09:45:16 +0200
Subject: [PATCH 204/749] GH-37273: [C++] Bump vendored xxhash version (#37275)

Bump from 0.8.1 to 0.8.2. It should fix a compilation error seen here, and may come with other improvements:
https://dev.azure.com/ursacomputing/crossbow/_build/results?buildId=53150&view=logs&j=0da5d1d9-276d-5173-c4c4-9d4d4ed14fdb

* Closes: #37273

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/vendored/xxhash/README.md |    2 +-
 cpp/src/arrow/vendored/xxhash/xxhash.c  |    2 +-
 cpp/src/arrow/vendored/xxhash/xxhash.h  | 3023 ++++++++++++++++-------
 3 files changed, 2110 insertions(+), 917 deletions(-)

diff --git a/cpp/src/arrow/vendored/xxhash/README.md b/cpp/src/arrow/vendored/xxhash/README.md
index c3c97ec08fa2f..6872c6652edfb 100644
--- a/cpp/src/arrow/vendored/xxhash/README.md
+++ b/cpp/src/arrow/vendored/xxhash/README.md
@@ -17,5 +17,5 @@
   under the License.
 -->
 
-The files in this directory are vendored from xxHash git tag v0.8.1
+The files in this directory are vendored from xxHash git tag v0.8.2
 (https://github.com/Cyan4973/xxHash).
diff --git a/cpp/src/arrow/vendored/xxhash/xxhash.c b/cpp/src/arrow/vendored/xxhash/xxhash.c
index 0fae88c5d673e..083b039d70dec 100644
--- a/cpp/src/arrow/vendored/xxhash/xxhash.c
+++ b/cpp/src/arrow/vendored/xxhash/xxhash.c
@@ -1,6 +1,6 @@
 /*
  * xxHash - Extremely Fast Hash algorithm
- * Copyright (C) 2012-2020 Yann Collet
+ * Copyright (C) 2012-2021 Yann Collet
  *
  * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
  *
diff --git a/cpp/src/arrow/vendored/xxhash/xxhash.h b/cpp/src/arrow/vendored/xxhash/xxhash.h
index 08ab79457233e..a18e8c762daaa 100644
--- a/cpp/src/arrow/vendored/xxhash/xxhash.h
+++ b/cpp/src/arrow/vendored/xxhash/xxhash.h
@@ -1,7 +1,7 @@
 /*
  * xxHash - Extremely Fast Hash algorithm
  * Header File
- * Copyright (C) 2012-2020 Yann Collet
+ * Copyright (C) 2012-2021 Yann Collet
  *
  * BSD 2-Clause License (https://www.opensource.org/licenses/bsd-license.php)
  *
@@ -32,49 +32,142 @@
  *   - xxHash homepage: https://www.xxhash.com
  *   - xxHash source repository: https://github.com/Cyan4973/xxHash
  */
+
 /*!
  * @mainpage xxHash
  *
+ * xxHash is an extremely fast non-cryptographic hash algorithm, working at RAM speed
+ * limits.
+ *
+ * It is proposed in four flavors, in three families:
+ * 1. @ref XXH32_family
+ *   - Classic 32-bit hash function. Simple, compact, and runs on almost all
+ *     32-bit and 64-bit systems.
+ * 2. @ref XXH64_family
+ *   - Classic 64-bit adaptation of XXH32. Just as simple, and runs well on most
+ *     64-bit systems (but _not_ 32-bit systems).
+ * 3. @ref XXH3_family
+ *   - Modern 64-bit and 128-bit hash function family which features improved
+ *     strength and performance across the board, especially on smaller data.
+ *     It benefits greatly from SIMD and 64-bit without requiring it.
+ *
+ * Benchmarks
+ * ---
+ * The reference system uses an Intel i7-9700K CPU, and runs Ubuntu x64 20.04.
+ * The open source benchmark program is compiled with clang v10.0 using -O3 flag.
+ *
+ * | Hash Name            | ISA ext | Width | Large Data Speed | Small Data Velocity |
+ * | -------------------- | ------- | ----: | ---------------: | ------------------: |
+ * | XXH3_64bits()        | @b AVX2 |    64 |        59.4 GB/s |               133.1 |
+ * | MeowHash             | AES-NI  |   128 |        58.2 GB/s |                52.5 |
+ * | XXH3_128bits()       | @b AVX2 |   128 |        57.9 GB/s |               118.1 |
+ * | CLHash               | PCLMUL  |    64 |        37.1 GB/s |                58.1 |
+ * | XXH3_64bits()        | @b SSE2 |    64 |        31.5 GB/s |               133.1 |
+ * | XXH3_128bits()       | @b SSE2 |   128 |        29.6 GB/s |               118.1 |
+ * | RAM sequential read  |         |   N/A |        28.0 GB/s |                 N/A |
+ * | ahash                | AES-NI  |    64 |        22.5 GB/s |               107.2 |
+ * | City64               |         |    64 |        22.0 GB/s |                76.6 |
+ * | T1ha2                |         |    64 |        22.0 GB/s |                99.0 |
+ * | City128              |         |   128 |        21.7 GB/s |                57.7 |
+ * | FarmHash             | AES-NI  |    64 |        21.3 GB/s |                71.9 |
+ * | XXH64()              |         |    64 |        19.4 GB/s |                71.0 |
+ * | SpookyHash           |         |    64 |        19.3 GB/s |                53.2 |
+ * | Mum                  |         |    64 |        18.0 GB/s |                67.0 |
+ * | CRC32C               | SSE4.2  |    32 |        13.0 GB/s |                57.9 |
+ * | XXH32()              |         |    32 |         9.7 GB/s |                71.9 |
+ * | City32               |         |    32 |         9.1 GB/s |                66.0 |
+ * | Blake3*              | @b AVX2 |   256 |         4.4 GB/s |                 8.1 |
+ * | Murmur3              |         |    32 |         3.9 GB/s |                56.1 |
+ * | SipHash*             |         |    64 |         3.0 GB/s |                43.2 |
+ * | Blake3*              | @b SSE2 |   256 |         2.4 GB/s |                 8.1 |
+ * | HighwayHash          |         |    64 |         1.4 GB/s |                 6.0 |
+ * | FNV64                |         |    64 |         1.2 GB/s |                62.7 |
+ * | Blake2*              |         |   256 |         1.1 GB/s |                 5.1 |
+ * | SHA1*                |         |   160 |         0.8 GB/s |                 5.6 |
+ * | MD5*                 |         |   128 |         0.6 GB/s |                 7.8 |
+ * @note
+ *   - Hashes which require a specific ISA extension are noted. SSE2 is also noted,
+ *     even though it is mandatory on x64.
+ *   - Hashes with an asterisk are cryptographic. Note that MD5 is non-cryptographic
+ *     by modern standards.
+ *   - Small data velocity is a rough average of algorithm's efficiency for small
+ *     data. For more accurate information, see the wiki.
+ *   - More benchmarks and strength tests are found on the wiki:
+ *         https://github.com/Cyan4973/xxHash/wiki
+ *
+ * Usage
+ * ------
+ * All xxHash variants use a similar API. Changing the algorithm is a trivial
+ * substitution.
+ *
+ * @pre
+ *    For functions which take an input and length parameter, the following
+ *    requirements are assumed:
+ *    - The range from [`input`, `input + length`) is valid, readable memory.
+ *      - The only exception is if the `length` is `0`, `input` may be `NULL`.
+ *    - For C++, the objects must have the *TriviallyCopyable* property, as the
+ *      functions access bytes directly as if it was an array of `unsigned char`.
+ *
+ * @anchor single_shot_example
+ * **Single Shot**
+ *
+ * These functions are stateless functions which hash a contiguous block of memory,
+ * immediately returning the result. They are the easiest and usually the fastest
+ * option.
+ *
+ * XXH32(), XXH64(), XXH3_64bits(), XXH3_128bits()
+ *
+ * @code{.c}
+ *   #include <string.h>
+ *   #include "xxhash.h"
+ *
+ *   // Example for a function which hashes a null terminated string with XXH32().
+ *   XXH32_hash_t hash_string(const char* string, XXH32_hash_t seed)
+ *   {
+ *       // NULL pointers are only valid if the length is zero
+ *       size_t length = (string == NULL) ? 0 : strlen(string);
+ *       return XXH32(string, length, seed);
+ *   }
+ * @endcode
+ *
+ * @anchor streaming_example
+ * **Streaming**
+ *
+ * These groups of functions allow incremental hashing of unknown size, even
+ * more than what would fit in a size_t.
+ *
+ * XXH32_reset(), XXH64_reset(), XXH3_64bits_reset(), XXH3_128bits_reset()
+ *
+ * @code{.c}
+ *   #include <stdio.h>
+ *   #include <assert.h>
+ *   #include "xxhash.h"
+ *   // Example for a function which hashes a FILE incrementally with XXH3_64bits().
+ *   XXH64_hash_t hashFile(FILE* f)
+ *   {
+ *       // Allocate a state struct. Do not just use malloc() or new.
+ *       XXH3_state_t* state = XXH3_createState();
+ *       assert(state != NULL && "Out of memory!");
+ *       // Reset the state to start a new hashing session.
+ *       XXH3_64bits_reset(state);
+ *       char buffer[4096];
+ *       size_t count;
+ *       // Read the file in chunks
+ *       while ((count = fread(buffer, 1, sizeof(buffer), f)) != 0) {
+ *           // Run update() as many times as necessary to process the data
+ *           XXH3_64bits_update(state, buffer, count);
+ *       }
+ *       // Retrieve the finalized hash. This will not change the state.
+ *       XXH64_hash_t result = XXH3_64bits_digest(state);
+ *       // Free the state. Do not use free().
+ *       XXH3_freeState(state);
+ *       return result;
+ *   }
+ * @endcode
+ *
  * @file xxhash.h
  * xxHash prototypes and implementation
  */
-/* TODO: update */
-/* Notice extracted from xxHash homepage:
-
-xxHash is an extremely fast hash algorithm, running at RAM speed limits.
-It also successfully passes all tests from the SMHasher suite.
-
-Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
-
-Name            Speed       Q.Score   Author
-xxHash          5.4 GB/s     10
-CrapWow         3.2 GB/s      2       Andrew
-MurmurHash 3a   2.7 GB/s     10       Austin Appleby
-SpookyHash      2.0 GB/s     10       Bob Jenkins
-SBox            1.4 GB/s      9       Bret Mulvey
-Lookup3         1.2 GB/s      9       Bob Jenkins
-SuperFastHash   1.2 GB/s      1       Paul Hsieh
-CityHash64      1.05 GB/s    10       Pike & Alakuijala
-FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
-MD5-32          0.33 GB/s    10       Ronald L. Rivest
-SHA1-32         0.28 GB/s    10
-
-Q.Score is a measure of quality of the hash function.
-It depends on successfully passing SMHasher test set.
-10 is a perfect score.
-
-Note: SMHasher's CRC32 implementation is not the fastest one.
-Other speed-oriented implementations can be faster,
-especially in combination with PCLMUL instruction:
-https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html?showComment=1552696407071#c3490092340461170735
-
-A 64-bit version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bit applications only.
-Name     Speed on 64 bits    Speed on 32 bits
-XXH64       13.8 GB/s            1.9 GB/s
-XXH32        6.8 GB/s            6.0 GB/s
-*/
 
 #if defined (__cplusplus)
 extern "C" {
@@ -84,21 +177,80 @@ extern "C" {
  *  INLINE mode
  ******************************/
 /*!
- * XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ * @defgroup public Public API
+ * Contains details on the public xxHash functions.
+ * @{
+ */
+#ifdef XXH_DOXYGEN
+/*!
+ * @brief Gives access to internal state declaration, required for static allocation.
+ *
+ * Incompatible with dynamic linking, due to risks of ABI changes.
+ *
+ * Usage:
+ * @code{.c}
+ *     #define XXH_STATIC_LINKING_ONLY
+ *     #include "xxhash.h"
+ * @endcode
+ */
+#  define XXH_STATIC_LINKING_ONLY
+/* Do not undef XXH_STATIC_LINKING_ONLY for Doxygen */
+
+/*!
+ * @brief Gives access to internal definitions.
+ *
+ * Usage:
+ * @code{.c}
+ *     #define XXH_STATIC_LINKING_ONLY
+ *     #define XXH_IMPLEMENTATION
+ *     #include "xxhash.h"
+ * @endcode
+ */
+#  define XXH_IMPLEMENTATION
+/* Do not undef XXH_IMPLEMENTATION for Doxygen */
+
+/*!
+ * @brief Exposes the implementation and marks all functions as `inline`.
+ *
  * Use these build macros to inline xxhash into the target unit.
  * Inlining improves performance on small inputs, especially when the length is
  * expressed as a compile-time constant:
  *
- *      https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html
+ *  https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html
  *
  * It also keeps xxHash symbols private to the unit, so they are not exported.
  *
  * Usage:
+ * @code{.c}
  *     #define XXH_INLINE_ALL
  *     #include "xxhash.h"
- *
+ * @endcode
  * Do not compile and link xxhash.o as a separate object, as it is not useful.
  */
+#  define XXH_INLINE_ALL
+#  undef XXH_INLINE_ALL
+/*!
+ * @brief Exposes the implementation without marking functions as inline.
+ */
+#  define XXH_PRIVATE_API
+#  undef XXH_PRIVATE_API
+/*!
+ * @brief Emulate a namespace by transparently prefixing all symbols.
+ *
+ * If you want to include _and expose_ xxHash functions from within your own
+ * library, but also want to avoid symbol collisions with other libraries which
+ * may also include xxHash, you can use @ref XXH_NAMESPACE to automatically prefix
+ * any public symbol from xxhash library with the value of @ref XXH_NAMESPACE
+ * (therefore, avoid empty or numeric values).
+ *
+ * Note that no change is required within the calling program as long as it
+ * includes `xxhash.h`: Regular symbol names will be automatically translated
+ * by this header.
+ */
+#  define XXH_NAMESPACE /* YOUR NAME HERE */
+#  undef XXH_NAMESPACE
+#endif
+
 #if (defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)) \
     && !defined(XXH_INLINE_ALL_31684351384)
    /* this section should be traversed only once */
@@ -213,21 +365,13 @@ extern "C" {
 #  undef XXHASH_H_STATIC_13879238742
 #endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
 
-
-
 /* ****************************************************************
  *  Stable API
  *****************************************************************/
 #ifndef XXHASH_H_5627135585666179
 #define XXHASH_H_5627135585666179 1
 
-
-/*!
- * @defgroup public Public API
- * Contains details on the public xxHash functions.
- * @{
- */
-/* specific declaration modes for Windows */
+/*! @brief Marks a global symbol. */
 #if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)
 #  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))
 #    ifdef XXH_EXPORT
@@ -240,24 +384,6 @@ extern "C" {
 #  endif
 #endif
 
-#ifdef XXH_DOXYGEN
-/*!
- * @brief Emulate a namespace by transparently prefixing all symbols.
- *
- * If you want to include _and expose_ xxHash functions from within your own
- * library, but also want to avoid symbol collisions with other libraries which
- * may also include xxHash, you can use XXH_NAMESPACE to automatically prefix
- * any public symbol from xxhash library with the value of XXH_NAMESPACE
- * (therefore, avoid empty or numeric values).
- *
- * Note that no change is required within the calling program as long as it
- * includes `xxhash.h`: Regular symbol names will be automatically translated
- * by this header.
- */
-#  define XXH_NAMESPACE /* YOUR NAME HERE */
-#  undef XXH_NAMESPACE
-#endif
-
 #ifdef XXH_NAMESPACE
 #  define XXH_CAT(A,B) A##B
 #  define XXH_NAME2(A,B) XXH_CAT(A,B)
@@ -317,12 +443,40 @@ extern "C" {
 #endif
 
 
+/* *************************************
+*  Compiler specifics
+***************************************/
+
+/* specific declaration modes for Windows */
+#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)
+#  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))
+#    ifdef XXH_EXPORT
+#      define XXH_PUBLIC_API __declspec(dllexport)
+#    elif XXH_IMPORT
+#      define XXH_PUBLIC_API __declspec(dllimport)
+#    endif
+#  else
+#    define XXH_PUBLIC_API   /* do nothing */
+#  endif
+#endif
+
+#if defined (__GNUC__)
+# define XXH_CONSTF  __attribute__((const))
+# define XXH_PUREF   __attribute__((pure))
+# define XXH_MALLOCF __attribute__((malloc))
+#else
+# define XXH_CONSTF  /* disable */
+# define XXH_PUREF
+# define XXH_MALLOCF
+#endif
+
 /* *************************************
 *  Version
 ***************************************/
 #define XXH_VERSION_MAJOR    0
 #define XXH_VERSION_MINOR    8
-#define XXH_VERSION_RELEASE  1
+#define XXH_VERSION_RELEASE  2
+/*! @brief Version number, encoded as two digits each */
 #define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
 
 /*!
@@ -331,16 +485,22 @@ extern "C" {
  * This is mostly useful when xxHash is compiled as a shared library,
  * since the returned value comes from the library, as opposed to header file.
  *
- * @return `XXH_VERSION_NUMBER` of the invoked library.
+ * @return @ref XXH_VERSION_NUMBER of the invoked library.
  */
-XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+XXH_PUBLIC_API XXH_CONSTF unsigned XXH_versionNumber (void);
 
 
 /* ****************************
 *  Common basic types
 ******************************/
 #include <stddef.h>   /* size_t */
-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+/*!
+ * @brief Exit code for the streaming API.
+ */
+typedef enum {
+    XXH_OK = 0, /*!< OK */
+    XXH_ERROR   /*!< Error */
+} XXH_errorcode;
 
 
 /*-**********************************************************************
@@ -364,29 +524,27 @@ typedef uint32_t XXH32_hash_t;
 #   include <limits.h>
 #   if UINT_MAX == 0xFFFFFFFFUL
       typedef unsigned int XXH32_hash_t;
+#   elif ULONG_MAX == 0xFFFFFFFFUL
+      typedef unsigned long XXH32_hash_t;
 #   else
-#     if ULONG_MAX == 0xFFFFFFFFUL
-        typedef unsigned long XXH32_hash_t;
-#     else
-#       error "unsupported platform: need a 32-bit type"
-#     endif
+#     error "unsupported platform: need a 32-bit type"
 #   endif
 #endif
 
 /*!
  * @}
  *
- * @defgroup xxh32_family XXH32 family
+ * @defgroup XXH32_family XXH32 family
  * @ingroup public
  * Contains functions used in the classic 32-bit xxHash algorithm.
  *
  * @note
  *   XXH32 is useful for older platforms, with no or poor 64-bit performance.
- *   Note that @ref xxh3_family provides competitive speed
- *   for both 32-bit and 64-bit systems, and offers true 64/128 bit hash results.
+ *   Note that the @ref XXH3_family provides competitive speed for both 32-bit
+ *   and 64-bit systems, and offers true 64/128 bit hash results.
  *
- * @see @ref xxh64_family, @ref xxh3_family : Other xxHash families
- * @see @ref xxh32_impl for implementation details
+ * @see @ref XXH64_family, @ref XXH3_family : Other xxHash families
+ * @see @ref XXH32_impl for implementation details
  * @{
  */
 
@@ -395,6 +553,8 @@ typedef uint32_t XXH32_hash_t;
  *
  * Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark): 5.4 GB/s
  *
+ * See @ref single_shot_example "Single Shot Example" for an example.
+ *
  * @param input The block of data to be hashed, at least @p length bytes in size.
  * @param length The length of @p input, in bytes.
  * @param seed The 32-bit seed to alter the hash's output predictably.
@@ -412,8 +572,9 @@ typedef uint32_t XXH32_hash_t;
  * @see
  *    XXH32_createState(), XXH32_update(), XXH32_digest(): Streaming version.
  */
-XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);
+XXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);
 
+#ifndef XXH_NO_STREAM
 /*!
  * Streaming functions generate the xxHash value from an incremental input.
  * This method is slower than single-call functions, due to state management.
@@ -436,32 +597,7 @@ XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_
  *
  * When done, release the state using `XXH*_freeState()`.
  *
- * Example code for incrementally hashing a file:
- * @code{.c}
- *    #include <stdio.h>
- *    #include <xxhash.h>
- *    #define BUFFER_SIZE 256
- *
- *    // Note: XXH64 and XXH3 use the same interface.
- *    XXH32_hash_t
- *    hashFile(FILE* stream)
- *    {
- *        XXH32_state_t* state;
- *        unsigned char buf[BUFFER_SIZE];
- *        size_t amt;
- *        XXH32_hash_t hash;
- *
- *        state = XXH32_createState();       // Create a state
- *        assert(state != NULL);             // Error check here
- *        XXH32_reset(state, 0xbaad5eed);    // Reset state with our seed
- *        while ((amt = fread(buf, 1, sizeof(buf), stream)) != 0) {
- *            XXH32_update(state, buf, amt); // Hash the file in chunks
- *        }
- *        hash = XXH32_digest(state);        // Finalize the hash
- *        XXH32_freeState(state);            // Clean up
- *        return hash;
- *    }
- * @endcode
+ * @see streaming_example at the top of @ref xxhash.h for an example.
  */
 
 /*!
@@ -478,7 +614,7 @@ typedef struct XXH32_state_s XXH32_state_t;
  * Must be freed with XXH32_freeState().
  * @return An allocated XXH32_state_t on success, `NULL` on failure.
  */
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_MALLOCF XXH32_state_t* XXH32_createState(void);
 /*!
  * @brief Frees an @ref XXH32_state_t.
  *
@@ -546,7 +682,8 @@ XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void*
  *
  * @return The calculated xxHash32 value from that state.
  */
-XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+XXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr);
+#endif /* !XXH_NO_STREAM */
 
 /*******   Canonical representation   *******/
 
@@ -597,43 +734,72 @@ XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t
  *
  * @return The converted hash.
  */
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+XXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
 
 
+/*! @cond Doxygen ignores this part */
 #ifdef __has_attribute
 # define XXH_HAS_ATTRIBUTE(x) __has_attribute(x)
 #else
 # define XXH_HAS_ATTRIBUTE(x) 0
 #endif
+/*! @endcond */
+
+/*! @cond Doxygen ignores this part */
+/*
+ * C23 __STDC_VERSION__ number hasn't been specified yet. For now
+ * leave as `201711L` (C17 + 1).
+ * TODO: Update to correct value when its been specified.
+ */
+#define XXH_C23_VN 201711L
+/*! @endcond */
 
+/*! @cond Doxygen ignores this part */
 /* C-language Attributes are added in C23. */
-#if defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201710L) && defined(__has_c_attribute)
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= XXH_C23_VN) && defined(__has_c_attribute)
 # define XXH_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)
 #else
 # define XXH_HAS_C_ATTRIBUTE(x) 0
 #endif
+/*! @endcond */
 
+/*! @cond Doxygen ignores this part */
 #if defined(__cplusplus) && defined(__has_cpp_attribute)
 # define XXH_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
 #else
 # define XXH_HAS_CPP_ATTRIBUTE(x) 0
 #endif
+/*! @endcond */
 
+/*! @cond Doxygen ignores this part */
 /*
-Define XXH_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute
-introduced in CPP17 and C23.
-CPP17 : https://en.cppreference.com/w/cpp/language/attributes/fallthrough
-C23   : https://en.cppreference.com/w/c/language/attributes/fallthrough
-*/
-#if XXH_HAS_C_ATTRIBUTE(x)
-# define XXH_FALLTHROUGH [[fallthrough]]
-#elif XXH_HAS_CPP_ATTRIBUTE(x)
+ * Define XXH_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute
+ * introduced in CPP17 and C23.
+ * CPP17 : https://en.cppreference.com/w/cpp/language/attributes/fallthrough
+ * C23   : https://en.cppreference.com/w/c/language/attributes/fallthrough
+ */
+#if XXH_HAS_C_ATTRIBUTE(fallthrough) || XXH_HAS_CPP_ATTRIBUTE(fallthrough)
 # define XXH_FALLTHROUGH [[fallthrough]]
 #elif XXH_HAS_ATTRIBUTE(__fallthrough__)
-# define XXH_FALLTHROUGH __attribute__ ((fallthrough))
+# define XXH_FALLTHROUGH __attribute__ ((__fallthrough__))
+#else
+# define XXH_FALLTHROUGH /* fallthrough */
+#endif
+/*! @endcond */
+
+/*! @cond Doxygen ignores this part */
+/*
+ * Define XXH_NOESCAPE for annotated pointers in public API.
+ * https://clang.llvm.org/docs/AttributeReference.html#noescape
+ * As of writing this, only supported by clang.
+ */
+#if XXH_HAS_ATTRIBUTE(noescape)
+# define XXH_NOESCAPE __attribute__((noescape))
 #else
-# define XXH_FALLTHROUGH
+# define XXH_NOESCAPE
 #endif
+/*! @endcond */
+
 
 /*!
  * @}
@@ -671,7 +837,7 @@ typedef uint64_t XXH64_hash_t;
 /*!
  * @}
  *
- * @defgroup xxh64_family XXH64 family
+ * @defgroup XXH64_family XXH64 family
  * @ingroup public
  * @{
  * Contains functions used in the classic 64-bit xxHash algorithm.
@@ -682,7 +848,6 @@ typedef uint64_t XXH64_hash_t;
  *   It provides better speed for systems with vector processing capabilities.
  */
 
-
 /*!
  * @brief Calculates the 64-bit hash of @p input using xxHash64.
  *
@@ -706,32 +871,131 @@ typedef uint64_t XXH64_hash_t;
  * @see
  *    XXH64_createState(), XXH64_update(), XXH64_digest(): Streaming version.
  */
-XXH_PUBLIC_API XXH64_hash_t XXH64(const void* input, size_t length, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);
 
 /*******   Streaming   *******/
+#ifndef XXH_NO_STREAM
 /*!
  * @brief The opaque state struct for the XXH64 streaming API.
  *
  * @see XXH64_state_s for details.
  */
 typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+
+/*!
+ * @brief Allocates an @ref XXH64_state_t.
+ *
+ * Must be freed with XXH64_freeState().
+ * @return An allocated XXH64_state_t on success, `NULL` on failure.
+ */
+XXH_PUBLIC_API XXH_MALLOCF XXH64_state_t* XXH64_createState(void);
+
+/*!
+ * @brief Frees an @ref XXH64_state_t.
+ *
+ * Must be allocated with XXH64_createState().
+ * @param statePtr A pointer to an @ref XXH64_state_t allocated with @ref XXH64_createState().
+ * @return XXH_OK.
+ */
 XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
 
-XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, XXH64_hash_t seed);
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+/*!
+ * @brief Copies one @ref XXH64_state_t to another.
+ *
+ * @param dst_state The state to copy to.
+ * @param src_state The state to copy from.
+ * @pre
+ *   @p dst_state and @p src_state must not be `NULL` and must not overlap.
+ */
+XXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+/*!
+ * @brief Resets an @ref XXH64_state_t to begin a new hash.
+ *
+ * This function resets and seeds a state. Call it before @ref XXH64_update().
+ *
+ * @param statePtr The state struct to reset.
+ * @param seed The 64-bit seed to alter the hash result predictably.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed);
+
+/*!
+ * @brief Consumes a block of @p input to an @ref XXH64_state_t.
+ *
+ * Call this to incrementally consume blocks of data.
+ *
+ * @param statePtr The state struct to update.
+ * @param input The block of data to be hashed, at least @p length bytes in size.
+ * @param length The length of @p input, in bytes.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ * @pre
+ *   The memory between @p input and @p input + @p length must be valid,
+ *   readable, contiguous memory. However, if @p length is `0`, @p input may be
+ *   `NULL`. In C++, this also must be *TriviallyCopyable*.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH_NOESCAPE XXH64_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);
 
+/*!
+ * @brief Returns the calculated hash value from an @ref XXH64_state_t.
+ *
+ * @note
+ *   Calling XXH64_digest() will not affect @p statePtr, so you can update,
+ *   digest, and update again.
+ *
+ * @param statePtr The state struct to calculate the hash from.
+ *
+ * @pre
+ *  @p statePtr must not be `NULL`.
+ *
+ * @return The calculated xxHash64 value from that state.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_digest (XXH_NOESCAPE const XXH64_state_t* statePtr);
+#endif /* !XXH_NO_STREAM */
 /*******   Canonical representation   *******/
+
+/*!
+ * @brief Canonical (big endian) representation of @ref XXH64_hash_t.
+ */
 typedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_canonical_t;
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+
+/*!
+ * @brief Converts an @ref XXH64_hash_t to a big endian @ref XXH64_canonical_t.
+ *
+ * @param dst The @ref XXH64_canonical_t pointer to be stored to.
+ * @param hash The @ref XXH64_hash_t to be converted.
+ *
+ * @pre
+ *   @p dst must not be `NULL`.
+ */
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash);
+
+/*!
+ * @brief Converts an @ref XXH64_canonical_t to a native @ref XXH64_hash_t.
+ *
+ * @param src The @ref XXH64_canonical_t to convert.
+ *
+ * @pre
+ *   @p src must not be `NULL`.
+ *
+ * @return The converted hash.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src);
+
+#ifndef XXH_NO_XXH3
 
 /*!
  * @}
  * ************************************************************************
- * @defgroup xxh3_family XXH3 family
+ * @defgroup XXH3_family XXH3 family
  * @ingroup public
  * @{
  *
@@ -751,16 +1015,26 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
  *
  * XXH3's speed benefits greatly from SIMD and 64-bit arithmetic,
  * but does not require it.
- * Any 32-bit and 64-bit targets that can run XXH32 smoothly
- * can run XXH3 at competitive speeds, even without vector support.
- * Further details are explained in the implementation.
- *
- * Optimized implementations are provided for AVX512, AVX2, SSE2, NEON, POWER8,
- * ZVector and scalar targets. This can be controlled via the XXH_VECTOR macro.
+ * Most 32-bit and 64-bit targets that can run XXH32 smoothly can run XXH3
+ * at competitive speeds, even without vector support. Further details are
+ * explained in the implementation.
+ *
+ * XXH3 has a fast scalar implementation, but it also includes accelerated SIMD
+ * implementations for many common platforms:
+ *   - AVX512
+ *   - AVX2
+ *   - SSE2
+ *   - ARM NEON
+ *   - WebAssembly SIMD128
+ *   - POWER8 VSX
+ *   - s390x ZVector
+ * This can be controlled via the @ref XXH_VECTOR macro, but it automatically
+ * selects the best version according to predefined macros. For the x86 family, an
+ * automatic runtime dispatcher is included separately in @ref xxh_x86dispatch.c.
  *
  * XXH3 implementation is portable:
  * it has a generic C90 formulation that can be compiled on any platform,
- * all implementations generage exactly the same hash value on all platforms.
+ * all implementations generate exactly the same hash value on all platforms.
  * Starting from v0.8.0, it's also labelled "stable", meaning that
  * any future version will also generate the same hash value.
  *
@@ -772,24 +1046,42 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
  *
  * The API supports one-shot hashing, streaming mode, and custom secrets.
  */
-
 /*-**********************************************************************
 *  XXH3 64-bit variant
 ************************************************************************/
 
-/* XXH3_64bits():
- * default 64-bit variant, using default secret and default seed of 0.
- * It's the fastest variant. */
-XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* data, size_t len);
+/*!
+ * @brief 64-bit unseeded variant of XXH3.
+ *
+ * This is equivalent to @ref XXH3_64bits_withSeed() with a seed of 0, however
+ * it may have slightly better performance due to constant propagation of the
+ * defaults.
+ *
+ * @see
+ *    XXH32(), XXH64(), XXH3_128bits(): equivalent for the other xxHash algorithms
+ * @see
+ *    XXH3_64bits_withSeed(), XXH3_64bits_withSecret(): other seeding variants
+ * @see
+ *    XXH3_64bits_reset(), XXH3_64bits_update(), XXH3_64bits_digest(): Streaming version.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length);
 
-/*
- * XXH3_64bits_withSeed():
- * This variant generates a custom secret on the fly
- * based on default secret altered using the `seed` value.
+/*!
+ * @brief 64-bit seeded variant of XXH3
+ *
+ * This variant generates a custom secret on the fly based on default secret
+ * altered using the `seed` value.
+ *
  * While this operation is decently fast, note that it's not completely free.
- * Note: seed==0 produces the same results as XXH3_64bits().
+ *
+ * @note
+ *    seed == 0 produces the same results as @ref XXH3_64bits().
+ *
+ * @param input The data to hash
+ * @param length The length
+ * @param seed The 64-bit seed to alter the state.
  */
-XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);
 
 /*!
  * The bare minimum size for a custom secret.
@@ -800,8 +1092,9 @@ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, X
  */
 #define XXH3_SECRET_SIZE_MIN 136
 
-/*
- * XXH3_64bits_withSecret():
+/*!
+ * @brief 64-bit variant of XXH3 with a custom "secret".
+ *
  * It's possible to provide any blob of bytes as a "secret" to generate the hash.
  * This makes it more difficult for an external actor to prepare an intentional collision.
  * The main condition is that secretSize *must* be large enough (>= XXH3_SECRET_SIZE_MIN).
@@ -817,10 +1110,11 @@ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSeed(const void* data, size_t len, X
  * This is not necessarily the case when using the blob of bytes directly
  * because, when hashing _small_ inputs, only a portion of the secret is employed.
  */
-XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);
 
 
 /*******   Streaming   *******/
+#ifndef XXH_NO_STREAM
 /*
  * Streaming requires state maintenance.
  * This operation costs memory and CPU.
@@ -834,23 +1128,53 @@ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_withSecret(const void* data, size_t len,
  * @see XXH3_state_s for details.
  */
 typedef struct XXH3_state_s XXH3_state_t;
-XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void);
+XXH_PUBLIC_API XXH_MALLOCF XXH3_state_t* XXH3_createState(void);
 XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr);
-XXH_PUBLIC_API void XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state);
 
-/*
- * XXH3_64bits_reset():
- * Initialize with default parameters.
- * digest will be equivalent to `XXH3_64bits()`.
+/*!
+ * @brief Copies one @ref XXH3_state_t to another.
+ *
+ * @param dst_state The state to copy to.
+ * @param src_state The state to copy from.
+ * @pre
+ *   @p dst_state and @p src_state must not be `NULL` and must not overlap.
  */
-XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH3_state_t* statePtr);
-/*
- * XXH3_64bits_reset_withSeed():
- * Generate a custom secret from `seed`, and store it into `statePtr`.
- * digest will be equivalent to `XXH3_64bits_withSeed()`.
+XXH_PUBLIC_API void XXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state);
+
+/*!
+ * @brief Resets an @ref XXH3_state_t to begin a new hash.
+ *
+ * This function resets `statePtr` and generate a secret with default parameters. Call it before @ref XXH3_64bits_update().
+ * Digest will be equivalent to `XXH3_64bits()`.
+ *
+ * @param statePtr The state struct to reset.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ *
  */
-XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed);
-/*
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);
+
+/*!
+ * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.
+ *
+ * This function resets `statePtr` and generate a secret from `seed`. Call it before @ref XXH3_64bits_update().
+ * Digest will be equivalent to `XXH3_64bits_withSeed()`.
+ *
+ * @param statePtr The state struct to reset.
+ * @param seed     The 64-bit seed to alter the state.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ *
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);
+
+/*!
  * XXH3_64bits_reset_withSecret():
  * `secret` is referenced, it _must outlive_ the hash streaming session.
  * Similar to one-shot API, `secretSize` must be >= `XXH3_SECRET_SIZE_MIN`,
@@ -859,53 +1183,172 @@ XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr,
  * When in doubt about the randomness of a candidate `secret`,
  * consider employing `XXH3_generateSecret()` instead (see below).
  */
-XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize);
-
-XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH3_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH3_64bits_digest (const XXH3_state_t* statePtr);
-
-/* note : canonical representation of XXH3 is the same as XXH64
- * since they both produce XXH64_hash_t values */
-
-
-/*-**********************************************************************
-*  XXH3 128-bit variant
-************************************************************************/
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);
+
+/*!
+ * @brief Consumes a block of @p input to an @ref XXH3_state_t.
+ *
+ * Call this to incrementally consume blocks of data.
+ *
+ * @param statePtr The state struct to update.
+ * @param input The block of data to be hashed, at least @p length bytes in size.
+ * @param length The length of @p input, in bytes.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ * @pre
+ *   The memory between @p input and @p input + @p length must be valid,
+ *   readable, contiguous memory. However, if @p length is `0`, @p input may be
+ *   `NULL`. In C++, this also must be *TriviallyCopyable*.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);
+
+/*!
+ * @brief Returns the calculated XXH3 64-bit hash value from an @ref XXH3_state_t.
+ *
+ * @note
+ *   Calling XXH3_64bits_digest() will not affect @p statePtr, so you can update,
+ *   digest, and update again.
+ *
+ * @param statePtr The state struct to calculate the hash from.
+ *
+ * @pre
+ *  @p statePtr must not be `NULL`.
+ *
+ * @return The calculated XXH3 64-bit hash value from that state.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t  XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);
+#endif /* !XXH_NO_STREAM */
+
+/* note : canonical representation of XXH3 is the same as XXH64
+ * since they both produce XXH64_hash_t values */
+
+
+/*-**********************************************************************
+*  XXH3 128-bit variant
+************************************************************************/
+
+/*!
+ * @brief The return value from 128-bit hashes.
+ *
+ * Stored in little endian order, although the fields themselves are in native
+ * endianness.
+ */
+typedef struct {
+    XXH64_hash_t low64;   /*!< `value & 0xFFFFFFFFFFFFFFFF` */
+    XXH64_hash_t high64;  /*!< `value >> 64` */
+} XXH128_hash_t;
+
+/*!
+ * @brief Unseeded 128-bit variant of XXH3
+ *
+ * The 128-bit variant of XXH3 has more strength, but it has a bit of overhead
+ * for shorter inputs.
+ *
+ * This is equivalent to @ref XXH3_128bits_withSeed() with a seed of 0, however
+ * it may have slightly better performance due to constant propagation of the
+ * defaults.
+ *
+ * @see
+ *    XXH32(), XXH64(), XXH3_64bits(): equivalent for the other xxHash algorithms
+ * @see
+ *    XXH3_128bits_withSeed(), XXH3_128bits_withSecret(): other seeding variants
+ * @see
+ *    XXH3_128bits_reset(), XXH3_128bits_update(), XXH3_128bits_digest(): Streaming version.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* data, size_t len);
+/*! @brief Seeded 128-bit variant of XXH3. @see XXH3_64bits_withSeed(). */
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSeed(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);
+/*! @brief Custom secret 128-bit variant of XXH3. @see XXH3_64bits_withSecret(). */
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);
+
+/*******   Streaming   *******/
+#ifndef XXH_NO_STREAM
+/*
+ * Streaming requires state maintenance.
+ * This operation costs memory and CPU.
+ * As a consequence, streaming is slower than one-shot hashing.
+ * For better performance, prefer one-shot functions whenever applicable.
+ *
+ * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits().
+ * Use already declared XXH3_createState() and XXH3_freeState().
+ *
+ * All reset and streaming functions have same meaning as their 64-bit counterpart.
+ */
+
+/*!
+ * @brief Resets an @ref XXH3_state_t to begin a new hash.
+ *
+ * This function resets `statePtr` and generate a secret with default parameters. Call it before @ref XXH3_128bits_update().
+ * Digest will be equivalent to `XXH3_128bits()`.
+ *
+ * @param statePtr The state struct to reset.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ *
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);
+
+/*!
+ * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.
+ *
+ * This function resets `statePtr` and generate a secret from `seed`. Call it before @ref XXH3_128bits_update().
+ * Digest will be equivalent to `XXH3_128bits_withSeed()`.
+ *
+ * @param statePtr The state struct to reset.
+ * @param seed     The 64-bit seed to alter the state.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ *
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);
+/*! @brief Custom secret 128-bit variant of XXH3. @see XXH_64bits_reset_withSecret(). */
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);
+
+/*!
+ * @brief Consumes a block of @p input to an @ref XXH3_state_t.
+ *
+ * Call this to incrementally consume blocks of data.
+ *
+ * @param statePtr The state struct to update.
+ * @param input The block of data to be hashed, at least @p length bytes in size.
+ * @param length The length of @p input, in bytes.
+ *
+ * @pre
+ *   @p statePtr must not be `NULL`.
+ * @pre
+ *   The memory between @p input and @p input + @p length must be valid,
+ *   readable, contiguous memory. However, if @p length is `0`, @p input may be
+ *   `NULL`. In C++, this also must be *TriviallyCopyable*.
+ *
+ * @return @ref XXH_OK on success, @ref XXH_ERROR on failure.
+ */
+XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);
 
 /*!
- * @brief The return value from 128-bit hashes.
+ * @brief Returns the calculated XXH3 128-bit hash value from an @ref XXH3_state_t.
  *
- * Stored in little endian order, although the fields themselves are in native
- * endianness.
- */
-typedef struct {
-    XXH64_hash_t low64;   /*!< `value & 0xFFFFFFFFFFFFFFFF` */
-    XXH64_hash_t high64;  /*!< `value >> 64` */
-} XXH128_hash_t;
-
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* data, size_t len);
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSeed(const void* data, size_t len, XXH64_hash_t seed);
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_withSecret(const void* data, size_t len, const void* secret, size_t secretSize);
-
-/*******   Streaming   *******/
-/*
- * Streaming requires state maintenance.
- * This operation costs memory and CPU.
- * As a consequence, streaming is slower than one-shot hashing.
- * For better performance, prefer one-shot functions whenever applicable.
+ * @note
+ *   Calling XXH3_128bits_digest() will not affect @p statePtr, so you can update,
+ *   digest, and update again.
  *
- * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits().
- * Use already declared XXH3_createState() and XXH3_freeState().
+ * @param statePtr The state struct to calculate the hash from.
  *
- * All reset and streaming functions have same meaning as their 64-bit counterpart.
+ * @pre
+ *  @p statePtr must not be `NULL`.
+ *
+ * @return The calculated XXH3 128-bit hash value from that state.
  */
-
-XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH3_state_t* statePtr);
-XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed);
-XXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize);
-
-XXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH3_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* statePtr);
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);
+#endif /* !XXH_NO_STREAM */
 
 /* Following helper functions make it possible to compare XXH128_hast_t values.
  * Since XXH128_hash_t is a structure, this capability is not offered by the language.
@@ -915,26 +1358,48 @@ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* statePtr);
  * XXH128_isEqual():
  * Return: 1 if `h1` and `h2` are equal, 0 if they are not.
  */
-XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);
+XXH_PUBLIC_API XXH_PUREF int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);
 
 /*!
- * XXH128_cmp():
- *
+ * @brief Compares two @ref XXH128_hash_t
  * This comparator is compatible with stdlib's `qsort()`/`bsearch()`.
  *
- * return: >0 if *h128_1  > *h128_2
- *         =0 if *h128_1 == *h128_2
- *         <0 if *h128_1  < *h128_2
+ * @return: >0 if *h128_1  > *h128_2
+ *          =0 if *h128_1 == *h128_2
+ *          <0 if *h128_1  < *h128_2
  */
-XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2);
+XXH_PUBLIC_API XXH_PUREF int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2);
 
 
 /*******   Canonical representation   *******/
 typedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_canonical_t;
-XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash);
-XXH_PUBLIC_API XXH128_hash_t XXH128_hashFromCanonical(const XXH128_canonical_t* src);
 
 
+/*!
+ * @brief Converts an @ref XXH128_hash_t to a big endian @ref XXH128_canonical_t.
+ *
+ * @param dst The @ref XXH128_canonical_t pointer to be stored to.
+ * @param hash The @ref XXH128_hash_t to be converted.
+ *
+ * @pre
+ *   @p dst must not be `NULL`.
+ */
+XXH_PUBLIC_API void XXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash);
+
+/*!
+ * @brief Converts an @ref XXH128_canonical_t to a native @ref XXH128_hash_t.
+ *
+ * @param src The @ref XXH128_canonical_t to convert.
+ *
+ * @pre
+ *   @p src must not be `NULL`.
+ *
+ * @return The converted hash.
+ */
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src);
+
+
+#endif  /* !XXH_NO_XXH3 */
 #endif  /* XXH_NO_LONG_LONG */
 
 /*!
@@ -978,7 +1443,7 @@ struct XXH32_state_s {
    XXH32_hash_t v[4];         /*!< Accumulator lanes */
    XXH32_hash_t mem32[4];     /*!< Internal buffer for partial reads. Treated as unsigned char[16]. */
    XXH32_hash_t memsize;      /*!< Amount of data in @ref mem32 */
-   XXH32_hash_t reserved;     /*!< Reserved field. Do not read or write to it, it may be removed. */
+   XXH32_hash_t reserved;     /*!< Reserved field. Do not read nor write to it. */
 };   /* typedef'd to XXH32_state_t */
 
 
@@ -1002,9 +1467,11 @@ struct XXH64_state_s {
    XXH64_hash_t mem64[4];     /*!< Internal buffer for partial reads. Treated as unsigned char[32]. */
    XXH32_hash_t memsize;      /*!< Amount of data in @ref mem64 */
    XXH32_hash_t reserved32;   /*!< Reserved field, needed for padding anyways*/
-   XXH64_hash_t reserved64;   /*!< Reserved field. Do not read or write to it, it may be removed. */
+   XXH64_hash_t reserved64;   /*!< Reserved field. Do not read or write to it. */
 };   /* typedef'd to XXH64_state_t */
 
+#ifndef XXH_NO_XXH3
+
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* >= C11 */
 #  include <stdalign.h>
 #  define XXH_ALIGN(n)      alignas(n)
@@ -1038,6 +1505,7 @@ struct XXH64_state_s {
 #define XXH3_INTERNALBUFFER_SIZE 256
 
 /*!
+ * @internal
  * @brief Default size of the secret buffer (and @ref XXH3_kSecret).
  *
  * This is the size used in @ref XXH3_kSecret and the seeded functions.
@@ -1070,7 +1538,7 @@ struct XXH64_state_s {
  */
 struct XXH3_state_s {
    XXH_ALIGN_MEMBER(64, XXH64_hash_t acc[8]);
-       /*!< The 8 accumulators. Similar to `vN` in @ref XXH32_state_s::v1 and @ref XXH64_state_s */
+       /*!< The 8 accumulators. See @ref XXH32_state_s::v and @ref XXH64_state_s::v */
    XXH_ALIGN_MEMBER(64, unsigned char customSecret[XXH3_SECRET_DEFAULT_SIZE]);
        /*!< Used to store a custom secret generated from a seed. */
    XXH_ALIGN_MEMBER(64, unsigned char buffer[XXH3_INTERNALBUFFER_SIZE]);
@@ -1110,69 +1578,119 @@ struct XXH3_state_s {
  * Note that this doesn't prepare the state for a streaming operation,
  * it's still necessary to use XXH3_NNbits_reset*() afterwards.
  */
-#define XXH3_INITSTATE(XXH3_state_ptr)   { (XXH3_state_ptr)->seed = 0; }
+#define XXH3_INITSTATE(XXH3_state_ptr)                       \
+    do {                                                     \
+        XXH3_state_t* tmp_xxh3_state_ptr = (XXH3_state_ptr); \
+        tmp_xxh3_state_ptr->seed = 0;                        \
+        tmp_xxh3_state_ptr->extSecret = NULL;                \
+    } while(0)
 
 
-/* XXH128() :
+/*!
  * simple alias to pre-selected XXH3_128bits variant
  */
-XXH_PUBLIC_API XXH128_hash_t XXH128(const void* data, size_t len, XXH64_hash_t seed);
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);
 
 
 /* ===   Experimental API   === */
 /* Symbols defined below must be considered tied to a specific library version. */
 
-/*
+/*!
  * XXH3_generateSecret():
  *
  * Derive a high-entropy secret from any user-defined content, named customSeed.
  * The generated secret can be used in combination with `*_withSecret()` functions.
- * The `_withSecret()` variants are useful to provide a higher level of protection than 64-bit seed,
- * as it becomes much more difficult for an external actor to guess how to impact the calculation logic.
+ * The `_withSecret()` variants are useful to provide a higher level of protection
+ * than 64-bit seed, as it becomes much more difficult for an external actor to
+ * guess how to impact the calculation logic.
  *
  * The function accepts as input a custom seed of any length and any content,
- * and derives from it a high-entropy secret of length @secretSize
- * into an already allocated buffer @secretBuffer.
- * @secretSize must be >= XXH3_SECRET_SIZE_MIN
+ * and derives from it a high-entropy secret of length @p secretSize into an
+ * already allocated buffer @p secretBuffer.
  *
  * The generated secret can then be used with any `*_withSecret()` variant.
- * Functions `XXH3_128bits_withSecret()`, `XXH3_64bits_withSecret()`,
- * `XXH3_128bits_reset_withSecret()` and `XXH3_64bits_reset_withSecret()`
+ * The functions @ref XXH3_128bits_withSecret(), @ref XXH3_64bits_withSecret(),
+ * @ref XXH3_128bits_reset_withSecret() and @ref XXH3_64bits_reset_withSecret()
  * are part of this list. They all accept a `secret` parameter
- * which must be large enough for implementation reasons (>= XXH3_SECRET_SIZE_MIN)
+ * which must be large enough for implementation reasons (>= @ref XXH3_SECRET_SIZE_MIN)
  * _and_ feature very high entropy (consist of random-looking bytes).
- * These conditions can be a high bar to meet, so
- * XXH3_generateSecret() can be employed to ensure proper quality.
+ * These conditions can be a high bar to meet, so @ref XXH3_generateSecret() can
+ * be employed to ensure proper quality.
  *
- * customSeed can be anything. It can have any size, even small ones,
- * and its content can be anything, even "poor entropy" sources such as a bunch of zeroes.
- * The resulting `secret` will nonetheless provide all required qualities.
+ * @p customSeed can be anything. It can have any size, even small ones,
+ * and its content can be anything, even "poor entropy" sources such as a bunch
+ * of zeroes. The resulting `secret` will nonetheless provide all required qualities.
  *
- * When customSeedSize > 0, supplying NULL as customSeed is undefined behavior.
+ * @pre
+ *   - @p secretSize must be >= @ref XXH3_SECRET_SIZE_MIN
+ *   - When @p customSeedSize > 0, supplying NULL as customSeed is undefined behavior.
+ *
+ * Example code:
+ * @code{.c}
+ *    #include <stdio.h>
+ *    #include <stdlib.h>
+ *    #include <string.h>
+ *    #define XXH_STATIC_LINKING_ONLY // expose unstable API
+ *    #include "xxhash.h"
+ *    // Hashes argv[2] using the entropy from argv[1].
+ *    int main(int argc, char* argv[])
+ *    {
+ *        char secret[XXH3_SECRET_SIZE_MIN];
+ *        if (argv != 3) { return 1; }
+ *        XXH3_generateSecret(secret, sizeof(secret), argv[1], strlen(argv[1]));
+ *        XXH64_hash_t h = XXH3_64bits_withSecret(
+ *             argv[2], strlen(argv[2]),
+ *             secret, sizeof(secret)
+ *        );
+ *        printf("%016llx\n", (unsigned long long) h);
+ *    }
+ * @endcode
  */
-XXH_PUBLIC_API XXH_errorcode XXH3_generateSecret(void* secretBuffer, size_t secretSize, const void* customSeed, size_t customSeedSize);
-
+XXH_PUBLIC_API XXH_errorcode XXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize);
 
-/*
- * XXH3_generateSecret_fromSeed():
- *
- * Generate the same secret as the _withSeed() variants.
- *
- * The resulting secret has a length of XXH3_SECRET_DEFAULT_SIZE (necessarily).
- * @secretBuffer must be already allocated, of size at least XXH3_SECRET_DEFAULT_SIZE bytes.
+/*!
+ * @brief Generate the same secret as the _withSeed() variants.
  *
  * The generated secret can be used in combination with
  *`*_withSecret()` and `_withSecretandSeed()` variants.
- * This generator is notably useful in combination with `_withSecretandSeed()`,
- * as a way to emulate a faster `_withSeed()` variant.
+ *
+ * Example C++ `std::string` hash class:
+ * @code{.cpp}
+ *    #include <string>
+ *    #define XXH_STATIC_LINKING_ONLY // expose unstable API
+ *    #include "xxhash.h"
+ *    // Slow, seeds each time
+ *    class HashSlow {
+ *        XXH64_hash_t seed;
+ *    public:
+ *        HashSlow(XXH64_hash_t s) : seed{s} {}
+ *        size_t operator()(const std::string& x) const {
+ *            return size_t{XXH3_64bits_withSeed(x.c_str(), x.length(), seed)};
+ *        }
+ *    };
+ *    // Fast, caches the seeded secret for future uses.
+ *    class HashFast {
+ *        unsigned char secret[XXH3_SECRET_SIZE_MIN];
+ *    public:
+ *        HashFast(XXH64_hash_t s) {
+ *            XXH3_generateSecret_fromSeed(secret, seed);
+ *        }
+ *        size_t operator()(const std::string& x) const {
+ *            return size_t{
+ *                XXH3_64bits_withSecret(x.c_str(), x.length(), secret, sizeof(secret))
+ *            };
+ *        }
+ *    };
+ * @endcode
+ * @param secretBuffer A writable buffer of @ref XXH3_SECRET_SIZE_MIN bytes
+ * @param seed The seed to seed the state.
  */
-XXH_PUBLIC_API void XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed);
+XXH_PUBLIC_API void XXH3_generateSecret_fromSeed(XXH_NOESCAPE void* secretBuffer, XXH64_hash_t seed);
 
-/*
- * *_withSecretandSeed() :
+/*!
  * These variants generate hash values using either
- * @seed for "short" keys (< XXH3_MIDSIZE_MAX = 240 bytes)
- * or @secret for "large" keys (>= XXH3_MIDSIZE_MAX).
+ * @p seed for "short" keys (< XXH3_MIDSIZE_MAX = 240 bytes)
+ * or @p secret for "large" keys (>= XXH3_MIDSIZE_MAX).
  *
  * This generally benefits speed, compared to `_withSeed()` or `_withSecret()`.
  * `_withSeed()` has to generate the secret on the fly for "large" keys.
@@ -1181,7 +1699,7 @@ XXH_PUBLIC_API void XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_
  * which requires more instructions than _withSeed() variants.
  * Therefore, _withSecretandSeed variant combines the best of both worlds.
  *
- * When @secret has been generated by XXH3_generateSecret_fromSeed(),
+ * When @p secret has been generated by XXH3_generateSecret_fromSeed(),
  * this variant produces *exactly* the same results as `_withSeed()` variant,
  * hence offering only a pure speed benefit on "large" input,
  * by skipping the need to regenerate the secret for every large input.
@@ -1190,32 +1708,34 @@ XXH_PUBLIC_API void XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_
  * for example with XXH3_64bits(), which then becomes the seed,
  * and then employ both the seed and the secret in _withSecretandSeed().
  * On top of speed, an added benefit is that each bit in the secret
- * has a 50% chance to swap each bit in the output,
- * via its impact to the seed.
+ * has a 50% chance to swap each bit in the output, via its impact to the seed.
+ *
  * This is not guaranteed when using the secret directly in "small data" scenarios,
  * because only portions of the secret are employed for small data.
  */
-XXH_PUBLIC_API XXH64_hash_t
-XXH3_64bits_withSecretandSeed(const void* data, size_t len,
-                              const void* secret, size_t secretSize,
+XXH_PUBLIC_API XXH_PUREF XXH64_hash_t
+XXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* data, size_t len,
+                              XXH_NOESCAPE const void* secret, size_t secretSize,
                               XXH64_hash_t seed);
-
-XXH_PUBLIC_API XXH128_hash_t
-XXH3_128bits_withSecretandSeed(const void* data, size_t len,
-                               const void* secret, size_t secretSize,
+/*! @copydoc XXH3_64bits_withSecretandSeed() */
+XXH_PUBLIC_API XXH_PUREF XXH128_hash_t
+XXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length,
+                               XXH_NOESCAPE const void* secret, size_t secretSize,
                                XXH64_hash_t seed64);
-
+#ifndef XXH_NO_STREAM
+/*! @copydoc XXH3_64bits_withSecretandSeed() */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
-                                    const void* secret, size_t secretSize,
+XXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,
+                                    XXH_NOESCAPE const void* secret, size_t secretSize,
                                     XXH64_hash_t seed64);
-
+/*! @copydoc XXH3_64bits_withSecretandSeed() */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
-                                     const void* secret, size_t secretSize,
+XXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,
+                                     XXH_NOESCAPE const void* secret, size_t secretSize,
                                      XXH64_hash_t seed64);
+#endif /* !XXH_NO_STREAM */
 
-
+#endif  /* !XXH_NO_XXH3 */
 #endif  /* XXH_NO_LONG_LONG */
 #if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
 #  define XXH_IMPLEMENTATION
@@ -1269,7 +1789,7 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
 /*!
  * @brief Define this to disable 64-bit code.
  *
- * Useful if only using the @ref xxh32_family and you have a strict C90 compiler.
+ * Useful if only using the @ref XXH32_family and you have a strict C90 compiler.
  */
 #  define XXH_NO_LONG_LONG
 #  undef XXH_NO_LONG_LONG /* don't actually */
@@ -1292,7 +1812,7 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  *     Use `memcpy()`. Safe and portable. Note that most modern compilers will
  *     eliminate the function call and treat it as an unaligned access.
  *
- *  - `XXH_FORCE_MEMORY_ACCESS=1`: `__attribute__((packed))`
+ *  - `XXH_FORCE_MEMORY_ACCESS=1`: `__attribute__((aligned(1)))`
  *   @par
  *     Depends on compiler extensions and is therefore not portable.
  *     This method is safe _if_ your compiler supports it,
@@ -1312,19 +1832,47 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  *     inline small `memcpy()` calls, and it might also be faster on big-endian
  *     systems which lack a native byteswap instruction. However, some compilers
  *     will emit literal byteshifts even if the target supports unaligned access.
- *  .
+ *
  *
  * @warning
  *   Methods 1 and 2 rely on implementation-defined behavior. Use these with
  *   care, as what works on one compiler/platform/optimization level may cause
  *   another to read garbage data or even crash.
  *
- * See http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.
+ * See https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.
  *
  * Prefer these methods in priority order (0 > 3 > 1 > 2)
  */
 #  define XXH_FORCE_MEMORY_ACCESS 0
 
+/*!
+ * @def XXH_SIZE_OPT
+ * @brief Controls how much xxHash optimizes for size.
+ *
+ * xxHash, when compiled, tends to result in a rather large binary size. This
+ * is mostly due to heavy usage to forced inlining and constant folding of the
+ * @ref XXH3_family to increase performance.
+ *
+ * However, some developers prefer size over speed. This option can
+ * significantly reduce the size of the generated code. When using the `-Os`
+ * or `-Oz` options on GCC or Clang, this is defined to 1 by default,
+ * otherwise it is defined to 0.
+ *
+ * Most of these size optimizations can be controlled manually.
+ *
+ * This is a number from 0-2.
+ *  - `XXH_SIZE_OPT` == 0: Default. xxHash makes no size optimizations. Speed
+ *    comes first.
+ *  - `XXH_SIZE_OPT` == 1: Default for `-Os` and `-Oz`. xxHash is more
+ *    conservative and disables hacks that increase code size. It implies the
+ *    options @ref XXH_NO_INLINE_HINTS == 1, @ref XXH_FORCE_ALIGN_CHECK == 0,
+ *    and @ref XXH3_NEON_LANES == 8 if they are not already defined.
+ *  - `XXH_SIZE_OPT` == 2: xxHash tries to make itself as small as possible.
+ *    Performance may cry. For example, the single shot functions just use the
+ *    streaming API.
+ */
+#  define XXH_SIZE_OPT 0
+
 /*!
  * @def XXH_FORCE_ALIGN_CHECK
  * @brief If defined to non-zero, adds a special path for aligned inputs (XXH32()
@@ -1346,9 +1894,11 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  *
  * In these cases, the alignment check can be removed by setting this macro to 0.
  * Then the code will always use unaligned memory access.
- * Align check is automatically disabled on x86, x64 & arm64,
+ * Align check is automatically disabled on x86, x64, ARM64, and some ARM chips
  * which are platforms known to offer good unaligned memory accesses performance.
  *
+ * It is also disabled by default when @ref XXH_SIZE_OPT >= 1.
+ *
  * This option does not affect XXH3 (only XXH32 and XXH64).
  */
 #  define XXH_FORCE_ALIGN_CHECK 0
@@ -1370,11 +1920,28 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  * XXH_NO_INLINE_HINTS marks all internal functions as static, giving the
  * compiler full control on whether to inline or not.
  *
- * When not optimizing (-O0), optimizing for size (-Os, -Oz), or using
- * -fno-inline with GCC or Clang, this will automatically be defined.
+ * When not optimizing (-O0), using `-fno-inline` with GCC or Clang, or if
+ * @ref XXH_SIZE_OPT >= 1, this will automatically be defined.
  */
 #  define XXH_NO_INLINE_HINTS 0
 
+/*!
+ * @def XXH3_INLINE_SECRET
+ * @brief Determines whether to inline the XXH3 withSecret code.
+ *
+ * When the secret size is known, the compiler can improve the performance
+ * of XXH3_64bits_withSecret() and XXH3_128bits_withSecret().
+ *
+ * However, if the secret size is not known, it doesn't have any benefit. This
+ * happens when xxHash is compiled into a global symbol. Therefore, if
+ * @ref XXH_INLINE_ALL is *not* defined, this will be defined to 0.
+ *
+ * Additionally, this defaults to 0 on GCC 12+, which has an issue with function pointers
+ * that are *sometimes* force inline on -Og, and it is impossible to automatically
+ * detect this optimization level.
+ */
+#  define XXH3_INLINE_SECRET 0
+
 /*!
  * @def XXH32_ENDJMP
  * @brief Whether to use a jump for `XXH32_finalize`.
@@ -1396,34 +1963,45 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  */
 #  define XXH_OLD_NAMES
 #  undef XXH_OLD_NAMES /* don't actually use, it is ugly. */
+
+/*!
+ * @def XXH_NO_STREAM
+ * @brief Disables the streaming API.
+ *
+ * When xxHash is not inlined and the streaming functions are not used, disabling
+ * the streaming functions can improve code size significantly, especially with
+ * the @ref XXH3_family which tends to make constant folded copies of itself.
+ */
+#  define XXH_NO_STREAM
+#  undef XXH_NO_STREAM /* don't actually */
 #endif /* XXH_DOXYGEN */
 /*!
  * @}
  */
 
 #ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-   /* prefer __packed__ structures (method 1) for gcc on armv7+ and mips */
-#  if !defined(__clang__) && \
-( \
-    (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
-    ( \
-        defined(__GNUC__) && ( \
-            (defined(__ARM_ARCH) && __ARM_ARCH >= 7) || \
-            ( \
-                defined(__mips__) && \
-                (__mips <= 5 || __mips_isa_rev < 6) && \
-                (!defined(__mips16) || defined(__mips_mips16e2)) \
-            ) \
-        ) \
-    ) \
-)
+   /* prefer __packed__ structures (method 1) for GCC
+    * < ARMv7 with unaligned access (e.g. Raspbian armhf) still uses byte shifting, so we use memcpy
+    * which for some reason does unaligned loads. */
+#  if defined(__GNUC__) && !(defined(__ARM_ARCH) && __ARM_ARCH < 7 && defined(__ARM_FEATURE_UNALIGNED))
 #    define XXH_FORCE_MEMORY_ACCESS 1
 #  endif
 #endif
 
+#ifndef XXH_SIZE_OPT
+   /* default to 1 for -Os or -Oz */
+#  if (defined(__GNUC__) || defined(__clang__)) && defined(__OPTIMIZE_SIZE__)
+#    define XXH_SIZE_OPT 1
+#  else
+#    define XXH_SIZE_OPT 0
+#  endif
+#endif
+
 #ifndef XXH_FORCE_ALIGN_CHECK  /* can be defined externally */
-#  if defined(__i386)  || defined(__x86_64__) || defined(__aarch64__) \
-   || defined(_M_IX86) || defined(_M_X64)     || defined(_M_ARM64) /* visual */
+   /* don't check on sizeopt, x86, aarch64, or arm when unaligned access is available */
+#  if XXH_SIZE_OPT >= 1 || \
+      defined(__i386)  || defined(__x86_64__) || defined(__aarch64__) || defined(__ARM_FEATURE_UNALIGNED) \
+   || defined(_M_IX86) || defined(_M_X64)     || defined(_M_ARM64)    || defined(_M_ARM) /* visual */
 #    define XXH_FORCE_ALIGN_CHECK 0
 #  else
 #    define XXH_FORCE_ALIGN_CHECK 1
@@ -1431,14 +2009,22 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
 #endif
 
 #ifndef XXH_NO_INLINE_HINTS
-#  if defined(__OPTIMIZE_SIZE__) /* -Os, -Oz */ \
-   || defined(__NO_INLINE__)     /* -O0, -fno-inline */
+#  if XXH_SIZE_OPT >= 1 || defined(__NO_INLINE__)  /* -O0, -fno-inline */
 #    define XXH_NO_INLINE_HINTS 1
 #  else
 #    define XXH_NO_INLINE_HINTS 0
 #  endif
 #endif
 
+#ifndef XXH3_INLINE_SECRET
+#  if (defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 12) \
+     || !defined(XXH_INLINE_ALL)
+#    define XXH3_INLINE_SECRET 0
+#  else
+#    define XXH3_INLINE_SECRET 1
+#  endif
+#endif
+
 #ifndef XXH32_ENDJMP
 /* generally preferable for performance */
 #  define XXH32_ENDJMP 0
@@ -1453,6 +2039,24 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
 /* *************************************
 *  Includes & Memory related functions
 ***************************************/
+#if defined(XXH_NO_STREAM)
+/* nothing */
+#elif defined(XXH_NO_STDLIB)
+
+/* When requesting to disable any mention of stdlib,
+ * the library loses the ability to invoked malloc / free.
+ * In practice, it means that functions like `XXH*_createState()`
+ * will always fail, and return NULL.
+ * This flag is useful in situations where
+ * xxhash.h is integrated into some kernel, embedded or limited environment
+ * without access to dynamic allocation.
+ */
+
+static XXH_CONSTF void* XXH_malloc(size_t s) { (void)s; return NULL; }
+static void XXH_free(void* p) { (void)p; }
+
+#else
+
 /*
  * Modify the local functions below should you wish to use
  * different memory routines for malloc() and free()
@@ -1463,7 +2067,7 @@ XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr,
  * @internal
  * @brief Modify this function to use a different routine than malloc().
  */
-static void* XXH_malloc(size_t s) { return malloc(s); }
+static XXH_MALLOCF void* XXH_malloc(size_t s) { return malloc(s); }
 
 /*!
  * @internal
@@ -1471,6 +2075,8 @@ static void* XXH_malloc(size_t s) { return malloc(s); }
  */
 static void XXH_free(void* p) { free(p); }
 
+#endif  /* XXH_NO_STDLIB */
+
 #include <string.h>
 
 /*!
@@ -1515,6 +2121,11 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size)
 #  define XXH_NO_INLINE static
 #endif
 
+#if XXH3_INLINE_SECRET
+#  define XXH3_WITH_SECRET_INLINE XXH_FORCE_INLINE
+#else
+#  define XXH3_WITH_SECRET_INLINE XXH_NO_INLINE
+#endif
 
 
 /* *************************************
@@ -1540,14 +2151,17 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size)
 #  include <assert.h>   /* note: can still be disabled with NDEBUG */
 #  define XXH_ASSERT(c)   assert(c)
 #else
-#  define XXH_ASSERT(c)   ((void)0)
+#  if defined(__INTEL_COMPILER)
+#    define XXH_ASSERT(c)   XXH_ASSUME((unsigned char) (c))
+#  else
+#    define XXH_ASSERT(c)   XXH_ASSUME(c)
+#  endif
 #endif
 
 /* note: use after variable declarations */
 #ifndef XXH_STATIC_ASSERT
 #  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)    /* C11 */
-#    include <assert.h>
-#    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { static_assert((c),m); } while(0)
+#    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { _Static_assert((c),m); } while(0)
 #  elif defined(__cplusplus) && (__cplusplus >= 201103L)            /* C++11 */
 #    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { static_assert((c),m); } while(0)
 #  else
@@ -1573,11 +2187,19 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size)
  * XXH3_initCustomSecret_scalar().
  */
 #if defined(__GNUC__) || defined(__clang__)
-#  define XXH_COMPILER_GUARD(var) __asm__ __volatile__("" : "+r" (var))
+#  define XXH_COMPILER_GUARD(var) __asm__("" : "+r" (var))
 #else
 #  define XXH_COMPILER_GUARD(var) ((void)0)
 #endif
 
+/* Specifically for NEON vectors which use the "w" constraint, on
+ * Clang. */
+#if defined(__clang__) && defined(__ARM_ARCH) && !defined(__wasm__)
+#  define XXH_COMPILER_GUARD_CLANG_NEON(var) __asm__("" : "+w" (var))
+#else
+#  define XXH_COMPILER_GUARD_CLANG_NEON(var) ((void)0)
+#endif
+
 /* *************************************
 *  Basic Types
 ***************************************/
@@ -1592,6 +2214,7 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size)
 typedef XXH32_hash_t xxh_u32;
 
 #ifdef XXH_OLD_NAMES
+#  warning "XXH_OLD_NAMES is planned to be removed starting v0.9. If the program depends on it, consider moving away from it by employing newer type names directly"
 #  define BYTE xxh_u8
 #  define U8   xxh_u8
 #  define U32  xxh_u32
@@ -1665,25 +2288,26 @@ static xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*) memPtr;
 #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
 
 /*
- * __pack instructions are safer but compiler specific, hence potentially
- * problematic for some compilers.
- *
- * Currently only defined for GCC and ICC.
+ * __attribute__((aligned(1))) is supported by gcc and clang. Originally the
+ * documentation claimed that it only increased the alignment, but actually it
+ * can decrease it on gcc, clang, and icc:
+ * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,
+ * https://gcc.godbolt.org/z/xYez1j67Y.
  */
 #ifdef XXH_OLD_NAMES
 typedef union { xxh_u32 u32; } __attribute__((packed)) unalign;
 #endif
 static xxh_u32 XXH_read32(const void* ptr)
 {
-    typedef union { xxh_u32 u32; } __attribute__((packed)) xxh_unalign;
-    return ((const xxh_unalign*)ptr)->u32;
+    typedef __attribute__((aligned(1))) xxh_u32 xxh_unalign32;
+    return *((const xxh_unalign32*)ptr);
 }
 
 #else
 
 /*
  * Portable and safe solution. Generally efficient.
- * see: http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
+ * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
  */
 static xxh_u32 XXH_read32(const void* memPtr)
 {
@@ -1759,6 +2383,51 @@ static int XXH_isLittleEndian(void)
 #  define XXH_HAS_BUILTIN(x) 0
 #endif
 
+
+
+/*
+ * C23 and future versions have standard "unreachable()".
+ * Once it has been implemented reliably we can add it as an
+ * additional case:
+ *
+ * ```
+ * #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= XXH_C23_VN)
+ * #  include <stddef.h>
+ * #  ifdef unreachable
+ * #    define XXH_UNREACHABLE() unreachable()
+ * #  endif
+ * #endif
+ * ```
+ *
+ * Note C++23 also has std::unreachable() which can be detected
+ * as follows:
+ * ```
+ * #if defined(__cpp_lib_unreachable) && (__cpp_lib_unreachable >= 202202L)
+ * #  include <utility>
+ * #  define XXH_UNREACHABLE() std::unreachable()
+ * #endif
+ * ```
+ * NB: `__cpp_lib_unreachable` is defined in the `<version>` header.
+ * We don't use that as including `<utility>` in `extern "C"` blocks
+ * doesn't work on GCC12
+ */
+
+#if XXH_HAS_BUILTIN(__builtin_unreachable)
+#  define XXH_UNREACHABLE() __builtin_unreachable()
+
+#elif defined(_MSC_VER)
+#  define XXH_UNREACHABLE() __assume(0)
+
+#else
+#  define XXH_UNREACHABLE()
+#endif
+
+#if XXH_HAS_BUILTIN(__builtin_assume)
+#  define XXH_ASSUME(c) __builtin_assume(c)
+#else
+#  define XXH_ASSUME(c) if (!(c)) { XXH_UNREACHABLE(); }
+#endif
+
 /*!
  * @internal
  * @def XXH_rotl32(x,r)
@@ -1881,8 +2550,10 @@ XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
 *********************************************************************/
 /*!
  * @}
- * @defgroup xxh32_impl XXH32 implementation
+ * @defgroup XXH32_impl XXH32 implementation
  * @ingroup impl
+ *
+ * Details on the XXH32 implementation.
  * @{
  */
  /* #define instead of static const, to be used as initializers */
@@ -1916,7 +2587,7 @@ static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
     acc += input * XXH_PRIME32_2;
     acc  = XXH_rotl32(acc, 13);
     acc *= XXH_PRIME32_1;
-#if (defined(__SSE4_1__) || defined(__aarch64__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)
+#if (defined(__SSE4_1__) || defined(__aarch64__) || defined(__wasm_simd128__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)
     /*
      * UGLY HACK:
      * A compiler fence is the only thing that prevents GCC and Clang from
@@ -1946,9 +2617,12 @@ static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
      *   can load data, while v3 can multiply. SSE forces them to operate
      *   together.
      *
-     * This is also enabled on AArch64, as Clang autovectorizes it incorrectly
-     * and it is pointless writing a NEON implementation that is basically the
-     * same speed as scalar for XXH32.
+     * This is also enabled on AArch64, as Clang is *very aggressive* in vectorizing
+     * the loop. NEON is only faster on the A53, and with the newer cores, it is less
+     * than half the speed.
+     *
+     * Additionally, this is used on WASM SIMD128 because it JITs to the same
+     * SIMD instructions and has the same issue.
      */
     XXH_COMPILER_GUARD(acc);
 #endif
@@ -1962,17 +2636,17 @@ static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
  * The final mix ensures that all input bits have a chance to impact any bit in
  * the output digest, resulting in an unbiased distribution.
  *
- * @param h32 The hash to avalanche.
+ * @param hash The hash to avalanche.
  * @return The avalanched hash.
  */
-static xxh_u32 XXH32_avalanche(xxh_u32 h32)
+static xxh_u32 XXH32_avalanche(xxh_u32 hash)
 {
-    h32 ^= h32 >> 15;
-    h32 *= XXH_PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= XXH_PRIME32_3;
-    h32 ^= h32 >> 16;
-    return(h32);
+    hash ^= hash >> 15;
+    hash *= XXH_PRIME32_2;
+    hash ^= hash >> 13;
+    hash *= XXH_PRIME32_3;
+    hash ^= hash >> 16;
+    return hash;
 }
 
 #define XXH_get32bits(p) XXH_readLE32_align(p, align)
@@ -1985,24 +2659,25 @@ static xxh_u32 XXH32_avalanche(xxh_u32 h32)
  * This final stage will digest them to ensure that all input bytes are present
  * in the final mix.
  *
- * @param h32 The hash to finalize.
+ * @param hash The hash to finalize.
  * @param ptr The pointer to the remaining input.
  * @param len The remaining length, modulo 16.
  * @param align Whether @p ptr is aligned.
  * @return The finalized hash.
+ * @see XXH64_finalize().
  */
-static xxh_u32
-XXH32_finalize(xxh_u32 h32, const xxh_u8* ptr, size_t len, XXH_alignment align)
+static XXH_PUREF xxh_u32
+XXH32_finalize(xxh_u32 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)
 {
-#define XXH_PROCESS1 do {                           \
-    h32 += (*ptr++) * XXH_PRIME32_5;                \
-    h32 = XXH_rotl32(h32, 11) * XXH_PRIME32_1;      \
+#define XXH_PROCESS1 do {                             \
+    hash += (*ptr++) * XXH_PRIME32_5;                 \
+    hash = XXH_rotl32(hash, 11) * XXH_PRIME32_1;      \
 } while (0)
 
-#define XXH_PROCESS4 do {                           \
-    h32 += XXH_get32bits(ptr) * XXH_PRIME32_3;      \
-    ptr += 4;                                   \
-    h32  = XXH_rotl32(h32, 17) * XXH_PRIME32_4;     \
+#define XXH_PROCESS4 do {                             \
+    hash += XXH_get32bits(ptr) * XXH_PRIME32_3;       \
+    ptr += 4;                                         \
+    hash  = XXH_rotl32(hash, 17) * XXH_PRIME32_4;     \
 } while (0)
 
     if (ptr==NULL) XXH_ASSERT(len == 0);
@@ -2018,49 +2693,49 @@ XXH32_finalize(xxh_u32 h32, const xxh_u8* ptr, size_t len, XXH_alignment align)
             XXH_PROCESS1;
             --len;
         }
-        return XXH32_avalanche(h32);
+        return XXH32_avalanche(hash);
     } else {
          switch(len&15) /* or switch(bEnd - p) */ {
            case 12:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 8:       XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 4:       XXH_PROCESS4;
-                         return XXH32_avalanche(h32);
+                         return XXH32_avalanche(hash);
 
            case 13:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 9:       XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 5:       XXH_PROCESS4;
                          XXH_PROCESS1;
-                         return XXH32_avalanche(h32);
+                         return XXH32_avalanche(hash);
 
            case 14:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 10:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 6:       XXH_PROCESS4;
                          XXH_PROCESS1;
                          XXH_PROCESS1;
-                         return XXH32_avalanche(h32);
+                         return XXH32_avalanche(hash);
 
            case 15:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 11:      XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 7:       XXH_PROCESS4;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 3:       XXH_PROCESS1;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 2:       XXH_PROCESS1;
-                         XXH_FALLTHROUGH;
+                         XXH_FALLTHROUGH;  /* fallthrough */
            case 1:       XXH_PROCESS1;
-                         XXH_FALLTHROUGH;
-           case 0:       return XXH32_avalanche(h32);
+                         XXH_FALLTHROUGH;  /* fallthrough */
+           case 0:       return XXH32_avalanche(hash);
         }
         XXH_ASSERT(0);
-        return h32;   /* reaching this point is deemed impossible */
+        return hash;   /* reaching this point is deemed impossible */
     }
 }
 
@@ -2080,7 +2755,7 @@ XXH32_finalize(xxh_u32 h32, const xxh_u8* ptr, size_t len, XXH_alignment align)
  * @param align Whether @p input is aligned.
  * @return The calculated hash.
  */
-XXH_FORCE_INLINE xxh_u32
+XXH_FORCE_INLINE XXH_PUREF xxh_u32
 XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align)
 {
     xxh_u32 h32;
@@ -2113,10 +2788,10 @@ XXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment
     return XXH32_finalize(h32, input, len&15, align);
 }
 
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)
 {
-#if 0
+#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2
     /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
     XXH32_state_t state;
     XXH32_reset(&state, seed);
@@ -2135,42 +2810,39 @@ XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t s
 
 
 /*******   Hash streaming   *******/
-/*!
- * @ingroup xxh32_family
- */
+#ifndef XXH_NO_STREAM
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
 {
     return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
 }
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
 {
     XXH_free(statePtr);
     return XXH_OK;
 }
 
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
 {
     XXH_memcpy(dstState, srcState, sizeof(*dstState));
 }
 
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed)
 {
-    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v[0] = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
-    state.v[1] = seed + XXH_PRIME32_2;
-    state.v[2] = seed + 0;
-    state.v[3] = seed - XXH_PRIME32_1;
-    /* do not write into reserved, planned to be removed in a future version */
-    XXH_memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
+    XXH_ASSERT(statePtr != NULL);
+    memset(statePtr, 0, sizeof(*statePtr));
+    statePtr->v[0] = seed + XXH_PRIME32_1 + XXH_PRIME32_2;
+    statePtr->v[1] = seed + XXH_PRIME32_2;
+    statePtr->v[2] = seed + 0;
+    statePtr->v[3] = seed - XXH_PRIME32_1;
     return XXH_OK;
 }
 
 
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH_errorcode
 XXH32_update(XXH32_state_t* state, const void* input, size_t len)
 {
@@ -2225,7 +2897,7 @@ XXH32_update(XXH32_state_t* state, const void* input, size_t len)
 }
 
 
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state)
 {
     xxh_u32 h32;
@@ -2243,12 +2915,12 @@ XXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state)
 
     return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);
 }
-
+#endif /* !XXH_NO_STREAM */
 
 /*******   Canonical representation   *******/
 
 /*!
- * @ingroup xxh32_family
+ * @ingroup XXH32_family
  * The default return values from XXH functions are unsigned 32 and 64 bit
  * integers.
  *
@@ -2267,7 +2939,7 @@ XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t
     if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
     XXH_memcpy(dst, &hash, sizeof(*dst));
 }
-/*! @ingroup xxh32_family */
+/*! @ingroup XXH32_family */
 XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
 {
     return XXH_readBE32(src);
@@ -2308,25 +2980,26 @@ static xxh_u64 XXH_read64(const void* memPtr)
 #elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
 
 /*
- * __pack instructions are safer, but compiler specific, hence potentially
- * problematic for some compilers.
- *
- * Currently only defined for GCC and ICC.
+ * __attribute__((aligned(1))) is supported by gcc and clang. Originally the
+ * documentation claimed that it only increased the alignment, but actually it
+ * can decrease it on gcc, clang, and icc:
+ * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,
+ * https://gcc.godbolt.org/z/xYez1j67Y.
  */
 #ifdef XXH_OLD_NAMES
 typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) unalign64;
 #endif
 static xxh_u64 XXH_read64(const void* ptr)
 {
-    typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) xxh_unalign64;
-    return ((const xxh_unalign64*)ptr)->u64;
+    typedef __attribute__((aligned(1))) xxh_u64 xxh_unalign64;
+    return *((const xxh_unalign64*)ptr);
 }
 
 #else
 
 /*
  * Portable and safe solution. Generally efficient.
- * see: http://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
+ * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html
  */
 static xxh_u64 XXH_read64(const void* memPtr)
 {
@@ -2410,8 +3083,10 @@ XXH_readLE64_align(const void* ptr, XXH_alignment align)
 /*******   xxh64   *******/
 /*!
  * @}
- * @defgroup xxh64_impl XXH64 implementation
+ * @defgroup XXH64_impl XXH64 implementation
  * @ingroup impl
+ *
+ * Details on the XXH64 implementation.
  * @{
  */
 /* #define rather that static const, to be used as initializers */
@@ -2429,6 +3104,7 @@ XXH_readLE64_align(const void* ptr, XXH_alignment align)
 #  define PRIME64_5 XXH_PRIME64_5
 #endif
 
+/*! @copydoc XXH32_round */
 static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
 {
     acc += input * XXH_PRIME64_2;
@@ -2445,43 +3121,59 @@ static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)
     return acc;
 }
 
-static xxh_u64 XXH64_avalanche(xxh_u64 h64)
+/*! @copydoc XXH32_avalanche */
+static xxh_u64 XXH64_avalanche(xxh_u64 hash)
 {
-    h64 ^= h64 >> 33;
-    h64 *= XXH_PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= XXH_PRIME64_3;
-    h64 ^= h64 >> 32;
-    return h64;
+    hash ^= hash >> 33;
+    hash *= XXH_PRIME64_2;
+    hash ^= hash >> 29;
+    hash *= XXH_PRIME64_3;
+    hash ^= hash >> 32;
+    return hash;
 }
 
 
 #define XXH_get64bits(p) XXH_readLE64_align(p, align)
 
-static xxh_u64
-XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len, XXH_alignment align)
+/*!
+ * @internal
+ * @brief Processes the last 0-31 bytes of @p ptr.
+ *
+ * There may be up to 31 bytes remaining to consume from the input.
+ * This final stage will digest them to ensure that all input bytes are present
+ * in the final mix.
+ *
+ * @param hash The hash to finalize.
+ * @param ptr The pointer to the remaining input.
+ * @param len The remaining length, modulo 32.
+ * @param align Whether @p ptr is aligned.
+ * @return The finalized hash
+ * @see XXH32_finalize().
+ */
+static XXH_PUREF xxh_u64
+XXH64_finalize(xxh_u64 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)
 {
     if (ptr==NULL) XXH_ASSERT(len == 0);
     len &= 31;
     while (len >= 8) {
         xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr));
         ptr += 8;
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * XXH_PRIME64_1 + XXH_PRIME64_4;
+        hash ^= k1;
+        hash  = XXH_rotl64(hash,27) * XXH_PRIME64_1 + XXH_PRIME64_4;
         len -= 8;
     }
     if (len >= 4) {
-        h64 ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;
+        hash ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;
         ptr += 4;
-        h64 = XXH_rotl64(h64, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;
+        hash = XXH_rotl64(hash, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;
         len -= 4;
     }
     while (len > 0) {
-        h64 ^= (*ptr++) * XXH_PRIME64_5;
-        h64 = XXH_rotl64(h64, 11) * XXH_PRIME64_1;
+        hash ^= (*ptr++) * XXH_PRIME64_5;
+        hash = XXH_rotl64(hash, 11) * XXH_PRIME64_1;
         --len;
     }
-    return  XXH64_avalanche(h64);
+    return  XXH64_avalanche(hash);
 }
 
 #ifdef XXH_OLD_NAMES
@@ -2494,7 +3186,15 @@ XXH64_finalize(xxh_u64 h64, const xxh_u8* ptr, size_t len, XXH_alignment align)
 #  undef XXH_PROCESS8_64
 #endif
 
-XXH_FORCE_INLINE xxh_u64
+/*!
+ * @internal
+ * @brief The implementation for @ref XXH64().
+ *
+ * @param input , len , seed Directly passed from @ref XXH64().
+ * @param align Whether @p input is aligned.
+ * @return The calculated hash.
+ */
+XXH_FORCE_INLINE XXH_PUREF xxh_u64
 XXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment align)
 {
     xxh_u64 h64;
@@ -2531,10 +3231,10 @@ XXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment
 }
 
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t len, XXH64_hash_t seed)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API XXH64_hash_t XXH64 (XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)
 {
-#if 0
+#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2
     /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
     XXH64_state_t state;
     XXH64_reset(&state, seed);
@@ -2552,42 +3252,40 @@ XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t len, XXH64_hash_t s
 }
 
 /*******   Hash Streaming   *******/
-
-/*! @ingroup xxh64_family*/
+#ifndef XXH_NO_STREAM
+/*! @ingroup XXH64_family*/
 XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
 {
     return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
 }
-/*! @ingroup xxh64_family */
+/*! @ingroup XXH64_family */
 XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
 {
     XXH_free(statePtr);
     return XXH_OK;
 }
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dstState, const XXH64_state_t* srcState)
 {
     XXH_memcpy(dstState, srcState, sizeof(*dstState));
 }
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, XXH64_hash_t seed)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed)
 {
-    XXH64_state_t state;   /* use a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v[0] = seed + XXH_PRIME64_1 + XXH_PRIME64_2;
-    state.v[1] = seed + XXH_PRIME64_2;
-    state.v[2] = seed + 0;
-    state.v[3] = seed - XXH_PRIME64_1;
-     /* do not write into reserved64, might be removed in a future version */
-    XXH_memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved64));
+    XXH_ASSERT(statePtr != NULL);
+    memset(statePtr, 0, sizeof(*statePtr));
+    statePtr->v[0] = seed + XXH_PRIME64_1 + XXH_PRIME64_2;
+    statePtr->v[1] = seed + XXH_PRIME64_2;
+    statePtr->v[2] = seed + 0;
+    statePtr->v[3] = seed - XXH_PRIME64_1;
     return XXH_OK;
 }
 
-/*! @ingroup xxh64_family */
+/*! @ingroup XXH64_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH64_update (XXH64_state_t* state, const void* input, size_t len)
+XXH64_update (XXH_NOESCAPE XXH64_state_t* state, XXH_NOESCAPE const void* input, size_t len)
 {
     if (input==NULL) {
         XXH_ASSERT(len == 0);
@@ -2637,8 +3335,8 @@ XXH64_update (XXH64_state_t* state, const void* input, size_t len)
 }
 
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API XXH64_hash_t XXH64_digest(XXH_NOESCAPE const XXH64_state_t* state)
 {
     xxh_u64 h64;
 
@@ -2656,20 +3354,20 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_digest(const XXH64_state_t* state)
 
     return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned);
 }
-
+#endif /* !XXH_NO_STREAM */
 
 /******* Canonical representation   *******/
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash)
 {
     XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
     if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
     XXH_memcpy(dst, &hash, sizeof(*dst));
 }
 
-/*! @ingroup xxh64_family */
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
+/*! @ingroup XXH64_family */
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src)
 {
     return XXH_readBE64(src);
 }
@@ -2682,7 +3380,7 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
 ************************************************************************ */
 /*!
  * @}
- * @defgroup xxh3_impl XXH3 implementation
+ * @defgroup XXH3_impl XXH3 implementation
  * @ingroup impl
  * @{
  */
@@ -2690,11 +3388,19 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
 /* ===   Compiler specifics   === */
 
 #if ((defined(sun) || defined(__sun)) && __cplusplus) /* Solaris includes __STDC_VERSION__ with C++. Tested with GCC 5.5 */
-#  define XXH_RESTRICT /* disable */
+#  define XXH_RESTRICT   /* disable */
 #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* >= C99 */
 #  define XXH_RESTRICT   restrict
+#elif (defined (__GNUC__) && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))) \
+   || (defined (__clang__)) \
+   || (defined (_MSC_VER) && (_MSC_VER >= 1400)) \
+   || (defined (__INTEL_COMPILER) && (__INTEL_COMPILER >= 1300))
+/*
+ * There are a LOT more compilers that recognize __restrict but this
+ * covers the major ones.
+ */
+#  define XXH_RESTRICT   __restrict
 #else
-/* Note: it might be useful to define __restrict or __restrict__ for some C++ compilers */
 #  define XXH_RESTRICT   /* disable */
 #endif
 
@@ -2708,17 +3414,33 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
 #    define XXH_unlikely(x) (x)
 #endif
 
-#if defined(__GNUC__)
-#  if defined(__AVX2__)
-#    include <immintrin.h>
-#  elif defined(__SSE2__)
-#    include <emmintrin.h>
-#  elif defined(__ARM_NEON__) || defined(__ARM_NEON)
+#ifndef XXH_HAS_INCLUDE
+#  ifdef __has_include
+#    define XXH_HAS_INCLUDE(x) __has_include(x)
+#  else
+#    define XXH_HAS_INCLUDE(x) 0
+#  endif
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+#  if defined(__ARM_FEATURE_SVE)
+#    include <arm_sve.h>
+#  endif
+#  if defined(__ARM_NEON__) || defined(__ARM_NEON) \
+   || (defined(_M_ARM) && _M_ARM >= 7) \
+   || defined(_M_ARM64) || defined(_M_ARM64EC) \
+   || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE(<arm_neon.h>)) /* WASM SIMD128 via SIMDe */
 #    define inline __inline__  /* circumvent a clang bug */
 #    include <arm_neon.h>
 #    undef inline
+#  elif defined(__AVX2__)
+#    include <immintrin.h>
+#  elif defined(__SSE2__)
+#    include <emmintrin.h>
 #  endif
-#elif defined(_MSC_VER)
+#endif
+
+#if defined(_MSC_VER)
 #  include <intrin.h>
 #endif
 
@@ -2818,7 +3540,7 @@ XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src
  * Note that these are actually implemented as macros.
  *
  * If this is not defined, it is detected automatically.
- * @ref XXH_X86DISPATCH overrides this.
+ * internal macro XXH_X86DISPATCH overrides this.
  */
 enum XXH_VECTOR_TYPE /* fake enum */ {
     XXH_SCALAR = 0,  /*!< Portable scalar version */
@@ -2830,14 +3552,19 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
                       */
     XXH_AVX2   = 2,  /*!< AVX2 for Haswell and Bulldozer */
     XXH_AVX512 = 3,  /*!< AVX512 for Skylake and Icelake */
-    XXH_NEON   = 4,  /*!< NEON for most ARMv7-A and all AArch64 */
+    XXH_NEON   = 4,  /*!<
+                       * NEON for most ARMv7-A, all AArch64, and WASM SIMD128
+                       * via the SIMDeverywhere polyfill provided with the
+                       * Emscripten SDK.
+                       */
     XXH_VSX    = 5,  /*!< VSX and ZVector for POWER8/z13 (64-bit) */
+    XXH_SVE    = 6,  /*!< SVE for some ARMv8-A and ARMv9-A */
 };
 /*!
  * @ingroup tuning
  * @brief Selects the minimum alignment for XXH3's accumulators.
  *
- * When using SIMD, this should match the alignment reqired for said vector
+ * When using SIMD, this should match the alignment required for said vector
  * type, so, for example, 32 for AVX2.
  *
  * Default: Auto detected.
@@ -2853,23 +3580,27 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
 #  define XXH_AVX512 3
 #  define XXH_NEON   4
 #  define XXH_VSX    5
+#  define XXH_SVE    6
 #endif
 
 #ifndef XXH_VECTOR    /* can be defined on command line */
-#  if defined(__AVX512F__)
-#    define XXH_VECTOR XXH_AVX512
-#  elif defined(__AVX2__)
-#    define XXH_VECTOR XXH_AVX2
-#  elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))
-#    define XXH_VECTOR XXH_SSE2
+#  if defined(__ARM_FEATURE_SVE)
+#    define XXH_VECTOR XXH_SVE
 #  elif ( \
         defined(__ARM_NEON__) || defined(__ARM_NEON) /* gcc */ \
-     || defined(_M_ARM64) || defined(_M_ARM_ARMV7VE) /* msvc */ \
+     || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) /* msvc */ \
+     || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE(<arm_neon.h>)) /* wasm simd128 via SIMDe */ \
    ) && ( \
         defined(_WIN32) || defined(__LITTLE_ENDIAN__) /* little endian only */ \
     || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
    )
 #    define XXH_VECTOR XXH_NEON
+#  elif defined(__AVX512F__)
+#    define XXH_VECTOR XXH_AVX512
+#  elif defined(__AVX2__)
+#    define XXH_VECTOR XXH_AVX2
+#  elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))
+#    define XXH_VECTOR XXH_SSE2
 #  elif (defined(__PPC64__) && defined(__POWER8_VECTOR__)) \
      || (defined(__s390x__) && defined(__VEC__)) \
      && defined(__GNUC__) /* TODO: IBM XL */
@@ -2879,6 +3610,17 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
 #  endif
 #endif
 
+/* __ARM_FEATURE_SVE is only supported by GCC & Clang. */
+#if (XXH_VECTOR == XXH_SVE) && !defined(__ARM_FEATURE_SVE)
+#  ifdef _MSC_VER
+#    pragma warning(once : 4606)
+#  else
+#    warning "__ARM_FEATURE_SVE isn't supported. Use SCALAR instead."
+#  endif
+#  undef XXH_VECTOR
+#  define XXH_VECTOR XXH_SCALAR
+#endif
+
 /*
  * Controls the alignment of the accumulator,
  * for compatibility with aligned vector loads, which are usually faster.
@@ -2898,16 +3640,26 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
 #     define XXH_ACC_ALIGN 16
 #  elif XXH_VECTOR == XXH_AVX512  /* avx512 */
 #     define XXH_ACC_ALIGN 64
+#  elif XXH_VECTOR == XXH_SVE   /* sve */
+#     define XXH_ACC_ALIGN 64
 #  endif
 #endif
 
 #if defined(XXH_X86DISPATCH) || XXH_VECTOR == XXH_SSE2 \
     || XXH_VECTOR == XXH_AVX2 || XXH_VECTOR == XXH_AVX512
 #  define XXH_SEC_ALIGN XXH_ACC_ALIGN
+#elif XXH_VECTOR == XXH_SVE
+#  define XXH_SEC_ALIGN XXH_ACC_ALIGN
 #else
 #  define XXH_SEC_ALIGN 8
 #endif
 
+#if defined(__GNUC__) || defined(__clang__)
+#  define XXH_ALIASING __attribute__((may_alias))
+#else
+#  define XXH_ALIASING /* nothing */
+#endif
+
 /*
  * UGLY HACK:
  * GCC usually generates the best code with -O3 for xxHash.
@@ -2931,111 +3683,130 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
  */
 #if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \
   && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
-  && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */
+  && defined(__OPTIMIZE__) && XXH_SIZE_OPT <= 0 /* respect -O0 and -Os */
 #  pragma GCC push_options
 #  pragma GCC optimize("-O2")
 #endif
 
-
 #if XXH_VECTOR == XXH_NEON
+
 /*
- * NEON's setup for vmlal_u32 is a little more complicated than it is on
- * SSE2, AVX2, and VSX.
- *
- * While PMULUDQ and VMULEUW both perform a mask, VMLAL.U32 performs an upcast.
- *
- * To do the same operation, the 128-bit 'Q' register needs to be split into
- * two 64-bit 'D' registers, performing this operation::
- *
- *   [                a                 |                 b                ]
- *            |              '---------. .--------'                |
- *            |                         x                          |
- *            |              .---------' '--------.                |
- *   [ a & 0xFFFFFFFF | b & 0xFFFFFFFF ],[    a >> 32     |     b >> 32    ]
+ * UGLY HACK: While AArch64 GCC on Linux does not seem to care, on macOS, GCC -O3
+ * optimizes out the entire hashLong loop because of the aliasing violation.
  *
- * Due to significant changes in aarch64, the fastest method for aarch64 is
- * completely different than the fastest method for ARMv7-A.
- *
- * ARMv7-A treats D registers as unions overlaying Q registers, so modifying
- * D11 will modify the high half of Q5. This is similar to how modifying AH
- * will only affect bits 8-15 of AX on x86.
- *
- * VZIP takes two registers, and puts even lanes in one register and odd lanes
- * in the other.
+ * However, GCC is also inefficient at load-store optimization with vld1q/vst1q,
+ * so the only option is to mark it as aliasing.
+ */
+typedef uint64x2_t xxh_aliasing_uint64x2_t XXH_ALIASING;
+
+/*!
+ * @internal
+ * @brief `vld1q_u64` but faster and alignment-safe.
  *
- * On ARMv7-A, this strangely modifies both parameters in place instead of
- * taking the usual 3-operand form.
+ * On AArch64, unaligned access is always safe, but on ARMv7-a, it is only
+ * *conditionally* safe (`vld1` has an alignment bit like `movdq[ua]` in x86).
  *
- * Therefore, if we want to do this, we can simply use a D-form VZIP.32 on the
- * lower and upper halves of the Q register to end up with the high and low
- * halves where we want - all in one instruction.
+ * GCC for AArch64 sees `vld1q_u8` as an intrinsic instead of a load, so it
+ * prohibits load-store optimizations. Therefore, a direct dereference is used.
  *
- *   vzip.32   d10, d11       @ d10 = { d10[0], d11[0] }; d11 = { d10[1], d11[1] }
+ * Otherwise, `vld1q_u8` is used with `vreinterpretq_u8_u64` to do a safe
+ * unaligned load.
+ */
+#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__)
+XXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr) /* silence -Wcast-align */
+{
+    return *(xxh_aliasing_uint64x2_t const *)ptr;
+}
+#else
+XXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr)
+{
+    return vreinterpretq_u64_u8(vld1q_u8((uint8_t const*)ptr));
+}
+#endif
+
+/*!
+ * @internal
+ * @brief `vmlal_u32` on low and high halves of a vector.
  *
- * Unfortunately we need inline assembly for this: Instructions modifying two
- * registers at once is not possible in GCC or Clang's IR, and they have to
- * create a copy.
+ * This is a workaround for AArch64 GCC < 11 which implemented arm_neon.h with
+ * inline assembly and were therefore incapable of merging the `vget_{low, high}_u32`
+ * with `vmlal_u32`.
+ */
+#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 11
+XXH_FORCE_INLINE uint64x2_t
+XXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)
+{
+    /* Inline assembly is the only way */
+    __asm__("umlal   %0.2d, %1.2s, %2.2s" : "+w" (acc) : "w" (lhs), "w" (rhs));
+    return acc;
+}
+XXH_FORCE_INLINE uint64x2_t
+XXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)
+{
+    /* This intrinsic works as expected */
+    return vmlal_high_u32(acc, lhs, rhs);
+}
+#else
+/* Portable intrinsic versions */
+XXH_FORCE_INLINE uint64x2_t
+XXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)
+{
+    return vmlal_u32(acc, vget_low_u32(lhs), vget_low_u32(rhs));
+}
+/*! @copydoc XXH_vmlal_low_u32
+ * Assume the compiler converts this to vmlal_high_u32 on aarch64 */
+XXH_FORCE_INLINE uint64x2_t
+XXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)
+{
+    return vmlal_u32(acc, vget_high_u32(lhs), vget_high_u32(rhs));
+}
+#endif
+
+/*!
+ * @ingroup tuning
+ * @brief Controls the NEON to scalar ratio for XXH3
  *
- * aarch64 requires a different approach.
+ * This can be set to 2, 4, 6, or 8.
  *
- * In order to make it easier to write a decent compiler for aarch64, many
- * quirks were removed, such as conditional execution.
+ * ARM Cortex CPUs are _very_ sensitive to how their pipelines are used.
  *
- * NEON was also affected by this.
+ * For example, the Cortex-A73 can dispatch 3 micro-ops per cycle, but only 2 of those
+ * can be NEON. If you are only using NEON instructions, you are only using 2/3 of the CPU
+ * bandwidth.
  *
- * aarch64 cannot access the high bits of a Q-form register, and writes to a
- * D-form register zero the high bits, similar to how writes to W-form scalar
- * registers (or DWORD registers on x86_64) work.
+ * This is even more noticeable on the more advanced cores like the Cortex-A76 which
+ * can dispatch 8 micro-ops per cycle, but still only 2 NEON micro-ops at once.
  *
- * The formerly free vget_high intrinsics now require a vext (with a few
- * exceptions)
+ * Therefore, to make the most out of the pipeline, it is beneficial to run 6 NEON lanes
+ * and 2 scalar lanes, which is chosen by default.
  *
- * Additionally, VZIP was replaced by ZIP1 and ZIP2, which are the equivalent
- * of PUNPCKL* and PUNPCKH* in SSE, respectively, in order to only modify one
- * operand.
+ * This does not apply to Apple processors or 32-bit processors, which run better with
+ * full NEON. These will default to 8. Additionally, size-optimized builds run 8 lanes.
  *
- * The equivalent of the VZIP.32 on the lower and upper halves would be this
- * mess:
+ * This change benefits CPUs with large micro-op buffers without negatively affecting
+ * most other CPUs:
  *
- *   ext     v2.4s, v0.4s, v0.4s, #2 // v2 = { v0[2], v0[3], v0[0], v0[1] }
- *   zip1    v1.2s, v0.2s, v2.2s     // v1 = { v0[0], v2[0] }
- *   zip2    v0.2s, v0.2s, v1.2s     // v0 = { v0[1], v2[1] }
+ *  | Chipset               | Dispatch type       | NEON only | 6:2 hybrid | Diff. |
+ *  |:----------------------|:--------------------|----------:|-----------:|------:|
+ *  | Snapdragon 730 (A76)  | 2 NEON/8 micro-ops  |  8.8 GB/s |  10.1 GB/s |  ~16% |
+ *  | Snapdragon 835 (A73)  | 2 NEON/3 micro-ops  |  5.1 GB/s |   5.3 GB/s |   ~5% |
+ *  | Marvell PXA1928 (A53) | In-order dual-issue |  1.9 GB/s |   1.9 GB/s |    0% |
+ *  | Apple M1              | 4 NEON/8 micro-ops  | 37.3 GB/s |  36.1 GB/s |  ~-3% |
  *
- * Instead, we use a literal downcast, vmovn_u64 (XTN), and vshrn_n_u64 (SHRN):
+ * It also seems to fix some bad codegen on GCC, making it almost as fast as clang.
  *
- *   shrn    v1.2s, v0.2d, #32  // v1 = (uint32x2_t)(v0 >> 32);
- *   xtn     v0.2s, v0.2d       // v0 = (uint32x2_t)(v0 & 0xFFFFFFFF);
+ * When using WASM SIMD128, if this is 2 or 6, SIMDe will scalarize 2 of the lanes meaning
+ * it effectively becomes worse 4.
  *
- * This is available on ARMv7-A, but is less efficient than a single VZIP.32.
+ * @see XXH3_accumulate_512_neon()
  */
-
-/*!
- * Function-like macro:
- * void XXH_SPLIT_IN_PLACE(uint64x2_t &in, uint32x2_t &outLo, uint32x2_t &outHi)
- * {
- *     outLo = (uint32x2_t)(in & 0xFFFFFFFF);
- *     outHi = (uint32x2_t)(in >> 32);
- *     in = UNDEFINED;
- * }
- */
-# if !defined(XXH_NO_VZIP_HACK) /* define to disable */ \
-   && defined(__GNUC__) \
-   && !defined(__aarch64__) && !defined(__arm64__) && !defined(_M_ARM64)
-#  define XXH_SPLIT_IN_PLACE(in, outLo, outHi)                                              \
-    do {                                                                                    \
-      /* Undocumented GCC/Clang operand modifier: %e0 = lower D half, %f0 = upper D half */ \
-      /* https://github.com/gcc-mirror/gcc/blob/38cf91e5/gcc/config/arm/arm.c#L22486 */     \
-      /* https://github.com/llvm-mirror/llvm/blob/2c4ca683/lib/Target/ARM/ARMAsmPrinter.cpp#L399 */ \
-      __asm__("vzip.32  %e0, %f0" : "+w" (in));                                             \
-      (outLo) = vget_low_u32 (vreinterpretq_u32_u64(in));                                   \
-      (outHi) = vget_high_u32(vreinterpretq_u32_u64(in));                                   \
-   } while (0)
-# else
-#  define XXH_SPLIT_IN_PLACE(in, outLo, outHi)                                            \
-    do {                                                                                  \
-      (outLo) = vmovn_u64    (in);                                                        \
-      (outHi) = vshrn_n_u64  ((in), 32);                                                  \
-    } while (0)
+# ifndef XXH3_NEON_LANES
+#  if (defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64) || defined(_M_ARM64EC)) \
+   && !defined(__APPLE__) && XXH_SIZE_OPT <= 0
+#   define XXH3_NEON_LANES 6
+#  else
+#   define XXH3_NEON_LANES XXH_ACC_NB
+#  endif
 # endif
 #endif  /* XXH_VECTOR == XXH_NEON */
 
@@ -3048,27 +3819,42 @@ enum XXH_VECTOR_TYPE /* fake enum */ {
  * inconsistent intrinsics, spotty coverage, and multiple endiannesses.
  */
 #if XXH_VECTOR == XXH_VSX
+/* Annoyingly, these headers _may_ define three macros: `bool`, `vector`,
+ * and `pixel`. This is a problem for obvious reasons.
+ *
+ * These keywords are unnecessary; the spec literally says they are
+ * equivalent to `__bool`, `__vector`, and `__pixel` and may be undef'd
+ * after including the header.
+ *
+ * We use pragma push_macro/pop_macro to keep the namespace clean. */
+#  pragma push_macro("bool")
+#  pragma push_macro("vector")
+#  pragma push_macro("pixel")
+/* silence potential macro redefined warnings */
+#  undef bool
+#  undef vector
+#  undef pixel
+
 #  if defined(__s390x__)
 #    include <s390intrin.h>
 #  else
-/* gcc's altivec.h can have the unwanted consequence to unconditionally
- * #define bool, vector, and pixel keywords,
- * with bad consequences for programs already using these keywords for other purposes.
- * The paragraph defining these macros is skipped when __APPLE_ALTIVEC__ is defined.
- * __APPLE_ALTIVEC__ is _generally_ defined automatically by the compiler,
- * but it seems that, in some cases, it isn't.
- * Force the build macro to be defined, so that keywords are not altered.
- */
-#    if defined(__GNUC__) && !defined(__APPLE_ALTIVEC__)
-#      define __APPLE_ALTIVEC__
-#    endif
 #    include <altivec.h>
 #  endif
 
+/* Restore the original macro values, if applicable. */
+#  pragma pop_macro("pixel")
+#  pragma pop_macro("vector")
+#  pragma pop_macro("bool")
+
 typedef __vector unsigned long long xxh_u64x2;
 typedef __vector unsigned char xxh_u8x16;
 typedef __vector unsigned xxh_u32x4;
 
+/*
+ * UGLY HACK: Similar to aarch64 macOS GCC, s390x GCC has the same aliasing issue.
+ */
+typedef xxh_u64x2 xxh_aliasing_u64x2 XXH_ALIASING;
+
 # ifndef XXH_VSX_BE
 #  if defined(__BIG_ENDIAN__) \
   || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
@@ -3120,8 +3906,9 @@ XXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)
  /* s390x is always big endian, no issue on this platform */
 #  define XXH_vec_mulo vec_mulo
 #  define XXH_vec_mule vec_mule
-# elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw)
+# elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw) && !defined(__ibmxl__)
 /* Clang has a better way to control this, we can just use the builtin which doesn't swap. */
+ /* The IBM XL Compiler (which defined __clang__) only implements the vec_* operations */
 #  define XXH_vec_mulo __builtin_altivec_vmulouw
 #  define XXH_vec_mule __builtin_altivec_vmuleuw
 # else
@@ -3142,13 +3929,28 @@ XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)
 # endif /* XXH_vec_mulo, XXH_vec_mule */
 #endif /* XXH_VECTOR == XXH_VSX */
 
+#if XXH_VECTOR == XXH_SVE
+#define ACCRND(acc, offset) \
+do { \
+    svuint64_t input_vec = svld1_u64(mask, xinput + offset);         \
+    svuint64_t secret_vec = svld1_u64(mask, xsecret + offset);       \
+    svuint64_t mixed = sveor_u64_x(mask, secret_vec, input_vec);     \
+    svuint64_t swapped = svtbl_u64(input_vec, kSwap);                \
+    svuint64_t mixed_lo = svextw_u64_x(mask, mixed);                 \
+    svuint64_t mixed_hi = svlsr_n_u64_x(mask, mixed, 32);            \
+    svuint64_t mul = svmad_u64_x(mask, mixed_lo, mixed_hi, swapped); \
+    acc = svadd_u64_x(mask, acc, mul);                               \
+} while (0)
+#endif /* XXH_VECTOR == XXH_SVE */
 
 /* prefetch
  * can be disabled, by declaring XXH_NO_PREFETCH build macro */
 #if defined(XXH_NO_PREFETCH)
 #  define XXH_PREFETCH(ptr)  (void)(ptr)  /* disabled */
 #else
-#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))  /* _mm_prefetch() not defined outside of x86/x64 */
+#  if XXH_SIZE_OPT >= 1
+#    define XXH_PREFETCH(ptr) (void)(ptr)
+#  elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))  /* _mm_prefetch() not defined outside of x86/x64 */
 #    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
 #    define XXH_PREFETCH(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
 #  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
@@ -3185,6 +3987,8 @@ XXH_ALIGN(64) static const xxh_u8 XXH3_kSecret[XXH_SECRET_DEFAULT_SIZE] = {
     0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
 };
 
+static const xxh_u64 PRIME_MX1 = 0x165667919E3779F9ULL;  /*!< 0b0001011001010110011001111001000110011110001101110111100111111001 */
+static const xxh_u64 PRIME_MX2 = 0x9FB21C651E98DF25ULL;  /*!< 0b1001111110110010000111000110010100011110100110001101111100100101 */
 
 #ifdef XXH_OLD_NAMES
 #  define kSecret XXH3_kSecret
@@ -3213,7 +4017,6 @@ XXH_mult32to64(xxh_u64 x, xxh_u64 y)
    return (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF);
 }
 #elif defined(_MSC_VER) && defined(_M_IX86)
-#    include <intrin.h>
 #    define XXH_mult32to64(x, y) __emulu((unsigned)(x), (unsigned)(y))
 #else
 /*
@@ -3253,7 +4056,7 @@ XXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)
      * In that case it is best to use the portable one.
      * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677
      */
-#if defined(__GNUC__) && !defined(__wasm__) \
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(__wasm__) \
     && defined(__SIZEOF_INT128__) \
     || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
 
@@ -3270,7 +4073,7 @@ XXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)
      *
      * This compiles to single operand MUL on x64.
      */
-#elif defined(_M_X64) || defined(_M_IA64)
+#elif (defined(_M_X64) || defined(_M_IA64)) && !defined(_M_ARM64EC)
 
 #ifndef _MSC_VER
 #   pragma intrinsic(_umul128)
@@ -3287,7 +4090,7 @@ XXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)
      *
      * This compiles to the same MUL + UMULH as GCC/Clang's __uint128_t method.
      */
-#elif defined(_M_ARM64)
+#elif defined(_M_ARM64) || defined(_M_ARM64EC)
 
 #ifndef _MSC_VER
 #   pragma intrinsic(__umulh)
@@ -3377,7 +4180,7 @@ XXH3_mul128_fold64(xxh_u64 lhs, xxh_u64 rhs)
 }
 
 /*! Seems to produce slightly better code on GCC for some reason. */
-XXH_FORCE_INLINE xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
+XXH_FORCE_INLINE XXH_CONSTF xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
 {
     XXH_ASSERT(0 <= shift && shift < 64);
     return v64 ^ (v64 >> shift);
@@ -3390,7 +4193,7 @@ XXH_FORCE_INLINE xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
 static XXH64_hash_t XXH3_avalanche(xxh_u64 h64)
 {
     h64 = XXH_xorshift64(h64, 37);
-    h64 *= 0x165667919E3779F9ULL;
+    h64 *= PRIME_MX1;
     h64 = XXH_xorshift64(h64, 32);
     return h64;
 }
@@ -3404,9 +4207,9 @@ static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
 {
     /* this mix is inspired by Pelle Evensen's rrmxmx */
     h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);
-    h64 *= 0x9FB21C651E98DF25ULL;
+    h64 *= PRIME_MX2;
     h64 ^= (h64 >> 35) + len ;
-    h64 *= 0x9FB21C651E98DF25ULL;
+    h64 *= PRIME_MX2;
     return XXH_xorshift64(h64, 28);
 }
 
@@ -3444,7 +4247,7 @@ static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
  *
  * This adds an extra layer of strength for custom secrets.
  */
-XXH_FORCE_INLINE XXH64_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(input != NULL);
@@ -3466,7 +4269,7 @@ XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_h
     }
 }
 
-XXH_FORCE_INLINE XXH64_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(input != NULL);
@@ -3482,7 +4285,7 @@ XXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_h
     }
 }
 
-XXH_FORCE_INLINE XXH64_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(input != NULL);
@@ -3499,7 +4302,7 @@ XXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_
     }
 }
 
-XXH_FORCE_INLINE XXH64_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(len <= 16);
@@ -3569,7 +4372,7 @@ XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
 }
 
 /* For mid range keys, XXH3 uses a Mum-hash variant. */
-XXH_FORCE_INLINE XXH64_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                      XXH64_hash_t seed)
@@ -3578,6 +4381,14 @@ XXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
     XXH_ASSERT(16 < len && len <= 128);
 
     {   xxh_u64 acc = len * XXH_PRIME64_1;
+#if XXH_SIZE_OPT >= 1
+        /* Smaller and cleaner, but slightly slower. */
+        unsigned int i = (unsigned int)(len - 1) / 32;
+        do {
+            acc += XXH3_mix16B(input+16 * i, secret+32*i, seed);
+            acc += XXH3_mix16B(input+len-16*(i+1), secret+32*i+16, seed);
+        } while (i-- != 0);
+#else
         if (len > 32) {
             if (len > 64) {
                 if (len > 96) {
@@ -3592,14 +4403,14 @@ XXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
         }
         acc += XXH3_mix16B(input+0, secret+0, seed);
         acc += XXH3_mix16B(input+len-16, secret+16, seed);
-
+#endif
         return XXH3_avalanche(acc);
     }
 }
 
 #define XXH3_MIDSIZE_MAX 240
 
-XXH_NO_INLINE XXH64_hash_t
+XXH_NO_INLINE XXH_PUREF XXH64_hash_t
 XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
                       const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                       XXH64_hash_t seed)
@@ -3611,13 +4422,17 @@ XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
     #define XXH3_MIDSIZE_LASTOFFSET  17
 
     {   xxh_u64 acc = len * XXH_PRIME64_1;
-        int const nbRounds = (int)len / 16;
-        int i;
+        xxh_u64 acc_end;
+        unsigned int const nbRounds = (unsigned int)len / 16;
+        unsigned int i;
+        XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
         for (i=0; i<8; i++) {
             acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed);
         }
-        acc = XXH3_avalanche(acc);
+        /* last bytes */
+        acc_end = XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);
         XXH_ASSERT(nbRounds >= 8);
+        acc = XXH3_avalanche(acc);
 #if defined(__clang__)                                /* Clang */ \
     && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \
     && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */
@@ -3644,11 +4459,13 @@ XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
         #pragma clang loop vectorize(disable)
 #endif
         for (i=8 ; i < nbRounds; i++) {
-            acc += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);
+            /*
+             * Prevents clang for unrolling the acc loop and interleaving with this one.
+             */
+            XXH_COMPILER_GUARD(acc);
+            acc_end += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);
         }
-        /* last bytes */
-        acc += XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);
-        return XXH3_avalanche(acc);
+        return XXH3_avalanche(acc + acc_end);
     }
 }
 
@@ -3664,6 +4481,47 @@ XXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,
 #  define ACC_NB XXH_ACC_NB
 #endif
 
+#ifndef XXH_PREFETCH_DIST
+#  ifdef __clang__
+#    define XXH_PREFETCH_DIST 320
+#  else
+#    if (XXH_VECTOR == XXH_AVX512)
+#      define XXH_PREFETCH_DIST 512
+#    else
+#      define XXH_PREFETCH_DIST 384
+#    endif
+#  endif  /* __clang__ */
+#endif  /* XXH_PREFETCH_DIST */
+
+/*
+ * These macros are to generate an XXH3_accumulate() function.
+ * The two arguments select the name suffix and target attribute.
+ *
+ * The name of this symbol is XXH3_accumulate_<name>() and it calls
+ * XXH3_accumulate_512_<name>().
+ *
+ * It may be useful to hand implement this function if the compiler fails to
+ * optimize the inline function.
+ */
+#define XXH3_ACCUMULATE_TEMPLATE(name)                      \
+void                                                        \
+XXH3_accumulate_##name(xxh_u64* XXH_RESTRICT acc,           \
+                       const xxh_u8* XXH_RESTRICT input,    \
+                       const xxh_u8* XXH_RESTRICT secret,   \
+                       size_t nbStripes)                    \
+{                                                           \
+    size_t n;                                               \
+    for (n = 0; n < nbStripes; n++ ) {                      \
+        const xxh_u8* const in = input + n*XXH_STRIPE_LEN;  \
+        XXH_PREFETCH(in + XXH_PREFETCH_DIST);               \
+        XXH3_accumulate_512_##name(                         \
+                 acc,                                       \
+                 in,                                        \
+                 secret + n*XXH_SECRET_CONSUME_RATE);       \
+    }                                                       \
+}
+
+
 XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)
 {
     if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64);
@@ -3684,6 +4542,7 @@ XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)
     typedef long long xxh_i64;
 #endif
 
+
 /*
  * XXH3_accumulate_512 is the tightest loop for long inputs, and it is the most optimized.
  *
@@ -3731,7 +4590,7 @@ XXH3_accumulate_512_avx512(void* XXH_RESTRICT acc,
         /* data_key    = data_vec ^ key_vec; */
         __m512i const data_key    = _mm512_xor_si512     (data_vec, key_vec);
         /* data_key_lo = data_key >> 32; */
-        __m512i const data_key_lo = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1));
+        __m512i const data_key_lo = _mm512_srli_epi64 (data_key, 32);
         /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
         __m512i const product     = _mm512_mul_epu32     (data_key, data_key_lo);
         /* xacc[0] += swap(data_vec); */
@@ -3741,6 +4600,7 @@ XXH3_accumulate_512_avx512(void* XXH_RESTRICT acc,
         *xacc = _mm512_add_epi64(product, sum);
     }
 }
+XXH_FORCE_INLINE XXH_TARGET_AVX512 XXH3_ACCUMULATE_TEMPLATE(avx512)
 
 /*
  * XXH3_scrambleAcc: Scrambles the accumulators to improve mixing.
@@ -3774,13 +4634,12 @@ XXH3_scrambleAcc_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
         /* xacc[0] ^= (xacc[0] >> 47) */
         __m512i const acc_vec     = *xacc;
         __m512i const shifted     = _mm512_srli_epi64    (acc_vec, 47);
-        __m512i const data_vec    = _mm512_xor_si512     (acc_vec, shifted);
         /* xacc[0] ^= secret; */
         __m512i const key_vec     = _mm512_loadu_si512   (secret);
-        __m512i const data_key    = _mm512_xor_si512     (data_vec, key_vec);
+        __m512i const data_key    = _mm512_ternarylogic_epi32(key_vec, acc_vec, shifted, 0x96 /* key_vec ^ acc_vec ^ shifted */);
 
         /* xacc[0] *= XXH_PRIME32_1; */
-        __m512i const data_key_hi = _mm512_shuffle_epi32 (data_key, (_MM_PERM_ENUM)_MM_SHUFFLE(0, 3, 0, 1));
+        __m512i const data_key_hi = _mm512_srli_epi64 (data_key, 32);
         __m512i const prod_lo     = _mm512_mul_epu32     (data_key, prime32);
         __m512i const prod_hi     = _mm512_mul_epu32     (data_key_hi, prime32);
         *xacc = _mm512_add_epi64(prod_lo, _mm512_slli_epi64(prod_hi, 32));
@@ -3795,7 +4654,8 @@ XXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
     XXH_ASSERT(((size_t)customSecret & 63) == 0);
     (void)(&XXH_writeLE64);
     {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m512i);
-        __m512i const seed = _mm512_mask_set1_epi64(_mm512_set1_epi64((xxh_i64)seed64), 0xAA, (xxh_i64)(0U - seed64));
+        __m512i const seed_pos = _mm512_set1_epi64((xxh_i64)seed64);
+        __m512i const seed     = _mm512_mask_sub_epi64(seed_pos, 0xAA, _mm512_set1_epi8(0), seed_pos);
 
         const __m512i* const src  = (const __m512i*) ((const void*) XXH3_kSecret);
               __m512i* const dest = (      __m512i*) customSecret;
@@ -3803,14 +4663,7 @@ XXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
         XXH_ASSERT(((size_t)src & 63) == 0); /* control alignment */
         XXH_ASSERT(((size_t)dest & 63) == 0);
         for (i=0; i < nbRounds; ++i) {
-            /* GCC has a bug, _mm512_stream_load_si512 accepts 'void*', not 'void const*',
-             * this will warn "discards 'const' qualifier". */
-            union {
-                const __m512i* cp;
-                void* p;
-            } remote_const_void;
-            remote_const_void.cp = src + i;
-            dest[i] = _mm512_add_epi64(_mm512_stream_load_si512(remote_const_void.p), seed);
+            dest[i] = _mm512_add_epi64(_mm512_load_si512(src + i), seed);
     }   }
 }
 
@@ -3846,7 +4699,7 @@ XXH3_accumulate_512_avx2( void* XXH_RESTRICT acc,
             /* data_key    = data_vec ^ key_vec; */
             __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);
             /* data_key_lo = data_key >> 32; */
-            __m256i const data_key_lo = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            __m256i const data_key_lo = _mm256_srli_epi64 (data_key, 32);
             /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */
             __m256i const product     = _mm256_mul_epu32     (data_key, data_key_lo);
             /* xacc[i] += swap(data_vec); */
@@ -3856,6 +4709,7 @@ XXH3_accumulate_512_avx2( void* XXH_RESTRICT acc,
             xacc[i] = _mm256_add_epi64(product, sum);
     }   }
 }
+XXH_FORCE_INLINE XXH_TARGET_AVX2 XXH3_ACCUMULATE_TEMPLATE(avx2)
 
 XXH_FORCE_INLINE XXH_TARGET_AVX2 void
 XXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
@@ -3878,7 +4732,7 @@ XXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
             __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);
 
             /* xacc[i] *= XXH_PRIME32_1; */
-            __m256i const data_key_hi = _mm256_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));
+            __m256i const data_key_hi = _mm256_srli_epi64 (data_key, 32);
             __m256i const prod_lo     = _mm256_mul_epu32     (data_key, prime32);
             __m256i const prod_hi     = _mm256_mul_epu32     (data_key_hi, prime32);
             xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32));
@@ -3910,12 +4764,12 @@ XXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_initCustomSecret_avx2(void* XXH_RESTR
         XXH_ASSERT(((size_t)dest & 31) == 0);
 
         /* GCC -O2 need unroll loop manually */
-        dest[0] = _mm256_add_epi64(_mm256_stream_load_si256(src+0), seed);
-        dest[1] = _mm256_add_epi64(_mm256_stream_load_si256(src+1), seed);
-        dest[2] = _mm256_add_epi64(_mm256_stream_load_si256(src+2), seed);
-        dest[3] = _mm256_add_epi64(_mm256_stream_load_si256(src+3), seed);
-        dest[4] = _mm256_add_epi64(_mm256_stream_load_si256(src+4), seed);
-        dest[5] = _mm256_add_epi64(_mm256_stream_load_si256(src+5), seed);
+        dest[0] = _mm256_add_epi64(_mm256_load_si256(src+0), seed);
+        dest[1] = _mm256_add_epi64(_mm256_load_si256(src+1), seed);
+        dest[2] = _mm256_add_epi64(_mm256_load_si256(src+2), seed);
+        dest[3] = _mm256_add_epi64(_mm256_load_si256(src+3), seed);
+        dest[4] = _mm256_add_epi64(_mm256_load_si256(src+4), seed);
+        dest[5] = _mm256_add_epi64(_mm256_load_si256(src+5), seed);
     }
 }
 
@@ -3962,6 +4816,7 @@ XXH3_accumulate_512_sse2( void* XXH_RESTRICT acc,
             xacc[i] = _mm_add_epi64(product, sum);
     }   }
 }
+XXH_FORCE_INLINE XXH_TARGET_SSE2 XXH3_ACCUMULATE_TEMPLATE(sse2)
 
 XXH_FORCE_INLINE XXH_TARGET_SSE2 void
 XXH3_scrambleAcc_sse2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
@@ -4029,96 +4884,222 @@ XXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTR
 
 #if (XXH_VECTOR == XXH_NEON)
 
+/* forward declarations for the scalar routines */
+XXH_FORCE_INLINE void
+XXH3_scalarRound(void* XXH_RESTRICT acc, void const* XXH_RESTRICT input,
+                 void const* XXH_RESTRICT secret, size_t lane);
+
+XXH_FORCE_INLINE void
+XXH3_scalarScrambleRound(void* XXH_RESTRICT acc,
+                         void const* XXH_RESTRICT secret, size_t lane);
+
+/*!
+ * @internal
+ * @brief The bulk processing loop for NEON and WASM SIMD128.
+ *
+ * The NEON code path is actually partially scalar when running on AArch64. This
+ * is to optimize the pipelining and can have up to 15% speedup depending on the
+ * CPU, and it also mitigates some GCC codegen issues.
+ *
+ * @see XXH3_NEON_LANES for configuring this and details about this optimization.
+ *
+ * NEON's 32-bit to 64-bit long multiply takes a half vector of 32-bit
+ * integers instead of the other platforms which mask full 64-bit vectors,
+ * so the setup is more complicated than just shifting right.
+ *
+ * Additionally, there is an optimization for 4 lanes at once noted below.
+ *
+ * Since, as stated, the most optimal amount of lanes for Cortexes is 6,
+ * there needs to be *three* versions of the accumulate operation used
+ * for the remaining 2 lanes.
+ *
+ * WASM's SIMD128 uses SIMDe's arm_neon.h polyfill because the intrinsics overlap
+ * nearly perfectly.
+ */
+
 XXH_FORCE_INLINE void
 XXH3_accumulate_512_neon( void* XXH_RESTRICT acc,
                     const void* XXH_RESTRICT input,
                     const void* XXH_RESTRICT secret)
 {
     XXH_ASSERT((((size_t)acc) & 15) == 0);
-    {
-        uint64x2_t* const xacc = (uint64x2_t *) acc;
+    XXH_STATIC_ASSERT(XXH3_NEON_LANES > 0 && XXH3_NEON_LANES <= XXH_ACC_NB && XXH3_NEON_LANES % 2 == 0);
+    {   /* GCC for darwin arm64 does not like aliasing here */
+        xxh_aliasing_uint64x2_t* const xacc = (xxh_aliasing_uint64x2_t*) acc;
         /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */
-        uint8_t const* const xinput = (const uint8_t *) input;
-        uint8_t const* const xsecret  = (const uint8_t *) secret;
+        uint8_t const* xinput = (const uint8_t *) input;
+        uint8_t const* xsecret  = (const uint8_t *) secret;
 
         size_t i;
-        for (i=0; i < XXH_STRIPE_LEN / sizeof(uint64x2_t); i++) {
+#ifdef __wasm_simd128__
+        /*
+         * On WASM SIMD128, Clang emits direct address loads when XXH3_kSecret
+         * is constant propagated, which results in it converting it to this
+         * inside the loop:
+         *
+         *    a = v128.load(XXH3_kSecret +  0 + $secret_offset, offset = 0)
+         *    b = v128.load(XXH3_kSecret + 16 + $secret_offset, offset = 0)
+         *    ...
+         *
+         * This requires a full 32-bit address immediate (and therefore a 6 byte
+         * instruction) as well as an add for each offset.
+         *
+         * Putting an asm guard prevents it from folding (at the cost of losing
+         * the alignment hint), and uses the free offset in `v128.load` instead
+         * of adding secret_offset each time which overall reduces code size by
+         * about a kilobyte and improves performance.
+         */
+        XXH_COMPILER_GUARD(xsecret);
+#endif
+        /* Scalar lanes use the normal scalarRound routine */
+        for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {
+            XXH3_scalarRound(acc, input, secret, i);
+        }
+        i = 0;
+        /* 4 NEON lanes at a time. */
+        for (; i+1 < XXH3_NEON_LANES / 2; i+=2) {
             /* data_vec = xinput[i]; */
-            uint8x16_t data_vec    = vld1q_u8(xinput  + (i * 16));
+            uint64x2_t data_vec_1 = XXH_vld1q_u64(xinput  + (i * 16));
+            uint64x2_t data_vec_2 = XXH_vld1q_u64(xinput  + ((i+1) * 16));
             /* key_vec  = xsecret[i];  */
-            uint8x16_t key_vec     = vld1q_u8(xsecret + (i * 16));
-            uint64x2_t data_key;
-            uint32x2_t data_key_lo, data_key_hi;
-            /* xacc[i] += swap(data_vec); */
-            uint64x2_t const data64  = vreinterpretq_u64_u8(data_vec);
-            uint64x2_t const swapped = vextq_u64(data64, data64, 1);
-            xacc[i] = vaddq_u64 (xacc[i], swapped);
+            uint64x2_t key_vec_1  = XXH_vld1q_u64(xsecret + (i * 16));
+            uint64x2_t key_vec_2  = XXH_vld1q_u64(xsecret + ((i+1) * 16));
+            /* data_swap = swap(data_vec) */
+            uint64x2_t data_swap_1 = vextq_u64(data_vec_1, data_vec_1, 1);
+            uint64x2_t data_swap_2 = vextq_u64(data_vec_2, data_vec_2, 1);
             /* data_key = data_vec ^ key_vec; */
-            data_key = vreinterpretq_u64_u8(veorq_u8(data_vec, key_vec));
-            /* data_key_lo = (uint32x2_t) (data_key & 0xFFFFFFFF);
-             * data_key_hi = (uint32x2_t) (data_key >> 32);
-             * data_key = UNDEFINED; */
-            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
-            /* xacc[i] += (uint64x2_t) data_key_lo * (uint64x2_t) data_key_hi; */
-            xacc[i] = vmlal_u32 (xacc[i], data_key_lo, data_key_hi);
+            uint64x2_t data_key_1 = veorq_u64(data_vec_1, key_vec_1);
+            uint64x2_t data_key_2 = veorq_u64(data_vec_2, key_vec_2);
 
+            /*
+             * If we reinterpret the 64x2 vectors as 32x4 vectors, we can use a
+             * de-interleave operation for 4 lanes in 1 step with `vuzpq_u32` to
+             * get one vector with the low 32 bits of each lane, and one vector
+             * with the high 32 bits of each lane.
+             *
+             * The intrinsic returns a double vector because the original ARMv7-a
+             * instruction modified both arguments in place. AArch64 and SIMD128 emit
+             * two instructions from this intrinsic.
+             *
+             *  [ dk11L | dk11H | dk12L | dk12H ] -> [ dk11L | dk12L | dk21L | dk22L ]
+             *  [ dk21L | dk21H | dk22L | dk22H ] -> [ dk11H | dk12H | dk21H | dk22H ]
+             */
+            uint32x4x2_t unzipped = vuzpq_u32(
+                vreinterpretq_u32_u64(data_key_1),
+                vreinterpretq_u32_u64(data_key_2)
+            );
+            /* data_key_lo = data_key & 0xFFFFFFFF */
+            uint32x4_t data_key_lo = unzipped.val[0];
+            /* data_key_hi = data_key >> 32 */
+            uint32x4_t data_key_hi = unzipped.val[1];
+            /*
+             * Then, we can split the vectors horizontally and multiply which, as for most
+             * widening intrinsics, have a variant that works on both high half vectors
+             * for free on AArch64. A similar instruction is available on SIMD128.
+             *
+             * sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi
+             */
+            uint64x2_t sum_1 = XXH_vmlal_low_u32(data_swap_1, data_key_lo, data_key_hi);
+            uint64x2_t sum_2 = XXH_vmlal_high_u32(data_swap_2, data_key_lo, data_key_hi);
+            /*
+             * Clang reorders
+             *    a += b * c;     // umlal   swap.2d, dkl.2s, dkh.2s
+             *    c += a;         // add     acc.2d, acc.2d, swap.2d
+             * to
+             *    c += a;         // add     acc.2d, acc.2d, swap.2d
+             *    c += b * c;     // umlal   acc.2d, dkl.2s, dkh.2s
+             *
+             * While it would make sense in theory since the addition is faster,
+             * for reasons likely related to umlal being limited to certain NEON
+             * pipelines, this is worse. A compiler guard fixes this.
+             */
+            XXH_COMPILER_GUARD_CLANG_NEON(sum_1);
+            XXH_COMPILER_GUARD_CLANG_NEON(sum_2);
+            /* xacc[i] = acc_vec + sum; */
+            xacc[i]   = vaddq_u64(xacc[i], sum_1);
+            xacc[i+1] = vaddq_u64(xacc[i+1], sum_2);
+        }
+        /* Operate on the remaining NEON lanes 2 at a time. */
+        for (; i < XXH3_NEON_LANES / 2; i++) {
+            /* data_vec = xinput[i]; */
+            uint64x2_t data_vec = XXH_vld1q_u64(xinput  + (i * 16));
+            /* key_vec  = xsecret[i];  */
+            uint64x2_t key_vec  = XXH_vld1q_u64(xsecret + (i * 16));
+            /* acc_vec_2 = swap(data_vec) */
+            uint64x2_t data_swap = vextq_u64(data_vec, data_vec, 1);
+            /* data_key = data_vec ^ key_vec; */
+            uint64x2_t data_key = veorq_u64(data_vec, key_vec);
+            /* For two lanes, just use VMOVN and VSHRN. */
+            /* data_key_lo = data_key & 0xFFFFFFFF; */
+            uint32x2_t data_key_lo = vmovn_u64(data_key);
+            /* data_key_hi = data_key >> 32; */
+            uint32x2_t data_key_hi = vshrn_n_u64(data_key, 32);
+            /* sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi; */
+            uint64x2_t sum = vmlal_u32(data_swap, data_key_lo, data_key_hi);
+            /* Same Clang workaround as before */
+            XXH_COMPILER_GUARD_CLANG_NEON(sum);
+            /* xacc[i] = acc_vec + sum; */
+            xacc[i] = vaddq_u64 (xacc[i], sum);
         }
     }
 }
+XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(neon)
 
 XXH_FORCE_INLINE void
 XXH3_scrambleAcc_neon(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
 {
     XXH_ASSERT((((size_t)acc) & 15) == 0);
 
-    {   uint64x2_t* xacc       = (uint64x2_t*) acc;
+    {   xxh_aliasing_uint64x2_t* xacc       = (xxh_aliasing_uint64x2_t*) acc;
         uint8_t const* xsecret = (uint8_t const*) secret;
-        uint32x2_t prime       = vdup_n_u32 (XXH_PRIME32_1);
 
         size_t i;
-        for (i=0; i < XXH_STRIPE_LEN/sizeof(uint64x2_t); i++) {
+        /* WASM uses operator overloads and doesn't need these. */
+#ifndef __wasm_simd128__
+        /* { prime32_1, prime32_1 } */
+        uint32x2_t const kPrimeLo = vdup_n_u32(XXH_PRIME32_1);
+        /* { 0, prime32_1, 0, prime32_1 } */
+        uint32x4_t const kPrimeHi = vreinterpretq_u32_u64(vdupq_n_u64((xxh_u64)XXH_PRIME32_1 << 32));
+#endif
+
+        /* AArch64 uses both scalar and neon at the same time */
+        for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {
+            XXH3_scalarScrambleRound(acc, secret, i);
+        }
+        for (i=0; i < XXH3_NEON_LANES / 2; i++) {
             /* xacc[i] ^= (xacc[i] >> 47); */
             uint64x2_t acc_vec  = xacc[i];
-            uint64x2_t shifted  = vshrq_n_u64 (acc_vec, 47);
-            uint64x2_t data_vec = veorq_u64   (acc_vec, shifted);
+            uint64x2_t shifted  = vshrq_n_u64(acc_vec, 47);
+            uint64x2_t data_vec = veorq_u64(acc_vec, shifted);
 
             /* xacc[i] ^= xsecret[i]; */
-            uint8x16_t key_vec  = vld1q_u8    (xsecret + (i * 16));
-            uint64x2_t data_key = veorq_u64   (data_vec, vreinterpretq_u64_u8(key_vec));
-
+            uint64x2_t key_vec  = XXH_vld1q_u64(xsecret + (i * 16));
+            uint64x2_t data_key = veorq_u64(data_vec, key_vec);
             /* xacc[i] *= XXH_PRIME32_1 */
-            uint32x2_t data_key_lo, data_key_hi;
-            /* data_key_lo = (uint32x2_t) (xacc[i] & 0xFFFFFFFF);
-             * data_key_hi = (uint32x2_t) (xacc[i] >> 32);
-             * xacc[i] = UNDEFINED; */
-            XXH_SPLIT_IN_PLACE(data_key, data_key_lo, data_key_hi);
-            {   /*
-                 * prod_hi = (data_key >> 32) * XXH_PRIME32_1;
-                 *
-                 * Avoid vmul_u32 + vshll_n_u32 since Clang 6 and 7 will
-                 * incorrectly "optimize" this:
-                 *   tmp     = vmul_u32(vmovn_u64(a), vmovn_u64(b));
-                 *   shifted = vshll_n_u32(tmp, 32);
-                 * to this:
-                 *   tmp     = "vmulq_u64"(a, b); // no such thing!
-                 *   shifted = vshlq_n_u64(tmp, 32);
-                 *
-                 * However, unlike SSE, Clang lacks a 64-bit multiply routine
-                 * for NEON, and it scalarizes two 64-bit multiplies instead.
-                 *
-                 * vmull_u32 has the same timing as vmul_u32, and it avoids
-                 * this bug completely.
-                 * See https://bugs.llvm.org/show_bug.cgi?id=39967
-                 */
-                uint64x2_t prod_hi = vmull_u32 (data_key_hi, prime);
-                /* xacc[i] = prod_hi << 32; */
-                xacc[i] = vshlq_n_u64(prod_hi, 32);
-                /* xacc[i] += (prod_hi & 0xFFFFFFFF) * XXH_PRIME32_1; */
-                xacc[i] = vmlal_u32(xacc[i], data_key_lo, prime);
-            }
-    }   }
+#ifdef __wasm_simd128__
+            /* SIMD128 has multiply by u64x2, use it instead of expanding and scalarizing */
+            xacc[i] = data_key * XXH_PRIME32_1;
+#else
+            /*
+             * Expanded version with portable NEON intrinsics
+             *
+             *    lo(x) * lo(y) + (hi(x) * lo(y) << 32)
+             *
+             * prod_hi = hi(data_key) * lo(prime) << 32
+             *
+             * Since we only need 32 bits of this multiply a trick can be used, reinterpreting the vector
+             * as a uint32x4_t and multiplying by { 0, prime, 0, prime } to cancel out the unwanted bits
+             * and avoid the shift.
+             */
+            uint32x4_t prod_hi = vmulq_u32 (vreinterpretq_u32_u64(data_key), kPrimeHi);
+            /* Extract low bits for vmlal_u32  */
+            uint32x2_t data_key_lo = vmovn_u64(data_key);
+            /* xacc[i] = prod_hi + lo(data_key) * XXH_PRIME32_1; */
+            xacc[i] = vmlal_u32(vreinterpretq_u64_u32(prod_hi), data_key_lo, kPrimeLo);
+#endif
+        }
+    }
 }
-
 #endif
 
 #if (XXH_VECTOR == XXH_VSX)
@@ -4129,23 +5110,23 @@ XXH3_accumulate_512_vsx(  void* XXH_RESTRICT acc,
                     const void* XXH_RESTRICT secret)
 {
     /* presumed aligned */
-    unsigned long long* const xacc = (unsigned long long*) acc;
-    xxh_u64x2 const* const xinput   = (xxh_u64x2 const*) input;   /* no alignment restriction */
-    xxh_u64x2 const* const xsecret  = (xxh_u64x2 const*) secret;    /* no alignment restriction */
+    xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;
+    xxh_u8 const* const xinput   = (xxh_u8 const*) input;   /* no alignment restriction */
+    xxh_u8 const* const xsecret  = (xxh_u8 const*) secret;    /* no alignment restriction */
     xxh_u64x2 const v32 = { 32, 32 };
     size_t i;
     for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {
         /* data_vec = xinput[i]; */
-        xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + i);
+        xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + 16*i);
         /* key_vec = xsecret[i]; */
-        xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
+        xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + 16*i);
         xxh_u64x2 const data_key = data_vec ^ key_vec;
         /* shuffled = (data_key << 32) | (data_key >> 32); */
         xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32);
         /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */
         xxh_u64x2 const product  = XXH_vec_mulo((xxh_u32x4)data_key, shuffled);
         /* acc_vec = xacc[i]; */
-        xxh_u64x2 acc_vec        = vec_xl(0, xacc + 2 * i);
+        xxh_u64x2 acc_vec        = xacc[i];
         acc_vec += product;
 
         /* swap high and low halves */
@@ -4154,18 +5135,18 @@ XXH3_accumulate_512_vsx(  void* XXH_RESTRICT acc,
 #else
         acc_vec += vec_xxpermdi(data_vec, data_vec, 2);
 #endif
-        /* xacc[i] = acc_vec; */
-        vec_xst(acc_vec, 0, xacc + 2 * i);
+        xacc[i] = acc_vec;
     }
 }
+XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(vsx)
 
 XXH_FORCE_INLINE void
 XXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
 {
     XXH_ASSERT((((size_t)acc) & 15) == 0);
 
-    {         xxh_u64x2* const xacc    =       (xxh_u64x2*) acc;
-        const xxh_u64x2* const xsecret = (const xxh_u64x2*) secret;
+    {   xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;
+        const xxh_u8* const xsecret = (const xxh_u8*) secret;
         /* constants */
         xxh_u64x2 const v32  = { 32, 32 };
         xxh_u64x2 const v47 = { 47, 47 };
@@ -4177,7 +5158,7 @@ XXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
             xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47);
 
             /* xacc[i] ^= xsecret[i]; */
-            xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + i);
+            xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + 16*i);
             xxh_u64x2 const data_key = data_vec ^ key_vec;
 
             /* xacc[i] *= XXH_PRIME32_1 */
@@ -4191,40 +5172,233 @@ XXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
 
 #endif
 
+#if (XXH_VECTOR == XXH_SVE)
+
+XXH_FORCE_INLINE void
+XXH3_accumulate_512_sve( void* XXH_RESTRICT acc,
+                   const void* XXH_RESTRICT input,
+                   const void* XXH_RESTRICT secret)
+{
+    uint64_t *xacc = (uint64_t *)acc;
+    const uint64_t *xinput = (const uint64_t *)(const void *)input;
+    const uint64_t *xsecret = (const uint64_t *)(const void *)secret;
+    svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);
+    uint64_t element_count = svcntd();
+    if (element_count >= 8) {
+        svbool_t mask = svptrue_pat_b64(SV_VL8);
+        svuint64_t vacc = svld1_u64(mask, xacc);
+        ACCRND(vacc, 0);
+        svst1_u64(mask, xacc, vacc);
+    } else if (element_count == 2) {   /* sve128 */
+        svbool_t mask = svptrue_pat_b64(SV_VL2);
+        svuint64_t acc0 = svld1_u64(mask, xacc + 0);
+        svuint64_t acc1 = svld1_u64(mask, xacc + 2);
+        svuint64_t acc2 = svld1_u64(mask, xacc + 4);
+        svuint64_t acc3 = svld1_u64(mask, xacc + 6);
+        ACCRND(acc0, 0);
+        ACCRND(acc1, 2);
+        ACCRND(acc2, 4);
+        ACCRND(acc3, 6);
+        svst1_u64(mask, xacc + 0, acc0);
+        svst1_u64(mask, xacc + 2, acc1);
+        svst1_u64(mask, xacc + 4, acc2);
+        svst1_u64(mask, xacc + 6, acc3);
+    } else {
+        svbool_t mask = svptrue_pat_b64(SV_VL4);
+        svuint64_t acc0 = svld1_u64(mask, xacc + 0);
+        svuint64_t acc1 = svld1_u64(mask, xacc + 4);
+        ACCRND(acc0, 0);
+        ACCRND(acc1, 4);
+        svst1_u64(mask, xacc + 0, acc0);
+        svst1_u64(mask, xacc + 4, acc1);
+    }
+}
+
+XXH_FORCE_INLINE void
+XXH3_accumulate_sve(xxh_u64* XXH_RESTRICT acc,
+               const xxh_u8* XXH_RESTRICT input,
+               const xxh_u8* XXH_RESTRICT secret,
+               size_t nbStripes)
+{
+    if (nbStripes != 0) {
+        uint64_t *xacc = (uint64_t *)acc;
+        const uint64_t *xinput = (const uint64_t *)(const void *)input;
+        const uint64_t *xsecret = (const uint64_t *)(const void *)secret;
+        svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);
+        uint64_t element_count = svcntd();
+        if (element_count >= 8) {
+            svbool_t mask = svptrue_pat_b64(SV_VL8);
+            svuint64_t vacc = svld1_u64(mask, xacc + 0);
+            do {
+                /* svprfd(svbool_t, void *, enum svfprop); */
+                svprfd(mask, xinput + 128, SV_PLDL1STRM);
+                ACCRND(vacc, 0);
+                xinput += 8;
+                xsecret += 1;
+                nbStripes--;
+           } while (nbStripes != 0);
+
+           svst1_u64(mask, xacc + 0, vacc);
+        } else if (element_count == 2) { /* sve128 */
+            svbool_t mask = svptrue_pat_b64(SV_VL2);
+            svuint64_t acc0 = svld1_u64(mask, xacc + 0);
+            svuint64_t acc1 = svld1_u64(mask, xacc + 2);
+            svuint64_t acc2 = svld1_u64(mask, xacc + 4);
+            svuint64_t acc3 = svld1_u64(mask, xacc + 6);
+            do {
+                svprfd(mask, xinput + 128, SV_PLDL1STRM);
+                ACCRND(acc0, 0);
+                ACCRND(acc1, 2);
+                ACCRND(acc2, 4);
+                ACCRND(acc3, 6);
+                xinput += 8;
+                xsecret += 1;
+                nbStripes--;
+           } while (nbStripes != 0);
+
+           svst1_u64(mask, xacc + 0, acc0);
+           svst1_u64(mask, xacc + 2, acc1);
+           svst1_u64(mask, xacc + 4, acc2);
+           svst1_u64(mask, xacc + 6, acc3);
+        } else {
+            svbool_t mask = svptrue_pat_b64(SV_VL4);
+            svuint64_t acc0 = svld1_u64(mask, xacc + 0);
+            svuint64_t acc1 = svld1_u64(mask, xacc + 4);
+            do {
+                svprfd(mask, xinput + 128, SV_PLDL1STRM);
+                ACCRND(acc0, 0);
+                ACCRND(acc1, 4);
+                xinput += 8;
+                xsecret += 1;
+                nbStripes--;
+           } while (nbStripes != 0);
+
+           svst1_u64(mask, xacc + 0, acc0);
+           svst1_u64(mask, xacc + 4, acc1);
+       }
+    }
+}
+
+#endif
+
 /* scalar variants - universal */
 
+#if defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__))
+/*
+ * In XXH3_scalarRound(), GCC and Clang have a similar codegen issue, where they
+ * emit an excess mask and a full 64-bit multiply-add (MADD X-form).
+ *
+ * While this might not seem like much, as AArch64 is a 64-bit architecture, only
+ * big Cortex designs have a full 64-bit multiplier.
+ *
+ * On the little cores, the smaller 32-bit multiplier is used, and full 64-bit
+ * multiplies expand to 2-3 multiplies in microcode. This has a major penalty
+ * of up to 4 latency cycles and 2 stall cycles in the multiply pipeline.
+ *
+ * Thankfully, AArch64 still provides the 32-bit long multiply-add (UMADDL) which does
+ * not have this penalty and does the mask automatically.
+ */
+XXH_FORCE_INLINE xxh_u64
+XXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)
+{
+    xxh_u64 ret;
+    /* note: %x = 64-bit register, %w = 32-bit register */
+    __asm__("umaddl %x0, %w1, %w2, %x3" : "=r" (ret) : "r" (lhs), "r" (rhs), "r" (acc));
+    return ret;
+}
+#else
+XXH_FORCE_INLINE xxh_u64
+XXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)
+{
+    return XXH_mult32to64((xxh_u32)lhs, (xxh_u32)rhs) + acc;
+}
+#endif
+
+/*!
+ * @internal
+ * @brief Scalar round for @ref XXH3_accumulate_512_scalar().
+ *
+ * This is extracted to its own function because the NEON path uses a combination
+ * of NEON and scalar.
+ */
+XXH_FORCE_INLINE void
+XXH3_scalarRound(void* XXH_RESTRICT acc,
+                 void const* XXH_RESTRICT input,
+                 void const* XXH_RESTRICT secret,
+                 size_t lane)
+{
+    xxh_u64* xacc = (xxh_u64*) acc;
+    xxh_u8 const* xinput  = (xxh_u8 const*) input;
+    xxh_u8 const* xsecret = (xxh_u8 const*) secret;
+    XXH_ASSERT(lane < XXH_ACC_NB);
+    XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);
+    {
+        xxh_u64 const data_val = XXH_readLE64(xinput + lane * 8);
+        xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + lane * 8);
+        xacc[lane ^ 1] += data_val; /* swap adjacent lanes */
+        xacc[lane] = XXH_mult32to64_add64(data_key /* & 0xFFFFFFFF */, data_key >> 32, xacc[lane]);
+    }
+}
+
+/*!
+ * @internal
+ * @brief Processes a 64 byte block of data using the scalar path.
+ */
 XXH_FORCE_INLINE void
 XXH3_accumulate_512_scalar(void* XXH_RESTRICT acc,
                      const void* XXH_RESTRICT input,
                      const void* XXH_RESTRICT secret)
 {
-    xxh_u64* const xacc = (xxh_u64*) acc; /* presumed aligned */
-    const xxh_u8* const xinput  = (const xxh_u8*) input;  /* no alignment restriction */
-    const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */
     size_t i;
-    XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);
+    /* ARM GCC refuses to unroll this loop, resulting in a 24% slowdown on ARMv6. */
+#if defined(__GNUC__) && !defined(__clang__) \
+  && (defined(__arm__) || defined(__thumb2__)) \
+  && defined(__ARM_FEATURE_UNALIGNED) /* no unaligned access just wastes bytes */ \
+  && XXH_SIZE_OPT <= 0
+#  pragma GCC unroll 8
+#endif
     for (i=0; i < XXH_ACC_NB; i++) {
-        xxh_u64 const data_val = XXH_readLE64(xinput + 8*i);
-        xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + i*8);
-        xacc[i ^ 1] += data_val; /* swap adjacent lanes */
-        xacc[i] += XXH_mult32to64(data_key & 0xFFFFFFFF, data_key >> 32);
+        XXH3_scalarRound(acc, input, secret, i);
     }
 }
+XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(scalar)
 
+/*!
+ * @internal
+ * @brief Scalar scramble step for @ref XXH3_scrambleAcc_scalar().
+ *
+ * This is extracted to its own function because the NEON path uses a combination
+ * of NEON and scalar.
+ */
 XXH_FORCE_INLINE void
-XXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+XXH3_scalarScrambleRound(void* XXH_RESTRICT acc,
+                         void const* XXH_RESTRICT secret,
+                         size_t lane)
 {
     xxh_u64* const xacc = (xxh_u64*) acc;   /* presumed aligned */
     const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */
-    size_t i;
     XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0);
-    for (i=0; i < XXH_ACC_NB; i++) {
-        xxh_u64 const key64 = XXH_readLE64(xsecret + 8*i);
-        xxh_u64 acc64 = xacc[i];
+    XXH_ASSERT(lane < XXH_ACC_NB);
+    {
+        xxh_u64 const key64 = XXH_readLE64(xsecret + lane * 8);
+        xxh_u64 acc64 = xacc[lane];
         acc64 = XXH_xorshift64(acc64, 47);
         acc64 ^= key64;
         acc64 *= XXH_PRIME32_1;
-        xacc[i] = acc64;
+        xacc[lane] = acc64;
+    }
+}
+
+/*!
+ * @internal
+ * @brief Scrambles the accumulators after a large chunk has been read
+ */
+XXH_FORCE_INLINE void
+XXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
+{
+    size_t i;
+    for (i=0; i < XXH_ACC_NB; i++) {
+        XXH3_scalarScrambleRound(acc, secret, i);
     }
 }
 
@@ -4239,15 +5413,16 @@ XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
     const xxh_u8* kSecretPtr = XXH3_kSecret;
     XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);
 
-#if defined(__clang__) && defined(__aarch64__)
+#if defined(__GNUC__) && defined(__aarch64__)
     /*
      * UGLY HACK:
-     * Clang generates a bunch of MOV/MOVK pairs for aarch64, and they are
+     * GCC and Clang generate a bunch of MOV/MOVK pairs for aarch64, and they are
      * placed sequentially, in order, at the top of the unrolled loop.
      *
      * While MOVK is great for generating constants (2 cycles for a 64-bit
-     * constant compared to 4 cycles for LDR), long MOVK chains stall the
-     * integer pipelines:
+     * constant compared to 4 cycles for LDR), it fights for bandwidth with
+     * the arithmetic instructions.
+     *
      *   I   L   S
      * MOVK
      * MOVK
@@ -4256,7 +5431,7 @@ XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
      * ADD
      * SUB      STR
      *          STR
-     * By forcing loads from memory (as the asm line causes Clang to assume
+     * By forcing loads from memory (as the asm line causes the compiler to assume
      * that XXH3_kSecretPtr has been changed), the pipelines are used more
      * efficiently:
      *   I   L   S
@@ -4264,23 +5439,20 @@ XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
      *  ADD LDR
      *  SUB     STR
      *          STR
+     *
+     * See XXH3_NEON_LANES for details on the pipsline.
+     *
      * XXH3_64bits_withSeed, len == 256, Snapdragon 835
      *   without hack: 2654.4 MB/s
      *   with hack:    3202.9 MB/s
      */
     XXH_COMPILER_GUARD(kSecretPtr);
 #endif
-    /*
-     * Note: in debug mode, this overrides the asm optimization
-     * and Clang will emit MOVK chains again.
-     */
-    XXH_ASSERT(kSecretPtr == XXH3_kSecret);
-
     {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16;
         int i;
         for (i=0; i < nbRounds; i++) {
             /*
-             * The asm hack causes Clang to assume that kSecretPtr aliases with
+             * The asm hack causes the compiler to assume that kSecretPtr aliases with
              * customSecret, and on aarch64, this prevented LDP from merging two
              * loads together for free. Putting the loads together before the stores
              * properly generates LDP.
@@ -4293,7 +5465,7 @@ XXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)
 }
 
 
-typedef void (*XXH3_f_accumulate_512)(void* XXH_RESTRICT, const void*, const void*);
+typedef void (*XXH3_f_accumulate)(xxh_u64* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, size_t);
 typedef void (*XXH3_f_scrambleAcc)(void* XXH_RESTRICT, const void*);
 typedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64);
 
@@ -4301,82 +5473,63 @@ typedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64);
 #if (XXH_VECTOR == XXH_AVX512)
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_avx512
+#define XXH3_accumulate     XXH3_accumulate_avx512
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_avx512
 #define XXH3_initCustomSecret XXH3_initCustomSecret_avx512
 
 #elif (XXH_VECTOR == XXH_AVX2)
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_avx2
+#define XXH3_accumulate     XXH3_accumulate_avx2
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_avx2
 #define XXH3_initCustomSecret XXH3_initCustomSecret_avx2
 
 #elif (XXH_VECTOR == XXH_SSE2)
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_sse2
+#define XXH3_accumulate     XXH3_accumulate_sse2
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_sse2
 #define XXH3_initCustomSecret XXH3_initCustomSecret_sse2
 
 #elif (XXH_VECTOR == XXH_NEON)
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_neon
+#define XXH3_accumulate     XXH3_accumulate_neon
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_neon
 #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
 
 #elif (XXH_VECTOR == XXH_VSX)
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_vsx
+#define XXH3_accumulate     XXH3_accumulate_vsx
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_vsx
 #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
 
+#elif (XXH_VECTOR == XXH_SVE)
+#define XXH3_accumulate_512 XXH3_accumulate_512_sve
+#define XXH3_accumulate     XXH3_accumulate_sve
+#define XXH3_scrambleAcc    XXH3_scrambleAcc_scalar
+#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
+
 #else /* scalar */
 
 #define XXH3_accumulate_512 XXH3_accumulate_512_scalar
+#define XXH3_accumulate     XXH3_accumulate_scalar
 #define XXH3_scrambleAcc    XXH3_scrambleAcc_scalar
 #define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
 
 #endif
 
-
-
-#ifndef XXH_PREFETCH_DIST
-#  ifdef __clang__
-#    define XXH_PREFETCH_DIST 320
-#  else
-#    if (XXH_VECTOR == XXH_AVX512)
-#      define XXH_PREFETCH_DIST 512
-#    else
-#      define XXH_PREFETCH_DIST 384
-#    endif
-#  endif  /* __clang__ */
-#endif  /* XXH_PREFETCH_DIST */
-
-/*
- * XXH3_accumulate()
- * Loops over XXH3_accumulate_512().
- * Assumption: nbStripes will not overflow the secret size
- */
-XXH_FORCE_INLINE void
-XXH3_accumulate(     xxh_u64* XXH_RESTRICT acc,
-                const xxh_u8* XXH_RESTRICT input,
-                const xxh_u8* XXH_RESTRICT secret,
-                      size_t nbStripes,
-                      XXH3_f_accumulate_512 f_acc512)
-{
-    size_t n;
-    for (n = 0; n < nbStripes; n++ ) {
-        const xxh_u8* const in = input + n*XXH_STRIPE_LEN;
-        XXH_PREFETCH(in + XXH_PREFETCH_DIST);
-        f_acc512(acc,
-                 in,
-                 secret + n*XXH_SECRET_CONSUME_RATE);
-    }
-}
+#if XXH_SIZE_OPT >= 1 /* don't do SIMD for initialization */
+#  undef XXH3_initCustomSecret
+#  define XXH3_initCustomSecret XXH3_initCustomSecret_scalar
+#endif
 
 XXH_FORCE_INLINE void
 XXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,
                       const xxh_u8* XXH_RESTRICT input, size_t len,
                       const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
-                            XXH3_f_accumulate_512 f_acc512,
+                            XXH3_f_accumulate f_acc,
                             XXH3_f_scrambleAcc f_scramble)
 {
     size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;
@@ -4388,7 +5541,7 @@ XXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,
     XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
 
     for (n = 0; n < nb_blocks; n++) {
-        XXH3_accumulate(acc, input + n*block_len, secret, nbStripesPerBlock, f_acc512);
+        f_acc(acc, input + n*block_len, secret, nbStripesPerBlock);
         f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN);
     }
 
@@ -4396,12 +5549,12 @@ XXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,
     XXH_ASSERT(len > XXH_STRIPE_LEN);
     {   size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN;
         XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE));
-        XXH3_accumulate(acc, input + nb_blocks*block_len, secret, nbStripes, f_acc512);
+        f_acc(acc, input + nb_blocks*block_len, secret, nbStripes);
 
         /* last stripe */
         {   const xxh_u8* const p = input + len - XXH_STRIPE_LEN;
 #define XXH_SECRET_LASTACC_START 7  /* not aligned on 8, last secret is different from acc & scrambler */
-            f_acc512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);
+            XXH3_accumulate_512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);
     }   }
 }
 
@@ -4446,12 +5599,12 @@ XXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secre
 XXH_FORCE_INLINE XXH64_hash_t
 XXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,
                            const void* XXH_RESTRICT secret, size_t secretSize,
-                           XXH3_f_accumulate_512 f_acc512,
+                           XXH3_f_accumulate f_acc,
                            XXH3_f_scrambleAcc f_scramble)
 {
     XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;
 
-    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc512, f_scramble);
+    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc, f_scramble);
 
     /* converge into final hash */
     XXH_STATIC_ASSERT(sizeof(acc) == 64);
@@ -4465,13 +5618,15 @@ XXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,
  * It's important for performance to transmit secret's size (when it's static)
  * so that the compiler can properly optimize the vectorized loop.
  * This makes a big performance difference for "medium" keys (<1 KB) when using AVX instruction set.
+ * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE
+ * breaks -Og, this is XXH_NO_INLINE.
  */
-XXH_FORCE_INLINE XXH64_hash_t
+XXH3_WITH_SECRET_INLINE XXH64_hash_t
 XXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len,
                              XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)
 {
     (void)seed64;
-    return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate_512, XXH3_scrambleAcc);
+    return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate, XXH3_scrambleAcc);
 }
 
 /*
@@ -4480,12 +5635,12 @@ XXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len,
  * Note that inside this no_inline function, we do inline the internal loop,
  * and provide a statically defined secret size to allow optimization of vector loop.
  */
-XXH_NO_INLINE XXH64_hash_t
+XXH_NO_INLINE XXH_PUREF XXH64_hash_t
 XXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len,
                           XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)
 {
     (void)seed64; (void)secret; (void)secretLen;
-    return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate_512, XXH3_scrambleAcc);
+    return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate, XXH3_scrambleAcc);
 }
 
 /*
@@ -4502,18 +5657,20 @@ XXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len,
 XXH_FORCE_INLINE XXH64_hash_t
 XXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,
                                     XXH64_hash_t seed,
-                                    XXH3_f_accumulate_512 f_acc512,
+                                    XXH3_f_accumulate f_acc,
                                     XXH3_f_scrambleAcc f_scramble,
                                     XXH3_f_initCustomSecret f_initSec)
 {
+#if XXH_SIZE_OPT <= 0
     if (seed == 0)
         return XXH3_hashLong_64b_internal(input, len,
                                           XXH3_kSecret, sizeof(XXH3_kSecret),
-                                          f_acc512, f_scramble);
+                                          f_acc, f_scramble);
+#endif
     {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
         f_initSec(secret, seed);
         return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret),
-                                          f_acc512, f_scramble);
+                                          f_acc, f_scramble);
     }
 }
 
@@ -4521,12 +5678,12 @@ XXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,
  * It's important for performance that XXH3_hashLong is not inlined.
  */
 XXH_NO_INLINE XXH64_hash_t
-XXH3_hashLong_64b_withSeed(const void* input, size_t len,
-                           XXH64_hash_t seed, const xxh_u8* secret, size_t secretLen)
+XXH3_hashLong_64b_withSeed(const void* XXH_RESTRICT input, size_t len,
+                           XXH64_hash_t seed, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)
 {
     (void)secret; (void)secretLen;
     return XXH3_hashLong_64b_withSeed_internal(input, len, seed,
-                XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret);
+                XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);
 }
 
 
@@ -4558,37 +5715,37 @@ XXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,
 
 /* ===   Public entry point   === */
 
-/*! @ingroup xxh3_family */
-XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(const void* input, size_t len)
+/*! @ingroup XXH3_family */
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length)
 {
-    return XXH3_64bits_internal(input, len, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default);
+    return XXH3_64bits_internal(input, length, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH64_hash_t
-XXH3_64bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize)
+XXH3_64bits_withSecret(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize)
 {
-    return XXH3_64bits_internal(input, len, 0, secret, secretSize, XXH3_hashLong_64b_withSecret);
+    return XXH3_64bits_internal(input, length, 0, secret, secretSize, XXH3_hashLong_64b_withSecret);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH64_hash_t
-XXH3_64bits_withSeed(const void* input, size_t len, XXH64_hash_t seed)
+XXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed)
 {
-    return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed);
+    return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed);
 }
 
 XXH_PUBLIC_API XXH64_hash_t
-XXH3_64bits_withSecretandSeed(const void* input, size_t len, const void* secret, size_t secretSize, XXH64_hash_t seed)
+XXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)
 {
-    if (len <= XXH3_MIDSIZE_MAX)
-        return XXH3_64bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);
-    return XXH3_hashLong_64b_withSecret(input, len, seed, (const xxh_u8*)secret, secretSize);
+    if (length <= XXH3_MIDSIZE_MAX)
+        return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);
+    return XXH3_hashLong_64b_withSecret(input, length, seed, (const xxh_u8*)secret, secretSize);
 }
 
 
 /* ===   XXH3 streaming   === */
-
+#ifndef XXH_NO_STREAM
 /*
  * Malloc's a pointer that is always aligned to align.
  *
@@ -4612,7 +5769,7 @@ XXH3_64bits_withSecretandSeed(const void* input, size_t len, const void* secret,
  *
  * Align must be a power of 2 and 8 <= align <= 128.
  */
-static void* XXH_alignedMalloc(size_t s, size_t align)
+static XXH_MALLOCF void* XXH_alignedMalloc(size_t s, size_t align)
 {
     XXH_ASSERT(align <= 128 && align >= 8); /* range check */
     XXH_ASSERT((align & (align-1)) == 0);   /* power of 2 */
@@ -4654,7 +5811,13 @@ static void XXH_alignedFree(void* p)
         XXH_free(base);
     }
 }
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
+/*!
+ * @brief Allocate an @ref XXH3_state_t.
+ *
+ * Must be freed with XXH3_freeState().
+ * @return An allocated XXH3_state_t on success, `NULL` on failure.
+ */
 XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
 {
     XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64);
@@ -4663,16 +5826,23 @@ XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
     return state;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
+/*!
+ * @brief Frees an @ref XXH3_state_t.
+ *
+ * Must be allocated with XXH3_createState().
+ * @param statePtr A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().
+ * @return XXH_OK.
+ */
 XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)
 {
     XXH_alignedFree(statePtr);
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API void
-XXH3_copyState(XXH3_state_t* dst_state, const XXH3_state_t* src_state)
+XXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state)
 {
     XXH_memcpy(dst_state, src_state, sizeof(*dst_state));
 }
@@ -4704,18 +5874,18 @@ XXH3_reset_internal(XXH3_state_t* statePtr,
     statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_reset(XXH3_state_t* statePtr)
+XXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)
 {
     if (statePtr == NULL) return XXH_ERROR;
     XXH3_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize)
+XXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)
 {
     if (statePtr == NULL) return XXH_ERROR;
     XXH3_reset_internal(statePtr, 0, secret, secretSize);
@@ -4724,9 +5894,9 @@ XXH3_64bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
+XXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)
 {
     if (statePtr == NULL) return XXH_ERROR;
     if (seed==0) return XXH3_64bits_reset(statePtr);
@@ -4736,9 +5906,9 @@ XXH3_64bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_reset_withSecretandSeed(XXH3_state_t* statePtr, const void* secret, size_t secretSize, XXH64_hash_t seed64)
+XXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed64)
 {
     if (statePtr == NULL) return XXH_ERROR;
     if (secret == NULL) return XXH_ERROR;
@@ -4748,35 +5918,61 @@ XXH3_64bits_reset_withSecretandSeed(XXH3_state_t* statePtr, const void* secret,
     return XXH_OK;
 }
 
-/* Note : when XXH3_consumeStripes() is invoked,
- * there must be a guarantee that at least one more byte must be consumed from input
- * so that the function can blindly consume all stripes using the "normal" secret segment */
-XXH_FORCE_INLINE void
+/*!
+ * @internal
+ * @brief Processes a large input for XXH3_update() and XXH3_digest_long().
+ *
+ * Unlike XXH3_hashLong_internal_loop(), this can process data that overlaps a block.
+ *
+ * @param acc                Pointer to the 8 accumulator lanes
+ * @param nbStripesSoFarPtr  In/out pointer to the number of leftover stripes in the block*
+ * @param nbStripesPerBlock  Number of stripes in a block
+ * @param input              Input pointer
+ * @param nbStripes          Number of stripes to process
+ * @param secret             Secret pointer
+ * @param secretLimit        Offset of the last block in @p secret
+ * @param f_acc              Pointer to an XXH3_accumulate implementation
+ * @param f_scramble         Pointer to an XXH3_scrambleAcc implementation
+ * @return                   Pointer past the end of @p input after processing
+ */
+XXH_FORCE_INLINE const xxh_u8 *
 XXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc,
                     size_t* XXH_RESTRICT nbStripesSoFarPtr, size_t nbStripesPerBlock,
                     const xxh_u8* XXH_RESTRICT input, size_t nbStripes,
                     const xxh_u8* XXH_RESTRICT secret, size_t secretLimit,
-                    XXH3_f_accumulate_512 f_acc512,
+                    XXH3_f_accumulate f_acc,
                     XXH3_f_scrambleAcc f_scramble)
 {
-    XXH_ASSERT(nbStripes <= nbStripesPerBlock);  /* can handle max 1 scramble per invocation */
-    XXH_ASSERT(*nbStripesSoFarPtr < nbStripesPerBlock);
-    if (nbStripesPerBlock - *nbStripesSoFarPtr <= nbStripes) {
-        /* need a scrambling operation */
-        size_t const nbStripesToEndofBlock = nbStripesPerBlock - *nbStripesSoFarPtr;
-        size_t const nbStripesAfterBlock = nbStripes - nbStripesToEndofBlock;
-        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripesToEndofBlock, f_acc512);
-        f_scramble(acc, secret + secretLimit);
-        XXH3_accumulate(acc, input + nbStripesToEndofBlock * XXH_STRIPE_LEN, secret, nbStripesAfterBlock, f_acc512);
-        *nbStripesSoFarPtr = nbStripesAfterBlock;
-    } else {
-        XXH3_accumulate(acc, input, secret + nbStripesSoFarPtr[0] * XXH_SECRET_CONSUME_RATE, nbStripes, f_acc512);
+    const xxh_u8* initialSecret = secret + *nbStripesSoFarPtr * XXH_SECRET_CONSUME_RATE;
+    /* Process full blocks */
+    if (nbStripes >= (nbStripesPerBlock - *nbStripesSoFarPtr)) {
+        /* Process the initial partial block... */
+        size_t nbStripesThisIter = nbStripesPerBlock - *nbStripesSoFarPtr;
+
+        do {
+            /* Accumulate and scramble */
+            f_acc(acc, input, initialSecret, nbStripesThisIter);
+            f_scramble(acc, secret + secretLimit);
+            input += nbStripesThisIter * XXH_STRIPE_LEN;
+            nbStripes -= nbStripesThisIter;
+            /* Then continue the loop with the full block size */
+            nbStripesThisIter = nbStripesPerBlock;
+            initialSecret = secret;
+        } while (nbStripes >= nbStripesPerBlock);
+        *nbStripesSoFarPtr = 0;
+    }
+    /* Process a partial block */
+    if (nbStripes > 0) {
+        f_acc(acc, input, initialSecret, nbStripes);
+        input += nbStripes * XXH_STRIPE_LEN;
         *nbStripesSoFarPtr += nbStripes;
     }
+    /* Return end pointer */
+    return input;
 }
 
 #ifndef XXH3_STREAM_USE_STACK
-# ifndef __clang__ /* clang doesn't need additional stack space */
+# if XXH_SIZE_OPT <= 0 && !defined(__clang__) /* clang doesn't need additional stack space */
 #   define XXH3_STREAM_USE_STACK 1
 # endif
 #endif
@@ -4786,7 +5982,7 @@ XXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc,
 XXH_FORCE_INLINE XXH_errorcode
 XXH3_update(XXH3_state_t* XXH_RESTRICT const state,
             const xxh_u8* XXH_RESTRICT input, size_t len,
-            XXH3_f_accumulate_512 f_acc512,
+            XXH3_f_accumulate f_acc,
             XXH3_f_scrambleAcc f_scramble)
 {
     if (input==NULL) {
@@ -4802,7 +5998,8 @@ XXH3_update(XXH3_state_t* XXH_RESTRICT const state,
          * when operating accumulators directly into state.
          * Operating into stack space seems to enable proper optimization.
          * clang, on the other hand, doesn't seem to need this trick */
-        XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[8]; memcpy(acc, state->acc, sizeof(acc));
+        XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[8];
+        XXH_memcpy(acc, state->acc, sizeof(acc));
 #else
         xxh_u64* XXH_RESTRICT const acc = state->acc;
 #endif
@@ -4810,7 +6007,7 @@ XXH3_update(XXH3_state_t* XXH_RESTRICT const state,
         XXH_ASSERT(state->bufferedSize <= XXH3_INTERNALBUFFER_SIZE);
 
         /* small input : just fill in tmp buffer */
-        if (state->bufferedSize + len <= XXH3_INTERNALBUFFER_SIZE) {
+        if (len <= XXH3_INTERNALBUFFER_SIZE - state->bufferedSize) {
             XXH_memcpy(state->buffer + state->bufferedSize, input, len);
             state->bufferedSize += (XXH32_hash_t)len;
             return XXH_OK;
@@ -4832,57 +6029,20 @@ XXH3_update(XXH3_state_t* XXH_RESTRICT const state,
                                &state->nbStripesSoFar, state->nbStripesPerBlock,
                                 state->buffer, XXH3_INTERNALBUFFER_STRIPES,
                                 secret, state->secretLimit,
-                                f_acc512, f_scramble);
+                                f_acc, f_scramble);
             state->bufferedSize = 0;
         }
         XXH_ASSERT(input < bEnd);
-
-        /* large input to consume : ingest per full block */
-        if ((size_t)(bEnd - input) > state->nbStripesPerBlock * XXH_STRIPE_LEN) {
+        if (bEnd - input > XXH3_INTERNALBUFFER_SIZE) {
             size_t nbStripes = (size_t)(bEnd - 1 - input) / XXH_STRIPE_LEN;
-            XXH_ASSERT(state->nbStripesPerBlock >= state->nbStripesSoFar);
-            /* join to current block's end */
-            {   size_t const nbStripesToEnd = state->nbStripesPerBlock - state->nbStripesSoFar;
-                XXH_ASSERT(nbStripes <= nbStripes);
-                XXH3_accumulate(acc, input, secret + state->nbStripesSoFar * XXH_SECRET_CONSUME_RATE, nbStripesToEnd, f_acc512);
-                f_scramble(acc, secret + state->secretLimit);
-                state->nbStripesSoFar = 0;
-                input += nbStripesToEnd * XXH_STRIPE_LEN;
-                nbStripes -= nbStripesToEnd;
-            }
-            /* consume per entire blocks */
-            while(nbStripes >= state->nbStripesPerBlock) {
-                XXH3_accumulate(acc, input, secret, state->nbStripesPerBlock, f_acc512);
-                f_scramble(acc, secret + state->secretLimit);
-                input += state->nbStripesPerBlock * XXH_STRIPE_LEN;
-                nbStripes -= state->nbStripesPerBlock;
-            }
-            /* consume last partial block */
-            XXH3_accumulate(acc, input, secret, nbStripes, f_acc512);
-            input += nbStripes * XXH_STRIPE_LEN;
-            XXH_ASSERT(input < bEnd);  /* at least some bytes left */
-            state->nbStripesSoFar = nbStripes;
-            /* buffer predecessor of last partial stripe */
-            XXH_memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);
-            XXH_ASSERT(bEnd - input <= XXH_STRIPE_LEN);
-        } else {
-            /* content to consume <= block size */
-            /* Consume input by a multiple of internal buffer size */
-            if (bEnd - input > XXH3_INTERNALBUFFER_SIZE) {
-                const xxh_u8* const limit = bEnd - XXH3_INTERNALBUFFER_SIZE;
-                do {
-                    XXH3_consumeStripes(acc,
+            input = XXH3_consumeStripes(acc,
                                        &state->nbStripesSoFar, state->nbStripesPerBlock,
-                                        input, XXH3_INTERNALBUFFER_STRIPES,
-                                        secret, state->secretLimit,
-                                        f_acc512, f_scramble);
-                    input += XXH3_INTERNALBUFFER_SIZE;
-                } while (input<limit);
-                /* buffer predecessor of last partial stripe */
-                XXH_memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);
-            }
-        }
+                                       input, nbStripes,
+                                       secret, state->secretLimit,
+                                       f_acc, f_scramble);
+            XXH_memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);
 
+        }
         /* Some remaining input (always) : buffer it */
         XXH_ASSERT(input < bEnd);
         XXH_ASSERT(bEnd - input <= XXH3_INTERNALBUFFER_SIZE);
@@ -4891,19 +6051,19 @@ XXH3_update(XXH3_state_t* XXH_RESTRICT const state,
         state->bufferedSize = (XXH32_hash_t)(bEnd-input);
 #if defined(XXH3_STREAM_USE_STACK) && XXH3_STREAM_USE_STACK >= 1
         /* save stack accumulators into state */
-        memcpy(state->acc, acc, sizeof(acc));
+        XXH_memcpy(state->acc, acc, sizeof(acc));
 #endif
     }
 
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_64bits_update(XXH3_state_t* state, const void* input, size_t len)
+XXH3_64bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)
 {
     return XXH3_update(state, (const xxh_u8*)input, len,
-                       XXH3_accumulate_512, XXH3_scrambleAcc);
+                       XXH3_accumulate, XXH3_scrambleAcc);
 }
 
 
@@ -4912,37 +6072,40 @@ XXH3_digest_long (XXH64_hash_t* acc,
                   const XXH3_state_t* state,
                   const unsigned char* secret)
 {
+    xxh_u8 lastStripe[XXH_STRIPE_LEN];
+    const xxh_u8* lastStripePtr;
+
     /*
      * Digest on a local copy. This way, the state remains unaltered, and it can
      * continue ingesting more input afterwards.
      */
     XXH_memcpy(acc, state->acc, sizeof(state->acc));
     if (state->bufferedSize >= XXH_STRIPE_LEN) {
+        /* Consume remaining stripes then point to remaining data in buffer */
         size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN;
         size_t nbStripesSoFar = state->nbStripesSoFar;
         XXH3_consumeStripes(acc,
                            &nbStripesSoFar, state->nbStripesPerBlock,
                             state->buffer, nbStripes,
                             secret, state->secretLimit,
-                            XXH3_accumulate_512, XXH3_scrambleAcc);
-        /* last stripe */
-        XXH3_accumulate_512(acc,
-                            state->buffer + state->bufferedSize - XXH_STRIPE_LEN,
-                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
+                            XXH3_accumulate, XXH3_scrambleAcc);
+        lastStripePtr = state->buffer + state->bufferedSize - XXH_STRIPE_LEN;
     } else {  /* bufferedSize < XXH_STRIPE_LEN */
-        xxh_u8 lastStripe[XXH_STRIPE_LEN];
+        /* Copy to temp buffer */
         size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize;
         XXH_ASSERT(state->bufferedSize > 0);  /* there is always some input buffered */
         XXH_memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);
         XXH_memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);
-        XXH3_accumulate_512(acc,
-                            lastStripe,
-                            secret + state->secretLimit - XXH_SECRET_LASTACC_START);
+        lastStripePtr = lastStripe;
     }
+    /* Last stripe */
+    XXH3_accumulate_512(acc,
+                        lastStripePtr,
+                        secret + state->secretLimit - XXH_SECRET_LASTACC_START);
 }
 
-/*! @ingroup xxh3_family */
-XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
+/*! @ingroup XXH3_family */
+XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* state)
 {
     const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
     if (state->totalLen > XXH3_MIDSIZE_MAX) {
@@ -4958,7 +6121,7 @@ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
     return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen),
                                   secret, state->secretLimit + XXH_STRIPE_LEN);
 }
-
+#endif /* !XXH_NO_STREAM */
 
 
 /* ==========================================
@@ -4978,7 +6141,7 @@ XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (const XXH3_state_t* state)
  * fast for a _128-bit_ hash on 32-bit (it usually clears XXH64).
  */
 
-XXH_FORCE_INLINE XXH128_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     /* A doubled version of 1to3_64b with different constants. */
@@ -5007,7 +6170,7 @@ XXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_
     }
 }
 
-XXH_FORCE_INLINE XXH128_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(input != NULL);
@@ -5027,14 +6190,14 @@ XXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_
         m128.low64  ^= (m128.high64 >> 3);
 
         m128.low64   = XXH_xorshift64(m128.low64, 35);
-        m128.low64  *= 0x9FB21C651E98DF25ULL;
+        m128.low64  *= PRIME_MX2;
         m128.low64   = XXH_xorshift64(m128.low64, 28);
         m128.high64  = XXH3_avalanche(m128.high64);
         return m128;
     }
 }
 
-XXH_FORCE_INLINE XXH128_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(input != NULL);
@@ -5109,7 +6272,7 @@ XXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64
 /*
  * Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN
  */
-XXH_FORCE_INLINE XXH128_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
 {
     XXH_ASSERT(len <= 16);
@@ -5140,7 +6303,7 @@ XXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,
 }
 
 
-XXH_FORCE_INLINE XXH128_hash_t
+XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
                       const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                       XXH64_hash_t seed)
@@ -5151,6 +6314,16 @@ XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
     {   XXH128_hash_t acc;
         acc.low64 = len * XXH_PRIME64_1;
         acc.high64 = 0;
+
+#if XXH_SIZE_OPT >= 1
+        {
+            /* Smaller, but slightly slower. */
+            unsigned int i = (unsigned int)(len - 1) / 32;
+            do {
+                acc = XXH128_mix32B(acc, input+16*i, input+len-16*(i+1), secret+32*i, seed);
+            } while (i-- != 0);
+        }
+#else
         if (len > 32) {
             if (len > 64) {
                 if (len > 96) {
@@ -5161,6 +6334,7 @@ XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
             acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed);
         }
         acc = XXH128_mix32B(acc, input, input+len-16, secret, seed);
+#endif
         {   XXH128_hash_t h128;
             h128.low64  = acc.low64 + acc.high64;
             h128.high64 = (acc.low64    * XXH_PRIME64_1)
@@ -5173,7 +6347,7 @@ XXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
     }
 }
 
-XXH_NO_INLINE XXH128_hash_t
+XXH_NO_INLINE XXH_PUREF XXH128_hash_t
 XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
                        const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                        XXH64_hash_t seed)
@@ -5182,25 +6356,34 @@ XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
     XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);
 
     {   XXH128_hash_t acc;
-        int const nbRounds = (int)len / 32;
-        int i;
+        unsigned i;
         acc.low64 = len * XXH_PRIME64_1;
         acc.high64 = 0;
-        for (i=0; i<4; i++) {
+        /*
+         *  We set as `i` as offset + 32. We do this so that unchanged
+         * `len` can be used as upper bound. This reaches a sweet spot
+         * where both x86 and aarch64 get simple agen and good codegen
+         * for the loop.
+         */
+        for (i = 32; i < 160; i += 32) {
             acc = XXH128_mix32B(acc,
-                                input  + (32 * i),
-                                input  + (32 * i) + 16,
-                                secret + (32 * i),
+                                input  + i - 32,
+                                input  + i - 16,
+                                secret + i - 32,
                                 seed);
         }
         acc.low64 = XXH3_avalanche(acc.low64);
         acc.high64 = XXH3_avalanche(acc.high64);
-        XXH_ASSERT(nbRounds >= 4);
-        for (i=4 ; i < nbRounds; i++) {
+        /*
+         * NB: `i <= len` will duplicate the last 32-bytes if
+         * len % 32 was zero. This is an unfortunate necessity to keep
+         * the hash result stable.
+         */
+        for (i=160; i <= len; i += 32) {
             acc = XXH128_mix32B(acc,
-                                input + (32 * i),
-                                input + (32 * i) + 16,
-                                secret + XXH3_MIDSIZE_STARTOFFSET + (32 * (i - 4)),
+                                input + i - 32,
+                                input + i - 16,
+                                secret + XXH3_MIDSIZE_STARTOFFSET + i - 160,
                                 seed);
         }
         /* last bytes */
@@ -5208,7 +6391,7 @@ XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
                             input + len - 16,
                             input + len - 32,
                             secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16,
-                            0ULL - seed);
+                            (XXH64_hash_t)0 - seed);
 
         {   XXH128_hash_t h128;
             h128.low64  = acc.low64 + acc.high64;
@@ -5225,12 +6408,12 @@ XXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,
 XXH_FORCE_INLINE XXH128_hash_t
 XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,
                             const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
-                            XXH3_f_accumulate_512 f_acc512,
+                            XXH3_f_accumulate f_acc,
                             XXH3_f_scrambleAcc f_scramble)
 {
     XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;
 
-    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc512, f_scramble);
+    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc, f_scramble);
 
     /* converge into final hash */
     XXH_STATIC_ASSERT(sizeof(acc) == 64);
@@ -5248,47 +6431,50 @@ XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,
 }
 
 /*
- * It's important for performance that XXH3_hashLong is not inlined.
+ * It's important for performance that XXH3_hashLong() is not inlined.
  */
-XXH_NO_INLINE XXH128_hash_t
+XXH_NO_INLINE XXH_PUREF XXH128_hash_t
 XXH3_hashLong_128b_default(const void* XXH_RESTRICT input, size_t len,
                            XXH64_hash_t seed64,
                            const void* XXH_RESTRICT secret, size_t secretLen)
 {
     (void)seed64; (void)secret; (void)secretLen;
     return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret),
-                                       XXH3_accumulate_512, XXH3_scrambleAcc);
+                                       XXH3_accumulate, XXH3_scrambleAcc);
 }
 
 /*
- * It's important for performance to pass @secretLen (when it's static)
+ * It's important for performance to pass @p secretLen (when it's static)
  * to the compiler, so that it can properly optimize the vectorized loop.
+ *
+ * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE
+ * breaks -Og, this is XXH_NO_INLINE.
  */
-XXH_FORCE_INLINE XXH128_hash_t
+XXH3_WITH_SECRET_INLINE XXH128_hash_t
 XXH3_hashLong_128b_withSecret(const void* XXH_RESTRICT input, size_t len,
                               XXH64_hash_t seed64,
                               const void* XXH_RESTRICT secret, size_t secretLen)
 {
     (void)seed64;
     return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, secretLen,
-                                       XXH3_accumulate_512, XXH3_scrambleAcc);
+                                       XXH3_accumulate, XXH3_scrambleAcc);
 }
 
 XXH_FORCE_INLINE XXH128_hash_t
 XXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,
                                 XXH64_hash_t seed64,
-                                XXH3_f_accumulate_512 f_acc512,
+                                XXH3_f_accumulate f_acc,
                                 XXH3_f_scrambleAcc f_scramble,
                                 XXH3_f_initCustomSecret f_initSec)
 {
     if (seed64 == 0)
         return XXH3_hashLong_128b_internal(input, len,
                                            XXH3_kSecret, sizeof(XXH3_kSecret),
-                                           f_acc512, f_scramble);
+                                           f_acc, f_scramble);
     {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
         f_initSec(secret, seed64);
         return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),
-                                           f_acc512, f_scramble);
+                                           f_acc, f_scramble);
     }
 }
 
@@ -5301,7 +6487,7 @@ XXH3_hashLong_128b_withSeed(const void* input, size_t len,
 {
     (void)secret; (void)secretLen;
     return XXH3_hashLong_128b_withSeed_internal(input, len, seed64,
-                XXH3_accumulate_512, XXH3_scrambleAcc, XXH3_initCustomSecret);
+                XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);
 }
 
 typedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, size_t,
@@ -5331,94 +6517,93 @@ XXH3_128bits_internal(const void* input, size_t len,
 
 /* ===   Public XXH128 API   === */
 
-/*! @ingroup xxh3_family */
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(const void* input, size_t len)
+/*! @ingroup XXH3_family */
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* input, size_t len)
 {
     return XXH3_128bits_internal(input, len, 0,
                                  XXH3_kSecret, sizeof(XXH3_kSecret),
                                  XXH3_hashLong_128b_default);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH128_hash_t
-XXH3_128bits_withSecret(const void* input, size_t len, const void* secret, size_t secretSize)
+XXH3_128bits_withSecret(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize)
 {
     return XXH3_128bits_internal(input, len, 0,
                                  (const xxh_u8*)secret, secretSize,
                                  XXH3_hashLong_128b_withSecret);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH128_hash_t
-XXH3_128bits_withSeed(const void* input, size_t len, XXH64_hash_t seed)
+XXH3_128bits_withSeed(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)
 {
     return XXH3_128bits_internal(input, len, seed,
                                  XXH3_kSecret, sizeof(XXH3_kSecret),
                                  XXH3_hashLong_128b_withSeed);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH128_hash_t
-XXH3_128bits_withSecretandSeed(const void* input, size_t len, const void* secret, size_t secretSize, XXH64_hash_t seed)
+XXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)
 {
     if (len <= XXH3_MIDSIZE_MAX)
         return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);
     return XXH3_hashLong_128b_withSecret(input, len, seed, secret, secretSize);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH128_hash_t
-XXH128(const void* input, size_t len, XXH64_hash_t seed)
+XXH128(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)
 {
     return XXH3_128bits_withSeed(input, len, seed);
 }
 
 
 /* ===   XXH3 128-bit streaming   === */
-
+#ifndef XXH_NO_STREAM
 /*
  * All initialization and update functions are identical to 64-bit streaming variant.
  * The only difference is the finalization routine.
  */
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_reset(XXH3_state_t* statePtr)
+XXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)
 {
     return XXH3_64bits_reset(statePtr);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_reset_withSecret(XXH3_state_t* statePtr, const void* secret, size_t secretSize)
+XXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)
 {
     return XXH3_64bits_reset_withSecret(statePtr, secret, secretSize);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_reset_withSeed(XXH3_state_t* statePtr, XXH64_hash_t seed)
+XXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)
 {
     return XXH3_64bits_reset_withSeed(statePtr, seed);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_reset_withSecretandSeed(XXH3_state_t* statePtr, const void* secret, size_t secretSize, XXH64_hash_t seed)
+XXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)
 {
     return XXH3_64bits_reset_withSecretandSeed(statePtr, secret, secretSize, seed);
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_128bits_update(XXH3_state_t* state, const void* input, size_t len)
+XXH3_128bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)
 {
-    return XXH3_update(state, (const xxh_u8*)input, len,
-                       XXH3_accumulate_512, XXH3_scrambleAcc);
+    return XXH3_64bits_update(state, input, len);
 }
 
-/*! @ingroup xxh3_family */
-XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* state)
+/*! @ingroup XXH3_family */
+XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* state)
 {
     const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;
     if (state->totalLen > XXH3_MIDSIZE_MAX) {
@@ -5442,13 +6627,13 @@ XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (const XXH3_state_t* state)
     return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen),
                                    secret, state->secretLimit + XXH_STRIPE_LEN);
 }
-
+#endif /* !XXH_NO_STREAM */
 /* 128-bit utility functions */
 
 #include <string.h>   /* memcmp, memcpy */
 
 /* return : 1 is equal, 0 if different */
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)
 {
     /* note : XXH128_hash_t is compact, it has no padding byte */
@@ -5456,11 +6641,11 @@ XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)
 }
 
 /* This prototype is compatible with stdlib's qsort().
- * return : >0 if *h128_1  > *h128_2
- *          <0 if *h128_1  < *h128_2
- *          =0 if *h128_1 == *h128_2  */
-/*! @ingroup xxh3_family */
-XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2)
+ * @return : >0 if *h128_1  > *h128_2
+ *           <0 if *h128_1  < *h128_2
+ *           =0 if *h128_1 == *h128_2  */
+/*! @ingroup XXH3_family */
+XXH_PUBLIC_API int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2)
 {
     XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;
     XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;
@@ -5472,9 +6657,9 @@ XXH_PUBLIC_API int XXH128_cmp(const void* h128_1, const void* h128_2)
 
 
 /*======   Canonical representation   ======*/
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API void
-XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash)
+XXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash)
 {
     XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));
     if (XXH_CPU_LITTLE_ENDIAN) {
@@ -5485,9 +6670,9 @@ XXH128_canonicalFromHash(XXH128_canonical_t* dst, XXH128_hash_t hash)
     XXH_memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH128_hash_t
-XXH128_hashFromCanonical(const XXH128_canonical_t* src)
+XXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src)
 {
     XXH128_hash_t h;
     h.high64 = XXH_readBE64(src);
@@ -5503,26 +6688,34 @@ XXH128_hashFromCanonical(const XXH128_canonical_t* src)
  */
 #define XXH_MIN(x, y) (((x) > (y)) ? (y) : (x))
 
-static void XXH3_combine16(void* dst, XXH128_hash_t h128)
+XXH_FORCE_INLINE void XXH3_combine16(void* dst, XXH128_hash_t h128)
 {
     XXH_writeLE64( dst, XXH_readLE64(dst) ^ h128.low64 );
     XXH_writeLE64( (char*)dst+8, XXH_readLE64((char*)dst+8) ^ h128.high64 );
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API XXH_errorcode
-XXH3_generateSecret(void* secretBuffer, size_t secretSize, const void* customSeed, size_t customSeedSize)
+XXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize)
 {
+#if (XXH_DEBUGLEVEL >= 1)
     XXH_ASSERT(secretBuffer != NULL);
-    if (secretBuffer == NULL) return XXH_ERROR;
     XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
+#else
+    /* production mode, assert() are disabled */
+    if (secretBuffer == NULL) return XXH_ERROR;
     if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
+#endif
+
     if (customSeedSize == 0) {
         customSeed = XXH3_kSecret;
         customSeedSize = XXH_SECRET_DEFAULT_SIZE;
     }
+#if (XXH_DEBUGLEVEL >= 1)
     XXH_ASSERT(customSeed != NULL);
+#else
     if (customSeed == NULL) return XXH_ERROR;
+#endif
 
     /* Fill secretBuffer with a copy of customSeed - repeat as needed */
     {   size_t pos = 0;
@@ -5546,9 +6739,9 @@ XXH3_generateSecret(void* secretBuffer, size_t secretSize, const void* customSee
     return XXH_OK;
 }
 
-/*! @ingroup xxh3_family */
+/*! @ingroup XXH3_family */
 XXH_PUBLIC_API void
-XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed)
+XXH3_generateSecret_fromSeed(XXH_NOESCAPE void* secretBuffer, XXH64_hash_t seed)
 {
     XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
     XXH3_initCustomSecret(secret, seed);
@@ -5561,7 +6754,7 @@ XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed)
 /* Pop our optimization override from above */
 #if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \
   && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \
-  && defined(__OPTIMIZE__) && !defined(__OPTIMIZE_SIZE__) /* respect -O0 and -Os */
+  && defined(__OPTIMIZE__) && XXH_SIZE_OPT <= 0 /* respect -O0 and -Os */
 #  pragma GCC pop_options
 #endif
 
@@ -5576,5 +6769,5 @@ XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed)
 
 
 #if defined (__cplusplus)
-}
+} /* extern "C" */
 #endif

From fe750ed10531c47131b447397e67486656cf8135 Mon Sep 17 00:00:00 2001
From: Junming Chen <junming.chen.r@outlook.com>
Date: Tue, 22 Aug 2023 16:22:14 +0800
Subject: [PATCH 205/749] GH-36240: [Python] Refactor CumulativeSumOptions to a
 separate class for independent deprecation (#36977)

**Rationale for this change**
As https://github.com/apache/arrow/issues/36240 says, we refactor CumulativeSumOptions to a separate class.

**What changes are included in this PR?**

- independent CumulativeSumOptions
- the original simple test before #32190
- fix a typo in CumulativeOptions

**Are these changes tested?**
No.
Actually, the PR can't pass the `test_option_class_equality` in test_compute.py ([Error example](https://github.com/apache/arrow/actions/runs/5728571658/job/15523443371?pr=36977)). Cause CumulativeSumOptions's C++ part is also CumulativeOptions.
![image](https://github.com/apache/arrow/assets/18380073/0a173684-47f8-4eb9-b8f4-ba72aa5aab97)

**Are there any user-facing changes?**
No.

Closes: https://github.com/apache/arrow/issues/36240
* Closes: #36240

Lead-authored-by: Junming Chen <junming.chen.r@outlook.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/_compute.pyx          | 26 ++++++++++++++++++++++++--
 python/pyarrow/compute.py            |  2 +-
 python/pyarrow/tests/test_compute.py |  7 ++++++-
 3 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 453f487c4de80..74b9c2ec8c78b 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -29,11 +29,12 @@ from pyarrow.lib cimport *
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
 import pyarrow.lib as lib
-
+from pyarrow.util import _DEPR_MSG
 from libcpp cimport bool as c_bool
 
 import inspect
 import numpy as np
+import warnings
 
 
 def _forbid_instantiation(klass, subclasses_instead=True):
@@ -1947,7 +1948,7 @@ cdef class _CumulativeOptions(FunctionOptions):
                     pyarrow_unwrap_scalar(start), skip_nulls))
             except Exception:
                 _raise_invalid_function_option(
-                    start, "`start` type for CumulativeSumOptions", TypeError)
+                    start, "`start` type for CumulativeOptions", TypeError)
 
 
 class CumulativeOptions(_CumulativeOptions):
@@ -1974,6 +1975,27 @@ class CumulativeOptions(_CumulativeOptions):
         self._set_options(start, skip_nulls)
 
 
+class CumulativeSumOptions(_CumulativeOptions):
+    """
+    Options for `cumulative_sum` function.
+
+    Parameters
+    ----------
+    start : Scalar, default None
+        Starting value for sum computation
+    skip_nulls : bool, default False
+        When false, the first encountered null is propagated.
+    """
+
+    def __init__(self, start=None, *, skip_nulls=False):
+        warnings.warn(
+            _DEPR_MSG.format("CumulativeSumOptions", "14.0", "CumulativeOptions"),
+            FutureWarning,
+            stacklevel=2
+        )
+        self._set_options(start, skip_nulls)
+
+
 cdef class _PairwiseOptions(FunctionOptions):
     def _set_options(self, period):
         self.wrapped.reset(new CPairwiseOptions(period))
diff --git a/python/pyarrow/compute.py b/python/pyarrow/compute.py
index 7b8983cbb98d2..205ab393b8b09 100644
--- a/python/pyarrow/compute.py
+++ b/python/pyarrow/compute.py
@@ -34,7 +34,7 @@
     CastOptions,
     CountOptions,
     CumulativeOptions,
-    CumulativeOptions as CumulativeSumOptions,
+    CumulativeSumOptions,
     DayOfWeekOptions,
     DictionaryEncodeOptions,
     RunEndEncodeOptions,
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 30a3cdba36d71..6fbca5209975c 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -210,7 +210,12 @@ def test_option_class_equality():
         buf = option.serialize()
         deserialized = pc.FunctionOptions.deserialize(buf)
         assert option == deserialized
-        assert repr(option) == repr(deserialized)
+        # TODO remove the check under the if statement
+        # when the deprecated class CumulativeSumOptions is removed.
+        if repr(option).startswith("CumulativeSumOptions"):
+            assert repr(deserialized).startswith("CumulativeOptions")
+        else:
+            assert repr(option) == repr(deserialized)
     for option1, option2 in zip(options, options[1:]):
         assert option1 != option2
 

From 9ddd8d5c52796f20cf619b8f43538b9d454fb9c0 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 22 Aug 2023 15:24:09 +0200
Subject: [PATCH 206/749] GH-37266: [CI][C++] Use ARROW_CMAKE_ARGS not
 CMAKE_ARGS (#37272)

* Closes: #32766
* Closes: #37266

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .github/workflows/cpp.yml  | 2 +-
 .github/workflows/ruby.yml | 2 +-
 ci/appveyor-cpp-build.bat  | 4 ++--
 ci/scripts/cpp_build.sh    | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 401f5dcf8916f..41032fc1b08fc 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -370,7 +370,7 @@ jobs:
       # Don't use preinstalled Boost by empty BOOST_ROOT and
       # -DBoost_NO_BOOST_CMAKE=ON
       BOOST_ROOT: ""
-      CMAKE_ARGS: >-
+      ARROW_CMAKE_ARGS: >-
         -DARROW_PACKAGE_PREFIX=/${{ matrix.msystem_lower}}
         -DBoost_NO_BOOST_CMAKE=ON
         -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index a05f4d5a11d68..1e744975578f5 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -226,7 +226,7 @@ jobs:
       # Don't use preinstalled Boost by empty BOOST_ROOT and
       # -DBoost_NO_BOOST_CMAKE=ON
       BOOST_ROOT: ""
-      CMAKE_ARGS: >-
+      ARROW_CMAKE_ARGS: >-
         -DARROW_PACKAGE_PREFIX=/ucrt${{ matrix.mingw-n-bits }}
         -DBoost_NO_BOOST_CMAKE=ON
         -DCMAKE_FIND_PACKAGE_PREFER_CONFIG=ON
diff --git a/ci/appveyor-cpp-build.bat b/ci/appveyor-cpp-build.bat
index caadaab90b9aa..e69c7bf2516d9 100644
--- a/ci/appveyor-cpp-build.bat
+++ b/ci/appveyor-cpp-build.bat
@@ -37,7 +37,7 @@ call activate arrow
 @rem The "main" C++ build script for Windows CI
 @rem (i.e. for usual configurations)
 
-set CMAKE_ARGS=-DARROW_DEPENDENCY_SOURCE=CONDA -DARROW_WITH_BZ2=ON
+set ARROW_CMAKE_ARGS=-DARROW_DEPENDENCY_SOURCE=CONDA -DARROW_WITH_BZ2=ON
 
 @rem Enable warnings-as-errors
 set ARROW_CXXFLAGS=/WX /MP
@@ -58,7 +58,7 @@ pushd cpp\build
 @rem In release mode, disable optimizations (/Od) for faster compiling
 @rem and enable runtime assertions.
 
-cmake -G "%GENERATOR%" %CMAKE_ARGS% ^
+cmake -G "%GENERATOR%" %ARROW_CMAKE_ARGS% ^
       -DARROW_ACERO=ON ^
       -DARROW_BOOST_USE_SHARED=ON ^
       -DARROW_BUILD_EXAMPLES=ON ^
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index f71724cf61eb4..5a89fafc6015e 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -34,7 +34,7 @@ if [ ! -z "${CONDA_PREFIX}" ]; then
   echo -e "===\n=== Conda environment for build\n==="
   conda list
 
-  export CMAKE_ARGS="${CMAKE_ARGS} -DCMAKE_AR=${AR} -DCMAKE_RANLIB=${RANLIB}"
+  export ARROW_CMAKE_ARGS="${ARROW_CMAKE_ARGS} -DCMAKE_AR=${AR} -DCMAKE_RANLIB=${RANLIB}"
   export ARROW_GANDIVA_PC_CXX_FLAGS=$(echo | ${CXX} -E -Wp,-v -xc++ - 2>&1 | grep '^ ' | awk '{print "-isystem;" substr($1, 1)}' | tr '\n' ';')
 elif [ -x "$(command -v xcrun)" ]; then
   export ARROW_GANDIVA_PC_CXX_FLAGS="-isysroot;$(xcrun --show-sdk-path)"
@@ -183,7 +183,7 @@ cmake \
   -Dzstd_SOURCE=${zstd_SOURCE:-} \
   -Dxsimd_SOURCE=${xsimd_SOURCE:-} \
   -G "${CMAKE_GENERATOR:-Ninja}" \
-  ${CMAKE_ARGS} \
+  ${ARROW_CMAKE_ARGS} \
   ${source_dir}
 
 export CMAKE_BUILD_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL:-$[${n_jobs} + 1]}

From 702e9cae138e8d372643e3545375d8fc4c6212a2 Mon Sep 17 00:00:00 2001
From: Weston Pace <weston.pace@gmail.com>
Date: Tue, 22 Aug 2023 09:27:38 -0700
Subject: [PATCH 207/749] GH-33985: [C++] Add substrait
 serialization/deserialization for expressions (#34834)

### Rationale for this change

Substrait provides a library-independent way to represent compute expressions.  By serializing and deserializing pyarrow compute expression to substrait we can allow interoperability with other libraries.

Originally it was thought this would not be needed because users would be sending entire query plans (which contain expressions) back and forth and so there was no need to work with expressions by themselves.

However, as more and more APIs and integration points emerge it turns out there are situations where serializing expressions by themselves is useful.  For example, the proposed datasets protocol, or for the Java JNI datasets implementation (which uses Arrow-C++'s datasets)

### What changes are included in this PR?

In Arrow-C++ we add two new methods to serialize and deserialize a collection of named, bound expressions to Substrait's ExtendedExpression message.

In pyarrow we expose these two methods and also add utility methods to pyarrow.compute.Expression to convert a single expression to/from substrait (these will be encoded as an ExtendedExpression message with one expression named "expression")

In addition, this PR exposed that we do not have very many bindings for arrow-functions to substrait-functions (previous work has mostly focused on the reverse direction).  This PR adds many (though not all) new bindings.

In addition, this PR adds ToProto for cast and both FromProto and ToProto support for the SingularOrList expression type (we convert is_in to SingularOrList and convert SingularOrList to an or list).

This should provide support for all the sargable operators except between (there is no Arrow-C++ between function) and like (we still don't have arrow->substrait bindings for the string functions) which should be a sufficient set of expressions for a first release.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

There are new features, as described above, but no backwards incompatible changes.

### Caveats

There are a fair number of minor inconsistencies or surprises, many of which can be smoothed over by follow-up work.

#### Bound Expressions

Arrow-C++ has long had a distinction between "unbound expressions" (e.g. `a + b`) and "bound expressions" (e.g. `a:i32 + b:i32`).  A bound expression is an expression that has been bound to a schema of some kind.  Field references are resolved and the output type is known for every node of the AST.

Pyarrow has hidden this complexity and most pyarrow compute expressions that the user encounters will be unbound expressions.  Substrait is only capable (currently) of representing bound expressions.  As a result, in order to serialize expressions, the user will need to provide an input schema.  This can be an inconvenience for some workflows.  To resolve this, I would like to eventually add support for unbound expressions to Substrait (https://github.com/substrait-io/substrait/issues/515)

Another minor annoyance of bound expressions is that an unbound pyarrow.compute.Expression object will not be equal to a bound pyarrow.compute.Expression object.  It would make testing easier if we had a `pyarrow.compute.Expression.equals` variant that did not examine bound fields.

#### Named field references

Pyarrow datasets users are used to working with named field references.  For example, one can set a filter `pc.equal(ds.field("x"), 7)`.  Substrait, since it requires everything to be bound, considers named references to be superfluous and does everything in terms of numeric indices into the base schema.  So the above expression, after round tripping, would become something like `pc.equal(ds.field(3), 7)` (assuming `"x"` is at index `3` in the schema used for serialization).  This is something that can be overcome in the future if Substrait adds support for unbound expressions.  Or, if that doesn't happen, it could still be implemented as a Substrait expression hint (this would allow named references to be used even if the user wants to work with bound expressions).

#### UDFs

UDFs ARE supported by this PR.  This covers both "builtin arrow functions that do not exist in substrait (e.g. shift_left)" and "custom UDFs added with `register_scalar_function`".  By default, UDFs will not be allowed when converting to Substrait because the resulting message would not be portable (e.g. you can't expect an external system to know about your custom UDFs).  However, you can set the `allow_udfs` flag to True and these will be allowed.  The Substrait representation will have the URI `urn:arrow:substrait_simple_extension_function`.

**Options**: Although UDFs are allowed we do not yet support UDFs that take function options.  These are trickier to convert to Substrait (though it should be possible in the future if someone is motivated enough).

#### Rough Edges

There are a few corner cases:

 * The function `is_in` converts to Substrait's `SingularOrList`.  On conversion back to Arrow this becomes an or list.  In other words, the function `is_in(5, [1, 2, 5])` converts to `5 == 1 || 5 == 2 || 5 == 5`.  This is because Substrait's or list is more expression and allows things like `5 == field_ref(0) || 5 == 7` which cannot be expressed as an `is_in` function.
 * Arrow functions can either be converted to Substrait or are considered UDFs.  However, there are a small number of functions which can "sometimes" be converted to Substrait depending on the function options.  At the moment I think this is only the `is_null` function.  The `is_null` function has an option `nan_is_null` which will allow you to consider `NaN` as a null value.  Substrait has no single function that evaluates both `NULL` and `NaN` as true.  In the meantime you can use `is_null || is_nan`.  In the future, should someone want to, they could add special logic to convert this case.
* Closes: #33985

Lead-authored-by: Weston Pace <weston.pace@gmail.com>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake   |   7 +-
 cpp/src/arrow/compute/cast.cc                 |  10 +
 cpp/src/arrow/compute/cast.h                  |   9 +
 cpp/src/arrow/engine/CMakeLists.txt           |   1 +
 .../engine/substrait/expression_internal.cc   | 162 +++++++++++++-
 .../substrait/extended_expression_internal.cc | 210 ++++++++++++++++++
 .../substrait/extended_expression_internal.h  |  51 +++++
 .../arrow/engine/substrait/extension_set.cc   | 112 ++++++++--
 .../arrow/engine/substrait/extension_set.h    |  12 +
 cpp/src/arrow/engine/substrait/options.h      |   8 +-
 .../arrow/engine/substrait/plan_internal.cc   | 114 +---------
 cpp/src/arrow/engine/substrait/relation.h     |  17 ++
 cpp/src/arrow/engine/substrait/serde.cc       |  42 ++--
 cpp/src/arrow/engine/substrait/serde.h        |  28 +++
 cpp/src/arrow/engine/substrait/serde_test.cc  |  95 ++++++++
 cpp/src/arrow/engine/substrait/util.cc        |  10 +
 cpp/src/arrow/engine/substrait/util.h         |  10 +
 .../arrow/engine/substrait/util_internal.cc   |  12 +
 .../arrow/engine/substrait/util_internal.h    | 114 ++++++++++
 cpp/thirdparty/versions.txt                   |   4 +-
 docs/source/python/api/substrait.rst          |  13 ++
 python/pyarrow/_compute.pyx                   |  69 ++++++
 python/pyarrow/_substrait.pyx                 | 141 +++++++++++-
 .../pyarrow/includes/libarrow_substrait.pxd   |  18 ++
 python/pyarrow/substrait.py                   |   3 +
 python/pyarrow/tests/test_compute.py          | 142 +++++++++++-
 python/pyarrow/tests/test_substrait.py        | 107 ++++++++-
 27 files changed, 1363 insertions(+), 158 deletions(-)
 create mode 100644 cpp/src/arrow/engine/substrait/extended_expression_internal.cc
 create mode 100644 cpp/src/arrow/engine/substrait/extended_expression_internal.h

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 4422e17e85cb6..1767c05b5ee3a 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -1785,7 +1785,12 @@ macro(build_substrait)
 
   # Note: not all protos in Substrait actually matter to plan
   # consumption. No need to build the ones we don't need.
-  set(SUBSTRAIT_PROTOS algebra extensions/extensions plan type)
+  set(SUBSTRAIT_PROTOS
+      algebra
+      extended_expression
+      extensions/extensions
+      plan
+      type)
   set(ARROW_SUBSTRAIT_PROTOS extension_rels)
   set(ARROW_SUBSTRAIT_PROTOS_DIR "${CMAKE_SOURCE_DIR}/proto")
 
diff --git a/cpp/src/arrow/compute/cast.cc b/cpp/src/arrow/compute/cast.cc
index 13bf6f85a4874..232638b7fc738 100644
--- a/cpp/src/arrow/compute/cast.cc
+++ b/cpp/src/arrow/compute/cast.cc
@@ -223,6 +223,16 @@ CastOptions::CastOptions(bool safe)
       allow_float_truncate(!safe),
       allow_invalid_utf8(!safe) {}
 
+bool CastOptions::is_safe() const {
+  return !allow_int_overflow && !allow_time_truncate && !allow_time_overflow &&
+         !allow_decimal_truncate && !allow_float_truncate && !allow_invalid_utf8;
+}
+
+bool CastOptions::is_unsafe() const {
+  return allow_int_overflow && allow_time_truncate && allow_time_overflow &&
+         allow_decimal_truncate && allow_float_truncate && allow_invalid_utf8;
+}
+
 constexpr char CastOptions::kTypeName[];
 
 Result<Datum> Cast(const Datum& value, const CastOptions& options, ExecContext* ctx) {
diff --git a/cpp/src/arrow/compute/cast.h b/cpp/src/arrow/compute/cast.h
index 7432933a12469..613e8a55addd2 100644
--- a/cpp/src/arrow/compute/cast.h
+++ b/cpp/src/arrow/compute/cast.h
@@ -69,6 +69,15 @@ class ARROW_EXPORT CastOptions : public FunctionOptions {
   // Indicate if conversions from Binary/FixedSizeBinary to string must
   // validate the utf8 payload.
   bool allow_invalid_utf8;
+
+  /// true if the safety options all match CastOptions::Safe
+  ///
+  /// Note, if this returns false it does not mean is_unsafe will return true
+  bool is_safe() const;
+  /// true if the safety options all match CastOptions::Unsafe
+  ///
+  /// Note, if this returns false it does not mean is_safe will return true
+  bool is_unsafe() const;
 };
 
 /// @}
diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt
index 7494be8ebb19c..fcaa242b11487 100644
--- a/cpp/src/arrow/engine/CMakeLists.txt
+++ b/cpp/src/arrow/engine/CMakeLists.txt
@@ -21,6 +21,7 @@ arrow_install_all_headers("arrow/engine")
 
 set(ARROW_SUBSTRAIT_SRCS
     substrait/expression_internal.cc
+    substrait/extended_expression_internal.cc
     substrait/extension_set.cc
     substrait/extension_types.cc
     substrait/options.cc
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc
index 5e214bdda4d4a..0df8425609ff1 100644
--- a/cpp/src/arrow/engine/substrait/expression_internal.cc
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -41,6 +41,7 @@
 #include "arrow/buffer.h"
 #include "arrow/builder.h"
 #include "arrow/compute/api_scalar.h"
+#include "arrow/compute/cast.h"
 #include "arrow/compute/expression.h"
 #include "arrow/compute/expression_internal.h"
 #include "arrow/engine/substrait/extension_set.h"
@@ -338,6 +339,22 @@ Result<compute::Expression> FromProto(const substrait::Expression& expr,
       return compute::call("case_when", std::move(args));
     }
 
+    case substrait::Expression::kSingularOrList: {
+      const auto& or_list = expr.singular_or_list();
+
+      ARROW_ASSIGN_OR_RAISE(compute::Expression value,
+                            FromProto(or_list.value(), ext_set, conversion_options));
+
+      std::vector<compute::Expression> option_eqs;
+      for (const auto& option : or_list.options()) {
+        ARROW_ASSIGN_OR_RAISE(compute::Expression arrow_option,
+                              FromProto(option, ext_set, conversion_options));
+        option_eqs.push_back(compute::call("equal", {value, arrow_option}));
+      }
+
+      return compute::or_(option_eqs);
+    }
+
     case substrait::Expression::kScalarFunction: {
       const auto& scalar_fn = expr.scalar_function();
 
@@ -1055,9 +1072,68 @@ Result<std::unique_ptr<substrait::Expression::ScalarFunction>> EncodeSubstraitCa
                              " arguments but no argument could be found at index ", i);
     }
   }
+
+  for (const auto& option : call.options()) {
+    substrait::FunctionOption* fn_option = scalar_fn->add_options();
+    fn_option->set_name(option.first);
+    for (const auto& opt_val : option.second) {
+      std::string* pref = fn_option->add_preference();
+      *pref = opt_val;
+    }
+  }
+
   return std::move(scalar_fn);
 }
 
+Result<std::vector<std::unique_ptr<substrait::Expression>>> DatumToLiterals(
+    const Datum& datum, ExtensionSet* ext_set,
+    const ConversionOptions& conversion_options) {
+  std::vector<std::unique_ptr<substrait::Expression>> literals;
+
+  auto ScalarToLiteralExpr = [&](const std::shared_ptr<Scalar>& scalar)
+      -> Result<std::unique_ptr<substrait::Expression>> {
+    ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::Expression::Literal> literal,
+                          ToProto(scalar, ext_set, conversion_options));
+    auto literal_expr = std::make_unique<substrait::Expression>();
+    literal_expr->set_allocated_literal(literal.release());
+    return literal_expr;
+  };
+
+  switch (datum.kind()) {
+    case Datum::Kind::SCALAR: {
+      ARROW_ASSIGN_OR_RAISE(auto literal_expr, ScalarToLiteralExpr(datum.scalar()));
+      literals.push_back(std::move(literal_expr));
+      break;
+    }
+    case Datum::Kind::ARRAY: {
+      std::shared_ptr<Array> values = datum.make_array();
+      for (int64_t i = 0; i < values->length(); i++) {
+        ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Scalar> scalar, values->GetScalar(i));
+        ARROW_ASSIGN_OR_RAISE(auto literal_expr, ScalarToLiteralExpr(scalar));
+        literals.push_back(std::move(literal_expr));
+      }
+      break;
+    }
+    case Datum::Kind::CHUNKED_ARRAY: {
+      std::shared_ptr<ChunkedArray> values = datum.chunked_array();
+      for (const auto& chunk : values->chunks()) {
+        for (int64_t i = 0; i < chunk->length(); i++) {
+          ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Scalar> scalar, chunk->GetScalar(i));
+          ARROW_ASSIGN_OR_RAISE(auto literal_expr, ScalarToLiteralExpr(scalar));
+          literals.push_back(std::move(literal_expr));
+        }
+      }
+      break;
+    }
+    case Datum::Kind::RECORD_BATCH:
+    case Datum::Kind::TABLE:
+    case Datum::Kind::NONE:
+      return Status::Invalid("Expected a literal or an array of literals, got ",
+                             datum.ToString());
+  }
+  return literals;
+}
+
 Result<std::unique_ptr<substrait::Expression>> ToProto(
     const compute::Expression& expr, ExtensionSet* ext_set,
     const ConversionOptions& conversion_options) {
@@ -1164,15 +1240,89 @@ Result<std::unique_ptr<substrait::Expression>> ToProto(
 
     out->set_allocated_if_then(if_then.release());
     return std::move(out);
+  } else if (call->function_name == "cast") {
+    auto cast = std::make_unique<substrait::Expression::Cast>();
+
+    // Arrow's cast function does not have a "return null" option and so throw exception
+    // is the only behavior we can support.
+    cast->set_failure_behavior(
+        substrait::Expression::Cast::FAILURE_BEHAVIOR_THROW_EXCEPTION);
+
+    std::shared_ptr<compute::CastOptions> cast_options =
+        internal::checked_pointer_cast<compute::CastOptions>(call->options);
+    if (!cast_options->is_unsafe()) {
+      return Status::Invalid("Substrait is only capable of representing unsafe casts");
+    }
+
+    if (arguments.size() != 1) {
+      return Status::Invalid(
+          "A call to the cast function must have exactly one argument");
+    }
+
+    cast->set_allocated_input(arguments[0].release());
+
+    ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::Type> to_type,
+                          ToProto(*cast_options->to_type.type, /*nullable=*/true, ext_set,
+                                  conversion_options));
+
+    cast->set_allocated_type(to_type.release());
+
+    out->set_allocated_cast(cast.release());
+    return std::move(out);
+  } else if (call->function_name == "is_in") {
+    auto or_list = std::make_unique<substrait::Expression::SingularOrList>();
+
+    if (arguments.size() != 1) {
+      return Status::Invalid(
+          "A call to the is_in function must have exactly one argument");
+    }
+
+    or_list->set_allocated_value(arguments[0].release());
+    std::shared_ptr<compute::SetLookupOptions> is_in_options =
+        internal::checked_pointer_cast<compute::SetLookupOptions>(call->options);
+
+    // TODO(GH-36420) Acero does not currently handle nulls correctly
+    ARROW_ASSIGN_OR_RAISE(
+        std::vector<std::unique_ptr<substrait::Expression>> options,
+        DatumToLiterals(is_in_options->value_set, ext_set, conversion_options));
+    for (auto& option : options) {
+      or_list->mutable_options()->AddAllocated(option.release());
+    }
+    out->set_allocated_singular_or_list(or_list.release());
+    return std::move(out);
   }
 
   // other expression types dive into extensions immediately
-  ARROW_ASSIGN_OR_RAISE(
-      ExtensionIdRegistry::ArrowToSubstraitCall converter,
-      ext_set->registry()->GetArrowToSubstraitCall(call->function_name));
-  ARROW_ASSIGN_OR_RAISE(SubstraitCall substrait_call, converter(*call));
-  ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::Expression::ScalarFunction> scalar_fn,
-                        EncodeSubstraitCall(substrait_call, ext_set, conversion_options));
+  Result<ExtensionIdRegistry::ArrowToSubstraitCall> maybe_converter =
+      ext_set->registry()->GetArrowToSubstraitCall(call->function_name);
+
+  ExtensionIdRegistry::ArrowToSubstraitCall converter;
+  std::unique_ptr<substrait::Expression::ScalarFunction> scalar_fn;
+  if (maybe_converter.ok()) {
+    converter = *maybe_converter;
+    ARROW_ASSIGN_OR_RAISE(SubstraitCall substrait_call, converter(*call));
+    ARROW_ASSIGN_OR_RAISE(
+        scalar_fn, EncodeSubstraitCall(substrait_call, ext_set, conversion_options));
+  } else if (maybe_converter.status().IsNotImplemented() &&
+             conversion_options.allow_arrow_extensions) {
+    if (call->options) {
+      return Status::NotImplemented(
+          "The function ", call->function_name,
+          " has no Substrait mapping.  Arrow extensions are enabled but the call "
+          "contains function options and there is no current mechanism to encode those.");
+    }
+    Id persistent_id = ext_set->RegisterPlanSpecificId(
+        {kArrowSimpleExtensionFunctionsUri, call->function_name});
+    SubstraitCall substrait_call(persistent_id, call->type.GetSharedPtr(),
+                                 /*nullable=*/true);
+    for (int i = 0; i < static_cast<int>(call->arguments.size()); i++) {
+      substrait_call.SetValueArg(i, call->arguments[i]);
+    }
+    ARROW_ASSIGN_OR_RAISE(
+        scalar_fn, EncodeSubstraitCall(substrait_call, ext_set, conversion_options));
+  } else {
+    return maybe_converter.status();
+  }
   out->set_allocated_scalar_function(scalar_fn.release());
   return std::move(out);
 }
diff --git a/cpp/src/arrow/engine/substrait/extended_expression_internal.cc b/cpp/src/arrow/engine/substrait/extended_expression_internal.cc
new file mode 100644
index 0000000000000..a6401e1d0b36d
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extended_expression_internal.cc
@@ -0,0 +1,210 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT 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 API is EXPERIMENTAL.
+
+#include "arrow/engine/substrait/extended_expression_internal.h"
+
+#include "arrow/engine/substrait/expression_internal.h"
+#include "arrow/engine/substrait/relation_internal.h"
+#include "arrow/engine/substrait/type_internal.h"
+#include "arrow/engine/substrait/util.h"
+#include "arrow/engine/substrait/util_internal.h"
+#include "arrow/status.h"
+#include "arrow/util/iterator.h"
+#include "arrow/util/string.h"
+
+namespace arrow {
+namespace engine {
+
+namespace {
+Result<ExtensionSet> GetExtensionSetFromExtendedExpression(
+    const substrait::ExtendedExpression& expr,
+    const ConversionOptions& conversion_options, const ExtensionIdRegistry* registry) {
+  return GetExtensionSetFromMessage(expr, conversion_options, registry);
+}
+
+Status AddExtensionSetToExtendedExpression(const ExtensionSet& ext_set,
+                                           substrait::ExtendedExpression* expr) {
+  return AddExtensionSetToMessage(ext_set, expr);
+}
+
+Status VisitNestedFields(const DataType& type,
+                         std::function<Status(const Field&)> visitor) {
+  if (!is_nested(type.id())) {
+    return Status::OK();
+  }
+  for (const auto& field : type.fields()) {
+    ARROW_RETURN_NOT_OK(VisitNestedFields(*field->type(), visitor));
+    ARROW_RETURN_NOT_OK(visitor(*field));
+  }
+  return Status::OK();
+}
+
+Result<NamedExpression> ExpressionFromProto(
+    const substrait::ExpressionReference& expression, const Schema& input_schema,
+    const ExtensionSet& ext_set, const ConversionOptions& conversion_options,
+    const ExtensionIdRegistry* registry) {
+  NamedExpression named_expr;
+  switch (expression.expr_type_case()) {
+    case substrait::ExpressionReference::ExprTypeCase::kExpression: {
+      ARROW_ASSIGN_OR_RAISE(
+          named_expr.expression,
+          FromProto(expression.expression(), ext_set, conversion_options));
+      break;
+    }
+    case substrait::ExpressionReference::ExprTypeCase::kMeasure: {
+      return Status::NotImplemented("ExtendedExpression containing aggregate functions");
+    }
+    default: {
+      return Status::Invalid(
+          "Unrecognized substrait::ExpressionReference::ExprTypeCase: ",
+          expression.expr_type_case());
+    }
+  }
+
+  ARROW_ASSIGN_OR_RAISE(named_expr.expression, named_expr.expression.Bind(input_schema));
+  const DataType& output_type = *named_expr.expression.type();
+
+  // An expression reference has the entire DFS tree of field names for the output type
+  // which is usually redundant.  Then it has one extra name for the name of the
+  // expression which is not redundant.
+  //
+  // For example, if the base schema is [struct<foo:i32>, i32] and the expression is
+  // field(0) the the extended expression output names might be ["foo", "my_expression"].
+  // The "foo" is redundant but we can verify it matches and reject if it does not.
+  //
+  // The one exception is struct literals which have no field names.  For example, if
+  // the base schema is [i32, i64] and the expression is {7, 3}_struct<i8,i8> then the
+  // output type is struct<?:i8, ?:i8> and we do not know the names of the output type.
+  //
+  // TODO(weston) we could patch the names back in at this point using the output
+  // names field but this is rather complex and it might be easier to give names to
+  // struct literals in Substrait.
+  int output_name_idx = 0;
+  ARROW_RETURN_NOT_OK(VisitNestedFields(output_type, [&](const Field& field) {
+    if (output_name_idx >= expression.output_names_size()) {
+      return Status::Invalid("Ambiguous plan.  Expression had ",
+                             expression.output_names_size(),
+                             " output names but the field in base_schema had type ",
+                             output_type.ToString(), " which needs more output names");
+    }
+    if (!field.name().empty() &&
+        field.name() != expression.output_names(output_name_idx)) {
+      return Status::Invalid("Ambiguous plan.  Expression had output type ",
+                             output_type.ToString(),
+                             " which contains a nested field named ", field.name(),
+                             " but the output_names in the Substrait message contained ",
+                             expression.output_names(output_name_idx));
+    }
+    output_name_idx++;
+    return Status::OK();
+  }));
+  // The last name is the actual field name that we can't verify but there should only
+  // be one extra name.
+  if (output_name_idx < expression.output_names_size() - 1) {
+    return Status::Invalid("Ambiguous plan.  Expression had ",
+                           expression.output_names_size(),
+                           " output names but the field in base_schema had type ",
+                           output_type.ToString(), " which doesn't have enough fields");
+  }
+  if (expression.output_names_size() == 0) {
+    // This is potentially invalid substrait but we can handle it
+    named_expr.name = "";
+  } else {
+    named_expr.name = expression.output_names(expression.output_names_size() - 1);
+  }
+  return named_expr;
+}
+
+Result<std::unique_ptr<substrait::ExpressionReference>> CreateExpressionReference(
+    const std::string& name, const Expression& expr, ExtensionSet* ext_set,
+    const ConversionOptions& conversion_options) {
+  auto expr_ref = std::make_unique<substrait::ExpressionReference>();
+  ARROW_RETURN_NOT_OK(VisitNestedFields(*expr.type(), [&](const Field& field) {
+    expr_ref->add_output_names(field.name());
+    return Status::OK();
+  }));
+  expr_ref->add_output_names(name);
+  ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::Expression> expression,
+                        ToProto(expr, ext_set, conversion_options));
+  expr_ref->set_allocated_expression(expression.release());
+  return std::move(expr_ref);
+}
+
+}  // namespace
+
+Result<BoundExpressions> FromProto(const substrait::ExtendedExpression& expression,
+                                   ExtensionSet* ext_set_out,
+                                   const ConversionOptions& conversion_options,
+                                   const ExtensionIdRegistry* registry) {
+  BoundExpressions bound_expressions;
+  ARROW_RETURN_NOT_OK(CheckVersion(expression.version().major_number(),
+                                   expression.version().minor_number()));
+  if (expression.has_advanced_extensions()) {
+    return Status::NotImplemented("Advanced extensions in ExtendedExpression");
+  }
+  ARROW_ASSIGN_OR_RAISE(
+      ExtensionSet ext_set,
+      GetExtensionSetFromExtendedExpression(expression, conversion_options, registry));
+
+  ARROW_ASSIGN_OR_RAISE(bound_expressions.schema,
+                        FromProto(expression.base_schema(), ext_set, conversion_options));
+
+  bound_expressions.named_expressions.reserve(expression.referred_expr_size());
+
+  for (const auto& referred_expr : expression.referred_expr()) {
+    ARROW_ASSIGN_OR_RAISE(NamedExpression named_expr,
+                          ExpressionFromProto(referred_expr, *bound_expressions.schema,
+                                              ext_set, conversion_options, registry));
+    bound_expressions.named_expressions.push_back(std::move(named_expr));
+  }
+
+  if (ext_set_out) {
+    *ext_set_out = std::move(ext_set);
+  }
+
+  return std::move(bound_expressions);
+}
+
+Result<std::unique_ptr<substrait::ExtendedExpression>> ToProto(
+    const BoundExpressions& bound_expressions, ExtensionSet* ext_set,
+    const ConversionOptions& conversion_options) {
+  auto expression = std::make_unique<substrait::ExtendedExpression>();
+  expression->set_allocated_version(CreateVersion().release());
+  ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::NamedStruct> base_schema,
+                        ToProto(*bound_expressions.schema, ext_set, conversion_options));
+  expression->set_allocated_base_schema(base_schema.release());
+  for (const auto& named_expression : bound_expressions.named_expressions) {
+    Expression bound_expr = named_expression.expression;
+    if (!bound_expr.IsBound()) {
+      // This will use the default function registry.  Most of the time that will be fine.
+      // In the cases where this is not what the user wants then the user should make sure
+      // to pass in bound expressions.
+      ARROW_ASSIGN_OR_RAISE(bound_expr, bound_expr.Bind(*bound_expressions.schema));
+    }
+    ARROW_ASSIGN_OR_RAISE(std::unique_ptr<substrait::ExpressionReference> expr_ref,
+                          CreateExpressionReference(named_expression.name, bound_expr,
+                                                    ext_set, conversion_options));
+    expression->mutable_referred_expr()->AddAllocated(expr_ref.release());
+  }
+  RETURN_NOT_OK(AddExtensionSetToExtendedExpression(*ext_set, expression.get()));
+  return std::move(expression);
+}
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extended_expression_internal.h b/cpp/src/arrow/engine/substrait/extended_expression_internal.h
new file mode 100644
index 0000000000000..81bc4b8745186
--- /dev/null
+++ b/cpp/src/arrow/engine/substrait/extended_expression_internal.h
@@ -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.
+
+// This API is EXPERIMENTAL.
+
+#pragma once
+
+#include <memory>
+
+#include "arrow/compute/type_fwd.h"
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/substrait/options.h"
+#include "arrow/engine/substrait/relation.h"
+#include "arrow/engine/substrait/visibility.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+
+#include "substrait/extended_expression.pb.h"  // IWYU pragma: export
+
+namespace arrow {
+namespace engine {
+
+/// Convert a Substrait ExtendedExpression to a vector of expressions and output names
+ARROW_ENGINE_EXPORT
+Result<BoundExpressions> FromProto(const substrait::ExtendedExpression& expression,
+                                   ExtensionSet* ext_set_out,
+                                   const ConversionOptions& conversion_options,
+                                   const ExtensionIdRegistry* extension_id_registry);
+
+/// Convert a vector of expressions to a Substrait ExtendedExpression
+ARROW_ENGINE_EXPORT
+Result<std::unique_ptr<substrait::ExtendedExpression>> ToProto(
+    const BoundExpressions& bound_expressions, ExtensionSet* ext_set,
+    const ConversionOptions& conversion_options);
+
+}  // namespace engine
+}  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc
index d89248383b722..b0dd6aeffbcfa 100644
--- a/cpp/src/arrow/engine/substrait/extension_set.cc
+++ b/cpp/src/arrow/engine/substrait/extension_set.cc
@@ -28,12 +28,15 @@
 #include "arrow/engine/substrait/options.h"
 #include "arrow/type.h"
 #include "arrow/type_fwd.h"
+#include "arrow/util/checked_cast.h"
 #include "arrow/util/hash_util.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/string.h"
 
 namespace arrow {
+
+using internal::checked_pointer_cast;
 namespace engine {
 namespace {
 
@@ -229,6 +232,8 @@ Status ExtensionSet::AddUri(Id id) {
   return Status::OK();
 }
 
+Id ExtensionSet::RegisterPlanSpecificId(Id id) { return plan_specific_ids_->Emplace(id); }
+
 // Creates an extension set from the Substrait plan's top-level extensions block
 Result<ExtensionSet> ExtensionSet::Make(
     std::unordered_map<uint32_t, std::string_view> uris,
@@ -873,11 +878,10 @@ ExtensionIdRegistry::ArrowToSubstraitCall EncodeOptionlessOverflowableArithmetic
       };
 }
 
-ExtensionIdRegistry::ArrowToSubstraitCall EncodeOptionlessComparison(Id substrait_fn_id) {
+ExtensionIdRegistry::ArrowToSubstraitCall EncodeBasic(Id substrait_fn_id) {
   return
       [substrait_fn_id](const compute::Expression::Call& call) -> Result<SubstraitCall> {
-        // nullable=true isn't quite correct but we don't know the nullability of
-        // the inputs
+        // nullable=true errs on the side of caution
         SubstraitCall substrait_call(substrait_fn_id, call.type.GetSharedPtr(),
                                      /*nullable=*/true);
         for (std::size_t i = 0; i < call.arguments.size(); i++) {
@@ -887,11 +891,31 @@ ExtensionIdRegistry::ArrowToSubstraitCall EncodeOptionlessComparison(Id substrai
       };
 }
 
+ExtensionIdRegistry::ArrowToSubstraitCall EncodeIsNull(Id substrait_fn_id) {
+  return
+      [substrait_fn_id](const compute::Expression::Call& call) -> Result<SubstraitCall> {
+        if (call.options != nullptr) {
+          auto null_opts = checked_pointer_cast<compute::NullOptions>(call.options);
+          if (null_opts->nan_is_null) {
+            return Status::Invalid(
+                "Substrait does not support is_null with nan_is_null=true.  You can use "
+                "is_null || is_nan instead");
+          }
+        }
+        SubstraitCall substrait_call(substrait_fn_id, call.type.GetSharedPtr(),
+                                     /*nullable=*/false);
+        for (std::size_t i = 0; i < call.arguments.size(); i++) {
+          substrait_call.SetValueArg(static_cast<int>(i), call.arguments[i]);
+        }
+        return std::move(substrait_call);
+      };
+}
+
 ExtensionIdRegistry::SubstraitCallToArrow DecodeOptionlessBasicMapping(
     const std::string& function_name, int max_args) {
   return [function_name,
           max_args](const SubstraitCall& call) -> Result<compute::Expression> {
-    if (call.size() > max_args) {
+    if (max_args >= 0 && call.size() > max_args) {
       return Status::NotImplemented("Acero does not have a kernel for ", function_name,
                                     " that receives ", call.size(), " arguments");
     }
@@ -1033,14 +1057,15 @@ struct DefaultExtensionIdRegistry : ExtensionIdRegistryImpl {
     // -------------- Substrait -> Arrow Functions -----------------
     // Mappings with a _checked variant
     for (const auto& function_name :
-         {"add", "subtract", "multiply", "divide", "power", "sqrt", "abs"}) {
+         {"add", "subtract", "multiply", "divide", "negate", "power", "sqrt", "abs"}) {
       DCHECK_OK(
           AddSubstraitCallToArrow({kSubstraitArithmeticFunctionsUri, function_name},
                                   DecodeOptionlessOverflowableArithmetic(function_name)));
     }
 
-    // Mappings without a _checked variant
-    for (const auto& function_name : {"exp", "sign"}) {
+    // Mappings either without a _checked variant or substrait has no overflow option
+    for (const auto& function_name :
+         {"exp", "sign", "cos", "sin", "tan", "acos", "asin", "atan", "atan2"}) {
       DCHECK_OK(
           AddSubstraitCallToArrow({kSubstraitArithmeticFunctionsUri, function_name},
                                   DecodeOptionlessUncheckedArithmetic(function_name)));
@@ -1096,6 +1121,21 @@ struct DefaultExtensionIdRegistry : ExtensionIdRegistryImpl {
     DCHECK_OK(
         AddSubstraitCallToArrow({kSubstraitBooleanFunctionsUri, "not"},
                                 DecodeOptionlessBasicMapping("invert", /*max_args=*/1)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitArithmeticFunctionsUri, "bitwise_not"},
+        DecodeOptionlessBasicMapping("bit_wise_not", /*max_args=*/1)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitArithmeticFunctionsUri, "bitwise_or"},
+        DecodeOptionlessBasicMapping("bit_wise_or", /*max_args=*/2)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitArithmeticFunctionsUri, "bitwise_and"},
+        DecodeOptionlessBasicMapping("bit_wise_and", /*max_args=*/2)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitArithmeticFunctionsUri, "bitwise_xor"},
+        DecodeOptionlessBasicMapping("bit_wise_xor", /*max_args=*/2)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitComparisonFunctionsUri, "coalesce"},
+        DecodeOptionlessBasicMapping("coalesce", /*max_args=*/-1)));
     DCHECK_OK(AddSubstraitCallToArrow({kSubstraitDatetimeFunctionsUri, "extract"},
                                       DecodeTemporalExtractionMapping()));
     DCHECK_OK(AddSubstraitCallToArrow({kSubstraitStringFunctionsUri, "concat"},
@@ -1103,6 +1143,12 @@ struct DefaultExtensionIdRegistry : ExtensionIdRegistryImpl {
     DCHECK_OK(
         AddSubstraitCallToArrow({kSubstraitComparisonFunctionsUri, "is_null"},
                                 DecodeOptionlessBasicMapping("is_null", /*max_args=*/1)));
+    DCHECK_OK(
+        AddSubstraitCallToArrow({kSubstraitComparisonFunctionsUri, "is_nan"},
+                                DecodeOptionlessBasicMapping("is_nan", /*max_args=*/1)));
+    DCHECK_OK(AddSubstraitCallToArrow(
+        {kSubstraitComparisonFunctionsUri, "is_finite"},
+        DecodeOptionlessBasicMapping("is_finite", /*max_args=*/1)));
     DCHECK_OK(AddSubstraitCallToArrow(
         {kSubstraitComparisonFunctionsUri, "is_not_null"},
         DecodeOptionlessBasicMapping("is_valid", /*max_args=*/1)));
@@ -1127,7 +1173,9 @@ struct DefaultExtensionIdRegistry : ExtensionIdRegistryImpl {
     }
 
     // --------------- Arrow -> Substrait Functions ---------------
-    for (const auto& fn_name : {"add", "subtract", "multiply", "divide"}) {
+    // Functions with a _checked variant
+    for (const auto& fn_name :
+         {"add", "subtract", "multiply", "divide", "negate", "power", "abs"}) {
       Id fn_id{kSubstraitArithmeticFunctionsUri, fn_name};
       DCHECK_OK(AddArrowToSubstraitCall(
           fn_name, EncodeOptionlessOverflowableArithmetic<false>(fn_id)));
@@ -1135,11 +1183,49 @@ struct DefaultExtensionIdRegistry : ExtensionIdRegistryImpl {
           AddArrowToSubstraitCall(std::string(fn_name) + "_checked",
                                   EncodeOptionlessOverflowableArithmetic<true>(fn_id)));
     }
-    // Comparison operators
-    for (const auto& fn_name : {"equal", "is_not_distinct_from"}) {
-      Id fn_id{kSubstraitComparisonFunctionsUri, fn_name};
-      DCHECK_OK(AddArrowToSubstraitCall(fn_name, EncodeOptionlessComparison(fn_id)));
-    }
+    // Functions with no options...
+    //   ...and the same name
+    for (const auto& fn_pair : std::vector<std::pair<std::string_view, std::string_view>>{
+             {kSubstraitComparisonFunctionsUri, "equal"},
+             {kSubstraitComparisonFunctionsUri, "not_equal"},
+             {kSubstraitComparisonFunctionsUri, "is_not_distinct_from"},
+             {kSubstraitComparisonFunctionsUri, "is_nan"},
+             {kSubstraitComparisonFunctionsUri, "is_finite"},
+             {kSubstraitComparisonFunctionsUri, "coalesce"},
+             {kSubstraitArithmeticFunctionsUri, "sqrt"},
+             {kSubstraitArithmeticFunctionsUri, "sign"},
+             {kSubstraitArithmeticFunctionsUri, "exp"},
+             {kSubstraitArithmeticFunctionsUri, "cos"},
+             {kSubstraitArithmeticFunctionsUri, "sin"},
+             {kSubstraitArithmeticFunctionsUri, "tan"},
+             {kSubstraitArithmeticFunctionsUri, "acos"},
+             {kSubstraitArithmeticFunctionsUri, "asin"},
+             {kSubstraitArithmeticFunctionsUri, "atan"},
+             {kSubstraitArithmeticFunctionsUri, "atan2"}}) {
+      Id fn_id{fn_pair.first, fn_pair.second};
+      DCHECK_OK(AddArrowToSubstraitCall(std::string(fn_pair.second), EncodeBasic(fn_id)));
+    }
+    //   ...and different names
+    for (const auto& fn_triple :
+         std::vector<std::tuple<std::string_view, std::string_view, std::string>>{
+             {kSubstraitComparisonFunctionsUri, "lt", "less"},
+             {kSubstraitComparisonFunctionsUri, "gt", "greater"},
+             {kSubstraitComparisonFunctionsUri, "lte", "less_equal"},
+             {kSubstraitComparisonFunctionsUri, "gte", "greater_equal"},
+             {kSubstraitComparisonFunctionsUri, "is_not_null", "is_valid"},
+             {kSubstraitArithmeticFunctionsUri, "bitwise_and", "bit_wise_and"},
+             {kSubstraitArithmeticFunctionsUri, "bitwise_not", "bit_wise_not"},
+             {kSubstraitArithmeticFunctionsUri, "bitwise_or", "bit_wise_or"},
+             {kSubstraitArithmeticFunctionsUri, "bitwise_xor", "bit_wise_xor"},
+             {kSubstraitBooleanFunctionsUri, "and", "and_kleene"},
+             {kSubstraitBooleanFunctionsUri, "or", "or_kleene"},
+             {kSubstraitBooleanFunctionsUri, "not", "invert"}}) {
+      Id fn_id{std::get<0>(fn_triple), std::get<1>(fn_triple)};
+      DCHECK_OK(AddArrowToSubstraitCall(std::get<2>(fn_triple), EncodeBasic(fn_id)));
+    }
+
+    DCHECK_OK(AddArrowToSubstraitCall(
+        "is_null", EncodeIsNull({kSubstraitComparisonFunctionsUri, "is_null"})));
   }
 };
 
diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h
index 50e0b11943f61..d9c0af081a546 100644
--- a/cpp/src/arrow/engine/substrait/extension_set.h
+++ b/cpp/src/arrow/engine/substrait/extension_set.h
@@ -131,6 +131,9 @@ class ARROW_ENGINE_EXPORT SubstraitCall {
   const std::shared_ptr<DataType>& output_type() const { return output_type_; }
   bool output_nullable() const { return output_nullable_; }
   bool is_hash() const { return is_hash_; }
+  const std::unordered_map<std::string, std::vector<std::string>>& options() const {
+    return options_;
+  }
 
   bool HasEnumArg(int index) const;
   Result<std::string_view> GetEnumArg(int index) const;
@@ -427,6 +430,15 @@ class ARROW_ENGINE_EXPORT ExtensionSet {
   /// \return An anchor that can be used to refer to the function within a plan
   Result<uint32_t> EncodeFunction(Id function_id);
 
+  /// \brief Stores a plan-specific id that is not known to the registry
+  ///
+  /// This is used when converting an Arrow execution plan to a Substrait plan.
+  ///
+  /// If the function is a UDF, something that wasn't known to the registry,
+  /// then we need long term storage of the function name (the ids are just
+  /// views)
+  Id RegisterPlanSpecificId(Id id);
+
   /// \brief Return the number of custom functions in this extension set
   std::size_t num_functions() const { return functions_.size(); }
 
diff --git a/cpp/src/arrow/engine/substrait/options.h b/cpp/src/arrow/engine/substrait/options.h
index 0d66c5eea43e5..1e6f6efb2c751 100644
--- a/cpp/src/arrow/engine/substrait/options.h
+++ b/cpp/src/arrow/engine/substrait/options.h
@@ -106,7 +106,8 @@ struct ARROW_ENGINE_EXPORT ConversionOptions {
       : strictness(ConversionStrictness::BEST_EFFORT),
         named_table_provider(kDefaultNamedTableProvider),
         named_tap_provider(default_named_tap_provider()),
-        extension_provider(default_extension_provider()) {}
+        extension_provider(default_extension_provider()),
+        allow_arrow_extensions(false) {}
 
   /// \brief How strictly the converter should adhere to the structure of the input.
   ConversionStrictness strictness;
@@ -123,6 +124,11 @@ struct ARROW_ENGINE_EXPORT ConversionOptions {
   ///
   /// The default behavior will provide for relations known to Arrow.
   std::shared_ptr<ExtensionProvider> extension_provider;
+  /// \brief If true then Arrow-specific types and functions will be allowed
+  ///
+  /// Set to false to create plans that are more likely to be compatible with non-Arrow
+  /// engines
+  bool allow_arrow_extensions;
 };
 
 }  // namespace engine
diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc
index ecee81e25ff53..cc4806878c404 100644
--- a/cpp/src/arrow/engine/substrait/plan_internal.cc
+++ b/cpp/src/arrow/engine/substrait/plan_internal.cc
@@ -25,9 +25,10 @@
 #include <utility>
 
 #include "arrow/compute/type_fwd.h"
-#include "arrow/config.h"
 #include "arrow/engine/substrait/relation_internal.h"
 #include "arrow/engine/substrait/type_fwd.h"
+#include "arrow/engine/substrait/util.h"
+#include "arrow/engine/substrait/util_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/hashing.h"
@@ -43,122 +44,15 @@ using internal::checked_cast;
 namespace engine {
 
 Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) {
-  plan->clear_extension_uris();
-
-  std::unordered_map<std::string_view, int, ::arrow::internal::StringViewHash> map;
-
-  auto uris = plan->mutable_extension_uris();
-  uris->Reserve(static_cast<int>(ext_set.uris().size()));
-  for (uint32_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) {
-    auto uri = ext_set.uris().at(anchor);
-    if (uri.empty()) continue;
-
-    auto ext_uri = std::make_unique<substrait::extensions::SimpleExtensionURI>();
-    ext_uri->set_uri(std::string(uri));
-    ext_uri->set_extension_uri_anchor(anchor);
-    uris->AddAllocated(ext_uri.release());
-
-    map[uri] = anchor;
-  }
-
-  auto extensions = plan->mutable_extensions();
-  extensions->Reserve(static_cast<int>(ext_set.num_types() + ext_set.num_functions()));
-
-  using ExtDecl = substrait::extensions::SimpleExtensionDeclaration;
-
-  for (uint32_t anchor = 0; anchor < ext_set.num_types(); ++anchor) {
-    ARROW_ASSIGN_OR_RAISE(auto type_record, ext_set.DecodeType(anchor));
-    if (type_record.id.empty()) continue;
-
-    auto ext_decl = std::make_unique<ExtDecl>();
-
-    auto type = std::make_unique<ExtDecl::ExtensionType>();
-    type->set_extension_uri_reference(map[type_record.id.uri]);
-    type->set_type_anchor(anchor);
-    type->set_name(std::string(type_record.id.name));
-    ext_decl->set_allocated_extension_type(type.release());
-    extensions->AddAllocated(ext_decl.release());
-  }
-
-  for (uint32_t anchor = 0; anchor < ext_set.num_functions(); ++anchor) {
-    ARROW_ASSIGN_OR_RAISE(Id function_id, ext_set.DecodeFunction(anchor));
-
-    auto fn = std::make_unique<ExtDecl::ExtensionFunction>();
-    fn->set_extension_uri_reference(map[function_id.uri]);
-    fn->set_function_anchor(anchor);
-    fn->set_name(std::string(function_id.name));
-
-    auto ext_decl = std::make_unique<ExtDecl>();
-    ext_decl->set_allocated_extension_function(fn.release());
-    extensions->AddAllocated(ext_decl.release());
-  }
-
-  return Status::OK();
+  return AddExtensionSetToMessage(ext_set, plan);
 }
 
 Result<ExtensionSet> GetExtensionSetFromPlan(const substrait::Plan& plan,
                                              const ConversionOptions& conversion_options,
                                              const ExtensionIdRegistry* registry) {
-  if (registry == NULLPTR) {
-    registry = default_extension_id_registry();
-  }
-  std::unordered_map<uint32_t, std::string_view> uris;
-  uris.reserve(plan.extension_uris_size());
-  for (const auto& uri : plan.extension_uris()) {
-    uris[uri.extension_uri_anchor()] = uri.uri();
-  }
-
-  // NOTE: it's acceptable to use views to memory owned by plan; ExtensionSet::Make
-  // will only store views to memory owned by registry.
-
-  std::unordered_map<uint32_t, Id> type_ids, function_ids;
-  for (const auto& ext : plan.extensions()) {
-    switch (ext.mapping_type_case()) {
-      case substrait::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: {
-        return Status::NotImplemented("Type Variations are not yet implemented");
-      }
-
-      case substrait::extensions::SimpleExtensionDeclaration::kExtensionType: {
-        const auto& type = ext.extension_type();
-        std::string_view uri = uris[type.extension_uri_reference()];
-        type_ids[type.type_anchor()] = Id{uri, type.name()};
-        break;
-      }
-
-      case substrait::extensions::SimpleExtensionDeclaration::kExtensionFunction: {
-        const auto& fn = ext.extension_function();
-        std::string_view uri = uris[fn.extension_uri_reference()];
-        function_ids[fn.function_anchor()] = Id{uri, fn.name()};
-        break;
-      }
-
-      default:
-        Unreachable();
-    }
-  }
-
-  return ExtensionSet::Make(std::move(uris), std::move(type_ids), std::move(function_ids),
-                            conversion_options, registry);
-}
-
-namespace {
-
-// TODO(ARROW-18145) Populate these from cmake files
-constexpr uint32_t kSubstraitMajorVersion = 0;
-constexpr uint32_t kSubstraitMinorVersion = 20;
-constexpr uint32_t kSubstraitPatchVersion = 0;
-
-std::unique_ptr<substrait::Version> CreateVersion() {
-  auto version = std::make_unique<substrait::Version>();
-  version->set_major_number(kSubstraitMajorVersion);
-  version->set_minor_number(kSubstraitMinorVersion);
-  version->set_patch_number(kSubstraitPatchVersion);
-  version->set_producer("Acero " + GetBuildInfo().version_string);
-  return version;
+  return GetExtensionSetFromMessage(plan, conversion_options, registry);
 }
 
-}  // namespace
-
 Result<std::unique_ptr<substrait::Plan>> PlanToProto(
     const acero::Declaration& declr, ExtensionSet* ext_set,
     const ConversionOptions& conversion_options) {
diff --git a/cpp/src/arrow/engine/substrait/relation.h b/cpp/src/arrow/engine/substrait/relation.h
index 0be4e03bb3871..d0913b9ae029b 100644
--- a/cpp/src/arrow/engine/substrait/relation.h
+++ b/cpp/src/arrow/engine/substrait/relation.h
@@ -20,6 +20,7 @@
 #include <memory>
 
 #include "arrow/acero/exec_plan.h"
+#include "arrow/compute/api_aggregate.h"
 #include "arrow/engine/substrait/visibility.h"
 #include "arrow/type_fwd.h"
 
@@ -50,5 +51,21 @@ struct ARROW_ENGINE_EXPORT PlanInfo {
   std::vector<std::string> names;
 };
 
+/// An expression whose output has a name
+struct ARROW_ENGINE_EXPORT NamedExpression {
+  /// An expression
+  compute::Expression expression;
+  // An optional name to assign to the output, may be the empty string
+  std::string name;
+};
+
+/// A collection of expressions bound to a common schema
+struct ARROW_ENGINE_EXPORT BoundExpressions {
+  /// The expressions
+  std::vector<NamedExpression> named_expressions;
+  /// The schema that all the expressions are bound to
+  std::shared_ptr<Schema> schema;
+};
+
 }  // namespace engine
 }  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc
index b5effd7852451..9e670f121778e 100644
--- a/cpp/src/arrow/engine/substrait/serde.cc
+++ b/cpp/src/arrow/engine/substrait/serde.cc
@@ -35,12 +35,14 @@
 #include "arrow/compute/expression.h"
 #include "arrow/dataset/file_base.h"
 #include "arrow/engine/substrait/expression_internal.h"
+#include "arrow/engine/substrait/extended_expression_internal.h"
 #include "arrow/engine/substrait/extension_set.h"
 #include "arrow/engine/substrait/plan_internal.h"
 #include "arrow/engine/substrait/relation.h"
 #include "arrow/engine/substrait/relation_internal.h"
 #include "arrow/engine/substrait/type_fwd.h"
 #include "arrow/engine/substrait/type_internal.h"
+#include "arrow/engine/substrait/util.h"
 #include "arrow/type.h"
 
 namespace arrow {
@@ -74,6 +76,20 @@ Result<std::shared_ptr<Buffer>> SerializePlan(
   return Buffer::FromString(std::move(serialized));
 }
 
+Result<std::shared_ptr<Buffer>> SerializeExpressions(
+    const BoundExpressions& bound_expressions,
+    const ConversionOptions& conversion_options, ExtensionSet* ext_set) {
+  ExtensionSet throwaway_ext_set;
+  if (ext_set == nullptr) {
+    ext_set = &throwaway_ext_set;
+  }
+  ARROW_ASSIGN_OR_RAISE(
+      std::unique_ptr<substrait::ExtendedExpression> extended_expression,
+      ToProto(bound_expressions, ext_set, conversion_options));
+  std::string serialized = extended_expression->SerializeAsString();
+  return Buffer::FromString(std::move(serialized));
+}
+
 Result<std::shared_ptr<Buffer>> SerializeRelation(
     const acero::Declaration& declaration, ExtensionSet* ext_set,
     const ConversionOptions& conversion_options) {
@@ -125,20 +141,14 @@ DeclarationFactory MakeWriteDeclarationFactory(
   };
 }
 
-constexpr uint32_t kMinimumMajorVersion = 0;
-constexpr uint32_t kMinimumMinorVersion = 20;
-
 Result<std::vector<acero::Declaration>> DeserializePlans(
     const Buffer& buf, DeclarationFactory declaration_factory,
     const ExtensionIdRegistry* registry, ExtensionSet* ext_set_out,
     const ConversionOptions& conversion_options) {
   ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer<substrait::Plan>(buf));
 
-  if (plan.version().major_number() < kMinimumMajorVersion &&
-      plan.version().minor_number() < kMinimumMinorVersion) {
-    return Status::Invalid("Can only parse plans with a version >= ",
-                           kMinimumMajorVersion, ".", kMinimumMinorVersion);
-  }
+  ARROW_RETURN_NOT_OK(
+      CheckVersion(plan.version().major_number(), plan.version().minor_number()));
 
   ARROW_ASSIGN_OR_RAISE(auto ext_set,
                         GetExtensionSetFromPlan(plan, conversion_options, registry));
@@ -196,12 +206,8 @@ ARROW_ENGINE_EXPORT Result<PlanInfo> DeserializePlan(
     const Buffer& buf, const ExtensionIdRegistry* registry, ExtensionSet* ext_set_out,
     const ConversionOptions& conversion_options) {
   ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer<substrait::Plan>(buf));
-
-  if (plan.version().major_number() < kMinimumMajorVersion &&
-      plan.version().minor_number() < kMinimumMinorVersion) {
-    return Status::Invalid("Can only parse plans with a version >= ",
-                           kMinimumMajorVersion, ".", kMinimumMinorVersion);
-  }
+  ARROW_RETURN_NOT_OK(
+      CheckVersion(plan.version().major_number(), plan.version().minor_number()));
 
   ARROW_ASSIGN_OR_RAISE(auto ext_set,
                         GetExtensionSetFromPlan(plan, conversion_options, registry));
@@ -233,6 +239,14 @@ ARROW_ENGINE_EXPORT Result<PlanInfo> DeserializePlan(
   return PlanInfo{std::move(decl_info), std::move(names)};
 }
 
+Result<BoundExpressions> DeserializeExpressions(
+    const Buffer& buf, const ExtensionIdRegistry* registry,
+    const ConversionOptions& conversion_options, ExtensionSet* ext_set_out) {
+  ARROW_ASSIGN_OR_RAISE(auto extended_expression,
+                        ParseFromBuffer<substrait::ExtendedExpression>(buf));
+  return FromProto(extended_expression, ext_set_out, conversion_options, registry);
+}
+
 namespace {
 
 Result<std::shared_ptr<acero::ExecPlan>> MakeSingleDeclarationPlan(
diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h
index ebbefb176e2a9..ab749f4a64b05 100644
--- a/cpp/src/arrow/engine/substrait/serde.h
+++ b/cpp/src/arrow/engine/substrait/serde.h
@@ -52,6 +52,19 @@ Result<std::shared_ptr<Buffer>> SerializePlan(
     const acero::Declaration& declaration, ExtensionSet* ext_set,
     const ConversionOptions& conversion_options = {});
 
+/// \brief Serialize expressions to a Substrait message
+///
+/// \param[in] bound_expressions the expressions to serialize.
+/// \param[in] conversion_options options to control how the conversion is done
+/// \param[in,out] ext_set the extension mapping to use, optional, only needed
+///                        if you want to control the value of function anchors
+///                        to mirror a previous serialization / deserialization.
+///                        Will be updated if new functions are encountered
+ARROW_ENGINE_EXPORT
+Result<std::shared_ptr<Buffer>> SerializeExpressions(
+    const BoundExpressions& bound_expressions,
+    const ConversionOptions& conversion_options = {}, ExtensionSet* ext_set = NULLPTR);
+
 /// Factory function type for generating the node that consumes the batches produced by
 /// each toplevel Substrait relation when deserializing a Substrait Plan.
 using ConsumerFactory = std::function<std::shared_ptr<acero::SinkNodeConsumer>()>;
@@ -155,6 +168,21 @@ ARROW_ENGINE_EXPORT Result<PlanInfo> DeserializePlan(
     ExtensionSet* ext_set_out = NULLPTR,
     const ConversionOptions& conversion_options = {});
 
+/// \brief Deserialize a Substrait ExtendedExpression message to the corresponding Arrow
+/// type
+///
+/// \param[in] buf a buffer containing the protobuf serialization of a collection of bound
+/// expressions
+/// \param[in] registry an extension-id-registry to use, or null for the default one
+/// \param[in] conversion_options options to control how the conversion is done
+/// \param[out] ext_set_out if non-null, the extension mapping used by the Substrait
+/// message is returned here.
+/// \return A collection of expressions and a common input schema they are bound to
+ARROW_ENGINE_EXPORT Result<BoundExpressions> DeserializeExpressions(
+    const Buffer& buf, const ExtensionIdRegistry* registry = NULLPTR,
+    const ConversionOptions& conversion_options = {},
+    ExtensionSet* ext_set_out = NULLPTR);
+
 /// \brief Deserializes a Substrait Type message to the corresponding Arrow type
 ///
 /// \param[in] buf a buffer containing the protobuf serialization of a Substrait Type
diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc
index efe1f702b4868..2e72ae70edd88 100644
--- a/cpp/src/arrow/engine/substrait/serde_test.cc
+++ b/cpp/src/arrow/engine/substrait/serde_test.cc
@@ -6070,5 +6070,100 @@ TEST(Substrait, PlanWithSegmentedAggregateExtension) {
   CheckRoundTripResult(std::move(expected_table), buf, {}, conversion_options);
 }
 
+void CheckExpressionRoundTrip(const Schema& schema,
+                              const compute::Expression& expression) {
+  ASSERT_OK_AND_ASSIGN(compute::Expression bound_expression, expression.Bind(schema));
+  BoundExpressions bound_expressions;
+  bound_expressions.schema = std::make_shared<Schema>(schema);
+  bound_expressions.named_expressions = {{std::move(bound_expression), "some_name"}};
+
+  ASSERT_OK_AND_ASSIGN(std::shared_ptr<Buffer> buf,
+                       SerializeExpressions(bound_expressions));
+
+  ASSERT_OK_AND_ASSIGN(BoundExpressions round_tripped, DeserializeExpressions(*buf));
+
+  AssertSchemaEqual(schema, *round_tripped.schema);
+  ASSERT_EQ(1, round_tripped.named_expressions.size());
+  ASSERT_EQ("some_name", round_tripped.named_expressions[0].name);
+  ASSERT_EQ(bound_expressions.named_expressions[0].expression,
+            round_tripped.named_expressions[0].expression);
+}
+
+TEST(Substrait, ExtendedExpressionSerialization) {
+  std::shared_ptr<Schema> test_schema =
+      schema({field("a", int32()), field("b", int32()), field("c", float32()),
+              field("nested", struct_({field("x", float32()), field("y", float32())}))});
+  // Basic a + b
+  CheckExpressionRoundTrip(
+      *test_schema, compute::call("add", {compute::field_ref(0), compute::field_ref(1)}));
+  // Nested struct reference
+  CheckExpressionRoundTrip(*test_schema, compute::field_ref(FieldPath{3, 0}));
+  // Struct return type
+  CheckExpressionRoundTrip(*test_schema, compute::field_ref(3));
+  // c + nested.y
+  CheckExpressionRoundTrip(
+      *test_schema,
+      compute::call("add", {compute::field_ref(2), compute::field_ref(FieldPath{3, 1})}));
+}
+
+TEST(Substrait, ExtendedExpressionInvalidPlans) {
+  // The schema defines the type as {"x", "y"} but output_names has {"a", "y"}
+  constexpr std::string_view kBadOuptutNames = R"(
+    {
+      "referredExpr":[
+        {
+          "expression":{
+            "selection":{
+              "directReference":{
+                "structField":{
+                  "field":3
+                }
+              },
+              "rootReference":{}
+            }
+          },
+          "outputNames":["a", "y", "some_name"]
+        }
+      ],
+      "baseSchema":{
+        "names":["a","b","c","nested","x","y"],
+        "struct":{
+          "types":[
+            {
+              "i32":{"nullability":"NULLABILITY_NULLABLE"}
+            },
+            {
+              "i32":{"nullability":"NULLABILITY_NULLABLE"}
+            },
+            {
+              "fp32":{"nullability":"NULLABILITY_NULLABLE"}
+            },
+            {
+              "struct":{
+                "types":[
+                  {
+                    "fp32":{"nullability":"NULLABILITY_NULLABLE"}
+                  },
+                  {
+                    "fp32":{"nullability":"NULLABILITY_NULLABLE"}
+                  }
+                ],
+                "nullability":"NULLABILITY_NULLABLE"
+              }
+            }
+          ]
+        }
+      },
+      "version":{"majorNumber":9999}
+    }
+  )";
+
+  ASSERT_OK_AND_ASSIGN(
+      auto buf, internal::SubstraitFromJSON("ExtendedExpression", kBadOuptutNames));
+
+  ASSERT_THAT(DeserializeExpressions(*buf),
+              Raises(StatusCode::Invalid, testing::HasSubstr("Ambiguous plan")));
+}
+
 }  // namespace engine
 }  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/util.cc b/cpp/src/arrow/engine/substrait/util.cc
index b74e333fd97f2..d842d0ef9d73b 100644
--- a/cpp/src/arrow/engine/substrait/util.cc
+++ b/cpp/src/arrow/engine/substrait/util.cc
@@ -70,6 +70,16 @@ const std::string& default_extension_types_uri() {
   return uri;
 }
 
+Status CheckVersion(uint32_t major_version, uint32_t minor_version) {
+  if (major_version < kSubstraitMinimumMajorVersion &&
+      minor_version < kSubstraitMinimumMinorVersion) {
+    return Status::Invalid("Can only parse Substrait messages with a version >= ",
+                           kSubstraitMinimumMajorVersion, ".",
+                           kSubstraitMinimumMinorVersion);
+  }
+  return Status::OK();
+}
+
 }  // namespace engine
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/util.h b/cpp/src/arrow/engine/substrait/util.h
index 9f8bd8048899a..5128ec44bff77 100644
--- a/cpp/src/arrow/engine/substrait/util.h
+++ b/cpp/src/arrow/engine/substrait/util.h
@@ -68,6 +68,16 @@ ARROW_ENGINE_EXPORT std::shared_ptr<ExtensionIdRegistry> MakeExtensionIdRegistry
 
 ARROW_ENGINE_EXPORT const std::string& default_extension_types_uri();
 
+// TODO(ARROW-18145) Populate these from cmake files
+constexpr uint32_t kSubstraitMajorVersion = 0;
+constexpr uint32_t kSubstraitMinorVersion = 27;
+constexpr uint32_t kSubstraitPatchVersion = 0;
+
+constexpr uint32_t kSubstraitMinimumMajorVersion = 0;
+constexpr uint32_t kSubstraitMinimumMinorVersion = 20;
+
+Status CheckVersion(uint32_t major_version, uint32_t minor_version);
+
 }  // namespace engine
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/util_internal.cc b/cpp/src/arrow/engine/substrait/util_internal.cc
index 4e6cacf4f672b..89034784ab5bd 100644
--- a/cpp/src/arrow/engine/substrait/util_internal.cc
+++ b/cpp/src/arrow/engine/substrait/util_internal.cc
@@ -17,6 +17,9 @@
 
 #include "arrow/engine/substrait/util_internal.h"
 
+#include "arrow/config.h"
+#include "arrow/engine/substrait/util.h"
+
 namespace arrow {
 
 namespace engine {
@@ -30,6 +33,15 @@ std::string EnumToString(int value, const google::protobuf::EnumDescriptor& desc
   return value_desc->name();
 }
 
+std::unique_ptr<substrait::Version> CreateVersion() {
+  auto version = std::make_unique<substrait::Version>();
+  version->set_major_number(kSubstraitMajorVersion);
+  version->set_minor_number(kSubstraitMinorVersion);
+  version->set_patch_number(kSubstraitPatchVersion);
+  version->set_producer("Acero " + GetBuildInfo().version_string);
+  return version;
+}
+
 }  // namespace engine
 
 }  // namespace arrow
diff --git a/cpp/src/arrow/engine/substrait/util_internal.h b/cpp/src/arrow/engine/substrait/util_internal.h
index efc3145543dd2..627ad1126df6e 100644
--- a/cpp/src/arrow/engine/substrait/util_internal.h
+++ b/cpp/src/arrow/engine/substrait/util_internal.h
@@ -17,8 +17,17 @@
 
 #pragma once
 
+#include <unordered_map>
+
+#include "arrow/engine/substrait/extension_set.h"
+#include "arrow/engine/substrait/options.h"
 #include "arrow/engine/substrait/visibility.h"
+#include "arrow/result.h"
+#include "arrow/util/hashing.h"
+#include "arrow/util/unreachable.h"
+
 #include "substrait/algebra.pb.h"  // IWYU pragma: export
+#include "substrait/plan.pb.h"     // IWYU pragma: export
 
 namespace arrow {
 namespace engine {
@@ -26,5 +35,110 @@ namespace engine {
 ARROW_ENGINE_EXPORT std::string EnumToString(
     int value, const google::protobuf::EnumDescriptor& descriptor);
 
+// Extension sets can be present in both substrait::Plan and substrait::ExtendedExpression
+// and so this utility is templated to support both.
+template <typename MessageType>
+Result<ExtensionSet> GetExtensionSetFromMessage(
+    const MessageType& message, const ConversionOptions& conversion_options,
+    const ExtensionIdRegistry* registry) {
+  if (registry == NULLPTR) {
+    registry = default_extension_id_registry();
+  }
+  std::unordered_map<uint32_t, std::string_view> uris;
+  uris.reserve(message.extension_uris_size());
+  for (const auto& uri : message.extension_uris()) {
+    uris[uri.extension_uri_anchor()] = uri.uri();
+  }
+
+  // NOTE: it's acceptable to use views to memory owned by message; ExtensionSet::Make
+  // will only store views to memory owned by registry.
+
+  std::unordered_map<uint32_t, Id> type_ids, function_ids;
+  for (const auto& ext : message.extensions()) {
+    switch (ext.mapping_type_case()) {
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: {
+        return Status::NotImplemented("Type Variations are not yet implemented");
+      }
+
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionType: {
+        const auto& type = ext.extension_type();
+        std::string_view uri = uris[type.extension_uri_reference()];
+        type_ids[type.type_anchor()] = Id{uri, type.name()};
+        break;
+      }
+
+      case substrait::extensions::SimpleExtensionDeclaration::kExtensionFunction: {
+        const auto& fn = ext.extension_function();
+        std::string_view uri = uris[fn.extension_uri_reference()];
+        function_ids[fn.function_anchor()] = Id{uri, fn.name()};
+        break;
+      }
+
+      default:
+        Unreachable();
+    }
+  }
+
+  return ExtensionSet::Make(std::move(uris), std::move(type_ids), std::move(function_ids),
+                            conversion_options, registry);
+}
+
+template <typename Message>
+Status AddExtensionSetToMessage(const ExtensionSet& ext_set, Message* message) {
+  message->clear_extension_uris();
+
+  std::unordered_map<std::string_view, int, ::arrow::internal::StringViewHash> map;
+
+  auto uris = message->mutable_extension_uris();
+  uris->Reserve(static_cast<int>(ext_set.uris().size()));
+  for (uint32_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) {
+    auto uri = ext_set.uris().at(anchor);
+    if (uri.empty()) continue;
+
+    auto ext_uri = std::make_unique<substrait::extensions::SimpleExtensionURI>();
+    ext_uri->set_uri(std::string(uri));
+    ext_uri->set_extension_uri_anchor(anchor);
+    uris->AddAllocated(ext_uri.release());
+
+    map[uri] = anchor;
+  }
+
+  auto extensions = message->mutable_extensions();
+  extensions->Reserve(static_cast<int>(ext_set.num_types() + ext_set.num_functions()));
+
+  using ExtDecl = substrait::extensions::SimpleExtensionDeclaration;
+
+  for (uint32_t anchor = 0; anchor < ext_set.num_types(); ++anchor) {
+    ARROW_ASSIGN_OR_RAISE(auto type_record, ext_set.DecodeType(anchor));
+    if (type_record.id.empty()) continue;
+
+    auto ext_decl = std::make_unique<ExtDecl>();
+
+    auto type = std::make_unique<ExtDecl::ExtensionType>();
+    type->set_extension_uri_reference(map[type_record.id.uri]);
+    type->set_type_anchor(anchor);
+    type->set_name(std::string(type_record.id.name));
+    ext_decl->set_allocated_extension_type(type.release());
+    extensions->AddAllocated(ext_decl.release());
+  }
+
+  for (uint32_t anchor = 0; anchor < ext_set.num_functions(); ++anchor) {
+    ARROW_ASSIGN_OR_RAISE(Id function_id, ext_set.DecodeFunction(anchor));
+
+    auto fn = std::make_unique<ExtDecl::ExtensionFunction>();
+    fn->set_extension_uri_reference(map[function_id.uri]);
+    fn->set_function_anchor(anchor);
+    fn->set_name(std::string(function_id.name));
+
+    auto ext_decl = std::make_unique<ExtDecl>();
+    ext_decl->set_allocated_extension_function(fn.release());
+    extensions->AddAllocated(ext_decl.release());
+  }
+
+  return Status::OK();
+}
+
+std::unique_ptr<substrait::Version> CreateVersion();
+
 }  // namespace engine
 }  // namespace arrow
diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt
index c05ff4228462c..8edaa422b3dcf 100644
--- a/cpp/thirdparty/versions.txt
+++ b/cpp/thirdparty/versions.txt
@@ -101,8 +101,8 @@ ARROW_RE2_BUILD_SHA256_CHECKSUM=f89c61410a072e5cbcf8c27e3a778da7d6fd2f2b5b1445cd
 # 1.1.9 is patched to implement https://github.com/google/snappy/pull/148 if this is bumped, remove the patch
 ARROW_SNAPPY_BUILD_VERSION=1.1.9
 ARROW_SNAPPY_BUILD_SHA256_CHECKSUM=75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7
-ARROW_SUBSTRAIT_BUILD_VERSION=v0.20.0
-ARROW_SUBSTRAIT_BUILD_SHA256_CHECKSUM=5ceaa559ccef29a7825b5e5d4b5e7eed384830294f08bec913feecdd903a94cf
+ARROW_SUBSTRAIT_BUILD_VERSION=v0.27.0
+ARROW_SUBSTRAIT_BUILD_SHA256_CHECKSUM=4ed375f69d972a57fdc5ec406c17003a111831d8640d3f1733eccd4b3ff45628
 ARROW_S2N_TLS_BUILD_VERSION=v1.3.35
 ARROW_S2N_TLS_BUILD_SHA256_CHECKSUM=9d32b26e6bfcc058d98248bf8fc231537e347395dd89cf62bb432b55c5da990d
 ARROW_THRIFT_BUILD_VERSION=0.16.0
diff --git a/docs/source/python/api/substrait.rst b/docs/source/python/api/substrait.rst
index 207b2d9cdbcea..66e88fcd279ae 100644
--- a/docs/source/python/api/substrait.rst
+++ b/docs/source/python/api/substrait.rst
@@ -31,6 +31,19 @@ Query Execution
 
    run_query
 
+Expression Serialization
+------------------------
+
+These functions allow for serialization and deserialization of pyarrow
+compute expressions.
+
+.. autosummary::
+   :toctree: ../generated/
+
+   BoundExpressions
+   deserialize_expressions
+   serialize_expressions
+
 Utility
 -------
 
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 74b9c2ec8c78b..0c1744febbe1e 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -37,6 +37,23 @@ import numpy as np
 import warnings
 
 
+__pas = None
+_substrait_msg = (
+    "The pyarrow installation is not built with support for Substrait."
+)
+
+
+def _pas():
+    global __pas
+    if __pas is None:
+        try:
+            import pyarrow.substrait as pas
+            __pas = pas
+        except ImportError:
+            raise ImportError(_substrait_msg)
+    return __pas
+
+
 def _forbid_instantiation(klass, subclasses_instead=True):
     msg = '{} is an abstract class thus cannot be initialized.'.format(
         klass.__name__
@@ -2386,6 +2403,58 @@ cdef class Expression(_Weakrefable):
             self.__class__.__name__, str(self)
         )
 
+    @staticmethod
+    def from_substrait(object buffer not None):
+        """
+        Deserialize an expression from Substrait
+
+        The serialized message must be an ExtendedExpression message that has
+        only a single expression.  The name of the expression and the schema
+        the expression was bound to will be ignored.  Use
+        pyarrow.substrait.deserialize_expressions if this information is needed
+        or if the message might contain multiple expressions.
+
+        Parameters
+        ----------
+        buffer : bytes or Buffer
+            The Substrait message to deserialize
+
+        Returns
+        -------
+        Expression
+            The deserialized expression
+        """
+        expressions = _pas().deserialize_expressions(buffer).expressions
+        if len(expressions) == 0:
+            raise ValueError("Substrait message did not contain any expressions")
+        if len(expressions) > 1:
+            raise ValueError(
+                "Substrait message contained multiple expressions.  Use pyarrow.substrait.deserialize_expressions instead")
+        return next(iter(expressions.values()))
+
+    def to_substrait(self, Schema schema not None, c_bool allow_arrow_extensions=False):
+        """
+        Serialize the expression using Substrait
+
+        The expression will be serialized as an ExtendedExpression message that has a
+        single expression named "expression"
+
+        Parameters
+        ----------
+        schema : Schema
+            The input schema the expression will be bound to
+        allow_arrow_extensions : bool, default False
+            If False then only functions that are part of the core Substrait function
+            definitions will be allowed.  Set this to True to allow pyarrow-specific functions
+            but the result may not be accepted by other compute libraries.
+
+        Returns
+        -------
+        Buffer
+            A buffer containing the serialized Protobuf plan.
+        """
+        return _pas().serialize_expressions([self], ["expression"], schema, allow_arrow_extensions=allow_arrow_extensions)
+
     @staticmethod
     def _deserialize(Buffer buffer not None):
         return Expression.wrap(GetResultValue(CDeserializeExpression(
diff --git a/python/pyarrow/_substrait.pyx b/python/pyarrow/_substrait.pyx
index 1be2e6330aba5..4efad2c4d1bc5 100644
--- a/python/pyarrow/_substrait.pyx
+++ b/python/pyarrow/_substrait.pyx
@@ -20,6 +20,7 @@ from cython.operator cimport dereference as deref
 from libcpp.vector cimport vector as std_vector
 
 from pyarrow import Buffer, py_buffer
+from pyarrow._compute cimport Expression
 from pyarrow.lib import frombytes, tobytes
 from pyarrow.lib cimport *
 from pyarrow.includes.libarrow cimport *
@@ -164,7 +165,7 @@ def _parse_json_plan(plan):
 
     Parameters
     ----------
-    plan: bytes
+    plan : bytes
         Substrait plan in JSON.
 
     Returns
@@ -185,6 +186,144 @@ def _parse_json_plan(plan):
     return pyarrow_wrap_buffer(c_buf_plan)
 
 
+def serialize_expressions(exprs, names, schema, *, allow_arrow_extensions=False):
+    """
+    Serialize a collection of expressions into Substrait
+
+    Substrait expressions must be bound to a schema.  For example,
+    the Substrait expression ``a:i32 + b:i32`` is different from the
+    Substrait expression ``a:i64 + b:i64``.  Pyarrow expressions are
+    typically unbound.  For example, both of the above expressions
+    would be represented as ``a + b`` in pyarrow.
+
+    This means a schema must be provided when serializing an expression.
+    It also means that the serialization may fail if a matching function
+    call cannot be found for the expression.
+
+    Parameters
+    ----------
+    exprs : list of Expression
+        The expressions to serialize
+    names : list of str
+        Names for the expressions
+    schema : Schema
+        The schema the expressions will be bound to
+    allow_arrow_extensions : bool, default False
+        If False then only functions that are part of the core Substrait function
+        definitions will be allowed.  Set this to True to allow pyarrow-specific functions
+        and user defined functions but the result may not be accepted by other
+        compute libraries.
+
+    Returns
+    -------
+    Buffer
+        An ExtendedExpression message containing the serialized expressions
+    """
+    cdef:
+        CResult[shared_ptr[CBuffer]] c_res_buffer
+        shared_ptr[CBuffer] c_buffer
+        CNamedExpression c_named_expr
+        CBoundExpressions c_bound_exprs
+        CConversionOptions c_conversion_options
+
+    if len(exprs) != len(names):
+        raise ValueError("exprs and names need to have the same length")
+    for expr, name in zip(exprs, names):
+        if not isinstance(expr, Expression):
+            raise TypeError(f"Expected Expression, got '{type(expr)}' in exprs")
+        if not isinstance(name, str):
+            raise TypeError(f"Expected str, got '{type(name)}' in names")
+        c_named_expr.expression = (<Expression> expr).unwrap()
+        c_named_expr.name = tobytes(<str> name)
+        c_bound_exprs.named_expressions.push_back(c_named_expr)
+
+    c_bound_exprs.schema = (<Schema> schema).sp_schema
+
+    c_conversion_options.allow_arrow_extensions = allow_arrow_extensions
+
+    with nogil:
+        c_res_buffer = SerializeExpressions(c_bound_exprs, c_conversion_options)
+        c_buffer = GetResultValue(c_res_buffer)
+    return pyarrow_wrap_buffer(c_buffer)
+
+
+cdef class BoundExpressions(_Weakrefable):
+    """
+    A collection of named expressions and the schema they are bound to
+
+    This is equivalent to the Substrait ExtendedExpression message
+    """
+
+    cdef:
+        CBoundExpressions c_bound_exprs
+
+    def __init__(self):
+        msg = 'BoundExpressions is an abstract class thus cannot be initialized.'
+        raise TypeError(msg)
+
+    cdef void init(self, CBoundExpressions bound_expressions):
+        self.c_bound_exprs = bound_expressions
+
+    @property
+    def schema(self):
+        """
+        The common schema that all expressions are bound to
+        """
+        return pyarrow_wrap_schema(self.c_bound_exprs.schema)
+
+    @property
+    def expressions(self):
+        """
+        A dict from expression name to expression
+        """
+        expr_dict = {}
+        for named_expr in self.c_bound_exprs.named_expressions:
+            name = frombytes(named_expr.name)
+            expr = Expression.wrap(named_expr.expression)
+            expr_dict[name] = expr
+        return expr_dict
+
+    @staticmethod
+    cdef wrap(const CBoundExpressions& bound_expressions):
+        cdef BoundExpressions self = BoundExpressions.__new__(BoundExpressions)
+        self.init(bound_expressions)
+        return self
+
+
+def deserialize_expressions(buf):
+    """
+    Deserialize an ExtendedExpression Substrait message into a BoundExpressions object
+
+    Parameters
+    ----------
+    buf : Buffer or bytes
+        The message to deserialize
+
+    Returns
+    -------
+    BoundExpressions
+        The deserialized expressions, their names, and the bound schema
+    """
+    cdef:
+        shared_ptr[CBuffer] c_buffer
+        CResult[CBoundExpressions] c_res_bound_exprs
+        CBoundExpressions c_bound_exprs
+
+    if isinstance(buf, bytes):
+        c_buffer = pyarrow_unwrap_buffer(py_buffer(buf))
+    elif isinstance(buf, Buffer):
+        c_buffer = pyarrow_unwrap_buffer(buf)
+    else:
+        raise TypeError(
+            f"Expected 'pyarrow.Buffer' or bytes, got '{type(buf)}'")
+
+    with nogil:
+        c_res_bound_exprs = DeserializeExpressions(deref(c_buffer))
+        c_bound_exprs = GetResultValue(c_res_bound_exprs)
+
+    return BoundExpressions.wrap(c_bound_exprs)
+
+
 def get_supported_functions():
     """
     Get a list of Substrait functions that the underlying
diff --git a/python/pyarrow/includes/libarrow_substrait.pxd b/python/pyarrow/includes/libarrow_substrait.pxd
index eabccb2b4a3cb..c41f4c05d3a77 100644
--- a/python/pyarrow/includes/libarrow_substrait.pxd
+++ b/python/pyarrow/includes/libarrow_substrait.pxd
@@ -40,6 +40,7 @@ cdef extern from "arrow/engine/substrait/options.h" namespace "arrow::engine" no
         CConversionOptions()
         ConversionStrictness strictness
         function[CNamedTableProvider] named_table_provider
+        c_bool allow_arrow_extensions
 
 cdef extern from "arrow/engine/substrait/extension_set.h" \
         namespace "arrow::engine" nogil:
@@ -49,6 +50,23 @@ cdef extern from "arrow/engine/substrait/extension_set.h" \
 
     ExtensionIdRegistry* default_extension_id_registry()
 
+cdef extern from "arrow/engine/substrait/relation.h" namespace "arrow::engine" nogil:
+
+    cdef cppclass CNamedExpression "arrow::engine::NamedExpression":
+        CExpression expression
+        c_string name
+
+    cdef cppclass CBoundExpressions "arrow::engine::BoundExpressions":
+        std_vector[CNamedExpression] named_expressions
+        shared_ptr[CSchema] schema
+
+cdef extern from "arrow/engine/substrait/serde.h" namespace "arrow::engine" nogil:
+
+    CResult[shared_ptr[CBuffer]] SerializeExpressions(
+        const CBoundExpressions& bound_expressions, const CConversionOptions& conversion_options)
+
+    CResult[CBoundExpressions] DeserializeExpressions(
+        const CBuffer& serialized_expressions)
 
 cdef extern from "arrow/engine/substrait/util.h" namespace "arrow::engine" nogil:
     CResult[shared_ptr[CRecordBatchReader]] ExecuteSerializedPlan(
diff --git a/python/pyarrow/substrait.py b/python/pyarrow/substrait.py
index ea7e19142cdd3..a2b217f4936c5 100644
--- a/python/pyarrow/substrait.py
+++ b/python/pyarrow/substrait.py
@@ -17,8 +17,11 @@
 
 try:
     from pyarrow._substrait import (  # noqa
+        BoundExpressions,
         get_supported_functions,
         run_query,
+        deserialize_expressions,
+        serialize_expressions
     )
 except ImportError as exc:
     raise ImportError(
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 6fbca5209975c..03d2688e65705 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -41,6 +41,10 @@
 from pyarrow.lib import ArrowNotImplementedError
 from pyarrow.tests import util
 
+try:
+    import pyarrow.substrait as pas
+except ImportError:
+    pas = None
 
 all_array_types = [
     ('bool', [True, False, False, True, True]),
@@ -3285,7 +3289,14 @@ def test_rank_options():
                        tiebreaker="NonExisting")
 
 
-def test_expression_serialization():
+def create_sample_expressions():
+    # We need a schema for substrait conversion
+    schema = pa.schema([pa.field("i64", pa.int64()), pa.field(
+        "foo", pa.struct([pa.field("bar", pa.string())]))])
+
+    # Creates a bunch of sample expressions for testing
+    # serialization and deserialization. The expressions are categorized
+    # to reflect certain nuances in Substrait conversion.
     a = pc.scalar(1)
     b = pc.scalar(1.1)
     c = pc.scalar(True)
@@ -3294,20 +3305,133 @@ def test_expression_serialization():
     f = pc.scalar({'a': 1})
     g = pc.scalar(pa.scalar(1))
     h = pc.scalar(np.int64(2))
+    j = pc.scalar(False)
+
+    # These expression consist entirely of literals
+    literal_exprs = [a, b, c, d, e, g, h, j]
+
+    # These expressions include at least one function call
+    exprs_with_call = [a == b, a != b, a > b, c & j, c | j, ~c, d.is_valid(),
+                       a + b, a - b, a * b, a / b, pc.negate(a),
+                       pc.add(a, b), pc.subtract(a, b), pc.divide(a, b),
+                       pc.multiply(a, b), pc.power(a, a), pc.sqrt(a),
+                       pc.exp(b), pc.cos(b), pc.sin(b), pc.tan(b),
+                       pc.acos(b), pc.atan(b), pc.asin(b), pc.atan2(b, b),
+                       pc.abs(b), pc.sign(a), pc.bit_wise_not(a),
+                       pc.bit_wise_and(a, a), pc.bit_wise_or(a, a),
+                       pc.bit_wise_xor(a, a), pc.is_nan(b), pc.is_finite(b),
+                       pc.coalesce(a, b),
+                       a.cast(pa.int32(), safe=False)]
+
+    # These expressions test out various reference styles and may include function
+    # calls.  Named references are used here.
+    exprs_with_ref = [pc.field('i64') > 5, pc.field('i64') == 5,
+                      pc.field('i64') == 7,
+                      pc.field(('foo', 'bar')) == 'value',
+                      pc.field('foo', 'bar') == 'value']
+
+    # Similar to above but these use numeric references instead of string refs
+    exprs_with_numeric_refs = [pc.field(0) > 5, pc.field(0) == 5,
+                               pc.field(0) == 7,
+                               pc.field((1, 0)) == 'value',
+                               pc.field(1, 0) == 'value']
+
+    # Expressions that behave uniquely when converting to/from substrait
+    special_cases = [
+        f,  # Struct literals lose their field names
+        a.isin([1, 2, 3]),  # isin converts to an or list
+        pc.field('i64').is_null()  # pyarrow always specifies a FunctionOptions
+                                   # for is_null which, being the default, is
+                                   # dropped on serialization
+    ]
+
+    all_exprs = literal_exprs.copy()
+    all_exprs += exprs_with_call
+    all_exprs += exprs_with_ref
+    all_exprs += special_cases
+
+    return {
+        "all": all_exprs,
+        "literals": literal_exprs,
+        "calls": exprs_with_call,
+        "refs": exprs_with_ref,
+        "numeric_refs": exprs_with_numeric_refs,
+        "special": special_cases,
+        "schema": schema
+    }
 
-    all_exprs = [a, b, c, d, e, f, g, h, a == b, a > b, a & b, a | b, ~c,
-                 d.is_valid(), a.cast(pa.int32(), safe=False),
-                 a.cast(pa.int32(), safe=False), a.isin([1, 2, 3]),
-                 pc.field('i64') > 5, pc.field('i64') == 5,
-                 pc.field('i64') == 7, pc.field('i64').is_null(),
-                 pc.field(('foo', 'bar')) == 'value',
-                 pc.field('foo', 'bar') == 'value']
-    for expr in all_exprs:
+# Tests the Arrow-specific serialization mechanism
+
+
+def test_expression_serialization_arrow():
+    for expr in create_sample_expressions()["all"]:
         assert isinstance(expr, pc.Expression)
         restored = pickle.loads(pickle.dumps(expr))
         assert expr.equals(restored)
 
 
+@pytest.mark.substrait
+def test_expression_serialization_substrait():
+
+    exprs = create_sample_expressions()
+    schema = exprs["schema"]
+
+    # Basic literals don't change on binding and so they will round
+    # trip without any change
+    for expr in exprs["literals"]:
+        serialized = expr.to_substrait(schema)
+        deserialized = pc.Expression.from_substrait(serialized)
+        assert expr.equals(deserialized)
+
+    # Expressions are bound when they get serialized.  Since bound
+    # expressions are not equal to their unbound variants we cannot
+    # compare the round tripped with the original
+    for expr in exprs["calls"]:
+        serialized = expr.to_substrait(schema)
+        deserialized = pc.Expression.from_substrait(serialized)
+        # We can't compare the expressions themselves because of the bound
+        # unbound difference. But we can compare the string representation
+        assert str(deserialized) == str(expr)
+        serialized_again = deserialized.to_substrait(schema)
+        deserialized_again = pc.Expression.from_substrait(serialized_again)
+        assert deserialized.equals(deserialized_again)
+
+    for expr, expr_norm in zip(exprs["refs"], exprs["numeric_refs"]):
+        serialized = expr.to_substrait(schema)
+        deserialized = pc.Expression.from_substrait(serialized)
+        assert str(deserialized) == str(expr_norm)
+        serialized_again = deserialized.to_substrait(schema)
+        deserialized_again = pc.Expression.from_substrait(serialized_again)
+        assert deserialized.equals(deserialized_again)
+
+    # For the special cases we get various wrinkles in serialization but we
+    # should always get the same thing from round tripping twice
+    for expr in exprs["special"]:
+        serialized = expr.to_substrait(schema)
+        deserialized = pc.Expression.from_substrait(serialized)
+        serialized_again = deserialized.to_substrait(schema)
+        deserialized_again = pc.Expression.from_substrait(serialized_again)
+        assert deserialized.equals(deserialized_again)
+
+    # Special case, we lose the field names of struct literals
+    f = exprs["special"][0]
+    serialized = f.to_substrait(schema)
+    deserialized = pc.Expression.from_substrait(serialized)
+    assert deserialized.equals(pc.scalar({'': 1}))
+
+    # Special case, is_in converts to a == opt[0] || a == opt[1] ...
+    a = pc.scalar(1)
+    expr = a.isin([1, 2, 3])
+    target = (a == 1) | (a == 2) | (a == 3)
+    serialized = expr.to_substrait(schema)
+    deserialized = pc.Expression.from_substrait(serialized)
+    # Compare str's here to bypass the bound/unbound difference
+    assert str(target) == str(deserialized)
+    serialized_again = deserialized.to_substrait(schema)
+    deserialized_again = pc.Expression.from_substrait(serialized_again)
+    assert deserialized.equals(deserialized_again)
+
+
 def test_expression_construction():
     zero = pc.scalar(0)
     one = pc.scalar(1)
diff --git a/python/pyarrow/tests/test_substrait.py b/python/pyarrow/tests/test_substrait.py
index 93ecae7bfa10e..be35a21a02411 100644
--- a/python/pyarrow/tests/test_substrait.py
+++ b/python/pyarrow/tests/test_substrait.py
@@ -21,8 +21,10 @@
 import pytest
 
 import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.dataset as ds
 from pyarrow.lib import tobytes
-from pyarrow.lib import ArrowInvalid
+from pyarrow.lib import ArrowInvalid, ArrowNotImplementedError
 
 try:
     import pyarrow.substrait as substrait
@@ -923,3 +925,106 @@ def table_provider(names, _):
 
     # Ordering of k is deterministic because this is running with serial execution
     assert res_tb == expected_tb
+
+
+@pytest.mark.parametrize("expr", [
+    pc.equal(ds.field("x"), 7),
+    pc.equal(ds.field("x"), ds.field("y")),
+    ds.field("x") > 50
+])
+def test_serializing_expressions(expr):
+    schema = pa.schema([
+        pa.field("x", pa.int32()),
+        pa.field("y", pa.int32())
+    ])
+
+    buf = pa.substrait.serialize_expressions([expr], ["test_expr"], schema)
+    returned = pa.substrait.deserialize_expressions(buf)
+    assert schema == returned.schema
+    assert len(returned.expressions) == 1
+    assert "test_expr" in returned.expressions
+
+
+def test_invalid_expression_ser_des():
+    schema = pa.schema([
+        pa.field("x", pa.int32()),
+        pa.field("y", pa.int32())
+    ])
+    expr = pc.equal(ds.field("x"), 7)
+    bad_expr = pc.equal(ds.field("z"), 7)
+    # Invalid number of names
+    with pytest.raises(ValueError) as excinfo:
+        pa.substrait.serialize_expressions([expr], [], schema)
+    assert 'need to have the same length' in str(excinfo.value)
+    with pytest.raises(ValueError) as excinfo:
+        pa.substrait.serialize_expressions([expr], ["foo", "bar"], schema)
+    assert 'need to have the same length' in str(excinfo.value)
+    # Expression doesn't match schema
+    with pytest.raises(ValueError) as excinfo:
+        pa.substrait.serialize_expressions([bad_expr], ["expr"], schema)
+    assert 'No match for FieldRef' in str(excinfo.value)
+
+
+def test_serializing_multiple_expressions():
+    schema = pa.schema([
+        pa.field("x", pa.int32()),
+        pa.field("y", pa.int32())
+    ])
+    exprs = [pc.equal(ds.field("x"), 7), pc.equal(ds.field("x"), ds.field("y"))]
+    buf = pa.substrait.serialize_expressions(exprs, ["first", "second"], schema)
+    returned = pa.substrait.deserialize_expressions(buf)
+    assert schema == returned.schema
+    assert len(returned.expressions) == 2
+
+    norm_exprs = [pc.equal(ds.field(0), 7), pc.equal(ds.field(0), ds.field(1))]
+    assert str(returned.expressions["first"]) == str(norm_exprs[0])
+    assert str(returned.expressions["second"]) == str(norm_exprs[1])
+
+
+def test_serializing_with_compute():
+    schema = pa.schema([
+        pa.field("x", pa.int32()),
+        pa.field("y", pa.int32())
+    ])
+    expr = pc.equal(ds.field("x"), 7)
+    expr_norm = pc.equal(ds.field(0), 7)
+    buf = expr.to_substrait(schema)
+    returned = pa.substrait.deserialize_expressions(buf)
+
+    assert schema == returned.schema
+    assert len(returned.expressions) == 1
+
+    assert str(returned.expressions["expression"]) == str(expr_norm)
+
+    # Compute can't deserialize messages with multiple expressions
+    buf = pa.substrait.serialize_expressions([expr, expr], ["first", "second"], schema)
+    with pytest.raises(ValueError) as excinfo:
+        pc.Expression.from_substrait(buf)
+    assert 'contained multiple expressions' in str(excinfo.value)
+
+    # Deserialization should be possible regardless of the expression name
+    buf = pa.substrait.serialize_expressions([expr], ["weirdname"], schema)
+    expr2 = pc.Expression.from_substrait(buf)
+    assert str(expr2) == str(expr_norm)
+
+
+def test_serializing_udfs():
+    # Note, UDF in this context means a function that is not
+    # recognized by Substrait.  It might still be a builtin pyarrow
+    # function.
+    schema = pa.schema([
+        pa.field("x", pa.uint32())
+    ])
+    a = pc.scalar(10)
+    b = pc.scalar(4)
+    exprs = [pc.shift_left(a, b)]
+
+    with pytest.raises(ArrowNotImplementedError):
+        pa.substrait.serialize_expressions(exprs, ["expr"], schema)
+
+    buf = pa.substrait.serialize_expressions(
+        exprs, ["expr"], schema, allow_arrow_extensions=True)
+    returned = pa.substrait.deserialize_expressions(buf)
+    assert schema == returned.schema
+    assert len(returned.expressions) == 1
+    assert str(returned.expressions["expr"]) == str(exprs[0])

From d062c899fbdaa7ce8b67ebe657c4bb76bf918d94 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 22 Aug 2023 15:08:37 -0400
Subject: [PATCH 208/749] GH-36103: [C++] Initial device sync API (#37040)

### Rationale for this change
Building on the `ArrowDeviceArray` we need to expand the abstractions for handling events and stream synchronization for devices.

### What changes are included in this PR?
Initial Abstract implementations for the new DeviceSync API and a CPU implementation. This will be followed up by a CUDA implementation in a subsequent PR.

### Are these changes tested?
Yes, tests are added for Import/Export DeviceArrays using the DeviceSync handling.

* Closes: #36103

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/buffer.h            |   2 +
 cpp/src/arrow/c/bridge.cc         |  44 ++---
 cpp/src/arrow/c/bridge.h          |  29 ++--
 cpp/src/arrow/c/bridge_test.cc    | 278 ++++++++++++++++++++++++++----
 cpp/src/arrow/device.cc           |   9 +
 cpp/src/arrow/device.h            |  66 +++++++
 cpp/src/arrow/gpu/cuda_context.cc |   7 +
 cpp/src/arrow/gpu/cuda_context.h  |   3 +
 8 files changed, 365 insertions(+), 73 deletions(-)

diff --git a/cpp/src/arrow/buffer.h b/cpp/src/arrow/buffer.h
index 08a3bd749e25d..7cc2d2c9cc8c4 100644
--- a/cpp/src/arrow/buffer.h
+++ b/cpp/src/arrow/buffer.h
@@ -346,6 +346,8 @@ class ARROW_EXPORT Buffer {
   static Result<std::shared_ptr<Buffer>> ViewOrCopy(
       std::shared_ptr<Buffer> source, const std::shared_ptr<MemoryManager>& to);
 
+  virtual std::shared_ptr<Device::SyncEvent> device_sync_event() { return NULLPTR; }
+
  protected:
   bool is_mutable_;
   bool is_cpu_;
diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index 13355dd6d05ae..b967af28e4aec 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -521,8 +521,7 @@ struct ExportedArrayPrivateData : PoolAllocationMixin<ExportedArrayPrivateData>
   SmallVector<struct ArrowArray*, 4> child_pointers_;
 
   std::shared_ptr<ArrayData> data_;
-
-  RawSyncEvent sync_event_;
+  std::shared_ptr<Device::SyncEvent> sync_;
 
   ExportedArrayPrivateData() = default;
   ARROW_DEFAULT_MOVE_AND_ASSIGN(ExportedArrayPrivateData);
@@ -547,10 +546,6 @@ void ReleaseExportedArray(struct ArrowArray* array) {
   }
   DCHECK_NE(array->private_data, nullptr);
   auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(array->private_data);
-  if (pdata->sync_event_.sync_event != nullptr &&
-      pdata->sync_event_.release_func != nullptr) {
-    pdata->sync_event_.release_func(pdata->sync_event_.sync_event);
-  }
   delete pdata;
 
   ArrowArrayMarkReleased(array);
@@ -591,7 +586,7 @@ struct ArrayExporter {
     // Store owning pointer to ArrayData
     export_.data_ = data;
 
-    export_.sync_event_ = RawSyncEvent();
+    export_.sync_ = nullptr;
     return Status::OK();
   }
 
@@ -714,12 +709,9 @@ Result<std::pair<std::optional<DeviceAllocationType>, int64_t>> ValidateDeviceIn
   return std::make_pair(device_type, device_id);
 }
 
-Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
+Status ExportDeviceArray(const Array& array, std::shared_ptr<Device::SyncEvent> sync,
                          struct ArrowDeviceArray* out, struct ArrowSchema* out_schema) {
-  if (sync_event.sync_event != nullptr && sync_event.release_func) {
-    return Status::Invalid(
-        "Must provide a release event function if providing a non-null event");
-  }
+  void* sync_event = sync ? sync->get_raw() : nullptr;
 
   SchemaExportGuard guard(out_schema);
   if (out_schema != nullptr) {
@@ -739,19 +731,20 @@ Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
   exporter.Finish(&out->array);
 
   auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(out->array.private_data);
-  pdata->sync_event_ = sync_event;
-  out->sync_event = sync_event.sync_event;
+  pdata->sync_ = std::move(sync);
+  out->sync_event = sync_event;
 
   guard.Detach();
   return Status::OK();
 }
 
-Status ExportDeviceRecordBatch(const RecordBatch& batch, RawSyncEvent sync_event,
+Status ExportDeviceRecordBatch(const RecordBatch& batch,
+                               std::shared_ptr<Device::SyncEvent> sync,
                                struct ArrowDeviceArray* out,
                                struct ArrowSchema* out_schema) {
-  if (sync_event.sync_event != nullptr && sync_event.release_func == nullptr) {
-    return Status::Invalid(
-        "Must provide a release event function if providing a non-null event");
+  void* sync_event{nullptr};
+  if (sync) {
+    sync_event = sync->get_raw();
   }
 
   // XXX perhaps bypass ToStructArray for speed?
@@ -776,8 +769,8 @@ Status ExportDeviceRecordBatch(const RecordBatch& batch, RawSyncEvent sync_event
   exporter.Finish(&out->array);
 
   auto* pdata = reinterpret_cast<ExportedArrayPrivateData*>(out->array.private_data);
-  pdata->sync_event_ = sync_event;
-  out->sync_event = sync_event.sync_event;
+  pdata->sync_ = std::move(sync);
+  out->sync_event = sync_event;
 
   guard.Detach();
   return Status::OK();
@@ -1362,7 +1355,7 @@ namespace {
 // The ArrowArray is released on destruction.
 struct ImportedArrayData {
   struct ArrowArray array_;
-  void* sync_event_;
+  std::shared_ptr<Device::SyncEvent> device_sync_;
 
   ImportedArrayData() {
     ArrowArrayMarkReleased(&array_);  // Initially released
@@ -1395,6 +1388,10 @@ class ImportedBuffer : public Buffer {
 
   ~ImportedBuffer() override {}
 
+  std::shared_ptr<Device::SyncEvent> device_sync_event() override {
+    return import_->device_sync_;
+  }
+
  protected:
   std::shared_ptr<ImportedArrayData> import_;
 };
@@ -1409,7 +1406,10 @@ struct ArrayImporter {
     ARROW_ASSIGN_OR_RAISE(memory_mgr_, mapper(src->device_type, src->device_id));
     device_type_ = static_cast<DeviceAllocationType>(src->device_type);
     RETURN_NOT_OK(Import(&src->array));
-    import_->sync_event_ = src->sync_event;
+    if (src->sync_event != nullptr) {
+      ARROW_ASSIGN_OR_RAISE(import_->device_sync_, memory_mgr_->WrapDeviceSyncEvent(
+                                                       src->sync_event, [](void*) {}));
+    }
     // reset internal state before next import
     memory_mgr_.reset();
     device_type_ = DeviceAllocationType::kCPU;
diff --git a/cpp/src/arrow/c/bridge.h b/cpp/src/arrow/c/bridge.h
index 92707a59729fc..45583109a761f 100644
--- a/cpp/src/arrow/c/bridge.h
+++ b/cpp/src/arrow/c/bridge.h
@@ -22,6 +22,7 @@
 #include <string>
 
 #include "arrow/c/abi.h"
+#include "arrow/device.h"
 #include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/type_fwd.h"
@@ -172,17 +173,6 @@ Result<std::shared_ptr<RecordBatch>> ImportRecordBatch(struct ArrowArray* array,
 ///
 /// @{
 
-/// \brief EXPERIMENTAL: Type for freeing a sync event
-///
-/// If synchronization is necessary for accessing the data on a device,
-/// a pointer to an event needs to be passed when exporting the device
-/// array. It's the responsibility of the release function for the array
-/// to release the event. Both can be null if no sync'ing is necessary.
-struct RawSyncEvent {
-  void* sync_event = NULL;
-  std::function<void(void*)> release_func;
-};
-
 /// \brief EXPERIMENTAL: Export C++ Array as an ArrowDeviceArray.
 ///
 /// The resulting ArrowDeviceArray struct keeps the array data and buffers alive
@@ -190,15 +180,15 @@ struct RawSyncEvent {
 /// the provided array MUST have the same device_type, otherwise an error
 /// will be returned.
 ///
-/// If a non-null sync_event is provided, then the sync_release func must also be
-/// non-null. If the sync_event is null, then the sync_release parameter is not called.
+/// If sync is non-null, get_event will be called on it in order to
+/// potentially provide an event for consumers to synchronize on.
 ///
 /// \param[in] array Array object to export
-/// \param[in] sync_event A struct containing what is needed for syncing if necessary
+/// \param[in] sync shared_ptr to object derived from Device::SyncEvent or null
 /// \param[out] out C struct to export the array to
 /// \param[out] out_schema optional C struct to export the array type to
 ARROW_EXPORT
-Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
+Status ExportDeviceArray(const Array& array, std::shared_ptr<Device::SyncEvent> sync,
                          struct ArrowDeviceArray* out,
                          struct ArrowSchema* out_schema = NULLPTR);
 
@@ -212,15 +202,16 @@ Status ExportDeviceArray(const Array& array, RawSyncEvent sync_event,
 /// otherwise an error will be returned. If columns are on different devices,
 /// they should be exported using different ArrowDeviceArray instances.
 ///
-/// If a non-null sync_event is provided, then the sync_release func must also be
-/// non-null. If the sync_event is null, then the sync_release parameter is ignored.
+/// If sync is non-null, get_event will be called on it in order to
+/// potentially provide an event for consumers to synchronize on.
 ///
 /// \param[in] batch Record batch to export
-/// \param[in] sync_event A struct containing what is needed for syncing if necessary
+/// \param[in] sync shared_ptr to object derived from Device::SyncEvent or null
 /// \param[out] out C struct where to export the record batch
 /// \param[out] out_schema optional C struct where to export the record batch schema
 ARROW_EXPORT
-Status ExportDeviceRecordBatch(const RecordBatch& batch, RawSyncEvent sync_event,
+Status ExportDeviceRecordBatch(const RecordBatch& batch,
+                               std::shared_ptr<Device::SyncEvent> sync,
                                struct ArrowDeviceArray* out,
                                struct ArrowSchema* out_schema = NULLPTR);
 
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 5c7de8e4a0783..9727403163e58 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -1135,12 +1135,49 @@ TEST_F(TestArrayExport, ExportRecordBatch) {
 
 static const char kMyDeviceTypeName[] = "arrowtest::MyDevice";
 static const ArrowDeviceType kMyDeviceType = ARROW_DEVICE_EXT_DEV;
+static const void* kMyEventPtr = reinterpret_cast<void*>(uintptr_t(0xBAADF00D));
 
 class MyBuffer final : public MutableBuffer {
  public:
   using MutableBuffer::MutableBuffer;
 
   ~MyBuffer() { default_memory_pool()->Free(const_cast<uint8_t*>(data_), size_); }
+
+  std::shared_ptr<Device::SyncEvent> device_sync_event() override { return device_sync_; }
+
+ protected:
+  std::shared_ptr<Device::SyncEvent> device_sync_;
+};
+
+class MyDevice : public Device {
+ public:
+  explicit MyDevice(int64_t value) : Device(true), value_(value) {}
+  const char* type_name() const override { return kMyDeviceTypeName; }
+  std::string ToString() const override { return kMyDeviceTypeName; }
+  bool Equals(const Device& other) const override {
+    if (other.type_name() != kMyDeviceTypeName || other.device_type() != device_type()) {
+      return false;
+    }
+    return checked_cast<const MyDevice&>(other).value_ == value_;
+  }
+  DeviceAllocationType device_type() const override {
+    return static_cast<DeviceAllocationType>(kMyDeviceType);
+  }
+  int64_t device_id() const override { return value_; }
+  std::shared_ptr<MemoryManager> default_memory_manager() override;
+
+  class MySyncEvent final : public Device::SyncEvent {
+   public:
+    explicit MySyncEvent(void* sync_event, release_fn_t release_sync_event)
+        : Device::SyncEvent(sync_event, release_sync_event) {}
+
+    virtual ~MySyncEvent() = default;
+    Status Wait() override { return Status::OK(); }
+    Status Record(const Device::Stream&) override { return Status::OK(); }
+  };
+
+ protected:
+  int64_t value_;
 };
 
 class MyMemoryManager : public CPUMemoryManager {
@@ -1154,6 +1191,16 @@ class MyMemoryManager : public CPUMemoryManager {
     return std::make_unique<MyBuffer>(data, size, shared_from_this());
   }
 
+  Result<std::shared_ptr<Device::SyncEvent>> MakeDeviceSyncEvent() override {
+    return std::make_shared<MyDevice::MySyncEvent>(const_cast<void*>(kMyEventPtr),
+                                                   [](void*) {});
+  }
+
+  Result<std::shared_ptr<Device::SyncEvent>> WrapDeviceSyncEvent(
+      void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) override {
+    return std::make_shared<MyDevice::MySyncEvent>(sync_event, release_sync_event);
+  }
+
  protected:
   Result<std::shared_ptr<Buffer>> CopyBufferFrom(
       const std::shared_ptr<Buffer>& buf,
@@ -1174,28 +1221,9 @@ class MyMemoryManager : public CPUMemoryManager {
   }
 };
 
-class MyDevice : public Device {
- public:
-  explicit MyDevice(int value) : Device(true), value_(value) {}
-  const char* type_name() const override { return kMyDeviceTypeName; }
-  std::string ToString() const override { return kMyDeviceTypeName; }
-  bool Equals(const Device& other) const override {
-    if (other.type_name() != kMyDeviceTypeName || other.device_type() != device_type()) {
-      return false;
-    }
-    return checked_cast<const MyDevice&>(other).value_ == value_;
-  }
-  DeviceAllocationType device_type() const override {
-    return static_cast<DeviceAllocationType>(kMyDeviceType);
-  }
-  int64_t device_id() const override { return value_; }
-  std::shared_ptr<MemoryManager> default_memory_manager() override {
-    return std::make_shared<MyMemoryManager>(shared_from_this());
-  }
-
- protected:
-  int value_;
-};
+std::shared_ptr<MemoryManager> MyDevice::default_memory_manager() {
+  return std::make_shared<MyMemoryManager>(shared_from_this());
+}
 
 class TestDeviceArrayExport : public ::testing::Test {
  public:
@@ -1251,7 +1279,8 @@ class TestDeviceArrayExport : public ::testing::Test {
                        ", array data = ", arr->ToString());
     const ArrayData& data = *arr->data();  // non-owning reference
     struct ArrowDeviceArray c_export;
-    ASSERT_OK(ExportDeviceArray(*arr, {nullptr, nullptr}, &c_export));
+    std::shared_ptr<Device::SyncEvent> sync{nullptr};
+    ASSERT_OK(ExportDeviceArray(*arr, sync, &c_export));
 
     ArrayExportGuard guard(&c_export.array);
     auto new_bytes = pool_->bytes_allocated();
@@ -1455,7 +1484,8 @@ TEST_F(TestDeviceArrayExport, ExportArrayAndType) {
   ArrayExportGuard array_guard(&c_array.array);
 
   auto array = ToDevice(mm, *ArrayFromJSON(int8(), "[1, 2, 3]")->data()).ValueOrDie();
-  ASSERT_OK(ExportDeviceArray(*array, {nullptr, nullptr}, &c_array, &c_schema));
+  auto sync = mm->MakeDeviceSyncEvent().ValueOrDie();
+  ASSERT_OK(ExportDeviceArray(*array, sync, &c_array, &c_schema));
   const ArrayData& data = *array->data();
   array.reset();
   ASSERT_FALSE(ArrowSchemaIsReleased(&c_schema));
@@ -1463,7 +1493,7 @@ TEST_F(TestDeviceArrayExport, ExportArrayAndType) {
   ASSERT_EQ(c_schema.format, std::string("c"));
   ASSERT_EQ(c_schema.n_children, 0);
   ArrayExportChecker checker{};
-  checker(&c_array, data, kMyDeviceType, 1, nullptr);
+  checker(&c_array, data, kMyDeviceType, 1, kMyEventPtr);
 }
 
 TEST_F(TestDeviceArrayExport, ExportRecordBatch) {
@@ -1481,25 +1511,25 @@ TEST_F(TestDeviceArrayExport, ExportRecordBatch) {
                   .ValueOrDie();
 
   auto batch_factory = [&]() { return RecordBatch::Make(schema, 3, {arr0, arr1}); };
-
+  auto sync = mm->MakeDeviceSyncEvent().ValueOrDie();
   {
     auto batch = batch_factory();
 
-    ASSERT_OK(ExportDeviceRecordBatch(*batch, {nullptr, nullptr}, &c_array, &c_schema));
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, sync, &c_array, &c_schema));
     SchemaExportGuard schema_guard(&c_schema);
     ArrayExportGuard array_guard(&c_array.array);
     RecordBatchExportChecker checker{};
-    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+    checker(&c_array, *batch, kMyDeviceType, 1, kMyEventPtr);
 
     // create batch anew, with the same buffer pointers
     batch = batch_factory();
-    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+    checker(&c_array, *batch, kMyDeviceType, 1, kMyEventPtr);
   }
   {
     // Check one can export both schema and record batch at once
     auto batch = batch_factory();
 
-    ASSERT_OK(ExportDeviceRecordBatch(*batch, {nullptr, nullptr}, &c_array, &c_schema));
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, sync, &c_array, &c_schema));
     SchemaExportGuard schema_guard(&c_schema);
     ArrayExportGuard array_guard(&c_array.array);
     ASSERT_EQ(c_schema.format, std::string("+s"));
@@ -1508,11 +1538,11 @@ TEST_F(TestDeviceArrayExport, ExportRecordBatch) {
     ASSERT_EQ(kEncodedMetadata2,
               std::string(c_schema.metadata, kEncodedMetadata2.size()));
     RecordBatchExportChecker checker{};
-    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+    checker(&c_array, *batch, kMyDeviceType, 1, kMyEventPtr);
 
     // Create batch anew, with the same buffer pointers
     batch = batch_factory();
-    checker(&c_array, *batch, kMyDeviceType, 1, nullptr);
+    checker(&c_array, *batch, kMyDeviceType, 1, kMyEventPtr);
   }
 }
 
@@ -3552,6 +3582,190 @@ TEST_F(TestArrayRoundtrip, RecordBatch) {
   }
 }
 
+class TestDeviceArrayRoundtrip : public ::testing::Test {
+ public:
+  using ArrayFactory = std::function<Result<std::shared_ptr<Array>>()>;
+
+  void SetUp() override { pool_ = default_memory_pool(); }
+
+  static Result<std::shared_ptr<MemoryManager>> DeviceMapper(ArrowDeviceType type,
+                                                             int64_t id) {
+    if (type != kMyDeviceType) {
+      return Status::NotImplemented("should only be MyDevice");
+    }
+
+    std::shared_ptr<Device> device = std::make_shared<MyDevice>(id);
+    return device->default_memory_manager();
+  }
+
+  static Result<std::shared_ptr<ArrayData>> ToDeviceData(
+      const std::shared_ptr<MemoryManager>& mm, const ArrayData& data) {
+    arrow::BufferVector buffers;
+    for (const auto& buf : data.buffers) {
+      if (buf) {
+        ARROW_ASSIGN_OR_RAISE(auto dest, mm->CopyBuffer(buf, mm));
+        buffers.push_back(dest);
+      } else {
+        buffers.push_back(nullptr);
+      }
+    }
+
+    arrow::ArrayDataVector children;
+    for (const auto& child : data.child_data) {
+      ARROW_ASSIGN_OR_RAISE(auto dest, ToDeviceData(mm, *child));
+      children.push_back(dest);
+    }
+
+    return ArrayData::Make(data.type, data.length, buffers, children, data.null_count,
+                           data.offset);
+  }
+
+  static Result<std::shared_ptr<Array>> ToDevice(const std::shared_ptr<MemoryManager>& mm,
+                                                 const ArrayData& data) {
+    ARROW_ASSIGN_OR_RAISE(auto result, ToDeviceData(mm, data));
+    return MakeArray(result);
+  }
+
+  static ArrayFactory ToDeviceFactory(const std::shared_ptr<MemoryManager>& mm,
+                                      ArrayFactory&& factory) {
+    return [&]() -> Result<std::shared_ptr<Array>> {
+      ARROW_ASSIGN_OR_RAISE(auto arr, factory());
+      return ToDevice(mm, *arr->data());
+    };
+  }
+
+  static ArrayFactory JSONArrayFactory(const std::shared_ptr<MemoryManager>& mm,
+                                       std::shared_ptr<DataType> type, const char* json) {
+    return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
+  }
+
+  static ArrayFactory SlicedArrayFactory(ArrayFactory factory) {
+    return [=]() -> Result<std::shared_ptr<Array>> {
+      ARROW_ASSIGN_OR_RAISE(auto arr, factory());
+      DCHECK_GE(arr->length(), 2);
+      return arr->Slice(1, arr->length() - 2);
+    };
+  }
+
+  template <typename ArrayFactory>
+  void TestWithArrayFactory(ArrayFactory&& factory) {
+    TestWithArrayFactory(factory, factory);
+  }
+
+  template <typename ArrayFactory, typename ExpectedArrayFactory>
+  void TestWithArrayFactory(ArrayFactory&& factory,
+                            ExpectedArrayFactory&& factory_expected) {
+    std::shared_ptr<Array> array;
+    struct ArrowDeviceArray c_array {};
+    struct ArrowSchema c_schema {};
+    ArrayExportGuard array_guard(&c_array.array);
+    SchemaExportGuard schema_guard(&c_schema);
+
+    auto orig_bytes = pool_->bytes_allocated();
+
+    ASSERT_OK_AND_ASSIGN(array, ToResult(factory()));
+    ASSERT_OK(ExportType(*array->type(), &c_schema));
+    std::shared_ptr<Device::SyncEvent> sync{nullptr};
+    ASSERT_OK(ExportDeviceArray(*array, sync, &c_array));
+
+    auto new_bytes = pool_->bytes_allocated();
+    if (array->type_id() != Type::NA) {
+      ASSERT_GT(new_bytes, orig_bytes);
+    }
+
+    array.reset();
+    ASSERT_EQ(pool_->bytes_allocated(), new_bytes);
+    ASSERT_OK_AND_ASSIGN(array, ImportDeviceArray(&c_array, &c_schema, DeviceMapper));
+    ASSERT_OK(array->ValidateFull());
+    ASSERT_TRUE(ArrowSchemaIsReleased(&c_schema));
+    ASSERT_TRUE(ArrowArrayIsReleased(&c_array.array));
+
+    // Re-export and re-import, now both at once
+    ASSERT_OK(ExportDeviceArray(*array, sync, &c_array, &c_schema));
+    array.reset();
+    ASSERT_OK_AND_ASSIGN(array, ImportDeviceArray(&c_array, &c_schema, DeviceMapper));
+    ASSERT_OK(array->ValidateFull());
+    ASSERT_TRUE(ArrowSchemaIsReleased(&c_schema));
+    ASSERT_TRUE(ArrowArrayIsReleased(&c_array.array));
+
+    // Check value of imported array
+    {
+      std::shared_ptr<Array> expected;
+      ASSERT_OK_AND_ASSIGN(expected, ToResult(factory_expected()));
+      AssertTypeEqual(*expected->type(), *array->type());
+      AssertArraysEqual(*expected, *array, true);
+    }
+    array.reset();
+    ASSERT_EQ(pool_->bytes_allocated(), orig_bytes);
+  }
+
+  template <typename BatchFactory>
+  void TestWithBatchFactory(BatchFactory&& factory) {
+    std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+    auto mm = device->default_memory_manager();
+
+    std::shared_ptr<RecordBatch> batch;
+    struct ArrowDeviceArray c_array {};
+    struct ArrowSchema c_schema {};
+    ArrayExportGuard array_guard(&c_array.array);
+    SchemaExportGuard schema_guard(&c_schema);
+
+    auto orig_bytes = pool_->bytes_allocated();
+    ASSERT_OK_AND_ASSIGN(batch, ToResult(factory()));
+    ASSERT_OK(ExportSchema(*batch->schema(), &c_schema));
+    ASSERT_OK_AND_ASSIGN(auto sync, mm->MakeDeviceSyncEvent());
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, sync, &c_array));
+
+    auto new_bytes = pool_->bytes_allocated();
+    batch.reset();
+    ASSERT_EQ(pool_->bytes_allocated(), new_bytes);
+    ASSERT_OK_AND_ASSIGN(batch,
+                         ImportDeviceRecordBatch(&c_array, &c_schema, DeviceMapper));
+    ASSERT_OK(batch->ValidateFull());
+    ASSERT_TRUE(ArrowSchemaIsReleased(&c_schema));
+    ASSERT_TRUE(ArrowArrayIsReleased(&c_array.array));
+
+    // Re-export and re-import, now both at once
+    ASSERT_OK(ExportDeviceRecordBatch(*batch, sync, &c_array, &c_schema));
+    batch.reset();
+    ASSERT_OK_AND_ASSIGN(batch,
+                         ImportDeviceRecordBatch(&c_array, &c_schema, DeviceMapper));
+    ASSERT_OK(batch->ValidateFull());
+    ASSERT_TRUE(ArrowSchemaIsReleased(&c_schema));
+    ASSERT_TRUE(ArrowArrayIsReleased(&c_array.array));
+
+    // Check value of imported record batch
+    {
+      std::shared_ptr<RecordBatch> expected;
+      ASSERT_OK_AND_ASSIGN(expected, ToResult(factory()));
+      AssertSchemaEqual(*expected->schema(), *batch->schema());
+      AssertBatchesEqual(*expected, *batch);
+    }
+    batch.reset();
+    ASSERT_EQ(pool_->bytes_allocated(), orig_bytes);
+  }
+
+  void TestWithJSON(const std::shared_ptr<MemoryManager>& mm,
+                    std::shared_ptr<DataType> type, const char* json) {
+    TestWithArrayFactory(JSONArrayFactory(mm, type, json));
+  }
+
+  void TestWithJSONSliced(const std::shared_ptr<MemoryManager>& mm,
+                          std::shared_ptr<DataType> type, const char* json) {
+    TestWithArrayFactory(SlicedArrayFactory(JSONArrayFactory(mm, type, json)));
+  }
+
+ protected:
+  MemoryPool* pool_;
+};
+
+TEST_F(TestDeviceArrayRoundtrip, Primitive) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  TestWithJSON(mm, int32(), "[4, 5, null]");
+}
+
 // TODO C -> C++ -> C roundtripping tests?
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/cpp/src/arrow/device.cc b/cpp/src/arrow/device.cc
index fbb0c3e1a4a39..14d3bac0af1b7 100644
--- a/cpp/src/arrow/device.cc
+++ b/cpp/src/arrow/device.cc
@@ -29,6 +29,15 @@ namespace arrow {
 
 MemoryManager::~MemoryManager() {}
 
+Result<std::shared_ptr<Device::SyncEvent>> MemoryManager::MakeDeviceSyncEvent() {
+  return nullptr;
+}
+
+Result<std::shared_ptr<Device::SyncEvent>> MemoryManager::WrapDeviceSyncEvent(
+    void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) {
+  return nullptr;
+}
+
 Device::~Device() {}
 
 #define COPY_BUFFER_SUCCESS(maybe_buffer) \
diff --git a/cpp/src/arrow/device.h b/cpp/src/arrow/device.h
index 9cc68fe8c82ce..55037ac418808 100644
--- a/cpp/src/arrow/device.h
+++ b/cpp/src/arrow/device.h
@@ -22,6 +22,8 @@
 #include <string>
 
 #include "arrow/io/type_fwd.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
 #include "arrow/type_fwd.h"
 #include "arrow/util/compare.h"
 #include "arrow/util/macros.h"
@@ -98,6 +100,54 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
   /// \brief Return the DeviceAllocationType of this device
   virtual DeviceAllocationType device_type() const = 0;
 
+  class SyncEvent;
+
+  /// \brief EXPERIMENTAL: An opaque wrapper for Device-specific streams
+  ///
+  /// In essence this is just a wrapper around a void* to represent the
+  /// standard concept of a stream/queue on a device. Derived classes
+  /// should be trivially constructible from it's device-specific counterparts.
+  class ARROW_EXPORT Stream {
+   public:
+    virtual const void* get_raw() const { return NULLPTR; }
+
+    /// \brief Make the stream wait on the provided event.
+    ///
+    /// Tells the stream that it should wait until the synchronization
+    /// event is completed without blocking the CPU.
+    virtual Status WaitEvent(const SyncEvent&) = 0;
+
+   protected:
+    Stream() = default;
+    virtual ~Stream() = default;
+  };
+
+  /// \brief EXPERIMENTAL: An object that provides event/stream sync primitives
+  class ARROW_EXPORT SyncEvent {
+   public:
+    using release_fn_t = void (*)(void*);
+
+    virtual ~SyncEvent() = default;
+
+    void* get_raw() { return sync_event_.get(); }
+
+    /// @brief Block until sync event is completed.
+    virtual Status Wait() = 0;
+
+    /// @brief Record the wrapped event on the stream so it triggers
+    /// the event when the stream gets to that point in its queue.
+    virtual Status Record(const Stream&) = 0;
+
+   protected:
+    /// If creating this with a passed in event, the caller must ensure
+    /// that the event lives until clear_event is called on this as it
+    /// won't own it.
+    explicit SyncEvent(void* sync_event, release_fn_t release_sync_event)
+        : sync_event_{sync_event, release_sync_event} {}
+
+    std::unique_ptr<void, release_fn_t> sync_event_;
+  };
+
  protected:
   ARROW_DISALLOW_COPY_AND_ASSIGN(Device);
   explicit Device(bool is_cpu = false) : is_cpu_(is_cpu) {}
@@ -165,6 +215,22 @@ class ARROW_EXPORT MemoryManager : public std::enable_shared_from_this<MemoryMan
   static Result<std::shared_ptr<Buffer>> ViewBuffer(
       const std::shared_ptr<Buffer>& source, const std::shared_ptr<MemoryManager>& to);
 
+  /// \brief Create a new SyncEvent.
+  ///
+  /// This version should construct the appropriate event for the device and
+  /// provide the unique_ptr with the correct deleter for the event type.
+  /// If the device does not require or work with any synchronization, it is
+  /// allowed for it to return a nullptr.
+  virtual Result<std::shared_ptr<Device::SyncEvent>> MakeDeviceSyncEvent();
+
+  /// \brief Wrap an event into a SyncEvent.
+  ///
+  /// @param sync_event passed in sync_event from the imported device array.
+  /// @param release_sync_event destructor to free sync_event. `nullptr` may be
+  ///        passed to indicate that no destruction/freeing is necessary
+  virtual Result<std::shared_ptr<Device::SyncEvent>> WrapDeviceSyncEvent(
+      void* sync_event, Device::SyncEvent::release_fn_t release_sync_event);
+
  protected:
   ARROW_DISALLOW_COPY_AND_ASSIGN(MemoryManager);
 
diff --git a/cpp/src/arrow/gpu/cuda_context.cc b/cpp/src/arrow/gpu/cuda_context.cc
index 869ea6453ccda..3e1af26cac39b 100644
--- a/cpp/src/arrow/gpu/cuda_context.cc
+++ b/cpp/src/arrow/gpu/cuda_context.cc
@@ -293,6 +293,13 @@ std::shared_ptr<CudaDevice> CudaMemoryManager::cuda_device() const {
   return checked_pointer_cast<CudaDevice>(device_);
 }
 
+Result<std::shared_ptr<Device::SyncEvent>> CudaMemoryManager::WrapDeviceSyncEvent(
+    void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) {
+  return nullptr;
+  // auto ev = reinterpret_cast<CUstream*>(sync_event);
+  // return std::make_shared<CudaDeviceSync>(ev);
+}
+
 Result<std::shared_ptr<io::RandomAccessFile>> CudaMemoryManager::GetBufferReader(
     std::shared_ptr<Buffer> buf) {
   if (*buf->device() != *device_) {
diff --git a/cpp/src/arrow/gpu/cuda_context.h b/cpp/src/arrow/gpu/cuda_context.h
index a1b95c7b4181d..79a2ec9f97581 100644
--- a/cpp/src/arrow/gpu/cuda_context.h
+++ b/cpp/src/arrow/gpu/cuda_context.h
@@ -179,6 +179,9 @@ class ARROW_EXPORT CudaMemoryManager : public MemoryManager {
   /// having to cast the `device()` result.
   std::shared_ptr<CudaDevice> cuda_device() const;
 
+  Result<std::shared_ptr<Device::SyncEvent>> WrapDeviceSyncEvent(
+      void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) override;
+
  protected:
   using MemoryManager::MemoryManager;
   static std::shared_ptr<CudaMemoryManager> Make(const std::shared_ptr<Device>& device);

From faa46522d64167c00b0340dea2c309a391525e7b Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 22 Aug 2023 15:50:57 -0400
Subject: [PATCH 209/749] GH-37253: [MATLAB] Add test cases which verify that
 the `NumFields`, `BitWidth`, and `ID` properties can not be modified to
 `hFixedWidth` test class (#37316)

### Rationale for this change

As @ sgilmore10 pointed out in https://github.com/apache/arrow/pull/37250#discussion_r1298747336, it makes sense to move the tests which verify that the `NumFields`, `BitWidth`, and `ID` properties cannot be set into the `hFixedWidthType` superclass, rather than having these tests implemented in `tTime32Type` and `tTime64Type`, since they are common to all fixed width types.

### What changes are included in this PR?

1. Moved tests which verify that the `BitWidth`, `NumFields`, and `ID` properties cannot be set out of the `tTime32Type` and `tTime64Type` classes and into the superclass `hFixedWidthType`.
2. Fixed typo in `tTime32Type` and `tTime64Type`. Changed variable name `schema` to `type`.

### Are these changes tested?

Yes.

1. Moved tests which verify that the `BitWidth`, `NumFields`, and `ID` properties cannot be set out of the `tTime32Type` and `tTime64Type` classes and into the superclass `hFixedWidthType`.

### Are there any user-facing changes?

No.

This pull request only modifies tests.
* Closes: #37253

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/test/arrow/type/hFixedWidthType.m | 33 ++++++++++++++++++++----
 matlab/test/arrow/type/tTime32Type.m     | 25 ++----------------
 matlab/test/arrow/type/tTime64Type.m     | 25 ++----------------
 3 files changed, 32 insertions(+), 51 deletions(-)

diff --git a/matlab/test/arrow/type/hFixedWidthType.m b/matlab/test/arrow/type/hFixedWidthType.m
index 308ac46011a6c..adb234bbd3f38 100644
--- a/matlab/test/arrow/type/hFixedWidthType.m
+++ b/matlab/test/arrow/type/hFixedWidthType.m
@@ -26,27 +26,50 @@
 
     methods(Test)
         function TestClass(testCase)
-        % Verify ArrowType is an object of the expected class type.
+            % Verify ArrowType is an object of the expected class type.
             name = string(class(testCase.ArrowType));
             testCase.verifyEqual(name, testCase.ClassName);
         end
 
         function TestTypeID(testCase)
-        % Verify ID is set to the appropriate arrow.type.ID value.
+            % Verify ID is set to the appropriate arrow.type.ID value.
             arrowType = testCase.ArrowType;
             testCase.verifyEqual(arrowType.ID, testCase.TypeID);
         end
 
         function TestBitWidth(testCase)
-        % Verify the BitWidth value.
+            % Verify the BitWidth value.
             arrowType = testCase.ArrowType;
             testCase.verifyEqual(arrowType.BitWidth, testCase.BitWidth);
         end
 
         function TestNumFields(testCase)
-        % Verify NumFields is set to 0 for primitive types.
+            % Verify NumFields is set to 0 for primitive types.
             arrowType = testCase.ArrowType;
             testCase.verifyEqual(arrowType.NumFields, int32(0));
         end
+
+        function TestBitWidthNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the BitWidth property.
+            arrowType = testCase.ArrowType;
+            testCase.verifyError(@() setfield(arrowType, "BitWidth", 64), "MATLAB:class:SetProhibited");
+        end
+
+        function TestIDNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the ID property.
+            arrowType = testCase.ArrowType;
+            testCase.verifyError(@() setfield(arrowType, "ID", 15), "MATLAB:class:SetProhibited");
+        end
+
+        function TestNumFieldsNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the NumFields property.
+            arrowType = testCase.ArrowType;
+            testCase.verifyError(@() setfield(arrowType, "NumFields", 2), "MATLAB:class:SetProhibited");
+        end
+
     end
-end
\ No newline at end of file
+
+end
diff --git a/matlab/test/arrow/type/tTime32Type.m b/matlab/test/arrow/type/tTime32Type.m
index 115b8dfe96b52..d778237588a27 100644
--- a/matlab/test/arrow/type/tTime32Type.m
+++ b/matlab/test/arrow/type/tTime32Type.m
@@ -107,29 +107,8 @@ function Display(testCase)
         function TimeUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the TimeUnit property.
-            schema = arrow.time32(TimeUnit="Millisecond");
-            testCase.verifyError(@() setfield(schema, "TimeUnit", "Second"), "MATLAB:class:SetProhibited");
-        end
-
-        function BitWidthNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the BitWidth property.
-            schema = arrow.time32(TimeUnit="Millisecond");
-            testCase.verifyError(@() setfield(schema, "BitWidth", 64), "MATLAB:class:SetProhibited");
-        end
-
-        function IDNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the ID property.
-            schema = arrow.time32(TimeUnit="Millisecond");
-            testCase.verifyError(@() setfield(schema, "ID", 15), "MATLAB:class:SetProhibited");
-        end
-
-        function NumFieldsNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the NumFields property.
-            schema = arrow.time32(TimeUnit="Millisecond");
-            testCase.verifyError(@() setfield(schema, "NumFields", 2), "MATLAB:class:SetProhibited");
+            type = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyError(@() setfield(type, "TimeUnit", "Second"), "MATLAB:class:SetProhibited");
         end
 
         function InvalidProxy(testCase)
diff --git a/matlab/test/arrow/type/tTime64Type.m b/matlab/test/arrow/type/tTime64Type.m
index 1b3998c5171f5..a231a76c615fd 100644
--- a/matlab/test/arrow/type/tTime64Type.m
+++ b/matlab/test/arrow/type/tTime64Type.m
@@ -108,29 +108,8 @@ function Display(testCase)
         function TimeUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the TimeUnit property.
-            schema = arrow.time64(TimeUnit="Nanosecond");
-            testCase.verifyError(@() setfield(schema, "TimeUnit", "Microsecond"), "MATLAB:class:SetProhibited");
-        end
-
-        function BitWidthNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the BitWidth property.
-            schema = arrow.time64(TimeUnit="Nanosecond");
-            testCase.verifyError(@() setfield(schema, "BitWidth", 32), "MATLAB:class:SetProhibited");
-        end
-
-        function IDNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the ID property.
-            schema = arrow.time64(TimeUnit="Nanosecond");
-            testCase.verifyError(@() setfield(schema, "ID", 15), "MATLAB:class:SetProhibited");
-        end
-
-        function NumFieldsNoSetter(testCase)
-            % Verify that an error is thrown when trying to set the value
-            % of the NumFields property.
-            schema = arrow.time64(TimeUnit="Nanosecond");
-            testCase.verifyError(@() setfield(schema, "NumFields", 2), "MATLAB:class:SetProhibited");
+            type = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyError(@() setfield(type, "TimeUnit", "Microsecond"), "MATLAB:class:SetProhibited");
         end
 
         function InvalidProxy(testCase)

From b3936b9f0d0a899480741f2026c0349bf876c210 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Wed, 23 Aug 2023 04:36:24 +0800
Subject: [PATCH 210/749] GH-37299: [C++] Fix clang-format version mismatch
 error with Homebrew's clang-format (#37300)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

On my mac system, the clang-format version information is:
```
➜  ~ clang-format -version
Homebrew clang-format version 16.0.4
```

This isn't matched by the current clang-format regex in the CMake setup:
```cmake
find_clang_tool(clang-format CLANG_FORMAT_BIN
                "^clang-format version ${ARROW_CLANG_TOOLS_VERSION_ESCAPED}")
```

### What changes are included in this PR?

Make regex more lenient to accomodate the Homebrew clang-format version string.

### Are these changes tested?
no

### Are there any user-facing changes?

no
* Closes: #37299

Authored-by: light-city <455954986@qq.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/FindClangTools.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/cmake_modules/FindClangTools.cmake b/cpp/cmake_modules/FindClangTools.cmake
index a00ff2c939db9..90df60bf541d4 100644
--- a/cpp/cmake_modules/FindClangTools.cmake
+++ b/cpp/cmake_modules/FindClangTools.cmake
@@ -108,7 +108,7 @@ else()
 endif()
 
 find_clang_tool(clang-format CLANG_FORMAT_BIN
-                "^clang-format version ${ARROW_CLANG_TOOLS_VERSION_ESCAPED}")
+                "clang-format version ${ARROW_CLANG_TOOLS_VERSION_ESCAPED}")
 if(CLANG_FORMAT_BIN)
   set(CLANG_FORMAT_FOUND 1)
   message(STATUS "clang-format found at ${CLANG_FORMAT_BIN}")

From 7da0bfff0a710e5ec7b9e44f5d060c781e233d92 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 23 Aug 2023 10:12:49 +0900
Subject: [PATCH 211/749] GH-37257: [Ruby][FlightSQL] Use the same options for
 auto prepared statement close request (#37258)

### Rationale for this change

If we don't pass the same options for auto prepared statement close request, the close request may be failed.
For example, it's caused when authentication information in the options.

### What changes are included in this PR?

`ArrowFlightSQL::Client#prepare` change is the main change to use the given options for auto prepared statement close  request too.

Other changes (`gaflight_server_call_context_foreach_incoming_header()` and related changes) are for testing the above change.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37257

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/arrow-flight-glib/client.cpp           |  2 +-
 c_glib/arrow-flight-glib/server.cpp           | 63 ++++++++++++++++---
 c_glib/arrow-flight-glib/server.h             | 19 +++---
 .../arrow-flight-glib-docs.xml                |  4 ++
 .../lib/arrow-flight-sql/client.rb            |  6 +-
 .../test/helper/server.rb                     |  7 ++-
 ruby/red-arrow-flight-sql/test/test-client.rb |  6 +-
 .../lib/arrow-flight/loader.rb                |  1 +
 .../lib/arrow-flight/server-call-context.rb   | 31 +++++++++
 9 files changed, 115 insertions(+), 24 deletions(-)
 create mode 100644 ruby/red-arrow-flight/lib/arrow-flight/server-call-context.rb

diff --git a/c_glib/arrow-flight-glib/client.cpp b/c_glib/arrow-flight-glib/client.cpp
index 65bc2d56a51f6..60dec29dbbdfb 100644
--- a/c_glib/arrow-flight-glib/client.cpp
+++ b/c_glib/arrow-flight-glib/client.cpp
@@ -148,7 +148,7 @@ gaflight_call_options_clear_headers(GAFlightCallOptions *options)
  * @func: (scope call): The user's callback function.
  * @user_data: (closure): Data for @func.
  *
- * Iterates over all header in the options.
+ * Iterates over all headers in the options.
  *
  * Since: 9.0.0
  */
diff --git a/c_glib/arrow-flight-glib/server.cpp b/c_glib/arrow-flight-glib/server.cpp
index 53ecbf6e08db5..9deb1623b16cd 100644
--- a/c_glib/arrow-flight-glib/server.cpp
+++ b/c_glib/arrow-flight-glib/server.cpp
@@ -293,9 +293,11 @@ gaflight_message_reader_get_descriptor(GAFlightMessageReader *reader)
 }
 
 
-typedef struct GAFlightServerCallContextPrivate_ {
+struct GAFlightServerCallContextPrivate {
   arrow::flight::ServerCallContext *call_context;
-} GAFlightServerCallContextPrivate;
+  std::string current_incoming_header_key;
+  std::string current_incoming_header_value;
+};
 
 enum {
   PROP_CALL_CONTEXT = 1,
@@ -310,6 +312,15 @@ G_DEFINE_TYPE_WITH_PRIVATE(GAFlightServerCallContext,
     gaflight_server_call_context_get_instance_private(  \
       GAFLIGHT_SERVER_CALL_CONTEXT(obj)))
 
+static void
+gaflight_server_call_context_finalize(GObject *object)
+{
+  auto priv = GAFLIGHT_SERVER_CALL_CONTEXT_GET_PRIVATE(object);
+  priv->current_incoming_header_key.~basic_string();
+  priv->current_incoming_header_value.~basic_string();
+  G_OBJECT_CLASS(gaflight_server_call_context_parent_class)->finalize(object);
+}
+
 static void
 gaflight_server_call_context_set_property(GObject *object,
                                           guint prop_id,
@@ -333,6 +344,9 @@ gaflight_server_call_context_set_property(GObject *object,
 static void
 gaflight_server_call_context_init(GAFlightServerCallContext *object)
 {
+  auto priv = GAFLIGHT_SERVER_CALL_CONTEXT_GET_PRIVATE(object);
+  new(&(priv->current_incoming_header_key)) std::string;
+  new(&(priv->current_incoming_header_value)) std::string;
 }
 
 static void
@@ -340,6 +354,7 @@ gaflight_server_call_context_class_init(GAFlightServerCallContextClass *klass)
 {
   auto gobject_class = G_OBJECT_CLASS(klass);
 
+  gobject_class->finalize = gaflight_server_call_context_finalize;
   gobject_class->set_property = gaflight_server_call_context_set_property;
 
   GParamSpec *spec;
@@ -351,6 +366,33 @@ gaflight_server_call_context_class_init(GAFlightServerCallContextClass *klass)
   g_object_class_install_property(gobject_class, PROP_CALL_CONTEXT, spec);
 }
 
+/**
+ * gaflight_server_call_context_foreach_incoming_header:
+ * @context: A #GAFlightServerCallContext.
+ * @func: (scope call): The user's callback function.
+ * @user_data: (closure): Data for @func.
+ *
+ * Iterates over all incoming headers.
+ *
+ * Since: 14.0.0
+ */
+void
+gaflight_server_call_context_foreach_incoming_header(
+  GAFlightServerCallContext *context,
+  GAFlightHeaderFunc func,
+  gpointer user_data)
+{
+  auto priv = GAFLIGHT_SERVER_CALL_CONTEXT_GET_PRIVATE(context);
+  auto flight_context = gaflight_server_call_context_get_raw(context);
+  for (const auto &header : flight_context->incoming_headers()) {
+    priv->current_incoming_header_key = std::string(header.first);
+    priv->current_incoming_header_value = std::string(header.second);
+    func(priv->current_incoming_header_key.c_str(),
+         priv->current_incoming_header_value.c_str(),
+         user_data);
+  }
+}
+
 
 struct GAFlightServerAuthSenderPrivate {
   arrow::flight::ServerAuthSender *sender;
@@ -630,9 +672,8 @@ namespace gaflight {
       auto klass = GAFLIGHT_SERVER_CUSTOM_AUTH_HANDLER_GET_CLASS(handler_);
       auto gacontext = gaflight_server_call_context_new_raw(&context);
       auto gtoken = g_bytes_new_static(token.data(), token.size());
-      GBytes *gpeer_identity = nullptr;
       GError *error = nullptr;
-      klass->is_valid(handler_, gacontext, gtoken, &gpeer_identity, &error);
+      auto gpeer_identity = klass->is_valid(handler_, gacontext, gtoken, &error);
       g_bytes_unref(gtoken);
       g_object_unref(gacontext);
       if (gpeer_identity) {
@@ -718,20 +759,20 @@ gaflight_server_custom_auth_handler_authenticate(
  * @context: A #GAFlightServerCallContext.
  * @token: The client token. May be the empty string if the client does not
  *   provide a token.
- * @peer_identity: (out): The identity of the peer, if this authentication
- *   method supports it.
  * @error: (nullable): Return location for a #GError or %NULL.
  *
  * Validates a per-call client token.
  *
+ * Returns: (nullable) (transfer full): The identity of the peer, if
+ *   this authentication method supports it.
+ *
  * Since: 12.0.0
  */
-void
+GBytes *
 gaflight_server_custom_auth_handler_is_valid(
   GAFlightServerCustomAuthHandler *handler,
   GAFlightServerCallContext *context,
   GBytes *token,
-  GBytes **peer_identity,
   GError **error)
 {
   auto flight_handler =
@@ -749,8 +790,10 @@ gaflight_server_custom_auth_handler_is_valid(
                     status,
                     "[flight-server-custom-auth-handler]"
                     "[is-valid]")) {
-    *peer_identity = g_bytes_new(flight_peer_identity.data(),
-                                 flight_peer_identity.size());
+    return g_bytes_new(flight_peer_identity.data(),
+                       flight_peer_identity.size());
+  } else {
+    return nullptr;
   }
 }
 
diff --git a/c_glib/arrow-flight-glib/server.h b/c_glib/arrow-flight-glib/server.h
index 7fa0dcf878000..77ecf36fd5221 100644
--- a/c_glib/arrow-flight-glib/server.h
+++ b/c_glib/arrow-flight-glib/server.h
@@ -84,6 +84,13 @@ struct _GAFlightServerCallContextClass
   GObjectClass parent_class;
 };
 
+GARROW_AVAILABLE_IN_14_0
+void
+gaflight_server_call_context_foreach_incoming_header(
+  GAFlightServerCallContext *context,
+  GAFlightHeaderFunc func,
+  gpointer user_data);
+
 
 #define GAFLIGHT_TYPE_SERVER_AUTH_SENDER        \
   (gaflight_server_auth_sender_get_type())
@@ -158,11 +165,10 @@ struct _GAFlightServerCustomAuthHandlerClass
                        GAFlightServerAuthSender *sender,
                        GAFlightServerAuthReader *reader,
                        GError **error);
-  void (*is_valid)(GAFlightServerCustomAuthHandler *handler,
-                   GAFlightServerCallContext *context,
-                   GBytes *token,
-                   GBytes **peer_identity,
-                   GError **error);
+  GBytes *(*is_valid)(GAFlightServerCustomAuthHandler *handler,
+                      GAFlightServerCallContext *context,
+                      GBytes *token,
+                      GError **error);
 };
 
 GARROW_AVAILABLE_IN_12_0
@@ -175,12 +181,11 @@ gaflight_server_custom_auth_handler_authenticate(
   GError **error);
 
 GARROW_AVAILABLE_IN_12_0
-void
+GBytes *
 gaflight_server_custom_auth_handler_is_valid(
   GAFlightServerCustomAuthHandler *handler,
   GAFlightServerCallContext *context,
   GBytes *token,
-  GBytes **peer_identity,
   GError **error);
 
 
diff --git a/c_glib/doc/arrow-flight-glib/arrow-flight-glib-docs.xml b/c_glib/doc/arrow-flight-glib/arrow-flight-glib-docs.xml
index e078b1c037b5f..e58ff375c5964 100644
--- a/c_glib/doc/arrow-flight-glib/arrow-flight-glib-docs.xml
+++ b/c_glib/doc/arrow-flight-glib/arrow-flight-glib-docs.xml
@@ -55,6 +55,10 @@
     <title>Index of deprecated API</title>
     <xi:include href="xml/api-index-deprecated.xml"><xi:fallback /></xi:include>
   </index>
+  <index id="api-index-14-0-0" role="14.0.0">
+    <title>Index of new symbols in 14.0.0</title>
+    <xi:include href="xml/api-index-14.0.0.xml"><xi:fallback /></xi:include>
+  </index>
   <index id="api-index-12-0-0" role="12.0.0">
     <title>Index of new symbols in 12.0.0</title>
     <xi:include href="xml/api-index-12.0.0.xml"><xi:fallback /></xi:include>
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb
index ff3169d5621b2..dc8815fced6e9 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/client.rb
@@ -18,13 +18,13 @@
 module ArrowFlightSQL
   class Client
     alias_method :prepare_raw, :prepare
-    def prepare(*args)
-      statement = prepare_raw(*args)
+    def prepare(query, options=nil)
+      statement = prepare_raw(query, options)
       if block_given?
         begin
           yield(statement)
         ensure
-          statement.close unless statement.closed?
+          statement.close(options) unless statement.closed?
         end
       else
         statement
diff --git a/ruby/red-arrow-flight-sql/test/helper/server.rb b/ruby/red-arrow-flight-sql/test/helper/server.rb
index f7c935fab91fa..6426e11f2984d 100644
--- a/ruby/red-arrow-flight-sql/test/helper/server.rb
+++ b/ruby/red-arrow-flight-sql/test/helper/server.rb
@@ -39,7 +39,7 @@ def virtual_do_do_get_statement(context, command)
     end
 
     def virtual_do_create_prepared_statement(context, request)
-      unless request.query == "INSERT INTO page_view_table VALUES (?, true)"
+      unless request.query == "INSERT INTO page_view_table VALUES ($1, true)"
         raise Arrow::Error::Invalid.new("invalid SQL")
       end
       result = ArrowFlightSQL::CreatePreparedStatementResult.new
@@ -62,6 +62,11 @@ def virtual_do_close_prepared_statement(context, request)
       unless request.handle.to_s == "valid-handle"
         raise Arrow::Error::Invalid.new("invalid handle")
       end
+      access_key = context.incoming_headers.assoc("x-access-key")
+      unless access_key == ["x-access-key", "secret"]
+        message = "invalid access key: #{access_key.inspect}"
+        raise Arrow::Error::Invalid.new(message)
+      end
     end
   end
 end
diff --git a/ruby/red-arrow-flight-sql/test/test-client.rb b/ruby/red-arrow-flight-sql/test/test-client.rb
index 21554c1bdab84..1fff21da0193c 100644
--- a/ruby/red-arrow-flight-sql/test/test-client.rb
+++ b/ruby/red-arrow-flight-sql/test/test-client.rb
@@ -41,9 +41,11 @@ def test_execute
   end
 
   def test_prepare
-    insert_sql = "INSERT INTO page_view_table VALUES (?, true)"
+    insert_sql = "INSERT INTO page_view_table VALUES ($1, true)"
     block_called = false
-    @sql_client.prepare(insert_sql) do |statement|
+    options = ArrowFlight::CallOptions.new
+    options.add_header("x-access-key", "secret")
+    @sql_client.prepare(insert_sql, options) do |statement|
       block_called = true
       assert_equal([
                      Arrow::Schema.new(count: :uint64, private: :boolean),
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/loader.rb b/ruby/red-arrow-flight/lib/arrow-flight/loader.rb
index 042e15769368e..e9e9e08f32dd9 100644
--- a/ruby/red-arrow-flight/lib/arrow-flight/loader.rb
+++ b/ruby/red-arrow-flight/lib/arrow-flight/loader.rb
@@ -34,6 +34,7 @@ def require_libraries
       require "arrow-flight/client-options"
       require "arrow-flight/location"
       require "arrow-flight/record-batch-reader"
+      require "arrow-flight/server-call-context"
       require "arrow-flight/server-options"
       require "arrow-flight/ticket"
     end
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/server-call-context.rb b/ruby/red-arrow-flight/lib/arrow-flight/server-call-context.rb
new file mode 100644
index 0000000000000..7cbad1fd079df
--- /dev/null
+++ b/ruby/red-arrow-flight/lib/arrow-flight/server-call-context.rb
@@ -0,0 +1,31 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 ArrowFlight
+  class ServerCallContext
+    def each_incoming_header
+      return to_enum(__method__) unless block_given?
+      foreach_incoming_header do |key, value|
+        yield(key, value)
+      end
+    end
+
+    def incoming_headers
+      each_incoming_header.to_a
+    end
+  end
+end

From 0781f1341446b8dbb281ac2910dc5e05ec982851 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 22 Aug 2023 22:49:35 -0400
Subject: [PATCH 212/749] GH-37290: [MATLAB] Add `arrow.array.Time32Array`
 class (#37315)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Now that the `arrow.type.Time32Type` class has been added to the MATLAB Interface (#37250), we can add the `arrow.array.Time32Array` class.

### What changes are included in this PR?

1. Added a new class `arrow.array.Time32Array`. It has the following read-only properties: `Type` and `Length`. It has the following methods: `fromMATLAB()`, `toMATLAB()`, and `duration()`. For reference, `duration` arrays in MATLAB represent lengths of time in fixed-length units. Here's a [link](https://www.mathworks.com/help/matlab/ref/duration.html) to the documentation.
2. Added a new class called `arrow.type.traits.Time32Traits`.

**Example Usage**

```matlab
>> times = seconds([100 120 NaN 200])

times =

  1×4 duration array

   100 sec   120 sec   NaN sec   200 sec

>> time32Array = arrow.array.Time32Array.fromMATLAB(times)

time32Array =

[
  00:01:40,
  00:02:00,
  null,
  00:03:20
]

>> roundtrip = toMATLAB(time32Array)

roundtrip =

  4×1 duration array

   100 sec
   120 sec
   NaN sec
   200 sec

```

You can also specify the `TimeUnit` to use via a name-value pair. `TimeUnit` can either be `"Second"`  (default) or `"Milisecond"`.

```matlab
>> times = seconds([100 120 NaN 200]);
>> time32Array = arrow.array.Time32Array.fromMATLAB(times, TimeUnit="Millisecond")

time32Array =

[
  00:01:40.000,
  00:02:00.000,
  null,
  00:03:20.000
]
```

### Are these changes tested?

Yes. Added two new test classes: `tTime32Array.m` and `tTime32Traits.m`.

### Are there any user-facing changes?

Yes, users can now create `arrow.array.Time32Array`s from MATLAB `duration`s via the static `fromMATLAB` method on `arrow.array.Time32Array`.

### Future Directions

1. Add `arrow.array.Time64Array`
2. Add `arrow.type.Date32Type` and `arrow.array.Date32Array`
4. Add `arrow.type.Date64Type` and `arrow.array.Date64Array`

* Closes: #37290

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../arrow/matlab/array/proxy/time32_array.cc  |  62 +++++
 .../arrow/matlab/array/proxy/time32_array.h   |  31 +++
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   3 +
 matlab/src/matlab/+arrow/+array/Time32Array.m |  84 +++++++
 .../+arrow/+type/+traits/Time32Traits.m       |  29 +++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   2 +
 matlab/test/arrow/array/tTime32Array.m        | 220 ++++++++++++++++++
 matlab/test/arrow/type/traits/tTime32Traits.m |  32 +++
 matlab/test/arrow/type/traits/ttraits.m       |  12 +
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 11 files changed, 478 insertions(+)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/time32_array.h
 create mode 100644 matlab/src/matlab/+arrow/+array/Time32Array.m
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
 create mode 100644 matlab/test/arrow/array/tTime32Array.m
 create mode 100644 matlab/test/arrow/type/traits/tTime32Traits.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
new file mode 100644
index 0000000000000..5def045a9d77d
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/array/proxy/time32_array.h"
+
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/util/utf8.h"
+
+namespace arrow::matlab::array::proxy {
+
+    // Specialization of NumericArray::Make for arrow::Time32Type
+    template <>
+    libmexclass::proxy::MakeResult Time32Array::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+       namespace mda = ::matlab::data;
+       using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+       using Time32Array = arrow::Time32Array;
+       using Time32ArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>;
+
+       mda::StructArray opts = constructor_arguments[0];
+
+       // Get the mxArray from constructor arguments
+       const mda::TypedArray<int32_t> time32_mda = opts[0]["MatlabArray"];
+       const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+       
+       const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
+
+       // extract the time unit
+       const std::u16string& u16_timeunit = units_mda[0];
+       MATLAB_ASSIGN_OR_ERROR(const auto time_unit,
+                              arrow::matlab::type::timeUnitFromString(u16_timeunit),
+                              error::UKNOWN_TIME_UNIT_ERROR_ID)
+
+       // create the Time32Type
+       auto data_type = arrow::time32(time_unit);
+       auto array_length = static_cast<int32_t>(time32_mda.getNumberOfElements()); // cast size_t to int32_t
+
+       auto data_buffer = std::make_shared<MatlabBuffer>(time32_mda);
+
+       // Pack the validity bitmap values.
+       MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap,
+                              bit::packValid(validity_bitmap_mda),
+                              error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+       auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
+       auto time32_array = std::static_pointer_cast<Time32Array>(arrow::MakeArray(array_data));
+       return std::make_shared<Time32ArrayProxy>(std::move(time32_array));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.h
new file mode 100644
index 0000000000000..6770adeaed67d
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.h
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/array/proxy/numeric_array.h"
+
+#include "arrow/matlab/api/visibility.h"
+
+namespace arrow::matlab::array::proxy {
+
+    using Time32Array = NumericArray<arrow::Time32Type>;
+
+    // Specialization of NumericArray::Make for arrow::Time32Type
+    template<>
+    ARROW_MATLAB_EXPORT libmexclass::proxy::MakeResult Time32Array::make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+}
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index ec6a544c4fac9..554046f600abc 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -19,6 +19,7 @@
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
 #include "arrow/matlab/array/proxy/timestamp_array.h"
+#include "arrow/matlab/array/proxy/time32_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
@@ -49,6 +50,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.BooleanArray  , arrow::matlab::array::proxy::BooleanArray);
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
+    REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index b01148fe1c0a9..39c60fea9bc5c 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -19,6 +19,7 @@
 
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -50,6 +51,8 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<PrimitiveCType<double>>(std::static_pointer_cast<arrow::DoubleType>(type));
             case ID::TIMESTAMP:
                 return std::make_shared<TimestampType>(std::static_pointer_cast<arrow::TimestampType>(type));
+            case ID::TIME32:
+                return std::make_shared<Time32Type>(std::static_pointer_cast<arrow::Time32Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
             default:
diff --git a/matlab/src/matlab/+arrow/+array/Time32Array.m b/matlab/src/matlab/+arrow/+array/Time32Array.m
new file mode 100644
index 0000000000000..85babd26a721a
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/Time32Array.m
@@ -0,0 +1,84 @@
+% arrow.array.Time32Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time32Array < arrow.array.Array
+
+    properties(Access=private)
+        NullSubstitutionValue = seconds(NaN);
+    end
+
+    methods
+        function obj = Time32Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Time32Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function times = toMATLAB(obj)
+            import arrow.type.TimeUnit
+
+            matlabArray = obj.Proxy.toMATLAB();
+            if obj.Type.TimeUnit == TimeUnit.Second
+                times = seconds(matlabArray);
+            else
+                times = milliseconds(matlabArray);
+            end
+            times(~obj.Valid) = obj.NullSubstitutionValue;
+        end
+
+        function times = duration(obj)
+            times = obj.toMATLAB();
+        end
+    end
+
+    methods(Static, Access=private)
+        function ticks = convertDurationToTicks(data, timeUnit)
+            if (timeUnit == arrow.type.TimeUnit.Second)
+                ticks = cast(seconds(data), "int32");
+            else
+                ticks = cast(milliseconds(data), "int32");
+            end
+        end
+    end
+
+    methods(Static)
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.TimeUnit(1, 1) TimeUnit {timeUnit("Time32", opts.TimeUnit)} = TimeUnit.Second
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            import arrow.type.TimeUnit
+            import arrow.array.Time32Array
+            import arrow.internal.validate.temporal.timeUnit
+            
+            arrow.internal.validate.type(data, "duration");
+            arrow.internal.validate.shape(data);
+
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            ticks = Time32Array.convertDurationToTicks(data, opts.TimeUnit);
+
+            args = struct(MatlabArray=ticks, Valid=validElements, TimeUnit=string(opts.TimeUnit));
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.Time32Array", args);
+            array = Time32Array(proxy);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
new file mode 100644
index 0000000000000..844740167c380
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
@@ -0,0 +1,29 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time32Traits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        ArrayConstructor = @arrow.array.Time32Array
+        ArrayClassName = "arrow.array.Time32Array"
+        ArrayProxyClassName = "arrow.array.proxy.Time32Array"
+        TypeConstructor = @arrow.type.Time32Type;
+        TypeClassName = "arrow.type.Time32Type"
+        TypeProxyClassName = "arrow.type.proxy.Time32Type"
+        MatlabConstructor = @duration
+        MatlabClassName = "duration"
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index af59e2822df96..0c3628f01e561 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -48,6 +48,8 @@
                 typeTraits = StringTraits();
             case ID.Timestamp
                 typeTraits = TimestampTraits();
+            case ID.Time32
+                typeTraits = Time32Traits();
             otherwise
                 error("arrow:type:traits:UnsupportedArrowTypeID", "Unsupported Arrow type ID: " + type);
         end
diff --git a/matlab/test/arrow/array/tTime32Array.m b/matlab/test/arrow/array/tTime32Array.m
new file mode 100644
index 0000000000000..d885cd80cc972
--- /dev/null
+++ b/matlab/test/arrow/array/tTime32Array.m
@@ -0,0 +1,220 @@
+%TTIME32ARRAY Unit tests for arrow.array.Time32Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime32Array < matlab.unittest.TestCase
+
+    properties
+        ArrowArrayConstructorFcn = @arrow.array.Time32Array.fromMATLAB
+    end
+
+    properties(TestParameter)
+        Unit = {arrow.type.TimeUnit.Second, arrow.type.TimeUnit.Millisecond}
+    end
+
+    methods (Test)
+        function Basic(tc)
+            times = seconds(1:4);
+            array = tc.ArrowArrayConstructorFcn(times);
+            tc.verifyInstanceOf(array, "arrow.array.Time32Array");
+        end
+
+        function TypeIsTime32(tc)
+            times = seconds(1:4);
+            array = tc.ArrowArrayConstructorFcn(times);
+            tc.verifyTime32Type(array.Type, arrow.type.TimeUnit.Second);
+        end
+
+        function SupportedTimeUnit(tc)
+            import arrow.type.TimeUnit
+            times = seconds(1:4);
+            
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit="Second");
+            tc.verifyTime32Type(array.Type, arrow.type.TimeUnit.Second);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Second);
+            tc.verifyTime32Type(array.Type, arrow.type.TimeUnit.Second);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit="Millisecond");
+            tc.verifyTime32Type(array.Type, arrow.type.TimeUnit.Millisecond);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Millisecond);
+            tc.verifyTime32Type(array.Type, arrow.type.TimeUnit.Millisecond);
+        end
+
+        function UnsupportedTimeUnitError(tc)
+            % Verify arrow.array.Time32Array.fromMATLAB() errors if 
+            % supplied an unsupported TimeUnit (Microsecond or Nanosecond).
+            import arrow.type.TimeUnit
+            times = seconds(1:4);
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit="Microsecond");
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime32TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Microsecond);
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime32TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit="Nanosecond");
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime32TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Nanosecond);
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime32TimeUnit");
+        end
+
+        function TestLength(testCase)
+            % Verify the Length property.
+
+            times = duration.empty(0, 1);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+
+            times = duration(1, 2, 3);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(1));
+
+            times = duration(1, 2, 3) + hours(0:4);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(5));
+        end
+
+        function TestToMATLAB(testCase, Unit)
+            % Verify toMATLAB() round-trips the original duration array.
+            times = seconds([100 200 355 400]);
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit);
+            values = toMATLAB(array);
+            testCase.verifyEqual(values, times');
+        end
+
+        function TestDuration(testCase, Unit)
+            % Verify duration() round-trips the original duration array.
+            times = seconds([100 200 355 400]);
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit);
+            values = duration(array);
+            testCase.verifyEqual(values, times');
+        end
+
+        function TestValid(testCase, Unit)
+            % Verify the Valid property returns the expected logical vector.
+            times = seconds([100 200 NaN 355 NaN 400]);
+            arrray = testCase.ArrowArrayConstructorFcn(times, TImeUnit=Unit);
+            testCase.verifyEqual(arrray.Valid, [true; true; false; true; false; true]);
+            testCase.verifyEqual(toMATLAB(arrray), times');
+            testCase.verifyEqual(duration(arrray), times');
+        end
+
+        function InferNullsTrueNVPair(testCase, Unit)
+            % Verify arrow.array.Time32Array.fromMATLAB() behaves as
+            % expected when InferNulls=true is provided.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            array = testCase.ArrowArrayConstructorFcn(times, InferNulls=true, TimeUnit=Unit);
+            expectedValid = [true; true; false; true; true; false; true];
+            testCase.verifyEqual(array.Valid, expectedValid);
+            testCase.verifyEqual(toMATLAB(array), times');
+            testCase.verifyEqual(duration(array), times');
+        end
+
+        function InferNullsFalseNVPair(testCase, Unit)
+            % Verify arrow.array.Time32Array.fromMATLAB() behaves as
+            % expected when InferNulls=false is provided.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            array = testCase.ArrowArrayConstructorFcn(times, InferNulls=false, TimeUnit=Unit);
+            expectedValid = true([7 1]);
+            testCase.verifyEqual(array.Valid, expectedValid);
+
+            % If NaN durations were not considered null values, then they
+            % are treated like int32(0) values.
+            expectedTime = times';
+            expectedTime([3 6]) = 0;
+            testCase.verifyEqual(toMATLAB(array), expectedTime);
+            testCase.verifyEqual(duration(array), expectedTime);
+        end
+
+        function TestValidNVPair(testCase, Unit)
+            % Verify arrow.array.Time32Array.fromMATLAB() accepts the Valid
+            % nv-pair, and it behaves as expected.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            
+            % Supply the Valid name-value pair as vector of indices.
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit, Valid=[1 2 3 5]);
+            testCase.verifyEqual(array.Valid, [true; true; true; false; true; false; false]);
+            expectedTimes = times';
+            expectedTimes(3) = 0;
+            expectedTimes([4 6 7]) = NaN;
+            testCase.verifyEqual(toMATLAB(array), expectedTimes);
+
+            % Supply the Valid name-value pair as a logical scalar.
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit, Valid=false);
+            testCase.verifyEqual(array.Valid, false([7 1]));
+            expectedTimes(:) = NaN;
+            testCase.verifyEqual(toMATLAB(array), expectedTimes);
+        end
+
+        function EmptyDurationVector(testCase)
+            % Verify arrow.array.Time32Array.fromMATLAB() accepts any
+            % empty-shaped duration as input.
+
+            times = duration.empty(0, 0);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
+
+            % Test with an N-Dimensional empty array
+            times = duration.empty(0, 1, 0);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
+        end
+
+        function ErrorIfNonVector(testCase)
+            % Verify arrow.array.Time32Array.fromMATLAB() throws an error
+            % if the input provided is not a vector.
+
+            times = duration(200, 45, 34) + hours(0:11);
+            times = reshape(times, 2, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+
+            times = reshape(times, 3, 2, 2);
+            fcn = @() testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+        end
+
+        function ErrorIfNonDuration(testCase)
+            % Verify arrow.array.Time32Array.fromMATLAB() throws an error
+            % if not given a duration as input.
+
+            dates = datetime(2023, 4, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+
+            numbers = [1; 2; 3; 4];
+            fcn = @() testCase.ArrowArrayConstructorFcn(numbers);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+        end
+    end
+
+    methods
+        function verifyTime32Type(testCase, actual, expectedTimeUnit)
+            testCase.verifyInstanceOf(actual, "arrow.type.Time32Type");
+            testCase.verifyEqual(actual.ID, arrow.type.ID.Time32);
+            testCase.verifyEqual(actual.TimeUnit, expectedTimeUnit);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/tTime32Traits.m b/matlab/test/arrow/type/traits/tTime32Traits.m
new file mode 100644
index 0000000000000..52e00a901aa3f
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tTime32Traits.m
@@ -0,0 +1,32 @@
+%TTIME32TRAITS Unit tests for arrow.type.traits.Time32Traits
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime32Traits < hTypeTraits
+    
+    properties
+        TraitsConstructor = @arrow.type.traits.Time32Traits
+        ArrayConstructor = @arrow.array.Time32Array
+        ArrayClassName = "arrow.array.Time32Array"
+        ArrayProxyClassName = "arrow.array.proxy.Time32Array"
+        TypeConstructor = @arrow.type.Time32Type
+        TypeClassName = "arrow.type.Time32Type"
+        TypeProxyClassName = "arrow.type.proxy.Time32Type"
+        MatlabConstructor = @duration
+        MatlabClassName = "duration"
+    end
+    
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index 14149a5ebff48..3bfde78dbb615 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -151,6 +151,18 @@ function TestBoolean(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestTime32(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.Time32;
+            expectedTraits = Time32Traits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits); 
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index c421cb904e607..477d7e6724d5a 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -45,6 +45,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/boolean_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time32_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"

From 7c1e71c6b672e606a0f5aaa513251dd2c3ef0648 Mon Sep 17 00:00:00 2001
From: Rajat Subhra Mukherjee <raromukherjee@gmail.com>
Date: Wed, 23 Aug 2023 13:10:27 +0530
Subject: [PATCH 213/749] GH-35167: [Docs][C++] Use new API for
 arrow::json::TableReader (#37301)

### Rationale for this change

The current document causes a build error.

### What changes are included in this PR?

Use the current API.

### Are these changes tested?

No.

### Are there any user-facing changes?

Yes.

* Closes: #35167

Lead-authored-by: Rajat Subhra Mukherjee <raromukherjee@gmail.com>
Co-authored-by: Will Jones <willjones127@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/cpp/json.rst | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/docs/source/cpp/json.rst b/docs/source/cpp/json.rst
index 003e768529695..3e49c045c8a92 100644
--- a/docs/source/cpp/json.rst
+++ b/docs/source/cpp/json.rst
@@ -49,7 +49,6 @@ the output table.
 
    {
       // ...
-      arrow::Status st;
       arrow::MemoryPool* pool = default_memory_pool();
       std::shared_ptr<arrow::io::InputStream> input = ...;
 
@@ -57,20 +56,19 @@ the output table.
       auto parse_options = arrow::json::ParseOptions::Defaults();
 
       // Instantiate TableReader from input stream and options
-      std::shared_ptr<arrow::json::TableReader> reader;
-      st = arrow::json::TableReader::Make(pool, input, read_options,
-                                          parse_options, &reader);
-      if (!st.ok()) {
+      auto maybe_reader = arrow::json::TableReader::Make(pool, input, read_options, parse_options);
+      if (!maybe_reader.ok()) {
          // Handle TableReader instantiation error...
       }
+      auto reader = *maybe_reader;
 
-      std::shared_ptr<arrow::Table> table;
       // Read table from JSON file
-      st = reader->Read(&table);
-      if (!st.ok()) {
+      auto maybe_table = reader->Read();
+      if (!maybe_table.ok()) {
          // Handle JSON read error
          // (for example a JSON syntax error or failed type conversion)
       }
+      auto table = *maybe_table;
    }
 
 StreamingReader

From bfb921998c6f2b24c7de05ee78b6935366b51a1a Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Wed, 23 Aug 2023 19:04:26 +0800
Subject: [PATCH 214/749] GH-37276: [C++] Skip multithread tests on single
 thread env (#37327)

### Rationale for this change

Some tests assume a multi-threaded environment without checking the actual threading capacity. Given that they intend to check the behavior of multi-threaded execution, they should be skipped if there is only one thread available.

### What changes are included in this PR?

`SegmentedAggregationWithMultiThreading` and `InvalidRowsSkippedAsync` are skipped if there is only one thread available in the default ThreadPool.

### Are these changes tested?

Tested on my local machine. Unfortunately there is no single core CI pipeline avaible.

### Are there any user-facing changes?
 No.

* Closes: #37276

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/acero/plan_test.cc | 3 +++
 cpp/src/arrow/csv/reader_test.cc | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/cpp/src/arrow/acero/plan_test.cc b/cpp/src/arrow/acero/plan_test.cc
index 03e10483ebf00..e74ad6a6665a4 100644
--- a/cpp/src/arrow/acero/plan_test.cc
+++ b/cpp/src/arrow/acero/plan_test.cc
@@ -1623,6 +1623,9 @@ TEST(ExecPlanExecution, SegmentedAggregationWithMultiThreading) {
 #ifndef ARROW_ENABLE_THREADING
   GTEST_SKIP() << "Test requires threading enabled";
 #endif
+  if (internal::GetCpuThreadPool()->GetCapacity() < 2) {
+    GTEST_SKIP() << "Test requires at least 2 threads";
+  }
   BatchesWithSchema data;
   data.batches = {ExecBatchFromJSON({int32()}, "[[1]]")};
   data.schema = schema({field("i32", int32())});
diff --git a/cpp/src/arrow/csv/reader_test.cc b/cpp/src/arrow/csv/reader_test.cc
index 9febdc243c5ea..57cc7d8efa571 100644
--- a/cpp/src/arrow/csv/reader_test.cc
+++ b/cpp/src/arrow/csv/reader_test.cc
@@ -315,6 +315,9 @@ TEST(StreamingReaderTests, InvalidRowsSkipped) {
   TestInvalidRowsSkipped(MakeStreamingFactory(/*use_threads=*/false), /*async=*/false);
 }
 TEST(StreamingReaderTests, InvalidRowsSkippedAsync) {
+  if (internal::GetCpuThreadPool()->GetCapacity() < 2) {
+    GTEST_SKIP() << "Test requires at least 2 threads";
+  }
   TestInvalidRowsSkipped(MakeStreamingFactory(), /*async=*/true);
 }
 

From ac5468c9dba9f8a3239d4738b114672c0f3ee68f Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 23 Aug 2023 13:50:11 +0200
Subject: [PATCH 215/749] GH-37303: [Python] Update test_option_class_equality
 due to CumulativeSumOptions refactor (#37305)

### Rationale for this change

Merging of https://github.com/apache/arrow/pull/36977 caused a CI failure due to a test giving a warning.

### What changes are included in this PR?

Add a `filterwarnings` mark to the failing tests. This also tests the deprecation message.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37303

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/tests/test_compute.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 03d2688e65705..6ee54ca4b1259 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -135,6 +135,9 @@ def test_exported_option_classes():
                                       param.VAR_KEYWORD)
 
 
+@pytest.mark.filterwarnings(
+    "ignore:pyarrow.CumulativeSumOptions is deprecated as of 14.0"
+)
 def test_option_class_equality():
     options = [
         pc.ArraySortOptions(),
@@ -214,8 +217,8 @@ def test_option_class_equality():
         buf = option.serialize()
         deserialized = pc.FunctionOptions.deserialize(buf)
         assert option == deserialized
-        # TODO remove the check under the if statement
-        # when the deprecated class CumulativeSumOptions is removed.
+        # TODO remove the check under the if statement and the filterwarnings
+        # mark when the deprecated class CumulativeSumOptions is removed.
         if repr(option).startswith("CumulativeSumOptions"):
             assert repr(deserialized).startswith("CumulativeOptions")
         else:

From ebf03a6dd389251620172bbc711d19477bf5644f Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 23 Aug 2023 15:32:37 +0200
Subject: [PATCH 216/749] GH-37330: [Docs][CI]Increase the Timeout for the
 Sphinx build (#37331)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Failing Sphinc Documentation job due to the timeout limit
https://github.com/apache/arrow/actions/runs/5899257777/job/16097467804

### What changes are included in this PR?

Increase the timeout for `AMD64 Conda Python 3.9 Sphinx Documentation` from 45min to 60min.
* Closes: #37330

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .github/workflows/docs_light.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/docs_light.yml b/.github/workflows/docs_light.yml
index ed8cd12ca361e..b1e6a21eada7b 100644
--- a/.github/workflows/docs_light.yml
+++ b/.github/workflows/docs_light.yml
@@ -41,7 +41,7 @@ jobs:
     name: AMD64 Conda Python 3.9 Sphinx Documentation
     runs-on: ubuntu-latest
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
-    timeout-minutes: 45
+    timeout-minutes: 60
     env:
       PYTHON: "3.9"
     steps:

From 5da0465db250fad2db44c4d1f224691908062427 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 23 Aug 2023 16:00:03 +0200
Subject: [PATCH 217/749] MINOR: [Release] Update versions for 14.0.0-SNAPSHOT

---
 c_glib/meson.build                            |  2 +-
 ci/scripts/PKGBUILD                           |  2 +-
 cpp/CMakeLists.txt                            |  2 +-
 cpp/vcpkg.json                                |  2 +-
 csharp/Directory.Build.props                  |  2 +-
 .../homebrew-formulae/apache-arrow-glib.rb    |  2 +-
 dev/tasks/homebrew-formulae/apache-arrow.rb   |  2 +-
 .../autobrew/apache-arrow.rb                  |  2 +-
 docs/source/_static/versions.json             |  8 +++--
 go/arrow/_examples/helloworld/main.go         |  8 ++---
 go/arrow/_tools/tmpl/main.go                  |  2 +-
 go/arrow/array.go                             |  4 +--
 go/arrow/array/array.go                       |  6 ++--
 go/arrow/array/array_test.go                  | 10 +++----
 go/arrow/array/binary.go                      |  4 +--
 go/arrow/array/binary_test.go                 |  6 ++--
 go/arrow/array/binarybuilder.go               |  8 ++---
 go/arrow/array/binarybuilder_test.go          |  6 ++--
 go/arrow/array/boolean.go                     |  8 ++---
 go/arrow/array/boolean_test.go                |  4 +--
 go/arrow/array/booleanbuilder.go              | 10 +++----
 go/arrow/array/booleanbuilder_test.go         |  6 ++--
 go/arrow/array/bufferbuilder.go               |  6 ++--
 go/arrow/array/bufferbuilder_byte.go          |  2 +-
 go/arrow/array/bufferbuilder_numeric.gen.go   |  6 ++--
 .../array/bufferbuilder_numeric.gen.go.tmpl   |  6 ++--
 go/arrow/array/bufferbuilder_numeric_test.go  |  4 +--
 go/arrow/array/builder.go                     |  8 ++---
 go/arrow/array/builder_test.go                |  4 +--
 go/arrow/array/compare.go                     |  6 ++--
 go/arrow/array/compare_test.go                | 10 +++----
 go/arrow/array/concat.go                      | 14 ++++-----
 go/arrow/array/concat_test.go                 | 10 +++----
 go/arrow/array/data.go                        |  6 ++--
 go/arrow/array/data_test.go                   |  4 +--
 go/arrow/array/decimal128.go                  | 12 ++++----
 go/arrow/array/decimal128_test.go             |  8 ++---
 go/arrow/array/decimal256.go                  | 12 ++++----
 go/arrow/array/decimal256_test.go             |  8 ++---
 go/arrow/array/decimal_test.go                | 12 ++++----
 go/arrow/array/dictionary.go                  | 20 ++++++-------
 go/arrow/array/dictionary_test.go             | 14 ++++-----
 go/arrow/array/diff.go                        |  2 +-
 go/arrow/array/diff_test.go                   | 10 +++----
 go/arrow/array/encoded.go                     | 12 ++++----
 go/arrow/array/encoded_test.go                |  8 ++---
 go/arrow/array/extension.go                   |  6 ++--
 go/arrow/array/extension_test.go              |  8 ++---
 go/arrow/array/fixed_size_list.go             | 10 +++----
 go/arrow/array/fixed_size_list_test.go        |  6 ++--
 go/arrow/array/fixedsize_binary.go            |  4 +--
 go/arrow/array/fixedsize_binary_test.go       |  6 ++--
 go/arrow/array/fixedsize_binarybuilder.go     |  8 ++---
 .../array/fixedsize_binarybuilder_test.go     |  4 +--
 go/arrow/array/float16.go                     |  6 ++--
 go/arrow/array/float16_builder.go             | 12 ++++----
 go/arrow/array/float16_builder_test.go        |  6 ++--
 go/arrow/array/interval.go                    | 10 +++----
 go/arrow/array/interval_test.go               |  6 ++--
 go/arrow/array/json_reader.go                 |  8 ++---
 go/arrow/array/json_reader_test.go            |  6 ++--
 go/arrow/array/list.go                        | 10 +++----
 go/arrow/array/list_test.go                   |  6 ++--
 go/arrow/array/map.go                         |  6 ++--
 go/arrow/array/map_test.go                    |  6 ++--
 go/arrow/array/null.go                        |  8 ++---
 go/arrow/array/null_test.go                   |  6 ++--
 go/arrow/array/numeric.gen.go                 |  4 +--
 go/arrow/array/numeric.gen.go.tmpl            |  4 +--
 go/arrow/array/numeric_test.go                |  8 ++---
 go/arrow/array/numericbuilder.gen.go          | 10 +++----
 go/arrow/array/numericbuilder.gen.go.tmpl     | 10 +++----
 go/arrow/array/numericbuilder.gen_test.go     |  6 ++--
 .../array/numericbuilder.gen_test.go.tmpl     |  6 ++--
 go/arrow/array/record.go                      |  8 ++---
 go/arrow/array/record_test.go                 |  6 ++--
 go/arrow/array/string.go                      |  6 ++--
 go/arrow/array/string_test.go                 |  8 ++---
 go/arrow/array/struct.go                      | 10 +++----
 go/arrow/array/struct_test.go                 |  6 ++--
 go/arrow/array/table.go                       |  4 +--
 go/arrow/array/table_test.go                  |  6 ++--
 go/arrow/array/timestamp.go                   | 10 +++----
 go/arrow/array/timestamp_test.go              |  6 ++--
 go/arrow/array/union.go                       | 12 ++++----
 go/arrow/array/union_test.go                  |  6 ++--
 go/arrow/array/util.go                        | 10 +++----
 go/arrow/array/util_test.go                   | 14 ++++-----
 go/arrow/arrio/arrio.go                       |  2 +-
 go/arrow/arrio/arrio_test.go                  | 10 +++----
 go/arrow/bitutil/bitmaps.go                   |  6 ++--
 go/arrow/bitutil/bitmaps_test.go              |  4 +--
 go/arrow/bitutil/bitutil.go                   |  2 +-
 go/arrow/bitutil/bitutil_test.go              |  4 +--
 go/arrow/cdata/cdata.go                       |  8 ++---
 go/arrow/cdata/cdata_exports.go               | 10 +++----
 go/arrow/cdata/cdata_test.go                  | 10 +++----
 go/arrow/cdata/cdata_test_framework.go        |  4 +--
 go/arrow/cdata/exports.go                     |  4 +--
 go/arrow/cdata/interface.go                   |  8 ++---
 go/arrow/cdata/test/test_cimport.go           |  8 ++---
 go/arrow/compute/arithmetic.go                | 12 ++++----
 go/arrow/compute/arithmetic_test.go           | 20 ++++++-------
 go/arrow/compute/cast.go                      | 10 +++----
 go/arrow/compute/cast_test.go                 | 20 ++++++-------
 go/arrow/compute/datum.go                     |  6 ++--
 go/arrow/compute/example_test.go              | 10 +++----
 go/arrow/compute/exec.go                      |  6 ++--
 go/arrow/compute/exec/kernel.go               |  8 ++---
 go/arrow/compute/exec/kernel_test.go          | 12 ++++----
 go/arrow/compute/exec/span.go                 | 10 +++----
 go/arrow/compute/exec/span_test.go            | 16 +++++-----
 go/arrow/compute/exec/utils.go                | 14 ++++-----
 go/arrow/compute/exec/utils_test.go           |  8 ++---
 go/arrow/compute/exec_internals_test.go       | 14 ++++-----
 go/arrow/compute/exec_test.go                 | 12 ++++----
 go/arrow/compute/executor.go                  | 16 +++++-----
 go/arrow/compute/expression.go                | 16 +++++-----
 go/arrow/compute/expression_test.go           | 10 +++----
 go/arrow/compute/exprs/builders.go            |  4 +--
 go/arrow/compute/exprs/builders_test.go       |  4 +--
 go/arrow/compute/exprs/exec.go                | 18 +++++------
 go/arrow/compute/exprs/exec_internal_test.go  |  8 ++---
 go/arrow/compute/exprs/exec_test.go           | 12 ++++----
 go/arrow/compute/exprs/extension_types.go     |  4 +--
 go/arrow/compute/exprs/field_refs.go          | 10 +++----
 go/arrow/compute/exprs/types.go               |  4 +--
 go/arrow/compute/fieldref.go                  |  4 +--
 go/arrow/compute/fieldref_test.go             |  8 ++---
 go/arrow/compute/functions.go                 |  4 +--
 go/arrow/compute/functions_test.go            |  4 +--
 .../internal/kernels/base_arithmetic.go       | 10 +++----
 .../internal/kernels/base_arithmetic_amd64.go |  4 +--
 .../kernels/base_arithmetic_avx2_amd64.go     |  2 +-
 .../kernels/base_arithmetic_sse4_amd64.go     |  2 +-
 .../kernels/basic_arithmetic_noasm.go         |  2 +-
 .../compute/internal/kernels/boolean_cast.go  |  6 ++--
 go/arrow/compute/internal/kernels/cast.go     |  6 ++--
 .../compute/internal/kernels/cast_numeric.go  |  2 +-
 .../kernels/cast_numeric_avx2_amd64.go        |  2 +-
 .../kernels/cast_numeric_neon_arm64.go        |  2 +-
 .../kernels/cast_numeric_sse4_amd64.go        |  2 +-
 .../compute/internal/kernels/cast_temporal.go |  8 ++---
 go/arrow/compute/internal/kernels/helpers.go  | 14 ++++-----
 .../compute/internal/kernels/numeric_cast.go  | 14 ++++-----
 go/arrow/compute/internal/kernels/rounding.go | 10 +++----
 .../internal/kernels/scalar_arithmetic.go     | 14 ++++-----
 .../internal/kernels/scalar_boolean.go        |  6 ++--
 .../kernels/scalar_comparison_amd64.go        |  4 +--
 .../kernels/scalar_comparison_avx2_amd64.go   |  2 +-
 .../kernels/scalar_comparison_noasm.go        |  2 +-
 .../kernels/scalar_comparison_sse4_amd64.go   |  2 +-
 .../internal/kernels/scalar_comparisons.go    | 16 +++++-----
 .../compute/internal/kernels/string_casts.go  | 12 ++++----
 go/arrow/compute/internal/kernels/types.go    |  8 ++---
 .../compute/internal/kernels/vector_hash.go   | 14 ++++-----
 .../internal/kernels/vector_run_end_encode.go | 16 +++++-----
 .../internal/kernels/vector_selection.go      | 14 ++++-----
 go/arrow/compute/registry.go                  |  2 +-
 go/arrow/compute/registry_test.go             |  6 ++--
 go/arrow/compute/scalar_bool.go               |  6 ++--
 go/arrow/compute/scalar_bool_test.go          | 10 +++----
 go/arrow/compute/scalar_compare.go            |  6 ++--
 go/arrow/compute/scalar_compare_test.go       | 18 +++++------
 go/arrow/compute/selection.go                 |  8 ++---
 go/arrow/compute/utils.go                     | 12 ++++----
 go/arrow/compute/vector_hash.go               |  4 +--
 go/arrow/compute/vector_hash_test.go          | 14 ++++-----
 go/arrow/compute/vector_run_end_test.go       | 14 ++++-----
 go/arrow/compute/vector_run_ends.go           |  4 +--
 go/arrow/compute/vector_selection_test.go     | 18 +++++------
 go/arrow/csv/common.go                        |  4 +--
 go/arrow/csv/reader.go                        | 14 ++++-----
 go/arrow/csv/reader_test.go                   | 14 ++++-----
 go/arrow/csv/transformer.go                   |  4 +--
 go/arrow/csv/writer.go                        |  2 +-
 go/arrow/csv/writer_test.go                   | 16 +++++-----
 go/arrow/datatype.go                          |  2 +-
 go/arrow/datatype_binary_test.go              |  2 +-
 go/arrow/datatype_extension_test.go           |  4 +--
 go/arrow/datatype_fixedwidth.go               |  2 +-
 go/arrow/datatype_fixedwidth_test.go          |  2 +-
 go/arrow/datatype_nested.go                   |  2 +-
 go/arrow/datatype_null_test.go                |  2 +-
 go/arrow/decimal128/decimal128.go             |  2 +-
 go/arrow/decimal128/decimal128_test.go        |  2 +-
 go/arrow/decimal256/decimal256.go             |  4 +--
 go/arrow/decimal256/decimal256_test.go        |  2 +-
 go/arrow/doc.go                               |  2 +-
 go/arrow/encoded/ree_utils.go                 |  2 +-
 go/arrow/encoded/ree_utils_test.go            |  8 ++---
 go/arrow/endian/endian.go                     |  4 +--
 go/arrow/example_test.go                      |  8 ++---
 go/arrow/flight/basic_auth_flight_test.go     |  2 +-
 go/arrow/flight/client.go                     |  2 +-
 go/arrow/flight/cookie_middleware_test.go     |  2 +-
 go/arrow/flight/example_flight_server_test.go |  2 +-
 go/arrow/flight/flight_middleware_test.go     |  4 +--
 go/arrow/flight/flight_test.go                | 10 +++----
 go/arrow/flight/flightsql/client.go           | 12 ++++----
 go/arrow/flight/flightsql/client_test.go      | 12 ++++----
 go/arrow/flight/flightsql/column_metadata.go  |  2 +-
 .../flight/flightsql/driver/config_test.go    |  2 +-
 go/arrow/flight/flightsql/driver/driver.go    | 10 +++----
 .../flight/flightsql/driver/driver_test.go    | 14 ++++-----
 go/arrow/flight/flightsql/driver/utils.go     |  4 +--
 .../cmd/sqlite_flightsql_server/main.go       |  6 ++--
 .../flightsql/example/sql_batch_reader.go     | 10 +++----
 .../flight/flightsql/example/sqlite_info.go   |  4 +--
 .../flight/flightsql/example/sqlite_server.go | 14 ++++-----
 .../sqlite_tables_schema_batch_reader.go      | 12 ++++----
 .../flight/flightsql/example/type_info.go     |  8 ++---
 .../flightsql/schema_ref/reference_schemas.go |  2 +-
 go/arrow/flight/flightsql/server.go           | 16 +++++-----
 go/arrow/flight/flightsql/server_test.go      | 12 ++++----
 go/arrow/flight/flightsql/sql_info.go         |  4 +--
 .../flight/flightsql/sqlite_server_test.go    | 16 +++++-----
 go/arrow/flight/flightsql/types.go            |  2 +-
 go/arrow/flight/record_batch_reader.go        | 12 ++++----
 go/arrow/flight/record_batch_writer.go        |  6 ++--
 go/arrow/flight/server.go                     |  2 +-
 go/arrow/flight/server_example_test.go        |  2 +-
 go/arrow/internal/arrdata/arrdata.go          | 16 +++++-----
 go/arrow/internal/arrdata/ioutil.go           | 10 +++----
 go/arrow/internal/arrjson/arrjson.go          | 20 ++++++-------
 go/arrow/internal/arrjson/arrjson_test.go     |  6 ++--
 go/arrow/internal/arrjson/option.go           |  4 +--
 go/arrow/internal/arrjson/reader.go           | 10 +++----
 go/arrow/internal/arrjson/writer.go           | 10 +++----
 go/arrow/internal/dictutils/dict.go           |  6 ++--
 go/arrow/internal/dictutils/dict_test.go      |  8 ++---
 .../arrow-flight-integration-client/main.go   |  2 +-
 .../arrow-flight-integration-server/main.go   |  2 +-
 .../internal/flight_integration/scenario.go   | 18 +++++------
 .../internal/testing/gen/random_array_gen.go  |  8 ++---
 go/arrow/internal/testing/tools/bits_test.go  |  2 +-
 go/arrow/internal/testing/tools/data_types.go |  4 +--
 go/arrow/internal/utils.go                    |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main.go            |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main_test.go       |  8 ++---
 go/arrow/ipc/cmd/arrow-file-to-stream/main.go |  6 ++--
 .../ipc/cmd/arrow-file-to-stream/main_test.go |  4 +--
 .../cmd/arrow-json-integration-test/main.go   | 12 ++++----
 .../arrow-json-integration-test/main_test.go  |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main.go             |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main_test.go        |  8 ++---
 go/arrow/ipc/cmd/arrow-stream-to-file/main.go |  6 ++--
 .../ipc/cmd/arrow-stream-to-file/main_test.go |  4 +--
 go/arrow/ipc/compression.go                   |  6 ++--
 go/arrow/ipc/endian_swap.go                   |  6 ++--
 go/arrow/ipc/endian_swap_test.go              | 10 +++----
 go/arrow/ipc/file_reader.go                   | 16 +++++-----
 go/arrow/ipc/file_test.go                     |  6 ++--
 go/arrow/ipc/file_writer.go                   | 10 +++----
 go/arrow/ipc/ipc.go                           |  8 ++---
 go/arrow/ipc/ipc_test.go                      |  8 ++---
 go/arrow/ipc/message.go                       |  6 ++--
 go/arrow/ipc/message_test.go                  |  6 ++--
 go/arrow/ipc/metadata.go                      | 10 +++----
 go/arrow/ipc/metadata_test.go                 | 12 ++++----
 go/arrow/ipc/reader.go                        | 14 ++++-----
 go/arrow/ipc/reader_test.go                   |  6 ++--
 go/arrow/ipc/stream_test.go                   |  6 ++--
 go/arrow/ipc/writer.go                        | 16 +++++-----
 go/arrow/ipc/writer_test.go                   | 10 +++----
 go/arrow/math/float64.go                      |  2 +-
 go/arrow/math/float64_avx2_amd64.go           |  2 +-
 go/arrow/math/float64_neon_arm64.go           |  2 +-
 go/arrow/math/float64_sse4_amd64.go           |  2 +-
 go/arrow/math/float64_test.go                 |  6 ++--
 go/arrow/math/int64.go                        |  2 +-
 go/arrow/math/int64_avx2_amd64.go             |  2 +-
 go/arrow/math/int64_neon_arm64.go             |  2 +-
 go/arrow/math/int64_sse4_amd64.go             |  2 +-
 go/arrow/math/int64_test.go                   |  6 ++--
 go/arrow/math/type.go.tmpl                    |  2 +-
 go/arrow/math/type_simd_amd64.go.tmpl         |  2 +-
 go/arrow/math/type_simd_arm64.go.tmpl         |  2 +-
 go/arrow/math/type_test.go.tmpl               |  6 ++--
 go/arrow/math/uint64.go                       |  2 +-
 go/arrow/math/uint64_avx2_amd64.go            |  2 +-
 go/arrow/math/uint64_neon_arm64.go            |  2 +-
 go/arrow/math/uint64_sse4_amd64.go            |  2 +-
 go/arrow/math/uint64_test.go                  |  6 ++--
 go/arrow/memory/buffer.go                     |  2 +-
 go/arrow/memory/buffer_test.go                |  2 +-
 go/arrow/memory/cgo_allocator.go              |  2 +-
 go/arrow/memory/default_mallocator.go         |  2 +-
 go/arrow/memory/default_mallocator_test.go    |  4 +--
 go/arrow/memory/mallocator/mallocator_test.go |  2 +-
 go/arrow/memory/memory_test.go                |  2 +-
 go/arrow/record.go                            |  2 +-
 go/arrow/scalar/append.go                     | 10 +++----
 go/arrow/scalar/append_test.go                | 10 +++----
 go/arrow/scalar/binary.go                     |  4 +--
 go/arrow/scalar/compare.go                    |  2 +-
 go/arrow/scalar/nested.go                     |  8 ++---
 go/arrow/scalar/numeric.gen.go                |  6 ++--
 go/arrow/scalar/numeric.gen_test.go           |  4 +--
 go/arrow/scalar/numeric.gen_test.go.tmpl      |  4 +--
 go/arrow/scalar/parse.go                      | 12 ++++----
 go/arrow/scalar/scalar.go                     | 20 ++++++-------
 go/arrow/scalar/scalar_test.go                | 12 ++++----
 go/arrow/scalar/temporal.go                   |  2 +-
 go/arrow/schema.go                            |  2 +-
 go/arrow/schema_test.go                       |  2 +-
 go/arrow/table.go                             |  2 +-
 go/arrow/tensor/numeric.gen.go                |  2 +-
 go/arrow/tensor/numeric.gen.go.tmpl           |  4 +--
 go/arrow/tensor/numeric.gen_test.go           |  8 ++---
 go/arrow/tensor/numeric.gen_test.go.tmpl      |  8 ++---
 go/arrow/tensor/tensor.go                     |  4 +--
 go/arrow/tensor/tensor_test.go                |  8 ++---
 go/arrow/type_traits_boolean.go               |  2 +-
 go/arrow/type_traits_decimal128.go            |  4 +--
 go/arrow/type_traits_decimal256.go            |  4 +--
 go/arrow/type_traits_float16.go               |  4 +--
 go/arrow/type_traits_interval.go              |  4 +--
 go/arrow/type_traits_numeric.gen.go           |  2 +-
 go/arrow/type_traits_numeric.gen.go.tmpl      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go.tmpl |  2 +-
 go/arrow/type_traits_test.go                  |  8 ++---
 go/arrow/type_traits_timestamp.go             |  2 +-
 go/arrow/util/byte_size.go                    |  6 ++--
 go/arrow/util/byte_size_test.go               |  8 ++---
 go/go.mod                                     |  2 +-
 go/internal/bitutils/bit_block_counter.go     |  4 +--
 .../bitutils/bit_block_counter_test.go        |  6 ++--
 go/internal/bitutils/bit_run_reader.go        |  6 ++--
 go/internal/bitutils/bit_run_reader_test.go   |  6 ++--
 go/internal/bitutils/bit_set_run_reader.go    |  4 +--
 .../bitutils/bit_set_run_reader_test.go       |  6 ++--
 go/internal/bitutils/bitmap_generate.go       |  2 +-
 go/internal/bitutils/bitmap_generate_test.go  |  2 +-
 go/internal/hashing/xxh3_memo_table.gen.go    |  6 ++--
 .../hashing/xxh3_memo_table.gen.go.tmpl       |  4 +--
 go/internal/types/extension_types.go          |  6 ++--
 go/internal/types/extension_types_test.go     | 10 +++----
 go/internal/utils/transpose_ints_def.go       |  2 +-
 go/internal/utils/transpose_ints_test.go      |  2 +-
 go/parquet/cmd/parquet_reader/dumper.go       |  6 ++--
 go/parquet/cmd/parquet_reader/main.go         | 10 +++----
 go/parquet/cmd/parquet_schema/main.go         |  4 +--
 go/parquet/compress/brotli.go                 |  2 +-
 go/parquet/compress/compress.go               |  2 +-
 go/parquet/compress/compress_test.go          |  2 +-
 go/parquet/compress/zstd.go                   |  2 +-
 go/parquet/doc.go                             |  6 ++--
 go/parquet/encryption_properties.go           |  2 +-
 go/parquet/encryption_properties_test.go      |  4 +--
 go/parquet/encryption_read_config_test.go     |  8 ++---
 go/parquet/encryption_write_config_test.go    |  8 ++---
 go/parquet/file/column_reader.go              | 14 ++++-----
 go/parquet/file/column_reader_test.go         | 12 ++++----
 go/parquet/file/column_reader_types.gen.go    |  6 ++--
 .../file/column_reader_types.gen.go.tmpl      |  4 +--
 go/parquet/file/column_writer.go              | 16 +++++-----
 go/parquet/file/column_writer_test.go         | 26 ++++++++--------
 go/parquet/file/column_writer_types.gen.go    | 12 ++++----
 .../file/column_writer_types.gen.go.tmpl      |  8 ++---
 go/parquet/file/file_reader.go                |  8 ++---
 go/parquet/file/file_reader_mmap.go           |  2 +-
 go/parquet/file/file_reader_mmap_windows.go   |  2 +-
 go/parquet/file/file_reader_test.go           | 20 ++++++-------
 go/parquet/file/file_writer.go                | 10 +++----
 go/parquet/file/file_writer_test.go           | 14 ++++-----
 go/parquet/file/level_conversion.go           | 10 +++----
 go/parquet/file/level_conversion_test.go      |  6 ++--
 go/parquet/file/page_reader.go                | 14 ++++-----
 go/parquet/file/page_writer.go                | 18 +++++------
 go/parquet/file/record_reader.go              | 16 +++++-----
 go/parquet/file/row_group_reader.go           |  8 ++---
 go/parquet/file/row_group_writer.go           |  8 ++---
 go/parquet/file/row_group_writer_test.go      |  8 ++---
 .../internal/encoding/boolean_decoder.go      |  8 ++---
 .../internal/encoding/boolean_encoder.go      |  6 ++--
 .../internal/encoding/byte_array_decoder.go   | 12 ++++----
 .../internal/encoding/byte_array_encoder.go   | 10 +++----
 go/parquet/internal/encoding/decoder.go       | 20 ++++++-------
 .../internal/encoding/delta_bit_packing.go    | 10 +++----
 .../internal/encoding/delta_byte_array.go     |  6 ++--
 .../encoding/delta_byte_array_test.go         |  4 +--
 .../encoding/delta_length_byte_array.go       |  6 ++--
 go/parquet/internal/encoding/encoder.go       | 16 +++++-----
 .../encoding/encoding_benchmarks_test.go      | 16 +++++-----
 go/parquet/internal/encoding/encoding_test.go | 14 ++++-----
 .../encoding/fixed_len_byte_array_decoder.go  |  4 +--
 .../encoding/fixed_len_byte_array_encoder.go  |  6 ++--
 go/parquet/internal/encoding/levels.go        | 10 +++----
 go/parquet/internal/encoding/levels_test.go   | 10 +++----
 go/parquet/internal/encoding/memo_table.go    | 10 +++----
 .../internal/encoding/memo_table_test.go      | 10 +++----
 .../internal/encoding/memo_table_types.gen.go |  4 +--
 .../encoding/memo_table_types.gen.go.tmpl     |  2 +-
 .../encoding/plain_encoder_types.gen.go       | 10 +++----
 .../encoding/plain_encoder_types.gen.go.tmpl  |  8 ++---
 .../internal/encoding/typed_encoder.gen.go    | 18 +++++------
 .../encoding/typed_encoder.gen.go.tmpl        | 14 ++++-----
 go/parquet/internal/encoding/types.go         | 10 +++----
 go/parquet/internal/encryption/aes.go         |  2 +-
 go/parquet/internal/encryption/decryptor.go   |  4 +--
 go/parquet/internal/encryption/encryptor.go   |  4 +--
 go/parquet/internal/testutils/pagebuilder.go  | 14 ++++-----
 .../internal/testutils/primitive_typed.go     | 10 +++----
 go/parquet/internal/testutils/random.go       | 14 ++++-----
 go/parquet/internal/testutils/random_arrow.go |  6 ++--
 go/parquet/internal/testutils/utils.go        |  2 +-
 go/parquet/internal/thrift/helpers.go         |  2 +-
 .../internal/utils/bit_benchmark_test.go      |  6 ++--
 go/parquet/internal/utils/bit_reader.go       |  8 ++---
 go/parquet/internal/utils/bit_reader_test.go  | 10 +++----
 go/parquet/internal/utils/bit_writer.go       |  2 +-
 go/parquet/internal/utils/bitmap_writer.go    |  2 +-
 .../internal/utils/bitmap_writer_test.go      |  4 +--
 go/parquet/internal/utils/rle.go              |  8 ++---
 .../internal/utils/typed_rle_dict.gen.go      |  6 ++--
 .../internal/utils/typed_rle_dict.gen.go.tmpl |  6 ++--
 go/parquet/metadata/app_version.go            |  4 +--
 go/parquet/metadata/column_chunk.go           | 14 ++++-----
 go/parquet/metadata/file.go                   | 12 ++++----
 go/parquet/metadata/metadata_test.go          |  6 ++--
 go/parquet/metadata/row_group.go              |  8 ++---
 go/parquet/metadata/stat_compare_test.go      |  4 +--
 go/parquet/metadata/statistics.go             | 16 +++++-----
 go/parquet/metadata/statistics_test.go        | 10 +++----
 go/parquet/metadata/statistics_types.gen.go   | 16 +++++-----
 .../metadata/statistics_types.gen.go.tmpl     | 14 ++++-----
 go/parquet/pqarrow/column_readers.go          | 18 +++++------
 go/parquet/pqarrow/encode_arrow.go            | 16 +++++-----
 go/parquet/pqarrow/encode_arrow_test.go       | 30 +++++++++----------
 go/parquet/pqarrow/encode_dict_compute.go     | 16 +++++-----
 go/parquet/pqarrow/encode_dict_nocompute.go   |  4 +--
 go/parquet/pqarrow/encode_dictionary_test.go  | 16 +++++-----
 go/parquet/pqarrow/file_reader.go             | 14 ++++-----
 go/parquet/pqarrow/file_reader_test.go        | 14 ++++-----
 go/parquet/pqarrow/file_writer.go             | 12 ++++----
 go/parquet/pqarrow/helpers.go                 |  2 +-
 go/parquet/pqarrow/path_builder.go            | 10 +++----
 go/parquet/pqarrow/path_builder_test.go       |  8 ++---
 go/parquet/pqarrow/properties.go              |  6 ++--
 go/parquet/pqarrow/reader_writer_test.go      | 12 ++++----
 go/parquet/pqarrow/schema.go                  | 16 +++++-----
 go/parquet/pqarrow/schema_test.go             | 18 +++++------
 go/parquet/reader_properties.go               |  4 +--
 go/parquet/reader_writer_properties_test.go   |  6 ++--
 go/parquet/schema/column.go                   |  4 +--
 go/parquet/schema/converted_types.go          |  2 +-
 go/parquet/schema/converted_types_test.go     |  2 +-
 go/parquet/schema/helpers.go                  |  2 +-
 go/parquet/schema/helpers_test.go             |  4 +--
 go/parquet/schema/logical_types.go            |  8 ++---
 go/parquet/schema/logical_types_test.go       |  6 ++--
 go/parquet/schema/node.go                     |  4 +--
 go/parquet/schema/reflection.go               |  4 +--
 go/parquet/schema/reflection_test.go          |  4 +--
 go/parquet/schema/schema.go                   |  4 +--
 go/parquet/schema/schema_element_test.go      |  4 +--
 go/parquet/schema/schema_flatten_test.go      |  4 +--
 go/parquet/schema/schema_test.go              |  6 ++--
 go/parquet/types.go                           |  4 +--
 go/parquet/writer_properties.go               |  6 ++--
 java/adapter/avro/pom.xml                     |  2 +-
 java/adapter/jdbc/pom.xml                     |  2 +-
 java/adapter/orc/pom.xml                      |  2 +-
 java/algorithm/pom.xml                        |  2 +-
 java/c/pom.xml                                |  2 +-
 java/compression/pom.xml                      |  2 +-
 java/dataset/pom.xml                          |  2 +-
 java/flight/flight-core/pom.xml               |  2 +-
 java/flight/flight-grpc/pom.xml               |  2 +-
 java/flight/flight-integration-tests/pom.xml  |  2 +-
 java/flight/flight-sql-jdbc-core/pom.xml      |  2 +-
 java/flight/flight-sql-jdbc-driver/pom.xml    |  2 +-
 java/flight/flight-sql/pom.xml                |  2 +-
 java/flight/pom.xml                           |  2 +-
 java/format/pom.xml                           |  2 +-
 java/gandiva/pom.xml                          |  2 +-
 java/memory/memory-core/pom.xml               |  2 +-
 java/memory/memory-netty/pom.xml              |  2 +-
 java/memory/memory-unsafe/pom.xml             |  2 +-
 java/memory/pom.xml                           |  2 +-
 java/performance/pom.xml                      |  4 +--
 java/pom.xml                                  |  2 +-
 java/tools/pom.xml                            |  2 +-
 java/vector/pom.xml                           |  2 +-
 js/package.json                               |  2 +-
 matlab/CMakeLists.txt                         |  2 +-
 python/CMakeLists.txt                         |  2 +-
 python/setup.py                               |  2 +-
 r/DESCRIPTION                                 |  2 +-
 r/NEWS.md                                     |  4 ++-
 r/pkgdown/assets/versions.json                |  8 +++--
 ruby/red-arrow-cuda/lib/arrow-cuda/version.rb |  2 +-
 .../lib/arrow-dataset/version.rb              |  2 +-
 .../lib/arrow-flight-sql/version.rb           |  2 +-
 .../lib/arrow-flight/version.rb               |  2 +-
 ruby/red-arrow/lib/arrow/version.rb           |  2 +-
 ruby/red-gandiva/lib/gandiva/version.rb       |  2 +-
 ruby/red-parquet/lib/parquet/version.rb       |  2 +-
 500 files changed, 1721 insertions(+), 1711 deletions(-)

diff --git a/c_glib/meson.build b/c_glib/meson.build
index 8028e304604cd..d9de6fcbf7e24 100644
--- a/c_glib/meson.build
+++ b/c_glib/meson.build
@@ -24,7 +24,7 @@ project('arrow-glib', 'c', 'cpp',
           'cpp_std=c++17',
         ])
 
-version = '13.0.0-SNAPSHOT'
+version = '14.0.0-SNAPSHOT'
 if version.endswith('-SNAPSHOT')
   version_numbers = version.split('-')[0].split('.')
   version_tag = version.split('-')[1]
diff --git a/ci/scripts/PKGBUILD b/ci/scripts/PKGBUILD
index f2a81aee1b4d2..dcd313087e966 100644
--- a/ci/scripts/PKGBUILD
+++ b/ci/scripts/PKGBUILD
@@ -18,7 +18,7 @@
 _realname=arrow
 pkgbase=mingw-w64-${_realname}
 pkgname="${MINGW_PACKAGE_PREFIX}-${_realname}"
-pkgver=12.0.1.9000
+pkgver=13.0.0.9000
 pkgrel=8000
 pkgdesc="Apache Arrow is a cross-language development platform for in-memory data (mingw-w64)"
 arch=("any")
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 301c919667db6..27d7097a2901f 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -47,7 +47,7 @@ cmake_policy(SET CMP0074 NEW)
 # https://cmake.org/cmake/help/latest/policy/CMP0091.html
 cmake_policy(SET CMP0091 NEW)
 
-set(ARROW_VERSION "13.0.0-SNAPSHOT")
+set(ARROW_VERSION "14.0.0-SNAPSHOT")
 
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_BASE_VERSION "${ARROW_VERSION}")
 
diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json
index f6e65b2b95f4a..71855dafdea35 100644
--- a/cpp/vcpkg.json
+++ b/cpp/vcpkg.json
@@ -1,6 +1,6 @@
 {
   "name": "arrow",
-  "version-string": "13.0.0-SNAPSHOT",
+  "version-string": "14.0.0-SNAPSHOT",
   "dependencies": [
     "abseil",
     {
diff --git a/csharp/Directory.Build.props b/csharp/Directory.Build.props
index fa142b895827d..b6c7c75c237e5 100644
--- a/csharp/Directory.Build.props
+++ b/csharp/Directory.Build.props
@@ -29,7 +29,7 @@
     <Product>Apache Arrow library</Product>
     <Copyright>Copyright 2016-2019 The Apache Software Foundation</Copyright>
     <Company>The Apache Software Foundation</Company>
-    <Version>13.0.0-SNAPSHOT</Version>
+    <Version>14.0.0-SNAPSHOT</Version>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
index b861c06b0201f..0d8954e9a2a46 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
@@ -29,7 +29,7 @@
 class ApacheArrowGlib < Formula
   desc "GLib bindings for Apache Arrow"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-13.0.0-SNAPSHOT/apache-arrow-13.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.0-SNAPSHOT/apache-arrow-14.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index f5d7ff36ea041..464c921281b95 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -29,7 +29,7 @@
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-13.0.0-SNAPSHOT/apache-arrow-13.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.0-SNAPSHOT/apache-arrow-14.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb b/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
index b47d0edfe0dd7..387759edf27e6 100644
--- a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
@@ -19,7 +19,7 @@
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-12.0.1.9000/apache-arrow-12.0.1.9000.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-13.0.0.9000/apache-arrow-13.0.0.9000.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   head "https://github.com/apache/arrow.git", branch: "main"
 
diff --git a/docs/source/_static/versions.json b/docs/source/_static/versions.json
index 465ebb53b112a..f91b0a17e7774 100644
--- a/docs/source/_static/versions.json
+++ b/docs/source/_static/versions.json
@@ -1,16 +1,20 @@
 [
     {
-        "name": "13.0 (dev)",
+        "name": "14.0 (dev)",
         "version": "dev/"
     },
     {
-        "name": "12.0 (stable)",
+        "name": "13.0 (stable)",
         "version": ""
     },
     {
         "name": "12.0",
         "version": "12.0/"
     },
+    {
+        "name": "12.0",
+        "version": "12.0/"
+    },
     {
         "name": "11.0",
         "version": "11.0/"
diff --git a/go/arrow/_examples/helloworld/main.go b/go/arrow/_examples/helloworld/main.go
index 358214464659d..02601be694400 100644
--- a/go/arrow/_examples/helloworld/main.go
+++ b/go/arrow/_examples/helloworld/main.go
@@ -19,10 +19,10 @@ package main
 import (
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/math"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/_tools/tmpl/main.go b/go/arrow/_tools/tmpl/main.go
index ddbbfb78a035b..87c4b6ed02c12 100644
--- a/go/arrow/_tools/tmpl/main.go
+++ b/go/arrow/_tools/tmpl/main.go
@@ -28,7 +28,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const Ext = ".tmpl"
diff --git a/go/arrow/array.go b/go/arrow/array.go
index c08c568fdf4b7..7622e7503e0b6 100644
--- a/go/arrow/array.go
+++ b/go/arrow/array.go
@@ -19,8 +19,8 @@ package arrow
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // ArrayData is the underlying memory and metadata of an Arrow array, corresponding
diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index 83273211f6b87..418f67034583d 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/array/array_test.go b/go/arrow/array/array_test.go
index bae44219a8825..6139548ddec7d 100644
--- a/go/arrow/array/array_test.go
+++ b/go/arrow/array/array_test.go
@@ -19,11 +19,11 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binary.go b/go/arrow/array/binary.go
index 3ed9ff3cd00ac..e9e6e66e7e813 100644
--- a/go/arrow/array/binary.go
+++ b/go/arrow/array/binary.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type BinaryLike interface {
diff --git a/go/arrow/array/binary_test.go b/go/arrow/array/binary_test.go
index b1dd5a5358fc4..5febb55691d7d 100644
--- a/go/arrow/array/binary_test.go
+++ b/go/arrow/array/binary_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binarybuilder.go b/go/arrow/array/binarybuilder.go
index b9af44762cd84..3cb709b45b7a1 100644
--- a/go/arrow/array/binarybuilder.go
+++ b/go/arrow/array/binarybuilder.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A BinaryBuilder is used to build a Binary array using the Append methods.
diff --git a/go/arrow/array/binarybuilder_test.go b/go/arrow/array/binarybuilder_test.go
index 48dce6aca4023..c63307433bcca 100644
--- a/go/arrow/array/binarybuilder_test.go
+++ b/go/arrow/array/binarybuilder_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/boolean.go b/go/arrow/array/boolean.go
index 7584aec98fd6b..464cef48bdf32 100644
--- a/go/arrow/array/boolean.go
+++ b/go/arrow/array/boolean.go
@@ -21,10 +21,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of boolean values.
diff --git a/go/arrow/array/boolean_test.go b/go/arrow/array/boolean_test.go
index 48b127ae9f643..c49ec08624cc6 100644
--- a/go/arrow/array/boolean_test.go
+++ b/go/arrow/array/boolean_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/booleanbuilder.go b/go/arrow/array/booleanbuilder.go
index 765d47e6425dd..f4a5ba9816dfc 100644
--- a/go/arrow/array/booleanbuilder.go
+++ b/go/arrow/array/booleanbuilder.go
@@ -23,11 +23,11 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type BooleanBuilder struct {
diff --git a/go/arrow/array/booleanbuilder_test.go b/go/arrow/array/booleanbuilder_test.go
index ef7064163edf4..702b0ca554f00 100644
--- a/go/arrow/array/booleanbuilder_test.go
+++ b/go/arrow/array/booleanbuilder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/bufferbuilder.go b/go/arrow/array/bufferbuilder.go
index deda3a2718f03..e023b0d907421 100644
--- a/go/arrow/array/bufferbuilder.go
+++ b/go/arrow/array/bufferbuilder.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type bufBuilder interface {
diff --git a/go/arrow/array/bufferbuilder_byte.go b/go/arrow/array/bufferbuilder_byte.go
index 803d6b8687f8c..00a0d1c21b3ef 100644
--- a/go/arrow/array/bufferbuilder_byte.go
+++ b/go/arrow/array/bufferbuilder_byte.go
@@ -16,7 +16,7 @@
 
 package array
 
-import "github.com/apache/arrow/go/v13/arrow/memory"
+import "github.com/apache/arrow/go/v14/arrow/memory"
 
 type byteBufferBuilder struct {
 	bufferBuilder
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go b/go/arrow/array/bufferbuilder_numeric.gen.go
index 4f861ab6d3b27..879bc9f571152 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go
@@ -19,9 +19,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type int64BufferBuilder struct {
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
index ebf9b988b5156..e859b5bff02a1 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
@@ -17,9 +17,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/bufferbuilder_numeric_test.go b/go/arrow/array/bufferbuilder_numeric_test.go
index 3a629b27d4766..ba0a60e5b703b 100644
--- a/go/arrow/array/bufferbuilder_numeric_test.go
+++ b/go/arrow/array/bufferbuilder_numeric_test.go
@@ -20,8 +20,8 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index 7e9a219336f7f..aada095d099b8 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const (
diff --git a/go/arrow/array/builder_test.go b/go/arrow/array/builder_test.go
index 25106e2bf9885..eeb7a2ac46b3f 100644
--- a/go/arrow/array/builder_test.go
+++ b/go/arrow/array/builder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index bc61c19fe163f..7dca60688d490 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 // RecordEqual reports whether the two provided records are equal.
diff --git a/go/arrow/array/compare_test.go b/go/arrow/array/compare_test.go
index 590c1071a7051..51421aa04fe9a 100644
--- a/go/arrow/array/compare_test.go
+++ b/go/arrow/array/compare_test.go
@@ -22,11 +22,11 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 5d3d2e005d488..f00a36fec1171 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -22,13 +22,13 @@ import (
 	"math"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/encoded"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // Concatenate creates a new arrow.Array which is the concatenation of the
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index a74166541e856..cc4d29cf42460 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/data.go b/go/arrow/array/data.go
index a9d2b440471d5..49df06fb1174a 100644
--- a/go/arrow/array/data.go
+++ b/go/arrow/array/data.go
@@ -22,9 +22,9 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Data represents the memory and metadata of an Arrow array.
diff --git a/go/arrow/array/data_test.go b/go/arrow/array/data_test.go
index 014cb432c47a1..2773096995fb6 100644
--- a/go/arrow/array/data_test.go
+++ b/go/arrow/array/data_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal128.go b/go/arrow/array/decimal128.go
index ec2d402efa6bf..3317531687ca4 100644
--- a/go/arrow/array/decimal128.go
+++ b/go/arrow/array/decimal128.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of 128-bit decimal values.
diff --git a/go/arrow/array/decimal128_test.go b/go/arrow/array/decimal128_test.go
index da2c57e93c811..8ef09b68c176a 100644
--- a/go/arrow/array/decimal128_test.go
+++ b/go/arrow/array/decimal128_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal256.go b/go/arrow/array/decimal256.go
index 003726190c150..d63544f784a09 100644
--- a/go/arrow/array/decimal256.go
+++ b/go/arrow/array/decimal256.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Decimal256 is a type that represents an immutable sequence of 256-bit decimal values.
diff --git a/go/arrow/array/decimal256_test.go b/go/arrow/array/decimal256_test.go
index 6fa2858d5936b..a02098e79103f 100644
--- a/go/arrow/array/decimal256_test.go
+++ b/go/arrow/array/decimal256_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal_test.go b/go/arrow/array/decimal_test.go
index 1bd1011023c2e..2203b2702c09a 100644
--- a/go/arrow/array/decimal_test.go
+++ b/go/arrow/array/decimal_test.go
@@ -21,12 +21,12 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index ccb6f32321496..06978244d8f31 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -25,16 +25,16 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/hashing"
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // Dictionary represents the type for dictionary-encoded data with a data
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index 99c8e6ffcd47b..4fb37127d6951 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -24,13 +24,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/diff.go b/go/arrow/array/diff.go
index 3afee563f7ad5..026a27b983f59 100644
--- a/go/arrow/array/diff.go
+++ b/go/arrow/array/diff.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Edit represents one entry in the edit script to compare two arrays.
diff --git a/go/arrow/array/diff_test.go b/go/arrow/array/diff_test.go
index eeec38d476259..0eff8dc4f0577 100644
--- a/go/arrow/array/diff_test.go
+++ b/go/arrow/array/diff_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 type diffTestCase struct {
diff --git a/go/arrow/array/encoded.go b/go/arrow/array/encoded.go
index 4f775c2f45f66..10e9b949c7c35 100644
--- a/go/arrow/array/encoded.go
+++ b/go/arrow/array/encoded.go
@@ -23,12 +23,12 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/encoded"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // RunEndEncoded represents an array containing two children:
diff --git a/go/arrow/array/encoded_test.go b/go/arrow/array/encoded_test.go
index 1043af40e9732..57c01cf22d2d6 100644
--- a/go/arrow/array/encoded_test.go
+++ b/go/arrow/array/encoded_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/array/extension.go b/go/arrow/array/extension.go
index 7ed4d79c99d7c..03e8c1734b9d6 100644
--- a/go/arrow/array/extension.go
+++ b/go/arrow/array/extension.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // ExtensionArray is the interface that needs to be implemented to handle
diff --git a/go/arrow/array/extension_test.go b/go/arrow/array/extension_test.go
index 63dfe9eece0a3..5b473fed428ef 100644
--- a/go/arrow/array/extension_test.go
+++ b/go/arrow/array/extension_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/fixed_size_list.go b/go/arrow/array/fixed_size_list.go
index 49c1608044283..62c3213861a7d 100644
--- a/go/arrow/array/fixed_size_list.go
+++ b/go/arrow/array/fixed_size_list.go
@@ -22,11 +22,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // FixedSizeList represents an immutable sequence of N array values.
diff --git a/go/arrow/array/fixed_size_list_test.go b/go/arrow/array/fixed_size_list_test.go
index 10e1f78f02a39..83dff923fe120 100644
--- a/go/arrow/array/fixed_size_list_test.go
+++ b/go/arrow/array/fixed_size_list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/fixedsize_binary.go b/go/arrow/array/fixedsize_binary.go
index c55cd24152253..5466156d5a256 100644
--- a/go/arrow/array/fixedsize_binary.go
+++ b/go/arrow/array/fixedsize_binary.go
@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of fixed-length binary strings.
diff --git a/go/arrow/array/fixedsize_binary_test.go b/go/arrow/array/fixedsize_binary_test.go
index c320605e11b9c..b65c7051a9b3e 100644
--- a/go/arrow/array/fixedsize_binary_test.go
+++ b/go/arrow/array/fixedsize_binary_test.go
@@ -21,9 +21,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFixedSizeBinary(t *testing.T) {
diff --git a/go/arrow/array/fixedsize_binarybuilder.go b/go/arrow/array/fixedsize_binarybuilder.go
index 6e6607b506e2a..ba4b474a89fd0 100644
--- a/go/arrow/array/fixedsize_binarybuilder.go
+++ b/go/arrow/array/fixedsize_binarybuilder.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A FixedSizeBinaryBuilder is used to build a FixedSizeBinary array using the Append methods.
diff --git a/go/arrow/array/fixedsize_binarybuilder_test.go b/go/arrow/array/fixedsize_binarybuilder_test.go
index 9246c624f9e1e..e3962ad3b9372 100644
--- a/go/arrow/array/fixedsize_binarybuilder_test.go
+++ b/go/arrow/array/fixedsize_binarybuilder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/float16.go b/go/arrow/array/float16.go
index 93045857e1bf4..de499e26706cc 100644
--- a/go/arrow/array/float16.go
+++ b/go/arrow/array/float16.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of Float16 values.
diff --git a/go/arrow/array/float16_builder.go b/go/arrow/array/float16_builder.go
index 40491c1311709..f96ab6037e002 100644
--- a/go/arrow/array/float16_builder.go
+++ b/go/arrow/array/float16_builder.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Float16Builder struct {
diff --git a/go/arrow/array/float16_builder_test.go b/go/arrow/array/float16_builder_test.go
index a1ad3f7444340..6ee028d978fb0 100644
--- a/go/arrow/array/float16_builder_test.go
+++ b/go/arrow/array/float16_builder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/interval.go b/go/arrow/array/interval.go
index 11cb6e2489653..ff059c92c8583 100644
--- a/go/arrow/array/interval.go
+++ b/go/arrow/array/interval.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 func NewIntervalData(data arrow.ArrayData) arrow.Array {
diff --git a/go/arrow/array/interval_test.go b/go/arrow/array/interval_test.go
index cc5b5d8c7595b..50a96e4779f03 100644
--- a/go/arrow/array/interval_test.go
+++ b/go/arrow/array/interval_test.go
@@ -20,9 +20,9 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/json_reader.go b/go/arrow/array/json_reader.go
index 25f8b5db68ed5..e09717c4199b7 100644
--- a/go/arrow/array/json_reader.go
+++ b/go/arrow/array/json_reader.go
@@ -22,10 +22,10 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Option func(config)
diff --git a/go/arrow/array/json_reader_test.go b/go/arrow/array/json_reader_test.go
index 8a0e86daebf02..3a095a0d33189 100644
--- a/go/arrow/array/json_reader_test.go
+++ b/go/arrow/array/json_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/list.go b/go/arrow/array/list.go
index 42f7b46ca851b..36035dd2f01a8 100644
--- a/go/arrow/array/list.go
+++ b/go/arrow/array/list.go
@@ -22,11 +22,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type ListLike interface {
diff --git a/go/arrow/array/list_test.go b/go/arrow/array/list_test.go
index 138548532f1f8..9f193fe19aabd 100644
--- a/go/arrow/array/list_test.go
+++ b/go/arrow/array/list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index 1d9c2985c08d9..84c1b55a0cf21 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Map represents an immutable sequence of Key/Value structs. It is a
diff --git a/go/arrow/array/map_test.go b/go/arrow/array/map_test.go
index c9b87b045a68e..cfb1cac87bedc 100644
--- a/go/arrow/array/map_test.go
+++ b/go/arrow/array/map_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/null.go b/go/arrow/array/null.go
index 94abe71dc7b78..150a1030eb49d 100644
--- a/go/arrow/array/null.go
+++ b/go/arrow/array/null.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Null represents an immutable, degenerate array with no physical storage.
diff --git a/go/arrow/array/null_test.go b/go/arrow/array/null_test.go
index f2c06be1bcf82..e1bf1e0345b84 100644
--- a/go/arrow/array/null_test.go
+++ b/go/arrow/array/null_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numeric.gen.go b/go/arrow/array/numeric.gen.go
index dd23f63cc31dc..a3e1101516aa6 100644
--- a/go/arrow/array/numeric.gen.go
+++ b/go/arrow/array/numeric.gen.go
@@ -23,8 +23,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of int64 values.
diff --git a/go/arrow/array/numeric.gen.go.tmpl b/go/arrow/array/numeric.gen.go.tmpl
index cd5d920f12dfe..34d17fbfc8854 100644
--- a/go/arrow/array/numeric.gen.go.tmpl
+++ b/go/arrow/array/numeric.gen.go.tmpl
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numeric_test.go b/go/arrow/array/numeric_test.go
index dceb00c7ba287..34f59c238cbef 100644
--- a/go/arrow/array/numeric_test.go
+++ b/go/arrow/array/numeric_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen.go b/go/arrow/array/numericbuilder.gen.go
index 880bf44fee733..d3648f0b1fbc4 100644
--- a/go/arrow/array/numericbuilder.gen.go
+++ b/go/arrow/array/numericbuilder.gen.go
@@ -27,11 +27,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Int64Builder struct {
diff --git a/go/arrow/array/numericbuilder.gen.go.tmpl b/go/arrow/array/numericbuilder.gen.go.tmpl
index 4ac32ec009c42..cf663c031f616 100644
--- a/go/arrow/array/numericbuilder.gen.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen.go.tmpl
@@ -17,11 +17,11 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numericbuilder.gen_test.go b/go/arrow/array/numericbuilder.gen_test.go
index 246d3a7cdad9d..b5986775cd995 100644
--- a/go/arrow/array/numericbuilder.gen_test.go
+++ b/go/arrow/array/numericbuilder.gen_test.go
@@ -21,9 +21,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen_test.go.tmpl b/go/arrow/array/numericbuilder.gen_test.go.tmpl
index 6b01684ac656d..bc8c993374671 100644
--- a/go/arrow/array/numericbuilder.gen_test.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen_test.go.tmpl
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/record.go b/go/arrow/array/record.go
index 67c652cb99c02..0b0fe4c3847fc 100644
--- a/go/arrow/array/record.go
+++ b/go/arrow/array/record.go
@@ -22,10 +22,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // RecordReader reads a stream of records.
diff --git a/go/arrow/array/record_test.go b/go/arrow/array/record_test.go
index 6a6d4175a26f0..da50a30b646f1 100644
--- a/go/arrow/array/record_test.go
+++ b/go/arrow/array/record_test.go
@@ -21,9 +21,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 8187edd612f72..61e964004de5d 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -23,9 +23,9 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // String represents an immutable sequence of variable-length UTF-8 strings.
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index 9f27ceaa86bda..0966ef17395ee 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/struct.go b/go/arrow/array/struct.go
index 9605645d4c1e5..868078842a692 100644
--- a/go/arrow/array/struct.go
+++ b/go/arrow/array/struct.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Struct represents an ordered sequence of relative types.
diff --git a/go/arrow/array/struct_test.go b/go/arrow/array/struct_test.go
index 30f5673f40955..86a5b311fcc21 100644
--- a/go/arrow/array/struct_test.go
+++ b/go/arrow/array/struct_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/table.go b/go/arrow/array/table.go
index 7bfd93718a875..d23ca60599440 100644
--- a/go/arrow/array/table.go
+++ b/go/arrow/array/table.go
@@ -22,8 +22,8 @@ import (
 	"math"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // NewColumnSlice returns a new zero-copy slice of the column with the indicated
diff --git a/go/arrow/array/table_test.go b/go/arrow/array/table_test.go
index ee38a8a4d1331..938ec7948f162 100644
--- a/go/arrow/array/table_test.go
+++ b/go/arrow/array/table_test.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestChunked(t *testing.T) {
diff --git a/go/arrow/array/timestamp.go b/go/arrow/array/timestamp.go
index a9928320748d1..2928b1fc77ff6 100644
--- a/go/arrow/array/timestamp.go
+++ b/go/arrow/array/timestamp.go
@@ -24,11 +24,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Timestamp represents an immutable sequence of arrow.Timestamp values.
diff --git a/go/arrow/array/timestamp_test.go b/go/arrow/array/timestamp_test.go
index d8d9f8a389274..1e55364e8da0d 100644
--- a/go/arrow/array/timestamp_test.go
+++ b/go/arrow/array/timestamp_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/union.go b/go/arrow/array/union.go
index 3b91356b3246e..869355ac7108a 100644
--- a/go/arrow/array/union.go
+++ b/go/arrow/array/union.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Union is a convenience interface to encompass both Sparse and Dense
diff --git a/go/arrow/array/union_test.go b/go/arrow/array/union_test.go
index 5ce1f97ebe98e..2f2bf3b84e9f7 100644
--- a/go/arrow/array/union_test.go
+++ b/go/arrow/array/union_test.go
@@ -21,9 +21,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/array/util.go b/go/arrow/array/util.go
index bad9897b5910e..54d15a8095c80 100644
--- a/go/arrow/array/util.go
+++ b/go/arrow/array/util.go
@@ -22,11 +22,11 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/hashing"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 func min(a, b int) int {
diff --git a/go/arrow/array/util_test.go b/go/arrow/array/util_test.go
index 25df34e9271c1..d3d2b37365513 100644
--- a/go/arrow/array/util_test.go
+++ b/go/arrow/array/util_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/arrio/arrio.go b/go/arrow/arrio/arrio.go
index be05b9494b8ed..466a93a68400a 100644
--- a/go/arrow/arrio/arrio.go
+++ b/go/arrow/arrio/arrio.go
@@ -22,7 +22,7 @@ import (
 	"errors"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Reader is the interface that wraps the Read method.
diff --git a/go/arrow/arrio/arrio_test.go b/go/arrow/arrio/arrio_test.go
index e2d49ba542135..7e9aac8fbe520 100644
--- a/go/arrow/arrio/arrio_test.go
+++ b/go/arrow/arrio/arrio_test.go
@@ -22,11 +22,11 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type copyKind int
diff --git a/go/arrow/bitutil/bitmaps.go b/go/arrow/bitutil/bitmaps.go
index 3a1258414b8bd..2e9c0601c3c45 100644
--- a/go/arrow/bitutil/bitmaps.go
+++ b/go/arrow/bitutil/bitmaps.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // BitmapReader is a simple bitmap reader for a byte slice.
diff --git a/go/arrow/bitutil/bitmaps_test.go b/go/arrow/bitutil/bitmaps_test.go
index 6fb61ae2aa66b..60022a179d1da 100644
--- a/go/arrow/bitutil/bitmaps_test.go
+++ b/go/arrow/bitutil/bitmaps_test.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/bitutil/bitutil.go b/go/arrow/bitutil/bitutil.go
index a5d74f2b325a2..a4a1519b8f940 100644
--- a/go/arrow/bitutil/bitutil.go
+++ b/go/arrow/bitutil/bitutil.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/bitutil/bitutil_test.go b/go/arrow/bitutil/bitutil_test.go
index 922ad440b0374..9e29e9d04d1db 100644
--- a/go/arrow/bitutil/bitutil_test.go
+++ b/go/arrow/bitutil/bitutil_test.go
@@ -21,8 +21,8 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index 3d209e65a5d69..97e1cb91ad7e0 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -47,10 +47,10 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index dae9f5fefe242..209bd237f6f53 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -45,11 +45,11 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
 )
 
 func encodeCMetadata(keys, values []string) []byte {
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index 0c4bbae3d5526..5b8082a4322d0 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -34,11 +34,11 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index c731c730c6bcd..5a9b696e296ca 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -70,8 +70,8 @@ import (
 	"math/rand"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 const (
diff --git a/go/arrow/cdata/exports.go b/go/arrow/cdata/exports.go
index 118dec2c38b96..4dc2364da2913 100644
--- a/go/arrow/cdata/exports.go
+++ b/go/arrow/cdata/exports.go
@@ -21,8 +21,8 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 // #include <stdlib.h>
diff --git a/go/arrow/cdata/interface.go b/go/arrow/cdata/interface.go
index 50404878005b9..c7e81dde9f063 100644
--- a/go/arrow/cdata/interface.go
+++ b/go/arrow/cdata/interface.go
@@ -22,10 +22,10 @@ package cdata
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/test/test_cimport.go b/go/arrow/cdata/test/test_cimport.go
index daa3b2f785640..a7c5dc034496a 100644
--- a/go/arrow/cdata/test/test_cimport.go
+++ b/go/arrow/cdata/test/test_cimport.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/cdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/cdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/compute/arithmetic.go b/go/arrow/compute/arithmetic.go
index 046cb3f2d9e13..2fb95f06ff84a 100644
--- a/go/arrow/compute/arithmetic.go
+++ b/go/arrow/compute/arithmetic.go
@@ -22,12 +22,12 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 type (
diff --git a/go/arrow/compute/arithmetic_test.go b/go/arrow/compute/arithmetic_test.go
index d9dd799b7cfce..a99b2074eb69f 100644
--- a/go/arrow/compute/arithmetic_test.go
+++ b/go/arrow/compute/arithmetic_test.go
@@ -26,16 +26,16 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/klauspost/cpuid/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/compute/cast.go b/go/arrow/compute/cast.go
index d77273f539595..8b720a2bad5d8 100644
--- a/go/arrow/compute/cast.go
+++ b/go/arrow/compute/cast.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/cast_test.go b/go/arrow/compute/cast_test.go
index e1051a33dfa1d..cc301cc35e6e5 100644
--- a/go/arrow/compute/cast_test.go
+++ b/go/arrow/compute/cast_test.go
@@ -26,16 +26,16 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/datum.go b/go/arrow/compute/datum.go
index 431c79d48554a..1d3c1b4dab700 100644
--- a/go/arrow/compute/datum.go
+++ b/go/arrow/compute/datum.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 //go:generate go run golang.org/x/tools/cmd/stringer -type=DatumKind -linecomment
diff --git a/go/arrow/compute/example_test.go b/go/arrow/compute/example_test.go
index 8d0f25e4c4372..f0db9f377868e 100644
--- a/go/arrow/compute/example_test.go
+++ b/go/arrow/compute/example_test.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // This example demonstrates how to register a custom scalar function.
diff --git a/go/arrow/compute/exec.go b/go/arrow/compute/exec.go
index c478a1dcdef7d..84e3310cc2df8 100644
--- a/go/arrow/compute/exec.go
+++ b/go/arrow/compute/exec.go
@@ -22,9 +22,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 func haveChunkedArray(values []Datum) bool {
diff --git a/go/arrow/compute/exec/kernel.go b/go/arrow/compute/exec/kernel.go
index c93a17e947335..327426da68eb9 100644
--- a/go/arrow/compute/exec/kernel.go
+++ b/go/arrow/compute/exec/kernel.go
@@ -24,10 +24,10 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/slices"
 )
 
diff --git a/go/arrow/compute/exec/kernel_test.go b/go/arrow/compute/exec/kernel_test.go
index 65fc41e4e4d56..16a29ea2deda6 100644
--- a/go/arrow/compute/exec/kernel_test.go
+++ b/go/arrow/compute/exec/kernel_test.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/span.go b/go/arrow/compute/exec/span.go
index baf280142daac..b6d240fa4a0be 100644
--- a/go/arrow/compute/exec/span.go
+++ b/go/arrow/compute/exec/span.go
@@ -23,11 +23,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // BufferSpan is a lightweight Buffer holder for ArraySpans that does not
diff --git a/go/arrow/compute/exec/span_test.go b/go/arrow/compute/exec/span_test.go
index 3cbd54f0d4094..c642be1c30c23 100644
--- a/go/arrow/compute/exec/span_test.go
+++ b/go/arrow/compute/exec/span_test.go
@@ -24,14 +24,14 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/utils.go b/go/arrow/compute/exec/utils.go
index 39c4fff90920e..6d83b75da1313 100644
--- a/go/arrow/compute/exec/utils.go
+++ b/go/arrow/compute/exec/utils.go
@@ -25,13 +25,13 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/exec/utils_test.go b/go/arrow/compute/exec/utils_test.go
index 4f908bb2057b1..e9bb07177f2ac 100644
--- a/go/arrow/compute/exec/utils_test.go
+++ b/go/arrow/compute/exec/utils_test.go
@@ -21,10 +21,10 @@ package exec_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec_internals_test.go b/go/arrow/compute/exec_internals_test.go
index 3247becd969a3..eb9273d23389f 100644
--- a/go/arrow/compute/exec_internals_test.go
+++ b/go/arrow/compute/exec_internals_test.go
@@ -24,13 +24,13 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/exec_test.go b/go/arrow/compute/exec_test.go
index 308e30aac7316..30bfbc0246a1c 100644
--- a/go/arrow/compute/exec_test.go
+++ b/go/arrow/compute/exec_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index 962f41019dac2..ac87d063915b7 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -25,14 +25,14 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // ExecCtx holds simple contextual information for execution
diff --git a/go/arrow/compute/expression.go b/go/arrow/compute/expression.go
index 04128bef7738c..9f20c9704dca7 100644
--- a/go/arrow/compute/expression.go
+++ b/go/arrow/compute/expression.go
@@ -28,14 +28,14 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 var hashSeed = maphash.MakeSeed()
diff --git a/go/arrow/compute/expression_test.go b/go/arrow/compute/expression_test.go
index 5373d056238c2..71b1b64c4b0c1 100644
--- a/go/arrow/compute/expression_test.go
+++ b/go/arrow/compute/expression_test.go
@@ -22,11 +22,11 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exprs/builders.go b/go/arrow/compute/exprs/builders.go
index 28e0b06fc7763..39606c27e714a 100644
--- a/go/arrow/compute/exprs/builders.go
+++ b/go/arrow/compute/exprs/builders.go
@@ -25,8 +25,8 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/builders_test.go b/go/arrow/compute/exprs/builders_test.go
index 7b6f3ecac7c4a..9aaa4a2c4f9e4 100644
--- a/go/arrow/compute/exprs/builders_test.go
+++ b/go/arrow/compute/exprs/builders_test.go
@@ -21,8 +21,8 @@ package exprs_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/exec.go b/go/arrow/compute/exprs/exec.go
index 7683587478bf2..d63752696082b 100644
--- a/go/arrow/compute/exprs/exec.go
+++ b/go/arrow/compute/exprs/exec.go
@@ -23,15 +23,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/exec_internal_test.go b/go/arrow/compute/exprs/exec_internal_test.go
index a41a21ef59d11..9475a9a8cbca9 100644
--- a/go/arrow/compute/exprs/exec_internal_test.go
+++ b/go/arrow/compute/exprs/exec_internal_test.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/exprs/exec_test.go b/go/arrow/compute/exprs/exec_test.go
index 9cadcb37ad21a..e30d2afdb73f8 100644
--- a/go/arrow/compute/exprs/exec_test.go
+++ b/go/arrow/compute/exprs/exec_test.go
@@ -23,12 +23,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exprs"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/extension_types.go b/go/arrow/compute/exprs/extension_types.go
index dd753727f59c8..ce375492d67f1 100644
--- a/go/arrow/compute/exprs/extension_types.go
+++ b/go/arrow/compute/exprs/extension_types.go
@@ -24,8 +24,8 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type simpleExtensionTypeFactory[P comparable] struct {
diff --git a/go/arrow/compute/exprs/field_refs.go b/go/arrow/compute/exprs/field_refs.go
index 3a08d519fbebe..fd4313818195e 100644
--- a/go/arrow/compute/exprs/field_refs.go
+++ b/go/arrow/compute/exprs/field_refs.go
@@ -21,11 +21,11 @@ package exprs
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 )
 
diff --git a/go/arrow/compute/exprs/types.go b/go/arrow/compute/exprs/types.go
index b9bb9f492a752..9f807e1e1ecbc 100644
--- a/go/arrow/compute/exprs/types.go
+++ b/go/arrow/compute/exprs/types.go
@@ -24,8 +24,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/fieldref.go b/go/arrow/compute/fieldref.go
index 4fe51817a64b5..ee6f39948ebf1 100644
--- a/go/arrow/compute/fieldref.go
+++ b/go/arrow/compute/fieldref.go
@@ -27,8 +27,8 @@ import (
 	"unicode"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 var (
diff --git a/go/arrow/compute/fieldref_test.go b/go/arrow/compute/fieldref_test.go
index 11ceb4c9037ec..c38ad8ac1fe30 100644
--- a/go/arrow/compute/fieldref_test.go
+++ b/go/arrow/compute/fieldref_test.go
@@ -19,10 +19,10 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/functions.go b/go/arrow/compute/functions.go
index 887346f7f5d06..a1905f91850f0 100644
--- a/go/arrow/compute/functions.go
+++ b/go/arrow/compute/functions.go
@@ -23,8 +23,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 type Function interface {
diff --git a/go/arrow/compute/functions_test.go b/go/arrow/compute/functions_test.go
index f452ebeec2ac6..b37da285badd0 100644
--- a/go/arrow/compute/functions_test.go
+++ b/go/arrow/compute/functions_test.go
@@ -21,8 +21,8 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic.go b/go/arrow/compute/internal/kernels/base_arithmetic.go
index bfdb7b8f2103e..67e80af74f511 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic.go
@@ -24,11 +24,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
index 9683ac9420fdd..0e78e6c9183ff 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/sys/cpu"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
index f5c48d9cb874f..29cce7830e0f4 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
index ccb4ac93ba4bf..e9b03551f81b1 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
index 767425d61e221..4f160a1411091 100644
--- a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
+++ b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
@@ -19,7 +19,7 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/boolean_cast.go b/go/arrow/compute/internal/kernels/boolean_cast.go
index b0ca7c2d9157a..18d04c845c41d 100644
--- a/go/arrow/compute/internal/kernels/boolean_cast.go
+++ b/go/arrow/compute/internal/kernels/boolean_cast.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 func isNonZero[T exec.FixedWidthTypes](ctx *exec.KernelCtx, in []T, out []byte) error {
diff --git a/go/arrow/compute/internal/kernels/cast.go b/go/arrow/compute/internal/kernels/cast.go
index 50cf775d2985e..5a71206b2476c 100644
--- a/go/arrow/compute/internal/kernels/cast.go
+++ b/go/arrow/compute/internal/kernels/cast.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 type CastOptions struct {
diff --git a/go/arrow/compute/internal/kernels/cast_numeric.go b/go/arrow/compute/internal/kernels/cast_numeric.go
index 0638c178a167e..4e5c5c1d9ea77 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 var castNumericUnsafe func(itype, otype arrow.Type, in, out []byte, len int) = castNumericGo
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
index fba165b5c37b7..6b28441ec083e 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
index 6e6288c4996e8..d53a4486f6983 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
index a1fbc85881de1..1cbea033dec27 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_temporal.go b/go/arrow/compute/internal/kernels/cast_temporal.go
index 8201119a4edbc..82fce1e33c959 100644
--- a/go/arrow/compute/internal/kernels/cast_temporal.go
+++ b/go/arrow/compute/internal/kernels/cast_temporal.go
@@ -24,10 +24,10 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const millisecondsInDay = 86400000
diff --git a/go/arrow/compute/internal/kernels/helpers.go b/go/arrow/compute/internal/kernels/helpers.go
index 99816bc9bd43a..ed25071c9d87f 100644
--- a/go/arrow/compute/internal/kernels/helpers.go
+++ b/go/arrow/compute/internal/kernels/helpers.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/numeric_cast.go b/go/arrow/compute/internal/kernels/numeric_cast.go
index f0e469f15f338..8e5350754723d 100644
--- a/go/arrow/compute/internal/kernels/numeric_cast.go
+++ b/go/arrow/compute/internal/kernels/numeric_cast.go
@@ -23,13 +23,13 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/rounding.go b/go/arrow/compute/internal/kernels/rounding.go
index 93f5829018f67..2f58a9faea8a2 100644
--- a/go/arrow/compute/internal/kernels/rounding.go
+++ b/go/arrow/compute/internal/kernels/rounding.go
@@ -22,11 +22,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_arithmetic.go b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
index 3f6832cbbc583..9cb32ae64a4a9 100644
--- a/go/arrow/compute/internal/kernels/scalar_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // scalar kernel that ignores (assumed all-null inputs) and returns null
diff --git a/go/arrow/compute/internal/kernels/scalar_boolean.go b/go/arrow/compute/internal/kernels/scalar_boolean.go
index 59ea7627a204f..812f4ad1bd363 100644
--- a/go/arrow/compute/internal/kernels/scalar_boolean.go
+++ b/go/arrow/compute/internal/kernels/scalar_boolean.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 type computeWordFN func(leftTrue, leftFalse, rightTrue, rightFalse uint64) (outValid, outData uint64)
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
index a4cecb80bbd2f..585d1bff01ab6 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
index 5916b244440db..868179057ccf4 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
index 204eaa6d448ea..56abad42b1ffc 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
@@ -18,7 +18,7 @@
 
 package kernels
 
-import "github.com/apache/arrow/go/v13/arrow/compute/exec"
+import "github.com/apache/arrow/go/v14/arrow/compute/exec"
 
 func genCompareKernel[T exec.NumericTypes](op CompareOperator) *CompareData {
 	return genGoCompareKernel(getCmpOp[T](op))
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
index 3ff90dacdb424..7cf96a4171d6c 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparisons.go b/go/arrow/compute/internal/kernels/scalar_comparisons.go
index 8d4ae244397d3..8a957eafd85da 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparisons.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparisons.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 type binaryKernel func(left, right, out []byte, offset int)
diff --git a/go/arrow/compute/internal/kernels/string_casts.go b/go/arrow/compute/internal/kernels/string_casts.go
index db278fd853d1d..3070514665d7d 100644
--- a/go/arrow/compute/internal/kernels/string_casts.go
+++ b/go/arrow/compute/internal/kernels/string_casts.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 func validateUtf8Fsb(input *exec.ArraySpan) error {
diff --git a/go/arrow/compute/internal/kernels/types.go b/go/arrow/compute/internal/kernels/types.go
index b1d0fa0403229..2788fb7054c53 100644
--- a/go/arrow/compute/internal/kernels/types.go
+++ b/go/arrow/compute/internal/kernels/types.go
@@ -21,10 +21,10 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 var (
diff --git a/go/arrow/compute/internal/kernels/vector_hash.go b/go/arrow/compute/internal/kernels/vector_hash.go
index ee592b98b87a5..e0ede826e876e 100644
--- a/go/arrow/compute/internal/kernels/vector_hash.go
+++ b/go/arrow/compute/internal/kernels/vector_hash.go
@@ -21,13 +21,13 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/hashing"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/hashing"
 )
 
 type HashState interface {
diff --git a/go/arrow/compute/internal/kernels/vector_run_end_encode.go b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
index e5ea93a3ebc47..e073ff1ff5308 100644
--- a/go/arrow/compute/internal/kernels/vector_run_end_encode.go
+++ b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
@@ -24,14 +24,14 @@ import (
 	"sort"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type RunEndEncodeState struct {
diff --git a/go/arrow/compute/internal/kernels/vector_selection.go b/go/arrow/compute/internal/kernels/vector_selection.go
index 73b54fdeb5420..c7a902bd008d0 100644
--- a/go/arrow/compute/internal/kernels/vector_selection.go
+++ b/go/arrow/compute/internal/kernels/vector_selection.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 type NullSelectionBehavior int8
diff --git a/go/arrow/compute/registry.go b/go/arrow/compute/registry.go
index 823d625528ded..4f1c435fb680a 100644
--- a/go/arrow/compute/registry.go
+++ b/go/arrow/compute/registry.go
@@ -21,7 +21,7 @@ package compute
 import (
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/registry_test.go b/go/arrow/compute/registry_test.go
index c447364359287..428f7cf1d8fda 100644
--- a/go/arrow/compute/registry_test.go
+++ b/go/arrow/compute/registry_test.go
@@ -23,9 +23,9 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/scalar_bool.go b/go/arrow/compute/scalar_bool.go
index 5678a1fb6943e..49c745688284e 100644
--- a/go/arrow/compute/scalar_bool.go
+++ b/go/arrow/compute/scalar_bool.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/scalar_bool_test.go b/go/arrow/compute/scalar_bool_test.go
index d2d13cc08884c..6eadc973d6965 100644
--- a/go/arrow/compute/scalar_bool_test.go
+++ b/go/arrow/compute/scalar_bool_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/compute/scalar_compare.go b/go/arrow/compute/scalar_compare.go
index 14c0a4d25d0da..476f37711e289 100644
--- a/go/arrow/compute/scalar_compare.go
+++ b/go/arrow/compute/scalar_compare.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 type compareFunction struct {
diff --git a/go/arrow/compute/scalar_compare_test.go b/go/arrow/compute/scalar_compare_test.go
index 4643e26ce1873..13fdd24fdd6b3 100644
--- a/go/arrow/compute/scalar_compare_test.go
+++ b/go/arrow/compute/scalar_compare_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/selection.go b/go/arrow/compute/selection.go
index 4593ba0daf4df..ed6d80418d3f6 100644
--- a/go/arrow/compute/selection.go
+++ b/go/arrow/compute/selection.go
@@ -22,10 +22,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/arrow/compute/utils.go b/go/arrow/compute/utils.go
index 5b3aef1691848..cc4d6edc48ec8 100644
--- a/go/arrow/compute/utils.go
+++ b/go/arrow/compute/utils.go
@@ -24,12 +24,12 @@ import (
 	"math"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/compute/vector_hash.go b/go/arrow/compute/vector_hash.go
index 9fdbd3d974dcc..5f9aec55c55bc 100644
--- a/go/arrow/compute/vector_hash.go
+++ b/go/arrow/compute/vector_hash.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_hash_test.go b/go/arrow/compute/vector_hash_test.go
index e83687b12700d..50c96ddc04f6c 100644
--- a/go/arrow/compute/vector_hash_test.go
+++ b/go/arrow/compute/vector_hash_test.go
@@ -23,13 +23,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/vector_run_end_test.go b/go/arrow/compute/vector_run_end_test.go
index 62ea7dba015a2..8d894d96b8f0a 100644
--- a/go/arrow/compute/vector_run_end_test.go
+++ b/go/arrow/compute/vector_run_end_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/vector_run_ends.go b/go/arrow/compute/vector_run_ends.go
index 75d48f04de582..48f3dcba8c481 100644
--- a/go/arrow/compute/vector_run_ends.go
+++ b/go/arrow/compute/vector_run_ends.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_selection_test.go b/go/arrow/compute/vector_selection_test.go
index 2a97f4c1301bb..10788d60e10d2 100644
--- a/go/arrow/compute/vector_selection_test.go
+++ b/go/arrow/compute/vector_selection_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/compute/exec"
-	"github.com/apache/arrow/go/v13/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/csv/common.go b/go/arrow/csv/common.go
index ccdf964eae5a1..bdc18f2fbea90 100644
--- a/go/arrow/csv/common.go
+++ b/go/arrow/csv/common.go
@@ -22,8 +22,8 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/csv/reader.go b/go/arrow/csv/reader.go
index 8843cac87ca1a..80af520a12b7f 100644
--- a/go/arrow/csv/reader.go
+++ b/go/arrow/csv/reader.go
@@ -29,13 +29,13 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Reader wraps encoding/csv.Reader and creates array.Records from a schema.
diff --git a/go/arrow/csv/reader_test.go b/go/arrow/csv/reader_test.go
index d6d635163226e..f481cd2e961d3 100644
--- a/go/arrow/csv/reader_test.go
+++ b/go/arrow/csv/reader_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/csv"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/csv"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/csv/transformer.go b/go/arrow/csv/transformer.go
index 3eeb44cfe6e01..7c8eafcee1a59 100644
--- a/go/arrow/csv/transformer.go
+++ b/go/arrow/csv/transformer.go
@@ -25,8 +25,8 @@ import (
 	"math/big"
 	"strconv"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 func (w *Writer) transformColToStringArr(typ arrow.DataType, col arrow.Array) []string {
diff --git a/go/arrow/csv/writer.go b/go/arrow/csv/writer.go
index 9c451b845b057..e558364ecf16d 100644
--- a/go/arrow/csv/writer.go
+++ b/go/arrow/csv/writer.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Writer wraps encoding/csv.Writer and writes arrow.Record based on a schema.
diff --git a/go/arrow/csv/writer_test.go b/go/arrow/csv/writer_test.go
index 7216eb8cbd439..f945023790426 100644
--- a/go/arrow/csv/writer_test.go
+++ b/go/arrow/csv/writer_test.go
@@ -25,14 +25,14 @@ import (
 	"log"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/csv"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/csv"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 )
 
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index 760b0f01a5e2b..d784c2bfe0767 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -21,7 +21,7 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Type is a logical type. They can be expressed as
diff --git a/go/arrow/datatype_binary_test.go b/go/arrow/datatype_binary_test.go
index 91e5a1169a236..c47df3da1db9c 100644
--- a/go/arrow/datatype_binary_test.go
+++ b/go/arrow/datatype_binary_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestBinaryType(t *testing.T) {
diff --git a/go/arrow/datatype_extension_test.go b/go/arrow/datatype_extension_test.go
index 4e361a7536a84..c542b22b769e6 100644
--- a/go/arrow/datatype_extension_test.go
+++ b/go/arrow/datatype_extension_test.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index 4b6ca55291537..f8806d25e201c 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/internal/json"
 
 	"golang.org/x/xerrors"
 )
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index 669c7f9ca87ad..bf93f0fc61c67 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/datatype_nested.go b/go/arrow/datatype_nested.go
index fd7093662fe1f..50777929c00a6 100644
--- a/go/arrow/datatype_nested.go
+++ b/go/arrow/datatype_nested.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 type (
diff --git a/go/arrow/datatype_null_test.go b/go/arrow/datatype_null_test.go
index 6c6fa9f454de7..286a72fb7fea3 100644
--- a/go/arrow/datatype_null_test.go
+++ b/go/arrow/datatype_null_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestNullType(t *testing.T) {
diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index 4757ec5307638..68d729526d353 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -23,7 +23,7 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 var (
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index fcb4a04e7a98a..6fa54091019e7 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -22,7 +22,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/decimal256/decimal256.go b/go/arrow/decimal256/decimal256.go
index 62a9b3a10a8b4..4bfcd4e0419f2 100644
--- a/go/arrow/decimal256/decimal256.go
+++ b/go/arrow/decimal256/decimal256.go
@@ -23,8 +23,8 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal256/decimal256_test.go b/go/arrow/decimal256/decimal256_test.go
index 1de4558b7e5c5..b944d0b1305df 100644
--- a/go/arrow/decimal256/decimal256_test.go
+++ b/go/arrow/decimal256/decimal256_test.go
@@ -22,7 +22,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/doc.go b/go/arrow/doc.go
index 0d8272e7df33f..ad03f2eca8ca1 100644
--- a/go/arrow/doc.go
+++ b/go/arrow/doc.go
@@ -37,7 +37,7 @@ To build with tinygo include the noasm build tag.
 */
 package arrow
 
-const PkgVersion = "13.0.0-SNAPSHOT"
+const PkgVersion = "14.0.0-SNAPSHOT"
 
 //go:generate go run _tools/tmpl/main.go -i -data=numeric.tmpldata type_traits_numeric.gen.go.tmpl type_traits_numeric.gen_test.go.tmpl array/numeric.gen.go.tmpl array/numericbuilder.gen.go.tmpl array/bufferbuilder_numeric.gen.go.tmpl
 //go:generate go run _tools/tmpl/main.go -i -data=datatype_numeric.gen.go.tmpldata datatype_numeric.gen.go.tmpl tensor/numeric.gen.go.tmpl tensor/numeric.gen_test.go.tmpl
diff --git a/go/arrow/encoded/ree_utils.go b/go/arrow/encoded/ree_utils.go
index 1e15209f77e82..1f71e7b5210cf 100644
--- a/go/arrow/encoded/ree_utils.go
+++ b/go/arrow/encoded/ree_utils.go
@@ -20,7 +20,7 @@ import (
 	"math"
 	"sort"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // FindPhysicalIndex performs a binary search on the run-ends to return
diff --git a/go/arrow/encoded/ree_utils_test.go b/go/arrow/encoded/ree_utils_test.go
index cd11c127591a1..785a3b105a47d 100644
--- a/go/arrow/encoded/ree_utils_test.go
+++ b/go/arrow/encoded/ree_utils_test.go
@@ -21,10 +21,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/encoded"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/endian/endian.go b/go/arrow/endian/endian.go
index 81690234a8490..3ecda7b3600b7 100644
--- a/go/arrow/endian/endian.go
+++ b/go/arrow/endian/endian.go
@@ -17,8 +17,8 @@
 package endian
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
 )
 
 type Endianness flatbuf.Endianness
diff --git a/go/arrow/example_test.go b/go/arrow/example_test.go
index ee232313192ea..10b3633f65536 100644
--- a/go/arrow/example_test.go
+++ b/go/arrow/example_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 // This example demonstrates how to build an array of int64 values using a builder and Append.
diff --git a/go/arrow/flight/basic_auth_flight_test.go b/go/arrow/flight/basic_auth_flight_test.go
index 7f9b7ca2f77ab..0f63a400353d2 100755
--- a/go/arrow/flight/basic_auth_flight_test.go
+++ b/go/arrow/flight/basic_auth_flight_test.go
@@ -22,7 +22,7 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index 1de5fc47f5f28..c4a5843ea10f4 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/cookie_middleware_test.go b/go/arrow/flight/cookie_middleware_test.go
index e48e9e65779df..2bde37fc0bb85 100644
--- a/go/arrow/flight/cookie_middleware_test.go
+++ b/go/arrow/flight/cookie_middleware_test.go
@@ -28,7 +28,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/example_flight_server_test.go b/go/arrow/flight/example_flight_server_test.go
index a9ac8d376fd39..09f01361d13a0 100755
--- a/go/arrow/flight/example_flight_server_test.go
+++ b/go/arrow/flight/example_flight_server_test.go
@@ -23,7 +23,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flight_middleware_test.go b/go/arrow/flight/flight_middleware_test.go
index 8cde29e969f0f..f2b240d1f2e45 100755
--- a/go/arrow/flight/flight_middleware_test.go
+++ b/go/arrow/flight/flight_middleware_test.go
@@ -23,8 +23,8 @@ import (
 	sync "sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flight_test.go b/go/arrow/flight/flight_test.go
index 7099f69d6b62a..7cd724b76b8ce 100755
--- a/go/arrow/flight/flight_test.go
+++ b/go/arrow/flight/flight_test.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flightsql/client.go b/go/arrow/flight/flightsql/client.go
index f4cd6ee7ce56f..13d046661e96d 100644
--- a/go/arrow/flight/flightsql/client.go
+++ b/go/arrow/flight/flightsql/client.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index fdc08a247f9ff..bb4ae29477997 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/column_metadata.go b/go/arrow/flight/flightsql/column_metadata.go
index 9f53ac2d1971f..d9785892888b2 100644
--- a/go/arrow/flight/flightsql/column_metadata.go
+++ b/go/arrow/flight/flightsql/column_metadata.go
@@ -19,7 +19,7 @@ package flightsql
 import (
 	"strconv"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/driver/config_test.go b/go/arrow/flight/flightsql/driver/config_test.go
index 366cc4fafd1ac..abcececeaf214 100644
--- a/go/arrow/flight/flightsql/driver/config_test.go
+++ b/go/arrow/flight/flightsql/driver/config_test.go
@@ -22,7 +22,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
 )
 
 func TestConfigTLSRegistry(t *testing.T) {
diff --git a/go/arrow/flight/flightsql/driver/driver.go b/go/arrow/flight/flightsql/driver/driver.go
index 11a103e596fd5..b4cb0d2dbda2e 100644
--- a/go/arrow/flight/flightsql/driver/driver.go
+++ b/go/arrow/flight/flightsql/driver/driver.go
@@ -25,11 +25,11 @@ import (
 	"sort"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go
index 08c23e7b1425b..3ec8533979a32 100644
--- a/go/arrow/flight/flightsql/driver/driver_test.go
+++ b/go/arrow/flight/flightsql/driver/driver_test.go
@@ -33,13 +33,13 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/driver"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 const defaultTableName = "drivertest"
diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go
index e3c2cebd6b4fb..a2ed4ef26e227 100644
--- a/go/arrow/flight/flightsql/driver/utils.go
+++ b/go/arrow/flight/flightsql/driver/utils.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 // *** GRPC helpers ***
diff --git a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
index 6fd63a255160b..6508833876fa5 100644
--- a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
+++ b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
@@ -27,9 +27,9 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/example/sql_batch_reader.go b/go/arrow/flight/flightsql/example/sql_batch_reader.go
index a8735de48a5e6..7101b8f830a6f 100644
--- a/go/arrow/flight/flightsql/example/sql_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sql_batch_reader.go
@@ -26,11 +26,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/wrapperspb"
diff --git a/go/arrow/flight/flightsql/example/sqlite_info.go b/go/arrow/flight/flightsql/example/sqlite_info.go
index d8333ca32b60b..bf29265853c65 100644
--- a/go/arrow/flight/flightsql/example/sqlite_info.go
+++ b/go/arrow/flight/flightsql/example/sqlite_info.go
@@ -20,8 +20,8 @@
 package example
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 func SqlInfoResultMap() flightsql.SqlInfoResultMap {
diff --git a/go/arrow/flight/flightsql/example/sqlite_server.go b/go/arrow/flight/flightsql/example/sqlite_server.go
index 2f8ff99b3155f..63b41ee5e0a4a 100644
--- a/go/arrow/flight/flightsql/example/sqlite_server.go
+++ b/go/arrow/flight/flightsql/example/sqlite_server.go
@@ -45,13 +45,13 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
index 3fef303f54c1e..507abf622d890 100644
--- a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	sqlite3 "modernc.org/sqlite/lib"
 )
 
diff --git a/go/arrow/flight/flightsql/example/type_info.go b/go/arrow/flight/flightsql/example/type_info.go
index 22c4358ecf336..6d6ceb339e4b0 100644
--- a/go/arrow/flight/flightsql/example/type_info.go
+++ b/go/arrow/flight/flightsql/example/type_info.go
@@ -22,10 +22,10 @@ package example
 import (
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func GetTypeInfoResult(mem memory.Allocator) arrow.Record {
diff --git a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
index de9fa6b2ec7f0..98d61f8110d45 100644
--- a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
+++ b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
@@ -18,7 +18,7 @@
 // by FlightSQL servers and clients.
 package schema_ref
 
-import "github.com/apache/arrow/go/v13/arrow"
+import "github.com/apache/arrow/go/v14/arrow"
 
 var (
 	Catalogs = arrow.NewSchema(
diff --git a/go/arrow/flight/flightsql/server.go b/go/arrow/flight/flightsql/server.go
index 48c0314fa6490..e9cbc177da2c4 100644
--- a/go/arrow/flight/flightsql/server.go
+++ b/go/arrow/flight/flightsql/server.go
@@ -20,14 +20,14 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
diff --git a/go/arrow/flight/flightsql/server_test.go b/go/arrow/flight/flightsql/server_test.go
index 43a23bb7e9ac6..33e9b8236a261 100644
--- a/go/arrow/flight/flightsql/server_test.go
+++ b/go/arrow/flight/flightsql/server_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/sql_info.go b/go/arrow/flight/flightsql/sql_info.go
index 904e784570483..a12c4fbdaeda9 100644
--- a/go/arrow/flight/flightsql/sql_info.go
+++ b/go/arrow/flight/flightsql/sql_info.go
@@ -17,8 +17,8 @@
 package flightsql
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/sqlite_server_test.go b/go/arrow/flight/flightsql/sqlite_server_test.go
index 24c2ccb1e4760..03ae3d7a8313a 100644
--- a/go/arrow/flight/flightsql/sqlite_server_test.go
+++ b/go/arrow/flight/flightsql/sqlite_server_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/types.go b/go/arrow/flight/flightsql/types.go
index 34db36b44df2a..98086a61fe067 100644
--- a/go/arrow/flight/flightsql/types.go
+++ b/go/arrow/flight/flightsql/types.go
@@ -17,7 +17,7 @@
 package flightsql
 
 import (
-	pb "github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
diff --git a/go/arrow/flight/record_batch_reader.go b/go/arrow/flight/record_batch_reader.go
index e7ee65b0aeb08..b726180627e6f 100644
--- a/go/arrow/flight/record_batch_reader.go
+++ b/go/arrow/flight/record_batch_reader.go
@@ -21,12 +21,12 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // DataStreamReader is an interface for receiving flight data messages on a stream
diff --git a/go/arrow/flight/record_batch_writer.go b/go/arrow/flight/record_batch_writer.go
index a070de78b58b7..3ae17bcf48042 100644
--- a/go/arrow/flight/record_batch_writer.go
+++ b/go/arrow/flight/record_batch_writer.go
@@ -19,9 +19,9 @@ package flight
 import (
 	"bytes"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // DataStreamWriter is an interface that represents an Arrow Flight stream
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index 88006b2fe2556..cf471f9b3a2b6 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -22,7 +22,7 @@ import (
 	"os"
 	"os/signal"
 
-	"github.com/apache/arrow/go/v13/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 )
 
diff --git a/go/arrow/flight/server_example_test.go b/go/arrow/flight/server_example_test.go
index 39d094fa6d97c..b82e2cb7f7164 100644
--- a/go/arrow/flight/server_example_test.go
+++ b/go/arrow/flight/server_example_test.go
@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/apache/arrow/go/v13/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/health"
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 311645fd3ccba..3b592cf3992aa 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -21,14 +21,14 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 var (
diff --git a/go/arrow/internal/arrdata/ioutil.go b/go/arrow/internal/arrdata/ioutil.go
index abd9c2196e276..1a2ce0e5b5eca 100644
--- a/go/arrow/internal/arrdata/ioutil.go
+++ b/go/arrow/internal/arrdata/ioutil.go
@@ -23,11 +23,11 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // CheckArrowFile checks whether a given ARROW file contains the expected list of records.
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index 2748120b0c4fc..fa4438276f186 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Schema struct {
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index e969e553a1394..882dc9a0d860a 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -22,9 +22,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/arrjson/option.go b/go/arrow/internal/arrjson/option.go
index 71aa59c0c3811..7ae2058d471a7 100644
--- a/go/arrow/internal/arrjson/option.go
+++ b/go/arrow/internal/arrjson/option.go
@@ -17,8 +17,8 @@
 package arrjson
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type config struct {
diff --git a/go/arrow/internal/arrjson/reader.go b/go/arrow/internal/arrjson/reader.go
index 6ae397782f4a0..34b9b6e10ec4a 100644
--- a/go/arrow/internal/arrjson/reader.go
+++ b/go/arrow/internal/arrjson/reader.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Reader struct {
diff --git a/go/arrow/internal/arrjson/writer.go b/go/arrow/internal/arrjson/writer.go
index 7800483a9d0e1..ddac32609b604 100644
--- a/go/arrow/internal/arrjson/writer.go
+++ b/go/arrow/internal/arrjson/writer.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const (
diff --git a/go/arrow/internal/dictutils/dict.go b/go/arrow/internal/dictutils/dict.go
index fc8a856be2288..e09a2f4a0ecd1 100644
--- a/go/arrow/internal/dictutils/dict.go
+++ b/go/arrow/internal/dictutils/dict.go
@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"hash/maphash"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type Kind int8
diff --git a/go/arrow/internal/dictutils/dict_test.go b/go/arrow/internal/dictutils/dict_test.go
index e8c4f20570446..6cafacbd1df00 100644
--- a/go/arrow/internal/dictutils/dict_test.go
+++ b/go/arrow/internal/dictutils/dict_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestDictMemo(t *testing.T) {
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
index bd9b2229c1f74..8da39858fabab 100755
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
index 8d00e4cb05bdb..9cebb2c695ece 100644
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
@@ -23,7 +23,7 @@ import (
 	"os"
 	"syscall"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
 )
 
 var (
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 6646502ab648f..4108cf8124245 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -31,15 +31,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v13/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"golang.org/x/xerrors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index dd6257a399a24..ab9e015163730 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -19,10 +19,10 @@ package gen
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/arrow/internal/testing/tools/bits_test.go b/go/arrow/internal/testing/tools/bits_test.go
index d99337bd05532..7d0fccb5f999e 100644
--- a/go/arrow/internal/testing/tools/bits_test.go
+++ b/go/arrow/internal/testing/tools/bits_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/testing/tools/data_types.go b/go/arrow/internal/testing/tools/data_types.go
index b304f2b0f0be2..654780bc3e853 100644
--- a/go/arrow/internal/testing/tools/data_types.go
+++ b/go/arrow/internal/testing/tools/data_types.go
@@ -21,8 +21,8 @@ package tools
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/internal/utils.go b/go/arrow/internal/utils.go
index ea60371c55df3..265f030dfd19a 100644
--- a/go/arrow/internal/utils.go
+++ b/go/arrow/internal/utils.go
@@ -17,8 +17,8 @@
 package internal
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
 )
 
 const CurMetadataVersion = flatbuf.MetadataVersionV5
diff --git a/go/arrow/ipc/cmd/arrow-cat/main.go b/go/arrow/ipc/cmd/arrow-cat/main.go
index a24bc2a99b482..af53c9b4e5f44 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main.go
@@ -63,8 +63,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-cat/main_test.go b/go/arrow/ipc/cmd/arrow-cat/main_test.go
index 273192c73703c..22e4f6ffe0778 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestCatStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
index c4d7f5e197165..7e86263d6d5b8 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
index ad03b48a3c983..30db24715386f 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFileToStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
index 67f485eea173c..91ba6a4ad9b61 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
@@ -22,12 +22,12 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
index b0156da9d8667..140f9f62478c0 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
@@ -20,8 +20,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestIntegration(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main.go b/go/arrow/ipc/cmd/arrow-ls/main.go
index 3cee44c588771..f739c9ae7da8e 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main.go
@@ -61,8 +61,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main_test.go b/go/arrow/ipc/cmd/arrow-ls/main_test.go
index 4ffe97f68bc14..2c038dae97b52 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestLsStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
index ce27063873bce..758231ea21cf5 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
index d40309f0f1f06..4354b46e8964b 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestStreamToFile(t *testing.T) {
diff --git a/go/arrow/ipc/compression.go b/go/arrow/ipc/compression.go
index 51ca2400100fa..73fb916500804 100644
--- a/go/arrow/ipc/compression.go
+++ b/go/arrow/ipc/compression.go
@@ -19,9 +19,9 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/klauspost/compress/zstd"
 	"github.com/pierrec/lz4/v4"
 )
diff --git a/go/arrow/ipc/endian_swap.go b/go/arrow/ipc/endian_swap.go
index f8ed933b47653..d98fec1089f04 100644
--- a/go/arrow/ipc/endian_swap.go
+++ b/go/arrow/ipc/endian_swap.go
@@ -20,9 +20,9 @@ import (
 	"errors"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // swap the endianness of the array's buffers as needed in-place to save
diff --git a/go/arrow/ipc/endian_swap_test.go b/go/arrow/ipc/endian_swap_test.go
index 719da6b4d7198..4f02bb53d61a4 100644
--- a/go/arrow/ipc/endian_swap_test.go
+++ b/go/arrow/ipc/endian_swap_test.go
@@ -20,11 +20,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index d12f57324daf7..7d799149c2a69 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // FileReader is an Arrow file reader.
diff --git a/go/arrow/ipc/file_test.go b/go/arrow/ipc/file_test.go
index c22e966373b37..1b22719dc8097 100644
--- a/go/arrow/ipc/file_test.go
+++ b/go/arrow/ipc/file_test.go
@@ -21,9 +21,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFile(t *testing.T) {
diff --git a/go/arrow/ipc/file_writer.go b/go/arrow/ipc/file_writer.go
index 89cfae20b97a6..12384225b70a1 100644
--- a/go/arrow/ipc/file_writer.go
+++ b/go/arrow/ipc/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // PayloadWriter is an interface for injecting a different payloadwriter
diff --git a/go/arrow/ipc/ipc.go b/go/arrow/ipc/ipc.go
index 0376bf7f513c4..6c04b6f5ad2d6 100644
--- a/go/arrow/ipc/ipc.go
+++ b/go/arrow/ipc/ipc.go
@@ -19,10 +19,10 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 const (
diff --git a/go/arrow/ipc/ipc_test.go b/go/arrow/ipc/ipc_test.go
index 69083cc6311c9..551d325dc1212 100644
--- a/go/arrow/ipc/ipc_test.go
+++ b/go/arrow/ipc/ipc_test.go
@@ -29,10 +29,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestArrow12072(t *testing.T) {
diff --git a/go/arrow/ipc/message.go b/go/arrow/ipc/message.go
index 69e662b220055..c5d0ec68d19c4 100644
--- a/go/arrow/ipc/message.go
+++ b/go/arrow/ipc/message.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // MetadataVersion represents the Arrow metadata version.
diff --git a/go/arrow/ipc/message_test.go b/go/arrow/ipc/message_test.go
index ddc115ce7ff3f..cc41fdd3fe13d 100644
--- a/go/arrow/ipc/message_test.go
+++ b/go/arrow/ipc/message_test.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestMessageReaderBodyInAllocator(t *testing.T) {
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index eaa04beeb0d7d..5c5e41833aea1 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"sort"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
diff --git a/go/arrow/ipc/metadata_test.go b/go/arrow/ipc/metadata_test.go
index b3b9aacfc0e39..3038abdf5f791 100644
--- a/go/arrow/ipc/metadata_test.go
+++ b/go/arrow/ipc/metadata_test.go
@@ -21,12 +21,12 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	flatbuffers "github.com/google/flatbuffers/go"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/arrow/ipc/reader.go b/go/arrow/ipc/reader.go
index bee48cf965682..1f684c1f6c034 100644
--- a/go/arrow/ipc/reader.go
+++ b/go/arrow/ipc/reader.go
@@ -23,13 +23,13 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Reader reads records from an io.Reader.
diff --git a/go/arrow/ipc/reader_test.go b/go/arrow/ipc/reader_test.go
index 7bcf737af0d6d..229374e94ec74 100644
--- a/go/arrow/ipc/reader_test.go
+++ b/go/arrow/ipc/reader_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/stream_test.go b/go/arrow/ipc/stream_test.go
index d2a3878af8342..d8bbd8f04b14d 100644
--- a/go/arrow/ipc/stream_test.go
+++ b/go/arrow/ipc/stream_test.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestStream(t *testing.T) {
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index a56769ae9ec27..7866ec2b41011 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -26,14 +26,14 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type swriter struct {
diff --git a/go/arrow/ipc/writer_test.go b/go/arrow/ipc/writer_test.go
index e5629de3a6430..47aa29db91082 100644
--- a/go/arrow/ipc/writer_test.go
+++ b/go/arrow/ipc/writer_test.go
@@ -24,11 +24,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/math/float64.go b/go/arrow/math/float64.go
index 3c95fb0b7141f..81de594df6ce6 100644
--- a/go/arrow/math/float64.go
+++ b/go/arrow/math/float64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Float64Funcs struct {
diff --git a/go/arrow/math/float64_avx2_amd64.go b/go/arrow/math/float64_avx2_amd64.go
index 2ad0eccdda54a..8a131a2bc8fc5 100644
--- a/go/arrow/math/float64_avx2_amd64.go
+++ b/go/arrow/math/float64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_neon_arm64.go b/go/arrow/math/float64_neon_arm64.go
index 5c09f28624dc4..ad9b6435b26fc 100755
--- a/go/arrow/math/float64_neon_arm64.go
+++ b/go/arrow/math/float64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_sse4_amd64.go b/go/arrow/math/float64_sse4_amd64.go
index 5bdfaa8ab31b1..a2be5de43f5bb 100644
--- a/go/arrow/math/float64_sse4_amd64.go
+++ b/go/arrow/math/float64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_test.go b/go/arrow/math/float64_test.go
index abccb566a74d7..b10214f6d892f 100644
--- a/go/arrow/math/float64_test.go
+++ b/go/arrow/math/float64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/math"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/int64.go b/go/arrow/math/int64.go
index 8df4d7e47ece4..2adff970c2233 100644
--- a/go/arrow/math/int64.go
+++ b/go/arrow/math/int64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Int64Funcs struct {
diff --git a/go/arrow/math/int64_avx2_amd64.go b/go/arrow/math/int64_avx2_amd64.go
index d65815b354c6a..ac0b2e1ff662a 100644
--- a/go/arrow/math/int64_avx2_amd64.go
+++ b/go/arrow/math/int64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_neon_arm64.go b/go/arrow/math/int64_neon_arm64.go
index fab545aa1efde..4ab5fb771a526 100755
--- a/go/arrow/math/int64_neon_arm64.go
+++ b/go/arrow/math/int64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_sse4_amd64.go b/go/arrow/math/int64_sse4_amd64.go
index 39003d2458b37..85304210eb448 100644
--- a/go/arrow/math/int64_sse4_amd64.go
+++ b/go/arrow/math/int64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_test.go b/go/arrow/math/int64_test.go
index dadc4264e2be5..06b42ffe9351b 100644
--- a/go/arrow/math/int64_test.go
+++ b/go/arrow/math/int64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/math"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/type.go.tmpl b/go/arrow/math/type.go.tmpl
index f8833c8e75261..7ae142c46f12b 100644
--- a/go/arrow/math/type.go.tmpl
+++ b/go/arrow/math/type.go.tmpl
@@ -17,7 +17,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$def := .D}}
diff --git a/go/arrow/math/type_simd_amd64.go.tmpl b/go/arrow/math/type_simd_amd64.go.tmpl
index 71ec6292537e7..72d40ea386a8f 100644
--- a/go/arrow/math/type_simd_amd64.go.tmpl
+++ b/go/arrow/math/type_simd_amd64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_simd_arm64.go.tmpl b/go/arrow/math/type_simd_arm64.go.tmpl
index 71ec6292537e7..72d40ea386a8f 100755
--- a/go/arrow/math/type_simd_arm64.go.tmpl
+++ b/go/arrow/math/type_simd_arm64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_test.go.tmpl b/go/arrow/math/type_test.go.tmpl
index 3d4a03137584c..160fc34e4d4d4 100644
--- a/go/arrow/math/type_test.go.tmpl
+++ b/go/arrow/math/type_test.go.tmpl
@@ -19,9 +19,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/math"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/uint64.go b/go/arrow/math/uint64.go
index 64ffaf546044f..64ac63a3d1853 100644
--- a/go/arrow/math/uint64.go
+++ b/go/arrow/math/uint64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Uint64Funcs struct {
diff --git a/go/arrow/math/uint64_avx2_amd64.go b/go/arrow/math/uint64_avx2_amd64.go
index 2fa66a7c7abad..2a35bebc980b3 100644
--- a/go/arrow/math/uint64_avx2_amd64.go
+++ b/go/arrow/math/uint64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_neon_arm64.go b/go/arrow/math/uint64_neon_arm64.go
index 7bfa0aba0b4f8..f6588694bb1fd 100755
--- a/go/arrow/math/uint64_neon_arm64.go
+++ b/go/arrow/math/uint64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_sse4_amd64.go b/go/arrow/math/uint64_sse4_amd64.go
index 57dc5aa98e016..8c6621464f118 100644
--- a/go/arrow/math/uint64_sse4_amd64.go
+++ b/go/arrow/math/uint64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_test.go b/go/arrow/math/uint64_test.go
index 7d060c7e72094..aac768e599cf8 100644
--- a/go/arrow/math/uint64_test.go
+++ b/go/arrow/math/uint64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/math"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/buffer.go b/go/arrow/memory/buffer.go
index 640c538f2e7b3..2ddb3f829c833 100644
--- a/go/arrow/memory/buffer.go
+++ b/go/arrow/memory/buffer.go
@@ -19,7 +19,7 @@ package memory
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Buffer is a wrapper type for a buffer of bytes.
diff --git a/go/arrow/memory/buffer_test.go b/go/arrow/memory/buffer_test.go
index 12490fae1ed9b..25a0b39848519 100644
--- a/go/arrow/memory/buffer_test.go
+++ b/go/arrow/memory/buffer_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/cgo_allocator.go b/go/arrow/memory/cgo_allocator.go
index 291f3196b01b5..85ee445216f6a 100644
--- a/go/arrow/memory/cgo_allocator.go
+++ b/go/arrow/memory/cgo_allocator.go
@@ -22,7 +22,7 @@ package memory
 import (
 	"runtime"
 
-	cga "github.com/apache/arrow/go/v13/arrow/memory/internal/cgoalloc"
+	cga "github.com/apache/arrow/go/v14/arrow/memory/internal/cgoalloc"
 )
 
 // CgoArrowAllocator is an allocator which exposes the C++ memory pool class
diff --git a/go/arrow/memory/default_mallocator.go b/go/arrow/memory/default_mallocator.go
index 3da16dc3c3ee5..12ad0846677b1 100644
--- a/go/arrow/memory/default_mallocator.go
+++ b/go/arrow/memory/default_mallocator.go
@@ -19,7 +19,7 @@
 package memory
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 )
 
 // DefaultAllocator is a default implementation of Allocator and can be used anywhere
diff --git a/go/arrow/memory/default_mallocator_test.go b/go/arrow/memory/default_mallocator_test.go
index 5d0de3afdcbe5..b209ced68a067 100644
--- a/go/arrow/memory/default_mallocator_test.go
+++ b/go/arrow/memory/default_mallocator_test.go
@@ -21,8 +21,8 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/mallocator/mallocator_test.go b/go/arrow/memory/mallocator/mallocator_test.go
index c4753f37a21db..5b09355033f70 100644
--- a/go/arrow/memory/mallocator/mallocator_test.go
+++ b/go/arrow/memory/mallocator/mallocator_test.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/memory_test.go b/go/arrow/memory/memory_test.go
index c1224016a1520..dff2e0bfd0712 100644
--- a/go/arrow/memory/memory_test.go
+++ b/go/arrow/memory/memory_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/record.go b/go/arrow/record.go
index 1d9a1368f46c6..d98c7732ef798 100644
--- a/go/arrow/record.go
+++ b/go/arrow/record.go
@@ -16,7 +16,7 @@
 
 package arrow
 
-import "github.com/apache/arrow/go/v13/internal/json"
+import "github.com/apache/arrow/go/v14/internal/json"
 
 // Record is a collection of equal-length arrays matching a particular Schema.
 // Also known as a RecordBatch in the spec and in some implementations.
diff --git a/go/arrow/scalar/append.go b/go/arrow/scalar/append.go
index 69fe26b418fd7..9bcfe3e22dc63 100644
--- a/go/arrow/scalar/append.go
+++ b/go/arrow/scalar/append.go
@@ -21,11 +21,11 @@ package scalar
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/scalar/append_test.go b/go/arrow/scalar/append_test.go
index 4d36d80617bc5..497a6a2d02933 100644
--- a/go/arrow/scalar/append_test.go
+++ b/go/arrow/scalar/append_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/binary.go b/go/arrow/scalar/binary.go
index 3170e13bea5d9..3c041210fde9c 100644
--- a/go/arrow/scalar/binary.go
+++ b/go/arrow/scalar/binary.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type BinaryScalar interface {
diff --git a/go/arrow/scalar/compare.go b/go/arrow/scalar/compare.go
index baf6fcec066e4..be7fa4d01cc19 100644
--- a/go/arrow/scalar/compare.go
+++ b/go/arrow/scalar/compare.go
@@ -16,7 +16,7 @@
 
 package scalar
 
-import "github.com/apache/arrow/go/v13/arrow"
+import "github.com/apache/arrow/go/v14/arrow"
 
 // Equals returns true if two scalars are equal, which means they have the same
 // datatype, validity and value.
diff --git a/go/arrow/scalar/nested.go b/go/arrow/scalar/nested.go
index 38fe3298e5cb4..87e84210f58a1 100644
--- a/go/arrow/scalar/nested.go
+++ b/go/arrow/scalar/nested.go
@@ -21,10 +21,10 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/numeric.gen.go b/go/arrow/scalar/numeric.gen.go
index 1514cddface21..90ae2a7004ce3 100644
--- a/go/arrow/scalar/numeric.gen.go
+++ b/go/arrow/scalar/numeric.gen.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 )
 
 type Int8 struct {
diff --git a/go/arrow/scalar/numeric.gen_test.go b/go/arrow/scalar/numeric.gen_test.go
index 603a3e56cde10..987cd66c75f3c 100644
--- a/go/arrow/scalar/numeric.gen_test.go
+++ b/go/arrow/scalar/numeric.gen_test.go
@@ -21,8 +21,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/numeric.gen_test.go.tmpl b/go/arrow/scalar/numeric.gen_test.go.tmpl
index 54ec4e1f2b480..c975cc9db6e1c 100644
--- a/go/arrow/scalar/numeric.gen_test.go.tmpl
+++ b/go/arrow/scalar/numeric.gen_test.go.tmpl
@@ -19,8 +19,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/parse.go b/go/arrow/scalar/parse.go
index 2051c54b397d0..fcffe1ea6adf8 100644
--- a/go/arrow/scalar/parse.go
+++ b/go/arrow/scalar/parse.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type TypeToScalar interface {
diff --git a/go/arrow/scalar/scalar.go b/go/arrow/scalar/scalar.go
index cf629de93eacf..395771fa89c94 100644
--- a/go/arrow/scalar/scalar.go
+++ b/go/arrow/scalar/scalar.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/encoded"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/float16"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/scalar_test.go b/go/arrow/scalar/scalar_test.go
index 6d46383261bbd..405571a14880d 100644
--- a/go/arrow/scalar/scalar_test.go
+++ b/go/arrow/scalar/scalar_test.go
@@ -25,12 +25,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/temporal.go b/go/arrow/scalar/temporal.go
index bd2b493dc2386..880416f7dd5a3 100644
--- a/go/arrow/scalar/temporal.go
+++ b/go/arrow/scalar/temporal.go
@@ -22,7 +22,7 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func temporalToString(s TemporalScalar) string {
diff --git a/go/arrow/schema.go b/go/arrow/schema.go
index 4aef961a0d04a..a7fa434131925 100644
--- a/go/arrow/schema.go
+++ b/go/arrow/schema.go
@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 type Metadata struct {
diff --git a/go/arrow/schema_test.go b/go/arrow/schema_test.go
index 481bba387a308..5e79723f90352 100644
--- a/go/arrow/schema_test.go
+++ b/go/arrow/schema_test.go
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/table.go b/go/arrow/table.go
index f4a6d18840c8a..5a68085f8df93 100644
--- a/go/arrow/table.go
+++ b/go/arrow/table.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Table represents a logical sequence of chunked arrays of equal length. It is
diff --git a/go/arrow/tensor/numeric.gen.go b/go/arrow/tensor/numeric.gen.go
index 7d42c1eccd835..5b7bbde150fe2 100644
--- a/go/arrow/tensor/numeric.gen.go
+++ b/go/arrow/tensor/numeric.gen.go
@@ -19,7 +19,7 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Int8 is an n-dim array of int8s.
diff --git a/go/arrow/tensor/numeric.gen.go.tmpl b/go/arrow/tensor/numeric.gen.go.tmpl
index 00958c1db6c32..c693082192247 100644
--- a/go/arrow/tensor/numeric.gen.go.tmpl
+++ b/go/arrow/tensor/numeric.gen.go.tmpl
@@ -17,8 +17,8 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/numeric.gen_test.go b/go/arrow/tensor/numeric.gen_test.go
index 1ebf8abc486fd..00922a84b6b03 100644
--- a/go/arrow/tensor/numeric.gen_test.go
+++ b/go/arrow/tensor/numeric.gen_test.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 func TestTensorInt8(t *testing.T) {
diff --git a/go/arrow/tensor/numeric.gen_test.go.tmpl b/go/arrow/tensor/numeric.gen_test.go.tmpl
index ea9339594def0..665bb8dc68da9 100644
--- a/go/arrow/tensor/numeric.gen_test.go.tmpl
+++ b/go/arrow/tensor/numeric.gen_test.go.tmpl
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/tensor.go b/go/arrow/tensor/tensor.go
index 436842588d3a6..27c380345a498 100644
--- a/go/arrow/tensor/tensor.go
+++ b/go/arrow/tensor/tensor.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Interface represents an n-dimensional array of numerical data.
diff --git a/go/arrow/tensor/tensor_test.go b/go/arrow/tensor/tensor_test.go
index 9b626e5197585..4cfe69f780421 100644
--- a/go/arrow/tensor/tensor_test.go
+++ b/go/arrow/tensor/tensor_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 func TestTensor(t *testing.T) {
diff --git a/go/arrow/type_traits_boolean.go b/go/arrow/type_traits_boolean.go
index f1f9caf9f600a..6a46bdec702ff 100644
--- a/go/arrow/type_traits_boolean.go
+++ b/go/arrow/type_traits_boolean.go
@@ -17,7 +17,7 @@
 package arrow
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 type booleanTraits struct{}
diff --git a/go/arrow/type_traits_decimal128.go b/go/arrow/type_traits_decimal128.go
index dbe88ae007624..d2d3aae371663 100644
--- a/go/arrow/type_traits_decimal128.go
+++ b/go/arrow/type_traits_decimal128.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 // Decimal128 traits
diff --git a/go/arrow/type_traits_decimal256.go b/go/arrow/type_traits_decimal256.go
index e2b35a7df22ec..256ed68fffc8d 100644
--- a/go/arrow/type_traits_decimal256.go
+++ b/go/arrow/type_traits_decimal256.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 // Decimal256 traits
diff --git a/go/arrow/type_traits_float16.go b/go/arrow/type_traits_float16.go
index cb7afc2e0c25b..c40363d3785da 100644
--- a/go/arrow/type_traits_float16.go
+++ b/go/arrow/type_traits_float16.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 )
 
 // Float16 traits
diff --git a/go/arrow/type_traits_interval.go b/go/arrow/type_traits_interval.go
index aff39effe5c1b..35e6057090f10 100644
--- a/go/arrow/type_traits_interval.go
+++ b/go/arrow/type_traits_interval.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go b/go/arrow/type_traits_numeric.gen.go
index 3330e2616bbe7..6edd75291155c 100644
--- a/go/arrow/type_traits_numeric.gen.go
+++ b/go/arrow/type_traits_numeric.gen.go
@@ -23,7 +23,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go.tmpl b/go/arrow/type_traits_numeric.gen.go.tmpl
index b2af18579af93..ffae975c1aa15 100644
--- a/go/arrow/type_traits_numeric.gen.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen.go.tmpl
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen_test.go b/go/arrow/type_traits_numeric.gen_test.go
index abcc2aca928fa..74395485736ff 100644
--- a/go/arrow/type_traits_numeric.gen_test.go
+++ b/go/arrow/type_traits_numeric.gen_test.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestInt64Traits(t *testing.T) {
diff --git a/go/arrow/type_traits_numeric.gen_test.go.tmpl b/go/arrow/type_traits_numeric.gen_test.go.tmpl
index 5f963dff138de..96685f31327bd 100644
--- a/go/arrow/type_traits_numeric.gen_test.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen_test.go.tmpl
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 {{- range .In}}
diff --git a/go/arrow/type_traits_test.go b/go/arrow/type_traits_test.go
index a54d2d7c696c4..85ad4da9d041d 100644
--- a/go/arrow/type_traits_test.go
+++ b/go/arrow/type_traits_test.go
@@ -22,10 +22,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/decimal256"
-	"github.com/apache/arrow/go/v13/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 )
 
 func TestBooleanTraits(t *testing.T) {
diff --git a/go/arrow/type_traits_timestamp.go b/go/arrow/type_traits_timestamp.go
index e39867309c06b..7c393b3559f82 100644
--- a/go/arrow/type_traits_timestamp.go
+++ b/go/arrow/type_traits_timestamp.go
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var TimestampTraits timestampTraits
diff --git a/go/arrow/util/byte_size.go b/go/arrow/util/byte_size.go
index 2c3c0de44618e..141b78c459119 100644
--- a/go/arrow/util/byte_size.go
+++ b/go/arrow/util/byte_size.go
@@ -17,9 +17,9 @@
 package util
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func isArrayDataNil(arrayData arrow.ArrayData) bool {
diff --git a/go/arrow/util/byte_size_test.go b/go/arrow/util/byte_size_test.go
index 0c7aebe294a93..052bf3adee158 100644
--- a/go/arrow/util/byte_size_test.go
+++ b/go/arrow/util/byte_size_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/arrow/util"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/util"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/go.mod b/go/go.mod
index 9dd89db8aa404..46c093ed1ece2 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -14,7 +14,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-module github.com/apache/arrow/go/v13
+module github.com/apache/arrow/go/v14
 
 go 1.20
 
diff --git a/go/internal/bitutils/bit_block_counter.go b/go/internal/bitutils/bit_block_counter.go
index 76d9b89942275..86818bfd45ab7 100644
--- a/go/internal/bitutils/bit_block_counter.go
+++ b/go/internal/bitutils/bit_block_counter.go
@@ -21,8 +21,8 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 func loadWord(byt []byte) uint64 {
diff --git a/go/internal/bitutils/bit_block_counter_test.go b/go/internal/bitutils/bit_block_counter_test.go
index 96ad2a655f0fa..ad5e989d1fa65 100644
--- a/go/internal/bitutils/bit_block_counter_test.go
+++ b/go/internal/bitutils/bit_block_counter_test.go
@@ -19,9 +19,9 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/rand"
 )
diff --git a/go/internal/bitutils/bit_run_reader.go b/go/internal/bitutils/bit_run_reader.go
index 00a174b96ea61..a1686a4909b8b 100644
--- a/go/internal/bitutils/bit_run_reader.go
+++ b/go/internal/bitutils/bit_run_reader.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // BitRun represents a run of bits with the same value of length Len
diff --git a/go/internal/bitutils/bit_run_reader_test.go b/go/internal/bitutils/bit_run_reader_test.go
index 6d93bdecba9e8..0e1500bff811a 100644
--- a/go/internal/bitutils/bit_run_reader_test.go
+++ b/go/internal/bitutils/bit_run_reader_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/internal/bitutils/bit_set_run_reader.go b/go/internal/bitutils/bit_set_run_reader.go
index 8f7c66ac7d86a..a2269ffecb870 100644
--- a/go/internal/bitutils/bit_set_run_reader.go
+++ b/go/internal/bitutils/bit_set_run_reader.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // IsMultipleOf64 returns whether v is a multiple of 64.
diff --git a/go/internal/bitutils/bit_set_run_reader_test.go b/go/internal/bitutils/bit_set_run_reader_test.go
index bfc56610b2795..205954b3800a8 100644
--- a/go/internal/bitutils/bit_set_run_reader_test.go
+++ b/go/internal/bitutils/bit_set_run_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/internal/bitutils/bitmap_generate.go b/go/internal/bitutils/bitmap_generate.go
index 648ebd4db53ae..78219d8120bcc 100644
--- a/go/internal/bitutils/bitmap_generate.go
+++ b/go/internal/bitutils/bitmap_generate.go
@@ -16,7 +16,7 @@
 
 package bitutils
 
-import "github.com/apache/arrow/go/v13/arrow/bitutil"
+import "github.com/apache/arrow/go/v14/arrow/bitutil"
 
 // GenerateBits writes sequential bits to a bitmap. Bits preceding the
 // initial start offset are preserved, bits following the bitmap may
diff --git a/go/internal/bitutils/bitmap_generate_test.go b/go/internal/bitutils/bitmap_generate_test.go
index f3bb4aa3992a1..788b2198c3a78 100644
--- a/go/internal/bitutils/bitmap_generate_test.go
+++ b/go/internal/bitutils/bitmap_generate_test.go
@@ -19,7 +19,7 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go b/go/internal/hashing/xxh3_memo_table.gen.go
index f561c5f30f895..cc996552b49e5 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go
+++ b/go/internal/hashing/xxh3_memo_table.gen.go
@@ -21,9 +21,9 @@ package hashing
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 type payloadInt8 struct {
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
index 10127c43cc6b1..25164341d227e 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
+++ b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
@@ -17,8 +17,8 @@
 package hashing
 
 import (
-  "github.com/apache/arrow/go/v13/arrow/bitutil"  
-  "github.com/apache/arrow/go/v13/internal/utils"  
+  "github.com/apache/arrow/go/v14/arrow/bitutil"  
+  "github.com/apache/arrow/go/v14/internal/utils"  
 )
 
 {{range .In}}
diff --git a/go/internal/types/extension_types.go b/go/internal/types/extension_types.go
index ee7349523404e..1a31014874bbe 100644
--- a/go/internal/types/extension_types.go
+++ b/go/internal/types/extension_types.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/google/uuid"
 	"golang.org/x/xerrors"
 )
diff --git a/go/internal/types/extension_types_test.go b/go/internal/types/extension_types_test.go
index 9d89c9aa7d05c..16273890b4c9c 100644
--- a/go/internal/types/extension_types_test.go
+++ b/go/internal/types/extension_types_test.go
@@ -20,11 +20,11 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/internal/utils/transpose_ints_def.go b/go/internal/utils/transpose_ints_def.go
index ef3b06de14b23..cc3b0abb59363 100644
--- a/go/internal/utils/transpose_ints_def.go
+++ b/go/internal/utils/transpose_ints_def.go
@@ -19,7 +19,7 @@ package utils
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl -i -data=transpose_ints.tmpldata -d arch=avx2 transpose_ints_simd.go.tmpl=transpose_ints_avx2_amd64.go
diff --git a/go/internal/utils/transpose_ints_test.go b/go/internal/utils/transpose_ints_test.go
index 5b54e21310464..e41b61156abdc 100644
--- a/go/internal/utils/transpose_ints_test.go
+++ b/go/internal/utils/transpose_ints_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 var (
diff --git a/go/parquet/cmd/parquet_reader/dumper.go b/go/parquet/cmd/parquet_reader/dumper.go
index be6094ee977c9..a04dcf23b2d8d 100644
--- a/go/parquet/cmd/parquet_reader/dumper.go
+++ b/go/parquet/cmd/parquet_reader/dumper.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 const defaultBatchSize = 128
diff --git a/go/parquet/cmd/parquet_reader/main.go b/go/parquet/cmd/parquet_reader/main.go
index d0d99f35af0ee..e7d1cd7fc5a7d 100644
--- a/go/parquet/cmd/parquet_reader/main.go
+++ b/go/parquet/cmd/parquet_reader/main.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 
 	"github.com/docopt/docopt-go"
 )
diff --git a/go/parquet/cmd/parquet_schema/main.go b/go/parquet/cmd/parquet_schema/main.go
index c4ec13d367352..28d1288b54aeb 100644
--- a/go/parquet/cmd/parquet_schema/main.go
+++ b/go/parquet/cmd/parquet_schema/main.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/docopt/docopt-go"
 )
 
diff --git a/go/parquet/compress/brotli.go b/go/parquet/compress/brotli.go
index b74eaf8e6623b..1c1ae1dffaca5 100644
--- a/go/parquet/compress/brotli.go
+++ b/go/parquet/compress/brotli.go
@@ -21,7 +21,7 @@ import (
 	"io"
 
 	"github.com/andybalholm/brotli"
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 )
 
 type brotliCodec struct{}
diff --git a/go/parquet/compress/compress.go b/go/parquet/compress/compress.go
index 21c233846881b..4c4c792c2f614 100644
--- a/go/parquet/compress/compress.go
+++ b/go/parquet/compress/compress.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Compression is an alias to the thrift compression codec enum type for easy use
diff --git a/go/parquet/compress/compress_test.go b/go/parquet/compress/compress_test.go
index 359c31e323795..e8041a64c0996 100644
--- a/go/parquet/compress/compress_test.go
+++ b/go/parquet/compress/compress_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/compress/zstd.go b/go/parquet/compress/zstd.go
index 8de87c7a0d276..129af62807175 100644
--- a/go/parquet/compress/zstd.go
+++ b/go/parquet/compress/zstd.go
@@ -20,7 +20,7 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 	"github.com/klauspost/compress/zstd"
 )
 
diff --git a/go/parquet/doc.go b/go/parquet/doc.go
index 8a0a747602656..99a605a284fae 100644
--- a/go/parquet/doc.go
+++ b/go/parquet/doc.go
@@ -29,9 +29,9 @@
 // Install
 //
 // You can download the library and cli utilities via:
-//   go get -u github.com/apache/arrow/go/v13/parquet
-//   go install github.com/apache/arrow/go/v13/parquet/cmd/parquet_reader@latest
-//   go install github.com/apache/arrow/go/v13/parquet/cmd/parquet_schema@latest
+//   go get -u github.com/apache/arrow/go/v14/parquet
+//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_reader@latest
+//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_schema@latest
 //
 // Modules
 //
diff --git a/go/parquet/encryption_properties.go b/go/parquet/encryption_properties.go
index 3468be14d0dfc..dd85a856820fe 100644
--- a/go/parquet/encryption_properties.go
+++ b/go/parquet/encryption_properties.go
@@ -20,7 +20,7 @@ import (
 	"crypto/rand"
 	"unicode/utf8"
 
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Constants that will be used as the default values with encryption/decryption
diff --git a/go/parquet/encryption_properties_test.go b/go/parquet/encryption_properties_test.go
index 606c4a7676d90..0b1118a5cfa66 100644
--- a/go/parquet/encryption_properties_test.go
+++ b/go/parquet/encryption_properties_test.go
@@ -19,8 +19,8 @@ package parquet_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/encryption_read_config_test.go b/go/parquet/encryption_read_config_test.go
index 220a17d1d90e6..8a84c19900dd0 100644
--- a/go/parquet/encryption_read_config_test.go
+++ b/go/parquet/encryption_read_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/encryption_write_config_test.go b/go/parquet/encryption_write_config_test.go
index e88a901fe893a..6b2d049e1390c 100644
--- a/go/parquet/encryption_write_config_test.go
+++ b/go/parquet/encryption_write_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/file/column_reader.go b/go/parquet/file/column_reader.go
index 9a36bf54b5cf5..1ebceaca234c1 100644
--- a/go/parquet/file/column_reader.go
+++ b/go/parquet/file/column_reader.go
@@ -20,13 +20,13 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_reader_test.go b/go/parquet/file/column_reader_test.go
index 8568f16ef0791..3ce05c6cfe47e 100755
--- a/go/parquet/file/column_reader_test.go
+++ b/go/parquet/file/column_reader_test.go
@@ -24,12 +24,12 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/file/column_reader_types.gen.go b/go/parquet/file/column_reader_types.gen.go
index 3f9a5384aa6d0..31dccc157642f 100644
--- a/go/parquet/file/column_reader_types.gen.go
+++ b/go/parquet/file/column_reader_types.gen.go
@@ -21,9 +21,9 @@ package file
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 // Int32ColumnChunkReader is the Typed Column chunk reader instance for reading
diff --git a/go/parquet/file/column_reader_types.gen.go.tmpl b/go/parquet/file/column_reader_types.gen.go.tmpl
index 3520c2ae8d952..6557963e69f50 100644
--- a/go/parquet/file/column_reader_types.gen.go.tmpl
+++ b/go/parquet/file/column_reader_types.gen.go.tmpl
@@ -17,8 +17,8 @@
 package file
 
 import (
-    "github.com/apache/arrow/go/v13/parquet"
-    "github.com/apache/arrow/go/v13/parquet/internal/encoding"
+    "github.com/apache/arrow/go/v14/parquet"
+    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/column_writer.go b/go/parquet/file/column_writer.go
index 7dca48d4783b9..9d9111042df28 100755
--- a/go/parquet/file/column_writer.go
+++ b/go/parquet/file/column_writer.go
@@ -21,14 +21,14 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata column_writer_types.gen.go.tmpl
diff --git a/go/parquet/file/column_writer_test.go b/go/parquet/file/column_writer_test.go
index a2a0e64826938..e2ae6b0f4a71e 100755
--- a/go/parquet/file/column_writer_test.go
+++ b/go/parquet/file/column_writer_test.go
@@ -24,19 +24,19 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	arrutils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	arrutils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/column_writer_types.gen.go b/go/parquet/file/column_writer_types.gen.go
index 02563230b1767..5594f63249fb8 100644
--- a/go/parquet/file/column_writer_types.gen.go
+++ b/go/parquet/file/column_writer_types.gen.go
@@ -22,12 +22,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_writer_types.gen.go.tmpl b/go/parquet/file/column_writer_types.gen.go.tmpl
index 77be3105cf506..c00e1dabb5fe6 100644
--- a/go/parquet/file/column_writer_types.gen.go.tmpl
+++ b/go/parquet/file/column_writer_types.gen.go.tmpl
@@ -19,10 +19,10 @@ package file
 import (
     "fmt"
     
-    "github.com/apache/arrow/go/v13/parquet"
-    "github.com/apache/arrow/go/v13/parquet/metadata"
-    "github.com/apache/arrow/go/v13/parquet/internal/encoding"
-    format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+    "github.com/apache/arrow/go/v14/parquet"
+    "github.com/apache/arrow/go/v14/parquet/metadata"
+    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+    format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/file_reader.go b/go/parquet/file/file_reader.go
index 7243837f06ee6..5481d5c7738b0 100644
--- a/go/parquet/file/file_reader.go
+++ b/go/parquet/file/file_reader.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/file_reader_mmap.go b/go/parquet/file/file_reader_mmap.go
index b7f26b50d444b..89c5a84cee2e1 100644
--- a/go/parquet/file/file_reader_mmap.go
+++ b/go/parquet/file/file_reader_mmap.go
@@ -22,7 +22,7 @@ package file
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/exp/mmap"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/file_reader_mmap_windows.go b/go/parquet/file/file_reader_mmap_windows.go
index 9d239727726e6..6b08422163fd1 100644
--- a/go/parquet/file/file_reader_mmap_windows.go
+++ b/go/parquet/file/file_reader_mmap_windows.go
@@ -22,7 +22,7 @@ package file
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 func mmapOpen(filename string) (parquet.ReaderAtSeeker, error) {
diff --git a/go/parquet/file/file_reader_test.go b/go/parquet/file/file_reader_test.go
index fa5a51cb5b8d5..eccb572b30040 100644
--- a/go/parquet/file/file_reader_test.go
+++ b/go/parquet/file/file_reader_test.go
@@ -23,16 +23,16 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index cd0445f4180f1..64a21473c293a 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 // Writer is the primary interface for writing a parquet file
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index 2cbdb910724ad..0cca1cd40d4c9 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -22,13 +22,13 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/file/level_conversion.go b/go/parquet/file/level_conversion.go
index 9d4862b5e1083..ac53dcd18abae 100755
--- a/go/parquet/file/level_conversion.go
+++ b/go/parquet/file/level_conversion.go
@@ -22,11 +22,11 @@ import (
 	"math/bits"
 	"unsafe"
 
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/level_conversion_test.go b/go/parquet/file/level_conversion_test.go
index 0ebd755964a1b..343edb687980d 100644
--- a/go/parquet/file/level_conversion_test.go
+++ b/go/parquet/file/level_conversion_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/file/page_reader.go b/go/parquet/file/page_reader.go
index 6e7fc735d53f8..ab8679b127f1b 100644
--- a/go/parquet/file/page_reader.go
+++ b/go/parquet/file/page_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/page_writer.go b/go/parquet/file/page_writer.go
index 10f0da48f6a91..b2b6d5061b0fc 100644
--- a/go/parquet/file/page_writer.go
+++ b/go/parquet/file/page_writer.go
@@ -20,15 +20,15 @@ import (
 	"bytes"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/record_reader.go b/go/parquet/file/record_reader.go
index e016a62dd7fc7..3311a6d77da39 100755
--- a/go/parquet/file/record_reader.go
+++ b/go/parquet/file/record_reader.go
@@ -23,14 +23,14 @@ import (
 	"unsafe"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_reader.go b/go/parquet/file/row_group_reader.go
index 7ae988680c8c3..f1aebf1085a23 100644
--- a/go/parquet/file/row_group_reader.go
+++ b/go/parquet/file/row_group_reader.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer.go b/go/parquet/file/row_group_writer.go
index 410f48b477a7c..75f0dede5246f 100644
--- a/go/parquet/file/row_group_writer.go
+++ b/go/parquet/file/row_group_writer.go
@@ -17,10 +17,10 @@
 package file
 
 import (
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer_test.go b/go/parquet/file/row_group_writer_test.go
index 35d6f5e804dfc..bc95e99d91582 100644
--- a/go/parquet/file/row_group_writer_test.go
+++ b/go/parquet/file/row_group_writer_test.go
@@ -20,10 +20,10 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/parquet/internal/encoding/boolean_decoder.go b/go/parquet/internal/encoding/boolean_decoder.go
index 582321472bdd5..dd213395d6324 100644
--- a/go/parquet/internal/encoding/boolean_decoder.go
+++ b/go/parquet/internal/encoding/boolean_decoder.go
@@ -17,10 +17,10 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/boolean_encoder.go b/go/parquet/internal/encoding/boolean_encoder.go
index adbf1e8b42937..65ba2658b0637 100644
--- a/go/parquet/internal/encoding/boolean_encoder.go
+++ b/go/parquet/internal/encoding/boolean_encoder.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/byte_array_decoder.go b/go/parquet/internal/encoding/byte_array_decoder.go
index 366e32800662d..c3ca1de5888f7 100644
--- a/go/parquet/internal/encoding/byte_array_decoder.go
+++ b/go/parquet/internal/encoding/byte_array_decoder.go
@@ -19,12 +19,12 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	pqutils "github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	pqutils "github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/byte_array_encoder.go b/go/parquet/internal/encoding/byte_array_encoder.go
index d18ce69a20043..cb49178435a6f 100644
--- a/go/parquet/internal/encoding/byte_array_encoder.go
+++ b/go/parquet/internal/encoding/byte_array_encoder.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // PlainByteArrayEncoder encodes byte arrays according to the spec for Plain encoding
diff --git a/go/parquet/internal/encoding/decoder.go b/go/parquet/internal/encoding/decoder.go
index ed105b68b7b44..b441868e1df85 100644
--- a/go/parquet/internal/encoding/decoder.go
+++ b/go/parquet/internal/encoding/decoder.go
@@ -20,16 +20,16 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index d3271506734b7..5b246f4591657 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -22,11 +22,11 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_byte_array.go b/go/parquet/internal/encoding/delta_byte_array.go
index b6ce25fec647f..60a20a3ff0d72 100644
--- a/go/parquet/internal/encoding/delta_byte_array.go
+++ b/go/parquet/internal/encoding/delta_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_byte_array_test.go b/go/parquet/internal/encoding/delta_byte_array_test.go
index 1c008505252fb..69c632bf69971 100644
--- a/go/parquet/internal/encoding/delta_byte_array_test.go
+++ b/go/parquet/internal/encoding/delta_byte_array_test.go
@@ -18,8 +18,8 @@ package encoding
 
 import (
 	"fmt"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
diff --git a/go/parquet/internal/encoding/delta_length_byte_array.go b/go/parquet/internal/encoding/delta_length_byte_array.go
index d719dcf829cbd..981a067b07e08 100644
--- a/go/parquet/internal/encoding/delta_length_byte_array.go
+++ b/go/parquet/internal/encoding/delta_length_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/encoder.go b/go/parquet/internal/encoding/encoder.go
index 5a0b2e97550d2..9626e4e9ff97f 100644
--- a/go/parquet/internal/encoding/encoder.go
+++ b/go/parquet/internal/encoding/encoder.go
@@ -21,14 +21,14 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata plain_encoder_types.gen.go.tmpl typed_encoder.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/encoding_benchmarks_test.go b/go/parquet/internal/encoding/encoding_benchmarks_test.go
index 59ad029632fb5..0bb4e895f316d 100644
--- a/go/parquet/internal/encoding/encoding_benchmarks_test.go
+++ b/go/parquet/internal/encoding/encoding_benchmarks_test.go
@@ -21,14 +21,14 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/hashing"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index f82d9d75d392e..65b085d0ea167 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -26,13 +26,13 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
index f68f41acf16d0..e4516bf4a1ac1 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
@@ -19,8 +19,8 @@ package encoding
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
index 463941d959a50..b5aee337d5bf0 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
@@ -19,9 +19,9 @@ package encoding
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // PlainFixedLenByteArrayEncoder writes the raw bytes of the byte array
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index d6a47f3366f66..c5622519b0ce4 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/levels_test.go b/go/parquet/internal/encoding/levels_test.go
index 106b262a37b33..ae3a3a8c497fc 100644
--- a/go/parquet/internal/encoding/levels_test.go
+++ b/go/parquet/internal/encoding/levels_test.go
@@ -21,11 +21,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table.go b/go/parquet/internal/encoding/memo_table.go
index 6a2580f16e907..170eab47d6160 100644
--- a/go/parquet/internal/encoding/memo_table.go
+++ b/go/parquet/internal/encoding/memo_table.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/hashing"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata memo_table_types.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/memo_table_test.go b/go/parquet/internal/encoding/memo_table_test.go
index 5fa79840d3661..1eb61cb2559a3 100644
--- a/go/parquet/internal/encoding/memo_table_test.go
+++ b/go/parquet/internal/encoding/memo_table_test.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/hashing"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go b/go/parquet/internal/encoding/memo_table_types.gen.go
index 67dc32a1e1488..c9af6178bbb98 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go
@@ -19,8 +19,8 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
index 6bdca97c9e490..7e88238d67b71 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
@@ -17,7 +17,7 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v13/parquet"
+  "github.com/apache/arrow/go/v14/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go b/go/parquet/internal/encoding/plain_encoder_types.gen.go
index 44963ea83cfc4..23db13b7a4121 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go
@@ -24,11 +24,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
index d1fc651081d05..e45419050302d 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
@@ -20,10 +20,10 @@ import (
   "encoding/binary"
   "fmt"
 
-  "github.com/apache/arrow/go/v13/arrow"
-  "github.com/apache/arrow/go/v13/parquet"
-  "github.com/apache/arrow/go/v13/internal/utils"
-  "github.com/apache/arrow/go/v13/internal/bitutils"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 var (
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go b/go/parquet/internal/encoding/typed_encoder.gen.go
index 6adbc69f44c69..7c1f954632f06 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go
@@ -22,15 +22,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
index a4b352908c072..f0d4fb50ae2fc 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
@@ -17,13 +17,13 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v13/parquet"
-  "github.com/apache/arrow/go/v13/parquet/schema"
-  format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-  "github.com/apache/arrow/go/v13/arrow"
-  "github.com/apache/arrow/go/v13/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-  "github.com/apache/arrow/go/v13/internal/bitutils"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/parquet/schema"
+  format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 // fully typed encoder interfaces to enable writing against encoder/decoders
diff --git a/go/parquet/internal/encoding/types.go b/go/parquet/internal/encoding/types.go
index fda5c8a76f5c2..2d13a9c8f877a 100644
--- a/go/parquet/internal/encoding/types.go
+++ b/go/parquet/internal/encoding/types.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encryption/aes.go b/go/parquet/internal/encryption/aes.go
index 02d909df26bf1..cc0cea0112fee 100644
--- a/go/parquet/internal/encryption/aes.go
+++ b/go/parquet/internal/encryption/aes.go
@@ -29,7 +29,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // important constants for handling the aes encryption
diff --git a/go/parquet/internal/encryption/decryptor.go b/go/parquet/internal/encryption/decryptor.go
index 11a28d9115f25..62a4f2ee9e56e 100644
--- a/go/parquet/internal/encryption/decryptor.go
+++ b/go/parquet/internal/encryption/decryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // FileDecryptor is an interface used by the filereader for decrypting an
diff --git a/go/parquet/internal/encryption/encryptor.go b/go/parquet/internal/encryption/encryptor.go
index 762fcbe9b726c..2ef09e558a23f 100644
--- a/go/parquet/internal/encryption/encryptor.go
+++ b/go/parquet/internal/encryption/encryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // FileEncryptor is the interface for constructing encryptors for the different
diff --git a/go/parquet/internal/testutils/pagebuilder.go b/go/parquet/internal/testutils/pagebuilder.go
index c4753c263dd72..9c1fd72a1bdf0 100644
--- a/go/parquet/internal/testutils/pagebuilder.go
+++ b/go/parquet/internal/testutils/pagebuilder.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/mock"
 )
 
diff --git a/go/parquet/internal/testutils/primitive_typed.go b/go/parquet/internal/testutils/primitive_typed.go
index c5c44cb61390c..2bd0a29dd2970 100644
--- a/go/parquet/internal/testutils/primitive_typed.go
+++ b/go/parquet/internal/testutils/primitive_typed.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 type PrimitiveTypedTest struct {
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index 2fe4c94de595e..2c8a2809dc784 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -24,13 +24,13 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/endian"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
diff --git a/go/parquet/internal/testutils/random_arrow.go b/go/parquet/internal/testutils/random_arrow.go
index 10ba60faa67c8..360b8e7476430 100644
--- a/go/parquet/internal/testutils/random_arrow.go
+++ b/go/parquet/internal/testutils/random_arrow.go
@@ -17,9 +17,9 @@
 package testutils
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/parquet/internal/testutils/utils.go b/go/parquet/internal/testutils/utils.go
index e8e19860dbf6f..1122f4286f386 100644
--- a/go/parquet/internal/testutils/utils.go
+++ b/go/parquet/internal/testutils/utils.go
@@ -19,7 +19,7 @@ package testutils
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 var typeToParquetTypeMap = map[reflect.Type]parquet.Type{
diff --git a/go/parquet/internal/thrift/helpers.go b/go/parquet/internal/thrift/helpers.go
index af1d4653a293e..357d9020989d3 100644
--- a/go/parquet/internal/thrift/helpers.go
+++ b/go/parquet/internal/thrift/helpers.go
@@ -23,7 +23,7 @@ import (
 	"context"
 	"io"
 
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/apache/thrift/lib/go/thrift"
 )
 
diff --git a/go/parquet/internal/utils/bit_benchmark_test.go b/go/parquet/internal/utils/bit_benchmark_test.go
index 3f3507ae8305a..2518e48a4baa8 100644
--- a/go/parquet/internal/utils/bit_benchmark_test.go
+++ b/go/parquet/internal/utils/bit_benchmark_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
 )
 
 type linearBitRunReader struct {
diff --git a/go/parquet/internal/utils/bit_reader.go b/go/parquet/internal/utils/bit_reader.go
index 27a1badb3a8c0..cf61395c0b16c 100644
--- a/go/parquet/internal/utils/bit_reader.go
+++ b/go/parquet/internal/utils/bit_reader.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // masks for grabbing the trailing bits based on the number of trailing bits desired
diff --git a/go/parquet/internal/utils/bit_reader_test.go b/go/parquet/internal/utils/bit_reader_test.go
index c753780a1a55f..317cc4960afe2 100644
--- a/go/parquet/internal/utils/bit_reader_test.go
+++ b/go/parquet/internal/utils/bit_reader_test.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"golang.org/x/exp/rand"
diff --git a/go/parquet/internal/utils/bit_writer.go b/go/parquet/internal/utils/bit_writer.go
index 837a85d5541a0..99a1db065590d 100644
--- a/go/parquet/internal/utils/bit_writer.go
+++ b/go/parquet/internal/utils/bit_writer.go
@@ -21,7 +21,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 // WriterAtBuffer is a convenience struct for providing a WriteAt function
diff --git a/go/parquet/internal/utils/bitmap_writer.go b/go/parquet/internal/utils/bitmap_writer.go
index 629be64bf25a6..447222139b773 100644
--- a/go/parquet/internal/utils/bitmap_writer.go
+++ b/go/parquet/internal/utils/bitmap_writer.go
@@ -20,7 +20,7 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 // BitmapWriter is an interface for bitmap writers so that we can use multiple
diff --git a/go/parquet/internal/utils/bitmap_writer_test.go b/go/parquet/internal/utils/bitmap_writer_test.go
index e2f94ffa85a3c..9f38f1ef291ea 100644
--- a/go/parquet/internal/utils/bitmap_writer_test.go
+++ b/go/parquet/internal/utils/bitmap_writer_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index bcb69fa8583cf..866d7c61b4099 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -24,10 +24,10 @@ import (
 	"encoding/binary"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go b/go/parquet/internal/utils/typed_rle_dict.gen.go
index c1a7e42756bcc..dff22711b120f 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go
@@ -19,9 +19,9 @@
 package utils
 
 import (
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
index bc1d2cc305712..090275745ff59 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
@@ -17,9 +17,9 @@
 package utils
 
 import (
-  "github.com/apache/arrow/go/v13/parquet"
-  "github.com/apache/arrow/go/v13/internal/bitutils"
-  "github.com/apache/arrow/go/v13/internal/utils"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v14/internal/utils"
 )
 
 {{range .In}}
diff --git a/go/parquet/metadata/app_version.go b/go/parquet/metadata/app_version.go
index bf57e77931e09..85ace57365bd3 100644
--- a/go/parquet/metadata/app_version.go
+++ b/go/parquet/metadata/app_version.go
@@ -21,8 +21,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 var (
diff --git a/go/parquet/metadata/column_chunk.go b/go/parquet/metadata/column_chunk.go
index b46646ebb7228..e6ea6ff1ea183 100644
--- a/go/parquet/metadata/column_chunk.go
+++ b/go/parquet/metadata/column_chunk.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/file.go b/go/parquet/metadata/file.go
index e1644b1d8f6f5..efe3c01c25b33 100644
--- a/go/parquet/metadata/file.go
+++ b/go/parquet/metadata/file.go
@@ -24,12 +24,12 @@ import (
 	"reflect"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/metadata_test.go b/go/parquet/metadata/metadata_test.go
index 55f91e0ec6d8a..0db64d88ab0f4 100644
--- a/go/parquet/metadata/metadata_test.go
+++ b/go/parquet/metadata/metadata_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/row_group.go b/go/parquet/metadata/row_group.go
index 4aa8e49e11499..16af67241e959 100644
--- a/go/parquet/metadata/row_group.go
+++ b/go/parquet/metadata/row_group.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 // RowGroupMetaData is a proxy around the thrift RowGroup meta data object
diff --git a/go/parquet/metadata/stat_compare_test.go b/go/parquet/metadata/stat_compare_test.go
index af7e2bd239d98..d02123cbef039 100644
--- a/go/parquet/metadata/stat_compare_test.go
+++ b/go/parquet/metadata/stat_compare_test.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/statistics.go b/go/parquet/metadata/statistics.go
index 11ec0b6207fd3..245b06a7348c4 100644
--- a/go/parquet/metadata/statistics.go
+++ b/go/parquet/metadata/statistics.go
@@ -22,14 +22,14 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata statistics_types.gen.go.tmpl
diff --git a/go/parquet/metadata/statistics_test.go b/go/parquet/metadata/statistics_test.go
index bda7210eb12ff..35d8b7821c51a 100644
--- a/go/parquet/metadata/statistics_test.go
+++ b/go/parquet/metadata/statistics_test.go
@@ -21,11 +21,11 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go b/go/parquet/metadata/statistics_types.gen.go
index 297c67c265431..e6aa7f1801a0f 100644
--- a/go/parquet/metadata/statistics_types.gen.go
+++ b/go/parquet/metadata/statistics_types.gen.go
@@ -22,14 +22,14 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go.tmpl b/go/parquet/metadata/statistics_types.gen.go.tmpl
index ec6191a2fa813..35470f06046bf 100644
--- a/go/parquet/metadata/statistics_types.gen.go.tmpl
+++ b/go/parquet/metadata/statistics_types.gen.go.tmpl
@@ -19,13 +19,13 @@ package metadata
 import (
   "fmt"
 
-  "github.com/apache/arrow/go/v13/arrow"
-  "github.com/apache/arrow/go/v13/parquet"
-  "github.com/apache/arrow/go/v13/parquet/schema"
-  "github.com/apache/arrow/go/v13/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v13/internal/utils"
-  "github.com/apache/arrow/go/v13/parquet/internal/encoding"
-  "github.com/apache/arrow/go/v13/internal/bitutils"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/parquet/schema"
+  "github.com/apache/arrow/go/v14/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 {{range .In}}
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 6846b9cc73b7e..6b84e56295ac6 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -26,15 +26,15 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index a91cee3a7307a..6784014281b8b 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -24,14 +24,14 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
 )
 
 // get the count of the number of leaf arrays for the type
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 68e014ffec2ac..63fd4f142abba 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -25,21 +25,21 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/bitutil"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/encode_dict_compute.go b/go/parquet/pqarrow/encode_dict_compute.go
index 3eaf49745233a..59e25cec19132 100644
--- a/go/parquet/pqarrow/encode_dict_compute.go
+++ b/go/parquet/pqarrow/encode_dict_compute.go
@@ -21,14 +21,14 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 func isDictEncoding(enc parquet.Encoding) bool {
diff --git a/go/parquet/pqarrow/encode_dict_nocompute.go b/go/parquet/pqarrow/encode_dict_nocompute.go
index 70d9d58349ccf..31d0f1bc1ce27 100644
--- a/go/parquet/pqarrow/encode_dict_nocompute.go
+++ b/go/parquet/pqarrow/encode_dict_nocompute.go
@@ -21,8 +21,8 @@ package pqarrow
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/parquet/file"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/parquet/file"
 )
 
 func writeDictionaryArrow(*arrowWriteContext, file.ColumnChunkWriter, arrow.Array, []int16, []int16, bool) (err error) {
diff --git a/go/parquet/pqarrow/encode_dictionary_test.go b/go/parquet/pqarrow/encode_dictionary_test.go
index b438d68f9ca3f..995f3fb329534 100644
--- a/go/parquet/pqarrow/encode_dictionary_test.go
+++ b/go/parquet/pqarrow/encode_dictionary_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/compute"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/pqarrow/file_reader.go b/go/parquet/pqarrow/file_reader.go
index 3e987ba148819..d54e365b55e0c 100755
--- a/go/parquet/pqarrow/file_reader.go
+++ b/go/parquet/pqarrow/file_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/arrio"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/pqarrow/file_reader_test.go b/go/parquet/pqarrow/file_reader_test.go
index 4f0ffc945f719..2b4aa8ab78dbe 100644
--- a/go/parquet/pqarrow/file_reader_test.go
+++ b/go/parquet/pqarrow/file_reader_test.go
@@ -24,13 +24,13 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/decimal128"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index 0e72afededf99..052220e716c77 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/internal/utils"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/helpers.go b/go/parquet/pqarrow/helpers.go
index 0b40b57df0541..e8b740d12ba62 100644
--- a/go/parquet/pqarrow/helpers.go
+++ b/go/parquet/pqarrow/helpers.go
@@ -17,7 +17,7 @@
 package pqarrow
 
 import (
-	"github.com/apache/arrow/go/v13/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func releaseArrays(arrays []arrow.Array) {
diff --git a/go/parquet/pqarrow/path_builder.go b/go/parquet/pqarrow/path_builder.go
index 14bf0156b2f38..c4915d58dd59f 100644
--- a/go/parquet/pqarrow/path_builder.go
+++ b/go/parquet/pqarrow/path_builder.go
@@ -21,11 +21,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/bitutils"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/path_builder_test.go b/go/parquet/pqarrow/path_builder_test.go
index fe91893c22c0e..16b994582df02 100644
--- a/go/parquet/pqarrow/path_builder_test.go
+++ b/go/parquet/pqarrow/path_builder_test.go
@@ -20,10 +20,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/properties.go b/go/parquet/pqarrow/properties.go
index 4f0ab03ecf66a..98427bbf9398c 100755
--- a/go/parquet/pqarrow/properties.go
+++ b/go/parquet/pqarrow/properties.go
@@ -19,9 +19,9 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 // ArrowWriterProperties are used to determine how to manipulate the arrow data
diff --git a/go/parquet/pqarrow/reader_writer_test.go b/go/parquet/pqarrow/reader_writer_test.go
index 71da990289190..e3f66834c2cee 100644
--- a/go/parquet/pqarrow/reader_writer_test.go
+++ b/go/parquet/pqarrow/reader_writer_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/array"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index 2e83d3926a48f..4c1627263681a 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -22,14 +22,14 @@ import (
 	"math"
 	"strconv"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/file"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/schema_test.go b/go/parquet/pqarrow/schema_test.go
index 119acef6b966d..e195358af6c98 100644
--- a/go/parquet/pqarrow/schema_test.go
+++ b/go/parquet/pqarrow/schema_test.go
@@ -20,15 +20,15 @@ import (
 	"encoding/base64"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	"github.com/apache/arrow/go/v13/arrow/flight"
-	"github.com/apache/arrow/go/v13/arrow/ipc"
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/types"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/metadata"
-	"github.com/apache/arrow/go/v13/parquet/pqarrow"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/reader_properties.go b/go/parquet/reader_properties.go
index 6bd423a80b5b7..dd2032958a51c 100644
--- a/go/parquet/reader_properties.go
+++ b/go/parquet/reader_properties.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // ReaderProperties are used to define how the file reader will handle buffering and allocating buffers
diff --git a/go/parquet/reader_writer_properties_test.go b/go/parquet/reader_writer_properties_test.go
index 6aea266f9a98c..6bd93a02550e4 100644
--- a/go/parquet/reader_writer_properties_test.go
+++ b/go/parquet/reader_writer_properties_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/compress"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/column.go b/go/parquet/schema/column.go
index 6c1caf5f0e510..1575037d59d23 100644
--- a/go/parquet/schema/column.go
+++ b/go/parquet/schema/column.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Column encapsulates the information necessary to interpret primitive
diff --git a/go/parquet/schema/converted_types.go b/go/parquet/schema/converted_types.go
index 974c2f7281f55..6a4702b819259 100644
--- a/go/parquet/schema/converted_types.go
+++ b/go/parquet/schema/converted_types.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // ConvertedType corresponds to the ConvertedType in the parquet.Thrift,
diff --git a/go/parquet/schema/converted_types_test.go b/go/parquet/schema/converted_types_test.go
index 70b5574b0d9ba..a4f9ea0018196 100644
--- a/go/parquet/schema/converted_types_test.go
+++ b/go/parquet/schema/converted_types_test.go
@@ -19,7 +19,7 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/helpers.go b/go/parquet/schema/helpers.go
index 1198b0b926ac8..23a5a0b667f26 100644
--- a/go/parquet/schema/helpers.go
+++ b/go/parquet/schema/helpers.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	"github.com/apache/arrow/go/v13/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/helpers_test.go b/go/parquet/schema/helpers_test.go
index b4f0b684003db..6d136e4ecd155 100644
--- a/go/parquet/schema/helpers_test.go
+++ b/go/parquet/schema/helpers_test.go
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index 4075edc1e9402..a0607a1a2f62d 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // DecimalMetadata is a struct for managing scale and precision information between
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 117157f95ef83..8531a061abb77 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -19,9 +19,9 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/internal/json"
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/node.go b/go/parquet/schema/node.go
index 6f198027240b7..28259c8d61f58 100644
--- a/go/parquet/schema/node.go
+++ b/go/parquet/schema/node.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index b85c1c28c781a..bc863f1390030 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index 4a029d058155a..e18feada7a796 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -22,8 +22,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/schema.go b/go/parquet/schema/schema.go
index 8c7c4fdc5c365..1b3363f58d11f 100644
--- a/go/parquet/schema/schema.go
+++ b/go/parquet/schema/schema.go
@@ -35,8 +35,8 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/schema_element_test.go b/go/parquet/schema/schema_element_test.go
index 3221f30f64834..e9a2ef5eb31f6 100644
--- a/go/parquet/schema/schema_element_test.go
+++ b/go/parquet/schema/schema_element_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_flatten_test.go b/go/parquet/schema/schema_flatten_test.go
index c2ed82c8d4aea..90741ae9b43bb 100644
--- a/go/parquet/schema/schema_flatten_test.go
+++ b/go/parquet/schema/schema_flatten_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_test.go b/go/parquet/schema/schema_test.go
index cdd7f2a12b5ce..e69a13e07986e 100644
--- a/go/parquet/schema/schema_test.go
+++ b/go/parquet/schema/schema_test.go
@@ -20,9 +20,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v13/parquet"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v13/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/types.go b/go/parquet/types.go
index d1e90a3a01161..7b6df2ea9d16c 100644
--- a/go/parquet/types.go
+++ b/go/parquet/types.go
@@ -24,8 +24,8 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v13/arrow"
-	format "github.com/apache/arrow/go/v13/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 const (
diff --git a/go/parquet/writer_properties.go b/go/parquet/writer_properties.go
index 6ffa6bf5035ba..bd172f7f92702 100644
--- a/go/parquet/writer_properties.go
+++ b/go/parquet/writer_properties.go
@@ -17,8 +17,8 @@
 package parquet
 
 import (
-	"github.com/apache/arrow/go/v13/arrow/memory"
-	"github.com/apache/arrow/go/v13/parquet/compress"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 )
 
 // Constants for default property values used for the default reader, writer and column props.
@@ -46,7 +46,7 @@ const (
 	DefaultStatsEnabled = true
 	// If the stats are larger than 4K the writer will skip writing them out anyways.
 	DefaultMaxStatsSize int64 = 4096
-	DefaultCreatedBy          = "parquet-go version 13.0.0-SNAPSHOT"
+	DefaultCreatedBy          = "parquet-go version 14.0.0-SNAPSHOT"
 	DefaultRootName           = "schema"
 )
 
diff --git a/java/adapter/avro/pom.xml b/java/adapter/avro/pom.xml
index 02364e9cfa77d..7f55fdc19fc27 100644
--- a/java/adapter/avro/pom.xml
+++ b/java/adapter/avro/pom.xml
@@ -16,7 +16,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
     <relativePath>../../pom.xml</relativePath>
   </parent>
 
diff --git a/java/adapter/jdbc/pom.xml b/java/adapter/jdbc/pom.xml
index 2a645f7b49b55..1a160fcc983d1 100644
--- a/java/adapter/jdbc/pom.xml
+++ b/java/adapter/jdbc/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/adapter/orc/pom.xml b/java/adapter/orc/pom.xml
index de3ffb9a57589..90e14679c172e 100644
--- a/java/adapter/orc/pom.xml
+++ b/java/adapter/orc/pom.xml
@@ -114,7 +114,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/algorithm/pom.xml b/java/algorithm/pom.xml
index a3d79fc0dd991..7041e92788e64 100644
--- a/java/algorithm/pom.xml
+++ b/java/algorithm/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-algorithm</artifactId>
   <name>Arrow Algorithms</name>
diff --git a/java/c/pom.xml b/java/c/pom.xml
index ed7b7b47aa272..d347175fefa53 100644
--- a/java/c/pom.xml
+++ b/java/c/pom.xml
@@ -13,7 +13,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/compression/pom.xml b/java/compression/pom.xml
index efcedb0613eb9..a914d0208433f 100644
--- a/java/compression/pom.xml
+++ b/java/compression/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-compression</artifactId>
   <name>Arrow Compression</name>
diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index b8ec317e9c14a..055fa1cabd4d9 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/flight/flight-core/pom.xml b/java/flight/flight-core/pom.xml
index b9d94b25a1c19..9ce777ec1ee5f 100644
--- a/java/flight/flight-core/pom.xml
+++ b/java/flight/flight-core/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/flight-grpc/pom.xml b/java/flight/flight-grpc/pom.xml
index 3b77e419ce137..5e77461841c1f 100644
--- a/java/flight/flight-grpc/pom.xml
+++ b/java/flight/flight-grpc/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
   <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-integration-tests/pom.xml b/java/flight/flight-integration-tests/pom.xml
index 689d5c41a3e75..b6a754dea7b18 100644
--- a/java/flight/flight-integration-tests/pom.xml
+++ b/java/flight/flight-integration-tests/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index dbf3efa595757..106d4f968dbda 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 38ebc929efe47..1fd9222be3747 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql/pom.xml b/java/flight/flight-sql/pom.xml
index 5e60aca9ae774..565c170587040 100644
--- a/java/flight/flight-sql/pom.xml
+++ b/java/flight/flight-sql/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/pom.xml b/java/flight/pom.xml
index 7f5e537a3ecce..b1e1f4d317467 100644
--- a/java/flight/pom.xml
+++ b/java/flight/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/format/pom.xml b/java/format/pom.xml
index 6df06fccce22f..c8e83336c0ff3 100644
--- a/java/format/pom.xml
+++ b/java/format/pom.xml
@@ -15,7 +15,7 @@
 <parent>
   <artifactId>arrow-java-root</artifactId>
   <groupId>org.apache.arrow</groupId>
-  <version>13.0.0-SNAPSHOT</version>
+  <version>14.0.0-SNAPSHOT</version>
 </parent>
 
 <artifactId>arrow-format</artifactId>
diff --git a/java/gandiva/pom.xml b/java/gandiva/pom.xml
index 5e68d45a8af93..d9f20cfd9be43 100644
--- a/java/gandiva/pom.xml
+++ b/java/gandiva/pom.xml
@@ -14,7 +14,7 @@
     <parent>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-java-root</artifactId>
-      <version>13.0.0-SNAPSHOT</version>
+      <version>14.0.0-SNAPSHOT</version>
     </parent>
 
     <groupId>org.apache.arrow.gandiva</groupId>
diff --git a/java/memory/memory-core/pom.xml b/java/memory/memory-core/pom.xml
index 2262bcb6410a3..62d74bd0925c9 100644
--- a/java/memory/memory-core/pom.xml
+++ b/java/memory/memory-core/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-netty/pom.xml b/java/memory/memory-netty/pom.xml
index 240b24aa6c83f..be3abed76d2c4 100644
--- a/java/memory/memory-netty/pom.xml
+++ b/java/memory/memory-netty/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-unsafe/pom.xml b/java/memory/memory-unsafe/pom.xml
index 11f378425dee4..cf4ac4fcc594d 100644
--- a/java/memory/memory-unsafe/pom.xml
+++ b/java/memory/memory-unsafe/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/pom.xml b/java/memory/pom.xml
index 0057576902614..0ddbf63ef38b9 100644
--- a/java/memory/pom.xml
+++ b/java/memory/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-memory</artifactId>
   <name>Arrow Memory</name>
diff --git a/java/performance/pom.xml b/java/performance/pom.xml
index c0f211aa0b192..8653afca2191e 100644
--- a/java/performance/pom.xml
+++ b/java/performance/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-performance</artifactId>
     <packaging>jar</packaging>
@@ -74,7 +74,7 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-algorithm</artifactId>
-            <version>13.0.0-SNAPSHOT</version>
+            <version>14.0.0-SNAPSHOT</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
diff --git a/java/pom.xml b/java/pom.xml
index f6837cd82c7b5..cbfe723436af4 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-java-root</artifactId>
-  <version>13.0.0-SNAPSHOT</version>
+  <version>14.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>Apache Arrow Java Root POM</name>
diff --git a/java/tools/pom.xml b/java/tools/pom.xml
index 8ceab7e06f53d..ba9343228319e 100644
--- a/java/tools/pom.xml
+++ b/java/tools/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>13.0.0-SNAPSHOT</version>
+        <version>14.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-tools</artifactId>
     <name>Arrow Tools</name>
diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index 09233a69475cf..e6dcef0e1b3e6 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>13.0.0-SNAPSHOT</version>
+    <version>14.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-vector</artifactId>
   <name>Arrow Vectors</name>
diff --git a/js/package.json b/js/package.json
index 720349e5d1f54..d072e9b373bbb 100644
--- a/js/package.json
+++ b/js/package.json
@@ -122,5 +122,5 @@
   "engines": {
     "node": ">=12.0"
   },
-  "version": "13.0.0-SNAPSHOT"
+  "version": "14.0.0-SNAPSHOT"
 }
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index 5380e4cbe1b60..feda2cc6adbd6 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -193,7 +193,7 @@ endmacro()
 
 set(CMAKE_CXX_STANDARD 17)
 
-set(MLARROW_VERSION "13.0.0-SNAPSHOT")
+set(MLARROW_VERSION "14.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" MLARROW_BASE_VERSION "${MLARROW_VERSION}")
 
 project(mlarrow VERSION "${MLARROW_BASE_VERSION}")
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 21a2ace5216bb..242ba8448f4a6 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -21,7 +21,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(pyarrow)
 
-set(PYARROW_VERSION "13.0.0-SNAPSHOT")
+set(PYARROW_VERSION "14.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" PYARROW_BASE_VERSION "${PYARROW_VERSION}")
 
 # Running from a Python sdist tarball
diff --git a/python/setup.py b/python/setup.py
index dc529679c7f90..abd9d03cfb17e 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -407,7 +407,7 @@ def get_outputs(self):
 
 # If the event of not running from a git clone (e.g. from a git archive
 # or a Python sdist), see if we can set the version number ourselves
-default_version = '13.0.0-SNAPSHOT'
+default_version = '14.0.0-SNAPSHOT'
 if (not os.path.exists('../.git') and
         not os.environ.get('SETUPTOOLS_SCM_PRETEND_VERSION')):
     os.environ['SETUPTOOLS_SCM_PRETEND_VERSION'] = \
diff --git a/r/DESCRIPTION b/r/DESCRIPTION
index bcf051b1f78cc..0088e590803a6 100644
--- a/r/DESCRIPTION
+++ b/r/DESCRIPTION
@@ -1,6 +1,6 @@
 Package: arrow
 Title: Integration to 'Apache' 'Arrow'
-Version: 12.0.1.9000
+Version: 13.0.0.9000
 Authors@R: c(
     person("Neal", "Richardson", email = "neal.p.richardson@gmail.com", role = c("aut")),
     person("Ian", "Cook", email = "ianmcook@gmail.com", role = c("aut")),
diff --git a/r/NEWS.md b/r/NEWS.md
index 6d09355170a67..d789231187e3b 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -17,7 +17,9 @@
   under the License.
 -->
 
-# arrow 12.0.1.9000
+# arrow 13.0.0.9000
+
+# arrow 13.0.0
 
 ## New features
 
diff --git a/r/pkgdown/assets/versions.json b/r/pkgdown/assets/versions.json
index 4d7658e6e5e25..565f67b9730a4 100644
--- a/r/pkgdown/assets/versions.json
+++ b/r/pkgdown/assets/versions.json
@@ -1,12 +1,16 @@
 [
     {
-        "name": "12.0.1.9000 (dev)",
+        "name": "13.0.0.9000 (dev)",
         "version": "dev/"
     },
     {
-        "name": "12.0.1.1 (release)",
+        "name": "13.0.0 (release)",
         "version": ""
     },
+    {
+        "name": "12.0.1.1",
+        "version": "12.0/"
+    },
     {
         "name": "12.0.0",
         "version": "12.0/"
diff --git a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
index 32eece985ea1f..f1619503fe63a 100644
--- a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
+++ b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowCUDA
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
index 302ced6f94689..ae903d6a1b9d7 100644
--- a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
+++ b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowDataset
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
index 679f709cc38c2..2a800c7f3f2bf 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlightSQL
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/version.rb b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
index 559fb879ceadc..ab06445180191 100644
--- a/ruby/red-arrow-flight/lib/arrow-flight/version.rb
+++ b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlight
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow/lib/arrow/version.rb b/ruby/red-arrow/lib/arrow/version.rb
index 9d4c8f9cf610c..23d0239549e48 100644
--- a/ruby/red-arrow/lib/arrow/version.rb
+++ b/ruby/red-arrow/lib/arrow/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-gandiva/lib/gandiva/version.rb b/ruby/red-gandiva/lib/gandiva/version.rb
index fbdd240bf2601..190abcf134a9a 100644
--- a/ruby/red-gandiva/lib/gandiva/version.rb
+++ b/ruby/red-gandiva/lib/gandiva/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Gandiva
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-parquet/lib/parquet/version.rb b/ruby/red-parquet/lib/parquet/version.rb
index 745d9c35b7b85..747c68f9af7f8 100644
--- a/ruby/red-parquet/lib/parquet/version.rb
+++ b/ruby/red-parquet/lib/parquet/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Parquet
-  VERSION = "13.0.0-SNAPSHOT"
+  VERSION = "14.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")

From 187c9535d52aa0a8962c6e7de35c5e7f2daadb11 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 23 Aug 2023 16:00:03 +0200
Subject: [PATCH 218/749] MINOR: [Release] Update .deb package names for 14.0.0

---
 .../apache-arrow/debian/control.in            | 104 +++++++++---------
 ...300.install => libarrow-acero1400.install} |   0
 ...install => libarrow-cuda-glib1400.install} |   0
 ...1300.install => libarrow-cuda1400.install} |   0
 ...tall => libarrow-dataset-glib1400.install} |   0
 ...0.install => libarrow-dataset1400.install} |   0
 ...stall => libarrow-flight-glib1400.install} |   0
 ...l => libarrow-flight-sql-glib1400.install} |   0
 ...nstall => libarrow-flight-sql1400.install} |   0
 ...00.install => libarrow-flight1400.install} |   0
 ...1300.install => libarrow-glib1400.install} |   0
 ...arrow1300.install => libarrow1400.install} |   0
 ...00.install => libgandiva-glib1400.install} |   0
 ...iva1300.install => libgandiva1400.install} |   0
 ...00.install => libparquet-glib1400.install} |   0
 ...uet1300.install => libparquet1400.install} |   0
 dev/tasks/tasks.yml                           |  60 +++++-----
 17 files changed, 82 insertions(+), 82 deletions(-)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-acero1300.install => libarrow-acero1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-cuda-glib1300.install => libarrow-cuda-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-cuda1300.install => libarrow-cuda1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-dataset-glib1300.install => libarrow-dataset-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-dataset1300.install => libarrow-dataset1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-glib1300.install => libarrow-flight-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-sql-glib1300.install => libarrow-flight-sql-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-sql1300.install => libarrow-flight-sql1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight1300.install => libarrow-flight1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-glib1300.install => libarrow-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow1300.install => libarrow1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libgandiva-glib1300.install => libgandiva-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libgandiva1300.install => libgandiva1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libparquet-glib1300.install => libparquet-glib1400.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libparquet1300.install => libparquet1400.install} (100%)

diff --git a/dev/tasks/linux-packages/apache-arrow/debian/control.in b/dev/tasks/linux-packages/apache-arrow/debian/control.in
index 25b69b24cbe87..6b161ddef5d67 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/control.in
+++ b/dev/tasks/linux-packages/apache-arrow/debian/control.in
@@ -41,7 +41,7 @@ Build-Depends-Indep: libglib2.0-doc
 Standards-Version: 3.9.8
 Homepage: https://arrow.apache.org/
 
-Package: libarrow1300
+Package: libarrow1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -61,12 +61,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides tools.
 
-Package: libarrow-cuda1300
+Package: libarrow-cuda1400
 Section: libs
 Architecture: @CUDA_ARCHITECTURE@
 Multi-Arch: same
@@ -74,12 +74,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for CUDA support.
 
-Package: libarrow-acero1300
+Package: libarrow-acero1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -87,12 +87,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Acero module.
 
-Package: libarrow-dataset1300
+Package: libarrow-dataset1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -100,13 +100,13 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-acero1300 (= ${binary:Version}),
-  libparquet1300 (= ${binary:Version})
+  libarrow-acero1400 (= ${binary:Version}),
+  libparquet1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Dataset module.
 
-Package: libarrow-flight1300
+Package: libarrow-flight1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -114,12 +114,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Flight RPC system.
 
-Package: libarrow-flight-sql1300
+Package: libarrow-flight-sql1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -127,7 +127,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-flight1300 (= ${binary:Version})
+  libarrow-flight1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Flight SQL system.
@@ -138,7 +138,7 @@ Architecture: any
 Multi-Arch: same
 Depends:
   ${misc:Depends},
-  libarrow1300 (= ${binary:Version}),
+  libarrow1400 (= ${binary:Version}),
   libbrotli-dev,
   libbz2-dev,
   libc-ares-dev,
@@ -167,7 +167,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libarrow-cuda1300 (= ${binary:Version})
+  libarrow-cuda1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for CUDA support.
@@ -178,7 +178,7 @@ Architecture: any
 Multi-Arch: same
 Depends:
   ${misc:Depends},
-  libarrow-acero1300 (= ${binary:Version}),
+  libarrow-acero1400 (= ${binary:Version}),
   libparquet-dev (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -191,7 +191,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-acero-dev (= ${binary:Version}),
-  libarrow-dataset1300 (= ${binary:Version}),
+  libarrow-dataset1400 (= ${binary:Version}),
   libparquet-dev (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -204,7 +204,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libarrow-flight1300 (= ${binary:Version})
+  libarrow-flight1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for Flight RPC system.
@@ -216,12 +216,12 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-flight-dev (= ${binary:Version}),
-  libarrow-flight-sql1300 (= ${binary:Version})
+  libarrow-flight-sql1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for Flight SQL system.
 
-Package: libgandiva1300
+Package: libgandiva1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -229,7 +229,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
@@ -242,13 +242,13 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libgandiva1300 (= ${binary:Version})
+  libgandiva1400 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
  This package provides C++ header files.
 
-Package: libparquet1300
+Package: libparquet1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -268,7 +268,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libparquet1300 (= ${binary:Version})
+  libparquet1400 (= ${binary:Version})
 Description: Apache Parquet is a columnar storage format
  .
  This package provides tools.
@@ -280,12 +280,12 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libparquet1300 (= ${binary:Version})
+  libparquet1400 (= ${binary:Version})
 Description: Apache Parquet is a columnar storage format
  .
  This package provides C++ header files.
 
-Package: libarrow-glib1300
+Package: libarrow-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -293,7 +293,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1300 (= ${binary:Version})
+  libarrow1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files.
@@ -317,7 +317,7 @@ Depends:
   ${misc:Depends},
   libglib2.0-dev,
   libarrow-dev (= ${binary:Version}),
-  libarrow-glib1300 (= ${binary:Version}),
+  libarrow-glib1400 (= ${binary:Version}),
   gir1.2-arrow-1.0 (= ${binary:Version})
 Suggests: libarrow-glib-doc
 Description: Apache Arrow is a data processing library for analysis
@@ -335,7 +335,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations.
 
-Package: libarrow-cuda-glib1300
+Package: libarrow-cuda-glib1400
 Section: libs
 Architecture: @CUDA_ARCHITECTURE@
 Multi-Arch: same
@@ -343,8 +343,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1300 (= ${binary:Version}),
-  libarrow-cuda1300 (= ${binary:Version})
+  libarrow-glib1400 (= ${binary:Version}),
+  libarrow-cuda1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for CUDA support.
@@ -369,13 +369,13 @@ Depends:
   ${misc:Depends},
   libarrow-cuda-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-cuda-glib1300 (= ${binary:Version}),
+  libarrow-cuda-glib1400 (= ${binary:Version}),
   gir1.2-arrow-cuda-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based header files for CUDA support.
 
-Package: libarrow-dataset-glib1300
+Package: libarrow-dataset-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -383,8 +383,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1300 (= ${binary:Version}),
-  libarrow-dataset1300 (= ${binary:Version})
+  libarrow-glib1400 (= ${binary:Version}),
+  libarrow-dataset1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for dataset module.
@@ -409,7 +409,7 @@ Depends:
   ${misc:Depends},
   libarrow-dataset-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-dataset-glib1300 (= ${binary:Version}),
+  libarrow-dataset-glib1400 (= ${binary:Version}),
   gir1.2-arrow-dataset-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -426,7 +426,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for dataset module.
 
-Package: libarrow-flight-glib1300
+Package: libarrow-flight-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -434,8 +434,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1300 (= ${binary:Version}),
-  libarrow-flight1300 (= ${binary:Version})
+  libarrow-glib1400 (= ${binary:Version}),
+  libarrow-flight1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for Apache Arrow Flight.
@@ -461,7 +461,7 @@ Depends:
   ${misc:Depends},
   libarrow-flight-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-flight-glib1300 (= ${binary:Version}),
+  libarrow-flight-glib1400 (= ${binary:Version}),
   gir1.2-arrow-flight-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -478,7 +478,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for Apache Arrow Flight.
 
-Package: libarrow-flight-sql-glib1300
+Package: libarrow-flight-sql-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -486,8 +486,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-flight-glib1300 (= ${binary:Version}),
-  libarrow-flight-sql1300 (= ${binary:Version})
+  libarrow-flight-glib1400 (= ${binary:Version}),
+  libarrow-flight-sql1400 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for Apache Arrow Flight SQL.
@@ -513,7 +513,7 @@ Depends:
   ${misc:Depends},
   libarrow-flight-sql-dev (= ${binary:Version}),
   libarrow-flight-glib-dev (= ${binary:Version}),
-  libarrow-flight-sql-glib1300 (= ${binary:Version}),
+  libarrow-flight-sql-glib1400 (= ${binary:Version}),
   gir1.2-arrow-flight-sql-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -530,7 +530,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for Apache Arrow Flight SQL.
 
-Package: libgandiva-glib1300
+Package: libgandiva-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -538,8 +538,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1300 (= ${binary:Version}),
-  libgandiva1300 (= ${binary:Version})
+  libarrow-glib1400 (= ${binary:Version}),
+  libgandiva1400 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
@@ -566,7 +566,7 @@ Depends:
   ${misc:Depends},
   libgandiva-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libgandiva-glib1300 (= ${binary:Version}),
+  libgandiva-glib1400 (= ${binary:Version}),
   gir1.2-gandiva-1.0 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
@@ -585,7 +585,7 @@ Description: Gandiva is a toolset for compiling and evaluating expressions
  .
  This package provides documentations.
 
-Package: libparquet-glib1300
+Package: libparquet-glib1400
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -593,8 +593,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1300 (= ${binary:Version}),
-  libparquet1300 (= ${binary:Version})
+  libarrow-glib1400 (= ${binary:Version}),
+  libparquet1400 (= ${binary:Version})
 Description: Apache Parquet is a columnar storage format
  .
  This package provides GLib based library files.
@@ -619,7 +619,7 @@ Depends:
   ${misc:Depends},
   libarrow-glib-dev (= ${binary:Version}),
   libparquet-dev (= ${binary:Version}),
-  libparquet-glib1300 (= ${binary:Version}),
+  libparquet-glib1400 (= ${binary:Version}),
   gir1.2-parquet-1.0 (= ${binary:Version})
 Suggests: libparquet-glib-doc
 Description: Apache Parquet is a columnar storage format
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libgandiva1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libgandiva1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libgandiva1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libgandiva1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1400.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libparquet1300.install b/dev/tasks/linux-packages/apache-arrow/debian/libparquet1400.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libparquet1300.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libparquet1400.install
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index bad5b3c1f8988..33643f16a33d0 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -605,59 +605,59 @@ tasks:
       - gir1.2-gandiva-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - gir1.2-parquet-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-acero-dev_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-acero1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-acero1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-acero1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-acero1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-dataset-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-dataset-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-dataset1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-dataset1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-dataset-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-dataset-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-dataset1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-dataset1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-sql-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-sql-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-sql1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-sql1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-sql-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-sql-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-sql1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-sql1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libgandiva-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libgandiva-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libgandiva1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libgandiva1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libgandiva-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libgandiva-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libgandiva1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libgandiva1400_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libparquet-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libparquet-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libparquet1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libparquet1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libparquet-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libparquet-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libparquet1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libparquet1400_{no_rc_version}-1_[a-z0-9]+.deb
       - parquet-tools_{no_rc_version}-1_[a-z0-9]+.deb
     {% if architecture == "amd64" %}
       - gir1.2-arrow-cuda-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-cuda-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-cuda-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-cuda-glib1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-cuda-glib1300_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-cuda1300-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-cuda1300_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-cuda-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-cuda-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-cuda1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-cuda1400_{no_rc_version}-1_[a-z0-9]+.deb
     {% endif %}
   {% endfor %}
 {% endfor %}

From e38e1c9357e9d52d6457fd8ce2ce9d3cafe578da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 23 Aug 2023 16:00:04 +0200
Subject: [PATCH 219/749] MINOR: [Release] Update .deb/.rpm changelogs for
 13.0.0

---
 .../linux-packages/apache-arrow-apt-source/debian/changelog | 6 ++++++
 .../apache-arrow-release/yum/apache-arrow-release.spec.in   | 3 +++
 dev/tasks/linux-packages/apache-arrow/debian/changelog      | 6 ++++++
 dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in     | 3 +++
 4 files changed, 18 insertions(+)

diff --git a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
index 07d8cf3721977..597a2d4d3b43a 100644
--- a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
@@ -1,3 +1,9 @@
+apache-arrow-apt-source (13.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 17 Aug 2023 08:01:24 -0000
+
 apache-arrow-apt-source (12.0.1-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
index 0155a54c44c5f..79cb46006d074 100644
--- a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
@@ -102,6 +102,9 @@ else
 fi
 
 %changelog
+* Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
+- New upstream release.
+
 * Wed Jun 07 2023 Raúl Cumplido <raulcumplido@gmail.com> - 12.0.1-1
 - New upstream release.
 
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/changelog b/dev/tasks/linux-packages/apache-arrow/debian/changelog
index 073e1be8b7a88..525ae9cae02a0 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow/debian/changelog
@@ -1,3 +1,9 @@
+apache-arrow (13.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 17 Aug 2023 08:01:24 -0000
+
 apache-arrow (12.0.1-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 46c6d91b2d5dc..8fe0313338030 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -866,6 +866,9 @@ Documentation for Apache Parquet GLib.
 %{_datadir}/gtk-doc/html/parquet-glib/
 
 %changelog
+* Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
+- New upstream release.
+
 * Wed Jun 07 2023 Raúl Cumplido <raulcumplido@gmail.com> - 12.0.1-1
 - New upstream release.
 

From 5fc73e8adc13a389f4782aca9cd60c419d6e1cff Mon Sep 17 00:00:00 2001
From: Will Jones <willjones127@gmail.com>
Date: Wed, 23 Aug 2023 08:38:23 -0700
Subject: [PATCH 220/749] GH-20086: [C++] Cast between fixed size and variable
 size lists (#37292)

### Rationale for this change

These list types should be able to cast to each other. In our code base, we find users might naively make an list array (for example, with `pa.Table.from_pylist()`) and want it automatically casted to a tensor array (which is based on a fixed size list).

### What changes are included in this PR?

Adds casts from FSL -> (Large)List and (Large)List -> FSL.

### Are these changes tested?

The kernels are tested.

### Are there any user-facing changes?

Just a new kernel.
* Closes: #20086

Authored-by: Will Jones <willjones127@gmail.com>
Signed-off-by: Will Jones <willjones127@gmail.com>
---
 .../compute/kernels/scalar_cast_nested.cc     | 190 ++++++++++++++++--
 .../arrow/compute/kernels/scalar_cast_test.cc |  82 ++++++++
 2 files changed, 260 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_nested.cc b/cpp/src/arrow/compute/kernels/scalar_cast_nested.cc
index 28170a223d248..6fd449a931381 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_nested.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_nested.cc
@@ -22,6 +22,7 @@
 #include <vector>
 
 #include "arrow/array/builder_nested.h"
+#include "arrow/array/builder_primitive.h"
 #include "arrow/compute/api_scalar.h"
 #include "arrow/compute/cast.h"
 #include "arrow/compute/kernels/common_internal.h"
@@ -33,11 +34,24 @@ namespace arrow {
 
 using internal::CopyBitmap;
 
-namespace compute {
-namespace internal {
+namespace compute::internal {
 
 namespace {
 
+Result<std::shared_ptr<Buffer>> GetNullBitmapBuffer(const ArraySpan& in_array,
+                                                    MemoryPool* pool) {
+  if (in_array.buffers[0].data == nullptr) {
+    return nullptr;
+  }
+
+  if (in_array.offset == 0) {
+    return in_array.GetBuffer(0);
+  }
+
+  // If a non-zero offset, we need to shift the bitmap
+  return CopyBitmap(pool, in_array.buffers[0].data, in_array.offset, in_array.length);
+}
+
 // (Large)List<T> -> (Large)List<U>
 
 // TODO(wesm): memory could be preallocated here and it would make
@@ -111,18 +125,12 @@ struct CastList {
     const ArraySpan& in_array = batch[0].array;
 
     ArrayData* out_array = out->array_data().get();
-    out_array->buffers[0] = in_array.GetBuffer(0);
+    ARROW_ASSIGN_OR_RAISE(out_array->buffers[0],
+                          GetNullBitmapBuffer(in_array, ctx->memory_pool()));
     out_array->buffers[1] = in_array.GetBuffer(1);
 
     std::shared_ptr<ArrayData> values = in_array.child_data[0].ToArrayData();
 
-    // Shift bitmap in case the source offset is non-zero
-    if (in_array.offset != 0 && in_array.buffers[0].data != nullptr) {
-      ARROW_ASSIGN_OR_RAISE(out_array->buffers[0],
-                            CopyBitmap(ctx->memory_pool(), in_array.buffers[0].data,
-                                       in_array.offset, in_array.length));
-    }
-
     RETURN_NOT_OK(HandleOffsets(ctx, in_array, out_array, &values));
 
     // Handle values
@@ -145,6 +153,160 @@ void AddListCast(CastFunction* func) {
   DCHECK_OK(func->AddKernel(SrcType::type_id, std::move(kernel)));
 }
 
+template <typename DestType>
+struct CastFixedToVarList {
+  using dest_offset_type = typename DestType::offset_type;
+
+  static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+    const CastOptions& options = CastState::Get(ctx);
+
+    auto child_type = checked_cast<const DestType&>(*out->type()).value_type();
+
+    const ArraySpan& in_array = batch[0].array;
+
+    ArrayData* out_array = out->array_data().get();
+    ARROW_ASSIGN_OR_RAISE(out_array->buffers[0],
+                          GetNullBitmapBuffer(in_array, ctx->memory_pool()));
+
+    const auto& in_type = checked_cast<const FixedSizeListType&>(*in_array.type);
+    const int32_t list_size = in_type.list_size();
+
+    // Allocate a new offsets buffer
+    ARROW_ASSIGN_OR_RAISE(out_array->buffers[1],
+                          ctx->Allocate(sizeof(dest_offset_type) * (batch.length + 1)));
+    auto* offsets = out_array->GetMutableValues<dest_offset_type>(1);
+    dest_offset_type offset = 0;
+    for (int64_t i = 0; i <= batch.length; ++i) {
+      offsets[i] = offset;
+      offset += list_size;
+    }
+
+    // Handle values
+    std::shared_ptr<ArrayData> values = in_array.child_data[0].ToArrayData();
+    if (in_array.offset > 0) {
+      values = values->Slice(in_array.offset * list_size, in_array.length * list_size);
+    }
+    ARROW_ASSIGN_OR_RAISE(Datum cast_values,
+                          Cast(values, child_type, options, ctx->exec_context()));
+    DCHECK(cast_values.is_array());
+    out_array->child_data.push_back(cast_values.array());
+
+    return Status::OK();
+  }
+};
+
+template <typename SrcType>
+struct CastVarToFixedList {
+  using src_offset_type = typename SrcType::offset_type;
+
+  // Validate the lengths of each list are equal to the list size.
+  // Additionally, checks if the null slots are all the list size. Returns true
+  // if so, which can be used to optimize the cast.
+  static Result<bool> ValidateLengths(const ArraySpan& in_array, int32_t list_size) {
+    const auto* offsets = in_array.GetValues<src_offset_type>(1);
+    src_offset_type expected_offset = offsets[0] + list_size;
+    // If there are nulls, it's possible that the null slots are the correct
+    // size. That enables an optimization later in this function.
+    bool nulls_have_correct_length = true;
+    if (in_array.GetNullCount() > 0) {
+      for (int64_t i = 1; i <= in_array.length; ++i) {
+        if (in_array.IsNull(i - 1)) {
+          if (offsets[i] != expected_offset) {
+            nulls_have_correct_length = false;
+          }
+          // If element is null, it can be any size, so the next offset is valid.
+          expected_offset = offsets[i] + list_size;
+        } else {
+          if (offsets[i] != expected_offset) {
+            return Status::Invalid("ListType can only be casted to FixedSizeListType ",
+                                   "if the lists are all the expected size.");
+          }
+          expected_offset += list_size;
+        }
+      }
+    } else {
+      // Don't need to check null slots if there are no nulls
+      for (int64_t i = 1; i <= in_array.length; ++i) {
+        if (offsets[i] != expected_offset) {
+          return Status::Invalid("ListType can only be casted to FixedSizeListType ",
+                                 "if the lists are all the expected size.");
+        }
+        expected_offset += list_size;
+      }
+    }
+    return nulls_have_correct_length;
+  }
+
+  // Build take indices for the values. This is used to fill in the null slots
+  // if they aren't already the correct size.
+  static Result<std::shared_ptr<Array>> BuildTakeIndices(const ArraySpan& in_array,
+                                                         int32_t list_size,
+                                                         KernelContext* ctx) {
+    const auto* offsets = in_array.GetValues<src_offset_type>(1);
+    // We need to fill in the null slots, so we'll use Take on the values.
+    auto builder = Int64Builder(ctx->memory_pool());
+    RETURN_NOT_OK(builder.Reserve(in_array.length * list_size));
+    for (int64_t offset_i = 0; offset_i < in_array.length; ++offset_i) {
+      if (in_array.IsNull(offset_i)) {
+        // If element is null, just fill in the null slots with first value.
+        for (int64_t j = 0; j < list_size; ++j) {
+          builder.UnsafeAppend(0);
+        }
+      } else {
+        int64_t value_i = offsets[offset_i];
+        for (int64_t j = 0; j < list_size; ++j) {
+          builder.UnsafeAppend(value_i++);
+        }
+      }
+    }
+    return builder.Finish();
+  }
+
+  static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+    const CastOptions& options = CastState::Get(ctx);
+
+    auto child_type = checked_cast<const FixedSizeListType&>(*out->type()).value_type();
+
+    const ArraySpan& in_array = batch[0].array;
+
+    const auto& out_type = checked_cast<const FixedSizeListType&>(*out->type());
+    const int32_t list_size = out_type.list_size();
+
+    ARROW_ASSIGN_OR_RAISE(bool nulls_have_correct_length,
+                          ValidateLengths(in_array, list_size));
+
+    ArrayData* out_array = out->array_data().get();
+    ARROW_ASSIGN_OR_RAISE(out_array->buffers[0],
+                          GetNullBitmapBuffer(in_array, ctx->memory_pool()));
+
+    // Handle values
+    std::shared_ptr<ArrayData> values = in_array.child_data[0].ToArrayData();
+    ARROW_ASSIGN_OR_RAISE(Datum cast_values_datum,
+                          Cast(values, child_type, options, ctx->exec_context()));
+
+    DCHECK(cast_values_datum.is_array());
+    std::shared_ptr<ArrayData> cast_values = cast_values_datum.array();
+
+    const auto* offsets = in_array.GetValues<src_offset_type>(1);
+    if (in_array.GetNullCount() > 0 && !nulls_have_correct_length) {
+      // We need to fill in the null slots, so we'll use Take on the values.
+      ARROW_ASSIGN_OR_RAISE(auto indices, BuildTakeIndices(in_array, list_size, ctx));
+      ARROW_ASSIGN_OR_RAISE(auto take_result,
+                            Take(cast_values, Datum(indices),
+                                 TakeOptions::NoBoundsCheck(), ctx->exec_context()));
+      DCHECK(take_result.is_array());
+      cast_values = take_result.array();
+    } else if (offsets[0] != 0) {
+      // No nulls, but we need to slice the values
+      cast_values = cast_values->Slice(offsets[0], in_array.length * list_size);
+    }
+
+    out_array->child_data.emplace_back(std::move(cast_values));
+
+    return Status::OK();
+  }
+};
+
 struct CastFixedList {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     const CastOptions& options = CastState::Get(ctx);
@@ -319,12 +481,15 @@ std::vector<std::shared_ptr<CastFunction>> GetNestedCasts() {
   AddCommonCasts(Type::LIST, kOutputTargetType, cast_list.get());
   AddListCast<ListType, ListType>(cast_list.get());
   AddListCast<LargeListType, ListType>(cast_list.get());
+  AddTypeToTypeCast<CastFixedToVarList<ListType>, FixedSizeListType>(cast_list.get());
 
   auto cast_large_list =
       std::make_shared<CastFunction>("cast_large_list", Type::LARGE_LIST);
   AddCommonCasts(Type::LARGE_LIST, kOutputTargetType, cast_large_list.get());
   AddListCast<ListType, LargeListType>(cast_large_list.get());
   AddListCast<LargeListType, LargeListType>(cast_large_list.get());
+  AddTypeToTypeCast<CastFixedToVarList<LargeListType>, FixedSizeListType>(
+      cast_large_list.get());
 
   auto cast_map = std::make_shared<CastFunction>("cast_map", Type::MAP);
   AddCommonCasts(Type::MAP, kOutputTargetType, cast_map.get());
@@ -337,6 +502,8 @@ std::vector<std::shared_ptr<CastFunction>> GetNestedCasts() {
       std::make_shared<CastFunction>("cast_fixed_size_list", Type::FIXED_SIZE_LIST);
   AddCommonCasts(Type::FIXED_SIZE_LIST, kOutputTargetType, cast_fsl.get());
   AddTypeToTypeCast<CastFixedList, FixedSizeListType>(cast_fsl.get());
+  AddTypeToTypeCast<CastVarToFixedList<ListType>, ListType>(cast_fsl.get());
+  AddTypeToTypeCast<CastVarToFixedList<LargeListType>, LargeListType>(cast_fsl.get());
 
   // So is struct
   auto cast_struct = std::make_shared<CastFunction>("cast_struct", Type::STRUCT);
@@ -351,6 +518,5 @@ std::vector<std::shared_ptr<CastFunction>> GetNestedCasts() {
   return {cast_list, cast_large_list, cast_map, cast_fsl, cast_struct, cast_dictionary};
 }
 
-}  // namespace internal
-}  // namespace compute
+}  // namespace compute::internal
 }  // namespace arrow
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
index 1db06a762544b..57cd3ad5ed5fc 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
@@ -2327,6 +2327,88 @@ TEST(Cast, FSLToFSLOptionsPassThru) {
   CheckCast(fsl_int32, ArrayFromJSON(fixed_size_list(int16(), 1), "[[32689]]"), options);
 }
 
+void CheckCastList(const std::shared_ptr<DataType>& from_type,
+                   const std::shared_ptr<DataType>& to_type,
+                   const std::string& json_data) {
+  CheckCast(ArrayFromJSON(from_type, json_data), ArrayFromJSON(to_type, json_data));
+}
+
+TEST(Cast, FSLToList) {
+  CheckCastList(fixed_size_list(int16(), 2), list(int16()),
+                "[[0, 1], [2, 3], [null, 5], null]");
+  // Large variant
+  CheckCastList(fixed_size_list(int16(), 2), large_list(int16()),
+                "[[0, 1], [2, 3], [null, 5], null]");
+  // Different child types
+  CheckCastList(fixed_size_list(int16(), 2), list(int32()),
+                "[[0, 1], [2, 3], [null, 5], null]");
+  // No nulls
+  CheckCastList(fixed_size_list(int16(), 2), list(int32()), "[[0, 1], [2, 3], [4, 5]]");
+  // Nested lists
+  CheckCastList(fixed_size_list(list(int16()), 2), list(list(int32())),
+                "[[[0, 1], [2, 3]], [[4, 5], null]]");
+  // Sliced children (top-level slicing handled in CheckCast)
+  auto children_src = ArrayFromJSON(int32(), "[1, 2, null, 4, 5, null]");
+  children_src = children_src->Slice(2);
+  auto from =
+      std::make_shared<FixedSizeListArray>(fixed_size_list(int32(), 2), 2, children_src);
+  auto to = ArrayFromJSON(list(int32()), "[[null, 4], [5, null]]");
+  CheckCast(from, to);
+  // Options pass through
+  auto fsl_int32 = ArrayFromJSON(fixed_size_list(int32(), 1), "[[87654321]]");
+  auto options = CastOptions::Safe(list(int16()));
+  CheckCastFails(fsl_int32, options);
+  options.allow_int_overflow = true;
+  CheckCast(fsl_int32, ArrayFromJSON(fixed_size_list(int16(), 1), "[[32689]]"), options);
+}
+
+TEST(Cast, ListToFSL) {
+  CheckCastList(list(int16()), fixed_size_list(int16(), 2),
+                "[[0, 1], [2, 3], null, [null, 5], null]");
+  // Large variant
+  CheckCastList(large_list(int16()), fixed_size_list(int16(), 2),
+                "[[0, 1], [2, 3], null, [null, 5], null]");
+  // Different child types
+  CheckCastList(list(int32()), fixed_size_list(int16(), 2),
+                "[[0, 1], [2, 3], null, [null, 5], null]");
+  // No nulls
+  CheckCastList(list(int32()), fixed_size_list(int16(), 2), "[[0, 1], [2, 3], [4, 5]]");
+  // Nested lists
+  CheckCastList(list(list(int32())), fixed_size_list(list(int16()), 2),
+                "[[[0, 1], [2, 3]], [[4, 5], null]]");
+  // Sliced children (top-level slicing handled in CheckCast)
+  {
+    auto children_src = ArrayFromJSON(int32(), "[1, 2, null, 4, 5, null]");
+    children_src = children_src->Slice(2);
+    ASSERT_OK_AND_ASSIGN(
+        auto from,
+        ListArray::FromArrays(*ArrayFromJSON(int32(), "[0, 2, 4]"), *children_src));
+    auto to = ArrayFromJSON(fixed_size_list(int32(), 2), "[[null, 4], [5, null]]");
+    CheckCast(from, to);
+  }
+
+  // Null slots with non-zero size
+  {
+    auto from = MaskArrayWithNullsAt(
+        ArrayFromJSON(list(int32()), "[[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]"),
+        {1, 2, 4});
+    auto to =
+        ArrayFromJSON(fixed_size_list(int32(), 2), "[[0, 1], null, null, [6, 7], null]");
+    CheckCast(from, to);
+  }
+
+  // Options pass through
+  auto fsl_int32 = ArrayFromJSON(fixed_size_list(int32(), 1), "[[87654321]]");
+  auto options = CastOptions::Safe(list(int16()));
+  CheckCastFails(fsl_int32, options);
+  options.allow_int_overflow = true;
+  CheckCast(fsl_int32, ArrayFromJSON(fixed_size_list(int16(), 1), "[[32689]]"), options);
+
+  // Invalid fixed_size_list cast if inconsistent size
+  ASSERT_RAISES(Invalid, Cast(ArrayFromJSON(list(int32()), "[[0, 1, 2], null, [3, 4]]"),
+                              CastOptions::Safe(fixed_size_list(int32(), 3))));
+}
+
 TEST(Cast, CastMap) {
   const std::string map_json =
       "[[[\"x\", 1], [\"y\", 8], [\"z\", 9]], [[\"x\", 6]], [[\"y\", 36]]]";

From ee2122b6f59f252ed3915e89197e31964d023e09 Mon Sep 17 00:00:00 2001
From: Val Gridnev <87963219+valri11@users.noreply.github.com>
Date: Thu, 24 Aug 2023 03:31:53 +1000
Subject: [PATCH 221/749] MINOR: [Go] Add LazyQuotes parsing option to CSV
 reader (#37304)

### Rationale for this change

CSV data could have quotes inside of column data. Go csv package handles this with LazyQuotes flag.
PR adds option to set this flag.

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

Authored-by: Valery Gridnev <valer.gr@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/csv/common.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/go/arrow/csv/common.go b/go/arrow/csv/common.go
index bdc18f2fbea90..91f42897a24a6 100644
--- a/go/arrow/csv/common.go
+++ b/go/arrow/csv/common.go
@@ -118,6 +118,18 @@ func WithHeader(useHeader bool) Option {
 	}
 }
 
+// WithLazyQuotes sets csv parsing option to LazyQuotes
+func WithLazyQuotes(useLazyQuotes bool) Option {
+	return func(cfg config) {
+		switch cfg := cfg.(type) {
+		case *Reader:
+			cfg.r.LazyQuotes = useLazyQuotes
+		default:
+			panic(fmt.Errorf("arrow/csv: unknown config type %T", cfg))
+		}
+	}
+}
+
 // DefaultNullValues is the set of values considered as NULL values by default
 // when Reader is configured to handle NULL values.
 var DefaultNullValues = []string{"", "NULL", "null"}

From b6ab9092af14bbd96755a88b5cdcfcb1a212c840 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Wed, 23 Aug 2023 13:33:57 -0400
Subject: [PATCH 222/749] GH-37093: [Python] Add async Flight client with
 GetFlightInfo  (#36986)

### Rationale for this change

Demonstrate how to deal with async Flight from Python.

### What changes are included in this PR?

Add bindings for GetFlightInfo.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes, new APIs.

* Closes: #37093

Lead-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/flight/client.cc                |   4 +-
 cpp/src/arrow/flight/client.h                 |   7 ++
 cpp/src/arrow/flight/test_definitions.cc      |   2 +
 cpp/src/arrow/flight/transport.h              |   6 +-
 .../flight/transport/grpc/grpc_client.cc      |   9 +-
 python/pyarrow/_flight.pyx                    |  74 ++++++++++++
 python/pyarrow/error.pxi                      | 113 ++++++++++--------
 python/pyarrow/includes/common.pxd            |  14 +++
 python/pyarrow/includes/libarrow_flight.pxd   |   5 +
 python/pyarrow/includes/libarrow_python.pxd   |   2 +-
 python/pyarrow/lib.pxd                        |   1 +
 python/pyarrow/src/arrow/python/async.h       |  60 ++++++++++
 python/pyarrow/src/arrow/python/common.h      |  44 +++++++
 python/pyarrow/src/arrow/python/pyarrow.cc    |   6 +
 python/pyarrow/src/arrow/python/pyarrow.h     |   5 +
 python/pyarrow/tests/test_flight_async.py     |  93 ++++++++++++++
 16 files changed, 388 insertions(+), 57 deletions(-)
 create mode 100644 python/pyarrow/src/arrow/python/async.h
 create mode 100644 python/pyarrow/tests/test_flight_async.py

diff --git a/cpp/src/arrow/flight/client.cc b/cpp/src/arrow/flight/client.cc
index f8dd4ba549ff3..25da5e8007660 100644
--- a/cpp/src/arrow/flight/client.cc
+++ b/cpp/src/arrow/flight/client.cc
@@ -722,7 +722,9 @@ Status FlightClient::Close() {
   return Status::OK();
 }
 
-bool FlightClient::supports_async() const { return transport_->supports_async(); }
+bool FlightClient::supports_async() const { return transport_->CheckAsyncSupport().ok(); }
+
+Status FlightClient::CheckAsyncSupport() const { return transport_->CheckAsyncSupport(); }
 
 Status FlightClient::CheckOpen() const {
   if (closed_) {
diff --git a/cpp/src/arrow/flight/client.h b/cpp/src/arrow/flight/client.h
index 705b36c23cebe..e26a821359781 100644
--- a/cpp/src/arrow/flight/client.h
+++ b/cpp/src/arrow/flight/client.h
@@ -396,6 +396,13 @@ class ARROW_FLIGHT_EXPORT FlightClient {
   /// \brief Whether this client supports asynchronous methods.
   bool supports_async() const;
 
+  /// \brief Check whether this client supports asynchronous methods.
+  ///
+  /// This is like supports_async(), except that a detailed error message
+  /// is returned if async support is not available.  If async support is
+  /// available, this function returns successfully.
+  Status CheckAsyncSupport() const;
+
  private:
   FlightClient();
   Status CheckOpen() const;
diff --git a/cpp/src/arrow/flight/test_definitions.cc b/cpp/src/arrow/flight/test_definitions.cc
index 55be3244fbde4..c84c5a18ff468 100644
--- a/cpp/src/arrow/flight/test_definitions.cc
+++ b/cpp/src/arrow/flight/test_definitions.cc
@@ -1832,7 +1832,9 @@ void AsyncClientTest::SetUpTest() {
   ASSERT_OK_AND_ASSIGN(client_, FlightClient::Connect(real_location, client_options));
 
   ASSERT_TRUE(client_->supports_async());
+  ASSERT_OK(client_->CheckAsyncSupport());
 }
+
 void AsyncClientTest::TearDownTest() {
   if (supports_async()) {
     ASSERT_OK(client_->Close());
diff --git a/cpp/src/arrow/flight/transport.h b/cpp/src/arrow/flight/transport.h
index 8cb2479d113fc..ee7bd01720730 100644
--- a/cpp/src/arrow/flight/transport.h
+++ b/cpp/src/arrow/flight/transport.h
@@ -201,7 +201,11 @@ class ARROW_FLIGHT_EXPORT ClientTransport {
   virtual Status DoExchange(const FlightCallOptions& options,
                             std::unique_ptr<ClientDataStream>* stream);
 
-  virtual bool supports_async() const { return false; }
+  bool supports_async() const { return CheckAsyncSupport().ok(); }
+  virtual Status CheckAsyncSupport() const {
+    return Status::NotImplemented(
+        "this Flight transport does not support async operations");
+  }
 
   static void SetAsyncRpc(AsyncListenerBase* listener, std::unique_ptr<AsyncRpc>&& rpc);
   static AsyncRpc* GetAsyncRpc(AsyncListenerBase* listener);
diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
index 5baf687cd83dc..f7612759e8de6 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_client.cc
@@ -1034,16 +1034,17 @@ class GrpcClientImpl : public internal::ClientTransport {
         ->StartCall();
   }
 
-  bool supports_async() const override { return true; }
+  Status CheckAsyncSupport() const override { return Status::OK(); }
 #else
   void GetFlightInfoAsync(const FlightCallOptions& options,
                           const FlightDescriptor& descriptor,
                           std::shared_ptr<AsyncListener<FlightInfo>> listener) override {
-    listener->OnFinish(
-        Status::NotImplemented("gRPC 1.40 or newer is required to use async"));
+    listener->OnFinish(CheckAsyncSupport());
   }
 
-  bool supports_async() const override { return false; }
+  Status CheckAsyncSupport() const override {
+    return Status::NotImplemented("gRPC 1.40 or newer is required to use async");
+  }
 #endif
 
  private:
diff --git a/python/pyarrow/_flight.pyx b/python/pyarrow/_flight.pyx
index 0572ed77b40ef..42b221ed72a1b 100644
--- a/python/pyarrow/_flight.pyx
+++ b/python/pyarrow/_flight.pyx
@@ -837,6 +837,12 @@ cdef class FlightInfo(_Weakrefable):
     cdef:
         unique_ptr[CFlightInfo] info
 
+    @staticmethod
+    cdef wrap(CFlightInfo c_info):
+        cdef FlightInfo obj = FlightInfo.__new__(FlightInfo)
+        obj.info.reset(new CFlightInfo(move(c_info)))
+        return obj
+
     def __init__(self, Schema schema, FlightDescriptor descriptor, endpoints,
                  total_records, total_bytes):
         """Create a FlightInfo object from a schema, descriptor, and endpoints.
@@ -1219,6 +1225,66 @@ cdef class FlightMetadataWriter(_Weakrefable):
             check_flight_status(self.writer.get().WriteMetadata(deref(buf)))
 
 
+class AsyncioCall:
+    """State for an async RPC using asyncio."""
+
+    def __init__(self) -> None:
+        import asyncio
+        self._future = asyncio.get_running_loop().create_future()
+
+    def as_awaitable(self) -> object:
+        return self._future
+
+    def wakeup(self, result_or_exception) -> None:
+        # Mark the Future done from within its loop (asyncio
+        # objects are generally not thread-safe)
+        loop = self._future.get_loop()
+        if isinstance(result_or_exception, BaseException):
+            loop.call_soon_threadsafe(
+                self._future.set_exception, result_or_exception)
+        else:
+            loop.call_soon_threadsafe(
+                self._future.set_result, result_or_exception)
+
+
+cdef class AsyncioFlightClient:
+    """
+    A FlightClient with an asyncio-based async interface.
+
+    This interface is EXPERIMENTAL.
+    """
+
+    cdef:
+        FlightClient _client
+
+    def __init__(self, FlightClient client) -> None:
+        self._client = client
+
+    async def get_flight_info(
+        self,
+        descriptor: FlightDescriptor,
+        *,
+        options: FlightCallOptions = None,
+    ):
+        call = AsyncioCall()
+        self._get_flight_info(call, descriptor, options)
+        return await call.as_awaitable()
+
+    cdef _get_flight_info(self, call, descriptor, options):
+        cdef:
+            CFlightCallOptions* c_options = \
+                FlightCallOptions.unwrap(options)
+            CFlightDescriptor c_descriptor = \
+                FlightDescriptor.unwrap(descriptor)
+            CFuture[CFlightInfo] c_future
+
+        with nogil:
+            c_future = self._client.client.get().GetFlightInfoAsync(
+                deref(c_options), c_descriptor)
+
+        BindFuture(move(c_future), call.wakeup, FlightInfo.wrap)
+
+
 cdef class FlightClient(_Weakrefable):
     """A client to a Flight service.
 
@@ -1320,6 +1386,14 @@ cdef class FlightClient(_Weakrefable):
             check_flight_status(CFlightClient.Connect(c_location, c_options
                                                       ).Value(&self.client))
 
+    @property
+    def supports_async(self):
+        return self.client.get().supports_async()
+
+    def as_async(self) -> None:
+        check_status(self.client.get().CheckAsyncSupport())
+        return AsyncioFlightClient(self)
+
     def wait_for_available(self, timeout=5):
         """Block until the server can be contacted.
 
diff --git a/python/pyarrow/error.pxi b/python/pyarrow/error.pxi
index 46ea021ebf634..4357cde32c31d 100644
--- a/python/pyarrow/error.pxi
+++ b/python/pyarrow/error.pxi
@@ -77,8 +77,8 @@ class ArrowCancelled(ArrowException):
 ArrowIOError = IOError
 
 
-# This function could be written directly in C++ if we didn't
-# define Arrow-specific subclasses (ArrowInvalid etc.)
+# check_status() and convert_status() could be written directly in C++
+# if we didn't define Arrow-specific subclasses (ArrowInvalid etc.)
 cdef int check_status(const CStatus& status) except -1 nogil:
     if status.ok():
         return 0
@@ -88,61 +88,74 @@ cdef int check_status(const CStatus& status) except -1 nogil:
             RestorePyError(status)
             return -1
 
-        # We don't use Status::ToString() as it would redundantly include
-        # the C++ class name.
-        message = frombytes(status.message(), safe=True)
-        detail = status.detail()
-        if detail != nullptr:
-            message += ". Detail: " + frombytes(detail.get().ToString(),
-                                                safe=True)
-
-        if status.IsInvalid():
-            raise ArrowInvalid(message)
-        elif status.IsIOError():
-            # Note: OSError constructor is
-            #   OSError(message)
-            # or
-            #   OSError(errno, message, filename=None)
-            # or (on Windows)
-            #   OSError(errno, message, filename, winerror)
-            errno = ErrnoFromStatus(status)
-            winerror = WinErrorFromStatus(status)
-            if winerror != 0:
-                raise IOError(errno, message, None, winerror)
-            elif errno != 0:
-                raise IOError(errno, message)
-            else:
-                raise IOError(message)
-        elif status.IsOutOfMemory():
-            raise ArrowMemoryError(message)
-        elif status.IsKeyError():
-            raise ArrowKeyError(message)
-        elif status.IsNotImplemented():
-            raise ArrowNotImplementedError(message)
-        elif status.IsTypeError():
-            raise ArrowTypeError(message)
-        elif status.IsCapacityError():
-            raise ArrowCapacityError(message)
-        elif status.IsIndexError():
-            raise ArrowIndexError(message)
-        elif status.IsSerializationError():
-            raise ArrowSerializationError(message)
-        elif status.IsCancelled():
-            signum = SignalFromStatus(status)
-            if signum > 0:
-                raise ArrowCancelled(message, signum)
-            else:
-                raise ArrowCancelled(message)
+        raise convert_status(status)
+
+
+cdef object convert_status(const CStatus& status):
+    if IsPyError(status):
+        try:
+            RestorePyError(status)
+        except BaseException as e:
+            return e
+
+    # We don't use Status::ToString() as it would redundantly include
+    # the C++ class name.
+    message = frombytes(status.message(), safe=True)
+    detail = status.detail()
+    if detail != nullptr:
+        message += ". Detail: " + frombytes(detail.get().ToString(),
+                                            safe=True)
+
+    if status.IsInvalid():
+        return ArrowInvalid(message)
+    elif status.IsIOError():
+        # Note: OSError constructor is
+        #   OSError(message)
+        # or
+        #   OSError(errno, message, filename=None)
+        # or (on Windows)
+        #   OSError(errno, message, filename, winerror)
+        errno = ErrnoFromStatus(status)
+        winerror = WinErrorFromStatus(status)
+        if winerror != 0:
+            return IOError(errno, message, None, winerror)
+        elif errno != 0:
+            return IOError(errno, message)
+        else:
+            return IOError(message)
+    elif status.IsOutOfMemory():
+        return ArrowMemoryError(message)
+    elif status.IsKeyError():
+        return ArrowKeyError(message)
+    elif status.IsNotImplemented():
+        return ArrowNotImplementedError(message)
+    elif status.IsTypeError():
+        return ArrowTypeError(message)
+    elif status.IsCapacityError():
+        return ArrowCapacityError(message)
+    elif status.IsIndexError():
+        return ArrowIndexError(message)
+    elif status.IsSerializationError():
+        return ArrowSerializationError(message)
+    elif status.IsCancelled():
+        signum = SignalFromStatus(status)
+        if signum > 0:
+            return ArrowCancelled(message, signum)
         else:
-            message = frombytes(status.ToString(), safe=True)
-            raise ArrowException(message)
+            return ArrowCancelled(message)
+    else:
+        message = frombytes(status.ToString(), safe=True)
+        return ArrowException(message)
 
 
-# This is an API function for C++ PyArrow
+# These are API functions for C++ PyArrow
 cdef api int pyarrow_internal_check_status(const CStatus& status) \
         except -1 nogil:
     return check_status(status)
 
+cdef api object pyarrow_internal_convert_status(const CStatus& status):
+    return convert_status(status)
+
 
 cdef class StopToken:
     cdef void init(self, CStopToken stop_token):
diff --git a/python/pyarrow/includes/common.pxd b/python/pyarrow/includes/common.pxd
index 9e139be3e5918..044dd0333f323 100644
--- a/python/pyarrow/includes/common.pxd
+++ b/python/pyarrow/includes/common.pxd
@@ -149,6 +149,20 @@ cdef extern from "arrow/result.h" namespace "arrow" nogil:
         T operator*()
 
 
+cdef extern from "arrow/util/future.h" namespace "arrow" nogil:
+    cdef cppclass CFuture "arrow::Future"[T]:
+        CFuture()
+
+
+cdef extern from "arrow/python/async.h" namespace "arrow::py" nogil:
+    # BindFuture's third argument is really a C++ callable with
+    # the signature `object(T*)`, but Cython does not allow declaring that.
+    # We use an ellipsis as a workaround.
+    # Another possibility is to type-erase the argument by making it
+    # `object(void*)`, but it would lose compile-time C++ type safety.
+    void BindFuture[T](CFuture[T], object cb, ...)
+
+
 cdef extern from "arrow/python/common.h" namespace "arrow::py" nogil:
     T GetResultValue[T](CResult[T]) except *
     cdef function[F] BindFunction[F](void* unbound, object bound, ...)
diff --git a/python/pyarrow/includes/libarrow_flight.pxd b/python/pyarrow/includes/libarrow_flight.pxd
index 624904ed77a69..4bddd2d080f5f 100644
--- a/python/pyarrow/includes/libarrow_flight.pxd
+++ b/python/pyarrow/includes/libarrow_flight.pxd
@@ -382,6 +382,9 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
         CResult[unique_ptr[CFlightClient]] Connect(const CLocation& location,
                                                    const CFlightClientOptions& options)
 
+        c_bool supports_async()
+        CStatus CheckAsyncSupport()
+
         CStatus Authenticate(CFlightCallOptions& options,
                              unique_ptr[CClientAuthHandler] auth_handler)
 
@@ -396,6 +399,8 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
         CResult[unique_ptr[CFlightListing]] ListFlights(CFlightCallOptions& options, CCriteria criteria)
         CResult[unique_ptr[CFlightInfo]] GetFlightInfo(CFlightCallOptions& options,
                                                        CFlightDescriptor& descriptor)
+        CFuture[CFlightInfo] GetFlightInfoAsync(CFlightCallOptions& options,
+                                                CFlightDescriptor& descriptor)
         CResult[unique_ptr[CSchemaResult]] GetSchema(CFlightCallOptions& options,
                                                      CFlightDescriptor& descriptor)
         CResult[unique_ptr[CFlightStreamReader]] DoGet(CFlightCallOptions& options, CTicket& ticket)
diff --git a/python/pyarrow/includes/libarrow_python.pxd b/python/pyarrow/includes/libarrow_python.pxd
index f08fcaa40d104..4d109fc660e08 100644
--- a/python/pyarrow/includes/libarrow_python.pxd
+++ b/python/pyarrow/includes/libarrow_python.pxd
@@ -258,7 +258,7 @@ cdef extern from "arrow/python/pyarrow.h" namespace "arrow::py":
 
 cdef extern from "arrow/python/common.h" namespace "arrow::py":
     c_bool IsPyError(const CStatus& status)
-    void RestorePyError(const CStatus& status)
+    void RestorePyError(const CStatus& status) except *
 
 
 cdef extern from "arrow/python/inference.h" namespace "arrow::py":
diff --git a/python/pyarrow/lib.pxd b/python/pyarrow/lib.pxd
index e8c89cf0d56dc..63ebe6aea8233 100644
--- a/python/pyarrow/lib.pxd
+++ b/python/pyarrow/lib.pxd
@@ -65,6 +65,7 @@ cdef extern from "Python.h":
 
 
 cdef int check_status(const CStatus& status) except -1 nogil
+cdef object convert_status(const CStatus& status)
 
 
 cdef class _Weakrefable:
diff --git a/python/pyarrow/src/arrow/python/async.h b/python/pyarrow/src/arrow/python/async.h
new file mode 100644
index 0000000000000..1568d21938e6e
--- /dev/null
+++ b/python/pyarrow/src/arrow/python/async.h
@@ -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.
+
+#pragma once
+
+#include <utility>
+
+#include "arrow/python/common.h"
+#include "arrow/status.h"
+#include "arrow/util/future.h"
+
+namespace arrow::py {
+
+/// \brief Bind a Python callback to an arrow::Future.
+///
+/// If the Future finishes successfully, py_wrapper is called with its
+/// result value and should return a PyObject*. If py_wrapper is successful,
+/// py_cb is called with its return value.
+///
+/// If either the Future or py_wrapper fails, py_cb is called with the
+/// associated Python exception.
+///
+/// \param future The future to bind to.
+/// \param py_cb The Python callback function. Will be passed the result of
+///   py_wrapper, or a Python exception if the future failed or one was
+///   raised by py_wrapper.
+/// \param py_wrapper A function (likely defined in Cython) to convert the C++
+///   result of the future to a Python object.
+template <typename T, typename PyWrapper = PyObject* (*)(T)>
+void BindFuture(Future<T> future, PyObject* py_cb, PyWrapper py_wrapper) {
+  Py_INCREF(py_cb);
+  OwnedRefNoGIL cb_ref(py_cb);
+
+  auto future_cb = [cb_ref = std::move(cb_ref),
+                    py_wrapper = std::move(py_wrapper)](Result<T> result) {
+    SafeCallIntoPythonVoid([&]() {
+      OwnedRef py_value_or_exc{WrapResult(std::move(result), std::move(py_wrapper))};
+      Py_XDECREF(
+          PyObject_CallFunctionObjArgs(cb_ref.obj(), py_value_or_exc.obj(), NULLPTR));
+      ARROW_WARN_NOT_OK(CheckPyError(), "Internal error in async call");
+    });
+  };
+  future.AddCallback(std::move(future_cb));
+}
+
+}  // namespace arrow::py
diff --git a/python/pyarrow/src/arrow/python/common.h b/python/pyarrow/src/arrow/python/common.h
index bfd11ba702a84..e36c0834fd424 100644
--- a/python/pyarrow/src/arrow/python/common.h
+++ b/python/pyarrow/src/arrow/python/common.h
@@ -72,6 +72,37 @@ T GetResultValue(Result<T> result) {
   }
 }
 
+/// \brief Wrap a Result and return the corresponding Python object.
+///
+/// If the Result is successful, py_wrapper is called with its result value
+/// and should return a PyObject*. If py_wrapper is successful (returns
+/// a non-NULL value), its return value is returned.
+///
+/// If either the Result or py_wrapper fails, the associated Python exception
+/// is raised and NULL is returned.
+//
+/// \param result The Result whose value to wrap in a Python object.
+/// \param py_wrapper A function (likely defined in Cython) to convert the C++
+///   value of the Result to a Python object.
+/// \return A new Python reference, or NULL if an exception occurred
+template <typename T, typename PyWrapper = PyObject* (*)(T)>
+PyObject* WrapResult(Result<T> result, PyWrapper&& py_wrapper) {
+  static_assert(std::is_same_v<PyObject*, decltype(py_wrapper(std::declval<T>()))>,
+                "PyWrapper argument to WrapResult should return a PyObject* "
+                "when called with a T*");
+  Status st = result.status();
+  if (st.ok()) {
+    PyObject* py_value = py_wrapper(result.MoveValueUnsafe());
+    st = CheckPyError();
+    if (st.ok()) {
+      return py_value;
+    }
+    Py_XDECREF(py_value);  // should be null, but who knows
+  }
+  // Status is an error, convert it to an exception.
+  return internal::convert_status(st);
+}
+
 // A RAII-style helper that ensures the GIL is acquired inside a lexical block.
 class ARROW_PYTHON_EXPORT PyAcquireGIL {
  public:
@@ -131,6 +162,19 @@ auto SafeCallIntoPython(Function&& func) -> decltype(func()) {
   return maybe_status;
 }
 
+template <typename Function>
+auto SafeCallIntoPythonVoid(Function&& func) -> decltype(func()) {
+  PyAcquireGIL lock;
+  PyObject* exc_type;
+  PyObject* exc_value;
+  PyObject* exc_traceback;
+  PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+  func();
+  if (exc_type != NULLPTR) {
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+  }
+}
+
 // A RAII primitive that DECREFs the underlying PyObject* when it
 // goes out of scope.
 class ARROW_PYTHON_EXPORT OwnedRef {
diff --git a/python/pyarrow/src/arrow/python/pyarrow.cc b/python/pyarrow/src/arrow/python/pyarrow.cc
index 30d1f04f12317..af0fbbad1f74b 100644
--- a/python/pyarrow/src/arrow/python/pyarrow.cc
+++ b/python/pyarrow/src/arrow/python/pyarrow.cc
@@ -24,6 +24,7 @@
 #include "arrow/table.h"
 #include "arrow/tensor.h"
 #include "arrow/type.h"
+#include "arrow/util/logging.h"
 
 #include "arrow/python/common.h"
 #include "arrow/python/datetime.h"
@@ -89,6 +90,11 @@ namespace internal {
 
 int check_status(const Status& status) { return ::pyarrow_internal_check_status(status); }
 
+PyObject* convert_status(const Status& status) {
+  DCHECK(!status.ok());
+  return ::pyarrow_internal_convert_status(status);
+}
+
 }  // namespace internal
 }  // namespace py
 }  // namespace arrow
diff --git a/python/pyarrow/src/arrow/python/pyarrow.h b/python/pyarrow/src/arrow/python/pyarrow.h
index 4c365081d70ca..113035500c005 100644
--- a/python/pyarrow/src/arrow/python/pyarrow.h
+++ b/python/pyarrow/src/arrow/python/pyarrow.h
@@ -75,8 +75,13 @@ DECLARE_WRAP_FUNCTIONS(table, Table)
 
 namespace internal {
 
+// If status is ok, return 0.
+// If status is not ok, set Python error indicator and return -1.
 ARROW_PYTHON_EXPORT int check_status(const Status& status);
 
+// Convert status to a Python exception object.  Status must not be ok.
+ARROW_PYTHON_EXPORT PyObject* convert_status(const Status& status);
+
 }  // namespace internal
 }  // namespace py
 }  // namespace arrow
diff --git a/python/pyarrow/tests/test_flight_async.py b/python/pyarrow/tests/test_flight_async.py
new file mode 100644
index 0000000000000..f3cd1bbb58e2f
--- /dev/null
+++ b/python/pyarrow/tests/test_flight_async.py
@@ -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.
+
+import asyncio
+
+import pytest
+
+import pyarrow
+
+flight = pytest.importorskip("pyarrow.flight")
+pytestmark = pytest.mark.flight
+
+
+class ExampleServer(flight.FlightServerBase):
+    simple_info = flight.FlightInfo(
+        pyarrow.schema([("a", "int32")]),
+        flight.FlightDescriptor.for_command(b"simple"),
+        [],
+        -1,
+        -1,
+    )
+
+    def get_flight_info(self, context, descriptor):
+        if descriptor.command == b"simple":
+            return self.simple_info
+        elif descriptor.command == b"unknown":
+            raise NotImplementedError("Unknown command")
+
+        raise NotImplementedError("Unknown descriptor")
+
+
+def async_or_skip(client):
+    if not client.supports_async:
+        # Use async error message as skip message
+        with pytest.raises(NotImplementedError) as e:
+            client.as_async()
+        pytest.skip(str(e.value))
+
+
+@pytest.fixture(scope="module")
+def flight_client():
+    with ExampleServer() as server:
+        with flight.connect(f"grpc://localhost:{server.port}") as client:
+            yield client
+
+
+@pytest.fixture(scope="module")
+def async_client(flight_client):
+    async_or_skip(flight_client)
+    yield flight_client.as_async()
+
+
+def test_async_support_property(flight_client):
+    assert isinstance(flight_client.supports_async, bool)
+    if flight_client.supports_async:
+        flight_client.as_async()
+    else:
+        with pytest.raises(NotImplementedError):
+            flight_client.as_async()
+
+
+def test_get_flight_info(async_client):
+    async def _test():
+        descriptor = flight.FlightDescriptor.for_command(b"simple")
+        info = await async_client.get_flight_info(descriptor)
+        assert info == ExampleServer.simple_info
+
+    asyncio.run(_test())
+
+
+def test_get_flight_info_error(async_client):
+    async def _test():
+        descriptor = flight.FlightDescriptor.for_command(b"unknown")
+        with pytest.raises(NotImplementedError) as excinfo:
+            await async_client.get_flight_info(descriptor)
+
+        assert "Unknown command" in repr(excinfo.value)
+
+    asyncio.run(_test())

From 6837d0595153b3a20b9a9fa63d4149115a1987c2 Mon Sep 17 00:00:00 2001
From: Spencer Nelson <spencer@b612foundation.org>
Date: Wed, 23 Aug 2023 11:13:33 -0700
Subject: [PATCH 223/749] GH-35740: Add documentation for list arrays' values
 property (#35865)

Just docs.

I'm a little shaky on my understanding of exactly what's going on with FixedSizeListArray.values, and its behavior with nulls, so that wording might deserve a careful read.
* Closes: #35740

Lead-authored-by: Spencer Nelson <spencer@b612foundation.org>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/array.pxi | 172 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 171 insertions(+), 1 deletion(-)

diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index ce4eafd8e30fb..e26b1ad3291b5 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -1964,7 +1964,7 @@ cdef class BaseListArray(Array):
         The returned Array is logically a concatenation of all the sub-lists
         in this Array.
 
-        Note that this method is different from ``self.values()`` in that
+        Note that this method is different from ``self.values`` in that
         it takes care of the slicing offset as well as null elements backed
         by non-empty sub-lists.
 
@@ -2103,6 +2103,72 @@ cdef class ListArray(BaseListArray):
 
     @property
     def values(self):
+        """
+        Return the underlying array of values which backs the ListArray
+        ignoring the array's offset.
+
+        If any of the list elements are null, but are backed by a
+        non-empty sub-list, those elements will be included in the
+        output.
+
+        Compare with :meth:`flatten`, which returns only the non-null
+        values taking into consideration the array's offset.
+
+        Returns
+        -------
+        values : Array
+
+        See Also
+        --------
+        ListArray.flatten : ...
+
+        Examples
+        --------
+
+        The values include null elements from sub-lists:
+
+        >>> import pyarrow as pa
+        >>> array = pa.array([[1, 2], None, [3, 4, None, 6]])
+        >>> array.values
+        <pyarrow.lib.Int64Array object at ...>
+        [
+          1,
+          2,
+          3,
+          4,
+          null,
+          6
+        ]
+
+        If an array is sliced, the slice still uses the same
+        underlying data as the original array, just with an
+        offset. Since values ignores the offset, the values are the
+        same:
+
+        >>> sliced = array.slice(1, 2)
+        >>> sliced
+        <pyarrow.lib.ListArray object at ...>
+        [
+          null,
+          [
+            3,
+            4,
+            null,
+            6
+          ]
+        ]
+        >>> sliced.values
+        <pyarrow.lib.Int64Array object at ...>
+        [
+          1,
+          2,
+          3,
+          4,
+          null,
+          6
+        ]
+
+        """
         cdef CListArray* arr = <CListArray*> self.ap
         return pyarrow_wrap_array(arr.values())
 
@@ -2190,6 +2256,74 @@ cdef class LargeListArray(BaseListArray):
 
     @property
     def values(self):
+        """
+        Return the underlying array of values which backs the LargeListArray
+        ignoring the array's offset.
+
+        If any of the list elements are null, but are backed by a
+        non-empty sub-list, those elements will be included in the
+        output.
+
+        Compare with :meth:`flatten`, which returns only the non-null
+        values taking into consideration the array's offset.
+
+        Returns
+        -------
+        values : Array
+
+        See Also
+        --------
+        LargeListArray.flatten : ...
+
+        Examples
+        --------
+
+        The values include null elements from the sub-lists:
+
+        >>> import pyarrow as pa
+        >>> array = pa.array(
+        ...     [[1, 2], None, [3, 4, None, 6]],
+        ...     type=pa.large_list(pa.int32()),
+        ... )
+        >>> array.values
+        <pyarrow.lib.Int32Array object at ...>
+        [
+          1,
+          2,
+          3,
+          4,
+          null,
+          6
+        ]
+
+        If an array is sliced, the slice still uses the same
+        underlying data as the original array, just with an
+        offset. Since values ignores the offset, the values are the
+        same:
+
+        >>> sliced = array.slice(1, 2)
+        >>> sliced
+        <pyarrow.lib.LargeListArray object at ...>
+        [
+          null,
+          [
+            3,
+            4,
+            null,
+            6
+          ]
+        ]
+        >>> sliced.values
+        <pyarrow.lib.Int32Array object at ...>
+        [
+          1,
+          2,
+          3,
+          4,
+          null,
+          6
+        ]
+        """
         cdef CLargeListArray* arr = <CLargeListArray*> self.ap
         return pyarrow_wrap_array(arr.values())
 
@@ -2346,6 +2480,42 @@ cdef class FixedSizeListArray(BaseListArray):
 
     @property
     def values(self):
+        """
+        Return the underlying array of values which backs the
+        FixedSizeListArray.
+
+        Note even null elements are included.
+
+        Compare with :meth:`flatten`, which returns only the non-null
+        sub-list values.
+
+        Returns
+        -------
+        values : Array
+
+        See Also
+        --------
+        FixedSizeListArray.flatten : ...
+
+        Examples
+        --------
+        >>> import pyarrow as pa
+        >>> array = pa.array(
+        ...     [[1, 2], None, [3, None]],
+        ...     type=pa.list_(pa.int32(), 2)
+        ... )
+        >>> array.values
+        <pyarrow.lib.Int32Array object at ...>
+        [
+          1,
+          2,
+          null,
+          null,
+          3,
+          null
+        ]
+
+        """
         cdef CFixedSizeListArray* arr = <CFixedSizeListArray*> self.ap
         return pyarrow_wrap_array(arr.values())
 

From 91a492757a2ebbe338258ecc1bcbd854e1fc7370 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 23 Aug 2023 17:14:51 -0400
Subject: [PATCH 224/749] GH-37340: [MATLAB] The `column(index)` method of
 `arrow.tabular.RecordBatch` errors if `index` refers to an
 `arrow.array.Time32Array` column (#37347)

### Rationale for this change

The `column(index)` method of `arrow.tabular.RecordBatch` errors  if `index` refers to an `arrow.array.Time32Array` column.

```matlab
>> string = arrow.array(["A", "B", "C"]);
>> time32 = arrow.array.Time32Array.fromMATLAB(seconds(1:3));
>> rb = arrow.tabular.RecordBatch.fromArrays(string, time32, ColumnNames=["String", "Time32"])

rb =

String:   [
    "A",
    "B",
    "C"
  ]
Time32:   [
    00:00:01,
    00:00:02,
    00:00:03
  ]

>> time32Column = rb.column(2)

Error using  .
Unsupported DataType: time32[s]

Error in arrow.tabular.RecordBatch/column (line 63)
            [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);
```

`column(index)` is throwing this error because the case for `Time32` was not added to `arrow::matlab::array::proxy::wrap(arrowArray)` in #37315. `column(index)` calls this function to create proxy objects around existing arrow arrays. Adding the case for `Time32` will resolve this bug.

### What changes are included in this PR?

1. Updated `arrow::Result<proxy::Array> wrap(const std::shared_ptr<arrow::Array>& array)` to handle wrapping `arrow::Time32Array` instances within `proxy::Time32Array`s.
2. Added a new test utility called `arrow.internal.test.tabular.createAllSupportedArrayTypes`, which returns two cell arrays: `arrowArrays` and `matlabData`. The `arrowArrays` cell array contains one instance of each concrete subclass of `arrow.array.Array`. The `matlabData` cell array contains the MATLAB arrays used to generate each array in `arrowArrays`. This utility can be used to create an `arrow.array.RecordBatch` that contains all the arrow array types that are supported by the MATLAB interface.

### Are these changes tested?

Yes. Updated the `fromArrays` test cases in `tRecordBatch` to verify the `column(index)` method of `arrow.type.RecordBatch` supports extracting columns of any arrow type (supported by the MATLAB Interface).

### Are there any user-facing changes?

Yes. Fixed a bug in `arrow.tabular.RecordBatch`.

### Future Directions

1. #37345

* Closes: #37340

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   2 +
 .../+tabular/createAllSupportedArrayTypes.m   | 104 ++++++++++++++++++
 matlab/test/arrow/tabular/tRecordBatch.m      |  39 ++++---
 3 files changed, 125 insertions(+), 20 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index dab09359598d4..e11e9bb7669b1 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -51,6 +51,8 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::DoubleType>>(std::static_pointer_cast<arrow::DoubleArray>(array));
             case ID::TIMESTAMP:
                 return std::make_shared<proxy::NumericArray<arrow::TimestampType>>(std::static_pointer_cast<arrow::TimestampArray>(array));
+            case ID::TIME32:
+                return std::make_shared<proxy::NumericArray<arrow::Time32Type>>(std::static_pointer_cast<arrow::Time32Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
             default:
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
new file mode 100644
index 0000000000000..7d3f36cb46e7c
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -0,0 +1,104 @@
+%CREATEALLSUPPORTEDARRAYTYPES Creates a MATLAB cell array containing all 
+%the concrete subclasses of arrow.array.Array. Returns a cell array
+%containing the MATLAB data from which the arrow arrays were generated
+%as second output argument.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function [arrowArrays, matlabData] = createAllSupportedArrayTypes(opts)
+    arguments
+        opts.NumRows(1, 1) {mustBeFinite, mustBeNonnegative} = 3;  
+    end
+
+    import arrow.type.ID
+    import arrow.array.*
+
+    classes = getArrayClassNames();
+    numClasses = numel(classes);
+    arrowArrays = cell(numClasses, 1);
+    matlabData  = cell(numClasses, 1);
+    
+    numericArrayToMatlabTypeDict = getArrowArrayToMatlabTypeDictionary();
+
+    for ii = 1:numel(classes)
+        name = classes(ii);
+        if name == "arrow.array.BooleanArray"
+            matlabData{ii} = randomLogicals(opts.NumRows);
+            arrowArrays{ii} = BooleanArray.fromMATLAB(matlabData{ii});
+        elseif isKey(numericArrayToMatlabTypeDict, name)
+            matlabType = numericArrayToMatlabTypeDict(name);
+            matlabData{ii} = randomNumbers(matlabType, opts.NumRows);
+            cmd = compose("%s.fromMATLAB(matlabData{ii})", name);
+            arrowArrays{ii} = eval(cmd);
+        elseif name == "arrow.array.StringArray"
+            matlabData{ii} = randomStrings(opts.NumRows);
+            arrowArrays{ii} = StringArray.fromMATLAB(matlabData{ii});
+        elseif name == "arrow.array.TimestampArray"
+            matlabData{ii} = randomDatetimes(opts.NumRows);
+            arrowArrays{ii} = TimestampArray.fromMATLAB(matlabData{ii});
+        elseif name == "arrow.array.Time32Array"
+            matlabData{ii} = randomDurations(opts.NumRows);
+            arrowArrays{ii} = Time32Array.fromMATLAB(matlabData{ii});
+        else
+            error("arrow:test:SupportedArrayCase", ...
+                "Missing if-branch for array class " + name); 
+        end
+    end
+end
+
+function classes = getArrayClassNames()
+    metaClass = meta.package.fromName("arrow.array").ClassList;
+
+    % Removes all Abstract classes from the list of all subclasses
+    abstract = [metaClass.Abstract];
+    metaClass(abstract) = [];
+    classes = string({metaClass.Name});
+end
+
+function dict = getArrowArrayToMatlabTypeDictionary()
+    pkg = "arrow.array";
+    unsignedTypes = compose("UInt%d", power(2, 3:6));
+    signedTypes = compose("Int%d", power(2, 3:6));
+    floatTypes = compose("Float%d", power(2, 5:6));
+    numericTypes = [unsignedTypes, signedTypes, floatTypes];
+    keys = compose("%s.%sArray", pkg, numericTypes);
+    
+    values = [lower([unsignedTypes, signedTypes]) "single" "double"];
+    dict = dictionary(keys, values);
+end
+
+function number = randomNumbers(numberType, numElements)
+    number = cast(randi(255, [numElements 1]), numberType);
+end
+
+function text = randomStrings(numElements)
+    text = string(randi(255, [numElements 1]));
+end
+
+function tf = randomLogicals(numElements)
+    number = randi(2, [numElements 1]) - 1;
+    tf = logical(number);
+end
+
+function times = randomDurations(numElements)
+    number = randi(255, [numElements 1]);
+    times = seconds(number);
+end
+
+function dates = randomDatetimes(numElements)
+    day = days(randi(255, [numElements 1]));
+    dates = datetime(2023, 8, 23) + day;
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 027195d3d8250..d9c3c98652b08 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -28,11 +28,17 @@ function Basic(tc)
         function SupportedTypes(tc)
             % Create a table all supported MATLAB types.
             import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.type.traits.traits
 
             TOriginal = createTableWithSupportedTypes();
             arrowRecordBatch = arrow.recordBatch(TOriginal);
             expectedColumnNames = string(TOriginal.Properties.VariableNames);
-            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
+
+            % For each variable in the input MATLAB table, look up the 
+            % corresponding Arrow Array type using type traits.
+            expectedArrayClasses = varfun(@(var) traits(string(class(var))).ArrayClassName, ...
+                TOriginal, OutputFormat="uniform");
+            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, expectedArrayClasses, TOriginal);
         end
 
         function ToMATLAB(tc)
@@ -125,19 +131,16 @@ function FromArraysColumnNamesNotProvided(tc)
         % RecordBatch when given a comma-separated list of
         % arrow.array.Array values.
             import arrow.tabular.RecordBatch
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.internal.test.tabular.createAllSupportedArrayTypes
 
-            TOriginal = createTableWithSupportedTypes();
-
-            arrowArrays = cell([1 width(TOriginal)]);
-            for ii = 1:width(TOriginal)
-                arrowArrays{ii} = arrow.array(TOriginal.(ii));
-            end
+            [arrowArrays, matlabData] = createAllSupportedArrayTypes();
+            TOriginal = table(matlabData{:});
 
             arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:});
             expectedColumnNames = compose("Column%d", 1:width(TOriginal));
             TOriginal.Properties.VariableNames = expectedColumnNames;
-            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, TOriginal);
+            expectedArrayClasses = cellfun(@(c) string(class(c)), arrowArrays, UniformOutput=true);
+            tc.verifyRecordBatch(arrowRecordBatch, expectedColumnNames, expectedArrayClasses, TOriginal);
         end
 
         function FromArraysWithColumnNamesProvided(tc)
@@ -145,19 +148,16 @@ function FromArraysWithColumnNamesProvided(tc)
         % RecordBatch when given a comma-separated list of
         % arrow.array.Array values and the ColumnNames nv-pair is provided.
             import arrow.tabular.RecordBatch
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
-
-            TOriginal = createTableWithSupportedTypes();
+            import arrow.internal.test.tabular.createAllSupportedArrayTypes
 
-            arrowArrays = cell([1 width(TOriginal)]);
-            for ii = 1:width(TOriginal)
-                arrowArrays{ii} = arrow.array(TOriginal.(ii));
-            end
+            [arrowArrays, matlabData] = createAllSupportedArrayTypes();
+            TOriginal = table(matlabData{:});
 
             columnNames = compose("MyVar%d", 1:numel(arrowArrays));
             arrowRecordBatch = RecordBatch.fromArrays(arrowArrays{:}, ColumnNames=columnNames);
             TOriginal.Properties.VariableNames = columnNames;
-            tc.verifyRecordBatch(arrowRecordBatch, columnNames, TOriginal);
+            expectedArrayClasses = cellfun(@(c) string(class(c)), arrowArrays, UniformOutput=true);
+            tc.verifyRecordBatch(arrowRecordBatch, columnNames, expectedArrayClasses, TOriginal);
         end
 
         function FromArraysUnequalArrayLengthsError(tc)
@@ -226,7 +226,7 @@ function SchemaNoSetter(tc)
     end
 
     methods
-        function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedTable)
+        function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedArrayClasses, expectedTable)
             tc.verifyEqual(recordBatch.NumColumns, int32(width(expectedTable)));
             tc.verifyEqual(recordBatch.ColumnNames, expectedColumnNames);
             convertedTable = recordBatch.table();
@@ -234,8 +234,7 @@ function verifyRecordBatch(tc, recordBatch, expectedColumnNames, expectedTable)
              for ii = 1:recordBatch.NumColumns
                 column = recordBatch.column(ii);
                 tc.verifyEqual(column.toMATLAB(), expectedTable{:, ii});
-                traits = arrow.type.traits.traits(string(class(expectedTable{:, ii})));
-                tc.verifyInstanceOf(column, traits.ArrayClassName);
+                tc.verifyInstanceOf(column, expectedArrayClasses(ii));
              end
         end
     end

From 0f73be11778300e63c5bbe363412d98a7dde1d34 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 23 Aug 2023 17:21:13 -0400
Subject: [PATCH 225/749] GH-37229: [MATLAB] Add `arrow.type.Date32Type` class
 and `arrow.date32` construction function (#37348)

### Rationale for this change

In support of adding `arrow.array.Date32Array`, this pull request adds a new `arrow.type.Date32Type` class and associated `arrow.date32` construction function to the MATLAB interface.

### What changes are included in this PR?

1. New `arrow.type.Date32Type` class.
2. New `arrow.date32` construction function that returns an `arrow.type.Date32Type` instance.
3. New `arrow.type.ID.Date32` type enumeration value.
4. Added an abstract `arrow.type.DateType` class which `arrow.type.Date32Type` inherits from. `arrow.type.Date64Type` will also inherit from this class to share the `DateUnit` property. This mirrors the implementation of the `Time32Type` and `Time64Type` classes inheriting from an abstract `arrow.type.TimeType` class to share the `TimeUnit` property.

**Example**

```matlab
>> type = arrow.date32()

type =

  Date32Type with properties:

          ID: Date32
    DateUnit: Day
```

### Are these changes tested?

Yes.

1. Added a new `tDate32Type` test class.
2. Updated the `tID` test class to include `arrow.type.ID.Date32`.

### Are there any user-facing changes?

Yes.

1. There is a new public `arrow.type.Date32Type` class.
2. There is a new public `arrow.date32` construction function.
3. There is a new `arrow.type.ID.Date32` type enumeration value.

### Future Directions

1. #37230
2. Add `arrow.array.Date32Array` class.
3. Add `arrow.array.Date64Array` class.
* Closes: #37229

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |  4 +-
 .../arrow/matlab/type/proxy/date32_type.cc    | 31 +++++++
 .../cpp/arrow/matlab/type/proxy/date32_type.h | 36 +++++++++
 .../cpp/arrow/matlab/type/proxy/date_type.cc  | 37 +++++++++
 .../cpp/arrow/matlab/type/proxy/date_type.h   | 35 ++++++++
 matlab/src/matlab/+arrow/+type/Date32Type.m   | 33 ++++++++
 matlab/src/matlab/+arrow/+type/DateType.m     | 45 +++++++++++
 matlab/src/matlab/+arrow/+type/ID.m           |  2 +-
 matlab/src/matlab/+arrow/date32.m             | 20 +++++
 matlab/test/arrow/type/tDate32Type.m          | 81 +++++++++++++++++++
 matlab/test/arrow/type/tID.m                  |  1 +
 .../cmake/BuildMatlabArrowInterface.cmake     |  2 +
 12 files changed, 325 insertions(+), 2 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date32_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date32_type.h
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/Date32Type.m
 create mode 100644 matlab/src/matlab/+arrow/+type/DateType.m
 create mode 100644 matlab/src/matlab/+arrow/date32.m
 create mode 100644 matlab/test/arrow/type/tDate32Type.m

diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 554046f600abc..93dd9245aeb3c 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -26,6 +26,7 @@
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/date32_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/field.h"
@@ -67,8 +68,9 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.BooleanType    , arrow::matlab::type::proxy::PrimitiveCType<bool>);
     REGISTER_PROXY(arrow.type.proxy.StringType     , arrow::matlab::type::proxy::StringType);
     REGISTER_PROXY(arrow.type.proxy.TimestampType  , arrow::matlab::type::proxy::TimestampType);
-    REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
     REGISTER_PROXY(arrow.type.proxy.Time32Type     , arrow::matlab::type::proxy::Time32Type);
+    REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
+    REGISTER_PROXY(arrow.type.proxy.Date32Type     , arrow::matlab::type::proxy::Date32Type);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.cc
new file mode 100644
index 0000000000000..c699c121efc1b
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.cc
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/type/proxy/date32_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    Date32Type::Date32Type(std::shared_ptr<arrow::Date32Type> date32_type) : DateType(std::move(date32_type)) {}
+
+    libmexclass::proxy::MakeResult Date32Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        using Date32TypeProxy = arrow::matlab::type::proxy::Date32Type;
+
+        const auto type = arrow::date32();
+        const auto date32_type = std::static_pointer_cast<arrow::Date32Type>(type);
+        return std::make_shared<Date32TypeProxy>(std::move(date32_type));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.h
new file mode 100644
index 0000000000000..a239d4e6b45ca
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date32_type.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/date_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    class Date32Type : public arrow::matlab::type::proxy::DateType {
+
+        public:
+            Date32Type(std::shared_ptr<arrow::Date32Type> date32_type);
+
+            ~Date32Type() {}
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    };
+
+}
+
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/date_type.cc
new file mode 100644
index 0000000000000..25b639f8477ed
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date_type.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/date_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    DateType::DateType(std::shared_ptr<arrow::DateType> date_type) : FixedWidthType(std::move(date_type)) {
+        REGISTER_METHOD(DateType, getDateUnit);
+    }
+
+    void DateType::getDateUnit(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        auto date_type = std::static_pointer_cast<arrow::DateType>(data_type);
+        const auto date_unit = date_type->unit();
+        // Cast to uint8_t since there are only two supported DateUnit enumeration values:
+        // Day and Millisecond
+        auto date_unit_mda = factory.createScalar(static_cast<uint8_t>(date_unit));
+        context.outputs[0] = date_unit_mda;
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/date_type.h
new file mode 100644
index 0000000000000..72c33751abca8
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date_type.h
@@ -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.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/fixed_width_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+class DateType : public arrow::matlab::type::proxy::FixedWidthType {
+
+    public:
+        DateType(std::shared_ptr<arrow::DateType> date_type);
+
+        ~DateType() {}
+
+    protected:
+        void getDateUnit(libmexclass::proxy::method::Context& context);
+};
+
+}
diff --git a/matlab/src/matlab/+arrow/+type/Date32Type.m b/matlab/src/matlab/+arrow/+type/Date32Type.m
new file mode 100644
index 0000000000000..8f0a2b1dc5cb0
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/Date32Type.m
@@ -0,0 +1,33 @@
+%DATE32TYPE Type class for date32 data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Date32Type < arrow.type.DateType
+
+    methods
+
+        function obj = Date32Type(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Date32Type")}
+            end
+            import arrow.internal.proxy.validate
+
+            obj@arrow.type.DateType(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/DateType.m b/matlab/src/matlab/+arrow/+type/DateType.m
new file mode 100644
index 0000000000000..f8a3966602e12
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/DateType.m
@@ -0,0 +1,45 @@
+%DATETYPE Type class for date data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef DateType < arrow.type.TemporalType
+
+    properties(Dependent, SetAccess=private, GetAccess=public)
+        DateUnit
+    end
+
+    methods
+        function obj = DateType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy
+            end
+            obj@arrow.type.TemporalType(proxy);
+        end
+
+        function dateUnit = get.DateUnit(obj)
+            dateUnitvalue = obj.Proxy.getDateUnit();
+            dateUnit = arrow.type.DateUnit(dateUnitvalue);
+        end
+    end
+
+    methods (Access=protected)
+        function group = getPropertyGroups(~)
+            targets = ["ID" "DateUnit"];
+            group = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index e5b53cfa655bf..66ea3a5c7f750 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -32,7 +32,7 @@
         String  (13)
         % Binary (14)
         % FixedSizeBinary (15)
-        % Date32 (16)
+        Date32 (16)
         % Date64 (17)
         Timestamp (18)
         Time32    (19)
diff --git a/matlab/src/matlab/+arrow/date32.m b/matlab/src/matlab/+arrow/date32.m
new file mode 100644
index 0000000000000..a64cb7c419051
--- /dev/null
+++ b/matlab/src/matlab/+arrow/date32.m
@@ -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.
+
+function type = date32()
+%DATE32 Creates an arrow.type.Date32Type object
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.Date32Type");
+    type = arrow.type.Date32Type(proxy);
+end
diff --git a/matlab/test/arrow/type/tDate32Type.m b/matlab/test/arrow/type/tDate32Type.m
new file mode 100644
index 0000000000000..984baa66bbda1
--- /dev/null
+++ b/matlab/test/arrow/type/tDate32Type.m
@@ -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.
+
+classdef tDate32Type < hFixedWidthType
+% Test class for arrow.type.Date32Type and arrow.date32
+
+    properties
+        ConstructionFcn = @arrow.date32
+        ArrowType = arrow.date32
+        TypeID = arrow.type.ID.Date32
+        BitWidth = int32(32)
+        ClassName = "arrow.type.Date32Type"
+    end
+
+    methods(Test)
+        function TestClass(testCase)
+            % Verify ArrowType is an object of the expected class type.
+            name = string(class(testCase.ArrowType));
+            testCase.verifyEqual(name, testCase.ClassName);
+        end
+
+        function DefaultDateUnit(testCase)
+            % Verify the default DateUnit is Day.
+            type = testCase.ArrowType;
+            actualUnit = type.DateUnit;
+            expectedUnit = arrow.type.DateUnit.Day;
+            testCase.verifyEqual(actualUnit, expectedUnit);
+        end
+
+        function Display(testCase)
+            % Verify the display of Date32Type objects.
+            %
+            % Example:
+            %
+            %  Date32Type with properties:
+            %
+            %          ID: Date32
+            %    DateUnit: Day
+            %
+            type = testCase.ConstructionFcn(); %#ok<NASGU>
+            classnameLink = "<a href=""matlab:helpPopup arrow.type.Date32Type"" style=""font-weight:bold"">Date32Type</a>";
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "DateUnit:"]));
+            body = body + " " + ["Date32"; "Day"];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DateUnitNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the DateUnit property.
+            type = arrow.date32();
+            testCase.verifyError(@() setfield(type, "DateUnit", "Millisecond"), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidProxy(testCase)
+            % Verify that an error is thrown when a Proxy of an unexpected
+            % type is passed to the arrow.type.Date32Type constructor.
+            array = arrow.array([1, 2, 3]);
+            proxy = array.Proxy;
+            testCase.verifyError(@() arrow.type.Date32Type(proxy), "arrow:proxy:ProxyNameMismatch");
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index f0014718e3a50..d83bb4475feff 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -42,6 +42,7 @@ function CastToUInt64(testCase)
                 ID.Float32,   11, ...
                 ID.Float64,   12, ...
                 ID.String,    13, ...
+                ID.Date32,    16, ...
                 ID.Timestamp, 18, ...
                 ID.Time32,    19, ...
                 ID.Time64,    20  ...
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 477d7e6724d5a..306ffa7debb2a 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -55,6 +55,8 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/date_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/date32_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"

From 6d3cbda1839cf9b1a7099001e97880d9cdb0136f Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 24 Aug 2023 00:57:51 +0100
Subject: [PATCH 226/749] MINOR: [R] Update reference to data.frame which
 should say tibble instead (#37335)

### Rationale for this change

Incorrect information in docs

### What changes are included in this PR?

Change ref to `data.frame` to `tibble` instead

### Are these changes tested?

No
### Are there any user-facing changes?

No

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 r/data-raw/docgen.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/data-raw/docgen.R b/r/data-raw/docgen.R
index 3bfb222fa9708..5f7f21b90299f 100644
--- a/r/data-raw/docgen.R
+++ b/r/data-raw/docgen.R
@@ -54,7 +54,7 @@ file_template <- "# Licensed to the Apache Software Foundation (ASF) under one
 #' to a `dbplyr::tbl_lazy`. This means that the verbs do not eagerly evaluate
 #' the query on the data. To run the query, call either `compute()`,
 #' which returns an `arrow` [Table], or `collect()`, which pulls the resulting
-#' Table into an R `data.frame`.
+#' Table into an R `tibble`.
 #'
 %s
 #'

From 0be17e669e7d1b6c586b7d8ca17b67c64c87b04e Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Wed, 23 Aug 2023 21:49:06 -0400
Subject: [PATCH 227/749] GH-37294: [C++] Use std::string for HasSubstr matcher
 (#37314)

### Rationale for this change

Apparently not all versions of GTest/GMock handle `testing::HasSubstr` against a `std::string_view`.

### What changes are included in this PR?

Explicitly wrap in `std::string`.

### Are these changes tested?

They are the tests.

### Are there any user-facing changes?

No.
* Closes: #37294

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/flight_test.cc      | 47 ++++++++++++++----------
 cpp/src/arrow/flight/test_definitions.cc |  2 +-
 2 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/cpp/src/arrow/flight/flight_test.cc b/cpp/src/arrow/flight/flight_test.cc
index c36c9eee71ba1..020fb7b24efc3 100644
--- a/cpp/src/arrow/flight/flight_test.cc
+++ b/cpp/src/arrow/flight/flight_test.cc
@@ -89,6 +89,32 @@ const char kBasicPrefix[] = "Basic ";
 const char kBearerPrefix[] = "Bearer ";
 const char kAuthHeader[] = "authorization";
 
+class OtelEnvironment : public ::testing::Environment {
+ public:
+  void SetUp() override {
+#ifdef ARROW_WITH_OPENTELEMETRY
+    // The default tracer always generates no-op spans which have no
+    // span/trace ID. Set up a different tracer. Note, this needs to be run
+    // before Arrow uses OTel as GetTracer() gets a tracer once and keeps it
+    // in a static. Also, arrow::Future may GetTracer(). So this has to be
+    // done as a Googletest environment, which runs before any tests.
+    std::vector<std::unique_ptr<opentelemetry::sdk::trace::SpanProcessor>> processors;
+    auto provider =
+        opentelemetry::nostd::shared_ptr<opentelemetry::sdk::trace::TracerProvider>(
+            new opentelemetry::sdk::trace::TracerProvider(std::move(processors)));
+    opentelemetry::trace::Provider::SetTracerProvider(std::move(provider));
+
+    opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(
+        opentelemetry::nostd::shared_ptr<
+            opentelemetry::context::propagation::TextMapPropagator>(
+            new opentelemetry::trace::propagation::HttpTraceContext()));
+#endif
+  }
+};
+
+static ::testing::Environment* kOtelEnvironment =
+    ::testing::AddGlobalTestEnvironment(new OtelEnvironment);
+
 //------------------------------------------------------------
 // Common transport tests
 
@@ -1681,24 +1707,7 @@ class TracingTestServer : public FlightServerBase {
 
 class TestTracing : public ::testing::Test {
  public:
-  void SetUp() {
-#ifdef ARROW_WITH_OPENTELEMETRY
-    // The default tracer always generates no-op spans which have no
-    // span/trace ID. Set up a different tracer. Note, this needs to
-    // be run before Arrow uses OTel as GetTracer() gets a tracer once
-    // and keeps it in a static.
-    std::vector<std::unique_ptr<opentelemetry::sdk::trace::SpanProcessor>> processors;
-    auto provider =
-        opentelemetry::nostd::shared_ptr<opentelemetry::sdk::trace::TracerProvider>(
-            new opentelemetry::sdk::trace::TracerProvider(std::move(processors)));
-    opentelemetry::trace::Provider::SetTracerProvider(std::move(provider));
-
-    opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(
-        opentelemetry::nostd::shared_ptr<
-            opentelemetry::context::propagation::TextMapPropagator>(
-            new opentelemetry::trace::propagation::HttpTraceContext()));
-#endif
-
+  void SetUp() override {
     ASSERT_OK(MakeServer<TracingTestServer>(
         &server_, &client_,
         [](FlightServerOptions* options) {
@@ -1711,7 +1720,7 @@ class TestTracing : public ::testing::Test {
           return Status::OK();
         }));
   }
-  void TearDown() { ASSERT_OK(server_->Shutdown()); }
+  void TearDown() override { ASSERT_OK(server_->Shutdown()); }
 
  protected:
   std::unique_ptr<FlightClient> client_;
diff --git a/cpp/src/arrow/flight/test_definitions.cc b/cpp/src/arrow/flight/test_definitions.cc
index c84c5a18ff468..c43b693d84a47 100644
--- a/cpp/src/arrow/flight/test_definitions.cc
+++ b/cpp/src/arrow/flight/test_definitions.cc
@@ -1679,7 +1679,7 @@ void ErrorHandlingTest::TestAsyncGetFlightInfo() {
 
       // The server-side arrow::Status-to-TransportStatus conversion puts the
       // detail into the main error message.
-      EXPECT_THAT(detail->get().message(),
+      EXPECT_THAT(std::string(detail->get().message()),
                   ::testing::HasSubstr("Expected message. Detail:"));
 
       std::string_view arrow_code, arrow_message, binary_detail;

From 175b2a2fe2d6e35237c36666478800f62e3f6947 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Wed, 23 Aug 2023 22:12:55 -0400
Subject: [PATCH 228/749] GH-37254: [Python] Parametrize all pickling tests to
 use both the pickle and cloudpickle modules (#37255)

### Rationale for this change

Cloudpickle was not tested in most parts of the pyarrow test suite. Improving this coverage will make the Cython 3.0.0 upgrade cleaner as cloudpickle was failing in a few places where the default pickle module was not. This has been verified using Cython 0.29.36.

### What changes are included in this PR?

* `__reduce__` methods that need to pass kwargs have been changed from classmethod to staticmethod
* All pytests that pickle objects are parameterized to use both `pickle` and `cloudpickle`

### Are these changes tested?

Yes, pytests run successfully with Cython 0.29.36

### Are there any user-facing changes?

No.
* Closes: #37254

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/_dataset_parquet.pyx          |  12 +-
 python/pyarrow/_fs.pyx                       |   8 +-
 python/pyarrow/_gcsfs.pyx                    |  13 +-
 python/pyarrow/_hdfs.pyx                     |  11 +-
 python/pyarrow/_s3fs.pyx                     |  11 +-
 python/pyarrow/scalar.pxi                    |   6 +-
 python/pyarrow/tests/conftest.py             | 111 ++++++++++++---
 python/pyarrow/tests/parquet/test_dataset.py |  25 +---
 python/pyarrow/tests/test_array.py           |  35 ++---
 python/pyarrow/tests/test_compute.py         |  13 +-
 python/pyarrow/tests/test_csv.py             |  30 ++--
 python/pyarrow/tests/test_dataset.py         | 139 ++++++++++---------
 python/pyarrow/tests/test_extension_type.py  |  39 +++---
 python/pyarrow/tests/test_fs.py              | 117 ++++++++--------
 python/pyarrow/tests/test_hdfs.py            |  14 +-
 python/pyarrow/tests/test_io.py              |  23 ++-
 python/pyarrow/tests/test_json.py            |  17 +--
 python/pyarrow/tests/test_scalars.py         |  23 ++-
 python/pyarrow/tests/test_schema.py          |   7 +-
 python/pyarrow/tests/test_table.py           |  13 +-
 python/pyarrow/tests/test_types.py           |  13 +-
 21 files changed, 372 insertions(+), 308 deletions(-)

diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx
index 4de396f4f50eb..79bd270ce54d2 100644
--- a/python/pyarrow/_dataset_parquet.pyx
+++ b/python/pyarrow/_dataset_parquet.pyx
@@ -19,6 +19,7 @@
 
 """Dataset support for Parquest file format."""
 
+from cython cimport binding
 from cython.operator cimport dereference as deref
 
 import os
@@ -770,9 +771,12 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
             other.thrift_container_size_limit)
         return attrs == other_attrs
 
-    @classmethod
-    def _reconstruct(cls, kwargs):
-        return cls(**kwargs)
+    @staticmethod
+    @binding(True)  # Required for Cython < 3
+    def _reconstruct(kwargs):
+        # __reduce__ doesn't allow passing named arguments directly to the
+        # reconstructor, hence this wrapper.
+        return ParquetFragmentScanOptions(**kwargs)
 
     def __reduce__(self):
         kwargs = dict(
@@ -782,7 +786,7 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
             thrift_string_size_limit=self.thrift_string_size_limit,
             thrift_container_size_limit=self.thrift_container_size_limit,
         )
-        return type(self)._reconstruct, (kwargs,)
+        return ParquetFragmentScanOptions._reconstruct, (kwargs,)
 
 
 cdef class ParquetFactoryOptions(_Weakrefable):
diff --git a/python/pyarrow/_fs.pyx b/python/pyarrow/_fs.pyx
index dbd7ebe5e4d52..ef8db31bfc2f6 100644
--- a/python/pyarrow/_fs.pyx
+++ b/python/pyarrow/_fs.pyx
@@ -18,6 +18,7 @@
 # cython: language_level = 3
 
 from cpython.datetime cimport datetime, PyDateTime_DateTime
+from cython cimport binding
 
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow_python cimport PyDateTime_to_TimePoint
@@ -1106,11 +1107,12 @@ cdef class LocalFileSystem(FileSystem):
         FileSystem.init(self, c_fs)
         self.localfs = <CLocalFileSystem*> c_fs.get()
 
-    @classmethod
-    def _reconstruct(cls, kwargs):
+    @staticmethod
+    @binding(True)  # Required for cython < 3
+    def _reconstruct(kwargs):
         # __reduce__ doesn't allow passing named arguments directly to the
         # reconstructor, hence this wrapper.
-        return cls(**kwargs)
+        return LocalFileSystem(**kwargs)
 
     def __reduce__(self):
         cdef CLocalFileSystemOptions opts = self.localfs.options()
diff --git a/python/pyarrow/_gcsfs.pyx b/python/pyarrow/_gcsfs.pyx
index 1fda08232ca44..5e69413cea953 100644
--- a/python/pyarrow/_gcsfs.pyx
+++ b/python/pyarrow/_gcsfs.pyx
@@ -17,6 +17,8 @@
 
 # cython: language_level = 3
 
+from cython cimport binding
+
 from pyarrow.lib cimport (pyarrow_wrap_metadata,
                           pyarrow_unwrap_metadata)
 from pyarrow.lib import frombytes, tobytes, ensure_metadata
@@ -154,10 +156,6 @@ cdef class GcsFileSystem(FileSystem):
         FileSystem.init(self, wrapped)
         self.gcsfs = <CGcsFileSystem*> wrapped.get()
 
-    @classmethod
-    def _reconstruct(cls, kwargs):
-        return cls(**kwargs)
-
     def _expiration_datetime_from_options(self):
         expiration_ns = TimePoint_to_ns(
             self.gcsfs.options().credentials.expiration())
@@ -165,6 +163,13 @@ cdef class GcsFileSystem(FileSystem):
             return None
         return datetime.fromtimestamp(expiration_ns / 1.0e9, timezone.utc)
 
+    @staticmethod
+    @binding(True)  # Required for cython < 3
+    def _reconstruct(kwargs):
+        # __reduce__ doesn't allow passing named arguments directly to the
+        # reconstructor, hence this wrapper.
+        return GcsFileSystem(**kwargs)
+
     def __reduce__(self):
         cdef CGcsOptions opts = self.gcsfs.options()
         service_account = frombytes(opts.credentials.target_service_account())
diff --git a/python/pyarrow/_hdfs.pyx b/python/pyarrow/_hdfs.pyx
index a0cef25105732..c426337a12ec1 100644
--- a/python/pyarrow/_hdfs.pyx
+++ b/python/pyarrow/_hdfs.pyx
@@ -17,6 +17,8 @@
 
 # cython: language_level = 3
 
+from cython cimport binding
+
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
 from pyarrow.includes.libarrow_fs cimport *
@@ -134,9 +136,12 @@ replication=1)``
         self.init(<shared_ptr[CFileSystem]> wrapped)
         return self
 
-    @classmethod
-    def _reconstruct(cls, kwargs):
-        return cls(**kwargs)
+    @staticmethod
+    @binding(True)  # Required for cython < 3
+    def _reconstruct(kwargs):
+        # __reduce__ doesn't allow passing named arguments directly to the
+        # reconstructor, hence this wrapper.
+        return HadoopFileSystem(**kwargs)
 
     def __reduce__(self):
         cdef CHdfsOptions opts = self.hdfs.options()
diff --git a/python/pyarrow/_s3fs.pyx b/python/pyarrow/_s3fs.pyx
index 51c248d147828..ab45171369953 100644
--- a/python/pyarrow/_s3fs.pyx
+++ b/python/pyarrow/_s3fs.pyx
@@ -17,6 +17,8 @@
 
 # cython: language_level = 3
 
+from cython cimport binding
+
 from pyarrow.lib cimport (check_status, pyarrow_wrap_metadata,
                           pyarrow_unwrap_metadata)
 from pyarrow.lib import frombytes, tobytes, KeyValueMetadata
@@ -388,9 +390,12 @@ cdef class S3FileSystem(FileSystem):
         FileSystem.init(self, wrapped)
         self.s3fs = <CS3FileSystem*> wrapped.get()
 
-    @classmethod
-    def _reconstruct(cls, kwargs):
-        return cls(**kwargs)
+    @staticmethod
+    @binding(True)  # Required for cython < 3
+    def _reconstruct(kwargs):
+        # __reduce__ doesn't allow passing named arguments directly to the
+        # reconstructor, hence this wrapper.
+        return S3FileSystem(**kwargs)
 
     def __reduce__(self):
         cdef CS3Options opts = self.s3fs.options()
diff --git a/python/pyarrow/scalar.pxi b/python/pyarrow/scalar.pxi
index e19807ba56ee1..e07949c675524 100644
--- a/python/pyarrow/scalar.pxi
+++ b/python/pyarrow/scalar.pxi
@@ -16,6 +16,7 @@
 # under the License.
 
 import collections
+from cython cimport binding
 
 
 cdef class Scalar(_Weakrefable):
@@ -836,8 +837,9 @@ cdef class DictionaryScalar(Scalar):
     Concrete class for dictionary-encoded scalars.
     """
 
-    @classmethod
-    def _reconstruct(cls, type, is_valid, index, dictionary):
+    @staticmethod
+    @binding(True)  # Required for cython < 3
+    def _reconstruct(type, is_valid, index, dictionary):
         cdef:
             CDictionaryScalarIndexAndDictionary value
             shared_ptr[CDictionaryScalar] wrapped
diff --git a/python/pyarrow/tests/conftest.py b/python/pyarrow/tests/conftest.py
index e6d87217eca16..241ae4814a5ae 100644
--- a/python/pyarrow/tests/conftest.py
+++ b/python/pyarrow/tests/conftest.py
@@ -15,13 +15,16 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import functools
 import os
 import pathlib
 import subprocess
 import sys
-from tempfile import TemporaryDirectory
+import time
+import urllib.request
 
 import pytest
+from pytest_lazyfixture import lazy_fixture
 import hypothesis as h
 from ..conftest import groups, defaults
 
@@ -146,8 +149,49 @@ def s3_connection():
     return host, port, access_key, secret_key
 
 
+def retry(attempts=3, delay=1.0, max_delay=None, backoff=1):
+    """
+    Retry decorator
+
+    Parameters
+    ----------
+    attempts : int, default 3
+        The number of attempts.
+    delay : float, default 1
+        Initial delay in seconds.
+    max_delay : float, optional
+        The max delay between attempts.
+    backoff : float, default 1
+        The multiplier to delay after each attempt.
+    """
+    def decorate(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            remaining_attempts = attempts
+            curr_delay = delay
+            while remaining_attempts > 0:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as err:
+                    remaining_attempts -= 1
+                    last_exception = err
+                    curr_delay *= backoff
+                    if max_delay:
+                        curr_delay = min(curr_delay, max_delay)
+                    time.sleep(curr_delay)
+            raise last_exception
+        return wrapper
+    return decorate
+
+
 @pytest.fixture(scope='session')
-def s3_server(s3_connection):
+def s3_server(s3_connection, tmpdir_factory):
+    @retry(attempts=5, delay=0.1, backoff=2)
+    def minio_server_health_check(address):
+        resp = urllib.request.urlopen(f"http://{address}/minio/health/cluster")
+        assert resp.getcode() == 200
+
+    tmpdir = tmpdir_factory.getbasetemp()
     host, port, access_key, secret_key = s3_connection
 
     address = '{}:{}'.format(host, port)
@@ -157,24 +201,26 @@ def s3_server(s3_connection):
         'MINIO_SECRET_KEY': secret_key
     })
 
-    with TemporaryDirectory() as tempdir:
-        args = ['minio', '--compat', 'server', '--quiet', '--address',
-                address, tempdir]
-        proc = None
-        try:
-            proc = subprocess.Popen(args, env=env)
-        except OSError:
-            pytest.skip('`minio` command cannot be located')
-        else:
-            yield {
-                'connection': s3_connection,
-                'process': proc,
-                'tempdir': tempdir
-            }
-        finally:
-            if proc is not None:
-                proc.kill()
-                proc.wait()
+    args = ['minio', '--compat', 'server', '--quiet', '--address',
+            address, tmpdir]
+    proc = None
+    try:
+        proc = subprocess.Popen(args, env=env)
+    except OSError:
+        pytest.skip('`minio` command cannot be located')
+    else:
+        # Wait for the server to startup before yielding
+        minio_server_health_check(address)
+
+        yield {
+            'connection': s3_connection,
+            'process': proc,
+            'tempdir': tmpdir
+        }
+    finally:
+        if proc is not None:
+            proc.kill()
+            proc.wait()
 
 
 @pytest.fixture(scope='session')
@@ -202,3 +248,28 @@ def gcs_server():
         if proc is not None:
             proc.kill()
             proc.wait()
+
+
+@pytest.fixture(
+    params=[
+        lazy_fixture('builtin_pickle'),
+        lazy_fixture('cloudpickle')
+    ],
+    scope='session'
+)
+def pickle_module(request):
+    return request.param
+
+
+@pytest.fixture(scope='session')
+def builtin_pickle():
+    import pickle
+    return pickle
+
+
+@pytest.fixture(scope='session')
+def cloudpickle():
+    cp = pytest.importorskip('cloudpickle')
+    if 'HIGHEST_PROTOCOL' not in cp.__dict__:
+        cp.HIGHEST_PROTOCOL = cp.DEFAULT_PROTOCOL
+    return cp
diff --git a/python/pyarrow/tests/parquet/test_dataset.py b/python/pyarrow/tests/parquet/test_dataset.py
index 3e6ff49265c32..be27c71b813e4 100644
--- a/python/pyarrow/tests/parquet/test_dataset.py
+++ b/python/pyarrow/tests/parquet/test_dataset.py
@@ -1533,10 +1533,13 @@ def _make_dataset_for_pickling(tempdir, use_legacy_dataset=False, N=100):
     return dataset
 
 
-def _assert_dataset_is_picklable(dataset, pickler, use_legacy_dataset=False):
+@pytest.mark.pandas
+@parametrize_legacy_dataset
+def test_pickle_dataset(tempdir, datadir, use_legacy_dataset, pickle_module):
     def is_pickleable(obj):
-        return obj == pickler.loads(pickler.dumps(obj))
+        return obj == pickle_module.loads(pickle_module.dumps(obj))
 
+    dataset = _make_dataset_for_pickling(tempdir, use_legacy_dataset)
     assert is_pickleable(dataset)
     if use_legacy_dataset:
         with pytest.warns(FutureWarning):
@@ -1555,24 +1558,6 @@ def is_pickleable(obj):
                 assert is_pickleable(metadata.row_group(i))
 
 
-@pytest.mark.pandas
-@parametrize_legacy_dataset
-def test_builtin_pickle_dataset(tempdir, datadir, use_legacy_dataset):
-    import pickle
-    dataset = _make_dataset_for_pickling(tempdir, use_legacy_dataset)
-    _assert_dataset_is_picklable(
-        dataset, pickler=pickle, use_legacy_dataset=use_legacy_dataset)
-
-
-@pytest.mark.pandas
-@parametrize_legacy_dataset
-def test_cloudpickle_dataset(tempdir, datadir, use_legacy_dataset):
-    cp = pytest.importorskip('cloudpickle')
-    dataset = _make_dataset_for_pickling(tempdir, use_legacy_dataset)
-    _assert_dataset_is_picklable(
-        dataset, pickler=cp, use_legacy_dataset=use_legacy_dataset)
-
-
 @pytest.mark.pandas
 @parametrize_legacy_dataset
 def test_partitioned_dataset(tempdir, use_legacy_dataset):
diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py
index 0546830a661de..fca094b519fa5 100644
--- a/python/pyarrow/tests/test_array.py
+++ b/python/pyarrow/tests/test_array.py
@@ -21,7 +21,6 @@
 import hypothesis as h
 import hypothesis.strategies as st
 import itertools
-import pickle
 import pytest
 import struct
 import subprocess
@@ -29,10 +28,6 @@
 import weakref
 
 import numpy as np
-try:
-    import pickle5
-except ImportError:
-    pickle5 = None
 
 import pyarrow as pa
 import pyarrow.tests.strategies as past
@@ -2007,21 +2002,21 @@ def test_cast_identities(ty, values):
 
 
 @pickle_test_parametrize
-def test_array_pickle(data, typ):
+def test_array_pickle(data, typ, pickle_module):
     # Allocate here so that we don't have any Arrow data allocated.
     # This is needed to ensure that allocator tests can be reliable.
     array = pa.array(data, type=typ)
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        result = pickle.loads(pickle.dumps(array, proto))
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
+        result = pickle_module.loads(pickle_module.dumps(array, proto))
         assert array.equals(result)
 
 
-def test_array_pickle_dictionary():
+def test_array_pickle_dictionary(pickle_module):
     # not included in the above as dictionary array cannot be created with
     # the pa.array function
     array = pa.DictionaryArray.from_arrays([0, 1, 2, 0, 1], ['a', 'b', 'c'])
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        result = pickle.loads(pickle.dumps(array, proto))
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
+        result = pickle_module.loads(pickle_module.dumps(array, proto))
         assert array.equals(result)
 
 
@@ -2031,27 +2026,23 @@ def test_array_pickle_dictionary():
         size=st.integers(min_value=0, max_value=10)
     )
 )
-def test_pickling(arr):
-    data = pickle.dumps(arr)
-    restored = pickle.loads(data)
+def test_pickling(pickle_module, arr):
+    data = pickle_module.dumps(arr)
+    restored = pickle_module.loads(data)
     assert arr.equals(restored)
 
 
 @pickle_test_parametrize
-def test_array_pickle5(data, typ):
+def test_array_pickle_protocol5(data, typ, pickle_module):
     # Test zero-copy pickling with protocol 5 (PEP 574)
-    picklemod = pickle5 or pickle
-    if pickle5 is None and picklemod.HIGHEST_PROTOCOL < 5:
-        pytest.skip("need pickle5 package or Python 3.8+")
-
     array = pa.array(data, type=typ)
     addresses = [buf.address if buf is not None else 0
                  for buf in array.buffers()]
 
-    for proto in range(5, pickle.HIGHEST_PROTOCOL + 1):
+    for proto in range(5, pickle_module.HIGHEST_PROTOCOL + 1):
         buffers = []
-        pickled = picklemod.dumps(array, proto, buffer_callback=buffers.append)
-        result = picklemod.loads(pickled, buffers=buffers)
+        pickled = pickle_module.dumps(array, proto, buffer_callback=buffers.append)
+        result = pickle_module.loads(pickled, buffers=buffers)
         assert array.equals(result)
 
         result_addresses = [buf.address if buf is not None else 0
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 6ee54ca4b1259..152cae1be1fe9 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -23,7 +23,6 @@
 import itertools
 import math
 import os
-import pickle
 import pytest
 import random
 import sys
@@ -278,18 +277,18 @@ def test_call_function_with_memory_pool():
     assert result3.equals(expected)
 
 
-def test_pickle_functions():
+def test_pickle_functions(pickle_module):
     # Pickle registered functions
     for name in pc.list_functions():
         func = pc.get_function(name)
-        reconstructed = pickle.loads(pickle.dumps(func))
+        reconstructed = pickle_module.loads(pickle_module.dumps(func))
         assert type(reconstructed) is type(func)
         assert reconstructed.name == func.name
         assert reconstructed.arity == func.arity
         assert reconstructed.num_kernels == func.num_kernels
 
 
-def test_pickle_global_functions():
+def test_pickle_global_functions(pickle_module):
     # Pickle global wrappers (manual or automatic) of registered functions
     for name in pc.list_functions():
         try:
@@ -297,7 +296,7 @@ def test_pickle_global_functions():
         except AttributeError:
             # hash_aggregate functions are not exported as callables.
             continue
-        reconstructed = pickle.loads(pickle.dumps(func))
+        reconstructed = pickle_module.loads(pickle_module.dumps(func))
         assert reconstructed is func
 
 
@@ -3366,10 +3365,10 @@ def create_sample_expressions():
 # Tests the Arrow-specific serialization mechanism
 
 
-def test_expression_serialization_arrow():
+def test_expression_serialization_arrow(pickle_module):
     for expr in create_sample_expressions()["all"]:
         assert isinstance(expr, pc.Expression)
-        restored = pickle.loads(pickle.dumps(expr))
+        restored = pickle_module.loads(pickle_module.dumps(expr))
         assert expr.equals(restored)
 
 
diff --git a/python/pyarrow/tests/test_csv.py b/python/pyarrow/tests/test_csv.py
index 81c31d98ac7ec..afc5380b75516 100644
--- a/python/pyarrow/tests/test_csv.py
+++ b/python/pyarrow/tests/test_csv.py
@@ -24,7 +24,6 @@
 import io
 import itertools
 import os
-import pickle
 import select
 import shutil
 import signal
@@ -102,10 +101,10 @@ def check_options_class(cls, **attr_values):
 
 
 # The various options classes need to be picklable for dataset
-def check_options_class_pickling(cls, **attr_values):
+def check_options_class_pickling(cls, pickler, **attr_values):
     opts = cls(**attr_values)
-    new_opts = pickle.loads(pickle.dumps(opts,
-                                         protocol=pickle.HIGHEST_PROTOCOL))
+    new_opts = pickler.loads(pickler.dumps(opts,
+                                           protocol=pickler.HIGHEST_PROTOCOL))
     for name, value in attr_values.items():
         assert getattr(new_opts, name) == value
 
@@ -128,7 +127,7 @@ def __ne__(self, other):
                 other.result != self.result)
 
 
-def test_read_options():
+def test_read_options(pickle_module):
     cls = ReadOptions
     opts = cls()
 
@@ -139,7 +138,8 @@ def test_read_options():
                         encoding=['utf8', 'utf16'],
                         skip_rows_after_names=[0, 27])
 
-    check_options_class_pickling(cls, use_threads=True,
+    check_options_class_pickling(cls, pickler=pickle_module,
+                                 use_threads=True,
                                  skip_rows=3,
                                  column_names=["ab", "cd"],
                                  autogenerate_column_names=False,
@@ -182,7 +182,7 @@ def test_read_options():
         opts.validate()
 
 
-def test_parse_options():
+def test_parse_options(pickle_module):
     cls = ParseOptions
     skip_handler = InvalidRowHandler('skip')
 
@@ -194,7 +194,8 @@ def test_parse_options():
                         ignore_empty_lines=[True, False],
                         invalid_row_handler=[None, skip_handler])
 
-    check_options_class_pickling(cls, delimiter='x',
+    check_options_class_pickling(cls, pickler=pickle_module,
+                                 delimiter='x',
                                  escape_char='y',
                                  quote_char=False,
                                  double_quote=False,
@@ -241,7 +242,7 @@ def test_parse_options():
         opts.validate()
 
 
-def test_convert_options():
+def test_convert_options(pickle_module):
     cls = ConvertOptions
     opts = cls()
 
@@ -256,7 +257,8 @@ def test_convert_options():
         timestamp_parsers=[[], [ISO8601, '%y-%m']])
 
     check_options_class_pickling(
-        cls, check_utf8=False,
+        cls, pickler=pickle_module,
+        check_utf8=False,
         strings_can_be_null=True,
         quoted_strings_can_be_null=False,
         decimal_point=',',
@@ -622,7 +624,7 @@ def format_msg(msg_format, row, *args):
                             read_options=read_options,
                             convert_options=convert_options)
 
-    def test_invalid_row_handler(self):
+    def test_invalid_row_handler(self, pickle_module):
         rows = b"a,b\nc\nd,e\nf,g,h\ni,j\n"
         parse_opts = ParseOptions()
         with pytest.raises(
@@ -657,7 +659,7 @@ def row_num(x):
 
         # Test ser/de
         parse_opts.invalid_row_handler = InvalidRowHandler('skip')
-        parse_opts = pickle.loads(pickle.dumps(parse_opts))
+        parse_opts = pickle_module.loads(pickle_module.dumps(parse_opts))
 
         table = self.read_bytes(rows, parse_options=parse_opts)
         assert table.to_pydict() == {
@@ -1792,13 +1794,13 @@ def test_skip_rows_after_names(self):
             assert reader.read_next_batch()
 
 
-class TestSerialStreamingCSVRead(BaseStreamingCSVRead, unittest.TestCase):
+class TestSerialStreamingCSVRead(BaseStreamingCSVRead):
     @property
     def use_threads(self):
         return False
 
 
-class TestThreadedStreamingCSVRead(BaseStreamingCSVRead, unittest.TestCase):
+class TestThreadedStreamingCSVRead(BaseStreamingCSVRead):
     @property
     def use_threads(self):
         return True
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index f92317c0f223e..b8a0c38089980 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -20,7 +20,6 @@
 import posixpath
 import datetime
 import pathlib
-import pickle
 import sys
 import textwrap
 import tempfile
@@ -700,7 +699,7 @@ def test_partitioning():
             assert load_back_table.equals(table)
 
 
-def test_partitioning_pickling():
+def test_partitioning_pickling(pickle_module):
     schema = pa.schema([
         pa.field('i64', pa.int64()),
         pa.field('f64', pa.float64())
@@ -715,7 +714,7 @@ def test_partitioning_pickling():
     ]
 
     for part in parts:
-        assert pickle.loads(pickle.dumps(part)) == part
+        assert pickle_module.loads(pickle_module.dumps(part)) == part
 
 
 def test_expression_arithmetic_operators():
@@ -818,7 +817,7 @@ def test_parquet_scan_options():
     assert opts5 != opts1
 
 
-def test_file_format_pickling():
+def test_file_format_pickling(pickle_module):
     formats = [
         ds.IpcFileFormat(),
         ds.CsvFileFormat(),
@@ -854,10 +853,10 @@ def test_file_format_pickling():
         ])
 
     for file_format in formats:
-        assert pickle.loads(pickle.dumps(file_format)) == file_format
+        assert pickle_module.loads(pickle_module.dumps(file_format)) == file_format
 
 
-def test_fragment_scan_options_pickling():
+def test_fragment_scan_options_pickling(pickle_module):
     options = [
         ds.CsvFragmentScanOptions(),
         ds.CsvFragmentScanOptions(
@@ -879,7 +878,7 @@ def test_fragment_scan_options_pickling():
         ])
 
     for option in options:
-        assert pickle.loads(pickle.dumps(option)) == option
+        assert pickle_module.loads(pickle_module.dumps(option)) == option
 
 
 @pytest.mark.parametrize('paths_or_selector', [
@@ -982,7 +981,7 @@ def test_make_fragment(multisourcefs):
         assert row_group_fragment.row_groups == [0]
 
 
-def test_make_csv_fragment_from_buffer(dataset_reader):
+def test_make_csv_fragment_from_buffer(dataset_reader, pickle_module):
     content = textwrap.dedent("""
         alpha,num,animal
         a,12,dog
@@ -1003,11 +1002,11 @@ def test_make_csv_fragment_from_buffer(dataset_reader):
                         names=['alpha', 'num', 'animal'])
     assert dataset_reader.to_table(fragment).equals(expected)
 
-    pickled = pickle.loads(pickle.dumps(fragment))
+    pickled = pickle_module.loads(pickle_module.dumps(fragment))
     assert dataset_reader.to_table(pickled).equals(fragment.to_table())
 
 
-def test_make_json_fragment_from_buffer(dataset_reader):
+def test_make_json_fragment_from_buffer(dataset_reader, pickle_module):
     content = '{"alpha" : "a", "num": 12, "animal" : "dog"}\n' + \
         '{"alpha" : "b", "num": 11, "animal" : "cat"}\n' + \
         '{"alpha" : "c", "num": 10, "animal" : "rabbit"}\n'
@@ -1025,12 +1024,12 @@ def test_make_json_fragment_from_buffer(dataset_reader):
                         names=['alpha', 'num', 'animal'])
     assert dataset_reader.to_table(fragment).equals(expected)
 
-    pickled = pickle.loads(pickle.dumps(fragment))
+    pickled = pickle_module.loads(pickle_module.dumps(fragment))
     assert dataset_reader.to_table(pickled).equals(fragment.to_table())
 
 
 @pytest.mark.parquet
-def test_make_parquet_fragment_from_buffer(dataset_reader):
+def test_make_parquet_fragment_from_buffer(dataset_reader, pickle_module):
     arrays = [
         pa.array(['a', 'b', 'c']),
         pa.array([12, 11, 10]),
@@ -1063,7 +1062,7 @@ def test_make_parquet_fragment_from_buffer(dataset_reader):
         fragment = format_.make_fragment(buffer)
         assert dataset_reader.to_table(fragment).equals(table)
 
-        pickled = pickle.loads(pickle.dumps(fragment))
+        pickled = pickle_module.loads(pickle_module.dumps(fragment))
         assert dataset_reader.to_table(pickled).equals(table)
 
 
@@ -1140,7 +1139,7 @@ def test_fragments_implicit_cast(tempdir):
 @pytest.mark.parquet
 @pytest.mark.filterwarnings(
     "ignore:Passing 'use_legacy_dataset=True':FutureWarning")
-def test_fragments_reconstruct(tempdir, dataset_reader):
+def test_fragments_reconstruct(tempdir, dataset_reader, pickle_module):
     table, dataset = _create_dataset_for_fragments(tempdir)
 
     def assert_yields_projected(fragment, row_slice,
@@ -1157,7 +1156,7 @@ def assert_yields_projected(fragment, row_slice,
     parquet_format = fragment.format
 
     # test pickle roundtrip
-    pickled_fragment = pickle.loads(pickle.dumps(fragment))
+    pickled_fragment = pickle_module.loads(pickle_module.dumps(fragment))
     assert dataset_reader.to_table(
         pickled_fragment) == dataset_reader.to_table(fragment)
 
@@ -1272,7 +1271,7 @@ def test_fragments_parquet_row_groups_dictionary(tempdir, dataset_reader):
 @pytest.mark.parquet
 @pytest.mark.filterwarnings(
     "ignore:Passing 'use_legacy_dataset=True':FutureWarning")
-def test_fragments_parquet_ensure_metadata(tempdir, open_logging_fs):
+def test_fragments_parquet_ensure_metadata(tempdir, open_logging_fs, pickle_module):
     fs, assert_opens = open_logging_fs
     _, dataset = _create_dataset_for_fragments(
         tempdir, chunk_size=2, filesystem=fs
@@ -1304,7 +1303,7 @@ def test_fragments_parquet_ensure_metadata(tempdir, open_logging_fs):
     assert row_group.statistics is not None
 
     # pickling preserves row group ids
-    pickled_fragment = pickle.loads(pickle.dumps(new_fragment))
+    pickled_fragment = pickle_module.loads(pickle_module.dumps(new_fragment))
     with assert_opens([fragment.path]):
         assert pickled_fragment.row_groups == [0, 1]
         row_group = pickled_fragment.row_groups[0]
@@ -1314,7 +1313,7 @@ def test_fragments_parquet_ensure_metadata(tempdir, open_logging_fs):
 
 @pytest.mark.pandas
 @pytest.mark.parquet
-def test_fragments_parquet_pickle_no_metadata(tempdir, open_logging_fs):
+def test_fragments_parquet_pickle_no_metadata(tempdir, open_logging_fs, pickle_module):
     # https://issues.apache.org/jira/browse/ARROW-15796
     fs, assert_opens = open_logging_fs
     _, dataset = _create_dataset_for_fragments(tempdir, filesystem=fs)
@@ -1323,7 +1322,7 @@ def test_fragments_parquet_pickle_no_metadata(tempdir, open_logging_fs):
     # second fragment hasn't yet loaded the metadata,
     # and pickling it also should not read the metadata
     with assert_opens([]):
-        pickled_fragment = pickle.loads(pickle.dumps(fragment))
+        pickled_fragment = pickle_module.loads(pickle_module.dumps(fragment))
 
     # then accessing the row group info reads the metadata
     with assert_opens([pickled_fragment.path]):
@@ -1487,7 +1486,8 @@ def test_fragments_parquet_row_groups_predicate(tempdir):
 @pytest.mark.parquet
 @pytest.mark.filterwarnings(
     "ignore:Passing 'use_legacy_dataset=True':FutureWarning")
-def test_fragments_parquet_row_groups_reconstruct(tempdir, dataset_reader):
+def test_fragments_parquet_row_groups_reconstruct(tempdir, dataset_reader,
+                                                  pickle_module):
     table, dataset = _create_dataset_for_fragments(tempdir, chunk_size=2)
 
     fragment = list(dataset.get_fragments())[0]
@@ -1495,7 +1495,7 @@ def test_fragments_parquet_row_groups_reconstruct(tempdir, dataset_reader):
     row_group_fragments = list(fragment.split_by_row_group())
 
     # test pickle roundtrip
-    pickled_fragment = pickle.loads(pickle.dumps(fragment))
+    pickled_fragment = pickle_module.loads(pickle_module.dumps(fragment))
     assert dataset_reader.to_table(
         pickled_fragment) == dataset_reader.to_table(fragment)
 
@@ -1644,14 +1644,14 @@ def test_fragments_repr(tempdir, dataset):
 
 @pytest.mark.parquet
 @pytest.mark.parametrize(
-    "pickled", [lambda x: x, lambda x: pickle.loads(pickle.dumps(x))])
-def test_partitioning_factory(mockfs, pickled):
+    "pickled", [lambda x, m: x, lambda x, m: m.loads(m.dumps(x))])
+def test_partitioning_factory(mockfs, pickled, pickle_module):
     paths_or_selector = fs.FileSelector('subdir', recursive=True)
     format = ds.ParquetFileFormat()
 
     options = ds.FileSystemFactoryOptions('subdir')
     partitioning_factory = ds.DirectoryPartitioning.discover(['group', 'key'])
-    partitioning_factory = pickled(partitioning_factory)
+    partitioning_factory = pickled(partitioning_factory, pickle_module)
     assert isinstance(partitioning_factory, ds.PartitioningFactory)
     options.partitioning_factory = partitioning_factory
 
@@ -1678,15 +1678,16 @@ def test_partitioning_factory(mockfs, pickled):
 @pytest.mark.parquet
 @pytest.mark.parametrize('infer_dictionary', [False, True])
 @pytest.mark.parametrize(
-    "pickled", [lambda x: x, lambda x: pickle.loads(pickle.dumps(x))])
-def test_partitioning_factory_dictionary(mockfs, infer_dictionary, pickled):
+    "pickled", [lambda x, m: x, lambda x, m: m.loads(m.dumps(x))])
+def test_partitioning_factory_dictionary(mockfs, infer_dictionary, pickled,
+                                         pickle_module):
     paths_or_selector = fs.FileSelector('subdir', recursive=True)
     format = ds.ParquetFileFormat()
     options = ds.FileSystemFactoryOptions('subdir')
 
     partitioning_factory = ds.DirectoryPartitioning.discover(
         ['group', 'key'], infer_dictionary=infer_dictionary)
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
 
     factory = ds.FileSystemDatasetFactory(
         mockfs, paths_or_selector, format, options)
@@ -1711,8 +1712,8 @@ def test_partitioning_factory_dictionary(mockfs, infer_dictionary, pickled):
 
 
 @pytest.mark.parametrize(
-    "pickled", [lambda x: x, lambda x: pickle.loads(pickle.dumps(x))])
-def test_partitioning_factory_segment_encoding(pickled):
+    "pickled", [lambda x, m: x, lambda x, m: m.loads(m.dumps(x))])
+def test_partitioning_factory_segment_encoding(pickled, pickle_module):
     mockfs = fs._MockFileSystem()
     format = ds.IpcFileFormat()
     schema = pa.schema([("i64", pa.int64())])
@@ -1737,7 +1738,7 @@ def test_partitioning_factory_segment_encoding(pickled):
     options = ds.FileSystemFactoryOptions("directory")
     partitioning_factory = ds.DirectoryPartitioning.discover(
         schema=partition_schema)
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     inferred_schema = factory.inspect()
     assert inferred_schema == full_schema
@@ -1748,7 +1749,7 @@ def test_partitioning_factory_segment_encoding(pickled):
 
     partitioning_factory = ds.DirectoryPartitioning.discover(
         ["date", "string"], segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1757,7 +1758,7 @@ def test_partitioning_factory_segment_encoding(pickled):
 
     partitioning = ds.DirectoryPartitioning(
         string_partition_schema, segment_encoding="none")
-    options.partitioning = pickled(partitioning)
+    options.partitioning = pickled(partitioning, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1766,7 +1767,7 @@ def test_partitioning_factory_segment_encoding(pickled):
 
     partitioning_factory = ds.DirectoryPartitioning.discover(
         schema=partition_schema, segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     with pytest.raises(pa.ArrowInvalid,
                        match="Could not cast segments for partition field"):
@@ -1777,7 +1778,7 @@ def test_partitioning_factory_segment_encoding(pickled):
     options = ds.FileSystemFactoryOptions("hive")
     partitioning_factory = ds.HivePartitioning.discover(
         schema=partition_schema)
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     inferred_schema = factory.inspect()
     assert inferred_schema == full_schema
@@ -1788,7 +1789,7 @@ def test_partitioning_factory_segment_encoding(pickled):
 
     partitioning_factory = ds.HivePartitioning.discover(
         segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1805,7 +1806,7 @@ def test_partitioning_factory_segment_encoding(pickled):
 
     partitioning_factory = ds.HivePartitioning.discover(
         schema=partition_schema, segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     with pytest.raises(pa.ArrowInvalid,
                        match="Could not cast segments for partition field"):
@@ -1813,8 +1814,8 @@ def test_partitioning_factory_segment_encoding(pickled):
 
 
 @pytest.mark.parametrize(
-    "pickled", [lambda x: x, lambda x: pickle.loads(pickle.dumps(x))])
-def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
+    "pickled", [lambda x, m: x, lambda x, m: m.loads(m.dumps(x))])
+def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled, pickle_module):
     mockfs = fs._MockFileSystem()
     format = ds.IpcFileFormat()
     schema = pa.schema([("i64", pa.int64())])
@@ -1845,7 +1846,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
     options = ds.FileSystemFactoryOptions("hive")
     partitioning_factory = ds.HivePartitioning.discover(
         schema=partition_schema)
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     inferred_schema = factory.inspect()
     assert inferred_schema == full_schema
@@ -1856,7 +1857,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
 
     partitioning_factory = ds.HivePartitioning.discover(
         segment_encoding="uri")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1865,7 +1866,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
 
     partitioning = ds.HivePartitioning(
         string_partition_schema, segment_encoding="uri")
-    options.partitioning = pickled(partitioning)
+    options.partitioning = pickled(partitioning, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1874,7 +1875,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
 
     partitioning_factory = ds.HivePartitioning.discover(
         segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1883,7 +1884,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
 
     partitioning = ds.HivePartitioning(
         string_partition_schema_en, segment_encoding="none")
-    options.partitioning = pickled(partitioning)
+    options.partitioning = pickled(partitioning, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     fragments = list(factory.finish().get_fragments())
     assert fragments[0].partition_expression.equals(
@@ -1892,7 +1893,7 @@ def test_partitioning_factory_hive_segment_encoding_key_encoded(pickled):
 
     partitioning_factory = ds.HivePartitioning.discover(
         schema=partition_schema_en, segment_encoding="none")
-    options.partitioning_factory = pickled(partitioning_factory)
+    options.partitioning_factory = pickled(partitioning_factory, pickle_module)
     factory = ds.FileSystemDatasetFactory(mockfs, selector, format, options)
     with pytest.raises(pa.ArrowInvalid,
                        match="Could not cast segments for partition field"):
@@ -2087,14 +2088,14 @@ def _create_directory_of_files(base_dir):
     return (table1, table2), (path1, path2)
 
 
-def _check_dataset(dataset, table, dataset_reader):
+def _check_dataset(dataset, table, dataset_reader, pickler):
     # also test that pickle roundtrip keeps the functionality
-    for d in [dataset, pickle.loads(pickle.dumps(dataset))]:
+    for d in [dataset, pickler.loads(pickler.dumps(dataset))]:
         assert dataset.schema.equals(table.schema)
         assert dataset_reader.to_table(dataset).equals(table)
 
 
-def _check_dataset_from_path(path, table, dataset_reader, **kwargs):
+def _check_dataset_from_path(path, table, dataset_reader, pickler, **kwargs):
     # pathlib object
     assert isinstance(path, pathlib.Path)
 
@@ -2102,39 +2103,39 @@ def _check_dataset_from_path(path, table, dataset_reader, **kwargs):
     for p in [path, str(path), [path], [str(path)]]:
         dataset = ds.dataset(path, **kwargs)
         assert isinstance(dataset, ds.FileSystemDataset)
-        _check_dataset(dataset, table, dataset_reader)
+        _check_dataset(dataset, table, dataset_reader, pickler)
 
     # relative string path
     with change_cwd(path.parent):
         dataset = ds.dataset(path.name, **kwargs)
         assert isinstance(dataset, ds.FileSystemDataset)
-        _check_dataset(dataset, table, dataset_reader)
+        _check_dataset(dataset, table, dataset_reader, pickler)
 
 
 @pytest.mark.parquet
-def test_open_dataset_single_file(tempdir, dataset_reader):
+def test_open_dataset_single_file(tempdir, dataset_reader, pickle_module):
     table, path = _create_single_file(tempdir)
-    _check_dataset_from_path(path, table, dataset_reader)
+    _check_dataset_from_path(path, table, dataset_reader, pickle_module)
 
 
 @pytest.mark.parquet
-def test_deterministic_row_order(tempdir, dataset_reader):
+def test_deterministic_row_order(tempdir, dataset_reader, pickle_module):
     # ARROW-8447 Ensure that dataset.to_table (and Scanner::ToTable) returns a
     # deterministic row ordering. This is achieved by constructing a single
     # parquet file with one row per RowGroup.
     table, path = _create_single_file(tempdir, row_group_size=1)
-    _check_dataset_from_path(path, table, dataset_reader)
+    _check_dataset_from_path(path, table, dataset_reader, pickle_module)
 
 
 @pytest.mark.parquet
-def test_open_dataset_directory(tempdir, dataset_reader):
+def test_open_dataset_directory(tempdir, dataset_reader, pickle_module):
     tables, _ = _create_directory_of_files(tempdir)
     table = pa.concat_tables(tables)
-    _check_dataset_from_path(tempdir, table, dataset_reader)
+    _check_dataset_from_path(tempdir, table, dataset_reader, pickle_module)
 
 
 @pytest.mark.parquet
-def test_open_dataset_list_of_files(tempdir, dataset_reader):
+def test_open_dataset_list_of_files(tempdir, dataset_reader, pickle_module):
     tables, (path1, path2) = _create_directory_of_files(tempdir)
     table = pa.concat_tables(tables)
 
@@ -2143,7 +2144,7 @@ def test_open_dataset_list_of_files(tempdir, dataset_reader):
         ds.dataset([str(path1), str(path2)])
     ]
     datasets += [
-        pickle.loads(pickle.dumps(d)) for d in datasets
+        pickle_module.loads(pickle_module.dumps(d)) for d in datasets
     ]
 
     for dataset in datasets:
@@ -2173,7 +2174,7 @@ def test_open_dataset_filesystem_fspath(tempdir):
 
 
 @pytest.mark.parquet
-def test_construct_from_single_file(tempdir, dataset_reader):
+def test_construct_from_single_file(tempdir, dataset_reader, pickle_module):
     directory = tempdir / 'single-file'
     directory.mkdir()
     table, path = _create_single_file(directory)
@@ -2186,14 +2187,14 @@ def test_construct_from_single_file(tempdir, dataset_reader):
     # instantiate from a single file with prefixed filesystem URI
     d3 = ds.dataset(str(relative_path), filesystem=_filesystem_uri(directory))
     # pickle roundtrip
-    d4 = pickle.loads(pickle.dumps(d1))
+    d4 = pickle_module.loads(pickle_module.dumps(d1))
 
     assert dataset_reader.to_table(d1) == dataset_reader.to_table(
         d2) == dataset_reader.to_table(d3) == dataset_reader.to_table(d4)
 
 
 @pytest.mark.parquet
-def test_construct_from_single_directory(tempdir, dataset_reader):
+def test_construct_from_single_directory(tempdir, dataset_reader, pickle_module):
     directory = tempdir / 'single-directory'
     directory.mkdir()
     tables, paths = _create_directory_of_files(directory)
@@ -2208,7 +2209,7 @@ def test_construct_from_single_directory(tempdir, dataset_reader):
 
     # test pickle roundtrip
     for d in [d1, d2, d3]:
-        restored = pickle.loads(pickle.dumps(d))
+        restored = pickle_module.loads(pickle_module.dumps(d))
         assert dataset_reader.to_table(restored) == t1
 
 
@@ -2403,12 +2404,12 @@ def _create_partitioned_dataset(basedir):
 
 
 @pytest.mark.parquet
-def test_open_dataset_partitioned_directory(tempdir, dataset_reader):
+def test_open_dataset_partitioned_directory(tempdir, dataset_reader, pickle_module):
     full_table, path = _create_partitioned_dataset(tempdir)
 
     # no partitioning specified, just read all individual files
     table = full_table.select(['a', 'b'])
-    _check_dataset_from_path(path, table, dataset_reader)
+    _check_dataset_from_path(path, table, dataset_reader, pickle_module)
 
     # specify partition scheme with discovery
     dataset = ds.dataset(
@@ -2470,14 +2471,14 @@ def test_open_dataset_unsupported_format(tempdir):
 
 
 @pytest.mark.parquet
-def test_open_union_dataset(tempdir, dataset_reader):
+def test_open_union_dataset(tempdir, dataset_reader, pickle_module):
     _, path = _create_single_file(tempdir)
     dataset = ds.dataset(path)
 
     union = ds.dataset([dataset, dataset])
     assert isinstance(union, ds.UnionDataset)
 
-    pickled = pickle.loads(pickle.dumps(union))
+    pickled = pickle_module.loads(pickle_module.dumps(union))
     assert dataset_reader.to_table(pickled) == dataset_reader.to_table(union)
 
 
@@ -2568,7 +2569,7 @@ def expected_type(key):
 
 
 @pytest.mark.pandas
-def test_dataset_partitioned_dictionary_type_reconstruct(tempdir):
+def test_dataset_partitioned_dictionary_type_reconstruct(tempdir, pickle_module):
     # https://issues.apache.org/jira/browse/ARROW-11400
     table = pa.table({'part': np.repeat(['A', 'B'], 5), 'col': range(10)})
     part = ds.partitioning(table.select(['part']).schema, flavor="hive")
@@ -2586,10 +2587,10 @@ def test_dataset_partitioned_dictionary_type_reconstruct(tempdir):
     assert fragment.to_table(schema=dataset.schema).equals(expected[:5])
     part_expr = fragment.partition_expression
 
-    restored = pickle.loads(pickle.dumps(dataset))
+    restored = pickle_module.loads(pickle_module.dumps(dataset))
     assert restored.to_table().equals(expected)
 
-    restored = pickle.loads(pickle.dumps(fragment))
+    restored = pickle_module.loads(pickle_module.dumps(fragment))
     assert restored.to_table(schema=dataset.schema).equals(expected[:5])
     # to_pandas call triggers computation of the actual dictionary values
     assert restored.to_table(schema=dataset.schema).to_pandas().equals(
@@ -3789,7 +3790,7 @@ def test_dataset_preserved_partitioning(tempdir):
     assert isinstance(dataset.partitioning, ds.DirectoryPartitioning)
     # TODO(GH-34884) partitioning attribute not preserved in pickling
     # dataset_ = ds.dataset(path)
-    # for dataset in [dataset_, pickle.loads(pickle.dumps(dataset_))]:
+    # for dataset in [dataset_, pickle_module.loads(pickle_module.dumps(dataset_))]:
     #     assert isinstance(dataset.partitioning, ds.DirectoryPartitioning)
 
     # through discovery, with hive partitioning but not specified
diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py
index 973aa29c7583f..1eb7d5fa76188 100644
--- a/python/pyarrow/tests/test_extension_type.py
+++ b/python/pyarrow/tests/test_extension_type.py
@@ -16,7 +16,6 @@
 # under the License.
 
 import os
-import pickle
 import shutil
 import subprocess
 import weakref
@@ -217,12 +216,12 @@ def test_ext_type_as_py():
         assert result.as_py() == expected
 
 
-def test_uuid_type_pickle():
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+def test_uuid_type_pickle(pickle_module):
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
         ty = UuidType()
-        ser = pickle.dumps(ty, protocol=proto)
+        ser = pickle_module.dumps(ty, protocol=proto)
         del ty
-        ty = pickle.loads(ser)
+        ty = pickle_module.loads(ser)
         wr = weakref.ref(ty)
         assert ty.extension_name == "arrow.py_extension_type"
         del ty
@@ -410,14 +409,14 @@ def test_ext_scalar_from_storage():
     assert s.value == pa.scalar(b"0123456789abcdef", ty.storage_type)
 
 
-def test_ext_array_pickling():
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+def test_ext_array_pickling(pickle_module):
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
         ty = ParamExtType(3)
         storage = pa.array([b"foo", b"bar"], type=pa.binary(3))
         arr = pa.ExtensionArray.from_storage(ty, storage)
-        ser = pickle.dumps(arr, protocol=proto)
+        ser = pickle_module.dumps(arr, protocol=proto)
         del ty, storage, arr
-        arr = pickle.loads(ser)
+        arr = pickle_module.loads(ser)
         arr.validate()
         assert isinstance(arr, pa.ExtensionArray)
         assert arr.type == ParamExtType(3)
@@ -867,23 +866,23 @@ def test_generic_ext_type_equality():
     assert not period_type == period_type3
 
 
-def test_generic_ext_type_pickling(registered_period_type):
+def test_generic_ext_type_pickling(registered_period_type, pickle_module):
     # GH-36038
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
         period_type, _ = registered_period_type
-        ser = pickle.dumps(period_type, protocol=proto)
-        period_type_pickled = pickle.loads(ser)
+        ser = pickle_module.dumps(period_type, protocol=proto)
+        period_type_pickled = pickle_module.loads(ser)
         assert period_type == period_type_pickled
 
 
-def test_generic_ext_array_pickling(registered_period_type):
-    for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+def test_generic_ext_array_pickling(registered_period_type, pickle_module):
+    for proto in range(0, pickle_module.HIGHEST_PROTOCOL + 1):
         period_type, _ = registered_period_type
         storage = pa.array([1, 2, 3, 4], pa.int64())
         arr = pa.ExtensionArray.from_storage(period_type, storage)
-        ser = pickle.dumps(arr, protocol=proto)
+        ser = pickle_module.dumps(arr, protocol=proto)
         del storage, arr
-        arr = pickle.loads(ser)
+        arr = pickle_module.loads(ser)
         arr.validate()
         assert isinstance(arr, pa.ExtensionArray)
         assert arr.type == period_type
@@ -1338,17 +1337,17 @@ def test_extension_to_pandas_storage_type(registered_period_type):
         assert isinstance(result["ext"].dtype, pd.ArrowDtype)
 
 
-def test_tensor_type_is_picklable():
+def test_tensor_type_is_picklable(pickle_module):
     # GH-35599
 
     expected_type = pa.fixed_shape_tensor(pa.int32(), (2, 2))
-    result = pickle.loads(pickle.dumps(expected_type))
+    result = pickle_module.loads(pickle_module.dumps(expected_type))
 
     assert result == expected_type
 
     arr = [[1, 2, 3, 4], [10, 20, 30, 40], [100, 200, 300, 400]]
     storage = pa.array(arr, pa.list_(pa.int32(), 4))
     expected_arr = pa.ExtensionArray.from_storage(expected_type, storage)
-    result = pickle.loads(pickle.dumps(expected_arr))
+    result = pickle_module.loads(pickle_module.dumps(expected_arr))
 
     assert result == expected_arr
diff --git a/python/pyarrow/tests/test_fs.py b/python/pyarrow/tests/test_fs.py
index b64680c87c8a5..8135f70f6905c 100644
--- a/python/pyarrow/tests/test_fs.py
+++ b/python/pyarrow/tests/test_fs.py
@@ -19,7 +19,6 @@
 import gzip
 import os
 import pathlib
-import pickle
 import subprocess
 import sys
 
@@ -559,17 +558,17 @@ def test_subtree_filesystem():
                                   ' base_fs=<pyarrow._fs.LocalFileSystem')
 
 
-def test_filesystem_pickling(fs):
+def test_filesystem_pickling(fs, pickle_module):
     if fs.type_name.split('::')[-1] == 'mock':
         pytest.xfail(reason='MockFileSystem is not serializable')
 
-    serialized = pickle.dumps(fs)
-    restored = pickle.loads(serialized)
+    serialized = pickle_module.dumps(fs)
+    restored = pickle_module.loads(serialized)
     assert isinstance(restored, FileSystem)
     assert restored.equals(fs)
 
 
-def test_filesystem_is_functional_after_pickling(fs, pathfn):
+def test_filesystem_is_functional_after_pickling(fs, pathfn, pickle_module):
     if fs.type_name.split('::')[-1] == 'mock':
         pytest.xfail(reason='MockFileSystem is not serializable')
     skip_fsspec_s3fs(fs)
@@ -584,7 +583,7 @@ def test_filesystem_is_functional_after_pickling(fs, pathfn):
     with fs.open_output_stream(c) as fp:
         fp.write(b'test')
 
-    restored = pickle.loads(pickle.dumps(fs))
+    restored = pickle_module.loads(pickle_module.dumps(fs))
     aaa_info, bb_info, c_info = restored.get_file_info([aaa, bb, c])
     assert aaa_info.type == FileType.Directory
     assert bb_info.type == FileType.File
@@ -1060,7 +1059,7 @@ def test_mockfs_mtime_roundtrip(mockfs):
 
 
 @pytest.mark.gcs
-def test_gcs_options():
+def test_gcs_options(pickle_module):
     from pyarrow.fs import GcsFileSystem
     dt = datetime.now()
     fs = GcsFileSystem(access_token='abc',
@@ -1072,20 +1071,20 @@ def test_gcs_options():
     assert isinstance(fs, GcsFileSystem)
     assert fs.default_bucket_location == 'us-west2'
     assert fs.project_id == 'test-project-id'
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = GcsFileSystem()
     assert isinstance(fs, GcsFileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = GcsFileSystem(anonymous=True)
     assert isinstance(fs, GcsFileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = GcsFileSystem(default_metadata={"ACL": "authenticated-read",
                                          "Content-Type": "text/plain"})
     assert isinstance(fs, GcsFileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     with pytest.raises(ValueError):
         GcsFileSystem(access_token='access')
@@ -1098,7 +1097,7 @@ def test_gcs_options():
 
 
 @pytest.mark.s3
-def test_s3_options():
+def test_s3_options(pickle_module):
     from pyarrow.fs import (AwsDefaultS3RetryStrategy,
                             AwsStandardS3RetryStrategy, S3FileSystem,
                             S3RetryStrategy)
@@ -1108,12 +1107,12 @@ def test_s3_options():
                       scheme='https', endpoint_override='localhost:8999')
     assert isinstance(fs, S3FileSystem)
     assert fs.region == 'us-east-2'
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = S3FileSystem(role_arn='role', session_name='session',
                       external_id='id', load_frequency=100)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     # Note that the retry strategy won't survive pickling for now
     fs = S3FileSystem(
@@ -1126,35 +1125,35 @@ def test_s3_options():
 
     fs2 = S3FileSystem(role_arn='role')
     assert isinstance(fs2, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs2)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs2
     assert fs2 != fs
 
     fs = S3FileSystem(anonymous=True)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = S3FileSystem(background_writes=True)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs2 = S3FileSystem(background_writes=True,
                        default_metadata={"ACL": "authenticated-read",
                                          "Content-Type": "text/plain"})
     assert isinstance(fs2, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs2)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs2
     assert fs2 != fs
 
     fs = S3FileSystem(allow_bucket_creation=True, allow_bucket_deletion=True)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = S3FileSystem(request_timeout=0.5, connect_timeout=0.25)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs2 = S3FileSystem(request_timeout=0.25, connect_timeout=0.5)
     assert isinstance(fs2, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs2)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs2
     assert fs2 != fs
 
     with pytest.raises(ValueError):
@@ -1182,7 +1181,7 @@ def test_s3_options():
 
 
 @pytest.mark.s3
-def test_s3_proxy_options(monkeypatch):
+def test_s3_proxy_options(monkeypatch, pickle_module):
     from pyarrow.fs import S3FileSystem
 
     # The following two are equivalent:
@@ -1195,111 +1194,111 @@ def test_s3_proxy_options(monkeypatch):
     # Check dict case for 'proxy_options'
     fs = S3FileSystem(proxy_options=proxy_opts_1_dict)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = S3FileSystem(proxy_options=proxy_opts_2_dict)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     # Check str case for 'proxy_options'
     fs = S3FileSystem(proxy_options=proxy_opts_1_str)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     fs = S3FileSystem(proxy_options=proxy_opts_2_str)
     assert isinstance(fs, S3FileSystem)
-    assert pickle.loads(pickle.dumps(fs)) == fs
+    assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     # Check that two FSs using the same proxy_options dict are equal
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     # Check that two FSs using the same proxy_options str are equal
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_str)
     fs2 = S3FileSystem(proxy_options=proxy_opts_1_str)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_2_str)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_str)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     # Check that two FSs using equivalent proxy_options
     # (one dict, one str) are equal
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_1_str)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_str)
     assert fs1 == fs2
-    assert pickle.loads(pickle.dumps(fs1)) == fs2
-    assert pickle.loads(pickle.dumps(fs2)) == fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) == fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) == fs1
 
     # Check that two FSs using nonequivalent proxy_options are not equal
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_str)
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_str)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_str)
     fs2 = S3FileSystem(proxy_options=proxy_opts_2_str)
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     # Check that two FSs (one using proxy_options and the other not)
     # are not equal
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_dict)
     fs2 = S3FileSystem()
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_1_str)
     fs2 = S3FileSystem()
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_2_dict)
     fs2 = S3FileSystem()
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     fs1 = S3FileSystem(proxy_options=proxy_opts_2_str)
     fs2 = S3FileSystem()
     assert fs1 != fs2
-    assert pickle.loads(pickle.dumps(fs1)) != fs2
-    assert pickle.loads(pickle.dumps(fs2)) != fs1
+    assert pickle_module.loads(pickle_module.dumps(fs1)) != fs2
+    assert pickle_module.loads(pickle_module.dumps(fs2)) != fs1
 
     # Only dict and str are supported
     with pytest.raises(TypeError):
@@ -1347,7 +1346,7 @@ def test_s3fs_wrong_region():
 
 
 @pytest.mark.hdfs
-def test_hdfs_options(hdfs_connection):
+def test_hdfs_options(hdfs_connection, pickle_module):
     from pyarrow.fs import HadoopFileSystem
     if not pa.have_libhdfs():
         pytest.skip('Cannot locate libhdfs')
@@ -1405,7 +1404,7 @@ def test_hdfs_options(hdfs_connection):
 
     for fs in [hdfs1, hdfs2, hdfs3, hdfs4, hdfs5, hdfs6, hdfs7, hdfs8,
                hdfs9, hdfs10, hdfs11]:
-        assert pickle.loads(pickle.dumps(fs)) == fs
+        assert pickle_module.loads(pickle_module.dumps(fs)) == fs
 
     host, port, user = hdfs_connection
 
@@ -1524,12 +1523,12 @@ def test_py_filesystem_equality():
     assert fs1 != object()
 
 
-def test_py_filesystem_pickling():
+def test_py_filesystem_pickling(pickle_module):
     handler = DummyHandler()
     fs = PyFileSystem(handler)
 
-    serialized = pickle.dumps(fs)
-    restored = pickle.loads(serialized)
+    serialized = pickle_module.dumps(fs)
+    restored = pickle_module.loads(serialized)
     assert isinstance(restored, FileSystem)
     assert restored == fs
     assert restored.handler == handler
diff --git a/python/pyarrow/tests/test_hdfs.py b/python/pyarrow/tests/test_hdfs.py
index 1f5f10f7d9e3d..511dbf9a1c4e1 100644
--- a/python/pyarrow/tests/test_hdfs.py
+++ b/python/pyarrow/tests/test_hdfs.py
@@ -16,9 +16,7 @@
 # under the License.
 
 import os
-import pickle
 import random
-import unittest
 from io import BytesIO
 from os.path import join as pjoin
 
@@ -81,20 +79,20 @@ def _make_test_file(self, hdfs, test_name, test_path, test_data):
         return full_path
 
     @classmethod
-    def setUpClass(cls):
+    def setup_class(cls):
         cls.check_driver()
         cls.hdfs = hdfs_test_client()
         cls.tmp_path = '/tmp/pyarrow-test-{}'.format(random.randint(0, 1000))
         cls.hdfs.mkdir(cls.tmp_path)
 
     @classmethod
-    def tearDownClass(cls):
+    def teardown_class(cls):
         cls.hdfs.delete(cls.tmp_path, recursive=True)
         cls.hdfs.close()
 
-    def test_pickle(self):
-        s = pickle.dumps(self.hdfs)
-        h2 = pickle.loads(s)
+    def test_pickle(self, pickle_module):
+        s = pickle_module.dumps(self.hdfs)
+        h2 = pickle_module.loads(s)
         assert h2.is_open
         assert h2.host == self.hdfs.host
         assert h2.port == self.hdfs.port
@@ -392,7 +390,7 @@ def test_write_to_dataset_no_partitions(self):
             tmpdir, filesystem=self.hdfs)
 
 
-class TestLibHdfs(HdfsTestCases, unittest.TestCase):
+class TestLibHdfs(HdfsTestCases):
 
     @classmethod
     def check_driver(cls):
diff --git a/python/pyarrow/tests/test_io.py b/python/pyarrow/tests/test_io.py
index a6488d70df53e..0c9e591ccd466 100644
--- a/python/pyarrow/tests/test_io.py
+++ b/python/pyarrow/tests/test_io.py
@@ -24,7 +24,6 @@
 import math
 import os
 import pathlib
-import pickle
 import pytest
 import sys
 import tempfile
@@ -372,17 +371,17 @@ def test_python_file_closing():
 # Buffers
 
 
-def check_buffer_pickling(buf):
+def check_buffer_pickling(buf, pickler):
     # Check that buffer survives a pickle roundtrip
-    for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-        result = pickle.loads(pickle.dumps(buf, protocol=protocol))
+    for protocol in range(0, pickler.HIGHEST_PROTOCOL + 1):
+        result = pickler.loads(pickler.dumps(buf, protocol=protocol))
         assert len(result) == len(buf)
         assert memoryview(result) == memoryview(buf)
         assert result.to_pybytes() == buf.to_pybytes()
         assert result.is_mutable == buf.is_mutable
 
 
-def test_buffer_bytes():
+def test_buffer_bytes(pickle_module):
     val = b'some data'
 
     buf = pa.py_buffer(val)
@@ -393,10 +392,10 @@ def test_buffer_bytes():
     result = buf.to_pybytes()
     assert result == val
 
-    check_buffer_pickling(buf)
+    check_buffer_pickling(buf, pickle_module)
 
 
-def test_buffer_null_data():
+def test_buffer_null_data(pickle_module):
     null_buff = pa.foreign_buffer(address=0, size=0)
     assert null_buff.to_pybytes() == b""
     assert null_buff.address == 0
@@ -406,10 +405,10 @@ def test_buffer_null_data():
     assert m.tobytes() == b""
     assert pa.py_buffer(m).address != 0
 
-    check_buffer_pickling(null_buff)
+    check_buffer_pickling(null_buff, pickle_module)
 
 
-def test_buffer_memoryview():
+def test_buffer_memoryview(pickle_module):
     val = b'some data'
 
     buf = pa.py_buffer(val)
@@ -420,10 +419,10 @@ def test_buffer_memoryview():
     result = memoryview(buf)
     assert result == val
 
-    check_buffer_pickling(buf)
+    check_buffer_pickling(buf, pickle_module)
 
 
-def test_buffer_bytearray():
+def test_buffer_bytearray(pickle_module):
     val = bytearray(b'some data')
 
     buf = pa.py_buffer(val)
@@ -434,7 +433,7 @@ def test_buffer_bytearray():
     result = bytearray(buf)
     assert result == val
 
-    check_buffer_pickling(buf)
+    check_buffer_pickling(buf, pickle_module)
 
 
 def test_buffer_invalid():
diff --git a/python/pyarrow/tests/test_json.py b/python/pyarrow/tests/test_json.py
index f37019ade574c..be83f891a2fb4 100644
--- a/python/pyarrow/tests/test_json.py
+++ b/python/pyarrow/tests/test_json.py
@@ -20,7 +20,6 @@
 import io
 import itertools
 import json
-import pickle
 import string
 import unittest
 
@@ -53,15 +52,15 @@ def make_random_json(num_cols=2, num_rows=10, linesep='\r\n'):
     return data, expected
 
 
-def check_options_class_pickling(cls, **attr_values):
+def check_options_class_pickling(cls, pickler, **attr_values):
     opts = cls(**attr_values)
-    new_opts = pickle.loads(pickle.dumps(opts,
-                                         protocol=pickle.HIGHEST_PROTOCOL))
+    new_opts = pickler.loads(pickler.dumps(opts,
+                                           protocol=pickler.HIGHEST_PROTOCOL))
     for name, value in attr_values.items():
         assert getattr(new_opts, name) == value
 
 
-def test_read_options():
+def test_read_options(pickle_module):
     cls = ReadOptions
     opts = cls()
 
@@ -77,11 +76,12 @@ def test_read_options():
     assert opts.block_size == 1234
     assert opts.use_threads is False
 
-    check_options_class_pickling(cls, block_size=1234,
+    check_options_class_pickling(cls, pickler=pickle_module,
+                                 block_size=1234,
                                  use_threads=False)
 
 
-def test_parse_options():
+def test_parse_options(pickle_module):
     cls = ParseOptions
     opts = cls()
     assert opts.newlines_in_values is False
@@ -102,7 +102,8 @@ def test_parse_options():
     with pytest.raises(ValueError):
         opts.unexpected_field_behavior = "invalid-value"
 
-    check_options_class_pickling(cls, explicit_schema=schema,
+    check_options_class_pickling(cls, pickler=pickle_module,
+                                 explicit_schema=schema,
                                  newlines_in_values=False,
                                  unexpected_field_behavior="ignore")
 
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index d52edce6d91a8..5f6c8c813f12a 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -17,7 +17,6 @@
 
 import datetime
 import decimal
-import pickle
 import pytest
 import sys
 import weakref
@@ -68,7 +67,7 @@
     ({'a': 1, 'b': [1, 2]}, None, pa.StructScalar),
     ([('a', 1), ('b', 2)], pa.map_(pa.string(), pa.int8()), pa.MapScalar),
 ])
-def test_basics(value, ty, klass):
+def test_basics(value, ty, klass, pickle_module):
     s = pa.scalar(value, type=ty)
     s.validate()
     s.validate(full=True)
@@ -87,7 +86,7 @@ def test_basics(value, ty, klass):
     assert s != pa.scalar(value, type=ty)
 
     # test pickle roundtrip
-    restored = pickle.loads(pickle.dumps(s))
+    restored = pickle_module.loads(pickle_module.dumps(s))
     assert s.equals(restored)
 
     # test that scalars are weak-referenceable
@@ -110,7 +109,7 @@ def test_null_singleton():
         pa.NullScalar()
 
 
-def test_nulls():
+def test_nulls(pickle_module):
     null = pa.scalar(None)
     assert null is pa.NA
     assert null.as_py() is None
@@ -126,7 +125,7 @@ def test_nulls():
         assert v.as_py() is None
 
     # test pickle roundtrip
-    restored = pickle.loads(pickle.dumps(null))
+    restored = pickle_module.loads(pickle_module.dumps(null))
     assert restored.equals(null)
 
     # test that scalars are weak-referenceable
@@ -683,7 +682,7 @@ def test_struct_duplicate_fields():
         s.as_py()
 
 
-def test_map():
+def test_map(pickle_module):
     ty = pa.map_(pa.string(), pa.int8())
     v = [('a', 1), ('b', 2)]
     s = pa.scalar(v, type=ty)
@@ -713,11 +712,11 @@ def test_map():
     with pytest.raises(IndexError):
         s[2]
 
-    restored = pickle.loads(pickle.dumps(s))
+    restored = pickle_module.loads(pickle_module.dumps(s))
     assert restored.equals(s)
 
 
-def test_dictionary():
+def test_dictionary(pickle_module):
     indices = pa.array([2, None, 1, 2, 0, None])
     dictionary = pa.array(['foo', 'bar', 'baz'])
 
@@ -733,7 +732,7 @@ def test_dictionary():
         assert s.index.equals(i)
         assert s.dictionary.equals(dictionary)
 
-        restored = pickle.loads(pickle.dumps(s))
+        restored = pickle_module.loads(pickle_module.dumps(s))
         assert restored.equals(s)
 
 
@@ -758,7 +757,7 @@ def test_run_end_encoded():
         pa.scalar(1, pa.run_end_encoded(pa.int64(), pa.int64()))
 
 
-def test_union():
+def test_union(pickle_module):
     # sparse
     arr = pa.UnionArray.from_sparse(
         pa.array([0, 0, 1, 1], type=pa.int8()),
@@ -773,7 +772,7 @@ def test_union():
         assert s.type.equals(arr.type)
         assert s.is_valid is True
         with pytest.raises(pa.ArrowNotImplementedError):
-            pickle.loads(pickle.dumps(s))
+            pickle_module.loads(pickle_module.dumps(s))
 
     assert arr[0].type_code == 0
     assert arr[0].as_py() == "a"
@@ -799,7 +798,7 @@ def test_union():
         assert s.type.equals(arr.type)
         assert s.is_valid is True
         with pytest.raises(pa.ArrowNotImplementedError):
-            pickle.loads(pickle.dumps(s))
+            pickle_module.loads(pickle_module.dumps(s))
 
     assert arr[0].type_code == 0
     assert arr[0].as_py() == b'a'
diff --git a/python/pyarrow/tests/test_schema.py b/python/pyarrow/tests/test_schema.py
index 2c2f9547f2276..e28e0ac445ef8 100644
--- a/python/pyarrow/tests/test_schema.py
+++ b/python/pyarrow/tests/test_schema.py
@@ -16,7 +16,6 @@
 # under the License.
 
 from collections import OrderedDict
-import pickle
 import sys
 import weakref
 
@@ -585,7 +584,7 @@ def test_schema_repr_with_dictionaries():
     assert repr(sch) == expected
 
 
-def test_type_schema_pickling():
+def test_type_schema_pickling(pickle_module):
     cases = [
         pa.int8(),
         pa.string(),
@@ -621,7 +620,7 @@ def test_type_schema_pickling():
     ]
 
     for val in cases:
-        roundtripped = pickle.loads(pickle.dumps(val))
+        roundtripped = pickle_module.loads(pickle_module.dumps(val))
         assert val == roundtripped
 
     fields = []
@@ -632,7 +631,7 @@ def test_type_schema_pickling():
             fields.append(pa.field('_f{}'.format(i), f))
 
     schema = pa.schema(fields, metadata={b'foo': b'bar'})
-    roundtripped = pickle.loads(pickle.dumps(schema))
+    roundtripped = pickle_module.loads(pickle_module.dumps(schema))
     assert schema == roundtripped
 
 
diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py
index e28256e91f0a6..f93c6bbc2c204 100644
--- a/python/pyarrow/tests/test_table.py
+++ b/python/pyarrow/tests/test_table.py
@@ -17,7 +17,6 @@
 
 from collections import OrderedDict
 from collections.abc import Iterable
-import pickle
 import sys
 import weakref
 
@@ -301,14 +300,14 @@ def ne(xarrs, yarrs):
             pa.struct([pa.field('a', pa.int64()), pa.field('b', pa.string())]))
     ]
 )
-def test_chunked_array_pickle(data, typ):
+def test_chunked_array_pickle(data, typ, pickle_module):
     arrays = []
     while data:
         arrays.append(pa.array(data[:2], type=typ))
         data = data[2:]
     array = pa.chunked_array(arrays, type=typ)
     array.validate()
-    result = pickle.loads(pickle.dumps(array))
+    result = pickle_module.loads(pickle_module.dumps(array))
     result.validate()
     assert result.equals(array)
 
@@ -663,7 +662,7 @@ def test_recordbatch_empty_metadata():
     assert batch.schema.metadata is None
 
 
-def test_recordbatch_pickle():
+def test_recordbatch_pickle(pickle_module):
     data = [
         pa.array(range(5), type='int8'),
         pa.array([-10, -5, 0, 5, 10], type='float32')
@@ -675,7 +674,7 @@ def test_recordbatch_pickle():
     schema = pa.schema(fields, metadata={b'foo': b'bar'})
     batch = pa.record_batch(data, schema=schema)
 
-    result = pickle.loads(pickle.dumps(batch))
+    result = pickle_module.loads(pickle_module.dumps(batch))
     assert result.equals(batch)
     assert result.schema == schema
 
@@ -1022,7 +1021,7 @@ def test_table_from_lists():
     assert result.equals(expected)
 
 
-def test_table_pickle():
+def test_table_pickle(pickle_module):
     data = [
         pa.chunked_array([[1, 2], [3, 4]], type=pa.uint32()),
         pa.chunked_array([["some", "strings", None, ""]], type=pa.string()),
@@ -1032,7 +1031,7 @@ def test_table_pickle():
                        metadata={b'foo': b'bar'})
     table = pa.Table.from_arrays(data, schema=schema)
 
-    result = pickle.loads(pickle.dumps(table))
+    result = pickle_module.loads(pickle_module.dumps(table))
     result.validate()
     assert result.equals(table)
 
diff --git a/python/pyarrow/tests/test_types.py b/python/pyarrow/tests/test_types.py
index 568702d8e888f..f3b6001003d9c 100644
--- a/python/pyarrow/tests/test_types.py
+++ b/python/pyarrow/tests/test_types.py
@@ -21,7 +21,6 @@
 import datetime
 import sys
 
-import pickle
 import pytest
 import hypothesis as h
 import hypothesis.strategies as st
@@ -790,10 +789,10 @@ def test_types_hashable():
         assert in_dict[type_] == i
 
 
-def test_types_picklable():
+def test_types_picklable(pickle_module):
     for ty in get_many_types():
-        data = pickle.dumps(ty)
-        assert pickle.loads(data) == ty
+        data = pickle_module.dumps(ty)
+        assert pickle_module.loads(data) == ty
 
 
 def test_types_weakref():
@@ -1193,9 +1192,9 @@ def test_is_boolean_value():
 @h.example(
     pa.field(name='', type=pa.null(), metadata={'0': '', '': ''})
 )
-def test_pickling(field):
-    data = pickle.dumps(field)
-    assert pickle.loads(data) == field
+def test_pickling(pickle_module, field):
+    data = pickle_module.dumps(field)
+    assert pickle_module.loads(data) == field
 
 
 @h.given(

From 59954225d4615f9b3bd7a3c266fb68761794229a Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 24 Aug 2023 08:21:51 +0100
Subject: [PATCH 229/749] GH-37325: [R] Update NEWS.md with missing changes for
 13.0.0  (#37326)

### Rationale for this change

Missing items in NEWS.md need documenting

### What changes are included in this PR?

Adding these items

### Are these changes tested?

No
* Closes: #37325

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NEWS.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/r/NEWS.md b/r/NEWS.md
index d789231187e3b..d80efbf8de18e 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -21,11 +21,16 @@
 
 # arrow 13.0.0
 
+## Breaking changes
+
+* Input objects which inherit only from `data.frame` and no other classes now have the `class` attribute dropped, resulting in now always returning tibbles from file reading functions and `arrow_table()`, which results in consistency in the type of returned objects.  Calling `as.data.frame()` on Arrow Tabular objects now always returns a `data.frame` object (#34775)
+
 ## New features
 
 * `open_dataset()` now works with ND-JSON files (#35055)
 * Calling `schema()` on multiple Arrow objects now returns the object's schema (#35543)
 * dplyr `.by`/`by` argument now supported in arrow implementation of dplyr verbs  (@eitsupi, #35667)
+* Binding for `dplyr::case_when()` now accepts `.default` parameter to match the update in dplyr 1.1.0 (#35502)
 
 ## Minor improvements and fixes
 

From b9453a2a33e935e26dc8358846ad671aefdcb4d0 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 24 Aug 2023 18:43:57 +0900
Subject: [PATCH 230/749] GH-37329: [Release][Homebrew] Follow directory
 structure change (#37349)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

    Before: Formula/apache-arrow-glib.rb
    After:  Formula/a/apache-arrow-glib.rb

### What changes are included in this PR?

Remove `Formula/*/` from `Formula/a/apache-arrow-glib.rb` path to detect formula name.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37329

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/release/post-13-homebrew.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/release/post-13-homebrew.sh b/dev/release/post-13-homebrew.sh
index 14f41b158f777..fa73dd0d96002 100755
--- a/dev/release/post-13-homebrew.sh
+++ b/dev/release/post-13-homebrew.sh
@@ -67,7 +67,7 @@ brew bump-formula-pr \
      apache-arrow-glib
 
 for dependency in $(grep -l -r 'depends_on "apache-arrow"' Formula); do
-  dependency=${dependency#Formula/}
+  dependency=${dependency#Formula/*/}
   dependency=${dependency%.rb}
   if [ ${dependency} = "apache-arrow-glib" ]; then
     continue

From 9958896fe067dbda351b9937cc97686c9d9ac93c Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 24 Aug 2023 12:56:55 -0300
Subject: [PATCH 231/749] GH-37173: [C++][Go][Format] C-export/import Run-End
 Encoded Arrays (#37174)

### Rationale for this change

All array types should be C-exportable.

It uses `"+r"` as the format string. `+` because it's a nested format and `r` was not taken and seems like the obvious choice.

### What changes are included in this PR?

- [x] Ability to C-import/expor REE arrays.
- [x] Reference update

### Are these changes tested?

Yes.
* Closes: #37173

Lead-authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Co-authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/c/bridge.cc                 |  31 +++
 cpp/src/arrow/c/bridge_test.cc            | 230 +++++++++++++++++++++-
 cpp/src/arrow/type.cc                     |   2 +-
 docs/source/format/CDataInterface.rst     |  10 +
 go/arrow/array/encoded.go                 |   2 +-
 go/arrow/cdata/cdata.go                   |  26 +++
 go/arrow/cdata/cdata_exports.go           |  10 +
 go/arrow/cdata/cdata_test.go              |  14 ++
 go/arrow/cdata/cdata_test_framework.go    |  12 +-
 go/arrow/cdata/test/test_export_to_cgo.py |  19 +-
 10 files changed, 339 insertions(+), 17 deletions(-)

diff --git a/cpp/src/arrow/c/bridge.cc b/cpp/src/arrow/c/bridge.cc
index b967af28e4aec..033371d3d6719 100644
--- a/cpp/src/arrow/c/bridge.cc
+++ b/cpp/src/arrow/c/bridge.cc
@@ -478,6 +478,8 @@ struct SchemaExporter {
     return Status::OK();
   }
 
+  Status Visit(const RunEndEncodedType& type) { return SetFormat("+r"); }
+
   ExportedSchemaPrivateData export_;
   int64_t flags_ = 0;
   std::vector<std::pair<std::string, std::string>> additional_metadata_;
@@ -1106,6 +1108,8 @@ struct SchemaImporter {
         return ProcessMap();
       case 'u':
         return ProcessUnion();
+      case 'r':
+        return ProcessREE();
     }
     return f_parser_.Invalid();
   }
@@ -1280,6 +1284,22 @@ struct SchemaImporter {
     return Status::OK();
   }
 
+  Status ProcessREE() {
+    RETURN_NOT_OK(f_parser_.CheckAtEnd());
+    RETURN_NOT_OK(CheckNumChildren(2));
+    ARROW_ASSIGN_OR_RAISE(auto run_ends_field, MakeChildField(0));
+    ARROW_ASSIGN_OR_RAISE(auto values_field, MakeChildField(1));
+    if (!is_run_end_type(run_ends_field->type()->id())) {
+      return Status::Invalid("Expected a valid run-end integer type, but struct has ",
+                             run_ends_field->type()->ToString());
+    }
+    if (values_field->type()->id() == Type::RUN_END_ENCODED) {
+      return Status::Invalid("ArrowArray struct contains a nested run-end encoded array");
+    }
+    type_ = run_end_encoded(run_ends_field->type(), values_field->type());
+    return Status::OK();
+  }
+
   Result<std::shared_ptr<Field>> MakeChildField(int64_t child_id) {
     const auto& child = child_importers_[child_id];
     if (child.c_struct_->name == nullptr) {
@@ -1601,6 +1621,17 @@ struct ArrayImporter {
     return Status::OK();
   }
 
+  Status Visit(const RunEndEncodedType& type) {
+    RETURN_NOT_OK(CheckNumChildren(2));
+    RETURN_NOT_OK(CheckNumBuffers(0));
+    RETURN_NOT_OK(AllocateArrayData());
+    // Always have a null bitmap buffer as much of the code in arrow assumes
+    // the buffers vector to have at least one entry on every array format.
+    data_->buffers.emplace_back(nullptr);
+    data_->null_count = 0;
+    return Status::OK();
+  }
+
   Status ImportFixedSizePrimitive(const FixedWidthType& type) {
     RETURN_NOT_OK(CheckNoChildren());
     RETURN_NOT_OK(CheckNumBuffers(2));
diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 9727403163e58..bd0e498a9f332 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -43,6 +43,11 @@
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 
+// TODO(GH-37221): Remove these ifdef checks when compute dependency is removed
+#ifdef ARROW_COMPUTE
+#include "arrow/compute/api_vector.h"
+#endif
+
 namespace arrow {
 
 using internal::ArrayExportGuard;
@@ -443,6 +448,20 @@ TEST_F(TestSchemaExport, Union) {
              {ARROW_FLAG_NULLABLE});
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestSchemaExport, RunEndEncoded) {
+  TestNested(run_end_encoded(int16(), uint8()), {"+r", "s", "C"},
+             {"", "run_ends", "values"}, {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE});
+  TestNested(run_end_encoded(int32(), float64()), {"+r", "i", "g"},
+             {"", "run_ends", "values"}, {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE});
+  TestNested(run_end_encoded(int64(), utf8()), {"+r", "l", "u"},
+             {"", "run_ends", "values"}, {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE});
+  TestNested(run_end_encoded(int32(), list(utf8())), {"+r", "i", "+l", "u"},
+             {"", "run_ends", "values", "item"},
+             {ARROW_FLAG_NULLABLE, 0, ARROW_FLAG_NULLABLE, ARROW_FLAG_NULLABLE});
+}
+#endif
+
 std::string GetIndexFormat(Type::type type_id) {
   switch (type_id) {
     case Type::UINT8:
@@ -952,6 +971,36 @@ TEST_F(TestArrayExport, Union) {
   TestNested(type, data);
 }
 
+#ifdef ARROW_COMPUTE
+Result<std::shared_ptr<Array>> REEFromJSON(const std::shared_ptr<DataType>& ree_type,
+                                           const std::string& json) {
+  auto ree_type_ptr = checked_cast<const RunEndEncodedType*>(ree_type.get());
+  auto array = ArrayFromJSON(ree_type_ptr->value_type(), json);
+  ARROW_ASSIGN_OR_RAISE(
+      auto datum,
+      RunEndEncode(array, compute::RunEndEncodeOptions{ree_type_ptr->run_end_type()}));
+  return datum.make_array();
+}
+
+TEST_F(TestArrayExport, RunEndEncoded) {
+  auto factory = []() {
+    return REEFromJSON(run_end_encoded(int32(), int8()),
+                       "[1, 2, 2, 3, null, null, null, 4]");
+  };
+  TestNested(factory);
+}
+
+TEST_F(TestArrayExport, RunEndEncodedSliced) {
+  auto factory = []() -> Result<std::shared_ptr<Array>> {
+    ARROW_ASSIGN_OR_RAISE(auto ree_array,
+                          REEFromJSON(run_end_encoded(int32(), int8()),
+                                      "[1, 2, 2, 3, null, null, null, 4]"));
+    return ree_array->Slice(1, 5);
+  };
+  TestNested(factory);
+}
+#endif
+
 TEST_F(TestArrayExport, Dictionary) {
   {
     auto factory = []() {
@@ -1269,6 +1318,17 @@ class TestDeviceArrayExport : public ::testing::Test {
     return [=]() { return ToDevice(mm, *ArrayFromJSON(type, json)->data()); };
   }
 
+#ifdef ARROW_COMPUTE
+  static std::function<Result<std::shared_ptr<Array>>()> JSONREEArrayFactory(
+      const std::shared_ptr<MemoryManager>& mm, std::shared_ptr<DataType> type,
+      const char* json) {
+    return [=]() -> Result<std::shared_ptr<Array>> {
+      ARROW_ASSIGN_OR_RAISE(auto result, REEFromJSON(type, json));
+      return ToDevice(mm, *result->data());
+    };
+  }
+#endif
+
   template <typename ArrayFactory, typename ExportCheckFunc>
   void TestWithArrayFactory(ArrayFactory&& factory, ExportCheckFunc&& check_func) {
     auto orig_bytes = pool_->bytes_allocated();
@@ -1465,6 +1525,17 @@ TEST_F(TestDeviceArrayExport, Union) {
   TestNested(mm, type, data);
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestDeviceArrayExport, RunEndEncoded) {
+  std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
+  auto mm = device->default_memory_manager();
+
+  auto type = run_end_encoded(int32(), int32());
+  const char* data = "[1, null, 2, 2, 4, 5]";
+  TestNested(JSONREEArrayFactory(mm, type, data));
+}
+#endif
+
 TEST_F(TestDeviceArrayExport, Extension) {
   std::shared_ptr<Device> device = std::make_shared<MyDevice>(1);
   auto mm = device->default_memory_manager();
@@ -1564,11 +1635,10 @@ class SchemaStructBuilder {
 
   // Create a new ArrowSchema struct with a stable C pointer
   struct ArrowSchema* AddChild() {
-    nested_structs_.emplace_back();
-    struct ArrowSchema* result = &nested_structs_.back();
-    memset(result, 0, sizeof(*result));
-    result->release = NoOpSchemaRelease;
-    return result;
+    auto& result = nested_structs_.emplace_back();
+    memset(&result, 0, sizeof(result));
+    result.release = NoOpSchemaRelease;
+    return &result;
   }
 
   // Create a stable C pointer to the N last structs in nested_structs_
@@ -1620,6 +1690,17 @@ class SchemaStructBuilder {
     c->children = NLastChildren(c->n_children, c);
   }
 
+  void FillRunEndEncoded(struct ArrowSchema* c, const char* format,
+                         const char* name = nullptr, int64_t flags = kDefaultFlags) {
+    c->flags = flags;
+    c->format = format;
+    c->name = name;
+    c->n_children = 2;
+    c->children = NLastChildren(2, c);
+    c->children[0]->name = "run_ends";
+    c->children[1]->name = "values";
+  }
+
   void FillPrimitive(const char* format, const char* name = nullptr,
                      int64_t flags = kDefaultFlags) {
     FillPrimitive(&c_struct_, format, name, flags);
@@ -1637,6 +1718,11 @@ class SchemaStructBuilder {
     FillStructLike(&c_struct_, format, n_children, name, flags);
   }
 
+  void FillRunEndEncoded(const char* format, const char* name = nullptr,
+                         int64_t flags = kDefaultFlags) {
+    FillRunEndEncoded(&c_struct_, format, name, flags);
+  }
+
   struct ArrowSchema c_struct_;
   // Deque elements don't move when the deque is appended to, which allows taking
   // stable C pointers to them.
@@ -1902,6 +1988,15 @@ TEST_F(TestSchemaImport, Map) {
   CheckImport(expected);
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestSchemaImport, RunEndEncoded) {
+  FillPrimitive(AddChild(), "s", "run_ends");
+  FillPrimitive(AddChild(), "I", "values");
+  FillRunEndEncoded("+r");
+  CheckImport(run_end_encoded(int16(), uint32()));
+}
+#endif
+
 TEST_F(TestSchemaImport, Dictionary) {
   FillPrimitive(AddChild(), "u");
   FillPrimitive("c");
@@ -2021,6 +2116,33 @@ TEST_F(TestSchemaImport, UnionError) {
   CheckImportError();
 }
 
+TEST_F(TestSchemaImport, RunEndEncodedError) {
+  // Bad run-end type
+  FillPrimitive(AddChild(), "c", "run_ends");
+  FillPrimitive(AddChild(), "u", "values");
+  FillRunEndEncoded("+r");
+  CheckImportError();
+
+  // REE of a REE also causes an error
+  ArrowSchema* run_ends = AddChild();
+  ArrowSchema* values;
+  FillPrimitive(run_ends, "i", "run_ends");
+  {
+    FillPrimitive(AddChild(), "i", "run_ends");
+    FillPrimitive(AddChild(), "u", "values");
+    values = AddChild();
+    FillRunEndEncoded(values, "+r", "values");
+  }
+  // Fill the top-level REE
+  ArrowSchema* children[2] = {run_ends, values};
+  c_struct_.flags = kDefaultFlags;
+  c_struct_.format = "+r";
+  c_struct_.name = "";
+  c_struct_.n_children = 2;
+  c_struct_.children = children;
+  CheckImportError();
+}
+
 TEST_F(TestSchemaImport, DictionaryError) {
   // Bad index type
   FillPrimitive(AddChild(), "c");
@@ -2178,6 +2300,10 @@ static const void* timestamp_buffers_no_nulls2[2] = {nullptr, timestamp_data_buf
 static const void* timestamp_buffers_no_nulls3[2] = {nullptr, timestamp_data_buffer3};
 static const void* timestamp_buffers_no_nulls4[2] = {nullptr, timestamp_data_buffer4};
 
+static const uint16_t run_ends_data_buffer5[5] = {1, 2, 4, 7, 9};
+[[maybe_unused]] static const void* run_ends_buffers5[2] = {nullptr,
+                                                            run_ends_data_buffer5};
+
 static const uint8_t string_data_buffer1[] = "foobarquuxxyzzy";
 
 static const int32_t string_offsets_buffer1[] = {0, 3, 3, 6, 10, 15};
@@ -2354,6 +2480,20 @@ class TestArrayImport : public ::testing::Test {
                   legacy);
   }
 
+  void FillRunEndEncoded(int64_t length, int64_t offset) {
+    FillRunEndEncoded(&c_struct_, length, offset);
+  }
+
+  void FillRunEndEncoded(struct ArrowArray* c, int64_t length, int64_t offset) {
+    c->length = length;
+    c->null_count = 0;
+    c->offset = offset;
+    c->n_buffers = 0;
+    c->buffers = nullptr;
+    c->n_children = 2;
+    c->children = NLastChildren(2, c);
+  }
+
   void CheckImport(const std::shared_ptr<Array>& expected) {
     ArrayReleaseCallback cb(&c_struct_);
 
@@ -2704,6 +2844,51 @@ TEST_F(TestArrayImport, Struct) {
   CheckImport(expected);
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestArrayImport, RunEndEncoded) {
+  FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
+  FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
+  FillRunEndEncoded(9, 0);
+  ASSERT_OK_AND_ASSIGN(auto expected,
+                       REEFromJSON(run_end_encoded(int16(), float32()),
+                                   "[0.0, 1.5, -2.0, -2.0, 3.0, 3.0, 3.0, 4.0, 4.0]"));
+  ASSERT_OK(expected->ValidateFull());
+  CheckImport(expected);
+}
+
+TEST_F(TestArrayImport, RunEndEncodedWithOffset) {
+  auto ree_type = run_end_encoded(int16(), float32());
+  // Offset in children
+  FillPrimitive(AddChild(), 3, 0, 2, run_ends_buffers5);
+  FillPrimitive(AddChild(), 3, 0, 2, primitive_buffers_no_nulls5);
+  FillRunEndEncoded(7, 0);
+  ASSERT_OK_AND_ASSIGN(auto expected,
+                       REEFromJSON(ree_type, "[-2.0, -2.0, -2.0, -2.0, 3.0, 3.0, 3.0]"));
+  CheckImport(expected);
+
+  // Ofsset in parent
+  FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
+  FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
+  FillRunEndEncoded(5, 2);
+  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0, 3.0]"));
+  CheckImport(expected);
+
+  // Length in parent that cuts last run
+  FillPrimitive(AddChild(), 5, 0, 0, run_ends_buffers5);
+  FillPrimitive(AddChild(), 5, 0, 0, primitive_buffers_no_nulls5);
+  FillRunEndEncoded(4, 2);
+  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
+  CheckImport(expected);
+
+  // Offset in both children and parent
+  FillPrimitive(AddChild(), 3, 0, 2, run_ends_buffers5);
+  FillPrimitive(AddChild(), 3, 0, 2, primitive_buffers_no_nulls5);
+  FillRunEndEncoded(4, 2);
+  ASSERT_OK_AND_ASSIGN(expected, REEFromJSON(ree_type, "[-2.0, -2.0, 3.0, 3.0]"));
+  CheckImport(expected);
+}
+#endif
+
 TEST_F(TestArrayImport, SparseUnion) {
   auto type = sparse_union({field("strs", utf8()), field("ints", int8())}, {43, 42});
   auto expected =
@@ -3209,6 +3394,13 @@ TEST_F(TestSchemaRoundtrip, Union) {
   TestWithTypeFactory([&]() { return dense_union({f1, f2}, type_codes); });
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestSchemaRoundtrip, RunEndEncoded) {
+  TestWithTypeFactory([]() { return run_end_encoded(int16(), float32()); });
+  TestWithTypeFactory([]() { return run_end_encoded(int32(), list(float32())); });
+}
+#endif
+
 TEST_F(TestSchemaRoundtrip, Dictionary) {
   for (auto index_ty : all_dictionary_index_types()) {
     TestWithTypeFactory([&]() { return dictionary(index_ty, utf8()); });
@@ -3500,6 +3692,34 @@ TEST_F(TestArrayRoundtrip, Union) {
   }
 }
 
+#ifdef ARROW_COMPUTE
+TEST_F(TestArrayRoundtrip, RunEndEncoded) {
+  {
+    auto factory = []() -> Result<std::shared_ptr<Array>> {
+      ARROW_ASSIGN_OR_RAISE(auto ree_array,
+                            REEFromJSON(run_end_encoded(int32(), int8()),
+                                        "[1, 2, 2, 3, null, null, null, 4]"));
+      return ree_array->Slice(1, 5);
+    };
+    TestWithArrayFactory(factory);
+  }
+  {
+    auto factory = []() -> Result<std::shared_ptr<Array>> {
+      ARROW_ASSIGN_OR_RAISE(
+          auto ree_array,
+          RunEndEncodedArray::Make(
+              run_end_encoded(int64(), list(utf8())), 8,
+              ArrayFromJSON(int64(), "[1, 3, 4, 7, 8]"),
+              ArrayFromJSON(list(utf8()),
+                            R"([["abc", "def"], ["efg"], [], null, ["efg", "hij"]])")));
+      RETURN_NOT_OK(ree_array->ValidateFull());
+      return ree_array;
+    };
+    TestWithArrayFactory(factory);
+  }
+}
+#endif
+
 TEST_F(TestArrayRoundtrip, Dictionary) {
   {
     auto factory = []() {
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 21c47e17239cb..3d294a3fa8642 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -2658,7 +2658,7 @@ std::shared_ptr<DataType> struct_(
   return std::make_shared<StructType>(MakeFields(fields));
 }
 
-std::shared_ptr<DataType> run_end_encoded(std::shared_ptr<arrow::DataType> run_end_type,
+std::shared_ptr<DataType> run_end_encoded(std::shared_ptr<DataType> run_end_type,
                                           std::shared_ptr<DataType> value_type) {
   return std::make_shared<RunEndEncodedType>(std::move(run_end_type),
                                              std::move(value_type));
diff --git a/docs/source/format/CDataInterface.rst b/docs/source/format/CDataInterface.rst
index b55d64a2fa6c2..8f491470965b0 100644
--- a/docs/source/format/CDataInterface.rst
+++ b/docs/source/format/CDataInterface.rst
@@ -217,6 +217,8 @@ names and types of child fields are read from the child arrays.
 +------------------------+---------------------------------------------------+------------+
 | ``+us:I,J,...``        | sparse union with type ids I,J...                 |            |
 +------------------------+---------------------------------------------------+------------+
+| ``+r``                 | run-end encoded                                   | \(3)       |
++------------------------+---------------------------------------------------+------------+
 
 Notes:
 
@@ -228,6 +230,11 @@ Notes:
    As specified in the Arrow columnar format, the map type has a single child type
    named ``entries``, itself a 2-child struct type of ``(key, value)``.
 
+(3)
+   As specified in the Arrow columnar format, the run-end encoded type has two
+   children where the first is the (integral) ``run_ends`` and the second is the
+   ``values``.
+
 Examples
 --------
 
@@ -245,6 +252,9 @@ Examples
 * A ``sparse_union<ints: int32, floats: float32>`` with type ids ``4, 5``
   has format string ``+us:4,5``; its two children have names ``ints`` and
   ``floats``, and format strings ``i`` and ``f`` respectively.
+* A ``run_end_encoded<int32, float32>`` has format string ``+r``; its two
+  children have names ``run_ends`` and ``values``, and format strings
+  ``i`` and ``f`` respectively.
 
 .. _c-data-interface-struct-defs:
 
diff --git a/go/arrow/array/encoded.go b/go/arrow/array/encoded.go
index 10e9b949c7c35..bf4a942cf1c35 100644
--- a/go/arrow/array/encoded.go
+++ b/go/arrow/array/encoded.go
@@ -424,7 +424,7 @@ func (b *RunEndEncodedBuilder) newData() (data *Data) {
 	defer runEnds.Release()
 
 	data = NewData(
-		b.dt, b.length, []*memory.Buffer{nil},
+		b.dt, b.length, []*memory.Buffer{},
 		[]arrow.ArrayData{runEnds.Data(), values.Data()}, 0, 0)
 	b.reset()
 	return
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index 97e1cb91ad7e0..bc8fc6e987b93 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -278,6 +278,11 @@ func importSchema(schema *CArrowSchema) (ret arrow.Field, err error) {
 			dt = arrow.FixedSizeListOfField(int32(listSize), childFields[0])
 		case 's': // struct
 			dt = arrow.StructOf(childFields...)
+		case 'r': // run-end encoded
+			if len(childFields) != 2 {
+				return ret, fmt.Errorf("%w: run-end encoded arrays must have 2 children", arrow.ErrInvalid)
+			}
+			dt = arrow.RunEndEncodedOf(childFields[0].Type, childFields[1].Type)
 		case 'm': // map type is basically a list of structs.
 			st := childFields[0].Type.(*arrow.StructType)
 			dt = arrow.MapOf(st.Field(0).Type, st.Field(1).Type)
@@ -379,6 +384,16 @@ func (imp *cimporter) doImportChildren() error {
 			imp.children[i].dt = st.Field(i).Type
 			imp.children[i].importChild(imp, c)
 		}
+	case arrow.RUN_END_ENCODED: // import run-ends and values
+		st := imp.dt.(*arrow.RunEndEncodedType)
+		imp.children[0].dt = st.RunEnds()
+		if err := imp.children[0].importChild(imp, children[0]); err != nil {
+			return err
+		}
+		imp.children[1].dt = st.Encoded()
+		if err := imp.children[1].importChild(imp, children[1]); err != nil {
+			return err
+		}
 	case arrow.MAP: // only one child to import, it's a struct array
 		imp.children[0].dt = imp.dt.(*arrow.MapType).Elem()
 		if err := imp.children[0].importChild(imp, children[0]); err != nil {
@@ -491,6 +506,17 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 		}
 
 		imp.data = array.NewData(dt, int(imp.arr.length), []*memory.Buffer{nulls}, children, int(imp.arr.null_count), int(imp.arr.offset))
+	case *arrow.RunEndEncodedType:
+		if err := imp.checkNumBuffers(0); err != nil {
+			return err
+		}
+
+		if len(imp.children) != 2 {
+			return fmt.Errorf("%w: run-end encoded array should have 2 children", arrow.ErrInvalid)
+		}
+
+		children := []arrow.ArrayData{imp.children[0].data, imp.children[1].data}
+		imp.data = array.NewData(dt, int(imp.arr.length), []*memory.Buffer{}, children, int(imp.arr.null_count), int(imp.arr.offset))
 	case *arrow.DenseUnionType:
 		if err := imp.checkNoNulls(); err != nil {
 			return err
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index 209bd237f6f53..ae6247494b100 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -232,6 +232,8 @@ func (exp *schemaExporter) exportFormat(dt arrow.DataType) string {
 		return fmt.Sprintf("+w:%d", dt.Len())
 	case *arrow.StructType:
 		return "+s"
+	case *arrow.RunEndEncodedType:
+		return "+r"
 	case *arrow.MapType:
 		if dt.KeysSorted {
 			exp.flags |= C.ARROW_FLAG_MAP_KEYS_SORTED
@@ -425,6 +427,14 @@ func exportArray(arr arrow.Array, out *CArrowArray, outSchema *CArrowSchema) {
 			childPtrs[i] = &children[i]
 		}
 		out.children = (**CArrowArray)(unsafe.Pointer(&childPtrs[0]))
+	case *array.RunEndEncoded:
+		out.n_children = 2
+		childPtrs := allocateArrowArrayPtrArr(2)
+		children := allocateArrowArrayArr(2)
+		exportArray(arr.RunEndsArr(), &children[0], nil)
+		exportArray(arr.Values(), &children[1], nil)
+		childPtrs[0], childPtrs[1] = &children[0], &children[1]
+		out.children = (**CArrowArray)(unsafe.Pointer(&childPtrs[0]))
 	case *array.Dictionary:
 		out.dictionary = (*CArrowArray)(C.malloc(C.sizeof_struct_ArrowArray))
 		exportArray(arr.Dictionary(), out.dictionary, nil)
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index 5b8082a4322d0..a0c2f25496a6b 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -24,6 +24,7 @@
 package cdata
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -586,6 +587,18 @@ func createTestStructArr() arrow.Array {
 	return bld.NewArray()
 }
 
+func createTestRunEndsArr() arrow.Array {
+	bld := array.NewRunEndEncodedBuilder(memory.DefaultAllocator,
+		arrow.PrimitiveTypes.Int32, arrow.PrimitiveTypes.Int8)
+	defer bld.Release()
+
+	if err := json.Unmarshal([]byte(`[1, 2, 2, 3, null, null, null, 4]`), bld); err != nil {
+		panic(err)
+	}
+
+	return bld.NewArray()
+}
+
 func createTestMapArr() arrow.Array {
 	bld := array.NewMapBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int8, arrow.BinaryTypes.String, false)
 	defer bld.Release()
@@ -662,6 +675,7 @@ func TestNestedArrays(t *testing.T) {
 		{"map", createTestMapArr},
 		{"sparse union", createTestSparseUnion},
 		{"dense union", createTestDenseUnion},
+		{"run-end encoded", createTestRunEndsArr},
 	}
 
 	for _, tt := range tests {
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index 5a9b696e296ca..7dd23926a607a 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -262,6 +262,11 @@ func createCArr(arr arrow.Array) *CArrowArray {
 		clist := []*CArrowArray{createCArr(arr.ListValues())}
 		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
 		nchildren += 1
+	case *array.RunEndEncoded:
+		clist := []*CArrowArray{createCArr(arr.RunEndsArr()),
+			createCArr(arr.Values())}
+		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
+		nchildren += 2
 	case array.Union:
 		clist := []*CArrowArray{}
 		for i := 0; i < arr.NumFields(); i++ {
@@ -277,7 +282,13 @@ func createCArr(arr arrow.Array) *CArrowArray {
 	carr.length = C.int64_t(arr.Len())
 	carr.null_count = C.int64_t(arr.NullN())
 	carr.offset = C.int64_t(arr.Data().Offset())
+	carr.release = (*[0]byte)(C.release_test_arr)
+
 	buffers := arr.Data().Buffers()
+	if len(buffers) == 0 {
+		return carr
+	}
+
 	cbufs := allocateBufferPtrArr(len(buffers))
 	for i, b := range buffers {
 		if b != nil {
@@ -290,7 +301,6 @@ func createCArr(arr arrow.Array) *CArrowArray {
 	if len(cbufs) > 0 {
 		carr.buffers = (*unsafe.Pointer)(unsafe.Pointer(&cbufs[0]))
 	}
-	carr.release = (*[0]byte)(C.release_test_arr)
 
 	return carr
 }
diff --git a/go/arrow/cdata/test/test_export_to_cgo.py b/go/arrow/cdata/test/test_export_to_cgo.py
index e794a84bd43b8..4b669f6424437 100644
--- a/go/arrow/cdata/test/test_export_to_cgo.py
+++ b/go/arrow/cdata/test/test_export_to_cgo.py
@@ -182,28 +182,29 @@ def test_batch_roundtrip(self):
         pa.float32(),
         pa.float64(),
         pa.decimal128(19, 4),        
-        # pa.string(),
-        # pa.binary(),
-        # pa.binary(10),
-        # pa.large_string(),
-        # pa.large_binary(),
+        pa.string(),
+        pa.binary(),
+        pa.binary(10),
+        pa.large_string(),
+        pa.large_binary(),
         pa.list_(pa.int32()),
         pa.list_(pa.int32(), 2),
         pa.large_list(pa.uint16()),
         pa.struct([
             pa.field("a", pa.int32()),
             pa.field("b", pa.int8()),
-            # pa.field("c", pa.string()),
+            pa.field("c", pa.string()),
         ]),
         pa.struct([
             pa.field("a", pa.int32(), nullable=False),
             pa.field("b", pa.int8(), nullable=False),
-            # pa.field("c", pa.string()),
+            pa.field("c", pa.string()),
         ]),
         pa.dictionary(pa.int8(), pa.int64()),
-        # pa.dictionary(pa.int8(), pa.string()),
-        # pa.map_(pa.string(), pa.int32()),
+        pa.dictionary(pa.int8(), pa.string()),
+        pa.map_(pa.string(), pa.int32()),
         pa.map_(pa.int64(), pa.int32()),
+        # pa.run_end_encoded(pa.int16(), pa.int64()),
     ]
 
     def test_empty_roundtrip(self):

From c9275200081ee8b245c974e0cbe854df5ab1e3c0 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 24 Aug 2023 21:33:17 +0200
Subject: [PATCH 232/749] GH-37307: [Python][CI] Manually skip tests with
 skip_with_pyarrow_strings marker for nightly dask integration tests (#37324)

### Rationale for this change

Dask added some tests with a custom `@ pytest.mark.skip_with_pyarrow_strings` mark, which ensures to skip some tests when pyarrow is installed. However, that skip doesn't work correctly when running the tests on an installed version of dask with `pytest --pyargs dask.tests`.
Therefore manually skipping tests with that mark as a workaround.

* Closes: #37307

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 ci/scripts/integration_dask.sh | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/ci/scripts/integration_dask.sh b/ci/scripts/integration_dask.sh
index d1e2ecdc847f2..5b57fb486aa6c 100755
--- a/ci/scripts/integration_dask.sh
+++ b/ci/scripts/integration_dask.sh
@@ -31,11 +31,13 @@ python -c "import dask.dataframe"
 # pytest -sv --pyargs dask.bytes.tests.test_hdfs
 # pytest -sv --pyargs dask.bytes.tests.test_local
 
-pytest -v --pyargs dask.dataframe.tests.test_dataframe
+# The "skip_with_pyarrow_strings" marker is meant to skip automatically, but that doesn't work with --pyargs, so de-selecting manually
+pytest -v --pyargs dask.dataframe.tests.test_dataframe -m "not skip_with_pyarrow_strings"
 pytest -v --pyargs dask.dataframe.io.tests.test_orc
 # skip failing parquet tests
 # test_pandas_timestamp_overflow_pyarrow is skipped because of GH-33321.
 pytest -v --pyargs dask.dataframe.io.tests.test_parquet \
-  -k "not test_pandas_timestamp_overflow_pyarrow"
+  -k "not test_pandas_timestamp_overflow_pyarrow" \
+  -m "not skip_with_pyarrow_strings and not xfail_with_pyarrow_strings"
 # this file contains parquet tests that use S3 filesystem
 pytest -v --pyargs dask.bytes.tests.test_s3

From baff0090b7b2fc88ecf2086e69aa5548e39e2107 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 25 Aug 2023 10:15:05 +0900
Subject: [PATCH 233/749] GH-37334: [Packaging][Release][RPM] Don't remove old
 repodata/* (#37351)

### Rationale for this change

If we remove them, users can't use Yum repositories for unsupported distributions such as Amazon Linux 2.

### What changes are included in this PR?

This keeps garbage in repodata/* but we can accept it because we'll migrate to Debian/RPM type repositories eventually. We don't manage repodata/* by ourselves after we migrate to Debian/RPM type repositories.

See also: GH-37350

### Are these changes tested?

No. I hope that this works.

### Are there any user-facing changes?

Yes.
* Closes: #37334

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/binary-task.rb | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/dev/release/binary-task.rb b/dev/release/binary-task.rb
index f3fab8e945f83..ddbf86320d042 100644
--- a/dev/release/binary-task.rb
+++ b/dev/release/binary-task.rb
@@ -1785,7 +1785,6 @@ def define_yum_release_tasks
           release_distribution(distribution,
                                list: uploaded_files_name)
 
-          # Remove old repodata
           distribution_dir = "#{yum_release_repositories_dir}/#{distribution}"
           download_distribution(distribution,
                                 distribution_dir,
@@ -1795,7 +1794,14 @@ def define_yum_release_tasks
                                              distribution: distribution,
                                              source: distribution_dir,
                                              staging: staging?,
-                                             sync: true,
+                                             # Don't remove old repodata for
+                                             # unsupported distribution version
+                                             # such as Amazon Linux 2.
+                                             # This keeps garbage in repodata/
+                                             # for currently available
+                                             # distribution versions but we
+                                             # accept it for easy to implement.
+                                             sync: false,
                                              sync_pattern: /\/repodata\//)
           uploader.upload
         end

From 86b7a84c9317fa08222eb63f6930bbb54c2e6d0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Fri, 25 Aug 2023 03:29:15 +0200
Subject: [PATCH 234/749] GH-37308: [C++][Docs] Change name for CPP tutorial
 and minor fixes to the job (#37311)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Fix the job and rename so it's picked up as part of the nightlies

### What changes are included in this PR?

Rename + fixes to the job.

### Are these changes tested?

Via CI

### Are there any user-facing changes?

No
* Closes: #37308

Lead-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/examples/tutorial_examples/CMakeLists.txt     | 9 ++-------
 cpp/examples/tutorial_examples/build_example.sh   | 2 +-
 cpp/examples/tutorial_examples/dataset_example.cc | 1 +
 cpp/examples/tutorial_examples/run.sh             | 9 +++++++--
 dev/tasks/tasks.yml                               | 2 +-
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/cpp/examples/tutorial_examples/CMakeLists.txt b/cpp/examples/tutorial_examples/CMakeLists.txt
index 7758af90fb2a2..8788501484c87 100644
--- a/cpp/examples/tutorial_examples/CMakeLists.txt
+++ b/cpp/examples/tutorial_examples/CMakeLists.txt
@@ -19,11 +19,7 @@ cmake_minimum_required(VERSION 3.16)
 
 project(ArrowTutorialExamples)
 
-find_package(Arrow REQUIRED)
-
-get_filename_component(ARROW_CONFIG_PATH ${Arrow_CONFIG} DIRECTORY)
-find_package(Parquet REQUIRED HINTS ${ARROW_CONFIG_PATH})
-find_package(ArrowDataset REQUIRED HINTS ${ARROW_CONFIG_PATH})
+find_package(ArrowDataset)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra")
@@ -44,5 +40,4 @@ add_executable(compute_example compute_example.cc)
 target_link_libraries(compute_example PRIVATE Arrow::arrow_shared)
 
 add_executable(dataset_example dataset_example.cc)
-target_link_libraries(dataset_example PRIVATE Arrow::arrow_shared Parquet::parquet_shared
-                                              ArrowDataset::arrow_dataset_shared)
+target_link_libraries(dataset_example PRIVATE ArrowDataset::arrow_dataset_shared)
diff --git a/cpp/examples/tutorial_examples/build_example.sh b/cpp/examples/tutorial_examples/build_example.sh
index a315755a597f5..0b279890a78e4 100755
--- a/cpp/examples/tutorial_examples/build_example.sh
+++ b/cpp/examples/tutorial_examples/build_example.sh
@@ -21,7 +21,7 @@ set -ex
 mkdir -p $EXAMPLE_BUILD_DIR
 pushd $EXAMPLE_BUILD_DIR
 
-cmake /io
+cmake /io $EXAMPLE_CMAKE_OPTIONS
 make
 
 popd
diff --git a/cpp/examples/tutorial_examples/dataset_example.cc b/cpp/examples/tutorial_examples/dataset_example.cc
index 005cdc324d057..a980fa54939c5 100644
--- a/cpp/examples/tutorial_examples/dataset_example.cc
+++ b/cpp/examples/tutorial_examples/dataset_example.cc
@@ -25,6 +25,7 @@
 #include <parquet/arrow/reader.h>
 #include <parquet/arrow/writer.h>
 
+#include <unistd.h>
 #include <iostream>
 // (Doc section: Includes)
 
diff --git a/cpp/examples/tutorial_examples/run.sh b/cpp/examples/tutorial_examples/run.sh
index ed319a9d327ec..bc0078435cc47 100755
--- a/cpp/examples/tutorial_examples/run.sh
+++ b/cpp/examples/tutorial_examples/run.sh
@@ -22,6 +22,7 @@ cd /io
 
 export ARROW_BUILD_DIR=/build/arrow
 export EXAMPLE_BUILD_DIR=/build/example
+export ARROW_INSTALL_DIR=/build/arrow-install
 
 echo
 echo "=="
@@ -29,7 +30,9 @@ echo "== Building Arrow C++ library"
 echo "=="
 echo
 
-./build_arrow.sh
+ARROW_CMAKE_OPTIONS="-DCMAKE_INSTALL_PREFIX=${ARROW_INSTALL_DIR} \
+                     -DCMAKE_INSTALL_RPATH=${ARROW_INSTALL_DIR}/lib" \
+  ./build_arrow.sh
 
 echo
 echo "=="
@@ -37,7 +40,9 @@ echo "== Building example project using Arrow C++ library"
 echo "=="
 echo
 
-./build_example.sh
+EXAMPLE_CMAKE_OPTIONS="-DCMAKE_INSTALL_RPATH=${ARROW_INSTALL_DIR}/lib \
+                       -DCMAKE_PREFIX_PATH=${ARROW_INSTALL_DIR}" \
+  ./build_example.sh
 
 echo
 echo "=="
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 33643f16a33d0..55f23ed1304b7 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1625,7 +1625,7 @@ tasks:
       run: {{ kind }}
 {% endfor %}
 
-  cpp-tutorial-example:
+  example-cpp-tutorial:
     ci: github
     template: cpp-examples/github.linux.yml
     params:

From b4b2b1846d44a958a4d859b4a2efeffbac37b178 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 25 Aug 2023 17:02:50 +0900
Subject: [PATCH 235/749] GH-37373: [CI][Integration] Free up disk space
 (#37374)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

We need more disk space.

### What changes are included in this PR?

Remove unused pre-installed packages.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37373

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .github/workflows/integration.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 738b6ed3f1987..e7efd11c87044 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -69,6 +69,9 @@ jobs:
         with:
           repository: apache/arrow-rs
           path: rust
+      - name: Free up disk space
+        run: |
+          ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
         uses: actions/cache@v3
         with:

From 8f347c559d93f5c4087558e48cd4300d0fe8b806 Mon Sep 17 00:00:00 2001
From: David Greiss <dgreiss@users.noreply.github.com>
Date: Fri, 25 Aug 2023 08:56:11 -0400
Subject: [PATCH 236/749] GH-36247: [R] Add write_csv_dataset (#36436)

### Rationale for this change

Create a convenience wrapper around `write_dataset` for csv files.

### What changes are included in this PR?

Adds a `write_csv_dataset()`

### Are these changes tested?

Yes a few tests were added.

### Are there any user-facing changes?

Yes a new function has been added. If this looks good I can add more to the docs as well.
* Closes: #36247

Lead-authored-by: David Greiss <david.dgreiss@gmail.com>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Co-authored-by: David Greiss <dgreiss@users.noreply.github.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                              |   3 +
 r/R/csv.R                                |  40 ++++-
 r/R/dataset-format.R                     |  19 ++-
 r/R/dataset-write.R                      | 199 +++++++++++++++++++++-
 r/_pkgdown.yml                           |   3 +
 r/man/write_dataset.Rd                   |   2 +-
 r/man/write_delim_dataset.Rd             | 158 ++++++++++++++++++
 r/src/csv.cpp                            |   6 +-
 r/tests/testthat/_snaps/dataset-write.md |   2 +-
 r/tests/testthat/test-dataset-write.R    | 204 +++++++++++++++++++++++
 10 files changed, 613 insertions(+), 23 deletions(-)
 create mode 100644 r/man/write_delim_dataset.Rd

diff --git a/r/NAMESPACE b/r/NAMESPACE
index f4799176425d7..21f88b4180d24 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -406,12 +406,15 @@ export(value_counts)
 export(vctrs_extension_array)
 export(vctrs_extension_type)
 export(write_csv_arrow)
+export(write_csv_dataset)
 export(write_dataset)
+export(write_delim_dataset)
 export(write_feather)
 export(write_ipc_file)
 export(write_ipc_stream)
 export(write_parquet)
 export(write_to_raw)
+export(write_tsv_dataset)
 importFrom(R6,R6Class)
 importFrom(assertthat,assert_that)
 importFrom(assertthat,is.string)
diff --git a/r/R/csv.R b/r/R/csv.R
index d53dc07b42454..b119d16a84c06 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -510,32 +510,56 @@ CsvReadOptions$create <- function(use_threads = option_use_threads(),
   options
 }
 
-readr_to_csv_write_options <- function(include_header = TRUE,
+readr_to_csv_write_options <- function(col_names = TRUE,
                                        batch_size = 1024L,
-                                       na = "") {
+                                       delim = ",",
+                                       na = "",
+                                       eol = "\n",
+                                       quote = c("needed", "all", "none")) {
+  quoting_style_arrow_opts <- c("Needed", "AllValid", "None")
+  quote <- match(match.arg(quote), c("needed", "all", "none"))
+  quote <- quoting_style_arrow_opts[quote]
+
   CsvWriteOptions$create(
-    include_header = include_header,
+    include_header = col_names,
     batch_size = batch_size,
-    null_string = na
+    delimiter = delim,
+    null_string = na,
+    eol = eol,
+    quoting_style = quote
   )
 }
 
 #' @rdname CsvReadOptions
 #' @export
 CsvWriteOptions <- R6Class("CsvWriteOptions", inherit = ArrowObject)
-CsvWriteOptions$create <- function(include_header = TRUE, batch_size = 1024L, null_string = "") {
-  assert_that(is_integerish(batch_size, n = 1, finite = TRUE), batch_size > 0)
+CsvWriteOptions$create <- function(include_header = TRUE,
+                                   batch_size = 1024L,
+                                   null_string = "",
+                                   delimiter = ",",
+                                   eol = "\n",
+                                   quoting_style = c("Needed", "AllValid", "None")) {
+  quoting_style <- match.arg(quoting_style)
+  quoting_style_opts <- c("Needed", "AllValid", "None")
+  quoting_style <- match(quoting_style, quoting_style_opts) - 1L
+
   assert_that(is.logical(include_header))
+  assert_that(is_integerish(batch_size, n = 1, finite = TRUE), batch_size > 0)
+  assert_that(is.character(delimiter))
   assert_that(is.character(null_string))
   assert_that(!is.na(null_string))
   assert_that(length(null_string) == 1)
   assert_that(!grepl('"', null_string), msg = "na argument must not contain quote characters.")
+  assert_that(is.character(eol))
 
   csv___WriteOptions__initialize(
     list(
       include_header = include_header,
       batch_size = as.integer(batch_size),
-      null_string = as.character(null_string)
+      delimiter = delimiter,
+      null_string = as.character(null_string),
+      eol = eol,
+      quoting_style = quoting_style
     )
   )
 }
@@ -787,7 +811,7 @@ write_csv_arrow <- function(x,
 
   if (is.null(write_options)) {
     write_options <- readr_to_csv_write_options(
-      include_header = include_header,
+      col_names = include_header,
       batch_size = batch_size,
       na = na
     )
diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R
index 9c7e332f5ea2c..e1f434d60cd50 100644
--- a/r/R/dataset-format.R
+++ b/r/R/dataset-format.R
@@ -76,9 +76,10 @@ FileFormat <- R6Class("FileFormat",
 )
 FileFormat$create <- function(format, schema = NULL, ...) {
   opt_names <- names(list(...))
-  if (format %in% c("csv", "text") || any(opt_names %in% c("delim", "delimiter"))) {
+  if (format %in% c("csv", "text", "txt") || any(opt_names %in% c("delim", "delimiter"))) {
     CsvFileFormat$create(schema = schema, ...)
   } else if (format == "tsv") {
+    # This delimiter argument is ignored.
     CsvFileFormat$create(delimiter = "\t", schema = schema, ...)
   } else if (format == "parquet") {
     ParquetFileFormat$create(...)
@@ -635,7 +636,7 @@ FileWriteOptions <- R6Class("FileWriteOptions",
             "codec",
             "null_fallback"
           )
-        } else if (format == "csv") {
+        } else if (format %in% c("csv", "tsv", "txt", "text")) {
           supported_args <- c(
             names(formals(CsvWriteOptions$create)),
             names(formals(readr_to_csv_write_options))
@@ -691,14 +692,20 @@ FileWriteOptions <- R6Class("FileWriteOptions",
             get_ipc_metadata_version(args$metadata_version)
           )
         }
-      } else if (self$type == "csv") {
+      } else if (self$type %in% c("csv", "tsv", "txt", "text")) {
         arrow_opts <- names(formals(CsvWriteOptions$create))
         readr_opts <- names(formals(readr_to_csv_write_options))
         readr_only_opts <- setdiff(readr_opts, arrow_opts)
+        arrow_only_opts <- setdiff(arrow_opts, readr_opts)
 
-        is_arrow_opt <- !is.na(pmatch(names(args), arrow_opts))
-        is_readr_opt <- !is.na(pmatch(names(args), readr_opts))
-        is_readr_only_opt <- !is.na(pmatch(names(args), readr_only_opts))
+        is_arrow_opt <- !is.na(match(names(args), arrow_opts))
+        is_readr_opt <- !is.na(match(names(args), readr_opts))
+        is_arrow_only_opt <- !is.na(match(names(args), arrow_only_opts))
+        is_readr_only_opt <- !is.na(match(names(args), readr_only_opts))
+
+        if (any(is_arrow_only_opt) && any(is_readr_only_opt)) {
+          stop("Use either Arrow write options or readr write options, not both")
+        }
 
         # These option names aren't mutually exclusive, so only use readr path
         # if we have at least one readr-specific option.
diff --git a/r/R/dataset-write.R b/r/R/dataset-write.R
index f971c0e9cd6e3..288da4ffde7c8 100644
--- a/r/R/dataset-write.R
+++ b/r/R/dataset-write.R
@@ -122,7 +122,7 @@
 #' @export
 write_dataset <- function(dataset,
                           path,
-                          format = c("parquet", "feather", "arrow", "ipc", "csv"),
+                          format = c("parquet", "feather", "arrow", "ipc", "csv", "tsv", "txt", "text"),
                           partitioning = dplyr::group_vars(dataset),
                           basename_template = paste0("part-{i}.", as.character(format)),
                           hive_style = TRUE,
@@ -178,12 +178,31 @@ write_dataset <- function(dataset,
   }
 
   path_and_fs <- get_path_and_filesystem(path)
+
+  dots <- list(...)
+  if (format %in% c("txt", "text") && !any(c("delimiter", "delim") %in% names(dots))) {
+    stop("A delimiter must be given for a txt format.")
+  }
+  if (format == "tsv" && any(c("delimiter", "delim") %in% names(dots))) {
+    stop("Can't set a delimiter for the tsv format.")
+  }
+
   output_schema <- final_node$schema
-  options <- FileWriteOptions$create(
-    format,
-    column_names = names(output_schema),
-    ...
-  )
+  # This is a workaround because CsvFileFormat$create defaults the delimiter to ","
+  if (format == "tsv") {
+    options <- FileWriteOptions$create(
+      format,
+      column_names = names(output_schema),
+      delimiter = "\t",
+      ...
+    )
+  } else {
+    options <- FileWriteOptions$create(
+      format,
+      column_names = names(output_schema),
+      ...
+    )
+  }
 
   # TODO(ARROW-16200): expose FileSystemDatasetWriteOptions in R
   # and encapsulate this logic better
@@ -209,6 +228,174 @@ write_dataset <- function(dataset,
   )
 }
 
+#' Write a dataset into partitioned flat files.
+#'
+#' The `write_*_dataset()` are a family of wrappers around [write_dataset] to allow for easy switching
+#' between functions for writing datasets.
+#'
+#' @inheritParams write_dataset
+#' @param col_names Whether to write an initial header line with column names.
+#' @param batch_size Maximum number of rows processed at a time. Default is 1024L.
+#' @param delim Delimiter used to separate values. Defaults to `","` for `write_delim_dataset()` and
+#' `write_csv_dataset()`, and `"\t` for `write_tsv_dataset()`. Cannot be changed for `write_tsv_dataset()`.
+#' @param na a character vector of strings to interpret as missing values. Quotes are not allowed in this string.
+#' The default is an empty string `""`.
+#' @param eol the end of line character to use for ending rows. The default is `"\n"`.
+#' @param quote How to handle fields which contain characters that need to be quoted.
+#' - `needed` - Enclose all strings and binary values in quotes which need them, because their CSV rendering can
+#'  contain quotes itself  (the default)
+#' - `all` -   Enclose all valid values in quotes. Nulls are not quoted. May cause readers to
+#' interpret all values as strings if schema is inferred.
+#' - `none` -   Do not enclose any values in quotes. Prevents values from containing quotes ("),
+#' cell delimiters (,) or line endings (\\r, \\n), (following RFC4180). If values
+#' contain these characters, an error is caused when attempting to write.
+#' @return The input `dataset`, invisibly.
+#'
+#' @seealso [write_dataset()]
+#' @export
+write_delim_dataset <- function(dataset,
+                                path,
+                                partitioning = dplyr::group_vars(dataset),
+                                basename_template = "part-{i}.txt",
+                                hive_style = TRUE,
+                                existing_data_behavior = c("overwrite", "error", "delete_matching"),
+                                max_partitions = 1024L,
+                                max_open_files = 900L,
+                                max_rows_per_file = 0L,
+                                min_rows_per_group = 0L,
+                                max_rows_per_group = bitwShiftL(1, 20),
+                                col_names = TRUE,
+                                batch_size = 1024L,
+                                delim = ",",
+                                na = "",
+                                eol = "\n",
+                                quote = c("needed", "all", "none")) {
+  if (!missing(max_rows_per_file) && missing(max_rows_per_group) && max_rows_per_group > max_rows_per_file) {
+    max_rows_per_group <- max_rows_per_file
+  }
+
+  quoting_style_arrow_opts <- c("Needed", "AllValid", "None")
+  quote <- match(match.arg(quote), c("needed", "all", "none"))
+  quote <- quoting_style_arrow_opts[quote]
+
+  write_dataset(
+    dataset = dataset,
+    path = path,
+    format = "txt",
+    partitioning = partitioning,
+    basename_template = basename_template,
+    hive_style = hive_style,
+    existing_data_behavior = existing_data_behavior,
+    max_partitions = max_partitions,
+    max_open_files = max_open_files,
+    max_rows_per_file = max_rows_per_file,
+    min_rows_per_group = min_rows_per_group,
+    max_rows_per_group = max_rows_per_group,
+    include_header = col_names,
+    batch_size = batch_size,
+    delimiter = delim,
+    null_string = na,
+    eol = eol,
+    quoting_style = quote
+  )
+}
+
+#' @rdname write_delim_dataset
+#' @export
+write_csv_dataset <- function(dataset,
+                              path,
+                              partitioning = dplyr::group_vars(dataset),
+                              basename_template = "part-{i}.csv",
+                              hive_style = TRUE,
+                              existing_data_behavior = c("overwrite", "error", "delete_matching"),
+                              max_partitions = 1024L,
+                              max_open_files = 900L,
+                              max_rows_per_file = 0L,
+                              min_rows_per_group = 0L,
+                              max_rows_per_group = bitwShiftL(1, 20),
+                              col_names = TRUE,
+                              batch_size = 1024L,
+                              delim = ",",
+                              na = "",
+                              eol = "\n",
+                              quote = c("needed", "all", "none")) {
+  if (!missing(max_rows_per_file) && missing(max_rows_per_group) && max_rows_per_group > max_rows_per_file) {
+    max_rows_per_group <- max_rows_per_file
+  }
+
+  quoting_style_arrow_opts <- c("Needed", "AllValid", "None")
+  quote <- match(match.arg(quote), c("needed", "all", "none"))
+  quote <- quoting_style_arrow_opts[quote]
+
+  write_dataset(
+    dataset = dataset,
+    path = path,
+    format = "csv",
+    partitioning = partitioning,
+    basename_template = basename_template,
+    hive_style = hive_style,
+    existing_data_behavior = existing_data_behavior,
+    max_partitions = max_partitions,
+    max_open_files = max_open_files,
+    max_rows_per_file = max_rows_per_file,
+    min_rows_per_group = min_rows_per_group,
+    max_rows_per_group = max_rows_per_group,
+    include_header = col_names,
+    batch_size = batch_size,
+    delimiter = delim,
+    null_string = na,
+    eol = eol,
+    quoting_style = quote
+  )
+}
+
+#' @rdname write_delim_dataset
+#' @export
+write_tsv_dataset <- function(dataset,
+                              path,
+                              partitioning = dplyr::group_vars(dataset),
+                              basename_template = "part-{i}.tsv",
+                              hive_style = TRUE,
+                              existing_data_behavior = c("overwrite", "error", "delete_matching"),
+                              max_partitions = 1024L,
+                              max_open_files = 900L,
+                              max_rows_per_file = 0L,
+                              min_rows_per_group = 0L,
+                              max_rows_per_group = bitwShiftL(1, 20),
+                              col_names = TRUE,
+                              batch_size = 1024L,
+                              na = "",
+                              eol = "\n",
+                              quote = c("needed", "all", "none")) {
+  if (!missing(max_rows_per_file) && missing(max_rows_per_group) && max_rows_per_group > max_rows_per_file) {
+    max_rows_per_group <- max_rows_per_file
+  }
+
+  quoting_style_arrow_opts <- c("Needed", "AllValid", "None")
+  quote <- match(match.arg(quote), c("needed", "all", "none"))
+  quote <- quoting_style_arrow_opts[quote]
+
+  write_dataset(
+    dataset = dataset,
+    path = path,
+    format = "tsv",
+    partitioning = partitioning,
+    basename_template = basename_template,
+    hive_style = hive_style,
+    existing_data_behavior = existing_data_behavior,
+    max_partitions = max_partitions,
+    max_open_files = max_open_files,
+    max_rows_per_file = max_rows_per_file,
+    min_rows_per_group = min_rows_per_group,
+    max_rows_per_group = max_rows_per_group,
+    include_header = col_names,
+    batch_size = batch_size,
+    null_string = na,
+    eol = eol,
+    quoting_style = quote
+  )
+}
+
 validate_positive_int_value <- function(value, msg) {
   if (!is_integerish(value, n = 1) || is.na(value) || value < 0) {
     abort(paste(substitute(value), "must be a positive, non-missing integer"))
diff --git a/r/_pkgdown.yml b/r/_pkgdown.yml
index 10323a4796602..57c21e3c0f2cb 100644
--- a/r/_pkgdown.yml
+++ b/r/_pkgdown.yml
@@ -152,6 +152,9 @@ reference:
     Write multi-file datasets to disk.
   contents:
   - write_dataset
+  - write_delim_dataset
+  - write_csv_dataset
+  - write_tsv_dataset
 
 - title: Read files
   desc: >
diff --git a/r/man/write_dataset.Rd b/r/man/write_dataset.Rd
index 1bc940697cc4a..34cffefbce5d3 100644
--- a/r/man/write_dataset.Rd
+++ b/r/man/write_dataset.Rd
@@ -7,7 +7,7 @@
 write_dataset(
   dataset,
   path,
-  format = c("parquet", "feather", "arrow", "ipc", "csv"),
+  format = c("parquet", "feather", "arrow", "ipc", "csv", "tsv", "txt", "text"),
   partitioning = dplyr::group_vars(dataset),
   basename_template = paste0("part-{i}.", as.character(format)),
   hive_style = TRUE,
diff --git a/r/man/write_delim_dataset.Rd b/r/man/write_delim_dataset.Rd
new file mode 100644
index 0000000000000..2dcd9707dca03
--- /dev/null
+++ b/r/man/write_delim_dataset.Rd
@@ -0,0 +1,158 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/dataset-write.R
+\name{write_delim_dataset}
+\alias{write_delim_dataset}
+\alias{write_csv_dataset}
+\alias{write_tsv_dataset}
+\title{Write a dataset into partitioned flat files.}
+\usage{
+write_delim_dataset(
+  dataset,
+  path,
+  partitioning = dplyr::group_vars(dataset),
+  basename_template = "part-{i}.txt",
+  hive_style = TRUE,
+  existing_data_behavior = c("overwrite", "error", "delete_matching"),
+  max_partitions = 1024L,
+  max_open_files = 900L,
+  max_rows_per_file = 0L,
+  min_rows_per_group = 0L,
+  max_rows_per_group = bitwShiftL(1, 20),
+  col_names = TRUE,
+  batch_size = 1024L,
+  delim = ",",
+  na = "",
+  eol = "\\n",
+  quote = c("needed", "all", "none")
+)
+
+write_csv_dataset(
+  dataset,
+  path,
+  partitioning = dplyr::group_vars(dataset),
+  basename_template = "part-{i}.csv",
+  hive_style = TRUE,
+  existing_data_behavior = c("overwrite", "error", "delete_matching"),
+  max_partitions = 1024L,
+  max_open_files = 900L,
+  max_rows_per_file = 0L,
+  min_rows_per_group = 0L,
+  max_rows_per_group = bitwShiftL(1, 20),
+  col_names = TRUE,
+  batch_size = 1024L,
+  delim = ",",
+  na = "",
+  eol = "\\n",
+  quote = c("needed", "all", "none")
+)
+
+write_tsv_dataset(
+  dataset,
+  path,
+  partitioning = dplyr::group_vars(dataset),
+  basename_template = "part-{i}.tsv",
+  hive_style = TRUE,
+  existing_data_behavior = c("overwrite", "error", "delete_matching"),
+  max_partitions = 1024L,
+  max_open_files = 900L,
+  max_rows_per_file = 0L,
+  min_rows_per_group = 0L,
+  max_rows_per_group = bitwShiftL(1, 20),
+  col_names = TRUE,
+  batch_size = 1024L,
+  na = "",
+  eol = "\\n",
+  quote = c("needed", "all", "none")
+)
+}
+\arguments{
+\item{dataset}{\link{Dataset}, \link{RecordBatch}, \link{Table}, \code{arrow_dplyr_query}, or
+\code{data.frame}. If an \code{arrow_dplyr_query}, the query will be evaluated and
+the result will be written. This means that you can \code{select()}, \code{filter()}, \code{mutate()},
+etc. to transform the data before it is written if you need to.}
+
+\item{path}{string path, URI, or \code{SubTreeFileSystem} referencing a directory
+to write to (directory will be created if it does not exist)}
+
+\item{partitioning}{\code{Partitioning} or a character vector of columns to
+use as partition keys (to be written as path segments). Default is to
+use the current \code{group_by()} columns.}
+
+\item{basename_template}{string template for the names of files to be written.
+Must contain \code{"{i}"}, which will be replaced with an autoincremented
+integer to generate basenames of datafiles. For example, \code{"part-{i}.arrow"}
+will yield \verb{"part-0.arrow", ...}.
+If not specified, it defaults to \code{"part-{i}.<default extension>"}.}
+
+\item{hive_style}{logical: write partition segments as Hive-style
+(\code{key1=value1/key2=value2/file.ext}) or as just bare values. Default is \code{TRUE}.}
+
+\item{existing_data_behavior}{The behavior to use when there is already data
+in the destination directory.  Must be one of "overwrite", "error", or
+"delete_matching".
+\itemize{
+\item "overwrite" (the default) then any new files created will overwrite
+existing files
+\item "error" then the operation will fail if the destination directory is not
+empty
+\item "delete_matching" then the writer will delete any existing partitions
+if data is going to be written to those partitions and will leave alone
+partitions which data is not written to.
+}}
+
+\item{max_partitions}{maximum number of partitions any batch may be
+written into. Default is 1024L.}
+
+\item{max_open_files}{maximum number of files that can be left opened
+during a write operation. If greater than 0 then this will limit the
+maximum number of files that can be left open. If an attempt is made to open
+too many files then the least recently used file will be closed.
+If this setting is set too low you may end up fragmenting your data
+into many small files. The default is 900 which also allows some # of files to be
+open by the scanner before hitting the default Linux limit of 1024.}
+
+\item{max_rows_per_file}{maximum number of rows per file.
+If greater than 0 then this will limit how many rows are placed in any single file.
+Default is 0L.}
+
+\item{min_rows_per_group}{write the row groups to the disk when this number of
+rows have accumulated. Default is 0L.}
+
+\item{max_rows_per_group}{maximum rows allowed in a single
+group and when this number of rows is exceeded, it is split and the next set
+of rows is written to the next group. This value must be set such that it is
+greater than \code{min_rows_per_group}. Default is 1024 * 1024.}
+
+\item{col_names}{Whether to write an initial header line with column names.}
+
+\item{batch_size}{Maximum number of rows processed at a time. Default is 1024L.}
+
+\item{delim}{Delimiter used to separate values. Defaults to \code{","} for \code{write_delim_dataset()} and
+\code{write_csv_dataset()}, and \verb{"\\t} for \code{write_tsv_dataset()}. Cannot be changed for \code{write_tsv_dataset()}.}
+
+\item{na}{a character vector of strings to interpret as missing values. Quotes are not allowed in this string.
+The default is an empty string \code{""}.}
+
+\item{eol}{the end of line character to use for ending rows. The default is \code{"\\n"}.}
+
+\item{quote}{How to handle fields which contain characters that need to be quoted.
+\itemize{
+\item \code{needed} - Enclose all strings and binary values in quotes which need them, because their CSV rendering can
+contain quotes itself  (the default)
+\item \code{all} -   Enclose all valid values in quotes. Nulls are not quoted. May cause readers to
+interpret all values as strings if schema is inferred.
+\item \code{none} -   Do not enclose any values in quotes. Prevents values from containing quotes ("),
+cell delimiters (,) or line endings (\\r, \\n), (following RFC4180). If values
+contain these characters, an error is caused when attempting to write.
+}}
+}
+\value{
+The input \code{dataset}, invisibly.
+}
+\description{
+The \verb{write_*_dataset()} are a family of wrappers around \link{write_dataset} to allow for easy switching
+between functions for writing datasets.
+}
+\seealso{
+\code{\link[=write_dataset]{write_dataset()}}
+}
diff --git a/r/src/csv.cpp b/r/src/csv.cpp
index d04caf5c1fd7a..ffb8a11e6b4ef 100644
--- a/r/src/csv.cpp
+++ b/r/src/csv.cpp
@@ -31,8 +31,12 @@ std::shared_ptr<arrow::csv::WriteOptions> csv___WriteOptions__initialize(
       std::make_shared<arrow::csv::WriteOptions>(arrow::csv::WriteOptions::Defaults());
   res->include_header = cpp11::as_cpp<bool>(options["include_header"]);
   res->batch_size = cpp11::as_cpp<int>(options["batch_size"]);
-  res->io_context = MainRThread::GetInstance().CancellableIOContext();
+  res->delimiter = cpp11::as_cpp<char>(options["delimiter"]);
   res->null_string = cpp11::as_cpp<std::string>(options["null_string"]);
+  res->io_context = MainRThread::GetInstance().CancellableIOContext();
+  res->eol = cpp11::as_cpp<std::string>(options["eol"]);
+  res->quoting_style =
+      cpp11::as_cpp<enum arrow::csv::QuotingStyle>(options["quoting_style"]);
   return res;
 }
 
diff --git a/r/tests/testthat/_snaps/dataset-write.md b/r/tests/testthat/_snaps/dataset-write.md
index e302d8463d0f0..19f687be67163 100644
--- a/r/tests/testthat/_snaps/dataset-write.md
+++ b/r/tests/testthat/_snaps/dataset-write.md
@@ -42,7 +42,7 @@
     Condition
       Error in `check_additional_args()`:
       ! `nonsensical_arg` is not a valid argument for your chosen `format`.
-      i Supported arguments: `include_header`, `batch_size`, `null_string`, and `na`.
+      i Supported arguments: `include_header`, `batch_size`, `null_string`, `delimiter`, `eol`, `quoting_style`, `col_names`, `delim`, `na`, and `quote`.
 
 ---
 
diff --git a/r/tests/testthat/test-dataset-write.R b/r/tests/testthat/test-dataset-write.R
index 8553dafd80f95..e2c3c68b50227 100644
--- a/r/tests/testthat/test-dataset-write.R
+++ b/r/tests/testthat/test-dataset-write.R
@@ -812,3 +812,207 @@ test_that("write_dataset() errors on data.frame with NULL names", {
   names(df) <- NULL
   expect_error(write_dataset(df, tempfile()), "Input data frame columns must be named")
 })
+
+test_that("Writing a dataset to text files with wrapper functions.", {
+  df <- tibble(
+    int = 1:10,
+    dbl = as.numeric(1:10),
+    lgl = rep(c(TRUE, FALSE, NA, TRUE, FALSE), 2),
+    chr = letters[1:10],
+  )
+
+  dst_dir <- make_temp_dir()
+  write_delim_dataset(df, dst_dir)
+  expect_true(dir.exists(dst_dir))
+  new_ds <- open_dataset(dst_dir, format = "text")
+  expect_equal(new_ds %>% collect(), df)
+
+  dst_dir <- make_temp_dir()
+  write_csv_dataset(df, dst_dir)
+  expect_true(dir.exists(dst_dir))
+  new_ds <- open_dataset(dst_dir, format = "csv")
+  expect_equal(new_ds %>% collect(), df)
+
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(df, dst_dir)
+  expect_true(dir.exists(dst_dir))
+  new_ds <- open_dataset(dst_dir, format = "tsv")
+  expect_equal(new_ds %>% collect(), df)
+})
+
+test_that("Writing a flat file dataset: `basename_template` default behavier", {
+  ds <- open_dataset(csv_dir, partitioning = "part", format = "csv")
+
+  dst_dir <- make_temp_dir()
+  write_delim_dataset(ds, dst_dir, max_rows_per_file = 5L)
+  expect_identical(
+    dir(dst_dir, full.names = FALSE, recursive = TRUE),
+    paste0("part-", 0:3, ".txt")
+  )
+
+  dst_dir <- make_temp_dir()
+  write_csv_dataset(ds, dst_dir, max_rows_per_file = 5L)
+  expect_identical(
+    dir(dst_dir, full.names = FALSE, recursive = TRUE),
+    paste0("part-", 0:3, ".csv")
+  )
+
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(ds, dst_dir, max_rows_per_file = 5L)
+  expect_identical(
+    dir(dst_dir, full.names = FALSE, recursive = TRUE),
+    paste0("part-", 0:3, ".tsv")
+  )
+})
+
+test_that("max_rows_per_group is adjusted if at odds with max_rows_per_file in write_delim_dataset()", {
+  skip_if_not_available("parquet")
+  df <- tibble::tibble(
+    int = 1:10,
+    dbl = as.numeric(1:10),
+    lgl = rep(c(TRUE, FALSE, NA, TRUE, FALSE), 2),
+    chr = letters[1:10],
+  )
+
+  # max_rows_per_group unset adjust silently
+  dst_dir <- make_temp_dir()
+  expect_silent(
+    write_delim_dataset(df, dst_dir, max_rows_per_file = 5)
+  )
+
+  dst_dir <- make_temp_dir()
+  expect_silent(
+    write_csv_dataset(df, dst_dir, max_rows_per_file = 5)
+  )
+
+  dst_dir <- make_temp_dir()
+  expect_silent(
+    write_tsv_dataset(df, dst_dir, max_rows_per_file = 5)
+  )
+})
+
+test_that("Writing a flat file dataset without a delimiter throws an error.", {
+  df <- tibble(
+    int = 1:10,
+    dbl = as.numeric(1:10),
+    lgl = rep(c(TRUE, FALSE, NA, TRUE, FALSE), 2),
+    chr = letters[1:10],
+  )
+
+  dst_dir <- make_temp_dir()
+  expect_error(
+    write_dataset(df, dst_dir, format = "txt"),
+    "A delimiter must be given for a txt format."
+  )
+
+  expect_error(
+    write_dataset(df, dst_dir, format = "text"),
+    "A delimiter must be given for a txt format."
+  )
+})
+
+test_that("Dataset can write flat files using readr::write_csv() options.", {
+  df <- tibble(
+    int = 1:10,
+    dbl = as.numeric(1:10),
+    lgl = rep(c(TRUE, FALSE, NA, TRUE, FALSE), 2),
+    chr = letters[1:10],
+  )
+
+  dst_dir <- make_temp_dir()
+  write_dataset(df, dst_dir, format = "csv", col_names = FALSE)
+  expect_true(dir.exists(dst_dir))
+
+  header <- readLines(file(paste0(dst_dir, "/part-0.csv")), n = 1L)
+  expect_equal(header, "1,1,true,\"a\"")
+
+  df2 <- tibble(x = "")
+  dst_dir <- make_temp_dir()
+  write_dataset(df2, dst_dir, format = "csv", eol = "\r\n")
+  expect_true(dir.exists(dst_dir))
+
+  header <- readBin(con <- file(paste0(dst_dir, "/part-0.csv"), "rb"), "raw", n = 5)
+  close(con)
+
+  # 0d and 0a are the character codes for CRLF (https://www.asciitable.com)
+  expect_equal(header[4:5], as.raw(c(0x0d, 0x0a)))
+
+  dst_dir <- make_temp_dir()
+  expect_error(
+    write_dataset(df, dst_dir, format = "csv", include_header = FALSE, delim = ";"),
+    "Use either Arrow write options or readr write options, not both"
+  )
+  dst_dir <- make_temp_dir()
+  write_dataset(df, dst_dir, format = "csv", quoting_style = "AllValid")
+  ds <- open_dataset(dst_dir, format = "csv")
+  expect_equal(df, ds |> collect())
+
+  lines <- paste(readLines(paste0(dst_dir, "/part-0.csv")), sep = "\n")
+  expect_equal(lines[2], "\"1\",\"1\",\"true\",\"a\"")
+
+  expect_error(
+    write_dataset(df, dst_dir, format = "tsv", delimiter = ";"),
+    "Can't set a delimiter for the tsv format."
+  )
+})
+
+test_that("Dataset write wrappers can write flat files using readr::write_csv() options.", {
+  df <- tibble(
+    int = 1:10,
+    dbl = as.numeric(1:10),
+    lgl = rep(c(TRUE, FALSE, NA, TRUE, FALSE), 2),
+    chr = letters[1:10],
+  )
+
+  dst_dir <- make_temp_dir()
+  write_csv_dataset(df, dst_dir, col_names = FALSE)
+
+  header <- readLines(file(paste0(dst_dir, "/part-0.csv")), n = 1L)
+  expect_equal(header, "1,1,true,\"a\"")
+
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(df, dst_dir, col_names = FALSE)
+
+  header <- readLines(file(paste0(dst_dir, "/part-0.tsv")), n = 1L)
+  expect_equal(header, "1\t1\ttrue\t\"a\"")
+
+  df2 <- tibble(x = "")
+  dst_dir <- make_temp_dir()
+  write_csv_dataset(df2, dst_dir, eol = "\r\n")
+  header <- readBin(con <- file(paste0(dst_dir, "/part-0.csv"), "rb"), "raw", n = 5)
+  close(con)
+  # 0d and 0a are the character codes for CRLF (https://www.asciitable.com)
+  expect_equal(header[4:5], as.raw(c(0x0d, 0x0a)))
+
+  df2 <- tibble(x = "")
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(df2, dst_dir, eol = "\r\n")
+  header <- readBin(con <- file(paste0(dst_dir, "/part-0.tsv"), "rb"), "raw", n = 5)
+  close(con)
+  # 0d and 0a are the character codes for CRLF (https://www.asciitable.com)
+  expect_equal(header[4:5], as.raw(c(0x0d, 0x0a)))
+
+  dst_dir <- make_temp_dir()
+  write_csv_dataset(df, dst_dir, quote = "all", delim = ";")
+  ds <- open_dataset(dst_dir, format = "csv", delim = ";")
+  expect_equal(df, ds |> collect())
+
+  lines <- paste(readLines(paste0(dst_dir, "/part-0.csv")), sep = "\n")
+  expect_equal(lines[2], "\"1\";\"1\";\"true\";\"a\"")
+
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(df, dst_dir, quote = "all", eol = "\r\n")
+  ds <- open_dataset(dst_dir, format = "tsv")
+  expect_equal(df, ds |> collect())
+
+  lines <- paste(readLines(paste0(dst_dir, "/part-0.tsv")), sep = "\n")
+  expect_equal(lines[2], "\"1\"\t\"1\"\t\"true\"\t\"a\"")
+  dst_dir <- make_temp_dir()
+  write_tsv_dataset(df, dst_dir, na = "NOVALUE")
+  ds <- open_dataset(dst_dir, format = "tsv") |> collect()
+
+  expect_equal(
+    ds$lgl,
+    c("true", "false", "NOVALUE", "true", "false", "true", "false", "NOVALUE", "true", "false")
+  )
+})

From 45c60ee22ba1a32eb2b5395a45709b5f9eab5c0f Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 25 Aug 2023 15:44:25 +0100
Subject: [PATCH 237/749] GH-37386: [R] CRAN failures due to "invalid
 non-character version specification" (#37387)

### Rationale for this change

Package version comparison results in CRAN checks failing due to values being numeric not character

### What changes are included in this PR?

Changing numeric values to characters

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37386

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/test-data-type.R | 2 +-
 r/tests/testthat/test-schema.R    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/tests/testthat/test-data-type.R b/r/tests/testthat/test-data-type.R
index 0f193f19d3733..e7212eb61b552 100644
--- a/r/tests/testthat/test-data-type.R
+++ b/r/tests/testthat/test-data-type.R
@@ -609,7 +609,7 @@ test_that("DataType$code()", {
   expect_code_roundtrip(dictionary(index_type = int8(), value_type = large_utf8()))
   expect_code_roundtrip(dictionary(index_type = int8(), ordered = TRUE))
 
-  skip_if(packageVersion("rlang") < 1)
+  skip_if(packageVersion("rlang") < "1")
   # Are these unsupported for a reason?
   expect_error(
     eval(DayTimeInterval__initialize()$code()),
diff --git a/r/tests/testthat/test-schema.R b/r/tests/testthat/test-schema.R
index 77259fb5077df..db91cee330960 100644
--- a/r/tests/testthat/test-schema.R
+++ b/r/tests/testthat/test-schema.R
@@ -43,7 +43,7 @@ test_that("Schema$code()", {
     schema(a = int32(), b = struct(c = double(), d = utf8()), e = list_of(binary()))
   )
 
-  skip_if(packageVersion("rlang") < 1)
+  skip_if(packageVersion("rlang") < "1")
   expect_error(
     eval(schema(x = int32(), y = DayTimeInterval__initialize())$code()),
     "Unsupported type"

From c079dac1bb112c21e2721008d845b90e6bba94f4 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 25 Aug 2023 18:15:45 +0100
Subject: [PATCH 238/749] GH-37384: [R] Set
 _R_CHECK_STOP_ON_INVALID_NUMERIC_VERSION_INPUTS_ = TRUE on CI (#37385)

### Rationale for this change

Checks fail on CRAN which don't fail on our CI - we should make them fail on our CI instead of just issue a warning

### What changes are included in this PR?

Update settings for R builds so these checks raise error not warning

### Are these changes tested?

Nope

### Are there any user-facing changes?

No
* Closes: #37384

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 .github/workflows/r.yml | 3 ++-
 ci/scripts/r_test.sh    | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml
index 277080bec5ce5..807d21b6c800c 100644
--- a/.github/workflows/r.yml
+++ b/.github/workflows/r.yml
@@ -305,7 +305,8 @@ jobs:
             RWINLIB_LOCAL = file.path(Sys.getenv("GITHUB_WORKSPACE"), "r", "windows", "libarrow.zip"),
             MAKEFLAGS = paste0("-j", parallel::detectCores()),
             ARROW_R_DEV = TRUE,
-            "_R_CHECK_FORCE_SUGGESTS_" = FALSE
+            "_R_CHECK_FORCE_SUGGESTS_" = FALSE,
+            "_R_CHECK_STOP_ON_INVALID_NUMERIC_VERSION_INPUTS_" = TRUE
           )
           rcmdcheck::rcmdcheck(".",
             build_args = '--no-build-vignettes',
diff --git a/ci/scripts/r_test.sh b/ci/scripts/r_test.sh
index d7df44e2e43a9..e0c2ce9efedd8 100755
--- a/ci/scripts/r_test.sh
+++ b/ci/scripts/r_test.sh
@@ -65,6 +65,8 @@ export _R_CHECK_DONTTEST_EXAMPLES_=TRUE
 export _R_CHECK_FORCE_SUGGESTS_=FALSE
 export _R_CHECK_LIMIT_CORES_=FALSE
 export _R_CHECK_TESTS_NLINES_=0
+# This can cause failures on CRAN but needs to be set here so issues an error not a warning
+export _R_CHECK_STOP_ON_INVALID_NUMERIC_VERSION_INPUTS_=TRUE
 
 # By default, aws-sdk tries to contact a non-existing local ip host
 # to retrieve metadata. Disable this so that S3FileSystem tests run faster.

From fa0af70b21d7d0cbd94ae0bd27ea34b936f7f347 Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Fri, 25 Aug 2023 10:32:15 -0800
Subject: [PATCH 239/749] MINOR: [R][Docs] Improve error message around
 add_filename (#37372)

### Rationale for this change

Before this change, it's difficult for the user to not get stuck when they run into an error trying to use the result of add_filename in subsequent pipeline steps.

### What changes are included in this PR?

- Update error message string now includes advice
- Updated docs page for add_filename including an example

### Are these changes tested?

Yes. Tests were updated and confirmed to pass.

### Are there any user-facing changes?

No.

Authored-by: Bryce Mecum <petridish@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/R/dplyr-funcs-augmented.R     | 24 +++++++++++++++++++-----
 r/R/util.R                      |  5 +++--
 r/man/add_filename.Rd           | 21 ++++++++++++++++++---
 r/tests/testthat/test-dataset.R |  5 +++--
 4 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/r/R/dplyr-funcs-augmented.R b/r/R/dplyr-funcs-augmented.R
index 1067f15573b95..116248d2dd92a 100644
--- a/r/R/dplyr-funcs-augmented.R
+++ b/r/R/dplyr-funcs-augmented.R
@@ -20,13 +20,27 @@
 #' This function only exists inside `arrow` `dplyr` queries, and it only is
 #' valid when quering on a `FileSystemDataset`.
 #'
-#' @return A `FieldRef` `Expression` that refers to the filename augmented
-#' column.
-#' @examples
-#' \dontrun{
+#' To use filenames generated by this function in subsequent pipeline steps, you
+#' must either call \code{\link[dplyr:compute]{compute()}} or
+#' \code{\link[dplyr:collect]{collect()}} first. See Examples.
+#'
+#' @return A `FieldRef` \code{\link{Expression}} that refers to the filename
+#' augmented column.
+#'
+#' @examples \dontrun{
+#' open_dataset("nyc-taxi") %>% mutate(
+#'   file =
+#'     add_filename()
+#' )
+#'
+#' # To use a verb like mutate() with add_filename() we need to first call
+#' # compute()
 #' open_dataset("nyc-taxi") %>%
-#'   mutate(file = add_filename())
+#'   mutate(file = add_filename()) %>%
+#'   compute() %>%
+#'   mutate(filename_length = nchar(file))
 #' }
+#'
 #' @keywords internal
 add_filename <- function() Expression$field_ref("__filename")
 
diff --git a/r/R/util.R b/r/R/util.R
index 46ce92d0c1845..a7cb5b3792d29 100644
--- a/r/R/util.R
+++ b/r/R/util.R
@@ -223,8 +223,9 @@ handle_augmented_field_misuse <- function(msg, call) {
       msg,
       i = paste(
         "`add_filename()` or use of the `__filename` augmented field can only",
-        "be used with with Dataset objects, and can only be added before doing",
-        "an aggregation or a join."
+        "be used with Dataset objects, can only be added before doing",
+        "an aggregation or a join, and cannot be referenced in subsequent",
+        "pipeline steps until either compute() or collect() is called."
       )
     )
     abort(msg, call = call)
diff --git a/r/man/add_filename.Rd b/r/man/add_filename.Rd
index ca7ed0e4b1760..93718435a2042 100644
--- a/r/man/add_filename.Rd
+++ b/r/man/add_filename.Rd
@@ -7,17 +7,32 @@
 add_filename()
 }
 \value{
-A \code{FieldRef} \code{Expression} that refers to the filename augmented
-column.
+A \code{FieldRef} \code{\link{Expression}} that refers to the filename
+augmented column.
 }
 \description{
 This function only exists inside \code{arrow} \code{dplyr} queries, and it only is
 valid when quering on a \code{FileSystemDataset}.
 }
+\details{
+To use filenames generated by this function in subsequent pipeline steps, you
+must either call \code{\link[dplyr:compute]{compute()}} or
+\code{\link[dplyr:collect]{collect()}} first. See Examples.
+}
 \examples{
 \dontrun{
+open_dataset("nyc-taxi") \%>\% mutate(
+  file =
+    add_filename()
+)
+
+# To use a verb like mutate() with add_filename() we need to first call
+# compute()
 open_dataset("nyc-taxi") \%>\%
-  mutate(file = add_filename())
+  mutate(file = add_filename()) \%>\%
+  compute() \%>\%
+  mutate(filename_length = nchar(file))
 }
+
 }
 \keyword{internal}
diff --git a/r/tests/testthat/test-dataset.R b/r/tests/testthat/test-dataset.R
index cbeb081d0bae6..b7632084e4622 100644
--- a/r/tests/testthat/test-dataset.R
+++ b/r/tests/testthat/test-dataset.R
@@ -1440,8 +1440,9 @@ test_that("can add in augmented fields", {
 
   error_regex <- paste(
     "`add_filename()` or use of the `__filename` augmented field can only",
-    "be used with with Dataset objects, and can only be added before doing",
-    "an aggregation or a join."
+    "be used with Dataset objects, can only be added before doing",
+    "an aggregation or a join, and cannot be referenced in subsequent",
+    "pipeline steps until either compute() or collect() is called."
   )
 
   # errors appropriately with ArrowTabular objects

From faccbeff6e8ad0d54c6aaa28e2af1766d8ecd929 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 25 Aug 2023 15:55:05 -0400
Subject: [PATCH 240/749] GH-37337: [MATLAB] Add `arrow.array.Time64Array`
 class (#37368)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Now that `arrow.type.Time64Type` class has been added to the MATLAB Interface (#37287), we can add the `arrow.array.Time64Array` class.

### What changes are included in this PR?

1. New `arrow.array.Time64Array` class.
2. New `arrow.type.traits.Time64Traits` class.
3. Enhanced `arrow.array(data)` to return a `arrow.array.Time64Array` instance if the input `data` is a MATLAB `duration` array. The MATLAB `duration` type represents length of time in fixed-length units.
4. Enhanced `arrow.type.traits.traits(id)` to return an `arrow.type.traits.Time64Traits` instance if `id` is an `arrow.type.ID.Time64` value or equal to the string `"duration".`
5. Updated the test utility `arrow.internal.test.tabular.createAllSupportedArrayTypes()` to include an `arrow.array.Time64Array` instance in its output.
6. Updated the test utility `arrow.internal.test.tabular.createTableWithSupportedTypes()` to include a `duration` variable on the returned `table`.
7. Updated the README.md to include `Time32Array` and `Time64Array`.

**Example Usage**
```matlab

% Create a duration array
>> ms = milliseconds([100 150 1001])

ms =

  1×3 duration array

     0.1 sec    0.15 sec   1.001 sec

% Create an arrow.type.Time64Array
>> time = arrow.array(ms)

time =

[
  00:00:00.100000,
  00:00:00.150000,
  00:00:01.001000
]

% Create a duration array from an arrow.array.Time64Array
>> data = duration(time)

data =

  3×1 duration array

     0.1 sec
    0.15 sec
   1.001 sec

```

### Are these changes tested?

Yes.

1. Added a new test class `tTime64Array.m`.
2. Added a new test class `tTime64Traits.m`
3. Added new test cases to `tArray.m` and `ttraits.m`

### Are there any user-facing changes?

Yes. Users can now create `arrow.array.Time64Array`s from  MATLAB `duration`s

* Closes: #37337

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/README.md                              |   2 +
 .../arrow/matlab/array/proxy/time32_array.cc  |  38 +--
 .../arrow/matlab/array/proxy/time64_array.cc  |  28 +++
 .../arrow/matlab/array/proxy/time64_array.h   |  31 +++
 .../cpp/arrow/matlab/array/proxy/time_array.h |  72 ++++++
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   4 +-
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../arrow/matlab/type/proxy/time32_type.cc    |  21 +-
 .../arrow/matlab/type/proxy/time64_type.cc    |  21 +-
 .../cpp/arrow/matlab/type/proxy/time_type.cc  |  41 ++-
 .../cpp/arrow/matlab/type/proxy/time_type.h   |   4 +
 .../src/cpp/arrow/matlab/type/proxy/traits.h  |  12 +
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   3 +
 matlab/src/cpp/arrow/matlab/type/time_unit.cc |  20 ++
 matlab/src/cpp/arrow/matlab/type/time_unit.h  |   3 +
 matlab/src/matlab/+arrow/+array/Time64Array.m |  80 ++++++
 .../+tabular/createAllSupportedArrayTypes.m   |  14 +-
 .../+tabular/createTableWithSupportedTypes.m  |   4 +-
 .../+arrow/+type/+traits/Time64Traits.m       |  29 +++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   4 +
 matlab/src/matlab/+arrow/array.m              |   2 +
 matlab/test/arrow/array/tArray.m              |   1 +
 matlab/test/arrow/array/tTime64Array.m        | 236 ++++++++++++++++++
 matlab/test/arrow/type/traits/tTime64Traits.m |  32 +++
 matlab/test/arrow/type/traits/ttraits.m       |  23 ++
 matlab/test/tfeather.m                        |  49 ++--
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 28 files changed, 667 insertions(+), 111 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/time64_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/time64_array.h
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/time_array.h
 create mode 100644 matlab/src/matlab/+arrow/+array/Time64Array.m
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
 create mode 100644 matlab/test/arrow/array/tTime64Array.m
 create mode 100644 matlab/test/arrow/type/traits/tTime64Traits.m

diff --git a/matlab/README.md b/matlab/README.md
index e0acb8b748b6d..d6b08fbee1c15 100644
--- a/matlab/README.md
+++ b/matlab/README.md
@@ -51,6 +51,8 @@ Supported `arrow.array.Array` types are included in the table below.
 | `logical`         | `BooleanArray`   |
 | `string`          | `StringArray`    |
 | `datetime`        | `TimestampArray` |
+| `duration`        | `Time32Array`    |
+| `duration`        | `Time64Array`    |
 
 ## Prerequisites
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
index 5def045a9d77d..2be1af6d2c264 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time32_array.cc
@@ -16,47 +16,13 @@
 // under the License.
 
 #include "arrow/matlab/array/proxy/time32_array.h"
-
-#include "arrow/matlab/type/time_unit.h"
-#include "arrow/util/utf8.h"
+#include "arrow/matlab/array/proxy/time_array.h"
 
 namespace arrow::matlab::array::proxy {
 
     // Specialization of NumericArray::Make for arrow::Time32Type
     template <>
     libmexclass::proxy::MakeResult Time32Array::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
-       namespace mda = ::matlab::data;
-       using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
-       using Time32Array = arrow::Time32Array;
-       using Time32ArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>;
-
-       mda::StructArray opts = constructor_arguments[0];
-
-       // Get the mxArray from constructor arguments
-       const mda::TypedArray<int32_t> time32_mda = opts[0]["MatlabArray"];
-       const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
-       
-       const mda::TypedArray<mda::MATLABString> units_mda = opts[0]["TimeUnit"];
-
-       // extract the time unit
-       const std::u16string& u16_timeunit = units_mda[0];
-       MATLAB_ASSIGN_OR_ERROR(const auto time_unit,
-                              arrow::matlab::type::timeUnitFromString(u16_timeunit),
-                              error::UKNOWN_TIME_UNIT_ERROR_ID)
-
-       // create the Time32Type
-       auto data_type = arrow::time32(time_unit);
-       auto array_length = static_cast<int32_t>(time32_mda.getNumberOfElements()); // cast size_t to int32_t
-
-       auto data_buffer = std::make_shared<MatlabBuffer>(time32_mda);
-
-       // Pack the validity bitmap values.
-       MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap,
-                              bit::packValid(validity_bitmap_mda),
-                              error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
-
-       auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
-       auto time32_array = std::static_pointer_cast<Time32Array>(arrow::MakeArray(array_data));
-       return std::make_shared<Time32ArrayProxy>(std::move(time32_array));
+        return make_time_array<arrow::Time32Type>(constructor_arguments);
     }
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.cc
new file mode 100644
index 0000000000000..4ef2e990dc7ec
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.cc
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/array/proxy/time64_array.h"
+#include "arrow/matlab/array/proxy/time_array.h"
+
+namespace arrow::matlab::array::proxy {
+
+    // Specialization of NumericArray::Make for arrow::Time64Type
+    template <>
+    libmexclass::proxy::MakeResult Time64Array::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        return make_time_array<arrow::Time64Type>(constructor_arguments);
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.h
new file mode 100644
index 0000000000000..aab586defe75e
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time64_array.h
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/array/proxy/numeric_array.h"
+
+#include "arrow/matlab/api/visibility.h"
+
+namespace arrow::matlab::array::proxy {
+
+    using Time64Array = NumericArray<arrow::Time64Type>;
+
+    // Specialization of NumericArray::Make for arrow::Time64Type
+    template<>
+    ARROW_MATLAB_EXPORT libmexclass::proxy::MakeResult Time64Array::make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/time_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/time_array.h
new file mode 100644
index 0000000000000..68713a3dcce34
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/time_array.h
@@ -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.
+
+#include "arrow/matlab/array/proxy/numeric_array.h"
+
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/util/utf8.h"
+#include "arrow/type_traits.h"
+
+namespace arrow::matlab::array::proxy {
+
+    template <typename ArrowType>
+    using is_time = arrow::is_time_type<ArrowType>;
+
+    template <typename ArrowType>
+    using enable_if_time = std::enable_if_t<is_time<ArrowType>::value, bool>; 
+
+    template <typename ArrowType, enable_if_time<ArrowType> = true>
+    libmexclass::proxy::MakeResult make_time_array(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+       namespace mda = ::matlab::data;
+       using namespace arrow::matlab::type;
+       using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+       using TimeArray =  arrow::NumericArray<ArrowType>; 
+       using TimeArrayProxy = proxy::NumericArray<ArrowType>;
+       using CType = typename arrow::TypeTraits<ArrowType>::CType;
+
+       mda::StructArray opts = constructor_arguments[0];
+
+       const mda::TypedArray<CType> time_mda = opts[0]["MatlabArray"];
+       const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+       const mda::TypedArray<mda::MATLABString> time_unit_mda = opts[0]["TimeUnit"];
+
+       // extract the time unit
+       const std::u16string& time_unit_utf16 = time_unit_mda[0];
+       MATLAB_ASSIGN_OR_ERROR(const auto time_unit,
+                              timeUnitFromString(time_unit_utf16),
+                              error::UKNOWN_TIME_UNIT_ERROR_ID);
+
+       MATLAB_ERROR_IF_NOT_OK(validateTimeUnit<ArrowType>(time_unit),
+                              error::INVALID_TIME_UNIT);
+
+       // create the ArrowType
+       const auto data_type = std::make_shared<ArrowType>(time_unit);
+
+       auto array_length = static_cast<size_t>(time_mda.getNumberOfElements()); 
+       auto data_buffer = std::make_shared<MatlabBuffer>(time_mda);
+
+       // Pack the validity bitmap values.
+       MATLAB_ASSIGN_OR_ERROR(auto packed_validity_bitmap,
+                              bit::packValid(validity_bitmap_mda),
+                              error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+       auto array_data = arrow::ArrayData::Make(data_type, array_length, {packed_validity_bitmap, data_buffer});
+       auto time_array = std::static_pointer_cast<TimeArray>(arrow::MakeArray(array_data));
+       return std::make_shared<TimeArrayProxy>(std::move(time_array));
+
+    }
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index e11e9bb7669b1..3d1881a7dfb58 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -53,10 +53,12 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::TimestampType>>(std::static_pointer_cast<arrow::TimestampArray>(array));
             case ID::TIME32:
                 return std::make_shared<proxy::NumericArray<arrow::Time32Type>>(std::static_pointer_cast<arrow::Time32Array>(array));
+            case ID::TIME64:
+                return std::make_shared<proxy::NumericArray<arrow::Time64Type>>(std::static_pointer_cast<arrow::Time64Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
             default:
                 return arrow::Status::NotImplemented("Unsupported DataType: " + array->type()->ToString());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index deac5e26fc1c0..2f17cfda16f3d 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -171,6 +171,7 @@ namespace arrow::matlab::error {
     static const char* STRING_BUILDER_APPEND_FAILED = "arrow:matlab:array:string:StringBuilderAppendFailed";
     static const char* STRING_BUILDER_FINISH_FAILED = "arrow:matlab:array:string:StringBuilderFinishFailed";
     static const char* UKNOWN_TIME_UNIT_ERROR_ID = "arrow:matlab:UnknownTimeUnit";
+    static const char* INVALID_TIME_UNIT = "arrow:type:InvalidTimeUnit";
     static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
     static const char* ARRAY_FAILED_TO_CREATE_TYPE_PROXY = "arrow:array:FailedToCreateTypeProxy";
     static const char* ARROW_TABULAR_SCHEMA_INVALID_NUMERIC_FIELD_INDEX = "arrow:tabular:schema:InvalidNumericFieldIndex";
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 93dd9245aeb3c..7a84810c5a93c 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -20,6 +20,7 @@
 #include "arrow/matlab/array/proxy/string_array.h"
 #include "arrow/matlab/array/proxy/timestamp_array.h"
 #include "arrow/matlab/array/proxy/time32_array.h"
+#include "arrow/matlab/array/proxy/time64_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
@@ -52,6 +53,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
+    REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
index 7b2313d6c312d..a3f54ed56a5da 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time32_type.cc
@@ -16,31 +16,12 @@
 // under the License.
 
 #include "arrow/matlab/type/proxy/time32_type.h"
-#include "arrow/matlab/type/time_unit.h"
-#include "arrow/matlab/error/error.h"
-#include "arrow/util/utf8.h"
 
 namespace arrow::matlab::type::proxy {
 
     Time32Type::Time32Type(std::shared_ptr<arrow::Time32Type> time32_type) : TimeType(std::move(time32_type)) {}
 
     libmexclass::proxy::MakeResult Time32Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
-        namespace mda = ::matlab::data;
-
-        using Time32TypeProxy = arrow::matlab::type::proxy::Time32Type;
-
-        mda::StructArray opts = constructor_arguments[0];
-
-        const mda::StringArray timeunit_mda = opts[0]["TimeUnit"];
-
-        // extract the time unit
-        const std::u16string& utf16_timeunit = timeunit_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto timeunit,
-                               arrow::matlab::type::timeUnitFromString(utf16_timeunit),
-                               error::UKNOWN_TIME_UNIT_ERROR_ID);
-
-        auto type = arrow::time32(timeunit);
-        auto time_type = std::static_pointer_cast<arrow::Time32Type>(type);
-        return std::make_shared<Time32TypeProxy>(std::move(time_type));
+        return make_time_type<arrow::Time32Type>(constructor_arguments);
     }
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
index 0ec58337622a7..ab494c909ac56 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time64_type.cc
@@ -16,31 +16,12 @@
 // under the License.
 
 #include "arrow/matlab/type/proxy/time64_type.h"
-#include "arrow/matlab/type/time_unit.h"
-#include "arrow/matlab/error/error.h"
-#include "arrow/util/utf8.h"
 
 namespace arrow::matlab::type::proxy {
 
     Time64Type::Time64Type(std::shared_ptr<arrow::Time64Type> time64_type) : TimeType(std::move(time64_type)) {}
 
     libmexclass::proxy::MakeResult Time64Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
-        namespace mda = ::matlab::data;
-
-        using Time64TypeProxy = arrow::matlab::type::proxy::Time64Type;
-
-        mda::StructArray opts = constructor_arguments[0];
-
-        const mda::StringArray timeunit_mda = opts[0]["TimeUnit"];
-
-        // extract the time unit
-        const std::u16string& utf16_timeunit = timeunit_mda[0];
-        MATLAB_ASSIGN_OR_ERROR(const auto timeunit,
-                               arrow::matlab::type::timeUnitFromString(utf16_timeunit),
-                               error::UKNOWN_TIME_UNIT_ERROR_ID);
-
-        auto type = arrow::time64(timeunit);
-        auto time_type = std::static_pointer_cast<arrow::Time64Type>(type);
-        return std::make_shared<Time64TypeProxy>(std::move(time_type));
+        return make_time_type<arrow::Time64Type>(constructor_arguments);
     }
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
index 1cc92834b9449..84c875ba489ad 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.cc
@@ -16,6 +16,10 @@
 // under the License.
 
 #include "arrow/matlab/type/proxy/time_type.h"
+#include "arrow/matlab/type/proxy/traits.h"
+#include "arrow/matlab/type/time_unit.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/util/utf8.h"
 
 namespace arrow::matlab::type::proxy {
 
@@ -28,10 +32,43 @@ namespace arrow::matlab::type::proxy {
         mda::ArrayFactory factory;
 
         auto time_type = std::static_pointer_cast<arrow::TimeType>(data_type);
-        const auto timeunit = time_type->unit();
+        const auto time_unit = time_type->unit();
         // Cast to uint8_t since there are only four supported TimeUnit enumeration values:
         // Nanosecond, Microsecond, Millisecond, Second
-        auto timeunit_mda = factory.createScalar(static_cast<uint8_t>(timeunit));
+        auto timeunit_mda = factory.createScalar(static_cast<uint8_t>(time_unit));
         context.outputs[0] = timeunit_mda;
     }
+
+    template <typename ArrowType> 
+    libmexclass::proxy::MakeResult make_time_type(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using namespace arrow::matlab::type;
+        using TimeTypeProxy = typename proxy::Traits<ArrowType>::TypeProxy; 
+
+        mda::StructArray opts = constructor_arguments[0];
+
+        const mda::StringArray time_unit_mda = opts[0]["TimeUnit"];
+
+        // extract the time unit
+        const std::u16string& time_unit_utf16 = time_unit_mda[0];
+        MATLAB_ASSIGN_OR_ERROR(const auto timeunit,
+                               timeUnitFromString(time_unit_utf16),
+                               error::UKNOWN_TIME_UNIT_ERROR_ID);
+
+        // validate timeunit 
+        MATLAB_ERROR_IF_NOT_OK(validateTimeUnit<ArrowType>(timeunit),
+                               error::INVALID_TIME_UNIT);
+
+        auto type = std::make_shared<ArrowType>(timeunit);
+        auto time_type = std::static_pointer_cast<ArrowType>(type);
+        return std::make_shared<TimeTypeProxy>(std::move(time_type));
+    }
+
+    // Trigger code generation for the allowed template specializations using explicit instantiation.
+    template
+    libmexclass::proxy::MakeResult make_time_type<arrow::Time32Type>(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    template
+    libmexclass::proxy::MakeResult make_time_type<arrow::Time64Type>(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
index 05521b9c36b19..91d92aa4c40e2 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/time_type.h
@@ -32,4 +32,8 @@ class TimeType : public arrow::matlab::type::proxy::FixedWidthType {
         void getTimeUnit(libmexclass::proxy::method::Context& context);
 };
 
+template <typename ArrowType>
+libmexclass::proxy::MakeResult make_time_type(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
index 3d9a957a5e3dc..fdae911062b28 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
@@ -21,6 +21,8 @@
 
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
+#include "arrow/matlab/type/proxy/time32_type.h"
+#include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -87,4 +89,14 @@ namespace arrow::matlab::type::proxy {
     struct Traits<arrow::TimestampType> {
         using TypeProxy = TimestampType;
     };
+
+    template <>
+    struct Traits<arrow::Time32Type> {
+        using TypeProxy = Time32Type;
+    };
+
+    template <>
+    struct Traits<arrow::Time64Type> {
+        using TypeProxy = Time64Type;
+    };
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index 39c60fea9bc5c..efb510e89751d 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -20,6 +20,7 @@
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
+#include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -53,6 +54,8 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<TimestampType>(std::static_pointer_cast<arrow::TimestampType>(type));
             case ID::TIME32:
                 return std::make_shared<Time32Type>(std::static_pointer_cast<arrow::Time32Type>(type));
+            case ID::TIME64:
+                return std::make_shared<Time64Type>(std::static_pointer_cast<arrow::Time64Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
             default:
diff --git a/matlab/src/cpp/arrow/matlab/type/time_unit.cc b/matlab/src/cpp/arrow/matlab/type/time_unit.cc
index eb839b0e78096..7a7cf7f350828 100644
--- a/matlab/src/cpp/arrow/matlab/type/time_unit.cc
+++ b/matlab/src/cpp/arrow/matlab/type/time_unit.cc
@@ -35,4 +35,24 @@ namespace arrow::matlab::type {
             return arrow::Status::Invalid(msg);
         }
     }
+
+    template<>
+    arrow::Status validateTimeUnit<arrow::Time32Type>(arrow::TimeUnit::type unit) {
+        using arrow::TimeUnit;
+        if (unit == TimeUnit::type::SECOND || unit == TimeUnit::type::MILLI) {
+            return arrow::Status::OK();
+        } else {
+            return arrow::Status::Invalid("TimeUnit for Time32 must be Second or Millisecond"); 
+        }
+    }
+
+    template<>
+    arrow::Status validateTimeUnit<arrow::Time64Type>(arrow::TimeUnit::type unit) {
+        using arrow::TimeUnit;
+        if (unit == TimeUnit::type::MICRO || unit == TimeUnit::type::NANO) {
+            return arrow::Status::OK();
+        } else {
+            return arrow::Status::Invalid("TimeUnit for Time64 must be Microsecond or Nanosecond"); 
+        }
+    }
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/time_unit.h b/matlab/src/cpp/arrow/matlab/type/time_unit.h
index 9534b1f902db7..2470fc53cf434 100644
--- a/matlab/src/cpp/arrow/matlab/type/time_unit.h
+++ b/matlab/src/cpp/arrow/matlab/type/time_unit.h
@@ -24,4 +24,7 @@ namespace arrow::matlab::type {
 
     arrow::Result<arrow::TimeUnit::type> timeUnitFromString(std::u16string_view unit_str);
 
+    template <typename TimeType>
+    arrow::Status validateTimeUnit(arrow::TimeUnit::type unit);
+
 }
diff --git a/matlab/src/matlab/+arrow/+array/Time64Array.m b/matlab/src/matlab/+arrow/+array/Time64Array.m
new file mode 100644
index 0000000000000..f85eeb1f8f0c9
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/Time64Array.m
@@ -0,0 +1,80 @@
+% arrow.array.Time64Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time64Array < arrow.array.Array
+
+    properties(Access=private)
+        NullSubstitutionValue = seconds(NaN);
+    end
+
+    methods
+        function obj = Time64Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Time64Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function times = toMATLAB(obj)
+            import arrow.type.TimeUnit
+            divider = ticksPerSecond(obj.Type.TimeUnit) / ticksPerSecond(TimeUnit.Millisecond);
+            matlabArray = obj.Proxy.toMATLAB();
+            % TODO: This conversion may be lossy. Is it better to cast the
+            % int64 array to a double before dividing by 1e3 or 1e6? 
+            times = milliseconds(cast(matlabArray, "double") / divider);
+            times(~obj.Valid) = obj.NullSubstitutionValue;
+        end
+
+        function times = duration(obj)
+            times = obj.toMATLAB();
+        end
+    end
+
+    methods(Static, Access=private)
+        function ticks = convertDurationToTicks(data, timeUnit)
+            import arrow.type.TimeUnit
+            multiplier = ticksPerSecond(timeUnit) / ticksPerSecond(TimeUnit.Millisecond);
+            ticks = cast(milliseconds(data) * multiplier, "int64");
+        end
+    end
+
+    methods(Static)
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.TimeUnit(1, 1) TimeUnit {timeUnit("Time64", opts.TimeUnit)} = TimeUnit.Microsecond
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            import arrow.type.TimeUnit
+            import arrow.array.Time64Array
+            import arrow.internal.validate.temporal.timeUnit
+            
+            arrow.internal.validate.type(data, "duration");
+            arrow.internal.validate.shape(data);
+
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            ticks = Time64Array.convertDurationToTicks(data, opts.TimeUnit);
+
+            args = struct(MatlabArray=ticks, Valid=validElements, TimeUnit=string(opts.TimeUnit));
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.Time64Array", args);
+            array = Time64Array(proxy);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index 7d3f36cb46e7c..15ee0589d56e4 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -31,7 +31,8 @@
     arrowArrays = cell(numClasses, 1);
     matlabData  = cell(numClasses, 1);
     
-    numericArrayToMatlabTypeDict = getArrowArrayToMatlabTypeDictionary();
+    timeClasses = getTimeArrayClasses();
+    numericArrayToMatlabTypeDict = getNumericArrayToMatlabDictionary();
 
     for ii = 1:numel(classes)
         name = classes(ii);
@@ -49,9 +50,10 @@
         elseif name == "arrow.array.TimestampArray"
             matlabData{ii} = randomDatetimes(opts.NumRows);
             arrowArrays{ii} = TimestampArray.fromMATLAB(matlabData{ii});
-        elseif name == "arrow.array.Time32Array"
+        elseif ismember(name, timeClasses)
             matlabData{ii} = randomDurations(opts.NumRows);
-            arrowArrays{ii} = Time32Array.fromMATLAB(matlabData{ii});
+            cmd = compose("%s.fromMATLAB(matlabData{ii})", name);
+            arrowArrays{ii} = eval(cmd);
         else
             error("arrow:test:SupportedArrayCase", ...
                 "Missing if-branch for array class " + name); 
@@ -68,7 +70,7 @@
     classes = string({metaClass.Name});
 end
 
-function dict = getArrowArrayToMatlabTypeDictionary()
+function dict = getNumericArrayToMatlabDictionary()
     pkg = "arrow.array";
     unsignedTypes = compose("UInt%d", power(2, 3:6));
     signedTypes = compose("Int%d", power(2, 3:6));
@@ -80,6 +82,10 @@
     dict = dictionary(keys, values);
 end
 
+function timeClasses = getTimeArrayClasses()
+    timeClasses = compose("arrow.array.Time%dArray", [32 64]);
+end
+
 function number = randomNumbers(numberType, numElements)
     number = cast(randi(255, [numElements 1]), numberType);
 end
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
index c69aef35d18b3..804a8f358c8be 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createTableWithSupportedTypes.m
@@ -35,7 +35,8 @@
                      "single", ...
                      "double", ...
                      "string", ...
-                     "datetime"];
+                     "datetime", ...
+                     "duration"];
 
     T = table(uint8   ((1:numRows)'), ...
               uint16  ((1:numRows)'), ...
@@ -50,5 +51,6 @@
               double  ((1:numRows)'), ...
               string  ((1:numRows)'), ...
               datetime(2023, 6, 28) + days(0:numRows-1)', ...
+              seconds((1:numRows)'), ...
               VariableNames=variableNames);
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
new file mode 100644
index 0000000000000..f9108d6ac3879
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
@@ -0,0 +1,29 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Time64Traits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        ArrayConstructor = @arrow.array.Time64Array
+        ArrayClassName = "arrow.array.Time64Array"
+        ArrayProxyClassName = "arrow.array.proxy.Time64Array"
+        TypeConstructor = @arrow.type.Time64Type;
+        TypeClassName = "arrow.type.Time64Type"
+        TypeProxyClassName = "arrow.type.proxy.Time64Type"
+        MatlabConstructor = @duration
+        MatlabClassName = "duration"
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index 0c3628f01e561..e7c7f9b3272d1 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -50,6 +50,8 @@
                 typeTraits = TimestampTraits();
             case ID.Time32
                 typeTraits = Time32Traits();
+            case ID.Time64
+                typeTraits = Time64Traits();
             otherwise
                 error("arrow:type:traits:UnsupportedArrowTypeID", "Unsupported Arrow type ID: " + type);
         end
@@ -81,6 +83,8 @@
                 typeTraits = StringTraits();
             case "datetime"
                 typeTraits = TimestampTraits();
+            case "duration"
+                typeTraits = Time64Traits();
             otherwise
                 error("arrow:type:traits:UnsupportedMatlabClass", "Unsupported MATLAB class: " + type);
         end
diff --git a/matlab/src/matlab/+arrow/array.m b/matlab/src/matlab/+arrow/array.m
index a2d0ecd2e8f76..983b3c88680c4 100644
--- a/matlab/src/matlab/+arrow/array.m
+++ b/matlab/src/matlab/+arrow/array.m
@@ -51,6 +51,8 @@
             arrowArray = arrow.array.StringArray.fromMATLAB(data, args{:});
         case "datetime"
             arrowArray = arrow.array.TimestampArray.fromMATLAB(data, args{:});
+        case "duration"
+            arrowArray = arrow.array.Time64Array.fromMATLAB(data, args{:});
         otherwise
             errid = "arrow:array:UnsupportedMATLABType";
             msg = join(["Unable to convert MATLAB type" classname "to arrow array."]);
diff --git a/matlab/test/arrow/array/tArray.m b/matlab/test/arrow/array/tArray.m
index 4a476696bfacf..54b31270b25d2 100644
--- a/matlab/test/arrow/array/tArray.m
+++ b/matlab/test/arrow/array/tArray.m
@@ -31,6 +31,7 @@
             {single([1 2]),        "arrow.array.Float32Array"}, ...
             {[1 2],                "arrow.array.Float64Array"}, ...
             {datetime(2022, 1, 1), "arrow.array.TimestampArray"}, ...
+            {seconds([1 2]),       "arrow.array.Time64Array"}, ...
             {["A" "B"],            "arrow.array.StringArray"}};
     end
 
diff --git a/matlab/test/arrow/array/tTime64Array.m b/matlab/test/arrow/array/tTime64Array.m
new file mode 100644
index 0000000000000..973a8e6b6af75
--- /dev/null
+++ b/matlab/test/arrow/array/tTime64Array.m
@@ -0,0 +1,236 @@
+%TTIME64ARRAY Unit tests for arrow.array.Time64Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime64Array < matlab.unittest.TestCase
+
+    properties
+        ArrowArrayConstructorFcn = @arrow.array.Time64Array.fromMATLAB
+    end
+
+    properties(TestParameter)
+        Unit = {arrow.type.TimeUnit.Microsecond, arrow.type.TimeUnit.Nanosecond}
+    end
+
+    methods (Test)
+        function Basic(tc)
+            times = seconds(1:4);
+            array = tc.ArrowArrayConstructorFcn(times);
+            tc.verifyInstanceOf(array, "arrow.array.Time64Array");
+        end
+
+        function TypeIsTime64(tc)
+            times = seconds(1:4);
+            array = tc.ArrowArrayConstructorFcn(times);
+            tc.verifyTime64Type(array.Type, arrow.type.TimeUnit.Microsecond);
+        end
+
+        function SupportedTimeUnit(tc)
+            import arrow.type.TimeUnit
+            times = seconds(1:4);
+            
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit="Microsecond");
+            tc.verifyTime64Type(array.Type, arrow.type.TimeUnit.Microsecond);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Microsecond);
+            tc.verifyTime64Type(array.Type, arrow.type.TimeUnit.Microsecond);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit="Nanosecond");
+            tc.verifyTime64Type(array.Type, arrow.type.TimeUnit.Nanosecond);
+
+            array = tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Nanosecond);
+            tc.verifyTime64Type(array.Type, arrow.type.TimeUnit.Nanosecond);
+        end
+
+        function UnsupportedTimeUnitError(tc)
+            % Verify arrow.array.Time64Array.fromMATLAB() errors if 
+            % supplied an unsupported TimeUnit (Second or Millisecond).
+            import arrow.type.TimeUnit
+            times = seconds(1:4);
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit="Second");
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime64TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Second);
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime64TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit="Millisecond");
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime64TimeUnit");
+
+            fcn = @() tc.ArrowArrayConstructorFcn(times, TimeUnit=TimeUnit.Millisecond);
+            tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime64TimeUnit");
+        end
+
+        function TestLength(testCase)
+            % Verify the Length property.
+
+            times = duration.empty(0, 1);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+
+            times = duration(1, 2, 3);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(1));
+
+            times = duration(1, 2, 3) + hours(0:4);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(5));
+        end
+
+        function TestToMATLAB(testCase, Unit)
+            % Verify toMATLAB() round-trips the original duration array.
+            times = seconds([100 200 355 400]);
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit);
+            values = toMATLAB(array);
+            testCase.verifyEqual(values, times');
+        end
+
+        function TestDuration(testCase, Unit)
+            % Verify duration() round-trips the original duration array.
+            times = seconds([100 200 355 400]);
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit);
+            values = duration(array);
+            testCase.verifyEqual(values, times');
+        end
+
+        function TestValid(testCase, Unit)
+            % Verify the Valid property returns the expected logical vector.
+            times = seconds([100 200 NaN 355 NaN 400]);
+            arrray = testCase.ArrowArrayConstructorFcn(times, TImeUnit=Unit);
+            testCase.verifyEqual(arrray.Valid, [true; true; false; true; false; true]);
+            testCase.verifyEqual(toMATLAB(arrray), times');
+            testCase.verifyEqual(duration(arrray), times');
+        end
+
+        function InferNullsTrueNVPair(testCase, Unit)
+            % Verify arrow.array.Time64Array.fromMATLAB() behaves as
+            % expected when InferNulls=true is provided.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            array = testCase.ArrowArrayConstructorFcn(times, InferNulls=true, TimeUnit=Unit);
+            expectedValid = [true; true; false; true; true; false; true];
+            testCase.verifyEqual(array.Valid, expectedValid);
+            testCase.verifyEqual(toMATLAB(array), times');
+            testCase.verifyEqual(duration(array), times');
+        end
+
+        function InferNullsFalseNVPair(testCase, Unit)
+            % Verify arrow.array.Time64Array.fromMATLAB() behaves as
+            % expected when InferNulls=false is provided.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            array = testCase.ArrowArrayConstructorFcn(times, InferNulls=false, TimeUnit=Unit);
+            expectedValid = true([7 1]);
+            testCase.verifyEqual(array.Valid, expectedValid);
+
+            % If NaN durations were not considered null values, then they
+            % are treated like int64(0) values.
+            expectedTime = times';
+            expectedTime([3 6]) = 0;
+            testCase.verifyEqual(toMATLAB(array), expectedTime);
+            testCase.verifyEqual(duration(array), expectedTime);
+        end
+
+        function TestValidNVPair(testCase, Unit)
+            % Verify arrow.array.Time64Array.fromMATLAB() accepts the Valid
+            % nv-pair, and it behaves as expected.
+
+            times = seconds([1 2 NaN 4 5 NaN 7]);
+            
+            % Supply the Valid name-value pair as vector of indices.
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit, Valid=[1 2 3 5]);
+            testCase.verifyEqual(array.Valid, [true; true; true; false; true; false; false]);
+            expectedTimes = times';
+            expectedTimes(3) = 0;
+            expectedTimes([4 6 7]) = NaN;
+            testCase.verifyEqual(toMATLAB(array), expectedTimes);
+
+            % Supply the Valid name-value pair as a logical scalar.
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit, Valid=false);
+            testCase.verifyEqual(array.Valid, false([7 1]));
+            expectedTimes(:) = NaN;
+            testCase.verifyEqual(toMATLAB(array), expectedTimes);
+        end
+
+        function EmptyDurationVector(testCase)
+            % Verify arrow.array.Time64Array.fromMATLAB() accepts any
+            % empty-shaped duration as input.
+
+            times = duration.empty(0, 0);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
+
+            % Test with an N-Dimensional empty array
+            times = duration.empty(0, 1, 0);
+            array = testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
+        end
+
+        function ErrorIfNonVector(testCase)
+            % Verify arrow.array.Time64Array.fromMATLAB() throws an error
+            % if the input provided is not a vector.
+
+            times = duration(200, 45, 34) + hours(0:11);
+            times = reshape(times, 2, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+
+            times = reshape(times, 3, 2, 2);
+            fcn = @() testCase.ArrowArrayConstructorFcn(times);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+        end
+
+        function ErrorIfNonDuration(testCase)
+            % Verify arrow.array.Time64Array.fromMATLAB() throws an error
+            % if not given a duration as input.
+
+            dates = datetime(2023, 4, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+
+            numbers = [1; 2; 3; 4];
+            fcn = @() testCase.ArrowArrayConstructorFcn(numbers);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+        end
+
+        function MicrosecondPrecision(testCase)
+            % Verify microsecond precision when TimeUnit="Microsecond" 
+            original = milliseconds(1.0033);
+            array = testCase.ArrowArrayConstructorFcn(original, TimeUnit="Microsecond");
+            expected = milliseconds(1.003);
+            testCase.verifyEqual(duration(array), expected);
+        end
+
+        function NanosecondPrecision(testCase)
+            % Verify nanosecond precision when TimeUnit="Nanosecond"
+            original = milliseconds(1.0030031);
+            array = testCase.ArrowArrayConstructorFcn(original, TimeUnit="Nanosecond");
+            expected = milliseconds(1.0030030);
+            testCase.verifyEqual(duration(array), expected);
+        end
+    end
+
+    methods
+        function verifyTime64Type(testCase, actual, expectedTimeUnit)
+            testCase.verifyInstanceOf(actual, "arrow.type.Time64Type");
+            testCase.verifyEqual(actual.ID, arrow.type.ID.Time64);
+            testCase.verifyEqual(actual.TimeUnit, expectedTimeUnit);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/tTime64Traits.m b/matlab/test/arrow/type/traits/tTime64Traits.m
new file mode 100644
index 0000000000000..bc4e205b96c5d
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tTime64Traits.m
@@ -0,0 +1,32 @@
+%TTIME64TRAITS Unit tests for arrow.type.traits.Time64Traits
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTime64Traits < hTypeTraits
+
+    properties
+        TraitsConstructor = @arrow.type.traits.Time64Traits
+        ArrayConstructor = @arrow.array.Time64Array
+        ArrayClassName = "arrow.array.Time64Array"
+        ArrayProxyClassName = "arrow.array.proxy.Time64Array"
+        TypeConstructor = @arrow.type.Time64Type
+        TypeClassName = "arrow.type.Time64Type"
+        TypeProxyClassName = "arrow.type.proxy.Time64Type"
+        MatlabConstructor = @duration
+        MatlabClassName = "duration"
+    end
+    
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index 3bfde78dbb615..771562152a5ef 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -163,6 +163,18 @@ function TestTime32(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits); 
         end
 
+        function TestTime64(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.Time64;
+            expectedTraits = Time64Traits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits); 
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 
@@ -306,6 +318,17 @@ function TestMatlabDatetime(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestMatlabDuration(testCase)
+            import arrow.type.traits.*
+
+            type = "duration";
+            expectedTraits = Time64Traits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestErrorIfUnsupportedMatlabClass(testCase)
             import arrow.type.traits.*
 
diff --git a/matlab/test/tfeather.m b/matlab/test/tfeather.m
index 72d2438cee83f..b24b6b4af1def 100755
--- a/matlab/test/tfeather.m
+++ b/matlab/test/tfeather.m
@@ -28,23 +28,21 @@ function setupTempWorkingDirectory(testCase)
     methods(Test)
 
         function NumericDatatypesNoNulls(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
-            
-            actualTable = createTableWithSupportedTypes;
+
+            actualTable = createFeatherCompatibleTable();
             expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NumericDatatypesWithNaNRow(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTableWithSupportedTypes;
+            t = createFeatherCompatibleTable();
             t = removevars(t, ["logical", "string", "datetime"]);
             
             variableNames = {'uint8', ...
@@ -73,12 +71,11 @@ function NumericDatatypesWithNaNRow(testCase)
         end
 
         function NumericDatatypesWithNaNColumns(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             actualTable.double = [NaN; NaN; NaN];
             actualTable.int64  = [NaN; NaN; NaN];
             
@@ -87,12 +84,11 @@ function NumericDatatypesWithNaNColumns(testCase)
         end
         
         function NumericDatatypesWithExpInfSciNotation(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             actualTable.single(2) = 1.0418e+06;
             
             actualTable.double(1) = Inf;
@@ -105,26 +101,24 @@ function NumericDatatypesWithExpInfSciNotation(testCase)
         end
         
         function IgnoreRowVarNames(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             time = {'day1', 'day2', 'day3'};
             actualTable.Properties.RowNames = time;
             expectedTable = roundtrip(filename, actualTable);
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             testCase.verifyEqual(actualTable, expectedTable);
         end
 
         function NotFeatherExtension(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.txt');
             
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
         end
@@ -140,12 +134,11 @@ function EmptyTable(testCase)
         end
 
         function zeroByNTable(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
             import arrow.internal.test.io.feather.roundtrip
 
             filename = fullfile(pwd, 'temp.feather');
             
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             actualTable([1, 2], :) = [];
             expectedTable = roundtrip(filename, actualTable);
             testCase.verifyEqual(actualTable, expectedTable);
@@ -162,11 +155,10 @@ function ErrorIfUnableToOpenFile(testCase)
         end
 
         function ErrorIfCorruptedFeatherFile(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTableWithSupportedTypes;
+            t = createFeatherCompatibleTable();
             featherwrite(filename, t);
             
             fileID = fopen(filename, 'w');
@@ -177,19 +169,17 @@ function ErrorIfCorruptedFeatherFile(testCase)
         end
         
         function ErrorIfInvalidFilenameDatatype(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
-            t = createTableWithSupportedTypes;
+            t = createFeatherCompatibleTable();
             
             testCase.verifyError(@() featherwrite({table}, t), 'MATLAB:validation:UnableToConvert');
         end
 
         function ErrorIfTooManyInputs(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
             filename = fullfile(pwd, 'temp.feather');
             
-            t = createTableWithSupportedTypes;
+            t = createFeatherCompatibleTable();
 
             testCase.verifyError(@() featherwrite(filename, t, 'SomeValue', 'SomeOtherValue'), 'MATLAB:TooManyInputs');
             testCase.verifyError(@() featherread(filename, 'SomeValue', 'SomeOtherValue'), 'MATLAB:TooManyInputs');
@@ -215,11 +205,10 @@ function ErrorIfMultiColVarExist(testCase)
         end
         
         function UnsupportedMATLABDatatypes(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
 
             filename = fullfile(pwd, 'temp.feather');
 
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             calendarDurationVariable = [calendarDuration(1, 7, 9); ...
                                         calendarDuration(2, 1, 1); ...
                                         calendarDuration(5, 3, 2)];
@@ -229,11 +218,9 @@ function UnsupportedMATLABDatatypes(testCase)
         end
         
         function NumericComplexUnsupported(testCase)
-            import arrow.internal.test.tabular.createTableWithSupportedTypes
-
             filename = fullfile(pwd, 'temp.feather');
 
-            actualTable = createTableWithSupportedTypes;
+            actualTable = createFeatherCompatibleTable();
             actualTable.single(1) = 1.0418 + 2i;
             actualTable.double(2) = exp(9) + 5i;
             actualTable.int64(2) = 1.0418e+03;
@@ -282,3 +269,11 @@ function UnicodeVariableNames(testCase)
 
     end
 end
+
+function t = createFeatherCompatibleTable()
+    import arrow.internal.test.tabular.createTableWithSupportedTypes
+    t = createTableWithSupportedTypes;
+    % Remove the duration variable because Feather V1 does not support
+    % either Time32 or Time64 types.
+    t = removevars(t, "duration");
+end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 306ffa7debb2a..fadb1924a13c4 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -46,6 +46,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/string_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time32_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time64_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"

From 4586689ea9ed690f72104f052a7ab13c5e0af053 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 25 Aug 2023 16:25:43 -0400
Subject: [PATCH 241/749] GH-37345: [MATLAB] Add function handle to
 `fromMATLAB` static construction methods to `TypeTraits` classes (#37370)

### Rationale for this change

Each concrete `arrow.array.Array` subclass has an associated `fromMATLAB `static construction method. It would be helpful if the `TypeTraits` classes had access to these corresponding fromMATLAB methods.

This would involve adding a new property like `ArrayStaticConstructor` to the TypeTraits classes.

For example:

```matlab
>> arrow.type.traits.Int8Traits

ans =

  Int8Traits with properties:

       ArrayConstructor: @ arrow.array.Int8Array
         ArrayClassName: "arrow.array.Int8Array"
    ArrayProxyClassName: "arrow.array.proxy.Int8Array"
 ArrayStaticConstructor: @ arrow.array.Int8Array.fromMATLAB
        TypeConstructor: @ arrow.type.Int8Type
          TypeClassName: "arrow.type.Int8Type"
     TypeProxyClassName: "arrow.type.proxy.Int8Type"
      MatlabConstructor: @ int8
        MatlabClassName: "int8"
```
### What changes are included in this PR?

1. Added a new abstract property called `ArrayStaticConstructor` to the parent class `arrow.type.traits.TypeTraits`.
2. Defined the `ArrayStaticConstructor` property in all concrete classes of `ArrayStaticConstructor`.

### Are these changes tested?

Yes. Added a new test case to abstract test class `hTypeTraits.m`.

### Are there any user-facing changes?

No.

* Closes: #37345

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+type/+traits/BooleanTraits.m   | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Float32Traits.m   | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Float64Traits.m   | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Int16Traits.m     | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Int32Traits.m     | 1 +
 matlab/src/matlab/+arrow/+type/+traits/Int64Traits.m     | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Int8Traits.m      | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/StringTraits.m    | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m    | 1 +
 matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m    | 1 +
 matlab/src/matlab/+arrow/+type/+traits/TimestampTraits.m | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/TypeTraits.m      | 1 +
 matlab/src/matlab/+arrow/+type/+traits/UInt16Traits.m    | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/UInt32Traits.m    | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/UInt64Traits.m    | 3 ++-
 matlab/src/matlab/+arrow/+type/+traits/UInt8Traits.m     | 3 ++-
 matlab/test/arrow/type/traits/hTypeTraits.m              | 5 +++++
 matlab/test/arrow/type/traits/tBooleanTraits.m           | 1 +
 matlab/test/arrow/type/traits/tInt16Traits.m             | 1 +
 matlab/test/arrow/type/traits/tInt32Traits.m             | 1 +
 matlab/test/arrow/type/traits/tInt64Traits.m             | 1 +
 matlab/test/arrow/type/traits/tInt8Traits.m              | 1 +
 matlab/test/arrow/type/traits/tStringTraits.m            | 1 +
 matlab/test/arrow/type/traits/tTime32Traits.m            | 1 +
 matlab/test/arrow/type/traits/tTime64Traits.m            | 1 +
 matlab/test/arrow/type/traits/tTimestampTraits.m         | 1 +
 matlab/test/arrow/type/traits/tUInt16Traits.m            | 1 +
 matlab/test/arrow/type/traits/tUInt32Traits.m            | 1 +
 matlab/test/arrow/type/traits/tUInt64Traits.m            | 1 +
 matlab/test/arrow/type/traits/tUInt8Traits.m             | 1 +
 30 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+type/+traits/BooleanTraits.m b/matlab/src/matlab/+arrow/+type/+traits/BooleanTraits.m
index 82a8b6b1e28ba..76d4c5ac929ed 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/BooleanTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/BooleanTraits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.BooleanArray
         ArrayClassName = "arrow.array.BooleanArray"
         ArrayProxyClassName = "arrow.array.proxy.BooleanArray"
-        TypeConstructor = @arrow.type.BooleanType;
+        ArrayStaticConstructor = @arrow.array.BooleanArray.fromMATLAB
+        TypeConstructor = @arrow.type.BooleanType
         TypeClassName = "arrow.type.BooleanType"
         TypeProxyClassName = "arrow.type.proxy.BooleanType"
         MatlabConstructor = @logical
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Float32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Float32Traits.m
index 7dc0d17474e2f..cbf78e3eaa17d 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Float32Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Float32Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.Float32Array
         ArrayClassName = "arrow.array.Float32Array"
         ArrayProxyClassName = "arrow.array.proxy.Float32Array"
-        TypeConstructor = @arrow.type.Float32Type;
+        ArrayStaticConstructor = @arrow.array.Float32Array.fromMATLAB
+        TypeConstructor = @arrow.type.Float32Type
         TypeClassName = "arrow.type.Float32Type"
         TypeProxyClassName = "arrow.type.proxy.Float32Type"
         MatlabConstructor = @single
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Float64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Float64Traits.m
index 9c52634b2c942..387ed27639930 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Float64Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Float64Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.Float64Array
         ArrayClassName = "arrow.array.Float64Array"
         ArrayProxyClassName = "arrow.array.proxy.Float64Array"
-        TypeConstructor = @arrow.type.Float64Type;
+        ArrayStaticConstructor = @arrow.array.Float64Array.fromMATLAB
+        TypeConstructor = @arrow.type.Float64Type
         TypeClassName = "arrow.type.Float64Type"
         TypeProxyClassName = "arrow.type.proxy.Float64Type"
         MatlabConstructor = @double
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Int16Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Int16Traits.m
index 46b67b43c1783..04d7f8a2e5c46 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Int16Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Int16Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.Int16Array
         ArrayClassName = "arrow.array.Int16Array"
         ArrayProxyClassName = "arrow.array.proxy.Int16Array"
-        TypeConstructor = @arrow.type.Int16Type;
+        ArrayStaticConstructor = @arrow.array.Int16Array.fromMATLAB
+        TypeConstructor = @arrow.type.Int16Type
         TypeClassName = "arrow.type.Int16Type"
         TypeProxyClassName = "arrow.type.proxy.Int16Type"
         MatlabConstructor = @int16
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Int32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Int32Traits.m
index 4117271e50ff1..2edfc305c3694 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Int32Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Int32Traits.m
@@ -19,6 +19,7 @@
         ArrayConstructor = @arrow.array.Int32Array
         ArrayClassName = "arrow.array.Int32Array"
         ArrayProxyClassName = "arrow.array.proxy.Int32Array"
+        ArrayStaticConstructor = @arrow.array.Int32Array.fromMATLAB
         TypeConstructor = @arrow.type.Int32Type;
         TypeClassName = "arrow.type.Int32Type"
         TypeProxyClassName = "arrow.type.proxy.Int32Type"
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Int64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Int64Traits.m
index e25da953aa0fc..889087b02d966 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Int64Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Int64Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.Int64Array
         ArrayClassName = "arrow.array.Int64Array"
         ArrayProxyClassName = "arrow.array.proxy.Int64Array"
-        TypeConstructor = @arrow.type.Int64Type;
+        ArrayStaticConstructor = @arrow.array.Int64Array.fromMATLAB
+        TypeConstructor = @arrow.type.Int64Type
         TypeClassName = "arrow.type.Int64Type"
         TypeProxyClassName = "arrow.type.proxy.Int64Type"
         MatlabConstructor = @int64
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Int8Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Int8Traits.m
index 9f73bd2667e1b..e2040ae652863 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Int8Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Int8Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.Int8Array
         ArrayClassName = "arrow.array.Int8Array"
         ArrayProxyClassName = "arrow.array.proxy.Int8Array"
-        TypeConstructor = @arrow.type.Int8Type;
+        ArrayStaticConstructor = @arrow.array.Int8Array.fromMATLAB
+        TypeConstructor = @arrow.type.Int8Type
         TypeClassName = "arrow.type.Int8Type"
         TypeProxyClassName = "arrow.type.proxy.Int8Type"
         MatlabConstructor = @int8
diff --git a/matlab/src/matlab/+arrow/+type/+traits/StringTraits.m b/matlab/src/matlab/+arrow/+type/+traits/StringTraits.m
index 0730657270129..ce2fdf97c8886 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/StringTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/StringTraits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.StringArray
         ArrayClassName = "arrow.array.StringArray"
         ArrayProxyClassName = "arrow.array.proxy.StringArray"
-        TypeConstructor = @arrow.type.StringType;
+        ArrayStaticConstructor = @arrow.array.StringArray.fromMATLAB
+        TypeConstructor = @arrow.type.StringType
         TypeClassName = "arrow.type.StringType"
         TypeProxyClassName = "arrow.type.proxy.StringType"
         MatlabConstructor = @string
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
index 844740167c380..e665800c46c9d 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Time32Traits.m
@@ -19,6 +19,7 @@
         ArrayConstructor = @arrow.array.Time32Array
         ArrayClassName = "arrow.array.Time32Array"
         ArrayProxyClassName = "arrow.array.proxy.Time32Array"
+        ArrayStaticConstructor = @arrow.array.Time32Array.fromMATLAB
         TypeConstructor = @arrow.type.Time32Type;
         TypeClassName = "arrow.type.Time32Type"
         TypeProxyClassName = "arrow.type.proxy.Time32Type"
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
index f9108d6ac3879..7f46f3e4db464 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/Time64Traits.m
@@ -19,6 +19,7 @@
         ArrayConstructor = @arrow.array.Time64Array
         ArrayClassName = "arrow.array.Time64Array"
         ArrayProxyClassName = "arrow.array.proxy.Time64Array"
+        ArrayStaticConstructor = @arrow.array.Time64Array.fromMATLAB
         TypeConstructor = @arrow.type.Time64Type;
         TypeClassName = "arrow.type.Time64Type"
         TypeProxyClassName = "arrow.type.proxy.Time64Type"
diff --git a/matlab/src/matlab/+arrow/+type/+traits/TimestampTraits.m b/matlab/src/matlab/+arrow/+type/+traits/TimestampTraits.m
index 488a5e7314016..91fc7d263f7ae 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/TimestampTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/TimestampTraits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.TimestampArray
         ArrayClassName = "arrow.array.TimestampArray"
         ArrayProxyClassName = "arrow.array.proxy.TimestampArray"
-        TypeConstructor = @arrow.type.TimestampType;
+        ArrayStaticConstructor = @arrow.array.TimestampArray.fromMATLAB
+        TypeConstructor = @arrow.type.TimestampType
         TypeClassName = "arrow.type.TimestampType"
         TypeProxyClassName = "arrow.type.proxy.TimestampType"
         MatlabConstructor = @datetime
diff --git a/matlab/src/matlab/+arrow/+type/+traits/TypeTraits.m b/matlab/src/matlab/+arrow/+type/+traits/TypeTraits.m
index 54b8fc0a7709c..06380d6fe19f1 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/TypeTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/TypeTraits.m
@@ -19,6 +19,7 @@
         ArrayConstructor
         ArrayClassName
         ArrayProxyClassName
+        ArrayStaticConstructor
         TypeConstructor
         TypeClassName
         TypeProxyClassName
diff --git a/matlab/src/matlab/+arrow/+type/+traits/UInt16Traits.m b/matlab/src/matlab/+arrow/+type/+traits/UInt16Traits.m
index b90e6294ce0d8..039dac673d10e 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/UInt16Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/UInt16Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.UInt16Array
         ArrayClassName = "arrow.array.UInt16Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt16Array"
-        TypeConstructor = @arrow.type.UInt16Type;
+        ArrayStaticConstructor = @arrow.array.UInt16Array.fromMATLAB
+        TypeConstructor = @arrow.type.UInt16Type
         TypeClassName = "arrow.type.UInt16Type"
         TypeProxyClassName = "arrow.type.proxy.UInt16Type"
         MatlabConstructor = @uint16
diff --git a/matlab/src/matlab/+arrow/+type/+traits/UInt32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/UInt32Traits.m
index ff79bd9579a3b..5254054792252 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/UInt32Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/UInt32Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.UInt32Array
         ArrayClassName = "arrow.array.UInt32Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt32Array"
-        TypeConstructor = @arrow.type.UInt32Type;
+        ArrayStaticConstructor = @arrow.array.UInt32Array.fromMATLAB
+        TypeConstructor = @arrow.type.UInt32Type
         TypeClassName = "arrow.type.UInt32Type"
         TypeProxyClassName = "arrow.type.proxy.UInt32Type"
         MatlabConstructor = @uint32
diff --git a/matlab/src/matlab/+arrow/+type/+traits/UInt64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/UInt64Traits.m
index a6b0de37528a9..246ab4a7e954e 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/UInt64Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/UInt64Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.UInt64Array
         ArrayClassName = "arrow.array.UInt64Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt64Array"
-        TypeConstructor = @arrow.type.UInt64Type;
+        ArrayStaticConstructor = @arrow.array.UInt64Array.fromMATLAB
+        TypeConstructor = @arrow.type.UInt64Type
         TypeClassName = "arrow.type.UInt64Type"
         TypeProxyClassName = "arrow.type.proxy.UInt64Type"
         MatlabConstructor = @uint64
diff --git a/matlab/src/matlab/+arrow/+type/+traits/UInt8Traits.m b/matlab/src/matlab/+arrow/+type/+traits/UInt8Traits.m
index ff2377ff812c3..477fffd390bf3 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/UInt8Traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/UInt8Traits.m
@@ -19,7 +19,8 @@
         ArrayConstructor = @arrow.array.UInt8Array
         ArrayClassName = "arrow.array.UInt8Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt8Array"
-        TypeConstructor = @arrow.type.UInt8Type;
+        ArrayStaticConstructor = @arrow.array.UInt8Array.fromMATLAB
+        TypeConstructor = @arrow.type.UInt8Type
         TypeClassName = "arrow.type.UInt8Type"
         TypeProxyClassName = "arrow.type.proxy.UInt8Type"
         MatlabConstructor = @uint8
diff --git a/matlab/test/arrow/type/traits/hTypeTraits.m b/matlab/test/arrow/type/traits/hTypeTraits.m
index df62fdd325f2f..7e6d2e34f1649 100644
--- a/matlab/test/arrow/type/traits/hTypeTraits.m
+++ b/matlab/test/arrow/type/traits/hTypeTraits.m
@@ -22,6 +22,7 @@
         ArrayConstructor
         ArrayClassName
         ArrayProxyClassName
+        ArrayStaticConstructor
         TypeConstructor
         TypeClassName
         TypeProxyClassName
@@ -53,6 +54,10 @@ function TestArrayProxyClassName(testCase)
             testCase.verifyEqual(testCase.Traits.ArrayProxyClassName, testCase.ArrayProxyClassName);
         end
 
+        function TestArrayStaticConstructor(testCase)
+            testCase.verifyEqual(testCase.Traits.ArrayStaticConstructor, testCase.ArrayStaticConstructor);
+        end
+
         function TestTypeConstructor(testCase)
             testCase.verifyEqual(testCase.Traits.TypeConstructor, testCase.TypeConstructor);
         end
diff --git a/matlab/test/arrow/type/traits/tBooleanTraits.m b/matlab/test/arrow/type/traits/tBooleanTraits.m
index 859dc630a1fc7..0fc8ad6478a0a 100644
--- a/matlab/test/arrow/type/traits/tBooleanTraits.m
+++ b/matlab/test/arrow/type/traits/tBooleanTraits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.BooleanArray
         ArrayClassName = "arrow.array.BooleanArray"
         ArrayProxyClassName = "arrow.array.proxy.BooleanArray"
+        ArrayStaticConstructor = @arrow.array.BooleanArray.fromMATLAB
         TypeConstructor = @arrow.type.BooleanType
         TypeClassName = "arrow.type.BooleanType"
         TypeProxyClassName = "arrow.type.proxy.BooleanType"
diff --git a/matlab/test/arrow/type/traits/tInt16Traits.m b/matlab/test/arrow/type/traits/tInt16Traits.m
index bde308d28e68a..7015e45075ef2 100644
--- a/matlab/test/arrow/type/traits/tInt16Traits.m
+++ b/matlab/test/arrow/type/traits/tInt16Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.Int16Array
         ArrayClassName = "arrow.array.Int16Array"
         ArrayProxyClassName = "arrow.array.proxy.Int16Array"
+        ArrayStaticConstructor = @arrow.array.Int16Array.fromMATLAB
         TypeConstructor = @arrow.type.Int16Type
         TypeClassName = "arrow.type.Int16Type"
         TypeProxyClassName = "arrow.type.proxy.Int16Type"
diff --git a/matlab/test/arrow/type/traits/tInt32Traits.m b/matlab/test/arrow/type/traits/tInt32Traits.m
index 651f647455408..f8ea16b2d09a9 100644
--- a/matlab/test/arrow/type/traits/tInt32Traits.m
+++ b/matlab/test/arrow/type/traits/tInt32Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.Int32Array
         ArrayClassName = "arrow.array.Int32Array"
         ArrayProxyClassName = "arrow.array.proxy.Int32Array"
+        ArrayStaticConstructor = @arrow.array.Int32Array.fromMATLAB
         TypeConstructor = @arrow.type.Int32Type
         TypeClassName = "arrow.type.Int32Type"
         TypeProxyClassName = "arrow.type.proxy.Int32Type"
diff --git a/matlab/test/arrow/type/traits/tInt64Traits.m b/matlab/test/arrow/type/traits/tInt64Traits.m
index 4f16c91eb4e09..149530476dd9a 100644
--- a/matlab/test/arrow/type/traits/tInt64Traits.m
+++ b/matlab/test/arrow/type/traits/tInt64Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.Int64Array
         ArrayClassName = "arrow.array.Int64Array"
         ArrayProxyClassName = "arrow.array.proxy.Int64Array"
+        ArrayStaticConstructor = @arrow.array.Int64Array.fromMATLAB
         TypeConstructor = @arrow.type.Int64Type
         TypeClassName = "arrow.type.Int64Type"
         TypeProxyClassName = "arrow.type.proxy.Int64Type"
diff --git a/matlab/test/arrow/type/traits/tInt8Traits.m b/matlab/test/arrow/type/traits/tInt8Traits.m
index 3e767abbebba4..17217487e2704 100644
--- a/matlab/test/arrow/type/traits/tInt8Traits.m
+++ b/matlab/test/arrow/type/traits/tInt8Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.Int8Array
         ArrayClassName = "arrow.array.Int8Array"
         ArrayProxyClassName = "arrow.array.proxy.Int8Array"
+        ArrayStaticConstructor = @arrow.array.Int8Array.fromMATLAB
         TypeConstructor = @arrow.type.Int8Type
         TypeClassName = "arrow.type.Int8Type"
         TypeProxyClassName = "arrow.type.proxy.Int8Type"
diff --git a/matlab/test/arrow/type/traits/tStringTraits.m b/matlab/test/arrow/type/traits/tStringTraits.m
index 68f061d1b031d..2f739c852e766 100644
--- a/matlab/test/arrow/type/traits/tStringTraits.m
+++ b/matlab/test/arrow/type/traits/tStringTraits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.StringArray
         ArrayClassName = "arrow.array.StringArray"
         ArrayProxyClassName = "arrow.array.proxy.StringArray"
+        ArrayStaticConstructor = @arrow.array.StringArray.fromMATLAB
         TypeConstructor = @arrow.type.StringType
         TypeClassName = "arrow.type.StringType"
         TypeProxyClassName = "arrow.type.proxy.StringType"
diff --git a/matlab/test/arrow/type/traits/tTime32Traits.m b/matlab/test/arrow/type/traits/tTime32Traits.m
index 52e00a901aa3f..4f455330a75ec 100644
--- a/matlab/test/arrow/type/traits/tTime32Traits.m
+++ b/matlab/test/arrow/type/traits/tTime32Traits.m
@@ -22,6 +22,7 @@
         ArrayConstructor = @arrow.array.Time32Array
         ArrayClassName = "arrow.array.Time32Array"
         ArrayProxyClassName = "arrow.array.proxy.Time32Array"
+        ArrayStaticConstructor = @arrow.array.Time32Array.fromMATLAB
         TypeConstructor = @arrow.type.Time32Type
         TypeClassName = "arrow.type.Time32Type"
         TypeProxyClassName = "arrow.type.proxy.Time32Type"
diff --git a/matlab/test/arrow/type/traits/tTime64Traits.m b/matlab/test/arrow/type/traits/tTime64Traits.m
index bc4e205b96c5d..80fb5ae8c006b 100644
--- a/matlab/test/arrow/type/traits/tTime64Traits.m
+++ b/matlab/test/arrow/type/traits/tTime64Traits.m
@@ -22,6 +22,7 @@
         ArrayConstructor = @arrow.array.Time64Array
         ArrayClassName = "arrow.array.Time64Array"
         ArrayProxyClassName = "arrow.array.proxy.Time64Array"
+        ArrayStaticConstructor = @arrow.array.Time64Array.fromMATLAB
         TypeConstructor = @arrow.type.Time64Type
         TypeClassName = "arrow.type.Time64Type"
         TypeProxyClassName = "arrow.type.proxy.Time64Type"
diff --git a/matlab/test/arrow/type/traits/tTimestampTraits.m b/matlab/test/arrow/type/traits/tTimestampTraits.m
index 5f451c0631465..561808ef03e45 100644
--- a/matlab/test/arrow/type/traits/tTimestampTraits.m
+++ b/matlab/test/arrow/type/traits/tTimestampTraits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.TimestampArray
         ArrayClassName = "arrow.array.TimestampArray"
         ArrayProxyClassName = "arrow.array.proxy.TimestampArray"
+        ArrayStaticConstructor = @arrow.array.TimestampArray.fromMATLAB
         TypeConstructor = @arrow.type.TimestampType
         TypeClassName = "arrow.type.TimestampType"
         TypeProxyClassName = "arrow.type.proxy.TimestampType"
diff --git a/matlab/test/arrow/type/traits/tUInt16Traits.m b/matlab/test/arrow/type/traits/tUInt16Traits.m
index 4a9eef6f2978d..9692d8ee85486 100644
--- a/matlab/test/arrow/type/traits/tUInt16Traits.m
+++ b/matlab/test/arrow/type/traits/tUInt16Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.UInt16Array
         ArrayClassName = "arrow.array.UInt16Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt16Array"
+        ArrayStaticConstructor = @arrow.array.UInt16Array.fromMATLAB
         TypeConstructor = @arrow.type.UInt16Type
         TypeClassName = "arrow.type.UInt16Type"
         TypeProxyClassName = "arrow.type.proxy.UInt16Type"
diff --git a/matlab/test/arrow/type/traits/tUInt32Traits.m b/matlab/test/arrow/type/traits/tUInt32Traits.m
index 227e42c4eb0ec..a14268e2ca1e9 100644
--- a/matlab/test/arrow/type/traits/tUInt32Traits.m
+++ b/matlab/test/arrow/type/traits/tUInt32Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.UInt32Array
         ArrayClassName = "arrow.array.UInt32Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt32Array"
+        ArrayStaticConstructor = @arrow.array.UInt32Array.fromMATLAB
         TypeConstructor = @arrow.type.UInt32Type
         TypeClassName = "arrow.type.UInt32Type"
         TypeProxyClassName = "arrow.type.proxy.UInt32Type"
diff --git a/matlab/test/arrow/type/traits/tUInt64Traits.m b/matlab/test/arrow/type/traits/tUInt64Traits.m
index 370e905f27736..f35899332c288 100644
--- a/matlab/test/arrow/type/traits/tUInt64Traits.m
+++ b/matlab/test/arrow/type/traits/tUInt64Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.UInt64Array
         ArrayClassName = "arrow.array.UInt64Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt64Array"
+        ArrayStaticConstructor = @arrow.array.UInt64Array.fromMATLAB
         TypeConstructor = @arrow.type.UInt64Type
         TypeClassName = "arrow.type.UInt64Type"
         TypeProxyClassName = "arrow.type.proxy.UInt64Type"
diff --git a/matlab/test/arrow/type/traits/tUInt8Traits.m b/matlab/test/arrow/type/traits/tUInt8Traits.m
index d93f9d3c1b942..af90df0633d3a 100644
--- a/matlab/test/arrow/type/traits/tUInt8Traits.m
+++ b/matlab/test/arrow/type/traits/tUInt8Traits.m
@@ -20,6 +20,7 @@
         ArrayConstructor = @arrow.array.UInt8Array
         ArrayClassName = "arrow.array.UInt8Array"
         ArrayProxyClassName = "arrow.array.proxy.UInt8Array"
+        ArrayStaticConstructor = @arrow.array.UInt8Array.fromMATLAB
         TypeConstructor = @arrow.type.UInt8Type
         TypeClassName = "arrow.type.UInt8Type"
         TypeProxyClassName = "arrow.type.proxy.UInt8Type"

From c9bfca5ec40d30b6ae974953e2f8b12690227be2 Mon Sep 17 00:00:00 2001
From: Dominik Moritz <domoritz@gmail.com>
Date: Fri, 25 Aug 2023 16:01:06 -0700
Subject: [PATCH 242/749] GH-37392: [JS] Remove lerna (#37393)

We only use learna for making releases and can easily replace it with a bash script.
* Closes: #37392

Authored-by: Dominik Moritz <domoritz@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/DEVELOP.md     |    4 -
 js/lerna.json     |   12 -
 js/npm-release.sh |    3 +-
 js/package.json   |    1 -
 js/yarn.lock      | 2636 ++-------------------------------------------
 5 files changed, 73 insertions(+), 2583 deletions(-)
 delete mode 100644 js/lerna.json

diff --git a/js/DEVELOP.md b/js/DEVELOP.md
index 4b963c03ccec7..81a30afe2a5f4 100644
--- a/js/DEVELOP.md
+++ b/js/DEVELOP.md
@@ -66,10 +66,6 @@ This argument configuration also applies to `clean` and `test` scripts.
 To run tests on the bundles, you need to build them first.
 To run tests directly on the sources without bundling, use the `src` target (e.g. `yarn test -t src`).
 
-* `yarn deploy`
-
-Uses [lerna](https://github.com/lerna/lerna) to publish each build target to npm with [conventional](https://conventionalcommits.org/) [changelogs](https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-cli).
-
 * `yarn doc`
 
 Compiles the documentation with [Typedoc](https://typedoc.org/). Use `yarn doc --watch` to automatically rebuild when the docs change.
diff --git a/js/lerna.json b/js/lerna.json
deleted file mode 100644
index 99d6f64fbd4d0..0000000000000
--- a/js/lerna.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "lerna": "3.22.1",
-  "version": "4.0.0",
-  "npmClient": "yarn",
-  "packages": [
-    "targets/ts",
-    "targets/es5/*",
-    "targets/es2015/*",
-    "targets/esnext/*",
-    "targets/apache-arrow"
-  ]
-}
diff --git a/js/npm-release.sh b/js/npm-release.sh
index 5d92d01cb0a93..cff5945756e1c 100755
--- a/js/npm-release.sh
+++ b/js/npm-release.sh
@@ -25,4 +25,5 @@ yarn gulp
 read -p "Please enter your npm 2FA one-time password (or leave empty if you don't have 2FA enabled): " NPM_OTP </dev/tty
 
 # publish the JS target modules to npm
-yarn lerna exec --concurrency 1 --no-bail "npm publish${NPM_OTP:+ --otp=$NPM_OTP}"
+find targets -type f -name package.json -execdir sh -c \
+  "npm publish \$(dirname \$(realpath {})) ${NPM_OTP:+ --otp=$NPM_OTP}" \;
diff --git a/js/package.json b/js/package.json
index d072e9b373bbb..deb107d727689 100644
--- a/js/package.json
+++ b/js/package.json
@@ -99,7 +99,6 @@
     "ix": "5.0.0",
     "jest": "29.6.2",
     "jest-silent-reporter": "0.5.0",
-    "lerna": "7.0.0",
     "memfs": "4.2.1",
     "mkdirp": "3.0.1",
     "multistream": "4.1.0",
diff --git a/js/yarn.lock b/js/yarn.lock
index 99aa2dbf6db3e..0d0a50933598f 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -605,11 +605,6 @@
   resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.42.0.tgz#484a1d638de2911e6f5a30c12f49c7e4a3270fb6"
   integrity sha512-6SWlXpWU5AvId8Ac7zjzmIOqMOba/JWY8XZ4A7q7Gn1Vlfg/SFFIlrtHXt9nPn4op9ZPAkl91Jao+QQv3r/ukw==
 
-"@gar/promisify@^1.1.3":
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/@gar/promisify/-/promisify-1.1.3.tgz#555193ab2e3bb3b6adc3d551c9c030d9e860daf6"
-  integrity sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==
-
 "@gulp-sourcemaps/identity-map@^2.0.1":
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/@gulp-sourcemaps/identity-map/-/identity-map-2.0.1.tgz#a6e8b1abec8f790ec6be2b8c500e6e68037c0019"
@@ -648,11 +643,6 @@
   resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
   integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
 
-"@hutson/parse-repository-url@^3.0.0":
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/@hutson/parse-repository-url/-/parse-repository-url-3.0.2.tgz#98c23c950a3d9b6c8f0daed06da6c3af06981340"
-  integrity sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==
-
 "@isaacs/cliui@^8.0.2":
   version "8.0.2"
   resolved "https://registry.yarnpkg.com/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550"
@@ -950,34 +940,6 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
-"@lerna/child-process@7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@lerna/child-process/-/child-process-7.0.0.tgz#f3b7c04182d5fc05299116f2155a0882a25ee000"
-  integrity sha512-aY1Lvu8yA/TuyoNJmVyTBMuzj06LYy9OkfAUA2/YcTuFj3To1v0m0ImnKt+cCj6iEhEeZiW/qo98zFsyjleh6Q==
-  dependencies:
-    chalk "^4.1.0"
-    execa "^5.0.0"
-    strong-log-transformer "^2.1.0"
-
-"@lerna/create@7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@lerna/create/-/create-7.0.0.tgz#f89d8401f53235d3d61baf4f7fb0034bdff45d89"
-  integrity sha512-GcfZi0Ix+rcqC+LQyZyQ+BFuC8VxBnTJO14ENIwE4Yv2C1VJzCSqKrKtYeDFBQ9qpKadUoEH1ojSHQGTJZmBPw==
-  dependencies:
-    "@lerna/child-process" "7.0.0"
-    dedent "0.7.0"
-    fs-extra "^11.1.1"
-    init-package-json "5.0.0"
-    npm-package-arg "8.1.1"
-    p-reduce "^2.1.0"
-    pacote "^15.2.0"
-    pify "5.0.0"
-    semver "^7.3.4"
-    slash "^3.0.0"
-    validate-npm-package-license "^3.0.4"
-    validate-npm-package-name "5.0.0"
-    yargs-parser "20.2.4"
-
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
   resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
@@ -999,272 +961,11 @@
     "@nodelib/fs.scandir" "2.1.5"
     fastq "^1.6.0"
 
-"@npmcli/fs@^2.1.0":
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/@npmcli/fs/-/fs-2.1.2.tgz#a9e2541a4a2fec2e69c29b35e6060973da79b865"
-  integrity sha512-yOJKRvohFOaLqipNtwYB9WugyZKhC/DZC4VYPmpaCzDBrA8YpK3qHZ8/HGscMnE4GqbkLNuVcCnxkeQEdGt6LQ==
-  dependencies:
-    "@gar/promisify" "^1.1.3"
-    semver "^7.3.5"
-
-"@npmcli/fs@^3.1.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@npmcli/fs/-/fs-3.1.0.tgz#233d43a25a91d68c3a863ba0da6a3f00924a173e"
-  integrity sha512-7kZUAaLscfgbwBQRbvdMYaZOWyMEcPTH/tJjnyAWJ/dvvs9Ef+CERx/qJb9GExJpl1qipaDGn7KqHnFGGixd0w==
-  dependencies:
-    semver "^7.3.5"
-
-"@npmcli/git@^4.0.0":
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/@npmcli/git/-/git-4.1.0.tgz#ab0ad3fd82bc4d8c1351b6c62f0fa56e8fe6afa6"
-  integrity sha512-9hwoB3gStVfa0N31ymBmrX+GuDGdVA/QWShZVqE0HK2Af+7QGGrCTbZia/SW0ImUTjTne7SP91qxDmtXvDHRPQ==
-  dependencies:
-    "@npmcli/promise-spawn" "^6.0.0"
-    lru-cache "^7.4.4"
-    npm-pick-manifest "^8.0.0"
-    proc-log "^3.0.0"
-    promise-inflight "^1.0.1"
-    promise-retry "^2.0.1"
-    semver "^7.3.5"
-    which "^3.0.0"
-
-"@npmcli/installed-package-contents@^2.0.1":
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/@npmcli/installed-package-contents/-/installed-package-contents-2.0.2.tgz#bfd817eccd9e8df200919e73f57f9e3d9e4f9e33"
-  integrity sha512-xACzLPhnfD51GKvTOOuNX2/V4G4mz9/1I2MfDoye9kBM3RYe5g2YbscsaGoTlaWqkxeiapBWyseULVKpSVHtKQ==
-  dependencies:
-    npm-bundled "^3.0.0"
-    npm-normalize-package-bin "^3.0.0"
-
-"@npmcli/move-file@^2.0.0":
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@npmcli/move-file/-/move-file-2.0.1.tgz#26f6bdc379d87f75e55739bab89db525b06100e4"
-  integrity sha512-mJd2Z5TjYWq/ttPLLGqArdtnC74J6bOzg4rMDnN+p1xTacZ2yPRCk2y0oSWQtygLR9YVQXgOcONrwtnk3JupxQ==
-  dependencies:
-    mkdirp "^1.0.4"
-    rimraf "^3.0.2"
-
-"@npmcli/node-gyp@^3.0.0":
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@npmcli/node-gyp/-/node-gyp-3.0.0.tgz#101b2d0490ef1aa20ed460e4c0813f0db560545a"
-  integrity sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==
-
-"@npmcli/promise-spawn@^6.0.0", "@npmcli/promise-spawn@^6.0.1":
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/@npmcli/promise-spawn/-/promise-spawn-6.0.2.tgz#c8bc4fa2bd0f01cb979d8798ba038f314cfa70f2"
-  integrity sha512-gGq0NJkIGSwdbUt4yhdF8ZrmkGKVz9vAdVzpOfnom+V8PLSmSOVhZwbNvZZS1EYcJN5hzzKBxmmVVAInM6HQLg==
-  dependencies:
-    which "^3.0.0"
-
-"@npmcli/run-script@6.0.2", "@npmcli/run-script@^6.0.0":
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/@npmcli/run-script/-/run-script-6.0.2.tgz#a25452d45ee7f7fb8c16dfaf9624423c0c0eb885"
-  integrity sha512-NCcr1uQo1k5U+SYlnIrbAh3cxy+OQT1VtqiAbxdymSlptbzBb62AjH2xXgjNCoP073hoa1CfCAcwoZ8k96C4nA==
-  dependencies:
-    "@npmcli/node-gyp" "^3.0.0"
-    "@npmcli/promise-spawn" "^6.0.0"
-    node-gyp "^9.0.0"
-    read-package-json-fast "^3.0.0"
-    which "^3.0.0"
-
-"@nrwl/devkit@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nrwl/devkit/-/devkit-16.3.2.tgz#b45393dfd62dcb75554ff0c2dff6715a907e3877"
-  integrity sha512-EiDwVIvh6AcClXv22Q7auQh7Iy/ONISEFWzTswy/J6ZmVGCQesbiwg4cGV0MKiScr+awdVzqyNey+wD6IR5Lkw==
-  dependencies:
-    "@nx/devkit" "16.3.2"
-
-"@nrwl/tao@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nrwl/tao/-/tao-16.3.2.tgz#eefc1974342afbbe48e4e5351d6707ad2f9fb179"
-  integrity sha512-2Kg7dtv6JcQagCZPSq+okceI81NqmXGGgbKWqS7sOfdmp1otxS9uiUFNXw+Pdtnw38mdRviMtSOXScntu4sUKg==
-  dependencies:
-    nx "16.3.2"
-
-"@nx/devkit@16.3.2", "@nx/devkit@>=16.1.3 < 17":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/devkit/-/devkit-16.3.2.tgz#95d58d104449c54bdc276fa1c9166fcad867cfa8"
-  integrity sha512-1ev3EDm2Sx/ibziZroL1SheqxDR7UgC49tkBgJz1GrQLQnfdhBYroCPSyBSWGPMLHjIuHb3+hyGSV1Bz+BIYOA==
-  dependencies:
-    "@nrwl/devkit" "16.3.2"
-    ejs "^3.1.7"
-    ignore "^5.0.4"
-    semver "7.3.4"
-    tmp "~0.2.1"
-    tslib "^2.3.0"
-
-"@nx/nx-darwin-arm64@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-darwin-arm64/-/nx-darwin-arm64-16.3.2.tgz#83b6e78b27d2d7da8f7626560f52070c8735d28a"
-  integrity sha512-YfYVNfsJBzBcBnJUU4AcA6A4QMkgnVlETfp4KGL36Otq542mRY1ISGHdox63ocI5AKh5gay5AaGcR4wR9PU9Vg==
-
-"@nx/nx-darwin-x64@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-darwin-x64/-/nx-darwin-x64-16.3.2.tgz#0ae2a64356542c5fb73ca8038ce10ec4512e7fcb"
-  integrity sha512-bJtpozz0zSRVRrcQ76GrlT3TWEGTymLYWrVG51bH5KZ46t6/a4EQBI3uL3vubMmOZ0jR4ywybOcPBBhxmBJ68w==
-
-"@nx/nx-freebsd-x64@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-freebsd-x64/-/nx-freebsd-x64-16.3.2.tgz#202adf4d6070f47ed46450f006ecd50851147c74"
-  integrity sha512-ZvufI0bWqT67nLbBo6ejrIGxypdoedRQTP/tudWbs/4isvxLe1uVku1BfKCTQUsJG367SqNOU1H5kzI/MRr3ow==
-
-"@nx/nx-linux-arm-gnueabihf@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-linux-arm-gnueabihf/-/nx-linux-arm-gnueabihf-16.3.2.tgz#62314a82566e3647866b9dd4167a2d0e1397f001"
-  integrity sha512-IQL4kxdiZLvifar7+SIum3glRuVsxtE0dL8RvteSDXrxDQnaTUrjILC+VGhalRmk7ngBbGKNrhWOeeL7390CzQ==
-
-"@nx/nx-linux-arm64-gnu@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-linux-arm64-gnu/-/nx-linux-arm64-gnu-16.3.2.tgz#02826400aa55b8f44bac83332dd29647d0e95001"
-  integrity sha512-f6AWgPVu3mfUEoOBa0rY2/7QY0Or9eR0KtLFpcPh7RUpxPw2EXzIbjD/0RGipdpspSrgiMKbZpsUjo6mXBFsQA==
-
-"@nx/nx-linux-arm64-musl@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-linux-arm64-musl/-/nx-linux-arm64-musl-16.3.2.tgz#a0a81520e0904aa026a7ab0a8a3bf3facec9f14c"
-  integrity sha512-AvrWcYz7021E3b5P9/0i26p60XMZfw86Epks51L6AhlflarlOH4AcEChc7APMtb1ELAIbDWx2S6oIDRbQ7rtVA==
-
-"@nx/nx-linux-x64-gnu@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-linux-x64-gnu/-/nx-linux-x64-gnu-16.3.2.tgz#e79b5c142ec8d9bfb458ea5803bc4b62abbcf296"
-  integrity sha512-K2pWGAcbCNm6b7UZI9cc8z4Rb540QcuepBXD7akjPjWerzXriT6VCn4i9mVKsCg2mwSfknTJJVJ1PZwJSmTl/Q==
-
-"@nx/nx-linux-x64-musl@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-linux-x64-musl/-/nx-linux-x64-musl-16.3.2.tgz#900aee8f171638b9fb44378e2ac0548cb4aa99a7"
-  integrity sha512-sY1QDuQlqyYiRPJZanrtV07tU0DOXiCrWb0pDsGiO0qHuUSmW5Vw17GWEY4z3rt0/5U8fJ+/9WQrneviOmsOKg==
-
-"@nx/nx-win32-arm64-msvc@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-win32-arm64-msvc/-/nx-win32-arm64-msvc-16.3.2.tgz#88db772b3535648e147b1a0206b1a1fe875fa9a5"
-  integrity sha512-wBfohT2hjrLKn9WFHvG0MFVk7uYhgYNiptnTLdTouziHgFyZ08vyl7XYBq55BwHPMQ5iswVoEfjn/5ZBfCPscg==
-
-"@nx/nx-win32-x64-msvc@16.3.2":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/@nx/nx-win32-x64-msvc/-/nx-win32-x64-msvc-16.3.2.tgz#2195faaf1fc465c7a89bfdd62323fdd2a5d91f15"
-  integrity sha512-QC0sWrfQm0/WdvvM//7UAgm+otbak6bznZ0zawTeqmLBh1hLjNeweyzSVKQEtZtlzDMKpzCVuuwkJq+VKBLvmw==
-
-"@octokit/auth-token@^3.0.0":
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/@octokit/auth-token/-/auth-token-3.0.4.tgz#70e941ba742bdd2b49bdb7393e821dea8520a3db"
-  integrity sha512-TWFX7cZF2LXoCvdmJWY7XVPi74aSY0+FfBZNSXEXFkMpjcqsQwDSYVv5FhRFaI0V1ECnwbz4j59T/G+rXNWaIQ==
-
-"@octokit/core@^4.2.1":
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/@octokit/core/-/core-4.2.1.tgz#fee6341ad0ce60c29cc455e056cd5b500410a588"
-  integrity sha512-tEDxFx8E38zF3gT7sSMDrT1tGumDgsw5yPG6BBh/X+5ClIQfMH/Yqocxz1PnHx6CHyF6pxmovUTOfZAUvQ0Lvw==
-  dependencies:
-    "@octokit/auth-token" "^3.0.0"
-    "@octokit/graphql" "^5.0.0"
-    "@octokit/request" "^6.0.0"
-    "@octokit/request-error" "^3.0.0"
-    "@octokit/types" "^9.0.0"
-    before-after-hook "^2.2.0"
-    universal-user-agent "^6.0.0"
-
-"@octokit/endpoint@^7.0.0":
-  version "7.0.6"
-  resolved "https://registry.yarnpkg.com/@octokit/endpoint/-/endpoint-7.0.6.tgz#791f65d3937555141fb6c08f91d618a7d645f1e2"
-  integrity sha512-5L4fseVRUsDFGR00tMWD/Trdeeihn999rTMGRMC1G/Ldi1uWlWJzI98H4Iak5DB/RVvQuyMYKqSK/R6mbSOQyg==
-  dependencies:
-    "@octokit/types" "^9.0.0"
-    is-plain-object "^5.0.0"
-    universal-user-agent "^6.0.0"
-
-"@octokit/graphql@^5.0.0":
-  version "5.0.6"
-  resolved "https://registry.yarnpkg.com/@octokit/graphql/-/graphql-5.0.6.tgz#9eac411ac4353ccc5d3fca7d76736e6888c5d248"
-  integrity sha512-Fxyxdy/JH0MnIB5h+UQ3yCoh1FG4kWXfFKkpWqjZHw/p+Kc8Y44Hu/kCgNBT6nU1shNumEchmW/sUO1JuQnPcw==
-  dependencies:
-    "@octokit/request" "^6.0.0"
-    "@octokit/types" "^9.0.0"
-    universal-user-agent "^6.0.0"
-
-"@octokit/openapi-types@^18.0.0":
-  version "18.0.0"
-  resolved "https://registry.yarnpkg.com/@octokit/openapi-types/-/openapi-types-18.0.0.tgz#f43d765b3c7533fd6fb88f3f25df079c24fccf69"
-  integrity sha512-V8GImKs3TeQRxRtXFpG2wl19V7444NIOTDF24AWuIbmNaNYOQMWRbjcGDXV5B+0n887fgDcuMNOmlul+k+oJtw==
-
-"@octokit/plugin-enterprise-rest@6.0.1":
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/@octokit/plugin-enterprise-rest/-/plugin-enterprise-rest-6.0.1.tgz#e07896739618dab8da7d4077c658003775f95437"
-  integrity sha512-93uGjlhUD+iNg1iWhUENAtJata6w5nE+V4urXOAlIXdco6xNZtUSfYY8dzp3Udy74aqO/B5UZL80x/YMa5PKRw==
-
-"@octokit/plugin-paginate-rest@^6.1.2":
-  version "6.1.2"
-  resolved "https://registry.yarnpkg.com/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-6.1.2.tgz#f86456a7a1fe9e58fec6385a85cf1b34072341f8"
-  integrity sha512-qhrmtQeHU/IivxucOV1bbI/xZyC/iOBhclokv7Sut5vnejAIAEXVcGQeRpQlU39E0WwK9lNvJHphHri/DB6lbQ==
-  dependencies:
-    "@octokit/tsconfig" "^1.0.2"
-    "@octokit/types" "^9.2.3"
-
-"@octokit/plugin-request-log@^1.0.4":
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@octokit/plugin-request-log/-/plugin-request-log-1.0.4.tgz#5e50ed7083a613816b1e4a28aeec5fb7f1462e85"
-  integrity sha512-mLUsMkgP7K/cnFEw07kWqXGF5LKrOkD+lhCrKvPHXWDywAwuDUeDwWBpc69XK3pNX0uKiVt8g5z96PJ6z9xCFA==
-
-"@octokit/plugin-rest-endpoint-methods@^7.1.2":
-  version "7.2.1"
-  resolved "https://registry.yarnpkg.com/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-7.2.1.tgz#0e086930c8b4470b0eabaa7d68b67fd1b245bb3a"
-  integrity sha512-UmlNrrcF+AXxcxhZslTt1a/8aDxUKH0trrt/mJCxEPrWbW1ZEc+6xxcd5/n0iw3b+Xo8UBJQUKDr71+vNCBpRQ==
-  dependencies:
-    "@octokit/types" "^9.3.1"
-
-"@octokit/request-error@^3.0.0":
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/@octokit/request-error/-/request-error-3.0.3.tgz#ef3dd08b8e964e53e55d471acfe00baa892b9c69"
-  integrity sha512-crqw3V5Iy2uOU5Np+8M/YexTlT8zxCfI+qu+LxUB7SZpje4Qmx3mub5DfEKSO8Ylyk0aogi6TYdf6kxzh2BguQ==
-  dependencies:
-    "@octokit/types" "^9.0.0"
-    deprecation "^2.0.0"
-    once "^1.4.0"
-
-"@octokit/request@^6.0.0":
-  version "6.2.5"
-  resolved "https://registry.yarnpkg.com/@octokit/request/-/request-6.2.5.tgz#7beef1065042998f7455973ef3f818e7b84d6ec2"
-  integrity sha512-z83E8UIlPNaJUsXpjD8E0V5o/5f+vJJNbNcBwVZsX3/vC650U41cOkTLjq4PKk9BYonQGOnx7N17gvLyNjgGcQ==
-  dependencies:
-    "@octokit/endpoint" "^7.0.0"
-    "@octokit/request-error" "^3.0.0"
-    "@octokit/types" "^9.0.0"
-    is-plain-object "^5.0.0"
-    node-fetch "^2.6.7"
-    universal-user-agent "^6.0.0"
-
-"@octokit/rest@19.0.11":
-  version "19.0.11"
-  resolved "https://registry.yarnpkg.com/@octokit/rest/-/rest-19.0.11.tgz#2ae01634fed4bd1fca5b642767205ed3fd36177c"
-  integrity sha512-m2a9VhaP5/tUw8FwfnW2ICXlXpLPIqxtg3XcAiGMLj/Xhw3RSBfZ8le/466ktO1Gcjr8oXudGnHhxV1TXJgFxw==
-  dependencies:
-    "@octokit/core" "^4.2.1"
-    "@octokit/plugin-paginate-rest" "^6.1.2"
-    "@octokit/plugin-request-log" "^1.0.4"
-    "@octokit/plugin-rest-endpoint-methods" "^7.1.2"
-
-"@octokit/tsconfig@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@octokit/tsconfig/-/tsconfig-1.0.2.tgz#59b024d6f3c0ed82f00d08ead5b3750469125af7"
-  integrity sha512-I0vDR0rdtP8p2lGMzvsJzbhdOWy405HcGovrspJ8RRibHnyRgggUSNO5AIox5LmqiwmatHKYsvj6VGFHkqS7lA==
-
-"@octokit/types@^9.0.0", "@octokit/types@^9.2.3", "@octokit/types@^9.3.1":
-  version "9.3.1"
-  resolved "https://registry.yarnpkg.com/@octokit/types/-/types-9.3.1.tgz#9eb20390f8cfcc975635d813f9a2094efd4aa2dd"
-  integrity sha512-zfJzyXLHC42sWcn2kS+oZ/DRvFZBYCCbfInZtwp1Uopl1qh6pRg4NSP/wFX1xCOpXvEkctiG1sxlSlkZmzvxdw==
-  dependencies:
-    "@octokit/openapi-types" "^18.0.0"
-
 "@openpgp/web-stream-tools@0.0.13":
   version "0.0.13"
   resolved "https://registry.yarnpkg.com/@openpgp/web-stream-tools/-/web-stream-tools-0.0.13.tgz#f0be50120c152efb11b65df29ab482dc192dbbd7"
   integrity sha512-VQ0O0lUcD9ilLcMLQMJMgPhp8fDgMd4copd+UhSBGjud0vbI1ONQ3ffAhixEMml/AApLJtqCpd7PJcccPliFSA==
 
-"@parcel/watcher@2.0.4":
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@parcel/watcher/-/watcher-2.0.4.tgz#f300fef4cc38008ff4b8c29d92588eced3ce014b"
-  integrity sha512-cTDi+FUDBIUOBKEtj+nhiJ71AZVlkAsQFuGQTun5tV9mwQBQgZvhCzG+URPQc8myeN32yRVZEfVAPCs1RW+Jvg==
-  dependencies:
-    node-addon-api "^3.2.1"
-    node-gyp-build "^4.3.0"
-
 "@pkgjs/parseargs@^0.11.0":
   version "0.11.0"
   resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
@@ -1308,20 +1009,6 @@
   resolved "https://registry.yarnpkg.com/@rollup/stream/-/stream-3.0.0.tgz#8578177aa992e1e7d932d7b8b9ac302ce272663e"
   integrity sha512-rCctaa32QWDmbO/NyZPE3fKbpi4RHmR3N/mPvCYaig7ieSsDg4uSudKkIsaDHuLuYpvNII8kPwgXs1k077lAPg==
 
-"@sigstore/protobuf-specs@^0.1.0":
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/@sigstore/protobuf-specs/-/protobuf-specs-0.1.0.tgz#957cb64ea2f5ce527cc9cf02a096baeb0d2b99b4"
-  integrity sha512-a31EnjuIDSX8IXBUib3cYLDRlPMU36AWX4xS8ysLaNu4ZzUesDiPt83pgrW2X1YLMe5L2HbDyaKK5BrL4cNKaQ==
-
-"@sigstore/tuf@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@sigstore/tuf/-/tuf-1.0.0.tgz#13b69323e7bf8de458cd6c952c57acd1169772a5"
-  integrity sha512-bLzi9GeZgMCvjJeLUIfs8LJYCxrPRA8IXQkzUtaFKKVPTz0mucRyqFcV2U20yg9K+kYAD0YSitzGfRZCFLjdHQ==
-  dependencies:
-    "@sigstore/protobuf-specs" "^0.1.0"
-    make-fetch-happen "^11.0.1"
-    tuf-js "^1.1.3"
-
 "@sinclair/typebox@^0.27.8":
   version "0.27.8"
   resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
@@ -1341,11 +1028,6 @@
   dependencies:
     "@sinonjs/commons" "^3.0.0"
 
-"@tootallnate/once@2":
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-2.0.0.tgz#f544a148d3ab35801c1f633a7441fd87c2e484bf"
-  integrity sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==
-
 "@tsconfig/node10@^1.0.7":
   version "1.0.9"
   resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"
@@ -1366,19 +1048,6 @@
   resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
   integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
 
-"@tufjs/canonical-json@1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@tufjs/canonical-json/-/canonical-json-1.0.0.tgz#eade9fd1f537993bc1f0949f3aea276ecc4fab31"
-  integrity sha512-QTnf++uxunWvG2z3UFNzAoQPHxnSXOwtaI3iJ+AohhV+5vONuArPjJE7aPXPVXfXJsqrVbZBu9b81AJoSd09IQ==
-
-"@tufjs/models@1.0.4":
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@tufjs/models/-/models-1.0.4.tgz#5a689630f6b9dbda338d4b208019336562f176ef"
-  integrity sha512-qaGV9ltJP0EO25YfFUPhxRVK0evXFIAGicsVXuRim4Ed9cjPxYhNnNJ49SFmbeLgtxpslIkX317IgpfcHPVj/A==
-  dependencies:
-    "@tufjs/canonical-json" "1.0.0"
-    minimatch "^9.0.0"
-
 "@types/babel__core@^7.1.14":
   version "7.20.1"
   resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.20.1.tgz#916ecea274b0c776fec721e333e55762d3a9614b"
@@ -1500,17 +1169,12 @@
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.12.tgz#d70faba7039d5fca54c83c7dbab41051d2b6f6cb"
   integrity sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==
 
-"@types/minimatch@^3.0.3":
-  version "3.0.5"
-  resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.5.tgz#1001cc5e6a3704b83c236027e77f2f58ea010f40"
-  integrity sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ==
-
 "@types/minimatch@^5.1.2":
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-5.1.2.tgz#07508b45797cb81ec3f273011b054cd0755eddca"
   integrity sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==
 
-"@types/minimist@^1.2.0", "@types/minimist@^1.2.2":
+"@types/minimist@^1.2.2":
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
   integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
@@ -1797,39 +1461,6 @@
   resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
   integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
 
-"@yarnpkg/lockfile@^1.1.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz#e77a97fbd345b76d83245edcd17d393b1b41fb31"
-  integrity sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ==
-
-"@yarnpkg/parsers@^3.0.0-rc.18":
-  version "3.0.0-rc.45"
-  resolved "https://registry.yarnpkg.com/@yarnpkg/parsers/-/parsers-3.0.0-rc.45.tgz#fcc7d0ab7828afdb20d1e13160b1d117c07536f4"
-  integrity sha512-Aj0aHBV/crFQTpKQvL6k1xNiOhnlfVLu06LunelQAvl1MTeWrSi8LD9UJJDCFJiG4kx8NysUE6Tx0KZyPQUzIw==
-  dependencies:
-    js-yaml "^3.10.0"
-    tslib "^2.4.0"
-
-"@zkochan/js-yaml@0.0.6":
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/@zkochan/js-yaml/-/js-yaml-0.0.6.tgz#975f0b306e705e28b8068a07737fa46d3fc04826"
-  integrity sha512-nzvgl3VfhcELQ8LyVrYOru+UtAy1nrygk2+AGbTm8a5YcO6o8lSjAT+pfg3vJWxIoZKOUhrK6UU7xW/+00kQrg==
-  dependencies:
-    argparse "^2.0.1"
-
-JSONStream@^1.3.5:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
-  integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-abbrev@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
-  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
-
 acorn-import-assertions@^1.9.0:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz#507276249d684797c84e0734ef84860334cfb1ac"
@@ -1855,35 +1486,6 @@ acorn@^8.0.4, acorn@^8.4.1, acorn@^8.7.1, acorn@^8.8.0, acorn@^8.8.2:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a"
   integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
 
-add-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/add-stream/-/add-stream-1.0.0.tgz#6a7990437ca736d5e1288db92bd3266d5f5cb2aa"
-  integrity sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==
-
-agent-base@6, agent-base@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77"
-  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
-  dependencies:
-    debug "4"
-
-agentkeepalive@^4.2.1:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/agentkeepalive/-/agentkeepalive-4.3.0.tgz#bb999ff07412653c1803b3ced35e50729830a255"
-  integrity sha512-7Epl1Blf4Sy37j4v9f9FjICCh4+KAQOyXgHEwlyBiAQLbhKdq/i2QQU3amQalS/wPhdPzDXPL5DMR5bkn+YeWg==
-  dependencies:
-    debug "^4.1.0"
-    depd "^2.0.0"
-    humanize-ms "^1.2.1"
-
-aggregate-error@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
-  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
-  dependencies:
-    clean-stack "^2.0.0"
-    indent-string "^4.0.0"
-
 aggregate-error@^4.0.0:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-4.0.1.tgz#25091fe1573b9e0be892aeda15c7c66a545f758e"
@@ -1919,11 +1521,6 @@ ansi-colors@^3.0.5:
   resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.4.tgz#e3a3da4bfbae6c86a9c285625de124a234026fbf"
   integrity sha512-hHUXGagefjN2iRrID63xckIvotOXOojhQKWIPUZ4mNUZ9nLZW+7FMNoE1lOkEhNWYsx/7ysGIuJYCiMAA9FnrA==
 
-ansi-colors@^4.1.1:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b"
-  integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
-
 ansi-escapes@^4.2.1, ansi-escapes@^4.3.0:
   version "4.3.2"
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
@@ -2010,24 +1607,11 @@ append-buffer@^1.0.2:
   dependencies:
     buffer-equal "^1.0.0"
 
-"aproba@^1.0.3 || ^2.0.0":
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/aproba/-/aproba-2.0.0.tgz#52520b8ae5b569215b354efc0caa3fe1e45a8adc"
-  integrity sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==
-
 archy@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40"
   integrity sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==
 
-are-we-there-yet@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz#679df222b278c64f2cdba1175cdc00b0d96164bd"
-  integrity sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==
-  dependencies:
-    delegates "^1.0.0"
-    readable-stream "^3.6.0"
-
 arg@^4.1.0:
   version "4.1.3"
   resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
@@ -2089,21 +1673,11 @@ array-back@^6.2.2:
   resolved "https://registry.yarnpkg.com/array-back/-/array-back-6.2.2.tgz#f567d99e9af88a6d3d2f9dfcc21db6f9ba9fd157"
   integrity sha512-gUAZ7HPyb4SJczXAMUXMGAvI976JoK3qEx9v1FTmeYuJj0IBiaKttG1ydtGKdkfqWkIkouke7nG8ufGy77+Cvw==
 
-array-differ@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/array-differ/-/array-differ-3.0.0.tgz#3cbb3d0f316810eafcc47624734237d6aee4ae6b"
-  integrity sha512-THtfYS6KtME/yIAhKjZ2ul7XI96lQGHRputJQHO80LAWQnuGP4iCIN8vdMRboGbIEYBwU33q8Tch1os2+X0kMg==
-
 array-each@^1.0.0, array-each@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/array-each/-/array-each-1.0.1.tgz#a794af0c05ab1752846ee753a1f211a05ba0c44f"
   integrity sha512-zHjL5SZa68hkKHBFBK6DJCTtr9sfTCPCaph/L7tMSLcTFgy+zX7E+6q5UArbtOtMBCtxdICpfTCspRse+ywyXA==
 
-array-ify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
-  integrity sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==
-
 array-initial@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/array-initial/-/array-initial-1.1.0.tgz#2fa74b26739371c3947bd7a7adc73be334b3d795"
@@ -2148,11 +1722,6 @@ arrify@^1.0.1:
   resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==
 
-arrify@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-2.0.1.tgz#c9655e9331e0abcd588d2a7cad7e9956f66701fa"
-  integrity sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==
-
 asap@~2.0.6:
   version "2.0.6"
   resolved "https://registry.yarnpkg.com/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
@@ -2199,30 +1768,11 @@ async-settle@^1.0.0:
   dependencies:
     async-done "^1.2.2"
 
-async@^3.2.3:
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/async/-/async-3.2.4.tgz#2d22e00f8cddeb5fde5dd33522b56d1cf569a81c"
-  integrity sha512-iAB+JbDEGXhyIUavoDl9WP/Jj106Kz9DEn1DPgYw5ruDn0e3Wgi3sKFm55sASdGBNOQB8F59d9qQ7deqrHA8wQ==
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
-  integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==
-
 atob@^2.1.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
-axios@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-1.4.0.tgz#38a7bf1224cd308de271146038b551d725f0be1f"
-  integrity sha512-S4XCWMEmzvo64T9GfvQDOXgYRDJ/wsSZc7Jvdgx5u1sd0JwsuPLqb3SYmusag+edF6ziyMensPVqLTSc1PiSEA==
-  dependencies:
-    follow-redirects "^1.15.0"
-    form-data "^4.0.0"
-    proxy-from-env "^1.1.0"
-
 babel-jest@^29.6.2:
   version "29.6.2"
   resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-29.6.2.tgz#cada0a59e07f5acaeb11cbae7e3ba92aec9c1126"
@@ -2303,11 +1853,6 @@ balanced-match@^1.0.0:
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 
-base64-js@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
-  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
-
 base@^0.11.1:
   version "0.11.2"
   resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
@@ -2321,11 +1866,6 @@ base@^0.11.1:
     mixin-deep "^1.2.0"
     pascalcase "^0.1.1"
 
-before-after-hook@^2.2.0:
-  version "2.2.3"
-  resolved "https://registry.yarnpkg.com/before-after-hook/-/before-after-hook-2.2.3.tgz#c51e809c81a4e354084422b9b26bad88249c517c"
-  integrity sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==
-
 benchmark@^2.1.4:
   version "2.1.4"
   resolved "https://registry.yarnpkg.com/benchmark/-/benchmark-2.1.4.tgz#09f3de31c916425d498cc2ee565a0ebf3c2a5629"
@@ -2374,15 +1914,6 @@ bl@^1.2.1:
     readable-stream "^2.3.5"
     safe-buffer "^5.1.1"
 
-bl@^4.0.3, bl@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
-  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
-  dependencies:
-    buffer "^5.5.0"
-    inherits "^2.0.4"
-    readable-stream "^3.4.0"
-
 brace-expansion@^1.1.7:
   version "1.1.11"
   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
@@ -2455,78 +1986,11 @@ buffer-from@^1.0.0:
   resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
-buffer@^5.5.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
-  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.1.13"
-
 builtin-modules@^3.3.0:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.3.0.tgz#cae62812b89801e9656336e46223e030386be7b6"
   integrity sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==
 
-builtins@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/builtins/-/builtins-1.0.3.tgz#cb94faeb61c8696451db36534e1422f94f0aee88"
-  integrity sha512-uYBjakWipfaO/bXI7E8rq6kpwHRZK5cNYrUv2OzZSI/FvmdMyXJ2tG9dKcjEC5YHmHpUAwsargWIZNWdxb/bnQ==
-
-builtins@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/builtins/-/builtins-5.0.1.tgz#87f6db9ab0458be728564fa81d876d8d74552fa9"
-  integrity sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ==
-  dependencies:
-    semver "^7.0.0"
-
-byte-size@8.1.1:
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/byte-size/-/byte-size-8.1.1.tgz#3424608c62d59de5bfda05d31e0313c6174842ae"
-  integrity sha512-tUkzZWK0M/qdoLEqikxBWe4kumyuwjl3HO6zHTr4yEI23EojPtLYXdG1+AQY7MN0cGyNDvEaJ8wiYQm6P2bPxg==
-
-cacache@^16.1.0:
-  version "16.1.3"
-  resolved "https://registry.yarnpkg.com/cacache/-/cacache-16.1.3.tgz#a02b9f34ecfaf9a78c9f4bc16fceb94d5d67a38e"
-  integrity sha512-/+Emcj9DAXxX4cwlLmRI9c166RuL3w30zp4R7Joiv2cQTtTtA+jeuCAjH3ZlGnYS3tKENSrKhAzVVP9GVyzeYQ==
-  dependencies:
-    "@npmcli/fs" "^2.1.0"
-    "@npmcli/move-file" "^2.0.0"
-    chownr "^2.0.0"
-    fs-minipass "^2.1.0"
-    glob "^8.0.1"
-    infer-owner "^1.0.4"
-    lru-cache "^7.7.1"
-    minipass "^3.1.6"
-    minipass-collect "^1.0.2"
-    minipass-flush "^1.0.5"
-    minipass-pipeline "^1.2.4"
-    mkdirp "^1.0.4"
-    p-map "^4.0.0"
-    promise-inflight "^1.0.1"
-    rimraf "^3.0.2"
-    ssri "^9.0.0"
-    tar "^6.1.11"
-    unique-filename "^2.0.0"
-
-cacache@^17.0.0:
-  version "17.1.3"
-  resolved "https://registry.yarnpkg.com/cacache/-/cacache-17.1.3.tgz#c6ac23bec56516a7c0c52020fd48b4909d7c7044"
-  integrity sha512-jAdjGxmPxZh0IipMdR7fK/4sDSrHMLUV0+GvVUsjwyGNKHsh79kW/otg+GkbXwl6Uzvy9wsvHOX4nUoWldeZMg==
-  dependencies:
-    "@npmcli/fs" "^3.1.0"
-    fs-minipass "^3.0.0"
-    glob "^10.2.2"
-    lru-cache "^7.7.1"
-    minipass "^5.0.0"
-    minipass-collect "^1.0.2"
-    minipass-flush "^1.0.5"
-    minipass-pipeline "^1.2.4"
-    p-map "^4.0.0"
-    ssri "^10.0.0"
-    tar "^6.1.11"
-    unique-filename "^3.0.0"
-
 cache-base@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
@@ -2555,15 +2019,6 @@ callsites@^3.0.0:
   resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 
-camelcase-keys@^6.2.2:
-  version "6.2.2"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0"
-  integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==
-  dependencies:
-    camelcase "^5.3.1"
-    map-obj "^4.0.0"
-    quick-lru "^4.0.1"
-
 camelcase-keys@^7.0.0:
   version "7.0.2"
   resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-7.0.2.tgz#d048d8c69448745bb0de6fc4c1c52a30dfbe7252"
@@ -2601,15 +2056,7 @@ chalk-template@^0.4.0:
   dependencies:
     chalk "^4.1.2"
 
-chalk@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
-  integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-chalk@4.x, chalk@^4.0.0, chalk@^4.0.2, chalk@^4.1.0, chalk@^4.1.1, chalk@^4.1.2:
+chalk@4.x, chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
@@ -2631,11 +2078,6 @@ char-regex@^1.0.2:
   resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
   integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==
 
-chardet@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
-  integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
-
 chokidar@^2.0.0:
   version "2.1.8"
   resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.1.8.tgz#804b3a7b6a99358c3c5c61e71d8728f041cff917"
@@ -2655,11 +2097,6 @@ chokidar@^2.0.0:
   optionalDependencies:
     fsevents "^1.2.7"
 
-chownr@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
-  integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
-
 chrome-trace-event@^1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
@@ -2670,7 +2107,7 @@ ci-info@^2.0.0:
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
   integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==
 
-ci-info@^3.2.0, ci-info@^3.6.1, ci-info@^3.8.0:
+ci-info@^3.2.0, ci-info@^3.8.0:
   version "3.8.0"
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.8.0.tgz#81408265a5380c929f0bc665d62256628ce9ef91"
   integrity sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==
@@ -2697,11 +2134,6 @@ clean-regexp@^1.0.0:
   dependencies:
     escape-string-regexp "^1.0.5"
 
-clean-stack@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
-  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
-
 clean-stack@^4.0.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-4.2.0.tgz#c464e4cde4ac789f4e0735c5d75beb49d7b30b31"
@@ -2709,28 +2141,13 @@ clean-stack@^4.0.0:
   dependencies:
     escape-string-regexp "5.0.0"
 
-cli-cursor@3.1.0, cli-cursor@^3.1.0:
+cli-cursor@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
   integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
   dependencies:
     restore-cursor "^3.1.0"
 
-cli-spinners@2.6.1:
-  version "2.6.1"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.6.1.tgz#adc954ebe281c37a6319bfa401e6dd2488ffb70d"
-  integrity sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==
-
-cli-spinners@^2.5.0:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.9.0.tgz#5881d0ad96381e117bbe07ad91f2008fe6ffd8db"
-  integrity sha512-4/aL9X3Wh0yiMQlE+eeRhWP6vclO3QRtw1JHKIT0FFUs5FjpFmESqtMvYZ0+lbzBw900b95mS0hohy+qn2VK/g==
-
-cli-width@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6"
-  integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==
-
 cliui@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
@@ -2740,15 +2157,6 @@ cliui@^3.2.0:
     strip-ansi "^3.0.1"
     wrap-ansi "^2.0.0"
 
-cliui@^7.0.2:
-  version "7.0.4"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
-  integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
-  dependencies:
-    string-width "^4.2.0"
-    strip-ansi "^6.0.0"
-    wrap-ansi "^7.0.0"
-
 cliui@^8.0.1:
   version "8.0.1"
   resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa"
@@ -2763,25 +2171,11 @@ clone-buffer@^1.0.0:
   resolved "https://registry.yarnpkg.com/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"
   integrity sha512-KLLTJWrvwIP+OPfMn0x2PheDEP20RPUcGXj/ERegTgdmPEZylALQldygiqrPPu8P45uNuPs7ckmReLY6v/iA5g==
 
-clone-deep@4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
-  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
-  dependencies:
-    is-plain-object "^2.0.4"
-    kind-of "^6.0.2"
-    shallow-clone "^3.0.0"
-
 clone-stats@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-1.0.0.tgz#b3782dff8bb5474e18b9b6bf0fdfe782f8777680"
   integrity sha512-au6ydSpg6nsrigcZ4m8Bc9hxjeW+GJ8xh5G3BJCMt4WXe1H10UNaVOamqQTmrx1kjVuxAHIQSNU6hY4Nsn9/ag==
 
-clone@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
-  integrity sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==
-
 clone@^2.1.1, clone@^2.1.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
@@ -2796,11 +2190,6 @@ cloneable-readable@^1.0.0:
     process-nextick-args "^2.0.0"
     readable-stream "^2.3.5"
 
-cmd-shim@6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/cmd-shim/-/cmd-shim-6.0.1.tgz#a65878080548e1dca760b3aea1e21ed05194da9d"
-  integrity sha512-S9iI9y0nKR4hwEQsVWpyxld/6kRfGepGfzff83FcaiEBpmvlbA2nnGe7Cylgrx2f/p1P5S5wpRm9oL8z1PbS3Q==
-
 co@^4.6.0:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
@@ -2862,21 +2251,6 @@ color-support@^1.1.3:
   resolved "https://registry.yarnpkg.com/color-support/-/color-support-1.1.3.tgz#93834379a1cc9a0c61f82f52f0d04322251bd5a2"
   integrity sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==
 
-columnify@1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/columnify/-/columnify-1.6.0.tgz#6989531713c9008bb29735e61e37acf5bd553cf3"
-  integrity sha512-lomjuFZKfM6MSAnV9aCZC9sc0qGbmZdfygNv+nCpqVkSKdCxCklLtd16O0EILGkImHw9ZpHkAnHaB+8Zxq5W6Q==
-  dependencies:
-    strip-ansi "^6.0.1"
-    wcwidth "^1.0.0"
-
-combined-stream@^1.0.8:
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
-  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
-  dependencies:
-    delayed-stream "~1.0.0"
-
 command-line-args@5.2.1, command-line-args@^5.2.1:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/command-line-args/-/command-line-args-5.2.1.tgz#c44c32e437a57d7c51157696893c5909e9cec42e"
@@ -2917,14 +2291,6 @@ common-tags@^1.8.0:
   resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6"
   integrity sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==
 
-compare-func@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3"
-  integrity sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==
-  dependencies:
-    array-ify "^1.0.0"
-    dot-prop "^5.1.0"
-
 component-emitter@^1.2.1:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
@@ -2945,94 +2311,6 @@ concat-stream@^1.6.0:
     readable-stream "^2.2.2"
     typedarray "^0.0.6"
 
-concat-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-2.0.0.tgz#414cf5af790a48c60ab9be4527d56d5e41133cb1"
-  integrity sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==
-  dependencies:
-    buffer-from "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.0.2"
-    typedarray "^0.0.6"
-
-console-control-strings@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
-  integrity sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==
-
-conventional-changelog-angular@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-6.0.0.tgz#a9a9494c28b7165889144fd5b91573c4aa9ca541"
-  integrity sha512-6qLgrBF4gueoC7AFVHu51nHL9pF9FRjXrH+ceVf7WmAfH3gs+gEYOkvxhjMPjZu57I4AGUGoNTY8V7Hrgf1uqg==
-  dependencies:
-    compare-func "^2.0.0"
-
-conventional-changelog-core@5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-5.0.1.tgz#3c331b155d5b9850f47b4760aeddfc983a92ad49"
-  integrity sha512-Rvi5pH+LvgsqGwZPZ3Cq/tz4ty7mjijhr3qR4m9IBXNbxGGYgTVVO+duXzz9aArmHxFtwZ+LRkrNIMDQzgoY4A==
-  dependencies:
-    add-stream "^1.0.0"
-    conventional-changelog-writer "^6.0.0"
-    conventional-commits-parser "^4.0.0"
-    dateformat "^3.0.3"
-    get-pkg-repo "^4.2.1"
-    git-raw-commits "^3.0.0"
-    git-remote-origin-url "^2.0.0"
-    git-semver-tags "^5.0.0"
-    normalize-package-data "^3.0.3"
-    read-pkg "^3.0.0"
-    read-pkg-up "^3.0.0"
-
-conventional-changelog-preset-loader@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-3.0.0.tgz#14975ef759d22515d6eabae6396c2ae721d4c105"
-  integrity sha512-qy9XbdSLmVnwnvzEisjxdDiLA4OmV3o8db+Zdg4WiFw14fP3B6XNz98X0swPPpkTd/pc1K7+adKgEDM1JCUMiA==
-
-conventional-changelog-writer@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-6.0.0.tgz#8c8dea0441c6e648c9b25bb784e750d02f8002d5"
-  integrity sha512-8PyWTnn7zBIt9l4hj4UusFs1TyG+9Ulu1zlOAc72L7Sdv9Hsc8E86ot7htY3HXCVhXHB/NO0pVGvZpwsyJvFfw==
-  dependencies:
-    conventional-commits-filter "^3.0.0"
-    dateformat "^3.0.3"
-    handlebars "^4.7.7"
-    json-stringify-safe "^5.0.1"
-    meow "^8.1.2"
-    semver "^6.3.0"
-    split "^1.0.1"
-
-conventional-commits-filter@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-3.0.0.tgz#bf1113266151dd64c49cd269e3eb7d71d7015ee2"
-  integrity sha512-1ymej8b5LouPx9Ox0Dw/qAO2dVdfpRFq28e5Y0jJEU8ZrLdy0vOSkkIInwmxErFGhg6SALro60ZrwYFVTUDo4Q==
-  dependencies:
-    lodash.ismatch "^4.4.0"
-    modify-values "^1.0.1"
-
-conventional-commits-parser@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-4.0.0.tgz#02ae1178a381304839bce7cea9da5f1b549ae505"
-  integrity sha512-WRv5j1FsVM5FISJkoYMR6tPk07fkKT0UodruX4je86V4owk451yjXAKzKAPOs9l7y59E2viHUS9eQ+dfUA9NSg==
-  dependencies:
-    JSONStream "^1.3.5"
-    is-text-path "^1.0.1"
-    meow "^8.1.2"
-    split2 "^3.2.2"
-
-conventional-recommended-bump@7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/conventional-recommended-bump/-/conventional-recommended-bump-7.0.1.tgz#ec01f6c7f5d0e2491c2d89488b0d757393392424"
-  integrity sha512-Ft79FF4SlOFvX4PkwFDRnaNiIVX7YbmqGU0RwccUaiGvgp3S0a8ipR2/Qxk31vclDNM+GSdJOVs2KrsUCjblVA==
-  dependencies:
-    concat-stream "^2.0.0"
-    conventional-changelog-preset-loader "^3.0.0"
-    conventional-commits-filter "^3.0.0"
-    conventional-commits-parser "^4.0.0"
-    git-raw-commits "^3.0.0"
-    git-semver-tags "^5.0.0"
-    meow "^8.1.2"
-
 convert-source-map@^1.0.0, convert-source-map@^1.5.0, convert-source-map@^1.6.0, convert-source-map@^1.7.0:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
@@ -3061,16 +2339,6 @@ core-util-is@~1.0.0:
   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
   integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
 
-cosmiconfig@^8.2.0:
-  version "8.2.0"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-8.2.0.tgz#f7d17c56a590856cd1e7cee98734dca272b0d8fd"
-  integrity sha512-3rTMnFJA1tCOPwRxtgF4wd7Ab2qvDbL8jX+3smjIbS4HlZBagTlpERbdN7iAbWlrfxE3M8c27kTwTawQ7st+OQ==
-  dependencies:
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-
 create-require@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
@@ -3109,16 +2377,6 @@ d@1, d@^1.0.1:
     es5-ext "^0.10.50"
     type "^1.0.1"
 
-dargs@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc"
-  integrity sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==
-
-dateformat@^3.0.3:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae"
-  integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==
-
 debug-fabulous@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/debug-fabulous/-/debug-fabulous-1.1.0.tgz#af8a08632465224ef4174a9f06308c3c2a1ebc8e"
@@ -3135,13 +2393,6 @@ debug@3.X:
   dependencies:
     ms "^2.1.1"
 
-debug@4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.3, debug@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
 debug@^2.2.0, debug@^2.3.3:
   version "2.6.9"
   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
@@ -3149,6 +2400,13 @@ debug@^2.2.0, debug@^2.3.3:
   dependencies:
     ms "2.0.0"
 
+debug@^4.1.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
+  version "4.3.4"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
+  dependencies:
+    ms "2.1.2"
+
 decamelize-keys@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8"
@@ -3172,11 +2430,6 @@ decode-uri-component@^0.2.0:
   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.2.tgz#e69dbe25d37941171dd540e024c444cd5188e1e9"
   integrity sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==
 
-dedent@0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
-  integrity sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==
-
 dedent@^1.0.0:
   version "1.5.1"
   resolved "https://registry.yarnpkg.com/dedent/-/dedent-1.5.1.tgz#4f3fc94c8b711e9bb2800d185cd6ad20f2a90aff"
@@ -3204,18 +2457,6 @@ default-resolution@^2.0.0:
   resolved "https://registry.yarnpkg.com/default-resolution/-/default-resolution-2.0.0.tgz#bcb82baa72ad79b426a76732f1a81ad6df26d684"
   integrity sha512-2xaP6GiwVwOEbXCGoJ4ufgC76m8cj805jrghScewJC2ZDsb9U0b4BIrba+xt/Uytyd0HvQ6+WymSRTfnYj59GQ==
 
-defaults@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/defaults/-/defaults-1.0.4.tgz#b0b02062c1e2aa62ff5d9528f0f98baa90978d7a"
-  integrity sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==
-  dependencies:
-    clone "^1.0.2"
-
-define-lazy-prop@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz#3f7ae421129bcaaac9bc74905c98a0009ec9ee7f"
-  integrity sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==
-
 define-properties@^1.1.4:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.0.tgz#52988570670c9eacedd8064f4a990f2405849bd5"
@@ -3268,36 +2509,11 @@ del@7.0.0, del@^7.0.0:
     rimraf "^3.0.2"
     slash "^4.0.0"
 
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
-  integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==
-
-delegates@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
-  integrity sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==
-
-depd@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
-  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
-
-deprecation@^2.0.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/deprecation/-/deprecation-2.3.1.tgz#6368cbdb40abf3373b525ac87e4a260c3a700919"
-  integrity sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==
-
 detect-file@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
   integrity sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==
 
-detect-indent@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d"
-  integrity sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==
-
 detect-newline@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2"
@@ -3332,19 +2548,7 @@ doctrine@^3.0.0:
   dependencies:
     esutils "^2.0.2"
 
-dot-prop@^5.1.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88"
-  integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==
-  dependencies:
-    is-obj "^2.0.0"
-
-dotenv@~10.0.0:
-  version "10.0.0"
-  resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-10.0.0.tgz#3d4227b8fb95f81096cdd2b66653fb2c7085ba81"
-  integrity sha512-rlBi9d8jpv9Sf1klPjNfFAuWDjKLwTIJJ/VxtoTwIR6hnZxcEOQCZg2oIL3MWBYw5GpUDKOEnND7LXTbIpQ03Q==
-
-duplexer@^0.1.1, duplexer@^0.1.2:
+duplexer@^0.1.2:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
   integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
@@ -3372,13 +2576,6 @@ eastasianwidth@^0.2.0:
   resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
   integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
-ejs@^3.1.7:
-  version "3.1.9"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-3.1.9.tgz#03c9e8777fe12686a9effcef22303ca3d8eeb361"
-  integrity sha512-rC+QVNMJWv+MtPgkt0y+0rVEIdbtxVADApW9JXrUVlzHetgcyczP/E7DJmWJ4fJCZF2cPcBk0laWO9ZHMG3DmQ==
-  dependencies:
-    jake "^10.8.5"
-
 electron-to-chromium@^1.4.411:
   version "1.4.427"
   resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.427.tgz#67e8069f7a864fc092fe2e09f196e68af5cb88a1"
@@ -3399,14 +2596,7 @@ emoji-regex@^9.2.2:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
-encoding@^0.1.13:
-  version "0.1.13"
-  resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.13.tgz#56574afdd791f54a8e9b2785c0582a2d26210fa9"
-  integrity sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==
-  dependencies:
-    iconv-lite "^0.6.2"
-
-end-of-stream@^1.0.0, end-of-stream@^1.1.0, end-of-stream@^1.4.1, end-of-stream@^1.4.4:
+end-of-stream@^1.0.0, end-of-stream@^1.1.0, end-of-stream@^1.4.4:
   version "1.4.4"
   resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
   integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
@@ -3421,28 +2611,6 @@ enhanced-resolve@^5.14.1:
     graceful-fs "^4.2.4"
     tapable "^2.2.0"
 
-enquirer@~2.3.6:
-  version "2.3.6"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
-  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
-  dependencies:
-    ansi-colors "^4.1.1"
-
-env-paths@^2.2.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2"
-  integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==
-
-envinfo@7.8.1:
-  version "7.8.1"
-  resolved "https://registry.yarnpkg.com/envinfo/-/envinfo-7.8.1.tgz#06377e3e5f4d379fea7ac592d5ad8927e0c4d475"
-  integrity sha512-/o+BXHmB7ocbHEAs6F2EnG0ogybVVUdkRunTT2glZU9XAaGmhqskrvKwqXuDfNjEO0LZKWdejEEpnq8aM0tOaw==
-
-err-code@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-2.0.3.tgz#23c2f3b756ffdfc608d30e27c9a941024807e7f9"
-  integrity sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==
-
 errno@^0.1.3:
   version "0.1.8"
   resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
@@ -3739,31 +2907,11 @@ event-emitter@^0.3.5:
     d "1"
     es5-ext "~0.10.14"
 
-eventemitter3@^4.0.4:
-  version "4.0.7"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
-  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
-
 events@^3.2.0:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
-execa@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-5.0.0.tgz#4029b0007998a841fbd1032e5f4de86a3c1e3376"
-  integrity sha512-ov6w/2LCiuyO4RLYGdpFGjkcs0wMTgGE8PrkTHikeUy5iJekXyPIKUjifk5CsE0pt7sMCrMZ3YNqoCj6idQOnQ==
-  dependencies:
-    cross-spawn "^7.0.3"
-    get-stream "^6.0.0"
-    human-signals "^2.1.0"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.1"
-    onetime "^5.1.2"
-    signal-exit "^3.0.3"
-    strip-final-newline "^2.0.0"
-
 execa@^5.0.0:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
@@ -3843,15 +2991,6 @@ extend@^3.0.0:
   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
-external-editor@^3.0.3:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495"
-  integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==
-  dependencies:
-    chardet "^0.7.0"
-    iconv-lite "^0.4.24"
-    tmp "^0.0.33"
-
 extglob@^2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
@@ -3886,17 +3025,6 @@ fast-fifo@^1.1.0:
   resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.2.0.tgz#2ee038da2468e8623066dee96958b0c1763aa55a"
   integrity sha512-NcvQXt7Cky1cNau15FWy64IjuO8X0JijhTBBrJj1YlxlDfRkJXNaK9RFUjwpfDPzMdv7wB38jr53l9tkNLxnWg==
 
-fast-glob@3.2.7:
-  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.7.tgz#fd6cb7a2d7e9aa7a7846111e85a196d6b2f766a1"
-  integrity sha512-rYGMRwip6lUMvYD3BTScMwT1HtAs2d71SMv66Vrxs0IekGZEjhM0pcMfjQPnknBt2zeCwQMEupiN02ZP4DiT1Q==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
 fast-glob@^3.2.11, fast-glob@^3.2.9:
   version "3.2.12"
   resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80"
@@ -3937,13 +3065,6 @@ fb-watchman@^2.0.0:
   dependencies:
     bser "2.1.1"
 
-figures@3.2.0, figures@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af"
-  integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==
-  dependencies:
-    escape-string-regexp "^1.0.5"
-
 file-entry-cache@^6.0.1:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
@@ -3956,13 +3077,6 @@ file-uri-to-path@1.0.0:
   resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
   integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
 
-filelist@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/filelist/-/filelist-1.0.4.tgz#f78978a1e944775ff9e62e744424f215e58352b5"
-  integrity sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==
-  dependencies:
-    minimatch "^5.0.1"
-
 filesize@^8.0.7:
   version "8.0.7"
   resolved "https://registry.yarnpkg.com/filesize/-/filesize-8.0.7.tgz#695e70d80f4e47012c132d57a059e80c6b580bd8"
@@ -4000,13 +3114,6 @@ find-up@^1.0.0:
     path-exists "^2.0.0"
     pinkie-promise "^2.0.0"
 
-find-up@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
-  integrity sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==
-  dependencies:
-    locate-path "^2.0.0"
-
 find-up@^4.0.0, find-up@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
@@ -4067,11 +3174,6 @@ flat-cache@^3.0.4:
     flatted "^3.1.0"
     rimraf "^3.0.2"
 
-flat@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
-  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
-
 flatbuffers@23.5.26:
   version "23.5.26"
   resolved "https://registry.yarnpkg.com/flatbuffers/-/flatbuffers-23.5.26.tgz#01358e272a61239f0faf3bfbe4e014f3ace9d746"
@@ -4090,11 +3192,6 @@ flush-write-stream@^1.0.2:
     inherits "^2.0.3"
     readable-stream "^2.3.6"
 
-follow-redirects@^1.15.0:
-  version "1.15.2"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.2.tgz#b460864144ba63f2681096f274c4e57026da2c13"
-  integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==
-
 for-in@^1.0.1, for-in@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
@@ -4115,15 +3212,6 @@ foreground-child@^3.1.0:
     cross-spawn "^7.0.0"
     signal-exit "^4.0.1"
 
-form-data@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452"
-  integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.8"
-    mime-types "^2.1.12"
-
 fragment-cache@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
@@ -4131,11 +3219,6 @@ fragment-cache@^0.2.1:
   dependencies:
     map-cache "^0.2.2"
 
-fs-constants@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
-  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
-
 fs-extra@^10.0.0:
   version "10.1.0"
   resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
@@ -4145,29 +3228,6 @@ fs-extra@^10.0.0:
     jsonfile "^6.0.1"
     universalify "^2.0.0"
 
-fs-extra@^11.1.0, fs-extra@^11.1.1:
-  version "11.1.1"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.1.1.tgz#da69f7c39f3b002378b0954bb6ae7efdc0876e2d"
-  integrity sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==
-  dependencies:
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-minipass@^2.0.0, fs-minipass@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-2.1.0.tgz#7f5036fdbf12c63c169190cbe4199c852271f9fb"
-  integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==
-  dependencies:
-    minipass "^3.0.0"
-
-fs-minipass@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-3.0.2.tgz#5b383858efa8c1eb8c33b39e994f7e8555b8b3a3"
-  integrity sha512-2GAfyfoaCDRrM6jaOS3UsBts8yJ55VioXdWcOL7dK9zdAuKT71+WBA4ifnNYqVjYv+4SsPxjK0JT4yIIn4cA/g==
-  dependencies:
-    minipass "^5.0.0"
-
 fs-mkdirp-stream@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz#0b7815fc3201c6a69e14db98ce098c16935259eb"
@@ -4199,20 +3259,6 @@ function-bind@^1.1.1:
   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
-gauge@^4.0.3:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/gauge/-/gauge-4.0.4.tgz#52ff0652f2bbf607a989793d53b751bef2328dce"
-  integrity sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==
-  dependencies:
-    aproba "^1.0.3 || ^2.0.0"
-    color-support "^1.1.3"
-    console-control-strings "^1.1.0"
-    has-unicode "^2.0.1"
-    signal-exit "^3.0.7"
-    string-width "^4.2.3"
-    strip-ansi "^6.0.1"
-    wide-align "^1.1.5"
-
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
   resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
@@ -4243,26 +3289,6 @@ get-package-type@^0.1.0:
   resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
   integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
 
-get-pkg-repo@^4.2.1:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-4.2.1.tgz#75973e1c8050c73f48190c52047c4cee3acbf385"
-  integrity sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==
-  dependencies:
-    "@hutson/parse-repository-url" "^3.0.0"
-    hosted-git-info "^4.0.0"
-    through2 "^2.0.0"
-    yargs "^16.2.0"
-
-get-port@5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/get-port/-/get-port-5.1.1.tgz#0469ed07563479de6efb986baf053dcd7d4e3193"
-  integrity sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==
-
-get-stream@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.0.tgz#3e0012cb6827319da2706e601a1583e8629a6718"
-  integrity sha512-A1B3Bh1UmL0bidM/YX2NsCOTnGJePL9rO/M+Mw3m9f2gUpfokS0hi5Eah0WSUEWZdZhIZtMjkIYS7mDfOqNHbg==
-
 get-stream@^6.0.0:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
@@ -4273,60 +3299,6 @@ get-value@^2.0.3, get-value@^2.0.6:
   resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
   integrity sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==
 
-git-raw-commits@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-3.0.0.tgz#5432f053a9744f67e8db03dbc48add81252cfdeb"
-  integrity sha512-b5OHmZ3vAgGrDn/X0kS+9qCfNKWe4K/jFnhwzVWWg0/k5eLa3060tZShrRg8Dja5kPc+YjS0Gc6y7cRr44Lpjw==
-  dependencies:
-    dargs "^7.0.0"
-    meow "^8.1.2"
-    split2 "^3.2.2"
-
-git-remote-origin-url@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f"
-  integrity sha512-eU+GGrZgccNJcsDH5LkXR3PB9M958hxc7sbA8DFJjrv9j4L2P/eZfKhM+QD6wyzpiv+b1BpK0XrYCxkovtjSLw==
-  dependencies:
-    gitconfiglocal "^1.0.0"
-    pify "^2.3.0"
-
-git-semver-tags@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-5.0.0.tgz#775ff55effae0b50b755448408de6cd56ce293e2"
-  integrity sha512-fZ+tmZ1O5aXW/T5nLzZLbxWAHdQTLLXalOECMNAmhoEQSfqZjtaeMjpsXH4C5qVhrICTkVQeQFujB1lKzIHljA==
-  dependencies:
-    meow "^8.1.2"
-    semver "^6.3.0"
-
-git-up@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/git-up/-/git-up-7.0.0.tgz#bace30786e36f56ea341b6f69adfd83286337467"
-  integrity sha512-ONdIrbBCFusq1Oy0sC71F5azx8bVkvtZtMJAsv+a6lz5YAmbNnLD6HAB4gptHZVLPR8S2/kVN6Gab7lryq5+lQ==
-  dependencies:
-    is-ssh "^1.4.0"
-    parse-url "^8.1.0"
-
-git-url-parse@13.1.0:
-  version "13.1.0"
-  resolved "https://registry.yarnpkg.com/git-url-parse/-/git-url-parse-13.1.0.tgz#07e136b5baa08d59fabdf0e33170de425adf07b4"
-  integrity sha512-5FvPJP/70WkIprlUZ33bm4UAaFdjcLkJLpWft1BeZKqwR0uhhNGoKwlUaPtVb4LxCSQ++erHapRak9kWGj+FCA==
-  dependencies:
-    git-up "^7.0.0"
-
-gitconfiglocal@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b"
-  integrity sha512-spLUXeTAVHxDtKsJc8FkFVgFtMdEN9qPGpL23VfSHx4fP4+Ds097IXLvymbnDH8FnmxX5Nr9bPw3A+AQ6mWEaQ==
-  dependencies:
-    ini "^1.3.2"
-
-glob-parent@5.1.2, glob-parent@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
 glob-parent@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
@@ -4335,6 +3307,13 @@ glob-parent@^3.1.0:
     is-glob "^3.1.0"
     path-dirname "^1.0.0"
 
+glob-parent@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
+  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
+  dependencies:
+    is-glob "^4.0.1"
+
 glob-parent@^6.0.2:
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
@@ -4376,7 +3355,7 @@ glob-watcher@^5.0.3:
     normalize-path "^3.0.0"
     object.defaults "^1.1.0"
 
-glob@10.2.7, glob@^10.2.2:
+glob@10.2.7:
   version "10.2.7"
   resolved "https://registry.yarnpkg.com/glob/-/glob-10.2.7.tgz#9dd2828cd5bc7bd861e7738d91e7113dda41d7d8"
   integrity sha512-jTKehsravOJo8IJxUGfZILnkvVJM/MOfHRs8QcXolVef2zNI9Tqyy5+SeuOAZd3upViEZQLyFpQhYiHLrMUNmA==
@@ -4387,18 +3366,6 @@ glob@10.2.7, glob@^10.2.2:
     minipass "^5.0.0 || ^6.0.2"
     path-scurry "^1.7.0"
 
-glob@7.1.4:
-  version "7.1.4"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.4.tgz#aa608a2f6c577ad357e1ae5a5c26d9a8d1969255"
-  integrity sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
 glob@^7.1.1, glob@^7.1.3, glob@^7.1.4:
   version "7.2.3"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
@@ -4411,27 +3378,6 @@ glob@^7.1.1, glob@^7.1.3, glob@^7.1.4:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^8.0.1:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-8.1.0.tgz#d388f656593ef708ee3e34640fdfb99a9fd1c33e"
-  integrity sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^5.0.1"
-    once "^1.3.0"
-
-glob@^9.2.0:
-  version "9.3.5"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-9.3.5.tgz#ca2ed8ca452781a3009685607fdf025a899dfe21"
-  integrity sha512-e1LleDykUz2Iu+MTYdkSsuWX8lvAjAcs0Xef0lNIu0S2wOAzuTxCJtcd9S3cijlwYF18EsU3rzb8jPVobxDh9Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    minimatch "^8.0.2"
-    minipass "^4.2.4"
-    path-scurry "^1.6.1"
-
 global-modules@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
@@ -4464,7 +3410,7 @@ globals@^13.19.0:
   dependencies:
     type-fest "^0.20.2"
 
-globby@11.1.0, globby@^11.1.0:
+globby@^11.1.0:
   version "11.1.0"
   resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
   integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
@@ -4529,7 +3475,7 @@ google-closure-compiler@20230502.0.0:
     google-closure-compiler-osx "^20230502.0.0"
     google-closure-compiler-windows "^20230502.0.0"
 
-graceful-fs@4.2.11, graceful-fs@^4.0.0, graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
+graceful-fs@^4.0.0, graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4, graceful-fs@^4.2.9:
   version "4.2.11"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
   integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
@@ -4677,18 +3623,6 @@ gzip-size@^6.0.0:
   dependencies:
     duplexer "^0.1.2"
 
-handlebars@^4.7.7:
-  version "4.7.7"
-  resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1"
-  integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==
-  dependencies:
-    minimist "^1.2.5"
-    neo-async "^2.6.0"
-    source-map "^0.6.1"
-    wordwrap "^1.0.0"
-  optionalDependencies:
-    uglify-js "^3.1.4"
-
 hard-rejection@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
@@ -4721,11 +3655,6 @@ has-symbols@^1.0.3:
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
   integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
 
-has-unicode@2.0.1, has-unicode@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
-  integrity sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==
-
 has-value@^0.3.1:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
@@ -4776,105 +3705,29 @@ hosted-git-info@^2.1.4:
   resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
   integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==
 
-hosted-git-info@^3.0.6:
-  version "3.0.8"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-3.0.8.tgz#6e35d4cc87af2c5f816e4cb9ce350ba87a3f370d"
-  integrity sha512-aXpmwoOhRBrw6X3j0h5RloK4x1OzsxMPyxqIHyNfSe2pypkVTZFpEiRoSipPEPlMrh0HW/XsjkJ5WgnCirpNUw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-hosted-git-info@^4.0.0, hosted-git-info@^4.0.1:
+hosted-git-info@^4.0.1:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
   integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
   dependencies:
     lru-cache "^6.0.0"
 
-hosted-git-info@^6.0.0:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-6.1.1.tgz#629442c7889a69c05de604d52996b74fe6f26d58"
-  integrity sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==
-  dependencies:
-    lru-cache "^7.5.1"
-
 html-escaper@^2.0.0:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
-http-cache-semantics@^4.1.0, http-cache-semantics@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz#abe02fcb2985460bf0323be664436ec3476a6d5a"
-  integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==
-
-http-proxy-agent@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz#5129800203520d434f142bc78ff3c170800f2b43"
-  integrity sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==
-  dependencies:
-    "@tootallnate/once" "2"
-    agent-base "6"
-    debug "4"
-
-https-proxy-agent@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6"
-  integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==
-  dependencies:
-    agent-base "6"
-    debug "4"
-
 human-signals@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
   integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
 
-humanize-ms@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/humanize-ms/-/humanize-ms-1.2.1.tgz#c46e3159a293f6b896da29316d8b6fe8bb79bbed"
-  integrity sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==
-  dependencies:
-    ms "^2.0.0"
-
 hyperdyperid@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/hyperdyperid/-/hyperdyperid-1.2.0.tgz#59668d323ada92228d2a869d3e474d5a33b69e6b"
   integrity sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==
 
-iconv-lite@^0.4.24:
-  version "0.4.24"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
-  integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3"
-
-iconv-lite@^0.6.2:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501"
-  integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3.0.0"
-
-ieee754@^1.1.13:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
-  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
-
-ignore-walk@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-5.0.1.tgz#5f199e23e1288f518d90358d461387788a154776"
-  integrity sha512-yemi4pMf51WKT7khInJqAvsIGzoqYXblnsz0ql8tM+yi1EKYTY1evX4NAbJrLL/Aanr2HyZeluqU+Oi7MGHokw==
-  dependencies:
-    minimatch "^5.0.1"
-
-ignore-walk@^6.0.0:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-6.0.3.tgz#0fcdb6decaccda35e308a7b0948645dd9523b7bb"
-  integrity sha512-C7FfFoTA+bI10qfeydT8aZbvr91vAEU+2W5BZUlzPec47oNb07SsOfwYrtxuvOYdUApPP/Qlh4DtAO51Ekk2QA==
-  dependencies:
-    minimatch "^9.0.0"
-
-ignore@^5.0.4, ignore@^5.2.0:
+ignore@^5.2.0:
   version "5.2.4"
   resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
   integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
@@ -4887,7 +3740,7 @@ import-fresh@^3.0.0, import-fresh@^3.2.1:
     parent-module "^1.0.0"
     resolve-from "^4.0.0"
 
-import-local@3.1.0, import-local@^3.0.2:
+import-local@^3.0.2:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.1.0.tgz#b4479df8a5fd44f6cdce24070675676063c95cb4"
   integrity sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==
@@ -4910,11 +3763,6 @@ indent-string@^5.0.0:
   resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-5.0.0.tgz#4fd2980fccaf8622d14c64d694f4cf33c81951a5"
   integrity sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==
 
-infer-owner@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/infer-owner/-/infer-owner-1.0.4.tgz#c4cefcaa8e51051c2a40ba2ce8a3d27295af9467"
-  integrity sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==
-
 inflight@^1.0.4:
   version "1.0.6"
   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
@@ -4928,45 +3776,11 @@ inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
-ini@^1.3.2, ini@^1.3.4, ini@^1.3.8:
+ini@^1.3.4:
   version "1.3.8"
   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
-init-package-json@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/init-package-json/-/init-package-json-5.0.0.tgz#030cf0ea9c84cfc1b0dc2e898b45d171393e4b40"
-  integrity sha512-kBhlSheBfYmq3e0L1ii+VKe3zBTLL5lDCDWR+f9dLmEGSB3MqLlMlsolubSsyI88Bg6EA+BIMlomAnQ1SwgQBw==
-  dependencies:
-    npm-package-arg "^10.0.0"
-    promzard "^1.0.0"
-    read "^2.0.0"
-    read-package-json "^6.0.0"
-    semver "^7.3.5"
-    validate-npm-package-license "^3.0.4"
-    validate-npm-package-name "^5.0.0"
-
-inquirer@^8.2.4:
-  version "8.2.5"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-8.2.5.tgz#d8654a7542c35a9b9e069d27e2df4858784d54f8"
-  integrity sha512-QAgPDQMEgrDssk1XiwwHoOGYF9BAbUcc1+j+FhEvaOt8/cKRqyLn0U5qA6F74fGhTMGxf92pOvPBeh29jQJDTQ==
-  dependencies:
-    ansi-escapes "^4.2.1"
-    chalk "^4.1.1"
-    cli-cursor "^3.1.0"
-    cli-width "^3.0.0"
-    external-editor "^3.0.3"
-    figures "^3.0.0"
-    lodash "^4.17.21"
-    mute-stream "0.0.8"
-    ora "^5.4.1"
-    run-async "^2.4.0"
-    rxjs "^7.5.5"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-    through "^2.3.6"
-    wrap-ansi "^7.0.0"
-
 interpret@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
@@ -4977,11 +3791,6 @@ invert-kv@^1.0.0:
   resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
   integrity sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==
 
-ip@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-2.0.0.tgz#4cf4ab182fee2314c75ede1276f8c80b479936da"
-  integrity sha512-WKa+XuLG1A1R0UWhl2+1XQSi+fZWMsYKffMZTTYsiZaUD8k2yDAj5atimTUD2TZkyCkNEeYE5NhFZmupOGtjYQ==
-
 is-absolute@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-absolute/-/is-absolute-1.0.0.tgz#395e1ae84b11f26ad1795e73c17378e48a301576"
@@ -5028,13 +3837,6 @@ is-builtin-module@^3.2.1:
   dependencies:
     builtin-modules "^3.3.0"
 
-is-ci@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-3.0.1.tgz#db6ecbed1bd659c43dac0f45661e7674103d1867"
-  integrity sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==
-  dependencies:
-    ci-info "^3.2.0"
-
 is-ci@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c"
@@ -5042,7 +3844,7 @@ is-ci@^2.0.0:
   dependencies:
     ci-info "^2.0.0"
 
-is-core-module@^2.11.0, is-core-module@^2.5.0, is-core-module@^2.8.1:
+is-core-module@^2.11.0, is-core-module@^2.5.0:
   version "2.12.1"
   resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.1.tgz#0c0b6885b6f80011c71541ce15c8d66cf5a4f9fd"
   integrity sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg==
@@ -5081,11 +3883,6 @@ is-descriptor@^1.0.0, is-descriptor@^1.0.2:
     is-data-descriptor "^1.0.0"
     kind-of "^6.0.2"
 
-is-docker@^2.0.0, is-docker@^2.1.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
-  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
-
 is-extendable@^0.1.0, is-extendable@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
@@ -5134,16 +3931,6 @@ is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3:
   dependencies:
     is-extglob "^2.1.1"
 
-is-interactive@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-interactive/-/is-interactive-1.0.0.tgz#cea6e6ae5c870a7b0a0004070b7b587e0252912e"
-  integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==
-
-is-lambda@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-lambda/-/is-lambda-1.0.1.tgz#3d9877899e6a53efc0160504cde15f82e6f061d5"
-  integrity sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==
-
 is-module@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
@@ -5171,11 +3958,6 @@ is-number@^7.0.0:
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
-is-obj@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
-  integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
-
 is-path-cwd@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-3.0.0.tgz#889b41e55c8588b1eb2a96a61d05740a674521c7"
@@ -5191,7 +3973,7 @@ is-path-inside@^4.0.0:
   resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-4.0.0.tgz#805aeb62c47c1b12fc3fd13bfb3ed1e7430071db"
   integrity sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==
 
-is-plain-obj@^1.0.0, is-plain-obj@^1.1.0:
+is-plain-obj@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
   integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==
@@ -5220,30 +4002,11 @@ is-relative@^1.0.0:
   dependencies:
     is-unc-path "^1.0.0"
 
-is-ssh@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/is-ssh/-/is-ssh-1.4.0.tgz#4f8220601d2839d8fa624b3106f8e8884f01b8b2"
-  integrity sha512-x7+VxdxOdlV3CYpjvRLBv5Lo9OJerlYanjwFrPR9fuGPjCiNiCzFgAWpiLAohSbsnH4ZAys3SBh+hq5rJosxUQ==
-  dependencies:
-    protocols "^2.0.1"
-
-is-stream@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.0.tgz#bde9c32680d6fae04129d6ac9d921ce7815f78e3"
-  integrity sha512-XCoy+WlUr7d1+Z8GgSuXmpuUFC9fOhRXglJMx+dwLKTkL44Cjd4W1Z5P+BQZpr+cR93aGP4S/s7Ftw6Nd/kiEw==
-
 is-stream@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
-is-text-path@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
-  integrity sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w==
-  dependencies:
-    text-extensions "^1.0.0"
-
 is-unc-path@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-unc-path/-/is-unc-path-1.0.0.tgz#d731e8898ed090a12c352ad2eaed5095ad322c9d"
@@ -5251,11 +4014,6 @@ is-unc-path@^1.0.0:
   dependencies:
     unc-path-regex "^0.1.2"
 
-is-unicode-supported@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7"
-  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
-
 is-utf8@^0.2.0, is-utf8@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
@@ -5271,13 +4029,6 @@ is-windows@^1.0.1, is-windows@^1.0.2:
   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 
-is-wsl@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
-  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
-  dependencies:
-    is-docker "^2.0.0"
-
 isarray@1.0.0, isarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
@@ -5367,16 +4118,6 @@ jackspeak@^2.0.3:
   optionalDependencies:
     "@pkgjs/parseargs" "^0.11.0"
 
-jake@^10.8.5:
-  version "10.8.7"
-  resolved "https://registry.yarnpkg.com/jake/-/jake-10.8.7.tgz#63a32821177940c33f356e0ba44ff9d34e1c7d8f"
-  integrity sha512-ZDi3aP+fG/LchyBzUM804VjddnwfSfsdeYkwt8NcbKRvo4rFkjhs456iLFn3k2ZUWvNe4i48WACDbza8fhq2+w==
-  dependencies:
-    async "^3.2.3"
-    chalk "^4.0.2"
-    filelist "^1.0.4"
-    minimatch "^3.1.2"
-
 jest-changed-files@^29.5.0:
   version "29.5.0"
   resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-29.5.0.tgz#e88786dca8bf2aa899ec4af7644e16d9dcf9b23e"
@@ -5457,16 +4198,6 @@ jest-config@^29.6.2:
     slash "^3.0.0"
     strip-json-comments "^3.1.1"
 
-"jest-diff@>=29.4.3 < 30":
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.5.0.tgz#e0d83a58eb5451dcc1fa61b1c3ee4e8f5a290d63"
-  integrity sha512-LtxijLLZBduXnHSniy0WMdaHjmQnt3g5sa16W4p0HqukYTTsyTW3GD1q41TyGl5YFXj/5B2U6dlh5FM1LIMgxw==
-  dependencies:
-    chalk "^4.0.0"
-    diff-sequences "^29.4.3"
-    jest-get-type "^29.4.3"
-    pretty-format "^29.5.0"
-
 jest-diff@^29.6.2:
   version "29.6.2"
   resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.6.2.tgz#c36001e5543e82a0805051d3ceac32e6825c1c46"
@@ -5791,14 +4522,7 @@ js-tokens@^4.0.0:
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
-js-yaml@4.1.0, js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-js-yaml@^3.10.0, js-yaml@^3.13.1:
+js-yaml@^3.13.1:
   version "3.14.1"
   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
@@ -5806,6 +4530,13 @@ js-yaml@^3.10.0, js-yaml@^3.13.1:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
+js-yaml@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
+  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  dependencies:
+    argparse "^2.0.1"
+
 jsesc@^2.5.1:
   version "2.5.2"
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
@@ -5834,21 +4565,11 @@ json-joy@^9.2.0:
     arg "^5.0.2"
     hyperdyperid "^1.2.0"
 
-json-parse-better-errors@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
-  integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
-
 json-parse-even-better-errors@^2.3.0, json-parse-even-better-errors@^2.3.1:
   version "2.3.1"
   resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
   integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
 
-json-parse-even-better-errors@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.0.tgz#2cb2ee33069a78870a0c7e3da560026b89669cf7"
-  integrity sha512-iZbGHafX/59r39gPwVPRBGw0QQKnA7tte5pSMrhWOW7swGsVvVTjmfyAV9pNqk8YGT7tRCdxRu8uzcgZwoDooA==
-
 json-schema-traverse@^0.4.1:
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
@@ -5859,11 +4580,6 @@ json-stable-stringify-without-jsonify@^1.0.1:
   resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
   integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
 
-json-stringify-safe@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
-  integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
-
 json2csv@^5.0.6:
   version "5.0.7"
   resolved "https://registry.yarnpkg.com/json2csv/-/json2csv-5.0.7.tgz#f3a583c25abd9804be873e495d1e65ad8d1b54ae"
@@ -5878,7 +4594,7 @@ json5@^2.2.2, json5@^2.2.3:
   resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
   integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
 
-jsonc-parser@3.2.0, jsonc-parser@^3.2.0:
+jsonc-parser@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-3.2.0.tgz#31ff3f4c2b9793f89c67212627c51c6394f88e76"
   integrity sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==
@@ -5892,7 +4608,7 @@ jsonfile@^6.0.1:
   optionalDependencies:
     graceful-fs "^4.1.6"
 
-jsonparse@^1.2.0, jsonparse@^1.3.1:
+jsonparse@^1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
   integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
@@ -5965,86 +4681,6 @@ lead@^1.0.0:
   dependencies:
     flush-write-stream "^1.0.2"
 
-lerna@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/lerna/-/lerna-7.0.0.tgz#7c805dd6c5aadb8e616295533210c10bb58a6d18"
-  integrity sha512-g84mUPUcPFCZ7RpJ2TQjEqIq0XbhbghcZgnoUfk83fUmyN8vozxqF4TqRVWkHEd0MCvf0OO3h8n422ZGe3jG3w==
-  dependencies:
-    "@lerna/child-process" "7.0.0"
-    "@lerna/create" "7.0.0"
-    "@npmcli/run-script" "6.0.2"
-    "@nx/devkit" ">=16.1.3 < 17"
-    "@octokit/plugin-enterprise-rest" "6.0.1"
-    "@octokit/rest" "19.0.11"
-    byte-size "8.1.1"
-    chalk "4.1.0"
-    clone-deep "4.0.1"
-    cmd-shim "6.0.1"
-    columnify "1.6.0"
-    conventional-changelog-angular "6.0.0"
-    conventional-changelog-core "5.0.1"
-    conventional-recommended-bump "7.0.1"
-    cosmiconfig "^8.2.0"
-    dedent "0.7.0"
-    envinfo "7.8.1"
-    execa "5.0.0"
-    fs-extra "^11.1.1"
-    get-port "5.1.1"
-    get-stream "6.0.0"
-    git-url-parse "13.1.0"
-    glob-parent "5.1.2"
-    globby "11.1.0"
-    graceful-fs "4.2.11"
-    has-unicode "2.0.1"
-    import-local "3.1.0"
-    ini "^1.3.8"
-    init-package-json "5.0.0"
-    inquirer "^8.2.4"
-    is-ci "3.0.1"
-    is-stream "2.0.0"
-    jest-diff ">=29.4.3 < 30"
-    js-yaml "4.1.0"
-    libnpmaccess "7.0.2"
-    libnpmpublish "7.3.0"
-    load-json-file "6.2.0"
-    make-dir "3.1.0"
-    minimatch "3.0.5"
-    multimatch "5.0.0"
-    node-fetch "2.6.7"
-    npm-package-arg "8.1.1"
-    npm-packlist "5.1.1"
-    npm-registry-fetch "^14.0.5"
-    npmlog "^6.0.2"
-    nx ">=16.1.3 < 17"
-    p-map "4.0.0"
-    p-map-series "2.1.0"
-    p-pipe "3.1.0"
-    p-queue "6.6.2"
-    p-reduce "2.1.0"
-    p-waterfall "2.1.1"
-    pacote "^15.2.0"
-    pify "5.0.0"
-    read-cmd-shim "4.0.0"
-    read-package-json "6.0.4"
-    resolve-from "5.0.0"
-    rimraf "^4.4.1"
-    semver "^7.3.8"
-    signal-exit "3.0.7"
-    slash "3.0.0"
-    ssri "^9.0.1"
-    strong-log-transformer "2.1.0"
-    tar "6.1.11"
-    temp-dir "1.0.0"
-    typescript ">=3 < 6"
-    upath "2.0.1"
-    uuid "^9.0.0"
-    validate-npm-package-license "3.0.4"
-    validate-npm-package-name "5.0.0"
-    write-file-atomic "5.0.1"
-    write-pkg "4.0.0"
-    yargs "16.2.0"
-    yargs-parser "20.2.4"
-
 leven@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2"
@@ -6058,28 +4694,6 @@ levn@^0.4.1:
     prelude-ls "^1.2.1"
     type-check "~0.4.0"
 
-libnpmaccess@7.0.2:
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/libnpmaccess/-/libnpmaccess-7.0.2.tgz#7f056c8c933dd9c8ba771fa6493556b53c5aac52"
-  integrity sha512-vHBVMw1JFMTgEk15zRsJuSAg7QtGGHpUSEfnbcRL1/gTBag9iEfJbyjpDmdJmwMhvpoLoNBtdAUCdGnaP32hhw==
-  dependencies:
-    npm-package-arg "^10.1.0"
-    npm-registry-fetch "^14.0.3"
-
-libnpmpublish@7.3.0:
-  version "7.3.0"
-  resolved "https://registry.yarnpkg.com/libnpmpublish/-/libnpmpublish-7.3.0.tgz#2ceb2b36866d75a6cd7b4aa748808169f4d17e37"
-  integrity sha512-fHUxw5VJhZCNSls0KLNEG0mCD2PN1i14gH5elGOgiVnU3VgTcRahagYP2LKI1m0tFCJ+XrAm0zVYyF5RCbXzcg==
-  dependencies:
-    ci-info "^3.6.1"
-    normalize-package-data "^5.0.0"
-    npm-package-arg "^10.1.0"
-    npm-registry-fetch "^14.0.3"
-    proc-log "^3.0.0"
-    semver "^7.3.7"
-    sigstore "^1.4.0"
-    ssri "^10.0.1"
-
 liftoff@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/liftoff/-/liftoff-3.1.0.tgz#c9ba6081f908670607ee79062d700df062c52ed3"
@@ -6099,21 +4713,6 @@ lines-and-columns@^1.1.6:
   resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
   integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
 
-lines-and-columns@~2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-2.0.3.tgz#b2f0badedb556b747020ab8ea7f0373e22efac1b"
-  integrity sha512-cNOjgCnLB+FnvWWtyRTzmB3POJ+cXxTA81LoW7u8JdmhfXzriropYwpjShnz1QLLWsQwY7nIxoDmcPTwphDK9w==
-
-load-json-file@6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-6.2.0.tgz#5c7770b42cafa97074ca2848707c61662f4251a1"
-  integrity sha512-gUD/epcRms75Cw8RT1pUdHugZYM5ce64ucs2GEISABwkRsOQr0q2wm/MV2TKThycIe5e0ytRweW2RZxclogCdQ==
-  dependencies:
-    graceful-fs "^4.1.15"
-    parse-json "^5.0.0"
-    strip-bom "^4.0.0"
-    type-fest "^0.6.0"
-
 load-json-file@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
@@ -6125,29 +4724,11 @@ load-json-file@^1.0.0:
     pinkie-promise "^2.0.0"
     strip-bom "^2.0.0"
 
-load-json-file@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b"
-  integrity sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^4.0.0"
-    pify "^3.0.0"
-    strip-bom "^3.0.0"
-
 loader-runner@^4.2.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
   integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
 
-locate-path@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
-  integrity sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==
-  dependencies:
-    p-locate "^2.0.0"
-    path-exists "^3.0.0"
-
 locate-path@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
@@ -6182,11 +4763,6 @@ lodash.get@^4.4.2:
   resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
   integrity sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==
 
-lodash.ismatch@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37"
-  integrity sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g==
-
 lodash.memoize@4.x:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
@@ -6207,14 +4783,6 @@ lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.4:
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 
-log-symbols@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503"
-  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
-  dependencies:
-    chalk "^4.1.0"
-    is-unicode-supported "^0.1.0"
-
 log-update@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
@@ -6239,11 +4807,6 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
-lru-cache@^7.4.4, lru-cache@^7.5.1, lru-cache@^7.7.1:
-  version "7.18.3"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.18.3.tgz#f793896e0fd0e954a59dfdd82f0773808df6aa89"
-  integrity sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==
-
 lru-cache@^9.1.1:
   version "9.1.2"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-9.1.2.tgz#255fdbc14b75589d6d0e73644ca167a8db506835"
@@ -6261,69 +4824,18 @@ lunr@^2.3.9:
   resolved "https://registry.yarnpkg.com/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1"
   integrity sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==
 
-make-dir@3.1.0, make-dir@^3.0.0:
+make-dir@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
   integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
   dependencies:
     semver "^6.0.0"
 
-make-dir@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
-  integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
-  dependencies:
-    pify "^4.0.1"
-    semver "^5.6.0"
-
 make-error@1.x, make-error@^1.1.1:
   version "1.3.6"
   resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
 
-make-fetch-happen@^10.0.3:
-  version "10.2.1"
-  resolved "https://registry.yarnpkg.com/make-fetch-happen/-/make-fetch-happen-10.2.1.tgz#f5e3835c5e9817b617f2770870d9492d28678164"
-  integrity sha512-NgOPbRiaQM10DYXvN3/hhGVI2M5MtITFryzBGxHM5p4wnFxsVCbxkrBrDsk+EZ5OB4jEOT7AjDxtdF+KVEFT7w==
-  dependencies:
-    agentkeepalive "^4.2.1"
-    cacache "^16.1.0"
-    http-cache-semantics "^4.1.0"
-    http-proxy-agent "^5.0.0"
-    https-proxy-agent "^5.0.0"
-    is-lambda "^1.0.1"
-    lru-cache "^7.7.1"
-    minipass "^3.1.6"
-    minipass-collect "^1.0.2"
-    minipass-fetch "^2.0.3"
-    minipass-flush "^1.0.5"
-    minipass-pipeline "^1.2.4"
-    negotiator "^0.6.3"
-    promise-retry "^2.0.1"
-    socks-proxy-agent "^7.0.0"
-    ssri "^9.0.0"
-
-make-fetch-happen@^11.0.0, make-fetch-happen@^11.0.1, make-fetch-happen@^11.1.0:
-  version "11.1.1"
-  resolved "https://registry.yarnpkg.com/make-fetch-happen/-/make-fetch-happen-11.1.1.tgz#85ceb98079584a9523d4bf71d32996e7e208549f"
-  integrity sha512-rLWS7GCSTcEujjVBs2YqG7Y4643u8ucvCJeSRqiLYhesrDuzeuFIk37xREzAsfQaqzl8b9rNCE4m6J8tvX4Q8w==
-  dependencies:
-    agentkeepalive "^4.2.1"
-    cacache "^17.0.0"
-    http-cache-semantics "^4.1.1"
-    http-proxy-agent "^5.0.0"
-    https-proxy-agent "^5.0.0"
-    is-lambda "^1.0.1"
-    lru-cache "^7.7.1"
-    minipass "^5.0.0"
-    minipass-fetch "^3.0.0"
-    minipass-flush "^1.0.5"
-    minipass-pipeline "^1.2.4"
-    negotiator "^0.6.3"
-    promise-retry "^2.0.1"
-    socks-proxy-agent "^7.0.0"
-    ssri "^10.0.0"
-
 make-iterator@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/make-iterator/-/make-iterator-1.0.1.tgz#29b33f312aa8f547c4a5e490f56afcec99133ad6"
@@ -6348,7 +4860,7 @@ map-obj@^1.0.0:
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
   integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==
 
-map-obj@^4.0.0, map-obj@^4.1.0:
+map-obj@^4.1.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
   integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
@@ -6428,23 +4940,6 @@ meow@^10.1.3:
     type-fest "^1.2.2"
     yargs-parser "^20.2.9"
 
-meow@^8.1.2:
-  version "8.1.2"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-8.1.2.tgz#bcbe45bda0ee1729d350c03cffc8395a36c4e897"
-  integrity sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==
-  dependencies:
-    "@types/minimist" "^1.2.0"
-    camelcase-keys "^6.2.2"
-    decamelize-keys "^1.1.0"
-    hard-rejection "^2.1.0"
-    minimist-options "4.1.0"
-    normalize-package-data "^3.0.0"
-    read-pkg-up "^7.0.1"
-    redent "^3.0.0"
-    trim-newlines "^3.0.0"
-    type-fest "^0.18.0"
-    yargs-parser "^20.2.3"
-
 merge-stream@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
@@ -6487,7 +4982,7 @@ mime-db@1.52.0:
   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
-mime-types@^2.1.12, mime-types@^2.1.27:
+mime-types@^2.1.27:
   version "2.1.35"
   resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
   integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
@@ -6504,13 +4999,6 @@ min-indent@^1.0.0, min-indent@^1.0.1:
   resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
   integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
 
-minimatch@3.0.5:
-  version "3.0.5"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.5.tgz#4da8f1290ee0f0f8e83d60ca69f8f134068604a3"
-  integrity sha512-tUpxzX0VAzJHjLu0xUfFv1gwVp9ba3IOuRAVH2EGuRW8a5emA2FlACLqiT/lDVtS1W+TGNwqz3sWaNyLgDJWuw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
 minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
@@ -6518,20 +5006,6 @@ minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
   dependencies:
     brace-expansion "^1.1.7"
 
-minimatch@^5.0.1:
-  version "5.1.6"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-5.1.6.tgz#1cfcb8cf5522ea69952cd2af95ae09477f122a96"
-  integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==
-  dependencies:
-    brace-expansion "^2.0.1"
-
-minimatch@^8.0.2:
-  version "8.0.4"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-8.0.4.tgz#847c1b25c014d4e9a7f68aaf63dedd668a626229"
-  integrity sha512-W0Wvr9HyFXZRGIDgCicunpQ299OKXs9RgZfaukz4qAW/pJhcpUfupc9c+OObPOFueNy8VSrZgEmDtk6Kh4WzDA==
-  dependencies:
-    brace-expansion "^2.0.1"
-
 minimatch@^9.0.0, minimatch@^9.0.1:
   version "9.0.1"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.1.tgz#8a555f541cf976c622daf078bb28f29fb927c253"
@@ -6548,99 +5022,16 @@ minimist-options@4.1.0:
     is-plain-obj "^1.1.0"
     kind-of "^6.0.3"
 
-minimist@1.x, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6:
+minimist@1.x:
   version "1.2.8"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
 
-minipass-collect@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/minipass-collect/-/minipass-collect-1.0.2.tgz#22b813bf745dc6edba2576b940022ad6edc8c617"
-  integrity sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==
-  dependencies:
-    minipass "^3.0.0"
-
-minipass-fetch@^2.0.3:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/minipass-fetch/-/minipass-fetch-2.1.2.tgz#95560b50c472d81a3bc76f20ede80eaed76d8add"
-  integrity sha512-LT49Zi2/WMROHYoqGgdlQIZh8mLPZmOrN2NdJjMXxYe4nkN6FUyuPuOAOedNJDrx0IRGg9+4guZewtp8hE6TxA==
-  dependencies:
-    minipass "^3.1.6"
-    minipass-sized "^1.0.3"
-    minizlib "^2.1.2"
-  optionalDependencies:
-    encoding "^0.1.13"
-
-minipass-fetch@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/minipass-fetch/-/minipass-fetch-3.0.3.tgz#d9df70085609864331b533c960fd4ffaa78d15ce"
-  integrity sha512-n5ITsTkDqYkYJZjcRWzZt9qnZKCT7nKCosJhHoj7S7zD+BP4jVbWs+odsniw5TA3E0sLomhTKOKjF86wf11PuQ==
-  dependencies:
-    minipass "^5.0.0"
-    minipass-sized "^1.0.3"
-    minizlib "^2.1.2"
-  optionalDependencies:
-    encoding "^0.1.13"
-
-minipass-flush@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/minipass-flush/-/minipass-flush-1.0.5.tgz#82e7135d7e89a50ffe64610a787953c4c4cbb373"
-  integrity sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==
-  dependencies:
-    minipass "^3.0.0"
-
-minipass-json-stream@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minipass-json-stream/-/minipass-json-stream-1.0.1.tgz#7edbb92588fbfc2ff1db2fc10397acb7b6b44aa7"
-  integrity sha512-ODqY18UZt/I8k+b7rl2AENgbWE8IDYam+undIJONvigAz8KR5GWblsFTEfQs0WODsjbSXWlm+JHEv8Gr6Tfdbg==
-  dependencies:
-    jsonparse "^1.3.1"
-    minipass "^3.0.0"
-
-minipass-pipeline@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz#68472f79711c084657c067c5c6ad93cddea8214c"
-  integrity sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==
-  dependencies:
-    minipass "^3.0.0"
-
-minipass-sized@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/minipass-sized/-/minipass-sized-1.0.3.tgz#70ee5a7c5052070afacfbc22977ea79def353b70"
-  integrity sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==
-  dependencies:
-    minipass "^3.0.0"
-
-minipass@^3.0.0, minipass@^3.1.1, minipass@^3.1.6:
-  version "3.3.6"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-3.3.6.tgz#7bba384db3a1520d18c9c0e5251c3444e95dd94a"
-  integrity sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==
-  dependencies:
-    yallist "^4.0.0"
-
-minipass@^4.2.4:
-  version "4.2.8"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-4.2.8.tgz#f0010f64393ecfc1d1ccb5f582bcaf45f48e1a3a"
-  integrity sha512-fNzuVyifolSLFL4NzpF+wEF4qrgqaaKX0haXPQEdQ7NKAN+WecoKMHV09YcuL/DHxrUsYQOK3MiuDf7Ip2OXfQ==
-
-minipass@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-5.0.0.tgz#3e9788ffb90b694a5d0ec94479a45b5d8738133d"
-  integrity sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==
-
 "minipass@^5.0.0 || ^6.0.2":
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/minipass/-/minipass-6.0.2.tgz#542844b6c4ce95b202c0995b0a471f1229de4c81"
   integrity sha512-MzWSV5nYVT7mVyWCwn2o7JH13w2TBRmmSqSRCKzTw+lmft9X4z+3wjvs06Tzijo5z4W/kahUCDpRXTF+ZrmF/w==
 
-minizlib@^2.1.1, minizlib@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-2.1.2.tgz#e90d3466ba209b932451508a11ce3d3632145931"
-  integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==
-  dependencies:
-    minipass "^3.0.0"
-    yallist "^4.0.0"
-
 mixin-deep@^1.2.0:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
@@ -6654,16 +5045,6 @@ mkdirp@3.0.1:
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-3.0.1.tgz#e44e4c5607fb279c168241713cc6e0fea9adcb50"
   integrity sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==
 
-mkdirp@^1.0.3, mkdirp@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
-  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
-
-modify-values@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
-  integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
-
 mrmime@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-1.0.1.tgz#5f90c825fad4bdd41dc914eff5d1a8cfdaf24f27"
@@ -6679,22 +5060,11 @@ ms@2.1.2:
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
-ms@^2.0.0, ms@^2.1.1:
+ms@^2.1.1:
   version "2.1.3"
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
-multimatch@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/multimatch/-/multimatch-5.0.0.tgz#932b800963cea7a31a033328fa1e0c3a1874dbe6"
-  integrity sha512-ypMKuglUrZUD99Tk2bUQ+xNQj43lPEfAeX2o9cTteAmShXy2VHDJpuwu1o0xqoKCt9jLVAvwyFKdLTPXKAfJyA==
-  dependencies:
-    "@types/minimatch" "^3.0.3"
-    array-differ "^3.0.0"
-    array-union "^2.1.0"
-    arrify "^2.0.1"
-    minimatch "^3.0.4"
-
 multistream@4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/multistream/-/multistream-4.1.0.tgz#7bf00dfd119556fbc153cff3de4c6d477909f5a8"
@@ -6708,16 +5078,6 @@ mute-stdout@^1.0.0:
   resolved "https://registry.yarnpkg.com/mute-stdout/-/mute-stdout-1.0.1.tgz#acb0300eb4de23a7ddeec014e3e96044b3472331"
   integrity sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==
 
-mute-stream@0.0.8:
-  version "0.0.8"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
-  integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
-
-mute-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-1.0.0.tgz#e31bd9fe62f0aed23520aa4324ea6671531e013e"
-  integrity sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA==
-
 nan@^2.12.1:
   version "2.17.0"
   resolved "https://registry.yarnpkg.com/nan/-/nan-2.17.0.tgz#c0150a2368a182f033e9aa5195ec76ea41a199cb"
@@ -6750,12 +5110,7 @@ natural-compare@^1.4.0:
   resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
 
-negotiator@^0.6.3:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd"
-  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
-
-neo-async@^2.6.0, neo-async@^2.6.2:
+neo-async@^2.6.2:
   version "2.6.2"
   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
@@ -6765,46 +5120,6 @@ next-tick@1, next-tick@^1.1.0:
   resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb"
   integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==
 
-node-addon-api@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-3.2.1.tgz#81325e0a2117789c0128dab65e7e38f07ceba161"
-  integrity sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==
-
-node-fetch@2.6.7:
-  version "2.6.7"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad"
-  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-fetch@^2.6.7:
-  version "2.6.11"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.11.tgz#cde7fc71deef3131ef80a738919f999e6edfff25"
-  integrity sha512-4I6pdBY1EthSqDmJkiNk3JIT8cswwR9nfeW/cPdUagJYEQG7R95WRH74wpz7ma8Gh/9dI9FP+OU+0E4FvtA55w==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-gyp-build@^4.3.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.6.0.tgz#0c52e4cbf54bbd28b709820ef7b6a3c2d6209055"
-  integrity sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==
-
-node-gyp@^9.0.0:
-  version "9.3.1"
-  resolved "https://registry.yarnpkg.com/node-gyp/-/node-gyp-9.3.1.tgz#1e19f5f290afcc9c46973d68700cbd21a96192e4"
-  integrity sha512-4Q16ZCqq3g8awk6UplT7AuxQ35XN4R/yf/+wSAwcBUAjg7l58RTactWaP8fIDTi0FzI7YcVLujwExakZlfWkXg==
-  dependencies:
-    env-paths "^2.2.0"
-    glob "^7.1.4"
-    graceful-fs "^4.2.6"
-    make-fetch-happen "^10.0.3"
-    nopt "^6.0.0"
-    npmlog "^6.0.0"
-    rimraf "^3.0.2"
-    semver "^7.3.5"
-    tar "^6.1.2"
-    which "^2.0.2"
-
 node-int64@^0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b"
@@ -6815,13 +5130,6 @@ node-releases@^2.0.12:
   resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.12.tgz#35627cc224a23bfb06fb3380f2b3afaaa7eb1039"
   integrity sha512-QzsYKWhXTWx8h1kIvqfnC++o0pEmpRQA/aenALsL2F4pqNVr7YzcdMlDij5WBnwftRbJCNJL/O7zdKaxKPHqgQ==
 
-nopt@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-6.0.0.tgz#245801d8ebf409c6df22ab9d95b65e1309cdb16d"
-  integrity sha512-ZwLpbTgdhuZUnZzjd7nb1ZV+4DoiC6/sfiVKok72ym/4Tlf+DFdlHYmT2JPmcNNWV6Pi3SDf1kT+A4r9RTuT9g==
-  dependencies:
-    abbrev "^1.0.0"
-
 normalize-package-data@^2.3.2, normalize-package-data@^2.5.0:
   version "2.5.0"
   resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
@@ -6832,7 +5140,7 @@ normalize-package-data@^2.3.2, normalize-package-data@^2.5.0:
     semver "2 || 3 || 4 || 5"
     validate-npm-package-license "^3.0.1"
 
-normalize-package-data@^3.0.0, normalize-package-data@^3.0.2, normalize-package-data@^3.0.3:
+normalize-package-data@^3.0.2:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
   integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
@@ -6842,16 +5150,6 @@ normalize-package-data@^3.0.0, normalize-package-data@^3.0.2, normalize-package-
     semver "^7.3.4"
     validate-npm-package-license "^3.0.1"
 
-normalize-package-data@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-5.0.0.tgz#abcb8d7e724c40d88462b84982f7cbf6859b4588"
-  integrity sha512-h9iPVIfrVZ9wVYQnxFgtw1ugSvGEMOlyPWWtm8BMJhnwyEL/FLbYbTY3V3PpjI/BUK67n9PEWDu6eHzu1fB15Q==
-  dependencies:
-    hosted-git-info "^6.0.0"
-    is-core-module "^2.8.1"
-    semver "^7.3.5"
-    validate-npm-package-license "^3.0.4"
-
 normalize-path@^2.0.1, normalize-path@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
@@ -6869,97 +5167,7 @@ now-and-later@^2.0.0:
   resolved "https://registry.yarnpkg.com/now-and-later/-/now-and-later-2.0.1.tgz#8e579c8685764a7cc02cb680380e94f43ccb1f7c"
   integrity sha512-KGvQ0cB70AQfg107Xvs/Fbu+dGmZoTRJp2TaPwcwQm3/7PteUyN2BCgk8KBMPGBUXZdVwyWS8fDCGFygBm19UQ==
   dependencies:
-    once "^1.3.2"
-
-npm-bundled@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-1.1.2.tgz#944c78789bd739035b70baa2ca5cc32b8d860bc1"
-  integrity sha512-x5DHup0SuyQcmL3s7Rx/YQ8sbw/Hzg0rj48eN0dV7hf5cmQq5PXIeioroH3raV1QC1yh3uTYuMThvEQF3iKgGQ==
-  dependencies:
-    npm-normalize-package-bin "^1.0.1"
-
-npm-bundled@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-3.0.0.tgz#7e8e2f8bb26b794265028491be60321a25a39db7"
-  integrity sha512-Vq0eyEQy+elFpzsKjMss9kxqb9tG3YHg4dsyWuUENuzvSUWe1TCnW/vV9FkhvBk/brEDoDiVd+M1Btosa6ImdQ==
-  dependencies:
-    npm-normalize-package-bin "^3.0.0"
-
-npm-install-checks@^6.0.0:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/npm-install-checks/-/npm-install-checks-6.1.1.tgz#b459b621634d06546664207fde16810815808db1"
-  integrity sha512-dH3GmQL4vsPtld59cOn8uY0iOqRmqKvV+DLGwNXV/Q7MDgD2QfOADWd/mFXcIE5LVhYYGjA3baz6W9JneqnuCw==
-  dependencies:
-    semver "^7.1.1"
-
-npm-normalize-package-bin@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/npm-normalize-package-bin/-/npm-normalize-package-bin-1.0.1.tgz#6e79a41f23fd235c0623218228da7d9c23b8f6e2"
-  integrity sha512-EPfafl6JL5/rU+ot6P3gRSCpPDW5VmIzX959Ob1+ySFUuuYHWHekXpwdUZcKP5C+DS4GEtdJluwBjnsNDl+fSA==
-
-npm-normalize-package-bin@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/npm-normalize-package-bin/-/npm-normalize-package-bin-3.0.1.tgz#25447e32a9a7de1f51362c61a559233b89947832"
-  integrity sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==
-
-npm-package-arg@8.1.1:
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/npm-package-arg/-/npm-package-arg-8.1.1.tgz#00ebf16ac395c63318e67ce66780a06db6df1b04"
-  integrity sha512-CsP95FhWQDwNqiYS+Q0mZ7FAEDytDZAkNxQqea6IaAFJTAY9Lhhqyl0irU/6PMc7BGfUmnsbHcqxJD7XuVM/rg==
-  dependencies:
-    hosted-git-info "^3.0.6"
-    semver "^7.0.0"
-    validate-npm-package-name "^3.0.0"
-
-npm-package-arg@^10.0.0, npm-package-arg@^10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/npm-package-arg/-/npm-package-arg-10.1.0.tgz#827d1260a683806685d17193073cc152d3c7e9b1"
-  integrity sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==
-  dependencies:
-    hosted-git-info "^6.0.0"
-    proc-log "^3.0.0"
-    semver "^7.3.5"
-    validate-npm-package-name "^5.0.0"
-
-npm-packlist@5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-5.1.1.tgz#79bcaf22a26b6c30aa4dd66b976d69cc286800e0"
-  integrity sha512-UfpSvQ5YKwctmodvPPkK6Fwk603aoVsf8AEbmVKAEECrfvL8SSe1A2YIwrJ6xmTHAITKPwwZsWo7WwEbNk0kxw==
-  dependencies:
-    glob "^8.0.1"
-    ignore-walk "^5.0.1"
-    npm-bundled "^1.1.2"
-    npm-normalize-package-bin "^1.0.1"
-
-npm-packlist@^7.0.0:
-  version "7.0.4"
-  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-7.0.4.tgz#033bf74110eb74daf2910dc75144411999c5ff32"
-  integrity sha512-d6RGEuRrNS5/N84iglPivjaJPxhDbZmlbTwTDX2IbcRHG5bZCdtysYMhwiPvcF4GisXHGn7xsxv+GQ7T/02M5Q==
-  dependencies:
-    ignore-walk "^6.0.0"
-
-npm-pick-manifest@^8.0.0:
-  version "8.0.1"
-  resolved "https://registry.yarnpkg.com/npm-pick-manifest/-/npm-pick-manifest-8.0.1.tgz#c6acd97d1ad4c5dbb80eac7b386b03ffeb289e5f"
-  integrity sha512-mRtvlBjTsJvfCCdmPtiu2bdlx8d/KXtF7yNXNWe7G0Z36qWA9Ny5zXsI2PfBZEv7SXgoxTmNaTzGSbbzDZChoA==
-  dependencies:
-    npm-install-checks "^6.0.0"
-    npm-normalize-package-bin "^3.0.0"
-    npm-package-arg "^10.0.0"
-    semver "^7.3.5"
-
-npm-registry-fetch@^14.0.0, npm-registry-fetch@^14.0.3, npm-registry-fetch@^14.0.5:
-  version "14.0.5"
-  resolved "https://registry.yarnpkg.com/npm-registry-fetch/-/npm-registry-fetch-14.0.5.tgz#fe7169957ba4986a4853a650278ee02e568d115d"
-  integrity sha512-kIDMIo4aBm6xg7jOttupWZamsZRkAqMqwqqbVXnUqstY5+tapvv6bkH/qMR76jdgV+YljEUCyWx3hRYMrJiAgA==
-  dependencies:
-    make-fetch-happen "^11.0.0"
-    minipass "^5.0.0"
-    minipass-fetch "^3.0.0"
-    minipass-json-stream "^1.0.1"
-    minizlib "^2.1.2"
-    npm-package-arg "^10.0.0"
-    proc-log "^3.0.0"
+    once "^1.3.2"
 
 npm-run-path@^4.0.1:
   version "4.0.1"
@@ -6968,72 +5176,11 @@ npm-run-path@^4.0.1:
   dependencies:
     path-key "^3.0.0"
 
-npmlog@^6.0.0, npmlog@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-6.0.2.tgz#c8166017a42f2dea92d6453168dd865186a70830"
-  integrity sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==
-  dependencies:
-    are-we-there-yet "^3.0.0"
-    console-control-strings "^1.1.0"
-    gauge "^4.0.3"
-    set-blocking "^2.0.0"
-
 number-is-nan@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
   integrity sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==
 
-nx@16.3.2, "nx@>=16.1.3 < 17":
-  version "16.3.2"
-  resolved "https://registry.yarnpkg.com/nx/-/nx-16.3.2.tgz#92a2d7ef06d15b3b111b7cf9d35de08de0a22d90"
-  integrity sha512-fOzCVL7qoCJAcYTJwvJ9j+PSaL791ro4AICWuLxaphZsp2jcLoav4Ev7ONPks2Wlkt8FS9bee3nqQ3w1ya36Og==
-  dependencies:
-    "@nrwl/tao" "16.3.2"
-    "@parcel/watcher" "2.0.4"
-    "@yarnpkg/lockfile" "^1.1.0"
-    "@yarnpkg/parsers" "^3.0.0-rc.18"
-    "@zkochan/js-yaml" "0.0.6"
-    axios "^1.0.0"
-    chalk "^4.1.0"
-    cli-cursor "3.1.0"
-    cli-spinners "2.6.1"
-    cliui "^7.0.2"
-    dotenv "~10.0.0"
-    enquirer "~2.3.6"
-    fast-glob "3.2.7"
-    figures "3.2.0"
-    flat "^5.0.2"
-    fs-extra "^11.1.0"
-    glob "7.1.4"
-    ignore "^5.0.4"
-    js-yaml "4.1.0"
-    jsonc-parser "3.2.0"
-    lines-and-columns "~2.0.3"
-    minimatch "3.0.5"
-    npm-run-path "^4.0.1"
-    open "^8.4.0"
-    semver "7.3.4"
-    string-width "^4.2.3"
-    strong-log-transformer "^2.1.0"
-    tar-stream "~2.2.0"
-    tmp "~0.2.1"
-    tsconfig-paths "^4.1.2"
-    tslib "^2.3.0"
-    v8-compile-cache "2.3.0"
-    yargs "^17.6.2"
-    yargs-parser "21.1.1"
-  optionalDependencies:
-    "@nx/nx-darwin-arm64" "16.3.2"
-    "@nx/nx-darwin-x64" "16.3.2"
-    "@nx/nx-freebsd-x64" "16.3.2"
-    "@nx/nx-linux-arm-gnueabihf" "16.3.2"
-    "@nx/nx-linux-arm64-gnu" "16.3.2"
-    "@nx/nx-linux-arm64-musl" "16.3.2"
-    "@nx/nx-linux-x64-gnu" "16.3.2"
-    "@nx/nx-linux-x64-musl" "16.3.2"
-    "@nx/nx-win32-arm64-msvc" "16.3.2"
-    "@nx/nx-win32-x64-msvc" "16.3.2"
-
 object-assign@4.X, object-assign@^4.0.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
@@ -7117,15 +5264,6 @@ onetime@^5.1.0, onetime@^5.1.2:
   dependencies:
     mimic-fn "^2.1.0"
 
-open@^8.4.0:
-  version "8.4.2"
-  resolved "https://registry.yarnpkg.com/open/-/open-8.4.2.tgz#5b5ffe2a8f793dcd2aad73e550cb87b59cb084f9"
-  integrity sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==
-  dependencies:
-    define-lazy-prop "^2.0.0"
-    is-docker "^2.1.1"
-    is-wsl "^2.2.0"
-
 opener@^1.5.2:
   version "1.5.2"
   resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
@@ -7143,21 +5281,6 @@ optionator@^0.9.1:
     type-check "^0.4.0"
     word-wrap "^1.2.3"
 
-ora@^5.4.1:
-  version "5.4.1"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-5.4.1.tgz#1b2678426af4ac4a509008e5e4ac9e9959db9e18"
-  integrity sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==
-  dependencies:
-    bl "^4.1.0"
-    chalk "^4.1.0"
-    cli-cursor "^3.1.0"
-    cli-spinners "^2.5.0"
-    is-interactive "^1.0.0"
-    is-unicode-supported "^0.1.0"
-    log-symbols "^4.1.0"
-    strip-ansi "^6.0.0"
-    wcwidth "^1.0.1"
-
 ordered-read-streams@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz#77c0cb37c41525d64166d990ffad7ec6a0e1363e"
@@ -7172,23 +5295,6 @@ os-locale@^1.4.0:
   dependencies:
     lcid "^1.0.0"
 
-os-tmpdir@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
-  integrity sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==
-
-p-finally@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
-  integrity sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==
-
-p-limit@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
-  integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==
-  dependencies:
-    p-try "^1.0.0"
-
 p-limit@^2.2.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
@@ -7203,13 +5309,6 @@ p-limit@^3.0.2, p-limit@^3.1.0:
   dependencies:
     yocto-queue "^0.1.0"
 
-p-locate@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
-  integrity sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==
-  dependencies:
-    p-limit "^1.1.0"
-
 p-locate@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
@@ -7224,18 +5323,6 @@ p-locate@^5.0.0:
   dependencies:
     p-limit "^3.0.2"
 
-p-map-series@2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/p-map-series/-/p-map-series-2.1.0.tgz#7560d4c452d9da0c07e692fdbfe6e2c81a2a91f2"
-  integrity sha512-RpYIIK1zXSNEOdwxcfe7FdvGcs7+y5n8rifMhMNWvaxRNMPINJHF5GDeuVxWqnfrcHPSCnp7Oo5yNXHId9Av2Q==
-
-p-map@4.0.0, p-map@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
-  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
-  dependencies:
-    aggregate-error "^3.0.0"
-
 p-map@^5.5.0:
   version "5.5.0"
   resolved "https://registry.yarnpkg.com/p-map/-/p-map-5.5.0.tgz#054ca8ca778dfa4cf3f8db6638ccb5b937266715"
@@ -7243,72 +5330,11 @@ p-map@^5.5.0:
   dependencies:
     aggregate-error "^4.0.0"
 
-p-pipe@3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/p-pipe/-/p-pipe-3.1.0.tgz#48b57c922aa2e1af6a6404cb7c6bf0eb9cc8e60e"
-  integrity sha512-08pj8ATpzMR0Y80x50yJHn37NF6vjrqHutASaX5LiH5npS9XPvrUmscd9MF5R4fuYRHOxQR1FfMIlF7AzwoPqw==
-
-p-queue@6.6.2:
-  version "6.6.2"
-  resolved "https://registry.yarnpkg.com/p-queue/-/p-queue-6.6.2.tgz#2068a9dcf8e67dd0ec3e7a2bcb76810faa85e426"
-  integrity sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==
-  dependencies:
-    eventemitter3 "^4.0.4"
-    p-timeout "^3.2.0"
-
-p-reduce@2.1.0, p-reduce@^2.0.0, p-reduce@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/p-reduce/-/p-reduce-2.1.0.tgz#09408da49507c6c274faa31f28df334bc712b64a"
-  integrity sha512-2USApvnsutq8uoxZBGbbWM0JIYLiEMJ9RlaN7fAzVNb9OZN0SHjjTTfIcb667XynS5Y1VhwDJVDa72TnPzAYWw==
-
-p-timeout@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-3.2.0.tgz#c7e17abc971d2a7962ef83626b35d635acf23dfe"
-  integrity sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==
-  dependencies:
-    p-finally "^1.0.0"
-
-p-try@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
-  integrity sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==
-
 p-try@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
 
-p-waterfall@2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/p-waterfall/-/p-waterfall-2.1.1.tgz#63153a774f472ccdc4eb281cdb2967fcf158b2ee"
-  integrity sha512-RRTnDb2TBG/epPRI2yYXsimO0v3BXC8Yd3ogr1545IaqKK17VGhbWVeGGN+XfCm/08OK8635nH31c8bATkHuSw==
-  dependencies:
-    p-reduce "^2.0.0"
-
-pacote@^15.2.0:
-  version "15.2.0"
-  resolved "https://registry.yarnpkg.com/pacote/-/pacote-15.2.0.tgz#0f0dfcc3e60c7b39121b2ac612bf8596e95344d3"
-  integrity sha512-rJVZeIwHTUta23sIZgEIM62WYwbmGbThdbnkt81ravBplQv+HjyroqnLRNH2+sLJHcGZmLRmhPwACqhfTcOmnA==
-  dependencies:
-    "@npmcli/git" "^4.0.0"
-    "@npmcli/installed-package-contents" "^2.0.1"
-    "@npmcli/promise-spawn" "^6.0.1"
-    "@npmcli/run-script" "^6.0.0"
-    cacache "^17.0.0"
-    fs-minipass "^3.0.0"
-    minipass "^5.0.0"
-    npm-package-arg "^10.0.0"
-    npm-packlist "^7.0.0"
-    npm-pick-manifest "^8.0.0"
-    npm-registry-fetch "^14.0.0"
-    proc-log "^3.0.0"
-    promise-retry "^2.0.1"
-    read-package-json "^6.0.0"
-    read-package-json-fast "^3.0.0"
-    sigstore "^1.3.0"
-    ssri "^10.0.0"
-    tar "^6.1.11"
-
 pad-left@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/pad-left/-/pad-left-2.1.0.tgz#16e6a3b2d44a8e138cb0838cc7cb403a4fc9e994"
@@ -7339,14 +5365,6 @@ parse-json@^2.2.0:
   dependencies:
     error-ex "^1.2.0"
 
-parse-json@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
-  integrity sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==
-  dependencies:
-    error-ex "^1.3.1"
-    json-parse-better-errors "^1.0.1"
-
 parse-json@^5.0.0, parse-json@^5.2.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
@@ -7367,20 +5385,6 @@ parse-passwd@^1.0.0:
   resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
   integrity sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==
 
-parse-path@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/parse-path/-/parse-path-7.0.0.tgz#605a2d58d0a749c8594405d8cc3a2bf76d16099b"
-  integrity sha512-Euf9GG8WT9CdqwuWJGdf3RkUcTBArppHABkO7Lm8IzRQp0e2r/kkFnmhu4TSK30Wcu5rVAZLmfPKSBBi9tWFog==
-  dependencies:
-    protocols "^2.0.0"
-
-parse-url@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/parse-url/-/parse-url-8.1.0.tgz#972e0827ed4b57fc85f0ea6b0d839f0d8a57a57d"
-  integrity sha512-xDvOoLU5XRrcOZvnI6b8zA6n9O9ejNk/GExuz1yBuWUGn9KA97GI6HTs6u02wKara1CeVmZhH+0TZFdWScR89w==
-  dependencies:
-    parse-path "^7.0.0"
-
 pascalcase@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
@@ -7398,11 +5402,6 @@ path-exists@^2.0.0:
   dependencies:
     pinkie-promise "^2.0.0"
 
-path-exists@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
-  integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==
-
 path-exists@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
@@ -7435,7 +5434,7 @@ path-root@^0.1.1:
   dependencies:
     path-root-regex "^0.1.0"
 
-path-scurry@^1.6.1, path-scurry@^1.7.0:
+path-scurry@^1.7.0:
   version "1.9.2"
   resolved "https://registry.yarnpkg.com/path-scurry/-/path-scurry-1.9.2.tgz#90f9d296ac5e37e608028e28a447b11d385b3f63"
   integrity sha512-qSDLy2aGFPm8i4rsbHd4MNyTcrzHFsLQykrtbuGRknZZCBBVXSv2tSCDN2Cg6Rt/GFRw8GoW9y9Ecw5rIPG1sg==
@@ -7452,13 +5451,6 @@ path-type@^1.0.0:
     pify "^2.0.0"
     pinkie-promise "^2.0.0"
 
-path-type@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-3.0.0.tgz#cef31dc8e0a1a3bb0d105c0cd97cf3bf47f4e36f"
-  integrity sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==
-  dependencies:
-    pify "^3.0.0"
-
 path-type@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
@@ -7479,26 +5471,11 @@ picomatch@^2.0.4, picomatch@^2.2.3, picomatch@^2.3.1:
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
-pify@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-5.0.0.tgz#1f5eca3f5e87ebec28cc6d54a0e4aaf00acc127f"
-  integrity sha512-eW/gHNMlxdSP6dmG6uJip6FXN0EQBwm2clYYd8Wul42Cwu/DK8HEftzsapcNdYe2MfLiIwZqsDk2RDEsTE79hA==
-
-pify@^2.0.0, pify@^2.3.0:
+pify@^2.0.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
   integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
 
-pify@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
-  integrity sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==
-
-pify@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
-  integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
-
 pinkie-promise@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
@@ -7568,7 +5545,7 @@ prelude-ls@^1.2.1:
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
-pretty-format@^29.0.0, pretty-format@^29.5.0, pretty-format@^29.6.2:
+pretty-format@^29.0.0, pretty-format@^29.6.2:
   version "29.6.2"
   resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.6.2.tgz#3d5829261a8a4d89d8b9769064b29c50ed486a47"
   integrity sha512-1q0oC8eRveTg5nnBEWMXAU2qpv65Gnuf2eCQzSjxpWFkPaPARwqZZDGuNE0zPAZfTCHzIk3A8dIjwlQKKLphyg==
@@ -7582,29 +5559,11 @@ pretty-hrtime@^1.0.0:
   resolved "https://registry.yarnpkg.com/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz#b7e3ea42435a4c9b2759d99e0f201eb195802ee1"
   integrity sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==
 
-proc-log@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/proc-log/-/proc-log-3.0.0.tgz#fb05ef83ccd64fd7b20bbe9c8c1070fc08338dd8"
-  integrity sha512-++Vn7NS4Xf9NacaU9Xq3URUuqZETPsf8L4j5/ckhaRYsfPeRyzGw+iDjFhV/Jr3uNmTvvddEJFWh5R1gRgUH8A==
-
 process-nextick-args@^2.0.0, process-nextick-args@~2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
-promise-inflight@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/promise-inflight/-/promise-inflight-1.0.1.tgz#98472870bf228132fcbdd868129bad12c3c029e3"
-  integrity sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==
-
-promise-retry@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/promise-retry/-/promise-retry-2.0.1.tgz#ff747a13620ab57ba688f5fc67855410c370da22"
-  integrity sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==
-  dependencies:
-    err-code "^2.0.2"
-    retry "^0.12.0"
-
 promise@^8.0.1:
   version "8.3.0"
   resolved "https://registry.yarnpkg.com/promise/-/promise-8.3.0.tgz#8cb333d1edeb61ef23869fbb8a4ea0279ab60e0a"
@@ -7620,23 +5579,6 @@ prompts@^2.0.1:
     kleur "^3.0.3"
     sisteransi "^1.0.5"
 
-promzard@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/promzard/-/promzard-1.0.0.tgz#3246f8e6c9895a77c0549cefb65828ac0f6c006b"
-  integrity sha512-KQVDEubSUHGSt5xLakaToDFrSoZhStB8dXLzk2xvwR67gJktrHFvpR63oZgHyK19WKbHFLXJqCPXdVR3aBP8Ig==
-  dependencies:
-    read "^2.0.0"
-
-protocols@^2.0.0, protocols@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/protocols/-/protocols-2.0.1.tgz#8f155da3fc0f32644e83c5782c8e8212ccf70a86"
-  integrity sha512-/XJ368cyBJ7fzLMwLKv1e4vLxOju2MNAIokcr7meSaNcVbWz/CPcW22cP04mwxOErdA5mwjA8Q6w/cdAQxVn7Q==
-
-proxy-from-env@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
-  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
-
 prr@~1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
@@ -7679,11 +5621,6 @@ queue-tick@^1.0.1:
   resolved "https://registry.yarnpkg.com/queue-tick/-/queue-tick-1.0.1.tgz#f6f07ac82c1fd60f82e098b417a80e52f1f4c142"
   integrity sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==
 
-quick-lru@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
-  integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==
-
 quick-lru@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
@@ -7710,29 +5647,6 @@ react-is@^18.0.0:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.2.0.tgz#199431eeaaa2e09f86427efbb4f1473edb47609b"
   integrity sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==
 
-read-cmd-shim@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/read-cmd-shim/-/read-cmd-shim-4.0.0.tgz#640a08b473a49043e394ae0c7a34dd822c73b9bb"
-  integrity sha512-yILWifhaSEEytfXI76kB9xEEiG1AiozaCJZ83A87ytjRiN+jVibXjedjCRNjoZviinhG+4UkalO3mWTd8u5O0Q==
-
-read-package-json-fast@^3.0.0:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/read-package-json-fast/-/read-package-json-fast-3.0.2.tgz#394908a9725dc7a5f14e70c8e7556dff1d2b1049"
-  integrity sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==
-  dependencies:
-    json-parse-even-better-errors "^3.0.0"
-    npm-normalize-package-bin "^3.0.0"
-
-read-package-json@6.0.4, read-package-json@^6.0.0:
-  version "6.0.4"
-  resolved "https://registry.yarnpkg.com/read-package-json/-/read-package-json-6.0.4.tgz#90318824ec456c287437ea79595f4c2854708836"
-  integrity sha512-AEtWXYfopBj2z5N5PbkAOeNHRPUg5q+Nen7QLxV8M2zJq1ym6/lCz3fYNTCXe19puu2d06jfHhrP7v/S2PtMMw==
-  dependencies:
-    glob "^10.2.2"
-    json-parse-even-better-errors "^3.0.0"
-    normalize-package-data "^5.0.0"
-    npm-normalize-package-bin "^3.0.0"
-
 read-pkg-up@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
@@ -7741,14 +5655,6 @@ read-pkg-up@^1.0.1:
     find-up "^1.0.0"
     read-pkg "^1.0.0"
 
-read-pkg-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
-  integrity sha512-YFzFrVvpC6frF1sz8psoHDBGF7fLPc+llq/8NB43oagqWkx8ar5zYtsTORtOjw9W2RHLpWP+zTWwBvf1bCmcSw==
-  dependencies:
-    find-up "^2.0.0"
-    read-pkg "^3.0.0"
-
 read-pkg-up@^7.0.1:
   version "7.0.1"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
@@ -7776,15 +5682,6 @@ read-pkg@^1.0.0:
     normalize-package-data "^2.3.2"
     path-type "^1.0.0"
 
-read-pkg@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389"
-  integrity sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==
-  dependencies:
-    load-json-file "^4.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^3.0.0"
-
 read-pkg@^5.2.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
@@ -7805,14 +5702,7 @@ read-pkg@^6.0.0:
     parse-json "^5.2.0"
     type-fest "^1.0.1"
 
-read@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/read/-/read-2.1.0.tgz#69409372c54fe3381092bc363a00650b6ac37218"
-  integrity sha512-bvxi1QLJHcaywCAEsAk4DG3nVoqiY2Csps3qzWalhj5hFqRn1d/OixkFXtLO1PrgHUcAP0FNaSY/5GYNfENFFQ==
-  dependencies:
-    mute-stream "~1.0.0"
-
-"readable-stream@2 || 3", readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.0.2, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
+"readable-stream@2 || 3", readable-stream@3, readable-stream@^3.6.0:
   version "3.6.2"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967"
   integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
@@ -7850,14 +5740,6 @@ rechoir@^0.6.2:
   dependencies:
     resolve "^1.1.6"
 
-redent@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
-  integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
-  dependencies:
-    indent-string "^4.0.0"
-    strip-indent "^3.0.0"
-
 redent@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/redent/-/redent-4.0.0.tgz#0c0ba7caabb24257ab3bb7a4fd95dd1d5c5681f9"
@@ -7971,16 +5853,16 @@ resolve-dir@^1.0.0, resolve-dir@^1.0.1:
     expand-tilde "^2.0.0"
     global-modules "^1.0.0"
 
-resolve-from@5.0.0, resolve-from@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
-  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
-
 resolve-from@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
+resolve-from@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
+  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
+
 resolve-options@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/resolve-options/-/resolve-options-1.1.0.tgz#32bb9e39c06d67338dc9378c0d6d6074566ad131"
@@ -8020,30 +5902,18 @@ ret@~0.1.10:
   resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
 
-retry@^0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b"
-  integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==
-
 reusify@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
   integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
 
-rimraf@^3.0.0, rimraf@^3.0.2:
+rimraf@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
   dependencies:
     glob "^7.1.3"
 
-rimraf@^4.4.1:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-4.4.1.tgz#bd33364f67021c5b79e93d7f4fa0568c7c21b755"
-  integrity sha512-Gk8NlF062+T9CqNGn6h4tls3k6T1+/nXdOcSZVikNVtlRdYpA7wRJJMoXmuvOnLW844rPjdQ7JgXCYM6PPC/og==
-  dependencies:
-    glob "^9.2.0"
-
 rollup@3.25.0:
   version "3.25.0"
   resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.25.0.tgz#71327d396a9decbf23c87b55916ae7204211738a"
@@ -8051,11 +5921,6 @@ rollup@3.25.0:
   optionalDependencies:
     fsevents "~2.3.2"
 
-run-async@^2.4.0:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.4.1.tgz#8440eccf99ea3e70bd409d49aab88e10c189a455"
-  integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==
-
 run-parallel@^1.1.9:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
@@ -8063,7 +5928,7 @@ run-parallel@^1.1.9:
   dependencies:
     queue-microtask "^1.2.2"
 
-rxjs@7.8.1, rxjs@^7.5.5:
+rxjs@7.8.1:
   version "7.8.1"
   resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543"
   integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==
@@ -8094,11 +5959,6 @@ safe-regex@^2.1.1:
   dependencies:
     regexp-tree "~0.1.1"
 
-"safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0":
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
-  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
-
 sax@>=0.6.0:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
@@ -8120,19 +5980,12 @@ semver-greatest-satisfied-range@^1.1.0:
   dependencies:
     sver-compat "^1.5.0"
 
-"semver@2 || 3 || 4 || 5", semver@^5.6.0:
+"semver@2 || 3 || 4 || 5":
   version "5.7.2"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
 
-semver@7.3.4:
-  version "7.3.4"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.4.tgz#27aaa7d2e4ca76452f98d3add093a72c943edc97"
-  integrity sha512-tCfb2WLjqFAtXn4KEdxIhalnRtoKFN7nAwj0B3ZXCbQloV2tq5eDbcTmT68JJD3nRJq24/XgxtQKFIpQdtvmVw==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@7.x, semver@^7.0.0, semver@^7.1.1, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
+semver@7.x, semver@^7.3.4, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
   version "7.5.4"
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
@@ -8166,13 +6019,6 @@ set-value@^2.0.0, set-value@^2.0.1:
     is-plain-object "^2.0.3"
     split-string "^3.0.1"
 
-shallow-clone@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
-  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
-  dependencies:
-    kind-of "^6.0.2"
-
 shebang-command@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
@@ -8195,7 +6041,7 @@ shiki@^0.14.1:
     vscode-oniguruma "^1.7.0"
     vscode-textmate "^8.0.0"
 
-signal-exit@3.0.7, signal-exit@^3.0.2, signal-exit@^3.0.3, signal-exit@^3.0.7:
+signal-exit@^3.0.2, signal-exit@^3.0.3, signal-exit@^3.0.7:
   version "3.0.7"
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
   integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
@@ -8205,16 +6051,6 @@ signal-exit@^4.0.1:
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.0.2.tgz#ff55bb1d9ff2114c13b400688fa544ac63c36967"
   integrity sha512-MY2/qGx4enyjprQnFaZsHib3Yadh3IXyV2C321GY0pjGfVBu4un0uDJkwgdxqO+Rdx8JMT8IfJIRwbYVz3Ob3Q==
 
-sigstore@^1.3.0, sigstore@^1.4.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/sigstore/-/sigstore-1.6.0.tgz#887a4007c6ee83f3ef3fd844be1a0840e849c301"
-  integrity sha512-QODKff/qW/TXOZI6V/Clqu74xnInAS6it05mufj4/fSewexLtfEntgLZZcBtUK44CDQyUE5TUXYy1ARYzlfG9g==
-  dependencies:
-    "@sigstore/protobuf-specs" "^0.1.0"
-    "@sigstore/tuf" "^1.0.0"
-    make-fetch-happen "^11.0.1"
-    tuf-js "^1.1.3"
-
 sirv@^1.0.7:
   version "1.0.19"
   resolved "https://registry.yarnpkg.com/sirv/-/sirv-1.0.19.tgz#1d73979b38c7fe91fcba49c85280daa9c2363b49"
@@ -8229,7 +6065,7 @@ sisteransi@^1.0.5:
   resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
   integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==
 
-slash@3.0.0, slash@^3.0.0:
+slash@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
@@ -8248,11 +6084,6 @@ slice-ansi@^4.0.0:
     astral-regex "^2.0.0"
     is-fullwidth-code-point "^3.0.0"
 
-smart-buffer@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/smart-buffer/-/smart-buffer-4.2.0.tgz#6e1d71fa4f18c05f7d0ff216dd16a481d0e8d9ae"
-  integrity sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==
-
 snapdragon-node@^2.0.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
@@ -8283,30 +6114,6 @@ snapdragon@^0.8.1:
     source-map-resolve "^0.5.0"
     use "^3.1.0"
 
-socks-proxy-agent@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/socks-proxy-agent/-/socks-proxy-agent-7.0.0.tgz#dc069ecf34436621acb41e3efa66ca1b5fed15b6"
-  integrity sha512-Fgl0YPZ902wEsAyiQ+idGd1A7rSFx/ayC1CQVMw5P+EQx2V0SgpGtf6OKFhVjPflPUl9YMmEOnmfjCdMUsygww==
-  dependencies:
-    agent-base "^6.0.2"
-    debug "^4.3.3"
-    socks "^2.6.2"
-
-socks@^2.6.2:
-  version "2.7.1"
-  resolved "https://registry.yarnpkg.com/socks/-/socks-2.7.1.tgz#d8e651247178fde79c0663043e07240196857d55"
-  integrity sha512-7maUZy1N7uo6+WVEX6psASxtNlKaNVMlGQKkG/63nEDdLOWNbiUMoLK7X4uYoLhQstau72mLgfEWcXcwsaHbYQ==
-  dependencies:
-    ip "^2.0.0"
-    smart-buffer "^4.2.0"
-
-sort-keys@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-2.0.0.tgz#658535584861ec97d730d6cf41822e1f56684128"
-  integrity sha512-/dPCrG1s3ePpWm6yBbxZq5Be1dXGLyLn9Z791chDC3NFrpkVbWGzkBwPN1knaciexFXgRJ7hzdnwZ4stHSDmjg==
-  dependencies:
-    is-plain-obj "^1.0.0"
-
 source-map-resolve@^0.5.0:
   version "0.5.3"
   resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
@@ -8400,39 +6207,11 @@ split-string@^3.0.1, split-string@^3.0.2:
   dependencies:
     extend-shallow "^3.0.0"
 
-split2@^3.2.2:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
-  integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
-  dependencies:
-    readable-stream "^3.0.0"
-
-split@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
-  integrity sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==
-  dependencies:
-    through "2"
-
 sprintf-js@~1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
   integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
 
-ssri@^10.0.0, ssri@^10.0.1:
-  version "10.0.4"
-  resolved "https://registry.yarnpkg.com/ssri/-/ssri-10.0.4.tgz#5a20af378be586df139ddb2dfb3bf992cf0daba6"
-  integrity sha512-12+IR2CB2C28MMAw0Ncqwj5QbTcs0nGIhgJzYWzDkb21vWmfNI83KS4f3Ci6GI98WreIfG7o9UXp3C0qbpA8nQ==
-  dependencies:
-    minipass "^5.0.0"
-
-ssri@^9.0.0, ssri@^9.0.1:
-  version "9.0.1"
-  resolved "https://registry.yarnpkg.com/ssri/-/ssri-9.0.1.tgz#544d4c357a8d7b71a19700074b6883fcb4eae057"
-  integrity sha512-o57Wcn66jMQvfHG1FlYbWeZWW/dHZhJXjpIcTfXldXEk5nz5lStPo3mK0OJQfGR3RbZUlbISexbljkJzuEj/8Q==
-  dependencies:
-    minipass "^3.1.1"
-
 stack-trace@0.0.10:
   version "0.0.10"
   resolved "https://registry.yarnpkg.com/stack-trace/-/stack-trace-0.0.10.tgz#547c70b347e8d32b4e108ea1a2a159e5fdde19c0"
@@ -8484,7 +6263,7 @@ string-length@^4.0.1:
     char-regex "^1.0.2"
     strip-ansi "^6.0.0"
 
-"string-width-cjs@npm:string-width@^4.2.0", "string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
+"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
   version "4.2.3"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -8558,11 +6337,6 @@ strip-bom@^2.0.0:
   dependencies:
     is-utf8 "^0.2.0"
 
-strip-bom@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
-  integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==
-
 strip-bom@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
@@ -8592,15 +6366,6 @@ strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
-strong-log-transformer@2.1.0, strong-log-transformer@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/strong-log-transformer/-/strong-log-transformer-2.1.0.tgz#0f5ed78d325e0421ac6f90f7f10e691d6ae3ae10"
-  integrity sha512-B3Hgul+z0L9a236FAUC9iZsL+nVHgoCJnqCbN588DjYxvGXaXaaFbfmQ/JhvKjZwsOukuR72XbHv71Qkug0HxA==
-  dependencies:
-    duplexer "^0.1.1"
-    minimist "^1.2.0"
-    through "^2.3.4"
-
 supports-color@^5.3.0:
   version "5.5.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
@@ -8653,41 +6418,6 @@ tapable@^2.1.1, tapable@^2.2.0:
   resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
   integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
 
-tar-stream@~2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
-  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
-  dependencies:
-    bl "^4.0.3"
-    end-of-stream "^1.4.1"
-    fs-constants "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.1.1"
-
-tar@6.1.11:
-  version "6.1.11"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-6.1.11.tgz#6760a38f003afa1b2ffd0ffe9e9abbd0eab3d621"
-  integrity sha512-an/KZQzQUkZCkuoAA64hM92X0Urb6VpRhAFllDzz44U2mcD5scmT3zBc4VgVpkugF580+DQn8eAFSyoQt0tznA==
-  dependencies:
-    chownr "^2.0.0"
-    fs-minipass "^2.0.0"
-    minipass "^3.0.0"
-    minizlib "^2.1.1"
-    mkdirp "^1.0.3"
-    yallist "^4.0.0"
-
-tar@^6.1.11, tar@^6.1.2:
-  version "6.1.15"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-6.1.15.tgz#c9738b0b98845a3b344d334b8fa3041aaba53a69"
-  integrity sha512-/zKt9UyngnxIT/EAGYuxaMYgOIJiP81ab9ZfkILq4oNLPFX50qyYmu7jRj9qeXoxmJHjGlbH0+cm2uy1WCs10A==
-  dependencies:
-    chownr "^2.0.0"
-    fs-minipass "^2.0.0"
-    minipass "^5.0.0"
-    minizlib "^2.1.1"
-    mkdirp "^1.0.3"
-    yallist "^4.0.0"
-
 teex@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/teex/-/teex-1.0.1.tgz#b8fa7245ef8e8effa8078281946c85ab780a0b12"
@@ -8695,11 +6425,6 @@ teex@^1.0.1:
   dependencies:
     streamx "^2.12.5"
 
-temp-dir@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/temp-dir/-/temp-dir-1.0.0.tgz#0a7c0ea26d3a39afa7e0ebea9c1fc0bc4daa011d"
-  integrity sha512-xZFXEGbG7SNC3itwBzI3RYjq/cEhBkx2hJuKGIUOcEULmkQExXiHat2z/qkISYsuR+IKumhEfKKbV5qXmhICFQ==
-
 terser-webpack-plugin@^5.3.7:
   version "5.3.9"
   resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz#832536999c51b46d468067f9e37662a3b96adfe1"
@@ -8730,11 +6455,6 @@ test-exclude@^6.0.0:
     glob "^7.1.4"
     minimatch "^3.0.4"
 
-text-extensions@^1.0.0:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26"
-  integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==
-
 text-table@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
@@ -8781,7 +6501,7 @@ through2@^4.0.2:
   dependencies:
     readable-stream "3"
 
-through@2, "through@>=2.2.7 <3", through@^2.3.4, through@^2.3.6, through@^2.3.8:
+through@^2.3.6, through@^2.3.8:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
@@ -8799,20 +6519,6 @@ timers-ext@^0.1.7:
     es5-ext "~0.10.46"
     next-tick "1"
 
-tmp@^0.0.33:
-  version "0.0.33"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
-  integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
-  dependencies:
-    os-tmpdir "~1.0.2"
-
-tmp@~0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14"
-  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
-  dependencies:
-    rimraf "^3.0.0"
-
 tmpl@1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc"
@@ -8875,16 +6581,6 @@ totalist@^1.0.0:
   resolved "https://registry.yarnpkg.com/totalist/-/totalist-1.1.0.tgz#a4d65a3e546517701e3e5c37a47a70ac97fe56df"
   integrity sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g==
 
-tr46@~0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
-  integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==
-
-trim-newlines@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144"
-  integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==
-
 trim-newlines@^4.0.2:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-4.1.1.tgz#28c88deb50ed10c7ba6dc2474421904a00139125"
@@ -8923,21 +6619,12 @@ ts-node@10.9.1:
     v8-compile-cache-lib "^3.0.1"
     yn "3.1.1"
 
-tsconfig-paths@^4.1.2:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz#ef78e19039133446d244beac0fd6a1632e2d107c"
-  integrity sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==
-  dependencies:
-    json5 "^2.2.2"
-    minimist "^1.2.6"
-    strip-bom "^3.0.0"
-
 tslib@^1.8.1:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
   integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
 
-tslib@^2.1.0, tslib@^2.3.0, tslib@^2.4.0, tslib@^2.5.3:
+tslib@^2.1.0, tslib@^2.3.0, tslib@^2.5.3:
   version "2.5.3"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.3.tgz#24944ba2d990940e6e982c4bea147aba80209913"
   integrity sha512-mSxlJJwl3BMEQCUNnxXBU9jP4JBktcEGhURcPR6VQVlnP0FdDEsIaz0C35dXNGLyRfrATNofF0F5p2KPxQgB+w==
@@ -8949,15 +6636,6 @@ tsutils@^3.21.0:
   dependencies:
     tslib "^1.8.1"
 
-tuf-js@^1.1.3:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/tuf-js/-/tuf-js-1.1.6.tgz#ad3e7a20237b83b51c2a8f9d1ddf093279a10fc2"
-  integrity sha512-CXwFVIsXGbVY4vFiWF7TJKWmlKJAT8TWkH4RmiohJRcDJInix++F0dznDmoVbtJNzZ8yLprKUG4YrDIhv3nBMg==
-  dependencies:
-    "@tufjs/models" "1.0.4"
-    debug "^4.3.4"
-    make-fetch-happen "^11.1.0"
-
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
@@ -8970,11 +6648,6 @@ type-detect@4.0.8:
   resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
   integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==
 
-type-fest@^0.18.0:
-  version "0.18.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f"
-  integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==
-
 type-fest@^0.20.2:
   version "0.20.2"
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
@@ -8985,11 +6658,6 @@ type-fest@^0.21.3:
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
   integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
 
-type-fest@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.4.1.tgz#8bdf77743385d8a4f13ba95f610f5ccd68c728f8"
-  integrity sha512-IwzA/LSfD2vC1/YDYMv/zHP4rDF1usCwllsDpbolT3D4fUepIO7f9K70jjmUewU/LmGUKJcwcVtDCpnKk4BPMw==
-
 type-fest@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
@@ -9030,7 +6698,7 @@ typedoc@0.24.8:
     minimatch "^9.0.0"
     shiki "^0.14.1"
 
-typescript@5.1.3, "typescript@>=3 < 6":
+typescript@5.1.3:
   version "5.1.3"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.1.3.tgz#8d84219244a6b40b6fb2b33cc1c062f715b9e826"
   integrity sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==
@@ -9045,11 +6713,6 @@ typical@^7.1.1:
   resolved "https://registry.yarnpkg.com/typical/-/typical-7.1.1.tgz#ba177ab7ab103b78534463ffa4c0c9754523ac1f"
   integrity sha512-T+tKVNs6Wu7IWiAce5BgMd7OZfNYUndHwc5MknN+UHOudi7sGZzuHdCadllRuqJ3fPtgFtIH9+lt9qRv6lmpfA==
 
-uglify-js@^3.1.4:
-  version "3.17.4"
-  resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.17.4.tgz#61678cf5fa3f5b7eb789bb345df29afb8257c22c"
-  integrity sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==
-
 unc-path-regex@^0.1.2:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/unc-path-regex/-/unc-path-regex-0.1.2.tgz#e73dd3d7b0d7c5ed86fbac6b0ae7d8c6a69d50fa"
@@ -9086,34 +6749,6 @@ union-value@^1.0.0:
     is-extendable "^0.1.1"
     set-value "^2.0.1"
 
-unique-filename@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-2.0.1.tgz#e785f8675a9a7589e0ac77e0b5c34d2eaeac6da2"
-  integrity sha512-ODWHtkkdx3IAR+veKxFV+VBkUMcN+FaqzUUd7IZzt+0zhDZFPFxhlqwPF3YQvMHx1TD0tdgYl+kuPnJ8E6ql7A==
-  dependencies:
-    unique-slug "^3.0.0"
-
-unique-filename@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-3.0.0.tgz#48ba7a5a16849f5080d26c760c86cf5cf05770ea"
-  integrity sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==
-  dependencies:
-    unique-slug "^4.0.0"
-
-unique-slug@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/unique-slug/-/unique-slug-3.0.0.tgz#6d347cf57c8a7a7a6044aabd0e2d74e4d76dc7c9"
-  integrity sha512-8EyMynh679x/0gqE9fT9oilG+qEt+ibFyqjuVTsZn1+CMxH+XLlpvr2UZx4nVcCwTpx81nICr2JQFkM+HPLq4w==
-  dependencies:
-    imurmurhash "^0.1.4"
-
-unique-slug@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/unique-slug/-/unique-slug-4.0.0.tgz#6bae6bb16be91351badd24cdce741f892a6532e3"
-  integrity sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==
-  dependencies:
-    imurmurhash "^0.1.4"
-
 unique-stream@^2.0.2:
   version "2.3.1"
   resolved "https://registry.yarnpkg.com/unique-stream/-/unique-stream-2.3.1.tgz#c65d110e9a4adf9a6c5948b28053d9a8d04cbeac"
@@ -9122,11 +6757,6 @@ unique-stream@^2.0.2:
     json-stable-stringify-without-jsonify "^1.0.1"
     through2-filter "^3.0.0"
 
-universal-user-agent@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/universal-user-agent/-/universal-user-agent-6.0.0.tgz#3381f8503b251c0d9cd21bc1de939ec9df5480ee"
-  integrity sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w==
-
 universalify@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
@@ -9140,11 +6770,6 @@ unset-value@^1.0.0:
     has-value "^0.3.1"
     isobject "^3.0.0"
 
-upath@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/upath/-/upath-2.0.1.tgz#50c73dea68d6f6b990f51d279ce6081665d61a8b"
-  integrity sha512-1uEe95xksV1O0CYKXo8vQvN1JEbtJp7lb7C5U9HMsIp6IVwntkH/oNUzyVNQSd4S1sYk2FpSSW44FqMc8qee5w==
-
 upath@^1.1.1:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894"
@@ -9180,21 +6805,11 @@ util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
-uuid@^9.0.0:
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-9.0.0.tgz#592f550650024a38ceb0c562f2f6aa435761efb5"
-  integrity sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg==
-
 v8-compile-cache-lib@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
   integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
 
-v8-compile-cache@2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
-  integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
-
 v8-to-istanbul@^9.0.1:
   version "9.1.0"
   resolved "https://registry.yarnpkg.com/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz#1b83ed4e397f58c85c266a570fc2558b5feb9265"
@@ -9211,7 +6826,7 @@ v8flags@^3.2.0:
   dependencies:
     homedir-polyfill "^1.0.1"
 
-validate-npm-package-license@3.0.4, validate-npm-package-license@^3.0.1, validate-npm-package-license@^3.0.4:
+validate-npm-package-license@^3.0.1:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
@@ -9219,20 +6834,6 @@ validate-npm-package-license@3.0.4, validate-npm-package-license@^3.0.1, validat
     spdx-correct "^3.0.0"
     spdx-expression-parse "^3.0.0"
 
-validate-npm-package-name@5.0.0, validate-npm-package-name@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-name/-/validate-npm-package-name-5.0.0.tgz#f16afd48318e6f90a1ec101377fa0384cfc8c713"
-  integrity sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==
-  dependencies:
-    builtins "^5.0.0"
-
-validate-npm-package-name@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-name/-/validate-npm-package-name-3.0.0.tgz#5fa912d81eb7d0c74afc140de7317f0ca7df437e"
-  integrity sha512-M6w37eVCMMouJ9V/sdPGnC5H4uDr73/+xdq0FBLO3TFFX1+7wiUY6Es328NN+y43tmY+doUdN9g9J21vqB7iLw==
-  dependencies:
-    builtins "^1.0.3"
-
 value-or-function@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/value-or-function/-/value-or-function-3.0.0.tgz#1c243a50b595c1be54a754bfece8563b9ff8d813"
@@ -9352,23 +6953,11 @@ watchpack@^2.4.0:
     glob-to-regexp "^0.4.1"
     graceful-fs "^4.1.2"
 
-wcwidth@^1.0.0, wcwidth@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
-  integrity sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==
-  dependencies:
-    defaults "^1.0.3"
-
 web-streams-polyfill@3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz#71c2718c52b45fd49dbeee88634b3a60ceab42a6"
   integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==
 
-webidl-conversions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
-  integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==
-
 webpack-bundle-analyzer@4.9.0:
   version "4.9.0"
   resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.9.0.tgz#fc093c4ab174fd3dcbd1c30b763f56d10141209d"
@@ -9434,14 +7023,6 @@ webpack@5.86.0:
     watchpack "^2.4.0"
     webpack-sources "^3.2.3"
 
-whatwg-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
-  integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==
-  dependencies:
-    tr46 "~0.0.3"
-    webidl-conversions "^3.0.0"
-
 which-module@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/which-module/-/which-module-1.0.0.tgz#bba63ca861948994ff307736089e3b96026c2a4f"
@@ -9454,37 +7035,18 @@ which@^1.2.14:
   dependencies:
     isexe "^2.0.0"
 
-which@^2.0.1, which@^2.0.2:
+which@^2.0.1:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
   dependencies:
     isexe "^2.0.0"
 
-which@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-3.0.1.tgz#89f1cd0c23f629a8105ffe69b8172791c87b4be1"
-  integrity sha512-XA1b62dzQzLfaEOSQFTCOd5KFf/1VSzZo7/7TUjnya6u0vGGKzU96UQBZTAThCb2j4/xjBAyii1OhRLJEivHvg==
-  dependencies:
-    isexe "^2.0.0"
-
-wide-align@^1.1.5:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.5.tgz#df1d4c206854369ecf3c9a4898f1b23fbd9d15d3"
-  integrity sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==
-  dependencies:
-    string-width "^1.0.2 || 2 || 3 || 4"
-
 word-wrap@^1.2.3:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.4.tgz#cb4b50ec9aca570abd1f52f33cd45b6c61739a9f"
   integrity sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==
 
-wordwrap@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
-  integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==
-
 wordwrapjs@^5.1.0:
   version "5.1.0"
   resolved "https://registry.yarnpkg.com/wordwrapjs/-/wordwrapjs-5.1.0.tgz#4c4d20446dcc670b14fa115ef4f8fd9947af2b3a"
@@ -9531,23 +7093,6 @@ wrappy@1:
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
 
-write-file-atomic@5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-5.0.1.tgz#68df4717c55c6fa4281a7860b4c2ba0a6d2b11e7"
-  integrity sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==
-  dependencies:
-    imurmurhash "^0.1.4"
-    signal-exit "^4.0.1"
-
-write-file-atomic@^2.4.2:
-  version "2.4.3"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-2.4.3.tgz#1fd2e9ae1df3e75b8d8c367443c692d4ca81f481"
-  integrity sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==
-  dependencies:
-    graceful-fs "^4.1.11"
-    imurmurhash "^0.1.4"
-    signal-exit "^3.0.2"
-
 write-file-atomic@^4.0.2:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-4.0.2.tgz#a9df01ae5b77858a027fd2e80768ee433555fcfd"
@@ -9556,27 +7101,6 @@ write-file-atomic@^4.0.2:
     imurmurhash "^0.1.4"
     signal-exit "^3.0.7"
 
-write-json-file@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/write-json-file/-/write-json-file-3.2.0.tgz#65bbdc9ecd8a1458e15952770ccbadfcff5fe62a"
-  integrity sha512-3xZqT7Byc2uORAatYiP3DHUUAVEkNOswEWNs9H5KXiicRTvzYzYqKjYc4G7p+8pltvAw641lVByKVtMpf+4sYQ==
-  dependencies:
-    detect-indent "^5.0.0"
-    graceful-fs "^4.1.15"
-    make-dir "^2.1.0"
-    pify "^4.0.1"
-    sort-keys "^2.0.0"
-    write-file-atomic "^2.4.2"
-
-write-pkg@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/write-pkg/-/write-pkg-4.0.0.tgz#675cc04ef6c11faacbbc7771b24c0abbf2a20039"
-  integrity sha512-v2UQ+50TNf2rNHJ8NyWttfm/EJUBWMJcx6ZTYZr6Qp52uuegWw/lBkCtCbnYZEmPRNL61m+u67dAmGxo+HTULA==
-  dependencies:
-    sort-keys "^2.0.0"
-    type-fest "^0.4.1"
-    write-json-file "^3.2.0"
-
 ws@^7.3.1:
   version "7.5.9"
   resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
@@ -9620,17 +7144,12 @@ yallist@^4.0.0:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
-yargs-parser@20.2.4:
-  version "20.2.4"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54"
-  integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==
-
-yargs-parser@21.1.1, yargs-parser@>=5.0.0-security.0, yargs-parser@^21.0.1, yargs-parser@^21.1.1:
+yargs-parser@>=5.0.0-security.0, yargs-parser@^21.0.1, yargs-parser@^21.1.1:
   version "21.1.1"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
   integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
 
-yargs-parser@^20.2.2, yargs-parser@^20.2.3, yargs-parser@^20.2.9:
+yargs-parser@^20.2.9:
   version "20.2.9"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
   integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
@@ -9643,20 +7162,7 @@ yargs-parser@^5.0.1:
     camelcase "^3.0.0"
     object.assign "^4.1.0"
 
-yargs@16.2.0, yargs@^16.2.0:
-  version "16.2.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
-  integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
-  dependencies:
-    cliui "^7.0.2"
-    escalade "^3.1.1"
-    get-caller-file "^2.0.5"
-    require-directory "^2.1.1"
-    string-width "^4.2.0"
-    y18n "^5.0.5"
-    yargs-parser "^20.2.2"
-
-yargs@^17.3.1, yargs@^17.6.2:
+yargs@^17.3.1:
   version "17.7.2"
   resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269"
   integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==

From f27dc02f4afded28ab37c1536ebc60766da232d0 Mon Sep 17 00:00:00 2001
From: Bruno Tremblay <bruno@boostao.ca>
Date: Mon, 28 Aug 2023 01:24:14 -0400
Subject: [PATCH 243/749] GH-37208: [R] Use currrently running R binary to
 compile test program (nix install) (#37225)

### Rationale for this change

See #37208.

### What changes are included in this PR?

Use the currrently running R binary to compile test program (nix install).

### Are these changes tested?

No. Installation.

### Are there any user-facing changes?

No

* Closes: #37208

Lead-authored-by: Bruno Tremblay <bruno@boostao.ca>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Neal Richardson <neal.p.richardson@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 r/tools/nixlibs.R | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 90ea868ea3491..dca277c80948c 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -197,7 +197,14 @@ compile_test_program <- function(code) {
   # Note: if we wanted to check for openssl on macOS, we'd have to set the brew
   # path as a -I directory. But since we (currently) only run this code to
   # determine whether we can download a Linux binary, it's not relevant.
-  runner <- "`R CMD config CXX17` `R CMD config CPPFLAGS` `R CMD config CXX17FLAGS` `R CMD config CXX17STD` -E -xc++"
+  runner <- paste(
+    R_CMD_config("CXX17"),
+    R_CMD_config("CPPFLAGS"),
+    R_CMD_config("CXX17FLAGS"),
+    R_CMD_config("CXX17STD"),
+    "-E",
+    "-xc++"
+  )
   suppressWarnings(system2("echo", sprintf('"%s" | %s -', code, runner), stdout = FALSE, stderr = TRUE))
 }
 

From 78b0c10cca226178cb5921c3cec3b85530f818ad Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 28 Aug 2023 23:09:19 +0900
Subject: [PATCH 244/749] GH-37406: [C++][FlightSQL] Add missing
 ArrowFlight::arrow_flight_{shared,static} dependencies (#37407)

### Rationale for this change

`ArrowFlightSql::arrow_flight_sql_shared` must depend on `ArrowFlight::arrow_flight_shared` because `arrow/flight/sql/*.h` uses ` arrow/flight/*.h` and all users must use Flight RPC API with Flight SQL API.

### What changes are included in this PR?

Add missing `{SHARED,STATIC}_INSTALL_INTERFACE_LIBS`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37406

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/flight/sql/CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/cpp/src/arrow/flight/sql/CMakeLists.txt b/cpp/src/arrow/flight/sql/CMakeLists.txt
index 0f12dbfdf90be..b0a551a2bca77 100644
--- a/cpp/src/arrow/flight/sql/CMakeLists.txt
+++ b/cpp/src/arrow/flight/sql/CMakeLists.txt
@@ -64,8 +64,12 @@ add_arrow_lib(arrow_flight_sql
               ${ARROW_VERSION_SCRIPT_FLAGS} # Defined in cpp/arrow/CMakeLists.txt
               SHARED_LINK_LIBS
               arrow_flight_shared
+              SHARED_INSTALL_INTERFACE_LIBS
+              ArrowFlight::arrow_flight_shared
               STATIC_LINK_LIBS
               arrow_flight_static
+              STATIC_INSTALL_INTERFACE_LIBS
+              ArrowFlight::arrow_flight_static
               PRIVATE_INCLUDES
               "${Protobuf_INCLUDE_DIRS}")
 

From be5ab860cb122e3c26dd55c2aa49a739089f0790 Mon Sep 17 00:00:00 2001
From: jeremyosterhoudt <jeremyosterhoudt@yahoo.com>
Date: Mon, 28 Aug 2023 08:25:47 -0700
Subject: [PATCH 245/749] GH-36078: [C#] Flight SQL implementation for C#
 (#36079)

Flight SQL implementation for C# that is compatible with the C++ and Java implementations.

Closes issue #36078
* Closes: #36078

Lead-authored-by: Jeremy Osterhoudt <jeremy.osterhoudt@ge.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 csharp/Apache.Arrow.sln                       |  12 +
 .../Apache.Arrow.Flight.Sql.csproj            |  18 +
 .../FlightSqlServer.cs                        | 389 ++++++++++++++++++
 .../Apache.Arrow.Flight.Sql/FlightSqlUtils.cs | 158 +++++++
 .../src/Apache.Arrow.Flight.Sql/SqlActions.cs |  22 +
 .../Client/FlightClient.cs                    |  20 +-
 .../FlightClientRecordBatchStreamReader.cs    |   2 +-
 .../FlightClientRecordBatchStreamWriter.cs    |   4 +-
 csharp/src/Apache.Arrow.Flight/FlightData.cs  |  53 +++
 .../FlightHandshakeRequest.cs                 |  58 +++
 .../FlightHandshakeResponse.cs                |  63 +++
 .../FlightRecordBatchStreamWriter.cs          |   4 +-
 .../Internal/FlightDataStream.cs              |   4 +-
 .../Internal/SchemaWriter.cs                  |  12 +-
 .../Server/FlightServer.cs                    |   7 +-
 .../FlightServerRecordBatchStreamReader.cs    |   7 +-
 .../FlightServerRecordBatchStreamWriter.cs    |  10 +-
 .../Internal/FlightServerImplementation.cs    |  30 +-
 .../Server/Internal/HandshakeAdapters.cs      |  40 ++
 .../Apache.Arrow.Flight.Sql.Tests.csproj      |  19 +
 .../FlightSqlServerTests.cs                   | 375 +++++++++++++++++
 .../FlightSqlTestExtensions.cs                |  27 ++
 .../FlightSqlUtilsTests.cs                    |  73 ++++
 .../TestFlightSqlSever.cs                     |  89 ++++
 .../TestFlightServer.cs                       |  16 +
 .../Apache.Arrow.Flight.Tests/FlightTests.cs  |  26 ++
 dev/release/rat_exclude_files.txt             |   2 +
 27 files changed, 1508 insertions(+), 32 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
 create mode 100644 csharp/src/Apache.Arrow.Flight.Sql/FlightSqlServer.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight.Sql/FlightSqlUtils.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight.Sql/SqlActions.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight/FlightData.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight/FlightHandshakeRequest.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight/FlightHandshakeResponse.cs
 create mode 100644 csharp/src/Apache.Arrow.Flight/Server/Internal/HandshakeAdapters.cs
 create mode 100644 csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
 create mode 100644 csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlServerTests.cs
 create mode 100644 csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlTestExtensions.cs
 create mode 100644 csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlUtilsTests.cs
 create mode 100644 csharp/test/Apache.Arrow.Flight.Sql.Tests/TestFlightSqlSever.cs

diff --git a/csharp/Apache.Arrow.sln b/csharp/Apache.Arrow.sln
index baf4bc6129598..7e7f7c6331e88 100644
--- a/csharp/Apache.Arrow.sln
+++ b/csharp/Apache.Arrow.sln
@@ -23,6 +23,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Apache.Arrow.Compression",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Apache.Arrow.Compression.Tests", "test\Apache.Arrow.Compression.Tests\Apache.Arrow.Compression.Tests.csproj", "{5D7FF380-B7DF-4752-B415-7C08C70C9F06}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Apache.Arrow.Flight.Sql.Tests", "test\Apache.Arrow.Flight.Sql.Tests\Apache.Arrow.Flight.Sql.Tests.csproj", "{DCC99EB1-4E60-4F0D-AEA9-C44A4C0C8B1D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Apache.Arrow.Flight.Sql", "src\Apache.Arrow.Flight.Sql\Apache.Arrow.Flight.Sql.csproj", "{2ADE087A-B424-4895-8CC5-10170D10BA62}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -69,6 +73,14 @@ Global
 		{5D7FF380-B7DF-4752-B415-7C08C70C9F06}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5D7FF380-B7DF-4752-B415-7C08C70C9F06}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{5D7FF380-B7DF-4752-B415-7C08C70C9F06}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DCC99EB1-4E60-4F0D-AEA9-C44A4C0C8B1D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DCC99EB1-4E60-4F0D-AEA9-C44A4C0C8B1D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DCC99EB1-4E60-4F0D-AEA9-C44A4C0C8B1D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DCC99EB1-4E60-4F0D-AEA9-C44A4C0C8B1D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2ADE087A-B424-4895-8CC5-10170D10BA62}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2ADE087A-B424-4895-8CC5-10170D10BA62}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2ADE087A-B424-4895-8CC5-10170D10BA62}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2ADE087A-B424-4895-8CC5-10170D10BA62}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
new file mode 100644
index 0000000000000..50570d628924b
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Grpc.Tools" Version="2.42.0" PrivateAssets="All" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Apache.Arrow.Flight\Apache.Arrow.Flight.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Protobuf Include="..\..\..\format\FlightSql.proto" Access="public" />
+  </ItemGroup>
+</Project>
diff --git a/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlServer.cs b/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlServer.cs
new file mode 100644
index 0000000000000..dbfc1f7c7ea49
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlServer.cs
@@ -0,0 +1,389 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Apache.Arrow.Flight.Server;
+using Apache.Arrow.Types;
+using Arrow.Flight.Protocol.Sql;
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+using Grpc.Core;
+using Microsoft.Extensions.Logging;
+
+namespace Apache.Arrow.Flight.Sql;
+
+public abstract class FlightSqlServer : FlightServer
+{
+    private ILogger<FlightSqlServer>? Logger { get; }
+    public static readonly Schema CatalogSchema = new(new List<Field> {new("catalog_name", StringType.Default, false)}, null);
+    public static readonly Schema TableTypesSchema = new(new List<Field> {new("table_type", StringType.Default, false)}, null);
+    public static readonly Schema DbSchemaFlightSchema = new(new List<Field> {new("catalog_name", StringType.Default, true), new("db_schema_name", StringType.Default, false)}, null);
+
+    public static readonly Schema PrimaryKeysSchema = new(new List<Field>
+    {
+        new("catalog_name", StringType.Default, true),
+        new("db_schema_name", StringType.Default, true),
+        new("table_name", StringType.Default, false),
+        new("column_name", StringType.Default, false),
+        new("key_sequence", Int32Type.Default, false),
+        new("key_name", StringType.Default, true)
+    }, null);
+
+    public static readonly Schema KeyImportExportSchema = new(new List<Field>
+    {
+        new("pk_catalog_name", StringType.Default, true),
+        new("pk_db_schema_name", StringType.Default, true),
+        new("pk_table_name", StringType.Default, false),
+        new("pk_column_name", StringType.Default, false),
+        new("fk_catalog_name", StringType.Default, true),
+        new("fk_db_schema_name", StringType.Default, true),
+        new("fk_table_name", StringType.Default, false),
+        new("fk_column_name", StringType.Default, false),
+        new("key_sequence", Int32Type.Default, false),
+        new("fk_key_name", StringType.Default, true),
+        new("pk_key_name", StringType.Default, true),
+        new("update_rule", UInt8Type.Default, false),
+        new("delete_rule", UInt8Type.Default, false)
+    }, null);
+
+    public static readonly Schema TypeInfoSchema = new(new List<Field>
+    {
+        new("type_name", StringType.Default, false),
+        new("data_type", Int32Type.Default, false),
+        new("column_size", Int32Type.Default, true),
+        new("literal_prefix", StringType.Default, true),
+        new("literal_suffix", StringType.Default, true),
+        new("create_params", new ListType(new Field("item", StringType.Default, false)), true),
+        new("nullable", Int32Type.Default, false),
+        new("case_sensitive", BooleanType.Default, false),
+        new("searchable", Int32Type.Default, false),
+        new("unsigned_attribute", BooleanType.Default, true),
+        new("fixed_prec_scale", BooleanType.Default, false),
+        new("auto_increment", BooleanType.Default, true),
+        new("local_type_name", StringType.Default, true),
+        new("minimum_scale", Int32Type.Default, true),
+        new("maximum_scale", Int32Type.Default, true),
+        new("sql_data_type", Int32Type.Default, false),
+        new("datetime_subcode", Int32Type.Default, true),
+        new("num_prec_radix", Int32Type.Default, true),
+        new("interval_precision", Int32Type.Default, true)
+    }, null);
+
+    public static readonly Schema SqlInfoSchema = new(new List<Field>
+    {
+        new("info_name", UInt32Type.Default, false)
+        //TODO: once we have union serialization in Arrow Flight for .Net we should to add these fields
+        // fieldList.Add(new Field("value", new UnionType(new List<Field>(), new List<byte>()), false));
+        // fieldList.Add(new Field("value", new UnionType(new []
+        // {
+        //     new Field("string_value", StringType.Default, false),
+        //     new Field("bool_value", BooleanType.Default, false),
+        //     new Field("bigint_value", Int64Type.Default, false),
+        //     new Field("bool_value", BooleanType.Default, false),
+        //     new Field("bigint_value", Int64Type.Default, false),
+        //     new Field("int32_bitmask", Int32Type.Default, false),
+        //     new Field("string_list", new ListType(new Field("item", StringType.Default, false)), false),
+        //     new Field("int32_to_int32_list_map", new DictionaryType(Int32Type.Default, new ListType(Int32Type.Default), false), false),
+        // }, new []{(byte)ArrowTypeId.String, (byte)ArrowTypeId.Boolean, (byte)ArrowTypeId.Int64,/* (byte)3, (byte)4, (byte)5*/}, UnionMode.Dense), false));
+    }, null);
+
+    private static readonly Schema s_tableSchema = new(new List<Field>
+    {
+        new("catalog_name", StringType.Default, true),
+        new("db_schema_name", StringType.Default, true),
+        new("table_name", StringType.Default, false),
+        new("table_type", StringType.Default, false)
+    }, null);
+
+    public static Schema GetTableSchema(bool includeTableSchemaField)
+    {
+        if (!includeTableSchemaField)
+        {
+            return s_tableSchema;
+        }
+
+        var fields = s_tableSchema.FieldsList.ToList();
+        fields.Add(new Field("table_schema", BinaryType.Default, false));
+
+        return new Schema(fields, s_tableSchema.Metadata);
+    }
+
+    public static IMessage? GetCommand(FlightTicket ticket)
+    {
+        try
+        {
+            return GetCommand(Any.Parser.ParseFrom(ticket.Ticket));
+        }
+        catch (InvalidProtocolBufferException) { } //The ticket is not a flight sql command
+
+        return null;
+    }
+
+    public static async Task<IMessage?> GetCommand(FlightServerRecordBatchStreamReader requestStream)
+    {
+        return GetCommand(await requestStream.FlightDescriptor.ConfigureAwait(false));
+    }
+
+    public static IMessage? GetCommand(FlightDescriptor? request)
+    {
+        if (request == null) return null;
+        if (request.Type == FlightDescriptorType.Command && request.ParsedAndUnpackedMessage() is { } command)
+        {
+            return command;
+        }
+
+        return null;
+    }
+
+    private static IMessage? GetCommand(Any command)
+    {
+        if (command.Is(CommandPreparedStatementQuery.Descriptor))
+        {
+            return command.Unpack<CommandPreparedStatementQuery>();
+        }
+
+        if (command.Is(CommandGetSqlInfo.Descriptor))
+        {
+            return command.Unpack<CommandGetSqlInfo>();
+        }
+
+        if (command.Is(CommandGetCatalogs.Descriptor))
+        {
+            return command.Unpack<CommandGetCatalogs>();
+        }
+
+        if (command.Is(CommandGetTableTypes.Descriptor))
+        {
+            return command.Unpack<CommandGetTableTypes>();
+        }
+
+        if (command.Is(CommandGetTables.Descriptor))
+        {
+            return command.Unpack<CommandGetTables>();
+        }
+
+        if (command.Is(CommandGetDbSchemas.Descriptor))
+        {
+            return command.Unpack<CommandGetDbSchemas>();
+        }
+
+        if (command.Is(CommandGetPrimaryKeys.Descriptor))
+        {
+            return command.Unpack<CommandGetPrimaryKeys>();
+        }
+
+        if (command.Is(CommandGetExportedKeys.Descriptor))
+        {
+            return command.Unpack<CommandGetExportedKeys>();
+        }
+
+        if (command.Is(CommandGetImportedKeys.Descriptor))
+        {
+            return command.Unpack<CommandGetImportedKeys>();
+        }
+
+        if (command.Is(CommandGetCrossReference.Descriptor))
+        {
+            return command.Unpack<CommandGetCrossReference>();
+        }
+
+        if (command.Is(CommandGetXdbcTypeInfo.Descriptor))
+        {
+            return command.Unpack<CommandGetXdbcTypeInfo>();
+        }
+
+        return null;
+    }
+
+    protected FlightSqlServer(ILoggerFactory? factory = null)
+    {
+        Logger = factory?.CreateLogger<FlightSqlServer>();
+    }
+
+    /// <summary>
+    /// Lists actions supported by Flight SQL.  For Flight RPC actions support
+    /// implementers should extend this method to return additional supported actions.
+    /// </summary>
+    public override async Task ListActions(IAsyncStreamWriter<FlightActionType> responseStream, ServerCallContext context)
+    {
+        foreach (var actionType in FlightSqlUtils.FlightSqlActions)
+        {
+            await responseStream.WriteAsync(actionType).ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>
+    /// Attempts to execute a valid Flight SQL command.  For Flight RPC calls
+    /// implementers should extend this method in order to handle RPC messages.
+    /// </summary>
+    public override Task<FlightInfo> GetFlightInfo(FlightDescriptor flightDescriptor, ServerCallContext context)
+    {
+        var sqlCommand = GetCommand(flightDescriptor);
+        Logger?.LogTrace("Executing Flight SQL FlightInfo command: {DescriptorName}", sqlCommand?.Descriptor.Name);
+        return sqlCommand switch
+        {
+            CommandStatementQuery command => GetStatementQueryFlightInfo(command, flightDescriptor, context),
+            CommandPreparedStatementQuery command => GetPreparedStatementQueryFlightInfo(command, flightDescriptor, context),
+            CommandGetCatalogs command => GetCatalogFlightInfo(command, flightDescriptor, context),
+            CommandGetDbSchemas command => GetDbSchemaFlightInfo(command, flightDescriptor, context),
+            CommandGetTables command => GetTablesFlightInfo(command, flightDescriptor, context),
+            CommandGetTableTypes command => GetTableTypesFlightInfo(command, flightDescriptor, context),
+            CommandGetSqlInfo command => GetSqlFlightInfo(command, flightDescriptor, context),
+            CommandGetPrimaryKeys command => GetPrimaryKeysFlightInfo(command, flightDescriptor, context),
+            CommandGetExportedKeys command => GetExportedKeysFlightInfo(command, flightDescriptor, context),
+            CommandGetImportedKeys command => GetImportedKeysFlightInfo(command, flightDescriptor, context),
+            CommandGetCrossReference command => GetCrossReferenceFlightInfo(command, flightDescriptor, context),
+            CommandGetXdbcTypeInfo command => GetXdbcTypeFlightInfo(command, flightDescriptor, context),
+            _ => throw new InvalidOperationException($"command type {sqlCommand?.Descriptor?.Name} not supported")
+        };
+    }
+
+    /// <summary>
+    /// Attempts to execute a valid Flight SQL command.  For Flight RPC calls
+    /// implementers should extend this method in order to handle RPC messages.
+    /// </summary>
+    public override Task DoGet(FlightTicket ticket, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context)
+    {
+        var sqlCommand = GetCommand(ticket);
+        Logger?.LogTrace("Executing Flight SQL DoGet command: {SqlCommandDescriptor}", sqlCommand?.Descriptor);
+        return sqlCommand switch
+        {
+            CommandPreparedStatementQuery command => DoGetPreparedStatementQuery(command, responseStream, context),
+            CommandGetSqlInfo command => DoGetSqlInfo(command, responseStream, context),
+            CommandGetCatalogs command => DoGetCatalog(command, responseStream, context),
+            CommandGetTableTypes command => DoGetTableType(command, responseStream, context),
+            CommandGetTables command => DoGetTables(command, responseStream, context),
+            CommandGetDbSchemas command => DoGetDbSchema(command, responseStream, context),
+            CommandGetPrimaryKeys command => DoGetPrimaryKeys(command, responseStream, context),
+            CommandGetExportedKeys command => DoGetExportedKeys(command, responseStream, context),
+            CommandGetImportedKeys command => DoGetImportedKeys(command, responseStream, context),
+            CommandGetCrossReference command => DoGetCrossReference(command, responseStream, context),
+            CommandGetXdbcTypeInfo command => DoGetXbdcTypeInfo(command, responseStream, context),
+            _ => throw new RpcException(new Status(StatusCode.InvalidArgument, $"DoGet command {sqlCommand?.Descriptor} is not supported."))
+        };
+    }
+
+    /// <summary>
+    /// Attempts to execute a valid Flight SQL command.  For Flight RPC calls
+    /// implementers should extend this method in order to handle RPC messages.
+    /// </summary>
+    public override Task DoAction(FlightAction action, IAsyncStreamWriter<FlightResult> responseStream, ServerCallContext context)
+    {
+        Logger?.LogTrace("Executing Flight SQL DoAction: {ActionType}", action.Type);
+        switch (action.Type)
+        {
+            case SqlAction.CreateRequest:
+                var command = FlightSqlUtils.ParseAndUnpack<ActionCreatePreparedStatementRequest>(action.Body);
+                return CreatePreparedStatement(command, action, responseStream, context);
+            case SqlAction.CloseRequest:
+                var closeCommand = FlightSqlUtils.ParseAndUnpack<ActionClosePreparedStatementRequest>(action.Body);
+                return ClosePreparedStatement(closeCommand, action, responseStream, context);
+            default:
+                throw new NotImplementedException($"Action type {action.Type} not supported");
+        }
+    }
+
+    /// <summary>
+    /// Attempts to execute a valid Flight SQL command.  For Flight RPC calls
+    /// implementers should extend this method in order to handle RPC messages.
+    /// </summary>
+    public override async Task DoPut(FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context)
+    {
+        if (await GetCommand(requestStream).ConfigureAwait(false) is { } command)
+        {
+            await DoPutInternal(command, requestStream, responseStream, context).ConfigureAwait(false);
+        }
+        else
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    private Task DoPutInternal(IMessage command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context)
+    {
+        Logger?.LogTrace("Executing Flight SQL DoAction: {DescriptorName}", command.Descriptor.Name);
+        return command switch
+        {
+            CommandStatementUpdate statementUpdate => PutStatementUpdate(statementUpdate, requestStream, responseStream, context),
+            CommandPreparedStatementQuery preparedStatementQuery => PutPreparedStatementQuery(preparedStatementQuery, requestStream, responseStream, context),
+            CommandPreparedStatementUpdate preparedStatementUpdate => PutPreparedStatementUpdate(preparedStatementUpdate, requestStream, responseStream, context),
+            _ => throw new NotImplementedException($"Command {command.Descriptor.Name} not supported")
+        };
+    }
+
+    public static bool SupportsAction(FlightAction action)
+    {
+        switch (action.Type)
+        {
+            case SqlAction.CreateRequest:
+            case SqlAction.CloseRequest:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+
+    #region FlightInfo
+
+    protected abstract Task<FlightInfo> GetStatementQueryFlightInfo(CommandStatementQuery commandStatementQuery, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetPreparedStatementQueryFlightInfo(CommandPreparedStatementQuery preparedStatementQuery, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetCatalogFlightInfo(CommandGetCatalogs command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetDbSchemaFlightInfo(CommandGetDbSchemas command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetTablesFlightInfo(CommandGetTables command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetTableTypesFlightInfo(CommandGetTableTypes command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetSqlFlightInfo(CommandGetSqlInfo commandGetSqlInfo, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetPrimaryKeysFlightInfo(CommandGetPrimaryKeys command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetExportedKeysFlightInfo(CommandGetExportedKeys command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetImportedKeysFlightInfo(CommandGetImportedKeys command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetCrossReferenceFlightInfo(CommandGetCrossReference command, FlightDescriptor flightDescriptor, ServerCallContext context);
+    protected abstract Task<FlightInfo> GetXdbcTypeFlightInfo(CommandGetXdbcTypeInfo command, FlightDescriptor flightDescriptor, ServerCallContext context);
+
+    #endregion
+
+    #region DoGet
+
+    protected abstract Task DoGetPreparedStatementQuery(CommandPreparedStatementQuery preparedStatementQuery, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetSqlInfo(CommandGetSqlInfo getSqlInfo, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetCatalog(CommandGetCatalogs command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetTableType(CommandGetTableTypes command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetTables(CommandGetTables command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetPrimaryKeys(CommandGetPrimaryKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetDbSchema(CommandGetDbSchemas command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetExportedKeys(CommandGetExportedKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetImportedKeys(CommandGetImportedKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetCrossReference(CommandGetCrossReference command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+    protected abstract Task DoGetXbdcTypeInfo(CommandGetXdbcTypeInfo command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context);
+
+    #endregion
+
+    #region DoAction
+
+    protected abstract Task CreatePreparedStatement(ActionCreatePreparedStatementRequest request, FlightAction action, IAsyncStreamWriter<FlightResult> streamWriter, ServerCallContext context);
+    protected abstract Task ClosePreparedStatement(ActionClosePreparedStatementRequest request, FlightAction action, IAsyncStreamWriter<FlightResult> streamWriter, ServerCallContext context);
+
+    #endregion
+
+    #region DoPut
+
+    protected abstract Task PutPreparedStatementUpdate(CommandPreparedStatementUpdate command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context);
+    protected abstract Task PutStatementUpdate(CommandStatementUpdate command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context);
+    protected abstract Task PutPreparedStatementQuery(CommandPreparedStatementQuery command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context);
+
+    #endregion
+}
diff --git a/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlUtils.cs b/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlUtils.cs
new file mode 100644
index 0000000000000..295fe4d32a9f6
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight.Sql/FlightSqlUtils.cs
@@ -0,0 +1,158 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using Arrow.Flight.Protocol.Sql;
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+namespace Apache.Arrow.Flight.Sql
+{
+    /// <summary>
+    /// Helper methods for doing common Flight Sql tasks and conversions
+    /// </summary>
+    public class FlightSqlUtils
+    {
+        public static readonly FlightActionType FlightSqlCreatePreparedStatement = new("CreatePreparedStatement",
+            "Creates a reusable prepared statement resource on the server. \n" +
+            "Request Message: ActionCreatePreparedStatementRequest\n" +
+            "Response Message: ActionCreatePreparedStatementResult");
+
+        public static readonly FlightActionType FlightSqlClosePreparedStatement = new("ClosePreparedStatement",
+            "Closes a reusable prepared statement resource on the server. \n" +
+            "Request Message: ActionClosePreparedStatementRequest\n" +
+            "Response Message: N/A");
+
+        /// <summary>
+        /// List of possible actions
+        /// </summary>
+        public static readonly List<FlightActionType> FlightSqlActions = new()
+        {
+            FlightSqlCreatePreparedStatement,
+            FlightSqlClosePreparedStatement
+        };
+
+        /// <summary>
+        /// Helper to parse {@link com.google.protobuf.Any} objects to the specific protobuf object.
+        /// </summary>
+        /// <param name="source">the raw bytes source value.</param>
+        /// <returns>the materialized protobuf object.</returns>
+        public static Any Parse(ByteString source)
+        {
+            return Any.Parser.ParseFrom(source);
+        }
+
+        /// <summary>
+        /// Helper to unpack {@link com.google.protobuf.Any} objects to the specific protobuf object.
+        /// </summary>
+        /// <param name="source">the parsed Source value.</param>
+        /// <typeparam name="T">IMessage</typeparam>
+        /// <returns>the materialized protobuf object.</returns>
+        public static T Unpack<T>(Any source) where T : IMessage, new()
+        {
+            return source.Unpack<T>();
+        }
+
+        /// <summary>
+        /// Helper to parse and unpack {@link com.google.protobuf.Any} objects to the specific protobuf object.
+        /// </summary>
+        /// <param name="source">the raw bytes source value.</param>
+        /// <typeparam name="T">IMessage</typeparam>
+        /// <returns>the materialized protobuf object.</returns>
+        public static T ParseAndUnpack<T>(ByteString source) where T : IMessage, new()
+        {
+            return Unpack<T>(Parse(source));
+        }
+    }
+
+    /// <summary>
+    /// A set of helper functions for converting encoded commands to IMessage types
+    /// </summary>
+    public static class FlightSqlExtensions
+    {
+        private static Any ParsedCommand(this FlightDescriptor descriptor)
+        {
+            return FlightSqlUtils.Parse(descriptor.Command);
+        }
+
+        private static IMessage UnpackMessage(this Any command)
+        {
+            if (command.Is(CommandStatementQuery.Descriptor))
+                return FlightSqlUtils.Unpack<CommandStatementQuery>(command);
+            if (command.Is(CommandPreparedStatementQuery.Descriptor))
+                return FlightSqlUtils.Unpack<CommandPreparedStatementQuery>(command);
+            if (command.Is(CommandGetCatalogs.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetCatalogs>(command);
+            if (command.Is(CommandGetDbSchemas.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetDbSchemas>(command);
+            if (command.Is(CommandGetTables.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetTables>(command);
+            if (command.Is(CommandGetTableTypes.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetTableTypes>(command);
+            if (command.Is(CommandGetSqlInfo.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetSqlInfo>(command);
+            if (command.Is(CommandGetPrimaryKeys.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetPrimaryKeys>(command);
+            if (command.Is(CommandGetExportedKeys.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetExportedKeys>(command);
+            if (command.Is(CommandGetImportedKeys.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetImportedKeys>(command);
+            if (command.Is(CommandGetCrossReference.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetCrossReference>(command);
+            if (command.Is(CommandGetXdbcTypeInfo.Descriptor))
+                return FlightSqlUtils.Unpack<CommandGetXdbcTypeInfo>(command);
+            if (command.Is(TicketStatementQuery.Descriptor))
+                return FlightSqlUtils.Unpack<TicketStatementQuery>(command);
+            if (command.Is(TicketStatementQuery.Descriptor))
+                return FlightSqlUtils.Unpack<TicketStatementQuery>(command);
+            if (command.Is(CommandStatementUpdate.Descriptor))
+                return FlightSqlUtils.Unpack<CommandStatementUpdate>(command);
+            if (command.Is(CommandPreparedStatementUpdate.Descriptor))
+                return FlightSqlUtils.Unpack<CommandPreparedStatementUpdate>(command);
+            if (command.Is(CommandPreparedStatementQuery.Descriptor))
+                return FlightSqlUtils.Unpack<CommandPreparedStatementQuery>(command);
+
+            throw new ArgumentException("The defined request is invalid.");
+        }
+
+        /// <summary>
+        /// Extracts a command from a FlightDescriptor
+        /// </summary>
+        /// <param name="descriptor"></param>
+        /// <returns>An IMessage that has been parsed and unpacked</returns>
+        public static IMessage? ParsedAndUnpackedMessage(this FlightDescriptor descriptor)
+        {
+            try
+            {
+                return descriptor.ParsedCommand().UnpackMessage();
+            }
+            catch (ArgumentException)
+            {
+                return null;
+            }
+        }
+
+        public static ByteString Serialize(this IBufferMessage message)
+        {
+            int size = message.CalculateSize();
+            var writer = new ArrayBufferWriter<byte>(size);
+            message.WriteTo(writer);
+            var schemaBytes = writer.WrittenSpan;
+            return ByteString.CopyFrom(schemaBytes);
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow.Flight.Sql/SqlActions.cs b/csharp/src/Apache.Arrow.Flight.Sql/SqlActions.cs
new file mode 100644
index 0000000000000..f3f3bef1e1d00
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight.Sql/SqlActions.cs
@@ -0,0 +1,22 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Apache.Arrow.Flight.Sql;
+
+public static class SqlAction
+{
+    public const string CreateRequest = "CreatePreparedStatement";
+    public const string CloseRequest = "ClosePreparedStatement";
+}
diff --git a/csharp/src/Apache.Arrow.Flight/Client/FlightClient.cs b/csharp/src/Apache.Arrow.Flight/Client/FlightClient.cs
index 8140e06493dc2..5dc0d1b434b6d 100644
--- a/csharp/src/Apache.Arrow.Flight/Client/FlightClient.cs
+++ b/csharp/src/Apache.Arrow.Flight/Client/FlightClient.cs
@@ -13,11 +13,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using Apache.Arrow.Flight.Internal;
 using Apache.Arrow.Flight.Protocol;
+using Apache.Arrow.Flight.Server;
+using Apache.Arrow.Flight.Server.Internal;
 using Grpc.Core;
 using Grpc.Net.Client;
 
@@ -93,6 +93,22 @@ public FlightRecordBatchDuplexStreamingCall StartPut(FlightDescriptor flightDesc
                 channels.Dispose);
         }
 
+        public AsyncDuplexStreamingCall<FlightHandshakeRequest, FlightHandshakeResponse> Handshake(Metadata headers = null)
+        {
+            var channel = _client.Handshake(headers);
+            var readStream = new StreamReader<HandshakeResponse, FlightHandshakeResponse>(channel.ResponseStream, response => new FlightHandshakeResponse(response));
+            var writeStream = new FlightHandshakeStreamWriterAdapter(channel.RequestStream);
+            var call = new AsyncDuplexStreamingCall<FlightHandshakeRequest, FlightHandshakeResponse>(
+                writeStream,
+                readStream,
+                channel.ResponseHeadersAsync,
+                channel.GetStatus,
+                channel.GetTrailers,
+                channel.Dispose);
+
+            return call;
+        }
+
         public AsyncServerStreamingCall<FlightResult> DoAction(FlightAction action, Metadata headers = null)
         {
             var stream = _client.DoAction(action.ToProtocol(), headers);
diff --git a/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamReader.cs b/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamReader.cs
index 011af0c831508..73094338be4cd 100644
--- a/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamReader.cs
+++ b/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamReader.cs
@@ -21,7 +21,7 @@ namespace Apache.Arrow.Flight.Client
 {
     public class FlightClientRecordBatchStreamReader : FlightRecordBatchStreamReader
     {
-        internal FlightClientRecordBatchStreamReader(IAsyncStreamReader<FlightData> flightDataStream) : base(flightDataStream)
+        internal FlightClientRecordBatchStreamReader(IAsyncStreamReader<Protocol.FlightData> flightDataStream) : base(flightDataStream)
         {
         }
     }
diff --git a/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamWriter.cs b/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamWriter.cs
index d2e62c42e8621..e5fa30c9f6aed 100644
--- a/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamWriter.cs
+++ b/csharp/src/Apache.Arrow.Flight/Client/FlightClientRecordBatchStreamWriter.cs
@@ -25,9 +25,9 @@ namespace Apache.Arrow.Flight.Client
 {
     public class FlightClientRecordBatchStreamWriter : FlightRecordBatchStreamWriter, IClientStreamWriter<RecordBatch>
     {
-        private readonly IClientStreamWriter<FlightData> _clientStreamWriter;
+        private readonly IClientStreamWriter<Protocol.FlightData> _clientStreamWriter;
         private bool _completed = false;
-        internal FlightClientRecordBatchStreamWriter(IClientStreamWriter<FlightData> clientStreamWriter, FlightDescriptor flightDescriptor) : base(clientStreamWriter, flightDescriptor)
+        internal FlightClientRecordBatchStreamWriter(IClientStreamWriter<Protocol.FlightData> clientStreamWriter, FlightDescriptor flightDescriptor) : base(clientStreamWriter, flightDescriptor)
         {
             _clientStreamWriter = clientStreamWriter;
         }
diff --git a/csharp/src/Apache.Arrow.Flight/FlightData.cs b/csharp/src/Apache.Arrow.Flight/FlightData.cs
new file mode 100644
index 0000000000000..f38b1de2206a8
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight/FlightData.cs
@@ -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.
+
+using Google.Protobuf;
+
+namespace Apache.Arrow.Flight;
+
+public class FlightData
+{
+    public FlightDescriptor Descriptor { get; }
+    public ByteString AppMetadata { get; }
+    public ByteString DataBody { get; }
+    public ByteString DataHeader { get; }
+
+    public FlightData(FlightDescriptor descriptor, ByteString dataBody = null, ByteString dataHeader = null, ByteString appMetadata = null)
+    {
+        Descriptor = descriptor;
+        DataBody = dataBody;
+        DataHeader = dataHeader;
+        AppMetadata = appMetadata;
+    }
+
+    internal FlightData(Protocol.FlightData protocolFlightData)
+    {
+        Descriptor = protocolFlightData.FlightDescriptor == null ? null : new FlightDescriptor(protocolFlightData.FlightDescriptor);
+        DataBody = protocolFlightData.DataBody;
+        DataHeader = protocolFlightData.DataHeader;
+        AppMetadata = protocolFlightData.AppMetadata;
+    }
+
+    internal Protocol.FlightData ToProtocol()
+    {
+        return new Protocol.FlightData
+        {
+            FlightDescriptor = Descriptor?.ToProtocol(),
+            AppMetadata = AppMetadata,
+            DataBody = DataBody,
+            DataHeader = DataHeader
+        };
+    }
+}
diff --git a/csharp/src/Apache.Arrow.Flight/FlightHandshakeRequest.cs b/csharp/src/Apache.Arrow.Flight/FlightHandshakeRequest.cs
new file mode 100644
index 0000000000000..62db6446072a4
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight/FlightHandshakeRequest.cs
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Google.Protobuf;
+
+namespace Apache.Arrow.Flight;
+
+public class FlightHandshakeRequest
+{
+    private readonly Protocol.HandshakeRequest _result;
+    public ByteString Payload => _result.Payload;
+    public ulong ProtocolVersion => _result.ProtocolVersion;
+
+    internal FlightHandshakeRequest(Protocol.HandshakeRequest result)
+    {
+        _result = result;
+    }
+
+    public FlightHandshakeRequest(ByteString payload, ulong protocolVersion = 1)
+    {
+        _result = new Protocol.HandshakeRequest
+        {
+            Payload = payload,
+            ProtocolVersion = protocolVersion
+        };
+    }
+
+    internal Protocol.HandshakeRequest ToProtocol()
+    {
+        return _result;
+    }
+
+    public override bool Equals(object obj)
+    {
+        if(obj is FlightHandshakeRequest other)
+        {
+            return Equals(_result, other._result);
+        }
+        return false;
+    }
+
+    public override int GetHashCode()
+    {
+        return _result.GetHashCode();
+    }
+}
diff --git a/csharp/src/Apache.Arrow.Flight/FlightHandshakeResponse.cs b/csharp/src/Apache.Arrow.Flight/FlightHandshakeResponse.cs
new file mode 100644
index 0000000000000..4ceb288f8eda1
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight/FlightHandshakeResponse.cs
@@ -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.
+
+using Google.Protobuf;
+
+namespace Apache.Arrow.Flight;
+
+public class FlightHandshakeResponse
+{
+    public static readonly FlightHandshakeResponse Empty = new FlightHandshakeResponse();
+    private readonly Protocol.HandshakeResponse _handshakeResponse;
+
+    public ulong ProtocolVersion
+    {
+        get => _handshakeResponse.ProtocolVersion;
+        set => _handshakeResponse.ProtocolVersion = value;
+    }
+
+    public ByteString Payload
+    {
+        get => _handshakeResponse.Payload;
+        set => _handshakeResponse.Payload = value;
+    }
+
+    public FlightHandshakeResponse()
+    {
+        _handshakeResponse = new Protocol.HandshakeResponse
+        {
+            ProtocolVersion = 1
+        };
+    }
+
+    internal FlightHandshakeResponse(Protocol.HandshakeResponse handshakeResponse)
+    {
+        _handshakeResponse = handshakeResponse;
+    }
+
+    public FlightHandshakeResponse(ByteString payload, ulong protocolVersion = 1)
+    {
+        _handshakeResponse = new Protocol.HandshakeResponse
+        {
+            ProtocolVersion = protocolVersion,
+            Payload = payload
+        };
+    }
+
+    internal Protocol.HandshakeResponse ToProtocol()
+    {
+        return _handshakeResponse;
+    }
+}
diff --git a/csharp/src/Apache.Arrow.Flight/FlightRecordBatchStreamWriter.cs b/csharp/src/Apache.Arrow.Flight/FlightRecordBatchStreamWriter.cs
index a72be5a823403..f76f08224541f 100644
--- a/csharp/src/Apache.Arrow.Flight/FlightRecordBatchStreamWriter.cs
+++ b/csharp/src/Apache.Arrow.Flight/FlightRecordBatchStreamWriter.cs
@@ -27,12 +27,12 @@ namespace Apache.Arrow.Flight
     public abstract class FlightRecordBatchStreamWriter : IAsyncStreamWriter<RecordBatch>, IDisposable
     {
         private FlightDataStream _flightDataStream;
-        private readonly IAsyncStreamWriter<FlightData> _clientStreamWriter;
+        private readonly IAsyncStreamWriter<Protocol.FlightData> _clientStreamWriter;
         private readonly FlightDescriptor _flightDescriptor;
 
         private bool _disposed;
 
-        private protected FlightRecordBatchStreamWriter(IAsyncStreamWriter<FlightData> clientStreamWriter, FlightDescriptor flightDescriptor)
+        private protected FlightRecordBatchStreamWriter(IAsyncStreamWriter<Protocol.FlightData> clientStreamWriter, FlightDescriptor flightDescriptor)
         {
             _clientStreamWriter = clientStreamWriter;
             _flightDescriptor = flightDescriptor;
diff --git a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
index 3211212c99cb9..72c1551be2917 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/FlightDataStream.cs
@@ -34,10 +34,10 @@ namespace Apache.Arrow.Flight.Internal
     internal class FlightDataStream : ArrowStreamWriter
     {
         private readonly FlightDescriptor _flightDescriptor;
-        private readonly IAsyncStreamWriter<FlightData> _clientStreamWriter;
+        private readonly IAsyncStreamWriter<Protocol.FlightData> _clientStreamWriter;
         private Protocol.FlightData _currentFlightData;
 
-        public FlightDataStream(IAsyncStreamWriter<FlightData> clientStreamWriter, FlightDescriptor flightDescriptor, Schema schema)
+        public FlightDataStream(IAsyncStreamWriter<Protocol.FlightData> clientStreamWriter, FlightDescriptor flightDescriptor, Schema schema)
             : base(new MemoryStream(), schema)
         {
             _clientStreamWriter = clientStreamWriter;
diff --git a/csharp/src/Apache.Arrow.Flight/Internal/SchemaWriter.cs b/csharp/src/Apache.Arrow.Flight/Internal/SchemaWriter.cs
index c7e7d8135a1dd..be27cb1e39161 100644
--- a/csharp/src/Apache.Arrow.Flight/Internal/SchemaWriter.cs
+++ b/csharp/src/Apache.Arrow.Flight/Internal/SchemaWriter.cs
@@ -20,6 +20,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Apache.Arrow.Flatbuf;
+using Apache.Arrow.Flight.Internal;
 using Apache.Arrow.Ipc;
 using Google.Protobuf;
 
@@ -30,7 +31,7 @@ namespace Apache.Arrow.Flight.Internal
     /// </summary>
     internal class SchemaWriter : ArrowStreamWriter
     {
-        private SchemaWriter(Stream baseStream, Schema schema) : base(baseStream, schema)
+        internal SchemaWriter(Stream baseStream, Schema schema) : base(baseStream, schema)
         {
         }
 
@@ -53,3 +54,12 @@ public void WriteSchema(Schema schema, CancellationToken cancellationToken)
         }
     }
 }
+
+public static class SchemaExtension
+{
+    // Translate an Apache.Arrow.Schema to FlatBuffer Schema to ByteString
+    public static ByteString ToByteString(this Apache.Arrow.Schema schema)
+    {
+        return SchemaWriter.SerializeSchema(schema);
+    }
+}
diff --git a/csharp/src/Apache.Arrow.Flight/Server/FlightServer.cs b/csharp/src/Apache.Arrow.Flight/Server/FlightServer.cs
index 30b0409d422fb..0005caf175f67 100644
--- a/csharp/src/Apache.Arrow.Flight/Server/FlightServer.cs
+++ b/csharp/src/Apache.Arrow.Flight/Server/FlightServer.cs
@@ -14,8 +14,6 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Threading.Tasks;
 using Grpc.Core;
 
@@ -57,5 +55,10 @@ public virtual Task<FlightInfo> GetFlightInfo(FlightDescriptor request, ServerCa
         {
             throw new NotImplementedException();
         }
+
+        public virtual Task Handshake(IAsyncStreamReader<FlightHandshakeRequest> requestStream, IAsyncStreamWriter<FlightHandshakeResponse> responseStream, ServerCallContext context)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamReader.cs b/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamReader.cs
index 5476d3d0e5ff9..c52b761ad38d9 100644
--- a/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamReader.cs
+++ b/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamReader.cs
@@ -14,7 +14,6 @@
 // limitations under the License.
 
 using System.Threading.Tasks;
-using Apache.Arrow.Flight.Protocol;
 using Apache.Arrow.Flight.Internal;
 using Grpc.Core;
 
@@ -22,7 +21,11 @@ namespace Apache.Arrow.Flight.Server
 {
     public class FlightServerRecordBatchStreamReader : FlightRecordBatchStreamReader
     {
-        internal FlightServerRecordBatchStreamReader(IAsyncStreamReader<FlightData> flightDataStream) : base(flightDataStream)
+        public FlightServerRecordBatchStreamReader(IAsyncStreamReader<FlightData> flightDataStream) : base(new StreamReader<FlightData, Protocol.FlightData>(flightDataStream, data => data.ToProtocol()))
+        {
+        }
+
+        internal FlightServerRecordBatchStreamReader(IAsyncStreamReader<Protocol.FlightData> flightDataStream) : base(flightDataStream)
         {
         }
 
diff --git a/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamWriter.cs b/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamWriter.cs
index 6c1987339bdf3..7d1c89ea3df2a 100644
--- a/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamWriter.cs
+++ b/csharp/src/Apache.Arrow.Flight/Server/FlightServerRecordBatchStreamWriter.cs
@@ -13,10 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System;
-using System.Collections.Generic;
-using System.Text;
-using Apache.Arrow.Flight.Protocol;
 using Apache.Arrow.Flight.Internal;
 using Grpc.Core;
 
@@ -24,7 +20,11 @@ namespace Apache.Arrow.Flight.Server
 {
     public class FlightServerRecordBatchStreamWriter : FlightRecordBatchStreamWriter, IServerStreamWriter<RecordBatch>
     {
-        internal FlightServerRecordBatchStreamWriter(IServerStreamWriter<FlightData> clientStreamWriter) : base(clientStreamWriter, null)
+        public FlightServerRecordBatchStreamWriter(IServerStreamWriter<FlightData> clientStreamWriter) : base(new StreamWriter<Protocol.FlightData, FlightData>(clientStreamWriter, data => new FlightData(data)), null)
+        {
+        }
+
+        internal FlightServerRecordBatchStreamWriter(IServerStreamWriter<Protocol.FlightData> clientStreamWriter) : base(clientStreamWriter, null)
         {
         }
     }
diff --git a/csharp/src/Apache.Arrow.Flight/Server/Internal/FlightServerImplementation.cs b/csharp/src/Apache.Arrow.Flight/Server/Internal/FlightServerImplementation.cs
index dcf6e57681894..f34ffaf92fc81 100644
--- a/csharp/src/Apache.Arrow.Flight/Server/Internal/FlightServerImplementation.cs
+++ b/csharp/src/Apache.Arrow.Flight/Server/Internal/FlightServerImplementation.cs
@@ -14,12 +14,9 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
-using System.Text;
 using System.Threading.Tasks;
 using Apache.Arrow.Flight.Internal;
 using Apache.Arrow.Flight.Protocol;
-using Apache.Arrow.Flight.Server;
 using Grpc.Core;
 
 namespace Apache.Arrow.Flight.Server.Internal
@@ -35,21 +32,26 @@ public FlightServerImplementation(FlightServer flightServer)
             _flightServer = flightServer;
         }
 
-        public override async Task DoPut(IAsyncStreamReader<FlightData> requestStream, IServerStreamWriter<Protocol.PutResult> responseStream, ServerCallContext context)
+        public override async Task DoPut(IAsyncStreamReader<Protocol.FlightData> requestStream, IServerStreamWriter<Protocol.PutResult> responseStream, ServerCallContext context)
         {
             var readStream = new FlightServerRecordBatchStreamReader(requestStream);
-            var writeStream = new StreamWriter<FlightPutResult, Protocol.PutResult>(responseStream, putResult => putResult.ToProtocol());
+            var writeStream = new StreamWriter<FlightPutResult, PutResult>(responseStream, putResult => putResult.ToProtocol());
+
             await _flightServer.DoPut(readStream, writeStream, context).ConfigureAwait(false);
         }
 
-        public override Task DoGet(Protocol.Ticket request, IServerStreamWriter<FlightData> responseStream, ServerCallContext context)
+        public override Task DoGet(Protocol.Ticket request, IServerStreamWriter<Protocol.FlightData> responseStream, ServerCallContext context)
         {
-            return _flightServer.DoGet(new FlightTicket(request.Ticket_), new FlightServerRecordBatchStreamWriter(responseStream), context);
+            var flightTicket = new FlightTicket(request.Ticket_);
+            var flightServerRecordBatchStreamWriter = new FlightServerRecordBatchStreamWriter(responseStream);
+
+            return _flightServer.DoGet(flightTicket, flightServerRecordBatchStreamWriter, context);
         }
 
         public override Task ListFlights(Protocol.Criteria request, IServerStreamWriter<Protocol.FlightInfo> responseStream, ServerCallContext context)
         {
             var writeStream = new StreamWriter<FlightInfo, Protocol.FlightInfo>(responseStream, flightInfo => flightInfo.ToProtocol());
+
             return _flightServer.ListFlights(new FlightCriteria(request), writeStream, context);
         }
 
@@ -57,6 +59,7 @@ public override Task DoAction(Protocol.Action request, IServerStreamWriter<Proto
         {
             var action = new FlightAction(request);
             var writeStream = new StreamWriter<FlightResult, Protocol.Result>(responseStream, result => result.ToProtocol());
+
             return _flightServer.DoAction(action, writeStream, context);
         }
 
@@ -74,12 +77,12 @@ public override async Task<SchemaResult> GetSchema(Protocol.FlightDescriptor req
         public override async Task<Protocol.FlightInfo> GetFlightInfo(Protocol.FlightDescriptor request, ServerCallContext context)
         {
             var flightDescriptor = new FlightDescriptor(request);
-            var flightInfo = await _flightServer.GetFlightInfo(flightDescriptor, context).ConfigureAwait(false);
+            FlightInfo flightInfo = await _flightServer.GetFlightInfo(flightDescriptor, context).ConfigureAwait(false);
 
             return flightInfo.ToProtocol();
         }
 
-        public override Task DoExchange(IAsyncStreamReader<FlightData> requestStream, IServerStreamWriter<FlightData> responseStream, ServerCallContext context)
+        public override Task DoExchange(IAsyncStreamReader<Protocol.FlightData> requestStream, IServerStreamWriter<Protocol.FlightData> responseStream, ServerCallContext context)
         {
             //Exchange is not yet implemented
             throw new NotImplementedException();
@@ -87,14 +90,15 @@ public override Task DoExchange(IAsyncStreamReader<FlightData> requestStream, IS
 
         public override Task Handshake(IAsyncStreamReader<HandshakeRequest> requestStream, IServerStreamWriter<HandshakeResponse> responseStream, ServerCallContext context)
         {
-            //Handshake is not yet implemented
-            throw new NotImplementedException();
+            var readStream = new StreamReader<HandshakeRequest, FlightHandshakeRequest>(requestStream, request => new FlightHandshakeRequest(request));
+            var writeStream = new StreamWriter<FlightHandshakeResponse, Protocol.HandshakeResponse>(responseStream, result => result.ToProtocol());
+            return _flightServer.Handshake(readStream, writeStream, context);
         }
 
-        public override Task ListActions(Empty request, IServerStreamWriter<Protocol.ActionType> responseStream, ServerCallContext context)
+        public override async Task ListActions(Empty request, IServerStreamWriter<Protocol.ActionType> responseStream, ServerCallContext context)
         {
             var writeStream = new StreamWriter<FlightActionType, Protocol.ActionType>(responseStream, (actionType) => actionType.ToProtocol());
-            return _flightServer.ListActions(writeStream, context);
+            await _flightServer.ListActions(writeStream, context).ConfigureAwait(false);
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow.Flight/Server/Internal/HandshakeAdapters.cs b/csharp/src/Apache.Arrow.Flight/Server/Internal/HandshakeAdapters.cs
new file mode 100644
index 0000000000000..40ac3bebf1b19
--- /dev/null
+++ b/csharp/src/Apache.Arrow.Flight/Server/Internal/HandshakeAdapters.cs
@@ -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.
+
+using System.Threading.Tasks;
+using Apache.Arrow.Flight.Protocol;
+using Grpc.Core;
+
+namespace Apache.Arrow.Flight.Server.Internal;
+
+internal class FlightHandshakeStreamWriterAdapter : IClientStreamWriter<FlightHandshakeRequest>
+{
+    private readonly IClientStreamWriter<HandshakeRequest> _writeStream;
+
+    public FlightHandshakeStreamWriterAdapter(IClientStreamWriter<HandshakeRequest> writeStream)
+    {
+        _writeStream = writeStream;
+    }
+
+    public Task WriteAsync(FlightHandshakeRequest message) => _writeStream.WriteAsync(message.ToProtocol());
+
+    public WriteOptions WriteOptions
+    {
+        get => _writeStream.WriteOptions;
+        set => _writeStream.WriteOptions = value;
+    }
+
+    public Task CompleteAsync() => _writeStream.CompleteAsync();
+}
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
new file mode 100644
index 0000000000000..07e341eb27ab2
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+      <TargetFramework>net7.0</TargetFramework>
+      <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+      <PackageReference Include="xunit" Version="2.4.0" />
+      <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+      <PackageReference Include="coverlet.collector" Version="1.2.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\..\src\Apache.Arrow.Flight.Sql\Apache.Arrow.Flight.Sql.csproj" />
+    </ItemGroup>
+
+</Project>
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlServerTests.cs b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlServerTests.cs
new file mode 100644
index 0000000000000..4ad5bde0874a8
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlServerTests.cs
@@ -0,0 +1,375 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Apache.Arrow.Flight.Server;
+using Apache.Arrow.Types;
+using Arrow.Flight.Protocol.Sql;
+using Google.Protobuf;
+using Grpc.Core;
+using Xunit;
+
+namespace Apache.Arrow.Flight.Sql.Tests;
+
+public class FlightSqlServerTests
+{
+    [Theory]
+    [InlineData(FlightDescriptorType.Path, null)]
+    [InlineData(FlightDescriptorType.Command, null)]
+    [InlineData(FlightDescriptorType.Command, typeof(CommandGetCatalogs))]
+    public void EnsureGetCommandReturnsTheCorrectResponse(FlightDescriptorType type, Type? expectedResult)
+    {
+        //Given
+        FlightDescriptor descriptor;
+        if (type == FlightDescriptorType.Command)
+        {
+            descriptor = expectedResult != null ?
+                FlightDescriptor.CreateCommandDescriptor(((IMessage) Activator.CreateInstance(expectedResult!)!).PackAndSerialize().ToByteArray()) :
+                FlightDescriptor.CreateCommandDescriptor(ByteString.Empty.ToStringUtf8());
+        }
+        else
+        {
+            descriptor = FlightDescriptor.CreatePathDescriptor(System.Array.Empty<string>());
+        }
+
+        //When
+        var result = FlightSqlServer.GetCommand(descriptor);
+
+        //Then
+        Assert.Equal(expectedResult, result?.GetType());
+    }
+
+    [Fact]
+    public async Task EnsureTheCorrectActionsAreGiven()
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+        var streamWriter = new MockServerStreamWriter<FlightActionType>();
+
+        //When
+        await producer.ListActions(streamWriter, new MockServerCallContext()).ConfigureAwait(false);
+        var actions = streamWriter.Messages.ToArray();
+
+        Assert.Equal(FlightSqlUtils.FlightSqlActions, actions);
+    }
+
+    [Theory]
+    [InlineData(false,
+        new[] {"catalog_name", "db_schema_name", "table_name", "table_type"},
+        new[] {typeof(StringType), typeof(StringType), typeof(StringType), typeof(StringType)},
+        new[] {true, true, false, false})
+    ]
+    [InlineData(true,
+        new[] {"catalog_name", "db_schema_name", "table_name", "table_type", "table_schema"},
+        new[] {typeof(StringType), typeof(StringType), typeof(StringType), typeof(StringType), typeof(BinaryType)},
+        new[] {true, true, false, false, false})
+    ]
+    public void EnsureTableSchemaIsCorrectWithoutTableSchema(bool includeTableSchemaField, string[] expectedNames, Type[] expectedTypes, bool[] expectedIsNullable)
+    {
+        // Arrange
+
+        // Act
+        var schema = FlightSqlServer.GetTableSchema(includeTableSchemaField);
+        var fields = schema.FieldsList;
+
+        //Assert
+        Assert.False(schema.HasMetadata);
+        Assert.Equal(expectedNames.Length, fields.Count);
+        for (int i = 0; i < fields.Count; i++)
+        {
+            Assert.Equal(expectedNames[i], fields[i].Name);
+            Assert.Equal(expectedTypes[i], fields[i].DataType.GetType());
+            Assert.Equal(expectedIsNullable[i], fields[i].IsNullable);
+        }
+    }
+
+    #region FlightInfoTests
+    [Theory]
+    [InlineData(typeof(CommandStatementQuery), "GetStatementQueryFlightInfo")]
+    [InlineData(typeof(CommandPreparedStatementQuery), "GetPreparedStatementQueryFlightInfo")]
+    [InlineData(typeof(CommandGetCatalogs), "GetCatalogFlightInfo")]
+    [InlineData(typeof(CommandGetDbSchemas), "GetDbSchemaFlightInfo")]
+    [InlineData(typeof(CommandGetTables), "GetTablesFlightInfo")]
+    [InlineData(typeof(CommandGetTableTypes), "GetTableTypesFlightInfo")]
+    [InlineData(typeof(CommandGetSqlInfo), "GetSqlFlightInfo")]
+    [InlineData(typeof(CommandGetPrimaryKeys), "GetPrimaryKeysFlightInfo")]
+    [InlineData(typeof(CommandGetExportedKeys), "GetExportedKeysFlightInfo")]
+    [InlineData(typeof(CommandGetImportedKeys), "GetImportedKeysFlightInfo")]
+    [InlineData(typeof(CommandGetCrossReference), "GetCrossReferenceFlightInfo")]
+    [InlineData(typeof(CommandGetXdbcTypeInfo), "GetXdbcTypeFlightInfo")]
+    public async void EnsureGetFlightInfoIsCorrectlyRoutedForCommand(Type commandType, string expectedResult)
+    {
+        //Given
+        var command = (IMessage) Activator.CreateInstance(commandType)!;
+        var producer = new TestFlightSqlSever();
+        var descriptor = FlightDescriptor.CreateCommandDescriptor(command.PackAndSerialize().ToArray());
+
+        //When
+        var flightInfo = await producer.GetFlightInfo(descriptor, new MockServerCallContext());
+
+        //Then
+        Assert.Equal(expectedResult, flightInfo.Descriptor.Paths.First());
+    }
+
+
+    [Fact]
+    public async void EnsureAnInvalidOperationExceptionIsThrownWhenACommandIsNotSupportedAndHasNoDescriptor()
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+
+        //When
+        async Task<FlightInfo> Act() => await producer.GetFlightInfo(FlightDescriptor.CreatePathDescriptor(""), new MockServerCallContext());
+        var exception = await Record.ExceptionAsync(Act);
+
+        //Then
+        Assert.Equal("command type  not supported", exception?.Message);
+    }
+
+    [Fact]
+    public async void EnsureAnInvalidOperationExceptionIsThrownWhenACommandIsNotSupported()
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+        var command = new CommandPreparedStatementUpdate();
+        var descriptor = FlightDescriptor.CreateCommandDescriptor(command.PackAndSerialize().ToArray());
+
+        //When
+        async Task<FlightInfo> Act() => await producer.GetFlightInfo(descriptor, new MockServerCallContext());
+        var exception = await Record.ExceptionAsync(Act);
+
+        //Then
+        Assert.Equal("command type CommandPreparedStatementUpdate not supported", exception?.Message);
+    }
+    #endregion
+
+    #region DoGetTests
+
+    [Theory]
+    [InlineData(typeof(CommandPreparedStatementQuery), "DoGetPreparedStatementQuery")]
+    [InlineData(typeof(CommandGetSqlInfo), "DoGetSqlInfo")]
+    [InlineData(typeof(CommandGetCatalogs), "DoGetCatalog")]
+    [InlineData(typeof(CommandGetTableTypes), "DoGetTableType")]
+    [InlineData(typeof(CommandGetTables), "DoGetTables")]
+    [InlineData(typeof(CommandGetDbSchemas), "DoGetDbSchema")]
+    [InlineData(typeof(CommandGetPrimaryKeys), "DoGetPrimaryKeys")]
+    [InlineData(typeof(CommandGetExportedKeys), "DoGetExportedKeys")]
+    [InlineData(typeof(CommandGetImportedKeys), "DoGetImportedKeys")]
+    [InlineData(typeof(CommandGetCrossReference), "DoGetCrossReference")]
+    [InlineData(typeof(CommandGetXdbcTypeInfo), "DoGetXbdcTypeInfo")]
+    public async void EnsureDoGetIsCorrectlyRoutedForADoGetCommand(Type commandType, string expectedResult)
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+        var command = (IMessage) Activator.CreateInstance(commandType)!;
+        var ticket = new FlightTicket(command.PackAndSerialize());
+        var streamWriter = new MockServerStreamWriter<FlightData>();
+
+        //When
+        await producer.DoGet(ticket, new FlightServerRecordBatchStreamWriter(streamWriter), new MockServerCallContext());
+        var schema = await streamWriter.Messages.GetSchema();
+
+        //Then
+        Assert.Equal(expectedResult, schema.FieldsList[0].Name);
+    }
+
+    [Fact]
+    public async void EnsureAnInvalidOperationExceptionIsThrownWhenADoGetCommandIsNotSupported()
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+        var ticket = new FlightTicket("");
+        var streamWriter = new MockServerStreamWriter<FlightData>();
+
+        //When
+        async Task Act() => await producer.DoGet(ticket, new FlightServerRecordBatchStreamWriter(streamWriter), new MockServerCallContext());
+        var exception = await Record.ExceptionAsync(Act);
+
+        //Then
+        Assert.Equal("Status(StatusCode=\"InvalidArgument\", Detail=\"DoGet command  is not supported.\")", exception?.Message);
+    }
+    #endregion
+
+    #region DoActionTests
+    [Theory]
+    [InlineData(SqlAction.CloseRequest, typeof(ActionClosePreparedStatementRequest), "ClosePreparedStatement")]
+    [InlineData(SqlAction.CreateRequest, typeof(ActionCreatePreparedStatementRequest), "CreatePreparedStatement")]
+    [InlineData("BadCommand", typeof(ActionCreatePreparedStatementRequest), "Action type BadCommand not supported", true)]
+    public async void EnsureDoActionIsCorrectlyRoutedForAnActionRequest(string actionType, Type actionBodyType, string expectedResponse, bool isException = false)
+    {
+        //Given
+        var producer = new TestFlightSqlSever();
+        var actionBody = (IMessage) Activator.CreateInstance(actionBodyType)!;
+        var action = new FlightAction(actionType, actionBody.PackAndSerialize());
+        var mockStreamWriter = new MockStreamWriter<FlightResult>();
+
+        //When
+        async Task Act() => await producer.DoAction(action, mockStreamWriter, new MockServerCallContext());
+        var exception = await Record.ExceptionAsync(Act);
+        string? actualMessage = isException ? exception?.Message : mockStreamWriter.Messages[0].Body.ToStringUtf8();
+
+        //Then
+        Assert.Equal(expectedResponse, actualMessage);
+    }
+    #endregion
+
+    #region DoPutTests
+    [Theory]
+    [InlineData(typeof(CommandStatementUpdate), "PutStatementUpdate")]
+    [InlineData(typeof(CommandPreparedStatementQuery), "PutPreparedStatementQuery")]
+    [InlineData(typeof(CommandPreparedStatementUpdate), "PutPreparedStatementUpdate")]
+    [InlineData(typeof(CommandGetXdbcTypeInfo), "Command CommandGetXdbcTypeInfo not supported", true)]
+    public async void EnsureDoPutIsCorrectlyRoutedForTheCommand(Type commandType, string expectedResponse, bool isException = false)
+    {
+        //Given
+        var command = (IMessage) Activator.CreateInstance(commandType)!;
+        var producer = new TestFlightSqlSever();
+        var descriptor = FlightDescriptor.CreateCommandDescriptor(command.PackAndSerialize().ToArray());
+        var recordBatch = new RecordBatch(new Schema(new List<Field>(), null), System.Array.Empty<Int8Array>(), 0);
+        var reader = new MockStreamReader<FlightData>(await recordBatch.ToFlightData(descriptor).ConfigureAwait(false));
+        var batchReader = new FlightServerRecordBatchStreamReader(reader);
+        var mockStreamWriter = new MockServerStreamWriter<FlightPutResult>();
+
+        //When
+        async Task Act() => await producer.DoPut(batchReader, mockStreamWriter, new MockServerCallContext()).ConfigureAwait(false);
+        var exception = await Record.ExceptionAsync(Act);
+        string? actualMessage = isException ? exception?.Message : mockStreamWriter.Messages[0].ApplicationMetadata.ToStringUtf8();
+
+        //Then
+        Assert.Equal(expectedResponse, actualMessage);
+    }
+    #endregion
+
+    private class MockServerCallContext : ServerCallContext
+    {
+        protected override Task WriteResponseHeadersAsyncCore(Metadata responseHeaders) => throw new NotImplementedException();
+
+        protected override ContextPropagationToken CreatePropagationTokenCore(ContextPropagationOptions? options) => throw new NotImplementedException();
+        protected override string MethodCore => "";
+        protected override string HostCore => "";
+        protected override string PeerCore => "";
+        protected override DateTime DeadlineCore => new();
+        protected override Metadata RequestHeadersCore => new();
+        protected override CancellationToken CancellationTokenCore => default;
+        protected override Metadata ResponseTrailersCore => new();
+        protected override Status StatusCore { get; set; }
+        protected override WriteOptions WriteOptionsCore { get; set; } = WriteOptions.Default;
+        protected override AuthContext AuthContextCore => new("", new Dictionary<string, List<AuthProperty>>());
+    }
+}
+
+internal class MockStreamWriter<T> : IServerStreamWriter<T>
+{
+    public Task WriteAsync(T message)
+    {
+        _messages.Add(message);
+        return Task.FromResult(message);
+    }
+
+    public IReadOnlyList<T> Messages => new ReadOnlyCollection<T>(_messages);
+    public WriteOptions? WriteOptions { get; set; }
+    private readonly List<T> _messages = new();
+}
+
+internal class MockServerStreamWriter<T> : IServerStreamWriter<T>
+{
+    public Task WriteAsync(T message)
+    {
+        _messages.Add(message);
+        return Task.FromResult(message);
+    }
+
+    public IReadOnlyList<T> Messages => new ReadOnlyCollection<T>(_messages);
+    public WriteOptions? WriteOptions { get; set; }
+    private readonly List<T> _messages = new();
+}
+
+internal static class MockStreamReaderWriterExtensions
+{
+    public static async Task<List<RecordBatch>> GetRecordBatches(this IReadOnlyList<FlightData> flightDataList)
+    {
+        var list = new List<RecordBatch>();
+        var recordBatchReader = new FlightServerRecordBatchStreamReader(new MockStreamReader<FlightData>(flightDataList));
+        while (await recordBatchReader.MoveNext().ConfigureAwait(false))
+        {
+            list.Add(recordBatchReader.Current);
+        }
+
+        return list;
+    }
+
+    public static async Task<Schema> GetSchema(this IEnumerable<FlightData> flightDataList)
+    {
+        var recordBatchReader = new FlightServerRecordBatchStreamReader(new MockStreamReader<FlightData>(flightDataList));
+        return await recordBatchReader.Schema;
+    }
+
+    public static async Task<IEnumerable<FlightData>> ToFlightData(this RecordBatch recordBatch, FlightDescriptor? descriptor = null)
+    {
+        var responseStream = new MockFlightServerRecordBatchStreamWriter();
+        await responseStream.WriteRecordBatchAsync(recordBatch).ConfigureAwait(false);
+        if (descriptor == null)
+        {
+            return responseStream.FlightData;
+        }
+
+        return responseStream.FlightData.Select(
+            flightData => new FlightData(descriptor, flightData.DataBody, flightData.DataHeader, flightData.AppMetadata)
+            );
+    }
+}
+
+internal class MockStreamReader<T>: IAsyncStreamReader<T>
+{
+    private readonly IEnumerator<T> _flightActions;
+
+    public MockStreamReader(IEnumerable<T> flightActions)
+    {
+        _flightActions = flightActions.GetEnumerator();
+    }
+
+    public Task<bool> MoveNext(CancellationToken cancellationToken)
+    {
+        return Task.FromResult(_flightActions.MoveNext());
+    }
+
+    public T Current => _flightActions.Current;
+}
+
+internal class MockFlightServerRecordBatchStreamWriter : FlightServerRecordBatchStreamWriter
+{
+    private readonly MockStreamWriter<FlightData> _streamWriter;
+    public MockFlightServerRecordBatchStreamWriter() : this(new MockStreamWriter<FlightData>()) { }
+
+    private MockFlightServerRecordBatchStreamWriter(MockStreamWriter<FlightData> clientStreamWriter) : base(clientStreamWriter)
+    {
+        _streamWriter = clientStreamWriter;
+    }
+
+    public IEnumerable<FlightData> FlightData => _streamWriter.Messages;
+
+    public async Task WriteRecordBatchAsync(RecordBatch recordBatch)
+    {
+        await WriteAsync(recordBatch).ConfigureAwait(false);
+    }
+}
+
+
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlTestExtensions.cs b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlTestExtensions.cs
new file mode 100644
index 0000000000000..031495fffdcc7
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlTestExtensions.cs
@@ -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.
+
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+
+namespace Apache.Arrow.Flight.Sql.Tests;
+
+public static class FlightSqlTestExtensions
+{
+    public static ByteString PackAndSerialize(this IMessage command)
+    {
+        return Any.Pack(command).Serialize();
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlUtilsTests.cs b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlUtilsTests.cs
new file mode 100644
index 0000000000000..3ea7a8d3f0463
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/FlightSqlUtilsTests.cs
@@ -0,0 +1,73 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Arrow.Flight.Protocol.Sql;
+using Google.Protobuf;
+using Google.Protobuf.WellKnownTypes;
+using Xunit;
+
+namespace Apache.Arrow.Flight.Sql.Tests
+{
+    public class FlightSqlUtilsTests
+    {
+        [Fact]
+        public void EnsureParseCanCorrectlyReviveTheCommand()
+        {
+            //Given
+            var expectedCommand = new CommandStatementQuery
+            {
+                Query = "select * from database"
+            };
+
+            //When
+            var command = FlightSqlUtils.Parse(Any.Pack(expectedCommand).ToByteString());
+
+            //Then
+            Assert.Equal(command.Unpack<CommandStatementQuery>(), expectedCommand);
+        }
+
+        [Fact]
+        public void EnsureUnpackCanCreateTheCorrectObject()
+        {
+            //Given
+            var expectedCommand = new CommandPreparedStatementQuery
+            {
+                PreparedStatementHandle = ByteString.Empty
+            };
+
+            //When
+            var command = FlightSqlUtils.Unpack<CommandPreparedStatementQuery>(Any.Pack(expectedCommand));
+
+            //Then
+            Assert.Equal(command, expectedCommand);
+        }
+
+        [Fact]
+        public void EnsureParseAndUnpackProducesTheCorrectObject()
+        {
+            //Given
+            var expectedCommand = new CommandPreparedStatementQuery
+            {
+                PreparedStatementHandle = ByteString.Empty
+            };
+
+            //When
+            var command = FlightSqlUtils.ParseAndUnpack<CommandPreparedStatementQuery>(Any.Pack(expectedCommand).ToByteString());
+
+            //Then
+            Assert.Equal(command, expectedCommand);
+        }
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/TestFlightSqlSever.cs b/csharp/test/Apache.Arrow.Flight.Sql.Tests/TestFlightSqlSever.cs
new file mode 100644
index 0000000000000..3dca632b5b761
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/TestFlightSqlSever.cs
@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+using Apache.Arrow.Flight.Server;
+using Apache.Arrow.Types;
+using Arrow.Flight.Protocol.Sql;
+using Grpc.Core;
+
+namespace Apache.Arrow.Flight.Sql.Tests;
+
+public class TestFlightSqlSever : FlightSqlServer
+{
+    protected override Task<FlightInfo> GetStatementQueryFlightInfo(CommandStatementQuery commandStatementQuery, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetPreparedStatementQueryFlightInfo(CommandPreparedStatementQuery preparedStatementQuery, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetCatalogFlightInfo(CommandGetCatalogs command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetDbSchemaFlightInfo(CommandGetDbSchemas command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetTablesFlightInfo(CommandGetTables command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetTableTypesFlightInfo(CommandGetTableTypes command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetSqlFlightInfo(CommandGetSqlInfo commandGetSqlInfo, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetPrimaryKeysFlightInfo(CommandGetPrimaryKeys command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetExportedKeysFlightInfo(CommandGetExportedKeys command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetImportedKeysFlightInfo(CommandGetImportedKeys command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetCrossReferenceFlightInfo(CommandGetCrossReference command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override Task<FlightInfo> GetXdbcTypeFlightInfo(CommandGetXdbcTypeInfo command, FlightDescriptor flightDescriptor, ServerCallContext serverCallContext) => Task.FromResult(new FlightInfo(null, FlightDescriptor.CreatePathDescriptor(MethodBase.GetCurrentMethod().Name), System.Array.Empty<FlightEndpoint>()));
+
+    protected override async Task DoGetPreparedStatementQuery(CommandPreparedStatementQuery preparedStatementQuery, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetPreparedStatementQuery"));
+
+    protected override async Task DoGetSqlInfo(CommandGetSqlInfo getSqlInfo, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetSqlInfo"));
+
+    protected override async Task DoGetCatalog(CommandGetCatalogs command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetCatalog"));
+
+    protected override async Task DoGetTableType(CommandGetTableTypes command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetTableType"));
+
+    protected override async Task DoGetTables(CommandGetTables command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetTables"));
+
+    protected override async Task DoGetPrimaryKeys(CommandGetPrimaryKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetPrimaryKeys"));
+
+    protected override async Task DoGetDbSchema(CommandGetDbSchemas command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetDbSchema"));
+
+    protected override async Task DoGetExportedKeys(CommandGetExportedKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetExportedKeys"));
+
+    protected override async Task DoGetImportedKeys(CommandGetImportedKeys command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetImportedKeys"));
+
+    protected override async Task DoGetCrossReference(CommandGetCrossReference command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetCrossReference"));
+
+    protected override async Task DoGetXbdcTypeInfo(CommandGetXdbcTypeInfo command, FlightServerRecordBatchStreamWriter responseStream, ServerCallContext context) => await responseStream.WriteAsync(MockRecordBatch("DoGetXbdcTypeInfo"));
+
+    protected override async Task CreatePreparedStatement(ActionCreatePreparedStatementRequest request, FlightAction action, IAsyncStreamWriter<FlightResult> streamWriter, ServerCallContext serverCallContext) => await streamWriter.WriteAsync(new FlightResult("CreatePreparedStatement"));
+
+    protected override async Task ClosePreparedStatement(ActionClosePreparedStatementRequest request, FlightAction action, IAsyncStreamWriter<FlightResult> streamWriter, ServerCallContext serverCallContext) => await streamWriter.WriteAsync(new FlightResult("ClosePreparedStatement"));
+
+    protected override async Task PutPreparedStatementUpdate(CommandPreparedStatementUpdate command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context) => await responseStream.WriteAsync(new FlightPutResult("PutPreparedStatementUpdate"));
+
+    protected override async Task PutStatementUpdate(CommandStatementUpdate command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context) => await responseStream.WriteAsync(new FlightPutResult("PutStatementUpdate"));
+
+    protected override async Task PutPreparedStatementQuery(CommandPreparedStatementQuery command, FlightServerRecordBatchStreamReader requestStream, IAsyncStreamWriter<FlightPutResult> responseStream, ServerCallContext context) => await responseStream.WriteAsync(new FlightPutResult("PutPreparedStatementQuery"));
+
+    private RecordBatch MockRecordBatch(string name)
+    {
+        var schema = new Schema(new List<Field> {new(name, StringType.Default, false)}, System.Array.Empty<KeyValuePair<string, string>>());
+        return new RecordBatch(schema, new []{ new StringArray.Builder().Append(name).Build() }, 1);
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Flight.TestWeb/TestFlightServer.cs b/csharp/test/Apache.Arrow.Flight.TestWeb/TestFlightServer.cs
index ae6e2e4b03b6d..a613b04a32002 100644
--- a/csharp/test/Apache.Arrow.Flight.TestWeb/TestFlightServer.cs
+++ b/csharp/test/Apache.Arrow.Flight.TestWeb/TestFlightServer.cs
@@ -18,6 +18,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Apache.Arrow.Flight.Server;
+using Google.Protobuf;
 using Grpc.Core;
 using Grpc.Core.Utils;
 
@@ -86,6 +87,21 @@ public override Task<FlightInfo> GetFlightInfo(FlightDescriptor request, ServerC
             throw new RpcException(new Status(StatusCode.NotFound, "Flight not found"));
         }
 
+        public override async Task Handshake(IAsyncStreamReader<FlightHandshakeRequest> requestStream, IAsyncStreamWriter<FlightHandshakeResponse> responseStream, ServerCallContext context)
+        {
+            while (await requestStream.MoveNext().ConfigureAwait(false))
+            {
+                if (requestStream.Current.Payload.ToStringUtf8() == "Hello")
+                {
+                    await responseStream.WriteAsync(new(ByteString.CopyFromUtf8("Hello handshake"))).ConfigureAwait(false);
+                }
+                else
+                {
+                    await responseStream.WriteAsync(new(ByteString.CopyFromUtf8("Done"))).ConfigureAwait(false);
+                }
+            }
+        }
+
         public override Task<Schema> GetSchema(FlightDescriptor request, ServerCallContext context)
         {
             if(_flightStore.Flights.TryGetValue(request, out var flightHolder))
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/FlightTests.cs b/csharp/test/Apache.Arrow.Flight.Tests/FlightTests.cs
index 3556c6a17feef..267fe4e4b606d 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/FlightTests.cs
+++ b/csharp/test/Apache.Arrow.Flight.Tests/FlightTests.cs
@@ -283,6 +283,32 @@ public async Task TestListFlights()
             }
         }
 
+        [Fact]
+        public async Task TestHandshake()
+        {
+            var duplexStreamingCall = _flightClient.Handshake();
+
+            await duplexStreamingCall.RequestStream.WriteAsync(new FlightHandshakeRequest(ByteString.Empty)).ConfigureAwait(false);
+            await duplexStreamingCall.RequestStream.CompleteAsync().ConfigureAwait(false);
+            var results = await duplexStreamingCall.ResponseStream.ToListAsync().ConfigureAwait(false);
+
+            Assert.Single(results);
+            Assert.Equal("Done", results.First().Payload.ToStringUtf8());
+        }
+
+        [Fact]
+        public async Task TestHandshakeWithSpecificMessage()
+        {
+            var duplexStreamingCall = _flightClient.Handshake();
+
+            await duplexStreamingCall.RequestStream.WriteAsync(new FlightHandshakeRequest(ByteString.CopyFromUtf8("Hello"))).ConfigureAwait(false);
+            await duplexStreamingCall.RequestStream.CompleteAsync().ConfigureAwait(false);
+            var results = await duplexStreamingCall.ResponseStream.ToListAsync().ConfigureAwait(false);
+
+            Assert.Single(results);
+            Assert.Equal("Hello handshake", results.First().Payload.ToStringUtf8());
+        }
+
         [Fact]
         public async Task TestGetBatchesWithAsyncEnumerable()
         {
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index 7bdb692d048e9..aebe321d613ab 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -113,8 +113,10 @@ csharp/src/Apache.Arrow/Properties/Resources.resx
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
 csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
 csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
+csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
 csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
 csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
 csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
 csharp/test/Apache.Arrow.IntegrationTest/Apache.Arrow.IntegrationTest.csproj
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj

From b83fa18a82ccee770a74f15e88f450706b0add4c Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 28 Aug 2023 23:28:41 +0800
Subject: [PATCH 246/749] GH-37268: [C++] adding move in some ctor in fs and
 dataset (#37264)

### Rationale for this change

Fix some typo and add move in some ctor in fs and dataset.

### What changes are included in this PR?

Some minor fix.

### Are these changes tested?

No

### Are there any user-facing changes?

No

* Closes: #37268

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 cpp/src/arrow/dataset/scan_node.cc     | 3 ++-
 cpp/src/arrow/filesystem/filesystem.cc | 4 +++-
 cpp/src/arrow/filesystem/filesystem.h  | 4 ++--
 cpp/src/arrow/io/caching.h             | 4 ++--
 cpp/src/arrow/util/async_util.h        | 3 ++-
 cpp/src/arrow/util/thread_pool.h       | 2 +-
 6 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/dataset/scan_node.cc b/cpp/src/arrow/dataset/scan_node.cc
index 46cc1dc6c8c3f..5ed6eee5ddf83 100644
--- a/cpp/src/arrow/dataset/scan_node.cc
+++ b/cpp/src/arrow/dataset/scan_node.cc
@@ -20,6 +20,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "arrow/acero/exec_plan.h"
@@ -125,7 +126,7 @@ class ScanNode : public acero::ExecNode, public acero::TracedNode {
            std::shared_ptr<Schema> output_schema)
       : acero::ExecNode(plan, {}, {}, std::move(output_schema)),
         acero::TracedNode(this),
-        options_(options) {}
+        options_(std::move(options)) {}
 
   static Result<ScanV2Options> NormalizeAndValidate(const ScanV2Options& options,
                                                     compute::ExecContext* ctx) {
diff --git a/cpp/src/arrow/filesystem/filesystem.cc b/cpp/src/arrow/filesystem/filesystem.cc
index 6296dd8d85d22..9ecc4610f3864 100644
--- a/cpp/src/arrow/filesystem/filesystem.cc
+++ b/cpp/src/arrow/filesystem/filesystem.cc
@@ -498,7 +498,9 @@ Result<std::string> SubTreeFileSystem::PathFromUri(const std::string& uri_string
 
 SlowFileSystem::SlowFileSystem(std::shared_ptr<FileSystem> base_fs,
                                std::shared_ptr<io::LatencyGenerator> latencies)
-    : FileSystem(base_fs->io_context()), base_fs_(base_fs), latencies_(latencies) {}
+    : FileSystem(base_fs->io_context()),
+      base_fs_(std::move(base_fs)),
+      latencies_(std::move(latencies)) {}
 
 SlowFileSystem::SlowFileSystem(std::shared_ptr<FileSystem> base_fs,
                                double average_latency)
diff --git a/cpp/src/arrow/filesystem/filesystem.h b/cpp/src/arrow/filesystem/filesystem.h
index cfadaeb0ce1fb..559f1335f12c1 100644
--- a/cpp/src/arrow/filesystem/filesystem.h
+++ b/cpp/src/arrow/filesystem/filesystem.h
@@ -325,8 +325,8 @@ class ARROW_EXPORT FileSystem : public std::enable_shared_from_this<FileSystem>
   Result<std::shared_ptr<io::OutputStream>> OpenAppendStream(const std::string& path);
 
  protected:
-  explicit FileSystem(const io::IOContext& io_context = io::default_io_context())
-      : io_context_(io_context) {}
+  explicit FileSystem(io::IOContext io_context = io::default_io_context())
+      : io_context_(std::move(io_context)) {}
 
   io::IOContext io_context_;
   // Whether metadata operations (such as GetFileInfo or OpenInputStream)
diff --git a/cpp/src/arrow/io/caching.h b/cpp/src/arrow/io/caching.h
index 93f8873d63fe1..9c1b8fe88b3bd 100644
--- a/cpp/src/arrow/io/caching.h
+++ b/cpp/src/arrow/io/caching.h
@@ -113,11 +113,11 @@ class ARROW_EXPORT ReadRangeCache {
   /// Construct a read cache with given options
   explicit ReadRangeCache(std::shared_ptr<RandomAccessFile> file, IOContext ctx,
                           CacheOptions options)
-      : ReadRangeCache(file, file.get(), ctx, options) {}
+      : ReadRangeCache(file, file.get(), std::move(ctx), options) {}
 
   /// Construct a read cache with an unowned file
   ReadRangeCache(RandomAccessFile* file, IOContext ctx, CacheOptions options)
-      : ReadRangeCache(NULLPTR, file, ctx, options) {}
+      : ReadRangeCache(NULLPTR, file, std::move(ctx), options) {}
 
   ~ReadRangeCache();
 
diff --git a/cpp/src/arrow/util/async_util.h b/cpp/src/arrow/util/async_util.h
index db03719f5e84c..7a675da59facd 100644
--- a/cpp/src/arrow/util/async_util.h
+++ b/cpp/src/arrow/util/async_util.h
@@ -383,7 +383,8 @@ bool AsyncTaskScheduler::AddAsyncGenerator(std::function<Future<T>()> generator,
           std::unique_ptr<AsyncTaskGroup> task_group, std::string_view name)
         : generator(std::move(generator)),
           visitor(std::move(visitor)),
-          task_group(std::move(task_group)) {}
+          task_group(std::move(task_group)),
+          name(name) {}
     std::function<Future<T>()> generator;
     std::function<Status(const T&)> visitor;
     std::unique_ptr<AsyncTaskGroup> task_group;
diff --git a/cpp/src/arrow/util/thread_pool.h b/cpp/src/arrow/util/thread_pool.h
index eba79fc05d7e0..44b1e227b0e5f 100644
--- a/cpp/src/arrow/util/thread_pool.h
+++ b/cpp/src/arrow/util/thread_pool.h
@@ -291,7 +291,7 @@ class ARROW_EXPORT SerialExecutor : public Executor {
   /// The TopLevelTask (or one of the tasks it schedules) must either return an invalid
   /// status or call the finish signal. Failure to do this will result in a deadlock.  For
   /// this reason it is preferable (if possible) to use the helper methods (below)
-  /// RunSynchronously/RunSerially which delegates the responsiblity onto a Future
+  /// RunSynchronously/RunSerially which delegates the responsibility onto a Future
   /// producer's existing responsibility to always mark a future finished (which can
   /// someday be aided by ARROW-12207).
   template <typename T = internal::Empty, typename FT = Future<T>,

From 8dc19979d588bb7408fafb374daf4aada11ce2b3 Mon Sep 17 00:00:00 2001
From: Frederic Branczyk <fbranczyk@gmail.com>
Date: Mon, 28 Aug 2023 17:53:24 +0200
Subject: [PATCH 247/749] GH-37306: [Go] Add binary dictionary unifier (#37309)

The "generic" dictionary unifier is fine for starting out, but causes unnecessary CPU cycles because of the `getvalFn` returning `interface{}` and the ramifications of it.

Fixes #37306

### Rationale for this change

See #37306

### What changes are included in this PR?

An optimized version of a unifier for binary dictionaries.

### Are these changes tested?

Tested by using it within [Parca](https://github.com/parca-dev/parca).

### Are there any user-facing changes?

This is a new API.
* Closes: #37306

Authored-by: Frederic Branczyk <fbranczyk@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/dictionary.go      | 129 ++++++++++++++++++++++++++++++
 go/arrow/array/dictionary_test.go |  49 ++++++++++++
 2 files changed, 178 insertions(+)

diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index 06978244d8f31..30bdc23c375b5 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -1674,6 +1674,135 @@ func (u *unifier) GetResultWithIndexType(indexType arrow.DataType) (arrow.Array,
 	return MakeFromData(dictData), nil
 }
 
+type binaryUnifier struct {
+	mem       memory.Allocator
+	memoTable *hashing.BinaryMemoTable
+}
+
+// NewBinaryDictionaryUnifier constructs and returns a new dictionary unifier for dictionaries
+// of binary values, using the provided allocator for allocating the unified dictionary
+// and the memotable used for building it.
+func NewBinaryDictionaryUnifier(alloc memory.Allocator) DictionaryUnifier {
+	return &binaryUnifier{
+		mem:       alloc,
+		memoTable: hashing.NewBinaryMemoTable(0, 0, NewBinaryBuilder(alloc, arrow.BinaryTypes.Binary)),
+	}
+}
+
+func (u *binaryUnifier) Release() {
+	u.memoTable.Release()
+}
+
+func (u *binaryUnifier) Unify(dict arrow.Array) (err error) {
+	if !arrow.TypeEqual(arrow.BinaryTypes.Binary, dict.DataType()) {
+		return fmt.Errorf("dictionary type different from unifier: %s, expected: %s", dict.DataType(), arrow.BinaryTypes.Binary)
+	}
+
+	typedDict := dict.(*Binary)
+	for i := 0; i < dict.Len(); i++ {
+		if dict.IsNull(i) {
+			u.memoTable.GetOrInsertNull()
+			continue
+		}
+
+		if _, _, err = u.memoTable.GetOrInsertBytes(typedDict.Value(i)); err != nil {
+			return err
+		}
+	}
+	return
+}
+
+func (u *binaryUnifier) UnifyAndTranspose(dict arrow.Array) (transposed *memory.Buffer, err error) {
+	if !arrow.TypeEqual(arrow.BinaryTypes.Binary, dict.DataType()) {
+		return nil, fmt.Errorf("dictionary type different from unifier: %s, expected: %s", dict.DataType(), arrow.BinaryTypes.Binary)
+	}
+
+	transposed = memory.NewResizableBuffer(u.mem)
+	transposed.Resize(arrow.Int32Traits.BytesRequired(dict.Len()))
+
+	newIdxes := arrow.Int32Traits.CastFromBytes(transposed.Bytes())
+	typedDict := dict.(*Binary)
+	for i := 0; i < dict.Len(); i++ {
+		if dict.IsNull(i) {
+			idx, _ := u.memoTable.GetOrInsertNull()
+			newIdxes[i] = int32(idx)
+			continue
+		}
+
+		idx, _, err := u.memoTable.GetOrInsertBytes(typedDict.Value(i))
+		if err != nil {
+			transposed.Release()
+			return nil, err
+		}
+		newIdxes[i] = int32(idx)
+	}
+	return
+}
+
+func (u *binaryUnifier) GetResult() (outType arrow.DataType, outDict arrow.Array, err error) {
+	dictLen := u.memoTable.Size()
+	var indexType arrow.DataType
+	switch {
+	case dictLen <= math.MaxInt8:
+		indexType = arrow.PrimitiveTypes.Int8
+	case dictLen <= math.MaxInt16:
+		indexType = arrow.PrimitiveTypes.Int16
+	case dictLen <= math.MaxInt32:
+		indexType = arrow.PrimitiveTypes.Int32
+	default:
+		indexType = arrow.PrimitiveTypes.Int64
+	}
+	outType = &arrow.DictionaryType{IndexType: indexType, ValueType: arrow.BinaryTypes.Binary}
+
+	dictData, err := GetDictArrayData(u.mem, arrow.BinaryTypes.Binary, u.memoTable, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	u.memoTable.Reset()
+
+	defer dictData.Release()
+	outDict = MakeFromData(dictData)
+	return
+}
+
+func (u *binaryUnifier) GetResultWithIndexType(indexType arrow.DataType) (arrow.Array, error) {
+	dictLen := u.memoTable.Size()
+	var toobig bool
+	switch indexType.ID() {
+	case arrow.UINT8:
+		toobig = dictLen > math.MaxUint8
+	case arrow.INT8:
+		toobig = dictLen > math.MaxInt8
+	case arrow.UINT16:
+		toobig = dictLen > math.MaxUint16
+	case arrow.INT16:
+		toobig = dictLen > math.MaxInt16
+	case arrow.UINT32:
+		toobig = uint(dictLen) > math.MaxUint32
+	case arrow.INT32:
+		toobig = dictLen > math.MaxInt32
+	case arrow.UINT64:
+		toobig = uint64(dictLen) > uint64(math.MaxUint64)
+	case arrow.INT64:
+	default:
+		return nil, fmt.Errorf("arrow/array: invalid dictionary index type: %s, must be integral", indexType)
+	}
+	if toobig {
+		return nil, errors.New("arrow/array: cannot combine dictionaries. unified dictionary requires a larger index type")
+	}
+
+	dictData, err := GetDictArrayData(u.mem, arrow.BinaryTypes.Binary, u.memoTable, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	u.memoTable.Reset()
+
+	defer dictData.Release()
+	return MakeFromData(dictData), nil
+}
+
 func unifyRecursive(mem memory.Allocator, typ arrow.DataType, chunks []*Data) (changed bool, err error) {
 	debug.Assert(len(chunks) != 0, "must provide non-zero length chunk slice")
 	var extType arrow.DataType
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index 4fb37127d6951..d0878fa3b0329 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -1422,6 +1422,55 @@ func TestDictionaryUnifierString(t *testing.T) {
 	checkTransposeMap(t, b2, []int32{2, 0})
 }
 
+func TestDictionaryUnifierBinary(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(t, 0)
+
+	dictType := arrow.BinaryTypes.Binary
+	d1, _, err := array.FromJSON(mem, dictType, strings.NewReader(`["Zm9vCg==", "YmFyCg=="]`)) // base64("foo\n"), base64("bar\n")
+	require.NoError(t, err)
+	defer d1.Release()
+
+	d2, _, err := array.FromJSON(mem, dictType, strings.NewReader(`["cXV1eAo=", "Zm9vCg=="]`)) // base64("quux\n"), base64("foo\n")
+	require.NoError(t, err)
+	defer d2.Release()
+
+	expected := &arrow.DictionaryType{IndexType: arrow.PrimitiveTypes.Int8, ValueType: dictType}
+	expectedDict, _, _ := array.FromJSON(mem, dictType, strings.NewReader(`["Zm9vCg==", "YmFyCg==", "cXV1eAo="]`))
+	defer expectedDict.Release()
+
+	unifier := array.NewBinaryDictionaryUnifier(mem)
+	defer unifier.Release()
+
+	assert.NoError(t, unifier.Unify(d1))
+	assert.NoError(t, unifier.Unify(d2))
+	outType, outDict, err := unifier.GetResult()
+	assert.NoError(t, err)
+	defer outDict.Release()
+
+	assert.Truef(t, arrow.TypeEqual(expected, outType), "got: %s, expected: %s", outType, expected)
+	assert.Truef(t, array.Equal(expectedDict, outDict), "got: %s, expected: %s", outDict, expectedDict)
+
+	b1, err := unifier.UnifyAndTranspose(d1)
+	assert.NoError(t, err)
+	b2, err := unifier.UnifyAndTranspose(d2)
+	assert.NoError(t, err)
+
+	outType, outDict, err = unifier.GetResult()
+	assert.NoError(t, err)
+	defer func() {
+		outDict.Release()
+		b1.Release()
+		b2.Release()
+	}()
+
+	assert.Truef(t, arrow.TypeEqual(expected, outType), "got: %s, expected: %s", outType, expected)
+	assert.Truef(t, array.Equal(expectedDict, outDict), "got: %s, expected: %s", outDict, expectedDict)
+
+	checkTransposeMap(t, b1, []int32{0, 1})
+	checkTransposeMap(t, b2, []int32{2, 0})
+}
+
 func TestDictionaryUnifierFixedSizeBinary(t *testing.T) {
 	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
 	defer mem.AssertSize(t, 0)

From a21fe1e4771e1341a25aa396374b08ecb2cac155 Mon Sep 17 00:00:00 2001
From: Frederic Branczyk <fbranczyk@gmail.com>
Date: Mon, 28 Aug 2023 18:54:28 +0200
Subject: [PATCH 248/749] GH-37416: [Go] Allow accessing underlying index
 builder of dictionary builders (#37417)

### Rationale for this change

See #37416

### What changes are included in this PR?

Exposing the index builder of dictionary builders.

### Are these changes tested?

Tested by an external usage. Since this is about exporting something that seemed appropriate enough.

### Are there any user-facing changes?

A new API, so no.
* Closes: #37416

Authored-by: Frederic Branczyk <fbranczyk@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/dictionary.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index 30bdc23c375b5..a7994db6b51bb 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -946,6 +946,10 @@ func (b *dictionaryBuilder) AppendArray(arr arrow.Array) error {
 	return nil
 }
 
+func (b *dictionaryBuilder) IndexBuilder() Builder {
+	return b.idxBuilder
+}
+
 func (b *dictionaryBuilder) AppendIndices(indices []int, valid []bool) {
 	b.length += len(indices)
 	switch idxbldr := b.idxBuilder.Builder.(type) {

From 8802666e6e907a8d765f94997200401adc009a92 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:37:48 +0900
Subject: [PATCH 249/749] MINOR: [C#] Bump xunit.runner.visualstudio from 2.4.0
 to 2.5.0 in /csharp (#37420)

Bumps [xunit.runner.visualstudio](https://github.com/xunit/visualstudio.xunit) from 2.4.0 to 2.5.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/xunit/visualstudio.xunit/releases">xunit.runner.visualstudio's releases</a>.</em></p>
<blockquote>
<h2>v2.4.5</h2>
<h2>Changes:</h2>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/308">#308</a>: Downgrade xunit.runner.vs to net462</li>
</ul>
<p>This list of changes was <a href="https://dev.azure.com/dotnet/fe18572b-d1ba-496a-9e95-1af3bc3df99b/_release?releaseId=178&amp;_a=release-summary">auto generated</a>.</p>
<h2>v2.4.4</h2>
<h2>Changes:</h2>
<h3>Bugs:</h3>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/292">#292</a>: Fixing a hang in test discovery</li>
</ul>
<h3>Others:</h3>
<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/304">#304</a>: Update xunit version to 2.4.2-pre.12</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/297">#297</a>: Bump NSubstitute from 4.2.2 to 4.3.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/294">#294</a>: Bump Microsoft.NET.Test.Sdk from 16.10.0 to 17.0.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/293">#293</a>: Bump Nerdbank.GitVersioning from 3.4.231 to 3.4.255</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/296">#296</a>: Bump Microsoft.NETCore.UniversalWindowsPlatform from 6.2.12 to 6.2.13</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/299">#299</a>: Bump MSBuild.Sdk.Extras from 3.0.23 to 3.0.44</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/270">#270</a>: Upgrade to GitHub-native Dependabot</li>
</ul>

<ul>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/281">#281</a>: Bump Nerdbank.GitVersioning from 3.4.228 to 3.4.231</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/280">#280</a>: Bump Nerdbank.GitVersioning from 3.4.220 to 3.4.228</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/277">#277</a>: Bump Nerdbank.GitVersioning from 3.4.216 to 3.4.220</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/275">#275</a>: Bump Nerdbank.GitVersioning from 3.4.205 to 3.4.216</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/274">#274</a>: Bump Nerdbank.GitVersioning from 3.4.203 to 3.4.205</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/273">#273</a>: Bump Microsoft.NET.Test.Sdk from 16.9.4 to 16.10.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/272">#272</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.9.4 to 16.10.0</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/271">#271</a>: Bump Nerdbank.GitVersioning from 3.4.194 to 3.4.203</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/268">#268</a>: Bump Nerdbank.GitVersioning from 3.4.190 to 3.4.194</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/267">#267</a>: Bump Nerdbank.GitVersioning from 3.3.37 to 3.4.190</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/265">#265</a>: Bump Microsoft.NET.Test.Sdk from 16.9.1 to 16.9.4</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/264">#264</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.9.1 to 16.9.4</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/260">#260</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.8.3 to 16.9.1</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/261">#261</a>: Bump Microsoft.NET.Test.Sdk from 16.8.3 to 16.9.1</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/258">#258</a>: Bump Microsoft.NETCore.UniversalWindowsPlatform from 6.2.11 to 6.2.12</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/256">#256</a>: Bump MSBuild.Sdk.Extras from 3.0.22 to 3.0.23</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/255">#255</a>: Bump MSBuild.Sdk.Extras from 2.1.2 to 3.0.22</li>
<li><a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/254">#254</a>: Bump Microsoft.TestPlatform.ObjectModel from 16.8.0 to 16.8.3</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/xunit/visualstudio.xunit/commits/2.5.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit.runner.visualstudio&package-manager=nuget&previous-version=2.4.0&new-version=2.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 07e341eb27ab2..5d2b7ab47aad9 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -8,7 +8,7 @@
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
       <PackageReference Include="xunit" Version="2.4.0" />
-      <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+      <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
       <PackageReference Include="coverlet.collector" Version="1.2.0" />
     </ItemGroup>
 

From 35aaaf45cf2b6f5b38014afd25fcf9336153dc20 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:40:40 +0900
Subject: [PATCH 250/749] MINOR: [C#] Bump Grpc.Tools from 2.42.0 to 2.57.0 in
 /csharp (#37421)

Bumps [Grpc.Tools](https://github.com/grpc/grpc) from 2.42.0 to 2.57.0.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/grpc/grpc/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Tools&package-manager=nuget&previous-version=2.42.0&new-version=2.57.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
index 50570d628924b..57bb6b6876ca8 100644
--- a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
+++ b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.Tools" Version="2.42.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>

From af97607c617270c01fb4b4cd13559b1d03b5b20a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:43:20 +0900
Subject: [PATCH 251/749] MINOR: [C#] Bump Grpc.AspNetCore from 2.55.0 to
 2.56.0 in /csharp (#37425)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore](https://github.com/grpc/grpc-dotnet) from 2.55.0 to 2.56.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore's releases</a>.</em></p>
<blockquote>
<h2>Release v2.56.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Update version to 2.56.0 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2251">grpc/grpc-dotnet#2251</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0</a></p>
<h2>Release v2.56.0-pre2</h2>
<h2>What's Changed</h2>
<ul>
<li>[2.56.x] Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2234">grpc/grpc-dotnet#2234</a></li>
<li>[2.56.x] Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2233">grpc/grpc-dotnet#2233</a></li>
<li>Update version to -pre2 on v2.56.x branch by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2246">grpc/grpc-dotnet#2246</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2</a></p>
<h2>Release v2.56.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Update 2.55 branch to 2.55-pre1 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2174">grpc/grpc-dotnet#2174</a></li>
<li>Revert &quot;update 2.55 branch to 2.55-pre1&quot; by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2175">grpc/grpc-dotnet#2175</a></li>
<li>Update version to 2.55.0-dev (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2177">grpc/grpc-dotnet#2177</a></li>
<li>update readme by <a href="https://github.com/Varorbc"><code>@​Varorbc</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2183">grpc/grpc-dotnet#2183</a></li>
<li>Start 2.56.x development cycle (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2185">grpc/grpc-dotnet#2185</a></li>
<li>Improve grpc-dotnet debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2192">grpc/grpc-dotnet#2192</a></li>
<li>Even better gRPC debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2193">grpc/grpc-dotnet#2193</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2199">grpc/grpc-dotnet#2199</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2198">grpc/grpc-dotnet#2198</a></li>
<li>Bump tough-cookie from 4.0.0 to 4.1.3 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2187">grpc/grpc-dotnet#2187</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2189">grpc/grpc-dotnet#2189</a></li>
<li>Remove System.Memory dependency on .NET Standard 2.1 in Grpc.Core.Api. by <a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
<li>Socket transport: Don't close socket on available data by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2179">grpc/grpc-dotnet#2179</a></li>
<li>Update SocketConnectivitySubchannelTransport.cs by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2202">grpc/grpc-dotnet#2202</a></li>
<li>Improve gRPC channel and client debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2196">grpc/grpc-dotnet#2196</a></li>
<li>Fix gRPC client retry deadlock by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2209">grpc/grpc-dotnet#2209</a></li>
<li>Support idle connection timeout with pending sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2213">grpc/grpc-dotnet#2213</a></li>
<li>Correctly check socket on stream creation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2215">grpc/grpc-dotnet#2215</a></li>
<li>Add net462 build to Grpc.Net.Client with WinHttpHandler default by <a href="https://github.com/stephentoub"><code>@​stephentoub</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2220">grpc/grpc-dotnet#2220</a></li>
<li>Update version to v2.56.0-pre1 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2224">grpc/grpc-dotnet#2224</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> made their first contribution in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b9e7a8b03fa8cb23fce00e2d3f70888a0a6e757b"><code>b9e7a8b</code></a> Update version to 2.56.0 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2251">#2251</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c41d7e2302d85d55b6282023d4edc770325517c3"><code>c41d7e2</code></a> Update version to -pre2 on v2.56.x branch (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2246">#2246</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/400bbb7aeadb8584bd0bbe6ba3b2d0590b1a8884"><code>400bbb7</code></a> [2.56.x] Validate Windows version when using WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2233">#2233</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1422de08f0d499f4c44c702c70baad22b278725c"><code>1422de0</code></a> [2.56.x] Support infinite idle connection timeout values (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2234">#2234</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/df13e5a7f1c0899302a0e259ad562a24531b5246"><code>df13e5a</code></a> Update version to v2.56.0-pre1 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2224">#2224</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6a4bca703aee8040144b7548c88706063445c1fb"><code>6a4bca7</code></a> Add net462 build to Grpc.Net.Client with WinHttpHandler default (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2220">#2220</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a2d005c86bfea561105155d5d9366d74531872cc"><code>a2d005c</code></a> Correctly check socket on stream creation (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2215">#2215</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1d1234064c3c6a5ed394bc56a13bf1dc687a12d4"><code>1d12340</code></a> Support idle connection timeout with pending sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2213">#2213</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/0ab3ada34aa76740b436b3b1d320f2f406f82f50"><code>0ab3ada</code></a> Fix gRPC client retry deadlock (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2209">#2209</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bff852c7f10ebf917e8229940eb8ac695f141ac0"><code>bff852c</code></a> Improve gRPC channel and client debugging (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2196">#2196</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore&package-manager=nuget&previous-version=2.55.0&new-version=2.56.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.TestWeb.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
index 32ff4a9ece5e1..ef7d730d2cd45 100644
--- a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
+++ b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.55.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.56.0" />
   </ItemGroup>
 
   <ItemGroup>

From 8e41366d2f09357987a02f91a31968c503cc899b Mon Sep 17 00:00:00 2001
From: Benjamin Kietzman <bengilgit@gmail.com>
Date: Mon, 28 Aug 2023 19:44:25 -0400
Subject: [PATCH 252/749] GH-36124: [C++] Export compile_commands.json by
 default (#37426)

`CMakePresets.json` does not export `compile_commands.json` by default, which is used by all clang tooling. Adding it as a default ensures that new developers (or any others who forget to specifically specify the option) will still be able to use their language servers without regenerating the cmake build dir.

The relevant option is `"CMAKE_EXPORT_COMPILE_COMMANDS": "ON"`, and causes generation of a ~1MB file at build time.
* Closes: #36124

Authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakePresets.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cpp/CMakePresets.json b/cpp/CMakePresets.json
index 94141d693be8f..f6324c1c0a96d 100644
--- a/cpp/CMakePresets.json
+++ b/cpp/CMakePresets.json
@@ -11,7 +11,8 @@
       "hidden": true,
       "generator": "Ninja",
       "cacheVariables": {
-        "ARROW_BUILD_STATIC": "OFF"
+        "ARROW_BUILD_STATIC": "OFF",
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
       }
     },
     {

From 796ed7fbf53992c4fa5f3f531549872325018c22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 29 Aug 2023 02:21:57 +0200
Subject: [PATCH 253/749] GH-37414: [Release][CI] Update references to wrong
 apache-arrow Homebrew formula path (#37415)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

There are currently some references to the wrong homebrew-core arrow and arrow-glib formula paths.

### What changes are included in this PR?

Changing to the correct path.

### Are these changes tested?

The `post-04-ruby.sh` script has been used locally for the post release tasks. The other changes via archery.

### Are there any user-facing changes?

No
* Closes: #37414

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/post-04-ruby.sh                      | 2 +-
 dev/tasks/homebrew-formulae/apache-arrow-glib.rb | 2 +-
 dev/tasks/homebrew-formulae/apache-arrow.rb      | 2 +-
 dev/tasks/r/github.macos.brew.yml                | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dev/release/post-04-ruby.sh b/dev/release/post-04-ruby.sh
index 395fa8dfcb531..b216a65d21812 100755
--- a/dev/release/post-04-ruby.sh
+++ b/dev/release/post-04-ruby.sh
@@ -39,7 +39,7 @@ homebrew_version=$(
   curl \
     --fail \
     --no-progress-meter \
-    https://raw.githubusercontent.com/Homebrew/homebrew-core/HEAD/Formula/apache-arrow-glib.rb | \
+    https://raw.githubusercontent.com/Homebrew/homebrew-core/HEAD/Formula/a/apache-arrow-glib.rb | \
     grep url | \
     grep -o "[0-9]*\.[0-9]*\.[0-9]*" | \
     head -n 1)
diff --git a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
index 0d8954e9a2a46..c31ef267d73c5 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
@@ -24,7 +24,7 @@
 # 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.
 
-# https://github.com/Homebrew/homebrew-core/blob/-/Formula/apache-arrow-glib.rb
+# https://github.com/Homebrew/homebrew-core/blob/-/Formula/a/apache-arrow-glib.rb
 
 class ApacheArrowGlib < Formula
   desc "GLib bindings for Apache Arrow"
diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index 464c921281b95..edf2d7b73b8f5 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -24,7 +24,7 @@
 # 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.
 
-# https://github.com/Homebrew/homebrew-core/blob/-/Formula/apache-arrow.rb
+# https://github.com/Homebrew/homebrew-core/blob/-/Formula/a/apache-arrow.rb
 
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
diff --git a/dev/tasks/r/github.macos.brew.yml b/dev/tasks/r/github.macos.brew.yml
index 8a0e6f6bb96e3..285eefa293eaa 100644
--- a/dev/tasks/r/github.macos.brew.yml
+++ b/dev/tasks/r/github.macos.brew.yml
@@ -41,7 +41,7 @@ jobs:
 
           # TODO(ARROW-16907): apache/arrow@main seems to be installed already
           # so this does nothing on a branch/PR
-          brew install -v --HEAD {{ '$(brew --repository homebrew/core)/Formula/apache-arrow.rb' }}
+          brew install -v --HEAD {{ '$(brew --repository homebrew/core)/Formula/a/apache-arrow.rb' }}
 
           mkdir -p homebrew-logs
           cp -a ~/Library/Logs/Homebrew/apache-arrow homebrew-logs/

From d5be430253a48ee1c3c4e746853bb70f836abfea Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 29 Aug 2023 09:22:57 +0900
Subject: [PATCH 254/749] GH-37237: [C++] Set extraction time to all downloaded
 contents timestamp (#37238)

### Rationale for this change

The "The DOWNLOAD_EXTRACT_TIMESTAMP option was not given and policy CMP0135 is not set." warnings are noisy.

### What changes are included in this PR?

Set `CMP0135` policy.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37237

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakeLists.txt | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 27d7097a2901f..64fd5d96432c4 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -18,35 +18,52 @@
 cmake_minimum_required(VERSION 3.16)
 message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 
-# Compiler id for Apple Clang is now AppleClang.
 # https://www.cmake.org/cmake/help/latest/policy/CMP0025.html
+#
+# Compiler id for Apple Clang is now AppleClang.
 cmake_policy(SET CMP0025 NEW)
 
-# Only interpret if() arguments as variables or keywords when unquoted.
 # https://www.cmake.org/cmake/help/latest/policy/CMP0054.html
+#
+# Only interpret if() arguments as variables or keywords when unquoted.
 cmake_policy(SET CMP0054 NEW)
 
-# Support new if() IN_LIST operator.
 # https://www.cmake.org/cmake/help/latest/policy/CMP0057.html
+#
+# Support new if() IN_LIST operator.
 cmake_policy(SET CMP0057 NEW)
 
+# https://www.cmake.org/cmake/help/latest/policy/CMP0063.html
+#
 # Adapted from Apache Kudu: https://github.com/apache/kudu/commit/bd549e13743a51013585
 # Honor visibility properties for all target types.
-# https://www.cmake.org/cmake/help/latest/policy/CMP0063.html
 cmake_policy(SET CMP0063 NEW)
 
-# RPATH settings on macOS do not affect install_name.
 # https://cmake.org/cmake/help/latest/policy/CMP0068.html
+#
+# RPATH settings on macOS do not affect install_name.
 cmake_policy(SET CMP0068 NEW)
 
-# find_package() uses <PackageName>_ROOT variables.
 # https://cmake.org/cmake/help/latest/policy/CMP0074.html
+#
+# find_package() uses <PackageName>_ROOT variables.
 cmake_policy(SET CMP0074 NEW)
 
-# MSVC runtime library flags are selected by an abstraction.
 # https://cmake.org/cmake/help/latest/policy/CMP0091.html
+#
+# MSVC runtime library flags are selected by an abstraction.
 cmake_policy(SET CMP0091 NEW)
 
+# https://cmake.org/cmake/help/latest/policy/CMP0135.html
+#
+# CMP0135 is for solving re-building and re-downloading.
+# We don't have a real problem with the OLD behavior for now
+# but we use the NEW behavior explicitly to suppress CMP0135
+# warnings.
+if(POLICY CMP0135)
+  cmake_policy(SET CMP0135 NEW)
+endif()
+
 set(ARROW_VERSION "14.0.0-SNAPSHOT")
 
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_BASE_VERSION "${ARROW_VERSION}")

From e1227a29c294333f76785e1ea8ee3f154fbfebd1 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 29 Aug 2023 09:24:02 +0900
Subject: [PATCH 255/749] GH-37352: [C++] Don't put all dependencies to
 ArrowConfig.cmake/arrow.pc (#37399)

### Rationale for this change

Currently, `arrow.pc` has `Requires.private: grpc++` when Flight is enabled and system gRPC is used. `grpc++.pc` depends on `re2.pc` on Amazon Linux 2023 and `re2.pc` has `-std=c++11`. It causes a problem when an user uses `c++ -std=c++17 a.cc $(pkg-config --cflags --libs arrow)`. Because the command will be expanded to `c++ -std=c++17 ... -std=c++11 ...`. The expanded command line uses C++11 not C++17 because `-std=c++11` is appeared after `-std=c++17`. In general, the user must use `c++ ... $(pkg-config --cflags --libs arrow) -std=c++17` to ensure using their `-std=XXX`. But we want to avoid this case as much as possible.

### What changes are included in this PR?

Split Flight related dependencies such as gRPC to ArrowFlightConfig.cmake/arrow-flight.pc from ArrowConfig.cmake/arrow.pc.

Split Parquet related dependencies such as Thrift to ParquetConfig.cmake/parquet.pc from ArrowConfig.cmake/arrow.pc.

With this change, `c++ -std=c++17 ... $(pkg-config --cflags --libs arrow)` works because `arrow.pc` doesn't depend on `grpc++` (`re2`). But `c++ -std=c++17 ... $(pkg-config --cflags --libs arrow-flight)` still doesn't work on Amazon Linux 2023. `c++ ... $(pkg-config --cflags --libs arrow-flight) ... -std=c++17 ...` should be used for the case.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37352

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakeLists.txt                            |   6 +
 cpp/cmake_modules/ThirdpartyToolchain.cmake   | 108 +++++++++++++-----
 cpp/src/arrow/ArrowConfig.cmake.in            |  24 ++--
 cpp/src/arrow/ArrowTestingConfig.cmake.in     |  18 +--
 .../arrow/flight/ArrowFlightConfig.cmake.in   |   6 +
 cpp/src/arrow/flight/arrow-flight.pc.in       |   1 +
 cpp/src/parquet/ParquetConfig.cmake.in        |   6 +
 cpp/src/parquet/parquet.pc.in                 |   1 +
 dev/release/verify-apt.sh                     |   2 +-
 dev/release/verify-yum.sh                     |   2 +-
 .../apache-arrow/debian/control.in            |  15 +--
 .../apache-arrow/yum/arrow.spec.in            |  12 +-
 12 files changed, 131 insertions(+), 70 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 64fd5d96432c4..fcff62c447014 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -516,12 +516,18 @@ set(ARROW_PC_CFLAGS_PRIVATE " -DARROW_STATIC")
 set(ARROW_PC_LIBS_PRIVATE "")
 set(ARROW_PC_REQUIRES_PRIVATE "")
 
+# For arrow-flight.pc.
+set(ARROW_FLIGHT_PC_REQUIRES_PRIVATE "")
+
 # For arrow-testing.pc.
 set(ARROW_TESTING_PC_CFLAGS "")
 set(ARROW_TESTING_PC_CFLAGS_PRIVATE " -DARROW_TESTING_STATIC")
 set(ARROW_TESTING_PC_LIBS "")
 set(ARROW_TESTING_PC_REQUIRES "")
 
+# For parquet.pc.
+set(PARQUET_PC_REQUIRES_PRIVATE "")
+
 include(ThirdpartyToolchain)
 
 # Add common flags
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 1767c05b5ee3a..3101c1dc73aa6 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -32,6 +32,9 @@ set(ARROW_BUNDLED_STATIC_LIBS)
 # Accumulate all system dependencies to provide suitable static link
 # parameters to the third party libraries.
 set(ARROW_SYSTEM_DEPENDENCIES)
+set(ARROW_FLIGHT_SYSTEM_DEPENDENCIES)
+set(ARROW_TESTING_SYSTEM_DEPENDENCIES)
+set(PARQUET_SYSTEM_DEPENDENCIES)
 
 # ----------------------------------------------------------------------
 # Toolchain linkage options
@@ -233,6 +236,7 @@ macro(resolve_dependency DEPENDENCY_NAME)
   set(options)
   set(one_value_args
       ARROW_CMAKE_PACKAGE_NAME
+      ARROW_PC_PACKAGE_NAME
       FORCE_ANY_NEWER_VERSION
       HAVE_ALT
       IS_RUNTIME_DEPENDENCY
@@ -297,12 +301,26 @@ macro(resolve_dependency DEPENDENCY_NAME)
     if(NOT ARG_ARROW_CMAKE_PACKAGE_NAME)
       set(ARG_ARROW_CMAKE_PACKAGE_NAME "Arrow")
     endif()
-    if(ARG_ARROW_CMAKE_PACKAGE_NAME STREQUAL "Arrow")
-      provide_find_module(${PACKAGE_NAME} "Arrow")
-      list(APPEND ARROW_SYSTEM_DEPENDENCIES ${PACKAGE_NAME})
-    else()
-      provide_find_module(${PACKAGE_NAME} ${ARG_ARROW_CMAKE_PACKAGE_NAME})
+    # ArrowFlight -> _Arrow_Flight
+    string(REGEX REPLACE "([A-Z])" "_\\1" ARG_ARROW_CMAKE_PACKAGE_NAME_SNAKE
+                         ${ARG_ARROW_CMAKE_PACKAGE_NAME})
+    # _Arrow_Flight -> Arrow_Flight
+    string(SUBSTRING ${ARG_ARROW_CMAKE_PACKAGE_NAME_SNAKE} 1 -1
+                     ARG_ARROW_CMAKE_PACKAGE_NAME_SNAKE)
+    # Arrow_Flight -> ARROW_FLIGHT
+    string(TOUPPER ${ARG_ARROW_CMAKE_PACKAGE_NAME_SNAKE}
+                   ARG_ARROW_CMAKE_PACKAGE_NAME_UPPER_SNAKE)
+    provide_find_module(${PACKAGE_NAME} ${ARG_ARROW_CMAKE_PACKAGE_NAME})
+    list(APPEND ${ARG_ARROW_CMAKE_PACKAGE_NAME_UPPER_SNAKE}_SYSTEM_DEPENDENCIES
+         ${PACKAGE_NAME})
+    if(NOT ARG_ARROW_PC_PACKAGE_NAME)
+      set(ARG_ARROW_PC_PACKAGE_NAME "arrow")
     endif()
+    # arrow-flight -> arrow_flight
+    string(REPLACE "-" "_" ARG_ARROW_PC_PACKAGE_NAME_SNAKE ${ARG_ARROW_PC_PACKAGE_NAME})
+    # arrow_flight -> ARROW_FLIGHT
+    string(TOUPPER ${ARG_ARROW_PC_PACKAGE_NAME_SNAKE}
+                   ARG_ARROW_PC_PACKAGE_NAME_UPPER_SNAKE)
     if(ARROW_BUILD_STATIC)
       find_package(PkgConfig QUIET)
       foreach(ARG_PC_PACKAGE_NAME ${ARG_PC_PACKAGE_NAMES})
@@ -311,13 +329,16 @@ macro(resolve_dependency DEPENDENCY_NAME)
                           NO_CMAKE_PATH
                           NO_CMAKE_ENVIRONMENT_PATH
                           QUIET)
+        set(RESOLVE_DEPENDENCY_PC_PACKAGE
+            "pkg-config package for ${ARG_PC_PACKAGE_NAME} ")
+        string(APPEND RESOLVE_DEPENDENCY_PC_PACKAGE
+               "that is used by ${ARG_ARROW_PC_PACKAGE_NAME} for static link")
         if(${${ARG_PC_PACKAGE_NAME}_PC_FOUND})
-          message(STATUS "Using pkg-config package for ${ARG_PC_PACKAGE_NAME} for static link"
-          )
-          string(APPEND ARROW_PC_REQUIRES_PRIVATE " ${ARG_PC_PACKAGE_NAME}")
+          message(STATUS "Using ${RESOLVE_DEPENDENCY_PC_PACKAGE}")
+          string(APPEND ${ARG_ARROW_PC_PACKAGE_NAME_UPPER_SNAKE}_PC_REQUIRES_PRIVATE
+                 " ${ARG_PC_PACKAGE_NAME}")
         else()
-          message(STATUS "pkg-config package for ${ARG_PC_PACKAGE_NAME} for static link isn't found"
-          )
+          message(STATUS "${RESOLVE_DEPENDENCY_PC_PACKAGE} isn't found")
         endif()
       endforeach()
     endif()
@@ -1614,12 +1635,16 @@ endmacro()
 if(ARROW_WITH_THRIFT)
   # Thrift C++ code generated by 0.13 requires 0.11 or greater
   resolve_dependency(Thrift
+                     ARROW_CMAKE_PACKAGE_NAME
+                     Parquet
+                     ARROW_PC_PACKAGE_NAME
+                     parquet
                      HAVE_ALT
                      TRUE
-                     REQUIRED_VERSION
-                     0.11.0
                      PC_PACKAGE_NAMES
-                     thrift)
+                     thrift
+                     REQUIRED_VERSION
+                     0.11.0)
 
   string(REPLACE "." ";" Thrift_VERSION_LIST ${Thrift_VERSION})
   list(GET Thrift_VERSION_LIST 0 Thrift_VERSION_MAJOR)
@@ -1715,6 +1740,13 @@ if(ARROW_WITH_PROTOBUF)
   else()
     set(ARROW_PROTOBUF_REQUIRED_VERSION "2.6.1")
   endif()
+  if(ARROW_FLIGHT)
+    set(ARROW_PROTOBUF_ARROW_CMAKE_PACKAGE_NAME "ArrowFlight")
+    set(ARROW_PROTOBUF_ARROW_PC_PACKAGE_NAME "arrow-flight")
+  else()
+    set(ARROW_PROTOBUF_ARROW_CMAKE_PACKAGE_NAME "Arrow")
+    set(ARROW_PROTOBUF_ARROW_PC_PACKAGE_NAME "arrow")
+  endif()
   # We need to use FORCE_ANY_NEWER_VERSION here to accept Protobuf
   # newer version such as 23.4. If we don't use it, 23.4 is processed
   # as an incompatible version with 3.12.0 with protobuf-config.cmake
@@ -1724,14 +1756,18 @@ if(ARROW_WITH_PROTOBUF)
   # we use FORCE_ANY_NEWER_VERSION here, we can bypass the check and
   # use 23.4.
   resolve_dependency(Protobuf
+                     ARROW_CMAKE_PACKAGE_NAME
+                     ${ARROW_PROTOBUF_ARROW_CMAKE_PACKAGE_NAME}
+                     ARROW_PC_PACKAGE_NAME
+                     ${ARROW_PROTOBUF_ARROW_PC_PACKAGE_NAME}
                      FORCE_ANY_NEWER_VERSION
                      TRUE
                      HAVE_ALT
                      TRUE
-                     REQUIRED_VERSION
-                     ${ARROW_PROTOBUF_REQUIRED_VERSION}
                      PC_PACKAGE_NAMES
-                     protobuf)
+                     protobuf
+                     REQUIRED_VERSION
+                     ${ARROW_PROTOBUF_REQUIRED_VERSION})
 
   if(NOT Protobuf_USE_STATIC_LIBS AND MSVC_TOOLCHAIN)
     add_definitions(-DPROTOBUF_USE_DLLS)
@@ -2167,12 +2203,12 @@ endmacro()
 if(ARROW_TESTING)
   set(GTestAlt_NEED_CXX_STANDARD_CHECK TRUE)
   resolve_dependency(GTest
+                     ARROW_CMAKE_PACKAGE_NAME
+                     ArrowTesting
                      HAVE_ALT
                      TRUE
                      REQUIRED_VERSION
-                     1.10.0
-                     ARROW_CMAKE_PACKAGE_NAME
-                     "ArrowTesting")
+                     1.10.0)
 
   if(GTest_SOURCE STREQUAL "SYSTEM")
     find_package(PkgConfig QUIET)
@@ -2351,10 +2387,12 @@ endif()
 
 if(ARROW_USE_XSIMD)
   resolve_dependency(xsimd
+                     FORCE_ANY_NEWER_VERSION
+                     TRUE
                      REQUIRED_VERSION
                      "8.1.0"
-                     FORCE_ANY_NEWER_VERSION
-                     TRUE)
+                     PC_PACKAGE_NAMES
+                     xsimd)
 
   if(xsimd_SOURCE STREQUAL "BUNDLED")
     add_library(arrow::xsimd INTERFACE IMPORTED)
@@ -2678,10 +2716,10 @@ endmacro()
 
 if(ARROW_WITH_UTF8PROC)
   resolve_dependency(utf8proc
-                     REQUIRED_VERSION
-                     "2.2.0"
                      PC_PACKAGE_NAMES
-                     libutf8proc)
+                     libutf8proc
+                     REQUIRED_VERSION
+                     "2.2.0")
   add_definitions(-DARROW_WITH_UTF8PROC)
 endif()
 
@@ -3694,6 +3732,10 @@ endmacro()
 
 macro(build_grpc)
   resolve_dependency(c-ares
+                     ARROW_CMAKE_PACKAGE_NAME
+                     ArrowFlight
+                     ARROW_PC_PACKAGE_NAME
+                     arrow-flight
                      HAVE_ALT
                      TRUE
                      PC_PACKAGE_NAMES
@@ -3998,12 +4040,16 @@ if(ARROW_WITH_GRPC)
     set(gRPC_SOURCE "${Protobuf_SOURCE}")
   endif()
   resolve_dependency(gRPC
+                     ARROW_CMAKE_PACKAGE_NAME
+                     ArrowFlight
+                     ARROW_PC_PACKAGE_NAME
+                     arrow-flight
                      HAVE_ALT
                      TRUE
-                     REQUIRED_VERSION
-                     ${ARROW_GRPC_REQUIRED_VERSION}
                      PC_PACKAGE_NAMES
-                     grpc++)
+                     grpc++
+                     REQUIRED_VERSION
+                     ${ARROW_GRPC_REQUIRED_VERSION})
 
   if(GRPC_VENDORED)
     # Remove "v" from "vX.Y.Z"
@@ -5119,7 +5165,13 @@ macro(build_ucx)
 endmacro()
 
 if(ARROW_WITH_UCX)
-  resolve_dependency(ucx PC_PACKAGE_NAMES ucx)
+  resolve_dependency(ucx
+                     ARROW_CMAKE_PACKAGE_NAME
+                     ArrowFlight
+                     ARROW_PC_PACKAGE_NAME
+                     arrow-flight
+                     PC_PACKAGE_NAMES
+                     ucx)
   add_library(ucx::ucx INTERFACE IMPORTED)
   target_include_directories(ucx::ucx INTERFACE "${UCX_INCLUDE_DIRS}")
   target_link_libraries(ucx::ucx INTERFACE ucx::ucp ucx::uct ucx::ucs)
diff --git a/cpp/src/arrow/ArrowConfig.cmake.in b/cpp/src/arrow/ArrowConfig.cmake.in
index deb7bf94a80a2..7bd19fb41a31f 100644
--- a/cpp/src/arrow/ArrowConfig.cmake.in
+++ b/cpp/src/arrow/ArrowConfig.cmake.in
@@ -41,13 +41,7 @@ set(ARROW_SYSTEM_DEPENDENCIES "@ARROW_SYSTEM_DEPENDENCIES@")
 
 include("${CMAKE_CURRENT_LIST_DIR}/ArrowOptions.cmake")
 
-if(ARROW_BUILD_STATIC)
-  include(CMakeFindDependencyMacro)
-
-  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
-  find_dependency(Threads)
-
+macro(arrow_find_dependencies dependencies)
   if(DEFINED CMAKE_MODULE_PATH)
     set(ARROW_CMAKE_MODULE_PATH_OLD ${CMAKE_MODULE_PATH})
   else()
@@ -55,9 +49,9 @@ if(ARROW_BUILD_STATIC)
   endif()
   set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
 
-  foreach(_DEPENDENCY ${ARROW_SYSTEM_DEPENDENCIES})
+  foreach(dependency ${dependencies})
     set(ARROW_OPENSSL_HOMEBREW_MAKE_DETECTABLE FALSE)
-    if(${_DEPENDENCY} STREQUAL "OpenSSL" AND NOT OPENSSL_ROOT_DIR)
+    if(${dependency} STREQUAL "OpenSSL" AND NOT OPENSSL_ROOT_DIR)
       find_program(ARROW_BREW brew)
       if(ARROW_BREW)
         set(ARROW_OPENSSL_ROOT_DIR_ORIGINAL ${OPENSSL_ROOT_DIR})
@@ -78,7 +72,7 @@ if(ARROW_BUILD_STATIC)
         endif()
       endif()
     endif()
-    find_dependency(${_DEPENDENCY})
+    find_dependency(${dependency})
     if(ARROW_OPENSSL_HOMEBREW_MAKE_DETECTABLE)
       set(OPENSSL_ROOT_DIR ${ARROW_OPENSSL_ROOT_DIR_ORIGINAL})
     endif()
@@ -90,6 +84,16 @@ if(ARROW_BUILD_STATIC)
   else()
     unset(CMAKE_MODULE_PATH)
   endif()
+endmacro()
+
+if(ARROW_BUILD_STATIC)
+  include(CMakeFindDependencyMacro)
+
+  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+  find_dependency(Threads)
+
+  arrow_find_dependencies("${ARROW_SYSTEM_DEPENDENCIES}")
 endif()
 
 include("${CMAKE_CURRENT_LIST_DIR}/ArrowTargets.cmake")
diff --git a/cpp/src/arrow/ArrowTestingConfig.cmake.in b/cpp/src/arrow/ArrowTestingConfig.cmake.in
index b65f6ef0d58b0..148d6516a093f 100644
--- a/cpp/src/arrow/ArrowTestingConfig.cmake.in
+++ b/cpp/src/arrow/ArrowTestingConfig.cmake.in
@@ -26,26 +26,12 @@
 
 @PACKAGE_INIT@
 
-set(ARROW_GTEST_SOURCE "@GTest_SOURCE@")
+set(ARROW_TESTING_SYSTEM_DEPENDENCIES "@ARROW_TESTING_SYSTEM_DEPENDENCIES@")
 
 include(CMakeFindDependencyMacro)
 find_dependency(Arrow)
 
-if(DEFINED CMAKE_MODULE_PATH)
-  set(ARROW_TESTING_CMAKE_MODULE_PATH_OLD ${CMAKE_MODULE_PATH})
-else()
-  unset(ARROW_TESTING_CMAKE_MODULE_PATH_OLD)
-endif()
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
-if("${ARROW_GTEST_SOURCE}" STREQUAL "SYSTEM")
-  find_dependency(GTestAlt)
-endif()
-if(DEFINED ARROW_TESTING_CMAKE_MODULE_PATH_OLD)
-  set(CMAKE_MODULE_PATH ${ARROW_TESTING_CMAKE_MODULE_PATH_OLD})
-  unset(ARROW_TESTING_CMAKE_MODULE_PATH_OLD)
-else()
-  unset(CMAKE_MODULE_PATH)
-endif()
+arrow_find_dependencies("${ARROW_TESTING_SYSTEM_DEPENDENCIES}")
 
 include("${CMAKE_CURRENT_LIST_DIR}/ArrowTestingTargets.cmake")
 
diff --git a/cpp/src/arrow/flight/ArrowFlightConfig.cmake.in b/cpp/src/arrow/flight/ArrowFlightConfig.cmake.in
index 70beb901c857f..92803289f1ea8 100644
--- a/cpp/src/arrow/flight/ArrowFlightConfig.cmake.in
+++ b/cpp/src/arrow/flight/ArrowFlightConfig.cmake.in
@@ -26,9 +26,15 @@
 
 @PACKAGE_INIT@
 
+set(ARROW_FLIGHT_SYSTEM_DEPENDENCIES "@ARROW_FLIGHT_SYSTEM_DEPENDENCIES@")
+
 include(CMakeFindDependencyMacro)
 find_dependency(Arrow)
 
+if(ARROW_BUILD_STATIC)
+  arrow_find_dependencies("${ARROW_FLIGHT_SYSTEM_DEPENDENCIES}")
+endif()
+
 include("${CMAKE_CURRENT_LIST_DIR}/ArrowFlightTargets.cmake")
 
 arrow_keep_backward_compatibility(ArrowFlight arrow_flight)
diff --git a/cpp/src/arrow/flight/arrow-flight.pc.in b/cpp/src/arrow/flight/arrow-flight.pc.in
index 5a57a8922377e..a63d6cadaa80e 100644
--- a/cpp/src/arrow/flight/arrow-flight.pc.in
+++ b/cpp/src/arrow/flight/arrow-flight.pc.in
@@ -23,5 +23,6 @@ Name: Apache Arrow Flight
 Description: Apache Arrow's RPC system built on gRPC
 Version: @ARROW_VERSION@
 Requires: arrow
+Requires.private:@ARROW_FLIGHT_PC_REQUIRES_PRIVATE@
 Libs: -L${libdir} -larrow_flight
 Cflags.private: -DARROW_FLIGHT_STATIC
diff --git a/cpp/src/parquet/ParquetConfig.cmake.in b/cpp/src/parquet/ParquetConfig.cmake.in
index 1030530138865..90e1d4d00bc34 100644
--- a/cpp/src/parquet/ParquetConfig.cmake.in
+++ b/cpp/src/parquet/ParquetConfig.cmake.in
@@ -29,9 +29,15 @@
 
 @PACKAGE_INIT@
 
+set(PARQUET_SYSTEM_DEPENDENCIES "@PARQUET_SYSTEM_DEPENDENCIES@")
+
 include(CMakeFindDependencyMacro)
 find_dependency(Arrow)
 
+if(ARROW_BUILD_STATIC)
+  arrow_find_dependencies("${PARQUET_SYSTEM_DEPENDENCIES}")
+endif()
+
 set(PARQUET_VERSION "@ARROW_VERSION@")
 set(PARQUET_SO_VERSION "@ARROW_SO_VERSION@")
 set(PARQUET_FULL_SO_VERSION "@ARROW_FULL_SO_VERSION@")
diff --git a/cpp/src/parquet/parquet.pc.in b/cpp/src/parquet/parquet.pc.in
index b992eba81998a..6def1c5d8b399 100644
--- a/cpp/src/parquet/parquet.pc.in
+++ b/cpp/src/parquet/parquet.pc.in
@@ -27,6 +27,7 @@ Name: Apache Parquet
 Description: Apache Parquet is a columnar storage format.
 Version: @ARROW_VERSION@
 Requires: arrow
+Requires.private:@PARQUET_PC_REQUIRES_PRIVATE@
 Libs: -L${libdir} -lparquet
 Cflags: -I${includedir}
 Cflags.private: -DPARQUET_STATIC
diff --git a/dev/release/verify-apt.sh b/dev/release/verify-apt.sh
index 49671f01cc7e8..cbb6d93823b21 100755
--- a/dev/release/verify-apt.sh
+++ b/dev/release/verify-apt.sh
@@ -166,7 +166,7 @@ pushd build/minimal_build
 cmake .
 make -j$(nproc)
 ./arrow-example
-c++ -std=c++17 -o arrow-example example.cc $(pkg-config --cflags --libs arrow)
+c++ -o arrow-example example.cc $(pkg-config --cflags --libs arrow) -std=c++17
 ./arrow-example
 popd
 echo "::endgroup::"
diff --git a/dev/release/verify-yum.sh b/dev/release/verify-yum.sh
index 55fc0c1735931..a3904169bbf61 100755
--- a/dev/release/verify-yum.sh
+++ b/dev/release/verify-yum.sh
@@ -211,7 +211,7 @@ pushd build/minimal_build
 ${cmake_command} .
 make -j$(nproc)
 ./arrow-example
-c++ -std=c++17 -o arrow-example example.cc $(pkg-config --cflags --libs arrow)
+c++ -o arrow-example example.cc $(pkg-config --cflags --libs arrow) -std=c++17
 ./arrow-example
 popd
 echo "::endgroup::"
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/control.in b/dev/tasks/linux-packages/apache-arrow/debian/control.in
index 6b161ddef5d67..8c1bab8d058da 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/control.in
+++ b/dev/tasks/linux-packages/apache-arrow/debian/control.in
@@ -141,16 +141,12 @@ Depends:
   libarrow1400 (= ${binary:Version}),
   libbrotli-dev,
   libbz2-dev,
-  libc-ares-dev,
   libcurl4-openssl-dev,
-@USE_SYSTEM_GRPC@  libgrpc++-dev,
   liblz4-dev,
-@USE_SYSTEM_PROTOBUF@  libprotobuf-dev,
-@USE_SYSTEM_PROTOBUF@  libprotoc-dev,
+  libc-ares-dev,
   libre2-dev,
   libsnappy-dev,
   libssl-dev,
-  libthrift-dev,
   libutf8proc-dev,
   libzstd-dev,
   nlohmann-json-dev | nlohmann-json3-dev,
@@ -204,7 +200,11 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libarrow-flight1400 (= ${binary:Version})
+  libarrow-flight1400 (= ${binary:Version}),
+  libc-ares-dev,
+@USE_SYSTEM_GRPC@  libgrpc++-dev,
+@USE_SYSTEM_PROTOBUF@  libprotobuf-dev,
+@USE_SYSTEM_PROTOBUF@  libprotoc-dev
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for Flight RPC system.
@@ -280,7 +280,8 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libparquet1400 (= ${binary:Version})
+  libparquet1400 (= ${binary:Version}),
+  libthrift-dev
 Description: Apache Parquet is a columnar storage format
  .
  This package provides C++ header files.
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 8fe0313338030..6a87e19cd3091 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -273,14 +273,7 @@ License:	Apache-2.0
 Requires:	%{name}%{major_version}-libs = %{version}-%{release}
 Requires:	brotli-devel
 Requires:	bzip2-devel
-%if %{use_flight}
-Requires:	c-ares-devel
-%endif
 Requires:	curl-devel
-%if %{have_grpc}
-Requires:	grpc-devel
-Requires:	grpc-plugins
-%endif
 %if %{use_gcs}
 Requires:	json-devel
 %endif
@@ -413,6 +406,11 @@ Summary:	Libraries and header files for Apache Arrow Flight.
 License:	Apache-2.0
 Requires:	%{name}%{major_version}-flight-libs = %{version}-%{release}
 Requires:	%{name}-devel = %{version}-%{release}
+Requires:	c-ares-devel
+%if %{have_grpc}
+Requires:	grpc-devel
+Requires:	grpc-plugins
+%endif
 
 %description flight-devel
 Libraries and header files for Apache Arrow Flight.

From 5720f7c4f31c5985b130462c312c5da6c971e9e4 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 29 Aug 2023 09:25:02 +0900
Subject: [PATCH 256/749] GH-37408: [C++] Install arrow-compute.pc only when
 ARROW_COMPUTE=ON (#37409)

### Rationale for this change

GH-34295  changed meaning of `ARROW_COMPUTE`. `ARROW_COMPUTE=ON` means that "all compute kerenels are enabled" not "compute module is enabled".

`arrow-compute.pc`  is for detecting `ARROW_COMPUTE`. So `arrow-compute.pc` should be installed only when `ARROW_COMPUTE=ON`.

### What changes are included in this PR?

Add missing `if (ARROW_COMPUTE)`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37408

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/compute/CMakeLists.txt      | 6 ++++--
 cpp/src/arrow/compute/arrow-compute.pc.in | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/compute/CMakeLists.txt b/cpp/src/arrow/compute/CMakeLists.txt
index 1d71c14dca714..1134e0a98ae45 100644
--- a/cpp/src/arrow/compute/CMakeLists.txt
+++ b/cpp/src/arrow/compute/CMakeLists.txt
@@ -19,8 +19,10 @@ add_custom_target(arrow_compute)
 
 arrow_install_all_headers("arrow/compute")
 
-# pkg-config support
-arrow_add_pkg_config("arrow-compute")
+if(ARROW_COMPUTE)
+  # pkg-config support
+  arrow_add_pkg_config("arrow-compute")
+endif()
 
 #
 # Unit tests
diff --git a/cpp/src/arrow/compute/arrow-compute.pc.in b/cpp/src/arrow/compute/arrow-compute.pc.in
index 35bfb51683779..a94a0261cce3b 100644
--- a/cpp/src/arrow/compute/arrow-compute.pc.in
+++ b/cpp/src/arrow/compute/arrow-compute.pc.in
@@ -20,6 +20,6 @@ includedir=@ARROW_PKG_CONFIG_INCLUDEDIR@
 libdir=@ARROW_PKG_CONFIG_LIBDIR@
 
 Name: Apache Arrow Compute
-Description: Compute modules for Apache Arrow
+Description: All compute kernels for Apache Arrow
 Version: @ARROW_VERSION@
 Requires: arrow

From a2c16fbb258ad0b3cb71c8e50450df685cdfb8ee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 10:53:51 +0900
Subject: [PATCH 257/749] MINOR: [C#] Bump Microsoft.NET.Test.Sdk from 16.5.0
 to 17.7.1 in /csharp (#37422)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 16.5.0 to 17.7.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/releases">Microsoft.NET.Test.Sdk's releases</a>.</em></p>
<blockquote>
<h2>v17.7.1</h2>
<h2>What's Changed</h2>
<ul>
<li>Take System dlls from testhost folder to fix running .NET Framework dlls on mono and under VS on Mac in <a href="https://redirect.github.com/microsoft/vstest/issues/4610">#4610</a> by <a href="https://github.com/Evangelink"><code>@​Evangelink</code></a></li>
<li>Fix hangs in parallel execution and discovery in <a href="https://redirect.github.com/microsoft/vstest/issues/4629">#4629</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a></li>
<li>Fix executable bitness for testhost.x86 in <a href="https://redirect.github.com/microsoft/vstest/issues/4654">#4654</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.7.0...v17.7.1">https://github.com/microsoft/vstest/compare/v17.7.0...v17.7.1</a></p>
<h2>v17.7.0</h2>
<blockquote>
<p>⚠️ Microsoft.TestPlatform 17.7.0 nuget package is hidden from Nuget.org, we've encountered an unexpected issue with versioning which prevents it from being used in all AzDO clients. We are working on a fix.</p>
</blockquote>
<p>The most pressing issues were all backported to <a href="https://github.com/microsoft/vstest/releases/tag/v17.6.1">17.6.1</a>, <a href="https://github.com/microsoft/vstest/releases/tag/v17.6.2">17.6.2</a> and <a href="https://github.com/microsoft/vstest/releases/tag/v17.6.3">17.6.3</a>.</p>
<h2>Issues fixed (since 17.6.3)</h2>
<ul>
<li>
<p>Don't print socket transport error in console by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/issues/4493">#4493</a> which fixes <a href="https://redirect.github.com/microsoft/vstest/issues/4461">#4461</a>
When testhost crashes, we no longer print the transport error:</p>
<pre><code>---&gt; System.Exception: Unable to read data from the transport connection:
		An existing connection was forcibly closed by the remote host..
</code></pre>
<p>This error is a side-effect or our architecture is almost never the culprit. Instead it leads developers away from the actual issue which is crash of testhost, or datacollector.</p>
</li>
<li>
<p>Pass workloads to proxy managers in <a href="https://redirect.github.com/microsoft/vstest/issues/4422">#4422</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a>
Which allows datacollector users to only receive the sources that are currently running in the testhost associated to datacollector, instead of all the sources that have the same target framework.</p>
</li>
<li>
<p>Fix Newtonsoft versions in testhost.deps.json in <a href="https://redirect.github.com/microsoft/vstest/issues/4367">#4367</a> by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a>
testhost.runtimeconfig.json files that we ship with testhost contained an old version of Newtonsoft.Json. The version in this file does not have an effect on execution, but some compliance tools statically analyze it and report possible vulnerabilities.</p>
</li>
</ul>
<p>Other fixes:</p>
<ul>
<li>Replacing calls to BuildMultipleAssemblyPath when passing only one source in acceptance tests in <a href="https://redirect.github.com/microsoft/vstest/issues/4358">#4358</a> by <a href="https://github.com/daveMueller"><code>@​daveMueller</code></a></li>
<li>Check for null Path in <a href="https://redirect.github.com/microsoft/vstest/issues/4391">#4391</a> by <a href="https://github.com/lewing"><code>@​lewing</code></a></li>
<li>Remove unused variable in <a href="https://redirect.github.com/microsoft/vstest/issues/4425">#4425</a> by <a href="https://github.com/mthalman"><code>@​mthalman</code></a></li>
<li>Fix execution gets stucks on single netstandard source by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/issues/4497">#4497</a> which fixes <a href="https://redirect.github.com/microsoft/vstest/issues/4392">#4392</a></li>
<li>TestObject use ConcurrentDictionary instead of Dictionary in <a href="https://redirect.github.com/microsoft/vstest/issues/4450">#4450</a> by <a href="https://github.com/Evangelink"><code>@​Evangelink</code></a></li>
<li>Drop usage of Microsoft.Internal.TestPlatform.Remote in <a href="https://redirect.github.com/microsoft/vstest/issues/4456">#4456</a> by <a href="https://github.com/Evangelink"><code>@​Evangelink</code></a></li>
</ul>
<p>Special thanks to <a href="https://github.com/SimonCropp"><code>@​SimonCropp</code></a> for the many fixes regarding nullability spelling and code style in <a href="https://redirect.github.com/microsoft/vstest/issues/4518">#4518</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4520">#4520</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4525">#4525</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4526">#4526</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4521">#4521</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4519">#4519</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4522">#4522</a>, <a href="https://redirect.github.com/microsoft/vstest/issues/4529">#4529</a> 🙇</p>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.6.3...v17.7.0">https://github.com/microsoft/vstest/compare/v17.6.3...v17.7.0</a></p>
<h3>Drops</h3>
<ul>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.7.0">v17.7.0</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/blob/main/docs/releases.md">Microsoft.NET.Test.Sdk's changelog</a>.</em></p>
<blockquote>
<h1>Release Notes</h1>
<h2>17.6.1 and newer</h2>
<p>Please see release notes directly in the release page: <a href="https://github.com/microsoft/vstest/releases">https://github.com/microsoft/vstest/releases</a></p>
<h2>17.6.0</h2>
<h3>Issues Fixed</h3>
<ul>
<li>Add legacy feeds</li>
<li>[rel/17.6] Fix Newtonsoft versions in testhost.deps.json <a href="https://redirect.github.com/microsoft/vstest/pull/4372">#4372</a></li>
<li>Revert &quot;Revert &quot;Fix signature verification&quot; (<a href="https://redirect.github.com/microsoft/vstest/issues/4333">#4333</a>&quot; <a href="https://redirect.github.com/microsoft/vstest/pull/4345">#4345</a></li>
<li>Revert &quot;Fix signature verification&quot; <a href="https://redirect.github.com/microsoft/vstest/pull/4333">#4333</a></li>
<li>Fix signature verification <a href="https://redirect.github.com/microsoft/vstest/pull/4331">#4331</a></li>
<li>Pre-start testhosts <a href="https://redirect.github.com/microsoft/vstest/pull/3666">#3666</a></li>
<li>Add <code>dotnet vstest</code> deprecation message <a href="https://redirect.github.com/microsoft/vstest/pull/4297">#4297</a></li>
<li>Catch unhandled exception and avoid crash on test host exit <a href="https://redirect.github.com/microsoft/vstest/pull/4291">#4291</a></li>
<li>Remove chutzpah <a href="https://redirect.github.com/microsoft/vstest/pull/4249">#4249</a></li>
<li>Fix string conversion of <code>Microsoft.TestPlatform.Extensions.TrxLogger.ObjectMode.TestOutcome</code> <a href="https://redirect.github.com/microsoft/vstest/pull/4243">#4243</a></li>
<li>Fix potential trx logger NRE <a href="https://redirect.github.com/microsoft/vstest/pull/4240">#4240</a></li>
<li>handle object disposed exception <a href="https://redirect.github.com/microsoft/vstest/pull/4221">#4221</a></li>
<li>Added support for checking testhost compatibility with test sessions <a href="https://redirect.github.com/microsoft/vstest/pull/4199">#4199</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.5.0...v17.6.0">here</a></p>
<h3>Artifacts</h3>
<ul>
<li>TestPlatform vsix: <a href="https://vsdrop.corp.microsoft.com/file/v1/Products/DevDiv/microsoft/vstest/17.6/20230515-01;/TestPlatform.vsix">17.6.0</a></li>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.6.0">17.6.0</a></li>
</ul>
<h2>17.3.3</h2>
<h3>Issues Fixed</h3>
<ul>
<li>[rel/17.3] Update Newtonsoft.Json to 13.0.1 <a href="https://redirect.github.com/microsoft/vstest/pull/4299">#4299</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.3.2...v17.3.3">here</a></p>
<h3>Drops</h3>
<ul>
<li>TestPlatform vsix: <a href="https://vsdrop.corp.microsoft.com/file/v1/Products/DevDiv/microsoft/vstest/17.3/20230324-03;/TestPlatform.vsix">17.3.3</a></li>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.3.3">17.3.3</a></li>
</ul>
<h2>17.2.1</h2>
<h3>Issues Fixed</h3>
<ul>
<li>[rel/17.2] Update Newtonsoft.Json to 13.0.1 <a href="https://redirect.github.com/microsoft/vstest/pull/4310">#4310</a></li>
</ul>
<p>See full log <a href="https://github.com/microsoft/vstest/compare/v17.2.0...v17.2.1">here</a></p>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/vstest/commit/76fea143ffe5e3883dcd04e0923b4b8e1e158145"><code>76fea14</code></a> Fix executable bitness for testhost.x86 (<a href="https://redirect.github.com/microsoft/vstest/issues/4652">#4652</a>) (<a href="https://redirect.github.com/microsoft/vstest/issues/4654">#4654</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/c59bb292a6a72ca9268439f50931dd5d1cc4ded2"><code>c59bb29</code></a> RTM build fix (<a href="https://redirect.github.com/microsoft/vstest/issues/4643">#4643</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/52b57f08f0c7860f087f2a02ba9fc360c52f8644"><code>52b57f0</code></a> Backport recent fixes (<a href="https://redirect.github.com/microsoft/vstest/issues/4632">#4632</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/f6bfa29dc08ae44ab27a9cf2d98ad18c4e62dbe7"><code>f6bfa29</code></a> [rel/17.7] Fix branding on 17.7-release (<a href="https://redirect.github.com/microsoft/vstest/issues/4615">#4615</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/bc17bb9693cfc4778ded51aa0ab7f1065433f989"><code>bc17bb9</code></a> [rel/17.7] Update dependencies from devdiv/DevDiv/vs-code-coverage (<a href="https://redirect.github.com/microsoft/vstest/issues/4602">#4602</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/f0bc50efe4379126b49b24123f247cce0cf83f04"><code>f0bc50e</code></a> Revert &quot;Fix yml to generate RTM/stable version &amp; fix symbol check issues (<a href="https://redirect.github.com/microsoft/vstest/issues/46">#46</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/fab9246e637e863a1c4311eff462035168ce7907"><code>fab9246</code></a> Fix yml to generate RTM/stable version &amp; fix symbol check issues (<a href="https://redirect.github.com/microsoft/vstest/issues/4600">#4600</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/d7f4faa42b22ba20d697b530dd6809a0c02e6278"><code>d7f4faa</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/132324c9f65e0dc9e6b76fe0d34a13227e2d3b36"><code>132324c</code></a> Consume localized resources in source-build (<a href="https://redirect.github.com/microsoft/vstest/issues/4564">#4564</a>) (<a href="https://redirect.github.com/microsoft/vstest/issues/4567">#4567</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/18e0eaa980b569c039332054d52d2f1f6ba70823"><code>18e0eaa</code></a> Externals final 17.7 upgrade (<a href="https://redirect.github.com/microsoft/vstest/issues/4565">#4565</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/microsoft/vstest/compare/v16.5.0...v17.7.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.NET.Test.Sdk&package-manager=nuget&previous-version=16.5.0&new-version=17.7.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 5d2b7ab47aad9..dcc036edb1e84 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
       <PackageReference Include="xunit" Version="2.4.0" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
       <PackageReference Include="coverlet.collector" Version="1.2.0" />

From e86291c893b6ad1e6f5f6be10efd78210ca86a40 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 14:10:23 +0900
Subject: [PATCH 258/749] MINOR: [C#] Bump coverlet.collector from 1.2.0 to
 6.0.0 in /csharp (#37423)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [coverlet.collector](https://github.com/coverlet-coverage/coverlet) from 1.2.0 to 6.0.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/coverlet-coverage/coverlet/releases">coverlet.collector's releases</a>.</em></p>
<blockquote>
<h2>v6.0.0</h2>
<p>Fixed
-Could not write lines to file CoverletSourceRootsMapping - in use by another process <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1155">coverlet-coverage/coverlet#1155</a><br />
-Incorrect coverage for methods returning IAsyncEnumerable in generic classes <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1383">coverlet-coverage/coverlet#1383</a><br />
-Wrong branch coverage for async methods .NET Standard 1.x <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1376">coverlet-coverage/coverlet#1376</a><br />
-Empty path exception in visual basic projects <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/775">coverlet-coverage/coverlet#775</a><br />
-Align published nuget package version to github release version <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1413">coverlet-coverage/coverlet#1413</a><br />
-Sync nuget and github release versions <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1122">coverlet-coverage/coverlet#1122</a></p>
<p>Improvements
-Migration of the project to .NET 6.0 <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1473">coverlet-coverage/coverlet#1473</a></p>
<p>Breaking changes
New parameter ExcludeAssembliesWithoutSources to control automatic assembly exclusion <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1164">coverlet-coverage/coverlet#1164</a>. The parameter InstrumentModulesWithoutLocalSources has been removed. since it can be handled by setting ExcludeAssembliesWithoutSources to None.
The default heuristics for determining whether to instrument an assembly has been changed. In previous versions any missing source file was taken as a signal that it was a third-party project that shouldn't be instrumented, with exceptions for some common file name patterns for source generators. Now only assemblies where no source files at all can be found are excluded from instrumentation, and the code for detecting source generator files have been removed. To get back to the behaviour that at least one missing file is sufficient to exclude an assembly, set ExcludeAssembliesWithoutSources to MissingAny, or use assembly exclusion filters for more fine-grained control.</p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.2...v6.0.0">Diff between 3.2.0 and 6.0.0</a></p>
<h2>v5.8.0</h2>
<h3>Fixed</h3>
<p>-Fix TypeLoadException when referencing Microsoft.Extensions.DependencyInjection v6.0.1 <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1390">#1390</a><br />
-Source Link for code generators fails <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1322">#1322</a><br />
-Await foreach has wrong branch coverage when method is generic <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1210">#1210</a><br />
-ExcludeFromCodeCoverage attribute on local functions ignores lambda expression <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1302">#1302</a></p>
<h3>Added</h3>
<p>-Added InstrumentModulesWithoutLocalSources setting <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1360">#1360</a> by <a href="https://github.com/TFTomSun"><code>@​TFTomSun</code></a></p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.2...v5.8.0">Diff between 3.1.2 and 3.2.0</a></p>
<h2>v5.7.2</h2>
<p>Fixed
-Fix CoreLib's coverage measurement is broken <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1286">#1286</a>
-Fix UnloadModule injection <a href="https://redirect.github.com/coverlet-coverage/coverlet/pull/1291">1291</a></p>
<p><a href="https://github.com/coverlet-coverage/coverlet/compare/v5.7.1...v5.7.2">Diff between 3.1.1 and 3.1.2</a></p>
<h2>v5.7.1</h2>
<p>Fixed
-Fix wrong branch coverage with EnumeratorCancellation attribute <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1275">#1275</a> -Fix negative coverage exceeding int.MaxValue <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1266">#1266</a>
-Fix summary output format for culture de-DE <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1263">#1263</a>
-Fix branch coverage issue for finally block with await <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1233">#1233</a>
-Fix threshold doesn't work when coverage empty <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1205">#1205</a>
-Fix branch coverage issue for il switch <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1177">#1177</a>
-Fix branch coverage with using statement and several awaits#1176
-Fix CopyCoverletDataCollectorFiles to avoid to override user dlls for dotnet publish scenario <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1243">#1243</a></p>
<p>Improvements
-Improve logging in case of exception inside static ctor of NetstandardAwareAssemblyResolver <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1230">#1230</a>
-When collecting open the hitfile with read access <a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1214">#1214</a> by <a href="https://github.com/JamesWTruher">https://github.com/JamesWTruher</a></p>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/6427ae3c87494fc04e576bd367c22153f92699fd"><code>6427ae3</code></a> Rebrand for next version 6.0.1 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1478">#1478</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/b288808ee73c87f34b2e4b0871931674be729ea8"><code>b288808</code></a> Prepare release 6.0.0 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1477">#1477</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/4e58654ee6ec406ca8a46b0f3bc7a2f699616e19"><code>4e58654</code></a> Bump Mono.Cecil (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1476">#1476</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/98b84d207558a08f60dff58f99b2afe69ca72b64"><code>98b84d2</code></a> migration to .net 6.0 (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1473">#1473</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/d93613826b1a33f894b9c80f6ae893643a8b7254"><code>d936138</code></a> Fixes CoverletSourceRootsMapping issue (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1456">#1456</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/3bbe50284571b9ae4f3a0f8a08bd66013adb2177"><code>3bbe502</code></a> Update collector docs with info about passing format without runsettings file...</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/a014bf0cd0fdb5a65a24df393d254ae98f7f45f9"><code>a014bf0</code></a> Path is empty for VB My namespace (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1073">#1073</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/1ff097d22c640a45b65e52156d4a1e3202a53f4a"><code>1ff097d</code></a> Wrong branch coverage for async methods .NET Standard 1.x  (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1433">#1433</a>)</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/04b82c23d8e2f5a37ff3f0648dc1aea120859332"><code>04b82c2</code></a> Incorrect coverage for methods returning IAsyncEnumerable in generic classes ...</li>
<li><a href="https://github.com/coverlet-coverage/coverlet/commit/72d5ee289f859f18c20e70885e52797af09ccd63"><code>72d5ee2</code></a> Large CC XML error (<a href="https://redirect.github.com/coverlet-coverage/coverlet/issues/1428">#1428</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/coverlet-coverage/coverlet/compare/v1.2.0...v6.0.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=coverlet.collector&package-manager=nuget&previous-version=1.2.0&new-version=6.0.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index dcc036edb1e84..99389a6957e0a 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -9,7 +9,7 @@
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
       <PackageReference Include="xunit" Version="2.4.0" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
-      <PackageReference Include="coverlet.collector" Version="1.2.0" />
+      <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
 
     <ItemGroup>

From bfd01f938ba3d17d24610423c8dcbf7cc73f45dd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 14:10:43 +0900
Subject: [PATCH 259/749] MINOR: [C#] Bump xunit from 2.4.0 to 2.5.0 in /csharp
 (#37424)

Bumps [xunit](https://github.com/xunit/xunit) from 2.4.0 to 2.5.0.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/12ec6b87aea7ad0496aa053e11b84d4c928f90a8"><code>12ec6b8</code></a> Bump up to v2.5.1-pre</li>
<li><a href="https://github.com/xunit/xunit/commit/92f31c4c3a4adf391a19e6c9b531f4195636f132"><code>92f31c4</code></a> v2.5.0</li>
<li><a href="https://github.com/xunit/xunit/commit/188216b64a3bb9a141cb2851fce47264f29593bf"><code>188216b</code></a> Ensure both failed tests and error cause error return codes (and cancel for s...</li>
<li><a href="https://github.com/xunit/xunit/commit/c97317920dcd10e88264adf6c81a303aca7bfc06"><code>c973179</code></a> Latest analyzers</li>
<li><a href="https://github.com/xunit/xunit/commit/f93d52dbf743957131287690bef34a518c402eae"><code>f93d52d</code></a> Propagate StopOnFail from config file =&gt; execution options</li>
<li><a href="https://github.com/xunit/xunit/commit/5e70f54cab281f0d19ababd6dea9832518137a4d"><code>5e70f54</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2737">#2737</a>: Restore XunitException constructor (breaking change) (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/028866f82155319ffa583503245aa5ec438f7804"><code>028866f</code></a> Add PackageDownload for Microsoft.NETFramework.ReferenceAssemblies.net452 to ...</li>
<li><a href="https://github.com/xunit/xunit/commit/aeba1bbfc354d24ce2ddb17e1d248bf5ddf7b4cc"><code>aeba1bb</code></a> Remove UAP/UWP support</li>
<li><a href="https://github.com/xunit/xunit/commit/530802128e5acd624406f35869ab61d73d6c0514"><code>5308021</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/1857">#1857</a>: Add overload to Assert.Contains for ConcurrentDictionary (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/5fbaa0a34994a5293589c47935bfbfe49b29357c"><code>5fbaa0a</code></a> Incorrect type restriction on obsoleted Assert.ThrowsAny&lt;T&gt; for Func&lt;Task&gt; an...</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/xunit/compare/2.4...2.5.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.4.0&new-version=2.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 99389a6957e0a..860f7c9b34f69 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -7,7 +7,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
-      <PackageReference Include="xunit" Version="2.4.0" />
+      <PackageReference Include="xunit" Version="2.5.0" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>

From 29819425f428d703ad5c80cc0afaf7902dbbb224 Mon Sep 17 00:00:00 2001
From: James Henderson <jms@juxt.pro>
Date: Tue, 29 Aug 2023 11:59:31 +0100
Subject: [PATCH 260/749] MINOR: [Docs][Java] Fix typo in javadoc (#37435)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Hey folks - while I wouldn't normally submit a PR for a small javadoc typo, this one was [rather unfortunate](https://dictionary.cambridge.org/dictionary/english/coon)...

(I, of course, have no doubt that it was unintentional!)

James

Authored-by: James Henderson <jms@juxt.pro>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .../org/apache/arrow/vector/complex/AbstractStructVector.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/AbstractStructVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/AbstractStructVector.java
index be6d992338996..797a5af31f9a4 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/AbstractStructVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/AbstractStructVector.java
@@ -78,7 +78,7 @@ public enum ConflictPolicy {
   }
 
   /**
-   *  Base coonstructor that sets default conflict policy to APPEND.
+   *  Base constructor that sets default conflict policy to APPEND.
    */
   protected AbstractStructVector(String name,
                                  BufferAllocator allocator,

From 439d066effa7b774a47c8a9727a14741fc46de99 Mon Sep 17 00:00:00 2001
From: Frederic Branczyk <fbranczyk@gmail.com>
Date: Tue, 29 Aug 2023 18:05:02 +0200
Subject: [PATCH 261/749] MINOR: [Go] Export IndexBuilder struct (#37438)

We allow accessing the IndexBuilder since GH-37416 merged. While the `Builder` interface functions can be accessed, the actual array builder cannot.

### Rationale for this change

#37416 added the function to access the index builder, but since it returns the `Builder` interface, we can't actually access the underlying builder as the unexported `IndexBuilder` is unexported.

Alternatives could be:

* Return `indexBuilder.Builder` instead in the `IndexBuilder()` function
* Return the unexported `indexBuilder` type, but this tends to be more awkward to use

### What changes are included in this PR?

Exporting the type so it can be type asserted.

### Are these changes tested?

Yes, rolled this out in our infra.

### Are there any user-facing changes?

Yes, but this API hasn't been released yet.

Authored-by: Frederic Branczyk <fbranczyk@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/dictionary.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index a7994db6b51bb..d0a1c4dc97e1d 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -314,13 +314,13 @@ func arrayApproxEqualDict(l, r *Dictionary, opt equalOption) bool {
 }
 
 // helper for building the properly typed indices of the dictionary builder
-type indexBuilder struct {
+type IndexBuilder struct {
 	Builder
 	Append func(int)
 }
 
-func createIndexBuilder(mem memory.Allocator, dt arrow.FixedWidthDataType) (ret indexBuilder, err error) {
-	ret = indexBuilder{Builder: NewBuilder(mem, dt)}
+func createIndexBuilder(mem memory.Allocator, dt arrow.FixedWidthDataType) (ret IndexBuilder, err error) {
+	ret = IndexBuilder{Builder: NewBuilder(mem, dt)}
 	switch dt.ID() {
 	case arrow.INT8:
 		ret.Append = func(idx int) {
@@ -420,7 +420,7 @@ type dictionaryBuilder struct {
 	dt          *arrow.DictionaryType
 	deltaOffset int
 	memoTable   hashing.MemoTable
-	idxBuilder  indexBuilder
+	idxBuilder  IndexBuilder
 }
 
 // NewDictionaryBuilderWithDict initializes a dictionary builder and inserts the values from `init` as the first
@@ -946,7 +946,7 @@ func (b *dictionaryBuilder) AppendArray(arr arrow.Array) error {
 	return nil
 }
 
-func (b *dictionaryBuilder) IndexBuilder() Builder {
+func (b *dictionaryBuilder) IndexBuilder() IndexBuilder {
 	return b.idxBuilder
 }
 

From f36855a3110a09d408df58582ee2c6341a0cdb48 Mon Sep 17 00:00:00 2001
From: Vibhatha Lakmal Abeykoon <vibhatha@users.noreply.github.com>
Date: Tue, 29 Aug 2023 22:07:46 +0530
Subject: [PATCH 262/749] GH-35296: [Go] Add arrow.Table.String() (#35580)

This PR fixes https://github.com/apache/arrow/issues/35296
* Closes: #35296

Authored-by: vibhatha <vibhatha@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/table.go      | 20 ++++++++++++++++
 go/arrow/array/table_test.go | 45 ++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+)

diff --git a/go/arrow/array/table.go b/go/arrow/array/table.go
index d23ca60599440..6456992e34973 100644
--- a/go/arrow/array/table.go
+++ b/go/arrow/array/table.go
@@ -20,6 +20,7 @@ import (
 	"errors"
 	"fmt"
 	"math"
+	"strings"
 	"sync/atomic"
 
 	"github.com/apache/arrow/go/v14/arrow"
@@ -257,6 +258,25 @@ func (tbl *simpleTable) Release() {
 	}
 }
 
+func (tbl *simpleTable) String() string {
+	o := new(strings.Builder)
+	o.WriteString(tbl.Schema().String())
+	o.WriteString("\n")
+
+	for i := 0; i < int(tbl.NumCols()); i++ {
+		col := tbl.Column(i)
+		o.WriteString(col.Field().Name + ": [")
+		for j, chunk := range col.Data().Chunks() {
+			if j != 0 {
+				o.WriteString(", ")
+			}
+			o.WriteString(chunk.String())
+		}
+		o.WriteString("]\n")
+	}
+	return o.String()
+}
+
 // TableReader is a Record iterator over a (possibly chunked) Table
 type TableReader struct {
 	refCount int64
diff --git a/go/arrow/array/table_test.go b/go/arrow/array/table_test.go
index 938ec7948f162..8e22d53963ba4 100644
--- a/go/arrow/array/table_test.go
+++ b/go/arrow/array/table_test.go
@@ -786,3 +786,48 @@ func TestTableReader(t *testing.T) {
 		})
 	}
 }
+
+func TestTableToString(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer mem.AssertSize(t, 0)
+
+	schema := arrow.NewSchema(
+		[]arrow.Field{
+			{Name: "f1-i32", Type: arrow.PrimitiveTypes.Int32},
+			{Name: "f2-f64", Type: arrow.PrimitiveTypes.Float64},
+		},
+		nil,
+	)
+
+	b := array.NewRecordBuilder(mem, schema)
+	defer b.Release()
+
+	b.Field(0).(*array.Int32Builder).AppendValues([]int32{1, 2, 3, 4, 5, 6}, nil)
+	b.Field(0).(*array.Int32Builder).AppendValues([]int32{7, 8, 9, 10}, []bool{true, true, false, true})
+	b.Field(1).(*array.Float64Builder).AppendValues([]float64{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}, nil)
+
+	rec1 := b.NewRecord()
+	defer rec1.Release()
+
+	b.Field(0).(*array.Int32Builder).AppendValues([]int32{111, 112, 113, 114, 115, 116, 117, 118, 119, 120}, nil)
+	b.Field(1).(*array.Float64Builder).AppendValues([]float64{211, 212, 213, 214, 215, 216, 217, 218, 219, 220}, nil)
+
+	rec2 := b.NewRecord()
+	defer rec2.Release()
+
+	tbl := array.NewTableFromRecords(schema, []arrow.Record{rec1, rec2})
+	defer tbl.Release()
+
+	table_str := tbl.String()
+	expected_str :=
+		`schema:
+  fields: 2
+    - f1-i32: type=int32
+    - f2-f64: type=float64
+f1-i32: [[1 2 3 4 5 6 7 8 (null) 10], [111 112 113 114 115 116 117 118 119 120]]
+f2-f64: [[11 12 13 14 15 16 17 18 19 20], [211 212 213 214 215 216 217 218 219 220]]
+`
+	if got, want := table_str, expected_str; table_str != expected_str {
+		t.Fatalf("invalid String: got=%#v, want=%#v", got, want)
+	}
+}

From 5bb16d70717941918a8dbbc74e6a04fb5f191260 Mon Sep 17 00:00:00 2001
From: Ian Cook <ianmcook@gmail.com>
Date: Tue, 29 Aug 2023 19:46:32 -0400
Subject: [PATCH 263/749] GH-37447: [C++][Docs] Document `ARROW_SUBSTRAIT`
 CMake flag (#37451)

Documents the `ARROW_SUBSTRAIT` flag added in #31565 / #12915 and adds a missing seimcolon to the docs entry for `ARROW_WITH_RE2`.
* Closes: #37447

Authored-by: Ian Cook <ianmcook@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/cpp/building.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/source/developers/cpp/building.rst b/docs/source/developers/cpp/building.rst
index dfd0f6ceec5f7..5fab745679e93 100644
--- a/docs/source/developers/cpp/building.rst
+++ b/docs/source/developers/cpp/building.rst
@@ -374,7 +374,8 @@ boolean flags to ``cmake``.
   ``ARROW_FILESYSTEM``, ``ARROW_HDFS``, and ``ARROW_JSON`` directly
   instead.
 * ``-DARROW_S3=ON``: Support for Amazon S3-compatible filesystems
-* ``-DARROW_WITH_RE2=ON`` Build with support for regular expressions using the re2 
+* ``-DARROW_SUBSTRAIT=ON``: Build with support for Substrait
+* ``-DARROW_WITH_RE2=ON``: Build with support for regular expressions using the re2 
   library, on by default and used when ``ARROW_COMPUTE`` or ``ARROW_GANDIVA`` is ``ON``
 * ``-DARROW_WITH_UTF8PROC=ON``: Build with support for Unicode properties using
   the utf8proc library, on by default and used when ``ARROW_COMPUTE`` or ``ARROW_GANDIVA``

From 8ba3264e5a647d817f17be29f744b55c87e6fff7 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 30 Aug 2023 09:11:52 +0900
Subject: [PATCH 264/749] GH-37394: [C++][S3] Use AWS_SDK_VERSION_* instead of
 try_compile() (#37395)

### Rationale for this change

I don't know why but `try_compile()` based `Aws::SDKOptions::ioOptions` detection seems not work on some environments. Some unrelated errors may be happen.

### What changes are included in this PR?

Using `AWS_SDK_VERSION_{MAJOR,MINOR,PATCH}` instead of `try_compile()`.

Downside: `AWS_SDK_VERSION_*` are available since 1.9.7 or later but `Aws::SDKOptions::ioOptions` is available since 1.9.0. So we can't detect `Aws::SDKOptions::ioOptions` with [1.9.0,1.9.6]. I think that it's acceptable.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37394

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/CMakeLists.txt                  | 10 -----
 cpp/src/arrow/filesystem/s3fs.cc              | 39 +++++++++++++++----
 .../filesystem/try_compile/check_s3fs_crt.cc  | 28 -------------
 3 files changed, 31 insertions(+), 46 deletions(-)
 delete mode 100644 cpp/src/arrow/filesystem/try_compile/check_s3fs_crt.cc

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index a398e790de14b..ba3f0ef30dd93 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -497,16 +497,6 @@ if(ARROW_FILESYSTEM)
     list(APPEND ARROW_SRCS filesystem/hdfs.cc)
   endif()
   if(ARROW_S3)
-    try_compile(S3_HAS_CRT ${CMAKE_CURRENT_BINARY_DIR}/try_compile
-                SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/filesystem/try_compile/check_s3fs_crt.cc"
-                CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CURRENT_INCLUDE_DIRECTORIES}"
-                LINK_LIBRARIES ${AWSSDK_LINK_LIBRARIES} CXX_STANDARD 17)
-
-    if(S3_HAS_CRT)
-      message(STATUS "AWS SDK is new enough to have CRT support")
-      add_definitions(-DARROW_S3_HAS_CRT)
-    endif()
-
     list(APPEND ARROW_SRCS filesystem/s3fs.cc)
     set_source_files_properties(filesystem/s3fs.cc
                                 PROPERTIES SKIP_PRECOMPILE_HEADERS ON
diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index c67f7668ffa4d..29f8882225ae3 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -44,6 +44,7 @@
 
 #include <aws/core/Aws.h>
 #include <aws/core/Region.h>
+#include <aws/core/VersionConfig.h>
 #include <aws/core/auth/AWSCredentials.h>
 #include <aws/core/auth/AWSCredentialsProviderChain.h>
 #include <aws/core/auth/STSCredentialsProvider.h>
@@ -53,11 +54,6 @@
 #include <aws/core/utils/logging/ConsoleLogSystem.h>
 #include <aws/core/utils/stream/PreallocatedStreamBuf.h>
 #include <aws/core/utils/xml/XmlSerializer.h>
-#ifdef ARROW_S3_HAS_CRT
-#include <aws/crt/io/Bootstrap.h>
-#include <aws/crt/io/EventLoopGroup.h>
-#include <aws/crt/io/HostResolver.h>
-#endif
 #include <aws/identity-management/auth/STSAssumeRoleCredentialsProvider.h>
 #include <aws/s3/S3Client.h>
 #include <aws/s3/S3Errors.h>
@@ -80,6 +76,35 @@
 #include <aws/s3/model/PutObjectRequest.h>
 #include <aws/s3/model/UploadPartRequest.h>
 
+// AWS_SDK_VERSION_{MAJOR,MINOR,PATCH} are available since 1.9.7.
+#if defined(AWS_SDK_VERSION_MAJOR) && defined(AWS_SDK_VERSION_MINOR) && \
+    defined(AWS_SDK_VERSION_PATCH)
+// Redundant "(...)" are for suppressing "Weird number of spaces at
+// line-start. Are you using a 2-space indent? [whitespace/indent]
+// [3]" errors...
+#define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch)                      \
+  ((AWS_SDK_VERSION_MAJOR > (major) ||                                        \
+    (AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR > (minor)) ||  \
+    ((AWS_SDK_VERSION_MAJOR == (major) && AWS_SDK_VERSION_MINOR == (minor) && \
+      AWS_SDK_VERSION_PATCH >= (patch)))))
+#else
+#define ARROW_AWS_SDK_VERSION_CHECK(major, minor, patch) 0
+#endif
+
+// This feature is available since 1.9.0 but
+// AWS_SDK_VERSION_{MAJOR,MINOR,PATCH} are available since 1.9.7. So
+// we can't use this feature for [1.9.0,1.9.6]. If it's a problem,
+// please report it to our issue tracker.
+#if ARROW_AWS_SDK_VERSION_CHECK(1, 9, 0)
+#define ARROW_S3_HAS_CRT
+#endif
+
+#ifdef ARROW_S3_HAS_CRT
+#include <aws/crt/io/Bootstrap.h>
+#include <aws/crt/io/EventLoopGroup.h>
+#include <aws/crt/io/HostResolver.h>
+#endif
+
 #include "arrow/util/windows_fixup.h"
 
 #include "arrow/buffer.h"
@@ -2913,9 +2938,7 @@ struct AwsInstance {
       return std::make_shared<Aws::Utils::Logging::ConsoleLogSystem>(
           aws_options_.loggingOptions.logLevel);
     };
-#if (defined(AWS_SDK_VERSION_MAJOR) &&                          \
-     (AWS_SDK_VERSION_MAJOR > 1 || AWS_SDK_VERSION_MINOR > 9 || \
-      (AWS_SDK_VERSION_MINOR == 9 && AWS_SDK_VERSION_PATCH >= 272)))
+#if ARROW_AWS_SDK_VERSION_CHECK(1, 9, 272)
     // ARROW-18290: escape all special chars for compatibility with non-AWS S3 backends.
     // This configuration options is only available with AWS SDK 1.9.272 and later.
     aws_options_.httpOptions.compliantRfc3986Encoding = true;
diff --git a/cpp/src/arrow/filesystem/try_compile/check_s3fs_crt.cc b/cpp/src/arrow/filesystem/try_compile/check_s3fs_crt.cc
deleted file mode 100644
index 83240effdbf4b..0000000000000
--- a/cpp/src/arrow/filesystem/try_compile/check_s3fs_crt.cc
+++ /dev/null
@@ -1,28 +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.
-
-// Dummy file for checking if IOOptions exists in SDKOptions.
-// This was introduced when the AWS SDK switched to using the
-// CRT for I/O.
-
-#include <aws/core/Aws.h>
-
-int main() {
-  Aws::SDKOptions aws_options;
-  auto io_options = aws_options.ioOptions;
-  return 0;
-}

From 2bb6be1d337583678b0661a8ecfcb2b0f3291a02 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 29 Aug 2023 20:22:49 -0400
Subject: [PATCH 265/749] GH-37367: [MATLAB] Add `arrow.array.Date32Array`
 class (#37445)

### Rationale for this change

Now that `arrow.type.Date32Type` class has been added to the MATLAB Interface (#37348), we can add the `arrow.array.Date32Array` class.

`Date32Array`s can be created from MATLAB [`datetime`](https://www.mathworks.com/help/matlab/ref/datetime.html) values.

### What changes are included in this PR?

1. Added a new `arrow.array.Date32Array` class.
2. Added a new `arrow.type.traits.Date32Traits` class.
3. Added `arrow.type.Date32Type` support to `arrow.type.traits.traits` function.
4. Fixed typo `arrray` in `tTime32Array` test class.
5. Fixed bug in `numeric_array.h` where the `CType` rather than the `ArrowType` was being used to determine the `DataType` of an array class that is a `NumericArray<T>`.

`Date32Array`s can be created from MATLAB [`datetime`](https://www.mathworks.com/help/matlab/ref/datetime.html) values using the `fromMATLAB` method. `Date32Array`s can be converted to MATLAB `datetime` values using the `toMATLAB` method.

**Example**
```matlab
>> dates = [datetime(2021, 1, 2, 3, 4, 5), datetime(2023, 1, 1), datetime(1989, 2, 3, 10, 10, 10)]'

dates =

  3x1 datetime array

   02-Jan-2021 03:04:05
   01-Jan-2023 00:00:00
   03-Feb-1989 10:10:10

>> array = arrow.array.Date32Array.fromMATLAB(dates)

array =

[
  2021-01-02,
  2023-01-01,
  1989-02-03
]

>> array.toMATLAB()

ans =

  3x1 datetime array

   02-Jan-2021
   01-Jan-2023
   03-Feb-1989
```

### Are these changes tested?

Yes.

1. Added a new `tDate32Array` test class.
2. Added `Date32` related test to `ttraits.m`.
6. Added a new `tDate32Traits.m` test class.

### Are there any user-facing changes?

Yes.

1. Users can now create `arrow.array.Date32Array`s  from MATLAB `datetime`s.

### Future Directions

1. #37230
2. Add `arrow.array.Date64Array`.
3. Add a way to extract the raw `int32` values from an `arrow.array.Date32Array` without converting to a MATLAB `datetime` using `toMATLAB`.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37367

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../arrow/matlab/array/proxy/numeric_array.h  |   2 +-
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   2 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   1 +
 .../src/cpp/arrow/matlab/type/proxy/traits.h  |   6 +
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   3 +
 matlab/src/matlab/+arrow/+array/Date32Array.m |  92 ++++++
 .../+tabular/createAllSupportedArrayTypes.m   |  11 +-
 .../+arrow/+type/+traits/Date32Traits.m       |  30 ++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   2 +
 matlab/test/arrow/array/tDate32Array.m        | 295 ++++++++++++++++++
 matlab/test/arrow/array/tTime32Array.m        |   8 +-
 matlab/test/arrow/type/traits/tDate32Traits.m |  33 ++
 matlab/test/arrow/type/traits/ttraits.m       |  14 +-
 13 files changed, 492 insertions(+), 7 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+array/Date32Array.m
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/Date32Traits.m
 create mode 100644 matlab/test/arrow/array/tDate32Array.m
 create mode 100644 matlab/test/arrow/type/traits/tDate32Traits.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index 9c81d5ff6218e..f9da38dbaa062 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -56,7 +56,7 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
             
             auto data_buffer = std::make_shared<MatlabBuffer>(numeric_mda);
 
-            const auto data_type = arrow::CTypeTraits<CType>::type_singleton();
+            const auto data_type = arrow::TypeTraits<ArrowType>::type_singleton();
             const auto length = static_cast<int64_t>(numeric_mda.getNumberOfElements()); // cast size_t to int64_t
 
             // Pack the validity bitmap values.
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index 3d1881a7dfb58..104eecbb4f266 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -55,6 +55,8 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::Time32Type>>(std::static_pointer_cast<arrow::Time32Array>(array));
             case ID::TIME64:
                 return std::make_shared<proxy::NumericArray<arrow::Time64Type>>(std::static_pointer_cast<arrow::Time64Array>(array));
+            case ID::DATE32:
+                return std::make_shared<proxy::NumericArray<arrow::Date32Type>>(std::static_pointer_cast<arrow::Date32Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
             default:
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 7a84810c5a93c..0ad8d52cd53a6 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -54,6 +54,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
+    REGISTER_PROXY(arrow.array.proxy.Date32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
index fdae911062b28..a4c5d06f8ff22 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
@@ -23,6 +23,7 @@
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
+#include "arrow/matlab/type/proxy/date32_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -99,4 +100,9 @@ namespace arrow::matlab::type::proxy {
     struct Traits<arrow::Time64Type> {
         using TypeProxy = Time64Type;
     };
+
+    template <>
+    struct Traits<arrow::Date32Type> {
+        using TypeProxy = Date32Type;
+    };
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index efb510e89751d..7dfdf58e1dd21 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -21,6 +21,7 @@
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
+#include "arrow/matlab/type/proxy/date32_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -56,6 +57,8 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<Time32Type>(std::static_pointer_cast<arrow::Time32Type>(type));
             case ID::TIME64:
                 return std::make_shared<Time64Type>(std::static_pointer_cast<arrow::Time64Type>(type));
+            case ID::DATE32:
+                return std::make_shared<Date32Type>(std::static_pointer_cast<arrow::Date32Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
             default:
diff --git a/matlab/src/matlab/+arrow/+array/Date32Array.m b/matlab/src/matlab/+arrow/+array/Date32Array.m
new file mode 100644
index 0000000000000..a462bd4f85ac1
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/Date32Array.m
@@ -0,0 +1,92 @@
+% arrow.array.Date32Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Date32Array < arrow.array.Array
+
+    properties(Access=private)
+        NullSubstitutionValue = NaT
+    end
+
+    methods
+
+        function obj = Date32Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Date32Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function dates = toMATLAB(obj)
+            import arrow.type.DateUnit
+
+            matlabArray = obj.Proxy.toMATLAB();
+            % UNIX Epoch (January 1st, 1970).
+            unixEpoch = datetime(0, ConvertFrom="posixtime");
+            % A Date32 value encodes a certain number of whole days
+            % before or after the UNIX Epoch.
+            dates = unixEpoch + days(matlabArray);
+            dates(~obj.Valid) = obj.NullSubstitutionValue;
+        end
+
+        function dates = datetime(obj)
+            dates = obj.toMATLAB();
+        end
+
+    end
+
+    methods(Static)
+
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            import arrow.array.Date32Array
+
+            arrow.internal.validate.type(data, "datetime");
+            arrow.internal.validate.shape(data);
+
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+
+            % If the input MATLAB datetime array is zoned (i.e. has a TimeZone),
+            % then the datetime representing the UNIX Epoch must also have a TimeZone.
+            if ~isempty(data.TimeZone)
+                unixEpoch = datetime(0, ConvertFrom="posixtime", TimeZone="UTC");
+            else
+                unixEpoch = datetime(0, ConvertFrom="posixtime");
+            end
+
+            % Explicitly round down (i.e. floor) to the nearest whole number
+            % of days because durations and datetimes are not guaranteed
+            % to encode "whole" number dates / times (e.g. 1.5 days is a valid duration)
+            % and the int32 function rounds to the nearest whole number.
+            % Rounding to the nearest whole number without flooring first would result in a
+            % "round up error" of 1 whole day in cases where the fractional part of
+            % the duration is large enough to result in rounding up (e.g. 1.5 days would
+            % become 2 days).
+            numDays = int32(floor(days(data - unixEpoch)));
+            args = struct(MatlabArray=numDays, Valid=validElements);
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.Date32Array", args);
+            array = Date32Array(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index 15ee0589d56e4..6eb930271b467 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -32,6 +32,7 @@
     matlabData  = cell(numClasses, 1);
     
     timeClasses = getTimeArrayClasses();
+    dateClasses = getDateArrayClasses();
     numericArrayToMatlabTypeDict = getNumericArrayToMatlabDictionary();
 
     for ii = 1:numel(classes)
@@ -54,6 +55,10 @@
             matlabData{ii} = randomDurations(opts.NumRows);
             cmd = compose("%s.fromMATLAB(matlabData{ii})", name);
             arrowArrays{ii} = eval(cmd);
+        elseif ismember(name, dateClasses)
+            matlabData{ii} = randomDatetimes(opts.NumRows);
+            cmd = compose("%s.fromMATLAB(matlabData{ii})", name);
+            arrowArrays{ii} = eval(cmd);
         else
             error("arrow:test:SupportedArrayCase", ...
                 "Missing if-branch for array class " + name); 
@@ -86,6 +91,10 @@
     timeClasses = compose("arrow.array.Time%dArray", [32 64]);
 end
 
+function dateClasses = getDateArrayClasses()
+    dateClasses = compose("arrow.array.Date%dArray", 32);
+end
+
 function number = randomNumbers(numberType, numElements)
     number = cast(randi(255, [numElements 1]), numberType);
 end
@@ -107,4 +116,4 @@
 function dates = randomDatetimes(numElements)
     day = days(randi(255, [numElements 1]));
     dates = datetime(2023, 8, 23) + day;
-end
\ No newline at end of file
+end
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Date32Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Date32Traits.m
new file mode 100644
index 0000000000000..867e81fb276d8
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/Date32Traits.m
@@ -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.
+
+classdef Date32Traits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        ArrayConstructor = @arrow.array.Date32Array
+        ArrayClassName = "arrow.array.Date32Array"
+        ArrayProxyClassName = "arrow.array.proxy.Date32Array"
+        ArrayStaticConstructor = @arrow.array.Date32Array.fromMATLAB
+        TypeConstructor = @arrow.type.Date32Type;
+        TypeClassName = "arrow.type.Date32Type"
+        TypeProxyClassName = "arrow.type.proxy.Date32Type"
+        MatlabConstructor = @datetime
+        MatlabClassName = "datetime"
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index e7c7f9b3272d1..b1f6193a3e7c1 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -52,6 +52,8 @@
                 typeTraits = Time32Traits();
             case ID.Time64
                 typeTraits = Time64Traits();
+            case ID.Date32
+                typeTraits = Date32Traits();
             otherwise
                 error("arrow:type:traits:UnsupportedArrowTypeID", "Unsupported Arrow type ID: " + type);
         end
diff --git a/matlab/test/arrow/array/tDate32Array.m b/matlab/test/arrow/array/tDate32Array.m
new file mode 100644
index 0000000000000..a5fc1c1b64838
--- /dev/null
+++ b/matlab/test/arrow/array/tDate32Array.m
@@ -0,0 +1,295 @@
+%TDATE32ARRAY Unit tests for arrow.array.Date32Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDate32Array < matlab.unittest.TestCase
+
+    properties
+        ArrowArrayConstructorFcn = @arrow.array.Date32Array.fromMATLAB
+    end
+
+    properties (Constant)
+        UnixEpoch = datetime(0, ConvertFrom="posixtime");
+        MissingDates = [datetime(2023, 1, 1), NaT, NaT, datetime(2022, 1, 1), NaT];
+    end
+
+    methods (Test)
+
+        function TestBasic(testCase)
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyInstanceOf(array, "arrow.array.Date32Array");
+        end
+
+        function TestTypeIsDate32(testCase)
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyDate32Type(array.Type);
+        end
+
+        function TestLength(testCase)
+            dates = datetime.empty(0, 1);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+
+            dates = datetime(2023, 1, 1);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(1));
+
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(10));
+        end
+
+        function TestToMATLAB(testCase)
+            % Verify toMATLAB() round-trips the original datetime array.
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            values = toMATLAB(array);
+            testCase.verifyEqual(values, dates');
+        end
+
+        function TestDatetime(testCase)
+            % Verify datetime() round-trips the original datetime array.
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            values = datetime(array);
+            testCase.verifyEqual(values, dates');
+        end
+
+        function TestValid(testCase)
+            % Verify the Valid property returns the expected logical vector.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Valid, [true; false; false; true; false]);
+            testCase.verifyEqual(toMATLAB(array), dates');
+            testCase.verifyEqual(datetime(array), dates');
+        end
+
+        function TestInferNullsTrueNVPair(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() behaves as
+            % expected when InferNulls=true is provided.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates, InferNulls=true);
+            expectedValid = [true; false; false; true; false];
+            testCase.verifyEqual(array.Valid, expectedValid);
+            testCase.verifyEqual(toMATLAB(array), dates');
+            testCase.verifyEqual(datetime(array), dates');
+        end
+
+        function TestInferNullsFalseNVPair(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() behaves as
+            % expected when InferNulls=false is provided.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates, InferNulls=false);
+            expectedValid = [true; true; true; true; true];
+            testCase.verifyEqual(array.Valid, expectedValid);
+
+            % If NaT datetimes were not considered null values, then they
+            % are treated like int32(0) - i.e. the Unix epoch.
+            expectedDates = dates';
+            expectedDates([2, 3, 5]) = testCase.UnixEpoch;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+            testCase.verifyEqual(datetime(array), expectedDates);
+        end
+
+        function TestValidNVPair(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() accepts the Valid
+            % nv-pair, and it behaves as expected.
+            dates = testCase.MissingDates;
+
+            % Supply the Valid name-value pair as vector of indices.
+            array = testCase.ArrowArrayConstructorFcn(dates, Valid=[1, 2, 3]);
+            testCase.verifyEqual(array.Valid, [true; true; true; false; false]);
+            expectedDates = dates';
+            expectedDates([2, 3]) = testCase.UnixEpoch;
+            expectedDates([4, 5]) = NaT;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+
+            % Supply the Valid name-value pair as a logical scalar.
+            array = testCase.ArrowArrayConstructorFcn(dates, Valid=false);
+            testCase.verifyEqual(array.Valid, [false; false; false; false; false]);
+            expectedDates(:) = NaT;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+        end
+
+        function TestEmptyDatetimeVector(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() accepts any
+            % empty-shaped datetime as input.
+
+            dates = datetime.empty(0, 0);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
+
+            % Test with an N-Dimensional empty array
+            dates = datetime.empty(0, 1, 0);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
+        end
+
+        function TestErrorIfNonVector(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() throws an error
+            % if the input provided is not a vector.
+
+            dates = datetime(2023, 1, 1) + days(1:12);
+            dates = reshape(dates, 2, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+
+            dates = reshape(dates, 3, 2, 2);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+        end
+
+        function TestErrorIfNonDatetime(testCase)
+            % Verify arrow.array.Date32Array.fromMATLAB() throws an error
+            % if not given a datetime as input.
+
+            dates = duration(1, 2, 3);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+
+            numbers = [1; 2; 3; 4];
+            fcn = @() testCase.ArrowArrayConstructorFcn(numbers);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+        end
+
+        function TestInt32MaxDays(testCase)
+            % Verify that no precision is lost when trying to round-trip a
+            % datetime value that is within abs(intmin("int32")) days before
+            % and intmax("int32") days after the UNIX epoch.
+
+            % Cast to int64 before taking the absolute value to avoid loss
+            % of precision.
+            numDaysBefore = abs(int64(intmin("int32")));
+            numDaysAfter = intmax("int32");
+
+            expectedBefore = testCase.UnixEpoch - days(numDaysBefore);
+            expectedAfter = testCase.UnixEpoch + days(numDaysAfter);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedBefore);
+            actualBefore = array.toMATLAB();
+            testCase.verifyEqual(actualBefore, expectedBefore);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedAfter);
+            actualAfter = array.toMATLAB();
+            testCase.verifyEqual(actualAfter, expectedAfter);
+        end
+
+        function TestGreaterThanInt32MaxDays(testCase)
+            % Verify that precision is lost when trying to round-trip a
+            % datetime that is more than abs(intmin("int32")) days before
+            % or more than intmax("int32") after the UNIX epoch.
+
+            % Cast to int64 before taking the absolute value to avoid loss
+            % of precision.
+            numDaysBefore = abs(int64(intmin("int32"))) + 1;
+            numDaysAfter = int64(intmax("int32")) + 1;
+
+            expectedBefore = testCase.UnixEpoch - days(numDaysBefore);
+            expectedAfter = testCase.UnixEpoch + days(numDaysAfter);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedBefore);
+            actualBefore = array.toMATLAB();
+            testCase.verifyNotEqual(actualBefore, expectedBefore);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedAfter);
+            actualAfter = array.toMATLAB();
+            testCase.verifyNotEqual(actualAfter, expectedAfter);
+        end
+
+        function TestZonedDatetime(testCase)
+            % Verify that zoned datetimes are supported as inputs to the
+            % fromMATLAB method and that the output datetime returned by
+            % the toMATLAB method is unzoned.
+            expectedZoned = testCase.UnixEpoch + days(10);
+            expectedZoned.TimeZone = "America/New_York";
+            expected = expectedZoned;
+            expected.TimeZone = char.empty(0, 0);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedZoned);
+            actual = array.toMATLAB();
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function TestInt32MaxDaysZoned(testCase)
+            % Verify that zoned datetimes which are within abs(intmin("int32")) days
+            % before and intmax("int32") days after the UNIX epoch are round-tripped
+            % (not including the TimeZone).
+
+            % Cast to int64 before taking the absolute value to avoid loss
+            % of precision.
+            numDaysBefore = abs(int64(intmin("int32")));
+            numDaysAfter = intmax("int32");
+
+            expectedZonedBefore = testCase.UnixEpoch - days(numDaysBefore);
+            expectedZonedAfter = testCase.UnixEpoch + days(numDaysAfter);
+
+            expectedZonedBefore.TimeZone = "UTC";
+            expectedZonedAfter.TimeZone = "UTC";
+
+            expectedUnzonedBefore = expectedZonedBefore;
+            expectedUnzonedBefore.TimeZone = char.empty(0, 0);
+
+            expectedUnzonedAfter = expectedZonedAfter;
+            expectedUnzonedAfter.TimeZone = char.empty(0, 0);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedZonedBefore);
+            actualBefore = array.toMATLAB();
+            testCase.verifyEqual(actualBefore, expectedUnzonedBefore);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedUnzonedAfter);
+            actualAfter = array.toMATLAB();
+            testCase.verifyEqual(actualAfter, expectedUnzonedAfter);
+        end
+
+        function TestNonWholeDaysRoundDown(testCase)
+            % Verify that datetimes which are not whole days (i.e. are not
+            % datetimes with zero hours, zero minutes, and zero seconds),
+            % round down to the nearest whole day when round-tripping with
+            % Date32Array.
+            dates = testCase.UnixEpoch + days(10) + hours(20) + minutes(30) + seconds(40) + milliseconds(50);
+            % Round down to the nearest whole day when round-tripping.
+            expected = testCase.UnixEpoch + days(10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            actual = array.toMATLAB();
+            testCase.verifyEqual(actual, expected);
+
+            dates = testCase.UnixEpoch + days(10) + hours(10) + minutes(20) + seconds(30) + milliseconds(20);
+            % Round down to the nearest whole day when round-tripping.
+            expected = testCase.UnixEpoch + days(10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            actual = array.toMATLAB();
+            testCase.verifyEqual(actual, expected);
+        end
+
+    end
+
+    methods
+
+        function verifyDate32Type(testCase, actual)
+            testCase.verifyInstanceOf(actual, "arrow.type.Date32Type");
+            testCase.verifyEqual(actual.ID, arrow.type.ID.Date32);
+            testCase.verifyEqual(actual.DateUnit, arrow.type.DateUnit.Day);
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/array/tTime32Array.m b/matlab/test/arrow/array/tTime32Array.m
index d885cd80cc972..e874889e5879d 100644
--- a/matlab/test/arrow/array/tTime32Array.m
+++ b/matlab/test/arrow/array/tTime32Array.m
@@ -108,10 +108,10 @@ function TestDuration(testCase, Unit)
         function TestValid(testCase, Unit)
             % Verify the Valid property returns the expected logical vector.
             times = seconds([100 200 NaN 355 NaN 400]);
-            arrray = testCase.ArrowArrayConstructorFcn(times, TImeUnit=Unit);
-            testCase.verifyEqual(arrray.Valid, [true; true; false; true; false; true]);
-            testCase.verifyEqual(toMATLAB(arrray), times');
-            testCase.verifyEqual(duration(arrray), times');
+            array = testCase.ArrowArrayConstructorFcn(times, TimeUnit=Unit);
+            testCase.verifyEqual(array.Valid, [true; true; false; true; false; true]);
+            testCase.verifyEqual(toMATLAB(array), times');
+            testCase.verifyEqual(duration(array), times');
         end
 
         function InferNullsTrueNVPair(testCase, Unit)
diff --git a/matlab/test/arrow/type/traits/tDate32Traits.m b/matlab/test/arrow/type/traits/tDate32Traits.m
new file mode 100644
index 0000000000000..6f3c07c99d774
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tDate32Traits.m
@@ -0,0 +1,33 @@
+%TDATE32TRAITS Unit tests for arrow.type.traits.Date32Traits
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDate32Traits < hTypeTraits
+
+    properties
+        TraitsConstructor = @arrow.type.traits.Date32Traits
+        ArrayConstructor = @arrow.array.Date32Array
+        ArrayClassName = "arrow.array.Date32Array"
+        ArrayProxyClassName = "arrow.array.proxy.Date32Array"
+        ArrayStaticConstructor = @arrow.array.Date32Array.fromMATLAB
+        TypeConstructor = @arrow.type.Date32Type
+        TypeClassName = "arrow.type.Date32Type"
+        TypeProxyClassName = "arrow.type.proxy.Date32Type"
+        MatlabConstructor = @datetime
+        MatlabClassName = "datetime"
+    end
+
+end
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index 771562152a5ef..70508a5e7cfbf 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -175,6 +175,18 @@ function TestTime64(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits); 
         end
 
+        function TestDate32(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.Date32;
+            expectedTraits = Date32Traits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 
@@ -352,4 +364,4 @@ function TestErrorIfUnsupportedInputType(testCase)
 
     end
 
-end
\ No newline at end of file
+end

From 4612998b892dda698ce1f088b109aafaae7b594c Mon Sep 17 00:00:00 2001
From: jeremyosterhoudt <jeremyosterhoudt@yahoo.com>
Date: Tue, 29 Aug 2023 19:03:35 -0700
Subject: [PATCH 266/749] GH-37440: [C#][Docs] Add Flight SQL supported
 functions to status.rst (#37441)

### Rationale for this change

Update the feature support documentation to reflect that Flight SQL is now supported with C#

### What changes are included in this PR?

The feature support matrix for Flight SQL now lists functions supported with C#

### Are these changes tested?

N/A

### Are there any user-facing changes?

Yes, the documentation.

No

Closes issue #37440
* Closes: #37440

Authored-by: jeremyosterhoudt <jeremyosterhoudt@yahoo.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/status.rst | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/docs/source/status.rst b/docs/source/status.rst
index 6d7f674932a9c..e96fd1a6107a5 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -243,9 +243,9 @@ support/not support individual features.
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | CancelQuery                                | ✓     | ✓     |       |            |       |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| ClosePreparedStatement                     | ✓     | ✓     | ✓     |            |       |       |       |       |
+| ClosePreparedStatement                     | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| CreatePreparedStatement                    | ✓     | ✓     | ✓     |            |       |       |       |       |
+| CreatePreparedStatement                    | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | CreatePreparedSubstraitPlan                | ✓     | ✓     |       |            |       |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -253,35 +253,35 @@ support/not support individual features.
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | EndTransaction                             | ✓     | ✓     |       |            |       |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetCatalogs                                | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetCatalogs                                | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetCrossReference                          | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetCrossReference                          | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetDbSchemas                               | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetDbSchemas                               | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetExportedKeys                            | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetExportedKeys                            | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetImportedKeys                            | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetImportedKeys                            | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetPrimaryKeys                             | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetPrimaryKeys                             | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetSqlInfo                                 | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetSqlInfo                                 | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetTables                                  | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetTables                                  | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetTableTypes                              | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetTableTypes                              | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| GetXdbcTypeInfo                            | ✓     | ✓     | ✓     |            |       |       |       |       |
+| GetXdbcTypeInfo                            | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| PreparedStatementQuery                     | ✓     | ✓     | ✓     |            |       |       |       |       |
+| PreparedStatementQuery                     | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| PreparedStatementUpdate                    | ✓     | ✓     | ✓     |            |       |       |       |       |
+| PreparedStatementUpdate                    | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | StatementSubstraitPlan                     | ✓     | ✓     |       |            |       |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| StatementQuery                             | ✓     | ✓     | ✓     |            |       |       |       |       |
+| StatementQuery                             | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| StatementUpdate                            | ✓     | ✓     | ✓     |            |       |       |       |       |
+| StatementUpdate                            | ✓     | ✓     | ✓     |            | ✓     |       |       |       |
 +--------------------------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 .. seealso::

From 3cb4481386876c8004b2ab0b1bae58b658ef6ef0 Mon Sep 17 00:00:00 2001
From: Thomas Newton <thomas.w.newton@gmail.com>
Date: Wed, 30 Aug 2023 09:30:02 +0100
Subject: [PATCH 267/749] GH-29847: [C++] Build with Azure SDK for C++ (#36835)

### Rationale for this change
We want to use the Azure SDK for C++ to read/write to Azure blob storage. Obviously this is pretty important for building an `AzureFileSystem`.

### What changes are included in this PR?
Builds the the relevant parts of the azure SDK as a cmake external project. Adds a couple of simple tests that just assert that the Azure SDK is working and a couple of lines in `AzureFileSystem` to initialise the blob storage client to ensure the build is working correctly in all environments.

I started with the build setup from https://github.com/apache/arrow/pull/12914 but I did make few changes.

1. Although its atypical for this project we chose to switch from cmake's `ExternalProject` to `FetchContent`. `FetchContent` is recomended by the Azure docs https://github.com/Azure/azure-sdk-for-cpp#cmake-project--fetch-content. It also solves a few problems including: automatically linking system curl and ssl instead of bootstrapping vcpkg and installing curl and ssl from there.
2. Only build one version of the Azure SDK for C++ because it contains all the components. Previously we were unnecessarily building 5 different versions of the whole thing on top of each other. This created race conditions for which version each component came from.
3. We are using `azure-core_1.10.2` which is a very recent version. There are a couple of important reasons for this 1.  [an important managed identity fix](https://github.com/Azure/azure-sdk-for-cpp/issues/4723), 2. [fixed support for curl versions < 7.71.0](https://github.com/Azure/azure-sdk-for-cpp/issues/4792).

There will be follow up PRs to enable Azure in the manylinux builds. We need to update `vcpkg` first so we can get a version of the Azure SDK which contains [an important managed identity fix](https://github.com/Azure/azure-sdk-for-cpp/issues/4723).

### Are these changes tested?
Yes. There is a simple test that just runs the Azure client against azurite. Additionally just initialising the client in `AzureFileSystem` goes a long way towards ensuring the build is working.

### Are there any user-facing changes?
No
* Closes: #29847

Lead-authored-by: Thomas Newton <thomas.w.newton@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: shefali singh <shefalisingh@microsoft.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/docker/ubuntu-20.04-cpp.dockerfile       |  2 +
 ci/docker/ubuntu-22.04-cpp.dockerfile       |  2 +
 ci/scripts/cpp_build.sh                     |  1 +
 cpp/CMakeLists.txt                          |  5 ++
 cpp/cmake_modules/FindAzure.cmake           | 45 ++++++++++++++
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 68 +++++++++++++++++++++
 cpp/src/arrow/filesystem/azurefs.cc         |  9 +++
 cpp/src/arrow/filesystem/azurefs_test.cc    | 45 ++++++++++++--
 cpp/thirdparty/versions.txt                 |  3 +
 9 files changed, 174 insertions(+), 6 deletions(-)
 create mode 100644 cpp/cmake_modules/FindAzure.cmake

diff --git a/ci/docker/ubuntu-20.04-cpp.dockerfile b/ci/docker/ubuntu-20.04-cpp.dockerfile
index 125f1f48d482e..08dda6cf50a17 100644
--- a/ci/docker/ubuntu-20.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp.dockerfile
@@ -99,6 +99,7 @@ RUN apt-get update -y -q && \
         libssl-dev \
         libthrift-dev \
         libutf8proc-dev \
+        libxml2-dev \
         libzstd-dev \
         make \
         ninja-build \
@@ -172,6 +173,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_WITH_ZSTD=ON \
     ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-${llvm}/bin/llvm-symbolizer \
     AWSSDK_SOURCE=BUNDLED \
+    Azure_SOURCE=BUNDLED \
     google_cloud_cpp_storage_SOURCE=BUNDLED \
     gRPC_SOURCE=BUNDLED \
     GTest_SOURCE=BUNDLED \
diff --git a/ci/docker/ubuntu-22.04-cpp.dockerfile b/ci/docker/ubuntu-22.04-cpp.dockerfile
index 0840b3fa5c68d..dedeedd979f72 100644
--- a/ci/docker/ubuntu-22.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-22.04-cpp.dockerfile
@@ -98,6 +98,7 @@ RUN apt-get update -y -q && \
         libssl-dev \
         libthrift-dev \
         libutf8proc-dev \
+        libxml2-dev \
         libzstd-dev \
         make \
         ninja-build \
@@ -196,6 +197,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_WITH_ZSTD=ON \
     ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-${llvm}/bin/llvm-symbolizer \
     AWSSDK_SOURCE=BUNDLED \
+    Azure_SOURCE=BUNDLED \
     google_cloud_cpp_storage_SOURCE=BUNDLED \
     GTest_SOURCE=BUNDLED \
     ORC_SOURCE=BUNDLED \
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index 5a89fafc6015e..d73f4ad23085e 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -152,6 +152,7 @@ cmake \
   -DARROW_WITH_ZLIB=${ARROW_WITH_ZLIB:-OFF} \
   -DARROW_WITH_ZSTD=${ARROW_WITH_ZSTD:-OFF} \
   -DAWSSDK_SOURCE=${AWSSDK_SOURCE:-} \
+  -DAzure_SOURCE=${Azure_SOURCE:-} \
   -Dbenchmark_SOURCE=${benchmark_SOURCE:-} \
   -DBOOST_SOURCE=${BOOST_SOURCE:-} \
   -DBrotli_SOURCE=${Brotli_SOURCE:-} \
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index fcff62c447014..f8e7b1eb271b2 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -818,6 +818,11 @@ if(ARROW_WITH_OPENTELEMETRY)
   list(APPEND ARROW_STATIC_INSTALL_INTERFACE_LIBS CURL::libcurl)
 endif()
 
+if(ARROW_WITH_AZURE_SDK)
+  list(APPEND ARROW_SHARED_LINK_LIBS ${AZURE_SDK_LINK_LIBRARIES})
+  list(APPEND ARROW_STATIC_LINK_LIBS ${AZURE_SDK_LINK_LIBRARIES})
+endif()
+
 if(ARROW_WITH_UTF8PROC)
   list(APPEND ARROW_SHARED_LINK_LIBS utf8proc::utf8proc)
   list(APPEND ARROW_STATIC_LINK_LIBS utf8proc::utf8proc)
diff --git a/cpp/cmake_modules/FindAzure.cmake b/cpp/cmake_modules/FindAzure.cmake
new file mode 100644
index 0000000000000..fdf354b724e77
--- /dev/null
+++ b/cpp/cmake_modules/FindAzure.cmake
@@ -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.
+
+if(Azure_FOUND)
+  return()
+endif()
+
+set(find_package_args)
+list(APPEND find_package_args CONFIG)
+if(Azure_FIND_QUIETLY)
+  list(APPEND find_package_args QUIET)
+endif()
+
+if(Azure_FIND_REQUIRED)
+  list(APPEND find_package_args REQUIRED)
+endif()
+
+find_package(azure-core-cpp ${find_package_args})
+find_package(azure-identity-cpp ${find_package_args})
+find_package(azure-storage-blobs-cpp ${find_package_args})
+find_package(azure-storage-common-cpp ${find_package_args})
+find_package(azure-storage-files-datalake-cpp ${find_package_args})
+
+find_package_handle_standard_args(
+  Azure
+  REQUIRED_VARS azure-core-cpp_FOUND
+                azure-identity-cpp_FOUND
+                azure-storage-blobs-cpp_FOUND
+                azure-storage-common-cpp_FOUND
+                azure-storage-files-datalake-cpp_FOUND
+  VERSION_VAR azure-core-cpp_VERSION)
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 3101c1dc73aa6..5c2e679e10c86 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -49,6 +49,7 @@ set(ARROW_RE2_LINKAGE
 set(ARROW_THIRDPARTY_DEPENDENCIES
     absl
     AWSSDK
+    Azure
     benchmark
     Boost
     Brotli
@@ -162,6 +163,8 @@ macro(build_dependency DEPENDENCY_NAME)
     build_absl()
   elseif("${DEPENDENCY_NAME}" STREQUAL "AWSSDK")
     build_awssdk()
+  elseif("${DEPENDENCY_NAME}" STREQUAL "Azure")
+    build_azure_sdk()
   elseif("${DEPENDENCY_NAME}" STREQUAL "benchmark")
     build_benchmark()
   elseif("${DEPENDENCY_NAME}" STREQUAL "Boost")
@@ -389,6 +392,10 @@ if(ARROW_GCS)
   set(ARROW_WITH_ZLIB ON)
 endif()
 
+if(ARROW_AZURE)
+  set(ARROW_WITH_AZURE_SDK ON)
+endif()
+
 if(ARROW_JSON)
   set(ARROW_WITH_RAPIDJSON ON)
 endif()
@@ -569,6 +576,14 @@ else()
            "${THIRDPARTY_MIRROR_URL}/aws-sdk-cpp-${ARROW_AWSSDK_BUILD_VERSION}.tar.gz")
 endif()
 
+if(DEFINED ENV{ARROW_AZURE_SDK_URL})
+  set(ARROW_AZURE_SDK_URL "$ENV{ARROW_AZURE_SDK_URL}")
+else()
+  set_urls(ARROW_AZURE_SDK_URL
+           "https://github.com/Azure/azure-sdk-for-cpp/archive/${ARROW_AZURE_SDK_BUILD_VERSION}.tar.gz"
+  )
+endif()
+
 if(DEFINED ENV{ARROW_BOOST_URL})
   set(BOOST_SOURCE_URL "$ENV{ARROW_BOOST_URL}")
 else()
@@ -981,6 +996,8 @@ else()
   set(MAKE_BUILD_ARGS "-j${NPROC}")
 endif()
 
+include(FetchContent)
+
 # ----------------------------------------------------------------------
 # Find pthreads
 
@@ -1388,6 +1405,7 @@ endif()
 set(ARROW_OPENSSL_REQUIRED_VERSION "1.0.2")
 set(ARROW_USE_OPENSSL OFF)
 if(PARQUET_REQUIRE_ENCRYPTION
+   OR ARROW_AZURE
    OR ARROW_FLIGHT
    OR ARROW_GANDIVA
    OR ARROW_GCS
@@ -5095,6 +5113,56 @@ if(ARROW_S3)
   endif()
 endif()
 
+# ----------------------------------------------------------------------
+# Azure SDK for C++
+
+function(build_azure_sdk)
+  message(STATUS "Building Azure SDK for C++ from source")
+  fetchcontent_declare(azure_sdk
+                       URL ${ARROW_AZURE_SDK_URL}
+                       URL_HASH "SHA256=${ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM}")
+  set(BUILD_PERFORMANCE_TESTS FALSE)
+  set(BUILD_SAMPLES FALSE)
+  set(BUILD_TESTING FALSE)
+  set(BUILD_WINDOWS_UWP TRUE)
+  set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
+  set(DISABLE_AZURE_CORE_OPENTELEMETRY TRUE)
+  set(ENV{AZURE_SDK_DISABLE_AUTO_VCPKG} TRUE)
+  set(WARNINGS_AS_ERRORS FALSE)
+  # TODO: Configure flags in a better way. FetchContent builds inherit
+  # global flags but we want to disable -Werror for Azure SDK for C++ builds.
+  if(MSVC)
+    string(REPLACE "/WX" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+    string(REPLACE "/WX" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+  else()
+    string(REPLACE "-Werror" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+    string(REPLACE "-Werror" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+  endif()
+  fetchcontent_makeavailable(azure_sdk)
+  set(AZURE_SDK_VENDORED
+      TRUE
+      PARENT_SCOPE)
+  list(APPEND
+       ARROW_BUNDLED_STATIC_LIBS
+       Azure::azure-core
+       Azure::azure-identity
+       Azure::azure-storage-blobs
+       Azure::azure-storage-common
+       Azure::azure-storage-files-datalake)
+  set(ARROW_BUNDLED_STATIC_LIBS
+      ${ARROW_BUNDLED_STATIC_LIBS}
+      PARENT_SCOPE)
+endfunction()
+
+if(ARROW_WITH_AZURE_SDK)
+  resolve_dependency(Azure REQUIRED_VERSION 1.10.2)
+  set(AZURE_SDK_LINK_LIBRARIES
+      Azure::azure-storage-files-datalake
+      Azure::azure-storage-common
+      Azure::azure-storage-blobs
+      Azure::azure-identity
+      Azure::azure-core)
+endif()
 # ----------------------------------------------------------------------
 # ucx - communication framework for modern, high-bandwidth and low-latency networks
 
diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc
index 0158c0cec74e1..fcbae332d2397 100644
--- a/cpp/src/arrow/filesystem/azurefs.cc
+++ b/cpp/src/arrow/filesystem/azurefs.cc
@@ -17,6 +17,9 @@
 
 #include "arrow/filesystem/azurefs.h"
 
+#include <azure/identity/default_azure_credential.hpp>
+#include <azure/storage/blobs.hpp>
+
 #include "arrow/result.h"
 #include "arrow/util/checked_cast.h"
 
@@ -47,6 +50,12 @@ class AzureFileSystem::Impl {
       : io_context_(io_context), options_(std::move(options)) {}
 
   Status Init() {
+    // TODO: GH-18014 Delete this once we have a proper implementation. This just
+    // initializes a pointless Azure blob service client with a fake endpoint to ensure
+    // the build will fail if the Azure SDK build is broken.
+    auto default_credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
+    auto service_client = Azure::Storage::Blobs::BlobServiceClient(
+        "http://fake-blob-storage-endpoint", default_credential);
     if (options_.backend == AzureBackend::Azurite) {
       // gen1Client_->GetAccountInfo().Value.IsHierarchicalNamespaceEnabled
       // throws error in azurite
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index e940c5bd1bc32..9bf7cb8e753ec 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -45,6 +45,12 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
 
+#include <azure/identity/client_secret_credential.hpp>
+#include <azure/identity/default_azure_credential.hpp>
+#include <azure/identity/managed_identity_credential.hpp>
+#include <azure/storage/blobs.hpp>
+#include <azure/storage/common/storage_credential.hpp>
+
 namespace arrow {
 using internal::TemporaryDir;
 namespace fs {
@@ -105,15 +111,42 @@ AzuriteEnv* GetAzuriteEnv() {
   return ::arrow::internal::checked_cast<AzuriteEnv*>(azurite_env);
 }
 
-// Placeholder tests for file structure
+// Placeholder tests
 // TODO: GH-18014 Remove once a proper test is added
-TEST(AzureFileSystem, InitialiseAzurite) {
+TEST(AzureFileSystem, UploadThenDownload) {
+  const std::string container_name = "sample-container";
+  const std::string blob_name = "sample-blob.txt";
+  const std::string blob_content = "Hello Azure!";
+
   const std::string& account_name = GetAzuriteEnv()->account_name();
   const std::string& account_key = GetAzuriteEnv()->account_key();
-  EXPECT_EQ(account_name, "devstoreaccount1");
-  EXPECT_EQ(account_key,
-            "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/"
-            "K1SZFPTOtr/KBHBeksoGMGw==");
+
+  auto credential = std::make_shared<Azure::Storage::StorageSharedKeyCredential>(
+      account_name, account_key);
+
+  auto service_client = Azure::Storage::Blobs::BlobServiceClient(
+      std::string("http://127.0.0.1:10000/") + account_name, credential);
+  auto container_client = service_client.GetBlobContainerClient(container_name);
+  container_client.CreateIfNotExists();
+  auto blob_client = container_client.GetBlockBlobClient(blob_name);
+
+  std::vector<uint8_t> buffer(blob_content.begin(), blob_content.end());
+  blob_client.UploadFrom(buffer.data(), buffer.size());
+
+  std::vector<uint8_t> downloaded_content(blob_content.size());
+  blob_client.DownloadTo(downloaded_content.data(), downloaded_content.size());
+
+  EXPECT_EQ(std::string(downloaded_content.begin(), downloaded_content.end()),
+            blob_content);
+}
+
+TEST(AzureFileSystem, InitializeCredentials) {
+  auto default_credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
+  auto managed_identity_credential =
+      std::make_shared<Azure::Identity::ManagedIdentityCredential>();
+  auto service_principal_credential =
+      std::make_shared<Azure::Identity::ClientSecretCredential>("tenant_id", "client_id",
+                                                                "client_secret");
 }
 
 TEST(AzureFileSystem, OptionsCompare) {
diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt
index 8edaa422b3dcf..52d302592b55c 100644
--- a/cpp/thirdparty/versions.txt
+++ b/cpp/thirdparty/versions.txt
@@ -53,6 +53,9 @@ ARROW_AWS_LC_BUILD_VERSION=v1.3.0
 ARROW_AWS_LC_BUILD_SHA256_CHECKSUM=ae96a3567161552744fc0cae8b4d68ed88b1ec0f3d3c98700070115356da5a37
 ARROW_AWSSDK_BUILD_VERSION=1.10.55
 ARROW_AWSSDK_BUILD_SHA256_CHECKSUM=2d552fb1a84bef4a9b65e34aa7031851ed2aef5319e02cc6e4cb735c48aa30de
+# Despite the confusing version name this is still the whole Azure SDK for C++ including core, keyvault, storage-common, etc.
+ARROW_AZURE_SDK_BUILD_VERSION=azure-core_1.10.2
+ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM=36557dae87de4cdd257d9b441d9a7f043290eae6666fb1065e0fa486ae3e58a0
 ARROW_BOOST_BUILD_VERSION=1.81.0
 ARROW_BOOST_BUILD_SHA256_CHECKSUM=9e0ffae35528c35f90468997bc8d99500bf179cbae355415a89a600c38e13574
 ARROW_BROTLI_BUILD_VERSION=v1.0.9

From 9639e52e690959f9f51d1df36ad7f8dc5a58f1a0 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 30 Aug 2023 17:41:44 +0800
Subject: [PATCH 268/749] GH-37212: [C++] IO: Add FromString to
 ::arrow::io::BufferReader (#37360)

### Rationale for this change

Previously, when input an non-owned string, `arrow::io::BufferReader` would zero-copy it. It would cause lifetime problem. This patch add `FromString` to help build from `std::string`.

### What changes are included in this PR?

* Add a ctor for FromString(std::string), and deprecate non-owning ctors

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Some APIs are being deprecated. Users can use the new interface.

* Closes: #37212

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/examples/arrow/join_example.cc         |  2 +-
 cpp/src/arrow/adapters/orc/adapter_test.cc | 12 ++---
 cpp/src/arrow/buffer.cc                    |  4 +-
 cpp/src/arrow/compute/function_internal.cc |  6 ++-
 cpp/src/arrow/flight/sql/client.cc         |  8 ++-
 cpp/src/arrow/flight/types.cc              |  6 ++-
 cpp/src/arrow/io/memory.cc                 | 11 ++--
 cpp/src/arrow/io/memory.h                  | 18 ++++++-
 cpp/src/arrow/io/memory_test.cc            | 61 +++++++++++++++-------
 cpp/src/arrow/ipc/read_write_test.cc       |  8 +--
 cpp/src/arrow/ipc/reader.h                 |  2 +-
 11 files changed, 94 insertions(+), 44 deletions(-)

diff --git a/cpp/examples/arrow/join_example.cc b/cpp/examples/arrow/join_example.cc
index 17f709c720e43..c1c6e5e82ff11 100644
--- a/cpp/examples/arrow/join_example.cc
+++ b/cpp/examples/arrow/join_example.cc
@@ -64,7 +64,7 @@ arrow::Result<std::shared_ptr<arrow::dataset::Dataset>> CreateDataSetFromCSVData
   std::string csv_data = is_left ? kLeftRelationCsvData : kRightRelationCsvData;
   std::cout << csv_data << std::endl;
   std::string_view sv = csv_data;
-  input = std::make_shared<arrow::io::BufferReader>(sv);
+  input = arrow::io::BufferReader::FromString(std::string(sv));
   auto read_options = arrow::csv::ReadOptions::Defaults();
   auto parse_options = arrow::csv::ParseOptions::Defaults();
   auto convert_options = arrow::csv::ConvertOptions::Defaults();
diff --git a/cpp/src/arrow/adapters/orc/adapter_test.cc b/cpp/src/arrow/adapters/orc/adapter_test.cc
index 93cc4f4649d1f..73ecde6b9b576 100644
--- a/cpp/src/arrow/adapters/orc/adapter_test.cc
+++ b/cpp/src/arrow/adapters/orc/adapter_test.cc
@@ -483,9 +483,9 @@ TEST(TestAdapterRead, ReadCharAndVarcharType) {
   writer->add(*batch);
   writer->close();
 
-  std::shared_ptr<io::RandomAccessFile> in_stream(std::make_shared<io::BufferReader>(
-      reinterpret_cast<const uint8_t*>(mem_stream.getData()),
-      static_cast<int64_t>(mem_stream.getLength())));
+  std::shared_ptr<io::RandomAccessFile> in_stream = std::make_shared<io::BufferReader>(
+      std::make_shared<Buffer>(reinterpret_cast<const uint8_t*>(mem_stream.getData()),
+                               mem_stream.getLength()));
   ASSERT_OK_AND_ASSIGN(
       auto reader, adapters::orc::ORCFileReader::Open(in_stream, default_memory_pool()));
   ASSERT_EQ(row_count, reader->NumberOfRows());
@@ -557,9 +557,9 @@ TEST(TestAdapterRead, ReadFieldAttributes) {
   auto writer = CreateWriter(/*stripe_size=*/1024, *orc_type, &mem_stream);
   writer->close();
 
-  std::shared_ptr<io::RandomAccessFile> in_stream(std::make_shared<io::BufferReader>(
-      reinterpret_cast<const uint8_t*>(mem_stream.getData()),
-      static_cast<int64_t>(mem_stream.getLength())));
+  std::shared_ptr<io::RandomAccessFile> in_stream = std::make_shared<io::BufferReader>(
+      std::make_shared<Buffer>(reinterpret_cast<const uint8_t*>(mem_stream.getData()),
+                               mem_stream.getLength()));
   ASSERT_OK_AND_ASSIGN(
       auto reader, adapters::orc::ORCFileReader::Open(in_stream, default_memory_pool()));
   ASSERT_EQ(0, reader->NumberOfRows());
diff --git a/cpp/src/arrow/buffer.cc b/cpp/src/arrow/buffer.cc
index 99dc29cfe5296..1bd789b7cafe6 100644
--- a/cpp/src/arrow/buffer.cc
+++ b/cpp/src/arrow/buffer.cc
@@ -114,14 +114,14 @@ void Buffer::CheckCPU() const {
 
 Result<std::shared_ptr<io::RandomAccessFile>> Buffer::GetReader(
     std::shared_ptr<Buffer> buf) {
-  return buf->memory_manager_->GetBufferReader(buf);
+  return buf->memory_manager_->GetBufferReader(std::move(buf));
 }
 
 Result<std::shared_ptr<io::OutputStream>> Buffer::GetWriter(std::shared_ptr<Buffer> buf) {
   if (!buf->is_mutable()) {
     return Status::Invalid("Expected mutable buffer");
   }
-  return buf->memory_manager_->GetBufferWriter(buf);
+  return buf->memory_manager_->GetBufferWriter(std::move(buf));
 }
 
 Result<std::shared_ptr<Buffer>> Buffer::Copy(std::shared_ptr<Buffer> source,
diff --git a/cpp/src/arrow/compute/function_internal.cc b/cpp/src/arrow/compute/function_internal.cc
index cd73462e953c4..2ef1d265ea09c 100644
--- a/cpp/src/arrow/compute/function_internal.cc
+++ b/cpp/src/arrow/compute/function_internal.cc
@@ -83,8 +83,10 @@ Result<std::unique_ptr<FunctionOptions>> GenericOptionsType::Deserialize(
 
 Result<std::unique_ptr<FunctionOptions>> DeserializeFunctionOptions(
     const Buffer& buffer) {
-  io::BufferReader stream(buffer);
-  ARROW_ASSIGN_OR_RAISE(auto reader, ipc::RecordBatchFileReader::Open(&stream));
+  // Copying the buffer here is not ideal, but we need to do it to avoid
+  // use-after-free issues with the zero-copy buffer read.
+  auto stream = io::BufferReader::FromString(buffer.ToString());
+  ARROW_ASSIGN_OR_RAISE(auto reader, ipc::RecordBatchFileReader::Open(stream.get()));
   ARROW_ASSIGN_OR_RAISE(auto batch, reader->ReadRecordBatch(0));
   if (batch->num_rows() != 1) {
     return Status::Invalid(
diff --git a/cpp/src/arrow/flight/sql/client.cc b/cpp/src/arrow/flight/sql/client.cc
index db9555749082f..d0552e33df5c2 100644
--- a/cpp/src/arrow/flight/sql/client.cc
+++ b/cpp/src/arrow/flight/sql/client.cc
@@ -519,13 +519,17 @@ arrow::Result<std::shared_ptr<PreparedStatement>> PreparedStatement::ParseRespon
 
   std::shared_ptr<Schema> dataset_schema;
   if (!serialized_dataset_schema.empty()) {
-    io::BufferReader dataset_schema_reader(serialized_dataset_schema);
+    // Create a non-owned Buffer to avoid copying
+    io::BufferReader dataset_schema_reader(
+        std::make_shared<Buffer>(serialized_dataset_schema));
     ipc::DictionaryMemo in_memo;
     ARROW_ASSIGN_OR_RAISE(dataset_schema, ReadSchema(&dataset_schema_reader, &in_memo));
   }
   std::shared_ptr<Schema> parameter_schema;
   if (!serialized_parameter_schema.empty()) {
-    io::BufferReader parameter_schema_reader(serialized_parameter_schema);
+    // Create a non-owned Buffer to avoid copying
+    io::BufferReader parameter_schema_reader(
+        std::make_shared<Buffer>(serialized_parameter_schema));
     ipc::DictionaryMemo in_memo;
     ARROW_ASSIGN_OR_RAISE(parameter_schema,
                           ReadSchema(&parameter_schema_reader, &in_memo));
diff --git a/cpp/src/arrow/flight/types.cc b/cpp/src/arrow/flight/types.cc
index 8395919e4daeb..a24a9ef8758ab 100644
--- a/cpp/src/arrow/flight/types.cc
+++ b/cpp/src/arrow/flight/types.cc
@@ -152,7 +152,8 @@ Status FlightPayload::Validate() const {
 
 arrow::Result<std::shared_ptr<Schema>> SchemaResult::GetSchema(
     ipc::DictionaryMemo* dictionary_memo) const {
-  io::BufferReader schema_reader(raw_schema_);
+  // Create a non-owned Buffer to avoid copying
+  io::BufferReader schema_reader(std::make_shared<Buffer>(raw_schema_));
   return ipc::ReadSchema(&schema_reader, dictionary_memo);
 }
 
@@ -275,7 +276,8 @@ arrow::Result<std::shared_ptr<Schema>> FlightInfo::GetSchema(
   if (reconstructed_schema_) {
     return schema_;
   }
-  io::BufferReader schema_reader(data_.schema);
+  // Create a non-owned Buffer to avoid copying
+  io::BufferReader schema_reader(std::make_shared<Buffer>(data_.schema));
   RETURN_NOT_OK(ipc::ReadSchema(&schema_reader, dictionary_memo).Value(&schema_));
   reconstructed_schema_ = true;
   return schema_;
diff --git a/cpp/src/arrow/io/memory.cc b/cpp/src/arrow/io/memory.cc
index c3a9b06c05e86..37c266d917f3c 100644
--- a/cpp/src/arrow/io/memory.cc
+++ b/cpp/src/arrow/io/memory.cc
@@ -269,14 +269,17 @@ BufferReader::BufferReader(std::shared_ptr<Buffer> buffer)
       is_open_(true) {}
 
 BufferReader::BufferReader(const uint8_t* data, int64_t size)
-    : buffer_(nullptr), data_(data), size_(size), position_(0), is_open_(true) {}
+    : BufferReader(std::make_shared<Buffer>(data, size)) {}
 
 BufferReader::BufferReader(const Buffer& buffer)
-    : BufferReader(buffer.data(), buffer.size()) {}
+    : BufferReader(std::make_shared<Buffer>(buffer.data(), buffer.size())) {}
 
 BufferReader::BufferReader(std::string_view data)
-    : BufferReader(reinterpret_cast<const uint8_t*>(data.data()),
-                   static_cast<int64_t>(data.size())) {}
+    : BufferReader(std::make_shared<Buffer>(data)) {}
+
+std::unique_ptr<BufferReader> BufferReader::FromString(std::string data) {
+  return std::make_unique<BufferReader>(Buffer::FromString(std::move(data)));
+}
 
 Status BufferReader::DoClose() {
   is_open_ = false;
diff --git a/cpp/src/arrow/io/memory.h b/cpp/src/arrow/io/memory.h
index b8377be9a6fe3..d13e0714cbf5a 100644
--- a/cpp/src/arrow/io/memory.h
+++ b/cpp/src/arrow/io/memory.h
@@ -145,14 +145,28 @@ class ARROW_EXPORT FixedSizeBufferWriter : public WritableFile {
 class ARROW_EXPORT BufferReader
     : public internal::RandomAccessFileConcurrencyWrapper<BufferReader> {
  public:
+  /// \brief Instantiate from std::shared_ptr<Buffer>.
+  ///
+  /// This is a zero-copy constructor.
   explicit BufferReader(std::shared_ptr<Buffer> buffer);
+  ARROW_DEPRECATED(
+      "Deprecated in 14.0.0. Use FromString or BufferReader(std::shared_ptr<Buffer> "
+      "buffer) instead.")
   explicit BufferReader(const Buffer& buffer);
+  ARROW_DEPRECATED(
+      "Deprecated in 14.0.0. Use FromString or BufferReader(std::shared_ptr<Buffer> "
+      "buffer) instead.")
   BufferReader(const uint8_t* data, int64_t size);
 
-  /// \brief Instantiate from std::string or std::string_view. Does not
-  /// own data
+  /// \brief Instantiate from std::string_view. Does not own data
+  ARROW_DEPRECATED(
+      "Deprecated in 14.0.0. Use FromString or BufferReader(std::shared_ptr<Buffer> "
+      "buffer) instead.")
   explicit BufferReader(std::string_view data);
 
+  /// \brief Instantiate from std::string. Owns data.
+  static std::unique_ptr<BufferReader> FromString(std::string data);
+
   bool closed() const override;
 
   bool supports_zero_copy() const override;
diff --git a/cpp/src/arrow/io/memory_test.cc b/cpp/src/arrow/io/memory_test.cc
index 22f9a02fdbec8..bd898f17181a5 100644
--- a/cpp/src/arrow/io/memory_test.cc
+++ b/cpp/src/arrow/io/memory_test.cc
@@ -168,11 +168,11 @@ TEST(TestBufferReader, FromStrings) {
   std::string data = "data123456";
   auto view = std::string_view(data);
 
-  BufferReader reader1(data);
-  BufferReader reader2(view);
+  std::unique_ptr<BufferReader> reader1 = BufferReader::FromString(data);
+  BufferReader reader2(std::make_shared<::arrow::Buffer>(view));
 
   std::shared_ptr<Buffer> piece;
-  ASSERT_OK_AND_ASSIGN(piece, reader1.Read(4));
+  ASSERT_OK_AND_ASSIGN(piece, reader1->Read(4));
   ASSERT_EQ(0, memcmp(piece->data(), data.data(), 4));
 
   ASSERT_OK(reader2.Seek(2));
@@ -191,17 +191,17 @@ TEST(TestBufferReader, FromNullBuffer) {
 TEST(TestBufferReader, Seeking) {
   std::string data = "data123456";
 
-  BufferReader reader(data);
-  ASSERT_OK_AND_EQ(0, reader.Tell());
+  std::unique_ptr<BufferReader> reader = BufferReader::FromString(data);
+  ASSERT_OK_AND_EQ(0, reader->Tell());
 
-  ASSERT_OK(reader.Seek(9));
-  ASSERT_OK_AND_EQ(9, reader.Tell());
+  ASSERT_OK(reader->Seek(9));
+  ASSERT_OK_AND_EQ(9, reader->Tell());
 
-  ASSERT_OK(reader.Seek(10));
-  ASSERT_OK_AND_EQ(10, reader.Tell());
+  ASSERT_OK(reader->Seek(10));
+  ASSERT_OK_AND_EQ(10, reader->Tell());
 
-  ASSERT_RAISES(IOError, reader.Seek(11));
-  ASSERT_OK_AND_EQ(10, reader.Tell());
+  ASSERT_RAISES(IOError, reader->Seek(11));
+  ASSERT_OK_AND_EQ(10, reader->Tell());
 }
 
 TEST(TestBufferReader, Peek) {
@@ -283,12 +283,37 @@ TEST(TestBufferReader, WillNeed) {
   }
   {
     std::string data = "data123456";
-    BufferReader reader(reinterpret_cast<const uint8_t*>(data.data()),
-                        static_cast<int64_t>(data.size()));
+    auto reader = BufferReader::FromString(data);
 
-    ASSERT_OK(reader.WillNeed({{0, 4}, {4, 6}}));
-    ASSERT_RAISES(IOError, reader.WillNeed({{11, 1}}));  // Out of bounds
+    ASSERT_OK(reader->WillNeed({{0, 4}, {4, 6}}));
+    ASSERT_RAISES(IOError, reader->WillNeed({{11, 1}}));  // Out of bounds
+  }
+}
+
+void TestBufferReaderLifetime(
+    std::function<std::unique_ptr<BufferReader>(std::string&)> fn) {
+  std::shared_ptr<Buffer> result;
+  std::string data = "data12345678910111213";
+  {
+    std::string data_inner = data;
+    std::unique_ptr<BufferReader> reader = fn(data_inner);
+    EXPECT_EQ(true, reader->supports_zero_copy());
+    ASSERT_OK_AND_ASSIGN(result, reader->Read(data.length()));
   }
+  EXPECT_EQ(std::string_view(data), std::string_view(*result));
+}
+
+TEST(TestBufferReader, Lifetime) {
+  // BufferReader(std::shared_ptr<Buffer>)
+  TestBufferReaderLifetime([](std::string& data) -> std::unique_ptr<BufferReader> {
+    auto buffer = Buffer::FromString(std::move(data));
+    return std::make_unique<BufferReader>(std::move(buffer));
+  });
+
+  // BufferReader(std::string)
+  TestBufferReaderLifetime([](std::string& data) -> std::unique_ptr<BufferReader> {
+    return BufferReader::FromString(std::move(data));
+  });
 }
 
 TEST(TestRandomAccessFile, GetStream) {
@@ -730,7 +755,7 @@ TEST(RangeReadCache, Basics) {
   for (auto lazy : std::vector<bool>{false, true}) {
     SCOPED_TRACE(lazy);
     options.lazy = lazy;
-    auto file = std::make_shared<CountingBufferReader>(Buffer(data));
+    auto file = std::make_shared<CountingBufferReader>(std::make_shared<Buffer>(data));
     internal::ReadRangeCache cache(file, {}, options);
 
     ASSERT_OK(cache.Cache({{1, 2}, {3, 2}, {8, 2}, {20, 2}, {25, 0}}));
@@ -808,7 +833,7 @@ TEST(RangeReadCache, Concurrency) {
 TEST(RangeReadCache, Lazy) {
   std::string data = "abcdefghijklmnopqrstuvwxyz";
 
-  auto file = std::make_shared<CountingBufferReader>(Buffer(data));
+  auto file = std::make_shared<CountingBufferReader>(std::make_shared<Buffer>(data));
   CacheOptions options = CacheOptions::LazyDefaults();
   options.hole_size_limit = 2;
   options.range_size_limit = 10;
@@ -849,7 +874,7 @@ TEST(RangeReadCache, Lazy) {
 TEST(RangeReadCache, LazyWithPrefetching) {
   std::string data = "abcdefghijklmnopqrstuvwxyz";
 
-  auto file = std::make_shared<CountingBufferReader>(Buffer(data));
+  auto file = std::make_shared<CountingBufferReader>(std::make_shared<Buffer>(data));
   CacheOptions options = CacheOptions::LazyDefaults();
   options.hole_size_limit = 1;
   options.range_size_limit = 3;
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 6b4f70763708c..69b827b8fe78d 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -574,12 +574,12 @@ TEST_F(TestIpcRoundTrip, SpecificMetadataVersion) {
 
 TEST(TestReadMessage, CorruptedSmallInput) {
   std::string data = "abc";
-  io::BufferReader reader(data);
-  ASSERT_RAISES(Invalid, ReadMessage(&reader));
+  auto reader = io::BufferReader::FromString(data);
+  ASSERT_RAISES(Invalid, ReadMessage(reader.get()));
 
   // But no error on unsignaled EOS
-  io::BufferReader reader2("");
-  ASSERT_OK_AND_ASSIGN(auto message, ReadMessage(&reader2));
+  auto reader2 = io::BufferReader::FromString("");
+  ASSERT_OK_AND_ASSIGN(auto message, ReadMessage(reader2.get()));
   ASSERT_EQ(nullptr, message);
 }
 
diff --git a/cpp/src/arrow/ipc/reader.h b/cpp/src/arrow/ipc/reader.h
index 9440fcaba92d6..0d7ae22264052 100644
--- a/cpp/src/arrow/ipc/reader.h
+++ b/cpp/src/arrow/ipc/reader.h
@@ -190,7 +190,7 @@ class ARROW_EXPORT RecordBatchFileReader
   /// \return the read batch
   virtual Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(int i) = 0;
 
-  /// \brief Read a particular record batch along with its custom metadada from the file.
+  /// \brief Read a particular record batch along with its custom metadata from the file.
   /// Does not copy memory if the input source supports zero-copy.
   ///
   /// \param[in] i the index of the record batch to return

From f40bf7751772276134c46cae7ac25cef2cdad560 Mon Sep 17 00:00:00 2001
From: Adam Reeve <adreeve@gmail.com>
Date: Wed, 30 Aug 2023 21:57:24 +1200
Subject: [PATCH 269/749] GH-37453: [C++][Parquet] Performance fix for
 WriteBatch (#37454)

### Rationale for this change

Reduces the time taken for `TypedColumnWriter::WriteBatch`, which regressed with #35230

### What changes are included in this PR?

This change computes the value for `pages_change_on_record_boundaries` once when a `TypedColumnWriter` is constructed rather than on every call to `WriteBatch`.

### Are these changes tested?

This doesn't change behaviour so should be covered by existing tests.

### Are there any user-facing changes?

No
* Closes: #37453

Authored-by: Adam Reeve <adreeve@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/column_writer.cc | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index e34420b9f6e79..3fca5542a0733 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -1219,6 +1219,9 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
       page_statistics_ = MakeStatistics<DType>(descr_, allocator_);
       chunk_statistics_ = MakeStatistics<DType>(descr_, allocator_);
     }
+    pages_change_on_record_boundaries_ =
+        properties->data_page_version() == ParquetDataPageVersion::V2 ||
+        properties->page_index_enabled(descr_->path());
   }
 
   int64_t Close() override { return ColumnWriterImpl::Close(); }
@@ -1386,8 +1389,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
   const WriterProperties* properties() override { return properties_; }
 
   bool pages_change_on_record_boundaries() const {
-    return properties_->data_page_version() == ParquetDataPageVersion::V2 ||
-           properties_->page_index_enabled(descr_->path());
+    return pages_change_on_record_boundaries_;
   }
 
  private:
@@ -1402,6 +1404,7 @@ class TypedColumnWriterImpl : public ColumnWriterImpl, public TypedColumnWriter<
   DictEncoder<DType>* current_dict_encoder_;
   std::shared_ptr<TypedStats> page_statistics_;
   std::shared_ptr<TypedStats> chunk_statistics_;
+  bool pages_change_on_record_boundaries_;
 
   // If writing a sequence of ::arrow::DictionaryArray to the writer, we keep the
   // dictionary passed to DictEncoder<T>::PutDictionary so we can check

From 6aec261a3d95f6bcbf32b30941769bf348fab993 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Wed, 30 Aug 2023 13:53:39 +0100
Subject: [PATCH 270/749] GH-36771: [R] stringr helper functions drop calling
 environment when evaluating (#36784)

### What changes are included in this PR?

Update internals of `get_stringr_pattern_options()` to use `eval_tidy()` instead of `eval()` to ensure we're evaluating things in the right environment.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes
* Closes: #36771

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/dplyr-funcs-string.R                   | 27 +++++++++++-----------
 r/tests/testthat/test-dplyr-funcs-string.R |  9 ++++++++
 2 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/r/R/dplyr-funcs-string.R b/r/R/dplyr-funcs-string.R
index b4becb4081bcb..3cd8f94476e5e 100644
--- a/r/R/dplyr-funcs-string.R
+++ b/r/R/dplyr-funcs-string.R
@@ -58,15 +58,18 @@ get_stringr_pattern_options <- function(pattern) {
   }
 
   ensure_opts <- function(opts) {
+
+    # default options for the simple cases
     if (is.character(opts)) {
       opts <- list(pattern = opts, fixed = FALSE, ignore_case = FALSE)
     }
     opts
   }
 
-  pattern <- clean_pattern_namespace(pattern)
+  pattern_expr <- clean_pattern_namespace(quo_get_expr(pattern))
+  pattern <- quo_set_expr(pattern, pattern_expr)
 
-  ensure_opts(eval(pattern))
+  ensure_opts(eval_tidy(pattern, data = list(regex = regex, coll = coll, boundary = boundary, fixed = fixed)))
 }
 
 # Ensure that e.g. stringr::regex and regex both work within patterns
@@ -74,10 +77,7 @@ clean_pattern_namespace <- function(pattern) {
   modifier_funcs <- c("fixed", "regex", "coll", "boundary")
   if (is_call(pattern, modifier_funcs, ns = "stringr")) {
     function_called <- call_name(pattern[1])
-
-    if (function_called %in% modifier_funcs) {
-      pattern[1] <- call2(function_called)
-    }
+    pattern[1] <- call2(function_called)
   }
 
   pattern
@@ -255,7 +255,7 @@ register_bindings_string_regex <- function() {
 
 
   register_binding("stringr::str_detect", function(string, pattern, negate = FALSE) {
-    opts <- get_stringr_pattern_options(enexpr(pattern))
+    opts <- get_stringr_pattern_options(enquo(pattern))
     arrow_fun <- ifelse(opts$fixed, "match_substring", "match_substring_regex")
     out <- create_string_match_expr(arrow_fun,
       string = string,
@@ -282,11 +282,12 @@ register_bindings_string_regex <- function() {
   register_binding(
     "stringr::str_count",
     function(string, pattern) {
-      opts <- get_stringr_pattern_options(enexpr(pattern))
+      opts <- get_stringr_pattern_options(enquo(pattern))
       if (!is.string(pattern)) {
         arrow_not_supported("`pattern` must be a length 1 character vector; other values")
       }
       arrow_fun <- ifelse(opts$fixed, "count_substring", "count_substring_regex")
+
       Expression$create(
         arrow_fun,
         string,
@@ -313,7 +314,7 @@ register_bindings_string_regex <- function() {
   })
 
   register_binding("stringr::str_starts", function(string, pattern, negate = FALSE) {
-    opts <- get_stringr_pattern_options(enexpr(pattern))
+    opts <- get_stringr_pattern_options(enquo(pattern))
     if (opts$fixed) {
       out <- call_binding("startsWith", x = string, prefix = opts$pattern)
     } else {
@@ -331,7 +332,7 @@ register_bindings_string_regex <- function() {
   })
 
   register_binding("stringr::str_ends", function(string, pattern, negate = FALSE) {
-    opts <- get_stringr_pattern_options(enexpr(pattern))
+    opts <- get_stringr_pattern_options(enquo(pattern))
     if (opts$fixed) {
       out <- call_binding("endsWith", x = string, suffix = opts$pattern)
     } else {
@@ -366,7 +367,7 @@ register_bindings_string_regex <- function() {
   arrow_stringr_string_replace_function <- function(max_replacements) {
     force(max_replacements)
     function(string, pattern, replacement) {
-      opts <- get_stringr_pattern_options(enexpr(pattern))
+      opts <- get_stringr_pattern_options(enquo(pattern))
       arrow_r_string_replace_function(max_replacements)(
         pattern = opts$pattern,
         replacement = replacement,
@@ -380,7 +381,7 @@ register_bindings_string_regex <- function() {
   arrow_stringr_string_remove_function <- function(max_replacements) {
     force(max_replacements)
     function(string, pattern) {
-      opts <- get_stringr_pattern_options(enexpr(pattern))
+      opts <- get_stringr_pattern_options(enquo(pattern))
       arrow_r_string_replace_function(max_replacements)(
         pattern = opts$pattern,
         replacement = "",
@@ -423,7 +424,7 @@ register_bindings_string_regex <- function() {
              pattern,
              n = Inf,
              simplify = FALSE) {
-      opts <- get_stringr_pattern_options(enexpr(pattern))
+      opts <- get_stringr_pattern_options(enquo(pattern))
       arrow_fun <- ifelse(opts$fixed, "split_pattern", "split_pattern_regex")
       if (opts$ignore_case) {
         arrow_not_supported("Case-insensitive string splitting")
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index fc202bfb3a99e..1cebec9dddac3 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -303,6 +303,15 @@ test_that("str_detect", {
       collect(),
     df
   )
+
+  string <- "^F"
+  compare_dplyr_binding(
+    .input %>%
+      filter(str_detect(x, regex(string))) %>%
+      collect(),
+    df
+  )
+
   compare_dplyr_binding(
     .input %>%
       transmute(

From 0952ee1c7d6903011a6103b935ecf15585473482 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 30 Aug 2023 15:00:01 +0200
Subject: [PATCH 271/749] MINOR: [C++] Mark more files generated (#37462)

### Rationale for this change

Some generated files, such as Thrift C++ implementation files, can be shown by default in PR diff views.

### What changes are included in this PR?

Mark more files generated.

### Are these changes tested?

No tests required.

### Are there any user-facing changes?

No.

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .gitattributes | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/.gitattributes b/.gitattributes
index 1a5b156b491fd..69f4139c4e4f4 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,9 +1,11 @@
+cpp/src/arrow/util/bpacking_*_generated.h linguist-generated=true
+cpp/src/generated/*.cpp linguist-generated=true
+cpp/src/generated/*.h linguist-generated=true
+go/**/*.s linguist-generated=true
+go/arrow/unionmode_string.go linguist-generated=true
 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
-cpp/src/generated/*.h linguist-generated=true
 r/NEWS.md merge=union
-go/**/*.s linguist-generated=true
-go/arrow/unionmode_string.go linguist-generated=true

From 1fbe62058a0310dfabbc3700bf566c1d0cae2ec8 Mon Sep 17 00:00:00 2001
From: Ian Cook <ianmcook@gmail.com>
Date: Wed, 30 Aug 2023 09:56:08 -0400
Subject: [PATCH 272/749] GH-37449: [Python] Catch error importing
 `pyarrow.dataset` in `python/pyarrow/tests/test_substrait.py` (#37450)

This catches an error importing `pyarrow.dataset` which is causing a CI
failure.
* Closes: #37449

---------

Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/tests/test_substrait.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/python/pyarrow/tests/test_substrait.py b/python/pyarrow/tests/test_substrait.py
index be35a21a02411..5dda2cfcf09e7 100644
--- a/python/pyarrow/tests/test_substrait.py
+++ b/python/pyarrow/tests/test_substrait.py
@@ -22,7 +22,6 @@
 
 import pyarrow as pa
 import pyarrow.compute as pc
-import pyarrow.dataset as ds
 from pyarrow.lib import tobytes
 from pyarrow.lib import ArrowInvalid, ArrowNotImplementedError
 
@@ -33,7 +32,7 @@
 
 # Marks all of the tests in this module
 # Ignore these with pytest ... -m 'not substrait'
-pytestmark = [pytest.mark.dataset, pytest.mark.substrait]
+pytestmark = pytest.mark.substrait
 
 
 def mock_udf_context(batch_length=10):
@@ -928,9 +927,9 @@ def table_provider(names, _):
 
 
 @pytest.mark.parametrize("expr", [
-    pc.equal(ds.field("x"), 7),
-    pc.equal(ds.field("x"), ds.field("y")),
-    ds.field("x") > 50
+    pc.equal(pc.field("x"), 7),
+    pc.equal(pc.field("x"), pc.field("y")),
+    pc.field("x") > 50
 ])
 def test_serializing_expressions(expr):
     schema = pa.schema([
@@ -950,8 +949,8 @@ def test_invalid_expression_ser_des():
         pa.field("x", pa.int32()),
         pa.field("y", pa.int32())
     ])
-    expr = pc.equal(ds.field("x"), 7)
-    bad_expr = pc.equal(ds.field("z"), 7)
+    expr = pc.equal(pc.field("x"), 7)
+    bad_expr = pc.equal(pc.field("z"), 7)
     # Invalid number of names
     with pytest.raises(ValueError) as excinfo:
         pa.substrait.serialize_expressions([expr], [], schema)
@@ -970,13 +969,13 @@ def test_serializing_multiple_expressions():
         pa.field("x", pa.int32()),
         pa.field("y", pa.int32())
     ])
-    exprs = [pc.equal(ds.field("x"), 7), pc.equal(ds.field("x"), ds.field("y"))]
+    exprs = [pc.equal(pc.field("x"), 7), pc.equal(pc.field("x"), pc.field("y"))]
     buf = pa.substrait.serialize_expressions(exprs, ["first", "second"], schema)
     returned = pa.substrait.deserialize_expressions(buf)
     assert schema == returned.schema
     assert len(returned.expressions) == 2
 
-    norm_exprs = [pc.equal(ds.field(0), 7), pc.equal(ds.field(0), ds.field(1))]
+    norm_exprs = [pc.equal(pc.field(0), 7), pc.equal(pc.field(0), pc.field(1))]
     assert str(returned.expressions["first"]) == str(norm_exprs[0])
     assert str(returned.expressions["second"]) == str(norm_exprs[1])
 
@@ -986,8 +985,8 @@ def test_serializing_with_compute():
         pa.field("x", pa.int32()),
         pa.field("y", pa.int32())
     ])
-    expr = pc.equal(ds.field("x"), 7)
-    expr_norm = pc.equal(ds.field(0), 7)
+    expr = pc.equal(pc.field("x"), 7)
+    expr_norm = pc.equal(pc.field(0), 7)
     buf = expr.to_substrait(schema)
     returned = pa.substrait.deserialize_expressions(buf)
 

From c9012a0b53a692d1640f1f373a9442339cb4526d Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 30 Aug 2023 11:40:39 -0400
Subject: [PATCH 273/749] GH-37391: [MATLAB] Implement the `isequal()` method
 on `arrow.array.Array` (#37446)

### Rationale for this change

Currently, it's not possible to determine if two `arrow.array.Array` instances are equal because the `isequal()` method always returns `false` by default:

**Example**

```matlab
>> a = arrow.array([1 2 3])

a =

[
  1,
  2,
  3
]

% Compare a with itself.
>> tf = isequal(a, a)

tf =

  logical

   0
````

### What changes are included in this PR?

1. Defined an `isequal()` overload on the `arrow.array.Array` super-class.
2. Added a new method called `isEqual()` on the `arrow::matlab::array::proxy::Array` class.

Two arrays are considered equal in the MATLAB Interface if the following conditions are met:

 1. They have the same type
 2. They have the same length
 3. The same elements are valid
 4. Corresponding valid elements are equal.

**NOTE:** NaN values are not considered equal.

**Example**

```matlab
>> a = arrow.array([1 2 3])

a =

[
  1,
  2,
  3
]

% Compare a with itself.
>> tf = isequal(a, a)

tf =

  logical

   1

```

### Are these changes tested?

Yes. Added positive and negative `isequal` tests for all concrete subclasses of `arrow.array.Array`.

### Are there any user-facing changes?

Yes. Users can now use `isequal()` with `arrow.array.Array` subclasses.

### Future Directions

1. Implement [`isequaln`](https://www.mathworks.com/help/matlab/ref/isequaln.html) so that users can test array equality with NaNs being treated as equal.
* Closes: #37391

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc | 26 +++++-
 .../src/cpp/arrow/matlab/array/proxy/array.h  |  4 +-
 .../matlab/tabular/proxy/record_batch.cc      |  2 +-
 matlab/src/matlab/+arrow/+array/Array.m       | 19 ++++
 matlab/test/arrow/array/hNumericArray.m       | 51 +++++++++++
 matlab/test/arrow/array/tBooleanArray.m       | 53 +++++++++++
 matlab/test/arrow/array/tDate32Array.m        | 53 +++++++++++
 matlab/test/arrow/array/tFloat32Array.m       |  7 ++
 matlab/test/arrow/array/tFloat64Array.m       |  7 ++
 matlab/test/arrow/array/tStringArray.m        | 51 +++++++++++
 matlab/test/arrow/array/tTime32Array.m        | 66 ++++++++++++++
 matlab/test/arrow/array/tTime64Array.m        | 66 ++++++++++++++
 matlab/test/arrow/array/tTimestampArray.m     | 89 +++++++++++++++++++
 13 files changed, 491 insertions(+), 3 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index 8520cf1f21fdd..9dc14c3419b97 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -35,9 +35,11 @@ namespace arrow::matlab::array::proxy {
         REGISTER_METHOD(Array, length);
         REGISTER_METHOD(Array, valid);
         REGISTER_METHOD(Array, type);
+        REGISTER_METHOD(Array, isEqual);
+
     }
 
-    std::shared_ptr<arrow::Array> Array::getArray() {
+    std::shared_ptr<arrow::Array> Array::unwrap() {
         return array;
     }
 
@@ -91,4 +93,26 @@ namespace arrow::matlab::array::proxy {
         context.outputs[0] = factory.createScalar(proxy_id);
         context.outputs[1] = factory.createScalar(static_cast<int64_t>(type_id));
     }
+
+    void Array::isEqual(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        const mda::TypedArray<uint64_t> array_proxy_ids = context.inputs[0];
+
+        bool is_equal = true;
+        const auto equals_options = arrow::EqualOptions::Defaults();
+        for (const auto& array_proxy_id : array_proxy_ids) {
+           // Retrieve the Array proxy from the ProxyManager
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(array_proxy_id);
+            auto array_proxy = std::static_pointer_cast<proxy::Array>(proxy);
+            auto array_to_compare = array_proxy->unwrap();
+
+            if (!array->Equals(array_to_compare, equals_options)) {
+                is_equal = false;
+                break;
+            }
+        }
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(is_equal);
+    }
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index 90199767258e2..fe28c8a8dd009 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -30,7 +30,7 @@ class Array : public libmexclass::proxy::Proxy {
     
         virtual ~Array() {}
 
-        std::shared_ptr<arrow::Array> getArray();
+        std::shared_ptr<arrow::Array> unwrap();
 
     protected:
 
@@ -44,6 +44,8 @@ class Array : public libmexclass::proxy::Proxy {
 
         virtual void toMATLAB(libmexclass::proxy::method::Context& context) = 0;
 
+        void isEqual(libmexclass::proxy::method::Context& context);
+
         std::shared_ptr<arrow::Array> array;
 };
 
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index c526bfc81d9f7..7b81eee21ef70 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -81,7 +81,7 @@ namespace arrow::matlab::tabular::proxy {
         for (const auto& arrow_array_proxy_id : arrow_array_proxy_ids) {
             auto proxy = libmexclass::proxy::ProxyManager::getProxy(arrow_array_proxy_id);
             auto arrow_array_proxy = std::static_pointer_cast<arrow::matlab::array::proxy::Array>(proxy);
-            auto arrow_array = arrow_array_proxy->getArray();
+            auto arrow_array = arrow_array_proxy->unwrap();
             arrow_arrays.push_back(arrow_array);
         }
 
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 46b46660e7cf3..dbf4abad45425 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -69,5 +69,24 @@ function displayScalarObject(obj)
             disp(obj.toString());
         end
     end
+
+    methods
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+            tf = false;
+            % Extract each array's proxy ID
+            proxyIDs = zeros(numel(varargin), 1, "uint64");
+            for ii = 1:numel(varargin)
+                array = varargin{ii};
+                if ~isa(array, "arrow.array.Array")
+                    % Return early if array is not a arrow.array.Array
+                    return;
+                end
+                proxyIDs(ii) = array.Proxy.ID;
+            end
+            % Invoke isEqual proxy object method
+            tf = obj.Proxy.isEqual(proxyIDs);
+        end
+    end
 end
 
diff --git a/matlab/test/arrow/array/hNumericArray.m b/matlab/test/arrow/array/hNumericArray.m
index fc5f5a05998ed..2780ae5668ad0 100644
--- a/matlab/test/arrow/array/hNumericArray.m
+++ b/matlab/test/arrow/array/hNumericArray.m
@@ -149,5 +149,56 @@ function TestArrowType(tc)
             arrowArray = tc.ArrowArrayConstructorFcn(data);
             tc.verifyEqual(arrowArray.Type.ID, tc.ArrowType.ID);
         end
+
+        function TestIsEqualTrue(tc)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+
+            data1 = tc.MatlabArrayFcn([1 2 3 4]);
+            data2 = tc.MatlabArrayFcn([1 2 5 4]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc)
+            % Verify isequal returns false when expected. 
+            data1 = tc.MatlabArrayFcn([1 2 3 4]);
+            data2 = tc.MatlabArrayFcn([5 2 3 4]);
+            data3 = tc.MatlabArrayFcn([1 2 3 4 5]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(data3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
     end
 end
diff --git a/matlab/test/arrow/array/tBooleanArray.m b/matlab/test/arrow/array/tBooleanArray.m
index df7f052597075..0a488039a0ab7 100644
--- a/matlab/test/arrow/array/tBooleanArray.m
+++ b/matlab/test/arrow/array/tBooleanArray.m
@@ -158,5 +158,58 @@ function TestArrowType(tc)
             arrowArray = tc.ArrowArrayConstructorFcn(data);
             tc.verifyEqual(arrowArray.Type.ID, tc.ArrowType.ID);
         end
+
+        function TestIsEqualTrue(tc)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+
+            
+            data1 = tc.MatlabArrayFcn([true false true false]);
+            data2 = tc.MatlabArrayFcn([true false false false]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc)
+            % Verify isequal returns false when expected. 
+
+            data1 = tc.MatlabArrayFcn([true false true false]);
+            data2 = tc.MatlabArrayFcn([false false true false]);
+            data3 = tc.MatlabArrayFcn([true false true false false]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            array4 = arrow.array([1 2 3 4]);
+            array5 = tc.ArrowArrayConstructorFcn(data3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
     end
 end
diff --git a/matlab/test/arrow/array/tDate32Array.m b/matlab/test/arrow/array/tDate32Array.m
index a5fc1c1b64838..d7289c1df857e 100644
--- a/matlab/test/arrow/array/tDate32Array.m
+++ b/matlab/test/arrow/array/tDate32Array.m
@@ -280,6 +280,59 @@ function TestNonWholeDaysRoundDown(testCase)
             testCase.verifyEqual(actual, expected);
         end
 
+        function TestIsEqualTrue(tc)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+
+            
+            dates1 = datetime(2023, 6, 22)  + days(0:4);
+            dates2 = datetime(2023, 6, 22) + days([0 1 5 3 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc)
+            % Verify isequal returns false when expected. 
+            dates1 = datetime(2023, 6, 22) + days(0:4);
+            dates2 = datetime(2023, 6, 22) + days([1 1 2 3 4]);
+            dates3 = datetime(2023, 6, 22) + days(0:5);
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(dates3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
+
     end
 
     methods
diff --git a/matlab/test/arrow/array/tFloat32Array.m b/matlab/test/arrow/array/tFloat32Array.m
index 2ec9b90b4d277..8a583c6b64a15 100644
--- a/matlab/test/arrow/array/tFloat32Array.m
+++ b/matlab/test/arrow/array/tFloat32Array.m
@@ -110,5 +110,12 @@ function NumericlValidNVPair(testCase)
             testCase.verifyEqual(arrowArray.Valid, [true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), single([1; NaN; 3]));
         end
+
+        function TestNanIsEqualFalse(testCase)
+            % Verify corresponding NaN values are not considered equal.
+            matlabArray = single([1 2 NaN 4]);
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=false);
+            testCase.verifyFalse(isequal(arrowArray, arrowArray));
+        end
     end
 end
diff --git a/matlab/test/arrow/array/tFloat64Array.m b/matlab/test/arrow/array/tFloat64Array.m
index a39a3d1e62cb4..ec2871a124894 100755
--- a/matlab/test/arrow/array/tFloat64Array.m
+++ b/matlab/test/arrow/array/tFloat64Array.m
@@ -115,5 +115,12 @@ function NumericlValidNVPair(testCase)
             testCase.verifyEqual(arrowArray.Valid, [true; false; true]);
             testCase.verifyEqual(toMATLAB(arrowArray), [1; NaN; 3]);
         end
+
+        function TestNanIsEqualFalse(testCase)
+            % Verify corresponding NaN values are not considered equal.
+            matlabArray = [1 2 NaN 4];
+            arrowArray = testCase.ArrowArrayConstructorFcn(matlabArray, InferNulls=false);
+            testCase.verifyFalse(isequal(arrowArray, arrowArray));
+        end
     end
 end
diff --git a/matlab/test/arrow/array/tStringArray.m b/matlab/test/arrow/array/tStringArray.m
index 85628ce4216dd..f042a21ff87af 100644
--- a/matlab/test/arrow/array/tStringArray.m
+++ b/matlab/test/arrow/array/tStringArray.m
@@ -228,5 +228,56 @@ function ErrorIfChar(tc)
             matlabArray = char.empty(1, 0);
             tc.verifyError(@() tc.ArrowArrayConstructorFcn(matlabArray), "arrow:array:InvalidType");
         end
+
+        function TestIsEqualTrue(tc)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+            
+            data1 = tc.MatlabArrayFcn(["1" "2" "3" "4"]);
+            data2 = tc.MatlabArrayFcn(["1" "2" "5" "4"]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc)
+            % Verify isequal returns false when expected.
+            data1 = tc.MatlabArrayFcn(["1" "2" "3" "4"]);
+            data2 = tc.MatlabArrayFcn(["5" "2" "3" "4"]);
+            data3 = tc.MatlabArrayFcn(["1" "2" "3" "4" "5"]);
+            array1 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(data1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(data2, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(data3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
     end
 end
diff --git a/matlab/test/arrow/array/tTime32Array.m b/matlab/test/arrow/array/tTime32Array.m
index e874889e5879d..b593b2630c709 100644
--- a/matlab/test/arrow/array/tTime32Array.m
+++ b/matlab/test/arrow/array/tTime32Array.m
@@ -208,6 +208,72 @@ function ErrorIfNonDuration(testCase)
             fcn = @() testCase.ArrowArrayConstructorFcn(numbers);
             testCase.verifyError(fcn, "arrow:array:InvalidType");
         end
+
+        function TestIsEqualTrue(tc, Unit)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+
+            times1 = seconds([1 2 3 4]);
+            times2 = seconds([1 2 10 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(times2, TimeUnit=Unit, Valid=[1 2 4]);
+
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc, Unit)
+            % Verify isequal returns false when expected.
+            times1 = seconds([1 2 3 4]);
+            times2 = seconds([1 1 2 3]);
+            times3 = seconds([1 2 3 4 5]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(times2,  TimeUnit=Unit, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(times3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
+
+        function TestIsEqualFalseTimeUnitMistmatch(tc)
+            % Verify two Time32Arrays are not considered equal if they have
+            % different TimeUnit values.
+
+            times1 = seconds([1 2 3 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit="Second");
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit="Millisecond");
+
+            % arrays are not equal
+            tc.verifyFalse(isequal(array1, array2));
+        end
     end
 
     methods
diff --git a/matlab/test/arrow/array/tTime64Array.m b/matlab/test/arrow/array/tTime64Array.m
index 973a8e6b6af75..ea4fec3da6c8f 100644
--- a/matlab/test/arrow/array/tTime64Array.m
+++ b/matlab/test/arrow/array/tTime64Array.m
@@ -224,6 +224,72 @@ function NanosecondPrecision(testCase)
             expected = milliseconds(1.0030030);
             testCase.verifyEqual(duration(array), expected);
         end
+
+        function TestIsEqualTrue(tc, Unit)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+            
+            times1 = seconds([1 2 3 4]);
+            times2 = seconds([1 2 10 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(times2, TimeUnit=Unit, Valid=[1 2 4]);
+
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc, Unit)
+            % Verify isequal returns false when expected.
+
+            times1 = seconds([1 2 3 4]);
+            times2 = seconds([1 1 2 3]);
+            times3 = seconds([1 2 3 4 5]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit=Unit, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(times2,  TimeUnit=Unit, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(times3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
+
+        function TestIsEqualFalseTimeUnitMistmatch(tc)
+            % Verify two Time64Arrays are not considered equal if they have
+            % different TimeUnit values.
+            times1 = seconds([1 2 3 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(times1, TimeUnit="Nanosecond");
+            array2 = tc.ArrowArrayConstructorFcn(times1, TimeUnit="Microsecond");
+
+            % arrays are not equal
+            tc.verifyFalse(isequal(array1, array2));
+        end
     end
 
     methods
diff --git a/matlab/test/arrow/array/tTimestampArray.m b/matlab/test/arrow/array/tTimestampArray.m
index 5b7182c386c25..cf273b3de2041 100644
--- a/matlab/test/arrow/array/tTimestampArray.m
+++ b/matlab/test/arrow/array/tTimestampArray.m
@@ -179,8 +179,97 @@ function EmptyDatetimeVector(testCase)
             testCase.verifyEqual(arrowArray.Length, int64(0));
             testCase.verifyEqual(arrowArray.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(arrowArray), datetime.empty(0, 1));
+        end
+
+        function TestIsEqualTrue(tc, TimeZone)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+            
+            dates1 = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
+            dates2 = datetime(2023, 6, 22, TimeZone=TimeZone) + days([0 1 5 3 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3)); 
+        end
+
+        function TestIsEqualFalse(tc, TimeZone)
+            % Verify isequal returns false when expected.
+            
+            dates1 = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
+            dates2 = datetime(2023, 6, 22, TimeZone=TimeZone) + days([1 1 2 3 4]);
+            dates3 = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:5);
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(dates3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
 
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5)); 
+        end
+
+        function TestIsEqualFalseTimeZoneMistmatch(tc)
+            % Verify two TimestampArrays are not considered equal if one
+            % has a TimeZone and one does not. 
+            dates1 = datetime(2023, 6, 22, TimeZone="America/Anchorage") + days(0:4);
+            dates2 = dates1 - tzoffset(dates1);
+            dates2.TimeZone = '';
+
+            array1 = tc.ArrowArrayConstructorFcn(dates1);
+            array2 = tc.ArrowArrayConstructorFcn(dates2);
+
+            % arrays are not equal
+            tc.verifyFalse(isequal(array1, array2));
+        end
+
+        function TestIsEqualSameInstantDifferentTimeZone(tc)
+            % Verify two TimestampArrays are not considered equal if
+            % they represent the same "instant in time", but have different
+            % TimeZone values.
+            dates1 = datetime(2023, 6, 22, TimeZone="America/Anchorage") + days(0:4);
+            dates2 = dates1;
+            dates2.TimeZone = "America/New_York";
+
+            array1 = tc.ArrowArrayConstructorFcn(dates1);
+            array2 = tc.ArrowArrayConstructorFcn(dates2);
+
+            % arrays are not equal
+            tc.verifyFalse(isequal(array1, array2));
+        end
 
+        function TestIsEqualFalseTimeUnitMistmatch(tc, TimeZone)
+            % Verify two TimestampArrays are not considered equal if their
+            % TimeUnit values differ.
+            dates1 = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
+            array1 = tc.ArrowArrayConstructorFcn(dates1, TimeUnit="Millisecond");
+            array2 = tc.ArrowArrayConstructorFcn(dates1, TimeUnit="Microsecond");
+            tc.verifyFalse(isequal(array1, array2));
         end
     end
 

From e0ee82cb8db2aa950119689f6ce3972ef4333aa9 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Thu, 31 Aug 2023 00:03:28 +0800
Subject: [PATCH 274/749] GH-34909: [C++] Avoid mean overflow on large integer
 inputs (#37243)

### Rationale for this change

The `mean` aggregate function would overflow if the input array's sum is larger than int64_max.

### What changes are included in this PR?

Store intermediate sum in double instead of int64, so that it won't overflow.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #34909

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../kernels/aggregate_basic_internal.h        | 57 ++++++++++++-------
 .../arrow/compute/kernels/aggregate_test.cc   | 14 +++++
 2 files changed, 52 insertions(+), 19 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
index 3de922531ab19..4966e9871d62c 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
+++ b/cpp/src/arrow/compute/kernels/aggregate_basic_internal.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <cmath>
+#include <type_traits>
 #include <utility>
 
 #include "arrow/compute/api_aggregate.h"
@@ -25,13 +26,13 @@
 #include "arrow/compute/kernels/codegen_internal.h"
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/compute/kernels/util_internal.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
 #include "arrow/util/align_util.h"
 #include "arrow/util/bit_block_counter.h"
 #include "arrow/util/decimal.h"
 
-namespace arrow {
-namespace compute {
-namespace internal {
+namespace arrow::compute::internal {
 
 void AddBasicAggKernels(KernelInit init,
                         const std::vector<std::shared_ptr<DataType>>& types,
@@ -58,16 +59,17 @@ void AddMinMaxAvx512AggKernels(ScalarAggregateFunction* func);
 // ----------------------------------------------------------------------
 // Sum implementation
 
-template <typename ArrowType, SimdLevel::type SimdLevel>
+template <typename ArrowType, SimdLevel::type SimdLevel,
+          typename ResultType = typename FindAccumulatorType<ArrowType>::Type>
 struct SumImpl : public ScalarAggregator {
-  using ThisType = SumImpl<ArrowType, SimdLevel>;
+  using ThisType = SumImpl<ArrowType, SimdLevel, ResultType>;
   using CType = typename TypeTraits<ArrowType>::CType;
-  using SumType = typename FindAccumulatorType<ArrowType>::Type;
+  using SumType = ResultType;
   using SumCType = typename TypeTraits<SumType>::CType;
   using OutputType = typename TypeTraits<SumType>::ScalarType;
 
-  SumImpl(std::shared_ptr<DataType> out_type, const ScalarAggregateOptions& options_)
-      : out_type(out_type), options(options_) {}
+  SumImpl(std::shared_ptr<DataType> out_type, ScalarAggregateOptions options_)
+      : out_type(std::move(out_type)), options(std::move(options_)) {}
 
   Status Consume(KernelContext*, const ExecSpan& batch) override {
     if (batch[0].is_array()) {
@@ -169,14 +171,19 @@ struct NullSumImpl : public NullImpl<ArrowType> {
   }
 };
 
+template <typename ArrowType, SimdLevel::type SimdLevel, typename Enable = void>
+struct MeanImpl;
+
 template <typename ArrowType, SimdLevel::type SimdLevel>
-struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
+struct MeanImpl<ArrowType, SimdLevel, enable_if_decimal<ArrowType>>
+    : public SumImpl<ArrowType, SimdLevel> {
   using SumImpl<ArrowType, SimdLevel>::SumImpl;
+  using SumImpl<ArrowType, SimdLevel>::options;
+  using SumCType = typename SumImpl<ArrowType, SimdLevel>::SumCType;
+  using OutputType = typename SumImpl<ArrowType, SimdLevel>::OutputType;
 
   template <typename T = ArrowType>
-  enable_if_decimal<T, Status> FinalizeImpl(Datum* out) {
-    using SumCType = typename SumImpl<ArrowType, SimdLevel>::SumCType;
-    using OutputType = typename SumImpl<ArrowType, SimdLevel>::OutputType;
+  Status FinalizeImpl(Datum* out) {
     if ((!options.skip_nulls && this->nulls_observed) ||
         (this->count < options.min_count) || (this->count == 0)) {
       out->value = std::make_shared<OutputType>(this->out_type);
@@ -196,20 +203,34 @@ struct MeanImpl : public SumImpl<ArrowType, SimdLevel> {
     }
     return Status::OK();
   }
+
+  Status Finalize(KernelContext*, Datum* out) override { return FinalizeImpl(out); }
+};
+
+template <typename ArrowType, SimdLevel::type SimdLevel>
+struct MeanImpl<ArrowType, SimdLevel,
+                std::enable_if_t<!is_decimal_type<ArrowType>::value>>
+    // Override the ResultType of SumImpl because we need to use double for intermediate
+    // sum to prevent integer overflows
+    : public SumImpl<ArrowType, SimdLevel, DoubleType> {
+  using SumImpl<ArrowType, SimdLevel, DoubleType>::SumImpl;
+  using SumImpl<ArrowType, SimdLevel, DoubleType>::options;
+
   template <typename T = ArrowType>
-  enable_if_t<!is_decimal_type<T>::value, Status> FinalizeImpl(Datum* out) {
+  Status FinalizeImpl(Datum* out) {
     if ((!options.skip_nulls && this->nulls_observed) ||
         (this->count < options.min_count)) {
       out->value = std::make_shared<DoubleScalar>();
     } else {
-      const double mean = static_cast<double>(this->sum) / this->count;
+      static_assert(std::is_same_v<decltype(this->sum), double>,
+                    "SumCType must be double for numeric inputs");
+      const double mean = this->sum / this->count;
       out->value = std::make_shared<DoubleScalar>(mean);
     }
     return Status::OK();
   }
-  Status Finalize(KernelContext*, Datum* out) override { return FinalizeImpl(out); }
 
-  using SumImpl<ArrowType, SimdLevel>::options;
+  Status Finalize(KernelContext*, Datum* out) override { return FinalizeImpl(out); }
 };
 
 template <template <typename> class KernelClass>
@@ -1012,6 +1033,4 @@ struct MinMaxInitState {
   }
 };
 
-}  // namespace internal
-}  // namespace compute
-}  // namespace arrow
+}  // namespace arrow::compute::internal
diff --git a/cpp/src/arrow/compute/kernels/aggregate_test.cc b/cpp/src/arrow/compute/kernels/aggregate_test.cc
index 2a7ba1a51e433..aa19fb3401232 100644
--- a/cpp/src/arrow/compute/kernels/aggregate_test.cc
+++ b/cpp/src/arrow/compute/kernels/aggregate_test.cc
@@ -1274,6 +1274,20 @@ TYPED_TEST(TestNumericMeanKernel, ScalarAggregateOptions) {
               ResultWith(Datum(MakeNullScalar(float64()))));
 }
 
+TEST(TestNumericMeanKernel, Overflow) {
+  // will overflow if intermediate sum is int64_t
+  EXPECT_THAT(
+      Mean(ArrayFromJSON(
+          int64(), "[9223372036854775805, 9223372036854775806, 9223372036854775807]")),
+      ResultWith(ScalarFromJSON(float64(), "9223372036854775806")));
+
+  // will overflow if intermediate sum is uint64_t
+  EXPECT_THAT(
+      Mean(ArrayFromJSON(
+          uint64(), "[9223372036854775805, 9223372036854775806, 9223372036854775807]")),
+      ResultWith(ScalarFromJSON(float64(), "9223372036854775806")));
+}
+
 template <typename ArrowType>
 class TestRandomNumericMeanKernel : public ::testing::Test {};
 

From f209161a9dc6c3654aceca7775be0c5285f799f2 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 30 Aug 2023 18:43:14 +0200
Subject: [PATCH 275/749] GH-37466: [C++][Parquet] Fix Valgrind failure in
 DELTA_BYTE_ARRAY decoder (#37471)

### Rationale for this change

Avoid skipping any padding bits where reading a one-value data page, as it doesn't contain any block (the value is encoded in the header).

### Are these changes tested?

Yes, by existing tests and CI jobs.

### Are there any user-facing changes?

No.

* Closes: #37466

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/util/bit_stream_utils.h | 60 +++++++++++++--------------
 cpp/src/parquet/encoding.cc           | 51 +++++++++++++----------
 2 files changed, 56 insertions(+), 55 deletions(-)

diff --git a/cpp/src/arrow/util/bit_stream_utils.h b/cpp/src/arrow/util/bit_stream_utils.h
index 3854d55515a27..2afb2e5193697 100644
--- a/cpp/src/arrow/util/bit_stream_utils.h
+++ b/cpp/src/arrow/util/bit_stream_utils.h
@@ -108,34 +108,39 @@ class BitWriter {
   int bit_offset_;   // Offset in buffered_values_
 };
 
+namespace detail {
+
+inline uint64_t ReadLittleEndianWord(const uint8_t* buffer, int bytes_remaining) {
+  uint64_t le_value = 0;
+  if (ARROW_PREDICT_TRUE(bytes_remaining >= 8)) {
+    memcpy(&le_value, buffer, 8);
+  } else {
+    memcpy(&le_value, buffer, bytes_remaining);
+  }
+  return arrow::bit_util::FromLittleEndian(le_value);
+}
+
+}  // namespace detail
+
 /// Utility class to read bit/byte stream.  This class can read bits or bytes
 /// that are either byte aligned or not.  It also has utilities to read multiple
 /// bytes in one read (e.g. encoded int).
 class BitReader {
  public:
+  BitReader() = default;
+
   /// 'buffer' is the buffer to read from.  The buffer's length is 'buffer_len'.
-  BitReader(const uint8_t* buffer, int buffer_len)
-      : buffer_(buffer), max_bytes_(buffer_len), byte_offset_(0), bit_offset_(0) {
-    int num_bytes = std::min(8, max_bytes_ - byte_offset_);
-    memcpy(&buffered_values_, buffer_ + byte_offset_, num_bytes);
-    buffered_values_ = arrow::bit_util::FromLittleEndian(buffered_values_);
+  BitReader(const uint8_t* buffer, int buffer_len) : BitReader() {
+    Reset(buffer, buffer_len);
   }
 
-  BitReader()
-      : buffer_(NULL),
-        max_bytes_(0),
-        buffered_values_(0),
-        byte_offset_(0),
-        bit_offset_(0) {}
-
   void Reset(const uint8_t* buffer, int buffer_len) {
     buffer_ = buffer;
     max_bytes_ = buffer_len;
     byte_offset_ = 0;
     bit_offset_ = 0;
-    int num_bytes = std::min(8, max_bytes_ - byte_offset_);
-    memcpy(&buffered_values_, buffer_ + byte_offset_, num_bytes);
-    buffered_values_ = arrow::bit_util::FromLittleEndian(buffered_values_);
+    buffered_values_ =
+        detail::ReadLittleEndianWord(buffer_ + byte_offset_, max_bytes_ - byte_offset_);
   }
 
   /// Gets the next value from the buffer.  Returns true if 'v' could be read or false if
@@ -260,16 +265,6 @@ inline bool BitWriter::PutAligned(T val, int num_bytes) {
 
 namespace detail {
 
-inline void ResetBufferedValues_(const uint8_t* buffer, int byte_offset,
-                                 int bytes_remaining, uint64_t* buffered_values) {
-  if (ARROW_PREDICT_TRUE(bytes_remaining >= 8)) {
-    memcpy(buffered_values, buffer + byte_offset, 8);
-  } else {
-    memcpy(buffered_values, buffer + byte_offset, bytes_remaining);
-  }
-  *buffered_values = arrow::bit_util::FromLittleEndian(*buffered_values);
-}
-
 template <typename T>
 inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer,
                       int* bit_offset, int* byte_offset, uint64_t* buffered_values) {
@@ -287,7 +282,8 @@ inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer,
     *byte_offset += 8;
     *bit_offset -= 64;
 
-    ResetBufferedValues_(buffer, *byte_offset, max_bytes - *byte_offset, buffered_values);
+    *buffered_values =
+        detail::ReadLittleEndianWord(buffer + *byte_offset, max_bytes - *byte_offset);
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4800 4805)
@@ -384,8 +380,8 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
     }
   }
 
-  detail::ResetBufferedValues_(buffer, byte_offset, max_bytes - byte_offset,
-                               &buffered_values);
+  buffered_values =
+      detail::ReadLittleEndianWord(buffer + byte_offset, max_bytes - byte_offset);
 
   for (; i < batch_size; ++i) {
     detail::GetValue_(num_bits, &v[i], max_bytes, buffer, &bit_offset, &byte_offset,
@@ -425,8 +421,8 @@ inline bool BitReader::GetAligned(int num_bytes, T* v) {
   byte_offset_ += num_bytes;
 
   bit_offset_ = 0;
-  detail::ResetBufferedValues_(buffer_, byte_offset_, max_bytes_ - byte_offset_,
-                               &buffered_values_);
+  buffered_values_ =
+      detail::ReadLittleEndianWord(buffer_ + byte_offset_, max_bytes_ - byte_offset_);
   return true;
 }
 
@@ -438,8 +434,8 @@ inline bool BitReader::Advance(int64_t num_bits) {
   }
   byte_offset_ += static_cast<int>(bits_required >> 3);
   bit_offset_ = static_cast<int>(bits_required & 7);
-  detail::ResetBufferedValues_(buffer_, byte_offset_, max_bytes_ - byte_offset_,
-                               &buffered_values_);
+  buffered_values_ =
+      detail::ReadLittleEndianWord(buffer_ + byte_offset_, max_bytes_ - byte_offset_);
   return true;
 }
 
diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index a3cef4b4ce856..e3c8ab196f45e 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -2522,32 +2522,37 @@ class DeltaBitPackDecoder : public DecoderImpl, virtual public TypedDecoder<DTyp
     }
 
     int i = 0;
+
+    if (ARROW_PREDICT_FALSE(!first_block_initialized_)) {
+      // This is the first time we decode this data page, first output the
+      // last value and initialize the first block.
+      buffer[i++] = last_value_;
+      if (ARROW_PREDICT_FALSE(i == max_values)) {
+        // When i reaches max_values here we have two different possibilities:
+        // 1. total_value_count_ == 1, which means that the page may have only
+        //    one value (encoded in the header), and we should not initialize
+        //    any block, nor should we skip any padding bits below.
+        // 2. total_value_count_ != 1, which means we should initialize the
+        //    incoming block for subsequent reads.
+        if (total_value_count_ != 1) {
+          InitBlock();
+        }
+        total_values_remaining_ -= max_values;
+        this->num_values_ -= max_values;
+        return max_values;
+      }
+      InitBlock();
+    }
+
+    DCHECK(first_block_initialized_);
     while (i < max_values) {
+      // Ensure we have an initialized mini-block
       if (ARROW_PREDICT_FALSE(values_remaining_current_mini_block_ == 0)) {
-        if (ARROW_PREDICT_FALSE(!first_block_initialized_)) {
-          buffer[i++] = last_value_;
-          DCHECK_EQ(i, 1);  // we're at the beginning of the page
-          if (ARROW_PREDICT_FALSE(i == max_values)) {
-            // When block is uninitialized and i reaches max_values we have two
-            // different possibilities:
-            // 1. total_value_count_ == 1, which means that the page may have only
-            // one value (encoded in the header), and we should not initialize
-            // any block.
-            // 2. total_value_count_ != 1, which means we should initialize the
-            // incoming block for subsequent reads.
-            if (total_value_count_ != 1) {
-              InitBlock();
-            }
-            break;
-          }
-          InitBlock();
+        ++mini_block_idx_;
+        if (mini_block_idx_ < mini_blocks_per_block_) {
+          InitMiniBlock(delta_bit_widths_->data()[mini_block_idx_]);
         } else {
-          ++mini_block_idx_;
-          if (mini_block_idx_ < mini_blocks_per_block_) {
-            InitMiniBlock(delta_bit_widths_->data()[mini_block_idx_]);
-          } else {
-            InitBlock();
-          }
+          InitBlock();
         }
       }
 

From 4ee6688b8f460df89fa29459f69bd3da4716b5d3 Mon Sep 17 00:00:00 2001
From: Frederic Branczyk <fbranczyk@gmail.com>
Date: Wed, 30 Aug 2023 19:38:41 +0200
Subject: [PATCH 276/749] MINOR: [Go] Don't recursively reserve in append to
 struct builder (#37455)

### Rationale for this change

Recursively reserving on every append is extremely expensive. This is not fundamentally necessary, it is meant to try to save CPU cycles, but in fact because it requires tons of dynamic dispatch (because of interfaces), when appending a lot even though you correctly reserved previously you will waste tons of CPU cycles.

### What changes are included in this PR?

Only reserve space in the validity bitmap of the struct itself.

### Are these changes tested?

Tests are passing and we've successfully deployed and validated the improvement on Polar Signals Cloud.

### Are there any user-facing changes?

It's not an API change, but there is a slight change in behavior, which users should not notice since if reserving is still necessary for the children, then the children builder will perform it automatically. I believe this is only a positive improvement in every direction.

cc @ zeroshade

Authored-by: Frederic Branczyk <fbranczyk@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/struct.go | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/go/arrow/array/struct.go b/go/arrow/array/struct.go
index 868078842a692..248a25bf6044d 100644
--- a/go/arrow/array/struct.go
+++ b/go/arrow/array/struct.go
@@ -259,7 +259,15 @@ func (b *StructBuilder) Release() {
 }
 
 func (b *StructBuilder) Append(v bool) {
-	b.Reserve(1)
+	// Intentionally not calling `Reserve` as it will recursively call
+	// `Reserve` on the child builders, which during profiling has shown to be
+	// very expensive due to iterating over children, dynamic dispatch and all
+	// other code that gets executed even if previously `Reserve` was called to
+	// preallocate. Not calling `Reserve` has no downsides as when appending to
+	// the underlying children they already ensure they have enough space
+	// reserved. The only thing we must do is ensure we have enough space in
+	// the validity bitmap of the struct builder itself.
+	b.builder.reserve(1, b.resizeHelper)
 	b.unsafeAppendBoolToBitmap(v)
 	if !v {
 		for _, f := range b.fields {

From edb5e099ea66d51e4faecc763de0c291cc496749 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Thu, 31 Aug 2023 02:01:45 +0800
Subject: [PATCH 277/749] GH-37379: [C++][Parquet] Thrift: Generate movable
 types (#37461)

### Rationale for this change

Our generated Thrift bindings do not define move constructors, implying that copies are made when passing values around.

### What changes are included in this PR?

Enable the `moveable_types` option when generating Parquet Thrift.   It's introduced in Thrift 0.9.3 ( See https://github.com/apache/thrift/commit/3c5a788d8f243e23474b3ac09a795e4e15a8933f )

Also, exploit move construction and assignment to improve `TypedColumnIndex` construction performance.

### Are these changes tested?

By existing tests.

### Are there any user-facing changes?

1. Binary might grow larger
2. Some overhead might be reduced

* Closes: #37379

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/build-support/update-thrift.sh  |    2 +-
 cpp/src/generated/parquet_types.cpp | 1967 ++++++++++++++++++---------
 cpp/src/generated/parquet_types.h   |  104 +-
 cpp/src/parquet/page_index.cc       |   33 +-
 4 files changed, 1419 insertions(+), 687 deletions(-)

diff --git a/cpp/build-support/update-thrift.sh b/cpp/build-support/update-thrift.sh
index 1213a628e217a..9b8f2539cffe3 100755
--- a/cpp/build-support/update-thrift.sh
+++ b/cpp/build-support/update-thrift.sh
@@ -20,4 +20,4 @@
 
 # Run this from cpp/ directory. thrift is expected to be in your path
 
-thrift --gen cpp -out src/generated src/parquet/parquet.thrift
+thrift --gen cpp:moveable_types -out src/generated src/parquet/parquet.thrift
diff --git a/cpp/src/generated/parquet_types.cpp b/cpp/src/generated/parquet_types.cpp
index b19f2eb19f239..f4e378fd3822a 100644
--- a/cpp/src/generated/parquet_types.cpp
+++ b/cpp/src/generated/parquet_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.17.0)
+ * Autogenerated by Thrift Compiler (0.18.1)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -796,14 +796,33 @@ Statistics::Statistics(const Statistics& other0) {
   min_value = other0.min_value;
   __isset = other0.__isset;
 }
-Statistics& Statistics::operator=(const Statistics& other1) {
-  max = other1.max;
-  min = other1.min;
+Statistics::Statistics(Statistics&& other1) noexcept {
+  max = std::move(other1.max);
+  min = std::move(other1.min);
   null_count = other1.null_count;
   distinct_count = other1.distinct_count;
-  max_value = other1.max_value;
-  min_value = other1.min_value;
+  max_value = std::move(other1.max_value);
+  min_value = std::move(other1.min_value);
   __isset = other1.__isset;
+}
+Statistics& Statistics::operator=(const Statistics& other2) {
+  max = other2.max;
+  min = other2.min;
+  null_count = other2.null_count;
+  distinct_count = other2.distinct_count;
+  max_value = other2.max_value;
+  min_value = other2.min_value;
+  __isset = other2.__isset;
+  return *this;
+}
+Statistics& Statistics::operator=(Statistics&& other3) noexcept {
+  max = std::move(other3.max);
+  min = std::move(other3.min);
+  null_count = other3.null_count;
+  distinct_count = other3.distinct_count;
+  max_value = std::move(other3.max_value);
+  min_value = std::move(other3.min_value);
+  __isset = other3.__isset;
   return *this;
 }
 void Statistics::printTo(std::ostream& out) const {
@@ -873,11 +892,18 @@ void swap(StringType &a, StringType &b) {
   (void) b;
 }
 
-StringType::StringType(const StringType& other2) noexcept {
-  (void) other2;
+StringType::StringType(const StringType& other4) noexcept {
+  (void) other4;
 }
-StringType& StringType::operator=(const StringType& other3) noexcept {
-  (void) other3;
+StringType::StringType(StringType&& other5) noexcept {
+  (void) other5;
+}
+StringType& StringType::operator=(const StringType& other6) noexcept {
+  (void) other6;
+  return *this;
+}
+StringType& StringType::operator=(StringType&& other7) noexcept {
+  (void) other7;
   return *this;
 }
 void StringType::printTo(std::ostream& out) const {
@@ -941,11 +967,18 @@ void swap(UUIDType &a, UUIDType &b) {
   (void) b;
 }
 
-UUIDType::UUIDType(const UUIDType& other4) noexcept {
-  (void) other4;
+UUIDType::UUIDType(const UUIDType& other8) noexcept {
+  (void) other8;
 }
-UUIDType& UUIDType::operator=(const UUIDType& other5) noexcept {
-  (void) other5;
+UUIDType::UUIDType(UUIDType&& other9) noexcept {
+  (void) other9;
+}
+UUIDType& UUIDType::operator=(const UUIDType& other10) noexcept {
+  (void) other10;
+  return *this;
+}
+UUIDType& UUIDType::operator=(UUIDType&& other11) noexcept {
+  (void) other11;
   return *this;
 }
 void UUIDType::printTo(std::ostream& out) const {
@@ -1009,11 +1042,18 @@ void swap(MapType &a, MapType &b) {
   (void) b;
 }
 
-MapType::MapType(const MapType& other6) noexcept {
-  (void) other6;
+MapType::MapType(const MapType& other12) noexcept {
+  (void) other12;
 }
-MapType& MapType::operator=(const MapType& other7) noexcept {
-  (void) other7;
+MapType::MapType(MapType&& other13) noexcept {
+  (void) other13;
+}
+MapType& MapType::operator=(const MapType& other14) noexcept {
+  (void) other14;
+  return *this;
+}
+MapType& MapType::operator=(MapType&& other15) noexcept {
+  (void) other15;
   return *this;
 }
 void MapType::printTo(std::ostream& out) const {
@@ -1077,11 +1117,18 @@ void swap(ListType &a, ListType &b) {
   (void) b;
 }
 
-ListType::ListType(const ListType& other8) noexcept {
-  (void) other8;
+ListType::ListType(const ListType& other16) noexcept {
+  (void) other16;
 }
-ListType& ListType::operator=(const ListType& other9) noexcept {
-  (void) other9;
+ListType::ListType(ListType&& other17) noexcept {
+  (void) other17;
+}
+ListType& ListType::operator=(const ListType& other18) noexcept {
+  (void) other18;
+  return *this;
+}
+ListType& ListType::operator=(ListType&& other19) noexcept {
+  (void) other19;
   return *this;
 }
 void ListType::printTo(std::ostream& out) const {
@@ -1145,11 +1192,18 @@ void swap(EnumType &a, EnumType &b) {
   (void) b;
 }
 
-EnumType::EnumType(const EnumType& other10) noexcept {
-  (void) other10;
+EnumType::EnumType(const EnumType& other20) noexcept {
+  (void) other20;
 }
-EnumType& EnumType::operator=(const EnumType& other11) noexcept {
-  (void) other11;
+EnumType::EnumType(EnumType&& other21) noexcept {
+  (void) other21;
+}
+EnumType& EnumType::operator=(const EnumType& other22) noexcept {
+  (void) other22;
+  return *this;
+}
+EnumType& EnumType::operator=(EnumType&& other23) noexcept {
+  (void) other23;
   return *this;
 }
 void EnumType::printTo(std::ostream& out) const {
@@ -1213,11 +1267,18 @@ void swap(DateType &a, DateType &b) {
   (void) b;
 }
 
-DateType::DateType(const DateType& other12) noexcept {
-  (void) other12;
+DateType::DateType(const DateType& other24) noexcept {
+  (void) other24;
 }
-DateType& DateType::operator=(const DateType& other13) noexcept {
-  (void) other13;
+DateType::DateType(DateType&& other25) noexcept {
+  (void) other25;
+}
+DateType& DateType::operator=(const DateType& other26) noexcept {
+  (void) other26;
+  return *this;
+}
+DateType& DateType::operator=(DateType&& other27) noexcept {
+  (void) other27;
   return *this;
 }
 void DateType::printTo(std::ostream& out) const {
@@ -1281,11 +1342,18 @@ void swap(NullType &a, NullType &b) {
   (void) b;
 }
 
-NullType::NullType(const NullType& other14) noexcept {
-  (void) other14;
+NullType::NullType(const NullType& other28) noexcept {
+  (void) other28;
 }
-NullType& NullType::operator=(const NullType& other15) noexcept {
-  (void) other15;
+NullType::NullType(NullType&& other29) noexcept {
+  (void) other29;
+}
+NullType& NullType::operator=(const NullType& other30) noexcept {
+  (void) other30;
+  return *this;
+}
+NullType& NullType::operator=(NullType&& other31) noexcept {
+  (void) other31;
   return *this;
 }
 void NullType::printTo(std::ostream& out) const {
@@ -1392,13 +1460,22 @@ void swap(DecimalType &a, DecimalType &b) {
   swap(a.precision, b.precision);
 }
 
-DecimalType::DecimalType(const DecimalType& other16) noexcept {
-  scale = other16.scale;
-  precision = other16.precision;
+DecimalType::DecimalType(const DecimalType& other32) noexcept {
+  scale = other32.scale;
+  precision = other32.precision;
 }
-DecimalType& DecimalType::operator=(const DecimalType& other17) noexcept {
-  scale = other17.scale;
-  precision = other17.precision;
+DecimalType::DecimalType(DecimalType&& other33) noexcept {
+  scale = other33.scale;
+  precision = other33.precision;
+}
+DecimalType& DecimalType::operator=(const DecimalType& other34) noexcept {
+  scale = other34.scale;
+  precision = other34.precision;
+  return *this;
+}
+DecimalType& DecimalType::operator=(DecimalType&& other35) noexcept {
+  scale = other35.scale;
+  precision = other35.precision;
   return *this;
 }
 void DecimalType::printTo(std::ostream& out) const {
@@ -1464,11 +1541,18 @@ void swap(MilliSeconds &a, MilliSeconds &b) {
   (void) b;
 }
 
-MilliSeconds::MilliSeconds(const MilliSeconds& other18) noexcept {
-  (void) other18;
+MilliSeconds::MilliSeconds(const MilliSeconds& other36) noexcept {
+  (void) other36;
 }
-MilliSeconds& MilliSeconds::operator=(const MilliSeconds& other19) noexcept {
-  (void) other19;
+MilliSeconds::MilliSeconds(MilliSeconds&& other37) noexcept {
+  (void) other37;
+}
+MilliSeconds& MilliSeconds::operator=(const MilliSeconds& other38) noexcept {
+  (void) other38;
+  return *this;
+}
+MilliSeconds& MilliSeconds::operator=(MilliSeconds&& other39) noexcept {
+  (void) other39;
   return *this;
 }
 void MilliSeconds::printTo(std::ostream& out) const {
@@ -1532,11 +1616,18 @@ void swap(MicroSeconds &a, MicroSeconds &b) {
   (void) b;
 }
 
-MicroSeconds::MicroSeconds(const MicroSeconds& other20) noexcept {
-  (void) other20;
+MicroSeconds::MicroSeconds(const MicroSeconds& other40) noexcept {
+  (void) other40;
 }
-MicroSeconds& MicroSeconds::operator=(const MicroSeconds& other21) noexcept {
-  (void) other21;
+MicroSeconds::MicroSeconds(MicroSeconds&& other41) noexcept {
+  (void) other41;
+}
+MicroSeconds& MicroSeconds::operator=(const MicroSeconds& other42) noexcept {
+  (void) other42;
+  return *this;
+}
+MicroSeconds& MicroSeconds::operator=(MicroSeconds&& other43) noexcept {
+  (void) other43;
   return *this;
 }
 void MicroSeconds::printTo(std::ostream& out) const {
@@ -1600,11 +1691,18 @@ void swap(NanoSeconds &a, NanoSeconds &b) {
   (void) b;
 }
 
-NanoSeconds::NanoSeconds(const NanoSeconds& other22) noexcept {
-  (void) other22;
+NanoSeconds::NanoSeconds(const NanoSeconds& other44) noexcept {
+  (void) other44;
 }
-NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other23) noexcept {
-  (void) other23;
+NanoSeconds::NanoSeconds(NanoSeconds&& other45) noexcept {
+  (void) other45;
+}
+NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other46) noexcept {
+  (void) other46;
+  return *this;
+}
+NanoSeconds& NanoSeconds::operator=(NanoSeconds&& other47) noexcept {
+  (void) other47;
   return *this;
 }
 void NanoSeconds::printTo(std::ostream& out) const {
@@ -1729,17 +1827,30 @@ void swap(TimeUnit &a, TimeUnit &b) {
   swap(a.__isset, b.__isset);
 }
 
-TimeUnit::TimeUnit(const TimeUnit& other24) noexcept {
-  MILLIS = other24.MILLIS;
-  MICROS = other24.MICROS;
-  NANOS = other24.NANOS;
-  __isset = other24.__isset;
+TimeUnit::TimeUnit(const TimeUnit& other48) noexcept {
+  MILLIS = other48.MILLIS;
+  MICROS = other48.MICROS;
+  NANOS = other48.NANOS;
+  __isset = other48.__isset;
+}
+TimeUnit::TimeUnit(TimeUnit&& other49) noexcept {
+  MILLIS = std::move(other49.MILLIS);
+  MICROS = std::move(other49.MICROS);
+  NANOS = std::move(other49.NANOS);
+  __isset = other49.__isset;
+}
+TimeUnit& TimeUnit::operator=(const TimeUnit& other50) noexcept {
+  MILLIS = other50.MILLIS;
+  MICROS = other50.MICROS;
+  NANOS = other50.NANOS;
+  __isset = other50.__isset;
+  return *this;
 }
-TimeUnit& TimeUnit::operator=(const TimeUnit& other25) noexcept {
-  MILLIS = other25.MILLIS;
-  MICROS = other25.MICROS;
-  NANOS = other25.NANOS;
-  __isset = other25.__isset;
+TimeUnit& TimeUnit::operator=(TimeUnit&& other51) noexcept {
+  MILLIS = std::move(other51.MILLIS);
+  MICROS = std::move(other51.MICROS);
+  NANOS = std::move(other51.NANOS);
+  __isset = other51.__isset;
   return *this;
 }
 void TimeUnit::printTo(std::ostream& out) const {
@@ -1849,13 +1960,22 @@ void swap(TimestampType &a, TimestampType &b) {
   swap(a.unit, b.unit);
 }
 
-TimestampType::TimestampType(const TimestampType& other26) noexcept {
-  isAdjustedToUTC = other26.isAdjustedToUTC;
-  unit = other26.unit;
+TimestampType::TimestampType(const TimestampType& other52) noexcept {
+  isAdjustedToUTC = other52.isAdjustedToUTC;
+  unit = other52.unit;
+}
+TimestampType::TimestampType(TimestampType&& other53) noexcept {
+  isAdjustedToUTC = other53.isAdjustedToUTC;
+  unit = std::move(other53.unit);
+}
+TimestampType& TimestampType::operator=(const TimestampType& other54) noexcept {
+  isAdjustedToUTC = other54.isAdjustedToUTC;
+  unit = other54.unit;
+  return *this;
 }
-TimestampType& TimestampType::operator=(const TimestampType& other27) noexcept {
-  isAdjustedToUTC = other27.isAdjustedToUTC;
-  unit = other27.unit;
+TimestampType& TimestampType::operator=(TimestampType&& other55) noexcept {
+  isAdjustedToUTC = other55.isAdjustedToUTC;
+  unit = std::move(other55.unit);
   return *this;
 }
 void TimestampType::printTo(std::ostream& out) const {
@@ -1964,13 +2084,22 @@ void swap(TimeType &a, TimeType &b) {
   swap(a.unit, b.unit);
 }
 
-TimeType::TimeType(const TimeType& other28) noexcept {
-  isAdjustedToUTC = other28.isAdjustedToUTC;
-  unit = other28.unit;
+TimeType::TimeType(const TimeType& other56) noexcept {
+  isAdjustedToUTC = other56.isAdjustedToUTC;
+  unit = other56.unit;
+}
+TimeType::TimeType(TimeType&& other57) noexcept {
+  isAdjustedToUTC = other57.isAdjustedToUTC;
+  unit = std::move(other57.unit);
+}
+TimeType& TimeType::operator=(const TimeType& other58) noexcept {
+  isAdjustedToUTC = other58.isAdjustedToUTC;
+  unit = other58.unit;
+  return *this;
 }
-TimeType& TimeType::operator=(const TimeType& other29) noexcept {
-  isAdjustedToUTC = other29.isAdjustedToUTC;
-  unit = other29.unit;
+TimeType& TimeType::operator=(TimeType&& other59) noexcept {
+  isAdjustedToUTC = other59.isAdjustedToUTC;
+  unit = std::move(other59.unit);
   return *this;
 }
 void TimeType::printTo(std::ostream& out) const {
@@ -2079,13 +2208,22 @@ void swap(IntType &a, IntType &b) {
   swap(a.isSigned, b.isSigned);
 }
 
-IntType::IntType(const IntType& other30) noexcept {
-  bitWidth = other30.bitWidth;
-  isSigned = other30.isSigned;
+IntType::IntType(const IntType& other60) noexcept {
+  bitWidth = other60.bitWidth;
+  isSigned = other60.isSigned;
 }
-IntType& IntType::operator=(const IntType& other31) noexcept {
-  bitWidth = other31.bitWidth;
-  isSigned = other31.isSigned;
+IntType::IntType(IntType&& other61) noexcept {
+  bitWidth = other61.bitWidth;
+  isSigned = other61.isSigned;
+}
+IntType& IntType::operator=(const IntType& other62) noexcept {
+  bitWidth = other62.bitWidth;
+  isSigned = other62.isSigned;
+  return *this;
+}
+IntType& IntType::operator=(IntType&& other63) noexcept {
+  bitWidth = other63.bitWidth;
+  isSigned = other63.isSigned;
   return *this;
 }
 void IntType::printTo(std::ostream& out) const {
@@ -2151,11 +2289,18 @@ void swap(JsonType &a, JsonType &b) {
   (void) b;
 }
 
-JsonType::JsonType(const JsonType& other32) noexcept {
-  (void) other32;
+JsonType::JsonType(const JsonType& other64) noexcept {
+  (void) other64;
 }
-JsonType& JsonType::operator=(const JsonType& other33) noexcept {
-  (void) other33;
+JsonType::JsonType(JsonType&& other65) noexcept {
+  (void) other65;
+}
+JsonType& JsonType::operator=(const JsonType& other66) noexcept {
+  (void) other66;
+  return *this;
+}
+JsonType& JsonType::operator=(JsonType&& other67) noexcept {
+  (void) other67;
   return *this;
 }
 void JsonType::printTo(std::ostream& out) const {
@@ -2219,11 +2364,18 @@ void swap(BsonType &a, BsonType &b) {
   (void) b;
 }
 
-BsonType::BsonType(const BsonType& other34) noexcept {
-  (void) other34;
+BsonType::BsonType(const BsonType& other68) noexcept {
+  (void) other68;
+}
+BsonType::BsonType(BsonType&& other69) noexcept {
+  (void) other69;
+}
+BsonType& BsonType::operator=(const BsonType& other70) noexcept {
+  (void) other70;
+  return *this;
 }
-BsonType& BsonType::operator=(const BsonType& other35) noexcept {
-  (void) other35;
+BsonType& BsonType::operator=(BsonType&& other71) noexcept {
+  (void) other71;
   return *this;
 }
 void BsonType::printTo(std::ostream& out) const {
@@ -2538,37 +2690,70 @@ void swap(LogicalType &a, LogicalType &b) {
   swap(a.__isset, b.__isset);
 }
 
-LogicalType::LogicalType(const LogicalType& other36) noexcept {
-  STRING = other36.STRING;
-  MAP = other36.MAP;
-  LIST = other36.LIST;
-  ENUM = other36.ENUM;
-  DECIMAL = other36.DECIMAL;
-  DATE = other36.DATE;
-  TIME = other36.TIME;
-  TIMESTAMP = other36.TIMESTAMP;
-  INTEGER = other36.INTEGER;
-  UNKNOWN = other36.UNKNOWN;
-  JSON = other36.JSON;
-  BSON = other36.BSON;
-  UUID = other36.UUID;
-  __isset = other36.__isset;
-}
-LogicalType& LogicalType::operator=(const LogicalType& other37) noexcept {
-  STRING = other37.STRING;
-  MAP = other37.MAP;
-  LIST = other37.LIST;
-  ENUM = other37.ENUM;
-  DECIMAL = other37.DECIMAL;
-  DATE = other37.DATE;
-  TIME = other37.TIME;
-  TIMESTAMP = other37.TIMESTAMP;
-  INTEGER = other37.INTEGER;
-  UNKNOWN = other37.UNKNOWN;
-  JSON = other37.JSON;
-  BSON = other37.BSON;
-  UUID = other37.UUID;
-  __isset = other37.__isset;
+LogicalType::LogicalType(const LogicalType& other72) noexcept {
+  STRING = other72.STRING;
+  MAP = other72.MAP;
+  LIST = other72.LIST;
+  ENUM = other72.ENUM;
+  DECIMAL = other72.DECIMAL;
+  DATE = other72.DATE;
+  TIME = other72.TIME;
+  TIMESTAMP = other72.TIMESTAMP;
+  INTEGER = other72.INTEGER;
+  UNKNOWN = other72.UNKNOWN;
+  JSON = other72.JSON;
+  BSON = other72.BSON;
+  UUID = other72.UUID;
+  __isset = other72.__isset;
+}
+LogicalType::LogicalType(LogicalType&& other73) noexcept {
+  STRING = std::move(other73.STRING);
+  MAP = std::move(other73.MAP);
+  LIST = std::move(other73.LIST);
+  ENUM = std::move(other73.ENUM);
+  DECIMAL = std::move(other73.DECIMAL);
+  DATE = std::move(other73.DATE);
+  TIME = std::move(other73.TIME);
+  TIMESTAMP = std::move(other73.TIMESTAMP);
+  INTEGER = std::move(other73.INTEGER);
+  UNKNOWN = std::move(other73.UNKNOWN);
+  JSON = std::move(other73.JSON);
+  BSON = std::move(other73.BSON);
+  UUID = std::move(other73.UUID);
+  __isset = other73.__isset;
+}
+LogicalType& LogicalType::operator=(const LogicalType& other74) noexcept {
+  STRING = other74.STRING;
+  MAP = other74.MAP;
+  LIST = other74.LIST;
+  ENUM = other74.ENUM;
+  DECIMAL = other74.DECIMAL;
+  DATE = other74.DATE;
+  TIME = other74.TIME;
+  TIMESTAMP = other74.TIMESTAMP;
+  INTEGER = other74.INTEGER;
+  UNKNOWN = other74.UNKNOWN;
+  JSON = other74.JSON;
+  BSON = other74.BSON;
+  UUID = other74.UUID;
+  __isset = other74.__isset;
+  return *this;
+}
+LogicalType& LogicalType::operator=(LogicalType&& other75) noexcept {
+  STRING = std::move(other75.STRING);
+  MAP = std::move(other75.MAP);
+  LIST = std::move(other75.LIST);
+  ENUM = std::move(other75.ENUM);
+  DECIMAL = std::move(other75.DECIMAL);
+  DATE = std::move(other75.DATE);
+  TIME = std::move(other75.TIME);
+  TIMESTAMP = std::move(other75.TIMESTAMP);
+  INTEGER = std::move(other75.INTEGER);
+  UNKNOWN = std::move(other75.UNKNOWN);
+  JSON = std::move(other75.JSON);
+  BSON = std::move(other75.BSON);
+  UUID = std::move(other75.UUID);
+  __isset = other75.__isset;
   return *this;
 }
 void LogicalType::printTo(std::ostream& out) const {
@@ -2674,9 +2859,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast38;
-          xfer += iprot->readI32(ecast38);
-          this->type = static_cast<Type::type>(ecast38);
+          int32_t ecast76;
+          xfer += iprot->readI32(ecast76);
+          this->type = static_cast<Type::type>(ecast76);
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2692,9 +2877,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast39;
-          xfer += iprot->readI32(ecast39);
-          this->repetition_type = static_cast<FieldRepetitionType::type>(ecast39);
+          int32_t ecast77;
+          xfer += iprot->readI32(ecast77);
+          this->repetition_type = static_cast<FieldRepetitionType::type>(ecast77);
           this->__isset.repetition_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2718,9 +2903,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast40;
-          xfer += iprot->readI32(ecast40);
-          this->converted_type = static_cast<ConvertedType::type>(ecast40);
+          int32_t ecast78;
+          xfer += iprot->readI32(ecast78);
+          this->converted_type = static_cast<ConvertedType::type>(ecast78);
           this->__isset.converted_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2846,31 +3031,58 @@ void swap(SchemaElement &a, SchemaElement &b) {
   swap(a.__isset, b.__isset);
 }
 
-SchemaElement::SchemaElement(const SchemaElement& other41) {
-  type = other41.type;
-  type_length = other41.type_length;
-  repetition_type = other41.repetition_type;
-  name = other41.name;
-  num_children = other41.num_children;
-  converted_type = other41.converted_type;
-  scale = other41.scale;
-  precision = other41.precision;
-  field_id = other41.field_id;
-  logicalType = other41.logicalType;
-  __isset = other41.__isset;
-}
-SchemaElement& SchemaElement::operator=(const SchemaElement& other42) {
-  type = other42.type;
-  type_length = other42.type_length;
-  repetition_type = other42.repetition_type;
-  name = other42.name;
-  num_children = other42.num_children;
-  converted_type = other42.converted_type;
-  scale = other42.scale;
-  precision = other42.precision;
-  field_id = other42.field_id;
-  logicalType = other42.logicalType;
-  __isset = other42.__isset;
+SchemaElement::SchemaElement(const SchemaElement& other79) {
+  type = other79.type;
+  type_length = other79.type_length;
+  repetition_type = other79.repetition_type;
+  name = other79.name;
+  num_children = other79.num_children;
+  converted_type = other79.converted_type;
+  scale = other79.scale;
+  precision = other79.precision;
+  field_id = other79.field_id;
+  logicalType = other79.logicalType;
+  __isset = other79.__isset;
+}
+SchemaElement::SchemaElement(SchemaElement&& other80) noexcept {
+  type = other80.type;
+  type_length = other80.type_length;
+  repetition_type = other80.repetition_type;
+  name = std::move(other80.name);
+  num_children = other80.num_children;
+  converted_type = other80.converted_type;
+  scale = other80.scale;
+  precision = other80.precision;
+  field_id = other80.field_id;
+  logicalType = std::move(other80.logicalType);
+  __isset = other80.__isset;
+}
+SchemaElement& SchemaElement::operator=(const SchemaElement& other81) {
+  type = other81.type;
+  type_length = other81.type_length;
+  repetition_type = other81.repetition_type;
+  name = other81.name;
+  num_children = other81.num_children;
+  converted_type = other81.converted_type;
+  scale = other81.scale;
+  precision = other81.precision;
+  field_id = other81.field_id;
+  logicalType = other81.logicalType;
+  __isset = other81.__isset;
+  return *this;
+}
+SchemaElement& SchemaElement::operator=(SchemaElement&& other82) noexcept {
+  type = other82.type;
+  type_length = other82.type_length;
+  repetition_type = other82.repetition_type;
+  name = std::move(other82.name);
+  num_children = other82.num_children;
+  converted_type = other82.converted_type;
+  scale = other82.scale;
+  precision = other82.precision;
+  field_id = other82.field_id;
+  logicalType = std::move(other82.logicalType);
+  __isset = other82.__isset;
   return *this;
 }
 void SchemaElement::printTo(std::ostream& out) const {
@@ -2956,9 +3168,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast43;
-          xfer += iprot->readI32(ecast43);
-          this->encoding = static_cast<Encoding::type>(ecast43);
+          int32_t ecast83;
+          xfer += iprot->readI32(ecast83);
+          this->encoding = static_cast<Encoding::type>(ecast83);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2966,9 +3178,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast44;
-          xfer += iprot->readI32(ecast44);
-          this->definition_level_encoding = static_cast<Encoding::type>(ecast44);
+          int32_t ecast84;
+          xfer += iprot->readI32(ecast84);
+          this->definition_level_encoding = static_cast<Encoding::type>(ecast84);
           isset_definition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2976,9 +3188,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast45;
-          xfer += iprot->readI32(ecast45);
-          this->repetition_level_encoding = static_cast<Encoding::type>(ecast45);
+          int32_t ecast85;
+          xfer += iprot->readI32(ecast85);
+          this->repetition_level_encoding = static_cast<Encoding::type>(ecast85);
           isset_repetition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3053,21 +3265,38 @@ void swap(DataPageHeader &a, DataPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeader::DataPageHeader(const DataPageHeader& other46) {
-  num_values = other46.num_values;
-  encoding = other46.encoding;
-  definition_level_encoding = other46.definition_level_encoding;
-  repetition_level_encoding = other46.repetition_level_encoding;
-  statistics = other46.statistics;
-  __isset = other46.__isset;
-}
-DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other47) {
-  num_values = other47.num_values;
-  encoding = other47.encoding;
-  definition_level_encoding = other47.definition_level_encoding;
-  repetition_level_encoding = other47.repetition_level_encoding;
-  statistics = other47.statistics;
-  __isset = other47.__isset;
+DataPageHeader::DataPageHeader(const DataPageHeader& other86) {
+  num_values = other86.num_values;
+  encoding = other86.encoding;
+  definition_level_encoding = other86.definition_level_encoding;
+  repetition_level_encoding = other86.repetition_level_encoding;
+  statistics = other86.statistics;
+  __isset = other86.__isset;
+}
+DataPageHeader::DataPageHeader(DataPageHeader&& other87) noexcept {
+  num_values = other87.num_values;
+  encoding = other87.encoding;
+  definition_level_encoding = other87.definition_level_encoding;
+  repetition_level_encoding = other87.repetition_level_encoding;
+  statistics = std::move(other87.statistics);
+  __isset = other87.__isset;
+}
+DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other88) {
+  num_values = other88.num_values;
+  encoding = other88.encoding;
+  definition_level_encoding = other88.definition_level_encoding;
+  repetition_level_encoding = other88.repetition_level_encoding;
+  statistics = other88.statistics;
+  __isset = other88.__isset;
+  return *this;
+}
+DataPageHeader& DataPageHeader::operator=(DataPageHeader&& other89) noexcept {
+  num_values = other89.num_values;
+  encoding = other89.encoding;
+  definition_level_encoding = other89.definition_level_encoding;
+  repetition_level_encoding = other89.repetition_level_encoding;
+  statistics = std::move(other89.statistics);
+  __isset = other89.__isset;
   return *this;
 }
 void DataPageHeader::printTo(std::ostream& out) const {
@@ -3136,11 +3365,18 @@ void swap(IndexPageHeader &a, IndexPageHeader &b) {
   (void) b;
 }
 
-IndexPageHeader::IndexPageHeader(const IndexPageHeader& other48) noexcept {
-  (void) other48;
+IndexPageHeader::IndexPageHeader(const IndexPageHeader& other90) noexcept {
+  (void) other90;
+}
+IndexPageHeader::IndexPageHeader(IndexPageHeader&& other91) noexcept {
+  (void) other91;
+}
+IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other92) noexcept {
+  (void) other92;
+  return *this;
 }
-IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other49) noexcept {
-  (void) other49;
+IndexPageHeader& IndexPageHeader::operator=(IndexPageHeader&& other93) noexcept {
+  (void) other93;
   return *this;
 }
 void IndexPageHeader::printTo(std::ostream& out) const {
@@ -3206,9 +3442,9 @@ uint32_t DictionaryPageHeader::read(::apache::thrift::protocol::TProtocol* iprot
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast50;
-          xfer += iprot->readI32(ecast50);
-          this->encoding = static_cast<Encoding::type>(ecast50);
+          int32_t ecast94;
+          xfer += iprot->readI32(ecast94);
+          this->encoding = static_cast<Encoding::type>(ecast94);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3269,17 +3505,30 @@ void swap(DictionaryPageHeader &a, DictionaryPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other51) noexcept {
-  num_values = other51.num_values;
-  encoding = other51.encoding;
-  is_sorted = other51.is_sorted;
-  __isset = other51.__isset;
+DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other95) noexcept {
+  num_values = other95.num_values;
+  encoding = other95.encoding;
+  is_sorted = other95.is_sorted;
+  __isset = other95.__isset;
+}
+DictionaryPageHeader::DictionaryPageHeader(DictionaryPageHeader&& other96) noexcept {
+  num_values = other96.num_values;
+  encoding = other96.encoding;
+  is_sorted = other96.is_sorted;
+  __isset = other96.__isset;
+}
+DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other97) noexcept {
+  num_values = other97.num_values;
+  encoding = other97.encoding;
+  is_sorted = other97.is_sorted;
+  __isset = other97.__isset;
+  return *this;
 }
-DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other52) noexcept {
-  num_values = other52.num_values;
-  encoding = other52.encoding;
-  is_sorted = other52.is_sorted;
-  __isset = other52.__isset;
+DictionaryPageHeader& DictionaryPageHeader::operator=(DictionaryPageHeader&& other98) noexcept {
+  num_values = other98.num_values;
+  encoding = other98.encoding;
+  is_sorted = other98.is_sorted;
+  __isset = other98.__isset;
   return *this;
 }
 void DictionaryPageHeader::printTo(std::ostream& out) const {
@@ -3389,9 +3638,9 @@ uint32_t DataPageHeaderV2::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast53;
-          xfer += iprot->readI32(ecast53);
-          this->encoding = static_cast<Encoding::type>(ecast53);
+          int32_t ecast99;
+          xfer += iprot->readI32(ecast99);
+          this->encoding = static_cast<Encoding::type>(ecast99);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3510,27 +3759,50 @@ void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other54) {
-  num_values = other54.num_values;
-  num_nulls = other54.num_nulls;
-  num_rows = other54.num_rows;
-  encoding = other54.encoding;
-  definition_levels_byte_length = other54.definition_levels_byte_length;
-  repetition_levels_byte_length = other54.repetition_levels_byte_length;
-  is_compressed = other54.is_compressed;
-  statistics = other54.statistics;
-  __isset = other54.__isset;
-}
-DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other55) {
-  num_values = other55.num_values;
-  num_nulls = other55.num_nulls;
-  num_rows = other55.num_rows;
-  encoding = other55.encoding;
-  definition_levels_byte_length = other55.definition_levels_byte_length;
-  repetition_levels_byte_length = other55.repetition_levels_byte_length;
-  is_compressed = other55.is_compressed;
-  statistics = other55.statistics;
-  __isset = other55.__isset;
+DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other100) {
+  num_values = other100.num_values;
+  num_nulls = other100.num_nulls;
+  num_rows = other100.num_rows;
+  encoding = other100.encoding;
+  definition_levels_byte_length = other100.definition_levels_byte_length;
+  repetition_levels_byte_length = other100.repetition_levels_byte_length;
+  is_compressed = other100.is_compressed;
+  statistics = other100.statistics;
+  __isset = other100.__isset;
+}
+DataPageHeaderV2::DataPageHeaderV2(DataPageHeaderV2&& other101) noexcept {
+  num_values = other101.num_values;
+  num_nulls = other101.num_nulls;
+  num_rows = other101.num_rows;
+  encoding = other101.encoding;
+  definition_levels_byte_length = other101.definition_levels_byte_length;
+  repetition_levels_byte_length = other101.repetition_levels_byte_length;
+  is_compressed = other101.is_compressed;
+  statistics = std::move(other101.statistics);
+  __isset = other101.__isset;
+}
+DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other102) {
+  num_values = other102.num_values;
+  num_nulls = other102.num_nulls;
+  num_rows = other102.num_rows;
+  encoding = other102.encoding;
+  definition_levels_byte_length = other102.definition_levels_byte_length;
+  repetition_levels_byte_length = other102.repetition_levels_byte_length;
+  is_compressed = other102.is_compressed;
+  statistics = other102.statistics;
+  __isset = other102.__isset;
+  return *this;
+}
+DataPageHeaderV2& DataPageHeaderV2::operator=(DataPageHeaderV2&& other103) noexcept {
+  num_values = other103.num_values;
+  num_nulls = other103.num_nulls;
+  num_rows = other103.num_rows;
+  encoding = other103.encoding;
+  definition_levels_byte_length = other103.definition_levels_byte_length;
+  repetition_levels_byte_length = other103.repetition_levels_byte_length;
+  is_compressed = other103.is_compressed;
+  statistics = std::move(other103.statistics);
+  __isset = other103.__isset;
   return *this;
 }
 void DataPageHeaderV2::printTo(std::ostream& out) const {
@@ -3602,11 +3874,18 @@ void swap(SplitBlockAlgorithm &a, SplitBlockAlgorithm &b) {
   (void) b;
 }
 
-SplitBlockAlgorithm::SplitBlockAlgorithm(const SplitBlockAlgorithm& other56) noexcept {
-  (void) other56;
+SplitBlockAlgorithm::SplitBlockAlgorithm(const SplitBlockAlgorithm& other104) noexcept {
+  (void) other104;
+}
+SplitBlockAlgorithm::SplitBlockAlgorithm(SplitBlockAlgorithm&& other105) noexcept {
+  (void) other105;
 }
-SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(const SplitBlockAlgorithm& other57) noexcept {
-  (void) other57;
+SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(const SplitBlockAlgorithm& other106) noexcept {
+  (void) other106;
+  return *this;
+}
+SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(SplitBlockAlgorithm&& other107) noexcept {
+  (void) other107;
   return *this;
 }
 void SplitBlockAlgorithm::printTo(std::ostream& out) const {
@@ -3693,13 +3972,22 @@ void swap(BloomFilterAlgorithm &a, BloomFilterAlgorithm &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterAlgorithm::BloomFilterAlgorithm(const BloomFilterAlgorithm& other58) noexcept {
-  BLOCK = other58.BLOCK;
-  __isset = other58.__isset;
+BloomFilterAlgorithm::BloomFilterAlgorithm(const BloomFilterAlgorithm& other108) noexcept {
+  BLOCK = other108.BLOCK;
+  __isset = other108.__isset;
+}
+BloomFilterAlgorithm::BloomFilterAlgorithm(BloomFilterAlgorithm&& other109) noexcept {
+  BLOCK = std::move(other109.BLOCK);
+  __isset = other109.__isset;
+}
+BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(const BloomFilterAlgorithm& other110) noexcept {
+  BLOCK = other110.BLOCK;
+  __isset = other110.__isset;
+  return *this;
 }
-BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(const BloomFilterAlgorithm& other59) noexcept {
-  BLOCK = other59.BLOCK;
-  __isset = other59.__isset;
+BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(BloomFilterAlgorithm&& other111) noexcept {
+  BLOCK = std::move(other111.BLOCK);
+  __isset = other111.__isset;
   return *this;
 }
 void BloomFilterAlgorithm::printTo(std::ostream& out) const {
@@ -3764,11 +4052,18 @@ void swap(XxHash &a, XxHash &b) {
   (void) b;
 }
 
-XxHash::XxHash(const XxHash& other60) noexcept {
-  (void) other60;
+XxHash::XxHash(const XxHash& other112) noexcept {
+  (void) other112;
+}
+XxHash::XxHash(XxHash&& other113) noexcept {
+  (void) other113;
 }
-XxHash& XxHash::operator=(const XxHash& other61) noexcept {
-  (void) other61;
+XxHash& XxHash::operator=(const XxHash& other114) noexcept {
+  (void) other114;
+  return *this;
+}
+XxHash& XxHash::operator=(XxHash&& other115) noexcept {
+  (void) other115;
   return *this;
 }
 void XxHash::printTo(std::ostream& out) const {
@@ -3855,13 +4150,22 @@ void swap(BloomFilterHash &a, BloomFilterHash &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterHash::BloomFilterHash(const BloomFilterHash& other62) noexcept {
-  XXHASH = other62.XXHASH;
-  __isset = other62.__isset;
+BloomFilterHash::BloomFilterHash(const BloomFilterHash& other116) noexcept {
+  XXHASH = other116.XXHASH;
+  __isset = other116.__isset;
 }
-BloomFilterHash& BloomFilterHash::operator=(const BloomFilterHash& other63) noexcept {
-  XXHASH = other63.XXHASH;
-  __isset = other63.__isset;
+BloomFilterHash::BloomFilterHash(BloomFilterHash&& other117) noexcept {
+  XXHASH = std::move(other117.XXHASH);
+  __isset = other117.__isset;
+}
+BloomFilterHash& BloomFilterHash::operator=(const BloomFilterHash& other118) noexcept {
+  XXHASH = other118.XXHASH;
+  __isset = other118.__isset;
+  return *this;
+}
+BloomFilterHash& BloomFilterHash::operator=(BloomFilterHash&& other119) noexcept {
+  XXHASH = std::move(other119.XXHASH);
+  __isset = other119.__isset;
   return *this;
 }
 void BloomFilterHash::printTo(std::ostream& out) const {
@@ -3926,11 +4230,18 @@ void swap(Uncompressed &a, Uncompressed &b) {
   (void) b;
 }
 
-Uncompressed::Uncompressed(const Uncompressed& other64) noexcept {
-  (void) other64;
+Uncompressed::Uncompressed(const Uncompressed& other120) noexcept {
+  (void) other120;
 }
-Uncompressed& Uncompressed::operator=(const Uncompressed& other65) noexcept {
-  (void) other65;
+Uncompressed::Uncompressed(Uncompressed&& other121) noexcept {
+  (void) other121;
+}
+Uncompressed& Uncompressed::operator=(const Uncompressed& other122) noexcept {
+  (void) other122;
+  return *this;
+}
+Uncompressed& Uncompressed::operator=(Uncompressed&& other123) noexcept {
+  (void) other123;
   return *this;
 }
 void Uncompressed::printTo(std::ostream& out) const {
@@ -4017,13 +4328,22 @@ void swap(BloomFilterCompression &a, BloomFilterCompression &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterCompression::BloomFilterCompression(const BloomFilterCompression& other66) noexcept {
-  UNCOMPRESSED = other66.UNCOMPRESSED;
-  __isset = other66.__isset;
+BloomFilterCompression::BloomFilterCompression(const BloomFilterCompression& other124) noexcept {
+  UNCOMPRESSED = other124.UNCOMPRESSED;
+  __isset = other124.__isset;
+}
+BloomFilterCompression::BloomFilterCompression(BloomFilterCompression&& other125) noexcept {
+  UNCOMPRESSED = std::move(other125.UNCOMPRESSED);
+  __isset = other125.__isset;
+}
+BloomFilterCompression& BloomFilterCompression::operator=(const BloomFilterCompression& other126) noexcept {
+  UNCOMPRESSED = other126.UNCOMPRESSED;
+  __isset = other126.__isset;
+  return *this;
 }
-BloomFilterCompression& BloomFilterCompression::operator=(const BloomFilterCompression& other67) noexcept {
-  UNCOMPRESSED = other67.UNCOMPRESSED;
-  __isset = other67.__isset;
+BloomFilterCompression& BloomFilterCompression::operator=(BloomFilterCompression&& other127) noexcept {
+  UNCOMPRESSED = std::move(other127.UNCOMPRESSED);
+  __isset = other127.__isset;
   return *this;
 }
 void BloomFilterCompression::printTo(std::ostream& out) const {
@@ -4171,17 +4491,30 @@ void swap(BloomFilterHeader &a, BloomFilterHeader &b) {
   swap(a.compression, b.compression);
 }
 
-BloomFilterHeader::BloomFilterHeader(const BloomFilterHeader& other68) noexcept {
-  numBytes = other68.numBytes;
-  algorithm = other68.algorithm;
-  hash = other68.hash;
-  compression = other68.compression;
+BloomFilterHeader::BloomFilterHeader(const BloomFilterHeader& other128) noexcept {
+  numBytes = other128.numBytes;
+  algorithm = other128.algorithm;
+  hash = other128.hash;
+  compression = other128.compression;
 }
-BloomFilterHeader& BloomFilterHeader::operator=(const BloomFilterHeader& other69) noexcept {
-  numBytes = other69.numBytes;
-  algorithm = other69.algorithm;
-  hash = other69.hash;
-  compression = other69.compression;
+BloomFilterHeader::BloomFilterHeader(BloomFilterHeader&& other129) noexcept {
+  numBytes = other129.numBytes;
+  algorithm = std::move(other129.algorithm);
+  hash = std::move(other129.hash);
+  compression = std::move(other129.compression);
+}
+BloomFilterHeader& BloomFilterHeader::operator=(const BloomFilterHeader& other130) noexcept {
+  numBytes = other130.numBytes;
+  algorithm = other130.algorithm;
+  hash = other130.hash;
+  compression = other130.compression;
+  return *this;
+}
+BloomFilterHeader& BloomFilterHeader::operator=(BloomFilterHeader&& other131) noexcept {
+  numBytes = other131.numBytes;
+  algorithm = std::move(other131.algorithm);
+  hash = std::move(other131.hash);
+  compression = std::move(other131.compression);
   return *this;
 }
 void BloomFilterHeader::printTo(std::ostream& out) const {
@@ -4268,9 +4601,9 @@ uint32_t PageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast70;
-          xfer += iprot->readI32(ecast70);
-          this->type = static_cast<PageType::type>(ecast70);
+          int32_t ecast132;
+          xfer += iprot->readI32(ecast132);
+          this->type = static_cast<PageType::type>(ecast132);
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4410,27 +4743,50 @@ void swap(PageHeader &a, PageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-PageHeader::PageHeader(const PageHeader& other71) {
-  type = other71.type;
-  uncompressed_page_size = other71.uncompressed_page_size;
-  compressed_page_size = other71.compressed_page_size;
-  crc = other71.crc;
-  data_page_header = other71.data_page_header;
-  index_page_header = other71.index_page_header;
-  dictionary_page_header = other71.dictionary_page_header;
-  data_page_header_v2 = other71.data_page_header_v2;
-  __isset = other71.__isset;
-}
-PageHeader& PageHeader::operator=(const PageHeader& other72) {
-  type = other72.type;
-  uncompressed_page_size = other72.uncompressed_page_size;
-  compressed_page_size = other72.compressed_page_size;
-  crc = other72.crc;
-  data_page_header = other72.data_page_header;
-  index_page_header = other72.index_page_header;
-  dictionary_page_header = other72.dictionary_page_header;
-  data_page_header_v2 = other72.data_page_header_v2;
-  __isset = other72.__isset;
+PageHeader::PageHeader(const PageHeader& other133) {
+  type = other133.type;
+  uncompressed_page_size = other133.uncompressed_page_size;
+  compressed_page_size = other133.compressed_page_size;
+  crc = other133.crc;
+  data_page_header = other133.data_page_header;
+  index_page_header = other133.index_page_header;
+  dictionary_page_header = other133.dictionary_page_header;
+  data_page_header_v2 = other133.data_page_header_v2;
+  __isset = other133.__isset;
+}
+PageHeader::PageHeader(PageHeader&& other134) noexcept {
+  type = other134.type;
+  uncompressed_page_size = other134.uncompressed_page_size;
+  compressed_page_size = other134.compressed_page_size;
+  crc = other134.crc;
+  data_page_header = std::move(other134.data_page_header);
+  index_page_header = std::move(other134.index_page_header);
+  dictionary_page_header = std::move(other134.dictionary_page_header);
+  data_page_header_v2 = std::move(other134.data_page_header_v2);
+  __isset = other134.__isset;
+}
+PageHeader& PageHeader::operator=(const PageHeader& other135) {
+  type = other135.type;
+  uncompressed_page_size = other135.uncompressed_page_size;
+  compressed_page_size = other135.compressed_page_size;
+  crc = other135.crc;
+  data_page_header = other135.data_page_header;
+  index_page_header = other135.index_page_header;
+  dictionary_page_header = other135.dictionary_page_header;
+  data_page_header_v2 = other135.data_page_header_v2;
+  __isset = other135.__isset;
+  return *this;
+}
+PageHeader& PageHeader::operator=(PageHeader&& other136) noexcept {
+  type = other136.type;
+  uncompressed_page_size = other136.uncompressed_page_size;
+  compressed_page_size = other136.compressed_page_size;
+  crc = other136.crc;
+  data_page_header = std::move(other136.data_page_header);
+  index_page_header = std::move(other136.index_page_header);
+  dictionary_page_header = std::move(other136.dictionary_page_header);
+  data_page_header_v2 = std::move(other136.data_page_header_v2);
+  __isset = other136.__isset;
   return *this;
 }
 void PageHeader::printTo(std::ostream& out) const {
@@ -4545,15 +4901,26 @@ void swap(KeyValue &a, KeyValue &b) {
   swap(a.__isset, b.__isset);
 }
 
-KeyValue::KeyValue(const KeyValue& other73) {
-  key = other73.key;
-  value = other73.value;
-  __isset = other73.__isset;
+KeyValue::KeyValue(const KeyValue& other137) {
+  key = other137.key;
+  value = other137.value;
+  __isset = other137.__isset;
 }
-KeyValue& KeyValue::operator=(const KeyValue& other74) {
-  key = other74.key;
-  value = other74.value;
-  __isset = other74.__isset;
+KeyValue::KeyValue(KeyValue&& other138) noexcept {
+  key = std::move(other138.key);
+  value = std::move(other138.value);
+  __isset = other138.__isset;
+}
+KeyValue& KeyValue::operator=(const KeyValue& other139) {
+  key = other139.key;
+  value = other139.value;
+  __isset = other139.__isset;
+  return *this;
+}
+KeyValue& KeyValue::operator=(KeyValue&& other140) noexcept {
+  key = std::move(other140.key);
+  value = std::move(other140.value);
+  __isset = other140.__isset;
   return *this;
 }
 void KeyValue::printTo(std::ostream& out) const {
@@ -4682,15 +5049,26 @@ void swap(SortingColumn &a, SortingColumn &b) {
   swap(a.nulls_first, b.nulls_first);
 }
 
-SortingColumn::SortingColumn(const SortingColumn& other75) noexcept {
-  column_idx = other75.column_idx;
-  descending = other75.descending;
-  nulls_first = other75.nulls_first;
+SortingColumn::SortingColumn(const SortingColumn& other141) noexcept {
+  column_idx = other141.column_idx;
+  descending = other141.descending;
+  nulls_first = other141.nulls_first;
+}
+SortingColumn::SortingColumn(SortingColumn&& other142) noexcept {
+  column_idx = other142.column_idx;
+  descending = other142.descending;
+  nulls_first = other142.nulls_first;
 }
-SortingColumn& SortingColumn::operator=(const SortingColumn& other76) noexcept {
-  column_idx = other76.column_idx;
-  descending = other76.descending;
-  nulls_first = other76.nulls_first;
+SortingColumn& SortingColumn::operator=(const SortingColumn& other143) noexcept {
+  column_idx = other143.column_idx;
+  descending = other143.descending;
+  nulls_first = other143.nulls_first;
+  return *this;
+}
+SortingColumn& SortingColumn::operator=(SortingColumn&& other144) noexcept {
+  column_idx = other144.column_idx;
+  descending = other144.descending;
+  nulls_first = other144.nulls_first;
   return *this;
 }
 void SortingColumn::printTo(std::ostream& out) const {
@@ -4751,9 +5129,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast77;
-          xfer += iprot->readI32(ecast77);
-          this->page_type = static_cast<PageType::type>(ecast77);
+          int32_t ecast145;
+          xfer += iprot->readI32(ecast145);
+          this->page_type = static_cast<PageType::type>(ecast145);
           isset_page_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4761,9 +5139,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast78;
-          xfer += iprot->readI32(ecast78);
-          this->encoding = static_cast<Encoding::type>(ecast78);
+          int32_t ecast146;
+          xfer += iprot->readI32(ecast146);
+          this->encoding = static_cast<Encoding::type>(ecast146);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4824,15 +5202,26 @@ void swap(PageEncodingStats &a, PageEncodingStats &b) {
   swap(a.count, b.count);
 }
 
-PageEncodingStats::PageEncodingStats(const PageEncodingStats& other79) noexcept {
-  page_type = other79.page_type;
-  encoding = other79.encoding;
-  count = other79.count;
+PageEncodingStats::PageEncodingStats(const PageEncodingStats& other147) noexcept {
+  page_type = other147.page_type;
+  encoding = other147.encoding;
+  count = other147.count;
+}
+PageEncodingStats::PageEncodingStats(PageEncodingStats&& other148) noexcept {
+  page_type = other148.page_type;
+  encoding = other148.encoding;
+  count = other148.count;
 }
-PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other80) noexcept {
-  page_type = other80.page_type;
-  encoding = other80.encoding;
-  count = other80.count;
+PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other149) noexcept {
+  page_type = other149.page_type;
+  encoding = other149.encoding;
+  count = other149.count;
+  return *this;
+}
+PageEncodingStats& PageEncodingStats::operator=(PageEncodingStats&& other150) noexcept {
+  page_type = other150.page_type;
+  encoding = other150.encoding;
+  count = other150.count;
   return *this;
 }
 void PageEncodingStats::printTo(std::ostream& out) const {
@@ -4948,9 +5337,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast81;
-          xfer += iprot->readI32(ecast81);
-          this->type = static_cast<Type::type>(ecast81);
+          int32_t ecast151;
+          xfer += iprot->readI32(ecast151);
+          this->type = static_cast<Type::type>(ecast151);
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4960,16 +5349,16 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encodings.clear();
-            uint32_t _size82;
-            ::apache::thrift::protocol::TType _etype85;
-            xfer += iprot->readListBegin(_etype85, _size82);
-            this->encodings.resize(_size82);
-            uint32_t _i86;
-            for (_i86 = 0; _i86 < _size82; ++_i86)
+            uint32_t _size152;
+            ::apache::thrift::protocol::TType _etype155;
+            xfer += iprot->readListBegin(_etype155, _size152);
+            this->encodings.resize(_size152);
+            uint32_t _i156;
+            for (_i156 = 0; _i156 < _size152; ++_i156)
             {
-              int32_t ecast87;
-              xfer += iprot->readI32(ecast87);
-              this->encodings[_i86] = static_cast<Encoding::type>(ecast87);
+              int32_t ecast157;
+              xfer += iprot->readI32(ecast157);
+              this->encodings[_i156] = static_cast<Encoding::type>(ecast157);
             }
             xfer += iprot->readListEnd();
           }
@@ -4982,14 +5371,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size88;
-            ::apache::thrift::protocol::TType _etype91;
-            xfer += iprot->readListBegin(_etype91, _size88);
-            this->path_in_schema.resize(_size88);
-            uint32_t _i92;
-            for (_i92 = 0; _i92 < _size88; ++_i92)
+            uint32_t _size158;
+            ::apache::thrift::protocol::TType _etype161;
+            xfer += iprot->readListBegin(_etype161, _size158);
+            this->path_in_schema.resize(_size158);
+            uint32_t _i162;
+            for (_i162 = 0; _i162 < _size158; ++_i162)
             {
-              xfer += iprot->readString(this->path_in_schema[_i92]);
+              xfer += iprot->readString(this->path_in_schema[_i162]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5000,9 +5389,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast93;
-          xfer += iprot->readI32(ecast93);
-          this->codec = static_cast<CompressionCodec::type>(ecast93);
+          int32_t ecast163;
+          xfer += iprot->readI32(ecast163);
+          this->codec = static_cast<CompressionCodec::type>(ecast163);
           isset_codec = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5036,14 +5425,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->key_value_metadata.clear();
-            uint32_t _size94;
-            ::apache::thrift::protocol::TType _etype97;
-            xfer += iprot->readListBegin(_etype97, _size94);
-            this->key_value_metadata.resize(_size94);
-            uint32_t _i98;
-            for (_i98 = 0; _i98 < _size94; ++_i98)
+            uint32_t _size164;
+            ::apache::thrift::protocol::TType _etype167;
+            xfer += iprot->readListBegin(_etype167, _size164);
+            this->key_value_metadata.resize(_size164);
+            uint32_t _i168;
+            for (_i168 = 0; _i168 < _size164; ++_i168)
             {
-              xfer += this->key_value_metadata[_i98].read(iprot);
+              xfer += this->key_value_metadata[_i168].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5088,14 +5477,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encoding_stats.clear();
-            uint32_t _size99;
-            ::apache::thrift::protocol::TType _etype102;
-            xfer += iprot->readListBegin(_etype102, _size99);
-            this->encoding_stats.resize(_size99);
-            uint32_t _i103;
-            for (_i103 = 0; _i103 < _size99; ++_i103)
+            uint32_t _size169;
+            ::apache::thrift::protocol::TType _etype172;
+            xfer += iprot->readListBegin(_etype172, _size169);
+            this->encoding_stats.resize(_size169);
+            uint32_t _i173;
+            for (_i173 = 0; _i173 < _size169; ++_i173)
             {
-              xfer += this->encoding_stats[_i103].read(iprot);
+              xfer += this->encoding_stats[_i173].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5152,10 +5541,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("encodings", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    std::vector<Encoding::type> ::const_iterator _iter104;
-    for (_iter104 = this->encodings.begin(); _iter104 != this->encodings.end(); ++_iter104)
+    std::vector<Encoding::type> ::const_iterator _iter174;
+    for (_iter174 = this->encodings.begin(); _iter174 != this->encodings.end(); ++_iter174)
     {
-      xfer += oprot->writeI32(static_cast<int32_t>((*_iter104)));
+      xfer += oprot->writeI32(static_cast<int32_t>((*_iter174)));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5164,10 +5553,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter105;
-    for (_iter105 = this->path_in_schema.begin(); _iter105 != this->path_in_schema.end(); ++_iter105)
+    std::vector<std::string> ::const_iterator _iter175;
+    for (_iter175 = this->path_in_schema.begin(); _iter175 != this->path_in_schema.end(); ++_iter175)
     {
-      xfer += oprot->writeString((*_iter105));
+      xfer += oprot->writeString((*_iter175));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5193,10 +5582,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 8);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter106;
-      for (_iter106 = this->key_value_metadata.begin(); _iter106 != this->key_value_metadata.end(); ++_iter106)
+      std::vector<KeyValue> ::const_iterator _iter176;
+      for (_iter176 = this->key_value_metadata.begin(); _iter176 != this->key_value_metadata.end(); ++_iter176)
       {
-        xfer += (*_iter106).write(oprot);
+        xfer += (*_iter176).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -5225,10 +5614,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("encoding_stats", ::apache::thrift::protocol::T_LIST, 13);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->encoding_stats.size()));
-      std::vector<PageEncodingStats> ::const_iterator _iter107;
-      for (_iter107 = this->encoding_stats.begin(); _iter107 != this->encoding_stats.end(); ++_iter107)
+      std::vector<PageEncodingStats> ::const_iterator _iter177;
+      for (_iter177 = this->encoding_stats.begin(); _iter177 != this->encoding_stats.end(); ++_iter177)
       {
-        xfer += (*_iter107).write(oprot);
+        xfer += (*_iter177).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -5263,39 +5652,74 @@ void swap(ColumnMetaData &a, ColumnMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnMetaData::ColumnMetaData(const ColumnMetaData& other108) {
-  type = other108.type;
-  encodings = other108.encodings;
-  path_in_schema = other108.path_in_schema;
-  codec = other108.codec;
-  num_values = other108.num_values;
-  total_uncompressed_size = other108.total_uncompressed_size;
-  total_compressed_size = other108.total_compressed_size;
-  key_value_metadata = other108.key_value_metadata;
-  data_page_offset = other108.data_page_offset;
-  index_page_offset = other108.index_page_offset;
-  dictionary_page_offset = other108.dictionary_page_offset;
-  statistics = other108.statistics;
-  encoding_stats = other108.encoding_stats;
-  bloom_filter_offset = other108.bloom_filter_offset;
-  __isset = other108.__isset;
+ColumnMetaData::ColumnMetaData(const ColumnMetaData& other178) {
+  type = other178.type;
+  encodings = other178.encodings;
+  path_in_schema = other178.path_in_schema;
+  codec = other178.codec;
+  num_values = other178.num_values;
+  total_uncompressed_size = other178.total_uncompressed_size;
+  total_compressed_size = other178.total_compressed_size;
+  key_value_metadata = other178.key_value_metadata;
+  data_page_offset = other178.data_page_offset;
+  index_page_offset = other178.index_page_offset;
+  dictionary_page_offset = other178.dictionary_page_offset;
+  statistics = other178.statistics;
+  encoding_stats = other178.encoding_stats;
+  bloom_filter_offset = other178.bloom_filter_offset;
+  __isset = other178.__isset;
 }
-ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other109) {
-  type = other109.type;
-  encodings = other109.encodings;
-  path_in_schema = other109.path_in_schema;
-  codec = other109.codec;
-  num_values = other109.num_values;
-  total_uncompressed_size = other109.total_uncompressed_size;
-  total_compressed_size = other109.total_compressed_size;
-  key_value_metadata = other109.key_value_metadata;
-  data_page_offset = other109.data_page_offset;
-  index_page_offset = other109.index_page_offset;
-  dictionary_page_offset = other109.dictionary_page_offset;
-  statistics = other109.statistics;
-  encoding_stats = other109.encoding_stats;
-  bloom_filter_offset = other109.bloom_filter_offset;
-  __isset = other109.__isset;
+ColumnMetaData::ColumnMetaData(ColumnMetaData&& other179) noexcept {
+  type = other179.type;
+  encodings = std::move(other179.encodings);
+  path_in_schema = std::move(other179.path_in_schema);
+  codec = other179.codec;
+  num_values = other179.num_values;
+  total_uncompressed_size = other179.total_uncompressed_size;
+  total_compressed_size = other179.total_compressed_size;
+  key_value_metadata = std::move(other179.key_value_metadata);
+  data_page_offset = other179.data_page_offset;
+  index_page_offset = other179.index_page_offset;
+  dictionary_page_offset = other179.dictionary_page_offset;
+  statistics = std::move(other179.statistics);
+  encoding_stats = std::move(other179.encoding_stats);
+  bloom_filter_offset = other179.bloom_filter_offset;
+  __isset = other179.__isset;
+}
+ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other180) {
+  type = other180.type;
+  encodings = other180.encodings;
+  path_in_schema = other180.path_in_schema;
+  codec = other180.codec;
+  num_values = other180.num_values;
+  total_uncompressed_size = other180.total_uncompressed_size;
+  total_compressed_size = other180.total_compressed_size;
+  key_value_metadata = other180.key_value_metadata;
+  data_page_offset = other180.data_page_offset;
+  index_page_offset = other180.index_page_offset;
+  dictionary_page_offset = other180.dictionary_page_offset;
+  statistics = other180.statistics;
+  encoding_stats = other180.encoding_stats;
+  bloom_filter_offset = other180.bloom_filter_offset;
+  __isset = other180.__isset;
+  return *this;
+}
+ColumnMetaData& ColumnMetaData::operator=(ColumnMetaData&& other181) noexcept {
+  type = other181.type;
+  encodings = std::move(other181.encodings);
+  path_in_schema = std::move(other181.path_in_schema);
+  codec = other181.codec;
+  num_values = other181.num_values;
+  total_uncompressed_size = other181.total_uncompressed_size;
+  total_compressed_size = other181.total_compressed_size;
+  key_value_metadata = std::move(other181.key_value_metadata);
+  data_page_offset = other181.data_page_offset;
+  index_page_offset = other181.index_page_offset;
+  dictionary_page_offset = other181.dictionary_page_offset;
+  statistics = std::move(other181.statistics);
+  encoding_stats = std::move(other181.encoding_stats);
+  bloom_filter_offset = other181.bloom_filter_offset;
+  __isset = other181.__isset;
   return *this;
 }
 void ColumnMetaData::printTo(std::ostream& out) const {
@@ -5373,11 +5797,18 @@ void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b) {
   (void) b;
 }
 
-EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other110) noexcept {
-  (void) other110;
+EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other182) noexcept {
+  (void) other182;
+}
+EncryptionWithFooterKey::EncryptionWithFooterKey(EncryptionWithFooterKey&& other183) noexcept {
+  (void) other183;
 }
-EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other111) noexcept {
-  (void) other111;
+EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other184) noexcept {
+  (void) other184;
+  return *this;
+}
+EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(EncryptionWithFooterKey&& other185) noexcept {
+  (void) other185;
   return *this;
 }
 void EncryptionWithFooterKey::printTo(std::ostream& out) const {
@@ -5432,14 +5863,14 @@ uint32_t EncryptionWithColumnKey::read(::apache::thrift::protocol::TProtocol* ip
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size112;
-            ::apache::thrift::protocol::TType _etype115;
-            xfer += iprot->readListBegin(_etype115, _size112);
-            this->path_in_schema.resize(_size112);
-            uint32_t _i116;
-            for (_i116 = 0; _i116 < _size112; ++_i116)
+            uint32_t _size186;
+            ::apache::thrift::protocol::TType _etype189;
+            xfer += iprot->readListBegin(_etype189, _size186);
+            this->path_in_schema.resize(_size186);
+            uint32_t _i190;
+            for (_i190 = 0; _i190 < _size186; ++_i190)
             {
-              xfer += iprot->readString(this->path_in_schema[_i116]);
+              xfer += iprot->readString(this->path_in_schema[_i190]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5478,10 +5909,10 @@ uint32_t EncryptionWithColumnKey::write(::apache::thrift::protocol::TProtocol* o
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter117;
-    for (_iter117 = this->path_in_schema.begin(); _iter117 != this->path_in_schema.end(); ++_iter117)
+    std::vector<std::string> ::const_iterator _iter191;
+    for (_iter191 = this->path_in_schema.begin(); _iter191 != this->path_in_schema.end(); ++_iter191)
     {
-      xfer += oprot->writeString((*_iter117));
+      xfer += oprot->writeString((*_iter191));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5504,15 +5935,26 @@ void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b) {
   swap(a.__isset, b.__isset);
 }
 
-EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other118) {
-  path_in_schema = other118.path_in_schema;
-  key_metadata = other118.key_metadata;
-  __isset = other118.__isset;
+EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other192) {
+  path_in_schema = other192.path_in_schema;
+  key_metadata = other192.key_metadata;
+  __isset = other192.__isset;
 }
-EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other119) {
-  path_in_schema = other119.path_in_schema;
-  key_metadata = other119.key_metadata;
-  __isset = other119.__isset;
+EncryptionWithColumnKey::EncryptionWithColumnKey(EncryptionWithColumnKey&& other193) noexcept {
+  path_in_schema = std::move(other193.path_in_schema);
+  key_metadata = std::move(other193.key_metadata);
+  __isset = other193.__isset;
+}
+EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other194) {
+  path_in_schema = other194.path_in_schema;
+  key_metadata = other194.key_metadata;
+  __isset = other194.__isset;
+  return *this;
+}
+EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(EncryptionWithColumnKey&& other195) noexcept {
+  path_in_schema = std::move(other195.path_in_schema);
+  key_metadata = std::move(other195.key_metadata);
+  __isset = other195.__isset;
   return *this;
 }
 void EncryptionWithColumnKey::printTo(std::ostream& out) const {
@@ -5620,15 +6062,26 @@ void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other120) {
-  ENCRYPTION_WITH_FOOTER_KEY = other120.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other120.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other120.__isset;
+ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other196) {
+  ENCRYPTION_WITH_FOOTER_KEY = other196.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other196.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other196.__isset;
+}
+ColumnCryptoMetaData::ColumnCryptoMetaData(ColumnCryptoMetaData&& other197) noexcept {
+  ENCRYPTION_WITH_FOOTER_KEY = std::move(other197.ENCRYPTION_WITH_FOOTER_KEY);
+  ENCRYPTION_WITH_COLUMN_KEY = std::move(other197.ENCRYPTION_WITH_COLUMN_KEY);
+  __isset = other197.__isset;
 }
-ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other121) {
-  ENCRYPTION_WITH_FOOTER_KEY = other121.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other121.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other121.__isset;
+ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other198) {
+  ENCRYPTION_WITH_FOOTER_KEY = other198.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other198.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other198.__isset;
+  return *this;
+}
+ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(ColumnCryptoMetaData&& other199) noexcept {
+  ENCRYPTION_WITH_FOOTER_KEY = std::move(other199.ENCRYPTION_WITH_FOOTER_KEY);
+  ENCRYPTION_WITH_COLUMN_KEY = std::move(other199.ENCRYPTION_WITH_COLUMN_KEY);
+  __isset = other199.__isset;
   return *this;
 }
 void ColumnCryptoMetaData::printTo(std::ostream& out) const {
@@ -5870,29 +6323,54 @@ void swap(ColumnChunk &a, ColumnChunk &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnChunk::ColumnChunk(const ColumnChunk& other122) {
-  file_path = other122.file_path;
-  file_offset = other122.file_offset;
-  meta_data = other122.meta_data;
-  offset_index_offset = other122.offset_index_offset;
-  offset_index_length = other122.offset_index_length;
-  column_index_offset = other122.column_index_offset;
-  column_index_length = other122.column_index_length;
-  crypto_metadata = other122.crypto_metadata;
-  encrypted_column_metadata = other122.encrypted_column_metadata;
-  __isset = other122.__isset;
-}
-ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other123) {
-  file_path = other123.file_path;
-  file_offset = other123.file_offset;
-  meta_data = other123.meta_data;
-  offset_index_offset = other123.offset_index_offset;
-  offset_index_length = other123.offset_index_length;
-  column_index_offset = other123.column_index_offset;
-  column_index_length = other123.column_index_length;
-  crypto_metadata = other123.crypto_metadata;
-  encrypted_column_metadata = other123.encrypted_column_metadata;
-  __isset = other123.__isset;
+ColumnChunk::ColumnChunk(const ColumnChunk& other200) {
+  file_path = other200.file_path;
+  file_offset = other200.file_offset;
+  meta_data = other200.meta_data;
+  offset_index_offset = other200.offset_index_offset;
+  offset_index_length = other200.offset_index_length;
+  column_index_offset = other200.column_index_offset;
+  column_index_length = other200.column_index_length;
+  crypto_metadata = other200.crypto_metadata;
+  encrypted_column_metadata = other200.encrypted_column_metadata;
+  __isset = other200.__isset;
+}
+ColumnChunk::ColumnChunk(ColumnChunk&& other201) noexcept {
+  file_path = std::move(other201.file_path);
+  file_offset = other201.file_offset;
+  meta_data = std::move(other201.meta_data);
+  offset_index_offset = other201.offset_index_offset;
+  offset_index_length = other201.offset_index_length;
+  column_index_offset = other201.column_index_offset;
+  column_index_length = other201.column_index_length;
+  crypto_metadata = std::move(other201.crypto_metadata);
+  encrypted_column_metadata = std::move(other201.encrypted_column_metadata);
+  __isset = other201.__isset;
+}
+ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other202) {
+  file_path = other202.file_path;
+  file_offset = other202.file_offset;
+  meta_data = other202.meta_data;
+  offset_index_offset = other202.offset_index_offset;
+  offset_index_length = other202.offset_index_length;
+  column_index_offset = other202.column_index_offset;
+  column_index_length = other202.column_index_length;
+  crypto_metadata = other202.crypto_metadata;
+  encrypted_column_metadata = other202.encrypted_column_metadata;
+  __isset = other202.__isset;
+  return *this;
+}
+ColumnChunk& ColumnChunk::operator=(ColumnChunk&& other203) noexcept {
+  file_path = std::move(other203.file_path);
+  file_offset = other203.file_offset;
+  meta_data = std::move(other203.meta_data);
+  offset_index_offset = other203.offset_index_offset;
+  offset_index_length = other203.offset_index_length;
+  column_index_offset = other203.column_index_offset;
+  column_index_length = other203.column_index_length;
+  crypto_metadata = std::move(other203.crypto_metadata);
+  encrypted_column_metadata = std::move(other203.encrypted_column_metadata);
+  __isset = other203.__isset;
   return *this;
 }
 void ColumnChunk::printTo(std::ostream& out) const {
@@ -5981,14 +6459,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size124;
-            ::apache::thrift::protocol::TType _etype127;
-            xfer += iprot->readListBegin(_etype127, _size124);
-            this->columns.resize(_size124);
-            uint32_t _i128;
-            for (_i128 = 0; _i128 < _size124; ++_i128)
+            uint32_t _size204;
+            ::apache::thrift::protocol::TType _etype207;
+            xfer += iprot->readListBegin(_etype207, _size204);
+            this->columns.resize(_size204);
+            uint32_t _i208;
+            for (_i208 = 0; _i208 < _size204; ++_i208)
             {
-              xfer += this->columns[_i128].read(iprot);
+              xfer += this->columns[_i208].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6017,14 +6495,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->sorting_columns.clear();
-            uint32_t _size129;
-            ::apache::thrift::protocol::TType _etype132;
-            xfer += iprot->readListBegin(_etype132, _size129);
-            this->sorting_columns.resize(_size129);
-            uint32_t _i133;
-            for (_i133 = 0; _i133 < _size129; ++_i133)
+            uint32_t _size209;
+            ::apache::thrift::protocol::TType _etype212;
+            xfer += iprot->readListBegin(_etype212, _size209);
+            this->sorting_columns.resize(_size209);
+            uint32_t _i213;
+            for (_i213 = 0; _i213 < _size209; ++_i213)
             {
-              xfer += this->sorting_columns[_i133].read(iprot);
+              xfer += this->sorting_columns[_i213].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6083,10 +6561,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<ColumnChunk> ::const_iterator _iter134;
-    for (_iter134 = this->columns.begin(); _iter134 != this->columns.end(); ++_iter134)
+    std::vector<ColumnChunk> ::const_iterator _iter214;
+    for (_iter214 = this->columns.begin(); _iter214 != this->columns.end(); ++_iter214)
     {
-      xfer += (*_iter134).write(oprot);
+      xfer += (*_iter214).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -6104,10 +6582,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("sorting_columns", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      std::vector<SortingColumn> ::const_iterator _iter135;
-      for (_iter135 = this->sorting_columns.begin(); _iter135 != this->sorting_columns.end(); ++_iter135)
+      std::vector<SortingColumn> ::const_iterator _iter215;
+      for (_iter215 = this->sorting_columns.begin(); _iter215 != this->sorting_columns.end(); ++_iter215)
       {
-        xfer += (*_iter135).write(oprot);
+        xfer += (*_iter215).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -6145,25 +6623,46 @@ void swap(RowGroup &a, RowGroup &b) {
   swap(a.__isset, b.__isset);
 }
 
-RowGroup::RowGroup(const RowGroup& other136) {
-  columns = other136.columns;
-  total_byte_size = other136.total_byte_size;
-  num_rows = other136.num_rows;
-  sorting_columns = other136.sorting_columns;
-  file_offset = other136.file_offset;
-  total_compressed_size = other136.total_compressed_size;
-  ordinal = other136.ordinal;
-  __isset = other136.__isset;
+RowGroup::RowGroup(const RowGroup& other216) {
+  columns = other216.columns;
+  total_byte_size = other216.total_byte_size;
+  num_rows = other216.num_rows;
+  sorting_columns = other216.sorting_columns;
+  file_offset = other216.file_offset;
+  total_compressed_size = other216.total_compressed_size;
+  ordinal = other216.ordinal;
+  __isset = other216.__isset;
+}
+RowGroup::RowGroup(RowGroup&& other217) noexcept {
+  columns = std::move(other217.columns);
+  total_byte_size = other217.total_byte_size;
+  num_rows = other217.num_rows;
+  sorting_columns = std::move(other217.sorting_columns);
+  file_offset = other217.file_offset;
+  total_compressed_size = other217.total_compressed_size;
+  ordinal = other217.ordinal;
+  __isset = other217.__isset;
+}
+RowGroup& RowGroup::operator=(const RowGroup& other218) {
+  columns = other218.columns;
+  total_byte_size = other218.total_byte_size;
+  num_rows = other218.num_rows;
+  sorting_columns = other218.sorting_columns;
+  file_offset = other218.file_offset;
+  total_compressed_size = other218.total_compressed_size;
+  ordinal = other218.ordinal;
+  __isset = other218.__isset;
+  return *this;
 }
-RowGroup& RowGroup::operator=(const RowGroup& other137) {
-  columns = other137.columns;
-  total_byte_size = other137.total_byte_size;
-  num_rows = other137.num_rows;
-  sorting_columns = other137.sorting_columns;
-  file_offset = other137.file_offset;
-  total_compressed_size = other137.total_compressed_size;
-  ordinal = other137.ordinal;
-  __isset = other137.__isset;
+RowGroup& RowGroup::operator=(RowGroup&& other219) noexcept {
+  columns = std::move(other219.columns);
+  total_byte_size = other219.total_byte_size;
+  num_rows = other219.num_rows;
+  sorting_columns = std::move(other219.sorting_columns);
+  file_offset = other219.file_offset;
+  total_compressed_size = other219.total_compressed_size;
+  ordinal = other219.ordinal;
+  __isset = other219.__isset;
   return *this;
 }
 void RowGroup::printTo(std::ostream& out) const {
@@ -6234,11 +6733,18 @@ void swap(TypeDefinedOrder &a, TypeDefinedOrder &b) {
   (void) b;
 }
 
-TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other138) noexcept {
-  (void) other138;
+TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other220) noexcept {
+  (void) other220;
+}
+TypeDefinedOrder::TypeDefinedOrder(TypeDefinedOrder&& other221) noexcept {
+  (void) other221;
+}
+TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other222) noexcept {
+  (void) other222;
+  return *this;
 }
-TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other139) noexcept {
-  (void) other139;
+TypeDefinedOrder& TypeDefinedOrder::operator=(TypeDefinedOrder&& other223) noexcept {
+  (void) other223;
   return *this;
 }
 void TypeDefinedOrder::printTo(std::ostream& out) const {
@@ -6325,13 +6831,22 @@ void swap(ColumnOrder &a, ColumnOrder &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnOrder::ColumnOrder(const ColumnOrder& other140) noexcept {
-  TYPE_ORDER = other140.TYPE_ORDER;
-  __isset = other140.__isset;
+ColumnOrder::ColumnOrder(const ColumnOrder& other224) noexcept {
+  TYPE_ORDER = other224.TYPE_ORDER;
+  __isset = other224.__isset;
+}
+ColumnOrder::ColumnOrder(ColumnOrder&& other225) noexcept {
+  TYPE_ORDER = std::move(other225.TYPE_ORDER);
+  __isset = other225.__isset;
+}
+ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other226) noexcept {
+  TYPE_ORDER = other226.TYPE_ORDER;
+  __isset = other226.__isset;
+  return *this;
 }
-ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other141) noexcept {
-  TYPE_ORDER = other141.TYPE_ORDER;
-  __isset = other141.__isset;
+ColumnOrder& ColumnOrder::operator=(ColumnOrder&& other227) noexcept {
+  TYPE_ORDER = std::move(other227.TYPE_ORDER);
+  __isset = other227.__isset;
   return *this;
 }
 void ColumnOrder::printTo(std::ostream& out) const {
@@ -6459,15 +6974,26 @@ void swap(PageLocation &a, PageLocation &b) {
   swap(a.first_row_index, b.first_row_index);
 }
 
-PageLocation::PageLocation(const PageLocation& other142) noexcept {
-  offset = other142.offset;
-  compressed_page_size = other142.compressed_page_size;
-  first_row_index = other142.first_row_index;
+PageLocation::PageLocation(const PageLocation& other228) noexcept {
+  offset = other228.offset;
+  compressed_page_size = other228.compressed_page_size;
+  first_row_index = other228.first_row_index;
+}
+PageLocation::PageLocation(PageLocation&& other229) noexcept {
+  offset = other229.offset;
+  compressed_page_size = other229.compressed_page_size;
+  first_row_index = other229.first_row_index;
+}
+PageLocation& PageLocation::operator=(const PageLocation& other230) noexcept {
+  offset = other230.offset;
+  compressed_page_size = other230.compressed_page_size;
+  first_row_index = other230.first_row_index;
+  return *this;
 }
-PageLocation& PageLocation::operator=(const PageLocation& other143) noexcept {
-  offset = other143.offset;
-  compressed_page_size = other143.compressed_page_size;
-  first_row_index = other143.first_row_index;
+PageLocation& PageLocation::operator=(PageLocation&& other231) noexcept {
+  offset = other231.offset;
+  compressed_page_size = other231.compressed_page_size;
+  first_row_index = other231.first_row_index;
   return *this;
 }
 void PageLocation::printTo(std::ostream& out) const {
@@ -6520,14 +7046,14 @@ uint32_t OffsetIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->page_locations.clear();
-            uint32_t _size144;
-            ::apache::thrift::protocol::TType _etype147;
-            xfer += iprot->readListBegin(_etype147, _size144);
-            this->page_locations.resize(_size144);
-            uint32_t _i148;
-            for (_i148 = 0; _i148 < _size144; ++_i148)
+            uint32_t _size232;
+            ::apache::thrift::protocol::TType _etype235;
+            xfer += iprot->readListBegin(_etype235, _size232);
+            this->page_locations.resize(_size232);
+            uint32_t _i236;
+            for (_i236 = 0; _i236 < _size232; ++_i236)
             {
-              xfer += this->page_locations[_i148].read(iprot);
+              xfer += this->page_locations[_i236].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6558,10 +7084,10 @@ uint32_t OffsetIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("page_locations", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->page_locations.size()));
-    std::vector<PageLocation> ::const_iterator _iter149;
-    for (_iter149 = this->page_locations.begin(); _iter149 != this->page_locations.end(); ++_iter149)
+    std::vector<PageLocation> ::const_iterator _iter237;
+    for (_iter237 = this->page_locations.begin(); _iter237 != this->page_locations.end(); ++_iter237)
     {
-      xfer += (*_iter149).write(oprot);
+      xfer += (*_iter237).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -6577,11 +7103,18 @@ void swap(OffsetIndex &a, OffsetIndex &b) {
   swap(a.page_locations, b.page_locations);
 }
 
-OffsetIndex::OffsetIndex(const OffsetIndex& other150) {
-  page_locations = other150.page_locations;
+OffsetIndex::OffsetIndex(const OffsetIndex& other238) {
+  page_locations = other238.page_locations;
 }
-OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other151) {
-  page_locations = other151.page_locations;
+OffsetIndex::OffsetIndex(OffsetIndex&& other239) noexcept {
+  page_locations = std::move(other239.page_locations);
+}
+OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other240) {
+  page_locations = other240.page_locations;
+  return *this;
+}
+OffsetIndex& OffsetIndex::operator=(OffsetIndex&& other241) noexcept {
+  page_locations = std::move(other241.page_locations);
   return *this;
 }
 void OffsetIndex::printTo(std::ostream& out) const {
@@ -6652,14 +7185,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_pages.clear();
-            uint32_t _size152;
-            ::apache::thrift::protocol::TType _etype155;
-            xfer += iprot->readListBegin(_etype155, _size152);
-            this->null_pages.resize(_size152);
-            uint32_t _i156;
-            for (_i156 = 0; _i156 < _size152; ++_i156)
+            uint32_t _size242;
+            ::apache::thrift::protocol::TType _etype245;
+            xfer += iprot->readListBegin(_etype245, _size242);
+            this->null_pages.resize(_size242);
+            uint32_t _i246;
+            for (_i246 = 0; _i246 < _size242; ++_i246)
             {
-              xfer += iprot->readBool(this->null_pages[_i156]);
+              xfer += iprot->readBool(this->null_pages[_i246]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6672,14 +7205,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->min_values.clear();
-            uint32_t _size157;
-            ::apache::thrift::protocol::TType _etype160;
-            xfer += iprot->readListBegin(_etype160, _size157);
-            this->min_values.resize(_size157);
-            uint32_t _i161;
-            for (_i161 = 0; _i161 < _size157; ++_i161)
+            uint32_t _size247;
+            ::apache::thrift::protocol::TType _etype250;
+            xfer += iprot->readListBegin(_etype250, _size247);
+            this->min_values.resize(_size247);
+            uint32_t _i251;
+            for (_i251 = 0; _i251 < _size247; ++_i251)
             {
-              xfer += iprot->readBinary(this->min_values[_i161]);
+              xfer += iprot->readBinary(this->min_values[_i251]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6692,14 +7225,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->max_values.clear();
-            uint32_t _size162;
-            ::apache::thrift::protocol::TType _etype165;
-            xfer += iprot->readListBegin(_etype165, _size162);
-            this->max_values.resize(_size162);
-            uint32_t _i166;
-            for (_i166 = 0; _i166 < _size162; ++_i166)
+            uint32_t _size252;
+            ::apache::thrift::protocol::TType _etype255;
+            xfer += iprot->readListBegin(_etype255, _size252);
+            this->max_values.resize(_size252);
+            uint32_t _i256;
+            for (_i256 = 0; _i256 < _size252; ++_i256)
             {
-              xfer += iprot->readBinary(this->max_values[_i166]);
+              xfer += iprot->readBinary(this->max_values[_i256]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6710,9 +7243,9 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast167;
-          xfer += iprot->readI32(ecast167);
-          this->boundary_order = static_cast<BoundaryOrder::type>(ecast167);
+          int32_t ecast257;
+          xfer += iprot->readI32(ecast257);
+          this->boundary_order = static_cast<BoundaryOrder::type>(ecast257);
           isset_boundary_order = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -6722,14 +7255,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_counts.clear();
-            uint32_t _size168;
-            ::apache::thrift::protocol::TType _etype171;
-            xfer += iprot->readListBegin(_etype171, _size168);
-            this->null_counts.resize(_size168);
-            uint32_t _i172;
-            for (_i172 = 0; _i172 < _size168; ++_i172)
+            uint32_t _size258;
+            ::apache::thrift::protocol::TType _etype261;
+            xfer += iprot->readListBegin(_etype261, _size258);
+            this->null_counts.resize(_size258);
+            uint32_t _i262;
+            for (_i262 = 0; _i262 < _size258; ++_i262)
             {
-              xfer += iprot->readI64(this->null_counts[_i172]);
+              xfer += iprot->readI64(this->null_counts[_i262]);
             }
             xfer += iprot->readListEnd();
           }
@@ -6766,10 +7299,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("null_pages", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->null_pages.size()));
-    std::vector<bool> ::const_iterator _iter173;
-    for (_iter173 = this->null_pages.begin(); _iter173 != this->null_pages.end(); ++_iter173)
+    std::vector<bool> ::const_iterator _iter263;
+    for (_iter263 = this->null_pages.begin(); _iter263 != this->null_pages.end(); ++_iter263)
     {
-      xfer += oprot->writeBool((*_iter173));
+      xfer += oprot->writeBool((*_iter263));
     }
     xfer += oprot->writeListEnd();
   }
@@ -6778,10 +7311,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("min_values", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->min_values.size()));
-    std::vector<std::string> ::const_iterator _iter174;
-    for (_iter174 = this->min_values.begin(); _iter174 != this->min_values.end(); ++_iter174)
+    std::vector<std::string> ::const_iterator _iter264;
+    for (_iter264 = this->min_values.begin(); _iter264 != this->min_values.end(); ++_iter264)
     {
-      xfer += oprot->writeBinary((*_iter174));
+      xfer += oprot->writeBinary((*_iter264));
     }
     xfer += oprot->writeListEnd();
   }
@@ -6790,10 +7323,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("max_values", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->max_values.size()));
-    std::vector<std::string> ::const_iterator _iter175;
-    for (_iter175 = this->max_values.begin(); _iter175 != this->max_values.end(); ++_iter175)
+    std::vector<std::string> ::const_iterator _iter265;
+    for (_iter265 = this->max_values.begin(); _iter265 != this->max_values.end(); ++_iter265)
     {
-      xfer += oprot->writeBinary((*_iter175));
+      xfer += oprot->writeBinary((*_iter265));
     }
     xfer += oprot->writeListEnd();
   }
@@ -6807,10 +7340,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("null_counts", ::apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->null_counts.size()));
-      std::vector<int64_t> ::const_iterator _iter176;
-      for (_iter176 = this->null_counts.begin(); _iter176 != this->null_counts.end(); ++_iter176)
+      std::vector<int64_t> ::const_iterator _iter266;
+      for (_iter266 = this->null_counts.begin(); _iter266 != this->null_counts.end(); ++_iter266)
       {
-        xfer += oprot->writeI64((*_iter176));
+        xfer += oprot->writeI64((*_iter266));
       }
       xfer += oprot->writeListEnd();
     }
@@ -6831,21 +7364,38 @@ void swap(ColumnIndex &a, ColumnIndex &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnIndex::ColumnIndex(const ColumnIndex& other177) {
-  null_pages = other177.null_pages;
-  min_values = other177.min_values;
-  max_values = other177.max_values;
-  boundary_order = other177.boundary_order;
-  null_counts = other177.null_counts;
-  __isset = other177.__isset;
-}
-ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other178) {
-  null_pages = other178.null_pages;
-  min_values = other178.min_values;
-  max_values = other178.max_values;
-  boundary_order = other178.boundary_order;
-  null_counts = other178.null_counts;
-  __isset = other178.__isset;
+ColumnIndex::ColumnIndex(const ColumnIndex& other267) {
+  null_pages = other267.null_pages;
+  min_values = other267.min_values;
+  max_values = other267.max_values;
+  boundary_order = other267.boundary_order;
+  null_counts = other267.null_counts;
+  __isset = other267.__isset;
+}
+ColumnIndex::ColumnIndex(ColumnIndex&& other268) noexcept {
+  null_pages = std::move(other268.null_pages);
+  min_values = std::move(other268.min_values);
+  max_values = std::move(other268.max_values);
+  boundary_order = other268.boundary_order;
+  null_counts = std::move(other268.null_counts);
+  __isset = other268.__isset;
+}
+ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other269) {
+  null_pages = other269.null_pages;
+  min_values = other269.min_values;
+  max_values = other269.max_values;
+  boundary_order = other269.boundary_order;
+  null_counts = other269.null_counts;
+  __isset = other269.__isset;
+  return *this;
+}
+ColumnIndex& ColumnIndex::operator=(ColumnIndex&& other270) noexcept {
+  null_pages = std::move(other270.null_pages);
+  min_values = std::move(other270.min_values);
+  max_values = std::move(other270.max_values);
+  boundary_order = other270.boundary_order;
+  null_counts = std::move(other270.null_counts);
+  __isset = other270.__isset;
   return *this;
 }
 void ColumnIndex::printTo(std::ostream& out) const {
@@ -6975,17 +7525,30 @@ void swap(AesGcmV1 &a, AesGcmV1 &b) {
   swap(a.__isset, b.__isset);
 }
 
-AesGcmV1::AesGcmV1(const AesGcmV1& other179) {
-  aad_prefix = other179.aad_prefix;
-  aad_file_unique = other179.aad_file_unique;
-  supply_aad_prefix = other179.supply_aad_prefix;
-  __isset = other179.__isset;
+AesGcmV1::AesGcmV1(const AesGcmV1& other271) {
+  aad_prefix = other271.aad_prefix;
+  aad_file_unique = other271.aad_file_unique;
+  supply_aad_prefix = other271.supply_aad_prefix;
+  __isset = other271.__isset;
 }
-AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other180) {
-  aad_prefix = other180.aad_prefix;
-  aad_file_unique = other180.aad_file_unique;
-  supply_aad_prefix = other180.supply_aad_prefix;
-  __isset = other180.__isset;
+AesGcmV1::AesGcmV1(AesGcmV1&& other272) noexcept {
+  aad_prefix = std::move(other272.aad_prefix);
+  aad_file_unique = std::move(other272.aad_file_unique);
+  supply_aad_prefix = other272.supply_aad_prefix;
+  __isset = other272.__isset;
+}
+AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other273) {
+  aad_prefix = other273.aad_prefix;
+  aad_file_unique = other273.aad_file_unique;
+  supply_aad_prefix = other273.supply_aad_prefix;
+  __isset = other273.__isset;
+  return *this;
+}
+AesGcmV1& AesGcmV1::operator=(AesGcmV1&& other274) noexcept {
+  aad_prefix = std::move(other274.aad_prefix);
+  aad_file_unique = std::move(other274.aad_file_unique);
+  supply_aad_prefix = other274.supply_aad_prefix;
+  __isset = other274.__isset;
   return *this;
 }
 void AesGcmV1::printTo(std::ostream& out) const {
@@ -7113,17 +7676,30 @@ void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b) {
   swap(a.__isset, b.__isset);
 }
 
-AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other181) {
-  aad_prefix = other181.aad_prefix;
-  aad_file_unique = other181.aad_file_unique;
-  supply_aad_prefix = other181.supply_aad_prefix;
-  __isset = other181.__isset;
+AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other275) {
+  aad_prefix = other275.aad_prefix;
+  aad_file_unique = other275.aad_file_unique;
+  supply_aad_prefix = other275.supply_aad_prefix;
+  __isset = other275.__isset;
+}
+AesGcmCtrV1::AesGcmCtrV1(AesGcmCtrV1&& other276) noexcept {
+  aad_prefix = std::move(other276.aad_prefix);
+  aad_file_unique = std::move(other276.aad_file_unique);
+  supply_aad_prefix = other276.supply_aad_prefix;
+  __isset = other276.__isset;
 }
-AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other182) {
-  aad_prefix = other182.aad_prefix;
-  aad_file_unique = other182.aad_file_unique;
-  supply_aad_prefix = other182.supply_aad_prefix;
-  __isset = other182.__isset;
+AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other277) {
+  aad_prefix = other277.aad_prefix;
+  aad_file_unique = other277.aad_file_unique;
+  supply_aad_prefix = other277.supply_aad_prefix;
+  __isset = other277.__isset;
+  return *this;
+}
+AesGcmCtrV1& AesGcmCtrV1::operator=(AesGcmCtrV1&& other278) noexcept {
+  aad_prefix = std::move(other278.aad_prefix);
+  aad_file_unique = std::move(other278.aad_file_unique);
+  supply_aad_prefix = other278.supply_aad_prefix;
+  __isset = other278.__isset;
   return *this;
 }
 void AesGcmCtrV1::printTo(std::ostream& out) const {
@@ -7232,15 +7808,26 @@ void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b) {
   swap(a.__isset, b.__isset);
 }
 
-EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other183) {
-  AES_GCM_V1 = other183.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other183.AES_GCM_CTR_V1;
-  __isset = other183.__isset;
+EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other279) {
+  AES_GCM_V1 = other279.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other279.AES_GCM_CTR_V1;
+  __isset = other279.__isset;
+}
+EncryptionAlgorithm::EncryptionAlgorithm(EncryptionAlgorithm&& other280) noexcept {
+  AES_GCM_V1 = std::move(other280.AES_GCM_V1);
+  AES_GCM_CTR_V1 = std::move(other280.AES_GCM_CTR_V1);
+  __isset = other280.__isset;
 }
-EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other184) {
-  AES_GCM_V1 = other184.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other184.AES_GCM_CTR_V1;
-  __isset = other184.__isset;
+EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other281) {
+  AES_GCM_V1 = other281.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other281.AES_GCM_CTR_V1;
+  __isset = other281.__isset;
+  return *this;
+}
+EncryptionAlgorithm& EncryptionAlgorithm::operator=(EncryptionAlgorithm&& other282) noexcept {
+  AES_GCM_V1 = std::move(other282.AES_GCM_V1);
+  AES_GCM_CTR_V1 = std::move(other282.AES_GCM_CTR_V1);
+  __isset = other282.__isset;
   return *this;
 }
 void EncryptionAlgorithm::printTo(std::ostream& out) const {
@@ -7340,14 +7927,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->schema.clear();
-            uint32_t _size185;
-            ::apache::thrift::protocol::TType _etype188;
-            xfer += iprot->readListBegin(_etype188, _size185);
-            this->schema.resize(_size185);
-            uint32_t _i189;
-            for (_i189 = 0; _i189 < _size185; ++_i189)
+            uint32_t _size283;
+            ::apache::thrift::protocol::TType _etype286;
+            xfer += iprot->readListBegin(_etype286, _size283);
+            this->schema.resize(_size283);
+            uint32_t _i287;
+            for (_i287 = 0; _i287 < _size283; ++_i287)
             {
-              xfer += this->schema[_i189].read(iprot);
+              xfer += this->schema[_i287].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7368,14 +7955,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->row_groups.clear();
-            uint32_t _size190;
-            ::apache::thrift::protocol::TType _etype193;
-            xfer += iprot->readListBegin(_etype193, _size190);
-            this->row_groups.resize(_size190);
-            uint32_t _i194;
-            for (_i194 = 0; _i194 < _size190; ++_i194)
+            uint32_t _size288;
+            ::apache::thrift::protocol::TType _etype291;
+            xfer += iprot->readListBegin(_etype291, _size288);
+            this->row_groups.resize(_size288);
+            uint32_t _i292;
+            for (_i292 = 0; _i292 < _size288; ++_i292)
             {
-              xfer += this->row_groups[_i194].read(iprot);
+              xfer += this->row_groups[_i292].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7388,14 +7975,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->key_value_metadata.clear();
-            uint32_t _size195;
-            ::apache::thrift::protocol::TType _etype198;
-            xfer += iprot->readListBegin(_etype198, _size195);
-            this->key_value_metadata.resize(_size195);
-            uint32_t _i199;
-            for (_i199 = 0; _i199 < _size195; ++_i199)
+            uint32_t _size293;
+            ::apache::thrift::protocol::TType _etype296;
+            xfer += iprot->readListBegin(_etype296, _size293);
+            this->key_value_metadata.resize(_size293);
+            uint32_t _i297;
+            for (_i297 = 0; _i297 < _size293; ++_i297)
             {
-              xfer += this->key_value_metadata[_i199].read(iprot);
+              xfer += this->key_value_metadata[_i297].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7416,14 +8003,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->column_orders.clear();
-            uint32_t _size200;
-            ::apache::thrift::protocol::TType _etype203;
-            xfer += iprot->readListBegin(_etype203, _size200);
-            this->column_orders.resize(_size200);
-            uint32_t _i204;
-            for (_i204 = 0; _i204 < _size200; ++_i204)
+            uint32_t _size298;
+            ::apache::thrift::protocol::TType _etype301;
+            xfer += iprot->readListBegin(_etype301, _size298);
+            this->column_orders.resize(_size298);
+            uint32_t _i302;
+            for (_i302 = 0; _i302 < _size298; ++_i302)
             {
-              xfer += this->column_orders[_i204].read(iprot);
+              xfer += this->column_orders[_i302].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7480,10 +8067,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    std::vector<SchemaElement> ::const_iterator _iter205;
-    for (_iter205 = this->schema.begin(); _iter205 != this->schema.end(); ++_iter205)
+    std::vector<SchemaElement> ::const_iterator _iter303;
+    for (_iter303 = this->schema.begin(); _iter303 != this->schema.end(); ++_iter303)
     {
-      xfer += (*_iter205).write(oprot);
+      xfer += (*_iter303).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -7496,10 +8083,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    std::vector<RowGroup> ::const_iterator _iter206;
-    for (_iter206 = this->row_groups.begin(); _iter206 != this->row_groups.end(); ++_iter206)
+    std::vector<RowGroup> ::const_iterator _iter304;
+    for (_iter304 = this->row_groups.begin(); _iter304 != this->row_groups.end(); ++_iter304)
     {
-      xfer += (*_iter206).write(oprot);
+      xfer += (*_iter304).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -7509,10 +8096,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter207;
-      for (_iter207 = this->key_value_metadata.begin(); _iter207 != this->key_value_metadata.end(); ++_iter207)
+      std::vector<KeyValue> ::const_iterator _iter305;
+      for (_iter305 = this->key_value_metadata.begin(); _iter305 != this->key_value_metadata.end(); ++_iter305)
       {
-        xfer += (*_iter207).write(oprot);
+        xfer += (*_iter305).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -7527,10 +8114,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("column_orders", ::apache::thrift::protocol::T_LIST, 7);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
-      std::vector<ColumnOrder> ::const_iterator _iter208;
-      for (_iter208 = this->column_orders.begin(); _iter208 != this->column_orders.end(); ++_iter208)
+      std::vector<ColumnOrder> ::const_iterator _iter306;
+      for (_iter306 = this->column_orders.begin(); _iter306 != this->column_orders.end(); ++_iter306)
       {
-        xfer += (*_iter208).write(oprot);
+        xfer += (*_iter306).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -7565,29 +8152,54 @@ void swap(FileMetaData &a, FileMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-FileMetaData::FileMetaData(const FileMetaData& other209) {
-  version = other209.version;
-  schema = other209.schema;
-  num_rows = other209.num_rows;
-  row_groups = other209.row_groups;
-  key_value_metadata = other209.key_value_metadata;
-  created_by = other209.created_by;
-  column_orders = other209.column_orders;
-  encryption_algorithm = other209.encryption_algorithm;
-  footer_signing_key_metadata = other209.footer_signing_key_metadata;
-  __isset = other209.__isset;
-}
-FileMetaData& FileMetaData::operator=(const FileMetaData& other210) {
-  version = other210.version;
-  schema = other210.schema;
-  num_rows = other210.num_rows;
-  row_groups = other210.row_groups;
-  key_value_metadata = other210.key_value_metadata;
-  created_by = other210.created_by;
-  column_orders = other210.column_orders;
-  encryption_algorithm = other210.encryption_algorithm;
-  footer_signing_key_metadata = other210.footer_signing_key_metadata;
-  __isset = other210.__isset;
+FileMetaData::FileMetaData(const FileMetaData& other307) {
+  version = other307.version;
+  schema = other307.schema;
+  num_rows = other307.num_rows;
+  row_groups = other307.row_groups;
+  key_value_metadata = other307.key_value_metadata;
+  created_by = other307.created_by;
+  column_orders = other307.column_orders;
+  encryption_algorithm = other307.encryption_algorithm;
+  footer_signing_key_metadata = other307.footer_signing_key_metadata;
+  __isset = other307.__isset;
+}
+FileMetaData::FileMetaData(FileMetaData&& other308) noexcept {
+  version = other308.version;
+  schema = std::move(other308.schema);
+  num_rows = other308.num_rows;
+  row_groups = std::move(other308.row_groups);
+  key_value_metadata = std::move(other308.key_value_metadata);
+  created_by = std::move(other308.created_by);
+  column_orders = std::move(other308.column_orders);
+  encryption_algorithm = std::move(other308.encryption_algorithm);
+  footer_signing_key_metadata = std::move(other308.footer_signing_key_metadata);
+  __isset = other308.__isset;
+}
+FileMetaData& FileMetaData::operator=(const FileMetaData& other309) {
+  version = other309.version;
+  schema = other309.schema;
+  num_rows = other309.num_rows;
+  row_groups = other309.row_groups;
+  key_value_metadata = other309.key_value_metadata;
+  created_by = other309.created_by;
+  column_orders = other309.column_orders;
+  encryption_algorithm = other309.encryption_algorithm;
+  footer_signing_key_metadata = other309.footer_signing_key_metadata;
+  __isset = other309.__isset;
+  return *this;
+}
+FileMetaData& FileMetaData::operator=(FileMetaData&& other310) noexcept {
+  version = other310.version;
+  schema = std::move(other310.schema);
+  num_rows = other310.num_rows;
+  row_groups = std::move(other310.row_groups);
+  key_value_metadata = std::move(other310.key_value_metadata);
+  created_by = std::move(other310.created_by);
+  column_orders = std::move(other310.column_orders);
+  encryption_algorithm = std::move(other310.encryption_algorithm);
+  footer_signing_key_metadata = std::move(other310.footer_signing_key_metadata);
+  __isset = other310.__isset;
   return *this;
 }
 void FileMetaData::printTo(std::ostream& out) const {
@@ -7703,15 +8315,26 @@ void swap(FileCryptoMetaData &a, FileCryptoMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other211) {
-  encryption_algorithm = other211.encryption_algorithm;
-  key_metadata = other211.key_metadata;
-  __isset = other211.__isset;
+FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other311) {
+  encryption_algorithm = other311.encryption_algorithm;
+  key_metadata = other311.key_metadata;
+  __isset = other311.__isset;
+}
+FileCryptoMetaData::FileCryptoMetaData(FileCryptoMetaData&& other312) noexcept {
+  encryption_algorithm = std::move(other312.encryption_algorithm);
+  key_metadata = std::move(other312.key_metadata);
+  __isset = other312.__isset;
+}
+FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other313) {
+  encryption_algorithm = other313.encryption_algorithm;
+  key_metadata = other313.key_metadata;
+  __isset = other313.__isset;
+  return *this;
 }
-FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other212) {
-  encryption_algorithm = other212.encryption_algorithm;
-  key_metadata = other212.key_metadata;
-  __isset = other212.__isset;
+FileCryptoMetaData& FileCryptoMetaData::operator=(FileCryptoMetaData&& other314) noexcept {
+  encryption_algorithm = std::move(other314.encryption_algorithm);
+  key_metadata = std::move(other314.key_metadata);
+  __isset = other314.__isset;
   return *this;
 }
 void FileCryptoMetaData::printTo(std::ostream& out) const {
diff --git a/cpp/src/generated/parquet_types.h b/cpp/src/generated/parquet_types.h
index 826e58930445f..9f468b5051db3 100644
--- a/cpp/src/generated/parquet_types.h
+++ b/cpp/src/generated/parquet_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.17.0)
+ * Autogenerated by Thrift Compiler (0.18.1)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -465,7 +465,9 @@ class Statistics : public virtual ::apache::thrift::TBase {
  public:
 
   Statistics(const Statistics&);
+  Statistics(Statistics&&) noexcept;
   Statistics& operator=(const Statistics&);
+  Statistics& operator=(Statistics&&) noexcept;
   Statistics() noexcept
              : max(),
                min(),
@@ -574,7 +576,9 @@ class StringType : public virtual ::apache::thrift::TBase {
  public:
 
   StringType(const StringType&) noexcept;
+  StringType(StringType&&) noexcept;
   StringType& operator=(const StringType&) noexcept;
+  StringType& operator=(StringType&&) noexcept;
   StringType() noexcept {
   }
 
@@ -605,7 +609,9 @@ class UUIDType : public virtual ::apache::thrift::TBase {
  public:
 
   UUIDType(const UUIDType&) noexcept;
+  UUIDType(UUIDType&&) noexcept;
   UUIDType& operator=(const UUIDType&) noexcept;
+  UUIDType& operator=(UUIDType&&) noexcept;
   UUIDType() noexcept {
   }
 
@@ -636,7 +642,9 @@ class MapType : public virtual ::apache::thrift::TBase {
  public:
 
   MapType(const MapType&) noexcept;
+  MapType(MapType&&) noexcept;
   MapType& operator=(const MapType&) noexcept;
+  MapType& operator=(MapType&&) noexcept;
   MapType() noexcept {
   }
 
@@ -667,7 +675,9 @@ class ListType : public virtual ::apache::thrift::TBase {
  public:
 
   ListType(const ListType&) noexcept;
+  ListType(ListType&&) noexcept;
   ListType& operator=(const ListType&) noexcept;
+  ListType& operator=(ListType&&) noexcept;
   ListType() noexcept {
   }
 
@@ -698,7 +708,9 @@ class EnumType : public virtual ::apache::thrift::TBase {
  public:
 
   EnumType(const EnumType&) noexcept;
+  EnumType(EnumType&&) noexcept;
   EnumType& operator=(const EnumType&) noexcept;
+  EnumType& operator=(EnumType&&) noexcept;
   EnumType() noexcept {
   }
 
@@ -729,7 +741,9 @@ class DateType : public virtual ::apache::thrift::TBase {
  public:
 
   DateType(const DateType&) noexcept;
+  DateType(DateType&&) noexcept;
   DateType& operator=(const DateType&) noexcept;
+  DateType& operator=(DateType&&) noexcept;
   DateType() noexcept {
   }
 
@@ -767,7 +781,9 @@ class NullType : public virtual ::apache::thrift::TBase {
  public:
 
   NullType(const NullType&) noexcept;
+  NullType(NullType&&) noexcept;
   NullType& operator=(const NullType&) noexcept;
+  NullType& operator=(NullType&&) noexcept;
   NullType() noexcept {
   }
 
@@ -806,7 +822,9 @@ class DecimalType : public virtual ::apache::thrift::TBase {
  public:
 
   DecimalType(const DecimalType&) noexcept;
+  DecimalType(DecimalType&&) noexcept;
   DecimalType& operator=(const DecimalType&) noexcept;
+  DecimalType& operator=(DecimalType&&) noexcept;
   DecimalType() noexcept
               : scale(0),
                 precision(0) {
@@ -852,7 +870,9 @@ class MilliSeconds : public virtual ::apache::thrift::TBase {
  public:
 
   MilliSeconds(const MilliSeconds&) noexcept;
+  MilliSeconds(MilliSeconds&&) noexcept;
   MilliSeconds& operator=(const MilliSeconds&) noexcept;
+  MilliSeconds& operator=(MilliSeconds&&) noexcept;
   MilliSeconds() noexcept {
   }
 
@@ -883,7 +903,9 @@ class MicroSeconds : public virtual ::apache::thrift::TBase {
  public:
 
   MicroSeconds(const MicroSeconds&) noexcept;
+  MicroSeconds(MicroSeconds&&) noexcept;
   MicroSeconds& operator=(const MicroSeconds&) noexcept;
+  MicroSeconds& operator=(MicroSeconds&&) noexcept;
   MicroSeconds() noexcept {
   }
 
@@ -914,7 +936,9 @@ class NanoSeconds : public virtual ::apache::thrift::TBase {
  public:
 
   NanoSeconds(const NanoSeconds&) noexcept;
+  NanoSeconds(NanoSeconds&&) noexcept;
   NanoSeconds& operator=(const NanoSeconds&) noexcept;
+  NanoSeconds& operator=(NanoSeconds&&) noexcept;
   NanoSeconds() noexcept {
   }
 
@@ -951,7 +975,9 @@ class TimeUnit : public virtual ::apache::thrift::TBase {
  public:
 
   TimeUnit(const TimeUnit&) noexcept;
+  TimeUnit(TimeUnit&&) noexcept;
   TimeUnit& operator=(const TimeUnit&) noexcept;
+  TimeUnit& operator=(TimeUnit&&) noexcept;
   TimeUnit() noexcept {
   }
 
@@ -1010,7 +1036,9 @@ class TimestampType : public virtual ::apache::thrift::TBase {
  public:
 
   TimestampType(const TimestampType&) noexcept;
+  TimestampType(TimestampType&&) noexcept;
   TimestampType& operator=(const TimestampType&) noexcept;
+  TimestampType& operator=(TimestampType&&) noexcept;
   TimestampType() noexcept
                 : isAdjustedToUTC(0) {
   }
@@ -1057,7 +1085,9 @@ class TimeType : public virtual ::apache::thrift::TBase {
  public:
 
   TimeType(const TimeType&) noexcept;
+  TimeType(TimeType&&) noexcept;
   TimeType& operator=(const TimeType&) noexcept;
+  TimeType& operator=(TimeType&&) noexcept;
   TimeType() noexcept
            : isAdjustedToUTC(0) {
   }
@@ -1106,7 +1136,9 @@ class IntType : public virtual ::apache::thrift::TBase {
  public:
 
   IntType(const IntType&) noexcept;
+  IntType(IntType&&) noexcept;
   IntType& operator=(const IntType&) noexcept;
+  IntType& operator=(IntType&&) noexcept;
   IntType() noexcept
           : bitWidth(0),
             isSigned(0) {
@@ -1154,7 +1186,9 @@ class JsonType : public virtual ::apache::thrift::TBase {
  public:
 
   JsonType(const JsonType&) noexcept;
+  JsonType(JsonType&&) noexcept;
   JsonType& operator=(const JsonType&) noexcept;
+  JsonType& operator=(JsonType&&) noexcept;
   JsonType() noexcept {
   }
 
@@ -1190,7 +1224,9 @@ class BsonType : public virtual ::apache::thrift::TBase {
  public:
 
   BsonType(const BsonType&) noexcept;
+  BsonType(BsonType&&) noexcept;
   BsonType& operator=(const BsonType&) noexcept;
+  BsonType& operator=(BsonType&&) noexcept;
   BsonType() noexcept {
   }
 
@@ -1244,7 +1280,9 @@ class LogicalType : public virtual ::apache::thrift::TBase {
  public:
 
   LogicalType(const LogicalType&) noexcept;
+  LogicalType(LogicalType&&) noexcept;
   LogicalType& operator=(const LogicalType&) noexcept;
+  LogicalType& operator=(LogicalType&&) noexcept;
   LogicalType() noexcept {
   }
 
@@ -1386,7 +1424,9 @@ class SchemaElement : public virtual ::apache::thrift::TBase {
  public:
 
   SchemaElement(const SchemaElement&);
+  SchemaElement(SchemaElement&&) noexcept;
   SchemaElement& operator=(const SchemaElement&);
+  SchemaElement& operator=(SchemaElement&&) noexcept;
   SchemaElement() noexcept
                 : type(static_cast<Type::type>(0)),
                   type_length(0),
@@ -1553,7 +1593,9 @@ class DataPageHeader : public virtual ::apache::thrift::TBase {
  public:
 
   DataPageHeader(const DataPageHeader&);
+  DataPageHeader(DataPageHeader&&) noexcept;
   DataPageHeader& operator=(const DataPageHeader&);
+  DataPageHeader& operator=(DataPageHeader&&) noexcept;
   DataPageHeader() noexcept
                  : num_values(0),
                    encoding(static_cast<Encoding::type>(0)),
@@ -1638,7 +1680,9 @@ class IndexPageHeader : public virtual ::apache::thrift::TBase {
  public:
 
   IndexPageHeader(const IndexPageHeader&) noexcept;
+  IndexPageHeader(IndexPageHeader&&) noexcept;
   IndexPageHeader& operator=(const IndexPageHeader&) noexcept;
+  IndexPageHeader& operator=(IndexPageHeader&&) noexcept;
   IndexPageHeader() noexcept {
   }
 
@@ -1679,7 +1723,9 @@ class DictionaryPageHeader : public virtual ::apache::thrift::TBase {
  public:
 
   DictionaryPageHeader(const DictionaryPageHeader&) noexcept;
+  DictionaryPageHeader(DictionaryPageHeader&&) noexcept;
   DictionaryPageHeader& operator=(const DictionaryPageHeader&) noexcept;
+  DictionaryPageHeader& operator=(DictionaryPageHeader&&) noexcept;
   DictionaryPageHeader() noexcept
                        : num_values(0),
                          encoding(static_cast<Encoding::type>(0)),
@@ -1754,7 +1800,9 @@ class DataPageHeaderV2 : public virtual ::apache::thrift::TBase {
  public:
 
   DataPageHeaderV2(const DataPageHeaderV2&);
+  DataPageHeaderV2(DataPageHeaderV2&&) noexcept;
   DataPageHeaderV2& operator=(const DataPageHeaderV2&);
+  DataPageHeaderV2& operator=(DataPageHeaderV2&&) noexcept;
   DataPageHeaderV2() noexcept
                    : num_values(0),
                      num_nulls(0),
@@ -1872,7 +1920,9 @@ class SplitBlockAlgorithm : public virtual ::apache::thrift::TBase {
  public:
 
   SplitBlockAlgorithm(const SplitBlockAlgorithm&) noexcept;
+  SplitBlockAlgorithm(SplitBlockAlgorithm&&) noexcept;
   SplitBlockAlgorithm& operator=(const SplitBlockAlgorithm&) noexcept;
+  SplitBlockAlgorithm& operator=(SplitBlockAlgorithm&&) noexcept;
   SplitBlockAlgorithm() noexcept {
   }
 
@@ -1910,7 +1960,9 @@ class BloomFilterAlgorithm : public virtual ::apache::thrift::TBase {
  public:
 
   BloomFilterAlgorithm(const BloomFilterAlgorithm&) noexcept;
+  BloomFilterAlgorithm(BloomFilterAlgorithm&&) noexcept;
   BloomFilterAlgorithm& operator=(const BloomFilterAlgorithm&) noexcept;
+  BloomFilterAlgorithm& operator=(BloomFilterAlgorithm&&) noexcept;
   BloomFilterAlgorithm() noexcept {
   }
 
@@ -1958,7 +2010,9 @@ class XxHash : public virtual ::apache::thrift::TBase {
  public:
 
   XxHash(const XxHash&) noexcept;
+  XxHash(XxHash&&) noexcept;
   XxHash& operator=(const XxHash&) noexcept;
+  XxHash& operator=(XxHash&&) noexcept;
   XxHash() noexcept {
   }
 
@@ -1998,7 +2052,9 @@ class BloomFilterHash : public virtual ::apache::thrift::TBase {
  public:
 
   BloomFilterHash(const BloomFilterHash&) noexcept;
+  BloomFilterHash(BloomFilterHash&&) noexcept;
   BloomFilterHash& operator=(const BloomFilterHash&) noexcept;
+  BloomFilterHash& operator=(BloomFilterHash&&) noexcept;
   BloomFilterHash() noexcept {
   }
 
@@ -2045,7 +2101,9 @@ class Uncompressed : public virtual ::apache::thrift::TBase {
  public:
 
   Uncompressed(const Uncompressed&) noexcept;
+  Uncompressed(Uncompressed&&) noexcept;
   Uncompressed& operator=(const Uncompressed&) noexcept;
+  Uncompressed& operator=(Uncompressed&&) noexcept;
   Uncompressed() noexcept {
   }
 
@@ -2080,7 +2138,9 @@ class BloomFilterCompression : public virtual ::apache::thrift::TBase {
  public:
 
   BloomFilterCompression(const BloomFilterCompression&) noexcept;
+  BloomFilterCompression(BloomFilterCompression&&) noexcept;
   BloomFilterCompression& operator=(const BloomFilterCompression&) noexcept;
+  BloomFilterCompression& operator=(BloomFilterCompression&&) noexcept;
   BloomFilterCompression() noexcept {
   }
 
@@ -2125,7 +2185,9 @@ class BloomFilterHeader : public virtual ::apache::thrift::TBase {
  public:
 
   BloomFilterHeader(const BloomFilterHeader&) noexcept;
+  BloomFilterHeader(BloomFilterHeader&&) noexcept;
   BloomFilterHeader& operator=(const BloomFilterHeader&) noexcept;
+  BloomFilterHeader& operator=(BloomFilterHeader&&) noexcept;
   BloomFilterHeader() noexcept
                     : numBytes(0) {
   }
@@ -2197,7 +2259,9 @@ class PageHeader : public virtual ::apache::thrift::TBase {
  public:
 
   PageHeader(const PageHeader&);
+  PageHeader(PageHeader&&) noexcept;
   PageHeader& operator=(const PageHeader&);
+  PageHeader& operator=(PageHeader&&) noexcept;
   PageHeader() noexcept
              : type(static_cast<PageType::type>(0)),
                uncompressed_page_size(0),
@@ -2320,7 +2384,9 @@ class KeyValue : public virtual ::apache::thrift::TBase {
  public:
 
   KeyValue(const KeyValue&);
+  KeyValue(KeyValue&&) noexcept;
   KeyValue& operator=(const KeyValue&);
+  KeyValue& operator=(KeyValue&&) noexcept;
   KeyValue() noexcept
            : key(),
              value() {
@@ -2370,7 +2436,9 @@ class SortingColumn : public virtual ::apache::thrift::TBase {
  public:
 
   SortingColumn(const SortingColumn&) noexcept;
+  SortingColumn(SortingColumn&&) noexcept;
   SortingColumn& operator=(const SortingColumn&) noexcept;
+  SortingColumn& operator=(SortingColumn&&) noexcept;
   SortingColumn() noexcept
                 : column_idx(0),
                   descending(0),
@@ -2432,7 +2500,9 @@ class PageEncodingStats : public virtual ::apache::thrift::TBase {
  public:
 
   PageEncodingStats(const PageEncodingStats&) noexcept;
+  PageEncodingStats(PageEncodingStats&&) noexcept;
   PageEncodingStats& operator=(const PageEncodingStats&) noexcept;
+  PageEncodingStats& operator=(PageEncodingStats&&) noexcept;
   PageEncodingStats() noexcept
                     : page_type(static_cast<PageType::type>(0)),
                       encoding(static_cast<Encoding::type>(0)),
@@ -2506,7 +2576,9 @@ class ColumnMetaData : public virtual ::apache::thrift::TBase {
  public:
 
   ColumnMetaData(const ColumnMetaData&);
+  ColumnMetaData(ColumnMetaData&&) noexcept;
   ColumnMetaData& operator=(const ColumnMetaData&);
+  ColumnMetaData& operator=(ColumnMetaData&&) noexcept;
   ColumnMetaData() noexcept
                  : type(static_cast<Type::type>(0)),
                    codec(static_cast<CompressionCodec::type>(0)),
@@ -2680,7 +2752,9 @@ class EncryptionWithFooterKey : public virtual ::apache::thrift::TBase {
  public:
 
   EncryptionWithFooterKey(const EncryptionWithFooterKey&) noexcept;
+  EncryptionWithFooterKey(EncryptionWithFooterKey&&) noexcept;
   EncryptionWithFooterKey& operator=(const EncryptionWithFooterKey&) noexcept;
+  EncryptionWithFooterKey& operator=(EncryptionWithFooterKey&&) noexcept;
   EncryptionWithFooterKey() noexcept {
   }
 
@@ -2715,7 +2789,9 @@ class EncryptionWithColumnKey : public virtual ::apache::thrift::TBase {
  public:
 
   EncryptionWithColumnKey(const EncryptionWithColumnKey&);
+  EncryptionWithColumnKey(EncryptionWithColumnKey&&) noexcept;
   EncryptionWithColumnKey& operator=(const EncryptionWithColumnKey&);
+  EncryptionWithColumnKey& operator=(EncryptionWithColumnKey&&) noexcept;
   EncryptionWithColumnKey() noexcept
                           : key_metadata() {
   }
@@ -2772,7 +2848,9 @@ class ColumnCryptoMetaData : public virtual ::apache::thrift::TBase {
  public:
 
   ColumnCryptoMetaData(const ColumnCryptoMetaData&);
+  ColumnCryptoMetaData(ColumnCryptoMetaData&&) noexcept;
   ColumnCryptoMetaData& operator=(const ColumnCryptoMetaData&);
+  ColumnCryptoMetaData& operator=(ColumnCryptoMetaData&&) noexcept;
   ColumnCryptoMetaData() noexcept {
   }
 
@@ -2830,7 +2908,9 @@ class ColumnChunk : public virtual ::apache::thrift::TBase {
  public:
 
   ColumnChunk(const ColumnChunk&);
+  ColumnChunk(ColumnChunk&&) noexcept;
   ColumnChunk& operator=(const ColumnChunk&);
+  ColumnChunk& operator=(ColumnChunk&&) noexcept;
   ColumnChunk() noexcept
               : file_path(),
                 file_offset(0),
@@ -2970,7 +3050,9 @@ class RowGroup : public virtual ::apache::thrift::TBase {
  public:
 
   RowGroup(const RowGroup&);
+  RowGroup(RowGroup&&) noexcept;
   RowGroup& operator=(const RowGroup&);
+  RowGroup& operator=(RowGroup&&) noexcept;
   RowGroup() noexcept
            : total_byte_size(0),
              num_rows(0),
@@ -3080,7 +3162,9 @@ class TypeDefinedOrder : public virtual ::apache::thrift::TBase {
  public:
 
   TypeDefinedOrder(const TypeDefinedOrder&) noexcept;
+  TypeDefinedOrder(TypeDefinedOrder&&) noexcept;
   TypeDefinedOrder& operator=(const TypeDefinedOrder&) noexcept;
+  TypeDefinedOrder& operator=(TypeDefinedOrder&&) noexcept;
   TypeDefinedOrder() noexcept {
   }
 
@@ -3127,7 +3211,9 @@ class ColumnOrder : public virtual ::apache::thrift::TBase {
  public:
 
   ColumnOrder(const ColumnOrder&) noexcept;
+  ColumnOrder(ColumnOrder&&) noexcept;
   ColumnOrder& operator=(const ColumnOrder&) noexcept;
+  ColumnOrder& operator=(ColumnOrder&&) noexcept;
   ColumnOrder() noexcept {
   }
 
@@ -3217,7 +3303,9 @@ class PageLocation : public virtual ::apache::thrift::TBase {
  public:
 
   PageLocation(const PageLocation&) noexcept;
+  PageLocation(PageLocation&&) noexcept;
   PageLocation& operator=(const PageLocation&) noexcept;
+  PageLocation& operator=(PageLocation&&) noexcept;
   PageLocation() noexcept
                : offset(0),
                  compressed_page_size(0),
@@ -3277,7 +3365,9 @@ class OffsetIndex : public virtual ::apache::thrift::TBase {
  public:
 
   OffsetIndex(const OffsetIndex&);
+  OffsetIndex(OffsetIndex&&) noexcept;
   OffsetIndex& operator=(const OffsetIndex&);
+  OffsetIndex& operator=(OffsetIndex&&) noexcept;
   OffsetIndex() noexcept {
   }
 
@@ -3325,7 +3415,9 @@ class ColumnIndex : public virtual ::apache::thrift::TBase {
  public:
 
   ColumnIndex(const ColumnIndex&);
+  ColumnIndex(ColumnIndex&&) noexcept;
   ColumnIndex& operator=(const ColumnIndex&);
+  ColumnIndex& operator=(ColumnIndex&&) noexcept;
   ColumnIndex() noexcept
               : boundary_order(static_cast<BoundaryOrder::type>(0)) {
   }
@@ -3420,7 +3512,9 @@ class AesGcmV1 : public virtual ::apache::thrift::TBase {
  public:
 
   AesGcmV1(const AesGcmV1&);
+  AesGcmV1(AesGcmV1&&) noexcept;
   AesGcmV1& operator=(const AesGcmV1&);
+  AesGcmV1& operator=(AesGcmV1&&) noexcept;
   AesGcmV1() noexcept
            : aad_prefix(),
              aad_file_unique(),
@@ -3493,7 +3587,9 @@ class AesGcmCtrV1 : public virtual ::apache::thrift::TBase {
  public:
 
   AesGcmCtrV1(const AesGcmCtrV1&);
+  AesGcmCtrV1(AesGcmCtrV1&&) noexcept;
   AesGcmCtrV1& operator=(const AesGcmCtrV1&);
+  AesGcmCtrV1& operator=(AesGcmCtrV1&&) noexcept;
   AesGcmCtrV1() noexcept
               : aad_prefix(),
                 aad_file_unique(),
@@ -3565,7 +3661,9 @@ class EncryptionAlgorithm : public virtual ::apache::thrift::TBase {
  public:
 
   EncryptionAlgorithm(const EncryptionAlgorithm&);
+  EncryptionAlgorithm(EncryptionAlgorithm&&) noexcept;
   EncryptionAlgorithm& operator=(const EncryptionAlgorithm&);
+  EncryptionAlgorithm& operator=(EncryptionAlgorithm&&) noexcept;
   EncryptionAlgorithm() noexcept {
   }
 
@@ -3623,7 +3721,9 @@ class FileMetaData : public virtual ::apache::thrift::TBase {
  public:
 
   FileMetaData(const FileMetaData&);
+  FileMetaData(FileMetaData&&) noexcept;
   FileMetaData& operator=(const FileMetaData&);
+  FileMetaData& operator=(FileMetaData&&) noexcept;
   FileMetaData() noexcept
                : version(0),
                  num_rows(0),
@@ -3773,7 +3873,9 @@ class FileCryptoMetaData : public virtual ::apache::thrift::TBase {
  public:
 
   FileCryptoMetaData(const FileCryptoMetaData&);
+  FileCryptoMetaData(FileCryptoMetaData&&) noexcept;
   FileCryptoMetaData& operator=(const FileCryptoMetaData&);
+  FileCryptoMetaData& operator=(FileCryptoMetaData&&) noexcept;
   FileCryptoMetaData() noexcept
                      : key_metadata() {
   }
diff --git a/cpp/src/parquet/page_index.cc b/cpp/src/parquet/page_index.cc
index d29cc33eb5afd..9bae90e5540bd 100644
--- a/cpp/src/parquet/page_index.cc
+++ b/cpp/src/parquet/page_index.cc
@@ -88,9 +88,8 @@ class TypedColumnIndexImpl : public TypedColumnIndex<DType> {
  public:
   using T = typename DType::c_type;
 
-  TypedColumnIndexImpl(const ColumnDescriptor& descr,
-                       const format::ColumnIndex& column_index)
-      : column_index_(column_index) {
+  TypedColumnIndexImpl(const ColumnDescriptor& descr, format::ColumnIndex column_index)
+      : column_index_(std::move(column_index)) {
     // Make sure the number of pages is valid and it does not overflow to int32_t.
     const size_t num_pages = column_index_.null_pages.size();
     if (num_pages >= static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
@@ -840,21 +839,29 @@ std::unique_ptr<ColumnIndex> ColumnIndex::Make(const ColumnDescriptor& descr,
                                   &index_len, &column_index);
   switch (descr.physical_type()) {
     case Type::BOOLEAN:
-      return std::make_unique<TypedColumnIndexImpl<BooleanType>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<BooleanType>>(descr,
+                                                                 std::move(column_index));
     case Type::INT32:
-      return std::make_unique<TypedColumnIndexImpl<Int32Type>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<Int32Type>>(descr,
+                                                               std::move(column_index));
     case Type::INT64:
-      return std::make_unique<TypedColumnIndexImpl<Int64Type>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<Int64Type>>(descr,
+                                                               std::move(column_index));
     case Type::INT96:
-      return std::make_unique<TypedColumnIndexImpl<Int96Type>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<Int96Type>>(descr,
+                                                               std::move(column_index));
     case Type::FLOAT:
-      return std::make_unique<TypedColumnIndexImpl<FloatType>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<FloatType>>(descr,
+                                                               std::move(column_index));
     case Type::DOUBLE:
-      return std::make_unique<TypedColumnIndexImpl<DoubleType>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<DoubleType>>(descr,
+                                                                std::move(column_index));
     case Type::BYTE_ARRAY:
-      return std::make_unique<TypedColumnIndexImpl<ByteArrayType>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<ByteArrayType>>(
+          descr, std::move(column_index));
     case Type::FIXED_LEN_BYTE_ARRAY:
-      return std::make_unique<TypedColumnIndexImpl<FLBAType>>(descr, column_index);
+      return std::make_unique<TypedColumnIndexImpl<FLBAType>>(descr,
+                                                              std::move(column_index));
     case Type::UNDEFINED:
       return nullptr;
   }
@@ -876,8 +883,8 @@ std::shared_ptr<PageIndexReader> PageIndexReader::Make(
     ::arrow::io::RandomAccessFile* input, std::shared_ptr<FileMetaData> file_metadata,
     const ReaderProperties& properties,
     std::shared_ptr<InternalFileDecryptor> file_decryptor) {
-  return std::make_shared<PageIndexReaderImpl>(input, file_metadata, properties,
-                                               std::move(file_decryptor));
+  return std::make_shared<PageIndexReaderImpl>(input, std::move(file_metadata),
+                                               properties, std::move(file_decryptor));
 }
 
 std::unique_ptr<ColumnIndexBuilder> ColumnIndexBuilder::Make(

From 798132ce65ee4d7fb902e737e2e7832bf58faaaa Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 30 Aug 2023 16:13:13 -0400
Subject: [PATCH 278/749] GH-37473: [MATLAB] Add support for indexing
 `RecordBatch` columns by `Field` name  (#37475)

### Rationale for this change

Currently, `arrow.tabular.Schema` supports indexing by `Field` name. However, `arrow.tabular.RecordBatch` does not.

This pull request adds the ability to index columns in a `RecordBatch` by `Field` name.

### What changes are included in this PR?

1. Added support for indexing columns in a `RecordBatch` by `Field` name via the `column` method.

**Example**
```matlab
>> recordBatch = arrow.tabular.RecordBatch.fromArrays(...
       arrow.array([1, 2, 3]), ...
       arrow.array(["A", "B", "C"]), ...
       arrow.array([true, false, true]), ...
       ColumnNames=["A", "B", "C"] ...
   )

recordBatch =

A:   [
    1,
    2,
    3
  ]
B:   [
    "A",
    "B",
    "C"
  ]
C:   [
    true,
    false,
    true
  ]

>> recordBatch.column("B")

ans =

[
  "A",
  "B",
  "C"
]

>> recordBatch.column("C")

ans =

[
  true,
  false,
  true
]
```
2. Removed comments about vectorizing `field` method of `Schema` and `column` method of `RecordBatch`. After further consideration, we believe it would make more sense to only allow these methods to accept scalar inputs. We could revisit support for vectorization if we overload the parenthesis operator (e.g. `recordBatch(rows, columns)`)  in the future to return another `RecordBatch`/`Schema` that only includes the selected columns/fields.
3. Fixed typo in `tSchema.m`.

### Are these changes tested?

Yes.

1. Added tests for indexing by column name using the `column` method to `tRecordBatch.m`.

### Are there any user-facing changes?

Yes.

1. Users can now index `RecordBatch` columns by name using the syntax `column(name)`.

### Future Directions

1. Consider overloading parentheses-based indexing on `RecordBatch` and `Schema`.
* Closes: #37473

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../matlab/tabular/proxy/record_batch.cc      |  29 +++
 .../arrow/matlab/tabular/proxy/record_batch.h |   1 +
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  18 +-
 matlab/src/matlab/+arrow/+tabular/Schema.m    |   4 -
 matlab/test/arrow/tabular/tRecordBatch.m      | 165 +++++++++++++++++-
 matlab/test/arrow/tabular/tSchema.m           |   2 +-
 6 files changed, 206 insertions(+), 13 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index 7b81eee21ef70..b785d2cf080d8 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -55,6 +55,7 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(RecordBatch, numColumns);
         REGISTER_METHOD(RecordBatch, columnNames);
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
+        REGISTER_METHOD(RecordBatch, getColumnByName);
         REGISTER_METHOD(RecordBatch, getSchema);
     }
 
@@ -166,6 +167,34 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[1] = array_type_id_mda;
     }
 
+    void RecordBatch::getColumnByName(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::StringArray name_mda = args[0]["Name"];
+        const auto name_utf16 = std::u16string(name_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto name, arrow::util::UTF16StringToUTF8(name_utf16), context, error::UNICODE_CONVERSION_ERROR_ID);
+
+        const std::vector<std::string> names = {name};
+        const auto& schema = record_batch->schema();
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(schema->CanReferenceFieldsByNames(names), context, error::ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME);
+
+        const auto array = record_batch->GetColumnByName(name);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto array_proxy,
+                                            arrow::matlab::array::proxy::wrap(array),
+                                            context,
+                                            error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+
+        const auto array_proxy_id = ProxyManager::manageProxy(array_proxy);
+        const auto array_proxy_id_mda = factory.createScalar(array_proxy_id);
+        const auto array_type_id_mda = factory.createScalar(static_cast<int32_t>(array->type_id()));
+
+        context.outputs[0] = array_proxy_id_mda;
+        context.outputs[1] = array_type_id_mda;
+    }
+
     void RecordBatch::getSchema(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         using namespace libmexclass::proxy;
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index 3ffb8769a1c2d..febf18dd17826 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -38,6 +38,7 @@ namespace arrow::matlab::tabular::proxy {
             void numColumns(libmexclass::proxy::method::Context& context);
             void columnNames(libmexclass::proxy::method::Context& context);
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
+            void getColumnByName(libmexclass::proxy::method::Context& context);
             void getSchema(libmexclass::proxy::method::Context& context);
 
             std::shared_ptr<arrow::RecordBatch> record_batch;
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 8e1fc39ab70ae..b00c99f7a1c51 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -54,13 +54,17 @@
         function arrowArray = column(obj, idx)
             import arrow.internal.validate.*
 
-            idx = index.numeric(idx, "int32");
-            % TODO: Consider vectorizing column() in the future to support
-            % extracting multiple columns at once.
-            validateattributes(idx, "int32", "scalar");
-
-            args = struct(Index=idx);
-            [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);                
+            idx = index.numericOrString(idx, "int32");
+
+            if isnumeric(idx)
+                validateattributes(idx, "int32", "scalar");
+                args = struct(Index=idx);
+                [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);
+            else
+                validateattributes(idx, "string", "scalar");
+                args = struct(Name=idx);
+                [proxyID, typeID] = obj.Proxy.getColumnByName(args);
+            end
             
             traits = arrow.type.traits.traits(arrow.type.ID(typeID));
             proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=proxyID);
diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index b613bd650dfc8..229260a6ffb14 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -48,14 +48,10 @@
             idx = index.numericOrString(idx, "int32");
 
             if isnumeric(idx)
-                % TODO: Consider vectorizing field() to support extracting
-                % multiple fields at once.
                 validateattributes(idx, "int32", "scalar");
                 args = struct(Index=idx);
                 proxyID = obj.Proxy.getFieldByIndex(args);
             else
-                % TODO: Consider vectorizing field() to support extracting
-                % multiple fields at once.
                 validateattributes(idx, "string", "scalar");
                 args = struct(Name=idx);
                 proxyID = obj.Proxy.getFieldByName(args);
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index d9c3c98652b08..6721f2f3ae52b 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -109,7 +109,7 @@ function UnsupportedColumnIndexType(tc)
             TOriginal = table(1, 2, 3);
             arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column(datetime(2022, 1, 3));
-            tc.verifyError(fcn, "arrow:badsubscript:NonNumeric");
+            tc.verifyError(fcn, "arrow:badsubscript:UnsupportedIndexType");
         end
 
         function ErrorIfIndexIsNonScalar(tc)
@@ -223,6 +223,169 @@ function SchemaNoSetter(tc)
                 "MATLAB:class:SetProhibited");
         end
 
+        function GetColumnByName(testCase)
+            % Verify that columns can be accessed by name.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            expected = arrow.array([1, 2, 3]);
+            actual = recordBatch.column("A");
+            testCase.verifyEqual(actual, expected);
+
+            expected = arrow.array(["A", "B", "C"]);
+            actual = recordBatch.column("B");
+            testCase.verifyEqual(actual, expected);
+
+            expected = arrow.array([true, false, true]);
+            actual = recordBatch.column("C");
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function GetColumnByNameWithEmptyString(testCase)
+            % Verify that a column whose name is the empty string ("")
+            % can be accessed using the column() method.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["A", "", "C"] ...
+            );
+
+            expected = arrow.array(["A", "B", "C"]);
+            actual = recordBatch.column("");
+            testCase.verifyEqual(actual, expected)
+        end
+
+        function GetColumnByNameWithWhitespace(testCase)
+            % Verify that a column whose name contains only whitespace
+            % characters can be accessed using the column() method.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=[" ", "  ", "   "] ...
+            );
+
+            expected = arrow.array([1, 2, 3]);
+            actual = recordBatch.column(" ");
+            testCase.verifyEqual(actual, expected);
+
+            expected = arrow.array(["A", "B", "C"]);
+            actual = recordBatch.column("  ");
+            testCase.verifyEqual(actual, expected);
+
+            expected = arrow.array([true, false, true]);
+            actual = recordBatch.column("   ");
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ErrorIfColumnNameDoesNotExist(testCase)
+            % Verify that an error is thrown when trying to access a column
+            % with a name that is not part of the Schema of the RecordBatch.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            % Matching should be case sensitive.
+            name = "a";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "aA";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "D";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = " ";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function ErrorIfAmbiguousColumnName(testCase)
+            % Verify that an error is thrown when trying to access a column
+            % with a name that is ambiguous / occurs more than once in the
+            % Schema of the RecordBatch.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                arrow.array([days(1), days(2), days(3)]), ...
+                ColumnNames=["A", "A", "B", "B"] ...
+            );
+
+            name = "A";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "B";
+            testCase.verifyError(@() recordBatch.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function GetColumnByNameWithChar(testCase)
+            % Verify that the column method works when supplied a char
+            % vector as input.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["", "B", "123"] ...
+            );
+
+            % Should match the first column whose name is the
+            % empty string ("").
+            name = char.empty(0, 0);
+            expected = arrow.array([1, 2, 3]);
+            actual = recordBatch.column(name);
+            testCase.verifyEqual(actual, expected);
+
+            name = char.empty(0, 1);
+            expected = arrow.array([1, 2, 3]);
+            actual = recordBatch.column(name);
+            testCase.verifyEqual(actual, expected);
+
+            name = char.empty(1, 0);
+            expected = arrow.array([1, 2, 3]);
+            actual = recordBatch.column(name);
+            testCase.verifyEqual(actual, expected);
+
+            % Should match the second column whose name is "B".
+            name = 'B';
+            expected = arrow.array(["A", "B", "C"]);
+            actual = recordBatch.column(name);
+            testCase.verifyEqual(actual, expected);
+
+            % Should match the third column whose name is "123".
+            name = '123';
+            expected = arrow.array([true, false, true]);
+            actual = recordBatch.column(name);
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ErrorIfColumnNameIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar string array is
+            % specified as a column name to the column method.
+            recordBatch = arrow.tabular.RecordBatch.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            name = ["A", "B", "C"];
+            testCase.verifyError(@() recordBatch.column(name), "MATLAB:expectedScalar");
+
+            name = ["A";  "B"; "C"];
+            testCase.verifyError(@() recordBatch.column(name), "MATLAB:expectedScalar");
+        end
+
     end
 
     methods
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index dbeb2db1fd57d..45329a2f5fc07 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -429,7 +429,7 @@ function GetFieldByNameWithChar(testCase)
             testCase.verifyEqual(field.Name, "B");
             testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt16);
 
-            % Should match the second field whose name is "123".
+            % Should match the third field whose name is "123".
             fieldName = '123';
             field = schema.field(fieldName);
             testCase.verifyEqual(field.Name, "123");

From 602083be4f9630eda3edaf3ac18a660ccce91468 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 30 Aug 2023 16:24:42 -0400
Subject: [PATCH 279/749] GH-37472: [MATLAB] Implement the `isequal()` method
 on `arrow.type.Type` (#37474)

### Rationale for this change

Currently, it's not possible to determine if two `arrow.type.Type` instances are equal because the `isequal()` method always returns `false` by default:

```matlab

>> t = arrow.int32()

t =

  Int32Type with properties:

    ID: Int32

% Compare a with itself
>> tf = isequal(t, t)

tf =

  logical

   0

```

### What changes are included in this PR?

1. Implemented the `isequal` method on all concrete subclasses of `arrow.type.Type`
2. Added a new method called `isEqual()` on the `arrow::matlab::type::proxy::Type` class.

**Example Usage**

```matlab
>> t1 = arrow.timestamp(TimeUnit="Second");
>> t2 = arrow.timestamp(TimeUnit="Microsecond");
>> t3 = arrow.timestamp(TimeUnit="Second");

% Compare t1 and t2
>> tf1 = isequal(t1, t2)

tf1 =

  logical

   0

% Compare t1 and t3
>> tf2 = isequal(t1, t3)

tf2 =

  logical

   1
```

### Are these changes tested?

Yes. Added test cases verifying `isequal` behaves as expected for all concrete subclasses of `arrow.type.Type`.

### Are there any user-facing changes?

Yes. Users can now use the `isequal` method to compare `arrow.type.Type` instances for equality.

### Future Directions

1. Implement the `isequal` method for `arrow.type.Field`
2. Implement the `isequal` method for `arrow.tabular.Schema`

* Closes: #37472

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/type/proxy/type.cc   | 24 +++++++
 matlab/src/cpp/arrow/matlab/type/proxy/type.h |  2 +
 matlab/src/matlab/+arrow/+type/Type.m         | 35 +++++++++-
 matlab/test/arrow/type/tBooleanType.m         | 36 ++++++++++
 matlab/test/arrow/type/tDate32Type.m          | 34 +++++++++
 matlab/test/arrow/type/tFloat32Type.m         | 36 ++++++++++
 matlab/test/arrow/type/tFloat64Type.m         | 35 ++++++++++
 matlab/test/arrow/type/tInt16Type.m           | 36 ++++++++++
 matlab/test/arrow/type/tInt32Type.m           | 36 ++++++++++
 matlab/test/arrow/type/tInt64Type.m           | 36 ++++++++++
 matlab/test/arrow/type/tInt8Type.m            | 36 ++++++++++
 matlab/test/arrow/type/tStringType.m          | 34 +++++++++
 matlab/test/arrow/type/tTime32Type.m          | 47 +++++++++++++
 matlab/test/arrow/type/tTime64Type.m          | 46 ++++++++++++
 matlab/test/arrow/type/tTimestampType.m       | 70 +++++++++++++++++++
 matlab/test/arrow/type/tUInt16Type.m          | 36 ++++++++++
 matlab/test/arrow/type/tUInt32Type.m          | 36 ++++++++++
 matlab/test/arrow/type/tUInt64Type.m          | 36 ++++++++++
 matlab/test/arrow/type/tUInt8Type.m           | 36 ++++++++++
 19 files changed, 686 insertions(+), 1 deletion(-)

diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
index f6a307ff3f62f..95ff11c07735b 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
@@ -17,11 +17,14 @@
 
 #include "arrow/matlab/type/proxy/type.h"
 
+#include "libmexclass/proxy/ProxyManager.h"
+
 namespace arrow::matlab::type::proxy {
 
     Type::Type(std::shared_ptr<arrow::DataType> type) : data_type{std::move(type)} {
         REGISTER_METHOD(Type, typeID);
         REGISTER_METHOD(Type, numFields);
+        REGISTER_METHOD(Type, isEqual);
     }
 
     std::shared_ptr<arrow::DataType> Type::unwrap() {
@@ -44,5 +47,26 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = num_fields_mda;
     }
 
+    void Type::isEqual(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        const mda::TypedArray<uint64_t> type_proxy_ids = context.inputs[0];
+
+        bool is_equal = true;
+        const auto check_metadata = false;
+        for (const auto& type_proxy_id : type_proxy_ids) {
+            // Retrieve the Type proxy from the ProxyManager
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(type_proxy_id);
+            auto type_proxy = std::static_pointer_cast<proxy::Type>(proxy);
+            auto type_to_compare = type_proxy->unwrap();
+
+            if (!data_type->Equals(type_to_compare, check_metadata)) {
+                is_equal = false;
+                break;
+            }
+        }
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(is_equal);
+    }
 }
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.h b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
index e94097aa73cb4..d528d50d878c5 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
@@ -37,6 +37,8 @@ class Type : public libmexclass::proxy::Proxy {
 
         void numFields(libmexclass::proxy::method::Context& context);
 
+        void isEqual(libmexclass::proxy::method::Context& context);
+
         std::shared_ptr<arrow::DataType> data_type;
 };
 
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index c2ae3dbc58c9c..446649285fdf0 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -48,5 +48,38 @@
           propgrp = matlab.mixin.util.PropertyGroup(proplist);
         end
     end
-    
+
+    methods
+        function tf = isequal(obj, varargin)
+
+            narginchk(2, inf);
+            tf = false;
+            
+            proxyIDs = zeros([numel(obj) numel(varargin)], "uint64");
+
+            for ii = 1:numel(varargin)
+                type = varargin{ii};
+                if ~isa(type, "arrow.type.Type") || ~isequal(size(obj), size(type))
+                    % Return early if type is not an arrow.type.Type or if
+                    % the dimensions of obj and type do not match.
+                    return;
+                end
+
+                % type(:) flattens N-dimensional arrays into a column
+                % vector before collecting the Proxy properties into a
+                % row vector.
+                proxies = [type(:).Proxy];
+                proxyIDs(:, ii) = [proxies.ID];
+            end
+
+            for ii = 1:numel(obj)
+                % Invoke isEqual proxy method on each Type 
+                % in the object array
+                tf = obj(ii).Proxy.isEqual(proxyIDs(ii, :));
+                if ~tf
+                    return;
+                end
+            end
+        end
+    end
 end
diff --git a/matlab/test/arrow/type/tBooleanType.m b/matlab/test/arrow/type/tBooleanType.m
index eaa1c280d5355..673ac8e44ae5c 100644
--- a/matlab/test/arrow/type/tBooleanType.m
+++ b/matlab/test/arrow/type/tBooleanType.m
@@ -22,4 +22,40 @@
         BitWidth = int32(1)
         ClassName = "arrow.type.BooleanType"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.BooleanType returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.BooleanType
+            % 2. All inputs have the same size
+
+            % Scalar BooleanType arrays
+            boolType1 = arrow.boolean();
+            boolType2 = arrow.boolean();
+            testCase.verifyTrue(isequal(boolType1, boolType2));
+
+            % Non-scalar BooleanType arrays
+            typeArray1 = [boolType1 boolType1];
+            typeArray2 = [boolType2 boolType2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.BooleanType returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            boolType = arrow.boolean();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(boolType, int32Type));
+            testCase.verifyFalse(isequal([boolType boolType], [int32Type int32Type]));
+
+            % BooleanType arrays have different sizes
+            typeArray1 = [boolType boolType];
+            typeArray2 = [boolType boolType]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tDate32Type.m b/matlab/test/arrow/type/tDate32Type.m
index 984baa66bbda1..3c99bd1fc9f81 100644
--- a/matlab/test/arrow/type/tDate32Type.m
+++ b/matlab/test/arrow/type/tDate32Type.m
@@ -76,6 +76,40 @@ function InvalidProxy(testCase)
             testCase.verifyError(@() arrow.type.Date32Type(proxy), "arrow:proxy:ProxyNameMismatch");
         end
 
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Date32Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Date32Type
+            % 2. All inputs have the same size
+
+            % Scalar Date32Type arrays
+            date32Type1 = arrow.date32();
+            date32Type2 = arrow.date32();
+            testCase.verifyTrue(isequal(date32Type1, date32Type2));
+
+            % Non-scalar Date32Type arrays
+            typeArray1 = [date32Type1 date32Type1];
+            typeArray2 = [date32Type2 date32Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Date32Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            date32Type = arrow.date32();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(date32Type, int32Type));
+            testCase.verifyFalse(isequal([date32Type date32Type], [int32Type int32Type]));
+
+            % Date32Type arrays have different sizes
+            typeArray1 = [date32Type date32Type];
+            typeArray2 = [date32Type date32Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    
     end
 
 end
diff --git a/matlab/test/arrow/type/tFloat32Type.m b/matlab/test/arrow/type/tFloat32Type.m
index 1837c39a72ed8..d912d5bd76c1a 100644
--- a/matlab/test/arrow/type/tFloat32Type.m
+++ b/matlab/test/arrow/type/tFloat32Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(32)
         ClassName = "arrow.type.Float32Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Float32Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Float32Type
+            % 2. All inputs have the same size
+
+            % Scalar Float32Type arrays
+            float32Type1 = arrow.float32();
+            float32Type2 = arrow.float32();
+            testCase.verifyTrue(isequal(float32Type1, float32Type2));
+
+            % Non-scalar Float32Type arrays
+            typeArray1 = [float32Type1 float32Type1];
+            typeArray2 = [float32Type2 float32Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Float32Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            float32Type = arrow.float32();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(float32Type, int32Type));
+            testCase.verifyFalse(isequal([float32Type float32Type], [int32Type int32Type]));
+
+            % Float32Type arrays have different sizes
+            typeArray1 = [float32Type float32Type];
+            typeArray2 = [float32Type float32Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tFloat64Type.m b/matlab/test/arrow/type/tFloat64Type.m
index 8387a4bf5807b..606e12b2f46cb 100644
--- a/matlab/test/arrow/type/tFloat64Type.m
+++ b/matlab/test/arrow/type/tFloat64Type.m
@@ -21,6 +21,41 @@
         TypeID = arrow.type.ID.Float64
         BitWidth = int32(64)
         ClassName = "arrow.type.Float64Type"
+    end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Float64Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Float64Type
+            % 2. All inputs have the same size
+
+            % Scalar Float64Type arrays
+            float64Type1 = arrow.float64();
+            float64Type2 = arrow.float64();
+            testCase.verifyTrue(isequal(float64Type1, float64Type2));
+
+            % Non-scalar Float64Type arrays
+            typeArray1 = [float64Type1 float64Type1];
+            typeArray2 = [float64Type2 float64Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Float64Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            float64Type = arrow.float64();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(float64Type, int32Type));
+            testCase.verifyFalse(isequal([float64Type float64Type], [int32Type int32Type]));
 
+            % Float64Type arrays have different sizes
+            typeArray1 = [float64Type float64Type];
+            typeArray2 = [float64Type float64Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tInt16Type.m b/matlab/test/arrow/type/tInt16Type.m
index 9b741a32956f5..7e955aa865d0f 100644
--- a/matlab/test/arrow/type/tInt16Type.m
+++ b/matlab/test/arrow/type/tInt16Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(16)
         ClassName = "arrow.type.Int16Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Int16Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Int16Type
+            % 2. All inputs have the same size
+
+            % Scalar Int16Type arrays
+            int16Type1 = arrow.int16();
+            int16Type2 = arrow.int16();
+            testCase.verifyTrue(isequal(int16Type1, int16Type2));
+
+            % Non-scalar Int16Type arrays
+            typeArray1 = [int16Type1 int16Type1];
+            typeArray2 = [int16Type2 int16Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Int16Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            int16Type = arrow.int16();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(int16Type, int32Type));
+            testCase.verifyFalse(isequal([int16Type int16Type], [int32Type int32Type]));
+
+            % Int16Type arrays have different sizes
+            typeArray1 = [int16Type int16Type];
+            typeArray2 = [int16Type int16Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tInt32Type.m b/matlab/test/arrow/type/tInt32Type.m
index 9724f9a4a6a96..16540ef29d9de 100644
--- a/matlab/test/arrow/type/tInt32Type.m
+++ b/matlab/test/arrow/type/tInt32Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(32)
         ClassName = "arrow.type.Int32Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Int32Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Int32Type
+            % 2. All inputs have the same size
+
+            % Scalar Int32Type arrays
+            int32Type1 = arrow.int32();
+            int32Type2 = arrow.int32();
+            testCase.verifyTrue(isequal(int32Type1, int32Type2));
+
+            % Non-scalar Int32Type arrays
+            typeArray1 = [int32Type1 int32Type1];
+            typeArray2 = [int32Type2 int32Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Int32Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            int32Type = arrow.int32();
+            int64Type = arrow.int64();
+            testCase.verifyFalse(isequal(int32Type, int64Type));
+            testCase.verifyFalse(isequal([int32Type int32Type], [int64Type int64Type]));
+
+            % Int32Type arrays have different sizes
+            typeArray1 = [int32Type int32Type];
+            typeArray2 = [int32Type int32Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tInt64Type.m b/matlab/test/arrow/type/tInt64Type.m
index 2acb5fd2d3f1f..2ba9b22139615 100644
--- a/matlab/test/arrow/type/tInt64Type.m
+++ b/matlab/test/arrow/type/tInt64Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(64)
         ClassName = "arrow.type.Int64Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Int64Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Int64Type
+            % 2. All inputs have the same size
+
+            % Scalar Int64Type arrays
+            int64Type1 = arrow.int64();
+            int64Type2 = arrow.int64();
+            testCase.verifyTrue(isequal(int64Type1, int64Type2));
+
+            % Non-scalar Int64Type arrays
+            typeArray1 = [int64Type1 int64Type1];
+            typeArray2 = [int64Type2 int64Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Int64Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            int64Type = arrow.int64();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(int64Type, int32Type));
+            testCase.verifyFalse(isequal([int64Type int64Type], [int32Type int32Type]));
+
+            % Int64Type arrays have different sizes
+            typeArray1 = [int64Type int64Type];
+            typeArray2 = [int64Type int64Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tInt8Type.m b/matlab/test/arrow/type/tInt8Type.m
index 15e2629bc4d68..f37ef8bad188c 100644
--- a/matlab/test/arrow/type/tInt8Type.m
+++ b/matlab/test/arrow/type/tInt8Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(8)
         ClassName = "arrow.type.Int8Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Int8Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Int8Type
+            % 2. All inputs have the same size
+
+            % Scalar Int8Type arrays
+            int8Type1 = arrow.int8();
+            int8Type2 = arrow.int8();
+            testCase.verifyTrue(isequal(int8Type1, int8Type2));
+
+            % Non-scalar Int8Type arrays
+            typeArray1 = [int8Type1 int8Type1];
+            typeArray2 = [int8Type2 int8Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Int8Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            int8Type = arrow.int8();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(int8Type, int32Type));
+            testCase.verifyFalse(isequal([int8Type int8Type], [int32Type int32Type]));
+
+            % Int8Type arrays have different sizes
+            typeArray1 = [int8Type int8Type];
+            typeArray2 = [int8Type int8Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tStringType.m b/matlab/test/arrow/type/tStringType.m
index e52c2cb1cba0b..e2a16ab133dbd 100644
--- a/matlab/test/arrow/type/tStringType.m
+++ b/matlab/test/arrow/type/tStringType.m
@@ -30,6 +30,40 @@ function NumFields(tc)
             tc.verifyEqual(type.NumFields, int32(0));
         end
 
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.StringType returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.StringType
+            % 2. All inputs have the same size
+
+            % Scalar StringType arrays
+            stringType1 = arrow.string();
+            stringType2 = arrow.string();
+            testCase.verifyTrue(isequal(stringType1, stringType2));
+
+            % Non-scalar StringType arrays
+            typeArray1 = [stringType1 stringType1];
+            typeArray2 = [stringType2 stringType2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.StringType returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            stringType = arrow.string();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(stringType, int32Type));
+            testCase.verifyFalse(isequal([stringType stringType], [int32Type int32Type]));
+
+            % StringType arrays have different sizes
+            typeArray1 = [stringType stringType];
+            typeArray2 = [stringType stringType]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+
     end
 
 end
diff --git a/matlab/test/arrow/type/tTime32Type.m b/matlab/test/arrow/type/tTime32Type.m
index d778237588a27..0bb467b1bab4c 100644
--- a/matlab/test/arrow/type/tTime32Type.m
+++ b/matlab/test/arrow/type/tTime32Type.m
@@ -119,6 +119,53 @@ function InvalidProxy(testCase)
             testCase.verifyError(@() arrow.type.Time32Type(proxy), "arrow:proxy:ProxyNameMismatch");
         end
 
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Time32Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Time32Type
+            % 2. All inputs have the same size
+            % 3. The TimeUnit values of elements at corresponding positions in the arrays are equal
+
+            % Scalar Time32Type arrays
+            time32Type1 = arrow.time32(TimeUnit="Second");
+            time32Type2 = arrow.time32(TimeUnit="Second");
+            time32Type3 = arrow.time32(TimeUnit="Millisecond");
+            time32Type4 = arrow.time32(TimeUnit="Millisecond");
+            testCase.verifyTrue(isequal(time32Type1, time32Type2));
+            testCase.verifyTrue(isequal(time32Type3, time32Type4));
+
+            % Non-scalar Time32Type arrays
+            typeArray1 = [time32Type1 time32Type3];
+            typeArray2 = [time32Type2 time32Type4];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+            time32Type1 = arrow.time32(TimeUnit="Second");
+            time32Type2 = arrow.time32(TimeUnit="Millisecond");
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(time32Type1, time32Type2));
+            testCase.verifyFalse(isequal(time32Type1, int32Type));
+
+            % Arrays have different dimensions
+            typeArray1 = [time32Type1 time32Type2];
+            typeArray2 = [time32Type1 time32Type2]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+
+            % Corresponding elements have different TimeUnit values
+            typeArray3 = [time32Type2 time32Type1];
+            typeArray4 = [time32Type1 time32Type2]';
+            testCase.verifyFalse(isequal(typeArray3, typeArray4));
+
+            % Compare a nonscalar Time32Type array with a nonscalar
+            % Int32Type array.
+            typeArray5 = [int32Type int32Type];
+            testCase.verifyFalse(isequal(typeArray3, typeArray5));
+
+        end
+
     end
 
 end
diff --git a/matlab/test/arrow/type/tTime64Type.m b/matlab/test/arrow/type/tTime64Type.m
index a231a76c615fd..01460d9c1b5cd 100644
--- a/matlab/test/arrow/type/tTime64Type.m
+++ b/matlab/test/arrow/type/tTime64Type.m
@@ -120,6 +120,52 @@ function InvalidProxy(testCase)
             testCase.verifyError(@() arrow.type.Time64Type(proxy), "arrow:proxy:ProxyNameMismatch");
         end
 
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Time64Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Time64Type
+            % 2. All inputs have the same size
+            % 3. The TimeUnit values of elements at corresponding positions in the arrays are equal
+
+            % Scalar Time64Type arrays
+            time64Type1 = arrow.time64(TimeUnit="Microsecond");
+            time64Type2 = arrow.time64(TimeUnit="Microsecond");
+            time64Type3 = arrow.time64(TimeUnit="Nanosecond");
+            time64Type4 = arrow.time64(TimeUnit="Nanosecond");
+            testCase.verifyTrue(isequal(time64Type1, time64Type2));
+            testCase.verifyTrue(isequal(time64Type3, time64Type4));
+
+            % Non-scalar Time64Type arrays
+            typeArray1 = [time64Type1 time64Type3];
+            typeArray2 = [time64Type2 time64Type4];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+            time64Type1 = arrow.time64(TimeUnit="Microsecond");
+            time64Type2 = arrow.time64(TimeUnit="Nanosecond");
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(time64Type1, time64Type2));
+            testCase.verifyFalse(isequal(time64Type1, int32Type));
+
+            % arrays have different dimensions
+            typeArray1 = [time64Type1 time64Type2];
+            typeArray2 = [time64Type1 time64Type2]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+
+            % Corresponding elements have different TimeUnit values
+            typeArray3 = [time64Type2 time64Type1];
+            typeArray4 = [time64Type1 time64Type2]';
+            testCase.verifyFalse(isequal(typeArray3, typeArray4));
+
+            % Compare a nonscalar Time64Type array with a nonscalar
+            % Int32Type array.
+            typeArray5 = [int32Type int32Type];
+            testCase.verifyFalse(isequal(typeArray3, typeArray5));
+        end
+
     end
 
 end
diff --git a/matlab/test/arrow/type/tTimestampType.m b/matlab/test/arrow/type/tTimestampType.m
index 348c4b79da2aa..6a626ebde702a 100644
--- a/matlab/test/arrow/type/tTimestampType.m
+++ b/matlab/test/arrow/type/tTimestampType.m
@@ -23,6 +23,12 @@
         ClassName = "arrow.type.TimestampType"
     end
 
+    properties(TestParameter)
+        % Test against both "Zoned" (i.e. non-empty TimeZone value) 
+        % and "Unzoned" (i.e. empty TimeZone value).
+        TimeZone={'America/Anchorage', ''}
+    end
+
     methods(Test)
         function TestClass(testCase)
         % Verify ArrowType is an object of the expected class type.
@@ -128,5 +134,69 @@ function Display(testCase)
             actualDisplay = evalc('disp(type)');
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
+
+        function IsEqualTrue(testCase, TimeZone)
+            % Verifies isequal method of arrow.type.TimestampType returns 
+            % true if these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.TimestampType
+            % 2. All inputs have the same size
+            % 3. The TimeUnit values of elements at corresponding positions in the arrays are equal
+            % 4. The TimeZone values of elements at corresponding positions in the arrays are equal
+
+            % Scalar TimestampType arrays
+            timestampType1 = arrow.timestamp(TimeUnit="Second", TimeZone=TimeZone);
+            timestampType2 = arrow.timestamp(TimeUnit="Second", TimeZone=TimeZone);
+
+            timestampType3 = arrow.timestamp(TimeUnit="Millisecond", TimeZone=TimeZone);
+            time64Type4 = arrow.timestamp(TimeUnit="Millisecond", TimeZone=TimeZone);
+
+            timestampType5 = arrow.timestamp(TimeUnit="Microsecond", TimeZone=TimeZone);
+            timestampType6 = arrow.timestamp(TimeUnit="Microsecond", TimeZone=TimeZone);
+
+            timestampType7 = arrow.timestamp(TimeUnit="Nanosecond", TimeZone=TimeZone);
+            timestampType8 = arrow.timestamp(TimeUnit="Nanosecond", TimeZone=TimeZone);
+
+            % Scalar TimestampType arrays
+            testCase.verifyTrue(isequal(timestampType1, timestampType2));
+            testCase.verifyTrue(isequal(timestampType3, time64Type4));
+            testCase.verifyTrue(isequal(timestampType5, timestampType6));
+            testCase.verifyTrue(isequal(timestampType7, timestampType8));
+
+            % Non-scalar TimestampType arrays
+            typeArray1 = [timestampType1 timestampType3 timestampType5 timestampType7];
+            typeArray2 = [timestampType2 time64Type4 timestampType6 timestampType8];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+
+            timestampType1 = arrow.timestamp(TimeUnit="Second");
+            timestampType2 = arrow.timestamp(TimeUnit="Millisecond");
+            timestampType3 = arrow.timestamp(TimeUnit="Second", TimeZone="America/New_York");
+            timestampType4 = arrow.timestamp(TimeUnit="Second", TimeZone="Pacific/Fiji");
+            timestampType5 = arrow.timestamp(TimeUnit="Millisecond", TimeZone="America/New_York");
+
+            % TimeUnit values differ
+            testCase.verifyFalse(isequal(timestampType1, timestampType2));
+            testCase.verifyFalse(isequal(timestampType4, timestampType5));
+
+            % One TimestampType is zoned, while the other is unzoned.
+            testCase.verifyFalse(isequal(timestampType1, timestampType3));
+
+            % Both TimestampTypes are zoned, but have different values.
+            testCase.verifyFalse(isequal(timestampType3, timestampType4));
+
+            % Different dimensions
+            typeArray1 = [timestampType1 timestampType2 timestampType3];
+            typeArray2 = [timestampType1 timestampType2 timestampType3]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+
+            % Different TimestampType values at corresponding elements
+            typeArray3 = [timestampType1 timestampType3 timestampType4];
+            typeArray4 = [timestampType1 timestampType2 timestampType4];
+            testCase.verifyFalse(isequal(typeArray3, typeArray4));
+        end
     end
 end
diff --git a/matlab/test/arrow/type/tUInt16Type.m b/matlab/test/arrow/type/tUInt16Type.m
index 8a803dc0a7888..31e379a72dd0a 100644
--- a/matlab/test/arrow/type/tUInt16Type.m
+++ b/matlab/test/arrow/type/tUInt16Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(16)
         ClassName = "arrow.type.UInt16Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.UInt16Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.UInt16Type
+            % 2. All inputs have the same size
+
+            % Scalar UInt16Type arrays
+            uint16Type1 = arrow.uint16();
+            uint16Type2 = arrow.uint16();
+            testCase.verifyTrue(isequal(uint16Type1, uint16Type2));
+
+            % Non-scalar UInt16Type arrays
+            typeArray1 = [uint16Type1 uint16Type1];
+            typeArray2 = [uint16Type2 uint16Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.UInt16Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            uint16Type = arrow.uint16();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(uint16Type, int32Type));
+            testCase.verifyFalse(isequal([uint16Type uint16Type], [int32Type int32Type]));
+
+            % UInt16Type arrays have different sizes
+            typeArray1 = [uint16Type uint16Type];
+            typeArray2 = [uint16Type uint16Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tUInt32Type.m b/matlab/test/arrow/type/tUInt32Type.m
index 019b8ce26929d..fcadd3e6dc702 100644
--- a/matlab/test/arrow/type/tUInt32Type.m
+++ b/matlab/test/arrow/type/tUInt32Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(32)
         ClassName = "arrow.type.UInt32Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.UInt32Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.UInt32Type
+            % 2. All inputs have the same size
+
+            % Scalar UInt32Type arrays
+            uint32Type1 = arrow.uint32();
+            uint32Type2 = arrow.uint32();
+            testCase.verifyTrue(isequal(uint32Type1, uint32Type2));
+
+            % Non-scalar UInt32Type arrays
+            typeArray1 = [uint32Type1 uint32Type1];
+            typeArray2 = [uint32Type2 uint32Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.UInt32Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            uint32Type = arrow.uint32();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(uint32Type, int32Type));
+            testCase.verifyFalse(isequal([uint32Type uint32Type], [int32Type int32Type]));
+
+            % UInt32Type arrays have different sizes
+            typeArray1 = [uint32Type uint32Type];
+            typeArray2 = [uint32Type uint32Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tUInt64Type.m b/matlab/test/arrow/type/tUInt64Type.m
index 8287bb40d0052..d1c7627d1c092 100644
--- a/matlab/test/arrow/type/tUInt64Type.m
+++ b/matlab/test/arrow/type/tUInt64Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(64)
         ClassName = "arrow.type.UInt64Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.UInt64Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.UInt64Type
+            % 2. All inputs have the same size
+
+            % Scalar UInt64Type arrays
+            uint64Type1 = arrow.uint64();
+            uint64Type2 = arrow.uint64();
+            testCase.verifyTrue(isequal(uint64Type1, uint64Type2));
+
+            % Non-scalar UInt64Type arrays
+            typeArray1 = [uint64Type1 uint64Type1];
+            typeArray2 = [uint64Type2 uint64Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.UInt64Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            uint64Type = arrow.uint64();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(uint64Type, int32Type));
+            testCase.verifyFalse(isequal([uint64Type uint64Type], [int32Type int32Type]));
+
+            % UInt64Type arrays have different sizes
+            typeArray1 = [uint64Type uint64Type];
+            typeArray2 = [uint64Type uint64Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tUInt8Type.m b/matlab/test/arrow/type/tUInt8Type.m
index 1ff203c862aeb..62a7b95fd014b 100644
--- a/matlab/test/arrow/type/tUInt8Type.m
+++ b/matlab/test/arrow/type/tUInt8Type.m
@@ -22,4 +22,40 @@
         BitWidth = int32(8)
         ClassName = "arrow.type.UInt8Type"
     end
+
+    methods(Test)
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.UInt8Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.UInt8Type
+            % 2. All inputs have the same size
+
+            % Scalar UInt8Type arrays
+            uint8Type1 = arrow.uint8();
+            uint8Type2 = arrow.uint8();
+            testCase.verifyTrue(isequal(uint8Type1, uint8Type2));
+
+            % Non-scalar UInt8Type arrays
+            typeArray1 = [uint8Type1 uint8Type1];
+            typeArray2 = [uint8Type2 uint8Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.UInt8Type returns
+            % false when expected.
+            
+            % Pass a different arrow.type.Type subclass to isequal
+            uint8Type = arrow.uint8();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(uint8Type, int32Type));
+            testCase.verifyFalse(isequal([uint8Type uint8Type], [int32Type int32Type]));
+
+            % UInt8Type arrays have different sizes
+            typeArray1 = [uint8Type uint8Type];
+            typeArray2 = [uint8Type uint8Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+    end
 end
\ No newline at end of file

From 3b8ab8e80a3f37b975c9e8ab4aee8dc708b35d9d Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Wed, 30 Aug 2023 16:36:16 -0400
Subject: [PATCH 280/749] GH-37364: [C++][GPU] Add CUDA impl of Device
 Event/Stream (#37365)

### What changes are included in this PR?
Adding `CudaDevice::SyncEvent` and `CudaDevice::Stream` implementations which provide more idiomatic handling of Events and Streams.

### Are these changes tested?
Simple SyncEvent test added. More stream tests still being added.

* Closes: #37364

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/c/bridge_test.cc    |   4 +-
 cpp/src/arrow/device.h            |  46 +++++++++++--
 cpp/src/arrow/gpu/cuda_context.cc | 106 ++++++++++++++++++++++++++++--
 cpp/src/arrow/gpu/cuda_context.h  |  97 +++++++++++++++++++++++++++
 cpp/src/arrow/gpu/cuda_test.cc    |  59 +++++++++++++++++
 5 files changed, 299 insertions(+), 13 deletions(-)

diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index bd0e498a9f332..2aedccc965c45 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -1222,7 +1222,9 @@ class MyDevice : public Device {
 
     virtual ~MySyncEvent() = default;
     Status Wait() override { return Status::OK(); }
-    Status Record(const Device::Stream&) override { return Status::OK(); }
+    Status Record(const Device::Stream&, const unsigned int) override {
+      return Status::OK();
+    }
   };
 
  protected:
diff --git a/cpp/src/arrow/device.h b/cpp/src/arrow/device.h
index 55037ac418808..066ca7e32a4fe 100644
--- a/cpp/src/arrow/device.h
+++ b/cpp/src/arrow/device.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <string>
 
@@ -109,7 +110,11 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
   /// should be trivially constructible from it's device-specific counterparts.
   class ARROW_EXPORT Stream {
    public:
-    virtual const void* get_raw() const { return NULLPTR; }
+    using release_fn_t = std::function<void(void*)>;
+
+    virtual ~Stream() = default;
+
+    virtual const void* get_raw() const { return stream_.get(); }
 
     /// \brief Make the stream wait on the provided event.
     ///
@@ -117,15 +122,42 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
     /// event is completed without blocking the CPU.
     virtual Status WaitEvent(const SyncEvent&) = 0;
 
+    /// \brief Blocks the current thread until a stream's remaining tasks are completed
+    virtual Status Synchronize() const = 0;
+
    protected:
-    Stream() = default;
-    virtual ~Stream() = default;
+    explicit Stream(void* stream, release_fn_t release_stream)
+        : stream_{stream, release_stream} {}
+
+    std::unique_ptr<void, release_fn_t> stream_;
   };
 
+  virtual Result<std::shared_ptr<Stream>> MakeStream() { return NULLPTR; }
+
+  /// \brief Create a new device stream
+  ///
+  /// This should create the appropriate stream type for the device,
+  /// derived from Device::Stream to allow for stream ordered events
+  /// and memory allocations.
+  virtual Result<std::shared_ptr<Stream>> MakeStream(unsigned int flags) {
+    return NULLPTR;
+  }
+
+  /// @brief Wrap an existing device stream alongside a release function
+  ///
+  /// @param device_stream a pointer to the stream to wrap
+  /// @param release_fn a function to call during destruction, `nullptr` or
+  ///        a no-op function can be passed to indicate ownership is maintained
+  ///        externally
+  virtual Result<std::shared_ptr<Stream>> WrapStream(void* device_stream,
+                                                     Stream::release_fn_t release_fn) {
+    return NULLPTR;
+  }
+
   /// \brief EXPERIMENTAL: An object that provides event/stream sync primitives
   class ARROW_EXPORT SyncEvent {
    public:
-    using release_fn_t = void (*)(void*);
+    using release_fn_t = std::function<void(void*)>;
 
     virtual ~SyncEvent() = default;
 
@@ -134,9 +166,11 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
     /// @brief Block until sync event is completed.
     virtual Status Wait() = 0;
 
+    inline Status Record(const Stream& st) { return Record(st, 0); }
+
     /// @brief Record the wrapped event on the stream so it triggers
     /// the event when the stream gets to that point in its queue.
-    virtual Status Record(const Stream&) = 0;
+    virtual Status Record(const Stream&, const unsigned int flags) = 0;
 
    protected:
     /// If creating this with a passed in event, the caller must ensure
@@ -225,7 +259,7 @@ class ARROW_EXPORT MemoryManager : public std::enable_shared_from_this<MemoryMan
 
   /// \brief Wrap an event into a SyncEvent.
   ///
-  /// @param sync_event passed in sync_event from the imported device array.
+  /// @param sync_event passed in sync_event (should be a pointer to the appropriate type)
   /// @param release_sync_event destructor to free sync_event. `nullptr` may be
   ///        passed to indicate that no destruction/freeing is necessary
   virtual Result<std::shared_ptr<Device::SyncEvent>> WrapDeviceSyncEvent(
diff --git a/cpp/src/arrow/gpu/cuda_context.cc b/cpp/src/arrow/gpu/cuda_context.cc
index 3e1af26cac39b..fb8935319ed1c 100644
--- a/cpp/src/arrow/gpu/cuda_context.cc
+++ b/cpp/src/arrow/gpu/cuda_context.cc
@@ -26,11 +26,10 @@
 #include <utility>
 #include <vector>
 
-#include <cuda.h>
-
 #include "arrow/gpu/cuda_internal.h"
 #include "arrow/gpu/cuda_memory.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/logging.h"
 
 namespace arrow {
 
@@ -273,6 +272,35 @@ bool IsCudaDevice(const Device& device) {
   return device.type_name() == kCudaDeviceTypeName;
 }
 
+Result<std::shared_ptr<Device::Stream>> CudaDevice::MakeStream(unsigned int flags) {
+  ARROW_ASSIGN_OR_RAISE(auto context, GetContext());
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context.get()->handle()));
+
+  CUstream stream;
+  CU_RETURN_NOT_OK("cuStreamCreate", cuStreamCreate(&stream, flags));
+  return std::shared_ptr<Device::Stream>(
+      new CudaDevice::Stream(context, new CUstream(stream), [](void* st) {
+        auto typed_stream = reinterpret_cast<CUstream*>(st);
+        // DCHECK_OK still evaluates its argument in release mode
+        // but in debug mode it'll also throw if it fails
+        DCHECK_OK(
+            internal::StatusFromCuda(cuStreamDestroy(*typed_stream), "cuStreamDestroy"));
+        delete typed_stream;
+      }));
+}
+
+Result<std::shared_ptr<Device::Stream>> CudaDevice::WrapStream(
+    void* stream, Device::Stream::release_fn_t release_fn) {
+  if (!release_fn) {
+    release_fn = [](void*) {};
+  }
+
+  auto cu_stream = reinterpret_cast<CUstream*>(stream);
+  ARROW_ASSIGN_OR_RAISE(auto context, GetContext());
+  return std::shared_ptr<Device::Stream>(
+      new CudaDevice::Stream(context, cu_stream, release_fn));
+}
+
 Result<std::shared_ptr<CudaDevice>> AsCudaDevice(const std::shared_ptr<Device>& device) {
   if (IsCudaDevice(*device)) {
     return checked_pointer_cast<CudaDevice>(device);
@@ -281,6 +309,48 @@ Result<std::shared_ptr<CudaDevice>> AsCudaDevice(const std::shared_ptr<Device>&
   }
 }
 
+Status CudaDevice::Stream::WaitEvent(const Device::SyncEvent& event) {
+  auto cuda_event =
+      checked_cast<const CudaDevice::SyncEvent*, const Device::SyncEvent*>(&event);
+  if (!cuda_event) {
+    return Status::Invalid("CudaDevice::Stream cannot Wait on non-cuda event");
+  }
+
+  auto cu_event = cuda_event->value();
+  if (!cu_event) {
+    return Status::Invalid("Cuda Stream cannot wait on null event");
+  }
+
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+  CU_RETURN_NOT_OK("cuStreamWaitEvent",
+                   cuStreamWaitEvent(value(), cu_event, CU_EVENT_WAIT_DEFAULT));
+  return Status::OK();
+}
+
+Status CudaDevice::Stream::Synchronize() const {
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+  CU_RETURN_NOT_OK("cuStreamSynchronize", cuStreamSynchronize(value()));
+  return Status::OK();
+}
+
+Status CudaDevice::SyncEvent::Wait() {
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+  CU_RETURN_NOT_OK("cuEventSynchronize", cuEventSynchronize(value()));
+  return Status::OK();
+}
+
+Status CudaDevice::SyncEvent::Record(const Device::Stream& st, const unsigned int flags) {
+  auto cuda_stream = checked_cast<const CudaDevice::Stream*, const Device::Stream*>(&st);
+  if (!cuda_stream) {
+    return Status::Invalid("CudaDevice::Event cannot record on non-cuda stream");
+  }
+
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+  CU_RETURN_NOT_OK("cuEventRecordWithFlags",
+                   cuEventRecordWithFlags(value(), cuda_stream->value(), flags));
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // CudaMemoryManager implementation
 
@@ -293,11 +363,35 @@ std::shared_ptr<CudaDevice> CudaMemoryManager::cuda_device() const {
   return checked_pointer_cast<CudaDevice>(device_);
 }
 
+Result<std::shared_ptr<Device::SyncEvent>> CudaMemoryManager::MakeDeviceSyncEvent() {
+  ARROW_ASSIGN_OR_RAISE(auto context, cuda_device()->GetContext());
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context.get()->handle()));
+
+  // TODO: event creation flags
+  CUevent ev;
+  CU_RETURN_NOT_OK("cuEventCreate", cuEventCreate(&ev, CU_EVENT_DEFAULT));
+
+  return std::shared_ptr<Device::SyncEvent>(
+      new CudaDevice::SyncEvent(context, new CUevent(ev), [](void* ev) {
+        auto typed_event = reinterpret_cast<CUevent*>(ev);
+        // DCHECK_OK still evaluates its argument in release mode
+        // but in debug mode it'll also throw if it fails
+        DCHECK_OK(
+            internal::StatusFromCuda(cuEventDestroy(*typed_event), "cuEventDestroy"));
+        delete typed_event;
+      }));
+}
+
 Result<std::shared_ptr<Device::SyncEvent>> CudaMemoryManager::WrapDeviceSyncEvent(
     void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) {
-  return nullptr;
-  // auto ev = reinterpret_cast<CUstream*>(sync_event);
-  // return std::make_shared<CudaDeviceSync>(ev);
+  if (!release_sync_event) {
+    release_sync_event = [](void*) {};
+  }
+
+  auto ev = reinterpret_cast<CUevent*>(sync_event);
+  ARROW_ASSIGN_OR_RAISE(auto context, cuda_device()->GetContext());
+  return std::shared_ptr<Device::SyncEvent>(
+      new CudaDevice::SyncEvent(context, ev, release_sync_event));
 }
 
 Result<std::shared_ptr<io::RandomAccessFile>> CudaMemoryManager::GetBufferReader(
@@ -440,7 +534,7 @@ class CudaDeviceManager::Impl {
   Status AllocateHost(int device_number, int64_t nbytes, uint8_t** out) {
     RETURN_NOT_OK(CheckDeviceNum(device_number));
     ARROW_ASSIGN_OR_RAISE(auto ctx, GetContext(device_number));
-    ContextSaver set_temporary((CUcontext)(ctx.get()->handle()));
+    ContextSaver set_temporary(reinterpret_cast<CUcontext>(ctx.get()->handle()));
     CU_RETURN_NOT_OK("cuMemHostAlloc", cuMemHostAlloc(reinterpret_cast<void**>(out),
                                                       static_cast<size_t>(nbytes),
                                                       CU_MEMHOSTALLOC_PORTABLE));
diff --git a/cpp/src/arrow/gpu/cuda_context.h b/cpp/src/arrow/gpu/cuda_context.h
index 79a2ec9f97581..e4d8482855f6b 100644
--- a/cpp/src/arrow/gpu/cuda_context.h
+++ b/cpp/src/arrow/gpu/cuda_context.h
@@ -21,6 +21,8 @@
 #include <memory>
 #include <string>
 
+#include <cuda.h>
+
 #include "arrow/device.h"
 #include "arrow/result.h"
 #include "arrow/util/visibility.h"
@@ -140,6 +142,90 @@ class ARROW_EXPORT CudaDevice : public Device {
   /// \param[in] size The buffer size in bytes
   Result<std::shared_ptr<CudaHostBuffer>> AllocateHostBuffer(int64_t size);
 
+  /// \brief EXPERIMENTAL: Wrapper for CUstreams
+  ///
+  /// Does not *own* the CUstream object which must be separately constructed
+  /// and freed using cuStreamCreate and cuStreamDestroy (or equivalent).
+  /// Default construction will use the cuda default stream, and does not allow
+  /// construction from literal 0 or nullptr.
+  class ARROW_EXPORT Stream : public Device::Stream {
+   public:
+    ~Stream() = default;
+
+    [[nodiscard]] inline CUstream value() const noexcept {
+      if (!stream_) {
+        return CUstream{};
+      }
+      return *reinterpret_cast<CUstream*>(stream_.get());
+    }
+    operator CUstream() const noexcept { return value(); }
+
+    const void* get_raw() const noexcept override { return stream_.get(); }
+    Status WaitEvent(const Device::SyncEvent&) override;
+    Status Synchronize() const override;
+
+   protected:
+    friend class CudaDevice;
+
+    explicit Stream(std::shared_ptr<CudaContext> ctx, CUstream* st,
+                    Device::Stream::release_fn_t release_fn)
+        : Device::Stream(reinterpret_cast<void*>(st), release_fn),
+          context_{std::move(ctx)} {}
+
+    // disable construction from literal 0
+    explicit Stream(std::shared_ptr<CudaContext>, int,
+                    Device::Stream::release_fn_t) = delete;  // Prevent cast from 0
+    explicit Stream(std::shared_ptr<CudaContext>, std::nullptr_t,
+                    Device::Stream::release_fn_t) = delete;  // Prevent cast from nullptr
+
+   private:
+    std::shared_ptr<CudaContext> context_;
+  };
+
+  Result<std::shared_ptr<Device::Stream>> MakeStream() override { return MakeStream(0); }
+
+  /// \brief Create a CUstream wrapper in the current context
+  Result<std::shared_ptr<Device::Stream>> MakeStream(unsigned int flags) override;
+
+  /// @brief Wrap a pointer to an existing stream
+  ///
+  /// @param device_stream passed in stream (should be a CUstream*)
+  /// @param release_fn destructor to free the stream. `nullptr` may be passed
+  ///        to indicate there is no destruction/freeing necessary.
+  Result<std::shared_ptr<Device::Stream>> WrapStream(
+      void* device_stream, Stream::release_fn_t release_fn) override;
+
+  class ARROW_EXPORT SyncEvent : public Device::SyncEvent {
+   public:
+    [[nodiscard]] CUevent value() const {
+      if (sync_event_) {
+        return *static_cast<CUevent*>(sync_event_.get());
+      }
+      return CUevent{};
+    }
+    operator CUevent() const noexcept { return value(); }
+
+    /// @brief Block until the sync event is marked completed
+    Status Wait() override;
+
+    /// @brief Record the wrapped event on the stream
+    ///
+    /// Once the stream completes the tasks previously added to it,
+    /// it will trigger the event.
+    Status Record(const Device::Stream&, const unsigned int) override;
+
+   protected:
+    friend class CudaMemoryManager;
+
+    explicit SyncEvent(std::shared_ptr<CudaContext> ctx, CUevent* ev,
+                       Device::SyncEvent::release_fn_t release_ev)
+        : Device::SyncEvent(reinterpret_cast<void*>(ev), release_ev),
+          context_{std::move(ctx)} {}
+
+   private:
+    std::shared_ptr<CudaContext> context_;
+  };
+
  protected:
   struct Impl;
 
@@ -179,6 +265,17 @@ class ARROW_EXPORT CudaMemoryManager : public MemoryManager {
   /// having to cast the `device()` result.
   std::shared_ptr<CudaDevice> cuda_device() const;
 
+  /// \brief Creates a wrapped CUevent.
+  ///
+  /// Will call cuEventCreate and it will call cuEventDestroy internally
+  /// when the event is destructed.
+  Result<std::shared_ptr<Device::SyncEvent>> MakeDeviceSyncEvent() override;
+
+  /// \brief Wraps an existing event into a sync event.
+  ///
+  /// @param sync_event the event to wrap, must be a CUevent*
+  /// @param release_sync_event a function to call during destruction, `nullptr` or
+  ///        a no-op function can be passed to indicate ownership is maintained externally
   Result<std::shared_ptr<Device::SyncEvent>> WrapDeviceSyncEvent(
       void* sync_event, Device::SyncEvent::release_fn_t release_sync_event) override;
 
diff --git a/cpp/src/arrow/gpu/cuda_test.cc b/cpp/src/arrow/gpu/cuda_test.cc
index 6d392213e231f..c39dbe28e808a 100644
--- a/cpp/src/arrow/gpu/cuda_test.cc
+++ b/cpp/src/arrow/gpu/cuda_test.cc
@@ -39,9 +39,11 @@
 namespace arrow {
 
 using internal::checked_cast;
+using internal::checked_pointer_cast;
 
 namespace cuda {
 
+using internal::ContextSaver;
 using internal::StatusFromCuda;
 
 #define ASSERT_CUDA_OK(expr) ASSERT_OK(::arrow::cuda::internal::StatusFromCuda((expr)))
@@ -213,6 +215,63 @@ TEST_F(TestCudaDevice, Copy) {
   }
 }
 
+TEST_F(TestCudaDevice, CreateSyncEvent) {
+  ASSERT_OK_AND_ASSIGN(auto ev, mm_->MakeDeviceSyncEvent());
+  ASSERT_TRUE(ev);
+  auto cuda_ev = checked_pointer_cast<CudaDevice::SyncEvent>(ev);
+  ASSERT_CUDA_OK(cuEventQuery(*cuda_ev));
+}
+
+TEST_F(TestCudaDevice, WrapDeviceSyncEvent) {
+  // need a context to call cuEventCreate
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+
+  CUevent event;
+  ASSERT_CUDA_OK(cuEventCreate(&event, CU_EVENT_DEFAULT));
+  ASSERT_CUDA_OK(cuEventQuery(event));
+
+  {
+    // wrap event with no-op destructor
+    ASSERT_OK_AND_ASSIGN(auto ev, mm_->WrapDeviceSyncEvent(&event, [](void*) {}));
+    ASSERT_TRUE(ev);
+    // verify it's the same event we passed in
+    ASSERT_EQ(ev->get_raw(), &event);
+    auto cuda_ev = checked_pointer_cast<CudaDevice::SyncEvent>(ev);
+    ASSERT_CUDA_OK(cuEventQuery(*cuda_ev));
+  }
+
+  // verify that the event is still valid on the device when the shared_ptr
+  // goes away since we didn't give it ownership.
+  ASSERT_CUDA_OK(cuEventQuery(event));
+  ASSERT_CUDA_OK(cuEventDestroy(event));
+}
+
+TEST_F(TestCudaDevice, DefaultStream) {
+  ASSERT_OK_AND_ASSIGN(auto stream, device_->MakeStream());
+  ASSERT_OK_AND_ASSIGN(auto ev, mm_->MakeDeviceSyncEvent());
+
+  ASSERT_OK(ev->Record(*stream));
+  ASSERT_OK(stream->WaitEvent(*ev));
+  ASSERT_OK(ev->Wait());
+  ASSERT_OK(stream->Synchronize());
+}
+
+TEST_F(TestCudaDevice, ExplicitStream) {
+  // need a context to call cuEventCreate
+  ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
+
+  CUstream cu_stream = CU_STREAM_PER_THREAD;
+  {
+    ASSERT_OK_AND_ASSIGN(auto stream, device_->WrapStream(&cu_stream, nullptr));
+    ASSERT_OK_AND_ASSIGN(auto ev, mm_->MakeDeviceSyncEvent());
+
+    ASSERT_OK(ev->Record(*stream));
+    ASSERT_OK(stream->WaitEvent(*ev));
+    ASSERT_OK(ev->Wait());
+    ASSERT_OK(stream->Synchronize());
+  }
+}
+
 // ------------------------------------------------------------------------
 // Test CudaContext
 

From 9b6be29f431705ce1f85cc218c66d4d03698f06b Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 31 Aug 2023 00:32:26 -0400
Subject: [PATCH 281/749] GH-37480: [Python] Bump pandas version that contains
 regression for pandas issue 50127 (#37481)

### Rationale for this change

The pandas issue is now marked for v2.1.1 release.

### What changes are included in this PR?

Bump the pandas version when skipping relevant pytests.

### Are these changes tested?

Yes, CI will verify.

### Are there any user-facing changes?

No
* Closes: #37480

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/tests/test_pandas.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index ef6ddd09933c9..67502af443302 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -457,7 +457,7 @@ def test_mixed_column_names(self):
                                         preserve_index=True)
 
     def test_binary_column_name(self):
-        if Version("2.0.0") <= Version(pd.__version__) < Version("2.1.0"):
+        if Version("2.0.0") <= Version(pd.__version__) < Version("2.2.0"):
             # TODO: regression in pandas, hopefully fixed in next version
             # https://issues.apache.org/jira/browse/ARROW-18394
             # https://github.com/pandas-dev/pandas/issues/50127
@@ -3083,7 +3083,7 @@ def _fully_loaded_dataframe_example():
 
 @pytest.mark.parametrize('columns', ([b'foo'], ['foo']))
 def test_roundtrip_with_bytes_unicode(columns):
-    if Version("2.0.0") <= Version(pd.__version__) < Version("2.1.0"):
+    if Version("2.0.0") <= Version(pd.__version__) < Version("2.2.0"):
         # TODO: regression in pandas, hopefully fixed in next version
         # https://issues.apache.org/jira/browse/ARROW-18394
         # https://github.com/pandas-dev/pandas/issues/50127

From c99d318b3306f704b1fa39bdffe15d62e4c5d43b Mon Sep 17 00:00:00 2001
From: Elliott Brossard <64754120+sfc-gh-ebrossard@users.noreply.github.com>
Date: Thu, 31 Aug 2023 06:01:03 -0700
Subject: [PATCH 282/749] GH-37014: [C++][Parquet] Preserve some Parquet
 distinct counts when merging stats (#37016)

### Rationale for this change

Statistics merging is unnecessarily conservative with respect to preserving distinct counts. If either side is 0, the merge stats can preserve the distinct count, instead of clearing it.

### What changes are included in this PR?

Distinct count is preserved if either the lhs or rhs has a distinct count of 0 when merging stats.

### Are these changes tested?

Yes, added a unit test.

### Are there any user-facing changes?

I don't think this change to stats is considered to be user-facing.
* Closes: #37014

Lead-authored-by: Elliott Brossard <elliott.brossard@snowflake.com>
Co-authored-by: Elliott Brossard <64754120+sfc-gh-ebrossard@users.noreply.github.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/statistics.cc      | 15 ++++--
 cpp/src/parquet/statistics_test.cc | 76 +++++++++++++++++++-----------
 2 files changed, 60 insertions(+), 31 deletions(-)

diff --git a/cpp/src/parquet/statistics.cc b/cpp/src/parquet/statistics.cc
index a10fc2a4cfee7..d5fc71b3958e1 100644
--- a/cpp/src/parquet/statistics.cc
+++ b/cpp/src/parquet/statistics.cc
@@ -562,8 +562,15 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
     } else {
       this->has_null_count_ = false;
     }
-    // Clear has_distinct_count_ as distinct count cannot be merged.
-    has_distinct_count_ = false;
+    if (has_distinct_count_ && other.HasDistinctCount() &&
+        (distinct_count() == 0 || other.distinct_count() == 0)) {
+      // We can merge distinct counts if either side is zero.
+      statistics_.distinct_count =
+          std::max(statistics_.distinct_count, other.distinct_count());
+    } else {
+      // Otherwise clear has_distinct_count_ as distinct count cannot be merged.
+      this->has_distinct_count_ = false;
+    }
     // Do not clear min/max here if the other side does not provide
     // min/max which may happen when other is an empty stats or all
     // its values are null and/or NaN.
@@ -621,7 +628,9 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
       // num_values_ is reliable and it means number of non-null values.
       s.all_null_value = num_values_ == 0;
     }
-    // TODO (GH-36505): distinct count is not encoded for now.
+    if (HasDistinctCount()) {
+      s.set_distinct_count(this->distinct_count());
+    }
     return s;
   }
 
diff --git a/cpp/src/parquet/statistics_test.cc b/cpp/src/parquet/statistics_test.cc
index 76667f0029b99..637832945ec57 100644
--- a/cpp/src/parquet/statistics_test.cc
+++ b/cpp/src/parquet/statistics_test.cc
@@ -601,6 +601,39 @@ class TestStatisticsHasFlag : public TestStatistics<TestType> {
     this->SetUpSchema(Repetition::OPTIONAL);
   }
 
+  std::optional<int64_t> MergeDistinctCount(
+      std::optional<int64_t> initial,
+      const std::vector<std::optional<int64_t>>& subsequent) {
+    EncodedStatistics encoded_statistics;
+    if (initial) {
+      encoded_statistics.has_distinct_count = true;
+      encoded_statistics.distinct_count = *initial;
+    }
+    std::shared_ptr<TypedStatistics<TestType>> statistics =
+        std::dynamic_pointer_cast<TypedStatistics<TestType>>(
+            Statistics::Make(this->schema_.Column(0), &encoded_statistics,
+                             /*num_values=*/1000));
+    for (const auto& distinct_count : subsequent) {
+      EncodedStatistics next_encoded_statistics;
+      if (distinct_count) {
+        next_encoded_statistics.has_distinct_count = true;
+        next_encoded_statistics.distinct_count = *distinct_count;
+      }
+      std::shared_ptr<TypedStatistics<TestType>> next_statistics =
+          std::dynamic_pointer_cast<TypedStatistics<TestType>>(
+              Statistics::Make(this->schema_.Column(0), &next_encoded_statistics,
+                               /*num_values=*/1000));
+      statistics->Merge(*next_statistics);
+    }
+    EncodedStatistics final_statistics = statistics->Encode();
+    EXPECT_EQ(statistics->HasDistinctCount(), final_statistics.has_distinct_count);
+    if (statistics->HasDistinctCount()) {
+      EXPECT_EQ(statistics->distinct_count(), final_statistics.distinct_count);
+      return statistics->distinct_count();
+    }
+    return std::nullopt;
+  }
+
   std::shared_ptr<TypedStatistics<TestType>> MergedStatistics(
       const TypedStatistics<TestType>& stats1, const TypedStatistics<TestType>& stats2) {
     auto chunk_statistics = MakeStatistics<TestType>(this->schema_.Column(0));
@@ -616,35 +649,22 @@ class TestStatisticsHasFlag : public TestStatistics<TestType> {
     ASSERT_NO_FATAL_FAILURE(test_fn(MergedStatistics(stats2, stats1).get()));
   }
 
-  // Distinct count should set to false when Merge is called.
+  // Distinct count should set to false when Merge is called, unless one of the statistics
+  // has a zero count.
   void TestMergeDistinctCount() {
-    // Create a statistics object with distinct count.
-    std::shared_ptr<TypedStatistics<TestType>> statistics1;
-    {
-      EncodedStatistics encoded_statistics1;
-      statistics1 = std::dynamic_pointer_cast<TypedStatistics<TestType>>(
-          Statistics::Make(this->schema_.Column(0), &encoded_statistics1,
-                           /*num_values=*/1000));
-      EXPECT_FALSE(statistics1->HasDistinctCount());
-    }
-
-    // Create a statistics object with distinct count.
-    std::shared_ptr<TypedStatistics<TestType>> statistics2;
-    {
-      EncodedStatistics encoded_statistics2;
-      encoded_statistics2.has_distinct_count = true;
-      encoded_statistics2.distinct_count = 500;
-      statistics2 = std::dynamic_pointer_cast<TypedStatistics<TestType>>(
-          Statistics::Make(this->schema_.Column(0), &encoded_statistics2,
-                           /*num_values=*/1000));
-      EXPECT_TRUE(statistics2->HasDistinctCount());
-    }
-
-    VerifyMergedStatistics(*statistics1, *statistics2,
-                           [](TypedStatistics<TestType>* merged_statistics) {
-                             EXPECT_FALSE(merged_statistics->HasDistinctCount());
-                             EXPECT_FALSE(merged_statistics->Encode().has_distinct_count);
-                           });
+    // Sanity tests.
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(std::nullopt, {}));
+    ASSERT_EQ(10, MergeDistinctCount(10, {}));
+
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(std::nullopt, {0}));
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(std::nullopt, {10, 0}));
+    ASSERT_EQ(10, MergeDistinctCount(10, {0, 0}));
+    ASSERT_EQ(10, MergeDistinctCount(0, {10, 0}));
+    ASSERT_EQ(10, MergeDistinctCount(0, {0, 10}));
+    ASSERT_EQ(10, MergeDistinctCount(0, {0, 10, 0}));
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(10, {0, 10}));
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(10, {0, std::nullopt}));
+    ASSERT_EQ(std::nullopt, MergeDistinctCount(0, {std::nullopt, 0}));
   }
 
   // If all values in a page are null or nan, its stats should not set min-max.

From 323a92f8f533f6fbe2ec7c069486041f9fbd1120 Mon Sep 17 00:00:00 2001
From: Edward Visel <1693477+alistaire47@users.noreply.github.com>
Date: Thu, 31 Aug 2023 08:32:41 -0500
Subject: [PATCH 283/749] MINOR: [Go] Correct benchmark units from bits/s to
 bytes/s (#37479)

### Rationale for this change

We're trying to clean up the set of units used in Conbench, and the Go benchmarks stick out as `b/s` (bits per second), but looking at

https://github.com/apache/arrow/blob/602083be4f9630eda3edaf3ac18a660ccce91468/ci/scripts/go_bench_adapt.py#L86

it looks like they're actually in `B/s` (bytes per second).

### What changes are included in this PR?

Just changing the units submitted to Conbench

### Are these changes tested?

No, but the unit will be validated by the Conbench API

### Are there any user-facing changes?

No

Authored-by: Edward Visel <1693477+alistaire47@users.noreply.github.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/scripts/go_bench_adapt.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/scripts/go_bench_adapt.py b/ci/scripts/go_bench_adapt.py
index 103712f6d8f83..e4eea5c17af37 100644
--- a/ci/scripts/go_bench_adapt.py
+++ b/ci/scripts/go_bench_adapt.py
@@ -95,7 +95,7 @@ def _transform_results(self) -> List[BenchmarkResult]:
                     batch_id=batch_id,
                     stats={
                         "data": [data],
-                        "unit": "b/s",
+                        "unit": "B/s",
                         "times": [time],
                         "time_unit": "i/s",
                         "iterations": benchmark["Runs"],

From 2f3db6580ed59215524f30e09469f0451cb4a6c8 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 31 Aug 2023 10:38:32 -0400
Subject: [PATCH 284/749] GH-37477: [MATLAB] Add `AllowNonScalar` name-value
 pair to arrow.internal.validate.index.* validation functions (#37482)

### Rationale for this change

Per https://github.com/apache/arrow/pull/37475#discussion_r1310732596, we should consider adding a name-value pair like `AllowNonScalar = true | false` to the `arrow.internal.validate.index.*` validation functions since it is relatively common to want to explicitly allow (or disallow) non-scalar inputs to indexing functions (e.g. the `column` method of `RecordBatch` should only support scalar index values).

### What changes are included in this PR?

1. Modified all functions within the `arrow.internal.valdiate.index` package (i.e. `numeric()`, `string()`, and `numericOrString()`)  to accept a name-value pair called `AllowNonScalar`. This name-value pair can be set to `logical` scalar, and by default it's set to `true`.
2. Updated the `column()` method in `RecordBatch` to pass `AllowNonScalar=false` to `numericOrString()`.
3. Updated the `field()` method in `RecordBatch` to pass `AllowNonScalar=false` to `numericOrString()`.

**NOTE:** While character row vectors (e.g. `'ABC'`) are not scalar, they are equivalent to scalar `string` arrays. Therefore, both `string()` and `numericOrString()` do not error if given a character row vector as the index to validate and `AllowNonScalar=false`.

### Are these changes tested?

Yes. Added new test cases to `tNumeric.m`, `tString.m` and `tNumericOrString.m`

### Are there any user-facing changes?

No.

* Closes: #37477

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/+validate/+index/numeric.m      | 13 +++-
 .../+validate/+index/numericOrString.m        | 13 +++-
 .../+internal/+validate/+index/string.m       | 13 +++-
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  4 +-
 matlab/src/matlab/+arrow/+tabular/Schema.m    |  4 +-
 .../arrow/internal/validate/index/tNumeric.m  | 39 ++++++++++-
 .../validate/index/tNumericOrString.m         | 66 +++++++++++++++++++
 .../arrow/internal/validate/index/tString.m   | 43 ++++++++++++
 matlab/test/arrow/tabular/tRecordBatch.m      |  6 +-
 matlab/test/arrow/tabular/tSchema.m           | 12 ++--
 10 files changed, 191 insertions(+), 22 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
index 99bd109b53016..89594139aea57 100644
--- a/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/numeric.m
@@ -19,7 +19,12 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-function index = numeric(index, intType)
+function index = numeric(index, intType, opts)
+    arguments
+        index
+        intType(1, 1) string
+        opts.AllowNonScalar(1, 1) = true
+    end
 
     if ~isnumeric(index)
         errid = "arrow:badsubscript:NonNumeric";
@@ -27,6 +32,12 @@
         error(errid, msg);
     end
 
+    if ~opts.AllowNonScalar && ~isscalar(index)
+        errid = "arrow:badsubscript:NonScalar";
+        msg = "Expected a scalar index value.";
+        error(errid, msg);
+    end
+
      % Convert to full storage if sparse
     if issparse(index)
         index = full(index);
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
index ec4f00503f5d6..7b9e9cda2c7ce 100644
--- a/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/numericOrString.m
@@ -15,14 +15,21 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-function idx = numericOrString(idx, numericIndexType)
+function idx = numericOrString(idx, numericIndexType, opts)
+    arguments
+        idx
+        numericIndexType(1, 1) string
+        opts.AllowNonScalar(1, 1) logical = true
+    end
+
     import arrow.internal.validate.*
 
+    opts = namedargs2cell(opts);
     idx = convertCharsToStrings(idx);
     if isnumeric(idx)
-        idx = index.numeric(idx, numericIndexType);
+        idx = index.numeric(idx, numericIndexType, opts{:});
     elseif isstring(idx)
-        idx = index.string(idx);
+        idx = index.string(idx, opts{:});
     else
         errid = "arrow:badsubscript:UnsupportedIndexType";
         msg = "Indices must be positive integers or nonmissing strings.";
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
index e8c713770af52..ab629c800d6de 100644
--- a/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
+++ b/matlab/src/matlab/+arrow/+internal/+validate/+index/string.m
@@ -14,12 +14,21 @@
 % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
-function index = string(index)
+function index = string(index, opts)
+    arguments
+        index
+        opts.AllowNonScalar(1, 1) = true
+    end
 
     index = convertCharsToStrings(index);
-
     index = reshape(index, [], 1);
 
+    if ~opts.AllowNonScalar && ~isscalar(index)
+        errid = "arrow:badsubscript:NonScalar";
+        msg = "Expected a scalar index value.";
+        error(errid, msg);
+    end
+
     if ~isstring(index)
         errid = "arrow:badsubscript:NonString";
         msg = "Expected string index values.";
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index b00c99f7a1c51..d8c6eb47c6cf7 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -54,14 +54,12 @@
         function arrowArray = column(obj, idx)
             import arrow.internal.validate.*
 
-            idx = index.numericOrString(idx, "int32");
+            idx = index.numericOrString(idx, "int32", AllowNonScalar=false);
 
             if isnumeric(idx)
-                validateattributes(idx, "int32", "scalar");
                 args = struct(Index=idx);
                 [proxyID, typeID] = obj.Proxy.getColumnByIndex(args);
             else
-                validateattributes(idx, "string", "scalar");
                 args = struct(Name=idx);
                 [proxyID, typeID] = obj.Proxy.getColumnByName(args);
             end
diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index 229260a6ffb14..4b4a3d57821b1 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -45,14 +45,12 @@
         function F = field(obj, idx)
             import arrow.internal.validate.*
             
-            idx = index.numericOrString(idx, "int32");
+            idx = index.numericOrString(idx, "int32", AllowNonScalar=false);
 
             if isnumeric(idx)
-                validateattributes(idx, "int32", "scalar");
                 args = struct(Index=idx);
                 proxyID = obj.Proxy.getFieldByIndex(args);
             else
-                validateattributes(idx, "string", "scalar");
                 args = struct(Name=idx);
                 proxyID = obj.Proxy.getFieldByName(args);
             end
diff --git a/matlab/test/arrow/internal/validate/index/tNumeric.m b/matlab/test/arrow/internal/validate/index/tNumeric.m
index a2c07bf79ec3a..e3d1c9d7e51b2 100644
--- a/matlab/test/arrow/internal/validate/index/tNumeric.m
+++ b/matlab/test/arrow/internal/validate/index/tNumeric.m
@@ -128,7 +128,7 @@ function ErrorIfNonNumeric(testCase)
 
             import arrow.internal.validate.index.numeric
 
-            fcn = @() numeric(false);
+            fcn = @() numeric(false, "int32");
             testCase.verifyError(fcn, "arrow:badsubscript:NonNumeric");
         end
 
@@ -161,5 +161,42 @@ function OutputShape(testCase)
             actual = numeric(original, "int32");
             testCase.verifyEqual(actual, expected);
         end
+
+        function AllowNonScalarTrue(testCase)
+            % Verify numeric() behaves as expected provided
+            % AllowNonScalar=true.
+
+            import arrow.internal.validate.index.numeric
+            
+            % Provide a nonscalar array
+            original = [1 2 3]';
+            expected = int32([1 2 3])';
+            actual = numeric(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a scalar array
+            original = 1;
+            expected = int32(1);
+            actual = numeric(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function AllowNonScalarFalse(testCase)
+            % Verify numeric() behaves as expected when provided
+            % AllowNonScalar=false.
+
+            import arrow.internal.validate.index.numeric
+            
+            % Should throw an error when provided a nonscalar double array
+            original = [1 2 3]';
+            fcn = @() numeric(original, "int32", AllowNonScalar=false);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Should not throw an error when provided a scalar double array
+            original = 1;
+            expected = int32(1);
+            actual = numeric(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/index/tNumericOrString.m b/matlab/test/arrow/internal/validate/index/tNumericOrString.m
index 1657a1b24a4a5..f62a0e94cfd05 100644
--- a/matlab/test/arrow/internal/validate/index/tNumericOrString.m
+++ b/matlab/test/arrow/internal/validate/index/tNumericOrString.m
@@ -60,5 +60,71 @@ function ValidStringArray(testCase)
 
             testCase.verifyEqual(numericOrString(["B" "A"], "int32"), ["B", "A"]');
         end
+
+        function AllowNonScalarTrue(testCase)
+            % Verify numericOrString() behaves as expected provided
+            % AllowNonScalar=true.
+
+            import arrow.internal.validate.index.numericOrString
+            
+            % Provide a nonscalar double array
+            original = [1 2 3]';
+            expected = int32([1 2 3])';
+            actual = numericOrString(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a scalar double array
+            original = 1;
+            expected = int32(1);
+            actual = numericOrString(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a nonscalar string array
+            original = ["A", "B", "C"];
+            expected = ["A", "B", "C"]';
+            actual = numericOrString(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a scalar string array
+            original = "A";
+            expected = "A";
+            actual = numericOrString(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function AllowNonScalarFalse(testCase)
+            % Verify numericOrString() behaves as expected when provided
+            % AllowNonScalar=false.
+
+            import arrow.internal.validate.index.numericOrString
+            
+            % Should throw an error when provided a nonscalar double array
+            original = [1 2 3]';
+            fcn = @() numericOrString(original, "int32", AllowNonScalar=false);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Should not throw an error when provided a scalar double array
+            original = 1;
+            expected = int32(1);
+            actual = numericOrString(original, "int32", AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Should throw an error if provided a nonscalar string array
+            original = ["A", "B", "C"];
+            fcn = @() numericOrString(original, "int32", AllowNonScalar=false);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Should not throw an error if provided a scalar string array
+            original = "A";
+            expected = "A";
+            actual = numericOrString(original, "int32", AllowNonScalar=false);
+            testCase.verifyEqual(actual, expected);
+
+            % Should not throw an error if provided a character row vector
+            original = 'ABC';
+            expected = "ABC";
+            actual = numericOrString(original, "int32", AllowNonScalar=false);
+            testCase.verifyEqual(actual, expected);
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/internal/validate/index/tString.m b/matlab/test/arrow/internal/validate/index/tString.m
index 2e6bf020d6cf4..e8e27024ea84f 100644
--- a/matlab/test/arrow/internal/validate/index/tString.m
+++ b/matlab/test/arrow/internal/validate/index/tString.m
@@ -113,5 +113,48 @@ function OutputShape(testCase)
             actual = index.string(original);
             testCase.verifyEqual(actual, expected);
         end
+
+        function AllowNonScalarTrue(testCase)
+            % Verify string() behaves as expected provided
+            % AllowNonScalar=true.
+
+            import arrow.internal.validate.*
+            
+            % Provide a nonscalar string array
+            original = ["A", "B", "C"];
+            expected = ["A", "B", "C"]';
+            actual = index.string(original, AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+
+            % Provide a scalar string array
+            original = "A";
+            expected = "A";
+            actual = index.string(original, AllowNonScalar=true);
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function AllowNonScalarFalse(testCase)
+            % Verify string() behaves as expected when provided
+            % AllowNonScalar=false.
+
+            import arrow.internal.validate.*
+            
+            % Should throw an error if provided a nonscalar string array
+            original = ["A", "B", "C"];
+            fcn = @() index.string(original, AllowNonScalar=false);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Should not throw an error if provided a scalar string array
+            original = "A";
+            expected = "A";
+            actual = index.string(original, AllowNonScalar=false);
+            testCase.verifyEqual(actual, expected);
+
+            % Should not throw an error if provided a character row vector
+            original = 'ABC';
+            expected = "ABC";
+            actual = index.string(original, AllowNonScalar=false);
+            testCase.verifyEqual(actual, expected);
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index 6721f2f3ae52b..f4b156a377047 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -116,7 +116,7 @@ function ErrorIfIndexIsNonScalar(tc)
             TOriginal = table(1, 2, 3);
             arrowRecordBatch = arrow.recordBatch(TOriginal);
             fcn = @() arrowRecordBatch.column([1 2]);
-            tc.verifyError(fcn, "MATLAB:expectedScalar");
+            tc.verifyError(fcn, "arrow:badsubscript:NonScalar");
         end
 
         function ErrorIfIndexIsNonPositive(tc)
@@ -380,10 +380,10 @@ function ErrorIfColumnNameIsNonScalar(testCase)
             );
 
             name = ["A", "B", "C"];
-            testCase.verifyError(@() recordBatch.column(name), "MATLAB:expectedScalar");
+            testCase.verifyError(@() recordBatch.column(name), "arrow:badsubscript:NonScalar");
 
             name = ["A";  "B"; "C"];
-            testCase.verifyError(@() recordBatch.column(name), "MATLAB:expectedScalar");
+            testCase.verifyError(@() recordBatch.column(name), "arrow:badsubscript:NonScalar");
         end
 
     end
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index 45329a2f5fc07..b57ebffbc577e 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -139,7 +139,7 @@ function ErrorIfUnsupportedFieldIndex(testCase)
             ]);
 
             index = [];
-            testCase.verifyError(@() schema.field(index), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonScalar");
 
             index = 0;
             testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonPositive");
@@ -157,7 +157,7 @@ function ErrorIfUnsupportedFieldIndex(testCase)
             testCase.verifyError(@() schema.field(index), "arrow:badsubscript:UnsupportedIndexType");
 
             index = [1; 1];
-            testCase.verifyError(@() schema.field(index), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(index), "arrow:badsubscript:NonScalar");
         end
 
         function GetFieldByIndex(testCase)
@@ -446,10 +446,10 @@ function ErrorIfNumericIndexIsNonScalar(testCase)
             ]);
 
             fieldName = [1, 2, 3];
-            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(fieldName), "arrow:badsubscript:NonScalar");
 
             fieldName = [1; 2; 3];
-            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(fieldName), "arrow:badsubscript:NonScalar");
         end
 
         function ErrorIfFieldNameIsNonScalar(testCase)
@@ -462,10 +462,10 @@ function ErrorIfFieldNameIsNonScalar(testCase)
             ]);
 
             fieldName = ["A", "B", "C"];
-            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(fieldName), "arrow:badsubscript:NonScalar");
 
             fieldName = ["A";  "B"; "C"];
-            testCase.verifyError(@() schema.field(fieldName), "MATLAB:expectedScalar");
+            testCase.verifyError(@() schema.field(fieldName), "arrow:badsubscript:NonScalar");
         end
 
     end

From e8c39fbcce0add78e93be6723a30dec072f9ce4e Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 1 Sep 2023 00:09:53 +0900
Subject: [PATCH 285/749] GH-37485: [C++][Skyhook] Don't use deprecated
 BufferReader API (#37486)

### Rationale for this change

GH-37360 deprecated `BufferReader(const uint8_t*, int64_t)`.

### What changes are included in this PR?

Use `BufferReader(std::shared_ptr<Buffer>)` instead.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37485

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/skyhook/protocol/skyhook_protocol.cc | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/cpp/src/skyhook/protocol/skyhook_protocol.cc b/cpp/src/skyhook/protocol/skyhook_protocol.cc
index f83b124553b1c..3b1234c6ed913 100644
--- a/cpp/src/skyhook/protocol/skyhook_protocol.cc
+++ b/cpp/src/skyhook/protocol/skyhook_protocol.cc
@@ -73,10 +73,12 @@ arrow::Status DeserializeScanRequest(ceph::bufferlist& bl, ScanRequest* req) {
   req->partition_expression = partition_expression;
 
   arrow::ipc::DictionaryMemo empty_memo;
-  arrow::io::BufferReader projection_schema_reader(request->projection_schema()->data(),
-                                                   request->projection_schema()->size());
-  arrow::io::BufferReader dataset_schema_reader(request->dataset_schema()->data(),
-                                                request->dataset_schema()->size());
+  auto projection_schema_buffer = std::make_shared<arrow::Buffer>(
+      request->projection_schema()->data(), request->projection_schema()->size());
+  arrow::io::BufferReader projection_schema_reader(std::move(projection_schema_buffer));
+  auto dataset_schema_buffer = std::make_shared<arrow::Buffer>(
+      request->dataset_schema()->data(), request->dataset_schema()->size());
+  arrow::io::BufferReader dataset_schema_reader(std::move(dataset_schema_buffer));
 
   ARROW_ASSIGN_OR_RAISE(req->projection_schema,
                         arrow::ipc::ReadSchema(&projection_schema_reader, &empty_memo));

From d7b4d2d5f7491a788649ccc0a9f61d3212a6e438 Mon Sep 17 00:00:00 2001
From: Matthias Loibl <mail@matthiasloibl.com>
Date: Thu, 31 Aug 2023 16:35:04 +0100
Subject: [PATCH 286/749] GH-37465: [Go] Add Value method to BooleanBuilder
 (#37459)

### Rationale for this change

Similar to the changes we've made in #35744 we need this for the BooleanBuilder too.

### What changes are included in this PR?

Adding the method itself and adjusting a test to test both the Value method on the builder and the final array.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Just an enhancement to get on-par with other builders.

* Closes: #37465

Authored-by: Matthias Loibl <mail@matthiasloibl.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/booleanbuilder.go      |  4 ++++
 go/arrow/array/booleanbuilder_test.go | 11 ++++++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/go/arrow/array/booleanbuilder.go b/go/arrow/array/booleanbuilder.go
index f4a5ba9816dfc..10b7405aa5b2a 100644
--- a/go/arrow/array/booleanbuilder.go
+++ b/go/arrow/array/booleanbuilder.go
@@ -254,6 +254,10 @@ func (b *BooleanBuilder) UnmarshalJSON(data []byte) error {
 	return b.Unmarshal(dec)
 }
 
+func (b *BooleanBuilder) Value(i int) bool {
+	return bitutil.BitIsSet(b.rawData, i)
+}
+
 var (
 	_ Builder = (*BooleanBuilder)(nil)
 )
diff --git a/go/arrow/array/booleanbuilder_test.go b/go/arrow/array/booleanbuilder_test.go
index 702b0ca554f00..e270636a87b1c 100644
--- a/go/arrow/array/booleanbuilder_test.go
+++ b/go/arrow/array/booleanbuilder_test.go
@@ -32,12 +32,21 @@ func TestBooleanBuilder_AppendValues(t *testing.T) {
 	b := array.NewBooleanBuilder(mem)
 
 	exp := tools.Bools(1, 1, 0, 1, 1, 0)
-	got := make([]bool, len(exp)+2)
 
 	b.AppendValues(exp, nil)
 	assert.NoError(t, b.AppendValueFromString("true"))
 	assert.NoError(t, b.AppendValueFromString("false"))
 	exp = tools.Bools(1, 1, 0, 1, 1, 0, 1, 0)
+
+	got := make([]bool, len(exp))
+	// make sure we can read the values directly from the builder.
+	for i := 0; i < b.Len(); i++ {
+		got[i] = b.Value(i)
+	}
+	assert.Equal(t, exp, got)
+
+	got = make([]bool, len(exp)) // reset
+
 	a := b.NewBooleanArray()
 	b.Release()
 	for i := 0; i < a.Len(); i++ {

From 58c2c3716c5cc308f17708ba98e41137dec0fc51 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 31 Aug 2023 16:49:39 +0100
Subject: [PATCH 287/749] GH-37456: [R] CRAN incoming checks show NOTE due to
 internal function which isn't documented (#37457)

### Rationale for this change

Failed CRAN check due to updates to their checks on R-devel

### What changes are included in this PR?

Add additional roxygen header

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37456

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/dplyr-funcs.R         | 2 ++
 r/man/enums.Rd            | 2 +-
 r/man/register_binding.Rd | 8 ++++++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/r/R/dplyr-funcs.R b/r/R/dplyr-funcs.R
index 2728a64539657..956e31fe2bfdd 100644
--- a/r/R/dplyr-funcs.R
+++ b/r/R/dplyr-funcs.R
@@ -123,6 +123,8 @@ unregister_binding <- function(fun_name, registry = nse_funcs,
   invisible(previous_fun)
 }
 
+#' @rdname register_binding
+#' @keywords internal
 register_binding_agg <- function(fun_name,
                                  agg_fun,
                                  registry = agg_funcs,
diff --git a/r/man/enums.Rd b/r/man/enums.Rd
index 853fa07028fa6..dd0ca944b8c66 100644
--- a/r/man/enums.Rd
+++ b/r/man/enums.Rd
@@ -24,7 +24,7 @@ An object of class \code{TimeUnit::type} (inherits from \code{arrow-enum}) of le
 
 An object of class \code{DateUnit} (inherits from \code{arrow-enum}) of length 2.
 
-An object of class \code{Type::type} (inherits from \code{arrow-enum}) of length 37.
+An object of class \code{Type::type} (inherits from \code{arrow-enum}) of length 39.
 
 An object of class \code{StatusCode} (inherits from \code{arrow-enum}) of length 13.
 
diff --git a/r/man/register_binding.Rd b/r/man/register_binding.Rd
index fd857f5c67498..d10cd733bbe9d 100644
--- a/r/man/register_binding.Rd
+++ b/r/man/register_binding.Rd
@@ -2,6 +2,7 @@
 % Please edit documentation in R/dplyr-funcs.R
 \name{register_binding}
 \alias{register_binding}
+\alias{register_binding_agg}
 \title{Register compute bindings}
 \usage{
 register_binding(
@@ -11,6 +12,13 @@ register_binding(
   update_cache = FALSE,
   notes = character(0)
 )
+
+register_binding_agg(
+  fun_name,
+  agg_fun,
+  registry = agg_funcs,
+  notes = character(0)
+)
 }
 \arguments{
 \item{fun_name}{A string containing a function name in the form \code{"function"} or

From c6e21803672693e8b406989b780716c04b36807a Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 31 Aug 2023 16:50:32 +0100
Subject: [PATCH 288/749] GH-37463:  [R] CRAN incoming checks fail due to test
 run length  (#37464)

### Rationale for this change

Initial CRAN checks fail as it takes too long to run

### What changes are included in this PR?

Skip tests for dplyr function bindings on CRAN

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37463

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/test-dplyr-funcs-conditional.R | 2 ++
 r/tests/testthat/test-dplyr-funcs-datetime.R    | 2 ++
 r/tests/testthat/test-dplyr-funcs-math.R        | 2 ++
 r/tests/testthat/test-dplyr-funcs-string.R      | 2 ++
 r/tests/testthat/test-dplyr-funcs-type.R        | 2 ++
 r/tests/testthat/test-dplyr-funcs.R             | 3 +++
 6 files changed, 13 insertions(+)

diff --git a/r/tests/testthat/test-dplyr-funcs-conditional.R b/r/tests/testthat/test-dplyr-funcs-conditional.R
index e60712e9e618c..52edc25a67f5a 100644
--- a/r/tests/testthat/test-dplyr-funcs-conditional.R
+++ b/r/tests/testthat/test-dplyr-funcs-conditional.R
@@ -19,6 +19,8 @@ library(dplyr, warn.conflicts = FALSE)
 suppressPackageStartupMessages(library(bit64))
 
 skip_if_not_available("acero")
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
 
 tbl <- example_data
 tbl$verses <- verses[[1]]
diff --git a/r/tests/testthat/test-dplyr-funcs-datetime.R b/r/tests/testthat/test-dplyr-funcs-datetime.R
index d59356ad659ce..bcd2584851b70 100644
--- a/r/tests/testthat/test-dplyr-funcs-datetime.R
+++ b/r/tests/testthat/test-dplyr-funcs-datetime.R
@@ -22,6 +22,8 @@ library(lubridate, warn.conflicts = FALSE)
 library(dplyr, warn.conflicts = FALSE)
 
 skip_if_not_available("acero")
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
 
 # base::strptime() defaults to local timezone
 # but arrow's strptime defaults to UTC.
diff --git a/r/tests/testthat/test-dplyr-funcs-math.R b/r/tests/testthat/test-dplyr-funcs-math.R
index 733a7c6ea0642..1057f7ae06eb0 100644
--- a/r/tests/testthat/test-dplyr-funcs-math.R
+++ b/r/tests/testthat/test-dplyr-funcs-math.R
@@ -18,6 +18,8 @@
 library(dplyr, warn.conflicts = FALSE)
 
 skip_if_not_available("acero")
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
 
 test_that("abs()", {
   df <- tibble(x = c(-127, -10, -1, -0, 0, 1, 10, 127, NA))
diff --git a/r/tests/testthat/test-dplyr-funcs-string.R b/r/tests/testthat/test-dplyr-funcs-string.R
index 1cebec9dddac3..411b5ae3c738a 100644
--- a/r/tests/testthat/test-dplyr-funcs-string.R
+++ b/r/tests/testthat/test-dplyr-funcs-string.R
@@ -17,6 +17,8 @@
 
 skip_if_not_available("utf8proc")
 skip_if_not_available("acero")
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
 
 library(dplyr, warn.conflicts = FALSE)
 library(lubridate)
diff --git a/r/tests/testthat/test-dplyr-funcs-type.R b/r/tests/testthat/test-dplyr-funcs-type.R
index 435fa5fcb87df..2624e16156bce 100644
--- a/r/tests/testthat/test-dplyr-funcs-type.R
+++ b/r/tests/testthat/test-dplyr-funcs-type.R
@@ -20,6 +20,8 @@ suppressPackageStartupMessages(library(bit64))
 suppressPackageStartupMessages(library(lubridate))
 
 skip_if_not_available("acero")
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
 
 tbl <- example_data
 
diff --git a/r/tests/testthat/test-dplyr-funcs.R b/r/tests/testthat/test-dplyr-funcs.R
index 48b74c9af43f1..039604a85ee0c 100644
--- a/r/tests/testthat/test-dplyr-funcs.R
+++ b/r/tests/testthat/test-dplyr-funcs.R
@@ -15,6 +15,9 @@
 # specific language governing permissions and limitations
 # under the License.
 
+# Skip these tests on CRAN due to build times > 10 mins
+skip_on_cran()
+
 test_that("register_binding()/unregister_binding() works", {
   fake_registry <- new.env(parent = emptyenv())
   fun1 <- function() NULL

From d14c10b8ced99d5b87ebdb390138301736f55070 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 31 Aug 2023 16:51:34 +0100
Subject: [PATCH 289/749] GH-37431: [R] Tests failing for R versions < 4.0
 because of use of base pipe (|>) in tests (#37432)

### Rationale for this change

Nightly builds using R versions < 4.0 fail due usage of newer syntax

### What changes are included in this PR?

Use older syntax

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37431

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/test-dataset-write.R | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/r/tests/testthat/test-dataset-write.R b/r/tests/testthat/test-dataset-write.R
index e2c3c68b50227..28ff308747584 100644
--- a/r/tests/testthat/test-dataset-write.R
+++ b/r/tests/testthat/test-dataset-write.R
@@ -945,7 +945,7 @@ test_that("Dataset can write flat files using readr::write_csv() options.", {
   dst_dir <- make_temp_dir()
   write_dataset(df, dst_dir, format = "csv", quoting_style = "AllValid")
   ds <- open_dataset(dst_dir, format = "csv")
-  expect_equal(df, ds |> collect())
+  expect_equal(df, ds %>% collect())
 
   lines <- paste(readLines(paste0(dst_dir, "/part-0.csv")), sep = "\n")
   expect_equal(lines[2], "\"1\",\"1\",\"true\",\"a\"")
@@ -995,7 +995,7 @@ test_that("Dataset write wrappers can write flat files using readr::write_csv()
   dst_dir <- make_temp_dir()
   write_csv_dataset(df, dst_dir, quote = "all", delim = ";")
   ds <- open_dataset(dst_dir, format = "csv", delim = ";")
-  expect_equal(df, ds |> collect())
+  expect_equal(df, ds %>% collect())
 
   lines <- paste(readLines(paste0(dst_dir, "/part-0.csv")), sep = "\n")
   expect_equal(lines[2], "\"1\";\"1\";\"true\";\"a\"")
@@ -1003,13 +1003,13 @@ test_that("Dataset write wrappers can write flat files using readr::write_csv()
   dst_dir <- make_temp_dir()
   write_tsv_dataset(df, dst_dir, quote = "all", eol = "\r\n")
   ds <- open_dataset(dst_dir, format = "tsv")
-  expect_equal(df, ds |> collect())
+  expect_equal(df, ds %>% collect())
 
   lines <- paste(readLines(paste0(dst_dir, "/part-0.tsv")), sep = "\n")
   expect_equal(lines[2], "\"1\"\t\"1\"\t\"true\"\t\"a\"")
   dst_dir <- make_temp_dir()
   write_tsv_dataset(df, dst_dir, na = "NOVALUE")
-  ds <- open_dataset(dst_dir, format = "tsv") |> collect()
+  ds <- open_dataset(dst_dir, format = "tsv") %>% collect()
 
   expect_equal(
     ds$lgl,

From 66d948dc84b1ee7c403a11ebf354ef006e2f636b Mon Sep 17 00:00:00 2001
From: Gang Wu <ustcwg@gmail.com>
Date: Fri, 1 Sep 2023 00:55:37 +0800
Subject: [PATCH 290/749] GH-36882: [C++][Parquet] Default RLE for bool values
 in the parquet version 2.x (#36955)

### Rationale for this change

RLE is usually more efficient than PLAIN encoding for boolean columns, and it is already enabled by default in parquet-mr and arrow-rs.

### What changes are included in this PR?

* Slight breaking change in ColumnProperties to set default encoding to UNKNOWN (used to be PLAIN).
* If UNKNOWN is given, let the column writer decide the column encoding according to the selected Parquet format version and the column type.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes, default encoding of boolean type has been switched to RLE when the selected Parquet format version is at least 2.0 (the current default version is 2.6). It used to always be PLAIN.

* Closes: #36882

Authored-by: Gang Wu <ustcwg@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/column_writer.cc              |  6 +++
 cpp/src/parquet/column_writer_test.cc         | 53 +++++++++++++------
 cpp/src/parquet/properties.h                  |  2 +-
 python/pyarrow/tests/parquet/test_metadata.py |  2 +-
 4 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 3fca5542a0733..ae9216ba7c312 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -2332,6 +2332,12 @@ std::shared_ptr<ColumnWriter> ColumnWriter::Make(ColumnChunkMetaDataBuilder* met
   const bool use_dictionary = properties->dictionary_enabled(descr->path()) &&
                               descr->physical_type() != Type::BOOLEAN;
   Encoding::type encoding = properties->encoding(descr->path());
+  if (encoding == Encoding::UNKNOWN) {
+    encoding = (descr->physical_type() == Type::BOOLEAN &&
+                properties->version() != ParquetVersion::PARQUET_1_0)
+                   ? Encoding::RLE
+                   : Encoding::PLAIN;
+  }
   if (use_dictionary) {
     encoding = properties->dictionary_index_encoding();
   }
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index 58199c402bd7a..b2fd9cf930823 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -203,8 +203,15 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
 
     if (this->type_num() == Type::BOOLEAN) {
       // Dictionary encoding is not allowed for boolean type
-      // There are 2 encodings (PLAIN, RLE) in a non dictionary encoding case
-      std::set<Encoding::type> expected({Encoding::PLAIN, Encoding::RLE});
+      std::set<Encoding::type> expected;
+      if (version == ParquetVersion::PARQUET_1_0) {
+        // There are 2 encodings (PLAIN, RLE) in a non dictionary encoding case for
+        // version 1.0. Note that RLE is used for DL/RL.
+        expected = {Encoding::PLAIN, Encoding::RLE};
+      } else {
+        // There is only 1 encoding (RLE) in a fallback case for version 2.0
+        expected = {Encoding::RLE};
+      }
       ASSERT_EQ(encodings, expected);
     } else if (version == ParquetVersion::PARQUET_1_0) {
       // There are 3 encodings (PLAIN_DICTIONARY, PLAIN, RLE) in a fallback case
@@ -223,7 +230,8 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     std::vector<parquet::PageEncodingStats> encoding_stats =
         this->metadata_encoding_stats();
     if (this->type_num() == Type::BOOLEAN) {
-      ASSERT_EQ(encoding_stats[0].encoding, Encoding::PLAIN);
+      ASSERT_EQ(encoding_stats[0].encoding,
+                version == ParquetVersion::PARQUET_1_0 ? Encoding::PLAIN : Encoding::RLE);
       ASSERT_EQ(encoding_stats[0].page_type, PageType::DATA_PAGE);
     } else if (version == ParquetVersion::PARQUET_1_0) {
       std::vector<Encoding::type> expected(
@@ -757,21 +765,36 @@ TEST_F(TestValuesWriterInt32Type, OptionalNullValueChunk) {
   ASSERT_EQ(0, this->values_read_);
 }
 
+class TestBooleanValuesWriter : public TestPrimitiveWriter<BooleanType> {
+ public:
+  void TestWithEncoding(ParquetVersion::type version, Encoding::type encoding) {
+    this->SetUpSchema(Repetition::REQUIRED);
+    auto writer = this->BuildWriter(SMALL_SIZE, ColumnProperties(), version,
+                                    /*enable_checksum*/ false);
+    for (int i = 0; i < SMALL_SIZE; i++) {
+      bool value = (i % 2 == 0) ? true : false;
+      writer->WriteBatch(1, nullptr, nullptr, &value);
+    }
+    writer->Close();
+    this->ReadColumn();
+    for (int i = 0; i < SMALL_SIZE; i++) {
+      ASSERT_EQ((i % 2 == 0) ? true : false, this->values_out_[i]) << i;
+    }
+    const auto& encodings = this->metadata_encodings();
+    auto iter = std::find(encodings.begin(), encodings.end(), encoding);
+    ASSERT_TRUE(iter != encodings.end());
+  }
+};
+
 // PARQUET-764
 // Correct bitpacking for boolean write at non-byte boundaries
-using TestBooleanValuesWriter = TestPrimitiveWriter<BooleanType>;
 TEST_F(TestBooleanValuesWriter, AlternateBooleanValues) {
-  this->SetUpSchema(Repetition::REQUIRED);
-  auto writer = this->BuildWriter();
-  for (int i = 0; i < SMALL_SIZE; i++) {
-    bool value = (i % 2 == 0) ? true : false;
-    writer->WriteBatch(1, nullptr, nullptr, &value);
-  }
-  writer->Close();
-  this->ReadColumn();
-  for (int i = 0; i < SMALL_SIZE; i++) {
-    ASSERT_EQ((i % 2 == 0) ? true : false, this->values_out_[i]) << i;
-  }
+  TestWithEncoding(ParquetVersion::PARQUET_1_0, Encoding::PLAIN);
+}
+
+// Default encoding for boolean is RLE when using V2 pages
+TEST_F(TestBooleanValuesWriter, RleEncodedBooleanValues) {
+  TestWithEncoding(ParquetVersion::PARQUET_2_4, Encoding::RLE);
 }
 
 // PARQUET-979
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index bd7eb9dc7abd6..bdc5b15332d09 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -135,7 +135,7 @@ static constexpr int64_t DEFAULT_WRITE_BATCH_SIZE = 1024;
 static constexpr int64_t DEFAULT_MAX_ROW_GROUP_LENGTH = 1024 * 1024;
 static constexpr bool DEFAULT_ARE_STATISTICS_ENABLED = true;
 static constexpr int64_t DEFAULT_MAX_STATISTICS_SIZE = 4096;
-static constexpr Encoding::type DEFAULT_ENCODING = Encoding::PLAIN;
+static constexpr Encoding::type DEFAULT_ENCODING = Encoding::UNKNOWN;
 static const char DEFAULT_CREATED_BY[] = CREATED_BY_VERSION;
 static constexpr Compression::type DEFAULT_COMPRESSION_TYPE = Compression::UNCOMPRESSED;
 static constexpr bool DEFAULT_IS_PAGE_INDEX_ENABLED = false;
diff --git a/python/pyarrow/tests/parquet/test_metadata.py b/python/pyarrow/tests/parquet/test_metadata.py
index 3efaf1dbf5526..82182b0449afd 100644
--- a/python/pyarrow/tests/parquet/test_metadata.py
+++ b/python/pyarrow/tests/parquet/test_metadata.py
@@ -128,7 +128,7 @@ def test_parquet_metadata_api():
     assert col_meta.is_stats_set is True
     assert isinstance(col_meta.statistics, pq.Statistics)
     assert col_meta.compression == 'SNAPPY'
-    assert set(col_meta.encodings) == {'PLAIN', 'RLE'}
+    assert set(col_meta.encodings) == {'RLE'}
     assert col_meta.has_dictionary_page is False
     assert col_meta.dictionary_page_offset is None
     assert col_meta.data_page_offset > 0

From fb61e436371f8451788f9bed129c96513f002f04 Mon Sep 17 00:00:00 2001
From: Timothy Meehan <tim@timdmeehan.com>
Date: Thu, 31 Aug 2023 13:25:47 -0400
Subject: [PATCH 291/749] MINOR: [Docs][Flight] Fix PollFlightInfo diagrams
 (#37499)

[Based on this note](https://lists.apache.org/thread/pr1xgrow1111k8h2n08phrbvk33n8d0w), it appears that RetryInfo was renamed to PollInfo, but the docs were not updated to reflect this renaming.  This commit changes references of RetryInfo to PollInfo.

CC: @ kou

### Rationale for this change

Improve the documentation.

### What changes are included in this PR?

This is fixing a typo in the sequence diagrams of the documentation.

### Are these changes tested?

N/A

### Are there any user-facing changes?

No

Authored-by: Tim Meehan <tim@timdmeehan.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/format/Flight/PollFlightInfo.mmd     | 6 +++---
 docs/source/format/Flight/PollFlightInfo.mmd.svg | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/source/format/Flight/PollFlightInfo.mmd b/docs/source/format/Flight/PollFlightInfo.mmd
index 5a643654c0c41..d062a3a216958 100644
--- a/docs/source/format/Flight/PollFlightInfo.mmd
+++ b/docs/source/format/Flight/PollFlightInfo.mmd
@@ -25,11 +25,11 @@ participant Client
 participant Metadata Server
 participant Data Server
 Client->>Metadata Server: PollFlightInfo(FlightDescriptor)
-Metadata Server->>Client: RetryInfo{descriptor: FlightDescriptor', ...}
+Metadata Server->>Client: PollInfo{descriptor: FlightDescriptor', ...}
 Client->>Metadata Server: PollFlightInfo(FlightDescriptor')
-Metadata Server->>Client: RetryInfo{descriptor: FlightDescriptor'', ...}
+Metadata Server->>Client: PollInfo{descriptor: FlightDescriptor'', ...}
 Client->>Metadata Server: PollFlightInfo(FlightDescriptor'')
-Metadata Server->>Client: RetryInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}
+Metadata Server->>Client: PollInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}
 Note over Client, Data Server: This may be parallelized
 Note over Client, Data Server: Some endpoints may be processed while polling
 loop for each endpoint in FlightInfo.endpoints
diff --git a/docs/source/format/Flight/PollFlightInfo.mmd.svg b/docs/source/format/Flight/PollFlightInfo.mmd.svg
index d7b62f180aa85..1890361f88ce4 100644
--- a/docs/source/format/Flight/PollFlightInfo.mmd.svg
+++ b/docs/source/format/Flight/PollFlightInfo.mmd.svg
@@ -1 +1 @@
-<svg aria-roledescription="sequence" role="graphics-document document" viewBox="-50 -10 1125.5 688" style="max-width: 1125.5px; background-color: white;" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" width="100%" id="mermaid-1690782830274"><style>#mermaid-1690782830274{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-1690782830274 .error-icon{fill:#552222;}#mermaid-1690782830274 .error-text{fill:#552222;stroke:#552222;}#mermaid-1690782830274 .edge-thickness-normal{stroke-width:2px;}#mermaid-1690782830274 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-1690782830274 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-1690782830274 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-1690782830274 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-1690782830274 .marker{fill:#333333;stroke:#333333;}#mermaid-1690782830274 .marker.cross{stroke:#333333;}#mermaid-1690782830274 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-1690782830274 .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 text.actor&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .actor-line{stroke:grey;}#mermaid-1690782830274 .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-1690782830274 .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-1690782830274 #arrowhead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .sequenceNumber{fill:white;}#mermaid-1690782830274 #sequencenumber{fill:#333;}#mermaid-1690782830274 #crosshead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .messageText{fill:#333;stroke:none;}#mermaid-1690782830274 .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .labelText,#mermaid-1690782830274 .labelText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopText,#mermaid-1690782830274 .loopText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-1690782830274 .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-1690782830274 .noteText,#mermaid-1690782830274 .noteText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .actorPopupMenu{position:absolute;}#mermaid-1690782830274 .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-1690782830274 .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .actor-man circle,#mermaid-1690782830274 line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-1690782830274 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g/><defs><symbol height="24" width="24" id="computer"><path d="M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z" transform="scale(.5)"/></symbol></defs><defs><symbol clip-rule="evenodd" fill-rule="evenodd" id="database"><path d="M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z" transform="scale(.5)"/></symbol></defs><defs><symbol height="24" width="24" id="clock"><path d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z" transform="scale(.5)"/></symbol></defs><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="75" y1="5" x1="75" id="actor0"/><g id="root-0"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="736" y1="5" x1="736" id="actor1"/><g id="root-1"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="950.5" y1="5" x1="950.5" id="actor2"/><g id="root-2"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></g><defs><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="9" id="arrowhead"><path d="M 0 0 L 10 5 L 0 10 z"/></marker></defs><defs><marker refY="5" refX="4" orient="auto" markerHeight="8" markerWidth="15" id="crosshead"><path style="stroke-dasharray: 0, 0;" d="M 1,2 L 6,7 M 6,2 L 1,7" stroke-width="1pt" stroke="#000000" fill="none"/></marker></defs><defs><marker orient="auto" markerHeight="28" markerWidth="20" refY="7" refX="18" id="filled-head"><path d="M 18,7 L9,13 L14,7 L9,1 Z"/></marker></defs><defs><marker orient="auto" markerHeight="40" markerWidth="60" refY="15" refX="15" id="sequencenumber"><circle r="6" cy="15" cx="15"/></marker></defs><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="351" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="356" x="513"><tspan x="513">This may be parallelized</tspan></text></g><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="398" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="403" x="513"><tspan x="513">Some endpoints may be processed while polling</tspan></text></g><g><line class="loopLine" y2="445" x2="960.5" y1="445" x1="65"/><line class="loopLine" y2="582" x2="960.5" y1="445" x1="960.5"/><line class="loopLine" y2="582" x2="960.5" y1="582" x1="65"/><line class="loopLine" y2="582" x2="65" y1="445" x1="65"/><polygon class="labelBox" points="65,445 115,445 115,458 106.6,465 65,465"/><text style="font-size: 16px; font-weight: 400;" class="labelText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="458" x="90">loop</text><text style="font-size: 16px; font-weight: 400;" class="loopText" text-anchor="middle" y="463" x="537.75"><tspan x="537.75">[for each endpoint in FlightInfo.endpoints]</tspan></text></g><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="80" x="406">PollFlightInfo(FlightDescriptor)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="111" x2="736" y1="111" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="115" x="75">1</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="126" x="406">RetryInfo{descriptor: FlightDescriptor', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="157" x2="75" y1="157" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="161" x="736">2</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="172" x="406">PollFlightInfo(FlightDescriptor')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="203" x2="736" y1="203" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="207" x="75">3</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="218" x="406">RetryInfo{descriptor: FlightDescriptor'', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="249" x2="75" y1="249" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="253" x="736">4</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="264" x="406">PollFlightInfo(FlightDescriptor'')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="295" x2="736" y1="295" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="299" x="75">5</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="310" x="406">RetryInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="341" x2="75" y1="341" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="345" x="736">6</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="495" x="513">DoGet(Ticket)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="526" x2="950.5" y1="526" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="530" x="75">7</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="541" x="513">stream of FlightData</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="572" x2="75" y1="572" x1="950.5"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="576" x="950.5">8</text><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></svg>
\ No newline at end of file
+<svg aria-roledescription="sequence" role="graphics-document document" viewBox="-50 -10 1125.5 688" style="max-width: 1125.5px; background-color: white;" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.w3.org/2000/svg" width="100%" id="mermaid-1690782830274"><style>#mermaid-1690782830274{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-1690782830274 .error-icon{fill:#552222;}#mermaid-1690782830274 .error-text{fill:#552222;stroke:#552222;}#mermaid-1690782830274 .edge-thickness-normal{stroke-width:2px;}#mermaid-1690782830274 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-1690782830274 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-1690782830274 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-1690782830274 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-1690782830274 .marker{fill:#333333;stroke:#333333;}#mermaid-1690782830274 .marker.cross{stroke:#333333;}#mermaid-1690782830274 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-1690782830274 .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 text.actor&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .actor-line{stroke:grey;}#mermaid-1690782830274 .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-1690782830274 .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-1690782830274 #arrowhead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .sequenceNumber{fill:white;}#mermaid-1690782830274 #sequencenumber{fill:#333;}#mermaid-1690782830274 #crosshead path{fill:#333;stroke:#333;}#mermaid-1690782830274 .messageText{fill:#333;stroke:none;}#mermaid-1690782830274 .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .labelText,#mermaid-1690782830274 .labelText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopText,#mermaid-1690782830274 .loopText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-1690782830274 .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-1690782830274 .noteText,#mermaid-1690782830274 .noteText&gt;tspan{fill:black;stroke:none;}#mermaid-1690782830274 .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-1690782830274 .actorPopupMenu{position:absolute;}#mermaid-1690782830274 .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-1690782830274 .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1690782830274 .actor-man circle,#mermaid-1690782830274 line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-1690782830274 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g/><defs><symbol height="24" width="24" id="computer"><path d="M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z" transform="scale(.5)"/></symbol></defs><defs><symbol clip-rule="evenodd" fill-rule="evenodd" id="database"><path d="M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z" transform="scale(.5)"/></symbol></defs><defs><symbol height="24" width="24" id="clock"><path d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z" transform="scale(.5)"/></symbol></defs><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="75" y1="5" x1="75" id="actor0"/><g id="root-0"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="736" y1="5" x1="736" id="actor1"/><g id="root-1"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g></g><g><line stroke="#999" stroke-width="0.5px" class="200" y2="622" x2="950.5" y1="5" x1="950.5" id="actor2"/><g id="root-2"><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="0" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="32.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></g><defs><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="9" id="arrowhead"><path d="M 0 0 L 10 5 L 0 10 z"/></marker></defs><defs><marker refY="5" refX="4" orient="auto" markerHeight="8" markerWidth="15" id="crosshead"><path style="stroke-dasharray: 0, 0;" d="M 1,2 L 6,7 M 6,2 L 1,7" stroke-width="1pt" stroke="#000000" fill="none"/></marker></defs><defs><marker orient="auto" markerHeight="28" markerWidth="20" refY="7" refX="18" id="filled-head"><path d="M 18,7 L9,13 L14,7 L9,1 Z"/></marker></defs><defs><marker orient="auto" markerHeight="40" markerWidth="60" refY="15" refX="15" id="sequencenumber"><circle r="6" cy="15" cx="15"/></marker></defs><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="351" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="356" x="513"><tspan x="513">This may be parallelized</tspan></text></g><g><rect class="note" ry="0" rx="0" height="37" width="925.5" stroke="#666" fill="#EDF2AE" y="398" x="50"/><text style="font-size: 16px; font-weight: 400;" dy="1em" class="noteText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="403" x="513"><tspan x="513">Some endpoints may be processed while polling</tspan></text></g><g><line class="loopLine" y2="445" x2="960.5" y1="445" x1="65"/><line class="loopLine" y2="582" x2="960.5" y1="445" x1="960.5"/><line class="loopLine" y2="582" x2="960.5" y1="582" x1="65"/><line class="loopLine" y2="582" x2="65" y1="445" x1="65"/><polygon class="labelBox" points="65,445 115,445 115,458 106.6,465 65,465"/><text style="font-size: 16px; font-weight: 400;" class="labelText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="458" x="90">loop</text><text style="font-size: 16px; font-weight: 400;" class="loopText" text-anchor="middle" y="463" x="537.75"><tspan x="537.75">[for each endpoint in FlightInfo.endpoints]</tspan></text></g><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="80" x="406">PollFlightInfo(FlightDescriptor)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="111" x2="736" y1="111" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="115" x="75">1</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="126" x="406">PollInfo{descriptor: FlightDescriptor', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="157" x2="75" y1="157" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="161" x="736">2</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="172" x="406">PollFlightInfo(FlightDescriptor')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="203" x2="736" y1="203" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="207" x="75">3</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="218" x="406">PollInfo{descriptor: FlightDescriptor'', ...}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="249" x2="75" y1="249" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="253" x="736">4</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="264" x="406">PollFlightInfo(FlightDescriptor'')</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="295" x2="736" y1="295" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="299" x="75">5</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="310" x="406">PollInfo{descriptor: null, info: FlightInfo{endpoints: [FlightEndpoint{ticket: Ticket}, …]}</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="341" x2="75" y1="341" x1="736"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="345" x="736">6</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="495" x="513">DoGet(Ticket)</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="526" x2="950.5" y1="526" x1="75"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="530" x="75">7</text><text style="font-size: 16px; font-weight: 400;" dy="1em" class="messageText" alignment-baseline="middle" dominant-baseline="middle" text-anchor="middle" y="541" x="513">stream of FlightData</text><line style="fill: none;" marker-start="url(#sequencenumber)" marker-end="url(#arrowhead)" stroke="none" stroke-width="2" class="messageLine0" y2="572" x2="75" y1="572" x1="950.5"/><text class="sequenceNumber" text-anchor="middle" font-size="12px" font-family="sans-serif" y="576" x="950.5">8</text><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="0"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="75"><tspan dy="0" x="75">Client</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="661"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="736"><tspan dy="0" x="736">Metadata Server</tspan></text></g><g><rect class="actor" ry="3" rx="3" height="65" width="150" stroke="#666" fill="#eaeaea" y="602" x="875.5"/><text style="text-anchor: middle; font-size: 16px; font-weight: 400;" class="actor" alignment-baseline="central" dominant-baseline="central" y="634.5" x="950.5"><tspan dy="0" x="950.5">Data Server</tspan></text></g></svg>
\ No newline at end of file

From 3c2e74ce9c9ad195a2db53dea2fc241e77cacf0b Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 31 Aug 2023 19:30:39 +0200
Subject: [PATCH 292/749] GH-37373: [CI] Make integration build a bit leaner
 (#37366)

### Rationale for this change

Some CI builds on GitHub Actions occasionally fail for disk space issues. The conda-integration build is one of them:
https://github.com/apache/arrow/actions/runs/5966046880/attempts/2?pr=37341

### What changes are included in this PR?

1. Disable more C++ components in the integration build.
2. Remove intermediate build artifacts at the end of a C++ CI build (object files).
3. Remove intermediate build directories at the end of a Rust CI build.

### Are these changes tested?

Self-tested by definition.

### Are there any user-facing changes?

No.

* Closes: #37373

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/docker/conda-integration.dockerfile | 2 ++
 ci/scripts/cpp_build.sh                | 3 +++
 ci/scripts/rust_build.sh               | 5 +++++
 3 files changed, 10 insertions(+)

diff --git a/ci/docker/conda-integration.dockerfile b/ci/docker/conda-integration.dockerfile
index da315776b58f2..d6fad57b9f6ab 100644
--- a/ci/docker/conda-integration.dockerfile
+++ b/ci/docker/conda-integration.dockerfile
@@ -67,11 +67,13 @@ ENV ARROW_ACERO=OFF \
     ARROW_FLIGHT=ON \
     ARROW_FLIGHT_SQL=ON \
     ARROW_GANDIVA=OFF \
+    ARROW_GCS=OFF \
     ARROW_HDFS=OFF \
     ARROW_JEMALLOC=OFF \
     ARROW_JSON=OFF \
     ARROW_ORC=OFF \
     ARROW_PARQUET=OFF \
     ARROW_S3=OFF \
+    ARROW_SUBSTRAIT=OFF \
     ARROW_USE_GLOG=OFF \
     CMAKE_UNITY_BUILD=ON
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index d73f4ad23085e..a420cb64cb387 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -190,6 +190,9 @@ cmake \
 export CMAKE_BUILD_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL:-$[${n_jobs} + 1]}
 time cmake --build . --target install
 
+# Save disk space by removing large temporary build products
+find . -name "*.o" -delete
+
 popd
 
 if [ -x "$(command -v ldconfig)" ]; then
diff --git a/ci/scripts/rust_build.sh b/ci/scripts/rust_build.sh
index 3532ea3d5c642..2dfc0f1b1892d 100755
--- a/ci/scripts/rust_build.sh
+++ b/ci/scripts/rust_build.sh
@@ -56,4 +56,9 @@ pushd ${source_dir}
 # build only the integration testing binaries
 cargo build -p arrow-integration-testing
 
+# Save disk space by removing large temporary build products
+rm -rf target/debug/deps
+rm -rf target/debug/build
+rm -rf target/debug/incremental
+
 popd

From 84583d65306c01897fae01ba587885f140054b0c Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 1 Sep 2023 02:44:12 +0800
Subject: [PATCH 293/749] GH-37434: [C++] IO: Refactor
 BufferedInputStream::Read for small input (#37460)

### Rationale for this change

If we Set BufferSize == 100k, and read 3k bytes per IO. When we read the 34 times, the IO would be (99k, 102k]

In Read, it will read buffered (99k, 100k], issue IO for (100k, 102k]. Rather than (100k, 200k].

### What changes are included in this PR?

Refactor `BufferedInputStream::Read` to optimize small IO.

### Are these changes tested?

Already has tests?

### Are there any user-facing changes?

User might get io-pattern changed. It can be optimization or downgrade.

* Closes: #37434

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/io/buffered.cc        |  88 +++++----
 cpp/src/arrow/io/buffered_test.cc   | 275 +++++++++++++++++++++++++++-
 cpp/src/arrow/testing/gtest_util.cc |   2 +-
 cpp/src/arrow/testing/gtest_util.h  |   2 +-
 4 files changed, 321 insertions(+), 46 deletions(-)

diff --git a/cpp/src/arrow/io/buffered.cc b/cpp/src/arrow/io/buffered.cc
index e0e37c580269f..21cce478d3fa5 100644
--- a/cpp/src/arrow/io/buffered.cc
+++ b/cpp/src/arrow/io/buffered.cc
@@ -342,23 +342,28 @@ class BufferedInputStream::Impl : public BufferedBase {
     buffer_pos_ = bytes_buffered_ = 0;
   }
 
-  Status BufferIfNeeded() {
-    if (bytes_buffered_ == 0) {
-      // Fill buffer
-      if (!buffer_) {
-        RETURN_NOT_OK(ResetBuffer());
-      }
+  Status DoBuffer() {
+    // Fill buffer
+    if (!buffer_) {
+      RETURN_NOT_OK(ResetBuffer());
+    }
 
-      int64_t bytes_to_buffer = buffer_size_;
-      if (raw_read_bound_ >= 0) {
-        bytes_to_buffer = std::min(buffer_size_, raw_read_bound_ - raw_read_total_);
-      }
-      ARROW_ASSIGN_OR_RAISE(bytes_buffered_, raw_->Read(bytes_to_buffer, buffer_data_));
-      buffer_pos_ = 0;
-      raw_read_total_ += bytes_buffered_;
+    int64_t bytes_to_buffer = buffer_size_;
+    if (raw_read_bound_ >= 0) {
+      bytes_to_buffer = std::min(buffer_size_, raw_read_bound_ - raw_read_total_);
+    }
+    ARROW_ASSIGN_OR_RAISE(bytes_buffered_, raw_->Read(bytes_to_buffer, buffer_data_));
+    buffer_pos_ = 0;
+    raw_read_total_ += bytes_buffered_;
 
-      // Do not make assumptions about the raw stream position
-      raw_pos_ = -1;
+    // Do not make assumptions about the raw stream position
+    raw_pos_ = -1;
+    return Status::OK();
+  }
+
+  Status BufferIfNeeded() {
+    if (bytes_buffered_ == 0) {
+      return DoBuffer();
     }
     return Status::OK();
   }
@@ -373,33 +378,38 @@ class BufferedInputStream::Impl : public BufferedBase {
       return Status::Invalid("Bytes to read must be positive. Received:", nbytes);
     }
 
-    if (nbytes < buffer_size_) {
-      // Pre-buffer for small reads
-      RETURN_NOT_OK(BufferIfNeeded());
+    // 1. First consume pre-buffered data.
+    int64_t pre_buffer_copy_bytes = std::min(nbytes, bytes_buffered_);
+    if (pre_buffer_copy_bytes > 0) {
+      memcpy(out, buffer_data_ + buffer_pos_, pre_buffer_copy_bytes);
+      ConsumeBuffer(pre_buffer_copy_bytes);
     }
-
-    if (nbytes > bytes_buffered_) {
-      // Copy buffered bytes into out, then read rest
-      memcpy(out, buffer_data_ + buffer_pos_, bytes_buffered_);
-
-      int64_t bytes_to_read = nbytes - bytes_buffered_;
-      if (raw_read_bound_ >= 0) {
-        bytes_to_read = std::min(bytes_to_read, raw_read_bound_ - raw_read_total_);
-      }
-      ARROW_ASSIGN_OR_RAISE(
-          int64_t bytes_read,
-          raw_->Read(bytes_to_read, reinterpret_cast<uint8_t*>(out) + bytes_buffered_));
+    int64_t remaining_bytes = nbytes - pre_buffer_copy_bytes;
+    if (raw_read_bound_ >= 0) {
+      remaining_bytes = std::min(remaining_bytes, raw_read_bound_ - raw_read_total_);
+    }
+    if (remaining_bytes == 0) {
+      return pre_buffer_copy_bytes;
+    }
+    DCHECK_EQ(0, bytes_buffered_);
+
+    // 2. Read from storage.
+    if (remaining_bytes >= buffer_size_) {
+      // 2.1. If read is larger than buffer size, read directly from storage.
+      ARROW_ASSIGN_OR_RAISE(int64_t bytes_read,
+                            raw_->Read(remaining_bytes, reinterpret_cast<uint8_t*>(out) +
+                                                            pre_buffer_copy_bytes));
       raw_read_total_ += bytes_read;
-
-      // Do not make assumptions about the raw stream position
-      raw_pos_ = -1;
-      bytes_read += bytes_buffered_;
       RewindBuffer();
-      return bytes_read;
+      return pre_buffer_copy_bytes + bytes_read;
     } else {
-      memcpy(out, buffer_data_ + buffer_pos_, nbytes);
-      ConsumeBuffer(nbytes);
-      return nbytes;
+      // 2.2. If read is smaller than buffer size, fill buffer and copy from buffer.
+      RETURN_NOT_OK(DoBuffer());
+      int64_t bytes_copy_after_buffer = std::min(bytes_buffered_, remaining_bytes);
+      memcpy(reinterpret_cast<uint8_t*>(out) + pre_buffer_copy_bytes,
+             buffer_data_ + buffer_pos_, bytes_copy_after_buffer);
+      ConsumeBuffer(bytes_copy_after_buffer);
+      return pre_buffer_copy_bytes + bytes_copy_after_buffer;
     }
   }
 
@@ -432,7 +442,7 @@ class BufferedInputStream::Impl : public BufferedBase {
 BufferedInputStream::BufferedInputStream(std::shared_ptr<InputStream> raw,
                                          MemoryPool* pool,
                                          int64_t raw_total_bytes_bound) {
-  impl_.reset(new Impl(std::move(raw), pool, raw_total_bytes_bound));
+  impl_ = std::make_unique<Impl>(std::move(raw), pool, raw_total_bytes_bound);
 }
 
 BufferedInputStream::~BufferedInputStream() { internal::CloseFromDestructor(this); }
diff --git a/cpp/src/arrow/io/buffered_test.cc b/cpp/src/arrow/io/buffered_test.cc
index 520eaaa93567a..82feeea0517fd 100644
--- a/cpp/src/arrow/io/buffered_test.cc
+++ b/cpp/src/arrow/io/buffered_test.cc
@@ -46,8 +46,7 @@
 #include "arrow/testing/gtest_util.h"
 #include "arrow/util/io_util.h"
 
-namespace arrow {
-namespace io {
+namespace arrow::io {
 
 using ::arrow::internal::TemporaryDir;
 
@@ -321,7 +320,7 @@ TEST_F(TestBufferedOutputStream, TruncatesFile) {
 // ----------------------------------------------------------------------
 // BufferedInputStream tests
 
-const char kExample1[] = "informaticacrobaticsimmolation";
+const std::string_view kExample1 = "informaticacrobaticsimmolation";
 
 class TestBufferedInputStream : public FileTestFixture<BufferedInputStream> {
  public:
@@ -672,5 +671,271 @@ TEST_F(TestBufferedInputStreamBound, BufferExactlyExhausted) {
   }
 }
 
-}  // namespace io
-}  // namespace arrow
+// These tests exercise the buffering algorithm by checking the reads issued
+// to the underlying raw stream.
+class TestBufferedInputStreamChunk : public TestBufferedInputStream {
+ public:
+  void SetUp() { TestBufferedInputStream::SetUp(); }
+
+  void TearDown() {
+    buffered_ = nullptr;
+    tracked_ = nullptr;
+    raw_ = nullptr;
+  }
+
+  void MakeExample(int64_t buffer_size,
+                   std::optional<int64_t> read_bound = std::nullopt) {
+    test_data_ = kExample1;
+    MemoryPool* pool = default_memory_pool();
+
+    ASSERT_OK_AND_ASSIGN(auto file_out, FileOutputStream::Open(path_));
+    ASSERT_OK(file_out->Write(test_data_));
+    ASSERT_OK(file_out->Close());
+
+    ASSERT_OK_AND_ASSIGN(auto file_in, ReadableFile::Open(path_));
+    raw_ = file_in;
+    tracked_ = TrackedRandomAccessFile::Make(dynamic_cast<RandomAccessFile*>(raw_.get()));
+    ASSERT_OK_AND_ASSIGN(buffered_,
+                         BufferedInputStream::Create(buffer_size, pool, tracked_,
+                                                     read_bound.value_or(-1)));
+  }
+
+ protected:
+  std::shared_ptr<TrackedRandomAccessFile> tracked_;
+};
+
+TEST_F(TestBufferedInputStreamChunk, NoRead) {
+  const int64_t kBufferSize = 5;
+  MakeExample(kBufferSize);
+
+  EXPECT_TRUE(tracked_->get_read_ranges().empty());
+}
+
+TEST_F(TestBufferedInputStreamChunk, LargeRead) {
+  const int64_t kBufferSize = 5;
+  MakeExample(kBufferSize);
+
+  // Read bytes greater than buffer_size would not buffer.
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(6));
+  AssertBufferEqual(*buf, kExample1.substr(0, 6));
+
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, 6}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+TEST_F(TestBufferedInputStreamChunk, SmallReadThenLargeRead) {
+  const int64_t kBufferSize = 5;
+  MakeExample(kBufferSize);
+
+  // Small read would trigger buffer the whole chunk
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(1));
+  AssertBufferEqual(*buf, kExample1.substr(0, 1));
+  EXPECT_EQ(4, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, 5}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // Large read with pre-buffered will copy the
+  // pre-buffered data first, then read the remaining without filling
+  // the buffer.
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(20));
+  AssertBufferEqual(*buf, kExample1.substr(1, 20));
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  read_ranges.push_back(ReadRange{5, 16});
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // Small read again
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(2));
+  AssertBufferEqual(*buf, kExample1.substr(21, 2));
+  EXPECT_EQ(kBufferSize - 2, buffered_->bytes_buffered());
+  read_ranges.push_back(ReadRange{21, 5});
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+TEST_F(TestBufferedInputStreamChunk, BufferWholeChunk) {
+  const int64_t kBufferSize = 5;
+  MakeExample(kBufferSize);
+
+  // Small read
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(1));
+  AssertBufferEqual(*buf, kExample1.substr(0, 1));
+  EXPECT_EQ(kBufferSize - 1, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, 5}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // Whole read size is larger than buffer size, but raw read size would be
+  // smaller than buffer size => buffer is filled anew
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(6));
+  AssertBufferEqual(*buf, kExample1.substr(1, 6));
+  EXPECT_EQ(kBufferSize * 2 - 1 - 6, buffered_->bytes_buffered());
+  read_ranges.push_back(ReadRange{5, 5});
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+TEST_F(TestBufferedInputStreamChunk, BufferLargerThanFileSize) {
+  const int64_t kFileSize = static_cast<int64_t>(kExample1.size());
+  const int64_t kBufferSize = kFileSize + 10;
+  MakeExample(kBufferSize);
+
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(1));
+  AssertBufferEqual(*buf, kExample1.substr(0, 1));
+  EXPECT_EQ(kFileSize - 1, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, kBufferSize}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(kFileSize - 3));
+  AssertBufferEqual(*buf, kExample1.substr(1, kFileSize - 3));
+  EXPECT_EQ(2, buffered_->bytes_buffered());
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // Short read up to EOF
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(20));
+  AssertBufferEqual(*buf, kExample1.substr(kFileSize - 2, 2));
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  read_ranges.push_back(ReadRange{kFileSize, kBufferSize});
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // EOF
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(20));
+  AssertBufferEqual(*buf, "");
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  // (BufferedInputStream still tries to fetch more bytes)
+  read_ranges.push_back(ReadRange{kFileSize, kBufferSize});
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+TEST_F(TestBufferedInputStreamChunk, BufferLargerThanReadBound) {
+  const int64_t kBufferSize = 6;
+  const int64_t kReadBound = 5;
+  MakeExample(kBufferSize, kReadBound);
+
+  // Small read
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(1));
+  AssertBufferEqual(*buf, kExample1.substr(0, 1));
+  EXPECT_EQ(kReadBound - 1, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, 5}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // Longer read, but truncated due to the read bound
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(10));
+  AssertBufferEqual(*buf, kExample1.substr(1, 4));
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  // Due to the read bound, no more row reads were issued
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // EOF
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(10));
+  AssertBufferEqual(*buf, "");
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+TEST_F(TestBufferedInputStreamChunk, BufferSmallerThanReadBound) {
+  const int64_t kBufferSize = 3;
+  const int64_t kReadBound = 5;
+  MakeExample(kBufferSize, kReadBound);
+
+  ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(6));
+  AssertBufferEqual(*buf, kExample1.substr(0, 5));
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  std::vector<ReadRange> read_ranges = {ReadRange{0, 5}};
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+
+  // EOF
+  ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(10));
+  AssertBufferEqual(*buf, "");
+  EXPECT_EQ(0, buffered_->bytes_buffered());
+  EXPECT_EQ(tracked_->get_read_ranges(), read_ranges);
+}
+
+class TestBufferedInputStreamRandom : public ::testing::Test {
+ public:
+  void MakeBuffered(int64_t data_size, int64_t buffer_size,
+                    std::optional<int64_t> read_bound = std::nullopt) {
+    buffer_size_ = buffer_size;
+    data_.clear();
+    data_.reserve(data_size);
+    while (data_.size() < static_cast<size_t>(data_size)) {
+      data_.append(kExample1, /*pos*/ 0,
+                   /*count*/ static_cast<size_t>(data_size) - data_.size());
+    }
+    EXPECT_EQ(data_.size(), data_size);
+
+    // Clear dependent streams in reverse order
+    buffered_.reset();
+    tracked_.reset();
+    // Read from a copy of data, so that data_.substr() below doesn't invalidate it
+    raw_ = BufferReader::FromString(data_);
+    tracked_ = TrackedRandomAccessFile::Make(raw_.get());
+    EXPECT_OK_AND_ASSIGN(buffered_,
+                         BufferedInputStream::Create(buffer_size, default_memory_pool(),
+                                                     tracked_, read_bound.value_or(-1)));
+    if (read_bound) {
+      data_ = data_.substr(0, *read_bound);
+    }
+  }
+
+  void TestReads() {
+    std::default_random_engine gen(/*seed*/ 42);
+    std::uniform_int_distribution<int64_t> read_len_dist(1, 80);
+
+    int64_t pos = 0;
+    const int64_t size = static_cast<int64_t>(data_.size());
+    while (pos < size) {
+      const int64_t read_len = read_len_dist(gen);
+      ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(read_len));
+      AssertBufferEqual(*buf, std::string_view(data_).substr(pos, read_len));
+      pos += buf->size();
+    }
+
+    // EOF was reached
+    ASSERT_EQ(pos, size);
+
+    // Number of reads should not be excessive given the buffer size
+    int64_t max_reads = (size + buffer_size_ - 1) / buffer_size_;
+    EXPECT_LE(tracked_->num_reads(), max_reads);
+    const auto& read_ranges = tracked_->get_read_ranges();
+    pos = 0;
+    for (size_t i = 0; i < read_ranges.size(); ++i) {
+      const auto cur = read_ranges[i];
+      ASSERT_EQ(cur.offset, pos);
+      // Never read less than buffer size bytes, except perhaps if fewer bytes remain
+      ASSERT_GE(cur.length, std::min(buffer_size_, size - pos));
+      // Bump actual position in the file
+      pos += std::min(cur.length, size - pos);
+    }
+
+    // Further reads return an empty buffer
+    ASSERT_OK_AND_ASSIGN(auto buf, buffered_->Read(buffer_size_ - 1));
+    AssertBufferEqual(*buf, "");
+    ASSERT_OK_AND_ASSIGN(buf, buffered_->Read(buffer_size_ + 1));
+    AssertBufferEqual(*buf, "");
+  }
+
+ protected:
+  std::string data_;
+  int64_t buffer_size_;
+  std::shared_ptr<RandomAccessFile> raw_;
+  std::shared_ptr<TrackedRandomAccessFile> tracked_;
+  std::shared_ptr<BufferedInputStream> buffered_;
+};
+
+TEST_F(TestBufferedInputStreamRandom, ReadsWithoutReadBound) {
+  constexpr int kNumIters = 10;
+
+  for (int i = 0; i < kNumIters; ++i) {
+    MakeBuffered(/*data_size=*/3000, /*buffer_size=*/11);
+    TestReads();
+  }
+}
+
+TEST_F(TestBufferedInputStreamRandom, ReadsWithReadBound) {
+  constexpr int kNumIters = 10;
+
+  for (int i = 0; i < kNumIters; ++i) {
+    MakeBuffered(/*data_size=*/3000, /*buffer_size=*/11, /*read_bound=*/2000);
+    TestReads();
+  }
+}
+
+}  // namespace arrow::io
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index c6de6b02fc8ef..a6dc1d59c67a9 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -214,7 +214,7 @@ void AssertBufferEqual(const Buffer& buffer, const std::vector<uint8_t>& expecte
   }
 }
 
-void AssertBufferEqual(const Buffer& buffer, const std::string& expected) {
+void AssertBufferEqual(const Buffer& buffer, std::string_view expected) {
   ASSERT_EQ(static_cast<size_t>(buffer.size()), expected.length())
       << "Mismatching buffer size";
   const uint8_t* buffer_data = buffer.data();
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index e3838bfe4bf71..bb462af86a5f2 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -232,7 +232,7 @@ ARROW_TESTING_EXPORT void AssertChunkedApproxEquivalent(
 ARROW_TESTING_EXPORT void AssertBufferEqual(const Buffer& buffer,
                                             const std::vector<uint8_t>& expected);
 ARROW_TESTING_EXPORT void AssertBufferEqual(const Buffer& buffer,
-                                            const std::string& expected);
+                                            std::string_view expected);
 ARROW_TESTING_EXPORT void AssertBufferEqual(const Buffer& buffer, const Buffer& expected);
 
 ARROW_TESTING_EXPORT void AssertTypeEqual(const DataType& lhs, const DataType& rhs,

From b6c0ea455d08a0de590a1e195af69676ca56457e Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 1 Sep 2023 11:40:01 +0900
Subject: [PATCH 294/749] GH-37488: [C++] Disable unity build for Azure SDK for
 C++ (#37489)

### Rationale for this change

It seems that Azure SDK for C++ doesn't support unity build.

### What changes are included in this PR?

Force to disable unity build.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37488

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 5c2e679e10c86..b2360dab2ec4f 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -5126,6 +5126,7 @@ function(build_azure_sdk)
   set(BUILD_TESTING FALSE)
   set(BUILD_WINDOWS_UWP TRUE)
   set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
+  set(CMAKE_UNITY_BUILD FALSE)
   set(DISABLE_AZURE_CORE_OPENTELEMETRY TRUE)
   set(ENV{AZURE_SDK_DISABLE_AUTO_VCPKG} TRUE)
   set(WARNINGS_AS_ERRORS FALSE)

From c0998b1c94260284a624da6b3ddee6b59e5c4558 Mon Sep 17 00:00:00 2001
From: Hirokazu SUZUKI <heronshoes877@gmail.com>
Date: Fri, 1 Sep 2023 13:10:13 +0900
Subject: [PATCH 295/749] GH-37259: [Ruby] Add explicit csv gem dependency
 (#37506)

### Rationale for this change

The "csv" gem is a default gem for now but it will be a bundled gem in Ruby 3.4.
Bundled gem requires an explicit gem dependency.

This will cause failure when we do `require "csv"` in Ruby 3.4 (this means in master branch of Ruby = ruby 3.3.0dev for now). See examples in #37259.

### What changes are included in this PR?

Added `gem "csv"` in gemspec's runtime dependency of Red Arrow.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Users will use 'csv' gem from rubygems, not bundled, for Ruby < 3.4 .

* Closes: #37259

Authored-by: Hirokazu SUZUKI <heronshoes877@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ruby/red-arrow/red-arrow.gemspec | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ruby/red-arrow/red-arrow.gemspec b/ruby/red-arrow/red-arrow.gemspec
index c92d3f57509ec..9e9c147f76507 100644
--- a/ruby/red-arrow/red-arrow.gemspec
+++ b/ruby/red-arrow/red-arrow.gemspec
@@ -47,6 +47,7 @@ Gem::Specification.new do |spec|
   spec.extensions = ["ext/arrow/extconf.rb"]
 
   spec.add_runtime_dependency("bigdecimal", ">= 3.1.0")
+  spec.add_runtime_dependency("csv")
   spec.add_runtime_dependency("extpp", ">= 0.1.1")
   spec.add_runtime_dependency("gio2", ">= 3.5.0")
   spec.add_runtime_dependency("native-package-installer")

From 715cc98de3d1dc03090b2693d36a22c796cf94d2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 1 Sep 2023 14:30:47 +0900
Subject: [PATCH 296/749] GH-37507: [GLib] Don't use implicit include
 directories (#37508)

### Rationale for this change

Our source code should not have "#include"s that depend on source/binary directories exists in include path.

This also fixes that CUDA's cuda.h isn't included problem.

### What changes are included in this PR?

Don't use implicit include directories.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37507

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/arrow-cuda-glib/meson.build       | 1 +
 c_glib/arrow-dataset-glib/meson.build    | 1 +
 c_glib/arrow-flight-glib/meson.build     | 1 +
 c_glib/arrow-flight-sql-glib/meson.build | 1 +
 c_glib/arrow-glib/meson.build            | 1 +
 c_glib/gandiva-glib/meson.build          | 1 +
 c_glib/parquet-glib/meson.build          | 1 +
 7 files changed, 7 insertions(+)

diff --git a/c_glib/arrow-cuda-glib/meson.build b/c_glib/arrow-cuda-glib/meson.build
index fd9e8f0e7b139..1718e2fc990d5 100644
--- a/c_glib/arrow-cuda-glib/meson.build
+++ b/c_glib/arrow-cuda-glib/meson.build
@@ -43,6 +43,7 @@ libarrow_cuda_glib = library('arrow-cuda-glib',
                              sources: sources,
                              install: true,
                              dependencies: dependencies,
+                             implicit_include_directories: false,
                              include_directories: base_include_directories,
                              soversion: so_version,
                              version: library_version)
diff --git a/c_glib/arrow-dataset-glib/meson.build b/c_glib/arrow-dataset-glib/meson.build
index afdbbd79a1fcd..4037cf00b7a13 100644
--- a/c_glib/arrow-dataset-glib/meson.build
+++ b/c_glib/arrow-dataset-glib/meson.build
@@ -70,6 +70,7 @@ libarrow_dataset_glib = library('arrow-dataset-glib',
                                 sources: sources + enums,
                                 install: true,
                                 dependencies: dependencies,
+                                implicit_include_directories: false,
                                 include_directories: base_include_directories,
                                 soversion: so_version,
                                 version: library_version)
diff --git a/c_glib/arrow-flight-glib/meson.build b/c_glib/arrow-flight-glib/meson.build
index 3eb3177a522eb..b869fd226b86a 100644
--- a/c_glib/arrow-flight-glib/meson.build
+++ b/c_glib/arrow-flight-glib/meson.build
@@ -48,6 +48,7 @@ libarrow_flight_glib = library('arrow-flight-glib',
                                sources: sources,
                                install: true,
                                dependencies: dependencies,
+                               implicit_include_directories: false,
                                include_directories: base_include_directories,
                                soversion: so_version,
                                version: library_version)
diff --git a/c_glib/arrow-flight-sql-glib/meson.build b/c_glib/arrow-flight-sql-glib/meson.build
index 21cec3f0d101a..f1ea6d67cb04e 100644
--- a/c_glib/arrow-flight-sql-glib/meson.build
+++ b/c_glib/arrow-flight-sql-glib/meson.build
@@ -45,6 +45,7 @@ libarrow_flight_sql_glib = library('arrow-flight-sql-glib',
                                    sources: sources,
                                    install: true,
                                    dependencies: dependencies,
+                                   implicit_include_directories: false,
                                    include_directories: base_include_directories,
                                    soversion: so_version,
                                    version: library_version)
diff --git a/c_glib/arrow-glib/meson.build b/c_glib/arrow-glib/meson.build
index 2b9c3c2472c84..b26dcc4c080eb 100644
--- a/c_glib/arrow-glib/meson.build
+++ b/c_glib/arrow-glib/meson.build
@@ -249,6 +249,7 @@ libarrow_glib = library('arrow-glib',
                         sources: sources + enums,
                         install: true,
                         dependencies: dependencies,
+                        implicit_include_directories: false,
                         include_directories: base_include_directories,
                         soversion: so_version,
                         version: library_version)
diff --git a/c_glib/gandiva-glib/meson.build b/c_glib/gandiva-glib/meson.build
index c397bd1f9f9e8..52729f64da007 100644
--- a/c_glib/gandiva-glib/meson.build
+++ b/c_glib/gandiva-glib/meson.build
@@ -85,6 +85,7 @@ libgandiva_glib = library('gandiva-glib',
                           sources: sources + enums,
                           install: true,
                           dependencies: dependencies,
+                          implicit_include_directories: false,
                           include_directories: base_include_directories,
                           soversion: so_version,
                           version: library_version)
diff --git a/c_glib/parquet-glib/meson.build b/c_glib/parquet-glib/meson.build
index 15a2d56383ba0..08288484bf9b4 100644
--- a/c_glib/parquet-glib/meson.build
+++ b/c_glib/parquet-glib/meson.build
@@ -55,6 +55,7 @@ libparquet_glib = library('parquet-glib',
                           sources: sources,
                           install: true,
                           dependencies: dependencies,
+                          implicit_include_directories: false,
                           include_directories: base_include_directories,
                           soversion: so_version,
                           version: library_version)

From 4b7d699ab9eeb87996b647ec4a3f2034f9108cfd Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Fri, 1 Sep 2023 09:58:27 +0200
Subject: [PATCH 297/749] GH-37500: [CI][C++] Disable Dataset and Substrait by
 default (#37501)

### Rationale for this change

Datasets and Substrait are heavy subcomponents (as they have non-trivial dependencies), so should not be enabled unwillingly in all CI builds.

### What changes are included in this PR?

Disable Dataset and Substrait in `ci/scripts/cpp_build.sh`, enable them explicitly in relevant builds.

Disable more subcomponents in CI builds that don't need them, especially "minimal" builds.

### Are these changes tested?

Yes, by existing CI jobs.

### Are there any user-facing changes?

No.

* Closes: #37500

Lead-authored-by: Antoine Pitrou <antoine@python.org>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/cpp.yml                    |  3 +++
 .github/workflows/ruby.yml                   |  2 ++
 ci/docker/alpine-linux-3.16-cpp.dockerfile   |  1 +
 ci/docker/conda-cpp.dockerfile               |  1 +
 ci/docker/conda-integration.dockerfile       |  1 +
 ci/docker/conda-python-dask.dockerfile       | 12 ++++++++++
 ci/docker/conda-python-substrait.dockerfile  | 11 +++++----
 ci/docker/conda-python.dockerfile            |  1 +
 ci/docker/debian-11-cpp.dockerfile           |  1 +
 ci/docker/fedora-35-cpp.dockerfile           |  1 +
 ci/docker/ubuntu-20.04-cpp.dockerfile        |  1 +
 ci/docker/ubuntu-22.04-cpp.dockerfile        |  1 +
 ci/scripts/cpp_build.sh                      |  4 ++--
 ci/scripts/integration_substrait.sh          |  2 +-
 ci/scripts/python_build.sh                   |  2 +-
 cpp/examples/minimal_build/run_static.sh     | 15 ------------
 docker-compose.yml                           |  4 ++++
 python/examples/minimal_build/build_conda.sh | 25 ++++++++------------
 python/examples/minimal_build/build_venv.sh  | 12 ++++------
 19 files changed, 55 insertions(+), 45 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 41032fc1b08fc..7dd825c72fbd4 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -167,6 +167,7 @@ jobs:
       ARROW_ORC: ON
       ARROW_PARQUET: ON
       ARROW_S3: ON
+      ARROW_SUBSTRAIT: ON
       ARROW_WITH_BROTLI: ON
       ARROW_WITH_BZ2: ON
       ARROW_WITH_LZ4: ON
@@ -257,6 +258,7 @@ jobs:
       ARROW_ORC: ON
       ARROW_PARQUET: ON
       ARROW_SIMD_LEVEL: ${{ matrix.simd-level }}
+      ARROW_SUBSTRAIT: ON
       ARROW_USE_GLOG: OFF
       ARROW_VERBOSE_THIRDPARTY_BUILD: OFF
       ARROW_WITH_BROTLI: OFF
@@ -358,6 +360,7 @@ jobs:
       ARROW_JEMALLOC: OFF
       ARROW_PARQUET: ON
       ARROW_S3: ON
+      ARROW_SUBSTRAIT: ON
       ARROW_USE_GLOG: OFF
       ARROW_VERBOSE_THIRDPARTY_BUILD: OFF
       ARROW_WITH_BROTLI: ON
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index 1e744975578f5..af4f34fee2b10 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -121,6 +121,7 @@ jobs:
       ARROW_BUILD_STATIC: OFF
       ARROW_BUILD_TESTS: OFF
       ARROW_BUILD_UTILITIES: OFF
+      ARROW_DATASET: ON
       ARROW_FLIGHT: ON
       ARROW_FLIGHT_SQL: ON
       ARROW_GANDIVA: ON
@@ -206,6 +207,7 @@ jobs:
       ARROW_BUILD_TESTS: OFF
       ARROW_BUILD_UTILITIES: OFF
       ARROW_BUILD_TYPE: release
+      ARROW_DATASET: ON
       ARROW_FLIGHT: ON
       ARROW_FLIGHT_SQL: ON
       ARROW_GANDIVA: ON
diff --git a/ci/docker/alpine-linux-3.16-cpp.dockerfile b/ci/docker/alpine-linux-3.16-cpp.dockerfile
index f269fa548c141..8828e717a53a1 100644
--- a/ci/docker/alpine-linux-3.16-cpp.dockerfile
+++ b/ci/docker/alpine-linux-3.16-cpp.dockerfile
@@ -85,6 +85,7 @@ ENV ARROW_ACERO=ON \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_CCACHE=ON \
     ARROW_WITH_BROTLI=ON \
     ARROW_WITH_BZ2=ON \
diff --git a/ci/docker/conda-cpp.dockerfile b/ci/docker/conda-cpp.dockerfile
index 2997983ca320d..b635e5e93455c 100644
--- a/ci/docker/conda-cpp.dockerfile
+++ b/ci/docker/conda-cpp.dockerfile
@@ -61,6 +61,7 @@ ENV ARROW_ACERO=ON \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_CCACHE=ON \
     ARROW_WITH_BROTLI=ON \
     ARROW_WITH_BZ2=ON \
diff --git a/ci/docker/conda-integration.dockerfile b/ci/docker/conda-integration.dockerfile
index d6fad57b9f6ab..43d7e7ab0b60d 100644
--- a/ci/docker/conda-integration.dockerfile
+++ b/ci/docker/conda-integration.dockerfile
@@ -57,6 +57,7 @@ ENV DOTNET_ROOT=/opt/dotnet \
 RUN curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin -Channel 7.0 -InstallDir /opt/dotnet
 
 ENV ARROW_ACERO=OFF \
+    ARROW_AZURE=OFF \
     ARROW_BUILD_INTEGRATION=ON \
     ARROW_BUILD_STATIC=OFF \
     ARROW_BUILD_TESTS=OFF \
diff --git a/ci/docker/conda-python-dask.dockerfile b/ci/docker/conda-python-dask.dockerfile
index 400106f189e3a..44840110817e9 100644
--- a/ci/docker/conda-python-dask.dockerfile
+++ b/ci/docker/conda-python-dask.dockerfile
@@ -23,3 +23,15 @@ FROM ${repo}:${arch}-conda-python-${python}
 ARG dask=latest
 COPY ci/scripts/install_dask.sh /arrow/ci/scripts/
 RUN /arrow/ci/scripts/install_dask.sh ${dask}
+
+ENV ARROW_ACERO=OFF \
+    ARROW_COMPUTE=ON \
+    ARROW_CSV=ON \
+    ARROW_DATASET=ON \
+    ARROW_FLIGHT=OFF \
+    ARROW_FLIGHT_SQL=OFF \
+    ARROW_FILESYSTEM=ON \
+    ARROW_GANDIVA=OFF \
+    ARROW_ORC=ON \
+    ARROW_SUBSTRAIT=OFF \
+    ARROW_TENSORFLOW=OFF
diff --git a/ci/docker/conda-python-substrait.dockerfile b/ci/docker/conda-python-substrait.dockerfile
index 33f6957a86f6e..191795f253000 100644
--- a/ci/docker/conda-python-substrait.dockerfile
+++ b/ci/docker/conda-python-substrait.dockerfile
@@ -36,13 +36,16 @@ RUN mamba install -q -y \
 ARG substrait=latest
 COPY ci/scripts/install_substrait_consumer.sh /arrow/ci/scripts/
 
+RUN /arrow/ci/scripts/install_substrait_consumer.sh
+
 ENV ARROW_ACERO=ON \
-    ARROW_BUILD_TESTS=ON \
     ARROW_COMPUTE=ON \
     ARROW_CSV=ON \
     ARROW_DATASET=ON \
     ARROW_FILESYSTEM=ON \
+    ARROW_FLIGHT=OFF \
+    ARROW_FLIGHT_SQL=OFF \
+    ARROW_GANDIVA=OFF \
     ARROW_JSON=ON \
-    ARROW_SUBSTRAIT=ON
-
-RUN /arrow/ci/scripts/install_substrait_consumer.sh
+    ARROW_SUBSTRAIT=ON \
+    ARROW_TESTING=OFF
diff --git a/ci/docker/conda-python.dockerfile b/ci/docker/conda-python.dockerfile
index 21e57228f44f0..ca0ceee5f9227 100644
--- a/ci/docker/conda-python.dockerfile
+++ b/ci/docker/conda-python.dockerfile
@@ -46,5 +46,6 @@ ENV ARROW_ACERO=ON \
     ARROW_GDB=ON \
     ARROW_HDFS=ON \
     ARROW_JSON=ON \
+    ARROW_SUBSTRAIT=OFF \
     ARROW_TENSORFLOW=ON \
     ARROW_USE_GLOG=OFF
diff --git a/ci/docker/debian-11-cpp.dockerfile b/ci/docker/debian-11-cpp.dockerfile
index 00adc6bd6b3c9..46824054624ab 100644
--- a/ci/docker/debian-11-cpp.dockerfile
+++ b/ci/docker/debian-11-cpp.dockerfile
@@ -108,6 +108,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_CCACHE=ON \
     ARROW_WITH_BROTLI=ON \
     ARROW_WITH_BZ2=ON \
diff --git a/ci/docker/fedora-35-cpp.dockerfile b/ci/docker/fedora-35-cpp.dockerfile
index 668e35b4435ba..aefa25663ba14 100644
--- a/ci/docker/fedora-35-cpp.dockerfile
+++ b/ci/docker/fedora-35-cpp.dockerfile
@@ -87,6 +87,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_CCACHE=ON \
     ARROW_WITH_BROTLI=ON \
     ARROW_WITH_BZ2=ON \
diff --git a/ci/docker/ubuntu-20.04-cpp.dockerfile b/ci/docker/ubuntu-20.04-cpp.dockerfile
index 08dda6cf50a17..1e0a1e4807402 100644
--- a/ci/docker/ubuntu-20.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp.dockerfile
@@ -161,6 +161,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_ASAN=OFF \
     ARROW_USE_CCACHE=ON \
     ARROW_USE_UBSAN=OFF \
diff --git a/ci/docker/ubuntu-22.04-cpp.dockerfile b/ci/docker/ubuntu-22.04-cpp.dockerfile
index dedeedd979f72..fffafe2b0521d 100644
--- a/ci/docker/ubuntu-22.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-22.04-cpp.dockerfile
@@ -185,6 +185,7 @@ ENV absl_SOURCE=BUNDLED \
     ARROW_ORC=ON \
     ARROW_PARQUET=ON \
     ARROW_S3=ON \
+    ARROW_SUBSTRAIT=ON \
     ARROW_USE_ASAN=OFF \
     ARROW_USE_CCACHE=ON \
     ARROW_USE_UBSAN=OFF \
diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index a420cb64cb387..1f5596e2a50e1 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -104,7 +104,7 @@ cmake \
   -DARROW_C_FLAGS_DEBUG="${ARROW_C_FLAGS_DEBUG:-}" \
   -DARROW_C_FLAGS_RELEASE="${ARROW_C_FLAGS_RELEASE:-}" \
   -DARROW_C_FLAGS_RELWITHDEBINFO="${ARROW_C_FLAGS_RELWITHDEBINFO:-}" \
-  -DARROW_DATASET=${ARROW_DATASET:-ON} \
+  -DARROW_DATASET=${ARROW_DATASET:-OFF} \
   -DARROW_DEPENDENCY_SOURCE=${ARROW_DEPENDENCY_SOURCE:-AUTO} \
   -DARROW_ENABLE_THREADING=${ARROW_ENABLE_THREADING:-ON} \
   -DARROW_ENABLE_TIMING_TESTS=${ARROW_ENABLE_TIMING_TESTS:-ON} \
@@ -129,7 +129,7 @@ cmake \
   -DARROW_S3=${ARROW_S3:-OFF} \
   -DARROW_SIMD_LEVEL=${ARROW_SIMD_LEVEL:-DEFAULT} \
   -DARROW_SKYHOOK=${ARROW_SKYHOOK:-OFF} \
-  -DARROW_SUBSTRAIT=${ARROW_SUBSTRAIT:-ON} \
+  -DARROW_SUBSTRAIT=${ARROW_SUBSTRAIT:-OFF} \
   -DARROW_TEST_LINKAGE=${ARROW_TEST_LINKAGE:-shared} \
   -DARROW_TEST_MEMCHECK=${ARROW_TEST_MEMCHECK:-OFF} \
   -DARROW_USE_ASAN=${ARROW_USE_ASAN:-OFF} \
diff --git a/ci/scripts/integration_substrait.sh b/ci/scripts/integration_substrait.sh
index ce4c68ceb7a86..f7208ae113814 100755
--- a/ci/scripts/integration_substrait.sh
+++ b/ci/scripts/integration_substrait.sh
@@ -28,4 +28,4 @@ python -c "from substrait_consumer.consumers import AceroConsumer"
 
 echo "Executing pytest"
 cd consumer-testing
-pytest substrait_consumer/tests/functional/extension_functions/test_boolean_functions.py --producer IsthmusProducer --consumer AceroConsumer
+pytest -r s substrait_consumer/tests/functional/extension_functions/test_boolean_functions.py --producer IsthmusProducer --consumer AceroConsumer
diff --git a/ci/scripts/python_build.sh b/ci/scripts/python_build.sh
index b5b5b75b9679a..c0a27e6e705e9 100755
--- a/ci/scripts/python_build.sh
+++ b/ci/scripts/python_build.sh
@@ -54,7 +54,7 @@ fi
 export PYARROW_CMAKE_GENERATOR=${CMAKE_GENERATOR:-Ninja}
 export PYARROW_BUILD_TYPE=${CMAKE_BUILD_TYPE:-debug}
 
-export PYARROW_WITH_ACERO=${ARROW_ACERO:-ON}
+export PYARROW_WITH_ACERO=${ARROW_ACERO:-OFF}
 export PYARROW_WITH_CUDA=${ARROW_CUDA:-OFF}
 export PYARROW_WITH_DATASET=${ARROW_DATASET:-ON}
 export PYARROW_WITH_FLIGHT=${ARROW_FLIGHT:-OFF}
diff --git a/cpp/examples/minimal_build/run_static.sh b/cpp/examples/minimal_build/run_static.sh
index 5b6afbd67aea8..189f59a007b2a 100755
--- a/cpp/examples/minimal_build/run_static.sh
+++ b/cpp/examples/minimal_build/run_static.sh
@@ -39,24 +39,9 @@ NPROC=$(nproc)
 cmake $ARROW_DIR/cpp \
     -DARROW_BUILD_SHARED=OFF \
     -DARROW_BUILD_STATIC=ON \
-    -DARROW_COMPUTE=ON \
     -DARROW_CSV=ON \
-    -DARROW_DATASET=ON \
     -DARROW_DEPENDENCY_SOURCE=${ARROW_DEPENDENCY_SOURCE} \
     -DARROW_DEPENDENCY_USE_SHARED=OFF \
-    -DARROW_FILESYSTEM=ON \
-    -DARROW_HDFS=ON \
-    -DARROW_JEMALLOC=ON \
-    -DARROW_JSON=ON \
-    -DARROW_ORC=ON \
-    -DARROW_PARQUET=ON \
-    -DARROW_WITH_BROTLI=ON \
-    -DARROW_WITH_BZ2=ON \
-    -DARROW_WITH_LZ4=ON \
-    -DARROW_WITH_SNAPPY=ON \
-    -DARROW_WITH_ZLIB=ON \
-    -DARROW_WITH_ZSTD=ON \
-    -DORC_SOURCE=BUNDLED \
     -Dxsimd_SOURCE=BUNDLED \
     $ARROW_CMAKE_OPTIONS
 
diff --git a/docker-compose.yml b/docker-compose.yml
index c193a7d11e0e3..8947eadd70218 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -497,6 +497,8 @@ services:
     environment:
       <<: [*common, *ccache, *sccache, *cpp]
       ARROW_BUILD_UTILITIES: "OFF"
+      ARROW_ACERO: "OFF"
+      ARROW_AZURE: "OFF"
       ARROW_COMPUTE: "OFF"
       ARROW_CSV: "OFF"
       ARROW_DATASET: "OFF"
@@ -1326,8 +1328,10 @@ services:
     shm_size: *shm-size
     environment:
       <<: [*common, *ccache]
+      ARROW_ACERO: "OFF"
       ARROW_DATASET: "OFF"
       ARROW_FLIGHT: "OFF"
+      ARROW_FLIGHT_SQL: "OFF"
       ARROW_GANDIVA: "OFF"
       ARROW_JAVA_CDATA: "ON"
       ARROW_ORC: "OFF"
diff --git a/python/examples/minimal_build/build_conda.sh b/python/examples/minimal_build/build_conda.sh
index a2a1fcbf941aa..cd0030ac5fc65 100755
--- a/python/examples/minimal_build/build_conda.sh
+++ b/python/examples/minimal_build/build_conda.sh
@@ -34,22 +34,19 @@ git config --global --add safe.directory $ARROW_ROOT
 # Run these only once
 
 function setup_miniconda() {
-  MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh"
+  MINICONDA_URL="https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-Linux-x86_64.sh"
   wget -O miniconda.sh $MINICONDA_URL
   bash miniconda.sh -b -p $MINICONDA
   rm -f miniconda.sh
   LOCAL_PATH=$PATH
   export PATH="$MINICONDA/bin:$PATH"
 
-  conda update -y -q conda
-  conda config --set auto_update_conda false
-  conda info -a
+  mamba info -a
 
   conda config --set show_channel_urls True
-  conda config --add channels https://repo.anaconda.com/pkgs/free
-  conda config --add channels conda-forge
+  conda config --show channels
 
-  conda create -y -n pyarrow-$PYTHON -c conda-forge \
+  mamba create -y -n pyarrow-$PYTHON \
         --file arrow/ci/conda_env_unix.txt \
         --file arrow/ci/conda_env_cpp.txt \
         --file arrow/ci/conda_env_python.txt \
@@ -63,7 +60,7 @@ function setup_miniconda() {
 setup_miniconda
 
 #----------------------------------------------------------------------
-# Activate conda in bash and activate conda environment
+# Activate mamba in bash and activate mamba environment
 
 . $MINICONDA/etc/profile.d/conda.sh
 conda activate pyarrow-$PYTHON
@@ -79,13 +76,11 @@ cmake -GNinja \
       -DCMAKE_BUILD_TYPE=DEBUG \
       -DCMAKE_INSTALL_PREFIX=$ARROW_HOME \
       -DCMAKE_INSTALL_LIBDIR=lib \
-      -DARROW_WITH_BZ2=ON \
-      -DARROW_WITH_ZLIB=ON \
-      -DARROW_WITH_ZSTD=ON \
-      -DARROW_WITH_LZ4=ON \
-      -DARROW_WITH_SNAPPY=ON \
-      -DARROW_WITH_BROTLI=ON \
-      -DARROW_PYTHON=ON \
+      -DCMAKE_UNITY_BUILD=ON \
+      -DARROW_COMPUTE=ON \
+      -DARROW_CSV=ON \
+      -DARROW_FILESYSTEM=ON \
+      -DARROW_JSON=ON \
       $ARROW_ROOT/cpp
 
 ninja install
diff --git a/python/examples/minimal_build/build_venv.sh b/python/examples/minimal_build/build_venv.sh
index 2f1bc4ed304dd..d0432049f7a86 100755
--- a/python/examples/minimal_build/build_venv.sh
+++ b/python/examples/minimal_build/build_venv.sh
@@ -46,14 +46,12 @@ cmake -GNinja \
       -DCMAKE_BUILD_TYPE=DEBUG \
       -DCMAKE_INSTALL_PREFIX=$ARROW_HOME \
       -DCMAKE_INSTALL_LIBDIR=lib \
+      -DCMAKE_UNITY_BUILD=ON \
       -DARROW_BUILD_STATIC=OFF \
-      -DARROW_WITH_BZ2=ON \
-      -DARROW_WITH_ZLIB=ON \
-      -DARROW_WITH_ZSTD=ON \
-      -DARROW_WITH_LZ4=ON \
-      -DARROW_WITH_SNAPPY=ON \
-      -DARROW_WITH_BROTLI=ON \
-      -DARROW_PYTHON=ON \
+      -DARROW_COMPUTE=ON \
+      -DARROW_CSV=ON \
+      -DARROW_FILESYSTEM=ON \
+      -DARROW_JSON=ON \
       $ARROW_ROOT/cpp
 
 ninja install

From e883f893adecf3d03b390aeaf9185cf166fe3f50 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Fri, 1 Sep 2023 10:28:33 +0200
Subject: [PATCH 298/749] GH-35641: [CI][C++] Disable precompiled headers
 (#37502)

### Rationale for this change

ccache does not like precompiled headers and does not cache anything in that case, which pessimizes build times.

### What changes are included in this PR?

Disable precompiled headers, and enable unity builds to make up for it.

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

No.

* Closes: #35641

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .github/workflows/cpp.yml         | 2 ++
 .github/workflows/docs_light.yml  | 1 +
 .github/workflows/go.yml          | 2 ++
 .github/workflows/integration.yml | 2 ++
 .github/workflows/java.yml        | 2 ++
 .github/workflows/java_jni.yml    | 2 ++
 .github/workflows/python.yml      | 2 ++
 .github/workflows/r.yml           | 2 ++
 .github/workflows/ruby.yml        | 2 ++
 .github/workflows/swift.yml       | 2 ++
 docker-compose.yml                | 2 --
 11 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 7dd825c72fbd4..bf110c87b5fec 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -29,6 +29,7 @@ on:
       - 'ci/scripts/msys2_*'
       - 'ci/scripts/util_*'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'format/Flight.proto'
   pull_request:
     paths:
@@ -41,6 +42,7 @@ on:
       - 'ci/scripts/msys2_*'
       - 'ci/scripts/util_*'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'format/Flight.proto'
 
 concurrency:
diff --git a/.github/workflows/docs_light.yml b/.github/workflows/docs_light.yml
index b1e6a21eada7b..21185b746eee7 100644
--- a/.github/workflows/docs_light.yml
+++ b/.github/workflows/docs_light.yml
@@ -27,6 +27,7 @@ on:
       - 'ci/docker/conda-python.dockerfile'
       - 'ci/scripts/cpp_build.sh'
       - 'ci/scripts/python_build.sh'
+      - 'docker-compose.yml'
 
 permissions:
   contents: read
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 4aa3eef7852b9..df4f1207ee842 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -23,6 +23,7 @@ on:
       - '.github/workflows/go.yml'
       - 'ci/docker/*_go.dockerfile'
       - 'ci/scripts/go_*'
+      - 'docker-compose.yml'
       - 'go/**'
   pull_request:
     paths:
@@ -30,6 +31,7 @@ on:
       - 'ci/docker/*_go.dockerfile'
       - 'ci/docker/**'
       - 'ci/scripts/go_*'
+      - 'docker-compose.yml'
       - 'go/**'
 
 concurrency:
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index e7efd11c87044..62b61c29bc0ae 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -23,6 +23,7 @@ on:
       - '.github/workflows/integration.yml'
       - 'ci/**'
       - 'dev/archery/**'
+      - 'docker-compose.yml'
       - 'go/**'
       - 'integration/**'
       - 'js/**'
@@ -34,6 +35,7 @@ on:
       - '.github/workflows/integration.yml'
       - 'ci/**'
       - 'dev/archery/**'
+      - 'docker-compose.yml'
       - 'go/**'
       - 'integration/**'
       - 'js/**'
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 8a66d7858af37..49e500b42083f 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -24,6 +24,7 @@ on:
       - 'ci/docker/*java*'
       - 'ci/scripts/java*.sh'
       - 'ci/scripts/util_*.sh'
+      - 'docker-compose.yml'
       - 'format/Flight.proto'
       - 'java/**'
   pull_request:
@@ -32,6 +33,7 @@ on:
       - 'ci/docker/*java*'
       - 'ci/scripts/java*.sh'
       - 'ci/scripts/util_*.sh'
+      - 'docker-compose.yml'
       - 'format/Flight.proto'
       - 'java/**'
 
diff --git a/.github/workflows/java_jni.yml b/.github/workflows/java_jni.yml
index 2787ac1fc71a4..2bfc7c82c25da 100644
--- a/.github/workflows/java_jni.yml
+++ b/.github/workflows/java_jni.yml
@@ -25,6 +25,7 @@ on:
       - 'ci/scripts/cpp_build.sh'
       - 'ci/scripts/java_*'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'java/**'
   pull_request:
     paths:
@@ -33,6 +34,7 @@ on:
       - 'ci/scripts/cpp_build.sh'
       - 'ci/scripts/java_*'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'java/**'
 
 concurrency:
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index bf7d2827f6ba7..76f76411b6e11 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -23,12 +23,14 @@ on:
       - '.github/workflows/python.yml'
       - 'ci/**'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'python/**'
   pull_request:
     paths:
       - '.github/workflows/python.yml'
       - 'ci/**'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'python/**'
 
 concurrency:
diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml
index 807d21b6c800c..3e3a4f856e4c5 100644
--- a/.github/workflows/r.yml
+++ b/.github/workflows/r.yml
@@ -27,6 +27,7 @@ on:
       - "ci/etc/rprofile"
       - "ci/docker/**"
       - "cpp/**"
+      - 'docker-compose.yml'
       - "r/**"
   pull_request:
     paths:
@@ -37,6 +38,7 @@ on:
       - "ci/etc/rprofile"
       - "ci/docker/**"
       - "cpp/**"
+      - 'docker-compose.yml'
       - "r/**"
 
 concurrency:
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index af4f34fee2b10..33f0c5b89c139 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -29,6 +29,7 @@ on:
       - 'ci/scripts/util_*'
       - 'c_glib/**'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'ruby/**'
   pull_request:
     paths:
@@ -41,6 +42,7 @@ on:
       - 'ci/scripts/util_*'
       - 'c_glib/**'
       - 'cpp/**'
+      - 'docker-compose.yml'
       - 'ruby/**'
 
 concurrency:
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
index 2169dfe525898..b2ee3f0b3cab3 100644
--- a/.github/workflows/swift.yml
+++ b/.github/workflows/swift.yml
@@ -23,12 +23,14 @@ on:
       - '.github/workflows/swift.yml'
       - 'ci/docker/*swift*'
       - 'ci/scripts/swift_*'
+      - 'docker-compose.yml'
       - 'swift/**'
   pull_request:
     paths:
       - '.github/workflows/swift.yml'
       - 'ci/docker/*swift*'
       - 'ci/scripts/swift_*'
+      - 'docker-compose.yml'
       - 'swift/**'
 
 concurrency:
diff --git a/docker-compose.yml b/docker-compose.yml
index 8947eadd70218..a79b13c0a5f91 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -289,7 +289,6 @@ services:
       ARROW_EXTRA_ERROR_CONTEXT: "ON"
       ARROW_MIMALLOC: "ON"
       ARROW_USE_LD_GOLD: "ON"
-      ARROW_USE_PRECOMPILED_HEADERS: "ON"
       BUILD_DOCS_PYTHON: "ON"
     volumes: &conda-volumes
       - .:/arrow:delegated
@@ -1851,7 +1850,6 @@ services:
       ARROW_HDFS_TEST_PORT: 8020
       ARROW_HDFS_TEST_USER: hdfs
       ARROW_S3: "OFF"
-      CMAKE_UNITY_BUILD: "ON"
     shm_size: *shm-size
     volumes: &conda-maven-volumes
       - .:/arrow:delegated

From faa7cf6bcf412677a379ca28fbbb5582c0715cb6 Mon Sep 17 00:00:00 2001
From: Alex Shcherbakov <candiduslynx@users.noreply.github.com>
Date: Fri, 1 Sep 2023 18:41:28 +0300
Subject: [PATCH 299/749] MINOR: [Go] Make `arrow.TimestampType.GetToTimeFunc`
 similar to `arrow.Timestamp.ToTime` (#37512)

### Rationale for this change

Follow-up for https://github.com/apache/arrow/pull/36964

### What changes are included in this PR?

Make the `arrow.TimestampType.GetToTimeFunc` similar to `arrow.Timestamp.ToTime` in order not to get overflows.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No.

Authored-by: candiduslynx <candiduslynx@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/datatype_fixedwidth.go      | 14 ++++----------
 go/arrow/datatype_fixedwidth_test.go | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index f8806d25e201c..7f62becdc2884 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -374,9 +374,9 @@ func (t *TimestampType) Fingerprint() string {
 // BitWidth returns the number of bits required to store a single element of this data type in memory.
 func (*TimestampType) BitWidth() int { return 64 }
 
-func (TimestampType) Bytes() int { return Int64SizeBytes }
+func (*TimestampType) Bytes() int { return Int64SizeBytes }
 
-func (TimestampType) Layout() DataTypeLayout {
+func (*TimestampType) Layout() DataTypeLayout {
 	return DataTypeLayout{Buffers: []BufferSpec{SpecBitmap(), SpecFixedWidth(TimestampSizeBytes)}}
 }
 
@@ -444,15 +444,9 @@ func (t *TimestampType) GetToTimeFunc() (func(Timestamp) time.Time, error) {
 	case Second:
 		return func(v Timestamp) time.Time { return time.Unix(int64(v), 0).In(tz) }, nil
 	case Millisecond:
-		factor := int64(time.Second / time.Millisecond)
-		return func(v Timestamp) time.Time {
-			return time.Unix(int64(v)/factor, (int64(v)%factor)*int64(time.Millisecond)).In(tz)
-		}, nil
+		return func(v Timestamp) time.Time { return time.UnixMilli(int64(v)).In(tz) }, nil
 	case Microsecond:
-		factor := int64(time.Second / time.Microsecond)
-		return func(v Timestamp) time.Time {
-			return time.Unix(int64(v)/factor, (int64(v)%factor)*int64(time.Microsecond)).In(tz)
-		}, nil
+		return func(v Timestamp) time.Time { return time.UnixMicro(int64(v)).In(tz) }, nil
 	case Nanosecond:
 		return func(v Timestamp) time.Time { return time.Unix(0, int64(v)).In(tz) }, nil
 	}
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index bf93f0fc61c67..1d3a07de09c1d 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -166,6 +166,20 @@ func TestTimestampToTime(t *testing.T) {
 	assert.Equal(t, "2345-12-30 00:00:00", tm.Format("2006-01-02 15:04:05.999"))
 }
 
+func TestTimestampType_GetToTimeFunc(t *testing.T) {
+	typUTC := &arrow.TimestampType{Unit: arrow.Millisecond}
+	toTimeUTC, err := typUTC.GetToTimeFunc()
+	assert.NoError(t, err)
+
+	typNY := &arrow.TimestampType{Unit: arrow.Millisecond, TimeZone: "America/New_York"}
+	toTimeNY, err := typNY.GetToTimeFunc()
+	assert.NoError(t, err)
+
+	ts := arrow.Timestamp(11865225600000)
+	assert.Equal(t, "2345-12-30T00:00:00Z", toTimeUTC(ts).Format(time.RFC3339))
+	assert.Equal(t, "2345-12-29T19:00:00-05:00", toTimeNY(ts).Format(time.RFC3339))
+}
+
 func TestTime32Type(t *testing.T) {
 	for _, tc := range []struct {
 		unit arrow.TimeUnit

From a43206846a02028fc2ac5091c388aa65b07799c1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 2 Sep 2023 06:00:11 +0900
Subject: [PATCH 300/749] MINOR: [JS] Bump del-cli from 5.0.0 to 5.1.0 in /js
 (#37518)

Bumps [del-cli](https://github.com/sindresorhus/del-cli) from 5.0.0 to 5.1.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/sindresorhus/del-cli/releases">del-cli's releases</a>.</em></p>
<blockquote>
<h2>v5.1.0</h2>
<ul>
<li>Add <code>--verbose</code> flag (<a href="https://redirect.github.com/sindresorhus/del-cli/issues/37">#37</a>)  f32b531</li>
</ul>
<p><a href="https://github.com/sindresorhus/del-cli/compare/v5.0.1...v5.1.0">https://github.com/sindresorhus/del-cli/compare/v5.0.1...v5.1.0</a></p>
<h2>v5.0.1</h2>
<ul>
<li>Fix Windows compatibility for use with <code>npx</code>  537e5b3</li>
</ul>
<p><a href="https://github.com/sindresorhus/del-cli/compare/v5.0.0...v5.0.1">https://github.com/sindresorhus/del-cli/compare/v5.0.0...v5.0.1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/sindresorhus/del-cli/commit/7de3b1e46c1e0b8477c8300d37c1f2218ba6b338"><code>7de3b1e</code></a> 5.1.0</li>
<li><a href="https://github.com/sindresorhus/del-cli/commit/f32b531d9425c61452ef92db965200eb059f6007"><code>f32b531</code></a> Add <code>--verbose</code> flag (<a href="https://redirect.github.com/sindresorhus/del-cli/issues/37">#37</a>)</li>
<li><a href="https://github.com/sindresorhus/del-cli/commit/dde9e112afda2a95195847f79b547aa443991d45"><code>dde9e11</code></a> Fix broken build (<a href="https://redirect.github.com/sindresorhus/del-cli/issues/36">#36</a>)</li>
<li><a href="https://github.com/sindresorhus/del-cli/commit/e3f699652ce8e11382e77f79a62714a3cbdf2976"><code>e3f6996</code></a> 5.0.1</li>
<li><a href="https://github.com/sindresorhus/del-cli/commit/537e5b39e228292817d9a94c57cfb04f543d9803"><code>537e5b3</code></a> Fix Windows compatibility for use with <code>npx</code></li>
<li>See full diff in <a href="https://github.com/sindresorhus/del-cli/compare/v5.0.0...v5.1.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=del-cli&package-manager=npm_and_yarn&previous-version=5.0.0&new-version=5.1.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 26 ++++++++++++++++++++------
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/js/package.json b/js/package.json
index deb107d727689..fadaac87449e2 100644
--- a/js/package.json
+++ b/js/package.json
@@ -78,7 +78,7 @@
     "benny": "3.7.1",
     "cross-env": "7.0.3",
     "del": "7.0.0",
-    "del-cli": "5.0.0",
+    "del-cli": "5.1.0",
     "esbuild": "0.19.0",
     "esbuild-plugin-alias": "0.2.1",
     "eslint": "8.42.0",
diff --git a/js/yarn.lock b/js/yarn.lock
index 0d0a50933598f..e8814f111b1f7 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -2487,15 +2487,15 @@ define-property@^2.0.2:
     is-descriptor "^1.0.2"
     isobject "^3.0.1"
 
-del-cli@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/del-cli/-/del-cli-5.0.0.tgz#fa79fd57e888ecaaf8a468d87e8a175142a24aa9"
-  integrity sha512-rENFhUaYcjoMODwFhhlON+ogN7DoG+4+GFN+bsA1XeDt4w2OKQnQadFP1thHSAlK9FAtl88qgP66wOV+eFZZiQ==
+del-cli@5.1.0:
+  version "5.1.0"
+  resolved "https://registry.yarnpkg.com/del-cli/-/del-cli-5.1.0.tgz#740eca1c7a9eb13043e68d8a361cf0ff9a18d5c8"
+  integrity sha512-xwMeh2acluWeccsfzE7VLsG3yTr7nWikbfw+xhMnpRrF15pGSkw+3/vJZWlGoE4I86UiLRNHicmKt4tkIX9Jtg==
   dependencies:
-    del "^7.0.0"
+    del "^7.1.0"
     meow "^10.1.3"
 
-del@7.0.0, del@^7.0.0:
+del@7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/del/-/del-7.0.0.tgz#79db048bec96f83f344b46c1a66e35d9c09fe8ac"
   integrity sha512-tQbV/4u5WVB8HMJr08pgw0b6nG4RGt/tj+7Numvq+zqcvUFeMaIWWOUFltiU+6go8BSO2/ogsB4EasDaj0y68Q==
@@ -2509,6 +2509,20 @@ del@7.0.0, del@^7.0.0:
     rimraf "^3.0.2"
     slash "^4.0.0"
 
+del@^7.1.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/del/-/del-7.1.0.tgz#0de0044d556b649ff05387f1fa7c885e155fd1b6"
+  integrity sha512-v2KyNk7efxhlyHpjEvfyxaAihKKK0nWCuf6ZtqZcFFpQRG0bJ12Qsr0RpvsICMjAAZ8DOVCxrlqpxISlMHC4Kg==
+  dependencies:
+    globby "^13.1.2"
+    graceful-fs "^4.2.10"
+    is-glob "^4.0.3"
+    is-path-cwd "^3.0.0"
+    is-path-inside "^4.0.0"
+    p-map "^5.5.0"
+    rimraf "^3.0.2"
+    slash "^4.0.0"
+
 detect-file@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"

From 562b0d3f3c79b5ad9afb70bb909c89ad493fa3fd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 2 Sep 2023 07:02:22 +0900
Subject: [PATCH 301/749] MINOR: [JS] Bump webpack-bundle-analyzer from 4.9.0
 to 4.9.1 in /js (#37521)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [webpack-bundle-analyzer](https://github.com/webpack-contrib/webpack-bundle-analyzer) from 4.9.0 to 4.9.1.
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/master/CHANGELOG.md">webpack-bundle-analyzer's changelog</a>.</em></p>
<blockquote>
<h2>4.9.1</h2>
<ul>
<li>
<p><strong>Internal</strong></p>
<ul>
<li>Replace some lodash usages with JavaScript native API (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/pull/505">#505</a>) by <a href="https://github.com/sukkaw"><code>@​sukkaw</code></a>.</li>
<li>Make module much slimmer (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/pull/609">#609</a>) by <a href="https://github.com/sukkaw"><code>@​sukkaw</code></a>.</li>
</ul>
</li>
<li>
<p><strong>Bug Fix</strong></p>
<ul>
<li>fix <code>analyzerMode: 'server'</code> on certain machines (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/pull/611">#611</a> by <a href="https://github.com/panbenson"><code>@​panbenson</code></a>)</li>
</ul>
</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/52bf2eaf067f192ea5f6750ed17a591923806a7b"><code>52bf2ea</code></a> v4.9.1</li>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/a0e04ef295159e158682e1bd949bf7fc5ac7e747"><code>a0e04ef</code></a> bump sirv to fix analyzerMode server (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/issues/611">#611</a>)</li>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/e2a6479a7da1fd0130b69bfbcea4b3fd5f3dd415"><code>e2a6479</code></a> Reduce installation size (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/issues/609">#609</a>)</li>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/e120231d662e29bbd40d885cba017db2417aed71"><code>e120231</code></a> Reduce the usage of lodash (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/issues/505">#505</a>)</li>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/ff7631df5732d66249c383a06ea7861125d30c06"><code>ff7631d</code></a> Bump tough-cookie from 4.0.0 to 4.1.3 (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/issues/606">#606</a>)</li>
<li><a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/commit/d936b0e89379480fa15d0daa78813d479a66a4a0"><code>d936b0e</code></a> Bump word-wrap from 1.2.3 to 1.2.4 (<a href="https://redirect.github.com/webpack-contrib/webpack-bundle-analyzer/issues/608">#608</a>)</li>
<li>See full diff in <a href="https://github.com/webpack-contrib/webpack-bundle-analyzer/compare/v4.9.0...v4.9.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=webpack-bundle-analyzer&package-manager=npm_and_yarn&previous-version=4.9.0&new-version=4.9.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 73 +++++++++++++++++++++++++++++++++++++------------
 2 files changed, 56 insertions(+), 19 deletions(-)

diff --git a/js/package.json b/js/package.json
index fadaac87449e2..3c100033c4e7d 100644
--- a/js/package.json
+++ b/js/package.json
@@ -114,7 +114,7 @@
     "vinyl-source-stream": "2.0.0",
     "web-streams-polyfill": "3.2.1",
     "webpack": "5.86.0",
-    "webpack-bundle-analyzer": "4.9.0",
+    "webpack-bundle-analyzer": "4.9.1",
     "webpack-stream": "7.0.0",
     "xml2js": "0.6.2"
   },
diff --git a/js/yarn.lock b/js/yarn.lock
index e8814f111b1f7..035d17416ab1b 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -2056,7 +2056,7 @@ chalk-template@^0.4.0:
   dependencies:
     chalk "^4.1.2"
 
-chalk@4.x, chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
+chalk@4.x, chalk@^4.0.0, chalk@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
@@ -4772,11 +4772,31 @@ lodash.clone@^4.3.2:
   resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-4.5.0.tgz#195870450f5a13192478df4bc3d23d2dea1907b6"
   integrity sha512-GhrVeweiTD6uTmmn5hV/lzgCQhccwReIVRLHp7LT4SopOjqEZ5BbX8b5WWEtAKasjmy8hR7ZPwsYlxRCku5odg==
 
+lodash.debounce@^4.0.8:
+  version "4.0.8"
+  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
+  integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==
+
+lodash.escape@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/lodash.escape/-/lodash.escape-4.0.1.tgz#c9044690c21e04294beaa517712fded1fa88de98"
+  integrity sha512-nXEOnb/jK9g0DYMr1/Xvq6l5xMD7GDG55+GSYIYmS0G4tBk/hURD4JR9WCavs04t33WmJx9kCyp9vJ+mr4BOUw==
+
+lodash.flatten@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
+  integrity sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==
+
 lodash.get@^4.4.2:
   version "4.4.2"
   resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
   integrity sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==
 
+lodash.invokemap@^4.6.0:
+  version "4.6.0"
+  resolved "https://registry.yarnpkg.com/lodash.invokemap/-/lodash.invokemap-4.6.0.tgz#1748cda5d8b0ef8369c4eb3ec54c21feba1f2d62"
+  integrity sha512-CfkycNtMqgUlfjfdh2BhKO/ZXrP8ePOX5lEU/g0R3ItJcnuxWDwokMGKx1hWcfOikmyOVx6X9IwWnDGlgKl61w==
+
 lodash.memoize@4.x:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
@@ -4787,12 +4807,22 @@ lodash.merge@^4.6.2:
   resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
   integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
 
+lodash.pullall@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/lodash.pullall/-/lodash.pullall-4.2.0.tgz#9d98b8518b7c965b0fae4099bd9fb7df8bbf38ba"
+  integrity sha512-VhqxBKH0ZxPpLhiu68YD1KnHmbhQJQctcipvmFnqIBDYzcIHzf3Zpu0tpeOKtR4x76p9yohc506eGdOjTmyIBg==
+
 lodash.some@^4.2.2:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/lodash.some/-/lodash.some-4.6.0.tgz#1bb9f314ef6b8baded13b549169b2a945eb68e4d"
   integrity sha512-j7MJE+TuT51q9ggt4fSgVqro163BEFjAt3u97IqU+JA2DkWl80nFTrowzLpZ/BnpN7rrl0JA/593NAdd8p/scQ==
 
-lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.4:
+lodash.uniqby@^4.7.0:
+  version "4.7.0"
+  resolved "https://registry.yarnpkg.com/lodash.uniqby/-/lodash.uniqby-4.7.0.tgz#d99c07a669e9e6d24e1362dfe266c67616af1302"
+  integrity sha512-e/zcLx6CSbmaEgFHCA7BnoQKyCtKMxnuWrJygbwPs/AIn+IMKl66L8/s+wBUn5LRw2pZx3bUHibiV1b6aTWIww==
+
+lodash@^4.17.21, lodash@^4.17.4:
   version "4.17.21"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
@@ -6065,14 +6095,14 @@ signal-exit@^4.0.1:
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.0.2.tgz#ff55bb1d9ff2114c13b400688fa544ac63c36967"
   integrity sha512-MY2/qGx4enyjprQnFaZsHib3Yadh3IXyV2C321GY0pjGfVBu4un0uDJkwgdxqO+Rdx8JMT8IfJIRwbYVz3Ob3Q==
 
-sirv@^1.0.7:
-  version "1.0.19"
-  resolved "https://registry.yarnpkg.com/sirv/-/sirv-1.0.19.tgz#1d73979b38c7fe91fcba49c85280daa9c2363b49"
-  integrity sha512-JuLThK3TnZG1TAKDwNIqNq6QA2afLOCcm+iE8D1Kj3GA40pSPsxQjjJl0J8X3tsR7T+CP1GavpzLwYkgVLWrZQ==
+sirv@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.3.tgz#ca5868b87205a74bef62a469ed0296abceccd446"
+  integrity sha512-O9jm9BsID1P+0HOi81VpXPoDxYP374pkOLzACAoyUQ/3OUVndNpsz6wMnY2z+yOxzbllCKZrM+9QrWsv4THnyA==
   dependencies:
     "@polka/url" "^1.0.0-next.20"
     mrmime "^1.0.0"
-    totalist "^1.0.0"
+    totalist "^3.0.0"
 
 sisteransi@^1.0.5:
   version "1.0.5"
@@ -6590,10 +6620,10 @@ to-through@^2.0.0:
   dependencies:
     through2 "^2.0.3"
 
-totalist@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/totalist/-/totalist-1.1.0.tgz#a4d65a3e546517701e3e5c37a47a70ac97fe56df"
-  integrity sha512-gduQwd1rOdDMGxFG1gEvhV88Oirdo2p+KjoYFU7k2g+i7n6AFFbDQ5kMPUsW0pNbfQsB/cwXvT1i4Bue0s9g5g==
+totalist@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/totalist/-/totalist-3.0.1.tgz#ba3a3d600c915b1a97872348f79c127475f6acf8"
+  integrity sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==
 
 trim-newlines@^4.0.2:
   version "4.1.1"
@@ -6972,20 +7002,27 @@ web-streams-polyfill@3.2.1:
   resolved "https://registry.yarnpkg.com/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz#71c2718c52b45fd49dbeee88634b3a60ceab42a6"
   integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==
 
-webpack-bundle-analyzer@4.9.0:
-  version "4.9.0"
-  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.9.0.tgz#fc093c4ab174fd3dcbd1c30b763f56d10141209d"
-  integrity sha512-+bXGmO1LyiNx0i9enBu3H8mv42sj/BJWhZNFwjz92tVnBa9J3JMGo2an2IXlEleoDOPn/Hofl5hr/xCpObUDtw==
+webpack-bundle-analyzer@4.9.1:
+  version "4.9.1"
+  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.9.1.tgz#d00bbf3f17500c10985084f22f1a2bf45cb2f09d"
+  integrity sha512-jnd6EoYrf9yMxCyYDPj8eutJvtjQNp8PHmni/e/ulydHBWhT5J3menXt3HEkScsu9YqMAcG4CfFjs3rj5pVU1w==
   dependencies:
     "@discoveryjs/json-ext" "0.5.7"
     acorn "^8.0.4"
     acorn-walk "^8.0.0"
-    chalk "^4.1.0"
     commander "^7.2.0"
+    escape-string-regexp "^4.0.0"
     gzip-size "^6.0.0"
-    lodash "^4.17.20"
+    is-plain-object "^5.0.0"
+    lodash.debounce "^4.0.8"
+    lodash.escape "^4.0.1"
+    lodash.flatten "^4.4.0"
+    lodash.invokemap "^4.6.0"
+    lodash.pullall "^4.2.0"
+    lodash.uniqby "^4.7.0"
     opener "^1.5.2"
-    sirv "^1.0.7"
+    picocolors "^1.0.0"
+    sirv "^2.0.3"
     ws "^7.3.1"
 
 webpack-sources@^3.2.3:

From caa94a446a07508cc4327bc9e848ae4c6526a33e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 2 Sep 2023 07:37:04 +0900
Subject: [PATCH 302/749] MINOR: [JS] Bump gulp-vinyl-size from 1.1.3 to 1.1.4
 in /js (#37522)

Bumps [gulp-vinyl-size](https://github.com/burntcustard/gulp-vinyl-size) from 1.1.3 to 1.1.4.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/burntcustard/gulp-vinyl-size/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=gulp-vinyl-size&package-manager=npm_and_yarn&previous-version=1.1.3&new-version=1.1.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 27 +++++++++++++++++----------
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/js/package.json b/js/package.json
index 3c100033c4e7d..031f465cabcd9 100644
--- a/js/package.json
+++ b/js/package.json
@@ -95,7 +95,7 @@
     "gulp-sourcemaps": "3.0.0",
     "gulp-terser": "2.1.0",
     "gulp-typescript": "5.0.1",
-    "gulp-vinyl-size": "1.1.3",
+    "gulp-vinyl-size": "1.1.4",
     "ix": "5.0.0",
     "jest": "29.6.2",
     "jest-silent-reporter": "0.5.0",
diff --git a/js/yarn.lock b/js/yarn.lock
index 035d17416ab1b..c528a166e554c 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -3029,6 +3029,13 @@ fancy-log@^1.3.2, fancy-log@^1.3.3:
     parse-node-version "^1.0.0"
     time-stamp "^1.0.0"
 
+fancy-log@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/fancy-log/-/fancy-log-2.0.0.tgz#cad207b8396d69ae4796d74d17dff5f68b2f7343"
+  integrity sha512-9CzxZbACXMUXW13tS0tI8XsGGmxWzO2DmYrGuBJOJ8k8q2K7hwfJA5qHjuPPe8wtsco33YR9wc+Rlr5wYFvhSA==
+  dependencies:
+    color-support "^1.1.3"
+
 fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
@@ -3091,10 +3098,10 @@ file-uri-to-path@1.0.0:
   resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
   integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
 
-filesize@^8.0.7:
-  version "8.0.7"
-  resolved "https://registry.yarnpkg.com/filesize/-/filesize-8.0.7.tgz#695e70d80f4e47012c132d57a059e80c6b580bd8"
-  integrity sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==
+filesize@^9.0.11:
+  version "9.0.11"
+  resolved "https://registry.yarnpkg.com/filesize/-/filesize-9.0.11.tgz#4ac3a42c084232dd9b2a1da0107f32d42fcfa5e4"
+  integrity sha512-gTAiTtI0STpKa5xesyTA9hA3LX4ga8sm2nWRcffEa1L/5vQwb4mj2MdzMkoHoGv4QzfDshQZuYscQSf8c4TKOA==
 
 fill-range@^4.0.0:
   version "4.0.0"
@@ -3604,13 +3611,13 @@ gulp-typescript@5.0.1:
     vinyl "^2.1.0"
     vinyl-fs "^3.0.3"
 
-gulp-vinyl-size@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/gulp-vinyl-size/-/gulp-vinyl-size-1.1.3.tgz#9916e15a7b504289a1d443ed6f55cbdea47d0be3"
-  integrity sha512-ZIBCHldmuhAFK6ioH7ZRPw00oRwVjFDBIKfpAMwjK6f2MfH+nyQWmBnGpQ06rmUZH0fATKCR8Kop7+VgBjWsBg==
+gulp-vinyl-size@1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/gulp-vinyl-size/-/gulp-vinyl-size-1.1.4.tgz#06b98a8aa9f91f420ea3068798800aa21f8ccdc1"
+  integrity sha512-k8QTnUD69CnQnbpbXExFRtMDtQ9jIc5nZXYyVNB5Z+7xrZIO3hVS0zotoWwZawgtBLNLvAnm6JZ3zL+O1ysQ3A==
   dependencies:
-    fancy-log "^1.3.3"
-    filesize "^8.0.7"
+    fancy-log "^2.0.0"
+    filesize "^9.0.11"
     gzip-size "^6.0.0"
 
 gulp@4.0.2:

From 8da657f2aba900030f38da4b647740dbd3567d0c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 3 Sep 2023 16:08:43 +0900
Subject: [PATCH 303/749] MINOR: [JS] Bump esbuild from 0.19.0 to 0.19.2 in /js
 (#37519)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [esbuild](https://github.com/evanw/esbuild) from 0.19.0 to 0.19.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/evanw/esbuild/releases">esbuild's releases</a>.</em></p>
<blockquote>
<h2>v0.19.2</h2>
<ul>
<li>
<p>Update how CSS nesting is parsed again</p>
<p>CSS nesting syntax has been changed again, and esbuild has been updated to match. Type selectors may now be used with CSS nesting:</p>
<pre lang="css"><code>.foo {
  div {
    color: red;
  }
}
</code></pre>
<p>Previously this was disallowed in the CSS specification because it's ambiguous whether an identifier is a declaration or a nested rule starting with a type selector without requiring unbounded lookahead in the parser. It has now been allowed because the CSS working group has decided that requiring unbounded lookahead is acceptable after all.</p>
<p>Note that this change means esbuild no longer considers any existing browser to support CSS nesting since none of the existing browsers support this new syntax. CSS nesting will now always be transformed when targeting a browser. This situation will change in the future as browsers add support for this new syntax.</p>
</li>
<li>
<p>Fix a scope-related bug with <code>--drop-labels=</code> (<a href="https://redirect.github.com/evanw/esbuild/issues/3311">#3311</a>)</p>
<p>The recently-released <code>--drop-labels=</code> feature previously had a bug where esbuild's internal scope stack wasn't being restored properly when a statement with a label was dropped. This could manifest as a tree-shaking issue, although it's possible that this could have also been causing other subtle problems too. The bug has been fixed in this release.</p>
</li>
<li>
<p>Make renamed CSS names unique across entry points (<a href="https://redirect.github.com/evanw/esbuild/issues/3295">#3295</a>)</p>
<p>Previously esbuild's generated names for local names in CSS were only unique within a given entry point (or across all entry points when code splitting was enabled). That meant that building multiple entry points with esbuild could result in local names being renamed to the same identifier even when those entry points were built simultaneously within a single esbuild API call. This problem was especially likely to happen with minification enabled. With this release, esbuild will now avoid renaming local names from two separate entry points to the same name if those entry points were built with a single esbuild API call, even when code splitting is disabled.</p>
</li>
<li>
<p>Fix CSS ordering bug with <code>@ layer</code> before <code>@ import</code></p>
<p>CSS lets you put <code>@ layer</code> rules before <code>@ import</code> rules to define the order of layers in a stylesheet. Previously esbuild's CSS bundler incorrectly ordered these after the imported files because before the introduction of cascade layers to CSS, imported files could be bundled by removing the <code>@ import</code> rules and then joining files together in the right order. But with <code>@ layer</code>, CSS files may now need to be split apart into multiple pieces in the bundle. For example:</p>
<pre><code>/* Original code */
@ layer start;
@ import &quot;data:text/css,@ layer inner.start;&quot;;
@ import &quot;data:text/css,@ layer inner.end;&quot;;
@ layer end;
<p>/* Old output (with --bundle) */
<a href="https://github.com/layer"><code>@​layer</code></a> inner.start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.end;
<a href="https://github.com/layer"><code>@​layer</code></a> start;
<a href="https://github.com/layer"><code>@​layer</code></a> end;</p>
<p>/* New output (with --bundle) */
<a href="https://github.com/layer"><code>@​layer</code></a> start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.end;
<a href="https://github.com/layer"><code>@​layer</code></a> end;
</code></pre></p>
</li>
<li>
<p>Unwrap nested duplicate <code>@ media</code> rules (<a href="https://redirect.github.com/evanw/esbuild/issues/3226">#3226</a>)</p>
</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/evanw/esbuild/blob/main/CHANGELOG.md">esbuild's changelog</a>.</em></p>
<blockquote>
<h2>0.19.2</h2>
<ul>
<li>
<p>Update how CSS nesting is parsed again</p>
<p>CSS nesting syntax has been changed again, and esbuild has been updated to match. Type selectors may now be used with CSS nesting:</p>
<pre lang="css"><code>.foo {
  div {
    color: red;
  }
}
</code></pre>
<p>Previously this was disallowed in the CSS specification because it's ambiguous whether an identifier is a declaration or a nested rule starting with a type selector without requiring unbounded lookahead in the parser. It has now been allowed because the CSS working group has decided that requiring unbounded lookahead is acceptable after all.</p>
<p>Note that this change means esbuild no longer considers any existing browser to support CSS nesting since none of the existing browsers support this new syntax. CSS nesting will now always be transformed when targeting a browser. This situation will change in the future as browsers add support for this new syntax.</p>
</li>
<li>
<p>Fix a scope-related bug with <code>--drop-labels=</code> (<a href="https://redirect.github.com/evanw/esbuild/issues/3311">#3311</a>)</p>
<p>The recently-released <code>--drop-labels=</code> feature previously had a bug where esbuild's internal scope stack wasn't being restored properly when a statement with a label was dropped. This could manifest as a tree-shaking issue, although it's possible that this could have also been causing other subtle problems too. The bug has been fixed in this release.</p>
</li>
<li>
<p>Make renamed CSS names unique across entry points (<a href="https://redirect.github.com/evanw/esbuild/issues/3295">#3295</a>)</p>
<p>Previously esbuild's generated names for local names in CSS were only unique within a given entry point (or across all entry points when code splitting was enabled). That meant that building multiple entry points with esbuild could result in local names being renamed to the same identifier even when those entry points were built simultaneously within a single esbuild API call. This problem was especially likely to happen with minification enabled. With this release, esbuild will now avoid renaming local names from two separate entry points to the same name if those entry points were built with a single esbuild API call, even when code splitting is disabled.</p>
</li>
<li>
<p>Fix CSS ordering bug with <code>@ layer</code> before <code>@ import</code></p>
<p>CSS lets you put <code>@ layer</code> rules before <code>@ import</code> rules to define the order of layers in a stylesheet. Previously esbuild's CSS bundler incorrectly ordered these after the imported files because before the introduction of cascade layers to CSS, imported files could be bundled by removing the <code>@ import</code> rules and then joining files together in the right order. But with <code>@ layer</code>, CSS files may now need to be split apart into multiple pieces in the bundle. For example:</p>
<pre><code>/* Original code */
@ layer start;
@ import &quot;data:text/css,@ layer inner.start;&quot;;
@ import &quot;data:text/css,@ layer inner.end;&quot;;
@ layer end;
<p>/* Old output (with --bundle) */
<a href="https://github.com/layer"><code>@​layer</code></a> inner.start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.end;
<a href="https://github.com/layer"><code>@​layer</code></a> start;
<a href="https://github.com/layer"><code>@​layer</code></a> end;</p>
<p>/* New output (with --bundle) */
<a href="https://github.com/layer"><code>@​layer</code></a> start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.start;
<a href="https://github.com/layer"><code>@​layer</code></a> inner.end;
<a href="https://github.com/layer"><code>@​layer</code></a> end;
</code></pre></p>
</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/evanw/esbuild/commit/09a100124e9daef9e0be57d21cc7729c6f3516e7"><code>09a1001</code></a> publish 0.19.2 to npm</li>
<li><a href="https://github.com/evanw/esbuild/commit/4d9b764f11b8f52024c798f3e3361be9f575b1cc"><code>4d9b764</code></a> fix <a href="https://redirect.github.com/evanw/esbuild/issues/3311">#3311</a>: pop scope after <code>--drop-labels=</code> runs</li>
<li><a href="https://github.com/evanw/esbuild/commit/f2d23b294e41253062f6c49fd7e339dfb8019940"><code>f2d23b2</code></a> fix some typos</li>
<li><a href="https://github.com/evanw/esbuild/commit/e76780c041b15fbf5d273861af2a95707f1621f1"><code>e76780c</code></a> css: further changes to css nesting syntax</li>
<li><a href="https://github.com/evanw/esbuild/commit/71f4a5aff3c943d2f44c606337a9a4d5ef530e31"><code>71f4a5a</code></a> update compat-table (note: css nesting changed)</li>
<li><a href="https://github.com/evanw/esbuild/commit/eb667c35bd1c32b3ea2fc5f56326665298131b3a"><code>eb667c3</code></a> css: try to merge adjacent <code>@ layer</code> rules together</li>
<li><a href="https://github.com/evanw/esbuild/commit/f7596931bb79ab8708dd630aa729d49bc68bbbbd"><code>f759693</code></a> css: fix ordering with <code>@ layer</code> before <code>@ import</code></li>
<li><a href="https://github.com/evanw/esbuild/commit/c73f0f8fc9185f7b2335363a2f8b98e29077a327"><code>c73f0f8</code></a> css: extract wrapping logic to a helper function</li>
<li><a href="https://github.com/evanw/esbuild/commit/a05a2f9c7a91dbe32202f4e963c8aca9ec24481d"><code>a05a2f9</code></a> css: make source index on compile results optional</li>
<li><a href="https://github.com/evanw/esbuild/commit/bb16fb7a92f07136d4b5b6a07132367e6533dc59"><code>bb16fb7</code></a> css: parser separates layers pre/post <code>@ import</code></li>
<li>Additional commits viewable in <a href="https://github.com/evanw/esbuild/compare/v0.19.0...v0.19.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=esbuild&package-manager=npm_and_yarn&previous-version=0.19.0&new-version=0.19.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |   2 +-
 js/yarn.lock    | 228 ++++++++++++++++++++++++------------------------
 2 files changed, 115 insertions(+), 115 deletions(-)

diff --git a/js/package.json b/js/package.json
index 031f465cabcd9..75e8132907cb6 100644
--- a/js/package.json
+++ b/js/package.json
@@ -79,7 +79,7 @@
     "cross-env": "7.0.3",
     "del": "7.0.0",
     "del-cli": "5.1.0",
-    "esbuild": "0.19.0",
+    "esbuild": "0.19.2",
     "esbuild-plugin-alias": "0.2.1",
     "eslint": "8.42.0",
     "eslint-plugin-jest": "27.2.3",
diff --git a/js/yarn.lock b/js/yarn.lock
index c528a166e554c..5b52b8c0d8dbe 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -358,220 +358,220 @@
   resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz#bafb75234a5d3d1b690e7c2956a599345e84a2fd"
   integrity sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==
 
-"@esbuild/android-arm64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.19.0.tgz#c5ea635bdbe9b83d1f78a711120814e716439029"
-  integrity sha512-AzsozJnB+RNaDncBCs3Ys5g3kqhPFUueItfEaCpp89JH2naFNX2mYDIvUgPYMqqjm8hiFoo+jklb3QHZyR3ubw==
+"@esbuild/android-arm64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.19.2.tgz#bc35990f412a749e948b792825eef7df0ce0e073"
+  integrity sha512-lsB65vAbe90I/Qe10OjkmrdxSX4UJDjosDgb8sZUKcg3oefEuW2OT2Vozz8ef7wrJbMcmhvCC+hciF8jY/uAkw==
 
 "@esbuild/android-arm@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.17.19.tgz#5898f7832c2298bc7d0ab53701c57beb74d78b4d"
   integrity sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==
 
-"@esbuild/android-arm@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.19.0.tgz#6eb6e1fbc0dbfafa035aaef8b5ecde25b539fcf9"
-  integrity sha512-GAkjUyHgWTYuex3evPd5V7uV/XS4LMKr1PWHRPW1xNyy/Jx08x3uTrDFRefBYLKT/KpaWM8/YMQcwbp5a3yIDA==
+"@esbuild/android-arm@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.19.2.tgz#edd1c8f23ba353c197f5b0337123c58ff2a56999"
+  integrity sha512-tM8yLeYVe7pRyAu9VMi/Q7aunpLwD139EY1S99xbQkT4/q2qa6eA4ige/WJQYdJ8GBL1K33pPFhPfPdJ/WzT8Q==
 
 "@esbuild/android-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.17.19.tgz#658368ef92067866d95fb268719f98f363d13ae1"
   integrity sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==
 
-"@esbuild/android-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.19.0.tgz#99f154f71f5b92e778468bcf0f425d166c17bf20"
-  integrity sha512-SUG8/qiVhljBDpdkHQ9DvOWbp7hFFIP0OzxOTptbmVsgBgzY6JWowmMd6yJuOhapfxmj/DrvwKmjRLvVSIAKZg==
+"@esbuild/android-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.19.2.tgz#2dcdd6e6f1f2d82ea1b746abd8da5b284960f35a"
+  integrity sha512-qK/TpmHt2M/Hg82WXHRc/W/2SGo/l1thtDHZWqFq7oi24AjZ4O/CpPSu6ZuYKFkEgmZlFoa7CooAyYmuvnaG8w==
 
 "@esbuild/darwin-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz#584c34c5991b95d4d48d333300b1a4e2ff7be276"
   integrity sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==
 
-"@esbuild/darwin-arm64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.19.0.tgz#2fcc11abf95fbabbf9167db6a11d899385bd777b"
-  integrity sha512-HkxZ8k3Jvcw0FORPNTavA8BMgQjLOB6AajT+iXmil7BwY3gU1hWvJJAyWyEogCmA4LdbGvKF8vEykdmJ4xNJJQ==
+"@esbuild/darwin-arm64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.19.2.tgz#55b36bc06d76f5c243987c1f93a11a80d8fc3b26"
+  integrity sha512-Ora8JokrvrzEPEpZO18ZYXkH4asCdc1DLdcVy8TGf5eWtPO1Ie4WroEJzwI52ZGtpODy3+m0a2yEX9l+KUn0tA==
 
 "@esbuild/darwin-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz#7751d236dfe6ce136cce343dce69f52d76b7f6cb"
   integrity sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==
 
-"@esbuild/darwin-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.19.0.tgz#b5bbde35468db093fdf994880b0eb4b62613b67c"
-  integrity sha512-9IRWJjqpWFHM9a5Qs3r3bK834NCFuDY5ZaLrmTjqE+10B6w65UMQzeZjh794JcxpHolsAHqwsN/33crUXNCM2Q==
+"@esbuild/darwin-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.19.2.tgz#982524af33a6424a3b5cb44bbd52559623ad719c"
+  integrity sha512-tP+B5UuIbbFMj2hQaUr6EALlHOIOmlLM2FK7jeFBobPy2ERdohI4Ka6ZFjZ1ZYsrHE/hZimGuU90jusRE0pwDw==
 
 "@esbuild/freebsd-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz#cacd171665dd1d500f45c167d50c6b7e539d5fd2"
   integrity sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==
 
-"@esbuild/freebsd-arm64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.0.tgz#3f64c76dc590f79cc40acef6b22dd5eb89fc2125"
-  integrity sha512-s7i2WcXcK0V1PJHVBe7NsGddsL62a9Vhpz2U7zapPrwKoFuxPP9jybwX8SXnropR/AOj3ppt2ern4ItblU6UQQ==
+"@esbuild/freebsd-arm64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.2.tgz#8e478a0856645265fe79eac4b31b52193011ee06"
+  integrity sha512-YbPY2kc0acfzL1VPVK6EnAlig4f+l8xmq36OZkU0jzBVHcOTyQDhnKQaLzZudNJQyymd9OqQezeaBgkTGdTGeQ==
 
 "@esbuild/freebsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz#0769456eee2a08b8d925d7c00b79e861cb3162e4"
   integrity sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==
 
-"@esbuild/freebsd-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.19.0.tgz#14d497e9e858fba2bb9b16130602b7f5944bc09c"
-  integrity sha512-NMdBSSdgwHCqCsucU5k1xflIIRU0qi1QZnM6+vdGy5fvxm1c8rKh50VzsWsIVTFUG3l91AtRxVwoz3Lcvy3I5w==
+"@esbuild/freebsd-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.19.2.tgz#01b96604f2540db023c73809bb8ae6cd1692d6f3"
+  integrity sha512-nSO5uZT2clM6hosjWHAsS15hLrwCvIWx+b2e3lZ3MwbYSaXwvfO528OF+dLjas1g3bZonciivI8qKR/Hm7IWGw==
 
 "@esbuild/linux-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz#38e162ecb723862c6be1c27d6389f48960b68edb"
   integrity sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==
 
-"@esbuild/linux-arm64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.19.0.tgz#0f2f4d8889f7dc89681c306d7312aa76445a5f65"
-  integrity sha512-I4zvE2srSZxRPapFnNqj+NL3sDJ1wkvEZqt903OZUlBBgigrQMvzUowvP/TTTu2OGYe1oweg5MFilfyrElIFag==
+"@esbuild/linux-arm64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.19.2.tgz#7e5d2c7864c5c83ec789b59c77cd9c20d2594916"
+  integrity sha512-ig2P7GeG//zWlU0AggA3pV1h5gdix0MA3wgB+NsnBXViwiGgY77fuN9Wr5uoCrs2YzaYfogXgsWZbm+HGr09xg==
 
 "@esbuild/linux-arm@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz#1a2cd399c50040184a805174a6d89097d9d1559a"
   integrity sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==
 
-"@esbuild/linux-arm@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.19.0.tgz#0b0f79dc72884f0ad02c0aabfc969a0bee7f6775"
-  integrity sha512-2F1+lH7ZBcCcgxiSs8EXQV0PPJJdTNiNcXxDb61vzxTRJJkXX1I/ye9mAhfHyScXzHaEibEXg1Jq9SW586zz7w==
+"@esbuild/linux-arm@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.19.2.tgz#c32ae97bc0246664a1cfbdb4a98e7b006d7db8ae"
+  integrity sha512-Odalh8hICg7SOD7XCj0YLpYCEc+6mkoq63UnExDCiRA2wXEmGlK5JVrW50vZR9Qz4qkvqnHcpH+OFEggO3PgTg==
 
 "@esbuild/linux-ia32@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz#e28c25266b036ce1cabca3c30155222841dc035a"
   integrity sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==
 
-"@esbuild/linux-ia32@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.19.0.tgz#dfcece1f5e74d0e7db090475e48b28d9aa270687"
-  integrity sha512-dz2Q7+P92r1Evc8kEN+cQnB3qqPjmCrOZ+EdBTn8lEc1yN8WDgaDORQQiX+mxaijbH8npXBT9GxUqE52Gt6Y+g==
+"@esbuild/linux-ia32@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.19.2.tgz#3fc4f0fa026057fe885e4a180b3956e704f1ceaa"
+  integrity sha512-mLfp0ziRPOLSTek0Gd9T5B8AtzKAkoZE70fneiiyPlSnUKKI4lp+mGEnQXcQEHLJAcIYDPSyBvsUbKUG2ri/XQ==
 
 "@esbuild/linux-loong64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz#0f887b8bb3f90658d1a0117283e55dbd4c9dcf72"
   integrity sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==
 
-"@esbuild/linux-loong64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.19.0.tgz#710f5bd55db3f5d9ebac8773ea49795261a35ca7"
-  integrity sha512-IcVJovJVflih4oFahhUw+N7YgNbuMSVFNr38awb0LNzfaiIfdqIh518nOfYaNQU3aVfiJnOIRVJDSAP4k35WxA==
+"@esbuild/linux-loong64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.19.2.tgz#633bcaea443f3505fb0ed109ab840c99ad3451a4"
+  integrity sha512-hn28+JNDTxxCpnYjdDYVMNTR3SKavyLlCHHkufHV91fkewpIyQchS1d8wSbmXhs1fiYDpNww8KTFlJ1dHsxeSw==
 
 "@esbuild/linux-mips64el@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz#f5d2a0b8047ea9a5d9f592a178ea054053a70289"
   integrity sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==
 
-"@esbuild/linux-mips64el@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.19.0.tgz#a918b310f9bf31fced3853ca52fee6e7acc09824"
-  integrity sha512-bZGRAGySMquWsKw0gIdsClwfvgbsSq/7oq5KVu1H1r9Il+WzOcfkV1hguntIuBjRVL8agI95i4AukjdAV2YpUw==
+"@esbuild/linux-mips64el@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.19.2.tgz#e0bff2898c46f52be7d4dbbcca8b887890805823"
+  integrity sha512-KbXaC0Sejt7vD2fEgPoIKb6nxkfYW9OmFUK9XQE4//PvGIxNIfPk1NmlHmMg6f25x57rpmEFrn1OotASYIAaTg==
 
 "@esbuild/linux-ppc64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz#876590e3acbd9fa7f57a2c7d86f83717dbbac8c7"
   integrity sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==
 
-"@esbuild/linux-ppc64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.19.0.tgz#104771ef6ce2719ac17031f6b9ed8aa98f8e5faf"
-  integrity sha512-3LC6H5/gCDorxoRBUdpLV/m7UthYSdar0XcCu+ypycQxMS08MabZ06y1D1yZlDzL/BvOYliRNRWVG/YJJvQdbg==
+"@esbuild/linux-ppc64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.19.2.tgz#d75798da391f54a9674f8c143b9a52d1dbfbfdde"
+  integrity sha512-dJ0kE8KTqbiHtA3Fc/zn7lCd7pqVr4JcT0JqOnbj4LLzYnp+7h8Qi4yjfq42ZlHfhOCM42rBh0EwHYLL6LEzcw==
 
 "@esbuild/linux-riscv64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz#7f49373df463cd9f41dc34f9b2262d771688bf09"
   integrity sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==
 
-"@esbuild/linux-riscv64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.19.0.tgz#83beafa472ad4224adcd4d7469e3a17ba1fbd976"
-  integrity sha512-jfvdKjWk+Cp2sgLtEEdSHXO7qckrw2B2eFBaoRdmfhThqZs29GMMg7q/LsQpybA7BxCLLEs4di5ucsWzZC5XPA==
+"@esbuild/linux-riscv64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.19.2.tgz#012409bd489ed1bb9b775541d4a46c5ded8e6dd8"
+  integrity sha512-7Z/jKNFufZ/bbu4INqqCN6DDlrmOTmdw6D0gH+6Y7auok2r02Ur661qPuXidPOJ+FSgbEeQnnAGgsVynfLuOEw==
 
 "@esbuild/linux-s390x@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz#e2afd1afcaf63afe2c7d9ceacd28ec57c77f8829"
   integrity sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==
 
-"@esbuild/linux-s390x@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.19.0.tgz#edc26cb41d8745716bda9c26bac1f0001eaad029"
-  integrity sha512-ofcucfNLkoXmcnJaw9ugdEOf40AWKGt09WBFCkpor+vFJVvmk/8OPjl/qRtks2Z7BuZbG3ztJuK1zS9z5Cgx9A==
+"@esbuild/linux-s390x@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.19.2.tgz#ece3ed75c5a150de8a5c110f02e97d315761626b"
+  integrity sha512-U+RinR6aXXABFCcAY4gSlv4CL1oOVvSSCdseQmGO66H+XyuQGZIUdhG56SZaDJQcLmrSfRmx5XZOWyCJPRqS7g==
 
 "@esbuild/linux-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz#8a0e9738b1635f0c53389e515ae83826dec22aa4"
   integrity sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==
 
-"@esbuild/linux-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.19.0.tgz#80a6b5e55ad454e0c0af5bdb267335287e331007"
-  integrity sha512-Fpf7zNDBti3xrQKQKLdXT0hTyOxgFdRJIMtNy8x1az9ATR9/GJ1brYbB/GLWoXhKiHsoWs+2DLkFVNNMTCLEwA==
+"@esbuild/linux-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.19.2.tgz#dea187019741602d57aaf189a80abba261fbd2aa"
+  integrity sha512-oxzHTEv6VPm3XXNaHPyUTTte+3wGv7qVQtqaZCrgstI16gCuhNOtBXLEBkBREP57YTd68P0VgDgG73jSD8bwXQ==
 
 "@esbuild/netbsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz#c29fb2453c6b7ddef9a35e2c18b37bda1ae5c462"
   integrity sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==
 
-"@esbuild/netbsd-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.19.0.tgz#2e6e8d869b58aea34bab9c0c47f15ae1bda29a90"
-  integrity sha512-AMQAp/5oENgDOvVhvOlbhVe1pWii7oFAMRHlmTjSEMcpjTpIHtFXhv9uAFgUERHm3eYtNvS9Vf+gT55cwuI6Aw==
+"@esbuild/netbsd-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.19.2.tgz#bbfd7cf9ab236a23ee3a41b26f0628c57623d92a"
+  integrity sha512-WNa5zZk1XpTTwMDompZmvQLHszDDDN7lYjEHCUmAGB83Bgs20EMs7ICD+oKeT6xt4phV4NDdSi/8OfjPbSbZfQ==
 
 "@esbuild/openbsd-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz#95e75a391403cb10297280d524d66ce04c920691"
   integrity sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==
 
-"@esbuild/openbsd-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.19.0.tgz#ca0817d3ab332afb0d8d96a2eb42b4d8ebaa8715"
-  integrity sha512-fDztEve1QUs3h/Dw2AUmBlWGkNQbhDoD05ppm5jKvzQv+HVuV13so7m5RYeiSMIC2XQy7PAjZh+afkxAnCRZxA==
+"@esbuild/openbsd-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.19.2.tgz#fa5c4c6ee52a360618f00053652e2902e1d7b4a7"
+  integrity sha512-S6kI1aT3S++Dedb7vxIuUOb3oAxqxk2Rh5rOXOTYnzN8JzW1VzBd+IqPiSpgitu45042SYD3HCoEyhLKQcDFDw==
 
 "@esbuild/sunos-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz#722eaf057b83c2575937d3ffe5aeb16540da7273"
   integrity sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==
 
-"@esbuild/sunos-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.19.0.tgz#8de27de2563cb3eb6c1af066b6d7fcb1229fe3d4"
-  integrity sha512-bKZzJ2/rvUjDzA5Ddyva2tMk89WzNJEibZEaq+wY6SiqPlwgFbqyQLimouxLHiHh1itb5P3SNCIF1bc2bw5H9w==
+"@esbuild/sunos-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.19.2.tgz#52a2ac8ac6284c02d25df22bb4cfde26fbddd68d"
+  integrity sha512-VXSSMsmb+Z8LbsQGcBMiM+fYObDNRm8p7tkUDMPG/g4fhFX5DEFmjxIEa3N8Zr96SjsJ1woAhF0DUnS3MF3ARw==
 
 "@esbuild/win32-arm64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz#9aa9dc074399288bdcdd283443e9aeb6b9552b6f"
   integrity sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==
 
-"@esbuild/win32-arm64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.19.0.tgz#67c2b410ff8862be2cd61145ad21e11be00fb914"
-  integrity sha512-NQJ+4jmnA79saI+sE+QzcEls19uZkoEmdxo7r//PDOjIpX8pmoWtTnWg6XcbnO7o4fieyAwb5U2LvgWynF4diA==
+"@esbuild/win32-arm64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.19.2.tgz#719ed5870855de8537aef8149694a97d03486804"
+  integrity sha512-5NayUlSAyb5PQYFAU9x3bHdsqB88RC3aM9lKDAz4X1mo/EchMIT1Q+pSeBXNgkfNmRecLXA0O8xP+x8V+g/LKg==
 
 "@esbuild/win32-ia32@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz#95ad43c62ad62485e210f6299c7b2571e48d2b03"
   integrity sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==
 
-"@esbuild/win32-ia32@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.19.0.tgz#cac8992219c6d943bb22226e4afeb3774a29cca1"
-  integrity sha512-uyxiZAnsfu9diHm9/rIH2soecF/HWLXYUhJKW4q1+/LLmNQ+55lRjvSUDhUmsgJtSUscRJB/3S4RNiTb9o9mCg==
+"@esbuild/win32-ia32@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.19.2.tgz#24832223880b0f581962c8660f8fb8797a1e046a"
+  integrity sha512-47gL/ek1v36iN0wL9L4Q2MFdujR0poLZMJwhO2/N3gA89jgHp4MR8DKCmwYtGNksbfJb9JoTtbkoe6sDhg2QTA==
 
 "@esbuild/win32-x64@0.17.19":
   version "0.17.19"
   resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz#8cfaf2ff603e9aabb910e9c0558c26cf32744061"
   integrity sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==
 
-"@esbuild/win32-x64@0.19.0":
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.19.0.tgz#fa5f12c96811cec3233a53bdbf61d1a05ba9018f"
-  integrity sha512-jl+NXUjK2StMgqnZnqgNjZuerFG8zQqWXMBZdMMv4W/aO1ZKQaYWZBxTrtWKphkCBVEMh0wMVfGgOd2BjOZqUQ==
+"@esbuild/win32-x64@0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.19.2.tgz#1205014625790c7ff0e471644a878a65d1e34ab0"
+  integrity sha512-tcuhV7ncXBqbt/Ybf0IyrMcwVOAPDckMK9rXNHtF17UTK18OKLpg08glminN06pt2WCoALhXdLfSPbVvK/6fxw==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.4.0":
   version "4.4.0"
@@ -2685,33 +2685,33 @@ esbuild-plugin-alias@0.2.1:
   resolved "https://registry.yarnpkg.com/esbuild-plugin-alias/-/esbuild-plugin-alias-0.2.1.tgz#45a86cb941e20e7c2bc68a2bea53562172494fcb"
   integrity sha512-jyfL/pwPqaFXyKnj8lP8iLk6Z0m099uXR45aSN8Av1XD4vhvQutxxPzgA2bTcAwQpa1zCXDcWOlhFgyP3GKqhQ==
 
-esbuild@0.19.0:
-  version "0.19.0"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.19.0.tgz#f187e4ce3bcc7396d13f408a991655efeba65282"
-  integrity sha512-i7i8TP4vuG55bKeLyqqk5sTPu1ZjPH3wkcLvAj/0X/222iWFo3AJUYRKjbOoY6BWFMH3teizxHEdV9Su5ESl0w==
+esbuild@0.19.2:
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.19.2.tgz#b1541828a89dfb6f840d38538767c6130dca2aac"
+  integrity sha512-G6hPax8UbFakEj3hWO0Vs52LQ8k3lnBhxZWomUJDxfz3rZTLqF5k/FCzuNdLx2RbpBiQQF9H9onlDDH1lZsnjg==
   optionalDependencies:
-    "@esbuild/android-arm" "0.19.0"
-    "@esbuild/android-arm64" "0.19.0"
-    "@esbuild/android-x64" "0.19.0"
-    "@esbuild/darwin-arm64" "0.19.0"
-    "@esbuild/darwin-x64" "0.19.0"
-    "@esbuild/freebsd-arm64" "0.19.0"
-    "@esbuild/freebsd-x64" "0.19.0"
-    "@esbuild/linux-arm" "0.19.0"
-    "@esbuild/linux-arm64" "0.19.0"
-    "@esbuild/linux-ia32" "0.19.0"
-    "@esbuild/linux-loong64" "0.19.0"
-    "@esbuild/linux-mips64el" "0.19.0"
-    "@esbuild/linux-ppc64" "0.19.0"
-    "@esbuild/linux-riscv64" "0.19.0"
-    "@esbuild/linux-s390x" "0.19.0"
-    "@esbuild/linux-x64" "0.19.0"
-    "@esbuild/netbsd-x64" "0.19.0"
-    "@esbuild/openbsd-x64" "0.19.0"
-    "@esbuild/sunos-x64" "0.19.0"
-    "@esbuild/win32-arm64" "0.19.0"
-    "@esbuild/win32-ia32" "0.19.0"
-    "@esbuild/win32-x64" "0.19.0"
+    "@esbuild/android-arm" "0.19.2"
+    "@esbuild/android-arm64" "0.19.2"
+    "@esbuild/android-x64" "0.19.2"
+    "@esbuild/darwin-arm64" "0.19.2"
+    "@esbuild/darwin-x64" "0.19.2"
+    "@esbuild/freebsd-arm64" "0.19.2"
+    "@esbuild/freebsd-x64" "0.19.2"
+    "@esbuild/linux-arm" "0.19.2"
+    "@esbuild/linux-arm64" "0.19.2"
+    "@esbuild/linux-ia32" "0.19.2"
+    "@esbuild/linux-loong64" "0.19.2"
+    "@esbuild/linux-mips64el" "0.19.2"
+    "@esbuild/linux-ppc64" "0.19.2"
+    "@esbuild/linux-riscv64" "0.19.2"
+    "@esbuild/linux-s390x" "0.19.2"
+    "@esbuild/linux-x64" "0.19.2"
+    "@esbuild/netbsd-x64" "0.19.2"
+    "@esbuild/openbsd-x64" "0.19.2"
+    "@esbuild/sunos-x64" "0.19.2"
+    "@esbuild/win32-arm64" "0.19.2"
+    "@esbuild/win32-ia32" "0.19.2"
+    "@esbuild/win32-x64" "0.19.2"
 
 esbuild@^0.17.11:
   version "0.17.19"

From 47ce129390fa9aeaa737565c3e61712e387fd8be Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Sun, 3 Sep 2023 03:25:19 -0400
Subject: [PATCH 304/749] GH-37448: [MATLAB] Add `arrow.array.ChunkedArray`
 class (#37525)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

In order to add an `arrow.tabular.Table` class to the MATLAB Interface, we first need to add a MATLAB class representing `arrow::ChunkedArray`s. This is required because an `arrow::Table` is backed by a vector of `arrow::ChunkedArray`s, and the output of its `column(int index)` method is an `arrow::ChunkedArray`.

### What changes are included in this PR?

1. Introduced a new class called `arrow.array.ChunkedArray`.
2. `arrow.array.ChunkedArray` has the following properties:
    1.  `Type` - datatype of the `arrow.array.Array`s
    2. `Length` - Sum of the `arrow.array.Array` lengths
    3. `NumChunks` - Number of `arrow.array.Array`s
3. `arrow.array.ChunkedArray` has the following methods:
   1. `chunk(index)` - Returns the `arrow.array.Array` stored at the specified index
   2. `fromArrays(array1, array1, ..., arrayN, Type=type)` - Creates a `ChunkedArray` from the arrays provided. If `Type` is provided, all arrays are expected to have the specified `Type`.

**Example Usage**

```matlab
>> a1 = arrow.array(1:100);
>> a2 = arrow.array(101:250);
>> a3 = arrow.array(251:300);

% Create a ChunkedArray from 3 Float64Arrays
>> c = arrow.array.ChunkedArray.fromArrays(a1, a2, a3)

c =

  ChunkedArray with properties:

         Type: [1×1 arrow.type.Float64Type]
    NumChunks: 3
       Length: 300

% Extract the first chunk and compare it to a1
>> c1 = c.chunk(1);
>> tf = isequal(c1, a1)

tf =

  logical

   1

% Create an empty ChunkedArray by providing the Type nv-pair
>> c = arrow.array.ChunkedArray.fromArrays(Type=arrow.timestamp())

c =

  ChunkedArray with properties:

         Type: [1×1 arrow.type.TimestampType]
    NumChunks: 0
       Length: 0

```

### Are these changes tested?

Yes. I added a new test class called `tChunkedArray.m` that contains unit tests for the new class.

### Are there any user-facing changes?

Yes. Users can now create a `ChunkedArray` in the MATLAB Interface.

### Future Directions

1. In this PR, we deliberately didn't include a convenience constructor function because we're not sure if we want users to create `ChunkedArray`s themselves. We think users will mostly use `ChunkedArray` when extracting columns from `Table`s.
2. We will implement more methods on `ChunkedArray`, such as `flatten()` and `combineChunks()`, etc.
* Closes: #37448

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc |  22 +-
 .../src/cpp/arrow/matlab/array/proxy/array.h  |   6 +-
 .../arrow/matlab/array/proxy/chunked_array.cc | 187 ++++++++++++
 .../arrow/matlab/array/proxy/chunked_array.h  |  51 ++++
 matlab/src/cpp/arrow/matlab/error/error.h     |   4 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../matlab/tabular/proxy/record_batch.cc      |   8 +-
 .../arrow/matlab/tabular/proxy/record_batch.h |   4 +-
 .../src/cpp/arrow/matlab/type/proxy/field.cc  |  15 +-
 .../src/cpp/arrow/matlab/type/proxy/field.h   |   4 +-
 .../matlab/type/proxy/fixed_width_type.cc     |   4 +-
 .../matlab/type/proxy/fixed_width_type.h      |   2 +-
 .../src/cpp/arrow/matlab/type/proxy/type.cc   |   8 +-
 matlab/src/cpp/arrow/matlab/type/proxy/type.h |   4 +-
 .../+internal/getArrayProxyIDs.m              |   0
 matlab/src/matlab/+arrow/+array/Array.m       |  10 +-
 .../src/matlab/+arrow/+array/ChunkedArray.m   | 115 ++++++++
 .../+tabular/createAllSupportedArrayTypes.m   |  10 +
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |   6 +-
 matlab/src/matlab/+arrow/+type/Field.m        |   8 +-
 .../src/matlab/+arrow/+type/FixedWidthType.m  |   2 +-
 matlab/src/matlab/+arrow/+type/Type.m         |   4 +-
 matlab/src/matlab/+arrow/recordBatch.m        |   2 +-
 matlab/test/arrow/array/tChunkedArray.m       | 267 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 25 files changed, 694 insertions(+), 52 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
 rename matlab/src/matlab/+arrow/{+tabular => +array}/+internal/getArrayProxyIDs.m (100%)
 create mode 100644 matlab/src/matlab/+arrow/+array/ChunkedArray.m
 create mode 100644 matlab/test/arrow/array/tChunkedArray.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index 9dc14c3419b97..ed6152259891d 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -32,9 +32,9 @@ namespace arrow::matlab::array::proxy {
         // Register Proxy methods.
         REGISTER_METHOD(Array, toString);
         REGISTER_METHOD(Array, toMATLAB);
-        REGISTER_METHOD(Array, length);
-        REGISTER_METHOD(Array, valid);
-        REGISTER_METHOD(Array, type);
+        REGISTER_METHOD(Array, getLength);
+        REGISTER_METHOD(Array, getValid);
+        REGISTER_METHOD(Array, getType);
         REGISTER_METHOD(Array, isEqual);
 
     }
@@ -51,13 +51,13 @@ namespace arrow::matlab::array::proxy {
         context.outputs[0] = str_mda;
     }
 
-    void Array::length(libmexclass::proxy::method::Context& context) {
+    void Array::getLength(libmexclass::proxy::method::Context& context) {
         ::matlab::data::ArrayFactory factory;
         auto length_mda = factory.createScalar(array->length());
         context.outputs[0] = length_mda;
     }
 
-    void Array::valid(libmexclass::proxy::method::Context& context) {
+    void Array::getValid(libmexclass::proxy::method::Context& context) {
         auto array_length = static_cast<size_t>(array->length());
 
         // If the Arrow array has no null values, then return a MATLAB
@@ -77,7 +77,7 @@ namespace arrow::matlab::array::proxy {
         context.outputs[0] = valid_elements_mda;
     }
 
-    void Array::type(libmexclass::proxy::method::Context& context) {
+    void Array::getType(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
 
         mda::ArrayFactory factory;
@@ -87,11 +87,13 @@ namespace arrow::matlab::array::proxy {
                                             context,
                                             error::ARRAY_FAILED_TO_CREATE_TYPE_PROXY);
 
-        auto type_id = type_proxy->unwrap()->id();
-        auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(type_proxy);
+        const auto type_id = static_cast<int32_t>(type_proxy->unwrap()->id());
+        const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(type_proxy);
 
-        context.outputs[0] = factory.createScalar(proxy_id);
-        context.outputs[1] = factory.createScalar(static_cast<int64_t>(type_id));
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(proxy_id);
+        output[0]["TypeID"] = factory.createScalar(type_id);
+        context.outputs[0] = output;
     }
 
     void Array::isEqual(libmexclass::proxy::method::Context& context) {
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index fe28c8a8dd009..185e107f75391 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -36,11 +36,11 @@ class Array : public libmexclass::proxy::Proxy {
 
         void toString(libmexclass::proxy::method::Context& context);
 
-        void length(libmexclass::proxy::method::Context& context);
+        void getLength(libmexclass::proxy::method::Context& context);
 
-        void valid(libmexclass::proxy::method::Context& context);
+        void getValid(libmexclass::proxy::method::Context& context);
 
-        void type(libmexclass::proxy::method::Context& context);
+        void getType(libmexclass::proxy::method::Context& context);
 
         virtual void toMATLAB(libmexclass::proxy::method::Context& context) = 0;
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
new file mode 100644
index 0000000000000..2b15fed675d18
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
@@ -0,0 +1,187 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/util/utf8.h"
+
+#include "arrow/matlab/array/proxy/chunked_array.h"
+#include "arrow/matlab/array/proxy/array.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/type/proxy/wrap.h"
+#include "arrow/matlab/array/proxy/wrap.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::array::proxy {
+
+    namespace {
+        libmexclass::error::Error makeEmptyChunkedArrayError() {
+            const std::string error_msg =  "Numeric indexing using the chunk method is not supported for chunked arrays with zero chunks.";
+            return libmexclass::error::Error{error::CHUNKED_ARRAY_NUMERIC_INDEX_WITH_EMPTY_CHUNKED_ARRAY, error_msg};
+        }
+
+        libmexclass::error::Error makeInvalidNumericIndexError(const int32_t matlab_index, const int32_t num_chunks) {
+            std::stringstream error_message_stream;
+            error_message_stream << "Invalid chunk index: ";
+            error_message_stream << matlab_index;
+            error_message_stream << ". Chunk index must be between 1 and the number of chunks (";
+            error_message_stream << num_chunks;
+            error_message_stream << ").";
+            return libmexclass::error::Error{error::CHUNKED_ARRAY_INVALID_NUMERIC_CHUNK_INDEX, error_message_stream.str()};
+        }
+    }
+
+    ChunkedArray::ChunkedArray(std::shared_ptr<arrow::ChunkedArray> chunked_array) : chunked_array{std::move(chunked_array)} {
+
+        // Register Proxy methods.
+        REGISTER_METHOD(ChunkedArray, getLength);
+        REGISTER_METHOD(ChunkedArray, getNumChunks);
+        REGISTER_METHOD(ChunkedArray, getChunk);
+        REGISTER_METHOD(ChunkedArray, getType);
+        REGISTER_METHOD(ChunkedArray, isEqual);
+    }
+
+
+    libmexclass::proxy::MakeResult ChunkedArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> array_proxy_ids = opts[0]["ArrayProxyIDs"];
+        const mda::TypedArray<uint64_t> type_proxy_id = opts[0]["TypeProxyID"];
+
+        std::vector<std::shared_ptr<arrow::Array>> arrays;
+        // Retrieve all of the Array Proxy instances from the libmexclass ProxyManager.
+        for (const auto& array_proxy_id : array_proxy_ids) {
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(array_proxy_id);
+            auto array_proxy = std::static_pointer_cast<proxy::Array>(proxy);
+            auto array = array_proxy->unwrap();
+            arrays.push_back(array);
+        }
+
+        auto proxy = libmexclass::proxy::ProxyManager::getProxy(type_proxy_id[0]);
+        auto type_proxy = std::static_pointer_cast<type::proxy::Type>(proxy);
+        auto type = type_proxy->unwrap();
+
+        MATLAB_ASSIGN_OR_ERROR(auto chunked_array, 
+                               arrow::ChunkedArray::Make(arrays, type),
+                               error::CHUNKED_ARRAY_MAKE_FAILED);
+
+        return std::make_unique<proxy::ChunkedArray>(std::move(chunked_array));
+    }
+
+    std::shared_ptr<arrow::ChunkedArray> ChunkedArray::unwrap() {
+        return chunked_array;
+    }
+
+    void ChunkedArray::getLength(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        auto length_mda = factory.createScalar(chunked_array->length());
+        context.outputs[0] = length_mda;
+    }
+
+    void ChunkedArray::getNumChunks(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        auto length_mda = factory.createScalar(chunked_array->num_chunks());
+        context.outputs[0] = length_mda;
+    }
+
+    void ChunkedArray::getChunk(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+        
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::Schema::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
+        const auto num_chunks = chunked_array->num_chunks();
+        
+        if (num_chunks == 0) {
+            context.error = makeEmptyChunkedArrayError();
+            return;
+        }
+        
+        if (matlab_index < 1 || matlab_index > num_chunks) {
+            context.error = makeInvalidNumericIndexError(matlab_index, num_chunks);
+            return;
+        }
+
+        const auto array = chunked_array->chunk(index);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto array_proxy,
+                                            arrow::matlab::array::proxy::wrap(array),
+                                            context,
+                                            error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+        
+        
+        const auto array_proxy_id = libmexclass::proxy::ProxyManager::manageProxy(array_proxy);
+        const auto type_id = static_cast<int64_t>(array->type_id());
+
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(array_proxy_id);
+        output[0]["TypeID"] = factory.createScalar(type_id);
+        context.outputs[0] = output;
+    }
+
+
+    void ChunkedArray::getType(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        mda::ArrayFactory factory;
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto type_proxy,
+                                            type::proxy::wrap(chunked_array->type()),
+                                            context,
+                                            error::ARRAY_FAILED_TO_CREATE_TYPE_PROXY);
+
+
+        const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(type_proxy);
+        const auto type_id = static_cast<int32_t>(type_proxy->unwrap()->id());
+
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(proxy_id);
+        output[0]["TypeID"] = factory.createScalar(type_id);
+        context.outputs[0] = output;
+    }
+
+    void ChunkedArray::isEqual(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        const mda::TypedArray<uint64_t> chunked_array_proxy_ids = context.inputs[0];
+
+        bool is_equal = true;
+        for (const auto& chunked_array_proxy_id : chunked_array_proxy_ids) {
+            // Retrieve the ChunkedArray proxy from the ProxyManager
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(chunked_array_proxy_id);
+            auto chunked_array_proxy = std::static_pointer_cast<proxy::ChunkedArray>(proxy);
+            auto chunked_array_to_compare = chunked_array_proxy->unwrap();
+
+            // Use the ChunkedArray::Equals(const ChunkedArray& other) overload instead
+            // of ChunkedArray::Equals(const std::shared_ptr<ChunkedArray> other&) to 
+            // ensure we don't assume chunked arrays with the same memory address are
+            // equal. This ensures we treat NaNs as not equal by default.
+            if (!chunked_array->Equals(*chunked_array_to_compare)) {
+                is_equal = false;
+                break;
+            }
+        }
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(is_equal);
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
new file mode 100644
index 0000000000000..ff47644182a89
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
@@ -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.
+
+#pragma once
+
+#include "arrow/chunked_array.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::array::proxy {
+
+class ChunkedArray : public libmexclass::proxy::Proxy {
+    public:
+        ChunkedArray(std::shared_ptr<arrow::ChunkedArray> chunked_array);
+    
+        ~ChunkedArray() {}
+
+        std::shared_ptr<arrow::ChunkedArray> unwrap();
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+
+        void getLength(libmexclass::proxy::method::Context& context);
+
+        void getNumChunks(libmexclass::proxy::method::Context& context);
+
+        void getChunk(libmexclass::proxy::method::Context& context);
+
+        void getType(libmexclass::proxy::method::Context& context);
+
+        void isEqual(libmexclass::proxy::method::Context& context);
+
+        std::shared_ptr<arrow::ChunkedArray> chunked_array;
+};
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 2f17cfda16f3d..4b64849bcef4d 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -190,5 +190,9 @@ namespace arrow::matlab::error {
     static const char* FEATHER_VERSION_UNKNOWN = "arrow:io:feather:FeatherVersionUnknown";
     static const char* FEATHER_FAILED_TO_READ_TABLE = "arrow:io:feather:FailedToReadTable";
     static const char* FEATHER_FAILED_TO_READ_RECORD_BATCH = "arrow:io:feather:FailedToReadRecordBatch";
+    static const char* CHUNKED_ARRAY_MAKE_FAILED = "arrow:chunkedarray:MakeFailed";
+    static const char* CHUNKED_ARRAY_NUMERIC_INDEX_WITH_EMPTY_CHUNKED_ARRAY = "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray";
+    static const char* CHUNKED_ARRAY_INVALID_NUMERIC_CHUNK_INDEX = "arrow:chunkedarray:InvalidNumericChunkIndex";
+
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 0ad8d52cd53a6..bc349bcfd595e 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -21,6 +21,7 @@
 #include "arrow/matlab/array/proxy/timestamp_array.h"
 #include "arrow/matlab/array/proxy/time32_array.h"
 #include "arrow/matlab/array/proxy/time64_array.h"
+#include "arrow/matlab/array/proxy/chunked_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
@@ -55,6 +56,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
     REGISTER_PROXY(arrow.array.proxy.Date32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
+    REGISTER_PROXY(arrow.array.proxy.ChunkedArray  , arrow::matlab::array::proxy::ChunkedArray);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index b785d2cf080d8..c3fc6a429d9ff 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -52,8 +52,8 @@ namespace arrow::matlab::tabular::proxy {
 
     RecordBatch::RecordBatch(std::shared_ptr<arrow::RecordBatch> record_batch) : record_batch{record_batch} {
         REGISTER_METHOD(RecordBatch, toString);
-        REGISTER_METHOD(RecordBatch, numColumns);
-        REGISTER_METHOD(RecordBatch, columnNames);
+        REGISTER_METHOD(RecordBatch, getNumColumns);
+        REGISTER_METHOD(RecordBatch, getColumnNames);
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
         REGISTER_METHOD(RecordBatch, getColumnByName);
         REGISTER_METHOD(RecordBatch, getSchema);
@@ -104,7 +104,7 @@ namespace arrow::matlab::tabular::proxy {
         return record_batch_proxy;
     }
 
-    void RecordBatch::numColumns(libmexclass::proxy::method::Context& context) {
+    void RecordBatch::getNumColumns(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
         const auto num_columns = record_batch->num_columns();
@@ -112,7 +112,7 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = num_columns_mda;
     }
 
-    void RecordBatch::columnNames(libmexclass::proxy::method::Context& context) {
+    void RecordBatch::getColumnNames(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
         const int num_columns = record_batch->num_columns();
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index febf18dd17826..bac1298e35c39 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -35,8 +35,8 @@ namespace arrow::matlab::tabular::proxy {
     
         protected:
             void toString(libmexclass::proxy::method::Context& context);
-            void numColumns(libmexclass::proxy::method::Context& context);
-            void columnNames(libmexclass::proxy::method::Context& context);
+            void getNumColumns(libmexclass::proxy::method::Context& context);
+            void getColumnNames(libmexclass::proxy::method::Context& context);
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
             void getColumnByName(libmexclass::proxy::method::Context& context);
             void getSchema(libmexclass::proxy::method::Context& context);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
index 0cf7c995fb275..7df0e7d6ef304 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
@@ -30,8 +30,8 @@
 namespace arrow::matlab::type::proxy {
 
     Field::Field(std::shared_ptr<arrow::Field> field) : field{std::move(field)} {
-        REGISTER_METHOD(Field, name);
-        REGISTER_METHOD(Field, type);
+        REGISTER_METHOD(Field, getName);
+        REGISTER_METHOD(Field, getType);
         REGISTER_METHOD(Field, toString);
     }
 
@@ -39,7 +39,7 @@ namespace arrow::matlab::type::proxy {
         return field;
     }
 
-    void Field::name(libmexclass::proxy::method::Context& context) {
+    void Field::getName(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
 
@@ -49,16 +49,19 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = str_mda;
     }
 
-    void Field::type(libmexclass::proxy::method::Context& context) {
+    void Field::getType(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
 
         const auto& datatype = field->type();
         MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto proxy, type::proxy::wrap(datatype), context, error::FIELD_FAILED_TO_CREATE_TYPE_PROXY); 
         const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(proxy);
+        const auto type_id = static_cast<int32_t>(datatype->id());
 
         mda::ArrayFactory factory;
-        context.outputs[0] = factory.createScalar(proxy_id);
-        context.outputs[1] = factory.createScalar(static_cast<uint64_t>(datatype->id()));
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(proxy_id);
+        output[0]["TypeID"] = factory.createScalar(type_id);
+        context.outputs[0] = output;
     }
 
     void Field::toString(libmexclass::proxy::method::Context& context) {
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.h b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
index 8df73aa8af3a2..4256fd21a0a23 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/field.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
@@ -34,8 +34,8 @@ class Field : public libmexclass::proxy::Proxy {
         static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
     protected:
-        void name(libmexclass::proxy::method::Context& context);
-        void type(libmexclass::proxy::method::Context& context);
+        void getName(libmexclass::proxy::method::Context& context);
+        void getType(libmexclass::proxy::method::Context& context);
         void toString(libmexclass::proxy::method::Context& context);
 
         std::shared_ptr<arrow::Field> field;
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc
index 9ede57f2ee1dd..b5015797bd660 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.cc
@@ -21,10 +21,10 @@
 namespace arrow::matlab::type::proxy {
 
     FixedWidthType::FixedWidthType(std::shared_ptr<arrow::FixedWidthType> type) : Type(std::move(type)) {
-        REGISTER_METHOD(FixedWidthType, bitWidth);
+        REGISTER_METHOD(FixedWidthType, getBitWidth);
     }
 
-    void FixedWidthType::bitWidth(libmexclass::proxy::method::Context& context) {
+    void FixedWidthType::getBitWidth(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
          mda::ArrayFactory factory;
      
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.h
index e245acd55640e..c1232462866d1 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/fixed_width_type.h
@@ -27,7 +27,7 @@ class FixedWidthType : public arrow::matlab::type::proxy::Type {
         virtual ~FixedWidthType() {}
 
     protected:
-        void bitWidth(libmexclass::proxy::method::Context& context);
+        void getBitWidth(libmexclass::proxy::method::Context& context);
 
 };
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
index 95ff11c07735b..1eed4e6141347 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
@@ -22,8 +22,8 @@
 namespace arrow::matlab::type::proxy {
 
     Type::Type(std::shared_ptr<arrow::DataType> type) : data_type{std::move(type)} {
-        REGISTER_METHOD(Type, typeID);
-        REGISTER_METHOD(Type, numFields);
+        REGISTER_METHOD(Type, getTypeID);
+        REGISTER_METHOD(Type, getNumFields);
         REGISTER_METHOD(Type, isEqual);
     }
 
@@ -31,7 +31,7 @@ namespace arrow::matlab::type::proxy {
         return data_type;
     }
 
-    void Type::typeID(libmexclass::proxy::method::Context& context) {
+    void Type::getTypeID(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
         
@@ -39,7 +39,7 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = type_number_mda;
     }
 
-    void Type::numFields(libmexclass::proxy::method::Context& context) {
+    void Type::getNumFields(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
         
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.h b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
index d528d50d878c5..efd2b8255aa28 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
@@ -33,9 +33,9 @@ class Type : public libmexclass::proxy::Proxy {
 
     protected:
 
-        void typeID(libmexclass::proxy::method::Context& context);
+        void getTypeID(libmexclass::proxy::method::Context& context);
 
-        void numFields(libmexclass::proxy::method::Context& context);
+        void getNumFields(libmexclass::proxy::method::Context& context);
 
         void isEqual(libmexclass::proxy::method::Context& context);
 
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m b/matlab/src/matlab/+arrow/+array/+internal/getArrayProxyIDs.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+tabular/+internal/getArrayProxyIDs.m
rename to matlab/src/matlab/+arrow/+array/+internal/getArrayProxyIDs.m
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index dbf4abad45425..4505d4b006ad8 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -39,11 +39,11 @@
         end
 
         function numElements = get.Length(obj)
-            numElements = obj.Proxy.length();
+            numElements = obj.Proxy.getLength();
         end
 
         function validElements = get.Valid(obj)
-            validElements = obj.Proxy.valid();
+            validElements = obj.Proxy.getValid();
         end
 
         function matlabArray = toMATLAB(obj)
@@ -51,9 +51,9 @@
         end
 
         function type = get.Type(obj)
-            [proxyID, typeID] = obj.Proxy.type();
-            traits = arrow.type.traits.traits(arrow.type.ID(typeID));
-            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=proxyID);
+            typeStruct = obj.Proxy.getType();
+            traits = arrow.type.traits.traits(arrow.type.ID(typeStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=typeStruct.ProxyID);
             type = traits.TypeConstructor(proxy);
         end
     end
diff --git a/matlab/src/matlab/+arrow/+array/ChunkedArray.m b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
new file mode 100644
index 0000000000000..e6ee812866f62
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
@@ -0,0 +1,115 @@
+%CHUNKEDARRAY arrow.array.ChunkedArray
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef ChunkedArray < matlab.mixin.CustomDisplay & ...
+                        matlab.mixin.Scalar
+
+    properties(Hidden, SetAccess=private, GetAccess=public)
+        Proxy
+    end
+
+    properties(Dependent, SetAccess=private, GetAccess=public)
+        Type
+        NumChunks
+        Length
+    end
+
+    methods
+        function obj = ChunkedArray(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.ChunkedArray")}
+            end
+            import arrow.internal.proxy.validate
+            obj.Proxy = proxy;
+        end
+
+        function numChunks = get.NumChunks(obj)
+            numChunks = obj.Proxy.getNumChunks();
+        end
+
+        function length = get.Length(obj)
+            length = obj.Proxy.getLength();
+        end
+
+        function type = get.Type(obj)
+            typeStruct = obj.Proxy.getType();
+            traits = arrow.type.traits.traits(arrow.type.ID(typeStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=typeStruct.ProxyID);
+            type = traits.TypeConstructor(proxy);
+        end
+
+        function array = chunk(obj, idx)
+            idx = arrow.internal.validate.index.numeric(idx, "int32", AllowNonScalar=false);
+            chunkStruct = obj.Proxy.getChunk(struct(Index=idx));
+            traits = arrow.type.traits.traits(arrow.type.ID(chunkStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=chunkStruct.ProxyID);
+            array = traits.ArrayConstructor(proxy);
+        end
+
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+
+            tf = false;
+            proxyIDs = zeros(numel(varargin), 1, "uint64");
+
+            % Extract each chunked array's proxy ID
+            for ii = 1:numel(varargin)
+                chunkedArray = varargin{ii};
+                if ~isa(chunkedArray, "arrow.array.ChunkedArray")
+                    % Return early if array is not a arrow.array.ChunkedArray
+                    return;
+                end
+                proxyIDs(ii) = chunkedArray.Proxy.ID;
+            end
+
+            % Invoke isEqual proxy object method
+            tf = obj.Proxy.isEqual(proxyIDs);
+        end
+    end
+
+    methods(Static)
+        function chunkedArray = fromArrays(arrays, opts)
+            arguments(Repeating)
+                arrays(1, 1) arrow.array.Array
+            end
+            arguments
+                opts.Type(1, 1) arrow.type.Type
+            end
+
+            typedProvided = isfield(opts, "Type");
+
+            if (isempty(arrays) && ~typedProvided)
+                errid = "arrow:chunkedarray:TypeRequiredWithZeroArrayInputs";
+                msg = "Must provide the Type name-value pair if no arrays were provided as input";
+                error(errid, msg);
+            end
+
+            if typedProvided
+                type = opts.Type;
+            else
+                type = arrays{1}.Type;
+            end
+
+            proxyIDs = arrow.array.internal.getArrayProxyIDs(arrays);
+            args = struct(ArrayProxyIDs=proxyIDs, TypeProxyID=type.Proxy.ID);
+            proxyName = "arrow.array.proxy.ChunkedArray";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+
+            chunkedArray = arrow.array.ChunkedArray(proxy);
+        end
+    end 
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index 6eb930271b467..f7a9bda927075 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -72,6 +72,16 @@
     % Removes all Abstract classes from the list of all subclasses
     abstract = [metaClass.Abstract];
     metaClass(abstract) = [];
+
+    % Remove all classes that don't inherit from arrow.array.Array
+    isArraySubclass = true(size(metaClass));
+    for ii = 1:numel(metaClass)
+        allSuperClasses = superclasses(metaClass(ii).Name);
+        isArraySubclass(ii) = ismember("arrow.array.Array", allSuperClasses);
+    end
+    metaClass(~isArraySubclass) = [];
+
+    % Return the class names as a string array
     classes = string({metaClass.Name});
 end
 
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index d8c6eb47c6cf7..f8a670d095635 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -38,11 +38,11 @@
         end
 
         function numColumns = get.NumColumns(obj)
-            numColumns = obj.Proxy.numColumns();
+            numColumns = obj.Proxy.getNumColumns();
         end
 
         function columnNames = get.ColumnNames(obj)
-            columnNames = obj.Proxy.columnNames();
+            columnNames = obj.Proxy.getColumnNames();
         end
 
         function schema = get.Schema(obj)
@@ -116,7 +116,7 @@ function displayScalarObject(obj)
 
             import arrow.tabular.internal.validateArrayLengths
             import arrow.tabular.internal.validateColumnNames
-            import arrow.tabular.internal.getArrayProxyIDs
+            import arrow.array.internal.getArrayProxyIDs
             
             numColumns = numel(arrowArrays);
             validateArrayLengths(arrowArrays);
diff --git a/matlab/src/matlab/+arrow/+type/Field.m b/matlab/src/matlab/+arrow/+type/Field.m
index aaab36b048e37..fb0b579e20bb9 100644
--- a/matlab/src/matlab/+arrow/+type/Field.m
+++ b/matlab/src/matlab/+arrow/+type/Field.m
@@ -40,14 +40,14 @@
         end
 
         function type = get.Type(obj)
-            [proxyID, typeID] = obj.Proxy.type();
-            traits = arrow.type.traits.traits(arrow.type.ID(typeID));
-            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=proxyID);
+            typeStruct = obj.Proxy.getType();
+            traits = arrow.type.traits.traits(arrow.type.ID(typeStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=typeStruct.ProxyID);
             type = traits.TypeConstructor(proxy);
         end
 
         function name = get.Name(obj)
-            name = obj.Proxy.name();
+            name = obj.Proxy.getName();
         end
 
     end
diff --git a/matlab/src/matlab/+arrow/+type/FixedWidthType.m b/matlab/src/matlab/+arrow/+type/FixedWidthType.m
index 8c9c5b26081ae..06744905252f0 100644
--- a/matlab/src/matlab/+arrow/+type/FixedWidthType.m
+++ b/matlab/src/matlab/+arrow/+type/FixedWidthType.m
@@ -29,7 +29,7 @@
         end
 
         function width = get.BitWidth(obj)
-            width = obj.Proxy.bitWidth();
+            width = obj.Proxy.getBitWidth();
         end
     end 
 end
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index 446649285fdf0..cc2da1403b64c 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -34,11 +34,11 @@
         end
 
         function numFields = get.NumFields(obj)
-            numFields = obj.Proxy.numFields();
+            numFields = obj.Proxy.getNumFields();
         end
 
         function typeID = get.ID(obj)
-            typeID = arrow.type.ID(obj.Proxy.typeID());
+            typeID = arrow.type.ID(obj.Proxy.getTypeID());
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/recordBatch.m b/matlab/src/matlab/+arrow/recordBatch.m
index 662db9cca940c..dd4a042b9d7c3 100644
--- a/matlab/src/matlab/+arrow/recordBatch.m
+++ b/matlab/src/matlab/+arrow/recordBatch.m
@@ -20,7 +20,7 @@
     end
 
     arrowArrays = arrow.tabular.internal.decompose(T);
-    arrayProxyIDs = arrow.tabular.internal.getArrayProxyIDs(arrowArrays);
+    arrayProxyIDs = arrow.array.internal.getArrayProxyIDs(arrowArrays);
 
     columnNames = string(T.Properties.VariableNames);
     args = struct(ArrayProxyIDs=arrayProxyIDs, ColumnNames=columnNames);
diff --git a/matlab/test/arrow/array/tChunkedArray.m b/matlab/test/arrow/array/tChunkedArray.m
new file mode 100644
index 0000000000000..e075d0c31aee0
--- /dev/null
+++ b/matlab/test/arrow/array/tChunkedArray.m
@@ -0,0 +1,267 @@
+%TCHUNKEDARRAY Unit tests arrow.array.ChunkedArray
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tChunkedArray < matlab.unittest.TestCase
+
+    properties (Constant)
+        Float64Array1 = arrow.array([1 2 3 4]);
+        Float64Array2 = arrow.array([NaN 6 7]);
+        Float64Array3 = arrow.array([8 NaN 10 11 12]);
+        Float64Type = arrow.float64()
+    end
+
+    methods (Test)
+        function FromArraysTooFewInputsError(testCase)
+            % Verify an error is thrown when neither the Type nv-pair nor
+            % arrays are provided to fromArrays.
+            import arrow.array.ChunkedArray
+            
+            fcn = @() ChunkedArray.fromArrays();
+            testCase.verifyError(fcn, "arrow:chunkedarray:TypeRequiredWithZeroArrayInputs");
+        end
+
+        function InconsistentArrayTypeError(testCase)
+            % Verify an error is thrown when arrays of different types are
+            % provided to fromArrays.
+            import arrow.array.ChunkedArray
+            
+            float32Array = arrow.array(single([1 2 3]));
+            fcn = @() ChunkedArray.fromArrays(testCase.Float64Array1, float32Array);
+            testCase.verifyError(fcn, "arrow:chunkedarray:MakeFailed");
+        end
+
+        function ArrayTypeNVPairMismatchError(testCase)
+            % Verify an error is thrown when the provided Type name-value 
+            % pair is not equal to the Type values of the provided arrays.
+            import arrow.array.ChunkedArray
+            
+            fcn = @() ChunkedArray.fromArrays(testCase.Float64Array1, ...
+                testCase.Float64Array2, Type=arrow.int32());
+            testCase.verifyError(fcn, "arrow:chunkedarray:MakeFailed");
+        end
+
+        function ZeroArraysTypeNVPairProvided(testCase)
+            % Verify formArrays returns the expected ChunkedArray when zero
+            % arrays are provided as input, but the Type name-value pair is
+            % provided.
+            import arrow.array.ChunkedArray
+            
+            chunkedArray = ChunkedArray.fromArrays(Type=arrow.string());
+            testCase.verifyChunkedArray(chunkedArray, ...
+                                        NumChunks=0, ...
+                                        Type=arrow.string(), ...
+                                        Arrays={});
+        end
+
+        function OneChunk(testCase)
+            % Verify fromArrays returns the expected ChunkedArray when one
+            % array is provided as input.
+            import arrow.array.ChunkedArray
+            
+            chunkedArray = ChunkedArray.fromArrays(testCase.Float64Array1);
+            testCase.verifyChunkedArray(chunkedArray, ...
+                                        NumChunks=1, ...
+                                        Type=testCase.Float64Type, ...
+                                        Arrays={testCase.Float64Array1});
+        end
+
+        function MultipleChunks(testCase)
+            % Verify fromArrays returns the expected ChunkedArray when
+            % multiple arrays are provided as input.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            testCase.verifyChunkedArray(chunkedArray, ...
+                                        NumChunks=3, ...
+                                        Type=testCase.Float64Type, ...
+                                        Arrays=arrays);
+        end
+
+        function TestIsEqualTrue(testCase)
+            % Verifies ChunkedArrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. Their Length properties ar eequal
+            %  3. The same elements are considered null
+            %  4. All corresponding valid elements have the same values
+            %
+            % NOTE: Having the same "chunking" is not a requirement for two
+            % ChunkedArrays to be equal. ChunkedArrays are considered equal
+            % as long as "flattening" them produces the same array.
+
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray1 = ChunkedArray.fromArrays(arrays{:});
+
+            data = [toMATLAB(arrays{1}); toMATLAB(arrays{2}); toMATLAB(arrays{3})];
+            floatArray = arrow.array(data);
+            chunkedArray2 = ChunkedArray.fromArrays(floatArray);
+
+            % Verify a chunked array is considered equal with itself
+            testCase.verifyTrue(isequal(chunkedArray1, chunkedArray1));
+
+            % Verify two chunked arrays are considered equal even if the
+            % way in which they are chunked is different.
+            testCase.verifyTrue(isequal(chunkedArray1, chunkedArray2));
+        end
+
+        function TestIsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray1 = ChunkedArray.fromArrays(arrays{:});
+
+            float64Array1 = arrow.array(toMATLAB(arrays{1}), InferNulls=false);
+            float64Array2 = arrow.array(toMATLAB(arrays{2}), InferNulls=false);
+            float64Array3 = arrow.array(toMATLAB(arrays{3}), InferNulls=false);
+
+            chunkedArray2 = ChunkedArray.fromArrays(float64Array1, float64Array2, float64Array3);
+
+            % Compare ChunkedArrays with different null values.
+            testCase.verifyFalse(isequal(chunkedArray1, chunkedArray2));
+
+            % Compare ChunkedArrays that have NaN values.
+            testCase.verifyFalse(isequal(chunkedArray2, chunkedArray2));
+
+            % Compare ChunkedArrays with different Length values.
+            chunkedArray3 = ChunkedArray.fromArrays(testCase.Float64Array1);
+            testCase.verifyFalse(isequal(chunkedArray1, chunkedArray3));
+
+            % Compare ChunkedArrays with different Type values.
+            float32Array1 = arrow.array(single(toMATLAB(arrays{1})));
+            float32Array2 = arrow.array(single(toMATLAB(arrays{2})));
+            float32Array3 = arrow.array(single(toMATLAB(arrays{3})));
+            chunkedArray3 = ChunkedArray.fromArrays(float32Array1, float32Array2, float32Array3);
+            testCase.verifyFalse(isequal(chunkedArray1, chunkedArray3));
+        end
+
+        function NumChunksNoSetter(testCase)
+            % Verify an error is thrown when trying to set the value
+            % of the NumChunks property.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            
+            fcn = @() setfield(chunkedArray, "NumChunks", int32(6));
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function TypeNoSetter(testCase)
+            % Verify an error is thrown when trying to set the value
+            % of the Type property.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            
+            fcn = @() setfield(chunkedArray, "Type", arrow.int32());
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function LengthNoSetter(testCase)
+            % Verify an error is thrown when trying to set the value
+            % of the Length property.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            
+            fcn = @() setfield(chunkedArray, "Length", int64(100));
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ChunkNonNumericIndexError(testCase)
+            % Verify that an error is thrown when a non-numeric index value
+            % is provided to the chunk() method.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            fcn = @() chunkedArray.chunk("INDEX");
+            testCase.verifyError(fcn, "arrow:badsubscript:NonNumeric");
+        end
+
+        function ChunkNonScalarIndexError(testCase)
+            % Verify that an error is thrown when a non-scalar index value
+            % is provided to the chunk() method.
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+            
+            % Provide a 1x2 array
+            fcn = @() chunkedArray.chunk([1 2]);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Provide a 0x0 array
+            fcn = @() chunkedArray.chunk([]);
+            testCase.verifyError(fcn, "arrow:badsubscript:NonScalar");
+        end
+
+        function NumericIndexWithEmptyChunkedArrayError(testCase)
+            % Verify that an error is thrown when a numeric value greater
+            % than NumChunks is provided to chunk().
+            import arrow.array.ChunkedArray
+
+            arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
+            chunkedArray = ChunkedArray.fromArrays(arrays{:});
+
+            % Provide an index greater than NumChunks
+            fcn = @() chunkedArray.chunk(4);
+            testCase.verifyError(fcn, "arrow:chunkedarray:InvalidNumericChunkIndex");
+        end
+
+        function NumericIndexEmptyChunkedArrayError(testCase)
+            % Verify that an error is thrown when calling chunk() on a
+            % zero-chunk ChunkedArray.
+            import arrow.array.ChunkedArray
+
+            chunkedArray = ChunkedArray.fromArrays(Type=arrow.time32());
+
+            fcn = @() chunkedArray.chunk(2);
+            testCase.verifyError(fcn, "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray");
+        end
+    end
+
+    methods
+        function verifyChunkedArray(testCase, chunkedArray, opts)
+            arguments
+                testCase
+                chunkedArray
+                opts.Type(1, 1) arrow.type.Type
+                opts.NumChunks(1, 1) int32
+                opts.Arrays(1, :) cell
+            end
+            testCase.assertTrue(numel(opts.Arrays) == opts.NumChunks); 
+            allLengths = cellfun(@(a) a.Length, opts.Arrays, UniformOutput=true);
+            expectedLengths = int64(sum(allLengths));
+
+            testCase.verifyEqual(chunkedArray.NumChunks, opts.NumChunks);
+            testCase.verifyEqual(chunkedArray.Length, expectedLengths);
+            testCase.verifyEqual(chunkedArray.Type, opts.Type);
+
+            for ii = 1:opts.NumChunks
+                testCase.verifyEqual(chunkedArray.chunk(ii), opts.Arrays{ii});
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index fadb1924a13c4..3cead42cea257 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -47,6 +47,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time32_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time64_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/chunked_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"

From 3b14c740c71d3d696a926b9e9f86fdad81c930b8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 3 Sep 2023 17:16:20 +0900
Subject: [PATCH 305/749] MINOR: [JS] Bump ts-jest from 29.1.0 to 29.1.1 in /js
 (#37520)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [ts-jest](https://github.com/kulshekhar/ts-jest) from 29.1.0 to 29.1.1.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/kulshekhar/ts-jest/releases">ts-jest's releases</a>.</em></p>
<blockquote>
<h2>v29.1.1</h2>
<p>Please refer to <a href="https://github.com/kulshekhar/ts-jest/blob/main/CHANGELOG.md">CHANGELOG.md</a> for details.</p>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/kulshekhar/ts-jest/blob/main/CHANGELOG.md">ts-jest's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/kulshekhar/ts-jest/compare/v29.1.0...v29.1.1">29.1.1</a> (2023-06-23)</h2>
<h3>Security Fixes</h3>
<ul>
<li>bump <code>semver</code> to <code>7.5.3</code></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/9670787b088e7d6d3b787e02ca74f8e83f57f9ee"><code>9670787</code></a> chore(release): 29.1.1 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4173">#4173</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/8c51d3252cc70e1292f3e29f26ecc7fdeadb98d7"><code>8c51d32</code></a> build(deps): Update actions/checkout digest to c85c95e (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4172">#4172</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/0f82024897739de1b01d97a54ddae6c2c210d737"><code>0f82024</code></a> build(deps): bump semver from 7.3.7 to 7.5.2 in /examples/react-app (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4170">#4170</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/431dca69cd8815bf0ec20fd602cbaa3d54486e09"><code>431dca6</code></a> build(deps): bump semver from 7.5.1 to 7.5.2 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4169">#4169</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/f4f7daeafd8bc4adada99e569a7ab3097ac238b5"><code>f4f7dae</code></a> build(deps): Update <a href="https://github.com/types"><code>@​types</code></a> packages (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4164">#4164</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/5e551acf30ac67c207ca90b44d6f603d89565ab7"><code>5e551ac</code></a> build(deps): Update dependency <code>@​formatjs/ts-transformer</code> to ^3.13.3 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4165">#4165</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/2925d0e0ab81a132bd9d335d046ce1254b7b9268"><code>2925d0e</code></a> build(deps): Update dependency <code>@​formatjs/ts-transformer</code> to ^3.13.2 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4160">#4160</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/71c778612871cfe21c87c5ded9fba95254853090"><code>71c7786</code></a> build(deps): Update <a href="https://github.com/types"><code>@​types</code></a> packages to ^5.59.9 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4159">#4159</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/099102e4a6c924bd6c590e72373635733cd99c64"><code>099102e</code></a> build(deps): Update dependency typescript to ~5.1.3 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4157">#4157</a>)</li>
<li><a href="https://github.com/kulshekhar/ts-jest/commit/6e5a29414ebef58b8318e230dc1054c457c4c757"><code>6e5a294</code></a> build(deps): Update dependency eslint to ^8.42.0 (<a href="https://redirect.github.com/kulshekhar/ts-jest/issues/4158">#4158</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/kulshekhar/ts-jest/compare/v29.1.0...v29.1.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=ts-jest&package-manager=npm_and_yarn&previous-version=29.1.0&new-version=29.1.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 38 +++++++++++++-------------------------
 2 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/js/package.json b/js/package.json
index 75e8132907cb6..1ee0e11bca5b9 100644
--- a/js/package.json
+++ b/js/package.json
@@ -105,7 +105,7 @@
     "randomatic": "3.1.1",
     "rollup": "3.25.0",
     "rxjs": "7.8.1",
-    "ts-jest": "29.1.0",
+    "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
     "typedoc": "0.24.8",
     "typescript": "5.1.3",
diff --git a/js/yarn.lock b/js/yarn.lock
index 5b52b8c0d8dbe..66ede59a598b1 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -862,7 +862,7 @@
     "@types/yargs" "^15.0.0"
     chalk "^4.0.0"
 
-"@jest/types@^29.5.0", "@jest/types@^29.6.1":
+"@jest/types@^29.6.1":
   version "29.6.1"
   resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.1.tgz#ae79080278acff0a6af5eb49d063385aaa897bf2"
   integrity sha512-tPKQNMPuXgvdOn2/Lg9HNfUvjYVGolt04Hp03f5hAk878uwOLikN+JzeLY0HcVgKgFl9Hs3EIqpu3WX27XNhnw==
@@ -4459,19 +4459,7 @@ jest-util@^26.0.0:
     is-ci "^2.0.0"
     micromatch "^4.0.2"
 
-jest-util@^29.0.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.5.0.tgz#24a4d3d92fc39ce90425311b23c27a6e0ef16b8f"
-  integrity sha512-RYMgG/MTadOr5t8KdhejfvUU82MxsCu5MF6KuDUHl+NuwzUt+Sm6jJWxTJVrDR1j5M/gJVCPKQEpWXY+yIQ6lQ==
-  dependencies:
-    "@jest/types" "^29.5.0"
-    "@types/node" "*"
-    chalk "^4.0.0"
-    ci-info "^3.2.0"
-    graceful-fs "^4.2.9"
-    picomatch "^2.2.3"
-
-jest-util@^29.6.2:
+jest-util@^29.0.0, jest-util@^29.6.2:
   version "29.6.2"
   resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.6.2.tgz#8a052df8fff2eebe446769fd88814521a517664d"
   integrity sha512-3eX1qb6L88lJNCFlEADKOkjpXJQyZRiavX1INZ4tRnrBVr2COd3RgcTLyUiEXMNBlDU/cgYq6taUS0fExrWW4w==
@@ -6036,18 +6024,18 @@ semver-greatest-satisfied-range@^1.1.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
 
-semver@7.x, semver@^7.3.4, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
+semver@^6.0.0, semver@^6.3.0:
+  version "6.3.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
+  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
+
+semver@^7.3.4, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
   version "7.5.4"
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
   dependencies:
     lru-cache "^6.0.0"
 
-semver@^6.0.0, semver@^6.3.0:
-  version "6.3.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
-  integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
-
 serialize-javascript@^6.0.1:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.1.tgz#b206efb27c3da0b0ab6b52f48d170b7996458e5c"
@@ -6637,10 +6625,10 @@ trim-newlines@^4.0.2:
   resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-4.1.1.tgz#28c88deb50ed10c7ba6dc2474421904a00139125"
   integrity sha512-jRKj0n0jXWo6kh62nA5TEh3+4igKDXLvzBJcPpiizP7oOolUrYIxmVBG9TOtHYFHoddUk6YvAkGeGoSVTXfQXQ==
 
-ts-jest@29.1.0:
-  version "29.1.0"
-  resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-29.1.0.tgz#4a9db4104a49b76d2b368ea775b6c9535c603891"
-  integrity sha512-ZhNr7Z4PcYa+JjMl62ir+zPiNJfXJN6E8hSLnaUKhOgqcn8vb3e537cpkd0FuAfRK3sR1LSqM1MOhliXNgOFPA==
+ts-jest@29.1.1:
+  version "29.1.1"
+  resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-29.1.1.tgz#f58fe62c63caf7bfcc5cc6472082f79180f0815b"
+  integrity sha512-D6xjnnbP17cC85nliwGiL+tpoKN0StpgE0TeOjXQTU6MVCfsB4v7aW05CgQ/1OywGb0x/oy9hHFnN+sczTiRaA==
   dependencies:
     bs-logger "0.x"
     fast-json-stable-stringify "2.x"
@@ -6648,7 +6636,7 @@ ts-jest@29.1.0:
     json5 "^2.2.3"
     lodash.memoize "4.x"
     make-error "1.x"
-    semver "7.x"
+    semver "^7.5.3"
     yargs-parser "^21.0.1"
 
 ts-node@10.9.1:

From 3ad2d0ccd98192d32d54af371bad6b61ea3c4736 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 4 Sep 2023 11:41:09 +0900
Subject: [PATCH 306/749] GH-37410: [C++][Gandiva] Add support for using LLVM
 shared library (#37412)

### Rationale for this change

Gandiva always links LLVM statically. But we can use LLVM shared library instead to reduce `libgandiva.so` size.

### What changes are included in this PR?

Add `ARROW_LLVM_USE_SHARED` like other dependencies.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.

This has a backward incompatible change. LLVM shared library not static libraries is used by default. If you want to use LLVM static libraries, you need to specify `-DARROW_LLVM_USE_SHARED=OFF` or `-DARROW_DEPENDENCY_USE_SHARED=OFF` explicitly.
* Closes: #37410

Lead-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/DefineOptions.cmake |  9 +++++
 cpp/cmake_modules/FindLLVMAlt.cmake   | 55 ++++++++++++++-------------
 cpp/src/gandiva/CMakeLists.txt        |  4 +-
 3 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index 29517567ce6e5..6e6a74c9c78f8 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -470,6 +470,15 @@ takes precedence over ccache if a storage backend is configured" ON)
                 "Rely on jemalloc shared libraries where relevant"
                 ${ARROW_DEPENDENCY_USE_SHARED})
 
+  if(MSVC)
+    # LLVM doesn't support shared library with MSVC.
+    set(ARROW_LLVM_USE_SHARED_DEFAULT OFF)
+  else()
+    set(ARROW_LLVM_USE_SHARED_DEFAULT ${ARROW_DEPENDENCY_USE_SHARED})
+  endif()
+  define_option(ARROW_LLVM_USE_SHARED "Rely on LLVM shared libraries where relevant"
+                ${ARROW_LLVM_USE_SHARED_DEFAULT})
+
   define_option(ARROW_LZ4_USE_SHARED "Rely on lz4 shared libraries where relevant"
                 ${ARROW_DEPENDENCY_USE_SHARED})
 
diff --git a/cpp/cmake_modules/FindLLVMAlt.cmake b/cpp/cmake_modules/FindLLVMAlt.cmake
index b3d77978f153c..e980f53fd3407 100644
--- a/cpp/cmake_modules/FindLLVMAlt.cmake
+++ b/cpp/cmake_modules/FindLLVMAlt.cmake
@@ -68,18 +68,6 @@ if(NOT LLVM_FOUND)
 endif()
 
 if(LLVM_FOUND)
-  # Find the libraries that correspond to the LLVM components
-  llvm_map_components_to_libnames(LLVM_LIBS
-                                  core
-                                  mcjit
-                                  native
-                                  ipo
-                                  bitreader
-                                  target
-                                  linker
-                                  analysis
-                                  debuginfodwarf)
-
   find_program(LLVM_LINK_EXECUTABLE llvm-link HINTS ${LLVM_TOOLS_BINARY_DIR})
 
   find_program(CLANG_EXECUTABLE
@@ -94,22 +82,37 @@ if(LLVM_FOUND)
                                    INTERFACE_COMPILE_FLAGS "${LLVM_DEFINITIONS}")
 
   add_library(LLVM::LLVM_LIBS INTERFACE IMPORTED)
-  set_target_properties(LLVM::LLVM_LIBS PROPERTIES INTERFACE_LINK_LIBRARIES
-                                                   "${LLVM_LIBS}")
+  if(ARROW_LLVM_USE_SHARED)
+    target_link_libraries(LLVM::LLVM_LIBS INTERFACE LLVM)
+  else()
+    # Find the libraries that correspond to the LLVM components
+    llvm_map_components_to_libnames(LLVM_LIBS
+                                    core
+                                    mcjit
+                                    native
+                                    ipo
+                                    bitreader
+                                    target
+                                    linker
+                                    analysis
+                                    debuginfodwarf)
+    target_link_libraries(LLVM::LLVM_LIBS INTERFACE ${LLVM_LIBS})
 
-  if(TARGET LLVMSupport AND NOT ARROW_ZSTD_USE_SHARED)
-    get_target_property(LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES LLVMSupport
-                        INTERFACE_LINK_LIBRARIES)
-    list(FIND LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES zstd::libzstd_shared
-         LLVM_SUPPORT_LIBZSTD_INDEX)
-    if(NOT LLVM_SUPPORT_LIBZSTD_INDEX EQUAL -1)
-      list(REMOVE_AT LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES ${LLVM_SUPPORT_LIBZSTD_INDEX})
-      list(INSERT LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES ${LLVM_SUPPORT_LIBZSTD_INDEX}
-           zstd::libzstd_static)
+    if(TARGET LLVMSupport AND NOT ARROW_ZSTD_USE_SHARED)
+      get_target_property(LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES LLVMSupport
+                          INTERFACE_LINK_LIBRARIES)
+      list(FIND LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES zstd::libzstd_shared
+           LLVM_SUPPORT_LIBZSTD_INDEX)
+      if(NOT LLVM_SUPPORT_LIBZSTD_INDEX EQUAL -1)
+        list(REMOVE_AT LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES
+             ${LLVM_SUPPORT_LIBZSTD_INDEX})
+        list(INSERT LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES ${LLVM_SUPPORT_LIBZSTD_INDEX}
+             zstd::libzstd_static)
+      endif()
+      set_target_properties(LLVMSupport
+                            PROPERTIES INTERFACE_LINK_LIBRARIES
+                                       "${LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES}")
     endif()
-    set_target_properties(LLVMSupport
-                          PROPERTIES INTERFACE_LINK_LIBRARIES
-                                     "${LLVM_SUPPORT_INTERFACE_LINK_LIBRARIES}")
   endif()
 endif()
 
diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index 6a92224e9113d..db260b5acc933 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -175,14 +175,14 @@ add_dependencies(gandiva ${GANDIVA_LIBRARIES})
 arrow_install_all_headers("gandiva")
 
 set(GANDIVA_STATIC_TEST_LINK_LIBS gandiva_static ${ARROW_TEST_LINK_LIBS})
-set(GANDIVA_SHARED_TEST_LINK_LIBS gandiva_shared ${ARROW_TEST_LINK_LIBS})
+set(GANDIVA_SHARED_TEST_LINK_LIBS gandiva_shared ${ARROW_TEST_LINK_LIBS} LLVM::LLVM_LIBS)
 if(ARROW_WITH_UTF8PROC)
   list(APPEND GANDIVA_SHARED_TEST_LINK_LIBS utf8proc::utf8proc)
   list(APPEND GANDIVA_STATIC_TEST_LINK_LIBS utf8proc::utf8proc)
 endif()
 if(WIN32)
   list(APPEND GANDIVA_STATIC_TEST_LINK_LIBS ${GANDIVA_OPENSSL_TARGETS})
-  list(APPEND GANDIVA_SHARED_TEST_LINK_LIBS LLVM::LLVM_LIBS ${GANDIVA_OPENSSL_TARGETS})
+  list(APPEND GANDIVA_SHARED_TEST_LINK_LIBS ${GANDIVA_OPENSSL_TARGETS})
 endif()
 
 function(ADD_GANDIVA_TEST REL_TEST_NAME)

From 3ce3a08fd0814f3547da0cf2e44c50261bb45bd5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:34:35 +0900
Subject: [PATCH 307/749] MINOR: [C#] Bump Google.Protobuf from 3.24.1 to
 3.24.2 in /csharp (#37547)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.24.1 to 3.24.2.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/54a2e5caa9d1a0a714fb2aa99753a1444414292a"><code>54a2e5c</code></a> Updating version.json and repo version numbers to: 24.2</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/7b825e1ca7e8624ff249451560c714382404d1a7"><code>7b825e1</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13656">#13656</a> from protocolbuffers/backport-tdp-msvc-32</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/5626baf004c3bb39fd4b362434c3f4cc8cc170f0"><code>5626baf</code></a> Remove a flaky test with very high memory requirements.</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/31efbb9f0eb9c4d020713a20fa07b7471802ae57"><code>31efbb9</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13655">#13655</a> from mkruskal-google/backport-tdp-msvc-32</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/01e1a5c28ae00cca0821a95e3c68447df4d1591c"><code>01e1a5c</code></a> Fixes for 32-bit MSVC.</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/a478e190268bd7e842def5cdf97ea008c092030d"><code>a478e19</code></a> Add windows 32-bit tests and re-enable 2022</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/57d122993f15c9cedf02a9e5d3051118b7b8046a"><code>57d1229</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13603">#13603</a> from protocolbuffers/24.x-202308181942</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/4a6f9c301f0eb38ec447414c5bce1ab97452dabd"><code>4a6f9c3</code></a> Updating version.json to: 24.2-dev</li>
<li>See full diff in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.24.1...v3.24.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.24.1&new-version=3.24.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 6550271f32093..799338e838e54 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.24.1" />
+    <PackageReference Include="Google.Protobuf" Version="3.24.2" />
     <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
     <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>

From ab303efb979e385e7e3f71cdd9c5ae57ec9ff1e8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:35:06 +0900
Subject: [PATCH 308/749] MINOR: [C#] Bump Microsoft.NET.Test.Sdk from 17.7.1
 to 17.7.2 in /csharp (#37548)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.7.1 to 17.7.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/releases">Microsoft.NET.Test.Sdk's releases</a>.</em></p>
<blockquote>
<h2>v17.7.2</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix cannot find System.Text.Json by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4669">microsoft/vstest#4669</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.7.1...v17.7.2">https://github.com/microsoft/vstest/compare/v17.7.1...v17.7.2</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/vstest/commit/604e7beeb3abe7e351a7bb5e507bea66d76a5888"><code>604e7be</code></a> [rel/17.7] Fix cannot find System.Text.Json (<a href="https://redirect.github.com/microsoft/vstest/issues/4669">#4669</a>)</li>
<li>See full diff in <a href="https://github.com/microsoft/vstest/compare/v17.7.1...v17.7.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.NET.Test.Sdk&package-manager=nuget&previous-version=17.7.1&new-version=17.7.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 0ae95a7b3690d..e06e0f9ef2845 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 860f7c9b34f69..dff3f1e541c08 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
       <PackageReference Include="xunit" Version="2.5.0" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 30b97738d540e..7f5a726ee5f03 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 044f1563035d7..ace172443d982 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>

From f8ec2df78aad6bd957fcfb9ef35012ac53485085 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:35:33 +0900
Subject: [PATCH 309/749] MINOR: [C#] Bump pythonnet from 3.0.1 to 3.0.2 in
 /csharp (#37549)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [pythonnet](https://github.com/pythonnet/pythonnet) from 3.0.1 to 3.0.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/pythonnet/pythonnet/releases">pythonnet's releases</a>.</em></p>
<blockquote>
<h2>v3.0.2</h2>
<h2>What's Changed</h2>
<ul>
<li>1776 Generic Virtual Method Causes Invalid Program: Fix + test by <a href="https://github.com/rmadsen-ks"><code>@​rmadsen-ks</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2026">pythonnet/pythonnet#2026</a></li>
<li>Workaround for Ubuntu-provided package version being unsupported by <a href="https://github.com/lostmsu"><code>@​lostmsu</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2081">pythonnet/pythonnet#2081</a></li>
<li>Ensure that <code>load</code> only runs once by <a href="https://github.com/filmor"><code>@​filmor</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2079">pythonnet/pythonnet#2079</a></li>
<li>Remove suggestions to use <code>internal</code> functions by <a href="https://github.com/filmor"><code>@​filmor</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2092">pythonnet/pythonnet#2092</a></li>
<li>1783 Implement Interface And Inherit Class by <a href="https://github.com/rmadsen-ks"><code>@​rmadsen-ks</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2028">pythonnet/pythonnet#2028</a></li>
<li>Fix <code>GetBuffer</code> throwing <code>ArgumentOutOfRangeException</code> by <a href="https://github.com/legomanww"><code>@​legomanww</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2120">pythonnet/pythonnet#2120</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/legomanww"><code>@​legomanww</code></a> made their first contribution in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2120">pythonnet/pythonnet#2120</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/pythonnet/pythonnet/compare/v3.0.1...v3.0.2">https://github.com/pythonnet/pythonnet/compare/v3.0.1...v3.0.2</a></p>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/pythonnet/pythonnet/blob/master/CHANGELOG.md">pythonnet's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/pythonnet/pythonnet/releases/tag/v3.0.2">3.0.2</a> - 2023-08-29</h2>
<h3>Fixed</h3>
<ul>
<li>Fixed error occuring when inheriting a class containing a virtual generic method</li>
<li>Make a second call to <code>pythonnet.load</code> a no-op, as it was intended</li>
<li>Added support for multiple inheritance when inheriting from a class and/or multiple interfaces</li>
<li>Fixed error occuring when calling <code>GetBuffer</code> for anything other than <code>PyBUF.SIMPLE</code></li>
<li>Bumped <code>clr_loader</code> dependency to incorporate patches</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/pythonnet/pythonnet/commit/6a4e04c1983b24888a1e8b04d75c28086594cb63"><code>6a4e04c</code></a> Release 3.0.2</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/639023a5ca0a3375fd39d2fea8baa5e9888284d0"><code>639023a</code></a> Bump clr_loader dependency</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/3b6500fbdc844096665a24ba07f5a56c11192e1b"><code>3b6500f</code></a> Add documentation dependency to fix empty docs</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/dddadbe78ef0fba3e8ffde30c466f224dbbc9aea"><code>dddadbe</code></a> Adjust docs for importing</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/a1cd73fa5bd93962737449feea3bd425f37c42ba"><code>a1cd73f</code></a> Exclude .gitignore from binary distribution</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/131b466dcaa9cf9135f3b1859c8a41ee229cace8"><code>131b466</code></a> Fix <code>GetBuffer</code> throwing <code>ArgumentOutOfRangeException</code> (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2120">#2120</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/a404d6e4d2ef6182763bd626ab08e0de4400e621"><code>a404d6e</code></a> 1783 Implement Interface And Inherit Class (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2028">#2028</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/c2fa4677035ef51d883be14aea9e41acfef281ea"><code>c2fa467</code></a> Remove suggestions to use <code>internal</code> functions (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2092">#2092</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/a0418119b452e29a3e9f025fbed67fe19412fbee"><code>a041811</code></a> Ensure that <code>load</code> only runs once (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2079">#2079</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/4020a0ca4738abdcb556c3d81f237081687b6461"><code>4020a0c</code></a> don't force setuptools upgrade during installation of requirements for testing</li>
<li>Additional commits viewable in <a href="https://github.com/pythonnet/pythonnet/compare/v3.0.1...v3.0.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=pythonnet&package-manager=nuget&previous-version=3.0.1&new-version=3.0.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index ace172443d982..d6dc25d6b5e20 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -17,7 +17,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
     <PackageReference Include="xunit.skippablefact" Version="1.4.13" />
-    <PackageReference Include="pythonnet" Version="3.0.1" />
+    <PackageReference Include="pythonnet" Version="3.0.2" />
   </ItemGroup>
 
   <ItemGroup>

From 0bdb26e755e419adf6b1ea2c57bf3e5f4dc988b5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:41:36 +0900
Subject: [PATCH 310/749] MINOR: [C#] Bump Grpc.AspNetCore.Server from 2.55.0
 to 2.56.0 in /csharp (#37546)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore.Server](https://github.com/grpc/grpc-dotnet) from 2.55.0 to 2.56.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore.Server's releases</a>.</em></p>
<blockquote>
<h2>Release v2.56.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Update version to 2.56.0 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2251">grpc/grpc-dotnet#2251</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0</a></p>
<h2>Release v2.56.0-pre2</h2>
<h2>What's Changed</h2>
<ul>
<li>[2.56.x] Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2234">grpc/grpc-dotnet#2234</a></li>
<li>[2.56.x] Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2233">grpc/grpc-dotnet#2233</a></li>
<li>Update version to -pre2 on v2.56.x branch by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2246">grpc/grpc-dotnet#2246</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2</a></p>
<h2>Release v2.56.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Update 2.55 branch to 2.55-pre1 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2174">grpc/grpc-dotnet#2174</a></li>
<li>Revert &quot;update 2.55 branch to 2.55-pre1&quot; by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2175">grpc/grpc-dotnet#2175</a></li>
<li>Update version to 2.55.0-dev (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2177">grpc/grpc-dotnet#2177</a></li>
<li>update readme by <a href="https://github.com/Varorbc"><code>@​Varorbc</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2183">grpc/grpc-dotnet#2183</a></li>
<li>Start 2.56.x development cycle (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2185">grpc/grpc-dotnet#2185</a></li>
<li>Improve grpc-dotnet debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2192">grpc/grpc-dotnet#2192</a></li>
<li>Even better gRPC debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2193">grpc/grpc-dotnet#2193</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2199">grpc/grpc-dotnet#2199</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2198">grpc/grpc-dotnet#2198</a></li>
<li>Bump tough-cookie from 4.0.0 to 4.1.3 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2187">grpc/grpc-dotnet#2187</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2189">grpc/grpc-dotnet#2189</a></li>
<li>Remove System.Memory dependency on .NET Standard 2.1 in Grpc.Core.Api. by <a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
<li>Socket transport: Don't close socket on available data by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2179">grpc/grpc-dotnet#2179</a></li>
<li>Update SocketConnectivitySubchannelTransport.cs by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2202">grpc/grpc-dotnet#2202</a></li>
<li>Improve gRPC channel and client debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2196">grpc/grpc-dotnet#2196</a></li>
<li>Fix gRPC client retry deadlock by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2209">grpc/grpc-dotnet#2209</a></li>
<li>Support idle connection timeout with pending sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2213">grpc/grpc-dotnet#2213</a></li>
<li>Correctly check socket on stream creation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2215">grpc/grpc-dotnet#2215</a></li>
<li>Add net462 build to Grpc.Net.Client with WinHttpHandler default by <a href="https://github.com/stephentoub"><code>@​stephentoub</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2220">grpc/grpc-dotnet#2220</a></li>
<li>Update version to v2.56.0-pre1 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2224">grpc/grpc-dotnet#2224</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> made their first contribution in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b9e7a8b03fa8cb23fce00e2d3f70888a0a6e757b"><code>b9e7a8b</code></a> Update version to 2.56.0 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2251">#2251</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c41d7e2302d85d55b6282023d4edc770325517c3"><code>c41d7e2</code></a> Update version to -pre2 on v2.56.x branch (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2246">#2246</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/400bbb7aeadb8584bd0bbe6ba3b2d0590b1a8884"><code>400bbb7</code></a> [2.56.x] Validate Windows version when using WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2233">#2233</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1422de08f0d499f4c44c702c70baad22b278725c"><code>1422de0</code></a> [2.56.x] Support infinite idle connection timeout values (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2234">#2234</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/df13e5a7f1c0899302a0e259ad562a24531b5246"><code>df13e5a</code></a> Update version to v2.56.0-pre1 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2224">#2224</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6a4bca703aee8040144b7548c88706063445c1fb"><code>6a4bca7</code></a> Add net462 build to Grpc.Net.Client with WinHttpHandler default (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2220">#2220</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a2d005c86bfea561105155d5d9366d74531872cc"><code>a2d005c</code></a> Correctly check socket on stream creation (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2215">#2215</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1d1234064c3c6a5ed394bc56a13bf1dc687a12d4"><code>1d12340</code></a> Support idle connection timeout with pending sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2213">#2213</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/0ab3ada34aa76740b436b3b1d320f2f406f82f50"><code>0ab3ada</code></a> Fix gRPC client retry deadlock (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2209">#2209</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bff852c7f10ebf917e8229940eb8ac695f141ac0"><code>bff852c</code></a> Improve gRPC channel and client debugging (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2196">#2196</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore.Server&package-manager=nuget&previous-version=2.55.0&new-version=2.56.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.AspNetCore.csproj                       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
index 7afb51925e6cc..c794e1a4f5089 100644
--- a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
+++ b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.55.0" />
+    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.56.0" />
   </ItemGroup>
 
   <ItemGroup>

From 43afe59f60de47f2ccc9d7ef60cea0421becd1a0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:54:10 +0900
Subject: [PATCH 311/749] MINOR: [CI] Bump actions/checkout from 3 to 4
 (#37551)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/actions/checkout/releases">actions/checkout's releases</a>.</em></p>
<blockquote>
<h2>v4.0.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Update default runtime to node20 by <a href="https://github.com/takost"><code>@​takost</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1436">actions/checkout#1436</a></li>
<li>Support fetching without the --progress option by <a href="https://github.com/simonbaird"><code>@​simonbaird</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1067">actions/checkout#1067</a></li>
<li>Release 4.0.0 by <a href="https://github.com/takost"><code>@​takost</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1447">actions/checkout#1447</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/takost"><code>@​takost</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1436">actions/checkout#1436</a></li>
<li><a href="https://github.com/simonbaird"><code>@​simonbaird</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1067">actions/checkout#1067</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/checkout/compare/v3...v4.0.0">https://github.com/actions/checkout/compare/v3...v4.0.0</a></p>
<h2>v3.6.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Mark test scripts with Bash'isms to be run via Bash by <a href="https://github.com/dscho"><code>@​dscho</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1377">actions/checkout#1377</a></li>
<li>Add option to fetch tags even if fetch-depth &gt; 0 by <a href="https://github.com/RobertWieczoreck"><code>@​RobertWieczoreck</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/579">actions/checkout#579</a></li>
<li>Release 3.6.0 by <a href="https://github.com/luketomlinson"><code>@​luketomlinson</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1437">actions/checkout#1437</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/RobertWieczoreck"><code>@​RobertWieczoreck</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/579">actions/checkout#579</a></li>
<li><a href="https://github.com/luketomlinson"><code>@​luketomlinson</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1437">actions/checkout#1437</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/checkout/compare/v3.5.3...v3.6.0">https://github.com/actions/checkout/compare/v3.5.3...v3.6.0</a></p>
<h2>v3.5.3</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix: Checkout Issue in self hosted runner due to faulty submodule check-ins by <a href="https://github.com/megamanics"><code>@​megamanics</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1196">actions/checkout#1196</a></li>
<li>Fix typos found by codespell by <a href="https://github.com/DimitriPapadopoulos"><code>@​DimitriPapadopoulos</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1287">actions/checkout#1287</a></li>
<li>Add support for sparse checkouts by <a href="https://github.com/dscho"><code>@​dscho</code></a> and <a href="https://github.com/dfdez"><code>@​dfdez</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1369">actions/checkout#1369</a></li>
<li>Release v3.5.3 by <a href="https://github.com/TingluoHuang"><code>@​TingluoHuang</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1376">actions/checkout#1376</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/megamanics"><code>@​megamanics</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1196">actions/checkout#1196</a></li>
<li><a href="https://github.com/DimitriPapadopoulos"><code>@​DimitriPapadopoulos</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1287">actions/checkout#1287</a></li>
<li><a href="https://github.com/dfdez"><code>@​dfdez</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1369">actions/checkout#1369</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/checkout/compare/v3...v3.5.3">https://github.com/actions/checkout/compare/v3...v3.5.3</a></p>
<h2>v3.5.2</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix: Use correct API url / endpoint in GHES by <a href="https://github.com/fhammerl"><code>@​fhammerl</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1289">actions/checkout#1289</a> based on <a href="https://redirect.github.com/actions/checkout/issues/1286">#1286</a> by <a href="https://github.com/1newsr"><code>@​1newsr</code></a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/checkout/compare/v3.5.1...v3.5.2">https://github.com/actions/checkout/compare/v3.5.1...v3.5.2</a></p>
<h2>v3.5.1</h2>
<h2>What's Changed</h2>
<ul>
<li>Improve checkout performance on Windows runners by upgrading <code>@​actions/github</code> dependency by <a href="https://github.com/BrettDong"><code>@​BrettDong</code></a> in <a href="https://redirect.github.com/actions/checkout/pull/1246">actions/checkout#1246</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/BrettDong"><code>@​BrettDong</code></a> made their first contribution in <a href="https://redirect.github.com/actions/checkout/pull/1246">actions/checkout#1246</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/actions/checkout/blob/main/CHANGELOG.md">actions/checkout's changelog</a>.</em></p>
<blockquote>
<h1>Changelog</h1>
<h2>v4.0.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1067">Support fetching without the --progress option</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1436">Update to node20</a></li>
</ul>
<h2>v3.6.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1377">Fix: Mark test scripts with Bash'isms to be run via Bash</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/579">Add option to fetch tags even if fetch-depth &gt; 0</a></li>
</ul>
<h2>v3.5.3</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1196">Fix: Checkout fail in self-hosted runners when faulty submodule are checked-in</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1287">Fix typos found by codespell</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1369">Add support for sparse checkouts</a></li>
</ul>
<h2>v3.5.2</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1289">Fix api endpoint for GHES</a></li>
</ul>
<h2>v3.5.1</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1246">Fix slow checkout on Windows</a></li>
</ul>
<h2>v3.5.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1237">Add new public key for known_hosts</a></li>
</ul>
<h2>v3.4.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1209">Upgrade codeql actions to v2</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1210">Upgrade dependencies</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1225">Upgrade <code>@​actions/io</code></a></li>
</ul>
<h2>v3.3.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/1045">Implement branch list using callbacks from exec function</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1050">Add in explicit reference to private checkout options</a></li>
<li>[Fix comment typos (that got added in <a href="https://redirect.github.com/actions/checkout/issues/770">#770</a>)](<a href="https://redirect.github.com/actions/checkout/pull/1057">actions/checkout#1057</a>)</li>
</ul>
<h2>v3.2.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/942">Add GitHub Action to perform release</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/967">Fix status badge</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1002">Replace datadog/squid with ubuntu/squid Docker image</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/964">Wrap pipeline commands for submoduleForeach in quotes</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1029">Update <code>@​actions/io</code> to 1.1.2</a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/1039">Upgrading version to 3.2.0</a></li>
</ul>
<h2>v3.1.0</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/939">Use <code>@​actions/core</code> <code>saveState</code> and <code>getState</code></a></li>
<li><a href="https://redirect.github.com/actions/checkout/pull/922">Add <code>github-server-url</code> input</a></li>
</ul>
<h2>v3.0.2</h2>
<ul>
<li><a href="https://redirect.github.com/actions/checkout/pull/770">Add input <code>set-safe-directory</code></a></li>
</ul>
<h2>v3.0.1</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/actions/checkout/commit/3df4ab11eba7bda6032a0b82a6bb43b11571feac"><code>3df4ab1</code></a> Release 4.0.0 (<a href="https://redirect.github.com/actions/checkout/issues/1447">#1447</a>)</li>
<li><a href="https://github.com/actions/checkout/commit/8b5e8b768746b50394015010d25e690bfab9dfbc"><code>8b5e8b7</code></a> Support fetching without the --progress option (<a href="https://redirect.github.com/actions/checkout/issues/1067">#1067</a>)</li>
<li><a href="https://github.com/actions/checkout/commit/97a652b80035363df47baee5031ec8670b8878ac"><code>97a652b</code></a> Update default runtime to node20 (<a href="https://redirect.github.com/actions/checkout/issues/1436">#1436</a>)</li>
<li>See full diff in <a href="https://github.com/actions/checkout/compare/v3...v4">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/checkout&package-manager=github_actions&previous-version=3&new-version=4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Lead-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/archery.yml      |  2 +-
 .github/workflows/comment_bot.yml  |  6 +++---
 .github/workflows/cpp.yml          | 10 +++++-----
 .github/workflows/csharp.yml       |  6 +++---
 .github/workflows/dev.yml          |  4 ++--
 .github/workflows/dev_pr.yml       |  2 +-
 .github/workflows/docs.yml         |  2 +-
 .github/workflows/docs_light.yml   |  2 +-
 .github/workflows/go.yml           | 18 +++++++++---------
 .github/workflows/integration.yml  |  4 ++--
 .github/workflows/java.yml         |  6 +++---
 .github/workflows/java_jni.yml     |  4 ++--
 .github/workflows/java_nightly.yml |  4 ++--
 .github/workflows/js.yml           |  6 +++---
 .github/workflows/matlab.yml       |  6 +++---
 .github/workflows/pr_bot.yml       |  2 +-
 .github/workflows/python.yml       |  4 ++--
 .github/workflows/r.yml            |  8 ++++----
 .github/workflows/r_nightly.yml    |  4 ++--
 .github/workflows/ruby.yml         |  6 +++---
 .github/workflows/swift.yml        |  2 +-
 dev/tasks/docs/github.linux.yml    |  2 +-
 dev/tasks/macros.jinja             |  4 ++--
 23 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/.github/workflows/archery.yml b/.github/workflows/archery.yml
index d337ec797cf90..bc11bb42366e2 100644
--- a/.github/workflows/archery.yml
+++ b/.github/workflows/archery.yml
@@ -50,7 +50,7 @@ jobs:
     timeout-minutes: 15
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Git Fixup
diff --git a/.github/workflows/comment_bot.yml b/.github/workflows/comment_bot.yml
index 43eb86ebe9434..cc9e02d955afd 100644
--- a/.github/workflows/comment_bot.yml
+++ b/.github/workflows/comment_bot.yml
@@ -35,7 +35,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: arrow
           # fetch the tags for version number generation
@@ -60,7 +60,7 @@ jobs:
     if: startsWith(github.event.comment.body, '@github-actions autotune')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: r-lib/actions/pr-fetch@v2
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
@@ -158,7 +158,7 @@ jobs:
     if: startsWith(github.event.comment.body, '@github-actions rebase')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: r-lib/actions/pr-fetch@v2
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index bf110c87b5fec..fc8d0bad58e9f 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -96,7 +96,7 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -138,7 +138,7 @@ jobs:
     timeout-minutes: 45
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -186,7 +186,7 @@ jobs:
           sysctl -a | grep cpu
           sysctl -a | grep "hw.optional"
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -290,7 +290,7 @@ jobs:
       - name: Install Dependencies
         run: choco install -y --no-progress openssl
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -393,7 +393,7 @@ jobs:
             /d 1 `
             /f
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/csharp.yml b/.github/workflows/csharp.yml
index 2a739e6f95bde..3d1e513bc609c 100644
--- a/.github/workflows/csharp.yml
+++ b/.github/workflows/csharp.yml
@@ -53,7 +53,7 @@ jobs:
         with:
           dotnet-version: ${{ matrix.dotnet }}
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Source Link
@@ -81,7 +81,7 @@ jobs:
         with:
           dotnet-version: ${{ matrix.dotnet }}
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Source Link
@@ -108,7 +108,7 @@ jobs:
         with:
           dotnet-version: ${{ matrix.dotnet }}
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Source Link
diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index 119d11d9a399a..f97c499890191 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -37,7 +37,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Setup Python
@@ -84,7 +84,7 @@ jobs:
       GIT_COMMITTER_EMAIL: github@actions
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Python
diff --git a/.github/workflows/dev_pr.yml b/.github/workflows/dev_pr.yml
index 23db5e0f53bbd..e5d2a77c5a8a2 100644
--- a/.github/workflows/dev_pr.yml
+++ b/.github/workflows/dev_pr.yml
@@ -43,7 +43,7 @@ jobs:
     name: Process
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           repository: apache/arrow
           ref: main
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index a4629001f8e48..a1ac4c3067dae 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -38,7 +38,7 @@ jobs:
       UBUNTU: "22.04"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Free up disk space
diff --git a/.github/workflows/docs_light.yml b/.github/workflows/docs_light.yml
index 21185b746eee7..74e6eabe24795 100644
--- a/.github/workflows/docs_light.yml
+++ b/.github/workflows/docs_light.yml
@@ -47,7 +47,7 @@ jobs:
       PYTHON: "3.9"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Cache Docker Volumes
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index df4f1207ee842..c31ad0b77c2df 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -78,7 +78,7 @@ jobs:
       STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -139,7 +139,7 @@ jobs:
     timeout-minutes: 20
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install Go
@@ -172,7 +172,7 @@ jobs:
       STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -219,7 +219,7 @@ jobs:
       STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Setup Python
@@ -261,7 +261,7 @@ jobs:
             staticcheck: v0.3.3
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -296,7 +296,7 @@ jobs:
             staticcheck: v0.3.3
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -359,7 +359,7 @@ jobs:
       ARROW_GO_TESTCGO: "1"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -409,7 +409,7 @@ jobs:
             /d 1 `
             /f
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -451,7 +451,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 62b61c29bc0ae..430b0bb2822e7 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -62,12 +62,12 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Checkout Arrow Rust
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: apache/arrow-rs
           path: rust
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 49e500b42083f..4c144955fbe93 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -80,7 +80,7 @@ jobs:
       MAVEN: ${{ matrix.maven }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -129,7 +129,7 @@ jobs:
           distribution: 'zulu'
           java-version: ${{ matrix.jdk }}
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -156,7 +156,7 @@ jobs:
           java-version: ${{ matrix.jdk }}
           distribution: 'temurin'
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/java_jni.yml b/.github/workflows/java_jni.yml
index 2bfc7c82c25da..0e75468cd374b 100644
--- a/.github/workflows/java_jni.yml
+++ b/.github/workflows/java_jni.yml
@@ -56,7 +56,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -96,7 +96,7 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/java_nightly.yml b/.github/workflows/java_nightly.yml
index 5dfef4626597f..4440d36d18f73 100644
--- a/.github/workflows/java_nightly.yml
+++ b/.github/workflows/java_nightly.yml
@@ -43,7 +43,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 1
           path: arrow
@@ -51,7 +51,7 @@ jobs:
           ref: main
           submodules: recursive
       - name: Checkout Crossbow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           path: crossbow
diff --git a/.github/workflows/js.yml b/.github/workflows/js.yml
index 7e8ef31b49cb6..9be11596d845f 100644
--- a/.github/workflows/js.yml
+++ b/.github/workflows/js.yml
@@ -47,7 +47,7 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Setup Python
@@ -87,7 +87,7 @@ jobs:
         node: [18]
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Jest Cache
@@ -117,7 +117,7 @@ jobs:
         node: [18]
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Jest Cache
diff --git a/.github/workflows/matlab.yml b/.github/workflows/matlab.yml
index 427bb813fdbe9..221ed5c77cd47 100644
--- a/.github/workflows/matlab.yml
+++ b/.github/workflows/matlab.yml
@@ -46,7 +46,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install ninja-build
@@ -92,7 +92,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install ninja-build
@@ -130,7 +130,7 @@ jobs:
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     steps:
       - name: Check out repository        
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Install MATLAB
diff --git a/.github/workflows/pr_bot.yml b/.github/workflows/pr_bot.yml
index 9d0d7ec88b857..617f3f2e017a3 100644
--- a/.github/workflows/pr_bot.yml
+++ b/.github/workflows/pr_bot.yml
@@ -73,7 +73,7 @@ jobs:
           curl -sL -o committers.yml $url
           echo "committers_path=$(pwd)/committers.yml" >> $GITHUB_OUTPUT
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: arrow
           repository: apache/arrow
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 76f76411b6e11..7a8fd8d10c235 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -89,7 +89,7 @@ jobs:
       NUMPY: ${{ matrix.numpy || 'latest' }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -156,7 +156,7 @@ jobs:
       MACOSX_DEPLOYMENT_TARGET: 10.15
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml
index 3e3a4f856e4c5..a8680aea56d48 100644
--- a/.github/workflows/r.yml
+++ b/.github/workflows/r.yml
@@ -68,7 +68,7 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -139,7 +139,7 @@ jobs:
       DEVTOOLSET_VERSION: ${{ matrix.config.devtoolset }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -197,7 +197,7 @@ jobs:
     steps:
       - run: git config --global core.autocrlf false
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Setup ccache
@@ -250,7 +250,7 @@ jobs:
     steps:
       - run: git config --global core.autocrlf false
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - run: mkdir r/windows
diff --git a/.github/workflows/r_nightly.yml b/.github/workflows/r_nightly.yml
index 0b16c16e9430d..7f21d4658e007 100644
--- a/.github/workflows/r_nightly.yml
+++ b/.github/workflows/r_nightly.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 1
           path: arrow
@@ -53,7 +53,7 @@ jobs:
           ref: main
           submodules: recursive
       - name: Checkout Crossbow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           path: crossbow
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index 33f0c5b89c139..2e4b98c2428e9 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -71,7 +71,7 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -142,7 +142,7 @@ jobs:
       XML_CATALOG_FILES: /usr/local/etc/xml/catalog
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
@@ -245,7 +245,7 @@ jobs:
             /d 1 `
             /f
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
index b2ee3f0b3cab3..825921ac6fa24 100644
--- a/.github/workflows/swift.yml
+++ b/.github/workflows/swift.yml
@@ -51,7 +51,7 @@ jobs:
     timeout-minutes: 15
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
           submodules: recursive
diff --git a/dev/tasks/docs/github.linux.yml b/dev/tasks/docs/github.linux.yml
index 6de297b663e01..8ab8a593c3ef3 100644
--- a/dev/tasks/docs/github.linux.yml
+++ b/dev/tasks/docs/github.linux.yml
@@ -40,7 +40,7 @@ jobs:
             {{ image }} \
             {{ command|default("") }}
       - name: Checkout Crossbow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           ref: {{ default_branch|default("main") }}
           path: crossbow
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 8ec351a270c74..06b9390c0f974 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -27,7 +27,7 @@ on:
 
 {%- macro github_checkout_arrow(fetch_depth=1, submodules="recursive") -%}
   - name: Checkout Arrow
-    uses: actions/checkout@v3
+    uses: actions/checkout@v4
     with:
       fetch-depth: {{ fetch_depth }}
       path: arrow
@@ -96,7 +96,7 @@ on:
         python3-pip
       sudo python3 -m pip install --upgrade pip
   - name: Checkout Crossbow
-    uses: actions/checkout@v3
+    uses: actions/checkout@v4
     with:
       path: crossbow
       ref: {{ job.branch }}

From a6d90608e6a081714f3ceb7bab9978f7d3526b79 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Mon, 4 Sep 2023 20:22:59 -0400
Subject: [PATCH 312/749] GH-37539: [C++][FlightRPC] Fix binding to IPv6
 addresses (#37552)

### Rationale for this change

Binding to an IPv6 address got broken along the way

### What changes are included in this PR?

Fix the binding and see if we can enable IPv6 testing in CI

### Are these changes tested?

If CI permits

### Are there any user-facing changes?

No
* Closes: #37539

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/flight/transport/grpc/grpc_server.cc | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
index 28c2090c95a9a..bbd01155fe4a4 100644
--- a/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
+++ b/cpp/src/arrow/flight/transport/grpc/grpc_server.cc
@@ -620,9 +620,13 @@ class GrpcServerTransport : public internal::ServerTransport {
     }
 
     if (scheme == kSchemeGrpcTls) {
-      ARROW_ASSIGN_OR_RAISE(location_, Location::ForGrpcTls(uri.host(), port));
+      ARROW_ASSIGN_OR_RAISE(
+          location_,
+          Location::ForGrpcTls(arrow::internal::UriEncodeHost(uri.host()), port));
     } else if (scheme == kSchemeGrpc || scheme == kSchemeGrpcTcp) {
-      ARROW_ASSIGN_OR_RAISE(location_, Location::ForGrpcTcp(uri.host(), port));
+      ARROW_ASSIGN_OR_RAISE(
+          location_,
+          Location::ForGrpcTcp(arrow::internal::UriEncodeHost(uri.host()), port));
     }
     return Status::OK();
   }

From f6d9e6bcafd92d5091ba04412ed6ebc22d978bd3 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Tue, 5 Sep 2023 01:55:26 +0100
Subject: [PATCH 313/749] MINOR: [R][CI] Add previous version of package to CI
 backwards comaptibility job (#37534)

### Rationale for this change

Add previous version of R package to backward compatibility job so we can ensure we don't make breaking changes

### What changes are included in this PR?

Add 12.0.1.1 to CI job

### Are these changes tested?

No
### Are there any user-facing changes?

No

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/tasks/r/github.linux.arrow.version.back.compat.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dev/tasks/r/github.linux.arrow.version.back.compat.yml b/dev/tasks/r/github.linux.arrow.version.back.compat.yml
index df4f7771adc94..804f0d2127059 100644
--- a/dev/tasks/r/github.linux.arrow.version.back.compat.yml
+++ b/dev/tasks/r/github.linux.arrow.version.back.compat.yml
@@ -73,6 +73,7 @@ jobs:
         config:
         # We use the R version that was released at the time of the arrow release in order
         # to make sure we can download binaries from RSPM.
+        - { old_arrow_version: '12.0.1.1', r: '4.3' }
         - { old_arrow_version: '11.0.0.3', r: '4.2' }
         - { old_arrow_version: '10.0.1', r: '4.2' }
         - { old_arrow_version: '9.0.0', r: '4.2' }

From 7dd862421e8466c1a131dd11a9ab79bbd0c3a16a Mon Sep 17 00:00:00 2001
From: takuya kodama <a.s.takuya1026@gmail.com>
Date: Tue, 5 Sep 2023 09:36:36 +0800
Subject: [PATCH 314/749] GH-33749: [Ruby] Add
 Arrow::RecordBatch#each_raw_record (#37137)

### Rationale for this change

This change allows for efficient iteration over large datasets, particularly those utilizing the Apache Parquet format.

### What changes are included in this PR?

- Add the following methods to make the raw_records method iterable.
  - Arrow::RecordBatch#each_raw_record
  - Arrow::Table#each_raw_record
- Add related test

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

This PR is related to  #33749
* Closes: #33749

Lead-authored-by: otegami <a.s.takuya1026@gmail.com>
Co-authored-by: takuya kodama <a.s.takuya1026@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ruby/red-arrow/ext/arrow/arrow.cpp            |   6 +
 ruby/red-arrow/ext/arrow/raw-records.cpp      | 152 ++++
 ruby/red-arrow/ext/arrow/red-arrow.hpp        |   2 +
 .../test/each-raw-record/test-basic-arrays.rb | 531 ++++++++++++
 .../each-raw-record/test-dense-union-array.rb | 706 ++++++++++++++++
 .../each-raw-record/test-dictionary-array.rb  | 457 +++++++++++
 .../test/each-raw-record/test-list-array.rb   | 771 ++++++++++++++++++
 .../test/each-raw-record/test-map-array.rb    | 647 +++++++++++++++
 .../each-raw-record/test-multiple-columns.rb  |  80 ++
 .../test-sparse-union-array.rb                | 662 +++++++++++++++
 .../test/each-raw-record/test-struct-array.rb | 669 +++++++++++++++
 .../test/each-raw-record/test-table.rb        |  51 ++
 .../test/raw-records/test-basic-arrays.rb     |   2 +-
 13 files changed, 4735 insertions(+), 1 deletion(-)
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-list-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-map-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-struct-array.rb
 create mode 100644 ruby/red-arrow/test/each-raw-record/test-table.rb

diff --git a/ruby/red-arrow/ext/arrow/arrow.cpp b/ruby/red-arrow/ext/arrow/arrow.cpp
index 8eb3b610090b5..404ec8996f232 100644
--- a/ruby/red-arrow/ext/arrow/arrow.cpp
+++ b/ruby/red-arrow/ext/arrow/arrow.cpp
@@ -82,11 +82,17 @@ extern "C" void Init_arrow() {
   rb_define_method(cArrowRecordBatch, "raw_records",
                    reinterpret_cast<rb::RawMethod>(red_arrow::record_batch_raw_records),
                    0);
+  rb_define_method(cArrowRecordBatch, "each_raw_record",
+                   reinterpret_cast<rb::RawMethod>(red_arrow::record_batch_each_raw_record),
+                   0);
 
   auto cArrowTable = rb_const_get_at(mArrow, rb_intern("Table"));
   rb_define_method(cArrowTable, "raw_records",
                    reinterpret_cast<rb::RawMethod>(red_arrow::table_raw_records),
                    0);
+  rb_define_method(cArrowTable, "each_raw_record",
+                   reinterpret_cast<rb::RawMethod>(red_arrow::table_each_raw_record),
+                   0);
 
   red_arrow::cDate = rb_const_get(rb_cObject, rb_intern("Date"));
 
diff --git a/ruby/red-arrow/ext/arrow/raw-records.cpp b/ruby/red-arrow/ext/arrow/raw-records.cpp
index e0326f9d2fdb7..0043ca3aaf2cc 100644
--- a/ruby/red-arrow/ext/arrow/raw-records.cpp
+++ b/ruby/red-arrow/ext/arrow/raw-records.cpp
@@ -144,6 +144,128 @@ namespace red_arrow {
       // The number of columns.
       const int n_columns_;
     };
+
+    class RawRecordsProducer : private Converter, public arrow::ArrayVisitor {
+    public:
+      explicit RawRecordsProducer()
+        : Converter(),
+          record_(Qnil),
+          column_index_(0),
+          row_offset_(0) {
+      }
+
+      void produce(const arrow::RecordBatch& record_batch) {
+        rb::protect([&] {
+          const auto n_columns = record_batch.num_columns();
+          const auto n_rows = record_batch.num_rows();
+          for (int64_t i = 0; i < n_rows; ++i) {
+            record_ = rb_ary_new_capa(n_columns);
+            row_offset_ = i;
+            for (int i = 0; i < n_columns; ++i) {
+              const auto array = record_batch.column(i).get();
+              column_index_ = i;
+              check_status(array->Accept(this),
+                           "[record-batch][each-raw-record]");
+            }
+            rb_yield(record_);
+          }
+          return Qnil;
+        });
+      }
+
+      void produce(const arrow::Table& table) {
+        rb::protect([&] {
+          const auto n_columns = table.num_columns();
+          const auto n_rows = table.num_rows();
+          std::vector<int> chunk_indexes(n_columns);
+          std::vector<int64_t> row_offsets(n_columns);
+          for (int64_t i_row = 0; i_row < n_rows; ++i_row) {
+            record_ = rb_ary_new_capa(n_columns);
+            for (int i_column = 0; i_column < n_columns; ++i_column) {
+              column_index_ = i_column;
+              const auto chunked_array = table.column(i_column).get();
+              auto& chunk_index = chunk_indexes[i_column];
+              auto& row_offset = row_offsets[i_column];
+              auto array = chunked_array->chunk(chunk_index).get();
+              while (array->length() == row_offset) {
+                ++chunk_index;
+                row_offset = 0;
+                array = chunked_array->chunk(chunk_index).get();
+              }
+              row_offset_ = row_offset;
+              check_status(array->Accept(this),
+                           "[table][each-raw-record]");
+              ++row_offset;
+            }
+            rb_yield(record_);
+          }
+
+          return Qnil;
+        });
+      }
+
+#define VISIT(TYPE)                                                     \
+      arrow::Status Visit(const arrow::TYPE ## Array& array) override { \
+        convert(array);                                                 \
+        return arrow::Status::OK();                                     \
+      }
+
+      VISIT(Null)
+      VISIT(Boolean)
+      VISIT(Int8)
+      VISIT(Int16)
+      VISIT(Int32)
+      VISIT(Int64)
+      VISIT(UInt8)
+      VISIT(UInt16)
+      VISIT(UInt32)
+      VISIT(UInt64)
+      VISIT(HalfFloat)
+      VISIT(Float)
+      VISIT(Double)
+      VISIT(Binary)
+      VISIT(String)
+      VISIT(FixedSizeBinary)
+      VISIT(Date32)
+      VISIT(Date64)
+      VISIT(Time32)
+      VISIT(Time64)
+      VISIT(Timestamp)
+      VISIT(MonthInterval)
+      VISIT(DayTimeInterval)
+      VISIT(MonthDayNanoInterval)
+      VISIT(List)
+      VISIT(Struct)
+      VISIT(Map)
+      VISIT(SparseUnion)
+      VISIT(DenseUnion)
+      VISIT(Dictionary)
+      VISIT(Decimal128)
+      VISIT(Decimal256)
+      // TODO
+      // VISIT(Extension)
+
+#undef VISIT
+
+    private:
+        template <typename ArrayType>
+        void convert(const ArrayType& array) {
+          auto value = Qnil;
+          if (!array.IsNull(row_offset_)) {
+            value = convert_value(array, row_offset_);
+          }
+          rb_ary_store(record_, column_index_, value);
+        }
+
+        // Destination for converted record.
+        VALUE record_;
+
+        // The current column index.
+        int column_index_;
+
+        // The current row offset.
+        int64_t row_offset_;
+    };
   }
 
   VALUE
@@ -181,4 +303,34 @@ namespace red_arrow {
 
     return records;
   }
+
+  VALUE
+  record_batch_each_raw_record(VALUE rb_record_batch){
+    auto garrow_record_batch = GARROW_RECORD_BATCH(RVAL2GOBJ(rb_record_batch));
+    auto record_batch = garrow_record_batch_get_raw(garrow_record_batch).get();
+
+    try {
+      RawRecordsProducer producer;
+      producer.produce(*record_batch);
+    } catch (rb::State& state) {
+      state.jump();
+    }
+
+    return Qnil;
+  }
+
+  VALUE
+  table_each_raw_record(VALUE rb_table) {
+    auto garrow_table = GARROW_TABLE(RVAL2GOBJ(rb_table));
+    auto table = garrow_table_get_raw(garrow_table).get();
+
+    try {
+      RawRecordsProducer producer;
+      producer.produce(*table);
+    } catch (rb::State& state) {
+      state.jump();
+    }
+
+    return Qnil;
+  }
 }
diff --git a/ruby/red-arrow/ext/arrow/red-arrow.hpp b/ruby/red-arrow/ext/arrow/red-arrow.hpp
index ba578076a7e39..ffc24f9844bb0 100644
--- a/ruby/red-arrow/ext/arrow/red-arrow.hpp
+++ b/ruby/red-arrow/ext/arrow/red-arrow.hpp
@@ -59,6 +59,8 @@ namespace red_arrow {
 
   VALUE record_batch_raw_records(VALUE obj);
   VALUE table_raw_records(VALUE obj);
+  VALUE record_batch_each_raw_record(VALUE obj);
+  VALUE table_each_raw_record(VALUE obj);
 
   inline VALUE time_unit_to_scale(const arrow::TimeUnit::type unit) {
     switch (unit) {
diff --git a/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb b/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
new file mode 100644
index 0000000000000..dbbbd79ee0acb
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
@@ -0,0 +1,531 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordBasicArraysTests
+  def test_null
+    records = [
+      [nil],
+      [nil],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({column: :null}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [true],
+      [nil],
+      [false],
+    ]
+    iterated_records = []
+    target = build({column: :boolean}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [-(2 ** 7)],
+      [nil],
+      [(2 ** 7) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :int8}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [0],
+      [nil],
+      [(2 ** 8) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :uint8}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [-(2 ** 15)],
+      [nil],
+      [(2 ** 15) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :int16}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [0],
+      [nil],
+      [(2 ** 16) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :uint16}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [-(2 ** 31)],
+      [nil],
+      [(2 ** 31) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :int32}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [0],
+      [nil],
+      [(2 ** 32) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :uint32}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [-(2 ** 63)],
+      [nil],
+      [(2 ** 63) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :int64}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [0],
+      [nil],
+      [(2 ** 64) - 1],
+    ]
+    iterated_records = []
+    target = build({column: :uint64}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_half_float
+    records = [
+      [-1.5],
+      [nil],
+      [1.5],
+    ]
+    iterated_records = []
+    target = build({column: :half_float}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_float
+    records = [
+      [-1.0],
+      [nil],
+      [1.0],
+    ]
+    iterated_records = []
+    target = build({column: :float}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_double
+    records = [
+      [-1.0],
+      [nil],
+      [1.0],
+    ]
+    iterated_records = []
+    target = build({column: :double}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_binary
+    records = [
+      ["\x00".b],
+      [nil],
+      ["\xff".b],
+    ]
+    iterated_records = []
+    target = build({column: :binary}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_string
+    records = [
+      ["Ruby"],
+      [nil],
+      ["\u3042"], # U+3042 HIRAGANA LETTER A
+    ]
+    iterated_records = []
+    target = build({column: :string}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [Date.new(1960, 1, 1)],
+      [nil],
+      [Date.new(2017, 8, 23)],
+    ]
+    iterated_records = []
+    target = build({column: :date32}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [DateTime.new(1960, 1, 1, 2, 9, 30)],
+      [nil],
+      [DateTime.new(2017, 8, 23, 14, 57, 2)],
+    ]
+    iterated_records = []
+    target = build({column: :date64}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [Time.parse("1960-01-01T02:09:30Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02Z")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :timestamp,
+                       unit: :second,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987Z")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :timestamp,
+                       unit: :milli,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123456Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987654Z")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :timestamp,
+                       unit: :micro,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123456789Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987654321Z")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :timestamp,
+                       unit: :nano,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      [Arrow::Time.new(unit, 60 * 10)], # 00:10:00
+      [nil],
+      [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :time32,
+                       unit: :second,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      [Arrow::Time.new(unit, (60 * 10) * 1000 + 123)], # 00:10:00.123
+      [nil],
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :time32,
+                       unit: :milli,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)],
+      [nil],
+      # 02:00:09.987654
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :time64,
+                       unit: :micro,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)],
+      [nil],
+      # 02:00:09.987654321
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :time64,
+                       unit: :nano,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [BigDecimal("92.92")],
+      [nil],
+      [BigDecimal("29.29")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :decimal128,
+                       precision: 8,
+                       scale: 2,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [BigDecimal("92.92")],
+      [nil],
+      [BigDecimal("29.29")],
+    ]
+    iterated_records = []
+    target = build({
+                     column: {
+                       type: :decimal256,
+                       precision: 38,
+                       scale: 2,
+                     }
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [1],
+      [nil],
+      [12],
+    ]
+    iterated_records = []
+    target = build({column: :month_interval}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{day: 1, millisecond: 100}],
+      [nil],
+      [{day: 2, millisecond: 300}],
+    ]
+    iterated_records = []
+    target = build({column: :day_time_interval}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{month: 1, day: 1, nanosecond: 100}],
+      [nil],
+      [{month: 2, day: 3, nanosecond: 400}],
+    ]
+    iterated_records = []
+    target = build({column: :month_day_nano_interval}, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchBasicArraysTest< Test::Unit::TestCase
+  include EachRawRecordBasicArraysTests
+
+  def build(schema, records)
+    Arrow::RecordBatch.new(schema, records)
+  end
+end
+
+class EachRawRecordTableBasicArraysTest < Test::Unit::TestCase
+  include EachRawRecordBasicArraysTests
+
+  def build(schema, records)
+    record_batch = Arrow::RecordBatch.new(schema, records)
+    # Multiple chunks
+    record_batches = [
+      record_batch.slice(0, 2),
+      record_batch.slice(2, 0), # Empty chunk
+      record_batch.slice(2, record_batch.length - 2),
+    ]
+    Arrow::Table.new(schema, record_batches)
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb b/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
new file mode 100644
index 0000000000000..7c784cccde3a1
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
@@ -0,0 +1,706 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordDenseUnionArrayTests
+  def build_schema(type, type_codes)
+    field_description = {}
+    if type.is_a?(Hash)
+      field_description = field_description.merge(type)
+    else
+      field_description[:type] = type
+    end
+    {
+      column: {
+        type: :dense_union,
+        fields: [
+          field_description.merge(name: "0"),
+          field_description.merge(name: "1"),
+        ],
+        type_codes: type_codes,
+      },
+    }
+  end
+
+  # TODO: Use Arrow::RecordBatch.new(build_schema(type, type_codes), records)
+  def build_record_batch(type, records)
+    type_codes = [0, 1]
+    schema = Arrow::Schema.new(build_schema(type, type_codes))
+    type_ids = []
+    offsets = []
+    arrays = schema.fields[0].data_type.fields.collect do |field|
+      sub_schema = Arrow::Schema.new([field])
+      sub_records = []
+      records.each do |record|
+        column = record[0]
+        next if column.nil?
+        next unless column.key?(field.name)
+        sub_records << [column[field.name]]
+      end
+      sub_record_batch = Arrow::RecordBatch.new(sub_schema,
+                                                sub_records)
+      sub_record_batch.columns[0].data
+    end
+    records.each do |record|
+      column = record[0]
+      if column.key?("0")
+        type_id = type_codes[0]
+        type_ids << type_id
+        offsets << (type_ids.count(type_id) - 1)
+      elsif column.key?("1")
+        type_id = type_codes[1]
+        type_ids << type_id
+        offsets << (type_ids.count(type_id) - 1)
+      end
+    end
+    union_array = Arrow::DenseUnionArray.new(schema.fields[0].data_type,
+                                             Arrow::Int8Array.new(type_ids),
+                                             Arrow::Int32Array.new(offsets),
+                                             arrays)
+    schema = Arrow::Schema.new(column: union_array.value_data_type)
+    Arrow::RecordBatch.new(schema,
+                           records.size,
+                           [union_array])
+  end
+
+  def remove_field_names(records)
+    records.collect do |record|
+      record.collect do |column|
+        if column.nil?
+          column
+        else
+          column.values[0]
+        end
+      end
+    end
+  end
+
+  def test_null
+    records = [
+      [{"0" => nil}],
+    ]
+    iterated_records = []
+    target = build(:null, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [{"0" => true}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:boolean, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [{"0" => -(2 ** 7)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [{"0" => (2 ** 8) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [{"0" => -(2 ** 15)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [{"0" => (2 ** 16) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [{"0" => -(2 ** 31)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [{"0" => (2 ** 32) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [{"0" => -(2 ** 63)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [{"0" => (2 ** 64) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_float
+    records = [
+      [{"0" => -1.0}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:float, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_double
+    records = [
+      [{"0" => -1.0}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:double, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_binary
+    records = [
+      [{"0" => "\xff".b}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:binary, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_string
+    records = [
+      [{"0" => "Ruby"}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:string, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [{"0" => Date.new(1960, 1, 1)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 target.raw_records)
+  end
+
+  def test_date64
+    records = [
+      [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      # 00:10:00
+      [{"0" => Arrow::Time.new(unit, 60 * 10)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      # 00:10:00.123
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [{"0" => BigDecimal("92.92")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal128,
+                     precision: 8,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [{"0" => BigDecimal("92.92")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [{"0" => 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"0" => {day: 1, millisecond: 100}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:day_time_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"0" => {month: 1, day: 1, nanosecond: 100}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_day_nano_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_list
+    records = [
+      [{"0" => [true, nil, false]}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :list,
+                     field: {
+                       name: :sub_element,
+                       type: :boolean,
+                     },
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_struct
+    records = [
+      [{"0" => {"sub_field" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"sub_field" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :struct,
+                     fields: [
+                       {
+                         name: :sub_field,
+                         type: :boolean,
+                       },
+                     ],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_map
+    records = [
+      [{"0" => {"key1" => true, "key2" => nil}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+
+  def test_sparse_union
+    records = [
+      [{"0" => {"field1" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"field2" => 29}}],
+      [{"0" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :sparse_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(remove_field_names(records)),
+                 iterated_records)
+  end
+
+  def test_dense_union
+    records = [
+      [{"0" => {"field1" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"field2" => 29}}],
+      [{"0" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dense_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(remove_field_names(records)),
+                 iterated_records)
+  end
+
+  def test_dictionary
+    records = [
+      [{"0" => "Ruby"}],
+      [{"1" => nil}],
+      [{"0" => "GLib"}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dictionary,
+                     index_data_type: :int8,
+                     value_data_type: :string,
+                     ordered: false,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records),
+                 iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchDenseUnionArrayTest < Test::Unit::TestCase
+  include EachRawRecordDenseUnionArrayTests
+
+  def build(type, records)
+    build_record_batch(type, records)
+  end
+end
+
+class EachRawRecordTableDenseUnionArrayTest < Test::Unit::TestCase
+  include EachRawRecordDenseUnionArrayTests
+
+  def build(type, records)
+    build_record_batch(type, records).to_table
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb b/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
new file mode 100644
index 0000000000000..edc6c33cc091d
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
@@ -0,0 +1,457 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordDictionaryArrayTests
+  def build_record_batch(array)
+    dictionary = array.dictionary_encode
+    schema = Arrow::Schema.new(column: dictionary.value_data_type)
+    Arrow::RecordBatch.new(schema, array.length, [dictionary])
+  end
+
+  def test_null
+    records = [
+      [nil],
+      [nil],
+      [nil],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(Arrow::NullArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [true],
+      [nil],
+      [false],
+    ]
+    iterated_records = []
+    target = build(Arrow::BooleanArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [-(2 ** 7)],
+      [nil],
+      [(2 ** 7) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::Int8Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [0],
+      [nil],
+      [(2 ** 8) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::UInt8Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [-(2 ** 15)],
+      [nil],
+      [(2 ** 15) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::Int16Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [0],
+      [nil],
+      [(2 ** 16) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::UInt16Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [-(2 ** 31)],
+      [nil],
+      [(2 ** 31) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::Int32Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [0],
+      [nil],
+      [(2 ** 32) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::UInt32Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [-(2 ** 63)],
+      [nil],
+      [(2 ** 63) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::Int64Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [0],
+      [nil],
+      [(2 ** 64) - 1],
+    ]
+    iterated_records = []
+    target = build(Arrow::UInt64Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_float
+    records = [
+      [-1.0],
+      [nil],
+      [1.0],
+    ]
+    iterated_records = []
+    target = build(Arrow::FloatArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_double
+    records = [
+      [-1.0],
+      [nil],
+      [1.0],
+    ]
+    iterated_records = []
+    target = build(Arrow::DoubleArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_binary
+    records = [
+      ["\x00".b],
+      [nil],
+      ["\xff".b],
+    ]
+    iterated_records = []
+    target = build(Arrow::BinaryArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_string
+    records = [
+      ["Ruby"],
+      [nil],
+      ["\u3042"], # U+3042 HIRAGANA LETTER A
+    ]
+    iterated_records = []
+    target = build(Arrow::StringArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [Date.new(1960, 1, 1)],
+      [nil],
+      [Date.new(2017, 8, 23)],
+    ]
+    iterated_records = []
+    target = build(Arrow::Date32Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [DateTime.new(1960, 1, 1, 2, 9, 30)],
+      [nil],
+      [DateTime.new(2017, 8, 23, 14, 57, 2)],
+    ]
+    iterated_records = []
+    target = build(Arrow::Date64Array.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [Time.parse("1960-01-01T02:09:30Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02Z")],
+    ]
+    iterated_records = []
+    target = build(Arrow::TimestampArray.new(:second, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987Z")],
+    ]
+    iterated_records = []
+    target = build(Arrow::TimestampArray.new(:milli, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123456Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987654Z")],
+    ]
+    iterated_records = []
+    target = build(Arrow::TimestampArray.new(:micro, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [Time.parse("1960-01-01T02:09:30.123456789Z")],
+      [nil],
+      [Time.parse("2017-08-23T14:57:02.987654321Z")],
+    ]
+    iterated_records = []
+    target = build(Arrow::TimestampArray.new(:nano, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      [Arrow::Time.new(unit, 60 * 10)], # 00:10:00
+      [nil],
+      [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
+    ]
+    iterated_records = []
+    target = build(Arrow::Time32Array.new(unit, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      [Arrow::Time.new(unit, (60 * 10) * 1000 + 123)], # 00:10:00.123
+      [nil],
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
+    ]
+    iterated_records = []
+    target = build(Arrow::Time32Array.new(unit, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)],
+      [nil],
+      # 02:00:09.987654
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
+    ]
+    iterated_records = []
+    target = build(Arrow::Time64Array.new(unit, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)],
+      [nil],
+      # 02:00:09.987654321
+      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
+    ]
+    iterated_records = []
+    target = build(Arrow::Time64Array.new(unit, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [BigDecimal("92.92")],
+      [nil],
+      [BigDecimal("29.29")],
+    ]
+    iterated_records = []
+    data_type = Arrow::Decimal128DataType.new(8, 2)
+    target = build(Arrow::Decimal128Array.new(data_type, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [BigDecimal("92.92")],
+      [nil],
+      [BigDecimal("29.29")],
+    ]
+    iterated_records = []
+    data_type = Arrow::Decimal256DataType.new(38, 2)
+    target = build(Arrow::Decimal256Array.new(data_type, records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, target.raw_records)
+  end
+
+  def test_month_interval
+    records = [
+      [1],
+      [nil],
+      [12],
+    ]
+    iterated_records = []
+    target = build(Arrow::MonthIntervalArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{day: 1, millisecond: 100}],
+      [nil],
+      [{day: 2, millisecond: 300}],
+    ]
+    iterated_records = []
+    target = build(Arrow::DayTimeIntervalArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{month: 1, day: 1, nanosecond: 100}],
+      [nil],
+      [{month: 2, day: 3, nanosecond: 400}],
+    ]
+    iterated_records = []
+    target = build(Arrow::MonthDayNanoIntervalArray.new(records.collect(&:first)))
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchDictionaryArraysTest < Test::Unit::TestCase
+  include EachRawRecordDictionaryArrayTests
+
+  def build(array)
+    build_record_batch(array)
+  end
+end
+
+class EachRawRecordTableDictionaryArraysTest < Test::Unit::TestCase
+  include EachRawRecordDictionaryArrayTests
+
+  def build(array)
+    build_record_batch(array).to_table
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-list-array.rb b/ruby/red-arrow/test/each-raw-record/test-list-array.rb
new file mode 100644
index 0000000000000..64cc5839bd757
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-list-array.rb
@@ -0,0 +1,771 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordListArrayTests
+  def build_schema(type)
+    field_description = {
+      name: :element,
+    }
+    if type.is_a?(Hash)
+      field_description = field_description.merge(type)
+    else
+      field_description[:type] = type
+    end
+    {
+      column: {
+        type: :list,
+        field: field_description,
+      },
+    }
+  end
+
+  def test_null
+    records = [
+      [[nil, nil, nil]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:null, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [[true, nil, false]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:boolean, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [[-(2 ** 7), nil, (2 ** 7) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [[0, nil, (2 ** 8) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [[-(2 ** 15), nil, (2 ** 15) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [[0, nil, (2 ** 16) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [[-(2 ** 31), nil, (2 ** 31) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [[0, nil, (2 ** 32) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [[-(2 ** 63), nil, (2 ** 63) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [[0, nil, (2 ** 64) - 1]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_float
+    records = [
+      [[-1.0, nil, 1.0]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:float, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_double
+    records = [
+      [[-1.0, nil, 1.0]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:double, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_binary
+    records = [
+      [["\x00".b, nil, "\xff".b]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:binary, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_string
+    records = [
+      [
+        [
+          "Ruby",
+          nil,
+          "\u3042", # U+3042 HIRAGANA LETTER A
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:string, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [
+        [
+          Date.new(1960, 1, 1),
+          nil,
+          Date.new(2017, 8, 23),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:date32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [
+        [
+          DateTime.new(1960, 1, 1, 2, 9, 30),
+          nil,
+          DateTime.new(2017, 8, 23, 14, 57, 2),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:date64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [
+        [
+          Time.parse("1960-01-01T02:09:30Z"),
+          nil,
+          Time.parse("2017-08-23T14:57:02Z"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :second,
+                   },
+                   records)
+    iterated_records = []
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [
+        [
+          Time.parse("1960-01-01T02:09:30.123Z"),
+          nil,
+          Time.parse("2017-08-23T14:57:02.987Z"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :milli,
+                   },
+                   records)
+    iterated_records = []
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [
+        [
+          Time.parse("1960-01-01T02:09:30.123456Z"),
+          nil,
+          Time.parse("2017-08-23T14:57:02.987654Z"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :micro,
+                   },
+                   records)
+    iterated_records = []
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [
+        [
+          Time.parse("1960-01-01T02:09:30.123456789Z"),
+          nil,
+          Time.parse("2017-08-23T14:57:02.987654321Z"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      [
+        [
+          # 00:10:00
+          Arrow::Time.new(unit, 60 * 10),
+          nil,
+          # 02:00:09
+          Arrow::Time.new(unit, 60 * 60 * 2 + 9),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      [
+        [
+          # 00:10:00.123
+          Arrow::Time.new(unit, (60 * 10) * 1000 + 123),
+          nil,
+          # 02:00:09.987
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      [
+        [
+          # 00:10:00.123456
+          Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456),
+          nil,
+          # 02:00:09.987654
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      [
+        [
+          # 00:10:00.123456789
+          Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789),
+          nil,
+          # 02:00:09.987654321
+          Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [
+        [
+          BigDecimal("92.92"),
+          nil,
+          BigDecimal("29.29"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal128,
+                     precision: 8,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [
+        [
+          BigDecimal("92.92"),
+          nil,
+          BigDecimal("29.29"),
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [[1, nil, 12]],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:month_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [
+        [
+          {day: 1, millisecond: 100},
+          nil,
+          {day: 2, millisecond: 300},
+        ]
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:day_time_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [
+        [
+          {month: 1, day: 1, nanosecond: 100},
+          nil,
+          {month: 2, day: 3, nanosecond: 400},
+        ]
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:month_day_nano_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_list
+    records = [
+      [
+        [
+          [
+            true,
+            nil,
+          ],
+          nil,
+          [
+            nil,
+            false,
+          ],
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :list,
+                     field: {
+                       name: :sub_element,
+                       type: :boolean,
+                     },
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_struct
+    records = [
+      [
+        [
+          {"field" => true},
+          nil,
+          {"field" => nil},
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :struct,
+                     fields: [
+                       {
+                         name: :field,
+                         type: :boolean,
+                       },
+                     ],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_map
+    records = [
+      [
+        [
+          {"key1" => true, "key2" => nil},
+          nil,
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def remove_union_field_names(records)
+    records.collect do |record|
+      record.collect do |column|
+        if column.nil?
+          column
+        else
+          column.collect do |value|
+            if value.nil?
+              value
+            else
+              value.values[0]
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_sparse_union
+    records = [
+      [
+        [
+          {"field1" => true},
+          nil,
+          {"field2" => 29},
+          {"field2" => nil},
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :sparse_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 iterated_records)
+  end
+
+  def test_dense_union
+    records = [
+      [
+        [
+          {"field1" => true},
+          nil,
+          {"field2" => 29},
+          {"field2" => nil},
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dense_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 iterated_records)
+  end
+
+  def test_dictionary
+    records = [
+      [
+        [
+          "Ruby",
+          nil,
+          "GLib",
+        ],
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dictionary,
+                     index_data_type: :int8,
+                     value_data_type: :string,
+                     ordered: false,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchListArrayTest < Test::Unit::TestCase
+  include EachRawRecordListArrayTests
+
+  def build(type, records)
+    Arrow::RecordBatch.new(build_schema(type), records)
+  end
+end
+
+class EachRawRecordTableListArrayTest < Test::Unit::TestCase
+  include EachRawRecordListArrayTests
+
+  def build(type, records)
+    Arrow::Table.new(build_schema(type), records)
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-map-array.rb b/ruby/red-arrow/test/each-raw-record/test-map-array.rb
new file mode 100644
index 0000000000000..b802275a7f00f
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-map-array.rb
@@ -0,0 +1,647 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordMapArrayTests
+  def build_schema(type)
+    {
+      column: {
+        type: :map,
+        key: :string,
+        item: type
+      },
+    }
+  end
+
+  def test_null
+    records = [
+      [{"key1" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:null, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [{"key1" => true, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:boolean, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [{"key1" => -(2 ** 7), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [{"key1" => (2 ** 8) - 1, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [{"key1" => -(2 ** 15), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [{"key1" => (2 ** 16) - 1, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [{"key1" => -(2 ** 31), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [{"key1" => (2 ** 32) - 1, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [{"key1" => -(2 ** 63), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:int64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [{"key1" => (2 ** 64) - 1, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:uint64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_float
+    records = [
+      [{"key1" => -1.0, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:float, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_double
+    records = [
+      [{"key1" => -1.0, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:double, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_binary
+    records = [
+      [{"key1" => "\xff".b, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:binary, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_string
+    records = [
+      [{"key1" => "Ruby", "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:string, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [{"key1" => Date.new(1960, 1, 1), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:date32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [{"key1" => DateTime.new(1960, 1, 1, 2, 9, 30), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:date64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [{"key1" => Time.parse("1960-01-01T02:09:30Z"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [{"key1" => Time.parse("1960-01-01T02:09:30.123Z"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [{"key1" => Time.parse("1960-01-01T02:09:30.123456Z"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [{"key1" => Time.parse("1960-01-01T02:09:30.123456789Z"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      # 00:10:00
+      [{"key1" => Arrow::Time.new(unit, 60 * 10), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      # 00:10:00.123
+      [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [{"key1" => BigDecimal("92.92"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal128,
+                     precision: 8,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [{"key1" => BigDecimal("92.92"), "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [{"key1" => 1, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:month_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [
+        {
+          "key1" => {day: 1, millisecond: 100},
+          "key2" => nil,
+        },
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:day_time_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [
+        {
+          "key1" => {month: 1, day: 1, nanosecond: 100},
+          "key2" => nil,
+        },
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:month_day_nano_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_list
+    records = [
+      [{"key1" => [true, nil, false], "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :list,
+                     field: {
+                       name: :element,
+                       type: :boolean,
+                     },
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_struct
+    records = [
+      [{"key1" => {"field" => true}, "key2" => nil, "key3" => {"field" => nil}}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :struct,
+                     fields: [
+                       {
+                         name: :field,
+                         type: :boolean,
+                       },
+                     ],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_map
+    records = [
+      [{"key1" => {"sub_key1" => true, "sub_key2" => nil}, "key2" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def remove_union_field_names(records)
+    records.collect do |record|
+      record.collect do |column|
+        if column.nil?
+          column
+        else
+          value = {}
+          column.each do |k, v|
+            v = v.values[0] unless v.nil?
+            value[k] = v
+          end
+          value
+        end
+      end
+    end
+  end
+
+  def test_sparse_union
+    records = [
+      [
+        {
+          "key1" => {"field1" => true},
+          "key2" => nil,
+          "key3" => {"field2" => 29},
+          "key4" => {"field2" => nil},
+        },
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :sparse_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 target.raw_records)
+  end
+
+  def test_dense_union
+    records = [
+      [
+        {
+          "key1" => {"field1" => true},
+          "key2" => nil,
+          "key3" => {"field2" => 29},
+          "key4" => {"field2" => nil},
+        },
+      ],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dense_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 target.raw_records)
+  end
+
+  def test_dictionary
+    records = [
+      [{"key1" => "Ruby", "key2" => nil, "key3" => "GLib"}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dictionary,
+                     index_data_type: :int8,
+                     value_data_type: :string,
+                     ordered: false,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchMapArrayTest < Test::Unit::TestCase
+  include EachRawRecordMapArrayTests
+
+  def build(type, records)
+    Arrow::RecordBatch.new(build_schema(type), records)
+  end
+end
+
+class EachRawRecordTableMapArrayTest < Test::Unit::TestCase
+  include EachRawRecordMapArrayTests
+
+  def build(type, records)
+    Arrow::Table.new(build_schema(type), records)
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb b/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
new file mode 100644
index 0000000000000..c0547d324d26d
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
@@ -0,0 +1,80 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordMultipleColumnsTests
+  def test_3_elements
+    records = [
+      [true, nil, "Ruby"],
+      [nil, 0, "GLib"],
+      [false, 2 ** 8 - 1, nil],
+    ]
+    iterated_records = []
+    target = build([
+                     {name: :column0, type: :boolean},
+                     {name: :column1, type: :uint8},
+                     {name: :column2, type: :string},
+                   ],
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_4_elements
+    records = [
+      [true, nil, "Ruby", -(2 ** 63)],
+      [nil, 0, "GLib", nil],
+      [false, 2 ** 8 - 1, nil, (2 ** 63) - 1],
+    ]
+    iterated_records = []
+    target = build([
+                     {name: :column0, type: :boolean},
+                     {name: :column1, type: :uint8},
+                     {name: :column2, type: :string},
+                     {name: :column3, type: :int64},
+                   ],
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchMultipleColumnsTest < Test::Unit::TestCase
+  include EachRawRecordMultipleColumnsTests
+
+  def build(schema, records)
+    Arrow::RecordBatch.new(schema, records)
+  end
+end
+
+class EachRawRecordTableMultipleColumnsTest < Test::Unit::TestCase
+  include EachRawRecordMultipleColumnsTests
+
+  def build(schema, records)
+    record_batch = Arrow::RecordBatch.new(schema, records)
+    record_batches = [
+      record_batch.slice(0, 2),
+      record_batch.slice(2, 0),
+      record_batch.slice(2, record_batch.length - 2),
+    ]
+
+    Arrow::Table.new(schema, record_batches)
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb b/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
new file mode 100644
index 0000000000000..4b1b941fb2079
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
@@ -0,0 +1,662 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordSparseUnionArrayTests
+  def build_schema(type, type_codes)
+    field_description = {}
+    if type.is_a?(Hash)
+      field_description = field_description.merge(type)
+    else
+      field_description[:type] = type
+    end
+    {
+      column: {
+        type: :sparse_union,
+        fields: [
+          field_description.merge(name: "0"),
+          field_description.merge(name: "1"),
+        ],
+        type_codes: type_codes,
+      },
+    }
+  end
+
+  # TODO: Use Arrow::RecordBatch.new(build_schema(type, type_codes), records)
+  def build_record_batch(type, records)
+    type_codes = [0, 1]
+    schema = Arrow::Schema.new(build_schema(type, type_codes))
+    type_ids = []
+    arrays = schema.fields[0].data_type.fields.collect do |field|
+      sub_schema = Arrow::Schema.new([field])
+      sub_records = records.collect do |record|
+        [record[0].nil? ? nil : record[0][field.name]]
+      end
+      sub_record_batch = Arrow::RecordBatch.new(sub_schema,
+                                                sub_records)
+      sub_record_batch.columns[0].data
+    end
+    records.each do |record|
+      column = record[0]
+      if column.key?("0")
+        type_ids << type_codes[0]
+      elsif column.key?("1")
+        type_ids << type_codes[1]
+      end
+    end
+    union_array = Arrow::SparseUnionArray.new(schema.fields[0].data_type,
+                                              Arrow::Int8Array.new(type_ids),
+                                              arrays)
+    schema = Arrow::Schema.new(column: union_array.value_data_type)
+    Arrow::RecordBatch.new(schema,
+                           records.size,
+                           [union_array])
+  end
+
+  def remove_field_names(records)
+    records.collect do |record|
+      record.collect do |column|
+        if column.nil?
+          column
+        else
+          column.values[0]
+        end
+      end
+    end
+  end
+
+  def test_null
+    records = [
+      [{"0" => nil}],
+    ]
+    iterated_records = []
+    target = build(:null, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [{"0" => true}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:boolean, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [{"0" => -(2 ** 7)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [{"0" => (2 ** 8) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [{"0" => -(2 ** 15)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [{"0" => (2 ** 16) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [{"0" => -(2 ** 31)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [{"0" => (2 ** 32) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [{"0" => -(2 ** 63)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [{"0" => (2 ** 64) - 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_float
+    records = [
+      [{"0" => -1.0}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:float, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_double
+    records = [
+      [{"0" => -1.0}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:double, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_binary
+    records = [
+      [{"0" => "\xff".b}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:binary, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_string
+    records = [
+      [{"0" => "Ruby"}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:string, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [{"0" => Date.new(1960, 1, 1)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+
+  end
+
+  def test_timestamp_micro
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      # 00:10:00
+      [{"0" => Arrow::Time.new(unit, 60 * 10)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      # 00:10:00.123
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [{"0" => BigDecimal("92.92")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal128,
+                     precision: 8,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [{"0" => BigDecimal("92.92")}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [{"0" => 1}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"0" => {day: 1, millisecond: 100}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:day_time_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"0" => {month: 1, day: 1, nanosecond: 100}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_day_nano_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_list
+    records = [
+      [{"0" => [true, nil, false]}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :list,
+                     field: {
+                       name: :sub_element,
+                       type: :boolean,
+                     },
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_struct
+    records = [
+      [{"0" => {"sub_field" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"sub_field" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :struct,
+                     fields: [
+                       {
+                         name: :sub_field,
+                         type: :boolean,
+                       },
+                     ],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_map
+    records = [
+      [{"0" => {"key1" => true, "key2" => nil}}],
+      [{"1" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+
+  def test_sparse_union
+    records = [
+      [{"0" => {"field1" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"field2" => 29}}],
+      [{"0" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :sparse_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(remove_field_names(records)), iterated_records)
+  end
+
+  def test_dense_union
+    records = [
+      [{"0" => {"field1" => true}}],
+      [{"1" => nil}],
+      [{"0" => {"field2" => 29}}],
+      [{"0" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dense_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(remove_field_names(records)), iterated_records)
+  end
+
+  def test_dictionary
+    records = [
+      [{"0" => "Ruby"}],
+      [{"1" => nil}],
+      [{"0" => "GLib"}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dictionary,
+                     index_data_type: :int8,
+                     value_data_type: :string,
+                     ordered: false,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_field_names(records), iterated_records)
+  end
+end
+
+class EachRawRecordRecordBatchSparseUnionArrayTest < Test::Unit::TestCase
+  include EachRawRecordSparseUnionArrayTests
+
+  def build(type, records)
+    build_record_batch(type, records)
+  end
+end
+
+class EachRawRecordTableSparseUnionArrayTest < Test::Unit::TestCase
+  include EachRawRecordSparseUnionArrayTests
+
+  def build(type, records)
+    build_record_batch(type, records).to_table
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-struct-array.rb b/ruby/red-arrow/test/each-raw-record/test-struct-array.rb
new file mode 100644
index 0000000000000..de6e78aaeef4c
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-struct-array.rb
@@ -0,0 +1,669 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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 EachRawRecordStructArrayTests
+  def build_schema(type)
+    field_description = {
+      name: :field,
+    }
+    if type.is_a?(Hash)
+      field_description = field_description.merge(type)
+    else
+      field_description[:type] = type
+    end
+    {
+      column: {
+        type: :struct,
+        fields: [
+          field_description,
+        ],
+      },
+    }
+  end
+
+  def test_null
+    records = [
+      [{"field" => nil}],
+      [nil],
+    ]
+    iterated_records = []
+    target = build(:null, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_boolean
+    records = [
+      [{"field" => true}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:boolean, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int8
+    records = [
+      [{"field" => -(2 ** 7)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint8
+    records = [
+      [{"field" => (2 ** 8) - 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint8, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int16
+    records = [
+      [{"field" => -(2 ** 15)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint16
+    records = [
+      [{"field" => (2 ** 16) - 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint16, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int32
+    records = [
+      [{"field" => -(2 ** 31)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint32
+    records = [
+      [{"field" => (2 ** 32) - 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_int64
+    records = [
+      [{"field" => -(2 ** 63)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:int64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_uint64
+    records = [
+      [{"field" => (2 ** 64) - 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:uint64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_float
+    records = [
+      [{"field" => -1.0}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:float, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_double
+    records = [
+      [{"field" => -1.0}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:double, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_binary
+    records = [
+      [{"field" => "\xff".b}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:binary, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_string
+    records = [
+      [{"field" => "Ruby"}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:string, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date32
+    records = [
+      [{"field" => Date.new(1960, 1, 1)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date32, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_date64
+    records = [
+      [{"field" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:date64, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_second
+    records = [
+      [{"field" => Time.parse("1960-01-01T02:09:30Z")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_milli
+    records = [
+      [{"field" => Time.parse("1960-01-01T02:09:30.123Z")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_micro
+    records = [
+      [{"field" => Time.parse("1960-01-01T02:09:30.123456Z")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_timestamp_nano
+    records = [
+      [{"field" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :timestamp,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_second
+    unit = Arrow::TimeUnit::SECOND
+    records = [
+      # 00:10:00
+      [{"field" => Arrow::Time.new(unit, 60 * 10)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :second,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time32_milli
+    unit = Arrow::TimeUnit::MILLI
+    records = [
+      # 00:10:00.123
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time32,
+                     unit: :milli,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_micro
+    unit = Arrow::TimeUnit::MICRO
+    records = [
+      # 00:10:00.123456
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :micro,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_time64_nano
+    unit = Arrow::TimeUnit::NANO
+    records = [
+      # 00:10:00.123456789
+      [{"field" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :time64,
+                     unit: :nano,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal128
+    records = [
+      [{"field" => BigDecimal("92.92")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal128,
+                     precision: 8,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_decimal256
+    records = [
+      [{"field" => BigDecimal("92.92")}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :decimal256,
+                     precision: 38,
+                     scale: 2,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_interval
+    records = [
+      [{"field" => 1}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_day_time_interval
+    records = [
+      [{"field" => {day: 1, millisecond: 100}}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:day_time_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_month_day_nano_interval
+    records = [
+      [{"field" => {month: 1, day: 1, nanosecond: 100}}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build(:month_day_nano_interval, records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_list
+    records = [
+      [{"field" => [true, nil, false]}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :list,
+                     field: {
+                       name: :sub_element,
+                       type: :boolean,
+                     },
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_struct
+    records = [
+      [{"field" => {"sub_field" => true}}],
+      [nil],
+      [{"field" => nil}],
+      [{"field" => {"sub_field" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :struct,
+                     fields: [
+                       {
+                         name: :sub_field,
+                         type: :boolean,
+                       },
+                     ],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def test_map
+    records = [
+      [{"field" => {"key1" => true, "key2" => nil}}],
+      [nil],
+      [{"field" => nil}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :map,
+                     key: :string,
+                     item: :boolean,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+
+  def remove_union_field_names(records)
+    records.collect do |record|
+      record.collect do |column|
+        if column.nil?
+          column
+        else
+          value = column["field"]
+          value = value.values[0] unless value.nil?
+          {"field" => value}
+        end
+      end
+    end
+  end
+
+  def test_sparse_union
+    records = [
+      [{"field" => {"field1" => true}}],
+      [nil],
+      [{"field" => nil}],
+      [{"field" => {"field2" => 29}}],
+      [{"field" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :sparse_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 iterated_records)
+  end
+
+  def test_dense_union
+    records = [
+      [{"field" => {"field1" => true}}],
+      [nil],
+      [{"field" => nil}],
+      [{"field" => {"field2" => 29}}],
+      [{"field" => {"field2" => nil}}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dense_union,
+                     fields: [
+                       {
+                         name: :field1,
+                         type: :boolean,
+                       },
+                       {
+                         name: :field2,
+                         type: :uint8,
+                       },
+                     ],
+                     type_codes: [0, 1],
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(remove_union_field_names(records),
+                 iterated_records)
+  end
+
+  def test_dictionary
+    records = [
+      [{"field" => "Ruby"}],
+      [nil],
+      [{"field" => nil}],
+      [{"field" => "GLib"}],
+    ]
+    iterated_records = []
+    target = build({
+                     type: :dictionary,
+                     index_data_type: :int8,
+                     value_data_type: :string,
+                     ordered: false,
+                   },
+                   records)
+    target.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(records, iterated_records)
+  end
+end
+
+class RawRecordsRecordBatchStructArrayTest < Test::Unit::TestCase
+  include EachRawRecordStructArrayTests
+
+  def build(type, records)
+    Arrow::RecordBatch.new(build_schema(type), records)
+  end
+end
+
+class RawRecordsTableStructArrayTest < Test::Unit::TestCase
+  include EachRawRecordStructArrayTests
+
+  def build(type, records)
+    Arrow::Table.new(build_schema(type), records)
+  end
+end
diff --git a/ruby/red-arrow/test/each-raw-record/test-table.rb b/ruby/red-arrow/test/each-raw-record/test-table.rb
new file mode 100644
index 0000000000000..b5bd80127c8b0
--- /dev/null
+++ b/ruby/red-arrow/test/each-raw-record/test-table.rb
@@ -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.
+
+class EachRawRecordTableTest < Test::Unit::TestCase
+  test("2 arrays") do
+    raw_record_batches = [
+      [
+        [true, nil, "Ruby"],
+        [nil, 0, "GLib"],
+        [false, 2 ** 8 - 1, nil],
+      ],
+      [
+        [nil, 10, "A"],
+        [true, 20, "B"],
+        [false, nil, "C"],
+        [nil, 40, nil],
+      ]
+    ]
+    raw_records = raw_record_batches.inject do |all_records, record_batch|
+      all_records + record_batch
+    end
+    schema = [
+      {name: :column0, type: :boolean},
+      {name: :column1, type: :uint8},
+      {name: :column2, type: :string},
+    ]
+    record_batches = raw_record_batches.collect do |record_batch|
+      Arrow::RecordBatch.new(schema, record_batch)
+    end
+    iterated_records = []
+    table = Arrow::Table.new(schema, record_batches)
+    table.each_raw_record do |record|
+      iterated_records << record
+    end
+    assert_equal(raw_records, iterated_records)
+  end
+end
diff --git a/ruby/red-arrow/test/raw-records/test-basic-arrays.rb b/ruby/red-arrow/test/raw-records/test-basic-arrays.rb
index 15cdee68209e7..9b95a30ad44d5 100644
--- a/ruby/red-arrow/test/raw-records/test-basic-arrays.rb
+++ b/ruby/red-arrow/test/raw-records/test-basic-arrays.rb
@@ -157,7 +157,7 @@ def test_binary
     assert_equal(records, target.raw_records)
   end
 
-  def test_tring
+  def test_string
     records = [
       ["Ruby"],
       [nil],

From 4589499b33410e0cc27061526efd2ba3ab8249a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 11:33:38 +0900
Subject: [PATCH 315/749] MINOR: [C#] Bump Grpc.Net.Client from 2.55.0 to
 2.56.0 in /csharp (#37550)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.Net.Client](https://github.com/grpc/grpc-dotnet) from 2.55.0 to 2.56.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.Net.Client's releases</a>.</em></p>
<blockquote>
<h2>Release v2.56.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Update version to 2.56.0 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2251">grpc/grpc-dotnet#2251</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre2...v2.56.0</a></p>
<h2>Release v2.56.0-pre2</h2>
<h2>What's Changed</h2>
<ul>
<li>[2.56.x] Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2234">grpc/grpc-dotnet#2234</a></li>
<li>[2.56.x] Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2233">grpc/grpc-dotnet#2233</a></li>
<li>Update version to -pre2 on v2.56.x branch by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2246">grpc/grpc-dotnet#2246</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2">https://github.com/grpc/grpc-dotnet/compare/v2.56.0-pre1...v2.56.0-pre2</a></p>
<h2>Release v2.56.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Update 2.55 branch to 2.55-pre1 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2174">grpc/grpc-dotnet#2174</a></li>
<li>Revert &quot;update 2.55 branch to 2.55-pre1&quot; by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2175">grpc/grpc-dotnet#2175</a></li>
<li>Update version to 2.55.0-dev (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2177">grpc/grpc-dotnet#2177</a></li>
<li>update readme by <a href="https://github.com/Varorbc"><code>@​Varorbc</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2183">grpc/grpc-dotnet#2183</a></li>
<li>Start 2.56.x development cycle (on master branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2185">grpc/grpc-dotnet#2185</a></li>
<li>Improve grpc-dotnet debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2192">grpc/grpc-dotnet#2192</a></li>
<li>Even better gRPC debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2193">grpc/grpc-dotnet#2193</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2199">grpc/grpc-dotnet#2199</a></li>
<li>Bump word-wrap from 1.2.3 to 1.2.4 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2198">grpc/grpc-dotnet#2198</a></li>
<li>Bump tough-cookie from 4.0.0 to 4.1.3 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2187">grpc/grpc-dotnet#2187</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2189">grpc/grpc-dotnet#2189</a></li>
<li>Remove System.Memory dependency on .NET Standard 2.1 in Grpc.Core.Api. by <a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
<li>Socket transport: Don't close socket on available data by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2179">grpc/grpc-dotnet#2179</a></li>
<li>Update SocketConnectivitySubchannelTransport.cs by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2202">grpc/grpc-dotnet#2202</a></li>
<li>Improve gRPC channel and client debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2196">grpc/grpc-dotnet#2196</a></li>
<li>Fix gRPC client retry deadlock by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2209">grpc/grpc-dotnet#2209</a></li>
<li>Support idle connection timeout with pending sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2213">grpc/grpc-dotnet#2213</a></li>
<li>Correctly check socket on stream creation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2215">grpc/grpc-dotnet#2215</a></li>
<li>Add net462 build to Grpc.Net.Client with WinHttpHandler default by <a href="https://github.com/stephentoub"><code>@​stephentoub</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2220">grpc/grpc-dotnet#2220</a></li>
<li>Update version to v2.56.0-pre1 (on v2.56.x branch) by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2224">grpc/grpc-dotnet#2224</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/teo-tsirpanis"><code>@​teo-tsirpanis</code></a> made their first contribution in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2186">grpc/grpc-dotnet#2186</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b9e7a8b03fa8cb23fce00e2d3f70888a0a6e757b"><code>b9e7a8b</code></a> Update version to 2.56.0 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2251">#2251</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c41d7e2302d85d55b6282023d4edc770325517c3"><code>c41d7e2</code></a> Update version to -pre2 on v2.56.x branch (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2246">#2246</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/400bbb7aeadb8584bd0bbe6ba3b2d0590b1a8884"><code>400bbb7</code></a> [2.56.x] Validate Windows version when using WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2233">#2233</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1422de08f0d499f4c44c702c70baad22b278725c"><code>1422de0</code></a> [2.56.x] Support infinite idle connection timeout values (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2234">#2234</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/df13e5a7f1c0899302a0e259ad562a24531b5246"><code>df13e5a</code></a> Update version to v2.56.0-pre1 (on v2.56.x branch) (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2224">#2224</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6a4bca703aee8040144b7548c88706063445c1fb"><code>6a4bca7</code></a> Add net462 build to Grpc.Net.Client with WinHttpHandler default (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2220">#2220</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a2d005c86bfea561105155d5d9366d74531872cc"><code>a2d005c</code></a> Correctly check socket on stream creation (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2215">#2215</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/1d1234064c3c6a5ed394bc56a13bf1dc687a12d4"><code>1d12340</code></a> Support idle connection timeout with pending sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2213">#2213</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/0ab3ada34aa76740b436b3b1d320f2f406f82f50"><code>0ab3ada</code></a> Fix gRPC client retry deadlock (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2209">#2209</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bff852c7f10ebf917e8229940eb8ac695f141ac0"><code>bff852c</code></a> Improve gRPC channel and client debugging (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2196">#2196</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.55.0...v2.56.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Net.Client&package-manager=nuget&previous-version=2.55.0&new-version=2.56.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 799338e838e54..005714ef28a18 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -6,7 +6,7 @@
   
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.2" />
-    <PackageReference Include="Grpc.Net.Client" Version="2.55.0" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.56.0" />
     <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>
 

From a526ba697d4e3f009731bebda6838b41899051e3 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 5 Sep 2023 12:04:02 +0900
Subject: [PATCH 316/749] GH-37433: [CI][Release] Increase timeout for macOS
 (#37530)

### Rationale for this change

It seems that running ci/scripts/release_test.sh on macOS may take 10+ minutes. (Normally, it's finished in 5-10 minutes.)

### What changes are included in this PR?

Increase timeout to 15 minutes.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37433

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/dev.yml  | 10 +++++-----
 ci/scripts/release_test.sh |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index f97c499890191..cee3c74762c3c 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -70,7 +70,7 @@ jobs:
     name: Source Release and Merge Script on ${{ matrix.runs-on }}
     runs-on: ${{ matrix.runs-on }}
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
-    timeout-minutes: 10
+    timeout-minutes: 15
     strategy:
       fail-fast: false
       matrix:
@@ -78,10 +78,10 @@ jobs:
           - macos-latest
           - ubuntu-latest
     env:
-      GIT_AUTHOR_NAME: Github Actions
-      GIT_AUTHOR_EMAIL: github@actions
-      GIT_COMMITTER_NAME: Github Actions
-      GIT_COMMITTER_EMAIL: github@actions
+      GIT_AUTHOR_NAME: "github-actions[bot]"
+      GIT_AUTHOR_EMAIL: "github-actions[bot]@users.noreply.github.com"
+      GIT_COMMITTER_NAME: "github-actions[bot]"
+      GIT_COMMITTER_EMAIL: "github-actions[bot]@users.noreply.github.com"
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
diff --git a/ci/scripts/release_test.sh b/ci/scripts/release_test.sh
index ae2ab328884b3..583d9618c657b 100755
--- a/ci/scripts/release_test.sh
+++ b/ci/scripts/release_test.sh
@@ -23,6 +23,6 @@ arrow_dir=${1}
 
 pushd ${arrow_dir}
 
-dev/release/run-test.rb
+dev/release/run-test.rb -vv
 
 popd

From b5d36e9f4d323f274e06ed04285ddd4e2121ab19 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Tue, 5 Sep 2023 10:12:00 -0300
Subject: [PATCH 317/749] GH-36819: [R] Use RunWithCapturedR for reading
 Parquet files (#37274)

### Rationale for this change

When we first added RunWithCapturedR to support reading files from R connections, none of the Parquet tests seemed to call R from another thread. Because RunWithCapturedR comes with some complexity, I didn't add it anywhere it wasn't strictly needed. A recent StackOverflow post exposed that reading very large parquet files do use multiple threads and thus need RunWithCapturedR.

### What changes are included in this PR?

The two most common calls to read a parquet in which a user might trigger this failure are now wrapped in RunWithCapturedR.

### Are these changes tested?

The changes are tested in the current suite.

### Are there any user-facing changes?

No.
* Closes: #36819

Lead-authored-by: Dewey Dunnington <dewey@voltrondata.com>
Co-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/src/parquet.cpp | 37 ++++++++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/r/src/parquet.cpp b/r/src/parquet.cpp
index f9f7b0447c17b..c32d0640592b8 100644
--- a/r/src/parquet.cpp
+++ b/r/src/parquet.cpp
@@ -17,6 +17,8 @@
 
 #include "./arrow_types.h"
 
+#include "./safe-call-into-r.h"
+
 #if defined(ARROW_R_WITH_PARQUET)
 
 #include <arrow/table.h>
@@ -129,7 +131,10 @@ std::shared_ptr<parquet::arrow::FileReader> parquet___arrow___FileReader__OpenFi
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadTable1(
     const std::shared_ptr<parquet::arrow::FileReader>& reader) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadTable(&table));
+  auto result =
+      RunWithCapturedRIfPossibleVoid([&]() { return reader->ReadTable(&table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -138,7 +143,10 @@ std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadTable2(
     const std::shared_ptr<parquet::arrow::FileReader>& reader,
     const std::vector<int>& column_indices) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadTable(column_indices, &table));
+  auto result = RunWithCapturedRIfPossibleVoid(
+      [&]() { return reader->ReadTable(column_indices, &table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -146,7 +154,10 @@ std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadTable2(
 std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroup1(
     const std::shared_ptr<parquet::arrow::FileReader>& reader, int i) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadRowGroup(i, &table));
+  auto result =
+      RunWithCapturedRIfPossibleVoid([&]() { return reader->ReadRowGroup(i, &table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -155,7 +166,10 @@ std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroup2(
     const std::shared_ptr<parquet::arrow::FileReader>& reader, int i,
     const std::vector<int>& column_indices) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadRowGroup(i, column_indices, &table));
+  auto result = RunWithCapturedRIfPossibleVoid(
+      [&]() { return reader->ReadRowGroup(i, column_indices, &table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -164,7 +178,10 @@ std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroups1(
     const std::shared_ptr<parquet::arrow::FileReader>& reader,
     const std::vector<int>& row_groups) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadRowGroups(row_groups, &table));
+  auto result = RunWithCapturedRIfPossibleVoid(
+      [&]() { return reader->ReadRowGroups(row_groups, &table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -173,7 +190,10 @@ std::shared_ptr<arrow::Table> parquet___arrow___FileReader__ReadRowGroups2(
     const std::shared_ptr<parquet::arrow::FileReader>& reader,
     const std::vector<int>& row_groups, const std::vector<int>& column_indices) {
   std::shared_ptr<arrow::Table> table;
-  PARQUET_THROW_NOT_OK(reader->ReadRowGroups(row_groups, column_indices, &table));
+  auto result = RunWithCapturedRIfPossibleVoid(
+      [&]() { return reader->ReadRowGroups(row_groups, column_indices, &table); });
+
+  StopIfNotOk(result);
   return table;
 }
 
@@ -199,7 +219,10 @@ int parquet___arrow___FileReader__num_row_groups(
 std::shared_ptr<arrow::ChunkedArray> parquet___arrow___FileReader__ReadColumn(
     const std::shared_ptr<parquet::arrow::FileReader>& reader, int i) {
   std::shared_ptr<arrow::ChunkedArray> array;
-  PARQUET_THROW_NOT_OK(reader->ReadColumn(i - 1, &array));
+  auto result =
+      RunWithCapturedRIfPossibleVoid([&]() { return reader->ReadColumn(i - 1, &array); });
+
+  StopIfNotOk(result);
   return array;
 }
 

From 697a2cbaf834616a676f11f1b89b9200344de998 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 5 Sep 2023 10:39:43 -0400
Subject: [PATCH 318/749] GH-37419: [Go][Parquet] Decimal256 support for
 pqarrow (#37503)

### Rationale for this change
When support for decimal128 was added to the Go Parquet lib, decimal256 wasn't yet implemented in the library. This adds proper support to read/write decimal256 with Parquet based on origin schemas and precision.

### Are these changes tested?
yes

* Closes: #37419

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/decimal128/decimal128.go       |   5 +
 go/parquet/pqarrow/column_readers.go    | 122 +++++++++++++++++++++---
 go/parquet/pqarrow/encode_arrow.go      |  63 ++++++++++++
 go/parquet/pqarrow/encode_arrow_test.go |  65 +++++++++++--
 go/parquet/pqarrow/schema.go            |  43 +++++++--
 go/parquet/writer_properties.go         |  43 ++++++---
 6 files changed, 298 insertions(+), 43 deletions(-)

diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index 68d729526d353..898d7b427ec84 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -26,6 +26,11 @@ import (
 	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
+const (
+	MaxPrecision = 38
+	MaxScale     = 38
+)
+
 var (
 	MaxDecimal128 = New(542101086242752217, 687399551400673280-1)
 )
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 6b84e56295ac6..759a3d8675927 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -30,6 +30,7 @@ import (
 	"github.com/apache/arrow/go/v14/arrow/array"
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
 	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/apache/arrow/go/v14/parquet"
@@ -493,14 +494,14 @@ func transferColumnData(rdr file.RecordReader, valueType arrow.DataType, descr *
 		data = transferDate64(rdr, valueType)
 	case arrow.FIXED_SIZE_BINARY, arrow.BINARY, arrow.STRING, arrow.LARGE_BINARY, arrow.LARGE_STRING:
 		return transferBinary(rdr, valueType), nil
-	case arrow.DECIMAL:
+	case arrow.DECIMAL, arrow.DECIMAL256:
 		switch descr.PhysicalType() {
 		case parquet.Types.Int32, parquet.Types.Int64:
 			data = transferDecimalInteger(rdr, valueType)
 		case parquet.Types.ByteArray, parquet.Types.FixedLenByteArray:
 			return transferDecimalBytes(rdr.(file.BinaryRecordReader), valueType)
 		default:
-			return nil, errors.New("physical type for decimal128 must be int32, int64, bytearray or fixed len byte array")
+			return nil, errors.New("physical type for decimal128/decimal256 must be int32, int64, bytearray or fixed len byte array")
 		}
 	case arrow.TIMESTAMP:
 		tstype := valueType.(*arrow.TimestampType)
@@ -722,10 +723,20 @@ func transferDecimalInteger(rdr file.RecordReader, dt arrow.DataType) arrow.Arra
 		values = reflect.ValueOf(arrow.Int64Traits.CastFromBytes(rdr.Values())[:length])
 	}
 
-	data := make([]byte, arrow.Decimal128Traits.BytesRequired(length))
-	out := arrow.Decimal128Traits.CastFromBytes(data)
-	for i := 0; i < values.Len(); i++ {
-		out[i] = decimal128.FromI64(values.Index(i).Int())
+	var data []byte
+	switch dt.ID() {
+	case arrow.DECIMAL128:
+		data = make([]byte, arrow.Decimal128Traits.BytesRequired(length))
+		out := arrow.Decimal128Traits.CastFromBytes(data)
+		for i := 0; i < values.Len(); i++ {
+			out[i] = decimal128.FromI64(values.Index(i).Int())
+		}
+	case arrow.DECIMAL256:
+		data = make([]byte, arrow.Decimal256Traits.BytesRequired(length))
+		out := arrow.Decimal256Traits.CastFromBytes(data)
+		for i := 0; i < values.Len(); i++ {
+			out[i] = decimal256.FromI64(values.Index(i).Int())
+		}
 	}
 
 	var nullmap *memory.Buffer
@@ -801,6 +812,52 @@ func bigEndianToDecimal128(buf []byte) (decimal128.Num, error) {
 	return decimal128.New(hi, uint64(lo)), nil
 }
 
+func bigEndianToDecimal256(buf []byte) (decimal256.Num, error) {
+	const (
+		minDecimalBytes = 1
+		maxDecimalBytes = 32
+	)
+
+	if len(buf) < minDecimalBytes || len(buf) > maxDecimalBytes {
+		return decimal256.Num{},
+			fmt.Errorf("%w: length of byte array for bigEndianToDecimal256 was %d but must be between %d and %d",
+				arrow.ErrInvalid, len(buf), minDecimalBytes, maxDecimalBytes)
+	}
+
+	var littleEndian [4]uint64
+	// bytes are coming in big-endian, so the first byte is the MSB and
+	// therefore holds the sign bit
+	initWord, isNeg := uint64(0), int8(buf[0]) < 0
+	if isNeg {
+		// sign extend if necessary
+		initWord = uint64(0xFFFFFFFFFFFFFFFF)
+	}
+
+	for wordIdx := 0; wordIdx < 4; wordIdx++ {
+		wordLen := utils.MinInt(len(buf), arrow.Uint64SizeBytes)
+		word := buf[len(buf)-wordLen:]
+
+		if wordLen == 8 {
+			// full words can be assigned as-is
+			littleEndian[wordIdx] = binary.BigEndian.Uint64(word)
+		} else {
+			result := initWord
+			if len(buf) > 0 {
+				// incorporate the actual values if present
+				// shift left enough bits to make room for the incoming int64
+				result = result << uint64(wordLen)
+				// preserve the upper bits by inplace OR-ing the int64
+				result |= uint64FromBigEndianShifted(word)
+			}
+			littleEndian[wordIdx] = result
+		}
+
+		buf = buf[:len(buf)-wordLen]
+	}
+
+	return decimal256.New(littleEndian[3], littleEndian[2], littleEndian[1], littleEndian[0]), nil
+}
+
 type varOrFixedBin interface {
 	arrow.Array
 	Value(i int) []byte
@@ -808,21 +865,19 @@ type varOrFixedBin interface {
 
 // convert physical byte storage, instead of integers, to decimal128
 func transferDecimalBytes(rdr file.BinaryRecordReader, dt arrow.DataType) (*arrow.Chunked, error) {
-	convert := func(arr arrow.Array) (arrow.Array, error) {
-		length := arr.Len()
+	convert128 := func(in varOrFixedBin) (arrow.Array, error) {
+		length := in.Len()
 		data := make([]byte, arrow.Decimal128Traits.BytesRequired(length))
 		out := arrow.Decimal128Traits.CastFromBytes(data)
 
-		input := arr.(varOrFixedBin)
-		nullCount := input.NullN()
-
+		nullCount := in.NullN()
 		var err error
 		for i := 0; i < length; i++ {
-			if nullCount > 0 && input.IsNull(i) {
+			if nullCount > 0 && in.IsNull(i) {
 				continue
 			}
 
-			rec := input.Value(i)
+			rec := in.Value(i)
 			if len(rec) <= 0 {
 				return nil, fmt.Errorf("invalud BYTEARRAY length for type: %s", dt)
 			}
@@ -833,12 +888,51 @@ func transferDecimalBytes(rdr file.BinaryRecordReader, dt arrow.DataType) (*arro
 		}
 
 		ret := array.NewData(dt, length, []*memory.Buffer{
-			input.Data().Buffers()[0], memory.NewBufferBytes(data),
+			in.Data().Buffers()[0], memory.NewBufferBytes(data),
 		}, nil, nullCount, 0)
 		defer ret.Release()
 		return array.MakeFromData(ret), nil
 	}
 
+	convert256 := func(in varOrFixedBin) (arrow.Array, error) {
+		length := in.Len()
+		data := make([]byte, arrow.Decimal256Traits.BytesRequired(length))
+		out := arrow.Decimal256Traits.CastFromBytes(data)
+
+		nullCount := in.NullN()
+		var err error
+		for i := 0; i < length; i++ {
+			if nullCount > 0 && in.IsNull(i) {
+				continue
+			}
+
+			rec := in.Value(i)
+			if len(rec) <= 0 {
+				return nil, fmt.Errorf("invalid BYTEARRAY length for type: %s", dt)
+			}
+			out[i], err = bigEndianToDecimal256(rec)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		ret := array.NewData(dt, length, []*memory.Buffer{
+			in.Data().Buffers()[0], memory.NewBufferBytes(data),
+		}, nil, nullCount, 0)
+		defer ret.Release()
+		return array.MakeFromData(ret), nil
+	}
+
+	convert := func(arr arrow.Array) (arrow.Array, error) {
+		switch dt.ID() {
+		case arrow.DECIMAL128:
+			return convert128(arr.(varOrFixedBin))
+		case arrow.DECIMAL256:
+			return convert256(arr.(varOrFixedBin))
+		}
+		return nil, arrow.ErrNotImplemented
+	}
+
 	chunks := rdr.GetBuilderChunks()
 	var err error
 	for idx, chunk := range chunks {
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index 6784014281b8b..c3a0a50c43f45 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -21,6 +21,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"math"
 	"time"
 	"unsafe"
 
@@ -28,10 +29,12 @@ import (
 	"github.com/apache/arrow/go/v14/arrow/array"
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
 	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/apache/arrow/go/v14/parquet"
 	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 )
 
 // get the count of the number of leaf arrays for the type
@@ -327,6 +330,18 @@ func writeDenseArrow(ctx *arrowWriteContext, cw file.ColumnChunkWriter, leafArr
 				for idx, val := range leafArr.(*array.Date64).Date64Values() {
 					data[idx] = int32(val / 86400000) // coerce date64 values
 				}
+			case arrow.DECIMAL128:
+				for idx, val := range leafArr.(*array.Decimal128).Values() {
+					debug.Assert(val.HighBits() == 0 || val.HighBits() == -1, "casting Decimal128 greater than the value range; high bits must be 0 or -1")
+					debug.Assert(val.LowBits() <= math.MaxUint32, "casting Decimal128 to int32 when value > MaxUint32")
+					data[idx] = int32(val.LowBits())
+				}
+			case arrow.DECIMAL256:
+				for idx, val := range leafArr.(*array.Decimal256).Values() {
+					debug.Assert(val.Array()[3] == 0 || val.Array()[3] == 0xFFFFFFFF, "casting Decimal128 greater than the value range; high bits must be 0 or -1")
+					debug.Assert(val.LowBits() <= math.MaxUint32, "casting Decimal128 to int32 when value > MaxUint32")
+					data[idx] = int32(val.LowBits())
+				}
 			default:
 				return fmt.Errorf("type mismatch, column is int32 writer, arrow array is %s, and not a compatible type", leafArr.DataType().Name())
 			}
@@ -396,6 +411,20 @@ func writeDenseArrow(ctx *arrowWriteContext, cw file.ColumnChunkWriter, leafArr
 				data = arrow.Int64Traits.CastFromBytes(leafArr.Data().Buffers()[1].Bytes())
 				data = data[leafArr.Data().Offset() : leafArr.Data().Offset()+leafArr.Len()]
 			}
+		case arrow.DECIMAL128:
+			ctx.dataBuffer.ResizeNoShrink(arrow.Int64Traits.BytesRequired(leafArr.Len()))
+			data = arrow.Int64Traits.CastFromBytes(ctx.dataBuffer.Bytes())
+			for idx, val := range leafArr.(*array.Decimal128).Values() {
+				debug.Assert(val.HighBits() == 0 || val.HighBits() == -1, "trying to cast Decimal128 to int64 greater than range, high bits must be 0 or -1")
+				data[idx] = int64(val.LowBits())
+			}
+		case arrow.DECIMAL256:
+			ctx.dataBuffer.ResizeNoShrink(arrow.Int64Traits.BytesRequired(leafArr.Len()))
+			data = arrow.Int64Traits.CastFromBytes(ctx.dataBuffer.Bytes())
+			for idx, val := range leafArr.(*array.Decimal256).Values() {
+				debug.Assert(val.Array()[3] == 0 || val.Array()[3] == 0xFFFFFFFF, "trying to cast Decimal128 to int64 greater than range, high bits must be 0 or -1")
+				data[idx] = int64(val.LowBits())
+			}
 		default:
 			return fmt.Errorf("unimplemented arrow type to write to int64 column: %s", leafArr.DataType().Name())
 		}
@@ -519,6 +548,40 @@ func writeDenseArrow(ctx *arrowWriteContext, cw file.ColumnChunkWriter, leafArr
 				}
 				wr.WriteBatchSpaced(data, defLevels, repLevels, arr.NullBitmapBytes(), int64(arr.Data().Offset()))
 			}
+		case *arrow.Decimal256Type:
+			// parquet decimal are stored with FixedLength values where the length is
+			// proportional to the precision. Arrow's Decimal are always stored with 16/32
+			// bytes. thus the internal FLBA must be adjusted by the offset calculation
+			offset := int(bitutil.BytesForBits(int64(dt.BitWidth()))) - int(DecimalSize(dt.Precision))
+			ctx.dataBuffer.ResizeNoShrink((leafArr.Len() - leafArr.NullN()) * dt.BitWidth())
+			scratch := ctx.dataBuffer.Bytes()
+			typeLen := wr.Descr().TypeLength()
+			fixDecimalEndianness := func(in decimal256.Num) parquet.FixedLenByteArray {
+				out := scratch[offset : offset+typeLen]
+				vals := in.Array()
+				binary.BigEndian.PutUint64(scratch, vals[3])
+				binary.BigEndian.PutUint64(scratch[arrow.Uint64SizeBytes:], vals[2])
+				binary.BigEndian.PutUint64(scratch[2*arrow.Uint64SizeBytes:], vals[1])
+				binary.BigEndian.PutUint64(scratch[3*arrow.Uint64SizeBytes:], vals[0])
+				scratch = scratch[4*arrow.Uint64SizeBytes:]
+				return out
+			}
+
+			data := make([]parquet.FixedLenByteArray, leafArr.Len())
+			arr := leafArr.(*array.Decimal256)
+			if leafArr.NullN() == 0 {
+				for idx := range data {
+					data[idx] = fixDecimalEndianness(arr.Value(idx))
+				}
+				_, err = wr.WriteBatch(data, defLevels, repLevels)
+			} else {
+				for idx := range data {
+					if arr.IsValid(idx) {
+						data[idx] = fixDecimalEndianness(arr.Value(idx))
+					}
+				}
+				wr.WriteBatchSpaced(data, defLevels, repLevels, arr.NullBitmapBytes(), int64(arr.Data().Offset()))
+			}
 		default:
 			return fmt.Errorf("%w: invalid column type to write to FixedLenByteArray: %s", arrow.ErrInvalid, leafArr.DataType().Name())
 		}
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 63fd4f142abba..654d3d813cf85 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -29,6 +29,7 @@ import (
 	"github.com/apache/arrow/go/v14/arrow/array"
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
 	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 	"github.com/apache/arrow/go/v14/arrow/ipc"
 	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/apache/arrow/go/v14/internal/types"
@@ -474,9 +475,9 @@ func getLogicalType(typ arrow.DataType) schema.LogicalType {
 		default:
 			panic("only micro and nano seconds are supported for arrow TIME64")
 		}
-	case arrow.DECIMAL:
-		dec := typ.(*arrow.Decimal128Type)
-		return schema.NewDecimalLogicalType(dec.Precision, dec.Scale)
+	case arrow.DECIMAL, arrow.DECIMAL256:
+		dec := typ.(arrow.DecimalType)
+		return schema.NewDecimalLogicalType(dec.GetPrecision(), dec.GetScale())
 	}
 	return schema.NoLogicalType{}
 }
@@ -552,15 +553,15 @@ func (ps *ParquetIOTestSuite) makeSimpleSchema(typ arrow.DataType, rep parquet.R
 	switch typ := typ.(type) {
 	case *arrow.FixedSizeBinaryType:
 		byteWidth = int32(typ.ByteWidth)
-	case *arrow.Decimal128Type:
-		byteWidth = pqarrow.DecimalSize(typ.Precision)
+	case arrow.DecimalType:
+		byteWidth = pqarrow.DecimalSize(typ.GetPrecision())
 	case *arrow.DictionaryType:
 		valuesType := typ.ValueType
 		switch dt := valuesType.(type) {
 		case *arrow.FixedSizeBinaryType:
 			byteWidth = int32(dt.ByteWidth)
-		case *arrow.Decimal128Type:
-			byteWidth = pqarrow.DecimalSize(dt.Precision)
+		case arrow.DecimalType:
+			byteWidth = pqarrow.DecimalSize(dt.GetPrecision())
 		}
 	}
 
@@ -932,6 +933,56 @@ func (ps *ParquetIOTestSuite) TestReadDecimals() {
 	ps.True(array.Equal(expected, chunked.Chunk(0)))
 }
 
+func (ps *ParquetIOTestSuite) TestReadDecimal256() {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(ps.T(), 0)
+
+	bigEndian := []parquet.ByteArray{
+		// 123456
+		[]byte{1, 226, 64},
+		// 987654
+		[]byte{15, 18, 6},
+		// -123456
+		[]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254, 29, 192},
+	}
+
+	bldr := array.NewDecimal256Builder(mem, &arrow.Decimal256Type{Precision: 40, Scale: 3})
+	defer bldr.Release()
+
+	bldr.Append(decimal256.FromU64(123456))
+	bldr.Append(decimal256.FromU64(987654))
+	bldr.Append(decimal256.FromI64(-123456))
+
+	expected := bldr.NewDecimal256Array()
+	defer expected.Release()
+
+	sc := schema.MustGroup(schema.NewGroupNode("schema", parquet.Repetitions.Required, schema.FieldList{
+		schema.Must(schema.NewPrimitiveNodeLogical("decimals", parquet.Repetitions.Required, schema.NewDecimalLogicalType(40, 3), parquet.Types.ByteArray, -1, -1)),
+	}, -1))
+
+	sink := encoding.NewBufferWriter(0, mem)
+	defer sink.Release()
+	writer := file.NewParquetWriter(sink, sc)
+
+	rgw := writer.AppendRowGroup()
+	cw, _ := rgw.NextColumn()
+	cw.(*file.ByteArrayColumnChunkWriter).WriteBatch(bigEndian, nil, nil)
+	cw.Close()
+	rgw.Close()
+	writer.Close()
+
+	rdr := ps.createReader(mem, sink.Bytes())
+	cr, err := rdr.GetColumn(context.TODO(), 0)
+	ps.NoError(err)
+
+	chunked, err := cr.NextBatch(smallSize)
+	ps.NoError(err)
+	defer chunked.Release()
+
+	ps.Len(chunked.Chunks(), 1)
+	ps.Truef(array.Equal(expected, chunked.Chunk(0)), "expected: %s\ngot: %s", expected, chunked.Chunk(0))
+}
+
 func (ps *ParquetIOTestSuite) TestReadNestedStruct() {
 	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
 	defer mem.AssertSize(ps.T(), 0)
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index 4c1627263681a..9ba8554898986 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -23,6 +23,7 @@ import (
 	"strconv"
 
 	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
 	"github.com/apache/arrow/go/v14/arrow/flight"
 	"github.com/apache/arrow/go/v14/arrow/ipc"
 	"github.com/apache/arrow/go/v14/arrow/memory"
@@ -304,12 +305,22 @@ func fieldToNode(name string, field arrow.Field, props *parquet.WriterProperties
 	case arrow.FIXED_SIZE_BINARY:
 		typ = parquet.Types.FixedLenByteArray
 		length = field.Type.(*arrow.FixedSizeBinaryType).ByteWidth
-	case arrow.DECIMAL:
-		typ = parquet.Types.FixedLenByteArray
-		dectype := field.Type.(*arrow.Decimal128Type)
-		precision = int(dectype.Precision)
-		scale = int(dectype.Scale)
-		length = int(DecimalSize(int32(precision)))
+	case arrow.DECIMAL, arrow.DECIMAL256:
+		dectype := field.Type.(arrow.DecimalType)
+		precision = int(dectype.GetPrecision())
+		scale = int(dectype.GetScale())
+
+		if props.StoreDecimalAsInteger() && 1 <= precision && precision <= 18 {
+			if precision <= 9 {
+				typ = parquet.Types.Int32
+			} else {
+				typ = parquet.Types.Int64
+			}
+		} else {
+			typ = parquet.Types.FixedLenByteArray
+			length = int(DecimalSize(int32(precision)))
+		}
+
 		logicalType = schema.NewDecimalLogicalType(int32(precision), int32(scale))
 	case arrow.DATE32:
 		typ = parquet.Types.Int32
@@ -521,6 +532,13 @@ func arrowTimestamp(logical *schema.TimestampLogicalType) (arrow.DataType, error
 	}
 }
 
+func arrowDecimal(logical *schema.DecimalLogicalType) arrow.DataType {
+	if logical.Precision() <= decimal128.MaxPrecision {
+		return &arrow.Decimal128Type{Precision: logical.Precision(), Scale: logical.Scale()}
+	}
+	return &arrow.Decimal256Type{Precision: logical.Precision(), Scale: logical.Scale()}
+}
+
 func arrowFromInt32(logical schema.LogicalType) (arrow.DataType, error) {
 	switch logtype := logical.(type) {
 	case schema.NoLogicalType:
@@ -528,7 +546,7 @@ func arrowFromInt32(logical schema.LogicalType) (arrow.DataType, error) {
 	case *schema.TimeLogicalType:
 		return arrowTime32(logtype)
 	case *schema.DecimalLogicalType:
-		return &arrow.Decimal128Type{Precision: logtype.Precision(), Scale: logtype.Scale()}, nil
+		return arrowDecimal(logtype), nil
 	case *schema.IntLogicalType:
 		return arrowInt(logtype)
 	case schema.DateLogicalType:
@@ -547,7 +565,7 @@ func arrowFromInt64(logical schema.LogicalType) (arrow.DataType, error) {
 	case *schema.IntLogicalType:
 		return arrowInt(logtype)
 	case *schema.DecimalLogicalType:
-		return &arrow.Decimal128Type{Precision: logtype.Precision(), Scale: logtype.Scale()}, nil
+		return arrowDecimal(logtype), nil
 	case *schema.TimeLogicalType:
 		return arrowTime64(logtype)
 	case *schema.TimestampLogicalType:
@@ -562,7 +580,7 @@ func arrowFromByteArray(logical schema.LogicalType) (arrow.DataType, error) {
 	case schema.StringLogicalType:
 		return arrow.BinaryTypes.String, nil
 	case *schema.DecimalLogicalType:
-		return &arrow.Decimal128Type{Precision: logtype.Precision(), Scale: logtype.Scale()}, nil
+		return arrowDecimal(logtype), nil
 	case schema.NoLogicalType,
 		schema.EnumLogicalType,
 		schema.JSONLogicalType,
@@ -576,7 +594,7 @@ func arrowFromByteArray(logical schema.LogicalType) (arrow.DataType, error) {
 func arrowFromFLBA(logical schema.LogicalType, length int) (arrow.DataType, error) {
 	switch logtype := logical.(type) {
 	case *schema.DecimalLogicalType:
-		return &arrow.Decimal128Type{Precision: logtype.Precision(), Scale: logtype.Scale()}, nil
+		return arrowDecimal(logtype), nil
 	case schema.NoLogicalType, schema.IntervalLogicalType, schema.UUIDLogicalType:
 		return &arrow.FixedSizeBinaryType{ByteWidth: int(length)}, nil
 	default:
@@ -1048,6 +1066,11 @@ func applyOriginalStorageMetadata(origin arrow.Field, inferred *SchemaField) (mo
 		inferred.Field.Type = &arrow.DictionaryType{IndexType: arrow.PrimitiveTypes.Int32,
 			ValueType: inferred.Field.Type, Ordered: dictOriginType.Ordered}
 		modified = true
+	case arrow.DECIMAL256:
+		if inferred.Field.Type.ID() == arrow.DECIMAL128 {
+			inferred.Field.Type = origin.Type
+			modified = true
+		}
 	}
 
 	if origin.HasMetadata() {
diff --git a/go/parquet/writer_properties.go b/go/parquet/writer_properties.go
index bd172f7f92702..e4199f451f5f9 100644
--- a/go/parquet/writer_properties.go
+++ b/go/parquet/writer_properties.go
@@ -63,6 +63,7 @@ type ColumnProperties struct {
 // DefaultColumnProperties returns the default properties which get utilized for writing.
 //
 // The default column properties are the following constants:
+//
 //	Encoding:						Encodings.Plain
 //	Codec:							compress.Codecs.Uncompressed
 //	DictionaryEnabled:	DefaultDictionaryEnabled
@@ -290,19 +291,28 @@ func WithEncryptionProperties(props *FileEncryptionProperties) WriterProperty {
 	}
 }
 
+// WithStoreDecimalAsInteger specifies whether to try using an int32/int64 for storing
+// decimal data rather than fixed len byte arrays if the precision is low enough.
+func WithStoreDecimalAsInteger(enabled bool) WriterProperty {
+	return func(cfg *writerPropConfig) {
+		cfg.wr.storeDecimalAsInt = enabled
+	}
+}
+
 // WriterProperties is the collection of properties to use for writing a parquet file. The values are
 // read only once it has been constructed.
 type WriterProperties struct {
-	mem             memory.Allocator
-	dictPagesize    int64
-	batchSize       int64
-	maxRowGroupLen  int64
-	pageSize        int64
-	parquetVersion  Version
-	createdBy       string
-	dataPageVersion DataPageVersion
-	rootName        string
-	rootRepetition  Repetition
+	mem               memory.Allocator
+	dictPagesize      int64
+	batchSize         int64
+	maxRowGroupLen    int64
+	pageSize          int64
+	parquetVersion    Version
+	createdBy         string
+	dataPageVersion   DataPageVersion
+	rootName          string
+	rootRepetition    Repetition
+	storeDecimalAsInt bool
 
 	defColumnProps  ColumnProperties
 	columnProps     map[string]*ColumnProperties
@@ -330,8 +340,9 @@ func defaultWriterProperties() *WriterProperties {
 // properties will be utilized for writing.
 //
 // The Default properties use the following constants:
+//
 //	Allocator:					memory.DefaultAllocator
-// 	DictionaryPageSize: DefaultDictionaryPageSizeLimit
+//	DictionaryPageSize: DefaultDictionaryPageSizeLimit
 //	BatchSize:					DefaultWriteBatchSize
 //	MaxRowGroupLength:	DefaultMaxRowGroupLen
 //	PageSize:						DefaultDataPageSize
@@ -413,7 +424,7 @@ func (w *WriterProperties) CompressionFor(path string) compress.Compression {
 	return w.defColumnProps.Codec
 }
 
-//CompressionPath is the same as CompressionFor but takes a ColumnPath
+// CompressionPath is the same as CompressionFor but takes a ColumnPath
 func (w *WriterProperties) CompressionPath(path ColumnPath) compress.Compression {
 	return w.CompressionFor(path.String())
 }
@@ -531,3 +542,11 @@ func (w *WriterProperties) ColumnEncryptionProperties(path string) *ColumnEncryp
 	}
 	return nil
 }
+
+// StoreDecimalAsInteger returns the config option controlling whether or not
+// to try storing decimal data as an integer type if the precision is low enough
+// (1 <= prec <= 18 can be stored as an int), otherwise it will be stored as
+// a fixed len byte array.
+func (w *WriterProperties) StoreDecimalAsInteger() bool {
+	return w.storeDecimalAsInt
+}

From 13f0cd8ee44833efbced05c8505de12f9f02f235 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 5 Sep 2023 11:33:18 -0400
Subject: [PATCH 319/749] GH-37523: [C++][CI][CUDA] Don't use newer API and add
 missing CUDA dependencies (#37497)

### Rationale for this change
#37365 was built locally using a newer version of the CUDA driver API than the crossbow builds run with causing the crossbow build to fail due to a change in macro names. This puts the macro name back to allow it to build with the older version of the cuda driver api.

* Closes: #37523

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/c/bridge_test.cc             |  4 +---
 cpp/src/arrow/device.h                     |  4 +---
 cpp/src/arrow/gpu/ArrowCUDAConfig.cmake.in |  4 ++++
 cpp/src/arrow/gpu/CMakeLists.txt           |  8 ++++++--
 cpp/src/arrow/gpu/arrow-cuda.pc.in         |  2 +-
 cpp/src/arrow/gpu/cuda_context.cc          | 10 +++++-----
 cpp/src/arrow/gpu/cuda_context.h           |  2 +-
 7 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/cpp/src/arrow/c/bridge_test.cc b/cpp/src/arrow/c/bridge_test.cc
index 2aedccc965c45..bd0e498a9f332 100644
--- a/cpp/src/arrow/c/bridge_test.cc
+++ b/cpp/src/arrow/c/bridge_test.cc
@@ -1222,9 +1222,7 @@ class MyDevice : public Device {
 
     virtual ~MySyncEvent() = default;
     Status Wait() override { return Status::OK(); }
-    Status Record(const Device::Stream&, const unsigned int) override {
-      return Status::OK();
-    }
+    Status Record(const Device::Stream&) override { return Status::OK(); }
   };
 
  protected:
diff --git a/cpp/src/arrow/device.h b/cpp/src/arrow/device.h
index 066ca7e32a4fe..efb0a5ab400a1 100644
--- a/cpp/src/arrow/device.h
+++ b/cpp/src/arrow/device.h
@@ -166,11 +166,9 @@ class ARROW_EXPORT Device : public std::enable_shared_from_this<Device>,
     /// @brief Block until sync event is completed.
     virtual Status Wait() = 0;
 
-    inline Status Record(const Stream& st) { return Record(st, 0); }
-
     /// @brief Record the wrapped event on the stream so it triggers
     /// the event when the stream gets to that point in its queue.
-    virtual Status Record(const Stream&, const unsigned int flags) = 0;
+    virtual Status Record(const Stream&) = 0;
 
    protected:
     /// If creating this with a passed in event, the caller must ensure
diff --git a/cpp/src/arrow/gpu/ArrowCUDAConfig.cmake.in b/cpp/src/arrow/gpu/ArrowCUDAConfig.cmake.in
index bb36abf241193..626c536a08d5e 100644
--- a/cpp/src/arrow/gpu/ArrowCUDAConfig.cmake.in
+++ b/cpp/src/arrow/gpu/ArrowCUDAConfig.cmake.in
@@ -30,6 +30,10 @@ include(CMakeFindDependencyMacro)
 find_dependency(Arrow)
 if(CMAKE_VERSION VERSION_LESS 3.17)
   find_package(CUDA REQUIRED)
+  add_library(ArrowCUDA::cuda_driver SHARED IMPORTED)
+  set_target_properties(ArrowCUDA::cuda_driver
+                        PROPERTIES IMPORTED_LOCATION "${CUDA_CUDA_LIBRARY}"
+                                   INTERFACE_INCLUDE_DIRECTORIES "${CUDA_INCLUDE_DIRS}")
 else()
   find_package(CUDAToolkit REQUIRED)
 endif()
diff --git a/cpp/src/arrow/gpu/CMakeLists.txt b/cpp/src/arrow/gpu/CMakeLists.txt
index 2556f30f0d5e6..a5b176793e495 100644
--- a/cpp/src/arrow/gpu/CMakeLists.txt
+++ b/cpp/src/arrow/gpu/CMakeLists.txt
@@ -32,8 +32,11 @@ endif()
 set(ARROW_CUDA_LINK_LIBS arrow::flatbuffers)
 if(CMAKE_VERSION VERSION_LESS 3.17)
   find_package(CUDA REQUIRED)
-  set(ARROW_CUDA_SHARED_LINK_LIBS ${CUDA_CUDA_LIBRARY})
-  include_directories(SYSTEM ${CUDA_INCLUDE_DIRS})
+  add_library(ArrowCUDA::cuda_driver SHARED IMPORTED)
+  set_target_properties(ArrowCUDA::cuda_driver
+                        PROPERTIES IMPORTED_LOCATION "${CUDA_CUDA_LIBRARY}"
+                                   INTERFACE_INCLUDE_DIRECTORIES "${CUDA_INCLUDE_DIRS}")
+  set(ARROW_CUDA_SHARED_LINK_LIBS ArrowCUDA::cuda_driver)
 else()
   # find_package(CUDA) is deprecated, and for newer CUDA, it doesn't
   # recognize that the CUDA driver library is in the "stubs" dir, but
@@ -61,6 +64,7 @@ add_arrow_lib(arrow_cuda
               ${ARROW_CUDA_SHARED_LINK_LIBS}
               SHARED_INSTALL_INTERFACE_LIBS
               Arrow::arrow_shared
+              ${ARROW_CUDA_SHARED_LINK_LIBS}
               # Static arrow_cuda must also link against CUDA shared libs
               STATIC_LINK_LIBS
               ${ARROW_CUDA_LINK_LIBS}
diff --git a/cpp/src/arrow/gpu/arrow-cuda.pc.in b/cpp/src/arrow/gpu/arrow-cuda.pc.in
index 84c8c5889856e..173d7d91ef9b5 100644
--- a/cpp/src/arrow/gpu/arrow-cuda.pc.in
+++ b/cpp/src/arrow/gpu/arrow-cuda.pc.in
@@ -22,6 +22,6 @@ libdir=@ARROW_PKG_CONFIG_LIBDIR@
 Name: Apache Arrow CUDA
 Description: CUDA integration library for Apache Arrow
 Version: @ARROW_VERSION@
-Requires: arrow
+Requires: arrow cuda
 Libs: -L${libdir} -larrow_cuda
 Cflags: -I${includedir}
diff --git a/cpp/src/arrow/gpu/cuda_context.cc b/cpp/src/arrow/gpu/cuda_context.cc
index fb8935319ed1c..81542d339bd70 100644
--- a/cpp/src/arrow/gpu/cuda_context.cc
+++ b/cpp/src/arrow/gpu/cuda_context.cc
@@ -322,8 +322,9 @@ Status CudaDevice::Stream::WaitEvent(const Device::SyncEvent& event) {
   }
 
   ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
-  CU_RETURN_NOT_OK("cuStreamWaitEvent",
-                   cuStreamWaitEvent(value(), cu_event, CU_EVENT_WAIT_DEFAULT));
+  // we are currently building with CUDA toolkit 11.0.3 which doesn't have enum
+  // values for the flags yet. The "flags" param *must* be 0 for now.
+  CU_RETURN_NOT_OK("cuStreamWaitEvent", cuStreamWaitEvent(value(), cu_event, 0));
   return Status::OK();
 }
 
@@ -339,15 +340,14 @@ Status CudaDevice::SyncEvent::Wait() {
   return Status::OK();
 }
 
-Status CudaDevice::SyncEvent::Record(const Device::Stream& st, const unsigned int flags) {
+Status CudaDevice::SyncEvent::Record(const Device::Stream& st) {
   auto cuda_stream = checked_cast<const CudaDevice::Stream*, const Device::Stream*>(&st);
   if (!cuda_stream) {
     return Status::Invalid("CudaDevice::Event cannot record on non-cuda stream");
   }
 
   ContextSaver set_temporary(reinterpret_cast<CUcontext>(context_.get()->handle()));
-  CU_RETURN_NOT_OK("cuEventRecordWithFlags",
-                   cuEventRecordWithFlags(value(), cuda_stream->value(), flags));
+  CU_RETURN_NOT_OK("cuEventRecord", cuEventRecord(value(), cuda_stream->value()));
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/gpu/cuda_context.h b/cpp/src/arrow/gpu/cuda_context.h
index e4d8482855f6b..56c4f3203524f 100644
--- a/cpp/src/arrow/gpu/cuda_context.h
+++ b/cpp/src/arrow/gpu/cuda_context.h
@@ -212,7 +212,7 @@ class ARROW_EXPORT CudaDevice : public Device {
     ///
     /// Once the stream completes the tasks previously added to it,
     /// it will trigger the event.
-    Status Record(const Device::Stream&, const unsigned int) override;
+    Status Record(const Device::Stream&) override;
 
    protected:
     friend class CudaMemoryManager;

From d5cc9d9a7d9a89eb6961bbbc1430b705bf696ace Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 5 Sep 2023 20:05:02 +0200
Subject: [PATCH 320/749] GH-37567: [C++] Migrate JSON Integration code to
 Result<> (#37573)

### Rationale for this change

The JSON Integration APIs still use the old-style of returning `Status` together with a `T*` out-parameter.
While those are internal APIs, it would still improve ease of us to migrate them to the newer idiom of returning a `Result<T>`.

### What changes are included in this PR?

Migrate the relevant APIs from `Status` to `Result`. Since the APIs are internal, no deprecation period is introduced.

Also, some very minor style and testing cleanups here and there.

### Are these changes tested?

By existing tests.

### Are there any user-facing changes?

No.

* Closes: #37567

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../test_integration_client.cc                |  10 +-
 cpp/src/arrow/ipc/type_fwd.h                  |   3 +
 cpp/src/arrow/testing/json_integration.cc     |  58 ++--
 cpp/src/arrow/testing/json_integration.h      |  59 ++--
 .../arrow/testing/json_integration_test.cc    | 103 +++----
 cpp/src/arrow/testing/json_internal.cc        | 279 ++++++++----------
 cpp/src/arrow/testing/json_internal.h         |  41 +--
 dev/archery/archery/cli.py                    |   2 +
 8 files changed, 232 insertions(+), 323 deletions(-)

diff --git a/cpp/src/arrow/flight/integration_tests/test_integration_client.cc b/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
index 9c5c985c06efd..db72c9f4b0613 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
@@ -56,11 +56,10 @@ namespace integration_tests {
 /// \brief Helper to read all batches from a JsonReader
 Status ReadBatches(std::unique_ptr<testing::IntegrationJsonReader>& reader,
                    std::vector<std::shared_ptr<RecordBatch>>* chunks) {
-  std::shared_ptr<RecordBatch> chunk;
   for (int i = 0; i < reader->num_record_batches(); i++) {
-    RETURN_NOT_OK(reader->ReadRecordBatch(i, &chunk));
+    ARROW_ASSIGN_OR_RAISE(auto chunk, reader->ReadRecordBatch(i));
     RETURN_NOT_OK(chunk->ValidateFull());
-    chunks->push_back(chunk);
+    chunks->push_back(std::move(chunk));
   }
   return Status::OK();
 }
@@ -150,11 +149,10 @@ class IntegrationTestScenario : public Scenario {
     FlightDescriptor descr{FlightDescriptor::PATH, "", {FLAGS_path}};
 
     // 1. Put the data to the server.
-    std::unique_ptr<testing::IntegrationJsonReader> reader;
     std::cout << "Opening JSON file '" << FLAGS_path << "'" << std::endl;
     auto in_file = *io::ReadableFile::Open(FLAGS_path);
-    ABORT_NOT_OK(
-        testing::IntegrationJsonReader::Open(default_memory_pool(), in_file, &reader));
+    ARROW_ASSIGN_OR_RAISE(auto reader, testing::IntegrationJsonReader::Open(
+                                           default_memory_pool(), in_file));
 
     std::shared_ptr<Schema> original_schema = reader->schema();
     std::vector<std::shared_ptr<RecordBatch>> original_data;
diff --git a/cpp/src/arrow/ipc/type_fwd.h b/cpp/src/arrow/ipc/type_fwd.h
index 3493c4f1409a9..b0d3afa922f78 100644
--- a/cpp/src/arrow/ipc/type_fwd.h
+++ b/cpp/src/arrow/ipc/type_fwd.h
@@ -56,6 +56,9 @@ class RecordBatchStreamReader;
 class RecordBatchFileReader;
 class RecordBatchWriter;
 
+class DictionaryFieldMapper;
+class DictionaryMemo;
+
 namespace feather {
 
 class Reader;
diff --git a/cpp/src/arrow/testing/json_integration.cc b/cpp/src/arrow/testing/json_integration.cc
index a6bed8ca195a1..e87566502b1dc 100644
--- a/cpp/src/arrow/testing/json_integration.cc
+++ b/cpp/src/arrow/testing/json_integration.cc
@@ -37,8 +37,6 @@
 #include <rapidjson/stringbuffer.h>
 #include <rapidjson/writer.h>
 
-using std::size_t;
-
 namespace arrow {
 
 using ipc::DictionaryFieldMapper;
@@ -82,12 +80,11 @@ class IntegrationJsonWriter::Impl {
     return Status::OK();
   }
 
-  Status Finish(std::string* result) {
+  Result<std::string> Finish() {
     writer_->EndArray();  // Record batches
     writer_->EndObject();
 
-    *result = string_buffer_.GetString();
-    return Status::OK();
+    return string_buffer_.GetString();
   }
 
   Status WriteRecordBatch(const RecordBatch& batch) {
@@ -115,15 +112,14 @@ IntegrationJsonWriter::IntegrationJsonWriter(const std::shared_ptr<Schema>& sche
 
 IntegrationJsonWriter::~IntegrationJsonWriter() {}
 
-Status IntegrationJsonWriter::Open(const std::shared_ptr<Schema>& schema,
-                                   std::unique_ptr<IntegrationJsonWriter>* writer) {
-  *writer = std::unique_ptr<IntegrationJsonWriter>(new IntegrationJsonWriter(schema));
-  return (*writer)->impl_->Start();
+Result<std::unique_ptr<IntegrationJsonWriter>> IntegrationJsonWriter::Open(
+    const std::shared_ptr<Schema>& schema) {
+  auto writer = std::unique_ptr<IntegrationJsonWriter>(new IntegrationJsonWriter(schema));
+  RETURN_NOT_OK(writer->impl_->Start());
+  return writer;
 }
 
-Status IntegrationJsonWriter::Finish(std::string* result) {
-  return impl_->Finish(result);
-}
+Result<std::string> IntegrationJsonWriter::Finish() { return impl_->Finish(); }
 
 Status IntegrationJsonWriter::WriteRecordBatch(const RecordBatch& batch) {
   return impl_->WriteRecordBatch(batch);
@@ -144,7 +140,7 @@ class IntegrationJsonReader::Impl {
       return Status::IOError("JSON parsing failed");
     }
 
-    RETURN_NOT_OK(json::ReadSchema(doc_, pool_, &dictionary_memo_, &schema_));
+    ARROW_ASSIGN_OR_RAISE(schema_, json::ReadSchema(doc_, pool_, &dictionary_memo_));
 
     auto it = std::as_const(doc_).FindMember("batches");
     RETURN_NOT_ARRAY("batches", it, doc_);
@@ -153,13 +149,13 @@ class IntegrationJsonReader::Impl {
     return Status::OK();
   }
 
-  Status ReadRecordBatch(int i, std::shared_ptr<RecordBatch>* batch) {
+  Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(int i) {
     DCHECK_GE(i, 0) << "i out of bounds";
     DCHECK_LT(i, static_cast<int>(record_batches_->GetArray().Size()))
         << "i out of bounds";
 
     return json::ReadRecordBatch(record_batches_->GetArray()[i], schema_,
-                                 &dictionary_memo_, pool_, batch);
+                                 &dictionary_memo_, pool_);
   }
 
   std::shared_ptr<Schema> schema() const { return schema_; }
@@ -179,29 +175,30 @@ class IntegrationJsonReader::Impl {
 };
 
 IntegrationJsonReader::IntegrationJsonReader(MemoryPool* pool,
-                                             const std::shared_ptr<Buffer>& data) {
-  impl_.reset(new Impl(pool, data));
+                                             std::shared_ptr<Buffer> data) {
+  impl_.reset(new Impl(pool, std::move(data)));
 }
 
 IntegrationJsonReader::~IntegrationJsonReader() {}
 
-Status IntegrationJsonReader::Open(const std::shared_ptr<Buffer>& data,
-                                   std::unique_ptr<IntegrationJsonReader>* reader) {
-  return Open(default_memory_pool(), data, reader);
+Result<std::unique_ptr<IntegrationJsonReader>> IntegrationJsonReader::Open(
+    MemoryPool* pool, std::shared_ptr<Buffer> data) {
+  auto reader = std::unique_ptr<IntegrationJsonReader>(
+      new IntegrationJsonReader(pool, std::move(data)));
+  RETURN_NOT_OK(reader->impl_->ParseAndReadSchema());
+  return reader;
 }
 
-Status IntegrationJsonReader::Open(MemoryPool* pool, const std::shared_ptr<Buffer>& data,
-                                   std::unique_ptr<IntegrationJsonReader>* reader) {
-  *reader = std::unique_ptr<IntegrationJsonReader>(new IntegrationJsonReader(pool, data));
-  return (*reader)->impl_->ParseAndReadSchema();
+Result<std::unique_ptr<IntegrationJsonReader>> IntegrationJsonReader::Open(
+    std::shared_ptr<Buffer> data) {
+  return Open(default_memory_pool(), std::move(data));
 }
 
-Status IntegrationJsonReader::Open(MemoryPool* pool,
-                                   const std::shared_ptr<io::ReadableFile>& in_file,
-                                   std::unique_ptr<IntegrationJsonReader>* reader) {
+Result<std::unique_ptr<IntegrationJsonReader>> IntegrationJsonReader::Open(
+    MemoryPool* pool, const std::shared_ptr<io::ReadableFile>& in_file) {
   ARROW_ASSIGN_OR_RAISE(int64_t file_size, in_file->GetSize());
   ARROW_ASSIGN_OR_RAISE(auto json_buffer, in_file->Read(file_size));
-  return Open(pool, json_buffer, reader);
+  return Open(pool, std::move(json_buffer));
 }
 
 std::shared_ptr<Schema> IntegrationJsonReader::schema() const { return impl_->schema(); }
@@ -210,9 +207,8 @@ int IntegrationJsonReader::num_record_batches() const {
   return impl_->num_record_batches();
 }
 
-Status IntegrationJsonReader::ReadRecordBatch(int i,
-                                              std::shared_ptr<RecordBatch>* batch) const {
-  return impl_->ReadRecordBatch(i, batch);
+Result<std::shared_ptr<RecordBatch>> IntegrationJsonReader::ReadRecordBatch(int i) const {
+  return impl_->ReadRecordBatch(i);
 }
 
 }  // namespace testing
diff --git a/cpp/src/arrow/testing/json_integration.h b/cpp/src/arrow/testing/json_integration.h
index 3486bb5d958be..c2d0c104a6077 100644
--- a/cpp/src/arrow/testing/json_integration.h
+++ b/cpp/src/arrow/testing/json_integration.h
@@ -22,21 +22,12 @@
 #include <memory>
 #include <string>
 
-#include "arrow/status.h"
+#include "arrow/io/type_fwd.h"
+#include "arrow/result.h"
 #include "arrow/testing/visibility.h"
+#include "arrow/type_fwd.h"
 
-namespace arrow {
-
-class Buffer;
-class MemoryPool;
-class RecordBatch;
-class Schema;
-
-namespace io {
-class ReadableFile;
-}  // namespace io
-
-namespace testing {
+namespace arrow::testing {
 
 /// \class IntegrationJsonWriter
 /// \brief Write the JSON representation of an Arrow record batch file or stream
@@ -49,19 +40,17 @@ class ARROW_TESTING_EXPORT IntegrationJsonWriter {
   /// \brief Create a new JSON writer that writes to memory
   ///
   /// \param[in] schema the schema of record batches
-  /// \param[out] out the returned writer object
-  /// \return Status
-  static Status Open(const std::shared_ptr<Schema>& schema,
-                     std::unique_ptr<IntegrationJsonWriter>* out);
+  /// \return the creater writer object
+  static Result<std::unique_ptr<IntegrationJsonWriter>> Open(
+      const std::shared_ptr<Schema>& schema);
 
   /// \brief Append a record batch
   Status WriteRecordBatch(const RecordBatch& batch);
 
   /// \brief Finish the JSON payload and return as a std::string
   ///
-  /// \param[out] result the JSON as as a std::string
-  /// \return Status
-  Status Finish(std::string* result);
+  /// \return the JSON payload as a string
+  Result<std::string> Finish();
 
  private:
   explicit IntegrationJsonWriter(const std::shared_ptr<Schema>& schema);
@@ -83,27 +72,24 @@ class ARROW_TESTING_EXPORT IntegrationJsonReader {
   ///
   /// \param[in] pool a MemoryPool to use for buffer allocations
   /// \param[in] data a Buffer containing the JSON data
-  /// \param[out] reader the returned reader object
-  /// \return Status
-  static Status Open(MemoryPool* pool, const std::shared_ptr<Buffer>& data,
-                     std::unique_ptr<IntegrationJsonReader>* reader);
+  /// \return the created JSON reader
+  static Result<std::unique_ptr<IntegrationJsonReader>> Open(
+      MemoryPool* pool, std::shared_ptr<Buffer> data);
 
   /// \brief Create a new JSON reader that uses the default memory pool
   ///
   /// \param[in] data a Buffer containing the JSON data
-  /// \param[out] reader the returned reader object
-  /// \return Status
-  static Status Open(const std::shared_ptr<Buffer>& data,
-                     std::unique_ptr<IntegrationJsonReader>* reader);
+  /// \return the created JSON reader
+  static Result<std::unique_ptr<IntegrationJsonReader>> Open(
+      std::shared_ptr<Buffer> data);
 
   /// \brief Create a new JSON reader from a file
   ///
   /// \param[in] pool a MemoryPool to use for buffer allocations
   /// \param[in] in_file a ReadableFile containing JSON data
-  /// \param[out] reader the returned reader object
-  /// \return Status
-  static Status Open(MemoryPool* pool, const std::shared_ptr<io::ReadableFile>& in_file,
-                     std::unique_ptr<IntegrationJsonReader>* reader);
+  /// \return the created JSON reader
+  static Result<std::unique_ptr<IntegrationJsonReader>> Open(
+      MemoryPool* pool, const std::shared_ptr<io::ReadableFile>& in_file);
 
   /// \brief Return the schema read from the JSON
   std::shared_ptr<Schema> schema() const;
@@ -114,16 +100,15 @@ class ARROW_TESTING_EXPORT IntegrationJsonReader {
   /// \brief Read a particular record batch from the file
   ///
   /// \param[in] i the record batch index, does not boundscheck
-  /// \param[out] batch the read record batch
-  Status ReadRecordBatch(int i, std::shared_ptr<RecordBatch>* batch) const;
+  /// \return the record batch read
+  Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(int i) const;
 
  private:
-  IntegrationJsonReader(MemoryPool* pool, const std::shared_ptr<Buffer>& data);
+  IntegrationJsonReader(MemoryPool* pool, std::shared_ptr<Buffer> data);
 
   // Hide RapidJSON details from public API
   class Impl;
   std::unique_ptr<Impl> impl_;
 };
 
-}  // namespace testing
-}  // namespace arrow
+}  // namespace arrow::testing
diff --git a/cpp/src/arrow/testing/json_integration_test.cc b/cpp/src/arrow/testing/json_integration_test.cc
index 7f1c706684d42..e950d36ce00d7 100644
--- a/cpp/src/arrow/testing/json_integration_test.cc
+++ b/cpp/src/arrow/testing/json_integration_test.cc
@@ -86,8 +86,7 @@ static Status ConvertJsonToArrow(const std::string& json_path,
   ARROW_ASSIGN_OR_RAISE(int64_t file_size, in_file->GetSize());
   ARROW_ASSIGN_OR_RAISE(auto json_buffer, in_file->Read(file_size));
 
-  std::unique_ptr<IntegrationJsonReader> reader;
-  RETURN_NOT_OK(IntegrationJsonReader::Open(json_buffer, &reader));
+  ARROW_ASSIGN_OR_RAISE(auto reader, IntegrationJsonReader::Open(json_buffer));
 
   if (FLAGS_verbose) {
     std::cout << "Found schema:\n"
@@ -97,8 +96,7 @@ static Status ConvertJsonToArrow(const std::string& json_path,
   ARROW_ASSIGN_OR_RAISE(auto writer, ipc::MakeFileWriter(out_file, reader->schema(),
                                                          IpcWriteOptions::Defaults()));
   for (int i = 0; i < reader->num_record_batches(); ++i) {
-    std::shared_ptr<RecordBatch> batch;
-    RETURN_NOT_OK(reader->ReadRecordBatch(i, &batch));
+    ARROW_ASSIGN_OR_RAISE(auto batch, reader->ReadRecordBatch(i));
     RETURN_NOT_OK(writer->WriteRecordBatch(*batch));
   }
   return writer->Close();
@@ -117,17 +115,15 @@ static Status ConvertArrowToJson(const std::string& arrow_path,
     std::cout << "Found schema:\n" << reader->schema()->ToString() << std::endl;
   }
 
-  std::unique_ptr<IntegrationJsonWriter> writer;
-  RETURN_NOT_OK(IntegrationJsonWriter::Open(reader->schema(), &writer));
+  ARROW_ASSIGN_OR_RAISE(auto writer, IntegrationJsonWriter::Open(reader->schema()));
 
   for (int i = 0; i < reader->num_record_batches(); ++i) {
     ARROW_ASSIGN_OR_RAISE(std::shared_ptr<RecordBatch> batch, reader->ReadRecordBatch(i));
     RETURN_NOT_OK(writer->WriteRecordBatch(*batch));
   }
 
-  std::string result;
-  RETURN_NOT_OK(writer->Finish(&result));
-  return out_file->Write(result.c_str(), static_cast<int64_t>(result.size()));
+  ARROW_ASSIGN_OR_RAISE(auto json_data, writer->Finish());
+  return out_file->Write(std::string_view(json_data));
 }
 
 // Validate the batch, accounting for the -validate_decimals , -validate_date64, and
@@ -162,8 +158,7 @@ static Status ValidateArrowVsJson(const std::string& arrow_path,
   ARROW_ASSIGN_OR_RAISE(int64_t file_size, json_file->GetSize());
   ARROW_ASSIGN_OR_RAISE(auto json_buffer, json_file->Read(file_size));
 
-  std::unique_ptr<IntegrationJsonReader> json_reader;
-  RETURN_NOT_OK(IntegrationJsonReader::Open(json_buffer, &json_reader));
+  ARROW_ASSIGN_OR_RAISE(auto json_reader, IntegrationJsonReader::Open(json_buffer));
 
   // Construct Arrow reader
   ARROW_ASSIGN_OR_RAISE(auto arrow_file, io::ReadableFile::Open(arrow_path));
@@ -198,7 +193,7 @@ static Status ValidateArrowVsJson(const std::string& arrow_path,
   std::shared_ptr<RecordBatch> arrow_batch;
   std::shared_ptr<RecordBatch> json_batch;
   for (int i = 0; i < json_nbatches; ++i) {
-    RETURN_NOT_OK(json_reader->ReadRecordBatch(i, &json_batch));
+    ARROW_ASSIGN_OR_RAISE(json_batch, json_reader->ReadRecordBatch(i));
     ARROW_ASSIGN_OR_RAISE(arrow_batch, arrow_reader->ReadRecordBatch(i));
     Status valid_st = ValidateFull(*json_batch);
     if (!valid_st.ok()) {
@@ -729,14 +724,14 @@ static const char* json_example6 = R"example(
 }
 )example";
 
-void TestSchemaRoundTrip(const Schema& schema) {
+void TestSchemaRoundTrip(const std::shared_ptr<Schema>& schema) {
   rj::StringBuffer sb;
   rj::Writer<rj::StringBuffer> writer(sb);
 
-  DictionaryFieldMapper mapper(schema);
+  DictionaryFieldMapper mapper(*schema);
 
   writer.StartObject();
-  ASSERT_OK(json::WriteSchema(schema, mapper, &writer));
+  ASSERT_OK(json::WriteSchema(*schema, mapper, &writer));
   writer.EndObject();
 
   std::string json_schema = sb.GetString();
@@ -747,15 +742,9 @@ void TestSchemaRoundTrip(const Schema& schema) {
   d.Parse(json_schema.data(), json_schema.size());
 
   DictionaryMemo in_memo;
-  std::shared_ptr<Schema> out;
-  const auto status = json::ReadSchema(d, default_memory_pool(), &in_memo, &out);
-  if (!status.ok()) {
-    FAIL() << "Unable to read JSON schema: " << json_schema << "\nStatus: " << status;
-  }
-
-  if (!schema.Equals(*out)) {
-    FAIL() << "In schema: " << schema.ToString() << "\nOut schema: " << out->ToString();
-  }
+  ASSERT_OK_AND_ASSIGN(auto result_schema,
+                       json::ReadSchema(d, default_memory_pool(), &in_memo));
+  AssertSchemaEqual(schema, result_schema, /*check_metadata=*/true);
 }
 
 void TestArrayRoundTrip(const Array& array) {
@@ -772,17 +761,17 @@ void TestArrayRoundTrip(const Array& array) {
   // Pass explicit size to avoid ASAN issues with
   // SIMD loads in RapidJson.
   d.Parse(array_as_json.data(), array_as_json.size());
-
   if (d.HasParseError()) {
     FAIL() << "JSON parsing failed";
   }
 
-  std::shared_ptr<Array> out;
-  ASSERT_OK(json::ReadArray(default_memory_pool(), d, ::arrow::field(name, array.type()),
-                            &out));
+  ASSERT_OK_AND_ASSIGN(
+      auto result_array,
+      json::ReadArray(default_memory_pool(), d, ::arrow::field(name, array.type())));
+  ASSERT_OK(result_array->ValidateFull());
 
   // std::cout << array_as_json << std::endl;
-  CompareArraysDetailed(0, *out, array);
+  CompareArraysDetailed(0, *result_array, array);
 }
 
 template <typename T, typename ValueType>
@@ -823,6 +812,7 @@ TEST(TestJsonSchemaWriter, FlatTypes) {
       field("f11", binary()),
       field("f12", list(int32())),
       field("f13", struct_({field("s1", int32()), field("s2", utf8())})),
+      field("f14", date32()),
       field("f15", date64()),
       field("f16", timestamp(TimeUnit::NANO)),
       field("f17", time64(TimeUnit::MICRO)),
@@ -836,7 +826,7 @@ TEST(TestJsonSchemaWriter, FlatTypes) {
       field("f23", run_end_encoded(int64(), utf8())),
   };
 
-  Schema schema(fields);
+  auto schema = ::arrow::schema(fields);
   TestSchemaRoundTrip(schema);
 }
 
@@ -982,8 +972,7 @@ TEST(TestJsonFileReadWrite, BasicRoundTrip) {
       ::arrow::schema({field("f1", v1_type), field("f2", v2_type), field("f3", v3_type),
                        field("f4", v4_type), field("f5", v5_type)});
 
-  std::unique_ptr<IntegrationJsonWriter> writer;
-  ASSERT_OK(IntegrationJsonWriter::Open(schema, &writer));
+  ASSERT_OK_AND_ASSIGN(auto writer, IntegrationJsonWriter::Open(schema));
 
   const int nbatches = 3;
   std::vector<std::shared_ptr<RecordBatch>> batches;
@@ -997,21 +986,17 @@ TEST(TestJsonFileReadWrite, BasicRoundTrip) {
     ASSERT_OK(writer->WriteRecordBatch(*batch));
   }
 
-  std::string result;
-  ASSERT_OK(writer->Finish(&result));
+  ASSERT_OK_AND_ASSIGN(auto json_data, writer->Finish());
 
-  std::unique_ptr<IntegrationJsonReader> reader;
-
-  auto buffer = std::make_shared<Buffer>(result);
-
-  ASSERT_OK(IntegrationJsonReader::Open(buffer, &reader));
-  ASSERT_TRUE(reader->schema()->Equals(*schema));
+  ASSERT_OK_AND_ASSIGN(auto reader,
+                       IntegrationJsonReader::Open(std::make_shared<Buffer>(json_data)));
+  AssertSchemaEqual(reader->schema(), schema, /*check_metadata=*/true);
 
   ASSERT_EQ(nbatches, reader->num_record_batches());
 
   for (int i = 0; i < nbatches; ++i) {
-    std::shared_ptr<RecordBatch> batch;
-    ASSERT_OK(reader->ReadRecordBatch(i, &batch));
+    ASSERT_OK_AND_ASSIGN(auto batch, reader->ReadRecordBatch(i));
+    ASSERT_OK(batch->ValidateFull());
     ASSERT_BATCHES_EQUAL(*batch, *batches[i]);
   }
 }
@@ -1020,13 +1005,13 @@ static void ReadOneBatchJson(const char* json, const Schema& expected_schema,
                              std::shared_ptr<RecordBatch>* out) {
   auto buffer = Buffer::Wrap(json, strlen(json));
 
-  std::unique_ptr<IntegrationJsonReader> reader;
-  ASSERT_OK(IntegrationJsonReader::Open(buffer, &reader));
+  ASSERT_OK_AND_ASSIGN(auto reader, IntegrationJsonReader::Open(buffer));
 
   AssertSchemaEqual(*reader->schema(), expected_schema, /*check_metadata=*/true);
   ASSERT_EQ(1, reader->num_record_batches());
 
-  ASSERT_OK(reader->ReadRecordBatch(0, out));
+  ASSERT_OK_AND_ASSIGN(*out, reader->ReadRecordBatch(0));
+  ASSERT_OK((*out)->ValidateFull());
 }
 
 TEST(TestJsonFileReadWrite, JsonExample1) {
@@ -1047,11 +1032,10 @@ TEST(TestJsonFileReadWrite, JsonExample2) {
   auto uuid_type = uuid();
   auto buffer = Buffer::Wrap(json_example2, strlen(json_example2));
 
-  std::unique_ptr<IntegrationJsonReader> reader;
   {
     ExtensionTypeGuard ext_guard(uuid_type);
 
-    ASSERT_OK(IntegrationJsonReader::Open(buffer, &reader));
+    ASSERT_OK_AND_ASSIGN(auto reader, IntegrationJsonReader::Open(buffer));
     // The second field is an unregistered extension and will be read as
     // its underlying storage.
     Schema ex_schema({field("uuids", uuid_type), field("things", null())});
@@ -1059,8 +1043,8 @@ TEST(TestJsonFileReadWrite, JsonExample2) {
     AssertSchemaEqual(ex_schema, *reader->schema());
     ASSERT_EQ(1, reader->num_record_batches());
 
-    std::shared_ptr<RecordBatch> batch;
-    ASSERT_OK(reader->ReadRecordBatch(0, &batch));
+    ASSERT_OK_AND_ASSIGN(auto batch, reader->ReadRecordBatch(0));
+    ASSERT_OK(batch->ValidateFull());
 
     auto storage_array =
         ArrayFromJSON(fixed_size_binary(16), R"(["0123456789abcdef", null])");
@@ -1070,7 +1054,7 @@ TEST(TestJsonFileReadWrite, JsonExample2) {
   }
 
   // Should fail now that the Uuid extension is unregistered
-  ASSERT_RAISES(KeyError, IntegrationJsonReader::Open(buffer, &reader));
+  ASSERT_RAISES(KeyError, IntegrationJsonReader::Open(buffer));
 }
 
 TEST(TestJsonFileReadWrite, JsonExample3) {
@@ -1139,22 +1123,17 @@ class TestJsonRoundTrip : public ::testing::TestWithParam<MakeRecordBatch*> {
 void CheckRoundtrip(const RecordBatch& batch) {
   ExtensionTypeGuard guard({uuid(), dict_extension_type(), complex128()});
 
-  TestSchemaRoundTrip(*batch.schema());
+  TestSchemaRoundTrip(batch.schema());
 
-  std::unique_ptr<IntegrationJsonWriter> writer;
-  ASSERT_OK(IntegrationJsonWriter::Open(batch.schema(), &writer));
+  ASSERT_OK_AND_ASSIGN(auto writer, IntegrationJsonWriter::Open(batch.schema()));
   ASSERT_OK(writer->WriteRecordBatch(batch));
 
-  std::string result;
-  ASSERT_OK(writer->Finish(&result));
-
-  auto buffer = std::make_shared<Buffer>(result);
-
-  std::unique_ptr<IntegrationJsonReader> reader;
-  ASSERT_OK(IntegrationJsonReader::Open(buffer, &reader));
+  ASSERT_OK_AND_ASSIGN(auto json_data, writer->Finish());
 
-  std::shared_ptr<RecordBatch> result_batch;
-  ASSERT_OK(reader->ReadRecordBatch(0, &result_batch));
+  ASSERT_OK_AND_ASSIGN(auto reader,
+                       IntegrationJsonReader::Open(std::make_shared<Buffer>(json_data)));
+  ASSERT_OK_AND_ASSIGN(auto result_batch, reader->ReadRecordBatch(0));
+  ASSERT_OK(result_batch->ValidateFull());
 
   // take care of float rounding error in the text representation
   ApproxCompareBatch(batch, *result_batch);
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/testing/json_internal.cc
index 81c4befbf2bdc..ead0625e7bf3d 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/testing/json_internal.cc
@@ -363,8 +363,7 @@ class SchemaWriter {
     return Status::OK();
   }
 
-  Status WriteChildren(const std::vector<std::shared_ptr<Field>>& children,
-                       FieldPosition field_pos) {
+  Status WriteChildren(const FieldVector& children, FieldPosition field_pos) {
     writer_->Key("children");
     writer_->StartArray();
     for (auto [i, field] : Zip(Enumerate<int>, children)) {
@@ -666,7 +665,7 @@ class ArrayWriter {
     // but that fails the Java parser (ARROW-11483).
   }
 
-  Status WriteChildren(const std::vector<std::shared_ptr<Field>>& fields,
+  Status WriteChildren(const FieldVector& fields,
                        const std::vector<std::shared_ptr<Array>>& arrays) {
     // NOTE: the Java parser fails on an empty "children" member (ARROW-11483).
     if (fields.size() == 0) return Status::OK();
@@ -822,77 +821,64 @@ Result<TimeUnit::type> GetMemberTimeUnit(const RjObject& obj, const std::string&
   return GetUnitFromString(unit_str);
 }
 
-Status GetInteger(const rj::Value::ConstObject& json_type,
-                  std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetInteger(const rj::Value::ConstObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const bool is_signed, GetMemberBool(json_type, "isSigned"));
   ARROW_ASSIGN_OR_RAISE(const int bit_width, GetMemberInt<int>(json_type, "bitWidth"));
 
   switch (bit_width) {
     case 8:
-      *type = is_signed ? int8() : uint8();
-      break;
+      return is_signed ? int8() : uint8();
     case 16:
-      *type = is_signed ? int16() : uint16();
-      break;
+      return is_signed ? int16() : uint16();
     case 32:
-      *type = is_signed ? int32() : uint32();
-      break;
+      return is_signed ? int32() : uint32();
     case 64:
-      *type = is_signed ? int64() : uint64();
-      break;
-    default:
-      return Status::Invalid("Invalid bit width: ", bit_width);
+      return is_signed ? int64() : uint64();
   }
-  return Status::OK();
+  return Status::Invalid("Invalid bit width: ", bit_width);
 }
 
-Status GetFloatingPoint(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetFloatingPoint(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const auto precision, GetMemberString(json_type, "precision"));
 
   if (precision == "DOUBLE") {
-    *type = float64();
+    return float64();
   } else if (precision == "SINGLE") {
-    *type = float32();
+    return float32();
   } else if (precision == "HALF") {
-    *type = float16();
-  } else {
-    return Status::Invalid("Invalid precision: ", precision);
+    return float16();
   }
-  return Status::OK();
+  return Status::Invalid("Invalid precision: ", precision);
 }
 
-Status GetMap(const RjObject& json_type,
-              const std::vector<std::shared_ptr<Field>>& children,
-              std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetMap(const RjObject& json_type,
+                                         const FieldVector& children) {
   if (children.size() != 1) {
     return Status::Invalid("Map must have exactly one child");
   }
 
   ARROW_ASSIGN_OR_RAISE(const bool keys_sorted, GetMemberBool(json_type, "keysSorted"));
-  return MapType::Make(children[0], keys_sorted).Value(type);
+  return MapType::Make(children[0], keys_sorted);
 }
 
-Status GetFixedSizeBinary(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetFixedSizeBinary(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const int32_t byte_width,
                         GetMemberInt<int32_t>(json_type, "byteWidth"));
-  *type = fixed_size_binary(byte_width);
-  return Status::OK();
+  return fixed_size_binary(byte_width);
 }
 
-Status GetFixedSizeList(const RjObject& json_type,
-                        const std::vector<std::shared_ptr<Field>>& children,
-                        std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetFixedSizeList(const RjObject& json_type,
+                                                   const FieldVector& children) {
   if (children.size() != 1) {
     return Status::Invalid("FixedSizeList must have exactly one child");
   }
 
   ARROW_ASSIGN_OR_RAISE(const int32_t list_size,
                         GetMemberInt<int32_t>(json_type, "listSize"));
-  *type = fixed_size_list(children[0], list_size);
-  return Status::OK();
+  return fixed_size_list(children[0], list_size);
 }
 
-Status GetDecimal(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetDecimal(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const int32_t precision,
                         GetMemberInt<int32_t>(json_type, "precision"));
   ARROW_ASSIGN_OR_RAISE(const int32_t scale, GetMemberInt<int32_t>(json_type, "scale"));
@@ -903,92 +889,82 @@ Status GetDecimal(const RjObject& json_type, std::shared_ptr<DataType>* type) {
   }
 
   if (bit_width == 128) {
-    *type = decimal128(precision, scale);
+    return decimal128(precision, scale);
   } else if (bit_width == 256) {
-    *type = decimal256(precision, scale);
-  } else {
-    return Status::Invalid("Only 128 bit and 256 Decimals are supported. Received",
-                           bit_width);
+    return decimal256(precision, scale);
   }
-  return Status::OK();
+  return Status::Invalid("Only 128 bit and 256 Decimals are supported. Received",
+                         bit_width);
 }
 
-Status GetDate(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetDate(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const auto unit_str, GetMemberString(json_type, "unit"));
 
   if (unit_str == "DAY") {
-    *type = date32();
+    return date32();
   } else if (unit_str == "MILLISECOND") {
-    *type = date64();
-  } else {
-    return Status::Invalid("Invalid date unit: ", unit_str);
+    return date64();
   }
-  return Status::OK();
+  return Status::Invalid("Invalid date unit: ", unit_str);
 }
 
-Status GetTime(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetTime(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const auto unit_str, GetMemberString(json_type, "unit"));
   ARROW_ASSIGN_OR_RAISE(const int bit_width, GetMemberInt<int>(json_type, "bitWidth"));
 
+  std::shared_ptr<DataType> type;
+
   if (unit_str == "SECOND") {
-    *type = time32(TimeUnit::SECOND);
+    type = time32(TimeUnit::SECOND);
   } else if (unit_str == "MILLISECOND") {
-    *type = time32(TimeUnit::MILLI);
+    type = time32(TimeUnit::MILLI);
   } else if (unit_str == "MICROSECOND") {
-    *type = time64(TimeUnit::MICRO);
+    type = time64(TimeUnit::MICRO);
   } else if (unit_str == "NANOSECOND") {
-    *type = time64(TimeUnit::NANO);
+    type = time64(TimeUnit::NANO);
   } else {
     return Status::Invalid("Invalid time unit: ", unit_str);
   }
 
-  const auto& fw_type = checked_cast<const FixedWidthType&>(**type);
-
+  const auto& fw_type = checked_cast<const FixedWidthType&>(*type);
   if (bit_width != fw_type.bit_width()) {
     return Status::Invalid("Indicated bit width does not match unit");
   }
-
-  return Status::OK();
+  return type;
 }
 
-Status GetDuration(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetDuration(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const TimeUnit::type unit, GetMemberTimeUnit(json_type, "unit"));
-  *type = duration(unit);
-  return Status::OK();
+  return duration(unit);
 }
 
-Status GetTimestamp(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetTimestamp(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const TimeUnit::type unit, GetMemberTimeUnit(json_type, "unit"));
 
   const auto& it_tz = json_type.FindMember("timezone");
   if (it_tz == json_type.MemberEnd()) {
-    *type = timestamp(unit);
+    return timestamp(unit);
   } else {
     RETURN_NOT_STRING("timezone", it_tz, json_type);
-    *type = timestamp(unit, it_tz->value.GetString());
+    return timestamp(unit, it_tz->value.GetString());
   }
-
-  return Status::OK();
 }
 
-Status GetInterval(const RjObject& json_type, std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetInterval(const RjObject& json_type) {
   ARROW_ASSIGN_OR_RAISE(const auto unit_str, GetMemberString(json_type, "unit"));
 
   if (unit_str == kDayTime) {
-    *type = day_time_interval();
+    return day_time_interval();
   } else if (unit_str == kYearMonth) {
-    *type = month_interval();
+    return month_interval();
   } else if (unit_str == kMonthDayNano) {
-    *type = month_day_nano_interval();
-  } else {
-    return Status::Invalid("Invalid interval unit: " + unit_str);
+    return month_day_nano_interval();
   }
-  return Status::OK();
+  return Status::Invalid("Invalid interval unit: " + unit_str);
 }
 
-Status GetUnion(const RjObject& json_type,
-                const std::vector<std::shared_ptr<Field>>& children,
-                std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetUnion(const RjObject& json_type,
+                                           const FieldVector& children) {
   ARROW_ASSIGN_OR_RAISE(const auto mode_str, GetMemberString(json_type, "mode"));
 
   UnionMode::type mode;
@@ -1012,17 +988,14 @@ Status GetUnion(const RjObject& json_type,
   }
 
   if (mode == UnionMode::SPARSE) {
-    *type = sparse_union(std::move(children), std::move(type_codes));
+    return sparse_union(std::move(children), std::move(type_codes));
   } else {
-    *type = dense_union(std::move(children), std::move(type_codes));
+    return dense_union(std::move(children), std::move(type_codes));
   }
-
-  return Status::OK();
 }
 
-Status GetRunEndEncoded(const RjObject& json_type,
-                        const std::vector<std::shared_ptr<Field>>& children,
-                        std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetRunEndEncoded(const RjObject& json_type,
+                                                   const FieldVector& children) {
   if (children.size() != 2) {
     return Status::Invalid("Run-end encoded array must have exactly 2 fields, but got ",
                            children.size());
@@ -1046,82 +1019,79 @@ Status GetRunEndEncoded(const RjObject& json_type,
   if (children[0]->nullable()) {
     return Status::Invalid("Run ends array should not be nullable");
   }
-  *type = run_end_encoded(children[0]->type(), children[1]->type());
-  return Status::OK();
+  return run_end_encoded(children[0]->type(), children[1]->type());
 }
 
-Status GetType(const RjObject& json_type,
-               const std::vector<std::shared_ptr<Field>>& children,
-               std::shared_ptr<DataType>* type) {
+Result<std::shared_ptr<DataType>> GetType(const RjObject& json_type,
+                                          const FieldVector& children) {
   ARROW_ASSIGN_OR_RAISE(const auto type_name, GetMemberString(json_type, "name"));
 
   if (type_name == "int") {
-    return GetInteger(json_type, type);
+    return GetInteger(json_type);
   } else if (type_name == "floatingpoint") {
-    return GetFloatingPoint(json_type, type);
+    return GetFloatingPoint(json_type);
   } else if (type_name == "bool") {
-    *type = boolean();
+    return boolean();
   } else if (type_name == "utf8") {
-    *type = utf8();
+    return utf8();
   } else if (type_name == "binary") {
-    *type = binary();
+    return binary();
   } else if (type_name == "largeutf8") {
-    *type = large_utf8();
+    return large_utf8();
   } else if (type_name == "largebinary") {
-    *type = large_binary();
+    return large_binary();
   } else if (type_name == "fixedsizebinary") {
-    return GetFixedSizeBinary(json_type, type);
+    return GetFixedSizeBinary(json_type);
   } else if (type_name == "decimal") {
-    return GetDecimal(json_type, type);
+    return GetDecimal(json_type);
   } else if (type_name == "null") {
-    *type = null();
+    return null();
   } else if (type_name == "date") {
-    return GetDate(json_type, type);
+    return GetDate(json_type);
   } else if (type_name == "time") {
-    return GetTime(json_type, type);
+    return GetTime(json_type);
   } else if (type_name == "timestamp") {
-    return GetTimestamp(json_type, type);
+    return GetTimestamp(json_type);
   } else if (type_name == "interval") {
-    return GetInterval(json_type, type);
+    return GetInterval(json_type);
   } else if (type_name == kDuration) {
-    return GetDuration(json_type, type);
+    return GetDuration(json_type);
   } else if (type_name == "list") {
     if (children.size() != 1) {
       return Status::Invalid("List must have exactly one child");
     }
-    *type = list(children[0]);
+    return list(children[0]);
   } else if (type_name == "largelist") {
     if (children.size() != 1) {
       return Status::Invalid("Large list must have exactly one child");
     }
-    *type = large_list(children[0]);
+    return large_list(children[0]);
   } else if (type_name == "map") {
-    return GetMap(json_type, children, type);
+    return GetMap(json_type, children);
   } else if (type_name == "fixedsizelist") {
-    return GetFixedSizeList(json_type, children, type);
+    return GetFixedSizeList(json_type, children);
   } else if (type_name == "struct") {
-    *type = struct_(children);
+    return struct_(children);
   } else if (type_name == "union") {
-    return GetUnion(json_type, children, type);
+    return GetUnion(json_type, children);
   } else if (type_name == "runendencoded") {
-    return GetRunEndEncoded(json_type, children, type);
-  } else {
-    return Status::Invalid("Unrecognized type name: ", type_name);
+    return GetRunEndEncoded(json_type, children);
   }
-  return Status::OK();
+  return Status::Invalid("Unrecognized type name: ", type_name);
 }
 
-Status GetField(const rj::Value& obj, FieldPosition field_pos,
-                DictionaryMemo* dictionary_memo, std::shared_ptr<Field>* field);
+Result<std::shared_ptr<Field>> GetField(const rj::Value& obj, FieldPosition field_pos,
+                                        DictionaryMemo* dictionary_memo);
 
-Status GetFieldsFromArray(const RjArray& json_fields, FieldPosition parent_pos,
-                          DictionaryMemo* dictionary_memo,
-                          std::vector<std::shared_ptr<Field>>* fields) {
-  fields->resize(json_fields.Size());
-  for (auto [json_field, field, i] : Zip(json_fields, *fields, Enumerate<int>)) {
-    RETURN_NOT_OK(GetField(json_field, parent_pos.child(i), dictionary_memo, &field));
+Result<FieldVector> GetFieldsFromArray(const RjArray& json_fields,
+                                       FieldPosition parent_pos,
+                                       DictionaryMemo* dictionary_memo) {
+  FieldVector fields(json_fields.Size());
+  for (auto [json_field, field, i] : Zip(json_fields, fields, Enumerate<int>)) {
+    ARROW_ASSIGN_OR_RAISE(field,
+                          GetField(json_field, parent_pos.child(i), dictionary_memo));
   }
-  return Status::OK();
+  return fields;
 }
 
 Status ParseDictionary(const RjObject& obj, int64_t* id, bool* is_ordered,
@@ -1135,16 +1105,16 @@ Status ParseDictionary(const RjObject& obj, int64_t* id, bool* is_ordered,
   if (type_name != "int") {
     return Status::Invalid("Dictionary indices can only be integers");
   }
-  return GetInteger(json_index_type, index_type);
+  return GetInteger(json_index_type).Value(index_type);
 }
 
 template <typename FieldOrStruct>
-Status GetKeyValueMetadata(const FieldOrStruct& field_or_struct,
-                           std::shared_ptr<KeyValueMetadata>* out) {
-  out->reset(new KeyValueMetadata);
+Result<std::shared_ptr<KeyValueMetadata>> GetKeyValueMetadata(
+    const FieldOrStruct& field_or_struct) {
+  auto metadata = std::make_shared<KeyValueMetadata>();
   auto it = field_or_struct.FindMember("metadata");
   if (it == field_or_struct.MemberEnd() || it->value.IsNull()) {
-    return Status::OK();
+    return metadata;
   }
   if (!it->value.IsArray()) {
     return Status::Invalid("Metadata was not a JSON array");
@@ -1159,32 +1129,30 @@ Status GetKeyValueMetadata(const FieldOrStruct& field_or_struct,
     ARROW_ASSIGN_OR_RAISE(const auto key, GetMemberString(key_value_pair, "key"));
     ARROW_ASSIGN_OR_RAISE(const auto value, GetMemberString(key_value_pair, "value"));
 
-    (*out)->Append(std::move(key), std::move(value));
+    metadata->Append(std::move(key), std::move(value));
   }
-  return Status::OK();
+  return metadata;
 }
 
-Status GetField(const rj::Value& obj, FieldPosition field_pos,
-                DictionaryMemo* dictionary_memo, std::shared_ptr<Field>* field) {
+Result<std::shared_ptr<Field>> GetField(const rj::Value& obj, FieldPosition field_pos,
+                                        DictionaryMemo* dictionary_memo) {
   if (!obj.IsObject()) {
     return Status::Invalid("Field was not a JSON object");
   }
   const auto& json_field = obj.GetObject();
 
-  std::shared_ptr<DataType> type;
-
   ARROW_ASSIGN_OR_RAISE(const auto name, GetMemberString(json_field, "name"));
   ARROW_ASSIGN_OR_RAISE(const bool nullable, GetMemberBool(json_field, "nullable"));
 
   ARROW_ASSIGN_OR_RAISE(const auto json_type, GetMemberObject(json_field, "type"));
   ARROW_ASSIGN_OR_RAISE(const auto json_children, GetMemberArray(json_field, "children"));
 
-  std::vector<std::shared_ptr<Field>> children;
-  RETURN_NOT_OK(GetFieldsFromArray(json_children, field_pos, dictionary_memo, &children));
-  RETURN_NOT_OK(GetType(json_type, children, &type));
+  ARROW_ASSIGN_OR_RAISE(FieldVector children,
+                        GetFieldsFromArray(json_children, field_pos, dictionary_memo));
+  ARROW_ASSIGN_OR_RAISE(std::shared_ptr<DataType> type, GetType(json_type, children));
 
-  std::shared_ptr<KeyValueMetadata> metadata;
-  RETURN_NOT_OK(GetKeyValueMetadata(json_field, &metadata));
+  ARROW_ASSIGN_OR_RAISE(std::shared_ptr<KeyValueMetadata> metadata,
+                        GetKeyValueMetadata(json_field));
 
   // Is it a dictionary type?
   int64_t dictionary_id = -1;
@@ -1226,13 +1194,13 @@ Status GetField(const rj::Value& obj, FieldPosition field_pos,
   }
 
   // Create field
-  *field = ::arrow::field(name, type, nullable, metadata);
+  auto field = ::arrow::field(name, type, nullable, metadata);
   if (dictionary_id != -1) {
     RETURN_NOT_OK(dictionary_memo->fields().AddField(dictionary_id, field_pos.path()));
     RETURN_NOT_OK(dictionary_memo->AddDictionaryType(dictionary_id, dict_value_type));
   }
 
-  return Status::OK();
+  return field;
 }
 
 template <typename T>
@@ -1753,38 +1721,34 @@ Status ReadDictionaries(const rj::Value& doc, MemoryPool* pool,
 
 }  // namespace
 
-Status ReadSchema(const rj::Value& json_schema, MemoryPool* pool,
-                  DictionaryMemo* dictionary_memo, std::shared_ptr<Schema>* schema) {
+Result<std::shared_ptr<Schema>> ReadSchema(const rj::Value& json_schema, MemoryPool* pool,
+                                           DictionaryMemo* dictionary_memo) {
   DCHECK(json_schema.IsObject());
   ARROW_ASSIGN_OR_RAISE(const auto obj_schema,
                         GetMemberObject(json_schema.GetObject(), "schema"));
 
   ARROW_ASSIGN_OR_RAISE(const auto json_fields, GetMemberArray(obj_schema, "fields"));
 
-  std::shared_ptr<KeyValueMetadata> metadata;
-  RETURN_NOT_OK(GetKeyValueMetadata(obj_schema, &metadata));
-
-  std::vector<std::shared_ptr<Field>> fields;
-  RETURN_NOT_OK(
-      GetFieldsFromArray(json_fields, FieldPosition(), dictionary_memo, &fields));
-
+  ARROW_ASSIGN_OR_RAISE(auto metadata, GetKeyValueMetadata(obj_schema));
+  ARROW_ASSIGN_OR_RAISE(
+      FieldVector fields,
+      GetFieldsFromArray(json_fields, FieldPosition(), dictionary_memo));
   // Read the dictionaries (if any) and cache in the memo
   RETURN_NOT_OK(ReadDictionaries(json_schema, pool, dictionary_memo));
 
-  *schema = ::arrow::schema(fields, metadata);
+  return ::arrow::schema(fields, metadata);
   return Status::OK();
 }
 
-Status ReadArray(MemoryPool* pool, const rj::Value& json_array,
-                 const std::shared_ptr<Field>& field, std::shared_ptr<Array>* out) {
+Result<std::shared_ptr<Array>> ReadArray(MemoryPool* pool, const rj::Value& json_array,
+                                         const std::shared_ptr<Field>& field) {
   ARROW_ASSIGN_OR_RAISE(auto data, ReadArrayData(pool, json_array, field));
-  *out = MakeArray(data);
-  return Status::OK();
+  return MakeArray(data);
 }
 
-Status ReadRecordBatch(const rj::Value& json_obj, const std::shared_ptr<Schema>& schema,
-                       DictionaryMemo* dictionary_memo, MemoryPool* pool,
-                       std::shared_ptr<RecordBatch>* batch) {
+Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
+    const rj::Value& json_obj, const std::shared_ptr<Schema>& schema,
+    DictionaryMemo* dictionary_memo, MemoryPool* pool) {
   DCHECK(json_obj.IsObject());
   const auto& batch_obj = json_obj.GetObject();
 
@@ -1800,8 +1764,7 @@ Status ReadRecordBatch(const rj::Value& json_obj, const std::shared_ptr<Schema>&
 
   RETURN_NOT_OK(ResolveDictionaries(columns, *dictionary_memo, pool));
 
-  *batch = RecordBatch::Make(schema, num_rows, columns);
-  return Status::OK();
+  return RecordBatch::Make(schema, num_rows, columns);
 }
 
 Status WriteSchema(const Schema& schema, const DictionaryFieldMapper& mapper,
diff --git a/cpp/src/arrow/testing/json_internal.h b/cpp/src/arrow/testing/json_internal.h
index 0870dd1e797d9..ca382782af1c1 100644
--- a/cpp/src/arrow/testing/json_internal.h
+++ b/cpp/src/arrow/testing/json_internal.h
@@ -30,9 +30,10 @@
 #include <rapidjson/stringbuffer.h>  // IWYU pragma: export
 #include <rapidjson/writer.h>        // IWYU pragma: export
 
-#include "arrow/status.h"  // IWYU pragma: export
+#include "arrow/ipc/type_fwd.h"
+#include "arrow/result.h"
 #include "arrow/testing/visibility.h"
-#include "arrow/type_fwd.h"  // IWYU pragma: keep
+#include "arrow/type_fwd.h"
 
 namespace rj = arrow::rapidjson;
 using RjWriter = rj::Writer<rj::StringBuffer>;
@@ -74,23 +75,7 @@ using RjObject = rj::Value::ConstObject;
     return Status::Invalid("field was not an object line ", __LINE__); \
   }
 
-namespace arrow {
-
-class Array;
-class Field;
-class MemoryPool;
-class RecordBatch;
-class Schema;
-
-namespace ipc {
-
-class DictionaryFieldMapper;
-class DictionaryMemo;
-
-}  // namespace ipc
-
-namespace testing {
-namespace json {
+namespace arrow::testing::json {
 
 /// \brief Append integration test Schema format to rapidjson writer
 ARROW_TESTING_EXPORT
@@ -108,19 +93,17 @@ ARROW_TESTING_EXPORT
 Status WriteArray(const std::string& name, const Array& array, RjWriter* writer);
 
 ARROW_TESTING_EXPORT
-Status ReadSchema(const rj::Value& json_obj, MemoryPool* pool,
-                  ipc::DictionaryMemo* dictionary_memo, std::shared_ptr<Schema>* schema);
+Result<std::shared_ptr<Schema>> ReadSchema(const rj::Value& json_obj, MemoryPool* pool,
+                                           ipc::DictionaryMemo* dictionary_memo);
 
 ARROW_TESTING_EXPORT
-Status ReadRecordBatch(const rj::Value& json_obj, const std::shared_ptr<Schema>& schema,
-                       ipc::DictionaryMemo* dict_memo, MemoryPool* pool,
-                       std::shared_ptr<RecordBatch>* batch);
+Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
+    const rj::Value& json_obj, const std::shared_ptr<Schema>& schema,
+    ipc::DictionaryMemo* dict_memo, MemoryPool* pool);
 
 // NOTE: Doesn't work with dictionary arrays, use ReadRecordBatch instead.
 ARROW_TESTING_EXPORT
-Status ReadArray(MemoryPool* pool, const rj::Value& json_obj,
-                 const std::shared_ptr<Field>& type, std::shared_ptr<Array>* array);
+Result<std::shared_ptr<Array>> ReadArray(MemoryPool* pool, const rj::Value& json_obj,
+                                         const std::shared_ptr<Field>& field);
 
-}  // namespace json
-}  // namespace testing
-}  // namespace arrow
+}  // namespace arrow::testing::json
diff --git a/dev/archery/archery/cli.py b/dev/archery/archery/cli.py
index 48022176a2d99..70f865cc2fa70 100644
--- a/dev/archery/archery/cli.py
+++ b/dev/archery/archery/cli.py
@@ -764,6 +764,8 @@ def integration(with_all=False, random_seed=12345, **args):
             enabled_languages += 1
 
     if gen_path:
+        # XXX See GH-37575: this option is only used by the JS test suite
+        # and might not be useful anymore.
         os.makedirs(gen_path, exist_ok=True)
         write_js_test_json(gen_path)
     else:

From 756a5d76e9b87958b11f14ffa497f507ccb48d6d Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 5 Sep 2023 14:21:52 -0400
Subject: [PATCH 321/749] GH-37230: [MATLAB] Add `arrow.type.Date64Type` class
 and `arrow.date64` construction function (#37578)

### Rationale for this change

In support of adding `arrow.array.Date64Array`, this pull request adds a new `arrow.type.Date64Type` class and associated `arrow.date64` construction function to the MATLAB interface.

### What changes are included in this PR?

1. New `arrow.type.Date64Type` class.
2. New `arrow.date64` construction function that returns an `arrow.type.Date64Type` instance.
3. New `arrow.type.ID.Date64` type enumeration value.

**Example**
```matlab
>> type = arrow.date64()

type =

  Date64Type with properties:

          ID: Date64
    DateUnit: Millisecond
```

### Are these changes tested?

Yes.

1. Added a new `tDate64Type` test class.
2. Updated the `tID` test class to include `arrow.type.ID.Date64`.

### Are there any user-facing changes?

Yes.

1. There is a new public `arrow.type.Date64Type` class.
2. There is a new public `arrow.date64` construction function.
3. There is a new `arrow.type.ID.Date64` type enumeration value.

### Future Directions

1. #37572
2. #37577
* Closes: #37230

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../arrow/matlab/type/proxy/date64_type.cc    |  31 +++++
 .../cpp/arrow/matlab/type/proxy/date64_type.h |  36 ++++++
 matlab/src/matlab/+arrow/+type/Date64Type.m   |  33 +++++
 matlab/src/matlab/+arrow/+type/ID.m           |   2 +-
 matlab/src/matlab/+arrow/date32.m             |   3 +-
 matlab/src/matlab/+arrow/date64.m             |  21 ++++
 matlab/test/arrow/type/tDate32Type.m          |   3 +-
 matlab/test/arrow/type/tDate64Type.m          | 116 ++++++++++++++++++
 matlab/test/arrow/type/tID.m                  |   1 +
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 11 files changed, 246 insertions(+), 3 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date64_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/date64_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/Date64Type.m
 create mode 100644 matlab/src/matlab/+arrow/date64.m
 create mode 100644 matlab/test/arrow/type/tDate64Type.m

diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index bc349bcfd595e..5a7d284c0b68c 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -29,6 +29,7 @@
 #include "arrow/matlab/type/proxy/string_type.h"
 #include "arrow/matlab/type/proxy/timestamp_type.h"
 #include "arrow/matlab/type/proxy/date32_type.h"
+#include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/field.h"
@@ -76,6 +77,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.Time32Type     , arrow::matlab::type::proxy::Time32Type);
     REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
     REGISTER_PROXY(arrow.type.proxy.Date32Type     , arrow::matlab::type::proxy::Date32Type);
+    REGISTER_PROXY(arrow.type.proxy.Date64Type     , arrow::matlab::type::proxy::Date64Type);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.cc
new file mode 100644
index 0000000000000..413b73afa6432
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.cc
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/type/proxy/date64_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    Date64Type::Date64Type(std::shared_ptr<arrow::Date64Type> date64_type) : DateType(std::move(date64_type)) {}
+
+    libmexclass::proxy::MakeResult Date64Type::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        using Date64TypeProxy = arrow::matlab::type::proxy::Date64Type;
+
+        const auto type = arrow::date64();
+        const auto date64_type = std::static_pointer_cast<arrow::Date64Type>(type);
+        return std::make_shared<Date64TypeProxy>(std::move(date64_type));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.h
new file mode 100644
index 0000000000000..f0712c73b803a
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/date64_type.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/date_type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    class Date64Type : public arrow::matlab::type::proxy::DateType {
+
+        public:
+            Date64Type(std::shared_ptr<arrow::Date64Type> date64_type);
+
+            ~Date64Type() {}
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    };
+
+}
+
diff --git a/matlab/src/matlab/+arrow/+type/Date64Type.m b/matlab/src/matlab/+arrow/+type/Date64Type.m
new file mode 100644
index 0000000000000..3c5f02c6ef5bd
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/Date64Type.m
@@ -0,0 +1,33 @@
+%DATE64TYPE Type class for date64 data.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Date64Type < arrow.type.DateType
+
+    methods
+
+        function obj = Date64Type(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Date64Type")}
+            end
+            import arrow.internal.proxy.validate
+
+            obj@arrow.type.DateType(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index 66ea3a5c7f750..646edb85c6632 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -33,7 +33,7 @@
         % Binary (14)
         % FixedSizeBinary (15)
         Date32 (16)
-        % Date64 (17)
+        Date64 (17)
         Timestamp (18)
         Time32    (19)
         Time64    (20)
diff --git a/matlab/src/matlab/+arrow/date32.m b/matlab/src/matlab/+arrow/date32.m
index a64cb7c419051..60039a24a5eed 100644
--- a/matlab/src/matlab/+arrow/date32.m
+++ b/matlab/src/matlab/+arrow/date32.m
@@ -1,3 +1,5 @@
+%DATE32 Creates an arrow.type.Date32Type object
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -14,7 +16,6 @@
 % permissions and limitations under the License.
 
 function type = date32()
-%DATE32 Creates an arrow.type.Date32Type object
     proxy = arrow.internal.proxy.create("arrow.type.proxy.Date32Type");
     type = arrow.type.Date32Type(proxy);
 end
diff --git a/matlab/src/matlab/+arrow/date64.m b/matlab/src/matlab/+arrow/date64.m
new file mode 100644
index 0000000000000..e3968a7b4c0c6
--- /dev/null
+++ b/matlab/src/matlab/+arrow/date64.m
@@ -0,0 +1,21 @@
+%DATE64 Creates an arrow.type.Date64Type object
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function type = date64()
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.Date64Type");
+    type = arrow.type.Date64Type(proxy);
+end
diff --git a/matlab/test/arrow/type/tDate32Type.m b/matlab/test/arrow/type/tDate32Type.m
index 3c99bd1fc9f81..71a9e5cf48fc6 100644
--- a/matlab/test/arrow/type/tDate32Type.m
+++ b/matlab/test/arrow/type/tDate32Type.m
@@ -1,3 +1,5 @@
+% Test class for arrow.type.Date32Type and arrow.date32
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -14,7 +16,6 @@
 % permissions and limitations under the License.
 
 classdef tDate32Type < hFixedWidthType
-% Test class for arrow.type.Date32Type and arrow.date32
 
     properties
         ConstructionFcn = @arrow.date32
diff --git a/matlab/test/arrow/type/tDate64Type.m b/matlab/test/arrow/type/tDate64Type.m
new file mode 100644
index 0000000000000..9345f6dbde50b
--- /dev/null
+++ b/matlab/test/arrow/type/tDate64Type.m
@@ -0,0 +1,116 @@
+% Test class for arrow.type.Date64Type and arrow.date64
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDate64Type < hFixedWidthType
+
+    properties
+        ConstructionFcn = @arrow.date64
+        ArrowType = arrow.date64
+        TypeID = arrow.type.ID.Date64
+        BitWidth = int32(64)
+        ClassName = "arrow.type.Date64Type"
+    end
+
+    methods(Test)
+        function TestClass(testCase)
+            % Verify ArrowType is an object of the expected class type.
+            name = string(class(testCase.ArrowType));
+            testCase.verifyEqual(name, testCase.ClassName);
+        end
+
+        function DefaultDateUnit(testCase)
+            % Verify the default DateUnit is Millisecond.
+            type = testCase.ArrowType;
+            actualUnit = type.DateUnit;
+            expectedUnit = arrow.type.DateUnit.Millisecond;
+            testCase.verifyEqual(actualUnit, expectedUnit);
+        end
+
+        function Display(testCase)
+            % Verify the display of Date64Type objects.
+            %
+            % Example:
+            %
+            %  Date32Type with properties:
+            %
+            %          ID: Date64
+            %    DateUnit: Millisecond
+            %
+            type = testCase.ConstructionFcn(); %#ok<NASGU>
+            classnameLink = "<a href=""matlab:helpPopup arrow.type.Date64Type"" style=""font-weight:bold"">Date64Type</a>";
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "DateUnit:"]));
+            body = body + " " + ["Date64"; "Millisecond"];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DateUnitNoSetter(testCase)
+            % Verify that an error is thrown when trying to set the value
+            % of the DateUnit property.
+            type = arrow.date64();
+            testCase.verifyError(@() setfield(type, "DateUnit", "Day"), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidProxy(testCase)
+            % Verify that an error is thrown when a Proxy of an unexpected
+            % type is passed to the arrow.type.Date64Type constructor.
+            array = arrow.array([1, 2, 3]);
+            proxy = array.Proxy;
+            testCase.verifyError(@() arrow.type.Date64Type(proxy), "arrow:proxy:ProxyNameMismatch");
+        end
+
+        function IsEqualTrue(testCase)
+            % Verifies isequal method of arrow.type.Date64Type returns true if
+            % these conditions are met:
+            %
+            % 1. All input arguments have a class type arrow.type.Date64Type
+            % 2. All inputs have the same size
+
+            % Scalar Date64Type arrays
+            date64Type1 = arrow.date64();
+            date64Type2 = arrow.date64();
+            testCase.verifyTrue(isequal(date64Type1, date64Type2));
+
+            % Non-scalar Date64Type arrays
+            typeArray1 = [date64Type1 date64Type1];
+            typeArray2 = [date64Type2 date64Type2];
+            testCase.verifyTrue(isequal(typeArray1, typeArray2));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies the isequal method of arrow.type.Date64Type returns
+            % false when expected.
+
+            % Pass a different arrow.type.Type subclass to isequal
+            date64Type = arrow.date64();
+            int32Type = arrow.int32();
+            testCase.verifyFalse(isequal(date64Type, int32Type));
+            testCase.verifyFalse(isequal([date64Type date64Type], [int32Type int32Type]));
+
+            % Date64Type arrays have different sizes
+            typeArray1 = [date64Type date64Type];
+            typeArray2 = [date64Type date64Type]';
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index d83bb4475feff..b69cd89842d73 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -43,6 +43,7 @@ function CastToUInt64(testCase)
                 ID.Float64,   12, ...
                 ID.String,    13, ...
                 ID.Date32,    16, ...
+                ID.Date64,    17, ...
                 ID.Timestamp, 18, ...
                 ID.Time32,    19, ...
                 ID.Time64,    20  ...
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 3cead42cea257..2d95682bc2081 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -59,6 +59,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/string_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/date_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/date32_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/date64_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/timestamp_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"

From ad7f6ef3a97be6a3eb6fe37d0df1b1634db057d2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 6 Sep 2023 10:44:49 +0900
Subject: [PATCH 322/749] GH-37067: [C++] Install bundled GoogleTest (#37483)

### Rationale for this change

Because `libarrow*_testing.so` depend it. If we don't install bundled GoogleTest, users can't use `libarrow*_testing.so`.

### What changes are included in this PR?

If we install bundled GoogleTest as-is, it may conflict existing GoogleTest. So this PR renames GoogleTest when we install GoogleTest:

* `lib{gtest,gtest_main,gmock,gmock_main}.so` -> `libarrow_{gtest,gtest_main,gmock,gmock_main}.so`
* `${PREFIX}/include/{gtest,gmock}/` -> `${PREFIX}/include/arrow-gtest/${gtest,gmock}/`

Other CMake packages and `.pc` files aren't installed. `ArrowTesting` CMake package and `arrow-testing.pc` configures bundled GoogleTest instead.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37067

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakeLists.txt                           |   7 +
 cpp/cmake_modules/ThirdpartyToolchain.cmake  | 200 ++++++-------------
 cpp/src/arrow/CMakeLists.txt                 |  20 +-
 cpp/src/arrow/compute/CMakeLists.txt         |   4 +-
 cpp/src/arrow/compute/kernels/CMakeLists.txt |   3 +-
 matlab/CMakeLists.txt                        |  62 +++---
 6 files changed, 107 insertions(+), 189 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index f8e7b1eb271b2..d343de836e528 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -23,6 +23,13 @@ message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 # Compiler id for Apple Clang is now AppleClang.
 cmake_policy(SET CMP0025 NEW)
 
+# https://cmake.org/cmake/help/latest/policy/CMP0042.html
+#
+# Enable MACOSX_RPATH by default. @rpath in a target's install name is
+# a more flexible and powerful mechanism than @executable_path or
+# @loader_path for locating shared libraries.
+cmake_policy(SET CMP0042 NEW)
+
 # https://www.cmake.org/cmake/help/latest/policy/CMP0054.html
 #
 # Only interpret if() arguments as variables or keywords when unquoted.
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index b2360dab2ec4f..a9ac0b9451481 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -998,6 +998,21 @@ endif()
 
 include(FetchContent)
 
+macro(prepare_fetchcontent)
+  set(BUILD_SHARED_LIBS OFF)
+  set(BUILD_STATIC_LIBS ON)
+  set(CMAKE_COMPILE_WARNING_AS_ERROR FALSE)
+  set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
+  set(CMAKE_MACOSX_RPATH ${ARROW_INSTALL_NAME_RPATH})
+  if(MSVC)
+    string(REPLACE "/WX" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+    string(REPLACE "/WX" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+  else()
+    string(APPEND CMAKE_C_FLAGS_DEBUG " -Wno-error")
+    string(APPEND CMAKE_CXX_FLAGS_DEBUG " -Wno-error")
+  endif()
+endmacro()
+
 # ----------------------------------------------------------------------
 # Find pthreads
 
@@ -2083,140 +2098,51 @@ endif()
 # ----------------------------------------------------------------------
 # Google gtest
 
-macro(build_gtest)
+function(build_gtest)
   message(STATUS "Building gtest from source")
   set(GTEST_VENDORED TRUE)
-  set(GTEST_CMAKE_CXX_FLAGS ${EP_CXX_FLAGS})
-
-  if(CMAKE_BUILD_TYPE MATCHES DEBUG)
-    set(CMAKE_GTEST_DEBUG_EXTENSION "d")
-  else()
-    set(CMAKE_GTEST_DEBUG_EXTENSION "")
-  endif()
-
+  fetchcontent_declare(googletest
+                       URL ${GTEST_SOURCE_URL}
+                       URL_HASH "SHA256=${ARROW_GTEST_BUILD_SHA256_CHECKSUM}")
+  prepare_fetchcontent()
   if(APPLE)
-    string(APPEND
-           GTEST_CMAKE_CXX_FLAGS
-           " -DGTEST_USE_OWN_TR1_TUPLE=1"
-           " -Wno-unused-value"
-           " -Wno-ignored-attributes")
-  endif()
-
-  if(WIN32)
-    string(APPEND GTEST_CMAKE_CXX_FLAGS " -DGTEST_CREATE_SHARED_LIBRARY=1")
-  endif()
-
-  set(GTEST_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/googletest_ep-prefix")
-  set(GTEST_INCLUDE_DIR "${GTEST_PREFIX}/include")
-
-  set(_GTEST_LIBRARY_DIR "${GTEST_PREFIX}/lib")
-
-  if(WIN32)
-    set(_GTEST_IMPORTED_TYPE IMPORTED_IMPLIB)
-    set(_GTEST_LIBRARY_SUFFIX
-        "${CMAKE_GTEST_DEBUG_EXTENSION}${CMAKE_IMPORT_LIBRARY_SUFFIX}")
-  else()
-    set(_GTEST_IMPORTED_TYPE IMPORTED_LOCATION)
-    set(_GTEST_LIBRARY_SUFFIX
-        "${CMAKE_GTEST_DEBUG_EXTENSION}${CMAKE_SHARED_LIBRARY_SUFFIX}")
-
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-unused-value" " -Wno-ignored-attributes")
   endif()
-
-  set(GTEST_SHARED_LIB
-      "${_GTEST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest${_GTEST_LIBRARY_SUFFIX}")
-  set(GMOCK_SHARED_LIB
-      "${_GTEST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gmock${_GTEST_LIBRARY_SUFFIX}")
-  set(GTEST_MAIN_SHARED_LIB
-      "${_GTEST_LIBRARY_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${_GTEST_LIBRARY_SUFFIX}"
-  )
-  set(GTEST_INSTALL_NAME_DIR "$<INSTALL_PREFIX$<ANGLE-R>/lib")
-  # Fix syntax highlighting mess introduced by unclosed bracket above
-  set(dummy ">")
-
-  set(GTEST_CMAKE_ARGS
-      ${EP_COMMON_CMAKE_ARGS}
-      -DBUILD_SHARED_LIBS=ON
-      -DBUILD_STATIC_LIBS=OFF
-      -DCMAKE_CXX_FLAGS=${GTEST_CMAKE_CXX_FLAGS}
-      -DCMAKE_INSTALL_NAME_DIR=${GTEST_INSTALL_NAME_DIR}
-      -DCMAKE_INSTALL_PREFIX=${GTEST_PREFIX}
-      -DCMAKE_MACOSX_RPATH=OFF)
-  set(GMOCK_INCLUDE_DIR "${GTEST_PREFIX}/include")
-
-  if(WIN32 AND NOT ARROW_USE_STATIC_CRT)
-    list(APPEND GTEST_CMAKE_ARGS -Dgtest_force_shared_crt=ON)
-  endif()
-
-  externalproject_add(googletest_ep
-                      ${EP_COMMON_OPTIONS}
-                      URL ${GTEST_SOURCE_URL}
-                      URL_HASH "SHA256=${ARROW_GTEST_BUILD_SHA256_CHECKSUM}"
-                      BUILD_BYPRODUCTS ${GTEST_SHARED_LIB} ${GTEST_MAIN_SHARED_LIB}
-                                       ${GMOCK_SHARED_LIB}
-                      CMAKE_ARGS ${GTEST_CMAKE_ARGS})
-  if(WIN32)
-    # Copy the built shared libraries to the same directory as our
-    # test programs because Windows doesn't provided rpath (run-time
-    # search path) feature. We need to put these shared libraries to
-    # the same directory as our test programs or add
-    # _GTEST_LIBRARY_DIR to PATH when we run our test programs. We
-    # choose the former because the latter may be forgotten.
-    set(_GTEST_RUNTIME_DIR "${GTEST_PREFIX}/bin")
-    set(_GTEST_RUNTIME_SUFFIX
-        "${CMAKE_GTEST_DEBUG_EXTENSION}${CMAKE_SHARED_LIBRARY_SUFFIX}")
-    set(_GTEST_RUNTIME_LIB
-        "${_GTEST_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest${_GTEST_RUNTIME_SUFFIX}"
-    )
-    set(_GMOCK_RUNTIME_LIB
-        "${_GTEST_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gmock${_GTEST_RUNTIME_SUFFIX}"
-    )
-    set(_GTEST_MAIN_RUNTIME_LIB
-        "${_GTEST_RUNTIME_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${_GTEST_RUNTIME_SUFFIX}"
-    )
-    get_property(_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    if(_GENERATOR_IS_MULTI_CONFIG)
-      set(_GTEST_RUNTIME_OUTPUT_DIR "${BUILD_OUTPUT_ROOT_DIRECTORY}/${CMAKE_BUILD_TYPE}")
-    else()
-      set(_GTEST_RUNTIME_OUTPUT_DIR ${BUILD_OUTPUT_ROOT_DIRECTORY})
-    endif()
-    externalproject_add_step(googletest_ep copy
-                             COMMAND ${CMAKE_COMMAND} -E make_directory
-                                     ${_GTEST_RUNTIME_OUTPUT_DIR}
-                             COMMAND ${CMAKE_COMMAND} -E copy ${_GTEST_RUNTIME_LIB}
-                                     ${_GTEST_RUNTIME_OUTPUT_DIR}
-                             COMMAND ${CMAKE_COMMAND} -E copy ${_GMOCK_RUNTIME_LIB}
-                                     ${_GTEST_RUNTIME_OUTPUT_DIR}
-                             COMMAND ${CMAKE_COMMAND} -E copy ${_GTEST_MAIN_RUNTIME_LIB}
-                                     ${_GTEST_RUNTIME_OUTPUT_DIR}
-                             DEPENDEES install)
+  set(BUILD_SHARED_LIBS ON)
+  set(BUILD_STATIC_LIBS OFF)
+  # We need to use "cache" variable to override the default
+  # INSTALL_GTEST option by this value. See also:
+  # https://cmake.org/cmake/help/latest/policy/CMP0077.html
+  set(INSTALL_GTEST
+      OFF
+      CACHE "BOOL"
+            "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)"
+            FORCE)
+  string(APPEND CMAKE_INSTALL_INCLUDEDIR "/arrow-gtest")
+  fetchcontent_makeavailable(googletest)
+  set_target_properties(gmock PROPERTIES OUTPUT_NAME "arrow_gmock")
+  set_target_properties(gmock_main PROPERTIES OUTPUT_NAME "arrow_gmock_main")
+  set_target_properties(gtest PROPERTIES OUTPUT_NAME "arrow_gtest")
+  set_target_properties(gtest_main PROPERTIES OUTPUT_NAME "arrow_gtest_main")
+  install(DIRECTORY "${googletest_SOURCE_DIR}/googlemock/include/"
+                    "${googletest_SOURCE_DIR}/googletest/include/"
+          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+  install(TARGETS gmock gmock_main gtest gtest_main
+          EXPORT arrow_testing_targets
+          RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+          ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+          LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+  if(MSVC)
+    install(FILES $<TARGET_PDB_FILE:gmock> $<TARGET_PDB_FILE:gmock_main>
+                  $<TARGET_PDB_FILE:gtest> $<TARGET_PDB_FILE:gtest_main>
+            DESTINATION "${CMAKE_INSTALL_BINDIR}"
+            OPTIONAL)
   endif()
-
-  # The include directory must exist before it is referenced by a target.
-  file(MAKE_DIRECTORY "${GTEST_INCLUDE_DIR}")
-
-  add_library(arrow::GTest::gtest SHARED IMPORTED)
-  set_target_properties(arrow::GTest::gtest
-                        PROPERTIES ${_GTEST_IMPORTED_TYPE} "${GTEST_SHARED_LIB}"
-                                   INTERFACE_COMPILE_DEFINITIONS
-                                   "GTEST_LINKED_AS_SHARED_LIBRARY=1"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
-
-  add_library(arrow::GTest::gtest_main SHARED IMPORTED)
-  set_target_properties(arrow::GTest::gtest_main
-                        PROPERTIES ${_GTEST_IMPORTED_TYPE} "${GTEST_MAIN_SHARED_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
-
-  add_library(arrow::GTest::gmock SHARED IMPORTED)
-  set_target_properties(arrow::GTest::gmock
-                        PROPERTIES ${_GTEST_IMPORTED_TYPE} "${GMOCK_SHARED_LIB}"
-                                   INTERFACE_COMPILE_DEFINITIONS
-                                   "GMOCK_LINKED_AS_SHARED_LIBRARY=1"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
-  add_dependencies(toolchain-tests googletest_ep)
-  add_dependencies(arrow::GTest::gtest googletest_ep)
-  add_dependencies(arrow::GTest::gtest_main googletest_ep)
-  add_dependencies(arrow::GTest::gmock googletest_ep)
-endmacro()
+  add_library(arrow::GTest::gmock ALIAS gmock)
+  add_library(arrow::GTest::gmock_main ALIAS gmock_main)
+  add_library(arrow::GTest::gtest ALIAS gtest)
+  add_library(arrow::GTest::gtest_main ALIAS gtest_main)
+endfunction()
 
 if(ARROW_TESTING)
   set(GTestAlt_NEED_CXX_STANDARD_CHECK TRUE)
@@ -2249,9 +2175,8 @@ if(ARROW_TESTING)
     set(ARROW_GTEST_GTEST GTest::gtest)
     set(ARROW_GTEST_GTEST_MAIN GTest::gtest_main)
   else()
-    # TODO: How to solve BUNDLED case? Do we install bundled GoogleTest?
-    # string(APPEND ARROW_TESTING_PC_CFLAGS " -I${GTEST_INCLUDE_DIR}")
-    # string(APPEND ARROW_TESTING_PC_LIBS " -lgtest")
+    string(APPEND ARROW_TESTING_PC_CFLAGS " -I\${includedir}/arrow-gtest")
+    string(APPEND ARROW_TESTING_PC_LIBS " -larrow_gtest")
     set(ARROW_GTEST_GMOCK arrow::GTest::gmock)
     set(ARROW_GTEST_GTEST arrow::GTest::gtest)
     set(ARROW_GTEST_GTEST_MAIN arrow::GTest::gtest_main)
@@ -5121,24 +5046,15 @@ function(build_azure_sdk)
   fetchcontent_declare(azure_sdk
                        URL ${ARROW_AZURE_SDK_URL}
                        URL_HASH "SHA256=${ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM}")
+  prepare_fetchcontent()
   set(BUILD_PERFORMANCE_TESTS FALSE)
   set(BUILD_SAMPLES FALSE)
   set(BUILD_TESTING FALSE)
   set(BUILD_WINDOWS_UWP TRUE)
-  set(CMAKE_EXPORT_NO_PACKAGE_REGISTRY TRUE)
   set(CMAKE_UNITY_BUILD FALSE)
   set(DISABLE_AZURE_CORE_OPENTELEMETRY TRUE)
   set(ENV{AZURE_SDK_DISABLE_AUTO_VCPKG} TRUE)
   set(WARNINGS_AS_ERRORS FALSE)
-  # TODO: Configure flags in a better way. FetchContent builds inherit
-  # global flags but we want to disable -Werror for Azure SDK for C++ builds.
-  if(MSVC)
-    string(REPLACE "/WX" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
-    string(REPLACE "/WX" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-  else()
-    string(REPLACE "-Werror" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
-    string(REPLACE "-Werror" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-  endif()
   fetchcontent_makeavailable(azure_sdk)
   set(AZURE_SDK_VENDORED
       TRUE
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index ba3f0ef30dd93..9ecf2b51c91bf 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -324,6 +324,11 @@ if(ARROW_WITH_ZSTD)
   list(APPEND ARROW_SRCS util/compression_zstd.cc)
 endif()
 
+set(ARROW_TESTING_SHARED_LINK_LIBS arrow::flatbuffers rapidjson::rapidjson arrow_shared
+                                   ${ARROW_GTEST_GTEST})
+set(ARROW_TESTING_STATIC_LINK_LIBS arrow::flatbuffers rapidjson::rapidjson arrow_static
+                                   ${ARROW_GTEST_GTEST})
+
 set(ARROW_TESTING_SRCS
     io/test_common.cc
     ipc/test_common.cc
@@ -503,6 +508,8 @@ if(ARROW_FILESYSTEM)
                                            SKIP_UNITY_BUILD_INCLUSION ON)
   endif()
 
+  list(APPEND ARROW_TESTING_SHARED_LINK_LIBS ${ARROW_GTEST_GMOCK})
+  list(APPEND ARROW_TESTING_STATIC_LINK_LIBS ${ARROW_GTEST_GMOCK})
   list(APPEND ARROW_TESTING_SRCS filesystem/test_util.cc)
 endif()
 
@@ -710,6 +717,9 @@ if(ARROW_TESTING)
   if(GTest_SOURCE STREQUAL "SYSTEM")
     list(APPEND ARROW_TESTING_SHARED_INSTALL_INTERFACE_LIBS ${ARROW_GTEST_GTEST})
     list(APPEND ARROW_TESTING_STATIC_INSTALL_INTERFACE_LIBS ${ARROW_GTEST_GTEST})
+  else()
+    list(APPEND ARROW_TESTING_SHARED_INSTALL_INTERFACE_LIBS ArrowTesting::gtest)
+    list(APPEND ARROW_TESTING_STATIC_INSTALL_INTERFACE_LIBS ArrowTesting::gtest)
   endif()
   add_arrow_lib(arrow_testing
                 CMAKE_PACKAGE_NAME
@@ -725,17 +735,11 @@ if(ARROW_TESTING)
                 DEPENDENCIES
                 arrow_test_dependencies
                 SHARED_LINK_LIBS
-                arrow::flatbuffers
-                rapidjson::rapidjson
-                arrow_shared
-                ${ARROW_GTEST_GTEST}
+                ${ARROW_TESTING_SHARED_LINK_LIBS}
                 SHARED_INSTALL_INTERFACE_LIBS
                 ${ARROW_TESTING_SHARED_INSTALL_INTERFACE_LIBS}
                 STATIC_LINK_LIBS
-                arrow::flatbuffers
-                rapidjson::rapidjson
-                arrow_static
-                ${ARROW_GTEST_GTEST}
+                ${ARROW_TESTING_STATIC_LINK_LIBS}
                 STATIC_INSTALL_INTERFACE_LIBS
                 ${ARROW_TESTING_STATIC_INSTALL_INTERFACE_LIBS})
 
diff --git a/cpp/src/arrow/compute/CMakeLists.txt b/cpp/src/arrow/compute/CMakeLists.txt
index 1134e0a98ae45..001424dd42072 100644
--- a/cpp/src/arrow/compute/CMakeLists.txt
+++ b/cpp/src/arrow/compute/CMakeLists.txt
@@ -89,7 +89,9 @@ add_arrow_test(internals_test
                kernel_test.cc
                light_array_test.cc
                registry_test.cc
-               key_hash_test.cc)
+               key_hash_test.cc
+               EXTRA_LINK_LIBS
+               ${ARROW_GTEST_GMOCK})
 
 add_arrow_compute_test(expression_test SOURCES expression_test.cc)
 
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 0bd6fe86134ab..78743050625a4 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -23,7 +23,8 @@ if(ARROW_TESTING)
   add_library(arrow_compute_kernels_testing OBJECT test_util.cc)
   # Even though this is still just an object library we still need to "link" our
   # dependencies so that include paths are configured correctly
-  target_link_libraries(arrow_compute_kernels_testing ${ARROW_GTEST_GTEST})
+  target_link_libraries(arrow_compute_kernels_testing ${ARROW_GTEST_GTEST}
+                        ${ARROW_GTEST_GMOCK})
 endif()
 
 add_arrow_test(scalar_cast_test
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index feda2cc6adbd6..d73173b58e78a 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -115,35 +115,25 @@ function(build_arrow)
 endfunction()
 
 macro(enable_gtest)
-  set(ARROW_GTEST_PREFIX "${ARROW_BINARY_DIR}/googletest_ep-prefix")
-  set(ARROW_GTEST_MAIN_PREFIX "${ARROW_BINARY_DIR}/googletest_ep-prefix")
+  set(ARROW_GTEST_INCLUDE_DIR "${ARROW_PREFIX}/include/arrow-gtest")
 
+  set(ARROW_GTEST_IMPORT_LIB_DIR "${ARROW_PREFIX}/lib")
   if(WIN32)
-    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_GTEST_PREFIX}/bin")
-    set(ARROW_GTEST_MAIN_SHARED_LIB_DIR "${ARROW_GTEST_MAIN_PREFIX}/bin")
-
-    set(ARROW_GTEST_LINK_LIB_DIR "${ARROW_GTEST_PREFIX}/lib")
-    set(ARROW_GTEST_LINK_LIB
-        "${ARROW_GTEST_LINK_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}gtest${CMAKE_IMPORT_LIBRARY_SUFFIX}"
-    )
-
-    set(ARROW_GTEST_MAIN_LINK_LIB_DIR "${ARROW_GTEST_MAIN_PREFIX}/lib")
-    set(ARROW_GTEST_MAIN_LINK_LIB
-        "${ARROW_GTEST_MAIN_LINK_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}gtest_main${CMAKE_IMPORT_LIBRARY_SUFFIX}"
-    )
+    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_PREFIX}/bin")
   else()
-    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_GTEST_PREFIX}/lib")
-    set(ARROW_GTEST_MAIN_SHARED_LIB_DIR "${ARROW_GTEST_MAIN_PREFIX}/lib")
+    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_PREFIX}/lib")
   endif()
-
-  set(ARROW_GTEST_INCLUDE_DIR "${ARROW_GTEST_PREFIX}/include")
+  set(ARROW_GTEST_IMPORT_LIB
+      "${ARROW_GTEST_IMPORT_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}arrow_gtest${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+  )
+  set(ARROW_GTEST_MAIN_IMPORT_LIB
+      "${ARROW_GTEST_IMPORT_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}arrow_gtest_main${CMAKE_IMPORT_LIBRARY_SUFFIX}"
+  )
   set(ARROW_GTEST_SHARED_LIB
-      "${ARROW_GTEST_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest${CMAKE_SHARED_LIBRARY_SUFFIX}"
+      "${ARROW_GTEST_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}arrow_gtest${CMAKE_SHARED_LIBRARY_SUFFIX}"
   )
-
-  set(ARROW_GTEST_MAIN_INCLUDE_DIR "${ARROW_GTEST_MAIN_PREFIX}/include")
   set(ARROW_GTEST_MAIN_SHARED_LIB
-      "${ARROW_GTEST_MAIN_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${CMAKE_SHARED_LIBRARY_SUFFIX}"
+      "${ARROW_GTEST_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}arrow_gtest_main${CMAKE_SHARED_LIBRARY_SUFFIX}"
   )
 
   list(APPEND ARROW_CMAKE_ARGS "-DARROW_BUILD_TESTS=ON")
@@ -152,8 +142,8 @@ macro(enable_gtest)
   # executables.
   if(WIN32)
     # On Windows, add the gtest link libraries as BUILD_BYPRODUCTS for arrow_ep.
-    list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_LINK_LIB}"
-         "${ARROW_GTEST_MAIN_LINK_LIB}")
+    list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_IMPORT_LIB}"
+         "${ARROW_GTEST_MAIN_IMPORT_LIB}")
   else()
     # On Linux and macOS, add the gtest shared libraries as BUILD_BYPRODUCTS for arrow_ep.
     list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_SHARED_LIB}"
@@ -168,26 +158,17 @@ macro(build_gtest)
   # Create target GTest::gtest
   add_library(GTest::gtest SHARED IMPORTED)
   set_target_properties(GTest::gtest
-                        PROPERTIES IMPORTED_LOCATION ${ARROW_GTEST_SHARED_LIB}
+                        PROPERTIES IMPORTED_IMPLIB ${ARROW_GTEST_IMPORT_LIB}
+                                   IMPORTED_LOCATION ${ARROW_GTEST_SHARED_LIB}
                                    INTERFACE_INCLUDE_DIRECTORIES
                                    ${ARROW_GTEST_INCLUDE_DIR})
-  if(WIN32)
-    set_target_properties(GTest::gtest PROPERTIES IMPORTED_IMPLIB ${ARROW_GTEST_LINK_LIB})
-  endif()
-
   add_dependencies(GTest::gtest arrow_ep)
 
   # Create target GTest::gtest_main
   add_library(GTest::gtest_main SHARED IMPORTED)
   set_target_properties(GTest::gtest_main
-                        PROPERTIES IMPORTED_LOCATION ${ARROW_GTEST_MAIN_SHARED_LIB}
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   ${ARROW_GTEST_MAIN_INCLUDE_DIR})
-  if(WIN32)
-    set_target_properties(GTest::gtest_main PROPERTIES IMPORTED_IMPLIB
-                                                       ${ARROW_GTEST_MAIN_LINK_LIB})
-  endif()
-
+                        PROPERTIES IMPORTED_IMPLIB ${ARROW_GTEST_MAIN_IMPORT_LIB}
+                                   IMPORTED_LOCATION ${ARROW_GTEST_MAIN_SHARED_LIB})
   add_dependencies(GTest::gtest_main arrow_ep)
 endmacro()
 
@@ -345,6 +326,13 @@ if(MATLAB_BUILD_TESTS)
   # targets.
   target_link_libraries(placeholder_test GTest::gtest GTest::gtest_main)
 
+  # Ensure using GTest:gtest and GTest::gtest_main on macOS without
+  # specifying DYLD_LIBRARY_DIR.
+  set_target_properties(placeholder_test
+                        PROPERTIES BUILD_RPATH
+                                   "$<TARGET_FILE_DIR:GTest::gtest>;$<TARGET_FILE_DIR:GTest::gtest_main>"
+  )
+
   # Add test targets for C++ tests.
   add_test(PlaceholderTestTarget placeholder_test)
 

From 33b714ec4e0c0f30236dc83223ff831517e0165d Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 6 Sep 2023 11:37:58 -0400
Subject: [PATCH 323/749] GH-37572: [MATLAB] Add `arrow.array.Date64Array`
 class (#37581)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Now that `arrow.type.Date64Type` class has been added to the MATLAB Interface (#37578), we can add the `arrow.array.Date64Array` class.

`Date64Array`s can be created from MATLAB [`datetime`](https://www.mathworks.com/help/matlab/ref/datetime.html) values.

### What changes are included in this PR?

1. Added a new `arrow.array.Date64Array` class.
2. Added a new `arrow.type.traits.Date64Traits` class.
3. Added `arrow.type.Date64Type` support to `arrow.type.traits.traits` function.
4. Factored out `convertToEpochTime` method on `TimestampArray` into internal helper function `arrow.array.internal.temporal.convertDatetimeToEpochTime`.
5. Updated `arrow.internal.test.tabular.createAllSupportedArrayTypes` to include `Date64Array`.

`Date64Array`s can be created from MATLAB [`datetime`](https://www.mathworks.com/help/matlab/ref/datetime.html) values using the `fromMATLAB` method. `Date64Array`s can be converted to MATLAB `datetime` values using the `toMATLAB` method.

**Example**
```matlab
>> dates = datetime + milliseconds(1:5)'

dates =

  5×1 datetime array

   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12

% "SSS" displays fractional seconds (i.e. milliseconds)
>> dates.Format = "MMM dd, yyyy HH:mm:ss SSS"

dates =

  5×1 datetime array

   Sep 05, 2023 16:47:12 933
   Sep 05, 2023 16:47:12 934
   Sep 05, 2023 16:47:12 935
   Sep 05, 2023 16:47:12 936
   Sep 05, 2023 16:47:12 937

>> array = arrow.array.Date64Array.fromMATLAB(dates)

array =

[
  2023-09-05,
  2023-09-05,
  2023-09-05,
  2023-09-05,
  2023-09-05
]

>> array.toMATLAB

ans =

  5×1 datetime array

   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12
   05-Sep-2023 16:47:12

% Milliseconds are preserved on round-trip
>> ans.Format = "MMM dd, yyyy HH:mm:ss SSS"

ans =

  5×1 datetime array

   Sep 05, 2023 16:47:12 933
   Sep 05, 2023 16:47:12 934
   Sep 05, 2023 16:47:12 935
   Sep 05, 2023 16:47:12 936
   Sep 05, 2023 16:47:12 937
```

### Are these changes tested?

1. Added a new `tDate64Array` test class.
2. Added `Date64` related test to `ttraits.m`.
3. Added a new `tDate64Traits.m` test class.

### Are there any user-facing changes?

Yes.

1. Users can now create `arrow.array.Date64Array`s  from MATLAB `datetime`s.

### Future Directions

1. Add round-trip precision tests for `TimestampArray` (i.e. similar to the test case `TestInt64MaxMilliseconds`).
2. Add a way to extract the raw `int64` values from an `arrow.array.Date64Array` without converting to a MATLAB `datetime` using `toMATLAB`.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37572

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   2 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   1 +
 .../src/cpp/arrow/matlab/type/proxy/traits.h  |   6 +
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   3 +
 .../+temporal/convertDatetimeToEpochTime.m    |  31 ++
 matlab/src/matlab/+arrow/+array/Date64Array.m |  77 +++++
 .../src/matlab/+arrow/+array/TimestampArray.m |  32 +-
 .../+tabular/createAllSupportedArrayTypes.m   |   2 +-
 .../+arrow/+type/+traits/Date64Traits.m       |  30 ++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   2 +
 matlab/src/matlab/+arrow/+type/DateUnit.m     |  15 +
 matlab/test/arrow/array/tDate64Array.m        | 316 ++++++++++++++++++
 matlab/test/arrow/type/traits/tDate64Traits.m |  33 ++
 matlab/test/arrow/type/traits/ttraits.m       |  12 +
 14 files changed, 537 insertions(+), 25 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+temporal/convertDatetimeToEpochTime.m
 create mode 100644 matlab/src/matlab/+arrow/+array/Date64Array.m
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/Date64Traits.m
 create mode 100644 matlab/test/arrow/array/tDate64Array.m
 create mode 100644 matlab/test/arrow/type/traits/tDate64Traits.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index 104eecbb4f266..a8e3f239919cc 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -57,6 +57,8 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::Time64Type>>(std::static_pointer_cast<arrow::Time64Array>(array));
             case ID::DATE32:
                 return std::make_shared<proxy::NumericArray<arrow::Date32Type>>(std::static_pointer_cast<arrow::Date32Array>(array));
+            case ID::DATE64:
+                return std::make_shared<proxy::NumericArray<arrow::Date64Type>>(std::static_pointer_cast<arrow::Date64Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
             default:
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 5a7d284c0b68c..593e8ffbb6f01 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -57,6 +57,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
     REGISTER_PROXY(arrow.array.proxy.Date32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
+    REGISTER_PROXY(arrow.array.proxy.Date64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date64Type>);
     REGISTER_PROXY(arrow.array.proxy.ChunkedArray  , arrow::matlab::array::proxy::ChunkedArray);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
index a4c5d06f8ff22..799a40cd67450 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/traits.h
@@ -24,6 +24,7 @@
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/date32_type.h"
+#include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -105,4 +106,9 @@ namespace arrow::matlab::type::proxy {
     struct Traits<arrow::Date32Type> {
         using TypeProxy = Date32Type;
     };
+
+    template <>
+    struct Traits<arrow::Date64Type> {
+        using TypeProxy = Date64Type;
+    };
 }
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index 7dfdf58e1dd21..91a1e353496c7 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -22,6 +22,7 @@
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/date32_type.h"
+#include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -59,6 +60,8 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<Time64Type>(std::static_pointer_cast<arrow::Time64Type>(type));
             case ID::DATE32:
                 return std::make_shared<Date32Type>(std::static_pointer_cast<arrow::Date32Type>(type));
+            case ID::DATE64:
+                return std::make_shared<Date64Type>(std::static_pointer_cast<arrow::Date64Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
             default:
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+temporal/convertDatetimeToEpochTime.m b/matlab/src/matlab/+arrow/+array/+internal/+temporal/convertDatetimeToEpochTime.m
new file mode 100644
index 0000000000000..f38de844693df
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+temporal/convertDatetimeToEpochTime.m
@@ -0,0 +1,31 @@
+% Converts MATLAB datetime values to integer "Epoch time" values which
+% represent the number of "ticks" since the UNIX Epoch (Jan-1-1970) with
+% respect to the specified TimeUnit / DateUnit.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function epochTime = convertDatetimeToEpochTime(datetimes, unit)
+    epochTime = zeros(size(datetimes), "int64");
+    indices = ~isnat(datetimes);
+
+    % convertTo uses the Unzoned UNIX Epoch Jan-1-1970 as the default Epoch.
+    % If the input datetime array has a TimeZone, then a Zoned UNIX Epoch
+    % of Jan-1-1970 UTC is used instead.
+    %
+    % TODO: convertTo may error if the datetime is 2^63-1 before or
+    % after the epoch. We should throw a custom error in this case.
+    epochTime(indices) = convertTo(datetimes(indices), "epochtime", TicksPerSecond=ticksPerSecond(unit));
+end
diff --git a/matlab/src/matlab/+arrow/+array/Date64Array.m b/matlab/src/matlab/+arrow/+array/Date64Array.m
new file mode 100644
index 0000000000000..f5da26bbb5594
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/Date64Array.m
@@ -0,0 +1,77 @@
+% arrow.array.Date64Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Date64Array < arrow.array.Array
+
+    properties(Access=private)
+        NullSubstitutionValue = NaT
+    end
+
+    methods
+
+        function obj = Date64Array(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.Date64Array")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function dates = toMATLAB(obj)
+            epochTime = obj.Proxy.toMATLAB();
+
+            ticksPerSecond = obj.Type.DateUnit.ticksPerSecond();
+
+            % UNIX Epoch (January 1st, 1970).
+            unixEpoch = datetime(0, ConvertFrom="posixtime", TimeZone="UTC");
+            dates = datetime(epochTime, ConvertFrom="epochtime", Epoch=unixEpoch, ....
+                TicksPerSecond=ticksPerSecond);
+
+            dates(~obj.Valid) = obj.NullSubstitutionValue;
+        end
+
+        function dates = datetime(obj)
+            dates = obj.toMATLAB();
+        end
+
+    end
+
+    methods(Static)
+
+        function array = fromMATLAB(data, opts)
+            arguments
+                data
+                opts.InferNulls(1, 1) logical = true
+                opts.Valid
+            end
+
+            import arrow.array.Date64Array
+
+            arrow.internal.validate.type(data, "datetime");
+            arrow.internal.validate.shape(data);
+
+            validElements = arrow.internal.validate.parseValidElements(data, opts);
+            epochTime = arrow.array.internal.temporal.convertDatetimeToEpochTime(data, arrow.type.DateUnit.Millisecond);
+
+            args = struct(MatlabArray=epochTime, Valid=validElements);
+            proxy = arrow.internal.proxy.create("arrow.array.proxy.Date64Array", args);
+            array = Date64Array(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+array/TimestampArray.m b/matlab/src/matlab/+arrow/+array/TimestampArray.m
index 3b05903bb13ea..80198f965fe92 100644
--- a/matlab/src/matlab/+arrow/+array/TimestampArray.m
+++ b/matlab/src/matlab/+arrow/+array/TimestampArray.m
@@ -30,15 +30,15 @@
         end
 
         function dates = toMATLAB(obj)
-            time = obj.Proxy.toMATLAB();
+            epochTime = obj.Proxy.toMATLAB();
 
-            epoch = datetime(1970, 1, 1, TimeZone="UTC");
+            timeZone = obj.Type.TimeZone;
+            ticksPerSecond = obj.Type.TimeUnit.ticksPerSecond();
 
-            tz = obj.Type.TimeZone;
-            ticsPerSecond = ticksPerSecond(obj.Type.TimeUnit);
-            
-            dates = datetime(time, ConvertFrom="epochtime", Epoch=epoch, ...
-                TimeZone=tz, TicksPerSecond=ticsPerSecond);
+            % UNIX Epoch (January 1st, 1970).
+            unixEpoch = datetime(0, ConvertFrom="posixtime", TimeZone="UTC");
+            dates = datetime(epochTime, ConvertFrom="epochtime", Epoch=unixEpoch, ...
+                TimeZone=timeZone, TicksPerSecond=ticksPerSecond);
 
             dates(~obj.Valid) = obj.NullSubstitutionValue;
         end
@@ -48,21 +48,6 @@
         end
     end
 
-    methods (Static, Access = private)
-        function time = convertToEpochTime(dates, units)
-
-            time = zeros(size(dates), "int64");
-            indices = ~isnat(dates);
-
-            % convertTo uses Jan-1-1970 as the default epoch. If the input
-            % datetime array has a TimeZone, the epoch is Jan-1-1970 UTC.
-            %
-            % TODO: convertTo may error if the datetime is 2^63-1 before or
-            % after the epoch. We should throw a custom error in this case.
-            time(indices) = convertTo(dates(indices), "epochtime", TicksPerSecond=ticksPerSecond(units));
-        end
-    end
-
     methods(Static)
         function array = fromMATLAB(data, opts)
             arguments
@@ -74,9 +59,8 @@
             
             arrow.internal.validate.type(data, "datetime");
             arrow.internal.validate.shape(data);
-
             validElements = arrow.internal.validate.parseValidElements(data, opts);
-            epochTime = arrow.array.TimestampArray.convertToEpochTime(data, opts.TimeUnit);
+            epochTime = arrow.array.internal.temporal.convertDatetimeToEpochTime(data, opts.TimeUnit);
             timezone = string(data.TimeZone);
 
             args = struct(MatlabArray=epochTime, Valid=validElements, TimeZone=timezone, TimeUnit=string(opts.TimeUnit));
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index f7a9bda927075..c0bedaf2faf39 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -102,7 +102,7 @@
 end
 
 function dateClasses = getDateArrayClasses()
-    dateClasses = compose("arrow.array.Date%dArray", 32);
+    dateClasses = compose("arrow.array.Date%dArray", [32 64]);
 end
 
 function number = randomNumbers(numberType, numElements)
diff --git a/matlab/src/matlab/+arrow/+type/+traits/Date64Traits.m b/matlab/src/matlab/+arrow/+type/+traits/Date64Traits.m
new file mode 100644
index 0000000000000..c7ff4ac2f8245
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/Date64Traits.m
@@ -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.
+
+classdef Date64Traits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        ArrayConstructor = @arrow.array.Date64Array
+        ArrayClassName = "arrow.array.Date64Array"
+        ArrayProxyClassName = "arrow.array.proxy.Date64Array"
+        ArrayStaticConstructor = @arrow.array.Date64Array.fromMATLAB
+        TypeConstructor = @arrow.type.Date64Type;
+        TypeClassName = "arrow.type.Date64Type"
+        TypeProxyClassName = "arrow.type.proxy.Date64Type"
+        MatlabConstructor = @datetime
+        MatlabClassName = "datetime"
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index b1f6193a3e7c1..78804fdccb3f0 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -54,6 +54,8 @@
                 typeTraits = Time64Traits();
             case ID.Date32
                 typeTraits = Date32Traits();
+            case ID.Date64
+                typeTraits = Date64Traits();
             otherwise
                 error("arrow:type:traits:UnsupportedArrowTypeID", "Unsupported Arrow type ID: " + type);
         end
diff --git a/matlab/src/matlab/+arrow/+type/DateUnit.m b/matlab/src/matlab/+arrow/+type/DateUnit.m
index bb82de5b02ab3..45354be62f59a 100644
--- a/matlab/src/matlab/+arrow/+type/DateUnit.m
+++ b/matlab/src/matlab/+arrow/+type/DateUnit.m
@@ -21,4 +21,19 @@
         Millisecond  (1)
     end
 
+    methods (Hidden)
+
+        function ticks = ticksPerSecond(obj)
+            import arrow.type.DateUnit
+            switch obj
+                case DateUnit.Millisecond
+                    ticks = 1e3;
+                otherwise
+                    error("arrow:dateunit:UnsupportedTicksPerSecond", ...
+                        "The ticksPerSecond method can only be called on a DateUnit of type Millisecond.");
+            end
+        end
+
+    end
+
 end
diff --git a/matlab/test/arrow/array/tDate64Array.m b/matlab/test/arrow/array/tDate64Array.m
new file mode 100644
index 0000000000000..57eb3b0ca7d95
--- /dev/null
+++ b/matlab/test/arrow/array/tDate64Array.m
@@ -0,0 +1,316 @@
+%TDATE64ARRAY Unit tests for arrow.array.Date64Array
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDate64Array < matlab.unittest.TestCase
+
+    properties
+        ArrowArrayConstructorFcn = @arrow.array.Date64Array.fromMATLAB
+    end
+
+    properties (Constant)
+        UnixEpoch = datetime(0, ConvertFrom="posixtime");
+        MissingDates = [datetime(2023, 1, 1), NaT, NaT, datetime(2022, 1, 1), NaT];
+    end
+
+    methods (Test)
+
+        function TestBasic(testCase)
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyInstanceOf(array, "arrow.array.Date64Array");
+        end
+
+        function TestTypeIsDate64(testCase)
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyDate64Type(array.Type);
+        end
+
+        function TestLength(testCase)
+            dates = datetime.empty(0, 1);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+
+            dates = datetime(2023, 1, 1);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(1));
+
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(10));
+        end
+
+        function TestToMATLAB(testCase)
+            % Verify toMATLAB() round-trips the original datetime array.
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            values = toMATLAB(array);
+            testCase.verifyEqual(values, dates');
+        end
+
+        function TestDatetime(testCase)
+            % Verify datetime() round-trips the original datetime array.
+            dates = testCase.UnixEpoch + days(1:10);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            values = datetime(array);
+            testCase.verifyEqual(values, dates');
+        end
+
+        function TestValid(testCase)
+            % Verify the Valid property returns the expected logical vector.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Valid, [true; false; false; true; false]);
+            testCase.verifyEqual(toMATLAB(array), dates');
+            testCase.verifyEqual(datetime(array), dates');
+        end
+
+        function TestInferNullsTrueNVPair(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() behaves as
+            % expected when InferNulls=true is provided.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates, InferNulls=true);
+            expectedValid = [true; false; false; true; false];
+            testCase.verifyEqual(array.Valid, expectedValid);
+            testCase.verifyEqual(toMATLAB(array), dates');
+            testCase.verifyEqual(datetime(array), dates');
+        end
+
+        function TestInferNullsFalseNVPair(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() behaves as
+            % expected when InferNulls=false is provided.
+            dates = testCase.MissingDates;
+            array = testCase.ArrowArrayConstructorFcn(dates, InferNulls=false);
+            expectedValid = [true; true; true; true; true];
+            testCase.verifyEqual(array.Valid, expectedValid);
+
+            % If NaT datetimes were not considered null values, then they
+            % are treated like int64(0) - i.e. the Unix epoch.
+            expectedDates = dates';
+            expectedDates([2, 3, 5]) = testCase.UnixEpoch;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+            testCase.verifyEqual(datetime(array), expectedDates);
+        end
+
+        function TestValidNVPair(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() accepts the Valid
+            % nv-pair, and it behaves as expected.
+            dates = testCase.MissingDates;
+
+            % Supply the Valid name-value pair as vector of indices.
+            array = testCase.ArrowArrayConstructorFcn(dates, Valid=[1, 2, 3]);
+            testCase.verifyEqual(array.Valid, [true; true; true; false; false]);
+            expectedDates = dates';
+            expectedDates([2, 3]) = testCase.UnixEpoch;
+            expectedDates([4, 5]) = NaT;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+
+            % Supply the Valid name-value pair as a logical scalar.
+            array = testCase.ArrowArrayConstructorFcn(dates, Valid=false);
+            testCase.verifyEqual(array.Valid, [false; false; false; false; false]);
+            expectedDates(:) = NaT;
+            testCase.verifyEqual(toMATLAB(array), expectedDates);
+        end
+
+        function TestEmptyDatetimeVector(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() accepts any
+            % empty-shaped datetime as input.
+
+            dates = datetime.empty(0, 0);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
+
+            % Test with an N-Dimensional empty array
+            dates = datetime.empty(0, 1, 0);
+            array = testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.Valid, logical.empty(0, 1));
+            testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
+        end
+
+        function TestErrorIfNonVector(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() throws an error
+            % if the input provided is not a vector.
+
+            dates = datetime(2023, 1, 1) + days(1:12);
+            dates = reshape(dates, 2, 6);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+
+            dates = reshape(dates, 3, 2, 2);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidShape");
+        end
+
+        function TestErrorIfNonDatetime(testCase)
+            % Verify arrow.array.Date64Array.fromMATLAB() throws an error
+            % if not given a datetime as input.
+
+            dates = duration(1, 2, 3);
+            fcn = @() testCase.ArrowArrayConstructorFcn(dates);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+
+            numbers = [1; 2; 3; 4];
+            fcn = @() testCase.ArrowArrayConstructorFcn(numbers);
+            testCase.verifyError(fcn, "arrow:array:InvalidType");
+        end
+
+        function TestInt64MaxMilliseconds(testCase)
+            % Verify that no precision is lost when trying to round-trip a
+            % datetime value that is within abs(intmin("int64")) milliseconds before
+            % and intmax("int64") days after the UNIX epoch.
+
+            ticksPerSecond = 1e3;
+
+            numMillisecondsBefore = intmin("int64");
+            numMillisecondsAfter = intmax("int64");
+
+            expectedBefore = datetime(numMillisecondsBefore, ConvertFrom="epochtime", ...
+                Epoch=testCase.UnixEpoch, TicksPerSecond=ticksPerSecond);
+            expectedAfter = datetime(numMillisecondsAfter, ConvertFrom="epochtime", ...
+                Epoch=testCase.UnixEpoch, TicksPerSecond=ticksPerSecond);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedBefore);
+            actualBefore = array.toMATLAB();
+            testCase.verifyEqual(actualBefore, expectedBefore);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedAfter);
+            actualAfter = array.toMATLAB();
+            testCase.verifyEqual(actualAfter, expectedAfter);
+        end
+
+        function TestZonedDatetime(testCase)
+            % Verify that zoned datetimes are supported as inputs to the
+            % fromMATLAB method and that the output datetime returned by
+            % the toMATLAB method is unzoned.
+            zoned = testCase.UnixEpoch + days(10);
+            zoned.TimeZone = "America/New_York";
+
+            expected = zoned;
+            % Set the TimeZone of the expected datetime value to "UTC"
+            % to trigger a time adjustment to UTC-relative time.
+            % Date64Array values are implicitly relative to UTC time, so
+            % adjusting the expected datetime value to UTC will ensure that
+            % the actual and expected datetimes represent the same "instant-in-time".
+            expected.TimeZone = "UTC";
+            % datetimes returned by the toMATLAB method of Date64Array are unzoned.
+            % Set the TimeZone of the expected datetime to a 0x0 empty char array
+            % in order to make the datetime unzoned.
+            expected.TimeZone = char.empty(0, 0);
+
+            array = testCase.ArrowArrayConstructorFcn(zoned);
+            actual = array.toMATLAB();
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function TestInt64MaxMillisecondsZoned(testCase)
+            % Verify that zoned datetimes which are within abs(intmin("int64")) days
+            % before and intmax("int64") days after the UNIX epoch are round-tripped
+            % (not including the TimeZone).
+
+            ticksPerSecond = 1e3;
+
+            numMillisecondsBefore = intmin("int64");
+            numMillisecondsAfter = intmax("int64");
+
+            expectedBefore = datetime(numMillisecondsBefore, ConvertFrom="epochtime", ...
+                Epoch=testCase.UnixEpoch, TicksPerSecond=ticksPerSecond);
+            expectedAfter = datetime(numMillisecondsAfter, ConvertFrom="epochtime", ...
+                Epoch=testCase.UnixEpoch, TicksPerSecond=ticksPerSecond);
+
+            expectedZonedBefore = expectedBefore;
+            expectedZonedBefore.TimeZone = "UTC";
+
+            expectedZonedAfter = expectedAfter;
+            expectedZonedAfter.TimeZone = "UTC";
+
+            array = testCase.ArrowArrayConstructorFcn(expectedZonedBefore);
+            actualBefore = array.toMATLAB();
+            testCase.verifyEqual(actualBefore, expectedBefore);
+
+            array = testCase.ArrowArrayConstructorFcn(expectedZonedAfter);
+            actualAfter = array.toMATLAB();
+            testCase.verifyEqual(actualAfter, expectedAfter);
+        end
+
+        function TestIsEqualTrue(tc)
+            % Verifies arrays are considered equal if:
+            %
+            %  1. Their Type properties are equal
+            %  2. They have the same length (i.e. their Length properties are equal)
+            %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
+            %  4. All corresponding valid elements have the same values
+
+            dates1 = datetime(2023, 6, 22)  + days(0:4);
+            dates2 = datetime(2023, 6, 22) + days([0 1 5 3 4]);
+
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+
+            tc.verifyTrue(isequal(array1, array2));
+            tc.verifyTrue(isequal(array1, array3));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyTrue(isequal(array1, array2, array3));
+        end
+
+        function TestIsEqualFalse(tc)
+            % Verify isequal returns false when expected.
+            dates1 = datetime(2023, 6, 22) + days(0:4);
+            dates2 = datetime(2023, 6, 22) + days([1 1 2 3 4]);
+            dates3 = datetime(2023, 6, 22) + days(0:5);
+            array1 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 2 4]);
+            array2 = tc.ArrowArrayConstructorFcn(dates1, Valid=[1 4]);
+            array3 = tc.ArrowArrayConstructorFcn(dates2, Valid=[1 2 4]);
+            array4 = arrow.array([true false true false]);
+            array5 = tc.ArrowArrayConstructorFcn(dates3, Valid=[1 2 4]);
+
+            % Their validity bitmaps are not equal
+            tc.verifyFalse(isequal(array1, array2));
+
+            % Not all corresponding valid elements are equal
+            tc.verifyFalse(isequal(array1, array3));
+
+            % Their Type properties are not equal
+            tc.verifyFalse(isequal(array1, array4));
+
+            % Their Length properties are not equal
+            tc.verifyFalse(isequal(array1, array5));
+
+            % Comparing an arrow.array.Array to a MATLAB double
+            tc.verifyFalse(isequal(array1, 1));
+
+            % Test supplying more than two arrays to isequal
+            tc.verifyFalse(isequal(array1, array1, array3, array4, array5));
+        end
+
+    end
+
+    methods
+
+        function verifyDate64Type(testCase, actual)
+            testCase.verifyInstanceOf(actual, "arrow.type.Date64Type");
+            testCase.verifyEqual(actual.ID, arrow.type.ID.Date64);
+            testCase.verifyEqual(actual.DateUnit, arrow.type.DateUnit.Millisecond);
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/traits/tDate64Traits.m b/matlab/test/arrow/type/traits/tDate64Traits.m
new file mode 100644
index 0000000000000..1dc3b38b7f755
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tDate64Traits.m
@@ -0,0 +1,33 @@
+%TDATE64TRAITS Unit tests for arrow.type.traits.Date64Traits
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDate64Traits < hTypeTraits
+
+    properties
+        TraitsConstructor = @arrow.type.traits.Date64Traits
+        ArrayConstructor = @arrow.array.Date64Array
+        ArrayClassName = "arrow.array.Date64Array"
+        ArrayProxyClassName = "arrow.array.proxy.Date64Array"
+        ArrayStaticConstructor = @arrow.array.Date64Array.fromMATLAB
+        TypeConstructor = @arrow.type.Date64Type
+        TypeClassName = "arrow.type.Date64Type"
+        TypeProxyClassName = "arrow.type.proxy.Date64Type"
+        MatlabConstructor = @datetime
+        MatlabClassName = "datetime"
+    end
+
+end
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index 70508a5e7cfbf..cdc5990ed03ba 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -187,6 +187,18 @@ function TestDate32(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestDate64(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.Date64;
+            expectedTraits = Date64Traits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 

From 5cd140b83481a366f9ff692e9bf1bd71ae547a16 Mon Sep 17 00:00:00 2001
From: Frederic Branczyk <fbranczyk@gmail.com>
Date: Wed, 6 Sep 2023 20:09:25 +0200
Subject: [PATCH 324/749] GH-37584: [Go] Add value len function to string array
 (#37586)

### Rationale for this change

The binary array already has this function, and it's a useful mechanism when all one needs is the length of a value and not the value itself (for pre-allocation of a new buffer for example).

### What changes are included in this PR?

Add function to return only the length of the string at index position `i`.

### Are these changes tested?

Yes tested by including this in https://parca.dev/

### Are there any user-facing changes?

This is a new API mirroring the same API that already exists on the binary array.
* Closes: #37584

Authored-by: Frederic Branczyk <fbranczyk@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/string.go      |  8 ++++++++
 go/arrow/array/string_test.go | 25 +++++++++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 61e964004de5d..86e27c970cbe9 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -73,6 +73,14 @@ func (a *String) ValueOffset64(i int) int64 {
 	return int64(a.ValueOffset(i))
 }
 
+func (a *String) ValueLen(i int) int {
+	if i < 0 || i >= a.array.data.length {
+		panic("arrow/array: index out of range")
+	}
+	beg := a.array.data.offset + i
+	return int(a.offsets[beg+1] - a.offsets[beg])
+}
+
 func (a *String) ValueOffsets() []int32 {
 	beg := a.array.data.offset
 	end := beg + a.array.data.length + 1
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index 0966ef17395ee..fbc106b098332 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -594,3 +594,28 @@ func TestLargeStringStringRoundTrip(t *testing.T) {
 
 	assert.True(t, array.Equal(arr, arr1))
 }
+
+func TestStringValueLen(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer mem.AssertSize(t, 0)
+
+	values := []string{"a", "bc", "", "", "hijk", "lm", "", "opq", "", "tu"}
+	valids := []bool{true, true, false, false, true, true, true, true, false, true}
+
+	b := array.NewStringBuilder(mem)
+	defer b.Release()
+
+	b.AppendStringValues(values, valids)
+
+	arr := b.NewArray().(*array.String)
+	defer arr.Release()
+
+	slice := array.NewSlice(arr, 2, 9).(*array.String)
+	defer slice.Release()
+
+	vs := values[2:9]
+
+	for i, v := range vs {
+		assert.Equal(t, len(v), slice.ValueLen(i))
+	}
+}

From cf0cf9bdaaad89d603fe0d6b1daa8a482f3670b7 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <pitrou@free.fr>
Date: Wed, 6 Sep 2023 20:47:26 +0200
Subject: [PATCH 325/749] GH-37587: [C++] Move integration machinery into its
 own directory and namespace (#37588)

### Rationale for this change

The JSON integration machinery currently lives in the `arrow::testing` namespace and the corresponding directory, but it can be compiled and used even when testing is disabled.

### What changes are included in this PR?

Move the integration machinery source files into a new `arrow/integration` directory.

Move the integration APIs into a new `arrow::internal::integration` namespace.

### Are these changes tested?

By existing tests and CI jobs.

### Are there any user-facing changes?

No, as these are not supposed to be public-facing facilities.

* Closes: #37587

Lead-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/CMakeLists.txt                  | 21 ++++++++----
 .../test_integration_client.cc                | 10 +++---
 .../test_integration_server.cc                |  1 -
 cpp/src/arrow/flight/sql/test_server_cli.cc   |  1 -
 cpp/src/arrow/integration/CMakeLists.txt      | 33 +++++++++++++++++++
 .../json_integration.cc                       | 19 ++++-------
 .../json_integration.h                        | 10 +++---
 .../json_integration_test.cc                  | 23 ++++++-------
 .../{testing => integration}/json_internal.cc | 25 ++++++--------
 .../{testing => integration}/json_internal.h  | 20 +++++------
 cpp/src/arrow/testing/CMakeLists.txt          | 15 ---------
 11 files changed, 95 insertions(+), 83 deletions(-)
 create mode 100644 cpp/src/arrow/integration/CMakeLists.txt
 rename cpp/src/arrow/{testing => integration}/json_integration.cc (95%)
 rename cpp/src/arrow/{testing => integration}/json_integration.h (94%)
 rename cpp/src/arrow/{testing => integration}/json_integration_test.cc (98%)
 rename cpp/src/arrow/{testing => integration}/json_internal.cc (99%)
 rename cpp/src/arrow/{testing => integration}/json_internal.h (94%)

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 9ecf2b51c91bf..427463bb1657b 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -332,8 +332,6 @@ set(ARROW_TESTING_STATIC_LINK_LIBS arrow::flatbuffers rapidjson::rapidjson arrow
 set(ARROW_TESTING_SRCS
     io/test_common.cc
     ipc/test_common.cc
-    testing/json_integration.cc
-    testing/json_internal.cc
     testing/gtest_util.cc
     testing/random.cc
     testing/generator.cc
@@ -375,6 +373,10 @@ endif()
 # Configure the base Arrow libraries
 #
 
+if(ARROW_BUILD_INTEGRATION OR ARROW_BUILD_TESTS)
+  list(APPEND ARROW_SRCS integration/json_integration.cc integration/json_internal.cc)
+endif()
+
 if(ARROW_CSV)
   list(APPEND
        ARROW_SRCS
@@ -836,12 +838,15 @@ add_subdirectory(tensor)
 add_subdirectory(util)
 add_subdirectory(vendored)
 
-if(ARROW_CSV)
-  add_subdirectory(csv)
+if(ARROW_BUILD_INTEGRATION OR ARROW_BUILD_TESTS)
+  # We build tests for the JSON integration machinery even if integration
+  # is not enabled, to ensure it's exercised in more builds than just the
+  # integration build.
+  add_subdirectory(integration)
 endif()
 
-if(ARROW_SUBSTRAIT)
-  add_subdirectory(engine)
+if(ARROW_CSV)
+  add_subdirectory(csv)
 endif()
 
 if(ARROW_ACERO)
@@ -877,6 +882,10 @@ if(ARROW_ORC)
   add_subdirectory(adapters/orc)
 endif()
 
+if(ARROW_SUBSTRAIT)
+  add_subdirectory(engine)
+endif()
+
 if(ARROW_TENSORFLOW)
   add_subdirectory(adapters/tensorflow)
 endif()
diff --git a/cpp/src/arrow/flight/integration_tests/test_integration_client.cc b/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
index db72c9f4b0613..c5c3f10576d32 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration_client.cc
@@ -29,6 +29,7 @@
 
 #include <gflags/gflags.h>
 
+#include "arrow/integration/json_integration.h"
 #include "arrow/io/file.h"
 #include "arrow/io/test_common.h"
 #include "arrow/ipc/dictionary.h"
@@ -37,7 +38,6 @@
 #include "arrow/table.h"
 #include "arrow/testing/extension_type.h"
 #include "arrow/testing/gtest_util.h"
-#include "arrow/testing/json_integration.h"
 #include "arrow/util/logging.h"
 
 #include "arrow/flight/api.h"
@@ -49,12 +49,14 @@ DEFINE_int32(port, 31337, "Server port to connect to");
 DEFINE_string(path, "", "Resource path to request");
 DEFINE_string(scenario, "", "Integration test scenario to run");
 
+using arrow::internal::integration::IntegrationJsonReader;
+
 namespace arrow {
 namespace flight {
 namespace integration_tests {
 
 /// \brief Helper to read all batches from a JsonReader
-Status ReadBatches(std::unique_ptr<testing::IntegrationJsonReader>& reader,
+Status ReadBatches(std::unique_ptr<IntegrationJsonReader>& reader,
                    std::vector<std::shared_ptr<RecordBatch>>* chunks) {
   for (int i = 0; i < reader->num_record_batches(); i++) {
     ARROW_ASSIGN_OR_RAISE(auto chunk, reader->ReadRecordBatch(i));
@@ -151,8 +153,8 @@ class IntegrationTestScenario : public Scenario {
     // 1. Put the data to the server.
     std::cout << "Opening JSON file '" << FLAGS_path << "'" << std::endl;
     auto in_file = *io::ReadableFile::Open(FLAGS_path);
-    ARROW_ASSIGN_OR_RAISE(auto reader, testing::IntegrationJsonReader::Open(
-                                           default_memory_pool(), in_file));
+    ARROW_ASSIGN_OR_RAISE(auto reader,
+                          IntegrationJsonReader::Open(default_memory_pool(), in_file));
 
     std::shared_ptr<Schema> original_schema = reader->schema();
     std::vector<std::shared_ptr<RecordBatch>> original_data;
diff --git a/cpp/src/arrow/flight/integration_tests/test_integration_server.cc b/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
index 4c5b87523b5fa..be65edf78d8cb 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
@@ -31,7 +31,6 @@
 #include "arrow/io/test_common.h"
 #include "arrow/record_batch.h"
 #include "arrow/table.h"
-#include "arrow/testing/json_integration.h"
 #include "arrow/util/logging.h"
 
 #include "arrow/flight/integration_tests/test_integration.h"
diff --git a/cpp/src/arrow/flight/sql/test_server_cli.cc b/cpp/src/arrow/flight/sql/test_server_cli.cc
index e847b1137aecd..8f5a78ce268f5 100644
--- a/cpp/src/arrow/flight/sql/test_server_cli.cc
+++ b/cpp/src/arrow/flight/sql/test_server_cli.cc
@@ -25,7 +25,6 @@
 #include "arrow/flight/server.h"
 #include "arrow/flight/sql/example/sqlite_server.h"
 #include "arrow/io/test_common.h"
-#include "arrow/testing/json_integration.h"
 #include "arrow/util/logging.h"
 
 DEFINE_int32(port, 31337, "Server port to listen on");
diff --git a/cpp/src/arrow/integration/CMakeLists.txt b/cpp/src/arrow/integration/CMakeLists.txt
new file mode 100644
index 0000000000000..0d7b7e5a7d47d
--- /dev/null
+++ b/cpp/src/arrow/integration/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT 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_install_all_headers("arrow/integration")
+
+# json_integration_test is two things at the same time:
+# - an executable that can be called to answer integration test requests
+# - a self-(unit)test for the C++ side of integration testing
+if(ARROW_BUILD_TESTS)
+  add_arrow_test(json_integration_test EXTRA_LINK_LIBS ${GFLAGS_LIBRARIES})
+  add_dependencies(arrow-integration arrow-json-integration-test)
+elseif(ARROW_BUILD_INTEGRATION)
+  add_executable(arrow-json-integration-test json_integration_test.cc)
+  target_link_libraries(arrow-json-integration-test ${ARROW_TEST_LINK_LIBS}
+                        ${GFLAGS_LIBRARIES} ${ARROW_GTEST_GTEST})
+
+  add_dependencies(arrow-json-integration-test arrow arrow_testing)
+  add_dependencies(arrow-integration arrow-json-integration-test)
+endif()
diff --git a/cpp/src/arrow/testing/json_integration.cc b/cpp/src/arrow/integration/json_integration.cc
similarity index 95%
rename from cpp/src/arrow/testing/json_integration.cc
rename to cpp/src/arrow/integration/json_integration.cc
index e87566502b1dc..178abe5e8b687 100644
--- a/cpp/src/arrow/testing/json_integration.cc
+++ b/cpp/src/arrow/integration/json_integration.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/testing/json_integration.h"
+#include "arrow/integration/json_integration.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -24,25 +24,19 @@
 #include <utility>
 
 #include "arrow/buffer.h"
+#include "arrow/integration/json_internal.h"
 #include "arrow/io/file.h"
 #include "arrow/ipc/dictionary.h"
 #include "arrow/record_batch.h"
 #include "arrow/result.h"
 #include "arrow/status.h"
-#include "arrow/testing/json_internal.h"
 #include "arrow/type.h"
 #include "arrow/util/logging.h"
 
-#include <rapidjson/document.h>
-#include <rapidjson/stringbuffer.h>
-#include <rapidjson/writer.h>
+using arrow::ipc::DictionaryFieldMapper;
+using arrow::ipc::DictionaryMemo;
 
-namespace arrow {
-
-using ipc::DictionaryFieldMapper;
-using ipc::DictionaryMemo;
-
-namespace testing {
+namespace arrow::internal::integration {
 
 // ----------------------------------------------------------------------
 // Writer implementation
@@ -211,5 +205,4 @@ Result<std::shared_ptr<RecordBatch>> IntegrationJsonReader::ReadRecordBatch(int
   return impl_->ReadRecordBatch(i);
 }
 
-}  // namespace testing
-}  // namespace arrow
+}  // namespace arrow::internal::integration
diff --git a/cpp/src/arrow/testing/json_integration.h b/cpp/src/arrow/integration/json_integration.h
similarity index 94%
rename from cpp/src/arrow/testing/json_integration.h
rename to cpp/src/arrow/integration/json_integration.h
index c2d0c104a6077..0284ef6c89d97 100644
--- a/cpp/src/arrow/testing/json_integration.h
+++ b/cpp/src/arrow/integration/json_integration.h
@@ -24,16 +24,16 @@
 
 #include "arrow/io/type_fwd.h"
 #include "arrow/result.h"
-#include "arrow/testing/visibility.h"
 #include "arrow/type_fwd.h"
+#include "arrow/util/visibility.h"
 
-namespace arrow::testing {
+namespace arrow::internal::integration {
 
 /// \class IntegrationJsonWriter
 /// \brief Write the JSON representation of an Arrow record batch file or stream
 ///
 /// This is used for integration testing
-class ARROW_TESTING_EXPORT IntegrationJsonWriter {
+class ARROW_EXPORT IntegrationJsonWriter {
  public:
   ~IntegrationJsonWriter();
 
@@ -64,7 +64,7 @@ class ARROW_TESTING_EXPORT IntegrationJsonWriter {
 /// \brief Read the JSON representation of an Arrow record batch file or stream
 ///
 /// This is used for integration testing
-class ARROW_TESTING_EXPORT IntegrationJsonReader {
+class ARROW_EXPORT IntegrationJsonReader {
  public:
   ~IntegrationJsonReader();
 
@@ -111,4 +111,4 @@ class ARROW_TESTING_EXPORT IntegrationJsonReader {
   std::unique_ptr<Impl> impl_;
 };
 
-}  // namespace arrow::testing
+}  // namespace arrow::internal::integration
diff --git a/cpp/src/arrow/testing/json_integration_test.cc b/cpp/src/arrow/integration/json_integration_test.cc
similarity index 98%
rename from cpp/src/arrow/testing/json_integration_test.cc
rename to cpp/src/arrow/integration/json_integration_test.cc
index e950d36ce00d7..e023e6a3a44d3 100644
--- a/cpp/src/arrow/testing/json_integration_test.cc
+++ b/cpp/src/arrow/integration/json_integration_test.cc
@@ -31,6 +31,8 @@
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
 #include "arrow/array/builder_primitive.h"
+#include "arrow/integration/json_integration.h"
+#include "arrow/integration/json_internal.h"
 #include "arrow/io/file.h"
 #include "arrow/ipc/dictionary.h"
 #include "arrow/ipc/reader.h"
@@ -41,8 +43,6 @@
 #include "arrow/testing/builder.h"
 #include "arrow/testing/extension_type.h"
 #include "arrow/testing/gtest_util.h"
-#include "arrow/testing/json_integration.h"
-#include "arrow/testing/json_internal.h"
 #include "arrow/testing/random.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
@@ -65,15 +65,13 @@ DEFINE_bool(validate_date64, true,
 DEFINE_bool(validate_times, true,
             "Validate that values for TIME32 and TIME64 are within their valid ranges");
 
-namespace arrow {
+namespace arrow::internal::integration {
 
-using internal::TemporaryDir;
-using ipc::DictionaryFieldMapper;
-using ipc::DictionaryMemo;
-using ipc::IpcWriteOptions;
-using ipc::MetadataVersion;
-
-namespace testing {
+using ::arrow::internal::TemporaryDir;
+using ::arrow::ipc::DictionaryFieldMapper;
+using ::arrow::ipc::DictionaryMemo;
+using ::arrow::ipc::IpcWriteOptions;
+using ::arrow::ipc::MetadataVersion;
 
 using namespace ::arrow::ipc::test;  // NOLINT
 
@@ -1176,8 +1174,7 @@ const std::vector<ipc::test::MakeRecordBatch*> kBatchCases = {
 INSTANTIATE_TEST_SUITE_P(TestJsonRoundTrip, TestJsonRoundTrip,
                          ::testing::ValuesIn(kBatchCases));
 
-}  // namespace testing
-}  // namespace arrow
+}  // namespace arrow::internal::integration
 
 int main(int argc, char** argv) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
@@ -1186,7 +1183,7 @@ int main(int argc, char** argv) {
 
   if (FLAGS_integration) {
     arrow::Status result =
-        arrow::testing::RunCommand(FLAGS_json, FLAGS_arrow, FLAGS_mode);
+        arrow::internal::integration::RunCommand(FLAGS_json, FLAGS_arrow, FLAGS_mode);
     if (!result.ok()) {
       std::cout << "Error message: " << result.ToString() << std::endl;
       ret = 1;
diff --git a/cpp/src/arrow/testing/json_internal.cc b/cpp/src/arrow/integration/json_internal.cc
similarity index 99%
rename from cpp/src/arrow/testing/json_internal.cc
rename to cpp/src/arrow/integration/json_internal.cc
index ead0625e7bf3d..ed7be4b502985 100644
--- a/cpp/src/arrow/testing/json_internal.cc
+++ b/cpp/src/arrow/integration/json_internal.cc
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include "arrow/testing/json_internal.h"
+#include "arrow/integration/json_internal.h"
 
 #include <cstdint>
 #include <cstdlib>
@@ -53,19 +53,16 @@
 #include "arrow/visit_array_inline.h"
 #include "arrow/visit_type_inline.h"
 
-namespace arrow {
+using arrow::internal::checked_cast;
+using arrow::internal::Enumerate;
+using arrow::internal::ParseValue;
+using arrow::internal::Zip;
 
-using internal::checked_cast;
-using internal::Enumerate;
-using internal::ParseValue;
-using internal::Zip;
+using arrow::ipc::DictionaryFieldMapper;
+using arrow::ipc::DictionaryMemo;
+using arrow::ipc::internal::FieldPosition;
 
-using ipc::DictionaryFieldMapper;
-using ipc::DictionaryMemo;
-using ipc::internal::FieldPosition;
-
-namespace testing {
-namespace json {
+namespace arrow::internal::integration::json {
 
 namespace {
 
@@ -1814,6 +1811,4 @@ Status WriteArray(const std::string& name, const Array& array, RjWriter* json_wr
   return converter.Write();
 }
 
-}  // namespace json
-}  // namespace testing
-}  // namespace arrow
+}  // namespace arrow::internal::integration::json
diff --git a/cpp/src/arrow/testing/json_internal.h b/cpp/src/arrow/integration/json_internal.h
similarity index 94%
rename from cpp/src/arrow/testing/json_internal.h
rename to cpp/src/arrow/integration/json_internal.h
index ca382782af1c1..ac5bd2069d39c 100644
--- a/cpp/src/arrow/testing/json_internal.h
+++ b/cpp/src/arrow/integration/json_internal.h
@@ -32,8 +32,8 @@
 
 #include "arrow/ipc/type_fwd.h"
 #include "arrow/result.h"
-#include "arrow/testing/visibility.h"
 #include "arrow/type_fwd.h"
+#include "arrow/util/visibility.h"
 
 namespace rj = arrow::rapidjson;
 using RjWriter = rj::Writer<rj::StringBuffer>;
@@ -75,35 +75,35 @@ using RjObject = rj::Value::ConstObject;
     return Status::Invalid("field was not an object line ", __LINE__); \
   }
 
-namespace arrow::testing::json {
+namespace arrow::internal::integration::json {
 
 /// \brief Append integration test Schema format to rapidjson writer
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Status WriteSchema(const Schema& schema, const ipc::DictionaryFieldMapper& mapper,
                    RjWriter* writer);
 
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Status WriteDictionary(int64_t id, const std::shared_ptr<Array>& dictionary,
                        RjWriter* writer);
 
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Status WriteRecordBatch(const RecordBatch& batch, RjWriter* writer);
 
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Status WriteArray(const std::string& name, const Array& array, RjWriter* writer);
 
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Result<std::shared_ptr<Schema>> ReadSchema(const rj::Value& json_obj, MemoryPool* pool,
                                            ipc::DictionaryMemo* dictionary_memo);
 
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(
     const rj::Value& json_obj, const std::shared_ptr<Schema>& schema,
     ipc::DictionaryMemo* dict_memo, MemoryPool* pool);
 
 // NOTE: Doesn't work with dictionary arrays, use ReadRecordBatch instead.
-ARROW_TESTING_EXPORT
+ARROW_EXPORT
 Result<std::shared_ptr<Array>> ReadArray(MemoryPool* pool, const rj::Value& json_obj,
                                          const std::shared_ptr<Field>& field);
 
-}  // namespace arrow::testing::json
+}  // namespace arrow::internal::integration::json
diff --git a/cpp/src/arrow/testing/CMakeLists.txt b/cpp/src/arrow/testing/CMakeLists.txt
index 19c2a83efe28a..d5332405964ba 100644
--- a/cpp/src/arrow/testing/CMakeLists.txt
+++ b/cpp/src/arrow/testing/CMakeLists.txt
@@ -20,18 +20,3 @@ arrow_install_all_headers("arrow/testing")
 if(ARROW_BUILD_TESTS)
   add_arrow_test(random_test)
 endif()
-
-# json_integration_test is two things at the same time:
-# - an executable that can be called to answer integration test requests
-# - a self-(unit)test for the C++ side of integration testing
-if(ARROW_BUILD_TESTS)
-  add_arrow_test(json_integration_test EXTRA_LINK_LIBS ${GFLAGS_LIBRARIES})
-  add_dependencies(arrow-integration arrow-json-integration-test)
-elseif(ARROW_BUILD_INTEGRATION)
-  add_executable(arrow-json-integration-test json_integration_test.cc)
-  target_link_libraries(arrow-json-integration-test ${ARROW_TEST_LINK_LIBS}
-                        ${GFLAGS_LIBRARIES} ${ARROW_GTEST_GTEST})
-
-  add_dependencies(arrow-json-integration-test arrow arrow_testing)
-  add_dependencies(arrow-integration arrow-json-integration-test)
-endif()

From f7b6ddbe8787fe62f5bde5cf9e686380c60adc40 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 6 Sep 2023 16:33:07 -0400
Subject: [PATCH 326/749] GH-37591: [MATLAB] Make `arrow.type.Type` inherit
 from `matlab.mixin.Heterogeneous` (#37593)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

We should modify `arrow.type.Type` to inherit from `matlab.mixin.Heterogeneous` so that it's possible to create a nonscalar array containing different concrete subclasses of `arrow.type.Type`.

**Example**
```matlab
>> float32Type = arrow.float32();
>> timestampType = arrow.timestamp(TimeZone="Pacific/Fiji");
>> typeArray = [float32Type timestampType]

typeArray =

  1×2 heterogeneous FixedWidthType (Float32Type, TimestampType) array with properties:

    ID
```

Currently, running the example above results in an error:

```matlab
>> float32Type = arrow.float32();
>> timestampType = arrow.timestamp(TimeZone="Pacific/Fiji");
>> typeArray = [float32Type timestampType]
Error using horzcat
The following error occurred converting from arrow.type.TimestampType to arrow.type.Float32Type:
Invalid argument at position 1. Value must be of type libmexclass.proxy.Proxy or be convertible to libmexclass.proxy.Proxy.
```

### What changes are included in this PR?

1. Updated `arrow.type.Type` to inherit from `matlab.mixin.Heterogeneous`. Previously, it only inherited from `matlab.mixin.CustomDisplay`.
2. Because `arrow.type.Type` is now `heterogeneous`, its subclasses cannot override the protected method `getPropertyGroups` - which is inherited from `matlab.mixin.CustomDisplay`. This method must be `Sealed` and defined on `Type` because only `Sealed` methods can be called on nonscalar `heterogeneous` arrays. To get around this limitation, I defined a new abstract template method called `getDisplayPropertyGroups`, which `getPropertyGroups` invokes if the array is either scalar or nonscalar and `homogeneous`. Refer to [this link](https://www.mathworks.com/help/matlab/matlab_oop/custom-display-for-heterogeneous-arrays.html) for more details.

**Displaying a nonscalar *heterogeneous* `arrow.type.Type`**

```matlab
>> float32Type = arrow.timestamp(TimeUnit="Second");
>> timestampType = arrow.timestamp(TimeZone="Pacific/Fiji");
>> typeArray = [float32Type timestampType]

typeArray =

  1×2 heterogeneous FixedWidthType (Float32Type, TimestampType) array with properties:

    ID
```

**Displaying a nonscalar *homogeneous* `arrow.type.Type`**

```matlab
>> timestampType1 = arrow.timestamp(TimeUnit="Second");
>> timestampType2 = arrow.timestamp(TimeZone="Pacific/Fiji");
>> typeArray = [timestampType1 timestampType2]

typeArray =

  1×2 TimestampType array with properties:

    ID
    TimeUnit
    TimeZone
```

### Are these changes tested?

Yes

1. Added a new test class in `test/arrow/type` called `tDisplay.m`
2. Added display unit tests for all concrete subclasses of `arrow.type.Type` if they did not already exist.
3. Added a new test class in `test/arrow/type` called `tIsEqual.m`. This class contains unit tests verifying the `isequal` method of `arrow.type.Type` behaves as expected when called on heterogeneous arrays.

### Are there any user-facing changes?

Yes. Users can now create nonscalar  arrays with different concrete subclasses of `arrow.type.Type`.

### Future Directions

1. Move all display unit tests to `tDisplay.m`
2. Add an `arrow.type.NumericType` class from which all numeric types inherit. This class will define `getDisplayPropertyGroups` for all numeric types.

* Closes: #37591

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+type/BooleanType.m  |   7 +
 matlab/src/matlab/+arrow/+type/DateType.m     |   4 +-
 matlab/src/matlab/+arrow/+type/Float32Type.m  |   7 +
 matlab/src/matlab/+arrow/+type/Float64Type.m  |   7 +
 matlab/src/matlab/+arrow/+type/Int16Type.m    |   7 +
 matlab/src/matlab/+arrow/+type/Int32Type.m    |   7 +
 matlab/src/matlab/+arrow/+type/Int64Type.m    |   7 +
 matlab/src/matlab/+arrow/+type/Int8Type.m     |   7 +
 matlab/src/matlab/+arrow/+type/StringType.m   |   9 +-
 matlab/src/matlab/+arrow/+type/TimeType.m     |   4 +-
 .../src/matlab/+arrow/+type/TimestampType.m   |   6 +-
 matlab/src/matlab/+arrow/+type/Type.m         |  56 +++-
 matlab/src/matlab/+arrow/+type/UInt16Type.m   |   8 +
 matlab/src/matlab/+arrow/+type/UInt32Type.m   |   8 +
 matlab/src/matlab/+arrow/+type/UInt64Type.m   |   7 +
 matlab/src/matlab/+arrow/+type/UInt8Type.m    |   7 +
 matlab/test/arrow/type/tDate32Type.m          |  22 --
 matlab/test/arrow/type/tDate64Type.m          |  22 --
 matlab/test/arrow/type/tIsEqual.m             |  52 ++++
 matlab/test/arrow/type/tTime32Type.m          |  22 --
 matlab/test/arrow/type/tTime64Type.m          |  22 --
 matlab/test/arrow/type/tTimestampType.m       |  23 --
 matlab/test/arrow/type/tTypeDisplay.m         | 256 ++++++++++++++++++
 23 files changed, 452 insertions(+), 125 deletions(-)
 create mode 100644 matlab/test/arrow/type/tIsEqual.m
 create mode 100644 matlab/test/arrow/type/tTypeDisplay.m

diff --git a/matlab/src/matlab/+arrow/+type/BooleanType.m b/matlab/src/matlab/+arrow/+type/BooleanType.m
index 6afa00e9258cb..197ab515838f1 100644
--- a/matlab/src/matlab/+arrow/+type/BooleanType.m
+++ b/matlab/src/matlab/+arrow/+type/BooleanType.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/DateType.m b/matlab/src/matlab/+arrow/+type/DateType.m
index f8a3966602e12..ac6ece47ced4c 100644
--- a/matlab/src/matlab/+arrow/+type/DateType.m
+++ b/matlab/src/matlab/+arrow/+type/DateType.m
@@ -36,9 +36,9 @@
     end
 
     methods (Access=protected)
-        function group = getPropertyGroups(~)
+        function groups = getDisplayPropertyGroups(~)
             targets = ["ID" "DateUnit"];
-            group = matlab.mixin.util.PropertyGroup(targets);
+            groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+type/Float32Type.m b/matlab/src/matlab/+arrow/+type/Float32Type.m
index df5fa1ce844e9..98c9f5fd79aba 100644
--- a/matlab/src/matlab/+arrow/+type/Float32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Float32Type.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Float64Type.m b/matlab/src/matlab/+arrow/+type/Float64Type.m
index ba93265ebc73e..634e7d1a5cc6e 100644
--- a/matlab/src/matlab/+arrow/+type/Float64Type.m
+++ b/matlab/src/matlab/+arrow/+type/Float64Type.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Int16Type.m b/matlab/src/matlab/+arrow/+type/Int16Type.m
index c16d3fd5ca53f..ca59f1c077826 100644
--- a/matlab/src/matlab/+arrow/+type/Int16Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int16Type.m
@@ -25,5 +25,12 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+type/Int32Type.m b/matlab/src/matlab/+arrow/+type/Int32Type.m
index 786697bf1136b..68036d64859c1 100644
--- a/matlab/src/matlab/+arrow/+type/Int32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int32Type.m
@@ -25,5 +25,12 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+type/Int64Type.m b/matlab/src/matlab/+arrow/+type/Int64Type.m
index bf6c71d622a63..d5bd7ff3a5636 100644
--- a/matlab/src/matlab/+arrow/+type/Int64Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int64Type.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Int8Type.m b/matlab/src/matlab/+arrow/+type/Int8Type.m
index b28785f876ea8..5df75afe76035 100644
--- a/matlab/src/matlab/+arrow/+type/Int8Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int8Type.m
@@ -25,5 +25,12 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+type/StringType.m b/matlab/src/matlab/+arrow/+type/StringType.m
index c269bfa6db33c..53c73b3e33e52 100644
--- a/matlab/src/matlab/+arrow/+type/StringType.m
+++ b/matlab/src/matlab/+arrow/+type/StringType.m
@@ -24,6 +24,13 @@
             import arrow.internal.proxy.validate
             obj@arrow.type.Type(proxy);
         end
-   end
+    end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+type/TimeType.m b/matlab/src/matlab/+arrow/+type/TimeType.m
index 59d938788983f..a0f8beb70493d 100644
--- a/matlab/src/matlab/+arrow/+type/TimeType.m
+++ b/matlab/src/matlab/+arrow/+type/TimeType.m
@@ -36,9 +36,9 @@
     end
 
     methods (Access=protected)
-        function group = getPropertyGroups(~)
+        function groups = getDisplayPropertyGroups(~)
             targets = ["ID" "TimeUnit"];
-            group = matlab.mixin.util.PropertyGroup(targets);
+            groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+type/TimestampType.m b/matlab/src/matlab/+arrow/+type/TimestampType.m
index cb47743148310..07e61f9570790 100644
--- a/matlab/src/matlab/+arrow/+type/TimestampType.m
+++ b/matlab/src/matlab/+arrow/+type/TimestampType.m
@@ -42,9 +42,9 @@
     end
 
     methods (Access=protected)
-        function group = getPropertyGroups(~)
-          targets = ["ID" "TimeUnit" "TimeZone"];
-          group = matlab.mixin.util.PropertyGroup(targets);
+        function groups = getDisplayPropertyGroups(~)
+            targets = ["ID" "TimeUnit" "TimeZone"];
+            groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index cc2da1403b64c..8f4ce4dd6c765 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -13,7 +13,8 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef (Abstract) Type < matlab.mixin.CustomDisplay
+classdef (Abstract) Type < matlab.mixin.CustomDisplay & ...
+                           matlab.mixin.Heterogeneous
 %TYPE Abstract type class. 
 
     properties (Dependent, GetAccess=public, SetAccess=private)
@@ -42,14 +43,57 @@
         end
     end
 
-    methods (Access=protected)
-        function propgrp = getPropertyGroups(~)
-          proplist = {'ID'};
-          propgrp = matlab.mixin.util.PropertyGroup(proplist);
+    methods(Access = protected)
+        groups = getDisplayPropertyGroups(obj)
+    end
+
+    methods (Sealed, Access = protected)
+        function header = getHeader(obj)
+            header = getHeader@matlab.mixin.CustomDisplay(obj);
+        end
+ 
+        function groups = getPropertyGroups(obj)
+            if isscalar(obj)
+               groups = getDisplayPropertyGroups(obj);
+            else
+                % Check if every type in the array has the same class type.
+                % If so, call getDisplayPropertyGroups() so that all
+                % properties assoicated with that class are displayed.
+                classnames = arrayfun(@(type) string(class(type)), obj);
+                if numel(unique(classnames)) == 1
+                    groups = getDisplayPropertyGroups(obj(1));
+                else
+                    % If the array is heterogeneous, just display ID, which
+                    % is the only property shared by all concrete
+                    % subclasses of arrow.type.Type.
+                    proplist = "ID";
+                    groups = matlab.mixin.util.PropertyGroup(proplist);
+                end
+            end
+        end
+ 
+        function footer = getFooter(obj)
+            footer = getFooter@matlab.mixin.CustomDisplay(obj);
+        end
+ 
+        function displayNonScalarObject(obj)
+            displayNonScalarObject@matlab.mixin.CustomDisplay(obj);
+        end
+
+        function displayScalarObject(obj)
+            displayScalarObject@matlab.mixin.CustomDisplay(obj)
+        end
+
+        function displayEmptyObject(obj)
+            displayEmptyObject@matlab.mixin.CustomDisplay(obj);
+        end
+
+        function displayScalarHandleToDeletedObject(obj)
+            displayScalarHandleToDeletedObject@matlab.mixin.CustomDisplay(obj);
         end
     end
 
-    methods
+    methods (Sealed)
         function tf = isequal(obj, varargin)
 
             narginchk(2, inf);
diff --git a/matlab/src/matlab/+arrow/+type/UInt16Type.m b/matlab/src/matlab/+arrow/+type/UInt16Type.m
index 3198b78671ef9..d7600c982bcab 100644
--- a/matlab/src/matlab/+arrow/+type/UInt16Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt16Type.m
@@ -25,4 +25,12 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt32Type.m b/matlab/src/matlab/+arrow/+type/UInt32Type.m
index 53e60e4e34290..e16699cba5cab 100644
--- a/matlab/src/matlab/+arrow/+type/UInt32Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt32Type.m
@@ -25,4 +25,12 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt64Type.m b/matlab/src/matlab/+arrow/+type/UInt64Type.m
index f8512ec59497c..c190f252ab4c3 100644
--- a/matlab/src/matlab/+arrow/+type/UInt64Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt64Type.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt8Type.m b/matlab/src/matlab/+arrow/+type/UInt8Type.m
index 898426e3a4076..89715991ed519 100644
--- a/matlab/src/matlab/+arrow/+type/UInt8Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt8Type.m
@@ -25,4 +25,11 @@
             obj@arrow.type.FixedWidthType(proxy);
         end
     end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tDate32Type.m b/matlab/test/arrow/type/tDate32Type.m
index 71a9e5cf48fc6..c486772c455a7 100644
--- a/matlab/test/arrow/type/tDate32Type.m
+++ b/matlab/test/arrow/type/tDate32Type.m
@@ -40,28 +40,6 @@ function DefaultDateUnit(testCase)
             testCase.verifyEqual(actualUnit, expectedUnit);
         end
 
-        function Display(testCase)
-            % Verify the display of Date32Type objects.
-            %
-            % Example:
-            %
-            %  Date32Type with properties:
-            %
-            %          ID: Date32
-            %    DateUnit: Day
-            %
-            type = testCase.ConstructionFcn(); %#ok<NASGU>
-            classnameLink = "<a href=""matlab:helpPopup arrow.type.Date32Type"" style=""font-weight:bold"">Date32Type</a>";
-            header = "  " + classnameLink + " with properties:" + newline;
-            body = strjust(pad(["ID:"; "DateUnit:"]));
-            body = body + " " + ["Date32"; "Day"];
-            body = "    " + body;
-            footer = string(newline);
-            expectedDisplay = char(strjoin([header body' footer], newline));
-            actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-
         function DateUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the DateUnit property.
diff --git a/matlab/test/arrow/type/tDate64Type.m b/matlab/test/arrow/type/tDate64Type.m
index 9345f6dbde50b..b9e9c3637e9d0 100644
--- a/matlab/test/arrow/type/tDate64Type.m
+++ b/matlab/test/arrow/type/tDate64Type.m
@@ -40,28 +40,6 @@ function DefaultDateUnit(testCase)
             testCase.verifyEqual(actualUnit, expectedUnit);
         end
 
-        function Display(testCase)
-            % Verify the display of Date64Type objects.
-            %
-            % Example:
-            %
-            %  Date32Type with properties:
-            %
-            %          ID: Date64
-            %    DateUnit: Millisecond
-            %
-            type = testCase.ConstructionFcn(); %#ok<NASGU>
-            classnameLink = "<a href=""matlab:helpPopup arrow.type.Date64Type"" style=""font-weight:bold"">Date64Type</a>";
-            header = "  " + classnameLink + " with properties:" + newline;
-            body = strjust(pad(["ID:"; "DateUnit:"]));
-            body = body + " " + ["Date64"; "Millisecond"];
-            body = "    " + body;
-            footer = string(newline);
-            expectedDisplay = char(strjoin([header body' footer], newline));
-            actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-
         function DateUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the DateUnit property.
diff --git a/matlab/test/arrow/type/tIsEqual.m b/matlab/test/arrow/type/tIsEqual.m
new file mode 100644
index 0000000000000..babb08a04ef27
--- /dev/null
+++ b/matlab/test/arrow/type/tIsEqual.m
@@ -0,0 +1,52 @@
+%TISEQUAL Verifies the behavior of arrow.type.Type's isequal method on
+%nonscalar heterogeneous arrays.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tIsEqual < matlab.unittest.TestCase
+
+    methods (Test)
+        % Test methods
+
+        function IsEqualTrue(testCase)
+            float32Type = arrow.float32();
+            timestampType = arrow.timestamp(TimeUnit="Second");
+            typeArray = [float32Type, timestampType];
+            testCase.verifyTrue(isequal(typeArray, typeArray));
+        end
+
+        function IsEqualFalse(testCase)
+            float32Type = arrow.float32();
+            timestampType1 = arrow.timestamp(TimeUnit="Second");
+            typeArray1 = [float32Type, timestampType1];
+
+            % Their dimensions are not equal
+            testCase.verifyFalse(isequal(typeArray1, typeArray1'));
+
+            % Corresponding elements are not equal
+            timestampType2 = arrow.timestamp(TimeUnit="Millisecond");
+            typeArray2 = [float32Type, timestampType2];
+            testCase.verifyFalse(isequal(typeArray1, typeArray2));
+
+            % Corresponding elements have different class types
+            stringType = arrow.string();
+            typeArray3 = [float32Type, stringType];
+            testCase.verifyFalse(isequal(typeArray1, typeArray3));
+        end
+
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tTime32Type.m b/matlab/test/arrow/type/tTime32Type.m
index 0bb467b1bab4c..86615312a1120 100644
--- a/matlab/test/arrow/type/tTime32Type.m
+++ b/matlab/test/arrow/type/tTime32Type.m
@@ -82,28 +82,6 @@ function ErrorIfTimeUnitIsNonScalar(testCase)
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
-        function Display(testCase)
-            % Verify the display of Time32Type objects.
-            %
-            % Example:
-            %
-            %  Time32Type with properties:
-            %
-            %          ID: Time32
-            %    TimeUnit: Second
-            %
-            type = testCase.ConstructionFcn(TimeUnit="Second"); %#ok<NASGU>
-            classnameLink = "<a href=""matlab:helpPopup arrow.type.Time32Type"" style=""font-weight:bold"">Time32Type</a>";
-            header = "  " + classnameLink + " with properties:" + newline;
-            body = strjust(pad(["ID:"; "TimeUnit:"]));
-            body = body + " " + ["Time32"; "Second"];
-            body = "    " + body;
-            footer = string(newline);
-            expectedDisplay = char(strjoin([header body' footer], newline));
-            actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-
         function TimeUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the TimeUnit property.
diff --git a/matlab/test/arrow/type/tTime64Type.m b/matlab/test/arrow/type/tTime64Type.m
index 01460d9c1b5cd..a69808199069e 100644
--- a/matlab/test/arrow/type/tTime64Type.m
+++ b/matlab/test/arrow/type/tTime64Type.m
@@ -83,28 +83,6 @@ function ErrorIfTimeUnitIsNonScalar(testCase)
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
-        function Display(testCase)
-            % Verify the display of Time64Type objects.
-            %
-            % Example:
-            %
-            %  Time64Type with properties:
-            %
-            %          ID: Time64
-            %    TimeUnit: Microsecond
-            %
-            type = testCase.ConstructionFcn(TimeUnit="Microsecond"); %#ok<NASGU>
-            classnameLink = "<a href=""matlab:helpPopup arrow.type.Time64Type"" style=""font-weight:bold"">Time64Type</a>";
-            header = "  " + classnameLink + " with properties:" + newline;
-            body = strjust(pad(["ID:"; "TimeUnit:"]));
-            body = body + " " + ["Time64"; "Microsecond"];
-            body = "    " + body;
-            footer = string(newline);
-            expectedDisplay = char(strjoin([header body' footer], newline));
-            actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-
         function TimeUnitNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the TimeUnit property.
diff --git a/matlab/test/arrow/type/tTimestampType.m b/matlab/test/arrow/type/tTimestampType.m
index 6a626ebde702a..1266faff4ab02 100644
--- a/matlab/test/arrow/type/tTimestampType.m
+++ b/matlab/test/arrow/type/tTimestampType.m
@@ -112,29 +112,6 @@ function ErrorIfTimeUnitIsNonScalar(testCase)
             testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
         end
 
-        function Display(testCase)
-        % Verify the display of TimestampType objects.
-        %
-        % Example:
-        %
-        %  TimestampType with properties:
-        %
-        %          ID: Timestamp
-        %    TimeUnit: Second
-        %    TimeZone: "America/Anchorage"
-        %
-            type = arrow.timestamp(TimeUnit="Second", TimeZone="America/Anchorage"); %#ok<NASGU>
-            classnameLink = "<a href=""matlab:helpPopup arrow.type.TimestampType"" style=""font-weight:bold"">TimestampType</a>";
-            header = "  " + classnameLink + " with properties:" + newline;
-            body = strjust(pad(["ID:"; "TimeUnit:"; "TimeZone:"]));
-            body = body + " " + ["Timestamp"; "Second"; """America/Anchorage"""];
-            body = "    " + body;
-            footer = string(newline);
-            expectedDisplay = char(strjoin([header body' footer], newline));
-            actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-
         function IsEqualTrue(testCase, TimeZone)
             % Verifies isequal method of arrow.type.TimestampType returns 
             % true if these conditions are met:
diff --git a/matlab/test/arrow/type/tTypeDisplay.m b/matlab/test/arrow/type/tTypeDisplay.m
new file mode 100644
index 0000000000000..4d3c023da71ab
--- /dev/null
+++ b/matlab/test/arrow/type/tTypeDisplay.m
@@ -0,0 +1,256 @@
+%TTYPEDISPLAY Unit tests verifying the display of all classes within the
+%arrow.type.Type class hierarchy.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTypeDisplay < matlab.unittest.TestCase
+
+    properties(TestParameter)
+        TypeDisplaysOnlyID = {arrow.boolean(), ...
+                              arrow.uint8(), ...
+                              arrow.uint16(), ...
+                              arrow.uint32(), ...
+                              arrow.uint64(), ...
+                              arrow.int8(), ...
+                              arrow.int16(), ...
+                              arrow.int32(), ...
+                              arrow.int64(), ...
+                              arrow.float32(), ...
+                              arrow.float64(), ...
+                              arrow.float64(), ...
+                              arrow.string()}
+
+        TimeType = {arrow.time32(TimeUnit="Second"), ...
+                   arrow.time64(TimeUnit="Nanosecond")};
+
+        DateType = {arrow.date32(), ...
+                    arrow.date64()};
+    end
+
+    methods (Test)
+        function EmptyTypeDisplay(testCase)
+            % Verify the display of an empty arrow.type.Type instance.
+            %
+            % Example:
+            %
+            %  0x1 Type array with properties:
+            %
+            %    ID
+
+            type = arrow.type.Type.empty(0, 1);
+            typeLink = makeLinkString(FullClassName="arrow.type.Type", ClassName="Type", BoldFont=true);
+            dimensionString = makeDimensionString(size(type));
+            header = "  " + dimensionString + " " + typeLink + " array with properties:" + newline;
+            body = strjust(pad("ID"));
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+        end
+
+        function NonScalarArrayDifferentTypes(testCase)
+            % Verify the display of a nonscalar, heterogeneous arrow.type.Type array:
+            % 
+            % Example:
+            %
+            %  1×2 heterogeneous FixedWidthType (Float32Type, TimestampType) array with properties:
+            %
+            %    ID
+
+            float32Type = arrow.float32();
+            timestampType = arrow.timestamp();
+            typeArray = [float32Type timestampType];
+
+            heterogeneousLink =  makeLinkString(FullClassName="matlab.mixin.Heterogeneous", ClassName="heterogeneous",  BoldFont=false);
+            fixedWidthLink    =  makeLinkString(FullClassName="arrow.type.FixedWidthType",  ClassName="FixedWidthType", BoldFont=true);
+            timestampLink     = makeLinkString(FullClassName="arrow.type.TimestampType",   ClassName="TimestampType",   BoldFont=false);
+            float32Link       = makeLinkString(FullClassName="arrow.type.Float32Type",     ClassName="Float32Type",     BoldFont=false);
+
+            dimensionString = makeDimensionString(size(typeArray));
+            
+            header = "  " + dimensionString + " " + heterogeneousLink + " " + fixedWidthLink + ...
+                " (" +  float32Link + ", " + timestampLink + ") array with properties:" + newline;
+            body = "    " + "ID";
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(typeArray)');
+            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+        end
+
+        function NonScalarArraySameTypes(testCase)
+            % Verify the display of a scalar, homogeneous arrow.type.Type array:
+            % 
+            % Example:
+            %
+            %  1×2 TimestampType array with properties:
+            %
+            %    ID
+            %    TimeUnit
+            %    TimeZone 
+
+            timestampType1 = arrow.timestamp(TimeZone="Pacific/Fiji");
+            timestampType2 = arrow.timestamp(TimeUnit="Second");
+            typeArray = [timestampType1 timestampType2];
+
+            timestampLink = makeLinkString(FullClassName="arrow.type.TimestampType", ClassName="TimestampType", BoldFont=true);
+            dimensionString = makeDimensionString(size(typeArray));
+            header = "  " + dimensionString + " " + timestampLink + " array with properties:" + newline;
+            body = strjust(["ID"; "TimeUnit"; "TimeZone"], "left");
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(typeArray)');
+            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+        end
+
+        function TestTypeDisplaysOnlyID(testCase, TypeDisplaysOnlyID)
+            % Verify the display of arrow.type.Type subclasses that only
+            % display the ID property.
+            %
+            % Example:
+            %
+            %  BooleanType with properties:
+            %
+            %          ID: Boolean
+
+            type = TypeDisplaysOnlyID;
+            fullClassName = string(class(type));
+            className = reverse(extractBefore(reverse(fullClassName), "."));
+            typeLink = makeLinkString(FullClassName=fullClassName, ClassName=className, BoldFont=true);
+            header = "  " + typeLink + " with properties:" + newline;
+            body = "    ID: " + string(type.ID);
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+        end
+
+        function TestTimeType(testCase, TimeType)
+            % Verify the display of TimeType objects.
+            %
+            % Example:
+            %
+            %  Time32Type with properties:
+            %
+            %          ID: Time32
+            %    TimeUnit: Second
+
+            type = TimeType;
+            fullClassName = string(class(type));
+            className = reverse(extractBefore(reverse(fullClassName), "."));
+            typeLink = makeLinkString(FullClassName=fullClassName, ClassName=className, BoldFont=true);
+
+            header = "  " + typeLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "TimeUnit:"]));
+            body = body + " " + [string(type.ID); string(type.TimeUnit)];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function TestDateType(testCase, DateType)
+            % Verify the display of DateType objects.
+            %
+            % Example:
+            %
+            %  Date32Type with properties:
+            %
+            %          ID: Date32
+            %    DateUnit: Day
+
+            type = DateType;
+            fullClassName = string(class(type));
+            className = reverse(extractBefore(reverse(fullClassName), "."));
+            typeLink = makeLinkString(FullClassName=fullClassName, ClassName=className, BoldFont=true);
+
+            header = "  " + typeLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "DateUnit:"]));
+            body = body + " " + [string(type.ID); string(type.DateUnit)];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function Display(testCase)
+            % Verify the display of TimestampType objects.
+            %
+            % Example:
+            %
+            %  TimestampType with properties:
+            %
+            %          ID: Timestamp
+            %    TimeUnit: Second
+            %    TimeZone: "America/Anchorage"
+
+            type = arrow.timestamp(TimeUnit="Second", TimeZone="America/Anchorage"); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.type.TimestampType", ClassName="TimestampType", BoldFont=true);
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "TimeUnit:"; "TimeZone:"]));
+            body = body + " " + ["Timestamp"; "Second"; """America/Anchorage"""];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+    end
+
+    methods
+        function verifyDisplay(testCase, actualDisplay, expectedDisplay)
+            % When the MATLAB GUI is running, '×' (char(215)) is used as
+            % the delimiter between dimension values. However, when the 
+            % GUI is not running, 'x' (char(120)) is used as the delimiter.
+            % To account for this discrepancy, check if actualDisplay 
+            % contains char(215). If not, replace all instances of
+            % char(215) in expectedDisplay with char(120).
+
+            tf = contains(actualDisplay, char(215));
+            if ~tf
+                idx = strfind(expectedDisplay, char(215));
+                expectedDisplay(idx) = char(120);
+            end
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+    end
+end
+
+function link = makeLinkString(opts)
+    arguments
+        opts.FullClassName(1, 1) string
+        opts.ClassName(1, 1) string
+        % When displaying heterogeneous arrays, only the name of the 
+        % closest shared anscestor class is displayed in bold. All other
+        % class names are not bolded.
+        opts.BoldFont(1, 1) logical
+    end
+
+    if opts.BoldFont
+        link = compose("<a href=""matlab:helpPopup %s"" style=""font-weight:bold"">%s</a>", ...
+            opts.FullClassName, opts.ClassName);
+    else
+        link = compose("<a href=""matlab:helpPopup %s"">%s</a>", opts.FullClassName, opts.ClassName);
+    end
+end
+
+function dimensionString = makeDimensionString(arraySize)
+    dimensionString = string(arraySize);
+    dimensionString = join(dimensionString, char(215));
+end
\ No newline at end of file

From 7f604b2e2ad10c6bc8c8ebddbc64d1916dec5eca Mon Sep 17 00:00:00 2001
From: Sam Albers <sam.albers@gmail.com>
Date: Wed, 6 Sep 2023 16:17:35 -0700
Subject: [PATCH 327/749] MINOR: [R] fix R dev docs (#37595)

### Rationale for this change

This fixes this failing build: https://github.com/apache/arrow-site/actions/runs/5745111541/job/15572612431#step:9:27

### What changes are included in this PR?

That job is now called `test-ubuntu-22.04-docs` and started running the day after `test-ubuntu-default-docs` stopped running. I wasn't sure if it was possible (or worth it) to extend the task template into the ruby file so I just opted for a code comment for future changes.

### Are these changes tested?

### Are there any user-facing changes?

dev docs will build again

Lead-authored-by: Sam Albers <sam.albers@gmail.com>
Co-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/release/binary-task.rb | 2 +-
 dev/tasks/tasks.yml        | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/dev/release/binary-task.rb b/dev/release/binary-task.rb
index ddbf86320d042..e7b618ba3348d 100644
--- a/dev/release/binary-task.rb
+++ b/dev/release/binary-task.rb
@@ -1895,7 +1895,7 @@ def define_docs_tasks
                               :docs,
                               "#{rc_dir}/docs/#{full_version}",
                               "#{release_dir}/docs/#{full_version}",
-                              "test-ubuntu-default-docs/**/*")
+                              "test-ubuntu-22.04-docs/**/*")
   end
 
   def define_nuget_tasks
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 55f23ed1304b7..ed238778635d3 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1508,6 +1508,7 @@ tasks:
       image: debian-go
   {% endfor %}
 
+  # be sure to update binary-task.rb when upgrading ubuntu
   test-ubuntu-22.04-docs:
     ci: github
     template: docs/github.linux.yml

From 85ec07e5b104dcb198bf041652b5f3086384d06f Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 6 Sep 2023 22:38:19 -0400
Subject: [PATCH 328/749] GH-37515: [C++] Remove memory address optimization
 from `ChunkedArray::Equals(const std::shared_ptr<arrow::ChunkedArray>&
 other)` if the `ChunkedArray` can have `NaN` values (#37579)

### Rationale for this change

`ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other)` assumes that if the two `ChunkedArray`s share the same memory address, then they must be equal. However, this optimization doesn't take into account that `NaN` values are not considered equal by default. Consequently, this can lead to surprising, inconsistent results from a user's perspective. For example, `ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other)`  and `ChunkedArray::Equals(const ChunkedArray& other)` may return different results.

 The program below illustrates this inconsistency:

```c++
#include <arrow/api.h>
#include <arrow/type.h>

#include <iostream>
#include <math.h>
#include <sstream>

arrow::Result<std::shared_ptr<arrow::ChunkedArray>> make_chunked_array() {
    arrow::NumericBuilder<arrow::DoubleType> builder;

    std::shared_ptr<arrow::Array> array;
    ARROW_RETURN_NOT_OK(builder.AppendValues({0, 1, NAN, 2, 4}));
    ARROW_RETURN_NOT_OK(builder.Finish(&array));

    return arrow::ChunkedArray::Make({array});
}

int main(int argc, char *argv[])
{
    auto maybe_chunked_array = make_chunked_array();
    if (!maybe_chunked_array.ok()) {
        return -1;
    }
    auto chunked_array = std::move(maybe_chunked_array).ValueUnsafe();
    auto array = chunked_array->chunk(0);

    std::stringstream stream;

    stream << "chunked_array contents: ";
    stream << "\n\n";
    stream << chunked_array->ToString();
    stream << "\n\n";
    stream << "chunked_array->Equals(chunked_array): ";
    stream << chunked_array->Equals(chunked_array);
    stream << "chunked_array->Equals(*chunked_array): ";
    stream << chunked_array->Equals(*chunked_array);

    std::cout << stream.str() << std::endl;
}
```

Here is the output of this program:

```shell
chunked_array contents:

[
  [
    0,
    1,
    nan,
    2,
    4
  ]
]

chunked_array->Equals(chunked_array): 1
chunked_array->Equals(*chunked_array): 0
```

### What changes are included in this PR?

Updated `ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other)` to only return `true` early IF:
   - The two share the same address AND
   - They cannot have `NaN` values

If both of those conditions are not satisfied, `ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other)` will do the element-by-element comparison.

### Are these changes tested?

Yes. I added a new test case called `EqualsSameAddressWithNaNs` to `chunked_array_test.cc`.

### Are there any user-facing changes?

Yes. `ChunkedArray::Equals(const std::shared_ptr<arrow::ChunkedArray>& other)` may return `false` even if the two `ChunkedArray`s have the same memory address. This will only occur if the `ChunkedArray`'s contain `NaN` values.

* Closes: #37515

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/chunked_array.cc      | 24 +++++++++++++++++++++---
 cpp/src/arrow/chunked_array_test.cc | 29 +++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/chunked_array.cc b/cpp/src/arrow/chunked_array.cc
index c5e6d7fa4bdf0..12937406e7800 100644
--- a/cpp/src/arrow/chunked_array.cc
+++ b/cpp/src/arrow/chunked_array.cc
@@ -30,6 +30,7 @@
 #include "arrow/pretty_print.h"
 #include "arrow/status.h"
 #include "arrow/type.h"
+#include "arrow/type_traits.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging.h"
 
@@ -111,13 +112,30 @@ bool ChunkedArray::Equals(const ChunkedArray& other) const {
       .ok();
 }
 
-bool ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other) const {
-  if (this == other.get()) {
-    return true;
+namespace {
+
+bool mayHaveNaN(const arrow::DataType& type) {
+  if (type.num_fields() == 0) {
+    return is_floating(type.id());
+  } else {
+    for (const auto& field : type.fields()) {
+      if (mayHaveNaN(*field->type())) {
+        return true;
+      }
+    }
   }
+  return false;
+}
+
+}  //  namespace
+
+bool ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other) const {
   if (!other) {
     return false;
   }
+  if (this == other.get() && !mayHaveNaN(*type_)) {
+    return true;
+  }
   return Equals(*other.get());
 }
 
diff --git a/cpp/src/arrow/chunked_array_test.cc b/cpp/src/arrow/chunked_array_test.cc
index 08410b4cd5367..46dccaf3c6b86 100644
--- a/cpp/src/arrow/chunked_array_test.cc
+++ b/cpp/src/arrow/chunked_array_test.cc
@@ -146,6 +146,35 @@ TEST_F(TestChunkedArray, EqualsDifferingMetadata) {
   ASSERT_TRUE(left.Equals(right));
 }
 
+TEST_F(TestChunkedArray, EqualsSameAddressWithNaNs) {
+  auto chunk_with_nan1 = ArrayFromJSON(float64(), "[0, 1, 2, NaN]");
+  auto chunk_without_nan1 = ArrayFromJSON(float64(), "[3, 4, 5]");
+  ArrayVector chunks1 = {chunk_with_nan1, chunk_without_nan1};
+  ASSERT_OK_AND_ASSIGN(auto chunked_array_with_nan1, ChunkedArray::Make(chunks1));
+  ASSERT_FALSE(chunked_array_with_nan1->Equals(chunked_array_with_nan1));
+
+  auto chunk_without_nan2 = ArrayFromJSON(float64(), "[6, 7, 8, 9]");
+  ArrayVector chunks2 = {chunk_without_nan1, chunk_without_nan2};
+  ASSERT_OK_AND_ASSIGN(auto chunked_array_without_nan1, ChunkedArray::Make(chunks2));
+  ASSERT_TRUE(chunked_array_without_nan1->Equals(chunked_array_without_nan1));
+
+  auto int32_array = ArrayFromJSON(int32(), "[0, 1, 2]");
+  auto float64_array_with_nan = ArrayFromJSON(float64(), "[0, 1, NaN]");
+  ArrayVector arrays1 = {int32_array, float64_array_with_nan};
+  std::vector<std::string> fieldnames = {"Int32Type", "Float64Type"};
+  ASSERT_OK_AND_ASSIGN(auto struct_with_nan, StructArray::Make(arrays1, fieldnames));
+  ArrayVector chunks3 = {struct_with_nan};
+  ASSERT_OK_AND_ASSIGN(auto chunked_array_with_nan2, ChunkedArray::Make(chunks3));
+  ASSERT_FALSE(chunked_array_with_nan2->Equals(chunked_array_with_nan2));
+
+  auto float64_array_without_nan = ArrayFromJSON(float64(), "[0, 1, 2]");
+  ArrayVector arrays2 = {int32_array, float64_array_without_nan};
+  ASSERT_OK_AND_ASSIGN(auto struct_without_nan, StructArray::Make(arrays2, fieldnames));
+  ArrayVector chunks4 = {struct_without_nan};
+  ASSERT_OK_AND_ASSIGN(auto chunked_array_without_nan2, ChunkedArray::Make(chunks4));
+  ASSERT_TRUE(chunked_array_without_nan2->Equals(chunked_array_without_nan2));
+}
+
 TEST_F(TestChunkedArray, SliceEquals) {
   random::RandomArrayGenerator gen(42);
 

From b06e3ada73359ad07fa1922d8d7774455d1ec0b6 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 7 Sep 2023 14:11:28 +0900
Subject: [PATCH 329/749] GH-37601: [C++][Parquet] Add missing GoogleMock
 dependency (#37602)

### Rationale for this change

Parquet's tests uses GoogleMock. So we should specify GoogleMock as a dependency explicitly.

### What changes are included in this PR?

Add `${ARROW_GTEST_GMOCK}` to `PARQUET_MIN_TEST_LIBS`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37601

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/parquet/CMakeLists.txt | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index eb2e2d8fed88f..eabfcea586905 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -114,12 +114,13 @@ else()
   set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
 endif()
 
-set(PARQUET_MIN_TEST_LIBS ${ARROW_GTEST_GTEST_MAIN} ${ARROW_GTEST_GTEST} Boost::headers)
+set(PARQUET_MIN_TEST_LIBS ${ARROW_GTEST_GMOCK} ${ARROW_GTEST_GTEST}
+                          ${ARROW_GTEST_GTEST_MAIN} Boost::headers)
 
 if(APPLE)
-  set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} ${CMAKE_DL_LIBS})
+  list(APPEND PARQUET_MIN_TEST_LIBS ${CMAKE_DL_LIBS})
 elseif(NOT MSVC)
-  set(PARQUET_MIN_TEST_LIBS ${PARQUET_MIN_TEST_LIBS} pthread ${CMAKE_DL_LIBS})
+  list(APPEND PARQUET_MIN_TEST_LIBS pthread ${CMAKE_DL_LIBS})
 endif()
 
 set(PARQUET_SHARED_TEST_LINK_LIBS arrow_testing_shared ${PARQUET_MIN_TEST_LIBS}

From a918abb853e149cb37994354ae84a7556a388ea5 Mon Sep 17 00:00:00 2001
From: Tero Vuotila <tero.vuotila@gmail.com>
Date: Thu, 7 Sep 2023 09:42:44 +0300
Subject: [PATCH 330/749] MINOR: [Python][Docs] Fix a code example rendering
 (#37557)

Add the required empty line before a code example of binary.

### Rationale for this change

The last code example of [pyarrow.binary](https://arrow.apache.org/docs/python/generated/pyarrow.binary.html#pyarrow.binary) was not rendered correctly in documentation.

### What changes are included in this PR?

Added one line break to make the code example render correctly.

### Are these changes tested?

No

### Are there any user-facing changes?

[pyarrow.binary](https://arrow.apache.org/docs/python/generated/pyarrow.binary.html#pyarrow.binary) documentation only.

Authored-by: Tero Vuotila <tero.vuotila@falcony.io>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/types.pxi | 1 +
 1 file changed, 1 insertion(+)

diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index f2dd59a0f1ad8..ffaebd2418a58 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -4135,6 +4135,7 @@ def binary(int length=-1):
     FixedSizeBinaryType(fixed_size_binary[3])
 
     and use the fixed-length binary type to create an array:
+
     >>> pa.array(['foo', 'bar', 'baz'], type=pa.binary(3))
     <pyarrow.lib.FixedSizeBinaryArray object at ...>
     [

From b957847a616a82e89af988c3c922af79379f6160 Mon Sep 17 00:00:00 2001
From: Paul Taylor <178183+trxcllnt@users.noreply.github.com>
Date: Thu, 7 Sep 2023 01:17:08 -0700
Subject: [PATCH 331/749] GH-31621: [JS] Fix Union null bitmaps (#37122)

This PR fixes `Union` null handling, and re-enables the disabled `SparseUnion` test.

The format doc [says](https://arrow.apache.org/docs/format/Columnar.html#union-layout):
> Unlike other data types, unions do not have their own validity bitmap.

Therefore we need to remove null masks from union types and allow them to delegate validity to their children.

Also fixes https://github.com/apache/arrow/issues/37063 for good measure.

* Closes: #31621
* Closes: #37063
* Closes #24123
* Closes #17168

Authored-by: ptaylor <paul.e.taylor@me.com>
Signed-off-by: Dominik Moritz <domoritz@gmail.com>
---
 dev/archery/archery/integration/datagen.py |  39 ++++----
 dev/archery/archery/integration/runner.py  |  74 ++++++++++++---
 docs/source/status.rst                     |   8 +-
 js/.eslintrc.cjs                           |   6 +-
 js/.vscode/launch.json                     |  37 +++++---
 js/bin/arrow2csv.js                        |   6 +-
 js/bin/integration.js                      |   6 +-
 js/bin/json-to-arrow.js                    |   8 +-
 js/bin/print-buffer-alignment.js           |   4 +-
 js/gulp/test-task.js                       |  12 +--
 js/src/builder/union.ts                    |   4 +-
 js/src/data.ts                             | 104 +++++++++++++++------
 js/src/ipc/message.ts                      |   2 +-
 js/src/ipc/metadata/file.ts                |   6 +-
 js/src/ipc/metadata/json.ts                |  18 ++--
 js/src/ipc/metadata/message.ts             |  20 ++--
 js/src/ipc/reader.ts                       |   4 +-
 js/src/ipc/writer.ts                       |   2 +-
 js/src/recordbatch.ts                      |  30 +++---
 js/src/schema.ts                           |   6 +-
 js/src/type.ts                             |  19 +++-
 js/src/util/buffer.ts                      |   6 +-
 js/src/vector.ts                           |  19 ++--
 js/src/visitor/indexof.ts                  |  14 ++-
 js/src/visitor/jsontypeassembler.ts        |   2 +-
 js/src/visitor/jsonvectorassembler.ts      |   9 +-
 js/src/visitor/vectorassembler.ts          |  64 +++++++------
 js/src/visitor/vectorloader.ts             |  23 +++--
 js/test/generate-test-data.ts              |  52 +++++------
 js/test/unit/generated-data-tests.ts       |   2 +-
 js/test/unit/generated-data-validators.ts  |   2 +
 js/test/unit/visitor-tests.ts              |   8 +-
 js/tsconfig.json                           |  13 ++-
 33 files changed, 394 insertions(+), 235 deletions(-)

diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 99aeda52488db..f924c8a73cb8a 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1556,18 +1556,18 @@ def generate_nested_large_offsets_case():
 
 def generate_unions_case():
     fields = [
-        SparseUnionField('sparse', [get_field('f1', 'int32'),
-                                    get_field('f2', 'utf8')],
+        SparseUnionField('sparse_1', [get_field('f1', 'int32'),
+                                      get_field('f2', 'utf8')],
                          type_ids=[5, 7]),
-        DenseUnionField('dense', [get_field('f1', 'int16'),
-                                  get_field('f2', 'binary')],
+        DenseUnionField('dense_1', [get_field('f1', 'int16'),
+                                    get_field('f2', 'binary')],
                         type_ids=[10, 20]),
-        SparseUnionField('sparse', [get_field('f1', 'float32', nullable=False),
-                                    get_field('f2', 'bool')],
+        SparseUnionField('sparse_2', [get_field('f1', 'float32', nullable=False),
+                                      get_field('f2', 'bool')],
                          type_ids=[5, 7], nullable=False),
-        DenseUnionField('dense', [get_field('f1', 'uint8', nullable=False),
-                                  get_field('f2', 'uint16'),
-                                  NullField('f3')],
+        DenseUnionField('dense_2', [get_field('f1', 'uint8', nullable=False),
+                                    get_field('f2', 'uint16'),
+                                    NullField('f3')],
                         type_ids=[42, 43, 44], nullable=False),
     ]
 
@@ -1669,11 +1669,9 @@ def _temp_path():
         .skip_category('C#')
         .skip_category('JS'),
 
-        generate_null_case([10, 0])
-        .skip_category('JS'),   # TODO(ARROW-7900)
+        generate_null_case([10, 0]),
 
-        generate_null_trivial_case([0, 0])
-        .skip_category('JS'),   # TODO(ARROW-7900)
+        generate_null_trivial_case([0, 0]),
 
         generate_decimal128_case(),
 
@@ -1699,8 +1697,7 @@ def _temp_path():
 
         generate_non_canonical_map_case()
         .skip_category('C#')
-        .skip_category('Java')   # TODO(ARROW-8715)
-        .skip_category('JS'),     # TODO(ARROW-8716)
+        .skip_category('Java'),   # TODO(ARROW-8715)
 
         generate_nested_case(),
 
@@ -1711,12 +1708,10 @@ def _temp_path():
         .skip_category('JS'),
 
         generate_unions_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_category('C#'),
 
         generate_custom_metadata_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_category('C#'),
 
         generate_duplicate_fieldnames_case()
         .skip_category('C#')
@@ -1731,8 +1726,7 @@ def _temp_path():
 
         generate_nested_dictionary_case()
         .skip_category('C#')
-        .skip_category('Java')  # TODO(ARROW-7779)
-        .skip_category('JS'),
+        .skip_category('Java'),  # TODO(ARROW-7779)
 
         generate_run_end_encoded_case()
         .skip_category('C#')
@@ -1741,8 +1735,7 @@ def _temp_path():
         .skip_category('Rust'),
 
         generate_extension_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_category('C#'),
     ]
 
     generated_paths = []
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index 966da84e655b2..0ee9ab814e5e6 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -132,6 +132,7 @@ def _gold_tests(self, gold_dir):
                 skip = set()
             if name == 'union' and prefix == '0.17.1':
                 skip.add("Java")
+                skip.add("JS")
             if prefix == '1.0.0-bigendian' or prefix == '1.0.0-littleendian':
                 skip.add("C#")
                 skip.add("Java")
@@ -500,33 +501,78 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
 
 
 def write_js_test_json(directory):
+    datagen.generate_primitive_case([], name='primitive_no_batches').write(
+        os.path.join(directory, 'primitive-no-batches.json')
+    )
+    datagen.generate_primitive_case([17, 20], name='primitive').write(
+        os.path.join(directory, 'primitive.json')
+    )
+    datagen.generate_primitive_case([0, 0, 0], name='primitive_zerolength').write(
+        os.path.join(directory, 'primitive-empty.json')
+    )
+    # datagen.generate_primitive_large_offsets_case([17, 20]).write(
+    #     os.path.join(directory, 'primitive-large-offsets.json')
+    # )
+    datagen.generate_null_case([10, 0]).write(
+        os.path.join(directory, 'null.json')
+    )
+    datagen.generate_null_trivial_case([0, 0]).write(
+        os.path.join(directory, 'null-trivial.json')
+    )
+    datagen.generate_decimal128_case().write(
+        os.path.join(directory, 'decimal128.json')
+    )
+    # datagen.generate_decimal256_case().write(
+    #     os.path.join(directory, 'decimal256.json')
+    # )
+    datagen.generate_datetime_case().write(
+        os.path.join(directory, 'datetime.json')
+    )
+    # datagen.generate_duration_case().write(
+    #     os.path.join(directory, 'duration.json')
+    # )
+    # datagen.generate_interval_case().write(
+    #     os.path.join(directory, 'interval.json')
+    # )
+    # datagen.generate_month_day_nano_interval_case().write(
+    #     os.path.join(directory, 'month_day_nano_interval.json')
+    # )
     datagen.generate_map_case().write(
         os.path.join(directory, 'map.json')
     )
+    datagen.generate_non_canonical_map_case().write(
+        os.path.join(directory, 'non_canonical_map.json')
+    )
     datagen.generate_nested_case().write(
         os.path.join(directory, 'nested.json')
     )
-    datagen.generate_decimal128_case().write(
-        os.path.join(directory, 'decimal.json')
+    datagen.generate_recursive_nested_case().write(
+        os.path.join(directory, 'recursive-nested.json')
     )
-    datagen.generate_decimal256_case().write(
-        os.path.join(directory, 'decimal256.json')
+    # datagen.generate_nested_large_offsets_case().write(
+    #     os.path.join(directory, 'nested-large-offsets.json')
+    # )
+    datagen.generate_unions_case().write(
+        os.path.join(directory, 'unions.json')
     )
-    datagen.generate_datetime_case().write(
-        os.path.join(directory, 'datetime.json')
+    datagen.generate_custom_metadata_case().write(
+        os.path.join(directory, 'custom-metadata.json')
     )
+    # datagen.generate_duplicate_fieldnames_case().write(
+    #     os.path.join(directory, 'duplicate-fieldnames.json')
+    # )
     datagen.generate_dictionary_case().write(
         os.path.join(directory, 'dictionary.json')
     )
     datagen.generate_dictionary_unsigned_case().write(
-        os.path.join(directory, 'dictionary_unsigned.json')
+        os.path.join(directory, 'dictionary-unsigned.json')
     )
-    datagen.generate_primitive_case([]).write(
-        os.path.join(directory, 'primitive_no_batches.json')
+    datagen.generate_nested_dictionary_case().write(
+        os.path.join(directory, 'dictionary-nested.json')
     )
-    datagen.generate_primitive_case([7, 10]).write(
-        os.path.join(directory, 'primitive.json')
-    )
-    datagen.generate_primitive_case([0, 0, 0]).write(
-        os.path.join(directory, 'primitive-empty.json')
+    # datagen.generate_run_end_encoded_case().write(
+    #     os.path.join(directory, 'run_end_encoded.json')
+    # )
+    datagen.generate_extension_case().write(
+        os.path.join(directory, 'extension.json')
     )
diff --git a/docs/source/status.rst b/docs/source/status.rst
index e96fd1a6107a5..36c29fcdc4da6 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -44,7 +44,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Float32/64        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Decimal128        | ✓     | ✓     | ✓     |            |  ✓    |  ✓    | ✓     |       |
+| Decimal128        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Decimal256        | ✓     | ✓     | ✓     |            |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -92,7 +92,7 @@ Data Types
 | Data type         | C++   | Java  | Go    | JavaScript | C#    | Rust  | Julia | Swift |
 | (special)         |       |       |       |            |       |       |       |       |
 +===================+=======+=======+=======+============+=======+=======+=======+=======+
-| Dictionary        | ✓     | ✓ (2) | ✓     | ✓ (2)      | ✓ (2) | ✓ (2) | ✓     |       |
+| Dictionary        | ✓     | ✓ (2) | ✓     | ✓          | ✓ (2) | ✓ (2) | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Extension         | ✓     | ✓     | ✓     |            |       | ✓     | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -125,7 +125,7 @@ IPC Format
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Replacement dictionaries    | ✓     | ✓     | ✓     |            |       |       | ✓     |       |
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Delta dictionaries          | ✓ (1) |       | ✓ (1) |            |  ✓    |       | ✓     |       |
+| Delta dictionaries          | ✓ (1) |       | ✓ (1) | ✓          |  ✓    |       | ✓     |       |
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Tensors                     | ✓     |       |       |            |       |       |       |       |
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -135,7 +135,7 @@ IPC Format
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Endianness conversion       | ✓ (2) |       | ✓ (2) |            |       |       |       |       |
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Custom schema metadata      | ✓     | ✓     | ✓     |            |  ✓    |  ✓    | ✓     |       |
+| Custom schema metadata      | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-----------------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 Notes:
diff --git a/js/.eslintrc.cjs b/js/.eslintrc.cjs
index c5cf17c59352f..b629b862190f4 100644
--- a/js/.eslintrc.cjs
+++ b/js/.eslintrc.cjs
@@ -102,9 +102,9 @@ module.exports = {
         "unicorn/text-encoding-identifier-case": "off",
         "unicorn/prefer-top-level-await": "off",
 
-        "unicorn/consistent-destructuring": "warn",
-        "unicorn/no-array-reduce": ["warn", { "allowSimpleOperations": true }],
-        "unicorn/no-await-expression-member": "warn",
+        "unicorn/consistent-destructuring": "off",
+        "unicorn/no-array-reduce": "off",
+        "unicorn/no-await-expression-member": "off",
         "unicorn/no-useless-undefined": "warn",
         "unicorn/consistent-function-scoping": "warn",
         "unicorn/prefer-math-trunc": "warn",
diff --git a/js/.vscode/launch.json b/js/.vscode/launch.json
index e09d0a39e1ff1..7d169ccb26274 100644
--- a/js/.vscode/launch.json
+++ b/js/.vscode/launch.json
@@ -59,6 +59,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug Gulp Build",
+      "cwd": "${workspaceFolder}",
       "program": "${workspaceFolder}/node_modules/gulp/bin/gulp.js",
       "args": [
         "build",
@@ -71,7 +72,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug Unit Tests",
-      "cwd": "${workspaceRoot}",
+      "cwd": "${workspaceFolder}",
       "console": "integratedTerminal",
       "program": "${workspaceFolder}/node_modules/.bin/jest",
       "skipFiles": [
@@ -96,7 +97,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug Integration Tests",
-      "cwd": "${workspaceRoot}",
+      "cwd": "${workspaceFolder}",
       "program": "${workspaceFolder}/bin/integration.js",
       "skipFiles": [
         "<node_internals>/**/*.js",
@@ -104,25 +105,36 @@
       ],
       "env": {
         "NODE_NO_WARNINGS": "1",
+        "ARROW_JS_DEBUG": "src",
+        "TS_NODE_CACHE": "false"
       },
+      "runtimeArgs": [
+        "-r",
+        "ts-node/register"
+      ],
       "args": [
         "--mode",
-        "VALIDATE"
+        "VALIDATE",
+        "-j", "test/data/json/unions.json",
+        "-a", "./test/data/cpp/stream/struct_example.arrow"
       ]
     },
     {
+      "type": "node",
+      "request": "launch",
       "name": "Debug Bundle",
+      "cwd": "${workspaceFolder}",
       "program": "${input:BUNDLE_FILE}",
-      "request": "launch",
       "skipFiles": [
         "<node_internals>/**"
-      ],
-      "type": "node"
+      ]
     },
     {
+      "type": "node",
+      "request": "launch",
       "name": "Debug Benchmarks",
+      "cwd": "${workspaceFolder}",
       "program": "${workspaceFolder}/perf/index.ts",
-      "request": "launch",
       "skipFiles": [
         "<node_internals>/**",
         "${workspaceFolder}/node_modules/**/*.js"
@@ -130,13 +142,13 @@
       "runtimeArgs": [
         "--loader",
         "ts-node/esm/transpile-only"
-      ],
-      "type": "node"
+      ]
     },
     {
       "type": "node",
       "request": "launch",
       "name": "Debug bin/arrow2csv",
+      "cwd": "${workspaceFolder}",
       "env": {
         "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
@@ -160,6 +172,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug bin/file-to-stream",
+      "cwd": "${workspaceFolder}",
       "env": {
         "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
@@ -182,6 +195,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug bin/stream-to-file",
+      "cwd": "${workspaceFolder}",
       "env": {
         "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
@@ -204,6 +218,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug bin/json-to-arrow",
+      "cwd": "${workspaceFolder}",
       "env": {
         "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
@@ -230,6 +245,7 @@
       "type": "node",
       "request": "launch",
       "name": "Debug bin/print-buffer-alignment",
+      "cwd": "${workspaceFolder}",
       "env": {
         "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
@@ -251,10 +267,9 @@
       "type": "node",
       "name": "vscode-jest-tests",
       "request": "launch",
+      "cwd": "${workspaceFolder}",
       "console": "integratedTerminal",
       "internalConsoleOptions": "neverOpen",
-      "disableOptimisticBPs": true,
-      "cwd": "${workspaceFolder}",
       "program": "${workspaceFolder}/node_modules/.bin/jest",
       "runtimeArgs": [
         "--experimental-vm-modules"
diff --git a/js/bin/arrow2csv.js b/js/bin/arrow2csv.js
index 51984a7971df1..f7cb483ff4ce3 100755
--- a/js/bin/arrow2csv.js
+++ b/js/bin/arrow2csv.js
@@ -23,5 +23,9 @@ const arrow2csv = Path.join(here, `src/bin/arrow2csv.ts`);
 const env = { ...process.env, TS_NODE_TRANSPILE_ONLY: `true` };
 
 require('child_process').spawn(`node`, [
-    `--loader`, 'ts-node/esm/transpile-only', arrow2csv, ...process.argv.slice(2)
+    `-r`,
+    `ts-node/register`,
+    `--loader`,
+    `ts-node/esm/transpile-only`,
+    arrow2csv, ...process.argv.slice(2)
 ], { cwd: here, env, stdio: `inherit` });
diff --git a/js/bin/integration.js b/js/bin/integration.js
index 1b7d6ce2476be..583b7a2161d7d 100755
--- a/js/bin/integration.js
+++ b/js/bin/integration.js
@@ -21,17 +21,17 @@
 
 const fs = require('fs');
 const Path = require('path');
-const { promisify } = require('util');
-const glob = promisify(require('glob').glob);
+const { glob } = require('glob');
 const { zip } = require('ix/iterable/zip');
 const { parse: bignumJSONParse } = require('json-bignum');
 const argv = require(`command-line-args`)(cliOpts(), { partial: true });
+const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
 const {
     Table,
     RecordBatchReader,
     RecordBatchStreamWriter,
     util: { createElementComparator }
-} = require('../targets/apache-arrow/');
+} = require(`../index${extension}`);
 
 const exists = async (p) => {
     try {
diff --git a/js/bin/json-to-arrow.js b/js/bin/json-to-arrow.js
index ee7a952befddc..20442ac062358 100755
--- a/js/bin/json-to-arrow.js
+++ b/js/bin/json-to-arrow.js
@@ -53,10 +53,10 @@ const arrowPaths = [...(argv.arrow || [])];
 
     }));
 })()
-.then((x) => +x || 0, (e) => {
-    e && process.stderr.write(`${e}`);
-    return process.exitCode || 1;
-}).then((code = 0) => process.exit(code));
+    .then((x) => x ?? 0, (e) => {
+        e && process.stderr.write(`${e}`);
+        return process.exitCode || 1;
+    }).then((code = 0) => process.exit(code));
 
 function cliOpts() {
     return [
diff --git a/js/bin/print-buffer-alignment.js b/js/bin/print-buffer-alignment.js
index 5df83eb83f0fa..0dd46c2da1c5d 100755
--- a/js/bin/print-buffer-alignment.js
+++ b/js/bin/print-buffer-alignment.js
@@ -22,7 +22,9 @@
 const fs = require('fs');
 const path = require('path');
 const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const { VectorLoader } = require(`../targets/apache-arrow/visitor/vectorloader`);
+const { VectorLoader } = process.env.ARROW_JS_DEBUG
+    ? require(`../src/visitor/vectorloader${extension}`)
+    : require(`../targets/apache-arrow/visitor/vectorloader`);
 const { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } = require(`../index${extension}`);
 
 (async () => {
diff --git a/js/gulp/test-task.js b/js/gulp/test-task.js
index a35cb9dd1ed1b..5d190be22d5a0 100644
--- a/js/gulp/test-task.js
+++ b/js/gulp/test-task.js
@@ -20,8 +20,7 @@ import path from 'path';
 import { mkdirp } from 'mkdirp';
 import { argv } from './argv.js';
 import { promisify } from 'util';
-import { globSync } from 'glob';
-const glob = promisify(globSync);
+import { glob } from 'glob';
 import child_process from 'child_process';
 import { memoizeTask } from './memoize-task.js';
 import fs from 'fs';
@@ -36,7 +35,7 @@ import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
 
-const jestArgv = [`--reporters=jest-silent-reporter`];
+const jestArgv = [];
 const testFiles = [
     `test/unit/`,
     // `test/unit/bit-tests.ts`,
@@ -53,6 +52,8 @@ const testFiles = [
 
 if (argv.verbose) {
     jestArgv.push(`--verbose`);
+} else {
+    jestArgv.push(`--reporters=jest-silent-reporter`);
 }
 
 if (targetAndModuleCombinations.length > 1) {
@@ -120,9 +121,8 @@ async function createTestJSON() {
     await exec(`python3 -B -c '\
 import sys\n\
 sys.path.append("${ARROW_ARCHERY_DIR}")\n\
-sys.argv.append("--write_generated_json=${jsonFilesDir}")\n\
-from archery.cli import integration\n\
-integration()'`);
+from archery.integration.runner import write_js_test_json\n\
+write_js_test_json("${jsonFilesDir}")'`);
 }
 
 export async function createTestData() {
diff --git a/js/src/builder/union.ts b/js/src/builder/union.ts
index 1e668f9423e7f..ac8a13191a549 100644
--- a/js/src/builder/union.ts
+++ b/js/src/builder/union.ts
@@ -47,9 +47,7 @@ export abstract class UnionBuilder<T extends Union, TNull = any> extends Builder
         if (childTypeId === undefined) {
             childTypeId = this._valueToChildTypeId(this, value, index);
         }
-        if (this.setValid(index, this.isValid(value))) {
-            this.setValue(index, value, childTypeId);
-        }
+        this.setValue(index, value, childTypeId);
         return this;
     }
 
diff --git a/js/src/data.ts b/js/src/data.ts
index b6f53b6d0e131..dc423cdb01e1c 100644
--- a/js/src/data.ts
+++ b/js/src/data.ts
@@ -16,7 +16,7 @@
 // under the License.
 
 import { Vector } from './vector.js';
-import { BufferType, Type } from './enum.js';
+import { BufferType, Type, UnionMode } from './enum.js';
 import { DataType, strideForType } from './type.js';
 import { popcnt_bit_range, truncateBitmap } from './util/bit.js';
 
@@ -56,7 +56,6 @@ export class Data<T extends DataType = DataType> {
     declare public readonly length: number;
     declare public readonly offset: number;
     declare public readonly stride: number;
-    declare public readonly nullable: boolean;
     declare public readonly children: Data[];
 
     /**
@@ -70,10 +69,26 @@ export class Data<T extends DataType = DataType> {
     declare public readonly valueOffsets: Buffers<T>[BufferType.OFFSET];
 
     public get typeId(): T['TType'] { return this.type.typeId; }
+
     public get ArrayType(): T['ArrayType'] { return this.type.ArrayType; }
+
     public get buffers() {
         return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds] as Buffers<T>;
     }
+
+    public get nullable(): boolean {
+        if (this._nullCount !== 0) {
+            const { type } = this;
+            if (DataType.isSparseUnion(type)) {
+                return this.children.some((child) => child.nullable);
+            } else if (DataType.isDenseUnion(type)) {
+                return this.children.some((child) => child.nullable);
+            }
+            return this.nullBitmap && this.nullBitmap.byteLength > 0;
+        }
+        return true;
+    }
+
     public get byteLength(): number {
         let byteLength = 0;
         const { valueOffsets, values, nullBitmap, typeIds } = this;
@@ -86,7 +101,10 @@ export class Data<T extends DataType = DataType> {
 
     protected _nullCount: number | kUnknownNullCount;
 
-    public get nullCount() {
+    public get nullCount(): number {
+        if (DataType.isUnion(this.type)) {
+            return this.children.reduce((nullCount, child) => nullCount + child.nullCount, 0);
+        }
         let nullCount = this._nullCount;
         let nullBitmap: Uint8Array | undefined;
         if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {
@@ -118,10 +136,16 @@ export class Data<T extends DataType = DataType> {
                 (buffer = (buffers as Buffers<T>)[3]) && (this.typeIds = buffer);
             }
         }
-        this.nullable = this._nullCount !== 0 && this.nullBitmap && this.nullBitmap.byteLength > 0;
     }
 
-    public getValid(index: number) {
+    public getValid(index: number): boolean {
+        const { type } = this;
+        if (DataType.isUnion(type)) {
+            const union = (<unknown>type as Union);
+            const child = this.children[union.typeIdToChildIndex[this.typeIds[index]]];
+            const indexInChild = union.mode === UnionMode.Dense ? this.valueOffsets[index] : index;
+            return child.getValid(indexInChild);
+        }
         if (this.nullable && this.nullCount > 0) {
             const pos = this.offset + index;
             const val = this.nullBitmap[pos >> 3];
@@ -130,22 +154,45 @@ export class Data<T extends DataType = DataType> {
         return true;
     }
 
-    public setValid(index: number, value: boolean) {
-        // Don't interact w/ nullBitmap if not nullable
-        if (!this.nullable) { return value; }
-        // If no null bitmap, initialize one on the fly
-        if (!this.nullBitmap || this.nullBitmap.byteLength <= (index >> 3)) {
-            const { nullBitmap } = this._changeLengthAndBackfillNullBitmap(this.length);
-            Object.assign(this, { nullBitmap, _nullCount: 0 });
+    public setValid(index: number, value: boolean): boolean {
+        let prev: boolean;
+        const { type } = this;
+        if (DataType.isUnion(type)) {
+            const union = (<unknown>type as Union);
+            const child = this.children[union.typeIdToChildIndex[this.typeIds[index]]];
+            const indexInChild = union.mode === UnionMode.Dense ? this.valueOffsets[index] : index;
+            prev = child.getValid(indexInChild);
+            child.setValid(indexInChild, value);
+        } else {
+            let { nullBitmap } = this;
+            const { offset, length } = this;
+            const idx = offset + index;
+            const mask = 1 << (idx % 8);
+            const byteOffset = idx >> 3;
+
+            // If no null bitmap, initialize one on the fly
+            if (!nullBitmap || nullBitmap.byteLength <= byteOffset) {
+                nullBitmap = new Uint8Array((((offset + length) + 63) & ~63) >> 3).fill(255);
+                // if we have a nullBitmap, truncate + slice and set it over the pre-filled 1s
+                if (this.nullCount > 0) {
+                    nullBitmap.set(truncateBitmap(offset, length, this.nullBitmap), 0);
+                }
+                Object.assign(this, { nullBitmap, _nullCount: -1 });
+            }
+
+            const byte = nullBitmap[byteOffset];
+
+            prev = (byte & mask) !== 0;
+            value ?
+                (nullBitmap[byteOffset] = byte | mask) :
+                (nullBitmap[byteOffset] = byte & ~mask);
         }
-        const { nullBitmap, offset } = this;
-        const pos = (offset + index) >> 3;
-        const bit = (offset + index) % 8;
-        const val = (nullBitmap[pos] >> bit) & 1;
-        // If `val` is truthy and the current bit is 0, flip it to 1 and increment `_nullCount`.
-        // If `val` is falsey and the current bit is 1, flip it to 0 and decrement `_nullCount`.
-        value ? val === 0 && ((nullBitmap[pos] |= (1 << bit)), (this._nullCount = this.nullCount + 1))
-            : val === 1 && ((nullBitmap[pos] &= ~(1 << bit)), (this._nullCount = this.nullCount - 1));
+
+        if (prev !== !!value) {
+            // Update `_nullCount` if the new value is different from the old value.
+            this._nullCount = this.nullCount + (value ? -1 : 1);
+        }
+
         return value;
     }
 
@@ -228,7 +275,7 @@ class MakeDataVisitor extends Visitor {
             ['offset']: offset = 0,
             ['length']: length = 0,
         } = props;
-        return new Data(type, offset, length, 0);
+        return new Data(type, offset, length, length);
     }
     public visitBool<T extends Bool>(props: BoolDataProps<T>) {
         const { ['type']: type, ['offset']: offset = 0 } = props;
@@ -320,14 +367,13 @@ class MakeDataVisitor extends Visitor {
     }
     public visitUnion<T extends Union>(props: UnionDataProps<T>) {
         const { ['type']: type, ['offset']: offset = 0, ['children']: children = [] } = props;
-        const nullBitmap = toUint8Array(props['nullBitmap']);
         const typeIds = toArrayBufferView(type.ArrayType, props['typeIds']);
-        const { ['length']: length = typeIds.length, ['nullCount']: nullCount = props['nullBitmap'] ? -1 : 0, } = props;
+        const { ['length']: length = typeIds.length, ['nullCount']: nullCount = -1, } = props;
         if (DataType.isSparseUnion(type)) {
-            return new Data(type, offset, length, nullCount, [undefined, undefined, nullBitmap, typeIds], children);
+            return new Data(type, offset, length, nullCount, [undefined, undefined, undefined, typeIds], children);
         }
         const valueOffsets = toInt32Array(props['valueOffsets']);
-        return new Data(type, offset, length, nullCount, [valueOffsets, undefined, nullBitmap, typeIds], children);
+        return new Data(type, offset, length, nullCount, [valueOffsets, undefined, undefined, typeIds], children);
     }
     public visitDictionary<T extends Dictionary>(props: DictionaryDataProps<T>) {
         const { ['type']: type, ['offset']: offset = 0 } = props;
@@ -385,8 +431,8 @@ interface ListDataProps<T extends List> extends DataProps_<T> { valueOffsets: Va
 interface FixedSizeListDataProps<T extends FixedSizeList> extends DataProps_<T> { child: Data<T['valueType']> }
 interface StructDataProps<T extends Struct> extends DataProps_<T> { children: Data[] }
 interface Map_DataProps<T extends Map_> extends DataProps_<T> { valueOffsets: ValueOffsetsBuffer; child: Data }
-interface SparseUnionDataProps<T extends SparseUnion> extends DataProps_<T> { typeIds: TypeIdsBuffer; children: Data[] }
-interface DenseUnionDataProps<T extends DenseUnion> extends DataProps_<T> { typeIds: TypeIdsBuffer; children: Data[]; valueOffsets: ValueOffsetsBuffer }
+interface SparseUnionDataProps<T extends SparseUnion> extends DataProps_<T> { nullBitmap: never; typeIds: TypeIdsBuffer; children: Data[] }
+interface DenseUnionDataProps<T extends DenseUnion> extends DataProps_<T> { nullBitmap: never; typeIds: TypeIdsBuffer; children: Data[]; valueOffsets: ValueOffsetsBuffer }
 interface UnionDataProps<T extends Union> extends DataProps_<T> { typeIds: TypeIdsBuffer; children: Data[]; valueOffsets?: ValueOffsetsBuffer }
 
 export type DataProps<T extends DataType> = (
@@ -413,6 +459,8 @@ export type DataProps<T extends DataType> = (
  /*                                */ DataProps_<T>
 );
 
+const makeDataVisitor = new MakeDataVisitor();
+
 export function makeData<T extends Null>(props: NullDataProps<T>): Data<T>;
 export function makeData<T extends Int>(props: IntDataProps<T>): Data<T>;
 export function makeData<T extends Dictionary>(props: DictionaryDataProps<T>): Data<T>;
@@ -435,5 +483,5 @@ export function makeData<T extends DenseUnion>(props: DenseUnionDataProps<T>): D
 export function makeData<T extends Union>(props: UnionDataProps<T>): Data<T>;
 export function makeData<T extends DataType>(props: DataProps_<T>): Data<T>;
 export function makeData(props: any) {
-    return new MakeDataVisitor().visit(props);
+    return makeDataVisitor.visit(props);
 }
diff --git a/js/src/ipc/message.ts b/js/src/ipc/message.ts
index 678e6e5f26e12..3dc8625233f95 100644
--- a/js/src/ipc/message.ts
+++ b/js/src/ipc/message.ts
@@ -201,7 +201,7 @@ export class JSONMessageReader extends MessageReader {
             return (xs || []).reduce<any[][]>((buffers, column: any) => [
                 ...buffers,
                 ...(column['VALIDITY'] && [column['VALIDITY']] || []),
-                ...(column['TYPE'] && [column['TYPE']] || []),
+                ...(column['TYPE_ID'] && [column['TYPE_ID']] || []),
                 ...(column['OFFSET'] && [column['OFFSET']] || []),
                 ...(column['DATA'] && [column['DATA']] || []),
                 ...flattenDataSources(column['children'])
diff --git a/js/src/ipc/metadata/file.ts b/js/src/ipc/metadata/file.ts
index 036cee18e4cea..77c76286b7491 100644
--- a/js/src/ipc/metadata/file.ts
+++ b/js/src/ipc/metadata/file.ts
@@ -38,7 +38,7 @@ class Footer_ {
     public static decode(buf: ArrayBufferViewInput) {
         buf = new ByteBuffer(toUint8Array(buf));
         const footer = _Footer.getRootAsFooter(buf);
-        const schema = Schema.decode(footer.schema()!);
+        const schema = Schema.decode(footer.schema()!, new Map(), footer.version());
         return new OffHeapFooter(schema, footer) as Footer_;
     }
 
@@ -63,7 +63,7 @@ class Footer_ {
 
         _Footer.startFooter(b);
         _Footer.addSchema(b, schemaOffset);
-        _Footer.addVersion(b, MetadataVersion.V4);
+        _Footer.addVersion(b, MetadataVersion.V5);
         _Footer.addRecordBatches(b, recordBatchesOffset);
         _Footer.addDictionaries(b, dictionaryBatchesOffset);
         _Footer.finishFooterBuffer(b, _Footer.endFooter(b));
@@ -77,7 +77,7 @@ class Footer_ {
     public get numDictionaries() { return this._dictionaryBatches.length; }
 
     constructor(public schema: Schema,
-        public version: MetadataVersion = MetadataVersion.V4,
+        public version: MetadataVersion = MetadataVersion.V5,
         recordBatches?: FileBlock[], dictionaryBatches?: FileBlock[]) {
         recordBatches && (this._recordBatches = recordBatches);
         dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);
diff --git a/js/src/ipc/metadata/json.ts b/js/src/ipc/metadata/json.ts
index 0fc1ca0801926..e5995110f084b 100644
--- a/js/src/ipc/metadata/json.ts
+++ b/js/src/ipc/metadata/json.ts
@@ -32,7 +32,7 @@ import { TimeUnit, Precision, IntervalUnit, UnionMode, DateUnit } from '../../en
 export function schemaFromJSON(_schema: any, dictionaries: Map<number, DataType> = new Map()) {
     return new Schema(
         schemaFieldsFromJSON(_schema, dictionaries),
-        customMetadataFromJSON(_schema['customMetadata']),
+        customMetadataFromJSON(_schema['metadata']),
         dictionaries
     );
 }
@@ -81,7 +81,7 @@ function buffersFromJSON(xs: any[], buffers: BufferRegion[] = []): BufferRegion[
     for (let i = -1, n = (xs || []).length; ++i < n;) {
         const column = xs[i];
         column['VALIDITY'] && buffers.push(new BufferRegion(buffers.length, column['VALIDITY'].length));
-        column['TYPE'] && buffers.push(new BufferRegion(buffers.length, column['TYPE'].length));
+        column['TYPE_ID'] && buffers.push(new BufferRegion(buffers.length, column['TYPE_ID'].length));
         column['OFFSET'] && buffers.push(new BufferRegion(buffers.length, column['OFFSET'].length));
         column['DATA'] && buffers.push(new BufferRegion(buffers.length, column['DATA'].length));
         buffers = buffersFromJSON(column['children'], buffers);
@@ -107,7 +107,7 @@ export function fieldFromJSON(_field: any, dictionaries?: Map<number, DataType>)
     // If no dictionary encoding
     if (!dictionaries || !(dictMeta = _field['dictionary'])) {
         type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries));
-        field = new Field(_field['name'], type, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));
+        field = new Field(_field['name'], type, _field['nullable'], customMetadataFromJSON(_field['metadata']));
     }
     // If dictionary encoded and the first time we've seen this dictionary id, decode
     // the data type and child fields, then wrap in a Dictionary type and insert the
@@ -117,7 +117,7 @@ export function fieldFromJSON(_field: any, dictionaries?: Map<number, DataType>)
         keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();
         dictionaries.set(id, type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries)));
         dictType = new Dictionary(type, keys, id, dictMeta['isOrdered']);
-        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));
+        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['metadata']));
     }
     // If dictionary encoded, and have already seen this dictionary Id in the schema, then reuse the
     // data type and wrap in a new Dictionary type and field.
@@ -125,14 +125,14 @@ export function fieldFromJSON(_field: any, dictionaries?: Map<number, DataType>)
         // a dictionary index defaults to signed 32 bit int if unspecified
         keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();
         dictType = new Dictionary(dictionaries.get(id)!, keys, id, dictMeta['isOrdered']);
-        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));
+        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['metadata']));
     }
     return field || null;
 }
 
 /** @ignore */
-function customMetadataFromJSON(_metadata?: Record<string, string>) {
-    return new Map<string, string>(Object.entries(_metadata || {}));
+function customMetadataFromJSON(metadata: { key: string; value: string }[] = []) {
+    return new Map<string, string>(metadata.map(({ key, value }) => [key, value]));
 }
 
 /** @ignore */
@@ -187,7 +187,9 @@ function typeFromJSON(f: any, children?: Field[]): DataType<any> {
         }
         case 'union': {
             const t = f['type'];
-            return new Union(UnionMode[t['mode']] as any, (t['typeIds'] || []), children || []);
+            const [m, ...ms] = (t['mode'] + '').toLowerCase();
+            const mode = (m.toUpperCase() + ms.join('')) as keyof typeof UnionMode;
+            return new Union(UnionMode[mode] as any, (t['typeIds'] || []), children || []);
         }
         case 'fixedsizebinary': {
             const t = f['type'];
diff --git a/js/src/ipc/metadata/message.ts b/js/src/ipc/metadata/message.ts
index c5a1c9c147e8a..6465d3d064720 100644
--- a/js/src/ipc/metadata/message.ts
+++ b/js/src/ipc/metadata/message.ts
@@ -68,7 +68,7 @@ export class Message<T extends MessageHeader = any> {
 
     /** @nocollapse */
     public static fromJSON<T extends MessageHeader>(msg: any, headerType: T): Message<T> {
-        const message = new Message(0, MetadataVersion.V4, headerType);
+        const message = new Message(0, MetadataVersion.V5, headerType);
         message._createHeader = messageHeaderFromJSON(msg, headerType);
         return message;
     }
@@ -97,7 +97,7 @@ export class Message<T extends MessageHeader = any> {
             headerOffset = DictionaryBatch.encode(b, message.header() as DictionaryBatch);
         }
         _Message.startMessage(b);
-        _Message.addVersion(b, MetadataVersion.V4);
+        _Message.addVersion(b, MetadataVersion.V5);
         _Message.addHeader(b, headerOffset);
         _Message.addHeaderType(b, message.headerType);
         _Message.addBodyLength(b, BigInt(message.bodyLength));
@@ -108,13 +108,13 @@ export class Message<T extends MessageHeader = any> {
     /** @nocollapse */
     public static from(header: Schema | RecordBatch | DictionaryBatch, bodyLength = 0) {
         if (header instanceof Schema) {
-            return new Message(0, MetadataVersion.V4, MessageHeader.Schema, header);
+            return new Message(0, MetadataVersion.V5, MessageHeader.Schema, header);
         }
         if (header instanceof RecordBatch) {
-            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.RecordBatch, header);
+            return new Message(bodyLength, MetadataVersion.V5, MessageHeader.RecordBatch, header);
         }
         if (header instanceof DictionaryBatch) {
-            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.DictionaryBatch, header);
+            return new Message(bodyLength, MetadataVersion.V5, MessageHeader.DictionaryBatch, header);
         }
         throw new Error(`Unrecognized Message header: ${header}`);
     }
@@ -225,7 +225,7 @@ function messageHeaderFromJSON(message: any, type: MessageHeader) {
 function decodeMessageHeader(message: _Message, type: MessageHeader) {
     return (() => {
         switch (type) {
-            case MessageHeader.Schema: return Schema.decode(message.header(new _Schema())!);
+            case MessageHeader.Schema: return Schema.decode(message.header(new _Schema())!, new Map(), message.version());
             case MessageHeader.RecordBatch: return RecordBatch.decode(message.header(new _RecordBatch())!, message.version());
             case MessageHeader.DictionaryBatch: return DictionaryBatch.decode(message.header(new _DictionaryBatch())!, message.version());
         }
@@ -290,13 +290,13 @@ declare module './message' {
 }
 
 /** @ignore */
-function decodeSchema(_schema: _Schema, dictionaries: Map<number, DataType> = new Map()) {
+function decodeSchema(_schema: _Schema, dictionaries: Map<number, DataType> = new Map(), version = MetadataVersion.V5) {
     const fields = decodeSchemaFields(_schema, dictionaries);
-    return new Schema(fields, decodeCustomMetadata(_schema), dictionaries);
+    return new Schema(fields, decodeCustomMetadata(_schema), dictionaries, version);
 }
 
 /** @ignore */
-function decodeRecordBatch(batch: _RecordBatch, version = MetadataVersion.V4) {
+function decodeRecordBatch(batch: _RecordBatch, version = MetadataVersion.V5) {
     if (batch.compression() !== null) {
         throw new Error('Record batch compression not implemented');
     }
@@ -304,7 +304,7 @@ function decodeRecordBatch(batch: _RecordBatch, version = MetadataVersion.V4) {
 }
 
 /** @ignore */
-function decodeDictionaryBatch(batch: _DictionaryBatch, version = MetadataVersion.V4) {
+function decodeDictionaryBatch(batch: _DictionaryBatch, version = MetadataVersion.V5) {
     return new DictionaryBatch(RecordBatch.decode(batch.data()!, version), batch.id(), batch.isDelta());
 }
 
diff --git a/js/src/ipc/reader.ts b/js/src/ipc/reader.ts
index 77496e799b871..b1ad5248d6158 100644
--- a/js/src/ipc/reader.ts
+++ b/js/src/ipc/reader.ts
@@ -371,7 +371,7 @@ abstract class RecordBatchReaderImpl<T extends TypeMap = any> implements RecordB
         return dictionary.memoize();
     }
     protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {
-        return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);
+        return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
     }
 }
 
@@ -678,7 +678,7 @@ class RecordBatchJSONReaderImpl<T extends TypeMap = any> extends RecordBatchStre
         super(source, dictionaries);
     }
     protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {
-        return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);
+        return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
     }
 }
 
diff --git a/js/src/ipc/writer.ts b/js/src/ipc/writer.ts
index 5f5cc37562bb0..54b4b0249e420 100644
--- a/js/src/ipc/writer.ts
+++ b/js/src/ipc/writer.ts
@@ -342,7 +342,7 @@ export class RecordBatchFileWriter<T extends TypeMap = any> extends RecordBatchW
 
     protected _writeFooter(schema: Schema<T>) {
         const buffer = Footer.encode(new Footer(
-            schema, MetadataVersion.V4,
+            schema, MetadataVersion.V5,
             this._recordBatchBlocks, this._dictionaryBlocks
         ));
         return super
diff --git a/js/src/recordbatch.ts b/js/src/recordbatch.ts
index eed9de66e8ec2..59505a70a3c81 100644
--- a/js/src/recordbatch.ts
+++ b/js/src/recordbatch.ts
@@ -315,23 +315,25 @@ function ensureSameLengthData<T extends TypeMap = any>(
 }
 
 /** @ignore */
-function collectDictionaries(fields: Field[], children: Data[], dictionaries = new Map<number, Vector>()): Map<number, Vector> {
-    for (let i = -1, n = fields.length; ++i < n;) {
-        const field = fields[i];
-        const type = field.type;
-        const data = children[i];
-        if (DataType.isDictionary(type)) {
-            if (!dictionaries.has(type.id)) {
-                if (data.dictionary) {
-                    dictionaries.set(type.id, data.dictionary);
+function collectDictionaries(fields: Field[], children: readonly Data[], dictionaries = new Map<number, Vector>()): Map<number, Vector> {
+    if ((fields?.length ?? 0) > 0 && (fields?.length === children?.length)) {
+        for (let i = -1, n = fields.length; ++i < n;) {
+            const { type } = fields[i];
+            const data = children[i];
+            for (const next of [data, ...(data?.dictionary?.data || [])]) {
+                collectDictionaries(type.children, next?.children, dictionaries);
+            }
+            if (DataType.isDictionary(type)) {
+                const { id } = type;
+                if (!dictionaries.has(id)) {
+                    if (data?.dictionary) {
+                        dictionaries.set(id, data.dictionary);
+                    }
+                } else if (dictionaries.get(id) !== data.dictionary) {
+                    throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);
                 }
-            } else if (dictionaries.get(type.id) !== data.dictionary) {
-                throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);
             }
         }
-        if (type.children && type.children.length > 0) {
-            collectDictionaries(type.children, data.children, dictionaries);
-        }
     }
     return dictionaries;
 }
diff --git a/js/src/schema.ts b/js/src/schema.ts
index 858bab915b010..a5b1dcb56665c 100644
--- a/js/src/schema.ts
+++ b/js/src/schema.ts
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+import { MetadataVersion } from './enum.js';
 import { DataType, TypeMap } from './type.js';
 
 export class Schema<T extends TypeMap = any> {
@@ -22,17 +23,20 @@ export class Schema<T extends TypeMap = any> {
     public readonly fields: Field<T[keyof T]>[];
     public readonly metadata: Map<string, string>;
     public readonly dictionaries: Map<number, DataType>;
+    public readonly metadataVersion: MetadataVersion;
 
     constructor(
         fields: Field<T[keyof T]>[] = [],
         metadata?: Map<string, string> | null,
-        dictionaries?: Map<number, DataType> | null) {
+        dictionaries?: Map<number, DataType> | null,
+        metadataVersion = MetadataVersion.V5) {
         this.fields = (fields || []) as Field<T[keyof T]>[];
         this.metadata = metadata || new Map();
         if (!dictionaries) {
             dictionaries = generateDictionaryMap(fields);
         }
         this.dictionaries = dictionaries;
+        this.metadataVersion = metadataVersion;
     }
     public get [Symbol.toStringTag]() { return 'Schema'; }
 
diff --git a/js/src/type.ts b/js/src/type.ts
index e3b9c02b5e4f2..1dc90c47cbd10 100644
--- a/js/src/type.ts
+++ b/js/src/type.ts
@@ -585,10 +585,25 @@ export interface Map_<TKey extends DataType = any, TValue extends DataType = any
 
 /** @ignore */
 export class Map_<TKey extends DataType = any, TValue extends DataType = any> extends DataType<Type.Map, { [0]: Struct<{ key: TKey; value: TValue }> }> {
-    constructor(child: Field<Struct<{ key: TKey; value: TValue }>>, keysSorted = false) {
+    constructor(entries: Field<Struct<{ key: TKey; value: TValue }>>, keysSorted = false) {
         super();
-        this.children = [child];
+        this.children = [entries];
         this.keysSorted = keysSorted;
+        // ARROW-8716
+        // https://github.com/apache/arrow/issues/17168
+        if (entries) {
+            (entries as any)['name'] = 'entries';
+            if ((entries as any)?.type?.children) {
+                const key = (entries as any)?.type?.children[0];
+                if (key) {
+                    key['name'] = 'key';
+                }
+                const val = (entries as any)?.type?.children[1];
+                if (val) {
+                    val['name'] = 'value';
+                }
+            }
+        }
     }
     public declare readonly keysSorted: boolean;
     public declare readonly children: Field<Struct<{ key: TKey; value: TValue }>>[];
diff --git a/js/src/util/buffer.ts b/js/src/util/buffer.ts
index c3d90ecadab11..dd8edf11f9258 100644
--- a/js/src/util/buffer.ts
+++ b/js/src/util/buffer.ts
@@ -212,12 +212,12 @@ export function rebaseValueOffsets(offset: number, length: number, valueOffsets:
     // If we have a non-zero offset, create a new offsets array with the values
     // shifted by the start offset, such that the new start offset is 0
     if (offset !== 0) {
-        valueOffsets = valueOffsets.slice(0, length + 1);
-        for (let i = -1; ++i <= length;) {
+        valueOffsets = valueOffsets.slice(0, length);
+        for (let i = -1, n = valueOffsets.length; ++i < n;) {
             valueOffsets[i] += offset;
         }
     }
-    return valueOffsets;
+    return valueOffsets.subarray(0, length);
 }
 
 /** @ignore */
diff --git a/js/src/vector.ts b/js/src/vector.ts
index 48d0a1244e815..318ce06e5c3c0 100644
--- a/js/src/vector.ts
+++ b/js/src/vector.ts
@@ -99,8 +99,6 @@ export class Vector<T extends DataType = any> {
     }
 
     declare protected _offsets: number[] | Uint32Array;
-    declare protected _nullCount: number;
-    declare protected _byteLength: number;
 
     /**
      * The {@link DataType `DataType`} of this Vector.
@@ -131,20 +129,14 @@ export class Vector<T extends DataType = any> {
      * The aggregate size (in bytes) of this Vector's buffers and/or child Vectors.
      */
     public get byteLength() {
-        if (this._byteLength === -1) {
-            this._byteLength = this.data.reduce((byteLength, data) => byteLength + data.byteLength, 0);
-        }
-        return this._byteLength;
+        return this.data.reduce((byteLength, data) => byteLength + data.byteLength, 0);
     }
 
     /**
      * The number of null elements in this Vector.
      */
     public get nullCount() {
-        if (this._nullCount === -1) {
-            this._nullCount = computeChunkNullCounts(this.data);
-        }
-        return this._nullCount;
+        return computeChunkNullCounts(this.data);
     }
 
     /**
@@ -195,7 +187,10 @@ export class Vector<T extends DataType = any> {
     // @ts-ignore
     public indexOf(element: T['TValue'], offset?: number): number { return -1; }
 
-    public includes(element: T['TValue'], offset?: number): boolean { return this.indexOf(element, offset) > 0; }
+    public includes(element: T['TValue'], offset?: number): boolean {
+        // eslint-disable-next-line unicorn/prefer-includes
+        return this.indexOf(element, offset) > -1;
+    }
 
     /**
      * Get the size in bytes of an element by index.
@@ -352,8 +347,6 @@ export class Vector<T extends DataType = any> {
         (proto as any).length = 0;
         (proto as any).stride = 1;
         (proto as any).numChildren = 0;
-        (proto as any)._nullCount = -1;
-        (proto as any)._byteLength = -1;
         (proto as any)._offsets = new Uint32Array([0]);
         (proto as any)[Symbol.isConcatSpreadable] = true;
 
diff --git a/js/src/visitor/indexof.ts b/js/src/visitor/indexof.ts
index 93b4c0c495ca9..654134c6dff04 100644
--- a/js/src/visitor/indexof.ts
+++ b/js/src/visitor/indexof.ts
@@ -111,7 +111,19 @@ function indexOfNull<T extends DataType>(data: Data<T>, fromIndex?: number): num
 /** @ignore */
 function indexOfValue<T extends DataType>(data: Data<T>, searchElement?: T['TValue'] | null, fromIndex?: number): number {
     if (searchElement === undefined) { return -1; }
-    if (searchElement === null) { return indexOfNull(data, fromIndex); }
+    if (searchElement === null) {
+        switch (data.typeId) {
+            // Unions don't have a nullBitmap of its own, so compare the `searchElement` to `get()`.
+            case Type.Union:
+                break;
+            // Dictionaries do have a nullBitmap, but their dictionary could also have null elements.
+            case Type.Dictionary:
+                break;
+            // All other types can iterate the null bitmap
+            default:
+                return indexOfNull(data, fromIndex);
+        }
+    }
     const get = getVisitor.getVisitFn(data);
     const compare = createElementComparator(searchElement);
     for (let i = (fromIndex || 0) - 1, n = data.length; ++i < n;) {
diff --git a/js/src/visitor/jsontypeassembler.ts b/js/src/visitor/jsontypeassembler.ts
index 9aae1c296893d..d83edfc24fbd8 100644
--- a/js/src/visitor/jsontypeassembler.ts
+++ b/js/src/visitor/jsontypeassembler.ts
@@ -72,7 +72,7 @@ export class JSONTypeAssembler extends Visitor {
     public visitUnion<T extends type.Union>({ typeId, mode, typeIds }: T) {
         return {
             'name': ArrowType[typeId].toLowerCase(),
-            'mode': UnionMode[mode],
+            'mode': UnionMode[mode].toUpperCase(),
             'typeIds': [...typeIds]
         };
     }
diff --git a/js/src/visitor/jsonvectorassembler.ts b/js/src/visitor/jsonvectorassembler.ts
index 270e31a2c6ab7..7a617f4afe2c4 100644
--- a/js/src/visitor/jsonvectorassembler.ts
+++ b/js/src/visitor/jsonvectorassembler.ts
@@ -35,7 +35,7 @@ export interface JSONVectorAssembler extends Visitor {
 
     visit<T extends DataType>(field: Field, node: Data<T>): Record<string, unknown>;
     visitMany<T extends DataType>(fields: Field[], nodes: readonly Data<T>[]): Record<string, unknown>[];
-    getVisitFn<T extends DataType>(node: Vector<T> | Data<T>): (data: Data<T>) => { name: string; count: number; VALIDITY: (0 | 1)[]; DATA?: any[]; OFFSET?: number[]; TYPE?: number[]; children?: any[] };
+    getVisitFn<T extends DataType>(node: Vector<T> | Data<T>): (data: Data<T>) => { name: string; count: number; VALIDITY: (0 | 1)[]; DATA?: any[]; OFFSET?: number[]; TYPE_ID?: number[]; children?: any[] };
 
     visitNull<T extends Null>(data: Data<T>): Record<string, never>;
     visitBool<T extends Bool>(data: Data<T>): { DATA: boolean[] };
@@ -50,7 +50,7 @@ export interface JSONVectorAssembler extends Visitor {
     visitDecimal<T extends Decimal>(data: Data<T>): { DATA: string[] };
     visitList<T extends List>(data: Data<T>): { children: any[]; OFFSET: number[] };
     visitStruct<T extends Struct>(data: Data<T>): { children: any[] };
-    visitUnion<T extends Union>(data: Data<T>): { children: any[]; TYPE: number[] };
+    visitUnion<T extends Union>(data: Data<T>): { children: any[]; TYPE_ID: number[] };
     visitInterval<T extends Interval>(data: Data<T>): { DATA: number[] };
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>): { children: any[] };
     visitMap<T extends Map_>(data: Data<T>): { children: any[] };
@@ -75,7 +75,8 @@ export class JSONVectorAssembler extends Visitor {
         return {
             'name': name,
             'count': length,
-            'VALIDITY': DataType.isNull(type) ? undefined
+            'VALIDITY': (DataType.isNull(type) || DataType.isUnion(type))
+                ? undefined
                 : nullCount <= 0 ? Array.from({ length }, () => 1)
                     : [...new BitIterator(nullBitmap, offset, length, null, getBit)],
             ...super.visit(data.clone(type, offset, length, 0, buffers))
@@ -137,7 +138,7 @@ export class JSONVectorAssembler extends Visitor {
     }
     public visitUnion<T extends Union>(data: Data<T>) {
         return {
-            'TYPE': [...data.typeIds],
+            'TYPE_ID': [...data.typeIds],
             'OFFSET': data.type.mode === UnionMode.Dense ? [...data.valueOffsets] : undefined,
             'children': this.visitMany(data.type.children, data.children)
         };
diff --git a/js/src/visitor/vectorassembler.ts b/js/src/visitor/vectorassembler.ts
index a9415b0e0c1dd..dbf778c4c3631 100644
--- a/js/src/visitor/vectorassembler.ts
+++ b/js/src/visitor/vectorassembler.ts
@@ -77,18 +77,23 @@ export class VectorAssembler extends Visitor {
         }
         const { type } = data;
         if (!DataType.isDictionary(type)) {
-            const { length, nullCount } = data;
+            const { length } = data;
             if (length > 2147483647) {
                 /* istanbul ignore next */
                 throw new RangeError('Cannot write arrays larger than 2^31 - 1 in length');
             }
-            if (!DataType.isNull(type)) {
-                addBuffer.call(this, nullCount <= 0
-                    ? new Uint8Array(0) // placeholder validity buffer
-                    : truncateBitmap(data.offset, length, data.nullBitmap)
-                );
+            if (DataType.isUnion(type)) {
+                this.nodes.push(new FieldNode(length, 0));
+            } else {
+                const { nullCount } = data;
+                if (!DataType.isNull(type)) {
+                    addBuffer.call(this, nullCount <= 0
+                        ? new Uint8Array(0) // placeholder validity buffer
+                        : truncateBitmap(data.offset, length, data.nullBitmap)
+                    );
+                }
+                this.nodes.push(new FieldNode(length, nullCount));
             }
-            this.nodes.push(new FieldNode(length, nullCount));
         }
         return super.visit(data);
     }
@@ -141,31 +146,30 @@ function assembleUnion<T extends Union>(this: VectorAssembler, data: Data<T>) {
             // A sliced Dense Union is an unpleasant case. Because the offsets are different for
             // each child vector, we need to "rebase" the valueOffsets for each child
             // Union typeIds are not necessary 0-indexed
-            const maxChildTypeId = typeIds.reduce((x, y) => Math.max(x, y), typeIds[0]);
-            const childLengths = new Int32Array(maxChildTypeId + 1);
-            // Set all to -1 to indicate that we haven't observed a first occurrence of a particular child yet
-            const childOffsets = new Int32Array(maxChildTypeId + 1).fill(-1);
             const shiftedOffsets = new Int32Array(length);
+            const childOffsets = Object.create(null) as Record<string, number>;
+            const childLengths = Object.create(null) as Record<string, number>;
             // If we have a non-zero offset, then the value offsets do not start at
             // zero. We must a) create a new offsets array with shifted offsets and
             // b) slice the values array accordingly
-            const unshiftedOffsets = rebaseValueOffsets(-valueOffsets[0], length, valueOffsets);
             for (let typeId, shift, index = -1; ++index < length;) {
-                if ((shift = childOffsets[typeId = typeIds[index]]) === -1) {
-                    shift = childOffsets[typeId] = unshiftedOffsets[typeId];
+                if ((typeId = typeIds[index]) === undefined) {
+                    continue;
+                }
+                if ((shift = childOffsets[typeId]) === undefined) {
+                    shift = childOffsets[typeId] = valueOffsets[index];
                 }
-                shiftedOffsets[index] = unshiftedOffsets[index] - shift;
-                ++childLengths[typeId];
+                shiftedOffsets[index] = valueOffsets[index] - shift;
+                childLengths[typeId] = (childLengths[typeId] ?? 0) + 1;
             }
             addBuffer.call(this, shiftedOffsets);
             // Slice and visit children accordingly
-            for (let child: Data | null, childIndex = -1, numChildren = type.children.length; ++childIndex < numChildren;) {
-                if (child = data.children[childIndex]) {
-                    const typeId = type.typeIds[childIndex];
-                    const childLength = Math.min(length, childLengths[typeId]);
-                    this.visit(child.slice(childOffsets[typeId], childLength));
-                }
-            }
+            this.visitMany(data.children.map((child, childIndex) => {
+                const typeId = type.typeIds[childIndex];
+                const childOffset = childOffsets[typeId];
+                const childLength = childLengths[typeId];
+                return child.slice(childOffset, Math.min(length, childLength));
+            }));
         }
     }
     return this;
@@ -198,12 +202,11 @@ function assembleFlatVector<T extends Int | Float | FixedSizeBinary | Date_ | Ti
 /** @ignore */
 function assembleFlatListVector<T extends Utf8 | Binary>(this: VectorAssembler, data: Data<T>) {
     const { length, values, valueOffsets } = data;
-    const firstOffset = valueOffsets[0];
-    const lastOffset = valueOffsets[length];
-    const byteLength = Math.min(lastOffset - firstOffset, values.byteLength - firstOffset);
+    const { [0]: begin, [length]: end } = valueOffsets;
+    const byteLength = Math.min(end - begin, values.byteLength - begin);
     // Push in the order FlatList types read their buffers
-    addBuffer.call(this, rebaseValueOffsets(-valueOffsets[0], length, valueOffsets)); // valueOffsets buffer first
-    addBuffer.call(this, values.subarray(firstOffset, firstOffset + byteLength)); // sliced values buffer second
+    addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets)); // valueOffsets buffer first
+    addBuffer.call(this, values.subarray(begin, begin + byteLength)); // sliced values buffer second
     return this;
 }
 
@@ -212,7 +215,10 @@ function assembleListVector<T extends Map_ | List | FixedSizeList>(this: VectorA
     const { length, valueOffsets } = data;
     // If we have valueOffsets (MapVector, ListVector), push that buffer first
     if (valueOffsets) {
-        addBuffer.call(this, rebaseValueOffsets(valueOffsets[0], length, valueOffsets));
+        const { [0]: begin, [length]: end } = valueOffsets;
+        addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets));
+        // Then insert the List's values child
+        return this.visit(data.children[0].slice(begin, end - begin));
     }
     // Then insert the List's values child
     return this.visit(data.children[0]);
diff --git a/js/src/visitor/vectorloader.ts b/js/src/visitor/vectorloader.ts
index 63431463a9623..cb4bc2829274f 100644
--- a/js/src/visitor/vectorloader.ts
+++ b/js/src/visitor/vectorloader.ts
@@ -24,7 +24,7 @@ import { Visitor } from '../visitor.js';
 import { packBools } from '../util/bit.js';
 import { encodeUtf8 } from '../util/utf8.js';
 import { Int64, Int128 } from '../util/int.js';
-import { UnionMode, DateUnit } from '../enum.js';
+import { UnionMode, DateUnit, MetadataVersion } from '../enum.js';
 import { toArrayBufferView } from '../util/buffer.js';
 import { BufferRegion, FieldNode } from '../ipc/metadata/message.js';
 
@@ -42,12 +42,14 @@ export class VectorLoader extends Visitor {
     private buffers: BufferRegion[];
     private buffersIndex = -1;
     private dictionaries: Map<number, Vector<any>>;
-    constructor(bytes: Uint8Array, nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {
+    private readonly metadataVersion: MetadataVersion;
+    constructor(bytes: Uint8Array, nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>, metadataVersion = MetadataVersion.V5) {
         super();
         this.bytes = bytes;
         this.nodes = nodes;
         this.buffers = buffers;
         this.dictionaries = dictionaries;
+        this.metadataVersion = metadataVersion;
     }
 
     public visit<T extends DataType>(node: Field<T> | T): Data<T> {
@@ -93,14 +95,19 @@ export class VectorLoader extends Visitor {
     public visitStruct<T extends type.Struct>(type: T, { length, nullCount } = this.nextFieldNode()) {
         return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), children: this.visitMany(type.children) });
     }
-    public visitUnion<T extends type.Union>(type: T) {
-        return type.mode === UnionMode.Sparse ? this.visitSparseUnion(type as type.SparseUnion) : this.visitDenseUnion(type as type.DenseUnion);
+    public visitUnion<T extends type.Union>(type: T, { length, nullCount } = this.nextFieldNode()) {
+        if (this.metadataVersion < MetadataVersion.V5) {
+            this.readNullBitmap(type, nullCount);
+        }
+        return type.mode === UnionMode.Sparse
+            ? this.visitSparseUnion(type as type.SparseUnion, { length, nullCount })
+            : this.visitDenseUnion(type as type.DenseUnion, { length, nullCount });
     }
     public visitDenseUnion<T extends type.DenseUnion>(type: T, { length, nullCount } = this.nextFieldNode()) {
-        return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), typeIds: this.readTypeIds(type), valueOffsets: this.readOffsets(type), children: this.visitMany(type.children) });
+        return makeData({ type, length, nullCount, typeIds: this.readTypeIds(type), valueOffsets: this.readOffsets(type), children: this.visitMany(type.children) });
     }
     public visitSparseUnion<T extends type.SparseUnion>(type: T, { length, nullCount } = this.nextFieldNode()) {
-        return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), typeIds: this.readTypeIds(type), children: this.visitMany(type.children) });
+        return makeData({ type, length, nullCount, typeIds: this.readTypeIds(type), children: this.visitMany(type.children) });
     }
     public visitDictionary<T extends type.Dictionary>(type: T, { length, nullCount } = this.nextFieldNode()) {
         return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type.indices), dictionary: this.readDictionary(type) });
@@ -133,8 +140,8 @@ export class VectorLoader extends Visitor {
 /** @ignore */
 export class JSONVectorLoader extends VectorLoader {
     private sources: any[][];
-    constructor(sources: any[][], nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {
-        super(new Uint8Array(0), nodes, buffers, dictionaries);
+    constructor(sources: any[][], nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>, metadataVersion: MetadataVersion) {
+        super(new Uint8Array(0), nodes, buffers, dictionaries, metadataVersion);
         this.sources = sources;
     }
     protected readNullBitmap<T extends DataType>(_type: T, nullCount: number, { offset } = this.nextBufferRange()) {
diff --git a/js/test/generate-test-data.ts b/js/test/generate-test-data.ts
index a84344e1a0395..a03b22c54c770 100644
--- a/js/test/generate-test-data.ts
+++ b/js/test/generate-test-data.ts
@@ -304,7 +304,7 @@ function generateFloat<T extends Float>(this: TestDataVectorGenerator, type: T,
 
 function generateUtf8<T extends Utf8>(this: TestDataVectorGenerator, type: T, length = 100, nullCount = Math.trunc(length * 0.2)): GeneratedVector<T> {
     const nullBitmap = createBitmap(length, nullCount);
-    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, undefined, undefined, nullCount != 0);
+    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, 10, 20, nullCount != 0);
     const values: string[] = new Array(valueOffsets.length - 1).fill(null);
     [...valueOffsets.slice(1)]
         .map((o, i) => isValid(nullBitmap, i) ? o - valueOffsets[i] : null)
@@ -326,7 +326,7 @@ function generateUtf8<T extends Utf8>(this: TestDataVectorGenerator, type: T, le
 
 function generateBinary<T extends Binary>(this: TestDataVectorGenerator, type: T, length = 100, nullCount = Math.trunc(length * 0.2)): GeneratedVector<T> {
     const nullBitmap = createBitmap(length, nullCount);
-    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, undefined, undefined, nullCount != 0);
+    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, 10, 20, nullCount != 0);
     const values = [...valueOffsets.slice(1)]
         .map((o, i) => isValid(nullBitmap, i) ? o - valueOffsets[i] : null)
         .map((length) => length == null ? null : randomBytes(length));
@@ -425,7 +425,7 @@ function generateList<T extends List>(this: TestDataVectorGenerator, type: T, le
     const childVec = child.vector;
     const nullBitmap = createBitmap(length, nullCount);
     const stride = childVec.length / (length - nullCount);
-    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, childVec.length, stride);
+    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, stride, stride);
     const values = memoize(() => {
         const childValues = child.values();
         const values: (T['valueType'] | null)[] = [...valueOffsets.slice(1)]
@@ -486,7 +486,8 @@ function generateUnion<T extends Union>(this: TestDataVectorGenerator, type: T,
 
     if (!children) {
         if (type.mode === UnionMode.Sparse) {
-            children = type.children.map((f) => this.visit(f.type, length, nullCount));
+            const childNullCount = nullCount && Math.trunc(length / nullCount);
+            children = type.children.map((f) => this.visit(f.type, length, childNullCount));
         } else {
             const childLength = Math.ceil(length / numChildren);
             const childNullCount = Math.trunc(nullCount / childLength);
@@ -498,7 +499,6 @@ function generateUnion<T extends Union>(this: TestDataVectorGenerator, type: T,
     const typeIdsBuffer = new Int8Array(length);
     const vecs = children.flatMap(({ vector }) => vector.data);
     const cols = children.map(({ values }) => values);
-    const nullBitmap = createBitmap(length, nullCount);
     const typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => {
         return (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex;
     }, Object.create(null) as { [key: number]: number });
@@ -507,37 +507,31 @@ function generateUnion<T extends Union>(this: TestDataVectorGenerator, type: T,
         const values = memoize(() => {
             const values = [] as any[];
             const childValues = cols.map((x) => x());
-            iterateBitmap(length, nullBitmap, (i, valid) => {
-                values[i] = !valid ? null : childValues[typeIdToChildIndex[typeIdsBuffer[i]]][i];
-            });
+            for (let i = -1; ++i < length;) {
+                values[i] = childValues[typeIdToChildIndex[typeIdsBuffer[i]]][i];
+            }
             return values;
         });
-        iterateBitmap(length, nullBitmap, (i, valid) => {
-            typeIdsBuffer[i] = !valid ? 0 : typeIds[Math.trunc(rand() * numChildren)];
-        });
-        return { values, vector: new Vector([makeData<SparseUnion>({ type: type as SparseUnion, length, nullCount, nullBitmap, typeIds: typeIdsBuffer, children: vecs })]) } as GeneratedVector<T>;
+        for (let i = -1; ++i < length;) {
+            typeIdsBuffer[i] = typeIds[Math.trunc(rand() * numChildren)];
+        }
+        return { values, vector: new Vector([makeData<SparseUnion>({ type: type as SparseUnion, length, nullCount: -1, typeIds: typeIdsBuffer, children: vecs })]) } as GeneratedVector<T>;
     }
 
     const valueOffsets = new Int32Array(length);
     const values = memoize(() => {
         const values = [] as any[];
         const childValues = cols.map((x) => x());
-        iterateBitmap(length, nullBitmap, (i, valid) => {
-            values[i] = !valid ? null : childValues[typeIdToChildIndex[typeIdsBuffer[i]]][valueOffsets[i]];
-        });
-        return values;
-    });
-    iterateBitmap(length, nullBitmap, (i, valid) => {
-        if (!valid) {
-            valueOffsets[i] = 0;
-            typeIdsBuffer[i] = 0;
-        } else {
-            const colIdx = Math.trunc(rand() * numChildren);
-            valueOffsets[i] = Math.trunc(i / numChildren);
-            typeIdsBuffer[i] = typeIds[colIdx];
+        for (let i = -1; ++i < length;) {
+            values[i] = childValues[typeIdToChildIndex[typeIdsBuffer[i]]][valueOffsets[i]];
         }
+        return values;
     });
-    return { values, vector: new Vector([makeData<DenseUnion>({ type: type as DenseUnion, length, nullCount, nullBitmap, typeIds: typeIdsBuffer, valueOffsets, children: vecs })]) } as GeneratedVector<T>;
+    for (let i = -1; ++i < length;) {
+        valueOffsets[i] = Math.trunc(i / numChildren);
+        typeIdsBuffer[i] = typeIds[i % numChildren];
+    }
+    return { values, vector: new Vector([makeData<DenseUnion>({ type: type as DenseUnion, length, nullCount: -1, typeIds: typeIdsBuffer, valueOffsets, children: vecs })]) } as GeneratedVector<T>;
 }
 
 function generateStruct<T extends Struct>(this: TestDataVectorGenerator, type: T, length = 100, nullCount = Math.trunc(length * 0.2), children = type.children.map((f) => this.visit(f.type, length, nullCount))): GeneratedVector<T> {
@@ -569,7 +563,7 @@ function generateMap<T extends Map_>(this: TestDataVectorGenerator,
     const childVec = child.vector;
     const nullBitmap = createBitmap(length, nullCount);
     const stride = childVec.length / (length - nullCount);
-    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, childVec.length, stride);
+    const valueOffsets = createVariableWidthOffsets(length, nullBitmap, stride, stride);
     const values = memoize(() => {
         const childValues: { key: K; value: V }[] = <any>child.values();
         const values: (Record<K, V> | null)[] = [...valueOffsets.slice(1)]
@@ -648,14 +642,14 @@ function createBitmap(length: number, nullCount: number) {
     return bytes;
 }
 
-function createVariableWidthOffsets(length: number, nullBitmap: Uint8Array, max = Number.POSITIVE_INFINITY, stride = 20, allowEmpty = true) {
+function createVariableWidthOffsets(length: number, nullBitmap: Uint8Array, min = 10, max = Number.POSITIVE_INFINITY, allowEmpty = true) {
     const offsets = new Int32Array(length + 1);
     iterateBitmap(length, nullBitmap, (i, valid) => {
         if (!valid) {
             offsets[i + 1] = offsets[i];
         } else {
             do {
-                offsets[i + 1] = Math.min(max, offsets[i] + Math.max(10, Math.trunc(rand() * stride)));
+                offsets[i + 1] = offsets[i] + Math.min(max, Math.max(min, Math.trunc(rand() * max)));
             } while (!allowEmpty && offsets[i + 1] === offsets[i]);
         }
     });
diff --git a/js/test/unit/generated-data-tests.ts b/js/test/unit/generated-data-tests.ts
index 948b7af70659e..90cf0d598aa6f 100644
--- a/js/test/unit/generated-data-tests.ts
+++ b/js/test/unit/generated-data-tests.ts
@@ -54,7 +54,7 @@ describe('Generated Test Data', () => {
     describe('List', () => { validateVector(generate.list()); });
     describe('Struct', () => { validateVector(generate.struct()); });
     describe('DenseUnion', () => { validateVector(generate.denseUnion()); });
-    // describe('SparseUnion', () => { validateVector(generate.sparseUnion()); });
+    describe('SparseUnion', () => { validateVector(generate.sparseUnion()); });
     describe('Dictionary', () => { validateVector(generate.dictionary()); });
     describe('IntervalDayTime', () => { validateVector(generate.intervalDayTime()); });
     describe('IntervalYearMonth', () => { validateVector(generate.intervalYearMonth()); });
diff --git a/js/test/unit/generated-data-validators.ts b/js/test/unit/generated-data-validators.ts
index 2a73a39cebd0a..52f642d2a6e89 100644
--- a/js/test/unit/generated-data-validators.ts
+++ b/js/test/unit/generated-data-validators.ts
@@ -162,6 +162,8 @@ function vectorTests(values: any[], vector: Vector<any>, keys?: number[]) {
                 actual = vector.indexOf(value);
                 expected = values.findIndex(compare(value));
                 expect(actual).toBe(expected);
+                // eslint-disable-next-line jest/prefer-to-contain
+                expect(vector.includes(value)).toBe(true);
             }
             // I would be pretty surprised if randomatic ever generates these values
             expect(vector.indexOf('purple elephants')).toBe(-1);
diff --git a/js/test/unit/visitor-tests.ts b/js/test/unit/visitor-tests.ts
index cadacf21eed39..645fcc60f8d90 100644
--- a/js/test/unit/visitor-tests.ts
+++ b/js/test/unit/visitor-tests.ts
@@ -110,7 +110,9 @@ describe('Visitor', () => {
         test(`visits Dictionary types`, () => validateBasicVisitor(new Dictionary(null as any, null as any)));
         test(`visits Interval types`, () => validateBasicVisitor(new Interval(0)));
         test(`visits FixedSizeList types`, () => validateBasicVisitor(new FixedSizeList(2, null as any)));
-        test(`visits Map types`, () => validateBasicVisitor(new Map_(new Field('', new Struct<{ key: Int; value: Int }>([] as any[])))));
+        test(`visits Map types`, () => validateBasicVisitor(new Map_(new Field('', new Struct<{ key: Utf8; value: Int }>([
+            new Field('key', new Utf8()), new Field('value', new Int8())
+        ] as any[])))));
         function validateBasicVisitor<T extends DataType>(type: T) {
             const visitor = new BasicVisitor();
             const result = visitor.visit(type);
@@ -156,7 +158,9 @@ describe('Visitor', () => {
         test(`visits IntervalDayTime types`, () => validateFeatureVisitor(new IntervalDayTime()));
         test(`visits IntervalYearMonth types`, () => validateFeatureVisitor(new IntervalYearMonth()));
         test(`visits FixedSizeList types`, () => validateFeatureVisitor(new FixedSizeList(2, null as any)));
-        test(`visits Map types`, () => validateFeatureVisitor(new Map_(new Field('', new Struct<{ key: Int; value: Int }>([] as any[])))));
+        test(`visits Map types`, () => validateFeatureVisitor(new Map_(new Field('', new Struct<{ key: Utf8; value: Int }>([
+            new Field('key', new Utf8()), new Field('value', new Int8())
+        ] as any[])))));
 
         function validateFeatureVisitor<T extends DataType>(type: T) {
             const visitor = new FeatureVisitor();
diff --git a/js/tsconfig.json b/js/tsconfig.json
index 81324ed2c9eb0..fa352302eaadc 100644
--- a/js/tsconfig.json
+++ b/js/tsconfig.json
@@ -17,5 +17,16 @@
       "apache-arrow/*": ["src/*"]
     }
   },
-  "include": ["src/**/*.ts", "test/**/*.ts", "perf/**/*.ts"]
+  "include": ["src/**/*.ts", "test/**/*.ts", "perf/**/*.ts"],
+  "ts-node": {
+    "transpileOnly": true,
+    "experimentalResolver": true,
+    "compilerOptions": {
+      "module": "CommonJS"
+    },
+    "moduleTypes": {
+      "index.ts": "cjs",
+      "src/**/*": "cjs",
+    }
+  }
 }

From 48cc2abe29fb261317d676090931b245e82f136e Mon Sep 17 00:00:00 2001
From: Timothy Meehan <tim@timdmeehan.com>
Date: Thu, 7 Sep 2023 10:14:31 -0400
Subject: [PATCH 332/749] GH-37553: [Java] Allow FlightInfo#Schema to be
 nullable for long-running queries (#37528)

With #36155, implementations of Flight RPC may not return quickly via a newly added pollFlightInfo function. Sometimes, the system implementing this function may not know the output schema for some time--for example, after a lengthy queue time as elapsed, or after planning.

In proto3, fields may not be present, and it's a coding convention to require them 1. To support upcoming client integration work for pollFlightInfo, the schema field can be made optional so that it's not a requirement to populate the FlightInfo's schema on the first pollFlightInfo request.

We can modify our client code to allow this field to be optional. This is already the case for the Go code.

This changes the Java client code to allow the Schema to be null.  A new `getSchemaOptional` method returns `Optional<Schema>`, which is a backwards compatible change.  The existing method is deprecated, but will still return an empty schema if the schema is not present on wire (as it used to before).

### Rationale for this change

With #36155, implementations of Flight RPC may not return quickly via a newly added pollFlightInfo function. Sometimes, the system implementing this function may not know the output schema for some time--for example, after a lengthy queue time as elapsed, or after planning.

In proto3, fields may not be present, and it's a coding convention to require them 1. To support upcoming client integration work for pollFlightInfo, the schema field can be made optional so that it's not a requirement to populate the FlightInfo's schema on the first pollFlightInfo request.

CC: `@ lidavidm`

### What changes are included in this PR?

This changes the Java client code to allow the Schema to be null.  `getSchema` is now deprecated and a new `getSchemaOptional` returns `Optional<Schema>`, which is a backwards compatible change.

### Are these changes tested?

Existing tests ensure serialization and deserialization continue to work.

### Are there any user-facing changes?

The `getSchema` methods are now deprecated in favor of `getSchemaOptional`.

* Closes: #37553

Authored-by: Tim Meehan <tim@timdmeehan.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../org/apache/arrow/flight/FlightInfo.java   | 57 ++++++++++++-------
 .../apache/arrow/flight/FlightProducer.java   |  7 ++-
 .../org/apache/arrow/flight/SchemaResult.java |  2 +
 .../arrow/flight/TestBasicOperation.java      | 14 +++++
 .../arrow/flight/TestFlightService.java       | 32 +++++++++++
 .../arrow/flight/TestMetadataVersion.java     |  3 +-
 .../ArrowFlightJdbcFlightStreamResultSet.java |  2 +-
 .../apache/arrow/flight/TestFlightSql.java    | 21 ++++---
 8 files changed, 107 insertions(+), 31 deletions(-)

diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
index 888c7293ea2c2..d871f89465c83 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
@@ -23,8 +23,10 @@
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.Collectors;
 
 import org.apache.arrow.flight.impl.Flight;
@@ -36,7 +38,6 @@
 import org.apache.arrow.vector.validate.MetadataV4UnionChecker;
 
 import com.fasterxml.jackson.databind.util.ByteBufferBackedInputStream;
-import com.google.common.collect.ImmutableList;
 import com.google.protobuf.ByteString;
 
 /**
@@ -93,10 +94,11 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
    */
   public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoint> endpoints, long bytes,
                     long records, boolean ordered, IpcOption option) {
-    Objects.requireNonNull(schema);
     Objects.requireNonNull(descriptor);
     Objects.requireNonNull(endpoints);
-    MetadataV4UnionChecker.checkForUnion(schema.getFields().iterator(), option.metadataVersion);
+    if (schema != null) {
+      MetadataV4UnionChecker.checkForUnion(schema.getFields().iterator(), option.metadataVersion);
+    }
     this.schema = schema;
     this.descriptor = descriptor;
     this.endpoints = endpoints;
@@ -114,8 +116,10 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
       final ByteBuffer schemaBuf = pbFlightInfo.getSchema().asReadOnlyByteBuffer();
       schema = pbFlightInfo.getSchema().size() > 0 ?
           MessageSerializer.deserializeSchema(
-              new ReadChannel(Channels.newChannel(new ByteBufferBackedInputStream(schemaBuf))))
-          : new Schema(ImmutableList.of());
+                          new ReadChannel(
+                                  Channels.newChannel(
+                                          new ByteBufferBackedInputStream(schemaBuf))))
+          : null;
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
@@ -130,8 +134,17 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
     option = IpcOption.DEFAULT;
   }
 
+  public Optional<Schema> getSchemaOptional() {
+    return Optional.ofNullable(schema);
+  }
+
+  /**
+   * Returns the schema, or an empty schema if no schema is present.
+   * @deprecated Deprecated. Use {@link #getSchemaOptional()} instead.
+   */
+  @Deprecated
   public Schema getSchema() {
-    return schema;
+    return schema != null ? schema : new Schema(Collections.emptyList());
   }
 
   public long getBytes() {
@@ -158,21 +171,25 @@ public boolean getOrdered() {
    * Converts to the protocol buffer representation.
    */
   Flight.FlightInfo toProtocol() {
-    // Encode schema in a Message payload
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    try {
-      MessageSerializer.serialize(new WriteChannel(Channels.newChannel(baos)), schema, option);
-    } catch (IOException e) {
-      throw new RuntimeException(e);
+    Flight.FlightInfo.Builder builder = Flight.FlightInfo.newBuilder()
+            .addAllEndpoint(endpoints.stream().map(t -> t.toProtocol()).collect(Collectors.toList()))
+            .setFlightDescriptor(descriptor.toProtocol())
+            .setTotalBytes(FlightInfo.this.bytes)
+            .setTotalRecords(records)
+            .setOrdered(ordered);
+    if (schema != null) {
+      ByteArrayOutputStream baos = new ByteArrayOutputStream();
+      try {
+        MessageSerializer.serialize(
+                new WriteChannel(Channels.newChannel(baos)),
+                schema,
+                option);
+        builder.setSchema(ByteString.copyFrom(baos.toByteArray()));
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
     }
-    return Flight.FlightInfo.newBuilder()
-        .addAllEndpoint(endpoints.stream().map(t -> t.toProtocol()).collect(Collectors.toList()))
-        .setSchema(ByteString.copyFrom(baos.toByteArray()))
-        .setFlightDescriptor(descriptor.toProtocol())
-        .setTotalBytes(FlightInfo.this.bytes)
-        .setTotalRecords(records)
-        .setOrdered(ordered)
-        .build();
+    return builder.build();
   }
 
   /**
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
index f2ae3db0b50d7..cdc29ae5de436 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightProducer.java
@@ -77,7 +77,12 @@ default PollInfo pollFlightInfo(CallContext context, FlightDescriptor descriptor
    */
   default SchemaResult getSchema(CallContext context, FlightDescriptor descriptor) {
     FlightInfo info = getFlightInfo(context, descriptor);
-    return new SchemaResult(info.getSchema());
+    return new SchemaResult(info
+            .getSchemaOptional()
+            .orElseThrow(() ->
+                    CallStatus
+                            .INVALID_ARGUMENT
+                            .withDescription("No schema is present in FlightInfo").toRuntimeException()));
   }
 
 
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/SchemaResult.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/SchemaResult.java
index 8a5e7d9a434dc..8becb85b8d32c 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/SchemaResult.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/SchemaResult.java
@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
+import java.util.Objects;
 
 import org.apache.arrow.flight.impl.Flight;
 import org.apache.arrow.vector.ipc.ReadChannel;
@@ -52,6 +53,7 @@ public SchemaResult(Schema schema) {
    * Create a schema result with specific IPC options for serialization.
    */
   public SchemaResult(Schema schema, IpcOption option) {
+    Objects.requireNonNull(schema);
     MetadataV4UnionChecker.checkForUnion(schema.getFields().iterator(), option.metadataVersion);
     this.schema = schema;
     this.option = option;
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
index 260ea4a0e3fed..238221f051a7e 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
@@ -27,6 +27,7 @@
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.nio.channels.Channels;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -49,8 +50,10 @@
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.VectorUnloader;
+import org.apache.arrow.vector.ipc.WriteChannel;
 import org.apache.arrow.vector.ipc.message.ArrowRecordBatch;
 import org.apache.arrow.vector.ipc.message.IpcOption;
+import org.apache.arrow.vector.ipc.message.MessageSerializer;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
@@ -556,6 +559,7 @@ public FlightInfo getFlightInfo(CallContext context,
         FlightDescriptor descriptor) {
       try {
         Flight.FlightInfo getInfo = Flight.FlightInfo.newBuilder()
+            .setSchema(schemaToByteString(new Schema(Collections.emptyList())))
             .setFlightDescriptor(Flight.FlightDescriptor.newBuilder()
                 .setType(DescriptorType.CMD)
                 .setCmd(ByteString.copyFrom("cool thing", Charsets.UTF_8)))
@@ -568,6 +572,16 @@ public FlightInfo getFlightInfo(CallContext context,
       }
     }
 
+    private static ByteString schemaToByteString(Schema schema)
+    {
+      try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+        MessageSerializer.serialize(new WriteChannel(Channels.newChannel(baos)), schema, IpcOption.DEFAULT);
+        return ByteString.copyFrom(baos.toByteArray());
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
     @Override
     public void doAction(CallContext context, Action action,
         StreamListener<Result> listener) {
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
index fb47a84164b88..691048fb03ed3 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
@@ -17,13 +17,20 @@
 
 package org.apache.arrow.flight;
 
+import static org.apache.arrow.flight.FlightTestUtil.LOCALHOST;
+import static org.apache.arrow.flight.Location.forGrpcInsecure;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import java.util.Collections;
+import java.util.Optional;
+
 import org.apache.arrow.flight.impl.Flight;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.util.AutoCloseables;
+import org.apache.arrow.vector.types.pojo.Schema;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -122,4 +129,29 @@ public void onCompleted() {
 
     // fail() would have been called if an error happened during doGetCustom(), so this test passed.
   }
+
+  @Test
+  public void supportsNullSchemas() throws Exception
+  {
+    final FlightProducer producer = new NoOpFlightProducer() {
+      @Override
+      public FlightInfo getFlightInfo(CallContext context,
+              FlightDescriptor descriptor) {
+        return new FlightInfo(null, descriptor, Collections.emptyList(), 0, 0);
+      }
+    };
+
+    try (final FlightServer s =
+            FlightServer.builder(allocator, forGrpcInsecure(LOCALHOST, 0), producer).build().start();
+            final FlightClient client = FlightClient.builder(allocator, s.getLocation()).build()) {
+      FlightInfo flightInfo = client.getInfo(FlightDescriptor.path("test"));
+      Assertions.assertEquals(Optional.empty(), flightInfo.getSchemaOptional());
+      Assertions.assertEquals(new Schema(Collections.emptyList()), flightInfo.getSchema());
+
+      Exception e = Assertions.assertThrows(
+          FlightRuntimeException.class,
+          () -> client.getSchema(FlightDescriptor.path("test")));
+      Assertions.assertEquals("No schema is present in FlightInfo", e.getMessage());
+    }
+  }
 }
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestMetadataVersion.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestMetadataVersion.java
index d6efa4ff80058..0d3f7d4ff843f 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestMetadataVersion.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestMetadataVersion.java
@@ -25,6 +25,7 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Optional;
 
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
@@ -72,7 +73,7 @@ public void testGetFlightInfoV4() throws Exception {
     try (final FlightServer server = startServer(optionV4);
          final FlightClient client = connect(server)) {
       final FlightInfo result = client.getInfo(FlightDescriptor.command(new byte[0]));
-      assertEquals(schema, result.getSchema());
+      assertEquals(Optional.of(schema), result.getSchemaOptional());
     }
   }
 
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
index 4c01cb6e5813c..9a53f9fcafdd2 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
@@ -123,7 +123,7 @@ protected AvaticaResultSet execute() throws SQLException {
     final FlightInfo flightInfo = ((ArrowFlightInfoStatement) statement).executeFlightInfoQuery();
 
     if (flightInfo != null) {
-      schema = flightInfo.getSchema();
+      schema = flightInfo.getSchemaOptional().orElse(null);
       execute(flightInfo);
     }
     return this;
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
index 4b73f3c35f477..6da915a8ffb14 100644
--- a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
@@ -39,6 +39,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.stream.IntStream;
 
 import org.apache.arrow.flight.sql.FlightSqlClient;
@@ -177,13 +178,15 @@ private static List<List<String>> getNonConformingResultsForGetSqlInfo(
   @Test
   public void testGetTablesSchema() {
     final FlightInfo info = sqlClient.getTables(null, null, null, null, true);
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA));
+    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA)));
   }
 
   @Test
   public void testGetTablesSchemaExcludeSchema() {
     final FlightInfo info = sqlClient.getTables(null, null, null, null, false);
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA));
+    MatcherAssert.assertThat(
+            info.getSchemaOptional(),
+            is(Optional.of(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA)));
   }
 
   @Test
@@ -364,7 +367,7 @@ public void testSimplePreparedStatementSchema() throws Exception {
           },
           () -> {
             final FlightInfo info = preparedStatement.execute();
-            MatcherAssert.assertThat(info.getSchema(), is(SCHEMA_INT_TABLE));
+            MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(SCHEMA_INT_TABLE)));
           }
       );
     }
@@ -477,7 +480,7 @@ public void testSimplePreparedStatementClosesProperly() {
   @Test
   public void testGetCatalogsSchema() {
     final FlightInfo info = sqlClient.getCatalogs();
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA));
+    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_CATALOGS_SCHEMA)));
   }
 
   @Test
@@ -497,7 +500,9 @@ public void testGetCatalogsResults() throws Exception {
   @Test
   public void testGetTableTypesSchema() {
     final FlightInfo info = sqlClient.getTableTypes();
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA));
+    MatcherAssert.assertThat(
+            info.getSchemaOptional(),
+            is(Optional.of(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA)));
   }
 
   @Test
@@ -526,7 +531,7 @@ public void testGetTableTypesResult() throws Exception {
   @Test
   public void testGetSchemasSchema() {
     final FlightInfo info = sqlClient.getSchemas(null, null);
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA));
+    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_SCHEMAS_SCHEMA)));
   }
 
   @Test
@@ -584,7 +589,7 @@ public void testGetPrimaryKey() {
   @Test
   public void testGetSqlInfoSchema() {
     final FlightInfo info = sqlClient.getSqlInfo();
-    MatcherAssert.assertThat(info.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA));
+    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)));
   }
 
   @Test
@@ -848,7 +853,7 @@ public void testGetCommandCrossReference() {
   @Test
   public void testCreateStatementSchema() throws Exception {
     final FlightInfo info = sqlClient.execute("SELECT * FROM intTable");
-    MatcherAssert.assertThat(info.getSchema(), is(SCHEMA_INT_TABLE));
+    MatcherAssert.assertThat(info.getSchemaOptional(), is(Optional.of(SCHEMA_INT_TABLE)));
 
     // Consume statement to close connection before cache eviction
     try (FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {

From 3b4a6b122a29c1d40623ba22e0c231c5540d84b7 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Fri, 8 Sep 2023 00:10:24 +0800
Subject: [PATCH 333/749] GH-37170: [C++] Support schema rewriting of
 RecordBatch. (#37171)

### Rationale for this change

We have a scene. There is a plan in pg that looks like the following. For the Append node, there are two scans in parallel, and then there is a column of data, but the column names are different. If it is mapped to the arrow schema It is a different field. For the append node, we will get two batches. The first batch comes from the first scan, and the second batch comes from the second scan, but because the two columns are constructed based on the scan The schema is different, so the final schema of the two batches is different. When we construct the slot returned by the Append node, we use the schema of the first batch. When we put the data of the second batch into it, the verification fails due to inconsistent shcema.

Therefore, the problem is simplified to: For a node, If there are n child nodes, the schema of the following child nodes must be consistent. If not, the schema of n-1 child nodes must be the same as the first schema, so there is logic to rewrite the schema of the batch data.

```
-> Vec Append
            -> Vec Seq Scan on public. tenk1
                  Output: tenk1.unique1
            -> Vec Seq Scan on public.tenk1 tenk1_1
                  Output: tenk1_1.fivethous
```
However, when reading the batch code, there is only the read-only interface schema(), so here we submit a pr to add and rewrite the schema interface, and only modify the columns with the same type. If they are not the same, an invalid modification will be returned.

backgroud: https://github.com/apache/arrow/issues/37170

### What changes are included in this PR?

- record_batch.h
- record_batch.cc
- record_batch_test.cc

### Are these changes tested?

yes, see record_batch_test.cc.

gtest filter is:
```
TestRecordBatch.RewriteSchema
```

### Are there any user-facing changes?

yes: see background in issue.
* Closes: #37170

Authored-by: light-city <455954986@qq.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/record_batch.cc      | 19 +++++++++++++++++
 cpp/src/arrow/record_batch.h       |  5 +++++
 cpp/src/arrow/record_batch_test.cc | 34 ++++++++++++++++++++++++++++++
 3 files changed, 58 insertions(+)

diff --git a/cpp/src/arrow/record_batch.cc b/cpp/src/arrow/record_batch.cc
index 1c5c8912e5a0b..f0ee295c6347d 100644
--- a/cpp/src/arrow/record_batch.cc
+++ b/cpp/src/arrow/record_batch.cc
@@ -283,6 +283,25 @@ bool RecordBatch::ApproxEquals(const RecordBatch& other, const EqualOptions& opt
   return true;
 }
 
+Result<std::shared_ptr<RecordBatch>> RecordBatch::ReplaceSchema(
+    std::shared_ptr<Schema> schema) const {
+  if (schema_->num_fields() != schema->num_fields())
+    return Status::Invalid("RecordBatch schema fields", schema_->num_fields(),
+                           ", did not match new schema fields: ", schema->num_fields());
+  auto fields = schema_->fields();
+  int n_fields = static_cast<int>(fields.size());
+  for (int i = 0; i < n_fields; i++) {
+    auto old_type = fields[i]->type();
+    auto replace_type = schema->field(i)->type();
+    if (!old_type->Equals(replace_type)) {
+      return Status::Invalid(
+          "RecordBatch schema field index ", i, " type is ", old_type->ToString(),
+          ", did not match new schema field type: ", replace_type->ToString());
+    }
+  }
+  return RecordBatch::Make(std::move(schema), num_rows(), columns());
+}
+
 Result<std::shared_ptr<RecordBatch>> RecordBatch::SelectColumns(
     const std::vector<int>& indices) const {
   int n = static_cast<int>(indices.size());
diff --git a/cpp/src/arrow/record_batch.h b/cpp/src/arrow/record_batch.h
index d728d5eb0da2f..cb1f6d54f7cff 100644
--- a/cpp/src/arrow/record_batch.h
+++ b/cpp/src/arrow/record_batch.h
@@ -114,6 +114,11 @@ class ARROW_EXPORT RecordBatch {
   /// \return the record batch's schema
   const std::shared_ptr<Schema>& schema() const { return schema_; }
 
+  /// \brief Replace the schema with another schema with the same types, but potentially
+  /// different field names and/or metadata.
+  Result<std::shared_ptr<RecordBatch>> ReplaceSchema(
+      std::shared_ptr<Schema> schema) const;
+
   /// \brief Retrieve all columns at once
   virtual const std::vector<std::shared_ptr<Array>>& columns() const = 0;
 
diff --git a/cpp/src/arrow/record_batch_test.cc b/cpp/src/arrow/record_batch_test.cc
index e8180c6740879..bc923a1444160 100644
--- a/cpp/src/arrow/record_batch_test.cc
+++ b/cpp/src/arrow/record_batch_test.cc
@@ -521,4 +521,38 @@ TEST_F(TestRecordBatchReader, ToTable) {
   ASSERT_EQ(table->column(0)->chunks().size(), 0);
 }
 
+TEST_F(TestRecordBatch, ReplaceSchema) {
+  const int length = 10;
+
+  auto f0 = field("f0", int32());
+  auto f1 = field("f1", uint8());
+  auto f2 = field("f2", int16());
+  auto f3 = field("f3", int8());
+
+  auto schema = ::arrow::schema({f0, f1, f2});
+
+  random::RandomArrayGenerator gen(42);
+
+  auto a0 = gen.ArrayOf(int32(), length);
+  auto a1 = gen.ArrayOf(uint8(), length);
+  auto a2 = gen.ArrayOf(int16(), length);
+
+  auto b1 = RecordBatch::Make(schema, length, {a0, a1, a2});
+
+  f0 = field("fd0", int32());
+  f1 = field("fd1", uint8());
+  f2 = field("fd2", int16());
+
+  schema = ::arrow::schema({f0, f1, f2});
+  ASSERT_OK_AND_ASSIGN(auto mutated, b1->ReplaceSchema(schema));
+  auto expected = RecordBatch::Make(schema, length, b1->columns());
+  ASSERT_TRUE(mutated->Equals(*expected));
+
+  schema = ::arrow::schema({f0, f1, f3});
+  ASSERT_RAISES(Invalid, b1->ReplaceSchema(schema));
+
+  schema = ::arrow::schema({f0, f1});
+  ASSERT_RAISES(Invalid, b1->ReplaceSchema(schema));
+}
+
 }  // namespace arrow

From 65e2f22a91db5b1aca32bb5a2481a03612a4df33 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 7 Sep 2023 13:46:23 -0400
Subject: [PATCH 334/749] GH-37597: [MATLAB] Add `toMATLAB` method to
 `arrow.array.ChunkedArray` class (#37613)

### Rationale for this change

Currently, there is no way to easily convert an `arrow.array.ChunkedArray` into a corresponding MATLAB array, other than (1) manually iterating chunk by chunk, (2) calling `toMATLAB` on each chunk, and then (3) concatenating all of the converted chunks together into one contiguous MATLAB array.

It would be helpful to add a toMATLAB method to `arrow.array.ChunkedArray` that abstracts away all of these steps.

### What changes are included in this PR?

1. Added `toMATLAB` method to `arrow.array.ChunkedArray` class
2. Added `preallocateMATLABArray` abstract method to `arrow.type.Type` class. This method is used by the `ChunkedArray` `toMATLAB` to pre-allocate a MATLAB array of the expected class type and shape. This is necessary to ensure `toMATLAB` returns the correct MATLAB array when the `ChunkedArray` has zero chunks. If `toMATLAB` stored the result of calling `toMATLAB` on each chunk in a `cell` array before concatenating the values, `toMATLAB` would return a 0x0 `double` array for zero-chunked arrays. The pre-allocation approach avoids this issue.
3. Implement `preallocateMATLABArray` on all `arrow.type.Type` classes.
4. Added an abstract class `arrow.type.NumericType` that all classes representing numeric data types inherit from. `NumericType` implements `preallocateMATLABArray` for its subclasses.

### Are these changes tested?

Yes. Added unit tests to `tChunkedArray.m`.

### Are there any user-facing changes?

Yes. Users can now call `toMATLAB` on `ChunkedArray`s.

**Example**

```matlab

>> a = arrow.array([1 2 NaN 4 5]);
>> b = arrow.array([6 7 8 9 NaN 11]);
>> c = arrow.array.ChunkedArray.fromArrays(a, b);
>> data = toMATLAB(c)

data =

     1
     2
   NaN
     4
     5
     6
     7
     8
     9
   NaN
    11

```

* Closes: #37597

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/matlab/+arrow/+array/ChunkedArray.m   |  11 +
 matlab/src/matlab/+arrow/+type/BooleanType.m  |   6 +
 matlab/src/matlab/+arrow/+type/DateType.m     |   6 +
 matlab/src/matlab/+arrow/+type/Float32Type.m  |  14 +-
 matlab/src/matlab/+arrow/+type/Float64Type.m  |  14 +-
 matlab/src/matlab/+arrow/+type/Int16Type.m    |  14 +-
 matlab/src/matlab/+arrow/+type/Int32Type.m    |  14 +-
 matlab/src/matlab/+arrow/+type/Int64Type.m    |  14 +-
 matlab/src/matlab/+arrow/+type/Int8Type.m     |  14 +-
 matlab/src/matlab/+arrow/+type/NumericType.m  |  43 ++++
 matlab/src/matlab/+arrow/+type/StringType.m   |   6 +
 matlab/src/matlab/+arrow/+type/TimeType.m     |   7 +
 .../src/matlab/+arrow/+type/TimestampType.m   |   6 +
 matlab/src/matlab/+arrow/+type/Type.m         |   4 +
 matlab/src/matlab/+arrow/+type/UInt16Type.m   |  15 +-
 matlab/src/matlab/+arrow/+type/UInt32Type.m   |  15 +-
 matlab/src/matlab/+arrow/+type/UInt64Type.m   |  14 +-
 matlab/src/matlab/+arrow/+type/UInt8Type.m    |  14 +-
 matlab/test/arrow/array/tChunkedArray.m       | 223 ++++++++++++++++++
 19 files changed, 352 insertions(+), 102 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+type/NumericType.m

diff --git a/matlab/src/matlab/+arrow/+array/ChunkedArray.m b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
index e6ee812866f62..96d7bb57a4021 100644
--- a/matlab/src/matlab/+arrow/+array/ChunkedArray.m
+++ b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
@@ -60,6 +60,17 @@
             array = traits.ArrayConstructor(proxy);
         end
 
+        function data = toMATLAB(obj)
+            data = preallocateMATLABArray(obj.Type,  obj.Length);
+            startIndex = 1;
+            for ii = 1:obj.NumChunks
+                chunk = obj.chunk(ii);
+                endIndex = startIndex + chunk.Length - 1;
+                data(startIndex:endIndex) = toMATLAB(chunk);
+                startIndex = endIndex + 1;
+            end
+        end
+
         function tf = isequal(obj, varargin)
             narginchk(2, inf);
 
diff --git a/matlab/src/matlab/+arrow/+type/BooleanType.m b/matlab/src/matlab/+arrow/+type/BooleanType.m
index 197ab515838f1..fcc5985ad2680 100644
--- a/matlab/src/matlab/+arrow/+type/BooleanType.m
+++ b/matlab/src/matlab/+arrow/+type/BooleanType.m
@@ -32,4 +32,10 @@
             groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
+
+    methods(Hidden)
+        function data = preallocateMATLABArray(~, length)
+            data = false([length 1]);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/DateType.m b/matlab/src/matlab/+arrow/+type/DateType.m
index ac6ece47ced4c..513538c8485ab 100644
--- a/matlab/src/matlab/+arrow/+type/DateType.m
+++ b/matlab/src/matlab/+arrow/+type/DateType.m
@@ -42,4 +42,10 @@
         end
     end
 
+    methods(Hidden)
+        function data = preallocateMATLABArray(~, length)
+            data = NaT([length 1]);
+        end
+    end
+
 end
diff --git a/matlab/src/matlab/+arrow/+type/Float32Type.m b/matlab/src/matlab/+arrow/+type/Float32Type.m
index 98c9f5fd79aba..14b9187ca6b32 100644
--- a/matlab/src/matlab/+arrow/+type/Float32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Float32Type.m
@@ -1,3 +1,5 @@
+%FLOAT32TYPE Type class for float32 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Float32Type < arrow.type.FixedWidthType
-%FLOAT32TYPE Type class for float32 data.
+classdef Float32Type < arrow.type.NumericType
     
     methods 
         function obj = Float32Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Float32Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Float64Type.m b/matlab/src/matlab/+arrow/+type/Float64Type.m
index 634e7d1a5cc6e..7c934b784e886 100644
--- a/matlab/src/matlab/+arrow/+type/Float64Type.m
+++ b/matlab/src/matlab/+arrow/+type/Float64Type.m
@@ -1,3 +1,5 @@
+%FLOAT64TYPE Type class for float64 data. 
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Float64Type < arrow.type.FixedWidthType
-%FLOAT64Type Type class for float64 data. 
+classdef Float64Type < arrow.type.NumericType
     
     methods 
         function obj = Float64Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Float64Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Int16Type.m b/matlab/src/matlab/+arrow/+type/Int16Type.m
index ca59f1c077826..a7343b39050fc 100644
--- a/matlab/src/matlab/+arrow/+type/Int16Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int16Type.m
@@ -1,3 +1,5 @@
+%INT16TYPE Type class for int16 data. 
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Int16Type < arrow.type.FixedWidthType
-%INT16TYPE Type class for int8 data. 
+classdef Int16Type < arrow.type.NumericType
     
     methods 
         function obj = Int16Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Int16Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/Int32Type.m b/matlab/src/matlab/+arrow/+type/Int32Type.m
index 68036d64859c1..2f1a65491582a 100644
--- a/matlab/src/matlab/+arrow/+type/Int32Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int32Type.m
@@ -1,3 +1,5 @@
+%INT32TYPE Type class for int32 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Int32Type < arrow.type.FixedWidthType
-%INT32TYPE Type class for int32 data.
+classdef Int32Type < arrow.type.NumericType
 
     methods 
         function obj = Int32Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Int32Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/Int64Type.m b/matlab/src/matlab/+arrow/+type/Int64Type.m
index d5bd7ff3a5636..52cd30ac3eb91 100644
--- a/matlab/src/matlab/+arrow/+type/Int64Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int64Type.m
@@ -1,3 +1,5 @@
+%INT64TYPE Type class for int64 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Int64Type < arrow.type.FixedWidthType
-%INT64TYPE Type class for int64 data.
+classdef Int64Type < arrow.type.NumericType
 
     methods 
         function obj = Int64Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Int64Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Int8Type.m b/matlab/src/matlab/+arrow/+type/Int8Type.m
index 5df75afe76035..bf07d0de44939 100644
--- a/matlab/src/matlab/+arrow/+type/Int8Type.m
+++ b/matlab/src/matlab/+arrow/+type/Int8Type.m
@@ -1,3 +1,5 @@
+%INT8TYPE Type class for int8 data. 
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Int8Type < arrow.type.FixedWidthType
-%INT8TYPE Type class for int8 data. 
+classdef Int8Type < arrow.type.NumericType
     
     methods 
         function obj = Int8Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.Int8Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/NumericType.m b/matlab/src/matlab/+arrow/+type/NumericType.m
new file mode 100644
index 0000000000000..b23fad7897bad
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/NumericType.m
@@ -0,0 +1,43 @@
+%NUMERICTYPE Type class for numeric data
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef NumericType < arrow.type.FixedWidthType
+
+    methods
+        function obj = NumericType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy
+            end
+
+            obj@arrow.type.FixedWidthType(proxy);
+        end
+    end
+
+    methods(Hidden)
+        function data = preallocateMATLABArray(obj, length)
+            traits = arrow.type.traits.traits(obj.ID);
+            data = zeros([length 1], traits.MatlabClassName);
+        end
+    end
+
+    methods (Access=protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = "ID";
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/StringType.m b/matlab/src/matlab/+arrow/+type/StringType.m
index 53c73b3e33e52..e85e94cf90d21 100644
--- a/matlab/src/matlab/+arrow/+type/StringType.m
+++ b/matlab/src/matlab/+arrow/+type/StringType.m
@@ -32,5 +32,11 @@
             groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
+
+    methods(Hidden)
+        function data = preallocateMATLABArray(~, length)
+            data = strings(length, 1);
+        end
+    end
 end
 
diff --git a/matlab/src/matlab/+arrow/+type/TimeType.m b/matlab/src/matlab/+arrow/+type/TimeType.m
index a0f8beb70493d..9e3e4fadbe4a1 100644
--- a/matlab/src/matlab/+arrow/+type/TimeType.m
+++ b/matlab/src/matlab/+arrow/+type/TimeType.m
@@ -42,4 +42,11 @@
         end
     end
 
+    methods(Hidden)
+        function data = preallocateMATLABArray(~, length)
+            data = NaN([length 1]);
+            data = seconds(data);
+        end
+    end
+
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/TimestampType.m b/matlab/src/matlab/+arrow/+type/TimestampType.m
index 07e61f9570790..8aa9b308eddfa 100644
--- a/matlab/src/matlab/+arrow/+type/TimestampType.m
+++ b/matlab/src/matlab/+arrow/+type/TimestampType.m
@@ -47,4 +47,10 @@
             groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
+    
+    methods(Hidden)
+        function data = preallocateMATLABArray(obj, length)
+            data = NaT([length, 1], TimeZone=obj.TimeZone);
+        end
+    end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index 8f4ce4dd6c765..24f83e0267058 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -93,6 +93,10 @@ function displayScalarHandleToDeletedObject(obj)
         end
     end
 
+    methods(Abstract, Hidden)
+        data = preallocateMATLABArray(obj, length)
+    end
+
     methods (Sealed)
         function tf = isequal(obj, varargin)
 
diff --git a/matlab/src/matlab/+arrow/+type/UInt16Type.m b/matlab/src/matlab/+arrow/+type/UInt16Type.m
index d7600c982bcab..abe40d1824ead 100644
--- a/matlab/src/matlab/+arrow/+type/UInt16Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt16Type.m
@@ -1,3 +1,5 @@
+%UINT16TYPE Type class for uint16 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef UInt16Type < arrow.type.FixedWidthType
-%UINT16TYPE Type class for uint16 data.
+classdef UInt16Type < arrow.type.NumericType
     
     methods 
         function obj = UInt16Type(proxy)
@@ -22,15 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.UInt16Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt32Type.m b/matlab/src/matlab/+arrow/+type/UInt32Type.m
index e16699cba5cab..a81c70aa43dee 100644
--- a/matlab/src/matlab/+arrow/+type/UInt32Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt32Type.m
@@ -1,3 +1,5 @@
+%UINT32TYPE Type class for uint32 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef UInt32Type < arrow.type.FixedWidthType
-%UINT32TYPE Type class for uint32 data.
+classdef UInt32Type < arrow.type.NumericType
     
     methods 
         function obj = UInt32Type(proxy)
@@ -22,15 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.UInt32Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt64Type.m b/matlab/src/matlab/+arrow/+type/UInt64Type.m
index c190f252ab4c3..488120c5faefc 100644
--- a/matlab/src/matlab/+arrow/+type/UInt64Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt64Type.m
@@ -1,3 +1,5 @@
+%UINT64TYPE Type class for uint64 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef UInt64Type < arrow.type.FixedWidthType
-%UINT64TYPE Type class for uint64 data.
+classdef UInt64Type < arrow.type.NumericType
     
     methods 
         function obj = UInt64Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.UInt64Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/UInt8Type.m b/matlab/src/matlab/+arrow/+type/UInt8Type.m
index 89715991ed519..e7a8756994225 100644
--- a/matlab/src/matlab/+arrow/+type/UInt8Type.m
+++ b/matlab/src/matlab/+arrow/+type/UInt8Type.m
@@ -1,3 +1,5 @@
+%UINT8TYPE Type class for uint8 data.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,8 +15,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef UInt8Type < arrow.type.FixedWidthType
-%UINT8TYPE Type class for uint8 data.
+classdef UInt8Type < arrow.type.NumericType
     
     methods 
         function obj = UInt8Type(proxy)
@@ -22,14 +23,7 @@
                 proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.UInt8Type")}
             end
             import arrow.internal.proxy.validate
-            obj@arrow.type.FixedWidthType(proxy);
-        end
-    end
-
-    methods (Access=protected)
-        function groups = getDisplayPropertyGroups(~)
-            targets = "ID";
-            groups = matlab.mixin.util.PropertyGroup(targets);
+            obj@arrow.type.NumericType(proxy);
         end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/tChunkedArray.m b/matlab/test/arrow/array/tChunkedArray.m
index e075d0c31aee0..3c7a52501f181 100644
--- a/matlab/test/arrow/array/tChunkedArray.m
+++ b/matlab/test/arrow/array/tChunkedArray.m
@@ -24,6 +24,21 @@
         Float64Type = arrow.float64()
     end
 
+    properties(TestParameter)
+        IntegerMatlabClass = {"uint8", ...
+                              "uint16", ...
+                              "uint32", ...
+                              "uint64", ...
+                              "int8", ...
+                              "int16", ...
+                              "int32", ...
+                              "int64"};
+
+        FloatMatlabClass = {"single", "double"}
+
+        TimeZone = {"America/New_York", ""}
+    end
+
     methods (Test)
         function FromArraysTooFewInputsError(testCase)
             % Verify an error is thrown when neither the Type nv-pair nor
@@ -240,6 +255,214 @@ function NumericIndexEmptyChunkedArrayError(testCase)
             fcn = @() chunkedArray.chunk(2);
             testCase.verifyError(fcn, "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray");
         end
+
+        function ToMATLABBooleanType(testCase)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains boolean arrays.
+            import arrow.array.ChunkedArray
+
+            bools = true([1 11]);
+            bools([2 3 7 8 9]) = false;
+            a1 = arrow.array(bools(1:8));
+            a2 = arrow.array(bools(8:7));
+            a3 = arrow.array(bools(9:11));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = bools';
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = logical.empty(0, 1);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = logical.empty(0, 1);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABIntegerTypes(testCase, IntegerMatlabClass)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains integer arrays.
+            import arrow.array.ChunkedArray
+
+            a1 = arrow.array(cast([1 2 3 4], IntegerMatlabClass));
+            a2 = arrow.array(cast([], IntegerMatlabClass));
+            a3 = arrow.array(cast([5 6 7 8 9], IntegerMatlabClass));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = cast((1:9)', IntegerMatlabClass);
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = cast(double.empty(0, 1), IntegerMatlabClass);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = cast(double.empty(0, 1), IntegerMatlabClass);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABFloatTypes(testCase, FloatMatlabClass)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains float arrays.
+            import arrow.array.ChunkedArray
+
+            a1 = arrow.array(cast([1 NaN 3 4], FloatMatlabClass));
+            a2 = arrow.array(cast([], FloatMatlabClass));
+            a3 = arrow.array(cast([5 6 7 NaN 9], FloatMatlabClass));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = cast((1:9)', FloatMatlabClass);
+            expectedArray1([2 8]) = NaN;
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = cast(double.empty(0, 1), FloatMatlabClass);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = cast(double.empty(0, 1), FloatMatlabClass);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABTimeTypes(testCase)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains time arrays.
+            import arrow.array.ChunkedArray
+
+            a1 = arrow.array(seconds([1 NaN 3 4]));
+            a2 = arrow.array(seconds([]));
+            a3 = arrow.array(seconds([5 6 7 NaN 9]));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = seconds((1:9)');
+            expectedArray1([2 8]) = NaN;
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = duration.empty(0, 1);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = duration.empty(0, 1);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABDateTypes(testCase)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains date arrays.
+            import arrow.array.*
+
+            dates = datetime(2023, 9, 7) + days(0:10);
+            dates([5 9]) = NaT;
+            a1 = Date64Array.fromMATLAB(dates(1:5));
+            a2 = Date64Array.fromMATLAB(dates(6:5));
+            a3 = Date64Array.fromMATLAB(dates(6:end));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = dates';
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = datetime.empty(0, 1);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = datetime.empty(0, 1);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABTimestampType(testCase, TimeZone)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains timestamp arrays.
+            import arrow.array.ChunkedArray
+
+            dates = datetime(2023, 9, 7, TimeZone=TimeZone) + days(0:10);
+            dates([5 9]) = NaT;
+            a1 = arrow.array(dates(1:5));
+            a2 = arrow.array(dates(6:5));
+            a3 = arrow.array(dates(6:end));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = dates';
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = datetime.empty(0, 1);
+            expectedArray2.TimeZone = TimeZone;
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = datetime.empty(0, 1);
+            expectedArray3.TimeZone = TimeZone;
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
+
+        function ToMATLABStringType(testCase)
+            % Verify toMATLAB returns the expected MATLAB array when the
+            % Chunked Array contains string arrays.
+            import arrow.array.*
+
+            strs = compose("%d", 1:11);
+            strs([5 9]) = missing;
+            a1 = arrow.array(strs(1:7));
+            a2 = arrow.array(strs(7:6));
+            a3 = arrow.array(strs(8:11));
+
+            % ChunkedArray with three chunks and nonzero length
+            chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
+            actualArray1 = toMATLAB(chunkedArray1);
+            expectedArray1 = strs';
+            testCase.verifyEqual(actualArray1, expectedArray1);
+
+            % ChunkedArray with zero chunks and zero length
+            chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
+            actualArray2 = toMATLAB(chunkedArray2);
+            expectedArray2 = string.empty(0, 1);
+            testCase.verifyEqual(actualArray2, expectedArray2);
+
+            % ChunkedArray with two chunks and zero length
+            chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
+            actualArray3 = toMATLAB(chunkedArray3);
+            expectedArray3 = string.empty(0, 1);
+            testCase.verifyEqual(actualArray3, expectedArray3);
+        end
     end
 
     methods

From 5a781693d953da8784edaf971f6124528398b4a2 Mon Sep 17 00:00:00 2001
From: Jacek Stania <38670505+janosik47@users.noreply.github.com>
Date: Thu, 7 Sep 2023 20:03:32 +0100
Subject: [PATCH 335/749] GH-37056: [Java] Fix importing an empty data array
 from c-data (#37531)

### Rationale for this change

Fix java lib bug that prevents from importing specific data via c-data interface.
Currently an attempt to load a vector with empty data buffer results in an IllegalStateException error.

### What changes are included in this PR?
Updated BufferImportTypeVisitor to correctly handle a situation when underlying c-data array pointer is NULL (0) and the expected length of data is zero (0).

### Are these changes tested?
Yes, updated the existing unit tests

### Are there any user-facing changes?
No

* Closes: #37056

Lead-authored-by: Jacek Stania <janosik47@gmail.com>
Co-authored-by: Jacek Stania <38670505+janosik47@users.noreply.github.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../arrow/c/BufferImportTypeVisitor.java      | 43 +++++++++----------
 .../apache/arrow/c/ArrowArrayUtilityTest.java | 30 ++++++++++---
 .../org/apache/arrow/c/RoundtripTest.java     |  8 ++++
 java/c/src/test/python/integration_tests.py   | 27 +++++++++++-
 4 files changed, 79 insertions(+), 29 deletions(-)

diff --git a/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java b/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
index c8b6d07086268..7408bf71136fa 100644
--- a/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
+++ b/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
@@ -80,45 +80,44 @@ public void close() throws Exception {
   }
 
   @VisibleForTesting
-  long getBufferPtr(ArrowType type, int index) {
+  ArrowBuf importBuffer(ArrowType type, int index, long capacity) {
     checkState(
-        buffers.length > index,
-        "Expected at least %s buffers for type %s, but found %s", index + 1, type, buffers.length);
-    if (buffers[index] == NULL) {
-      throw new IllegalStateException(String.format("Buffer %s for type %s cannot be null", index, type));
+            buffers.length > index,
+            "Expected at least %s buffers for type %s, but found %s", index + 1, type, buffers.length);
+    long bufferPtr = buffers[index];
+
+    if (bufferPtr == NULL) {
+      // C array may be NULL but only accept that if expected capacity is zero too
+      if (capacity != 0) {
+        throw new IllegalStateException(String.format("Buffer %s for type %s cannot be null", index, type));
+      } else {
+        // no data in the C array, return an empty buffer
+        return allocator.getEmpty();
+      }
     }
-    return buffers[index];
+
+    ArrowBuf buf = underlyingAllocation.unsafeAssociateAllocation(allocator, capacity, bufferPtr);
+    imported.add(buf);
+    return buf;
   }
 
   private ArrowBuf importFixedBits(ArrowType type, int index, long bitsPerSlot) {
-    final long bufferPtr = getBufferPtr(type, index);
     final long capacity = DataSizeRoundingUtil.divideBy8Ceil(bitsPerSlot * fieldNode.getLength());
-    ArrowBuf buf = underlyingAllocation.unsafeAssociateAllocation(allocator, capacity, bufferPtr);
-    this.imported.add(buf);
-    return buf;
+    return importBuffer(type, index, capacity);
   }
 
   private ArrowBuf importFixedBytes(ArrowType type, int index, long bytesPerSlot) {
-    final long bufferPtr = getBufferPtr(type, index);
     final long capacity = bytesPerSlot * fieldNode.getLength();
-    ArrowBuf buf = underlyingAllocation.unsafeAssociateAllocation(allocator, capacity, bufferPtr);
-    this.imported.add(buf);
-    return buf;
+    return importBuffer(type, index, capacity);
   }
 
   private ArrowBuf importOffsets(ArrowType type, long bytesPerSlot) {
-    final long bufferPtr = getBufferPtr(type, 1);
     final long capacity = bytesPerSlot * (fieldNode.getLength() + 1);
-    ArrowBuf buf = underlyingAllocation.unsafeAssociateAllocation(allocator, capacity, bufferPtr);
-    this.imported.add(buf);
-    return buf;
+    return importBuffer(type, 1, capacity);
   }
 
   private ArrowBuf importData(ArrowType type, long capacity) {
-    final long bufferPtr = getBufferPtr(type, 2);
-    ArrowBuf buf = underlyingAllocation.unsafeAssociateAllocation(allocator, capacity, bufferPtr);
-    this.imported.add(buf);
-    return buf;
+    return importBuffer(type, 2, capacity);
   }
 
   private ArrowBuf maybeImportBitmap(ArrowType type) {
diff --git a/java/c/src/test/java/org/apache/arrow/c/ArrowArrayUtilityTest.java b/java/c/src/test/java/org/apache/arrow/c/ArrowArrayUtilityTest.java
index 2d31089ca70eb..4a0a966ba1f1f 100644
--- a/java/c/src/test/java/org/apache/arrow/c/ArrowArrayUtilityTest.java
+++ b/java/c/src/test/java/org/apache/arrow/c/ArrowArrayUtilityTest.java
@@ -56,19 +56,39 @@ void afterEach() {
   // BufferImportTypeVisitor
 
   @Test
-  void getBufferPtr() throws Exception {
+  void importBuffer() throws Exception {
     // Note values are all dummy values here
-    try (BufferImportTypeVisitor visitor =
-        new BufferImportTypeVisitor(allocator, dummyHandle, new ArrowFieldNode(0, 0), new long[]{0})) {
+    try (BufferImportTypeVisitor notEmptyDataVisitor =
+        new BufferImportTypeVisitor(allocator, dummyHandle, new ArrowFieldNode(/* length= */ 1, 0), new long[]{0})) {
 
       // Too few buffers
-      assertThrows(IllegalStateException.class, () -> visitor.getBufferPtr(new ArrowType.Bool(), 1));
+      assertThrows(IllegalStateException.class, () -> notEmptyDataVisitor.importBuffer(new ArrowType.Bool(), 1, 1));
 
       // Null where one isn't expected
-      assertThrows(IllegalStateException.class, () -> visitor.getBufferPtr(new ArrowType.Bool(), 0));
+      assertThrows(IllegalStateException.class, () -> notEmptyDataVisitor.importBuffer(new ArrowType.Bool(), 0, 1));
+
+      // Expected capacity not zero but c array ptr is NULL (zero)
+      assertThrows(IllegalStateException.class, () -> notEmptyDataVisitor.importBuffer(new ArrowType.Bool(), 0, 1));
+
+      // Expected capacity is zero and c array ptr is NULL (zero)
+      assertThat(notEmptyDataVisitor.importBuffer(new ArrowType.Bool(), 0, 0)).isEqualTo(allocator.getEmpty());
+    }
+
+    try (BufferImportTypeVisitor emptyDataVisitor =
+        new BufferImportTypeVisitor(allocator, dummyHandle, new ArrowFieldNode(/* length= */ 0, 0), new long[]{0})) {
+
+      // Too few buffers
+      assertThrows(IllegalStateException.class, () -> emptyDataVisitor.importBuffer(new ArrowType.Bool(), 1, 1));
+
+      // Expected capacity not zero but c array ptr is NULL (zero)
+      assertThrows(IllegalStateException.class, () -> emptyDataVisitor.importBuffer(new ArrowType.Bool(), 0, 1));
+
+      // Expected capacity is zero and c array ptr is NULL (zero)
+      assertThat(emptyDataVisitor.importBuffer(new ArrowType.Bool(), 0, 0)).isEqualTo(allocator.getEmpty());
     }
   }
 
+
   @Test
   void cleanupAfterFailure() throws Exception {
     // Note values are all dummy values here
diff --git a/java/c/src/test/java/org/apache/arrow/c/RoundtripTest.java b/java/c/src/test/java/org/apache/arrow/c/RoundtripTest.java
index fc73df449bd2c..c1ceb93cb40c0 100644
--- a/java/c/src/test/java/org/apache/arrow/c/RoundtripTest.java
+++ b/java/c/src/test/java/org/apache/arrow/c/RoundtripTest.java
@@ -534,6 +534,14 @@ public void testListVector() {
     }
   }
 
+  @Test
+  public void testEmptyListVector() {
+    try (final ListVector vector = ListVector.empty("v", allocator)) {
+      setVector(vector, new ArrayList<Integer>());
+      assertTrue(roundtrip(vector, ListVector.class));
+    }
+  }
+
   @Test
   public void testLargeListVector() {
     try (final LargeListVector vector = LargeListVector.empty("v", allocator)) {
diff --git a/java/c/src/test/python/integration_tests.py b/java/c/src/test/python/integration_tests.py
index c23b4b9b4416e..eb8bb8c4b22df 100644
--- a/java/c/src/test/python/integration_tests.py
+++ b/java/c/src/test/python/integration_tests.py
@@ -24,6 +24,7 @@
 
 import jpype
 import pyarrow as pa
+import pyarrow.ipc as ipc
 from pyarrow.cffi import ffi
 
 
@@ -119,6 +120,10 @@ def close(self):
 
 
 class TestPythonIntegration(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        setup_jvm()
+
     def setUp(self):
         gc.collect()
         self.old_allocated_python = pa.total_allocated_bytes()
@@ -195,7 +200,26 @@ def test_list_array(self):
             # disabled check_metadata since the list internal field name ("item")
             # is not preserved during round trips (it becomes "$data$").
         ), check_metadata=False)
-        
+
+    def test_empty_list_array(self):
+        """Validates GH-37056 fix.
+        Empty list of int32 produces a vector with empty child data buffer, however with non-zero capacity.
+        Using streaming forces the c-data array which represent the child data buffer to be NULL (pointer is 0).
+        On Java side, an attempt to import such array triggered an exception described in GH-37056.
+        """
+        with pa.BufferOutputStream() as bos:
+            schema = pa.schema([pa.field("f0", pa.list_(pa.int32()), True)])
+            with ipc.new_stream(bos, schema) as writer:
+                src = pa.RecordBatch.from_arrays([pa.array([[]])], schema=schema)
+                writer.write(src)
+        data_bytes = bos.getvalue()
+
+        def recreate_batch():
+            with pa.input_stream(data_bytes) as ios:
+                with ipc.open_stream(ios) as reader:
+                    return reader.read_next_batch()
+
+        self.round_trip_record_batch(recreate_batch)
 
     def test_struct_array(self):
         fields = [
@@ -274,5 +298,4 @@ def test_reader_complex_roundtrip(self):
 
 
 if __name__ == '__main__':
-    setup_jvm()
     unittest.main(verbosity=2)

From 3aa7e249c35e81fdd38874697ae2f1239fbc7938 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 7 Sep 2023 16:39:51 -0400
Subject: [PATCH 336/749] GH-37569: [MATLAB] Implement `isequal` for the
 `arrow.type.Field` MATLAB class (#37617)

### Rationale for this change

Following on to https://github.com/apache/arrow/pull/37474, https://github.com/apache/arrow/pull/37446, and https://github.com/apache/arrow/pull/37525, we should implement `isequal` for the `arrow.type.Field` MATLAB class.

### What changes are included in this PR?

1. Implemented the `isequal` method for `arrow.type.Field`

### Are these changes tested?

Yes. Add new unit tests to `tField.m`

### Are there any user-facing changes?

Yes. Users can now call `isequal` on `arrow.type.Field`s to determine if two fields are equal.

**Example**
```matlab
>> f1 = arrow.field("A", arrow.time32(TimeUnit="Second"));
>> f2 = arrow.field("B", arrow.time32(TimeUnit="Second"));
>> f3 = arrow.field("A", arrow.time32(TimeUnit="Millisecond"));

>> isequal(f1, f1)

ans =

  logical

   1

% Name properties differ
>> isequal(f1, f2)

ans =

  logical

   0

% Type properties differ
>> isequal(f1, f3)

ans =

  logical

   0
```

### Future Directions

1. #37568
2. #37570

* Closes: #37569

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+type/Field.m |  45 ++++++++++-
 matlab/test/arrow/type/tField.m        | 103 +++++++++++++++++++++++++
 2 files changed, 145 insertions(+), 3 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+type/Field.m b/matlab/src/matlab/+arrow/+type/Field.m
index fb0b579e20bb9..f67ba69fe9826 100644
--- a/matlab/src/matlab/+arrow/+type/Field.m
+++ b/matlab/src/matlab/+arrow/+type/Field.m
@@ -1,3 +1,7 @@
+%FIELD A class representing a name and a type.
+% Fields are often used in tabular schemas for describing a column's
+% name and type.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -14,9 +18,6 @@
 % permissions and limitations under the License.
 
 classdef Field < matlab.mixin.CustomDisplay
-%FIELD A class representing a name and a type.
-% Fields are often used in tabular schemas for describing a column's
-% name and type.
 
     properties (GetAccess=public, SetAccess=private, Hidden)
         Proxy
@@ -50,6 +51,44 @@
             name = obj.Proxy.getName();
         end
 
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+            tf = false;
+
+            namesToCompare = strings(numel(obj), numel(varargin));
+            typesToCompare = cell([1 numel(varargin)]);
+
+            for ii = 1:numel(varargin)
+                field = varargin{ii};
+                if ~isa(field, "arrow.type.Field") || ~isequal(size(obj), size(field))
+                    % Return early if field is not an arrow.type.Field
+                    % or if the dimensions of obj and field do not match.
+                    return;
+                end
+
+                namesToCompare(:, ii) = [field(:).Name];
+                typesToCompare{1, ii} = [field(:).Type];
+            end
+
+            if isempty(obj)
+                % At this point, since we have already confirmed all the 
+                % Fields have the same dimensions, if one of the Fields are
+                % empty, then they must all be empty. This means they must
+                % all be equal.
+                tf = true;
+            else
+                names = [obj(:).Name]';
+                if any(names ~= namesToCompare, "all")
+                    % Return false early if the field names are not equal.
+                    return;
+                end
+    
+                % Field names were equal. Check if their corresponding types
+                % are equal and return the result.
+                types = [obj(:).Type];
+                tf = isequal(types, typesToCompare{:});
+            end
+        end
     end
 
     methods (Access = private)
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
index 77a05bbe39513..dba7190b49ce2 100644
--- a/matlab/test/arrow/type/tField.m
+++ b/matlab/test/arrow/type/tField.m
@@ -127,5 +127,108 @@ function TestImmutableProperties(testCase)
             testCase.verifyError(@() setfield(field, "Type", arrow.boolean), "MATLAB:class:noSetMethod")
         end
 
+        function TestIsEqualScalarTrue(testCase)
+            % Two scalar arrow.type.Field objects are equal if:
+            %
+            %  1. Their Name properties are equal
+            %  2. Their Type properties are equal
+
+            f1 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            f2 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            testCase.verifyTrue(isequal(f1, f2));
+        end
+
+        function TestIsEqualScalarFalse(testCase)
+            % Verifies isequal returns false when expected. 
+            f1 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            f2 = arrow.field("B", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            f3 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Millisecond"));
+            f4 = arrow.field("A", arrow.time32());
+
+            % Name properties are not equal
+            testCase.verifyFalse(isequal(f1, f2));
+
+            % Type properties are not equal
+            testCase.verifyFalse(isequal(f1, f3));
+
+            % Type properties have different class types
+            testCase.verifyFalse(isequal(f1, f4));
+
+            % Compare arrow.type.Field and a string
+            testCase.verifyFalse(isequal(f1, "A"));
+        end
+
+        function TestIsEqualNonScalarTrue(testCase)
+            % Two nonscalar arrow.type.Field arrays are equal if:
+            %  1. They have the same shape
+            %  2. Their corresponding Field elements are equal
+            
+            f1 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            f2 = arrow.field("B", arrow.string());
+            fieldArray1 = [f1 f2 f1; f2 f1 f1];
+            fieldArray2 = [f1 f2 f1; f2 f1 f1];
+
+            testCase.verifyTrue(isequal(fieldArray1, fieldArray2));
+            testCase.verifyTrue(isequal(fieldArray1, fieldArray2, fieldArray1));
+        end
+
+        function TestIsEqualEmptyFields(testCase)
+            % Verify isequal returns the expected value when at least one
+            % of the inputs is empty.
+            
+            f1 = arrow.type.Field.empty(1, 0);
+            f2 = arrow.type.Field.empty(0, 1);
+            f3 = arrow.type.Field.empty(0, 0);
+            f4 = arrow.field("B", arrow.string());
+
+            % Compare two 1x0 Field arrays
+            testCase.verifyTrue(isequal(f1, f1));
+            
+            % Compare two 0x1 Field arrays
+            testCase.verifyTrue(isequal(f2, f2));
+
+            % Compare two 0x0 Field arrays
+            testCase.verifyTrue(isequal(f3, f3));
+
+            % Compare 1x0 and 0x1 Field arrays
+            testCase.verifyFalse(isequal(f1, f2));
+
+            % Compare 1x0 and 0x0 Field arrays
+            testCase.verifyFalse(isequal(f1, f3));
+
+            % Compare 0x1 and 0x0 Field arrays
+            testCase.verifyFalse(isequal(f2, f3));
+
+            % Compare 1x0 and 1x1 Field arrays
+            testCase.verifyFalse(isequal(f1, f4));
+        end
+
+        function TestIsEqualNonScalarFalse(testCase)
+            % Verifies isequal returns false when expected for non-scalar
+            % Field arrays.
+            
+            f1 = arrow.field("A", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+            f2 = arrow.field("B", arrow.string());
+            f3 = arrow.field("B", arrow.date32());
+            f4 = arrow.field("C", arrow.timestamp(TimeZone="America/New_York", TimeUnit="Second"));
+
+            fieldArray1 = [f1 f2 f3; f4 f1 f2];
+            fieldArray2 = reshape(fieldArray1, [3 2]);
+            fieldArray3 = [f1 f3 f3; f4 f1 f2];
+            fieldArray4 = [f4 f2 f3; f4 f1 f2];
+            
+            % They have different shapes
+            testCase.verifyFalse(isequal(fieldArray1, fieldArray2));
+            testCase.verifyFalse(isequal(fieldArray1, fieldArray2, fieldArray1));
+
+            % Their corresponding elements are not equal - type mismatch
+            testCase.verifyFalse(isequal(fieldArray1, fieldArray3));
+
+            % Their corresponding elements are not equal - name mismatch
+            testCase.verifyFalse(isequal(fieldArray1, fieldArray4));
+
+            % Compare arrow.type.Field array and a string array
+            testCase.verifyFalse(isequal(f1, strings(size(f1))));
+        end
     end
 end

From cdc95c276a2ac268dcf9dfbeaed43225efb7d13b Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 7 Sep 2023 17:06:55 -0400
Subject: [PATCH 337/749] GH-37568: [MATLAB] Implement `isequal` for the
 `arrow.tabular.Schema` MATLAB class (#37619)

### Rationale for this change

Following on to https://github.com/apache/arrow/pull/37474, https://github.com/apache/arrow/pull/37446, and https://github.com/apache/arrow/pull/37525, we should implement `isequal` for the `arrow.tabular.Schema` MATLAB class.

### What changes are included in this PR?

1. Updated `arrow.tabular.Schema` class to inherit from `matlab.mixin.Scalar`.
2. Added `isequal` method to `arrow.tabular.Schema`.

### Are these changes tested?

Yes. Added `isequal` unit tests to `tSchema.m`

### Are there any user-facing changes?

Yes. Users can now compare two `arrow.tabular.Schema` objects via `isequal`.

**Example**
```matlab
>> schema1 = arrow.schema([arrow.field("A", arrow.uint8), arrow.field("B", arrow.uint16)]);
>> schema2 = arrow.schema([arrow.field("A", arrow.uint8), arrow.field("B", arrow.uint16)]);
>> schema3 = arrow.schema([arrow.field("A", arrow.uint8)]);

>> isequal(schema1, schema2)

ans =

  logical

   1

>> isequal(schema1, schema3)

ans =

  logical

   0
```

### Future Directions
1. #37570

* Closes: #37568

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+tabular/Schema.m | 31 +++++++++--
 matlab/test/arrow/tabular/tSchema.m        | 61 ++++++++++++++++++++++
 2 files changed, 87 insertions(+), 5 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index 4b4a3d57821b1..f679b1e0bc22c 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -1,3 +1,7 @@
+%SCHEMA A tabular schema which semantically describes
+% the names and types of the columns of an associated tabular
+% Arrow data type.
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -13,10 +17,8 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Schema < matlab.mixin.CustomDisplay
-%SCHEMA A tabular schema which semantically describes
-% the names and types of the columns of an associated tabular
-% Arrow data type.
+classdef Schema < matlab.mixin.CustomDisplay & ...
+                  matlab.mixin.Scalar
 
     properties (GetAccess=public, SetAccess=private, Hidden)
         Proxy
@@ -73,7 +75,26 @@
         function numFields = get.NumFields(obj)
             numFields = obj.Proxy.getNumFields();
         end
-        
+
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+            tf = false;
+            
+            fieldsToCompare = cell([1 numel(varargin)]);
+            for ii = 1:numel(varargin)
+                schema = varargin{ii};
+                if ~isa(schema, "arrow.tabular.Schema")
+                    % Return false early if schema is not actually an
+                    % arrow.tabular.Schema instance.
+                    return;
+                end
+
+                fieldsToCompare{ii} = schema.Fields;
+            end
+
+            % Return if the Schema Fields properties are equal
+            tf = isequal(obj.Fields, fieldsToCompare{:});
+        end
     end
 
     methods (Access = private)
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index b57ebffbc577e..3220236d4aabe 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -468,6 +468,67 @@ function ErrorIfFieldNameIsNonScalar(testCase)
             testCase.verifyError(@() schema.field(fieldName), "arrow:badsubscript:NonScalar");
         end
 
+        function TestIsEqualTrue(testCase)
+            % Schema objects are considered equal if:
+            %  1. They have the same number of fields
+            %  2. Their corresponding Fields properties are equal
+
+            schema1 = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+            schema2 = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+
+            % Create a Schema with zero fields
+            schema3 = arrow.recordBatch(table).Schema;
+            schema4 = arrow.recordBatch(table).Schema;
+            
+            testCase.verifyTrue(isequal(schema1, schema2));
+            testCase.verifyTrue(isequal(schema3, schema4));
+        end
+
+        function TestIsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+
+            schema1 = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+                arrow.field("123", arrow.uint32)
+            ]);
+            schema2 = arrow.schema([...
+                arrow.field("A", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+            ]);
+            schema3 = arrow.schema([...
+                arrow.field("A", arrow.float32), ...
+                arrow.field("B", arrow.uint16), ...
+            ]);
+            schema4 = arrow.schema([...
+                arrow.field("C", arrow.uint8), ...
+                arrow.field("B", arrow.uint16), ...
+            ]);
+
+            % Create a Schema with zero fields
+            schema5 = arrow.recordBatch(table).Schema;
+            
+            % Have different number of fields
+            testCase.verifyFalse(isequal(schema1, schema2));
+
+            % Fields properties are not equal
+            testCase.verifyFalse(isequal(schema2, schema3));
+            testCase.verifyFalse(isequal(schema2, schema4));
+            testCase.verifyFalse(isequal(schema4, schema5));
+
+            % Compare schema to double
+            testCase.verifyFalse(isequal(schema4, 5));
+
+        end
+
     end
 
 end

From da602af5e9a04b7aad63a2f6bb001b45201cb2ef Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Thu, 7 Sep 2023 17:10:16 -0400
Subject: [PATCH 338/749] GH-37571: [MATLAB] Add `arrow.tabular.Table` MATLAB
 class (#37620)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Following on from #37525, which adds `arrow.array.ChunkedArray` to the MATLAB interface, this pull request adds support for a new `arrow.tabular.Table` MATLAB class.

This pull request is intended to be an initial implementation of `Table` support and does not include all methods or properties that may be useful on `arrow.tabular.Table`.

### What changes are included in this PR?

1. Added new `arrow.tabular.Table` MATLAB class.

**Properties**

* `NumRows`
* `NumColumns`
* `ColumnNames`
* `Schema`

**Methods**

* `fromArrays(<array-1>, ..., <array-N>)`
* `column(<index>)`
* `table()`
* `toMATLAB()`

**Example of `arrow.tabular.Table.fromArrays(<array_1>, ..., <array-N>)` static construction method**
```matlab
>> arrowTable = arrow.tabular.Table.fromArrays(arrow.array([1, 2, 3]), arrow.array(["A", "B", "C"]), arrow.array([true, false, true]))

arrowTable =

Column1: double
Column2: string
Column3: bool
----
Column1:
  [
    [
      1,
      2,
      3
    ]
  ]
Column2:
  [
    [
      "A",
      "B",
      "C"
    ]
  ]
Column3:
  [
    [
      true,
      false,
      true
    ]
  ]

>> matlabTable = table(arrowTable)

matlabTable =

  3×3 table

    Column1    Column2    Column3
    _______    _______    _______

       1         "A"       true
       2         "B"       false
       3         "C"       true
```

2. Added a new `arrow.table(<matlab-table>)` construction function which creates an `arrow.tabular.Table` from a MATLAB `table`.

**Example of `arrow.table(<matlab-table>)` construction function**
```matlab
>> matlabTable = table([1; 2; 3], ["A"; "B"; "C"], [true; false; true])

matlabTable =

  3×3 table

    Var1    Var2    Var3
    ____    ____    _____

     1      "A"     true
     2      "B"     false
     3      "C"     true

>> arrowTable = arrow.table(matlabTable)

arrowTable =

Var1: double
Var2: string
Var3: bool
----
Var1:
  [
    [
      1,
      2,
      3
    ]
  ]
Var2:
  [
    [
      "A",
      "B",
      "C"
    ]
  ]
Var3:
  [
    [
      true,
      false,
      true
    ]
  ]

>> arrowTable.NumRows

ans =

  int64

   3

>> arrowTable.NumColumns

ans =

  int32

   3

>> arrowTable.ColumnNames

ans =

  1×3 string array

    "Var1"    "Var2"    "Var3"

>> arrowTable.Schema

ans =

Var1: double
Var2: string
Var3: bool

>> table(arrowTable)

ans =

  3×3 table

    Var1    Var2    Var3
    ____    ____    _____

     1      "A"     true
     2      "B"     false
     3      "C"     true

>> isequal(ans, matlabTable)

ans =

  logical

   1
```

### Are these changes tested?

Yes.

1. Added a new `tTable` test class for `arrow.tabular.Table` and `arrow.table(<matlab-table>)` tests.

### Are there any user-facing changes?

Yes.

1. Users can now create `arrow.tabular.Table` objects using the `fromArrays` static construction method or the `arrow.table(<matlab-table>)` construction function.

### Future Directions

1. Create shared test infrastructure for common `RecordBatch` and `Table` MATLAB tests.
2. Implement equality check (i.e. `isequal`) for `arrow.tabular.Table` instances.
4. Add more static construction methods to `arrow.tabular.Table`. For example: `fromChunkedArrays(<chunkedArray-1>, ..., <chunkedArray-N>)` and `fromRecordBatches(<recordBatch-1>, ..., <recordBatch-N>)`.

### Notes

1. A lot of the code for `arrow.tabular.Table` is very similar to the code for `arrow.tabular.RecordBatch`. It may make sense for us to try to share more of the code using C++ templates or another approach.
2. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37571

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |   2 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../cpp/arrow/matlab/tabular/proxy/table.cc   | 215 ++++++
 .../cpp/arrow/matlab/tabular/proxy/table.h    |  48 ++
 matlab/src/matlab/+arrow/+tabular/Table.m     | 145 ++++
 matlab/src/matlab/+arrow/table.m              |  33 +
 matlab/test/arrow/tabular/tTable.m            | 622 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 8 files changed, 1068 insertions(+)
 create mode 100644 matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
 create mode 100644 matlab/src/matlab/+arrow/+tabular/Table.m
 create mode 100644 matlab/src/matlab/+arrow/table.m
 create mode 100644 matlab/test/arrow/tabular/tTable.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 4b64849bcef4d..2b3009d51eb5a 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -181,6 +181,8 @@ namespace arrow::matlab::error {
     static const char* UNKNOWN_PROXY_FOR_ARRAY_TYPE = "arrow:array:UnknownProxyForArrayType";
     static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
     static const char* RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:recordbatch:InvalidNumericColumnIndex";
+    static const char* TABLE_NUMERIC_INDEX_WITH_EMPTY_TABLE = "arrow:tabular:table:NumericIndexWithEmptyTable";
+    static const char* TABLE_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:table:InvalidNumericColumnIndex";
     static const char* FAILED_TO_OPEN_FILE_FOR_WRITE = "arrow:io:FailedToOpenFileForWrite";
     static const char* FAILED_TO_OPEN_FILE_FOR_READ = "arrow:io:FailedToOpenFileForRead";
     static const char* FEATHER_FAILED_TO_WRITE_TABLE = "arrow:io:feather:FailedToWriteTable";
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 593e8ffbb6f01..4035725f2b382 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -23,6 +23,7 @@
 #include "arrow/matlab/array/proxy/time64_array.h"
 #include "arrow/matlab/array/proxy/chunked_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
+#include "arrow/matlab/tabular/proxy/table.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/type/proxy/primitive_ctype.h"
@@ -60,6 +61,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.Date64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date64Type>);
     REGISTER_PROXY(arrow.array.proxy.ChunkedArray  , arrow::matlab::array::proxy::ChunkedArray);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
+    REGISTER_PROXY(arrow.tabular.proxy.Table       , arrow::matlab::tabular::proxy::Table);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
     REGISTER_PROXY(arrow.type.proxy.Field          , arrow::matlab::type::proxy::Field);
     REGISTER_PROXY(arrow.type.proxy.Float32Type    , arrow::matlab::type::proxy::PrimitiveCType<float>);
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
new file mode 100644
index 0000000000000..228e28dad9e9c
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
@@ -0,0 +1,215 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+#include "arrow/matlab/array/proxy/array.h"
+#include "arrow/matlab/array/proxy/chunked_array.h"
+#include "arrow/matlab/array/proxy/wrap.h"
+
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/tabular/proxy/table.h"
+#include "arrow/matlab/tabular/proxy/schema.h"
+#include "arrow/type.h"
+#include "arrow/util/utf8.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+#include "libmexclass/error/Error.h"
+
+namespace arrow::matlab::tabular::proxy {
+
+    namespace {
+        libmexclass::error::Error makeEmptyTableError() {
+            const std::string error_msg =  "Numeric indexing using the column method is not supported for tables with no columns.";
+            return libmexclass::error::Error{error::TABLE_NUMERIC_INDEX_WITH_EMPTY_TABLE, error_msg};
+        }
+
+        libmexclass::error::Error makeInvalidNumericIndexError(const int32_t matlab_index, const int32_t num_columns) {
+            std::stringstream error_message_stream;
+            error_message_stream << "Invalid column index: ";
+            error_message_stream << matlab_index;
+            error_message_stream << ". Column index must be between 1 and the number of columns (";
+            error_message_stream << num_columns;
+            error_message_stream << ").";
+            return libmexclass::error::Error{error::TABLE_INVALID_NUMERIC_COLUMN_INDEX, error_message_stream.str()};
+        }
+    }
+
+    Table::Table(std::shared_ptr<arrow::Table> table) : table{table} {
+        REGISTER_METHOD(Table, toString);
+        REGISTER_METHOD(Table, getNumRows);
+        REGISTER_METHOD(Table, getNumColumns);
+        REGISTER_METHOD(Table, getColumnNames);
+        REGISTER_METHOD(Table, getSchema);
+        REGISTER_METHOD(Table, getColumnByIndex);
+        REGISTER_METHOD(Table, getColumnByName);
+    }
+
+    std::shared_ptr<arrow::Table> Table::unwrap() {
+        return table;
+    }
+
+    void Table::toString(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto utf16_string, arrow::util::UTF8StringToUTF16(table->ToString()), context, error::UNICODE_CONVERSION_ERROR_ID);
+        mda::ArrayFactory factory;
+        auto str_mda = factory.createScalar(utf16_string);
+        context.outputs[0] = str_mda;
+    }
+
+    libmexclass::proxy::MakeResult Table::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        using ArrayProxy = arrow::matlab::array::proxy::Array;
+        using TableProxy = arrow::matlab::tabular::proxy::Table;
+        namespace mda = ::matlab::data;
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> arrow_array_proxy_ids = opts[0]["ArrayProxyIDs"];
+        const mda::StringArray column_names = opts[0]["ColumnNames"];
+
+        std::vector<std::shared_ptr<arrow::Array>> arrow_arrays;
+        // Retrieve all of the Arrow Array Proxy instances from the libmexclass ProxyManager.
+        for (const auto& arrow_array_proxy_id : arrow_array_proxy_ids) {
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(arrow_array_proxy_id);
+            auto arrow_array_proxy = std::static_pointer_cast<ArrayProxy>(proxy);
+            auto arrow_array = arrow_array_proxy->unwrap();
+            arrow_arrays.push_back(arrow_array);
+        }
+
+        std::vector<std::shared_ptr<Field>> fields;
+        for (size_t i = 0; i < arrow_arrays.size(); ++i) {
+            const auto type = arrow_arrays[i]->type();
+            const auto column_name_utf16 = std::u16string(column_names[i]);
+            MATLAB_ASSIGN_OR_ERROR(const auto column_name_utf8, arrow::util::UTF16StringToUTF8(column_name_utf16), error::UNICODE_CONVERSION_ERROR_ID);
+            fields.push_back(std::make_shared<arrow::Field>(column_name_utf8, type));
+        }
+
+        arrow::SchemaBuilder schema_builder;
+        MATLAB_ERROR_IF_NOT_OK(schema_builder.AddFields(fields), error::SCHEMA_BUILDER_ADD_FIELDS_ERROR_ID);
+        MATLAB_ASSIGN_OR_ERROR(const auto schema, schema_builder.Finish(), error::SCHEMA_BUILDER_FINISH_ERROR_ID);
+        const auto num_rows = arrow_arrays.size() == 0 ? 0 : arrow_arrays[0]->length();
+        const auto table = arrow::Table::Make(schema, arrow_arrays, num_rows);
+        auto table_proxy = std::make_shared<TableProxy>(table);
+
+        return table_proxy;
+    }
+
+    void Table::getNumRows(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        const auto num_rows = table->num_rows();
+        auto num_rows_mda = factory.createScalar(num_rows);
+        context.outputs[0] = num_rows_mda;
+    }
+
+    void Table::getNumColumns(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        const auto num_columns = table->num_columns();
+        auto num_columns_mda = factory.createScalar(num_columns);
+        context.outputs[0] = num_columns_mda;
+    }
+
+    void Table::getColumnNames(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        const int num_columns = table->num_columns();
+
+        std::vector<mda::MATLABString> column_names;
+        const auto schema = table->schema();
+        const auto field_names = schema->field_names();
+        for (int i = 0; i < num_columns; ++i) {
+            const auto column_name_utf8 = field_names[i];
+            MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto column_name_utf16, arrow::util::UTF8StringToUTF16(column_name_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
+            const mda::MATLABString matlab_string = mda::MATLABString(std::move(column_name_utf16));
+            column_names.push_back(matlab_string);
+        }
+        auto column_names_mda = factory.createArray({size_t{1}, static_cast<size_t>(num_columns)}, column_names.begin(), column_names.end());
+        context.outputs[0] = column_names_mda;
+    }
+
+    void Table::getSchema(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using SchemaProxy = arrow::matlab::tabular::proxy::Schema;
+        mda::ArrayFactory factory;
+
+        const auto schema = table->schema();
+        const auto schema_proxy = std::make_shared<SchemaProxy>(std::move(schema));
+        const auto schema_proxy_id = ProxyManager::manageProxy(schema_proxy);
+        const auto schema_proxy_id_mda = factory.createScalar(schema_proxy_id);
+
+        context.outputs[0] = schema_proxy_id_mda;
+    }
+
+    void Table::getColumnByIndex(libmexclass::proxy::method::Context& context) {
+        using ChunkedArrayProxy = arrow::matlab::array::proxy::ChunkedArray;
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::Schema::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
+        const auto num_columns = table->num_columns();
+
+        if (num_columns == 0) {
+            context.error = makeEmptyTableError();
+            return;
+        }
+
+        if (matlab_index < 1 || matlab_index > num_columns) {
+            context.error = makeInvalidNumericIndexError(matlab_index, num_columns);
+            return;
+        }
+
+        const auto chunked_array = table->column(index);
+        const auto chunked_array_proxy = std::make_shared<ChunkedArrayProxy>(chunked_array);
+
+        const auto chunked_array_proxy_id = ProxyManager::manageProxy(chunked_array_proxy);
+        const auto chunked_array_proxy_id_mda = factory.createScalar(chunked_array_proxy_id);
+
+        context.outputs[0] = chunked_array_proxy_id_mda;
+    }
+
+    void Table::getColumnByName(libmexclass::proxy::method::Context& context) {
+        using ChunkedArrayProxy = arrow::matlab::array::proxy::ChunkedArray;
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::StringArray name_mda = args[0]["Name"];
+        const auto name_utf16 = std::u16string(name_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto name, arrow::util::UTF16StringToUTF8(name_utf16), context, error::UNICODE_CONVERSION_ERROR_ID);
+
+        const std::vector<std::string> names = {name};
+        const auto& schema = table->schema();
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(schema->CanReferenceFieldsByNames(names), context, error::ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME);
+
+        const auto chunked_array = table->GetColumnByName(name);
+        const auto chunked_array_proxy = std::make_shared<ChunkedArrayProxy>(chunked_array);
+
+        const auto chunked_array_proxy_id = ProxyManager::manageProxy(chunked_array_proxy);
+        const auto chunked_array_proxy_id_mda = factory.createScalar(chunked_array_proxy_id);
+
+        context.outputs[0] = chunked_array_proxy_id_mda;
+    }
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
new file mode 100644
index 0000000000000..dae86a180b7a6
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
@@ -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.
+
+#pragma once
+
+#include "arrow/table.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::tabular::proxy {
+
+    class Table : public libmexclass::proxy::Proxy {
+        public:
+            Table(std::shared_ptr<arrow::Table> table);
+
+            virtual ~Table() {}
+
+            std::shared_ptr<arrow::Table> unwrap();
+
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+        protected:
+            void toString(libmexclass::proxy::method::Context& context);
+            void getNumRows(libmexclass::proxy::method::Context& context);
+            void getNumColumns(libmexclass::proxy::method::Context& context);
+            void getColumnNames(libmexclass::proxy::method::Context& context);
+            void getSchema(libmexclass::proxy::method::Context& context);
+            void getColumnByIndex(libmexclass::proxy::method::Context& context);
+            void getColumnByName(libmexclass::proxy::method::Context& context);
+
+            std::shared_ptr<arrow::Table> table;
+    };
+
+}
diff --git a/matlab/src/matlab/+arrow/+tabular/Table.m b/matlab/src/matlab/+arrow/+tabular/Table.m
new file mode 100644
index 0000000000000..d9eb4d8409733
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/Table.m
@@ -0,0 +1,145 @@
+%TABLE A tabular data structure representing a set of
+% arrow.array.ChunkedArray objects with a fixed schema.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Table < matlab.mixin.CustomDisplay & matlab.mixin.Scalar
+
+    properties (Dependent, SetAccess=private, GetAccess=public)
+        NumRows
+        NumColumns
+        ColumnNames
+        Schema
+    end
+
+    properties (Hidden, SetAccess=private, GetAccess=public)
+        Proxy
+    end
+
+    methods
+
+        function obj = Table(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.tabular.proxy.Table")}
+            end
+            import arrow.internal.proxy.validate
+            obj.Proxy = proxy;
+        end
+
+        function numColumns = get.NumColumns(obj)
+            numColumns = obj.Proxy.getNumColumns();
+        end
+
+        function numRows = get.NumRows(obj)
+            numRows = obj.Proxy.getNumRows();
+        end
+
+        function columnNames = get.ColumnNames(obj)
+            columnNames = obj.Proxy.getColumnNames();
+        end
+
+        function schema = get.Schema(obj)
+            proxyID = obj.Proxy.getSchema();
+            proxy = libmexclass.proxy.Proxy(Name="arrow.tabular.proxy.Schema", ID=proxyID);
+            schema = arrow.tabular.Schema(proxy);
+        end
+
+        function chunkedArray = column(obj, idx)
+            import arrow.internal.validate.*
+
+            idx = index.numericOrString(idx, "int32", AllowNonScalar=false);
+
+            if isnumeric(idx)
+                args = struct(Index=idx);
+                proxyID = obj.Proxy.getColumnByIndex(args);
+            else
+                args = struct(Name=idx);
+                proxyID = obj.Proxy.getColumnByName(args);
+            end
+
+            proxy = libmexclass.proxy.Proxy(Name="arrow.array.proxy.ChunkedArray", ID=proxyID);
+            chunkedArray = arrow.array.ChunkedArray(proxy);
+        end
+
+        function T = table(obj)
+            import arrow.tabular.internal.*
+
+            numColumns = obj.NumColumns;
+            matlabArrays = cell(1, numColumns);
+
+            for ii = 1:numColumns
+                chunkedArray = obj.column(ii);
+                matlabArrays{ii} = toMATLAB(chunkedArray);
+            end
+
+            validVariableNames = makeValidVariableNames(obj.ColumnNames);
+            validDimensionNames = makeValidDimensionNames(validVariableNames);
+
+            T = table(matlabArrays{:}, ...
+                VariableNames=validVariableNames, ...
+                DimensionNames=validDimensionNames);
+        end
+
+        function T = toMATLAB(obj)
+            T = obj.table();
+        end
+
+    end
+
+    methods (Access = private)
+
+        function str = toString(obj)
+            str = obj.Proxy.toString();
+        end
+
+    end
+
+    methods (Access=protected)
+
+        function displayScalarObject(obj)
+            disp(obj.toString());
+        end
+
+    end
+
+    methods (Static, Access=public)
+
+        function arrowTable = fromArrays(arrowArrays, opts)
+            arguments(Repeating)
+                arrowArrays(1, 1) arrow.array.Array
+            end
+            arguments
+                opts.ColumnNames(1, :) string {mustBeNonmissing} = compose("Column%d", 1:numel(arrowArrays))
+            end
+
+            import arrow.tabular.internal.validateArrayLengths
+            import arrow.tabular.internal.validateColumnNames
+            import arrow.array.internal.getArrayProxyIDs
+
+            numColumns = numel(arrowArrays);
+            validateArrayLengths(arrowArrays);
+            validateColumnNames(opts.ColumnNames, numColumns);
+
+            arrayProxyIDs = getArrayProxyIDs(arrowArrays);
+            args = struct(ArrayProxyIDs=arrayProxyIDs, ColumnNames=opts.ColumnNames);
+            proxyName = "arrow.tabular.proxy.Table";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            arrowTable = arrow.tabular.Table(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/table.m b/matlab/src/matlab/+arrow/table.m
new file mode 100644
index 0000000000000..1f54481433b3b
--- /dev/null
+++ b/matlab/src/matlab/+arrow/table.m
@@ -0,0 +1,33 @@
+%TABLE Creates an arrow.tabular.Table from a MATLAB table.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function arrowTable = table(matlabTable)
+    arguments
+        % Use istable instead of the table type specifier here to avoid
+        % ambiguous name parsing issue with MATLAB table type and arrow.table.
+        matlabTable {istable} = table.empty(0, 0)
+    end
+
+    arrowArrays = arrow.tabular.internal.decompose(matlabTable);
+    arrayProxyIDs = arrow.array.internal.getArrayProxyIDs(arrowArrays);
+
+    columnNames = string(matlabTable.Properties.VariableNames);
+    args = struct(ArrayProxyIDs=arrayProxyIDs, ColumnNames=columnNames);
+    proxyName = "arrow.tabular.proxy.Table";
+    proxy = arrow.internal.proxy.create(proxyName, args);
+
+    arrowTable = arrow.tabular.Table(proxy);
+end
diff --git a/matlab/test/arrow/tabular/tTable.m b/matlab/test/arrow/tabular/tTable.m
new file mode 100644
index 0000000000000..8c6b9aae73752
--- /dev/null
+++ b/matlab/test/arrow/tabular/tTable.m
@@ -0,0 +1,622 @@
+% Tests for the arrow.tabular.Table class and the associated arrow.table
+% construction function.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTable < matlab.unittest.TestCase
+
+    methods(Test)
+
+        function Basic(testCase)
+            % Verify that an arrow.tabular.Table can be created
+            % from a MATLAB table using the arrow.table construction
+            % function.
+            matlabTable = table(...
+                [1, 2, 3]', ...
+                ["A", "B", "C"]', ...
+                [true, false, true]' ...
+            );
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyInstanceOf(arrowTable, "arrow.tabular.Table");
+        end
+
+        function SupportedTypes(testCase)
+            % Verify that a MATLAB table containing all types
+            % supported for conversion to Arrow Arrays can be round-tripped
+            % from an arrow.tabular.Table to a MATLAB table and back.
+            import arrow.internal.test.tabular.createTableWithSupportedTypes
+            import arrow.type.traits.traits
+
+            matlabTable = createTableWithSupportedTypes();
+            arrowTable = arrow.table(matlabTable);
+            expectedColumnNames = string(matlabTable.Properties.VariableNames);
+
+            % For each variable in the input MATLAB table, look up the
+            % corresponding Arrow Type of the corresponding ChunkedArray using type traits.
+            expectedChunkedArrayTypes = varfun(@(var) traits(string(class(var))).TypeClassName, ...
+                matlabTable, OutputFormat="uniform");
+            testCase.verifyTable(arrowTable, expectedColumnNames, expectedChunkedArrayTypes, matlabTable);
+        end
+
+        function ToMATLAB(testCase)
+            % Verify that the toMATLAB method converts
+            % an arrow.tabular.Table to a MATLAB table as expected.
+            expectedMatlabTable = table([1, 2, 3]');
+            arrowTable = arrow.table(expectedMatlabTable);
+            actualMatlabTable = arrowTable.toMATLAB();
+            testCase.verifyEqual(actualMatlabTable, expectedMatlabTable);
+        end
+
+        function Table(testCase)
+            % Verify that the toMATLAB method converts
+            % an arrow.tabular.Table to a MATLAB table as expected.
+            TOriginal = table([1, 2, 3]');
+            arrowRecordBatch = arrow.recordBatch(TOriginal);
+            TConverted = table(arrowRecordBatch);
+            testCase.verifyEqual(TOriginal, TConverted);
+        end
+
+        function NumRows(testCase)
+            % Verify that the NumRows property of arrow.tabular.Table
+            % returns the expected number of rows.
+            numRows = int64([1, 5, 100]);
+
+            for expectedNumRows = numRows
+                matlabTable = array2table(ones(expectedNumRows, 1));
+                arrowTable = arrow.table(matlabTable);
+                testCase.verifyEqual(arrowTable.NumRows, expectedNumRows);
+            end
+
+        end
+
+        function NumColumns(testCase)
+            % Verify that the NumColumns property of arrow.tabular.Table
+            % returns the expected number of columns.
+            numColumns = int32([1, 5, 100]);
+
+            for expectedNumColumns = numColumns
+                matlabTable = array2table(ones(1, expectedNumColumns));
+                arrowTable = arrow.table(matlabTable);
+                testCase.verifyEqual(arrowTable.NumColumns, expectedNumColumns);
+            end
+
+        end
+
+        function ColumnNames(testCase)
+            % Verify that the ColumnNames property of arrow.tabular.Table
+            % returns the expected string array of column names.
+            columnNames = ["A", "B", "C"];
+            matlabTable = table(1, 2, 3, VariableNames=columnNames);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyEqual(arrowTable.ColumnNames, columnNames);
+        end
+
+        function UnicodeColumnNames(testCase)
+            % Verify that an arrow.tabular.Table can be created from
+            % a MATLAB table with Unicode VariableNames.
+            smiley = "😀";
+            tree =  "🌲";
+            mango = "🥭";
+            columnNames = [smiley, tree, mango];
+            matlabTable = table(1, 2, 3, VariableNames=columnNames);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyEqual(arrowTable.ColumnNames, columnNames);
+        end
+
+        function EmptyTable(testCase)
+            % Verify that an arrow.tabular.Table can be created from an
+            % empty MATLAB table.
+            matlabTable = table.empty(0, 0);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyEqual(arrowTable.NumRows, int64(0));
+            testCase.verifyEqual(arrowTable.NumColumns, int32(0));
+            testCase.verifyEqual(arrowTable.ColumnNames, string.empty(1, 0));
+            testCase.verifyEqual(toMATLAB(arrowTable), matlabTable);
+
+            matlabTable = table.empty(1, 0);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyEqual(arrowTable.NumRows, int64(0));
+            testCase.verifyEqual(arrowTable.NumColumns, int32(0));
+            testCase.verifyEqual(arrowTable.ColumnNames, string.empty(1, 0));
+
+            matlabTable = table.empty(0, 1);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyEqual(arrowTable.NumRows, int64(0));
+            testCase.verifyEqual(arrowTable.NumColumns, int32(1));
+            testCase.verifyEqual(arrowTable.ColumnNames, "Var1");
+        end
+
+        function EmptyTableColumnIndexError(tc)
+            % Verify that an "arrow:tabular:table:NumericIndexWithEmptyTable" error
+            % is thrown when calling the column method on an empty Table.
+            matlabTable = table();
+            arrowTable = arrow.table(matlabTable);
+            fcn = @() arrowTable.column(1);
+            tc.verifyError(fcn, "arrow:tabular:table:NumericIndexWithEmptyTable");
+        end
+
+        function InvalidNumericIndexError(tc)
+            % Verify that an "arrow:tabular:table:InvalidNumericColumnIndex" error
+            % is thrown when providing an index to the column
+            % method that is outside the range of valid column indices
+            % (e.g. greater than the number of columns).
+            matlabTable = table(1, 2, 3);
+            arrowTable = arrow.table(matlabTable);
+            fcn = @() arrowTable.column(4);
+            tc.verifyError(fcn, "arrow:tabular:table:InvalidNumericColumnIndex");
+        end
+
+        function UnsupportedColumnIndexType(tc)
+            % Verify that an "arrow:badsubscript:UnsupportedIndexType" error
+            % is thrown when providing an index to the column
+            % method that is not a positive scalar integer.
+            matlabTable = table(1, 2, 3);
+            arrowTable = arrow.table(matlabTable);
+            fcn = @() arrowTable.column(datetime(2022, 1, 3));
+            tc.verifyError(fcn, "arrow:badsubscript:UnsupportedIndexType");
+        end
+
+        function ErrorIfIndexIsNonScalar(tc)
+            % Verify that an "arrow:badsubscript:NonScalar" error
+            % is thrown when providing a non-scalar index to the column
+            % method.
+            matlabtable = table(1, 2, 3);
+            arrowTable = arrow.table(matlabtable);
+            fcn = @() arrowTable.column([1 2]);
+            tc.verifyError(fcn, "arrow:badsubscript:NonScalar");
+        end
+
+        function ErrorIfIndexIsNonPositive(tc)
+            % Verify that an "arrow:badsubscript:NonPositive" error
+            % is thrown when providing a non-positive index to the column
+            % method.
+            matlabTable = table(1, 2, 3);
+            arrowTable = arrow.table(matlabTable);
+            fcn = @() arrowTable.column(-1);
+            tc.verifyError(fcn, "arrow:badsubscript:NonPositive");
+        end
+
+        function GetColumnByName(testCase)
+            % Verify that columns can be accessed by name.
+            matlabArray1 = [1; 2; 3];
+            matlabArray2 = ["A"; "B"; "C"];
+            matlabArray3 = [true; false; true];
+
+            arrowArray1 = arrow.array(matlabArray1);
+            arrowArray2 = arrow.array(matlabArray2);
+            arrowArray3 = arrow.array(matlabArray3);
+
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrowArray1, ...
+                arrowArray2, ...
+                arrowArray3, ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            column = arrowTable.column("A");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.float64();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray1, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            column = arrowTable.column("B");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.string();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray2, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            column = arrowTable.column("C");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.boolean();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray3, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+        end
+
+        function GetColumnByNameWithEmptyString(testCase)
+            % Verify that a column whose name is the empty string ("")
+            % can be accessed using the column() method.
+            matlabArray1 = [1; 2; 3];
+            matlabArray2 = ["A"; "B"; "C"];
+            matlabArray3 = [true; false; true];
+
+            arrowArray1 = arrow.array(matlabArray1);
+            arrowArray2 = arrow.array(matlabArray2);
+            arrowArray3 = arrow.array(matlabArray3);
+
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrowArray1, ...
+                arrowArray2, ...
+                arrowArray3, ...
+                ColumnNames=["A", "", "C"] ...
+            );
+
+            column = arrowTable.column("");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.string();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray2, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+        end
+
+        function GetColumnByNameWithWhitespace(testCase)
+            % Verify that a column whose name contains only whitespace
+            % characters can be accessed using the column() method.
+            matlabArray1 = [1; 2; 3];
+            matlabArray2 = ["A"; "B"; "C"];
+            matlabArray3 = [true; false; true];
+
+            arrowArray1 = arrow.array(matlabArray1);
+            arrowArray2 = arrow.array(matlabArray2);
+            arrowArray3 = arrow.array(matlabArray3);
+
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrowArray1, ...
+                arrowArray2, ...
+                arrowArray3, ...
+                ColumnNames=[" ", "  ", "   "] ...
+            );
+
+            column = arrowTable.column(" ");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.float64();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray1, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            column = arrowTable.column("  ");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.string();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray2, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            column = arrowTable.column("   ");
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.boolean();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray3, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+        end
+
+        function ErrorIfColumnNameDoesNotExist(testCase)
+            % Verify that an error is thrown when trying to access a column
+            % with a name that is not part of the Schema of the Table.
+            matlabArray1 = [1; 2; 3];
+            matlabArray2 = ["A"; "B"; "C"];
+            matlabArray3 = [true; false; true];
+
+            arrowArray1 = arrow.array(matlabArray1);
+            arrowArray2 = arrow.array(matlabArray2);
+            arrowArray3 = arrow.array(matlabArray3);
+
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrowArray1, ...
+                arrowArray2, ...
+                arrowArray3, ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            % Matching should be case sensitive.
+            name = "a";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "aA";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "D";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = " ";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function ErrorIfAmbiguousColumnName(testCase)
+            % Verify that an error is thrown when trying to access a column
+            % with a name that is ambiguous / occurs more than once in the
+            % Schema of the Table.
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                arrow.array([days(1), days(2), days(3)]), ...
+                ColumnNames=["A", "A", "B", "B"] ...
+            );
+
+            name = "A";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+
+            name = "B";
+            testCase.verifyError(@() arrowTable.column(name), "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function GetColumnByNameWithChar(testCase)
+            % Verify that the column method works when supplied a char
+            % vector as input.
+            matlabArray1 = [1; 2; 3];
+            matlabArray2 = ["A"; "B"; "C"];
+            matlabArray3 = [true; false; true];
+
+            arrowArray1 = arrow.array(matlabArray1);
+            arrowArray2 = arrow.array(matlabArray2);
+            arrowArray3 = arrow.array(matlabArray3);
+
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrowArray1, ...
+                arrowArray2, ...
+                arrowArray3, ...
+                ColumnNames=["", "B", "123"] ...
+            );
+
+            % Should match the first column whose name is the
+            % empty string ("").
+            name = char.empty(0, 0);
+            column = arrowTable.column(name);
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.float64();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray1, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            name = char.empty(0, 1);
+            column = arrowTable.column(name);
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.float64();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray1, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            name = char.empty(1, 0);
+            column = arrowTable.column(name);
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.float64();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray1, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            % Should match the second column whose name is "B".
+            name = 'B';
+            column = arrowTable.column(name);
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.string();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray2, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+
+            % Should match the third column whose name is "123".
+            name = '123';
+            column = arrowTable.column(name);
+            expectedNumChunks = int32(1);
+            expectedLength = int64(3);
+            expectedArrowType = arrow.boolean();
+            testCase.verifyChunkedArray(column, ...
+                                        matlabArray3, ...
+                                        expectedNumChunks, ...
+                                        expectedLength, ...
+                                        expectedArrowType);
+        end
+
+        function ErrorIfColumnNameIsNonScalar(testCase)
+            % Verify that an error is thrown if a nonscalar string array is
+            % specified as a column name to the column method.
+            arrowTable = arrow.tabular.Table.fromArrays(...
+                arrow.array([1, 2, 3]), ...
+                arrow.array(["A", "B", "C"]), ...
+                arrow.array([true, false, true]), ...
+                ColumnNames=["A", "B", "C"] ...
+            );
+
+            name = ["A", "B", "C"];
+            testCase.verifyError(@() arrowTable.column(name), "arrow:badsubscript:NonScalar");
+
+            name = ["A";  "B"; "C"];
+            testCase.verifyError(@() arrowTable.column(name), "arrow:badsubscript:NonScalar");
+        end
+
+        function FromArraysWithNoColumnNames(testCase)
+            % Verify arrow.tabular.Table.fromArrays creates the expected
+            % Table when given a comma-separated list of arrow.array.Array values.
+            import arrow.tabular.Table
+            import arrow.internal.test.tabular.createAllSupportedArrayTypes
+
+            [arrowArrays, matlabData] = createAllSupportedArrayTypes();
+            matlabTable = table(matlabData{:});
+
+            arrowTable = Table.fromArrays(arrowArrays{:});
+            expectedColumnNames = compose("Column%d", 1:width(matlabTable));
+            testCase.verifyEqual(arrowTable.ColumnNames, expectedColumnNames)
+        end
+
+        function FromArraysWithColumnNames(testCase)
+            % Verify arrow.tabular.Table.fromArrays creates the expected
+            % Table when given a comma-separated list of arrow.array.Array values
+            % and when the ColumnNames nv-pair is provided.
+            import arrow.tabular.Table
+            import arrow.internal.test.tabular.createAllSupportedArrayTypes
+
+            [arrowArrays, ~] = createAllSupportedArrayTypes();
+
+            expectedColumnNames = compose("MyVar%d", 1:numel(arrowArrays));
+            arrowTable = Table.fromArrays(arrowArrays{:}, ColumnNames=expectedColumnNames);
+            testCase.verifyEqual(arrowTable.ColumnNames, expectedColumnNames)
+        end
+
+        function FromArraysUnequalArrayLengthsError(testCase)
+            % Verify arrow.tabular.Table.fromArrays throws an error whose
+            % identifier is "arrow:tabular:UnequalArrayLengths" if the arrays
+            % provided don't all have the same length.
+            import arrow.tabular.Table
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B", "C"]);
+            fcn = @() Table.fromArrays(A1, A2);
+            testCase.verifyError(fcn, "arrow:tabular:UnequalArrayLengths");
+        end
+
+        function FromArraysWrongNumberColumnNamesError(testCase)
+            % Verify arrow.tabular.Table.fromArrays throws an error whose
+            % identifier is "arrow:tabular:WrongNumberColumnNames" if the
+            % ColumnNames provided doesn't have one element per array.
+            import arrow.tabular.Table
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B"]);
+            fcn = @() Table.fromArrays(A1, A2, ColumnNames=["A", "B", "C"]);
+            testCase.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+        end
+
+        function FromArraysColumnNamesHasMissingString(testCase)
+            % Verify arrow.tabular.Table.fromArrays throws an error whose
+            % identifier is "MATLAB:validators:mustBeNonmissing" if the
+            % ColumnNames provided has a missing string value.
+            import arrow.tabular.Table
+
+            A1 = arrow.array([1, 2]);
+            A2 = arrow.array(["A", "B"]);
+            fcn = @() Table.fromArrays(A1, A2, ColumnNames=["A", missing]);
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
+        end
+
+        function FromArraysNoInputs(testCase)
+            % Verify that an empty Table is returned when calling fromArrays
+            % with no input arguments.
+            arrowTable = arrow.tabular.Table.fromArrays();
+            testCase.verifyEqual(arrowTable.NumRows, int64(0));
+            testCase.verifyEqual(arrowTable.NumColumns, int32(0));
+            testCase.verifyEqual(arrowTable.ColumnNames, string.empty(1, 0));
+        end
+
+        function ConstructionFunctionNoInputs(testCase)
+            % Verify that an empty Table is returned when calling
+            % the arrow.table construction function with no inputs.
+            arrowTable = arrow.table();
+            testCase.verifyEqual(arrowTable.NumRows, int64(0));
+            testCase.verifyEqual(arrowTable.NumColumns, int32(0));
+            testCase.verifyEqual(arrowTable.ColumnNames, string.empty(1, 0));
+        end
+
+        function Schema(testCase)
+            % Verify that the public Schema property returns an approprate
+            % instance of arrow.tabular.Table.
+            matlabTable = table(...
+                ["A"; "B"; "C"], ...
+                [1; 2; 3], ...
+                [true; false; true], ...
+                VariableNames=["A", "B", "C"] ...
+            );
+            arrowTable = arrow.table(matlabTable);
+            schema = arrowTable.Schema;
+            testCase.verifyEqual(schema.NumFields, int32(3));
+            testCase.verifyEqual(schema.field(1).Type.ID, arrow.type.ID.String);
+            testCase.verifyEqual(schema.field(1).Name, "A");
+            testCase.verifyEqual(schema.field(2).Type.ID, arrow.type.ID.Float64);
+            testCase.verifyEqual(schema.field(2).Name, "B");
+            testCase.verifyEqual(schema.field(3).Type.ID, arrow.type.ID.Boolean);
+            testCase.verifyEqual(schema.field(3).Name, "C");
+        end
+
+        function NoColumnsNoSetter(testCase)
+            % Verify that trying to set the value of the public NumColumns property
+            % results in an error of type "MATLAB:class:SetProhibited".
+            matlabTable = table([1; 2; 3]);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyError(@() setfield(arrowTable, "NumColumns", int32(100)), ...
+                "MATLAB:class:SetProhibited");
+        end
+
+        function SchemaNoSetter(testCase)
+            % Verify that trying to set the value of the public Schema property
+            % results in an error of type "MATLAB:class:SetProhibited".
+            matlabTable = table([1; 2; 3]);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyError(@() setfield(arrowTable, "Schema", "Value"), ...
+                "MATLAB:class:SetProhibited");
+        end
+
+        function ColumnNamesNoSetter(testCase)
+            % Verify that trying to set the value of the public ColumnNames property
+            % results in an error of type "MATLAB:class:SetProhibited".
+            matlabTable = table([1; 2; 3]);
+            arrowTable = arrow.table(matlabTable);
+            testCase.verifyError(@() setfield(arrowTable, "ColumnNames", "Value"), ...
+                "MATLAB:class:SetProhibited");
+        end
+
+    end
+
+    methods
+
+        function verifyTable(testCase, arrowTable, expectedColumnNames, expectedArrayClasses, expectedMatlabTable)
+            testCase.verifyEqual(arrowTable.NumColumns, int32(width(expectedMatlabTable)));
+            testCase.verifyEqual(arrowTable.ColumnNames, expectedColumnNames);
+            matlabTable = table(arrowTable);
+            testCase.verifyEqual(matlabTable, expectedMatlabTable);
+            for ii = 1:arrowTable.NumColumns
+                column = arrowTable.column(ii);
+                testCase.verifyEqual(column.toMATLAB(), expectedMatlabTable{:, ii});
+                testCase.verifyInstanceOf(column.Type, expectedArrayClasses(ii));
+            end
+        end
+
+        function verifyChunkedArray(testCase, chunkedArray, expectedMatlabData, expectedNumChunks, expectedLength, expectedArrowType)
+            testCase.verifyInstanceOf(chunkedArray, "arrow.array.ChunkedArray");
+            testCase.verifyEqual(toMATLAB(chunkedArray), expectedMatlabData);
+            testCase.verifyEqual(chunkedArray.NumChunks, expectedNumChunks)
+            testCase.verifyEqual(chunkedArray.Length, expectedLength);
+            testCase.verifyEqual(chunkedArray.Type, expectedArrowType);
+        end
+
+    end
+
+end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 2d95682bc2081..a5c0b079b34a6 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -50,6 +50,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/chunked_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/table.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/schema.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/pack.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/bit/unpack.cc"

From a6c12bc28258c2ac26fae036bd9a9e06c4ab6242 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 8 Sep 2023 01:43:11 +0100
Subject: [PATCH 339/749] GH-37614: [R][CI] Update CI jobs due to duckdb repo
 moving (#37615)

### Rationale for this change

Duckdb have moved the R package to a separate repo

### What changes are included in this PR?

Updates the duckdb R package dev repo

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37614

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 ci/scripts/r_deps.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/scripts/r_deps.sh b/ci/scripts/r_deps.sh
index 50b3043978716..2b432f768c2b4 100755
--- a/ci/scripts/r_deps.sh
+++ b/ci/scripts/r_deps.sh
@@ -47,7 +47,7 @@ ${R_BIN} -e "options(warn=2); install.packages('remotes'); remotes::install_cran
 
 # Install DuckDB from github when requested
 if [ ${R_DUCKDB_DEV} == "true" ]; then
-  ${R_BIN} -e "remotes::install_github('duckdb/duckdb', subdir = '/tools/rpkg', build = FALSE)"
+  ${R_BIN} -e "remotes::install_github('duckdb/duckdb-r', build = FALSE)"
 fi
 
 # Separately install the optional/test dependencies but don't error on them,

From a8a604cfc5bc8d05ca3b1ef1388e6efd8ba6e5cd Mon Sep 17 00:00:00 2001
From: DenisTarasyuk <131180287+DenisTarasyuk@users.noreply.github.com>
Date: Fri, 8 Sep 2023 06:47:43 +0300
Subject: [PATCH 340/749] GH-37608: [C++][Gandiva] TO_DATE function supports
 YYYY-MM and YYYY (#37609)

Added fix for case when pattern does not contain day part

### Rationale for this change

TO_DATE Gandiva function returns wrong result if used with pattern 'YYYY-MM' or 'YYYY'.

### What changes are included in this PR?

Add a fix for case when tm_mday is zero to set it to 1

### Are these changes tested?

Added tests that cover described cases

### Are there any user-facing changes?

No

* Closes: #37608

Authored-by: DenisTarasyuk <131180287+DenisTarasyuk@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/value_parsing.h     |  2 +-
 cpp/src/gandiva/to_date_holder_test.cc | 29 ++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/util/value_parsing.h b/cpp/src/arrow/util/value_parsing.h
index 5193f0af750c6..d4bbf206659ba 100644
--- a/cpp/src/arrow/util/value_parsing.h
+++ b/cpp/src/arrow/util/value_parsing.h
@@ -801,7 +801,7 @@ static inline bool ParseTimestampStrptime(const char* buf, size_t length,
   // ignore the time part
   arrow_vendored::date::sys_seconds secs =
       arrow_vendored::date::sys_days(arrow_vendored::date::year(result.tm_year + 1900) /
-                                     (result.tm_mon + 1) / result.tm_mday);
+                                     (result.tm_mon + 1) / std::max(result.tm_mday, 1));
   if (!ignore_time_in_day) {
     secs += (std::chrono::hours(result.tm_hour) + std::chrono::minutes(result.tm_min) +
              std::chrono::seconds(result.tm_sec));
diff --git a/cpp/src/gandiva/to_date_holder_test.cc b/cpp/src/gandiva/to_date_holder_test.cc
index a420774bfcea9..99036817d8e65 100644
--- a/cpp/src/gandiva/to_date_holder_test.cc
+++ b/cpp/src/gandiva/to_date_holder_test.cc
@@ -149,4 +149,33 @@ TEST_F(TestToDateHolder, TestSimpleDateTimeMakeError) {
   EXPECT_EQ(status.IsInvalid(), true) << status.message();
 }
 
+TEST_F(TestToDateHolder, TestSimpleDateYearMonth) {
+  std::shared_ptr<ToDateHolder> to_date_holder;
+  ASSERT_OK(ToDateHolder::Make("YYYY-MM", 1, &to_date_holder));
+
+  auto& to_date = *to_date_holder;
+  bool out_valid;
+  std::string s("2012-12");
+  int64_t millis_since_epoch =
+      to_date(&execution_context_, s.data(), (int)s.length(), true, &out_valid);
+  EXPECT_EQ(millis_since_epoch, 1354320000000);
+
+  s = std::string("2012-01");
+  millis_since_epoch =
+      to_date(&execution_context_, s.data(), (int)s.length(), true, &out_valid);
+  EXPECT_EQ(millis_since_epoch, 1325376000000);
+}
+
+TEST_F(TestToDateHolder, TestSimpleDateYear) {
+  std::shared_ptr<ToDateHolder> to_date_holder;
+  ASSERT_OK(ToDateHolder::Make("YYYY", 1, &to_date_holder));
+
+  auto& to_date = *to_date_holder;
+  bool out_valid;
+  std::string s("1999");
+  int64_t millis_since_epoch =
+      to_date(&execution_context_, s.data(), (int)s.length(), true, &out_valid);
+  EXPECT_EQ(millis_since_epoch, 915148800000);
+}
+
 }  // namespace gandiva

From 50015f084846faaa5bf867346d045499e3f68316 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Fri, 8 Sep 2023 09:08:12 +0200
Subject: [PATCH 341/749] GH-37017: [C++] Guard unexpected uses of BMI2
 instructions (#37610)

### Rationale for this change

Some functions introduced with Acero only check for AVX2 availability, but they actually invoke BMI2 instructions.
This can have two negative consequences:
* compiling BMI2 intrinsics may fail because BMI2 was not explicitly enabled on the compiler (gh-37017)
* some rare CPUs (Via CPUs perhaps) may support AVX2 but not BMI2; other CPUs by AMD have a very inefficient implementation of some BMI2 instructions

### What changes are included in this PR?

1. Ensure that the suitable compiler flag is passed when compiling code with BMI2 intrinsics
2. Make sure the CPU supports BMI2 adequately before invoking functions featuring BMI2 instructions

### Are these changes tested?

Yes, assuming CI covers enough diversity of target platforms.

### Are there any user-facing changes?

No, but performance might change (positively or negatively) depending on the CPU and platform.

* Closes: #37017

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/cmake_modules/SetupCxxFlags.cmake  | 10 ++++++++--
 cpp/src/arrow/CMakeLists.txt           | 13 +++++++++++--
 cpp/src/arrow/compute/key_map.cc       | 10 ++++++----
 cpp/src/arrow/compute/key_map.h        |  3 ++-
 cpp/src/arrow/compute/util.cc          | 19 ++++++++++---------
 cpp/src/arrow/compute/util.h           |  3 ++-
 cpp/src/parquet/CMakeLists.txt         | 12 ++++++++----
 cpp/src/parquet/level_conversion_inc.h |  2 ++
 8 files changed, 49 insertions(+), 23 deletions(-)

diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 6b47fcb717287..a5f5659723c28 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -49,13 +49,16 @@ if(ARROW_CPU_FLAG STREQUAL "x86")
   if(MSVC)
     set(ARROW_SSE4_2_FLAG "")
     set(ARROW_AVX2_FLAG "/arch:AVX2")
+    # MSVC has no specific flag for BMI2, it seems to be enabled with AVX2
+    set(ARROW_BMI2_FLAG "/arch:AVX2")
     set(ARROW_AVX512_FLAG "/arch:AVX512")
     set(CXX_SUPPORTS_SSE4_2 TRUE)
   else()
     set(ARROW_SSE4_2_FLAG "-msse4.2")
     set(ARROW_AVX2_FLAG "-march=haswell")
+    set(ARROW_BMI2_FLAG "-mbmi2")
     # skylake-avx512 consists of AVX512F,AVX512BW,AVX512VL,AVX512CD,AVX512DQ
-    set(ARROW_AVX512_FLAG "-march=skylake-avx512 -mbmi2")
+    set(ARROW_AVX512_FLAG "-march=skylake-avx512")
     # Append the avx2/avx512 subset option also, fix issue ARROW-9877 for homebrew-cpp
     set(ARROW_AVX2_FLAG "${ARROW_AVX2_FLAG} -mavx2")
     set(ARROW_AVX512_FLAG
@@ -95,13 +98,16 @@ if(ARROW_CPU_FLAG STREQUAL "x86")
     set(ARROW_HAVE_RUNTIME_SSE4_2 ON)
     add_definitions(-DARROW_HAVE_RUNTIME_SSE4_2)
   endif()
+  # Note: for now we assume that AVX2 support should also enable BMI2 support,
+  # at least at compile-time (more care may be required for runtime dispatch).
   if(CXX_SUPPORTS_AVX2 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(AVX2|AVX512|MAX)$")
     set(ARROW_HAVE_RUNTIME_AVX2 ON)
+    set(ARROW_HAVE_RUNTIME_BMI2 ON)
     add_definitions(-DARROW_HAVE_RUNTIME_AVX2 -DARROW_HAVE_RUNTIME_BMI2)
   endif()
   if(CXX_SUPPORTS_AVX512 AND ARROW_RUNTIME_SIMD_LEVEL MATCHES "^(AVX512|MAX)$")
     set(ARROW_HAVE_RUNTIME_AVX512 ON)
-    add_definitions(-DARROW_HAVE_RUNTIME_AVX512 -DARROW_HAVE_RUNTIME_BMI2)
+    add_definitions(-DARROW_HAVE_RUNTIME_AVX512)
   endif()
   if(ARROW_SIMD_LEVEL STREQUAL "DEFAULT")
     set(ARROW_SIMD_LEVEL "SSE4_2")
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 427463bb1657b..f474d0c517fa0 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -127,6 +127,15 @@ macro(append_runtime_avx2_src SRC)
   endif()
 endmacro()
 
+macro(append_runtime_avx2_bmi2_src SRC)
+  if(ARROW_HAVE_RUNTIME_AVX2 AND ARROW_HAVE_RUNTIME_BMI2)
+    list(APPEND ARROW_SRCS ${SRC})
+    set_source_files_properties(${SRC} PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
+    set_source_files_properties(${SRC} PROPERTIES COMPILE_FLAGS
+                                                  "${ARROW_AVX2_FLAG} ${ARROW_BMI2_FLAG}")
+  endif()
+endmacro()
+
 macro(append_runtime_avx512_src SRC)
   if(ARROW_HAVE_RUNTIME_AVX512)
     list(APPEND ARROW_SRCS ${SRC})
@@ -433,10 +442,10 @@ list(APPEND
      compute/util.cc)
 
 append_runtime_avx2_src(compute/key_hash_avx2.cc)
-append_runtime_avx2_src(compute/key_map_avx2.cc)
+append_runtime_avx2_bmi2_src(compute/key_map_avx2.cc)
 append_runtime_avx2_src(compute/row/compare_internal_avx2.cc)
 append_runtime_avx2_src(compute/row/encode_internal_avx2.cc)
-append_runtime_avx2_src(compute/util_avx2.cc)
+append_runtime_avx2_bmi2_src(compute/util_avx2.cc)
 
 if(ARROW_COMPUTE)
   # Include the remaining kernels
diff --git a/cpp/src/arrow/compute/key_map.cc b/cpp/src/arrow/compute/key_map.cc
index 71ca56c91a9ff..525dae850f19b 100644
--- a/cpp/src/arrow/compute/key_map.cc
+++ b/cpp/src/arrow/compute/key_map.cc
@@ -28,6 +28,7 @@
 namespace arrow {
 
 using bit_util::CountLeadingZeros;
+using internal::CpuInfo;
 
 namespace compute {
 
@@ -133,9 +134,10 @@ void SwissTable::extract_group_ids(const int num_keys, const uint16_t* optional_
 
   // Optimistically use simplified lookup involving only a start block to find
   // a single group id candidate for every input.
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
   int num_group_id_bytes = num_group_id_bits / 8;
-  if ((hardware_flags_ & arrow::internal::CpuInfo::AVX2) && !optional_selection) {
+  if ((hardware_flags_ & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2() &&
+      !optional_selection) {
     num_processed = extract_group_ids_avx2(num_keys, hashes, local_slots, out_group_ids,
                                            sizeof(uint64_t), 8 + 8 * num_group_id_bytes,
                                            num_group_id_bytes);
@@ -301,8 +303,8 @@ void SwissTable::early_filter(const int num_keys, const uint32_t* hashes,
   // Optimistically use simplified lookup involving only a start block to find
   // a single group id candidate for every input.
   int num_processed = 0;
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
-  if (hardware_flags_ & arrow::internal::CpuInfo::AVX2) {
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  if ((hardware_flags_ & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2()) {
     if (log_blocks_ <= 4) {
       num_processed = early_filter_imp_avx2_x32(num_keys, hashes, out_match_bitvector,
                                                 out_local_slots);
diff --git a/cpp/src/arrow/compute/key_map.h b/cpp/src/arrow/compute/key_map.h
index 95fb3be274288..85ef9029d6fc9 100644
--- a/cpp/src/arrow/compute/key_map.h
+++ b/cpp/src/arrow/compute/key_map.h
@@ -163,7 +163,8 @@ class ARROW_EXPORT SwissTable {
   //
   void early_filter_imp(const int num_keys, const uint32_t* hashes,
                         uint8_t* out_match_bitvector, uint8_t* out_local_slots) const;
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  // The functions below use BMI2 instructions, be careful before calling!
   int early_filter_imp_avx2_x8(const int num_hashes, const uint32_t* hashes,
                                uint8_t* out_match_bitvector,
                                uint8_t* out_local_slots) const;
diff --git a/cpp/src/arrow/compute/util.cc b/cpp/src/arrow/compute/util.cc
index faf3e0c87e4d2..c55143af0cd59 100644
--- a/cpp/src/arrow/compute/util.cc
+++ b/cpp/src/arrow/compute/util.cc
@@ -27,6 +27,7 @@
 namespace arrow {
 
 using bit_util::CountTrailingZeros;
+using internal::CpuInfo;
 
 namespace util {
 
@@ -118,8 +119,8 @@ void bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
   // 64 bits at a time
   constexpr int unroll = 64;
   int tail = num_bits % unroll;
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
-  if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  if ((hardware_flags & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2()) {
     if (filter_input_indexes) {
       avx2::bits_filter_indexes_avx2(bit_to_search, num_bits - tail, bits, input_indexes,
                                      num_indexes, indexes);
@@ -141,7 +142,7 @@ void bits_to_indexes_internal(int64_t hardware_flags, const int num_bits,
         bits_to_indexes_helper(word, i * 64 + base_index, num_indexes, indexes);
       }
     }
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
   }
 #endif
   // Optionally process the last partial word with masking out bits outside range
@@ -253,8 +254,8 @@ void bits_to_bytes(int64_t hardware_flags, const int num_bits, const uint8_t* bi
   }
 
   int num_processed = 0;
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
-  if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  if ((hardware_flags & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2()) {
     // The function call below processes whole 32 bit chunks together.
     num_processed = num_bits - (num_bits % 32);
     avx2::bits_to_bytes_avx2(num_processed, bits, bytes);
@@ -309,8 +310,8 @@ void bytes_to_bits(int64_t hardware_flags, const int num_bits, const uint8_t* by
   }
 
   int num_processed = 0;
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
-  if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  if ((hardware_flags & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2()) {
     // The function call below processes whole 32 bit chunks together.
     num_processed = num_bits - (num_bits % 32);
     avx2::bytes_to_bits_avx2(num_processed, bytes, bits);
@@ -339,8 +340,8 @@ void bytes_to_bits(int64_t hardware_flags, const int num_bits, const uint8_t* by
 
 bool are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
                         uint32_t num_bytes) {
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
-  if (hardware_flags & arrow::internal::CpuInfo::AVX2) {
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+  if ((hardware_flags & CpuInfo::AVX2) && CpuInfo::GetInstance()->HasEfficientBmi2()) {
     return avx2::are_all_bytes_zero_avx2(bytes, num_bytes);
   }
 #endif
diff --git a/cpp/src/arrow/compute/util.h b/cpp/src/arrow/compute/util.h
index 730e59f346a52..e2a2e71b8521d 100644
--- a/cpp/src/arrow/compute/util.h
+++ b/cpp/src/arrow/compute/util.h
@@ -168,7 +168,8 @@ ARROW_EXPORT void bytes_to_bits(int64_t hardware_flags, const int num_bits,
 ARROW_EXPORT bool are_all_bytes_zero(int64_t hardware_flags, const uint8_t* bytes,
                                      uint32_t num_bytes);
 
-#if defined(ARROW_HAVE_RUNTIME_AVX2)
+#if defined(ARROW_HAVE_RUNTIME_AVX2) && defined(ARROW_HAVE_RUNTIME_BMI2)
+// The functions below use BMI2 instructions, be careful before calling!
 
 namespace avx2 {
 ARROW_EXPORT void bits_filter_indexes_avx2(int bit_to_search, const int num_bits,
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index eabfcea586905..8ffeab4dfbeab 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -212,10 +212,14 @@ if(ARROW_HAVE_RUNTIME_AVX2)
   #
   # TODO: Use COMPILE_OPTIONS instead of COMPILE_FLAGS when we require
   # CMake 3.11 or later.
-  set(BMI2_FLAGS "${AVX2_FLAGS} -DARROW_HAVE_BMI2 -mbmi2")
-  set_source_files_properties(level_conversion_bmi2.cc
-                              PROPERTIES SKIP_PRECOMPILE_HEADERS ON COMPILE_FLAGS
-                                                                    "${BMI2_FLAGS}")
+  if(ARROW_HAVE_RUNTIME_BMI2)
+    # Need to pass ARROW_HAVE_BMI2 for level_conversion_inc.h to compile
+    # the BMI2 path.
+    set(BMI2_FLAGS "${AVX2_FLAGS} ${ARROW_BMI2_FLAG} -DARROW_HAVE_BMI2")
+    set_source_files_properties(level_conversion_bmi2.cc
+                                PROPERTIES SKIP_PRECOMPILE_HEADERS ON COMPILE_FLAGS
+                                                                      "${BMI2_FLAGS}")
+  endif()
 endif()
 
 if(PARQUET_REQUIRE_ENCRYPTION)
diff --git a/cpp/src/parquet/level_conversion_inc.h b/cpp/src/parquet/level_conversion_inc.h
index 0bcdbccb34a73..d1ccedabfde50 100644
--- a/cpp/src/parquet/level_conversion_inc.h
+++ b/cpp/src/parquet/level_conversion_inc.h
@@ -29,9 +29,11 @@
 #include "arrow/util/simd.h"
 #include "parquet/exception.h"
 #include "parquet/level_comparison.h"
+
 #ifndef PARQUET_IMPL_NAMESPACE
 #error "PARQUET_IMPL_NAMESPACE must be defined"
 #endif
+
 namespace parquet::internal::PARQUET_IMPL_NAMESPACE {
 
 // clang-format off

From 0e6b8c53158be291c75c0b71cc72e7301171cff0 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 8 Sep 2023 10:55:10 -0400
Subject: [PATCH 342/749] GH-37570: [MATLAB] Implement `isequal` for the
 `arrow.tabular.RecordBatch` MATLAB class (#37627)

### Rationale for this change

Following on to https://github.com/apache/arrow/pull/37474, https://github.com/apache/arrow/pull/37446, and https://github.com/apache/arrow/pull/37525, we should implement `isequal` for the `arrow.tabular.RecordBatch` MATLAB class.

### What changes are included in this PR?

1. Implemented `isequal` method for `arrow.tabular.RecordBatch`

### Are these changes tested?

Yes. Added `isequal` unit tests to `tRecordBatch.m`.

### Are there any user-facing changes?

Yes, users can now use `isequal` to compare `arrow.tabular.RecordBatch`es.

**Example**

```matlab
>> t1 = table(1, "A", false, VariableNames=["Number",  "String", "Logical"]);
>> t2 = table([1; 2], ["A"; "B"], [false; false], VariableNames=["Number",  "String", "Logical"]);
>> rb1 = arrow.recordBatch(t1);
>> rb2 = arrow.recordBatch(t2);
>> rb3 = arrow.recordBatch(t1);

>> isequal(rb1, rb2)

ans =

  logical

   0

>> isequal(rb1, rb3)

ans =

  logical

   1
```

### Future Directions
1. #37628

* Closes: #37570

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 46 +++++++++++-
 matlab/test/arrow/tabular/tRecordBatch.m      | 72 +++++++++++++++++++
 2 files changed, 116 insertions(+), 2 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index f8a670d095635..32269e91141ca 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -1,3 +1,7 @@
+%RECORDBATCH A tabular data structure representing a set of 
+%arrow.array.Array objects with a fixed schema.
+
+
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
 % this work for additional information regarding copyright ownership.
@@ -15,8 +19,6 @@
 
 classdef RecordBatch < matlab.mixin.CustomDisplay & ...
                        matlab.mixin.Scalar
-%arrow.tabular.RecordBatch A tabular data structure representing
-% a set of arrow.array.Array objects with a fixed schema.
 
     properties (Dependent, SetAccess=private, GetAccess=public)
         NumColumns
@@ -91,6 +93,46 @@
         function T = toMATLAB(obj)
             T = obj.table();
         end
+
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+            tf = false;
+
+            schemasToCompare = cell([1 numel(varargin)]);
+            for ii = 1:numel(varargin)
+                rb = varargin{ii};
+                if ~isa(rb, "arrow.tabular.RecordBatch")
+                    % If rb is not a RecordBatch, then it cannot be equal
+                    % to obj. Return false early.
+                    return;
+                end
+                schemasToCompare{ii} = rb.Schema;
+            end
+
+            if ~isequal(obj.Schema, schemasToCompare{:})
+                % If the schemas are not equal, the record batches are not
+                % equal. Return false early.
+                return;
+            end
+
+            % Function that extracts the column stored at colIndex from the
+            % record batch stored at rbIndex in varargin.
+            getColumnFcn = @(rbIndex, colIndex) varargin{rbIndex}.column(colIndex);
+
+            rbIndices = 1:numel(varargin);
+            for ii = 1:obj.NumColumns
+                colIndices = repmat(ii, [1 numel(rbIndices)]);
+                % Gather all columns at index ii across the record
+                % batches stored in varargin. Compare these columns with
+                % the corresponding column in obj. If they are not equal,
+                % then the record batches are not equal. Return false.
+                columnsToCompare = arrayfun(getColumnFcn, rbIndices, colIndices, UniformOutput=false);
+                if ~isequal(obj.column(ii), columnsToCompare{:})
+                    return;
+                end
+            end
+            tf = true;
+        end
     end
 
     methods (Access = private)
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index f4b156a377047..b26729012a359 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -386,6 +386,78 @@ function ErrorIfColumnNameIsNonScalar(testCase)
             testCase.verifyError(@() recordBatch.column(name), "arrow:badsubscript:NonScalar");
         end
 
+        function TestIsEqualTrue(testCase)
+            % Verify two record batches are considered equal if:
+            %   1. They have the same schema
+            %   2. Their corresponding columns are equal
+            import arrow.tabular.RecordBatch
+
+            a1 = arrow.array([1 2 3]);
+            a2 = arrow.array(["A" "B" "C"]);
+            a3 = arrow.array([true true false]);
+
+            rb1 = RecordBatch.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            rb2 = RecordBatch.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            testCase.verifyTrue(isequal(rb1, rb2));
+
+            % Compare zero-column record batches
+            rb3 = RecordBatch.fromArrays();
+            rb4 = RecordBatch.fromArrays();
+            testCase.verifyTrue(isequal(rb3, rb4));
+
+            % Compare zero-row record batches
+            a4 = arrow.array([]);
+            a5 = arrow.array(strings(0, 0));
+            rb5 = RecordBatch.fromArrays(a4, a5, ColumnNames=["D" "E"]);
+            rb6 = RecordBatch.fromArrays(a4, a5, ColumnNames=["D" "E"]);
+            testCase.verifyTrue(isequal(rb5, rb6));
+
+            % Call isequal with more than two arguments
+            testCase.verifyTrue(isequal(rb3, rb4, rb3, rb4));
+        end
+
+        function TestIsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+            import arrow.tabular.RecordBatch
+
+            a1 = arrow.array([1 2 3]);
+            a2 = arrow.array(["A" "B" "C"]);
+            a3 = arrow.array([true true false]);
+            a4 = arrow.array(["A" missing "C"]); 
+            a5 = arrow.array([1 2]);
+            a6 = arrow.array(["A" "B"]);
+            a7 = arrow.array([true true]);
+
+            rb1 = RecordBatch.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            rb2 = RecordBatch.fromArrays(a1, a2, a3, ...
+                ColumnNames=["D", "E", "F"]);
+            rb3 = RecordBatch.fromArrays(a1, a4, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            rb4 = RecordBatch.fromArrays(a5, a6, a7, ...
+                ColumnNames=["A", "B", "C"]);
+            rb5 = RecordBatch.fromArrays(a1, a2, a3, a1, ...
+                ColumnNames=["A", "B", "C", "D"]);
+
+            % The column names are not equal
+            testCase.verifyFalse(isequal(rb1, rb2));
+
+            % The columns are not equal
+            testCase.verifyFalse(isequal(rb1, rb3));
+
+            % The number of rows are not equal
+            testCase.verifyFalse(isequal(rb1, rb4));
+
+            % The number of columns are not equal
+            testCase.verifyFalse(isequal(rb1, rb5));
+
+            % Call isequal with more than two arguments
+            testCase.verifyFalse(isequal(rb1, rb2, rb3, rb4));
+        end
+
+
     end
 
     methods

From f1d2fc92f9d898fc067d46a0d032d9b117a2d7fc Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 8 Sep 2023 11:37:21 -0400
Subject: [PATCH 343/749] GH-37628: [MATLAB] Implement `isequal` for the
 `arrow.tabular.Table` MATLAB class (#37629)

### Rationale for this change

Following on to #37474, #37446, #37525,  and  #37627, we should implement `isequal` for the arrow.tabular.Table` MATLAB class.

### What changes are included in this PR?

1. Add new function `arrow.internal.tabular.isequal` that both `arrow.tabular.RecordBatch` and `arrow.tabular.Table` can use to implement their `isequal` methods.
2. Modified `arrow.tabular.RecordBatch` to use the new `isequal` package function to implement  its `isequal` method.
3. Implemented the `isequal` method for `arrow.tabular.Table` using the new `isequal` package function.

### Are these changes tested?

Yes, added `isequal` unit tests to `tTable.m`

### Are there any user-facing changes?

Yes. Users can now compare `arrow.tabular.Table`s using `isequal`:

```matlab
>> t1 = table(1, "A", false, VariableNames=["Number",  "String", "Logical"]);
>> t2 = table([1; 2], ["A"; "B"], [false; false], VariableNames=["Number",  "String", "Logical"]);
>> tbl1 = arrow.table(t1);
>> tbl2 = arrow.table(t2);
>> tbl3 = arrow.table(t1);

>> isequal(tbl1, tbl2)

ans =

  logical

   0

>> isequal(tbl1, tbl3)

ans =

  logical

   1
```

* Closes: #37628

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+arrow/+tabular/+internal/isequal.m       | 60 +++++++++++++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  | 38 +---------
 matlab/src/matlab/+arrow/+tabular/Table.m     |  4 +
 matlab/test/arrow/tabular/tTable.m            | 75 ++++++++++++++++++-
 4 files changed, 138 insertions(+), 39 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/isequal.m

diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/isequal.m b/matlab/src/matlab/+arrow/+tabular/+internal/isequal.m
new file mode 100644
index 0000000000000..9457620e131f4
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/isequal.m
@@ -0,0 +1,60 @@
+%ISEQUAL Utility function used by both arrow.tabular.RecordBatch and
+%arrow.tabular.Table to implement the isequal method.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function tf = isequal(tabularObj, varargin)
+    narginchk(2, inf);
+    tf = false;
+
+    classType = string(class(tabularObj));
+
+    schemasToCompare = cell([1 numel(varargin)]);
+    for ii = 1:numel(varargin)
+        element = varargin{ii};
+        if ~isa(element, classType)
+            % If element is not an instance of classType, then it cannot
+            % be equal to tabularObj. Return false early. 
+            return;
+        end
+        schemasToCompare{ii} = element.Schema;
+    end
+
+    if ~isequal(tabularObj.Schema, schemasToCompare{:})
+        % If the schemas are not equal, then the record batches (or tables)
+        % are not equal. Return false early.
+        return;
+    end
+
+    % Function that extracts the column stored at colIndex from the
+    % record batch (or table) stored at tabularIndex in varargin.
+    getColumnFcn = @(tabularIndex, colIndex) varargin{tabularIndex}.column(colIndex);
+
+    tabularObjIndices = 1:numel(varargin);
+    for ii = 1:tabularObj.NumColumns
+        colIndices = repmat(ii, [1 numel(tabularObjIndices)]);
+        % Gather all columns at index ii across the record batches (or
+        % tables) stored in varargin. Compare these columns with the
+        % corresponding column in obj. If they are not equal, then the
+        % record batches (or tables) are not equal. Return false.
+        columnsToCompare = arrayfun(getColumnFcn, tabularObjIndices, colIndices, UniformOutput=false);
+        if ~isequal(tabularObj.column(ii), columnsToCompare{:})
+            return;
+        end
+    end
+    tf = true;
+end
+
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 32269e91141ca..725039e87e426 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -95,43 +95,7 @@
         end
 
         function tf = isequal(obj, varargin)
-            narginchk(2, inf);
-            tf = false;
-
-            schemasToCompare = cell([1 numel(varargin)]);
-            for ii = 1:numel(varargin)
-                rb = varargin{ii};
-                if ~isa(rb, "arrow.tabular.RecordBatch")
-                    % If rb is not a RecordBatch, then it cannot be equal
-                    % to obj. Return false early.
-                    return;
-                end
-                schemasToCompare{ii} = rb.Schema;
-            end
-
-            if ~isequal(obj.Schema, schemasToCompare{:})
-                % If the schemas are not equal, the record batches are not
-                % equal. Return false early.
-                return;
-            end
-
-            % Function that extracts the column stored at colIndex from the
-            % record batch stored at rbIndex in varargin.
-            getColumnFcn = @(rbIndex, colIndex) varargin{rbIndex}.column(colIndex);
-
-            rbIndices = 1:numel(varargin);
-            for ii = 1:obj.NumColumns
-                colIndices = repmat(ii, [1 numel(rbIndices)]);
-                % Gather all columns at index ii across the record
-                % batches stored in varargin. Compare these columns with
-                % the corresponding column in obj. If they are not equal,
-                % then the record batches are not equal. Return false.
-                columnsToCompare = arrayfun(getColumnFcn, rbIndices, colIndices, UniformOutput=false);
-                if ~isequal(obj.column(ii), columnsToCompare{:})
-                    return;
-                end
-            end
-            tf = true;
+            tf = arrow.tabular.internal.isequal(obj, varargin{:});
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+tabular/Table.m b/matlab/src/matlab/+arrow/+tabular/Table.m
index d9eb4d8409733..c2f73450408ef 100644
--- a/matlab/src/matlab/+arrow/+tabular/Table.m
+++ b/matlab/src/matlab/+arrow/+tabular/Table.m
@@ -97,6 +97,10 @@
             T = obj.table();
         end
 
+        function tf = isequal(obj, varargin)
+            tf = arrow.tabular.internal.isequal(obj, varargin{:});
+        end
+
     end
 
     methods (Access = private)
diff --git a/matlab/test/arrow/tabular/tTable.m b/matlab/test/arrow/tabular/tTable.m
index 8c6b9aae73752..7bb366a6043aa 100644
--- a/matlab/test/arrow/tabular/tTable.m
+++ b/matlab/test/arrow/tabular/tTable.m
@@ -64,8 +64,8 @@ function Table(testCase)
             % Verify that the toMATLAB method converts
             % an arrow.tabular.Table to a MATLAB table as expected.
             TOriginal = table([1, 2, 3]');
-            arrowRecordBatch = arrow.recordBatch(TOriginal);
-            TConverted = table(arrowRecordBatch);
+            arrowTable = arrow.table(TOriginal);
+            TConverted = table(arrowTable);
             testCase.verifyEqual(TOriginal, TConverted);
         end
 
@@ -593,6 +593,77 @@ function ColumnNamesNoSetter(testCase)
                 "MATLAB:class:SetProhibited");
         end
 
+        function TestIsEqualTrue(testCase)
+            % Verify two tables are considered equal if:
+            %   1. They have the same schema
+            %   2. Their corresponding columns are equal
+            import arrow.tabular.Table
+
+            a1 = arrow.array([1 2 3]);
+            a2 = arrow.array(["A" "B" "C"]);
+            a3 = arrow.array([true true false]);
+
+            t1 = Table.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            t2 = Table.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            testCase.verifyTrue(isequal(t1, t2));
+
+            % Compare zero-column tables
+            t3 = Table.fromArrays();
+            t4 = Table.fromArrays();
+            testCase.verifyTrue(isequal(t3, t4));
+
+            % Compare zero-row tables
+            a4 = arrow.array([]);
+            a5 = arrow.array(strings(0, 0));
+            t5 = Table.fromArrays(a4, a5, ColumnNames=["D" "E"]);
+            t6 = Table.fromArrays(a4, a5, ColumnNames=["D" "E"]);
+            testCase.verifyTrue(isequal(t5, t6));
+
+            % Call isequal with more than two arguments
+            testCase.verifyTrue(isequal(t3, t4, t3, t4));
+        end
+
+        function TestIsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+            import arrow.tabular.Table
+
+            a1 = arrow.array([1 2 3]);
+            a2 = arrow.array(["A" "B" "C"]);
+            a3 = arrow.array([true true false]);
+            a4 = arrow.array(["A" missing "C"]); 
+            a5 = arrow.array([1 2]);
+            a6 = arrow.array(["A" "B"]);
+            a7 = arrow.array([true true]);
+
+            t1 = Table.fromArrays(a1, a2, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            t2 = Table.fromArrays(a1, a2, a3, ...
+                ColumnNames=["D", "E", "F"]);
+            t3 = Table.fromArrays(a1, a4, a3, ...
+                ColumnNames=["A", "B", "C"]);
+            t4 = Table.fromArrays(a5, a6, a7, ...
+                ColumnNames=["A", "B", "C"]);
+            t5 = Table.fromArrays(a1, a2, a3, a1, ...
+                ColumnNames=["A", "B", "C", "D"]);
+
+            % The column names are not equal
+            testCase.verifyFalse(isequal(t1, t2));
+
+            % The columns are not equal
+            testCase.verifyFalse(isequal(t1, t3));
+
+            % The number of rows are not equal
+            testCase.verifyFalse(isequal(t1, t4));
+
+            % The number of columns are not equal
+            testCase.verifyFalse(isequal(t1, t5));
+
+            % Call isequal with more than two arguments
+            testCase.verifyFalse(isequal(t1, t2, t3, t4));
+        end
+
     end
 
     methods

From 44811ba18477560711d512939535c8389dd7787b Mon Sep 17 00:00:00 2001
From: Benjamin Kietzman <bengilgit@gmail.com>
Date: Fri, 8 Sep 2023 18:05:28 -0400
Subject: [PATCH 344/749] GH-36379: [C++] Bundled dependency include paths
 should override system include dirs (#37612)

### Rationale for this change

Bundled dependencies' include directories should override system include dirs. Otherwise an incompatible header in the system might be included when we wanted a header from the bundled dependency.

### What changes are included in this PR?

bundled dependencies explicitly insert their own include dirs ahead of others
* Closes: #36379

Authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 216 +++++++++-----------
 1 file changed, 99 insertions(+), 117 deletions(-)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index a9ac0b9451481..85c0337d108be 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -1322,10 +1322,9 @@ macro(build_snappy)
 
   set(Snappy_TARGET Snappy::snappy-static)
   add_library(${Snappy_TARGET} STATIC IMPORTED)
-  set_target_properties(${Snappy_TARGET}
-                        PROPERTIES IMPORTED_LOCATION "${SNAPPY_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${SNAPPY_PREFIX}/include")
+  set_target_properties(${Snappy_TARGET} PROPERTIES IMPORTED_LOCATION
+                                                    "${SNAPPY_STATIC_LIB}")
+  target_include_directories(${Snappy_TARGET} BEFORE INTERFACE "${SNAPPY_PREFIX}/include")
   add_dependencies(toolchain snappy_ep)
   add_dependencies(${Snappy_TARGET} snappy_ep)
 
@@ -1381,21 +1380,22 @@ macro(build_brotli)
   file(MAKE_DIRECTORY "${BROTLI_INCLUDE_DIR}")
 
   add_library(Brotli::brotlicommon STATIC IMPORTED)
-  set_target_properties(Brotli::brotlicommon
-                        PROPERTIES IMPORTED_LOCATION "${BROTLI_STATIC_LIBRARY_COMMON}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${BROTLI_INCLUDE_DIR}")
+  set_target_properties(Brotli::brotlicommon PROPERTIES IMPORTED_LOCATION
+                                                        "${BROTLI_STATIC_LIBRARY_COMMON}")
+  target_include_directories(Brotli::brotlicommon BEFORE
+                             INTERFACE "${BROTLI_INCLUDE_DIR}")
   add_dependencies(Brotli::brotlicommon brotli_ep)
 
   add_library(Brotli::brotlienc STATIC IMPORTED)
-  set_target_properties(Brotli::brotlienc
-                        PROPERTIES IMPORTED_LOCATION "${BROTLI_STATIC_LIBRARY_ENC}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${BROTLI_INCLUDE_DIR}")
+  set_target_properties(Brotli::brotlienc PROPERTIES IMPORTED_LOCATION
+                                                     "${BROTLI_STATIC_LIBRARY_ENC}")
+  target_include_directories(Brotli::brotlienc BEFORE INTERFACE "${BROTLI_INCLUDE_DIR}")
   add_dependencies(Brotli::brotlienc brotli_ep)
 
   add_library(Brotli::brotlidec STATIC IMPORTED)
-  set_target_properties(Brotli::brotlidec
-                        PROPERTIES IMPORTED_LOCATION "${BROTLI_STATIC_LIBRARY_DEC}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${BROTLI_INCLUDE_DIR}")
+  set_target_properties(Brotli::brotlidec PROPERTIES IMPORTED_LOCATION
+                                                     "${BROTLI_STATIC_LIBRARY_DEC}")
+  target_include_directories(Brotli::brotlidec BEFORE INTERFACE "${BROTLI_INCLUDE_DIR}")
   add_dependencies(Brotli::brotlidec brotli_ep)
 
   list(APPEND
@@ -1487,9 +1487,8 @@ macro(build_glog)
   file(MAKE_DIRECTORY "${GLOG_INCLUDE_DIR}")
 
   add_library(glog::glog STATIC IMPORTED)
-  set_target_properties(glog::glog
-                        PROPERTIES IMPORTED_LOCATION "${GLOG_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GLOG_INCLUDE_DIR}")
+  set_target_properties(glog::glog PROPERTIES IMPORTED_LOCATION "${GLOG_STATIC_LIB}")
+  target_include_directories(glog::glog BEFORE INTERFACE "${GLOG_INCLUDE_DIR}")
   add_dependencies(glog::glog glog_ep)
 
   list(APPEND ARROW_BUNDLED_STATIC_LIBS glog::glog)
@@ -1548,9 +1547,9 @@ macro(build_gflags)
   add_thirdparty_lib(gflags::gflags_static STATIC ${GFLAGS_STATIC_LIB})
   add_dependencies(gflags::gflags_static gflags_ep)
   set(GFLAGS_LIBRARY gflags::gflags_static)
-  set_target_properties(${GFLAGS_LIBRARY}
-                        PROPERTIES INTERFACE_COMPILE_DEFINITIONS "GFLAGS_IS_A_DLL=0"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GFLAGS_INCLUDE_DIR}")
+  set_target_properties(${GFLAGS_LIBRARY} PROPERTIES INTERFACE_COMPILE_DEFINITIONS
+                                                     "GFLAGS_IS_A_DLL=0")
+  target_include_directories(${GFLAGS_LIBRARY} BEFORE INTERFACE "${GFLAGS_INCLUDE_DIR}")
   if(MSVC)
     set_target_properties(${GFLAGS_LIBRARY} PROPERTIES INTERFACE_LINK_LIBRARIES
                                                        "shlwapi.lib")
@@ -1651,9 +1650,8 @@ macro(build_thrift)
   add_library(thrift::thrift STATIC IMPORTED)
   # The include directory must exist before it is referenced by a target.
   file(MAKE_DIRECTORY "${THRIFT_INCLUDE_DIR}")
-  set_target_properties(thrift::thrift
-                        PROPERTIES IMPORTED_LOCATION "${THRIFT_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${THRIFT_INCLUDE_DIR}")
+  set_target_properties(thrift::thrift PROPERTIES IMPORTED_LOCATION "${THRIFT_LIB}")
+  target_include_directories(thrift::thrift BEFORE INTERFACE "${THRIFT_INCLUDE_DIR}")
   if(ARROW_USE_BOOST)
     target_link_libraries(thrift::thrift INTERFACE Boost::headers)
   endif()
@@ -1741,15 +1739,15 @@ macro(build_protobuf)
   set(Protobuf_INCLUDE_DIRS "${PROTOBUF_INCLUDE_DIR}")
 
   add_library(arrow::protobuf::libprotobuf STATIC IMPORTED)
-  set_target_properties(arrow::protobuf::libprotobuf
-                        PROPERTIES IMPORTED_LOCATION "${PROTOBUF_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${PROTOBUF_INCLUDE_DIR}")
+  set_target_properties(arrow::protobuf::libprotobuf PROPERTIES IMPORTED_LOCATION
+                                                                "${PROTOBUF_STATIC_LIB}")
+  target_include_directories(arrow::protobuf::libprotobuf BEFORE
+                             INTERFACE "${PROTOBUF_INCLUDE_DIR}")
   add_library(arrow::protobuf::libprotoc STATIC IMPORTED)
-  set_target_properties(arrow::protobuf::libprotoc
-                        PROPERTIES IMPORTED_LOCATION "${PROTOC_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${PROTOBUF_INCLUDE_DIR}")
+  set_target_properties(arrow::protobuf::libprotoc PROPERTIES IMPORTED_LOCATION
+                                                              "${PROTOC_STATIC_LIB}")
+  target_include_directories(arrow::protobuf::libprotoc BEFORE
+                             INTERFACE "${PROTOBUF_INCLUDE_DIR}")
   add_executable(arrow::protobuf::protoc IMPORTED)
   set_target_properties(arrow::protobuf::protoc PROPERTIES IMPORTED_LOCATION
                                                            "${PROTOBUF_COMPILER}")
@@ -2021,9 +2019,9 @@ macro(build_jemalloc)
   add_library(jemalloc::jemalloc STATIC IMPORTED)
   set_target_properties(jemalloc::jemalloc
                         PROPERTIES INTERFACE_LINK_LIBRARIES Threads::Threads
-                                   IMPORTED_LOCATION "${JEMALLOC_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${JEMALLOC_INCLUDE_DIR}")
+                                   IMPORTED_LOCATION "${JEMALLOC_STATIC_LIB}")
+  target_include_directories(jemalloc::jemalloc BEFORE
+                             INTERFACE "${JEMALLOC_INCLUDE_DIR}")
   add_dependencies(jemalloc::jemalloc jemalloc_ep)
 
   list(APPEND ARROW_BUNDLED_STATIC_LIBS jemalloc::jemalloc)
@@ -2079,9 +2077,9 @@ if(ARROW_MIMALLOC)
   add_library(mimalloc::mimalloc STATIC IMPORTED)
   set_target_properties(mimalloc::mimalloc
                         PROPERTIES INTERFACE_LINK_LIBRARIES Threads::Threads
-                                   IMPORTED_LOCATION "${MIMALLOC_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${MIMALLOC_INCLUDE_DIR}")
+                                   IMPORTED_LOCATION "${MIMALLOC_STATIC_LIB}")
+  target_include_directories(mimalloc::mimalloc BEFORE
+                             INTERFACE "${MIMALLOC_INCLUDE_DIR}")
   if(WIN32)
     set_property(TARGET mimalloc::mimalloc
                  APPEND
@@ -2220,17 +2218,17 @@ macro(build_benchmark)
   file(MAKE_DIRECTORY "${GBENCHMARK_INCLUDE_DIR}")
 
   add_library(benchmark::benchmark STATIC IMPORTED)
-  set_target_properties(benchmark::benchmark
-                        PROPERTIES IMPORTED_LOCATION "${GBENCHMARK_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${GBENCHMARK_INCLUDE_DIR}")
+  set_target_properties(benchmark::benchmark PROPERTIES IMPORTED_LOCATION
+                                                        "${GBENCHMARK_STATIC_LIB}")
+  target_include_directories(benchmark::benchmark BEFORE
+                             INTERFACE "${GBENCHMARK_INCLUDE_DIR}")
   target_compile_definitions(benchmark::benchmark INTERFACE "BENCHMARK_STATIC_DEFINE")
 
   add_library(benchmark::benchmark_main STATIC IMPORTED)
   set_target_properties(benchmark::benchmark_main
-                        PROPERTIES IMPORTED_LOCATION "${GBENCHMARK_MAIN_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${GBENCHMARK_INCLUDE_DIR}")
+                        PROPERTIES IMPORTED_LOCATION "${GBENCHMARK_MAIN_STATIC_LIB}")
+  target_include_directories(benchmark::benchmark_main BEFORE
+                             INTERFACE "${GBENCHMARK_INCLUDE_DIR}")
 
   add_dependencies(toolchain-benchmarks gbenchmark_ep)
   add_dependencies(benchmark::benchmark gbenchmark_ep)
@@ -2374,9 +2372,8 @@ macro(build_zlib)
   add_library(ZLIB::ZLIB STATIC IMPORTED)
   set(ZLIB_LIBRARIES ${ZLIB_STATIC_LIB})
   set(ZLIB_INCLUDE_DIRS "${ZLIB_PREFIX}/include")
-  set_target_properties(ZLIB::ZLIB
-                        PROPERTIES IMPORTED_LOCATION ${ZLIB_LIBRARIES}
-                                   INTERFACE_INCLUDE_DIRECTORIES ${ZLIB_INCLUDE_DIRS})
+  set_target_properties(ZLIB::ZLIB PROPERTIES IMPORTED_LOCATION ${ZLIB_LIBRARIES})
+  target_include_directories(ZLIB::ZLIB BEFORE INTERFACE "${ZLIB_INCLUDE_DIRS}")
 
   add_dependencies(toolchain zlib_ep)
   add_dependencies(ZLIB::ZLIB zlib_ep)
@@ -2412,9 +2409,8 @@ macro(build_lz4)
 
   file(MAKE_DIRECTORY "${LZ4_PREFIX}/include")
   add_library(LZ4::lz4 STATIC IMPORTED)
-  set_target_properties(LZ4::lz4
-                        PROPERTIES IMPORTED_LOCATION "${LZ4_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${LZ4_PREFIX}/include")
+  set_target_properties(LZ4::lz4 PROPERTIES IMPORTED_LOCATION "${LZ4_STATIC_LIB}")
+  target_include_directories(LZ4::lz4 BEFORE INTERFACE "${LZ4_PREFIX}/include")
   add_dependencies(toolchain lz4_ep)
   add_dependencies(LZ4::lz4 lz4_ep)
 
@@ -2463,9 +2459,10 @@ macro(build_zstd)
   file(MAKE_DIRECTORY "${ZSTD_PREFIX}/include")
 
   add_library(zstd::libzstd_static STATIC IMPORTED)
-  set_target_properties(zstd::libzstd_static
-                        PROPERTIES IMPORTED_LOCATION "${ZSTD_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${ZSTD_PREFIX}/include")
+  set_target_properties(zstd::libzstd_static PROPERTIES IMPORTED_LOCATION
+                                                        "${ZSTD_STATIC_LIB}")
+  target_include_directories(zstd::libzstd_static BEFORE
+                             INTERFACE "${ZSTD_PREFIX}/include")
 
   add_dependencies(toolchain zstd_ep)
   add_dependencies(zstd::libzstd_static zstd_ep)
@@ -2521,9 +2518,8 @@ macro(build_re2)
 
   file(MAKE_DIRECTORY "${RE2_PREFIX}/include")
   add_library(re2::re2 STATIC IMPORTED)
-  set_target_properties(re2::re2
-                        PROPERTIES IMPORTED_LOCATION "${RE2_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${RE2_PREFIX}/include")
+  set_target_properties(re2::re2 PROPERTIES IMPORTED_LOCATION "${RE2_STATIC_LIB}")
+  target_include_directories(re2::re2 BEFORE INTERFACE "${RE2_PREFIX}/include")
 
   add_dependencies(toolchain re2_ep)
   add_dependencies(re2::re2 re2_ep)
@@ -2585,10 +2581,8 @@ macro(build_bzip2)
 
   file(MAKE_DIRECTORY "${BZIP2_PREFIX}/include")
   add_library(BZip2::BZip2 STATIC IMPORTED)
-  set_target_properties(BZip2::BZip2
-                        PROPERTIES IMPORTED_LOCATION "${BZIP2_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${BZIP2_PREFIX}/include")
+  set_target_properties(BZip2::BZip2 PROPERTIES IMPORTED_LOCATION "${BZIP2_STATIC_LIB}")
+  target_include_directories(BZip2::BZip2 BEFORE INTERFACE "${BZIP2_PREFIX}/include")
   set(BZIP2_INCLUDE_DIR "${BZIP2_PREFIX}/include")
 
   add_dependencies(toolchain bzip2_ep)
@@ -2600,13 +2594,6 @@ endmacro()
 if(ARROW_WITH_BZ2)
   resolve_dependency(BZip2 PC_PACKAGE_NAMES bzip2)
 
-  if(NOT TARGET BZip2::BZip2)
-    add_library(BZip2::BZip2 UNKNOWN IMPORTED)
-    set_target_properties(BZip2::BZip2
-                          PROPERTIES IMPORTED_LOCATION "${BZIP2_LIBRARIES}"
-                                     INTERFACE_INCLUDE_DIRECTORIES "${BZIP2_INCLUDE_DIR}")
-  endif()
-
   if(${BZip2_SOURCE} STREQUAL "SYSTEM"
      AND NOT bzip2_PC_FOUND
      AND ARROW_BUILD_STATIC)
@@ -2647,9 +2634,9 @@ macro(build_utf8proc)
   add_library(utf8proc::utf8proc STATIC IMPORTED)
   set_target_properties(utf8proc::utf8proc
                         PROPERTIES IMPORTED_LOCATION "${UTF8PROC_STATIC_LIB}"
-                                   INTERFACE_COMPILE_DEFINITIONS "UTF8PROC_STATIC"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${UTF8PROC_PREFIX}/include")
+                                   INTERFACE_COMPILE_DEFINITIONS "UTF8PROC_STATIC")
+  target_include_directories(utf8proc::utf8proc BEFORE
+                             INTERFACE "${UTF8PROC_PREFIX}/include")
 
   add_dependencies(toolchain utf8proc_ep)
   add_dependencies(utf8proc::utf8proc utf8proc_ep)
@@ -2691,9 +2678,8 @@ macro(build_cares)
 
   add_dependencies(toolchain cares_ep)
   add_library(c-ares::cares STATIC IMPORTED)
-  set_target_properties(c-ares::cares
-                        PROPERTIES IMPORTED_LOCATION "${CARES_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${CARES_INCLUDE_DIR}")
+  set_target_properties(c-ares::cares PROPERTIES IMPORTED_LOCATION "${CARES_STATIC_LIB}")
+  target_include_directories(c-ares::cares BEFORE INTERFACE "${CARES_INCLUDE_DIR}")
   add_dependencies(c-ares::cares cares_ep)
 
   if(APPLE)
@@ -2904,15 +2890,14 @@ macro(build_absl)
         "${ABSL_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}absl_${_ABSL_LIB}${CMAKE_STATIC_LIBRARY_SUFFIX}"
     )
     add_library(absl::${_ABSL_LIB} STATIC IMPORTED)
-    set_target_properties(absl::${_ABSL_LIB}
-                          PROPERTIES IMPORTED_LOCATION ${_ABSL_STATIC_LIBRARY}
-                                     INTERFACE_INCLUDE_DIRECTORIES "${ABSL_INCLUDE_DIR}")
+    set_target_properties(absl::${_ABSL_LIB} PROPERTIES IMPORTED_LOCATION
+                                                        ${_ABSL_STATIC_LIBRARY})
+    target_include_directories(absl::${_ABSL_LIB} BEFORE INTERFACE "${ABSL_INCLUDE_DIR}")
     list(APPEND ABSL_BUILD_BYPRODUCTS ${_ABSL_STATIC_LIBRARY})
   endforeach()
   foreach(_ABSL_LIB ${_ABSL_INTERFACE_LIBS})
     add_library(absl::${_ABSL_LIB} INTERFACE IMPORTED)
-    set_target_properties(absl::${_ABSL_LIB} PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                                        "${ABSL_INCLUDE_DIR}")
+    target_include_directories(absl::${_ABSL_LIB} BEFORE INTERFACE "${ABSL_INCLUDE_DIR}")
   endforeach()
 
   # Extracted the dependency information using the Abseil pkg-config files:
@@ -3832,9 +3817,9 @@ macro(build_grpc)
   file(MAKE_DIRECTORY ${GRPC_INCLUDE_DIR})
 
   add_library(gRPC::upb STATIC IMPORTED)
-  set_target_properties(gRPC::upb
-                        PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_UPB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+  set_target_properties(gRPC::upb PROPERTIES IMPORTED_LOCATION
+                                             "${GRPC_STATIC_LIBRARY_UPB}")
+  target_include_directories(gRPC::upb BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   set(GRPC_GPR_ABSL_LIBRARIES
       # We need a flattened list of Abseil libraries for the static linking case,
@@ -3895,20 +3880,21 @@ macro(build_grpc)
   add_library(gRPC::gpr STATIC IMPORTED)
   set_target_properties(gRPC::gpr
                         PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GPR}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}"
                                    INTERFACE_LINK_LIBRARIES "${GRPC_GPR_ABSL_LIBRARIES}")
+  target_include_directories(gRPC::gpr BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::address_sorting STATIC IMPORTED)
   set_target_properties(gRPC::address_sorting
                         PROPERTIES IMPORTED_LOCATION
-                                   "${GRPC_STATIC_LIBRARY_ADDRESS_SORTING}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+                                   "${GRPC_STATIC_LIBRARY_ADDRESS_SORTING}")
+  target_include_directories(gRPC::address_sorting BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::grpc++_reflection STATIC IMPORTED)
   set_target_properties(gRPC::grpc++_reflection
                         PROPERTIES IMPORTED_LOCATION
-                                   "${GRPC_STATIC_LIBRARY_GRPCPP_REFLECTION}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+                                   "${GRPC_STATIC_LIBRARY_GRPCPP_REFLECTION}")
+  target_include_directories(gRPC::grpc++_reflection BEFORE
+                             INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::grpc STATIC IMPORTED)
   set(GRPC_LINK_LIBRARIES
@@ -3922,15 +3908,15 @@ macro(build_grpc)
       Threads::Threads)
   set_target_properties(gRPC::grpc
                         PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GRPC}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}"
                                    INTERFACE_LINK_LIBRARIES "${GRPC_LINK_LIBRARIES}")
+  target_include_directories(gRPC::grpc BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::grpc++ STATIC IMPORTED)
   set(GRPCPP_LINK_LIBRARIES gRPC::grpc ${ARROW_PROTOBUF_LIBPROTOBUF})
   set_target_properties(gRPC::grpc++
                         PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GRPCPP}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}"
                                    INTERFACE_LINK_LIBRARIES "${GRPCPP_LINK_LIBRARIES}")
+  target_include_directories(gRPC::grpc++ BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_executable(gRPC::grpc_cpp_plugin IMPORTED)
   set_target_properties(gRPC::grpc_cpp_plugin PROPERTIES IMPORTED_LOCATION
@@ -4047,10 +4033,9 @@ macro(build_crc32c_once)
     # Work around https://gitlab.kitware.com/cmake/cmake/issues/15052
     file(MAKE_DIRECTORY "${CRC32C_INCLUDE_DIR}")
     add_library(Crc32c::crc32c STATIC IMPORTED)
-    set_target_properties(Crc32c::crc32c
-                          PROPERTIES IMPORTED_LOCATION ${_CRC32C_STATIC_LIBRARY}
-                                     INTERFACE_INCLUDE_DIRECTORIES
-                                     "${CRC32C_INCLUDE_DIR}")
+    set_target_properties(Crc32c::crc32c PROPERTIES IMPORTED_LOCATION
+                                                    ${_CRC32C_STATIC_LIBRARY})
+    target_include_directories(Crc32c::crc32c BEFORE INTERFACE "${CRC32C_INCLUDE_DIR}")
     add_dependencies(Crc32c::crc32c crc32c_ep)
   endif()
 endmacro()
@@ -4078,9 +4063,8 @@ macro(build_nlohmann_json)
   file(MAKE_DIRECTORY ${NLOHMANN_JSON_INCLUDE_DIR})
 
   add_library(nlohmann_json::nlohmann_json INTERFACE IMPORTED)
-  set_target_properties(nlohmann_json::nlohmann_json
-                        PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                   "${NLOHMANN_JSON_INCLUDE_DIR}")
+  target_include_directories(nlohmann_json::nlohmann_json BEFORE
+                             INTERFACE "${NLOHMANN_JSON_INCLUDE_DIR}")
   add_dependencies(nlohmann_json::nlohmann_json nlohmann_json_ep)
 endmacro()
 if(ARROW_WITH_NLOHMANN_JSON)
@@ -4189,9 +4173,9 @@ macro(build_google_cloud_cpp_storage)
   add_library(google-cloud-cpp::common STATIC IMPORTED)
   set_target_properties(google-cloud-cpp::common
                         PROPERTIES IMPORTED_LOCATION
-                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_COMMON}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
+                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_COMMON}")
+  target_include_directories(google-cloud-cpp::common BEFORE
+                             INTERFACE "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
   # Refer to https://github.com/googleapis/google-cloud-cpp/blob/main/google/cloud/google_cloud_cpp_common.cmake
   # (subsitute `main` for the SHA of the version we use)
   # Version 1.39.0 is at a different place (they refactored after):
@@ -4211,9 +4195,9 @@ macro(build_google_cloud_cpp_storage)
   add_library(google-cloud-cpp::rest-internal STATIC IMPORTED)
   set_target_properties(google-cloud-cpp::rest-internal
                         PROPERTIES IMPORTED_LOCATION
-                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_REST_INTERNAL}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
+                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_REST_INTERNAL}")
+  target_include_directories(google-cloud-cpp::rest-internal BEFORE
+                             INTERFACE "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
   set_property(TARGET google-cloud-cpp::rest-internal
                PROPERTY INTERFACE_LINK_LIBRARIES
                         absl::span
@@ -4226,9 +4210,9 @@ macro(build_google_cloud_cpp_storage)
   add_library(google-cloud-cpp::storage STATIC IMPORTED)
   set_target_properties(google-cloud-cpp::storage
                         PROPERTIES IMPORTED_LOCATION
-                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_STORAGE}"
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
+                                   "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_STORAGE}")
+  target_include_directories(google-cloud-cpp::storage BEFORE
+                             INTERFACE "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
   # Update this from https://github.com/googleapis/google-cloud-cpp/blob/main/google/cloud/storage/google_cloud_cpp_storage.cmake
   set_property(TARGET google-cloud-cpp::storage
                PROPERTY INTERFACE_LINK_LIBRARIES
@@ -4389,9 +4373,8 @@ macro(build_orc)
   set(ORC_VENDORED 1)
 
   add_library(orc::liborc STATIC IMPORTED)
-  set_target_properties(orc::liborc
-                        PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${ORC_INCLUDE_DIR}")
+  set_target_properties(orc::liborc PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}")
+  target_include_directories(orc::liborc BEFORE INTERFACE "${ORC_INCLUDE_DIR}")
   set(ORC_LINK_LIBRARIES LZ4::lz4 ZLIB::ZLIB ${ARROW_ZSTD_LIBZSTD} ${Snappy_TARGET})
   # Protobuf generated files may use ABSL_DCHECK*() and
   # absl::log_internal_check_op is needed for them.
@@ -4450,9 +4433,8 @@ macro(build_opentelemetry)
 
   foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_APIS})
     add_library(opentelemetry-cpp::${_OPENTELEMETRY_LIB} INTERFACE IMPORTED)
-    set_target_properties(opentelemetry-cpp::${_OPENTELEMETRY_LIB}
-                          PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                     "${OPENTELEMETRY_INCLUDE_DIR}")
+    target_include_directories(opentelemetry-cpp::${_OPENTELEMETRY_LIB} BEFORE
+                               INTERFACE "${OPENTELEMETRY_INCLUDE_DIR}")
   endforeach()
   foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_LIBS})
     # N.B. OTel targets and libraries don't follow any consistent naming scheme
@@ -4744,15 +4726,15 @@ macro(build_awssdk)
       set(_AWSSDK_TARGET_NAME AWS::${_AWSSDK_LIB})
     endif()
     add_library(${_AWSSDK_TARGET_NAME} STATIC IMPORTED)
-    set_target_properties(${_AWSSDK_TARGET_NAME}
-                          PROPERTIES IMPORTED_LOCATION ${_AWSSDK_STATIC_LIBRARY}
-                                     INTERFACE_INCLUDE_DIRECTORIES
-                                     "${AWSSDK_INCLUDE_DIR}")
+    set_target_properties(${_AWSSDK_TARGET_NAME} PROPERTIES IMPORTED_LOCATION
+                                                            ${_AWSSDK_STATIC_LIBRARY})
+    target_include_directories(${_AWSSDK_TARGET_NAME} BEFORE
+                               INTERFACE "${AWSSDK_INCLUDE_DIR}")
     if(${_AWSSDK_LIB} STREQUAL "aws-lc")
-      set_target_properties(${_AWSSDK_TARGET_NAME}
-                            PROPERTIES IMPORTED_LOCATION ${_AWSSDK_STATIC_LIBRARY}
-                                       INTERFACE_INCLUDE_DIRECTORIES
-                                       "${AWS_LC_INCLUDE_DIR}")
+      set_target_properties(${_AWSSDK_TARGET_NAME} PROPERTIES IMPORTED_LOCATION
+                                                              ${_AWSSDK_STATIC_LIBRARY})
+      target_include_directories(${_AWSSDK_TARGET_NAME} BEFORE
+                                 INTERFACE "${AWS_LC_INCLUDE_DIR}")
     endif()
     set("${_AWSSDK_LIB_NAME_PREFIX}_STATIC_LIBRARY" ${_AWSSDK_STATIC_LIBRARY})
 

From c0c56e8e1440d38b5099e4e3aaed989a0bdebeaa Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 11 Sep 2023 09:15:19 +0900
Subject: [PATCH 345/749] GH-37535: [C++][Parquet] Add missing "thrift"
 dependency in parquet.pc (#37603)

### Rationale for this change

GH-37399 removed "thrift" pkg-config package dependency from "parquet" pkg-config package accidentally.
Before GH-37399, "arrow" pkg-config packages has "thrift" pkg-config package dependency as `Requires.private`.

### What changes are included in this PR?

Add "thrift" to `Requires.private` of `parquet.pc`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37535

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakeLists.txt             |  3 ++
 cpp/src/parquet/CMakeLists.txt | 11 +++++
 cpp/src/parquet/parquet.pc.in  |  6 +--
 r/configure                    | 77 ++++++++++++++++++++++------------
 4 files changed, 68 insertions(+), 29 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index d343de836e528..f2906b960eba6 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -533,6 +533,9 @@ set(ARROW_TESTING_PC_LIBS "")
 set(ARROW_TESTING_PC_REQUIRES "")
 
 # For parquet.pc.
+set(PARQUET_PC_CFLAGS "")
+set(PARQUET_PC_CFLAGS_PRIVATE " -DPARQUET_STATIC")
+set(PARQUET_PC_REQUIRES "")
 set(PARQUET_PC_REQUIRES_PRIVATE "")
 
 include(ThirdpartyToolchain)
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index 8ffeab4dfbeab..3cdd24dbe9eb9 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -21,6 +21,17 @@ add_custom_target(parquet-benchmarks)
 add_custom_target(parquet-tests)
 add_dependencies(parquet-all parquet parquet-tests parquet-benchmarks)
 
+# If libparquet.a is only built, "pkg-config --cflags --libs parquet"
+# outputs build flags for static linking not shared
+# linking. PARQUET_PC_* except PARQUET_PC_*_PRIVATE are for the static
+# linking case.
+if(NOT ARROW_BUILD_SHARED AND ARROW_BUILD_STATIC)
+  string(APPEND PARQUET_PC_CFLAGS "${PARQUET_PC_CFLAGS_PRIVATE}")
+  set(PARQUET_PC_CFLAGS_PRIVATE "")
+  string(APPEND PARQUET_PC_REQUIRES "${PARQUET_PC_REQUIRES_PRIVATE}")
+  set(PARQUET_PC_REQUIRES_PRIVATE "")
+endif()
+
 function(ADD_PARQUET_TEST REL_TEST_NAME)
   set(one_value_args)
   set(multi_value_args EXTRA_DEPENDENCIES LABELS)
diff --git a/cpp/src/parquet/parquet.pc.in b/cpp/src/parquet/parquet.pc.in
index 6def1c5d8b399..d7a0389c5f187 100644
--- a/cpp/src/parquet/parquet.pc.in
+++ b/cpp/src/parquet/parquet.pc.in
@@ -26,8 +26,8 @@ full_so_version=@ARROW_FULL_SO_VERSION@
 Name: Apache Parquet
 Description: Apache Parquet is a columnar storage format.
 Version: @ARROW_VERSION@
-Requires: arrow
+Requires: arrow@PARQUET_PC_REQUIRES@
 Requires.private:@PARQUET_PC_REQUIRES_PRIVATE@
 Libs: -L${libdir} -lparquet
-Cflags: -I${includedir}
-Cflags.private: -DPARQUET_STATIC
+Cflags: -I${includedir}@PARQUET_PC_CFLAGS@
+Cflags.private:@PARQUET_PC_CFLAGS_PRIVATE@
diff --git a/r/configure b/r/configure
index 0586cbe071007..593f60bbddad9 100755
--- a/r/configure
+++ b/r/configure
@@ -278,6 +278,16 @@ do_autobrew () {
 # Once libarrow is obtained, this function sets `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS`
 # either from pkg-config or by inferring things about the directory in $1
 set_pkg_vars () {
+  if [ "$PKG_CONFIG_AVAILABLE" = "true" ]; then
+    set_lib_dir_with_pc
+  else
+    set_lib_dir_without_pc $1
+  fi
+
+  # Check cmake options for enabled features. This uses LIB_DIR that
+  # is set by the above set_lib_dir_* call.
+  add_feature_flags
+
   if [ "$PKG_CONFIG_AVAILABLE" = "true" ]; then
     set_pkg_vars_with_pc
   else
@@ -288,23 +298,27 @@ set_pkg_vars () {
   if [ "$ARROW_R_CXXFLAGS" ]; then
     PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"
   fi
-
-  # Finally, check cmake options for enabled features
-  add_feature_flags
 }
 
 # If we have pkg-config, it will tell us what libarrow needs
-set_pkg_vars_with_pc () {
+set_lib_dir_with_pc () {
   LIB_DIR="`${PKG_CONFIG} --variable=libdir --silence-errors ${PKG_CONFIG_NAME}`"
-  PKG_CFLAGS="`${PKG_CONFIG} --cflags --silence-errors ${PKG_CONFIG_NAME}` $PKG_CFLAGS"
-  PKG_LIBS=`${PKG_CONFIG} --libs-only-l --libs-only-other --silence-errors ${PKG_CONFIG_NAME}`
-  PKG_DIRS=`${PKG_CONFIG} --libs-only-L --silence-errors ${PKG_CONFIG_NAME}`
+}
+set_pkg_vars_with_pc () {
+  pkg_config_names="${PKG_CONFIG_NAME} ${PKG_CONFIG_NAMES_FEATURES}"
+  PKG_CFLAGS="`${PKG_CONFIG} --cflags --silence-errors ${pkg_config_names}` $PKG_CFLAGS"
+  PKG_CFLAGS="$PKG_CFLAGS $PKG_CFLAGS_FEATURES"
+  PKG_LIBS=`${PKG_CONFIG} --libs-only-l --libs-only-other --silence-errors ${pkg_config_names}`
+  PKG_LIBS="$PKG_LIBS $PKG_LIBS_FEATURES"
+  PKG_DIRS=`${PKG_CONFIG} --libs-only-L --silence-errors ${pkg_config_names}`
 }
 
 # If we don't have pkg-config, we can make some inferences
-set_pkg_vars_without_pc () {
+set_lib_dir_without_pc () {
   LIB_DIR="$1/lib"
-  PKG_CFLAGS="-I$1/include $PKG_CFLAGS"
+}
+set_pkg_vars_without_pc () {
+  PKG_CFLAGS="-I$1/include $PKG_CFLAGS $PKG_CFLAGS_FEATURES"
   if grep -q "_GLIBCXX_USE_CXX11_ABI=0" "${LIB_DIR}/pkgconfig/arrow.pc"; then
     PKG_CFLAGS="${PKG_CFLAGS} -D_GLIBCXX_USE_CXX11_ABI=0"
   fi
@@ -312,10 +326,12 @@ set_pkg_vars_without_pc () {
   if [ "${OPENSSL_ROOT_DIR}" != "" ]; then
     PKG_DIRS="${PKG_DIRS} -L${OPENSSL_ROOT_DIR}/lib"
   fi
-  PKG_LIBS="-larrow"
+  PKG_LIBS="$PKG_LIBS_FEATURES_WITHOUT_PC"
+  PKG_LIBS="$PKG_LIBS -larrow"
   if [ -n "$(find "$LIB_DIR" -name 'libarrow_bundled_dependencies.*')" ]; then
     PKG_LIBS="$PKG_LIBS -larrow_bundled_dependencies"
   fi
+  PKG_LIBS="$PKG_LIBS $PKG_LIBS_FEATURES"
 
   # If on Raspberry Pi, need to manually link against latomic
   # See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81358 for similar example
@@ -327,6 +343,11 @@ set_pkg_vars_without_pc () {
 }
 
 add_feature_flags () {
+  PKG_CFLAGS_FEATURES=""
+  PKG_CONFIG_NAMES_FEATURES=""
+  PKG_LIBS_FEATURES=""
+  PKG_LIBS_FEATURES_WITHOUT_PC=""
+
   # Now we need to check what features it was built with and enable
   # the corresponding feature flags in the R bindings (-DARROW_R_WITH_stuff).
   # We do this by inspecting ArrowOptions.cmake, which the libarrow build
@@ -336,39 +357,43 @@ add_feature_flags () {
     echo "*** $ARROW_OPTS_CMAKE not found; some features will not be enabled"
   else
     if arrow_built_with ARROW_PARQUET; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_PARQUET"
-      PKG_LIBS="-lparquet $PKG_LIBS"
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_PARQUET"
+      PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES parquet"
+      PKG_LIBS_FEATURES_WITHOUT_PC="-lparquet $PKG_LIBS_FEATURES_WITHOUT_PC"
       # NOTE: parquet is assumed to have the same -L flag as arrow
       # so there is no need to add its location to PKG_DIRS
     fi
     if arrow_built_with ARROW_DATASET; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_DATASET"
-      PKG_LIBS="-larrow_dataset $PKG_LIBS"
-      # NOTE: arrow-dataset is assumed to have the same -L flag as arrow
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_DATASET"
+      PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-dataset"
+      PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_dataset $PKG_LIBS_FEATURES_WITHOUT_PC"
+      # NOTE: arrow_dataset is assumed to have the same -L flag as arrow
       # so there is no need to add its location to PKG_DIRS
     fi
     if arrow_built_with ARROW_ACERO; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_ACERO"
-      PKG_LIBS="-larrow_acero $PKG_LIBS"
-      # NOTE: arrow-acero is assumed to have the same -L flag as arrow
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_ACERO"
+      PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-acero"
+      PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_acero $PKG_LIBS_FEATURES_WITHOUT_PC"
+      # NOTE: arrow_acero is assumed to have the same -L flag as arrow
       # so there is no need to add its location to PKG_DIRS
     fi
     if arrow_built_with ARROW_SUBSTRAIT; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_SUBSTRAIT"
-      PKG_LIBS="-larrow_substrait $PKG_LIBS"
-      # NOTE: arrow-substrait is assumed to have the same -L flag as arrow
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_SUBSTRAIT"
+      PKG_CONFIG_NAMES_FEATURES="$PKG_CONFIG_NAMES_FEATURES arrow-substrait"
+      PKG_LIBS_FEATURES_WITHOUT_PC="-larrow_substrait $PKG_LIBS_FEATURES_WITHOUT_PC"
+      # NOTE: arrow_substrait is assumed to have the same -L flag as arrow
       # so there is no need to add its location to PKG_DIRS
     fi
     if arrow_built_with ARROW_JSON; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_JSON"
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_JSON"
     fi
     if arrow_built_with ARROW_S3; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_S3"
-      PKG_LIBS="$PKG_LIBS $S3_LIBS"
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_S3"
+      PKG_LIBS_FEATURES="$PKG_LIBS_FEATURES $S3_LIBS"
     fi
     if arrow_built_with ARROW_GCS; then
-      PKG_CFLAGS="$PKG_CFLAGS -DARROW_R_WITH_GCS"
-      PKG_LIBS="$PKG_LIBS $GCS_LIBS"
+      PKG_CFLAGS_FEATURES="$PKG_CFLAGS_FEATURES -DARROW_R_WITH_GCS"
+      PKG_LIBS_FEATURES="$PKG_LIBS_FEATURES $GCS_LIBS"
     fi
   fi
 }

From e56726c161df1d588f2f6197dbdd0c0011f14855 Mon Sep 17 00:00:00 2001
From: takuya kodama <a.s.takuya1026@gmail.com>
Date: Mon, 11 Sep 2023 13:04:22 +0800
Subject: [PATCH 346/749] GH-37562: [Ruby] Add support for
 table.each_raw_record.to_a (#37600)

### Rationale for this change

This change aligns the behavior of `each_raw_record` with standard Ruby practices by returning an enumerator when no block is provided

### What changes are included in this PR?

- Made `Arrow::Table#each_raw_record` and `Arrow::RecordBatch#each_raw_record` return Enumerator when it was called without block.
- Added related tests
- Resolved warnings related to duplicate test classes which were caused by #37137

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No

* Closes: #37562

Authored-by: otegami <a.s.takuya1026@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ruby/red-arrow/ext/arrow/raw-records.cpp      |   4 +-
 .../test/each-raw-record/test-basic-arrays.rb | 180 +++------------
 .../each-raw-record/test-dense-union-array.rb | 210 +++--------------
 .../each-raw-record/test-dictionary-array.rb  | 176 +++-----------
 .../test/each-raw-record/test-list-array.rb   | 213 +++--------------
 .../test/each-raw-record/test-map-array.rb    | 210 +++--------------
 .../each-raw-record/test-multiple-columns.rb  |  12 +-
 .../test-sparse-union-array.rb                | 208 +++--------------
 .../test/each-raw-record/test-struct-array.rb | 218 ++++--------------
 .../test/each-raw-record/test-table.rb        |   6 +-
 10 files changed, 247 insertions(+), 1190 deletions(-)

diff --git a/ruby/red-arrow/ext/arrow/raw-records.cpp b/ruby/red-arrow/ext/arrow/raw-records.cpp
index 0043ca3aaf2cc..bbe421971d11a 100644
--- a/ruby/red-arrow/ext/arrow/raw-records.cpp
+++ b/ruby/red-arrow/ext/arrow/raw-records.cpp
@@ -305,9 +305,10 @@ namespace red_arrow {
   }
 
   VALUE
-  record_batch_each_raw_record(VALUE rb_record_batch){
+  record_batch_each_raw_record(VALUE rb_record_batch) {
     auto garrow_record_batch = GARROW_RECORD_BATCH(RVAL2GOBJ(rb_record_batch));
     auto record_batch = garrow_record_batch_get_raw(garrow_record_batch).get();
+    RETURN_SIZED_ENUMERATOR(rb_record_batch, 0, nullptr, record_batch->num_rows());
 
     try {
       RawRecordsProducer producer;
@@ -323,6 +324,7 @@ namespace red_arrow {
   table_each_raw_record(VALUE rb_table) {
     auto garrow_table = GARROW_TABLE(RVAL2GOBJ(rb_table));
     auto table = garrow_table_get_raw(garrow_table).get();
+    RETURN_SIZED_ENUMERATOR(rb_table, 0, nullptr, table->num_rows());
 
     try {
       RawRecordsProducer producer;
diff --git a/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb b/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
index dbbbd79ee0acb..d32031dec4ec0 100644
--- a/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-basic-arrays.rb
@@ -22,12 +22,8 @@ def test_null
       [nil],
       [nil],
     ]
-    iterated_records = []
     target = build({column: :null}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -36,12 +32,8 @@ def test_boolean
       [nil],
       [false],
     ]
-    iterated_records = []
     target = build({column: :boolean}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -50,12 +42,8 @@ def test_int8
       [nil],
       [(2 ** 7) - 1],
     ]
-    iterated_records = []
     target = build({column: :int8}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -64,12 +52,8 @@ def test_uint8
       [nil],
       [(2 ** 8) - 1],
     ]
-    iterated_records = []
     target = build({column: :uint8}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -78,12 +62,8 @@ def test_int16
       [nil],
       [(2 ** 15) - 1],
     ]
-    iterated_records = []
     target = build({column: :int16}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -92,12 +72,8 @@ def test_uint16
       [nil],
       [(2 ** 16) - 1],
     ]
-    iterated_records = []
     target = build({column: :uint16}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -106,12 +82,8 @@ def test_int32
       [nil],
       [(2 ** 31) - 1],
     ]
-    iterated_records = []
     target = build({column: :int32}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -120,12 +92,8 @@ def test_uint32
       [nil],
       [(2 ** 32) - 1],
     ]
-    iterated_records = []
     target = build({column: :uint32}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -134,12 +102,8 @@ def test_int64
       [nil],
       [(2 ** 63) - 1],
     ]
-    iterated_records = []
     target = build({column: :int64}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -148,12 +112,8 @@ def test_uint64
       [nil],
       [(2 ** 64) - 1],
     ]
-    iterated_records = []
     target = build({column: :uint64}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_half_float
@@ -162,12 +122,8 @@ def test_half_float
       [nil],
       [1.5],
     ]
-    iterated_records = []
     target = build({column: :half_float}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_float
@@ -176,12 +132,8 @@ def test_float
       [nil],
       [1.0],
     ]
-    iterated_records = []
     target = build({column: :float}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_double
@@ -190,12 +142,8 @@ def test_double
       [nil],
       [1.0],
     ]
-    iterated_records = []
     target = build({column: :double}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -204,12 +152,8 @@ def test_binary
       [nil],
       ["\xff".b],
     ]
-    iterated_records = []
     target = build({column: :binary}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_string
@@ -218,12 +162,8 @@ def test_string
       [nil],
       ["\u3042"], # U+3042 HIRAGANA LETTER A
     ]
-    iterated_records = []
     target = build({column: :string}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -232,12 +172,8 @@ def test_date32
       [nil],
       [Date.new(2017, 8, 23)],
     ]
-    iterated_records = []
     target = build({column: :date32}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -246,12 +182,8 @@ def test_date64
       [nil],
       [DateTime.new(2017, 8, 23, 14, 57, 2)],
     ]
-    iterated_records = []
     target = build({column: :date64}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -260,7 +192,6 @@ def test_timestamp_second
       [nil],
       [Time.parse("2017-08-23T14:57:02Z")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :timestamp,
@@ -268,10 +199,7 @@ def test_timestamp_second
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -280,7 +208,6 @@ def test_timestamp_milli
       [nil],
       [Time.parse("2017-08-23T14:57:02.987Z")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :timestamp,
@@ -288,10 +215,7 @@ def test_timestamp_milli
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -300,7 +224,6 @@ def test_timestamp_micro
       [nil],
       [Time.parse("2017-08-23T14:57:02.987654Z")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :timestamp,
@@ -308,10 +231,7 @@ def test_timestamp_micro
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -320,7 +240,6 @@ def test_timestamp_nano
       [nil],
       [Time.parse("2017-08-23T14:57:02.987654321Z")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :timestamp,
@@ -328,10 +247,7 @@ def test_timestamp_nano
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -341,7 +257,6 @@ def test_time32_second
       [nil],
       [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :time32,
@@ -349,10 +264,7 @@ def test_time32_second
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -362,7 +274,6 @@ def test_time32_milli
       [nil],
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :time32,
@@ -370,10 +281,7 @@ def test_time32_milli
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -385,7 +293,6 @@ def test_time64_micro
       # 02:00:09.987654
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :time64,
@@ -393,10 +300,7 @@ def test_time64_micro
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -408,7 +312,6 @@ def test_time64_nano
       # 02:00:09.987654321
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :time64,
@@ -416,10 +319,7 @@ def test_time64_nano
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -428,7 +328,6 @@ def test_decimal128
       [nil],
       [BigDecimal("29.29")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :decimal128,
@@ -437,10 +336,7 @@ def test_decimal128
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -449,7 +345,6 @@ def test_decimal256
       [nil],
       [BigDecimal("29.29")],
     ]
-    iterated_records = []
     target = build({
                      column: {
                        type: :decimal256,
@@ -458,10 +353,7 @@ def test_decimal256
                      }
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -470,12 +362,8 @@ def test_month_interval
       [nil],
       [12],
     ]
-    iterated_records = []
     target = build({column: :month_interval}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -484,12 +372,8 @@ def test_day_time_interval
       [nil],
       [{day: 2, millisecond: 300}],
     ]
-    iterated_records = []
     target = build({column: :day_time_interval}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -498,12 +382,8 @@ def test_month_day_nano_interval
       [nil],
       [{month: 2, day: 3, nanosecond: 400}],
     ]
-    iterated_records = []
     target = build({column: :month_day_nano_interval}, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb b/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
index 7c784cccde3a1..b75ce4b4e00d5 100644
--- a/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-dense-union-array.rb
@@ -92,13 +92,9 @@ def test_null
     records = [
       [{"0" => nil}],
     ]
-    iterated_records = []
     target = build(:null, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -106,13 +102,9 @@ def test_boolean
       [{"0" => true}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:boolean, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -120,13 +112,9 @@ def test_int8
       [{"0" => -(2 ** 7)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -134,13 +122,9 @@ def test_uint8
       [{"0" => (2 ** 8) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -148,13 +132,9 @@ def test_int16
       [{"0" => -(2 ** 15)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -162,13 +142,9 @@ def test_uint16
       [{"0" => (2 ** 16) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -176,13 +152,9 @@ def test_int32
       [{"0" => -(2 ** 31)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -190,13 +162,9 @@ def test_uint32
       [{"0" => (2 ** 32) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -204,13 +172,9 @@ def test_int64
       [{"0" => -(2 ** 63)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -218,13 +182,9 @@ def test_uint64
       [{"0" => (2 ** 64) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_float
@@ -232,13 +192,9 @@ def test_float
       [{"0" => -1.0}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:float, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_double
@@ -246,13 +202,9 @@ def test_double
       [{"0" => -1.0}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:double, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -260,13 +212,9 @@ def test_binary
       [{"0" => "\xff".b}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:binary, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_string
@@ -274,13 +222,9 @@ def test_string
       [{"0" => "Ruby"}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:string, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -288,13 +232,9 @@ def test_date32
       [{"0" => Date.new(1960, 1, 1)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:date32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 target.raw_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -302,13 +242,9 @@ def test_date64
       [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:date64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -316,17 +252,13 @@ def test_timestamp_second
       [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -334,17 +266,13 @@ def test_timestamp_milli
       [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -352,17 +280,13 @@ def test_timestamp_micro
       [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -370,17 +294,13 @@ def test_timestamp_nano
       [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -390,17 +310,13 @@ def test_time32_second
       [{"0" => Arrow::Time.new(unit, 60 * 10)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -410,17 +326,13 @@ def test_time32_milli
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -430,17 +342,13 @@ def test_time64_micro
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -450,17 +358,13 @@ def test_time64_nano
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -468,18 +372,14 @@ def test_decimal128
       [{"0" => BigDecimal("92.92")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal128,
                      precision: 8,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -487,18 +387,14 @@ def test_decimal256
       [{"0" => BigDecimal("92.92")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal256,
                      precision: 38,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -506,13 +402,9 @@ def test_month_interval
       [{"0" => 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:month_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -520,13 +412,9 @@ def test_day_time_interval
       [{"0" => {day: 1, millisecond: 100}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:day_time_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -534,13 +422,9 @@ def test_month_day_nano_interval
       [{"0" => {month: 1, day: 1, nanosecond: 100}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:month_day_nano_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_list
@@ -548,7 +432,6 @@ def test_list
       [{"0" => [true, nil, false]}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :list,
                      field: {
@@ -557,11 +440,8 @@ def test_list
                      },
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_struct
@@ -570,7 +450,6 @@ def test_struct
       [{"1" => nil}],
       [{"0" => {"sub_field" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :struct,
                      fields: [
@@ -581,11 +460,8 @@ def test_struct
                      ],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_map
@@ -593,18 +469,14 @@ def test_map
       [{"0" => {"key1" => true, "key2" => nil}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :map,
                      key: :string,
                      item: :boolean,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_sparse_union
@@ -614,7 +486,6 @@ def test_sparse_union
       [{"0" => {"field2" => 29}}],
       [{"0" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :sparse_union,
                      fields: [
@@ -630,11 +501,8 @@ def test_sparse_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(remove_field_names(records)),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dense_union
@@ -644,7 +512,6 @@ def test_dense_union
       [{"0" => {"field2" => 29}}],
       [{"0" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :dense_union,
                      fields: [
@@ -660,11 +527,8 @@ def test_dense_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(remove_field_names(records)),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dictionary
@@ -673,7 +537,6 @@ def test_dictionary
       [{"1" => nil}],
       [{"0" => "GLib"}],
     ]
-    iterated_records = []
     target = build({
                      type: :dictionary,
                      index_data_type: :int8,
@@ -681,11 +544,8 @@ def test_dictionary
                      ordered: false,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb b/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
index edc6c33cc091d..f85294b30aab8 100644
--- a/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-dictionary-array.rb
@@ -29,12 +29,8 @@ def test_null
       [nil],
       [nil],
     ]
-    iterated_records = []
     target = build(Arrow::NullArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -43,12 +39,8 @@ def test_boolean
       [nil],
       [false],
     ]
-    iterated_records = []
     target = build(Arrow::BooleanArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -57,12 +49,8 @@ def test_int8
       [nil],
       [(2 ** 7) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::Int8Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -71,12 +59,8 @@ def test_uint8
       [nil],
       [(2 ** 8) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::UInt8Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -85,12 +69,8 @@ def test_int16
       [nil],
       [(2 ** 15) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::Int16Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -99,12 +79,8 @@ def test_uint16
       [nil],
       [(2 ** 16) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::UInt16Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -113,12 +89,8 @@ def test_int32
       [nil],
       [(2 ** 31) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::Int32Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -127,12 +99,8 @@ def test_uint32
       [nil],
       [(2 ** 32) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::UInt32Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -141,12 +109,8 @@ def test_int64
       [nil],
       [(2 ** 63) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::Int64Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -155,12 +119,8 @@ def test_uint64
       [nil],
       [(2 ** 64) - 1],
     ]
-    iterated_records = []
     target = build(Arrow::UInt64Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_float
@@ -169,12 +129,8 @@ def test_float
       [nil],
       [1.0],
     ]
-    iterated_records = []
     target = build(Arrow::FloatArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_double
@@ -183,12 +139,8 @@ def test_double
       [nil],
       [1.0],
     ]
-    iterated_records = []
     target = build(Arrow::DoubleArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -197,12 +149,8 @@ def test_binary
       [nil],
       ["\xff".b],
     ]
-    iterated_records = []
     target = build(Arrow::BinaryArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_string
@@ -211,12 +159,8 @@ def test_string
       [nil],
       ["\u3042"], # U+3042 HIRAGANA LETTER A
     ]
-    iterated_records = []
-    target = build(Arrow::StringArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    target = build(Arrow::StringArray.new(records.collect(&:first)))    
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -225,12 +169,8 @@ def test_date32
       [nil],
       [Date.new(2017, 8, 23)],
     ]
-    iterated_records = []
     target = build(Arrow::Date32Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -239,12 +179,8 @@ def test_date64
       [nil],
       [DateTime.new(2017, 8, 23, 14, 57, 2)],
     ]
-    iterated_records = []
     target = build(Arrow::Date64Array.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -253,12 +189,8 @@ def test_timestamp_second
       [nil],
       [Time.parse("2017-08-23T14:57:02Z")],
     ]
-    iterated_records = []
     target = build(Arrow::TimestampArray.new(:second, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -267,12 +199,8 @@ def test_timestamp_milli
       [nil],
       [Time.parse("2017-08-23T14:57:02.987Z")],
     ]
-    iterated_records = []
     target = build(Arrow::TimestampArray.new(:milli, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -281,12 +209,8 @@ def test_timestamp_micro
       [nil],
       [Time.parse("2017-08-23T14:57:02.987654Z")],
     ]
-    iterated_records = []
     target = build(Arrow::TimestampArray.new(:micro, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -295,12 +219,8 @@ def test_timestamp_nano
       [nil],
       [Time.parse("2017-08-23T14:57:02.987654321Z")],
     ]
-    iterated_records = []
     target = build(Arrow::TimestampArray.new(:nano, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -310,12 +230,8 @@ def test_time32_second
       [nil],
       [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
     ]
-    iterated_records = []
     target = build(Arrow::Time32Array.new(unit, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -325,12 +241,8 @@ def test_time32_milli
       [nil],
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
     ]
-    iterated_records = []
     target = build(Arrow::Time32Array.new(unit, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -342,12 +254,8 @@ def test_time64_micro
       # 02:00:09.987654
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
     ]
-    iterated_records = []
     target = build(Arrow::Time64Array.new(unit, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -359,12 +267,8 @@ def test_time64_nano
       # 02:00:09.987654321
       [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
     ]
-    iterated_records = []
     target = build(Arrow::Time64Array.new(unit, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -373,13 +277,9 @@ def test_decimal128
       [nil],
       [BigDecimal("29.29")],
     ]
-    iterated_records = []
     data_type = Arrow::Decimal128DataType.new(8, 2)
     target = build(Arrow::Decimal128Array.new(data_type, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -388,13 +288,9 @@ def test_decimal256
       [nil],
       [BigDecimal("29.29")],
     ]
-    iterated_records = []
     data_type = Arrow::Decimal256DataType.new(38, 2)
     target = build(Arrow::Decimal256Array.new(data_type, records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, target.raw_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -403,12 +299,8 @@ def test_month_interval
       [nil],
       [12],
     ]
-    iterated_records = []
     target = build(Arrow::MonthIntervalArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -417,12 +309,8 @@ def test_day_time_interval
       [nil],
       [{day: 2, millisecond: 300}],
     ]
-    iterated_records = []
     target = build(Arrow::DayTimeIntervalArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -431,12 +319,8 @@ def test_month_day_nano_interval
       [nil],
       [{month: 2, day: 3, nanosecond: 400}],
     ]
-    iterated_records = []
     target = build(Arrow::MonthDayNanoIntervalArray.new(records.collect(&:first)))
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-list-array.rb b/ruby/red-arrow/test/each-raw-record/test-list-array.rb
index 64cc5839bd757..f6f92abf6679e 100644
--- a/ruby/red-arrow/test/each-raw-record/test-list-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-list-array.rb
@@ -38,12 +38,8 @@ def test_null
       [[nil, nil, nil]],
       [nil],
     ]
-    iterated_records = []
     target = build(:null, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -51,12 +47,8 @@ def test_boolean
       [[true, nil, false]],
       [nil],
     ]
-    iterated_records = []
     target = build(:boolean, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -64,12 +56,8 @@ def test_int8
       [[-(2 ** 7), nil, (2 ** 7) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:int8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -77,12 +65,8 @@ def test_uint8
       [[0, nil, (2 ** 8) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -90,12 +74,8 @@ def test_int16
       [[-(2 ** 15), nil, (2 ** 15) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:int16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -103,12 +83,8 @@ def test_uint16
       [[0, nil, (2 ** 16) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -116,12 +92,8 @@ def test_int32
       [[-(2 ** 31), nil, (2 ** 31) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:int32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -129,12 +101,8 @@ def test_uint32
       [[0, nil, (2 ** 32) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -142,12 +110,8 @@ def test_int64
       [[-(2 ** 63), nil, (2 ** 63) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:int64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -155,12 +119,8 @@ def test_uint64
       [[0, nil, (2 ** 64) - 1]],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_float
@@ -168,12 +128,8 @@ def test_float
       [[-1.0, nil, 1.0]],
       [nil],
     ]
-    iterated_records = []
     target = build(:float, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_double
@@ -181,12 +137,8 @@ def test_double
       [[-1.0, nil, 1.0]],
       [nil],
     ]
-    iterated_records = []
     target = build(:double, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -194,12 +146,8 @@ def test_binary
       [["\x00".b, nil, "\xff".b]],
       [nil],
     ]
-    iterated_records = []
     target = build(:binary, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_string
@@ -213,12 +161,8 @@ def test_string
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:string, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -232,12 +176,8 @@ def test_date32
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:date32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -251,12 +191,8 @@ def test_date64
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:date64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -270,17 +206,12 @@ def test_timestamp_second
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :second,
                    },
                    records)
-    iterated_records = []
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -294,17 +225,12 @@ def test_timestamp_milli
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :milli,
                    },
                    records)
-    iterated_records = []
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -318,17 +244,12 @@ def test_timestamp_micro
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :micro,
                    },
                    records)
-    iterated_records = []
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -342,16 +263,12 @@ def test_timestamp_nano
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -368,16 +285,12 @@ def test_time32_second
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -394,16 +307,12 @@ def test_time32_milli
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -420,16 +329,12 @@ def test_time64_micro
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -446,16 +351,12 @@ def test_time64_nano
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -469,17 +370,13 @@ def test_decimal128
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal128,
                      precision: 8,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -493,17 +390,13 @@ def test_decimal256
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal256,
                      precision: 38,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -511,12 +404,8 @@ def test_month_interval
       [[1, nil, 12]],
       [nil],
     ]
-    iterated_records = []
     target = build(:month_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -530,12 +419,8 @@ def test_day_time_interval
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:day_time_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -549,12 +434,8 @@ def test_month_day_nano_interval
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:month_day_nano_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_list
@@ -574,7 +455,6 @@ def test_list
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :list,
                      field: {
@@ -583,10 +463,7 @@ def test_list
                      },
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_struct
@@ -600,7 +477,6 @@ def test_struct
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :struct,
                      fields: [
@@ -611,10 +487,7 @@ def test_struct
                      ],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_map
@@ -627,17 +500,13 @@ def test_map
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :map,
                      key: :string,
                      item: :boolean,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def remove_union_field_names(records)
@@ -670,7 +539,6 @@ def test_sparse_union
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :sparse_union,
                      fields: [
@@ -686,11 +554,8 @@ def test_sparse_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dense_union
@@ -705,7 +570,6 @@ def test_dense_union
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :dense_union,
                      fields: [
@@ -721,11 +585,8 @@ def test_dense_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dictionary
@@ -739,7 +600,6 @@ def test_dictionary
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :dictionary,
                      index_data_type: :int8,
@@ -747,10 +607,7 @@ def test_dictionary
                      ordered: false,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-map-array.rb b/ruby/red-arrow/test/each-raw-record/test-map-array.rb
index b802275a7f00f..f256543a853e3 100644
--- a/ruby/red-arrow/test/each-raw-record/test-map-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-map-array.rb
@@ -31,12 +31,8 @@ def test_null
       [{"key1" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:null, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -44,12 +40,8 @@ def test_boolean
       [{"key1" => true, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:boolean, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -57,12 +49,8 @@ def test_int8
       [{"key1" => -(2 ** 7), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:int8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -70,12 +58,8 @@ def test_uint8
       [{"key1" => (2 ** 8) - 1, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -83,12 +67,8 @@ def test_int16
       [{"key1" => -(2 ** 15), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:int16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -96,12 +76,8 @@ def test_uint16
       [{"key1" => (2 ** 16) - 1, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -109,12 +85,8 @@ def test_int32
       [{"key1" => -(2 ** 31), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:int32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -122,12 +94,8 @@ def test_uint32
       [{"key1" => (2 ** 32) - 1, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -135,12 +103,8 @@ def test_int64
       [{"key1" => -(2 ** 63), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:int64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -148,12 +112,8 @@ def test_uint64
       [{"key1" => (2 ** 64) - 1, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:uint64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_float
@@ -161,12 +121,8 @@ def test_float
       [{"key1" => -1.0, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:float, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_double
@@ -174,12 +130,8 @@ def test_double
       [{"key1" => -1.0, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:double, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -187,12 +139,8 @@ def test_binary
       [{"key1" => "\xff".b, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:binary, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_string
@@ -200,12 +148,8 @@ def test_string
       [{"key1" => "Ruby", "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:string, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -213,12 +157,8 @@ def test_date32
       [{"key1" => Date.new(1960, 1, 1), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:date32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -226,12 +166,8 @@ def test_date64
       [{"key1" => DateTime.new(1960, 1, 1, 2, 9, 30), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:date64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -239,16 +175,12 @@ def test_timestamp_second
       [{"key1" => Time.parse("1960-01-01T02:09:30Z"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -256,16 +188,12 @@ def test_timestamp_milli
       [{"key1" => Time.parse("1960-01-01T02:09:30.123Z"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -273,16 +201,12 @@ def test_timestamp_micro
       [{"key1" => Time.parse("1960-01-01T02:09:30.123456Z"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -290,16 +214,12 @@ def test_timestamp_nano
       [{"key1" => Time.parse("1960-01-01T02:09:30.123456789Z"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -309,16 +229,12 @@ def test_time32_second
       [{"key1" => Arrow::Time.new(unit, 60 * 10), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -328,16 +244,12 @@ def test_time32_milli
       [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -347,16 +259,12 @@ def test_time64_micro
       [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -366,16 +274,12 @@ def test_time64_nano
       [{"key1" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -383,17 +287,13 @@ def test_decimal128
       [{"key1" => BigDecimal("92.92"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal128,
                      precision: 8,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -401,17 +301,13 @@ def test_decimal256
       [{"key1" => BigDecimal("92.92"), "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal256,
                      precision: 38,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -419,12 +315,8 @@ def test_month_interval
       [{"key1" => 1, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:month_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -437,12 +329,8 @@ def test_day_time_interval
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:day_time_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -455,12 +343,8 @@ def test_month_day_nano_interval
       ],
       [nil],
     ]
-    iterated_records = []
     target = build(:month_day_nano_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_list
@@ -468,7 +352,6 @@ def test_list
       [{"key1" => [true, nil, false], "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :list,
                      field: {
@@ -477,10 +360,7 @@ def test_list
                      },
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_struct
@@ -488,7 +368,6 @@ def test_struct
       [{"key1" => {"field" => true}, "key2" => nil, "key3" => {"field" => nil}}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :struct,
                      fields: [
@@ -499,10 +378,7 @@ def test_struct
                      ],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_map
@@ -510,17 +386,13 @@ def test_map
       [{"key1" => {"sub_key1" => true, "sub_key2" => nil}, "key2" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :map,
                      key: :string,
                      item: :boolean,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def remove_union_field_names(records)
@@ -552,7 +424,6 @@ def test_sparse_union
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :sparse_union,
                      fields: [
@@ -568,11 +439,8 @@ def test_sparse_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 target.raw_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dense_union
@@ -587,7 +455,6 @@ def test_dense_union
       ],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :dense_union,
                      fields: [
@@ -603,11 +470,8 @@ def test_dense_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 target.raw_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dictionary
@@ -615,7 +479,6 @@ def test_dictionary
       [{"key1" => "Ruby", "key2" => nil, "key3" => "GLib"}],
       [nil],
     ]
-    iterated_records = []
     target = build({
                      type: :dictionary,
                      index_data_type: :int8,
@@ -623,10 +486,7 @@ def test_dictionary
                      ordered: false,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb b/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
index c0547d324d26d..b222ed89afe25 100644
--- a/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-multiple-columns.rb
@@ -22,17 +22,13 @@ def test_3_elements
       [nil, 0, "GLib"],
       [false, 2 ** 8 - 1, nil],
     ]
-    iterated_records = []
     target = build([
                      {name: :column0, type: :boolean},
                      {name: :column1, type: :uint8},
                      {name: :column2, type: :string},
                    ],
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_4_elements
@@ -41,7 +37,6 @@ def test_4_elements
       [nil, 0, "GLib", nil],
       [false, 2 ** 8 - 1, nil, (2 ** 63) - 1],
     ]
-    iterated_records = []
     target = build([
                      {name: :column0, type: :boolean},
                      {name: :column1, type: :uint8},
@@ -49,10 +44,7 @@ def test_4_elements
                      {name: :column3, type: :int64},
                    ],
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
diff --git a/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb b/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
index 4b1b941fb2079..36b0884bbc91c 100644
--- a/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-sparse-union-array.rb
@@ -82,12 +82,8 @@ def test_null
     records = [
       [{"0" => nil}],
     ]
-    iterated_records = []
     target = build(:null, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -95,12 +91,8 @@ def test_boolean
       [{"0" => true}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:boolean, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -108,12 +100,8 @@ def test_int8
       [{"0" => -(2 ** 7)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -121,12 +109,8 @@ def test_uint8
       [{"0" => (2 ** 8) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -134,12 +118,8 @@ def test_int16
       [{"0" => -(2 ** 15)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -147,12 +127,8 @@ def test_uint16
       [{"0" => (2 ** 16) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -160,12 +136,8 @@ def test_int32
       [{"0" => -(2 ** 31)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -173,12 +145,8 @@ def test_uint32
       [{"0" => (2 ** 32) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -186,12 +154,8 @@ def test_int64
       [{"0" => -(2 ** 63)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:int64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -199,12 +163,8 @@ def test_uint64
       [{"0" => (2 ** 64) - 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:uint64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_float
@@ -212,12 +172,8 @@ def test_float
       [{"0" => -1.0}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:float, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_double
@@ -225,12 +181,8 @@ def test_double
       [{"0" => -1.0}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:double, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -238,12 +190,8 @@ def test_binary
       [{"0" => "\xff".b}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:binary, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_string
@@ -251,12 +199,8 @@ def test_string
       [{"0" => "Ruby"}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:string, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -264,12 +208,8 @@ def test_date32
       [{"0" => Date.new(1960, 1, 1)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:date32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -277,12 +217,8 @@ def test_date64
       [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:date64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -290,16 +226,12 @@ def test_timestamp_second
       [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -307,16 +239,12 @@ def test_timestamp_milli
       [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
 
   end
 
@@ -325,16 +253,12 @@ def test_timestamp_micro
       [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -342,16 +266,12 @@ def test_timestamp_nano
       [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -361,16 +281,12 @@ def test_time32_second
       [{"0" => Arrow::Time.new(unit, 60 * 10)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -380,16 +296,12 @@ def test_time32_milli
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1000 + 123)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -399,16 +311,12 @@ def test_time64_micro
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -418,16 +326,12 @@ def test_time64_nano
       [{"0" => Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -435,17 +339,13 @@ def test_decimal128
       [{"0" => BigDecimal("92.92")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal128,
                      precision: 8,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -453,17 +353,13 @@ def test_decimal256
       [{"0" => BigDecimal("92.92")}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal256,
                      precision: 38,
                      scale: 2,
                    },
-                   records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+                   records)    
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -471,12 +367,8 @@ def test_month_interval
       [{"0" => 1}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:month_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -484,12 +376,8 @@ def test_day_time_interval
       [{"0" => {day: 1, millisecond: 100}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:day_time_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -497,12 +385,8 @@ def test_month_day_nano_interval
       [{"0" => {month: 1, day: 1, nanosecond: 100}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build(:month_day_nano_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_list
@@ -510,7 +394,6 @@ def test_list
       [{"0" => [true, nil, false]}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :list,
                      field: {
@@ -519,10 +402,7 @@ def test_list
                      },
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_struct
@@ -531,7 +411,6 @@ def test_struct
       [{"1" => nil}],
       [{"0" => {"sub_field" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :struct,
                      fields: [
@@ -542,10 +421,7 @@ def test_struct
                      ],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_map
@@ -553,17 +429,13 @@ def test_map
       [{"0" => {"key1" => true, "key2" => nil}}],
       [{"1" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :map,
                      key: :string,
                      item: :boolean,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(records), iterated_records)
+    assert_equal(remove_field_names(records), target.each_raw_record.to_a)
   end
 
   def test_sparse_union
@@ -573,7 +445,6 @@ def test_sparse_union
       [{"0" => {"field2" => 29}}],
       [{"0" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :sparse_union,
                      fields: [
@@ -589,10 +460,8 @@ def test_sparse_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(remove_field_names(records)), iterated_records)
+    assert_equal(remove_field_names(remove_field_names(records)),
+                 target.each_raw_record.to_a)
   end
 
   def test_dense_union
@@ -602,7 +471,6 @@ def test_dense_union
       [{"0" => {"field2" => 29}}],
       [{"0" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :dense_union,
                      fields: [
@@ -618,10 +486,8 @@ def test_dense_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(remove_field_names(remove_field_names(records)), iterated_records)
+    assert_equal(remove_field_names(remove_field_names(records)),
+                 target.each_raw_record.to_a)
   end
 
   def test_dictionary
diff --git a/ruby/red-arrow/test/each-raw-record/test-struct-array.rb b/ruby/red-arrow/test/each-raw-record/test-struct-array.rb
index de6e78aaeef4c..91a3d09af4e84 100644
--- a/ruby/red-arrow/test/each-raw-record/test-struct-array.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-struct-array.rb
@@ -40,12 +40,8 @@ def test_null
       [{"field" => nil}],
       [nil],
     ]
-    iterated_records = []
     target = build(:null, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_boolean
@@ -54,12 +50,8 @@ def test_boolean
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:boolean, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int8
@@ -68,12 +60,8 @@ def test_int8
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:int8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint8
@@ -82,12 +70,8 @@ def test_uint8
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:uint8, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int16
@@ -96,12 +80,8 @@ def test_int16
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:int16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint16
@@ -110,12 +90,8 @@ def test_uint16
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:uint16, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int32
@@ -124,12 +100,8 @@ def test_int32
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:int32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint32
@@ -138,12 +110,8 @@ def test_uint32
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:uint32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_int64
@@ -152,12 +120,8 @@ def test_int64
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:int64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_uint64
@@ -166,12 +130,8 @@ def test_uint64
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:uint64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_float
@@ -180,12 +140,8 @@ def test_float
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:float, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_double
@@ -194,12 +150,8 @@ def test_double
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:double, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_binary
@@ -208,12 +160,8 @@ def test_binary
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:binary, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_string
@@ -222,12 +170,8 @@ def test_string
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
-    target = build(:string, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    target = build(:string, records)    
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date32
@@ -236,12 +180,8 @@ def test_date32
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:date32, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_date64
@@ -250,12 +190,8 @@ def test_date64
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:date64, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_second
@@ -264,16 +200,12 @@ def test_timestamp_second
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :second,
                    },
-                   records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+                   records)    
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_milli
@@ -282,16 +214,12 @@ def test_timestamp_milli
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_micro
@@ -300,16 +228,12 @@ def test_timestamp_micro
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_timestamp_nano
@@ -318,16 +242,12 @@ def test_timestamp_nano
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :timestamp,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_second
@@ -338,16 +258,12 @@ def test_time32_second
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :second,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time32_milli
@@ -358,16 +274,12 @@ def test_time32_milli
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time32,
                      unit: :milli,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_micro
@@ -378,16 +290,12 @@ def test_time64_micro
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :micro,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_time64_nano
@@ -398,16 +306,12 @@ def test_time64_nano
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :time64,
                      unit: :nano,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal128
@@ -416,17 +320,13 @@ def test_decimal128
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal128,
                      precision: 8,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_decimal256
@@ -435,17 +335,13 @@ def test_decimal256
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :decimal256,
                      precision: 38,
                      scale: 2,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_interval
@@ -454,12 +350,8 @@ def test_month_interval
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:month_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_day_time_interval
@@ -468,12 +360,8 @@ def test_day_time_interval
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:day_time_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_month_day_nano_interval
@@ -482,12 +370,8 @@ def test_month_day_nano_interval
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build(:month_day_nano_interval, records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_list
@@ -496,7 +380,6 @@ def test_list
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :list,
                      field: {
@@ -505,10 +388,7 @@ def test_list
                      },
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_struct
@@ -518,7 +398,6 @@ def test_struct
       [{"field" => nil}],
       [{"field" => {"sub_field" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :struct,
                      fields: [
@@ -529,10 +408,7 @@ def test_struct
                      ],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def test_map
@@ -541,17 +417,13 @@ def test_map
       [nil],
       [{"field" => nil}],
     ]
-    iterated_records = []
     target = build({
                      type: :map,
                      key: :string,
                      item: :boolean,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 
   def remove_union_field_names(records)
@@ -576,7 +448,6 @@ def test_sparse_union
       [{"field" => {"field2" => 29}}],
       [{"field" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :sparse_union,
                      fields: [
@@ -592,11 +463,8 @@ def test_sparse_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dense_union
@@ -607,7 +475,6 @@ def test_dense_union
       [{"field" => {"field2" => 29}}],
       [{"field" => {"field2" => nil}}],
     ]
-    iterated_records = []
     target = build({
                      type: :dense_union,
                      fields: [
@@ -623,11 +490,8 @@ def test_dense_union
                      type_codes: [0, 1],
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
     assert_equal(remove_union_field_names(records),
-                 iterated_records)
+                 target.each_raw_record.to_a)
   end
 
   def test_dictionary
@@ -637,7 +501,6 @@ def test_dictionary
       [{"field" => nil}],
       [{"field" => "GLib"}],
     ]
-    iterated_records = []
     target = build({
                      type: :dictionary,
                      index_data_type: :int8,
@@ -645,14 +508,11 @@ def test_dictionary
                      ordered: false,
                    },
                    records)
-    target.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(records, iterated_records)
+    assert_equal(records, target.each_raw_record.to_a)
   end
 end
 
-class RawRecordsRecordBatchStructArrayTest < Test::Unit::TestCase
+class EachRawRecordRecordBatchStructArrayTest < Test::Unit::TestCase
   include EachRawRecordStructArrayTests
 
   def build(type, records)
@@ -660,7 +520,7 @@ def build(type, records)
   end
 end
 
-class RawRecordsTableStructArrayTest < Test::Unit::TestCase
+class EachRawRecordTableStructArrayTest < Test::Unit::TestCase
   include EachRawRecordStructArrayTests
 
   def build(type, records)
diff --git a/ruby/red-arrow/test/each-raw-record/test-table.rb b/ruby/red-arrow/test/each-raw-record/test-table.rb
index b5bd80127c8b0..96dbe576382b2 100644
--- a/ruby/red-arrow/test/each-raw-record/test-table.rb
+++ b/ruby/red-arrow/test/each-raw-record/test-table.rb
@@ -41,11 +41,7 @@ class EachRawRecordTableTest < Test::Unit::TestCase
     record_batches = raw_record_batches.collect do |record_batch|
       Arrow::RecordBatch.new(schema, record_batch)
     end
-    iterated_records = []
     table = Arrow::Table.new(schema, record_batches)
-    table.each_raw_record do |record|
-      iterated_records << record
-    end
-    assert_equal(raw_records, iterated_records)
+    assert_equal(raw_records, table.each_raw_record.to_a)
   end
 end

From 65552ab52358fd1190882f987ce514b95d6e4de6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:32:23 +0900
Subject: [PATCH 347/749] MINOR: [C#] Bump Grpc.Net.Client from 2.56.0 to
 2.57.0 in /csharp (#37660)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.Net.Client](https://github.com/grpc/grpc-dotnet) from 2.56.0 to 2.57.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.Net.Client's releases</a>.</em></p>
<blockquote>
<h2>Release v2.57.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
<li>Update Grpc.Net.Client to use ActivitySource by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2244">grpc/grpc-dotnet#2244</a></li>
<li>Clear IAsyncStreamReader.Current value before reading next value by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2248">grpc/grpc-dotnet#2248</a></li>
<li>Upgrade QpsWorker to net8 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2250">grpc/grpc-dotnet#2250</a></li>
<li>Change subchannel ID to include a channel ID by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2253">grpc/grpc-dotnet#2253</a></li>
<li>Update Grpc.Tools dependency to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2257">grpc/grpc-dotnet#2257</a></li>
<li>Add transport status to subchannel picked log by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2261">grpc/grpc-dotnet#2261</a></li>
<li>Reduce logger allocations by not using generic CreateLogger by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2256">grpc/grpc-dotnet#2256</a></li>
<li>Update call debugger display to show status code by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2259">grpc/grpc-dotnet#2259</a></li>
<li>Log socket lifetime when closing unusable sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2258">grpc/grpc-dotnet#2258</a></li>
<li>Fix unobserved exceptions with retries by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2255">grpc/grpc-dotnet#2255</a></li>
<li>Change subchannel BalancerAddress when attributes change by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2228">grpc/grpc-dotnet#2228</a></li>
<li>Fix connection bugs from BalancerAddress changes by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2265">grpc/grpc-dotnet#2265</a></li>
<li>[v2.57.x] Update version to 2.57.0-pre1 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2266">grpc/grpc-dotnet#2266</a></li>
<li>[2.57.x] Update version to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2272">grpc/grpc-dotnet#2272</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0</a></p>
<h2>Release v2.57.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7733c07c69c98506e9f89ec68cd0fb33ecd1bcb4"><code>7733c07</code></a> [2.57.x] Update version to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2272">#2272</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/4dadd820d9180869948dd546fe3272fdc08401a3"><code>4dadd82</code></a> [v2.57.x] Update version to 2.57.0-pre1 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2266">#2266</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b50e46f851f3b1d787f54efced879fb0696d3bb4"><code>b50e46f</code></a> Fix connection bugs from BalancerAddress changes (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2265">#2265</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/311f8784c6f2300f85875927cbbdc7d29f0e2538"><code>311f878</code></a> Change subchannel BalancerAddress when attributes change (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2228">#2228</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b421751176ece4ea8fb969bbfc4e8a64be874a49"><code>b421751</code></a> Fix unobserved exceptions with retries (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2255">#2255</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/41f67ad900d470b3c3eadf92c07c518c7cb1dd5f"><code>41f67ad</code></a> Log socket lifetime when closing unusable sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2258">#2258</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a9e810c3df173f57b6b79c65421751b3e2b541bc"><code>a9e810c</code></a> Update call debugger display to show status code (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2259">#2259</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6429ae2f574788a1f9237a42c86f71c9f781e3e2"><code>6429ae2</code></a> Reduce logger allocations by not using generic CreateLogger (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2256">#2256</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3db1683820e58670cd54686d25d1180890ce81c3"><code>3db1683</code></a> Add transport status to subchannel picked log (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2261">#2261</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/01049834beb8342d1cf93bc5902a7fb2d3a310e1"><code>0104983</code></a> Update Grpc.Tools dependency to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2257">#2257</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Net.Client&package-manager=nuget&previous-version=2.56.0&new-version=2.57.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 005714ef28a18..eaa28e33ea9d4 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -6,7 +6,7 @@
   
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.2" />
-    <PackageReference Include="Grpc.Net.Client" Version="2.56.0" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
     <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
   </ItemGroup>
 

From 18792852007e45889326aaf4c94b22a780521f67 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:33:15 +0900
Subject: [PATCH 348/749] MINOR: [C#] Bump BenchmarkDotNet from 0.13.7 to
 0.13.8 in /csharp (#37661)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet) from 0.13.7 to 0.13.8.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet's releases</a>.</em></p>
<blockquote>
<h2>0.13.8</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.8.html">https://benchmarkdotnet.org/changelog/v0.13.8.html</a></p>
<h2>Highlights</h2>
<p>This release contains important bug fixes.</p>
<h2>What's Changed</h2>
<ul>
<li>Issue2394 multiple markdown exporters not possible even with different names by <a href="https://github.com/bstordrup"><code>@​bstordrup</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2395">dotnet/BenchmarkDotNet#2395</a></li>
<li>Make MarkdownExporter ctor and Dialect protected by <a href="https://github.com/nietras"><code>@​nietras</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2407">dotnet/BenchmarkDotNet#2407</a></li>
<li>Refactor out base TextLogger from StreamLogger by <a href="https://github.com/nietras"><code>@​nietras</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2406">dotnet/BenchmarkDotNet#2406</a></li>
<li>
<ul>
<li>update the templates install command to reflect dotnet cli updates by <a href="https://github.com/baywet"><code>@​baywet</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2415">dotnet/BenchmarkDotNet#2415</a></li>
</ul>
</li>
<li>Update stub decoding for .NET 8 for disassemblers by <a href="https://github.com/janvorli"><code>@​janvorli</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2416">dotnet/BenchmarkDotNet#2416</a></li>
<li>Enable nullability for BenchmarkDotNet.Annotations by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2418">dotnet/BenchmarkDotNet#2418</a></li>
<li>Nullability In BenchmarkDotNet project by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2419">dotnet/BenchmarkDotNet#2419</a></li>
<li>feat: add text justification style by <a href="https://github.com/Vahdanian"><code>@​Vahdanian</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2410">dotnet/BenchmarkDotNet#2410</a></li>
<li>Default to RoslynToolchain by <a href="https://github.com/timcassell"><code>@​timcassell</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2409">dotnet/BenchmarkDotNet#2409</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/bstordrup"><code>@​bstordrup</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2395">dotnet/BenchmarkDotNet#2395</a></li>
<li><a href="https://github.com/baywet"><code>@​baywet</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2415">dotnet/BenchmarkDotNet#2415</a></li>
<li><a href="https://github.com/Vahdanian"><code>@​Vahdanian</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2410">dotnet/BenchmarkDotNet#2410</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8">https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/f8de1e95a7a2c5d06862c14f5f657142d54e9328"><code>f8de1e9</code></a> Prepare v0.13.8 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e2e888c694854974c9e11e3fd92c278876637903"><code>e2e888c</code></a> Use Roslyn Toolchain by default if no build settings are changed.</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/b035d90c481bbbb8b8cd56daa5ca5730e2309797"><code>b035d90</code></a> feat: add text justification style (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2410">#2410</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2a8bab554774fbd1d100a148846332a28a717ca1"><code>2a8bab5</code></a> Fixed nullability warnings for some files from BenchmarkDotNet project</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/3860e4a0ec9de82f5addc750633ac0f7b470e08b"><code>3860e4a</code></a> Removed redundant check</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/83fc5ed5433109a7129f696cbe6ab35fd6e0810f"><code>83fc5ed</code></a> Updated CodeAnnotations to the actual version</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d763cf1dfabd90bb47d169981aca2f0269f6a02"><code>2d763cf</code></a> Enable nullability for BenchmarkDotNet.Annotations</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d391085c4a3298d3f9223197f986823f01c34e37"><code>d391085</code></a> Update stub decoding for .NET 8 for disassemblers (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2416">#2416</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e0c667f6363e75f4e18e34767b6211d360962873"><code>e0c667f</code></a> - update the templates install command to reflect dotnet cli updates (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2415">#2415</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c35dcb2b949096d257c743672ce7f2fd276828ad"><code>c35dcb2</code></a> Refactor out base TextLogger from StreamLogger (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2406">#2406</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet&package-manager=nuget&previous-version=0.13.7&new-version=0.13.8)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index a81fc15bae861..6a058a752bc2e 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.7" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
     <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.7" />
   </ItemGroup>
 

From b7581fee01ed0d111d5a0361c2f05779aa3c33e8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Sep 2023 08:34:12 +0900
Subject: [PATCH 349/749] MINOR: [C#] Bump Grpc.AspNetCore from 2.56.0 to
 2.57.0 in /csharp (#37664)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore](https://github.com/grpc/grpc-dotnet) from 2.56.0 to 2.57.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore's releases</a>.</em></p>
<blockquote>
<h2>Release v2.57.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
<li>Update Grpc.Net.Client to use ActivitySource by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2244">grpc/grpc-dotnet#2244</a></li>
<li>Clear IAsyncStreamReader.Current value before reading next value by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2248">grpc/grpc-dotnet#2248</a></li>
<li>Upgrade QpsWorker to net8 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2250">grpc/grpc-dotnet#2250</a></li>
<li>Change subchannel ID to include a channel ID by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2253">grpc/grpc-dotnet#2253</a></li>
<li>Update Grpc.Tools dependency to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2257">grpc/grpc-dotnet#2257</a></li>
<li>Add transport status to subchannel picked log by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2261">grpc/grpc-dotnet#2261</a></li>
<li>Reduce logger allocations by not using generic CreateLogger by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2256">grpc/grpc-dotnet#2256</a></li>
<li>Update call debugger display to show status code by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2259">grpc/grpc-dotnet#2259</a></li>
<li>Log socket lifetime when closing unusable sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2258">grpc/grpc-dotnet#2258</a></li>
<li>Fix unobserved exceptions with retries by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2255">grpc/grpc-dotnet#2255</a></li>
<li>Change subchannel BalancerAddress when attributes change by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2228">grpc/grpc-dotnet#2228</a></li>
<li>Fix connection bugs from BalancerAddress changes by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2265">grpc/grpc-dotnet#2265</a></li>
<li>[v2.57.x] Update version to 2.57.0-pre1 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2266">grpc/grpc-dotnet#2266</a></li>
<li>[2.57.x] Update version to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2272">grpc/grpc-dotnet#2272</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0</a></p>
<h2>Release v2.57.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7733c07c69c98506e9f89ec68cd0fb33ecd1bcb4"><code>7733c07</code></a> [2.57.x] Update version to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2272">#2272</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/4dadd820d9180869948dd546fe3272fdc08401a3"><code>4dadd82</code></a> [v2.57.x] Update version to 2.57.0-pre1 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2266">#2266</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b50e46f851f3b1d787f54efced879fb0696d3bb4"><code>b50e46f</code></a> Fix connection bugs from BalancerAddress changes (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2265">#2265</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/311f8784c6f2300f85875927cbbdc7d29f0e2538"><code>311f878</code></a> Change subchannel BalancerAddress when attributes change (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2228">#2228</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b421751176ece4ea8fb969bbfc4e8a64be874a49"><code>b421751</code></a> Fix unobserved exceptions with retries (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2255">#2255</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/41f67ad900d470b3c3eadf92c07c518c7cb1dd5f"><code>41f67ad</code></a> Log socket lifetime when closing unusable sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2258">#2258</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a9e810c3df173f57b6b79c65421751b3e2b541bc"><code>a9e810c</code></a> Update call debugger display to show status code (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2259">#2259</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6429ae2f574788a1f9237a42c86f71c9f781e3e2"><code>6429ae2</code></a> Reduce logger allocations by not using generic CreateLogger (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2256">#2256</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3db1683820e58670cd54686d25d1180890ce81c3"><code>3db1683</code></a> Add transport status to subchannel picked log (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2261">#2261</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/01049834beb8342d1cf93bc5902a7fb2d3a310e1"><code>0104983</code></a> Update Grpc.Tools dependency to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2257">#2257</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore&package-manager=nuget&previous-version=2.56.0&new-version=2.57.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.TestWeb.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
index ef7d730d2cd45..ce46466bd6ca5 100644
--- a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
+++ b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.56.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.57.0" />
   </ItemGroup>
 
   <ItemGroup>

From 247b7f0c067dbcdbdd69b3a970f3fbfc03b484f0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Sep 2023 09:48:39 +0900
Subject: [PATCH 350/749] MINOR: [C#] Bump BenchmarkDotNet.Diagnostics.Windows
 from 0.13.7 to 0.13.8 in /csharp (#37659)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet.Diagnostics.Windows](https://github.com/dotnet/BenchmarkDotNet) from 0.13.7 to 0.13.8.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet.Diagnostics.Windows's releases</a>.</em></p>
<blockquote>
<h2>0.13.8</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.8.html">https://benchmarkdotnet.org/changelog/v0.13.8.html</a></p>
<h2>Highlights</h2>
<p>This release contains important bug fixes.</p>
<h2>What's Changed</h2>
<ul>
<li>Issue2394 multiple markdown exporters not possible even with different names by <a href="https://github.com/bstordrup"><code>@​bstordrup</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2395">dotnet/BenchmarkDotNet#2395</a></li>
<li>Make MarkdownExporter ctor and Dialect protected by <a href="https://github.com/nietras"><code>@​nietras</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2407">dotnet/BenchmarkDotNet#2407</a></li>
<li>Refactor out base TextLogger from StreamLogger by <a href="https://github.com/nietras"><code>@​nietras</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2406">dotnet/BenchmarkDotNet#2406</a></li>
<li>
<ul>
<li>update the templates install command to reflect dotnet cli updates by <a href="https://github.com/baywet"><code>@​baywet</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2415">dotnet/BenchmarkDotNet#2415</a></li>
</ul>
</li>
<li>Update stub decoding for .NET 8 for disassemblers by <a href="https://github.com/janvorli"><code>@​janvorli</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2416">dotnet/BenchmarkDotNet#2416</a></li>
<li>Enable nullability for BenchmarkDotNet.Annotations by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2418">dotnet/BenchmarkDotNet#2418</a></li>
<li>Nullability In BenchmarkDotNet project by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2419">dotnet/BenchmarkDotNet#2419</a></li>
<li>feat: add text justification style by <a href="https://github.com/Vahdanian"><code>@​Vahdanian</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2410">dotnet/BenchmarkDotNet#2410</a></li>
<li>Default to RoslynToolchain by <a href="https://github.com/timcassell"><code>@​timcassell</code></a> in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2409">dotnet/BenchmarkDotNet#2409</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/bstordrup"><code>@​bstordrup</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2395">dotnet/BenchmarkDotNet#2395</a></li>
<li><a href="https://github.com/baywet"><code>@​baywet</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2415">dotnet/BenchmarkDotNet#2415</a></li>
<li><a href="https://github.com/Vahdanian"><code>@​Vahdanian</code></a> made their first contribution in <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2410">dotnet/BenchmarkDotNet#2410</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8">https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/f8de1e95a7a2c5d06862c14f5f657142d54e9328"><code>f8de1e9</code></a> Prepare v0.13.8 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e2e888c694854974c9e11e3fd92c278876637903"><code>e2e888c</code></a> Use Roslyn Toolchain by default if no build settings are changed.</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/b035d90c481bbbb8b8cd56daa5ca5730e2309797"><code>b035d90</code></a> feat: add text justification style (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2410">#2410</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2a8bab554774fbd1d100a148846332a28a717ca1"><code>2a8bab5</code></a> Fixed nullability warnings for some files from BenchmarkDotNet project</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/3860e4a0ec9de82f5addc750633ac0f7b470e08b"><code>3860e4a</code></a> Removed redundant check</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/83fc5ed5433109a7129f696cbe6ab35fd6e0810f"><code>83fc5ed</code></a> Updated CodeAnnotations to the actual version</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d763cf1dfabd90bb47d169981aca2f0269f6a02"><code>2d763cf</code></a> Enable nullability for BenchmarkDotNet.Annotations</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d391085c4a3298d3f9223197f986823f01c34e37"><code>d391085</code></a> Update stub decoding for .NET 8 for disassemblers (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2416">#2416</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e0c667f6363e75f4e18e34767b6211d360962873"><code>e0c667f</code></a> - update the templates install command to reflect dotnet cli updates (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2415">#2415</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c35dcb2b949096d257c743672ce7f2fd276828ad"><code>c35dcb2</code></a> Refactor out base TextLogger from StreamLogger (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2406">#2406</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.7...v0.13.8">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet.Diagnostics.Windows&package-manager=nuget&previous-version=0.13.7&new-version=0.13.8)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index 6a058a752bc2e..35f17270e0b04 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.7" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.8" />
   </ItemGroup>
 
   <ItemGroup>

From 5009282ddb4c980374833a95071f147a08b2b9f5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Sep 2023 09:49:15 +0900
Subject: [PATCH 351/749] MINOR: [C#] Bump Grpc.Tools from 2.57.0 to 2.58.0 in
 /csharp (#37662)

Bumps [Grpc.Tools](https://github.com/grpc/grpc) from 2.57.0 to 2.58.0.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/grpc/grpc/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Tools&package-manager=nuget&previous-version=2.57.0&new-version=2.58.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj  | 2 +-
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
index 57bb6b6876ca8..4f785971b2849 100644
--- a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
+++ b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index eaa28e33ea9d4..0ffb2f0a8e518 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.2" />
     <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
-    <PackageReference Include="Grpc.Tools" Version="2.57.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">

From 1adc745f67791dde1d9e2574b9de52a8d00ca7e8 Mon Sep 17 00:00:00 2001
From: Arkadiusz Rudny <93520526+aru-trackunit@users.noreply.github.com>
Date: Tue, 12 Sep 2023 06:27:34 +0200
Subject: [PATCH 352/749] GH-37560 [Python][Documentation] Replacing confusing
 batch size from 128Ki to 128_000 (#37605)

### Rationale for this change

https://github.com/apache/arrow/issues/37560

### Are these changes tested? -> No

### Are there any user-facing changes? -> Documentation
* Closes: #37560

Authored-by: Arkadiusz Rudny <aru@trackunit.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/_dataset.pyx | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/python/pyarrow/_dataset.pyx b/python/pyarrow/_dataset.pyx
index 8f5688de29072..d29fa125e2061 100644
--- a/python/pyarrow/_dataset.pyx
+++ b/python/pyarrow/_dataset.pyx
@@ -319,7 +319,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -441,7 +441,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -519,7 +519,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -597,7 +597,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -675,7 +675,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -730,7 +730,7 @@ cdef class Dataset(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1411,7 +1411,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1491,7 +1491,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1574,7 +1574,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1653,7 +1653,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1731,7 +1731,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -1786,7 +1786,7 @@ cdef class Fragment(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -3436,7 +3436,7 @@ cdef class Scanner(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -3515,7 +3515,7 @@ cdef class Scanner(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.
@@ -3601,7 +3601,7 @@ cdef class Scanner(_Weakrefable):
             partition information or internal metadata found in the data
             source, e.g. Parquet statistics. Otherwise filters the loaded
             RecordBatches before yielding them.
-        batch_size : int, default 128Ki
+        batch_size : int, default 131_072
             The maximum row count for scanned record batches. If scanned
             record batches are overflowing memory then this method can be
             called to reduce their size.

From 5a1ca69d617288a12769b279502d8815a859f487 Mon Sep 17 00:00:00 2001
From: Chris Jordan-Squire <788080+chrisjordansquire@users.noreply.github.com>
Date: Tue, 12 Sep 2023 07:02:17 -0400
Subject: [PATCH 353/749] GH-37244: [Python] Remove support for pickle5
 (#37644)

Resolve issue https://github.com/apache/arrow/issues/37244 by removing pickle5 usage in pyarrow.

### Rationale for this change

See issue https://github.com/apache/arrow/issues/37244 .

### What changes are included in this PR?

pickle5 usage is removed from pyarrow .

### Are these changes tested?

Yes, the python test suite was run.

### Are there any user-facing changes?

No.

* Closes: #37244

Authored-by: Chris Jordan-Squire <chris.jordansquire@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/compat.pxi          | 8 +-------
 python/pyarrow/io.pxi              | 3 ++-
 python/pyarrow/pandas_compat.py    | 5 +++--
 python/pyarrow/types.pxi           | 5 +++--
 python/requirements-wheel-test.txt | 1 -
 5 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/python/pyarrow/compat.pxi b/python/pyarrow/compat.pxi
index 98aa1f2433ef0..8cf106d5609b5 100644
--- a/python/pyarrow/compat.pxi
+++ b/python/pyarrow/compat.pxi
@@ -33,16 +33,10 @@ def encode_file_path(path):
 ordered_dict = dict
 
 
-try:
-    import pickle5 as builtin_pickle
-except ImportError:
-    import pickle as builtin_pickle
-
-
 try:
     import cloudpickle as pickle
 except ImportError:
-    pickle = builtin_pickle
+    import pickle
 
 
 def tobytes(o):
diff --git a/python/pyarrow/io.pxi b/python/pyarrow/io.pxi
index e3018ab4704f0..460e932b86273 100644
--- a/python/pyarrow/io.pxi
+++ b/python/pyarrow/io.pxi
@@ -21,6 +21,7 @@
 from libc.stdlib cimport malloc, free
 
 import codecs
+import pickle
 import re
 import sys
 import threading
@@ -1368,7 +1369,7 @@ cdef class Buffer(_Weakrefable):
 
     def __reduce_ex__(self, protocol):
         if protocol >= 5:
-            bufobj = builtin_pickle.PickleBuffer(self)
+            bufobj = pickle.PickleBuffer(self)
         elif self.buffer.get().is_mutable():
             # Need to pass a bytearray to recreate a mutable buffer when
             # unpickling.
diff --git a/python/pyarrow/pandas_compat.py b/python/pyarrow/pandas_compat.py
index 12f1cc431293c..4e5c868efd4c8 100644
--- a/python/pyarrow/pandas_compat.py
+++ b/python/pyarrow/pandas_compat.py
@@ -26,13 +26,14 @@
 from itertools import zip_longest
 import json
 import operator
+import pickle
 import re
 import warnings
 
 import numpy as np
 
 import pyarrow as pa
-from pyarrow.lib import _pandas_api, builtin_pickle, frombytes  # noqa
+from pyarrow.lib import _pandas_api, frombytes  # noqa
 
 
 _logical_type_map = {}
@@ -720,7 +721,7 @@ def _reconstruct_block(item, columns=None, extension_columns=None):
                                 klass=_int.DatetimeTZBlock,
                                 dtype=dtype)
     elif 'object' in item:
-        block = _int.make_block(builtin_pickle.loads(block_arr),
+        block = _int.make_block(pickle.loads(block_arr),
                                 placement=placement)
     elif 'py_array' in item:
         # create ExtensionBlock
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index ffaebd2418a58..9f8b347d56294 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -19,6 +19,7 @@ from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer
 
 import atexit
 from collections.abc import Mapping
+import pickle
 import re
 import sys
 import warnings
@@ -1699,12 +1700,12 @@ cdef class PyExtensionType(ExtensionType):
                                   .format(type(self).__name__))
 
     def __arrow_ext_serialize__(self):
-        return builtin_pickle.dumps(self)
+        return pickle.dumps(self)
 
     @classmethod
     def __arrow_ext_deserialize__(cls, storage_type, serialized):
         try:
-            ty = builtin_pickle.loads(serialized)
+            ty = pickle.loads(serialized)
         except Exception:
             # For some reason, it's impossible to deserialize the
             # ExtensionType instance.  Perhaps the serialized data is
diff --git a/python/requirements-wheel-test.txt b/python/requirements-wheel-test.txt
index c23a30f70e838..9de0acb754079 100644
--- a/python/requirements-wheel-test.txt
+++ b/python/requirements-wheel-test.txt
@@ -1,7 +1,6 @@
 cffi
 cython
 hypothesis
-pickle5; platform_system != "Windows" and python_version < "3.8"
 pytest
 pytest-lazy-fixture
 pytz

From f71594c982f115e01463c352b95bea0722bcd866 Mon Sep 17 00:00:00 2001
From: david dali susanibar arce <davi.sarces@gmail.com>
Date: Tue, 12 Sep 2023 08:40:13 -0500
Subject: [PATCH 354/749] GH-37216: [Docs] adding documentation to deal with
 unreleased allocators (#37498)

### Rationale for this change

To close #37216

### What changes are included in this PR?

Documentation added to try to catch unreleased allocations.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #37216

Lead-authored-by: david dali susanibar arce <davi.sarces@gmail.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/memory.rst | 49 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/docs/source/java/memory.rst b/docs/source/java/memory.rst
index af6c0abc7c82a..036befa148692 100644
--- a/docs/source/java/memory.rst
+++ b/docs/source/java/memory.rst
@@ -133,7 +133,7 @@ Development Guidelines
 Applications should generally:
 
 * Use the BufferAllocator interface in APIs instead of RootAllocator.
-* Create one RootAllocator at the start of the program.
+* Create one RootAllocator at the start of the program and explicitly pass it when needed.
 * ``close()`` allocators after use (whether they are child allocators or the RootAllocator), either manually or preferably via a try-with-resources statement.
 
 
@@ -288,6 +288,53 @@ Finally, enabling the ``TRACE`` logging level will automatically provide this st
    |        at RootAllocator.close (RootAllocator.java:29)
    |        at (#8:1)
 
+Sometimes, explicitly passing allocators around is difficult. For example, it
+can be hard to pass around extra state, like an allocator, through layers of 
+existing application or framework code. A global or singleton allocator instance
+can be useful here, though it should not be your first choice.
+
+How this works:
+
+1. Set up a global allocator in a singleton class.
+2. Provide methods to create child allocators from the global allocator.
+3. Give child allocators proper names to make it easier to figure out where
+   allocations occurred in case of errors.
+4. Ensure that resources are properly closed.
+5. Check that the global allocator is empty at some suitable point, such as
+   right before program shutdown.
+6. If it is not empty, review the above allocation bugs.
+
+.. code-block:: java
+
+    //1
+    private static final BufferAllocator allocator = new RootAllocator();
+    private static final AtomicInteger childNumber = new AtomicInteger(0);
+    ...
+    //2
+    public static BufferAllocator getChildAllocator() {
+        return allocator.newChildAllocator(nextChildName(), 0, Long.MAX_VALUE);
+    }
+    ...
+    //3
+    private static String nextChildName() {
+        return "Allocator-Child-" + childNumber.incrementAndGet();
+    }
+    ...
+    //4: Business code
+    try (BufferAllocator allocator = GlobalAllocator.getChildAllocator()) {
+        ...
+    }
+    ...
+    //5
+    public static void checkGlobalCleanUpResources() {
+        ...
+        if (!allocator.getChildAllocators().isEmpty()) {
+          throw new IllegalStateException(...);
+        } else if (allocator.getAllocatedMemory() != 0) {
+          throw new IllegalStateException(...);
+        }
+    }
+
 .. _`ArrowBuf`: https://arrow.apache.org/docs/java/reference/org/apache/arrow/memory/ArrowBuf.html
 .. _`ArrowBuf.print()`: https://arrow.apache.org/docs/java/reference/org/apache/arrow/memory/ArrowBuf.html#print-java.lang.StringBuilder-int-org.apache.arrow.memory.BaseAllocator.Verbosity-
 .. _`BufferAllocator`: https://arrow.apache.org/docs/java/reference/org/apache/arrow/memory/BufferAllocator.html

From 47bf6e9d9eb60fe873e42261db5cae3480d1cc73 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Tue, 12 Sep 2023 17:49:41 +0100
Subject: [PATCH 355/749] GH-37671: [R] legacy timezone symlinks cause CRAN
 failures (#37672)

### Rationale for this change

A tzdata update causes our tests to fail on CRAN due to our use of legacy timezones (i.e. starting with "US/") in some of our tests

### What changes are included in this PR?

Update the timezones

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37671

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/helper-data.R               |  4 ++--
 r/tests/testthat/test-Array.R                |  4 ++--
 r/tests/testthat/test-dplyr-funcs-datetime.R | 16 ++++++++--------
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/r/tests/testthat/helper-data.R b/r/tests/testthat/helper-data.R
index 1088be6850143..0631cfccae3fc 100644
--- a/r/tests/testthat/helper-data.R
+++ b/r/tests/testthat/helper-data.R
@@ -59,9 +59,9 @@ haven_data <- tibble::tibble(
 example_with_times <- tibble::tibble(
   date = Sys.Date() + 1:10,
   posixct = lubridate::ymd_hms("2018-10-07 19:04:05") + 1:10,
-  posixct_tz = lubridate::ymd_hms("2018-10-07 19:04:05", tz = "US/Eastern") + 1:10,
+  posixct_tz = lubridate::ymd_hms("2018-10-07 19:04:05", tz = "America/New_York") + 1:10,
   posixlt = as.POSIXlt(lubridate::ymd_hms("2018-10-07 19:04:05") + 1:10),
-  posixlt_tz = as.POSIXlt(lubridate::ymd_hms("2018-10-07 19:04:05", tz = "US/Eastern") + 1:10)
+  posixlt_tz = as.POSIXlt(lubridate::ymd_hms("2018-10-07 19:04:05", tz = "America/New_York") + 1:10)
 )
 
 verses <- list(
diff --git a/r/tests/testthat/test-Array.R b/r/tests/testthat/test-Array.R
index 960faa8bb751b..b29c1f4e09dde 100644
--- a/r/tests/testthat/test-Array.R
+++ b/r/tests/testthat/test-Array.R
@@ -283,8 +283,8 @@ test_that("array supports POSIXct (ARROW-3340)", {
   times[5] <- NA
   expect_array_roundtrip(times, timestamp("us", "UTC"))
 
-  times2 <- lubridate::ymd_hms("2018-10-07 19:04:05", tz = "US/Eastern") + 1:10
-  expect_array_roundtrip(times2, timestamp("us", "US/Eastern"))
+  times2 <- lubridate::ymd_hms("2018-10-07 19:04:05", tz = "America/New_York") + 1:10
+  expect_array_roundtrip(times2, timestamp("us", "America/New_York"))
 })
 
 test_that("array uses local timezone for POSIXct without timezone", {
diff --git a/r/tests/testthat/test-dplyr-funcs-datetime.R b/r/tests/testthat/test-dplyr-funcs-datetime.R
index bcd2584851b70..e707a194a3626 100644
--- a/r/tests/testthat/test-dplyr-funcs-datetime.R
+++ b/r/tests/testthat/test-dplyr-funcs-datetime.R
@@ -3606,7 +3606,7 @@ test_that("with_tz() and force_tz() works", {
     "2012-01-01 01:02:03"
   ), tz = "UTC")
 
-  timestamps_non_utc <- force_tz(timestamps, "US/Central")
+  timestamps_non_utc <- force_tz(timestamps, "America/Chicago")
 
   nonexistent <- as_datetime(c(
     "2015-03-29 02:30:00",
@@ -3622,10 +3622,10 @@ test_that("with_tz() and force_tz() works", {
     .input %>%
       mutate(
         timestamps_with_tz_1 = with_tz(timestamps, "UTC"),
-        timestamps_with_tz_2 = with_tz(timestamps, "US/Central"),
+        timestamps_with_tz_2 = with_tz(timestamps, "America/Chicago"),
         timestamps_with_tz_3 = with_tz(timestamps, "Asia/Kolkata"),
         timestamps_force_tz_1 = force_tz(timestamps, "UTC"),
-        timestamps_force_tz_2 = force_tz(timestamps, "US/Central"),
+        timestamps_force_tz_2 = force_tz(timestamps, "America/Chicago"),
         timestamps_force_tz_3 = force_tz(timestamps, "Asia/Kolkata")
       ) %>%
       collect(),
@@ -3636,7 +3636,7 @@ test_that("with_tz() and force_tz() works", {
     .input %>%
       mutate(
         timestamps_with_tz_1 = with_tz(timestamps, "UTC"),
-        timestamps_with_tz_2 = with_tz(timestamps, "US/Central"),
+        timestamps_with_tz_2 = with_tz(timestamps, "America/Chicago"),
         timestamps_with_tz_3 = with_tz(timestamps, "Asia/Kolkata")
       ) %>%
       collect(),
@@ -3733,17 +3733,17 @@ test_that("with_tz() and force_tz() can add timezone to timestamp without timezo
 
   expect_equal(
     arrow_table(timestamps = timestamps) %>%
-      mutate(timestamps = with_tz(timestamps, "US/Central")) %>%
+      mutate(timestamps = with_tz(timestamps, "America/Chicago")) %>%
       compute(),
-    arrow_table(timestamps = timestamps$cast(timestamp("s", "US/Central")))
+    arrow_table(timestamps = timestamps$cast(timestamp("s", "America/Chicago")))
   )
 
   expect_equal(
     arrow_table(timestamps = timestamps) %>%
-      mutate(timestamps = force_tz(timestamps, "US/Central")) %>%
+      mutate(timestamps = force_tz(timestamps, "America/Chicago")) %>%
       compute(),
     arrow_table(
-      timestamps = call_function("assume_timezone", timestamps, options = list(timezone = "US/Central"))
+      timestamps = call_function("assume_timezone", timestamps, options = list(timezone = "America/Chicago"))
     )
   )
 })

From 1940cbbb3a5224243e429f9577604bb7b276cf4f Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Tue, 12 Sep 2023 20:03:31 +0100
Subject: [PATCH 356/749] GH-37681: [R] Update NEWS.md for 13.0.0.1 (#37682)

### Rationale for this change

Update R changelog

### What changes are included in this PR?

Update R changelog

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37681

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NEWS.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/r/NEWS.md b/r/NEWS.md
index d80efbf8de18e..2e2db1ad5d3fa 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -19,6 +19,10 @@
 
 # arrow 13.0.0.9000
 
+# arrow 13.0.0.1
+
+* Remove reference to legacy timezones to prevent CRAN check failures (#37671)
+
 # arrow 13.0.0
 
 ## Breaking changes

From 8e4c826130df1592c7de0d2c221c16369e23c960 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 13 Sep 2023 08:28:47 +0900
Subject: [PATCH 357/749] MINOR: [C#] Bump Grpc.AspNetCore.Server from 2.56.0
 to 2.57.0 in /csharp (#37663)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

**This PR includes breaking changes to public APIs.**

Apache.Arrow.Flight.AspNetCore requires .NET 6.0 or later.

Bumps [Grpc.AspNetCore.Server](https://github.com/grpc/grpc-dotnet) from 2.56.0 to 2.57.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore.Server's releases</a>.</em></p>
<blockquote>
<h2>Release v2.57.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
<li>Update Grpc.Net.Client to use ActivitySource by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2244">grpc/grpc-dotnet#2244</a></li>
<li>Clear IAsyncStreamReader.Current value before reading next value by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2248">grpc/grpc-dotnet#2248</a></li>
<li>Upgrade QpsWorker to net8 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2250">grpc/grpc-dotnet#2250</a></li>
<li>Change subchannel ID to include a channel ID by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2253">grpc/grpc-dotnet#2253</a></li>
<li>Update Grpc.Tools dependency to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2257">grpc/grpc-dotnet#2257</a></li>
<li>Add transport status to subchannel picked log by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2261">grpc/grpc-dotnet#2261</a></li>
<li>Reduce logger allocations by not using generic CreateLogger by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2256">grpc/grpc-dotnet#2256</a></li>
<li>Update call debugger display to show status code by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2259">grpc/grpc-dotnet#2259</a></li>
<li>Log socket lifetime when closing unusable sockets by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2258">grpc/grpc-dotnet#2258</a></li>
<li>Fix unobserved exceptions with retries by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2255">grpc/grpc-dotnet#2255</a></li>
<li>Change subchannel BalancerAddress when attributes change by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2228">grpc/grpc-dotnet#2228</a></li>
<li>Fix connection bugs from BalancerAddress changes by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2265">grpc/grpc-dotnet#2265</a></li>
<li>[v2.57.x] Update version to 2.57.0-pre1 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2266">grpc/grpc-dotnet#2266</a></li>
<li>[2.57.x] Update version to 2.57.0 by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2272">grpc/grpc-dotnet#2272</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0</a></p>
<h2>Release v2.57.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.57.x development cycle by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2227">grpc/grpc-dotnet#2227</a></li>
<li>Validate Windows version when using WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2229">grpc/grpc-dotnet#2229</a></li>
<li>Support infinite idle connection timeout values by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2231">grpc/grpc-dotnet#2231</a></li>
<li>Improve BalancerAttributes debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2235">grpc/grpc-dotnet#2235</a></li>
<li>Update Grpc.Net.Client to remove ValueTask usage by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2222">grpc/grpc-dotnet#2222</a></li>
<li>Update Newtonsoft.Json to 13.0.3 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2219">grpc/grpc-dotnet#2219</a></li>
<li>Consistently don't log message errors on cancellation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2221">grpc/grpc-dotnet#2221</a></li>
<li>Fix load balancing flaky test by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2223">grpc/grpc-dotnet#2223</a></li>
<li>Improve comment in GrpcChannel for WinHttpHandler + OS validation by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2237">grpc/grpc-dotnet#2237</a></li>
<li>Update OS version detection to get version directly from Windows by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2239">grpc/grpc-dotnet#2239</a></li>
<li>Update implementation_comparison.md by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2240">grpc/grpc-dotnet#2240</a></li>
<li>Update to use .NET 8 by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2021">grpc/grpc-dotnet#2021</a></li>
<li>Bump semver from 6.3.0 to 6.3.1 in /testassets/InteropTestsGrpcWebWebsite/Tests by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2243">grpc/grpc-dotnet#2243</a></li>
<li>Force yielding after awaiting CallTask to avoid holding onto locks by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2245">grpc/grpc-dotnet#2245</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7733c07c69c98506e9f89ec68cd0fb33ecd1bcb4"><code>7733c07</code></a> [2.57.x] Update version to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2272">#2272</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/4dadd820d9180869948dd546fe3272fdc08401a3"><code>4dadd82</code></a> [v2.57.x] Update version to 2.57.0-pre1 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2266">#2266</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b50e46f851f3b1d787f54efced879fb0696d3bb4"><code>b50e46f</code></a> Fix connection bugs from BalancerAddress changes (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2265">#2265</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/311f8784c6f2300f85875927cbbdc7d29f0e2538"><code>311f878</code></a> Change subchannel BalancerAddress when attributes change (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2228">#2228</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/b421751176ece4ea8fb969bbfc4e8a64be874a49"><code>b421751</code></a> Fix unobserved exceptions with retries (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2255">#2255</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/41f67ad900d470b3c3eadf92c07c518c7cb1dd5f"><code>41f67ad</code></a> Log socket lifetime when closing unusable sockets (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2258">#2258</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a9e810c3df173f57b6b79c65421751b3e2b541bc"><code>a9e810c</code></a> Update call debugger display to show status code (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2259">#2259</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/6429ae2f574788a1f9237a42c86f71c9f781e3e2"><code>6429ae2</code></a> Reduce logger allocations by not using generic CreateLogger (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2256">#2256</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3db1683820e58670cd54686d25d1180890ce81c3"><code>3db1683</code></a> Add transport status to subchannel picked log (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2261">#2261</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/01049834beb8342d1cf93bc5902a7fb2d3a310e1"><code>0104983</code></a> Update Grpc.Tools dependency to 2.57.0 (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2257">#2257</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.56.0...v2.57.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore.Server&package-manager=nuget&previous-version=2.56.0&new-version=2.57.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Lead-authored-by: Eric Erhardt <eric.erhardt@microsoft.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.AspNetCore.csproj                     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
index c794e1a4f5089..845f2667970e4 100644
--- a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
+++ b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.56.0" />
+    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.57.0" />
   </ItemGroup>
 
   <ItemGroup>

From 2a56d4598a3a401447c91645448853b940e86fbe Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 12 Sep 2023 22:21:21 -0400
Subject: [PATCH 358/749] GH-37636: [Go] Bump minimum go versions (#37637)

Updating the Github Actions workflows to only test Go 1.19 and Go 1.20 instead of Go1.17 and Go1.18. Also bumping the default Go version in the `.env` file to update the docker images.
* Closes: #37636

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 .env                                      |   4 +-
 .github/workflows/go.yml                  |  74 ++++-------
 ci/docker/conda-integration.dockerfile    |   2 +-
 ci/docker/debian-11-go.dockerfile         |   4 +-
 go/arrow/compute/executor.go              |   3 +
 go/arrow/compute/exprs/builders_test.go   |   2 +-
 go/go.mod                                 |  54 ++++----
 go/go.sum                                 | 150 +++++++++-------------
 go/internal/hashing/hash_string_go1.19.go |  11 +-
 9 files changed, 130 insertions(+), 174 deletions(-)

diff --git a/.env b/.env
index c9cd6c8094ed8..014bad3fe2a7a 100644
--- a/.env
+++ b/.env
@@ -58,8 +58,8 @@ CUDA=11.0.3
 DASK=latest
 DOTNET=7.0
 GCC_VERSION=""
-GO=1.17
-STATICCHECK=v0.2.2
+GO=1.19.13
+STATICCHECK=v0.4.5
 HDFS=3.2.1
 JDK=8
 KARTOTHEK=latest
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index c31ad0b77c2df..3c695891b48d6 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -54,28 +54,23 @@ jobs:
         include:
           - arch-label: AMD64
             arch: amd64
-            go: 1.17
+            go: 1.19
             runs-on: ubuntu-latest
-            staticcheck: v0.2.2
           - arch-label: AMD64
             arch: amd64
-            go: 1.18
+            go: '1.20'
             runs-on: ubuntu-latest
-            staticcheck: v0.3.3
           - arch-label: ARM64
             arch: arm64v8
-            go: 1.17
-            staticcheck: v0.2.2
+            go: 1.19
             runs-on: ["self-hosted", "arm", "linux"]
           - arch-label: ARM64
             arch: arm64v8
-            go: 1.18
-            staticcheck: v0.3.3
+            go: '1.20'
             runs-on: ["self-hosted", "arm", "linux"]
     env:
       ARCH: ${{ matrix.arch }}
       GO: ${{ matrix.go }}
-      STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
@@ -145,7 +140,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v4
         with:
-          go-version: 1.18
+          go-version: 1.19
           cache: true
           cache-dependency-path: go/go.sum
       - name: Run build
@@ -161,15 +156,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [1.17, 1.18]
-        include:
-          - go: 1.17
-            staticcheck: v0.2.2
-          - go: 1.18
-            staticcheck: v0.3.3
+        go: [1.19, '1.20']
     env:
       GO: ${{ matrix.go }}
-      STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
@@ -208,15 +197,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [1.17, 1.18]
-        include:
-          - go: 1.17
-            staticcheck: v0.2.2
-          - go: 1.18
-            staticcheck: v0.3.3
+        go: [1.19, '1.20']
     env:
       GO: ${{ matrix.go }}
-      STATICCHECK: ${{ matrix.staticcheck }}
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
@@ -253,12 +236,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [1.17, 1.18]
-        include:
-          - go: 1.17
-            staticcheck: v0.2.2
-          - go: 1.18
-            staticcheck: v0.3.3
+        go: [1.19, '1.20']
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
@@ -272,7 +250,10 @@ jobs:
           cache: true
           cache-dependency-path: go/go.sum
       - name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@${{ matrix.staticcheck }}
+        shell: bash
+        run: |
+          . .env
+          go install honnef.co/go/tools/cmd/staticcheck@${STATICCHECK}
       - name: Build
         shell: bash
         run: ci/scripts/go_build.sh $(pwd)
@@ -288,12 +269,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [1.17, 1.18]
-        include:
-          - go: 1.17
-            staticcheck: v0.2.2
-          - go: 1.18
-            staticcheck: v0.3.3
+        go: [1.19, '1.20']
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
@@ -306,8 +282,10 @@ jobs:
           go-version: ${{ matrix.go }}
           cache: true
           cache-dependency-path: go/go.sum
-      - name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@${{ matrix.staticcheck }}
+      - name: Install staticcheck      
+        run: |
+          . .env
+          go install honnef.co/go/tools/cmd/staticcheck@${STATICCHECK}
       - name: Build
         shell: bash
         run: ci/scripts/go_build.sh $(pwd)
@@ -349,12 +327,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go: [1.17, 1.18]
-        include:
-          - go: 1.17
-            staticcheck: v0.2.2
-          - go: 1.18
-            staticcheck: v0.3.3
+        go: [1.19, '1.20']
     env:
       ARROW_GO_TESTCGO: "1"
     steps:
@@ -373,7 +346,9 @@ jobs:
         shell: bash
         run: brew install apache-arrow pkg-config
       - name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@${{ matrix.staticcheck }}
+        run: |
+          . .env
+          go install honnef.co/go/tools/cmd/staticcheck@${STATICCHECK}
       - name: Add To pkg config path
         shell: bash
         run: |
@@ -430,11 +405,14 @@ jobs:
       - name: Install go
         uses: actions/setup-go@v4
         with:
-          go-version: '1.18'
+          go-version: '1.19'
           cache: true
           cache-dependency-path: go/go.sum
       - name: Install staticcheck
-        run: go install honnef.co/go/tools/cmd/staticcheck@v0.3.3
+        shell: bash
+        run: |
+          . .env
+          go install honnef.co/go/tools/cmd/staticcheck@${STATICCHECK}
       - name: Build
         shell: bash
         run: ci/scripts/go_build.sh $(pwd)
diff --git a/ci/docker/conda-integration.dockerfile b/ci/docker/conda-integration.dockerfile
index 43d7e7ab0b60d..a306790b5cb6d 100644
--- a/ci/docker/conda-integration.dockerfile
+++ b/ci/docker/conda-integration.dockerfile
@@ -24,7 +24,7 @@ ARG maven=3.5
 ARG node=16
 ARG yarn=1.22
 ARG jdk=8
-ARG go=1.15
+ARG go=1.19.13
 
 # Install Archery and integration dependencies
 COPY ci/conda_env_archery.txt /arrow/ci/
diff --git a/ci/docker/debian-11-go.dockerfile b/ci/docker/debian-11-go.dockerfile
index 9f75bf23fddf2..de8186b9b8e1c 100644
--- a/ci/docker/debian-11-go.dockerfile
+++ b/ci/docker/debian-11-go.dockerfile
@@ -16,8 +16,8 @@
 # under the License.
 
 ARG arch=amd64
-ARG go=1.17
-ARG staticcheck=v0.2.2
+ARG go=1.19
+ARG staticcheck=v0.4.5
 FROM ${arch}/golang:${go}-bullseye
 
 # FROM collects all the args, get back the staticcheck version arg
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index ac87d063915b7..6da7ed1293065 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -1007,6 +1007,9 @@ func (v *vectorExecutor) WrapResults(ctx context.Context, out <-chan Datum, hasC
 	case <-ctx.Done():
 		return nil
 	case output = <-out:
+		if output == nil {
+			return nil
+		}
 		// if the inputs contained at least one chunked array
 		// then we want to return chunked output
 		if hasChunked {
diff --git a/go/arrow/compute/exprs/builders_test.go b/go/arrow/compute/exprs/builders_test.go
index 9aaa4a2c4f9e4..e42d7569a8f03 100644
--- a/go/arrow/compute/exprs/builders_test.go
+++ b/go/arrow/compute/exprs/builders_test.go
@@ -37,7 +37,7 @@ func TestNewScalarFunc(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.Equal(t, "add(i32(1), i32(10), {overflow: [ERROR]}) => i32", fn.String())
-	assert.Equal(t, "add:i32_i32", fn.Name())
+	assert.Equal(t, "add:i32_i32", fn.CompoundName())
 }
 
 func TestFieldRefDotPath(t *testing.T) {
diff --git a/go/go.mod b/go/go.mod
index 46c093ed1ece2..a5581eb3925ca 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -20,60 +20,60 @@ go 1.20
 
 require (
 	github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c
-	github.com/andybalholm/brotli v1.0.4
-	github.com/apache/thrift v0.16.0
+	github.com/andybalholm/brotli v1.0.5
+	github.com/apache/thrift v0.17.0
 	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
-	github.com/goccy/go-json v0.10.0
+	github.com/goccy/go-json v0.10.2
 	github.com/golang/snappy v0.0.4
-	github.com/google/flatbuffers v23.1.21+incompatible
+	github.com/google/flatbuffers v23.5.26+incompatible
 	github.com/klauspost/asmfmt v1.3.2
-	github.com/klauspost/compress v1.15.15
-	github.com/klauspost/cpuid/v2 v2.2.3
+	github.com/klauspost/compress v1.16.7
+	github.com/klauspost/cpuid/v2 v2.2.5
 	github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8
 	github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3
-	github.com/pierrec/lz4/v4 v4.1.17
-	github.com/stretchr/testify v1.8.1
+	github.com/pierrec/lz4/v4 v4.1.18
+	github.com/stretchr/testify v1.8.4
 	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/exp v0.0.0-20230206171751-46f607a40771
-	golang.org/x/sync v0.1.0
-	golang.org/x/sys v0.5.0
-	golang.org/x/tools v0.6.0
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
+	golang.org/x/sync v0.3.0
+	golang.org/x/sys v0.12.0
+	golang.org/x/tools v0.13.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gonum.org/v1/gonum v0.12.0
-	google.golang.org/grpc v1.53.0
-	google.golang.org/protobuf v1.28.1
-	modernc.org/sqlite v1.20.4
+	google.golang.org/grpc v1.54.0
+	google.golang.org/protobuf v1.31.0
+	modernc.org/sqlite v1.21.2
 )
 
 require (
 	github.com/google/uuid v1.3.0
-	github.com/substrait-io/substrait-go v0.2.1-0.20230517203920-30fa08bd57d0
+	github.com/substrait-io/substrait-go v0.4.2
 )
 
 require (
-	github.com/alecthomas/participle/v2 v2.0.0 // indirect
+	github.com/alecthomas/participle/v2 v2.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/fatih/color v1.13.0 // indirect
-	github.com/goccy/go-yaml v1.9.8 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/fatih/color v1.15.0 // indirect
+	github.com/goccy/go-yaml v1.11.0 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kr/text v0.2.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rogpeppe/go-internal v1.9.0 // indirect
 	github.com/stretchr/objx v0.5.0 // indirect
-	golang.org/x/mod v0.8.0 // indirect
-	golang.org/x/net v0.7.0 // indirect
-	golang.org/x/text v0.7.0 // indirect
-	google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc // indirect
+	golang.org/x/mod v0.12.0 // indirect
+	golang.org/x/net v0.15.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
+	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	lukechampine.com/uint128 v1.2.0 // indirect
+	lukechampine.com/uint128 v1.3.0 // indirect
 	modernc.org/cc/v3 v3.40.0 // indirect
 	modernc.org/ccgo/v3 v3.16.13 // indirect
-	modernc.org/libc v1.22.2 // indirect
+	modernc.org/libc v1.22.4 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
 	modernc.org/memory v1.5.0 // indirect
 	modernc.org/opt v0.1.3 // indirect
diff --git a/go/go.sum b/go/go.sum
index 0ccd809f50fae..609cf7173ef98 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -1,13 +1,13 @@
 github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c h1:RGWPOewvKIROun94nF7v2cua9qP+thov/7M50KEoeSU=
 github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk=
-github.com/alecthomas/assert/v2 v2.2.2 h1:Z/iVC0xZfWTaFNE6bA3z07T86hd45Xe2eLt6WVy2bbk=
-github.com/alecthomas/participle/v2 v2.0.0 h1:Fgrq+MbuSsJwIkw3fEj9h75vDP0Er5JzepJ0/HNHv0g=
-github.com/alecthomas/participle/v2 v2.0.0/go.mod h1:rAKZdJldHu8084ojcWevWAL8KmEU+AT+Olodb+WoN2Y=
+github.com/alecthomas/assert/v2 v2.3.0 h1:mAsH2wmvjsuvyBvAmCtm7zFsBlb8mIHx5ySLVdDZXL0=
+github.com/alecthomas/participle/v2 v2.1.0 h1:z7dElHRrOEEq45F2TG5cbQihMtNTv8vwldytDj7Wrz4=
+github.com/alecthomas/participle/v2 v2.1.0/go.mod h1:Y1+hAs8DHPmc3YUFzqllV+eSQ9ljPTk0ZkPMtEdAx2c=
 github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk=
-github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
-github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
-github.com/apache/thrift v0.16.0 h1:qEy6UW60iVOlUy+b9ZR0d5WzUWYGOo4HfopoyBaNmoY=
-github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/apache/thrift v0.17.0 h1:cMd2aj52n+8VoAtvSvLn4kDC3aZ6IAkBuqWQ2IDu7wo=
+github.com/apache/thrift v0.17.0/go.mod h1:OLxhMRJxomX+1I/KUw03qoV3mMz16BwaKI+d4fPBx7Q=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -16,28 +16,22 @@ github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815 h1:bWDMxwH3px2JBh
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
-github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
-github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
+github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
-github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
-github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
-github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
-github.com/goccy/go-json v0.10.0 h1:mXKd9Qw4NuzShiRlOXKews24ufknHO7gx30lsDyokKA=
-github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
-github.com/goccy/go-yaml v1.9.8 h1:5gMyLUeU1/6zl+WFfR1hN7D2kf+1/eRGa7DFtToiBvQ=
-github.com/goccy/go-yaml v1.9.8/go.mod h1:JubOolP3gh0HpiBc4BLRD4YmjEjHAmIIB2aaXKkTfoE=
-github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-yaml v1.11.0 h1:n7Z+zx8S9f9KgzG6KtQKf+kwqXZlLNR2F6018Dgau54=
+github.com/goccy/go-yaml v1.11.0/go.mod h1:H+mJrWtjPTJAHvRbV09MCK9xYwODM+wRTVFFTWckfng=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/flatbuffers v23.1.21+incompatible h1:bUqzx/MXCDxuS0hRJL2EfjyZL3uQrPbMocUa8zGqsTA=
-github.com/google/flatbuffers v23.1.21+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/flatbuffers v23.5.26+incompatible h1:M9dgRyhJemaM4Sw8+66GHBu8ioaQmyPLg1b8VwK5WJg=
+github.com/google/flatbuffers v23.5.26+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
@@ -48,31 +42,26 @@ github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNU
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
 github.com/klauspost/asmfmt v1.3.2 h1:4Ri7ox3EwapiOjCki+hw14RyKk201CN4rzyCJRFLpK4=
 github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE=
-github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw=
-github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4=
-github.com/klauspost/cpuid/v2 v2.2.3 h1:sxCkb+qR91z4vsqw4vGGZlDgPz3G7gjaLyK3V8y70BU=
-github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
-github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
-github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
 github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8 h1:AMFGa4R4MiIpspGNG7Z948v4n35fFGB3RR3G/ry4FWs=
 github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY=
 github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3 h1:+n/aFZefKZp7spd8DFdX7uMikMLXX4oubIzJF4kv/wI=
 github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE=
-github.com/pierrec/lz4/v4 v4.1.17 h1:kV4Ip+/hUBC+8T6+2EgburRtkE9ef4nbY3f4dFhGjMc=
-github.com/pierrec/lz4/v4 v4.1.17/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
+github.com/pierrec/lz4/v4 v4.1.18 h1:xaKrnTkyoqfh1YItXl56+6KJNVYWlEEPuAQW9xsplYQ=
+github.com/pierrec/lz4/v4 v4.1.18/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
@@ -84,93 +73,72 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/substrait-io/substrait-go v0.2.1-0.20230517203920-30fa08bd57d0 h1:ULhfcCHY7uxA133qmInVpNpqfjyicryPXIaxCjbDVbw=
-github.com/substrait-io/substrait-go v0.2.1-0.20230517203920-30fa08bd57d0/go.mod h1:qhpnLmrcvAnlZsUyPXZRqldiHapPTXC3t7xFgDi3aQg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/substrait-io/substrait-go v0.4.2 h1:buDnjsb3qAqTaNbOR7VKmNgXf4lYQxWEcnSGUWBtmN8=
+github.com/substrait-io/substrait-go v0.4.2/go.mod h1:qhpnLmrcvAnlZsUyPXZRqldiHapPTXC3t7xFgDi3aQg=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU=
-golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg=
-golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g=
-golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220406163625-3f8b81556e12/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 gonum.org/v1/gonum v0.12.0 h1:xKuo6hzt+gMav00meVPUlXwSdoEJP46BR+wdxQEFK2o=
 gonum.org/v1/gonum v0.12.0/go.mod h1:73TDxJfAAHeA8Mk9mf8NlIppyhQNo5GLTcYeqgo2lvY=
-google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc h1:ijGwO+0vL2hJt5gaygqP2j6PfflOBrRot0IczKbmtio=
-google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM=
-google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc=
-google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw=
+google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A=
+google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU=
+google.golang.org/grpc v1.54.0 h1:EhTqbhiYeixwWQtAEZAxmV9MGqcjEU2mFx52xCzNyag=
+google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
-lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
+lukechampine.com/uint128 v1.3.0 h1:cDdUVfRwDUDovz610ABgFD17nXD4/uDgVHl2sC3+sbo=
+lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
 modernc.org/cc/v3 v3.40.0 h1:P3g79IUS/93SYhtoeaHW+kRCIrYaxJ27MFPv+7kaTOw=
 modernc.org/cc/v3 v3.40.0/go.mod h1:/bTg4dnWkSXowUO6ssQKnOV0yMVxDYNIsIrzqTFDGH0=
 modernc.org/ccgo/v3 v3.16.13 h1:Mkgdzl46i5F/CNR/Kj80Ri59hC8TKAhZrYSaqvkwzUw=
 modernc.org/ccgo/v3 v3.16.13/go.mod h1:2Quk+5YgpImhPjv2Qsob1DnZ/4som1lJTodubIcoUkY=
 modernc.org/ccorpus v1.11.6 h1:J16RXiiqiCgua6+ZvQot4yUuUy8zxgqbqEEUuGPlISk=
 modernc.org/httpfs v1.0.6 h1:AAgIpFZRXuYnkjftxTAZwMIiwEqAfk8aVB2/oA6nAeM=
-modernc.org/libc v1.22.2 h1:4U7v51GyhlWqQmwCHj28Rdq2Yzwk55ovjFrdPjs8Hb0=
-modernc.org/libc v1.22.2/go.mod h1:uvQavJ1pZ0hIoC/jfqNoMLURIMhKzINIWypNM17puug=
+modernc.org/libc v1.22.4 h1:wymSbZb0AlrjdAVX3cjreCHTPCpPARbQXNz6BHPzdwQ=
+modernc.org/libc v1.22.4/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
 modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
 modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
 modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
 modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
 modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4=
 modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
-modernc.org/sqlite v1.20.4 h1:J8+m2trkN+KKoE7jglyHYYYiaq5xmz2HoHJIiBlRzbE=
-modernc.org/sqlite v1.20.4/go.mod h1:zKcGyrICaxNTMEHSr1HQ2GUraP0j+845GYw37+EyT6A=
+modernc.org/sqlite v1.21.2 h1:ixuUG0QS413Vfzyx6FWx6PYTmHaOegTY+hjzhn7L+a0=
+modernc.org/sqlite v1.21.2/go.mod h1:cxbLkB5WS32DnQqeH4h4o1B0eMr8W/y8/RGuxQ3JsC0=
 modernc.org/strutil v1.1.3 h1:fNMm+oJklMGYfU9Ylcywl0CO5O6nTfaowNsh2wpPjzY=
 modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw=
-modernc.org/tcl v1.15.0 h1:oY+JeD11qVVSgVvodMJsu7Edf8tr5E/7tuhF5cNYz34=
+modernc.org/tcl v1.15.1 h1:mOQwiEK4p7HruMZcwKTZPw/aqtGM4aY00uzWhlKKYws=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
 modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
 modernc.org/z v1.7.0 h1:xkDw/KepgEjeizO2sNco+hqYkU12taxQFqPEmgm1GWE=
diff --git a/go/internal/hashing/hash_string_go1.19.go b/go/internal/hashing/hash_string_go1.19.go
index c496f43abdcc6..f38eb5c523dde 100644
--- a/go/internal/hashing/hash_string_go1.19.go
+++ b/go/internal/hashing/hash_string_go1.19.go
@@ -24,7 +24,14 @@ import (
 )
 
 func hashString(val string, alg uint64) uint64 {
-	buf := *(*[]byte)(unsafe.Pointer(&val))
-	(*reflect.SliceHeader)(unsafe.Pointer(&buf)).Cap = len(val)
+	if val == "" {
+		return Hash([]byte{}, alg)
+	}
+	// highly efficient way to get byte slice without copy before
+	// the introduction of unsafe.StringData in go1.20
+	// (https://stackoverflow.com/questions/59209493/how-to-use-unsafe-get-a-byte-slice-from-a-string-without-memory-copy)
+	const MaxInt32 = 1<<31 - 1
+	buf := (*[MaxInt32]byte)(unsafe.Pointer((*reflect.StringHeader)(
+		unsafe.Pointer(&val)).Data))[: len(val)&MaxInt32 : len(val)&MaxInt32]
 	return Hash(buf, alg)
 }

From 4fac528e2ee9c4efce453420275cbaf0b3b6adb0 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Wed, 13 Sep 2023 11:24:17 +0200
Subject: [PATCH 359/749] GH-37639: [CI] Fix checkout on older OSes (#37640)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Jobs are failing due to not being supported by node 20

### What changes are included in this PR?

Using v3 where needed.

### Are these changes tested?

Crossbow
* Closes: #37639

Lead-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Co-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/tasks/macros.jinja                | 4 ++--
 dev/tasks/r/github.macos.autobrew.yml | 2 +-
 dev/tasks/r/github.packages.yml       | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 06b9390c0f974..faf77a1168d1b 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -25,9 +25,9 @@ on:
       - "*-github-*"
 {% endmacro %}
 
-{%- macro github_checkout_arrow(fetch_depth=1, submodules="recursive") -%}
+{%- macro github_checkout_arrow(fetch_depth=1, submodules="recursive", action_v="4") -%}
   - name: Checkout Arrow
-    uses: actions/checkout@v4
+    uses: actions/checkout@v{{ action_v }}
     with:
       fetch-depth: {{ fetch_depth }}
       path: arrow
diff --git a/dev/tasks/r/github.macos.autobrew.yml b/dev/tasks/r/github.macos.autobrew.yml
index 28733dbfef148..b8e23690e2090 100644
--- a/dev/tasks/r/github.macos.autobrew.yml
+++ b/dev/tasks/r/github.macos.autobrew.yml
@@ -34,7 +34,7 @@ jobs:
             - "{{ macros.r_release.ver }}"
             - "{{ macros.r_oldrel.ver }}"
     steps:
-      {{ macros.github_checkout_arrow()|indent }}
+      {{ macros.github_checkout_arrow(action_v='3')|indent }}
       - name: Configure autobrew script
         run: |
           # minio and sccache are pre-installed on the self-hosted 10.13 runner
diff --git a/dev/tasks/r/github.packages.yml b/dev/tasks/r/github.packages.yml
index e3e3d34e156dc..dbe21ffb6b160 100644
--- a/dev/tasks/r/github.packages.yml
+++ b/dev/tasks/r/github.packages.yml
@@ -262,7 +262,8 @@ jobs:
       # Get the arrow checkout just for the docker config scripts
       # Don't need submodules for this (hence false arg to macro): they fail on
       # actions/checkout for some reason in this context
-      {{ macros.github_checkout_arrow(1, false)|indent }}
+      {{ macros.github_checkout_arrow(1, false, '3')|indent }}
+
       - name: Install system requirements
         env:
           ARROW_R_DEV: "TRUE" # To install curl/openssl in r_docker_configure.sh

From 15a8ac3ce4e3ac31f9f361770ad4a38c69102aa1 Mon Sep 17 00:00:00 2001
From: andrewchambers <andrewchamberss@gmail.com>
Date: Thu, 14 Sep 2023 05:03:11 +1200
Subject: [PATCH 360/749] GH-37687: [Go] Don't copy in realloc when capacity is
 sufficient. (#37688)

This removes excessive copies observed in some benchmarks.

* Closes: #37687

Authored-by: Andrew Chambers <ac@acha.ninja>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/memory/go_allocator.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/go/arrow/memory/go_allocator.go b/go/arrow/memory/go_allocator.go
index 1dea4a8d23385..1017eb688d2ff 100644
--- a/go/arrow/memory/go_allocator.go
+++ b/go/arrow/memory/go_allocator.go
@@ -32,10 +32,9 @@ func (a *GoAllocator) Allocate(size int) []byte {
 }
 
 func (a *GoAllocator) Reallocate(size int, b []byte) []byte {
-	if size == len(b) {
-		return b
+	if cap(b) >= size {
+		return b[:size]
 	}
-
 	newBuf := a.Allocate(size)
 	copy(newBuf, b)
 	return newBuf

From 396b4759bfed70ad1f5d7724baaa7ee81654c6ea Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 14 Sep 2023 12:42:48 +0200
Subject: [PATCH 361/749] GH-37555: [Python] Update get_file_info_selector to
 ignore base directory (#37558)

### Rationale for this change

There has been some changes in the way fsspec lists the directories with new version 2023.9.0, see https://github.com/fsspec/filesystem_spec/pull/1329, which caused our tests to start failing.

### What changes are included in this PR?

This PR updates the `get_file_info_selector` in [FSSpecHandler](https://arrow.apache.org/docs/_modules/pyarrow/fs.html#FSSpecHandler) class to keep the behaviour of our spec.

### Are there any user-facing changes?

No.

* Closes: #37555

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/fs.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/python/pyarrow/fs.py b/python/pyarrow/fs.py
index 567bea8ac05e8..36655c7d12863 100644
--- a/python/pyarrow/fs.py
+++ b/python/pyarrow/fs.py
@@ -356,7 +356,12 @@ def get_file_info_selector(self, selector):
             selector.base_dir, maxdepth=maxdepth, withdirs=True, detail=True
         )
         for path, info in selected_files.items():
-            infos.append(self._create_file_info(path, info))
+            _path = path.strip("/")
+            base_dir = selector.base_dir.strip("/")
+            # Need to exclude base directory from selected files if present
+            # (fsspec filesystems, see GH-37555)
+            if _path != base_dir:
+                infos.append(self._create_file_info(path, info))
 
         return infos
 

From 28266f1f173f27c0db2aafd9497d4af7eb3f441c Mon Sep 17 00:00:00 2001
From: Slobodan Ilic <slobodan.a.ilic@gmail.com>
Date: Thu, 14 Sep 2023 17:46:32 +0200
Subject: [PATCH 362/749] MINOR: [Python][Docs] Add examples for
 `MapArray.from_arrays` (#37656)

### Rationale for this change
This PR enriched the `MapArray.from_arrays` with some nice examples. The examples are from the real-world scenario of working with survey data (scaled down, of course).

### What changes are included in this PR?
The only change that this PR presents is to the docstring of the `MapArray.from_arrays` function.

### Are these changes tested?
Does not apply

### Are there any user-facing changes?
Yes, the docstring of the `MapArray.from_arrays` function.

Lead-authored-by: Slobodan Ilic <slobodan.a.ilic@gmail.com>
Co-authored-by: Slobodan Ilic <slobodan@crunch.io>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/array.pxi | 73 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index e26b1ad3291b5..e36d8b2f04315 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -2363,6 +2363,79 @@ cdef class MapArray(ListArray):
         Returns
         -------
         map_array : MapArray
+
+        Examples
+        --------
+        First, let's understand the structure of our dataset when viewed in a rectangular data model. 
+        The total of 5 respondents answered the question "How much did you like the movie x?".
+        The value -1 in the integer array means that the value is missing. The boolean array
+        represents the null bitmask corresponding to the missing values in the integer array.
+
+        >>> import pyarrow as pa
+        >>> movies_rectangular = np.ma.masked_array([
+        ...     [10, -1, -1],
+        ...     [8, 4, 5],
+        ...     [-1, 10, 3],
+        ...     [-1, -1, -1],
+        ...     [-1, -1, -1]
+        ... ],
+        ... [
+        ...     [False, True, True],
+        ...     [False, False, False],
+        ...     [True, False, False],
+        ...     [True, True, True],
+        ...     [True, True, True],
+        ... ])
+
+        To represent the same data with the MapArray and from_arrays, the data is
+        formed like this:
+
+        >>> offsets = [
+        ...     0, #  -- row 1 start
+        ...     1, #  -- row 2 start
+        ...     4, #  -- row 3 start
+        ...     6, #  -- row 4 start
+        ...     6, #  -- row 5 start
+        ...     6, #  -- row 5 end
+        ... ]
+        >>> movies = [
+        ...     "Dark Knight", #  ---------------------------------- row 1
+        ...     "Dark Knight", "Meet the Parents", "Superman", #  -- row 2
+        ...     "Meet the Parents", "Superman", #  ----------------- row 3
+        ... ]
+        >>> likings = [
+        ...     10, #  -------- row 1
+        ...     8, 4, 5, #  --- row 2
+        ...     10, 3 #  ------ row 3
+        ... ]
+        >>> pa.MapArray.from_arrays(offsets, movies, likings).to_pandas()
+        0                                  [(Dark Knight, 10)]
+        1    [(Dark Knight, 8), (Meet the Parents, 4), (Sup...
+        2              [(Meet the Parents, 10), (Superman, 3)]
+        3                                                   []
+        4                                                   []
+        dtype: object
+
+        If the data in the empty rows needs to be marked as missing, it's possible
+        to do so by modifying the offsets argument, so that we specify `None` as
+        the starting positions of the rows we want marked as missing. The end row
+        offset still has to refer to the existing value from keys (and values):
+
+        >>> offsets = [
+        ...     0, #  ----- row 1 start
+        ...     1, #  ----- row 2 start
+        ...     4, #  ----- row 3 start
+        ...     None, #  -- row 4 start
+        ...     None, #  -- row 5 start
+        ...     6, #  ----- row 5 end
+        ... ]
+        >>> pa.MapArray.from_arrays(offsets, movies, likings).to_pandas()
+        0                                  [(Dark Knight, 10)]
+        1    [(Dark Knight, 8), (Meet the Parents, 4), (Sup...
+        2              [(Meet the Parents, 10), (Superman, 3)]
+        3                                                 None
+        4                                                 None
+        dtype: object
         """
         cdef:
             Array _offsets, _keys, _items

From 670cf3b820ade8f553a81ba5b3346b74734cf972 Mon Sep 17 00:00:00 2001
From: Matthias Loibl <mail@matthiasloibl.com>
Date: Thu, 14 Sep 2023 18:12:57 +0100
Subject: [PATCH 363/749] GH-37694: [Go] Add SetNull to array builders (#37695)

### Rationale for this change

We are proposing to add a `SetNull(i int)` to the `Builder` interface.
The underlying `builder` type implements this for most types.

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

The SetNull is added to the Builders type.

* Closes: #37694

Authored-by: Matthias Loibl <mail@matthiasloibl.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/builder.go      | 10 ++++++++++
 go/arrow/array/builder_test.go | 24 +++++++++++++++++++++++
 go/arrow/array/map.go          |  4 ++++
 go/arrow/array/map_test.go     | 35 ++++++++++++++++++++++++++++++++++
 4 files changed, 73 insertions(+)

diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index aada095d099b8..58d4a0f4b8895 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -86,6 +86,9 @@ type Builder interface {
 	// IsNull returns if a previously appended value at a given index is null or not.
 	IsNull(i int) bool
 
+	// SetNull sets the value at index i to null.
+	SetNull(i int)
+
 	UnsafeAppendBoolToBitmap(bool)
 
 	init(capacity int)
@@ -126,6 +129,13 @@ func (b *builder) IsNull(i int) bool {
 	return b.nullBitmap.Len() != 0 && bitutil.BitIsNotSet(b.nullBitmap.Bytes(), i)
 }
 
+func (b *builder) SetNull(i int) {
+	if i < 0 || i >= b.length {
+		panic("arrow/array: index out of range")
+	}
+	bitutil.ClearBit(b.nullBitmap.Bytes(), i)
+}
+
 func (b *builder) init(capacity int) {
 	toAlloc := bitutil.CeilByte(capacity) / 8
 	b.nullBitmap = memory.NewResizableBuffer(b.mem)
diff --git a/go/arrow/array/builder_test.go b/go/arrow/array/builder_test.go
index eeb7a2ac46b3f..3cacb54f725e7 100644
--- a/go/arrow/array/builder_test.go
+++ b/go/arrow/array/builder_test.go
@@ -97,3 +97,27 @@ func TestBuilder_IsNull(t *testing.T) {
 		assert.Equal(t, i%2 != 0, b.IsNull(i))
 	}
 }
+
+func TestBuilder_SetNull(t *testing.T) {
+	b := &builder{mem: memory.NewGoAllocator()}
+	n := 32
+	b.init(n)
+
+	for i := 0; i < n; i++ {
+		// Set everything to true
+		b.UnsafeAppendBoolToBitmap(true)
+	}
+	for i := 0; i < n; i++ {
+		if i%2 == 0 { // Set all even numbers to null
+			b.SetNull(i)
+		}
+	}
+
+	for i := 0; i < n; i++ {
+		if i%2 == 0 {
+			assert.True(t, b.IsNull(i))
+		} else {
+			assert.False(t, b.IsNull(i))
+		}
+	}
+}
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index 84c1b55a0cf21..4fe860f26ef61 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -234,6 +234,10 @@ func (b *MapBuilder) AppendNulls(n int) {
 	}
 }
 
+func (b *MapBuilder) SetNull(i int) {
+	b.listBuilder.SetNull(i)
+}
+
 func (b *MapBuilder) AppendEmptyValue() {
 	b.Append(true)
 }
diff --git a/go/arrow/array/map_test.go b/go/arrow/array/map_test.go
index cfb1cac87bedc..3fe78549ec803 100644
--- a/go/arrow/array/map_test.go
+++ b/go/arrow/array/map_test.go
@@ -217,3 +217,38 @@ func TestMapStringRoundTrip(t *testing.T) {
 
 	assert.True(t, array.Equal(arr, arr1))
 }
+
+func TestMapBuilder_SetNull(t *testing.T) {
+	pool := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer pool.AssertSize(t, 0)
+
+	var (
+		arr          *array.Map
+		equalValid   = []bool{true, true, true, true, true, true, true}
+		equalOffsets = []int32{0, 1, 2, 5, 6, 7, 8, 10}
+		equalKeys    = []string{"a", "a", "a", "b", "c", "a", "a", "a", "a", "b"}
+		equalValues  = []int32{1, 2, 3, 4, 5, 2, 2, 2, 5, 6}
+	)
+
+	bldr := array.NewMapBuilder(pool, arrow.BinaryTypes.String, arrow.PrimitiveTypes.Int32, false)
+	defer bldr.Release()
+
+	kb := bldr.KeyBuilder().(*array.StringBuilder)
+	ib := bldr.ItemBuilder().(*array.Int32Builder)
+
+	bldr.AppendValues(equalOffsets, equalValid)
+	for _, k := range equalKeys {
+		kb.Append(k)
+	}
+	ib.AppendValues(equalValues, nil)
+
+	bldr.SetNull(0)
+	bldr.SetNull(3)
+
+	arr = bldr.NewMapArray()
+	defer arr.Release()
+
+	assert.True(t, arr.IsNull(0))
+	assert.True(t, arr.IsValid(1))
+	assert.True(t, arr.IsNull(3))
+}

From 49890e94a0e878c60d8b4a62f48665f494ab2067 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 15 Sep 2023 11:32:28 +0900
Subject: [PATCH 364/749] GH-37715: [Packaging][CentOS] Use default g++ on
 CentOS 9 Stream (#37718)

### Rationale for this change

We can use default g++ by using shared LLVM library.

### What changes are included in this PR?

Use default g++ and remove needless `llvm-static`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37715

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../apache-arrow/yum/centos-9-stream/Dockerfile      | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/dev/tasks/linux-packages/apache-arrow/yum/centos-9-stream/Dockerfile b/dev/tasks/linux-packages/apache-arrow/yum/centos-9-stream/Dockerfile
index 513a63fee8128..b1e1630103c34 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/centos-9-stream/Dockerfile
+++ b/dev/tasks/linux-packages/apache-arrow/yum/centos-9-stream/Dockerfile
@@ -18,15 +18,12 @@
 ARG FROM=quay.io/centos/centos:stream9
 FROM ${FROM}
 
-ENV SCL=gcc-toolset-12
-
 ARG DEBUG
 
 RUN \
   quiet=$([ "${DEBUG}" = "yes" ] || echo "--quiet") && \
   dnf install -y ${quiet} epel-release && \
   dnf install --enablerepo=crb -y ${quiet} \
-    ${SCL} \
     bison \
     boost-devel \
     brotli-devel \
@@ -46,7 +43,6 @@ RUN \
     libarchive \
     libzstd-devel \
     llvm-devel \
-    llvm-static \
     lz4-devel \
     make \
     ncurses-devel \
@@ -65,11 +61,3 @@ RUN \
     vala \
     zlib-devel && \
   dnf clean ${quiet} all
-
-# Workaround: We can remove this once redhat-rpm-config uses "annobin"
-# not "gcc-annobin".
-RUN \
-  sed \
-    -i \
-    -e 's/gcc-annobin/annobin/g' \
-    /usr/lib/rpm/redhat/redhat-annobin-select-gcc-built-plugin

From 783a0023ffdb020b8bf20098e6bffff463a83541 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 15 Sep 2023 11:33:37 +0900
Subject: [PATCH 365/749] GH-37648: [Packaging][Linux] Fix
 libarrow-glib-dev/arrow-glib-devel dependencies (#37714)

### Rationale for this change

Apache Arrow C GLib depends on Acero. So `libarrow-glib-dev`/`arrow-glib-devel` should depend on `libarrow-acero-dev`/`arrow-acero-devel`.

### What changes are included in this PR?

Fix dependencies.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37648

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/linux-packages/apache-arrow/debian/control.in | 2 +-
 dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/tasks/linux-packages/apache-arrow/debian/control.in b/dev/tasks/linux-packages/apache-arrow/debian/control.in
index 8c1bab8d058da..f08fc05bfc3ad 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/control.in
+++ b/dev/tasks/linux-packages/apache-arrow/debian/control.in
@@ -317,7 +317,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libglib2.0-dev,
-  libarrow-dev (= ${binary:Version}),
+  libarrow-acero-dev (= ${binary:Version}),
   libarrow-glib1400 (= ${binary:Version}),
   gir1.2-arrow-1.0 (= ${binary:Version})
 Suggests: libarrow-glib-doc
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 6a87e19cd3091..4691f9e5439da 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -562,7 +562,7 @@ This package contains the libraries for Apache Arrow GLib.
 %package glib-devel
 Summary:	Libraries and header files for Apache Arrow GLib
 License:	Apache-2.0
-Requires:	%{name}-devel = %{version}-%{release}
+Requires:	%{name}-acero-devel = %{version}-%{release}
 Requires:	%{name}%{major_version}-glib-libs = %{version}-%{release}
 Requires:	glib2-devel
 Requires:	gobject-introspection-devel

From a446ff71b87880d399a204b767ee493cff573d15 Mon Sep 17 00:00:00 2001
From: Abe Tomoaki <abe@enzou.tokyo>
Date: Fri, 15 Sep 2023 17:09:45 +0900
Subject: [PATCH 366/749] GH-34567: [JS] Improve build and do not generate
 `bin/bin` directory (#36607)

### Rationale for this change

`bin/bin` directory is unnecessary and should not be generated.

### What changes are included in this PR?

* Add setting to exclude in tsconfig
* Correctly set up `bin` out directory

### Are these changes tested?

The following files are not generated.

```
targets/apache-arrow/bin/bin/arrow2csv.js
targets/apache-arrow/bin/bin/arrow2csv.js.map
targets/apache-arrow/bin/bin/arrow2csv.mjs
targets/apache-arrow/bin/src/bin/arrow2csv.ts
targets/es2015/cjs/bin/bin/arrow2csv.js
targets/es2015/cjs/bin/bin/arrow2csv.js.map
targets/es2015/cjs/bin/src/bin/arrow2csv.ts
targets/es2015/esm/bin/bin/arrow2csv.js
targets/es2015/esm/bin/bin/arrow2csv.js.map
targets/es2015/esm/bin/src/bin/arrow2csv.ts
targets/es2015/umd/bin/bin/arrow2csv.js
targets/es2015/umd/bin/bin/arrow2csv.js.map
targets/es2015/umd/bin/src/bin/arrow2csv.ts
targets/es5/cjs/bin/bin/arrow2csv.js
targets/es5/cjs/bin/bin/arrow2csv.js.map
targets/es5/cjs/bin/src/bin/arrow2csv.ts
targets/es5/esm/bin/bin/arrow2csv.js
targets/es5/esm/bin/bin/arrow2csv.js.map
targets/es5/esm/bin/src/bin/arrow2csv.ts
targets/es5/umd/bin/bin/arrow2csv.js
targets/es5/umd/bin/bin/arrow2csv.js.map
targets/es5/umd/bin/src/bin/arrow2csv.ts
targets/esnext/cjs/bin/bin/arrow2csv.js
targets/esnext/cjs/bin/bin/arrow2csv.js.map
targets/esnext/cjs/bin/src/bin/arrow2csv.ts
targets/esnext/esm/bin/bin/arrow2csv.js
targets/esnext/esm/bin/bin/arrow2csv.js.map
targets/esnext/esm/bin/src/bin/arrow2csv.ts
targets/esnext/umd/bin/bin/arrow2csv.js
targets/esnext/umd/bin/bin/arrow2csv.js.map
targets/esnext/umd/bin/src/bin/arrow2csv.ts
```

### Are there any user-facing changes?

* Closes: #34567

Lead-authored-by: abetomo <abe@enzou.tokyo>
Co-authored-by: ptaylor <paul.e.taylor@me.com>
Signed-off-by: Dominik Moritz <domoritz@gmail.com>
---
 js/.eslintrc.cjs               |  2 +-
 js/gulp/arrow-task.js          | 28 +++++++++++++++++++---------
 js/gulp/typescript-task.js     | 26 ++++++++++++++++++++------
 js/gulpfile.js                 |  4 ++++
 js/src/Arrow.ts                |  2 ++
 js/src/bin/arrow2csv.ts        | 16 ++++++++--------
 js/tsconfig/tsconfig.base.json |  2 +-
 7 files changed, 55 insertions(+), 25 deletions(-)
 mode change 100644 => 100755 js/src/bin/arrow2csv.ts

diff --git a/js/.eslintrc.cjs b/js/.eslintrc.cjs
index b629b862190f4..8a36516eec1c0 100644
--- a/js/.eslintrc.cjs
+++ b/js/.eslintrc.cjs
@@ -23,7 +23,7 @@ module.exports = {
     },
     parser: "@typescript-eslint/parser",
     parserOptions: {
-        project: "tsconfig.json",
+        project: ["tsconfig.json", "tsconfig/tsconfig.bin.cjs.json"],
         sourceType: "module",
         ecmaVersion: 2020,
     },
diff --git a/js/gulp/arrow-task.js b/js/gulp/arrow-task.js
index 411a817ddc09e..2de20947dc2f5 100644
--- a/js/gulp/arrow-task.js
+++ b/js/gulp/arrow-task.js
@@ -15,19 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-import { targetDir, observableFromStreams } from './util.js';
+import { mainExport, targetDir, observableFromStreams } from './util.js';
 
-import { deleteAsync as del } from 'del';
 import gulp from 'gulp';
+import path from 'path';
 import { mkdirp } from 'mkdirp';
+import * as fs from 'fs/promises';
 import gulpRename from 'gulp-rename';
 import gulpReplace from 'gulp-replace';
 import { memoizeTask } from './memoize-task.js';
 import { ReplaySubject, forkJoin as ObservableForkJoin } from 'rxjs';
 import { share } from 'rxjs/operators';
-import util from 'util';
-import stream from 'stream';
-const pipeline = util.promisify(stream.pipeline);
+import { pipeline } from 'stream/promises';
 
 export const arrowTask = ((cache) => memoizeTask(cache, function copyMain(target) {
     const out = targetDir(target);
@@ -54,9 +53,20 @@ export const arrowTask = ((cache) => memoizeTask(cache, function copyMain(target
 }))({});
 
 export const arrowTSTask = ((cache) => memoizeTask(cache, async function copyTS(target, format) {
+    const umd = targetDir(`es5`, `umd`);
     const out = targetDir(target, format);
-    await mkdirp(out);
-    await pipeline(gulp.src(`src/**/*`), gulp.dest(out));
-    await del(`${out}/**/*.js`);
-}))({});
+    const arrowUMD = path.join(umd, `${mainExport}.js`);
+    const arrow2csvUMD = path.join(umd, `bin`, `arrow2csv.js`);
+
+    await mkdirp(path.join(out, 'bin'));
 
+    await Promise.all([
+        pipeline(gulp.src(`src/**/*`), gulp.dest(out)),
+        pipeline(
+            gulp.src([arrowUMD, arrow2csvUMD]),
+            gulpReplace(`../${mainExport}.js`, `./${mainExport}.js`),
+            gulp.dest(path.join(out, 'bin'))
+        ),
+        fs.writeFile(path.join(out, 'bin', 'package.json'), '{"type": "commonjs"}')
+    ]);
+}))({});
diff --git a/js/gulp/typescript-task.js b/js/gulp/typescript-task.js
index 02192192327ad..31769e3b1b236 100644
--- a/js/gulp/typescript-task.js
+++ b/js/gulp/typescript-task.js
@@ -19,12 +19,13 @@ import { targetDir, tsconfigName, observableFromStreams, shouldRunInChildProcess
 
 import gulp from 'gulp';
 import path from 'path';
-import ts from 'gulp-typescript';
 import tsc from 'typescript';
+import ts from 'gulp-typescript';
+import * as fs from 'fs/promises';
 import sourcemaps from 'gulp-sourcemaps';
 import { memoizeTask } from './memoize-task.js';
-import { ReplaySubject, forkJoin as ObservableForkJoin } from 'rxjs';
-import { mergeWith, takeLast, share } from 'rxjs/operators';
+import { ReplaySubject, forkJoin as ObservableForkJoin, defer as ObservableDefer } from 'rxjs';
+import { mergeWith, takeLast, share, concat } from 'rxjs/operators';
 
 export const typescriptTask = ((cache) => memoizeTask(cache, function typescript(target, format) {
     if (shouldRunInChildProcess(target, format)) {
@@ -44,10 +45,15 @@ export default typescriptTask;
 export function compileBinFiles(target, format) {
     const out = targetDir(target, format);
     const tsconfigPath = path.join(`tsconfig`, `tsconfig.${tsconfigName('bin', 'cjs')}.json`);
-    return compileTypescript(path.join(out, 'bin'), tsconfigPath, { target });
+    const tsconfigOverrides = format === 'esm' ? { target, module: 'ES2015' } : { target };
+    return compileTypescript(out, tsconfigPath, tsconfigOverrides, false)
+      .pipe(takeLast(1))
+      .pipe(concat(ObservableDefer(() => {
+        return fs.chmod(path.join(out, 'bin', 'arrow2csv.js'), 0o755);
+      })));
 }
 
-function compileTypescript(out, tsconfigPath, tsconfigOverrides) {
+function compileTypescript(out, tsconfigPath, tsconfigOverrides, writeSourcemaps = true) {
     const tsProject = ts.createProject(tsconfigPath, { typescript: tsc, ...tsconfigOverrides });
     const { stream: { js, dts } } = observableFromStreams(
         tsProject.src(), sourcemaps.init(),
@@ -56,7 +62,15 @@ function compileTypescript(out, tsconfigPath, tsconfigOverrides) {
     const writeSources = observableFromStreams(tsProject.src(), gulp.dest(path.join(out, 'src')));
     const writeDTypes = observableFromStreams(dts, sourcemaps.write('./', { includeContent: false, sourceRoot: './src' }), gulp.dest(out));
     const mapFile = tsProject.options.module === tsc.ModuleKind.ES2015 ? esmMapFile : cjsMapFile;
-    const writeJS = observableFromStreams(js, sourcemaps.write('./', { mapFile, includeContent: false, sourceRoot: './src' }), gulp.dest(out));
+    const writeJSArgs = writeSourcemaps ? [
+        js,
+        sourcemaps.write('./', { mapFile, includeContent: false, sourceRoot: './src' }),
+        gulp.dest(out)
+      ] : [
+        js,
+        gulp.dest(out)
+      ];
+    const writeJS = observableFromStreams(...writeJSArgs);
     return ObservableForkJoin([writeSources, writeDTypes, writeJS]);
 }
 
diff --git a/js/gulpfile.js b/js/gulpfile.js
index 6544b987b73f6..bf84a4a9e1b49 100644
--- a/js/gulpfile.js
+++ b/js/gulpfile.js
@@ -54,6 +54,10 @@ knownTargets.forEach((target) => {
     ));
 });
 
+gulp.task(`build:ts`, gulp.series(
+    `build:es5:umd`, `clean:ts`, `compile:ts`, `package:ts`
+));
+
 // The main "apache-arrow" module builds the es2015/umd, es2015/cjs,
 // es2015/esm, and esnext/umd targets, then copies and renames the
 // compiled output into the apache-arrow folder
diff --git a/js/src/Arrow.ts b/js/src/Arrow.ts
index dc44e10b9206f..4a6394c266b1b 100644
--- a/js/src/Arrow.ts
+++ b/js/src/Arrow.ts
@@ -99,6 +99,7 @@ import * as util_bit_ from './util/bit.js';
 import * as util_math_ from './util/math.js';
 import * as util_buffer_ from './util/buffer.js';
 import * as util_vector_ from './util/vector.js';
+import * as util_pretty_ from './util/pretty.js';
 import { compareSchemas, compareFields, compareTypes } from './visitor/typecomparator.js';
 
 /** @ignore */
@@ -109,6 +110,7 @@ export const util = {
     ...util_math_,
     ...util_buffer_,
     ...util_vector_,
+    ...util_pretty_,
     compareSchemas,
     compareFields,
     compareTypes,
diff --git a/js/src/bin/arrow2csv.ts b/js/src/bin/arrow2csv.ts
old mode 100644
new mode 100755
index eae7f5805c41c..39db8c17497cd
--- a/js/src/bin/arrow2csv.ts
+++ b/js/src/bin/arrow2csv.ts
@@ -21,8 +21,7 @@
 
 import * as fs from 'fs';
 import * as stream from 'stream';
-import { valueToString } from '../util/pretty.js';
-import { Schema, RecordBatch, RecordBatchReader, AsyncByteQueue } from '../Arrow.node.js';
+import { Schema, RecordBatch, RecordBatchReader, AsyncByteQueue, util } from '../Arrow.js';
 
 import commandLineUsage from 'command-line-usage';
 import commandLineArgs from 'command-line-args';
@@ -58,9 +57,10 @@ type ToStringState = {
         if (state.closed) { break; }
         for await (reader of recordBatchReaders(source)) {
             hasReaders = true;
-            const transformToString = batchesToString(state, reader.schema);
+            const batches = stream.Readable.from(reader);
+            const toString = batchesToString(state, reader.schema);
             await pipeTo(
-                reader.pipe(transformToString),
+                batches.pipe(toString),
                 process.stdout, { end: false }
             ).catch(() => state.closed = true); // Handle EPIPE errors
         }
@@ -129,7 +129,7 @@ function batchesToString(state: ToStringState, schema: Schema) {
     let maxColWidths = [10];
     const { hr, sep, metadata } = state;
 
-    const header = ['row_id', ...schema.fields.map((f) => `${f}`)].map(val => valueToString(val));
+    const header = ['row_id', ...schema.fields.map((f) => `${f}`)].map(val => util.valueToString(val));
 
     state.maxColWidths = header.map((x, i) => Math.max(maxColWidths[i] || 0, x.length));
 
@@ -181,7 +181,7 @@ function batchesToString(state: ToStringState, schema: Schema) {
                     if (rowId % 350 === 0) {
                         this.push(`${formatRow(header, maxColWidths, sep)}\n`);
                     }
-                    this.push(`${formatRow([rowId++, ...row.toArray()].map(v => valueToString(v)), maxColWidths, sep)}\n`);
+                    this.push(`${formatRow([rowId++, ...row.toArray()].map(v => util.valueToString(v)), maxColWidths, sep)}\n`);
                 }
             }
             cb();
@@ -202,7 +202,7 @@ function formatMetadataValue(value = '') {
     try {
         parsed = JSON.stringify(JSON.parse(value), null, 2);
     } catch { parsed = value; }
-    return valueToString(parsed).split('\n').join('\n  ');
+    return util.valueToString(parsed).split('\n').join('\n  ');
 }
 
 function formatMetadata(metadata: Map<string, string>) {
@@ -236,7 +236,7 @@ function measureColumnWidths(rowId: number, batch: RecordBatch, maxColWidths: nu
                     (val.length * elementWidth) // width of stringified 2^N-1
                 );
             } else {
-                maxColWidths[j + 1] = Math.max(maxColWidths[j + 1] || 0, valueToString(val).length);
+                maxColWidths[j + 1] = Math.max(maxColWidths[j + 1] || 0, util.valueToString(val).length);
             }
             ++j;
         }
diff --git a/js/tsconfig/tsconfig.base.json b/js/tsconfig/tsconfig.base.json
index fb4ecb38b5892..0d7fefd90949f 100644
--- a/js/tsconfig/tsconfig.base.json
+++ b/js/tsconfig/tsconfig.base.json
@@ -1,5 +1,5 @@
 {
-  "exclude": ["../node_modules"],
+  "exclude": ["../node_modules", "../src/bin/*.ts"],
   "include": ["../src/**/*.ts"],
   "compileOnSave": false,
   "compilerOptions": {

From d8ab9a802227468976958b109c08c1ca9637a7e8 Mon Sep 17 00:00:00 2001
From: Christian Lorentzen <lorentzen.ch@gmail.com>
Date: Fri, 15 Sep 2023 10:12:26 +0200
Subject: [PATCH 367/749] MINOR: [C++][Python] [Docs] clearer description of q
 argument of quantiles (#37380)

### Rationale for this change
Documention of the `q` parameter of quantiles is made more precise.

### What changes are included in this PR?
Only documentation changes.

### Are these changes tested?
No

### Are there any user-facing changes?
No

Authored-by: Christian Lorentzen <lorentzen.ch@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/compute/api_aggregate.h | 4 ++--
 python/pyarrow/_compute.pyx           | 6 ++++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/compute/api_aggregate.h b/cpp/src/arrow/compute/api_aggregate.h
index 8f45f6199fbe1..3493c3146310d 100644
--- a/cpp/src/arrow/compute/api_aggregate.h
+++ b/cpp/src/arrow/compute/api_aggregate.h
@@ -138,7 +138,7 @@ class ARROW_EXPORT QuantileOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "QuantileOptions";
   static QuantileOptions Defaults() { return QuantileOptions{}; }
 
-  /// quantile must be between 0 and 1 inclusive
+  /// probability level of quantile must be between 0 and 1 inclusive
   std::vector<double> q;
   enum Interpolation interpolation;
   /// If true (the default), null values are ignored. Otherwise, if any value is null,
@@ -162,7 +162,7 @@ class ARROW_EXPORT TDigestOptions : public FunctionOptions {
   static constexpr char const kTypeName[] = "TDigestOptions";
   static TDigestOptions Defaults() { return TDigestOptions{}; }
 
-  /// quantile must be between 0 and 1 inclusive
+  /// probability level of quantile must be between 0 and 1 inclusive
   std::vector<double> q;
   /// compression parameter, default 100
   uint32_t delta;
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 0c1744febbe1e..609307528d2ec 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -2145,7 +2145,8 @@ class QuantileOptions(_QuantileOptions):
     Parameters
     ----------
     q : double or sequence of double, default 0.5
-        Quantiles to compute. All values must be in [0, 1].
+        Probability levels of the quantiles to compute. All values must be in
+        [0, 1].
     interpolation : str, default "linear"
         How to break ties between competing data points for a given quantile.
         Accepted values are:
@@ -2182,7 +2183,8 @@ class TDigestOptions(_TDigestOptions):
     Parameters
     ----------
     q : double or sequence of double, default 0.5
-        Quantiles to approximate. All values must be in [0, 1].
+        Probability levels of the quantiles to approximate. All values must be
+        in [0, 1].
     delta : int, default 100
         Compression parameter for the T-digest algorithm.
     buffer_size : int, default 500

From ac7e9a4c41b73242b2f7a15f13f3c8fde843416d Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Fri, 15 Sep 2023 00:50:20 -0800
Subject: [PATCH 368/749] GH-34105: [R] Provide extra output for failed builds
 (#37727)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

This is a replacement for the previous PR https://github.com/apache/arrow/pull/37698. The rationale for this PR is providing extra output for R package builds where the C++ build fails

### What changes are included in this PR?

Update the system call to save output when building Arrow C++ from the R package and output it if it's failed

### Are these changes tested?

No automated tests but the changes have been tested manually.

### Are there any user-facing changes?

Yes, but only for users building the R package from source which is hopefully not common.
* Closes: #34105

Lead-authored-by: Bryce Mecum <petridish@gmail.com>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 r/tools/nixlibs.R | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index dca277c80948c..3d908c05cab07 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -473,17 +473,25 @@ build_libarrow <- function(src_dir, dst_dir) {
   env_vars <- env_vars_as_string(env_var_list)
 
   cat("**** arrow", ifelse(quietly, "", paste("with", env_vars)), "\n")
-  status <- suppressWarnings(system(
-    paste(env_vars, "inst/build_arrow_static.sh"),
-    ignore.stdout = quietly, ignore.stderr = quietly
+
+  build_log_path <- tempfile(fileext = ".log")
+  status <- suppressWarnings(system2(
+    "bash",
+    "inst/build_arrow_static.sh",
+    env = env_vars,
+    stdout = ifelse(quietly, build_log_path, ""),
+    stderr = ifelse(quietly, build_log_path, "")
   ))
+
   if (status != 0) {
     # It failed :(
-    cat(
-      "**** Error building Arrow C++.",
-      ifelse(env_is("ARROW_R_DEV", "true"), "", "Re-run with ARROW_R_DEV=true for debug information."),
-      "\n"
-    )
+    cat("**** Error building Arrow C++.", "\n")
+    if (quietly) {
+      cat("**** Printing contents of build log because the build failed", 
+          "while ARROW_R_DEV was set to FALSE\n")
+      cat(readLines(build_log_path), sep = "\n")
+      cat("**** Complete build log may still be present at", build_log_path, "\n")
+    }
   }
   invisible(status)
 }

From d9ee3a7961df44a1e30d3fe615ee3a20af569025 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 15 Sep 2023 23:38:23 +0800
Subject: [PATCH 369/749] GH-37643: [C++] Enhance arrow::Datum::ToString
 (#37646)

### Rationale for this change

Add print child fields for `arrow::Datum::ToString`. Because previously it just print a type.

### What changes are included in this PR?

Add detail in `arrow::Datum::ToString`

### Are these changes tested?

no

### Are there any user-facing changes?

Yes

* Closes: #37643

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 c_glib/test/test-array-datum.rb         |  2 +-
 c_glib/test/test-chunked-array-datum.rb |  2 +-
 c_glib/test/test-record-batch-datum.rb  |  2 +-
 c_glib/test/test-scalar-datum.rb        |  2 +-
 c_glib/test/test-table-datum.rb         | 11 ++++++++++-
 cpp/src/arrow/datum.cc                  | 10 +++++-----
 cpp/src/arrow/datum.h                   |  1 -
 cpp/src/arrow/datum_test.cc             |  4 ++--
 8 files changed, 21 insertions(+), 13 deletions(-)

diff --git a/c_glib/test/test-array-datum.rb b/c_glib/test/test-array-datum.rb
index 623e5589ce40b..1b2c9f91e2aa2 100644
--- a/c_glib/test/test-array-datum.rb
+++ b/c_glib/test/test-array-datum.rb
@@ -61,7 +61,7 @@ def test_false
   end
 
   def test_to_string
-    assert_equal("Array", @datum.to_s)
+    assert_equal("Array([\n" + "  true,\n" + "  false\n" + "])", @datum.to_s)
   end
 
   def test_value
diff --git a/c_glib/test/test-chunked-array-datum.rb b/c_glib/test/test-chunked-array-datum.rb
index 76317315327e8..b82f3eed8a7af 100644
--- a/c_glib/test/test-chunked-array-datum.rb
+++ b/c_glib/test/test-chunked-array-datum.rb
@@ -49,7 +49,7 @@ def test_false
   end
 
   def test_to_string
-    assert_equal("ChunkedArray", @datum.to_s)
+    assert_equal("ChunkedArray([\n" + "  [\n" + "    true,\n" + "    false\n" + "  ]\n" + "])", @datum.to_s)
   end
 
   def test_value
diff --git a/c_glib/test/test-record-batch-datum.rb b/c_glib/test/test-record-batch-datum.rb
index 33eb793ba869a..ec572e0f13023 100644
--- a/c_glib/test/test-record-batch-datum.rb
+++ b/c_glib/test/test-record-batch-datum.rb
@@ -49,7 +49,7 @@ def test_false
   end
 
   def test_to_string
-    assert_equal("RecordBatch", @datum.to_s)
+    assert_equal("RecordBatch(visible:   [\n" + "    true,\n" + "    false\n" + "  ]\n" + ")", @datum.to_s)
   end
 
   def test_value
diff --git a/c_glib/test/test-scalar-datum.rb b/c_glib/test/test-scalar-datum.rb
index 17e5d6b061cc7..32a5331518d8b 100644
--- a/c_glib/test/test-scalar-datum.rb
+++ b/c_glib/test/test-scalar-datum.rb
@@ -60,7 +60,7 @@ def test_false
   end
 
   def test_to_string
-    assert_equal("Scalar", @datum.to_s)
+    assert_equal("Scalar(true)", @datum.to_s)
   end
 
   def test_value
diff --git a/c_glib/test/test-table-datum.rb b/c_glib/test/test-table-datum.rb
index 7ff3997e88a37..c34ecf6314118 100644
--- a/c_glib/test/test-table-datum.rb
+++ b/c_glib/test/test-table-datum.rb
@@ -49,7 +49,16 @@ def test_false
   end
 
   def test_to_string
-    assert_equal("Table", @datum.to_s)
+    assert_equal("Table(visible: bool\n" +
+    "----\n" +
+    "visible:\n" +
+    "  [\n" +
+    "    [\n" +
+    "      true,\n" +
+    "      false\n" +
+    "    ]\n" +
+    "  ]\n" +
+    ")", @datum.to_s)
   end
 
   def test_value
diff --git a/cpp/src/arrow/datum.cc b/cpp/src/arrow/datum.cc
index d0b5cf62c61be..2ac230232e1b7 100644
--- a/cpp/src/arrow/datum.cc
+++ b/cpp/src/arrow/datum.cc
@@ -182,15 +182,15 @@ std::string Datum::ToString() const {
     case Datum::NONE:
       return "nullptr";
     case Datum::SCALAR:
-      return "Scalar";
+      return "Scalar(" + scalar()->ToString() + ")";
     case Datum::ARRAY:
-      return "Array";
+      return "Array(" + make_array()->ToString() + ")";
     case Datum::CHUNKED_ARRAY:
-      return "ChunkedArray";
+      return "ChunkedArray(" + chunked_array()->ToString() + ")";
     case Datum::RECORD_BATCH:
-      return "RecordBatch";
+      return "RecordBatch(" + record_batch()->ToString() + ")";
     case Datum::TABLE:
-      return "Table";
+      return "Table(" + table()->ToString() + ")";
     default:
       DCHECK(false);
       return "";
diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h
index 57ae3731b5ccd..31b2d2274c900 100644
--- a/cpp/src/arrow/datum.h
+++ b/cpp/src/arrow/datum.h
@@ -301,7 +301,6 @@ struct ARROW_EXPORT Datum {
   bool operator==(const Datum& other) const { return Equals(other); }
   bool operator!=(const Datum& other) const { return !Equals(other); }
 
-  /// \brief Return a string representation of the kind of datum stored.
   std::string ToString() const;
 };
 
diff --git a/cpp/src/arrow/datum_test.cc b/cpp/src/arrow/datum_test.cc
index 14daac6a794fc..909d2577e68fb 100644
--- a/cpp/src/arrow/datum_test.cc
+++ b/cpp/src/arrow/datum_test.cc
@@ -154,8 +154,8 @@ TEST(Datum, ToString) {
   Datum v1(arr);
   Datum v2(std::make_shared<Int8Scalar>(1));
 
-  ASSERT_EQ("Array", v1.ToString());
-  ASSERT_EQ("Scalar", v2.ToString());
+  ASSERT_EQ("Array([\n  1,\n  2,\n  3,\n  4\n])", v1.ToString());
+  ASSERT_EQ("Scalar(1)", v2.ToString());
 }
 
 TEST(Datum, TotalBufferSize) {

From e32e87529e0810572821b0e11afbe1562f1e7edd Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 15 Sep 2023 14:40:20 -0400
Subject: [PATCH 370/749] GH-37654: [MATLAB] Add `Fields` property to
 `arrow.type.Type` MATLAB class (#37725)

### Rationale for this change

In order to implement `arrow.array.StructType`, we need to add a property called `Fields` to `arrow.type.Type`. This property will be a N-by-1 `arrow.type.Field` array. Adding `Fields` will let users inspect the `Type`s contained by a `StructType` object.

### What changes are included in this PR?

1. Added `Fields` as a property to `arrow.type.Type`. `Fields` is a 1xN `arrow.type.Field` array, where `N` is the number of fields.

2. Added method `field(idx)` to `arrow.type.Type`. This method accepts a numeric index and returns the `arrow.type.Field` stored at the specified index.

### Are these changes tested?

1. Yes, updated `hFixedWidthType.m` and `tStringType.m` to verify the behavior of the new property and method.
2. Currently, all of the concrete `arrow.type.Type`s do not have any fields. This means the `Fields` property is always a 0x0 `arrow.type.Field` array. Once we implement `StructType`, we will be able to test having a nonempty `Fields` property.

### Are there any user-facing changes?

Yes, users can now extract fields from an `arrow.type.Type` object.

### Future Directions

1. #37724
2. #37653
* Closes: #37654

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |  8 +--
 matlab/src/cpp/arrow/matlab/index/validate.cc | 56 +++++++++++++++
 matlab/src/cpp/arrow/matlab/index/validate.h  | 26 +++++++
 .../cpp/arrow/matlab/tabular/proxy/schema.cc  | 68 ++++++-------------
 .../src/cpp/arrow/matlab/type/proxy/type.cc   | 35 ++++++++++
 matlab/src/cpp/arrow/matlab/type/proxy/type.h |  2 +
 matlab/src/matlab/+arrow/+type/Type.m         | 24 +++++++
 matlab/test/arrow/tabular/tSchema.m           | 10 +--
 matlab/test/arrow/type/hFixedWidthType.m      | 25 +++++++
 matlab/test/arrow/type/tStringType.m          | 25 +++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |  4 +-
 11 files changed, 223 insertions(+), 60 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/index/validate.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/index/validate.h

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 2b3009d51eb5a..4ff77da8d8360 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -174,10 +174,7 @@ namespace arrow::matlab::error {
     static const char* INVALID_TIME_UNIT = "arrow:type:InvalidTimeUnit";
     static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
     static const char* ARRAY_FAILED_TO_CREATE_TYPE_PROXY = "arrow:array:FailedToCreateTypeProxy";
-    static const char* ARROW_TABULAR_SCHEMA_INVALID_NUMERIC_FIELD_INDEX = "arrow:tabular:schema:InvalidNumericFieldIndex";
-    static const char* ARROW_TABULAR_SCHEMA_UNKNOWN_FIELD_NAME = "arrow:tabular:schema:UnknownFieldName";
     static const char* ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME = "arrow:tabular:schema:AmbiguousFieldName";
-    static const char* ARROW_TABULAR_SCHEMA_NUMERIC_FIELD_INDEX_WITH_EMPTY_SCHEMA = "arrow:tabular:schema:NumericFieldIndexWithEmptySchema";
     static const char* UNKNOWN_PROXY_FOR_ARRAY_TYPE = "arrow:array:UnknownProxyForArrayType";
     static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
     static const char* RECORD_BATCH_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:recordbatch:InvalidNumericColumnIndex";
@@ -195,6 +192,7 @@ namespace arrow::matlab::error {
     static const char* CHUNKED_ARRAY_MAKE_FAILED = "arrow:chunkedarray:MakeFailed";
     static const char* CHUNKED_ARRAY_NUMERIC_INDEX_WITH_EMPTY_CHUNKED_ARRAY = "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray";
     static const char* CHUNKED_ARRAY_INVALID_NUMERIC_CHUNK_INDEX = "arrow:chunkedarray:InvalidNumericChunkIndex";
-
-
+    
+    static const char* INDEX_EMPTY_CONTAINER = "arrow:index:EmptyContainer";
+    static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
 }
diff --git a/matlab/src/cpp/arrow/matlab/index/validate.cc b/matlab/src/cpp/arrow/matlab/index/validate.cc
new file mode 100644
index 0000000000000..b24653f1b814c
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/index/validate.cc
@@ -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.
+
+#include "arrow/matlab/index/validate.h"
+
+#include <sstream>
+
+namespace arrow::matlab::index {
+
+    namespace {
+        std::string makeEmptyContainerErrorMessage() {
+            return "Numeric indexing using the field method is not supported for objects with zero fields.";
+        }
+
+        std::string makeIndexOutOfRangeErrorMessage(const int32_t matlab_index, const int32_t num_fields) {
+            std::stringstream error_message_stream;
+            error_message_stream << "Invalid field index: ";
+            // matlab uses 1-based indexing
+            error_message_stream << matlab_index;
+            error_message_stream << ". Field index must be between 1 and the number of fields (";
+            error_message_stream << num_fields;
+            error_message_stream << ").";
+            return error_message_stream.str();
+        }
+    } // anonymous namespace 
+
+    arrow::Status validateNonEmptyContainer(const int32_t num_fields) {
+        if (num_fields == 0) {
+            const auto msg = makeEmptyContainerErrorMessage();
+            return arrow::Status::Invalid(std::move(msg));
+        }
+        return arrow::Status::OK();
+    }
+
+    arrow::Status validateInRange(const int32_t matlab_index, const int32_t num_fields) {
+        if (matlab_index < 1 || matlab_index > num_fields) {
+            const auto msg = makeIndexOutOfRangeErrorMessage(matlab_index, num_fields);
+            return arrow::Status::Invalid(std::move(msg));
+        }
+        return arrow::Status::OK();
+    }
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/index/validate.h b/matlab/src/cpp/arrow/matlab/index/validate.h
new file mode 100644
index 0000000000000..40e109c19e9ef
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/index/validate.h
@@ -0,0 +1,26 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/status.h"
+
+namespace arrow::matlab::index {
+
+    arrow::Status validateNonEmptyContainer(const int32_t num_fields);
+    arrow::Status validateInRange(const int32_t matlab_index, const int32_t num_fields);
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
index 62fe863ca8b5f..ec1ac1eecb2fd 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
@@ -18,6 +18,7 @@
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
 #include "arrow/matlab/type/proxy/field.h"
+#include "arrow/matlab/index/validate.h"
 
 #include "libmexclass/proxy/ProxyManager.h"
 #include "libmexclass/error/Error.h"
@@ -28,25 +29,6 @@
 
 namespace arrow::matlab::tabular::proxy {
 
-    namespace {
-
-        libmexclass::error::Error makeUnknownFieldNameError(const std::string& name) {
-            using namespace libmexclass::error;
-            std::stringstream error_message_stream;
-            error_message_stream << "Unknown field name: '";
-            error_message_stream << name;
-            error_message_stream << "'.";
-            return Error{error::ARROW_TABULAR_SCHEMA_UNKNOWN_FIELD_NAME, error_message_stream.str()};
-        }
-
-        libmexclass::error::Error makeEmptySchemaError() {
-            using namespace libmexclass::error;
-            return Error{error::ARROW_TABULAR_SCHEMA_NUMERIC_FIELD_INDEX_WITH_EMPTY_SCHEMA,
-                         "Numeric indexing using the field method is not supported for schemas with no fields."};
-        }
-
-    }
-
     Schema::Schema(std::shared_ptr<arrow::Schema> schema) : schema{std::move(schema)} {
         REGISTER_METHOD(Schema, getFieldByIndex);
         REGISTER_METHOD(Schema, getFieldByName);
@@ -86,37 +68,27 @@ namespace arrow::matlab::tabular::proxy {
         mda::StructArray args = context.inputs[0];
         const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
         const auto matlab_index = int32_t(index_mda[0]);
-        // Note: MATLAB uses 1-based indexing, so subtract 1.
-        // arrow::Schema::field does not do any bounds checking.
-        const int32_t index = matlab_index - 1;
-        const auto num_fields = schema->num_fields();
 
-        if (num_fields == 0) {
-            const auto& error = makeEmptySchemaError();
-            context.error = error;
-            return;
-        }
+        // Validate there is at least 1 field
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateNonEmptyContainer(schema->num_fields()),
+            context,
+            error::INDEX_EMPTY_CONTAINER);
 
-        if (matlab_index < 1 || matlab_index > num_fields) {
-            using namespace libmexclass::error;
-            const std::string& error_message_id = std::string{error::ARROW_TABULAR_SCHEMA_INVALID_NUMERIC_FIELD_INDEX};
-            std::stringstream error_message_stream;
-            error_message_stream << "Invalid field index: ";
-            error_message_stream << matlab_index;
-            error_message_stream << ". Field index must be between 1 and the number of fields (";
-            error_message_stream << num_fields;
-            error_message_stream << ").";
-            const std::string& error_message = error_message_stream.str();
-            context.error = Error{error_message_id, error_message}; 
-            return;
-        }
+        // Validate the matlab index provided is within the range [1, num_fields]
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateInRange(matlab_index, schema->num_fields()),
+            context,
+            error::INDEX_OUT_OF_RANGE);
 
-        const auto& field = schema->field(index);
-        auto field_proxy = std::make_shared<FieldProxy>(field);
-        const auto field_proxy_id = ProxyManager::manageProxy(field_proxy);
-        const auto field_proxy_id_mda = factory.createScalar(field_proxy_id);
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::Schema::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
 
-        context.outputs[0] = field_proxy_id_mda;
+        auto field = schema->field(index);
+        auto field_proxy = std::make_shared<FieldProxy>(std::move(field));
+        auto field_proxy_id  = ProxyManager::manageProxy(field_proxy);
+        context.outputs[0] = factory.createScalar(field_proxy_id);
     }
 
     void Schema::getFieldByName(libmexclass::proxy::method::Context& context) {
@@ -135,9 +107,7 @@ namespace arrow::matlab::tabular::proxy {
         const auto field = schema->GetFieldByName(name);
         auto field_proxy = std::make_shared<FieldProxy>(field);
         const auto field_proxy_id = ProxyManager::manageProxy(field_proxy);
-        const auto field_proxy_id_mda = factory.createScalar(field_proxy_id);
-
-        context.outputs[0] = field_proxy_id_mda;
+        context.outputs[0] = factory.createScalar(field_proxy_id);
     }
 
     void Schema::getNumFields(libmexclass::proxy::method::Context& context) {
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
index 1eed4e6141347..1cbaaf328ee86 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.cc
@@ -15,7 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/index/validate.h"
 #include "arrow/matlab/type/proxy/type.h"
+#include "arrow/matlab/type/proxy/field.h"
 
 #include "libmexclass/proxy/ProxyManager.h"
 
@@ -24,6 +28,7 @@ namespace arrow::matlab::type::proxy {
     Type::Type(std::shared_ptr<arrow::DataType> type) : data_type{std::move(type)} {
         REGISTER_METHOD(Type, getTypeID);
         REGISTER_METHOD(Type, getNumFields);
+        REGISTER_METHOD(Type, getFieldByIndex);
         REGISTER_METHOD(Type, isEqual);
     }
 
@@ -47,6 +52,36 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = num_fields_mda;
     }
 
+    void Type::getFieldByIndex(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+
+        // Validate there is at least 1 field
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateNonEmptyContainer(data_type->num_fields()),
+            context,
+            error::INDEX_EMPTY_CONTAINER);
+
+        // Validate the matlab index provided is within the range [1, num_fields]
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateInRange(matlab_index, data_type->num_fields()),
+            context,
+            error::INDEX_OUT_OF_RANGE);
+
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        // arrow::DataType::field does not do any bounds checking.
+        const int32_t index = matlab_index - 1;
+
+        auto field = data_type->field(index);
+        auto field_proxy = std::make_shared<proxy::Field>(std::move(field));
+        auto field_proxy_id  = libmexclass::proxy::ProxyManager::manageProxy(field_proxy);
+        context.outputs[0] = factory.createScalar(field_proxy_id);
+    }
+
     void Type::isEqual(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/type.h b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
index efd2b8255aa28..3a6b287a9254e 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/type.h
@@ -37,6 +37,8 @@ class Type : public libmexclass::proxy::Proxy {
 
         void getNumFields(libmexclass::proxy::method::Context& context);
 
+        void getFieldByIndex(libmexclass::proxy::method::Context& context);
+
         void isEqual(libmexclass::proxy::method::Context& context);
 
         std::shared_ptr<arrow::DataType> data_type;
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index 24f83e0267058..0fd0139b18b7a 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -19,6 +19,7 @@
 
     properties (Dependent, GetAccess=public, SetAccess=private)
         ID
+        Fields
         NumFields
     end
 
@@ -41,6 +42,29 @@
         function typeID = get.ID(obj)
             typeID = arrow.type.ID(obj.Proxy.getTypeID());
         end
+
+        function F = field(obj, idx)
+            import arrow.internal.validate.*
+
+            idx = index.numeric(idx, "int32", AllowNonScalar=false);
+            args = struct(Index=idx);
+            proxyID = obj.Proxy.getFieldByIndex(args);
+            proxy = libmexclass.proxy.Proxy(Name="arrow.type.proxy.Field", ID=proxyID);
+            F = arrow.type.Field(proxy);
+        end
+
+        function fields = get.Fields(obj)
+            numFields = obj.NumFields;
+            if numFields == 0
+                fields = arrow.type.Field.empty(0, 0);
+            else
+                fields = cell(1, numFields);
+                for ii = 1:numFields
+                    fields{ii} = obj.field(ii);
+                end
+                fields = horzcat(fields);
+            end
+        end
     end
 
     methods(Access = protected)
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index 3220236d4aabe..e4c706d9a3d6c 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -239,7 +239,7 @@ function GetFieldByNameWithWhitespace(testCase)
             testCase.verifyEqual(field.Type.ID, arrow.type.ID.UInt32);
         end
 
-        function ErrorIfInvalidNumericFieldIndex(testCase)
+        function ErrorIfIndexIsOutOfRange(testCase)
             % Verify that an error is thrown when trying to access a field
             % with an invalid numeric index (e.g. greater than NumFields).
             schema = arrow.schema([...
@@ -250,7 +250,7 @@ function ErrorIfInvalidNumericFieldIndex(testCase)
 
             % Index is greater than NumFields.
             index = 100;
-            testCase.verifyError(@() schema.field(index), "arrow:tabular:schema:InvalidNumericFieldIndex");
+            testCase.verifyError(@() schema.field(index), "arrow:index:OutOfRange");
         end
 
         function ErrorIfFieldNameDoesNotExist(testCase)
@@ -376,7 +376,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
             testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
-            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+            testCase.verifyError(@() schema.field(1), "arrow:index:EmptyContainer");
 
             % 0x1 empty Field array.
             fields = arrow.type.Field.empty(0, 1);
@@ -385,7 +385,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
             testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
-            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+            testCase.verifyError(@() schema.field(1), "arrow:index:EmptyContainer");
 
             % 1x0 empty Field array.
             fields = arrow.type.Field.empty(1, 0);
@@ -394,7 +394,7 @@ function EmptySchema(testCase)
             testCase.verifyEqual(schema.FieldNames, string.empty(1, 0));
             testCase.verifyEqual(schema.Fields, arrow.type.Field.empty(0, 0));
             testCase.verifyError(@() schema.field(0), "arrow:badsubscript:NonPositive");
-            testCase.verifyError(@() schema.field(1), "arrow:tabular:schema:NumericFieldIndexWithEmptySchema");
+            testCase.verifyError(@() schema.field(1), "arrow:index:EmptyContainer");
         end
 
         function GetFieldByNameWithChar(testCase)
diff --git a/matlab/test/arrow/type/hFixedWidthType.m b/matlab/test/arrow/type/hFixedWidthType.m
index adb234bbd3f38..b23c21a6b4feb 100644
--- a/matlab/test/arrow/type/hFixedWidthType.m
+++ b/matlab/test/arrow/type/hFixedWidthType.m
@@ -49,6 +49,31 @@ function TestNumFields(testCase)
             testCase.verifyEqual(arrowType.NumFields, int32(0));
         end
 
+        function TestFieldsProperty(testCase)
+            % Verify Fields is a 0x0 arrow.type.Field array.
+            type = testCase.ArrowType;
+            fields = type.Fields;
+            testCase.verifyEqual(fields, arrow.type.Field.empty(0, 0));
+        end
+
+        function FieldsNoSetter(testCase)
+            % Verify the Fields property is not settable.
+            type = testCase.ArrowType;
+            testCase.verifyError(@() setfield(type, "Fields", "1"), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidFieldIndex(testCase)
+            % Verify the field() method throws the expected error message
+            % when given an invalid index.
+            type = testCase.ArrowType;
+
+            testCase.verifyError(@() type.field(0), "arrow:badsubscript:NonPositive");
+            testCase.verifyError(@() type.field("A"), "arrow:badsubscript:NonNumeric");
+
+            % NOTE: For FixedWidthTypes, Fields is always empty.
+            testCase.verifyError(@() type.field(1), "arrow:index:EmptyContainer");
+        end
+
         function TestBitWidthNoSetter(testCase)
             % Verify that an error is thrown when trying to set the value
             % of the BitWidth property.
diff --git a/matlab/test/arrow/type/tStringType.m b/matlab/test/arrow/type/tStringType.m
index e2a16ab133dbd..3d518b3da3320 100644
--- a/matlab/test/arrow/type/tStringType.m
+++ b/matlab/test/arrow/type/tStringType.m
@@ -64,6 +64,31 @@ function IsEqualFalse(testCase)
             testCase.verifyFalse(isequal(typeArray1, typeArray2));
         end
 
+        function TestFieldsProperty(testCase)
+            % Verify Fields is a 0x0 arrow.type.Field array.
+            type = arrow.string();
+            fields = type.Fields;
+            testCase.verifyEqual(fields, arrow.type.Field.empty(0, 0));
+        end
+
+        function FieldsNoSetter(testCase)
+            % Verify the Fields property is not settable.
+            type = arrow.string();
+            testCase.verifyError(@() setfield(type, "Fields", "1"), "MATLAB:class:SetProhibited");
+        end
+
+        function InvalidFieldIndex(testCase)
+            % Verify the field() method throws the expected error message
+            % when given an invalid index.
+            type = arrow.string();
+
+            testCase.verifyError(@() type.field(0), "arrow:badsubscript:NonPositive");
+            testCase.verifyError(@() type.field("A"), "arrow:badsubscript:NonNumeric");
+
+            % NOTE: For StringType, Fields is always empty.
+            testCase.verifyError(@() type.field(1), "arrow:index:EmptyContainer");
+        end
+
     end
 
 end
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index a5c0b079b34a6..b5c480d6a68e7 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -68,7 +68,9 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/reader.cc")
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/reader.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/index/validate.cc")
+
 
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")

From 60e7d24e1f9d41456313ffb5317eae064d0b4194 Mon Sep 17 00:00:00 2001
From: abandy <abandy@live.com>
Date: Fri, 15 Sep 2023 17:06:41 -0400
Subject: [PATCH 371/749] GH-37744: [Swift] Add test for arrow flight doGet
 FlightData (#37746)

Add a test for the doGet call that handles the FlightData response.
* Closes: #37744

Authored-by: Alva Bandy <abandy@live.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Tests/ArrowFlightTests/FlightTest.swift   | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
index d0db593b10304..3fd52af08b82f 100644
--- a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
+++ b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
@@ -225,6 +225,25 @@ public class FlightClientTester {
         XCTAssertEqual(num_call, 1)
     }
     
+    func doGetTestFlightData() async throws {
+        let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
+        var num_call = 0
+        try await client?.doGet(ticket, flightDataClosure: { flightData in
+            let reader = ArrowReader();
+            let result = reader.fromStream(flightData.dataBody)
+            switch result {
+            case .success(let rb):
+                XCTAssertEqual(rb.schema?.fields.count, 3)
+                XCTAssertEqual(rb.batches[0].length, 4)
+                num_call += 1
+            case .failure(let error):
+                throw error
+            }
+        })
+        
+        XCTAssertEqual(num_call, 1)
+    }
+    
     func doPutTest() async throws {
         let rb = try makeRecordBatch()
         var num_call = 0
@@ -290,6 +309,7 @@ final class FlightTest: XCTestCase {
             try await clientImpl.doActionTest()
             try await clientImpl.getSchemaTest()
             try await clientImpl.doGetTest()
+            try await clientImpl.doGetTestFlightData()
             try await clientImpl.doPutTest()
             try await clientImpl.doExchangeTest()
             

From 1db4c99f2448fc53588848f01eb49c1a51cf5a17 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Fri, 15 Sep 2023 17:14:46 -0400
Subject: [PATCH 372/749] GH-37738: [Go][CI] Update Go version for verification
 (#37745)

### Rationale for this change
Forgot to update the verification script to use the newer version of Go, it was still using Go 1.17

* Closes: #37738

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/verify-release-candidate.sh | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index ce31b497c1fab..77b996766f78c 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -24,7 +24,7 @@
 # - JDK >=7
 # - gcc >= 4.8
 # - Node.js >= 11.12 (best way is to use nvm)
-# - Go >= 1.17
+# - Go >= 1.19
 # - Docker
 #
 # If using a non-system Boost, set BOOST_ROOT and add Boost libraries to
@@ -405,7 +405,7 @@ install_go() {
     return 0
   fi
 
-  local version=1.17.13
+  local version=1.19.13
   show_info "Installing go version ${version}..."
 
   local arch="$(uname -m)"
@@ -422,8 +422,9 @@ install_go() {
   fi
 
   local archive="go${version}.${os}-${arch}.tar.gz"
-  curl -sLO https://dl.google.com/go/$archive
+  curl -sLO https://go.dev/dl/$archive
 
+  ls -l
   local prefix=${ARROW_TMPDIR}/go
   mkdir -p $prefix
   tar -xzf $archive -C $prefix
@@ -860,12 +861,12 @@ test_go() {
   show_header "Build and test Go libraries"
 
   maybe_setup_go || exit 1
-  maybe_setup_conda compilers go=1.17 || exit 1
+  maybe_setup_conda compilers go=1.19 || exit 1
 
   pushd go
   go get -v ./...
   go test ./...
-  go install ./...
+  go install -buildvcs=false ./...
   go clean -modcache
   popd
 }

From 3db62050daa67b927810574dea60fd5b84bcb523 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 15 Sep 2023 14:45:08 -0700
Subject: [PATCH 373/749] GH-37701: [Java] Add default comparators for more
 types (#37748)

### Rationale for this change

Add default comparators for more vector types to make algorithms easier to use and provide more consistency for Java compared to other languages.

### What changes are included in this PR?

Add default type comparators for:
- BitVector
- DateDayVector
- DateMilliVector
- Decimal256Vector
- DecimalVector
- DurationVector
- IntervalDayVector
- TimeMicroVector
- TimeMilliVector
- TimeNanoVector
- TimeSecVector
- TimeStampVector

IntervalMonthDayNanoVector is not supported due to its public type PeriodDuration not being Comparable.
BitVector's getWidth() method does not return valid data by design since its length is smaller than 1 byte. Using a BitVector with a fixed-width type's algorithm will throw an IllegalArgumentException.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37701

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../sort/DefaultVectorComparators.java        | 329 +++++++++++++
 .../FixedWidthOutOfPlaceVectorSorter.java     |   4 +
 .../sort/TestDefaultVectorComparator.java     | 447 ++++++++++++++++++
 .../apache/arrow/vector/Decimal256Vector.java |  12 +-
 .../apache/arrow/vector/DecimalVector.java    |  12 +-
 .../apache/arrow/vector/DurationVector.java   |  14 +-
 .../arrow/vector/IntervalDayVector.java       |  18 +-
 .../testing/ValueVectorDataPopulator.java     |  30 ++
 8 files changed, 858 insertions(+), 8 deletions(-)

diff --git a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
index c418219170380..99d66f94261ee 100644
--- a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
+++ b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
@@ -19,15 +19,31 @@
 
 import static org.apache.arrow.vector.complex.BaseRepeatedValueVector.OFFSET_WIDTH;
 
+import java.math.BigDecimal;
+import java.time.Duration;
+
 import org.apache.arrow.memory.util.ArrowBufPointer;
 import org.apache.arrow.memory.util.ByteFunctionHelpers;
 import org.apache.arrow.vector.BaseFixedWidthVector;
 import org.apache.arrow.vector.BaseVariableWidthVector;
 import org.apache.arrow.vector.BigIntVector;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.DateDayVector;
+import org.apache.arrow.vector.DateMilliVector;
+import org.apache.arrow.vector.Decimal256Vector;
+import org.apache.arrow.vector.DecimalVector;
+import org.apache.arrow.vector.DurationVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.IntervalDayVector;
+import org.apache.arrow.vector.IntervalMonthDayNanoVector;
 import org.apache.arrow.vector.SmallIntVector;
+import org.apache.arrow.vector.TimeMicroVector;
+import org.apache.arrow.vector.TimeMilliVector;
+import org.apache.arrow.vector.TimeNanoVector;
+import org.apache.arrow.vector.TimeSecVector;
+import org.apache.arrow.vector.TimeStampVector;
 import org.apache.arrow.vector.TinyIntVector;
 import org.apache.arrow.vector.UInt1Vector;
 import org.apache.arrow.vector.UInt2Vector;
@@ -69,6 +85,32 @@ public static <T extends ValueVector> VectorValueComparator<T> createDefaultComp
         return (VectorValueComparator<T>) new UInt4Comparator();
       } else if (vector instanceof UInt8Vector) {
         return (VectorValueComparator<T>) new UInt8Comparator();
+      } else if (vector instanceof BitVector) {
+        return (VectorValueComparator<T>) new BitComparator();
+      } else if (vector instanceof DateDayVector) {
+        return (VectorValueComparator<T>) new DateDayComparator();
+      } else if (vector instanceof DateMilliVector) {
+        return (VectorValueComparator<T>) new DateMilliComparator();
+      } else if (vector instanceof Decimal256Vector) {
+        return (VectorValueComparator<T>) new Decimal256Comparator();
+      } else if (vector instanceof DecimalVector) {
+        return (VectorValueComparator<T>) new DecimalComparator();
+      } else if (vector instanceof DurationVector) {
+        return (VectorValueComparator<T>) new DurationComparator();
+      } else if (vector instanceof IntervalDayVector) {
+        return (VectorValueComparator<T>) new IntervalDayComparator();
+      } else if (vector instanceof IntervalMonthDayNanoVector) {
+        throw new IllegalArgumentException("No default comparator for " + vector.getClass().getCanonicalName());
+      } else if (vector instanceof TimeMicroVector) {
+        return (VectorValueComparator<T>) new TimeMicroComparator();
+      } else if (vector instanceof TimeMilliVector) {
+        return (VectorValueComparator<T>) new TimeMilliComparator();
+      } else if (vector instanceof TimeNanoVector) {
+        return (VectorValueComparator<T>) new TimeNanoComparator();
+      } else if (vector instanceof TimeSecVector) {
+        return (VectorValueComparator<T>) new TimeSecComparator();
+      } else if (vector instanceof TimeStampVector) {
+        return (VectorValueComparator<T>) new TimeStampComparator();
       }
     } else if (vector instanceof BaseVariableWidthVector) {
       return (VectorValueComparator<T>) new VariableWidthComparator();
@@ -345,6 +387,293 @@ public VectorValueComparator<Float8Vector> createNew() {
     }
   }
 
+  /**
+   * Default comparator for bit type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class BitComparator extends VectorValueComparator<BitVector> {
+
+    public BitComparator() {
+      super(-1);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      boolean value1 = vector1.get(index1) != 0;
+      boolean value2 = vector2.get(index2) != 0;
+
+      return Boolean.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<BitVector> createNew() {
+      return new BitComparator();
+    }
+  }
+
+  /**
+   * Default comparator for DateDay type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class DateDayComparator extends VectorValueComparator<DateDayVector> {
+
+    public DateDayComparator() {
+      super(DateDayVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      int value1 = vector1.get(index1);
+      int value2 = vector2.get(index2);
+      return Integer.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<DateDayVector> createNew() {
+      return new DateDayComparator();
+    }
+  }
+
+  /**
+   * Default comparator for DateMilli type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class DateMilliComparator extends VectorValueComparator<DateMilliVector> {
+
+    public DateMilliComparator() {
+      super(DateMilliVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      long value1 = vector1.get(index1);
+      long value2 = vector2.get(index2);
+
+      return Long.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<DateMilliVector> createNew() {
+      return new DateMilliComparator();
+    }
+  }
+
+  /**
+   * Default comparator for Decimal256 type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class Decimal256Comparator extends VectorValueComparator<Decimal256Vector> {
+
+    public Decimal256Comparator() {
+      super(Decimal256Vector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      BigDecimal value1 = vector1.getObjectNotNull(index1);
+      BigDecimal value2 = vector2.getObjectNotNull(index2);
+
+      return value1.compareTo(value2);
+    }
+
+    @Override
+    public VectorValueComparator<Decimal256Vector> createNew() {
+      return new Decimal256Comparator();
+    }
+  }
+
+  /**
+   * Default comparator for Decimal type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class DecimalComparator extends VectorValueComparator<DecimalVector> {
+
+    public DecimalComparator() {
+      super(DecimalVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      BigDecimal value1 = vector1.getObjectNotNull(index1);
+      BigDecimal value2 = vector2.getObjectNotNull(index2);
+
+      return value1.compareTo(value2);
+    }
+
+    @Override
+    public VectorValueComparator<DecimalVector> createNew() {
+      return new DecimalComparator();
+    }
+  }
+
+  /**
+   * Default comparator for Duration type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class DurationComparator extends VectorValueComparator<DurationVector> {
+
+    public DurationComparator() {
+      super(DurationVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      Duration value1 = vector1.getObjectNotNull(index1);
+      Duration value2 = vector2.getObjectNotNull(index2);
+
+      return value1.compareTo(value2);
+    }
+
+    @Override
+    public VectorValueComparator<DurationVector> createNew() {
+      return new DurationComparator();
+    }
+  }
+
+  /**
+   * Default comparator for IntervalDay type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class IntervalDayComparator extends VectorValueComparator<IntervalDayVector> {
+
+    public IntervalDayComparator() {
+      super(IntervalDayVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      Duration value1 = vector1.getObjectNotNull(index1);
+      Duration value2 = vector2.getObjectNotNull(index2);
+
+      return value1.compareTo(value2);
+    }
+
+    @Override
+    public VectorValueComparator<IntervalDayVector> createNew() {
+      return new IntervalDayComparator();
+    }
+  }
+
+  /**
+   * Default comparator for TimeMicro type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class TimeMicroComparator extends VectorValueComparator<TimeMicroVector> {
+
+    public TimeMicroComparator() {
+      super(TimeMicroVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      long value1 = vector1.get(index1);
+      long value2 = vector2.get(index2);
+
+      return Long.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<TimeMicroVector> createNew() {
+      return new TimeMicroComparator();
+    }
+  }
+
+  /**
+   * Default comparator for TimeMilli type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class TimeMilliComparator extends VectorValueComparator<TimeMilliVector> {
+
+    public TimeMilliComparator() {
+      super(TimeMilliVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      int value1 = vector1.get(index1);
+      int value2 = vector2.get(index2);
+
+      return Integer.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<TimeMilliVector> createNew() {
+      return new TimeMilliComparator();
+    }
+  }
+
+  /**
+   * Default comparator for TimeNano type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class TimeNanoComparator extends VectorValueComparator<TimeNanoVector> {
+
+    public TimeNanoComparator() {
+      super(TimeNanoVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      long value1 = vector1.get(index1);
+      long value2 = vector2.get(index2);
+
+      return Long.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<TimeNanoVector> createNew() {
+      return new TimeNanoComparator();
+    }
+  }
+
+  /**
+   * Default comparator for TimeSec type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class TimeSecComparator extends VectorValueComparator<TimeSecVector> {
+
+    public TimeSecComparator() {
+      super(TimeSecVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      int value1 = vector1.get(index1);
+      int value2 = vector2.get(index2);
+
+      return Integer.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<TimeSecVector> createNew() {
+      return new TimeSecComparator();
+    }
+  }
+
+  /**
+   * Default comparator for TimeSec type.
+   * The comparison is based on values, with null comes first.
+   */
+  public static class TimeStampComparator extends VectorValueComparator<TimeStampVector> {
+
+    public TimeStampComparator() {
+      super(TimeStampVector.TYPE_WIDTH);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      long value1 = vector1.get(index1);
+      long value2 = vector2.get(index2);
+
+      return Long.compare(value1, value2);
+    }
+
+    @Override
+    public VectorValueComparator<TimeStampVector> createNew() {
+      return new TimeStampComparator();
+    }
+  }
+
   /**
    * Default comparator for {@link org.apache.arrow.vector.BaseVariableWidthVector}.
    * The comparison is in lexicographic order, with null comes first.
diff --git a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/FixedWidthOutOfPlaceVectorSorter.java b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/FixedWidthOutOfPlaceVectorSorter.java
index 43d604060d086..c3b68facfda97 100644
--- a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/FixedWidthOutOfPlaceVectorSorter.java
+++ b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/FixedWidthOutOfPlaceVectorSorter.java
@@ -21,6 +21,7 @@
 import org.apache.arrow.memory.util.MemoryUtil;
 import org.apache.arrow.util.Preconditions;
 import org.apache.arrow.vector.BaseFixedWidthVector;
+import org.apache.arrow.vector.BitVector;
 import org.apache.arrow.vector.BitVectorHelper;
 import org.apache.arrow.vector.IntVector;
 
@@ -35,6 +36,9 @@ public class FixedWidthOutOfPlaceVectorSorter<V extends BaseFixedWidthVector> im
 
   @Override
   public void sortOutOfPlace(V srcVector, V dstVector, VectorValueComparator<V> comparator) {
+    if (srcVector instanceof BitVector) {
+      throw new IllegalArgumentException("BitVector is not supported with FixedWidthOutOfPlaceVectorSorter.");
+    }
     comparator.attachVector(srcVector);
 
     int valueWidth = comparator.getValueWidth();
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
index 818bb60d116da..62051197740d8 100644
--- a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
@@ -25,8 +25,23 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.vector.BigIntVector;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.DateDayVector;
+import org.apache.arrow.vector.DateMilliVector;
+import org.apache.arrow.vector.Decimal256Vector;
+import org.apache.arrow.vector.DecimalVector;
+import org.apache.arrow.vector.DurationVector;
+import org.apache.arrow.vector.Float4Vector;
+import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.IntervalDayVector;
 import org.apache.arrow.vector.SmallIntVector;
+import org.apache.arrow.vector.TimeMicroVector;
+import org.apache.arrow.vector.TimeMilliVector;
+import org.apache.arrow.vector.TimeNanoVector;
+import org.apache.arrow.vector.TimeSecVector;
+import org.apache.arrow.vector.TimeStampMilliVector;
+import org.apache.arrow.vector.TimeStampVector;
 import org.apache.arrow.vector.TinyIntVector;
 import org.apache.arrow.vector.UInt1Vector;
 import org.apache.arrow.vector.UInt2Vector;
@@ -34,6 +49,7 @@
 import org.apache.arrow.vector.UInt8Vector;
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
+import org.apache.arrow.vector.types.TimeUnit;
 import org.apache.arrow.vector.types.Types;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.FieldType;
@@ -271,6 +287,76 @@ public void testCompareUInt8() {
     }
   }
 
+  @Test
+  public void testCompareFloat4() {
+    try (Float4Vector vec = new Float4Vector("", allocator)) {
+      vec.allocateNew(9);
+      ValueVectorDataPopulator.setVector(
+          vec, -1.1f, 0.0f, 1.0f, null, 1.0f, 2.0f, Float.NaN, Float.NaN, Float.POSITIVE_INFINITY,
+          Float.NEGATIVE_INFINITY);
+
+      VectorValueComparator<Float4Vector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+      assertTrue(comparator.compare(8, 3) > 0);
+
+      // NaN behavior.
+      assertTrue(comparator.compare(6, 7) == 0);
+      assertTrue(comparator.compare(7, 6) == 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+      assertTrue(comparator.compare(6, 0) > 0);
+      assertTrue(comparator.compare(6, 8) > 0);
+      assertTrue(comparator.compare(6, 3) > 0);
+    }
+  }
+
+  @Test
+  public void testCompareFloat8() {
+    try (Float8Vector vec = new Float8Vector("", allocator)) {
+      vec.allocateNew(9);
+      ValueVectorDataPopulator.setVector(
+          vec, -1.1, 0.0, 1.0, null, 1.0, 2.0, Double.NaN, Double.NaN, Double.POSITIVE_INFINITY,
+          Double.NEGATIVE_INFINITY);
+
+      VectorValueComparator<Float8Vector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+      assertTrue(comparator.compare(8, 3) > 0);
+
+      // NaN behavior.
+      assertTrue(comparator.compare(6, 7) == 0);
+      assertTrue(comparator.compare(7, 6) == 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+      assertTrue(comparator.compare(6, 0) > 0);
+      assertTrue(comparator.compare(6, 8) > 0);
+      assertTrue(comparator.compare(6, 3) > 0);
+    }
+  }
+
   @Test
   public void testCompareLong() {
     try (BigIntVector vec = new BigIntVector("", allocator)) {
@@ -393,6 +479,367 @@ public void testCompareByte() {
     }
   }
 
+  @Test
+  public void testCompareBit() {
+    try (BitVector vec = new BitVector("", allocator)) {
+      vec.allocateNew(6);
+      ValueVectorDataPopulator.setVector(
+          vec, 1, 2, 0, 0, -1, null);
+
+      VectorValueComparator<BitVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) == 0);
+      assertTrue(comparator.compare(0, 2) > 0);
+      assertTrue(comparator.compare(0, 4) == 0);
+      assertTrue(comparator.compare(2, 1) < 0);
+      assertTrue(comparator.compare(2, 4) < 0);
+
+      // null first
+      assertTrue(comparator.compare(5, 0) < 0);
+      assertTrue(comparator.compare(5, 2) < 0);
+    }
+  }
+
+  @Test
+  public void testCompareDateDay() {
+    try (DateDayVector vec = new DateDayVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1, 0, 1, null, 1, 5, Integer.MIN_VALUE + 1, Integer.MAX_VALUE);
+
+      VectorValueComparator<DateDayVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareDateMilli() {
+    try (DateMilliVector vec = new DateMilliVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<DateMilliVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareDecimal() {
+    try (DecimalVector vec = new DecimalVector("", allocator, 10, 1)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<DecimalVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareDecimal256() {
+    try (Decimal256Vector vec = new Decimal256Vector("", allocator, 10, 1)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<Decimal256Vector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareDuration() {
+    try (DurationVector vec =
+             new DurationVector("", FieldType.nullable(new ArrowType.Duration(TimeUnit.MILLISECOND)), allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<DurationVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareIntervalDay() {
+    try (IntervalDayVector vec =
+             new IntervalDayVector("", FieldType.nullable(new ArrowType.Duration(TimeUnit.MILLISECOND)), allocator)) {
+      vec.allocateNew(8);
+      vec.set(0, -1, 0);
+      vec.set(1, 0, 0);
+      vec.set(2, 1, 0);
+      vec.setNull(3);
+      vec.set(4, -1, -1);
+      vec.set(5, 1, 1);
+      vec.set(6, 1, 1);
+      vec.set(7, -1, -1);
+
+      VectorValueComparator<IntervalDayVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+      assertTrue(comparator.compare(2, 5) < 0);
+      assertTrue(comparator.compare(0, 4) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 6) == 0);
+      assertTrue(comparator.compare(4, 7) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+    }
+  }
+
+  @Test
+  public void testCompareTimeMicro() {
+    try (TimeMicroVector vec =
+             new TimeMicroVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<TimeMicroVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareTimeMilli() {
+    try (TimeMilliVector vec = new TimeMilliVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1, 0, 1, null, 1, 5, Integer.MIN_VALUE + 1, Integer.MAX_VALUE);
+
+      VectorValueComparator<TimeMilliVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareTimeNano() {
+    try (TimeNanoVector vec =
+             new TimeNanoVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<TimeNanoVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareTimeSec() {
+    try (TimeSecVector vec = new TimeSecVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1, 0, 1, null, 1, 5, Integer.MIN_VALUE + 1, Integer.MAX_VALUE);
+
+      VectorValueComparator<TimeSecVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareTimeStamp() {
+    try (TimeStampMilliVector vec =
+             new TimeStampMilliVector("", allocator)) {
+      vec.allocateNew(8);
+      ValueVectorDataPopulator.setVector(
+          vec, -1L, 0L, 1L, null, 1L, 5L, Long.MIN_VALUE + 1L, Long.MAX_VALUE);
+
+      VectorValueComparator<TimeStampVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+
+      assertTrue(comparator.compare(0, 1) < 0);
+      assertTrue(comparator.compare(0, 2) < 0);
+      assertTrue(comparator.compare(2, 1) > 0);
+
+      // test equality
+      assertTrue(comparator.compare(5, 5) == 0);
+      assertTrue(comparator.compare(2, 4) == 0);
+
+      // null first
+      assertTrue(comparator.compare(3, 4) < 0);
+      assertTrue(comparator.compare(5, 3) > 0);
+
+      // potential overflow
+      assertTrue(comparator.compare(6, 7) < 0);
+      assertTrue(comparator.compare(7, 6) > 0);
+      assertTrue(comparator.compare(7, 7) == 0);
+    }
+  }
+
   @Test
   public void testCheckNullsOnCompareIsFalseForNonNullableVector() {
     try (IntVector vec = new IntVector("not nullable",
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java b/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
index 4ccee50d6805a..70a895ff40496 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
@@ -154,10 +154,20 @@ public BigDecimal getObject(int index) {
     if (isSet(index) == 0) {
       return null;
     } else {
-      return DecimalUtility.getBigDecimalFromArrowBuf(valueBuffer, index, scale, TYPE_WIDTH);
+      return getObjectNotNull(index);
     }
   }
 
+  /**
+   * Same as {@link #getObject(int)}, but does not check for null.
+   *
+   * @param index   position of element
+   * @return element at given index
+   */
+  public BigDecimal getObjectNotNull(int index) {
+    return DecimalUtility.getBigDecimalFromArrowBuf(valueBuffer, index, scale, TYPE_WIDTH);
+  }
+
   /**
    * Return precision for the decimal value.
    */
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java b/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
index db04563df24d7..6a3ec60afc52e 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
@@ -153,10 +153,20 @@ public BigDecimal getObject(int index) {
     if (isSet(index) == 0) {
       return null;
     } else {
-      return DecimalUtility.getBigDecimalFromArrowBuf(valueBuffer, index, scale, TYPE_WIDTH);
+      return getObjectNotNull(index);
     }
   }
 
+  /**
+   * Same as {@link #getObect(int)} but does not check for null.
+   *
+   * @param index   position of element
+   * @return element at given index
+   */
+  public BigDecimal getObjectNotNull(int index) {
+    return DecimalUtility.getBigDecimalFromArrowBuf(valueBuffer, index, scale, TYPE_WIDTH);
+  }
+
   /**
    * Return precision for the decimal value.
    */
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/DurationVector.java b/java/vector/src/main/java/org/apache/arrow/vector/DurationVector.java
index 1e1db0d1c3c5f..b6abc16194b77 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/DurationVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/DurationVector.java
@@ -147,11 +147,21 @@ public Duration getObject(int index) {
     if (isSet(index) == 0) {
       return null;
     } else {
-      final long value = get(valueBuffer, index);
-      return toDuration(value, unit);
+      return getObjectNotNull(index);
     }
   }
 
+  /**
+   * Same as {@link #getObject(int)} but does not check for null.
+   *
+   * @param index   position of element
+   * @return element at given index
+   */
+  public Duration getObjectNotNull(int index) {
+    final long value = get(valueBuffer, index);
+    return toDuration(value, unit);
+  }
+
   /**
    * Converts the given value and unit to the appropriate {@link Duration}.
    */
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/IntervalDayVector.java b/java/vector/src/main/java/org/apache/arrow/vector/IntervalDayVector.java
index 35312ba7c96a1..7c0d19baa9a6f 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/IntervalDayVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/IntervalDayVector.java
@@ -168,13 +168,23 @@ public Duration getObject(int index) {
     if (isSet(index) == 0) {
       return null;
     } else {
-      final long startIndex = (long) index * TYPE_WIDTH;
-      final int days = valueBuffer.getInt(startIndex);
-      final int milliseconds = valueBuffer.getInt(startIndex + MILLISECOND_OFFSET);
-      return Duration.ofDays(days).plusMillis(milliseconds);
+      return getObjectNotNull(index);
     }
   }
 
+  /**
+   * Same as {@link #getObject(int)} but does not check for null.
+   *
+   * @param index   position of element
+   * @return element at given index
+   */
+  public Duration getObjectNotNull(int index) {
+    final long startIndex = (long) index * TYPE_WIDTH;
+    final int days = valueBuffer.getInt(startIndex);
+    final int milliseconds = valueBuffer.getInt(startIndex + MILLISECOND_OFFSET);
+    return Duration.ofDays(days).plusMillis(milliseconds);
+  }
+
   /**
    * Get the Interval value at a given index as a {@link StringBuilder} object.
    *
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/testing/ValueVectorDataPopulator.java b/java/vector/src/test/java/org/apache/arrow/vector/testing/ValueVectorDataPopulator.java
index 15d6a5cf993c4..f9f0357861c15 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/testing/ValueVectorDataPopulator.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/testing/ValueVectorDataPopulator.java
@@ -19,6 +19,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import java.math.BigDecimal;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Map;
@@ -29,6 +30,7 @@
 import org.apache.arrow.vector.BitVectorHelper;
 import org.apache.arrow.vector.DateDayVector;
 import org.apache.arrow.vector.DateMilliVector;
+import org.apache.arrow.vector.Decimal256Vector;
 import org.apache.arrow.vector.DecimalVector;
 import org.apache.arrow.vector.DurationVector;
 import org.apache.arrow.vector.FixedSizeBinaryVector;
@@ -147,6 +149,34 @@ public static void setVector(DecimalVector vector, Long... values) {
     vector.setValueCount(length);
   }
 
+  /**
+   * Populate values for Decimal256Vector.
+   */
+  public static void setVector(Decimal256Vector vector, Long... values) {
+    final int length = values.length;
+    vector.allocateNew(length);
+    for (int i = 0; i < length; i++) {
+      if (values[i] != null) {
+        vector.set(i, values[i]);
+      }
+    }
+    vector.setValueCount(length);
+  }
+
+  /**
+   * Populate values for Decimal256Vector.
+   */
+  public static void setVector(Decimal256Vector vector, BigDecimal... values) {
+    final int length = values.length;
+    vector.allocateNew(length);
+    for (int i = 0; i < length; i++) {
+      if (values[i] != null) {
+        vector.set(i, values[i]);
+      }
+    }
+    vector.setValueCount(length);
+  }
+
   /**
    * Populate values for DurationVector.
    * @param values values of elapsed time in either seconds, milliseconds, microseconds or nanoseconds.

From a7f5ee01b5949687bbc3b3918454860c6db6934c Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 18 Sep 2023 11:26:34 -0400
Subject: [PATCH 374/749] GH-37724: [MATLAB] Add `arrow.type.StructType` MATLAB
 class (#37749)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

In order to add a `arrow.array.StructArray` MATLAB class (https://github.com/apache/arrow/issues/37653), we first need to implement the `arrow.type.StructType` MATLAB class.

### What changes are included in this PR?

1. Added a new MATLAB class `arrow.type.StructType`
2. Added convenience constructor function `arrow.struct()`
3. Added `Struct` as a enumeration value to `arrow.type.ID`
4. Added `arrow.type.traits.StructTraits` MATLAB class. Some of its properties, such as `ArrayConstructor` and `ArrayProxyClassName`, are set to `missing` because they require `arrow.array.StructArray` (#37653). When that class is added, we can initialize these properties to correct values.

**Example Usage**
```matlab
>> fieldA = arrow.field("A", arrow.int32());
>> fieldB = arrow.field("B", arrow.timestamp(TimeZone="America/New_York"));
>> fieldC = arrow.field("C", arrow.string());
>> structType = arrow.struct(fieldA, fieldB, fieldC)

structType =

  StructType with properties:

        ID: Struct
    Fields: [1×3 arrow.type.Field]

>> fieldBFromStruct = structType.field(2)

fieldBFromStruct =

B: timestamp[us, tz=America/New_York]
```

### Are these changes tested?

Yes.

1. Added a new test class called `tStructType.m`
2. Added a new test case to `tTypeDisplay.m`
3. Updated test case in `tID.m`

### Are there any user-facing changes?

Yes. Users can now create an `arrow.type.StructType` object using the new `arrow.struct()` funciton.

### Future Directions

1. #37653
* Closes: #37724

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../arrow/matlab/type/proxy/struct_type.cc    |  45 +++++
 .../cpp/arrow/matlab/type/proxy/struct_type.h |  34 ++++
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   3 +
 .../+arrow/+type/+traits/StructTraits.m       |  36 ++++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   2 +
 matlab/src/matlab/+arrow/+type/ID.m           |   6 +
 matlab/src/matlab/+arrow/+type/StructType.m   |  46 +++++
 matlab/src/matlab/+arrow/+type/Type.m         |   2 +-
 matlab/src/matlab/+arrow/struct.m             |  43 ++++
 matlab/test/arrow/type/tField.m               |   1 +
 matlab/test/arrow/type/tID.m                  |   3 +-
 matlab/test/arrow/type/tStructType.m          | 190 ++++++++++++++++++
 matlab/test/arrow/type/tTypeDisplay.m         |  28 ++-
 matlab/test/arrow/type/traits/tStructTraits.m |  31 +++
 matlab/test/arrow/type/traits/ttraits.m       |  12 ++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 17 files changed, 482 insertions(+), 3 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/struct_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
 create mode 100644 matlab/src/matlab/+arrow/+type/StructType.m
 create mode 100644 matlab/src/matlab/+arrow/struct.m
 create mode 100644 matlab/test/arrow/type/tStructType.m
 create mode 100644 matlab/test/arrow/type/traits/tStructTraits.m

diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 4035725f2b382..ebeb020a9e7c7 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -33,6 +33,7 @@
 #include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
+#include "arrow/matlab/type/proxy/struct_type.h"
 #include "arrow/matlab/type/proxy/field.h"
 #include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/io/feather/proxy/reader.h"
@@ -81,6 +82,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.Time64Type     , arrow::matlab::type::proxy::Time64Type);
     REGISTER_PROXY(arrow.type.proxy.Date32Type     , arrow::matlab::type::proxy::Date32Type);
     REGISTER_PROXY(arrow.type.proxy.Date64Type     , arrow::matlab::type::proxy::Date64Type);
+    REGISTER_PROXY(arrow.type.proxy.StructType     , arrow::matlab::type::proxy::StructType);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
 
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.cc
new file mode 100644
index 0000000000000..fbb8dc3f6edbe
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.cc
@@ -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.
+
+#include "arrow/matlab/type/proxy/struct_type.h"
+#include "arrow/matlab/type/proxy/field.h"
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::type::proxy {
+
+    StructType::StructType(std::shared_ptr<arrow::StructType> struct_type) : Type(std::move(struct_type)) {}
+
+    libmexclass::proxy::MakeResult StructType::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using StructTypeProxy = arrow::matlab::type::proxy::StructType;
+
+        mda::StructArray args = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> field_proxy_ids_mda = args[0]["FieldProxyIDs"];
+
+        std::vector<std::shared_ptr<arrow::Field>> fields;
+        fields.reserve(field_proxy_ids_mda.getNumberOfElements());
+        for (const auto proxy_id : field_proxy_ids_mda) {
+            using namespace libmexclass::proxy;
+            auto proxy = std::static_pointer_cast<proxy::Field>(ProxyManager::getProxy(proxy_id));
+            auto field = proxy->unwrap();
+            fields.push_back(field);
+        }
+
+        auto struct_type = std::static_pointer_cast<arrow::StructType>(arrow::struct_(fields));
+        return std::make_shared<StructTypeProxy>(std::move(struct_type));
+    }
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
new file mode 100644
index 0000000000000..8ec6217b34278
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
@@ -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.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    class StructType : public arrow::matlab::type::proxy::Type {
+
+    public:
+        StructType(std::shared_ptr<arrow::StructType> struct_type);
+
+        ~StructType() {}
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+};
+
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index 91a1e353496c7..3dd86e91409fa 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -24,6 +24,7 @@
 #include "arrow/matlab/type/proxy/date32_type.h"
 #include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
+#include "arrow/matlab/type/proxy/struct_type.h"
 
 namespace arrow::matlab::type::proxy {
 
@@ -64,6 +65,8 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<Date64Type>(std::static_pointer_cast<arrow::Date64Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
+           case ID::STRUCT:
+                return std::make_shared<StructType>(std::static_pointer_cast<arrow::StructType>(type));
             default:
                 return arrow::Status::NotImplemented("Unsupported DataType: " + type->ToString());
         }
diff --git a/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
new file mode 100644
index 0000000000000..a8ed98f8ae468
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
@@ -0,0 +1,36 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef StructTraits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        % TODO: When arrow.array.StructArray is implemented, set these
+        % properties appropriately
+        ArrayConstructor = missing
+        ArrayClassName = missing
+        ArrayProxyClassName = missing
+        ArrayStaticConstructor = missing
+
+        TypeConstructor = @arrow.type.StructType
+        TypeClassName = "arrow.type.StructType"
+        TypeProxyClassName = "arrow.type.proxy.StructType"
+
+        % TODO: When arrow.array.StructArray is implemented, set these
+        % properties appropriately
+        MatlabConstructor = missing
+        MatlabClassName = missing
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index 78804fdccb3f0..f737108ce5f76 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -56,6 +56,8 @@
                 typeTraits = Date32Traits();
             case ID.Date64
                 typeTraits = Date64Traits();
+            case ID.Struct
+                typeTraits = StructTraits();
             otherwise
                 error("arrow:type:traits:UnsupportedArrowTypeID", "Unsupported Arrow type ID: " + type);
         end
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index 646edb85c6632..b2c4facbe4065 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -37,5 +37,11 @@
         Timestamp (18)
         Time32    (19)
         Time64    (20)
+        % IntervalMonths  (21)
+        % IntervalDayTime (22)
+        % Decimal128      (23)
+        % Decimal256      (24)
+        % List            (25)
+        Struct            (26)
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/StructType.m b/matlab/src/matlab/+arrow/+type/StructType.m
new file mode 100644
index 0000000000000..6c1318f6376f3
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/StructType.m
@@ -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.
+
+classdef StructType < arrow.type.Type
+
+    methods
+        function obj = StructType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.StructType")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.type.Type(proxy);
+        end
+    end
+
+    methods(Access = protected)
+        function groups = getDisplayPropertyGroups(obj)
+            targets = ["ID", "Fields"];
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+
+    methods (Hidden)
+        % TODO: Consider using a mixin approach to add this behavior. For
+        % example, ChunkedArray's toMATLAB method could check if its 
+        % Type inherits from a mixin called "Preallocateable" (or something
+        % more descriptive). If so, we can call preallocateMATLABArray
+        % in the toMATLAB method.
+        function preallocateMATLABArray(~)
+            error("arrow:type:UnsupportedFunction", ...
+                "preallocateMATLABArray is not supported for StructType");
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/Type.m b/matlab/src/matlab/+arrow/+type/Type.m
index 0fd0139b18b7a..6dc4fbc438f34 100644
--- a/matlab/src/matlab/+arrow/+type/Type.m
+++ b/matlab/src/matlab/+arrow/+type/Type.m
@@ -62,7 +62,7 @@
                 for ii = 1:numFields
                     fields{ii} = obj.field(ii);
                 end
-                fields = horzcat(fields);
+                fields = horzcat(fields{:});
             end
         end
     end
diff --git a/matlab/src/matlab/+arrow/struct.m b/matlab/src/matlab/+arrow/struct.m
new file mode 100644
index 0000000000000..2fdbd6a9864fd
--- /dev/null
+++ b/matlab/src/matlab/+arrow/struct.m
@@ -0,0 +1,43 @@
+%STRUCT Constructs an arrow.type.StructType object
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function type = struct(fields)
+    arguments(Repeating)
+        fields(1, :) arrow.type.Field {mustBeNonempty}
+    end
+
+    % Must have at least one Field in a Struct
+    if isempty(fields)
+        error("arrow:struct:TooFewInputs", ...
+            "Must supply at least one arrow.type.Field");
+    end
+
+    fields = horzcat(fields{:});
+
+    % Extract the corresponding Proxy IDs from each of the
+    % supplied arrow.type.Field objects.
+    numFields = numel(fields);
+    fieldProxyIDs = zeros(1, numFields, "uint64");
+    for ii = 1:numFields
+        fieldProxyIDs(ii) = fields(ii).Proxy.ID;
+    end
+
+    % Construct an Arrow Field Proxy in C++ from the supplied Field Proxy IDs.
+    args = struct(FieldProxyIDs=fieldProxyIDs);
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.StructType", args);
+    type = arrow.type.StructType(proxy);
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
index dba7190b49ce2..1a89c0077b5ae 100644
--- a/matlab/test/arrow/type/tField.m
+++ b/matlab/test/arrow/type/tField.m
@@ -42,6 +42,7 @@ function TestSupportedTypes(testCase)
                                  arrow.float64, ...
                                  arrow.string, ...
                                  arrow.timestamp, ...
+                                 arrow.struct(arrow.field("A", arrow.float32()))
                              };
             for ii = 1:numel(supportedTypes)
                 supportedType = supportedTypes{ii};
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index b69cd89842d73..e97d77e81c124 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -46,7 +46,8 @@ function CastToUInt64(testCase)
                 ID.Date64,    17, ...
                 ID.Timestamp, 18, ...
                 ID.Time32,    19, ...
-                ID.Time64,    20  ...
+                ID.Time64,    20, ...
+                ID.Struct,    26 ...
             );
 
             enumValues = typeIDs.keys();
diff --git a/matlab/test/arrow/type/tStructType.m b/matlab/test/arrow/type/tStructType.m
new file mode 100644
index 0000000000000..f0585823f8dcf
--- /dev/null
+++ b/matlab/test/arrow/type/tStructType.m
@@ -0,0 +1,190 @@
+% TSTRUCTTYPE Unit tests for arrow.type.StructType
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tStructType < matlab.unittest.TestCase
+
+    properties (Constant)
+        Field1 = arrow.field("A", arrow.float64())
+        Field2 = arrow.field("C", arrow.boolean())
+        Field3 = arrow.field("B", arrow.timestamp(TimeUnit="Microsecond", TimeZone="America/New_York"));
+    end
+
+    methods (Test)
+        function Basic(tc)
+            % Verify arrow.struct() returns an arrow.type.StructType
+            % object.
+            type = arrow.struct(tc.Field1);
+            className = string(class(type));
+            tc.verifyEqual(className, "arrow.type.StructType");
+            tc.verifyEqual(type.ID, arrow.type.ID.Struct);
+        end
+
+        function TooFewInputsError(tc)
+            % Verify arrow.struct() errors if given zero input arguments.
+            fcn = @() arrow.struct();
+            tc.verifyError(fcn, "arrow:struct:TooFewInputs");
+        end
+
+        function InvalidInputTypeError(tc)
+            % Verify arrow.struct() errors if any one of the input
+            % arguments is not an arrow.type.Field object.
+            fcn = @() arrow.struct(1);
+            tc.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function EmptyFieldError(tc)
+            % Verify arrow.struct() errors if given an empty 
+            % arrow.type.Field array as one of its inputs.
+            fcn = @() arrow.struct(tc.Field1, arrow.type.Field.empty(0, 0));
+            tc.verifyError(fcn, "MATLAB:validators:mustBeNonempty");
+        end
+
+        function NumFieldsGetter(tc)
+            % Verify the NumFields getter returns the expected value.
+            type = arrow.struct(tc.Field1);
+            tc.verifyEqual(type.NumFields, int32(1));
+
+            type = arrow.struct(tc.Field1, tc.Field2);
+            tc.verifyEqual(type.NumFields, int32(2));
+
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            tc.verifyEqual(type.NumFields, int32(3));
+        end
+
+        function NumFieldsNoSetter(tc)
+            % Verify the NumFields property is not settable.
+            type = arrow.struct(tc.Field1);
+            fcn = @() setfield(type, "NumFields", 20);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function FieldsGetter(tc)
+            % Verify the Fields getter returns the expected
+            % arrow.type.Field array.
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            actual = type.Fields;
+            expected = [tc.Field1, tc.Field2, tc.Field3];
+            tc.verifyEqual(actual, expected);
+        end
+
+        function FieldsNoSetter(tc)
+            % Verify the Fields property is not settable.
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            fcn = @() setfield(type, "Fields", tc.Field3);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function IDGetter(tc)
+            % Verify the ID getter returns the expected enum value.
+            type = arrow.struct(tc.Field1);
+            actual = type.ID;
+            expected = arrow.type.ID.Struct;
+            tc.verifyEqual(actual, expected);
+        end
+
+        function IDNoSetter(tc)
+            % Verify the ID property is not settable.
+            type = arrow.struct(tc.Field1);
+            fcn = @() setfield(type, "ID", arrow.type.ID.Boolean);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function FieldMethod(tc)
+            % Verify the field method returns the expected arrow.type.Field
+            % with respect to the index provided.
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            
+            % Extract the 1st field
+            actual1 = type.field(1);
+            expected1 = tc.Field1;
+            tc.verifyEqual(actual1, expected1);
+
+            % Extract the 2nd field
+            actual2 = type.field(2);
+            expected2 = tc.Field2;
+            tc.verifyEqual(actual2, expected2);
+
+            % Extract the 3rd field
+            actual3 = type.field(3);
+            expected3 = tc.Field3;
+            tc.verifyEqual(actual3, expected3);
+        end
+
+        function FieldIndexOutOfRangeError(tc)
+            % Verify field() throws an error if provided an index that
+            % exceeds NumFields.
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            fcn = @() type.field(100);
+            tc.verifyError(fcn, "arrow:index:OutOfRange");
+        end
+
+        function FieldIndexNonScalarError(tc)
+            % Verify field() throws an error if provided a nonscalar array
+            % of indices.
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            fcn = @() type.field([1 2]);
+            tc.verifyError(fcn, "arrow:badsubscript:NonScalar");
+        end
+
+        function FieldIndexNonNumberError(tc)
+            % Verify field() throws an error if not provided a number as 
+            % the index.
+  
+            type = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            fcn = @() type.field("A");
+            tc.verifyError(fcn, "arrow:badsubscript:NonNumeric");
+        end
+
+        function IsEqualTrue(tc)
+            % Verify two StructTypes are considered equal if their Fields
+            % properties are equal.
+
+            type1 = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            type2 = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+
+            tc.verifyTrue(isequal(type1, type2));
+            tc.verifyTrue(isequal(type1, type2, type2, type1));
+
+            % Non-scalar arrow.type.StructType arrays
+            type3 = [type1 type2];
+            type4 = [type1 type2];
+            tc.verifyTrue(isequal(type3, type4));
+        end
+
+        function IsEqualFalse(tc)
+            % Verify isequal returns false when expected.
+            type1 = arrow.struct(tc.Field1, tc.Field2, tc.Field3);
+            type2 = arrow.struct(tc.Field1, tc.Field2);
+            type3 = arrow.struct(tc.Field1, tc.Field3, tc.Field2);
+
+            % Fields properties have different lengths
+            tc.verifyFalse(isequal(type1, type2));
+
+            % The corresponding elements in the Fields arrays are not equal
+            tc.verifyFalse(isequal(type1, type3));
+
+            % Non-scalar arrow.type.StructType arrays
+            type4 = [type1 type2];
+            type5 = [type1; type2];
+            type6 = [type1 type2];
+            type7 = [type1 type3];
+            tc.verifyFalse(isequal(type4, type5));
+            tc.verifyFalse(isequal(type6, type7));
+
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/tTypeDisplay.m b/matlab/test/arrow/type/tTypeDisplay.m
index 4d3c023da71ab..f84c5ab56e270 100644
--- a/matlab/test/arrow/type/tTypeDisplay.m
+++ b/matlab/test/arrow/type/tTypeDisplay.m
@@ -189,7 +189,7 @@ function TestDateType(testCase, DateType)
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
 
-        function Display(testCase)
+        function TimestampTypeDisplay(testCase)
             % Verify the display of TimestampType objects.
             %
             % Example:
@@ -211,6 +211,32 @@ function Display(testCase)
             actualDisplay = evalc('disp(type)');
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
+
+        function StructTypeDisplay(testCase)
+            % Verify the display of StructType objects.
+            %
+            % Example:
+            %
+            %  StructType with properties:
+            %
+            %          ID: Struct
+            %      Fields: [1x2 arrow.type.Field]
+
+            fieldA = arrow.field("A", arrow.int32());
+            fieldB = arrow.field("B", arrow.timestamp(TimeZone="America/Anchorage"));
+            type = arrow.struct(fieldA, fieldB); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.type.StructType", ClassName="StructType", BoldFont=true);
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "Fields:"]));
+            dimensionString = makeDimensionString([1 2]);
+            fieldString = compose("[%s %s]", dimensionString, "arrow.type.Field");
+            body = body + " " + ["Struct"; fieldString];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+        end
     end
 
     methods
diff --git a/matlab/test/arrow/type/traits/tStructTraits.m b/matlab/test/arrow/type/traits/tStructTraits.m
new file mode 100644
index 0000000000000..6a97b1e1852d6
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tStructTraits.m
@@ -0,0 +1,31 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tStructTraits < hTypeTraits
+
+    properties
+        TraitsConstructor = @arrow.type.traits.StructTraits 
+        ArrayConstructor = missing
+        ArrayClassName = missing
+        ArrayProxyClassName = missing
+        ArrayStaticConstructor = missing
+        TypeConstructor = @arrow.type.StructType
+        TypeClassName = "arrow.type.StructType"
+        TypeProxyClassName = "arrow.type.proxy.StructType"
+        MatlabConstructor = missing
+        MatlabClassName = missing
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index cdc5990ed03ba..2880645f2957c 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -199,6 +199,18 @@ function TestDate64(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestStruct(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.Struct;
+            expectedTraits = StructTraits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index b5c480d6a68e7..40c6b5a51d4fe 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -65,6 +65,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time64_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/struct_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"

From 6a3c6a78e25b808174c71a9460f036b9f80390c0 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 18 Sep 2023 11:51:50 -0700
Subject: [PATCH 375/749] GH-37704: [Java] Add schema IPC serialization methods
 (#37778)

### Rationale for this change

The methods in the Schema class in Java serialize the schema in a way that is inconsistent with other languages. This can cause integration issues when using a Java-serialized schema in another language via IPC or Arrow Flight or vice-versa.

### What changes are included in this PR?

Added the serializeAsMessage() and deserializeMessage() methods to Schema for serialization Schemas to the standard IPC format (wrapped in an IPC Message).

Marked the methods that serialize to raw FlatBuffer objects as deprecated (toByteArray() and deserialize()).

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37704

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../flight/perf/PerformanceTestServer.java    |  3 +-
 .../apache/arrow/flight/perf/TestPerf.java    |  3 +-
 .../arrow/vector/types/pojo/Schema.java       | 44 +++++++++++++++++++
 .../arrow/vector/types/pojo/TestSchema.java   | 39 ++++++++++++++++
 4 files changed, 86 insertions(+), 3 deletions(-)

diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/PerformanceTestServer.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/PerformanceTestServer.java
index 319aee445dca6..0ded2f7065f9c 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/PerformanceTestServer.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/PerformanceTestServer.java
@@ -18,7 +18,6 @@
 package org.apache.arrow.flight.perf;
 
 import java.io.IOException;
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
@@ -115,7 +114,7 @@ public void getStream(CallContext context, Ticket ticket,
         try {
           Token token = Token.parseFrom(ticket.getBytes());
           Perf perf = token.getDefinition();
-          Schema schema = Schema.deserialize(ByteBuffer.wrap(perf.getSchema().toByteArray()));
+          Schema schema = Schema.deserializeMessage(perf.getSchema().asReadOnlyByteBuffer());
           root = VectorSchemaRoot.create(schema, allocator);
           BigIntVector a = (BigIntVector) root.getVector("a");
           BigIntVector b = (BigIntVector) root.getVector("b");
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/TestPerf.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/TestPerf.java
index a7af8b713097d..17c83c205feb0 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/TestPerf.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/perf/TestPerf.java
@@ -65,7 +65,8 @@ public static FlightDescriptor getPerfFlightDescriptor(long recordCount, int rec
         Field.nullable("d", MinorType.BIGINT.getType())
     ));
 
-    ByteString serializedSchema = ByteString.copyFrom(pojoSchema.toByteArray());
+    byte[] bytes = pojoSchema.serializeAsMessage();
+    ByteString serializedSchema = ByteString.copyFrom(bytes);
 
     return FlightDescriptor.command(Perf.newBuilder()
         .setRecordsPerStream(recordCount)
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/types/pojo/Schema.java b/java/vector/src/main/java/org/apache/arrow/vector/types/pojo/Schema.java
index 2b3db1fb7de43..dcffea0ef5367 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/types/pojo/Schema.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/types/pojo/Schema.java
@@ -20,9 +20,11 @@
 
 import static org.apache.arrow.vector.types.pojo.Field.convertField;
 
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.channels.Channels;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -36,7 +38,10 @@
 import org.apache.arrow.flatbuf.KeyValue;
 import org.apache.arrow.util.Collections2;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.ipc.ReadChannel;
+import org.apache.arrow.vector.ipc.WriteChannel;
 import org.apache.arrow.vector.ipc.message.FBSerializables;
+import org.apache.arrow.vector.ipc.message.MessageSerializer;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnore;
@@ -47,6 +52,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectReader;
 import com.fasterxml.jackson.databind.ObjectWriter;
+import com.fasterxml.jackson.databind.util.ByteBufferBackedInputStream;
 import com.google.flatbuffers.FlatBufferBuilder;
 
 /**
@@ -83,10 +89,30 @@ public static Schema fromJSON(String json) throws IOException {
     return reader.readValue(Preconditions.checkNotNull(json));
   }
 
+  /**
+   * Deserialize a schema that has been serialized using {@link #toByteArray()}.
+   * @param buffer the bytes to deserialize.
+   * @return The deserialized schema.
+   */
+  @Deprecated
   public static Schema deserialize(ByteBuffer buffer) {
     return convertSchema(org.apache.arrow.flatbuf.Schema.getRootAsSchema(buffer));
   }
 
+  /**
+   * Deserialize a schema that has been serialized as a message using {@link #serializeAsMessage()}.
+   * @param buffer the bytes to deserialize.
+   * @return The deserialized schema.
+   */
+  public static Schema deserializeMessage(ByteBuffer buffer) {
+    ByteBufferBackedInputStream stream = new ByteBufferBackedInputStream(buffer);
+    try (ReadChannel channel = new ReadChannel(Channels.newChannel(stream))) {
+      return MessageSerializer.deserializeSchema(channel);
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
   /** Converts a flatbuffer schema to its POJO representation. */
   public static Schema convertSchema(org.apache.arrow.flatbuf.Schema schema) {
     List<Field> fields = new ArrayList<>();
@@ -217,9 +243,27 @@ public int getSchema(FlatBufferBuilder builder) {
     return org.apache.arrow.flatbuf.Schema.endSchema(builder);
   }
 
+  /**
+   * Returns the serialized flatbuffer bytes of the schema wrapped in a message table.
+   * Use {@link #deserializeMessage() to rebuild the Schema.}
+   */
+  public byte[] serializeAsMessage() {
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    try (WriteChannel channel = new WriteChannel(Channels.newChannel(out))) {
+      long size = MessageSerializer.serialize(
+          new WriteChannel(Channels.newChannel(out)), this);
+      return out.toByteArray();
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
   /**
    * Returns the serialized flatbuffer representation of this schema.
+   * @deprecated This method does not encapsulate the schema in a Message payload which is incompatible with other
+   *     languages. Use {@link #serializeAsMessage()} instead.
    */
+  @Deprecated
   public byte[] toByteArray() {
     FlatBufferBuilder builder = new FlatBufferBuilder();
     int schemaOffset = this.getSchema(builder);
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/types/pojo/TestSchema.java b/java/vector/src/test/java/org/apache/arrow/vector/types/pojo/TestSchema.java
index 0e5375865a8bd..7b62247c6e12d 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/types/pojo/TestSchema.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/types/pojo/TestSchema.java
@@ -24,6 +24,7 @@
 import static org.junit.Assert.assertTrue;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -216,6 +217,35 @@ public void testMetadata() throws IOException {
     contains(schema, "\"" + METADATA_KEY + "\" : \"testKey\"", "\"" + METADATA_VALUE + "\" : \"testValue\"");
   }
 
+  @Test
+  public void testMessageSerialization() {
+    Schema schema = new Schema(asList(
+        field("a", false, new Null()),
+        field("b", new Struct(), field("ba", new Null())),
+        field("c", new List(), field("ca", new Null())),
+        field("d", new Union(UnionMode.Sparse, new int[] {1, 2, 3}), field("da", new Null())),
+        field("e", new Int(8, true)),
+        field("f", new FloatingPoint(FloatingPointPrecision.SINGLE)),
+        field("g", new Utf8()),
+        field("h", new Binary()),
+        field("i", new Bool()),
+        field("j", new Decimal(5, 5, 128)),
+        field("k", new Date(DateUnit.DAY)),
+        field("l", new Date(DateUnit.MILLISECOND)),
+        field("m", new Time(TimeUnit.SECOND, 32)),
+        field("n", new Time(TimeUnit.MILLISECOND, 32)),
+        field("o", new Time(TimeUnit.MICROSECOND, 64)),
+        field("p", new Time(TimeUnit.NANOSECOND, 64)),
+        field("q", new Timestamp(TimeUnit.MILLISECOND, "UTC")),
+        field("r", new Timestamp(TimeUnit.MICROSECOND, null)),
+        field("s", new Interval(IntervalUnit.DAY_TIME)),
+        field("t", new FixedSizeBinary(100)),
+        field("u", new Duration(TimeUnit.SECOND)),
+        field("v", new Duration(TimeUnit.MICROSECOND))
+    ));
+    roundTripMessage(schema);
+  }
+
   private void roundTrip(Schema schema) throws IOException {
     String json = schema.toJson();
     Schema actual = Schema.fromJSON(json);
@@ -225,6 +255,15 @@ private void roundTrip(Schema schema) throws IOException {
     assertEquals(schema.hashCode(), actual.hashCode());
   }
 
+  private void roundTripMessage(Schema schema) {
+    byte[] bytes = schema.serializeAsMessage();
+    Schema actual = Schema.deserializeMessage(ByteBuffer.wrap(bytes));
+    assertEquals(schema.toJson(), actual.toJson());
+    assertEquals(schema, actual);
+    validateFieldsHashcode(schema.getFields(), actual.getFields());
+    assertEquals(schema.hashCode(), actual.hashCode());
+  }
+
   private void validateFieldsHashcode(java.util.List<Field> schemaFields, java.util.List<Field> actualFields) {
     assertEquals(schemaFields.size(), actualFields.size());
     if (schemaFields.size() == 0) {

From efbabd3e9583a07cc44e13de84772e9de4f6953c Mon Sep 17 00:00:00 2001
From: Austin Dickey <austin3spammy@gmail.com>
Date: Mon, 18 Sep 2023 15:39:11 -0500
Subject: [PATCH 376/749] GH-37771: [Go][Benchmarking] Update Conbench git info
 (#37772)

This PR fixes the Go benchmarking script to comply with the new Conbench server and client versions. Fixes https://github.com/apache/arrow/issues/37771.
* Closes: #37771

Authored-by: Austin Dickey <austin3spammy@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 ci/scripts/go_bench_adapt.py | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/ci/scripts/go_bench_adapt.py b/ci/scripts/go_bench_adapt.py
index e4eea5c17af37..a05e25de8bdd3 100644
--- a/ci/scripts/go_bench_adapt.py
+++ b/ci/scripts/go_bench_adapt.py
@@ -20,7 +20,7 @@
 import uuid
 import logging
 from pathlib import Path
-from typing import List, Optional, Dict
+from typing import List
 
 from benchadapt import BenchmarkResult
 from benchadapt.adapters import BenchmarkAdapter
@@ -33,9 +33,9 @@
 
 # `github_commit_info` is meant to communicate GitHub-flavored commit
 # information to Conbench. See
-# https://github.com/conbench/conbench/blob/7c4968e631ecdc064559c86a1174a1353713b700/benchadapt/python/benchadapt/result.py#L66
+# https://github.com/conbench/conbench/blob/cf7931f/benchadapt/python/benchadapt/result.py#L66
 # for a specification.
-github_commit_info: Optional[Dict] = None
+github_commit_info = {"repository": "https://github.com/apache/arrow"}
 
 if os.environ.get("CONBENCH_REF") == "main":
     # Assume GitHub Actions CI. The environment variable lookups below are
@@ -53,7 +53,7 @@
 
     # This is probably a local dev environment, for testing. In this case, it
     # does usually not make sense to provide commit information (not a
-    # controlled CI environment). Explicitly keep `github_commit_info=None` to
+    # controlled CI environment). Explicitly leave out "commit" and "pr_number" to
     # reflect that (to not send commit information).
 
     # Reflect 'local dev' scenario in run_reason. Allow user to (optionally)
@@ -114,10 +114,9 @@ def _transform_results(self) -> List[BenchmarkResult]:
                     run_reason=run_reason,
                     github=github_commit_info,
                 )
-                if github_commit_info is not None:
-                    parsed.run_name = (
-                        f"{parsed.run_reason}: {github_commit_info['commit']}"
-                    )
+                parsed.run_name = (
+                    f"{parsed.run_reason}: {github_commit_info.get('commit')}"
+                )
                 parsed_results.append(parsed)
 
         return parsed_results

From 440dc92caa73ca67c8ca98cebfb74f33788150bf Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Mon, 18 Sep 2023 22:50:33 +0200
Subject: [PATCH 377/749] GH-37576: [R] Use `SafeCallIntoR()` to call garbage
 collector after a failed allocation (#37565)

### Rationale for this change

The `gc_memory_pool()` is the one we use almost everywhere in the R package. It uses a special allocation mechanism that calls into R to run the garbage collector after a failed allocation (in case there are any large objects that can be removed). In the case where an allocation happens on another thread (most of the time when running exec plans), the call into R may cause a crash: even though the memory pool was ensuring serialized access using a mutex, this is not sufficient for R (for reasons I don't understand).

### What changes are included in this PR?

Use `SafeCallIntoR()` to run the garbage collector instead. This ensures that the calling thread is used for any call into R (or errors if this is not possible).

### Are these changes tested?

Yes: there is an existing test that ensures this code path occurs at least once.

### Are there any user-facing changes?

No.
* Closes: #37576

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/src/memorypool.cpp          | 14 +++++++-------
 r/tests/testthat/test-arrow.R |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/r/src/memorypool.cpp b/r/src/memorypool.cpp
index 027aa8ef2aa8d..696e913eadc70 100644
--- a/r/src/memorypool.cpp
+++ b/r/src/memorypool.cpp
@@ -16,8 +16,8 @@
 // under the License.
 
 #include <arrow/memory_pool.h>
-#include <arrow/util/mutex.h>
 #include "./arrow_types.h"
+#include "./safe-call-into-r.h"
 
 class GcMemoryPool : public arrow::MemoryPool {
  public:
@@ -59,17 +59,17 @@ class GcMemoryPool : public arrow::MemoryPool {
     if (call().ok()) {
       return arrow::Status::OK();
     } else {
-      auto lock = mutex_.Lock();
-
       // ARROW-10080: Allocation may fail spuriously since the garbage collector is lazy.
       // Force it to run then try again in case any reusable allocations have been freed.
-      static cpp11::function gc = cpp11::package("base")["gc"];
-      gc();
+      arrow::Status r_call = SafeCallIntoRVoid([] {
+        cpp11::function gc = cpp11::package("base")["gc"];
+        gc();
+      });
+      ARROW_RETURN_NOT_OK(r_call);
+      return call();
     }
-    return call();
   }
 
-  arrow::util::Mutex mutex_;
   arrow::MemoryPool* pool_;
 };
 
diff --git a/r/tests/testthat/test-arrow.R b/r/tests/testthat/test-arrow.R
index 071a5ad3d982c..c6ae27ac52296 100644
--- a/r/tests/testthat/test-arrow.R
+++ b/r/tests/testthat/test-arrow.R
@@ -64,6 +64,6 @@ test_that("MemoryPool calls gc() to free memory when allocation fails (ARROW-100
   on.exit(suppressMessages(untrace(gc)))
   # We expect this should fail because we don't have this much memory,
   # but it should gc() and retry (and fail again)
-  expect_error(BufferOutputStream$create(2**60))
+  expect_error(BufferOutputStream$create(2**60), "Out of memory")
   expect_true(env$gc_was_called)
 })

From 42192d82cdd2a63bd3baf48ffbbda181d2c9cb97 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 19 Sep 2023 08:53:01 +0900
Subject: [PATCH 378/749] MINOR: [C#] Bump xunit from 2.5.0 to 2.5.1 in /csharp
 (#37775)

Bumps [xunit](https://github.com/xunit/xunit) from 2.5.0 to 2.5.1.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/9dc851b5e642ec7929da1ac06d59988d0a2d840b"><code>9dc851b</code></a> v2.5.1</li>
<li><a href="https://github.com/xunit/xunit/commit/86b0eef9ef286661a7f804ec16575396325ca458"><code>86b0eef</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2770">#2770</a>: Make SerializationHelper public</li>
<li><a href="https://github.com/xunit/xunit/commit/f49dafc318e93a105d78704b8a6734c966ae1418"><code>f49dafc</code></a> File re-sort for SerializationHelper &amp; XunitSerializationInfo</li>
<li><a href="https://github.com/xunit/xunit/commit/d0004ae78d9b0fafa0a6fc046af50bb912d1581e"><code>d0004ae</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2773">#2773</a>: Add Assert.RaisesAny and Assert.RaisesAnyAsync non-generic for EventAr...</li>
<li><a href="https://github.com/xunit/xunit/commit/c1dba28cf0929d6602168ab4a081ca6a536323f0"><code>c1dba28</code></a> Latest assertions</li>
<li><a href="https://github.com/xunit/xunit/commit/b7c828ebf130cf3d768ef6b3effcb38fe15690d3"><code>b7c828e</code></a> Move .editorconfig up into contentFiles</li>
<li><a href="https://github.com/xunit/xunit/commit/08e74e76b884f29f2e9d9f93e8fcf8bda39982de"><code>08e74e7</code></a> Add .editorconfig to assert source NuGet package to indicate generated code (...</li>
<li><a href="https://github.com/xunit/xunit/commit/79f411aabe2e74ab00fe2ecbd9f237bc85af792b"><code>79f411a</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2767">#2767</a>: Verify types match when comparing FileSystemInfo values (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/9c28f584e0cf5a714b03433eaa7e19c3d3c40ddb"><code>9c28f58</code></a> Latest dependencies</li>
<li><a href="https://github.com/xunit/xunit/commit/63dce4f197f79306c47eef96323be56c081b08f8"><code>63dce4f</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2767">#2767</a>: Special case FileSystemInfo objects by just comparing the FullName in ...</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/xunit/compare/2.5.0...2.5.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.5.0&new-version=2.5.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index e06e0f9ef2845..730099246edc9 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.0" />
+    <PackageReference Include="xunit" Version="2.5.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index dff3f1e541c08..d829d02cfada6 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -7,7 +7,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-      <PackageReference Include="xunit" Version="2.5.0" />
+      <PackageReference Include="xunit" Version="2.5.1" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 7f5a726ee5f03..4d00208fbaf2e 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.0" />
+    <PackageReference Include="xunit" Version="2.5.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index d6dc25d6b5e20..ccd630d279279 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -11,7 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.0" />
+    <PackageReference Include="xunit" Version="2.5.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

From 96907837707f79483baf4f3eda00b09c7fcb246b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 19 Sep 2023 08:54:25 +0900
Subject: [PATCH 379/749] MINOR: [C#] Bump Google.Protobuf from 3.24.2 to
 3.24.3 in /csharp (#37776)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.24.2 to 3.24.3.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/ee1355459c9ce7ffe264bc40cfdc7b7623d37e99"><code>ee13554</code></a> Updating version.json and repo version numbers to: 24.3</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/a19e9ab0b6edf4450a35e33e3ae2962b3aad299c"><code>a19e9ab</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13881">#13881</a> from honglooker/24.x</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/6af84eec4f0c69311526cce3ed6607276a9107f3"><code>6af84ee</code></a> bring protobuf dep [upb] to parity for 24.3</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/3465661aece8b9c754dcb3d4f0432bb89374e738"><code>3465661</code></a> Silence warnings about extra semicolon in non-TSAN builds. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13820">#13820</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/398a84ce486d282e217f1120b810626c6b71f058"><code>398a84c</code></a> Workaround ICE on gcc 7.5 by not having one overload call the other one with ...</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/e5b5696a87b6be69ffe1534d8a6ea4c91f0bf81b"><code>e5b5696</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13697">#13697</a> from protocolbuffers/24.x-202308252017</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/afecb4769852dde19f6e777901bfbc85e677365c"><code>afecb47</code></a> Updating version.json to: 24.3-dev</li>
<li>See full diff in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.24.2...v3.24.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.24.2&new-version=3.24.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 0ffb2f0a8e518..3a3a7d406b128 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.24.2" />
+    <PackageReference Include="Google.Protobuf" Version="3.24.3" />
     <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
     <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
   </ItemGroup>

From 25fa89df2b55012b447b9c0348733570cb695566 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 19 Sep 2023 11:46:24 +0900
Subject: [PATCH 380/749] MINOR: [C#] Bump xunit.runner.visualstudio from 2.5.0
 to 2.5.1 in /csharp (#37774)

Bumps [xunit.runner.visualstudio](https://github.com/xunit/xunit) from 2.5.0 to 2.5.1.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/9dc851b5e642ec7929da1ac06d59988d0a2d840b"><code>9dc851b</code></a> v2.5.1</li>
<li><a href="https://github.com/xunit/xunit/commit/86b0eef9ef286661a7f804ec16575396325ca458"><code>86b0eef</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2770">#2770</a>: Make SerializationHelper public</li>
<li><a href="https://github.com/xunit/xunit/commit/f49dafc318e93a105d78704b8a6734c966ae1418"><code>f49dafc</code></a> File re-sort for SerializationHelper &amp; XunitSerializationInfo</li>
<li><a href="https://github.com/xunit/xunit/commit/d0004ae78d9b0fafa0a6fc046af50bb912d1581e"><code>d0004ae</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2773">#2773</a>: Add Assert.RaisesAny and Assert.RaisesAnyAsync non-generic for EventAr...</li>
<li><a href="https://github.com/xunit/xunit/commit/c1dba28cf0929d6602168ab4a081ca6a536323f0"><code>c1dba28</code></a> Latest assertions</li>
<li><a href="https://github.com/xunit/xunit/commit/b7c828ebf130cf3d768ef6b3effcb38fe15690d3"><code>b7c828e</code></a> Move .editorconfig up into contentFiles</li>
<li><a href="https://github.com/xunit/xunit/commit/08e74e76b884f29f2e9d9f93e8fcf8bda39982de"><code>08e74e7</code></a> Add .editorconfig to assert source NuGet package to indicate generated code (...</li>
<li><a href="https://github.com/xunit/xunit/commit/79f411aabe2e74ab00fe2ecbd9f237bc85af792b"><code>79f411a</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2767">#2767</a>: Verify types match when comparing FileSystemInfo values (v2)</li>
<li><a href="https://github.com/xunit/xunit/commit/9c28f584e0cf5a714b03433eaa7e19c3d3c40ddb"><code>9c28f58</code></a> Latest dependencies</li>
<li><a href="https://github.com/xunit/xunit/commit/63dce4f197f79306c47eef96323be56c081b08f8"><code>63dce4f</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2767">#2767</a>: Special case FileSystemInfo objects by just comparing the FullName in ...</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/xunit/compare/2.5.0...2.5.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit.runner.visualstudio&package-manager=nuget&previous-version=2.5.0&new-version=2.5.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 730099246edc9..fc21b06ced689 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index d829d02cfada6..48ba93f58b973 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -8,7 +8,7 @@
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
       <PackageReference Include="xunit" Version="2.5.1" />
-      <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
+      <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 4d00208fbaf2e..6dd816ac73e86 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index ccd630d279279..e7af9e2246276 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -12,7 +12,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

From 3b646ad4c2b826fe08b31d19e6435f73650bcb5e Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 19 Sep 2023 16:41:31 +0200
Subject: [PATCH 381/749] GH-37537: [Integration][C++] Add C Data Interface
 integration testing (#37769)

### Rationale for this change

Currently there are no systematic integration tests between implementations of the C Data Interface, only a couple ad-hoc tests.

### What changes are included in this PR?

1. Add Archery infrastructure for integration testing of the C Data Interface
2. Add implementation of this interface for Arrow C++

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

No.
* Closes: #37537

Lead-authored-by: Antoine Pitrou <antoine@python.org>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Will Jones <willjones127@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/scripts/integration_arrow.sh               |   6 +-
 cpp/src/arrow/CMakeLists.txt                  |   6 +-
 .../c_data_integration_internal.cc            | 145 ++++++++++
 .../integration/c_data_integration_internal.h |  48 ++++
 cpp/src/arrow/integration/json_integration.cc |   7 +-
 cpp/src/arrow/symbols.map                     |   1 +
 dev/archery/archery/cli.py                    |  21 +-
 dev/archery/archery/integration/cdata.py      | 107 +++++++
 dev/archery/archery/integration/datagen.py    | 110 +++++---
 dev/archery/archery/integration/runner.py     | 267 ++++++++++++++----
 dev/archery/archery/integration/scenario.py   |   7 +-
 dev/archery/archery/integration/tester.py     | 183 +++++++++++-
 dev/archery/archery/integration/tester_cpp.py | 114 +++++++-
 dev/archery/archery/integration/util.py       |   4 +-
 dev/archery/setup.py                          |  11 +-
 15 files changed, 913 insertions(+), 124 deletions(-)
 create mode 100644 cpp/src/arrow/integration/c_data_integration_internal.cc
 create mode 100644 cpp/src/arrow/integration/c_data_integration_internal.h
 create mode 100644 dev/archery/archery/integration/cdata.py

diff --git a/ci/scripts/integration_arrow.sh b/ci/scripts/integration_arrow.sh
index 30cbb2d63791c..a165f8027bf8f 100755
--- a/ci/scripts/integration_arrow.sh
+++ b/ci/scripts/integration_arrow.sh
@@ -22,10 +22,12 @@ set -ex
 arrow_dir=${1}
 gold_dir=$arrow_dir/testing/data/arrow-ipc-stream/integration
 
-pip install -e $arrow_dir/dev/archery
+pip install -e $arrow_dir/dev/archery[integration]
 
 # Rust can be enabled by exporting ARCHERY_INTEGRATION_WITH_RUST=1
-archery integration \
+time archery integration \
+    --run-c-data \
+    --run-ipc \
     --run-flight \
     --with-cpp=1 \
     --with-csharp=1 \
diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index f474d0c517fa0..9a6117011535e 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -383,7 +383,11 @@ endif()
 #
 
 if(ARROW_BUILD_INTEGRATION OR ARROW_BUILD_TESTS)
-  list(APPEND ARROW_SRCS integration/json_integration.cc integration/json_internal.cc)
+  list(APPEND
+       ARROW_SRCS
+       integration/c_data_integration_internal.cc
+       integration/json_integration.cc
+       integration/json_internal.cc)
 endif()
 
 if(ARROW_CSV)
diff --git a/cpp/src/arrow/integration/c_data_integration_internal.cc b/cpp/src/arrow/integration/c_data_integration_internal.cc
new file mode 100644
index 0000000000000..79e09eaf91a39
--- /dev/null
+++ b/cpp/src/arrow/integration/c_data_integration_internal.cc
@@ -0,0 +1,145 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/integration/c_data_integration_internal.h"
+
+#include <sstream>
+#include <utility>
+
+#include "arrow/c/bridge.h"
+#include "arrow/integration/json_integration.h"
+#include "arrow/io/file.h"
+#include "arrow/memory_pool.h"
+#include "arrow/pretty_print.h"
+#include "arrow/record_batch.h"
+#include "arrow/result.h"
+#include "arrow/status.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::internal::integration {
+namespace {
+
+template <typename Func>
+const char* StatusToErrorString(Func&& func) {
+  static std::string error;
+
+  Status st = func();
+  if (st.ok()) {
+    return nullptr;
+  }
+  error = st.ToString();
+  ARROW_CHECK_GT(error.length(), 0);
+  return error.c_str();
+}
+
+Result<std::shared_ptr<Schema>> ReadSchemaFromJson(const std::string& json_path,
+                                                   MemoryPool* pool) {
+  ARROW_ASSIGN_OR_RAISE(auto file, io::ReadableFile::Open(json_path, pool));
+  ARROW_ASSIGN_OR_RAISE(auto reader, IntegrationJsonReader::Open(pool, file));
+  return reader->schema();
+}
+
+Result<std::shared_ptr<RecordBatch>> ReadBatchFromJson(const std::string& json_path,
+                                                       int num_batch, MemoryPool* pool) {
+  ARROW_ASSIGN_OR_RAISE(auto file, io::ReadableFile::Open(json_path, pool));
+  ARROW_ASSIGN_OR_RAISE(auto reader, IntegrationJsonReader::Open(pool, file));
+  return reader->ReadRecordBatch(num_batch);
+}
+
+// XXX ideally, we should allow use of a custom memory pool in the C bridge API,
+// but that requires non-trivial refactor
+
+Status ExportSchemaFromJson(std::string json_path, ArrowSchema* out) {
+  auto pool = default_memory_pool();
+  ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchemaFromJson(json_path, pool));
+  return ExportSchema(*schema, out);
+}
+
+Status ImportSchemaAndCompareToJson(std::string json_path, ArrowSchema* c_schema) {
+  auto pool = default_memory_pool();
+  ARROW_ASSIGN_OR_RAISE(auto json_schema, ReadSchemaFromJson(json_path, pool));
+  ARROW_ASSIGN_OR_RAISE(auto imported_schema, ImportSchema(c_schema));
+  if (!imported_schema->Equals(json_schema, /*check_metadata=*/true)) {
+    return Status::Invalid("Schemas are different:", "\n- Json Schema: ", *json_schema,
+                           "\n- Imported Schema: ", *imported_schema);
+  }
+  return Status::OK();
+}
+
+Status ExportBatchFromJson(std::string json_path, int num_batch, ArrowArray* out) {
+  auto pool = default_memory_pool();
+  ARROW_ASSIGN_OR_RAISE(auto batch, ReadBatchFromJson(json_path, num_batch, pool));
+  return ExportRecordBatch(*batch, out);
+}
+
+Status ImportBatchAndCompareToJson(std::string json_path, int num_batch,
+                                   ArrowArray* c_batch) {
+  auto pool = default_memory_pool();
+  ARROW_ASSIGN_OR_RAISE(auto batch, ReadBatchFromJson(json_path, num_batch, pool));
+  ARROW_ASSIGN_OR_RAISE(auto imported_batch, ImportRecordBatch(c_batch, batch->schema()));
+  RETURN_NOT_OK(imported_batch->ValidateFull());
+  if (!imported_batch->Equals(*batch, /*check_metadata=*/true)) {
+    std::stringstream pp_expected;
+    std::stringstream pp_actual;
+    PrettyPrintOptions options(/*indent=*/2);
+    options.window = 50;
+    ARROW_CHECK_OK(PrettyPrint(*batch, options, &pp_expected));
+    ARROW_CHECK_OK(PrettyPrint(*imported_batch, options, &pp_actual));
+    return Status::Invalid("Record Batches are different:", "\n- Json Batch: ",
+                           pp_expected.str(), "\n- Imported Batch: ", pp_actual.str());
+  }
+  return Status::OK();
+}
+
+}  // namespace
+}  // namespace arrow::internal::integration
+
+const char* ArrowCpp_CDataIntegration_ExportSchemaFromJson(const char* json_path,
+                                                           ArrowSchema* out) {
+  using namespace arrow::internal::integration;  // NOLINT(build/namespaces)
+  return StatusToErrorString([=]() { return ExportSchemaFromJson(json_path, out); });
+}
+
+const char* ArrowCpp_CDataIntegration_ImportSchemaAndCompareToJson(const char* json_path,
+                                                                   ArrowSchema* schema) {
+  using namespace arrow::internal::integration;  // NOLINT(build/namespaces)
+  return StatusToErrorString(
+      [=]() { return ImportSchemaAndCompareToJson(json_path, schema); });
+}
+
+const char* ArrowCpp_CDataIntegration_ExportBatchFromJson(const char* json_path,
+                                                          int num_batch,
+                                                          ArrowArray* out) {
+  using namespace arrow::internal::integration;  // NOLINT(build/namespaces)
+  return StatusToErrorString(
+      [=]() { return ExportBatchFromJson(json_path, num_batch, out); });
+}
+
+const char* ArrowCpp_CDataIntegration_ImportBatchAndCompareToJson(const char* json_path,
+                                                                  int num_batch,
+                                                                  ArrowArray* batch) {
+  using namespace arrow::internal::integration;  // NOLINT(build/namespaces)
+  return StatusToErrorString(
+      [=]() { return ImportBatchAndCompareToJson(json_path, num_batch, batch); });
+}
+
+int64_t ArrowCpp_BytesAllocated() {
+  auto pool = arrow::default_memory_pool();
+  return pool->bytes_allocated();
+}
diff --git a/cpp/src/arrow/integration/c_data_integration_internal.h b/cpp/src/arrow/integration/c_data_integration_internal.h
new file mode 100644
index 0000000000000..0a62363dffab3
--- /dev/null
+++ b/cpp/src/arrow/integration/c_data_integration_internal.h
@@ -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.
+
+#pragma once
+
+#include "arrow/c/abi.h"
+#include "arrow/util/visibility.h"
+
+// This file only serves as documentation for the C Data Interface integration
+// entrypoints. The actual functions are called by Archery through DLL symbol lookup.
+
+extern "C" {
+
+ARROW_EXPORT
+const char* ArrowCpp_CDataIntegration_ExportSchemaFromJson(const char* json_path,
+                                                           ArrowSchema* out);
+
+ARROW_EXPORT
+const char* ArrowCpp_CDataIntegration_ImportSchemaAndCompareToJson(const char* json_path,
+                                                                   ArrowSchema* schema);
+
+ARROW_EXPORT
+const char* ArrowCpp_CDataIntegration_ExportBatchFromJson(const char* json_path,
+                                                          int num_batch, ArrowArray* out);
+
+ARROW_EXPORT
+const char* ArrowCpp_CDataIntegration_ImportBatchAndCompareToJson(const char* json_path,
+                                                                  int num_batch,
+                                                                  ArrowArray* batch);
+
+ARROW_EXPORT
+int64_t ArrowCpp_BytesAllocated();
+
+}  // extern "C"
diff --git a/cpp/src/arrow/integration/json_integration.cc b/cpp/src/arrow/integration/json_integration.cc
index 178abe5e8b687..590f6eddd7c24 100644
--- a/cpp/src/arrow/integration/json_integration.cc
+++ b/cpp/src/arrow/integration/json_integration.cc
@@ -144,10 +144,9 @@ class IntegrationJsonReader::Impl {
   }
 
   Result<std::shared_ptr<RecordBatch>> ReadRecordBatch(int i) {
-    DCHECK_GE(i, 0) << "i out of bounds";
-    DCHECK_LT(i, static_cast<int>(record_batches_->GetArray().Size()))
-        << "i out of bounds";
-
+    if (i < 0 || i >= static_cast<int>(record_batches_->GetArray().Size())) {
+      return Status::IndexError("record batch index ", i, " out of bounds");
+    }
     return json::ReadRecordBatch(record_batches_->GetArray()[i], schema_,
                                  &dictionary_memo_, pool_);
   }
diff --git a/cpp/src/arrow/symbols.map b/cpp/src/arrow/symbols.map
index 9ef0e404bc091..0144e6116554b 100644
--- a/cpp/src/arrow/symbols.map
+++ b/cpp/src/arrow/symbols.map
@@ -32,6 +32,7 @@
     };
     # Also export C-level helpers
     arrow_*;
+    Arrow*;
     # ARROW-14771: export Protobuf symbol table
     descriptor_table_Flight_2eproto;
     descriptor_table_FlightSql_2eproto;
diff --git a/dev/archery/archery/cli.py b/dev/archery/archery/cli.py
index 70f865cc2fa70..7a3b45f9788e6 100644
--- a/dev/archery/archery/cli.py
+++ b/dev/archery/archery/cli.py
@@ -723,8 +723,12 @@ def _set_default(opt, default):
               envvar="ARCHERY_INTEGRATION_WITH_RUST")
 @click.option('--write_generated_json', default="",
               help='Generate test JSON to indicated path')
+@click.option('--run-ipc', is_flag=True, default=False,
+              help='Run IPC integration tests')
 @click.option('--run-flight', is_flag=True, default=False,
               help='Run Flight integration tests')
+@click.option('--run-c-data', is_flag=True, default=False,
+              help='Run C Data Interface integration tests')
 @click.option('--debug', is_flag=True, default=False,
               help='Run executables in debug mode as relevant')
 @click.option('--serial', is_flag=True, default=False,
@@ -753,15 +757,19 @@ def integration(with_all=False, random_seed=12345, **args):
     gen_path = args['write_generated_json']
 
     languages = ['cpp', 'csharp', 'java', 'js', 'go', 'rust']
+    formats = ['ipc', 'flight', 'c_data']
 
     enabled_languages = 0
     for lang in languages:
-        param = 'with_{}'.format(lang)
+        param = f'with_{lang}'
         if with_all:
             args[param] = with_all
+        enabled_languages += args[param]
 
-        if args[param]:
-            enabled_languages += 1
+    enabled_formats = 0
+    for fmt in formats:
+        param = f'run_{fmt}'
+        enabled_formats += args[param]
 
     if gen_path:
         # XXX See GH-37575: this option is only used by the JS test suite
@@ -769,8 +777,13 @@ def integration(with_all=False, random_seed=12345, **args):
         os.makedirs(gen_path, exist_ok=True)
         write_js_test_json(gen_path)
     else:
+        if enabled_formats == 0:
+            raise click.UsageError(
+                "Need to enable at least one format to test "
+                "(IPC, Flight, C Data Interface); try --help")
         if enabled_languages == 0:
-            raise Exception("Must enable at least 1 language to test")
+            raise click.UsageError(
+                "Need to enable at least one language to test; try --help")
         run_all_tests(**args)
 
 
diff --git a/dev/archery/archery/integration/cdata.py b/dev/archery/archery/integration/cdata.py
new file mode 100644
index 0000000000000..c201f5f867f8f
--- /dev/null
+++ b/dev/archery/archery/integration/cdata.py
@@ -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.
+
+import cffi
+from contextlib import contextmanager
+import functools
+
+from .tester import CDataExporter, CDataImporter
+
+
+_c_data_decls = """
+    struct ArrowSchema {
+      // Array type description
+      const char* format;
+      const char* name;
+      const char* metadata;
+      int64_t flags;
+      int64_t n_children;
+      struct ArrowSchema** children;
+      struct ArrowSchema* dictionary;
+
+      // Release callback
+      void (*release)(struct ArrowSchema*);
+      // Opaque producer-specific data
+      void* private_data;
+    };
+
+    struct ArrowArray {
+      // Array data description
+      int64_t length;
+      int64_t null_count;
+      int64_t offset;
+      int64_t n_buffers;
+      int64_t n_children;
+      const void** buffers;
+      struct ArrowArray** children;
+      struct ArrowArray* dictionary;
+
+      // Release callback
+      void (*release)(struct ArrowArray*);
+      // Opaque producer-specific data
+      void* private_data;
+    };
+
+    struct ArrowArrayStream {
+      int (*get_schema)(struct ArrowArrayStream*, struct ArrowSchema* out);
+      int (*get_next)(struct ArrowArrayStream*, struct ArrowArray* out);
+
+      const char* (*get_last_error)(struct ArrowArrayStream*);
+
+      // Release callback
+      void (*release)(struct ArrowArrayStream*);
+      // Opaque producer-specific data
+      void* private_data;
+    };
+    """
+
+
+@functools.lru_cache
+def ffi() -> cffi.FFI:
+    """
+    Return a FFI object supporting C Data Interface types.
+    """
+    ffi = cffi.FFI()
+    ffi.cdef(_c_data_decls)
+    return ffi
+
+
+@contextmanager
+def check_memory_released(exporter: CDataExporter, importer: CDataImporter):
+    """
+    A context manager for memory release checks.
+
+    The context manager arranges cooperation between the exporter and importer
+    to try and release memory at the end of the enclosed block.
+
+    However, if either the exporter or importer doesn't support deterministic
+    memory release, no memory check is performed.
+    """
+    do_check = (exporter.supports_releasing_memory and
+                importer.supports_releasing_memory)
+    if do_check:
+        before = exporter.record_allocation_state()
+    yield
+    # We don't use a `finally` clause: if the enclosed block raised an
+    # exception, no need to add another one.
+    if do_check:
+        ok = exporter.compare_allocation_state(before, importer.gc_until)
+        if not ok:
+            after = exporter.record_allocation_state()
+            raise RuntimeError(
+                f"Memory was not released correctly after roundtrip: "
+                f"before = {before}, after = {after} (should have been equal)")
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index f924c8a73cb8a..53f7ba58bff99 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -25,6 +25,7 @@
 import numpy as np
 
 from .util import frombytes, tobytes, random_bytes, random_utf8
+from .util import SKIP_C_SCHEMA, SKIP_C_ARRAY
 
 
 def metadata_key_values(pairs):
@@ -1224,15 +1225,16 @@ def get_json(self):
 class File(object):
 
     def __init__(self, name, schema, batches, dictionaries=None,
-                 skip=None, path=None, quirks=None):
+                 skip_testers=None, path=None, quirks=None):
         self.name = name
         self.schema = schema
         self.dictionaries = dictionaries or []
         self.batches = batches
-        self.skip = set()
+        self.skipped_testers = set()
+        self.skipped_formats = {}
         self.path = path
-        if skip:
-            self.skip.update(skip)
+        if skip_testers:
+            self.skipped_testers.update(skip_testers)
         # For tracking flags like whether to validate decimal values
         # fit into the given precision (ARROW-13558).
         self.quirks = set()
@@ -1258,14 +1260,39 @@ def write(self, path):
             f.write(json.dumps(self.get_json(), indent=2).encode('utf-8'))
         self.path = path
 
-    def skip_category(self, category):
-        """Skip this test for the given category.
+    def skip_tester(self, tester):
+        """Skip this test for the given tester (such as 'C#').
+        """
+        self.skipped_testers.add(tester)
+        return self
 
-        Category should be SKIP_ARROW or SKIP_FLIGHT.
+    def skip_format(self, format, tester='all'):
+        """Skip this test for the given format, and optionally tester.
         """
-        self.skip.add(category)
+        self.skipped_formats.setdefault(format, set()).add(tester)
         return self
 
+    def add_skips_from(self, other_file):
+        """Add skips from another File object.
+        """
+        self.skipped_testers.update(other_file.skipped_testers)
+        for format, testers in other_file.skipped_formats.items():
+            self.skipped_formats.setdefault(format, set()).update(testers)
+
+    def should_skip(self, tester, format):
+        """Whether this (tester, format) combination should be skipped.
+        """
+        if tester in self.skipped_testers:
+            return True
+        testers = self.skipped_formats.get(format, ())
+        return 'all' in testers or tester in testers
+
+    @property
+    def num_batches(self):
+        """The number of record batches in this file.
+        """
+        return len(self.batches)
+
 
 def get_field(name, type_, **kwargs):
     if type_ == 'binary':
@@ -1295,8 +1322,8 @@ def get_field(name, type_, **kwargs):
         raise TypeError(dtype)
 
 
-def _generate_file(name, fields, batch_sizes, dictionaries=None, skip=None,
-                   metadata=None):
+def _generate_file(name, fields, batch_sizes, *,
+                   dictionaries=None, metadata=None):
     schema = Schema(fields, metadata=metadata)
     batches = []
     for size in batch_sizes:
@@ -1307,7 +1334,7 @@ def _generate_file(name, fields, batch_sizes, dictionaries=None, skip=None,
 
         batches.append(RecordBatch(size, columns))
 
-    return File(name, schema, batches, dictionaries, skip=skip)
+    return File(name, schema, batches, dictionaries)
 
 
 def generate_custom_metadata_case():
@@ -1666,8 +1693,8 @@ def _temp_path():
         generate_primitive_case([0, 0, 0], name='primitive_zerolength'),
 
         generate_primitive_large_offsets_case([17, 20])
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_tester('C#')
+        .skip_tester('JS'),
 
         generate_null_case([10, 0]),
 
@@ -1676,66 +1703,71 @@ def _temp_path():
         generate_decimal128_case(),
 
         generate_decimal256_case()
-        .skip_category('JS'),
+        .skip_tester('JS'),
 
         generate_datetime_case(),
 
         generate_duration_case()
-        .skip_category('C#')
-        .skip_category('JS'),  # TODO(ARROW-5239): Intervals + JS
+        .skip_tester('C#')
+        .skip_tester('JS'),  # TODO(ARROW-5239): Intervals + JS
 
         generate_interval_case()
-        .skip_category('C#')
-        .skip_category('JS'),  # TODO(ARROW-5239): Intervals + JS
+        .skip_tester('C#')
+        .skip_tester('JS'),  # TODO(ARROW-5239): Intervals + JS
 
         generate_month_day_nano_interval_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_tester('C#')
+        .skip_tester('JS'),
 
         generate_map_case()
-        .skip_category('C#'),
+        .skip_tester('C#'),
 
         generate_non_canonical_map_case()
-        .skip_category('C#')
-        .skip_category('Java'),   # TODO(ARROW-8715)
+        .skip_tester('C#')
+        .skip_tester('Java')  # TODO(ARROW-8715)
+        # Canonical map names are restored on import, so the schemas are unequal
+        .skip_format(SKIP_C_SCHEMA, 'C++'),
 
         generate_nested_case(),
 
         generate_recursive_nested_case(),
 
         generate_nested_large_offsets_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_tester('C#')
+        .skip_tester('JS'),
 
         generate_unions_case()
-        .skip_category('C#'),
+        .skip_tester('C#'),
 
         generate_custom_metadata_case()
-        .skip_category('C#'),
+        .skip_tester('C#'),
 
         generate_duplicate_fieldnames_case()
-        .skip_category('C#')
-        .skip_category('JS'),
+        .skip_tester('C#')
+        .skip_tester('JS'),
 
         generate_dictionary_case()
-        .skip_category('C#'),
+        .skip_tester('C#'),
 
         generate_dictionary_unsigned_case()
-        .skip_category('C#')
-        .skip_category('Java'),  # TODO(ARROW-9377)
+        .skip_tester('C#')
+        .skip_tester('Java'),  # TODO(ARROW-9377)
 
         generate_nested_dictionary_case()
-        .skip_category('C#')
-        .skip_category('Java'),  # TODO(ARROW-7779)
+        .skip_tester('C#')
+        .skip_tester('Java'),  # TODO(ARROW-7779)
 
         generate_run_end_encoded_case()
-        .skip_category('C#')
-        .skip_category('Java')
-        .skip_category('JS')
-        .skip_category('Rust'),
+        .skip_tester('C#')
+        .skip_tester('Java')
+        .skip_tester('JS')
+        .skip_tester('Rust'),
 
         generate_extension_case()
-        .skip_category('C#'),
+        .skip_tester('C#')
+        # TODO: ensure the extension is registered in the C++ entrypoint
+        .skip_format(SKIP_C_SCHEMA, 'C++')
+        .skip_format(SKIP_C_ARRAY, 'C++'),
     ]
 
     generated_paths = []
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index 0ee9ab814e5e6..2fd1d2d7f0c44 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -25,17 +25,19 @@
 import sys
 import tempfile
 import traceback
-from typing import Callable, List
+from typing import Callable, List, Optional
 
+from . import cdata
 from .scenario import Scenario
-from .tester import Tester
-from .tester_cpp import CPPTester
+from .tester import Tester, CDataExporter, CDataImporter
+from .tester_cpp import CppTester
 from .tester_go import GoTester
 from .tester_rust import RustTester
 from .tester_java import JavaTester
 from .tester_js import JSTester
 from .tester_csharp import CSharpTester
-from .util import guid, SKIP_ARROW, SKIP_FLIGHT, printer
+from .util import guid, printer
+from .util import SKIP_C_ARRAY, SKIP_C_SCHEMA, SKIP_FLIGHT, SKIP_IPC
 from ..utils.source import ARROW_ROOT_DEFAULT
 from . import datagen
 
@@ -76,7 +78,7 @@ def __init__(self, json_files,
             self.json_files = [json_file for json_file in self.json_files
                                if self.match in json_file.name]
 
-    def run(self):
+    def run_ipc(self):
         """
         Run Arrow IPC integration tests for the matrix of enabled
         implementations.
@@ -84,23 +86,24 @@ def run(self):
         for producer, consumer in itertools.product(
                 filter(lambda t: t.PRODUCER, self.testers),
                 filter(lambda t: t.CONSUMER, self.testers)):
-            self._compare_implementations(
+            self._compare_ipc_implementations(
                 producer, consumer, self._produce_consume,
                 self.json_files)
         if self.gold_dirs:
             for gold_dir, consumer in itertools.product(
                     self.gold_dirs,
                     filter(lambda t: t.CONSUMER, self.testers)):
-                log('\n\n\n\n')
+                log('\n')
                 log('******************************************************')
                 log('Tests against golden files in {}'.format(gold_dir))
                 log('******************************************************')
 
                 def run_gold(_, consumer, test_case: datagen.File):
                     return self._run_gold(gold_dir, consumer, test_case)
-                self._compare_implementations(
+                self._compare_ipc_implementations(
                     consumer, consumer, run_gold,
                     self._gold_tests(gold_dir))
+        log('\n')
 
     def run_flight(self):
         """
@@ -112,6 +115,18 @@ def run_flight(self):
                          self.testers)
         for server, client in itertools.product(servers, clients):
             self._compare_flight_implementations(server, client)
+        log('\n')
+
+    def run_c_data(self):
+        """
+        Run Arrow C Data interface integration tests for the matrix of
+        enabled implementations.
+        """
+        for producer, consumer in itertools.product(
+                filter(lambda t: t.C_DATA_EXPORTER, self.testers),
+                filter(lambda t: t.C_DATA_IMPORTER, self.testers)):
+            self._compare_c_data_implementations(producer, consumer)
+        log('\n')
 
     def _gold_tests(self, gold_dir):
         prefix = os.path.basename(os.path.normpath(gold_dir))
@@ -125,28 +140,31 @@ def _gold_tests(self, gold_dir):
                 with open(out_path, "wb") as out:
                     out.write(i.read())
 
+            # Find the generated file with the same name as this gold file
             try:
-                skip = next(f for f in self.json_files
-                            if f.name == name).skip
+                equiv_json_file = next(f for f in self.json_files
+                                       if f.name == name)
             except StopIteration:
-                skip = set()
+                equiv_json_file = None
+
+            skip_testers = set()
             if name == 'union' and prefix == '0.17.1':
-                skip.add("Java")
-                skip.add("JS")
+                skip_testers.add("Java")
+                skip_testers.add("JS")
             if prefix == '1.0.0-bigendian' or prefix == '1.0.0-littleendian':
-                skip.add("C#")
-                skip.add("Java")
-                skip.add("JS")
-                skip.add("Rust")
+                skip_testers.add("C#")
+                skip_testers.add("Java")
+                skip_testers.add("JS")
+                skip_testers.add("Rust")
             if prefix == '2.0.0-compression':
-                skip.add("C#")
-                skip.add("JS")
+                skip_testers.add("C#")
+                skip_testers.add("JS")
 
             # See https://github.com/apache/arrow/pull/9822 for how to
             # disable specific compression type tests.
 
             if prefix == '4.0.0-shareddict':
-                skip.add("C#")
+                skip_testers.add("C#")
 
             quirks = set()
             if prefix in {'0.14.1', '0.17.1',
@@ -157,12 +175,18 @@ def _gold_tests(self, gold_dir):
                 quirks.add("no_date64_validate")
                 quirks.add("no_times_validate")
 
-            yield datagen.File(name, None, None, skip=skip, path=out_path,
-                               quirks=quirks)
+            json_file = datagen.File(name, schema=None, batches=None,
+                                     path=out_path,
+                                     skip_testers=skip_testers,
+                                     quirks=quirks)
+            if equiv_json_file is not None:
+                json_file.add_skips_from(equiv_json_file)
+            yield json_file
 
     def _run_test_cases(self,
                         case_runner: Callable[[datagen.File], Outcome],
-                        test_cases: List[datagen.File]) -> None:
+                        test_cases: List[datagen.File],
+                        *, serial: Optional[bool] = None) -> None:
         """
         Populate self.failures with the outcomes of the
         ``case_runner`` ran against ``test_cases``
@@ -171,10 +195,13 @@ def case_wrapper(test_case):
             with printer.cork():
                 return case_runner(test_case)
 
+        if serial is None:
+            serial = self.serial
+
         if self.failures and self.stop_on_error:
             return
 
-        if self.serial:
+        if serial:
             for outcome in map(case_wrapper, test_cases):
                 if outcome.failure is not None:
                     self.failures.append(outcome.failure)
@@ -189,7 +216,7 @@ def case_wrapper(test_case):
                         if self.stop_on_error:
                             break
 
-    def _compare_implementations(
+    def _compare_ipc_implementations(
         self,
         producer: Tester,
         consumer: Tester,
@@ -221,22 +248,17 @@ def _run_ipc_test_case(
         outcome = Outcome()
 
         json_path = test_case.path
-        log('==========================================================')
+        log('=' * 70)
         log('Testing file {0}'.format(json_path))
-        log('==========================================================')
-
-        if producer.name in test_case.skip:
-            log('-- Skipping test because producer {0} does '
-                'not support'.format(producer.name))
-            outcome.skipped = True
 
-        elif consumer.name in test_case.skip:
-            log('-- Skipping test because consumer {0} does '
-                'not support'.format(consumer.name))
+        if test_case.should_skip(producer.name, SKIP_IPC):
+            log(f'-- Skipping test because producer {producer.name} does '
+                f'not support IPC')
             outcome.skipped = True
 
-        elif SKIP_ARROW in test_case.skip:
-            log('-- Skipping test')
+        elif test_case.should_skip(consumer.name, SKIP_IPC):
+            log(f'-- Skipping test because consumer {consumer.name} does '
+                f'not support IPC')
             outcome.skipped = True
 
         else:
@@ -247,6 +269,8 @@ def _run_ipc_test_case(
                 outcome.failure = Failure(test_case, producer, consumer,
                                           sys.exc_info())
 
+        log('=' * 70)
+
         return outcome
 
     def _produce_consume(self,
@@ -344,22 +368,17 @@ def _run_flight_test_case(self,
         """
         outcome = Outcome()
 
-        log('=' * 58)
+        log('=' * 70)
         log('Testing file {0}'.format(test_case.name))
-        log('=' * 58)
-
-        if producer.name in test_case.skip:
-            log('-- Skipping test because producer {0} does '
-                'not support'.format(producer.name))
-            outcome.skipped = True
 
-        elif consumer.name in test_case.skip:
-            log('-- Skipping test because consumer {0} does '
-                'not support'.format(consumer.name))
+        if test_case.should_skip(producer.name, SKIP_FLIGHT):
+            log(f'-- Skipping test because producer {producer.name} does '
+                f'not support Flight')
             outcome.skipped = True
 
-        elif SKIP_FLIGHT in test_case.skip:
-            log('-- Skipping test')
+        elif test_case.should_skip(consumer.name, SKIP_FLIGHT):
+            log(f'-- Skipping test because consumer {consumer.name} does '
+                f'not support Flight')
             outcome.skipped = True
 
         else:
@@ -380,6 +399,125 @@ def _run_flight_test_case(self,
                 outcome.failure = Failure(test_case, producer, consumer,
                                           sys.exc_info())
 
+        log('=' * 70)
+
+        return outcome
+
+    def _compare_c_data_implementations(
+        self,
+        producer: Tester,
+        consumer: Tester
+    ):
+        log('##########################################################')
+        log(f'C Data Interface: '
+            f'{producer.name} exporting, {consumer.name} importing')
+        log('##########################################################')
+
+        # Serial execution is required for proper memory accounting
+        serial = True
+
+        exporter = producer.make_c_data_exporter()
+        importer = consumer.make_c_data_importer()
+
+        case_runner = partial(self._run_c_schema_test_case, producer, consumer,
+                              exporter, importer)
+        self._run_test_cases(case_runner, self.json_files, serial=serial)
+
+        case_runner = partial(self._run_c_array_test_cases, producer, consumer,
+                              exporter, importer)
+        self._run_test_cases(case_runner, self.json_files, serial=serial)
+
+    def _run_c_schema_test_case(self,
+                                producer: Tester, consumer: Tester,
+                                exporter: CDataExporter,
+                                importer: CDataImporter,
+                                test_case: datagen.File) -> Outcome:
+        """
+        Run one C ArrowSchema test case.
+        """
+        outcome = Outcome()
+
+        def do_run():
+            json_path = test_case.path
+            ffi = cdata.ffi()
+            c_schema_ptr = ffi.new("struct ArrowSchema*")
+            with cdata.check_memory_released(exporter, importer):
+                exporter.export_schema_from_json(json_path, c_schema_ptr)
+                importer.import_schema_and_compare_to_json(json_path, c_schema_ptr)
+
+        log('=' * 70)
+        log(f'Testing C ArrowSchema from file {test_case.name!r}')
+
+        if test_case.should_skip(producer.name, SKIP_C_SCHEMA):
+            log(f'-- Skipping test because producer {producer.name} does '
+                f'not support C ArrowSchema')
+            outcome.skipped = True
+
+        elif test_case.should_skip(consumer.name, SKIP_C_SCHEMA):
+            log(f'-- Skipping test because consumer {consumer.name} does '
+                f'not support C ArrowSchema')
+            outcome.skipped = True
+
+        else:
+            try:
+                do_run()
+            except Exception:
+                traceback.print_exc(file=printer.stdout)
+                outcome.failure = Failure(test_case, producer, consumer,
+                                          sys.exc_info())
+
+        log('=' * 70)
+
+        return outcome
+
+    def _run_c_array_test_cases(self,
+                                producer: Tester, consumer: Tester,
+                                exporter: CDataExporter,
+                                importer: CDataImporter,
+                                test_case: datagen.File) -> Outcome:
+        """
+        Run one set C ArrowArray test cases.
+        """
+        outcome = Outcome()
+
+        def do_run():
+            json_path = test_case.path
+            ffi = cdata.ffi()
+            c_array_ptr = ffi.new("struct ArrowArray*")
+            for num_batch in range(test_case.num_batches):
+                log(f'... with record batch #{num_batch}')
+                with cdata.check_memory_released(exporter, importer):
+                    exporter.export_batch_from_json(json_path,
+                                                    num_batch,
+                                                    c_array_ptr)
+                    importer.import_batch_and_compare_to_json(json_path,
+                                                              num_batch,
+                                                              c_array_ptr)
+
+        log('=' * 70)
+        log(f'Testing C ArrowArray '
+            f'from file {test_case.name!r}')
+
+        if test_case.should_skip(producer.name, SKIP_C_ARRAY):
+            log(f'-- Skipping test because producer {producer.name} does '
+                f'not support C ArrowArray')
+            outcome.skipped = True
+
+        elif test_case.should_skip(consumer.name, SKIP_C_ARRAY):
+            log(f'-- Skipping test because consumer {consumer.name} does '
+                f'not support C ArrowArray')
+            outcome.skipped = True
+
+        else:
+            try:
+                do_run()
+            except Exception:
+                traceback.print_exc(file=printer.stdout)
+                outcome.failure = Failure(test_case, producer, consumer,
+                                          sys.exc_info())
+
+        log('=' * 70)
+
         return outcome
 
 
@@ -387,7 +525,7 @@ def get_static_json_files():
     glob_pattern = os.path.join(ARROW_ROOT_DEFAULT,
                                 'integration', 'data', '*.json')
     return [
-        datagen.File(name=os.path.basename(p), path=p, skip=set(),
+        datagen.File(name=os.path.basename(p), path=p,
                      schema=None, batches=None)
         for p in glob.glob(glob_pattern)
     ]
@@ -395,13 +533,14 @@ def get_static_json_files():
 
 def run_all_tests(with_cpp=True, with_java=True, with_js=True,
                   with_csharp=True, with_go=True, with_rust=False,
-                  run_flight=False, tempdir=None, **kwargs):
+                  run_ipc=False, run_flight=False, run_c_data=False,
+                  tempdir=None, **kwargs):
     tempdir = tempdir or tempfile.mkdtemp(prefix='arrow-integration-')
 
     testers: List[Tester] = []
 
     if with_cpp:
-        testers.append(CPPTester(**kwargs))
+        testers.append(CppTester(**kwargs))
 
     if with_java:
         testers.append(JavaTester(**kwargs))
@@ -434,54 +573,57 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
         Scenario(
             "ordered",
             description="Ensure FlightInfo.ordered is supported.",
-            skip={"JS", "C#", "Rust"},
+            skip_testers={"JS", "C#", "Rust"},
         ),
         Scenario(
             "expiration_time:do_get",
             description=("Ensure FlightEndpoint.expiration_time with "
                          "DoGet is working as expected."),
-            skip={"JS", "C#", "Rust"},
+            skip_testers={"JS", "C#", "Rust"},
         ),
         Scenario(
             "expiration_time:list_actions",
             description=("Ensure FlightEndpoint.expiration_time related "
                          "pre-defined actions is working with ListActions "
                          "as expected."),
-            skip={"JS", "C#", "Rust"},
+            skip_testers={"JS", "C#", "Rust"},
         ),
         Scenario(
             "expiration_time:cancel_flight_info",
             description=("Ensure FlightEndpoint.expiration_time and "
                          "CancelFlightInfo are working as expected."),
-            skip={"JS", "C#", "Rust"},
+            skip_testers={"JS", "C#", "Rust"},
         ),
         Scenario(
             "expiration_time:renew_flight_endpoint",
             description=("Ensure FlightEndpoint.expiration_time and "
                          "RenewFlightEndpoint are working as expected."),
-            skip={"JS", "C#", "Rust"},
+            skip_testers={"JS", "C#", "Rust"},
         ),
         Scenario(
             "poll_flight_info",
             description="Ensure PollFlightInfo is supported.",
-            skip={"JS", "C#", "Rust"}
+            skip_testers={"JS", "C#", "Rust"}
         ),
         Scenario(
             "flight_sql",
             description="Ensure Flight SQL protocol is working as expected.",
-            skip={"Rust"}
+            skip_testers={"Rust"}
         ),
         Scenario(
             "flight_sql:extension",
             description="Ensure Flight SQL extensions work as expected.",
-            skip={"Rust"}
+            skip_testers={"Rust"}
         ),
     ]
 
     runner = IntegrationRunner(json_files, flight_scenarios, testers, **kwargs)
-    runner.run()
+    if run_ipc:
+        runner.run_ipc()
     if run_flight:
         runner.run_flight()
+    if run_c_data:
+        runner.run_c_data()
 
     fail_count = 0
     if runner.failures:
@@ -492,7 +634,8 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
             log(test_case.name, producer.name, "producing, ",
                 consumer.name, "consuming")
             if exc_info:
-                traceback.print_exception(*exc_info)
+                exc_type, exc_value, exc_tb = exc_info
+                log(f'{exc_type}: {exc_value}')
             log()
 
     log(fail_count, "failures")
diff --git a/dev/archery/archery/integration/scenario.py b/dev/archery/archery/integration/scenario.py
index 1fcbca64e6a1f..89c64452e5fc5 100644
--- a/dev/archery/archery/integration/scenario.py
+++ b/dev/archery/archery/integration/scenario.py
@@ -23,7 +23,10 @@ class Scenario:
     Does not correspond to a particular IPC JSON file.
     """
 
-    def __init__(self, name, description, skip=None):
+    def __init__(self, name, description, skip_testers=None):
         self.name = name
         self.description = description
-        self.skip = skip or set()
+        self.skipped_testers = skip_testers or set()
+
+    def should_skip(self, tester, format):
+        return tester in self.skipped_testers
diff --git a/dev/archery/archery/integration/tester.py b/dev/archery/archery/integration/tester.py
index 54bfe621efd92..6a3061992d006 100644
--- a/dev/archery/archery/integration/tester.py
+++ b/dev/archery/archery/integration/tester.py
@@ -17,12 +17,181 @@
 
 # Base class for language-specific integration test harnesses
 
+from abc import ABC, abstractmethod
+import os
 import subprocess
+import typing
 
 from .util import log
 
 
-class Tester(object):
+_Predicate = typing.Callable[[], bool]
+
+
+class CDataExporter(ABC):
+
+    @abstractmethod
+    def export_schema_from_json(self, json_path: os.PathLike,
+                                c_schema_ptr: object):
+        """
+        Read a JSON integration file and export its schema.
+
+        Parameters
+        ----------
+        json_path : Path
+            Path to the JSON file
+        c_schema_ptr : cffi pointer value
+            Pointer to the ``ArrowSchema`` struct to export to.
+        """
+
+    @abstractmethod
+    def export_batch_from_json(self, json_path: os.PathLike,
+                               num_batch: int,
+                               c_array_ptr: object):
+        """
+        Read a JSON integration file and export one of its batches.
+
+        Parameters
+        ----------
+        json_path : Path
+            Path to the JSON file
+        num_batch : int
+            Number of the record batch in the JSON file
+        c_schema_ptr : cffi pointer value
+            Pointer to the ``ArrowArray`` struct to export to.
+        """
+
+    @property
+    @abstractmethod
+    def supports_releasing_memory(self) -> bool:
+        """
+        Whether the implementation is able to release memory deterministically.
+
+        Here, "release memory" means that, after the `release` callback of
+        a C Data Interface export is called, `compare_allocation_state` is
+        able to trigger the deallocation of the memory underlying the export
+        (for example buffer data).
+
+        If false, then `record_allocation_state` and `compare_allocation_state`
+        are allowed to raise NotImplementedError.
+        """
+
+    def record_allocation_state(self) -> object:
+        """
+        Record the current memory allocation state.
+
+        Returns
+        -------
+        state : object
+            Opaque object representing the allocation state,
+            for example the number of allocated bytes.
+        """
+        raise NotImplementedError
+
+    def compare_allocation_state(self, recorded: object,
+                                 gc_until: typing.Callable[[_Predicate], bool]
+                                 ) -> bool:
+        """
+        Compare the current memory allocation state with the recorded one.
+
+        Parameters
+        ----------
+        recorded : object
+            The previous allocation state returned by
+            `record_allocation_state()`
+        gc_until : callable
+            A callable itself accepting a callable predicate, and
+            returning a boolean.
+            `gc_until` should try to release memory until the predicate
+            becomes true, or until it decides to give up. The final value
+            of the predicate should be returned.
+            `gc_until` is typically provided by the C Data Interface importer.
+
+        Returns
+        -------
+        success : bool
+            Whether memory allocation state finally reached its previously
+            recorded value.
+        """
+        raise NotImplementedError
+
+
+class CDataImporter(ABC):
+
+    @abstractmethod
+    def import_schema_and_compare_to_json(self, json_path: os.PathLike,
+                                          c_schema_ptr: object):
+        """
+        Import schema and compare it to the schema of a JSON integration file.
+
+        An error is raised if importing fails or the schemas differ.
+
+        Parameters
+        ----------
+        json_path : Path
+            The path to the JSON file
+        c_schema_ptr : cffi pointer value
+            Pointer to the ``ArrowSchema`` struct to import from.
+        """
+
+    @abstractmethod
+    def import_batch_and_compare_to_json(self, json_path: os.PathLike,
+                                         num_batch: int,
+                                         c_array_ptr: object):
+        """
+        Import record batch and compare it to one of the batches
+        from a JSON integration file.
+
+        The schema used for importing the record batch is the one from
+        the JSON file.
+
+        An error is raised if importing fails or the batches differ.
+
+        Parameters
+        ----------
+        json_path : Path
+            The path to the JSON file
+        num_batch : int
+            Number of the record batch in the JSON file
+        c_array_ptr : cffi pointer value
+            Pointer to the ``ArrowArray`` struct to import from.
+        """
+
+    @property
+    @abstractmethod
+    def supports_releasing_memory(self) -> bool:
+        """
+        Whether the implementation is able to release memory deterministically.
+
+        Here, "release memory" means calling the `release` callback of
+        a C Data Interface export (which should then trigger a deallocation
+        mechanism on the exporter).
+
+        If false, then `gc_until` is allowed to raise NotImplementedError.
+        """
+
+    def gc_until(self, predicate: _Predicate):
+        """
+        Try to release memory until the predicate becomes true, or fail.
+
+        Depending on the CDataImporter implementation, this may for example
+        try once, or run a garbage collector a given number of times, or
+        any other implementation-specific strategy for releasing memory.
+
+        The running time should be kept reasonable and compatible with
+        execution of multiple C Data integration tests.
+
+        This should not raise if `supports_releasing_memory` is true.
+
+        Returns
+        -------
+        success : bool
+            The final value of the predicate.
+        """
+        raise NotImplementedError
+
+
+class Tester:
     """
     The interface to declare a tester to run integration tests against.
     """
@@ -34,8 +203,12 @@ class Tester(object):
     FLIGHT_SERVER = False
     # whether the language supports receiving Flight
     FLIGHT_CLIENT = False
+    # whether the language supports the C Data Interface as an exporter
+    C_DATA_EXPORTER = False
+    # whether the language supports the C Data Interface as an importer
+    C_DATA_IMPORTER = False
 
-    # the name shown in the logs
+    # the name used for skipping and shown in the logs
     name = "unknown"
 
     def __init__(self, debug=False, **args):
@@ -85,3 +258,9 @@ def flight_server(self, scenario_name=None):
 
     def flight_request(self, port, json_path=None, scenario_name=None):
         raise NotImplementedError
+
+    def make_c_data_exporter(self) -> CDataExporter:
+        raise NotImplementedError
+
+    def make_c_data_importer(self) -> CDataImporter:
+        raise NotImplementedError
diff --git a/dev/archery/archery/integration/tester_cpp.py b/dev/archery/archery/integration/tester_cpp.py
index 52cc565dc00a3..9ddc3c480002a 100644
--- a/dev/archery/archery/integration/tester_cpp.py
+++ b/dev/archery/archery/integration/tester_cpp.py
@@ -16,10 +16,12 @@
 # under the License.
 
 import contextlib
+import functools
 import os
 import subprocess
 
-from .tester import Tester
+from . import cdata
+from .tester import Tester, CDataExporter, CDataImporter
 from .util import run_cmd, log
 from ..utils.source import ARROW_ROOT_DEFAULT
 
@@ -39,12 +41,19 @@
     "localhost",
 ]
 
+_dll_suffix = ".dll" if os.name == "nt" else ".so"
 
-class CPPTester(Tester):
+_DLL_PATH = _EXE_PATH
+_ARROW_DLL = os.path.join(_DLL_PATH, "libarrow" + _dll_suffix)
+
+
+class CppTester(Tester):
     PRODUCER = True
     CONSUMER = True
     FLIGHT_SERVER = True
     FLIGHT_CLIENT = True
+    C_DATA_EXPORTER = True
+    C_DATA_IMPORTER = True
 
     name = 'C++'
 
@@ -133,3 +142,104 @@ def flight_request(self, port, json_path=None, scenario_name=None):
         if self.debug:
             log(' '.join(cmd))
         run_cmd(cmd)
+
+    def make_c_data_exporter(self):
+        return CppCDataExporter(self.debug, self.args)
+
+    def make_c_data_importer(self):
+        return CppCDataImporter(self.debug, self.args)
+
+
+_cpp_c_data_entrypoints = """
+    const char* ArrowCpp_CDataIntegration_ExportSchemaFromJson(
+        const char* json_path, struct ArrowSchema* out);
+    const char* ArrowCpp_CDataIntegration_ImportSchemaAndCompareToJson(
+        const char* json_path, struct ArrowSchema* schema);
+
+    const char* ArrowCpp_CDataIntegration_ExportBatchFromJson(
+        const char* json_path, int num_batch, struct ArrowArray* out);
+    const char* ArrowCpp_CDataIntegration_ImportBatchAndCompareToJson(
+        const char* json_path, int num_batch, struct ArrowArray* batch);
+
+    int64_t ArrowCpp_BytesAllocated();
+    """
+
+
+@functools.lru_cache
+def _load_ffi(ffi, lib_path=_ARROW_DLL):
+    ffi.cdef(_cpp_c_data_entrypoints)
+    dll = ffi.dlopen(lib_path)
+    dll.ArrowCpp_CDataIntegration_ExportSchemaFromJson
+    return dll
+
+
+class _CDataBase:
+
+    def __init__(self, debug, args):
+        self.debug = debug
+        self.args = args
+        self.ffi = cdata.ffi()
+        self.dll = _load_ffi(self.ffi)
+
+    def _check_c_error(self, c_error):
+        """
+        Check a `const char*` error return from an integration entrypoint.
+
+        A null means success, a non-empty string is an error message.
+        The string is statically allocated on the C++ side.
+        """
+        assert self.ffi.typeof(c_error) is self.ffi.typeof("const char*")
+        if c_error != self.ffi.NULL:
+            error = self.ffi.string(c_error).decode('utf8',
+                                                    errors='replace')
+            raise RuntimeError(
+                f"C++ C Data Integration call failed: {error}")
+
+
+class CppCDataExporter(CDataExporter, _CDataBase):
+
+    def export_schema_from_json(self, json_path, c_schema_ptr):
+        c_error = self.dll.ArrowCpp_CDataIntegration_ExportSchemaFromJson(
+            str(json_path).encode(), c_schema_ptr)
+        self._check_c_error(c_error)
+
+    def export_batch_from_json(self, json_path, num_batch, c_array_ptr):
+        c_error = self.dll.ArrowCpp_CDataIntegration_ExportBatchFromJson(
+            str(json_path).encode(), num_batch, c_array_ptr)
+        self._check_c_error(c_error)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def record_allocation_state(self):
+        return self.dll.ArrowCpp_BytesAllocated()
+
+    def compare_allocation_state(self, recorded, gc_until):
+        def pred():
+            # No GC on our side, so just compare allocation state
+            return self.record_allocation_state() == recorded
+
+        return gc_until(pred)
+
+
+class CppCDataImporter(CDataImporter, _CDataBase):
+
+    def import_schema_and_compare_to_json(self, json_path, c_schema_ptr):
+        c_error = self.dll.ArrowCpp_CDataIntegration_ImportSchemaAndCompareToJson(
+            str(json_path).encode(), c_schema_ptr)
+        self._check_c_error(c_error)
+
+    def import_batch_and_compare_to_json(self, json_path, num_batch,
+                                         c_array_ptr):
+        c_error = self.dll.ArrowCpp_CDataIntegration_ImportBatchAndCompareToJson(
+            str(json_path).encode(), num_batch, c_array_ptr)
+        self._check_c_error(c_error)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def gc_until(self, predicate):
+        # No GC on our side, so can evaluate predicate immediately
+        return predicate()
diff --git a/dev/archery/archery/integration/util.py b/dev/archery/archery/integration/util.py
index 80ba30052e4da..afef7d5eb13b9 100644
--- a/dev/archery/archery/integration/util.py
+++ b/dev/archery/archery/integration/util.py
@@ -32,8 +32,10 @@ def guid():
 
 
 # SKIP categories
-SKIP_ARROW = 'arrow'
+SKIP_C_ARRAY = 'c_array'
+SKIP_C_SCHEMA = 'c_schema'
 SKIP_FLIGHT = 'flight'
+SKIP_IPC = 'ipc'
 
 
 class _Printer:
diff --git a/dev/archery/setup.py b/dev/archery/setup.py
index 627e576fb6f59..08e41225f673a 100755
--- a/dev/archery/setup.py
+++ b/dev/archery/setup.py
@@ -28,16 +28,17 @@
 jinja_req = 'jinja2>=2.11'
 
 extras = {
-    'lint': ['numpydoc==1.1.0', 'autopep8', 'flake8==6.1.0', 'cython-lint',
-             'cmake_format==0.6.13'],
     'benchmark': ['pandas'],
-    'docker': ['ruamel.yaml', 'python-dotenv'],
-    'release': ['pygithub', jinja_req, 'jira', 'semver', 'gitpython'],
     'crossbow': ['github3.py', jinja_req, 'pygit2>=1.6.0', 'requests',
                  'ruamel.yaml', 'setuptools_scm'],
     'crossbow-upload': ['github3.py', jinja_req, 'ruamel.yaml',
                         'setuptools_scm'],
-    'numpydoc': ['numpydoc==1.1.0']
+    'docker': ['ruamel.yaml', 'python-dotenv'],
+    'integration': ['cffi'],
+    'lint': ['numpydoc==1.1.0', 'autopep8', 'flake8==6.1.0', 'cython-lint',
+             'cmake_format==0.6.13'],
+    'numpydoc': ['numpydoc==1.1.0'],
+    'release': ['pygithub', jinja_req, 'jira', 'semver', 'gitpython'],
 }
 extras['bot'] = extras['crossbow'] + ['pygithub', 'jira']
 extras['all'] = list(set(functools.reduce(operator.add, extras.values())))

From 64ad8e564ea013101b8565ce200e54e5c85bac8d Mon Sep 17 00:00:00 2001
From: Jonathan Keane <jkeane@gmail.com>
Date: Tue, 19 Sep 2023 11:15:27 -0500
Subject: [PATCH 382/749] GH-33807: [R] Add a message if we detect running
 under emulation (#37777)

Resolves #33807 and #37034

### Rationale for this change

If someone is running R under emulation, arrow segfaults without error. We can detect this when we load so can also warn people that this is not recommended. Though the version of R being run is not directly an arrow issue, arrow fails very quickly in this configuration.

### What changes are included in this PR?

Detect when running under rosetta (on macOS only) and warn when the library is attached

### Are these changes tested?

No, given the paucity of ARM-based mac CI, testing this organically would be difficult. But the logic is straightforward.

### Are there any user-facing changes?

Yes, a warning when someone loads arrow under emulation.
* Closes: #33807

Authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Jonathan Keane <jkeane@gmail.com>
---
 r/R/arrow-package.R | 21 +++++++++++++++++++++
 r/R/install-arrow.R |  4 +---
 r/README.md         |  2 ++
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R
index 8f44f8936bdd3..09183250ba3e0 100644
--- a/r/R/arrow-package.R
+++ b/r/R/arrow-package.R
@@ -183,6 +183,22 @@ configure_tzdb <- function() {
   # Just to be extra safe, let's wrap this in a try();
   # we don't want a failed startup message to prevent the package from loading
   try({
+        # On MacOS only, Check if we are running in under emulation, and warn this will not work
+    if (on_rosetta()) {
+      packageStartupMessage(
+        paste(
+          "Warning:",
+          "  It appears that you are running R and Arrow in emulation (i.e. you're",
+          "  running an Intel version of R on a non-Intel mac). This configuration is",
+          "  not supported by arrow, you should install a native (arm64) build of R",
+          "  and use arrow with that. See https://cran.r-project.org/bin/macosx/",
+          "",
+          sep = "\n"
+        )
+      )
+    }
+
+
     features <- arrow_info()$capabilities
     # That has all of the #ifdef features, plus the compression libs and the
     # string libraries (but not the memory allocators, they're added elsewhere)
@@ -225,6 +241,11 @@ on_macos_10_13_or_lower <- function() {
     package_version(unname(Sys.info()["release"])) < "18.0.0"
 }
 
+on_rosetta <- function() {
+  identical(tolower(Sys.info()[["sysname"]]), "darwin") &&
+    identical(system("sysctl -n sysctl.proc_translated", intern = TRUE), "1")
+}
+
 option_use_threads <- function() {
   !is_false(getOption("arrow.use_threads"))
 }
diff --git a/r/R/install-arrow.R b/r/R/install-arrow.R
index 8380fa2af989c..7017d4f39b876 100644
--- a/r/R/install-arrow.R
+++ b/r/R/install-arrow.R
@@ -61,7 +61,6 @@ install_arrow <- function(nightly = FALSE,
                           verbose = Sys.getenv("ARROW_R_DEV", FALSE),
                           repos = getOption("repos"),
                           ...) {
-  sysname <- tolower(Sys.info()[["sysname"]])
   conda <- isTRUE(grepl("conda", R.Version()$platform))
 
   if (conda) {
@@ -80,8 +79,7 @@ install_arrow <- function(nightly = FALSE,
     # On the M1, we can't use the usual autobrew, which pulls Intel dependencies
     apple_m1 <- grepl("arm-apple|aarch64.*darwin", R.Version()$platform)
     # On Rosetta, we have to build without JEMALLOC, so we also can't autobrew
-    rosetta <- identical(sysname, "darwin") && identical(system("sysctl -n sysctl.proc_translated", intern = TRUE), "1")
-    if (rosetta) {
+    if (on_rosetta()) {
       Sys.setenv(ARROW_JEMALLOC = "OFF")
     }
     if (apple_m1 || rosetta) {
diff --git a/r/README.md b/r/README.md
index d343d6979c0a7..3c1e3570ffdd4 100644
--- a/r/README.md
+++ b/r/README.md
@@ -73,6 +73,8 @@ additional steps should be required.
 
 There are some special cases to note:
 
+- On macOS, the R you use with Arrow should match the architecture of the machine you are using. If you're using an ARM (aka M1, M2, etc.) processor use R compiled for arm64. If you're using an Intel based mac, use R compiled for x86. Using R and Arrow compiled for Intel based macs on an ARM based mac will result in segfaults and crashes. 
+
 - On Linux the installation process can sometimes be more involved because 
 CRAN does not host binaries for Linux. For more information please see the [installation guide](https://arrow.apache.org/docs/r/articles/install.html).
 

From 76c4a6e317436d616ddcd62ca21245bebef6091d Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 20 Sep 2023 00:29:10 +0800
Subject: [PATCH 383/749] GH-37487: [C++][Parquet] Dataset: Implement sync
 `ParquetFileFormat::GetReader` (#37514)

### Rationale for this change

As https://github.com/apache/arrow/issues/37487 says. When thread cnt == 1, the thread might blocking in `ParquetFileFormat::GetReaderAsync`, that's because:

1. `ParquetFileFormat::CountRows` would call `EnsureCompleteMetadata` in `io_executor`
2. `EnsureCompleteMetadata` call `ParquetFileFormat::GetReader`, which dispatch real request to async mode
3. `async` is executed in `io_executor`.

1/3 in same fix-sized executor, causing deadlock.

### What changes are included in this PR?

Implement sync `ParquetFileFormat::GetReader`.

### Are these changes tested?

Currently not

### Are there any user-facing changes?

Bugfix

* Closes: #37487

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/dataset/file_parquet.cc      | 61 +++++++++++++++++-----
 cpp/src/arrow/dataset/file_parquet_test.cc | 25 +++++++++
 2 files changed, 74 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index c30441d911e4e..9d0e8a6515878 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -88,6 +88,22 @@ parquet::ArrowReaderProperties MakeArrowReaderProperties(
   return properties;
 }
 
+parquet::ArrowReaderProperties MakeArrowReaderProperties(
+    const ParquetFileFormat& format, const parquet::FileMetaData& metadata,
+    const ScanOptions& options, const ParquetFragmentScanOptions& parquet_scan_options) {
+  auto arrow_properties = MakeArrowReaderProperties(format, metadata);
+  arrow_properties.set_batch_size(options.batch_size);
+  // Must be set here since the sync ScanTask handles pre-buffering itself
+  arrow_properties.set_pre_buffer(
+      parquet_scan_options.arrow_reader_properties->pre_buffer());
+  arrow_properties.set_cache_options(
+      parquet_scan_options.arrow_reader_properties->cache_options());
+  arrow_properties.set_io_context(
+      parquet_scan_options.arrow_reader_properties->io_context());
+  arrow_properties.set_use_threads(options.use_threads);
+  return arrow_properties;
+}
+
 template <typename M>
 Result<std::shared_ptr<SchemaManifest>> GetSchemaManifest(
     const M& metadata, const parquet::ArrowReaderProperties& properties) {
@@ -410,13 +426,42 @@ Result<std::shared_ptr<Schema>> ParquetFileFormat::Inspect(
 
 Result<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader(
     const FileSource& source, const std::shared_ptr<ScanOptions>& options) const {
-  return GetReaderAsync(source, options, nullptr).result();
+  return GetReader(source, options, /*metadata=*/nullptr);
 }
 
 Result<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader(
     const FileSource& source, const std::shared_ptr<ScanOptions>& options,
     const std::shared_ptr<parquet::FileMetaData>& metadata) const {
-  return GetReaderAsync(source, options, metadata).result();
+  ARROW_ASSIGN_OR_RAISE(
+      auto parquet_scan_options,
+      GetFragmentScanOptions<ParquetFragmentScanOptions>(kParquetTypeName, options.get(),
+                                                         default_fragment_scan_options));
+  auto properties =
+      MakeReaderProperties(*this, parquet_scan_options.get(), options->pool);
+  ARROW_ASSIGN_OR_RAISE(auto input, source.Open());
+  // `parquet::ParquetFileReader::Open` will not wrap the exception as status,
+  // so using `open_parquet_file` to wrap it.
+  auto open_parquet_file = [&]() -> Result<std::unique_ptr<parquet::ParquetFileReader>> {
+    BEGIN_PARQUET_CATCH_EXCEPTIONS
+    auto reader = parquet::ParquetFileReader::Open(std::move(input),
+                                                   std::move(properties), metadata);
+    return reader;
+    END_PARQUET_CATCH_EXCEPTIONS
+  };
+
+  auto reader_opt = open_parquet_file();
+  if (!reader_opt.ok()) {
+    return WrapSourceError(reader_opt.status(), source.path());
+  }
+  auto reader = std::move(reader_opt).ValueOrDie();
+
+  std::shared_ptr<parquet::FileMetaData> reader_metadata = reader->metadata();
+  auto arrow_properties =
+      MakeArrowReaderProperties(*this, *reader_metadata, *options, *parquet_scan_options);
+  std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
+  RETURN_NOT_OK(parquet::arrow::FileReader::Make(
+      options->pool, std::move(reader), std::move(arrow_properties), &arrow_reader));
+  return arrow_reader;
 }
 
 Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReaderAsync(
@@ -445,16 +490,8 @@ Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
         ARROW_ASSIGN_OR_RAISE(std::unique_ptr<parquet::ParquetFileReader> reader,
                               reader_fut.MoveResult());
         std::shared_ptr<parquet::FileMetaData> metadata = reader->metadata();
-        auto arrow_properties = MakeArrowReaderProperties(*self, *metadata);
-        arrow_properties.set_batch_size(options->batch_size);
-        // Must be set here since the sync ScanTask handles pre-buffering itself
-        arrow_properties.set_pre_buffer(
-            parquet_scan_options->arrow_reader_properties->pre_buffer());
-        arrow_properties.set_cache_options(
-            parquet_scan_options->arrow_reader_properties->cache_options());
-        arrow_properties.set_io_context(
-            parquet_scan_options->arrow_reader_properties->io_context());
-        arrow_properties.set_use_threads(options->use_threads);
+        auto arrow_properties =
+            MakeArrowReaderProperties(*this, *metadata, *options, *parquet_scan_options);
         std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
         RETURN_NOT_OK(parquet::arrow::FileReader::Make(options->pool, std::move(reader),
                                                        std::move(arrow_properties),
diff --git a/cpp/src/arrow/dataset/file_parquet_test.cc b/cpp/src/arrow/dataset/file_parquet_test.cc
index 42f923f0e6a27..8527c3af64c83 100644
--- a/cpp/src/arrow/dataset/file_parquet_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_test.cc
@@ -18,12 +18,14 @@
 #include "arrow/dataset/file_parquet.h"
 
 #include <memory>
+#include <thread>
 #include <utility>
 #include <vector>
 
 #include "arrow/compute/api_scalar.h"
 #include "arrow/dataset/dataset_internal.h"
 #include "arrow/dataset/test_util_internal.h"
+#include "arrow/io/interfaces.h"
 #include "arrow/io/memory.h"
 #include "arrow/io/test_common.h"
 #include "arrow/io/util_internal.h"
@@ -367,6 +369,29 @@ TEST_F(TestParquetFileFormat, MultithreadedScan) {
   ASSERT_EQ(batches.size(), kNumRowGroups);
 }
 
+TEST_F(TestParquetFileFormat, SingleThreadExecutor) {
+  // Reset capacity for io executor
+  struct PoolResetGuard {
+    int original_capacity = io::GetIOThreadPoolCapacity();
+    ~PoolResetGuard() { DCHECK_OK(io::SetIOThreadPoolCapacity(original_capacity)); }
+  } guard;
+  ASSERT_OK(io::SetIOThreadPoolCapacity(1));
+
+  auto reader = GetRecordBatchReader(schema({field("utf8", utf8())}));
+
+  ASSERT_OK_AND_ASSIGN(auto buffer, ParquetFormatHelper::Write(reader.get()));
+  auto buffer_reader = std::make_shared<::arrow::io::BufferReader>(buffer);
+  auto source = std::make_shared<FileSource>(std::move(buffer_reader), buffer->size());
+  auto options = std::make_shared<ScanOptions>();
+
+  {
+    auto fragment = MakeFragment(*source);
+    auto count_rows = fragment->CountRows(literal(true), options);
+    ASSERT_OK_AND_ASSIGN(auto result, count_rows.MoveResult());
+    ASSERT_EQ(expected_rows(), result);
+  }
+}
+
 class TestParquetFileSystemDataset : public WriteFileSystemDatasetMixin,
                                      public testing::Test {
  public:

From 0e6a68322c525aea84d8b7b127a8716bf484b227 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 20 Sep 2023 00:51:41 +0800
Subject: [PATCH 384/749] GH-37670: [C++] IO FileInterface extend from
 enable_shared_from_this (#37713)

### Rationale for this change

S3 `FlushAsync` might has lifetime problem, this patch fixes that.

### What changes are included in this PR?

1. Move `enable_shared_from_this` to `FileInterface`
2. Update S3 `FlushAsync`
3. Implement sync Flush to avoid call `share_from_this` in dtor.

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #37670

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: mwish <1506118561@qq.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/filesystem/s3fs.cc      | 85 +++++++++++++++------------
 cpp/src/arrow/filesystem/s3fs_test.cc | 25 ++++++++
 cpp/src/arrow/io/interfaces.cc        |  5 +-
 cpp/src/arrow/io/interfaces.h         |  6 +-
 4 files changed, 79 insertions(+), 42 deletions(-)

diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index 29f8882225ae3..08fbcde6fd9de 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -1454,14 +1454,7 @@ class ObjectOutputStream final : public io::OutputStream {
 
   // OutputStream interface
 
-  Status Close() override {
-    auto fut = CloseAsync();
-    return fut.status();
-  }
-
-  Future<> CloseAsync() override {
-    if (closed_) return Status::OK();
-
+  Status EnsureReadyToFlushFromClose() {
     if (current_part_) {
       // Upload last part
       RETURN_NOT_OK(CommitCurrentPart());
@@ -1472,36 +1465,56 @@ class ObjectOutputStream final : public io::OutputStream {
       RETURN_NOT_OK(UploadPart("", 0));
     }
 
-    // Wait for in-progress uploads to finish (if async writes are enabled)
-    return FlushAsync().Then([this]() {
-      ARROW_ASSIGN_OR_RAISE(auto client_lock, holder_->Lock());
+    return Status::OK();
+  }
 
-      // At this point, all part uploads have finished successfully
-      DCHECK_GT(part_number_, 1);
-      DCHECK_EQ(upload_state_->completed_parts.size(),
-                static_cast<size_t>(part_number_ - 1));
-
-      S3Model::CompletedMultipartUpload completed_upload;
-      completed_upload.SetParts(upload_state_->completed_parts);
-      S3Model::CompleteMultipartUploadRequest req;
-      req.SetBucket(ToAwsString(path_.bucket));
-      req.SetKey(ToAwsString(path_.key));
-      req.SetUploadId(upload_id_);
-      req.SetMultipartUpload(std::move(completed_upload));
-
-      auto outcome =
-          client_lock.Move()->CompleteMultipartUploadWithErrorFixup(std::move(req));
-      if (!outcome.IsSuccess()) {
-        return ErrorToStatus(
-            std::forward_as_tuple("When completing multiple part upload for key '",
-                                  path_.key, "' in bucket '", path_.bucket, "': "),
-            "CompleteMultipartUpload", outcome.GetError());
-      }
+  Status FinishPartUploadAfterFlush() {
+    ARROW_ASSIGN_OR_RAISE(auto client_lock, holder_->Lock());
 
-      holder_ = nullptr;
-      closed_ = true;
-      return Status::OK();
-    });
+    // At this point, all part uploads have finished successfully
+    DCHECK_GT(part_number_, 1);
+    DCHECK_EQ(upload_state_->completed_parts.size(),
+              static_cast<size_t>(part_number_ - 1));
+
+    S3Model::CompletedMultipartUpload completed_upload;
+    completed_upload.SetParts(upload_state_->completed_parts);
+    S3Model::CompleteMultipartUploadRequest req;
+    req.SetBucket(ToAwsString(path_.bucket));
+    req.SetKey(ToAwsString(path_.key));
+    req.SetUploadId(upload_id_);
+    req.SetMultipartUpload(std::move(completed_upload));
+
+    auto outcome =
+        client_lock.Move()->CompleteMultipartUploadWithErrorFixup(std::move(req));
+    if (!outcome.IsSuccess()) {
+      return ErrorToStatus(
+          std::forward_as_tuple("When completing multiple part upload for key '",
+                                path_.key, "' in bucket '", path_.bucket, "': "),
+          "CompleteMultipartUpload", outcome.GetError());
+    }
+
+    holder_ = nullptr;
+    closed_ = true;
+    return Status::OK();
+  }
+
+  Status Close() override {
+    if (closed_) return Status::OK();
+
+    RETURN_NOT_OK(EnsureReadyToFlushFromClose());
+
+    RETURN_NOT_OK(Flush());
+    return FinishPartUploadAfterFlush();
+  }
+
+  Future<> CloseAsync() override {
+    if (closed_) return Status::OK();
+
+    RETURN_NOT_OK(EnsureReadyToFlushFromClose());
+
+    auto self = std::dynamic_pointer_cast<ObjectOutputStream>(shared_from_this());
+    // Wait for in-progress uploads to finish (if async writes are enabled)
+    return FlushAsync().Then([self]() { return self->FinishPartUploadAfterFlush(); });
   }
 
   bool closed() const override { return closed_; }
diff --git a/cpp/src/arrow/filesystem/s3fs_test.cc b/cpp/src/arrow/filesystem/s3fs_test.cc
index e9f14fde72316..f88ee7eef9332 100644
--- a/cpp/src/arrow/filesystem/s3fs_test.cc
+++ b/cpp/src/arrow/filesystem/s3fs_test.cc
@@ -590,6 +590,21 @@ class TestS3FS : public S3TestMixin {
     AssertObjectContents(client_.get(), "bucket", "somefile", "new data");
   }
 
+  void TestOpenOutputStreamCloseAsyncDestructor() {
+    std::shared_ptr<io::OutputStream> stream;
+    ASSERT_OK_AND_ASSIGN(stream, fs_->OpenOutputStream("bucket/somefile"));
+    ASSERT_OK(stream->Write("new data"));
+    // Destructor implicitly closes stream and completes the multipart upload.
+    // GH-37670: Testing it doesn't matter whether flush is triggered asynchronously
+    // after CloseAsync or synchronously after stream.reset() since we're just
+    // checking that `closeAsyncFut` keeps the stream alive until completion
+    // rather than segfaulting on a dangling stream
+    auto closeAsyncFut = stream->CloseAsync();
+    stream.reset();
+    ASSERT_OK(closeAsyncFut.MoveResult());
+    AssertObjectContents(client_.get(), "bucket", "somefile", "new data");
+  }
+
  protected:
   S3Options options_;
   std::shared_ptr<S3FileSystem> fs_;
@@ -1177,6 +1192,16 @@ TEST_F(TestS3FS, OpenOutputStreamDestructorSyncWrite) {
   TestOpenOutputStreamDestructor();
 }
 
+TEST_F(TestS3FS, OpenOutputStreamAsyncDestructorBackgroundWrites) {
+  TestOpenOutputStreamCloseAsyncDestructor();
+}
+
+TEST_F(TestS3FS, OpenOutputStreamAsyncDestructorSyncWrite) {
+  options_.background_writes = false;
+  MakeFileSystem();
+  TestOpenOutputStreamCloseAsyncDestructor();
+}
+
 TEST_F(TestS3FS, OpenOutputStreamMetadata) {
   std::shared_ptr<io::OutputStream> stream;
 
diff --git a/cpp/src/arrow/io/interfaces.cc b/cpp/src/arrow/io/interfaces.cc
index e7819e139f67a..d3229fd067cbe 100644
--- a/cpp/src/arrow/io/interfaces.cc
+++ b/cpp/src/arrow/io/interfaces.cc
@@ -123,7 +123,8 @@ Result<std::shared_ptr<const KeyValueMetadata>> InputStream::ReadMetadata() {
 // executor
 Future<std::shared_ptr<const KeyValueMetadata>> InputStream::ReadMetadataAsync(
     const IOContext& ctx) {
-  auto self = shared_from_this();
+  std::shared_ptr<InputStream> self =
+      std::dynamic_pointer_cast<InputStream>(shared_from_this());
   return DeferNotOk(internal::SubmitIO(ctx, [self] { return self->ReadMetadata(); }));
 }
 
@@ -165,7 +166,7 @@ Result<std::shared_ptr<Buffer>> RandomAccessFile::ReadAt(int64_t position,
 Future<std::shared_ptr<Buffer>> RandomAccessFile::ReadAsync(const IOContext& ctx,
                                                             int64_t position,
                                                             int64_t nbytes) {
-  auto self = checked_pointer_cast<RandomAccessFile>(shared_from_this());
+  auto self = std::dynamic_pointer_cast<RandomAccessFile>(shared_from_this());
   return DeferNotOk(internal::SubmitIO(
       ctx, [self, position, nbytes] { return self->ReadAt(position, nbytes); }));
 }
diff --git a/cpp/src/arrow/io/interfaces.h b/cpp/src/arrow/io/interfaces.h
index dcbe4feb261fb..d2a11b7b6d7ce 100644
--- a/cpp/src/arrow/io/interfaces.h
+++ b/cpp/src/arrow/io/interfaces.h
@@ -96,7 +96,7 @@ struct ARROW_EXPORT IOContext {
   StopToken stop_token_;
 };
 
-class ARROW_EXPORT FileInterface {
+class ARROW_EXPORT FileInterface : public std::enable_shared_from_this<FileInterface> {
  public:
   virtual ~FileInterface() = 0;
 
@@ -205,9 +205,7 @@ class ARROW_EXPORT OutputStream : virtual public FileInterface, public Writable
   OutputStream() = default;
 };
 
-class ARROW_EXPORT InputStream : virtual public FileInterface,
-                                 virtual public Readable,
-                                 public std::enable_shared_from_this<InputStream> {
+class ARROW_EXPORT InputStream : virtual public FileInterface, virtual public Readable {
  public:
   /// \brief Advance or skip stream indicated number of bytes
   /// \param[in] nbytes the number to move forward

From fa4310635c784f03fe825ecc818efa3eca361ec0 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 19 Sep 2023 11:10:37 -0700
Subject: [PATCH 385/749] GH-37705: [Java] Extra input methods for binary
 writers (#37791)

### Rationale for this change
ByteBuffer and byte[] are commonly used to hold binary data. The current writers require working
with ArrowBuf objects which need to be populated by copying from these types, then copying
into the vector.

### What changes are included in this PR?
Add methods to VarBinary and LargeVarBinary writers to take in common binary parameters - byte[] and ByteBuffer.
The writer now sets these objects on the Vectors directly.

### Are these changes tested?
Yes.

* Closes: #37705

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../templates/AbstractFieldWriter.java        |  18 +++
 .../codegen/templates/ComplexWriters.java     |  33 +++++
 .../complex/writer/TestSimpleWriter.java      | 138 ++++++++++++++++++
 3 files changed, 189 insertions(+)
 create mode 100644 java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java

diff --git a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
index 1f80f25266b57..5e6580b6131c1 100644
--- a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
+++ b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
@@ -124,6 +124,24 @@ public void write(${name}Holder holder) {
   }
   </#if>
 
+  <#if minor.class?ends_with("VarBinary")>
+  public void writeTo${minor.class}(byte[] value) {
+    fail("${name}");
+  }
+
+  public void writeTo${minor.class}(byte[] value, int offset, int length) {
+    fail("${name}");
+  }
+
+  public void writeTo${minor.class}(ByteBuffer value) {
+    fail("${name}");
+  }
+
+  public void writeTo${minor.class}(ByteBuffer value, int offset, int length) {
+    fail("${name}");
+  }
+  </#if>
+
   </#list></#list>
 
   public void writeNull() {
diff --git a/java/vector/src/main/codegen/templates/ComplexWriters.java b/java/vector/src/main/codegen/templates/ComplexWriters.java
index 0b1e321afb70e..4ae4c4f75f208 100644
--- a/java/vector/src/main/codegen/templates/ComplexWriters.java
+++ b/java/vector/src/main/codegen/templates/ComplexWriters.java
@@ -180,6 +180,28 @@ public void writeNull() {
     vector.setValueCount(idx()+1);
   }
   </#if>
+
+  <#if minor.class?ends_with("VarBinary")>
+  public void writeTo${minor.class}(byte[] value) {
+    vector.setSafe(idx(), value);
+    vector.setValueCount(idx() + 1);
+  }
+
+  public void writeTo${minor.class}(byte[] value, int offset, int length) {
+    vector.setSafe(idx(), value, offset, length);
+    vector.setValueCount(idx() + 1);
+  }
+
+  public void writeTo${minor.class}(ByteBuffer value) {
+    vector.setSafe(idx(), value, 0, value.remaining());
+    vector.setValueCount(idx() + 1);
+  }
+
+  public void writeTo${minor.class}(ByteBuffer value, int offset, int length) {
+    vector.setSafe(idx(), value, offset, length);
+    vector.setValueCount(idx() + 1);
+  }
+  </#if>
 }
 
 <@pp.changeOutputFile name="/org/apache/arrow/vector/complex/writer/${eName}Writer.java" />
@@ -223,6 +245,17 @@ public interface ${eName}Writer extends BaseWriter {
   @Deprecated
   public void writeBigEndianBytesTo${minor.class}(byte[] value);
 </#if>
+
+<#if minor.class?ends_with("VarBinary")>
+  public void writeTo${minor.class}(byte[] value);
+
+  public void writeTo${minor.class}(byte[] value, int offset, int length);
+
+  public void writeTo${minor.class}(ByteBuffer value);
+
+  public void writeTo${minor.class}(ByteBuffer value, int offset, int length);
+</#if>
+
 }
 
 </#list>
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
new file mode 100644
index 0000000000000..7c06509b23c87
--- /dev/null
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
@@ -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.
+ */
+
+package org.apache.arrow.vector.complex.writer;
+
+import java.nio.ByteBuffer;
+
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.complex.impl.LargeVarBinaryWriterImpl;
+import org.apache.arrow.vector.complex.impl.VarBinaryWriterImpl;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TestSimpleWriter {
+
+  private BufferAllocator allocator;
+
+  @Before
+  public void init() {
+    allocator = new RootAllocator(Integer.MAX_VALUE);
+  }
+
+  @After
+  public void terminate() throws Exception {
+    allocator.close();
+  }
+
+  @Test
+  public void testWriteByteArrayToVarBinary() {
+    try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
+         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      writer.writeToVarBinary(input);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteArrayWithOffsetToVarBinary() {
+    try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
+         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      writer.writeToVarBinary(input, 1, 1);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(new byte[] { 0x02 }, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteBufferToVarBinary() {
+    try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
+         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      ByteBuffer buffer = ByteBuffer.wrap(input);
+      writer.writeToVarBinary(buffer);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteBufferWithOffsetToVarBinary() {
+    try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
+         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      ByteBuffer buffer = ByteBuffer.wrap(input);
+      writer.writeToVarBinary(buffer, 1, 1);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(new byte[] { 0x02 }, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteArrayToLargeVarBinary() {
+    try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
+         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      writer.writeToLargeVarBinary(input);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteArrayWithOffsetToLargeVarBinary() {
+    try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
+         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      writer.writeToLargeVarBinary(input, 1, 1);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(new byte[] { 0x02 }, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteBufferToLargeVarBinary() {
+    try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
+         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      ByteBuffer buffer = ByteBuffer.wrap(input);
+      writer.writeToLargeVarBinary(buffer);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteByteBufferWithOffsetToLargeVarBinary() {
+    try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
+         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+      byte[] input = new byte[] { 0x01, 0x02 };
+      ByteBuffer buffer = ByteBuffer.wrap(input);
+      writer.writeToLargeVarBinary(buffer, 1, 1);
+      byte[] result = vector.get(0);
+      Assert.assertArrayEquals(new byte[] { 0x02 }, result);
+    }
+  }
+}

From cda1e8fa00dbb0215f7e7e07b81dca3554e2f430 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 19 Sep 2023 16:06:29 -0400
Subject: [PATCH 386/749] GH-37532: [CI][Docs][MATLAB] Remove `GoogleTest`
 support from the CMake build system for the MATLAB interface (#37784)

### Rationale for this change

This pull request removes `GoogleTest` support from the CMake build system for the MATLAB interface.

1. `GoogleTest` support adds a lot of additional complexity to the CMake build system for the MATLAB interface, and we currently don't have any standalone C++ tests for the MATLAB interface code.
2. In order to use `GoogleTest` in the MATLAB CI workflows, we are currently relying on building the tests for the Arrow C++ libraries in order to "re-use" the `GoogleTest binaries. This adds additional overhead to the MATLAB CI workflows.
3. If we want to test some internal C++ code for the MATLAB interface in the future, we can instead use a MEX function to call the code from a MATLAB test as suggested by @ kou in https://github.com/apache/arrow/issues/37532#issue-1879320217.
4. There is [precedent for testing internal C++ code without GoogleTest for the Python bindings](https://github.com/apache/arrow/pull/14117).
5. On a somewhat related note - removing `GoogleTest` support will help unblock https://github.com/apache/arrow/pull/37773 as discussed in https://github.com/apache/arrow/pull/37773#issuecomment-1724207859.

### What changes are included in this PR?

1. Removed the `MATLAB_BUILD_TESTS` flag from the CMake build system for the MATLAB interface since there are no longer any C++ tests for the MATLAB interface to build.
2. Updated the `matlab_build.sh` CI workflow script to avoid building the tests for the Arrow C++ libraries and to no longer call `ctest`.
3. Updated the `README.md` for the MATLAB interface to no longer mention building or running C++ tests.
4. Updated the design document for the MATLAB Interface to no longer mention `GoogleTest` since we may end up testing internal C++ code using MEX function calls from MATLAB instead.
5. Removed placeholder C++ test (i.e. `placeholder_test.cc`).

### Are these changes tested?

Yes.

The MATLAB CI workflow is passing on all platforms.

### Are there any user-facing changes?

Yes.

There are no longer any C++ tests for the MATLAB interface. The `MATLAB_BUILD_TESTS` flag has been removed from the CMake build system to reflect this change. If a user supplies a value for `MATLAB_BUILD_TESTS` when building the MATLAB interface, the flag will be ignored by CMake.

### Future Directions

1. Add more developer-focused documentation on how to test C++ code via MEX function calls from MATLAB.

### Notes

1. In the future, we can consider testing internal C++ code using MEX function calls from MATLAB tests as suggested by @ kou in https://github.com/apache/arrow/issues/37532#issue-1879320217. Currently, we don't have any C++ tests that need to be adapted to use this approach.
2. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #37532

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 ci/scripts/matlab_build.sh                    |   2 -
 matlab/CMakeLists.txt                         | 266 +++---------------
 matlab/README.md                              |  19 --
 ...atlab_interface_for_apache_arrow_design.md |  12 +-
 matlab/src/placeholder_test.cc                |  27 --
 5 files changed, 49 insertions(+), 277 deletions(-)
 delete mode 100644 matlab/src/placeholder_test.cc

diff --git a/ci/scripts/matlab_build.sh b/ci/scripts/matlab_build.sh
index 235002da3afc6..d3f86adbb8a2b 100755
--- a/ci/scripts/matlab_build.sh
+++ b/ci/scripts/matlab_build.sh
@@ -29,8 +29,6 @@ cmake \
   -S ${source_dir} \
   -B ${build_dir} \
   -G Ninja \
-  -D MATLAB_BUILD_TESTS=ON \
   -D CMAKE_INSTALL_PREFIX=${install_dir} \
   -D MATLAB_ADD_INSTALL_DIR_TO_SEARCH_PATH=OFF
 cmake --build ${build_dir} --config Release --target install
-ctest --test-dir ${build_dir}
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index d73173b58e78a..c8100a389ace0 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -17,9 +17,9 @@
 
 cmake_minimum_required(VERSION 3.20)
 
-# Build the Arrow C++ libraries.
+# Build the Arrow C++ libraries using ExternalProject_Add.
 function(build_arrow)
-  set(options BUILD_GTEST)
+  set(options)
   set(one_value_args)
   set(multi_value_args)
 
@@ -37,70 +37,50 @@ function(build_arrow)
   set(ARROW_CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}"
                        "-DCMAKE_INSTALL_LIBDIR=lib" "-DARROW_BUILD_STATIC=OFF")
 
-  if(Arrow_FOUND
-     AND NOT GTest_FOUND
-     AND ARG_BUILD_GTEST)
-    # If find_package has already found a valid Arrow installation, then
-    # we don't want to link against the Arrow libraries that will be built
-    # from source.
-    #
-    # However, we still need to create a library target to trigger building
-    # of the arrow_ep target, which will ultimately build the bundled
-    # GoogleTest binaries.
-    add_library(arrow_shared_for_gtest SHARED IMPORTED)
-    set(ARROW_LIBRARY_TARGET arrow_shared_for_gtest)
+  add_library(arrow_shared SHARED IMPORTED)
+  set(ARROW_LIBRARY_TARGET arrow_shared)
+
+  # Set the runtime shared library (.dll, .so, or .dylib)
+  if(WIN32)
+    # The shared library (i.e. .dll) is located in the "bin" directory.
+    set(ARROW_SHARED_LIBRARY_DIR "${ARROW_PREFIX}/bin")
   else()
-    add_library(arrow_shared SHARED IMPORTED)
-    set(ARROW_LIBRARY_TARGET arrow_shared)
-
-    # Set the runtime shared library (.dll, .so, or .dylib)
-    if(WIN32)
-      # The shared library (i.e. .dll) is located in the "bin" directory.
-      set(ARROW_SHARED_LIBRARY_DIR "${ARROW_PREFIX}/bin")
-    else()
-      # The shared library (i.e. .so or .dylib) is located in the "lib" directory.
-      set(ARROW_SHARED_LIBRARY_DIR "${ARROW_PREFIX}/lib")
-    endif()
-
-    set(ARROW_SHARED_LIB_FILENAME
-        "${CMAKE_SHARED_LIBRARY_PREFIX}arrow${CMAKE_SHARED_LIBRARY_SUFFIX}")
-    set(ARROW_SHARED_LIB "${ARROW_SHARED_LIBRARY_DIR}/${ARROW_SHARED_LIB_FILENAME}")
-
-    set_target_properties(arrow_shared PROPERTIES IMPORTED_LOCATION ${ARROW_SHARED_LIB})
-
-    # Set the link-time import library (.lib)
-    if(WIN32)
-      # The import library (i.e. .lib) is located in the "lib" directory.
-      set(ARROW_IMPORT_LIB_FILENAME
-          "${CMAKE_IMPORT_LIBRARY_PREFIX}arrow${CMAKE_IMPORT_LIBRARY_SUFFIX}")
-      set(ARROW_IMPORT_LIB "${ARROW_PREFIX}/lib/${ARROW_IMPORT_LIB_FILENAME}")
-
-      set_target_properties(arrow_shared PROPERTIES IMPORTED_IMPLIB ${ARROW_IMPORT_LIB})
-    endif()
-
-    # Set the include directories
-    set(ARROW_INCLUDE_DIR "${ARROW_PREFIX}/include")
-    file(MAKE_DIRECTORY "${ARROW_INCLUDE_DIR}")
-    set_target_properties(arrow_shared PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
-                                                  ${ARROW_INCLUDE_DIR})
-
-    # Set the build byproducts for the ExternalProject build
-    # The appropriate libraries need to be guaranteed to be available when linking the test
-    # executables.
-    if(WIN32)
-      set(ARROW_BUILD_BYPRODUCTS "${ARROW_IMPORT_LIB}")
-    else()
-      set(ARROW_BUILD_BYPRODUCTS "${ARROW_SHARED_LIB}")
-    endif()
+    # The shared library (i.e. .so or .dylib) is located in the "lib" directory.
+    set(ARROW_SHARED_LIBRARY_DIR "${ARROW_PREFIX}/lib")
   endif()
 
-  # Building the Arrow C++ libraries and bundled GoogleTest binaries requires ExternalProject.
-  include(ExternalProject)
+  set(ARROW_SHARED_LIB_FILENAME
+      "${CMAKE_SHARED_LIBRARY_PREFIX}arrow${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  set(ARROW_SHARED_LIB "${ARROW_SHARED_LIBRARY_DIR}/${ARROW_SHARED_LIB_FILENAME}")
+
+  set_target_properties(arrow_shared PROPERTIES IMPORTED_LOCATION ${ARROW_SHARED_LIB})
+
+  # Set the link-time import library (.lib)
+  if(WIN32)
+    # The import library (i.e. .lib) is located in the "lib" directory.
+    set(ARROW_IMPORT_LIB_FILENAME
+        "${CMAKE_IMPORT_LIBRARY_PREFIX}arrow${CMAKE_IMPORT_LIBRARY_SUFFIX}")
+    set(ARROW_IMPORT_LIB "${ARROW_PREFIX}/lib/${ARROW_IMPORT_LIB_FILENAME}")
 
-  if(ARG_BUILD_GTEST)
-    enable_gtest()
+    set_target_properties(arrow_shared PROPERTIES IMPORTED_IMPLIB ${ARROW_IMPORT_LIB})
   endif()
 
+  # Set the include directories
+  set(ARROW_INCLUDE_DIR "${ARROW_PREFIX}/include")
+  file(MAKE_DIRECTORY "${ARROW_INCLUDE_DIR}")
+  set_target_properties(arrow_shared PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                                                ${ARROW_INCLUDE_DIR})
+
+  # Set the build byproducts for the ExternalProject build
+  if(WIN32)
+    set(ARROW_BUILD_BYPRODUCTS "${ARROW_IMPORT_LIB}")
+  else()
+    set(ARROW_BUILD_BYPRODUCTS "${ARROW_SHARED_LIB}")
+  endif()
+
+  # Building the Arrow C++ libraries requires ExternalProject.
+  include(ExternalProject)
+
   externalproject_add(arrow_ep
                       SOURCE_DIR "${CMAKE_SOURCE_DIR}/../cpp"
                       BINARY_DIR "${ARROW_BINARY_DIR}"
@@ -109,69 +89,8 @@ function(build_arrow)
 
   add_dependencies(${ARROW_LIBRARY_TARGET} arrow_ep)
 
-  if(ARG_BUILD_GTEST)
-    build_gtest()
-  endif()
 endfunction()
 
-macro(enable_gtest)
-  set(ARROW_GTEST_INCLUDE_DIR "${ARROW_PREFIX}/include/arrow-gtest")
-
-  set(ARROW_GTEST_IMPORT_LIB_DIR "${ARROW_PREFIX}/lib")
-  if(WIN32)
-    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_PREFIX}/bin")
-  else()
-    set(ARROW_GTEST_SHARED_LIB_DIR "${ARROW_PREFIX}/lib")
-  endif()
-  set(ARROW_GTEST_IMPORT_LIB
-      "${ARROW_GTEST_IMPORT_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}arrow_gtest${CMAKE_IMPORT_LIBRARY_SUFFIX}"
-  )
-  set(ARROW_GTEST_MAIN_IMPORT_LIB
-      "${ARROW_GTEST_IMPORT_LIB_DIR}/${CMAKE_IMPORT_LIBRARY_PREFIX}arrow_gtest_main${CMAKE_IMPORT_LIBRARY_SUFFIX}"
-  )
-  set(ARROW_GTEST_SHARED_LIB
-      "${ARROW_GTEST_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}arrow_gtest${CMAKE_SHARED_LIBRARY_SUFFIX}"
-  )
-  set(ARROW_GTEST_MAIN_SHARED_LIB
-      "${ARROW_GTEST_SHARED_LIB_DIR}/${CMAKE_SHARED_LIBRARY_PREFIX}arrow_gtest_main${CMAKE_SHARED_LIBRARY_SUFFIX}"
-  )
-
-  list(APPEND ARROW_CMAKE_ARGS "-DARROW_BUILD_TESTS=ON")
-
-  # The appropriate libraries need to be guaranteed to be available when linking the test
-  # executables.
-  if(WIN32)
-    # On Windows, add the gtest link libraries as BUILD_BYPRODUCTS for arrow_ep.
-    list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_IMPORT_LIB}"
-         "${ARROW_GTEST_MAIN_IMPORT_LIB}")
-  else()
-    # On Linux and macOS, add the gtest shared libraries as BUILD_BYPRODUCTS for arrow_ep.
-    list(APPEND ARROW_BUILD_BYPRODUCTS "${ARROW_GTEST_SHARED_LIB}"
-         "${ARROW_GTEST_MAIN_SHARED_LIB}")
-  endif()
-endmacro()
-
-# Build the GoogleTest binaries that are bundled with the Arrow C++ libraries.
-macro(build_gtest)
-  file(MAKE_DIRECTORY "${ARROW_GTEST_INCLUDE_DIR}")
-
-  # Create target GTest::gtest
-  add_library(GTest::gtest SHARED IMPORTED)
-  set_target_properties(GTest::gtest
-                        PROPERTIES IMPORTED_IMPLIB ${ARROW_GTEST_IMPORT_LIB}
-                                   IMPORTED_LOCATION ${ARROW_GTEST_SHARED_LIB}
-                                   INTERFACE_INCLUDE_DIRECTORIES
-                                   ${ARROW_GTEST_INCLUDE_DIR})
-  add_dependencies(GTest::gtest arrow_ep)
-
-  # Create target GTest::gtest_main
-  add_library(GTest::gtest_main SHARED IMPORTED)
-  set_target_properties(GTest::gtest_main
-                        PROPERTIES IMPORTED_IMPLIB ${ARROW_GTEST_MAIN_IMPORT_LIB}
-                                   IMPORTED_LOCATION ${ARROW_GTEST_MAIN_SHARED_LIB})
-  add_dependencies(GTest::gtest_main arrow_ep)
-endmacro()
-
 set(CMAKE_CXX_STANDARD 17)
 
 set(MLARROW_VERSION "14.0.0-SNAPSHOT")
@@ -185,8 +104,6 @@ if(WIN32)
   set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
 endif()
 
-option(MATLAB_BUILD_TESTS "Build the C++ tests for the MATLAB interface" OFF)
-
 # Add tools/cmake directory to the CMAKE_MODULE_PATH.
 list(PREPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/tools/cmake)
 
@@ -208,56 +125,9 @@ else()
   set(MATLAB_BUILD_OUTPUT_DIR "${CMAKE_BINARY_DIR}")
 endif()
 
-# Only build the MATLAB interface C++ tests if MATLAB_BUILD_TESTS=ON.
-if(MATLAB_BUILD_TESTS)
-  # find_package(GTest) supports custom GTEST_ROOT as well as package managers.
-  find_package(GTest)
-
-  if(NOT GTest_FOUND)
-    # find_package(Arrow) supports custom ARROW_HOME as well as package
-    # managers.
-    find_package(Arrow QUIET)
-    # Trigger an automatic build of the Arrow C++ libraries and bundled
-    # GoogleTest binaries. If a valid Arrow installation was not already
-    # found by find_package, then build_arrow will use the Arrow
-    # C++ libraries that are built from source.
-    build_arrow(BUILD_GTEST)
-  else()
-    # On Windows, IMPORTED_LOCATION needs to be set to indicate where the shared
-    # libraries live when GTest is found.
-    if(WIN32)
-      set(GTEST_SHARED_LIB_DIR "${GTEST_ROOT}/bin")
-      set(GTEST_SHARED_LIBRARY_FILENAME
-          "${CMAKE_SHARED_LIBRARY_PREFIX}gtest${CMAKE_SHARED_LIBRARY_SUFFIX}")
-      set(GTEST_SHARED_LIBRARY_LIB
-          "${GTEST_SHARED_LIB_DIR}/${GTEST_SHARED_LIBRARY_FILENAME}")
-
-      set(GTEST_MAIN_SHARED_LIB_DIR "${GTEST_ROOT}/bin")
-      set(GTEST_MAIN_SHARED_LIBRARY_FILENAME
-          "${CMAKE_SHARED_LIBRARY_PREFIX}gtest_main${CMAKE_SHARED_LIBRARY_SUFFIX}")
-      set(GTEST_MAIN_SHARED_LIBRARY_LIB
-          "${GTEST_MAIN_SHARED_LIB_DIR}/${GTEST_MAIN_SHARED_LIBRARY_FILENAME}")
-
-      set_target_properties(GTest::gtest PROPERTIES IMPORTED_LOCATION
-                                                    "${GTEST_SHARED_LIBRARY_LIB}")
-
-      set_target_properties(GTest::gtest_main
-                            PROPERTIES IMPORTED_LOCATION
-                                       "${GTEST_MAIN_SHARED_LIBRARY_LIB}")
-    endif()
-
-    find_package(Arrow QUIET)
-    if(NOT Arrow_FOUND)
-      # Trigger an automatic build of the Arrow C++ libraries.
-      build_arrow()
-    endif()
-  endif()
-
-else()
-  find_package(Arrow QUIET)
-  if(NOT Arrow_FOUND)
-    build_arrow()
-  endif()
+find_package(Arrow QUIET)
+if(NOT Arrow_FOUND)
+  build_arrow()
 endif()
 
 # MATLAB is Required
@@ -311,56 +181,6 @@ else()
   message(STATUS "ARROW_INCLUDE_DIR: ${ARROW_INCLUDE_DIR}")
 endif()
 
-# ##############################################################################
-# C++ Tests
-# ##############################################################################
-# Only build the C++ tests if MATLAB_BUILD_TESTS=ON.
-if(MATLAB_BUILD_TESTS)
-  enable_testing()
-
-  # Define a test executable target. TODO: Remove the placeholder test. This is
-  # just for testing GoogleTest integration.
-  add_executable(placeholder_test ${CMAKE_SOURCE_DIR}/src/placeholder_test.cc)
-
-  # Declare a dependency on the GTest::gtest and GTest::gtest_main IMPORTED
-  # targets.
-  target_link_libraries(placeholder_test GTest::gtest GTest::gtest_main)
-
-  # Ensure using GTest:gtest and GTest::gtest_main on macOS without
-  # specifying DYLD_LIBRARY_DIR.
-  set_target_properties(placeholder_test
-                        PROPERTIES BUILD_RPATH
-                                   "$<TARGET_FILE_DIR:GTest::gtest>;$<TARGET_FILE_DIR:GTest::gtest_main>"
-  )
-
-  # Add test targets for C++ tests.
-  add_test(PlaceholderTestTarget placeholder_test)
-
-  # On Windows:
-  # Add the directory of gtest.dll and gtest_main.dll to the %PATH% for running
-  # all tests.
-  # Add the directory of libmx.dll, libmex.dll, and libarrow.dll to the %PATH% for running
-  # CheckNumArgsTestTarget.
-  # Note: When appending to the path using set_test_properties' ENVIRONMENT property,
-  #       make sure that we escape ';' to prevent CMake from interpreting the input as
-  #       a list of strings.
-  if(WIN32)
-    get_target_property(GTEST_SHARED_LIB GTest::gtest IMPORTED_LOCATION)
-    get_filename_component(GTEST_SHARED_LIB_DIR ${GTEST_SHARED_LIB} DIRECTORY)
-
-    get_target_property(GTEST_MAIN_SHARED_LIB GTest::gtest_main IMPORTED_LOCATION)
-    get_filename_component(GTEST_MAIN_SHARED_LIB_DIR ${GTEST_MAIN_SHARED_LIB} DIRECTORY)
-
-    set_tests_properties(PlaceholderTestTarget
-                         PROPERTIES ENVIRONMENT
-                                    "PATH=${GTEST_SHARED_LIB_DIR}\;${GTEST_MAIN_SHARED_LIB_DIR}\;$ENV{PATH}"
-    )
-
-    get_target_property(ARROW_SHARED_LIB arrow_shared IMPORTED_LOCATION)
-    get_filename_component(ARROW_SHARED_LIB_DIR ${ARROW_SHARED_LIB} DIRECTORY)
-  endif()
-endif()
-
 # ##############################################################################
 # Install
 # ##############################################################################
diff --git a/matlab/README.md b/matlab/README.md
index d6b08fbee1c15..0a2bdf01f465f 100644
--- a/matlab/README.md
+++ b/matlab/README.md
@@ -100,31 +100,12 @@ As part of the install step, the installation directory is added to the [MATLAB
 
 ## Test
 
-There are two kinds of tests for the MATLAB Interface: MATLAB and C++. 
-
-### MATLAB
-
 To run the MATLAB tests, start MATLAB in the `arrow/matlab` directory and call the [`runtests`](https://mathworks.com/help/matlab/ref/runtests.html) command on the `test` directory with `IncludeSubFolders=true`:
 
 ``` matlab
 >> runtests("test", IncludeSubFolders=true);
 ```
 
-### C++
-
-To enable the C++ tests, set the `MATLAB_BUILD_TESTS` flag to `ON` at build time: 
-
-```console
-$ cmake -S . -B build -D MATLAB_BUILD_TESTS=ON
-$ cmake --build build --config Release
-```
-
-After building with the `MATLAB_BUILD_TESTS` flag enabled, the C++ tests can be run using [CTest](https://cmake.org/cmake/help/latest/manual/ctest.1.html):
-
-```console
-$ ctest --test-dir build
-```
-
 ## Usage
 
 Included below are some example code snippets that illustrate how to use the MATLAB interface.
diff --git a/matlab/doc/matlab_interface_for_apache_arrow_design.md b/matlab/doc/matlab_interface_for_apache_arrow_design.md
index 79b43fd02518b..17c7ba254c0ea 100644
--- a/matlab/doc/matlab_interface_for_apache_arrow_design.md
+++ b/matlab/doc/matlab_interface_for_apache_arrow_design.md
@@ -257,14 +257,13 @@ For large tables used in a multi-process "data processing pipeline", a user coul
 
 ## Testing 
 To ensure code quality, we would like to include the following testing infrastructure, at a minimum: 
-1. C++ APIs 
-   - GoogleTest C++ Unit Tests 
-   - Integration with CI workflows 
-2. MATLAB APIs  
-   - [MATLAB Class-Based Unit Tests] 
-   - Integration with CI workflows 
+
+1. [MATLAB Class-Based Unit Tests]
+2. [MATLAB CI Workflows]
 3. [Integration Testing]
 
+**Note**: To test internal C++ code, we can use a [MEX function] to call the C++ code from a MATLAB Class-Based Unit Test.
+
 ## Documentation 
 To ensure usability, discoverability, and accessibility, we would like to include high quality documentation for the MATLAB Interface for Apache Arrow. 
 
@@ -318,3 +317,4 @@ The table below provides a high-level roadmap for the development of specific ca
 [`apache-arrow` package via the `npm` package manager]: https://www.npmjs.com/package/apache-arrow
 [Rust user]: https://github.com/apache/arrow-rs
 [`arrow` crate via the `cargo` package manager]: https://crates.io/crates/arrow
+[MATLAB CI Workflows]: https://github.com/apache/arrow/actions/workflows/matlab.yml
diff --git a/matlab/src/placeholder_test.cc b/matlab/src/placeholder_test.cc
deleted file mode 100644
index eef37e178f623..0000000000000
--- a/matlab/src/placeholder_test.cc
+++ /dev/null
@@ -1,27 +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.
-
-#include <gtest/gtest.h>
-
-namespace arrow {
-namespace matlab {
-namespace test {
-// TODO: Remove this placeholder test.
-TEST(PlaceholderTestSuite, PlaceholderTestCase) { ASSERT_TRUE(true); }
-}  // namespace test
-}  // namespace matlab
-}  // namespace arrow

From 868b9bde7b7eefe487995dca279149a46eb99c34 Mon Sep 17 00:00:00 2001
From: Chris Jordan-Squire <788080+chrisjordansquire@users.noreply.github.com>
Date: Tue, 19 Sep 2023 20:16:45 -0400
Subject: [PATCH 387/749] GH-36111: [C++] Refactor dict_internal.h to use
 Result (#37754)

### Rationale for this change

This change addresses #36111 , updating the method GetDictionaryArrayData in dict_internal.h to return a Result instead of a Status type.

### What changes are included in this PR?

This is a narrow interpretation of the above issue, only changing the return type with minimal updates to the call sites or their return types.

### Are these changes tested?

Yes. The C++ test suite was run on the `ninja-debug` build target using the command `ctest -j16 --output-on-failure`. All tests not requiring parquet data passed. (I was unsure how to setup those tests based on the Arrow development guidelines.)

### Are there any user-facing changes?

No. The only changes should be library-internal.

* Closes: #36111

Authored-by: Chris Jordan-Squire <chris.jordansquire@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/array/array_dict.cc            | 12 ++---
 cpp/src/arrow/array/builder_dict.cc          |  5 ++-
 cpp/src/arrow/array/dict_internal.h          | 47 ++++++++------------
 cpp/src/arrow/compute/kernels/vector_hash.cc |  5 ++-
 4 files changed, 31 insertions(+), 38 deletions(-)

diff --git a/cpp/src/arrow/array/array_dict.cc b/cpp/src/arrow/array/array_dict.cc
index cccc7bb78220d..c9e2f93cde66f 100644
--- a/cpp/src/arrow/array/array_dict.cc
+++ b/cpp/src/arrow/array/array_dict.cc
@@ -282,9 +282,9 @@ class DictionaryUnifierImpl : public DictionaryUnifier {
     *out_type = arrow::dictionary(index_type, value_type_);
 
     // Build unified dictionary array
-    std::shared_ptr<ArrayData> data;
-    RETURN_NOT_OK(DictTraits::GetDictionaryArrayData(pool_, value_type_, memo_table_,
-                                                     0 /* start_offset */, &data));
+    ARROW_ASSIGN_OR_RAISE(
+        auto data, DictTraits::GetDictionaryArrayData(pool_, value_type_, memo_table_,
+                                                      0 /* start_offset */));
     *out_dict = MakeArray(data);
     return Status::OK();
   }
@@ -299,9 +299,9 @@ class DictionaryUnifierImpl : public DictionaryUnifier {
     }
 
     // Build unified dictionary array
-    std::shared_ptr<ArrayData> data;
-    RETURN_NOT_OK(DictTraits::GetDictionaryArrayData(pool_, value_type_, memo_table_,
-                                                     0 /* start_offset */, &data));
+    ARROW_ASSIGN_OR_RAISE(
+        auto data, DictTraits::GetDictionaryArrayData(pool_, value_type_, memo_table_,
+                                                      0 /* start_offset */));
     *out_dict = MakeArray(data);
     return Status::OK();
   }
diff --git a/cpp/src/arrow/array/builder_dict.cc b/cpp/src/arrow/array/builder_dict.cc
index 061fb600412fd..525b0afbc908a 100644
--- a/cpp/src/arrow/array/builder_dict.cc
+++ b/cpp/src/arrow/array/builder_dict.cc
@@ -106,8 +106,9 @@ class DictionaryMemoTable::DictionaryMemoTableImpl {
     enable_if_memoize<T, Status> Visit(const T&) {
       using ConcreteMemoTable = typename DictionaryTraits<T>::MemoTableType;
       auto memo_table = checked_cast<ConcreteMemoTable*>(memo_table_);
-      return DictionaryTraits<T>::GetDictionaryArrayData(pool_, value_type_, *memo_table,
-                                                         start_offset_, out_);
+      ARROW_ASSIGN_OR_RAISE(*out_, DictionaryTraits<T>::GetDictionaryArrayData(
+                                       pool_, value_type_, *memo_table, start_offset_));
+      return Status::OK();
     }
   };
 
diff --git a/cpp/src/arrow/array/dict_internal.h b/cpp/src/arrow/array/dict_internal.h
index 5245c8d0ff313..3c1c8c453d1e7 100644
--- a/cpp/src/arrow/array/dict_internal.h
+++ b/cpp/src/arrow/array/dict_internal.h
@@ -29,6 +29,7 @@
 
 #include "arrow/array.h"
 #include "arrow/buffer.h"
+#include "arrow/result.h"
 #include "arrow/status.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
@@ -63,11 +64,9 @@ struct DictionaryTraits<BooleanType> {
   using T = BooleanType;
   using MemoTableType = typename HashTraits<T>::MemoTableType;
 
-  static Status GetDictionaryArrayData(MemoryPool* pool,
-                                       const std::shared_ptr<DataType>& type,
-                                       const MemoTableType& memo_table,
-                                       int64_t start_offset,
-                                       std::shared_ptr<ArrayData>* out) {
+  static Result<std::shared_ptr<ArrayData>> GetDictionaryArrayData(
+      MemoryPool* pool, const std::shared_ptr<DataType>& type,
+      const MemoTableType& memo_table, int64_t start_offset) {
     if (start_offset < 0) {
       return Status::Invalid("invalid start_offset ", start_offset);
     }
@@ -82,7 +81,9 @@ struct DictionaryTraits<BooleanType> {
                                     : builder.Append(bool_values[i]));
     }
 
-    return builder.FinishInternal(out);
+    std::shared_ptr<ArrayData> out;
+    RETURN_NOT_OK(builder.FinishInternal(&out));
+    return out;
   }
 };  // namespace internal
 
@@ -91,11 +92,9 @@ struct DictionaryTraits<T, enable_if_has_c_type<T>> {
   using c_type = typename T::c_type;
   using MemoTableType = typename HashTraits<T>::MemoTableType;
 
-  static Status GetDictionaryArrayData(MemoryPool* pool,
-                                       const std::shared_ptr<DataType>& type,
-                                       const MemoTableType& memo_table,
-                                       int64_t start_offset,
-                                       std::shared_ptr<ArrayData>* out) {
+  static Result<std::shared_ptr<ArrayData>> GetDictionaryArrayData(
+      MemoryPool* pool, const std::shared_ptr<DataType>& type,
+      const MemoTableType& memo_table, int64_t start_offset) {
     auto dict_length = static_cast<int64_t>(memo_table.size()) - start_offset;
     // This makes a copy, but we assume a dictionary array is usually small
     // compared to the size of the dictionary-using array.
@@ -112,8 +111,7 @@ struct DictionaryTraits<T, enable_if_has_c_type<T>> {
     RETURN_NOT_OK(
         ComputeNullBitmap(pool, memo_table, start_offset, &null_count, &null_bitmap));
 
-    *out = ArrayData::Make(type, dict_length, {null_bitmap, dict_buffer}, null_count);
-    return Status::OK();
+    return ArrayData::Make(type, dict_length, {null_bitmap, dict_buffer}, null_count);
   }
 };
 
@@ -121,11 +119,9 @@ template <typename T>
 struct DictionaryTraits<T, enable_if_base_binary<T>> {
   using MemoTableType = typename HashTraits<T>::MemoTableType;
 
-  static Status GetDictionaryArrayData(MemoryPool* pool,
-                                       const std::shared_ptr<DataType>& type,
-                                       const MemoTableType& memo_table,
-                                       int64_t start_offset,
-                                       std::shared_ptr<ArrayData>* out) {
+  static Result<std::shared_ptr<ArrayData>> GetDictionaryArrayData(
+      MemoryPool* pool, const std::shared_ptr<DataType>& type,
+      const MemoTableType& memo_table, int64_t start_offset) {
     using offset_type = typename T::offset_type;
 
     // Create the offsets buffer
@@ -148,11 +144,9 @@ struct DictionaryTraits<T, enable_if_base_binary<T>> {
     RETURN_NOT_OK(
         ComputeNullBitmap(pool, memo_table, start_offset, &null_count, &null_bitmap));
 
-    *out = ArrayData::Make(type, dict_length,
+    return ArrayData::Make(type, dict_length,
                            {null_bitmap, std::move(dict_offsets), std::move(dict_data)},
                            null_count);
-
-    return Status::OK();
   }
 };
 
@@ -160,11 +154,9 @@ template <typename T>
 struct DictionaryTraits<T, enable_if_fixed_size_binary<T>> {
   using MemoTableType = typename HashTraits<T>::MemoTableType;
 
-  static Status GetDictionaryArrayData(MemoryPool* pool,
-                                       const std::shared_ptr<DataType>& type,
-                                       const MemoTableType& memo_table,
-                                       int64_t start_offset,
-                                       std::shared_ptr<ArrayData>* out) {
+  static Result<std::shared_ptr<ArrayData>> GetDictionaryArrayData(
+      MemoryPool* pool, const std::shared_ptr<DataType>& type,
+      const MemoTableType& memo_table, int64_t start_offset) {
     const T& concrete_type = internal::checked_cast<const T&>(*type);
 
     // Create the data buffer
@@ -182,9 +174,8 @@ struct DictionaryTraits<T, enable_if_fixed_size_binary<T>> {
     RETURN_NOT_OK(
         ComputeNullBitmap(pool, memo_table, start_offset, &null_count, &null_bitmap));
 
-    *out = ArrayData::Make(type, dict_length, {null_bitmap, std::move(dict_data)},
+    return ArrayData::Make(type, dict_length, {null_bitmap, std::move(dict_data)},
                            null_count);
-    return Status::OK();
   }
 };
 
diff --git a/cpp/src/arrow/compute/kernels/vector_hash.cc b/cpp/src/arrow/compute/kernels/vector_hash.cc
index a7bb2d88c291b..d9143b760f32b 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash.cc
@@ -285,8 +285,9 @@ class RegularHashKernel : public HashKernel {
   Status FlushFinal(ExecResult* out) override { return action_.FlushFinal(out); }
 
   Status GetDictionary(std::shared_ptr<ArrayData>* out) override {
-    return DictionaryTraits<Type>::GetDictionaryArrayData(pool_, type_, *memo_table_,
-                                                          0 /* start_offset */, out);
+    ARROW_ASSIGN_OR_RAISE(*out, DictionaryTraits<Type>::GetDictionaryArrayData(
+                                    pool_, type_, *memo_table_, 0 /* start_offset */));
+    return Status::OK();
   }
 
   std::shared_ptr<DataType> value_type() const override { return type_; }

From f52ebbbf76df5d5a16257aae2504d23319723ae5 Mon Sep 17 00:00:00 2001
From: Judah Rand <17158624+judahrand@users.noreply.github.com>
Date: Wed, 20 Sep 2023 09:52:16 +0100
Subject: [PATCH 388/749] GH-37470: [Python][Parquet] Add missing arguments to
 `ParquetFileWriteOptions` (#37469)

### Rationale for this change

I think this may have been missed when this feature was added.

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

* Closes: #37470

Authored-by: Judah Rand <17158624+judahrand@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/_dataset_parquet.pyx  |  8 +++++++
 python/pyarrow/tests/test_dataset.py | 32 ++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx
index 79bd270ce54d2..cf5c44c1c964a 100644
--- a/python/pyarrow/_dataset_parquet.pyx
+++ b/python/pyarrow/_dataset_parquet.pyx
@@ -595,6 +595,10 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
             ),
             column_encoding=self._properties["column_encoding"],
             data_page_version=self._properties["data_page_version"],
+            encryption_properties=self._properties["encryption_properties"],
+            write_batch_size=self._properties["write_batch_size"],
+            dictionary_pagesize_limit=self._properties["dictionary_pagesize_limit"],
+            write_page_index=self._properties["write_page_index"],
         )
 
     def _set_arrow_properties(self):
@@ -631,6 +635,10 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
             coerce_timestamps=None,
             allow_truncated_timestamps=False,
             use_compliant_nested_type=True,
+            encryption_properties=None,
+            write_batch_size=None,
+            dictionary_pagesize_limit=None,
+            write_page_index=False,
         )
         self._set_properties()
         self._set_arrow_properties()
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index b8a0c38089980..e0988f2752033 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -5291,6 +5291,38 @@ def test_write_dataset_preserve_field_metadata(tempdir):
     assert dataset.to_table().schema.equals(schema_metadata, check_metadata=True)
 
 
+def test_write_dataset_write_page_index(tempdir):
+    for write_statistics in [True, False]:
+        for write_page_index in [True, False]:
+            schema = pa.schema([
+                pa.field("x", pa.int64()),
+                pa.field("y", pa.int64())])
+
+            arrays = [[1, 2, 3], [None, 5, None]]
+            table = pa.Table.from_arrays(arrays, schema=schema)
+
+            file_format = ds.ParquetFileFormat()
+            base_dir = tempdir / f"write_page_index_{write_page_index}"
+            ds.write_dataset(
+                table,
+                base_dir,
+                format="parquet",
+                file_options=file_format.make_write_options(
+                    write_statistics=write_statistics,
+                    write_page_index=write_page_index,
+                ),
+                existing_data_behavior='overwrite_or_ignore',
+            )
+            ds1 = ds.dataset(base_dir, format="parquet")
+
+            for file in ds1.files:
+                # Can retrieve sorting columns from metadata
+                metadata = pq.read_metadata(file)
+                cc = metadata.row_group(0).column(0)
+                assert cc.has_offset_index is write_page_index
+                assert cc.has_column_index is write_page_index & write_statistics
+
+
 @pytest.mark.parametrize('dstype', [
     "fs", "mem"
 ])

From 008d2777ea3bdb6cf5f62144ace42ff725bc6255 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 20 Sep 2023 20:08:20 +0800
Subject: [PATCH 389/749] GH-37111: [C++][Parquet] Dataset: Fixing Schema Cast
 (#37793)

### Rationale for this change

Parquet and Arrow has two schema:
1. Parquet has a SchemaElement[1], it's language and implement independent. Parquet Arrow will extract the schema and decude it.
2. Parquet arrow stores schema and possible `field_id` in `key_value_metadata`[2] when `store_schema` enabled. When deserializing, it will first parse `SchemaElement`[1], and if self-defined key_value_metadata exists, it will use `key_value_metadata` to override the [1]

[1] https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift#L356
[2] https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift#L1033

The bug raise from that, when dataset parsing `SchemaManifest`, it doesn't use `key_value_metadata` from `Metadata`, which raises the problem.

For duration, when `store_schema` enabled, it will store `Int64` as physical type, and add a `::arrow::Duration` in `key_value_metadata`. And there is no `equal(Duration, i64)`. So raise the un-impl

### What changes are included in this PR?

Set `key_value_metadata` in implemented.

### Are these changes tested?

Yes

### Are there any user-facing changes?

bugfix

* Closes: #37111

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/dataset/file_parquet.cc      |  7 ++---
 cpp/src/arrow/dataset/file_parquet_test.cc | 31 ++++++++++++++++++++--
 2 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index 9d0e8a6515878..751937e93b937 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -104,11 +104,12 @@ parquet::ArrowReaderProperties MakeArrowReaderProperties(
   return arrow_properties;
 }
 
-template <typename M>
 Result<std::shared_ptr<SchemaManifest>> GetSchemaManifest(
-    const M& metadata, const parquet::ArrowReaderProperties& properties) {
+    const parquet::FileMetaData& metadata,
+    const parquet::ArrowReaderProperties& properties) {
   auto manifest = std::make_shared<SchemaManifest>();
-  const std::shared_ptr<const ::arrow::KeyValueMetadata>& key_value_metadata = nullptr;
+  const std::shared_ptr<const ::arrow::KeyValueMetadata>& key_value_metadata =
+      metadata.key_value_metadata();
   RETURN_NOT_OK(SchemaManifest::Make(metadata.schema(), key_value_metadata, properties,
                                      manifest.get()));
   return manifest;
diff --git a/cpp/src/arrow/dataset/file_parquet_test.cc b/cpp/src/arrow/dataset/file_parquet_test.cc
index 8527c3af64c83..177ca824179a8 100644
--- a/cpp/src/arrow/dataset/file_parquet_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_test.cc
@@ -65,11 +65,15 @@ class ParquetFormatHelper {
  public:
   using FormatType = ParquetFileFormat;
 
-  static Result<std::shared_ptr<Buffer>> Write(RecordBatchReader* reader) {
+  static Result<std::shared_ptr<Buffer>> Write(
+      RecordBatchReader* reader,
+      const std::shared_ptr<ArrowWriterProperties>& arrow_properties =
+          default_arrow_writer_properties()) {
     auto pool = ::arrow::default_memory_pool();
     std::shared_ptr<Buffer> out;
     auto sink = CreateOutputStream(pool);
-    RETURN_NOT_OK(WriteRecordBatchReader(reader, pool, sink));
+    RETURN_NOT_OK(WriteRecordBatchReader(reader, pool, sink, default_writer_properties(),
+                                         arrow_properties));
     return sink->Finish();
   }
   static std::shared_ptr<ParquetFileFormat> MakeFormat() {
@@ -703,6 +707,29 @@ TEST_P(TestParquetFileFormatScan, PredicatePushdownRowGroupFragmentsUsingStringC
   CountRowGroupsInFragment(fragment, {0, 3}, equal(field_ref("x"), literal("a")));
 }
 
+TEST_P(TestParquetFileFormatScan, PredicatePushdownRowGroupFragmentsUsingDurationColumn) {
+  // GH-37111: Parquet arrow stores writer schema and possible field_id in
+  // key_value_metadata when store_schema enabled. When storing `arrow::duration`, it will
+  // be stored as int64. This test ensures that dataset can parse the writer schema
+  // correctly.
+  auto table = TableFromJSON(schema({field("t", duration(TimeUnit::NANO))}),
+                             {
+                                 R"([{"t": 1}])",
+                                 R"([{"t": 2}, {"t": 3}])",
+                             });
+  TableBatchReader table_reader(*table);
+  ASSERT_OK_AND_ASSIGN(
+      auto buffer,
+      ParquetFormatHelper::Write(
+          &table_reader, ArrowWriterProperties::Builder().store_schema()->build()));
+  auto source = std::make_shared<FileSource>(buffer);
+  SetSchema({field("t", duration(TimeUnit::NANO))});
+  ASSERT_OK_AND_ASSIGN(auto fragment, format_->MakeFragment(*source));
+
+  auto expr = equal(field_ref("t"), literal(::arrow::DurationScalar(1, TimeUnit::NANO)));
+  CountRowGroupsInFragment(fragment, {0}, expr);
+}
+
 // Tests projection with nested/indexed FieldRefs.
 // https://github.com/apache/arrow/issues/35579
 TEST_P(TestParquetFileFormatScan, ProjectWithNonNamedFieldRefs) {

From fecb9681a07c7375d9ba30767a91ff0326d6dbfc Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Wed, 20 Sep 2023 16:41:36 +0200
Subject: [PATCH 390/749] GH-37750: [R][C++] Add compatability with IntelLLVM
 (#37781)

### Rationale for this change

The IntelLLVM compiler has a different compiler ID that we currently can't handle and causes the build to fail.

### What changes are included in this PR?

This adds the missing flags/IDs. Mimalloc in the current bundled version is not compatible with IntelLLVM this can be worked around by using a system version, a simple version bump is not sufficient and I don't think it's worth the effort to fix it properly for now.

For the R package build I have disabled mimalloc with IntelLLVM to avoid issues on CRAN.

* Closes: #37750

Authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 cpp/cmake_modules/BuildUtils.cmake    | 2 +-
 cpp/cmake_modules/SetupCxxFlags.cmake | 9 ++++++---
 r/inst/build_arrow_static.sh          | 7 +++++++
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/cpp/cmake_modules/BuildUtils.cmake b/cpp/cmake_modules/BuildUtils.cmake
index 9112b836c9ef4..083ac2fe9a862 100644
--- a/cpp/cmake_modules/BuildUtils.cmake
+++ b/cpp/cmake_modules/BuildUtils.cmake
@@ -99,7 +99,7 @@ function(arrow_create_merged_static_lib output_target)
   if(APPLE)
     set(BUNDLE_COMMAND "libtool" "-no_warning_for_no_symbols" "-static" "-o"
                        ${output_lib_path} ${all_library_paths})
-  elseif(CMAKE_CXX_COMPILER_ID MATCHES "^(Clang|GNU|Intel)$")
+  elseif(CMAKE_CXX_COMPILER_ID MATCHES "^(Clang|GNU|Intel|IntelLLVM)$")
     set(ar_script_path ${CMAKE_BINARY_DIR}/${ARG_NAME}.ar)
 
     file(WRITE ${ar_script_path}.in "CREATE ${output_lib_path}\n")
diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index a5f5659723c28..5531415ac2277 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -329,7 +329,8 @@ if("${BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-sign-conversion")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wunused-result")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wdate-time")
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
+                                                   "IntelLLVM")
     if(WIN32)
       set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
       set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wno-deprecated")
@@ -360,7 +361,8 @@ elseif("${BUILD_WARNING_LEVEL}" STREQUAL "EVERYTHING")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wextra")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-unused-parameter")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wunused-result")
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
+                                                   "IntelLLVM")
     if(WIN32)
       set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
     else()
@@ -383,7 +385,8 @@ else()
          OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
          OR CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall")
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL
+                                                   "IntelLLVM")
     if(WIN32)
       set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /Wall")
     else()
diff --git a/r/inst/build_arrow_static.sh b/r/inst/build_arrow_static.sh
index fe56b9fca9e59..52ac5b7d3245b 100755
--- a/r/inst/build_arrow_static.sh
+++ b/r/inst/build_arrow_static.sh
@@ -55,6 +55,13 @@ else
   ARROW_DEFAULT_PARAM="OFF"
 fi
 
+# Disable mimalloc on IntelLLVM because the bundled version (2.0.x) does not support it
+case "$CXX" in
+  *icpx*)
+    ARROW_MIMALLOC="OFF"
+    ;;
+esac
+
 mkdir -p "${BUILD_DIR}"
 pushd "${BUILD_DIR}"
 ${CMAKE} -DARROW_BOOST_USE_SHARED=OFF \

From 6b1bcae924a21bba7438502acf0f952efd895706 Mon Sep 17 00:00:00 2001
From: Tim Schaub <tschaub@users.noreply.github.com>
Date: Wed, 20 Sep 2023 08:50:01 -0600
Subject: [PATCH 391/749] GH-37779: [Go] Link to the pkg.go.dev site for Go
 reference docs (#37780)

### Rationale for this change

This change updates the Go `README.md` to point to the latest version of the reference documentation.

### What changes are included in this PR?

The Go `README.md` has been updated with a badge that points to [the v14 version](https://pkg.go.dev/github.com/apache/arrow/go/v14) of the docs.

In addition, the `dev/release/utils-prepare.sh` script has been modified so that the link in the Go `README.md` will be updated when the release version changes.

### Are these changes tested?

I tried running `PREPARE_CHANGELOG=0 ./dev/release/01-prepare.sh 14 15 1`, but I don't have `mvn` installed, so was not able to fully validate the changes.

In the `go` directory, I ran the following and confirmed that the changes looked like what I would expect:
```shell
find . "(" -name "*.go*" -o -name "go.mod" -o -name README.md ")" -exec sed -i.bak -E -e \
    "s|(github\\.com/apache/arrow/go)/v[0-9]+|\1/v15|g" {} \;
```

### Are there any user-facing changes?

Documentation changes only.
* Closes: #37779

Lead-authored-by: Tim Schaub <tim@planet.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 dev/release/post-11-bump-versions-test.rb  | 35 +++++++++++++++-------
 dev/release/utils-prepare.sh               |  4 +--
 go/README.md                               |  2 +-
 go/arrow/flight/flightsql/driver/README.md |  6 ++--
 4 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb
index 79d17e84eb7cb..0ef4646236740 100644
--- a/dev/release/post-11-bump-versions-test.rb
+++ b/dev/release/post-11-bump-versions-test.rb
@@ -235,7 +235,7 @@ def test_version_post_tag
       ]
     end
 
-    Dir.glob("go/**/{go.mod,*.go,*.go.*}") do |path|
+    Dir.glob("go/**/{go.mod,*.go,*.go.*,README.md}") do |path|
       if path == "go/arrow/doc.go"
         expected_changes << {
           path: path,
@@ -253,19 +253,34 @@ def test_version_post_tag
       hunks = []
       if release_type == :major
         lines = File.readlines(path, chomp: true)
-        target_lines = lines.grep(/#{Regexp.escape(import_path)}/)
+        target_lines = lines.each_with_index.select do |line, i|
+          line.include?(import_path)
+        end
         next if target_lines.empty?
-        hunk = []
-        target_lines.each do |line|
-          hunk << "-#{line}"
+        n_context_lines = 3 # The default of Git's diff.context
+        target_hunks = [[target_lines.first[0]]]
+        previous_i = target_lines.first[1]
+        target_lines[1..-1].each do |line, i|
+          if i - previous_i < n_context_lines
+            target_hunks.last << line
+          else
+            target_hunks << [line]
+          end
+          previous_i = i
         end
-        target_lines.each do |line|
-          new_line = line.gsub("v#{@snapshot_major_version}") do
-            "v#{@next_major_version}"
+        target_hunks.each do |lines|
+          hunk = []
+          lines.each do |line,|
+            hunk << "-#{line}"
+          end
+          lines.each do |line|
+            new_line = line.gsub("v#{@snapshot_major_version}") do
+              "v#{@next_major_version}"
+            end
+            hunk << "+#{new_line}"
           end
-          hunk << "+#{new_line}"
+          hunks << hunk
         end
-        hunks << hunk
       end
       if path == "go/parquet/writer_properties.go"
         hunks << [
diff --git a/dev/release/utils-prepare.sh b/dev/release/utils-prepare.sh
index ceb51812c11ae..464702b811d8b 100644
--- a/dev/release/utils-prepare.sh
+++ b/dev/release/utils-prepare.sh
@@ -155,8 +155,8 @@ update_versions() {
   popd
 
   pushd "${ARROW_DIR}/go"
-  find . "(" -name "*.go*" -o -name "go.mod" ")" -exec sed -i.bak -E -e \
-    "s|(github\\.com/apache/arrow/go)/v[0-9]+|\1/v${major_version}|" {} \;
+  find . "(" -name "*.go*" -o -name "go.mod" -o -name README.md ")" -exec sed -i.bak -E -e \
+    "s|(github\\.com/apache/arrow/go)/v[0-9]+|\1/v${major_version}|g" {} \;
   # update parquet writer version
   sed -i.bak -E -e \
     "s/\"parquet-go version .+\"/\"parquet-go version ${version}\"/" \
diff --git a/go/README.md b/go/README.md
index 5b3f72760f331..660549cb1b366 100644
--- a/go/README.md
+++ b/go/README.md
@@ -20,7 +20,7 @@
 Apache Arrow for Go
 ===================
 
-[![GoDoc](https://godoc.org/github.com/apache/arrow/go/arrow?status.svg)](https://godoc.org/github.com/apache/arrow/go/arrow)
+[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v14.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v14)
 
 [Apache Arrow][arrow] is a cross-language development platform for in-memory
 data. It specifies a standardized language-independent columnar memory format
diff --git a/go/arrow/flight/flightsql/driver/README.md b/go/arrow/flight/flightsql/driver/README.md
index f81cb9250e1c9..b8850527c19c1 100644
--- a/go/arrow/flight/flightsql/driver/README.md
+++ b/go/arrow/flight/flightsql/driver/README.md
@@ -36,7 +36,7 @@ connection pooling, transactions combined with ease of use (see (#usage)).
 ## Prerequisites
 
 * Go 1.17+
-* Installation via `go get -u github.com/apache/arrow/go/v12/arrow/flight/flightsql`
+* Installation via `go get -u github.com/apache/arrow/go/v14/arrow/flight/flightsql`
 * Backend speaking FlightSQL
 
 ---------------------------------------
@@ -55,7 +55,7 @@ import (
     "database/sql"
     "time"
 
-    _ "github.com/apache/arrow/go/v12/arrow/flight/flightsql"
+    _ "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 // Open the connection to an SQLite backend
@@ -141,7 +141,7 @@ import (
     "log"
     "time"
 
-    "github.com/apache/arrow/go/v12/arrow/flight/flightsql"
+    "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 func main() {

From 00481a2799420f8f00ca7fc137769c1c99186977 Mon Sep 17 00:00:00 2001
From: david dali susanibar arce <davi.sarces@gmail.com>
Date: Wed, 20 Sep 2023 10:47:32 -0500
Subject: [PATCH 392/749] GH-34252: [Java] Support ScannerBuilder::Project or
 ScannerBuilder::Filter as a Substrait proto extended expression (#35570)

### Rationale for this change

To close https://github.com/apache/arrow/issues/34252

### What changes are included in this PR?

This is a proposal to try to solve:
1. Receive a list of Substrait scalar expressions and use them to Project a Dataset
- [x] Draft a Substrait Extended Expression to test (this will be generated by 3rd party project such as Isthmus)
- [x] Use C++ draft PR to Serialize/Deserialize Extended Expression proto messages
- [x] Create JNI Wrapper for ScannerBuilder::Project
- [x] Create JNI API
- [x] Testing coverage
- [x] Documentation

Current problem is: `java.lang.RuntimeException: Inferring column projection from FieldRef FieldRef.FieldPath(0)`. Not able to infer by column position by able to infer by colum name. This problem is solved by https://github.com/apache/arrow/pull/35798

This PR needs/use this PRs/Issues:
- https://github.com/apache/arrow/pull/34834
- https://github.com/apache/arrow/pull/34227
- https://github.com/apache/arrow/issues/35579

2. Receive a Boolean-valued Substrait scalar expression and use it to filter a Dataset
- [x] Working to identify activities

### Are these changes tested?

Initial unit test added.

### Are there any user-facing changes?

No
* Closes: #34252

Lead-authored-by: david dali susanibar arce <davi.sarces@gmail.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Co-authored-by: benibus <bpharks@gmx.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/dataset.rst                  |  29 +-
 docs/source/java/substrait.rst                | 351 +++++++++++++++++-
 java/dataset/src/main/cpp/jni_wrapper.cc      |  57 ++-
 .../apache/arrow/dataset/jni/JniWrapper.java  |   8 +-
 .../arrow/dataset/jni/NativeDataset.java      |   4 +
 .../arrow/dataset/scanner/ScanOptions.java    |  80 +++-
 .../substrait/TestAceroSubstraitConsumer.java | 265 ++++++++++++-
 7 files changed, 770 insertions(+), 24 deletions(-)

diff --git a/docs/source/java/dataset.rst b/docs/source/java/dataset.rst
index 35ffa81058072..a4381e0814638 100644
--- a/docs/source/java/dataset.rst
+++ b/docs/source/java/dataset.rst
@@ -132,12 +132,10 @@ within method ``Scanner::schema()``:
 
 .. _java-dataset-projection:
 
-Projection
-==========
+Projection (Subset of Columns)
+==============================
 
-User can specify projections in ScanOptions. For ``FileSystemDataset``, only
-column projection is allowed for now, which means, only column names
-in the projection list will be accepted. For example:
+User can specify projections in ScanOptions. For example:
 
 .. code-block:: Java
 
@@ -159,6 +157,27 @@ Or use shortcut construtor:
 
 Then all columns will be emitted during scanning.
 
+Projection (Produce New Columns) and Filters
+============================================
+
+User can specify projections (new columns) or filters in ScanOptions using Substrait. For example:
+
+.. code-block:: Java
+
+   ByteBuffer substraitExpressionFilter = getSubstraitExpressionFilter();
+   ByteBuffer substraitExpressionProject = getSubstraitExpressionProjection();
+   // Use Substrait APIs to create an Expression and serialize to a ByteBuffer
+   ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+                .columns(Optional.empty())
+                .substraitExpressionFilter(substraitExpressionFilter)
+                .substraitExpressionProjection(getSubstraitExpressionProjection())
+                .build();
+
+.. seealso::
+
+   :doc:`Executing Projections and Filters Using Extended Expressions <substrait>`
+        Projections and Filters using Substrait.
+
 Read Data from HDFS
 ===================
 
diff --git a/docs/source/java/substrait.rst b/docs/source/java/substrait.rst
index 41effedbf01d9..d8d49a96e88f8 100644
--- a/docs/source/java/substrait.rst
+++ b/docs/source/java/substrait.rst
@@ -22,8 +22,10 @@ Substrait
 The ``arrow-dataset`` module can execute Substrait_ plans via the :doc:`Acero <../cpp/streaming_execution>`
 query engine.
 
-Executing Substrait Plans
-=========================
+.. contents::
+
+Executing Queries Using Substrait Plans
+=======================================
 
 Plans can reference data in files via URIs, or "named tables" that must be provided along with the plan.
 
@@ -102,6 +104,349 @@ Here is an example of a Java program that queries a Parquet file using Java Subs
     0	ALGERIA	0	 haggle. carefully final deposits detect slyly agai
     1	ARGENTINA	1	al foxes promise slyly according to the regular accounts. bold requests alon
 
+Executing Projections and Filters Using Extended Expressions
+============================================================
+
+Dataset also supports projections and filters with Substrait's `Extended Expression`_.
+This requires the substrait-java library.
+
+This Java program:
+
+- Loads a Parquet file containing the "nation" table from the TPC-H benchmark.
+- Projects two new columns:
+    - ``N_NAME || ' - ' || N_COMMENT``
+    - ``N_REGIONKEY + 10``
+- Applies a filter: ``N_NATIONKEY > 18``
+
+.. code-block:: Java
+
+    import io.substrait.extension.ExtensionCollector;
+    import io.substrait.proto.Expression;
+    import io.substrait.proto.ExpressionReference;
+    import io.substrait.proto.ExtendedExpression;
+    import io.substrait.proto.FunctionArgument;
+    import io.substrait.proto.SimpleExtensionDeclaration;
+    import io.substrait.proto.SimpleExtensionURI;
+    import io.substrait.type.NamedStruct;
+    import io.substrait.type.Type;
+    import io.substrait.type.TypeCreator;
+    import io.substrait.type.proto.TypeProtoConverter;
+    import java.nio.ByteBuffer;
+    import java.util.ArrayList;
+    import java.util.Arrays;
+    import java.util.Base64;
+    import java.util.HashMap;
+    import java.util.List;
+    import java.util.Optional;
+    import org.apache.arrow.dataset.file.FileFormat;
+    import org.apache.arrow.dataset.file.FileSystemDatasetFactory;
+    import org.apache.arrow.dataset.jni.NativeMemoryPool;
+    import org.apache.arrow.dataset.scanner.ScanOptions;
+    import org.apache.arrow.dataset.scanner.Scanner;
+    import org.apache.arrow.dataset.source.Dataset;
+    import org.apache.arrow.dataset.source.DatasetFactory;
+    import org.apache.arrow.memory.BufferAllocator;
+    import org.apache.arrow.memory.RootAllocator;
+    import org.apache.arrow.vector.ipc.ArrowReader;
+
+    public class ClientSubstraitExtendedExpressionsCookbook {
+
+      public static void main(String[] args) throws Exception {
+        // project and filter dataset using extended expression definition - 03 Expressions:
+        // Expression 01 - CONCAT: N_NAME || ' - ' || N_COMMENT = col 1 || ' - ' || col 3
+        // Expression 02 - ADD: N_REGIONKEY + 10 = col 1 + 10
+        // Expression 03 - FILTER: N_NATIONKEY > 18 = col 3 > 18
+        projectAndFilterDataset();
+      }
+
+      public static void projectAndFilterDataset() {
+        String uri = "file:///Users/data/tpch_parquet/nation.parquet";
+        ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+            .columns(Optional.empty())
+            .substraitFilter(getSubstraitExpressionFilter())
+            .substraitProjection(getSubstraitExpressionProjection())
+            .build();
+        try (
+            BufferAllocator allocator = new RootAllocator();
+            DatasetFactory datasetFactory = new FileSystemDatasetFactory(
+                allocator, NativeMemoryPool.getDefault(),
+                FileFormat.PARQUET, uri);
+            Dataset dataset = datasetFactory.finish();
+            Scanner scanner = dataset.newScan(options);
+            ArrowReader reader = scanner.scanBatches()
+        ) {
+          while (reader.loadNextBatch()) {
+            System.out.println(
+                reader.getVectorSchemaRoot().contentToTSVString());
+          }
+        } catch (Exception e) {
+          throw new RuntimeException(e);
+        }
+      }
+
+      private static ByteBuffer getSubstraitExpressionProjection() {
+        // Expression: N_REGIONKEY + 10 = col 3 + 10
+        Expression.Builder selectionBuilderProjectOne = Expression.newBuilder().
+            setSelection(
+                Expression.FieldReference.newBuilder().
+                    setDirectReference(
+                        Expression.ReferenceSegment.newBuilder().
+                            setStructField(
+                                Expression.ReferenceSegment.StructField.newBuilder().setField(
+                                    2)
+                            )
+                    )
+            );
+        Expression.Builder literalBuilderProjectOne = Expression.newBuilder()
+            .setLiteral(
+                Expression.Literal.newBuilder().setI32(10)
+            );
+        io.substrait.proto.Type outputProjectOne = TypeCreator.NULLABLE.I32.accept(
+            new TypeProtoConverter(new ExtensionCollector()));
+        Expression.Builder expressionBuilderProjectOne = Expression.
+            newBuilder().
+            setScalarFunction(
+                Expression.
+                    ScalarFunction.
+                    newBuilder().
+                    setFunctionReference(0).
+                    setOutputType(outputProjectOne).
+                    addArguments(
+                        0,
+                        FunctionArgument.newBuilder().setValue(
+                            selectionBuilderProjectOne)
+                    ).
+                    addArguments(
+                        1,
+                        FunctionArgument.newBuilder().setValue(
+                            literalBuilderProjectOne)
+                    )
+            );
+        ExpressionReference.Builder expressionReferenceBuilderProjectOne = ExpressionReference.newBuilder().
+            setExpression(expressionBuilderProjectOne)
+            .addOutputNames("ADD_TEN_TO_COLUMN_N_REGIONKEY");
+
+        // Expression: name || name = N_NAME || "-" || N_COMMENT = col 1 || col 3
+        Expression.Builder selectionBuilderProjectTwo = Expression.newBuilder().
+            setSelection(
+                Expression.FieldReference.newBuilder().
+                    setDirectReference(
+                        Expression.ReferenceSegment.newBuilder().
+                            setStructField(
+                                Expression.ReferenceSegment.StructField.newBuilder().setField(
+                                    1)
+                            )
+                    )
+            );
+        Expression.Builder selectionBuilderProjectTwoConcatLiteral = Expression.newBuilder()
+            .setLiteral(
+                Expression.Literal.newBuilder().setString(" - ")
+            );
+        Expression.Builder selectionBuilderProjectOneToConcat = Expression.newBuilder().
+            setSelection(
+                Expression.FieldReference.newBuilder().
+                    setDirectReference(
+                        Expression.ReferenceSegment.newBuilder().
+                            setStructField(
+                                Expression.ReferenceSegment.StructField.newBuilder().setField(
+                                    3)
+                            )
+                    )
+            );
+        io.substrait.proto.Type outputProjectTwo = TypeCreator.NULLABLE.STRING.accept(
+            new TypeProtoConverter(new ExtensionCollector()));
+        Expression.Builder expressionBuilderProjectTwo = Expression.
+            newBuilder().
+            setScalarFunction(
+                Expression.
+                    ScalarFunction.
+                    newBuilder().
+                    setFunctionReference(1).
+                    setOutputType(outputProjectTwo).
+                    addArguments(
+                        0,
+                        FunctionArgument.newBuilder().setValue(
+                            selectionBuilderProjectTwo)
+                    ).
+                    addArguments(
+                        1,
+                        FunctionArgument.newBuilder().setValue(
+                            selectionBuilderProjectTwoConcatLiteral)
+                    ).
+                    addArguments(
+                        2,
+                        FunctionArgument.newBuilder().setValue(
+                            selectionBuilderProjectOneToConcat)
+                    )
+            );
+        ExpressionReference.Builder expressionReferenceBuilderProjectTwo = ExpressionReference.newBuilder().
+            setExpression(expressionBuilderProjectTwo)
+            .addOutputNames("CONCAT_COLUMNS_N_NAME_AND_N_COMMENT");
+
+        List<String> columnNames = Arrays.asList("N_NATIONKEY", "N_NAME",
+            "N_REGIONKEY", "N_COMMENT");
+        List<Type> dataTypes = Arrays.asList(
+            TypeCreator.NULLABLE.I32,
+            TypeCreator.NULLABLE.STRING,
+            TypeCreator.NULLABLE.I32,
+            TypeCreator.NULLABLE.STRING
+        );
+        NamedStruct of = NamedStruct.of(
+            columnNames,
+            Type.Struct.builder().fields(dataTypes).nullable(false).build()
+        );
+        // Extensions URI
+        HashMap<String, SimpleExtensionURI> extensionUris = new HashMap<>();
+        extensionUris.put(
+            "key-001",
+            SimpleExtensionURI.newBuilder()
+                .setExtensionUriAnchor(1)
+                .setUri("/functions_arithmetic.yaml")
+                .build()
+        );
+        // Extensions
+        ArrayList<SimpleExtensionDeclaration> extensions = new ArrayList<>();
+        SimpleExtensionDeclaration extensionFunctionAdd = SimpleExtensionDeclaration.newBuilder()
+            .setExtensionFunction(
+                SimpleExtensionDeclaration.ExtensionFunction.newBuilder()
+                    .setFunctionAnchor(0)
+                    .setName("add:i32_i32")
+                    .setExtensionUriReference(1))
+            .build();
+        SimpleExtensionDeclaration extensionFunctionGreaterThan = SimpleExtensionDeclaration.newBuilder()
+            .setExtensionFunction(
+                SimpleExtensionDeclaration.ExtensionFunction.newBuilder()
+                    .setFunctionAnchor(1)
+                    .setName("concat:vchar")
+                    .setExtensionUriReference(2))
+            .build();
+        extensions.add(extensionFunctionAdd);
+        extensions.add(extensionFunctionGreaterThan);
+        // Extended Expression
+        ExtendedExpression.Builder extendedExpressionBuilder =
+            ExtendedExpression.newBuilder().
+                addReferredExpr(0,
+                    expressionReferenceBuilderProjectOne).
+                addReferredExpr(1,
+                    expressionReferenceBuilderProjectTwo).
+                setBaseSchema(of.toProto(new TypeProtoConverter(
+                    new ExtensionCollector())));
+        extendedExpressionBuilder.addAllExtensionUris(extensionUris.values());
+        extendedExpressionBuilder.addAllExtensions(extensions);
+        ExtendedExpression extendedExpression = extendedExpressionBuilder.build();
+        byte[] extendedExpressions = Base64.getDecoder().decode(
+            Base64.getEncoder().encodeToString(
+                extendedExpression.toByteArray()));
+        ByteBuffer substraitExpressionProjection = ByteBuffer.allocateDirect(
+            extendedExpressions.length);
+        substraitExpressionProjection.put(extendedExpressions);
+        return substraitExpressionProjection;
+      }
+
+      private static ByteBuffer getSubstraitExpressionFilter() {
+        // Expression: Filter: N_NATIONKEY > 18 = col 1 > 18
+        Expression.Builder selectionBuilderFilterOne = Expression.newBuilder().
+            setSelection(
+                Expression.FieldReference.newBuilder().
+                    setDirectReference(
+                        Expression.ReferenceSegment.newBuilder().
+                            setStructField(
+                                Expression.ReferenceSegment.StructField.newBuilder().setField(
+                                    0)
+                            )
+                    )
+            );
+        Expression.Builder literalBuilderFilterOne = Expression.newBuilder()
+            .setLiteral(
+                Expression.Literal.newBuilder().setI32(18)
+            );
+        io.substrait.proto.Type outputFilterOne = TypeCreator.NULLABLE.BOOLEAN.accept(
+            new TypeProtoConverter(new ExtensionCollector()));
+        Expression.Builder expressionBuilderFilterOne = Expression.
+            newBuilder().
+            setScalarFunction(
+                Expression.
+                    ScalarFunction.
+                    newBuilder().
+                    setFunctionReference(1).
+                    setOutputType(outputFilterOne).
+                    addArguments(
+                        0,
+                        FunctionArgument.newBuilder().setValue(
+                            selectionBuilderFilterOne)
+                    ).
+                    addArguments(
+                        1,
+                        FunctionArgument.newBuilder().setValue(
+                            literalBuilderFilterOne)
+                    )
+            );
+        ExpressionReference.Builder expressionReferenceBuilderFilterOne = ExpressionReference.newBuilder().
+            setExpression(expressionBuilderFilterOne)
+            .addOutputNames("COLUMN_N_NATIONKEY_GREATER_THAN_18");
+
+        List<String> columnNames = Arrays.asList("N_NATIONKEY", "N_NAME",
+            "N_REGIONKEY", "N_COMMENT");
+        List<Type> dataTypes = Arrays.asList(
+            TypeCreator.NULLABLE.I32,
+            TypeCreator.NULLABLE.STRING,
+            TypeCreator.NULLABLE.I32,
+            TypeCreator.NULLABLE.STRING
+        );
+        NamedStruct of = NamedStruct.of(
+            columnNames,
+            Type.Struct.builder().fields(dataTypes).nullable(false).build()
+        );
+        // Extensions URI
+        HashMap<String, SimpleExtensionURI> extensionUris = new HashMap<>();
+        extensionUris.put(
+            "key-001",
+            SimpleExtensionURI.newBuilder()
+                .setExtensionUriAnchor(1)
+                .setUri("/functions_comparison.yaml")
+                .build()
+        );
+        // Extensions
+        ArrayList<SimpleExtensionDeclaration> extensions = new ArrayList<>();
+        SimpleExtensionDeclaration extensionFunctionLowerThan = SimpleExtensionDeclaration.newBuilder()
+            .setExtensionFunction(
+                SimpleExtensionDeclaration.ExtensionFunction.newBuilder()
+                    .setFunctionAnchor(1)
+                    .setName("gt:any_any")
+                    .setExtensionUriReference(1))
+            .build();
+        extensions.add(extensionFunctionLowerThan);
+        // Extended Expression
+        ExtendedExpression.Builder extendedExpressionBuilder =
+            ExtendedExpression.newBuilder().
+                addReferredExpr(0,
+                    expressionReferenceBuilderFilterOne).
+                setBaseSchema(of.toProto(new TypeProtoConverter(
+                    new ExtensionCollector())));
+        extendedExpressionBuilder.addAllExtensionUris(extensionUris.values());
+        extendedExpressionBuilder.addAllExtensions(extensions);
+        ExtendedExpression extendedExpression = extendedExpressionBuilder.build();
+        byte[] extendedExpressions = Base64.getDecoder().decode(
+            Base64.getEncoder().encodeToString(
+                extendedExpression.toByteArray()));
+        ByteBuffer substraitExpressionFilter = ByteBuffer.allocateDirect(
+            extendedExpressions.length);
+        substraitExpressionFilter.put(extendedExpressions);
+        return substraitExpressionFilter;
+      }
+    }
+
+.. code-block:: text
+
+    ADD_TEN_TO_COLUMN_N_REGIONKEY	CONCAT_COLUMNS_N_NAME_AND_N_COMMENT
+    13	ROMANIA - ular asymptotes are about the furious multipliers. express dependencies nag above the ironically ironic account
+    14	SAUDI ARABIA - ts. silent requests haggle. closely express packages sleep across the blithely
+    12	VIETNAM - hely enticingly express accounts. even, final
+    13	RUSSIA -  requests against the platelets use never according to the quickly regular pint
+    13	UNITED KINGDOM - eans boost carefully special requests. accounts are. carefull
+    11	UNITED STATES - y final packages. slow foxes cajole quickly. quickly silent platelets breach ironic accounts. unusual pinto be
+
 .. _`Substrait`: https://substrait.io/
 .. _`Substrait Java`: https://github.com/substrait-io/substrait-java
-.. _`Acero`: https://arrow.apache.org/docs/cpp/streaming_execution.html
\ No newline at end of file
+.. _`Acero`: https://arrow.apache.org/docs/cpp/streaming_execution.html
+.. _`Extended Expression`: https://github.com/substrait-io/substrait/blob/main/site/docs/expressions/extended_expression.md
diff --git a/java/dataset/src/main/cpp/jni_wrapper.cc b/java/dataset/src/main/cpp/jni_wrapper.cc
index 5640bc4349670..49e0f1720909f 100644
--- a/java/dataset/src/main/cpp/jni_wrapper.cc
+++ b/java/dataset/src/main/cpp/jni_wrapper.cc
@@ -29,6 +29,8 @@
 #include "arrow/filesystem/path_util.h"
 #include "arrow/filesystem/s3fs.h"
 #include "arrow/engine/substrait/util.h"
+#include "arrow/engine/substrait/serde.h"
+#include "arrow/engine/substrait/relation.h"
 #include "arrow/ipc/api.h"
 #include "arrow/util/iterator.h"
 #include "jni_util.h"
@@ -200,7 +202,6 @@ arrow::Result<std::shared_ptr<arrow::Schema>> SchemaFromColumnNames(
       return arrow::Status::Invalid("Partition column '", ref.ToString(), "' is not in dataset schema");
     }
   }
-
   return schema(std::move(columns))->WithMetadata(input->metadata());
 }
 }  // namespace
@@ -317,6 +318,14 @@ std::shared_ptr<arrow::Table> GetTableByName(const std::vector<std::string>& nam
   return it->second;
 }
 
+std::shared_ptr<arrow::Buffer> LoadArrowBufferFromByteBuffer(JNIEnv* env, jobject byte_buffer) {
+  const auto *buff = reinterpret_cast<jbyte*>(env->GetDirectBufferAddress(byte_buffer));
+  int length = env->GetDirectBufferCapacity(byte_buffer);
+  std::shared_ptr<arrow::Buffer> buffer = JniGetOrThrow(arrow::AllocateBuffer(length));
+  std::memcpy(buffer->mutable_data(), buff, length);
+  return buffer;
+}
+
 /*
  * Class:     org_apache_arrow_dataset_jni_NativeMemoryPool
  * Method:    getDefaultMemoryPool
@@ -455,11 +464,12 @@ JNIEXPORT void JNICALL Java_org_apache_arrow_dataset_jni_JniWrapper_closeDataset
 /*
  * Class:     org_apache_arrow_dataset_jni_JniWrapper
  * Method:    createScanner
- * Signature: (J[Ljava/lang/String;JJ)J
+ * Signature: (J[Ljava/lang/String;Ljava/nio/ByteBuffer;Ljava/nio/ByteBuffer;JJ)J
  */
 JNIEXPORT jlong JNICALL Java_org_apache_arrow_dataset_jni_JniWrapper_createScanner(
-    JNIEnv* env, jobject, jlong dataset_id, jobjectArray columns, jlong batch_size,
-    jlong memory_pool_id) {
+    JNIEnv* env, jobject, jlong dataset_id, jobjectArray columns,
+    jobject substrait_projection, jobject substrait_filter,
+    jlong batch_size, jlong memory_pool_id) {
   JNI_METHOD_START
   arrow::MemoryPool* pool = reinterpret_cast<arrow::MemoryPool*>(memory_pool_id);
   if (pool == nullptr) {
@@ -474,6 +484,40 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_dataset_jni_JniWrapper_createScann
     std::vector<std::string> column_vector = ToStringVector(env, columns);
     JniAssertOkOrThrow(scanner_builder->Project(column_vector));
   }
+  if (substrait_projection != nullptr) {
+    std::shared_ptr<arrow::Buffer> buffer = LoadArrowBufferFromByteBuffer(env,
+                                                            substrait_projection);
+    std::vector<arrow::compute::Expression> project_exprs;
+    std::vector<std::string> project_names;
+    arrow::engine::BoundExpressions bounded_expression =
+          JniGetOrThrow(arrow::engine::DeserializeExpressions(*buffer));
+    for(arrow::engine::NamedExpression& named_expression :
+                                        bounded_expression.named_expressions) {
+      project_exprs.push_back(std::move(named_expression.expression));
+      project_names.push_back(std::move(named_expression.name));
+    }
+    JniAssertOkOrThrow(scanner_builder->Project(std::move(project_exprs), std::move(project_names)));
+  }
+  if (substrait_filter != nullptr) {
+    std::shared_ptr<arrow::Buffer> buffer = LoadArrowBufferFromByteBuffer(env,
+                                                                substrait_filter);
+    std::optional<arrow::compute::Expression> filter_expr = std::nullopt;
+    arrow::engine::BoundExpressions bounded_expression =
+          JniGetOrThrow(arrow::engine::DeserializeExpressions(*buffer));
+    for(arrow::engine::NamedExpression& named_expression :
+                                        bounded_expression.named_expressions) {
+      filter_expr = named_expression.expression;
+      if (named_expression.expression.type()->id() == arrow::Type::BOOL) {
+        filter_expr = named_expression.expression;
+      } else {
+        JniThrow("There is no filter expression in the expression provided");
+      }
+    }
+    if (filter_expr == std::nullopt) {
+      JniThrow("The filter expression has not been provided");
+    }
+    JniAssertOkOrThrow(scanner_builder->Filter(*filter_expr));
+  }
   JniAssertOkOrThrow(scanner_builder->BatchSize(batch_size));
 
   auto scanner = JniGetOrThrow(scanner_builder->Finish());
@@ -748,10 +792,7 @@ JNIEXPORT void JNICALL
   arrow::engine::ConversionOptions conversion_options;
   conversion_options.named_table_provider = std::move(table_provider);
   // mapping arrow::Buffer
-  auto *buff = reinterpret_cast<jbyte*>(env->GetDirectBufferAddress(plan));
-  int length = env->GetDirectBufferCapacity(plan);
-  std::shared_ptr<arrow::Buffer> buffer = JniGetOrThrow(arrow::AllocateBuffer(length));
-  std::memcpy(buffer->mutable_data(), buff, length);
+  std::shared_ptr<arrow::Buffer> buffer = LoadArrowBufferFromByteBuffer(env, plan);
   // execute plan
   std::shared_ptr<arrow::RecordBatchReader> reader_out =
     JniGetOrThrow(arrow::engine::ExecuteSerializedPlan(*buffer, nullptr, nullptr, conversion_options));
diff --git a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
index 93cc5d7a37040..a7df5be42f13b 100644
--- a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
+++ b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/JniWrapper.java
@@ -17,6 +17,8 @@
 
 package org.apache.arrow.dataset.jni;
 
+import java.nio.ByteBuffer;
+
 /**
  * JNI wrapper for Dataset API's native implementation.
  */
@@ -66,15 +68,19 @@ private JniWrapper() {
 
   /**
    * Create Scanner from a Dataset and get the native pointer of the Dataset.
+   *
    * @param datasetId the native pointer of the arrow::dataset::Dataset instance.
    * @param columns desired column names.
    *                Columns not in this list will not be emitted when performing scan operation. Null equals
    *                to "all columns".
+   * @param substraitProjection substrait extended expression to evaluate for project new columns
+   * @param substraitFilter substrait extended expression to evaluate for apply filter
    * @param batchSize batch size of scanned record batches.
    * @param memoryPool identifier of memory pool used in the native scanner.
    * @return the native pointer of the arrow::dataset::Scanner instance.
    */
-  public native long createScanner(long datasetId, String[] columns, long batchSize, long memoryPool);
+  public native long createScanner(long datasetId, String[] columns, ByteBuffer substraitProjection,
+                                   ByteBuffer substraitFilter, long batchSize, long memoryPool);
 
   /**
    * Get a serialized schema from native instance of a Scanner.
diff --git a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/NativeDataset.java b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/NativeDataset.java
index 30ff1a9302f7a..d9abad9971c4e 100644
--- a/java/dataset/src/main/java/org/apache/arrow/dataset/jni/NativeDataset.java
+++ b/java/dataset/src/main/java/org/apache/arrow/dataset/jni/NativeDataset.java
@@ -40,8 +40,12 @@ public synchronized NativeScanner newScan(ScanOptions options) {
     if (closed) {
       throw new NativeInstanceReleasedException();
     }
+
     long scannerId = JniWrapper.get().createScanner(datasetId, options.getColumns().orElse(null),
+        options.getSubstraitProjection().orElse(null),
+        options.getSubstraitFilter().orElse(null),
         options.getBatchSize(), context.getMemoryPool().getNativeInstanceId());
+
     return new NativeScanner(context, scannerId);
   }
 
diff --git a/java/dataset/src/main/java/org/apache/arrow/dataset/scanner/ScanOptions.java b/java/dataset/src/main/java/org/apache/arrow/dataset/scanner/ScanOptions.java
index f5a1af384b24e..995d05ac3b314 100644
--- a/java/dataset/src/main/java/org/apache/arrow/dataset/scanner/ScanOptions.java
+++ b/java/dataset/src/main/java/org/apache/arrow/dataset/scanner/ScanOptions.java
@@ -17,6 +17,7 @@
 
 package org.apache.arrow.dataset.scanner;
 
+import java.nio.ByteBuffer;
 import java.util.Optional;
 
 import org.apache.arrow.util.Preconditions;
@@ -25,8 +26,10 @@
  * Options used during scanning.
  */
 public class ScanOptions {
-  private final Optional<String[]> columns;
   private final long batchSize;
+  private final Optional<String[]> columns;
+  private final Optional<ByteBuffer> substraitProjection;
+  private final Optional<ByteBuffer> substraitFilter;
 
   /**
    * Constructor.
@@ -56,6 +59,8 @@ public ScanOptions(long batchSize, Optional<String[]> columns) {
     Preconditions.checkNotNull(columns);
     this.batchSize = batchSize;
     this.columns = columns;
+    this.substraitProjection = Optional.empty();
+    this.substraitFilter = Optional.empty();
   }
 
   public ScanOptions(long batchSize) {
@@ -69,4 +74,77 @@ public Optional<String[]> getColumns() {
   public long getBatchSize() {
     return batchSize;
   }
+
+  public Optional<ByteBuffer> getSubstraitProjection() {
+    return substraitProjection;
+  }
+
+  public Optional<ByteBuffer> getSubstraitFilter() {
+    return substraitFilter;
+  }
+
+  /**
+   * Builder for Options used during scanning.
+   */
+  public static class Builder {
+    private final long batchSize;
+    private Optional<String[]> columns;
+    private ByteBuffer substraitProjection;
+    private ByteBuffer substraitFilter;
+
+    /**
+     * Constructor.
+     * @param batchSize Maximum row number of each returned {@link org.apache.arrow.vector.ipc.message.ArrowRecordBatch}
+     */
+    public Builder(long batchSize) {
+      this.batchSize = batchSize;
+    }
+
+    /**
+     * Set the Projected columns. Empty for scanning all columns.
+     *
+     * @param columns Projected columns. Empty for scanning all columns.
+     * @return the ScanOptions configured.
+     */
+    public Builder columns(Optional<String[]> columns) {
+      Preconditions.checkNotNull(columns);
+      this.columns = columns;
+      return this;
+    }
+
+    /**
+     * Set the Substrait extended expression for Projection new columns.
+     *
+     * @param substraitProjection Expressions to evaluate for project new columns.
+     * @return the ScanOptions configured.
+     */
+    public Builder substraitProjection(ByteBuffer substraitProjection) {
+      Preconditions.checkNotNull(substraitProjection);
+      this.substraitProjection = substraitProjection;
+      return this;
+    }
+
+    /**
+     * Set the Substrait extended expression for Filter.
+     *
+     * @param substraitFilter Expressions to evaluate for apply Filter.
+     * @return the ScanOptions configured.
+     */
+    public Builder substraitFilter(ByteBuffer substraitFilter) {
+      Preconditions.checkNotNull(substraitFilter);
+      this.substraitFilter = substraitFilter;
+      return this;
+    }
+
+    public ScanOptions build() {
+      return new ScanOptions(this);
+    }
+  }
+
+  private ScanOptions(Builder builder) {
+    batchSize = builder.batchSize;
+    columns = builder.columns;
+    substraitProjection = Optional.ofNullable(builder.substraitProjection);
+    substraitFilter = Optional.ofNullable(builder.substraitFilter);
+  }
 }
diff --git a/java/dataset/src/test/java/org/apache/arrow/dataset/substrait/TestAceroSubstraitConsumer.java b/java/dataset/src/test/java/org/apache/arrow/dataset/substrait/TestAceroSubstraitConsumer.java
index c23b7e002880a..0fba72892cdc6 100644
--- a/java/dataset/src/test/java/org/apache/arrow/dataset/substrait/TestAceroSubstraitConsumer.java
+++ b/java/dataset/src/test/java/org/apache/arrow/dataset/substrait/TestAceroSubstraitConsumer.java
@@ -18,6 +18,8 @@
 package org.apache.arrow.dataset.substrait;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
@@ -27,6 +29,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 
 import org.apache.arrow.dataset.ParquetWriteSupport;
 import org.apache.arrow.dataset.TestDataset;
@@ -85,7 +88,7 @@ public void testRunQueryLocalFiles() throws Exception {
   }
 
   @Test
-  public void testRunQueryNamedTableNation() throws Exception {
+  public void testRunQueryNamedTable() throws Exception {
     //Query:
     //SELECT id, name FROM Users
     //Isthmus:
@@ -123,7 +126,7 @@ public void testRunQueryNamedTableNation() throws Exception {
   }
 
   @Test(expected = RuntimeException.class)
-  public void testRunQueryNamedTableNationWithException() throws Exception {
+  public void testRunQueryNamedTableWithException() throws Exception {
     //Query:
     //SELECT id, name FROM Users
     //Isthmus:
@@ -160,7 +163,7 @@ public void testRunQueryNamedTableNationWithException() throws Exception {
   }
 
   @Test
-  public void testRunBinaryQueryNamedTableNation() throws Exception {
+  public void testRunBinaryQueryNamedTable() throws Exception {
     //Query:
     //SELECT id, name FROM Users
     //Isthmus:
@@ -187,9 +190,7 @@ public void testRunBinaryQueryNamedTableNation() throws Exception {
       Map<String, ArrowReader> mapTableToArrowReader = new HashMap<>();
       mapTableToArrowReader.put("USERS", reader);
       // get binary plan
-      byte[] plan = Base64.getDecoder().decode(binaryPlan);
-      ByteBuffer substraitPlan = ByteBuffer.allocateDirect(plan.length);
-      substraitPlan.put(plan);
+      ByteBuffer substraitPlan = getByteBuffer(binaryPlan);
       // run query
       try (ArrowReader arrowReader = new AceroSubstraitConsumer(rootAllocator()).runQuery(
           substraitPlan,
@@ -204,4 +205,256 @@ public void testRunBinaryQueryNamedTableNation() throws Exception {
       }
     }
   }
+
+  @Test
+  public void testRunExtendedExpressionsFilter() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("id", new ArrowType.Int(32, true)),
+        Field.nullable("name", new ArrowType.Utf8())
+    ), null);
+    // Substrait Extended Expression: Filter:
+    // Expression 01: WHERE ID < 20
+    String base64EncodedSubstraitFilter = "Ch4IARIaL2Z1bmN0aW9uc19jb21wYXJpc29uLnlhbWwSEhoQCAIQAhoKbHQ6YW55X2F" +
+        "ueRo3ChwaGggCGgQKAhABIggaBhIECgISACIGGgQKAigUGhdmaWx0ZXJfaWRfbG93ZXJfdGhhbl8yMCIaCgJJRAoETkFNRRIOCgQqAhA" +
+        "BCgRiAhABGAI=";
+    ByteBuffer substraitExpressionFilter = getByteBuffer(base64EncodedSubstraitFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitFilter(substraitExpressionFilter)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish();
+        Scanner scanner = dataset.newScan(options);
+        ArrowReader reader = scanner.scanBatches()
+    ) {
+      assertEquals(schema.getFields(), reader.getVectorSchemaRoot().getSchema().getFields());
+      int rowcount = 0;
+      while (reader.loadNextBatch()) {
+        rowcount += reader.getVectorSchemaRoot().getRowCount();
+        assertTrue(reader.getVectorSchemaRoot().getVector("id").toString().equals("[19, 1, 11]"));
+        assertTrue(reader.getVectorSchemaRoot().getVector("name").toString()
+            .equals("[value_19, value_1, value_11]"));
+      }
+      assertEquals(3, rowcount);
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsFilterWithProjectionsInsteadOfFilterException() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("id", new ArrowType.Int(32, true)),
+        Field.nullable("name", new ArrowType.Utf8())
+    ), null);
+    // Substrait Extended Expression: Project New Column:
+    // Expression ADD: id + 2
+    // Expression CONCAT: name + '-' + name
+    String base64EncodedSubstraitFilter = "Ch4IARIaL2Z1bmN0aW9uc19hcml0aG1ldGljLnlhbWwSERoPCAEaC2FkZDppM" +
+        "zJfaTMyEhQaEggCEAEaDGNvbmNhdDp2Y2hhchoxChoaGBoEKgIQASIIGgYSBAoCEgAiBhoECgIoAhoTYWRkX3R3b190b19jb2x1" +
+        "bW5fYRpGCi0aKwgBGgRiAhABIgoaCBIGCgQSAggBIgkaBwoFYgMgLSAiChoIEgYKBBICCAEaFWNvbmNhdF9jb2x1bW5fYV9hbmR" +
+        "fYiIaCgJJRAoETkFNRRIOCgQqAhABCgRiAhABGAI=";
+    ByteBuffer substraitExpressionFilter = getByteBuffer(base64EncodedSubstraitFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitFilter(substraitExpressionFilter)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish()
+    ) {
+      Exception e = assertThrows(RuntimeException.class, () -> dataset.newScan(options));
+      assertTrue(e.getMessage().startsWith("There is no filter expression in the expression provided"));
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsFilterWithEmptyFilterException() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("id", new ArrowType.Int(32, true)),
+        Field.nullable("name", new ArrowType.Utf8())
+    ), null);
+    String base64EncodedSubstraitFilter = "";
+    ByteBuffer substraitExpressionFilter = getByteBuffer(base64EncodedSubstraitFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitFilter(substraitExpressionFilter)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish()
+    ) {
+      Exception e = assertThrows(RuntimeException.class, () -> dataset.newScan(options));
+      assertTrue(e.getMessage().contains("no anonymous struct type was provided to which names could be attached."));
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsProjection() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("add_two_to_column_a", new ArrowType.Int(32, true)),
+        Field.nullable("concat_column_a_and_b", new ArrowType.Utf8())
+    ), null);
+    // Substrait Extended Expression: Project New Column:
+    // Expression ADD: id + 2
+    // Expression CONCAT: name + '-' + name
+    String binarySubstraitExpressionProject = "Ch4IARIaL2Z1bmN0aW9uc19hcml0aG1ldGljLnlhbWwSERoPCAEaC2FkZDppM" +
+        "zJfaTMyEhQaEggCEAEaDGNvbmNhdDp2Y2hhchoxChoaGBoEKgIQASIIGgYSBAoCEgAiBhoECgIoAhoTYWRkX3R3b190b19jb2x1" +
+        "bW5fYRpGCi0aKwgBGgRiAhABIgoaCBIGCgQSAggBIgkaBwoFYgMgLSAiChoIEgYKBBICCAEaFWNvbmNhdF9jb2x1bW5fYV9hbmR" +
+        "fYiIaCgJJRAoETkFNRRIOCgQqAhABCgRiAhABGAI=";
+    ByteBuffer substraitExpressionProject = getByteBuffer(binarySubstraitExpressionProject);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+         .substraitProjection(substraitExpressionProject)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish();
+        Scanner scanner = dataset.newScan(options);
+        ArrowReader reader = scanner.scanBatches()
+    ) {
+      assertEquals(schema.getFields(), reader.getVectorSchemaRoot().getSchema().getFields());
+      int rowcount = 0;
+      while (reader.loadNextBatch()) {
+        assertTrue(reader.getVectorSchemaRoot().getVector("add_two_to_column_a").toString()
+            .equals("[21, 3, 13, 23, 47]"));
+        assertTrue(reader.getVectorSchemaRoot().getVector("concat_column_a_and_b").toString()
+            .equals("[value_19 - value_19, value_1 - value_1, value_11 - value_11, " +
+                "value_21 - value_21, value_45 - value_45]"));
+        rowcount += reader.getVectorSchemaRoot().getRowCount();
+      }
+      assertEquals(5, rowcount);
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsProjectionWithFilterInsteadOfProjectionException() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("filter_id_lower_than_20", new ArrowType.Bool())
+    ), null);
+    // Substrait Extended Expression: Filter:
+    // Expression 01: WHERE ID < 20
+    String binarySubstraitExpressionFilter = "Ch4IARIaL2Z1bmN0aW9uc19jb21wYXJpc29uLnlhbWwSEhoQCAIQAhoKbHQ6YW55X2F" +
+        "ueRo3ChwaGggCGgQKAhABIggaBhIECgISACIGGgQKAigUGhdmaWx0ZXJfaWRfbG93ZXJfdGhhbl8yMCIaCgJJRAoETkFNRRIOCgQqAhA" +
+        "BCgRiAhABGAI=";
+    ByteBuffer substraitExpressionFilter = getByteBuffer(binarySubstraitExpressionFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitProjection(substraitExpressionFilter)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish();
+        Scanner scanner = dataset.newScan(options);
+        ArrowReader reader = scanner.scanBatches()
+    ) {
+      assertEquals(schema.getFields(), reader.getVectorSchemaRoot().getSchema().getFields());
+      int rowcount = 0;
+      while (reader.loadNextBatch()) {
+        assertTrue(reader.getVectorSchemaRoot().getVector("filter_id_lower_than_20").toString()
+            .equals("[true, true, true, false, false]"));
+        rowcount += reader.getVectorSchemaRoot().getRowCount();
+      }
+      assertEquals(5, rowcount);
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsProjectionWithEmptyProjectionException() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("id", new ArrowType.Int(32, true)),
+        Field.nullable("name", new ArrowType.Utf8())
+    ), null);
+    String base64EncodedSubstraitFilter = "";
+    ByteBuffer substraitExpressionProjection = getByteBuffer(base64EncodedSubstraitFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitProjection(substraitExpressionProjection)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish()
+    ) {
+      Exception e = assertThrows(RuntimeException.class, () -> dataset.newScan(options));
+      assertTrue(e.getMessage().contains("no anonymous struct type was provided to which names could be attached."));
+    }
+  }
+
+  @Test
+  public void testRunExtendedExpressionsProjectAndFilter() throws Exception {
+    final Schema schema = new Schema(Arrays.asList(
+        Field.nullable("add_two_to_column_a", new ArrowType.Int(32, true)),
+        Field.nullable("concat_column_a_and_b", new ArrowType.Utf8())
+    ), null);
+    // Substrait Extended Expression: Project New Column:
+    // Expression ADD: id + 2
+    // Expression CONCAT: name + '-' + name
+    String binarySubstraitExpressionProject = "Ch4IARIaL2Z1bmN0aW9uc19hcml0aG1ldGljLnlhbWwSERoPCAEaC2FkZDppM" +
+        "zJfaTMyEhQaEggCEAEaDGNvbmNhdDp2Y2hhchoxChoaGBoEKgIQASIIGgYSBAoCEgAiBhoECgIoAhoTYWRkX3R3b190b19jb2x1" +
+        "bW5fYRpGCi0aKwgBGgRiAhABIgoaCBIGCgQSAggBIgkaBwoFYgMgLSAiChoIEgYKBBICCAEaFWNvbmNhdF9jb2x1bW5fYV9hbmR" +
+        "fYiIaCgJJRAoETkFNRRIOCgQqAhABCgRiAhABGAI=";
+    ByteBuffer substraitExpressionProject = getByteBuffer(binarySubstraitExpressionProject);
+    // Substrait Extended Expression: Filter:
+    // Expression 01: WHERE ID < 20
+    String base64EncodedSubstraitFilter = "Ch4IARIaL2Z1bmN0aW9uc19jb21wYXJpc29uLnlhbWwSEhoQCAIQAhoKbHQ6YW55X2F" +
+        "ueRo3ChwaGggCGgQKAhABIggaBhIECgISACIGGgQKAigUGhdmaWx0ZXJfaWRfbG93ZXJfdGhhbl8yMCIaCgJJRAoETkFNRRIOCgQqAhA" +
+        "BCgRiAhABGAI=";
+    ByteBuffer substraitExpressionFilter = getByteBuffer(base64EncodedSubstraitFilter);
+    ParquetWriteSupport writeSupport = ParquetWriteSupport
+        .writeTempFile(AVRO_SCHEMA_USER, TMP.newFolder(), 19, "value_19", 1, "value_1",
+            11, "value_11", 21, "value_21", 45, "value_45");
+    ScanOptions options = new ScanOptions.Builder(/*batchSize*/ 32768)
+        .columns(Optional.empty())
+        .substraitProjection(substraitExpressionProject)
+        .substraitFilter(substraitExpressionFilter)
+        .build();
+    try (
+        DatasetFactory datasetFactory = new FileSystemDatasetFactory(rootAllocator(), NativeMemoryPool.getDefault(),
+            FileFormat.PARQUET, writeSupport.getOutputURI());
+        Dataset dataset = datasetFactory.finish();
+        Scanner scanner = dataset.newScan(options);
+        ArrowReader reader = scanner.scanBatches()
+    ) {
+      assertEquals(schema.getFields(), reader.getVectorSchemaRoot().getSchema().getFields());
+      int rowcount = 0;
+      while (reader.loadNextBatch()) {
+        assertTrue(reader.getVectorSchemaRoot().getVector("add_two_to_column_a").toString()
+            .equals("[21, 3, 13]"));
+        assertTrue(reader.getVectorSchemaRoot().getVector("concat_column_a_and_b").toString()
+            .equals("[value_19 - value_19, value_1 - value_1, value_11 - value_11]"));
+        rowcount += reader.getVectorSchemaRoot().getRowCount();
+      }
+      assertEquals(3, rowcount);
+    }
+  }
+
+  private static ByteBuffer getByteBuffer(String base64EncodedSubstrait) {
+    byte[] decodedSubstrait = Base64.getDecoder().decode(base64EncodedSubstrait);
+    ByteBuffer substraitExpression = ByteBuffer.allocateDirect(decodedSubstrait.length);
+    substraitExpression.put(decodedSubstrait);
+    return substraitExpression;
+  }
 }

From e068b7f845514637d3ffebd6e341b38439742a40 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 20 Sep 2023 13:21:45 -0400
Subject: [PATCH 393/749] GH-37805: [CI][MATLAB] Hard-code `release` to
 `R2023a` for `matlab-actions/setup-matlab` action in MATLAB CI workflows
 (#37808)

### Rationale for this change

Due to a recent change to default to `R2023b` by default for the `[matlab-actions/setup-matlab`](https://github.com/matlab-actions/setup-matlab) action in GitHub Actions, the MATLAB CI workflows are failing.

Example failure logs:

https://github.com/apache/arrow/actions/runs/6250586979/job/16970596069?pr=37773#step:9:70

Our preferred solution to address this in the short term is to explicitly specify the [`release` parameter](https://github.com/matlab-actions/setup-matlab#set-up-matlab) to the `setup-matlab` action to be `R2023a`.

In the long term, we can work on figuring out why the build is failing on Windows with `R2023b`.

For reference - it appears that the `FindMatlab` CMake module only recently added R2023b to its list of recognized versions:

https://gitlab.kitware.com/cmake/cmake/-/merge_requests/8804

### What changes are included in this PR?

1. Hard-coded MATLAB `release` to `R2023a` for the [`matlab-actions/setup-matlab`](https://github.com/matlab-actions/setup-matlab) action in the MATLAB CI workflows.

### Are these changes tested?

Yes.

1. [MATLAB CI workflows are passing on all platforms in `mathworks/arrow`](https://github.com/mathworks/arrow/actions/runs/6251345588).

### Are there any user-facing changes?

No.

This change only impacts the MATLAB CI workflows which were defaulting to `R2023a` by default in the past.

### Future Directions

1. #37809
* Closes: #37805

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .github/workflows/matlab.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/matlab.yml b/.github/workflows/matlab.yml
index 221ed5c77cd47..6921e12213b5b 100644
--- a/.github/workflows/matlab.yml
+++ b/.github/workflows/matlab.yml
@@ -53,6 +53,8 @@ jobs:
         run: sudo apt-get install ninja-build
       - name: Install MATLAB
         uses: matlab-actions/setup-matlab@v1
+        with:
+          release: R2023a
       - name: Install ccache
         run: sudo apt-get install ccache
       - name: Setup ccache
@@ -99,6 +101,8 @@ jobs:
         run: brew install ninja
       - name: Install MATLAB
         uses: matlab-actions/setup-matlab@v1
+        with:
+          release: R2023a
       - name: Install ccache
         run: brew install ccache
       - name: Setup ccache
@@ -135,6 +139,8 @@ jobs:
           fetch-depth: 0
       - name: Install MATLAB
         uses: matlab-actions/setup-matlab@v1
+        with:
+          release: R2023a
       - name: Download Timezone Database
         shell: bash
         run: ci/scripts/download_tz_database.sh

From 2b34e37a956ac59b79e74da1dde8f037c9c88c5d Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 20 Sep 2023 14:31:12 -0400
Subject: [PATCH 394/749] GH-37770: [MATLAB] Add CSV `TableReader` and
 `TableWriter` MATLAB classes (#37773)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

To enable initial CSV I/O support, this PR adds `arrow.io.csv.TableReader` and `arrow.io.csv.TableWriter` MATLAB classes to the MATLAB interface.

### What changes are included in this PR?

1. Added a new `arrow.io.csv.TableReader` class
2. Added a new `arrow.io.csv.TableWriter` class

**Example**
```matlab
>> matlabTableWrite = array2table(rand(3))

matlabTableWrite =

  3×3 table

     Var1        Var2       Var3
    _______    ________    _______

    0.91131    0.091595    0.24594
    0.51315     0.27368    0.62119
    0.42942     0.88665    0.49501

>> arrowTableWrite = arrow.table(matlabTableWrite)

arrowTableWrite =

Var1: double
Var2: double
Var3: double
----
Var1:
  [
    [
      0.9113083542736461,
      0.5131490075412158,
      0.42942202968065213
    ]
  ]
Var2:
  [
    [
      0.09159480217154525,
      0.27367730380496647,
      0.8866478145458545
    ]
  ]
Var3:
  [
    [
      0.2459443412735529,
      0.6211893868708748,
      0.49500739584280073
    ]
  ]

>> writer = arrow.io.csv.TableWriter("example.csv")

writer =

  TableWriter with properties:

    Filename: "example.csv"

>> writer.write(arrowTableWrite)

>> reader = arrow.io.csv.TableReader("example.csv")

reader =

  TableReader with properties:

    Filename: "example.csv"

>> arrowTableRead = reader.read()

arrowTableRead =

Var1: double
Var2: double
Var3: double
----
Var1:
  [
    [
      0.9113083542736461,
      0.5131490075412158,
      0.42942202968065213
    ]
  ]
Var2:
  [
    [
      0.09159480217154525,
      0.27367730380496647,
      0.8866478145458545
    ]
  ]
Var3:
  [
    [
      0.2459443412735529,
      0.6211893868708748,
      0.49500739584280073
    ]
  ]

>> matlabTableRead = table(arrowTableRead)

matlabTableRead =

  3×3 table

     Var1        Var2       Var3
    _______    ________    _______

    0.91131    0.091595    0.24594
    0.51315     0.27368    0.62119
    0.42942     0.88665    0.49501

>> isequal(arrowTableRead, arrowTableWrite)

ans =

  logical

   1

>> isequal(matlabTableRead, matlabTableWrite)

ans =

  logical

   1
```

### Are these changes tested?

Yes.

1. Added new CSV I/O tests including `test/arrow/io/csv/tRoundTrip.m` and `test/arrow/io/csv/tError.m`.
2. Both of these test classes inherit from a `CSVTest` superclass.

### Are there any user-facing changes?

Yes.

1. Users can now read and write CSV files using `arrow.io.csv.TableReader` and `arrow.io.csv.TableWriter`.

### Future Directions

1. Expose [options](https://github.com/apache/arrow/blob/main/cpp/src/arrow/csv/options.h) for controlling CSV reading and writing in MATLAB.
2. Add more read/write tests for null value handling and other datatypes beyond numeric and string values.
4. Add a `RecordBatchReader` and `RecordBatchWriter` for CSV.
5. Add support for more I/O formats like Parquet, JSON, ORC, Arrow IPC, etc.

### Notes

1. Thank you @ sgilmore10 for your help with this pull request!
2. I chose to add both the `TableReader` and `TableWriter` in one pull request because it simplified testing. My apologies for the slightly lengthy pull request.
* Closes: #37770

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/CMakeLists.txt                         |   5 +-
 matlab/src/cpp/arrow/matlab/error/error.h     |   3 +
 .../arrow/matlab/io/csv/proxy/table_reader.cc |  93 ++++++++++++++++
 .../arrow/matlab/io/csv/proxy/table_reader.h  |  38 +++++++
 .../arrow/matlab/io/csv/proxy/table_writer.cc |  86 +++++++++++++++
 .../arrow/matlab/io/csv/proxy/table_writer.h  |  38 +++++++
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   4 +
 .../src/matlab/+arrow/+io/+csv/TableReader.m  |  51 +++++++++
 .../src/matlab/+arrow/+io/+csv/TableWriter.m  |  51 +++++++++
 matlab/test/arrow/io/csv/CSVTest.m            | 102 ++++++++++++++++++
 matlab/test/arrow/io/csv/tError.m             |  73 +++++++++++++
 matlab/test/arrow/io/csv/tRoundTrip.m         |  62 +++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   4 +-
 13 files changed, 606 insertions(+), 4 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.h
 create mode 100644 matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.h
 create mode 100644 matlab/src/matlab/+arrow/+io/+csv/TableReader.m
 create mode 100644 matlab/src/matlab/+arrow/+io/+csv/TableWriter.m
 create mode 100644 matlab/test/arrow/io/csv/CSVTest.m
 create mode 100644 matlab/test/arrow/io/csv/tError.m
 create mode 100644 matlab/test/arrow/io/csv/tRoundTrip.m

diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index c8100a389ace0..b7af37a278536 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -34,8 +34,9 @@ function(build_arrow)
 
   set(ARROW_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep-prefix")
   set(ARROW_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/arrow_ep-build")
-  set(ARROW_CMAKE_ARGS "-DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}"
-                       "-DCMAKE_INSTALL_LIBDIR=lib" "-DARROW_BUILD_STATIC=OFF")
+  set(ARROW_CMAKE_ARGS
+      "-DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}" "-DCMAKE_INSTALL_LIBDIR=lib"
+      "-DARROW_BUILD_STATIC=OFF" "-DARROW_CSV=ON")
 
   add_library(arrow_shared SHARED IMPORTED)
   set(ARROW_LIBRARY_TARGET arrow_shared)
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 4ff77da8d8360..ada9954353d9b 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -182,6 +182,9 @@ namespace arrow::matlab::error {
     static const char* TABLE_INVALID_NUMERIC_COLUMN_INDEX = "arrow:tabular:table:InvalidNumericColumnIndex";
     static const char* FAILED_TO_OPEN_FILE_FOR_WRITE = "arrow:io:FailedToOpenFileForWrite";
     static const char* FAILED_TO_OPEN_FILE_FOR_READ = "arrow:io:FailedToOpenFileForRead";
+    static const char* CSV_FAILED_TO_WRITE_TABLE = "arrow:io:csv:FailedToWriteTable";
+    static const char* CSV_FAILED_TO_CREATE_TABLE_READER = "arrow:io:csv:FailedToCreateTableReader";
+    static const char* CSV_FAILED_TO_READ_TABLE = "arrow:io:csv:FailedToReadTable";
     static const char* FEATHER_FAILED_TO_WRITE_TABLE = "arrow:io:feather:FailedToWriteTable";
     static const char* TABLE_FROM_RECORD_BATCH = "arrow:table:FromRecordBatch";
     static const char* FEATHER_FAILED_TO_CREATE_READER = "arrow:io:feather:FailedToCreateReader";
diff --git a/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc
new file mode 100644
index 0000000000000..ab9935ce145a8
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc
@@ -0,0 +1,93 @@
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/io/csv/proxy/table_reader.h"
+#include "arrow/matlab/tabular/proxy/table.h"
+
+#include "arrow/util/utf8.h"
+
+#include "arrow/result.h"
+
+#include "arrow/io/file.h"
+#include "arrow/io/interfaces.h"
+#include "arrow/csv/reader.h"
+#include "arrow/table.h"
+
+namespace arrow::matlab::io::csv::proxy {
+
+    TableReader::TableReader(const std::string& filename) : filename{filename} {
+        REGISTER_METHOD(TableReader, read);
+        REGISTER_METHOD(TableReader, getFilename);
+    }
+
+    libmexclass::proxy::MakeResult TableReader::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using TableReaderProxy = arrow::matlab::io::csv::proxy::TableReader;
+
+        mda::StructArray args = constructor_arguments[0];
+        const mda::StringArray filename_utf16_mda = args[0]["Filename"];
+        const auto filename_utf16 = std::u16string(filename_utf16_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR(const auto filename, arrow::util::UTF16StringToUTF8(filename_utf16), error::UNICODE_CONVERSION_ERROR_ID);
+
+        return std::make_shared<TableReaderProxy>(filename);
+    }
+
+    void TableReader::read(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        namespace csv = ::arrow::csv;
+        using TableProxy = arrow::matlab::tabular::proxy::Table;
+
+        mda::ArrayFactory factory;
+
+        // Create a file input stream.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto source, arrow::io::ReadableFile::Open(filename, arrow::default_memory_pool()), context, error::FAILED_TO_OPEN_FILE_FOR_READ);
+
+        const ::arrow::io::IOContext io_context;
+        const auto read_options = csv::ReadOptions::Defaults();
+        const auto parse_options = csv::ParseOptions::Defaults();
+        const auto convert_options = csv::ConvertOptions::Defaults();
+
+        // Create a TableReader from the file input stream.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto table_reader,
+                                            csv::TableReader::Make(io_context, source, read_options, parse_options, convert_options),
+                                            context,
+                                            error::CSV_FAILED_TO_CREATE_TABLE_READER);
+
+        // Read a Table from the file.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto table, table_reader->Read(), context, error::CSV_FAILED_TO_READ_TABLE);
+
+        auto table_proxy = std::make_shared<TableProxy>(table);
+        const auto table_proxy_id = ProxyManager::manageProxy(table_proxy);
+
+        const auto table_proxy_id_mda = factory.createScalar(table_proxy_id);
+
+        context.outputs[0] = table_proxy_id_mda;
+    }
+
+    void TableReader::getFilename(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto filename_utf16, arrow::util::UTF8StringToUTF16(filename), context, error::UNICODE_CONVERSION_ERROR_ID);
+        auto filename_utf16_mda = factory.createScalar(filename_utf16);
+        context.outputs[0] = filename_utf16_mda;
+    }
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.h b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.h
new file mode 100644
index 0000000000000..d5dfce50e4096
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_reader.h
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::io::csv::proxy {
+
+    class TableReader : public libmexclass::proxy::Proxy {
+        public:
+            TableReader(const std::string& filename);
+            ~TableReader() {}
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+        protected:
+            void read(libmexclass::proxy::method::Context& context);
+            void getFilename(libmexclass::proxy::method::Context& context);
+
+        private:
+            const std::string filename;
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc
new file mode 100644
index 0000000000000..b24bd81b06681
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc
@@ -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.
+
+#include "arrow/matlab/io/csv/proxy/table_writer.h"
+#include "arrow/matlab/tabular/proxy/table.h"
+#include "arrow/matlab/error/error.h"
+
+#include "arrow/result.h"
+#include "arrow/table.h"
+#include "arrow/util/utf8.h"
+
+#include "arrow/io/file.h"
+#include "arrow/csv/writer.h"
+#include "arrow/csv/options.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::io::csv::proxy {
+
+    TableWriter::TableWriter(const std::string& filename) : filename{filename} {
+        REGISTER_METHOD(TableWriter, getFilename);
+        REGISTER_METHOD(TableWriter, write);
+    }
+
+    libmexclass::proxy::MakeResult TableWriter::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::StringArray filename_mda = opts[0]["Filename"];
+        using TableWriterProxy = ::arrow::matlab::io::csv::proxy::TableWriter;
+
+        const auto filename_utf16 = std::u16string(filename_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR(const auto filename_utf8,
+                               arrow::util::UTF16StringToUTF8(filename_utf16),
+                               error::UNICODE_CONVERSION_ERROR_ID);
+
+        return std::make_shared<TableWriterProxy>(filename_utf8);
+    }
+
+    void TableWriter::getFilename(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto utf16_filename,
+                                            arrow::util::UTF8StringToUTF16(filename),
+                                            context,
+                                            error::UNICODE_CONVERSION_ERROR_ID);
+        mda::ArrayFactory factory;
+        auto str_mda = factory.createScalar(utf16_filename);
+        context.outputs[0] = str_mda;
+    }
+
+    void TableWriter::write(libmexclass::proxy::method::Context& context) {
+        namespace csv = ::arrow::csv;
+        namespace mda = ::matlab::data;
+        using TableProxy = ::arrow::matlab::tabular::proxy::Table;
+
+        mda::StructArray opts = context.inputs[0];
+        const mda::TypedArray<uint64_t> table_proxy_id_mda = opts[0]["TableProxyID"];
+        const uint64_t table_proxy_id = table_proxy_id_mda[0];
+
+        auto proxy = libmexclass::proxy::ProxyManager::getProxy(table_proxy_id);
+        auto table_proxy = std::static_pointer_cast<TableProxy>(proxy);
+        auto table = table_proxy->unwrap();
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto output_stream,
+                                            arrow::io::FileOutputStream::Open(filename),
+                                            context,
+                                            error::FAILED_TO_OPEN_FILE_FOR_WRITE);
+        const auto options = csv::WriteOptions::Defaults();
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(csv::WriteCSV(*table, options, output_stream.get()),
+                                            context,
+                                            error::CSV_FAILED_TO_WRITE_TABLE);
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.h b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.h
new file mode 100644
index 0000000000000..b9916bd9bdc22
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/io/csv/proxy/table_writer.h
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::io::csv::proxy {
+
+    class TableWriter : public libmexclass::proxy::Proxy {
+        public:
+            TableWriter(const std::string& filename);
+            ~TableWriter() {}
+            static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+        protected:
+            void getFilename(libmexclass::proxy::method::Context& context);
+            void write(libmexclass::proxy::method::Context& context);
+
+        private:
+            const std::string filename;
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index ebeb020a9e7c7..d1f46c7e2f71f 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -37,6 +37,8 @@
 #include "arrow/matlab/type/proxy/field.h"
 #include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/io/feather/proxy/reader.h"
+#include "arrow/matlab/io/csv/proxy/table_writer.h"
+#include "arrow/matlab/io/csv/proxy/table_reader.h"
 
 #include "factory.h"
 
@@ -85,6 +87,8 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.StructType     , arrow::matlab::type::proxy::StructType);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
+    REGISTER_PROXY(arrow.io.csv.proxy.TableWriter  , arrow::matlab::io::csv::proxy::TableWriter);
+    REGISTER_PROXY(arrow.io.csv.proxy.TableReader  , arrow::matlab::io::csv::proxy::TableReader);
 
     return libmexclass::error::Error{error::UNKNOWN_PROXY_ERROR_ID, "Did not find matching C++ proxy for " + class_name};
 };
diff --git a/matlab/src/matlab/+arrow/+io/+csv/TableReader.m b/matlab/src/matlab/+arrow/+io/+csv/TableReader.m
new file mode 100644
index 0000000000000..1e0308bb8d4fe
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+io/+csv/TableReader.m
@@ -0,0 +1,51 @@
+%TABLEREADER Reads tabular data from a CSV file into an arrow.tabular.Table.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef TableReader
+
+    properties (GetAccess=public, SetAccess=private, Hidden)
+        Proxy
+    end
+
+    properties (Dependent, SetAccess=private, GetAccess=public)
+        Filename
+    end
+
+    methods
+
+        function obj = TableReader(filename)
+            arguments
+                filename (1, 1) string {mustBeNonmissing, mustBeNonzeroLengthText}
+            end
+
+            args = struct(Filename=filename);
+            obj.Proxy = arrow.internal.proxy.create("arrow.io.csv.proxy.TableReader", args);
+        end
+
+        function table = read(obj)
+            tableProxyID = obj.Proxy.read();
+            proxy = libmexclass.proxy.Proxy(Name="arrow.tabular.proxy.Table", ID=tableProxyID);
+            table = arrow.tabular.Table(proxy);
+        end
+
+        function filename = get.Filename(obj)
+            filename = obj.Proxy.getFilename();
+        end
+
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+io/+csv/TableWriter.m b/matlab/src/matlab/+arrow/+io/+csv/TableWriter.m
new file mode 100644
index 0000000000000..eb1aafe08f545
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+io/+csv/TableWriter.m
@@ -0,0 +1,51 @@
+%TABLEWRITER Writes tabular data in an arrow.tabular.Table to a CSV file.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef TableWriter < matlab.mixin.Scalar
+
+    properties(Hidden, SetAccess=private, GetAccess=public)
+        Proxy
+    end
+
+    properties(Dependent, SetAccess=private, GetAccess=public)
+        Filename
+    end
+
+    methods
+        function obj = TableWriter(filename)
+            arguments
+                filename (1, 1) string {mustBeNonmissing, mustBeNonzeroLengthText}
+            end
+
+            args = struct(Filename=filename);
+            proxyName = "arrow.io.csv.proxy.TableWriter";
+            obj.Proxy = arrow.internal.proxy.create(proxyName, args);
+        end
+
+        function write(obj, table)
+            arguments
+                obj (1, 1) arrow.io.csv.TableWriter
+                table (1, 1) arrow.tabular.Table
+            end
+            args = struct(TableProxyID=table.Proxy.ID);
+            obj.Proxy.write(args);
+        end
+
+        function filename = get.Filename(obj)
+            filename = obj.Proxy.getFilename();
+        end
+    end
+end
diff --git a/matlab/test/arrow/io/csv/CSVTest.m b/matlab/test/arrow/io/csv/CSVTest.m
new file mode 100644
index 0000000000000..49f77eaaa7c63
--- /dev/null
+++ b/matlab/test/arrow/io/csv/CSVTest.m
@@ -0,0 +1,102 @@
+%CSVTEST Super class for CSV related tests.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef CSVTest < matlab.unittest.TestCase
+
+    properties
+        Filename
+    end
+
+    methods (TestClassSetup)
+
+        function initializeProperties(~)
+            % Seed the random number generator.
+            rng(1);
+        end
+
+    end
+
+    methods (TestMethodSetup)
+
+        function setupTestFilename(testCase)
+            import matlab.unittest.fixtures.TemporaryFolderFixture
+            fixture = testCase.applyFixture(TemporaryFolderFixture);
+            testCase.Filename = fullfile(fixture.Folder, "filename.csv");
+        end
+
+    end
+
+    methods
+
+        function verifyRoundTrip(testCase, arrowTable)
+            import arrow.io.csv.*
+
+            writer = TableWriter(testCase.Filename);
+            reader = TableReader(testCase.Filename);
+
+            writer.write(arrowTable);
+            arrowTableRead = reader.read();
+
+            testCase.verifyEqual(arrowTableRead, arrowTable);
+        end
+
+        function arrowTable = makeArrowTable(testCase, opts)
+            arguments
+                testCase
+                opts.Type
+                opts.ColumnNames
+                opts.NumRows
+                opts.WithNulls (1, 1) logical = false
+            end
+
+            if opts.Type == "numeric"
+                matlabTable = array2table(rand(opts.NumRows, numel(opts.ColumnNames)));
+            elseif opts.Type == "string"
+                matlabTable = array2table("A" + rand(opts.NumRows, numel(opts.ColumnNames)) + "B");
+            end
+
+            if opts.WithNulls
+                matlabTable = testCase.setNullValues(matlabTable, NullPercentage=0.2);
+            end
+
+            arrays = cell(1, width(matlabTable));
+            for ii = 1:width(matlabTable)
+                arrays{ii} = arrow.array(matlabTable.(ii));
+            end
+            arrowTable = arrow.tabular.Table.fromArrays(arrays{:}, ColumnNames=opts.ColumnNames);
+        end
+
+        function tWithNulls = setNullValues(testCase, t, opts)
+            arguments
+                testCase %#ok<INUSA>
+                t table
+                opts.NullPercentage (1, 1) double {mustBeGreaterThanOrEqual(opts.NullPercentage, 0)} = 0.5
+            end
+
+            tWithNulls = t;
+            for ii = 1:width(t)
+                temp = tWithNulls.(ii);
+                numValues = numel(temp);
+                numNulls = uint64(opts.NullPercentage * numValues);
+                nullIndices = randperm(numValues, numNulls);
+                temp(nullIndices) = missing;
+                tWithNulls.(ii) = temp;
+            end
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/io/csv/tError.m b/matlab/test/arrow/io/csv/tError.m
new file mode 100644
index 0000000000000..24c420e7ba2dd
--- /dev/null
+++ b/matlab/test/arrow/io/csv/tError.m
@@ -0,0 +1,73 @@
+%TERROR Error tests for CSV.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tError < CSVTest
+
+    methods(Test)
+
+        function EmptyFile(testCase)
+            import arrow.io.csv.*
+
+            arrowTableWrite = arrow.table();
+
+            writer = TableWriter(testCase.Filename);
+            reader = TableReader(testCase.Filename);
+
+            writer.write(arrowTableWrite);
+            fcn = @() reader.read();
+            testCase.verifyError(fcn, "arrow:io:csv:FailedToReadTable");
+        end
+
+        function InvalidWriterFilenameType(testCase)
+            import arrow.io.csv.*
+            fcn = @() TableWriter(table);
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+            fcn = @() TableWriter(["a", "b"]);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+        end
+
+        function InvalidReaderFilenameType(testCase)
+            import arrow.io.csv.*
+            fcn = @() TableReader(table);
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+            fcn = @() TableReader(["a", "b"]);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+        end
+
+        function InvalidWriterWriteType(testCase)
+            import arrow.io.csv.*
+            writer = TableWriter(testCase.Filename);
+            fcn = @() writer.write("text");
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function WriterFilenameNoSetter(testCase)
+            import arrow.io.csv.*
+            writer = TableWriter(testCase.Filename);
+            fcn = @() setfield(writer, "Filename", "filename.csv");
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ReaderFilenameNoSetter(testCase)
+            import arrow.io.csv.*
+            reader = TableReader(testCase.Filename);
+            fcn = @() setfield(reader, "Filename", "filename.csv");
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/io/csv/tRoundTrip.m b/matlab/test/arrow/io/csv/tRoundTrip.m
new file mode 100644
index 0000000000000..cb35822580106
--- /dev/null
+++ b/matlab/test/arrow/io/csv/tRoundTrip.m
@@ -0,0 +1,62 @@
+%TROUNDTRIP Round trip tests for CSV.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+classdef tRoundTrip < CSVTest
+
+    properties (TestParameter)
+        NumRows = { ...
+            2, ...
+            10, ...
+            100 ...
+        }
+        WithNulls = { ...
+            true, ...
+            false ...
+        }
+        ColumnNames = {...
+            ["A", "B", "C"], ...
+            ["😀", "🌲", "🥭", " ", "ABC"], ...
+            [" ", " ", " "]
+        }
+    end
+
+    methods(Test)
+
+        function Numeric(testCase, NumRows, WithNulls, ColumnNames)
+            arrowTable = testCase.makeArrowTable(...
+                Type="numeric", ...
+                NumRows=NumRows, ...
+                WithNulls=WithNulls, ...
+                ColumnNames=ColumnNames ...
+            );
+
+            testCase.verifyRoundTrip(arrowTable);
+        end
+
+        function String(testCase, NumRows, ColumnNames)
+            arrowTable = testCase.makeArrowTable(...
+                Type="string", ...
+                NumRows=NumRows, ...
+                WithNulls=false, ...
+                ColumnNames=ColumnNames ...
+            );
+
+            testCase.verifyRoundTrip(arrowTable);
+        end
+
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 40c6b5a51d4fe..294612dda370f 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -70,10 +70,10 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/reader.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/index/validate.cc")
 
-
-
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy/factory.cc")
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_LIBRARY_INCLUDE_DIRS ${MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_LIBRARY_ROOT_INCLUDE_DIR}

From 7b30ba48e7f3605507d1daecbd041c16b667178a Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 20 Sep 2023 15:43:55 -0400
Subject: [PATCH 395/749] GH-37653: [MATLAB] Add `arrow.array.StructArray`
 MATLAB class (#37806)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Now that many of the commonly-used "primitive" array types have been added to the MATLAB Inferface, we can implement `arrow.array.StructArray` class.

### What changes are included in this PR?

Added `arrow.array.StructArray` MATLAB class.

*Methods* of `arrow.array.StructArray` include:

- `fromArrays(arrays, nvpairs)`
- `field(i)` -> get the `i` field as an `arrow.array.Array`. `i` can be a positive integer or a field name.
- `toMATLAB()` -> convert to a MATLAB `table`
- `table()` -> convert to a MATLAB `table`

*Properties* of `arrow.array.StructArray` include:

- `Type`
- `Length`
- `NumFields`
- `FieldNames`
- `Valid`

**Example Usage**
```matlab
>> a = arrow.array([1, 2, 3, 4]);
>> b = arrow.array(["A", "B", "C", "D"]);
>> s = arrow.array.StructArray.fromArrays(a, b, FieldNames=["A", "B"])
s =

-- is_valid: all not null
-- child 0 type: double
  [
    1,
    2,
    3,
    4
  ]
-- child 1 type: string
  [
    "A",
    "B",
    "C",
    "D"
  ]

% Convert StructArray to a MATLAB table
>> t = toMATLAB(s)

t =

  4×2 table

    A     B
    _    ___

    1    "A"
    2    "B"
    3    "C"
    4    "D"
```

### Are these changes tested?

Yes. Added a new test class `tStructArray.m`

### Are there any user-facing changes?

Yes. Users can now construct an `arrow.array.StructArray` instance.

### Notes

1. Although [`struct`](https://www.mathworks.com/help/matlab/ref/struct.html) is a MATLAB datatype, `StructArray`'s `toMATLAB` method returns a MATLAB `table`. We went with this design because the layout of MATLAB `table`s more closely resembles `StructArray`s. MATLAB `tables` ensure a consistent schema and the data is laid out in a columnar format. In a future PR, we plan on adding a `struct` method to `StructArray`, which will return a MATLAB `struct` array.
2. I removed the virtual `toMATLAB` method from `proxy::Array` because the nested array MATLAB will implement their `toMATLAB` method by invoking the `toMATLAB` method on their field arrays. There's no need for the C++ proxy classes of nested arrays to have a `toMATLAB` method.

### Future Directions
1. Add a `fromMATLAB` static method to create `StructArray`s from MATLAB `tables` and MATLAB `struct` arrays.
4. Add a `fromTable` static method to create `StructArray`s from `arrow.tabular.Table`s
5. Add a `fromRecordBatch` static method to create `StructArray`s from `arrow.tabular.RecordBatch`s

* Closes: #37653

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc |   1 -
 .../src/cpp/arrow/matlab/array/proxy/array.h  |   2 -
 .../arrow/matlab/array/proxy/boolean_array.cc |   4 +-
 .../arrow/matlab/array/proxy/boolean_array.h  |   2 +-
 .../arrow/matlab/array/proxy/numeric_array.h  |   6 +-
 .../arrow/matlab/array/proxy/string_array.cc  |   4 +-
 .../arrow/matlab/array/proxy/string_array.h   |   2 +-
 .../arrow/matlab/array/proxy/struct_array.cc  | 199 +++++++++++++
 .../arrow/matlab/array/proxy/struct_array.h   |  44 +++
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   3 +
 matlab/src/cpp/arrow/matlab/error/error.h     |   2 +-
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 matlab/src/matlab/+arrow/+array/Array.m       |   5 +-
 .../src/matlab/+arrow/+array/BooleanArray.m   |   6 +-
 .../src/matlab/+arrow/+array/ChunkedArray.m   |   3 +-
 matlab/src/matlab/+arrow/+array/Date32Array.m |   2 +-
 matlab/src/matlab/+arrow/+array/Date64Array.m |   2 +-
 .../src/matlab/+arrow/+array/Float32Array.m   |   2 +-
 .../src/matlab/+arrow/+array/Float64Array.m   |   2 +-
 matlab/src/matlab/+arrow/+array/Int16Array.m  |   2 +-
 matlab/src/matlab/+arrow/+array/Int32Array.m  |   2 +-
 matlab/src/matlab/+arrow/+array/Int64Array.m  |   2 +-
 matlab/src/matlab/+arrow/+array/Int8Array.m   |   2 +-
 .../src/matlab/+arrow/+array/NumericArray.m   |   2 +-
 matlab/src/matlab/+arrow/+array/StringArray.m |   6 +-
 matlab/src/matlab/+arrow/+array/StructArray.m | 146 +++++++++
 matlab/src/matlab/+arrow/+array/Time32Array.m |   2 +-
 matlab/src/matlab/+arrow/+array/Time64Array.m |   2 +-
 .../src/matlab/+arrow/+array/TimestampArray.m |   2 +-
 matlab/src/matlab/+arrow/+array/UInt16Array.m |   2 +-
 matlab/src/matlab/+arrow/+array/UInt32Array.m |   2 +-
 matlab/src/matlab/+arrow/+array/UInt64Array.m |   2 +-
 matlab/src/matlab/+arrow/+array/UInt8Array.m  |   2 +-
 .../+tabular/createAllSupportedArrayTypes.m   |  11 +
 .../+arrow/+internal/+validate/parseValid.m   |  46 +++
 .../+internal/+validate/parseValidElements.m  |  25 +-
 .../+arrow/+type/+traits/StructTraits.m       |  17 +-
 matlab/src/matlab/+arrow/+type/StructType.m   |  32 +-
 matlab/test/arrow/array/tStructArray.m        | 277 ++++++++++++++++++
 matlab/test/arrow/type/traits/tStructTraits.m |  10 +-
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 41 files changed, 803 insertions(+), 85 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/struct_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/struct_array.h
 create mode 100644 matlab/src/matlab/+arrow/+array/StructArray.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+validate/parseValid.m
 create mode 100644 matlab/test/arrow/array/tStructArray.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index ed6152259891d..5fa533632f928 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -31,7 +31,6 @@ namespace arrow::matlab::array::proxy {
 
         // Register Proxy methods.
         REGISTER_METHOD(Array, toString);
-        REGISTER_METHOD(Array, toMATLAB);
         REGISTER_METHOD(Array, getLength);
         REGISTER_METHOD(Array, getValid);
         REGISTER_METHOD(Array, getType);
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index 185e107f75391..46e1fa5a81380 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -42,8 +42,6 @@ class Array : public libmexclass::proxy::Proxy {
 
         void getType(libmexclass::proxy::method::Context& context);
 
-        virtual void toMATLAB(libmexclass::proxy::method::Context& context) = 0;
-
         void isEqual(libmexclass::proxy::method::Context& context);
 
         std::shared_ptr<arrow::Array> array;
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
index 5be0cfb5a3d13..6a6e478274823 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
@@ -25,7 +25,9 @@
 namespace arrow::matlab::array::proxy {
 
         BooleanArray::BooleanArray(std::shared_ptr<arrow::BooleanArray> array) 
-            : arrow::matlab::array::proxy::Array{std::move(array)} {}
+            : arrow::matlab::array::proxy::Array{std::move(array)} {
+                REGISTER_METHOD(BooleanArray, toMATLAB);
+            }
 
         libmexclass::proxy::MakeResult BooleanArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
             ::matlab::data::StructArray opts = constructor_arguments[0];
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
index 775673c29eada..edc00b178e42a 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.h
@@ -31,7 +31,7 @@ namespace arrow::matlab::array::proxy {
             static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
         protected:
-            void toMATLAB(libmexclass::proxy::method::Context& context) override;
+            void toMATLAB(libmexclass::proxy::method::Context& context);
     };
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
index f9da38dbaa062..4b4ddb6588678 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/numeric_array.h
@@ -40,7 +40,9 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
     public:
 
         NumericArray(const std::shared_ptr<arrow::NumericArray<ArrowType>> numeric_array)
-            : arrow::matlab::array::proxy::Array{std::move(numeric_array)} {}
+            : arrow::matlab::array::proxy::Array{std::move(numeric_array)} {
+                REGISTER_METHOD(NumericArray, toMATLAB);
+            }
 
         static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {            
             using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
@@ -67,7 +69,7 @@ class NumericArray : public arrow::matlab::array::proxy::Array {
         }
 
     protected:
-        void toMATLAB(libmexclass::proxy::method::Context& context) override {
+        void toMATLAB(libmexclass::proxy::method::Context& context) {
            using CType = typename arrow::TypeTraits<ArrowType>::CType;
            using NumericArray = arrow::NumericArray<ArrowType>;
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
index c583e8851a3ac..7160e88a3c8a0 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.cc
@@ -28,7 +28,9 @@
 namespace arrow::matlab::array::proxy {
 
         StringArray::StringArray(const std::shared_ptr<arrow::StringArray> string_array) 
-            : arrow::matlab::array::proxy::Array(std::move(string_array)) {}
+            : arrow::matlab::array::proxy::Array(std::move(string_array)) {
+                REGISTER_METHOD(StringArray, toMATLAB);
+            }
 
         libmexclass::proxy::MakeResult StringArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
             namespace mda = ::matlab::data;
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
index bdcfedd7cdda3..4cc01f0a02f8c 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/string_array.h
@@ -32,7 +32,7 @@ namespace arrow::matlab::array::proxy {
             static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
 
         protected:
-            void toMATLAB(libmexclass::proxy::method::Context& context) override;
+            void toMATLAB(libmexclass::proxy::method::Context& context);
     };
 
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.cc
new file mode 100644
index 0000000000000..c6d9e47a9b0c4
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.cc
@@ -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.
+
+#include "arrow/matlab/array/proxy/struct_array.h"
+#include "arrow/matlab/array/proxy/wrap.h"
+#include "arrow/matlab/bit/pack.h"
+#include "arrow/matlab/error/error.h"
+#include "arrow/matlab/index/validate.h"
+
+#include "arrow/util/utf8.h"
+
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::array::proxy {
+
+    StructArray::StructArray(std::shared_ptr<arrow::StructArray> struct_array)  
+        : proxy::Array{std::move(struct_array)} {
+            REGISTER_METHOD(StructArray, getNumFields);
+            REGISTER_METHOD(StructArray, getFieldByIndex);
+            REGISTER_METHOD(StructArray, getFieldByName);
+            REGISTER_METHOD(StructArray, getFieldNames);
+        }
+
+    libmexclass::proxy::MakeResult StructArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using libmexclass::proxy::ProxyManager;
+
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> arrow_array_proxy_ids = opts[0]["ArrayProxyIDs"];
+        const mda::StringArray field_names_mda = opts[0]["FieldNames"];
+        const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+
+        std::vector<std::shared_ptr<arrow::Array>> arrow_arrays;
+        arrow_arrays.reserve(arrow_array_proxy_ids.getNumberOfElements());
+
+        // Retrieve all of the Arrow Array Proxy instances from the libmexclass ProxyManager.
+        for (const auto& arrow_array_proxy_id : arrow_array_proxy_ids) {
+            auto proxy = ProxyManager::getProxy(arrow_array_proxy_id);
+            auto arrow_array_proxy = std::static_pointer_cast<proxy::Array>(proxy);
+            auto arrow_array = arrow_array_proxy->unwrap();
+            arrow_arrays.push_back(arrow_array);
+        }
+
+        // Convert the utf-16 encoded field names into utf-8 encoded strings
+        std::vector<std::string> field_names;
+        field_names.reserve(field_names_mda.getNumberOfElements());
+        for (const auto& field_name : field_names_mda) {
+            const auto field_name_utf16 = std::u16string(field_name);
+            MATLAB_ASSIGN_OR_ERROR(const auto field_name_utf8, 
+                                   arrow::util::UTF16StringToUTF8(field_name_utf16),
+                                   error::UNICODE_CONVERSION_ERROR_ID);
+            field_names.push_back(field_name_utf8);
+        }
+
+        // Pack the validity bitmap values.
+        MATLAB_ASSIGN_OR_ERROR(auto validity_bitmap_buffer,
+                               bit::packValid(validity_bitmap_mda), 
+                               error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+        // Create the StructArray 
+        MATLAB_ASSIGN_OR_ERROR(auto array, 
+                               arrow::StructArray::Make(arrow_arrays, field_names, validity_bitmap_buffer),
+                               error::STRUCT_ARRAY_MAKE_FAILED);
+
+        // Construct the StructArray Proxy
+        auto struct_array = std::static_pointer_cast<arrow::StructArray>(array);
+        return std::make_shared<proxy::StructArray>(std::move(struct_array));
+    }
+
+    void StructArray::getNumFields(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        mda::ArrayFactory factory;
+        const auto num_fields = array->type()->num_fields();
+        context.outputs[0] = factory.createScalar(num_fields);
+    }
+
+    void StructArray::getFieldByIndex(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int32_t> index_mda = args[0]["Index"];
+        const auto matlab_index = int32_t(index_mda[0]);
+
+        auto struct_array = std::static_pointer_cast<arrow::StructArray>(array);
+
+        const auto num_fields = struct_array->type()->num_fields();
+
+        // Validate there is at least 1 field
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateNonEmptyContainer(num_fields),
+            context, error::INDEX_EMPTY_CONTAINER);
+
+        // Validate the matlab index provided is within the range [1, num_fields]
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(
+            index::validateInRange(matlab_index, num_fields),
+            context, error::INDEX_OUT_OF_RANGE);
+
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        const int32_t index = matlab_index - 1;
+
+        auto field_array = struct_array->field(index);
+
+        // Wrap the array within a proxy object if possible.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto field_array_proxy,
+                                            proxy::wrap(field_array),
+                                            context, error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+        const auto field_array_proxy_id = ProxyManager::manageProxy(field_array_proxy);
+        const auto type_id = field_array->type_id();
+
+        // Return a struct with two fields: ProxyID and TypeID. The MATLAB
+        // layer will use these values to construct the appropriate MATLAB
+        // arrow.array.Array subclass.
+        mda::ArrayFactory factory;
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(field_array_proxy_id);
+        output[0]["TypeID"] = factory.createScalar(static_cast<int32_t>(type_id));
+        context.outputs[0] = output;
+    }
+
+    void StructArray::getFieldByName(libmexclass::proxy::method::Context& context) {
+                    namespace mda = ::matlab::data;
+        using libmexclass::proxy::ProxyManager;
+
+        mda::StructArray args = context.inputs[0];
+
+        const mda::StringArray name_mda = args[0]["Name"];
+        const auto name_utf16 = std::u16string(name_mda[0]);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto name, 
+                                            arrow::util::UTF16StringToUTF8(name_utf16),
+                                            context, error::UNICODE_CONVERSION_ERROR_ID);
+        
+
+        auto struct_array = std::static_pointer_cast<arrow::StructArray>(array);
+        auto field_array = struct_array->GetFieldByName(name);
+        if (!field_array) {
+            // Return an error if we could not query the field by name.
+            const auto msg = "Could not find field named " + name + ".";
+            context.error = libmexclass::error::Error{
+                error::ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME, msg};
+            return;
+        }
+
+        // Wrap the array within a proxy object if possible.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto field_array_proxy,
+                                            proxy::wrap(field_array),
+                                            context, error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+        const auto field_array_proxy_id = ProxyManager::manageProxy(field_array_proxy);
+        const auto type_id = field_array->type_id();
+
+        // Return a struct with two fields: ProxyID and TypeID. The MATLAB
+        // layer will use these values to construct the appropriate MATLAB
+        // arrow.array.Array subclass.
+        mda::ArrayFactory factory;
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(field_array_proxy_id);
+        output[0]["TypeID"] = factory.createScalar(static_cast<int32_t>(type_id));
+        context.outputs[0] = output;
+    }
+
+    void StructArray::getFieldNames(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        const auto& fields = array->type()->fields();
+        const auto num_fields = fields.size();
+        std::vector<mda::MATLABString> names;
+        names.reserve(num_fields);
+       
+        for (size_t i = 0; i < num_fields; ++i) {
+            auto str_utf8 = fields[i]->name();
+
+            // MATLAB strings are UTF-16 encoded. Must convert UTF-8
+            // encoded field names before returning to MATLAB.
+            MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto str_utf16,
+                                                arrow::util::UTF8StringToUTF16(str_utf8),
+                                                context, error::UNICODE_CONVERSION_ERROR_ID);
+            const mda::MATLABString matlab_string = mda::MATLABString(std::move(str_utf16));
+            names.push_back(matlab_string);
+        }
+
+        mda::ArrayFactory factory;
+        context.outputs[0] =  factory.createArray({1, num_fields}, names.begin(), names.end());
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.h
new file mode 100644
index 0000000000000..cfb548c4e50df
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/struct_array.h
@@ -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.
+
+#pragma once
+
+#include "arrow/matlab/array/proxy/array.h"
+
+namespace arrow::matlab::array::proxy {
+
+class StructArray : public arrow::matlab::array::proxy::Array {
+    public:
+        StructArray(std::shared_ptr<arrow::StructArray> struct_array);
+    
+        ~StructArray() {}
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+
+        void getNumFields(libmexclass::proxy::method::Context& context);
+
+        void getFieldByIndex(libmexclass::proxy::method::Context& context);
+
+        void getFieldByName(libmexclass::proxy::method::Context& context);
+
+        void getFieldNames(libmexclass::proxy::method::Context& context);
+
+};
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index a8e3f239919cc..b14f4b18711cb 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -21,6 +21,7 @@
 #include "arrow/matlab/array/proxy/boolean_array.h"
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
+#include "arrow/matlab/array/proxy/struct_array.h"
 
 namespace arrow::matlab::array::proxy {
 
@@ -61,6 +62,8 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::Date64Type>>(std::static_pointer_cast<arrow::Date64Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
+            case ID::STRUCT:
+                return std::make_shared<proxy::StructArray>(std::static_pointer_cast<arrow::StructArray>(array));
             default:
                 return arrow::Status::NotImplemented("Unsupported DataType: " + array->type()->ToString());
         }
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index ada9954353d9b..347bc25b5f3a6 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -195,7 +195,7 @@ namespace arrow::matlab::error {
     static const char* CHUNKED_ARRAY_MAKE_FAILED = "arrow:chunkedarray:MakeFailed";
     static const char* CHUNKED_ARRAY_NUMERIC_INDEX_WITH_EMPTY_CHUNKED_ARRAY = "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray";
     static const char* CHUNKED_ARRAY_INVALID_NUMERIC_CHUNK_INDEX = "arrow:chunkedarray:InvalidNumericChunkIndex";
-    
+    static const char* STRUCT_ARRAY_MAKE_FAILED = "arrow:array:StructArrayMakeFailed";
     static const char* INDEX_EMPTY_CONTAINER = "arrow:index:EmptyContainer";
     static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
 }
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index d1f46c7e2f71f..62ed84fedcf6a 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -21,6 +21,7 @@
 #include "arrow/matlab/array/proxy/timestamp_array.h"
 #include "arrow/matlab/array/proxy/time32_array.h"
 #include "arrow/matlab/array/proxy/time64_array.h"
+#include "arrow/matlab/array/proxy/struct_array.h"
 #include "arrow/matlab/array/proxy/chunked_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/table.h"
@@ -57,6 +58,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.Int64Array    , arrow::matlab::array::proxy::NumericArray<arrow::Int64Type>);
     REGISTER_PROXY(arrow.array.proxy.BooleanArray  , arrow::matlab::array::proxy::BooleanArray);
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
+    REGISTER_PROXY(arrow.array.proxy.StructArray   , arrow::matlab::array::proxy::StructArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 4505d4b006ad8..436d5b80aa6a8 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -21,12 +21,9 @@
         Proxy
     end
 
-    properties (Dependent)
+    properties(Dependent, SetAccess=private, GetAccess=public)
         Length
         Valid % Validity bitmap
-    end
-
-    properties(Dependent, SetAccess=private, GetAccess=public)
         Type(1, 1) arrow.type.Type
     end
     
diff --git a/matlab/src/matlab/+arrow/+array/BooleanArray.m b/matlab/src/matlab/+arrow/+array/BooleanArray.m
index b9ef36b5a70c9..dc38ef93e545c 100644
--- a/matlab/src/matlab/+arrow/+array/BooleanArray.m
+++ b/matlab/src/matlab/+arrow/+array/BooleanArray.m
@@ -16,8 +16,8 @@
 classdef BooleanArray < arrow.array.Array
 % arrow.array.BooleanArray
 
-    properties (Hidden, SetAccess=private)
-        NullSubstitionValue = false;
+    properties (Hidden, GetAccess=public, SetAccess=private)
+        NullSubstitutionValue = false;
     end
 
     methods
@@ -35,7 +35,7 @@
 
         function matlabArray = toMATLAB(obj)
             matlabArray = obj.Proxy.toMATLAB();
-            matlabArray(~obj.Valid) = obj.NullSubstitionValue;
+            matlabArray(~obj.Valid) = obj.NullSubstitutionValue;
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/ChunkedArray.m b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
index 96d7bb57a4021..ede95323f4865 100644
--- a/matlab/src/matlab/+arrow/+array/ChunkedArray.m
+++ b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
@@ -66,7 +66,8 @@
             for ii = 1:obj.NumChunks
                 chunk = obj.chunk(ii);
                 endIndex = startIndex + chunk.Length - 1;
-                data(startIndex:endIndex) = toMATLAB(chunk);
+                % Use 2D indexing to support tabular MATLAB types.
+                data(startIndex:endIndex, :) = toMATLAB(chunk);
                 startIndex = endIndex + 1;
             end
         end
diff --git a/matlab/src/matlab/+arrow/+array/Date32Array.m b/matlab/src/matlab/+arrow/+array/Date32Array.m
index a462bd4f85ac1..cfe56bc67fb94 100644
--- a/matlab/src/matlab/+arrow/+array/Date32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Date32Array.m
@@ -17,7 +17,7 @@
 
 classdef Date32Array < arrow.array.Array
 
-    properties(Access=private)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = NaT
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Date64Array.m b/matlab/src/matlab/+arrow/+array/Date64Array.m
index f5da26bbb5594..c67b82a5bbc47 100644
--- a/matlab/src/matlab/+arrow/+array/Date64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Date64Array.m
@@ -17,7 +17,7 @@
 
 classdef Date64Array < arrow.array.Array
 
-    properties(Access=private)
+    properties(Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = NaT
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Float32Array.m b/matlab/src/matlab/+arrow/+array/Float32Array.m
index fe90db335b5aa..d12e772c41428 100644
--- a/matlab/src/matlab/+arrow/+array/Float32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Float32Array.m
@@ -16,7 +16,7 @@
 classdef Float32Array < arrow.array.NumericArray
 % arrow.array.Float32Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = single(NaN);
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Float64Array.m b/matlab/src/matlab/+arrow/+array/Float64Array.m
index ecf91e28954b5..028331b4f99c0 100644
--- a/matlab/src/matlab/+arrow/+array/Float64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Float64Array.m
@@ -16,7 +16,7 @@
 classdef Float64Array < arrow.array.NumericArray
 % arrow.array.Float64Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = NaN;
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Int16Array.m b/matlab/src/matlab/+arrow/+array/Int16Array.m
index 53c96c6eeb85c..aee94b39c8969 100644
--- a/matlab/src/matlab/+arrow/+array/Int16Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int16Array.m
@@ -16,7 +16,7 @@
 classdef Int16Array < arrow.array.NumericArray
 % arrow.array.Int16Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = int16(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Int32Array.m b/matlab/src/matlab/+arrow/+array/Int32Array.m
index d85bcaf627f7b..a0c0c76afa0e7 100644
--- a/matlab/src/matlab/+arrow/+array/Int32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int32Array.m
@@ -16,7 +16,7 @@
 classdef Int32Array < arrow.array.NumericArray
 % arrow.array.Int32Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = int32(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Int64Array.m b/matlab/src/matlab/+arrow/+array/Int64Array.m
index 72199df88ded1..1f8b1c793984a 100644
--- a/matlab/src/matlab/+arrow/+array/Int64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int64Array.m
@@ -16,7 +16,7 @@
 classdef Int64Array < arrow.array.NumericArray
 % arrow.array.Int64Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = int64(0);
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Int8Array.m b/matlab/src/matlab/+arrow/+array/Int8Array.m
index 0e9d8eec0edf5..02e21178ffe49 100644
--- a/matlab/src/matlab/+arrow/+array/Int8Array.m
+++ b/matlab/src/matlab/+arrow/+array/Int8Array.m
@@ -16,7 +16,7 @@
 classdef Int8Array < arrow.array.NumericArray
 % arrow.array.Int8Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = int8(0);
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/NumericArray.m b/matlab/src/matlab/+arrow/+array/NumericArray.m
index 8f465ce425e23..088ccfd6aa53f 100644
--- a/matlab/src/matlab/+arrow/+array/NumericArray.m
+++ b/matlab/src/matlab/+arrow/+array/NumericArray.m
@@ -16,7 +16,7 @@
 classdef NumericArray < arrow.array.Array
     % arrow.array.NumericArray
 
-    properties(Abstract, Access=protected)
+    properties(Abstract, Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue;
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/StringArray.m b/matlab/src/matlab/+arrow/+array/StringArray.m
index 18fdec9ac70c3..e016aeb704a4d 100644
--- a/matlab/src/matlab/+arrow/+array/StringArray.m
+++ b/matlab/src/matlab/+arrow/+array/StringArray.m
@@ -16,8 +16,8 @@
 classdef StringArray < arrow.array.Array
 % arrow.array.StringArray
 
-    properties (Hidden, SetAccess=private)
-        NullSubstitionValue = string(missing);
+    properties (Hidden, GetAccess=public, SetAccess=private)
+        NullSubstitutionValue = string(missing);
     end
 
     methods
@@ -35,7 +35,7 @@
 
         function matlabArray = toMATLAB(obj)
             matlabArray = obj.Proxy.toMATLAB();
-            matlabArray(~obj.Valid) = obj.NullSubstitionValue;
+            matlabArray(~obj.Valid) = obj.NullSubstitutionValue;
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/StructArray.m b/matlab/src/matlab/+arrow/+array/StructArray.m
new file mode 100644
index 0000000000000..589e39fecd015
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/StructArray.m
@@ -0,0 +1,146 @@
+% arrow.array.StructArray
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef StructArray < arrow.array.Array
+
+    properties (Dependent, GetAccess=public, SetAccess=private)
+        NumFields
+        FieldNames
+    end
+
+    properties (Hidden, Dependent, GetAccess=public, SetAccess=private)
+        NullSubstitutionValue
+    end
+
+    methods
+        function obj = StructArray(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.StructArray")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function numFields = get.NumFields(obj)
+            numFields = obj.Proxy.getNumFields();
+        end
+
+        function fieldNames = get.FieldNames(obj)
+            fieldNames = obj.Proxy.getFieldNames();
+        end
+
+        function F = field(obj, idx)
+            import arrow.internal.validate.*
+
+            idx = index.numericOrString(idx, "int32", AllowNonScalar=false);
+
+            if isnumeric(idx)
+                args = struct(Index=idx);
+                fieldStruct = obj.Proxy.getFieldByIndex(args);
+            else
+                args = struct(Name=idx);
+                fieldStruct = obj.Proxy.getFieldByName(args);
+            end
+            
+            traits = arrow.type.traits.traits(arrow.type.ID(fieldStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=fieldStruct.ProxyID);
+            F = traits.ArrayConstructor(proxy);
+        end
+
+        function T = toMATLAB(obj)
+            T = table(obj);
+        end
+
+        function T = table(obj)
+            import arrow.tabular.internal.*
+
+            numFields = obj.NumFields;
+            matlabArrays = cell(1, numFields);
+
+            invalid = ~obj.Valid;
+            numInvalid = nnz(invalid);
+            
+            for ii = 1:numFields
+                arrowArray = obj.field(ii);
+                matlabArray = toMATLAB(arrowArray);
+                if numInvalid ~= 0
+                    % MATLAB tables do not support null values themselves. 
+                    % So, to encode the StructArray's null values, we 
+                    % iterate over each  variable in the resulting MATLAB
+                    % table, and for each variable, we set the value of all
+                    % null elements to the "NullSubstitutionValue" that
+                    % corresponds to the variable's type (e.g. NaN for
+                    % double, NaT for datetime, etc.).
+                    matlabArray(invalid, :) = repmat(arrowArray.NullSubstitutionValue, [numInvalid 1]);
+                end
+                matlabArrays{ii} = matlabArray;
+            end
+
+            fieldNames = [obj.Type.Fields.Name];
+            validVariableNames = makeValidVariableNames(fieldNames);
+            validDimensionNames = makeValidDimensionNames(validVariableNames);
+
+            T = table(matlabArrays{:}, ...
+                VariableNames=validVariableNames, ...
+                DimensionNames=validDimensionNames);
+        end
+
+        function nullSubVal = get.NullSubstitutionValue(obj)
+            % Return a cell array containing each field's type-specifc
+            % "null" value. For example, NaN is the type-specific null
+            % value for Float32Arrays and Float64Arrays
+            numFields = obj.NumFields;
+            nullSubVal = cell(1, numFields);
+            for ii = 1:obj.NumFields
+                nullSubVal{ii} = obj.field(ii).NullSubstitutionValue;
+            end
+        end
+    end
+
+    methods (Static)
+        function array = fromArrays(arrowArrays, opts)
+            arguments(Repeating)
+                arrowArrays(1, 1) arrow.array.Array
+            end
+            arguments
+                opts.FieldNames(1, :) string {mustBeNonmissing} = compose("Field%d", 1:numel(arrowArrays))
+                opts.Valid
+            end
+
+            import arrow.tabular.internal.validateArrayLengths
+            import arrow.tabular.internal.validateColumnNames
+            import arrow.array.internal.getArrayProxyIDs
+            import arrow.internal.validate.parseValid
+
+            if numel(arrowArrays) == 0
+                error("arrow:struct:ZeroFields", ...
+                    "Must supply at least one field array.");
+            end
+
+            validateArrayLengths(arrowArrays);
+            validateColumnNames(opts.FieldNames, numel(arrowArrays));
+            validElements = parseValid(opts, arrowArrays{1}.Length);
+
+            arrayProxyIDs = getArrayProxyIDs(arrowArrays);
+            args = struct(ArrayProxyIDs=arrayProxyIDs, ...
+                FieldNames=opts.FieldNames, Valid=validElements);
+            proxyName = "arrow.array.proxy.StructArray";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            array = arrow.array.StructArray(proxy);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/Time32Array.m b/matlab/src/matlab/+arrow/+array/Time32Array.m
index 85babd26a721a..ae40a3a0b740c 100644
--- a/matlab/src/matlab/+arrow/+array/Time32Array.m
+++ b/matlab/src/matlab/+arrow/+array/Time32Array.m
@@ -17,7 +17,7 @@
 
 classdef Time32Array < arrow.array.Array
 
-    properties(Access=private)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = seconds(NaN);
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/Time64Array.m b/matlab/src/matlab/+arrow/+array/Time64Array.m
index f85eeb1f8f0c9..cd4b948324272 100644
--- a/matlab/src/matlab/+arrow/+array/Time64Array.m
+++ b/matlab/src/matlab/+arrow/+array/Time64Array.m
@@ -17,7 +17,7 @@
 
 classdef Time64Array < arrow.array.Array
 
-    properties(Access=private)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = seconds(NaN);
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/TimestampArray.m b/matlab/src/matlab/+arrow/+array/TimestampArray.m
index 80198f965fe92..9289d0a099f7c 100644
--- a/matlab/src/matlab/+arrow/+array/TimestampArray.m
+++ b/matlab/src/matlab/+arrow/+array/TimestampArray.m
@@ -16,7 +16,7 @@
 classdef TimestampArray < arrow.array.Array
 % arrow.array.TimestampArray
     
-    properties(Access=private)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = NaT;
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/UInt16Array.m b/matlab/src/matlab/+arrow/+array/UInt16Array.m
index 9d3f33c279175..d5487ee130d93 100644
--- a/matlab/src/matlab/+arrow/+array/UInt16Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt16Array.m
@@ -16,7 +16,7 @@
 classdef UInt16Array < arrow.array.NumericArray
 % arrow.array.UInt16Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = uint16(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/UInt32Array.m b/matlab/src/matlab/+arrow/+array/UInt32Array.m
index 5235d4fb15576..43c1caac3b791 100644
--- a/matlab/src/matlab/+arrow/+array/UInt32Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt32Array.m
@@ -16,7 +16,7 @@
 classdef UInt32Array < arrow.array.NumericArray
 % arrow.array.UInt32Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = uint32(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/UInt64Array.m b/matlab/src/matlab/+arrow/+array/UInt64Array.m
index 2d69bd031ac31..047e7102dd5c5 100644
--- a/matlab/src/matlab/+arrow/+array/UInt64Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt64Array.m
@@ -16,7 +16,7 @@
 classdef UInt64Array < arrow.array.NumericArray
 % arrow.array.UInt64Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = uint64(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+array/UInt8Array.m b/matlab/src/matlab/+arrow/+array/UInt8Array.m
index 3d007376bc89a..901a003161220 100644
--- a/matlab/src/matlab/+arrow/+array/UInt8Array.m
+++ b/matlab/src/matlab/+arrow/+array/UInt8Array.m
@@ -16,7 +16,7 @@
 classdef UInt8Array < arrow.array.NumericArray
 % arrow.array.UInt8Array
 
-    properties (Access=protected)
+    properties (Hidden, GetAccess=public, SetAccess=private)
         NullSubstitutionValue = uint8(0)
     end
 
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index c0bedaf2faf39..d3a751ca46731 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -23,6 +23,10 @@
         opts.NumRows(1, 1) {mustBeFinite, mustBeNonnegative} = 3;  
     end
 
+    % Seed the random number generator to ensure
+    % reproducible results in tests.
+    rng(1);
+
     import arrow.type.ID
     import arrow.array.*
 
@@ -59,6 +63,13 @@
             matlabData{ii} = randomDatetimes(opts.NumRows);
             cmd = compose("%s.fromMATLAB(matlabData{ii})", name);
             arrowArrays{ii} = eval(cmd);
+        elseif name == "arrow.array.StructArray"
+            dates = randomDatetimes(opts.NumRows);
+            strings = randomStrings(opts.NumRows);
+            timestampArray = arrow.array(dates);
+            stringArray = arrow.array(strings);
+            arrowArrays{ii} = StructArray.fromArrays(timestampArray, stringArray);
+            matlabData{ii} = table(dates, strings, VariableNames=["Field1", "Field2"]);
         else
             error("arrow:test:SupportedArrayCase", ...
                 "Missing if-branch for array class " + name); 
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/parseValid.m b/matlab/src/matlab/+arrow/+internal/+validate/parseValid.m
new file mode 100644
index 0000000000000..3281e24ec1963
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+validate/parseValid.m
@@ -0,0 +1,46 @@
+%PARSEVALID Utility function for parsing the Valid name-value pair. 
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function validElements = parseValid(opts, numElements)
+    if ~isfield(opts, "Valid")
+        % If Valid is not a field in opts, return an empty logical array.
+        validElements = logical.empty(0, 1);
+        return;
+    end
+
+    valid = opts.Valid;
+    if islogical(valid)
+        validElements = reshape(valid, [], 1);
+        if ~isscalar(validElements)
+            % Verify the logical vector has the correct number of elements
+            validateattributes(validElements, "logical", {'numel', numElements});
+        elseif validElements == false
+            validElements = false(numElements, 1);
+        else % validElements == true
+            % Return an empty logical to represent all elements are valid. 
+            validElements = logical.empty(0, 1);
+        end
+    else
+        % valid is a list of indices. Verify the indices are numeric, 
+        % integers, and within the range [1, numElements]
+        validateattributes(valid, "numeric", {'integer', '>', 0, '<=', numElements});
+        % Create a logical vector that contains true values at the indices
+        % specified by opts.Valid.
+        validElements = false([numElements 1]);
+        validElements(valid) = true;
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m b/matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m
index 4081f4092740b..8a43dbb4d78e1 100644
--- a/matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m
+++ b/matlab/src/matlab/+arrow/+internal/+validate/parseValidElements.m
@@ -21,7 +21,7 @@
 % precedence over InferNulls.
 
     if isfield(opts, "Valid")
-        validElements = parseValid(numel(data), opts.Valid);
+        validElements = arrow.internal.validate.parseValid(opts, numel(data));
     else
         validElements = parseInferNulls(data, opts.InferNulls);
     end
@@ -33,29 +33,6 @@
     end
 end
 
-function validElements = parseValid(numElements, valid)
-    if islogical(valid)
-        validElements = reshape(valid, [], 1);
-        if ~isscalar(validElements)
-            % Verify the logical vector has the correct number of elements
-            validateattributes(validElements, "logical", {'numel', numElements});
-        elseif validElements == false
-            validElements = false(numElements, 1);
-        else % validElements == true
-            % Return an empty logical to represent all elements are valid. 
-            validElements = logical.empty(0, 1);
-        end
-    else
-        % valid is a list of indices. Verify the indices are numeric, 
-        % integers, and within the range 1 < indices < numElements.
-        validateattributes(valid, "numeric", {'integer', '>', 0, '<=', numElements});
-        % Create a logical vector that contains true values at the indices
-        % specified by opts.Valid.
-        validElements = false([numElements 1]);
-        validElements(valid) = true;
-    end
-end
-
 function validElements = parseInferNulls(data, inferNulls)
     if inferNulls && ~(isinteger(data) || islogical(data))
         % Only call ismissing on data types that have a "missing" value,
diff --git a/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
index a8ed98f8ae468..0f8b7b3a2a663 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
@@ -16,21 +16,18 @@
 classdef StructTraits < arrow.type.traits.TypeTraits
 
     properties (Constant)
-        % TODO: When arrow.array.StructArray is implemented, set these
-        % properties appropriately
-        ArrayConstructor = missing
-        ArrayClassName = missing
-        ArrayProxyClassName = missing
+        ArrayConstructor = @arrow.array.StructArray
+        ArrayClassName = "arrow.array.StructArray"
+        ArrayProxyClassName = "arrow.array.proxy.StructArray"
+
+        % TODO: Implement fromMATLAB
         ArrayStaticConstructor = missing
 
         TypeConstructor = @arrow.type.StructType
         TypeClassName = "arrow.type.StructType"
         TypeProxyClassName = "arrow.type.proxy.StructType"
-
-        % TODO: When arrow.array.StructArray is implemented, set these
-        % properties appropriately
-        MatlabConstructor = missing
-        MatlabClassName = missing
+        MatlabConstructor = @table
+        MatlabClassName = "table"
     end
 
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/StructType.m b/matlab/src/matlab/+arrow/+type/StructType.m
index 6c1318f6376f3..331ac75a2ee16 100644
--- a/matlab/src/matlab/+arrow/+type/StructType.m
+++ b/matlab/src/matlab/+arrow/+type/StructType.m
@@ -33,14 +33,28 @@
     end
 
     methods (Hidden)
-        % TODO: Consider using a mixin approach to add this behavior. For
-        % example, ChunkedArray's toMATLAB method could check if its 
-        % Type inherits from a mixin called "Preallocateable" (or something
-        % more descriptive). If so, we can call preallocateMATLABArray
-        % in the toMATLAB method.
-        function preallocateMATLABArray(~)
-            error("arrow:type:UnsupportedFunction", ...
-                "preallocateMATLABArray is not supported for StructType");
-        end
+        function data = preallocateMATLABArray(obj, numElements)
+            import arrow.tabular.internal.*
+
+            fields = obj.Fields;
+            
+            % Construct the VariableNames and VariableDimensionNames
+            fieldNames = [fields.Name];
+            validVariableNames = makeValidVariableNames(fieldNames);
+            validDimensionNames = makeValidDimensionNames(validVariableNames);
+
+            % Recursively call preallocateMATLABArray to handle
+            % preallocation of nested types
+            variableData = cell(1, numel(fields));
+            for ii = 1:numel(fields)
+                type = fields(ii).Type;
+                variableData{ii} = preallocateMATLABArray(type,  numElements);
+            end
+
+            % Return a table with the appropriate schema and dimensions 
+            data = table(variableData{:}, ...
+                VariableNames=validVariableNames, ...
+                DimensionNames=validDimensionNames);
+         end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/tStructArray.m b/matlab/test/arrow/array/tStructArray.m
new file mode 100644
index 0000000000000..639df65befbf5
--- /dev/null
+++ b/matlab/test/arrow/array/tStructArray.m
@@ -0,0 +1,277 @@
+%TSTRUCTARRAY Unit tests for arrow.array.StructArray
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tStructArray < matlab.unittest.TestCase
+
+    properties
+        Float64Array = arrow.array([1 NaN 3 4 5]);
+        StringArray = arrow.array(["A" "B" "C" "D" missing]);
+    end
+
+    methods (Test)
+        function Basic(tc)
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            tc.verifyInstanceOf(array, "arrow.array.StructArray");
+        end
+
+        function FieldNames(tc)
+            % Verify the FieldNames property is set to the expected value.
+            import arrow.array.StructArray
+
+            % Default field names used
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            tc.verifyEqual(array.FieldNames, ["Field1", "Field2"]);
+            
+            % Field names provided
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["A", "B"]);
+            tc.verifyEqual(array.FieldNames, ["A", "B"]);
+
+            % Duplicate field names provided
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["C", "C"]);
+            tc.verifyEqual(array.FieldNames, ["C", "C"]);
+        end
+
+        function FieldNamesError(tc)
+            % Verify the FieldNames nv-pair errors when expected.
+            import arrow.array.StructArray
+
+            % Wrong type provided
+            fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames={table table});
+            tc.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+            
+            % Wrong number of field names provided
+            fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames="A");
+            tc.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+
+             % Missing string provided
+            fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["A" missing]);
+            tc.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
+        end
+
+        function FieldNamesNoSetter(tc)
+            % Verify the FieldNames property is read-only. 
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            fcn = @() setfield(array, "FieldNames", ["A", "B"]);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function NumFields(tc)
+            % Verify the NumFields property is set to the expected value.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            tc.verifyEqual(array.NumFields, int32(2));
+        end
+
+         function NumFieldsNoSetter(tc)
+            % Verify the NumFields property is read-only.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            fcn = @() setfield(array, "NumFields", 10);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+         end
+
+         function Valid(tc)
+            % Verify the Valid property is set to the expected value.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            expectedValid = true([5 1]);
+            tc.verifyEqual(array.Valid, expectedValid);
+
+            % Supply the Valid nv-pair
+            valid = [true true false true false];
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, Valid=valid);
+            tc.verifyEqual(array.Valid, valid');
+         end
+
+         function ValidNVPairError(tc)
+            % Verify the Valid nv-pair errors when expected.
+            import arrow.array.StructArray
+
+            % Provided an invalid index
+            fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, Valid=10);
+            tc.verifyError(fcn, "MATLAB:notLessEqual");
+
+            % Provided a logical vector with more elements than the array
+            % length
+            fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, Valid=false([7 1]));
+            tc.verifyError(fcn, "MATLAB:incorrectNumel");
+         end
+
+        function ValidNoSetter(tc)
+            % Verify the Valid property is read-only.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            fcn = @() setfield(array, "Valid", false);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function Length(tc)
+            % Verify the Length property is set to the expected value.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            tc.verifyEqual(array.Length, int64(5));
+        end
+
+        function LengthNoSetter(tc)
+            % Verify the Length property is read-only.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            fcn = @() setfield(array, "Length", 1);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function Type(tc)
+            % Verify the Type property is set to the expected value.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            field1 = arrow.field("X", arrow.float64());
+            field2 = arrow.field("Y", arrow.string());
+            expectedType = arrow.struct(field1, field2);
+            tc.verifyEqual(array.Type, expectedType);
+        end
+
+        function TypeNoSetter(tc)
+            % Verify the Type property is read-only.
+            import arrow.array.StructArray
+
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+            fcn = @() setfield(array, "Type", tc.Float64Array.Type);
+            tc.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function FieldByIndex(tc)
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+
+            % Extract 1st field
+            field1 = array.field(1);
+            tc.verifyEqual(field1, tc.Float64Array);
+
+            % Extract 2nd field
+            field2 = array.field(2);
+            tc.verifyEqual(field2, tc.StringArray);
+        end
+
+        function FieldByIndexError(tc)
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+
+            % Supply a nonscalar vector
+            fcn = @() array.field([1 2]);
+            tc.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Supply a noninteger
+            fcn = @() array.field(1.1);
+            tc.verifyError(fcn, "arrow:badsubscript:NonInteger");
+        end
+
+        function FieldByName(tc)
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+
+            % Extract 1st field
+            field1 = array.field("Field1");
+            tc.verifyEqual(field1, tc.Float64Array);
+
+            % Extract 2nd field
+            field2 = array.field("Field2");
+            tc.verifyEqual(field2, tc.StringArray);
+        end
+
+        function FieldByNameError(tc)
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
+
+            % Supply a nonscalar string array
+            fcn = @() array.field(["Field1" "Field2"]);
+            tc.verifyError(fcn, "arrow:badsubscript:NonScalar");
+
+            % Supply a nonexistent field name
+            fcn = @() array.field("B");
+            tc.verifyError(fcn, "arrow:tabular:schema:AmbiguousFieldName");
+        end
+
+        function toMATLAB(tc)
+            % Verify toMATLAB returns the expected MATLAB table
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            expectedTable = table(toMATLAB(tc.Float64Array), toMATLAB(tc.StringArray), VariableNames=["X", "Y"]);
+            actualTable = toMATLAB(array);
+            tc.verifyEqual(actualTable, expectedTable);
+
+            % Verify table elements that correspond to "null" values 
+            % in the StructArray are set to the type-specific null values.
+            valid = [1 2 5];
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"], Valid=valid);
+            float64NullValue = tc.Float64Array.NullSubstitutionValue;
+            stringNullValue = tc.StringArray.NullSubstitutionValue;
+            expectedTable([3 4], :) = repmat({float64NullValue stringNullValue}, [2 1]);
+            actualTable = toMATLAB(array);
+            tc.verifyEqual(actualTable, expectedTable);
+        end
+
+        function table(tc)
+            % Verify toMATLAB returns the expected MATLAB table
+            import arrow.array.StructArray
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            expectedTable = table(toMATLAB(tc.Float64Array), toMATLAB(tc.StringArray), VariableNames=["X", "Y"]);
+            actualTable = table(array);
+            tc.verifyEqual(actualTable, expectedTable);
+
+            % Verify table elements that correspond to "null" values 
+            % in the StructArray are set to the type-specific null values.
+            valid = [1 2 5];
+            array = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"], Valid=valid);
+            float64NullValue = tc.Float64Array.NullSubstitutionValue;
+            stringNullValue = tc.StringArray.NullSubstitutionValue;
+            expectedTable([3 4], :) = repmat({float64NullValue stringNullValue}, [2 1]);
+            actualTable = toMATLAB(array);
+            tc.verifyEqual(actualTable, expectedTable);
+        end
+
+        function IsEqualTrue(tc)
+            % Verify isequal returns true when expected.
+            import arrow.array.StructArray
+            array1 = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            array2 = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            tc.verifyTrue(isequal(array1, array2));
+        end
+
+        function IsEqualFalse(tc)
+            % Verify isequal returns false when expected.
+            import arrow.array.StructArray
+            array1 = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["X", "Y"]);
+            array2 = StructArray.fromArrays(tc.StringArray, tc.Float64Array, FieldNames=["X", "Y"]);
+            array3 = StructArray.fromArrays(tc.Float64Array, tc.StringArray, FieldNames=["A", "B"]);
+            % StructArrays have the same FieldNames but the Fields have different types.
+            tc.verifyFalse(isequal(array1, array2));
+            % Fields of the StructArrays have the same types but the StructArrays have different FieldNames.
+            tc.verifyFalse(isequal(array1, array3));
+        end
+
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/tStructTraits.m b/matlab/test/arrow/type/traits/tStructTraits.m
index 6a97b1e1852d6..07833aca162b5 100644
--- a/matlab/test/arrow/type/traits/tStructTraits.m
+++ b/matlab/test/arrow/type/traits/tStructTraits.m
@@ -17,15 +17,15 @@
 
     properties
         TraitsConstructor = @arrow.type.traits.StructTraits 
-        ArrayConstructor = missing
-        ArrayClassName = missing
-        ArrayProxyClassName = missing
+        ArrayConstructor = @arrow.array.StructArray
+        ArrayClassName = "arrow.array.StructArray"
+        ArrayProxyClassName = "arrow.array.proxy.StructArray"
         ArrayStaticConstructor = missing
         TypeConstructor = @arrow.type.StructType
         TypeClassName = "arrow.type.StructType"
         TypeProxyClassName = "arrow.type.proxy.StructType"
-        MatlabConstructor = missing
-        MatlabClassName = missing
+        MatlabConstructor = @table
+        MatlabClassName = "table"
     end
 
 end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 294612dda370f..149a688b27e15 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -47,6 +47,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/timestamp_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time32_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time64_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/struct_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/chunked_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"

From 6eb08dd886e6dec691fae5704a3f7e9e89552ae4 Mon Sep 17 00:00:00 2001
From: Tim Schaub <tschaub@users.noreply.github.com>
Date: Wed, 20 Sep 2023 19:47:18 -0600
Subject: [PATCH 396/749] GH-35775: [Go][Parquet] Allow key value file metadata
 to be written after writing row groups (#37786)

### Rationale for this change

The key value file metadata may include information generated while writing row groups.  Currently, it is not possible to set the key value file metadata after creating a writer.  With the changes in this branch, key value pairs may be added any time before closing the writer.

### What changes are included in this PR?

This branch adds a `writer.AppendKeyValueMetadata(key, value)` method to the parquet `file.Writer` and to the `pqarrow.FileWriter`.

### Are these changes tested?

Tests are added for the new functionality.

### Are there any user-facing changes?

The `KeyValueMetadata` field on the parquet `file.Writer` has been renamed to `initialKeyValueMetadata`.  This is a breaking change.  Although the field was exported, setting it did not result in new key value metadata being written.  Instead, it represented the initial key value metadata if the writer was passed the `WithWriteMetadata` write option.

The `WithWriteMetadata` option can still be used to provide the initial key value metadata values.  In addition, the `AppendKeyValueMetadata` method can be called to add key value pairs after creating a writer.

The `FileMetadata` field on the parquet `file.Writer` has been removed.  Previously, setting this field value had no effect.

**This PR includes breaking changes to public APIs.**

The `KeyValueMetadata` field is no longer exported from the parquet `file.Writer` struct.  Use the `WithWriteMetadata` writer option to set key value metadata when creating a writer or use the `AppendKeyValueMetadata` method to add key value metadata after creating a writer.

The `FileMetadata` field on the parquet `file.Writer` has been removed.
* Closes: #35775

Authored-by: Tim Schaub <tim@planet.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/file/file_writer.go          | 62 +++++++++++++++----------
 go/parquet/file/file_writer_test.go     | 29 ++++++++++++
 go/parquet/metadata/file.go             |  5 ++
 go/parquet/metadata/metadata_test.go    | 35 ++++++++++++++
 go/parquet/pqarrow/encode_arrow_test.go | 45 ++++++++++++++++++
 go/parquet/pqarrow/file_writer.go       |  5 ++
 6 files changed, 156 insertions(+), 25 deletions(-)

diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index 64a21473c293a..c6289434bbe6e 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -41,23 +41,24 @@ type Writer struct {
 
 	// The Schema of this writer
 	Schema *schema.Schema
-	// The current FileMetadata to write
-	FileMetadata *metadata.FileMetaData
-	// The current keyvalue metadata
-	KeyValueMetadata metadata.KeyValueMetadata
 }
 
-type WriteOption func(*Writer)
+type writerConfig struct {
+	props            *parquet.WriterProperties
+	keyValueMetadata metadata.KeyValueMetadata
+}
+
+type WriteOption func(*writerConfig)
 
 func WithWriterProps(props *parquet.WriterProperties) WriteOption {
-	return func(w *Writer) {
-		w.props = props
+	return func(c *writerConfig) {
+		c.props = props
 	}
 }
 
 func WithWriteMetadata(meta metadata.KeyValueMetadata) WriteOption {
-	return func(w *Writer) {
-		w.KeyValueMetadata = meta
+	return func(c *writerConfig) {
+		c.keyValueMetadata = meta
 	}
 }
 
@@ -66,19 +67,23 @@ func WithWriteMetadata(meta metadata.KeyValueMetadata) WriteOption {
 // If props is nil, then the default Writer Properties will be used. If the key value metadata is not nil,
 // it will be added to the file.
 func NewParquetWriter(w io.Writer, sc *schema.GroupNode, opts ...WriteOption) *Writer {
+	config := &writerConfig{}
+	for _, o := range opts {
+		o(config)
+	}
+	if config.props == nil {
+		config.props = parquet.NewWriterProperties()
+	}
+
 	fileSchema := schema.NewSchema(sc)
 	fw := &Writer{
+		props:  config.props,
 		sink:   &utils.TellWrapper{Writer: w},
 		open:   true,
 		Schema: fileSchema,
 	}
-	for _, o := range opts {
-		o(fw)
-	}
-	if fw.props == nil {
-		fw.props = parquet.NewWriterProperties()
-	}
-	fw.metadata = *metadata.NewFileMetadataBuilder(fw.Schema, fw.props, fw.KeyValueMetadata)
+
+	fw.metadata = *metadata.NewFileMetadataBuilder(fw.Schema, fw.props, config.keyValueMetadata)
 	fw.startFile()
 	return fw
 }
@@ -154,6 +159,11 @@ func (fw *Writer) startFile() {
 	}
 }
 
+// AppendKeyValueMetadata appends a key/value pair to the existing key/value metadata
+func (fw *Writer) AppendKeyValueMetadata(key string, value string) error {
+	return fw.metadata.AppendKeyValueMetadata(key, value)
+}
+
 // Close closes any open row group writer and writes the file footer. Subsequent
 // calls to close will have no effect.
 func (fw *Writer) Close() (err error) {
@@ -180,11 +190,12 @@ func (fw *Writer) Close() (err error) {
 
 		fileEncryptProps := fw.props.FileEncryptionProperties()
 		if fileEncryptProps == nil { // non encrypted file
-			if fw.FileMetadata, err = fw.metadata.Finish(); err != nil {
+			fileMetadata, err := fw.metadata.Finish()
+			if err != nil {
 				return err
 			}
 
-			_, err = writeFileMetadata(fw.FileMetadata, fw.sink)
+			_, err = writeFileMetadata(fileMetadata, fw.sink)
 			return err
 		}
 
@@ -193,12 +204,12 @@ func (fw *Writer) Close() (err error) {
 	return nil
 }
 
-func (fw *Writer) closeEncryptedFile(props *parquet.FileEncryptionProperties) (err error) {
+func (fw *Writer) closeEncryptedFile(props *parquet.FileEncryptionProperties) error {
 	// encrypted file with encrypted footer
 	if props.EncryptedFooter() {
-		fw.FileMetadata, err = fw.metadata.Finish()
+		fileMetadata, err := fw.metadata.Finish()
 		if err != nil {
-			return
+			return err
 		}
 
 		footerLen := int64(0)
@@ -211,7 +222,7 @@ func (fw *Writer) closeEncryptedFile(props *parquet.FileEncryptionProperties) (e
 
 		footerLen += n
 		footerEncryptor := fw.fileEncryptor.GetFooterEncryptor()
-		n, err = writeEncryptedFileMetadata(fw.FileMetadata, fw.sink, footerEncryptor, true)
+		n, err = writeEncryptedFileMetadata(fileMetadata, fw.sink, footerEncryptor, true)
 		if err != nil {
 			return err
 		}
@@ -224,11 +235,12 @@ func (fw *Writer) closeEncryptedFile(props *parquet.FileEncryptionProperties) (e
 			return err
 		}
 	} else {
-		if fw.FileMetadata, err = fw.metadata.Finish(); err != nil {
-			return
+		fileMetadata, err := fw.metadata.Finish()
+		if err != nil {
+			return err
 		}
 		footerSigningEncryptor := fw.fileEncryptor.GetFooterSigningEncryptor()
-		if _, err = writeEncryptedFileMetadata(fw.FileMetadata, fw.sink, footerSigningEncryptor, false); err != nil {
+		if _, err = writeEncryptedFileMetadata(fileMetadata, fw.sink, footerSigningEncryptor, false); err != nil {
 			return err
 		}
 	}
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index 0cca1cd40d4c9..af083ebe60e4f 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -30,6 +30,7 @@ import (
 	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
 	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
 
@@ -371,6 +372,34 @@ func TestAllNulls(t *testing.T) {
 	assert.Equal(t, []int16{0, 0, 0}, defLevels[:])
 }
 
+func TestKeyValueMetadata(t *testing.T) {
+	fields := schema.FieldList{
+		schema.NewInt32Node("unused", parquet.Repetitions.Optional, -1),
+	}
+	sc, _ := schema.NewGroupNode("root", parquet.Repetitions.Required, fields, -1)
+	sink := encoding.NewBufferWriter(0, memory.DefaultAllocator)
+
+	writer := file.NewParquetWriter(sink, sc)
+
+	testKey := "testKey"
+	testValue := "testValue"
+	writer.AppendKeyValueMetadata(testKey, testValue)
+	writer.Close()
+
+	buffer := sink.Finish()
+	defer buffer.Release()
+	props := parquet.NewReaderProperties(memory.DefaultAllocator)
+	props.BufferedStreamEnabled = true
+
+	reader, err := file.NewParquetReader(bytes.NewReader(buffer.Bytes()), file.WithReadProps(props))
+	assert.NoError(t, err)
+
+	metadata := reader.MetaData()
+	got := metadata.KeyValueMetadata().FindValue(testKey)
+	require.NotNil(t, got)
+	assert.Equal(t, testValue, *got)
+}
+
 func createSerializeTestSuite(typ reflect.Type) suite.TestingSuite {
 	return &SerializeTestSuite{PrimitiveTypedTest: testutils.NewPrimitiveTypedTest(typ)}
 }
diff --git a/go/parquet/metadata/file.go b/go/parquet/metadata/file.go
index efe3c01c25b33..dddd95c5df670 100644
--- a/go/parquet/metadata/file.go
+++ b/go/parquet/metadata/file.go
@@ -95,6 +95,11 @@ func (f *FileMetaDataBuilder) AppendRowGroup() *RowGroupMetaDataBuilder {
 	return f.currentRgBldr
 }
 
+// AppendKeyValueMetadata appends a key/value pair to the existing key/value metadata
+func (f *FileMetaDataBuilder) AppendKeyValueMetadata(key string, value string) error {
+	return f.kvmeta.Append(key, value)
+}
+
 // Finish will finalize the metadata of the number of rows, row groups,
 // version etc. This will clear out this filemetadatabuilder so it can
 // be re-used
diff --git a/go/parquet/metadata/metadata_test.go b/go/parquet/metadata/metadata_test.go
index 0db64d88ab0f4..b685dd2223274 100644
--- a/go/parquet/metadata/metadata_test.go
+++ b/go/parquet/metadata/metadata_test.go
@@ -272,6 +272,41 @@ func TestKeyValueMetadata(t *testing.T) {
 	assert.True(t, faccessor.KeyValueMetadata().Equals(kvmeta))
 }
 
+func TestKeyValueMetadataAppend(t *testing.T) {
+	props := parquet.NewWriterProperties(parquet.WithVersion(parquet.V1_0))
+
+	fields := schema.FieldList{
+		schema.NewInt32Node("int_col", parquet.Repetitions.Required, -1),
+		schema.NewFloat32Node("float_col", parquet.Repetitions.Required, -1),
+	}
+	root, err := schema.NewGroupNode("schema", parquet.Repetitions.Repeated, fields, -1)
+	require.NoError(t, err)
+	schema := schema.NewSchema(root)
+
+	kvmeta := metadata.NewKeyValueMetadata()
+	key1 := "test_key1"
+	value1 := "test_value1"
+	require.NoError(t, kvmeta.Append(key1, value1))
+
+	fbuilder := metadata.NewFileMetadataBuilder(schema, props, kvmeta)
+
+	key2 := "test_key2"
+	value2 := "test_value2"
+	require.NoError(t, fbuilder.AppendKeyValueMetadata(key2, value2))
+	faccessor, err := fbuilder.Finish()
+	require.NoError(t, err)
+
+	kv := faccessor.KeyValueMetadata()
+
+	got1 := kv.FindValue(key1)
+	require.NotNil(t, got1)
+	assert.Equal(t, value1, *got1)
+
+	got2 := kv.FindValue(key2)
+	require.NotNil(t, got2)
+	assert.Equal(t, value2, *got2)
+}
+
 func TestApplicationVersion(t *testing.T) {
 	version := metadata.NewAppVersion("parquet-mr version 1.7.9")
 	version1 := metadata.NewAppVersion("parquet-mr version 1.8.0")
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 654d3d813cf85..3c20cf2d4757b 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -360,6 +360,51 @@ func simpleRoundTrip(t *testing.T, tbl arrow.Table, rowGroupSize int64) {
 	}
 }
 
+func TestWriteKeyValueMetadata(t *testing.T) {
+	kv := map[string]string{
+		"key1": "value1",
+		"key2": "value2",
+		"key3": "value3",
+	}
+
+	sc := arrow.NewSchema([]arrow.Field{
+		{Name: "int32", Type: arrow.PrimitiveTypes.Int32, Nullable: true},
+	}, nil)
+	bldr := array.NewRecordBuilder(memory.DefaultAllocator, sc)
+	defer bldr.Release()
+	for _, b := range bldr.Fields() {
+		b.AppendNull()
+	}
+
+	rec := bldr.NewRecord()
+	defer rec.Release()
+
+	props := parquet.NewWriterProperties(
+		parquet.WithVersion(parquet.V1_0),
+	)
+	var buf bytes.Buffer
+	fw, err := pqarrow.NewFileWriter(sc, &buf, props, pqarrow.DefaultWriterProps())
+	require.NoError(t, err)
+	err = fw.Write(rec)
+	require.NoError(t, err)
+
+	for key, value := range kv {
+		require.NoError(t, fw.AppendKeyValueMetadata(key, value))
+	}
+
+	err = fw.Close()
+	require.NoError(t, err)
+
+	reader, err := file.NewParquetReader(bytes.NewReader(buf.Bytes()))
+	require.NoError(t, err)
+
+	for key, value := range kv {
+		got := reader.MetaData().KeyValueMetadata().FindValue(key)
+		require.NotNil(t, got)
+		assert.Equal(t, value, *got)
+	}
+}
+
 func TestWriteEmptyLists(t *testing.T) {
 	sc := arrow.NewSchema([]arrow.Field{
 		{Name: "f1", Type: arrow.ListOf(arrow.FixedWidthTypes.Date32)},
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index 052220e716c77..aa0bae7b1fdfb 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -272,6 +272,11 @@ func (fw *FileWriter) WriteTable(tbl arrow.Table, chunkSize int64) error {
 	return nil
 }
 
+// AppendKeyValueMetadata appends a key/value pair to the existing key/value metadata
+func (fw *FileWriter) AppendKeyValueMetadata(key string, value string) error {
+	return fw.wr.AppendKeyValueMetadata(key, value)
+}
+
 // Close flushes out the data and closes the file. It can be called multiple times,
 // subsequent calls after the first will have no effect.
 func (fw *FileWriter) Close() error {

From 6cd34f3cc4a5b75b51cab926348c6c7fc6172955 Mon Sep 17 00:00:00 2001
From: Chris Jordan-Squire <788080+chrisjordansquire@users.noreply.github.com>
Date: Wed, 20 Sep 2023 23:48:54 -0400
Subject: [PATCH 397/749] GH-35095: [C++] Prevent write after close in
 arrow::ipc::IpcFormatWriter (#37783)

This addresses GH-35095 by adding a flag to IpcFormatWriter to track when a writer has been closed, and check this flag before writes.

### Rationale for this change

This addresses #35095 , preventing stream and file IPC writers from writing record batches once the IPC writer has been closed.

### What changes are included in this PR?

Adding a flag so that an IpcFormatWriter to track when it's been closed, a check before writes in IpcFormatWriter, and two tests to confirm it works as expected.

### Are these changes tested?

Yes, the changes are tested. The two tests were added, and the C++ test suite ran. No unexpected failures appeared.

### Are there any user-facing changes?

Other than newly returning an invalid status when writing after close, no, there should not be any user-facing changes.

* Closes: #35095

Lead-authored-by: Chris Jordan-Squire <chris.jordansquire@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/ipc/read_write_test.cc | 19 +++++++++++++++++++
 cpp/src/arrow/ipc/writer.cc          |  8 +++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 69b827b8fe78d..3ae007c20efe7 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -1519,6 +1519,22 @@ class ReaderWriterMixin : public ExtensionTypesMixin {
     }
   }
 
+  void TestWriteAfterClose() {
+    // Part of GH-35095.
+    std::shared_ptr<RecordBatch> batch_ints;
+    ASSERT_OK(MakeIntRecordBatch(&batch_ints));
+
+    auto schema = batch_ints->schema();
+
+    WriterHelper writer_helper;
+    ASSERT_OK(writer_helper.Init(schema, IpcWriteOptions::Defaults()));
+    ASSERT_OK(writer_helper.WriteBatch(batch_ints));
+    ASSERT_OK(writer_helper.Finish());
+
+    // Write after close raises status
+    ASSERT_RAISES(Invalid, writer_helper.WriteBatch(batch_ints));
+  }
+
   void TestWriteDifferentSchema() {
     // Test writing batches with a different schema than the RecordBatchWriter
     // was initialized with.
@@ -1991,6 +2007,9 @@ TEST_F(TestFileFormatGenerator, DictionaryRoundTrip) { TestDictionaryRoundtrip()
 TEST_F(TestFileFormatGeneratorCoalesced, DictionaryRoundTrip) {
   TestDictionaryRoundtrip();
 }
+TEST_F(TestFileFormat, WriteAfterClose) { TestWriteAfterClose(); }
+
+TEST_F(TestStreamFormat, WriteAfterClose) { TestWriteAfterClose(); }
 
 TEST_F(TestStreamFormat, DifferentSchema) { TestWriteDifferentSchema(); }
 
diff --git a/cpp/src/arrow/ipc/writer.cc b/cpp/src/arrow/ipc/writer.cc
index 1d230601566a0..e4b49ed56464e 100644
--- a/cpp/src/arrow/ipc/writer.cc
+++ b/cpp/src/arrow/ipc/writer.cc
@@ -1070,6 +1070,9 @@ class ARROW_EXPORT IpcFormatWriter : public RecordBatchWriter {
   Status WriteRecordBatch(
       const RecordBatch& batch,
       const std::shared_ptr<const KeyValueMetadata>& custom_metadata) override {
+    if (closed_) {
+      return Status::Invalid("Destination already closed");
+    }
     if (!batch.schema()->Equals(schema_, false /* check_metadata */)) {
       return Status::Invalid("Tried to write record batch with different schema");
     }
@@ -1101,7 +1104,9 @@ class ARROW_EXPORT IpcFormatWriter : public RecordBatchWriter {
 
   Status Close() override {
     RETURN_NOT_OK(CheckStarted());
-    return payload_writer_->Close();
+    RETURN_NOT_OK(payload_writer_->Close());
+    closed_ = true;
+    return Status::OK();
   }
 
   Status Start() {
@@ -1213,6 +1218,7 @@ class ARROW_EXPORT IpcFormatWriter : public RecordBatchWriter {
   std::unordered_map<int64_t, std::shared_ptr<Array>> last_dictionaries_;
 
   bool started_ = false;
+  bool closed_ = false;
   IpcWriteOptions options_;
   WriteStats stats_;
 };

From 79e49dbfb71efc70555417ba19cb612eb50924e8 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 21 Sep 2023 11:32:06 +0200
Subject: [PATCH 398/749] GH-37803: [CI][Dev][Python] Release and merge script
 errors (#37819)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### What changes are included in this PR?

Pin the version of `setuptools_scm` to `<8.0.0`.
* Closes: #37803

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 ci/conda_env_archery.txt                    | 2 +-
 ci/conda_env_crossbow.txt                   | 2 +-
 ci/conda_env_python.txt                     | 2 +-
 dev/archery/setup.py                        | 2 +-
 dev/tasks/conda-recipes/arrow-cpp/meta.yaml | 4 ++--
 python/pyproject.toml                       | 2 +-
 python/requirements-build.txt               | 2 +-
 python/requirements-wheel-build.txt         | 2 +-
 python/setup.py                             | 2 +-
 9 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/ci/conda_env_archery.txt b/ci/conda_env_archery.txt
index ace7a42acb026..40875e0a55039 100644
--- a/ci/conda_env_archery.txt
+++ b/ci/conda_env_archery.txt
@@ -25,7 +25,7 @@ jira
 pygit2
 pygithub
 ruamel.yaml
-setuptools_scm
+setuptools_scm<8.0.0
 toolz
 
 # benchmark
diff --git a/ci/conda_env_crossbow.txt b/ci/conda_env_crossbow.txt
index 347294650ca28..59b799720f12b 100644
--- a/ci/conda_env_crossbow.txt
+++ b/ci/conda_env_crossbow.txt
@@ -21,5 +21,5 @@ jinja2
 jira
 pygit2
 ruamel.yaml
-setuptools_scm
+setuptools_scm<8.0.0
 toolz
diff --git a/ci/conda_env_python.txt b/ci/conda_env_python.txt
index 4ae5c3614a1dc..d914229ec58c0 100644
--- a/ci/conda_env_python.txt
+++ b/ci/conda_env_python.txt
@@ -28,4 +28,4 @@ pytest-faulthandler
 pytest-lazy-fixture
 s3fs>=2021.8.0
 setuptools
-setuptools_scm
+setuptools_scm<8.0.0
diff --git a/dev/archery/setup.py b/dev/archery/setup.py
index 08e41225f673a..e2c89ae204bd6 100755
--- a/dev/archery/setup.py
+++ b/dev/archery/setup.py
@@ -30,7 +30,7 @@
 extras = {
     'benchmark': ['pandas'],
     'crossbow': ['github3.py', jinja_req, 'pygit2>=1.6.0', 'requests',
-                 'ruamel.yaml', 'setuptools_scm'],
+                 'ruamel.yaml', 'setuptools_scm<8.0.0'],
     'crossbow-upload': ['github3.py', jinja_req, 'ruamel.yaml',
                         'setuptools_scm'],
     'docker': ['ruamel.yaml', 'python-dotenv'],
diff --git a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
index ac4b29eb5ee7e..fbe40af3dae01 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
+++ b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
@@ -244,7 +244,7 @@ outputs:
         - numpy
         - python
         - setuptools
-        - setuptools_scm
+        - setuptools_scm <8.0.0
       run:
         # - {{ pin_subpackage('libarrow', exact=True) }}
         - libarrow ={{ version }}=*_{{ PKG_BUILDNUM }}_{{ build_ext }}
@@ -327,7 +327,7 @@ outputs:
         - numpy
         - python
         - setuptools
-        - setuptools_scm
+        - setuptools_scm <8.0.0
       run:
         - {{ pin_subpackage('pyarrow', exact=True) }}
         - python
diff --git a/python/pyproject.toml b/python/pyproject.toml
index 7e61304585809..a1de6ac4f1c7e 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -19,7 +19,7 @@
 requires = [
     "cython >= 0.29.31,<3",
     "oldest-supported-numpy>=0.14",
-    "setuptools_scm",
+    "setuptools_scm < 8.0.0",
     "setuptools >= 40.1.0",
     "wheel"
 ]
diff --git a/python/requirements-build.txt b/python/requirements-build.txt
index 6378d1b94e1bb..efd653ec470d5 100644
--- a/python/requirements-build.txt
+++ b/python/requirements-build.txt
@@ -1,4 +1,4 @@
 cython>=0.29.31,<3
 oldest-supported-numpy>=0.14
-setuptools_scm
+setuptools_scm<8.0.0
 setuptools>=38.6.0
diff --git a/python/requirements-wheel-build.txt b/python/requirements-wheel-build.txt
index e4f5243fbc2fe..00504b0c731a1 100644
--- a/python/requirements-wheel-build.txt
+++ b/python/requirements-wheel-build.txt
@@ -1,5 +1,5 @@
 cython>=0.29.31,<3
 oldest-supported-numpy>=0.14
-setuptools_scm
+setuptools_scm<8.0.0
 setuptools>=58
 wheel
diff --git a/python/setup.py b/python/setup.py
index abd9d03cfb17e..062aac307b1e4 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -492,7 +492,7 @@ def has_ext_modules(foo):
                                  'pyarrow/_generated_version.py'),
         'version_scheme': guess_next_dev_version
     },
-    setup_requires=['setuptools_scm', 'cython >= 0.29.31,<3'] + setup_requires,
+    setup_requires=['setuptools_scm < 8.0.0', 'cython >= 0.29.31,<3'] + setup_requires,
     install_requires=install_requires,
     tests_require=['pytest', 'pandas', 'hypothesis'],
     python_requires='>=3.8',

From 9d6d501fb654a93496070b59fbe7f36f4f1ed604 Mon Sep 17 00:00:00 2001
From: Benjamin Kietzman <bengilgit@gmail.com>
Date: Thu, 21 Sep 2023 08:00:57 -0400
Subject: [PATCH 399/749] GH-35627: [Format][Integration] Add string-view to
 arrow format (#37526)

String view (and equivalent non-utf8 binary view) is an alternative representation for
variable length strings which offers greater efficiency for several common operations.
This representation is in use by UmbraDB, DuckDB, and Velox. Where those databases use
a raw pointer to out-of-line strings this PR uses a pair of 32 bit integers as a
buffer index and offset, which

-   makes explicit the guarantee that lifetime of all character data is equal
    to that of the array which views it, which is critical for confident
    consumption across an interface boundary
-   makes the arrays meaningfully serializable and
    venue agnostic; directly usable in shared memory without modification
-   allows easy validation

This PR is extracted from https://github.com/apache/arrow/pull/35628 to unblock independent PRs now that the vote has passed, including:

-   New types added to Schema.fbs
-   Message.fbs amended to support variable buffer counts between string view chunks
-   datagen.py extended to produce integration JSON for string view arrays
-   Columnar.rst amended with a description of the string view format

* Closes: #35627

Authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 dev/archery/archery/integration/datagen.py | 105 +++++++++++++++++++
 docs/source/format/Columnar.rst            | 112 ++++++++++++++++++---
 format/Message.fbs                         |  16 +++
 format/Schema.fbs                          |  24 +++++
 4 files changed, 243 insertions(+), 14 deletions(-)

diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 53f7ba58bff99..5ac32da56a8de 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -665,6 +665,26 @@ def _get_type(self):
         return OrderedDict([('name', 'largeutf8')])
 
 
+class BinaryViewField(BinaryField):
+
+    @property
+    def column_class(self):
+        return BinaryViewColumn
+
+    def _get_type(self):
+        return OrderedDict([('name', 'binaryview')])
+
+
+class StringViewField(StringField):
+
+    @property
+    def column_class(self):
+        return StringViewColumn
+
+    def _get_type(self):
+        return OrderedDict([('name', 'utf8view')])
+
+
 class Schema(object):
 
     def __init__(self, fields, metadata=None):
@@ -744,6 +764,74 @@ class LargeStringColumn(_BaseStringColumn, _LargeOffsetsMixin):
     pass
 
 
+class BinaryViewColumn(PrimitiveColumn):
+
+    def _encode_value(self, x):
+        return frombytes(binascii.hexlify(x).upper())
+
+    def _get_buffers(self):
+        views = []
+        data_buffers = []
+        # a small default data buffer size is used so we can exercise
+        # arrays with multiple data buffers with small data sets
+        DEFAULT_BUFFER_SIZE = 32
+        INLINE_SIZE = 12
+
+        for i, v in enumerate(self.values):
+            if not self.is_valid[i]:
+                v = b''
+            assert isinstance(v, bytes)
+
+            if len(v) <= INLINE_SIZE:
+                # Append an inline view, skip data buffer management.
+                views.append(OrderedDict([
+                    ('SIZE', len(v)),
+                    ('INLINED', self._encode_value(v)),
+                ]))
+                continue
+
+            if len(data_buffers) == 0:
+                # No data buffers have been added yet;
+                # add this string whole (we may append to it later).
+                offset = 0
+                data_buffers.append(v)
+            elif len(data_buffers[-1]) + len(v) > DEFAULT_BUFFER_SIZE:
+                # Appending this string to the current active data buffer
+                # would overflow the default buffer size; add it whole.
+                offset = 0
+                data_buffers.append(v)
+            else:
+                # Append this string to the current active data buffer.
+                offset = len(data_buffers[-1])
+                data_buffers[-1] += v
+
+            # the prefix is always 4 bytes so it may not be utf-8
+            # even if the whole string view is
+            prefix = frombytes(binascii.hexlify(v[:4]).upper())
+
+            views.append(OrderedDict([
+                ('SIZE', len(v)),
+                ('PREFIX_HEX', prefix),
+                ('BUFFER_INDEX', len(data_buffers) - 1),
+                ('OFFSET', offset),
+            ]))
+
+        return [
+            ('VALIDITY', [int(x) for x in self.is_valid]),
+            ('VIEWS', views),
+            ('VARIADIC_DATA_BUFFERS', [
+                frombytes(binascii.hexlify(b).upper())
+                for b in data_buffers
+            ]),
+        ]
+
+
+class StringViewColumn(BinaryViewColumn):
+
+    def _encode_value(self, x):
+        return frombytes(x)
+
+
 class FixedSizeBinaryColumn(PrimitiveColumn):
 
     def _encode_value(self, x):
@@ -1568,6 +1656,15 @@ def generate_run_end_encoded_case():
     return _generate_file("run_end_encoded", fields, batch_sizes)
 
 
+def generate_binary_view_case():
+    fields = [
+        BinaryViewField('bv'),
+        StringViewField('sv'),
+    ]
+    batch_sizes = [0, 7, 256]
+    return _generate_file("binary_view", fields, batch_sizes)
+
+
 def generate_nested_large_offsets_case():
     fields = [
         LargeListField('large_list_nullable', get_field('item', 'int32')),
@@ -1763,6 +1860,14 @@ def _temp_path():
         .skip_tester('JS')
         .skip_tester('Rust'),
 
+        generate_binary_view_case()
+        .skip_tester('C++')
+        .skip_tester('C#')
+        .skip_tester('Go')
+        .skip_tester('Java')
+        .skip_tester('JS')
+        .skip_tester('Rust'),
+
         generate_extension_case()
         .skip_tester('C#')
         # TODO: ensure the extension is registered in the C++ entrypoint
diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst
index 3390f1b7b5f2c..afbe2a08ee28c 100644
--- a/docs/source/format/Columnar.rst
+++ b/docs/source/format/Columnar.rst
@@ -21,7 +21,7 @@
 Arrow Columnar Format
 *********************
 
-*Version: 1.3*
+*Version: 1.4*
 
 The "Arrow Columnar Format" includes a language-agnostic in-memory
 data structure specification, metadata serialization, and a protocol
@@ -108,6 +108,10 @@ the different physical layouts defined by Arrow:
 * **Variable-size Binary**: a sequence of values each having a variable
   byte length. Two variants of this layout are supported using 32-bit
   and 64-bit length encoding.
+* **Views of Variable-size Binary**: a sequence of values each having a
+  variable byte length. In contrast to Variable-size Binary, the values
+  of this layout are distributed across potentially multiple buffers
+  instead of densely and sequentially packed in a single buffer.
 * **Fixed-size List**: a nested layout where each value has the same
   number of elements taken from a child data type.
 * **Variable-size List**: a nested layout where each value is a
@@ -350,6 +354,51 @@ will be represented as follows: ::
     |----------------|-----------------------|
     | joemark        | unspecified (padding) |
 
+Variable-size Binary View Layout
+--------------------------------
+
+.. versionadded:: Arrow Columnar Format 1.4
+
+Each value in this layout consists of 0 or more bytes. These bytes'
+locations are indicated using a **views** buffer, which may point to one
+of potentially several **data** buffers or may contain the characters
+inline.
+
+The views buffer contains `length` view structures with the following layout:
+
+::
+
+    * Short strings, length <= 12
+      | Bytes 0-3  | Bytes 4-15                            |
+      |------------|---------------------------------------|
+      | length     | data (padded with 0)                  |
+
+    * Long strings, length > 12
+      | Bytes 0-3  | Bytes 4-7  | Bytes 8-11 | Bytes 12-15 |
+      |------------|------------|------------|-------------|
+      | length     | prefix     | buf. index | offset      |
+
+In both the long and short string cases, the first four bytes encode the
+length of the string and can be used to determine how the rest of the view
+should be interpreted.
+
+In the short string case the string's bytes are inlined- stored inside the
+view itself, in the twelve bytes which follow the length.
+
+In the long string case, a buffer index indicates which data buffer
+stores the data bytes and an offset indicates where in that buffer the
+data bytes begin. Buffer index 0 refers to the first data buffer, IE
+the first buffer **after** the validity buffer and the views buffer.
+The half-open range ``[offset, offset + length)`` must be entirely contained
+within the indicated buffer. A copy of the first four bytes of the string is
+stored inline in the prefix, after the length. This prefix enables a
+profitable fast path for string comparisons, which are frequently determined
+within the first four bytes.
+
+All integers (length, buffer index, and offset) are signed.
+
+This layout is adapted from TU Munich's `UmbraDB`_.
+
 .. _variable-size-list-layout:
 
 Variable-size List Layout
@@ -880,19 +929,20 @@ For the avoidance of ambiguity, we provide listing the order and type
 of memory buffers for each layout.
 
 .. csv-table:: Buffer Layouts
-   :header: "Layout Type", "Buffer 0", "Buffer 1", "Buffer 2"
-   :widths: 30, 20, 20, 20
-
-   "Primitive",validity,data,
-   "Variable Binary",validity,offsets,data
-   "List",validity,offsets,
-   "Fixed-size List",validity,,
-   "Struct",validity,,
-   "Sparse Union",type ids,,
-   "Dense Union",type ids,offsets,
-   "Null",,,
-   "Dictionary-encoded",validity,data (indices),
-   "Run-end encoded",,,
+   :header: "Layout Type", "Buffer 0", "Buffer 1", "Buffer 2", "Variadic Buffers"
+   :widths: 30, 20, 20, 20, 20
+
+   "Primitive",validity,data,,
+   "Variable Binary",validity,offsets,data,
+   "Variable Binary View",validity,views,,data
+   "List",validity,offsets,,
+   "Fixed-size List",validity,,,
+   "Struct",validity,,,
+   "Sparse Union",type ids,,,
+   "Dense Union",type ids,offsets,,
+   "Null",,,,
+   "Dictionary-encoded",validity,data (indices),,
+   "Run-end encoded",,,,
 
 Logical Types
 =============
@@ -1071,6 +1121,39 @@ bytes. Since this metadata can be used to communicate in-memory pointer
 addresses between libraries, it is recommended to set ``size`` to the actual
 memory size rather than the padded size.
 
+Variadic buffers
+^^^^^^^^^^^^^^^^
+
+Some types such as Utf8View are represented using a variable number of buffers.
+For each such Field in the pre-ordered flattened logical schema, there will be
+an entry in ``variadicBufferCounts`` to indicate the number of variadic buffers
+which belong to that Field in the current RecordBatch.
+
+For example, consider the schema ::
+
+    col1: Struct<a: Int32, b: BinaryView, c: Float64>
+    col2: Utf8View
+
+This has two fields with variadic buffers, so ``variadicBufferCounts`` will
+have two entries in each RecordBatch. For a RecordBatch of this schema with
+``variadicBufferCounts = [3, 2]``, the flattened buffers would be::
+
+    buffer 0:  col1    validity
+    buffer 1:  col1.a  validity
+    buffer 2:  col1.a  values
+    buffer 3:  col1.b  validity
+    buffer 4:  col1.b  views
+    buffer 5:  col1.b  data
+    buffer 6:  col1.b  data
+    buffer 7:  col1.b  data
+    buffer 8:  col1.c  validity
+    buffer 9:  col1.c  values
+    buffer 10: col2    validity
+    buffer 11: col2    views
+    buffer 12: col2    data
+    buffer 13: col2    data
+
+
 Byte Order (`Endianness`_)
 ---------------------------
 
@@ -1346,3 +1429,4 @@ the Arrow spec.
 .. _Endianness: https://en.wikipedia.org/wiki/Endianness
 .. _SIMD: https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-introduction-to-the-simd-data-layout-templates
 .. _Parquet: https://parquet.apache.org/docs/
+.. _UmbraDB: https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf
diff --git a/format/Message.fbs b/format/Message.fbs
index 170ea8fbced89..92a629f3f9d95 100644
--- a/format/Message.fbs
+++ b/format/Message.fbs
@@ -99,6 +99,22 @@ table RecordBatch {
 
   /// Optional compression of the message body
   compression: BodyCompression;
+
+  /// Some types such as Utf8View are represented using a variable number of buffers.
+  /// For each such Field in the pre-ordered flattened logical schema, there will be
+  /// an entry in variadicBufferCounts to indicate the number of number of variadic
+  /// buffers which belong to that Field in the current RecordBatch.
+  ///
+  /// For example, the schema
+  ///     col1: Struct<a: Int32, b: BinaryView, c: Float64>
+  ///     col2: Utf8View
+  /// contains two Fields with variadic buffers so variadicBufferCounts will have
+  /// two entries, the first counting the variadic buffers of `col1.b` and the
+  /// second counting `col2`'s.
+  ///
+  /// This field may be omitted if and only if the schema contains no Fields with
+  /// a variable number of buffers, such as BinaryView and Utf8View.
+  variadicBufferCounts: [long];
 }
 
 /// For sending dictionary encoding information. Any Field can be
diff --git a/format/Schema.fbs b/format/Schema.fbs
index ce29c25b7d1c8..fdaf623931760 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -22,6 +22,7 @@
 /// Version 1.1 - Add Decimal256.
 /// Version 1.2 - Add Interval MONTH_DAY_NANO.
 /// Version 1.3 - Add Run-End Encoded.
+/// Version 1.4 - Add BinaryView, Utf8View, and variadicBufferCounts.
 
 namespace org.apache.arrow.flatbuf;
 
@@ -171,6 +172,27 @@ table LargeUtf8 {
 table LargeBinary {
 }
 
+/// Logically the same as Utf8, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+table Utf8View {
+}
+
+/// Logically the same as Binary, but the internal representation uses a header
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+table BinaryView {
+}
+
+
 table FixedSizeBinary {
   /// Number of bytes per value
   byteWidth: int;
@@ -427,6 +449,8 @@ union Type {
   LargeUtf8,
   LargeList,
   RunEndEncoded,
+  BinaryView,
+  Utf8View,
 }
 
 /// ----------------------------------------------------------------------

From e83c23bb86156ef32d073c8eb507d601847350e1 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 21 Sep 2023 11:06:38 -0400
Subject: [PATCH 400/749] GH-36730: [Python] Add support for Cython 3.0.0
 (#37097)

### Rationale for this change

Cython 3.0.0 is the latest release. PyArrow should work with Cython 3.0.0. **Cython 3 is not enabled in this diff.**

### What changes are included in this PR?

* Don't use `vector[XXX]&&`
* Add a declaration for `postincrement`
  * See also: https://cython.readthedocs.io/en/latest/src/userguide/migrating_to_cy30.html#c-postincrement-postdecrement-operator
* Ignore `C4551` warning (function call missing argument list) with MSVC
  * See also: https://github.com/cython/cython/issues/4445
* Add missing `const` to `CLocation`'s static methods.
* Don't use `StopIteration` to stop generator
  * See also: https://cython.readthedocs.io/en/latest/src/userguide/migrating_to_cy30.html#python-3-syntax-semantics
* non-extern `cdef` functions will now propagate python exceptions automatically unless explicitly labeled `noexcept`
* Function binding in cython is now enabled by default. Class methods that are used as wrappers for pickling should be converted to staticmethods.
* Numpydocs now validates more Cython 3 objects than Cython <3
  * Enum types are now being validated, and some unhelpful validation checks on Enums are now ignored
* Added a cython <3 nightly CI job

Note:
* Cython 3.0.0, 3.0.1, 3.0.2 has an issue when compiling with debug mode https://github.com/cython/cython/issues/5552

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.

* Closes: #36730

Lead-authored-by: Dane Pitkin <dane@voltrondata.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 ci/docker/conda-python-cython2.dockerfile   | 24 +++++++++++++++++
 dev/archery/archery/lang/python.py          |  9 +++++++
 dev/tasks/tasks.yml                         |  8 ++++++
 docker-compose.yml                          | 25 ++++++++++++++++++
 python/CMakeLists.txt                       | 29 +++++++++++++--------
 python/pyarrow/_dataset.pyx                 |  3 ++-
 python/pyarrow/_flight.pyx                  | 10 ++++---
 python/pyarrow/_substrait.pyx               |  3 ++-
 python/pyarrow/includes/libarrow_flight.pxd | 15 +++++++----
 python/pyarrow/ipc.pxi                      | 15 ++++++-----
 python/pyarrow/scalar.pxi                   |  4 +--
 python/pyarrow/tests/test_dataset.py        |  6 ++++-
 python/pyarrow/tests/test_scalars.py        |  4 +++
 13 files changed, 124 insertions(+), 31 deletions(-)
 create mode 100644 ci/docker/conda-python-cython2.dockerfile

diff --git a/ci/docker/conda-python-cython2.dockerfile b/ci/docker/conda-python-cython2.dockerfile
new file mode 100644
index 0000000000000..d67ef677276c7
--- /dev/null
+++ b/ci/docker/conda-python-cython2.dockerfile
@@ -0,0 +1,24 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+ARG repo
+ARG arch
+ARG python=3.8
+FROM ${repo}:${arch}-conda-python-${python}
+
+RUN mamba install -q -y "cython<3" && \
+    mamba clean --all
diff --git a/dev/archery/archery/lang/python.py b/dev/archery/archery/lang/python.py
index 8600a0d7c48c0..d4c1853d097b2 100644
--- a/dev/archery/archery/lang/python.py
+++ b/dev/archery/archery/lang/python.py
@@ -16,6 +16,7 @@
 # under the License.
 
 from contextlib import contextmanager
+from enum import EnumMeta
 import inspect
 import tokenize
 
@@ -112,6 +113,10 @@ def inspect_signature(obj):
 
 
 class NumpyDoc:
+    IGNORE_VALIDATION_ERRORS_FOR_TYPE = {
+        # Enum function signatures should never be documented
+        EnumMeta: ["PR01"]
+    }
 
     def __init__(self, symbols=None):
         if not have_numpydoc:
@@ -229,6 +234,10 @@ def callback(obj):
                     continue
                 if disallow_rules and errcode in disallow_rules:
                     continue
+                if any(isinstance(obj, obj_type) and errcode in errcode_list
+                       for obj_type, errcode_list
+                       in NumpyDoc.IGNORE_VALIDATION_ERRORS_FOR_TYPE.items()):
+                    continue
                 errors.append((errcode, errmsg))
 
             if len(errors):
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index ed238778635d3..29e038a922412 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1286,6 +1286,14 @@ tasks:
         PYTHON: "3.10"
       image: conda-python-substrait
 
+  test-conda-python-3.10-cython2:
+    ci: github
+    template: docker-tests/github.linux.yml
+    params:
+      env:
+        PYTHON: "3.10"
+      image: conda-python-cython2
+
   test-debian-11-python-3:
     ci: azure
     template: docker-tests/azure.linux.yml
diff --git a/docker-compose.yml b/docker-compose.yml
index a79b13c0a5f91..8ae06900c57f9 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -119,6 +119,7 @@ x-hierarchy:
       - conda-python:
         - conda-python-pandas:
           - conda-python-docs
+        - conda-python-cython2
         - conda-python-dask
         - conda-python-hdfs
         - conda-python-java-integration
@@ -1349,6 +1350,30 @@ services:
           /arrow/ci/scripts/java_build.sh /arrow /build /tmp/dist/java &&
           /arrow/ci/scripts/java_cdata_integration.sh /arrow /tmp/dist/java" ]
 
+  conda-python-cython2:
+    # Usage:
+    #   docker-compose build conda
+    #   docker-compose build conda-cpp
+    #   docker-compose build conda-python
+    #   docker-compose build conda-python-cython2
+    #   docker-compose run --rm conda-python-cython2
+    image: ${REPO}:${ARCH}-conda-python-${PYTHON}-cython2
+    build:
+      context: .
+      dockerfile: ci/docker/conda-python-cython2.dockerfile
+      cache_from:
+        - ${REPO}:${ARCH}-conda-python-${PYTHON}-cython2
+      args:
+        repo: ${REPO}
+        arch: ${ARCH}
+        python: ${PYTHON}
+    shm_size: *shm-size
+    environment:
+      <<: [*common, *ccache]
+      PYTEST_ARGS:  # inherit
+    volumes: *conda-volumes
+    command: *python-conda-command
+
   ################################## R ########################################
 
   ubuntu-r:
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 242ba8448f4a6..29f8d2da72f3a 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -168,37 +168,44 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${PYARROW_CXXFLAGS}")
 
 if(MSVC)
   # MSVC version of -Wno-return-type-c-linkage
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4190")
+  string(APPEND CMAKE_CXX_FLAGS " /wd4190")
 
   # Cython generates some bitshift expressions that MSVC does not like in
   # __Pyx_PyFloat_DivideObjC
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4293")
+  string(APPEND CMAKE_CXX_FLAGS " /wd4293")
 
   # Converting to/from C++ bool is pretty wonky in Cython. The C4800 warning
   # seem harmless, and probably not worth the effort of working around it
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4800")
+  string(APPEND CMAKE_CXX_FLAGS " /wd4800")
 
   # See https://github.com/cython/cython/issues/2731. Change introduced in
   # Cython 0.29.1 causes "unsafe use of type 'bool' in operation"
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4804")
+  string(APPEND CMAKE_CXX_FLAGS " /wd4804")
+
+  # See https://github.com/cython/cython/issues/4445.
+  #
+  # Cython 3 emits "(void)__Pyx_PyObject_CallMethod0;" to suppress a
+  # "unused function" warning but the code emits another "function
+  # call missing argument list" warning.
+  string(APPEND CMAKE_CXX_FLAGS " /wd4551")
 else()
   # Enable perf and other tools to work properly
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
+  string(APPEND CMAKE_CXX_FLAGS " -fno-omit-frame-pointer")
 
   # Suppress Cython warnings
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable -Wno-maybe-uninitialized")
+  string(APPEND CMAKE_CXX_FLAGS " -Wno-unused-variable -Wno-maybe-uninitialized")
 
   if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL
                                                     "Clang")
     # Cython warnings in clang
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-parentheses-equality")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-constant-logical-operand")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-declarations")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-sometimes-uninitialized")
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-parentheses-equality")
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-constant-logical-operand")
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-missing-declarations")
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-sometimes-uninitialized")
 
     # We have public Cython APIs which return C++ types, which are in an extern
     # "C" blog (no symbol mangling) and clang doesn't like this
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage")
+    string(APPEND CMAKE_CXX_FLAGS " -Wno-return-type-c-linkage")
   endif()
 endif()
 
diff --git a/python/pyarrow/_dataset.pyx b/python/pyarrow/_dataset.pyx
index d29fa125e2061..48ee676915311 100644
--- a/python/pyarrow/_dataset.pyx
+++ b/python/pyarrow/_dataset.pyx
@@ -1078,7 +1078,8 @@ cdef class FileSystemDataset(Dataset):
     @classmethod
     def from_paths(cls, paths, schema=None, format=None,
                    filesystem=None, partitions=None, root_partition=None):
-        """A Dataset created from a list of paths on a particular filesystem.
+        """
+        A Dataset created from a list of paths on a particular filesystem.
 
         Parameters
         ----------
diff --git a/python/pyarrow/_flight.pyx b/python/pyarrow/_flight.pyx
index 42b221ed72a1b..79aa24e4ce8e3 100644
--- a/python/pyarrow/_flight.pyx
+++ b/python/pyarrow/_flight.pyx
@@ -988,8 +988,10 @@ cdef class _MetadataRecordBatchReader(_Weakrefable, _ReadPandasMixin):
     cdef shared_ptr[CMetadataRecordBatchReader] reader
 
     def __iter__(self):
-        while True:
-            yield self.read_chunk()
+        return self
+
+    def __next__(self):
+        return self.read_chunk()
 
     @property
     def schema(self):
@@ -1699,7 +1701,9 @@ cdef class FlightClient(_Weakrefable):
 
     def close(self):
         """Close the client and disconnect."""
-        check_flight_status(self.client.get().Close())
+        client = self.client.get()
+        if client != NULL:
+            check_flight_status(client.Close())
 
     def __del__(self):
         # Not ideal, but close() wasn't originally present so
diff --git a/python/pyarrow/_substrait.pyx b/python/pyarrow/_substrait.pyx
index 4efad2c4d1bc5..067cb5f91681b 100644
--- a/python/pyarrow/_substrait.pyx
+++ b/python/pyarrow/_substrait.pyx
@@ -27,9 +27,10 @@ from pyarrow.includes.libarrow cimport *
 from pyarrow.includes.libarrow_substrait cimport *
 
 
+# TODO GH-37235: Fix exception handling
 cdef CDeclaration _create_named_table_provider(
     dict named_args, const std_vector[c_string]& names, const CSchema& schema
-):
+) noexcept:
     cdef:
         c_string c_name
         shared_ptr[CTable] c_in_table
diff --git a/python/pyarrow/includes/libarrow_flight.pxd b/python/pyarrow/includes/libarrow_flight.pxd
index 4bddd2d080f5f..c4cf5830c4128 100644
--- a/python/pyarrow/includes/libarrow_flight.pxd
+++ b/python/pyarrow/includes/libarrow_flight.pxd
@@ -118,16 +118,16 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
         c_bool Equals(const CLocation& other)
 
         @staticmethod
-        CResult[CLocation] Parse(c_string& uri_string)
+        CResult[CLocation] Parse(const c_string& uri_string)
 
         @staticmethod
-        CResult[CLocation] ForGrpcTcp(c_string& host, int port)
+        CResult[CLocation] ForGrpcTcp(const c_string& host, int port)
 
         @staticmethod
-        CResult[CLocation] ForGrpcTls(c_string& host, int port)
+        CResult[CLocation] ForGrpcTls(const c_string& host, int port)
 
         @staticmethod
-        CResult[CLocation] ForGrpcUnix(c_string& path)
+        CResult[CLocation] ForGrpcUnix(const c_string& path)
 
     cdef cppclass CFlightEndpoint" arrow::flight::FlightEndpoint":
         CFlightEndpoint()
@@ -172,7 +172,9 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
         CResult[unique_ptr[CFlightInfo]] Next()
 
     cdef cppclass CSimpleFlightListing" arrow::flight::SimpleFlightListing":
-        CSimpleFlightListing(vector[CFlightInfo]&& info)
+        # This doesn't work with Cython >= 3
+        # CSimpleFlightListing(vector[CFlightInfo]&& info)
+        CSimpleFlightListing(const vector[CFlightInfo]& info)
 
     cdef cppclass CFlightPayload" arrow::flight::FlightPayload":
         shared_ptr[CBuffer] descriptor
@@ -310,7 +312,10 @@ cdef extern from "arrow/flight/api.h" namespace "arrow" nogil:
     cdef cppclass CCallHeaders" arrow::flight::CallHeaders":
         cppclass const_iterator:
             pair[c_string, c_string] operator*()
+            # For Cython < 3
             const_iterator operator++()
+            # For Cython >= 3
+            const_iterator operator++(int)
             bint operator==(const_iterator)
             bint operator!=(const_iterator)
         const_iterator cbegin()
diff --git a/python/pyarrow/ipc.pxi b/python/pyarrow/ipc.pxi
index a8398597fe6cd..53e521fc11468 100644
--- a/python/pyarrow/ipc.pxi
+++ b/python/pyarrow/ipc.pxi
@@ -436,8 +436,10 @@ cdef class MessageReader(_Weakrefable):
         return result
 
     def __iter__(self):
-        while True:
-            yield self.read_next_message()
+        return self
+
+    def __next__(self):
+        return self.read_next_message()
 
     def read_next_message(self):
         """
@@ -656,11 +658,10 @@ cdef class RecordBatchReader(_Weakrefable):
     # cdef block is in lib.pxd
 
     def __iter__(self):
-        while True:
-            try:
-                yield self.read_next_batch()
-            except StopIteration:
-                return
+        return self
+
+    def __next__(self):
+        return self.read_next_batch()
 
     @property
     def schema(self):
diff --git a/python/pyarrow/scalar.pxi b/python/pyarrow/scalar.pxi
index e07949c675524..9a66dc81226d4 100644
--- a/python/pyarrow/scalar.pxi
+++ b/python/pyarrow/scalar.pxi
@@ -819,8 +819,8 @@ cdef class MapScalar(ListScalar):
         Iterate over this element's values.
         """
         arr = self.values
-        if array is None:
-            raise StopIteration
+        if arr is None:
+            return
         for k, v in zip(arr.field(self.type.key_field.name), arr.field(self.type.item_field.name)):
             yield (k.as_py(), v.as_py())
 
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index e0988f2752033..39c3c43daea37 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -1615,9 +1615,13 @@ def test_fragments_repr(tempdir, dataset):
     # partitioned parquet dataset
     fragment = list(dataset.get_fragments())[0]
     assert (
+        # Ordering of partition items is non-deterministic
         repr(fragment) ==
         "<pyarrow.dataset.ParquetFileFragment path=subdir/1/xxx/file0.parquet "
-        "partition=[key=xxx, group=1]>"
+        "partition=[key=xxx, group=1]>" or
+        repr(fragment) ==
+        "<pyarrow.dataset.ParquetFileFragment path=subdir/1/xxx/file0.parquet "
+        "partition=[group=1, key=xxx]>"
     )
 
     # single-file parquet dataset (no partition information in repr)
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index 5f6c8c813f12a..8a1dcfb057f74 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -700,6 +700,10 @@ def test_map(pickle_module):
     for i, j in zip(s, v):
         assert i == j
 
+    # test iteration with missing values
+    for _ in pa.scalar(None, type=ty):
+        pass
+
     assert s.as_py() == v
     assert s[1] == (
         pa.scalar('b', type=pa.string()),

From 772a01c080ad57eb11e9323f5347472b769d45de Mon Sep 17 00:00:00 2001
From: Junming Chen <junming.chen.r@outlook.com>
Date: Sat, 23 Sep 2023 00:40:31 +0800
Subject: [PATCH 401/749] GH-36420: [C++] Add An Enum Option For SetLookup
 Options (#36739)

### Rationale for this change
As #36420 says, we want add an sql-compatible `is_in` variant, which has a different logic handling Null. After a dicussion with @ ianmcook and @ bkietz, we decide to support an enum option `null_matching_behavior` for SetLookup, which actually adds two semantics of null handling for `is_in` and doesn't add an new behavior for `index_in`.

The enum option `null_matching_behavior` will replace `skip_nulls` in the future.

### What changes are included in this PR?
Add an enum parameter `null_matching_behavior` for SetLookupOptions.

### Are these changes tested?
Two kinds of tests are implemented
- Replace default parameter with `null_matching_behavior` instead of `skip_nulls` for `is_in` and `index_in` tests
- Add tests for `NullMatchingBehavior::EMIT_NULL` and `NullMatchingBehavior::INCONCLUSIVE` for `is_in`

Besides, since the `skip_nulls` is not deprecated now, I still preserve the old tests with `skip_nulls`. When the `skip_nulls` is totally deprecated, we can replace the test parameter `skip_nulls=false` with `null_matching_behavior=MATCH` and `skip_nulls=true` with `null_matching_behavior=SKIP` for these old tests.

### Are there any user-facing changes?
No. Currently we support backward compatibility. In the future, we plan to replace `skip_nulls` with `null_matching_behavior` completely.

* Closes: #36420

Lead-authored-by: Junming Chen <junming.chen.r@outlook.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 c_glib/arrow-glib/compute.cpp                 |  17 +-
 cpp/src/arrow/compute/api_scalar.cc           |  52 +-
 cpp/src/arrow/compute/api_scalar.h            |  34 +-
 cpp/src/arrow/compute/expression_test.cc      |   5 +-
 .../compute/kernels/scalar_set_lookup.cc      | 104 ++-
 .../compute/kernels/scalar_set_lookup_test.cc | 756 +++++++++++++++++-
 cpp/src/arrow/util/reflection_internal.h      |  24 +
 python/pyarrow/_compute.pyx                   |   2 +-
 8 files changed, 942 insertions(+), 52 deletions(-)

diff --git a/c_glib/arrow-glib/compute.cpp b/c_glib/arrow-glib/compute.cpp
index 7fe005f94a5bb..9692f277d183f 100644
--- a/c_glib/arrow-glib/compute.cpp
+++ b/c_glib/arrow-glib/compute.cpp
@@ -3346,7 +3346,7 @@ garrow_set_lookup_options_get_property(GObject *object,
     g_value_set_object(value, priv->value_set);
     break;
   case PROP_SET_LOOKUP_OPTIONS_SKIP_NULLS:
-    g_value_set_boolean(value, options->skip_nulls);
+    g_value_set_boolean(value, options->skip_nulls.has_value() && options->skip_nulls.value());
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
@@ -3398,13 +3398,11 @@ garrow_set_lookup_options_class_init(GArrowSetLookupOptionsClass *klass)
    *
    * Since: 6.0.0
    */
-  spec = g_param_spec_boolean("skip-nulls",
-                              "Skip NULLs",
-                              "Whether NULLs are skipped or not",
-                              options.skip_nulls,
-                              static_cast<GParamFlags>(G_PARAM_READWRITE));
-  g_object_class_install_property(gobject_class,
-                                  PROP_SET_LOOKUP_OPTIONS_SKIP_NULLS,
+  auto skip_nulls = (options.skip_nulls.has_value() && options.skip_nulls.value());
+  spec =
+      g_param_spec_boolean("skip-nulls", "Skip NULLs", "Whether NULLs are skipped or not",
+                           skip_nulls, static_cast<GParamFlags>(G_PARAM_READWRITE));
+  g_object_class_install_property(gobject_class, PROP_SET_LOOKUP_OPTIONS_SKIP_NULLS,
                                   spec);
 }
 
@@ -6458,9 +6456,10 @@ garrow_set_lookup_options_new_raw(
       arrow_copied_options.get());
   auto value_set =
     garrow_datum_new_raw(&(arrow_copied_set_lookup_options->value_set));
+  auto skip_nulls = (arrow_options->skip_nulls.has_value() && arrow_options->skip_nulls.value());
   auto options = g_object_new(GARROW_TYPE_SET_LOOKUP_OPTIONS,
                               "value-set", value_set,
-                              "skip-nulls", arrow_options->skip_nulls,
+                              "skip-nulls", skip_nulls,
                               NULL);
   return GARROW_SET_LOOKUP_OPTIONS(options);
 }
diff --git a/cpp/src/arrow/compute/api_scalar.cc b/cpp/src/arrow/compute/api_scalar.cc
index d7a61d0a55985..eaec940556361 100644
--- a/cpp/src/arrow/compute/api_scalar.cc
+++ b/cpp/src/arrow/compute/api_scalar.cc
@@ -275,6 +275,29 @@ struct EnumTraits<compute::MapLookupOptions::Occurrence>
   }
 };
 
+template <>
+struct EnumTraits<compute::SetLookupOptions::NullMatchingBehavior>
+    : BasicEnumTraits<compute::SetLookupOptions::NullMatchingBehavior,
+                      compute::SetLookupOptions::NullMatchingBehavior::MATCH,
+                      compute::SetLookupOptions::NullMatchingBehavior::SKIP,
+                      compute::SetLookupOptions::NullMatchingBehavior::EMIT_NULL,
+                      compute::SetLookupOptions::NullMatchingBehavior::INCONCLUSIVE> {
+  static std::string name() { return "SetLookupOptions::NullMatchingBehavior"; }
+  static std::string value_name(compute::SetLookupOptions::NullMatchingBehavior value) {
+    switch (value) {
+      case compute::SetLookupOptions::NullMatchingBehavior::MATCH:
+        return "MATCH";
+      case compute::SetLookupOptions::NullMatchingBehavior::SKIP:
+        return "SKIP";
+      case compute::SetLookupOptions::NullMatchingBehavior::EMIT_NULL:
+        return "EMIT_NULL";
+      case compute::SetLookupOptions::NullMatchingBehavior::INCONCLUSIVE:
+        return "INCONCLUSIVE";
+    }
+    return "<INVALID>";
+  }
+};
+
 }  // namespace internal
 
 namespace compute {
@@ -286,6 +309,7 @@ using ::arrow::internal::checked_cast;
 
 namespace internal {
 namespace {
+using ::arrow::internal::CoercedDataMember;
 using ::arrow::internal::DataMember;
 static auto kArithmeticOptionsType = GetFunctionOptionsType<ArithmeticOptions>(
     DataMember("check_overflow", &ArithmeticOptions::check_overflow));
@@ -344,7 +368,8 @@ static auto kRoundToMultipleOptionsType = GetFunctionOptionsType<RoundToMultiple
     DataMember("round_mode", &RoundToMultipleOptions::round_mode));
 static auto kSetLookupOptionsType = GetFunctionOptionsType<SetLookupOptions>(
     DataMember("value_set", &SetLookupOptions::value_set),
-    DataMember("skip_nulls", &SetLookupOptions::skip_nulls));
+    CoercedDataMember("null_matching_behavior", &SetLookupOptions::null_matching_behavior,
+                      &SetLookupOptions::GetNullMatchingBehavior));
 static auto kSliceOptionsType = GetFunctionOptionsType<SliceOptions>(
     DataMember("start", &SliceOptions::start), DataMember("stop", &SliceOptions::stop),
     DataMember("step", &SliceOptions::step));
@@ -540,8 +565,29 @@ constexpr char RoundToMultipleOptions::kTypeName[];
 SetLookupOptions::SetLookupOptions(Datum value_set, bool skip_nulls)
     : FunctionOptions(internal::kSetLookupOptionsType),
       value_set(std::move(value_set)),
-      skip_nulls(skip_nulls) {}
-SetLookupOptions::SetLookupOptions() : SetLookupOptions({}, false) {}
+      skip_nulls(skip_nulls) {
+  if (skip_nulls) {
+    this->null_matching_behavior = SetLookupOptions::SKIP;
+  } else {
+    this->null_matching_behavior = SetLookupOptions::MATCH;
+  }
+}
+SetLookupOptions::SetLookupOptions(
+    Datum value_set, SetLookupOptions::NullMatchingBehavior null_matching_behavior)
+    : FunctionOptions(internal::kSetLookupOptionsType),
+      value_set(std::move(value_set)),
+      null_matching_behavior(std::move(null_matching_behavior)) {}
+SetLookupOptions::SetLookupOptions()
+    : SetLookupOptions({}, SetLookupOptions::NullMatchingBehavior::MATCH) {}
+SetLookupOptions::NullMatchingBehavior SetLookupOptions::GetNullMatchingBehavior() const {
+  if (!this->skip_nulls.has_value()) {
+    return this->null_matching_behavior;
+  } else if (this->skip_nulls.value()) {
+    return SetLookupOptions::SKIP;
+  } else {
+    return SetLookupOptions::MATCH;
+  }
+}
 constexpr char SetLookupOptions::kTypeName[];
 
 SliceOptions::SliceOptions(int64_t start, int64_t stop, int64_t step)
diff --git a/cpp/src/arrow/compute/api_scalar.h b/cpp/src/arrow/compute/api_scalar.h
index 0a06a2829f0da..9f12471ddca14 100644
--- a/cpp/src/arrow/compute/api_scalar.h
+++ b/cpp/src/arrow/compute/api_scalar.h
@@ -268,19 +268,49 @@ class ARROW_EXPORT ExtractRegexOptions : public FunctionOptions {
 /// Options for IsIn and IndexIn functions
 class ARROW_EXPORT SetLookupOptions : public FunctionOptions {
  public:
-  explicit SetLookupOptions(Datum value_set, bool skip_nulls = false);
+  /// How to handle null values.
+  enum NullMatchingBehavior {
+    /// MATCH, any null in `value_set` is successfully matched in
+    /// the input.
+    MATCH,
+    /// SKIP, any null in `value_set` is ignored and nulls in the input
+    /// produce null (IndexIn) or false (IsIn) values in the output.
+    SKIP,
+    /// EMIT_NULL, any null in `value_set` is ignored and nulls in the
+    /// input produce null (IndexIn and IsIn) values in the output.
+    EMIT_NULL,
+    /// INCONCLUSIVE, null values are regarded as unknown values, which is
+    /// sql-compatible. nulls in the input produce null (IndexIn and IsIn)
+    /// values in the output. Besides, if `value_set` contains a null,
+    /// non-null unmatched values in the input also produce null values
+    /// (IndexIn and IsIn) in the output.
+    INCONCLUSIVE
+  };
+
+  explicit SetLookupOptions(Datum value_set, NullMatchingBehavior = MATCH);
   SetLookupOptions();
+
+  // DEPRECATED(will be removed after removing of skip_nulls)
+  explicit SetLookupOptions(Datum value_set, bool skip_nulls);
+
   static constexpr char const kTypeName[] = "SetLookupOptions";
 
   /// The set of values to look up input values into.
   Datum value_set;
+
+  NullMatchingBehavior null_matching_behavior;
+
+  // DEPRECATED(will be removed after removing of skip_nulls)
+  NullMatchingBehavior GetNullMatchingBehavior() const;
+
+  // DEPRECATED(use null_matching_behavior instead)
   /// Whether nulls in `value_set` count for lookup.
   ///
   /// If true, any null in `value_set` is ignored and nulls in the input
   /// produce null (IndexIn) or false (IsIn) values in the output.
   /// If false, any null in `value_set` is successfully matched in
   /// the input.
-  bool skip_nulls;
+  std::optional<bool> skip_nulls;
 };
 
 /// Options for struct_field function
diff --git a/cpp/src/arrow/compute/expression_test.cc b/cpp/src/arrow/compute/expression_test.cc
index b852f6f6b0cdb..44159e76600fb 100644
--- a/cpp/src/arrow/compute/expression_test.cc
+++ b/cpp/src/arrow/compute/expression_test.cc
@@ -263,8 +263,9 @@ TEST(Expression, ToString) {
   auto in_12 = call("index_in", {field_ref("beta")},
                     compute::SetLookupOptions{ArrayFromJSON(int32(), "[1,2]")});
 
-  EXPECT_EQ(in_12.ToString(),
-            "index_in(beta, {value_set=int32:[\n  1,\n  2\n], skip_nulls=false})");
+  EXPECT_EQ(
+      in_12.ToString(),
+      "index_in(beta, {value_set=int32:[\n  1,\n  2\n], null_matching_behavior=MATCH})");
 
   EXPECT_EQ(and_(field_ref("a"), field_ref("b")).ToString(), "(a and b)");
   EXPECT_EQ(or_(field_ref("a"), field_ref("b")).ToString(), "(a or b)");
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
index 00d391653d240..e2d5583e36e6b 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup.cc
@@ -44,6 +44,7 @@ struct SetLookupState : public SetLookupStateBase {
   explicit SetLookupState(MemoryPool* pool) : memory_pool(pool) {}
 
   Status Init(const SetLookupOptions& options) {
+    this->null_matching_behavior = options.GetNullMatchingBehavior();
     if (options.value_set.is_array()) {
       const ArrayData& value_set = *options.value_set.array();
       memo_index_to_value_index.reserve(value_set.length);
@@ -66,7 +67,8 @@ struct SetLookupState : public SetLookupStateBase {
     } else {
       return Status::Invalid("value_set should be an array or chunked array");
     }
-    if (!options.skip_nulls && lookup_table->GetNull() >= 0) {
+    if (this->null_matching_behavior != SetLookupOptions::SKIP &&
+        lookup_table->GetNull() >= 0) {
       null_index = memo_index_to_value_index[lookup_table->GetNull()];
     }
     value_set_type = options.value_set.type();
@@ -117,19 +119,23 @@ struct SetLookupState : public SetLookupStateBase {
   // be mapped back to indices in the value_set.
   std::vector<int32_t> memo_index_to_value_index;
   int32_t null_index = -1;
+  SetLookupOptions::NullMatchingBehavior null_matching_behavior;
 };
 
 template <>
 struct SetLookupState<NullType> : public SetLookupStateBase {
   explicit SetLookupState(MemoryPool*) {}
 
-  Status Init(const SetLookupOptions& options) {
-    value_set_has_null = (options.value_set.length() > 0) && !options.skip_nulls;
+  Status Init(SetLookupOptions& options) {
+    null_matching_behavior = options.GetNullMatchingBehavior();
+    value_set_has_null = (options.value_set.length() > 0) &&
+                         this->null_matching_behavior != SetLookupOptions::SKIP;
     value_set_type = null();
     return Status::OK();
   }
 
   bool value_set_has_null;
+  SetLookupOptions::NullMatchingBehavior null_matching_behavior;
 };
 
 // TODO: Put this concept somewhere reusable
@@ -270,14 +276,20 @@ struct IndexInVisitor {
       : ctx(ctx), data(data), out(out), out_bitmap(out->buffers[0].data) {}
 
   Status Visit(const DataType& type) {
-    DCHECK_EQ(type.id(), Type::NA);
+    DCHECK(false) << "IndexIn " << type;
+    return Status::NotImplemented("IndexIn has no implementation with value type ", type);
+  }
+
+  Status Visit(const NullType&) {
     const auto& state = checked_cast<const SetLookupState<NullType>&>(*ctx->state());
 
     if (data.length != 0) {
-      // skip_nulls is honored for consistency with other types
-      bit_util::SetBitsTo(out_bitmap, out->offset, out->length, state.value_set_has_null);
+      bit_util::SetBitsTo(out_bitmap, out->offset, out->length,
+                          state.null_matching_behavior == SetLookupOptions::MATCH &&
+                              state.value_set_has_null);
 
       // Set all values to 0, which will be unmasked only if null is in the value_set
+      // and null_matching_behavior is equal to MATCH
       std::memset(out->GetValues<int32_t>(1), 0x00, out->length * sizeof(int32_t));
     }
     return Status::OK();
@@ -305,7 +317,8 @@ struct IndexInVisitor {
           bitmap_writer.Next();
         },
         [&]() {
-          if (state.null_index != -1) {
+          if (state.null_index != -1 &&
+              state.null_matching_behavior == SetLookupOptions::MATCH) {
             bitmap_writer.Set();
 
             // value_set included null
@@ -379,49 +392,86 @@ Status ExecIndexIn(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   return IndexInVisitor(ctx, batch[0].array, out->array_span_mutable()).Execute();
 }
 
-// ----------------------------------------------------------------------
-
 // IsIn writes the results into a preallocated boolean data bitmap
 struct IsInVisitor {
   KernelContext* ctx;
   const ArraySpan& data;
   ArraySpan* out;
+  uint8_t* out_boolean_bitmap;
+  uint8_t* out_null_bitmap;
 
   IsInVisitor(KernelContext* ctx, const ArraySpan& data, ArraySpan* out)
-      : ctx(ctx), data(data), out(out) {}
+      : ctx(ctx),
+        data(data),
+        out(out),
+        out_boolean_bitmap(out->buffers[1].data),
+        out_null_bitmap(out->buffers[0].data) {}
 
   Status Visit(const DataType& type) {
-    DCHECK_EQ(type.id(), Type::NA);
+    DCHECK(false) << "IndexIn " << type;
+    return Status::NotImplemented("IsIn has no implementation with value type ", type);
+  }
+
+  Status Visit(const NullType&) {
     const auto& state = checked_cast<const SetLookupState<NullType>&>(*ctx->state());
-    // skip_nulls is honored for consistency with other types
-    bit_util::SetBitsTo(out->buffers[1].data, out->offset, out->length,
-                        state.value_set_has_null);
+
+    if (state.null_matching_behavior == SetLookupOptions::MATCH &&
+        state.value_set_has_null) {
+      bit_util::SetBitsTo(out_boolean_bitmap, out->offset, out->length, true);
+      bit_util::SetBitsTo(out_null_bitmap, out->offset, out->length, true);
+    } else if (state.null_matching_behavior == SetLookupOptions::SKIP ||
+               (!state.value_set_has_null &&
+                state.null_matching_behavior == SetLookupOptions::MATCH)) {
+      bit_util::SetBitsTo(out_boolean_bitmap, out->offset, out->length, false);
+      bit_util::SetBitsTo(out_null_bitmap, out->offset, out->length, true);
+    } else {
+      bit_util::SetBitsTo(out_null_bitmap, out->offset, out->length, false);
+    }
     return Status::OK();
   }
 
   template <typename Type>
   Status ProcessIsIn(const SetLookupState<Type>& state, const ArraySpan& input) {
     using T = typename GetViewType<Type>::T;
-    FirstTimeBitmapWriter writer(out->buffers[1].data, out->offset, out->length);
+    FirstTimeBitmapWriter writer_boolean(out_boolean_bitmap, out->offset, out->length);
+    FirstTimeBitmapWriter writer_null(out_null_bitmap, out->offset, out->length);
+    bool value_set_has_null = state.null_index != -1;
     VisitArraySpanInline<Type>(
         input,
         [&](T v) {
-          if (state.lookup_table->Get(v) != -1) {
-            writer.Set();
-          } else {
-            writer.Clear();
+          if (state.lookup_table->Get(v) != -1) {  // true
+            writer_boolean.Set();
+            writer_null.Set();
+          } else if (state.null_matching_behavior == SetLookupOptions::INCONCLUSIVE &&
+                     value_set_has_null) {  // null
+            writer_boolean.Clear();
+            writer_null.Clear();
+          } else {  // false
+            writer_boolean.Clear();
+            writer_null.Set();
           }
-          writer.Next();
+          writer_boolean.Next();
+          writer_null.Next();
         },
         [&]() {
-          if (state.null_index != -1) {
-            writer.Set();
-          } else {
-            writer.Clear();
+          if (state.null_matching_behavior == SetLookupOptions::MATCH &&
+              value_set_has_null) {  // true
+            writer_boolean.Set();
+            writer_null.Set();
+          } else if (state.null_matching_behavior == SetLookupOptions::SKIP ||
+                     (!value_set_has_null && state.null_matching_behavior ==
+                                                 SetLookupOptions::MATCH)) {  // false
+            writer_boolean.Clear();
+            writer_null.Set();
+          } else {  // null
+            writer_boolean.Clear();
+            writer_null.Clear();
           }
-          writer.Next();
+          writer_boolean.Next();
+          writer_null.Next();
         });
-    writer.Finish();
+    writer_boolean.Finish();
+    writer_null.Finish();
     return Status::OK();
   }
 
@@ -598,7 +648,7 @@ void RegisterScalarSetLookup(FunctionRegistry* registry) {
     ScalarKernel isin_base;
     isin_base.init = InitSetLookup;
     isin_base.exec = ExecIsIn;
-    isin_base.null_handling = NullHandling::OUTPUT_NOT_NULL;
+    isin_base.null_handling = NullHandling::COMPUTED_PREALLOCATE;
     auto is_in = std::make_shared<SetLookupFunction>("is_in", Arity::Unary(), is_in_doc);
 
     AddBasicSetLookupKernels(isin_base, /*output_type=*/boolean(), is_in.get());
diff --git a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
index d1645eb8d9a49..89e10d1b54103 100644
--- a/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_set_lookup_test.cc
@@ -50,7 +50,67 @@ namespace compute {
 
 void CheckIsIn(const std::shared_ptr<Array> input,
                const std::shared_ptr<Array>& value_set, const std::string& expected_json,
-               bool skip_nulls = false) {
+               SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                   SetLookupOptions::MATCH) {
+  auto expected = ArrayFromJSON(boolean(), expected_json);
+
+  ASSERT_OK_AND_ASSIGN(Datum actual_datum,
+                       IsIn(input, SetLookupOptions(value_set, null_matching_behavior)));
+  std::shared_ptr<Array> actual = actual_datum.make_array();
+  ValidateOutput(actual_datum);
+  AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+}
+
+void CheckIsIn(const std::shared_ptr<DataType>& type, const std::string& input_json,
+               const std::string& value_set_json, const std::string& expected_json,
+               SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                   SetLookupOptions::MATCH) {
+  auto input = ArrayFromJSON(type, input_json);
+  auto value_set = ArrayFromJSON(type, value_set_json);
+  CheckIsIn(input, value_set, expected_json, null_matching_behavior);
+}
+
+void CheckIsInChunked(const std::shared_ptr<ChunkedArray>& input,
+                      const std::shared_ptr<ChunkedArray>& value_set,
+                      const std::shared_ptr<ChunkedArray>& expected,
+                      SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                          SetLookupOptions::MATCH) {
+  ASSERT_OK_AND_ASSIGN(Datum actual_datum,
+                       IsIn(input, SetLookupOptions(value_set, null_matching_behavior)));
+  auto actual = actual_datum.chunked_array();
+  ValidateOutput(actual_datum);
+
+  // Output contiguous in a single chunk
+  ASSERT_EQ(1, actual->num_chunks());
+  ASSERT_TRUE(actual->Equals(*expected));
+}
+
+void CheckIsInDictionary(const std::shared_ptr<DataType>& type,
+                         const std::shared_ptr<DataType>& index_type,
+                         const std::string& input_dictionary_json,
+                         const std::string& input_index_json,
+                         const std::string& value_set_json,
+                         const std::string& expected_json,
+                         SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                             SetLookupOptions::MATCH) {
+  auto dict_type = dictionary(index_type, type);
+  auto indices = ArrayFromJSON(index_type, input_index_json);
+  auto dict = ArrayFromJSON(type, input_dictionary_json);
+
+  ASSERT_OK_AND_ASSIGN(auto input, DictionaryArray::FromArrays(dict_type, indices, dict));
+  auto value_set = ArrayFromJSON(type, value_set_json);
+  auto expected = ArrayFromJSON(boolean(), expected_json);
+
+  ASSERT_OK_AND_ASSIGN(Datum actual_datum,
+                       IsIn(input, SetLookupOptions(value_set, null_matching_behavior)));
+  std::shared_ptr<Array> actual = actual_datum.make_array();
+  ValidateOutput(actual_datum);
+  AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+}
+
+void CheckIsIn(const std::shared_ptr<Array> input,
+               const std::shared_ptr<Array>& value_set, const std::string& expected_json,
+               bool skip_nulls) {
   auto expected = ArrayFromJSON(boolean(), expected_json);
 
   ASSERT_OK_AND_ASSIGN(Datum actual_datum,
@@ -62,7 +122,7 @@ void CheckIsIn(const std::shared_ptr<Array> input,
 
 void CheckIsIn(const std::shared_ptr<DataType>& type, const std::string& input_json,
                const std::string& value_set_json, const std::string& expected_json,
-               bool skip_nulls = false) {
+               bool skip_nulls) {
   auto input = ArrayFromJSON(type, input_json);
   auto value_set = ArrayFromJSON(type, value_set_json);
   CheckIsIn(input, value_set, expected_json, skip_nulls);
@@ -70,8 +130,7 @@ void CheckIsIn(const std::shared_ptr<DataType>& type, const std::string& input_j
 
 void CheckIsInChunked(const std::shared_ptr<ChunkedArray>& input,
                       const std::shared_ptr<ChunkedArray>& value_set,
-                      const std::shared_ptr<ChunkedArray>& expected,
-                      bool skip_nulls = false) {
+                      const std::shared_ptr<ChunkedArray>& expected, bool skip_nulls) {
   ASSERT_OK_AND_ASSIGN(Datum actual_datum,
                        IsIn(input, SetLookupOptions(value_set, skip_nulls)));
   auto actual = actual_datum.chunked_array();
@@ -87,7 +146,7 @@ void CheckIsInDictionary(const std::shared_ptr<DataType>& type,
                          const std::string& input_dictionary_json,
                          const std::string& input_index_json,
                          const std::string& value_set_json,
-                         const std::string& expected_json, bool skip_nulls = false) {
+                         const std::string& expected_json, bool skip_nulls) {
   auto dict_type = dictionary(index_type, type);
   auto indices = ArrayFromJSON(index_type, input_index_json);
   auto dict = ArrayFromJSON(type, input_dictionary_json);
@@ -185,18 +244,43 @@ TYPED_TEST(TestIsInKernelPrimitive, IsIn) {
             /*skip_nulls=*/false);
   CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, 1]", "[false, true, true, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, 1]", "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, 1]", "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, 1]", "[null, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, 1]", "[null, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Nulls in right array
   CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[false, true, true, false, true]",
             /*skip_nulls=*/false);
   CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[false, true, true, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[0, 1, 2, 3, 2]", "[2, null, 1]", "[null, true, true, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Nulls in both the arrays
   CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]", "[true, true, true, false, true]",
             /*skip_nulls=*/false);
   CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]",
             "[false, true, true, false, true]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]", "[true, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]",
+            "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]", "[null, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[2, null, 1]", "[null, true, true, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in right array
   CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
@@ -204,6 +288,18 @@ TYPED_TEST(TestIsInKernelPrimitive, IsIn) {
             /*skip_nulls=*/false);
   CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
             "[false, true, true, false, true]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
+            "[true, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
+            "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
+            "[null, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, 1, 2, 3, 2]", "[null, 2, 2, null, 1, 1]",
+            "[null, true, true, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Empty Arrays
   CheckIsIn(type, "[]", "[]", "[]");
@@ -217,11 +313,30 @@ TEST_F(TestIsInKernel, NullType) {
   CheckIsIn(type, "[]", "[]", "[]");
 
   CheckIsIn(type, "[null, null]", "[null]", "[false, false]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, null]", "[null]", "[false, false]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, null]", "[null]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, null]", "[null]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
+
   CheckIsIn(type, "[null, null]", "[]", "[false, false]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, null]", "[]", "[false, false]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, null]", "[]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, null]", "[]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in right array
   CheckIsIn(type, "[null, null, null]", "[null, null]", "[true, true, true]");
   CheckIsIn(type, "[null, null]", "[null, null]", "[false, false]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[null, null]", "[null, null]", "[false, false]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[null, null]", "[null, null]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[null, null]", "[null, null]", "[null, null]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 }
 
 TEST_F(TestIsInKernel, TimeTimestamp) {
@@ -232,12 +347,36 @@ TEST_F(TestIsInKernel, TimeTimestamp) {
               "[true, true, false, true, true]", /*skip_nulls=*/false);
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
               "[true, false, false, true, true]", /*skip_nulls=*/true);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, true, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, false, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, null, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, null, null, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     // Duplicates in right array
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
               "[true, true, false, true, true]", /*skip_nulls=*/false);
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
               "[true, false, false, true, true]", /*skip_nulls=*/true);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, true, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, false, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, null, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, null, null, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
   }
 
   // Disallow mixing timezone-aware and timezone-naive values
@@ -260,12 +399,36 @@ TEST_F(TestIsInKernel, TimeDuration) {
               "[true, true, false, true, true]", /*skip_nulls=*/false);
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
               "[true, false, false, true, true]", /*skip_nulls=*/true);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, true, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, false, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, null, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, null]",
+              "[true, null, null, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     // Duplicates in right array
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
               "[true, true, false, true, true]", /*skip_nulls=*/false);
     CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
               "[true, false, false, true, true]", /*skip_nulls=*/true);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, true, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, false, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, null, false, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, "[1, null, 5, 1, 2]", "[2, 1, 1, null, 2]",
+              "[true, null, null, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
   }
 
   // Different units, cast value_set to values will fail, then cast values to value_set
@@ -285,17 +448,53 @@ TEST_F(TestIsInKernel, Boolean) {
             "[false, true, false, false, true]", /*skip_nulls=*/false);
   CheckIsIn(type, "[true, false, null, true, false]", "[false]",
             "[false, true, false, false, true]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false]",
+            "[false, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false]",
+            "[false, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false]",
+            "[false, true, null, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false]",
+            "[false, true, null, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
             "[false, true, true, false, true]", /*skip_nulls=*/false);
   CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
             "[false, true, false, false, true]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
+            "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
+            "[false, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
+            "[false, true, null, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[true, false, null, true, false]", "[false, null]",
+            "[null, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in right array
   CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
             "[false, true, true, false, true]", /*skip_nulls=*/false);
   CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
             "[false, true, false, false, true]", /*skip_nulls=*/true);
+  CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
+            "[false, true, true, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
+            "[false, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
+            "[false, true, null, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, "[true, false, null, true, false]", "[null, false, false, null]",
+            "[null, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 }
 
 TYPED_TEST_SUITE(TestIsInKernelBinary, BaseBinaryArrowTypes);
@@ -309,6 +508,18 @@ TYPED_TEST(TestIsInKernelBinary, Binary) {
   CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", ""])",
             "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", ""])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", ""])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", ""])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", ""])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
             "[true, true, false, true, true]",
@@ -316,6 +527,18 @@ TYPED_TEST(TestIsInKernelBinary, Binary) {
   CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
             "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
+            "[true, true, false, true, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])", R"(["aaa", "", null])",
+            "[true, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in right array
   CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
@@ -324,6 +547,18 @@ TYPED_TEST(TestIsInKernelBinary, Binary) {
   CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
             R"([null, "aaa", "aaa", "", "", null])", "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
+            R"([null, "aaa", "aaa", "", "", null])", "[true, true, false, true, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
+            R"([null, "aaa", "aaa", "", "", null])", "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
+            R"([null, "aaa", "aaa", "", "", null])", "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "", "cc", null, ""])",
+            R"([null, "aaa", "aaa", "", "", null])", "[true, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 }
 
 TEST_F(TestIsInKernel, FixedSizeBinary) {
@@ -335,6 +570,18 @@ TEST_F(TestIsInKernel, FixedSizeBinary) {
   CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb"])",
             "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb"])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb"])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb"])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb"])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
             "[true, true, false, true, true]",
@@ -342,6 +589,18 @@ TEST_F(TestIsInKernel, FixedSizeBinary) {
   CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
             "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
+            "[true, true, false, true, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])", R"(["aaa", "bbb", null])",
+            "[true, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in right array
   CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])",
@@ -352,6 +611,22 @@ TEST_F(TestIsInKernel, FixedSizeBinary) {
             R"(["aaa", null, "aaa", "bbb", "bbb", null])",
             "[true, true, false, false, true]",
             /*skip_nulls=*/true);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])",
+            R"(["aaa", null, "aaa", "bbb", "bbb", null])",
+            "[true, true, false, true, true]",
+            /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])",
+            R"(["aaa", null, "aaa", "bbb", "bbb", null])",
+            "[true, true, false, false, true]",
+            /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])",
+            R"(["aaa", null, "aaa", "bbb", "bbb", null])",
+            "[true, true, false, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  CheckIsIn(type, R"(["aaa", "bbb", "ccc", null, "bbb"])",
+            R"(["aaa", null, "aaa", "bbb", "bbb", null])",
+            "[true, true, null, null, true]",
+            /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   ASSERT_RAISES(Invalid,
                 IsIn(ArrayFromJSON(fixed_size_binary(3), R"(["abc"])"),
@@ -366,6 +641,18 @@ TEST_F(TestIsInKernel, Decimal) {
     CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])", R"(["12.3", "78.9"])",
               "[true, false, true, false, true]",
               /*skip_nulls=*/true);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])", R"(["12.3", "78.9"])",
+              "[true, false, true, false, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])", R"(["12.3", "78.9"])",
+              "[true, false, true, false, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])", R"(["12.3", "78.9"])",
+              "[true, false, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])", R"(["12.3", "78.9"])",
+              "[true, false, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
               R"(["12.3", "78.9", null])", "[true, false, true, true, true]",
@@ -373,6 +660,18 @@ TEST_F(TestIsInKernel, Decimal) {
     CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
               R"(["12.3", "78.9", null])", "[true, false, true, false, true]",
               /*skip_nulls=*/true);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"(["12.3", "78.9", null])", "[true, false, true, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"(["12.3", "78.9", null])", "[true, false, true, false, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"(["12.3", "78.9", null])", "[true, false, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"(["12.3", "78.9", null])", "[true, null, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     // Duplicates in right array
     CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
@@ -383,6 +682,22 @@ TEST_F(TestIsInKernel, Decimal) {
               R"([null, "12.3", "12.3", "78.9", "78.9", null])",
               "[true, false, true, false, true]",
               /*skip_nulls=*/true);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"([null, "12.3", "12.3", "78.9", "78.9", null])",
+              "[true, false, true, true, true]",
+              /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"([null, "12.3", "12.3", "78.9", "78.9", null])",
+              "[true, false, true, false, true]",
+              /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"([null, "12.3", "12.3", "78.9", "78.9", null])",
+              "[true, false, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsIn(type, R"(["12.3", "45.6", "78.9", null, "12.3"])",
+              R"([null, "12.3", "12.3", "78.9", "78.9", null])",
+              "[true, null, true, null, true]",
+              /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     CheckIsIn(ArrayFromJSON(decimal128(4, 2), R"(["12.30", "45.60", "78.90"])"),
               ArrayFromJSON(type, R"(["12.3", "78.9"])"), "[true, false, true]");
@@ -405,6 +720,20 @@ TEST_F(TestIsInKernel, DictionaryArray) {
                         /*value_set_json=*/"[4.1, 42, -1.0]",
                         /*expected_json=*/"[true, true, false, true]",
                         /*skip_nulls=*/false);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 2, null, 0]",
+                        /*value_set_json=*/R"(["A", "B", "C"])",
+                        /*expected_json=*/"[true, true, false, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsInDictionary(/*type=*/float32(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/"[4.1, -1.0, 42, 9.8]",
+                        /*input_index_json=*/"[1, 2, null, 0]",
+                        /*value_set_json=*/"[4.1, 42, -1.0]",
+                        /*expected_json=*/"[true, true, false, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
     // With nulls and skip_nulls=false
     CheckIsInDictionary(/*type=*/utf8(),
@@ -428,6 +757,27 @@ TEST_F(TestIsInKernel, DictionaryArray) {
                         /*value_set_json=*/R"(["C", "B", "A"])",
                         /*expected_json=*/"[false, false, false, true, false]",
                         /*skip_nulls=*/false);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[true, false, true, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[true, false, true, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A"])",
+                        /*expected_json=*/"[false, false, false, true, false]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
     // With nulls and skip_nulls=true
     CheckIsInDictionary(/*type=*/utf8(),
@@ -451,6 +801,73 @@ TEST_F(TestIsInKernel, DictionaryArray) {
                         /*value_set_json=*/R"(["C", "B", "A"])",
                         /*expected_json=*/"[false, false, false, true, false]",
                         /*skip_nulls=*/true);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[true, false, false, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[false, false, false, true, false]",
+                        /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A"])",
+                        /*expected_json=*/"[false, false, false, true, false]",
+                        /*null_matching_behavior=*/SetLookupOptions::SKIP);
+
+    // With nulls and null_matching_behavior=EMIT_NULL
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[true, false, null, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[null, false, null, true, null]",
+                        /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A"])",
+                        /*expected_json=*/"[null, false, null, true, null]",
+                        /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+
+    // With nulls and null_matching_behavior=INCONCLUSIVE
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[true, null, null, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A", null])",
+                        /*expected_json=*/"[null, null, null, true, null]",
+                        /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "B", "A"])",
+                        /*expected_json=*/"[null, false, null, true, null]",
+                        /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
     // With duplicates in value_set
     CheckIsInDictionary(/*type=*/utf8(),
@@ -474,6 +891,41 @@ TEST_F(TestIsInKernel, DictionaryArray) {
                         /*value_set_json=*/R"(["C", "C", "B", "A", null, null, "B"])",
                         /*expected_json=*/"[true, false, false, true, true]",
                         /*skip_nulls=*/true);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 2, null, 0]",
+                        /*value_set_json=*/R"(["A", "A", "B", "A", "B", "C"])",
+                        /*expected_json=*/"[true, true, false, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "C", "B", "A", null, null, "B"])",
+                        /*expected_json=*/"[true, false, true, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "C", "B", "A", null, null, "B"])",
+                        /*expected_json=*/"[true, false, false, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "C", "B", "A", null, null, "B"])",
+                        /*expected_json=*/"[true, false, null, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+    CheckIsInDictionary(/*type=*/utf8(),
+                        /*index_type=*/index_ty,
+                        /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                        /*input_index_json=*/"[1, 3, null, 0, 1]",
+                        /*value_set_json=*/R"(["C", "C", "B", "A", null, null, "B"])",
+                        /*expected_json=*/"[true, null, null, true, true]",
+                        /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
   }
 }
 
@@ -487,14 +939,38 @@ TEST_F(TestIsInKernel, ChunkedArrayInvoke) {
 
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/false);
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[true, true, true, true, false]", "[true, null, true, false]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[true, true, true, true, false]", "[true, null, true, false]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   value_set = ChunkedArrayFromJSON(utf8(), {R"(["", "def"])", R"([null])"});
   expected = ChunkedArrayFromJSON(
       boolean(), {"[false, true, true, false, false]", "[true, true, false, false]"});
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/false);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::MATCH);
   expected = ChunkedArrayFromJSON(
       boolean(), {"[false, true, true, false, false]", "[true, false, false, false]"});
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[false, true, true, false, false]", "[true, null, false, false]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[null, true, true, null, null]", "[true, null, null, null]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 
   // Duplicates in value_set
   value_set =
@@ -502,9 +978,21 @@ TEST_F(TestIsInKernel, ChunkedArrayInvoke) {
   expected = ChunkedArrayFromJSON(
       boolean(), {"[false, true, true, false, false]", "[true, true, false, false]"});
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/false);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::MATCH);
   expected = ChunkedArrayFromJSON(
       boolean(), {"[false, true, true, false, false]", "[true, false, false, false]"});
   CheckIsInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[false, true, true, false, false]", "[true, null, false, false]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::EMIT_NULL);
+  expected = ChunkedArrayFromJSON(
+      boolean(), {"[null, true, true, null, null]", "[true, null, null, null]"});
+  CheckIsInChunked(input, value_set, expected,
+                   /*null_matching_behavior=*/SetLookupOptions::INCONCLUSIVE);
 }
 
 // ----------------------------------------------------------------------
@@ -514,7 +1002,70 @@ class TestIndexInKernel : public ::testing::Test {
  public:
   void CheckIndexIn(const std::shared_ptr<Array>& input,
                     const std::shared_ptr<Array>& value_set,
-                    const std::string& expected_json, bool skip_nulls = false) {
+                    const std::string& expected_json,
+                    SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                        SetLookupOptions::MATCH) {
+    std::shared_ptr<Array> expected = ArrayFromJSON(int32(), expected_json);
+
+    SetLookupOptions options(value_set, null_matching_behavior);
+    ASSERT_OK_AND_ASSIGN(Datum actual_datum, IndexIn(input, options));
+    std::shared_ptr<Array> actual = actual_datum.make_array();
+    ValidateOutput(actual_datum);
+    AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+  }
+
+  void CheckIndexIn(const std::shared_ptr<DataType>& type, const std::string& input_json,
+                    const std::string& value_set_json, const std::string& expected_json,
+                    SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                        SetLookupOptions::MATCH) {
+    std::shared_ptr<Array> input = ArrayFromJSON(type, input_json);
+    std::shared_ptr<Array> value_set = ArrayFromJSON(type, value_set_json);
+    return CheckIndexIn(input, value_set, expected_json, null_matching_behavior);
+  }
+
+  void CheckIndexInChunked(const std::shared_ptr<ChunkedArray>& input,
+                           const std::shared_ptr<ChunkedArray>& value_set,
+                           const std::shared_ptr<ChunkedArray>& expected,
+                           SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+                               SetLookupOptions::MATCH) {
+    ASSERT_OK_AND_ASSIGN(
+        Datum actual,
+        IndexIn(input, SetLookupOptions(value_set, null_matching_behavior)));
+    ASSERT_EQ(Datum::CHUNKED_ARRAY, actual.kind());
+    ValidateOutput(actual);
+
+    auto actual_chunked = actual.chunked_array();
+
+    // Output contiguous in a single chunk
+    ASSERT_EQ(1, actual_chunked->num_chunks());
+    ASSERT_TRUE(actual_chunked->Equals(*expected));
+  }
+
+  void CheckIndexInDictionary(
+      const std::shared_ptr<DataType>& type, const std::shared_ptr<DataType>& index_type,
+      const std::string& input_dictionary_json, const std::string& input_index_json,
+      const std::string& value_set_json, const std::string& expected_json,
+      SetLookupOptions::NullMatchingBehavior null_matching_behavior =
+          SetLookupOptions::MATCH) {
+    auto dict_type = dictionary(index_type, type);
+    auto indices = ArrayFromJSON(index_type, input_index_json);
+    auto dict = ArrayFromJSON(type, input_dictionary_json);
+
+    ASSERT_OK_AND_ASSIGN(auto input,
+                         DictionaryArray::FromArrays(dict_type, indices, dict));
+    auto value_set = ArrayFromJSON(type, value_set_json);
+    auto expected = ArrayFromJSON(int32(), expected_json);
+
+    SetLookupOptions options(value_set, null_matching_behavior);
+    ASSERT_OK_AND_ASSIGN(Datum actual_datum, IndexIn(input, options));
+    std::shared_ptr<Array> actual = actual_datum.make_array();
+    ValidateOutput(actual_datum);
+    AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+  }
+
+  void CheckIndexIn(const std::shared_ptr<Array>& input,
+                    const std::shared_ptr<Array>& value_set,
+                    const std::string& expected_json, bool skip_nulls) {
     std::shared_ptr<Array> expected = ArrayFromJSON(int32(), expected_json);
 
     SetLookupOptions options(value_set, skip_nulls);
@@ -526,7 +1077,7 @@ class TestIndexInKernel : public ::testing::Test {
 
   void CheckIndexIn(const std::shared_ptr<DataType>& type, const std::string& input_json,
                     const std::string& value_set_json, const std::string& expected_json,
-                    bool skip_nulls = false) {
+                    bool skip_nulls) {
     std::shared_ptr<Array> input = ArrayFromJSON(type, input_json);
     std::shared_ptr<Array> value_set = ArrayFromJSON(type, value_set_json);
     return CheckIndexIn(input, value_set, expected_json, skip_nulls);
@@ -553,7 +1104,7 @@ class TestIndexInKernel : public ::testing::Test {
                               const std::string& input_dictionary_json,
                               const std::string& input_index_json,
                               const std::string& value_set_json,
-                              const std::string& expected_json, bool skip_nulls = false) {
+                              const std::string& expected_json, bool skip_nulls) {
     auto dict_type = dictionary(index_type, type);
     auto indices = ArrayFromJSON(index_type, input_index_json);
     auto dict = ArrayFromJSON(type, input_dictionary_json);
@@ -656,6 +1207,16 @@ TYPED_TEST(TestIndexInKernelPrimitive, SkipNulls) {
                      /*value_set=*/"[1, 3]",
                      /*expected=*/"[null, 0, null, 1, null]",
                      /*skip_nulls=*/true);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 3]",
+                     /*expected=*/"[null, 0, null, 1, null]",
+                     /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 3]",
+                     /*expected=*/"[null, 0, null, 1, null]",
+                     /*null_matching_behavior=*/SetLookupOptions::SKIP);
   // Same with duplicates in value_set
   this->CheckIndexIn(type,
                      /*input=*/"[0, 1, 2, 3, null]",
@@ -667,6 +1228,16 @@ TYPED_TEST(TestIndexInKernelPrimitive, SkipNulls) {
                      /*value_set=*/"[1, 1, 3, 3]",
                      /*expected=*/"[null, 0, null, 2, null]",
                      /*skip_nulls=*/true);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 1, 3, 3]",
+                     /*expected=*/"[null, 0, null, 2, null]",
+                     /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 1, 3, 3]",
+                     /*expected=*/"[null, 0, null, 2, null]",
+                     /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   // Nulls in value_set
   this->CheckIndexIn(type,
@@ -679,12 +1250,27 @@ TYPED_TEST(TestIndexInKernelPrimitive, SkipNulls) {
                      /*value_set=*/"[1, 1, null, null, 3, 3]",
                      /*expected=*/"[null, 0, null, 4, null]",
                      /*skip_nulls=*/true);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, null, 3]",
+                     /*expected=*/"[null, 0, null, 2, 1]",
+                     /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 1, null, null, 3, 3]",
+                     /*expected=*/"[null, 0, null, 4, null]",
+                     /*null_matching_behavior=*/SetLookupOptions::SKIP);
   // Same with duplicates in value_set
   this->CheckIndexIn(type,
                      /*input=*/"[0, 1, 2, 3, null]",
                      /*value_set=*/"[1, 1, null, null, 3, 3]",
                      /*expected=*/"[null, 0, null, 4, 2]",
                      /*skip_nulls=*/false);
+  this->CheckIndexIn(type,
+                     /*input=*/"[0, 1, 2, 3, null]",
+                     /*value_set=*/"[1, 1, null, null, 3, 3]",
+                     /*expected=*/"[null, 0, null, 4, 2]",
+                     /*null_matching_behavior=*/SetLookupOptions::MATCH);
 }
 
 TEST_F(TestIndexInKernel, NullType) {
@@ -695,6 +1281,10 @@ TEST_F(TestIndexInKernel, NullType) {
 
   CheckIndexIn(null(), "[null, null]", "[null]", "[null, null]", /*skip_nulls=*/true);
   CheckIndexIn(null(), "[null, null]", "[]", "[null, null]", /*skip_nulls=*/true);
+  CheckIndexIn(null(), "[null, null]", "[null]", "[null, null]",
+               /*null_matching_behavior=*/SetLookupOptions::SKIP);
+  CheckIndexIn(null(), "[null, null]", "[]", "[null, null]",
+               /*null_matching_behavior=*/SetLookupOptions::SKIP);
 }
 
 TEST_F(TestIndexInKernel, TimeTimestamp) {
@@ -979,6 +1569,11 @@ TEST_F(TestIndexInKernel, FixedSizeBinary) {
                /*value_set=*/R"(["aaa", null, "bbb", "ccc"])",
                /*expected=*/R"([2, null, null, 0, 3, 0])",
                /*skip_nulls=*/true);
+  CheckIndexIn(fixed_size_binary(3),
+               /*input=*/R"(["bbb", null, "ddd", "aaa", "ccc", "aaa"])",
+               /*value_set=*/R"(["aaa", null, "bbb", "ccc"])",
+               /*expected=*/R"([2, null, null, 0, 3, 0])",
+               /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   CheckIndexIn(fixed_size_binary(3),
                /*input=*/R"(["bbb", null, "ddd", "aaa", "ccc", "aaa"])",
@@ -989,6 +1584,11 @@ TEST_F(TestIndexInKernel, FixedSizeBinary) {
                /*value_set=*/R"(["aaa", "bbb", "ccc"])",
                /*expected=*/R"([1, null, null, 0, 2, 0])",
                /*skip_nulls=*/true);
+  CheckIndexIn(fixed_size_binary(3),
+               /*input=*/R"(["bbb", null, "ddd", "aaa", "ccc", "aaa"])",
+               /*value_set=*/R"(["aaa", "bbb", "ccc"])",
+               /*expected=*/R"([1, null, null, 0, 2, 0])",
+               /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   // Duplicates in value_set
   CheckIndexIn(fixed_size_binary(3),
@@ -1000,6 +1600,11 @@ TEST_F(TestIndexInKernel, FixedSizeBinary) {
                /*value_set=*/R"(["aaa", "aaa", null, null, "bbb", "bbb", "ccc"])",
                /*expected=*/R"([4, null, null, 0, 6, 0])",
                /*skip_nulls=*/true);
+  CheckIndexIn(fixed_size_binary(3),
+               /*input=*/R"(["bbb", null, "ddd", "aaa", "ccc", "aaa"])",
+               /*value_set=*/R"(["aaa", "aaa", null, null, "bbb", "bbb", "ccc"])",
+               /*expected=*/R"([4, null, null, 0, 6, 0])",
+               /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   // Empty input array
   CheckIndexIn(fixed_size_binary(5), R"([])", R"(["bbbbb", null, "aaaaa", "ccccc"])",
@@ -1026,6 +1631,11 @@ TEST_F(TestIndexInKernel, MonthDayNanoInterval) {
                /*value_set=*/R"([null, [4, 5, 6], [5, -1, 5]])",
                /*expected=*/R"([2, 0, 1, 2, null])",
                /*skip_nulls=*/false);
+  CheckIndexIn(type,
+               /*input=*/R"([[5, -1, 5], null, [4, 5, 6], [5, -1, 5], [1, 2, 3]])",
+               /*value_set=*/R"([null, [4, 5, 6], [5, -1, 5]])",
+               /*expected=*/R"([2, 0, 1, 2, null])",
+               /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
   // Duplicates in value_set
   CheckIndexIn(
@@ -1034,6 +1644,12 @@ TEST_F(TestIndexInKernel, MonthDayNanoInterval) {
       /*value_set=*/R"([null, null, [0, 0, 0], [0, 0, 0], [7, 8, 0], [7, 8, 0]])",
       /*expected=*/R"([4, 0, 2, 4, null])",
       /*skip_nulls=*/false);
+  CheckIndexIn(
+      type,
+      /*input=*/R"([[7, 8, 0], null, [0, 0, 0], [7, 8, 0], [0, 0, 1]])",
+      /*value_set=*/R"([null, null, [0, 0, 0], [0, 0, 0], [7, 8, 0], [7, 8, 0]])",
+      /*expected=*/R"([4, 0, 2, 4, null])",
+      /*null_matching_behavior=*/SetLookupOptions::MATCH);
 }
 
 TEST_F(TestIndexInKernel, Decimal) {
@@ -1048,6 +1664,16 @@ TEST_F(TestIndexInKernel, Decimal) {
                  /*value_set=*/R"([null, "11", "12"])",
                  /*expected=*/R"([2, null, 1, 2, null])",
                  /*skip_nulls=*/true);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"([null, "11", "12"])",
+                 /*expected=*/R"([2, 0, 1, 2, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"([null, "11", "12"])",
+                 /*expected=*/R"([2, null, 1, 2, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
     CheckIndexIn(type,
                  /*input=*/R"(["12", null, "11", "12", "13"])",
@@ -1059,6 +1685,16 @@ TEST_F(TestIndexInKernel, Decimal) {
                  /*value_set=*/R"(["11", "12"])",
                  /*expected=*/R"([1, null, 0, 1, null])",
                  /*skip_nulls=*/true);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"(["11", "12"])",
+                 /*expected=*/R"([1, null, 0, 1, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"(["11", "12"])",
+                 /*expected=*/R"([1, null, 0, 1, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
     // Duplicates in value_set
     CheckIndexIn(type,
@@ -1076,6 +1712,21 @@ TEST_F(TestIndexInKernel, Decimal) {
                  /*value_set=*/R"([null, "11", "12"])",
                  /*expected=*/R"([2, 0, 1, 2, null])",
                  /*skip_nulls=*/false);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"([null, null, "11", "11", "12", "12"])",
+                 /*expected=*/R"([4, 0, 2, 4, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"([null, null, "11", "11", "12", "12"])",
+                 /*expected=*/R"([4, null, 2, 4, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIndexIn(type,
+                 /*input=*/R"(["12", null, "11", "12", "13"])",
+                 /*value_set=*/R"([null, "11", "12"])",
+                 /*expected=*/R"([2, 0, 1, 2, null])",
+                 /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
     CheckIndexIn(
         ArrayFromJSON(decimal256(3, 1), R"(["12.0", null, "11.0", "12.0", "13.0"])"),
@@ -1099,6 +1750,20 @@ TEST_F(TestIndexInKernel, DictionaryArray) {
                            /*value_set_json=*/"[4.1, 42, -1.0]",
                            /*expected_json=*/"[2, 1, null, 0]",
                            /*skip_nulls=*/false);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                           /*input_index_json=*/"[1, 2, null, 0]",
+                           /*value_set_json=*/R"(["A", "B", "C"])",
+                           /*expected_json=*/"[1, 2, null, 0]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexInDictionary(/*type=*/float32(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/"[4.1, -1.0, 42, 9.8]",
+                           /*input_index_json=*/"[1, 2, null, 0]",
+                           /*value_set_json=*/"[4.1, 42, -1.0]",
+                           /*expected_json=*/"[2, 1, null, 0]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
     // With nulls and skip_nulls=false
     CheckIndexInDictionary(/*type=*/utf8(),
@@ -1122,6 +1787,27 @@ TEST_F(TestIndexInKernel, DictionaryArray) {
                            /*value_set_json=*/R"(["C", "B", "A"])",
                            /*expected_json=*/"[null, null, null, 2, null]",
                            /*skip_nulls=*/false);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A", null])",
+                           /*expected_json=*/"[1, null, 3, 2, 1]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A", null])",
+                           /*expected_json=*/"[3, null, 3, 2, 3]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A"])",
+                           /*expected_json=*/"[null, null, null, 2, null]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
 
     // With nulls and skip_nulls=true
     CheckIndexInDictionary(/*type=*/utf8(),
@@ -1145,6 +1831,27 @@ TEST_F(TestIndexInKernel, DictionaryArray) {
                            /*value_set_json=*/R"(["C", "B", "A"])",
                            /*expected_json=*/"[null, null, null, 2, null]",
                            /*skip_nulls=*/true);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A", null])",
+                           /*expected_json=*/"[1, null, null, 2, 1]",
+                           /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A", null])",
+                           /*expected_json=*/"[null, null, null, 2, null]",
+                           /*null_matching_behavior=*/SetLookupOptions::SKIP);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "B", "A"])",
+                           /*expected_json=*/"[null, null, null, 2, null]",
+                           /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
     // With duplicates in value_set
     CheckIndexInDictionary(/*type=*/utf8(),
@@ -1168,6 +1875,27 @@ TEST_F(TestIndexInKernel, DictionaryArray) {
                            /*value_set_json=*/R"(["C", "C", "B", "B", "A", "A", null])",
                            /*expected_json=*/"[null, null, null, 4, null]",
                            /*skip_nulls=*/true);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", "B", "C", "D"])",
+                           /*input_index_json=*/"[1, 2, null, 0]",
+                           /*value_set_json=*/R"(["A", "A", "B", "B", "C", "C"])",
+                           /*expected_json=*/"[2, 4, null, 0]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "C", "B", "B", "A", "A", null])",
+                           /*expected_json=*/"[6, null, 6, 4, 6]",
+                           /*null_matching_behavior=*/SetLookupOptions::MATCH);
+    CheckIndexInDictionary(/*type=*/utf8(),
+                           /*index_type=*/index_ty,
+                           /*input_dictionary_json=*/R"(["A", null, "C", "D"])",
+                           /*input_index_json=*/"[1, 3, null, 0, 1]",
+                           /*value_set_json=*/R"(["C", "C", "B", "B", "A", "A", null])",
+                           /*expected_json=*/"[null, null, null, 4, null]",
+                           /*null_matching_behavior=*/SetLookupOptions::SKIP);
   }
 }
 
@@ -1181,21 +1909,33 @@ TEST_F(TestIndexInKernel, ChunkedArrayInvoke) {
 
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/false);
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::MATCH);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   // Null in value_set
   value_set = ChunkedArrayFromJSON(utf8(), {R"(["ghi", "def"])", R"([null, "abc"])"});
   expected = ChunkedArrayFromJSON(int32(), {"[3, 1, 0, 3, null]", "[1, 2, 3, null]"});
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/false);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::MATCH);
   expected = ChunkedArrayFromJSON(int32(), {"[3, 1, 0, 3, null]", "[1, null, 3, null]"});
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::SKIP);
 
   // Duplicates in value_set
   value_set = ChunkedArrayFromJSON(
       utf8(), {R"(["ghi", "ghi", "def"])", R"(["def", null, null, "abc"])"});
   expected = ChunkedArrayFromJSON(int32(), {"[6, 2, 0, 6, null]", "[2, 4, 6, null]"});
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/false);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::MATCH);
   expected = ChunkedArrayFromJSON(int32(), {"[6, 2, 0, 6, null]", "[2, null, 6, null]"});
   CheckIndexInChunked(input, value_set, expected, /*skip_nulls=*/true);
+  CheckIndexInChunked(input, value_set, expected,
+                      /*null_matching_behavior=*/SetLookupOptions::SKIP);
 }
 
 TEST(TestSetLookup, DispatchBest) {
diff --git a/cpp/src/arrow/util/reflection_internal.h b/cpp/src/arrow/util/reflection_internal.h
index d7de913bafd88..5d281a265ff71 100644
--- a/cpp/src/arrow/util/reflection_internal.h
+++ b/cpp/src/arrow/util/reflection_internal.h
@@ -71,6 +71,30 @@ constexpr DataMemberProperty<Class, Type> DataMember(std::string_view name,
   return {name, ptr};
 }
 
+template <typename C, typename T>
+struct CoercedDataMemberProperty {
+  using Class = C;
+  using Type = T;
+
+  constexpr Type get(const Class& obj) const { return (obj.*get_coerced_)(); }
+
+  void set(Class* obj, Type value) const { (*obj).*ptr_for_set_ = std::move(value); }
+
+  constexpr std::string_view name() const { return name_; }
+
+  std::string_view name_;
+  Type Class::*ptr_for_set_;
+  Type (Class::*get_coerced_)() const;
+};
+
+template <typename Class, typename Type>
+constexpr CoercedDataMemberProperty<Class, Type> CoercedDataMember(std::string_view name,
+                                                                   Type Class::*ptr,
+                                                                   Type (Class::*get)()
+                                                                       const) {
+  return {name, ptr, get};
+}
+
 template <typename... Properties>
 struct PropertyTuple {
   template <typename Fn>
diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 609307528d2ec..25f77d8160ea8 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -2366,7 +2366,7 @@ cdef class Expression(_Weakrefable):
       1,
       2,
       3
-    ], skip_nulls=false})>
+    ], null_matching_behavior=MATCH})>
     """
 
     def __init__(self):

From 7b14b2b2712bc483cd7d14bbc6c38e26d27074ac Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 25 Sep 2023 09:05:40 +0100
Subject: [PATCH 402/749] GH-36638: [R] Error with
 create_package_with_all_dependencies() on Windows (#37226)

### Rationale for this change

Fix path to directory which stops `create_package_with_all_dependencies()` working on Windows

### What changes are included in this PR?

Character replacement in the script to ensure that on Windows, wsl-comaptible path is used and paths are normalised.

### Are these changes tested?

I tested it locally myself and it works - there are no tests for this function.

### Are there any user-facing changes?

Nope
* Closes: #36638

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/install-arrow.R | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/r/R/install-arrow.R b/r/R/install-arrow.R
index 7017d4f39b876..715478f6d0542 100644
--- a/r/R/install-arrow.R
+++ b/r/R/install-arrow.R
@@ -215,19 +215,25 @@ create_package_with_all_dependencies <- function(dest_file = NULL, source_file =
   untar_dir <- tempfile()
   on.exit(unlink(untar_dir, recursive = TRUE), add = TRUE)
   utils::untar(source_file, exdir = untar_dir)
-  tools_dir <- file.path(untar_dir, "arrow/tools")
+  tools_dir <- file.path(normalizePath(untar_dir, winslash = "/"), "arrow/tools")
   download_dependencies_sh <- file.path(tools_dir, "download_dependencies_R.sh")
   # If you change this path, also need to edit nixlibs.R
   download_dir <- file.path(tools_dir, "thirdparty_dependencies")
   dir.create(download_dir)
   download_script <- tempfile(fileext = ".R")
+
+  if (isTRUE(Sys.info()["sysname"] == "Windows")) {
+    download_dependencies_sh <- wslify_path(download_dependencies_sh)
+  }
+
   parse_versions_success <- system2(
     "bash", c(download_dependencies_sh, download_dir),
     stdout = download_script,
     stderr = FALSE
   ) == 0
+
   if (!parse_versions_success) {
-    stop("Failed to parse versions.txt")
+    stop(paste("Failed to parse versions.txt; view ", download_script, "for more information", collapse = ""))
   }
   # `source` the download_script to use R to download all the dependency bundles
   source(download_script)
@@ -250,3 +256,14 @@ create_package_with_all_dependencies <- function(dest_file = NULL, source_file =
   }
   invisible(dest_file)
 }
+
+# Convert a Windows path to a WSL path
+# e.g. wslify_path("C:/Users/user/AppData/") returns "/mnt/c/Users/user/AppData"
+wslify_path <- function(path) {
+  m <- regexpr("[A-Z]:/", path)
+  drive_expr <- regmatches(path, m)
+  drive_letter <- strsplit(drive_expr, ":/")[[1]]
+  wslified_drive <- paste0("/mnt/", tolower(drive_letter))
+  end_path <- strsplit(path, drive_expr)[[1]][-1]
+  file.path(wslified_drive, end_path)
+}

From 64acef8c5ce9731c6c73c5be386535e7af3af5f8 Mon Sep 17 00:00:00 2001
From: David Li <li.davidm96@gmail.com>
Date: Mon, 25 Sep 2023 08:45:08 -0400
Subject: [PATCH 403/749] GH-37722: [Java][FlightRPC] Deprecate stateful login
 methods (#37833)

### Rationale for this change

The existence of these interfaces confuses users and leads them to antipatterns.

### What changes are included in this PR?

Deprecate (but not for removal) the old interfaces.

### Are these changes tested?

N/A

### Are there any user-facing changes?

Yes.
* Closes: #37722

Authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../org/apache/arrow/flight/auth/ClientAuthHandler.java  | 7 +++++++
 .../org/apache/arrow/flight/auth/ServerAuthHandler.java  | 9 +++++++++
 2 files changed, 16 insertions(+)

diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ClientAuthHandler.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ClientAuthHandler.java
index 985e10aa4dd4b..af7da86e009e6 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ClientAuthHandler.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ClientAuthHandler.java
@@ -19,9 +19,16 @@
 
 import java.util.Iterator;
 
+import org.apache.arrow.flight.FlightClient;
+
 /**
  * Implement authentication for Flight on the client side.
+ *
+ * @deprecated As of 14.0.0. This implements a stateful "login" flow that does not play well with
+ *     distributed or stateless systems. It will not be removed, but should not be used. Instead
+ *     see {@link FlightClient#authenticateBasicToken(String, String)}.
  */
+@Deprecated
 public interface ClientAuthHandler {
   /**
    * Handle the initial handshake with the server.
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ServerAuthHandler.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ServerAuthHandler.java
index 3a978b131f26c..378027c9287fe 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ServerAuthHandler.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth/ServerAuthHandler.java
@@ -20,9 +20,18 @@
 import java.util.Iterator;
 import java.util.Optional;
 
+import org.apache.arrow.flight.FlightServer;
+import org.apache.arrow.flight.auth2.CallHeaderAuthenticator;
+
 /**
  * Interface for Server side authentication handlers.
+ *
+ * @deprecated As of 14.0.0. This implements a stateful "login" flow that does not play well with
+ *     distributed or stateless systems. It will not be removed, but should not be used. Instead,
+ *     see {@link FlightServer.Builder#headerAuthenticator(CallHeaderAuthenticator)}
+ *     and {@link CallHeaderAuthenticator}.
  */
+@Deprecated
 public interface ServerAuthHandler {
 
   /**

From e55f912ecbce21ad46043bdffe32712272d6268a Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 25 Sep 2023 06:04:18 -0700
Subject: [PATCH 404/749] GH-36795: [C#] Implement support for dense and sparse
 unions (#36797)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### What changes are included in this PR?

Support dense and sparse unions in the C# implementation.
Adds Archery support for C# unions.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Unions are now supported in the C# implementation.

**This PR includes breaking changes to public APIs.**

The public APIs for the UnionArray and UnionType were changed fairly substantially. As these were previously not implemented properly, the impact of the changes ought to be minimal.

The ChunkedArray and Column classes were changed to hold IArrowArrays instead of Arrays. To accomodate this, a constructor was added which may introduce ambiguity in calling code. This could be avoided by changing the overloaded constructor to instead be a factory method. This didn't seem worthwhile but could be reconsidered.

The metadata version was finally increased to V5.
 
* Closes: #36795

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 csharp/src/Apache.Arrow/Arrays/Array.cs       |  13 +--
 .../Arrays/ArrayDataConcatenator.cs           |  62 ++++++++++-
 .../Arrays/ArrayDataTypeComparer.cs           |  12 +-
 .../Apache.Arrow/Arrays/ArrowArrayFactory.cs  |  16 ++-
 .../Apache.Arrow/Arrays/DenseUnionArray.cs    |  52 +++++++++
 .../Arrays/PrimitiveArrayBuilder.cs           |   3 +
 .../Apache.Arrow/Arrays/SparseUnionArray.cs   |  46 ++++++++
 csharp/src/Apache.Arrow/Arrays/UnionArray.cs  |  77 ++++++++++---
 .../src/Apache.Arrow/C/CArrowArrayImporter.cs |  38 +++++++
 .../Apache.Arrow/C/CArrowSchemaExporter.cs    |  18 +++
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |  56 +++++++---
 csharp/src/Apache.Arrow/ChunkedArray.cs       |  30 +++--
 csharp/src/Apache.Arrow/Column.cs             |  24 ++--
 .../Extensions/FlatbufExtensions.cs           |  10 ++
 .../Apache.Arrow/Interfaces/IArrowArray.cs    |   4 -
 .../Ipc/ArrowReaderImplementation.cs          |  75 ++++++++-----
 .../src/Apache.Arrow/Ipc/ArrowStreamWriter.cs |  19 +++-
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |  14 ++-
 .../src/Apache.Arrow/Ipc/MessageSerializer.cs |   4 +
 csharp/src/Apache.Arrow/Table.cs              |   4 +-
 csharp/src/Apache.Arrow/Types/UnionType.cs    |  11 +-
 .../IntegrationCommand.cs                     |  63 ++++++++++-
 .../Apache.Arrow.IntegrationTest/JsonFile.cs  |   4 +
 .../Apache.Arrow.Tests/ArrayTypeComparer.cs   |  19 +++-
 .../ArrowArrayConcatenatorTests.cs            | 104 +++++++++++++++++-
 .../Apache.Arrow.Tests/ArrowReaderVerifier.cs |  19 ++++
 .../CDataInterfacePythonTests.cs              |  36 ++++--
 csharp/test/Apache.Arrow.Tests/ColumnTests.cs |   2 +-
 csharp/test/Apache.Arrow.Tests/TableTests.cs  |  10 +-
 csharp/test/Apache.Arrow.Tests/TestData.cs    |  64 +++++++++++
 dev/archery/archery/integration/datagen.py    |   3 +-
 docs/source/status.rst                        |   4 +-
 32 files changed, 797 insertions(+), 119 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Arrays/DenseUnionArray.cs
 create mode 100644 csharp/src/Apache.Arrow/Arrays/SparseUnionArray.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/Array.cs b/csharp/src/Apache.Arrow/Arrays/Array.cs
index a453b0807267f..0838134b19c6d 100644
--- a/csharp/src/Apache.Arrow/Arrays/Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Array.cs
@@ -62,16 +62,7 @@ internal static void Accept<T>(T array, IArrowArrayVisitor visitor)
 
         public Array Slice(int offset, int length)
         {
-            if (offset > Length)
-            {
-                throw new ArgumentException($"Offset {offset} cannot be greater than Length {Length} for Array.Slice");
-            }
-
-            length = Math.Min(Data.Length - offset, length);
-            offset += Data.Offset;
-
-            ArrayData newData = Data.Slice(offset, length);
-            return ArrowArrayFactory.BuildArray(newData) as Array;
+            return ArrowArrayFactory.Slice(this, offset, length) as Array;
         }
 
         public void Dispose()
@@ -88,4 +79,4 @@ protected virtual void Dispose(bool disposing)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
index 8859ecd7f05b9..806defdc7ce66 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
@@ -49,7 +49,8 @@ private class ArrayDataConcatenationVisitor :
             IArrowTypeVisitor<StringType>,
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
-            IArrowTypeVisitor<StructType>
+            IArrowTypeVisitor<StructType>,
+            IArrowTypeVisitor<UnionType>
         {
             public ArrayData Result { get; private set; }
             private readonly IReadOnlyList<ArrayData> _arrayDataList;
@@ -123,6 +124,33 @@ public void Visit(StructType type)
                 Result = new ArrayData(type, _arrayDataList[0].Length, _arrayDataList[0].NullCount, 0, _arrayDataList[0].Buffers, children);
             }
 
+            public void Visit(UnionType type)
+            {
+                int bufferCount = type.Mode switch
+                {
+                    UnionMode.Sparse => 1,
+                    UnionMode.Dense => 2,
+                    _ => throw new InvalidOperationException("TODO"),
+                };
+
+                CheckData(type, bufferCount);
+                List<ArrayData> children = new List<ArrayData>(type.Fields.Count);
+
+                for (int i = 0; i < type.Fields.Count; i++)
+                {
+                    children.Add(Concatenate(SelectChildren(i), _allocator));
+                }
+
+                ArrowBuffer[] buffers = new ArrowBuffer[bufferCount];
+                buffers[0] = ConcatenateUnionTypeBuffer();
+                if (bufferCount > 1)
+                {
+                    buffers[1] = ConcatenateUnionOffsetBuffer();
+                }
+
+                Result = new ArrayData(type, _totalLength, _totalNullCount, 0, buffers, children);
+            }
+
             public void Visit(IArrowType type)
             {
                 throw new NotImplementedException($"Concatenation for {type.Name} is not supported yet.");
@@ -231,6 +259,38 @@ private ArrowBuffer ConcatenateOffsetBuffer()
                 return builder.Build(_allocator);
             }
 
+            private ArrowBuffer ConcatenateUnionTypeBuffer()
+            {
+                var builder = new ArrowBuffer.Builder<byte>(_totalLength);
+
+                foreach (ArrayData arrayData in _arrayDataList)
+                {
+                    builder.Append(arrayData.Buffers[0]);
+                }
+
+                return builder.Build(_allocator);
+            }
+
+            private ArrowBuffer ConcatenateUnionOffsetBuffer()
+            {
+                var builder = new ArrowBuffer.Builder<int>(_totalLength);
+                int baseOffset = 0;
+
+                foreach (ArrayData arrayData in _arrayDataList)
+                {
+                    ReadOnlySpan<int> span = arrayData.Buffers[1].Span.CastTo<int>();
+                    foreach (int offset in span)
+                    {
+                        builder.Append(baseOffset + offset);
+                    }
+
+                    // The next offset must start from the current last offset.
+                    baseOffset += span[arrayData.Length];
+                }
+
+                return builder.Build(_allocator);
+            }
+
             private List<ArrayData> SelectChildren(int index)
             {
                 var children = new List<ArrayData>(_arrayDataList.Count);
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
index 8a6bfed29abb6..6b54ec1edb573 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
@@ -27,7 +27,8 @@ internal sealed class ArrayDataTypeComparer :
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
-        IArrowTypeVisitor<StructType>
+        IArrowTypeVisitor<StructType>,
+        IArrowTypeVisitor<UnionType>
     {
         private readonly IArrowType _expectedType;
         private bool _dataTypeMatch;
@@ -122,6 +123,15 @@ public void Visit(StructType actualType)
             }
         }
 
+        public void Visit(UnionType actualType)
+        {
+            if (_expectedType is UnionType expectedType
+                && CompareNested(expectedType, actualType))
+            {
+                _dataTypeMatch = true;
+            }
+        }
+
         private static bool CompareNested(NestedType expectedType, NestedType actualType)
         {
             if (expectedType.Fields.Count != actualType.Fields.Count)
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
index f82037bff47b1..aa407203d1858 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
@@ -62,7 +62,7 @@ public static IArrowArray BuildArray(ArrayData data)
                 case ArrowTypeId.Struct:
                     return new StructArray(data);
                 case ArrowTypeId.Union:
-                    return new UnionArray(data);
+                    return UnionArray.Create(data);
                 case ArrowTypeId.Date64:
                     return new Date64Array(data);
                 case ArrowTypeId.Date32:
@@ -91,5 +91,19 @@ public static IArrowArray BuildArray(ArrayData data)
                     throw new NotSupportedException($"An ArrowArray cannot be built for type {data.DataType.TypeId}.");
             }
         }
+
+        public static IArrowArray Slice(IArrowArray array, int offset, int length)
+        {
+            if (offset > array.Length)
+            {
+                throw new ArgumentException($"Offset {offset} cannot be greater than Length {array.Length} for Array.Slice");
+            }
+
+            length = Math.Min(array.Data.Length - offset, length);
+            offset += array.Data.Offset;
+
+            ArrayData newData = array.Data.Slice(offset, length);
+            return BuildArray(newData);
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/DenseUnionArray.cs b/csharp/src/Apache.Arrow/Arrays/DenseUnionArray.cs
new file mode 100644
index 0000000000000..1aacbe11f08b9
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/DenseUnionArray.cs
@@ -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.
+
+using Apache.Arrow.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Apache.Arrow
+{
+    public class DenseUnionArray : UnionArray
+    {
+        public ArrowBuffer ValueOffsetBuffer => Data.Buffers[1];
+
+        public ReadOnlySpan<int> ValueOffsets => ValueOffsetBuffer.Span.CastTo<int>();
+
+        public DenseUnionArray(
+            IArrowType dataType,
+            int length,
+            IEnumerable<IArrowArray> children,
+            ArrowBuffer typeIds,
+            ArrowBuffer valuesOffsetBuffer,
+            int nullCount = 0,
+            int offset = 0)
+            : base(new ArrayData(
+                dataType, length, nullCount, offset, new[] { typeIds, valuesOffsetBuffer },
+                children.Select(child => child.Data)))
+        {
+            _fields = children.ToArray();
+            ValidateMode(UnionMode.Dense, Type.Mode);
+        }
+
+        public DenseUnionArray(ArrayData data) 
+            : base(data)
+        {
+            ValidateMode(UnionMode.Dense, Type.Mode);
+            data.EnsureBufferCount(2);
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs b/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs
index a50d4b52c3257..67fe46633c18f 100644
--- a/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs
+++ b/csharp/src/Apache.Arrow/Arrays/PrimitiveArrayBuilder.cs
@@ -137,6 +137,9 @@ public TBuilder Append(T value)
             return Instance;
         }
 
+        public TBuilder Append(T? value) =>
+            (value == null) ? AppendNull() : Append(value.Value);
+
         public TBuilder Append(ReadOnlySpan<T> span)
         {
             int len = ValueBuffer.Length;
diff --git a/csharp/src/Apache.Arrow/Arrays/SparseUnionArray.cs b/csharp/src/Apache.Arrow/Arrays/SparseUnionArray.cs
new file mode 100644
index 0000000000000..b79c44c979e47
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/SparseUnionArray.cs
@@ -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.
+
+using Apache.Arrow.Types;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Apache.Arrow
+{
+    public class SparseUnionArray : UnionArray
+    {
+        public SparseUnionArray(
+            IArrowType dataType,
+            int length,
+            IEnumerable<IArrowArray> children,
+            ArrowBuffer typeIds,
+            int nullCount = 0,
+            int offset = 0)
+            : base(new ArrayData(
+                dataType, length, nullCount, offset, new[] { typeIds },
+                children.Select(child => child.Data)))
+        {
+            _fields = children.ToArray();
+            ValidateMode(UnionMode.Sparse, Type.Mode);
+        }
+
+        public SparseUnionArray(ArrayData data) 
+            : base(data)
+        {
+            ValidateMode(UnionMode.Sparse, Type.Mode);
+            data.EnsureBufferCount(1);
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Arrays/UnionArray.cs b/csharp/src/Apache.Arrow/Arrays/UnionArray.cs
index 8bccea2b59e31..0a7ae288fd0c5 100644
--- a/csharp/src/Apache.Arrow/Arrays/UnionArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/UnionArray.cs
@@ -15,37 +15,88 @@
 
 using Apache.Arrow.Types;
 using System;
+using System.Collections.Generic;
+using System.Threading;
 
 namespace Apache.Arrow
 {
-    public class UnionArray: Array
+    public abstract class UnionArray : IArrowArray
     {
-        public UnionType Type => Data.DataType as UnionType;
+        protected IReadOnlyList<IArrowArray> _fields;
 
-        public UnionMode Mode => Type.Mode;
+        public IReadOnlyList<IArrowArray> Fields =>
+            LazyInitializer.EnsureInitialized(ref _fields, () => InitializeFields());
+
+        public ArrayData Data { get; }
 
-        public ArrowBuffer TypeBuffer => Data.Buffers[1];
+        public UnionType Type => (UnionType)Data.DataType;
 
-        public ArrowBuffer ValueOffsetBuffer => Data.Buffers[2];
+        public UnionMode Mode => Type.Mode;
+
+        public ArrowBuffer TypeBuffer => Data.Buffers[0];
 
         public ReadOnlySpan<byte> TypeIds => TypeBuffer.Span;
 
-        public ReadOnlySpan<int> ValueOffsets => ValueOffsetBuffer.Span.CastTo<int>().Slice(0, Length + 1);
+        public int Length => Data.Length;
+
+        public int Offset => Data.Offset;
 
-        public UnionArray(ArrayData data) 
-            : base(data)
+        public int NullCount => Data.NullCount;
+
+        public bool IsValid(int index) => NullCount == 0 || Fields[TypeIds[index]].IsValid(index);
+
+        public bool IsNull(int index) => !IsValid(index);
+
+        protected UnionArray(ArrayData data) 
         {
+            Data = data;
             data.EnsureDataType(ArrowTypeId.Union);
-            data.EnsureBufferCount(3);
         }
 
-        public IArrowArray GetChild(int index)
+        public static UnionArray Create(ArrayData data)
         {
-            // TODO: Implement
-            throw new NotImplementedException();
+            return ((UnionType)data.DataType).Mode switch
+            {
+                UnionMode.Dense => new DenseUnionArray(data),
+                UnionMode.Sparse => new SparseUnionArray(data),
+                _ => throw new InvalidOperationException("unknown union mode in array creation")
+            };
         }
 
-        public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor);
+        public void Accept(IArrowArrayVisitor visitor) => Array.Accept(this, visitor);
 
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Data.Dispose();
+            }
+        }
+
+        protected static void ValidateMode(UnionMode expected, UnionMode actual)
+        {
+            if (expected != actual)
+            {
+                throw new ArgumentException(
+                    $"Specified union mode <{actual}> does not match expected mode <{expected}>",
+                    "Mode");
+            }
+        }
+
+        private IReadOnlyList<IArrowArray> InitializeFields()
+        {
+            IArrowArray[] result = new IArrowArray[Data.Children.Length];
+            for (int i = 0; i < Data.Children.Length; i++)
+            {
+                result[i] = ArrowArrayFactory.BuildArray(Data.Children[i]);
+            }
+            return result;
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
index 9b7bcb7abe5a5..da1b0f31b8f08 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
@@ -170,6 +170,15 @@ private ArrayData GetAsArrayData(CArrowArray* cArray, IArrowType type)
                         buffers = new ArrowBuffer[] { ImportValidityBuffer(cArray) };
                         break;
                     case ArrowTypeId.Union:
+                        UnionType unionType = (UnionType)type;
+                        children = ProcessStructChildren(cArray, unionType.Fields);
+                        buffers = unionType.Mode switch
+                        {
+                            UnionMode.Dense => ImportDenseUnionBuffers(cArray),
+                            UnionMode.Sparse => ImportSparseUnionBuffers(cArray),
+                            _ => throw new InvalidOperationException("unknown union mode in import")
+                        }; ;
+                        break;
                     case ArrowTypeId.Map:
                         break;
                     case ArrowTypeId.Null:
@@ -286,6 +295,35 @@ private ArrowBuffer[] ImportFixedSizeListBuffers(CArrowArray* cArray)
                 return buffers;
             }
 
+            private ArrowBuffer[] ImportDenseUnionBuffers(CArrowArray* cArray)
+            {
+                if (cArray->n_buffers != 2)
+                {
+                    throw new InvalidOperationException("Dense union arrays are expected to have exactly two children");
+                }
+                int length = checked((int)cArray->length);
+                int offsetsLength = length * 4;
+
+                ArrowBuffer[] buffers = new ArrowBuffer[2];
+                buffers[0] = new ArrowBuffer(AddMemory((IntPtr)cArray->buffers[0], 0, length));
+                buffers[1] = new ArrowBuffer(AddMemory((IntPtr)cArray->buffers[1], 0, offsetsLength));
+
+                return buffers;
+            }
+
+            private ArrowBuffer[] ImportSparseUnionBuffers(CArrowArray* cArray)
+            {
+                if (cArray->n_buffers != 1)
+                {
+                    throw new InvalidOperationException("Sparse union arrays are expected to have exactly one child");
+                }
+
+                ArrowBuffer[] buffers = new ArrowBuffer[1];
+                buffers[0] = new ArrowBuffer(AddMemory((IntPtr)cArray->buffers[0], 0, checked((int)cArray->length)));
+
+                return buffers;
+            }
+
             private ArrowBuffer[] ImportFixedWidthBuffers(CArrowArray* cArray, int bitWidth)
             {
                 if (cArray->n_buffers != 2)
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
index 66142da331ac8..c1a12362a942a 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
@@ -124,6 +124,23 @@ public static unsafe void ExportSchema(Schema schema, CArrowSchema* out_schema)
             _ => throw new InvalidDataException($"Unsupported time unit for export: {unit}"),
         };
 
+        private static string FormatUnion(UnionType unionType)
+        {
+            StringBuilder builder = new StringBuilder();
+            builder.Append(unionType.Mode switch
+            {
+                UnionMode.Sparse => "+us:",
+                UnionMode.Dense => "+ud:",
+                _ => throw new InvalidDataException($"Unsupported union mode for export: {unionType.Mode}"),
+            });
+            for (int i = 0; i < unionType.TypeIds.Length; i++)
+            {
+                if (i > 0) { builder.Append(','); }
+                builder.Append(unionType.TypeIds[i]);
+            }
+            return builder.ToString();
+        }
+
         private static string GetFormat(IArrowType datatype)
         {
             switch (datatype)
@@ -170,6 +187,7 @@ private static string GetFormat(IArrowType datatype)
                 case FixedSizeListType fixedListType:
                     return $"+w:{fixedListType.ListSize}";
                 case StructType _: return "+s";
+                case UnionType u: return FormatUnion(u);
                 // Dictionary
                 case DictionaryType dictionaryType:
                     return GetFormat(dictionaryType.IndexType);
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index 2a750d5e8250d..42c8cdd5ef548 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -184,21 +184,7 @@ public ArrowType GetAsType()
                 }
                 else if (format == "+s")
                 {
-                    var child_schemas = new ImportedArrowSchema[_cSchema->n_children];
-
-                    for (int i = 0; i < _cSchema->n_children; i++)
-                    {
-                        if (_cSchema->GetChild(i) == null)
-                        {
-                            throw new InvalidDataException("Expected struct type child to be non-null.");
-                        }
-                        child_schemas[i] = new ImportedArrowSchema(_cSchema->GetChild(i), isRoot: false);
-                    }
-
-
-                    List<Field> childFields = child_schemas.Select(schema => schema.GetAsField()).ToList();
-
-                    return new StructType(childFields);
+                    return new StructType(ParseChildren("struct"));
                 }
                 else if (format.StartsWith("+w:"))
                 {
@@ -265,6 +251,30 @@ public ArrowType GetAsType()
                     return new FixedSizeBinaryType(width);
                 }
 
+                // Unions
+                if (format.StartsWith("+ud:") || format.StartsWith("+us:"))
+                {
+                    UnionMode unionMode = format[2] == 'd' ? UnionMode.Dense : UnionMode.Sparse;
+                    List<int> typeIds = new List<int>();
+                    int pos = 4;
+                    do
+                    {
+                        int next = format.IndexOf(',', pos);
+                        if (next < 0) { next = format.Length; }
+
+                        int code;
+                        if (!int.TryParse(format.Substring(pos, next - pos), out code))
+                        {
+                            throw new InvalidDataException($"Invalid type code for union import: {format.Substring(pos, next - pos)}");
+                        }
+                        typeIds.Add(code);
+
+                        pos = next + 1;
+                    } while (pos < format.Length);
+
+                    return new UnionType(ParseChildren("union"), typeIds, unionMode);
+                }
+
                 return format switch
                 {
                     // Primitives
@@ -324,6 +334,22 @@ public Schema GetAsSchema()
                 }
             }
 
+            private List<Field> ParseChildren(string typeName)
+            {
+                var child_schemas = new ImportedArrowSchema[_cSchema->n_children];
+
+                for (int i = 0; i < _cSchema->n_children; i++)
+                {
+                    if (_cSchema->GetChild(i) == null)
+                    {
+                        throw new InvalidDataException($"Expected {typeName} type child to be non-null.");
+                    }
+                    child_schemas[i] = new ImportedArrowSchema(_cSchema->GetChild(i), isRoot: false);
+                }
+
+                return child_schemas.Select(schema => schema.GetAsField()).ToList();
+            }
+
             private unsafe static IReadOnlyDictionary<string, string> GetMetadata(byte* metadata)
             {
                 if (metadata == null)
diff --git a/csharp/src/Apache.Arrow/ChunkedArray.cs b/csharp/src/Apache.Arrow/ChunkedArray.cs
index 5f25acfe04a2f..f5909f5adfe48 100644
--- a/csharp/src/Apache.Arrow/ChunkedArray.cs
+++ b/csharp/src/Apache.Arrow/ChunkedArray.cs
@@ -15,7 +15,6 @@
 
 using System;
 using System.Collections.Generic;
-using Apache.Arrow;
 using Apache.Arrow.Types;
 
 namespace Apache.Arrow
@@ -25,7 +24,7 @@ namespace Apache.Arrow
     /// </summary>
     public class ChunkedArray
     {
-        private IList<Array> Arrays { get; }
+        private IList<IArrowArray> Arrays { get; }
         public IArrowType DataType { get; }
         public long Length { get; }
         public long NullCount { get; }
@@ -35,9 +34,16 @@ public int ArrayCount
             get => Arrays.Count;
         }
 
-        public Array Array(int index) => Arrays[index];
+        public Array Array(int index) => Arrays[index] as Array;
+
+        public IArrowArray ArrowArray(int index) => Arrays[index];
 
         public ChunkedArray(IList<Array> arrays)
+            : this(Cast(arrays))
+        {
+        }
+
+        public ChunkedArray(IList<IArrowArray> arrays)
         {
             Arrays = arrays ?? throw new ArgumentNullException(nameof(arrays));
             if (arrays.Count < 1)
@@ -45,14 +51,14 @@ public ChunkedArray(IList<Array> arrays)
                 throw new ArgumentException($"Count must be at least 1. Got {arrays.Count} instead");
             }
             DataType = arrays[0].Data.DataType;
-            foreach (Array array in arrays)
+            foreach (IArrowArray array in arrays)
             {
                 Length += array.Length;
                 NullCount += array.NullCount;
             }
         }
 
-        public ChunkedArray(Array array) : this(new[] { array }) { }
+        public ChunkedArray(Array array) : this(new IArrowArray[] { array }) { }
 
         public ChunkedArray Slice(long offset, long length)
         {
@@ -69,10 +75,10 @@ public ChunkedArray Slice(long offset, long length)
                 curArrayIndex++;
             }
 
-            IList<Array> newArrays = new List<Array>();
+            IList<IArrowArray> newArrays = new List<IArrowArray>();
             while (curArrayIndex < numArrays && length > 0)
             {
-                newArrays.Add(Arrays[curArrayIndex].Slice((int)offset,
+                newArrays.Add(ArrowArrayFactory.Slice(Arrays[curArrayIndex], (int)offset,
                               length > Arrays[curArrayIndex].Length ? Arrays[curArrayIndex].Length : (int)length));
                 length -= Arrays[curArrayIndex].Length - offset;
                 offset = 0;
@@ -86,6 +92,16 @@ public ChunkedArray Slice(long offset)
             return Slice(offset, Length - offset);
         }
 
+        private static IArrowArray[] Cast(IList<Array> arrays)
+        {
+            IArrowArray[] arrowArrays = new IArrowArray[arrays.Count];
+            for (int i = 0; i < arrays.Count; i++)
+            {
+                arrowArrays[i] = arrays[i];
+            }
+            return arrowArrays;
+        }
+
         // TODO: Flatten for Structs
     }
 }
diff --git a/csharp/src/Apache.Arrow/Column.cs b/csharp/src/Apache.Arrow/Column.cs
index 4eaf9a559e75d..0709b9142cafd 100644
--- a/csharp/src/Apache.Arrow/Column.cs
+++ b/csharp/src/Apache.Arrow/Column.cs
@@ -28,19 +28,23 @@ public class Column
         public ChunkedArray Data { get; }
 
         public Column(Field field, IList<Array> arrays)
+            : this(field, new ChunkedArray(arrays), doValidation: true)
+        {
+        }
+
+        public Column(Field field, IList<IArrowArray> arrays)
+            : this(field, new ChunkedArray(arrays), doValidation: true)
         {
-            Data = new ChunkedArray(arrays);
-            Field = field;
-            if (!ValidateArrayDataTypes())
-            {
-                throw new ArgumentException($"{Field.DataType} must match {Data.DataType}");
-            }
         }
 
-        private Column(Field field, ChunkedArray arrays)
+        private Column(Field field, ChunkedArray data, bool doValidation = false)
         {
+            Data = data;
             Field = field;
-            Data = arrays;
+            if (doValidation && !ValidateArrayDataTypes())
+            {
+                throw new ArgumentException($"{Field.DataType} must match {Data.DataType}");
+            }
         }
 
         public long Length => Data.Length;
@@ -64,12 +68,12 @@ private bool ValidateArrayDataTypes()
 
             for (int i = 0; i < Data.ArrayCount; i++)
             {
-                if (Data.Array(i).Data.DataType.TypeId != Field.DataType.TypeId)
+                if (Data.ArrowArray(i).Data.DataType.TypeId != Field.DataType.TypeId)
                 {
                     return false;
                 }
 
-                Data.Array(i).Data.DataType.Accept(dataTypeComparer);
+                Data.ArrowArray(i).Data.DataType.Accept(dataTypeComparer);
 
                 if (!dataTypeComparer.DataTypeMatch)
                 {
diff --git a/csharp/src/Apache.Arrow/Extensions/FlatbufExtensions.cs b/csharp/src/Apache.Arrow/Extensions/FlatbufExtensions.cs
index d2a70bca9e4ec..35c5b3e55157d 100644
--- a/csharp/src/Apache.Arrow/Extensions/FlatbufExtensions.cs
+++ b/csharp/src/Apache.Arrow/Extensions/FlatbufExtensions.cs
@@ -80,6 +80,16 @@ public static Types.TimeUnit ToArrow(this Flatbuf.TimeUnit unit)
                     throw new ArgumentException($"Unexpected Flatbuf TimeUnit", nameof(unit));
             }
         }
+
+        public static Types.UnionMode ToArrow(this Flatbuf.UnionMode mode)
+        {
+            return mode switch
+            {
+                Flatbuf.UnionMode.Dense => Types.UnionMode.Dense,
+                Flatbuf.UnionMode.Sparse => Types.UnionMode.Sparse,
+                _ => throw new ArgumentException($"Unsupported Flatbuf UnionMode", nameof(mode)),
+            };
+        }
     }
 }
 
diff --git a/csharp/src/Apache.Arrow/Interfaces/IArrowArray.cs b/csharp/src/Apache.Arrow/Interfaces/IArrowArray.cs
index 50fbc3af6dd72..9bcee36ef4eaf 100644
--- a/csharp/src/Apache.Arrow/Interfaces/IArrowArray.cs
+++ b/csharp/src/Apache.Arrow/Interfaces/IArrowArray.cs
@@ -32,9 +32,5 @@ public interface IArrowArray : IDisposable
         ArrayData Data { get; }
 
         void Accept(IArrowArrayVisitor visitor);
-
-        //IArrowArray Slice(int offset);
-
-        //IArrowArray Slice(int offset, int length);
     }
 }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
index c9c1b21673316..d3115da52cc6c 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowReaderImplementation.cs
@@ -116,11 +116,11 @@ protected RecordBatch CreateArrowObjectFromMessage(
                     break;
                 case Flatbuf.MessageHeader.DictionaryBatch:
                     Flatbuf.DictionaryBatch dictionaryBatch = message.Header<Flatbuf.DictionaryBatch>().Value;
-                    ReadDictionaryBatch(dictionaryBatch, bodyByteBuffer, memoryOwner);
+                    ReadDictionaryBatch(message.Version, dictionaryBatch, bodyByteBuffer, memoryOwner);
                     break;
                 case Flatbuf.MessageHeader.RecordBatch:
                     Flatbuf.RecordBatch rb = message.Header<Flatbuf.RecordBatch>().Value;
-                    List<IArrowArray> arrays = BuildArrays(Schema, bodyByteBuffer, rb);
+                    List<IArrowArray> arrays = BuildArrays(message.Version, Schema, bodyByteBuffer, rb);
                     return new RecordBatch(Schema, memoryOwner, arrays, (int)rb.Length);
                 default:
                     // NOTE: Skip unsupported message type
@@ -136,7 +136,11 @@ internal static ByteBuffer CreateByteBuffer(ReadOnlyMemory<byte> buffer)
             return new ByteBuffer(new ReadOnlyMemoryBufferAllocator(buffer), 0);
         }
 
-        private void ReadDictionaryBatch(Flatbuf.DictionaryBatch dictionaryBatch, ByteBuffer bodyByteBuffer, IMemoryOwner<byte> memoryOwner)
+        private void ReadDictionaryBatch(
+            MetadataVersion version,
+            Flatbuf.DictionaryBatch dictionaryBatch,
+            ByteBuffer bodyByteBuffer,
+            IMemoryOwner<byte> memoryOwner)
         {
             long id = dictionaryBatch.Id;
             IArrowType valueType = DictionaryMemo.GetDictionaryType(id);
@@ -149,7 +153,7 @@ private void ReadDictionaryBatch(Flatbuf.DictionaryBatch dictionaryBatch, ByteBu
 
             Field valueField = new Field("dummy", valueType, true);
             var schema = new Schema(new[] { valueField }, default);
-            IList<IArrowArray> arrays = BuildArrays(schema, bodyByteBuffer, recordBatch.Value);
+            IList<IArrowArray> arrays = BuildArrays(version, schema, bodyByteBuffer, recordBatch.Value);
 
             if (arrays.Count != 1)
             {
@@ -167,6 +171,7 @@ private void ReadDictionaryBatch(Flatbuf.DictionaryBatch dictionaryBatch, ByteBu
         }
 
         private List<IArrowArray> BuildArrays(
+            MetadataVersion version,
             Schema schema,
             ByteBuffer messageBuffer,
             Flatbuf.RecordBatch recordBatchMessage)
@@ -187,8 +192,8 @@ private List<IArrowArray> BuildArrays(
                 Flatbuf.FieldNode fieldNode = recordBatchEnumerator.CurrentNode;
 
                 ArrayData arrayData = field.DataType.IsFixedPrimitive()
-                    ? LoadPrimitiveField(ref recordBatchEnumerator, field, in fieldNode, messageBuffer, bufferCreator)
-                    : LoadVariableField(ref recordBatchEnumerator, field, in fieldNode, messageBuffer, bufferCreator);
+                    ? LoadPrimitiveField(version, ref recordBatchEnumerator, field, in fieldNode, messageBuffer, bufferCreator)
+                    : LoadVariableField(version, ref recordBatchEnumerator, field, in fieldNode, messageBuffer, bufferCreator);
 
                 arrays.Add(ArrowArrayFactory.BuildArray(arrayData));
             } while (recordBatchEnumerator.MoveNextNode());
@@ -225,6 +230,7 @@ private IBufferCreator GetBufferCreator(BodyCompression? compression)
         }
 
         private ArrayData LoadPrimitiveField(
+            MetadataVersion version,
             ref RecordBatchEnumerator recordBatchEnumerator,
             Field field,
             in Flatbuf.FieldNode fieldNode,
@@ -245,31 +251,44 @@ private ArrayData LoadPrimitiveField(
                 throw new InvalidDataException("Null count length must be >= 0"); // TODO:Localize exception message
             }
 
-            if (field.DataType.TypeId == ArrowTypeId.Null)
+            int buffers;
+            switch (field.DataType.TypeId)
             {
-                return new ArrayData(field.DataType, fieldLength, fieldNullCount, 0, System.Array.Empty<ArrowBuffer>());
-            }
-
-            ArrowBuffer nullArrowBuffer = BuildArrowBuffer(bodyData, recordBatchEnumerator.CurrentBuffer, bufferCreator);
-            if (!recordBatchEnumerator.MoveNextBuffer())
-            {
-                throw new Exception("Unable to move to the next buffer.");
+                case ArrowTypeId.Null:
+                    return new ArrayData(field.DataType, fieldLength, fieldNullCount, 0, System.Array.Empty<ArrowBuffer>());
+                case ArrowTypeId.Union:
+                    if (version < MetadataVersion.V5)
+                    {
+                        if (fieldNullCount > 0)
+                        {
+                            if (recordBatchEnumerator.CurrentBuffer.Length > 0)
+                            {
+                                // With older metadata we can get a validity bitmap. Fixing up union data is hard,
+                                // so we will just quit.
+                                throw new NotSupportedException("Cannot read pre-1.0.0 Union array with top-level validity bitmap");
+                            }
+                        }
+                        recordBatchEnumerator.MoveNextBuffer();
+                    }
+                    buffers = ((UnionType)field.DataType).Mode == Types.UnionMode.Dense ? 2 : 1;
+                    break;
+                case ArrowTypeId.Struct:
+                case ArrowTypeId.FixedSizeList:
+                    buffers = 1;
+                    break;
+                default:
+                    buffers = 2;
+                    break;
             }
 
-            ArrowBuffer[] arrowBuff;
-            if (field.DataType.TypeId == ArrowTypeId.Struct || field.DataType.TypeId == ArrowTypeId.FixedSizeList)
+            ArrowBuffer[] arrowBuff = new ArrowBuffer[buffers];
+            for (int i = 0; i < buffers; i++)
             {
-                arrowBuff = new[] { nullArrowBuffer };
-            }
-            else
-            {
-                ArrowBuffer valueArrowBuffer = BuildArrowBuffer(bodyData, recordBatchEnumerator.CurrentBuffer, bufferCreator);
+                arrowBuff[i] = BuildArrowBuffer(bodyData, recordBatchEnumerator.CurrentBuffer, bufferCreator);
                 recordBatchEnumerator.MoveNextBuffer();
-
-                arrowBuff = new[] { nullArrowBuffer, valueArrowBuffer };
             }
 
-            ArrayData[] children = GetChildren(ref recordBatchEnumerator, field, bodyData, bufferCreator);
+            ArrayData[] children = GetChildren(version, ref recordBatchEnumerator, field, bodyData, bufferCreator);
 
             IArrowArray dictionary = null;
             if (field.DataType.TypeId == ArrowTypeId.Dictionary)
@@ -282,6 +301,7 @@ private ArrayData LoadPrimitiveField(
         }
 
         private ArrayData LoadVariableField(
+            MetadataVersion version,
             ref RecordBatchEnumerator recordBatchEnumerator,
             Field field,
             in Flatbuf.FieldNode fieldNode,
@@ -316,7 +336,7 @@ private ArrayData LoadVariableField(
             }
 
             ArrowBuffer[] arrowBuff = new[] { nullArrowBuffer, offsetArrowBuffer, valueArrowBuffer };
-            ArrayData[] children = GetChildren(ref recordBatchEnumerator, field, bodyData, bufferCreator);
+            ArrayData[] children = GetChildren(version, ref recordBatchEnumerator, field, bodyData, bufferCreator);
 
             IArrowArray dictionary = null;
             if (field.DataType.TypeId == ArrowTypeId.Dictionary)
@@ -329,6 +349,7 @@ private ArrayData LoadVariableField(
         }
 
         private ArrayData[] GetChildren(
+            MetadataVersion version,
             ref RecordBatchEnumerator recordBatchEnumerator,
             Field field,
             ByteBuffer bodyData,
@@ -345,8 +366,8 @@ private ArrayData[] GetChildren(
 
                 Field childField = type.Fields[index];
                 ArrayData child = childField.DataType.IsFixedPrimitive()
-                    ? LoadPrimitiveField(ref recordBatchEnumerator, childField, in childFieldNode, bodyData, bufferCreator)
-                    : LoadVariableField(ref recordBatchEnumerator, childField, in childFieldNode, bodyData, bufferCreator);
+                    ? LoadPrimitiveField(version, ref recordBatchEnumerator, childField, in childFieldNode, bodyData, bufferCreator)
+                    : LoadVariableField(version, ref recordBatchEnumerator, childField, in childFieldNode, bodyData, bufferCreator);
 
                 children[index] = child;
             }
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
index a5d8db3f509d7..2b3815af71142 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
@@ -55,6 +55,7 @@ internal class ArrowRecordBatchFlatBufferBuilder :
             IArrowArrayVisitor<BinaryArray>,
             IArrowArrayVisitor<FixedSizeBinaryArray>,
             IArrowArrayVisitor<StructArray>,
+            IArrowArrayVisitor<UnionArray>,
             IArrowArrayVisitor<Decimal128Array>,
             IArrowArrayVisitor<Decimal256Array>,
             IArrowArrayVisitor<DictionaryArray>,
@@ -156,6 +157,22 @@ public void Visit(StructArray array)
                 }
             }
 
+            public void Visit(UnionArray array)
+            {
+                _buffers.Add(CreateBuffer(array.TypeBuffer));
+
+                ArrowBuffer? offsets = (array as DenseUnionArray)?.ValueOffsetBuffer;
+                if (offsets != null)
+                {
+                    _buffers.Add(CreateBuffer(offsets.Value));
+                }
+
+                for (int i = 0; i < array.Fields.Count; i++)
+                {
+                    array.Fields[i].Accept(this);
+                }
+            }
+
             public void Visit(DictionaryArray array)
             {
                 // Dictionary is serialized separately in Dictionary serialization.
@@ -218,7 +235,7 @@ public void Visit(IArrowArray array)
         private readonly bool _leaveOpen;
         private readonly IpcOptions _options;
 
-        private protected const Flatbuf.MetadataVersion CurrentMetadataVersion = Flatbuf.MetadataVersion.V4;
+        private protected const Flatbuf.MetadataVersion CurrentMetadataVersion = Flatbuf.MetadataVersion.V5;
 
         private static readonly byte[] s_padding = new byte[64];
 
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index 203aa72d93ea3..b11467538dd04 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -120,7 +120,9 @@ public void Visit(FixedSizeListType type)
 
             public void Visit(UnionType type)
             {
-                throw new NotImplementedException();
+                Result = FieldType.Build(
+                    Flatbuf.Type.Union,
+                    Flatbuf.Union.CreateUnion(Builder, ToFlatBuffer(type.Mode), Flatbuf.Union.CreateTypeIdsVector(Builder, type.TypeIds)));
             }
 
             public void Visit(StringType type)
@@ -279,5 +281,15 @@ private static Flatbuf.TimeUnit ToFlatBuffer(TimeUnit unit)
 
             return result;
         }
+
+        private static Flatbuf.UnionMode ToFlatBuffer(Types.UnionMode mode)
+        {
+            return mode switch
+            {
+                Types.UnionMode.Dense => Flatbuf.UnionMode.Dense,
+                Types.UnionMode.Sparse => Flatbuf.UnionMode.Sparse,
+                _ => throw new ArgumentException($"unsupported union mode <{mode}>", nameof(mode)),
+            };
+        }
     }
 }
diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
index 8ca69b61165bf..6249063ba81f4 100644
--- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
+++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
@@ -203,6 +203,10 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                 case Flatbuf.Type.Struct_:
                     Debug.Assert(childFields != null);
                     return new Types.StructType(childFields);
+                case Flatbuf.Type.Union:
+                    Debug.Assert(childFields != null);
+                    Flatbuf.Union unionMetadata = field.Type<Flatbuf.Union>().Value;
+                    return new Types.UnionType(childFields, unionMetadata.GetTypeIdsArray(), unionMetadata.Mode.ToArrow());
                 default:
                     throw new InvalidDataException($"Arrow primitive '{field.TypeType}' is unsupported.");
             }
diff --git a/csharp/src/Apache.Arrow/Table.cs b/csharp/src/Apache.Arrow/Table.cs
index 0b9f31557bec8..939ec23f54ff2 100644
--- a/csharp/src/Apache.Arrow/Table.cs
+++ b/csharp/src/Apache.Arrow/Table.cs
@@ -37,10 +37,10 @@ public static Table TableFromRecordBatches(Schema schema, IList<RecordBatch> rec
             List<Column> columns = new List<Column>(nColumns);
             for (int icol = 0; icol < nColumns; icol++)
             {
-                List<Array> columnArrays = new List<Array>(nBatches);
+                List<IArrowArray> columnArrays = new List<IArrowArray>(nBatches);
                 for (int jj = 0; jj < nBatches; jj++)
                 {
-                    columnArrays.Add(recordBatches[jj].Column(icol) as Array);
+                    columnArrays.Add(recordBatches[jj].Column(icol));
                 }
                 columns.Add(new Column(schema.GetFieldByIndex(icol), columnArrays));
             }
diff --git a/csharp/src/Apache.Arrow/Types/UnionType.cs b/csharp/src/Apache.Arrow/Types/UnionType.cs
index 293271018aa26..23fa3b45ab278 100644
--- a/csharp/src/Apache.Arrow/Types/UnionType.cs
+++ b/csharp/src/Apache.Arrow/Types/UnionType.cs
@@ -24,20 +24,21 @@ public enum UnionMode
         Dense
     }
 
-    public sealed class UnionType : ArrowType
+    public sealed class UnionType : NestedType
     {
         public override ArrowTypeId TypeId => ArrowTypeId.Union;
         public override string Name => "union";
 
         public UnionMode Mode { get; }
-        
-        public IEnumerable<byte> TypeCodes { get; }
+
+        public int[] TypeIds { get; }
 
         public UnionType(
-            IEnumerable<Field> fields, IEnumerable<byte> typeCodes,
+            IEnumerable<Field> fields, IEnumerable<int> typeIds,
             UnionMode mode = UnionMode.Sparse)
+            : base(fields.ToArray())
         {
-            TypeCodes = typeCodes.ToList();
+            TypeIds = typeIds.ToArray();
             Mode = mode;
         }
 
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
index abf7451e5e98c..1e76ee505a516 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
@@ -128,7 +128,7 @@ private RecordBatch CreateRecordBatch(Schema schema, JsonRecordBatch jsonRecordB
             for (int i = 0; i < jsonRecordBatch.Columns.Count; i++)
             {
                 JsonFieldData data = jsonRecordBatch.Columns[i];
-                Field field = schema.GetFieldByName(data.Name);
+                Field field = schema.FieldsList[i];
                 ArrayCreator creator = new ArrayCreator(data);
                 field.DataType.Accept(creator);
                 arrays.Add(creator.Array);
@@ -188,6 +188,7 @@ private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
                 "list" => ToListArrowType(type, children),
                 "fixedsizelist" => ToFixedSizeListArrowType(type, children),
                 "struct" => ToStructArrowType(type, children),
+                "union" => ToUnionArrowType(type, children),
                 "null" => NullType.Default,
                 _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}")
             };
@@ -281,6 +282,17 @@ private static IArrowType ToStructArrowType(JsonArrowType type, Field[] children
             return new StructType(children);
         }
 
+        private static IArrowType ToUnionArrowType(JsonArrowType type, Field[] children)
+        {
+            UnionMode mode = type.Mode switch
+            {
+                "SPARSE" => UnionMode.Sparse,
+                "DENSE" => UnionMode.Dense,
+                _ => throw new NotSupportedException($"Union mode not supported: {type.Mode}"),
+            };
+            return new UnionType(children, type.TypeIds, mode);
+        }
+
         private class ArrayCreator :
             IArrowTypeVisitor<BooleanType>,
             IArrowTypeVisitor<Int8Type>,
@@ -306,6 +318,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
+            IArrowTypeVisitor<UnionType>,
             IArrowTypeVisitor<NullType>
         {
             private JsonFieldData JsonFieldData { get; set; }
@@ -556,6 +569,43 @@ public void Visit(StructType type)
                 Array = new StructArray(arrayData);
             }
 
+            public void Visit(UnionType type)
+            {
+                ArrowBuffer[] buffers;
+                if (type.Mode == UnionMode.Dense)
+                {
+                    buffers = new ArrowBuffer[2];
+                    buffers[1] = GetOffsetBuffer();
+                }
+                else
+                {
+                    buffers = new ArrowBuffer[1];
+                }
+                buffers[0] = GetTypeIdBuffer();
+
+                ArrayData[] children = GetChildren(type);
+
+                int nullCount = 0;
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, buffers, children);
+                Array = UnionArray.Create(arrayData);
+            }
+
+            private ArrayData[] GetChildren(NestedType type)
+            {
+                ArrayData[] children = new ArrayData[type.Fields.Count];
+
+                var data = JsonFieldData;
+                for (int i = 0; i < children.Length; i++)
+                {
+                    JsonFieldData = data.Children[i];
+                    type.Fields[i].DataType.Accept(this);
+                    children[i] = Array.Data;
+                }
+                JsonFieldData = data;
+
+                return children;
+            }
+
             private static byte[] ConvertHexStringToByteArray(string hexString)
             {
                 byte[] data = new byte[hexString.Length / 2];
@@ -619,11 +669,22 @@ private void GenerateLongArray<T, TArray>(Func<ArrowBuffer, ArrowBuffer, int, in
 
             private ArrowBuffer GetOffsetBuffer()
             {
+                if (JsonFieldData.Count == 0) { return ArrowBuffer.Empty; }
                 ArrowBuffer.Builder<int> valueOffsets = new ArrowBuffer.Builder<int>(JsonFieldData.Offset.Length);
                 valueOffsets.AppendRange(JsonFieldData.Offset);
                 return valueOffsets.Build(default);
             }
 
+            private ArrowBuffer GetTypeIdBuffer()
+            {
+                ArrowBuffer.Builder<byte> typeIds = new ArrowBuffer.Builder<byte>(JsonFieldData.TypeId.Length);
+                for (int i = 0; i < JsonFieldData.TypeId.Length; i++)
+                {
+                    typeIds.Append(checked((byte)JsonFieldData.TypeId[i]));
+                }
+                return typeIds.Build(default);
+            }
+
             private ArrowBuffer GetValidityBuffer(out int nullCount)
             {
                 if (JsonFieldData.Validity == null)
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
index f0f63d3e19b8c..112eeabcb9931 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
@@ -71,6 +71,10 @@ public class JsonArrowType
         // FixedSizeList fields
         public int ListSize { get; set; }
 
+        // union fields
+        public string Mode { get; set; }
+        public int[] TypeIds { get; set; }
+        
         [JsonExtensionData]
         public Dictionary<string, JsonElement> ExtensionData { get; set; }
     }
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
index 77584aefb1bf4..c8bcc3cee0f99 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
@@ -28,7 +28,8 @@ public class ArrayTypeComparer :
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
-        IArrowTypeVisitor<StructType>
+        IArrowTypeVisitor<StructType>,
+        IArrowTypeVisitor<UnionType>
     {
         private readonly IArrowType _expectedType;
 
@@ -114,6 +115,22 @@ public void Visit(StructType actualType)
             CompareNested(expectedType, actualType);
         }
 
+        public void Visit(UnionType actualType)
+        {
+            Assert.IsAssignableFrom<UnionType>(_expectedType);
+            UnionType expectedType = (UnionType)_expectedType;
+
+            Assert.Equal(expectedType.Mode, actualType.Mode);
+
+            Assert.Equal(expectedType.TypeIds.Length, actualType.TypeIds.Length);
+            for (int i = 0; i < expectedType.TypeIds.Length; i++)
+            {
+                Assert.Equal(expectedType.TypeIds[i], actualType.TypeIds[i]);
+            }
+
+            CompareNested(expectedType, actualType);
+        }
+
         private static void CompareNested(NestedType expectedType, NestedType actualType)
         {
             Assert.Equal(expectedType.Fields.Count, actualType.Fields.Count);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
index 36cffe7eb4da1..f5a2c345e2ae6 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
@@ -77,6 +77,22 @@ private static IEnumerable<Tuple<List<IArrowArray>, IArrowArray>> GenerateTestDa
                         new Field.Builder().Name("Ints").DataType(Int32Type.Default).Nullable(true).Build()
                     }),
                     new FixedSizeListType(Int32Type.Default, 1),
+                    new UnionType(
+                        new List<Field>{
+                            new Field.Builder().Name("Strings").DataType(StringType.Default).Nullable(true).Build(),
+                            new Field.Builder().Name("Ints").DataType(Int32Type.Default).Nullable(true).Build()
+                        },
+                        new[] { 0, 1 },
+                        UnionMode.Sparse
+                    ),
+                    new UnionType(
+                        new List<Field>{
+                            new Field.Builder().Name("Strings").DataType(StringType.Default).Nullable(true).Build(),
+                            new Field.Builder().Name("Ints").DataType(Int32Type.Default).Nullable(true).Build()
+                        },
+                        new[] { 0, 1 },
+                        UnionMode.Dense
+                    ),
                 };
 
             foreach (IArrowType type in targetTypes)
@@ -119,7 +135,8 @@ private class TestDataGenerator :
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
-            IArrowTypeVisitor<StructType>
+            IArrowTypeVisitor<StructType>,
+            IArrowTypeVisitor<UnionType>
         {
 
             private List<List<int?>> _baseData;
@@ -392,6 +409,91 @@ public void Visit(StructType type)
                 ExpectedArray = new StructArray(type, 3, new List<Array> { resultStringArray, resultInt32Array }, nullBitmapBuffer, 1);
             }
 
+            public void Visit(UnionType type)
+            {
+                bool isDense = type.Mode == UnionMode.Dense;
+
+                StringArray.Builder stringResultBuilder = new StringArray.Builder().Reserve(_baseDataTotalElementCount);
+                Int32Array.Builder intResultBuilder = new Int32Array.Builder().Reserve(_baseDataTotalElementCount);
+                ArrowBuffer.Builder<byte> typeResultBuilder = new ArrowBuffer.Builder<byte>().Reserve(_baseDataTotalElementCount);
+                ArrowBuffer.Builder<int> offsetResultBuilder = new ArrowBuffer.Builder<int>().Reserve(_baseDataTotalElementCount);
+                int resultNullCount = 0;
+
+                for (int i = 0; i < _baseDataListCount; i++)
+                {
+                    List<int?> dataList = _baseData[i];
+                    StringArray.Builder stringBuilder = new StringArray.Builder().Reserve(dataList.Count);
+                    Int32Array.Builder intBuilder = new Int32Array.Builder().Reserve(dataList.Count);
+                    ArrowBuffer.Builder<byte> typeBuilder = new ArrowBuffer.Builder<byte>().Reserve(dataList.Count);
+                    ArrowBuffer.Builder<int> offsetBuilder = new ArrowBuffer.Builder<int>().Reserve(dataList.Count);
+                    int nullCount = 0;
+
+                    for (int j = 0; j < dataList.Count; j++)
+                    {
+                        byte index = (byte)Math.Max(j % 3, 1);
+                        int? intValue = (index == 1) ? dataList[j] : null;
+                        string stringValue = (index == 1) ? null : dataList[j]?.ToString();
+                        typeBuilder.Append(index);
+
+                        if (isDense)
+                        {
+                            if (index == 0)
+                            {
+                                offsetBuilder.Append(stringBuilder.Length);
+                                offsetResultBuilder.Append(stringResultBuilder.Length);
+                                stringBuilder.Append(stringValue);
+                                stringResultBuilder.Append(stringValue);
+                            }
+                            else
+                            {
+                                offsetBuilder.Append(intBuilder.Length);
+                                offsetResultBuilder.Append(intResultBuilder.Length);
+                                intBuilder.Append(intValue);
+                                intResultBuilder.Append(intValue);
+                            }
+                        }
+                        else
+                        {
+                            stringBuilder.Append(stringValue);
+                            stringResultBuilder.Append(stringValue);
+                            intBuilder.Append(intValue);
+                            intResultBuilder.Append(intValue);
+                        }
+
+                        if (dataList[j] == null)
+                        {
+                            nullCount++;
+                            resultNullCount++;
+                        }
+                    }
+
+                    ArrowBuffer[] buffers;
+                    if (isDense)
+                    {
+                        buffers = new[] { typeBuilder.Build(), offsetBuilder.Build() };
+                    }
+                    else
+                    {
+                        buffers = new[] { typeBuilder.Build() };
+                    }
+                    TestTargetArrayList.Add(UnionArray.Create(new ArrayData(
+                        type, dataList.Count, nullCount, 0, buffers,
+                        new[] { stringBuilder.Build().Data, intBuilder.Build().Data })));
+                }
+
+                ArrowBuffer[] resultBuffers;
+                if (isDense)
+                {
+                    resultBuffers = new[] { typeResultBuilder.Build(), offsetResultBuilder.Build() };
+                }
+                else
+                {
+                    resultBuffers = new[] { typeResultBuilder.Build() };
+                }
+                ExpectedArray = UnionArray.Create(new ArrayData(
+                    type, _baseDataTotalElementCount, resultNullCount, 0, resultBuffers,
+                        new[] { stringResultBuilder.Build().Data, intResultBuilder.Build().Data }));
+            }
 
             public void Visit(IArrowType type)
             {
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
index e588eab51e1fc..8b41763a70ac8 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
@@ -91,6 +91,7 @@ private class ArrayComparer :
             IArrowArrayVisitor<FixedSizeBinaryArray>,
             IArrowArrayVisitor<BinaryArray>,
             IArrowArrayVisitor<StructArray>,
+            IArrowArrayVisitor<UnionArray>,
             IArrowArrayVisitor<Decimal128Array>,
             IArrowArrayVisitor<Decimal256Array>,
             IArrowArrayVisitor<DictionaryArray>,
@@ -151,6 +152,24 @@ public void Visit(StructArray array)
                 }
             }
 
+            public void Visit(UnionArray array)
+            {
+                Assert.IsAssignableFrom<UnionArray>(_expectedArray);
+                UnionArray expectedArray = (UnionArray)_expectedArray;
+
+                Assert.Equal(expectedArray.Mode, array.Mode);
+                Assert.Equal(expectedArray.Length, array.Length);
+                Assert.Equal(expectedArray.NullCount, array.NullCount);
+                Assert.Equal(expectedArray.Offset, array.Offset);
+                Assert.Equal(expectedArray.Data.Children.Length, array.Data.Children.Length);
+                Assert.Equal(expectedArray.Fields.Count, array.Fields.Count);
+
+                for (int i = 0; i < array.Fields.Count; i++)
+                {
+                    array.Fields[i].Accept(new ArrayComparer(expectedArray.Fields[i], _strictCompare));
+                }
+            }
+
             public void Visit(DictionaryArray array)
             {
                 Assert.IsAssignableFrom<DictionaryArray>(_expectedArray);
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 29b1b9e7db74a..f28b89a9cd17e 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -112,6 +112,9 @@ private static Schema GetTestSchema()
                     .Field(f => f.Name("dict_string_ordered").DataType(new DictionaryType(Int32Type.Default, StringType.Default, true)).Nullable(false))
                     .Field(f => f.Name("list_dict_string").DataType(new ListType(new DictionaryType(Int32Type.Default, StringType.Default, false))).Nullable(false))
 
+                    .Field(f => f.Name("dense_union").DataType(new UnionType(new[] { new Field("i64", Int64Type.Default, false), new Field("f32", FloatType.Default, true), }, new[] { 0, 1 }, UnionMode.Dense)))
+                    .Field(f => f.Name("sparse_union").DataType(new UnionType(new[] { new Field("i32", Int32Type.Default, true), new Field("f64", DoubleType.Default, false), }, new[] { 0, 1 }, UnionMode.Sparse)))
+
                     // Checking wider characters.
                     .Field(f => f.Name("hello 你好 😄").DataType(BooleanType.Default).Nullable(true))
 
@@ -172,6 +175,9 @@ private static IEnumerable<dynamic> GetPythonFields()
                 yield return pa.field("dict_string_ordered", pa.dictionary(pa.int32(), pa.utf8(), true), false);
                 yield return pa.field("list_dict_string", pa.list_(pa.dictionary(pa.int32(), pa.utf8(), false)), false);
 
+                yield return pa.field("dense_union", pa.dense_union(List(pa.field("i64", pa.int64(), false), pa.field("f32", pa.float32(), true))));
+                yield return pa.field("sparse_union", pa.sparse_union(List(pa.field("i32", pa.int32(), true), pa.field("f64", pa.float64(), false))));
+
                 yield return pa.field("hello 你好 😄", pa.bool_(), true);
             }
         }
@@ -485,22 +491,29 @@ public unsafe void ImportRecordBatch()
                         pa.array(List(0.0, 1.4, 2.5, 3.6, 4.7)),
                         pa.array(new PyObject[] { List(1, 2), List(3, 4), PyObject.None, PyObject.None, List(5, 4, 3) }),
                         pa.StructArray.from_arrays(
-                            new PyList(new PyObject[]
-                            {
+                            List(
                                 List(10, 9, null, null, null),
                                 List("banana", "apple", "orange", "cherry", "grape"),
-                                List(null, 4.3, -9, 123.456, 0),
-                            }),
+                                List(null, 4.3, -9, 123.456, 0)
+                            ),
                             new[] { "fld1", "fld2", "fld3" }),
                         pa.DictionaryArray.from_arrays(
                             pa.array(List(1, 0, 1, 1, null)),
-                            pa.array(List("foo", "bar"))
-                            ),
+                            pa.array(List("foo", "bar"))),
                         pa.FixedSizeListArray.from_arrays(
                             pa.array(List(1, 2, 3, 4, null, 6, 7, null, null, null)),
                             2),
+                        pa.UnionArray.from_dense(
+                            pa.array(List(0, 1, 1, 0, 0), type: "int8"),
+                            pa.array(List(0, 0, 1, 1, 2), type: "int32"),
+                            List(
+                                pa.array(List(1, 4, null)),
+                                pa.array(List("two", "three"))
+                            ),
+                            /* field name */ List("i32", "s"),
+                            /* type codes */ List(3, 2)),
                     }),
-                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8" });
+                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9" });
 
                 dynamic batch = table.to_batches()[0];
 
@@ -568,6 +581,10 @@ public unsafe void ImportRecordBatch()
             Assert.Equal(new long[] { 1, 2, 3, 4, 0, 6, 7, 0, 0, 0 }, col8a.Values.ToArray());
             Assert.True(col8a.IsValid(3));
             Assert.False(col8a.IsValid(9));
+
+            UnionArray col9 = (UnionArray)recordBatch.Column("col9");
+            Assert.Equal(5, col9.Length);
+            Assert.True(col9 is DenseUnionArray);
         }
 
         [SkippableFact]
@@ -789,6 +806,11 @@ private static PyObject List(params string[] values)
             return new PyList(values.Select(i => i == null ? PyObject.None : new PyString(i)).ToArray());
         }
 
+        private static PyObject List(params PyObject[] values)
+        {
+            return new PyList(values);
+        }
+
         sealed class TestArrayStream : IArrowArrayStream
         {
             private readonly RecordBatch[] _batches;
diff --git a/csharp/test/Apache.Arrow.Tests/ColumnTests.cs b/csharp/test/Apache.Arrow.Tests/ColumnTests.cs
index b90c681622d5f..2d867b79176aa 100644
--- a/csharp/test/Apache.Arrow.Tests/ColumnTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ColumnTests.cs
@@ -39,7 +39,7 @@ public void TestColumn()
             Array intArrayCopy = MakeIntArray(10);
 
             Field field = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
-            Column column = new Column(field, new[] { intArray, intArrayCopy });
+            Column column = new Column(field, new IArrowArray[] { intArray, intArrayCopy });
 
             Assert.True(column.Name == field.Name);
             Assert.True(column.Field == field);
diff --git a/csharp/test/Apache.Arrow.Tests/TableTests.cs b/csharp/test/Apache.Arrow.Tests/TableTests.cs
index b4c4b1faed190..8b07a38c1b8c0 100644
--- a/csharp/test/Apache.Arrow.Tests/TableTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/TableTests.cs
@@ -30,7 +30,7 @@ public static Table MakeTableWithOneColumnOfTwoIntArrays(int lengthOfEachArray)
             Field field = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
             Schema s0 = new Schema.Builder().Field(field).Build();
 
-            Column column = new Column(field, new List<Array> { intArray, intArrayCopy });
+            Column column = new Column(field, new List<IArrowArray> { intArray, intArrayCopy });
             Table table = new Table(s0, new List<Column> { column });
             return table;
         }
@@ -60,7 +60,7 @@ public void TestTableFromRecordBatches()
 
             Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches);
             Assert.Equal(20, table1.RowCount);
-            Assert.Equal(24, table1.ColumnCount);
+            Assert.Equal(26, table1.ColumnCount);
 
             FixedSizeBinaryType type = new FixedSizeBinaryType(17);
             Field newField1 = new Field(type.Name, type, false);
@@ -86,13 +86,13 @@ public void TestTableAddRemoveAndSetColumn()
 
             Array nonEqualLengthIntArray = ColumnTests.MakeIntArray(10);
             Field field1 = new Field.Builder().Name("f1").DataType(Int32Type.Default).Build();
-            Column nonEqualLengthColumn = new Column(field1, new[] { nonEqualLengthIntArray});
+            Column nonEqualLengthColumn = new Column(field1, new IArrowArray[] { nonEqualLengthIntArray });
             Assert.Throws<ArgumentException>(() => table.InsertColumn(-1, nonEqualLengthColumn));
             Assert.Throws<ArgumentException>(() => table.InsertColumn(1, nonEqualLengthColumn));
 
             Array equalLengthIntArray = ColumnTests.MakeIntArray(20);
             Field field2 = new Field.Builder().Name("f2").DataType(Int32Type.Default).Build();
-            Column equalLengthColumn = new Column(field2, new[] { equalLengthIntArray});
+            Column equalLengthColumn = new Column(field2, new IArrowArray[] { equalLengthIntArray });
             Column existingColumn = table.Column(0);
 
             Table newTable = table.InsertColumn(0, equalLengthColumn);
@@ -118,7 +118,7 @@ public void TestBuildFromRecordBatch()
             RecordBatch batch = TestData.CreateSampleRecordBatch(schema, 10);
             Table table = Table.TableFromRecordBatches(schema, new[] { batch });
 
-            Assert.NotNull(table.Column(0).Data.Array(0) as Int64Array);
+            Assert.NotNull(table.Column(0).Data.ArrowArray(0) as Int64Array);
         }
     }
 
diff --git a/csharp/test/Apache.Arrow.Tests/TestData.cs b/csharp/test/Apache.Arrow.Tests/TestData.cs
index 41507311f6a04..9e2061e3428a9 100644
--- a/csharp/test/Apache.Arrow.Tests/TestData.cs
+++ b/csharp/test/Apache.Arrow.Tests/TestData.cs
@@ -60,6 +60,8 @@ public static RecordBatch CreateSampleRecordBatch(int length, int columnSetCount
                     builder.Field(CreateField(new DictionaryType(Int32Type.Default, StringType.Default, false), i));
                     builder.Field(CreateField(new FixedSizeBinaryType(16), i));
                     builder.Field(CreateField(new FixedSizeListType(Int32Type.Default, 3), i));
+                    builder.Field(CreateField(new UnionType(new[] { CreateField(StringType.Default, i), CreateField(Int32Type.Default, i) }, new[] { 0, 1 }, UnionMode.Sparse), i));
+                    builder.Field(CreateField(new UnionType(new[] { CreateField(StringType.Default, i), CreateField(Int32Type.Default, i) }, new[] { 0, 1 }, UnionMode.Dense), -i));
                 }
 
                 //builder.Field(CreateField(HalfFloatType.Default));
@@ -125,6 +127,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
+            IArrowTypeVisitor<UnionType>,
             IArrowTypeVisitor<Decimal128Type>,
             IArrowTypeVisitor<Decimal256Type>,
             IArrowTypeVisitor<DictionaryType>,
@@ -315,6 +318,67 @@ public void Visit(StructType type)
                 Array = new StructArray(type, Length, childArrays, nullBitmap.Build());
             }
 
+            public void Visit(UnionType type)
+            {
+                int[] lengths = new int[type.Fields.Count];
+                if (type.Mode == UnionMode.Sparse)
+                {
+                    for (int i = 0; i < lengths.Length; i++)
+                    {
+                        lengths[i] = Length;
+                    }
+                }
+                else
+                {
+                    int totalLength = Length;
+                    int oneLength = Length / lengths.Length;
+                    for (int i = 1; i < lengths.Length; i++)
+                    {
+                        lengths[i] = oneLength;
+                        totalLength -= oneLength;
+                    }
+                    lengths[0] = totalLength;
+                }
+
+                ArrayData[] childArrays = new ArrayData[type.Fields.Count];
+                for (int i = 0; i < childArrays.Length; i++)
+                {
+                    childArrays[i] = CreateArray(type.Fields[i], lengths[i]).Data;
+                }
+
+                ArrowBuffer.Builder<byte> typeIdBuilder = new ArrowBuffer.Builder<byte>(Length);
+                byte index = 0;
+                for (int i = 0; i < Length; i++)
+                {
+                    typeIdBuilder.Append(index);
+                    index++;
+                    if (index == lengths.Length)
+                    {
+                        index = 0;
+                    }
+                }
+
+                ArrowBuffer[] buffers;
+                if (type.Mode == UnionMode.Sparse)
+                {
+                    buffers = new ArrowBuffer[1];
+                }
+                else
+                {
+                    ArrowBuffer.Builder<int> offsetBuilder = new ArrowBuffer.Builder<int>(Length);
+                    for (int i = 0; i < Length; i++)
+                    {
+                        offsetBuilder.Append(i / lengths.Length);
+                    }
+
+                    buffers = new ArrowBuffer[2];
+                    buffers[1] = offsetBuilder.Build();
+                }
+                buffers[0] = typeIdBuilder.Build();
+
+                Array = UnionArray.Create(new ArrayData(type, Length, 0, 0, buffers, childArrays));
+            }
+
             public void Visit(DictionaryType type)
             {
                 Int32Array.Builder indicesBuilder = new Int32Array.Builder().Reserve(Length);
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 5ac32da56a8de..299881c4b613a 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1833,8 +1833,7 @@ def _temp_path():
         .skip_tester('C#')
         .skip_tester('JS'),
 
-        generate_unions_case()
-        .skip_tester('C#'),
+        generate_unions_case(),
 
         generate_custom_metadata_case()
         .skip_tester('C#'),
diff --git a/docs/source/status.rst b/docs/source/status.rst
index 36c29fcdc4da6..6314fd4c8d31f 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -83,9 +83,9 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Map               | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Dense Union       | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Dense Union       | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Sparse Union      | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Sparse Union      | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+

From 3c013da56fd55122072ffaca3e23afb12c290075 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 25 Sep 2023 06:17:26 -0700
Subject: [PATCH 405/749] GH-37795: [Java][FlightSQL] Add mock
 FlightSqlProducer and tests (#37837)

### Rationale for this change
Clarify how to write a FlightSqlProducer with examples and helper classes. This is more inline with what's available
to help developers write a FlightProducer.

### What changes are included in this PR?

Add helper classes for creating a No-op Flight SQL producer and a partially implemented FlightSqlProducer that can process metadata requests.

Add a mock flight producer and tests for it based on the new FlightSqlProducer partial implementations.

Clean-up missed closes of FlightStreams in TestFlightSql.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37795

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../flight/sql/BasicFlightSqlProducer.java    | 109 +++++
 .../flight/sql/NoOpFlightSqlProducer.java     | 221 +++++++++
 .../apache/arrow/flight/TestFlightSql.java    | 432 +++++++-----------
 .../arrow/flight/TestFlightSqlStreams.java    | 288 ++++++++++++
 .../flight/sql/util/FlightStreamUtils.java    | 129 ++++++
 5 files changed, 917 insertions(+), 262 deletions(-)
 create mode 100644 java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/BasicFlightSqlProducer.java
 create mode 100644 java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/NoOpFlightSqlProducer.java
 create mode 100644 java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
 create mode 100644 java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/util/FlightStreamUtils.java

diff --git a/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/BasicFlightSqlProducer.java b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/BasicFlightSqlProducer.java
new file mode 100644
index 0000000000000..ea99191f28e13
--- /dev/null
+++ b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/BasicFlightSqlProducer.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.flight.sql;
+
+import java.util.List;
+
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightEndpoint;
+import org.apache.arrow.flight.FlightInfo;
+import org.apache.arrow.flight.sql.impl.FlightSql;
+import org.apache.arrow.vector.types.pojo.Schema;
+
+import com.google.protobuf.Message;
+
+/**
+ * A {@link FlightSqlProducer} that implements getting FlightInfo for each metadata request.
+ */
+public abstract class BasicFlightSqlProducer extends NoOpFlightSqlProducer {
+
+  @Override
+  public FlightInfo getFlightInfoSqlInfo(FlightSql.CommandGetSqlInfo request, CallContext context,
+                                         FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_SQL_INFO_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTypeInfo(FlightSql.CommandGetXdbcTypeInfo request, CallContext context,
+                                          FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_TYPE_INFO_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoCatalogs(FlightSql.CommandGetCatalogs request, CallContext context,
+                                          FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_CATALOGS_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoSchemas(FlightSql.CommandGetDbSchemas request, CallContext context,
+                                         FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_SCHEMAS_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTables(FlightSql.CommandGetTables request, CallContext context,
+                                        FlightDescriptor descriptor) {
+    if (request.getIncludeSchema()) {
+      return generateFlightInfo(request, descriptor, Schemas.GET_TABLES_SCHEMA);
+    }
+    return generateFlightInfo(request, descriptor, Schemas.GET_TABLES_SCHEMA_NO_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTableTypes(FlightSql.CommandGetTableTypes request, CallContext context,
+                                            FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_TABLE_TYPES_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoPrimaryKeys(FlightSql.CommandGetPrimaryKeys request, CallContext context,
+                                             FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_PRIMARY_KEYS_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoExportedKeys(FlightSql.CommandGetExportedKeys request, CallContext context,
+                                              FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_EXPORTED_KEYS_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoImportedKeys(FlightSql.CommandGetImportedKeys request, CallContext context,
+                                              FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_IMPORTED_KEYS_SCHEMA);
+  }
+
+  @Override
+  public FlightInfo getFlightInfoCrossReference(FlightSql.CommandGetCrossReference request, CallContext context,
+                                                FlightDescriptor descriptor) {
+    return generateFlightInfo(request, descriptor, Schemas.GET_CROSS_REFERENCE_SCHEMA);
+  }
+
+  /**
+   * Return a list of FlightEndpoints for the given request and FlightDescriptor. This method should validate that
+   * the request is supported by this FlightSqlProducer.
+   */
+  protected abstract <T extends Message>
+        List<FlightEndpoint> determineEndpoints(T request, FlightDescriptor flightDescriptor, Schema schema);
+
+  protected <T extends Message> FlightInfo generateFlightInfo(T request, FlightDescriptor descriptor, Schema schema) {
+    final List<FlightEndpoint> endpoints = determineEndpoints(request, descriptor, schema);
+    return new FlightInfo(schema, descriptor, endpoints, -1, -1);
+  }
+}
diff --git a/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/NoOpFlightSqlProducer.java b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/NoOpFlightSqlProducer.java
new file mode 100644
index 0000000000000..a02cee64bd855
--- /dev/null
+++ b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/NoOpFlightSqlProducer.java
@@ -0,0 +1,221 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.flight.sql;
+
+import org.apache.arrow.flight.CallStatus;
+import org.apache.arrow.flight.Criteria;
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightInfo;
+import org.apache.arrow.flight.FlightStream;
+import org.apache.arrow.flight.PutResult;
+import org.apache.arrow.flight.Result;
+import org.apache.arrow.flight.SchemaResult;
+import org.apache.arrow.flight.sql.impl.FlightSql;
+
+/**
+ * A {@link FlightSqlProducer} that throws on all FlightSql-specific operations.
+ */
+public class NoOpFlightSqlProducer implements FlightSqlProducer {
+  @Override
+  public void createPreparedStatement(FlightSql.ActionCreatePreparedStatementRequest request,
+                                      CallContext context, StreamListener<Result> listener) {
+    listener.onError(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public void closePreparedStatement(FlightSql.ActionClosePreparedStatementRequest request,
+                                     CallContext context, StreamListener<Result> listener) {
+    listener.onError(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoStatement(FlightSql.CommandStatementQuery command,
+                                           CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoPreparedStatement(FlightSql.CommandPreparedStatementQuery command,
+                                                   CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public SchemaResult getSchemaStatement(FlightSql.CommandStatementQuery command,
+                                         CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamStatement(FlightSql.TicketStatementQuery ticket,
+                                 CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public void getStreamPreparedStatement(FlightSql.CommandPreparedStatementQuery command,
+                                         CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public Runnable acceptPutStatement(FlightSql.CommandStatementUpdate command, CallContext context,
+                                     FlightStream flightStream, StreamListener<PutResult> ackStream) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public Runnable acceptPutPreparedStatementUpdate(FlightSql.CommandPreparedStatementUpdate command,
+                                                   CallContext context, FlightStream flightStream,
+                                                   StreamListener<PutResult> ackStream) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public Runnable acceptPutPreparedStatementQuery(FlightSql.CommandPreparedStatementQuery command, CallContext context,
+                                                  FlightStream flightStream, StreamListener<PutResult> ackStream) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoSqlInfo(FlightSql.CommandGetSqlInfo request, CallContext context,
+                                         FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamSqlInfo(FlightSql.CommandGetSqlInfo command, CallContext context,
+                               ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTypeInfo(FlightSql.CommandGetXdbcTypeInfo request,
+                                          CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamTypeInfo(FlightSql.CommandGetXdbcTypeInfo request,
+                                CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoCatalogs(FlightSql.CommandGetCatalogs request,
+                                          CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamCatalogs(CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoSchemas(FlightSql.CommandGetDbSchemas request,
+                                         CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamSchemas(FlightSql.CommandGetDbSchemas command,
+                               CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTables(FlightSql.CommandGetTables request,
+                                        CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamTables(FlightSql.CommandGetTables command, CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoTableTypes(FlightSql.CommandGetTableTypes request, CallContext context,
+                                            FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamTableTypes(CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoPrimaryKeys(FlightSql.CommandGetPrimaryKeys request,
+                                             CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamPrimaryKeys(FlightSql.CommandGetPrimaryKeys command,
+                                   CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public FlightInfo getFlightInfoExportedKeys(FlightSql.CommandGetExportedKeys request,
+                                              CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoImportedKeys(FlightSql.CommandGetImportedKeys request,
+                                              CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoCrossReference(FlightSql.CommandGetCrossReference request,
+                                                CallContext context, FlightDescriptor descriptor) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+
+  @Override
+  public void getStreamExportedKeys(FlightSql.CommandGetExportedKeys command,
+                                    CallContext context, ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public void getStreamImportedKeys(FlightSql.CommandGetImportedKeys command, CallContext context,
+                                    ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public void getStreamCrossReference(FlightSql.CommandGetCrossReference command, CallContext context,
+                                      ServerStreamListener listener) {
+    listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+  }
+
+  @Override
+  public void close() throws Exception {
+
+  }
+
+  @Override
+  public void listFlights(CallContext context, Criteria criteria, StreamListener<FlightInfo> listener) {
+    throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+  }
+}
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
index 6da915a8ffb14..7635b80ecd0fd 100644
--- a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSql.java
@@ -20,7 +20,7 @@
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
-import static java.util.Objects.isNull;
+import static org.apache.arrow.flight.sql.util.FlightStreamUtils.getResults;
 import static org.apache.arrow.util.AutoCloseables.close;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.is;
@@ -29,16 +29,12 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.nio.channels.Channels;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.IntStream;
 
@@ -52,18 +48,9 @@
 import org.apache.arrow.flight.sql.util.TableRef;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
-import org.apache.arrow.vector.BitVector;
-import org.apache.arrow.vector.FieldVector;
 import org.apache.arrow.vector.IntVector;
-import org.apache.arrow.vector.UInt1Vector;
-import org.apache.arrow.vector.UInt4Vector;
-import org.apache.arrow.vector.VarBinaryVector;
 import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.VectorSchemaRoot;
-import org.apache.arrow.vector.complex.DenseUnionVector;
-import org.apache.arrow.vector.complex.ListVector;
-import org.apache.arrow.vector.ipc.ReadChannel;
-import org.apache.arrow.vector.ipc.message.MessageSerializer;
 import org.apache.arrow.vector.types.Types.MinorType;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
@@ -657,197 +644,202 @@ public void testGetSqlInfoResultsWithThreeArgs() throws Exception {
   }
 
   @Test
-  public void testGetCommandExportedKeys() {
-    final FlightStream stream =
+  public void testGetCommandExportedKeys() throws Exception {
+    try (final FlightStream stream =
         sqlClient.getStream(
             sqlClient.getExportedKeys(TableRef.of(null, null, "FOREIGNTABLE"))
-                .getEndpoints().get(0).getTicket());
-
-    final List<List<String>> results = getResults(stream);
-
-    final List<Matcher<String>> matchers = asList(
-        nullValue(String.class), // pk_catalog_name
-        is("APP"), // pk_schema_name
-        is("FOREIGNTABLE"), // pk_table_name
-        is("ID"), // pk_column_name
-        nullValue(String.class), // fk_catalog_name
-        is("APP"), // fk_schema_name
-        is("INTTABLE"), // fk_table_name
-        is("FOREIGNID"), // fk_column_name
-        is("1"), // key_sequence
-        containsString("SQL"), // fk_key_name
-        containsString("SQL"), // pk_key_name
-        is("3"), // update_rule
-        is("3")); // delete_rule
-
-    final List<Executable> assertions = new ArrayList<>();
-    Assertions.assertEquals(1, results.size());
-    for (int i = 0; i < matchers.size(); i++) {
-      final String actual = results.get(0).get(i);
-      final Matcher<String> expected = matchers.get(i);
-      assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+                .getEndpoints().get(0).getTicket())) {
+
+      final List<List<String>> results = getResults(stream);
+
+      final List<Matcher<String>> matchers = asList(
+          nullValue(String.class), // pk_catalog_name
+          is("APP"), // pk_schema_name
+          is("FOREIGNTABLE"), // pk_table_name
+          is("ID"), // pk_column_name
+          nullValue(String.class), // fk_catalog_name
+          is("APP"), // fk_schema_name
+          is("INTTABLE"), // fk_table_name
+          is("FOREIGNID"), // fk_column_name
+          is("1"), // key_sequence
+          containsString("SQL"), // fk_key_name
+          containsString("SQL"), // pk_key_name
+          is("3"), // update_rule
+          is("3")); // delete_rule
+
+      final List<Executable> assertions = new ArrayList<>();
+      Assertions.assertEquals(1, results.size());
+      for (int i = 0; i < matchers.size(); i++) {
+        final String actual = results.get(0).get(i);
+        final Matcher<String> expected = matchers.get(i);
+        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+      }
+      Assertions.assertAll(assertions);
     }
-    Assertions.assertAll(assertions);
   }
 
   @Test
-  public void testGetCommandImportedKeys() {
-    final FlightStream stream =
+  public void testGetCommandImportedKeys() throws Exception {
+    try (final FlightStream stream =
         sqlClient.getStream(
             sqlClient.getImportedKeys(TableRef.of(null, null, "INTTABLE"))
-                .getEndpoints().get(0).getTicket());
-
-    final List<List<String>> results = getResults(stream);
-
-    final List<Matcher<String>> matchers = asList(
-        nullValue(String.class), // pk_catalog_name
-        is("APP"), // pk_schema_name
-        is("FOREIGNTABLE"), // pk_table_name
-        is("ID"), // pk_column_name
-        nullValue(String.class), // fk_catalog_name
-        is("APP"), // fk_schema_name
-        is("INTTABLE"), // fk_table_name
-        is("FOREIGNID"), // fk_column_name
-        is("1"), // key_sequence
-        containsString("SQL"), // fk_key_name
-        containsString("SQL"), // pk_key_name
-        is("3"), // update_rule
-        is("3")); // delete_rule
-
-    Assertions.assertEquals(1, results.size());
-    final List<Executable> assertions = new ArrayList<>();
-    for (int i = 0; i < matchers.size(); i++) {
-      final String actual = results.get(0).get(i);
-      final Matcher<String> expected = matchers.get(i);
-      assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+                .getEndpoints().get(0).getTicket())) {
+
+      final List<List<String>> results = getResults(stream);
+
+      final List<Matcher<String>> matchers = asList(
+          nullValue(String.class), // pk_catalog_name
+          is("APP"), // pk_schema_name
+          is("FOREIGNTABLE"), // pk_table_name
+          is("ID"), // pk_column_name
+          nullValue(String.class), // fk_catalog_name
+          is("APP"), // fk_schema_name
+          is("INTTABLE"), // fk_table_name
+          is("FOREIGNID"), // fk_column_name
+          is("1"), // key_sequence
+          containsString("SQL"), // fk_key_name
+          containsString("SQL"), // pk_key_name
+          is("3"), // update_rule
+          is("3")); // delete_rule
+
+      Assertions.assertEquals(1, results.size());
+      final List<Executable> assertions = new ArrayList<>();
+      for (int i = 0; i < matchers.size(); i++) {
+        final String actual = results.get(0).get(i);
+        final Matcher<String> expected = matchers.get(i);
+        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+      }
+      Assertions.assertAll(assertions);
     }
-    Assertions.assertAll(assertions);
   }
 
   @Test
-  public void testGetTypeInfo() {
+  public void testGetTypeInfo() throws Exception {
     FlightInfo flightInfo = sqlClient.getXdbcTypeInfo();
 
-    FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket());
-
-    final List<List<String>> results = getResults(stream);
-
-    final List<List<String>> matchers = ImmutableList.of(
-        asList("BIGINT", "-5", "19", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
-            "BIGINT", "0", "0",
-            null, null, "10", null),
-        asList("LONG VARCHAR FOR BIT DATA", "-4", "32700", "X'", "'", emptyList().toString(), "1", "false", "0", "true",
-            "false", "false",
-            "LONG VARCHAR FOR BIT DATA", null, null, null, null, null, null),
-        asList("VARCHAR () FOR BIT DATA", "-3", "32672", "X'", "'", singletonList("length").toString(), "1", "false",
-            "2", "true", "false",
-            "false", "VARCHAR () FOR BIT DATA", null, null, null, null, null, null),
-        asList("CHAR () FOR BIT DATA", "-2", "254", "X'", "'", singletonList("length").toString(), "1", "false", "2",
-            "true", "false", "false",
-            "CHAR () FOR BIT DATA", null, null, null, null, null, null),
-        asList("LONG VARCHAR", "-1", "32700", "'", "'", emptyList().toString(), "1", "true", "1", "true", "false",
-            "false",
-            "LONG VARCHAR", null, null, null, null, null, null),
-        asList("CHAR", "1", "254", "'", "'", singletonList("length").toString(), "1", "true", "3", "true", "false",
-            "false", "CHAR", null, null,
-            null, null, null, null),
-        asList("NUMERIC", "2", "31", null, null, Arrays.asList("precision", "scale").toString(), "1", "false", "2",
-            "false", "true", "false",
-            "NUMERIC", "0", "31", null, null, "10", null),
-        asList("DECIMAL", "3", "31", null, null, Arrays.asList("precision", "scale").toString(), "1", "false", "2",
-            "false", "true", "false",
-            "DECIMAL", "0", "31", null, null, "10", null),
-        asList("INTEGER", "4", "10", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
-            "INTEGER", "0", "0",
-            null, null, "10", null),
-        asList("SMALLINT", "5", "5", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
-            "SMALLINT", "0",
-            "0", null, null, "10", null),
-        asList("FLOAT", "6", "52", null, null, singletonList("precision").toString(), "1", "false", "2", "false",
-            "false", "false", "FLOAT", null,
-            null, null, null, "2", null),
-        asList("REAL", "7", "23", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "false",
-            "REAL", null, null,
-            null, null, "2", null),
-        asList("DOUBLE", "8", "52", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "false",
-            "DOUBLE", null,
-            null, null, null, "2", null),
-        asList("VARCHAR", "12", "32672", "'", "'", singletonList("length").toString(), "1", "true", "3", "true",
-            "false", "false", "VARCHAR",
-            null, null, null, null, null, null),
-        asList("BOOLEAN", "16", "1", null, null, emptyList().toString(), "1", "false", "2", "true", "false", "false",
-            "BOOLEAN", null,
-            null, null, null, null, null),
-        asList("DATE", "91", "10", "DATE'", "'", emptyList().toString(), "1", "false", "2", "true", "false", "false",
-            "DATE", "0", "0",
-            null, null, "10", null),
-        asList("TIME", "92", "8", "TIME'", "'", emptyList().toString(), "1", "false", "2", "true", "false", "false",
-            "TIME", "0", "0",
-            null, null, "10", null),
-        asList("TIMESTAMP", "93", "29", "TIMESTAMP'", "'", emptyList().toString(), "1", "false", "2", "true", "false",
-            "false",
-            "TIMESTAMP", "0", "9", null, null, "10", null),
-        asList("OBJECT", "2000", null, null, null, emptyList().toString(), "1", "false", "2", "true", "false", "false",
-            "OBJECT", null,
-            null, null, null, null, null),
-        asList("BLOB", "2004", "2147483647", null, null, singletonList("length").toString(), "1", "false", "0", null,
-            "false", null, "BLOB", null,
-            null, null, null, null, null),
-        asList("CLOB", "2005", "2147483647", "'", "'", singletonList("length").toString(), "1", "true", "1", null,
-            "false", null, "CLOB", null,
-            null, null, null, null, null),
-        asList("XML", "2009", null, null, null, emptyList().toString(), "1", "true", "0", "false", "false", "false",
-            "XML", null, null,
-            null, null, null, null));
-    MatcherAssert.assertThat(results, is(matchers));
+    try (FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket())) {
+
+      final List<List<String>> results = getResults(stream);
+
+      final List<List<String>> matchers = ImmutableList.of(
+          asList("BIGINT", "-5", "19", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
+              "BIGINT", "0", "0",
+              null, null, "10", null),
+          asList("LONG VARCHAR FOR BIT DATA", "-4", "32700", "X'", "'", emptyList().toString(), "1", "false", "0",
+              "true", "false", "false",
+              "LONG VARCHAR FOR BIT DATA", null, null, null, null, null, null),
+          asList("VARCHAR () FOR BIT DATA", "-3", "32672", "X'", "'", singletonList("length").toString(), "1", "false",
+              "2", "true", "false",
+              "false", "VARCHAR () FOR BIT DATA", null, null, null, null, null, null),
+          asList("CHAR () FOR BIT DATA", "-2", "254", "X'", "'", singletonList("length").toString(), "1", "false", "2",
+              "true", "false", "false",
+              "CHAR () FOR BIT DATA", null, null, null, null, null, null),
+          asList("LONG VARCHAR", "-1", "32700", "'", "'", emptyList().toString(), "1", "true", "1", "true", "false",
+              "false",
+              "LONG VARCHAR", null, null, null, null, null, null),
+          asList("CHAR", "1", "254", "'", "'", singletonList("length").toString(), "1", "true", "3", "true", "false",
+              "false", "CHAR", null, null,
+              null, null, null, null),
+          asList("NUMERIC", "2", "31", null, null, Arrays.asList("precision", "scale").toString(), "1", "false", "2",
+              "false", "true", "false",
+              "NUMERIC", "0", "31", null, null, "10", null),
+          asList("DECIMAL", "3", "31", null, null, Arrays.asList("precision", "scale").toString(), "1", "false", "2",
+              "false", "true", "false",
+              "DECIMAL", "0", "31", null, null, "10", null),
+          asList("INTEGER", "4", "10", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
+              "INTEGER", "0", "0",
+              null, null, "10", null),
+          asList("SMALLINT", "5", "5", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
+              "SMALLINT", "0",
+              "0", null, null, "10", null),
+          asList("FLOAT", "6", "52", null, null, singletonList("precision").toString(), "1", "false", "2", "false",
+              "false", "false", "FLOAT", null,
+              null, null, null, "2", null),
+          asList("REAL", "7", "23", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "false",
+              "REAL", null, null,
+              null, null, "2", null),
+          asList("DOUBLE", "8", "52", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "false",
+              "DOUBLE", null,
+              null, null, null, "2", null),
+          asList("VARCHAR", "12", "32672", "'", "'", singletonList("length").toString(), "1", "true", "3", "true",
+              "false", "false", "VARCHAR",
+              null, null, null, null, null, null),
+          asList("BOOLEAN", "16", "1", null, null, emptyList().toString(), "1", "false", "2", "true", "false", "false",
+              "BOOLEAN", null,
+              null, null, null, null, null),
+          asList("DATE", "91", "10", "DATE'", "'", emptyList().toString(), "1", "false", "2", "true", "false", "false",
+              "DATE", "0", "0",
+              null, null, "10", null),
+          asList("TIME", "92", "8", "TIME'", "'", emptyList().toString(), "1", "false", "2", "true", "false", "false",
+              "TIME", "0", "0",
+              null, null, "10", null),
+          asList("TIMESTAMP", "93", "29", "TIMESTAMP'", "'", emptyList().toString(), "1", "false", "2", "true", "false",
+              "false",
+              "TIMESTAMP", "0", "9", null, null, "10", null),
+          asList("OBJECT", "2000", null, null, null, emptyList().toString(), "1", "false", "2", "true", "false",
+              "false", "OBJECT", null,
+              null, null, null, null, null),
+          asList("BLOB", "2004", "2147483647", null, null, singletonList("length").toString(), "1", "false", "0", null,
+              "false", null, "BLOB", null,
+              null, null, null, null, null),
+          asList("CLOB", "2005", "2147483647", "'", "'", singletonList("length").toString(), "1", "true", "1", null,
+              "false", null, "CLOB", null,
+              null, null, null, null, null),
+          asList("XML", "2009", null, null, null, emptyList().toString(), "1", "true", "0", "false", "false", "false",
+              "XML", null, null,
+              null, null, null, null));
+      MatcherAssert.assertThat(results, is(matchers));
+    }
   }
 
   @Test
-  public void testGetTypeInfoWithFiltering() {
+  public void testGetTypeInfoWithFiltering() throws Exception {
     FlightInfo flightInfo = sqlClient.getXdbcTypeInfo(-5);
 
-    FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket());
+    try (FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket())) {
 
-    final List<List<String>> results = getResults(stream);
+      final List<List<String>> results = getResults(stream);
 
-    final List<List<String>> matchers = ImmutableList.of(
-        asList("BIGINT", "-5", "19", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
-            "BIGINT", "0", "0",
-            null, null, "10", null));
-    MatcherAssert.assertThat(results, is(matchers));
+      final List<List<String>> matchers = ImmutableList.of(
+          asList("BIGINT", "-5", "19", null, null, emptyList().toString(), "1", "false", "2", "false", "false", "true",
+              "BIGINT", "0", "0",
+              null, null, "10", null));
+      MatcherAssert.assertThat(results, is(matchers));
+    }
   }
 
   @Test
-  public void testGetCommandCrossReference() {
+  public void testGetCommandCrossReference() throws Exception {
     final FlightInfo flightInfo = sqlClient.getCrossReference(TableRef.of(null, null,
         "FOREIGNTABLE"), TableRef.of(null, null, "INTTABLE"));
-    final FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket());
-
-    final List<List<String>> results = getResults(stream);
-
-    final List<Matcher<String>> matchers = asList(
-        nullValue(String.class), // pk_catalog_name
-        is("APP"), // pk_schema_name
-        is("FOREIGNTABLE"), // pk_table_name
-        is("ID"), // pk_column_name
-        nullValue(String.class), // fk_catalog_name
-        is("APP"), // fk_schema_name
-        is("INTTABLE"), // fk_table_name
-        is("FOREIGNID"), // fk_column_name
-        is("1"), // key_sequence
-        containsString("SQL"), // fk_key_name
-        containsString("SQL"), // pk_key_name
-        is("3"), // update_rule
-        is("3")); // delete_rule
-
-    Assertions.assertEquals(1, results.size());
-    final List<Executable> assertions = new ArrayList<>();
-    for (int i = 0; i < matchers.size(); i++) {
-      final String actual = results.get(0).get(i);
-      final Matcher<String> expected = matchers.get(i);
-      assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+    try (final FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket())) {
+
+      final List<List<String>> results = getResults(stream);
+
+      final List<Matcher<String>> matchers = asList(
+          nullValue(String.class), // pk_catalog_name
+          is("APP"), // pk_schema_name
+          is("FOREIGNTABLE"), // pk_table_name
+          is("ID"), // pk_column_name
+          nullValue(String.class), // fk_catalog_name
+          is("APP"), // fk_schema_name
+          is("INTTABLE"), // fk_table_name
+          is("FOREIGNID"), // fk_column_name
+          is("1"), // key_sequence
+          containsString("SQL"), // fk_key_name
+          containsString("SQL"), // pk_key_name
+          is("3"), // update_rule
+          is("3")); // delete_rule
+
+      Assertions.assertEquals(1, results.size());
+      final List<Executable> assertions = new ArrayList<>();
+      for (int i = 0; i < matchers.size(); i++) {
+        final String actual = results.get(0).get(i);
+        final Matcher<String> expected = matchers.get(i);
+        assertions.add(() -> MatcherAssert.assertThat(actual, expected));
+      }
+      Assertions.assertAll(assertions);
     }
-    Assertions.assertAll(assertions);
   }
 
   @Test
@@ -878,90 +870,6 @@ public void testCreateStatementResults() throws Exception {
     }
   }
 
-  List<List<String>> getResults(FlightStream stream) {
-    final List<List<String>> results = new ArrayList<>();
-    while (stream.next()) {
-      try (final VectorSchemaRoot root = stream.getRoot()) {
-        final long rowCount = root.getRowCount();
-        for (int i = 0; i < rowCount; ++i) {
-          results.add(new ArrayList<>());
-        }
-
-        root.getSchema().getFields().forEach(field -> {
-          try (final FieldVector fieldVector = root.getVector(field.getName())) {
-            if (fieldVector instanceof VarCharVector) {
-              final VarCharVector varcharVector = (VarCharVector) fieldVector;
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                final Text data = varcharVector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : data.toString());
-              }
-            } else if (fieldVector instanceof IntVector) {
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                Object data = fieldVector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
-              }
-            } else if (fieldVector instanceof VarBinaryVector) {
-              final VarBinaryVector varbinaryVector = (VarBinaryVector) fieldVector;
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                final byte[] data = varbinaryVector.getObject(rowIndex);
-                final String output;
-                try {
-                  output = isNull(data) ?
-                      null :
-                      MessageSerializer.deserializeSchema(
-                          new ReadChannel(Channels.newChannel(new ByteArrayInputStream(data)))).toJson();
-                } catch (final IOException e) {
-                  throw new RuntimeException("Failed to deserialize schema", e);
-                }
-                results.get(rowIndex).add(output);
-              }
-            } else if (fieldVector instanceof DenseUnionVector) {
-              final DenseUnionVector denseUnionVector = (DenseUnionVector) fieldVector;
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                final Object data = denseUnionVector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
-              }
-            } else if (fieldVector instanceof ListVector) {
-              for (int i = 0; i < fieldVector.getValueCount(); i++) {
-                if (!fieldVector.isNull(i)) {
-                  List<Text> elements = (List<Text>) ((ListVector) fieldVector).getObject(i);
-                  List<String> values = new ArrayList<>();
-
-                  for (Text element : elements) {
-                    values.add(element.toString());
-                  }
-                  results.get(i).add(values.toString());
-                }
-              }
-
-            } else if (fieldVector instanceof UInt4Vector) {
-              final UInt4Vector uInt4Vector = (UInt4Vector) fieldVector;
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                final Object data = uInt4Vector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
-              }
-            } else if (fieldVector instanceof UInt1Vector) {
-              final UInt1Vector uInt1Vector = (UInt1Vector) fieldVector;
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                final Object data = uInt1Vector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
-              }
-            } else if (fieldVector instanceof BitVector) {
-              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
-                Object data = fieldVector.getObject(rowIndex);
-                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
-              }
-            } else {
-              throw new UnsupportedOperationException("Not yet implemented");
-            }
-          }
-        });
-      }
-    }
-
-    return results;
-  }
-
   @Test
   public void testExecuteUpdate() {
     Assertions.assertAll(
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
new file mode 100644
index 0000000000000..4672e0a141832
--- /dev/null
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
@@ -0,0 +1,288 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.flight;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.apache.arrow.flight.sql.util.FlightStreamUtils.getResults;
+import static org.apache.arrow.util.AutoCloseables.close;
+import static org.apache.arrow.vector.types.Types.MinorType.INT;
+import static org.hamcrest.CoreMatchers.is;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.arrow.flight.sql.BasicFlightSqlProducer;
+import org.apache.arrow.flight.sql.FlightSqlClient;
+import org.apache.arrow.flight.sql.FlightSqlProducer;
+import org.apache.arrow.flight.sql.impl.FlightSql;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.types.Types;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.arrow.vector.util.Text;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+
+public class TestFlightSqlStreams {
+
+  /**
+   * A limited {@link FlightSqlProducer} for testing GetTables, GetTableTypes, GetSqlInfo, and limited SQL commands.
+   */
+  private static class FlightSqlTestProducer extends BasicFlightSqlProducer {
+
+    // Note that for simplicity the getStream* implementations are blocking, but a proper FlightSqlProducer should
+    // have non-blocking implementations of getStream*.
+
+    private static final String FIXED_QUERY = "SELECT 1 AS c1 FROM test_table";
+    private static final Schema FIXED_SCHEMA = new Schema(asList(
+        Field.nullable("c1", Types.MinorType.INT.getType())));
+
+    private BufferAllocator allocator;
+
+    FlightSqlTestProducer(BufferAllocator allocator) {
+      this.allocator = allocator;
+    }
+
+    @Override
+    protected <T extends Message> List<FlightEndpoint> determineEndpoints(T request, FlightDescriptor flightDescriptor,
+                                                                          Schema schema) {
+      if (request instanceof FlightSql.CommandGetTables ||
+          request instanceof FlightSql.CommandGetTableTypes ||
+          request instanceof FlightSql.CommandGetXdbcTypeInfo ||
+          request instanceof FlightSql.CommandGetSqlInfo) {
+        return Collections.singletonList(new FlightEndpoint(new Ticket(Any.pack(request).toByteArray())));
+      } else if (request instanceof FlightSql.CommandStatementQuery &&
+          ((FlightSql.CommandStatementQuery) request).getQuery().equals(FIXED_QUERY)) {
+
+        // Tickets from CommandStatementQuery requests should be built using TicketStatementQuery then packed() into
+        // a ticket. The content of the statement handle is specific to the FlightSqlProducer. It does not need to
+        // be the query. It can be a query ID for example.
+        FlightSql.TicketStatementQuery ticketStatementQuery = FlightSql.TicketStatementQuery.newBuilder()
+            .setStatementHandle(((FlightSql.CommandStatementQuery) request).getQueryBytes())
+            .build();
+        return Collections.singletonList(new FlightEndpoint(new Ticket(Any.pack(ticketStatementQuery).toByteArray())));
+      }
+      throw CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException();
+    }
+
+    @Override
+    public FlightInfo getFlightInfoStatement(FlightSql.CommandStatementQuery command,
+                                             CallContext context, FlightDescriptor descriptor) {
+      return generateFlightInfo(command, descriptor, FIXED_SCHEMA);
+    }
+
+    @Override
+    public void getStreamStatement(FlightSql.TicketStatementQuery ticket,
+                                   CallContext context, ServerStreamListener listener) {
+      final String query = ticket.getStatementHandle().toStringUtf8();
+      if (!query.equals(FIXED_QUERY)) {
+        listener.error(CallStatus.UNIMPLEMENTED.withDescription("Not implemented.").toRuntimeException());
+      }
+
+      try (VectorSchemaRoot root = VectorSchemaRoot.create(FIXED_SCHEMA, allocator)) {
+        root.setRowCount(1);
+        ((IntVector) root.getVector("c1")).setSafe(0, 1);
+        listener.start(root);
+        listener.putNext();
+        listener.completed();
+      }
+    }
+
+    @Override
+    public void getStreamSqlInfo(FlightSql.CommandGetSqlInfo command, CallContext context,
+                                 ServerStreamListener listener) {
+      try (VectorSchemaRoot root = VectorSchemaRoot.create(Schemas.GET_SQL_INFO_SCHEMA, allocator)) {
+        root.setRowCount(0);
+        listener.start(root);
+        listener.putNext();
+        listener.completed();
+      }
+    }
+
+    @Override
+    public void getStreamTypeInfo(FlightSql.CommandGetXdbcTypeInfo request,
+                                  CallContext context, ServerStreamListener listener) {
+      try (VectorSchemaRoot root = VectorSchemaRoot.create(Schemas.GET_TYPE_INFO_SCHEMA, allocator)) {
+        root.setRowCount(1);
+        ((VarCharVector) root.getVector("type_name")).setSafe(0, new Text("Integer"));
+        ((IntVector) root.getVector("data_type")).setSafe(0, INT.ordinal());
+        ((IntVector) root.getVector("column_size")).setSafe(0, 400);
+        root.getVector("literal_prefix").setNull(0);
+        root.getVector("literal_suffix").setNull(0);
+        root.getVector("create_params").setNull(0);
+        ((IntVector) root.getVector("nullable")).setSafe(0, FlightSql.Nullable.NULLABILITY_NULLABLE.getNumber());
+        ((BitVector) root.getVector("case_sensitive")).setSafe(0, 1);
+        ((IntVector) root.getVector("nullable")).setSafe(0, FlightSql.Searchable.SEARCHABLE_FULL.getNumber());
+        ((BitVector) root.getVector("unsigned_attribute")).setSafe(0, 1);
+        root.getVector("fixed_prec_scale").setNull(0);
+        ((BitVector) root.getVector("auto_increment")).setSafe(0, 1);
+        ((VarCharVector) root.getVector("local_type_name")).setSafe(0, new Text("Integer"));
+        root.getVector("minimum_scale").setNull(0);
+        root.getVector("maximum_scale").setNull(0);
+        ((IntVector) root.getVector("sql_data_type")).setSafe(0, INT.ordinal());
+        root.getVector("datetime_subcode").setNull(0);
+        ((IntVector) root.getVector("num_prec_radix")).setSafe(0, 10);
+        root.getVector("interval_precision").setNull(0);
+
+        listener.start(root);
+        listener.putNext();
+        listener.completed();
+      }
+    }
+
+    @Override
+    public void getStreamTables(FlightSql.CommandGetTables command, CallContext context,
+                                ServerStreamListener listener) {
+      try (VectorSchemaRoot root = VectorSchemaRoot.create(Schemas.GET_TABLES_SCHEMA_NO_SCHEMA, allocator)) {
+        root.setRowCount(1);
+        root.getVector("catalog_name").setNull(0);
+        root.getVector("db_schema_name").setNull(0);
+        ((VarCharVector) root.getVector("table_name")).setSafe(0, new Text("test_table"));
+        ((VarCharVector) root.getVector("table_type")).setSafe(0, new Text("TABLE"));
+
+        listener.start(root);
+        listener.putNext();
+        listener.completed();
+      }
+    }
+
+    @Override
+    public void getStreamTableTypes(CallContext context, ServerStreamListener listener) {
+      try (VectorSchemaRoot root = VectorSchemaRoot.create(Schemas.GET_TABLE_TYPES_SCHEMA, allocator)) {
+        root.setRowCount(1);
+        ((VarCharVector) root.getVector("table_type")).setSafe(0, new Text("TABLE"));
+
+        listener.start(root);
+        listener.putNext();
+        listener.completed();
+      }
+    }
+  }
+
+  private static BufferAllocator allocator;
+
+  private static FlightServer server;
+  private static FlightSqlClient sqlClient;
+
+  @BeforeAll
+  public static void setUp() throws Exception {
+    allocator = new RootAllocator(Integer.MAX_VALUE);
+
+    final Location serverLocation = Location.forGrpcInsecure("localhost", 0);
+    server = FlightServer.builder(allocator, serverLocation, new FlightSqlTestProducer(allocator))
+        .build()
+        .start();
+
+    final Location clientLocation = Location.forGrpcInsecure("localhost", server.getPort());
+    sqlClient = new FlightSqlClient(FlightClient.builder(allocator, clientLocation).build());
+  }
+
+  @AfterAll
+  public static void tearDown() throws Exception {
+    close(sqlClient, server, allocator);
+  }
+
+  @Test
+  public void testGetTablesResultNoSchema() throws Exception {
+    try (final FlightStream stream =
+             sqlClient.getStream(
+                 sqlClient.getTables(null, null, null, null, false)
+                     .getEndpoints().get(0).getTicket())) {
+      Assertions.assertAll(
+          () -> MatcherAssert.assertThat(stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLES_SCHEMA_NO_SCHEMA)),
+          () -> {
+            final List<List<String>> results = getResults(stream);
+            final List<List<String>> expectedResults = ImmutableList.of(
+                // catalog_name | schema_name | table_name | table_type | table_schema
+                asList(null, null, "test_table", "TABLE"));
+            MatcherAssert.assertThat(results, is(expectedResults));
+          }
+      );
+    }
+  }
+
+  @Test
+  public void testGetTableTypesResult() throws Exception {
+    try (final FlightStream stream =
+             sqlClient.getStream(sqlClient.getTableTypes().getEndpoints().get(0).getTicket())) {
+      Assertions.assertAll(
+          () -> MatcherAssert.assertThat(stream.getSchema(), is(FlightSqlProducer.Schemas.GET_TABLE_TYPES_SCHEMA)),
+          () -> {
+            final List<List<String>> tableTypes = getResults(stream);
+            final List<List<String>> expectedTableTypes = ImmutableList.of(
+                // table_type
+                singletonList("TABLE")
+            );
+            MatcherAssert.assertThat(tableTypes, is(expectedTableTypes));
+          }
+      );
+    }
+  }
+
+  @Test
+  public void testGetSqlInfoResults() throws Exception {
+    final FlightInfo info = sqlClient.getSqlInfo();
+    try (final FlightStream stream = sqlClient.getStream(info.getEndpoints().get(0).getTicket())) {
+      Assertions.assertAll(
+          () -> MatcherAssert.assertThat(stream.getSchema(), is(FlightSqlProducer.Schemas.GET_SQL_INFO_SCHEMA)),
+          () -> MatcherAssert.assertThat(getResults(stream), is(emptyList()))
+      );
+    }
+  }
+
+  @Test
+  public void testGetTypeInfo() throws Exception {
+    FlightInfo flightInfo = sqlClient.getXdbcTypeInfo();
+
+    try (FlightStream stream = sqlClient.getStream(flightInfo.getEndpoints().get(0).getTicket())) {
+
+      final List<List<String>> results = getResults(stream);
+
+      final List<List<String>> matchers = ImmutableList.of(
+          asList("Integer", "4", "400", null, null, "3", "true", null, "true", null, "true",
+              "Integer", null, null, "4", null, "10", null));
+
+      MatcherAssert.assertThat(results, is(matchers));
+    }
+  }
+
+  @Test
+  public void testExecuteQuery() throws Exception {
+    try (final FlightStream stream = sqlClient
+        .getStream(sqlClient.execute(FlightSqlTestProducer.FIXED_QUERY).getEndpoints().get(0).getTicket())) {
+      Assertions.assertAll(
+          () -> MatcherAssert.assertThat(stream.getSchema(), is(FlightSqlTestProducer.FIXED_SCHEMA)),
+          () -> MatcherAssert.assertThat(getResults(stream), is(singletonList(singletonList("1"))))
+      );
+    }
+  }
+}
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/util/FlightStreamUtils.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/util/FlightStreamUtils.java
new file mode 100644
index 0000000000000..fbbe9ef01816e
--- /dev/null
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/sql/util/FlightStreamUtils.java
@@ -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.
+ */
+
+package org.apache.arrow.flight.sql.util;
+
+import static java.util.Objects.isNull;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.channels.Channels;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.apache.arrow.flight.FlightStream;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.UInt1Vector;
+import org.apache.arrow.vector.UInt4Vector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.complex.DenseUnionVector;
+import org.apache.arrow.vector.complex.ListVector;
+import org.apache.arrow.vector.ipc.ReadChannel;
+import org.apache.arrow.vector.ipc.message.MessageSerializer;
+import org.apache.arrow.vector.util.Text;
+
+public class FlightStreamUtils {
+
+  public static List<List<String>> getResults(FlightStream stream) {
+    final List<List<String>> results = new ArrayList<>();
+    while (stream.next()) {
+      try (final VectorSchemaRoot root = stream.getRoot()) {
+        final long rowCount = root.getRowCount();
+        for (int i = 0; i < rowCount; ++i) {
+          results.add(new ArrayList<>());
+        }
+
+        root.getSchema().getFields().forEach(field -> {
+          try (final FieldVector fieldVector = root.getVector(field.getName())) {
+            if (fieldVector instanceof VarCharVector) {
+              final VarCharVector varcharVector = (VarCharVector) fieldVector;
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                final Text data = varcharVector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : data.toString());
+              }
+            } else if (fieldVector instanceof IntVector) {
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                Object data = fieldVector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
+              }
+            } else if (fieldVector instanceof VarBinaryVector) {
+              final VarBinaryVector varbinaryVector = (VarBinaryVector) fieldVector;
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                final byte[] data = varbinaryVector.getObject(rowIndex);
+                final String output;
+                try {
+                  output = isNull(data) ?
+                      null :
+                      MessageSerializer.deserializeSchema(
+                          new ReadChannel(Channels.newChannel(new ByteArrayInputStream(data)))).toJson();
+                } catch (final IOException e) {
+                  throw new RuntimeException("Failed to deserialize schema", e);
+                }
+                results.get(rowIndex).add(output);
+              }
+            } else if (fieldVector instanceof DenseUnionVector) {
+              final DenseUnionVector denseUnionVector = (DenseUnionVector) fieldVector;
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                final Object data = denseUnionVector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
+              }
+            } else if (fieldVector instanceof ListVector) {
+              for (int i = 0; i < fieldVector.getValueCount(); i++) {
+                if (!fieldVector.isNull(i)) {
+                  List<Text> elements = (List<Text>) ((ListVector) fieldVector).getObject(i);
+                  List<String> values = new ArrayList<>();
+
+                  for (Text element : elements) {
+                    values.add(element.toString());
+                  }
+                  results.get(i).add(values.toString());
+                }
+              }
+
+            } else if (fieldVector instanceof UInt4Vector) {
+              final UInt4Vector uInt4Vector = (UInt4Vector) fieldVector;
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                final Object data = uInt4Vector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
+              }
+            } else if (fieldVector instanceof UInt1Vector) {
+              final UInt1Vector uInt1Vector = (UInt1Vector) fieldVector;
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                final Object data = uInt1Vector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
+              }
+            } else if (fieldVector instanceof BitVector) {
+              for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+                Object data = fieldVector.getObject(rowIndex);
+                results.get(rowIndex).add(isNull(data) ? null : Objects.toString(data));
+              }
+            } else {
+              throw new UnsupportedOperationException("Not yet implemented");
+            }
+          }
+        });
+      }
+    }
+
+    return results;
+  }
+}

From 0f94eb64c45a3a8f24395616941971e751b58765 Mon Sep 17 00:00:00 2001
From: hrishisd <hdharam@berkeley.edu>
Date: Mon, 25 Sep 2023 10:55:29 -0400
Subject: [PATCH 406/749] GH-37829: [Java] Avoid resizing data buffer twice
 when appending variable length vectors (#37844)

### Rationale for this change
This change prevents avoidable `OversizedAllocationException`s when appending a variable-length vector with many small elements to a variable-length vector with a few large elements.

When appending variable-length vectors, `VectorAppender` iteratively doubles the offset and validity buffers until they can accommodate the combined elements. In the previous implementation, each iteration would also double the data buffer's capacity. This behavior is appropriate for vectors of fixed-size types but can result in an oversized data buffers when appending many small elements to a variable length vector with a large data buffer.

### What changes are included in this PR?
The new behavior only resizes the offset and validity buffers when resizing the target vector's buffers to ensure they can hold the total number of combined elements.

The data buffer is resized based on the total required data size of the combined elements.

### Are these changes tested?
Yes. I added a unit test that results in an `OversizedAllocationException` when run against the previous version of the code.

### Are there any user-facing changes?
No.

* Closes: #37829

Authored-by: hrishisd <hdharam@berkeley.edu>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/vector/util/VectorAppender.java     |  4 +--
 .../arrow/vector/util/TestVectorAppender.java | 27 ++++++++++++++++++-
 .../util/TestVectorSchemaRootAppender.java    |  2 +-
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java b/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
index 9f73732ccfdd3..c5de380f9c173 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/VectorAppender.java
@@ -116,7 +116,7 @@ public ValueVector visit(BaseVariableWidthVector deltaVector, Void value) {
 
     // make sure there is enough capacity
     while (targetVector.getValueCapacity() < newValueCount) {
-      targetVector.reAlloc();
+      ((BaseVariableWidthVector) targetVector).reallocValidityAndOffsetBuffers();
     }
     while (targetVector.getDataBuffer().capacity() < newValueCapacity) {
       ((BaseVariableWidthVector) targetVector).reallocDataBuffer();
@@ -170,7 +170,7 @@ public ValueVector visit(BaseLargeVariableWidthVector deltaVector, Void value) {
 
     // make sure there is enough capacity
     while (targetVector.getValueCapacity() < newValueCount) {
-      targetVector.reAlloc();
+      ((BaseLargeVariableWidthVector) targetVector).reallocValidityAndOffsetBuffers();
     }
     while (targetVector.getDataBuffer().capacity() < newValueCapacity) {
       ((BaseLargeVariableWidthVector) targetVector).reallocDataBuffer();
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorAppender.java b/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorAppender.java
index 25d26623d5c05..ab36ea2fd2129 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorAppender.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorAppender.java
@@ -21,11 +21,14 @@
 import static junit.framework.TestCase.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.BaseValueVector;
 import org.apache.arrow.vector.BigIntVector;
 import org.apache.arrow.vector.BitVector;
 import org.apache.arrow.vector.Float4Vector;
@@ -63,7 +66,8 @@ public class TestVectorAppender {
 
   @Before
   public void prepare() {
-    allocator = new RootAllocator(1024 * 1024);
+    // Permit allocating 4 vectors of max size.
+    allocator = new RootAllocator(4 * BaseValueVector.MAX_ALLOCATION_SIZE);
   }
 
   @After
@@ -185,6 +189,27 @@ public void testAppendEmptyVariableWidthVector() {
     }
   }
 
+  @Test
+  public void testAppendLargeAndSmallVariableVectorsWithinLimit() {
+    int sixteenthOfMaxAllocation = Math.toIntExact(BaseValueVector.MAX_ALLOCATION_SIZE / 16);
+    try (VarCharVector target = makeVarCharVec(1, sixteenthOfMaxAllocation);
+        VarCharVector delta = makeVarCharVec(sixteenthOfMaxAllocation, 1)) {
+      new VectorAppender(delta).visit(target, null);
+      new VectorAppender(target).visit(delta, null);
+    }
+  }
+
+  private VarCharVector makeVarCharVec(int numElements, int bytesPerElement) {
+    VarCharVector v = new VarCharVector("text", allocator);
+    v.allocateNew((long) numElements * bytesPerElement, numElements);
+    for (int i = 0; i < numElements; i++) {
+      String s = String.join("", Collections.nCopies(bytesPerElement, "a"));
+      v.setSafe(i, s.getBytes(StandardCharsets.US_ASCII));
+    }
+    v.setValueCount(numElements);
+    return v;
+  }
+
   @Test
   public void testAppendLargeVariableWidthVector() {
     final int length1 = 5;
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorSchemaRootAppender.java b/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorSchemaRootAppender.java
index ab0ee3a2075a3..6309d385870c9 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorSchemaRootAppender.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/util/TestVectorSchemaRootAppender.java
@@ -50,7 +50,7 @@ public void shutdown() {
   }
 
   @Test
-  public void testVectorScehmaRootAppend() {
+  public void testVectorSchemaRootAppend() {
     final int length1 = 5;
     final int length2 = 3;
     final int length3 = 2;

From 1ae243628611a43812747f3bc1505072a139b1c8 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 25 Sep 2023 11:56:13 -0400
Subject: [PATCH 407/749] GH-37825: [MATLAB] Improve `arrow.type.Field` display
 (#37826)

### Rationale for this change

We should improve the display of `arrow.type.Field`, which currently looks like this:

```matlab
>> arrow.field("A", arrow.int32())

ans =

A: int32
```

This display isn't very "MATLAB-like". For instance, it doesn't display the object's class type.  This display would be better:

```matlab
>> arrow.field("A", arrow.int32())

ans =

  Field with properties:

    Name: "A"
    Type: [1x1 arrow.type.Int32Type]
```

### What changes are included in this PR?

1. Added `getPropertyGroups` method to `Field`. This method is inherited from the superclass `matlab.mixin.CustomDisplay`.
2. Removed `displayScalarObject` method from `Field`. This method is also inherited from `matlab.mixin.CustomDisplay`. By implementing `getPropertyGroups`, we no longer need to override `displayScalarObject` and can use the default implementation of this method in `CustomDisplay`.
3. Removed `toString()` method from `Field`. This method was private, and only used by `displayScalarObject`. Since `displayScalarObject` has been removed, `toString()` can be deleted too.
4. Converted the helper test methods (`makeLinkString`,  `makeDimensionString`, `verifyDisplay`) in `tTypeDisplay` into standalone functions.  Test classes other than `tTypeDisplay.m` can now use these utilities as well.

### Are these changes tested?

Yes. Added a `TestDisplay` unit test to `tField.m`.

### Are there any user-facing changes?

Yes. `arrow.type.Field` objects are now displayed differently in the Command Window.

### Future Directions
1. Update the display of `arrow.tabular.Schema`.
2. Update the display of `arrow.array.Array`.
3. Update the display of `arrow.tabular.Table`.
4.  Update the display of `arrow.tabular.RecordBatch`.
* Closes: #37825

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/type/proxy/field.cc  | 11 ---
 .../src/cpp/arrow/matlab/type/proxy/field.h   |  1 -
 .../+test/+display/makeDimensionString.m      | 22 +++++
 .../+internal/+test/+display/makeLinkString.m | 36 ++++++++
 .../+arrow/+internal/+test/+display/verify.m  | 32 +++++++
 matlab/src/matlab/+arrow/+type/Field.m        | 12 +--
 matlab/test/arrow/type/tField.m               | 28 ++++++
 matlab/test/arrow/type/tTypeDisplay.m         | 85 ++++++++-----------
 8 files changed, 157 insertions(+), 70 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+test/+display/makeDimensionString.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+test/+display/makeLinkString.m
 create mode 100644 matlab/src/matlab/+arrow/+internal/+test/+display/verify.m

diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
index 7df0e7d6ef304..138771a35c327 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.cc
@@ -32,7 +32,6 @@ namespace arrow::matlab::type::proxy {
     Field::Field(std::shared_ptr<arrow::Field> field) : field{std::move(field)} {
         REGISTER_METHOD(Field, getName);
         REGISTER_METHOD(Field, getType);
-        REGISTER_METHOD(Field, toString);
     }
 
     std::shared_ptr<arrow::Field> Field::unwrap() {
@@ -64,16 +63,6 @@ namespace arrow::matlab::type::proxy {
         context.outputs[0] = output;
     }
 
-    void Field::toString(libmexclass::proxy::method::Context& context) {
-        namespace mda = ::matlab::data;
-        mda::ArrayFactory factory;
-
-        const auto str_utf8 = field->ToString();
-        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
-        auto str_mda = factory.createScalar(str_utf16);
-        context.outputs[0] = str_mda;
-    }
-
     libmexclass::proxy::MakeResult Field::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
         namespace mda = ::matlab::data;
         using FieldProxy = arrow::matlab::type::proxy::Field;
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/field.h b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
index 4256fd21a0a23..3526a6c422ac3 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/field.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/field.h
@@ -36,7 +36,6 @@ class Field : public libmexclass::proxy::Proxy {
     protected:
         void getName(libmexclass::proxy::method::Context& context);
         void getType(libmexclass::proxy::method::Context& context);
-        void toString(libmexclass::proxy::method::Context& context);
 
         std::shared_ptr<arrow::Field> field;
 };
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+display/makeDimensionString.m b/matlab/src/matlab/+arrow/+internal/+test/+display/makeDimensionString.m
new file mode 100644
index 0000000000000..4281667543634
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+test/+display/makeDimensionString.m
@@ -0,0 +1,22 @@
+%MAKEDIMENSIONSTRING Utility function for creating a string representation
+%of dimensions.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function dimensionString = makeDimensionString(arraySize)
+    dimensionString = string(arraySize);
+    dimensionString = join(dimensionString, char(215));
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+display/makeLinkString.m b/matlab/src/matlab/+arrow/+internal/+test/+display/makeLinkString.m
new file mode 100644
index 0000000000000..df6a11612043c
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+test/+display/makeLinkString.m
@@ -0,0 +1,36 @@
+%MAKELINKSTRING Utility function for creating hyperlinks.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function link = makeLinkString(opts)
+    arguments
+        opts.FullClassName(1, 1) string
+        opts.ClassName(1, 1) string
+        % When displaying heterogeneous arrays, only the name of the 
+        % closest shared anscestor class is displayed in bold. All other
+        % class names are not bolded.
+        opts.BoldFont(1, 1) logical
+    end
+        
+    if opts.BoldFont
+        link = compose("<a href=""matlab:helpPopup %s""" + ...
+            " style=""font-weight:bold"">%s</a>", ...
+            opts.FullClassName, opts.ClassName);
+    else
+        link = compose("<a href=""matlab:helpPopup %s"">%s</a>", ...
+            opts.FullClassName, opts.ClassName);
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+display/verify.m b/matlab/src/matlab/+arrow/+internal/+test/+display/verify.m
new file mode 100644
index 0000000000000..d9a420663b783
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+test/+display/verify.m
@@ -0,0 +1,32 @@
+%VERIFY Utility function used to verify object display.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function verify(testCase, actualDisplay, expectedDisplay)
+    % When the MATLAB GUI is running, '×' (char(215)) is used as
+    % the delimiter between dimension values. However, when the 
+    % GUI is not running, 'x' (char(120)) is used as the delimiter.
+    % To account for this discrepancy, check if actualDisplay 
+    % contains char(215). If not, replace all instances of
+    % char(215) in expectedDisplay with char(120).
+
+    tf = contains(actualDisplay, char(215));
+    if ~tf
+        idx = strfind(expectedDisplay, char(215));
+        expectedDisplay(idx) = char(120);
+    end
+    testCase.verifyEqual(actualDisplay, expectedDisplay);
+end
diff --git a/matlab/src/matlab/+arrow/+type/Field.m b/matlab/src/matlab/+arrow/+type/Field.m
index f67ba69fe9826..d6e03f61fbea1 100644
--- a/matlab/src/matlab/+arrow/+type/Field.m
+++ b/matlab/src/matlab/+arrow/+type/Field.m
@@ -91,16 +91,10 @@
         end
     end
 
-    methods (Access = private)
-        function str = toString(obj)
-            str = obj.Proxy.toString();
-        end
-    end
-
     methods (Access=protected)
-        function displayScalarObject(obj)
-            disp(obj.toString());
+        function groups = getPropertyGroups(~)
+            targets = ["Name", "Type"];
+            groups = matlab.mixin.util.PropertyGroup(targets);
         end
     end
-
 end
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
index 1a89c0077b5ae..f84034d032c23 100644
--- a/matlab/test/arrow/type/tField.m
+++ b/matlab/test/arrow/type/tField.m
@@ -231,5 +231,33 @@ function TestIsEqualNonScalarFalse(testCase)
             % Compare arrow.type.Field array and a string array
             testCase.verifyFalse(isequal(f1, strings(size(f1))));
         end
+
+        function TestDisplay(testCase)
+            % Verify the display of Field objects.
+            %
+            % Example:
+            %
+            %  Field with properties:
+            %
+            %        Name: FieldA
+            %        Type: [1x2 arrow.type.Int32Type]
+
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
+            field = arrow.field("B", arrow.timestamp(TimeZone="America/Anchorage")); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.type.Field", ClassName="Field", BoldFont=true);
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["Name:"; "Type:"]));
+            dimensionString = makeDimensionString([1 1]);
+            fieldString = compose("[%s %s]", dimensionString, "arrow.type.TimestampType");
+            body = body + " " + ["""B"""; fieldString];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(field)');
+            verify(testCase, actualDisplay, expectedDisplay);
+        end
     end
 end
diff --git a/matlab/test/arrow/type/tTypeDisplay.m b/matlab/test/arrow/type/tTypeDisplay.m
index f84c5ab56e270..6f5a4bcd97717 100644
--- a/matlab/test/arrow/type/tTypeDisplay.m
+++ b/matlab/test/arrow/type/tTypeDisplay.m
@@ -50,6 +50,10 @@ function EmptyTypeDisplay(testCase)
             %
             %    ID
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
             type = arrow.type.Type.empty(0, 1);
             typeLink = makeLinkString(FullClassName="arrow.type.Type", ClassName="Type", BoldFont=true);
             dimensionString = makeDimensionString(size(type));
@@ -59,7 +63,7 @@ function EmptyTypeDisplay(testCase)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function NonScalarArrayDifferentTypes(testCase)
@@ -71,6 +75,10 @@ function NonScalarArrayDifferentTypes(testCase)
             %
             %    ID
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
             float32Type = arrow.float32();
             timestampType = arrow.timestamp();
             typeArray = [float32Type timestampType];
@@ -88,7 +96,7 @@ function NonScalarArrayDifferentTypes(testCase)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(typeArray)');
-            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function NonScalarArraySameTypes(testCase)
@@ -102,6 +110,10 @@ function NonScalarArraySameTypes(testCase)
             %    TimeUnit
             %    TimeZone 
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
             timestampType1 = arrow.timestamp(TimeZone="Pacific/Fiji");
             timestampType2 = arrow.timestamp(TimeUnit="Second");
             typeArray = [timestampType1 timestampType2];
@@ -114,7 +126,7 @@ function NonScalarArraySameTypes(testCase)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(typeArray)');
-            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function TestTypeDisplaysOnlyID(testCase, TypeDisplaysOnlyID)
@@ -127,6 +139,9 @@ function TestTypeDisplaysOnlyID(testCase, TypeDisplaysOnlyID)
             %
             %          ID: Boolean
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+
             type = TypeDisplaysOnlyID;
             fullClassName = string(class(type));
             className = reverse(extractBefore(reverse(fullClassName), "."));
@@ -136,7 +151,7 @@ function TestTypeDisplaysOnlyID(testCase, TypeDisplaysOnlyID)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function TestTimeType(testCase, TimeType)
@@ -149,6 +164,9 @@ function TestTimeType(testCase, TimeType)
             %          ID: Time32
             %    TimeUnit: Second
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+
             type = TimeType;
             fullClassName = string(class(type));
             className = reverse(extractBefore(reverse(fullClassName), "."));
@@ -161,7 +179,7 @@ function TestTimeType(testCase, TimeType)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function TestDateType(testCase, DateType)
@@ -174,6 +192,9 @@ function TestDateType(testCase, DateType)
             %          ID: Date32
             %    DateUnit: Day
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+
             type = DateType;
             fullClassName = string(class(type));
             className = reverse(extractBefore(reverse(fullClassName), "."));
@@ -186,7 +207,7 @@ function TestDateType(testCase, DateType)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function TimestampTypeDisplay(testCase)
@@ -200,6 +221,9 @@ function TimestampTypeDisplay(testCase)
             %    TimeUnit: Second
             %    TimeZone: "America/Anchorage"
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+
             type = arrow.timestamp(TimeUnit="Second", TimeZone="America/Anchorage"); %#ok<NASGU>
             classnameLink = makeLinkString(FullClassName="arrow.type.TimestampType", ClassName="TimestampType", BoldFont=true);
             header = "  " + classnameLink + " with properties:" + newline;
@@ -209,7 +233,7 @@ function TimestampTypeDisplay(testCase)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
 
         function StructTypeDisplay(testCase)
@@ -222,6 +246,10 @@ function StructTypeDisplay(testCase)
             %          ID: Struct
             %      Fields: [1x2 arrow.type.Field]
 
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
             fieldA = arrow.field("A", arrow.int32());
             fieldB = arrow.field("B", arrow.timestamp(TimeZone="America/Anchorage"));
             type = arrow.struct(fieldA, fieldB); %#ok<NASGU>
@@ -235,48 +263,7 @@ function StructTypeDisplay(testCase)
             footer = string(newline);
             expectedDisplay = char(strjoin([header body' footer], newline));
             actualDisplay = evalc('disp(type)');
-            testCase.verifyDisplay(actualDisplay, expectedDisplay);
+            verify(testCase, actualDisplay, expectedDisplay);
         end
     end
-
-    methods
-        function verifyDisplay(testCase, actualDisplay, expectedDisplay)
-            % When the MATLAB GUI is running, '×' (char(215)) is used as
-            % the delimiter between dimension values. However, when the 
-            % GUI is not running, 'x' (char(120)) is used as the delimiter.
-            % To account for this discrepancy, check if actualDisplay 
-            % contains char(215). If not, replace all instances of
-            % char(215) in expectedDisplay with char(120).
-
-            tf = contains(actualDisplay, char(215));
-            if ~tf
-                idx = strfind(expectedDisplay, char(215));
-                expectedDisplay(idx) = char(120);
-            end
-            testCase.verifyEqual(actualDisplay, expectedDisplay);
-        end
-    end
-end
-
-function link = makeLinkString(opts)
-    arguments
-        opts.FullClassName(1, 1) string
-        opts.ClassName(1, 1) string
-        % When displaying heterogeneous arrays, only the name of the 
-        % closest shared anscestor class is displayed in bold. All other
-        % class names are not bolded.
-        opts.BoldFont(1, 1) logical
-    end
-
-    if opts.BoldFont
-        link = compose("<a href=""matlab:helpPopup %s"" style=""font-weight:bold"">%s</a>", ...
-            opts.FullClassName, opts.ClassName);
-    else
-        link = compose("<a href=""matlab:helpPopup %s"">%s</a>", opts.FullClassName, opts.ClassName);
-    end
 end
-
-function dimensionString = makeDimensionString(arraySize)
-    dimensionString = string(arraySize);
-    dimensionString = join(dimensionString, char(215));
-end
\ No newline at end of file

From 5ca26e89228c272305aa2070ce8eb17a54e17640 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 25 Sep 2023 16:26:48 -0400
Subject: [PATCH 408/749] GH-37782: [C++] Add `CanReferenceFieldsByNames`
 method to `arrow::StructArray` (#37823)

### Rationale for this change

`arrow::Schema` has a method called `CanReferenceFieldsByNames` which callers can use prior to calling `GetFieldByName`. It would be nice if `arrow::StructArray` also had `CanReferenceFieldsByNames` as a method.

I also think it would be nice to add a `CanReferenceFieldByName` method that accepts a `std::string` instead of a `std::vector<std::string>` to `StructArray` and `Schema`. That way, users wouldn't have to create a `std::vector` containing one `std::string` when they just have one field name.

### What changes are included in this PR?

1. Added `CanReferenceFieldsByNames` method to `StructArray`
2. Added `CanReferenceFieldByName` method to `StructArray`
3. Added `CanReferenceFieldsByName` method to `Schema`

### Are these changes tested?

Yes. I added unit tests for `CanReferenceFieldsByNames` and `CanReferenceFieldByName` to `array_struct_test.cc` and `type_test.cc`.

### Are there any user-facing changes?

Yes. `CanReferenceFieldsByNames` and `CanReferenceFieldByName` can be called on a `StructArray`. Users can also call `CanReferenceFieldByName` on a `Schema`.

* Closes: #37782

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/array/array_nested.cc      | 16 ++++++++
 cpp/src/arrow/array/array_nested.h       |  6 +++
 cpp/src/arrow/array/array_struct_test.cc | 52 ++++++++++++++++++++++++
 cpp/src/arrow/type.cc                    | 14 ++++---
 cpp/src/arrow/type.h                     |  3 ++
 cpp/src/arrow/type_test.cc               | 18 ++++++++
 6 files changed, 104 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/array/array_nested.cc b/cpp/src/arrow/array/array_nested.cc
index df60074c78470..d8308c824953a 100644
--- a/cpp/src/arrow/array/array_nested.cc
+++ b/cpp/src/arrow/array/array_nested.cc
@@ -627,6 +627,22 @@ std::shared_ptr<Array> StructArray::GetFieldByName(const std::string& name) cons
   return i == -1 ? nullptr : field(i);
 }
 
+Status StructArray::CanReferenceFieldByName(const std::string& name) const {
+  if (GetFieldByName(name) == nullptr) {
+    return Status::Invalid("Field named '", name,
+                           "' not found or not unique in the struct.");
+  }
+  return Status::OK();
+}
+
+Status StructArray::CanReferenceFieldsByNames(
+    const std::vector<std::string>& names) const {
+  for (const auto& name : names) {
+    ARROW_RETURN_NOT_OK(CanReferenceFieldByName(name));
+  }
+  return Status::OK();
+}
+
 Result<ArrayVector> StructArray::Flatten(MemoryPool* pool) const {
   ArrayVector flattened;
   flattened.resize(data_->child_data.size());
diff --git a/cpp/src/arrow/array/array_nested.h b/cpp/src/arrow/array/array_nested.h
index 47c1db039ccc9..8d5cc95fec00d 100644
--- a/cpp/src/arrow/array/array_nested.h
+++ b/cpp/src/arrow/array/array_nested.h
@@ -404,6 +404,12 @@ class ARROW_EXPORT StructArray : public Array {
   /// Returns null if name not found
   std::shared_ptr<Array> GetFieldByName(const std::string& name) const;
 
+  /// Indicate if field named `name` can be found unambiguously in the struct.
+  Status CanReferenceFieldByName(const std::string& name) const;
+
+  /// Indicate if fields named `names` can be found unambiguously in the struct.
+  Status CanReferenceFieldsByNames(const std::vector<std::string>& names) const;
+
   /// \brief Flatten this array as a vector of arrays, one for each field
   ///
   /// \param[in] pool The pool to allocate null bitmaps from, if necessary
diff --git a/cpp/src/arrow/array/array_struct_test.cc b/cpp/src/arrow/array/array_struct_test.cc
index 318c83860e009..73d53a7efa59b 100644
--- a/cpp/src/arrow/array/array_struct_test.cc
+++ b/cpp/src/arrow/array/array_struct_test.cc
@@ -303,6 +303,58 @@ TEST(StructArray, FlattenOfSlice) {
   ASSERT_OK(arr->ValidateFull());
 }
 
+TEST(StructArray, CanReferenceFieldByName) {
+  auto a = ArrayFromJSON(int8(), "[4, 5]");
+  auto b = ArrayFromJSON(int16(), "[6, 7]");
+  auto c = ArrayFromJSON(int32(), "[8, 9]");
+  auto d = ArrayFromJSON(int64(), "[10, 11]");
+  auto children = std::vector<std::shared_ptr<Array>>{a, b, c, d};
+
+  auto f0 = field("f0", int8());
+  auto f1 = field("f1", int16());
+  auto f2 = field("f2", int32());
+  auto f3 = field("f1", int64());
+  auto type = struct_({f0, f1, f2, f3});
+
+  auto arr = std::make_shared<StructArray>(type, 2, children);
+
+  ASSERT_OK(arr->CanReferenceFieldByName("f0"));
+  ASSERT_OK(arr->CanReferenceFieldByName("f2"));
+  // Not found
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldByName("nope"));
+
+  // Duplicates
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldByName("f1"));
+}
+
+TEST(StructArray, CanReferenceFieldsByNames) {
+  auto a = ArrayFromJSON(int8(), "[4, 5]");
+  auto b = ArrayFromJSON(int16(), "[6, 7]");
+  auto c = ArrayFromJSON(int32(), "[8, 9]");
+  auto d = ArrayFromJSON(int64(), "[10, 11]");
+  auto children = std::vector<std::shared_ptr<Array>>{a, b, c, d};
+
+  auto f0 = field("f0", int8());
+  auto f1 = field("f1", int16());
+  auto f2 = field("f2", int32());
+  auto f3 = field("f1", int64());
+  auto type = struct_({f0, f1, f2, f3});
+
+  auto arr = std::make_shared<StructArray>(type, 2, children);
+
+  ASSERT_OK(arr->CanReferenceFieldsByNames({"f0", "f2"}));
+  ASSERT_OK(arr->CanReferenceFieldsByNames({"f2", "f0"}));
+
+  // Not found
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldsByNames({"nope"}));
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldsByNames({"f0", "nope"}));
+  // Duplicates
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldsByNames({"f1"}));
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldsByNames({"f0", "f1"}));
+  // Both
+  ASSERT_RAISES(Invalid, arr->CanReferenceFieldsByNames({"f0", "f1", "nope"}));
+}
+
 // ----------------------------------------------------------------------------------
 // Struct test
 class TestStructBuilder : public ::testing::Test {
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 3d294a3fa8642..47bf52660ffe9 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -1847,14 +1847,18 @@ std::vector<int> Schema::GetAllFieldIndices(const std::string& name) const {
   return result;
 }
 
+Status Schema::CanReferenceFieldByName(const std::string& name) const {
+  if (GetFieldByName(name) == nullptr) {
+    return Status::Invalid("Field named '", name,
+                           "' not found or not unique in the schema.");
+  }
+  return Status::OK();
+}
+
 Status Schema::CanReferenceFieldsByNames(const std::vector<std::string>& names) const {
   for (const auto& name : names) {
-    if (GetFieldByName(name) == nullptr) {
-      return Status::Invalid("Field named '", name,
-                             "' not found or not unique in the schema.");
-    }
+    ARROW_RETURN_NOT_OK(CanReferenceFieldByName(name));
   }
-
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 718540d449226..19910979287cc 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -2048,6 +2048,9 @@ class ARROW_EXPORT Schema : public detail::Fingerprintable,
   /// Return the indices of all fields having this name
   std::vector<int> GetAllFieldIndices(const std::string& name) const;
 
+  /// Indicate if field named `name` can be found unambiguously in the schema.
+  Status CanReferenceFieldByName(const std::string& name) const;
+
   /// Indicate if fields named `names` can be found unambiguously in the schema.
   Status CanReferenceFieldsByNames(const std::vector<std::string>& names) const;
 
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index c55b33b4151e4..3dbefdcf0c564 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -548,6 +548,24 @@ TEST_F(TestSchema, GetFieldDuplicates) {
   ASSERT_EQ(results.size(), 0);
 }
 
+TEST_F(TestSchema, CanReferenceFieldByName) {
+  auto f0 = field("f0", int32());
+  auto f1 = field("f1", uint8(), false);
+  auto f2 = field("f2", utf8());
+  auto f3 = field("f1", list(int16()));
+
+  auto schema = ::arrow::schema({f0, f1, f2, f3});
+
+  ASSERT_OK(schema->CanReferenceFieldByName("f0"));
+  ASSERT_OK(schema->CanReferenceFieldByName("f2"));
+
+  // Not found
+  ASSERT_RAISES(Invalid, schema->CanReferenceFieldByName("nope"));
+
+  // Duplicates
+  ASSERT_RAISES(Invalid, schema->CanReferenceFieldByName("f1"));
+}
+
 TEST_F(TestSchema, CanReferenceFieldsByNames) {
   auto f0 = field("f0", int32());
   auto f1 = field("f1", uint8(), false);

From ebc23687cb0376e24a0f002fe710db5ad891c674 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 26 Sep 2023 05:57:30 +0900
Subject: [PATCH 409/749] GH-37849: [C++] Add cpp/src/**/*.cmake to
 cmake-format targets (#37850)

### Rationale for this change

In general, all our `.cmake` files should be `cmake-format` targets.

### What changes are included in this PR?

Add missing patterns for `cpp/src/**/*.cmake`.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #37849

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/arrow-config.cmake  | 9 ++++-----
 dev/archery/archery/utils/lint.py | 1 +
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/arrow-config.cmake b/cpp/src/arrow/arrow-config.cmake
index 8c9173c1710cb..c18c9eff37279 100644
--- a/cpp/src/arrow/arrow-config.cmake
+++ b/cpp/src/arrow/arrow-config.cmake
@@ -19,8 +19,7 @@ message(WARNING "find_package(arrow) is deprecated. Use find_package(Arrow) inst
 find_package(Arrow CONFIG)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(arrow
-                                  REQUIRED_VARS
-                                  ARROW_INCLUDE_DIR
-                                  VERSION_VAR
-                                  ARROW_VERSION)
+find_package_handle_standard_args(
+  arrow
+  REQUIRED_VARS ARROW_INCLUDE_DIR
+  VERSION_VAR ARROW_VERSION)
diff --git a/dev/archery/archery/utils/lint.py b/dev/archery/archery/utils/lint.py
index 18c93a5b8b71b..3efe5994055db 100644
--- a/dev/archery/archery/utils/lint.py
+++ b/dev/archery/archery/utils/lint.py
@@ -149,6 +149,7 @@ def cmake_linter(src, fix=False):
         include_patterns=[
             'ci/**/*.cmake',
             'cpp/CMakeLists.txt',
+            'cpp/src/**/*.cmake',
             'cpp/src/**/*.cmake.in',
             'cpp/src/**/CMakeLists.txt',
             'cpp/examples/**/CMakeLists.txt',

From cc51e68c5b3f9372b6410f9496b9cb53437201e5 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 26 Sep 2023 09:14:02 +0200
Subject: [PATCH 410/749] GH-37789: [Integration][Go] Go C Data Interface
 integration testing (#37788)

### Rationale for this change

We want to enable integration testing of the Arrow Go implementation of the C Data Interface, so as to ensure interoperability.

### What changes are included in this PR?

1. Enable C Data Interface integration testing for the Arrow Go implementation
2. Fix compatibility issues found by the integration tests

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

Bugfixes in the Arrow Go C Data Interface implementation.

* Closes: #37789

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .github/workflows/go.yml                      |   2 +-
 ci/scripts/go_build.sh                        |  19 ++
 dev/archery/archery/integration/runner.py     |   7 +-
 dev/archery/archery/integration/tester_go.py  | 134 +++++++++++-
 docker-compose.yml                            |   1 +
 go/arrow/cdata/cdata.go                       |   2 +-
 go/arrow/cdata/cdata_exports.go               |  38 ++--
 go/arrow/cdata/cdata_test.go                  |  12 +-
 go/arrow/internal/arrjson/reader.go           |  10 +
 .../internal/cdata_integration/entrypoints.go | 192 ++++++++++++++++++
 10 files changed, 391 insertions(+), 26 deletions(-)
 create mode 100644 go/arrow/internal/cdata_integration/entrypoints.go

diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 3c695891b48d6..ad8fedb9bd9e4 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -232,7 +232,7 @@ jobs:
     name: AMD64 Windows 2019 Go ${{ matrix.go }}
     runs-on: windows-2019
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
-    timeout-minutes: 15
+    timeout-minutes: 25
     strategy:
       fail-fast: false
       matrix:
diff --git a/ci/scripts/go_build.sh b/ci/scripts/go_build.sh
index 3c8cc0f4ee2e2..2a38901337c56 100755
--- a/ci/scripts/go_build.sh
+++ b/ci/scripts/go_build.sh
@@ -41,3 +41,22 @@ pushd ${source_dir}/parquet
 go install -v ./...
 
 popd
+
+if [[ -n "${ARROW_GO_INTEGRATION}" ]]; then
+    pushd ${source_dir}/arrow/internal/cdata_integration
+
+    case "$(uname)" in
+        Linux)
+            go_lib="arrow_go_integration.so"
+            ;;
+        Darwin)
+            go_lib="arrow_go_integration.so"
+            ;;
+        MINGW*)
+            go_lib="arrow_go_integration.dll"
+            ;;
+    esac
+    go build -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
+
+    popd
+fi
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index 2fd1d2d7f0c44..a780d33cbf323 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -70,6 +70,7 @@ def __init__(self, json_files,
         self.serial = serial
         self.gold_dirs = gold_dirs
         self.failures: List[Outcome] = []
+        self.skips: List[Outcome] = []
         self.match = match
 
         if self.match is not None:
@@ -207,6 +208,8 @@ def case_wrapper(test_case):
                     self.failures.append(outcome.failure)
                     if self.stop_on_error:
                         break
+                elif outcome.skipped:
+                    self.skips.append(outcome)
 
         else:
             with ThreadPoolExecutor() as executor:
@@ -215,6 +218,8 @@ def case_wrapper(test_case):
                         self.failures.append(outcome.failure)
                         if self.stop_on_error:
                             break
+                    elif outcome.skipped:
+                        self.skips.append(outcome)
 
     def _compare_ipc_implementations(
         self,
@@ -638,7 +643,7 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
                 log(f'{exc_type}: {exc_value}')
             log()
 
-    log(fail_count, "failures")
+    log(f"{fail_count} failures, {len(runner.skips)} skips")
     if fail_count > 0:
         sys.exit(1)
 
diff --git a/dev/archery/archery/integration/tester_go.py b/dev/archery/archery/integration/tester_go.py
index fea33cd0ac6c1..6fa26ea02b8e7 100644
--- a/dev/archery/archery/integration/tester_go.py
+++ b/dev/archery/archery/integration/tester_go.py
@@ -16,11 +16,14 @@
 # under the License.
 
 import contextlib
+import functools
 import os
 import subprocess
 
-from .tester import Tester
+from . import cdata
+from .tester import Tester, CDataExporter, CDataImporter
 from .util import run_cmd, log
+from ..utils.source import ARROW_ROOT_DEFAULT
 
 
 # FIXME(sbinet): revisit for Go modules
@@ -39,12 +42,21 @@
     "localhost",
 ]
 
+_dll_suffix = ".dll" if os.name == "nt" else ".so"
+
+_DLL_PATH = os.path.join(
+    ARROW_ROOT_DEFAULT,
+    "go/arrow/internal/cdata_integration")
+_INTEGRATION_DLL = os.path.join(_DLL_PATH, "arrow_go_integration" + _dll_suffix)
+
 
 class GoTester(Tester):
     PRODUCER = True
     CONSUMER = True
     FLIGHT_SERVER = True
     FLIGHT_CLIENT = True
+    C_DATA_EXPORTER = True
+    C_DATA_IMPORTER = True
 
     name = 'Go'
 
@@ -119,3 +131,123 @@ def flight_request(self, port, json_path=None, scenario_name=None):
         if self.debug:
             log(' '.join(cmd))
         run_cmd(cmd)
+
+    def make_c_data_exporter(self):
+        return GoCDataExporter(self.debug, self.args)
+
+    def make_c_data_importer(self):
+        return GoCDataImporter(self.debug, self.args)
+
+
+_go_c_data_entrypoints = """
+    const char* ArrowGo_ExportSchemaFromJson(const char* json_path,
+                                             uintptr_t out);
+    const char* ArrowGo_ImportSchemaAndCompareToJson(
+        const char* json_path, uintptr_t c_schema);
+
+    const char* ArrowGo_ExportBatchFromJson(const char* json_path,
+                                            int num_batch,
+                                            uintptr_t out);
+    const char* ArrowGo_ImportBatchAndCompareToJson(
+        const char* json_path, int num_batch, uintptr_t c_array);
+
+    int64_t ArrowGo_BytesAllocated();
+    void ArrowGo_RunGC();
+    void ArrowGo_FreeError(const char*);
+    """
+
+
+@functools.lru_cache
+def _load_ffi(ffi, lib_path=_INTEGRATION_DLL):
+    ffi.cdef(_go_c_data_entrypoints)
+    dll = ffi.dlopen(lib_path)
+    return dll
+
+
+class _CDataBase:
+
+    def __init__(self, debug, args):
+        self.debug = debug
+        self.args = args
+        self.ffi = cdata.ffi()
+        self.dll = _load_ffi(self.ffi)
+
+    def _pointer_to_int(self, c_ptr):
+        return self.ffi.cast('uintptr_t', c_ptr)
+
+    def _check_go_error(self, go_error):
+        """
+        Check a `const char*` error return from an integration entrypoint.
+
+        A null means success, a non-empty string is an error message.
+        The string is dynamically allocated on the Go side.
+        """
+        assert self.ffi.typeof(go_error) is self.ffi.typeof("const char*")
+        if go_error != self.ffi.NULL:
+            try:
+                error = self.ffi.string(go_error).decode('utf8',
+                                                         errors='replace')
+                raise RuntimeError(
+                    f"Go C Data Integration call failed: {error}")
+            finally:
+                self.dll.ArrowGo_FreeError(go_error)
+
+    def _run_gc(self):
+        self.dll.ArrowGo_RunGC()
+
+
+class GoCDataExporter(CDataExporter, _CDataBase):
+    # Note: the Arrow Go C Data export functions expect their output
+    # ArrowStream or ArrowArray argument to be zero-initialized.
+    # This is currently ensured through the use of `ffi.new`.
+
+    def export_schema_from_json(self, json_path, c_schema_ptr):
+        go_error = self.dll.ArrowGo_ExportSchemaFromJson(
+            str(json_path).encode(), self._pointer_to_int(c_schema_ptr))
+        self._check_go_error(go_error)
+
+    def export_batch_from_json(self, json_path, num_batch, c_array_ptr):
+        go_error = self.dll.ArrowGo_ExportBatchFromJson(
+            str(json_path).encode(), num_batch,
+            self._pointer_to_int(c_array_ptr))
+        self._check_go_error(go_error)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def record_allocation_state(self):
+        self._run_gc()
+        return self.dll.ArrowGo_BytesAllocated()
+
+    def compare_allocation_state(self, recorded, gc_until):
+        def pred():
+            return self.record_allocation_state() == recorded
+
+        return gc_until(pred)
+
+
+class GoCDataImporter(CDataImporter, _CDataBase):
+
+    def import_schema_and_compare_to_json(self, json_path, c_schema_ptr):
+        go_error = self.dll.ArrowGo_ImportSchemaAndCompareToJson(
+            str(json_path).encode(), self._pointer_to_int(c_schema_ptr))
+        self._check_go_error(go_error)
+
+    def import_batch_and_compare_to_json(self, json_path, num_batch,
+                                         c_array_ptr):
+        go_error = self.dll.ArrowGo_ImportBatchAndCompareToJson(
+            str(json_path).encode(), num_batch,
+            self._pointer_to_int(c_array_ptr))
+        self._check_go_error(go_error)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def gc_until(self, predicate):
+        for i in range(10):
+            if predicate():
+                return True
+            self._run_gc()
+        return False
diff --git a/docker-compose.yml b/docker-compose.yml
index 8ae06900c57f9..62e5aee0a841c 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1732,6 +1732,7 @@ services:
       <<: [*common, *ccache]
       # tell archery where the arrow binaries are located
       ARROW_CPP_EXE_PATH: /build/cpp/debug
+      ARROW_GO_INTEGRATION: 1
       ARCHERY_INTEGRATION_WITH_RUST: 0
     command:
       ["/arrow/ci/scripts/rust_build.sh /arrow /build &&
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index bc8fc6e987b93..dc8825a7edb67 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -197,7 +197,7 @@ func importSchema(schema *CArrowSchema) (ret arrow.Field, err error) {
 
 	// handle types with params via colon
 	typs := strings.Split(f, ":")
-	defaulttz := "UTC"
+	defaulttz := ""
 	switch typs[0] {
 	case "tss":
 		tz := typs[1]
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index ae6247494b100..187c2deb9755f 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -368,34 +368,36 @@ func exportArray(arr arrow.Array, out *CArrowArray, outSchema *CArrowSchema) {
 		exportField(arrow.Field{Type: arr.DataType()}, outSchema)
 	}
 
+	nbuffers := len(arr.Data().Buffers())
+	buf_offset := 0
+	// Some types don't have validity bitmaps, but we keep them shifted
+	// to make processing easier in other contexts. This means that
+	// we have to adjust when exporting.
+	has_validity_bitmap := internal.DefaultHasValidityBitmap(arr.DataType().ID())
+	if nbuffers > 0 && !has_validity_bitmap {
+		nbuffers--
+		buf_offset++
+	}
+
 	out.dictionary = nil
 	out.null_count = C.int64_t(arr.NullN())
 	out.length = C.int64_t(arr.Len())
 	out.offset = C.int64_t(arr.Data().Offset())
-	out.n_buffers = C.int64_t(len(arr.Data().Buffers()))
-
-	if out.n_buffers > 0 {
-		var (
-			nbuffers = len(arr.Data().Buffers())
-			bufs     = arr.Data().Buffers()
-		)
-		// unions don't have validity bitmaps, but we keep them shifted
-		// to make processing easier in other contexts. This means that
-		// we have to adjust for union arrays
-		if !internal.DefaultHasValidityBitmap(arr.DataType().ID()) {
-			out.n_buffers--
-			nbuffers--
-			bufs = bufs[1:]
-		}
+	out.n_buffers = C.int64_t(nbuffers)
+	out.buffers = nil
+
+	if nbuffers > 0 {
+		bufs := arr.Data().Buffers()
 		buffers := allocateBufferPtrArr(nbuffers)
-		for i := range bufs {
-			buf := bufs[i]
+		for i, buf := range bufs[buf_offset:] {
 			if buf == nil || buf.Len() == 0 {
-				if i > 0 || !internal.DefaultHasValidityBitmap(arr.DataType().ID()) {
+				if i > 0 || !has_validity_bitmap {
 					// apache/arrow#33936: export a dummy buffer to be friendly to
 					// implementations that don't import NULL properly
 					buffers[i] = (*C.void)(unsafe.Pointer(&C.kGoCdataZeroRegion))
 				} else {
+					// null pointer permitted for the validity bitmap
+					// (assuming null count is 0)
 					buffers[i] = nil
 				}
 				continue
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index a0c2f25496a6b..af05649b1c541 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -184,13 +184,17 @@ func TestImportTemporalSchema(t *testing.T) {
 		{arrow.FixedWidthTypes.MonthInterval, "tiM"},
 		{arrow.FixedWidthTypes.DayTimeInterval, "tiD"},
 		{arrow.FixedWidthTypes.MonthDayNanoInterval, "tin"},
-		{arrow.FixedWidthTypes.Timestamp_s, "tss:"},
+		{arrow.FixedWidthTypes.Timestamp_s, "tss:UTC"},
+		{&arrow.TimestampType{Unit: arrow.Second}, "tss:"},
 		{&arrow.TimestampType{Unit: arrow.Second, TimeZone: "Europe/Paris"}, "tss:Europe/Paris"},
-		{arrow.FixedWidthTypes.Timestamp_ms, "tsm:"},
+		{arrow.FixedWidthTypes.Timestamp_ms, "tsm:UTC"},
+		{&arrow.TimestampType{Unit: arrow.Millisecond}, "tsm:"},
 		{&arrow.TimestampType{Unit: arrow.Millisecond, TimeZone: "Europe/Paris"}, "tsm:Europe/Paris"},
-		{arrow.FixedWidthTypes.Timestamp_us, "tsu:"},
+		{arrow.FixedWidthTypes.Timestamp_us, "tsu:UTC"},
+		{&arrow.TimestampType{Unit: arrow.Microsecond}, "tsu:"},
 		{&arrow.TimestampType{Unit: arrow.Microsecond, TimeZone: "Europe/Paris"}, "tsu:Europe/Paris"},
-		{arrow.FixedWidthTypes.Timestamp_ns, "tsn:"},
+		{arrow.FixedWidthTypes.Timestamp_ns, "tsn:UTC"},
+		{&arrow.TimestampType{Unit: arrow.Nanosecond}, "tsn:"},
 		{&arrow.TimestampType{Unit: arrow.Nanosecond, TimeZone: "Europe/Paris"}, "tsn:Europe/Paris"},
 	}
 
diff --git a/go/arrow/internal/arrjson/reader.go b/go/arrow/internal/arrjson/reader.go
index 34b9b6e10ec4a..c8056ef1dc744 100644
--- a/go/arrow/internal/arrjson/reader.go
+++ b/go/arrow/internal/arrjson/reader.go
@@ -82,6 +82,8 @@ func (r *Reader) Release() {
 				r.recs[i] = nil
 			}
 		}
+		r.memo.Clear()
+		r.memo = nil
 	}
 }
 func (r *Reader) Schema() *arrow.Schema { return r.schema }
@@ -96,6 +98,14 @@ func (r *Reader) Read() (arrow.Record, error) {
 	return rec, nil
 }
 
+func (r *Reader) ReadAt(index int) (arrow.Record, error) {
+	if index >= r.NumRecords() {
+		return nil, io.EOF
+	}
+	rec := r.recs[index]
+	return rec, nil
+}
+
 var (
 	_ arrio.Reader = (*Reader)(nil)
 )
diff --git a/go/arrow/internal/cdata_integration/entrypoints.go b/go/arrow/internal/cdata_integration/entrypoints.go
new file mode 100644
index 0000000000000..629b8a762a689
--- /dev/null
+++ b/go/arrow/internal/cdata_integration/entrypoints.go
@@ -0,0 +1,192 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build cdata_integration
+// +build cdata_integration
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/cdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+)
+
+// #include <stdint.h>
+// #include <stdlib.h>
+import "C"
+
+var alloc = memory.NewCheckedAllocator(memory.NewGoAllocator())
+
+//export ArrowGo_BytesAllocated
+func ArrowGo_BytesAllocated() int64 {
+	return int64(alloc.CurrentAlloc())
+}
+
+//export ArrowGo_RunGC
+func ArrowGo_RunGC() {
+	runtime.GC()
+}
+
+//export ArrowGo_FreeError
+func ArrowGo_FreeError(cError *C.char) {
+	C.free(unsafe.Pointer(cError))
+}
+
+// When used in a defer() statement, this functions catches an incoming
+// panic and converts it into a regular error. This avoids crashing the
+// archery integration process and lets other tests proceed.
+// Not all panics may be caught and some will still crash the process, though.
+func handlePanic(err *error) {
+	if e := recover(); e != nil {
+		// Add a prefix while wrapping the panic-error
+		*err = fmt.Errorf("panic: %w", e.(error))
+	}
+}
+
+func newJsonReader(cJsonPath *C.char) (*arrjson.Reader, error) {
+	jsonPath := C.GoString(cJsonPath)
+
+	f, err := os.Open(jsonPath)
+	if err != nil {
+		return nil, fmt.Errorf("could not open JSON file %q: %w", jsonPath, err)
+	}
+	defer f.Close()
+
+	jsonReader, err := arrjson.NewReader(f, arrjson.WithAllocator(alloc))
+	if err != nil {
+		return nil, fmt.Errorf("could not open JSON file reader from file %q: %w", jsonPath, err)
+	}
+	return jsonReader, nil
+}
+
+func exportSchemaFromJson(cJsonPath *C.char, out *cdata.CArrowSchema) error {
+	jsonReader, err := newJsonReader(cJsonPath)
+	if err != nil {
+		return err
+	}
+	defer jsonReader.Release()
+	schema := jsonReader.Schema()
+	defer handlePanic(&err)
+	cdata.ExportArrowSchema(schema, out)
+	return err
+}
+
+func importSchemaAndCompareToJson(cJsonPath *C.char, cSchema *cdata.CArrowSchema) error {
+	jsonReader, err := newJsonReader(cJsonPath)
+	if err != nil {
+		return err
+	}
+	defer jsonReader.Release()
+	schema := jsonReader.Schema()
+	importedSchema, err := cdata.ImportCArrowSchema(cSchema)
+	if err != nil {
+		return err
+	}
+	if !schema.Equal(importedSchema) || !schema.Metadata().Equal(importedSchema.Metadata()) {
+		return fmt.Errorf(
+			"Schemas are different:\n- Json Schema: %s\n- Imported Schema: %s",
+			schema.String(),
+			importedSchema.String())
+	}
+	return nil
+}
+
+func exportBatchFromJson(cJsonPath *C.char, num_batch int, out *cdata.CArrowArray) error {
+	// XXX this function exports a single batch at a time, but the JSON reader
+	// reads all batches at construction.
+	jsonReader, err := newJsonReader(cJsonPath)
+	if err != nil {
+		return err
+	}
+	defer jsonReader.Release()
+	batch, err := jsonReader.ReadAt(num_batch)
+	if err != nil {
+		return err
+	}
+	defer handlePanic(&err)
+	cdata.ExportArrowRecordBatch(batch, out, nil)
+	return err
+}
+
+func importBatchAndCompareToJson(cJsonPath *C.char, num_batch int, cArray *cdata.CArrowArray) error {
+	jsonReader, err := newJsonReader(cJsonPath)
+	if err != nil {
+		return err
+	}
+	defer jsonReader.Release()
+	schema := jsonReader.Schema()
+	batch, err := jsonReader.ReadAt(num_batch)
+	if err != nil {
+		return err
+	}
+
+	importedBatch, err := cdata.ImportCRecordBatchWithSchema(cArray, schema)
+	if err != nil {
+		return err
+	}
+	defer importedBatch.Release()
+	if !array.RecordEqual(batch, importedBatch) {
+		return fmt.Errorf(
+			"Batches are different:\n- Json Batch: %v\n- Imported Batch: %v",
+			batch, importedBatch)
+	}
+	return nil
+}
+
+//export ArrowGo_ExportSchemaFromJson
+func ArrowGo_ExportSchemaFromJson(cJsonPath *C.char, out uintptr) *C.char {
+	err := exportSchemaFromJson(cJsonPath, cdata.SchemaFromPtr(out))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return nil
+}
+
+//export ArrowGo_ExportBatchFromJson
+func ArrowGo_ExportBatchFromJson(cJsonPath *C.char, num_batch int, out uintptr) *C.char {
+	err := exportBatchFromJson(cJsonPath, num_batch, cdata.ArrayFromPtr(out))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return nil
+}
+
+//export ArrowGo_ImportSchemaAndCompareToJson
+func ArrowGo_ImportSchemaAndCompareToJson(cJsonPath *C.char, cSchema uintptr) *C.char {
+	err := importSchemaAndCompareToJson(cJsonPath, cdata.SchemaFromPtr(cSchema))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return nil
+}
+
+//export ArrowGo_ImportBatchAndCompareToJson
+func ArrowGo_ImportBatchAndCompareToJson(cJsonPath *C.char, num_batch int, cArray uintptr) *C.char {
+	err := importBatchAndCompareToJson(cJsonPath, num_batch, cdata.ArrayFromPtr(cArray))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return nil
+}
+
+func main() {}

From 38922eded5797afca8ade33145bf59140ada1663 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 26 Sep 2023 05:44:53 -0700
Subject: [PATCH 411/749] GH-37703: [Java] Method for setting exact number of
 records in ListVector (#37838)

### Rationale for this change
There is currently a setInitialCapacity() function that can be used to set a number of records and density factor when setting the capacity on a ListVector. A developer may want to specify the exact total number of records instead and can use the new methods introduced here.

### What changes are included in this PR?

Add setInitialTotalCapacity() to BaseRepeatedVector, ListVector, DensityAwareVector, and LargeListVector to specify the exact total number of records in the backing vector.

This is an alternative to using the density argument in setInitialCapacity() that allows the caller to precisely specify the capacity.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.

* Closes: #37703

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../complex/BaseRepeatedValueVector.java      | 21 ++++++++++++++++++
 .../arrow/vector/complex/LargeListVector.java | 21 ++++++++++++++++++
 .../arrow/vector/complex/ListVector.java      | 22 +++++++++++++++++++
 .../arrow/vector/TestLargeListVector.java     | 20 +++++++++++++++++
 .../apache/arrow/vector/TestListVector.java   | 20 +++++++++++++++++
 5 files changed, 104 insertions(+)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/BaseRepeatedValueVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/BaseRepeatedValueVector.java
index 62d4a1299dead..95deceb4e75ca 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/BaseRepeatedValueVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/BaseRepeatedValueVector.java
@@ -205,6 +205,27 @@ public void setInitialCapacity(int numRecords, double density) {
     }
   }
 
+  /**
+   * Specialized version of setInitialTotalCapacity() for ListVector. This is
+   * used by some callers when they want to explicitly control and be
+   * conservative about memory allocated for inner data vector. This is
+   * very useful when we are working with memory constraints for a query
+   * and have a fixed amount of memory reserved for the record batch. In
+   * such cases, we are likely to face OOM or related problems when
+   * we reserve memory for a record batch with value count x and
+   * do setInitialCapacity(x) such that each vector allocates only
+   * what is necessary and not the default amount but the multiplier
+   * forces the memory requirement to go beyond what was needed.
+   *
+   * @param numRecords value count
+   * @param totalNumberOfElements the total number of elements to to allow
+   *                              for in this vector across all records.
+   */
+  public void setInitialTotalCapacity(int numRecords, int totalNumberOfElements) {
+    offsetAllocationSizeInBytes = (numRecords + 1) * OFFSET_WIDTH;
+    vector.setInitialCapacity(totalNumberOfElements);
+  }
+
   @Override
   public int getValueCapacity() {
     final int offsetValueCapacity = Math.max(getOffsetBufferValueCapacity() - 1, 0);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
index 6ef5f994fc6f4..acb058cda3cb8 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
@@ -196,6 +196,27 @@ public void setInitialCapacity(int numRecords, double density) {
     }
   }
 
+  /**
+   * Specialized version of setInitialTotalCapacity() for ListVector. This is
+   * used by some callers when they want to explicitly control and be
+   * conservative about memory allocated for inner data vector. This is
+   * very useful when we are working with memory constraints for a query
+   * and have a fixed amount of memory reserved for the record batch. In
+   * such cases, we are likely to face OOM or related problems when
+   * we reserve memory for a record batch with value count x and
+   * do setInitialCapacity(x) such that each vector allocates only
+   * what is necessary and not the default amount but the multiplier
+   * forces the memory requirement to go beyond what was needed.
+   *
+   * @param numRecords value count
+   * @param totalNumberOfElements the total number of elements to to allow
+   *                              for in this vector across all records.
+   */
+  public void setInitialTotalCapacity(int numRecords, int totalNumberOfElements) {
+    offsetAllocationSizeInBytes = (numRecords + 1) * OFFSET_WIDTH;
+    vector.setInitialCapacity(totalNumberOfElements);
+  }
+
   /**
    * Get the density of this ListVector.
    * @return density
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
index 52e5307e13908..0d6ff11f8ccf3 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
@@ -148,6 +148,28 @@ public void setInitialCapacity(int numRecords, double density) {
     super.setInitialCapacity(numRecords, density);
   }
 
+  /**
+   * Specialized version of setInitialTotalCapacity() for ListVector. This is
+   * used by some callers when they want to explicitly control and be
+   * conservative about memory allocated for inner data vector. This is
+   * very useful when we are working with memory constraints for a query
+   * and have a fixed amount of memory reserved for the record batch. In
+   * such cases, we are likely to face OOM or related problems when
+   * we reserve memory for a record batch with value count x and
+   * do setInitialCapacity(x) such that each vector allocates only
+   * what is necessary and not the default amount but the multiplier
+   * forces the memory requirement to go beyond what was needed.
+   *
+   * @param numRecords value count
+   * @param totalNumberOfElements the total number of elements to to allow
+   *                              for in this vector across all records.
+   */
+  @Override
+  public void setInitialTotalCapacity(int numRecords, int totalNumberOfElements) {
+    validityAllocationSizeInBytes = getValidityBufferSizeFromCount(numRecords);
+    super.setInitialTotalCapacity(numRecords, totalNumberOfElements);
+  }
+
   /**
    * Get the density of this ListVector.
    * @return density
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
index c1d60da4d5988..adf86183c0ada 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
@@ -972,6 +972,26 @@ public void testIsEmpty() {
     }
   }
 
+  @Test
+  public void testTotalCapacity() {
+    final FieldType type = FieldType.nullable(MinorType.INT.getType());
+    try (final LargeListVector vector = new LargeListVector("list", allocator, type, null)) {
+      // Force the child vector to be allocated based on the type
+      // (this is a bad API: we have to track and repeat the type twice)
+      vector.addOrGetVector(type);
+
+      // Specify the allocation size but do not actually allocate
+      vector.setInitialTotalCapacity(10, 100);
+
+      // Finally actually do the allocation
+      vector.allocateNewSafe();
+
+      // Note: allocator rounds up and can be greater than the requested allocation.
+      assertTrue(vector.getValueCapacity() >= 10);
+      assertTrue(vector.getDataVector().getValueCapacity() >= 100);
+    }
+  }
+
   private void writeIntValues(UnionLargeListWriter writer, int[] values) {
     writer.startList();
     for (int v: values) {
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
index f0f19058eef20..2a1228c2a38c2 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
@@ -1115,6 +1115,26 @@ public void testIsEmpty() {
     }
   }
 
+  @Test
+  public void testTotalCapacity() {
+    final FieldType type = FieldType.nullable(MinorType.INT.getType());
+    try (final ListVector vector = new ListVector("list", allocator, type, null)) {
+      // Force the child vector to be allocated based on the type
+      // (this is a bad API: we have to track and repeat the type twice)
+      vector.addOrGetVector(type);
+
+      // Specify the allocation size but do not actually allocate
+      vector.setInitialTotalCapacity(10, 100);
+
+      // Finally actually do the allocation
+      vector.allocateNewSafe();
+
+      // Note: allocator rounds up and can be greater than the requested allocation.
+      assertTrue(vector.getValueCapacity() >= 10);
+      assertTrue(vector.getDataVector().getValueCapacity() >= 100);
+    }
+  }
+
   private void writeIntValues(UnionListWriter writer, int[] values) {
     writer.startList();
     for (int v: values) {

From 5978729277e164c5b4dfd8916bb410b9e67a04c7 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Tue, 26 Sep 2023 22:23:19 +0800
Subject: [PATCH 412/749] GH-37293: [C++][Parquet] Encoding: Add Benchmark for
 DELTA_BYTE_ARRAY (#37641)

### Rationale for this change

Add benchmark for DELTA_BYTE_ARRAY in parquet, and do tiny optimization.

### What changes are included in this PR?

Add benchmark for DELTA_BYTE_ARRAY in parquet, and do tiny optimization.

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #37293

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc           |   8 +-
 cpp/src/parquet/encoding_benchmark.cc | 108 ++++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 2 deletions(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index e3c8ab196f45e..0564ea2b93f3f 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -3300,7 +3300,11 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecode
 
   void SetData(int num_values, const uint8_t* data, int len) override {
     num_values_ = num_values;
-    decoder_ = std::make_shared<::arrow::bit_util::BitReader>(data, len);
+    if (decoder_) {
+      decoder_->Reset(data, len);
+    } else {
+      decoder_ = std::make_shared<::arrow::bit_util::BitReader>(data, len);
+    }
     prefix_len_decoder_.SetDecoder(num_values, decoder_);
 
     // get the number of encoded prefix lengths
@@ -3323,7 +3327,7 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecode
 
     // TODO: read corrupted files written with bug(PARQUET-246). last_value_ should be set
     // to last_value_in_previous_page_ when decoding a new page(except the first page)
-    last_value_ = "";
+    last_value_.clear();
   }
 
   int DecodeArrow(int num_values, int null_count, const uint8_t* valid_bits,
diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc
index 6726810911fd5..717c716330563 100644
--- a/cpp/src/parquet/encoding_benchmark.cc
+++ b/cpp/src/parquet/encoding_benchmark.cc
@@ -737,6 +737,114 @@ static void BM_DeltaLengthDecodingSpacedByteArray(benchmark::State& state) {
 BENCHMARK(BM_PlainDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments);
 BENCHMARK(BM_DeltaLengthDecodingSpacedByteArray)->Apply(ByteArrayCustomArguments);
 
+struct DeltaByteArrayState {
+  int32_t min_size = 0;
+  int32_t max_size;
+  int32_t array_length;
+  int32_t total_data_size = 0;
+  double prefixed_probability;
+  std::vector<uint8_t> buf;
+
+  explicit DeltaByteArrayState(const benchmark::State& state)
+      : max_size(static_cast<int32_t>(state.range(0))),
+        array_length(static_cast<int32_t>(state.range(1))),
+        prefixed_probability(state.range(2) / 100.0) {}
+
+  std::vector<ByteArray> MakeRandomByteArray(uint32_t seed) {
+    std::default_random_engine gen(seed);
+    std::uniform_int_distribution<int> dist_size(min_size, max_size);
+    std::uniform_int_distribution<int> dist_byte(0, 255);
+    std::bernoulli_distribution dist_has_prefix(prefixed_probability);
+    std::uniform_real_distribution<double> dist_prefix_length(0, 1);
+
+    std::vector<ByteArray> out(array_length);
+    buf.resize(max_size * array_length);
+    auto buf_ptr = buf.data();
+    total_data_size = 0;
+
+    for (int32_t i = 0; i < array_length; ++i) {
+      int len = dist_size(gen);
+      out[i].len = len;
+      out[i].ptr = buf_ptr;
+
+      bool do_prefix = i > 0 && dist_has_prefix(gen);
+      int prefix_len = 0;
+      if (do_prefix) {
+        int max_prefix_len = std::min(len, static_cast<int>(out[i - 1].len));
+        prefix_len =
+            static_cast<int>(std::ceil(max_prefix_len * dist_prefix_length(gen)));
+      }
+      for (int j = 0; j < prefix_len; ++j) {
+        buf_ptr[j] = out[i - 1].ptr[j];
+      }
+      for (int j = prefix_len; j < len; ++j) {
+        buf_ptr[j] = static_cast<uint8_t>(dist_byte(gen));
+      }
+      buf_ptr += len;
+      total_data_size += len;
+    }
+    return out;
+  }
+};
+
+static void BM_DeltaEncodingByteArray(benchmark::State& state) {
+  DeltaByteArrayState delta_state(state);
+  std::vector<ByteArray> values = delta_state.MakeRandomByteArray(/*seed=*/42);
+
+  auto encoder = MakeTypedEncoder<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+  const int64_t plain_encoded_size =
+      delta_state.total_data_size + 4 * delta_state.array_length;
+  int64_t encoded_size = 0;
+
+  for (auto _ : state) {
+    encoder->Put(values.data(), static_cast<int>(values.size()));
+    encoded_size = encoder->FlushValues()->size();
+  }
+  state.SetItemsProcessed(state.iterations() * delta_state.array_length);
+  state.SetBytesProcessed(state.iterations() * delta_state.total_data_size);
+  state.counters["compression_ratio"] =
+      static_cast<double>(plain_encoded_size) / encoded_size;
+}
+
+static void BM_DeltaDecodingByteArray(benchmark::State& state) {
+  DeltaByteArrayState delta_state(state);
+  std::vector<ByteArray> values = delta_state.MakeRandomByteArray(/*seed=*/42);
+
+  auto encoder = MakeTypedEncoder<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+  encoder->Put(values.data(), static_cast<int>(values.size()));
+  std::shared_ptr<Buffer> buf = encoder->FlushValues();
+
+  const int64_t plain_encoded_size =
+      delta_state.total_data_size + 4 * delta_state.array_length;
+  const int64_t encoded_size = buf->size();
+
+  auto decoder = MakeTypedDecoder<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+  for (auto _ : state) {
+    decoder->SetData(delta_state.array_length, buf->data(),
+                     static_cast<int>(buf->size()));
+    decoder->Decode(values.data(), static_cast<int>(values.size()));
+    ::benchmark::DoNotOptimize(values);
+  }
+  state.SetItemsProcessed(state.iterations() * delta_state.array_length);
+  state.SetBytesProcessed(state.iterations() * delta_state.total_data_size);
+  state.counters["compression_ratio"] =
+      static_cast<double>(plain_encoded_size) / encoded_size;
+}
+
+static void ByteArrayDeltaCustomArguments(benchmark::internal::Benchmark* b) {
+  for (int max_string_length : {8, 64, 1024}) {
+    for (int batch_size : {512, 2048}) {
+      for (int prefixed_percent : {10, 90, 99}) {
+        b->Args({max_string_length, batch_size, prefixed_percent});
+      }
+    }
+  }
+  b->ArgNames({"max-string-length", "batch-size", "prefixed-percent"});
+}
+
+BENCHMARK(BM_DeltaEncodingByteArray)->Apply(ByteArrayDeltaCustomArguments);
+BENCHMARK(BM_DeltaDecodingByteArray)->Apply(ByteArrayDeltaCustomArguments);
+
 static void BM_RleEncodingBoolean(benchmark::State& state) {
   std::vector<bool> values(state.range(0), true);
   auto encoder = MakeEncoder(Type::BOOLEAN, Encoding::RLE);

From 2895af492236e5dc42ac665406de8648a9aac6db Mon Sep 17 00:00:00 2001
From: Tim Schaub <tschaub@users.noreply.github.com>
Date: Tue, 26 Sep 2023 09:01:36 -0600
Subject: [PATCH 413/749] GH-37845: [Go][Parquet] Check the number of logical
 fields instead of physical columns (#37846)

### Rationale for this change

This makes it so trying to read with a column chunk reader consistently returns an error if the index is outside the bounds of the logical fields (currently it panics in some cases and returns an error in others).

### What changes are included in this PR?

This makes it so the column chunk reader checks the number of logical fields instead of the number of physical columns when checking if an index is out of range.

### Are these changes tested?

The new test will panics without the accompanying code change.

### Are there any user-facing changes?

Applications that used to panic will now have an error to handle instead.

* Closes: #37845

Authored-by: Tim Schaub <tim@planet.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/pqarrow/file_reader.go      |  4 +-
 go/parquet/pqarrow/file_reader_test.go | 67 ++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/go/parquet/pqarrow/file_reader.go b/go/parquet/pqarrow/file_reader.go
index d54e365b55e0c..d91010c62c19d 100755
--- a/go/parquet/pqarrow/file_reader.go
+++ b/go/parquet/pqarrow/file_reader.go
@@ -394,8 +394,8 @@ func (fr *FileReader) ReadRowGroups(ctx context.Context, indices, rowGroups []in
 }
 
 func (fr *FileReader) getColumnReader(ctx context.Context, i int, colFactory itrFactory) (*ColumnReader, error) {
-	if i < 0 || i >= fr.rdr.MetaData().Schema.NumColumns() {
-		return nil, fmt.Errorf("invalid column index chosen %d, there are only %d columns", i, fr.rdr.MetaData().Schema.NumColumns())
+	if i < 0 || i >= len(fr.Manifest.Fields) {
+		return nil, fmt.Errorf("invalid column index chosen %d, there are only %d columns", i, len(fr.Manifest.Fields))
 	}
 
 	ctx = context.WithValue(ctx, rdrCtxKey{}, readerCtx{
diff --git a/go/parquet/pqarrow/file_reader_test.go b/go/parquet/pqarrow/file_reader_test.go
index 2b4aa8ab78dbe..d1f3ae1c984a2 100644
--- a/go/parquet/pqarrow/file_reader_test.go
+++ b/go/parquet/pqarrow/file_reader_test.go
@@ -19,9 +19,11 @@ package pqarrow_test
 import (
 	"bytes"
 	"context"
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 
 	"github.com/apache/arrow/go/v14/arrow"
@@ -216,3 +218,68 @@ func TestFileReaderWriterMetadata(t *testing.T) {
 	assert.Equal(t, []string{"foo", "bar"}, kvMeta.Keys())
 	assert.Equal(t, []string{"bar", "baz"}, kvMeta.Values())
 }
+
+func TestFileReaderColumnChunkBoundsErrors(t *testing.T) {
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "zero", Type: arrow.PrimitiveTypes.Float64},
+		{Name: "g", Type: arrow.StructOf(
+			arrow.Field{Name: "one", Type: arrow.PrimitiveTypes.Float64},
+			arrow.Field{Name: "two", Type: arrow.PrimitiveTypes.Float64},
+			arrow.Field{Name: "three", Type: arrow.PrimitiveTypes.Float64},
+		)},
+	}, nil)
+
+	// generate Parquet data with four columns
+	// that are represented by two logical fields
+	data := `[
+		{
+			"zero": 1,
+			"g": {
+				"one": 1,
+				"two": 1,
+				"three": 1
+			}
+		},
+		{
+			"zero": 2,
+			"g": {
+				"one": 2,
+				"two": 2,
+				"three": 2
+			}
+		}
+	]`
+
+	record, _, err := array.RecordFromJSON(memory.DefaultAllocator, schema, strings.NewReader(data))
+	require.NoError(t, err)
+
+	output := &bytes.Buffer{}
+	writer, err := pqarrow.NewFileWriter(schema, output, parquet.NewWriterProperties(), pqarrow.DefaultWriterProps())
+	require.NoError(t, err)
+
+	require.NoError(t, writer.Write(record))
+	require.NoError(t, writer.Close())
+
+	fileReader, err := file.NewParquetReader(bytes.NewReader(output.Bytes()))
+	require.NoError(t, err)
+
+	arrowReader, err := pqarrow.NewFileReader(fileReader, pqarrow.ArrowReadProperties{BatchSize: 1024}, memory.DefaultAllocator)
+	require.NoError(t, err)
+
+	// assert that errors are returned for indexes outside the bounds of the logical fields (instead of the physical columns)
+	ctx := pqarrow.NewArrowWriteContext(context.Background(), nil)
+	assert.Greater(t, fileReader.NumRowGroups(), 0)
+	for rowGroupIndex := 0; rowGroupIndex < fileReader.NumRowGroups(); rowGroupIndex += 1 {
+		rowGroupReader := arrowReader.RowGroup(rowGroupIndex)
+		for fieldNum := 0; fieldNum < schema.NumFields(); fieldNum += 1 {
+			_, err := rowGroupReader.Column(fieldNum).Read(ctx)
+			assert.NoError(t, err, "reading field num: %d", fieldNum)
+		}
+
+		_, subZeroErr := rowGroupReader.Column(-1).Read(ctx)
+		assert.Error(t, subZeroErr)
+
+		_, tooHighErr := rowGroupReader.Column(schema.NumFields()).Read(ctx)
+		assert.ErrorContains(t, tooHighErr, fmt.Sprintf("there are only %d columns", schema.NumFields()))
+	}
+}

From c07f5bceacd5efbdfd2ab3a673916d2ff46078c8 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 26 Sep 2023 12:18:52 -0700
Subject: [PATCH 414/749] GH-37705: [Java] Extra input methods for VarChar
 writers (#37883)

### Rationale for this change
Improve the convenience of using VarCharWriter and LargeVarCharWriter interfaces.
Also allow users to avoid unnecessary overhead creating Arrow buffers when writing
String and Text data.

### What changes are included in this PR?
Add write() methods for Text and String types.
Ensure these methods are part of the writer interfaces and not just the Impls.### Are these changes tested?

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #37705

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../templates/AbstractFieldWriter.java        | 10 +++
 .../codegen/templates/ComplexWriters.java     | 21 ++++-
 .../complex/writer/TestSimpleWriter.java      | 81 +++++++++++++++----
 3 files changed, 94 insertions(+), 18 deletions(-)

diff --git a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
index 5e6580b6131c1..bb4ee45eaa073 100644
--- a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
+++ b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
@@ -142,6 +142,16 @@ public void write(${name}Holder holder) {
   }
   </#if>
 
+  <#if minor.class?ends_with("VarChar")>
+  public void write${minor.class}(${friendlyType} value) {
+    fail("${name}");
+  }
+
+  public void write${minor.class}(String value) {
+    fail("${name}");
+  }
+  </#if>
+
   </#list></#list>
 
   public void writeNull() {
diff --git a/java/vector/src/main/codegen/templates/ComplexWriters.java b/java/vector/src/main/codegen/templates/ComplexWriters.java
index 4ae4c4f75f208..51a52a6e3070d 100644
--- a/java/vector/src/main/codegen/templates/ComplexWriters.java
+++ b/java/vector/src/main/codegen/templates/ComplexWriters.java
@@ -44,7 +44,11 @@ public class ${eName}WriterImpl extends AbstractFieldWriter {
 
   final ${name}Vector vector;
 
-  public ${eName}WriterImpl(${name}Vector vector) {
+<#if minor.class?ends_with("VarChar")>
+  private final Text textBuffer = new Text();
+</#if>
+
+public ${eName}WriterImpl(${name}Vector vector) {
     this.vector = vector;
   }
 
@@ -120,11 +124,19 @@ public void write(Nullable${minor.class}Holder h) {
   }
   </#if>
 
-  <#if minor.class == "VarChar">
+  <#if minor.class?ends_with("VarChar")>
+  @Override
   public void write${minor.class}(${friendlyType} value) {
     vector.setSafe(idx(), value);
     vector.setValueCount(idx()+1);
   }
+
+  @Override
+  public void write${minor.class}(String value) {
+    textBuffer.set(value);
+    vector.setSafe(idx(), textBuffer);
+    vector.setValueCount(idx()+1);
+  }
   </#if>
 
   <#if minor.class?starts_with("Decimal")>
@@ -256,6 +268,11 @@ public interface ${eName}Writer extends BaseWriter {
   public void writeTo${minor.class}(ByteBuffer value, int offset, int length);
 </#if>
 
+<#if minor.class?ends_with("VarChar")>
+  public void write${minor.class}(${friendlyType} value);
+
+  public void write${minor.class}(String value);
+</#if>
 }
 
 </#list>
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
index 7c06509b23c87..ef918b13fb691 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
@@ -22,9 +22,14 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.LargeVarCharVector;
 import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.complex.impl.LargeVarBinaryWriterImpl;
+import org.apache.arrow.vector.complex.impl.LargeVarCharWriterImpl;
 import org.apache.arrow.vector.complex.impl.VarBinaryWriterImpl;
+import org.apache.arrow.vector.complex.impl.VarCharWriterImpl;
+import org.apache.arrow.vector.util.Text;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -45,9 +50,9 @@ public void terminate() throws Exception {
   }
 
   @Test
-  public void testWriteByteArrayToVarBinary() {
+  public void testWriteByteArrayToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
-         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+         VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       writer.writeToVarBinary(input);
       byte[] result = vector.get(0);
@@ -56,9 +61,9 @@ public void testWriteByteArrayToVarBinary() {
   }
 
   @Test
-  public void testWriteByteArrayWithOffsetToVarBinary() {
+  public void testWriteByteArrayWithOffsetToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
-         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+         VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       writer.writeToVarBinary(input, 1, 1);
       byte[] result = vector.get(0);
@@ -67,9 +72,9 @@ public void testWriteByteArrayWithOffsetToVarBinary() {
   }
 
   @Test
-  public void testWriteByteBufferToVarBinary() {
+  public void testWriteByteBufferToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
-         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+         VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
       writer.writeToVarBinary(buffer);
@@ -79,9 +84,9 @@ public void testWriteByteBufferToVarBinary() {
   }
 
   @Test
-  public void testWriteByteBufferWithOffsetToVarBinary() {
+  public void testWriteByteBufferWithOffsetToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
-         VarBinaryWriterImpl writer = new VarBinaryWriterImpl(vector)) {
+         VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
       writer.writeToVarBinary(buffer, 1, 1);
@@ -91,9 +96,9 @@ public void testWriteByteBufferWithOffsetToVarBinary() {
   }
 
   @Test
-  public void testWriteByteArrayToLargeVarBinary() {
+  public void testWriteByteArrayToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
-         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+         LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       writer.writeToLargeVarBinary(input);
       byte[] result = vector.get(0);
@@ -102,9 +107,9 @@ public void testWriteByteArrayToLargeVarBinary() {
   }
 
   @Test
-  public void testWriteByteArrayWithOffsetToLargeVarBinary() {
+  public void testWriteByteArrayWithOffsetToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
-         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+         LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       writer.writeToLargeVarBinary(input, 1, 1);
       byte[] result = vector.get(0);
@@ -113,9 +118,9 @@ public void testWriteByteArrayWithOffsetToLargeVarBinary() {
   }
 
   @Test
-  public void testWriteByteBufferToLargeVarBinary() {
+  public void testWriteByteBufferToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
-         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+         LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
       writer.writeToLargeVarBinary(buffer);
@@ -125,9 +130,9 @@ public void testWriteByteBufferToLargeVarBinary() {
   }
 
   @Test
-  public void testWriteByteBufferWithOffsetToLargeVarBinary() {
+  public void testWriteByteBufferWithOffsetToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
-         LargeVarBinaryWriterImpl writer = new LargeVarBinaryWriterImpl(vector)) {
+         LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
       writer.writeToLargeVarBinary(buffer, 1, 1);
@@ -135,4 +140,48 @@ public void testWriteByteBufferWithOffsetToLargeVarBinary() {
       Assert.assertArrayEquals(new byte[] { 0x02 }, result);
     }
   }
+
+  @Test
+  public void testWriteStringToVarChar() throws Exception {
+    try (VarCharVector vector = new VarCharVector("test", allocator);
+         VarCharWriter writer = new VarCharWriterImpl(vector)) {
+      String input = "testInput";
+      writer.writeVarChar(input);
+      String result = vector.getObject(0).toString();
+      Assert.assertEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteTextToVarChar() throws Exception {
+    try (VarCharVector vector = new VarCharVector("test", allocator);
+         VarCharWriter writer = new VarCharWriterImpl(vector)) {
+      String input = "testInput";
+      writer.writeVarChar(new Text(input));
+      String result = vector.getObject(0).toString();
+      Assert.assertEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteStringToLargeVarChar() throws Exception {
+    try (LargeVarCharVector vector = new LargeVarCharVector("test", allocator);
+         LargeVarCharWriter writer = new LargeVarCharWriterImpl(vector)) {
+      String input = "testInput";
+      writer.writeLargeVarChar(input);
+      String result = vector.getObject(0).toString();
+      Assert.assertEquals(input, result);
+    }
+  }
+
+  @Test
+  public void testWriteTextToLargeVarChar() throws Exception {
+    try (LargeVarCharVector vector = new LargeVarCharVector("test", allocator);
+         LargeVarCharWriter writer = new LargeVarCharWriterImpl(vector)) {
+      String input = "testInput";
+      writer.writeLargeVarChar(new Text(input));
+      String result = vector.getObject(0).toString();
+      Assert.assertEquals(input, result);
+    }
+  }
 }

From 23c1bf9ff74b749c11385b38911d6aa8d85e180c Mon Sep 17 00:00:00 2001
From: Dominik Moritz <domoritz@gmail.com>
Date: Tue, 26 Sep 2023 15:36:22 -0400
Subject: [PATCH 415/749] MINOR: [JS] update link to issues (#37882)

Update link to use GitHub for issues.
---
 js/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/js/package.json b/js/package.json
index 1ee0e11bca5b9..11bbe24f0244c 100644
--- a/js/package.json
+++ b/js/package.json
@@ -35,7 +35,7 @@
   "author": "Apache Software Foundation",
   "license": "Apache-2.0",
   "bugs": {
-    "url": "https://issues.apache.org/jira/projects/ARROW"
+    "url": "https://github.com/apache/arrow/issues"
   },
   "homepage": "https://github.com/apache/arrow/blob/main/js/README.md",
   "files": [

From 517d849b5813788ea23cf938629f668cba8b4fb8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 26 Sep 2023 22:48:44 +0200
Subject: [PATCH 416/749] GH-37858: [Docs][JS] Fix check of remote URL to
 generate JS docs (#37870)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

JS Docs are currently not being generated.

### What changes are included in this PR?

Use a regex check instead of an equality to cover both remote set with `.git` and without for upstream. Added also a fix to generate docs from origin from forks if necessary.

### Are these changes tested?

Via archery

### Are there any user-facing changes?
No
* Closes: #37858

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/js_build.sh | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/ci/scripts/js_build.sh b/ci/scripts/js_build.sh
index c97733257a721..d61f74f0b7ca1 100755
--- a/ci/scripts/js_build.sh
+++ b/ci/scripts/js_build.sh
@@ -32,12 +32,14 @@ yarn lint:ci
 yarn build
 
 if [ "${BUILD_DOCS_JS}" == "ON" ]; then
-  if [ "$(git config --get remote.origin.url)" == "https://github.com/apache/arrow.git" ]; then
-    yarn doc
-  elif [ "$(git config --get remote.upstream.url)" == "https://github.com/apache/arrow.git" ]; then
-    yarn doc --gitRemote upstream
-  elif [ "$(git config --get remote.apache.url)" == "git@github.com:apache/arrow.git" ]; then
+  # If apache or upstream are defined use those as remote.
+  # Otherwise use origin which could be a fork on PRs.
+  if [ "$(git config --get remote.apache.url)" == "git@github.com:apache/arrow.git" ]; then
     yarn doc --gitRemote apache
+  elif [[ "$(git config --get remote.upstream.url)" =~ "https://github.com/apache/arrow" ]]; then
+    yarn doc --gitRemote upstream
+  elif [[ "$(basename -s .git $(git config --get remote.origin.url))" == "arrow" ]]; then
+    yarn doc
   else
     echo "Failed to build docs because the remote is not set correctly. Please set the origin or upstream remote to https://github.com/apache/arrow.git or the apache remote to git@github.com:apache/arrow.git."
     exit 0

From e038498c70207df1ac64b1aa276a5fd5e3cd306b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 26 Sep 2023 13:52:07 -0700
Subject: [PATCH 417/749] GH-25659: [Java] Add DefaultVectorComparators for
 Large types (#37887)

### Rationale for this change
Support additional vector types in DefaultVectorComparators to make arrow-algorithm easier to use.

### What changes are included in this PR?
Add DefaultVectorComparators for large vector types (LargeVarCharVector and LargeVarBinaryVector).

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #25659

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../sort/DefaultVectorComparators.java        | 16 ++++++------
 .../sort/TestDefaultVectorComparator.java     | 26 +++++++++++++++++++
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
index 99d66f94261ee..4f9c8b7d71bab 100644
--- a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
+++ b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
@@ -25,7 +25,6 @@
 import org.apache.arrow.memory.util.ArrowBufPointer;
 import org.apache.arrow.memory.util.ByteFunctionHelpers;
 import org.apache.arrow.vector.BaseFixedWidthVector;
-import org.apache.arrow.vector.BaseVariableWidthVector;
 import org.apache.arrow.vector.BigIntVector;
 import org.apache.arrow.vector.BitVector;
 import org.apache.arrow.vector.DateDayVector;
@@ -50,6 +49,7 @@
 import org.apache.arrow.vector.UInt4Vector;
 import org.apache.arrow.vector.UInt8Vector;
 import org.apache.arrow.vector.ValueVector;
+import org.apache.arrow.vector.VariableWidthVector;
 import org.apache.arrow.vector.complex.BaseRepeatedValueVector;
 
 /**
@@ -112,7 +112,7 @@ public static <T extends ValueVector> VectorValueComparator<T> createDefaultComp
       } else if (vector instanceof TimeStampVector) {
         return (VectorValueComparator<T>) new TimeStampComparator();
       }
-    } else if (vector instanceof BaseVariableWidthVector) {
+    } else if (vector instanceof VariableWidthVector) {
       return (VectorValueComparator<T>) new VariableWidthComparator();
     } else if (vector instanceof BaseRepeatedValueVector) {
       VectorValueComparator<?> innerComparator =
@@ -675,14 +675,14 @@ public VectorValueComparator<TimeStampVector> createNew() {
   }
 
   /**
-   * Default comparator for {@link org.apache.arrow.vector.BaseVariableWidthVector}.
+   * Default comparator for {@link org.apache.arrow.vector.VariableWidthVector}.
    * The comparison is in lexicographic order, with null comes first.
    */
-  public static class VariableWidthComparator extends VectorValueComparator<BaseVariableWidthVector> {
+  public static class VariableWidthComparator extends VectorValueComparator<VariableWidthVector> {
 
-    private ArrowBufPointer reusablePointer1 = new ArrowBufPointer();
+    private final ArrowBufPointer reusablePointer1 = new ArrowBufPointer();
 
-    private ArrowBufPointer reusablePointer2 = new ArrowBufPointer();
+    private final ArrowBufPointer reusablePointer2 = new ArrowBufPointer();
 
     @Override
     public int compare(int index1, int index2) {
@@ -699,7 +699,7 @@ public int compareNotNull(int index1, int index2) {
     }
 
     @Override
-    public VectorValueComparator<BaseVariableWidthVector> createNew() {
+    public VectorValueComparator<VariableWidthVector> createNew() {
       return new VariableWidthComparator();
     }
   }
@@ -743,7 +743,7 @@ public int compareNotNull(int index1, int index2) {
     @Override
     public VectorValueComparator<BaseRepeatedValueVector> createNew() {
       VectorValueComparator<T> newInnerComparator = innerComparator.createNew();
-      return new RepeatedValueComparator(newInnerComparator);
+      return new RepeatedValueComparator<>(newInnerComparator);
     }
 
     @Override
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
index 62051197740d8..bdae85110aa62 100644
--- a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
@@ -35,6 +35,8 @@
 import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.IntervalDayVector;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.LargeVarCharVector;
 import org.apache.arrow.vector.SmallIntVector;
 import org.apache.arrow.vector.TimeMicroVector;
 import org.apache.arrow.vector.TimeMilliVector;
@@ -47,6 +49,9 @@
 import org.apache.arrow.vector.UInt2Vector;
 import org.apache.arrow.vector.UInt4Vector;
 import org.apache.arrow.vector.UInt8Vector;
+import org.apache.arrow.vector.ValueVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
 import org.apache.arrow.vector.types.TimeUnit;
@@ -911,4 +916,25 @@ public void testCheckNullsOnCompareIsTrueWithEmptyVectors() {
       assertTrue(comparator.checkNullsOnCompare());
     }
   }
+
+  @Test
+  public void testVariableWidthDefaultComparators() {
+    try (VarCharVector vec = new VarCharVector("test", allocator)) {
+      verifyVariableWidthComparatorReturned(vec);
+    }
+    try (VarBinaryVector vec = new VarBinaryVector("test", allocator)) {
+      verifyVariableWidthComparatorReturned(vec);
+    }
+    try (LargeVarCharVector vec = new LargeVarCharVector("test", allocator)) {
+      verifyVariableWidthComparatorReturned(vec);
+    }
+    try (LargeVarBinaryVector vec = new LargeVarBinaryVector("test", allocator)) {
+      verifyVariableWidthComparatorReturned(vec);
+    }
+  }
+
+  private static <V extends ValueVector> void verifyVariableWidthComparatorReturned(V vec) {
+    VectorValueComparator<V> comparator = DefaultVectorComparators.createDefaultComparator(vec);
+    assertEquals(DefaultVectorComparators.VariableWidthComparator.class, comparator.getClass());
+  }
 }

From 7dc9f69a8a77345d0ec7920af9224ef96d7f5f78 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 27 Sep 2023 16:23:26 +0200
Subject: [PATCH 418/749] GH-36590: [Docs] Support Pydata Sphinx Theme 0.14.0
 (#36591)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Preview: http://crossbow.voltrondata.com/pr_docs/36591/

### Rationale for this change

The Pydata Sphinx Theme that we use for our documentation has been pinned due to bigger changes in the theme layout. It needs to be unpinned and our layout needs to be updated.

### What changes are included in this PR?

Update of the Pydata Sphinx Theme and changes to our layout/structure:

- dark/light mode
- top menu bar
- search button in the top right navigation bar
- drop down from the theme layout in the top right navigation bar
- version warnings bar from the theme layout
- main landing page and the landing page for the dev docs

⚠️ Needs an update of the [versions.json](https://github.com/apache/arrow-site/blob/AlenkaF-patch-1/docs/_static/versions.json)

### Are these changes tested?

Yes, locally. Will also add docs preview via GitHub actions.

### Are there any user-facing changes?

No.

* Closes: #32451
* Closes: #36590

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 ci/conda_env_sphinx.txt                       |   2 +-
 dev/release/01-prepare-test.rb                |   3 +-
 dev/release/post-11-bump-versions-test.rb     |   3 +-
 dev/release/utils-update-docs-versions.py     |  10 +-
 docs/requirements.txt                         |   3 +-
 docs/source/_static/arrow-dark.png            | Bin 0 -> 91541 bytes
 docs/source/_static/theme_overrides.css       |  85 +-------
 docs/source/_static/versions.json             |  47 +++--
 docs/source/_static/versionwarning.js         |   2 +
 docs/source/_templates/docs-sidebar.html      |  25 ---
 docs/source/_templates/layout.html            |  10 -
 docs/source/_templates/version-switcher.html  |  60 ------
 docs/source/c_glib/index.rst                  |   2 +
 docs/source/conf.py                           |  37 +++-
 docs/source/cpp/index.rst                     |  55 +++--
 .../continuous_integration/index.rst          |   1 +
 .../continuous_integration/overview.rst       |   2 +-
 docs/source/developers/contributing.rst       | 190 -----------------
 .../developers/images/book-open-solid.svg     |   2 +-
 docs/source/developers/images/bug-solid.svg   |   2 +-
 docs/source/developers/images/code-solid.svg  |   2 +-
 docs/source/developers/images/users-solid.svg |   2 +-
 docs/source/developers/index.rst              | 198 +++++++++++++++++-
 docs/source/developers/overview.rst           |   6 +-
 docs/source/developers/release.rst            |   2 +
 docs/source/format/index.rst                  |   7 +-
 docs/source/index.rst                         | 115 ++++++----
 docs/source/java/index.rst                    |   3 +
 docs/source/js/index.rst                      |   2 +
 docs/source/python/index.rst                  |   8 +-
 docs/source/r/index.rst                       |   2 +
 31 files changed, 416 insertions(+), 472 deletions(-)
 create mode 100644 docs/source/_static/arrow-dark.png
 delete mode 100644 docs/source/_templates/docs-sidebar.html
 delete mode 100644 docs/source/_templates/version-switcher.html
 delete mode 100644 docs/source/developers/contributing.rst

diff --git a/ci/conda_env_sphinx.txt b/ci/conda_env_sphinx.txt
index bd08937ae81be..af1bfe9b780f4 100644
--- a/ci/conda_env_sphinx.txt
+++ b/ci/conda_env_sphinx.txt
@@ -20,7 +20,7 @@ breathe
 doxygen
 ipython
 numpydoc
-pydata-sphinx-theme==0.8
+pydata-sphinx-theme
 sphinx-autobuild
 sphinx-design
 sphinx-copybutton
diff --git a/dev/release/01-prepare-test.rb b/dev/release/01-prepare-test.rb
index 1062e8b06c090..54437e9da60ce 100644
--- a/dev/release/01-prepare-test.rb
+++ b/dev/release/01-prepare-test.rb
@@ -170,7 +170,8 @@ def test_version_pre_tag
               "+        \"name\": \"#{@release_compatible_version} (stable)\",",
               "+    {",
               "+        \"name\": \"#{@previous_compatible_version}\",",
-              "+        \"version\": \"#{@previous_compatible_version}/\"",
+              "+        \"version\": \"#{@previous_compatible_version}/\",",
+              "+        \"url\": \"https://arrow.apache.org/docs/#{@previous_compatible_version}/\"",
               "+    },",
             ],
           ],
diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb
index 0ef4646236740..8253472ccc5b9 100644
--- a/dev/release/post-11-bump-versions-test.rb
+++ b/dev/release/post-11-bump-versions-test.rb
@@ -148,7 +148,8 @@ def test_version_post_tag
               "+        \"name\": \"#{@release_compatible_version} (stable)\",",
               "+    {",
               "+        \"name\": \"#{@previous_compatible_version}\",",
-              "+        \"version\": \"#{@previous_compatible_version}/\"",
+              "+        \"version\": \"#{@previous_compatible_version}/\",",
+              "+        \"url\": \"https://arrow.apache.org/docs/#{@previous_compatible_version}/\"",
               "+    },",
             ],
           ],
diff --git a/dev/release/utils-update-docs-versions.py b/dev/release/utils-update-docs-versions.py
index 6e0137b7c84df..7ca4059214db5 100644
--- a/dev/release/utils-update-docs-versions.py
+++ b/dev/release/utils-update-docs-versions.py
@@ -50,11 +50,15 @@
     # Create new versions
     new_versions = [
         {"name": f"{dev_compatible_version} (dev)",
-         "version": "dev/"},
+         "version": "dev/",
+         "url": "https://arrow.apache.org/docs/dev/"},
         {"name": f"{stable_compatible_version} (stable)",
-         "version": ""},
+         "version": "",
+         "url": "https://arrow.apache.org/docs/",
+         "preferred": True},
         {"name": previous_compatible_version,
-         "version": f"{previous_compatible_version}/"},
+         "version": f"{previous_compatible_version}/",
+         "url": f"https://arrow.apache.org/docs/{previous_compatible_version}/"},
         *old_versions[2:],
     ]
     with open(main_versions_path, 'w') as json_file:
diff --git a/docs/requirements.txt b/docs/requirements.txt
index a4e5f7197b553..37a50d51dd54c 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -5,10 +5,9 @@
 breathe
 ipython
 numpydoc
-pydata-sphinx-theme==0.8
+pydata-sphinx-theme
 sphinx-autobuild
 sphinx-design
 sphinx-copybutton
-sphinxcontrib-jquery
 sphinx==6.2
 pandas
diff --git a/docs/source/_static/arrow-dark.png b/docs/source/_static/arrow-dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..618204a2370a56120e6809228498cac5d98ca54c
GIT binary patch
literal 91541
zcmeFZbzD?k7dA|c3<wORpmaz`gT&AvARQ9YAqdjlJ&uY<x6;zxor4NU2uO#7q(gTM
z^&Rf}_I@6H-}k@o&qsechvS)j_Fi$VYpuPuA?m7f_&3RKqM@PTE6B@eprK*mqoHAF
zVq*b!L}Z^t10U$F8gdWOO8Y61zz;7ibQLUBRM1#~YizU|=)`E4*N*_d(a_1!Zv1tP
zhNg&4@$a<;I?F%LV4$G|Tcd&gc}5@jyuM_={_EdQ%nbDZjF^G(>uD_f49s8G7@F7L
zJ9%lH34Gu<$?LhIp>Z-?|3UZ4k?;V9(zDjmb<<T*7B+XZ=Y0Ci(aeI=%iihwTWF$Q
z!oa1yh1*kFFMB%&S79$P`oEqK2ClDfbJ5fO^@y9T7`?8FI<2&$iv_I!CpRZIz4%R9
zT3S(;XO_YmGLQcGI`ESiy_K7rlQ0*Tr>7^U=L1ehm*-qOLPA1Z+`L@8yd1z29IoCD
zZcn{999$Xx9^}_JG8V4pF4j(N){YLe*W*4lb98qTqo==q(Z9d`o~N6&<$vDf;QG(9
zfCX}0{|grnCpXu>V*_6my}m1~=3;FDy!m>3aURjXp8W0JKkpIcx_<e8P3G^F{&g2v
zs`yP&u7AZQe)F#J4=@^<B$|SZl$ICzMk;v1UfaD?$O!@_#FZ^{yOkBv=`xy+O<7LI
znjdE+*?6Pkd-5G6y9@<~u-oj_(p;IHF}mtfZx53)9%bpW&|~LkywFf<n5(<wzkDzt
z?t9gA?tADdIxyinD%9n-`rY;`e<!PL$ty`T48kBZ5G@)y_Wv&bCx`zT!T+4$e@O5@
zMEqYk`2RmFt|^)>_r&9_*-&`6#|E9<yQoaIHyPI-W?rA-ow$LHT^)^vIV@1i>i*)l
zI7BWbsajrRk?$^>jZ4bD!-oOu!Ol0~)cV2ZiaEka#$MES=jQ7m?0mJ-tk2@?G&Eu@
z$``z-d`qJL2bS}tNK$j_W|200@(5pM50cadjWCaw6x#K?y1tM3Im7%XIYs6Fix#*u
z6ZUiF7|35Kp!ku#*~wELIZ*5M**6@uY8Ts#LtF|H_x*ilna6FN;|ugvaPqHC3ovL%
zXgG{mTa;0CPfK&F4tdmW{@)=6_J|l;E^%mFL9;>q0SH1qS-8oqf8l6=+*HVG)*l{l
z-i#xLTFE^S%p_fNyexff62IJf%wzq<Mde&m>)|j6f`N7a|H@<}_p!gU$NL-f7aZIw
zSdMsq@9ZKhK+yAR+}>xY{iOPDq(uXp(T5-7*|wk9tQIf(Aoush73MR(aeSv-99<nt
zKta6&k;gd+BF|&u+2UH6ZL+KbDX?I_sp($^b^Wr2+fs1ZByk0s1|4#U{y?C9V~A~D
z90GV*Lj`G3o0z6e$fXtVCan8vlzg=o$<OOi2Bg^PjRgl1Ii$zEKa<k}Jx7%PT@lQi
zcs@v2EocMsyWmV8VzBuh?H^9Q^?Sd)CT^r!{*{zncRmOM2B+5TBYi}RGQBlVn|QW1
zHWZo9wN)gJ%p>$#pv8_RRmrGR%kAp9Drr42rpO3DqLBrZW*WfH>Cj-Rg!86TA(pu@
zzoDR{G<J4>`D)L~@DeB#(VqEw1pUFZ9IdbLqtU5HD7wS$3v9~jvS^AYS<olKhjmY9
z9nWwm`HFAzkYNz!bD+P#s<9`>ga0NmVMW@Mr=^$TLpk2_^Wr%mi15^X8x4C2=koZ2
zm-n2?161rjg>4bZN5+>SaVTXnihQ;5c>w*w?i12lao>3J4E+yj^nf&;znfzStfVxf
zSm)Ho0Bd5Yc$gDm%N3hwA4nZ``;RbhYbef}vWMA;%3>fZhG6hO_t~|?q?FTuzFWQY
zY}X!>N+&s(@jyjImhQhX5cZl#KK1EkXZw4X7h+HXN_IP4Bknpe(1HOa!Q=SzaLl&C
zHwY=;sk#vU-3ne*4)8*Bofilxl4Rm!K&FkrjMWnp5RgB7(v}z)H9-5@U6(iZtj{NS
z0U?Ynb;K;-d=8E_iopak6GK_3g&FY}2``4a`pid}C4P!wQ{pXmVqGf-MNDfoNQR61
z+f321M_x-pKiLh=YDhRs&SwaG9afND;Fm3JZgY;pf{d--BVsiIV>lPPp;$4%?pDNh
zz(`4oK^an-29T!ThJtYtVLyMj{+$A<o2NvZZ_9y`4TCo=7c)Ak_gb#KeC%8thG@rm
zY<sB0CH<HAn}RSv_>Y1<GyP^dXdoL&K+^&pFnHAxXj-OhPPY{B1$^@SMJ7V%PcLx(
z<HJQ=<iQ;(8nqqUw>Hmca<5a7e6ee*aiqt4`J2_yaw`FYc?5|W_z1w@dIHK?YC#C8
zL;Ii`4?qjL4f^wvT}lHCe@%e<C7KkRE=U*ucRR_j1bsw~aycRRjlYr?nXlBVJ(@Q)
znVH$txy`Y42eZ(C2E%%OK7K8fd4=ZD3REv$;3F}%WJWFssy<fzlpFW=$bg^(`Cx)q
zztGiIP@1vDxugn$p-*lDrd<u8^pp4h27~(osKs(i<o$pYZA82{XX``YCT2veE1LQ3
zYqTOU<yMgRgLMunWBkC|pP3nmNn;DX1A|)v7*WjRG?+VPr(*;-T9H@*K8RMG7Ld@5
zkBqi|Sk(=ZcWh3C>o)~p8+7GZuvtX={ysBg%*b4cR5HU5g9v&;s74uwn>Gaak|hyf
zL&ZlQ_5T>71+<ZY&s>rYg{rAh+T9C&M=Xw-#0@<i!j?%tD0(ZN+4>XF-lB*@88-&H
z#TOLh|CCF|<en2Z8e!<Q4H5EX5d4u(T7h9sL*kmFLM9L%4DhDaIMX;iYAK;mh8(Ip
zvZVObmkpZ`Y9;$X0|yW`3t&iZ>6KdlFr*%4LRG-8m#gwVUxG3Lz0G_3EX<4FsKKT@
zSnU|v14dwp<Y$yZ!@y?%-1sT}>xMr@cuk1SY!8A^FX`OIp9~%)WQmbHPyj>33xlLU
z5K>Y-7H{cmD~9}S#gfOsN`4wAYnuNio{S67M}>7nd)HF7zxr8`GQO=U!r$c;9|m|p
zo7?t1iU|f!5;O$&F*psv9_79z3_^H;u*t)^LQ8)0FLZ3aSCSw|8XX*f%AC<D`#gU_
zA}CY=9ga;|JiKM2*@Q(%>ogej=%WlE5>Y@TJ?1J3e=Mkn32<_|g*d@5NpdJu4+i%?
z_}uQ2bHe;O+T8ye=sVctL+c5E&$ku*&t<N?)GY>$d0ACJB>wepekCjexKS{96P<QA
zqMfwzI8M~bl$k^P?Q1^M(60x(ycpoM7!XAN`<NC!2H`t68uOCSeEH4aeL+&`T7?SI
zwfW>na_otKdW4)k1tX?NYg`@_RX&;z5})jQ{n-Xv($oc54Ab+jv_BS;B!h_HZc|Hh
zq~t3A<WbaSK?s9uF28f1H_a&ui>;l(p9`9jou8LER$%k5L@#+A0?2j*(9t_`Mc&_O
z6Ro;0Ml04mC-pPSwKy0MTt>f#7Zk&FAe7A-?Jr2|`C*uvl7Iu00?<4dpOE|KR4jp|
zWH66}OFGV*I&N*18j!g6Q-kraDcwpZ3%EhFgn&jtI2ym%1scW-9iR;n`<b|;To`=V
z&GUFxAf>4(dC0G%Iu;?tmK?7L*k;ys{JP0l`v-v-6vt?R!NUz@XQyXcUpuIW4<Xt$
zFu?dW4M#~+6i{fp_E)&x$;j07)(9R(Dl-DTbl(UK?KcTZ246!o?o#&58<8fF?-Xl~
z-NBFq1;IpNryaXw**3l#+4R@ocIU7gFtI_tfSR}Dugrh|WrpMA#FoI-ApJY<%NId6
zAwvN;6h#cp_qBEZ)cUH>5(H6Yb{Y(SROZbwjA$>yrW|Rm;U)l#LJ)wX{YUbD#ioDh
z5E_VFjh51k2s-gjq={lKSEURM2G6ZCJ==&}%(i_rpW(l$6b|U&8mmEAvA-<`4J51#
zd>2BQQYK=};Dm5D4;GQ_&}Md0cg9pdCkHJ+k+%Vq9VEF~iPDx0s3FAwkUrx!=+1df
z=G_9&?_3a8K!_czOAeiHnbDL|Vj>}?b>gOjda#8BMaHu2eUDVZ0Qcfh-s(&V1LP5d
zL&(Q+7uo@6>%V7|FLaHjOs7WGh7x1VKlJUWVQ^AG2kD}f#UC~>%o})a`G$Z2e87J@
z2^i)Y=*~e&KV0Y!8zCH=768$SNBE_sJSBq8A5t7d6avPU|5kJvLSGI9Fp8FRL_4h(
zdoU1~9|3`RSRc>#58#NC&Jc7ezwh}i0W(bl>v}1K_-w57K!7*qpunco8X>%ei;k_F
z2nZFqcTez-8Q3!b0U#x-$qI+Ey2L$MhXw=u)wZhE;5(O7xd-(#_dwZe_3=dj-|pnU
zi}i<5u!IMt3zS2hc9aV+!33RmE$_*{0s-&DPR~3e{)tc7tk$InSlxX_r$Ms206BpP
zlK|{zb*x?Bk7<mO08gi+f+0??wdVwkY5@RBG-yk6-v-7=L`aEI+$;hN;|Jhqc+WqR
z{<j{0aM`GuVKQ&}U@LRer!K$w67ZZB`)E{-UkzK<z!QgiSZ;5FF6?^u$=e<Qvs`y7
z-q51Ss3f$y0oZ7X)g#tFxMPMB#*dfbI=539pX&l~;I^^w4ap1%7@t$QmVXRFDo~Z3
zBN8FZ$_mUZ7$N1oa~}t=cL*@n@DF*;KW8Qh=*B5G<!SOd=hPVx{C_?q$bU|SLpf4q
z)M$4b2Is63cMq1t1z^icib3PXA5vi?md6ASXf!+rVp+7fEI$1p1=K4-a7kMh?o`nX
z!f?F-!LCdgM7sqnL0L5@qkU;(g5)<V4U*Ksk(oyvMgl;7N&;T@xP9}mH03%xsI;?V
zfa3)fR`Gw5L3O_j>!og!p#@290@j}IPx6%Z50B9&cA7`b2?DxyYP{w%--`g=_WD)&
zP3!|K$Po_32-mQw4m;B;$#2&j=&G<)em=u$ZHWLKyDt>59q%9J&;M9lD$^ifV~jAk
z>T!s$mN=k(R`90yTC84BC_;)VDKAz4V1&=AG_A4uu5EXvmMY;7>&wSP2Sc7Ly*>$n
z=eYC%%*~k!@AGR_V5X)GZmxi?2fkv0MePT>x70%wNuc?%4@?0d;JyjyDofpr;*a?d
zz6%X1<2btk*@~`8K(re!>FV4AXo|3tlOi=#_rom{`RI{uUrvl~%q?GSvzrU8IQ5Hx
zEQXZ<5mL!}a0~AbW~qHGhfBiECyh<X2&tl^2IqL3Yr2t^CyqqG5*Y~dUjTF?QDr{k
zEop`_5C>U+X-N}Rp#Ls-bnGyBT6{`TgR_$wZh(ut?6Q1Cgw0$6Bm_lj!cOHW2&t#d
z-Cj`G&)C@*M7xu*9bgM_$^cY!Bkn`~u!UY6ASQcb3Re64$Oc0D{yqZM<{u=PaT8dS
z5kR3?^@Df;Cxu<Rnarn~|A&C00KCR&uQ2!k+Q>ev6Ql$PiW>Pw5u*J%Te;bxy5dR*
z&`rs<6imt@z+KI*k@NqIBtKbU0Wf&Ua`rL>*l3gJFyHe)37}m`fU}K$5-t8odkw6<
zlwasGM%&XQ<LT5H0ES>Qa_8MOr2iKPXIOwfO0C<RQh@Wm+y$bCMfi8bnoJvzhy=I{
z&gQiOX*(=@k~sD{GHEk|A!Bq-gE3<{<b+n&WEtO%Px*J+Lpw-|@gt+A8z?u7IB^K_
zqjE68G|_MY4Dfnw^Q=}`>$OI=fsALa^CK^Ibt+(#wRPNwzh|<v>S8db!6{-eL^b|F
z7&D~MF|pKu@B-jWT!X1I$Ayjn2KWr*mtKM(h30DAgh7%I0bOCh6@FV9uu7INNvM?(
zqADAZth7p}IiXXV;eGe{`A;|RG;;%4Cp80sz$*kF4&Z*XT_oV)&q~HXoME{pmk&ei
z|10MHb!kctz_K!&-di~tfnfop5hVKvbefGc0gF9~;A=Q|A_5qb$7MKX*<bnFt?MlC
zgI71@?-qmx@&UrrPxOy=9N04Rrnq{Gi1yH>3_vEKxyWK72&DLn?KYwvyoUgICqT5O
zIr5>Pp6fK4vOn$*^`T)DVISa9+P#YPxJ{eON(TfiRe3<x+GhB#9-5Za44E$%fnFle
zTQC4&yaI%+!L5n?r*j+-{+)|ky9@!GlHl7B!mO6>nmb+G?rSvg2Z)xnilmenXvo|G
z1R3EV+xaX-z+ws5I1)&9xWy8dK!AfuO2Rj5T#e+AAE^&{i|Tewss4+OSqZ{M?ydmz
zD;$#wTCZ~-2KT7*Pqj_Nf{5o|gIs^fDE{=2IbbUR#7r3AlcUCO;Cx1qB4c^^$Pi00
z5y)*}7w36&b^5SJL%-s2yf#rfNIT&SSv@zt8fo~-YiiB&2CA518!zlIK3DqA#MarG
zrRz=hy1C6n{AbVBTaYNJ;jLheW9eQO<ju|GT7z0MaS2Z8GlI4CepH%uqEKQ>WtacV
zn$OYYRiEi3^e9YS!a^^pUiCP_JkUDfG2t(fX_M@{>oa%C8;AoSt-ce#O{1}ND7rIp
ziU9Vv8I5U}oY$k4d=$6SETxuiz=&|NyL!x<BT<VLYmsbmD2DEuJ&Q11W&yzBZLaM@
zg(6q6YLDcrnD*3srTb9q{r9mGQg3-NZ-;89snwbbS=IQ{@!o{L)TR?qjw!Go3V4rc
z=&noZZFS0&G^^ZL;3i$LP3x-O?%$7+Lvjq6Shr0E<X@a?y#TLOd0QukbQ~#s@2|2@
zPMM7J=vyC~LaE@8O#VWEK~;=`2Vn>)k?H!7nzt0*=g!Y0oab%d;Kl=mK{MOhPb&wy
zNJKlvVVBP7)RSwqRrAyYNpb+876=3*pWgVPWj|XsfA&p6k>*}amH1ZqPB(IR=otBO
zsVNON_H#nG_Lr+@aRU?>S&b^D>hM&&y4RxM6MmqNtkbTWWBvMqwDJ?gey&?$ROEZ=
z6}Q42QT6FdN92A^TWk_6btWKhMSCbP#$U(!YzmL?nUZDJM$Zeeq`(gw2a79_al-25
ztt0Js9an>3XSzpxFpcd+5znn}0S=*8ahFYds3eWL&~&^VO)$x^)N*u%1`4!%C{TcT
zw-wI8dGp0~JL_tmzVW*+ShsnG+xYzRZ=wv4WjRPq(n~Jmd+r8T;v3_BCLxE4G#~H{
z+o-ZF$q$F0Sub4mV-2OtM|N+fm$+I#QUBL8RA{4wKhZlmy~BbCS{qi$TU!ef^P`gr
zB&Z@_n1L_H1bK;|EL0LVm;gUoX4_wG9iw-Ok~AX*hz||A$Oa)c2wlX{KXLzqhKSc$
zNNN<bBD2TDQE&ACuZZBLUA6h?t_GO*Epg)FJnT>aAEQhYWr0KrBd4U+zg#?2QCo&M
zEsGS&_=+luoIo%{YJEFYw|jGR6k1wRXW~Pk-aBT&=e#P8EH#+l+apS{0~$?<CsjnK
zGMfXk5BQe-(;j>~_oLP(SUrWu$8*VlElr1-YUYY6zY;1p+l-&Hg~4^R<VObDUyJ2j
zp!!)(m0god;`JtIuC}dL)Bw=@JNK=I2X)0#r~5X~J5SvuKc*_=p@m_#OR_QpoJ-fl
zf4{V+<YN#gu`Y*G#$tBk!V4WmD(FsiWY#q#!9s9OXyKByO-06c+#I@7TF;i`7y2DV
zGE36t<WX+cdJ8VwUvT$_(VzD64M9UtFFt#=IdWb+C`h+~8lyONp;E|4!at^Pw#FA<
zK6ny}OE&&(?_NP_tEbYikMHar-(<}PyXLZIXO@Zsf!ZD(#{vC4QW4wobF>#q)*w8M
zv#)_sxzm#$+FrSZ96XEPmqnUuM@U2n&I#<!*aY}|ia9#24=ve{{FeG4w|E&h(v)y}
zr^To@b6_PIU&StPWMDY@`Fm?_w?T8mv*0ID_`iaO6(j5b3;sO+HH6aceWd52b>EXG
zDT@3rg346RKewZ=#d_X9B$>ws719z)JxRQ{dDubV`|v^|HV4IN$PS==br^u!3H(1r
z3$ykWj~Wv%;(}9GNslA779BRS6vfeHCEQO7#P(BFG0}cB*FG2>K91d@Kg<e%P(#hq
zg(Q0On|j`iui6#uCCYQO97Z<P9uEmigg*@tNP5qP6s+)kpc1IsacP45loOzF@12cH
z?Zv{w!S#(|HL9bP?Za=aNhx1HZ7zuP13YEQo__Qh>BgQ%?3>;S8Sm(Rc8+5~JEZ-3
zxuc=&3-b*cceV%N;&<IC>L7LiXZ;IgBn5Fkdwr|9rq1MNr;qNYz1y}-&(|yg_{7Xw
zEC{kTB0N*cDE0(MsEKqW+EkB(K|r)b$bg&{lwX#_i@Y-5b{g%E&{Jw738QLkC7CNr
zE`U!UH<~^&YlAU1%4_ReFV#LPjC=cDei-sxU-ErDRLQBn(1sl6J=K0(n^R}!xY#r}
zL#h^|-)vMs&q*HnEK+i6tT)?NX(sq%f@z`bUE4bCa`!gZmg2NpAK$XbO}+;Grg{QY
z%|qsbjm7NH{XO{mI=M#-^Oq9Hz~>_u-{m-Fss9t(775=tH*^I8Idx7&Iwp8h6S4U0
zb1flD5J2-VGGdlxfGR37)ueRs9t<ABT}c9>jUxW({xEm_-4-@_s=D8cU4*Ylj>oya
zDEIN6@h<OiGQ9f2m*4c*Lp!9mHp`2=-)z+)&k|Z<G?3pmZcpo9FaklX=5I|>Z6&2O
z){E`o(v91WH=~JoE_T1D?#n+T-t>eWHK|%3#XW3%96h{+8Pin|b`|9_Zx>Sg{(UkI
zsh1uIe17qUEoWTmVv2lxAWSeuSbl$X$m`(y`gcz2WSPMq9Qs@1Pg;~bcD5eD?nq~f
zbxv3qC!?}fcGHt|9&P+$>5_TaUgz`9p@&EfFa$C-u}zwz?dPe?L`(RNaeh6Wppa|N
zc}ee{vX%@`s8ywc4nB2h@6AbCq5$8n!RdII@eSZve2u5MmgmC4(NL=$;^m*7s|K%y
zjw6P|x8F}z$C!x3%mhj>xZj#7Yu|nKIe(!`&R_6cU?^DOILd*eCR^2JAdlI^B;U`_
zeXb5cQih2hfNH0aJSy^H_eeS>;i|)&@erDKO&vM&)w@p*3BdpMJcpXQ3BQjG6}f63
zx_NMb9NN#3NSK-otQ&DZ6rSD`aCcg|9O_cM@L{P7@0h+3oS!x9+4I_9gelKvYJV2;
zK3VcS@bYo8zmbi@H%r%Tp-cU`lIcSN4e%R3DQ*2LH}8MhRXFp!^V_alPa=H>#!k2}
zz^w^S&zV`|EkFV~-Itx{FnCW=&<oeUHV!JA)huC{*w@98JJ)HNb4ZQrnG<QN{Aksu
zG5D_T3i)xr?<A)%x|km3fumP022S4MXyuPgg<c&hQfm`1;aH-$21*~fpPf)Wdp~m3
zwyjO4A;2*(dVw}*yZ)Gju(m3Fg0sxC=@kAYJ>Cd{cK`n6eZu%fL~mDi00zTy&g7)G
z2nyI~EIRO+Je14%v?Mq+Prkgp%^)g`GDb!W#l51M`Ef38Jbf9tcbTiP1tob$M|_pu
z+hMnGH4w%7UpoT13W!DHNWl`oAF`b1=B(HknIYJe*w`BP(bJ&$w<KOMU;BfbfKycQ
zb0G8uA>=_DZqmZal9+aFJ)JZp(?)k{*WsDtL@5p~Uc#E+s?}bSgsyY8NTY0#I`Q8^
zbIz3f<=j&2_#0j~YxhxCbPjoQs;BXq15`O+;S-s3%feB4F0tp_S;0%WRkj|KW1!^n
zX~>(|0OEa*JsJl8inT)qYf^3}G3gqICuZ+8xkipW6(q8{SLL}9guNC-r72Gin!(5}
zt2UKte^R~>eEHRT++|k-DMD4()BQWlDW^+@8HtX4S6V}~TasUSpHrGIAQKfM2=4%O
z>mfDD6Kz>=z8Y%rOK9+RCn+JzOUbofr}_DNiJ5#6A70&3%mp%*ChWLnT|2TGk5MM9
z@!)*@fYth(V;PswgpSniNvzX>OJU@R>OL!D)hKh@X$qRT3I5jQy^EKu)lCOX)?Bz8
zJ)gJd0+aL1=IoH?feR9+WIa6*E=twWdG-UF4L-AQ&9dVz%PZwI9aJ2B;qeyh&o|BG
zak2J$=cz-9Z&rhIj&oD^wtvd!o?hw^_onzrZDgGm@%a`XBm=&D{!;1<CU`5ID|#z|
z3oqi7y&Da~x(R>cWydcGNM<|%nVm1}W&&F^Hhp(sn4Lj2HifEp7Xy&ucY(yg9p5$b
zx@@oN4%gQfh=><hV>#@I^-JYYNF47m4FlkFO*TkMyJad%%XTmJ)ppOM`V9#VE>YJp
z8{r`~z6+^>If*$of<cV7p?pOgkyQ(68s@{}_#ZHhz;e&14Q7u((lf}E)yT2~fkJcS
zp~BRF9~Iut72gX1$g>odi`o(5-o?*XZp-_ot6A0MS9N<H86Q0kNTwGq_bexOogJgb
z?Kf(NE~of$u}`D-Y1oQ9l^o+AWk>>r6Z(3p{7u}lHeCCVuo)(f0>ROLv@V%32{PMQ
zuTTa-M6nD%RG2<BpSNWAgd)bSH)#aQ2u?3hW+2Eps~!kLo7ia%D3x2_stbU~<%7_*
zF)8fdGEEcN=2fLGQcq+P_y5GL8H}u)^qx_R*n24AaaLkC#Vb;<k2<MQfxJth#}9UM
zboc8zlQM?ppq}H!kE`~$IIgmVTv=6jMOODk?9+JV+)J1aaoioo2{4Mv`6A%`VJ|S-
zEo%65f8jV_)WW_Br&Peku>1J%M#lbW+>r#=0E0aln8>cTb%=K@Jz4U<5=nI;^hoy-
zYD{1Wt(~DD2neGfPV%6e&uKod6o*o4iv1QR##S;2^7AI(uU|kP>4f$mb`z`^-!217
z^iQoZL)GpToHtR{v{s!Bxjp5*0O1EwCy02&c7&(nJwI_S?51)ZSqTyv3vXhbI9u#$
zQoOjChK(g-JV&%HVb!Vj@Z?YeVhDAbuXQtB4H#;RLHVKuOwsNgWLozm@AaXUuP91H
zm`vI_+1@bm&~KZxFU-Yv;Sc3ERaH}6*22JxY6+x9fn=~>NexhH)lx$&N=D8c$K}G{
z0gEGRB^@s~3Ex~>CK=M_HA0F^zxC4HZO(0e{+Wq6*-x%~2^@A{Tl6(CcHZtF{$z#`
z$jxOZ^?<s5Lh53t+2aRG9my1AN=+#+xlBaPx-AcXqh4%ex*GX1HeK@KUgx$}4Oe{t
z<}<lb-&pkZN5*y@#3HBT<EpLm74=kp8lGz+$W4~Ehc>542L_WPg?ac3SIu>M-ny+0
zYh+42XCXZz;`J$H50asS6<Y2M3e)dR4hkmmS9pljNDXsE4Fi?f_uWRWtXX|UxT2I>
zE+0(p0mbNF%LOVs)cZLwxQZAgo}0AzF@t+w+|O75fAd=bzci5miexcCXDiXyY^%`j
zM$c<WOzfAjCFr?k3voD57E|wv5zO~m8`-rfS?x!ur>4_ouXd@nE|#JKa1F}Yq36MC
z3r!PeAy?9oX&+@3&dDx#7FU;V$Wpwbn)|k=G)nE!X_AFJDV1vVCjD8F8Zd;Q(Wt%U
z{DDu$_pBi7c-fz6qaW}6wpzcJQ4YlT{i}{JdTt`T3!b0BUOCxsPy<VST)&cQ02Nb#
zsd=c~b%%9k{ml)l8By6~brRX)rw@&KzvqnzzNGtWJpi__8U$6+4WeQEcxD?^@D9p>
z(I72ISu*gXmAcwX9E*R83_@tgRAXfq>z^^MM*TTp^6mL^*X2`6`>gDE&waxJ9~1-?
zU}h<DWWcjh=~OQ9=**tEMUEV@dy*cY6n3GQ*`d)po+GF<6EHhh`*I_vc4BbziDdEy
z*{cHuuE+1|tQyjvA;)!48@ywg^9RzK?(p8|M?z@=b>TTge1rG?%fSYTFr3AJDo+<5
zq#pxJRUk52%nZ~Tle?P<{;EGJ1DUl?txjUG3xFDfIiz`|gm+>kp$uK$!@p9fA|OTt
zT7GiAWv-*DddH!-*@1ETAMg7n<emu)h|LRqr%=@BI_!&ieL02X;0d+O`BA)8625+h
zn0>X_*A&)V%uzije%cDTqnjxfP>f`&WGqVaIZ0Ysj5sUjI`S<YJ1w{oy3Tz&y5#ap
z`Q`?*r|pMy`3jkIfGf^Aj_fn{?5&ATR~P>boc2wvCne(R4rTlg`z6e$LyrWDSsK!R
z#Q^hH6U8>l(xRR@&eN98G|IxK#zKP508I(kVAo1!JObseC>K9Y<+gyr?xav=s|bD-
zBzSHMwHS!~G^%PUV*FsWK|`b<Fxqi0SyYqabmp=Ev(7V_slR9n*Y6l*csS*hb{qHT
z5(2{%a)4W9Sw*s0bO}<K4hn<)&XcGm@QLU6cU-1_jvP5~_&1Lbd-wHy-S!OeAn^5d
zb!i~$7AQ*()!7bM?2~I1w92E{r@Ao09REhXUKdSu+&doo%b%{dbVGx>K2uZpYyk1S
zxlL+}!*8S(4Jhw2IPG8<4V+@-)o-z7$XC7u$cx{F>b&VaEjtj*foLZL7fFbYuegBu
z#h`F1vbTs@)k4JZ;%RQW!d2ILwLkRDr@OvsWWGj`#d)XFd^_Jb-<vl*cQ=1-ly1tM
zPwa`W&tuoH-wzJuG#4zmiVaBmwEvAd?YQU-JMLFq>*~qnq{{+6tPe>k_|T24^SZQ0
z$@lQiTY{uqihA~ftMV?;mnQf28d<uH6Az!1Oei(xxg8sdwFMu@SRegx*v_)P&aD2~
zqs}k@nfW!#jJB#T>S2IqY_5dI1W?&PsrGSt*x!Zqn4k-SYrsGU00SR~z4(L5J1utf
zxo*?oeVE2vxWg{a#|4qv8D`2m^+riz7E!rL;&P}*1#sK~=$v%UcI=~oB)jH`9~)9L
z8L*V`Ii5)Ur1<>_y++5hNIm`Us%e*{2Spm8(_dm*Jmes|W!B}VCP~MdH!E6>cRhTS
zJfl$&=hijdS@Gkvr&6sS5AQ3}V`m)L+&24bEA5xA1|ub*)`?a?-4JYr=WW}DuZIPT
z0XiyxHEh$L#i4Q&eH#aD3u4yfdA{B=O>cj^7J7t9HPgpx$`9;es9=cm(9O^j_M5k1
zb(J~pX535YKwF-3i>WUo3st4oZ$_xmO(@K$QRmvHW!UTQQlB=rS}r(ZzGP^tn>7y9
z-2RBOLi54jkF0GwBC;}5td%WSr#ns7a=kg;#|Y%minJge@NJlWFs+It-dxQi$sJ`9
zxjzuFu-BSchTU{#-^Kechyz9!rvUW0C~2_(tt1L*l~_b?fGv)8g+}9PwQ<{4bawxt
zz`<7bU|?$q$i#(iesensH6sGr^8joC;R_E9mgYi^0_^)*6w@>H<|fnLg713>2dbcy
z%HAz5IpvNYM|bFZ$h0=&`?IM=v?6pT@>-3bfxSI~{kOi*lusswejSHP=MaocouIkI
zA&;Eiw<Q`gZ88(xIVpT%{N6DNUx1$q7JR{XG3aNslsXWRR_{P8F|;YL#a!Eg&X}zS
zV%j44TF5l^@SnYfL1&B~*@yLM2&pa+X_dllaincNScwWcAy~@H|MgA_Q~1c!2f#|Y
z4+s3w54s_qScS7j7~+rVX6OhbmdFZvrVq44C<j+<8zjmpJgWvANa1%l>eZ*V#V*C8
zMNOC!r65O>&E&j9%#TE7;YMZ1z*~t$%#;(dmm;j1iBCgZ791|NZ6_HgleE<cma1%p
z=I8UU1M+VW@x8f7iA>kuA;F7`Q<Xla3X@tel|52q%X#`K!(K0qQ2tWKSYM#2vRBEb
z|K7imi6uU$%wNpXh#siYv-;emkVK5z0j(u^;~skRh;cB9u?d9bbqC>{P)S1u>XHC?
zpefGH4iDyW-3?TFM5&wXH&~&JY@D*H^OGh>+N?iPprf21vyL)*?$)=OT&h@oDe%?b
zc{FA;mpZ$F%$A}Jl2>ujTf6GM<B7GPdNInHG~ib-_wjMUd)L+(k~kFSrEhjS`^i;e
zZPVmtf?fJ%?rHT*>EJ_=O{($`KZY{@nyb!P6YHhqWuBD*%<7Ab3wtFHerI3pSTeY`
zGK{Z_H)jJCuP4~^pC*qMkf`|4$@7pAfJ*oZno?shUT-Ih&MlwmJEo00FzUb;^kop^
z=gvlo^BJ=EO4_vCoUq#OMB)xDP4z9?@@;CEk(gSin=WWS(2fw3{y#{D=2q5UGd{P0
z*NceHjFpuM$@nDj?Wv8A2TZ}MzPGo22)lTW%+T4Z=d={4&Bp^XZhW3o6xmLHPIx6(
z7tCel5EZ~^vTAX0FO9H4m+eC9W9bmIU4%f*cm5Q;04|0^ldLlD_Hnh_bh+g2Lgkjc
zZ9Rk5L{CesgyskDM+nUEaAkbiGkkgWdiil-`q?Y4C%N})=lmB0*H*{#@vibRO;oEW
z_x>Y*MdBUk7xOa4>jcPo>2VpXlOuGKj{7FCYwh$Fl?}&A-#vNne86%tk&6bz^VJa;
z=5cr8H)dQ~l?1|k9+;EH*o2I7GBM2Qp}5+qJ$nr%SAzH82CS#co%jo7oA_O;0M64F
zPo^e+Hv25&2p4Q*yc&<^{t_a5FvUIAym<gA^$egtkjs={n(62Tf8nY=AKousRP8ZW
zL-H0(BZwi-+B|;7*mWnBG4+u4J^@po-})G?ST^zyjQ`M2YAKJ5^4zQPKxEb!sT(um
zs5>~XW^Q4)9sa2xK>vm%s%>>U^wxdxqox#3GQBr@;yNfnjl{anuF)F2|AcdG!Z(O^
zYF0lWJrDCODi7gpQbCNr=*{`7Ug2>3s&QmiJZ6XD5DQY7OuKHz;sF402O)NsE>A<O
zEeE#M4h4;5Ks}z1mV*}PMv70+0>M_m@Vcn3hj8MT(~aZhbO}=mk;KRmf&QkS;-rUP
zC@(QL?lw-;>NAGs5DY^gZ#TrAb$QyPTX>5F+cnzMoGNZ?98+x!^pDq5J8MLk&eqk;
zh|N04-zCDX*Y!SETssQ0h#p7pd2Ybrd8RtWRO?vU$}>&Mna8*QYr+(^D44eA>>U2Q
z=3*!zvY)3Xu}b!R>Xy7l4dE}~)t9;M`v~d!9#h$A#_>==I~Oo<XX-=|C#OPGrsGL(
zsVg#(38p29==xOO?>Rr8RZDmL9LTEkGsth@01X2VgCtJxjU?4Yf@u=S<UPOSJ`rNt
z{O&5TLj`Q0no_Qw3C*@fo^V<R+D&R4WQe#%5I7eO=nk#wFt@m8Q^?b>AA;d?EEh00
z9c$<;zYv@A$L5Dh3H_W@j`Z*Bie`=mJi`Uv@&*<z@6KQoP_D*IteV+Bo93wKv$tg~
zP3Lps2HlMen(lxlR#tDASFW#Kt@Ev~p1&|Su;qC8s|5X18nO8C4#kn)*UT3<UK`8K
z`_x0O?qc)XLHCh<KogmsQ&%#BZ)C6k#p<?wN_OkJnJ<spmY_m%>Gyr&Bf&qw&hztd
z&M1V`w~1~Vj8T#u92{#Nm>+@yvecrb9f&=-|05;LJ$+0nu(;_(%|%_@6@QPdoOPL9
zj{CrnfQgp==PcW&SN%PKAvfz>dBxrzP7RAVLIQ4lOVF6U`fM2g%u^vRthsN2B&WAt
z!6%<jH6@8s$*fIc+*m~E;wGJhdsGjBYip@a_2b3>5B+HiH4c^*P4>(5C!(5b7awOQ
zj)e5D!u>=TrA?%6pScV1f3hm$h1Lh^^~PkbtzPAw*}vcDF?%HRH~E2C6Yt=Q(xnK(
zWg4u*3`Adxt1T{**{1j<4{=5&E~4P#dJZOGL-bDNuSipJTfORq7s>oC#(o4K&2!3}
zISzX7LM$#{mvta3)`B7A&H6SbGDMeYyz7tjfaDkrh{aez*5Az9lC0iCmIClqw^LWB
z@us{3;t%A8Hb!Nr!@PXnoh)V8Cn(O{KNK&h8s7dUp|#euY))I+T@Z3sx_K-YP%<1<
zpEU=MuI79!$kn8`7MWx8Kmlf!YgE;q)^@|$G)+$UWVafQo!BL8pKh$Y5;`vb@hG%<
zg%&BDvtpji5EuwLdxnhMUuLMOs@<%7XEH_BV@h;U^0P8C<ys;aC|R8sKx_J6Iiw0B
zVFYQ8;EMasJC6PVm69i#n-S~rvj{1j)TiUa%xv2|*7K$X5hO<Vl=*9HWNS$$$BKce
zb#JfADA{_qGg}?-wpw7AXQ_{N4dNX68G-mu0<<S_^E7sD{3Iz{ZWt=5D$rI{rx|Iv
z#6Xr9KM$@Qek?OBT<G_q)_ssR9vZ#z;gDeH?R31&{<nSA2g&ABwbMM*kbNP6%_i2A
z9Mx2v?JGLn&mJDNG$lTM_SA<VB%8H8wkFm-T`$)cLS@0u;#@Uh`hs<@)J9BnP!dxE
zQt<LQcUM|7Hb7$%V;-Eg#37<*n<C?l0n_8&@7EV<_iQt_`tZX8q6Q!;FXXCE4bQr2
z4Onz+<0Pu1a0K6+mwmgeTlMa<n1gme9gl_bBzip$_<p5xlB$SBvyg$rg#DZ*h2x#D
z&#PapQxmK3PVa^UO@A_9!lpbApF-9-<avjs%CXkJrtrq|Y(7xYc%e7SA62GyQK)A^
z1N8sAL@liDF9ydHn3(A345Kryx`)?nfBUT3;B&W2QIkc-&tcDbsH>OVDdT|OCU1Ey
z9Vp9S!X%Ti4}=w_wd(rE8ENKci`+=sy&gjDxodzKB-VZsY_Z<;o!@n}*uzK0GCas}
zj&==Hp~)4UTP1mu8~R4{?AdZ2;|d$K(@SBlRf@xtlH9VWR%Q27m40{nyr!ebi?rNx
zQl;(qq;STbGe`U52k}*<8f7%BQ>w`Wyq8HH6LM=;o_N^{Z2?iWXEC*&VsT-kv!A90
zwksV&>r=mTs*z=__ZG%YExEI<w`kNgoyk332qn03JU_Xp3uXO$x^iJRGOrVz8zuNR
zuL5d_Zjjnoi|C<rRx$lfj`%Is!*|@BPDwI~_vUTUBCmS|)HhwCrdG!lMQ%gYQ)jMb
z*DebVwzH|phM8}Cz;LGUV&6oxzqcU)T3^-$Vp#63`;=nrubO19{S;(AnL1HYG|8cq
zV4sodsc^aUV(zAkh*gb@=X7bx_Xj#T9>)69s+(h6#xiUIPGA-ock<MmKkMrz+7a3k
zFY@rTQGqx;Uky;cB=7CEq@^G~skr3Q^v>#DH=|B%6TIxBM(QWi)`yKIid+dkrbieB
zRGSfLzH=3_XTpIZkLxsCoYJJKqkCN&+F}EQOcJLOxso36VD_$NOZ4Pga{7oOo5d#F
zxSxWNUougzsXV_{#I7F!Wimnc(F7YVf)}J@`Rn($-Hjq>PrE6V#&j&1a4%*ImrIRI
zXU<ui57Hm9JzV(*)0l_{z4ye^gX2+;Qa<JAEFJFX2Dw^6vX(wCT1FlpN2Qe=O&V^-
zij5jnQpMlS6Mk;~c=RlscVR}u<hj?R%(&DP!Fw8XlLsjMej2$WK}g!_#)x>*MyFhp
zw$2=0L)s8m;aXXgF>{Smamo+%BS%VRqpjW?=0g7swr&it1%<RXP`lv)eSE5?ytSmy
z533*aYQ)<$x}sh>op;zp40wk5DT6)Q@&b!>NW6VRj}FmLRY?cyjzc1sMzw15O;#7?
zH8b&wdH%twBVC8@$|mTx2&Cqi4r6b$o}ox8&nOf(f7VHRHmrQ&+3tw#k*-->%xO&)
zeb>NQ+NG@_a=}4;CxX59s|Ra~A~MjnOHQE*Jut14Hc+jkO=J2r0-upV#C<#M)1Aac
z@iBo09X~&vfTuCFu-v?FZJiaPhpufqS7g6fPzDBuFxgqi9N>BY70wwl%K3p8x@&l2
z%)R!D(;E&V*a>ux!zR7&{+I`At9TTP-h8^C&m;GMmXUEbYLQO<9H!`)>wZ2zbA$0T
zXuW}vv;XKBeU67#pjKl`oOuqd7OiuN+uG62hXvi5$P40DZ#(wDM>mc%fo$WS6BbF0
z`e17UEC1D@D-Ej4<~(ZZgAU2<p)_~%fkMi*^?l8$U0Q1p?!v+fOn-&s%eSFB&um;~
ziQVg^gf6tm4|n&TnoVzDdt}V37D(hDC?UDB=XCs2OqdE2Q&DVvye52)GyURZ1x{Mi
zdA**dDNJlkzPl`~ZBm(5BR35p*_Z9v7a9uB{>HQ$D52cjAKTb!$#e68eZmbbEPLCt
z>62{Odibvl91Zpm$Ld^eK12N@iN)4#Nmr{<Hqa6-v*}hf#0hj&W&2Rj1D)ads@Rn5
zx=x8GGjiz3n<R6vwc)t1Y!Acy;xiEO1?UX}xNNLqNRS0M*-=Ktf`jo2I96ar_deD-
z2RJuzY}7jtzZGK;lO{QHR3~qe4L?;;T#PvO8;&N4r1sC;Nj+&HUQa9IrQa*w@A~3d
zd%Tj^57fq!)pP<JRdo71h2#Q&&hEeeF97{oEL;h_`8@R8`v$C4m^qe<0+n7<_U6G?
z39MJ@ImbG}-A1bcqha>5kEeW(>!-Wba8DG1+oCQXu2lxV-K+K&?63H+?=izZ>yhnO
zRkFGpJ3T5GeE+bj)w_!D-vWzra!@BH&{_KN{)0`kZbvA3q-~=7!05yS3~;K`Yj4rb
z-C9kcx6*R=c&Pqv-#D6l1JGJlObsp1N<v6A_?Or5(SR2yW#=;zA^U_@+}Evk4$V@z
zzNUHZde3x_n){m@K@jGeaRY%w>O>WlZRS0X2p)UpW{G;A2)j_z&T2(Jb>q3iJ-jaG
zCtbCw(id9o)tEPsMd|1InP0Ox8D5aIcVBf~xM=g<c5a~$e17NZl<e*Fa^d>s3NsEV
zChn+!r_J<qO?#)mfJ;*+35T_}zd-72=HrbtW9#d7uYc74mNBCu9BA5dJRXRrE*(lx
zyeP~ZxvyDFw3J4?Q!h|Tl3+CjgSS0C`<`8`1cPtfw;DbBT3B~V2<3jY2DGKY;A=i6
zS24q`w_xzgFx{K5PNE$e3Tqm40#hpFj1KBev(LrU6oa@(nZI1)aD&^RK!smv)53+b
zPFv%bp@E3^{IM6Dnnp$hb5enIxn19Ut6TVe9a}V3EgUp&;}<_*Zq#UF{h8yvLWDqa
z^isl+hMPR&!rR--JbgLiux%G3xj;%^TV(xS7P?5i5rY-CX)KacKnM8{DU4ZNw>8Wk
z^!*o!4w6I%@lhZ8HdP^Dl@bqqWR1hR3^ZwqR=i{Jm<Y`kBTE1UKRL5Q+JbYOrTgbw
z49Yvl<qK^+sPd44MT%GK?k3r4PsUq;wz}2nTQ!kMg%1FzEqd!$+$^tsoQz+}kD1Mj
zf!syF-~{>p=U+SeDcRT<)Y=JI-bgZI3EikDa;@bl_iqe47zXiVtk+CVcg$?HtmpF6
zM67oqUsj~@w#>rs5Lo7FOTzb@FVYzgZQo$sz;E^&6fQ}stN%)+KB11fg^cX73*EL&
z_wtdAE$Z$s`g)r$_JBqrz9M-<P2w3DkK)X@U{ruK%DVs@W3=g5DE=?)A;AGQ=wa}5
zYj)R{YfedVKv$-%a^wg93$qzbpiD|<lV@_jMze2m{YmKByBm-c#Ve^p5C1uqL+E!w
z@!Q_`SsT&fAm9W>fdfg+*XP+laN&<yBk$_rD(DA}9B4JdN2o@w46?6}Q#qj&$x1xD
zOQyQ#rZ+xUR2qJd!}_NW))CpTF1aBmx2@fnbu-Y=K~f-7DQq{RG`}g%&+I6OM|Ch7
z#d*eHF>T;iIq0?y9xF6wDy%9@8TH=wd%TU-xevMbPTSF7xk))rCcuFpy;^!9FtC1O
zFJn(oF&+=HbZ`AKomYs7cTIsN!;iYizKk-#WFUZHfOT%;n^n%`&q^>|tJOL)h1HM1
z1B3Se)b9pC804C-9su3oc|BWs3YvM!B!xqy6y|oDyNz8L&#jfG4iPZDW`(tNd<^gl
zbr>O3*S#3nA(R4dXl4&Qb{5^?7lFaWqjW(qCPI0t5S4N=ieM7#;BtwejmR1OA&&@n
z9o4aHes82Cthd&SyFs_H?s?-qkF?dp85!h<(`xW29c0#vqVCnCN|g$|L|q_x*iJKC
zAdqoJPdLIbGkhi(6*7Gi<R?3|in13$R?b^DT}-j{8Vz|F4O30V)QmN1kWB?Jm&dfX
zNBJ25=kxxl<EbkF=UXJPsPDIk3RZji=_s8USZRgH0_{6vHq3Lf1_vbHYY+vExn-<A
zp<yVwf--A*Cv{vA5zCilXMQA8xxk^x`SDwxo7%EO&n{vLFL{wQk7!lO;QXO+GPGjU
zz^R7-8isxI9Diz{aRS)P5pSU7pfd#*6cR&>=3XtqiogWl`iZ!AIy%*2mXlK6dX-ys
zRkWGR$I9Rp^1tu)sNB6P{P+YC<R16Bq@vZmVC@e47TAfJwZ>J1lcl+z%&$&Sf`h+m
z!Z>!HboDti>Oqdk@e-+hRr=I|Z{={r@rTS!hruI>vDX)^Ci4L+h(U_%QXQgAic|52
zr@{E^*1}jXjU5}DneO*Ri2DAQSlH3S+dkeU1&)2>5{r!;pL8v5-?_3Pz7LZO6A^Qm
z)AY&h?BdcEnaLkf<%v8t;3&)jdV>yAaxd;Rte-Izlu0Zk4fjUvVV~$<+f2R6h(LOR
zO(lh(MnS3g6V4|niyUAF@7|2m8f5K?LxU4`;5Cncr9-_^r@9<F=e1>*Yj5O8nbKqY
zP)@UY?omjEPVoIa`n}k*Nt2ba4%wG#ajp3~urvOtE#FgA0W)i$h(%)&pK8DJi=&yN
zV0o&GNRl^9)Atu>`zC3>&JlPi7%Po8>2MBt$Q^N}j5Tj~)$IAyjkLeDBANbi=~R9I
zLUMgFRw0OWt!bCQpRjtqystI7YO7eKgM&ZeFw{{yw`Wy=sb#I+ceu;*mBzMJ$|hv<
z`O3+wf3_Qd^Mm&?Dzrh6fKr|@qQZy34*FQ+t`Vl~m~O1UKgnXB7(c+{KL8eGIvfwQ
zJ&*F^Q@-m;&S~wZb)v<-{if{I5CYb?^g>NxR4WyS^2B-{o05`)npw#+$|dF2%bWMa
zsDT4N8R#s;82faDkmb{*_SQo>!p&2>_tjZ^VmwnH*18a!(U+=gEZZpY52^~|n&Rui
zTo#)oRUH<uKWCuIs=vak2iwE3nLZ2Hs|ad#93}efP}<+JcTG+Zdb4meF?gPvPr<?k
zzA4V!GG!s3N!2%t*~5_?nTS%2(_NixSn?~OJWzRiShHn++D~1rs-l&M{dO~3IemiJ
ze80v|+Q(j?rm*#t9p~SYvK140_^2f&xUijQsCPdp8?s^fr1bq0uxI3l<G8fa-8JbE
z)z;84^PREKwWJ#m!^bLZ+TBgrtyp++9{`GZeK0L{l<YWkkAEg)-SMyko6=9#T|$4&
z_R~ol76drEncam6hRm*-XHRvPxmQKr1PHE;A}!@Retv?gM~oS8dq1>E8cIlTVQM}P
zcR74wK?FbG2TqRX=}Te87K798>&<b89YbC-;oxrt6R<6U*WTPh+IcSe@>IFna{NjH
z+|x!!cC_xPSz<4G5A}~69VBuBdE4%<rS=R1?4+GQlp|zMY%{iQnLGYUQf=wT$0dVB
z;y8Wac#?Llx@d3LHs7zE@2fyW^O5>wlcJIF2p#__Z@hnS&ru+~o#Oa|{~R+WSCBNP
zzyKfGG`QKdBr1y-nGf2Js8WN^EDHhQ0B8BU@>qd0AX5p)?wX>`^N4obg+}>d>-3Vb
z9t<TNe=2CXIY2|Qvd0yTJdahf{ebhRJ<nA`ex0z>O~(89p)r!($Id|;s<jDq2OT>g
z>zY-W2kED0)p!qDvm~&X1GEQPYd?IA!Rw^X@Ih^1DOCsO!LK~|qINyO=c;Y=l;5LQ
z$+TWicWe^&+QGrGmsUs8*$fKCb&LDq!%{lc6<kpf;~tk|L0t5ir3}k+jtt8c+%zYr
zw{-$+KABBtDTBZG$t9XJx#x@!uUr1N>u}I!@DKqT#5Lx^tsX!vrn3}6`OH&fym!Q`
z_^}ay#M4@e<j|dWRQJ<^E-+gk?R7<~Y5cVXX1D&?JqDEn_k>UyvSSfJcWSJC@Qd`a
z?*Rf(#8BZOd`AlN7TM3Wz&=%0rIkQ-g*XZ>FEw?FNxo?h0^2y)itLre>VI?=eIVFj
zk{U;q0(~&RyRl~%cj`2Ge#d^b>zn>0Si3HNU0T~w;`GP(sf>~NjEeq|LP1V`d$kGX
zvdfhU3YY9&$li>E8A@-;Asg{(o#}#W^9-k8KSGpGNaO;f(k8N+QOq2;AbFMx4>gb5
zevrL2N5nF`#NLLhwGvq!xt?$&<_P~4kI-OG2nW5G@hK@w6^+t#*s11fGE4CbWO`b9
zVQ@RY(#unUnrV?7>PTO`$K%31<nQ5<hH}6O*H<<abs=ZA%rb}Wz=ll&gp%@p%ab)*
z-O}4Y9U(*<ndz<l_y)dYG~u1#Ac6$>eVh}1b`OYzzIOMl+MH&N(^`P)^u-uNTY-Ij
z(#@u7?y;)J+oniaJs#+!VJ{?JzY@0G_pB+PW72b~%V_tprw*@|VV+05{PcS%I(R~J
zs+fGEkwv`<JMwDQVw!r+`$r!ABOlr5y4Yr^wY+;8)5EyAIt31nHTW9GYJp{R9Mj%-
zx9r!OOwWmmmiwh$$^`=KE2X&)W#6PboKzfCo%$H7#KG^xfIbz^xUNjj$jK@bRJ<Df
zwZ9uCCAr7|hKN3C)Ni8VY!RIkqlyfVW=QUj4QlAB_u^7H3xV5@iW~VXAj~f}P^yOk
z$#<GH*KF~*7_RYF9%@YmJ;|S9#-(IA+*5snGCSJx%Sp`tD5qE!i)!S%EW0kz5c&_v
z0{I$|sH~K!AqIoUPUqKmn@Ws?%zksQO#}>V`K?x*2vx)3F&}7R6XO2Bwd4F!VKOZ_
zF+MHqQ|%0&x?c8SK%D!SvtHQ!<&~t7F4dDnMWZXLto*j^xHdzZ`%~>ym<MVF?8lg)
zo8|9X#<%JH<3{Er-?*nyu}t-o<wGdz9gxA%!?>fKZ@O@XHmh6O#>*cLUz#4#Uo&{I
zH4Ed_E_o`u9oey|p>d!YMgHO|Br$$(#Eyvui1|lHieJg@MhCrX_<D1^Ifbai?7=VE
z^P1>Omm&!A8pi6_QdYGv^_)v3J$F}a9249X0x#nN8X6zUF4!`g&<Fu-%ZJ@$r#=eS
zhML;Xo_Kc@wn8XR;_DLgM?U3@D_jIFH$En0jrtkO2_$xZ8`!HLf*5%?&d<-!<<ixH
zAb6reWpCB|j2&=-D@+(&RcfD&N(!W>1}xy-S@wCF<|@H_AfTU!|0M4JW9u#BqVC$h
zUrGiPNkLJ%LmKH+x*KVvMY<aXL<JOtp<AT8I|eCf9GW3UdIpe&q4(eOxz79E`+D{p
zKfLh6Fl!xa9rZiDtI@GKuT?QPC%^TgB)VSGYUzt{2zZLrSx`Xu#zGt=DRUWK+sQpH
zwR_-11v1au6Z$zDm&i6w^sYxBpAch-^P&4)3}9t%FV!}J-+OuPtr6L+u$r-)>f)3H
zq|ILN!5-$1Pj=cX-&LJ->wpMM4L)6^@yLwDXH!2=R%H2lihbx4W+#uIe%2QM#pcz&
zONC1|aUtFYF+)x-pm>oRgEN_dWKWpY1DvSW5X(TwBInXk%u}dI)ow;ErGWy5ePoC^
zNG&|uEH2YgJ*{I47JKVZFg%}(^hO71sQ-qRvkFo;_HL8`7~7mD`;T?$VP%QRe!ia%
zhF3sxuCuw}H#Gh+pi&B=5e7fEsKzS@?!C?j;<z>Q3X`|mlpGA6nRjyjcQTicVb#pL
z^RI`^nItWqo;lW1GvJ=<s>hDJTZ6n&nz}2pI+1kVG6WU)A_shQRhK9dEQ4D3eWYvD
zf3cWvLHjLK;~?fd)QY!pLT89$Q62Ha$EsXo!j}s!>C5_;<nu>n1=5MjbRFs_%ZNQA
z3luAUWAYy+?=Jt+DO%}9k>&(kg6lm33%_99OS|b~jg38o(l6O3<g<QJ)^|I7yL8hm
zm$oG2p3<IL#|Fp}$DI8(X^t<Q+Hz^@KxgUig}40(Gs}?C&F#xr-N%w6dnL)UBY%<p
zAmH#Z5U*Jl1uEb4c9S?3?IcweO|8xSn|Q5M2DEj$CIwKT4g)?bzK8+>?aP9yC8>2G
zZFrFBTl>myM<H)%hYCuY;*yF~n^G<VL^@n%pX*>@3J{$UQqB1v8aHSL#pG#ODC3`g
z$HNm$$6!S%2wT_%iCp<iE*ii@5CH{Q9zL~~4RX>6$qZspd&ZaKK1EZkzt2^i4NrvO
z8<@iusQ1+oja>$B;hCRIN<+qz3bCy`-2-ow1LEt|@D(oy^ok>};VL~e@O7a>UEIK8
zt}%lQzYwNhjZJTJzBe2y!-De(v6?HE`VCaw{5}*`+*16gD!82q2Vv1XpR2jXK-%em
zh+no>%@*AZT!~mBFnWL2c0abvqTDSVJ0@?6frrLj*a`OE{?ScQ3YPG=U_9q@j``P%
z@V*c0e+8UV@;IPYrI(SzzNC-x4EcN|_;<1T#Wl_oNJZ$}v~*@O>Qc8;NJJ*+t-B+|
z>>h;(z%vb!nsrV`%}4Wr>fkH=6H3@#K?#q1os#n3?3UBCaDf>MWV)6zh4%;>9D)<{
zL*}W93`j?O;l?q~SwE6>bNb+(tddBybj3aC@yCTb)@?6!<~NUSR5HzLAPYyt$nN<m
zj*o6q@I|@3H(QNaTOFjkd(Wjc;b{>dmdKceA60BeG7}nSIh*$s#QkPi9fybW32D%B
zS(WE`ovV9HU9h3=`9(^5*XK2T-4VrgX?_dAKLSFL8n6MSoAsWx{E%8p@e*v@%~fa^
z_3-j+qu*U%{uo?SAV?cE;8>OLaGp#!T~UFR_+~saM(-SZcof!L#(gQ@7*6}|kuQ8D
zv&OKJ1;|qxh7Jp0ocVl(YuDn`BWvrVgvR@1z_imEl(uG5UtVDL-r9i;97+5s1o+QU
zs2D&My-<aCMkr2S>WV|its6;{WX^i}!kv9~ivwhoB{Q@PjyT`is+~8?s^}E;1d7U(
zI6<{C>8j8%z2V6M%`u?88XBxkywg<)$;;~ZDNpvO$*o;oU00Yt+*nL*uAAGDaNeo~
zjZ?rMUyVF}`=^Qr!<_rYyPWHnt9NH+4G~$pKC2+eT;b;_O;Pk)&~faoC46_}juYsd
ztpyPqsi)i{+<g?{T`A1wePz769oL<5l|Oyj7~o%OPO&KA(D23Fb)arm^fjXB(K55-
z>+4E``9HJqT@;MKXz88cR^BvA%hH-O!v9~X6&MT8!88$<kWib%P{}%z+PVu%g=H8M
zN8<KSWTrM{N|TCMB=ybe;kPQ;uSfX*%-w>;e0rNmhnot+NrNAj+~v9UwyX7Z=>=p>
z%_^QK%NEOwNLB6t?m28>K#B|tL@tOc{}PJhh7hc$-9{k6p_wBzWp9a^Z`m3mW_*tq
z*mooTq~uE{8LPA@O@JjiRZFPbi|h-==WO8Rjgv>j(;IK4NE})%LcOGXo|sszc->j@
z*2znT&~gj-#J4`oll%j#=b;E;JcZCEH~Xcgao)~GFq~(276@<j%~v9xIv<%jZ*>aP
zHg_=7xGix>%8Jvlc{}3zoD5(<ZF|XZTuk6(rGw>h0l5h0_KKp8Ds196ZTs&pKuA~p
zLR!Pm;7B1#lSSOhu1SY7#P5;Xklm;Rrc2K`;*yy2J4@3*(<=1c$qdgCH)F%nuk3WW
zf9r8<31R(;hf>=+dSmo}3DT$<^;2t(?Dp*k;k}QT@dpa<5(a?l(Hs-I6}<7$NBflw
zlmb1pZwyg?Z4tk<QH)L6r+3tXJWb!crnJh{{KR{AgX6RSwv+#Nm6d+DB36SLH$l@<
zID{OI1kr%k{-7j)Z&PLc3-ct6|E{|I{<E`^p*}Ip+m~>5_VdcKb~TH{Ac3ags(fS;
zbv@!#CntZ2Hjo->-dHe|Fyq>hCO;4IJ03)lP0v@&h;lbEH3)w`hN7{YXR9h})ags$
z78{rDrx}U2YLUCoN6qD@bP?i$q3I|6*&Ci?n-_ry<k;E6q(f@;P=(gE6MvYZve~}-
z258~8RY}h4iw{S)9RganlYY$c(yu#`jv;b6>1i1kTvrTZw0KQuIAMpCxa6m&il#+-
z$JC3$Wr@yu&Hg47BTU!-O188fVSY)go&Cbrp|MsNp+7bcv_5EZOhjoPyo_3PudTY5
z`G@(G45SEDC!H(%RDvVq%jCUBus|9Gu7(|ED@{tlUl1AgEG-5TE<YvkY-U{-R>0We
z4mZ6mRfgifSVz@QN0$R~PdujKvNLu0a8)D(D1@QYg=3R|n|R@F+L1PA65S63NiXA<
zn4vN?-<+!=3cmlAYH=>&kkCM3zY{~B%gzw?sMcp?^{Nc{zla|)Ro82@2wr`VsGeW)
zCA(4g%&>N^Y=OHBvKg%Nb5|cFhE|T=E1*#d)UtNJ*~Pg53!Qw_e@9<Ci@hY7Pc-r{
z`Yv?`<t;qCtUB4c2~SFpYf+&E_<G!5$UNpKZ#E}uCpGaua}B}$TewmN#{B)o9dAim
zT)ulfD2br>gB?-}r5*E0Yf`F8GH1MrIuS!^CRz9lv>y#Q&9tX!Fg5<VQWY}9)l6v3
znO{aA+Ret~7q}njIJCOOOKz^+{$Z7Yb-F0bs&+93UdQ*0gp8giy{?*)#hV?M#Ul#%
z9+LiCJ-h&ZE^X^qFz_Abs4n}TZeKc(0nvHZvMp(_WO1D~FIsm#c?Xo9;$?<zIXRki
z!PuU$QfZo9W=NC#KXD>&?|ox9OkJA2-xc4fV10HxtpQX}Qd>|NX4dSdd`HibXF8Yp
zbb3t4nj@xpxALby!PqMj+wXjVD~v5whMX`zylg6K*Sk8?yLMcEN4qJ5GfsK7WOuh$
z-03bvD7I!_$(Eq*Tlwh?%Gh9@+kWauaYOp2&wiD6**&78BVip>Zgftso6KPMBO*L1
z5jRU{)%<1FQ}2e{$fFG3YMBckg-v*fJh-&XOny2g=s&6iZ@S!Lz(X`9Np2|tBM5Nb
z5`kT-G>_)~&Mf~`==OKb%}H0oOA4Tc;)5Ho7?-G-I|+_B5tE<PBo6@@HKmY>5WkOR
z`e&?=gPQZE7pPoEKYef2CJ#(p_rT$-Li*hiWwOpKrXc;CYff_7DO)JrGisv)M0FLx
zyl>>$X;i)tfA6yBj<Er=&G)O%4OM8lMc+Q02l~ly$;p<57K<5C)pHBai~#8|=Zu}a
z{3&1#%7?OTfBiIL2R%U)s6D(Ga@(cRK^?=N`tO%=X2^91S{?x}98d&|Zq*(e@M#G^
zV!QvHrtE5A6bO+Gtj~|Vc3*3jbVbYr9G>c$RyhD!gQT&9q(Sy`NUZiV5|Ls>xTX9s
zK7q$-WBY<0KnW@i4+FjNZ;20>ne2#Ncap+&x{zY}HxC5jonyM(n%6$Qg)ryD(H7uD
zm%Os0X{p=6!O=Ox0VcE5CL-_8M?z&ozUyitpql+x%Kkuo1X%+>S}v~HYrf;?445gB
zXgUAu`~P$OF3|y49-qBTu^u4kX>A3wTooGbJ<qO{MM3Ilg{M#8NjE0>A;vx}UX?}R
z4NuuW0n?EB;E1A6H5NOK9f?rzKL!T?0}WA6T1*E%$D6~=;zu7n04o6Ek%{fi9>4$k
zz%_u^5d-_^Fn*lhrlR|C#E-J}GzcHK=`R2=MQY}oF1;%+b~oOuSdZx|YO4bx0Q3~D
z^-Zn|V5^xIN%>bU6qZ$ScmVVjkvUnFzd1<4iG+8wlixkSFpR^k#AN})U`<a``S&vX
zKjIkT*YYxBUAuqO3f>~Z#M=z%IRZJT>bcKJk>3EaU_hM+S{eHi=;%JjAvCD;LWHpr
za{T$k0f=7z^7E+wA{!VVs=xRz)=)ms>dO~&<dbA`t5(9qSy@^P(9YQnUIlPH!Nyt8
zZneL^r*t0z97w&iV}5Ez!(P#ffa7WmtUWs5H&X8@asBHA|0C!AtS+NLabZlsX4KN)
zBV~ayBzLzzpJOU&e1#%7CIj*4UoGaI(YsY&Qupg(YbaQg(7DMVEXxUX5&g&-{)bdH
zTlHAO0QS!71BPtGnBWWY|E=5pV@cI4m{_29{3U)-S#KyTszUVxlz`geKvZ`|eu%#I
zr6cJm135re156^^Wwz-jpqET<6fqu9`3IQD!%gwh@-J+yf30uk|7Dnee>7I4%Y3fV
zq_e^O^{7|2p+W*!60PNG+v#)z4J0aN-dET(y%1pHMFdaj-~pl1lZL8C9cHcw1RFJ@
z_fH@~7xX)Fl?J+_d#=`wc>mLu{AYPA*}!hKY|L)Fi3aS?fN+2?SzuS8fe4J9Ey7lS
zP00Qp+KmEZgN`W(-}Ixb03rw52hJ9sOkf3KeKAV^onQV}FP{P!usK80DA9eYkr3Wy
z{$Ul4*TM0ugeq2&vV8yNAUWTkXMRZaTpwQ%_%8IBgY~a~`Btyuni7uxsrml1Utn#3
zAoC<i?>8Kn+ELYCP+cduN?Ir?14pd&As*_iOpgi!af+2PHYjFVc)w&WTPJ$<PE+6P
z>y7Y>n@8jUjb0!CbD9Xl3VwimCbHee{Fe#!4QGa?_1?386P*8;Z<x#$-W*>A0B7iU
ziHe)xPGQ&}`;>9BOAI#)sKgd?%-JBMN_5q@U@on^ZGOAiHF08M(=DyKmw8%?SL#4o
z5(bUX-@KZVBD7oj?&W?@DA7D0Ra#m(a+{HU+e#qvI-p{zyIdp4SMIbtqgis*&#k#o
zvmygLhYe;S`P8ilaq2htuX9Yy78OQi9kiCqH1jGN-#)c!jVGy}3{+ROPgxtfW(Ze)
zXJ5gYhg?hQB?Fm%2<@>PO0nE$B{VNP6V-I?Ap=RcYlUd;TC5^b5JEaSKysIgBT^EJ
z|9SMk4w=`Nu*@)%(lJ^HASxmQWi|Jh0e>S<Gat5Dv>2xMf&8=JzR}$)s=>a#B2_?|
ztVTC?XRy)9LPS+wcCwtXSDY_$bEh{wZ#koD+iL`)&JS6I29uQ}1D4=;p&RfD0P{FF
z^t=)JuifPbc9#uuHc|US89omM<Iihz(!252w<Xrfo(zuR5++Ec;r=B~!EQcKyhK>C
zF$n!7o8dhz|NkMIJ&}<iG&a{43{$@s)AN^*DC?2CQht`!vDShWsKN#F_6A6NDt%Jr
z)!Pt2rWe1k-T6km@lCL14$xcdQUJv2T|(V?Pyh15*7~~z|7$P28G#dPz*YNl25k*B
zBcu}1S|wsW?v<5nwR<Y!*RZe|)SzyU1#-ax5izM4Tzb3MEBOM5UohR2%$OFO$^cuO
z7Za<26}Xem)Zc^u>u95Zo0At9`PGETArKyEUb$3OSwOjQH1{?&cvAN7z|+YvKro6#
zWrPfbvN9q6vH)gR|Ng`BTJP0gSkW9?>i;SY{yEaQe}JoVsuXAjbz^#rE$5wS^B=p<
z7#kUX<%@!xnQ^S1>PX3$5bu!GsRP$jDUW%s5TN6nF+Q}QCSlAV|4U?)wH$1e#JPUL
z_-|wTe>zmePts)me7#Nb5m7>kFV4m<P=3&R1)V+Hyc0x5I_8YFJ>uo{n4Ya-Ggd@q
zytv|ljV(_9xt!Gsf|OpZ7sAM<gl_-z^EYWfbmr>K&(}2nhIOry`7Zy^f-7H*pE?ct
z4HZ)q*Z$(!%iIVYKUi+W7mcL<ve}W8Fe>h&DBJzLWn=#=)`p%1jh8MOWI!N;7XJ#7
zbk~Xp#9Qx*>Mu9`4m%_E^J6#!K7^~&U9MN8ODQ-X*EoEyL_}S3obth9QPc(91)NV%
z#+tw$yc@PO+yG2WZyD#wzc<6b7h4+6Iu0XXCxs8}0YX6<6tjw>v@=d2M-6BmabIGr
z&OT`{_bML&>K$If`aUH9u<Wmsk_}$KQgxIAoaUFO*t-Aajs$_TXL(3s{CD@)A|c68
zOiik(0z-uyVBRw6J_Y)PF%F^MYA*N9F#)BApJDiGZ*VO2DGLJoe?*r5yD6!k!ZM$S
zq_ks$ggGKol=h0x8Va-CE4{!8znjzxI{OmgI8t1xcdFQx$JXh7;9}%q;XR{O3yc6Q
z%1zQ5z|p5h^L#HSvzou@pPmX+Q?Pfa5yXBqhj=1;Cn-wbWo>9tHVIx@<$DV~fzxRT
zV$#<C-<WS`FV5~Y1kwkNc$OFi1f0>45aN$>y*677)(3zhd=0RTtt1m{UxQFD1hgvB
zzitEoDh5Am)#Oeo1T-(`33Aqo%hll0GHg&vbObiYP?cKnw+K5P`S3Rm=?7HB!Bc8W
zcy{_DnXB*Aa>;%zK0O}z?~__VPsgen^!|*#bV?Mql>eJx4baaepDiu=%$U<JS&UVi
zl=6LV)tTm53qA^>YH77oQUy9i)Fl8m`Tpr(Twp;~z0XWQ>t0@KWmzjA8}*$&)kA9N
z%x0|tk^l3evTMf0$8A%roOT+AFPIQu?Em|405D2Xqtzr{!0s%OwlKGF?;n&RuAe5y
z>9R%U^o@K^qp-UuKCluNt~9ZX{=x)|2cVlMP6=I!e|LicpPT?9pb}};^OjTzXqXyM
zi3M`M8mhu0P2H}ONlz8P8dlG8(b0Ilh>E;bc8dSeQT@lCEhxxnB>SyeKAYZiLb|}*
zKDbjGt4AF7c9(`+XuRm&DTpb3dtYS~9~dIW_~8so8I--k=V^k>j2UY-nd!~;mF`HY
zoNJkB#sjXVQtTgr?c#p;6*65)XOFCE<(TggSjHajAYax#Jw5urLO`~UfCV0MUs#m(
zMiitd_mE8D+gpm}4{$`X5*kS29}_X0^T5y|{J|dOm4XdlsCfZ$o;6b0BeUzLsJJCv
z)LP`@27{w8Ak?tXXP#swG_}99z2MppdAvw8c~XLkAq=+%M;wiQlf%<f1kRK9E<5G_
z_v_2N!~Z!*TJ;`K;S(bZU~V`cbQNO0lKzF3HM-54xlgoKqEZg;R|vX&6}#U-sY3$*
z{gRdOsYY-JV<}?F3aB`N3{W`^^l|V51jwbPNFSN7gGKQ49dRQ6hXn{OBuh>1ksl+V
zdaJ%qFb70G<q9$b1M*^xOGREL6(YK=ZGy4hrjYvz_Yyiww=o*VN2TJtkyQDY{hakM
zL-H027%S)YR}LVekA!h|l{!e?fc6bmOc@A)9({uGc8UPi(5-q4kN$7PvS2E&lP1C-
z0(rU#N32W&lcjdOe;Iq=w`A42%;N&8F|7_ihutaDtkpMcko7ySLjHP}A-Y^^;Oc19
z^#>eLim^`7$Ovi3Far?E>LU<-vUh<cUG6eD&&xoSMjB5=sw2)I%e~flm7gQ@41w_V
zEQTZHpO*Ob-a~2mlzY@=f}d;YwFJS<+gz<wM<1bDSTuMJ-^I?9<FtbEWG;z|-P=xU
z8WZHpPP4ernJ<SXZWS#kql>Q}9);|L3vAuw-nn%y1uTq>ebBpkinqTr<yZshM+y0&
z&e=_ZzXesD&?K#Gyi+=o9=aT+3!Is&`Su{;(m+2#Ar_Nkb4JPTS9dS>ZBb3}=lWkG
z{g_OhIE4L}24js<E6pnw^paXzNg3DDPrPV22J$^rfm<DL=G>RE1rP62c@<ie@{o!=
znG!EG`s414E=_g>(!>{gG9}DppEN8yY94{W`Z!)Mr&1pkU2`y~HDrZdwWA#NK2OHo
zp=~;hgPAi8v$i=Q+Ud9E7ok&>SJ(CF$5Ix)p%sB)Cm}5^6<#2u5KO%wgms?<(1Gr#
z&Z_G{j4T1CyJH4hQN3a7JZ*wK1G?$1iOcjiy4lP0f!8%qBjq?&=c}9+7w57`ryg<<
zZIFw1^*5Q`NZTcHm(s1)OV^b$FY#^(vsOjI=`FFiIH2H3Eb<eZ8I>}CfA=i^Z)7K}
zrV4=S0{~P;_q-^mw}yX@eM7xyQB$|3YNBPNYH2Mh;%Ff(L4^gHTW*7R)Fg&UZD~)9
zmEPFXr;+TIP|@lB!jnekPFCTzJbiV?qI6+YqjofZXKH2P2bWi9O@IuEFTvHH-+}o)
z1j{9zUQMtUa#TzE9XTC|My>q{4^1bIY0qWOWnp4B17&$ngZti|B<&J<jw)IlUOQT4
z8(Z#;n3a@avbnLm*}2PwGefSske(24PUQFe(Cnf(y;iW-qr*F~TllZo@4H(e2aHIf
zeCfp7rjvjYY=WjC16pf-Wz+=v_IE4#HJiI-|5}8$=r}a>t_qIQK#tpfjQjnC_;BdY
z4?Pq#X?#3JRcLV}gxxL_&qReg)Vy!d?oQY@UW|7e$=^GWv7%h{SXi7kvEH7F7cUnD
zpbhpKMs<)h7mc_3Nqtg02~4br&TYPQfH<ynb6}``O}pit#s=7tqy}ZXHtKw5l9e@2
zG${*^otn0E-p2TrXmXQi1B`#9!ST>PdYaV7Dn2e)n7B6T4h4jBsW~{B2Kv6GZ@fd<
zGtA2%r(M$%jVkIoZIZ^gXq$^>m4_wvzlUvSDs;rLg0`x&g1Ww%b9N{M)SdVsolz#C
zdSaZbs0WSx;x~4j>qEe2HYLQV?Df7hV72^cbCP87PV6%JDr)*>Ah?fkbvj(bd6%=)
zzJ%ce%>(>BM=+MSaZ{oTXK>yLJFEzRhAG)b+6BqJ8$3!&%k=guSS$Bh$hgR3WGb8#
zETsP0P-r!<OAf12?c(Y%4yZ#RSV{TcdaV3}Gd;+4ymZz778-wclu_bP)3tf+f;@zg
zuRe3uaVjC(q*<)L!p`4^&<MRTIG!Kfk`jLrl;Yy!QYPM1Uu%WtAMH|IxU$d`=CrzG
zu|?HvM%I24@O@rdi9;B@t$sW_x%DFM6;H}-!{1SAGZbXLrGJ2HP`nqR4$KsW$NW|8
z036v_J;f4dDdf@L{<}UP>_`w_`nn2R>wdc+lr8eQ_?B|^-m6+*KsjADH~K-f-Pi7+
zANajd=14-0-Ian)>&eI4C7!*HxAo6;#p8mu_8Z0U=lnl@3R@V(-c~K}DV#@&M#)_%
zh$+)d&e^ALv~?K=cPE`~n2YZ%UV%?kN~l8(l|w6}d?H{*hj(%UUkK=a`slN^Z7-O6
zqf4hs?o=yv4Vf>EPslu<%oqkO9xiR%vEO_+d0KKc#HAv@_f9>v2~_hF59g9^vUaaw
zM*{{7Ot#+YJY8)(HoH5#)0mtq{4}*;ywn(fnS_tL`x*RW>lcq|C_{%qaQ7H|H*euB
z<nqG;y{8uYl6+wfb8z_7fLf04CgbLoPhI|`fU3bwzgW&4*Enfc%%VM$xuI%&@b571
z+@5X<Rh*~amjzUd?w*-mn-L9nMNh9pstd%RZa7V7f!T<=8b4FA8#)s$L|hKVf)*-6
zH^|r5K3j-a*WIFAY~{OG;3#*}ANmG#Y6{I(ZRB<0OS(CWN|<^1S&R1GtG{z_DqGLA
z@ctGEo=m*pFrgYyeg<fXIK9hH-kk$H<{73(ra0g{9=ho2GzpWJG9W!_LxGR0p85sj
zDtl@tZ8<wEd`hCGAF=>Yv7IIP89-r-b?N#DA1k{M^C&HT8E>mVtE{V8w6Jq>+!|A0
z@ij!%u_$L>Vx;%+yY%9ltjd;_H=gY*YdrN(4Oj81AKwz4do*WQKYz2ZIJBJFdV4pk
z)ACBdhcMLqQWDq<XB7c$3*<<aq4t)$P7a`a{yK{DS}-(pbpQF18Bk}Bf)Ru8pZl0b
z+CAX7bq{sFs}2y`W0an}p4Xw(49N>vF0I$@j@a%|5spXNE1k#px4ecFM9qt#kCfdd
zeg-R&-c7?kKPjMt7w+v&nG_=LU?<iEjlq?O1_MpAysS=66B<qv38~lShAx%C^<^+$
zhZ$e;j5PmbX2Pd_YHo!mymj|8hWK+)9(op7AbsH<=^Gzk?Rr$8Y!Gy@CWAHI19ga6
z7QW<1>U3i~67JBl=;%N1zHjEx5NS+n3~V>cA}sX+oM!Q`Ix!UJw8X&8Pjpbe<oof@
zv<wG4P2J#W@5?oyv89N*%XF9V`FYEStlueHLgDO|cAbIKJ9`r~bx>cyfQg!v6G`AE
z(44tj(?aGb@8OJPa;Lj6?2F9Gm7?fH!7YEUovWBDg$2VPMbv|QnoM(+;I7NQ5E!+f
zWT0Zp)t9Y!O03m4nweRpXV;YzCkimhhMB5PzJYTUAlA!;-l+-*hnC%Sd9NZv)~scz
zbQcw!>YPK1Pee*~PTou(`op+Px7wHAy<5JTHSiFB%<c{C(R^c6>Nb-Bf!~JCV<=~}
zTuA&5>$bKj>Y}zT$s6w%MakA~95$9Pi1T9r`kd0erDgqw<1eesPMk~UW!wAKtLe*|
zrB%TACjue15zu^6=KtqUk5ni91{vO&rtYt;l3<#=Go#9>yZD)yyNHC{*SW~1k{|mC
z{fD2WjMRzTRy?0MF-gkr9ly-@c6OLr8GW1;!=tZf7z&40akR?a>r%TsUc@*DS_Q&K
z0ft$<?l2!J_M5K@16%xY17hyw<*k@(U4B?uBFz+W@uUFo?XiuCgGCqC57Ni!0-mQA
zUmyoG{DTpXaIhxn5Fz9m(&8V3B^n_x4QZlJ!S;Jd*tqgaG5F*D+(<Y`MPREanQ@5@
z(HVb6KD!Xy+sz`K<y}2h)qrlk>>n;5nmyT-PXxB1?YR|kH<q}BP_mS&#P!&Dm68Rw
zH(mc-2i~JON{d;~1T~Xai~Vmge&5xd)40v*O?OD+yuJTA{_@Aw5loguTf3FChVkiC
zu@_TvM!?;m^m)1x$rO{}ckS=WS~xg-eO?{fj2#OYB$x%loD|Q)iWgUW$8IG@uG%$4
zw<H7t$3^RAw(7<b1?pxOx;oAlY)5zLdC;kb(Rb?CBpVl6hjs*&eG9=3Tzs=$S(T9R
zIq?h57j)(<<&DqTEb<;Rr!dP#3~&W_Up<zPWq56HAJtBz1GucY4Hl=T@J`KL3?mn6
zF?!9Aw?2q4Wxh|fQOXPVqj#mz<W64Fhx6!eDfJHpjkQM=3)0$8+SSzp9|^G&-~aUz
zjNKFwsW;4M&<FsDCA5e*3;qComUfFy7#MruJXgjtj|2*hzyg!v`60T#yx*s@3;(`z
z_H(ij6cs_Eko!2R?qeMsMe~|pIV!8hR_kTQYkDd95gkESZPxWc0;^uN5RIYy96cgO
zVoaw<S+Z`Hvzzx9Gz)jR=p378U0mk$;)jzP9rfgIwC>I61RI$QNGOjyyLV?8l%E=a
z8&a=a8Mu(;kjKT$<Fu!UmvH?ZE%@euluxtdVy~dGu_K$Q-5?;4e|pP{Lwt{Q1jo!C
zn~TsxQvD}d9sBx~OYO)*X1{T!_A()Z62%tBEq1H$k1c~j!QXLwyT?4YLdpF(9ssoC
zw}EB1mPZ?lUYJ5Q<*<@D8yV<nnpka4Dgf0^BGUYIX2nl%M^_q@dZzgZ_hj&`Ne|1t
zm-Kl=YLo}Ow60WC(KIFHPIZ~-#yaM}6C)L{iYx2|ZV(|_L7OMYwkevi{w*oE6w`^n
zTZxnSH36omMuVq5$Vt*HP^L9R=PBBdE4d3TP3(YyiNdC~V!3_7bS!tlvP#x>S1Q)~
z{(z-aG5h4$CjOQXMTs?cKTF#wvS_`AT#DmPiZ9~IForg=V%yKoEby!-E74U-ZW9AO
zHnfkwsu>gaC<4@tg(5_&TZjG(d4D|}0lKSP^L>!hQGfc3-Hd>PPx)T3{Ph>ds>OWz
z+vXpt@X9m8&yO1klQJzEoM`TY@jQG<o6^k_UGb^EOsgkoh7oue5yl3badriF4Mjq`
zxrW3bJX<VyC<wpgs{#ifGoI?<n_l~pAmI5IJAO6)ETdb6D^~mn-CjZ}y&Fzy(1v`N
z&pa4A*=z3|0>dII?wafHO9R8Ux42FZ{gz9|7vS*#3&-JrHBQfP>e?fE-Y*gBLEDk}
z?j&wo$5AR_%&&7RH3N*dus5!SpB7Vffn_Lg4kjhE$9l2IesK0?6NhA<rJY#6{4nOJ
z)kOl0n{nPS61z=BN7TmI|I}zt4xPQ(OHk4FXXa3chOyEM6L%@#-^QRdd!KK~Rfh%i
z*|Y|?`4lDpWV{7KNwJ;Kr>mh9LR~z|PiXVjP!ZKmZ8ESZ<)<?~U7DARU%fc=&3`U6
zJ!l>&h;Xw)ib=IMsohOBq3%n{itTYPRku{eiJm3LG6#KkzEt>qQfG5qf8N3J1_;<(
zjKcN+@lV{4L6eT?=|2la4X{Au-@Ep>${}(;cK{Eyys_}lj)nqN&R{NG{+lEfivee}
z`$A|{5HmPy89j7MadWcSzC(>h%6G1adaehySo+n@k%^co-s|vRx}7&O6g<gL!8w>!
z!xP}8_jAid(@v3ynqR;6R!F7Wy9Rpho?2IUa|TaFZcT%l(NyyTJALJQnqS{?I7bFy
zx|R~PyB}&C&adwES;{JQ@^oX_dcUv=8^r;=J~$&?@kX2c_6g%<EY4rj2*F+}gB=f8
zot#^$wHduNd2{Tb>_y8`b|C-0Mfy(9Y-^v=4`vx}VsZhm6*fR=YLb>)b7G}@E%pxH
zB!xXWH*mtwD3mf6c43$d$hp?WA#BxeuH>BCyImF7AfpzcW0O2($|whf=%oaTh}@u(
zaX@i}m828eFJxjqO!1=lV(6I3&Icfh491^G;7zQ!(*ds;9fv(CVg-RKeGsgm?g=j@
zoT(PQHUo7P-nVrYt!ZOhOkc%ms?u?6Uk#MVhv7?ygVgvBW`>oma9zYpTxvo(e8feO
ztS=(?8KE-KU<uhm=iX4p&8QUh8uC3~)S$<S(S3G{b~A(+)Wj)=_*hQTpE(SR;@3W9
zyBQ`0BAnJg4ZZdwE;oTL$WKRZOI6plNN4rwp>P6!!6gBDIrx2?C2CPeyzyN)Zk(n_
z(qeO$+_MIIonEozsdwD-iCdeO*kkIA`x#7gve-Gp6{@ToC7r-1p9%9?>lfN(3$;7X
zcS&TfV!tZYB&Xp@dtLgJAJ)D^)G}KTQ6139tzd)H^j6pkJCjiYNe!QlU`PRg%O52A
z9`_;L#57?Lwowd|SS&`>co!4$lWrE1m{Jx=ax>n292EwHvNX&4G`btb`Hf>OwucTZ
z73SXpw8Zhy56M|RtuRTMHU3DT52;;*VC*T4e=R+#i#_Ur3q6az(_*;T-Y2v=QoDVk
zg<BDg5iE0!=X&MLz*2m|{kzHNV-TLEw@TKFwKiOi%zHn*{e;aTDg=}fo(~phP!`$O
z%Y4enMc;=B&fw|JRZ>5H{w=$~E}`G+o=9Gy(z{b=cg@T7#rOB6Mtmq_HeNx!@0l!F
z1bsm1&|-u1rA^NKYkBG1pg8nf657Q}xu5Z-utA}W89~go`ceyfrnz0@uM?_F4dKVk
zbXcH@TnU{#?@(e_s?RuPri;ut3=R_ou<aCX6OOiVV$C6#+$rogduK3;)k+!wZ(>Mg
z;{U$td*1isY2C+ns;p`F>5eiz?ppgKP>NK#euHe*O(b;7LHrP#V<RFAQ&W`x@Fr#T
zj?r9G?doN=WcRnFTv1}gs5HxR>NXntu;hnF3OAY<3C(|WDLYFfG!189W-%yvb;V3A
zX06M?>Gh_<)G5RWR)r&_eBzk#r2y{2p_<*hx6s_PfqsrO;IH<B9JCmU96pRo#jzND
zU+OaijxaeruUYk+w4KwlOosk!c3<kA-Q{6%t2RATHBsyGLMi)aA?@GY+1R3)`1aVG
z@4<7g@kHF9{J}xvWpUsLP;o@<;BjR4PVZqqScXl>I}}J-E;(`lDNXlF{9oVcCmP1C
z92N$q$v%cr<uBAYA|GkCPR@G`c<LNQjCF~!4}Hk)kO>=PSQeRkeT_L?Bb@MVx+x9w
z;eaeSjJUdDxAbPxhLZ;?X+48=^l@D~DK;Yud!x3H6oXwD4xcP?a1$kW{rnTgjcls0
zKsCNoM1fx`;*|vbPg406asiC*)ZDV-4<7H9CSJE3jVONY-bSu+2aQ9;7IF^k*jr`I
zsC{?2mdafV96r!GeZuEvc}z__T=D9IlMw4m9~yAPCc=q<8P3_*-j&+)1SnrZlGX9H
z1D>7=>0AL1Cp{8(laXd(lg2{pR|B<peFNFEw;87;C5x?uj)7o)r7pArpTBRYN}DVt
zNh%<k<D9p`A>^l!`DFYQ%WSWmhs)62mzAXW#S{S@k%r2u9P1YcFN@;q-uF}aNsC@P
z!w@qyv@=~u-0pGHPnV|?@2fzc=@>0d=8ajUm`wb+Lw_1PL2D8yyJF$0Y3wo-jFWW9
zjD+FYO*|2NidFAyUinEFGYumk<cOa6u-?p^E9(jRrIfJ9(D^Xz{WvkpbglA5FE`uZ
z?G1Y?3jcw5+PUT~{_5JVIWikFkRmlY>5Fb5{IOP_P!Pl>@NHh|gb`4#Kc~1)^<+|B
zC#vh29P~7k>HP7eOSzWl=?j2T#4Dl=s0Vz2DPyc}7+^_T8ARB}5_9H^^6QAR9U&8$
z1_=gT>UH(S2TX^r`EFPj5DxY@FEOK`vX~REYy|MUDvy`d8X1ye8LQJy;F@ZR!1IxA
zy2#EV5jNs&QmpI)>*0m<>1TW>UZ1z&WvYIsMvvk5J3ntYWQ!_WDp`OCd=i)KqtX&>
z!hTx1>A=ZLmhl<rG_KlpMxKE{gC7q%@Nj=K<J~nRds#w<aX9rHCm!HRBoTVsu6Cbw
zws|o)5O~WAqnPS@EbDMxE4^L{pX53xnxAao<!`dU4=PBnr<oSFJa+iCkMvw{2pzCp
zl2+9|WM%M&Im;vH!13<716feaz5e@2nmB|2T>lq=A=!qqF^DikS12mfay~+%{#DuA
z#RL3}rc0TY#>X6QgMbGup7#6ot~)^%eKJLsMV^pAo7)MnXdDvbX><Z3WgLqK1>Oz3
zB#32c_*FQ`cihUDhJPPNEF6O@BxDT{jC!&UC+T?k<qv&WMfIP%87trnl?HNDR>q%r
zK`jGs0t-`F%hNLRH3dqXqxJS5U9d}rU(fZ|O@AO0v4ldBbXK}Os#Jgcit`Z>*0$f(
zje(~RVN*-+b@79LuPx4vFpocRW-!Zn{}2h3u_epl=CHxD7lt$oQoeO=7o7)D`;?!<
z>Uqmp@*6tzo2VIMq1|}s1~>N8L8%LjJw=4&mlqnuglOvp&L9h|5S)X(L_mJjm7D{J
zA_k9%7#WMNNkwvlTeO7NI2qk|`J=xqTV^o*!lM$r@60qqfn|nlZc6G>YGTAIt|`T}
zU#Q)@Wa3e`ksBOW6>(d>R&>G!6VgF-*Mru=3OKfzs`Tu&Gf;sH)LJ}x+r(IeRMovi
zv|j>kK6;s`lOqSpX4EL0OQbc)>kP!OWiAD>ai(0fu<>}SG2ymWSfHShWY#{_6Y5{s
zR#AE4eW&;wfSb?W-oJk+i5)H~u1bGtsFi{Od%rOnlH}NHeJqF=C1E-BAcd4A`v;Rc
zm3yH0e%0!j$Pix$*}fmF_SF3Vg^|r6^_=+Wv<7Z41_8m9ItOcKQOk{*{l6>#!PETq
zu^^Drm8<Rtpa<GHCHc3<UZyWJ{p|CG{_uD3kx8(ZAv}iZ(7_#t@JL2F=MkLg4p>*I
z#MK~sVm7{m9ktC@@eFvp#ga-RWRD>(p(bSl*Mcvge7x*dD)e3?IImrPha5tB_Y*5z
zzKRV(%=ak<eXb>OfdMQ(@r}q;$Uw97FjwuH<l^5^?8%n?MSjwJkU=#)sO%_XSQo~c
zbMJHO2IV8hmO};5Hpk)Uw0Vni_W<5Uv-htaCoi~*9yF?_MBv6Hh2WrbD;s2)!)5*m
zTMgF;YTHt*-4xSYeu;o5{@`2n)K!^!xR$BW$AXRJy-4)6ooLtsc!91{K3+D&outIM
zI6QnI4k~*{TJq?Ci3`wR53^W6hN6x;=r&TI-Hi1euPLRBcY)``mNj<ejq=qNSVWoJ
z4$PA@gQ!HoWEn1ikBJRzn!tB{`by?uqWGV3YSoVk_!x~4we{agHZmF^uw(wg4dT}E
zI1Ejn!~SmiRqGZt@A#s3Kg=;1i(@fdi-<>Va%zdfL0Ne=buNmrDITXAzkg)IxwtN)
zEyweDT)z|B42ex>gv8A5>?iDI^nKlX<CeIeGMF0-X@)g!c>t=hf;hTa)gCg^pimqR
z8mI1@PZQW#G`eq-&OhEVdS#%~9bG4QG}>w??_nm{O1in#|B-C+31yeo*8S$&hL(q;
zF&Fl&5n;km2Db^W$)b*4ZhWfhAfRchFY2v2?Nc9LRlciZf(25H!lw$0fxq3uwUx__
zz1d+B#sX1x6KVG_63a&Xu8HOxkPGXkY;sg(yn!VWXn4S)E_-a8wCE;maZ(Wx%Y|Y}
z6WnaXsYIApw%I?dMB}+hhDk{d#1vF+#`B*<WNr_vvokNav#gl2NHIT@*fTkDI5>#F
z4dKrKheYAaF0Z172EJz9W$DoK((9bIz}z1T&DaY}TP#m(|Hvqui9*EPnB$kbkkhP?
za34xWFz4}5;Zsd$ELP^nQjm$biMC}w*H&4S!osQ_B@qE=Z+I+_4IMZ@(5xy@PuSl!
z0an15hh$YTiqY+B-^nKVOWI!9XTZBpx)*w?Dx-mh*Ccp0a&)+G%5FmKcLxDtn$;SU
za^pfMhh2^V8teq#gGz?59D8J%V$=#l;1XUSxj*lce#fh-YdlLb^cMMQ)B0oSCb{|2
zF6#pVGxzXRLLpi=Zqa$x!w$x)&(d0HR0+6(qQg)!EyMd48Kjp53+5opFUmgFT9gNp
z*vUH#&?f&k5)?ySd<$}qy*Ju$XOL+ycHe^s8K*eY-uNOr5JGDKLaY)gKo*z?1HPY#
zjF4{}tAp|(hI_kvb^p_W2cSzMGzM0&>;*}+8L0?j&;>;3(RA;^Gn;A1@Tf2g8>EQx
z0t)&`3e0{$DMt7WFwowp_A=lhW~LpmiyT;vsS?HZKR)87jlt>(zWy8lI4*g3#Nn;c
zVbY(k8Q5P3L)#2^+DbjQ^>HzMO;?Hucd}RWI*pGc`G#Pe1dUCkWW3v>2o3+er{J45
zJt334*9y-r^s!b|7nYOHg1M>f;7)l#JP<+L<pR{FtAp~vmA-w-X5P<4WP+NitQBol
zgB=YTfy&kAo=Ak$;U4J|Rk9bK1GwDWJ|;-11Xa%2I_-LMu#sU+d0!#1>sQW!0ny0r
z!&P8t?R~gS8=%49y@)lJoUgcsg?@_*E*bhpBl5}8fU@TV{Q%kS4mDW;<k+$i{OOTX
z%ZysBlgn3FsXiDIsWZthtcf%(`q(udXnzc0wC#^bcsppaZrw_Jz_c@18mH#7k-3|}
z%~T{UjDB$~Nc)Ui-GwJaHJbRu3dSlnUZ84w@MgWsW+JUjf+=RB#4j4Hm@ug8u2tgm
z_}QXjt7Tk)mm6(}FcPYJt;KGJ3){Nu)5xX9&G6_>p5n2seJ_*0GNI&XJMXu8>7yKz
zEBoMUnfVbep{mr<xAimvan0S<H`gX#sg%beFgk&kn2C7w0jP*S0rT-&I5Xh&62?VL
zr6Qo+Vri#rEE*RD78}rR5}o&*<Tn|3REg~5{Ss$M1CA?z%8%=tKJMk$R$?p~x948!
z*N^c8!O#yX?^!b`MKm&&oQrUMuci(Hv|u=P@d|VR=XpvzncbLPO2nJg`e2di$0URz
z<g><()M|tcr~Gv~K$7agAe3BY`rz;?dRteS_Rq(F$ZUdEKhE%g0np&@E3&Ipu30y(
zbG4UQ^|2p|oe0%!6Wh$Xj9-JPv7hgJUvlbI-1JwW=CF-RzG6Z`nLyq%TlH}ETJwxy
zJD-G6%l#JT{xGE=^4)n8Rw}jgP|?Q5S$O_{+2FW;0^P@J^Pj|x)4Dwi%OwP~^irBm
z;$D;|STV6S370P7(lS>?gJ(_J7mHO~xBny>Y3RuiAcfanonyWY10ImG0dVkmVrRg6
zJx*2rX}nOwWwux-kY&huTL4oOtsFU&ciKu-#BggI74Nw~0{^aBZqQb&XjOh)p%}G-
z??TZ%f~PYn>Z*1u&uQlj-)1xYtk&NiUA5gUww7={jdvQAFWBqtbmLxX^&7j1XiCx|
zY<t9qtOKuiX}3qF4tm3@eZ=MKowo<%gs#-=zH>qn2&69jxJTCUcC8ytdm6GaeCfbm
ztx9K<+riO84vfyuJkC3+miI1e(aDZgY7=4C{78b0p(~m65Xed;i@bNU_vQCtseYll
zG_O<Nhe6yWInLHCLF07iy~MUQv=l1>4lO@*pB>>j?<W@b^le3%-I`VMa53sW_YW$7
zH{3J;Ir;>JhU6fHJ<Dx9El>+e6p_OGn{knF02AsR)ymN_7y3SBA?LPYy@m=149g+y
zB|}mXG{)KMbJ`8P2ZO<KQ0iH!P06E7d`wZ%F59r)-H086d7C`oZj{!%IL=qV{nbIy
z4UN#q28FeB%LwfrDG=?#%a_JTS`Vj=H&?gHT(V0EKY`q`bQ@(OQMOZ-wXawsv%>0X
zvT;o4J-0`3Ry=JuxA=<@HY|CeKbWq+t<Ex~neEnDn(#v6PS5r@s8{GZIS(Zlj*`2B
ztsH{+x+4ano0Qrs8WCo+#X1(sO)>r{#?u}GuF1~VJo9)EPYKy&mO~E7)2#=q@ILYA
z5<~A@?>P=_qKP+YUT=_nfxp;2Z!ASIljpk4TRR2g^)kN=yxT8Xt?NC>T4;P6_4*5&
z_@`VVv2`XmVaRVz<!X3jX26L8g_QCs&PuNd^+(P%T5@R<r$uL?j_!Ong~REy`Kx!p
zo2`5tIT;PMI-hed^mIpALciTKajvYNS6D6h2U!`y151P&-qYsN0oCpde(m|p`NtXg
zdPx?xO{ihh%8KBP#!F5o(y$}lB}1ABzog*|Jq;p<jPG4p(gXB0b$D{$r{?q0g8FoN
zUSW?w@;-iAQqH^{smPAVN?fV%x{NjMH0<IS6O5EuN`7LgC;6w4l$M{G<!sw#Y(p_^
zdrg{!$>F3;Zsy!Ke@Z&0OMF8prozvv_<e;XXfE1&;t$7rjcbsnbIQ-l>v*w}oZ*7h
z-FSTM?7U?)ev71aQW?bHStT(TE7cOy_B{BIwGZJ1LAP09-ILZf$D<fg9b)aqUQlMq
zy~y43IP6?aiN-&WUC%jkyV)>(`(r<El4Pg{RBx-JG4IUNEVq#7Xr&CVQr(nYU6h(R
z4flYniUq5*=Dr&9!SkP6f%HL$1u+Cp3MzN$KHvq^JMv)jmEEZ9zMA^JXLwa~L)I8C
z&ddR5sMpMtzs65vgFYhHjaKbrkhING?}PzIg6272JD&yah4lxKJyBLckl+HJ2z~|`
zO2l`3s%u-voUw_<$KB7}3geO*aR_%go2Favs4&z*O0R~jnX)wwp6P1<YIzui1<514
z`dEyIx_}$KkLBW*h}P|uP@iv5&S5zo?fs>iv~@lhwT6)7b<$DDe<1_KewaNaZWL6L
z+GOM*oT(N9Riom2TW30gGd9@=|3tqVhJgjiGNVkj%9-jj>m4T!tu-+87SXpcX;Emo
z)ID^zVma`f(HvT8JW|>dAnDW@8Bon(wo7>OBji_#PYY)wgFeTqdIYsC>+F@>u!+;7
z=jPlYoll%vVHVv!Pb9R9*bTG&?!KarSK*N)-4WADXzfC~TUKg2wKw7S56*jqqj@Gz
zb6{t|Rtw|SeV}OiaJ8Sf-(fc5eTAA@Qn5+P+aE&TLaHBb53dIHJ&Wp|ymSzL@LTna
zRM()zw(a_@Ck+>Od}tJPOyk$AUAn*)Sre32W24CtQ)9rZwX}q*;+lGk1@%NSua76q
zT+@%Qm9>WP@LaJ#YPE|Mdv8d6lhN~5=VZn+bO||;7*Zo4??U&^U$|+hUk`Gxu(aXi
zk@cPU9>kyra@+AHl68sO$<Mim<ZLI)px~qO=Z3+PoQ|CyCckA(BAszJ<e}CKjf#xM
z8%MZFB&rTTI_+w7VqmOyy-X3D{dqWzk1fzWVN=$H=C^-=R*E^jT>|U*y6kdha>^#=
zGM7#y{=WEdncfS;oUmrm#4l6s5HQ+}Z)^K{5`Qmx+}kWD3AHW%<7-sYTPFCB{?KAk
z;<$#|7@jAKK@C}Ik;?_kkZZK$Z<PzLx7DA_t4L^hT$0{Dbfx5NsWS~X&wj5RYX-%Z
zEFM6(XQ6ElH(-w~^x{wY?{q^<L5BJ73`EZ^ygG<l9^WQa-o-Z_c(-m!IG+;(asUgy
zsU$jyi<euEl{K9%cGlT93_n&7Z(xuJHmhGV)tpYa2>l>DQ--m5UI*<YI`!8!s$;e3
zC{heb`(Qb9FPjBL%x%?YM4D>g1p3V}vcCEL2OA+xcTK$&!B0n5?%xJTLT6Rh=Yg|Q
zB0Z;|WsXyPceZr(t}70V4PWQ6%^?x_`7ZQWxy}rxSoJrAraTNA&?9qBxN={}p%&Rz
zS@A3#wu~M5CDoE8mVT$NKq8WgT`V$9i1ka>5j4A8q+$(`v0Soa3E6(6(bgepbg`^=
zajnmFCr03ikIAB5&GU4up|8szY&Jpd^$mbS+P=z0;~o|j%w+TtgwNf|jo4sn;`@S&
zV-V*me5!e2-*%pVoK*0t_j{Taq+?#-RB!~YjRW<qkXmrw+L!d{XscOuXnxM(m0cz`
ziRU0cw6P=f5I@`@J)`3DK}9uE9c@9tG}{XEnRFrXLw~3axfTX0tJ$dyH0}A&1GH{=
zR+VWn*P#m@MCTkOAJOjVb3?4&cdkI?*>0YZr970ITm9@=yYuPQcBM0XL;l%t@5*$7
zw<1=UST^J*Ykh?meU~Ua7&K#`^2d&ikN$l{*fUo{$rnhq;34Hk!(~A>5<$AE6$<M%
z;t*ywMy#V}YA~ITo$NI@gkxlDaL+5^C<0Qfvj<@{U1&y*9C8lY<dvUhiofW^fdW|2
zx3d+Ndm4|9zdqRdp@{b$>z_!NEot<oR(Y8_CqTzMX}Y^v>&lR=2R-zx??e)x3THzx
zcUgm)>o7DXPVYj`**L`erBx0w6djHQaO!evl%xKXa*-juLL^?RhN>@pC{Q%dJd)b;
z-+TFcn(vH>8sZ{K*>b8ZrFp_fcaw%LTlK{&$L_U{nkAo{=a3Y+C+;Pa6WlAX^SV|#
za{W4?A@fW-MSq^{{sf8UuJUi%A&u9Yn?!x%6c%iSPN|O?d8S>ojk&YVopiAa_6H|e
zmBx+}p6}M1&%*WIbk<YW3;1>Eem39N@?XkxCVy^OW<AteQ_H|rgwKtiv5#5=F%wdA
zlL>r#313JxEqFm_bo(HmmFx$Br7>sSdjYc3uQ_v@a{+pxHkZFm9tEnfI^{P=j1R?Z
zR13yO;7SSaz%;1yzOzDol+qg<IUlTt#NE4nx5EQx4e14%9Pd=^^2I?|=$Uohu97Yb
zMk!6xoUdtXl_Jv&SZLhY$ea4m)*<`Ip{NaE2DgLi6{i|J2BawQ-~7w3$f;%=XelCq
zCx@vN5-#*Qvcyzs@u|x9gt+Rs=_?iSEd6A`GMsonqe#B&_rT=(<F>_BAIU;^!)P6z
zc737C#f58<8<O?a-f@J<tX{@#xG&RfMtNMj1Ru$Ll>d2~V=FK8JWp0La;%oTTe_M&
z>#hZj)%^o*v`-RPZ7TLtPWeq;P-@ftfNE#36Xc3xFQwo_QgkuA`C9@`AQo;)G?Cs#
zkiv*!I;UB~O29lFcIDu8f|q|hdd+HW4gYZ#heC$xkvl#FRWeBNg71$-;^+MaHv7)}
zrT)qBc}}x+&*P=ZDgRjrE4wVsP?*OcjncEb*#K^cq${fl{r1N7=NuHV@2Y)#(VkH2
zwL3C7^R&PAPXdjw3K6Pu&+ijeFS9yBE<d33Fi`<24eH_I=ElI1#^3ynK3~j;D2pH%
z*S=tbwLUG{$s;UBUjT)ypLq6B1>-gr{)uOr`k@S1pgNi89y^ksFl|?Z4W)`5JYHT^
zv7_~1i)0p$n%!^Lb&D}V0wU<HxidV>he~Cvku}(_PjnBj?qRB81zVT~5Qp8_|5&Bt
z^KKX&v`ipM2Z2SMHfXZ0u+44<td`Z>jYc6a8z*_3RCP)j31aD42#RT?AGb;Va`DLv
z3A@?q{aC8j8H=lIcss0;V8I1uyl9U<#KxC?8I=Cyvn3HjeMZvr45;YsL&vto&(g9H
z;v7-7M_rXR(wu|;4^3Yk)pYy+4P&x_G=g+9I;BBEP^42rx&(yLDGf>}y%9=E3zE_e
z(nxpb=<eqE+~41M{^T6a;cQ&-zFs-BkiW>+J8+#SOC);H<x&1c(@RmYbF)j;t%s5;
zj4lSFLQ>e0$in2!f?MF>4H8?)KB4fBg|+1mhf1{xpmchHRd0vU9ki&X4AhzTg$d)?
znB=7+br+kn9{*y<=i9i(i+~_#n&}Kq1b_%zM`XCQIX;`QlTd_gnW%+}KGr92OjC$q
zhMPW9H5wu_r&LO^sz5Q!P11*pL{oak_cKTqe@7HF4$;$|3Axb!`(Sh2v>K0S+mc<d
zWJ`v3;;0*XisJM|N)PB1R_k{M(33pK+0(wS_w_(hJ5I)@X?yG3G_bWm!he2TmY5!R
zcsjY|7IY=pcPeb>UaKd{L`m<}`k8U5OGM`;jqLy%&bDwND-18<hb!>$F83BvCOo7m
zyg6_wmr(P+t<B}MgTV=S%|ZL+L>0dUW%iks8!%MWo*kxltQT%p%O~ou;l`y}&Mg-w
zb0AD1%`Q8H6(8v7XtQ>-Urx&`FHfwVc1&aMJN$<f6B4+G0>R4cv>-?&n;$ln_JiVe
zI<*M2CCD9_4W$BD?$q;Q_L+OOK^iug(-HJKatA&89ZyuYw5ct$7Ne<Bd-XutloaIh
zUZS(}1S?iNFeH2X0rl(e(p&w=8^HyumzoC>yeQcIW0;VmsqVklaboP*0mYJ(A<eV_
zL1%<u2!fT<{Yt{rH~-|w+Ptsu%rp*NTy4AhSm!G|E<z4w=3P;egP*Iq$RufqI;Nh$
zhu0HpBe-9vF)DUXeUsv<mI79v%Qau7B&UMoKz>d|*}o#Y6UD31C`;M~MV7>7+qn;E
z4>^8At(f{XBh;h4hD(BFO-F>5Yc@?T@Wc4bqWH4W2MOJDaUMuOysrf9FOOxkN0Oir
z{@l&_uTo38z=8r;+@KJ7qy}55HYy>arBBTkfDgEvynj58bx`>BKYQWL9so17>ees$
z<XlKa#<-;<nxw^w6ho0a0%{!Taiw8|dL|8iX%g0;#5+4;rDregiOO{yJE{Vr30Bx#
zVCLjdBpv?0blA$Yy}CR>te>_Tg2jEYkn5tI=?$BK49Omfd{02(N`a8LWZIMjIh=?k
zIA@Jm4ORFS!Qk{kAxk{o{{V^a8jxt0V?ZJ@eBqBJq4RIuyElT{qOz1XJ7DHwOf}sN
z#klJEjeeI`r0?|G!a<r`75tBCfNt-c1mYi4UU}4MS;C$rv%3jfjTp^OJSEI?D@J%y
zZt8j^N&ijWiBHp+>FU@;%6No|0$7`yJ+YAMrur<rRi?L{tfx97^MC+|lIja<MfdyC
z478Jz;+?4!Uc8&jbosCRe4-WI9jJA;+9NdCmh2+@4}|{ilKk;kvBzjWMP1LlIn=)R
zsRz+mVC`DX^h=co$IThbAAj>YGtZvvO!FUWGaUZiA)g|Vro&a<_fbp2&LBDcpc*ll
zc<xoWuG=rjYcuJu4k2g_;}w~_*woxySS^jf;$JaPB&e1N#QHd@Y9A)y{cn_>0I|dz
z9wA}*801u%4$T`(RJSDi-up%`FN`I5iN0Ar@`2g?L+>AqVHJa<Vh>6dwR(SJwj?M;
zE#8p|*&ICO`iXRY%eM<G9c6Q=zqN3-d;Msfle#vI(-!{jk27x<`O#`p<%}w&8tAd2
z56Ra#gXpb#->|p*0-*M#XBjMcdx}+cL<@EmCYgp8BpDN@t!=&SX#W8%TWEwLUP<;R
ztk;pZRYo-!VpSy|e@*QPmHn~DPsLYn09xX`e1I`JQhvhUR%v-zAVFhd$Vq>|#~Q$C
zae@LNw6ca2Nnp@ldb&-y?Bi9pDskVx3-kZpdHfj25&FcA^Y->8v2)Aj{0Psz!V8oX
z^PPX>yaX)M)Hd`5o1fg*p5@@Rwea&YmEO20ZM6y8{;_fEJU6B3uYcARBx!}q-Nnl_
zBg*#_=MV#@+sbn?E#bNTswszAc<D7!cTH}$a-&1ZiRzbpL^tzHwN?HfPO^7x`rohD
zB=i(m*0&s=RipBQXqR4~jiD6MQ8ir6y=UbrXN%hQ0i!?Cm^zJU0nZw`3*3*}X!K?S
z5`TnZ>O?P{{1O^?Ob}~w9en`I3|>cq-buS`k`}alK_SK3l9fJSx4d*s1KsPl00Rby
zE*?aF0o7|56}`rhxt3vl9|3sF>g&6VF2DA_xpVT`z|g&=N3T*S2KO9gAxRqcv4!&5
zKAa%sR4M;tuVeg?dX_|n)DOEy74$a55L1<7fpuh;vC~8i{w?Qs%wg(;=SyBMzMB3`
zxIH*&)&BX&%G_58>k*TIvZv;lsm^_MembYp(q-a=DMzLijlpI)B6vqGk9KqWF-aBQ
zGQQ4|@7Lh_%NmZhUCpdI_-B4ud>SedX&e-LHwW|6#|T<M(%FGGYO!1|;yQoK!BO9(
zUwB*CW^ri_&c;u`oVJvy!#v3B-<$OH`Dp}WHqIm=>|>UY>U+=njD#VYYo1JC?Ii{$
zULx~iBYP=%BcPt#<D{lBY9_x`=1a(4d}|w<d5g0tZMK%o6QKG<rqNlwb#LQYL`<2K
z9zYUqPB`-ukP)GKW`#9Ma6biyz6#9mz94uJ=qc}5K$+x4n8p&0A4UUfMqp?RwtYYC
zM<h-Vz1|sq^RnnGz5fohU~Fg(QvzK&aCfchaejJAwW{7O#b~Aw`PSDSY{`fdsUN)Y
zhWX_C`&V`FCnMAS9;2_>1^Gqa&t#0wDsOLm+DZ2P2P^B)4bb!5-;-+aPqqJ?f8dBH
z0Vml6^r~S|#!U+fz5DLK=67c)u{ldua|kw3;?!7|D3=@gGb&>MZyvL<%~HUlKts%>
zp(+q06~uFP!DYu$yKRGPR<y$0Hql_NU4y<&!9E@t!MS~^r0!q9P0#<WRYn-QLo(#1
zGUopjg!hcMT@E(0@uYo46=J7umj=vTK^SG_8MX?am>SSProbcy+@HK=&e_Qx(H<`W
zIl@K4TbPqm{oNa$;G*lF2QeMS0u{hzc_OMpU6aJ5vZGoAN7<CwW@Z+Rm){_(YjowU
z#59%ZsN&b<Un)s=d=LcB_qG^6mfiiEU7bf@mE_MAJk;YA=h>vPMhC)C=C;9(*%(`{
zq6vR91j$V+?vFL5(lp=ra$7eW9zLWhgr^2mB2nnG5ab3f+X9hL@D^^TgalfZemb{s
zFs4K=F6!T((+k#K6q`puvCz^sk$@?e)rsx(Y#M9DqJe^4i`lws)Q8Xhzjg$azDvBu
zavZi<{mZ=Ja{H-XqS>04$|0>z@dCK~9FUljpsve(MoIZ|z=Bk@o*$hLj8|6I^!}9%
z8wLq0S{=TZeYMIjF{%G$mU}KQzfHhZB0>2V6+;E86+YW#G*6qYQg%kNEdZ|@b$T#s
z43z2_DByiZJ)=0+b%ZZcKCsH%ByqgQ)<l_#?(lR~9C2qiDwIzXekT3U$|NNe)ancM
za@o}}I;wNi_=VN4!jyq$tS(GgpcZYMrhQhIO7TKu6<(1Senyv`x@a7EpL8?>Hha+W
zP4Qw-2oZ#-dd&s)o_^DWxmeilK`A7v;MAJwQxg~6@$O3T)+vf%`a;t&A(&D9*1>PL
z8{m51T{@iCDl})|j>9PzF~X7Q$j?<)MP1=1`cl1pRn7rN##oWS0spG$iRcL*p@<Fo
z6dxi-b?kA*V7|W<y><cwahx&(<DunJ)u{k&f=T~@#*MZ!DXr+kEGYmrLn+o-JL>nG
z8;d<85CZ}~|I@e5p7TML4u^$uyos>m{nTx^EB=QCIwS5G|Mrtt`vGcugSj4mM%Tu@
zB<0gE)1AK6Cz9Os62RtSZMBu29W!;kQ?P>&xmdLmvyU&7jTsiiu*z4jVwu6@9hGY~
zt4TV{d8V-~=g6s|E_YkIb+$crUJ-9cXGOVR(S<Z>IP5J~IXoSTbHK~otRzmN#z4I!
zl7!!qB+=sI&a=ER9+WVc+&I~cNwA*<Ed77qyv@@;XHH}joJz>E63E($jmT_(yLY?c
zOO`}Q%sgBmQ{`d$@E!$)(u#7puab2O@}az`#KnxtjTU{P4NB#fpIk6C&J4lR!z<;Y
z9ZfT2Q9(}i)$~}Oz$O&LsDTMRSFYhz-9J34BT{c3XhRP5bD)IH5RkltvCl8s2^SE6
z!W0h3uOeTa$nJp|3EsSD`!XdsVat>=_Vnr2Ym9yL<)m@-g(RxgFJb{oqxn0AR-*&;
zM-+ETh<^ok-&-?G`8<^_Gs34xl9IKj^<1{6pSaTk=@QdWjJVWhT+1WJ>ArY2Tu!p}
zQ>M|c$jtlA_%T|3^cq^Q1vmLgI=2aCy6<D~MXB5{n*Cl&^;_v{5o)1k=Nk!u)^$!~
zgE1XKC_v3DMpC8bTGi1yw<(vb&qx<jGv&7Gq2KC{!PA;*P-x;BosQ~U*>6XV023Wa
zTMKyU06jUIm8>*MMBIr0^&R(q0=)9P4M4}2iu{3Oy1WFyf!wZ?L038&bO#6p-OMC7
zGcH110JkVKVJw6_8yLEx2}pr4Vp>x15Rf6dVJR2*;=h7v->WxRK#wd}`Vp$4@NamG
zQO5)3Emmde6t*xk+X6a#3W&V7KRFc*QZ6AjgC&XH>KD{Yb46aUV4R88+f+0z^_=v(
zOg6o#ftmSPx?9muRO0BB?pnVP#pA`hgG!V2ZTs}hP+te9@dutOv&)QUOH0kQ9?Urk
zV2d7vvHGu1_iu5L8OfOc;5*WppD(JP%7j!Wvhw?nkqPMitgy3+V3>L09)v{+(u;Y%
z2}_z&Q8;4Mq#h`i@3A95PcVDwBu)MT@4tO=yri`1LoO2gaugHz{E_zq%n2T0%>d_j
zSzu2kvW))Sm|)+qLIKEH6xq`GMJytMIN45o|5GK25NfgQvaOu%5EIuoL^9@mk@Gs*
zu=dX&I3fh>j~mS*AHd!<>8e_yKS_*2UTUuOW(w}4VAI<e1OENGbzpM*OK;tj_B{N`
z!Wg`#n_PC))~H+c2&o=rA{00p8>_p|;k)PA=G|5zu2Y_erRNhbsj#G}nT%~r`hSkW
zC{+&jEpe{HQB5ddv1myL6Ug<v9;C!qEd%3?CsH5AjymlAx>LMXmRf!@1LxjY8&n^w
z<%<i&>3ibyPoal7rcnkUeo=CgA)GS_Knu4bm4{tRip;0*<S&88p3A0Bcba;dy(dv)
zo&|S0ZLV-N&4WemJgKpiJI^w?wsfJuhhhu}r_ppiAX3%`oWjp;qe6}nK-s)aIwt^x
zP)h()@EuD#Rp|5Cnw0<zIZF2a)XdQcZ7vuby_}$Xq2C%vQ7`RlP?aQXvm8yKw%*Lt
z8*`Hw7(S2+9d2W3efO2YMjiWl1vNW$uUvEW%PWIYG9lNbZgCV*pjnpj8-nXwLQnV&
zW^vct%Jer&SFP&_P3&<Rk`|Vrw7wq~-^9@C*kG8p+0S&i2=W$c=Fp;D2Z}EA*r;L6
z*O{xKeN&Tcj$>tQuzB4%Hmh)jP#C<^b^<`Eri4PPv0zCpTX$7l0;5AAXddiY_5dQK
zyBD!5f&Cdd10@RpK^`+tegUuu&yNj@8OHs=_p|9azRj}#Y8eWsK$U`LDnK)(p_S}1
z-KH!q%7v%5uQWveY#{m>AfPY;E-D!?pa~$jQy`{BBqMapsV8)C>H0CeZL<t9_=hw3
zHny8-BU)ggg>NX*#`TPf)(k}1PS6~jkef*?*i_2B5lZRvUyv|DFZBp-hT2}YFqLng
zo(YL@zPBp%kzOrN()`@w7_awqkyh7%f1z_UOC^(5?)G?~lRF*xI7SDjhC3n#@hFh$
z0Y+F0Ojr(cHRB<e%Ih-Bv%WOXyh6)1;oW&Bdv3{kONuzx^UF3a0Wb0Ne@f2ruS}j%
zK2v=p4`#h2POolZx5>Qw`EB3LMTt|Olpwaa@NH3RTa7ya7cG=MohtthOhMy)`A^_6
zd-1}Ds>pHAa6l4*|4_#?0|RKEgg&50n`9p7)3TM=y!+_${lqf|z)}|2Y#?}_h<kSM
z&Hy)=_!uJB-Dd7J*lRzf*BMhz6!M2A&`-vt^to({=HCv}flr1dewarha`>y2b7K0F
z8#_#U+-ZOSY?4012K{Pn9zo&WnjBs|Fgeuie@W1)s_1c4mH_LKyopn^_j4X24*j+r
z-lTQd%)m|lSzmd``9Zk4CND+l>=G)sfsJ`AK#7m7o`^@0^V@piNJx52=~>-g9-ob=
zxDow4g;Cbq3+Y+qL4x)9_c$o~HA9D*9`0lKw6*H>yU?}#mta=4J!L>caA8U#XthIa
z@mCUpS7_yA3H%eo{u5KQTmE-r^CsZJ$4XbEuy+$*`}Xm)0dfBS)6P7({`r|eL`1e)
z&&5y_ndPh@3ZDPTl`r!)ofM3x38?scR9?tn2+Gyubxnov2TU#dvboD^{(D3Xk5QvH
zpF24bk-2k2P7rJ%5x6i_SHv#ZQPfMS29MrR06aN?V!kV`vcHKU3&vDOs9ED{QXO1g
zF!|ILv8=IAp&D{ZE}P)u5Qkf+gQ(52YjKaxt=b}INGrOWPm1`^^vMfC?vI5{o?_zc
zDvNzT)2~uJSbng+=(G7=JCYeRiqO|~^i`)>P6QqkmkKtV00(vbuj1%s<V!h#(TKbU
ztscc(_5OzfnWDewy?HLwoB9MeZTqYVM3%`QtIgl=@{^DzkU!k-xMPR{jO-07DYXfL
zfXNOVKqRNupJ_o<mj0f4Vw&(fXSo1j2*1?#eFabe4q;<c^y2GT9zp?WNO<o{9*t-2
zCBaPo8-O+$CWcUtz_SF(^`<?qr#xinMiHixNm_?_!I<g8sO>!>%j-&fV}qv8H1Hm`
zMJR>9JL9#j>nk@cJn?f`FwR>gU)K3#pOd-nwPl?J1dO<`u|tUMCv(1d^{auUaHHA-
z!e>E0Zc2h~4LDUS1N5<aj@I~ZN-X{8d;j=-AfRP%VaV*|eK)Z)#|Xwt_7&BQynp@u
z>E~A+(*ht!xwZ!VX^PfwzhFQ^r2=5Gng&vvDr0W^Pw>2Uqy1<3%prL5A5^tGSh#p9
zjq>|RkJFmUdlfixG;iu<jTHTR((u5OT0+LGT`QZ(WV|2Uy2@8LI;V0GFR0zbj>R@J
z+uv;mP?-&e_EuEK6EA9r9rOJy@chMVu0_8rc4|Wn|IT|{mr8Ii*ZyHgO|^~Q&IWA%
zJY^eCtqaf3RrdMnnE$-#d#2Zvn(+sTPO#^B5%U+k5fkGsn%T=1*P=`56_4h;eU@C7
zFEN4Zp0?P-|9RD=3a3Jkd~CwJ?3~hhas15%hPTUD^RrEBN|dV-Dv2(5i0gIz?Rzk;
zeV9s)_*d2GmFEdOZsmT_E&+z(^w1s$EDsHn7UqQSzSpVAF5QrXBUz$3pF#-Ug9hr)
z>m`D=4ECktsE~ta5|Tj=FktEYvIqRN4>GrPbNLJftSx6zP%1-)C((q&B6No<EKgpU
zi7B4|+Hd@oi%!^63rWINXG58wR!u??X)L6d<~T+fk3zFl@Sf`+f+cux0t=?5II_kh
zlE}*b<-xMYipa~=S&JC<cVjk90JFY?=kFrr6u@|5d@W|W&@jJC8$ykOecE*B<_4E-
z&P<kC2DfU2K0%bi^^)EYA4r?87h5)cU@PX#L1#sH_@dpwu<kyP{&WRWxBkfqR*w5u
z?_NeL+KFO)1!f(A>y|DX11qb1Bz1;?;(=klr$WS)7n?1fPig;_#|)!8FYtWgbRqUN
zI+3xnRif-&@89gG{*rnj+{P+YQjY-{((D6dd5%;94yG1NHYtG0(*N9`ur=r|)We5F
zB(sGyD1;BE0A*m)Ajx15*(%d7t)_XR;?~E)*7DQtFEpoXe>fCD4HFexItVxU^`={6
zcP7mRLO3{e&N+rQ(EP!vI?ZIaHa$MTpNR0hg!(s&;Jdjk4>k<tqZtR6jR*xH5UC8c
z9NqPMwTHw?k~<c)4W5V|e2g4q&#aQ7{ap&zqqU$>ms+ubr<kL%-fZ{!`0$C+lh0ns
zXw){2#Y%J6HA{<cgD;fZ6K5B1AE=RwdFChPq6!@yjy?F-vx<$beNm@rc=B^SEk_-~
z_pgGvz|Jo5{o%sC&9UI5f)LSDstO`dg}9^>&?&U?zmb1(MPU|7g#)Dfc#uRSHF21T
z-H*2l^}1w(@r*HW&R)MBo9r6WZ|~zM;sG>&zqt!roMVfYgz_DnE3iKW$f1B|DsL!u
z5VLz9#$Rb^C@=ld>SwvZH_=_6bHf~nhb|M*qj=P4N{aUJ-51WyS@Y9-T>sW+)^n;w
zS&qMq-4^YoX*}!b3N}9kL#TUGEpOL*Mbs2Gk+c<|vS<co{J{!>u=Y$M|IfXpc^Ru7
z!*n%{CDP++y@HR$vIYh)Zly`PB)GwKN?HkvHO~m`Qp&w`sKxDAKIgl{9kKJa>lHR%
z)~OVm!EWh~4K3?q=yt)31b#KSR~WZl`5eVWj_vVbJ{=j>^6M^CRGo*~jIpyH0Zcvt
zm}TGC`oseihh2$x{8uIr1hqdZq_DhPI<avs>f}_;TL8ghO-sEeSbtLdHE>C!U=fM*
zt2e3IdFMR-6r6SBqw%l!Lwv*_OSr4Jhg$H_%aGDMs=@q_(wAye_iz76yEWTsX%^e-
z`NI-fKR%g_P#H%sC_`WJpt6uA%@IKd9SoxPU+1_lG;}<9>^X#maB5B`ohsr|30Pn1
z+tMZ#@ur$!W-8CVVxGNau?eh7@ZHgDw#b<)Ixi5`pwZD5?Y$h9J#hKc2>&v-v2JjE
zUWYu76KYPf%JMqJ_zybuX{i<t*2&QIkF{&CSNoVV&jz;q3%>SNL;zZ=)ko4fOgLlO
zXdR@_>%T9d2!huR>(@q`1A-Sy-{4;3*2OSC8SG#Gfb*-5<DQA;2tW$SuBzO=-M5)3
zJ_;lNF@Q81;m7Zl0zF^OuwIoUsb8M^yrw7F|EKq3%g4nWXyv9vUQ1AWh#kfr(o$93
z?#h7dVrh|buNUl|pAP18rzG?aDvutre9?auH1)-GE_63|sbgEh!%vHM=BrfUr@)g(
z=y8boE$RLTM*A}{vFHkuIaQ$*dR78GDEbY0g$icI(ulifo}JP-F$~SCkD6jC|F(HQ
zq05Dc2-Vl$6pw1wVy;C2p&bUjwyP@aYjS}J_o>Z&6^F6ZCnH{oCOvE>3?cP_fqe_K
zKbs70sMw-`#LnPjrhWDxj2r#`)ax<>+-mW1z;2jR+vwf1d|R$E>Ub4sUk;Qm&54kU
zl4~i=tYiE-1k8%=tCStnmeaY?tkUlDSX91x|7{x3lM#}*CMP)~bf4L?*i*01C)(z=
z444(W;pCA<jK;C!1bh*#nfp3MUj4z(YcBI4k>U!^(<#otranZBs1io$kjBtGVDC~T
zA#+txOndQzJNTWAUqU1kjQ1e!nCNqz{W)<<Z-34!4s)I49=}n<T9@4@gL+lm@-Hke
z|Cn1g8`Ily$9YJ);j_G5rAAJE%~3D$zole4{L1vAJG4>r&AO|COvrfXNcSq2UNc4<
zq6fpf?O@dhQ#9_dfU_#;^a-B*DfNVJAppJtZykfe)OG%wvB%;Wlmh!Up!pQ`v_E;i
zIujJKD6zl=oU~=>)z7gYU7cXO%%cPhDwoGeXDP#WEGpiNNy?OexL!#p6os!FdB`x_
z7o1*bP($^2QGR&#8BK}!zZvV4c?T=xsXO|vuEnjS@X||osx^U685MU$_Cr<B5jf}9
zo22|o_@Ccqb()4dTo`*t9IKFy36666kourN`!DWs-_h1oav3{fh+ojZ>kBYso>9ko
z6paN;vaRjV=^EqT{mm^$xlxb1GNi<4XK{3cQL@dB1`Eo|!|1WjqZFugpLN&45nSsS
zmocJJ=F)Y1m*K#mUwmYDFXl^^f>%}Wc~k`E(*}&bEOcJt{P^pdrKRb|;MA)1!;^zi
zKEitqt-U#$t2ndgAtYu49s0i)(zYECim{>4z6>|-qBlc;eiDofiaQ<2%&ZrU$fCwl
z6yBrG{ZZl|$QK+ZymI#d>E&fvc3KGD(NCF|GMVE!vTDm|H}(%7ep1zk_*GFPQKA}m
z@ZgdO5)nuGMo0T@abw>P(_ur|j2&o`YS{AkMReO!_!o+hSVOx<=GnWS$*QXW`nfLF
zx;{JP@)Y0uDPyc}ir>`X&Q3@t)r&G#nV#md&&#po(8$0*$n=#U%#r@KzD=W{C9&$u
zj#Jg1VPU_l(!{y4@1McLn|fQT`jPwapJU{w?fuM2ZFG(w*O@LOsu6c82?4X6&cKT)
zJ@0ng6~&bF(!=x137_(#K)yeH5do;eI`|QccMy*)A3+`?ZN`W}rFgfxxixhr>eN~z
z45$y^i2!`)XOa^3F<|TA0oS)Mo=#OXzx=sSA0TW%FZPuuPk8mw0X$zm$R)h4A_Cem
zH5FGjMZqvF(|H@jur_@#X$l7N@exqB$(Ed_2dRfyi9<dohYF)#2GP`LqF&HB=nuSY
z<^u1aitkyJ2E{w3UwEjuliDMm|8h9`tN}2CZ>zJ+e;I$5lKXgXtWrf(9qe_tcfFVS
zd@fTu(+<ism(#>T@JVZw$2wr@9ASldp?nj`zGQ2kFQAhnab+lG@4F`E_r+}k%WzTJ
zg1pCY{SM9(B+m3Rd$kL$8kX5s&qkf06jlu9+~hWUyPWxnp;XW|?nsWFE(N${q7zRD
zMOaOOuaZA4o03Z!2t*&UWu)*4v@UV903~KwOsi2Ld`|X9q+MUY1Joh~G^5(0*FoW!
zuiam;p#&EJP-bMf#+fz_=mtC?{|}=fuPRh=r0CGm*t1@3V4w59;bH-~?Kv58Ds=>s
zo^)(3+eDj)1&Zyr&7)>FMQZL1nv+;xIi|Z{?Vy7`8Wx>&lfE|K=nsG`zE<9B{7hY|
zY8p26b<GDea2P$_PrKhP2faOAGeXAjoD1mpx-AxCSVF2Um2piyhTltPT0m<}oXXGY
zdA37``V}~tyE+5~J~o}7gK_7lTxhct%Q`cZv}R4W?nyfbm{ii)vf&+g6p_fy^%TR4
zu7U0s!S83CQ~E5`e1|fbV_9D6SN#MO)G)yF!ngWqnJ%eVRV-3vH|7xCXHn$J2e^kq
z7L|uVc_&KCfz6w}Vv()rnaErq0LxKZ$Pbt5H&06A+t<#iSE1TWXHQ)&H{-XA9d~Mp
zMXtnW0PET(b0UFwU=S98HfjndI87g@6Z0OWU`p2LNqV{9-9*-|6TMbuqWa8`1(a=2
z<=qIocjza*ZNTTlIx{|g+Tm+rLG6r{^)SkIkF5Rl<Jr9;D-l2K8|jO-F~Hh0_F#Oo
zdDsC?q9G{d;#PPx*7WMZ1HX}Oy$4~YNKvgc!?@4ogw^T}<A|uLiajYRpEs6EKXz_v
z#uwY$U^FZD_2L`F=d9aM_AG@cqyq@Wd{n$6tjX)!pNE$r8V72tNtM?@2h9w*u^2VX
zY?Q*A^3p<mqZYtUL!Maxfdk7ddkrTXla3KxivY2A6vUpd;dj}QwRQJV8~{Rv^z*a<
zOV`Ga%U^h6PDcjpp}>h={#q$l3gtgQILqSHD$EKMGcT3V`YP>6(ay%z5<m0l*XK=|
z@Rc0SQw|q(w|f2H)<HWyiLJZh+;4*<0GpecA#U8TX6a6)^em_k8Q*s`WjbT??qGIF
zSO2B#zfof_PFaxVI^C?4Ld!hjWA4ekeqFDQ_Opo!y2f+o0_1&ivej=Wnb&vRebQ{#
zSWfD&^SaJwxNS}HffwnyPkBg)IEfJ{^OL1H4oX+U@TQXdjK5<$!+mXeJL0vE2vxym
zdcQ@nhML5a>#BRI2AZTjIw~QB2PdTO?fYOsuz^eb{b~%;Sq0OyN32#%tROnHry7W>
zXmV+PRJR6hZ9_>Qy1gsfkKW2>BMKuJ(ufN;ya|>`Isvl5!Z0Au3r(Ym0Y>!qm(d}Y
zr48u*W3ewLaA4H|o7X_7Siy6%Q4l@u=!~8&tQFxXas4BOEOsUG;Mpw~2L34N#OuM|
z^|bjq4N{)eM}Zd+qbr@GPx9yT2e-0N0=>@*9FEx08xw1>N!7b%m-Oy1QTxQ^n2gGx
zBpfpJ=kr@8Irn-$palH!d+6fyfJ(YYdGannuK^#<{2}vAtEn9yMm0AW2arAa@8~rE
zaxYK9Ol}47nnM$%ANBVGKWnY{oCiE{p`-6JI@fnk3K#TBp6cd(OItL*jJ}ofk^$@Q
zxaH#Aodw+c8r%+U;t@%k5L1xW+*CE%meI4wsk%CiFP5U_i%)K&@4SGW`SN!@gVhWc
za5{UM8oEYay<oGLZe+3gFFNE^>-3nelsxKBRbRd^?VYx<?Nj7_p~<JO7uzv!mZj;Q
zF>OfRMTInTztav_TNYUX@*sjS*+wo9HZsd-4eL>{P^!S5XGBkEo<VWGpizgrtrS(B
zqq!FNP}cWQ+caCNH%XQj58-mOtLX;37rxs5o9fLMN~!d48b7LmAI8-*QTif%g805-
zgvbEq$C39Z?J8-Oh|?=8*(zN1d4T%AOU|vUgmiEo%`nzWgF7Q<+H@MvmmFq{iK25l
z&}XI`{0MfvBMOqvmheaI$Y$i2*edt1?bghb*RR5)P2Ym&rE1lu9+?&pbD^|6b=lk+
zmL^rj2kyhIo0>xJ=M1CO3Udc3olTyNO>VSC`!a+zI`V|h58_9M-kyhWRR^scyq|ry
z6(MmH?6NEv`>cidTj0(d#>Yo$pqY{%2-!c$jiAlqK4gAK?&}8D)_|7U!7kg<tkLN+
ztE*zbf`sJqwlAd-@e<rA@Fla`*r9#)TG~6RRc3@pPo?&rDS(RYA=7>&D5OfaK}=Oy
z0Mul22dn>F|Lcxkvq%mDg+49#QKXrpyJHkXATygFiUUJj40RcP-Hf&!{epD@Zb3+`
zaWuy$cqY-7^}FNqe7FsN`LWgk`Cq&@&jjyK>`JhRYNA6<SnCB5pIjJa#@v&ZZ@91W
zpEl6qd*t6dm(oz7U~f6cD$n|!SZoh_QkJmLDIcD}99l*qW+-}3<g&>K!;_L&%5at>
z*kT1;xNa&*CC<;#Wv7=k^cX4*qdmrE$C#5R4YWgXcu41j2W}dUWu5*$5^|#87(FNv
zksq5$56C-lHHXq+=E}dKy;tSqODF~2O+ZolnlN@j4DfL6UAot=$gYNTq$An*Hr{I=
zvbD5MALjZ3O3C8BZ5?<wxsNK9_J2gQm!A5q<Cvtkh;gK27fYB5_UC^cS0h0fFdOp6
zbjA`8#Qw!D!YK7bgjhuVAqD};|GLdF?CB)_dm&R9I;~dmlIS~ol5n1jIo5HiW8sHB
z7pYD+vy;M%9yQaFcgH9Q&3o8{Cr73vE<M6VnaIbM0lzOyN8UTr3>A@nXnX6vP@5*=
z+1>rgk$r{-$^FP?G*3t-#`Cgy_{!|t&@&HZ7hXO@!=K7TOHBvP7ajaiPT4j@+<44=
zr$IP9q<YK7GbmX=K56J%Q9TomRj3wuWkvDuPv6iJ@04n!uHemx&~r16tJ3q%X>7;T
zJyw|B5!LY<^YB5EhXRi3VAWw3D_Ya%&!EaUpbGt2A51QjiA3Q-p`qW6EII|d>gU7l
z1kIE1?@RoxJeB*zM+wSaOPuLHKd(FyJC=XJGPmTM5qU^q&q?j|)^cM``f2#4WEtaI
zSs$FZQmXY{>|m`VSP*wN)roA^XGS`4K$djbN09Mq0U-6O?}p9T^9?HZJ1vt>3V-8u
zL4ex^jg%$aHik@TxCXcHTj1tX8m{vH+?6uMyD0`gZjJ3@)`{xA3in#yDbE>S_0^eu
zFZn|#kX&+N&m~-VR(Ly+v&zB5G)4D2omPx}Sa6l+ozI#Y(b!0kB*&u3zt1nWH~W%M
zN62HD)yHRRHX)(1fvW5w$MDWW(igoN?MZxC|G)y&!XWA0ue)ci)aoT$yZoh(CLfom
z?>&oDmqLhsIV6qdtJGB|G%>Fqb|_ONlC7IkPGb}68-!cW{lyRq!?n;dVz^^)-yix2
zmrgo+Y6J@EBycin(0qOXyErz#6uf?1dl%r5kiqN~^yo}$DM)^k(d#_<8KvMoD^jrk
z5OgaAUY^NNF?q}4yRi3|BI!X+Xur~icUL{c#ndnIQswzEsjX^-|B~kQLhcDLi=CkZ
zYyKx;>;M2F+f-H<haUnxXNfx=85j^p-3RmsIllXMF)WpoNJ8|kr@-`N%9i@g648wn
zqtz)vhl$!L!pZ66fet^KH}+h-1yoRIW?!NC#K4&wf`-A6deq;^3|nxL>uJ(S+o2qn
zo)+C6?~!{yoZk_^I#_3k?m{m<X^n#y<`3dCTD*<w5BMG%s6^}@f(5GH3N5a_w=9s0
zRCYTW*~LD#t~GF1c=wTgiJ#6V7H-9||2H?H{?Swuw6Hvbo`2>!f?FNA^k_ZP{ruZU
zqIQg+W5U)=nayw8Ek`;raD#^8cox72E%EN|UHQ-e%k-mT_ERc>qq^$@+nqa<VvpCv
z*j*4_3CSVDU=Xz=p{O!iU|X*F;6QGQ>QJonr>}z|xEU#R1-aDgnSW?Mnn|$|kddQT
z)c|&yF`-0u3i2i$2d9NRRdFY$+P=*X30geqS?~T+vd<a+-=YLuyu)96aTB)oT7$lR
z7>J4R&UQ`~J`E)rMSVl+CbG8!-ZZZ?H!FSN8{BD@)S~;O0y=u>mi|)%`QY$A=0y>-
za5g$@Vc^eVqEFn0dHwh?)$B?foe_<-o*SX36@SX8^-<j$dylgIx;l>7W&=~$GUe%%
zNfNgNAHlh^fc=6<5H$izX(cyjh3*;RSoy)c$cRhn1gl9!NY@W)I9I+iLiau5I#;4B
zCKq|Cxz~Sb&N1$1|0Hj0>79YI)0)>c>n+DGN?@Bm16??7D(q%F8%@n$^uD2fzxVU$
zZAe1BN5f9^h2LksdhPw7xj#(xvqz6l&WX7W*Bq(z79@LrD3y{6#>ae8H=qH{Fx;>B
z4j4|2Mx*ZDZkr_P-&cP~`u|w~9!mOOEtMEDKY6v-*I`q=#fSYZ43ntrl;YHTeiop9
z3a!PLGh%Ua%ImYHOdysFYn~q`hKHO0Re7@kVf?<qWKt?AZ)k-9?GKQ51JRZ&mHDEr
zQ$2I{-U?aJIIC;SSq}ILItCl&HX<p`jkTMi#58U0s`gGa*japYH%~s{k1~Ol+j^OH
zXvC~vNhcV(H~r9)kYljTbU}#sOeq{CA&zoA)aPSUOV9kdJundQL)H2)g(0O;Mbi|n
zY%Z+!upr8`$=oB&QRy(v3&s&y;xwONibp2Nn1+Hmd!JX+-I{&gY!@gWmQJ0cx~)5!
z>xW&$<6*>iIiY+k^cikqY6&K%h7)()jm8y|g@75+UXLXUzIQr1pgTc-@uZ9kS@NPS
z*dDanI9?U6=#kwv(mAm7vxnw25SMkQX^=sA_h+Xx<M;ah!2HsSGMLn4w6jayZOb$!
zh!J=uURq95*B`sDs^x<VAZ8|5k&%?QX1>ddK=1>{J5^ubrc$8&;)^Vh%|fw4l|?o+
z{N|6g!%HW+KYQI|r5hYPq?lKI|1&UaJ7!16(;Oyoi8&2FHPI)yos{DlM|V`QVUlo$
z)@HjE2;@8WsT@!d3oNe{#}45}zj<^Y4r2c5pX@LsNcP6ikG~DjZL<nZD&$UsK~Z$l
ze)R1z#TmcxCe_LWHB?g^nHb~V?gC!*Gu$n=jM4f^0s?4dOyE6L|KajerOH1kJ(~_(
z8U5g~RKLS@#J#|z$NpbU1t&l2>z_W)W4*UQk5$J>{o$tl)e3<_1I$CoC(hoBd#o}`
z8rO@3E|$IVxfdErTeSS*p@Dk^G$JCZJAfp^o_q$fB8)|q`txRSv$ZV)3upo%6d`~<
ziKzPyyalVa7#`_Q_qrQj4d@#G{!PnK0>KMpWaR;!_0HpqDc<5y4MRRiGT5{eII;M&
zkK?(&V3f{2)$2W5_fS2i8D==85X7D+$`tslq#Z0#-a&}5;>g8UoV(bpT))R<WOJ0Q
z%1ts*8^8_T8kP-U7r(_8#~r7S$NC`&rc%E*n(29k2p>y2?HQ?LSPts{(w7PU^vf^Y
z45*75>#AS*wVii8>z%R5g`tMLoi97-YKm@-b^gH-)!=^O!FSyoM1B2cFnSf<G5kvJ
zN-A;K*V5g+c{#Q}IR-8(Nki4?NLL01kK+NM8dyMdNztzGLvK(B{GF<DD4(}Dkk2uh
z#12?SNXs!GkyarmjOzGQWlYK@7?9mQNgl$x^H!N?Nu>v(!)Cb~D;h1DTt5(m5(xV1
z-~Cd$=TC@R`cr)7?-HTz1vdJ-j}!YJgC9(-e49YuyGKfyAM&PYlMMhe82Ob=tvWyw
z`)M7ch{(sssS`kl!lNN)45TK)2y0Cuy!Erj6!gw#tB1_g=}f_7XCra9Pp{vW{@i;s
zr-UlAgVL8pbjh!5e=6e;3piz%esP<Z+}?JD|JrX8aCGJtnsE&(u{EIGBo@75?9ux-
zbD5n{XeYtTybK!f-d`?#6A(q)#tPzzbtnJd*C7WUrvaK~OSN3ih4Jh|l#oO<F@b^i
zbkm1i4`p}5*a>4iH=`{&#<sded_@<JhGYaHt(PNV|4;$U>;<7{(^E?#reDI1UoycA
z)@4tCrsM3rZb}H5jA*-jt(qJ1Vk!58-f5W9L?7?w19NwW#vd<Li;vZDx~#6u#w;$~
zYoB@@KiV=RA=0K<+*cvnmV<-BX{slXE+5#nTl+k@O1?QUG%~6cqaI<pG}RH1^X4YM
zf~WLe!XwLhO`D+=Of8w-8@`s$9~Sq^n1QZEzF{!si|^fiBKTE_NA=>Mly@AcOm%Kc
zEEosp!OtPip!;FYFTI~g^_2N@z)?=^;rGMYyg~6p@uG!Ksb?vN4Vaa-IMSYo<!(V{
z-wwB{o{P@ybi=F20&_#jUT9AjwMebjwHM;bq%+c@fW^!eME_z&irzztPi<b7Mi@Uj
z?@IW39oR(!eFv9Bm}Us8|4JsKn9?1ohBLNEdV!RWBQA~`&eG=r<+^BYJb!@W+xeIB
zaK(XaL%zFBB{rzZc3P*`ohmXo@a{mCax2t2+C}T>l)uX0<J@R&Z<YBy5{$6Kqo~Zh
zQCBEYUrf)F;8!3xcVX>W&3a8>8XqQ%Q?|d92rr+k5GtQMVW>SncD%zw#|Zx87#~Go
zkBtq^!$Ow|bc*Bu;`mP?U1CO4@~XVhq{wdyZHe<sLD+D0h|0OT%v=cj=wsYfHIwUL
zlp74+6e21Wl6~R7@O)OEK?la?y0YS`HX;~fvRr?r%aP*qc|=${TIE8+Ktq5i%@Aw}
z;3_o5`vZNQzsz?W)J4HZFE0Q_)_%*?ZY(3L1+e+MPAR-T3aD&??ccUFx{;+s0*y#l
z-;=}e6TkV$S18@+Q`!K5T8~4kW!)7z0Mgr>6P&aY39;%=?0q}BKu^1!S6fR99o{D7
z8}<+K`U|T2V7e1}*sstG2~z@I4UG3yl~&h@MJcKQZ=a-Ppz0s$wrQyB)alBefhDk%
z^N&3(*EYGB%WFLg30rlJ{&+^jBoy<K1CC*3N)R4JYH8%Lwg}ShWN!bCm<b_x`E%yp
z@m<qS_7{V#mi;0QofcS{gT3s-$Qpk+OEanBozA^?O!D1&E8YTYjZp_j$FTjp$fhLm
z^vQj3>Uu>JJJz|gD)lQJHG<(<`<K@dw6+aV75|7+Vh$808-A$V(cQCbVJG0?8)`Q<
zij9TP&M>TPW#s>Uh^tmpyuIjuDgDz`Kj&pY&Q-&zL1z==471X+d%3y$gzKble`)&P
zqsye6Be2uQ*0@Hf{CX=yGl;fb-JA27?Bb#@3CjE$HEplif-&Q%#jx;CO2?=l4y4E8
z%=0hVdas;EIrA|r0u>~^`!4kpOW$x~rej4;M@FKljqr!Jl|1O-p3LOXrF`uorwiTz
z0w9}95v57RN9>O3bi7f}o+moHJSLg{?gd;i7t$RW>Ka&P4ovh(O#T?M0Ar`9$=KPX
zAN7syRd8qc!|3bPnR*_NB>;O0fV`+yil`mZQ5(CSW=qT2x1$u7(|7Q*&8j<7`q&90
zAfrXU<^f>>a7wP`b>I~NAF<iA8J<s4awY|+<T15g{jPgkD#mDR<;=lG%L<V&G$wf+
z(2%_B#Z4>Gv>cuBVph2;(ARo13UKsyt9|4@L~;@Fnnq+bAwyb7q~QFn{DSY-7^y0+
z#rL&f>I-3bgB_06ggq0-hn#3Xr-PwAOFE_R5B@B_+rPK9K5-X)w99>pm%lxjY!Y>Y
zpF7Z6$^<WxI4Er7_ll|4uV8}d3aQ-^1lFtFg;nHUB1nJ{F{MPDiCUlz_{t7+NTU&c
zzVW|%bj(l8T>1qBG9c(P!uMF9d<m>iM)jOY#f*^0{!tRnpBMv)`$7SA4|6*I&L#5~
zbb9<a0sj7<rLZ3{gw)TG<Ld;GplU;(aCs%MUp2Ym^pt2K{q(C#`}Ykzo7^%5O7X3R
zwd?;(de|ca_vX+;tTa)wtDDRTN5mzJ|4XJ?{)Bfi?zcGF_zu-k<N9f2O0~I$hF3&i
zgjdyi^i!9-ofIoA2#>7Ho*X?yjqbhG1SRdyMlsW}nhO6PUJyD0NP<iz@cTyWcL5ds
zw3ofQi9t=?zgEUmy4~0{mDAA0B!@^g{TC>4oR9obr;4iK$yfH{$N6Vl>wX5?0ZsAo
zEf@z~zF*cugxACOmRbEVf;tIJzZbiAxRC~^3Eew5Xc(n?6NRs30>t^Wj>D*Ah|%Qj
zZ%oo&78kPr?acIlqH5%fUa^RIPkru;#%i!sLGhgbS(yU|LKEj<_c4F0*uI%xx$p!R
z=Yjj}l$g}t`Ff<CgsNFY7F_d{yWyRb-MXZI^yAns9bqW~A&F@sAc2Eq!ym@oPzb?M
zCBZ%q4BBtWSVs0%`O*4^2euIwJ_;A6ULCRf`vAd+%z6e@`m>KFeZ1%xvx2kGn1w3f
z#TfLdHP8{^hcm-YyDuc}8PBK27@=u=oX}_{-MakO9D=js7aBJj`7H^EhipI9&$oLF
zDDc(eFBEQeQP^_d+t{*q`z<Y&6HRUZD>q`E?KYJ6`c->p$WESF#cwqZGuW65u^yu4
zyu*iiWs;4$3r3Lq9Niw$(CJ^mBVVNP!IT^wLmFDh7+B1!|FzhV?nBwF$?U~PQyKq|
zPZ5E06Q{`A3}&!z30!(U|5Fxt|K}%pqu)2n6w-X?f4iB4M@2E~VoPbM1Rs@}$^RWs
zJ_*_|ix9%xo1GlG2_)1jSG}0rw)ERu^;=vv)sIZI#3>nM6R<popkIH6lDQStE*Ps{
zQuEe|sstZjY>aDtEIsNyqr@U>e76@E!~(q*2UZjzuh+Eh0ps*8dWdf>LHrK%-<h-f
zi5nk!NXB`u?qpkXsGnzbK0QxdSSX=-XP%Z@;50^dC^KiW;RO8%iEspuLj4g~meNum
zFk4hbFYwvRE*jdtU%cqst#<h>@rCT%l{;tEkQyD6ZCni&B*o~TYrkny85M|52cG!v
zbZ6WBD#awJS?$8sOhP&X*)9cQs&5ElqyALlI+7Zf%t!HS08Lc~^6;z<4<)SnsLOzU
z_eB|u$0TmJ@7m3vi){8;F;qQ-_C^$Uzxs{o-_Ov>d(%H(o4fFozt?6-ZMtrs=m-sp
zqa(i|z?aMhgk%vHPtmUnfn_0d>y3rJ_Z$8=%u^QDU%V^v@TA4Nb~auTg7Z+r>s2HI
z!UX-K8<9NmfcQ})GVSbAV)`Ch(V7L8=Fq+?EfvG*3zr6-ZbmMQrm=)~)pD=%v$-r;
zM2tiic76$4t%$D9t2qQwMK4x+M^Usw-2d4vIiS_%@oCm8GsQmWCTyj#tx$ywexgZT
zg1enejnN)=yrKR%UCP+XgpUy34Zrqpo9hI6dP?KDUSREs{T`EfDUW8bvJbLH;T<1-
z4KS#7q4dbQ7pz?R>d3qgaC-n-1#jWsMy*v($l;ya%N`#nB+vQnmQ@WNCO@3kxlLbn
zxj&pLdLvmZw`08H=WPW_=6{2uo-7G^Mc$G4RhtmIrXP|M2$&=u^yVVot;-;kp7vJb
zm8bE8%WP*v5vJ3EfK@b?bCSg(k8>(*F!~-_GVDe*;FdH2-=bUN&N}}^U93x=ou2{&
z2$Lm((X@=fX8%!G+|&t=K}&z;!`xI>CKxr*%n!nR(*F}yzxXDt<P?wWtV?&YEV<AK
zUoVecEABfp<1+dz2XeGtNfmwuw%IBhI1DEregzlySACS|HIL^K4ia?{CKx-C;SOul
zxWfd6<g<Q9gJpKe^*&kEwHZEPSv@Q~)%LrTy%m_1xqpKeU~bSB^CH<R!G6upeDdx$
zX5ehi;jZxexZ7qr(<QGGe&tp{7X6DprnBdTVdozHb%Rohdo{tMR>k&)hu6@G%jYCH
zcHeVqd5yO2I6o~B@f_({>E`~C$bI5)#p?#}wf?QS(bn~q69Y}7EB)-<i@s=8?*tf~
zVRu)t)?l1^i>DVcSEL}!(s$SMSuW;8k#sxb2mmY`^!*FWp+^d<P%<Rf^%oFk-Rwpd
zw1;~t$!L}1GJ%1X=#Z{tYAWmITwTOt^I?{Jc5{w`Q(>IaM0CLFAUJJ9;?3e4`PLBb
zbT1w=Mvp6D#Rq1E`)Zbxh1LqWkr;&XZXDhpxCb(1K`}a!WlM26gDacf#s(~b9{G|N
z-4}6n*-;vo=BsFc`Qy0FA`sfHlkCP+_PN*)CaHXfIfH%ckKHR7qXiH!CIn>*8TmM;
z)uhOxV$Y?ITGzWq+O)rluHeCts|#v%7)G4QdU<NlQVG>-PDiWw(9;)vO>2hVN|2OF
z1n>kRX`xN}K}W-V)L5@~3+&H46SvS<c;FoxF!$c{Bc)(%tGFQ!&jijF&_fK~Nj7~4
zYZ+U`hqP8)V3DQLMF-00H{5;ckb0#|sk-z)HLh{}uMxNXSO9UN*t#qUzkDaDMlyA)
z=8%z39$bQolKgRNX>F5{Tfv$EWNVj@ydAr#bxKhc9!*gPYli$q^Ki5>8$(7JV(iQm
zEYO9Ws%*FGPQDz@@Ka&z&fyW2VDl&;x|2~9@XTJj>Cp;@z^Ie2p6;*!$zJK^g=%O^
z#cMU;_;JO}y1q4g9$e)fMOdu&B;&H+qnK&z$RR!XJCb9{PH^HN>5{>p1fBa|mY7dK
zX>!u%(i52<cS{q3my{GYKJIdbHIoo8#LiuzW|ty}87`k-$`3q_R@1Fv^X>N+bi_-T
z5M}#BKhW3mDS+U@)7mm%i*6S+&fCx2T_Q%4JE56luN7WhjqChOf9OCZF_;cFndcd=
zX+g<`fgf7+;+iM_Z;gR*9^}X+Wt1O@4EF;5cOTB6hr}=%SdpNI-1!AYb}rg#Twz=q
z3=R8(am0)a*Vr~eG=~SZb`*q1fxE)UI(IEhKW=${^0N^_vzb7ibpnwv9I-HFXsY+g
z5#MT4JV>-$jln{T41EU;gQ!|!Ko*k5A|7CJ2Rfb`k9cHH^L9S>2ogWP;VCcyrUsk-
za*`|GW5QKgtLFiXA7cA&mT*}8$*UPG0R$Kwl=K`Foa>ezZ|SpY#X)_TJXp0L-0dj6
zhKUOmSWoBlG}-Ds0iw@nEn*b|ux3A${eo4DIuuc^b<4*tn4Hz=Jds}=iwLwA17R+3
zyjT0I(TzoRM9m7q#546!Tf-F8G~Rdp9t$&dYD_*3ceYi3&m_nM+<(cBxEQm`<SEod
zL$&tX(DC~=a>Zz26JSy1uFcjx^QvNFB`9Dt4ZHPC<20l7xDi%thFH*$O`h9Z&~`)a
z^RIHvn|ai~dT6k~wL}*kZRb+*A&Nl@^mWw%umFA7E^S8!sR^4wrm8km%8{mA-A?H1
z?rL%9I2?ud>pW(4=xYnR!FPQZraO60Y)*k~9FW8AP{JDty5k<@A0sX8*2JtwMQ7s{
zHs8Hm`4AvHCYu_PihmsI98mQbx%#kNVxAF|06LHNjJbSWop?DC3YQLC57_le_#iHS
zj>-EezIfW*#EiFL{kgJ^Frw~PY!2@U&}U*WFb#Iv@gwjRg~wSeNR=5M?5WT#hD6RL
z3O8$tQVVm}DU!z9zzI`*N$g9rep_m}s|Fo}ysQQ~XSh2`M1EB6+Q3d_R5#u<h!6LF
zdvHN}b*p-TSau3c4n$u{-Wr(G^WzUBLbUs}duE;dprA>F&B}g#;q}Eu+*~}<VBM>v
z>-cS$A#pa5ZZXFlZG3ME9vIhUb17=kBi=7CSrwfax=bXn0G*zMlHOG%V_u0DLY6$M
ztuhk0whT+e%tp%hNkJC~PlaO7@W;}txr(QWxMl=Fv?D7&T7pFZE(i>I0Ue&yl7BGx
zr*#U(1y+B`m+DwNgChUM#GH{0+3_huztbX)h_!oP=f=6N=5Lwk(`C;H(Mc0cLi9Ga
zBPNWS6)@}}tGLoV-67dmxZqGZX~{s8?saHeVm<2r(e#yJQMKRK5)#rOAR!>#DK(@L
z(%mT`-3>#lbhj`x4BcJBC=HS#9n#$l3`4y0{QlSbZN8mr?sM+F*Is+?wFECbXKNNZ
z(QN*M?(`PNJgMCQeFfx?r+<V-Ijd{}k&s|ypNxnEB?60r)AHTob8EirdG_W!xRvv5
z(Xbh*Ke~J*Bf&)Ky8+m_2iq~rnFs!Nisr!jhaGfEBCm-yHAVc(EWf6QTsTW&8cIUe
z4i1dyV~01zCs3TZ*o8RTqTsB|m}(lptLcuR@z>G7Iv9<o_OL9$%0K&6QF6#ReVYBO
z&xZger-2Cl3^#zXk9*S{cmcaQh^(kZ;vl6!nvRec^$)?x)t`OP(pvJwo`Wryt-y#4
zYAziuf&KA#@9;B0!jETfsUtC_pflo>y=C?J*n_5>{o*j3C$c4<`ifv|N+%P*M2m9$
z!6qXo(3$%W_*2561Pa>P(xTR)m?||&#O02%X&FSdZ$p=z7V>#RQr{nMd0u+478S!a
znN?(s*N*n;8zb*v0q8L~i=_kc@Escbb3@1dQT2B#LWP)I5C`QRm?t2vjesz9G2YRj
zL>Nk|&KBYTe_WFKzoA6|tdX-vw+yL&IR;3ack8m5q-c#uP&DD^rvN2A^uu%aOm{+Q
zc@)MA-W?vUFhNsq7aV3)Fn{mxwr%fDcE+`7&mdB}M?v#{tx)|A47Qe8XUk5$UVjq4
z4JGc1%wzk~f$#Kf!l>Ku1qE`fW)rKu2BML<dwp|iOT=pNlWNH*_lRM5;%F!3K+(^O
zBE9{#$SZZ0`hC1+oi9~K&I1jBo-}^zMnt^xjl!4|aB?Gs@mK4g#^F!FMubU^@_hw?
z-=b-M4H5GCmELRnmgo9mG59{$Qt-1uATt>j(EJ!|ijDQ-!2iW;EDG`e9nRw!@(K>y
zg?dK)q;0SBE`u>x@M3<N^@|xvD3A`tW)YLGCg_UYSYVgY^2HU^xa>O;!tT=O+(`5A
z{kzXef4kn#5<5?_HwXnaoiGKOUqE6+GaW6sH9^don5`Gse5tfYu{nK_jVzBgo5C@k
zDJP&dpcy+rT-o?9hR)phRjca6_?HwLBnT}`jB<S~Fujg0dcwldpdZ^HHNVO{W6p}V
zeO|)h=nv5l@`!f&TDtR7kL&~26At=Y`OteD5Qn5u-1=`B*cJMdk1DFYYu3ZWzmK`D
zYgz$xBeb@^KE76|rD5^;u~i~4Dgmnl$_8k|0U62LY$v(a5cMaX6#S=N4J1?Z7oCAF
z$Iuw>Jpr0?p;In%u*)cZs|}Sp*fJFx1!0DXd#VHH<=zGI4EL%mx3T`Z2}N<%Ln@iP
zvpApncvOLZsks{TG6Ws>a(Tlk`t;fDN#(-5g6rt_t=Si}8SoYs<#k0f`2+`zu9!k(
z6m2^9?^R7VTlmuU*UH2QCeubIMtx`PoBmVhrQnYr;JqKQsabI{covM03&MONzP?!C
z{pXQ>H>vx@T+a}GV+b-r7BIC0u2aEkQuf9GX%GLIgSa$d=BNmHg^kS4Z<mPbJDQ(Y
zF8>s#3Mv%2XKW=-*r$rQTJ5FER`sIAUeK^H5Bq<kSllQ5FQ(xz(CKURKyO7&VH-a)
zTVXuT;@j`x(^jj8DuGh4pv*Da&AP#Nt2n_b^)mlA>9TB-;k}uo&C#F3=<WiT{p?6J
zR+#?^L()anf>B%oYuF5n;ym;(+31`?|4pdOf>w5s52WTTuLfWI8SR+06|kali2bhO
z<U(mjy+8ODos$R9AkzbhYcWvJ-sUdrOXsn#(W5AZFdXy$PjvmUIK`NNqQ70hN+yjs
z-O;01=jp@gIo1LS#GtKN!VaX&0Voc<-eWolZ@_H!#HRR1-6{RdRQ8WsW&)8qXW>#l
z;mE0Z?Z(y)yt8n-NwzpAdM=_5);Ksv-(|DRvmRHxvvx}8TZOU*GPl36=nOvOwZlcP
zPjz^7N$1*GPOCY$du~gI<uidyT!%E=w~etV300O%9)PDA+z?!2lxSpi`59eD-%i0V
zCCxj$&iw9h@VQ0Gyzu^hNGa%y5gOJv__7RrM1cSNo3FbIb%<uyUYF7)K3|w&+t`wG
zeBbW~?YD0JJquyvR!cw5jeZh1JQsQ8GOWL!ZU9tZm9PCl!vJ&8A`_)~)*Z?HDmt!N
zAuLoFxA|alxo6ZB9d~s3vnets$o3Vu5Fi&W^S31bDzt=D0~xQh($Dt8!wWwmuw<tS
zg5m%?GU;o|B+eW*`i$Q^3BHOi`s8c}^6o-EyWrN~sGnWF3c&VQT~YjbtN7~91Usmc
zl|(#C$9B`IhWWJ$a!dod5PDLmNQ6_m;}M*|9pF#d&C5n2D2cjZYwSK``|xK5)JOvM
zj#vBFmXtbc=5(v@i9E0On-h{qM&>%yFgT%`)SiiHQWNB#SZBp{uiQAg$e-4H7Rc~Z
zcl+UToPelaSEL{}(H5pBT*B%akm8@aAUV}*05)Q|402Dgq;fE|!^$#2|08+zoBr(!
z`r(kyyLoMw`uyD1oc=+1tc|M+T6~HXx%}GQ^|H4m)|ui?9^w2{t`uoJ7ymn+?$@=I
zGClG4<xlS{q>TqxK2HQ+RT>Rw`k;%ujc|*g`@BL~hC*i!rxlx4Kn7!7ifU1b>KDoN
zCJ|G*uReM(^~U5i?((S5q|=?#J&z&znU^MNNDC6AmEzm>Wtd-hu9}HjQEoDvqJbrK
z6Z^6>Q+ihDXX>NwkEP4sUm>5^mwYm6FE-hDH+GyOocl4|JG`)sQKFEak2|`F{^WdV
zw`oSs`AxTOYhJtiv!KEk&WO_S$^t0$e4Iy&V3u1%E^MQ`$NXM?*iy0GdznPQc65TF
zb@S}a!uQ>7dNmAGN_9fsjU41c+5{m9Z(oK*V$gpB4oJFcLnB??91UY(2m9ya?@fag
z)?$<i`d2xOtWO^=sBBVc_bAiVU3+T^yBj&ZITdB0z7dDcq$m+qI+FMlvg=?fn>5wf
ztgqu3-r$#u_-608-gNIW=Msz6la7~meB*g{)^tz%=#d(MF}$jZ$3}}5!xY1x9$rtj
zt*dZi6fMq^y3k26KY~^|q+Ci6F8~@TIDHp-)~Plw8?2TeCcgg(xzSKfNkW9CvMKx@
z*M;ym4Nd%SO-~pRL+$-HqI+^SU;0k#lRfVUGzTN;iciGhRv1&ybEgk!Zg2<pt99Hm
zq3ip)4n#ql!bY%JF*KoJ`09T{w&0?jGFe#9kT=IF(z~Kn5eX8s5FYp;qak)}<7jE#
zJ08azb#uO)EjHfY2%>!nXX`?L=_ALSbcP-|N0=?7lNy9&s>l6&&2m}F#Omx=7m&i=
zGM4-S*^Ew^B^#_BDLbq5h2%_7!2+g{h@+59VpZ{EVKp-oDc`@pCzY`8Rzwa4B#;~I
zT|ltQm~&#9fGd>~XK*$}49hU4h}We)h^;s0{4F17IT!X}Dim8fgCC$VzKj7gr$!cd
zVSNu+<(<_dlsEblA&OPcX%x6kxkm5l`CKOU0cC+_GcZichot54>v<g)yG$N6QKXA8
zxRKD)TFLwCO<uP3qRQn2>2v3T(AItG$MmENUexQ~=ephW15_BgeH;HE;1G3~h<;ya
zT%>9STk!I>2?`n_mj8!M3VV*VcQj@*lg0Vx3z+4e#4*3N=s2;}3N{5bXsHp4VjQ(X
zJ(3S)5j>LzsPoFBlMH>xa^QJRr1}onPU|g^w{ot~@S0H$_!J*mPW#OCWElL3JzB)c
z&44YTK<1@lFYR(@>oZq{{$8p$!^ji7qj6wQnZOBp<Gow7z?K*~Is~eEP7+!t()NKl
zijp>)QZt$QiA7?|EUV+g=@|&KbkI%IrNFqn^x`$L2$}UmjEls~ABsyuX&8?T%o`qv
z?$R%xR}i#Q@#LjB@z8erfgtUe&?R$J4Do%LzK!Bdw1HOgTk<l&ThQ+e7F#5xbeJLw
z;;Mhk`Xz_a;#_K5V1j<~l4=QLZw02r*hvpXA*lNgS}`F(Cu=$Z)YYkRf5qf>;~-O>
zuVSk1GLNIJ6(xh&(%F>NHZnu4nWekeK(X#^+KH@HbVP{^g!dplaH{~t!#DHS7s3y}
zel!6+_BtFd#fP`BFIVE3yi*mce-A`P(Z3E!dwvmf`cP@Mq;`ifY97l504i|*jJ#}x
zYWE{p3jdD^#zNmkn$K;UJR)1Jvq}>z>jD;R!`ZHloP57Z1{kT+y5gxn{YJ#bo0R*A
z<h75*BKkk2I*VA;SEM0H4`HQ=)Fvc3yI)A6%V?HTPE|Uq&gGPfPXWZGpxBxlB-M_O
zyF3hqu8r<T4g~)S^-st;Vl}?Ur_iaQz8+v6`>^JGkjH!4no(%Vfi=a;_F2;IQr6jU
z3H7qi11ZB$w{sDLc&TWjkCFHHM5<K3Vgz0IN40LR?N63NXVjt-ym;$M7F*@NG|po=
z3_+RCSEWOqC5eD+PZLV8(z{Sl6xQX`v?XeOV-vx&%aJw2EzZj@+i8B!i2N-oYM3I@
zjYf8Ptn^u(nUCP(p_BQwzp434yzkwv(6O&nLB+~5a;67eT;*59&kvoK<B?~-+PH~^
z?Ym8#d7zBUhDaKNTtwrzbMI+I@Jr8_zXwDV6(b@P`mFc4W_AblD9ojGBs&zv3d_Jc
zgl~?Qwa$^FP8>_IZ$r>s!h(0sKR<L_uFnGX6<b@(^uh0VzqaiQLEQM+*#1PGYD$@i
zD|_CSQa&!VpS${sw7rfR>~_*LrExx_0J}cz0i-!l9~t8*+U5#Kbd+*=*$7xqkzzQw
zjDg15d6ffXd$o$}yk|9ziAKY)Mi>mj@(W1tcUtGe{vgvPGf9{-i}p!jb1TpN2Zzb;
zo%V&X4kuHpoe4g#@`ZmRiDe$LkF&XxGWh>fW1_8WQ%7Fiz6fT_n1(ll?}>PkV;;l*
zz4fS285HCmF{5NyYl<t%W9!mZVh2}EJi~6cyOA0@1RdAUF1=yY9!VW~f!*x85_I7G
zR2ZvlscLq_G7)N|ANiO}o`91Uze?mz6KcHgeo&LDLoO<fGBK>QY=56A)}_!YUW<*X
ztJ=tZ%<0Na*?)3&fZfULJSn^+bffV{q2WB(lF>lX{jhC`RSrCze;<-lYvq=d>cpWi
zrq}w@M-I7fov3NEGia~#xOsm;w67H?Y0h1}wdWPKybP}e^<Ql#7Q91F$(0*&h4r=4
zZ{p#t{mFtApvWx75`SsUMz)kC847&#emmb3Of&xsQ_S3pvY%%zd`$nLt$50z&_{=g
zVan%*Ku5)ZFyy<pBKEK6yNaxH0$3rys2u;e9>zUEJ`^;!Xn(vgjV!yagip@dLXY($
zKeN>1?)Jx3R5agLvC^274o9jA&A>+3ZdULzb}j<ezA0i-CU7TvZ=->|q?MD74pMc^
z0vTCOJ(;c#N>%<%e8r*3UFny_Rd=6h*j#2vQlUpx`0uqFbEF!V%(3)4#(Li4L7d$}
zw=V}#tZ9Wr4tIHAc<D3VKOXH5x;vaOnO08B!!bmU9JvL{^%tPz{hT$kSaTR@CI0qG
z&5l9s@|Qn|p&3<YZ|sam_1|abf2u-3x4W&tK@#S)BvJ}0609eIr5{|e9}WOpnfOS;
zcvYCuI#FeUe?m&rKanYVlqxg`6(wR_cTvP56zxDRP^$@<D8aF9<W%G*7_Vh5m@Pu_
zgBnJ{{nT^!_oq}$lHZr{DwF&xH)jq0U{#Tjkwm2^=DAmD+$CngVyAJ4EjzCr4w(ET
z0yjafqA;VcF^Do9_w77ddUxj4b}CC;bf_2-@Ws+^sAaU?9vVqT;r_ElmW7)Ji=(^y
zjE5^E;!W3^*lQ`xW{Ur~#)3;`Y%dvw7kA$dbNT7`kB}J}Z98@%b>!5k7BPtg@7`oH
zOsd*w*=r7p|HgTraZ1;r_PAEm9c)f%KT9198vV>FK#ba4vk;D?>=@|h4+rwTB7^*Y
z4o<k6R2VgsD}>R@%rv|r%96!DA`g^}Q!bSWj|_hvd0qHeZWXN-gkx0`^RkvJM4j@Y
z=9%o*#}pbVW3?Z{^PpBKxCEER#G<Z^Z57kqx_H>iB>rxIvjNfP0zPtkZB^!#JZ&FU
zvYk!v`yN@%mcJ$^KNfz6h8}O=N5c`gMPFjimod8b2@a9Mi$s0qjB~Zqun!kYo4HU8
zi1WGl$m+)x8-6{QYlnBs!;RxkhH+%;wx}z*tP(n2ZrubXUbWp)p45>aCB8)R<Si~G
zSE5l*hYw|_5goy`Dv#1L)#OX=L`WG;n4r)UGb#oRyQBICn5adcwO9A&DVpMDRbt*d
ziS&3h4AG&Na??qP{mj{IbQW&kkqs(2W$V}f&~fqg;a(0;&ad&d3P`a0Hrq)?zY_Zs
zCe41~N7?&roxzf>B!Z*vP>&&U?Ko568E2O6<5=ykyp*wE5V`toIyJ@fwuAWo+Hkk)
zmCf2tP`#5y+aDAT(KiNI-(6yLJ9J2tmM*zSA<jvGZWhM=Ag7(^ea1$}332G(5oc+(
zRiPvcD?KITf6fS=E$~{zkF8<}mjY9H%+G)JHaYZ0=g)b{3-i8j@Tn!8t>c`|Z+`3S
z?EmZhXIi^+DVJgLDLP%!(j1G@Tw-)S18jQ(-A*c<o$@(5R7L?IQ4?185a0nr$A+(O
zdK;0DVG~5WaDEx2jEO5*$#1z>ZhvA`{XP0}%s7{b*8neDE!VA&?p_eYn&83#C5e`K
z{Md(|OF-wE+jusTlWS+dtX#Xo4wZU6+wL>ruPBxG*Myr}ZUgm%nR)8hM!sjyfgfv~
zX<=0f7Kt+E7rm$#C?w=vvF3EWM#o|$s|B@mbRmV39<RmQWyMT+)-;b%oblh=FZ%~P
zTkwU&PDXWoYBkUBWLL~l7P)c!@lesQssc9>7HDt&ml2|#vfAO(lb~2xmn)_pN28)F
zO$PZT`!qkGa@-~d#LZ@kvCH?k?`*vk0GK`;$lbvfL;BsNh?2MndGFfq7B}si;fm}A
zTk3rq>6d%H^Y@=q(-IrJb%P~ZrDUSJ4ORLI*2oe;J}V+*sDpW-(6ce*O<`^5KQVY?
zaHu-M98!8BkpB10=1KqTABYjVEYn$HsEpz@i-r$69&`N^rN&|^!_C>7G-@oqg4ND2
zpsFWv8bO3!{X09i&aCeSk4Xl``Uchv=VTYH&@fBiS4|`8;rPk;&&;N^v#kM*tZk_D
zuEFRI-j^<>Hz*f@172w~53@*MkU!Ce*UJj(t*a3NU6bE33EJg&{AIIhR`CGaq%3^j
z>2|IlLGPi@r=o6o9^1$gcA*<>nJu}8mW-V&JxRgV&{k54#pb^V7QbMA;~D)SPCB%X
zPbeX@;j27)B-I^HmQ(oGq_6L$EgJj&L2e=9%-JPzSnu}Y`s2_|;-H~WlOkC{*3^iS
zWWnd#n+or;FO#B(uRUFrzl<lFd~VfDtJaK6S53|JZ`yYDL4cFvLlDksa9)_}c$Q-f
zOm@sXY8l*eQEZdEXL429-GHMz7^@?n(3Z|ogtN$jPl(&8L4+fz@(N>J|IyC(WV>Tx
zrJ|#HseJ6n@#mf+4b<W^ZN6KE7R{6=7-J$;SGZ1l^|->Orb1-iB-HRZ2?iy^H3Ofl
zDt@=%<ye3}Jl`yhTahMy6xYuopl@xY3QM7(=(3r>+`%qM#mTo2UA6i=y+WU=XXuqB
zeOw2r3+RreM9hGaXymn5S`t}@o|Do~zj_Xp0XDnOB&BzCmLk8I_=A+_K)i^r$B+E$
z&d$k_OJ+5#dDI-e(*EVgZN`(%L2vr8k9cl;aWKD-=GVB!IwJIs0Xa8qg{!heHcfUK
z9HupKRwXiAw0~1v``1Jr;o3tXRL&E&JGKmz<A@J@AbrXRFpI~l1e~+`=flg~%ox7r
z#v6#wt4!&OJRFSNNb+5&WYDs(IaQF>E)fP6MjUSzR`RB6P~16ue&HqB`*Z-XCdNWT
z93A{6%7XVbfjPGVofv&4B5yKMq0e^)j-nX+X_rg;qR8{JUnz}Vv}MT6ucWQ8;fuw3
zrKQK2yAL}dEW*k@@3s+#5zVx;NwB@bRi@QPEQ6lN^?7x3CePK5h(aBYU?QI2R;cQV
zVL54j`lZ!-xSvC+5ooNIL>;kP_z>}_B7xyAO!-^P#8!&U^+#VG)i)VVEVf)*L(O55
za6nDBCVrw&OjZ^QVc3gkczVFgzAdG^5Q;sUeR6c!E2Bl9w1@0<g%N8ki?LC-o$A)r
zt`6Q&4u?a3&Gj1cp1(h3g-wfOYWu(Wtigl9;^}h?r(O<+YU>EU{al}!VMX=1z*0CI
zn!VYFg(kEA=>zZnC%NlsJTYp7fnyV#nx#FD<WaB5IVOahd4q&#z2l&QS=_Z=TR?95
zCwpBfR!MA18!IGMc_({kD`=q@4?ks<CunUTVPktqggk+WiA$(`>$;|~y^qUZhN|Jx
zZs$24U_b)>35qAv&)sbL=6li`0C5j?(Y|#Qt|~J2U4ie0cCpXrl;k=#6TOx3kQs$o
z_aJ-zt%ObI7hCt><%M3B%pnFl@t+%*+;Pi{JjP1FLeXGW5060Mv~7ch-JjNc{ArDv
z3A)5ny%84mN_sDYcU!s0ak+IK4R|TEx|%o#?S@w0vPq~*0b9o{YdV@22OY0UY_QM~
zgt!wLs|LL1-iVD^S(SjVVSsWjio3fvLFz_Ky6-mb{W$k{)AtGJjAbKGbT%DglPJAt
z|Ky&w)Z1|%i$Fi|2GmCd!3cEo5mgtrG;V*)K`~ugi%;5{=9eFs>dr7Z@L}52?Ge0|
z#rSw0Ao-2u`%6YcuT6Eti8y4;YKM1VxDNhRlkFLp2e0upmYSi3WImaAn0sVEH_gzN
zB8#}ruUvyA+_^fUu5e>9_P}vlO)0_EqC96*O1=BfGe4eJdZhf!JvjXw-X-qZGj*sc
zQo$lJJ_<%n8jUoa%k${Hd903IsC#9r?$d%@eoBPvp#Ss3lZ(ESq)Xseq`RK05$}1E
zyiz`Z6>-T%Qw%JaabTbjS1>zf!{Ocmy&JN~$H54!N|0xu5P3_35i>%Fi$7(IgVF0A
zrjyy1J-QYSWnCKXERW0qu=M?^SuR!D?c!~%l7S@lcB|gYcx7?k1WF#g4O_5%)~H>T
z=pfJco?J!=OvCR5S42T7HOBXWz4@1tj63SoI^|LJhWCs{im`aTXt#Kat~sek$3Zz&
zL>%fG%)TxH#okT;5d*<?-bX1(<DuQZH<=<BPx_C`zK3}9a>j1vuXoETq%|i}b`YhO
z>ja7M`0*+JlRxH%zN|`PKG7mlXv2^3AOC7O?B%ZSX)!1JI{K5XoVSMiC+iMjv9=Q7
zc51Rrm)#k_u(MxAoK*zNU%6dYgS_{Sulip=3#b|nvYIW<bp}clD3Biu>lPFoo%LY#
z`tGI?%^C~i#zAUHDbNDC;U1%a9uaWE7nQs9(}VC^At48`+g@^NzOCEQm-x(HqI1b3
z0J#feEL+UI-gkQV(Zq!Qm<bOP!LUE(hWSCs$zL&gi)NWNhNCKvGa7#1f>wz(Kecy>
z=^tNnAXxR9%cYj+;L}ly9(RC|g9mG29tGp0HD6O&f}{@96K|!P!&VE|*Nk6xQk+xa
za^nNn&OO<-OMKa=7Fb0xf4cH*r=pe(;aYrqz2^d)+$n~ku@8HBicq{xXAzzq@&--b
zz{W~N=@Zs)ncuG#vVD&OC0h-6{YsV^8?Z5AhcpLvJO}8|(b}5a$LH89P{Rmu)owd7
zEj_El!(0<S@Rk#X8fLg~6iXP8;*w@w7{avm=<5SeqcEy$=Z?(F2H&Z5;_H0oq;o5p
zo-~SogeB_KAr7~{PHZaO*uh5cb=eRL5G8+PK%t?0mh-6}XS1~WM^iV4%_`rVBUFsX
zoho3<7^&o2CaOnWr7&`u1>7HfX9-&#DO5GeSj)_9c>_0;3R34&{q?LN;}FLhheI~B
zyhk!Vb0L{1_D~|U$+rJJsdw{3$yHzL*p{a5a|(Y&1MOrNFk#hst$g{?-!=EdJ2MnU
zjvnEnqkimrdfjMo&Uz9{hAU)$;JE>1NuLXs@uZ&Xe2JFhDt%$=j$f*)^%AwiVk5_c
z5H~BO`~!uM;UH3jD3{Gqo}&D>hJnY^4B@8DD!Ry2HI?bv)56N{itk%_m%#Nk|HNOS
zVGFJjxaYnz<QIldfWKpecL|ODspFsoCcqF7<u%;D85%O9h=Q6@;3e{y1H6)}JNwDy
z-*9B$ekr$WMamH@l0yb+zhV?a52jn6$V^{LOxxL%yXCWNOqAMpkFkRO()pe<b{QL$
zGT^c29)+Pf#B`O<#&bdo`Ga8@{FL3QdoU>})DD7wKW1@8B$+0O)e+)t-u>}`IlDY-
zrJv+DkXu3=1bA9av!$s?TDnV3M3q~SPi{$6F1bYCT=?gib!AP4`v4@u!5}Nc%wK_(
zSF0LVdLvJ7?ykgwH;oFfOiPcNosm5M^F}Y0JcSCA-uBpo$+P$9g+?2dzv=6Xa1{*Y
z(9{j6-igc0SdulwQO<IiYcYd;8|{@07~2oB%H5TH><c(Kz{;JKS)7&Y;e7p`+f6Bb
z#n%QA4wGp_(=I!n$ClM6bN8s(`F45mXFKz##`==4&;KpMGUt&}OweFa7}(7tW|C~J
z<@qpZ&<S`!qJ7_-f0XMvH4p~Ss{MOuw&bN^uK&X(ZIoaw9)5yY@(22mmPL+PoQm1q
z_+vnsO>;XLCMPxAUeS`R-CWJlq^q^SiodP+JA<UXYVGWyeZt{R$?$f<d1StL%}9vI
zO`KdKpsm@;c^M(mLS1ZePR-|68%Kl@J{9)WqTUKKTm}<Wle@jf3vgf!-QaCWo*(3^
zfv1sUjemMEZ6O~j@qh@s6jc)`3Oo4BCx7PgXO;G-zzru~+HvH`gom@Ypt@}Y=>CRW
zjH%n5T6SnW;x(GED$A?>57_sP!wkz(5;Ge|jg-ZB)Ep4zz>)`d%qFrq1u8*AEU=;A
zk||re|N3Vae_g|5w}y&|aFB|-Nj<MuVD_SXhf?OA$J{|%{|t@z`$NySJ10$cghPds
zuf8e-rRAFK1&&U9_%`|e7eNh-ThwLp1T-(w{RLGLpWQypqW+8D$pifo9_{Q0-a9q1
zyt}dr<aK#Z`xzM#;f?LVb>1el;<vhF=dT_o2qa(vxZ+IH3kno|`PZsW$d747Z?NO}
zjgbPfiG^7_oE$NMRcVMRIO%@eMG&Naze_~wk1H1!H1C_X#`Ri6lIkNIpgZXG^A3`#
zT?!Zm7VUQZ6Q>#JNhNScO<rp(SC!@?cE3=CduUw_-RSYlRa1jiZaK0qJp7|$@l^qv
zmcKT0QkNU|1??nR&o_exy}d#fA75<?&vW)qfv%QY9+aK$dhNGL--sD|di6dJxd!B|
z{4?9;ek2o-3%v3lkn<ce#PR2BQ;a3eD;h?)-!-hbc0Iv`0Q)|bM+uwj_gLk>b#8=)
z3XSb?_<r`eALU4Y+QIJc-L)Dqcp2d*l$<X|5-yVqaj(&rWWJ*2q7YYg#t4W0{Ful^
zVKDwKon@nS=A>lyP2;cEnUd>G8x$vYS4=#FS?Mn@^9-?JThH#Bh!-7!UE3al{Ew_C
zW@^Oey+>#*k(xuEc+4Tc5RK@q>;Uz;&BvN;=n|q4kPkYG@M?7X<u%hM$xUafv>3gj
zu#*`ngh+s;fE*IA_k0Di^CPCyNyZk;Co;|7e)|`@m12@+np%{4HDGBa-}9;BEf<AI
zULLdOUM4(Uaws<7A^GwtYrH~Uf_qyWarAzv|L>x(HV~&4)4U(ifxE8WktzPR{YfhI
z^2GDeywK`Ezu7$9I<vlkRfetwWOVG71D9VUGmLL-l66NUDNujxo&<3O#=&F~dCxtw
zfWHOqN*axL?Oa%=?@KHQ=dU96rlwKfQ5=gg5rxb2NP8Q<*<-e~TMd^HIQp6qBzab;
zkd_N3W(|@NoqN;k1nLVLg%bFCSrOx@9%ZM<9HE~Ul8ogHK#OixhAl)<Av5I996^h@
z=RCK+$RvF+lW&g{M#S&?qhUc|A2ZFi!tWeC4okMP0L;o|?Zzh~qt~qy1}6$9TQa#D
zKa@}4Q@=NbZCFOd^0ijw9v^$CB}GJO^5<A10P&N_t}YQpE{=D6+IeDS0U;8BW$}OD
zP1!k*n}1}D5?jIV6N!1&(?inv--O$_nK{-kxOt<x<daqfYcPh(+$`BqN2&4Bc1@&9
z=-pg7&n3P@lL9!ME86^i8DU%1H<>vgN);{x!ius2zeFozT!K$+ooxPdRM+xHMZOfz
zhuM|{3yofU`OIP-_D^WcNop|??~?&Cry?6g2@Q7csQ#|6pK7sRAiPRHP07W73%?!Z
zPVIQRDXU#o!;&xFe&z4Fh}HrLO!z&ct<`Kc+-qAPra31_{!PD<^DI^LOE+z1!s~pu
z&f@K`#zSpaYm?x2z7Fb+TR|f?9@U4V+QHs3It^4^OmJKC)r*~=N2pOq?s)zVIcb0~
zr>HBKXOu-<b5>lq7+wP5p{Gn+QLruDx%a*A9>3AxWW(R0-ZmcnGrsa~j>QK$Dw)40
z?2^CvG2<8AhKO#D5pR2oQa@J2{oG*?X9De>0}XT|U_LNRgpLC1!vLxKn{enG2LZqD
z(4Q)pSQy@@vwObodET9W6Q>%+8F0zKf>m2&9rz$=^wp^`(cMe<*Ix(0jmyH00QK=1
zV=@V*jmLSV=ibKkQ~NjHcUu7x=A53Z?OP4jG1C}{x@EVY-pmeWR)@{)yru~-pP5uo
zH55D#HsK%mwm+*4R?HL|d{(8K$P~>}KKrPNSxd5ag3}+dYF|!DLwS)?Ikv5ig>joE
zz>~ac^5vp_F!(Iik)<sxk9?&<?~!X;GJn3#P9SqwO!t|Clxrz#lHDid-@4d${kzHT
z-UJ{uW`2gh`KyrKbcN`X_TILP;VAJ@WYxF$zudEd*T}^`WEbzFy_g``@jD9Uo%5F#
z3>#&@h5hxYX23P0!*|cy6-v{|lkR5<hbGYUmU$Wbha$7ljuoHBc%nA=;3E!3-VZPL
zuUZdDOz69+p(G{#BqygZ{1itBvu6Yei|y(S+2miPjYRLM_GJ9GdN~#AEi*Z@XF=zG
z%houru5s0-!y3<PSM}$+0JyHK2-g@iDT?%Ij1zwItG~J|l|Od56?`juIGp>u^~Lmn
zoD1r^n0pz=I$l1?Oo*-RuHs4izlT0zhz~(Li#a;xw<<Tgqg89YV!`7qC+ohml{{}b
z-*!E^D}4OzRly%p2RwGPy<h~)-ww@0GTlxqO6eiiBnLYl^&i1enR6}{YLF`dV+Zy3
zLdu%K)l$X_On6bD%cXx@*5n6}0M)$BrEW8;Q}rmaGMHOK!jL!WYX9D>bzi2xq-pBD
zsl_i07b;E2UKXWHJ0#AO>`M3M2n!7dqb`$%?&^J+>pnd)I6Ibzv;kC)6xg|ma7X8V
z*?GooP;rIQlbc|Qtbg0Dh!(2K^?l=Es9@6Cj<zGscQ+Z0hLo!aZ8uniXpylzGWA@H
z<f?PN<w5*P<GV<b_OknjLkylAS>y8Tfm?T5djQ4s@+z#po@vzm@TyLs0*Hg+!7gGv
zqFXR7gSpGeS&<&)Ugw6ykx2)Hj-{9B<(B&PGQcJ;xE{7@etPF_3SwAaS=_oxT=HfS
z{-Vqtp`e^Av8)&Kv^>6=2h@fYr+GF6M2XGMFi_ufQUdwsf<6ovouO+jA5gJzQnZse
z#d4lS9Rv~~b|H(2ro88(>H_c7-J>n0;;~>CGw$|Kr1cXm67e+vUBqHa8in?7*>6iM
zHjXfmQ3&pSsACh7c8CQn07}G(4LOka7MGdTo=+D7Lu@)kZKzo6cDm`nLfGw+tBZaL
zhANt}G;NB&Z_Z$nF@c%M81KI&4<@&#;@uU;Jl;RaXEO;&ur<iZB<a<?t-=m!M!=K}
zn<Ud{){^pG^oz7$Pn*4AAg&{Kc}sP2_xb|Zcyz5oEHG=F9G-_0SX{jjT-ptD%Nt!T
z9_fA}gl{jnFPj_lMlJN1^gc9=SA6N=^5ccf*IX^@92v(14Kw%v+kh9_cPiOJ3^dKB
zw?qsBkA}A2T_QfA(HCTSb)B?cwX$n*Q;<6T!VLE?8*l@>KIs>#p{=~{kiHQpBf?Ns
zp)4PL<m6II>(Kr?@8$kjtE(l0Dyi0?iUr;9wu({o)bq~~(i{sstXWnvXAohg$w6YD
z%hpRB8#3Oa`Tws4@GRSs-b?SN>Bf0RESiukO<g}^0OL#Ru)outLbDOh==c{s*{nqQ
z0%ab2G<T5bMR;+pSjK9!p?Nju>z~JTMU!6&n9K#M0~3>0O?Uf)A$^6hb;0LnVC%eB
zLoB;YsXQvH!Q#fwk>AQH6`l2G-_-52?F?h43bX*Ig7U28g_HgBgTo9?cxda=?OTWl
zi~yN4FfKyD58tl-bng8N*1R0>9XI2;k~9~PLu`s(Ll|i#-WyS8I^4gn>xNX}fp}s)
zCLFt*omkofNwr^3OTz~xj}pk$FShP*A<av%*B54f(WxB7pH6JCFl-MAjI9$i&nANw
zz&pDIDa+v^UtDJI3&qS#3IZ-~#th0Be~{vuvEob87JKRuvX|PC09OK1EZx(>!$xaN
z8;EdM^xjeEyc$e%Uen8~ob-SeT;Eul5^tM<q^X;$0O4p?Oa&NHWz3g<Uhz4rnhgII
z7HHMW2~`&a;it%%Hn|FaI_%yr8PgW%7TY<E2p-w)yaf%lB|Ua5p?1uA4SKknG?M8J
za~#T!UERzIm*pc<;Lz8r?kXqc%R-LW#L?t^x9T8|<Dk)8&KHu#yZ;UeGFEkNY%lsO
zBLTM(_kCmDXO2&<OM}c@5{-S@L><45<Qp;BTobv^O`~BWCY(ZZD(+?%o}w4(Bgr!#
z?4vJ3L~Mw6xRUn*F0r0__ZM`=?KGW#u=@4_TUk~-{vsvxLnfsxdh*dppUHSvgHNl7
zx5LA5nooT?^99BJwImk12Q?zYTLm(_J;vGh`k_atecj|%yK6sy(V<5OyiN^d6H=hJ
z%>FuBwJ8)1?YTy}J!>46b=Qc?)l%2oM-ySR)I}er(BHD7Z}yoodGb4_OM5Y{n|G|x
z@90$Z2J!l^gj01C8vRxyp0Db7%HWhmt4VPnJdf5Ny~Q!g<EV1aER9SKfB@tNn{~sd
zrb(R}x3-V?eP3j{C<CkAs>Ssi0zYz9F@s3Eif2JP=4lLPpC%R{OC#PkO?18m$IgwJ
z!}FM<E({^79qU+FMu){Ts$fV4J)?mN7S3n7HH7d}kiY}L`H0e0J%7~*CcSg>YH``-
zHpAa54Cx2m?$_-5%p4-cZXPK#THwFYY>?08dH8{o8>#GB6?Ap6tF-v-;HW(Ry7lqf
z)_RBCK{9^6qG*Q8yjJUx5zweNv8>6?^lQL5_z#)?+FsDk>5;Xub;C2+I!{1owKMsZ
zT7AvvcsLYZNsAuw&9R-EdU81-jN4`1{Q%Y%4#obD9s}mRk0}Y768_=P@GCrQc@)k1
zRG*IdW#Na><x%alXFf?5%}35x39o_g#*#@2_$XXn^kX*wgk6}&s0xq*4cMJQ*hIzF
zYo%8)jTsa3KvRfXUeP|6Si7J$DV)*bpOu+15!SBJldShYfGa^t$FF{xgwm8N5Acw)
zH5opHG31^6b;cheR8>&9i+JhS(atQ6O+tFgN$E0yIrT%{_)u&X*{7<x)U(Rx5Nim>
z(a)E0hRAr;>-X3&vQ~V5HH@_mdU!v#$Hf2q#mK1D`ERTEhbeMr2m?Z3F(gyeKj+E(
zWcnp+V5B!ILP1Z|2Sg3|sFHsuQ@E1XesZV3sGb5D8#KJ{P5)-O03w9#Noipuq()`x
zUFL4dPlC2u7j#~tA}#Egj=T6>!N=;E&dCG48wQN&OdG9zd!=f|Hi`O=bQHWy$y<eA
zV%nRLyAzg|cn$)<tzQf1Xo(q*Bzz(tcReS$b6v;cHOn3-&#j3>^e*h6eeMT28J`Ht
zKfIVOcm?wj(EYU;`#zuZxzi)2D{jlWV|Cnjy;FT+^+g^F)gj3EOQ2OYL3;~#OmXUk
z1^hgxk!K7TF8K$a`gKj0A|lTRDqjyT>3*mj_a<fmms0!gmCd?e?mb@aIaWB=)0W^9
zy2Y`=YXi=}wqpsIt0sD4dMm;0Cjq?=@b-rb(CA!>|1iP2<`u2cy(lUfUS}Hc)Y?ok
z%olK^7PQRNs6J}zn-*;9(=hI9{QL=~oE_qN6|#D97IcllPg~{6-elm$lAX95!hS_+
zrItXD6S7{4Uw6KfT3OYkdrEKq$AlSXj*RYlM<R9AVCFWewagQ+RV~hemZ*F0F+M+n
zoUeFpqO^Rz26TlRsi!J^GF4*X7WH)8>3!(&z~v{>J^ujwQWX<vQBT*{Ra55KYSyh_
z@}$AN9S*e<`!c5|G*4@^8y+_K{(!ccB=ZaHqbL$pABLJ_(n}ZD<7VZB9AgY&{z8lZ
z3wO5@;*Ac1M(;GTgBtO;I#k-yK=hsp>Lz{;Ee0Ns_uI2Hl)f2;f^@p?3h<lTrF%Yb
zcN_SmjNfb}{L~uZ`&{VKbll6ojv~?js4jQp9U}&>R=NmSOtmhx8lYj5H0+5SCnwk&
zb^tF#uCXdSeeg*dC-<cPZr|d-FMzO=`iOPz-Zx28FABH(11cjU0q(Wk4iQ?zrtjAp
zbA}(Ja4>|^cMcqSE`pD(0!%(_ug{w#Zsm^MRBuOZ`3xTvv*#u@n5s@^_*ItYFOM7>
z=q&9mg!B-!J9kBlKZ)jb{pePIR)T%26^k;T#kLNI2H)@4H-5Aximf%*GDL+-LUauS
zm5Ok5)U7}%`-_%tMdL%Bv^)oqL|<RAZO#mVw@6c6byV)<U+0g-zpLn`r&uw5DQW5x
z%6ZoO*BFToL=ma!bz3P!7%w?OtIJ3>EZ!qMS|ITxTT;3xD{qKc#+k;p#7`mtq-JH`
z&lJR@?Hd-djb<{5{r$5}o^|BEoTert>6$MmXbHCmQfWOOtApB3ld`L_R#l^WB7vR7
zBQ%l1nFGO^qZj)YK`F=u!EmTM<*a<#Wf-uG&@HEYJN9)VKB7K2pm`kOeqazi(Y-g8
zc(tuQ7t6A91{?FO4bdN)j~bG&KDADam8kJ~*Krd6INsYqlhAqfCsZg=&`8yT<%5Yx
zyQES~T-627vudtwZlTzH?xEe3XH8{X-sPk-eAY%2BAU2#1Y?8!t6P2pH}0t+ZyVc=
z1S<!Wk0TW3Q-f~2j7#!}G;&XB{5)C4f;}Du--OGoij61E8SlIbM?wCMG8vZG^w8o(
zHt|?fmWFqMs>(>B@sD5b?Q%}44H<5&&Lgh>wTtlZ)<7k8|I5M3=RSfiRcX999^zH_
zwd18=nU|XtDfwL~&bgJ1U*3cJ-q7|h+AaE|9&_gM-kb><=N5xVtaiEXvlL+Ej`C=5
zH_l1qX}|k@*fA4-TU)8R5(s?e(wlm0k$on9@^L8Mlt$Zw>g1X&8@%P-lYZLlYy4RX
zKjksG8mGcvD3+QpRUq{vv=Zk@^?oCuDRg5Cv}|?e2%AUr{PzA~3_M-GYa`3yio1iX
z>CMjyZ*O>db-!u0NYeee*K8I58E?$*Jlu-6Iy2@^bgTLSe9(@ec+%3f)ywp!u4}6~
z-Fv81MkjSdeokh=AZ7sLRpQkKu6&{HnR>&s>zvqsCssI>^CNz;g*uZAS6shaf#NO!
zF*E-~8{~AQoGy$WA*Cw`9>Y({RzAp~NoP_-_kgh+NQ9$&o>oM4mp&`;6lvi`)db(p
zL4xSq{-aOR{o_-wCl4%+W1ZG7gI6`U=v$;cTF1M$Pz8f@t^Wao&O5-IhmwbdQE1kU
z94Me%w(Xp|ki_1LX2#mYnTCG}j9~C^{<6Q^7^QP~6El~LG+z<Bz1nt2Wt~)3@FvOK
zOaqd%1H!d?PI$@r&R-?~{+P2PD#tHY<`RrMTC>I{#Z42*P@G^AZFeh>3)d=vOahM5
zD8>1aCLLj^S$;|514z*Gn)Z{yf~To>&3G*Vcyeroe)G?3TCUu{X3#+Mxpoyu#aO#*
zR&meG!539bZzmjDaX&zRpr7z8*<8^@Ub&vXz0y|6YDJ1m1}J)+KS>rrVk0@x<+(Hz
zge-2RMUS?&_#F1uOFHe#_Sw#qK-9Ws>m8>#?wl04%mC?Kt46ET{|fCA&sK{KTSwlX
z$Ra3diyiCkXQUt}@-QXoR`fFRyVJQVBK;sdHcK}+1OD|F53^_024?2e@UMSHkQu)A
z@=MISy3|VIcIgg?-frx-@?tIg4pld&HC>-10bP^0&mmr#h_oWL){z5(;Z4*g>o+Uk
z7ZNdtgCW*~V>_h=tF<`PQVW-3_rIlv#rN6)Ye+oEuHMJDc}+PtvOFWVZ*cf?=fObx
z{?u!j#g`1QB|#e!g>hk8Q#vUH62FAbK8eTy+Rkf@>&O_MYmB-7{T4)Z2qDBRLt%e5
z4gTGsyO^lUYnKomqmCYN$=9xvP)m@n9ch7-&l?mFh}&5i5RQGXy=v!QAd<_B1Esr<
zzb2}n3yV^;jkeGr6gR9%e1SJ`-|l^BE=G7~*?V9yeR(>fD6Hh3oG<ARL_{9b+jRdp
zQpau1I`J|}P10nrX|J*2#+C7u?3`52_frm=>GRQTu*I{EN;&0^X$*+YwD^Eh$%4XW
z(DGOmPNGnIy1;A-4B~v~xX`;yFc*Cm(D^CkYM2yEiE!D5cfTYTyExqXG36wpy=DOP
zY|JmcEoQbd`_Z+S|4&HPdo$s$CS&^Cp0??0JWKPtlt&eWGElE8SbVfk8zAa^VKSAw
zl80>n+3{!*V6hH<<XzzORZpi$SxLB8aWy1;m*lx#DNdkk>?KplVorcBSy3J9TkH5J
z%6=ZrpC5wwLNAZxtG<zfn#gby^i+hx!~S-80G()}EvJRo?!@ouY<63Tp#|QD+5%Bo
z*NMntrUG2?yseC-^G+J9$#l+TbCmj;79Ck)u<d9TClt>fI9?*9|MJW%IWcVse%&_V
z0aFZ$$0z17ixI=HOi{TY&hD)ivamYVt+r8z6{eH+b33$kiD1_^#dx@dUG`Nb2y(;t
zWHuL`m4@4O?=W{^!y6a_jTH4SwGbYF@vc=4PrsrKwjZUWxnH1B5ntJJ)rT&tj{D$b
z=xxXMM2@%LJU`!ecZRIFrgL)oOWj~$fhqUoa761KI=y%D&ttg>HB3&5+b=&R3XkP$
zTSqcNsLkiBq~QEzauY#0uY$`D_m(U3<rm(dVWoR(@%n|0o?MY3+ovdmpeA~XZo`{x
z7}U4W3vM7NY{^~+D0-|`#=&smAi~|1_cf)8$-2&Gd5LBYPNkbtM13!o2EewYQ<Dqo
z)OKs)l#1psl@$i^3AX_X22+3@3+ZezPkmF~jeVqYuZt&H$|Mza@1s}Fv2(QJgWidm
z=Cg;mxUd{&W|p`RenM38h(nkYi)bp`Ka;p$P{Xwto>$prgZ<v>nLn76@g!yrT;Yj~
zti}Ibk#fV8&Dn`;4l?p4n*5O!_=RS@;4EvE{R*zf0>gv<>uiwf)m{TJm?}+Y0QJ=#
zO<FTKEh{*J<t1FSoqT_{)$$(3(K-ZjQuwXy{q`8$(}`r<Gw~&IJzyYviPitKRoy!B
zw(4GnSDKd<siEF<e$!qT7|a-0WXX??W=_7x2k>SHdeU+(kptjh+-iyv;vVWVhs!*Q
z^+k9SpUYv`zd-krK96pU%<E7K5^hMP0?)8axzqJ3`9tQ_SmSr!sbKD%u%97vwC0aA
zqL9mRqyz{ibEP4f(ToA~u*suGe}3Owzh};DYVuQyp3LLC2|rGj32w(kt>db_;XT)3
zhd7l60+%-05}|GGgS(<OZ|%;z2Dc4Oz|b&vroZ_I5yG!zsaDWEGO}c|I=_004V+6p
zX4<VDSFr*3#LupPx>{OrNG2SPqGo!*^>E&MsF^k0x-i7eBoMd9?KQ#!9Kk9-$!4Z-
zQ_X2$Z>B`F-5xpf<6x|7O2m7Ag?bKbyyVY!MNqF7%PAszEc^I47z%96>%`o45|%=e
zl-v9;8LqQp)I82BEVN9Jj}{?2V;knQlxND{t-_(-pORiZAz9DAvZ3FtRNKWKtq4$V
zp&QbRrYYd}hx056YUCsNJckzV%POMDl!AMXObgOoM}Tf_pft6KdGfy7)Ky8Fw>K$k
zjjW1vYFaJVUZ&5vmoRME15y@F<nT`&z>_OFex`+2LMjp0Bk&Zzx(%HFH|jO56cCDN
zBZ7=%R^q@nyUKtj?n5WjjqQPpppFtaNmSR3S()nd$C%#@uQ2#(a;zpth8DR?&bO|X
zcz)Oyi#1OUiY6rnk^Kh!H%a4deiFOf$ulZ`Lsn6Y{s%^flwonPl!A$F3mIZzoT6XF
zTSchHi~yC2_9~Gr1i1L}o|AiT&41KXhlN{-C6YqX(Kn(2S-91=?}ekx2fjq(8)J7R
z@PPIafOpHlxTIC9Od7@79bJO=Cx*GX579C1V4XB0Oic5>U~xDhOZveHE19HWaN_vG
zmSwLs6jTS8q9%dt#d&K~P9N-7D@KO`mS+yZE!W)(@5}7nRPNAiVviH8<Aiv>;+J}9
zk~Da<nt0k8#~bjyZd)hNK0ZCe;SQNfCM5_6s(SD*8u#o7l*RZNMmNqkFmUVG{M)u{
zfqIKCi1?uG20Fms25#{edA8%}t?<Tyx=Zf2>84r@I!C75YO3dN>uhz~(eLe;w{bte
zUjM^fK=BG{5d!y!IZoP6wPM?p3hFO<5oUJ_G^<yIQJieO{mlEL>x-`5`pUG4vHfF*
z<+*tFvRTOAY$1c*IJN=N*#FIbh+2Ajru}93g87@FB|Ug;49Z>(D7X45lR5DZ(-f2B
z+t@PNd?fhp`Z|CNxBW|Y=)m$R@rG<wmv@uH<e&39=?%0}Z57q++ZKGnUXi$pXnFS}
zp}S9FSO$WAz5(V(n<8okZLE?mR_0o{jBN&K%mwXsmNH{!tY`Wq4^|Ma1GWA^?3idO
zfR$x2<CE^rPO1vn)B4QeuTSg6fphY=M0&(<UTyn{ig6y$KEc%}r03x(3T^Uzq8lBS
z=cign^KrkD5qtjm=eiX&M%caGpAn~t3{ecnGxCXb_mJLk)M9Pte6sEZIORMg`91?J
zCXK%71>b{+euL?jUw108qcX8ZS1Jw$%aH;WhH?r!?DMgJ%X8}pCk0UdMo<V^APUy+
z$Y;S2YIF3*EL=-@MeK$+5v#Xw`)cWd925bRv_&CDtO%0)LvDJN*wyJ=2~23oa5?ws
zDAMY1JaUtzbB8C}-#nRRho1SgtHn=AY!A6InLE6t3#O-)WDgN{Y7(ue90wb~*gf5z
z32Xwg$7!0~!%fE%)9MzVJDk?j_z;1pnvR8cQDO`1wA?8jP2g+E&8%y?2uRw%r!-2w
z%40=kB8{#J4SO|q8Y<fKN3GpyjQ58l{*p#d#~iURRoXe#gRJ>ubt5U$HF5df135x`
z^v~b7?_u8(L<5wHSYpp6O>ULmZ>n>9al;2gJyY~svimQ7%^ux#ps2M38J%11Io?@m
zZh7+4M*KVjK`Og;i9$;fkk5>;n5q$r4qDtpUA9jA>kdVh+hvOyhB=Nd`mulW!2_N)
zSQr>uJgToST$?y5^QUv$%B!dKTr{W6IdGtTtjIR<9W{%~%tv0<$$aWP6*{r{-EKo6
z{VZugrH~@vN5OK#w)|<$B~S|Jz=B<u)({*6fJ?G^O7tuGunFfTF1lvIx&L*IWfct*
z9)hF3)s4MYhyM$>9C0}ybslUGo9-?YxE=AfXBl>7NAX<|3;G0m`ck7-Ey7LBz+!!3
z>;XRg@MOSA@UPD|T|yRyW{8E^0Gab{mg)fPj*rvOO=e1bj0@RpEp+teS+6YZNBXBo
zpHRe3_{L)NY8J+_QJB8l+w8#j=c^iWlDSN<zJ2lQM?%u=Df*vNS(b&Tdzkg&e{dXB
zwyJ(+m_|>CXqd!ac{1d^%R96e^!<Gg{AlB{#9bq0j!TF;+P~Ip;sM>j{*Q_?eTi0k
zQYNPkSl=09MUU{IXqx+pE^@$*3tU?~C>g+v*!OyfXbytZc_*Ed5}hdrd;Kfo?a=Zm
zOeKrO;FHtzdP?`U1pf?*+T13a_<!xa_dgZx|37XV$H9qXpKRGO4wWrrB{H)2L6W_)
zG7my#vXfD=XGUh_6j?<=l9|1-M@W6H)AKc+yxy-r;QPJ3o<H?e=Q`K*xE|Nzaev$&
zgG{@+y<Dd-rM6iS>7y9(^*p*1CZ4s{gcy->I<?+`r=Kjlf<`63iVLfav*jMTMK%b(
zJI<X<;H(_WFfGl_W(#&<FZFUVuC}J)SvN8n-w-)oeBE`KBSuH2?&~Di@%N2L7m6_<
zqm6yfa~7Q0Eb}fEb=I0Lcf=YAe==4-I(qg^X*|GqcQER<d8zPG()42CR=s-PC78GA
zg?JOLA?{pX1yqqaN%K7GQFOv@Iyg)I@!i!>tY;hcJ2>Br3R5|FavOEYE3LXz#wg$B
zZI%JQnC`oQDWeMxkwuG@Da>dnpVxAL>|=%>AfT2o*nOL<L|C~aLPOD?`@4=wm)h@9
zV!^gn&m&?IpN}ma#7=@UoVukmYQ?KU8?U=%;xPL)3<BpSUu*xWPmz4yC+t>q!0>#k
znX&J|f%RLSSNXbaZ~CK07?XP+|1?l$lWGw}H7bsMcL;b<a_0S}s(Am4`2McSH~F4#
z6l%1(gjp%Z`3~f67IwF|j*PKunmh^-b_;l1-MM8uLfF1Bq|;}yeBsj?gh_XTC(A*^
zW8Cj+wPn{UVb2o3U-eViPnGU12L^{<k8A~9l320}B?{xxpWRq``E~Q9KI<A}RDfPH
zmHDBWdy6Vleu5DV8{(*VG}Y5KLGReC=y2p>>amKgz7D-AvPB-A%|V6@NvDY=U1FGP
zOh!*_w?>VSx}@~n06DMLzDy6srT!ImWW!H$S$baLq5#bUk?sy5GN@r`kje#yQW*~q
z0p$=vbG}dC=Vr)+3;nx;3XMzsZyeKJdXQZjc#-&fTY!6FR+(?m_k=D7b0+`ad**rK
zspHq*(I`h~OG;i&ZVCQ*rQ)Jb`|YKq=1)A0{TYY1=K}4{7TZ8*I7Gg-GKXdtbQY_W
z3Cs%g%Rl!Ym{kn;d_RA`w5^BvEFg#>BmJV2<E!NEKBR}?*|kX_84}rhsabsf>0d78
zndtSIFn8Rm?|wPYDaNAjr+H{o-Vhy+uXRAJOPz8#zAV-J$K3YY%Fd^6o$G$P&iH&A
zDE#_GV$@6;zfPJC9$+|s>-b17L;CIGmIU_?UvqhXQGI{k*gX=8-Pf19+}kwZy}>6(
z=WtBKzfoh`A4Hktbq@Uqt-a!FmK<(PiOuERq`lCSpaWJ)N+AmCk19P+HBJ1IyA@l}
zF|<H^wvp8*>#oDO*ZY{k9)>PI)eZx**rAQQ^L|abKV-WyOn5||C-_G{%^XRi5$_VD
zOCj-PaUdgpg?B%&@tHa$t16#Rg{7#?mdPc|ZRxQWK?b*;^ISIFRhi#;JNeN&{?q-c
z_E?jSjACVX)rf%6qPafX%1;RtiGI%_?h$r0OLun!1$da+D2!+br7&|#Yqq?azFWr^
zmzDUSEM4Y|!3Ub}t!cALmP&+LD?9fff<G&<A2+|h*jcIWag>nHZU)Zq0w2;z?X}zE
zw#M#?;A!(wNa%56_adc~5Qr2vhlc&bv<{wYuke(#f;v&h@#hPU+*)dP8mvVMIJZ6+
zT}t3<@8qSUgh%&V=&ST=9(M5b#2W~J3jOF89{R~YbSg>Qs6MYOJFd;YHXu%zydh$p
ztneY8Nj!G_`c>7*Zx1vrUg(pHSkg%QML!+A=(wwtpDat(5wT~QGu2cxedhkvxWIRt
z-;VdLj{NGPpkqFli*#pPm)4ib8j4JEykyN)^cYyIT=7c@m%jBp>}e~LeBFPzu#?x(
z8J}VfnA}F`4;{Ye*2x&PlxL482EIP#JMt8fx;{_LBF+J+v$*hT_J-?2X+b7S_hEbc
zj=ZqhNqsvx{bT$7?@dX;m*@R%hU@-#y-~61*w)b3?*QAgRUh3PqiKdg$4fcZb1uh6
zpf?DIl8C}|R)t-(@~+heJ^h@+74stdS5k<s_tN$YGn8*+4K5`hFb1zd*4UQX4mK)F
z+rxNz1dvXK8u7O-elBthR=T&4JG|Z<f7o0Yz1dvMyJ;Nv(EMq{mgSK4;WJU8PKO^l
zvRWchg!StsM{?B?{Q}=JXRtoWhYFo^X^&OR#mQh&yUUs&quifi{IxM^h=Zm+yC8hf
zoPfo7<BW0nUfWF<u5H2vDe14RnqTFF2R1vIQ&_y*9sqK1yT)%2i)<sT0ZeoU;rdK=
z{2Z{7lMbH4^$EsUjhrL{)mDu@H95gRGp`_b-PZbt6qovbKO|EZrZFXb&irkCSTtDO
zlZ=>SQfra0p77Z<2o1eI-{md7`!6^R%~Z4Emaa8ivt6-?7|A*B->__#9ID_@Z@~*X
z8$z`u*^z)|@_?<S2G%D1nx+ADFfLI)(7X_dvn%%34+$(QnxA_d24<`??A+73gXd6p
zd#mesgs-Ckd45?wO?3PIt*s7Sn)bz*qRLMdDjL4gPZ<l7rhb&w3UBucOZ53Sm%D21
ze!SD<aA0oht<qifj@fLjbF-^qy=_ALK%`dLb%s+vT$Rx%){A&pb-=FfE4AHkngg4}
z((Uh2=^5sp^p8HvrX70TB<|{c*a&B5`SD|9UqXk{Tg^r5iok|ssI((Rnyj9{gz)zG
zl7DAylkfXa!_S5ghzki{qqeg@9p%{!J@<dLYMr5LIlX_hwL2=h9$Xg?AJE6Kr%#sh
z@GA=_UU_F#V<w^hf~#@*aOvkJ*MU^+y;0G9ipM-PXt%@!YLm|ra^>v??atwvWYFOA
zo~A45&nA^X90(zVgppc_U+QU*l~8`YGg!`IHRX7z<2(sL*tu40<?Er5$F0TgO?lC7
z`+BjDc)qNq`&w>s2)+9>x+xTZr?Vt?BSU>`e1R|8B`YAquuOZHWKoJ<hk_+;%Qi!L
z&%rExgrcMCn}hCHqT(_F-x3V|k+ATu#VU(hwjEBtQfbN(mDLNnG~hJkh8Fbus`dM_
zSHRCJ>*HrVYF95;i+3|^_hXjCn%`Y6a$0z3W?)&>z%)@fUeMqyskdjxf5cb4?)cL0
zRoqDD?T#}y&!|18ajqYERJY&vkjZAUFUPJbf=chee&czk&UPbo@9oh$qH15da04|i
zlH07L*r~nleZ7&?<ku@adzCwsF;^gC6%B&hBA=!`V9@>v8jm~+u_YPof|zhJeP8lD
zw7kaWVnEC=OYil+`f<K}mc1l&xRd;<zJjSS54YzUJF;zi@G#(5JCeI`FEm68e)X6W
z!6WRGa^${Iq?6+!kp(JEc(a_^?LN@k1X9Kn<&m{dIf@Qz#ZkL1_@_9@jX2-j)|haK
z6K#a|Hm?&e+_LQNn)<D8Y_V{KuhA?&$)-&}_UqKV;7t}V&C)sQ=lhGFO?fR6uOEi%
zJ*mcWq`k;z8aFoPXms|!(Jk?{ks+vzPwTm(%06ej+@~YYI*iTD{Rc0N_AX?!6Z-Hz
zD*y0&boa~i1a=x<OK+aY9xKcew)(ZUu~u53>Pno^RQ`m|OEd49BtDyk^n>L0V|iKU
zzj-np{W8xmR=Tr%H&E=?{c(!f6?(>m6%C5{yB^KEBxijf1<|~X+KerQ)2$qEm&yQ;
z*;G4_R=Mk`p>~<V_S^BB??x~vJq|1wwwxE~E}e_n`5cN#$ZLDXrgx1U`BVGA-{if>
z<+mV>oD$uo*fv#Hy|~RTv;wj1J=SY<d$vrB&DAu2;HW_Gs)}<rN&d0kk<go!!gCEX
z6FdQ2Nz#T+>o@Z3X<P36;_7KCXlZ*(Ovlq#_?@ulck=PITNXfuHm)O=J>P$!N4`@0
z^-9$BwO({mr)%^k5#IpXygRaSb_S`lrLE$F*BG`A%g};VCZ|lKt-d{D8}v*0&J}yF
z0-D_|YUjDq>dE93flQlr`oJ7&o1>4T@t<hU3&luRPYP^zKFRF7wx#ENean48D0-aH
zeu?kP-K6*Zz1{os$dY}z&!c^dFV~U5_f~&ZM|Q9A#LP-;{ch1Z49?%bZri9{E$kBP
ztQjA(v6N{dr#>IELU!Yzwn_U|njG>X>y{`r{_`CgEgnaX{X|L4rx$_?zE^B4L@EDX
zt*Ow;mxwRh7`|(%_2WQzt8LEB^hVQ}?aQm%C^GxrOuYvo)<dC~LidK3)w1TGv7l=c
zF)a3hxP^ve%I1Co`$8AX)5Auk-MscUyf3XS^xpG+)fTkm6whYgc27w!Gvv9P-IUWE
zilvNhuOCejY0vKlJy&D>@Z_i-BJzAo&$U8+&kkD+R@3RR$~%5t6a<JxX?)g;=1@Ub
zwj<Sy_1v<QiHg|ZymgJy9m@b0Zs}qJqWpl#r*q{u#@^4p(HQmY_{Q^TPhDu@$@@o1
zJc4;OWgqyRyhiyISNrxqH?eYCoX^USbsbZ&sv8fpwXD>xO5^Xd%&{A*$J$*Q)sq~P
z{?gW*n(!b?xHR$S$L`<4BHwp^6?&vE34MPu@jGHw+_s~qH}N{RkMDtyv2b8yqA<f(
z38;VO#Eb1J<!qC2u0ZAWUzQo838viw2x0D*llcKLmQ|wk1k)?qRn)d}Nh#M}>!}2D
zI4+y?SPZ)VD9+ExcYn6ZQ~ha4)YdmNma%ZYnz$^8!+I^=$g+8r=cwU**LO3<?{+or
z76zPCHn9VZ)usi9pnJUfuru?QdWydd|Nf-?c!x2MwFgEq&M?PR(wu$!b{DsO;6?Z1
zYBBKx`=tfSAYHoq4R9*kG|7G4WG}Or-9rZ6J;79j(f!uj43jDHJDdKOj9!toU7z2b
z`yKpnr~$9K`q1W}f2@5}H9kMUKz3Z-uQB^k(!h;_f`9<}{<)IEoIYvGl%CMUbqOJ_
zsoGEL)xIWC3Y;Q(?sV%RLLV+5?^^z{$~4p0w0v+^j@N6|Jwr$*1L`Sm-xi%ZF*%l<
zJX^f_Xttkxf>_qW0mb)41w%EHx%_gpzPaZ`CwcO5wv%YYxRB&T%biC*gSL*}RC@mk
z+IkthZqt6_x3pzW@Qpq9jP)<C^!B!8dd=wqKaVC}+Iy*`)-rx}dGA9{{<2ecyL+r3
z>z&d0URpsqRk7X+IR-Cie>p7u*o%X+IDZtY;f)#byE&_DJ->bK20KB?`gLoUO;0&n
zzlc@zh{yN*SLbNirUF|Rs1~}mD4{ySL}o>q_eR;<^Y10SPT~pX@MK)uN^?j`rsd;6
zIfr9;r*AxOsJH$kzQA-&s4`_-ht8Hqs0Phf`>39{kY7tH#g@`aZ=jym`nni1m;Bp-
z{%EWqOdf3pxwG}e^TDq>KVwV1oAgbr^T!WSmJ6sxxn<AE1KY%RFO2tytDCz56zrO_
zoU)gwoL7I|wCvxisdnuYNVnko?M;oje<qP#0goW-T&_1C=qO6G>t5r?qb_q11X(%D
zC12}JKRq>E)nPfqejGict@?E}n(xZ>GTAlaxEh-mw+DE-0$k487EZeKwirH_tf5#d
zv_E#MOMyX4@jA33l-ayPtx_Dq^W9YyK3HpcR}Ajt_xMpf&vr<$FA_0~v0D{)_9)kR
zA=X3v-a*iDBet46!!fzP2i>CQx0@yG5|~!|f#bMkXU8I&yhmNm^NqR|`%E+aF{5x+
zfOytA-To(v<rj#Jf!ZCS8rAiK_}jnVd8Y(yxcaCK{2ZN&Y_ZRhA5>mBn-5Qo?z-XE
zcRuIS`#0<CRWa3f0++mRv;^{qhbs8+lVQ<zX7e2ICSApuZBBalPq&f!vzP=*8~aLq
z1CZWsKYoVZ@a=d?1^$V?malGz{80Qn!5jw}OdgK_5rPL{L(vnw3fYY?@TbfSTL0a4
zU?4ElD<T}I&$RyXz;?i7+tOPx03RPFpKD9tP>Fz>+-iycz=2$4I@sEu-oIlUb+FRf
zWjQa8hedb9zr4e;xM1%@*%uJ5@c2S6{)J2<9?ZbbYXn^Hda1OfrJcpkGXz<j@`{69
z4p_c_ZsG6>dLrv!d&0s}VwwkR2u_fJuByDYb9W^0CVRZcv2o!eN<h~vD@|-QMxfp9
z1#KyLb-o&s+m-xiBxR@n8T1nx^lPQICo9z^h3Wu6t5<<ny$;1^$a5JawD{*a@xU3t
zkryxFdxc&a5Wk&423@P#^WquK_Hv-dg8n?sS;3qYmrzVQ!S4X2P;55;ig(HpnwAmU
znlhPn=h5;!s(Ge?NnOL6ST6g{eLNl)^O7?G7$Cuatc(-pM@52Vvo4}A@gf*;*VDI6
zkz5SnJ=oteDYsTBWN%%2>JomZZFU+KmPiIIEHYVR+rBMuxUk%@xI{%lUdIT6yYqw;
z%hb6#C6>g#e_Iy!$J}~|D0b=ve;XrU_;wvHNZIwJoTt!H{gS_H&cA}07R@flptb3a
zJsOoYOi&UgA_sK!%qEt*+gYijZkAw>rFik!@a-l0QOy)%6ig_P@16Fs84WzbM82B{
zQ%5C#(dfKL5XE0Y!X4$WuRnwD6;w>&6h<cvI>)K0`$_JD2Bb)$u-A#s%bL5fpOT`~
za41-44G#u2FQW}8(FDa)cWI~owZI=8!^8Zdlt(Sz%u-$u2*rk?H|`95%FZe)-jtvf
z0p-BR`?0PDqy4c2XURf&D^rP!-v@OH;dJ@{#CXMIGD}E&rLcH?*xKp4l)`AB8sY*1
zLC>32zvLIM{m5m@4OJ96T*1&<#+nLutLH^Bjxgv4188OfY6#*CcgP0aUwZ#<@fvWm
zeFK=uxSG&*xLd6IsuxUYp^PXja@l1~{mPf(8O;MT{Rv;BxGq&n$7{X#O}ELO-8uJY
zP&T0Y;qfo^W8bJ8TahKPtvhFNd+z_oo_R5{Qp@x%z(V~cf`3R>UX`Ti0vwww?FE{Q
zbx}X0_0?tGwq|{PCIv~Qg6}1}xm{=W>0W4xMWfwQf*Q7lL^3!+v7D3>if9so*o#I4
zq^zfxZ2bg5z*FaMEDZp&#`ili&N&=o-5<!nzZbDm>w=v+D=N1mAyr;?jbDT93+UM0
zEXfovb^)=k@TzLvDpT4ulhsaDB#NQbByRPgNGMiF!j}*;N5aM+&==wQckRZBjEy5#
z6QzQ@DZ^i>vap&?M0g&$_E;HJ#1zYS6xC&h`l9Z2$4h+7ahR;#YM>+4dP^&1bmitz
z4+8#G`SsWGoPs7vr#iWL9|TewfBrF(KSVp|pLXCMUscMMOa9z+#m+VLV9i(xYk)0l
z&-v>@N;%&5p*9}>`W3KY|J0KXwA5Z=5y2@W=!g@y7TqVnvK3;bAO;GpZ}+aAkUCBs
zF}5Ut0*EQtp=T%k5kHTB3uyvG$IlQ@jYdpIea3a~&VYPY=yHcHRh&b(0$md5%e0gD
zxNab)LJ40U#%I}ifJcE|vdaG^`p@U_5AD7I89Z3vyN|TeCjGH>FdK?BI9{b(E@G-d
zZ=4gEIt%UTP%n19f@;t>Yl8C4`x^VQj_E_PQU==1RV0e<J_3GCd1@yB6i94;GldDL
zgC0KPi+^nH-*g8(26+fdBzRF=I^){uG;o&U`0f}zImSAs9#~lWQktF%8MH6?Kxl2T
zw!&0#=EHcNg#c1U?Kv_Ot8df#L_#l-z5p`NL=<+x7IzuTMDn#MdsBKt6n&^7L;Be<
zPtas5TPZ&ldGh6cgaUK9`Ef?9wIVRHpJcvwq`cY;w0m<wb7(+YD}%ez3XoFY`+Ir`
z@<Pbfyt`LW=xa|+`qRmx0IzJ>L%DUY6#-*ofIp$*BRnNFNh*0%I>-AFu}geNnQP2e
zV6K2#j|eGLn5Or2ieET}i16?t<cT$Cp}pDu6qh$^sD3KkUTt8kucv~fA$-*on@R&W
zGb}xlejSPj;U;kl$>MzDe@dG;I1yRrO+?@1GVX#lbk;O=I(Sg-;dAuVk`^>a?{fh7
znlQUAv2Gxe;UE~)Ra+JiB3wEjqTUmQ=?-2N;{bigCgunq2PxGF#Nv5ih+chW3R3*r
z&453qQ)3p*`l+yJO%1!T_rT-c_6lN0vLW9i4LpyeL$MWos4qg*EXP;)wa|bs9}{X5
zDQ}UUg<-xS<S!yM&2Lbh+O;D$Zr2kA!Shc#9JwX-<pj8p0hYTph2de(V^Kx{tu@^r
zU}24sUo;q%P+!bZUp%>={`7kZ0ojb3&a)&F+DrqVn{|E><HH2NH?UEidd0EHe>I*?
zT?aNV`~0MC>w|7;&^XrjHZXowgo^YEYGeF8$oVRhK|gFW078xQeX`Pcu@}zNS18#4
z&FKKKjDz^#O&}^mewf^$7BKt2y{?j+`l7Oo5Gg|$%NA+ly`daR_-75bwct)^EYM7Y
zUC$@W9USm?{74y7CIPguQtt072!3udsMZaEEqK_9xohzA4e%SX!ldvs>QfrgADIT0
z8<Z*#NEUqZrnjZK*B~c-6`CKzi8M=tgo!VAfPo#?%65f8tu-)6fRj%YE?1rGJ{ykS
zP^mj>6STOwau1|&=X~wA>4RWRs@9TOoYJ5I;*H0G;y|XWFL3I&xI=EEE?g1&x0m>H
zvRpaHQ%_~}1QZP0$}FOxrdP<|iJfw4+>r1J#c6C<=}Lp1m|=>S2S}E8h9Rxw%~H$b
zJ3qKDfyQ0WYfnE+V_}4<%2~5BdOJ42OJ8$-*6s>g7JWDYD2|6%+hxvhkI<ZaC-|^C
ziSo;jy?A=Q&sqv0-JFdI-)uGC5=1hU^j3l?1MfJIPB$_tF9oF>5t$gF+++?fKnN9z
z9$e|Xf-*wDfl*?I@l*qK9$uD)gptU%+-q$iakG|ied+|_%zwLjM2I{w2`6^yD<`r=
zL5PL7N7`CyaW~hzdt@OLJF%?9+JkFk8g58ULT{LrpF<9w@rMvz_elaKzOEKsW&94z
z0Vzt}dhsa~+wUMQ5ab{J@HGeURf0eRZ{zc4hM%%5TmUNBug!n<kUO}C)_(1=rCFth
zohmt8t6NuyR)d7?=~Qw>nxP~Vn5%7qB7kf!*k;<s>$2PxfYIKVFnFbMV2Y~x@lqn+
zm?)={iXe{-K|yg=*@}<zr1&t;DWiHvIFUapj8(v%LtCifShUr(bKrmC)D|xDAzRd(
zBUE3;D!1Lx@i}YtfDD?sY}m&u+c|oT4BEklj1?v4y~71uZxJNhiT$KL)Lv(!224#0
zaBk37TYEs?5|$Psi>ZN|Lh3H8dgxLexVU6nRe8YcHe<k1EJP&vv24U8f&EYULlwyL
zd+$yd04)#$qY?V#i$R0o6|@WhDerWLlW9&|4U!Vzu<ym1sgAX^=qXK<PlWQqRMgcw
z1x0>5=|o{2r9rP^&>sPi2*vmD93~mMP5twu4H?ufj*mOeY)=2V_-z17DhE_EZU2x(
zex?Tw2WV_-N3}Bc`9sT_WEdSvV2Jd+bd63JA~YN_*l3MKH>YOmPne<HHZux7({vZK
zPz%t*_dxxO?O|Fwxm^1kS-4yQ=TpxYP6G3dl0xGwMkoo*=eM!w%I9s*6pC8>i&{)p
zC9b+s!r}QYO$H;Xmia`49bCBjT=xA$swignXYGYwPN*Ut1O#AShxfo?tB_Vxq31wq
zf6X2cTXW-lIe7ru<;v`(c*Hiqu~Q$4zc<{?mm{C^PZ<uydYJ%$D!wp|h~k2!JR}NB
zf4Zt~vfl|NGF(ehc!7w@qNF<YMQk5E3Hp}`=YH{%g0iQ>*mz@qQOP&xvQX@H+Z%Dz
zC&`tfqNH;|f=J)xwEChCw^ewC+zSIL_}9V18&hqJ1Y2}0=;F6z?sW&YU18T|(_hD}
z?9XMkK*VC}7n7Mz++|3s8?4B)eIVMb9EiauROC&r%dSdC*-LqpQToHqP|OiK0?tJ1
zb)#)=uKU;Ry0fnOnIbCKDU%d1erKurLv_o5iK`kB$?U4^8_<xW({8IUagzw6Pl>+!
zRNrb^_0;j2)aA1*{durc<Xb>$LHf!aWwN+pup-t(G8QE>P@}&-J262^Ji4dooR9Oe
z5=MSmLZbpb(&f9UdJp7#f2DNOV{_R8szX~Z5@={$j3b{sg+Lc2aHcmupD1hq@buoC
z^?`=s#R8bcbgv3JIJqv*+`gV1FuLi5oE`$AZ(4P9c$Ccm5PE98=^WjqbN%>XHzTgi
z<!>hg9qnrFOMehm6;&rGK@U(*qj-4EDZjfYf$vq}i?h4Z-9rfY8%IbOn~uv_=9*qg
zYzXL3J?DB?vtQB?JH-p6XqeeQ<}P>a`u4zJ&KW`_SYM<E0;y6l>rdHi$iYeqnUGc&
zh{XM|GbF61<BZGT_2FuLw|?Z#)~TL#D>r;annn$ObeDf!^MEPO=Ch>Zv65i+c~5XW
z(EORd_?Wo{{c)_ZB3(ww%PrceMqtwNk1*Sw)hMBOVcBJDRdfW8uU6cndwuVeS;Qw;
z{^?NA)c=VC7xNCQ2@TEyF9|%R>d^E8FEG0?eT$FlK;4xJvPIGP9g9iR+W;E1Indyp
zq`!EKiwzy*tUs}UBb5?+M6^aj(z9<XEB!nPSVH7|U^hdt_*<kvC5FH>u*eeKy(>cl
z>5#DYVi&zNYJD!S(2S^*U55a2H9xT5b9T~j2!sBZm0rsO{$_=cf(?}tq906k(%9m|
zc0yXi(QeUZmw6kre9ZQ9Im6sV7JiAO0DoHuUdqb#u;Qg4+F6Fil}shz!k)x?0{5pu
z9X|}JX2J6vQbS3o-Mba8F#d>wvd03PqMXblvb6;EBUb@{yc6&O6Hg6-N;4v5;<Cz8
zpfQ?R$&-eEiuyoqU_^BCak>v;S+JN5AM~0!0s$(B90;}F9N5p>jT#AEOYY;xRrVE*
zS)Q*!KOhU3%VO|}_wx@yqt=XacVy3nEKlZjztKNw4<7@dPuqu*kcVg{;@&OqEb{|^
zf15KaOIA!W#%Plcl9gak+p5as9+yyspH|O8F{((X)VU)^HY?)@yikR+y|V<EMr!$s
z>C!jEV5bmF5TpPGm3i+Ols;UY|I_7r&2C3WiQ*n{N#QN2<T|IK%GX(7`r0!O8TEIt
zuqN6^WYEa-+>_2exazxcSlChNVr8PU7=iJHPgm4IZwc6lUlJo^{#pnzdmk+iW7tXg
zq2vJ1;>P3b<pBm(*@Gh8aBx3Y$)E{mpP;KEyPdGz%%4Clk&YZYQXuwS(=`#08vIp)
zE3SPG3b7MpB^A*^z*)_QCdQq5FX_S<5*!efE#R~c#|G$BdOIeCV)KUlf)bbQwFK)c
zy+OrkR(CY`6+ol_zDfp;66(paScRaq#Wg{swZ-EDdw&m4vG)I3niVV!(j(*=rmCoP
z*7-Uo5-i#fJGBm3ceT|}t4-y7^xG9cvQ4VWi5Y>xpxa&-b*b97K`hi_5`ms#D@xn4
zNoKtp5Nf^oNaTL$?#HAHka=9h^-5-h;gou1zyN{|uZ)w^B83K*YgWZ{43ZR71G3En
z%eKzu6ec@rmW>C%J?^2VCZyb$oc#{ECis?T2{EZKl&p?AdPLyVl66#_kTAlXNnKlj
z;?K7o{JKmJ@9i%DRp7JDb_<#M;`L%6k@K=8px}KVi660*cou7gAq*<*ZDx5il@i@2
zr+X<9jkwf%rdr|Ym?*Bq5`EFxR&sC_f)Rz>zS`r)O@BgR@d$KDinbkHy+RKZvSCnN
zHQFOku;cq|d4X!E@3s_H&w$p?>JekPDatnjkP=2Pp$r`%BvZkmUuAI0@X*8G3?C!;
zONqiP?Ey`rFRG<BI~$l9Q~_1)PXllukg4#n(O~z&qZie@&Z1%R>;xAJ?#U;eId$kc
z;O=ZCu_2mObGdcD{i^n1VF<Wb(}l9*vXzD0bUht<qOjlxs=*wJs3Ox#Fp!q^;&9s^
zql9~d$<7EQ1jJkldK~xuj#Tj=ht~kPlXQum*$Tv&PkOi2^}&n;0LU*GfzQ$6ro+tZ
zv9oUsmF0-cGk<^9(+dj|QNgoixrkfMQ25@-$IzsKTdj_o*$OA@pLq_8OQJZms1FIt
zqL7WZLpo{dhoZH4#PYK4tbxk=l!m)m@%A|Uf4P&Ez>^0A3qH@B5U2cnH$YF-g;K^Z
z93>Cngn-I;H~d-nDaU&-VozT#tvG1U&Cba5thZM)zmE_Sk+jRt4+%Rz`{qe>JILap
zg;S0k+GlfOFs#+h!6oF=q8Q$mDDO`rciTEdTsZXQ^3KNTr;Cp$<dR}!OJ=VXobvlB
z8f;z_AZD&XwHSD#-ze}Hy=;hzucGL=2LP%QXnwZ#2wS~pjo^Ssb=?(dG&gpAXfELY
z{wfjSWFsJr@U1sU&xT^y^fdZ4zurshiB~}t88O~GgP|k&F{St)rWmAu`AW;iC|7o1
zBXk+86)TxdKbebVFpIDn^i(9vZ|&WS-IP%N-&r^NuIq=OAIR$&`G#Y&K^=A^AGh3X
z*0CU7<)d#2(99dAXXpG&4AyvKss{|986N6237H9&6%sNN#--UHmZ>1`Bq3;rwe?yE
zD2kri2FjaY*=bXc{1r>Hv$a(}P&g^f^JMf?ym9d5ceR%M7e$OK_iU~`?I(qjyxf25
zIA}1Tx9*yFc{@nWGy_dzHcMbFgfueqGR3(Xs7gp8l(1Agn(%~`-iZid6=J-vS;eN~
z-S`-d@VSt-Tfo@Z{^4HR&8)*t92QsfzQX}eZC!gIDphd5hYPRnrw$Bi@#=~Q;0NDH
zF_hYlIk6Covmtm0$2XwDCtMmnEH*Mk8vSle(!3d1g&z$}_xbJ*vWmqQTNbqPa2K}P
zACv;(%J8x(FP+@fPnqj|oih*9og_C3oF-Nki~P!`5m+>-<9@Ry9v%mYnv#N^z^l;K
z2RH(zSd5SC<io^=l|=y3Mn;L*DkuW`Mf#TE+qlVE+yqO1v8bM#ELIy9cFJat2#TpN
zpoAvQdW-kyN&3xjg?v(WQ&=)*$ZhS1Vt%KfV2Hdk0kHM7-dCBe$3B=f-+Gt%nut&f
zYlEF~YoGRyCBU}QTup(^;{0MbI(Ml5@_POa{Re`OWe_D6z0EQ^6=BKe%3!#N!nRx<
za6srt0JBDofYUWr-AHH!?WoVp71~M+*=OMx28b`h<IM6b$%(rHZYdx48OvhNy~uoK
zHaVCE0#IiY-{Xyct88|4rjZ!62wnj%A9hO=Bfn3A`jmU*6&`u&A+ezt!I-+<{#yw6
zEt{^_3yN$Y&GOL(5_aHbd%lLUllAU<SlEcsmMd)M5#CdU%2JAj(}zIgX1slr+3~$M
zxqS)pm3t~Z)(#+TUwRJsSC!tqVfiV}cFs^NL&&Bs44#Ph6pL_75j`#05I|odh|M_=
zB7Vh8(xN2L>yxpcGaeQ>)?K<BEP!O9Z0F_<gQ&w|6TkvLmLF4{0?SB3%;IBN)qA$#
zSfoSCk!>uPM(CC-b#t<q66$~3k2$Mmyt0MT_X`XvvTO^P%a1~Yw9)`pP<LvB_O#;c
zJe0rFdk(o%eF$B;({@t`=~RnGb$+^0beVDkmZprw!!Om+kE}%8276KPcN#fGnBv2d
zc|d~>u-ql&RjjE#7$){AGSJ}#$R9m0KNHI>c#OJ91#zGPHQ&|No3I3wwsmybqdEmZ
z!6ASFC)bBooWdL-tr~!u5d#MF)>nq$h}Koe7|F`3Gz5Gi5fbKjYx1Hg?q7f_eAAJ`
zj&cI$dRt+64G?61Uk5D!*6`Lrp<ULV>jm2NETxaJff}INwdoh=s=`zlG^@P2Ujh`?
zJt`^4MHsPyt?atbSe{mxkIbOe&;NzlR<e>IYDmS0-|ktqk_ISK+XGY$D<4JlI5Ple
zxXcDd-VX5WcV0NS!B6@QJiubJN!bBZ%Y;SKw*62Wg`DFS)=}x;<rV~h9K_C}vm?K*
zL6|auR&iYm0EwH6+sokh5&p+sRKZ>tL$PzqkH;0WYJNS2fX8wUEW%W36ktjPuc-J2
z_q)Qzfe6JWMyuW9{(kda1OUD0P&|(RGg%^~)tY75FL@+V?jNoIg9af*NeC{%lr-i6
zM-+V>62?%ckS&Q13407(0s0dS0HT3X8^tLjC!ebb89SJpC4LXWK+aH%`vZPzU^+po
zGm90N_g2y!lqd`CDhk{V`U6<vb8M{K-|q<*%*b;QsFOg`iaovar0mXGX&2w<^mZTo
z(_i6xJ``U^Cj&6t-ZOR4Y6YAnX6!d9Ft0!mxo8^qP57iXW8A5ta3sS9uUGgzwA*)y
zMD68xgd6Tem!q$%An!c$P+5!^z1Hz;z>y|K74)CpRy<C{v5#nepa8|bKd4SiT}qx!
zs(FlZPY28aRUd#6Lc+-PK6aV|+f%_LNfB+C(E2b`LDr}9EXYUx7fKmPi~(#|WfHnd
z4YVn{x5=le`#pawZSj1O@4n0%V6%GaE;&sCzIQ0P{Z=?g|EVy;n|G4Q0U3>3v2psQ
z&1qFYsp3p?-Vh}iY7E+)Gi)w9krJ%11A#-@r%e&?&tVC_-zNgYx}oGc8j875o9FpH
z{yH#2ia30;!%z@#YQ;k}HYsdC+NvrT;wYqmTC}qz|F~j?YItRxL<uD<o6V--`+BW;
z1vf%jwpd~;Ts{q_?2X<VXHE*NRf1$T3k|G6CIk#Tycv#_uz9MUpG^Y~8sb{mu+_s&
zxY36}^Gf_l$uI_BjoRq6xKq|Gq?G};2s_fO40pO0mF}iLnFzMI0m}t)M#)OJ@B-!f
z#>uq~QZYa=<3|Kg+#YMj!`pQ~elUZia~v?57o`GD83a56F5IfD2JilaC)LnSM+V>w
z{+NIJXFn>O3Ba&Yt@RX;u#WsJ*zypk=kJx+7}7Ju-sGJ20(b-$sQ!@OOphR8FKfX$
zW8Dsp-s6mtN+)z)iOuyqc$PEYuXR?Vr`G=@u>K1T{g0JEM(HX}ZWY<?qd%DmR=5y8
zPJpYuj8l0NVVz&%=P@niKkXo4#_n6eKwTw))$2+8=6S;Afw#n~z_t!KdLSyJhr_>I
zok<-R2{xV10Q!@UTb3)4DC~UU@%?qSkLSR0z-N?gTZb#ew2fSZsAz!5sVzmT|I|_S
zxF7h08lxlxNTB|XfWq%ixiG!TLljoej*OLHXwunfDG#`3Ce`c0CnR1{zJp`G@d!M*
zfR-6PcKT0Cs0OwNQfWUxvezMHbjl8qE)Fb=AGNK24b@*XZE1P3#YY%)xVOpu7cPg5
z<^xAn*ZFqg^igjo$xo2bg<>fNN&bxXc7A9#Iso7Z_Ib22m@k^w?!yI}b)M@<VGmUx
zS)K)j4`vkoA#5jO4>ml^L&%mU3KI5kw(E~V2=ym`2vhdHk)h@h^`t_sG69P+;@F!G
zo()FM(b?D7gDue$^#54hV*ihfDvlus#*f0`DEna)B~&ovR+8g6KtrqAh2rN~d=5`!
z?Mn<H3X8M%2g=RE?wB;4#CLxl_6YYf)d7=W^oT6y$|-uMHGl+1>Tn?6)1ypH>G3<}
zpcy!B&o@%)*8V4us4|y07+}JkyQfwbm(7@ZB<YlM9cN>W5?c#sgR%c%vhfINKn_1W
zj`g=oq<kCT`glrg_OjGa4NY0AU-%&goG6gRJBvjt-@<WCw=ux+lWC8fBI7|miYf}g
z@hKd&R}~eJ5)HvIt4#UvBR*=VFS@|gMW={vl>uET1k}6CIo`_<ekwq0MsIX6oH81%
zBuX7+G567^jqWv_&2vKFGv8(T2`k8B0H|%zQwEOP`ECThF4dXR3cfRty9yvhML!gt
zbjpa`1+&|4eU}JTSTAv{B3A{(q=aZ3YU8afB^+uxmnHlK*uz0ir0*<QsKP=i1u;8H
z1IL2CzniajY9$BU(T;#Q-CX|Jbk*m>S~(X*db#n1nO<p}Cue$M6hPtQks!?`rF|Hs
z);vuKZA6DW7{ZXgA%exG0Dt?=WILJh<SFH)fqD4)t=qtk0|2H*bXB5sqg`0{YrAs@
zk)=2sKk-lwSi)^wy6Qg@I<39{Gsf1hHJfeWIKz$bi*H&(F>*W#xln+%7LKVvMB*?=
z;0M&F2Uh_?cgFIxn{8zPEJztXot&Twz$1z%-%2nxk`SAV3>N*G1tt}|evaO_*pWB=
zsSlU<9rxQLfv{;~@cJ$m;bjS&G7Iona5Di{ZKXA`Ea|u5VVEJ0-_g`K97t}c@k*Ek
z8gB?dA0jIK&IAm4$st6B9S=uqKf{)wHaSkeWTS{y@<5j1RPf>Jp;!x(t&cOdxts1Q
zkP01gMljCfCmYC!GuE#8a)HwVbHOm!MGdr@9$$r_jEph(ROpC@Pw7TnCT*PsctXvr
znzSO%&wz~lP}l+j5WpX<t%E0W43s^4nyNoHAn?J=Zbc+oo(4$k<++gCA4`|t7@yi;
z7JCT#V@649Vyrw2nznpFD`^+=gB;6twMqa-HlW<90R?f32cdY?Zj#FMKMc%sMCbbF
zTj5wEhnGilAbF>#2u6kjAhBjRAup?hLf&q_ApnDC0j-I!c$<7Gkq4eXAoJ|+<MOP`
z)oCR*-dcjd)x9bk`ML}=qAZ*CwE!-Ru_zJ9DG}Rh8Z>Ybo*`)b^Zfq{sC{=8{QJuS
zc#UXzo-as_r;N6}V792?Oqh2JC3L*#apGMO@cy|-pqaJL%9-r7wVhx)_kj(_aUioi
zr3Ql>I8$MgWtrwa?DUe9eE|@o_?VBE2nHa8xZ-($?G|uA;Z?NTDMm%!i=c-DI(EtQ
zrGv_Mpi91kF@-&VVk}a8diPsp5;0>EefGn}u4r}pQt3Za-6~m_fMgAD1Yg}VoS*-D
z{tf^?fXIH~HZnjW){9=$E~bP_>78x(gs4JSsaj*u^4hoy=0?OBSCV12Pd#_GkEED6
zNLbw1rBPB>u_h@1=}TwYD!VCxF;C+&RY4}(Xla78kU^049|`otPQ|8Zd5Bn%0BfS`
zwJTU!1^|0oJ-w6Iw8H>N3<6onxK^Q1%-0U;pEfEs*A?ISfQ5!}0qV-7@ZeJ$Sw?K|
z0!EDmu(E|zonG_=z)w8Y@{7O<-S*YJ-|7L}$a8*u*a&##+w84ZLEL)t{HY}(l)&w>
zuw$npn;g9<RFLrEXn(_05cNN{PK;#PuOKB}*tm!d={E{1bs>dd+;NYxVL9{DDZc~i
zYCS-IZYLO`r2ups>b3P)1*c|0l;;5zeE7nC@CN{>i)X+a+$kt=JDKAQkzc{pFML~u
z9qBLtwDwWzuBZ`E4Xh~oM*{<XeUdwM1&9&8ll1u)8?fGl<HKs@*%%t>#6EDJQZV^k
zRa`OEAnOZ!Y_4jG1j-QDa)T#?yqdL1Lf3?lsK8M?{<L%8Zl!@p(L7|IPv`|8VZg+?
z@IWOz7Valg9Zim)%Kned{L6}XGGK1=9A_F91%e@{bZ~@WVd9K5sL%7k-E%YlTdPxs
zz>{mLx8jT_B&^Ze*5(4v)hiCM_b4XVg>+diT*1|Y^qSfpzG$qn<p7sVjJxEplu-3k
zH$+MaCLd&i!c|gyo=jR2vr@~3%4sSPUr-#f#s-KG-QWV(?t9RO%bZ`M1)0tec^urE
zGfJX9rS;&q)`8--5{^|KZ%uWd*hHXnICudz$gtDp$p@H<jcyIpM}A!@L890`fOV`8
zzyVtga^#;fQXqw;P6~A#!FzqL^)ZfTv08or$c4xFHI0|3!OM!@r9<vk--`bUqS8fn
z+?`i_aswgH-<N5H<KS;dhovbyh(O!F9?pP5msXI#Q(K7*uqTpaG{*o9APxBeygyP5
ztO0Kh;yeA0AA>ie8MZ5g0O_DBf>Uof@na0=$Yr=FIpEw&8!X_HGPqB^isoZGC5wm<
z>DK8d9Wi~VkTU>i0KvQk;abNcxe8LRjJ8?~zdo(98r@n%Pe1@x;Q)b^$Y&|rh!csF
zcPeZJUw=fA#-mX$zOLW$lU;5H1Im+?=-?BTy(6-<I}4n!K~8Ww5t-Myw=O*p2M#g`
zZ-9E}nbyP!S>Qpw@&L8JY~x|Xh)L(}0c6)hbQL8Q?Tk3^IuGPzg6&oTF7dy`u|pso
zW+Zz)$T$KQ!(AT#;EZk6r3Lq!^p~leOv0&o>_ZUg@Rnv>IT=84uz~m}^xB#+r6Pzb
zf>@tu8iPs*1pKZ+%-cJ|&zJ0wzSqtbbTQmw*5wCa_6#m6$BQ`)JQqnobaYuD*e^ms
zi{E+5MT&cz*a|y!)vNcFI0<wZ-ZDm0c?1DanE{)7M0*cVZU0S6ss3pT?n~K;CwHdH
zuvNkTFhr_cShSWPB|H`XT}L~>CNzrIRlqVifaBaLez8G&O26*lrY_;$X^<0EzAFc3
zVddMvuiIGH0adbJEZ&~o3YS;G!?J~8`GIa=9s`%98Rm8B2_JI-@CAb&m%n}D$07nM
zhXE9amp}41W`TrR7%*xAQRaj1Pd<13^6498pNbz@e0==iGftu^$lAA$$}4aao&bL4
z=avO<3_Dah33(kZe;$Zs<Kv9M$7&rQUtS>Jh#N`CgeQ&zG|=b0)IkOaURjDYM_2**
zK_NIJ9jp~9uLhp~Px%bMr_@_}xPr(;U*4hz0Z_}ALCr&1oKpoQa$t`dc;5t1J%Vfm
zOb5+}4T-PH)|<u~2VlcS6p%3ZsVV1nW5CmTy-el`)DFkx@W0`4JSCeIP7tfG4vMkl
z_l_We*{;$o`ssWN$22s5!Z9Bi{nZ#Rswgm(2%Uv@zz9NZO<<R1%6zV!0fE}T<CdK?
z`8$8rP`yq?Zzy{8x(tGPh1a`MkUr+5?1!BkaFB`4;|j$h9A4zu!YF&bPoJla$$og1
z>}yw$0gnZ^11^9XlAm3-ICTfNI8fJ74c;%VZ@a?YYXF1W;4v>)4cPAlfXpla-WMW)
z_D58>mi{CIVrsn#q!jz?DIfO<F@5wW0OgO(jdE=MwNh`a!|_4DP+GrF1WZmKEqMW6
zzro#uXapRpD@95G&XtP?Yz4uCE?_oJn7dfWQ|kAb05c=K!p)yZ+lkwQ0EWZt*X0X<
zV+X_unB#YW!<KM`6X6U}`5hhJG-<zL|EhE=Wed4oMSAro<m8g_%3x!+=mFFdqlQ-$
zFVY()q{&Ylfc~PN4lPE!ezpW)YfF^SICN{RQi|ifRdAIS0PHW?)_uEp;)p0Jf}oJX
zLJp6+IUq$fXOBB$*uAtjkf%1EM=W?_B3b-#Kl;|q)~rlGndWlAG9F#kd5;!%iz@&H
zR|z@&{7cdP<xYW1A3LBOc3S`3RLEKV7l&Ft!xLr;3y-n|Wf|?$%`{0cXiw|(%sGgM
z`)&?R5|4x-sP44V;s#eCPtr!RC?BKx{9g<HWqASp3_?6hF5gh8H$lmeu<tJgC^acC
zA?x$rhp$#8+Gmd_;S4M-gB%a)Q-t+3E`O+C1LY714`8?>Kp2Qd?q20Pu_P$O1k4Ob
z8a`QuHG}#v3EHulhrY=e@Dym1Vo{6k%H(akIPznIGfmxjj>Uum<H)9*kHlSWHxMRo
zPv+Q(1@U1T9DoCPX(%UyBSGu|31UC{qvAS2KmL)dZ7BL9xBZKkCV#Gm@4g4NH7D`Z
z$N%{<K2i{5i@nXhI~%fkNwl!kc38}jO!!sIk@%<ey=B#|4G$QE#wR#+8a2JywDaqV
z;BWQlt`&+WWyw!QAvCTZ;wnrg%=U~kl4eA$2iAWZCSO?@Lo%X_P64-n=;%&lh}4TK
z7r*50Cf(GOGc~$cx&C=Y(EJ=Qw}-lQVH<iP_4)VTFiTeqg36HBrMtuh>0@>XqI^Ua
zPj33C;=K2kO0{tJ<DkZ>FIFNe?K-e>4kQGgdg2NE%Xc1g<dRp!?V0rO^la_Wy=?S5
zB**3k>yP>;&;}oM1wA5~tFL9j<<{?7zCGp(neGk6a{HIfW!feR+&Z>NR$964&#-R%
ze;)*g#s<4+2VBOwvn;E%Izh4!wP@~4-e=YRE$=34;!AVy;52Q(Hhk0fT2O!1K!(}%
zsS7G`%3QVo<{QBJ-<Pe2435;z-eEXwX{>osPxN*ZOR23Px@_xK_cez=kOwX>9I;n;
z)0Y%y0-7O@8ZS1luw<Xg<RFDGgG;uXQ&Pq?V^vmR!)k~k6?u32Zw{&+^6ZV@9y#<r
z5P>MMkr1!F^*CDWCm!Y%;!xTB!#MxjT>eu(@G$t4+L1`{J7<b6M{3h_aJox|KVs56
z8`bq~kc;b7d&=LVpA*LSU#tD^r~kLI{_m&%)18xk_g{AGf2#36)%gFZYHa+jS0v`d
x1OJ8odhMc`OMMaD8iG#<g(Fe_-}wWQ9Flxz!SG63vo!7`YRZ~Q6<5%q{|`Smz>EL@

literal 0
HcmV?d00001

diff --git a/docs/source/_static/theme_overrides.css b/docs/source/_static/theme_overrides.css
index e64d40f1116e5..eeba0ef4cce6e 100644
--- a/docs/source/_static/theme_overrides.css
+++ b/docs/source/_static/theme_overrides.css
@@ -21,43 +21,15 @@
 /* Customizing with theme CSS variables */
 
 :root {
-  --pst-color-active-navigation: 215, 70, 51;
-  --pst-color-link-hover: 215, 70, 51;
-  --pst-color-headerlink: 215, 70, 51;
-  /* Use normal text color (like h3, ..) instead of primary color */
-  --pst-color-h1: var(--color-text-base);
-  --pst-color-h2: var(--color-text-base);
-  /* Use softer blue from bootstrap's default info color */
-  --pst-color-info: 23, 162, 184;
-  --pst-header-height: 0px;
-}
-
-code {
-  color: rgb(215, 70, 51);
-}
-
-.footer {
-  text-align: center;
-}
-
-/* Ensure the logo is properly displayed */
-
-.navbar-brand {
-  height: auto;
-  width: auto;
-}
-
-a.navbar-brand img {
-  height: auto;
-  width: auto;
-  max-height: 15vh;
-  max-width: 100%;
+  /* Change header hight to make the logo a bit larger */
+  --pst-header-height: 6rem;
+  /* Make headings more bold */
+  --pst-font-weight-heading: 600;
 }
 
 /* Contibuting landing page overview cards */
 
 .contrib-card {
-  background: #fff;
   border-radius: 0;
   padding: 30px 10px 20px 10px;
   margin: 10px 0px;
@@ -70,12 +42,12 @@ a.navbar-brand img {
 .contrib-card .sd-card-img-top {
   margin: 2px;
   height: 75px;
+  background: none !important;
 }
 
 .contrib-card .sd-card-title {
-  /* color: rgb(var(--pst-color-h1)) !important; */
+  color: var(--pst-color-primary);
   font-size: var(--pst-font-size-h3);
-  /* font-weight: bold; */
   padding: 1rem 0rem 0.5rem 0rem;
 }
 
@@ -112,48 +84,3 @@ dl.cpp.enumerator {
 p.breathe-sectiondef-title {
   margin-top: 1rem;
 }
-
-/* Limit the max height of the sidebar navigation section. Because in our
-custimized template, there is more content above the navigation, i.e.
-larger logo: if we don't decrease the max-height, it will overlap with
-the footer.
-Details: min(15vh, 110px) for the logo size, 8rem for search box etc*/
-
-@media (min-width:720px) {
-  @supports (position:-webkit-sticky) or (position:sticky) {
-    .bd-links {
-      max-height: calc(100vh - min(15vh, 110px) - 8rem)
-    }
-  }
-}
-
-/* Styling to get the version dropdown and search box side-by-side on wide screens */
-
-#version-search-wrapper {
-  width: inherit;
-  display: flex;
-  flex-wrap: wrap;
-  justify-content: left;
-  align-items: center;
-}
-
-#version-button {
-  padding-left: 0.5rem;
-  padding-right: 1rem;
-}
-
-#search-box {
-  flex: 1 0 12em;
-}
-
-/* Fix table text wrapping in RTD theme,
- * see https://rackerlabs.github.io/docs-rackspace/tools/rtd-tables.html
- */
-
-@media screen {
-    table.docutils td {
-        /* !important prevents the common CSS stylesheets from overriding
-          this as on RTD they are loaded after this stylesheet */
-        white-space: normal !important;
-    }
-}
diff --git a/docs/source/_static/versions.json b/docs/source/_static/versions.json
index f91b0a17e7774..8d9c5878c8213 100644
--- a/docs/source/_static/versions.json
+++ b/docs/source/_static/versions.json
@@ -1,62 +1,73 @@
 [
     {
         "name": "14.0 (dev)",
-        "version": "dev/"
+        "version": "dev/",
+        "url": "https://arrow.apache.org/docs/dev/"
     },
     {
         "name": "13.0 (stable)",
-        "version": ""
+        "version": "",
+        "url": "https://arrow.apache.org/docs/",
+        "preferred": true
     },
     {
         "name": "12.0",
-        "version": "12.0/"
-    },
-    {
-        "name": "12.0",
-        "version": "12.0/"
+        "version": "12.0/",
+        "url": "https://arrow.apache.org/docs/12.0/"
     },
     {
         "name": "11.0",
-        "version": "11.0/"
+        "version": "11.0/",
+        "url": "https://arrow.apache.org/docs/11.0/"
     },
     {
         "name": "10.0",
-        "version": "10.0/"
+        "version": "10.0/",
+        "url": "https://arrow.apache.org/docs/10.0/"
     },
     {
         "name": "9.0",
-        "version": "9.0/"
+        "version": "9.0/",
+        "url": "https://arrow.apache.org/docs/9.0/"
     },
     {
         "name": "8.0",
-        "version": "8.0/"
+        "version": "8.0/",
+        "url": "https://arrow.apache.org/docs/8.0/"
     },
     {
         "name": "7.0",
-        "version": "7.0/"
+        "version": "7.0/",
+        "url": "https://arrow.apache.org/docs/7.0/"
     },
     {
         "name": "6.0",
-        "version": "6.0/"
+        "version": "6.0/",
+        "url": "https://arrow.apache.org/docs/6.0/"
     },
     {
         "name": "5.0",
-        "version": "5.0/"
+        "version": "5.0/",
+        "url": "https://arrow.apache.org/docs/5.0/"
     },
     {
         "name": "4.0",
-        "version": "4.0/"
+        "version": "4.0/",
+        "url": "https://arrow.apache.org/docs/4.0/"
     },
     {
         "name": "3.0",
-        "version": "3.0/"
+        "version": "3.0/",
+        "url": "https://arrow.apache.org/docs/3.0/"
     },
     {
         "name": "2.0",
-        "version": "2.0/"
+        "version": "2.0/",
+        "url": "https://arrow.apache.org/docs/2.0/"
     },
     {
         "name": "1.0",
-        "version": "1.0/"
+        "version": "1.0/",
+        "url": "https://arrow.apache.org/docs/dev/"
     }
 ]
diff --git a/docs/source/_static/versionwarning.js b/docs/source/_static/versionwarning.js
index 601b93b75ddd8..e53c160ed98f7 100644
--- a/docs/source/_static/versionwarning.js
+++ b/docs/source/_static/versionwarning.js
@@ -17,6 +17,8 @@
 
 (function() {
     // adapted 2022-11 from https://mne.tools/versionwarning.js
+    // Not used anymore for versions 14.0.0 and higher
+    // Kept for older docs versions (13.0.0 and lower)
     if (location.hostname == 'arrow.apache.org') {
         $.getJSON("https://arrow.apache.org/docs/_static/versions.json", function(data){
             var latestStable = data[1].name.replace(" (stable)","");
diff --git a/docs/source/_templates/docs-sidebar.html b/docs/source/_templates/docs-sidebar.html
deleted file mode 100644
index 26d42a82f1d5c..0000000000000
--- a/docs/source/_templates/docs-sidebar.html
+++ /dev/null
@@ -1,25 +0,0 @@
-
-<a class="navbar-brand" href="{{ pathto(master_doc) }}">
-  <img src="{{ logo_url|e }}" class="logo" alt="logo">
-</a>
-
-<div id="version-search-wrapper">
-
-{% include "version-switcher.html" %}
-
-<form id="search-box" class="bd-search d-flex align-items-center" action="{{ pathto('search') }}" method="get">
-  <i class="icon fas fa-search"></i>
-  <input type="search" class="form-control" name="q" id="search-input" placeholder="{{ theme_search_bar_text }}" aria-label="{{ theme_search_bar_text }}" autocomplete="off" >
-</form>
-
-</div>
-
-<nav class="bd-links" id="bd-docs-nav" aria-label="Main navigation">
-  <div class="bd-toc-item active">
-    {% if "python/api" in pagename or "python/generated" in pagename %}
-    {{ generate_nav_html("sidebar", startdepth=0, maxdepth=3, collapse=False, includehidden=True, titles_only=True) }}
-    {% else %}
-    {{ generate_nav_html("sidebar", startdepth=0, maxdepth=4, collapse=False, includehidden=True, titles_only=True) }}
-    {% endif %}
-  </div>
-</nav>
diff --git a/docs/source/_templates/layout.html b/docs/source/_templates/layout.html
index ca39e8e5a8fae..956e0142c5062 100644
--- a/docs/source/_templates/layout.html
+++ b/docs/source/_templates/layout.html
@@ -22,13 +22,3 @@
   </script>
   <!-- End Matomo Code -->
 {% endblock %}
-
-{# Silence the navbar #}
-{% block docs_navbar %}
-{% endblock %}
-
-{# Add version warnings #}
-{% block footer %}
-  {{ super() }}
-  <script type="text/javascript" src="/docs/_static/versionwarning.js"></script>
-{% endblock %}
diff --git a/docs/source/_templates/version-switcher.html b/docs/source/_templates/version-switcher.html
deleted file mode 100644
index 24a8c15ac0102..0000000000000
--- a/docs/source/_templates/version-switcher.html
+++ /dev/null
@@ -1,60 +0,0 @@
-<div id="version-button" class="dropdown">
-    <button type="button" class="btn btn-secondary btn-sm navbar-btn dropdown-toggle" id="version_switcher_button" data-toggle="dropdown">
-        {{ release }}
-        <span class="caret"></span>
-    </button>
-    <div id="version_switcher" class="dropdown-menu list-group-flush py-0" aria-labelledby="version_switcher_button">
-    <!-- dropdown will be populated by javascript on page load -->
-    </div>
-</div>
-
-<script type="text/javascript">
-// Function to construct the target URL from the JSON components
-function buildURL(entry) {
-    var template = "{{ switcher_template_url }}";  // supplied by jinja
-    template = template.replace("{version}", entry.version);
-    return template;
-}
-
-// Function to check if corresponding page path exists in other version of docs
-// and, if so, go there instead of the homepage of the other docs version
-function checkPageExistsAndRedirect(event) {
-    const currentFilePath = "{{ pagename }}.html",
-          otherDocsHomepage = event.target.getAttribute("href");
-    let tryUrl = `${otherDocsHomepage}${currentFilePath}`;
-    $.ajax({
-        type: 'HEAD',
-        url: tryUrl,
-        // if the page exists, go there
-        success: function() {
-            location.href = tryUrl;
-        }
-    }).fail(function() {
-        location.href = otherDocsHomepage;
-    });
-    return false;
-}
-
-// Function to populate the version switcher
-(function () {
-    // get JSON config
-    $.getJSON("{{ switcher_json_url }}", function(data, textStatus, jqXHR) {
-        // create the nodes first (before AJAX calls) to ensure the order is
-        // correct (for now, links will go to doc version homepage)
-        $.each(data, function(index, entry) {
-            // if no custom name specified (e.g., "latest"), use version string
-            if (!("name" in entry)) {
-                entry.name = entry.version;
-            }
-            // construct the appropriate URL, and add it to the dropdown
-            entry.url = buildURL(entry);
-            const node = document.createElement("a");
-            node.setAttribute("class", "list-group-item list-group-item-action py-1");
-            node.setAttribute("href", `${entry.url}`);
-            node.textContent = `${entry.name}`;
-            node.onclick = checkPageExistsAndRedirect;
-            $("#version_switcher").append(node);
-        });
-    });
-})();
-</script>
diff --git a/docs/source/c_glib/index.rst b/docs/source/c_glib/index.rst
index 56db23f2a2040..b10524eb2e8a5 100644
--- a/docs/source/c_glib/index.rst
+++ b/docs/source/c_glib/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _c-glib:
+
 C/GLib docs
 ===========
 
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 23b7070c4a84e..e9e8969f55254 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -115,7 +115,6 @@
     'IPython.sphinxext.ipython_console_highlighting',
     'IPython.sphinxext.ipython_directive',
     'numpydoc',
-    "sphinxcontrib.jquery",
     'sphinx_design',
     'sphinx_copybutton',
     'sphinx.ext.autodoc',
@@ -288,16 +287,37 @@
 # further.  For a list of options available for each theme, see the
 # documentation.
 #
+
 html_theme_options = {
     "show_toc_level": 2,
     "use_edit_page_button": True,
+    "logo": {
+      "image_light": "_static/arrow.png",
+      "image_dark": "_static/arrow-dark.png",
+    },
+    "header_links_before_dropdown": 2,
+    "header_dropdown_text": "Language implementations",
+    "navbar_end": ["version-switcher", "theme-switcher", "navbar-icon-links"],
+    "icon_links": [
+        {
+            "name": "GitHub",
+            "url": "https://github.com/apache/arrow",
+            "icon": "fa-brands fa-square-github",
+        },
+        {
+            "name": "Twitter",
+            "url": "https://twitter.com/ApacheArrow",
+            "icon": "fa-brands fa-square-twitter",
+        },
+    ],
+    "show_version_warning_banner": True,
+    "switcher": {
+        "json_url": "/docs/_static/versions.json",
+        "version_match": version,
+    },
 }
 
 html_context = {
-    "switcher_json_url": "/docs/_static/versions.json",
-    "switcher_template_url": "https://arrow.apache.org/docs/{version}",
-    # for local testing
-    # "switcher_template_url": "http://0.0.0.0:8000/docs/{version}",
     "github_user": "apache",
     "github_repo": "arrow",
     "github_version": "main",
@@ -319,7 +339,7 @@
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
 #
-html_logo = "_static/arrow.png"
+# html_logo = "_static/arrow.png"
 
 # The name of an image file (relative to this directory) to use as a favicon of
 # the docs.  This file should be a Windows icon file (.ico) being 16x16 or
@@ -354,10 +374,9 @@
 
 # Custom sidebar templates, maps document names to template names.
 #
-html_sidebars = {
+# html_sidebars = {
 #    '**': ['sidebar-logo.html', 'sidebar-search-bs.html', 'sidebar-nav-bs.html'],
-    '**': ['docs-sidebar.html'],
-}
+# }
 
 # The base URL which points to the root of the HTML documentation,
 # used for canonical url
diff --git a/docs/source/cpp/index.rst b/docs/source/cpp/index.rst
index e06453e202979..6d4d4aaa8148c 100644
--- a/docs/source/cpp/index.rst
+++ b/docs/source/cpp/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _cpp:
+
 C++ Implementation
 ==================
 
@@ -25,9 +27,9 @@ Welcome to the Apache Arrow C++ implementation documentation!
    :padding: 2 2 0 0
    :class-container: sd-text-center
 
-   .. grid-item-card:: Basic understanding
+   .. grid-item-card:: Getting started
       :class-card: contrib-card
-      :shadow: md
+      :shadow: none
 
       Start here to gain a basic understanding of Arrow with
       an installation and linking guide, documentation of
@@ -37,14 +39,14 @@ Welcome to the Apache Arrow C++ implementation documentation!
 
       .. button-link:: getting_started.html
          :click-parent:
-         :color: secondary
+         :color: primary
          :expand:
 
-         Getting started
+         To Getting started
 
    .. grid-item-card:: User Guide
       :class-card: contrib-card
-      :shadow: md
+      :shadow: none
 
       Explore more specific topics and underlying concepts
       of Arrow C++
@@ -53,19 +55,19 @@ Welcome to the Apache Arrow C++ implementation documentation!
 
       .. button-link:: user_guide.html
          :click-parent:
-         :color: secondary
+         :color: primary
          :expand:
 
-         User Guide
+         To the User Guide
 
 .. grid:: 2
    :gutter: 4
    :padding: 2 2 0 0
    :class-container: sd-text-center
 
-   .. grid-item-card:: Examples of use
+   .. grid-item-card:: Examples
       :class-card: contrib-card
-      :shadow: md
+      :shadow: none
 
       Find the description and location of the examples
       using Arrow C++ library
@@ -74,14 +76,14 @@ Welcome to the Apache Arrow C++ implementation documentation!
 
       .. button-link:: examples/index.html
          :click-parent:
-         :color: secondary
+         :color: primary
          :expand:
 
-         Examples
+         To the Examples
 
-   .. grid-item-card:: Reference documentation
+   .. grid-item-card:: API Reference
       :class-card: contrib-card
-      :shadow: md
+      :shadow: none
 
       Explore Arrow’s API reference documentation
 
@@ -89,10 +91,32 @@ Welcome to the Apache Arrow C++ implementation documentation!
 
       .. button-link:: api.html
          :click-parent:
-         :color: secondary
+         :color: primary
+         :expand:
+
+         To the API Reference
+
+.. grid:: 1
+   :gutter: 4
+   :padding: 2 2 0 0
+   :class-container: sd-text-center
+
+   .. grid-item-card:: Cookbook
+      :class-card: contrib-card
+      :shadow: none
+
+      Collection of recipes which demonstrate how to
+      solve many common tasks that users might need
+      to perform when working with arrow data
+
+      +++
+
+      .. button-link:: https://arrow.apache.org/cookbook/cpp/
+         :click-parent:
+         :color: primary
          :expand:
 
-         API Reference
+         To the Cookbook
 
 .. toctree::
    :maxdepth: 2
@@ -102,3 +126,4 @@ Welcome to the Apache Arrow C++ implementation documentation!
    user_guide
    Examples <examples/index>
    api
+   C++ cookbook <https://arrow.apache.org/cookbook/cpp/>
diff --git a/docs/source/developers/continuous_integration/index.rst b/docs/source/developers/continuous_integration/index.rst
index 6e8e26981c549..f988b5ab69d50 100644
--- a/docs/source/developers/continuous_integration/index.rst
+++ b/docs/source/developers/continuous_integration/index.rst
@@ -15,6 +15,7 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _continuous_integration:
 
 **********************
 Continuous Integration
diff --git a/docs/source/developers/continuous_integration/overview.rst b/docs/source/developers/continuous_integration/overview.rst
index 1d82e845a3360..3e155bf6001e9 100644
--- a/docs/source/developers/continuous_integration/overview.rst
+++ b/docs/source/developers/continuous_integration/overview.rst
@@ -20,7 +20,7 @@
 Continuous Integration
 ======================
 
-Continuous Integration for Arrow is fairly complex as it needs to run across different combinations of package managers, compilers, versions of multiple sofware libraries, operating systems, and other potential sources of variation.  In this article, we will give an overview of its main components and the relevant files and directories.
+Continuous Integration for Arrow is fairly complex as it needs to run across different combinations of package managers, compilers, versions of multiple software libraries, operating systems, and other potential sources of variation.  In this article, we will give an overview of its main components and the relevant files and directories.
 
 Some files central to Arrow CI are:
 
diff --git a/docs/source/developers/contributing.rst b/docs/source/developers/contributing.rst
deleted file mode 100644
index 6dc2a4e0147d6..0000000000000
--- a/docs/source/developers/contributing.rst
+++ /dev/null
@@ -1,190 +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.
-
-.. highlight:: console
-
-.. _contributing:
-
-****************************
-Contributing to Apache Arrow
-****************************
-
-**Thanks for your interest in the Apache Arrow project.**
-
-Arrow is a large project and may seem overwhelming when you're
-first getting involved. Contributing code is great, but that's
-probably not the first place to start. There are lots of ways to
-make valuable contributions to the project and community.
-
-This page provides some orientation for how to get involved. It also offers
-some recommendations on how to get the best results when engaging with the
-community.
-
-Code of Conduct
-===============
-
-All participation in the Apache Arrow project is governed by the ASF's
-`Code of Conduct <https://www.apache.org/foundation/policies/conduct.html>`_.
-
-.. grid:: 2
-   :gutter: 4
-   :padding: 2 2 0 0
-   :class-container: sd-text-center
-
-   .. grid-item-card:: Community
-      :img-top: ./images/users-solid.svg
-      :class-card: contrib-card
-      :shadow: md
-
-      A good first step to getting involved in the Arrow project is to join
-      the mailing lists and participate in discussions where you can.
-
-      +++
-
-      .. button-link:: https://arrow.apache.org/community/
-         :click-parent:
-         :color: secondary
-         :expand:
-
-         Apache Arrow Community
-
-   .. grid-item-card:: Bug reports
-      :img-top: ./images/bug-solid.svg
-      :class-card: contrib-card
-      :shadow: md
-
-      Alerting us to unexpected behavior and missing features, even
-      if you can't solve the problems yourself, help us understand
-      and prioritize work to improve the libraries.
-
-      +++
-
-      .. button-ref:: bug-reports
-         :ref-type: ref
-         :click-parent:
-         :color: secondary
-         :expand:
-
-         Bugs and Features
-
-.. dropdown:: Communicating through the mailing lists
-   :animate: fade-in-slide-down
-   :class-title: sd-fs-5
-   :class-container: sd-shadow-md
-
-   Projects in The Apache Software Foundation ("the ASF") use public, archived
-   mailing lists to create a public record of each project's development
-   activities and decision-making process.
-
-   While lacking the immediacy of chat or other forms of communication,
-   the mailing lists give participants the opportunity to slow down and be
-   thoughtful in their responses, and they help developers who are spread across
-   many timezones to participate more equally.
-
-   Read more on the `Apache Arrow Community <https://arrow.apache.org/community/>`_
-   page.
-
-.. dropdown:: Improve documentation
-   :animate: fade-in-slide-down
-   :class-title: sd-fs-5
-   :class-container: sd-shadow-md
-
-   A great way to contribute to the project is to improve documentation. If you
-   found some docs to be incomplete or inaccurate, share your hard-earned knowledge
-   with the rest of the community.
-
-   Documentation improvements are also a great way to gain some experience with
-   our submission and review process, discussed below, without requiring a lot
-   of local development environment setup. In fact, many documentation-only changes
-   can be made directly in the GitHub web interface by clicking the "edit" button.
-   This will handle making a fork and a pull request for you.
-
-   * :ref:`documentation`
-   * :ref:`building-docs`
-
-.. grid:: 2
-   :gutter: 4
-   :padding: 2 2 0 0
-   :class-container: sd-text-center
-
-   .. grid-item-card:: New Contributors
-      :img-top: ./images/book-open-solid.svg
-      :class-card: contrib-card
-      :shadow: md
-
-      First time contributing?
-
-      The New Contributor's Guide provides necessary information for
-      contributing to the Apache Arrow project.
-
-      +++
-
-      .. button-ref:: guide-introduction
-         :ref-type: ref
-         :click-parent:
-         :color: secondary
-         :expand:
-
-         New Contributor's guide
-
-   .. grid-item-card:: Overview
-      :img-top: ./images/code-solid.svg
-      :class-card: contrib-card
-      :shadow: md
-
-      A short overview of the contributing process we follow
-      and some additional information you might need if you are not
-      new to the contributing process in general.
-      +++
-
-      .. button-ref:: contrib-overview
-         :ref-type: ref
-         :click-parent:
-         :color: secondary
-         :expand:
-
-         Contributing overview
-
-Language specific
-=================
-
-Connection to the specific language development pages:
-
-.. tab-set::
-
-   .. tab-item:: C++
-
-      * :ref:`cpp-development`
-      * :ref:`C++ Development Guidelines <development-cpp>`
-      * :ref:`building-arrow-cpp`
-
-   .. tab-item:: Java
-
-      * :doc:`java/index`
-
-   .. tab-item:: Python
-
-      * :ref:`python-development`
-
-   .. tab-item:: R
-
-      * `Arrow R Package: Developer environment setup <https://arrow.apache.org/docs/dev/r/articles/developers/setup.html>`_
-      * `Arrow R Package: Common developer workflow tasks <https://arrow.apache.org/docs/dev/r/articles/developers/workflow.html>`_
-
-   .. tab-item:: Ruby
-
-      * `Red Arrow - Apache Arrow Ruby <https://github.com/apache/arrow/tree/main/ruby/red-arrow#development>`_
diff --git a/docs/source/developers/images/book-open-solid.svg b/docs/source/developers/images/book-open-solid.svg
index cbc8ed27256ca..9586e249be060 100644
--- a/docs/source/developers/images/book-open-solid.svg
+++ b/docs/source/developers/images/book-open-solid.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 6.0.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M144.3 32.04C106.9 31.29 63.7 41.44 18.6 61.29c-11.42 5.026-18.6 16.67-18.6 29.15l0 357.6c0 11.55 11.99 19.55 22.45 14.65c126.3-59.14 219.8 11 223.8 14.01C249.1 478.9 252.5 480 256 480c12.4 0 16-11.38 16-15.98V80.04c0-5.203-2.531-10.08-6.781-13.08C263.3 65.58 216.7 33.35 144.3 32.04zM557.4 61.29c-45.11-19.79-88.48-29.61-125.7-29.26c-72.44 1.312-118.1 33.55-120.9 34.92C306.5 69.96 304 74.83 304 80.04v383.1C304 468.4 307.5 480 320 480c3.484 0 6.938-1.125 9.781-3.328c3.925-3.018 97.44-73.16 223.8-14c10.46 4.896 22.45-3.105 22.45-14.65l.0001-357.6C575.1 77.97 568.8 66.31 557.4 61.29z"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" height="1em" viewBox="0 0 576 512"><!--! Font Awesome Free 6.4.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><style>svg{fill:#0a7e91}</style><path d="M249.6 471.5c10.8 3.8 22.4-4.1 22.4-15.5V78.6c0-4.2-1.6-8.4-5-11C247.4 52 202.4 32 144 32C93.5 32 46.3 45.3 18.1 56.1C6.8 60.5 0 71.7 0 83.8V454.1c0 11.9 12.8 20.2 24.1 16.5C55.6 460.1 105.5 448 144 448c33.9 0 79 14 105.6 23.5zm76.8 0C353 462 398.1 448 432 448c38.5 0 88.4 12.1 119.9 22.6c11.3 3.8 24.1-4.6 24.1-16.5V83.8c0-12.1-6.8-23.3-18.1-27.6C529.7 45.3 482.5 32 432 32c-58.4 0-103.4 20-123 35.6c-3.3 2.6-5 6.8-5 11V456c0 11.4 11.7 19.3 22.4 15.5z"/></svg>
\ No newline at end of file
diff --git a/docs/source/developers/images/bug-solid.svg b/docs/source/developers/images/bug-solid.svg
index f842cb240544f..49cc04a1f0f6e 100644
--- a/docs/source/developers/images/bug-solid.svg
+++ b/docs/source/developers/images/bug-solid.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 6.0.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M352 96V99.56C352 115.3 339.3 128 323.6 128H188.4C172.7 128 159.1 115.3 159.1 99.56V96C159.1 42.98 202.1 0 255.1 0C309 0 352 42.98 352 96zM41.37 105.4C53.87 92.88 74.13 92.88 86.63 105.4L150.6 169.4C151.3 170 151.9 170.7 152.5 171.4C166.8 164.1 182.9 160 199.1 160H312C329.1 160 345.2 164.1 359.5 171.4C360.1 170.7 360.7 170 361.4 169.4L425.4 105.4C437.9 92.88 458.1 92.88 470.6 105.4C483.1 117.9 483.1 138.1 470.6 150.6L406.6 214.6C405.1 215.3 405.3 215.9 404.6 216.5C410.7 228.5 414.6 241.9 415.7 256H480C497.7 256 512 270.3 512 288C512 305.7 497.7 320 480 320H416C416 344.6 410.5 367.8 400.6 388.6C402.7 389.9 404.8 391.5 406.6 393.4L470.6 457.4C483.1 469.9 483.1 490.1 470.6 502.6C458.1 515.1 437.9 515.1 425.4 502.6L362.3 439.6C337.8 461.4 306.5 475.8 272 479.2V240C272 231.2 264.8 224 255.1 224C247.2 224 239.1 231.2 239.1 240V479.2C205.5 475.8 174.2 461.4 149.7 439.6L86.63 502.6C74.13 515.1 53.87 515.1 41.37 502.6C28.88 490.1 28.88 469.9 41.37 457.4L105.4 393.4C107.2 391.5 109.3 389.9 111.4 388.6C101.5 367.8 96 344.6 96 320H32C14.33 320 0 305.7 0 288C0 270.3 14.33 256 32 256H96.3C97.38 241.9 101.3 228.5 107.4 216.5C106.7 215.9 106 215.3 105.4 214.6L41.37 150.6C28.88 138.1 28.88 117.9 41.37 105.4H41.37z"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" height="1em" viewBox="0 0 512 512"><!--! Font Awesome Free 6.4.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><style>svg{fill:#0a7e91}</style><path d="M256 0c53 0 96 43 96 96v3.6c0 15.7-12.7 28.4-28.4 28.4H188.4c-15.7 0-28.4-12.7-28.4-28.4V96c0-53 43-96 96-96zM41.4 105.4c12.5-12.5 32.8-12.5 45.3 0l64 64c.7 .7 1.3 1.4 1.9 2.1c14.2-7.3 30.4-11.4 47.5-11.4H312c17.1 0 33.2 4.1 47.5 11.4c.6-.7 1.2-1.4 1.9-2.1l64-64c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3l-64 64c-.7 .7-1.4 1.3-2.1 1.9c6.2 12 10.1 25.3 11.1 39.5H480c17.7 0 32 14.3 32 32s-14.3 32-32 32H416c0 24.6-5.5 47.8-15.4 68.6c2.2 1.3 4.2 2.9 6 4.8l64 64c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0l-63.1-63.1c-24.5 21.8-55.8 36.2-90.3 39.6V240c0-8.8-7.2-16-16-16s-16 7.2-16 16V479.2c-34.5-3.4-65.8-17.8-90.3-39.6L86.6 502.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l64-64c1.9-1.9 3.9-3.4 6-4.8C101.5 367.8 96 344.6 96 320H32c-17.7 0-32-14.3-32-32s14.3-32 32-32H96.3c1.1-14.1 5-27.5 11.1-39.5c-.7-.6-1.4-1.2-2.1-1.9l-64-64c-12.5-12.5-12.5-32.8 0-45.3z"/></svg>
\ No newline at end of file
diff --git a/docs/source/developers/images/code-solid.svg b/docs/source/developers/images/code-solid.svg
index 725f767148b2c..4bbd567528ef8 100644
--- a/docs/source/developers/images/code-solid.svg
+++ b/docs/source/developers/images/code-solid.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512"><!--! Font Awesome Pro 6.0.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M414.8 40.79L286.8 488.8C281.9 505.8 264.2 515.6 247.2 510.8C230.2 505.9 220.4 488.2 225.2 471.2L353.2 23.21C358.1 6.216 375.8-3.624 392.8 1.232C409.8 6.087 419.6 23.8 414.8 40.79H414.8zM518.6 121.4L630.6 233.4C643.1 245.9 643.1 266.1 630.6 278.6L518.6 390.6C506.1 403.1 485.9 403.1 473.4 390.6C460.9 378.1 460.9 357.9 473.4 345.4L562.7 256L473.4 166.6C460.9 154.1 460.9 133.9 473.4 121.4C485.9 108.9 506.1 108.9 518.6 121.4V121.4zM166.6 166.6L77.25 256L166.6 345.4C179.1 357.9 179.1 378.1 166.6 390.6C154.1 403.1 133.9 403.1 121.4 390.6L9.372 278.6C-3.124 266.1-3.124 245.9 9.372 233.4L121.4 121.4C133.9 108.9 154.1 108.9 166.6 121.4C179.1 133.9 179.1 154.1 166.6 166.6V166.6z"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" height="1em" viewBox="0 0 640 512"><!--! Font Awesome Free 6.4.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><style>svg{fill:#0a7c8f}</style><path d="M392.8 1.2c-17-4.9-34.7 5-39.6 22l-128 448c-4.9 17 5 34.7 22 39.6s34.7-5 39.6-22l128-448c4.9-17-5-34.7-22-39.6zm80.6 120.1c-12.5 12.5-12.5 32.8 0 45.3L562.7 256l-89.4 89.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l112-112c12.5-12.5 12.5-32.8 0-45.3l-112-112c-12.5-12.5-32.8-12.5-45.3 0zm-306.7 0c-12.5-12.5-32.8-12.5-45.3 0l-112 112c-12.5 12.5-12.5 32.8 0 45.3l112 112c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L77.3 256l89.4-89.4c12.5-12.5 12.5-32.8 0-45.3z"/></svg>
\ No newline at end of file
diff --git a/docs/source/developers/images/users-solid.svg b/docs/source/developers/images/users-solid.svg
index a04d7fe2fd4a0..4bdf638a70f89 100644
--- a/docs/source/developers/images/users-solid.svg
+++ b/docs/source/developers/images/users-solid.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 512"><!--! Font Awesome Pro 6.0.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2022 Fonticons, Inc. --><path d="M319.9 320c57.41 0 103.1-46.56 103.1-104c0-57.44-46.54-104-103.1-104c-57.41 0-103.1 46.56-103.1 104C215.9 273.4 262.5 320 319.9 320zM369.9 352H270.1C191.6 352 128 411.7 128 485.3C128 500.1 140.7 512 156.4 512h327.2C499.3 512 512 500.1 512 485.3C512 411.7 448.4 352 369.9 352zM512 160c44.18 0 80-35.82 80-80S556.2 0 512 0c-44.18 0-80 35.82-80 80S467.8 160 512 160zM183.9 216c0-5.449 .9824-10.63 1.609-15.91C174.6 194.1 162.6 192 149.9 192H88.08C39.44 192 0 233.8 0 285.3C0 295.6 7.887 304 17.62 304h199.5C196.7 280.2 183.9 249.7 183.9 216zM128 160c44.18 0 80-35.82 80-80S172.2 0 128 0C83.82 0 48 35.82 48 80S83.82 160 128 160zM551.9 192h-61.84c-12.8 0-24.88 3.037-35.86 8.24C454.8 205.5 455.8 210.6 455.8 216c0 33.71-12.78 64.21-33.16 88h199.7C632.1 304 640 295.6 640 285.3C640 233.8 600.6 192 551.9 192z"/></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" height="1em" viewBox="0 0 640 512"><!--! Font Awesome Free 6.4.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2023 Fonticons, Inc. --><style>svg{fill:#0a788a}</style><path d="M144 0a80 80 0 1 1 0 160A80 80 0 1 1 144 0zM512 0a80 80 0 1 1 0 160A80 80 0 1 1 512 0zM0 298.7C0 239.8 47.8 192 106.7 192h42.7c15.9 0 31 3.5 44.6 9.7c-1.3 7.2-1.9 14.7-1.9 22.3c0 38.2 16.8 72.5 43.3 96c-.2 0-.4 0-.7 0H21.3C9.6 320 0 310.4 0 298.7zM405.3 320c-.2 0-.4 0-.7 0c26.6-23.5 43.3-57.8 43.3-96c0-7.6-.7-15-1.9-22.3c13.6-6.3 28.7-9.7 44.6-9.7h42.7C592.2 192 640 239.8 640 298.7c0 11.8-9.6 21.3-21.3 21.3H405.3zM224 224a96 96 0 1 1 192 0 96 96 0 1 1 -192 0zM128 485.3C128 411.7 187.7 352 261.3 352H378.7C452.3 352 512 411.7 512 485.3c0 14.7-11.9 26.7-26.7 26.7H154.7c-14.7 0-26.7-11.9-26.7-26.7z"/></svg>
\ No newline at end of file
diff --git a/docs/source/developers/index.rst b/docs/source/developers/index.rst
index f6a15a6c5452e..c2f10c9e95c47 100644
--- a/docs/source/developers/index.rst
+++ b/docs/source/developers/index.rst
@@ -15,12 +15,206 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. highlight:: console
+
+.. _developers:
+
+Development
+===========
+
+Connection to the specific language development pages:
+
+.. tab-set::
+
+   .. tab-item:: C++
+
+      * :ref:`cpp-development`
+      * :ref:`C++ Development Guidelines <development-cpp>`
+      * :ref:`building-arrow-cpp`
+
+   .. tab-item:: Java
+
+      * :doc:`java/index`
+
+   .. tab-item:: Python
+
+      * :ref:`python-development`
+
+   .. tab-item:: R
+
+      * `Arrow R Package: Developer environment setup <https://arrow.apache.org/docs/dev/r/articles/developers/setup.html>`_
+      * `Arrow R Package: Common developer workflow tasks <https://arrow.apache.org/docs/dev/r/articles/developers/workflow.html>`_
+
+   .. tab-item:: Ruby
+
+      * `Red Arrow - Apache Arrow Ruby <https://github.com/apache/arrow/tree/main/ruby/red-arrow#development>`_
+
+.. _contributing:
+
+Contributing to Apache Arrow
+============================
+
+**Thanks for your interest in the Apache Arrow project.**
+
+Arrow is a large project and may seem overwhelming when you're
+first getting involved. Contributing code is great, but that's
+probably not the first place to start. There are lots of ways to
+make valuable contributions to the project and community.
+
+This page provides some orientation for how to get involved. It also offers
+some recommendations on how to get the best results when engaging with the
+community.
+
+Code of Conduct
+---------------
+
+All participation in the Apache Arrow project is governed by the ASF's
+`Code of Conduct <https://www.apache.org/foundation/policies/conduct.html>`_.
+
+.. grid:: 2
+   :gutter: 4
+   :padding: 2 2 0 0
+   :class-container: sd-text-center
+
+   .. grid-item-card:: Apache Arrow Community
+      :img-top: ./images/users-solid.svg
+      :class-card: contrib-card
+      :shadow: none
+
+      A good first step to getting involved in the Arrow project is to join
+      the mailing lists and participate in discussions where you can.
+
+      +++
+
+      .. button-link:: https://arrow.apache.org/community/
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To Apache Arrow Community
+
+   .. grid-item-card:: Bug reports and feature requests
+      :img-top: ./images/bug-solid.svg
+      :class-card: contrib-card
+      :shadow: none
+
+      Alerting us to unexpected behavior and missing features, even
+      if you can't solve the problems yourself, help us understand
+      and prioritize work to improve the libraries.
+
+      +++
+
+      .. button-ref:: bug-reports
+         :ref-type: ref
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To Bug reports and feature requests
+
+.. dropdown:: Communicating through the mailing lists
+   :animate: fade-in-slide-down
+   :class-title: sd-fs-5
+   :class-container: sd-shadow-none
+
+   Projects in The Apache Software Foundation ("the ASF") use public, archived
+   mailing lists to create a public record of each project's development
+   activities and decision-making process.
+
+   While lacking the immediacy of chat or other forms of communication,
+   the mailing lists give participants the opportunity to slow down and be
+   thoughtful in their responses, and they help developers who are spread across
+   many timezones to participate more equally.
+
+   Read more on the `Apache Arrow Community <https://arrow.apache.org/community/>`_
+   page.
+
+.. dropdown:: Improve documentation
+   :animate: fade-in-slide-down
+   :class-title: sd-fs-5
+
+   A great way to contribute to the project is to improve documentation. If you
+   found some docs to be incomplete or inaccurate, share your hard-earned knowledge
+   with the rest of the community.
+
+   Documentation improvements are also a great way to gain some experience with
+   our submission and review process, discussed below, without requiring a lot
+   of local development environment setup. In fact, many documentation-only changes
+   can be made directly in the GitHub web interface by clicking the "edit" button.
+   This will handle making a fork and a pull request for you.
+
+   * :ref:`documentation`
+   * :ref:`building-docs`
+
+.. grid:: 2
+   :gutter: 4
+   :padding: 2 2 0 0
+   :class-container: sd-text-center
+
+   .. grid-item-card:: New Contributor's guide
+      :img-top: ./images/book-open-solid.svg
+      :class-card: contrib-card
+
+      First time contributing?
+
+      The New Contributor's Guide provides necessary information for
+      contributing to the Apache Arrow project.
+
+      +++
+
+      .. button-ref:: guide-introduction
+         :ref-type: ref
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To the New Contributor's guide
+
+   .. grid-item-card:: Contributing Overview
+      :img-top: ./images/code-solid.svg
+      :class-card: contrib-card
+
+      A short overview of the contributing process we follow
+      and some additional information you might need if you are not
+      new to the contributing process in general.
+      +++
+
+      .. button-ref:: contrib-overview
+         :ref-type: ref
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To Contributing overview
+
+.. dropdown:: Continuous Integration
+   :animate: fade-in-slide-down
+   :class-title: sd-fs-5
+   :class-container: sd-shadow-none
+
+   Continuous Integration needs to run across different combinations of package managers, compilers, versions of multiple
+   software libraries, operating systems, and other potential sources of variation.
+
+   Read more on the :ref:`continuous_integration` page.
+
+.. dropdown:: Benchmarks
+   :animate: fade-in-slide-down
+   :class-title: sd-fs-5
+   :class-container: sd-shadow-none
+
+   How to use the benchmark suite can be found on the :ref:`benchmarks` page.
+
+.. dropdown:: Release Guide
+   :animate: fade-in-slide-down
+   :class-title: sd-fs-5
+   :class-container: sd-shadow-none
+
+   To learn about the detailed information on the steps followed to perform a release, see :ref:`release`.
+
 .. toctree::
    :maxdepth: 2
-   :caption: Development
    :hidden:
 
-   contributing
    bug_reports
    guide/index
    overview
diff --git a/docs/source/developers/overview.rst b/docs/source/developers/overview.rst
index 272f3dbd98074..c7bc4273313bc 100644
--- a/docs/source/developers/overview.rst
+++ b/docs/source/developers/overview.rst
@@ -45,7 +45,7 @@ checklist for using ``git``:
 
   .. dropdown:: How to squash local commits?
     :animate: fade-in-slide-down
-    :class-container: sd-shadow-md
+    :class-container: sd-shadow-none
 
     Abort the rebase with:
 
@@ -78,7 +78,7 @@ checklist for using ``git``:
     
   .. dropdown:: Setting rebase to be default
     :animate: fade-in-slide-down
-    :class-container: sd-shadow-md
+    :class-container: sd-shadow-none
 
     If you set the following in your repo's ``.git/config``, the ``--rebase`` option can be
     omitted from the ``git pull`` command, as it is implied by default.
@@ -136,7 +136,7 @@ will merge the pull request. This is done with a
 
 .. dropdown:: Details on squash merge
   :animate: fade-in-slide-down
-  :class-container: sd-shadow-md
+  :class-container: sd-shadow-none
 
   A pull request is merged with a squash merge so that all of your commits will be
   registered as a single commit to the main branch; this simplifies the
diff --git a/docs/source/developers/release.rst b/docs/source/developers/release.rst
index 066400b33ffb5..6924c2d714e8b 100644
--- a/docs/source/developers/release.rst
+++ b/docs/source/developers/release.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _release:
+
 ========================
 Release Management Guide
 ========================
diff --git a/docs/source/format/index.rst b/docs/source/format/index.rst
index 1771b36d76128..ae2baf128b472 100644
--- a/docs/source/format/index.rst
+++ b/docs/source/format/index.rst
@@ -15,10 +15,13 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _format:
+
+Specifications and Protocols
+============================
+
 .. toctree::
    :maxdepth: 2
-   :caption: Specifications and Protocols
-   :hidden:
 
    Versioning
    Columnar
diff --git a/docs/source/index.rst b/docs/source/index.rst
index b348d3dab22b7..e8cdf50c5b1ec 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+:html_theme.sidebar_secondary.remove:
+
 Apache Arrow
 ============
 
@@ -35,11 +37,71 @@ such topics as:
 **To learn how to use Arrow refer to the documentation specific to your
 target environment.**
 
+.. grid:: 2
+   :gutter: 4
+   :padding: 2 2 0 0
+   :class-container: sd-text-center
+
+   .. grid-item-card:: Specifications and Protocols
+      :class-card: contrib-card
+      :shadow: none
+
+      Read about the Apache Arrow format
+      specifications and Protocols.
+
+      +++
+
+      .. button-ref:: format
+         :ref-type: ref
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To the Specifications and Protocols
+
+   .. grid-item-card:: Development
+      :class-card: contrib-card
+      :shadow: none
+
+      Find the documentation on the topic of
+      contributions, reviews, building of the libraries
+      from source, building of the documentation, 
+      continuous integration, benchmarks and the
+      release process.
+
+      +++
+
+      .. button-ref:: developers
+         :ref-type: ref
+         :click-parent:
+         :color: primary
+         :expand:
+
+         To the Development
+
+.. _toc.columnar:
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   format/index
+
+.. _toc.development:
+
+.. toctree::
+   :maxdepth: 2
+   :hidden:
+
+   developers/index
+
+Implementations
+---------------
+
 .. _toc.usage:
 
 .. toctree::
    :maxdepth: 1
-   :caption: Supported Environments
 
    C/GLib <c_glib/index>
    C++ <cpp/index>
@@ -55,52 +117,15 @@ target environment.**
    Rust <https://docs.rs/crate/arrow/>
    status
 
+Examples
+--------
+
 .. _toc.cookbook:
 
 .. toctree::
    :maxdepth: 1
-   :caption: Cookbooks
-
-   C++ <https://arrow.apache.org/cookbook/cpp/>
-   Java <https://arrow.apache.org/cookbook/java/>
-   Python <https://arrow.apache.org/cookbook/py/>
-   R <https://arrow.apache.org/cookbook/r/>
 
-.. _toc.columnar:
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Specifications and Protocols
-
-   format/Versioning
-   format/Columnar
-   format/CanonicalExtensions
-   format/Flight
-   format/FlightSql
-   format/Integration
-   format/CDataInterface
-   format/CStreamInterface
-   format/CDeviceDataInterface
-   format/ADBC
-   format/Other
-   format/Changing
-   format/Glossary
-
-.. _toc.development:
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Development
-
-   developers/contributing
-   developers/bug_reports
-   developers/guide/index
-   developers/overview
-   developers/reviewing
-   developers/cpp/index
-   developers/java/index
-   developers/python
-   developers/continuous_integration/index
-   developers/benchmarks
-   developers/documentation
-   developers/release
+   C++ cookbook <https://arrow.apache.org/cookbook/cpp/>
+   Java cookbook <https://arrow.apache.org/cookbook/java/>
+   Python cookbook <https://arrow.apache.org/cookbook/py/>
+   R cookbook <https://arrow.apache.org/cookbook/r/>
diff --git a/docs/source/java/index.rst b/docs/source/java/index.rst
index 9b555e297b0f9..cf93b0e897832 100644
--- a/docs/source/java/index.rst
+++ b/docs/source/java/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _java:
+
 Java Implementation
 ===================
 
@@ -41,3 +43,4 @@ on the Arrow format and other language bindings see the :doc:`parent documentati
    cdata
    jdbc
    Reference (javadoc) <reference/index>
+   Java cookbook <https://arrow.apache.org/cookbook/java/>
diff --git a/docs/source/js/index.rst b/docs/source/js/index.rst
index 77813c1372dfe..2ab205a08b850 100644
--- a/docs/source/js/index.rst
+++ b/docs/source/js/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _js:
+
 JavaScript docs
 ===============
 
diff --git a/docs/source/python/index.rst b/docs/source/python/index.rst
index b80cbc7de594e..6a3de3d42b149 100644
--- a/docs/source/python/index.rst
+++ b/docs/source/python/index.rst
@@ -15,8 +15,13 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _python:
+
+Python
+======
+
 PyArrow - Apache Arrow Python bindings
-======================================
+--------------------------------------
 
 This is the documentation of the Python API of Apache Arrow.
 
@@ -62,3 +67,4 @@ files into Arrow structures.
    api
    getting_involved
    benchmarks
+   Python cookbook <https://arrow.apache.org/cookbook/py/>
diff --git a/docs/source/r/index.rst b/docs/source/r/index.rst
index b799544bb6bb3..8ccbec132ad3d 100644
--- a/docs/source/r/index.rst
+++ b/docs/source/r/index.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _r:
+
 R docs
 ======
 

From 286487010b43da384dbeec941d2b49f66638a90a Mon Sep 17 00:00:00 2001
From: Danyaal Khan <danyaal99@hotmail.co.uk>
Date: Wed, 27 Sep 2023 16:42:22 +0100
Subject: [PATCH 419/749] GH-37377: [C#] Throw OverflowException on overflow in
 TimestampArray.ConvertTo() (#37388)

Throw `OverflowException` on overflow in `TimestampArray.ConvertTo()` when `DataType.Unit` is `Nanosecond` and `ticks` is large, instead of silently overflowing and returning the wrong value.
* Closes: #37377

Authored-by: Danyaal Khan <danyaal99@hotmail.co.uk>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 csharp/src/Apache.Arrow/Arrays/TimestampArray.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/TimestampArray.cs b/csharp/src/Apache.Arrow/Arrays/TimestampArray.cs
index 0269768f490bb..0dc5726d01734 100644
--- a/csharp/src/Apache.Arrow/Arrays/TimestampArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/TimestampArray.cs
@@ -76,7 +76,7 @@ protected override long ConvertTo(DateTimeOffset value)
                 switch (DataType.Unit)
                 {
                     case TimeUnit.Nanosecond:
-                        return ticks * 100;
+                        return checked(ticks * 100);
                     case TimeUnit.Microsecond:
                         return ticks / 10;
                     case TimeUnit.Millisecond:

From aca1d3eeed3775c2f02e9f5d59d62478267950b1 Mon Sep 17 00:00:00 2001
From: ismail simsek <ismailsimsek09@gmail.com>
Date: Wed, 27 Sep 2023 17:51:05 +0200
Subject: [PATCH 420/749] GH-35770: [Go][Documentation] Update TimestampType
 zero value as seconds in comment (#37905)

### Rationale for this change

To clear the confusion around the zero value of `TimestampType`

### What changes are included in this PR?

Just a comment change `nanosecond -> second`

### Are these changes tested?

No need to test

### Are there any user-facing changes?

No

Closes: https://github.com/apache/arrow/issues/35770
* Closes: #35770

Authored-by: ismail simsek <ismailsimsek09@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/datatype_fixedwidth.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index 7f62becdc2884..fc0b3aea56e70 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -347,7 +347,7 @@ type TemporalWithUnit interface {
 }
 
 // TimestampType is encoded as a 64-bit signed integer since the UNIX epoch (2017-01-01T00:00:00Z).
-// The zero-value is a nanosecond and time zone neutral. Time zone neutral can be
+// The zero-value is a second and time zone neutral. Time zone neutral can be
 // considered UTC without having "UTC" as a time zone.
 type TimestampType struct {
 	Unit     TimeUnit

From c9674bcc16411d7ecfd3b5587f544758b9fc7062 Mon Sep 17 00:00:00 2001
From: h-vetinari <h.vetinari@gmx.com>
Date: Thu, 28 Sep 2023 22:18:07 +1100
Subject: [PATCH 421/749] GH-37621: [Packaging][Conda] Sync conda recipes with
 feedstocks (#37624)

Syncing after the release of 13.0.0 + a couple of migrations (state as of https://github.com/conda-forge/arrow-cpp-feedstock/pull/1168 & https://github.com/conda-forge/r-arrow-feedstock/pull/68)

Relevant updates:
* we're not building twice for different protobuf versions anymore
* new abseil version (fixes #36908)
* we've finally upgraded the aws-sdk to 1.11
* the default R versions (on unix) are now 4.2 & 4.3.

Also some further hardening of the activation scripts & clean-ups for dependencies & test skips.
* Closes: #37621

Lead-authored-by: H. Vetinari <h.vetinari@gmx.com>
Co-authored-by: h-vetinari <h.vetinari@gmx.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 .../linux_64_cuda_compiler_version11.2.yaml   | 20 +++---
 .../linux_64_cuda_compiler_versionNone.yaml   | 20 +++---
 ...nux_aarch64_cuda_compiler_version11.2.yaml | 20 +++---
 ...nux_aarch64_cuda_compiler_versionNone.yaml | 20 +++---
 ...nux_ppc64le_cuda_compiler_version11.2.yaml | 20 +++---
 ...nux_ppc64le_cuda_compiler_versionNone.yaml | 20 +++---
 .../conda-recipes/.ci_support/osx_64_.yaml    | 22 +++----
 .../conda-recipes/.ci_support/osx_arm64_.yaml | 20 +++---
 ...r_base4.1.yaml => linux_64_r_base4.3.yaml} |  2 +-
 ...e4.1.yaml => linux_aarch64_r_base4.3.yaml} |  2 +-
 ...4_r_base4.1.yaml => osx_64_r_base4.3.yaml} |  2 +-
 ..._base4.1.yaml => osx_arm64_r_base4.3.yaml} |  2 +-
 .../win_64_cuda_compiler_version11.2.yaml     | 22 +++----
 .../win_64_cuda_compiler_versionNone.yaml     | 22 +++----
 dev/tasks/conda-recipes/arrow-cpp/activate.sh | 17 +++--
 .../conda-recipes/arrow-cpp/build-arrow.sh    |  4 +-
 .../conda-recipes/arrow-cpp/build-pyarrow.sh  |  4 ++
 dev/tasks/conda-recipes/arrow-cpp/meta.yaml   | 65 ++++++++-----------
 dev/tasks/tasks.yml                           | 24 +++----
 19 files changed, 151 insertions(+), 177 deletions(-)
 rename dev/tasks/conda-recipes/.ci_support/r/{linux_64_r_base4.1.yaml => linux_64_r_base4.3.yaml} (98%)
 rename dev/tasks/conda-recipes/.ci_support/r/{linux_aarch64_r_base4.1.yaml => linux_aarch64_r_base4.3.yaml} (98%)
 rename dev/tasks/conda-recipes/.ci_support/r/{osx_64_r_base4.1.yaml => osx_64_r_base4.3.yaml} (98%)
 rename dev/tasks/conda-recipes/.ci_support/r/{osx_arm64_r_base4.1.yaml => osx_arm64_r_base4.3.yaml} (98%)

diff --git a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
index 1cdcec199e7ba..042e2364d1c49 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_version11.2.yaml
@@ -1,7 +1,7 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -33,20 +33,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -67,7 +65,7 @@ snappy:
 target_platform:
 - linux-64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
index 5be5b58a73932..9885e6db38cd7 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_64_cuda_compiler_versionNone.yaml
@@ -1,7 +1,7 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -33,20 +33,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -67,7 +65,7 @@ snappy:
 target_platform:
 - linux-64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
index 1677b03564c08..788b584504ec4 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_version11.2.yaml
@@ -1,9 +1,9 @@
 BUILD:
 - aarch64-conda_cos7-linux-gnu
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -37,20 +37,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -71,7 +69,7 @@ snappy:
 target_platform:
 - linux-aarch64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
index 88fdf1254e661..a1e4b8571abaf 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_aarch64_cuda_compiler_versionNone.yaml
@@ -1,9 +1,9 @@
 BUILD:
 - aarch64-conda_cos7-linux-gnu
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -37,20 +37,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -71,7 +69,7 @@ snappy:
 target_platform:
 - linux-aarch64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
index 3585db7b99baa..e21c4cbe853f8 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_version11.2.yaml
@@ -1,7 +1,7 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -33,20 +33,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -67,7 +65,7 @@ snappy:
 target_platform:
 - linux-ppc64le
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
index c13a522254286..89f1049ebdd84 100644
--- a/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/linux_ppc64le_cuda_compiler_versionNone.yaml
@@ -1,7 +1,7 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -33,20 +33,18 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -67,7 +65,7 @@ snappy:
 target_platform:
 - linux-ppc64le
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 ucx:
 - 1.14.0
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml b/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
index dd4a230760ef2..2a5f8c5b36bd3 100644
--- a/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/osx_64_.yaml
@@ -1,9 +1,9 @@
 MACOSX_DEPLOYMENT_TARGET:
-- '10.9'
+- '10.13'
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -27,22 +27,20 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 macos_machine:
 - x86_64-apple-darwin13.4.0
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -63,7 +61,7 @@ snappy:
 target_platform:
 - osx-64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml b/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
index 6a6713a54fe86..211b71226cae8 100644
--- a/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/osx_arm64_.yaml
@@ -1,9 +1,9 @@
 MACOSX_DEPLOYMENT_TARGET:
 - '11.0'
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
 c_compiler:
@@ -27,22 +27,20 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 macos_machine:
 - arm64-apple-darwin20.0.0
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -63,7 +61,7 @@ snappy:
 target_platform:
 - osx-arm64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 zip_keys:
 - - c_compiler_version
   - cxx_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.3.yaml
similarity index 98%
rename from dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml
rename to dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.3.yaml
index e63767cbe9771..a4d06c9f20cdd 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.1.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_64_r_base4.3.yaml
@@ -19,7 +19,7 @@ pin_run_as_build:
     min_pin: x.x
     max_pin: x.x
 r_base:
-- '4.1'
+- '4.3'
 target_platform:
 - linux-64
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.3.yaml
similarity index 98%
rename from dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml
rename to dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.3.yaml
index 2b80b020fdc0b..028b190bb1ef5 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.1.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/linux_aarch64_r_base4.3.yaml
@@ -23,7 +23,7 @@ pin_run_as_build:
     min_pin: x.x
     max_pin: x.x
 r_base:
-- '4.1'
+- '4.3'
 target_platform:
 - linux-aarch64
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.3.yaml
similarity index 98%
rename from dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml
rename to dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.3.yaml
index 6be6c2f5462c5..7b8b62d8e00bb 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.1.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_64_r_base4.3.yaml
@@ -19,7 +19,7 @@ pin_run_as_build:
     min_pin: x.x
     max_pin: x.x
 r_base:
-- '4.1'
+- '4.3'
 target_platform:
 - osx-64
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.3.yaml
similarity index 98%
rename from dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml
rename to dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.3.yaml
index 0ce856fcccf5c..a8e8aab83d598 100644
--- a/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.1.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/r/osx_arm64_r_base4.3.yaml
@@ -19,7 +19,7 @@ pin_run_as_build:
     min_pin: x.x
     max_pin: x.x
 r_base:
-- '4.1'
+- '4.3'
 target_platform:
 - osx-arm64
 zip_keys:
diff --git a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
index f75d92e276d9e..32da33c072019 100644
--- a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_version11.2.yaml
@@ -1,11 +1,9 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - vs2019
 channel_sources:
@@ -27,24 +25,22 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libcrc32c:
 - '1.1'
 libcurl:
 - '8'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -65,7 +61,7 @@ snappy:
 target_platform:
 - win-64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 zip_keys:
 - - cuda_compiler
   - cuda_compiler_version
diff --git a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
index 6d8fb15b15a2a..6a33b86b9d65e 100644
--- a/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
+++ b/dev/tasks/conda-recipes/.ci_support/win_64_cuda_compiler_versionNone.yaml
@@ -1,11 +1,9 @@
 aws_crt_cpp:
-- 0.20.3
+- 0.23.1
 aws_sdk_cpp:
-- 1.10.57
+- 1.11.156
 bzip2:
 - '1'
-c_ares:
-- '1'
 c_compiler:
 - vs2019
 channel_sources:
@@ -27,24 +25,22 @@ glog:
 google_cloud_cpp:
 - '2.12'
 libabseil:
-- '20230125'
+- '20230802'
 libcrc32c:
 - '1.1'
 libcurl:
 - '8'
 libgrpc:
-- '1.54'
-- '1.56'
+- '1.57'
 libprotobuf:
-- '3.21'
-- 4.23.3
+- 4.23.4
 lz4_c:
 - 1.9.3
 numpy:
-- '1.21'
+- '1.22'
 - '1.23'
-- '1.21'
-- '1.21'
+- '1.22'
+- '1.22'
 openssl:
 - '3'
 orc:
@@ -65,7 +61,7 @@ snappy:
 target_platform:
 - win-64
 thrift_cpp:
-- 0.18.1
+- 0.19.0
 zip_keys:
 - - cuda_compiler
   - cuda_compiler_version
diff --git a/dev/tasks/conda-recipes/arrow-cpp/activate.sh b/dev/tasks/conda-recipes/arrow-cpp/activate.sh
index 8757612781bbe..19d037ff4127a 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/activate.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/activate.sh
@@ -23,6 +23,13 @@ _la_log "Beginning libarrow activation."
 # where the GDB wrappers get installed
 _la_gdb_prefix="$CONDA_PREFIX/share/gdb/auto-load"
 
+# If the directory is not writable, nothing can be done
+if [ ! -w "$_la_gdb_prefix" ]; then
+    _la_log 'No rights to modify $_la_gdb_prefix, cannot create symlink!'
+    _la_log 'Unless you plan to use the GDB debugger with libarrow, this warning can be safely ignored.'
+    return
+fi
+
 # this needs to be in sync with ARROW_GDB_INSTALL_DIR in build.sh
 _la_placeholder="replace_this_section_with_absolute_slashed_path_to_CONDA_PREFIX"
 # the paths here are intentionally stacked, see #935, resp.
@@ -44,7 +51,7 @@ for _la_target in "$_la_orig_install_dir/"*.py; do
         # If the file doesn't exist, skip this iteration of the loop.
         # (This happens when no files are found, in which case the
         # loop runs with target equal to the pattern itself.)
-        _la_log 'Folder $_la_orig_install_dir seems to not contain .py files, skipping'
+        _la_log 'Folder $_la_orig_install_dir seems to not contain .py files, skipping.'
         continue
     fi
     _la_symlink="$_la_symlink_dir/$(basename "$_la_target")"
@@ -54,13 +61,13 @@ for _la_target in "$_la_orig_install_dir/"*.py; do
         _la_log 'symlink $_la_symlink already exists and points to $_la_target, skipping.'
         continue
     fi
-    _la_log 'Creating symlink $_la_symlink pointing to $_la_target'
+    _la_log 'Creating symlink $_la_symlink pointing to $_la_target.'
     mkdir -p "$_la_symlink_dir" || true
     # this check also creates the symlink; if it fails, we enter the if-branch.
     if ! ln -sf "$_la_target" "$_la_symlink"; then
-        echo -n "${BASH_SOURCE[0]} ERROR: Failed to create symlink from "
-        echo -n "'$_la_target' to '$_la_symlink'"
-        echo
+        echo -n "${BASH_SOURCE[0]} WARNING: Failed to create symlink from "
+        echo "'$_la_target' to '$_la_symlink'!"
+        echo "Unless you plan to use the GDB debugger with libarrow, this warning can be safely ignored."
         continue
     fi
 done
diff --git a/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
index dc588f9473870..ef0b038812a01 100755
--- a/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-arrow.sh
@@ -30,7 +30,7 @@ fi
 # Enable CUDA support
 if [[ ! -z "${cuda_compiler_version+x}" && "${cuda_compiler_version}" != "None" ]]
 then
-    EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=ON -DCUDA_TOOLKIT_ROOT_DIR=${CUDA_HOME} -DCMAKE_LIBRARY_PATH=${CONDA_BUILD_SYSROOT}/lib"
+    EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=ON -DCUDAToolkit_ROOT=${CUDA_HOME} -DCMAKE_LIBRARY_PATH=${CONDA_BUILD_SYSROOT}/lib"
 else
     EXTRA_CMAKE_ARGS=" ${EXTRA_CMAKE_ARGS} -DARROW_CUDA=OFF"
 fi
@@ -43,8 +43,8 @@ if [[ "${build_platform}" != "${target_platform}" ]]; then
     fi
     EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DCLANG_EXECUTABLE=${BUILD_PREFIX}/bin/${CONDA_TOOLCHAIN_HOST}-clang"
     EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DLLVM_LINK_EXECUTABLE=${BUILD_PREFIX}/bin/llvm-link"
+    EXTRA_CMAKE_ARGS="${EXTRA_CMAKE_ARGS} -DARROW_JEMALLOC_LG_PAGE=16"
     sed -ie "s;protoc-gen-grpc.*$;protoc-gen-grpc=${BUILD_PREFIX}/bin/grpc_cpp_plugin\";g" ../src/arrow/flight/CMakeLists.txt
-    sed -ie 's;"--with-jemalloc-prefix\=je_arrow_";"--with-jemalloc-prefix\=je_arrow_" "--with-lg-page\=16";g' ../cmake_modules/ThirdpartyToolchain.cmake
 fi
 
 # disable -fno-plt, which causes problems with GCC on PPC
diff --git a/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
index 9c12321a1c115..f39e06874ca0e 100755
--- a/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
+++ b/dev/tasks/conda-recipes/arrow-cpp/build-pyarrow.sh
@@ -24,6 +24,10 @@ BUILD_EXT_FLAGS=""
 # Enable CUDA support
 if [[ ! -z "${cuda_compiler_version+x}" && "${cuda_compiler_version}" != "None" ]]; then
     export PYARROW_WITH_CUDA=1
+    if [[ "${build_platform}" != "${target_platform}" ]]; then
+        export CUDAToolkit_ROOT=${CUDA_HOME}
+        export CMAKE_LIBRARY_PATH=${CONDA_BUILD_SYSROOT}/lib
+    fi
 else
     export PYARROW_WITH_CUDA=0
 fi
diff --git a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
index fbe40af3dae01..371b62245bb72 100644
--- a/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
+++ b/dev/tasks/conda-recipes/arrow-cpp/meta.yaml
@@ -61,7 +61,7 @@ outputs:
     build:
       string: h{{ PKG_HASH }}_{{ PKG_BUILDNUM }}_{{ build_ext }}
       run_exports:
-        - {{ pin_subpackage("libarrow", max_pin="x.x.x") }}
+        - {{ pin_subpackage("libarrow", max_pin="x") }}
       ignore_run_exports_from:
         - {{ compiler("cuda") }}                 # [cuda_compiler_version != "None"]
         # arrow only uses headers, apparently
@@ -114,6 +114,8 @@ outputs:
         - libgrpc
         - libprotobuf
         - libutf8proc
+        # gandiva requires shared libllvm
+        - llvm  # [unix]
         - lz4-c
         - nlohmann_json
         # gandiva depends on openssl
@@ -133,8 +135,6 @@ outputs:
         # its host deps (which aren't yet covered above) leak into the build here
         - libcrc32c  # [win]
         - libcurl    # [win]
-        # same for libgrpc (before 1.55.0, which is coupled with libprotobuf 4.23.x)
-        - c-ares     # [win and libprotobuf == "3.21"]
       run_constrained:
         - apache-arrow-proc =*={{ build_ext }}
         # make sure we don't co-install with old version of old package name
@@ -198,8 +198,6 @@ outputs:
     requirements:
       host:
         - {{ pin_subpackage('libarrow', exact=True) }}
-        # avoid wrappers for different builds colliding due to identical hashes
-        - libprotobuf
       run:
         - {{ pin_subpackage('libarrow', exact=True) }}
     test:
@@ -235,9 +233,7 @@ outputs:
         - cmake
         - ninja
       host:
-        # we're building for two protobuf versions, cannot pin exactly
-        # - {{ pin_subpackage('libarrow', exact=True) }}
-        - libarrow ={{ version }}=*_{{ PKG_BUILDNUM }}_{{ build_ext }}
+        - {{ pin_subpackage('libarrow', exact=True) }}
         - clangdev {{ llvm_version }}
         - llvmdev {{ llvm_version }}
         - cython <3
@@ -246,8 +242,7 @@ outputs:
         - setuptools
         - setuptools_scm <8.0.0
       run:
-        # - {{ pin_subpackage('libarrow', exact=True) }}
-        - libarrow ={{ version }}=*_{{ PKG_BUILDNUM }}_{{ build_ext }}
+        - {{ pin_subpackage('libarrow', exact=True) }}
         - {{ pin_compatible('numpy') }}
         - python
       run_constrained:
@@ -336,28 +331,28 @@ outputs:
 
     # crossbow CI: reduce to one python version, except on (unemulated) linux, where it's fast enough
     {% if linux64 or py == 311 %}
-    # {% if not (aarch64 or ppc64le) or py in (310, 311) %}
-    # only run the full test suite for one python version when in emulation (each run takes ~45min);
-    # there's essentially zero divergence in behaviour across python versions anyway, and otherwise
-    # CUDA builds for aarch/ppc consistently run out of disk space on azure for some reason
+    # {% if not (aarch64 or ppc64le) or py == 311 %}
+    # only run the full test suite for one python version when in emulation
+    # (each run can take up to ~45min); there's essentially zero divergence
+    # in behaviour across python versions anyway
     test:
       requires:
-        # vary protobuf version in test suite (historically, test failures only have a very
-        # weak dependency on python version, so we don't lose coverage by doing half & half)
-        - libprotobuf <4         # [py % 2 == 0]
         # test_cpp_extension_in_python requires a compiler
         - {{ compiler("cxx") }}  # [linux]
-        # temporary pin due to missing fixture
-        - pytest <7.4.0
+        - pytest
         - pytest-lazy-fixture
         - backports.zoneinfo     # [py<39]
+        - boto3
         - cffi
         - cloudpickle
         - cython <3
         - fastparquet
         - fsspec
         - hypothesis
+        # currently disabled due to GH-37692
+        # - minio-server
         - pandas
+        - s3fs >=2023
         - scipy
         # these are generally (far) behind on migrating abseil/grpc/protobuf,
         # and using them as test dependencies blocks the migrator unnecessarily
@@ -372,8 +367,8 @@ outputs:
       source_files:
         - testing/data
       commands:
-        - cd ${SP_DIR}/pyarrow/tests                        # [unix]
-        - cd %SP_DIR%\pyarrow\tests                         # [win]
+        - cd ${SP_DIR}                                      # [unix]
+        - cd %SP_DIR%                                       # [win]
         - export ARROW_TEST_DATA="${SRC_DIR}/testing/data"  # [unix]
         - set "ARROW_TEST_DATA=%SRC_DIR%\testing\data"      # [win]
 
@@ -382,34 +377,26 @@ outputs:
         {% set tests_to_skip = tests_to_skip + " or test_cuda" %}
         # skip tests that raise SIGINT and crash the test suite
         {% set tests_to_skip = tests_to_skip + " or (test_csv and test_cancellation)" %}  # [linux]
-        {% set tests_to_skip = tests_to_skip + " or (test_flight and test_interrupt)" %}  # [linux]
-        # tests that may crash the agent due to out-of-bound memory writes or other risky stuff
-        {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool" %}            # [aarch64 or ppc64le]
-        # cannot pass -D_LIBCPP_DISABLE_AVAILABILITY to test suite for our older macos sdk
-        {% set tests_to_skip = tests_to_skip + " or test_cpp_extension_in_python" %}      # [osx]
+        # skip test that intentionally writes out of bounds and then expects no error message
+        {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool_disabled[system_memory_pool]" %}  # [osx]
         # skip tests that make invalid(-for-conda) assumptions about the compilers setup
         {% set tests_to_skip = tests_to_skip + " or test_cython_api" %}                   # [unix]
         {% set tests_to_skip = tests_to_skip + " or test_visit_strings" %}                # [unix]
         # skip tests that cannot succeed in emulation
         {% set tests_to_skip = tests_to_skip + " or test_debug_memory_pool_disabled" %}   # [aarch64 or ppc64le]
         {% set tests_to_skip = tests_to_skip + " or test_env_var_io_thread_count" %}      # [aarch64 or ppc64le]
+        # XMinioInvalidObjectName on osx/win: "Object name contains unsupported characters"
+        {% set tests_to_skip = tests_to_skip + " or test_write_to_dataset_with_partitions_s3fs" %}  # [osx or win]
         # vvvvvvv TESTS THAT SHOULDN'T HAVE TO BE SKIPPED vvvvvvv
-        {% set tests_to_skip = tests_to_skip + " or test_extension_to_pandas_storage_type" %}
-        # segfaults on OSX: to investigate ASAP
-        {% set tests_to_skip = tests_to_skip + " or test_flight" %}                       # [osx]
+        # currently broken
+        {% set tests_to_skip = tests_to_skip + " or test_fastparquet_cross_compatibility" %}
         # gandiva tests are segfaulting on ppc
-        {% set tests_to_skip = tests_to_skip + " or test_gandiva" %}                      # [ppc64le]
-        # test failures on ppc
+        {% set tests_to_skip = tests_to_skip + " or test_gandiva" %}                                # [ppc64le]
+        # test failures on ppc (both failing with: Float value was truncated converting to int32)
         {% set tests_to_skip = tests_to_skip + " or test_safe_cast_from_float_with_nans_to_int" %}  # [ppc64le]
-        # gandiva tests are segfaulting on ppc
-        {% set tests_to_skip = tests_to_skip + " or test_float_with_null_as_integer" %}   # [ppc64le]
-        # test is broken; header is in $PREFIX, not $SP_DIR
-        {% set tests_to_skip = tests_to_skip + " or (test_misc and test_get_include)" %}  # [unix]
-        # flaky tests that fail occasionally
-        {% set tests_to_skip = tests_to_skip + " or test_total_bytes_allocated " %}       # [linux]
-        {% set tests_to_skip = tests_to_skip + " or test_feather_format " %}              # [linux]
+        {% set tests_to_skip = tests_to_skip + " or test_float_with_null_as_integer" %}             # [ppc64le]
         # ^^^^^^^ TESTS THAT SHOULDN'T HAVE TO BE SKIPPED ^^^^^^^
-        - pytest -rfEs -k "not ({{ tests_to_skip }})"
+        - pytest pyarrow/ -rfEs -k "not ({{ tests_to_skip }})"
     {% endif %}
 
     about:
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 29e038a922412..859ff8ddb5b44 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -246,15 +246,15 @@ tasks:
   #   generated and to be synced regularly from the feedstock. We have no way
   #   yet to generate them inside the arrow repository automatically.
 
-  conda-linux-x64-cpu-r41:
+  conda-linux-x64-cpu-r43:
     ci: azure
     template: conda-recipes/azure.linux.yml
     params:
       config: linux_64_cuda_compiler_versionNone
-      r_config: linux_64_r_base4.1
+      r_config: linux_64_r_base4.3
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
-      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+      - r-arrow-{no_rc_version}-r43(h[a-z0-9]+)_0.conda
 
   conda-linux-x64-cpu-r42:
     ci: azure
@@ -292,15 +292,15 @@ tasks:
 
   ########################### Conda Linux (aarch64) ###########################
 
-  conda-linux-aarch64-cpu-r41:
+  conda-linux-aarch64-cpu-r43:
     ci: azure
     template: conda-recipes/azure.linux.yml
     params:
       config: linux_aarch64_cuda_compiler_versionNone
-      r_config: linux_aarch64_r_base4.1
+      r_config: linux_aarch64_r_base4.3
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
-      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+      - r-arrow-{no_rc_version}-r43(h[a-z0-9]+)_0.conda
 
   conda-linux-aarch64-cpu-r42:
     ci: azure
@@ -364,15 +364,15 @@ tasks:
 
   ############################## Conda OSX (x64) ##############################
 
-  conda-osx-x64-cpu-r41:
+  conda-osx-x64-cpu-r43:
     ci: azure
     template: conda-recipes/azure.osx.yml
     params:
       config: osx_64_
-      r_config: osx_64_r_base4.1
+      r_config: osx_64_r_base4.3
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
-      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+      - r-arrow-{no_rc_version}-r43(h[a-z0-9]+)_0.conda
 
   conda-osx-x64-cpu-r42:
     ci: azure
@@ -398,15 +398,15 @@ tasks:
 
   ############################# Conda OSX (arm64) #############################
 
-  conda-osx-arm64-cpu-r41:
+  conda-osx-arm64-cpu-r43:
     ci: azure
     template: conda-recipes/azure.osx.yml
     params:
       config: osx_arm64_
-      r_config: osx_arm64_r_base4.1
+      r_config: osx_arm64_r_base4.3
     artifacts:
       - libarrow-{no_rc_version}-(h[a-z0-9]+)_0_cpu.conda
-      - r-arrow-{no_rc_version}-r41(h[a-z0-9]+)_0.conda
+      - r-arrow-{no_rc_version}-r43(h[a-z0-9]+)_0.conda
 
   conda-osx-arm64-cpu-r42:
     ci: azure

From 284dddd129fae072ec3e7ae269520b54c8decdb4 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 28 Sep 2023 06:22:26 -0700
Subject: [PATCH 422/749] GH-37863: [Java] Add typed getters for StructVector
 (#37916)

### Rationale for this change
Add methods for getting child vectors as specific vector subtypes
for convenience.

### What changes are included in this PR?
Add child getters which let the caller specify the target vector type to StructVector.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #37863

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../vector/complex/NonNullableStructVector.java      | 12 ++++++++++++
 .../org/apache/arrow/vector/TestStructVector.java    |  8 ++++++++
 2 files changed, 20 insertions(+)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
index 4da2668121af6..7d724656cdab7 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
@@ -374,6 +374,18 @@ public ValueVector getVectorById(int id) {
     return getChildByOrdinal(id);
   }
 
+  /**
+   * Gets a child vector by ordinal position and casts to the specified class.
+   */
+  public <V extends ValueVector> V getVectorById(int id, Class<V> clazz) {
+    ValueVector untyped = getVectorById(id);
+    if (clazz.isInstance(untyped)) {
+      return clazz.cast(untyped);
+    }
+    throw new ClassCastException("Id " + id + " had the wrong type. Expected " + clazz.getCanonicalName() +
+        " but was " + untyped.getClass().getCanonicalName());
+  }
+
   @Override
   public void setValueCount(int valueCount) {
     for (final ValueVector v : getChildren()) {
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
index b4c30480000c8..552d5752f236f 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
@@ -282,4 +282,12 @@ public void testAddChildVectorsWithDuplicatedFieldNamesForConflictPolicyReplace(
     }
   }
 
+  @Test
+  public void testTypedGetters() {
+    try (final StructVector s1 = StructVector.empty("s1", allocator)) {
+      s1.addOrGet("struct_child", FieldType.nullable(MinorType.INT.getType()), IntVector.class);
+      assertEquals(IntVector.class, s1.getChild("struct_child", IntVector.class).getClass());
+      assertEquals(IntVector.class, s1.getVectorById(0, IntVector.class).getClass());
+    }
+  }
 }

From 26667340f2e72c84107c9be28e68aa88dcb064ff Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Thu, 28 Sep 2023 06:22:45 -0700
Subject: [PATCH 423/749] GH-37864: [Java] Remove unnecessary throws from
 OrcReader (#37913)

### Rationale for this change
Make OrcReader more friendly to use with try-with-resources blocks and AutoCloseables by
removing an unnecessary throws modifier on close().

### What changes are included in this PR?
Removes an unused throws specifier on OrcReader#close().

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #37864

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../src/main/java/org/apache/arrow/adapter/orc/OrcReader.java   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/adapter/orc/src/main/java/org/apache/arrow/adapter/orc/OrcReader.java b/java/adapter/orc/src/main/java/org/apache/arrow/adapter/orc/OrcReader.java
index b42ddb48433b5..648e17e9c374c 100644
--- a/java/adapter/orc/src/main/java/org/apache/arrow/adapter/orc/OrcReader.java
+++ b/java/adapter/orc/src/main/java/org/apache/arrow/adapter/orc/OrcReader.java
@@ -84,7 +84,7 @@ public int getNumberOfStripes() throws IllegalArgumentException {
   }
 
   @Override
-  public void close() throws Exception {
+  public void close() {
     jniWrapper.close(nativeInstanceId);
   }
 }

From 019d06df56ba3215148465554948a4d93fd9c707 Mon Sep 17 00:00:00 2001
From: Laurent Goujon <laurentgo@users.noreply.github.com>
Date: Thu, 28 Sep 2023 07:50:51 -0700
Subject: [PATCH 424/749] GH-37893: [Java] Move Types.proto in a subfolder
 (#37894)

### Rationale for this change

Types.proto is a Gandiva protobuf definition used by Gandiva to exchange data between Java and C++. This file is packaged automatically within arrow-gandiva jar but because of its generic name, it may cause conflicts in others' people project.

### What changes are included in this PR?

Move `Types.proto` into `gandiva/types.proto` (also matching convention of using lowercase filename) so that it become less likely to cause a conflict.

### Are these changes tested?

Change should have no impact on the feature itself. Manually check the resulting jar to confirm that `types.proto` is not located at the root of the archive.

### Are there any user-facing changes?

No user-facing. Developers who were actually referencing Gandiva `Types.proto` in their project may have to change their `import` directive.

**This PR includes breaking changes to public APIs.**

* Closes: #37893

Authored-by: Laurent Goujon <laurent@apache.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/gandiva/CMakeLists.txt                   |  10 +-
 .../{Types.proto => gandiva/types.proto}      |   4 +-
 .../main/cpp/expression_registry_helper.cc    |  87 +++++-----
 java/gandiva/src/main/cpp/jni_common.cc       | 152 +++++++++---------
 4 files changed, 126 insertions(+), 127 deletions(-)
 rename java/gandiva/proto/{Types.proto => gandiva/types.proto} (99%)

diff --git a/java/gandiva/CMakeLists.txt b/java/gandiva/CMakeLists.txt
index 629ab2fb347d8..2aa8d92959e42 100644
--- a/java/gandiva/CMakeLists.txt
+++ b/java/gandiva/CMakeLists.txt
@@ -29,21 +29,21 @@ add_jar(arrow_java_jni_gandiva_jar
         arrow_java_jni_gandiva_headers)
 
 set(GANDIVA_PROTO_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
-set(GANDIVA_PROTO_OUTPUT_FILES "${GANDIVA_PROTO_OUTPUT_DIR}/Types.pb.cc"
-                               "${GANDIVA_PROTO_OUTPUT_DIR}/Types.pb.h")
+set(GANDIVA_PROTO_OUTPUT_FILES "${GANDIVA_PROTO_OUTPUT_DIR}/gandiva/types.pb.cc"
+                               "${GANDIVA_PROTO_OUTPUT_DIR}/gandiva/types.pb.h")
 
 set_source_files_properties(${GANDIVA_PROTO_OUTPUT_FILES} PROPERTIES GENERATED TRUE)
 
 set(GANDIVA_PROTO_DIR ${CMAKE_CURRENT_SOURCE_DIR}/proto)
-get_filename_component(GANDIVA_PROTO_FILE_ABSOLUTE ${GANDIVA_PROTO_DIR}/Types.proto
-                       ABSOLUTE)
+get_filename_component(GANDIVA_PROTO_FILE_ABSOLUTE
+                       ${GANDIVA_PROTO_DIR}/gandiva/types.proto ABSOLUTE)
 
 find_package(Protobuf REQUIRED)
 add_custom_command(OUTPUT ${GANDIVA_PROTO_OUTPUT_FILES}
                    COMMAND protobuf::protoc --proto_path ${GANDIVA_PROTO_DIR} --cpp_out
                            ${GANDIVA_PROTO_OUTPUT_DIR} ${GANDIVA_PROTO_FILE_ABSOLUTE}
                    DEPENDS ${GANDIVA_PROTO_FILE_ABSOLUTE}
-                   COMMENT "Running Protobuf compiler on Types.proto"
+                   COMMENT "Running Protobuf compiler on gandiva/types.proto"
                    VERBATIM)
 
 add_custom_target(garrow_java_jni_gandiva_proto ALL DEPENDS ${GANDIVA_PROTO_OUTPUT_FILES})
diff --git a/java/gandiva/proto/Types.proto b/java/gandiva/proto/gandiva/types.proto
similarity index 99%
rename from java/gandiva/proto/Types.proto
rename to java/gandiva/proto/gandiva/types.proto
index eb0d996b92e63..4ce342681d614 100644
--- a/java/gandiva/proto/Types.proto
+++ b/java/gandiva/proto/gandiva/types.proto
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-syntax = "proto2";
-package types;
+syntax = "proto3";
+package gandiva.types;
 
 option java_package = "org.apache.arrow.gandiva.ipc";
 option java_outer_classname = "GandivaTypes";
diff --git a/java/gandiva/src/main/cpp/expression_registry_helper.cc b/java/gandiva/src/main/cpp/expression_registry_helper.cc
index 6765df3b9727f..66b97c8b9ef44 100644
--- a/java/gandiva/src/main/cpp/expression_registry_helper.cc
+++ b/java/gandiva/src/main/cpp/expression_registry_helper.cc
@@ -20,121 +20,120 @@
 #include <arrow/util/logging.h>
 #include <gandiva/arrow.h>
 #include <gandiva/expression_registry.h>
-
-#include "Types.pb.h"
-#include "org_apache_arrow_gandiva_evaluator_ExpressionRegistryJniHelper.h"
+#include <gandiva/types.pb.h>
+#include <org_apache_arrow_gandiva_evaluator_ExpressionRegistryJniHelper.h>
 
 using gandiva::DataTypePtr;
 using gandiva::ExpressionRegistry;
 
-types::TimeUnit MapTimeUnit(arrow::TimeUnit::type& unit) {
+gandiva::types::TimeUnit MapTimeUnit(arrow::TimeUnit::type& unit) {
   switch (unit) {
     case arrow::TimeUnit::MILLI:
-      return types::TimeUnit::MILLISEC;
+      return gandiva::types::TimeUnit::MILLISEC;
     case arrow::TimeUnit::SECOND:
-      return types::TimeUnit::SEC;
+      return gandiva::types::TimeUnit::SEC;
     case arrow::TimeUnit::MICRO:
-      return types::TimeUnit::MICROSEC;
+      return gandiva::types::TimeUnit::MICROSEC;
     case arrow::TimeUnit::NANO:
-      return types::TimeUnit::NANOSEC;
+      return gandiva::types::TimeUnit::NANOSEC;
   }
   // satisfy gcc. should be unreachable.
-  return types::TimeUnit::SEC;
+  return gandiva::types::TimeUnit::SEC;
 }
 
-void ArrowToProtobuf(DataTypePtr type, types::ExtGandivaType* gandiva_data_type) {
+void ArrowToProtobuf(DataTypePtr type, gandiva::types::ExtGandivaType* gandiva_data_type) {
   switch (type->id()) {
     case arrow::Type::BOOL:
-      gandiva_data_type->set_type(types::GandivaType::BOOL);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::BOOL);
       break;
     case arrow::Type::UINT8:
-      gandiva_data_type->set_type(types::GandivaType::UINT8);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::UINT8);
       break;
     case arrow::Type::INT8:
-      gandiva_data_type->set_type(types::GandivaType::INT8);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INT8);
       break;
     case arrow::Type::UINT16:
-      gandiva_data_type->set_type(types::GandivaType::UINT16);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::UINT16);
       break;
     case arrow::Type::INT16:
-      gandiva_data_type->set_type(types::GandivaType::INT16);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INT16);
       break;
     case arrow::Type::UINT32:
-      gandiva_data_type->set_type(types::GandivaType::UINT32);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::UINT32);
       break;
     case arrow::Type::INT32:
-      gandiva_data_type->set_type(types::GandivaType::INT32);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INT32);
       break;
     case arrow::Type::UINT64:
-      gandiva_data_type->set_type(types::GandivaType::UINT64);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::UINT64);
       break;
     case arrow::Type::INT64:
-      gandiva_data_type->set_type(types::GandivaType::INT64);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INT64);
       break;
     case arrow::Type::HALF_FLOAT:
-      gandiva_data_type->set_type(types::GandivaType::HALF_FLOAT);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::HALF_FLOAT);
       break;
     case arrow::Type::FLOAT:
-      gandiva_data_type->set_type(types::GandivaType::FLOAT);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::FLOAT);
       break;
     case arrow::Type::DOUBLE:
-      gandiva_data_type->set_type(types::GandivaType::DOUBLE);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::DOUBLE);
       break;
     case arrow::Type::STRING:
-      gandiva_data_type->set_type(types::GandivaType::UTF8);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::UTF8);
       break;
     case arrow::Type::BINARY:
-      gandiva_data_type->set_type(types::GandivaType::BINARY);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::BINARY);
       break;
     case arrow::Type::DATE32:
-      gandiva_data_type->set_type(types::GandivaType::DATE32);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::DATE32);
       break;
     case arrow::Type::DATE64:
-      gandiva_data_type->set_type(types::GandivaType::DATE64);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::DATE64);
       break;
     case arrow::Type::TIMESTAMP: {
-      gandiva_data_type->set_type(types::GandivaType::TIMESTAMP);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::TIMESTAMP);
       std::shared_ptr<arrow::TimestampType> cast_time_stamp_type =
           std::dynamic_pointer_cast<arrow::TimestampType>(type);
       arrow::TimeUnit::type unit = cast_time_stamp_type->unit();
-      types::TimeUnit time_unit = MapTimeUnit(unit);
+      gandiva::types::TimeUnit time_unit = MapTimeUnit(unit);
       gandiva_data_type->set_timeunit(time_unit);
       break;
     }
     case arrow::Type::TIME32: {
-      gandiva_data_type->set_type(types::GandivaType::TIME32);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::TIME32);
       std::shared_ptr<arrow::Time32Type> cast_time_32_type =
           std::dynamic_pointer_cast<arrow::Time32Type>(type);
       arrow::TimeUnit::type unit = cast_time_32_type->unit();
-      types::TimeUnit time_unit = MapTimeUnit(unit);
+      gandiva::types::TimeUnit time_unit = MapTimeUnit(unit);
       gandiva_data_type->set_timeunit(time_unit);
       break;
     }
     case arrow::Type::TIME64: {
-      gandiva_data_type->set_type(types::GandivaType::TIME32);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::TIME32);
       std::shared_ptr<arrow::Time64Type> cast_time_64_type =
           std::dynamic_pointer_cast<arrow::Time64Type>(type);
       arrow::TimeUnit::type unit = cast_time_64_type->unit();
-      types::TimeUnit time_unit = MapTimeUnit(unit);
+      gandiva::types::TimeUnit time_unit = MapTimeUnit(unit);
       gandiva_data_type->set_timeunit(time_unit);
       break;
     }
     case arrow::Type::NA:
-      gandiva_data_type->set_type(types::GandivaType::NONE);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::NONE);
       break;
     case arrow::Type::DECIMAL: {
-      gandiva_data_type->set_type(types::GandivaType::DECIMAL);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::DECIMAL);
       gandiva_data_type->set_precision(0);
       gandiva_data_type->set_scale(0);
       break;
     }
     case arrow::Type::INTERVAL_MONTHS:
-      gandiva_data_type->set_type(types::GandivaType::INTERVAL);
-      gandiva_data_type->set_intervaltype(types::IntervalType::YEAR_MONTH);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INTERVAL);
+      gandiva_data_type->set_intervaltype(gandiva::types::IntervalType::YEAR_MONTH);
       break;
     case arrow::Type::INTERVAL_DAY_TIME:
-      gandiva_data_type->set_type(types::GandivaType::INTERVAL);
-      gandiva_data_type->set_intervaltype(types::IntervalType::DAY_TIME);
+      gandiva_data_type->set_type(gandiva::types::GandivaType::INTERVAL);
+      gandiva_data_type->set_intervaltype(gandiva::types::IntervalType::DAY_TIME);
       break;
     default:
       // un-supported types. test ensures that
@@ -146,10 +145,10 @@ void ArrowToProtobuf(DataTypePtr type, types::ExtGandivaType* gandiva_data_type)
 JNIEXPORT jbyteArray JNICALL
 Java_org_apache_arrow_gandiva_evaluator_ExpressionRegistryJniHelper_getGandivaSupportedDataTypes(  // NOLINT
     JNIEnv* env, jobject types_helper) {
-  types::GandivaDataTypes gandiva_data_types;
+  gandiva::types::GandivaDataTypes gandiva_data_types;
   auto supported_types = ExpressionRegistry::supported_types();
   for (auto const& type : supported_types) {
-    types::ExtGandivaType* gandiva_data_type = gandiva_data_types.add_datatype();
+    gandiva::types::ExtGandivaType* gandiva_data_type = gandiva_data_types.add_datatype();
     ArrowToProtobuf(type, gandiva_data_type);
   }
   auto size = static_cast<int>(gandiva_data_types.ByteSizeLong());
@@ -169,15 +168,15 @@ JNIEXPORT jbyteArray JNICALL
 Java_org_apache_arrow_gandiva_evaluator_ExpressionRegistryJniHelper_getGandivaSupportedFunctions(  // NOLINT
     JNIEnv* env, jobject types_helper) {
   ExpressionRegistry expr_registry;
-  types::GandivaFunctions gandiva_functions;
+  gandiva::types::GandivaFunctions gandiva_functions;
   for (auto function = expr_registry.function_signature_begin();
        function != expr_registry.function_signature_end(); function++) {
-    types::FunctionSignature* function_signature = gandiva_functions.add_function();
+    gandiva::types::FunctionSignature* function_signature = gandiva_functions.add_function();
     function_signature->set_name((*function).base_name());
-    types::ExtGandivaType* return_type = function_signature->mutable_returntype();
+    gandiva::types::ExtGandivaType* return_type = function_signature->mutable_returntype();
     ArrowToProtobuf((*function).ret_type(), return_type);
     for (auto& param_type : (*function).param_types()) {
-      types::ExtGandivaType* proto_param_type = function_signature->add_paramtypes();
+      gandiva::types::ExtGandivaType* proto_param_type = function_signature->add_paramtypes();
       ArrowToProtobuf(param_type, proto_param_type);
     }
   }
diff --git a/java/gandiva/src/main/cpp/jni_common.cc b/java/gandiva/src/main/cpp/jni_common.cc
index 43db266ff56f5..a5dff9981ce89 100644
--- a/java/gandiva/src/main/cpp/jni_common.cc
+++ b/java/gandiva/src/main/cpp/jni_common.cc
@@ -35,13 +35,13 @@
 #include <gandiva/projector.h>
 #include <gandiva/selection_vector.h>
 #include <gandiva/tree_expr_builder.h>
+#include <gandiva/types.pb.h>
+#include <org_apache_arrow_gandiva_evaluator_JniWrapper.h>
 
-#include "Types.pb.h"
 #include "config_holder.h"
 #include "env_helper.h"
 #include "id_to_module_map.h"
 #include "module_holder.h"
-#include "org_apache_arrow_gandiva_evaluator_JniWrapper.h"
 
 using gandiva::ConditionPtr;
 using gandiva::DataTypePtr;
@@ -65,7 +65,7 @@ using gandiva::FilterHolder;
 using gandiva::ProjectorHolder;
 
 // forward declarations
-NodePtr ProtoTypeToNode(const types::TreeNode& node);
+NodePtr ProtoTypeToNode(const gandiva::types::TreeNode& node);
 
 static jint JNI_VERSION = JNI_VERSION_1_6;
 
@@ -131,11 +131,11 @@ void JNI_OnUnload(JavaVM* vm, void* reserved) {
   env->DeleteGlobalRef(vector_expander_ret_class_);
 }
 
-DataTypePtr ProtoTypeToTime32(const types::ExtGandivaType& ext_type) {
+DataTypePtr ProtoTypeToTime32(const gandiva::types::ExtGandivaType& ext_type) {
   switch (ext_type.timeunit()) {
-    case types::SEC:
+    case gandiva::types::SEC:
       return arrow::time32(arrow::TimeUnit::SECOND);
-    case types::MILLISEC:
+    case gandiva::types::MILLISEC:
       return arrow::time32(arrow::TimeUnit::MILLI);
     default:
       std::cerr << "Unknown time unit: " << ext_type.timeunit() << " for time32\n";
@@ -143,11 +143,11 @@ DataTypePtr ProtoTypeToTime32(const types::ExtGandivaType& ext_type) {
   }
 }
 
-DataTypePtr ProtoTypeToTime64(const types::ExtGandivaType& ext_type) {
+DataTypePtr ProtoTypeToTime64(const gandiva::types::ExtGandivaType& ext_type) {
   switch (ext_type.timeunit()) {
-    case types::MICROSEC:
+    case gandiva::types::MICROSEC:
       return arrow::time64(arrow::TimeUnit::MICRO);
-    case types::NANOSEC:
+    case gandiva::types::NANOSEC:
       return arrow::time64(arrow::TimeUnit::NANO);
     default:
       std::cerr << "Unknown time unit: " << ext_type.timeunit() << " for time64\n";
@@ -155,15 +155,15 @@ DataTypePtr ProtoTypeToTime64(const types::ExtGandivaType& ext_type) {
   }
 }
 
-DataTypePtr ProtoTypeToTimestamp(const types::ExtGandivaType& ext_type) {
+DataTypePtr ProtoTypeToTimestamp(const gandiva::types::ExtGandivaType& ext_type) {
   switch (ext_type.timeunit()) {
-    case types::SEC:
+    case gandiva::types::SEC:
       return arrow::timestamp(arrow::TimeUnit::SECOND);
-    case types::MILLISEC:
+    case gandiva::types::MILLISEC:
       return arrow::timestamp(arrow::TimeUnit::MILLI);
-    case types::MICROSEC:
+    case gandiva::types::MICROSEC:
       return arrow::timestamp(arrow::TimeUnit::MICRO);
-    case types::NANOSEC:
+    case gandiva::types::NANOSEC:
       return arrow::timestamp(arrow::TimeUnit::NANO);
     default:
       std::cerr << "Unknown time unit: " << ext_type.timeunit() << " for timestamp\n";
@@ -171,11 +171,11 @@ DataTypePtr ProtoTypeToTimestamp(const types::ExtGandivaType& ext_type) {
   }
 }
 
-DataTypePtr ProtoTypeToInterval(const types::ExtGandivaType& ext_type) {
+DataTypePtr ProtoTypeToInterval(const gandiva::types::ExtGandivaType& ext_type) {
   switch (ext_type.intervaltype()) {
-    case types::YEAR_MONTH:
+    case gandiva::types::YEAR_MONTH:
       return arrow::month_interval();
-    case types::DAY_TIME:
+    case gandiva::types::DAY_TIME:
       return arrow::day_time_interval();
     default:
       std::cerr << "Unknown interval type: " << ext_type.intervaltype() << "\n";
@@ -183,59 +183,59 @@ DataTypePtr ProtoTypeToInterval(const types::ExtGandivaType& ext_type) {
   }
 }
 
-DataTypePtr ProtoTypeToDataType(const types::ExtGandivaType& ext_type) {
+DataTypePtr ProtoTypeToDataType(const gandiva::types::ExtGandivaType& ext_type) {
   switch (ext_type.type()) {
-    case types::NONE:
+    case gandiva::types::NONE:
       return arrow::null();
-    case types::BOOL:
+    case gandiva::types::BOOL:
       return arrow::boolean();
-    case types::UINT8:
+    case gandiva::types::UINT8:
       return arrow::uint8();
-    case types::INT8:
+    case gandiva::types::INT8:
       return arrow::int8();
-    case types::UINT16:
+    case gandiva::types::UINT16:
       return arrow::uint16();
-    case types::INT16:
+    case gandiva::types::INT16:
       return arrow::int16();
-    case types::UINT32:
+    case gandiva::types::UINT32:
       return arrow::uint32();
-    case types::INT32:
+    case gandiva::types::INT32:
       return arrow::int32();
-    case types::UINT64:
+    case gandiva::types::UINT64:
       return arrow::uint64();
-    case types::INT64:
+    case gandiva::types::INT64:
       return arrow::int64();
-    case types::HALF_FLOAT:
+    case gandiva::types::HALF_FLOAT:
       return arrow::float16();
-    case types::FLOAT:
+    case gandiva::types::FLOAT:
       return arrow::float32();
-    case types::DOUBLE:
+    case gandiva::types::DOUBLE:
       return arrow::float64();
-    case types::UTF8:
+    case gandiva::types::UTF8:
       return arrow::utf8();
-    case types::BINARY:
+    case gandiva::types::BINARY:
       return arrow::binary();
-    case types::DATE32:
+    case gandiva::types::DATE32:
       return arrow::date32();
-    case types::DATE64:
+    case gandiva::types::DATE64:
       return arrow::date64();
-    case types::DECIMAL:
+    case gandiva::types::DECIMAL:
       // TODO: error handling
       return arrow::decimal(ext_type.precision(), ext_type.scale());
-    case types::TIME32:
+    case gandiva::types::TIME32:
       return ProtoTypeToTime32(ext_type);
-    case types::TIME64:
+    case gandiva::types::TIME64:
       return ProtoTypeToTime64(ext_type);
-    case types::TIMESTAMP:
+    case gandiva::types::TIMESTAMP:
       return ProtoTypeToTimestamp(ext_type);
-    case types::INTERVAL:
+    case gandiva::types::INTERVAL:
       return ProtoTypeToInterval(ext_type);
-    case types::FIXED_SIZE_BINARY:
-    case types::LIST:
-    case types::STRUCT:
-    case types::UNION:
-    case types::DICTIONARY:
-    case types::MAP:
+    case gandiva::types::FIXED_SIZE_BINARY:
+    case gandiva::types::LIST:
+    case gandiva::types::STRUCT:
+    case gandiva::types::UNION:
+    case gandiva::types::DICTIONARY:
+    case gandiva::types::MAP:
       std::cerr << "Unhandled data type: " << ext_type.type() << "\n";
       return nullptr;
 
@@ -245,7 +245,7 @@ DataTypePtr ProtoTypeToDataType(const types::ExtGandivaType& ext_type) {
   }
 }
 
-FieldPtr ProtoTypeToField(const types::Field& f) {
+FieldPtr ProtoTypeToField(const gandiva::types::Field& f) {
   const std::string& name = f.name();
   DataTypePtr type = ProtoTypeToDataType(f.type());
   bool nullable = true;
@@ -256,7 +256,7 @@ FieldPtr ProtoTypeToField(const types::Field& f) {
   return field(name, type, nullable);
 }
 
-NodePtr ProtoTypeToFieldNode(const types::FieldNode& node) {
+NodePtr ProtoTypeToFieldNode(const gandiva::types::FieldNode& node) {
   FieldPtr field_ptr = ProtoTypeToField(node.field());
   if (field_ptr == nullptr) {
     std::cerr << "Unable to create field node from protobuf\n";
@@ -266,12 +266,12 @@ NodePtr ProtoTypeToFieldNode(const types::FieldNode& node) {
   return TreeExprBuilder::MakeField(field_ptr);
 }
 
-NodePtr ProtoTypeToFnNode(const types::FunctionNode& node) {
+NodePtr ProtoTypeToFnNode(const gandiva::types::FunctionNode& node) {
   const std::string& name = node.functionname();
   NodeVector children;
 
   for (int i = 0; i < node.inargs_size(); i++) {
-    const types::TreeNode& arg = node.inargs(i);
+    const gandiva::types::TreeNode& arg = node.inargs(i);
 
     NodePtr n = ProtoTypeToNode(arg);
     if (n == nullptr) {
@@ -291,7 +291,7 @@ NodePtr ProtoTypeToFnNode(const types::FunctionNode& node) {
   return TreeExprBuilder::MakeFunction(name, children, return_type);
 }
 
-NodePtr ProtoTypeToIfNode(const types::IfNode& node) {
+NodePtr ProtoTypeToIfNode(const gandiva::types::IfNode& node) {
   NodePtr cond = ProtoTypeToNode(node.cond());
   if (cond == nullptr) {
     std::cerr << "Unable to create cond node for if node\n";
@@ -319,11 +319,11 @@ NodePtr ProtoTypeToIfNode(const types::IfNode& node) {
   return TreeExprBuilder::MakeIf(cond, then_node, else_node, return_type);
 }
 
-NodePtr ProtoTypeToAndNode(const types::AndNode& node) {
+NodePtr ProtoTypeToAndNode(const gandiva::types::AndNode& node) {
   NodeVector children;
 
   for (int i = 0; i < node.args_size(); i++) {
-    const types::TreeNode& arg = node.args(i);
+    const gandiva::types::TreeNode& arg = node.args(i);
 
     NodePtr n = ProtoTypeToNode(arg);
     if (n == nullptr) {
@@ -335,11 +335,11 @@ NodePtr ProtoTypeToAndNode(const types::AndNode& node) {
   return TreeExprBuilder::MakeAnd(children);
 }
 
-NodePtr ProtoTypeToOrNode(const types::OrNode& node) {
+NodePtr ProtoTypeToOrNode(const gandiva::types::OrNode& node) {
   NodeVector children;
 
   for (int i = 0; i < node.args_size(); i++) {
-    const types::TreeNode& arg = node.args(i);
+    const gandiva::types::TreeNode& arg = node.args(i);
 
     NodePtr n = ProtoTypeToNode(arg);
     if (n == nullptr) {
@@ -351,7 +351,7 @@ NodePtr ProtoTypeToOrNode(const types::OrNode& node) {
   return TreeExprBuilder::MakeOr(children);
 }
 
-NodePtr ProtoTypeToInNode(const types::InNode& node) {
+NodePtr ProtoTypeToInNode(const gandiva::types::InNode& node) {
   NodePtr field = ProtoTypeToNode(node.node());
 
   if (node.has_intvalues()) {
@@ -417,7 +417,7 @@ NodePtr ProtoTypeToInNode(const types::InNode& node) {
   return nullptr;
 }
 
-NodePtr ProtoTypeToNullNode(const types::NullNode& node) {
+NodePtr ProtoTypeToNullNode(const gandiva::types::NullNode& node) {
   DataTypePtr data_type = ProtoTypeToDataType(node.type());
   if (data_type == nullptr) {
     std::cerr << "Unknown type " << data_type->ToString() << " for null node\n";
@@ -427,7 +427,7 @@ NodePtr ProtoTypeToNullNode(const types::NullNode& node) {
   return TreeExprBuilder::MakeNull(data_type);
 }
 
-NodePtr ProtoTypeToNode(const types::TreeNode& node) {
+NodePtr ProtoTypeToNode(const gandiva::types::TreeNode& node) {
   if (node.has_fieldnode()) {
     return ProtoTypeToFieldNode(node.fieldnode());
   }
@@ -494,7 +494,7 @@ NodePtr ProtoTypeToNode(const types::TreeNode& node) {
   return nullptr;
 }
 
-ExpressionPtr ProtoTypeToExpression(const types::ExpressionRoot& root) {
+ExpressionPtr ProtoTypeToExpression(const gandiva::types::ExpressionRoot& root) {
   NodePtr root_node = ProtoTypeToNode(root.root());
   if (root_node == nullptr) {
     std::cerr << "Unable to create expression node from expression protobuf\n";
@@ -510,7 +510,7 @@ ExpressionPtr ProtoTypeToExpression(const types::ExpressionRoot& root) {
   return TreeExprBuilder::MakeExpression(root_node, field);
 }
 
-ConditionPtr ProtoTypeToCondition(const types::Condition& condition) {
+ConditionPtr ProtoTypeToCondition(const gandiva::types::Condition& condition) {
   NodePtr root_node = ProtoTypeToNode(condition.root());
   if (root_node == nullptr) {
     return nullptr;
@@ -519,7 +519,7 @@ ConditionPtr ProtoTypeToCondition(const types::Condition& condition) {
   return TreeExprBuilder::MakeCondition(root_node);
 }
 
-SchemaPtr ProtoTypeToSchema(const types::Schema& schema) {
+SchemaPtr ProtoTypeToSchema(const gandiva::types::Schema& schema) {
   std::vector<FieldPtr> fields;
 
   for (int i = 0; i < schema.columns_size(); i++) {
@@ -608,11 +608,11 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_build
   std::shared_ptr<Projector> projector;
   std::shared_ptr<ProjectorHolder> holder;
 
-  types::Schema schema;
+  gandiva::types::Schema schema;
   jsize schema_len = env->GetArrayLength(schema_arr);
   jbyte* schema_bytes = env->GetByteArrayElements(schema_arr, 0);
 
-  types::ExpressionList exprs;
+  gandiva::types::ExpressionList exprs;
   jsize exprs_len = env->GetArrayLength(exprs_arr);
   jbyte* exprs_bytes = env->GetByteArrayElements(exprs_arr, 0);
 
@@ -643,7 +643,7 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_build
     goto err_out;
   }
 
-  // convert types::Schema to arrow::Schema
+  // convert gandiva::types::Schema to arrow::Schema
   schema_ptr = ProtoTypeToSchema(schema);
   if (schema_ptr == nullptr) {
     ss << "Unable to construct arrow schema object from schema protobuf\n";
@@ -666,13 +666,13 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_build
   }
 
   switch (selection_vector_type) {
-    case types::SV_NONE:
+    case gandiva::types::SV_NONE:
       mode = gandiva::SelectionVector::MODE_NONE;
       break;
-    case types::SV_INT16:
+    case gandiva::types::SV_INT16:
       mode = gandiva::SelectionVector::MODE_UINT16;
       break;
-    case types::SV_INT32:
+    case gandiva::types::SV_INT32:
       mode = gandiva::SelectionVector::MODE_UINT32;
       break;
   }
@@ -809,17 +809,17 @@ Java_org_apache_arrow_gandiva_evaluator_JniWrapper_evaluateProjector(
         reinterpret_cast<uint8_t*>(sel_vec_addr), sel_vec_size);
     int output_row_count = 0;
     switch (sel_vec_type) {
-      case types::SV_NONE: {
+      case gandiva::types::SV_NONE: {
         output_row_count = num_rows;
         break;
       }
-      case types::SV_INT16: {
+      case gandiva::types::SV_INT16: {
         status = gandiva::SelectionVector::MakeImmutableInt16(
             sel_vec_rows, selection_buffer, &selection_vector);
         output_row_count = sel_vec_rows;
         break;
       }
-      case types::SV_INT32: {
+      case gandiva::types::SV_INT32: {
         status = gandiva::SelectionVector::MakeImmutableInt32(
             sel_vec_rows, selection_buffer, &selection_vector);
         output_row_count = sel_vec_rows;
@@ -909,11 +909,11 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_build
   std::shared_ptr<Filter> filter;
   std::shared_ptr<FilterHolder> holder;
 
-  types::Schema schema;
+  gandiva::types::Schema schema;
   jsize schema_len = env->GetArrayLength(schema_arr);
   jbyte* schema_bytes = env->GetByteArrayElements(schema_arr, 0);
 
-  types::Condition condition;
+  gandiva::types::Condition condition;
   jsize condition_len = env->GetArrayLength(condition_arr);
   jbyte* condition_bytes = env->GetByteArrayElements(condition_arr, 0);
 
@@ -943,7 +943,7 @@ JNIEXPORT jlong JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_build
     goto err_out;
   }
 
-  // convert types::Schema to arrow::Schema
+  // convert gandiva::types::Schema to arrow::Schema
   schema_ptr = ProtoTypeToSchema(schema);
   if (schema_ptr == nullptr) {
     ss << "Unable to construct arrow schema object from schema protobuf\n";
@@ -1008,15 +1008,15 @@ JNIEXPORT jint JNICALL Java_org_apache_arrow_gandiva_evaluator_JniWrapper_evalua
     }
 
     auto selection_vector_type =
-        static_cast<types::SelectionVectorType>(jselection_vector_type);
+        static_cast<gandiva::types::SelectionVectorType>(jselection_vector_type);
     auto out_buffer = std::make_shared<arrow::MutableBuffer>(
         reinterpret_cast<uint8_t*>(out_buf_addr), out_buf_size);
     switch (selection_vector_type) {
-      case types::SV_INT16:
+      case gandiva::types::SV_INT16:
         status =
             gandiva::SelectionVector::MakeInt16(num_rows, out_buffer, &selection_vector);
         break;
-      case types::SV_INT32:
+      case gandiva::types::SV_INT32:
         status =
             gandiva::SelectionVector::MakeInt32(num_rows, out_buffer, &selection_vector);
         break;

From 853d8491addff3a10fc40950823a2942bb9fbf98 Mon Sep 17 00:00:00 2001
From: Gang Wu <ustcwg@gmail.com>
Date: Fri, 29 Sep 2023 00:07:16 +0800
Subject: [PATCH 425/749] GH-34950: [C++][Parquet] Support encryption for page
 index (#36574)

### Rationale for this change

Parquet modular encryption requires page index to be encrypted if the column chunk is encrypted. This feature is missing for now.

### What changes are included in this PR?

Support both encryption and decryption for parquet page index.

### Are these changes tested?

Added round trip tests in write_configurations_test.cc and read_configurations_test.cc.

### Are there any user-facing changes?

NO.
* Closes: #34950

Authored-by: Gang Wu <ustcwg@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/column_reader.cc              |   8 +-
 cpp/src/parquet/column_writer.cc              |   4 +-
 .../parquet/encryption/encryption_internal.h  |   2 +
 .../encryption/internal_file_decryptor.cc     |  55 ++++++
 .../encryption/internal_file_decryptor.h      |  13 ++
 .../encryption/read_configurations_test.cc    |  58 ++++--
 .../encryption/test_encryption_util.cc        | 178 +++++++++++++++++-
 .../parquet/encryption/test_encryption_util.h |  16 +-
 cpp/src/parquet/encryption/type_fwd.h         |  28 +++
 .../encryption/write_configurations_test.cc   |   2 +-
 cpp/src/parquet/file_reader.cc                |  34 +---
 cpp/src/parquet/file_writer.cc                |   6 +-
 cpp/src/parquet/metadata.cc                   |   7 +-
 cpp/src/parquet/metadata.h                    |   8 +-
 cpp/src/parquet/page_index.cc                 | 105 +++++++----
 cpp/src/parquet/page_index.h                  |  26 +--
 cpp/src/parquet/thrift_internal.h             |   7 +-
 cpp/src/parquet/type_fwd.h                    |   3 +
 18 files changed, 439 insertions(+), 121 deletions(-)
 create mode 100644 cpp/src/parquet/encryption/type_fwd.h

diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index 6fe1ce9da60fe..fa013dd2ea583 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -363,10 +363,8 @@ void SerializedPageReader::UpdateDecryption(const std::shared_ptr<Decryptor>& de
                                             int8_t module_type, std::string* page_aad) {
   ARROW_DCHECK(decryptor != nullptr);
   if (crypto_ctx_.start_decrypt_with_dictionary_page) {
-    std::string aad = encryption::CreateModuleAad(
-        decryptor->file_aad(), module_type, crypto_ctx_.row_group_ordinal,
-        crypto_ctx_.column_ordinal, kNonPageOrdinal);
-    decryptor->UpdateAad(aad);
+    UpdateDecryptor(decryptor, crypto_ctx_.row_group_ordinal, crypto_ctx_.column_ordinal,
+                    module_type);
   } else {
     encryption::QuickUpdatePageAad(page_ordinal_, page_aad);
     decryptor->UpdateAad(*page_aad);
@@ -449,7 +447,7 @@ std::shared_ptr<Page> SerializedPageReader::NextPage() {
         current_page_header_ = format::PageHeader();
         deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(view.data()),
                                         &header_size, &current_page_header_,
-                                        crypto_ctx_.meta_decryptor);
+                                        crypto_ctx_.meta_decryptor.get());
         break;
       } catch (std::exception& e) {
         // Failed to deserialize. Double the allowed page header size and try again
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index ae9216ba7c312..a0aedeee9e968 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -330,7 +330,7 @@ class SerializedPageWriter : public PageWriter {
       UpdateEncryption(encryption::kDictionaryPageHeader);
     }
     const int64_t header_size =
-        thrift_serializer_->Serialize(&page_header, sink_.get(), meta_encryptor_);
+        thrift_serializer_->Serialize(&page_header, sink_.get(), meta_encryptor_.get());
 
     PARQUET_THROW_NOT_OK(sink_->Write(output_data_buffer, output_data_len));
 
@@ -422,7 +422,7 @@ class SerializedPageWriter : public PageWriter {
       UpdateEncryption(encryption::kDataPageHeader);
     }
     const int64_t header_size =
-        thrift_serializer_->Serialize(&page_header, sink_.get(), meta_encryptor_);
+        thrift_serializer_->Serialize(&page_header, sink_.get(), meta_encryptor_.get());
     PARQUET_THROW_NOT_OK(sink_->Write(output_data_buffer, output_data_len));
 
     /// Collect page index
diff --git a/cpp/src/parquet/encryption/encryption_internal.h b/cpp/src/parquet/encryption/encryption_internal.h
index 4ed5b5cf61243..77921d8731d25 100644
--- a/cpp/src/parquet/encryption/encryption_internal.h
+++ b/cpp/src/parquet/encryption/encryption_internal.h
@@ -40,6 +40,8 @@ constexpr int8_t kDataPageHeader = 4;
 constexpr int8_t kDictionaryPageHeader = 5;
 constexpr int8_t kColumnIndex = 6;
 constexpr int8_t kOffsetIndex = 7;
+constexpr int8_t kBloomFilterHeader = 8;
+constexpr int8_t kBloomFilterBitset = 9;
 
 /// Performs AES encryption operations with GCM or CTR ciphers.
 class AesEncryptor {
diff --git a/cpp/src/parquet/encryption/internal_file_decryptor.cc b/cpp/src/parquet/encryption/internal_file_decryptor.cc
index 87bfc2bd12047..19e4845c8732d 100644
--- a/cpp/src/parquet/encryption/internal_file_decryptor.cc
+++ b/cpp/src/parquet/encryption/internal_file_decryptor.cc
@@ -16,8 +16,10 @@
 // under the License.
 
 #include "parquet/encryption/internal_file_decryptor.h"
+#include "arrow/util/logging.h"
 #include "parquet/encryption/encryption.h"
 #include "parquet/encryption/encryption_internal.h"
+#include "parquet/metadata.h"
 
 namespace parquet {
 
@@ -215,4 +217,57 @@ std::shared_ptr<Decryptor> InternalFileDecryptor::GetColumnDecryptor(
   return column_data_map_[column_path];
 }
 
+namespace {
+
+std::shared_ptr<Decryptor> GetColumnDecryptor(
+    const ColumnCryptoMetaData* crypto_metadata, InternalFileDecryptor* file_decryptor,
+    const std::function<std::shared_ptr<Decryptor>(
+        InternalFileDecryptor* file_decryptor, const std::string& column_path,
+        const std::string& column_key_metadata, const std::string& aad)>& func,
+    bool metadata) {
+  if (crypto_metadata == nullptr) {
+    return nullptr;
+  }
+
+  if (file_decryptor == nullptr) {
+    throw ParquetException("RowGroup is noted as encrypted but no file decryptor");
+  }
+
+  if (crypto_metadata->encrypted_with_footer_key()) {
+    return metadata ? file_decryptor->GetFooterDecryptorForColumnMeta()
+                    : file_decryptor->GetFooterDecryptorForColumnData();
+  }
+
+  // The column is encrypted with its own key
+  const std::string& column_key_metadata = crypto_metadata->key_metadata();
+  const std::string column_path = crypto_metadata->path_in_schema()->ToDotString();
+  return func(file_decryptor, column_path, column_key_metadata, /*aad=*/"");
+}
+
+}  // namespace
+
+std::shared_ptr<Decryptor> GetColumnMetaDecryptor(
+    const ColumnCryptoMetaData* crypto_metadata, InternalFileDecryptor* file_decryptor) {
+  return GetColumnDecryptor(crypto_metadata, file_decryptor,
+                            &InternalFileDecryptor::GetColumnMetaDecryptor,
+                            /*metadata=*/true);
+}
+
+std::shared_ptr<Decryptor> GetColumnDataDecryptor(
+    const ColumnCryptoMetaData* crypto_metadata, InternalFileDecryptor* file_decryptor) {
+  return GetColumnDecryptor(crypto_metadata, file_decryptor,
+                            &InternalFileDecryptor::GetColumnDataDecryptor,
+                            /*metadata=*/false);
+}
+
+void UpdateDecryptor(const std::shared_ptr<Decryptor>& decryptor,
+                     int16_t row_group_ordinal, int16_t column_ordinal,
+                     int8_t module_type) {
+  ARROW_DCHECK(!decryptor->file_aad().empty());
+  const std::string aad =
+      encryption::CreateModuleAad(decryptor->file_aad(), module_type, row_group_ordinal,
+                                  column_ordinal, kNonPageOrdinal);
+  decryptor->UpdateAad(aad);
+}
+
 }  // namespace parquet
diff --git a/cpp/src/parquet/encryption/internal_file_decryptor.h b/cpp/src/parquet/encryption/internal_file_decryptor.h
index 2f9c3952aff2d..0b27effda8822 100644
--- a/cpp/src/parquet/encryption/internal_file_decryptor.h
+++ b/cpp/src/parquet/encryption/internal_file_decryptor.h
@@ -31,6 +31,7 @@ class AesDecryptor;
 class AesEncryptor;
 }  // namespace encryption
 
+class ColumnCryptoMetaData;
 class FileDecryptionProperties;
 
 class PARQUET_EXPORT Decryptor {
@@ -110,4 +111,16 @@ class InternalFileDecryptor {
                                                 bool metadata = false);
 };
 
+/// Utility to get column meta decryptor of an encrypted column.
+std::shared_ptr<Decryptor> GetColumnMetaDecryptor(
+    const ColumnCryptoMetaData* crypto_metadata, InternalFileDecryptor* file_decryptor);
+
+/// Utility to get column data decryptor of an encrypted column.
+std::shared_ptr<Decryptor> GetColumnDataDecryptor(
+    const ColumnCryptoMetaData* crypto_metadata, InternalFileDecryptor* file_decryptor);
+
+void UpdateDecryptor(const std::shared_ptr<Decryptor>& decryptor,
+                     int16_t row_group_ordinal, int16_t column_ordinal,
+                     int8_t module_type);
+
 }  // namespace parquet
diff --git a/cpp/src/parquet/encryption/read_configurations_test.cc b/cpp/src/parquet/encryption/read_configurations_test.cc
index 10de7198ac5ff..695696db293fb 100644
--- a/cpp/src/parquet/encryption/read_configurations_test.cc
+++ b/cpp/src/parquet/encryption/read_configurations_test.cc
@@ -36,7 +36,7 @@
  * The unit-test is called multiple times, each time to decrypt parquet files using
  * different decryption configuration as described below.
  * In each call two encrypted files are read: one temporary file that was generated using
- * encryption-write-configurations-test.cc test and will be deleted upon
+ * write_configurations_test.cc test and will be deleted upon
  * reading it, while the second resides in
  * parquet-testing/data repository. Those two encrypted files were encrypted using the
  * same encryption configuration.
@@ -59,8 +59,8 @@
  *                                  read the footer + all non-encrypted columns.
  *                                  (pairs with encryption configuration 3)
  *
- * The encrypted parquet files that is read was encrypted using one of the configurations
- * below:
+ * The encrypted parquet files that are read were encrypted using one of the
+ * configurations below:
  *
  *  - Encryption configuration 1:   Encrypt all columns and the footer with the same key.
  *                                  (uniform encryption)
@@ -166,7 +166,11 @@ class TestDecryptionConfiguration
     vector_of_decryption_configurations_.push_back(NULL);
   }
 
-  void DecryptFile(std::string file, int decryption_config_num) {
+  void DecryptFileInternal(
+      const std::string& file, int decryption_config_num,
+      std::function<void(const std::string& file,
+                         const std::shared_ptr<FileDecryptionProperties>&)>
+          decrypt_func) {
     std::string exception_msg;
     std::shared_ptr<FileDecryptionProperties> file_decryption_properties;
     // if we get decryption_config_num = x then it means the actual number is x+1
@@ -176,18 +180,40 @@ class TestDecryptionConfiguration
           vector_of_decryption_configurations_[decryption_config_num]->DeepClone();
     }
 
-    decryptor_.DecryptFile(file, file_decryption_properties);
+    decrypt_func(std::move(file), std::move(file_decryption_properties));
+  }
+
+  void DecryptFile(const std::string& file, int decryption_config_num) {
+    DecryptFileInternal(
+        file, decryption_config_num,
+        [&](const std::string& file,
+            const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
+          decryptor_.DecryptFile(file, file_decryption_properties);
+        });
+  }
+
+  void DecryptPageIndex(const std::string& file, int decryption_config_num) {
+    DecryptFileInternal(
+        file, decryption_config_num,
+        [&](const std::string& file,
+            const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
+          decryptor_.DecryptPageIndex(file, file_decryption_properties);
+        });
   }
 
   // Check that the decryption result is as expected.
-  void CheckResults(const std::string file_name, unsigned decryption_config_num,
-                    unsigned encryption_config_num) {
+  void CheckResults(const std::string& file_name, unsigned decryption_config_num,
+                    unsigned encryption_config_num, bool file_has_page_index) {
     // Encryption_configuration number five contains aad_prefix and
     // disable_aad_prefix_storage.
     // An exception is expected to be thrown if the file is not decrypted with aad_prefix.
     if (encryption_config_num == 5) {
       if (decryption_config_num == 1 || decryption_config_num == 3) {
         EXPECT_THROW(DecryptFile(file_name, decryption_config_num - 1), ParquetException);
+        if (file_has_page_index) {
+          EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
+                       ParquetException);
+        }
         return;
       }
     }
@@ -196,6 +222,10 @@ class TestDecryptionConfiguration
     if (decryption_config_num == 2) {
       if (encryption_config_num != 5 && encryption_config_num != 4) {
         EXPECT_THROW(DecryptFile(file_name, decryption_config_num - 1), ParquetException);
+        if (file_has_page_index) {
+          EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
+                       ParquetException);
+        }
         return;
       }
     }
@@ -205,6 +235,9 @@ class TestDecryptionConfiguration
       return;
     }
     EXPECT_NO_THROW(DecryptFile(file_name, decryption_config_num - 1));
+    if (file_has_page_index) {
+      EXPECT_NO_THROW(DecryptPageIndex(file_name, decryption_config_num - 1));
+    }
   }
 
   // Returns true if file exists. Otherwise returns false.
@@ -217,14 +250,13 @@ class TestDecryptionConfiguration
 // Read encrypted parquet file.
 // The test reads two parquet files that were encrypted using the same encryption
 // configuration:
-// one was generated in encryption-write-configurations-test.cc tests and is deleted
+// one was generated in write_configurations_test.cc tests and is deleted
 // once the file is read and the second exists in parquet-testing/data folder.
 // The name of the files are passed as parameters to the unit-test.
 TEST_P(TestDecryptionConfiguration, TestDecryption) {
   int encryption_config_num = std::get<0>(GetParam());
   const char* param_file_name = std::get<1>(GetParam());
-  // Decrypt parquet file that was generated in encryption-write-configurations-test.cc
-  // test.
+  // Decrypt parquet file that was generated in write_configurations_test.cc test.
   std::string tmp_file_name = "tmp_" + std::string(param_file_name);
   std::string file_name = temp_dir->path().ToString() + tmp_file_name;
   if (!fexists(file_name)) {
@@ -237,7 +269,8 @@ TEST_P(TestDecryptionConfiguration, TestDecryption) {
   // parquet file.
   for (unsigned index = 0; index < vector_of_decryption_configurations_.size(); ++index) {
     unsigned decryption_config_num = index + 1;
-    CheckResults(file_name, decryption_config_num, encryption_config_num);
+    CheckResults(file_name, decryption_config_num, encryption_config_num,
+                 /*file_has_page_index=*/true);
   }
   // Delete temporary test file.
   ASSERT_EQ(std::remove(file_name.c_str()), 0);
@@ -255,7 +288,8 @@ TEST_P(TestDecryptionConfiguration, TestDecryption) {
   // parquet file.
   for (unsigned index = 0; index < vector_of_decryption_configurations_.size(); ++index) {
     unsigned decryption_config_num = index + 1;
-    CheckResults(file_name, decryption_config_num, encryption_config_num);
+    CheckResults(file_name, decryption_config_num, encryption_config_num,
+                 /*file_has_page_index=*/false);
   }
 }
 
diff --git a/cpp/src/parquet/encryption/test_encryption_util.cc b/cpp/src/parquet/encryption/test_encryption_util.cc
index 694ed3cf42d9e..4fa215312f265 100644
--- a/cpp/src/parquet/encryption/test_encryption_util.cc
+++ b/cpp/src/parquet/encryption/test_encryption_util.cc
@@ -19,14 +19,17 @@
 // Parquet column chunk within a row group. It could be extended in the future
 // to iterate through all data pages in all chunks in a file.
 
+#include <numeric>
 #include <sstream>
 
-#include <arrow/io/file.h>
-
+#include "arrow/io/file.h"
 #include "arrow/testing/future_util.h"
+#include "arrow/util/unreachable.h"
+
 #include "parquet/encryption/test_encryption_util.h"
 #include "parquet/file_reader.h"
 #include "parquet/file_writer.h"
+#include "parquet/page_index.h"
 #include "parquet/test_util.h"
 
 using ::arrow::io::FileOutputStream;
@@ -206,6 +209,7 @@ void FileEncryptor::EncryptFile(
   WriterProperties::Builder prop_builder;
   prop_builder.compression(parquet::Compression::UNCOMPRESSED);
   prop_builder.encryption(encryption_configurations);
+  prop_builder.enable_write_page_index();
   std::shared_ptr<WriterProperties> writer_properties = prop_builder.build();
 
   PARQUET_ASSIGN_OR_THROW(auto out_file, FileOutputStream::Open(file));
@@ -340,8 +344,8 @@ void ReadAndVerifyColumn(RowGroupReader* rg_reader, RowGroupMetadata* rg_md,
 }
 
 void FileDecryptor::DecryptFile(
-    std::string file,
-    std::shared_ptr<FileDecryptionProperties> file_decryption_properties) {
+    const std::string& file,
+    const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
   std::string exception_msg;
   parquet::ReaderProperties reader_properties = parquet::default_reader_properties();
   if (file_decryption_properties) {
@@ -353,7 +357,7 @@ void FileDecryptor::DecryptFile(
       source, ::arrow::io::ReadableFile::Open(file, reader_properties.memory_pool()));
 
   auto file_reader = parquet::ParquetFileReader::Open(source, reader_properties);
-  CheckFile(file_reader.get(), file_decryption_properties.get());
+  CheckFile(file_reader.get(), file_decryption_properties);
 
   if (file_decryption_properties) {
     reader_properties.file_decryption_properties(file_decryption_properties->DeepClone());
@@ -361,14 +365,15 @@ void FileDecryptor::DecryptFile(
   auto fut = parquet::ParquetFileReader::OpenAsync(source, reader_properties);
   ASSERT_FINISHES_OK(fut);
   ASSERT_OK_AND_ASSIGN(file_reader, fut.MoveResult());
-  CheckFile(file_reader.get(), file_decryption_properties.get());
+  CheckFile(file_reader.get(), file_decryption_properties);
 
   file_reader->Close();
   PARQUET_THROW_NOT_OK(source->Close());
 }
 
-void FileDecryptor::CheckFile(parquet::ParquetFileReader* file_reader,
-                              FileDecryptionProperties* file_decryption_properties) {
+void FileDecryptor::CheckFile(
+    parquet::ParquetFileReader* file_reader,
+    const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
   // Get the File MetaData
   std::shared_ptr<parquet::FileMetaData> file_metadata = file_reader->metadata();
 
@@ -509,4 +514,161 @@ void FileDecryptor::CheckFile(parquet::ParquetFileReader* file_reader,
   }
 }
 
+void FileDecryptor::DecryptPageIndex(
+    const std::string& file,
+    const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
+  std::string exception_msg;
+  parquet::ReaderProperties reader_properties = parquet::default_reader_properties();
+  if (file_decryption_properties) {
+    reader_properties.file_decryption_properties(file_decryption_properties->DeepClone());
+  }
+
+  std::shared_ptr<::arrow::io::RandomAccessFile> source;
+  PARQUET_ASSIGN_OR_THROW(
+      source, ::arrow::io::ReadableFile::Open(file, reader_properties.memory_pool()));
+
+  auto file_reader = parquet::ParquetFileReader::Open(source, reader_properties);
+  CheckPageIndex(file_reader.get(), file_decryption_properties);
+
+  ASSERT_NO_FATAL_FAILURE(file_reader->Close());
+  PARQUET_THROW_NOT_OK(source->Close());
+}
+
+template <typename DType, typename c_type = typename DType::c_type>
+void AssertColumnIndex(const std::shared_ptr<ColumnIndex>& column_index,
+                       const std::vector<int64_t>& expected_null_counts,
+                       const std::vector<c_type>& expected_min_values,
+                       const std::vector<c_type>& expected_max_values) {
+  auto typed_column_index =
+      std::dynamic_pointer_cast<TypedColumnIndex<DType>>(column_index);
+  ASSERT_NE(typed_column_index, nullptr);
+  ASSERT_EQ(typed_column_index->null_counts(), expected_null_counts);
+  if constexpr (std::is_same_v<FLBAType, DType>) {
+    ASSERT_EQ(typed_column_index->min_values().size(), expected_min_values.size());
+    ASSERT_EQ(typed_column_index->max_values().size(), expected_max_values.size());
+    for (size_t i = 0; i < expected_min_values.size(); ++i) {
+      ASSERT_EQ(
+          FixedLenByteArrayToString(typed_column_index->min_values()[i], kFixedLength),
+          FixedLenByteArrayToString(expected_min_values[i], kFixedLength));
+    }
+    for (size_t i = 0; i < expected_max_values.size(); ++i) {
+      ASSERT_EQ(
+          FixedLenByteArrayToString(typed_column_index->max_values()[i], kFixedLength),
+          FixedLenByteArrayToString(expected_max_values[i], kFixedLength));
+    }
+  } else {
+    ASSERT_EQ(typed_column_index->min_values(), expected_min_values);
+    ASSERT_EQ(typed_column_index->max_values(), expected_max_values);
+  }
+}
+
+void FileDecryptor::CheckPageIndex(
+    parquet::ParquetFileReader* file_reader,
+    const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties) {
+  std::shared_ptr<PageIndexReader> page_index_reader = file_reader->GetPageIndexReader();
+  ASSERT_NE(page_index_reader, nullptr);
+
+  const std::shared_ptr<parquet::FileMetaData> file_metadata = file_reader->metadata();
+  const int num_row_groups = file_metadata->num_row_groups();
+  const int num_columns = file_metadata->num_columns();
+  ASSERT_EQ(num_columns, 8);
+
+  // We cannot read page index of encrypted columns in the plaintext mode
+  std::vector<int32_t> need_row_groups(num_row_groups);
+  std::iota(need_row_groups.begin(), need_row_groups.end(), 0);
+  std::vector<int32_t> need_columns;
+  if (file_decryption_properties == nullptr) {
+    need_columns = {0, 1, 2, 3, 6, 7};
+  } else {
+    need_columns = {0, 1, 2, 3, 4, 5, 6, 7};
+  }
+
+  // Provide hint of requested columns to avoid accessing encrypted columns without
+  // decryption properties.
+  page_index_reader->WillNeed(
+      need_row_groups, need_columns,
+      PageIndexSelection{/*column_index=*/true, /*offset_index=*/true});
+
+  // Iterate over all the RowGroups in the file.
+  for (int r = 0; r < num_row_groups; ++r) {
+    auto row_group_page_index_reader = page_index_reader->RowGroup(r);
+    ASSERT_NE(row_group_page_index_reader, nullptr);
+
+    for (int c = 0; c < num_columns; ++c) {
+      // Skip reading encrypted columns without decryption properties.
+      if (file_decryption_properties == nullptr && (c == 4 || c == 5)) {
+        continue;
+      }
+
+      constexpr size_t kExpectedNumPages = 1;
+
+      // Check offset index.
+      auto offset_index = row_group_page_index_reader->GetOffsetIndex(c);
+      ASSERT_NE(offset_index, nullptr);
+      ASSERT_EQ(offset_index->page_locations().size(), kExpectedNumPages);
+      const auto& first_page = offset_index->page_locations()[0];
+      ASSERT_EQ(first_page.first_row_index, 0);
+      ASSERT_GT(first_page.compressed_page_size, 0);
+
+      // Int96 column does not have column index.
+      if (c == 3) {
+        continue;
+      }
+
+      // Check column index
+      auto column_index = row_group_page_index_reader->GetColumnIndex(c);
+      ASSERT_NE(column_index, nullptr);
+      ASSERT_EQ(column_index->null_pages().size(), kExpectedNumPages);
+      ASSERT_EQ(column_index->null_pages()[0], false);
+      ASSERT_EQ(column_index->encoded_min_values().size(), kExpectedNumPages);
+      ASSERT_EQ(column_index->encoded_max_values().size(), kExpectedNumPages);
+      ASSERT_TRUE(column_index->has_null_counts());
+
+      switch (c) {
+        case 0: {
+          AssertColumnIndex<BooleanType>(column_index, /*expected_null_counts=*/{0},
+                                         /*expected_min_values=*/{false},
+                                         /*expected_max_values=*/{true});
+        } break;
+        case 1: {
+          AssertColumnIndex<Int32Type>(column_index, /*expected_null_counts=*/{0},
+                                       /*expected_min_values=*/{0},
+                                       /*expected_max_values=*/{49});
+        } break;
+        case 2: {
+          AssertColumnIndex<Int64Type>(column_index, /*expected_null_counts=*/{0},
+                                       /*expected_min_values=*/{0},
+                                       /*expected_max_values=*/{99000000000000});
+        } break;
+        case 4: {
+          AssertColumnIndex<FloatType>(column_index, /*expected_null_counts=*/{0},
+                                       /*expected_min_values=*/{0.0F},
+                                       /*expected_max_values=*/{53.9F});
+        } break;
+        case 5: {
+          AssertColumnIndex<DoubleType>(column_index, /*expected_null_counts=*/{0},
+                                        /*expected_min_values=*/{0.0},
+                                        /*expected_max_values=*/{54.4444439});
+        } break;
+        case 6: {
+          AssertColumnIndex<ByteArrayType>(
+              column_index, /*expected_null_counts=*/{25},
+              /*expected_min_values=*/{ByteArray("parquet000")},
+              /*expected_max_values=*/{ByteArray("parquet048")});
+        } break;
+        case 7: {
+          const std::vector<uint8_t> kExpectedMinValue(kFixedLength, 0);
+          const std::vector<uint8_t> kExpectedMaxValue(kFixedLength, 49);
+          AssertColumnIndex<FLBAType>(
+              column_index, /*expected_null_counts=*/{0},
+              /*expected_min_values=*/{FLBA(kExpectedMinValue.data())},
+              /*expected_max_values=*/{FLBA(kExpectedMaxValue.data())});
+        } break;
+        default:
+          ::arrow::Unreachable("Unexpected column index " + std::to_string(c));
+      }
+    }
+  }
+}
+
 }  // namespace parquet::encryption::test
diff --git a/cpp/src/parquet/encryption/test_encryption_util.h b/cpp/src/parquet/encryption/test_encryption_util.h
index 19c230ee5ff99..86aa0ff07cf84 100644
--- a/cpp/src/parquet/encryption/test_encryption_util.h
+++ b/cpp/src/parquet/encryption/test_encryption_util.h
@@ -113,12 +113,20 @@ class FileEncryptor {
 
 class FileDecryptor {
  public:
-  void DecryptFile(std::string file_name,
-                   std::shared_ptr<FileDecryptionProperties> file_decryption_properties);
+  void DecryptFile(
+      const std::string& file_name,
+      const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties);
+  void DecryptPageIndex(
+      const std::string& file_name,
+      const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties);
 
  private:
-  void CheckFile(parquet::ParquetFileReader* file_reader,
-                 FileDecryptionProperties* file_decryption_properties);
+  void CheckFile(
+      parquet::ParquetFileReader* file_reader,
+      const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties);
+  void CheckPageIndex(
+      parquet::ParquetFileReader* file_reader,
+      const std::shared_ptr<FileDecryptionProperties>& file_decryption_properties);
 };
 
 }  // namespace encryption::test
diff --git a/cpp/src/parquet/encryption/type_fwd.h b/cpp/src/parquet/encryption/type_fwd.h
new file mode 100644
index 0000000000000..623811718482c
--- /dev/null
+++ b/cpp/src/parquet/encryption/type_fwd.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+namespace parquet {
+
+class Decryptor;
+class Encryptor;
+
+class InternalFileDecryptor;
+class InternalFileEncryptor;
+
+}  // namespace parquet
diff --git a/cpp/src/parquet/encryption/write_configurations_test.cc b/cpp/src/parquet/encryption/write_configurations_test.cc
index e262003db3e6a..f27da82694874 100644
--- a/cpp/src/parquet/encryption/write_configurations_test.cc
+++ b/cpp/src/parquet/encryption/write_configurations_test.cc
@@ -33,7 +33,7 @@
  * This file contains unit-tests for writing encrypted Parquet files with
  * different encryption configurations.
  * The files are saved in temporary folder and will be deleted after reading
- * them in encryption-read-configurations-test.cc test.
+ * them in read_configurations_test.cc test.
  *
  * A detailed description of the Parquet Modular Encryption specification can be found
  * here:
diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index 08d493b0bca2f..5247b9d4b543d 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -227,37 +227,19 @@ class SerializedRowGroup : public RowGroupReader::Contents {
                               always_compressed);
     }
 
-    if (file_decryptor_ == nullptr) {
-      throw ParquetException("RowGroup is noted as encrypted but no file decryptor");
-    }
+    // The column is encrypted
+    std::shared_ptr<Decryptor> meta_decryptor =
+        GetColumnMetaDecryptor(crypto_metadata.get(), file_decryptor_.get());
+    std::shared_ptr<Decryptor> data_decryptor =
+        GetColumnDataDecryptor(crypto_metadata.get(), file_decryptor_.get());
+    ARROW_DCHECK_NE(meta_decryptor, nullptr);
+    ARROW_DCHECK_NE(data_decryptor, nullptr);
 
     constexpr auto kEncryptedRowGroupsLimit = 32767;
     if (i > kEncryptedRowGroupsLimit) {
       throw ParquetException("Encrypted files cannot contain more than 32767 row groups");
     }
 
-    // The column is encrypted
-    std::shared_ptr<Decryptor> meta_decryptor;
-    std::shared_ptr<Decryptor> data_decryptor;
-    // The column is encrypted with footer key
-    if (crypto_metadata->encrypted_with_footer_key()) {
-      meta_decryptor = file_decryptor_->GetFooterDecryptorForColumnMeta();
-      data_decryptor = file_decryptor_->GetFooterDecryptorForColumnData();
-      CryptoContext ctx(col->has_dictionary_page(), row_group_ordinal_,
-                        static_cast<int16_t>(i), meta_decryptor, data_decryptor);
-      return PageReader::Open(stream, col->num_values(), col->compression(), properties_,
-                              always_compressed, &ctx);
-    }
-
-    // The column is encrypted with its own key
-    std::string column_key_metadata = crypto_metadata->key_metadata();
-    const std::string column_path = crypto_metadata->path_in_schema()->ToDotString();
-
-    meta_decryptor =
-        file_decryptor_->GetColumnMetaDecryptor(column_path, column_key_metadata);
-    data_decryptor =
-        file_decryptor_->GetColumnDataDecryptor(column_path, column_key_metadata);
-
     CryptoContext ctx(col->has_dictionary_page(), row_group_ordinal_,
                       static_cast<int16_t>(i), meta_decryptor, data_decryptor);
     return PageReader::Open(stream, col->num_values(), col->compression(), properties_,
@@ -330,7 +312,7 @@ class SerializedFile : public ParquetFileReader::Contents {
     }
     if (!page_index_reader_) {
       page_index_reader_ = PageIndexReader::Make(source_.get(), file_metadata_,
-                                                 properties_, file_decryptor_);
+                                                 properties_, file_decryptor_.get());
     }
     return page_index_reader_;
   }
diff --git a/cpp/src/parquet/file_writer.cc b/cpp/src/parquet/file_writer.cc
index 2a6a88df2dd0a..9a92d4525d23d 100644
--- a/cpp/src/parquet/file_writer.cc
+++ b/cpp/src/parquet/file_writer.cc
@@ -471,10 +471,6 @@ class FileSerializer : public ParquetFileWriter::Contents {
 
   void WritePageIndex() {
     if (page_index_builder_ != nullptr) {
-      if (properties_->file_encryption_properties()) {
-        throw ParquetException("Encryption is not supported with page index");
-      }
-
       // Serialize page index after all row groups have been written and report
       // location to the file metadata.
       PageIndexLocation page_index_location;
@@ -533,7 +529,7 @@ class FileSerializer : public ParquetFileWriter::Contents {
     }
 
     if (properties_->page_index_enabled()) {
-      page_index_builder_ = PageIndexBuilder::Make(&schema_);
+      page_index_builder_ = PageIndexBuilder::Make(&schema_, file_encryptor_.get());
     }
   }
 };
diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc
index 8aedf5b926add..4ef2151fee59d 100644
--- a/cpp/src/parquet/metadata.cc
+++ b/cpp/src/parquet/metadata.cc
@@ -211,7 +211,7 @@ class ColumnChunkMetaData::ColumnChunkMetaDataImpl {
           ThriftDeserializer deserializer(properties_);
           deserializer.DeserializeMessage(
               reinterpret_cast<const uint8_t*>(column->encrypted_column_metadata.c_str()),
-              &len, &decrypted_metadata_, decryptor);
+              &len, &decrypted_metadata_, decryptor.get());
           column_metadata_ = &decrypted_metadata_;
         } else {
           throw ParquetException(
@@ -603,7 +603,8 @@ class FileMetaData::FileMetaDataImpl {
 
     ThriftDeserializer deserializer(properties_);
     deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(metadata),
-                                    metadata_len, metadata_.get(), footer_decryptor);
+                                    metadata_len, metadata_.get(),
+                                    footer_decryptor.get());
     metadata_len_ = *metadata_len;
 
     if (metadata_->__isset.created_by) {
@@ -705,7 +706,7 @@ class FileMetaData::FileMetaDataImpl {
                      encryption::kGcmTagLength));
     } else {  // either plaintext file (when encryptor is null)
       // or encrypted file with encrypted footer
-      serializer.Serialize(metadata_.get(), dst, encryptor);
+      serializer.Serialize(metadata_.get(), dst, encryptor.get());
     }
   }
 
diff --git a/cpp/src/parquet/metadata.h b/cpp/src/parquet/metadata.h
index e62b2d187a20b..6609cff48bac2 100644
--- a/cpp/src/parquet/metadata.h
+++ b/cpp/src/parquet/metadata.h
@@ -25,6 +25,7 @@
 #include <utility>
 #include <vector>
 
+#include "parquet/encryption/type_fwd.h"
 #include "parquet/platform.h"
 #include "parquet/properties.h"
 #include "parquet/schema.h"
@@ -34,15 +35,10 @@ namespace parquet {
 
 class ColumnDescriptor;
 class EncodedStatistics;
+class FileCryptoMetaData;
 class Statistics;
 class SchemaDescriptor;
 
-class FileCryptoMetaData;
-class InternalFileDecryptor;
-class Decryptor;
-class Encryptor;
-class FooterSigningEncryptor;
-
 namespace schema {
 
 class ColumnPath;
diff --git a/cpp/src/parquet/page_index.cc b/cpp/src/parquet/page_index.cc
index 9bae90e5540bd..ec99af17f05a1 100644
--- a/cpp/src/parquet/page_index.cc
+++ b/cpp/src/parquet/page_index.cc
@@ -17,6 +17,9 @@
 
 #include "parquet/page_index.h"
 #include "parquet/encoding.h"
+#include "parquet/encryption/encryption_internal.h"
+#include "parquet/encryption/internal_file_decryptor.h"
+#include "parquet/encryption/internal_file_encryptor.h"
 #include "parquet/exception.h"
 #include "parquet/metadata.h"
 #include "parquet/schema.h"
@@ -192,13 +195,13 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
                               const ReaderProperties& properties,
                               int32_t row_group_ordinal,
                               const RowGroupIndexReadRange& index_read_range,
-                              std::shared_ptr<InternalFileDecryptor> file_decryptor)
+                              InternalFileDecryptor* file_decryptor)
       : input_(input),
         row_group_metadata_(std::move(row_group_metadata)),
         properties_(properties),
         row_group_ordinal_(row_group_ordinal),
         index_read_range_(index_read_range),
-        file_decryptor_(std::move(file_decryptor)) {}
+        file_decryptor_(file_decryptor) {}
 
   /// Read column index of a column chunk.
   std::shared_ptr<ColumnIndex> GetColumnIndex(int32_t i) override {
@@ -207,11 +210,6 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
     }
 
     auto col_chunk = row_group_metadata_->ColumnChunk(i);
-    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata = col_chunk->crypto_metadata();
-    if (crypto_metadata != nullptr) {
-      ParquetException::NYI("Cannot read encrypted column index yet");
-    }
-
     auto column_index_location = col_chunk->GetColumnIndexLocation();
     if (!column_index_location.has_value()) {
       return nullptr;
@@ -232,8 +230,17 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
     // uint32_t
     uint32_t length = static_cast<uint32_t>(column_index_location->length);
     auto descr = row_group_metadata_->schema()->Column(i);
+
+    // Get decryptor of column index if encrypted.
+    std::shared_ptr<Decryptor> decryptor = parquet::GetColumnMetaDecryptor(
+        col_chunk->crypto_metadata().get(), file_decryptor_);
+    if (decryptor != nullptr) {
+      UpdateDecryptor(decryptor, row_group_ordinal_, /*column_ordinal=*/i,
+                      encryption::kColumnIndex);
+    }
+
     return ColumnIndex::Make(*descr, column_index_buffer_->data() + buffer_offset, length,
-                             properties_);
+                             properties_, decryptor.get());
   }
 
   /// Read offset index of a column chunk.
@@ -243,11 +250,6 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
     }
 
     auto col_chunk = row_group_metadata_->ColumnChunk(i);
-    std::unique_ptr<ColumnCryptoMetaData> crypto_metadata = col_chunk->crypto_metadata();
-    if (crypto_metadata != nullptr) {
-      ParquetException::NYI("Cannot read encrypted offset index yet");
-    }
-
     auto offset_index_location = col_chunk->GetOffsetIndexLocation();
     if (!offset_index_location.has_value()) {
       return nullptr;
@@ -267,8 +269,17 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
     // OffsetIndex::Make() requires the type of serialized thrift message to be
     // uint32_t
     uint32_t length = static_cast<uint32_t>(offset_index_location->length);
+
+    // Get decryptor of offset index if encrypted.
+    std::shared_ptr<Decryptor> decryptor =
+        GetColumnMetaDecryptor(col_chunk->crypto_metadata().get(), file_decryptor_);
+    if (decryptor != nullptr) {
+      UpdateDecryptor(decryptor, row_group_ordinal_, /*column_ordinal=*/i,
+                      encryption::kOffsetIndex);
+    }
+
     return OffsetIndex::Make(offset_index_buffer_->data() + buffer_offset, length,
-                             properties_);
+                             properties_, decryptor.get());
   }
 
  private:
@@ -325,7 +336,7 @@ class RowGroupPageIndexReaderImpl : public RowGroupPageIndexReader {
   RowGroupIndexReadRange index_read_range_;
 
   /// File-level decryptor.
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  InternalFileDecryptor* file_decryptor_;
 
   /// Buffer to hold the raw bytes of the page index.
   /// Will be set lazily when the corresponding page index is accessed for the 1st time.
@@ -338,11 +349,11 @@ class PageIndexReaderImpl : public PageIndexReader {
   PageIndexReaderImpl(::arrow::io::RandomAccessFile* input,
                       std::shared_ptr<FileMetaData> file_metadata,
                       const ReaderProperties& properties,
-                      std::shared_ptr<InternalFileDecryptor> file_decryptor)
+                      InternalFileDecryptor* file_decryptor)
       : input_(input),
         file_metadata_(std::move(file_metadata)),
         properties_(properties),
-        file_decryptor_(std::move(file_decryptor)) {}
+        file_decryptor_(file_decryptor) {}
 
   std::shared_ptr<RowGroupPageIndexReader> RowGroup(int i) override {
     if (i < 0 || i >= file_metadata_->num_row_groups()) {
@@ -418,7 +429,7 @@ class PageIndexReaderImpl : public PageIndexReader {
   const ReaderProperties& properties_;
 
   /// File-level decrypter.
-  std::shared_ptr<InternalFileDecryptor> file_decryptor_;
+  InternalFileDecryptor* file_decryptor_;
 
   /// Coalesced read ranges of page index of row groups that have been suggested by
   /// WillNeed(). Key is the row group ordinal.
@@ -524,9 +535,9 @@ class ColumnIndexBuilderImpl final : public ColumnIndexBuilder {
     column_index_.__set_boundary_order(ToThrift(boundary_order));
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink) const override {
+  void WriteTo(::arrow::io::OutputStream* sink, Encryptor* encryptor) const override {
     if (state_ == BuilderState::kFinished) {
-      ThriftSerializer{}.Serialize(&column_index_, sink);
+      ThriftSerializer{}.Serialize(&column_index_, sink, encryptor);
     }
   }
 
@@ -634,9 +645,9 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
     }
   }
 
-  void WriteTo(::arrow::io::OutputStream* sink) const override {
+  void WriteTo(::arrow::io::OutputStream* sink, Encryptor* encryptor) const override {
     if (state_ == BuilderState::kFinished) {
-      ThriftSerializer{}.Serialize(&offset_index_, sink);
+      ThriftSerializer{}.Serialize(&offset_index_, sink, encryptor);
     }
   }
 
@@ -654,7 +665,9 @@ class OffsetIndexBuilderImpl final : public OffsetIndexBuilder {
 
 class PageIndexBuilderImpl final : public PageIndexBuilder {
  public:
-  explicit PageIndexBuilderImpl(const SchemaDescriptor* schema) : schema_(schema) {}
+  explicit PageIndexBuilderImpl(const SchemaDescriptor* schema,
+                                InternalFileEncryptor* file_encryptor)
+      : schema_(schema), file_encryptor_(file_encryptor) {}
 
   void AppendRowGroup() override {
     if (finished_) {
@@ -724,12 +737,31 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
     }
   }
 
+  std::shared_ptr<Encryptor> GetColumnMetaEncryptor(int row_group_ordinal,
+                                                    int column_ordinal,
+                                                    int8_t module_type) const {
+    std::shared_ptr<Encryptor> encryptor;
+    if (file_encryptor_ != nullptr) {
+      const auto column_path = schema_->Column(column_ordinal)->path()->ToDotString();
+      encryptor = file_encryptor_->GetColumnMetaEncryptor(column_path);
+      if (encryptor != nullptr) {
+        encryptor->UpdateAad(encryption::CreateModuleAad(
+            encryptor->file_aad(), module_type, row_group_ordinal, column_ordinal,
+            kNonPageOrdinal));
+      }
+    }
+    return encryptor;
+  }
+
   template <typename Builder>
   void SerializeIndex(
       const std::vector<std::vector<std::unique_ptr<Builder>>>& page_index_builders,
       ::arrow::io::OutputStream* sink,
       std::map<size_t, std::vector<std::optional<IndexLocation>>>* location) const {
     const auto num_columns = static_cast<size_t>(schema_->num_columns());
+    constexpr int8_t module_type = std::is_same_v<Builder, ColumnIndexBuilder>
+                                       ? encryption::kColumnIndex
+                                       : encryption::kOffsetIndex;
 
     /// Serialize the same kind of page index row group by row group.
     for (size_t row_group = 0; row_group < page_index_builders.size(); ++row_group) {
@@ -743,9 +775,13 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
       for (size_t column = 0; column < num_columns; ++column) {
         const auto& column_page_index_builder = row_group_page_index_builders[column];
         if (column_page_index_builder != nullptr) {
+          /// Get encryptor if encryption is enabled.
+          std::shared_ptr<Encryptor> encryptor = GetColumnMetaEncryptor(
+              static_cast<int>(row_group), static_cast<int>(column), module_type);
+
           /// Try serializing the page index.
           PARQUET_ASSIGN_OR_THROW(int64_t pos_before_write, sink->Tell());
-          column_page_index_builder->WriteTo(sink);
+          column_page_index_builder->WriteTo(sink, encryptor.get());
           PARQUET_ASSIGN_OR_THROW(int64_t pos_after_write, sink->Tell());
           int64_t len = pos_after_write - pos_before_write;
 
@@ -769,6 +805,7 @@ class PageIndexBuilderImpl final : public PageIndexBuilder {
   }
 
   const SchemaDescriptor* schema_;
+  InternalFileEncryptor* file_encryptor_;
   std::vector<std::vector<std::unique_ptr<ColumnIndexBuilder>>> column_index_builders_;
   std::vector<std::vector<std::unique_ptr<OffsetIndexBuilder>>> offset_index_builders_;
   bool finished_ = false;
@@ -832,11 +869,12 @@ RowGroupIndexReadRange PageIndexReader::DeterminePageIndexRangesInRowGroup(
 std::unique_ptr<ColumnIndex> ColumnIndex::Make(const ColumnDescriptor& descr,
                                                const void* serialized_index,
                                                uint32_t index_len,
-                                               const ReaderProperties& properties) {
+                                               const ReaderProperties& properties,
+                                               Decryptor* decryptor) {
   format::ColumnIndex column_index;
   ThriftDeserializer deserializer(properties);
   deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(serialized_index),
-                                  &index_len, &column_index);
+                                  &index_len, &column_index, decryptor);
   switch (descr.physical_type()) {
     case Type::BOOLEAN:
       return std::make_unique<TypedColumnIndexImpl<BooleanType>>(descr,
@@ -871,20 +909,20 @@ std::unique_ptr<ColumnIndex> ColumnIndex::Make(const ColumnDescriptor& descr,
 
 std::unique_ptr<OffsetIndex> OffsetIndex::Make(const void* serialized_index,
                                                uint32_t index_len,
-                                               const ReaderProperties& properties) {
+                                               const ReaderProperties& properties,
+                                               Decryptor* decryptor) {
   format::OffsetIndex offset_index;
   ThriftDeserializer deserializer(properties);
   deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(serialized_index),
-                                  &index_len, &offset_index);
+                                  &index_len, &offset_index, decryptor);
   return std::make_unique<OffsetIndexImpl>(offset_index);
 }
 
 std::shared_ptr<PageIndexReader> PageIndexReader::Make(
     ::arrow::io::RandomAccessFile* input, std::shared_ptr<FileMetaData> file_metadata,
-    const ReaderProperties& properties,
-    std::shared_ptr<InternalFileDecryptor> file_decryptor) {
+    const ReaderProperties& properties, InternalFileDecryptor* file_decryptor) {
   return std::make_shared<PageIndexReaderImpl>(input, std::move(file_metadata),
-                                               properties, std::move(file_decryptor));
+                                               properties, file_decryptor);
 }
 
 std::unique_ptr<ColumnIndexBuilder> ColumnIndexBuilder::Make(
@@ -917,8 +955,9 @@ std::unique_ptr<OffsetIndexBuilder> OffsetIndexBuilder::Make() {
   return std::make_unique<OffsetIndexBuilderImpl>();
 }
 
-std::unique_ptr<PageIndexBuilder> PageIndexBuilder::Make(const SchemaDescriptor* schema) {
-  return std::make_unique<PageIndexBuilderImpl>(schema);
+std::unique_ptr<PageIndexBuilder> PageIndexBuilder::Make(
+    const SchemaDescriptor* schema, InternalFileEncryptor* file_encryptor) {
+  return std::make_unique<PageIndexBuilderImpl>(schema, file_encryptor);
 }
 
 std::ostream& operator<<(std::ostream& out, const PageIndexSelection& selection) {
diff --git a/cpp/src/parquet/page_index.h b/cpp/src/parquet/page_index.h
index b6ea5fd6abc08..f2ed77cb97c3b 100644
--- a/cpp/src/parquet/page_index.h
+++ b/cpp/src/parquet/page_index.h
@@ -18,6 +18,7 @@
 #pragma once
 
 #include "arrow/io/interfaces.h"
+#include "parquet/encryption/type_fwd.h"
 #include "parquet/types.h"
 
 #include <optional>
@@ -25,14 +26,8 @@
 
 namespace parquet {
 
-class ColumnDescriptor;
 class EncodedStatistics;
-class FileMetaData;
-class InternalFileDecryptor;
 struct PageIndexLocation;
-class ReaderProperties;
-class RowGroupMetaData;
-class RowGroupPageIndexReader;
 
 /// \brief ColumnIndex is a proxy around format::ColumnIndex.
 class PARQUET_EXPORT ColumnIndex {
@@ -41,7 +36,8 @@ class PARQUET_EXPORT ColumnIndex {
   static std::unique_ptr<ColumnIndex> Make(const ColumnDescriptor& descr,
                                            const void* serialized_index,
                                            uint32_t index_len,
-                                           const ReaderProperties& properties);
+                                           const ReaderProperties& properties,
+                                           Decryptor* decryptor = NULLPTR);
 
   virtual ~ColumnIndex() = default;
 
@@ -126,7 +122,8 @@ class PARQUET_EXPORT OffsetIndex {
   /// \brief Create a OffsetIndex from a serialized thrift message.
   static std::unique_ptr<OffsetIndex> Make(const void* serialized_index,
                                            uint32_t index_len,
-                                           const ReaderProperties& properties);
+                                           const ReaderProperties& properties,
+                                           Decryptor* decryptor = NULLPTR);
 
   virtual ~OffsetIndex() = default;
 
@@ -187,7 +184,7 @@ class PARQUET_EXPORT PageIndexReader {
   static std::shared_ptr<PageIndexReader> Make(
       ::arrow::io::RandomAccessFile* input, std::shared_ptr<FileMetaData> file_metadata,
       const ReaderProperties& properties,
-      std::shared_ptr<InternalFileDecryptor> file_decryptor = NULLPTR);
+      InternalFileDecryptor* file_decryptor = NULLPTR);
 
   /// \brief Get the page index reader of a specific row group.
   /// \param[in] i row group ordinal to get page index reader.
@@ -283,7 +280,9 @@ class PARQUET_EXPORT ColumnIndexBuilder {
   /// not write any data to the sink.
   ///
   /// \param[out] sink output stream to write the serialized message.
-  virtual void WriteTo(::arrow::io::OutputStream* sink) const = 0;
+  /// \param[in] encryptor encryptor to encrypt the serialized column index.
+  virtual void WriteTo(::arrow::io::OutputStream* sink,
+                       Encryptor* encryptor = NULLPTR) const = 0;
 
   /// \brief Create a ColumnIndex directly.
   ///
@@ -322,7 +321,9 @@ class PARQUET_EXPORT OffsetIndexBuilder {
   /// \brief Serialize the offset index thrift message.
   ///
   /// \param[out] sink output stream to write the serialized message.
-  virtual void WriteTo(::arrow::io::OutputStream* sink) const = 0;
+  /// \param[in] encryptor encryptor to encrypt the serialized offset index.
+  virtual void WriteTo(::arrow::io::OutputStream* sink,
+                       Encryptor* encryptor = NULLPTR) const = 0;
 
   /// \brief Create an OffsetIndex directly.
   virtual std::unique_ptr<OffsetIndex> Build() const = 0;
@@ -332,7 +333,8 @@ class PARQUET_EXPORT OffsetIndexBuilder {
 class PARQUET_EXPORT PageIndexBuilder {
  public:
   /// \brief API convenience to create a PageIndexBuilder.
-  static std::unique_ptr<PageIndexBuilder> Make(const SchemaDescriptor* schema);
+  static std::unique_ptr<PageIndexBuilder> Make(
+      const SchemaDescriptor* schema, InternalFileEncryptor* file_encryptor = NULLPTR);
 
   virtual ~PageIndexBuilder() = default;
 
diff --git a/cpp/src/parquet/thrift_internal.h b/cpp/src/parquet/thrift_internal.h
index 5824a82d5b86d..7491f118d32a0 100644
--- a/cpp/src/parquet/thrift_internal.h
+++ b/cpp/src/parquet/thrift_internal.h
@@ -403,7 +403,7 @@ class ThriftDeserializer {
   // set to the actual length of the header.
   template <class T>
   void DeserializeMessage(const uint8_t* buf, uint32_t* len, T* deserialized_msg,
-                          const std::shared_ptr<Decryptor>& decryptor = NULLPTR) {
+                          Decryptor* decryptor = NULLPTR) {
     if (decryptor == NULLPTR) {
       // thrift message is not encrypted
       DeserializeUnencryptedMessage(buf, len, deserialized_msg);
@@ -495,7 +495,7 @@ class ThriftSerializer {
 
   template <class T>
   int64_t Serialize(const T* obj, ArrowOutputStream* out,
-                    const std::shared_ptr<Encryptor>& encryptor = NULLPTR) {
+                    Encryptor* encryptor = NULLPTR) {
     uint8_t* out_buffer;
     uint32_t out_length;
     SerializeToBuffer(obj, &out_length, &out_buffer);
@@ -523,8 +523,7 @@ class ThriftSerializer {
   }
 
   int64_t SerializeEncryptedObj(ArrowOutputStream* out, uint8_t* out_buffer,
-                                uint32_t out_length,
-                                const std::shared_ptr<Encryptor>& encryptor) {
+                                uint32_t out_length, Encryptor* encryptor) {
     auto cipher_buffer = std::static_pointer_cast<ResizableBuffer>(AllocateBuffer(
         encryptor->pool(),
         static_cast<int64_t>(encryptor->CiphertextSizeDelta() + out_length)));
diff --git a/cpp/src/parquet/type_fwd.h b/cpp/src/parquet/type_fwd.h
index 3e66f32fc0322..da0d0f7bdee96 100644
--- a/cpp/src/parquet/type_fwd.h
+++ b/cpp/src/parquet/type_fwd.h
@@ -69,6 +69,9 @@ struct ParquetVersion {
 };
 
 class FileMetaData;
+class RowGroupMetaData;
+
+class ColumnDescriptor;
 class SchemaDescriptor;
 
 class ReaderProperties;

From e9730f5971480b942c7394846162c4dfa9145aa9 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 28 Sep 2023 18:24:26 +0200
Subject: [PATCH 426/749] GH-37934: [Doc][Integration] Document C Data
 Interface testing (#37935)

### Rationale for this change

gh-37537 added integration testing for the C Data Interface, but the documentation was not updated.

### What changes are included in this PR?

Add documentation for C Data Interface integration testing.

### Are these changes tested?

N/A, only doc changes.

### Are there any user-facing changes?

No.
* Closes: #37934

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 docs/source/developers/java/development.rst |  10 +-
 docs/source/format/Integration.rst          | 114 ++++++++++++++++----
 2 files changed, 97 insertions(+), 27 deletions(-)

diff --git a/docs/source/developers/java/development.rst b/docs/source/developers/java/development.rst
index 1094d02f1c140..ce7e1704f641c 100644
--- a/docs/source/developers/java/development.rst
+++ b/docs/source/developers/java/development.rst
@@ -84,11 +84,13 @@ UI Benchmark:
 Integration Testing
 ===================
 
-Integration tests can be run via Archery:
+Integration tests can be run :ref:`via Archery <running_integration_tests>`.
+For example, assuming you only built Arrow Java and want to run the IPC
+integration tests, you would do:
 
-.. code-block::
+.. code-block:: console
 
-    $ archery integration --with-java true --with-cpp false --with-js false --with-csharp false --with-go false --with-rust false
+   $ archery integration --run-ipc --with-java 1
 
 Code Style
 ==========
@@ -104,4 +106,4 @@ This checks the code style of all source code under the current directory or fro
 .. _benchmark: https://github.com/ursacomputing/benchmarks
 .. _archery: https://github.com/apache/arrow/blob/main/dev/conbench_envs/README.md#L188
 .. _conbench: https://github.com/conbench/conbench
-.. _checkstyle: https://github.com/apache/arrow/blob/main/java/dev/checkstyle/checkstyle.xml
\ No newline at end of file
+.. _checkstyle: https://github.com/apache/arrow/blob/main/java/dev/checkstyle/checkstyle.xml
diff --git a/docs/source/format/Integration.rst b/docs/source/format/Integration.rst
index 5f2341b9c469c..e1160b287e77c 100644
--- a/docs/source/format/Integration.rst
+++ b/docs/source/format/Integration.rst
@@ -20,32 +20,98 @@
 Integration Testing
 ===================
 
+To ensure Arrow implementations are interoperable between each other,
+the Arrow project includes cross-language integration tests which are
+regularly run as Continuous Integration tasks.
+
+The integration tests exercise compliance with several Arrow specifications:
+the :ref:`IPC format <format-ipc>`, the :ref:`Flight RPC <flight-rpc>` protocol,
+and the :ref:`C Data Interface <c-data-interface>`.
+
+Strategy
+--------
+
 Our strategy for integration testing between Arrow implementations is:
 
-* Test datasets are specified in a custom human-readable, JSON-based format
-  designed exclusively for Arrow's integration tests
-* Each implementation provides a testing executable capable of converting
-  between the JSON and the binary Arrow file representation
-* Each testing executable is used to generate binary Arrow file representations
-  from the JSON-based test datasets. These results are then used to call the
-  testing executable of each other implementation to validate the contents
-  against the corresponding JSON file.
-  - *ie.* the C++ testing executable generates binary arrow files from JSON
-  specified datasets. The resulting files are then used as input to the Java
-  testing executable for validation, confirming that the Java implementation 
-  can correctly read what the C++ implementation wrote.
+* Test datasets are specified in a custom human-readable,
+  :ref:`JSON-based format <format_json_integration>` designed exclusively
+  for Arrow's integration tests.
+
+* The JSON files are generated by the integration test harness. Different
+  files are used to represent different data types and features, such as
+  numerics, lists, dictionary encoding, etc. This makes it easier to pinpoint
+  incompatibilities than if all data types were represented in a single file.
+
+* Each implementation provides entry points capable of converting
+  between the JSON and the Arrow in-memory representation, and of exposing
+  Arrow in-memory data using the desired format.
+
+* Each format (whether Arrow IPC, Flight or the C Data Interface) is tested for
+  all supported pairs of (producer, consumer) implementations. The producer
+  typically reads a JSON file, converts it to in-memory Arrow data, and exposes
+  this data using the format under test. The consumer reads the data in the
+  said format and converts it back to Arrow in-memory data; it also reads
+  the same JSON file as the producer, and validates that both datasets are
+  identical.
+
+Example: IPC format
+~~~~~~~~~~~~~~~~~~~
+
+Let's say we are testing Arrow C++ as a producer and Arrow Java as a consumer
+of the Arrow IPC format. Testing a JSON file would go as follows:
+
+#. A C++ executable reads the JSON file, converts it into Arrow in-memory data
+   and writes an Arrow IPC file (the file paths are typically given on the command
+   line).
+
+#. A Java executable reads the JSON file, converts it into Arrow in-memory data;
+   it also reads the Arrow IPC file generated by C++. Finally, it validates that
+   both Arrow in-memory datasets are equal.
+
+Example: C Data Interface
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now, let's say we are testing Arrow Go as a producer and Arrow C# as a consumer
+of the Arrow C Data Interface.
+
+#. The integration testing harness allocates a C
+   :ref:`ArrowArray <c-data-interface-struct-defs>` structure on the heap.
+
+#. A Go in-process entrypoint (for example a C-compatible function call)
+   reads a JSON file and exports one of its :term:`record batches <record batch>`
+   into the ``ArrowArray`` structure.
+
+#. A C# in-process entrypoint reads the same JSON file, converts the
+   same record batch into Arrow in-memory data; it also imports the
+   record batch exported by Arrow Go in the ``ArrowArray`` structure.
+   It validates that both record batches are equal, and then releases the
+   imported record batch.
+
+#. Depending on the implementation languages' abilities, the integration
+   testing harness may assert that memory consumption remained identical
+   (i.e., that the exported record batch didn't leak).
+
+#. At the end, the integration testing harness deallocates the ``ArrowArray``
+   structure.
+
+.. _running_integration_tests:
 
 Running integration tests
 -------------------------
 
 The integration test data generator and runner are implemented inside
-the :ref:`Archery <archery>` utility.
+the :ref:`Archery <archery>` utility. You need to install the ``integration``
+component of archery:
+
+.. code:: console
+
+   $ pip install -e "dev/archery[integration]"
 
 The integration tests are run using the ``archery integration`` command.
 
-.. code-block:: shell
+.. code-block:: console
 
-   archery integration --help
+   $ archery integration --help
 
 In order to run integration tests, you'll first need to build each component
 you want to include. See the respective developer docs for C++, Java, etc.
@@ -56,26 +122,26 @@ testing. For C++, for example, you need to add ``-DARROW_BUILD_INTEGRATION=ON``
 to your cmake command.
 
 Depending on which components you have built, you can enable and add them to
-the archery test run. For example, if you only have the C++ project built, run:
+the archery test run. For example, if you only have the C++ project built
+and want to run the Arrow IPC integration tests, run:
 
 .. code-block:: shell
 
-   archery integration --with-cpp=1
-
+   archery integration --run-ipc --with-cpp=1
 
 For Java, it may look like:
 
 .. code-block:: shell
 
-   VERSION=0.11.0-SNAPSHOT
+   VERSION=14.0.0-SNAPSHOT
    export ARROW_JAVA_INTEGRATION_JAR=$JAVA_DIR/tools/target/arrow-tools-$VERSION-jar-with-dependencies.jar
-   archery integration --with-cpp=1 --with-java=1
+   archery integration --run-ipc --with-cpp=1 --with-java=1
 
-To run all tests, including Flight integration tests, do:
+To run all tests, including Flight and C Data Interface integration tests, do:
 
 .. code-block:: shell
 
-   archery integration --with-all --run-flight
+   archery integration --with-all --run-flight --run-ipc --run-c-data
 
 Note that we run these tests in continuous integration, and the CI job uses
 docker-compose. You may also run the docker-compose job locally, or at least
@@ -85,6 +151,8 @@ certain tests.
 See :ref:`docker-builds` for more information about the project's
 ``docker-compose`` configuration.
 
+.. _format_json_integration:
+
 JSON test data format
 ---------------------
 
@@ -415,7 +483,7 @@ will have count 28.
 For "null" type, ``BufferData`` does not contain any buffers.
 
 Archery Integration Test Cases
---------------------------------------
+------------------------------
 
 This list can make it easier to understand what manual testing may need to
 be done for any future Arrow Format changes by knowing what cases the automated

From 79abb7362f671f484675b89f19566df861c45f6f Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 28 Sep 2023 21:40:45 +0100
Subject: [PATCH 427/749] GH-37842: [R] Implement infer_schema.data.frame()
 (#37843)

### Rationale for this change

Users will be able to easily see the schema which their `data.frame` object will have when it's converted into an Arrwo table.

### What changes are included in this PR?

Implements `infer_schema()` method for `data.frame` objects.

Before:

``` r
library(arrow)
schema(mtcars)
#> Error in UseMethod("infer_schema"): no applicable method for 'infer_schema' applied to an object of class "data.frame"
```
After:

``` r
library(arrow)
schema(mtcars)
#> Schema
#> mpg: double
#> cyl: double
#> disp: double
#> hp: double
#> drat: double
#> wt: double
#> qsec: double
#> vs: double
#> am: double
#> gear: double
#> carb: double
#>
#> See $metadata for additional Schema metadata
```

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes
* Closes: #37842

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                    | 1 +
 r/R/schema.R                   | 3 +++
 r/tests/testthat/test-schema.R | 5 +++++
 3 files changed, 9 insertions(+)

diff --git a/r/NAMESPACE b/r/NAMESPACE
index 21f88b4180d24..d49255f781f94 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -112,6 +112,7 @@ S3method(infer_schema,ArrowTabular)
 S3method(infer_schema,Dataset)
 S3method(infer_schema,RecordBatchReader)
 S3method(infer_schema,arrow_dplyr_query)
+S3method(infer_schema,data.frame)
 S3method(infer_type,ArrowDatum)
 S3method(infer_type,Expression)
 S3method(infer_type,blob)
diff --git a/r/R/schema.R b/r/R/schema.R
index 1ad18e314191e..ac0604b2b345c 100644
--- a/r/R/schema.R
+++ b/r/R/schema.R
@@ -285,6 +285,9 @@ infer_schema.Dataset <- function(x) x$schema
 #' @export
 infer_schema.arrow_dplyr_query <- function(x) implicit_schema(x)
 
+#' @export
+infer_schema.data.frame <- function(x) schema(!!!lapply(x, infer_type))
+
 #' @export
 names.Schema <- function(x) x$names
 
diff --git a/r/tests/testthat/test-schema.R b/r/tests/testthat/test-schema.R
index db91cee330960..b1dc06592955e 100644
--- a/r/tests/testthat/test-schema.R
+++ b/r/tests/testthat/test-schema.R
@@ -295,9 +295,14 @@ test_that("schema name assignment", {
 
 test_that("schema extraction", {
   skip_if_not_available("dataset")
+
   tbl <- arrow_table(example_data)
+  expect_equal(schema(example_data), tbl$schema)
   expect_equal(schema(tbl), tbl$schema)
 
+  expect_equal(schema(data.frame(a = 1, a = "x", check.names = FALSE)), schema(a = double(), a = string()))
+  expect_equal(schema(data.frame()), schema())
+
   ds <- InMemoryDataset$create(example_data)
   expect_equal(schema(ds), ds$schema)
 

From 9d3806a27747241c5daf2ecc901986c16962ead2 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Thu, 28 Sep 2023 21:41:56 +0100
Subject: [PATCH 428/749] GH-34640: [R] Can't read in partitioning column in
 CSV datasets when both (non-hive) partition and schema supplied (#37658)

### Rationale for this change

It wasn't possible to use the partitioning column in the dataset when reading in CSV datasets and supplying both a schema and a partition variable.

### What changes are included in this PR?

This PR updates the code which creates the `CSVReadOptions` object and makes sure we don't pass in the partition variable column name as a column name there, as previously this was resulting in an error.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes

* Closes: #34640

Lead-authored-by: Nic Crane <thisisnic@gmail.com>
Co-authored-by: Dewey Dunnington <dewey@dunnington.ca>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/dataset-factory.R               |  2 +-
 r/R/dataset-format.R                | 31 +++++++++++++++-----------
 r/tests/testthat/test-dataset-csv.R | 34 +++++++++++++++++++++++++++++
 3 files changed, 53 insertions(+), 14 deletions(-)

diff --git a/r/R/dataset-factory.R b/r/R/dataset-factory.R
index adb7353a043b9..d3d4f639e3729 100644
--- a/r/R/dataset-factory.R
+++ b/r/R/dataset-factory.R
@@ -49,7 +49,7 @@ DatasetFactory$create <- function(x,
   }
 
   if (is.character(format)) {
-    format <- FileFormat$create(match.arg(format), ...)
+    format <- FileFormat$create(match.arg(format), partitioning = partitioning, ...)
   } else {
     assert_is(format, "FileFormat")
   }
diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R
index e1f434d60cd50..5dd00b9344014 100644
--- a/r/R/dataset-format.R
+++ b/r/R/dataset-format.R
@@ -74,13 +74,14 @@ FileFormat <- R6Class("FileFormat",
     type = function() dataset___FileFormat__type_name(self)
   )
 )
-FileFormat$create <- function(format, schema = NULL, ...) {
+
+FileFormat$create <- function(format, schema = NULL, partitioning = NULL, ...) {
   opt_names <- names(list(...))
   if (format %in% c("csv", "text", "txt") || any(opt_names %in% c("delim", "delimiter"))) {
-    CsvFileFormat$create(schema = schema, ...)
+    CsvFileFormat$create(schema = schema, partitioning = partitioning, ...)
   } else if (format == "tsv") {
     # This delimiter argument is ignored.
-    CsvFileFormat$create(delimiter = "\t", schema = schema, ...)
+    CsvFileFormat$create(delimiter = "\t", schema = schema, partitioning = partitioning, ...)
   } else if (format == "parquet") {
     ParquetFileFormat$create(...)
   } else if (format %in% c("ipc", "arrow", "feather")) { # These are aliases for the same thing
@@ -189,16 +190,19 @@ JsonFileFormat$create <- function(...) {
 #'
 #' @export
 CsvFileFormat <- R6Class("CsvFileFormat", inherit = FileFormat)
-CsvFileFormat$create <- function(...) {
+CsvFileFormat$create <- function(..., partitioning = NULL) {
+
   dots <- list(...)
-  options <- check_csv_file_format_args(dots)
-  check_schema(options[["schema"]], options[["read_options"]]$column_names)
+
+  options <- check_csv_file_format_args(dots, partitioning = partitioning)
+  check_schema(options[["schema"]], partitioning, options[["read_options"]]$column_names)
 
   dataset___CsvFileFormat__Make(options$parse_options, options$convert_options, options$read_options)
 }
 
 # Check all arguments are valid
-check_csv_file_format_args <- function(args) {
+check_csv_file_format_args <- function(args, partitioning = NULL) {
+
   options <- list(
     parse_options = args$parse_options,
     convert_options = args$convert_options,
@@ -223,7 +227,7 @@ check_csv_file_format_args <- function(args) {
   }
 
   if (is.null(args$read_options)) {
-    options$read_options <- do.call(csv_file_format_read_opts, args)
+    options$read_options <- do.call(csv_file_format_read_opts, c(args, list(partitioning = partitioning)))
   } else if (is.list(args$read_options)) {
     options$read_options <- do.call(CsvReadOptions$create, args$read_options)
   }
@@ -339,7 +343,7 @@ check_ambiguous_options <- function(passed_opts, opts1, opts2) {
   }
 }
 
-check_schema <- function(schema, column_names) {
+check_schema <- function(schema, partitioning, column_names) {
   if (!is.null(schema) && !inherits(schema, "Schema")) {
     abort(paste0(
       "`schema` must be an object of class 'Schema' not '",
@@ -348,7 +352,7 @@ check_schema <- function(schema, column_names) {
     ))
   }
 
-  schema_names <- names(schema)
+  schema_names <- setdiff(names(schema), names(partitioning))
 
   if (!is.null(schema) && !identical(schema_names, column_names)) {
     missing_from_schema <- setdiff(column_names, schema_names)
@@ -451,7 +455,8 @@ csv_file_format_convert_opts <- function(...) {
   do.call(CsvConvertOptions$create, opts)
 }
 
-csv_file_format_read_opts <- function(schema = NULL, ...) {
+csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) {
+
   opts <- list(...)
   # Filter out arguments meant for CsvParseOptions/CsvConvertOptions
   arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options")
@@ -477,9 +482,9 @@ csv_file_format_read_opts <- function(schema = NULL, ...) {
 
   if (!is.null(schema) && null_or_true(opts[["column_names"]]) && null_or_true(opts[["col_names"]])) {
     if (any(is_readr_opt)) {
-      opts[["col_names"]] <- names(schema)
+      opts[["col_names"]] <- setdiff(names(schema), names(partitioning))
     } else {
-      opts[["column_names"]] <- names(schema)
+      opts[["column_names"]] <- setdiff(names(schema), names(partitioning))
     }
   }
 
diff --git a/r/tests/testthat/test-dataset-csv.R b/r/tests/testthat/test-dataset-csv.R
index c83c30ff904ff..ff1712646a472 100644
--- a/r/tests/testthat/test-dataset-csv.R
+++ b/r/tests/testthat/test-dataset-csv.R
@@ -593,3 +593,37 @@ test_that("CSVReadOptions field access", {
   expect_equal(options$block_size, 1048576L)
   expect_equal(options$encoding, "UTF-8")
 })
+
+test_that("GH-34640 - CSV datasets are read in correctly when both schema and partitioning supplied", {
+  target_schema <- schema(
+    int = int32(), dbl = float32(), lgl = bool(), chr = utf8(),
+    fct = utf8(), ts = timestamp(unit = "s"), part = int8()
+  )
+
+  ds <- open_dataset(
+    csv_dir,
+    partitioning = schema(part = int32()),
+    format = "csv",
+    schema = target_schema,
+    skip = 1
+  )
+  expect_r6_class(ds$format, "CsvFileFormat")
+  expect_r6_class(ds$filesystem, "LocalFileSystem")
+  expect_identical(names(ds), c(names(df1), "part"))
+  expect_identical(names(collect(ds)), c(names(df1), "part"))
+
+  expect_identical(dim(ds), c(20L, 7L))
+  expect_equal(schema(ds), target_schema)
+
+  expect_equal(
+    ds %>%
+      select(string = chr, integer = int, part) %>%
+      filter(integer > 6 & part == 5) %>%
+      collect() %>%
+      summarize(mean = mean(as.numeric(integer))),
+    df1 %>%
+      select(string = chr, integer = int) %>%
+      filter(integer > 6) %>%
+      summarize(mean = mean(integer))
+  )
+})

From 3ceb2f1ed871afbecfc481e5cabfd5e846dc5cd6 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 28 Sep 2023 23:09:43 +0200
Subject: [PATCH 429/749] GH-37803: [Python][CI] Pin setuptools_scm to fix
 release verification scripts (#37930)

Follow-up on https://github.com/apache/arrow/pull/37819, which missed one place to add a pin for the release verification scripts
* Closes: #37803

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/verify-release-candidate.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 77b996766f78c..ae28ebe792404 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -666,7 +666,7 @@ test_python() {
   show_header "Build and test Python libraries"
 
   # Build and test Python
-  maybe_setup_virtualenv "cython<3" numpy setuptools_scm setuptools || exit 1
+  maybe_setup_virtualenv "cython<3" numpy "setuptools_scm<8.0.0" setuptools || exit 1
   maybe_setup_conda --file ci/conda_env_python.txt || exit 1
 
   if [ "${USE_CONDA}" -gt 0 ]; then

From befcc90defcc6b2fc35e8b3226b1ee38851e0cdc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Franti=C5=A1ek=20Ne=C4=8Das?=
 <frantisek.necas@protonmail.com>
Date: Thu, 28 Sep 2023 23:40:54 +0200
Subject: [PATCH 430/749] GH-21815: [JS] Add support for Duration type (#37341)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

The `Duration` type is currently not supported and trying to deserialize a Table containing the type (e.g. using `tableFromIPC`) fails with `Unrecognized type` error. This PR aims to fix that.

### What changes are included in this PR?

- definition of the `Duration` data type
- updates to the visitor classes so that things like parsing work correctly
- test coverage for the type
- documentation update

### Are these changes tested?

Yes, I extended the data generator with the new type so that the type is tested by the existing tests.

### Are there any user-facing changes?

Yes, I've updated the documentation status page. I also noticed that it was outdated for JavaScript, i.e. there is already support for `Decimal` type so I updated this as well.

Closes: https://github.com/apache/arrow/issues/21815
Closes: https://github.com/apache/arrow/issues/35439
* Closes: #21815

Lead-authored-by: František Necas <frantisek.necas@protonmail.com>
Co-authored-by: ptaylor <paul.e.taylor@me.com>
Signed-off-by: Dominik Moritz <domoritz@gmail.com>
---
 dev/archery/archery/integration/datagen.py |  3 +-
 docs/source/status.rst                     |  4 +-
 js/src/Arrow.dom.ts                        |  2 +
 js/src/Arrow.ts                            |  2 +
 js/src/builder.ts                          |  6 +--
 js/src/builder/duration.ts                 | 46 ++++++++++++++++++++++
 js/src/data.ts                             | 11 ++++++
 js/src/enum.ts                             |  7 +++-
 js/src/interfaces.ts                       | 16 ++++++++
 js/src/ipc/metadata/json.ts                |  6 ++-
 js/src/ipc/metadata/message.ts             |  7 +++-
 js/src/type.ts                             | 34 ++++++++++++++++
 js/src/visitor.ts                          | 27 ++++++++++++-
 js/src/visitor/builderctor.ts              |  6 +++
 js/src/visitor/bytelength.ts               |  5 ++-
 js/src/visitor/get.ts                      | 30 ++++++++++++++
 js/src/visitor/indexof.ts                  | 11 ++++++
 js/src/visitor/iterator.ts                 | 11 ++++++
 js/src/visitor/jsontypeassembler.ts        |  3 ++
 js/src/visitor/jsonvectorassembler.ts      |  6 ++-
 js/src/visitor/set.ts                      | 31 +++++++++++++++
 js/src/visitor/typeassembler.ts            |  6 +++
 js/src/visitor/typecomparator.ts           | 18 +++++++++
 js/src/visitor/typector.ts                 |  5 +++
 js/src/visitor/vectorassembler.ts          |  6 ++-
 js/src/visitor/vectorloader.ts             |  5 ++-
 js/test/data/tables.ts                     |  3 +-
 js/test/generate-test-data.ts              | 20 +++++++++-
 js/test/unit/builders/builder-tests.ts     |  4 ++
 js/test/unit/generated-data-tests.ts       |  4 ++
 js/test/unit/visitor-tests.ts              | 11 ++++++
 31 files changed, 338 insertions(+), 18 deletions(-)
 create mode 100644 js/src/builder/duration.ts

diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 299881c4b613a..8d0cc6b0b01a8 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1805,8 +1805,7 @@ def _temp_path():
         generate_datetime_case(),
 
         generate_duration_case()
-        .skip_tester('C#')
-        .skip_tester('JS'),  # TODO(ARROW-5239): Intervals + JS
+        .skip_tester('C#'),
 
         generate_interval_case()
         .skip_tester('C#')
diff --git a/docs/source/status.rst b/docs/source/status.rst
index 6314fd4c8d31f..e2b3852e2229f 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -46,7 +46,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Decimal128        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Decimal256        | ✓     | ✓     | ✓     |            |  ✓    |  ✓    | ✓     |       |
+| Decimal256        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Date32/64         | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -54,7 +54,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Timestamp         | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Duration          | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
+| Duration          | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Interval          | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
diff --git a/js/src/Arrow.dom.ts b/js/src/Arrow.dom.ts
index 2fdef60c1fb55..451bf6acb6186 100644
--- a/js/src/Arrow.dom.ts
+++ b/js/src/Arrow.dom.ts
@@ -59,6 +59,7 @@ export {
     Union, DenseUnion, SparseUnion,
     Dictionary,
     Interval, IntervalDayTime, IntervalYearMonth,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     FixedSizeList,
     Map_, MapRow,
     Table, makeTable, tableFromArrays,
@@ -86,6 +87,7 @@ export {
     FixedSizeListBuilder,
     FloatBuilder, Float16Builder, Float32Builder, Float64Builder,
     IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder,
+    DurationBuilder, DurationSecondBuilder, DurationMillisecondBuilder, DurationMicrosecondBuilder, DurationNanosecondBuilder,
     IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder,
     ListBuilder,
     MapBuilder,
diff --git a/js/src/Arrow.ts b/js/src/Arrow.ts
index 4a6394c266b1b..714861e764ccb 100644
--- a/js/src/Arrow.ts
+++ b/js/src/Arrow.ts
@@ -48,6 +48,7 @@ export {
     Union, DenseUnion, SparseUnion,
     Dictionary,
     Interval, IntervalDayTime, IntervalYearMonth,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     FixedSizeList,
     Map_
 } from './type.js';
@@ -75,6 +76,7 @@ export { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint
 export { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from './builder/time.js';
 export { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from './builder/timestamp.js';
 export { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from './builder/interval.js';
+export { DurationBuilder, DurationSecondBuilder, DurationMillisecondBuilder, DurationMicrosecondBuilder, DurationNanosecondBuilder } from './builder/duration.js';
 export { Utf8Builder } from './builder/utf8.js';
 export { BinaryBuilder } from './builder/binary.js';
 export { ListBuilder } from './builder/list.js';
diff --git a/js/src/builder.ts b/js/src/builder.ts
index 90fe3ddcc9477..93510eedf84ff 100644
--- a/js/src/builder.ts
+++ b/js/src/builder.ts
@@ -21,7 +21,7 @@ import { MapRow, kKeys } from './row/map.js';
 import {
     DataType, strideForType,
     Float, Int, Decimal, FixedSizeBinary,
-    Date_, Time, Timestamp, Interval,
+    Date_, Time, Timestamp, Interval, Duration,
     Utf8, Binary, List, Map_,
 } from './type.js';
 import { createIsValidFunction } from './builder/valid.js';
@@ -290,7 +290,7 @@ export abstract class Builder<T extends DataType = any, TNull = any> {
         } else if (valueOffsets = _offsets?.flush(length)) { // Variable-width primitives (Binary, Utf8), and Lists
             // Binary, Utf8
             data = _values?.flush(_offsets.last());
-        } else { // Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, and Interval)
+        } else { // Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, Duration and Interval)
             data = _values?.flush(length);
         }
 
@@ -342,7 +342,7 @@ export abstract class Builder<T extends DataType = any, TNull = any> {
 (Builder.prototype as any)._isValid = () => true;
 
 /** @ignore */
-export abstract class FixedWidthBuilder<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval = any, TNull = any> extends Builder<T, TNull> {
+export abstract class FixedWidthBuilder<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval | Duration = any, TNull = any> extends Builder<T, TNull> {
     constructor(opts: BuilderOptions<T, TNull>) {
         super(opts);
         this._values = new DataBufferBuilder(new this.ArrayType(0), this.stride);
diff --git a/js/src/builder/duration.ts b/js/src/builder/duration.ts
new file mode 100644
index 0000000000000..968899ea55b91
--- /dev/null
+++ b/js/src/builder/duration.ts
@@ -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.
+
+import { FixedWidthBuilder } from '../builder.js';
+import { Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond } from '../type.js';
+import { setDuration, setDurationSecond, setDurationMillisecond, setDurationMicrosecond, setDurationNanosecond } from '../visitor/set.js';
+
+/** @ignore */
+export class DurationBuilder<T extends Duration = Duration, TNull = any> extends FixedWidthBuilder<T, TNull> { }
+
+(DurationBuilder.prototype as any)._setValue = setDuration;
+
+/** @ignore */
+export class DurationSecondBuilder<TNull = any> extends DurationBuilder<DurationSecond, TNull> { }
+
+(DurationSecondBuilder.prototype as any)._setValue = setDurationSecond;
+
+/** @ignore */
+export class DurationMillisecondBuilder<TNull = any> extends DurationBuilder<DurationMillisecond, TNull> { }
+
+(DurationMillisecondBuilder.prototype as any)._setValue = setDurationMillisecond;
+
+/** @ignore */
+export class DurationMicrosecondBuilder<TNull = any> extends DurationBuilder<DurationMicrosecond, TNull> { }
+
+(DurationMicrosecondBuilder.prototype as any)._setValue = setDurationMicrosecond;
+
+/** @ignore */
+export class DurationNanosecondBuilder<TNull = any> extends DurationBuilder<DurationNanosecond, TNull> { }
+
+(DurationNanosecondBuilder.prototype as any)._setValue = setDurationNanosecond;
diff --git a/js/src/data.ts b/js/src/data.ts
index dc423cdb01e1c..1e9df71cff8a7 100644
--- a/js/src/data.ts
+++ b/js/src/data.ts
@@ -257,6 +257,7 @@ import {
     Int,
     Date_,
     Interval,
+    Duration,
     Time,
     Timestamp,
     Union, DenseUnion, SparseUnion,
@@ -390,6 +391,13 @@ class MakeDataVisitor extends Visitor {
         const { ['length']: length = data.length / strideForType(type), ['nullCount']: nullCount = props['nullBitmap'] ? -1 : 0, } = props;
         return new Data(type, offset, length, nullCount, [undefined, data, nullBitmap]);
     }
+    public visitDuration<T extends Duration>(props: DurationDataProps<T>) {
+        const { ['type']: type, ['offset']: offset = 0 } = props;
+        const nullBitmap = toUint8Array(props['nullBitmap']);
+        const data = toArrayBufferView(type.ArrayType, props['data']);
+        const { ['length']: length = data.length, ['nullCount']: nullCount = props['nullBitmap'] ? -1 : 0, } = props;
+        return new Data(type, offset, length, nullCount, [undefined, data, nullBitmap]);
+    }
     public visitFixedSizeList<T extends FixedSizeList>(props: FixedSizeListDataProps<T>) {
         const { ['type']: type, ['offset']: offset = 0, ['child']: child = new MakeDataVisitor().visit({ type: type.valueType }) } = props;
         const nullBitmap = toUint8Array(props['nullBitmap']);
@@ -424,6 +432,7 @@ interface Date_DataProps<T extends Date_> extends DataProps_<T> { data?: DataBuf
 interface TimeDataProps<T extends Time> extends DataProps_<T> { data?: DataBuffer<T> }
 interface TimestampDataProps<T extends Timestamp> extends DataProps_<T> { data?: DataBuffer<T> }
 interface IntervalDataProps<T extends Interval> extends DataProps_<T> { data?: DataBuffer<T> }
+interface DurationDataProps<T extends Duration> extends DataProps_<T> { data?: DataBuffer<T> }
 interface FixedSizeBinaryDataProps<T extends FixedSizeBinary> extends DataProps_<T> { data?: DataBuffer<T> }
 interface BinaryDataProps<T extends Binary> extends DataProps_<T> { valueOffsets: ValueOffsetsBuffer; data?: DataBuffer<T> }
 interface Utf8DataProps<T extends Utf8> extends DataProps_<T> { valueOffsets: ValueOffsetsBuffer; data?: DataBuffer<T> }
@@ -446,6 +455,7 @@ export type DataProps<T extends DataType> = (
     T extends Time /*            */ ? TimeDataProps<T> :
     T extends Timestamp /*       */ ? TimestampDataProps<T> :
     T extends Interval /*        */ ? IntervalDataProps<T> :
+    T extends Duration /*        */ ? DurationDataProps<T> :
     T extends FixedSizeBinary /* */ ? FixedSizeBinaryDataProps<T> :
     T extends Binary /*          */ ? BinaryDataProps<T> :
     T extends Utf8 /*            */ ? Utf8DataProps<T> :
@@ -471,6 +481,7 @@ export function makeData<T extends Date_>(props: Date_DataProps<T>): Data<T>;
 export function makeData<T extends Time>(props: TimeDataProps<T>): Data<T>;
 export function makeData<T extends Timestamp>(props: TimestampDataProps<T>): Data<T>;
 export function makeData<T extends Interval>(props: IntervalDataProps<T>): Data<T>;
+export function makeData<T extends Duration>(props: DurationDataProps<T>): Data<T>;
 export function makeData<T extends FixedSizeBinary>(props: FixedSizeBinaryDataProps<T>): Data<T>;
 export function makeData<T extends Binary>(props: BinaryDataProps<T>): Data<T>;
 export function makeData<T extends Utf8>(props: Utf8DataProps<T>): Data<T>;
diff --git a/js/src/enum.ts b/js/src/enum.ts
index f5856bc06afbe..4e207dd37cec1 100644
--- a/js/src/enum.ts
+++ b/js/src/enum.ts
@@ -137,7 +137,7 @@ export enum MessageHeader {
  * nested type consisting of other data types, or another data type (e.g. a
  * timestamp encoded as an int64).
  *
- * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow
+ * **Note**: Only enum values 0-18 (NONE through Duration) are written to an Arrow
  * IPC payload.
  *
  * The rest of the values are specified here so TypeScript can narrow the type
@@ -174,6 +174,7 @@ export enum Type {
     FixedSizeBinary = 15, /** Fixed-size binary. Each value occupies the same number of bytes */
     FixedSizeList = 16, /** Fixed-size list. Each value occupies the same number of bytes */
     Map = 17, /** Map of named logical types */
+    Duration = 18, /** Measure of elapsed time in either seconds, miliseconds, microseconds or nanoseconds. */
 
     Dictionary = -1, /** Dictionary aka Category type */
     Int8 = -2,
@@ -201,6 +202,10 @@ export enum Type {
     SparseUnion = -24,
     IntervalDayTime = -25,
     IntervalYearMonth = -26,
+    DurationSecond = -27,
+    DurationMillisecond = -28,
+    DurationMicrosecond = -29,
+    DurationNanosecond = -30
 }
 
 export enum BufferType {
diff --git a/js/src/interfaces.ts b/js/src/interfaces.ts
index 8d61295919046..95c5adbb2a25e 100644
--- a/js/src/interfaces.ts
+++ b/js/src/interfaces.ts
@@ -31,6 +31,7 @@ import type { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder,
 import type { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from './builder/time.js';
 import type { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from './builder/timestamp.js';
 import type { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from './builder/interval.js';
+import type { DurationBuilder, DurationSecondBuilder, DurationMillisecondBuilder, DurationMicrosecondBuilder, DurationNanosecondBuilder } from './builder/duration.js';
 import type { Utf8Builder } from './builder/utf8.js';
 import type { BinaryBuilder } from './builder/binary.js';
 import type { ListBuilder } from './builder/list.js';
@@ -222,6 +223,11 @@ export type TypeToDataType<T extends Type> = {
     [Type.Interval]: type.Interval;
     [Type.IntervalDayTime]: type.IntervalDayTime;
     [Type.IntervalYearMonth]: type.IntervalYearMonth;
+    [Type.Duration]: type.Duration;
+    [Type.DurationSecond]: type.DurationSecond;
+    [Type.DurationMillisecond]: type.DurationMillisecond;
+    [Type.DurationMicrosecond]: type.DurationMicrosecond;
+    [Type.DurationNanosecond]: type.DurationNanosecond;
     [Type.Map]: type.Map_;
     [Type.List]: type.List;
     [Type.Struct]: type.Struct;
@@ -270,6 +276,11 @@ type TypeToBuilder<T extends Type = any, TNull = any> = {
     [Type.Interval]: IntervalBuilder<any, TNull>;
     [Type.IntervalDayTime]: IntervalDayTimeBuilder<TNull>;
     [Type.IntervalYearMonth]: IntervalYearMonthBuilder<TNull>;
+    [Type.Duration]: DurationBuilder<any, TNull>;
+    [Type.DurationSecond]: DurationBuilder<any, TNull>;
+    [Type.DurationMillisecond]: DurationMillisecondBuilder<TNull>;
+    [Type.DurationMicrosecond]: DurationMicrosecondBuilder<TNull>;
+    [Type.DurationNanosecond]: DurationNanosecondBuilder<TNull>;
     [Type.Map]: MapBuilder<any, any, TNull>;
     [Type.List]: ListBuilder<any, TNull>;
     [Type.Struct]: StructBuilder<any, TNull>;
@@ -318,6 +329,11 @@ type DataTypeToBuilder<T extends DataType = any, TNull = any> = {
     [Type.Interval]: T extends type.Interval ? IntervalBuilder<T, TNull> : never;
     [Type.IntervalDayTime]: T extends type.IntervalDayTime ? IntervalDayTimeBuilder<TNull> : never;
     [Type.IntervalYearMonth]: T extends type.IntervalYearMonth ? IntervalYearMonthBuilder<TNull> : never;
+    [Type.Duration]: T extends type.Duration ? DurationBuilder<T, TNull>: never;
+    [Type.DurationSecond]: T extends type.DurationSecond ? DurationSecondBuilder<TNull> : never;
+    [Type.DurationMillisecond]: T extends type.DurationMillisecond ? DurationMillisecondBuilder<TNull> : never;
+    [Type.DurationMicrosecond]: T extends type.DurationMicrosecond ? DurationMicrosecondBuilder<TNull>: never;
+    [Type.DurationNanosecond]: T extends type.DurationNanosecond ? DurationNanosecondBuilder<TNull>: never;
     [Type.Map]: T extends type.Map_ ? MapBuilder<T['keyType'], T['valueType'], TNull> : never;
     [Type.List]: T extends type.List ? ListBuilder<T['valueType'], TNull> : never;
     [Type.Struct]: T extends type.Struct ? StructBuilder<T['dataTypes'], TNull> : never;
diff --git a/js/src/ipc/metadata/json.ts b/js/src/ipc/metadata/json.ts
index e5995110f084b..f1f306730ddba 100644
--- a/js/src/ipc/metadata/json.ts
+++ b/js/src/ipc/metadata/json.ts
@@ -22,7 +22,7 @@ import {
     DataType, Dictionary, TimeBitWidth,
     Utf8, Binary, Decimal, FixedSizeBinary,
     List, FixedSizeList, Map_, Struct, Union,
-    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,
+    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys, Duration,
 } from '../../type.js';
 
 import { DictionaryBatch, RecordBatch, FieldNode, BufferRegion } from './message.js';
@@ -185,6 +185,10 @@ function typeFromJSON(f: any, children?: Field[]): DataType<any> {
             const t = f['type'];
             return new Interval(IntervalUnit[t['unit']] as any);
         }
+        case 'duration': {
+            const t = f['type'];
+            return new Duration(TimeUnit[t['unit']] as any);
+        }
         case 'union': {
             const t = f['type'];
             const [m, ...ms] = (t['mode'] + '').toLowerCase();
diff --git a/js/src/ipc/metadata/message.ts b/js/src/ipc/metadata/message.ts
index 6465d3d064720..27c9b92d6897b 100644
--- a/js/src/ipc/metadata/message.ts
+++ b/js/src/ipc/metadata/message.ts
@@ -36,6 +36,7 @@ import { Date as _Date } from '../../fb/date.js';
 import { Time as _Time } from '../../fb/time.js';
 import { Timestamp as _Timestamp } from '../../fb/timestamp.js';
 import { Interval as _Interval } from '../../fb/interval.js';
+import { Duration as _Duration } from '../../fb/duration.js';
 import { Union as _Union } from '../../fb/union.js';
 import { FixedSizeBinary as _FixedSizeBinary } from '../../fb/fixed-size-binary.js';
 import { FixedSizeList as _FixedSizeList } from '../../fb/fixed-size-list.js';
@@ -57,7 +58,7 @@ import {
     DataType, Dictionary, TimeBitWidth,
     Utf8, Binary, Decimal, FixedSizeBinary,
     List, FixedSizeList, Map_, Struct, Union,
-    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,
+    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys, Duration,
 } from '../../type.js';
 
 /**
@@ -466,6 +467,10 @@ function decodeFieldType(f: _Field, children?: Field[]): DataType<any> {
             const t = f.type(new _Interval())!;
             return new Interval(t.unit());
         }
+        case Type['Duration']: {
+            const t = f.type(new _Duration())!;
+            return new Duration(t.unit());
+        }
         case Type['Union']: {
             const t = f.type(new _Union())!;
             return new Union(t.mode(), t.typeIdsArray() || [], children || []);
diff --git a/js/src/type.ts b/js/src/type.ts
index 1dc90c47cbd10..34bbf45bca728 100644
--- a/js/src/type.ts
+++ b/js/src/type.ts
@@ -63,6 +63,7 @@ export abstract class DataType<TType extends Type = Type, TChildren extends Type
     /** @nocollapse */ static isTime(x: any): x is Time_ { return x?.typeId === Type.Time; }
     /** @nocollapse */ static isTimestamp(x: any): x is Timestamp_ { return x?.typeId === Type.Timestamp; }
     /** @nocollapse */ static isInterval(x: any): x is Interval_ { return x?.typeId === Type.Interval; }
+    /** @nocollapse */ static isDuration(x: any): x is Duration { return x?.typeId === Type.Duration; }
     /** @nocollapse */ static isList(x: any): x is List { return x?.typeId === Type.List; }
     /** @nocollapse */ static isStruct(x: any): x is Struct { return x?.typeId === Type.Struct; }
     /** @nocollapse */ static isUnion(x: any): x is Union_ { return x?.typeId === Type.Union; }
@@ -433,6 +434,39 @@ export class IntervalDayTime extends Interval_<Type.IntervalDayTime> { construct
 /** @ignore */
 export class IntervalYearMonth extends Interval_<Type.IntervalYearMonth> { constructor() { super(IntervalUnit.YEAR_MONTH); } }
 
+/** @ignore */
+type Durations = Type.Duration | Type.DurationSecond | Type.DurationMillisecond | Type.DurationMicrosecond | Type.DurationNanosecond;
+/** @ignore */
+export interface Duration<T extends Durations = Durations> extends DataType<T> {
+    TArray: BigInt64Array;
+    TValue: bigint;
+    ArrayType: BigInt64Array;
+}
+
+/** @ignore */
+export class Duration<T extends Durations = Durations> extends DataType<T> {
+    constructor(public readonly unit: TimeUnit) {
+        super();
+    }
+    public get typeId() { return Type.Duration as T; }
+    public toString() { return `Duration<${TimeUnit[this.unit]}>`; }
+    protected static [Symbol.toStringTag] = ((proto: Duration) => {
+        (<any>proto).unit = null;
+        (<any>proto).ArrayType = BigInt64Array;
+        return proto[Symbol.toStringTag] = 'Duration';
+    })(Duration.prototype);
+}
+
+/** @ignore */
+export class DurationSecond extends Duration<Type.DurationSecond> { constructor() { super(TimeUnit.SECOND); }}
+/** @ignore */
+export class DurationMillisecond extends Duration<Type.DurationMillisecond> { constructor() { super(TimeUnit.MILLISECOND); }}
+/** @ignore */
+export class DurationMicrosecond extends Duration<Type.DurationMicrosecond> { constructor() { super(TimeUnit.MICROSECOND); }}
+/** @ignore */
+export class DurationNanosecond extends Duration<Type.DurationNanosecond> { constructor() { super(TimeUnit.NANOSECOND); }}
+
+
 /** @ignore */
 export interface List<T extends DataType = any> extends DataType<Type.List, { [0]: T }> {
     TArray: Array<T>;
diff --git a/js/src/visitor.ts b/js/src/visitor.ts
index 3be50a6d3eacf..c63640b038e47 100644
--- a/js/src/visitor.ts
+++ b/js/src/visitor.ts
@@ -16,7 +16,7 @@
 // under the License.
 
 import { Type, Precision, DateUnit, TimeUnit, IntervalUnit, UnionMode } from './enum.js';
-import { DataType, Float, Int, Date_, Interval, Time, Timestamp, Union, } from './type.js';
+import { DataType, Float, Int, Date_, Interval, Time, Timestamp, Union, Duration } from './type.js';
 
 export abstract class Visitor {
     public visitMany(nodes: any[], ...args: any[][]) {
@@ -47,6 +47,7 @@ export abstract class Visitor {
     public visitUnion(_node: any, ..._args: any[]): any { return null; }
     public visitDictionary(_node: any, ..._args: any[]): any { return null; }
     public visitInterval(_node: any, ..._args: any[]): any { return null; }
+    public visitDuration(_node: any, ... _args: any[]): any { return null; }
     public visitFixedSizeList(_node: any, ..._args: any[]): any { return null; }
     public visitMap(_node: any, ..._args: any[]): any { return null; }
 }
@@ -113,6 +114,11 @@ function getVisitFnByTypeId(visitor: Visitor, dtype: Type, throwIfNotFound = tru
         case Type.Interval: fn = visitor.visitInterval; break;
         case Type.IntervalDayTime: fn = visitor.visitIntervalDayTime || visitor.visitInterval; break;
         case Type.IntervalYearMonth: fn = visitor.visitIntervalYearMonth || visitor.visitInterval; break;
+        case Type.Duration: fn = visitor.visitDuration; break;
+        case Type.DurationSecond: fn = visitor.visitDurationSecond || visitor.visitDuration; break;
+        case Type.DurationMillisecond: fn = visitor.visitDurationMillisecond || visitor.visitDuration; break;
+        case Type.DurationMicrosecond: fn = visitor.visitDurationMicrosecond || visitor.visitDuration; break;
+        case Type.DurationNanosecond: fn = visitor.visitDurationNanosecond || visitor.visitDuration; break;
         case Type.FixedSizeList: fn = visitor.visitFixedSizeList; break;
         case Type.Map: fn = visitor.visitMap; break;
     }
@@ -180,6 +186,15 @@ function inferDType<T extends DataType>(type: T): Type {
             }
             // @ts-ignore
             return Type.Interval;
+        case Type.Duration:
+            switch ((type as any as Duration).unit) {
+                case TimeUnit.SECOND: return Type.DurationSecond;
+                case TimeUnit.MILLISECOND: return Type.DurationMillisecond;
+                case TimeUnit.MICROSECOND: return Type.DurationMicrosecond;
+                case TimeUnit.NANOSECOND: return Type.DurationNanosecond;
+            }
+            // @ts-ignore
+            return Type.Duration;
         case Type.Map: return Type.Map;
         case Type.List: return Type.List;
         case Type.Struct: return Type.Struct;
@@ -239,6 +254,11 @@ export interface Visitor {
     visitInterval(node: any, ...args: any[]): any;
     visitIntervalDayTime?(node: any, ...args: any[]): any;
     visitIntervalYearMonth?(node: any, ...args: any[]): any;
+    visitDuration(node: any, ...args: any[]): any;
+    visitDurationSecond(node: any, ...args: any[]): any;
+    visitDurationMillisecond(node: any, ...args: any[]): any;
+    visitDurationMicrosecond(node: any, ...args: any[]): any;
+    visitDurationNanosecond(node: any, ...args: any[]): any;
     visitFixedSizeList(node: any, ...args: any[]): any;
     visitMap(node: any, ...args: any[]): any;
 }
@@ -270,3 +290,8 @@ export interface Visitor {
 (Visitor.prototype as any).visitSparseUnion = null;
 (Visitor.prototype as any).visitIntervalDayTime = null;
 (Visitor.prototype as any).visitIntervalYearMonth = null;
+(Visitor.prototype as any).visitDuration = null;
+(Visitor.prototype as any).visitDurationSecond = null;
+(Visitor.prototype as any).visitDurationMillisecond = null;
+(Visitor.prototype as any).visitDurationMicrosecond = null;
+(Visitor.prototype as any).visitDurationNanosecond = null;
diff --git a/js/src/visitor/builderctor.ts b/js/src/visitor/builderctor.ts
index 9ce9ae4d4a797..2d20f2a8efd5c 100644
--- a/js/src/visitor/builderctor.ts
+++ b/js/src/visitor/builderctor.ts
@@ -30,6 +30,7 @@ import { FixedSizeBinaryBuilder } from '../builder/fixedsizebinary.js';
 import { FixedSizeListBuilder } from '../builder/fixedsizelist.js';
 import { FloatBuilder, Float16Builder, Float32Builder, Float64Builder } from '../builder/float.js';
 import { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from '../builder/interval.js';
+import { DurationBuilder, DurationSecondBuilder, DurationMillisecondBuilder, DurationMicrosecondBuilder, DurationNanosecondBuilder } from '../builder/duration.js';
 import { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder } from '../builder/int.js';
 import { ListBuilder } from '../builder/list.js';
 import { MapBuilder } from '../builder/map.js';
@@ -91,6 +92,11 @@ export class GetBuilderCtor extends Visitor {
     public visitInterval() { return IntervalBuilder; }
     public visitIntervalDayTime() { return IntervalDayTimeBuilder; }
     public visitIntervalYearMonth() { return IntervalYearMonthBuilder; }
+    public visitDuration() { return DurationBuilder; }
+    public visitDurationSecond() { return DurationSecondBuilder; }
+    public visitDurationMillisecond() { return DurationMillisecondBuilder; }
+    public visitDurationMicrosecond() { return DurationMicrosecondBuilder; }
+    public visistDurationNanosecond() { return DurationNanosecondBuilder; }
     public visitFixedSizeList() { return FixedSizeListBuilder; }
     public visitMap() { return MapBuilder; }
 }
diff --git a/js/src/visitor/bytelength.ts b/js/src/visitor/bytelength.ts
index 862808ad54ee9..72d6148a52fd8 100644
--- a/js/src/visitor/bytelength.ts
+++ b/js/src/visitor/bytelength.ts
@@ -25,7 +25,7 @@ import { TypeToDataType } from '../interfaces.js';
 import { Type, TimeUnit, UnionMode } from '../enum.js';
 import {
     DataType, Dictionary,
-    Float, Int, Date_, Interval, Time, Timestamp,
+    Float, Int, Date_, Interval, Time, Timestamp, Duration,
     Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary,
     List, FixedSizeList, Map_, Struct, Union, DenseUnion, SparseUnion,
 } from '../type.js';
@@ -75,6 +75,9 @@ export class GetByteLengthVisitor extends Visitor {
     public visitInterval(data: Data<Interval>, _: number) {
         return (data.type.unit + 1) * 4;
     }
+    public visitDuration(____: Data<Duration>, _: number) {
+        return 8;
+    }
     public visitStruct(data: Data<Struct>, i: number) {
         return data.children.reduce((total, child) => total + instance.visit(child, i), 0);
     }
diff --git a/js/src/visitor/get.ts b/js/src/visitor/get.ts
index 12f8325470bac..5aaaedf51a37e 100644
--- a/js/src/visitor/get.ts
+++ b/js/src/visitor/get.ts
@@ -34,6 +34,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from '../type.js';
 
@@ -84,6 +85,11 @@ export interface GetVisitor extends Visitor {
     visitInterval<T extends Interval>(data: Data<T>, index: number): T['TValue'] | null;
     visitIntervalDayTime<T extends IntervalDayTime>(data: Data<T>, index: number): T['TValue'] | null;
     visitIntervalYearMonth<T extends IntervalYearMonth>(data: Data<T>, index: number): T['TValue'] | null;
+    visitDuration<T extends Duration>(data: Data<T>, index: number): T['TValue'] | null;
+    visitDurationSecond<T extends DurationSecond>(data: Data<T>, index: number): T['TValue'] | null;
+    visitDurationMillisecond<T extends DurationMillisecond>(data: Data<T>, index: number): T['TValue'] | null;
+    visitDurationMicrosecond<T extends DurationMicrosecond>(data: Data<T>, index: number): T['TValue'] | null;
+    visitDurationNanosecond<T extends DurationNanosecond>(data: Data<T>, index: number): T['TValue'] | null;
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>, index: number): T['TValue'] | null;
     visitMap<T extends Map_>(data: Data<T>, index: number): T['TValue'] | null;
 }
@@ -279,6 +285,25 @@ const getIntervalYearMonth = <T extends IntervalYearMonth>({ values }: Data<T>,
     return int32s;
 };
 
+/** @ignore */
+const getDurationSecond = <T extends DurationSecond>({ values }: Data<T>, index: number): T['TValue'] => values[index];
+/** @ignore */
+const getDurationMillisecond = <T extends DurationMillisecond>({ values }: Data<T>, index: number): T['TValue'] => values[index];
+/** @ignore */
+const getDurationMicrosecond = <T extends DurationMicrosecond>({ values }: Data<T>, index: number): T['TValue'] => values[index];
+/** @ignore */
+const getDurationNanosecond = <T extends DurationNanosecond>({ values }: Data<T>, index: number): T['TValue'] => values[index];
+/* istanbul ignore next */
+/** @ignore */
+const getDuration = <T extends Duration>(data: Data<T>, index: number): T['TValue'] => {
+    switch (data.type.unit) {
+        case TimeUnit.SECOND: return getDurationSecond(data as Data<DurationSecond>, index);
+        case TimeUnit.MILLISECOND: return getDurationMillisecond(data as Data<DurationMillisecond>, index);
+        case TimeUnit.MICROSECOND: return getDurationMicrosecond(data as Data<DurationMicrosecond>, index);
+        case TimeUnit.NANOSECOND: return getDurationNanosecond(data as Data<DurationNanosecond>, index);
+    }
+};
+
 /** @ignore */
 const getFixedSizeList = <T extends FixedSizeList>(data: Data<T>, index: number): T['TValue'] => {
     const { stride, children } = data;
@@ -328,6 +353,11 @@ GetVisitor.prototype.visitDictionary = wrapGet(getDictionary);
 GetVisitor.prototype.visitInterval = wrapGet(getInterval);
 GetVisitor.prototype.visitIntervalDayTime = wrapGet(getIntervalDayTime);
 GetVisitor.prototype.visitIntervalYearMonth = wrapGet(getIntervalYearMonth);
+GetVisitor.prototype.visitDuration = wrapGet(getDuration);
+GetVisitor.prototype.visitDurationSecond = wrapGet(getDurationSecond);
+GetVisitor.prototype.visitDurationMillisecond = wrapGet(getDurationMillisecond);
+GetVisitor.prototype.visitDurationMicrosecond = wrapGet(getDurationMicrosecond);
+GetVisitor.prototype.visitDurationNanosecond = wrapGet(getDurationNanosecond);
 GetVisitor.prototype.visitFixedSizeList = wrapGet(getFixedSizeList);
 GetVisitor.prototype.visitMap = wrapGet(getMap);
 
diff --git a/js/src/visitor/indexof.ts b/js/src/visitor/indexof.ts
index 654134c6dff04..28dcff20d3bd3 100644
--- a/js/src/visitor/indexof.ts
+++ b/js/src/visitor/indexof.ts
@@ -31,6 +31,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from '../type.js';
 
@@ -81,6 +82,11 @@ export interface IndexOfVisitor extends Visitor {
     visitInterval<T extends Interval>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
     visitIntervalDayTime<T extends IntervalDayTime>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
     visitIntervalYearMonth<T extends IntervalYearMonth>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
+    visitDuration<T extends Duration>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
+    visitDurationSecond<T extends DurationSecond>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
+    visitDurationMillisecond<T extends DurationMillisecond>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
+    visitDurationMicrosecond<T extends DurationMicrosecond>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
+    visitDurationNanosecond<T extends DurationNanosecond>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
     visitMap<T extends Map_>(data: Data<T>, value: T['TValue'] | null, index?: number): number;
 }
@@ -191,6 +197,11 @@ IndexOfVisitor.prototype.visitDictionary = indexOfValue;
 IndexOfVisitor.prototype.visitInterval = indexOfValue;
 IndexOfVisitor.prototype.visitIntervalDayTime = indexOfValue;
 IndexOfVisitor.prototype.visitIntervalYearMonth = indexOfValue;
+IndexOfVisitor.prototype.visitDuration = indexOfValue;
+IndexOfVisitor.prototype.visitDurationSecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationMillisecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationMicrosecond = indexOfValue;
+IndexOfVisitor.prototype.visitDurationNanosecond = indexOfValue;
 IndexOfVisitor.prototype.visitFixedSizeList = indexOfValue;
 IndexOfVisitor.prototype.visitMap = indexOfValue;
 
diff --git a/js/src/visitor/iterator.ts b/js/src/visitor/iterator.ts
index 48021a78e86f6..e38bb907695d0 100644
--- a/js/src/visitor/iterator.ts
+++ b/js/src/visitor/iterator.ts
@@ -28,6 +28,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from '../type.js';
 import { ChunkedIterator } from '../util/chunk.js';
@@ -79,6 +80,11 @@ export interface IteratorVisitor extends Visitor {
     visitInterval<T extends Interval>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
     visitIntervalDayTime<T extends IntervalDayTime>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
     visitIntervalYearMonth<T extends IntervalYearMonth>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
+    visitDuration<T extends Duration>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
+    visitDurationSecond<T extends DurationSecond>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
+    visitDurationMillisecond<T extends DurationMillisecond>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
+    visitDurationMicrosecond<T extends DurationMicrosecond>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
+    visitDurationNanosecond<T extends DurationNanosecond>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
     visitFixedSizeList<T extends FixedSizeList>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
     visitMap<T extends Map_>(vector: Vector<T>): IterableIterator<T['TValue'] | null>;
 }
@@ -177,6 +183,11 @@ IteratorVisitor.prototype.visitDictionary = vectorIterator;
 IteratorVisitor.prototype.visitInterval = vectorIterator;
 IteratorVisitor.prototype.visitIntervalDayTime = vectorIterator;
 IteratorVisitor.prototype.visitIntervalYearMonth = vectorIterator;
+IteratorVisitor.prototype.visitDuration = vectorIterator;
+IteratorVisitor.prototype.visitDurationSecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationMillisecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationMicrosecond = vectorIterator;
+IteratorVisitor.prototype.visitDurationNanosecond = vectorIterator;
 IteratorVisitor.prototype.visitFixedSizeList = vectorIterator;
 IteratorVisitor.prototype.visitMap = vectorIterator;
 
diff --git a/js/src/visitor/jsontypeassembler.ts b/js/src/visitor/jsontypeassembler.ts
index d83edfc24fbd8..6e6cfb07413c3 100644
--- a/js/src/visitor/jsontypeassembler.ts
+++ b/js/src/visitor/jsontypeassembler.ts
@@ -63,6 +63,9 @@ export class JSONTypeAssembler extends Visitor {
     public visitInterval<T extends type.Interval>({ typeId, unit }: T) {
         return { 'name': ArrowType[typeId].toLowerCase(), 'unit': IntervalUnit[unit] };
     }
+    public visitDuration<T extends type.Duration>({ typeId, unit }: T) {
+        return { 'name': ArrowType[typeId].toLocaleLowerCase(), 'unit': TimeUnit[unit]};
+    }
     public visitList<T extends type.List>({ typeId }: T) {
         return { 'name': ArrowType[typeId].toLowerCase() };
     }
diff --git a/js/src/visitor/jsonvectorassembler.ts b/js/src/visitor/jsonvectorassembler.ts
index 7a617f4afe2c4..55a6b4e2ea390 100644
--- a/js/src/visitor/jsonvectorassembler.ts
+++ b/js/src/visitor/jsonvectorassembler.ts
@@ -26,7 +26,7 @@ import { UnionMode, DateUnit, TimeUnit } from '../enum.js';
 import { BitIterator, getBit, getBool } from '../util/bit.js';
 import {
     DataType,
-    Float, Int, Date_, Interval, Time, Timestamp, Union,
+    Float, Int, Date_, Interval, Time, Timestamp, Union, Duration,
     Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct, IntArray,
 } from '../type.js';
 
@@ -52,6 +52,7 @@ export interface JSONVectorAssembler extends Visitor {
     visitStruct<T extends Struct>(data: Data<T>): { children: any[] };
     visitUnion<T extends Union>(data: Data<T>): { children: any[]; TYPE_ID: number[] };
     visitInterval<T extends Interval>(data: Data<T>): { DATA: number[] };
+    visitDuration<T extends Duration>(data: Data<T>): { DATA: string[] };
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>): { children: any[] };
     visitMap<T extends Map_>(data: Data<T>): { children: any[] };
 }
@@ -146,6 +147,9 @@ export class JSONVectorAssembler extends Visitor {
     public visitInterval<T extends Interval>(data: Data<T>) {
         return { 'DATA': [...data.values] };
     }
+    public visitDuration<T extends Duration>(data: Data<T>) {
+        return { 'DATA': [...bigNumsToStrings(data.values, 2)]};
+    }
     public visitFixedSizeList<T extends FixedSizeList>(data: Data<T>) {
         return {
             'children': this.visitMany(data.type.children, data.children)
diff --git a/js/src/visitor/set.ts b/js/src/visitor/set.ts
index c2d4319911afe..1a0eddc556899 100644
--- a/js/src/visitor/set.ts
+++ b/js/src/visitor/set.ts
@@ -32,6 +32,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from '../type.js';
 
@@ -82,6 +83,11 @@ export interface SetVisitor extends Visitor {
     visitInterval<T extends Interval>(data: Data<T>, index: number, value: T['TValue']): void;
     visitIntervalDayTime<T extends IntervalDayTime>(data: Data<T>, index: number, value: T['TValue']): void;
     visitIntervalYearMonth<T extends IntervalYearMonth>(data: Data<T>, index: number, value: T['TValue']): void;
+    visitDuration<T extends Duration>(data: Data<T>, index: number, value: T['TValue']): void;
+    visitDurationSecond<T extends DurationSecond>(data: Data<T>, index: number, value: T['TValue']): void;
+    visitDurationMillisecond<T extends DurationMillisecond>(data: Data<T>, index: number, value: T['TValue']): void;
+    visitDurationMicrosecond<T extends DurationMicrosecond>(data: Data<T>, index: number, value: T['TValue']): void;
+    visitDurationNanosecond<T extends DurationNanosecond>(data: Data<T>, index: number, value: T['TValue']): void;
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>, index: number, value: T['TValue']): void;
     visitMap<T extends Map_>(data: Data<T>, index: number, value: T['TValue']): void;
 }
@@ -308,6 +314,26 @@ export const setIntervalDayTime = <T extends IntervalDayTime>({ values }: Data<T
 /** @ignore */
 export const setIntervalYearMonth = <T extends IntervalYearMonth>({ values }: Data<T>, index: number, value: T['TValue']): void => { values[index] = (value[0] * 12) + (value[1] % 12); };
 
+/** @ignore */
+export const setDurationSecond = <T extends DurationSecond>({ values }: Data<T>, index: number, value: T['TValue']): void => { values[index] = value; };
+/** @ignore */
+export const setDurationMillisecond = <T extends DurationMillisecond>({ values }: Data<T>, index: number, value: T['TValue']): void => { values[index] = value; };
+/** @ignore */
+export const setDurationMicrosecond = <T extends DurationMicrosecond>({ values }: Data<T>, index: number, value: T['TValue']): void => { values[index] = value; };
+/** @ignore */
+export const setDurationNanosecond = <T extends DurationNanosecond>({ values }: Data<T>, index: number, value: T['TValue']): void => { values[index] = value; };
+/* istanbul ignore next */
+/** @ignore */
+export const setDuration = <T extends Duration>(data: Data<T>, index: number, value: T['TValue']): void => {
+    switch (data.type.unit) {
+        case TimeUnit.SECOND: return setDurationSecond(data as Data<DurationSecond>, index, value as DurationSecond['TValue']);
+        case TimeUnit.MILLISECOND: return setDurationMillisecond(data as Data<DurationMillisecond>, index, value as DurationMillisecond['TValue']);
+        case TimeUnit.MICROSECOND: return setDurationMicrosecond(data as Data<DurationMicrosecond>, index, value as DurationMicrosecond['TValue']);
+        case TimeUnit.NANOSECOND: return setDurationNanosecond(data as Data<DurationNanosecond>, index, value as DurationNanosecond['TValue']);
+    }
+};
+
+
 /** @ignore */
 const setFixedSizeList = <T extends FixedSizeList>(data: Data<T>, index: number, value: T['TValue']): void => {
     const { stride } = data;
@@ -364,6 +390,11 @@ SetVisitor.prototype.visitDictionary = wrapSet(setDictionary);
 SetVisitor.prototype.visitInterval = wrapSet(setIntervalValue);
 SetVisitor.prototype.visitIntervalDayTime = wrapSet(setIntervalDayTime);
 SetVisitor.prototype.visitIntervalYearMonth = wrapSet(setIntervalYearMonth);
+SetVisitor.prototype.visitDuration = wrapSet(setDuration);
+SetVisitor.prototype.visitDurationSecond = wrapSet(setDurationSecond);
+SetVisitor.prototype.visitDurationMillisecond = wrapSet(setDurationMillisecond);
+SetVisitor.prototype.visitDurationMicrosecond = wrapSet(setDurationMicrosecond);
+SetVisitor.prototype.visitDurationNanosecond = wrapSet(setDurationNanosecond);
 SetVisitor.prototype.visitFixedSizeList = wrapSet(setFixedSizeList);
 SetVisitor.prototype.visitMap = wrapSet(setMap);
 
diff --git a/js/src/visitor/typeassembler.ts b/js/src/visitor/typeassembler.ts
index c84e3930f64f5..c2262d20531b9 100644
--- a/js/src/visitor/typeassembler.ts
+++ b/js/src/visitor/typeassembler.ts
@@ -32,6 +32,7 @@ import { Date } from '../fb/date.js';
 import { Time } from '../fb/time.js';
 import { Timestamp } from '../fb/timestamp.js';
 import { Interval } from '../fb/interval.js';
+import { Duration } from '../fb/duration.js';
 import { List } from '../fb/list.js';
 import { Struct_ as Struct } from '../fb/struct-.js';
 import { Union } from '../fb/union.js';
@@ -109,6 +110,11 @@ export class TypeAssembler extends Visitor {
         Interval.addUnit(b, node.unit);
         return Interval.endInterval(b);
     }
+    public visitDuration<T extends type.Duration>(node: T, b: Builder) {
+        Duration.startDuration(b);
+        Duration.addUnit(b, node.unit);
+        return Duration.endDuration(b);
+    }
     public visitList<T extends type.List>(_node: T, b: Builder) {
         List.startList(b);
         return List.endList(b);
diff --git a/js/src/visitor/typecomparator.ts b/js/src/visitor/typecomparator.ts
index a77c4020961ce..1de8e218dae4f 100644
--- a/js/src/visitor/typecomparator.ts
+++ b/js/src/visitor/typecomparator.ts
@@ -28,6 +28,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from '../type.js';
 
@@ -77,6 +78,11 @@ export interface TypeComparator extends Visitor {
     visitInterval<T extends Interval>(type: T, other?: DataType | null): other is T;
     visitIntervalDayTime<T extends IntervalDayTime>(type: T, other?: DataType | null): other is T;
     visitIntervalYearMonth<T extends IntervalYearMonth>(type: T, other?: DataType | null): other is T;
+    visitDuration<T extends Duration>(type: T, other?: DataType | null): other is T;
+    visitDurationSecond<T extends DurationSecond>(type: T, other?: DataType | null): other is T;
+    visitDurationMillisecond<T extends DurationMillisecond>(type: T, other?: DataType | null): other is T;
+    visitDurationMicrosecond<T extends DurationMicrosecond>(type: T, other?: DataType | null): other is T;
+    visitDurationNanosecond<T extends DurationNanosecond>(type: T, other?: DataType | null): other is T;
     visitFixedSizeList<T extends FixedSizeList>(type: T, other?: DataType | null): other is T;
     visitMap<T extends Map_>(type: T, other?: DataType | null): other is T;
 }
@@ -202,6 +208,13 @@ function compareInterval<T extends Interval>(type: T, other?: DataType | null):
     );
 }
 
+function compareDuration<T extends Duration>(type: T, other?: DataType | null): other is T {
+    return (type === other) || (
+        compareConstructor(type, other) &&
+        type.unit === other.unit
+    );
+}
+
 function compareFixedSizeList<T extends FixedSizeList>(type: T, other?: DataType | null): other is T {
     return (type === other) || (
         compareConstructor(type, other) &&
@@ -261,6 +274,11 @@ TypeComparator.prototype.visitDictionary = compareDictionary;
 TypeComparator.prototype.visitInterval = compareInterval;
 TypeComparator.prototype.visitIntervalDayTime = compareInterval;
 TypeComparator.prototype.visitIntervalYearMonth = compareInterval;
+TypeComparator.prototype.visitDuration = compareDuration;
+TypeComparator.prototype.visitDurationSecond = compareDuration;
+TypeComparator.prototype.visitDurationMillisecond = compareDuration;
+TypeComparator.prototype.visitDurationMicrosecond = compareDuration;
+TypeComparator.prototype.visitDurationNanosecond = compareDuration;
 TypeComparator.prototype.visitFixedSizeList = compareFixedSizeList;
 TypeComparator.prototype.visitMap = compareMap;
 
diff --git a/js/src/visitor/typector.ts b/js/src/visitor/typector.ts
index c825a61dbadfb..077f66592fbfb 100644
--- a/js/src/visitor/typector.ts
+++ b/js/src/visitor/typector.ts
@@ -74,6 +74,11 @@ export class GetDataTypeConstructor extends Visitor {
     public visitInterval() { return type.Interval; }
     public visitIntervalDayTime() { return type.IntervalDayTime; }
     public visitIntervalYearMonth() { return type.IntervalYearMonth; }
+    public visitDuration() { return type.Duration; }
+    public visitDurationSecond() { return type.DurationSecond; }
+    public visitDurationMillisecond() { return type.DurationMillisecond; }
+    public visitDurationMicrosecond() { return type.DurationMicrosecond; }
+    public visitDurationNanosecond() { return type.DurationNanosecond; }
     public visitFixedSizeList() { return type.FixedSizeList; }
     public visitMap() { return type.Map_; }
 }
diff --git a/js/src/visitor/vectorassembler.ts b/js/src/visitor/vectorassembler.ts
index dbf778c4c3631..949463272e718 100644
--- a/js/src/visitor/vectorassembler.ts
+++ b/js/src/visitor/vectorassembler.ts
@@ -26,7 +26,7 @@ import { packBools, truncateBitmap } from '../util/bit.js';
 import { BufferRegion, FieldNode } from '../ipc/metadata/message.js';
 import {
     DataType, Dictionary,
-    Float, Int, Date_, Interval, Time, Timestamp, Union,
+    Float, Int, Date_, Interval, Time, Timestamp, Union, Duration,
     Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,
 } from '../type.js';
 
@@ -51,6 +51,7 @@ export interface VectorAssembler extends Visitor {
     visitStruct<T extends Struct>(data: Data<T>): this;
     visitUnion<T extends Union>(data: Data<T>): this;
     visitInterval<T extends Interval>(data: Data<T>): this;
+    visitDuration<T extends Duration>(data: Data<T>): this;
     visitFixedSizeList<T extends FixedSizeList>(data: Data<T>): this;
     visitMap<T extends Map_>(data: Data<T>): this;
 }
@@ -195,7 +196,7 @@ function assembleBoolVector<T extends Bool>(this: VectorAssembler, data: Data<T>
 }
 
 /** @ignore */
-function assembleFlatVector<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval>(this: VectorAssembler, data: Data<T>) {
+function assembleFlatVector<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval | Duration>(this: VectorAssembler, data: Data<T>) {
     return addBuffer.call(this, data.values.subarray(0, data.length * data.stride));
 }
 
@@ -243,5 +244,6 @@ VectorAssembler.prototype.visitList = assembleListVector;
 VectorAssembler.prototype.visitStruct = assembleNestedVector;
 VectorAssembler.prototype.visitUnion = assembleUnion;
 VectorAssembler.prototype.visitInterval = assembleFlatVector;
+VectorAssembler.prototype.visitDuration = assembleFlatVector;
 VectorAssembler.prototype.visitFixedSizeList = assembleListVector;
 VectorAssembler.prototype.visitMap = assembleListVector;
diff --git a/js/src/visitor/vectorloader.ts b/js/src/visitor/vectorloader.ts
index cb4bc2829274f..db34edad9a1c1 100644
--- a/js/src/visitor/vectorloader.ts
+++ b/js/src/visitor/vectorloader.ts
@@ -115,6 +115,9 @@ export class VectorLoader extends Visitor {
     public visitInterval<T extends type.Interval>(type: T, { length, nullCount } = this.nextFieldNode()) {
         return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
     }
+    public visitDuration<T extends type.Duration>(type: T, { length, nullCount } = this.nextFieldNode()) {
+        return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), data: this.readData(type) });
+    }
     public visitFixedSizeList<T extends type.FixedSizeList>(type: T, { length, nullCount } = this.nextFieldNode()) {
         return makeData({ type, length, nullCount, nullBitmap: this.readNullBitmap(type, nullCount), 'child': this.visit(type.children[0]) });
     }
@@ -157,7 +160,7 @@ export class JSONVectorLoader extends VectorLoader {
         const { sources } = this;
         if (DataType.isTimestamp(type)) {
             return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));
-        } else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64) {
+        } else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64 || DataType.isDuration(type)) {
             return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));
         } else if (DataType.isDate(type) && type.unit === DateUnit.MILLISECOND) {
             return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));
diff --git a/js/test/data/tables.ts b/js/test/data/tables.ts
index e4d859e0a69b7..28aed7e4feccf 100644
--- a/js/test/data/tables.ts
+++ b/js/test/data/tables.ts
@@ -30,7 +30,8 @@ const valueVectorGeneratorNames = [
     'float16', 'float32', 'float64', 'utf8', 'binary', 'fixedSizeBinary', 'dateDay', 'dateMillisecond',
     'timestampSecond', 'timestampMillisecond', 'timestampMicrosecond', 'timestampNanosecond',
     'timeSecond', 'timeMillisecond', 'timeMicrosecond', 'timeNanosecond', 'decimal',
-    'dictionary', 'intervalDayTime', 'intervalYearMonth'
+    'dictionary', 'intervalDayTime', 'intervalYearMonth',
+    'durationSecond', 'durationMillisecond', 'durationMicrosecond', 'durationNanosecond',
 ];
 
 const vectorGeneratorNames = [...valueVectorGeneratorNames, ...listVectorGeneratorNames, ...nestedVectorGeneratorNames];
diff --git a/js/test/generate-test-data.ts b/js/test/generate-test-data.ts
index a03b22c54c770..15fb715a31f95 100644
--- a/js/test/generate-test-data.ts
+++ b/js/test/generate-test-data.ts
@@ -36,6 +36,7 @@ import {
     Union, DenseUnion, SparseUnion,
     Dictionary,
     Interval, IntervalDayTime, IntervalYearMonth,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     FixedSizeList,
     Map_,
     DateUnit, TimeUnit, UnionMode,
@@ -58,6 +59,7 @@ interface TestDataVectorGenerator extends Visitor {
     visit<T extends Time>(type: T, length?: number, nullCount?: number): GeneratedVector<T>;
     visit<T extends Decimal>(type: T, length?: number, nullCount?: number): GeneratedVector<T>;
     visit<T extends Interval>(type: T, length?: number, nullCount?: number): GeneratedVector<T>;
+    visit<T extends Duration>(type: T, length?: number, nullCount?: number): GeneratedVector<T>;
     visit<T extends List>(type: T, length?: number, nullCount?: number, child?: Vector): GeneratedVector<T>;
     visit<T extends FixedSizeList>(type: T, length?: number, nullCount?: number, child?: Vector): GeneratedVector<T>;
     visit<T extends Dictionary>(type: T, length?: number, nullCount?: number, dictionary?: Vector): GeneratedVector<T>;
@@ -84,6 +86,7 @@ interface TestDataVectorGenerator extends Visitor {
     visitUnion: typeof generateUnion;
     visitDictionary: typeof generateDictionary;
     visitInterval: typeof generateInterval;
+    visitDuration: typeof generateDuration;
     visitFixedSizeList: typeof generateFixedSizeList;
     visitMap: typeof generateMap;
 }
@@ -108,6 +111,7 @@ TestDataVectorGenerator.prototype.visitStruct = generateStruct;
 TestDataVectorGenerator.prototype.visitUnion = generateUnion;
 TestDataVectorGenerator.prototype.visitDictionary = generateDictionary;
 TestDataVectorGenerator.prototype.visitInterval = generateInterval;
+TestDataVectorGenerator.prototype.visitDuration = generateDuration;
 TestDataVectorGenerator.prototype.visitFixedSizeList = generateFixedSizeList;
 TestDataVectorGenerator.prototype.visitMap = generateMap;
 
@@ -230,11 +234,15 @@ export const sparseUnion = (length = 100, nullCount = Math.trunc(length * 0.2),
 export const dictionary = <T extends DataType = Utf8, TKey extends TKeys = Int32>(length = 100, nullCount = Math.trunc(length * 0.2), dict: T = <any>new Utf8(), keys: TKey = <any>new Int32()) => vectorGenerator.visit(new Dictionary(dict, keys), length, nullCount);
 export const intervalDayTime = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new IntervalDayTime(), length, nullCount);
 export const intervalYearMonth = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new IntervalYearMonth(), length, nullCount);
+export const durationSecond = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new DurationSecond(), length, nullCount);
+export const durationMillisecond = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new DurationMillisecond(), length, nullCount);
+export const durationMicrosecond = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new DurationMicrosecond(), length, nullCount);
+export const durationNanosecond = (length = 100, nullCount = Math.trunc(length * 0.2)) => vectorGenerator.visit(new DurationNanosecond(), length, nullCount);
 export const fixedSizeList = (length = 100, nullCount = Math.trunc(length * 0.2), listSize = 2, child = defaultListChild) => vectorGenerator.visit(new FixedSizeList(listSize, child), length, nullCount);
 export const map = <TKey extends DataType = any, TValue extends DataType = any>(length = 100, nullCount = Math.trunc(length * 0.2), child: Field<Struct<{ key: TKey; value: TValue }>> = <any>defaultMapChild()) => vectorGenerator.visit(new Map_<TKey, TValue>(child), length, nullCount);
 
 export const vecs = {
-    null_, bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, utf8, binary, fixedSizeBinary, dateDay, dateMillisecond, timestampSecond, timestampMillisecond, timestampMicrosecond, timestampNanosecond, timeSecond, timeMillisecond, timeMicrosecond, timeNanosecond, decimal, list, struct, denseUnion, sparseUnion, dictionary, intervalDayTime, intervalYearMonth, fixedSizeList, map
+    null_, bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, utf8, binary, fixedSizeBinary, dateDay, dateMillisecond, timestampSecond, timestampMillisecond, timestampMicrosecond, timestampNanosecond, timeSecond, timeMillisecond, timeMicrosecond, timeNanosecond, decimal, list, struct, denseUnion, sparseUnion, dictionary, intervalDayTime, intervalYearMonth, fixedSizeList, map, durationSecond, durationMillisecond, durationMicrosecond, durationNanosecond
 } as { [k: string]: (...args: any[]) => any };
 
 function generateNull<T extends Null>(this: TestDataVectorGenerator, type: T, length = 100): GeneratedVector<T> {
@@ -421,6 +429,16 @@ function generateInterval<T extends Interval>(this: TestDataVectorGenerator, typ
     return { values, vector: new Vector([makeData({ type, length, nullCount, nullBitmap, data })]) };
 }
 
+function generateDuration<T extends Duration>(this: TestDataVectorGenerator, type: T, length = 100, nullCount = Math.trunc(length * 0.2)): GeneratedVector<T> {
+    const nullBitmap = createBitmap(length, nullCount);
+    const multiple = type.unit === TimeUnit.NANOSECOND ? 1000000000 :
+        type.unit === TimeUnit.MICROSECOND ? 1000000 :
+            type.unit === TimeUnit.MILLISECOND ? 1000 : 1;
+    const values: bigint[] = [];
+    const data = createTime64(length, nullBitmap, multiple, values);
+    return { values: () => values, vector: new Vector([makeData({ type, length, nullCount, nullBitmap, data })]) };
+}
+
 function generateList<T extends List>(this: TestDataVectorGenerator, type: T, length = 100, nullCount = Math.trunc(length * 0.2), child = this.visit(type.children[0].type, length * 3, nullCount * 3)): GeneratedVector<T> {
     const childVec = child.vector;
     const nullBitmap = createBitmap(length, nullCount);
diff --git a/js/test/unit/builders/builder-tests.ts b/js/test/unit/builders/builder-tests.ts
index a73183a7a5d47..b261e4f815e3a 100644
--- a/js/test/unit/builders/builder-tests.ts
+++ b/js/test/unit/builders/builder-tests.ts
@@ -64,6 +64,10 @@ describe('Generated Test Data', () => {
     describe('DictionaryBuilder', () => { validateBuilder(generate.dictionary); });
     describe('IntervalDayTimeBuilder', () => { validateBuilder(generate.intervalDayTime); });
     describe('IntervalYearMonthBuilder', () => { validateBuilder(generate.intervalYearMonth); });
+    describe('DurationSecondBuilder', () => { validateBuilder(generate.durationSecond); });
+    describe('DurationMillisecondBuilder', () => { validateBuilder(generate.durationMillisecond); });
+    describe('DurationMicrosecondBuilder', () => { validateBuilder(generate.durationMicrosecond); });
+    describe('DurationNanosecondBuilder', () => { validateBuilder(generate.durationNanosecond); });
     describe('FixedSizeListBuilder', () => { validateBuilder(generate.fixedSizeList); });
     describe('MapBuilder', () => { validateBuilder(generate.map); });
 });
diff --git a/js/test/unit/generated-data-tests.ts b/js/test/unit/generated-data-tests.ts
index 90cf0d598aa6f..d64c7c188d3ed 100644
--- a/js/test/unit/generated-data-tests.ts
+++ b/js/test/unit/generated-data-tests.ts
@@ -58,6 +58,10 @@ describe('Generated Test Data', () => {
     describe('Dictionary', () => { validateVector(generate.dictionary()); });
     describe('IntervalDayTime', () => { validateVector(generate.intervalDayTime()); });
     describe('IntervalYearMonth', () => { validateVector(generate.intervalYearMonth()); });
+    describe('DurationSecond', () => { validateVector(generate.durationSecond()); });
+    describe('DurationMillisecond', () => { validateVector(generate.durationMillisecond()); });
+    describe('DurationMicrosecond', () => { validateVector(generate.durationMicrosecond()); });
+    describe('DurationNanosecond', () => { validateVector(generate.durationNanosecond()); });
     describe('FixedSizeList', () => { validateVector(generate.fixedSizeList()); });
     describe('Map', () => { validateVector(generate.map()); });
 });
diff --git a/js/test/unit/visitor-tests.ts b/js/test/unit/visitor-tests.ts
index 645fcc60f8d90..8a7ba1ed778aa 100644
--- a/js/test/unit/visitor-tests.ts
+++ b/js/test/unit/visitor-tests.ts
@@ -25,6 +25,7 @@ import {
     Interval, IntervalDayTime, IntervalYearMonth,
     Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,
     Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,
+    Duration, DurationSecond, DurationMillisecond, DurationMicrosecond, DurationNanosecond,
     Union, DenseUnion, SparseUnion,
 } from 'apache-arrow';
 
@@ -46,6 +47,7 @@ class BasicVisitor extends Visitor {
     public visitUnion<T extends Union>(type: T) { return (this.type = type); }
     public visitDictionary<T extends Dictionary>(type: T) { return (this.type = type); }
     public visitInterval<T extends Interval>(type: T) { return (this.type = type); }
+    public visitDuration<T extends Duration>(type: T) { return (this.type = type); }
     public visitFixedSizeList<T extends FixedSizeList>(type: T) { return (this.type = type); }
     public visitMap<T extends Map_>(type: T) { return (this.type = type); }
 }
@@ -86,6 +88,10 @@ class FeatureVisitor extends Visitor {
     public visitDictionary<T extends Dictionary>(type: T) { return (this.type = type); }
     public visitIntervalDayTime<T extends IntervalDayTime>(type: T) { return (this.type = type); }
     public visitIntervalYearMonth<T extends IntervalYearMonth>(type: T) { return (this.type = type); }
+    public visitDurationSecond<T extends DurationSecond>(type: T) { return (this.type = type); }
+    public visitDurationMillisecond<T extends DurationMillisecond>(type: T) { return (this.type = type); }
+    public visitDurationMicrosecond<T extends DurationMicrosecond>(type: T) { return (this.type = type); }
+    public visitDurationNanosecond<T extends DurationNanosecond>(type: T) { return (this.type = type); }
     public visitFixedSizeList<T extends FixedSizeList>(type: T) { return (this.type = type); }
     public visitMap<T extends Map_>(type: T) { return (this.type = type); }
 }
@@ -109,6 +115,7 @@ describe('Visitor', () => {
         test(`visits Union types`, () => validateBasicVisitor(new Union(0, [] as any[], [] as any[])));
         test(`visits Dictionary types`, () => validateBasicVisitor(new Dictionary(null as any, null as any)));
         test(`visits Interval types`, () => validateBasicVisitor(new Interval(0)));
+        test(`visits Duration types`, () => validateBasicVisitor(new Duration(0)));
         test(`visits FixedSizeList types`, () => validateBasicVisitor(new FixedSizeList(2, null as any)));
         test(`visits Map types`, () => validateBasicVisitor(new Map_(new Field('', new Struct<{ key: Utf8; value: Int }>([
             new Field('key', new Utf8()), new Field('value', new Int8())
@@ -158,6 +165,10 @@ describe('Visitor', () => {
         test(`visits IntervalDayTime types`, () => validateFeatureVisitor(new IntervalDayTime()));
         test(`visits IntervalYearMonth types`, () => validateFeatureVisitor(new IntervalYearMonth()));
         test(`visits FixedSizeList types`, () => validateFeatureVisitor(new FixedSizeList(2, null as any)));
+        test(`visits DurationSecond types`, () => validateFeatureVisitor(new DurationSecond()));
+        test(`visits DurationMillisecond types`, () => validateFeatureVisitor(new DurationMillisecond()));
+        test(`visits DurationMicrosecond types`, () => validateFeatureVisitor(new DurationMicrosecond()));
+        test(`visits DurationNanosecond types`, () => validateFeatureVisitor(new DurationNanosecond()));
         test(`visits Map types`, () => validateFeatureVisitor(new Map_(new Field('', new Struct<{ key: Utf8; value: Int }>([
             new Field('key', new Utf8()), new Field('value', new Int8())
         ] as any[])))));

From 80b351cc99881dc864c9dc8850a9e67379a3f657 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 29 Sep 2023 09:53:39 +0100
Subject: [PATCH 431/749] MINOR: [R] Bump versions file for navigating between
 docs versions (#37928)

### Rationale for this change

Versions files needed bumping with the 13.0.01 release

### What changes are included in this PR?

Increasing version numbers

### Are these changes tested?

No

### Are there any user-facing changes?

No

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/pkgdown/assets/versions.html | 5 +++--
 r/pkgdown/assets/versions.json | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/r/pkgdown/assets/versions.html b/r/pkgdown/assets/versions.html
index 31f393a27785d..8ba513a98c85b 100644
--- a/r/pkgdown/assets/versions.html
+++ b/r/pkgdown/assets/versions.html
@@ -1,7 +1,8 @@
 <!DOCTYPE html>
 <html>
-<body><p><a href="../dev/r/">12.0.1.9000 (dev)</a></p>
-<p><a href="../r/">12.0.1.1 (release)</a></p>
+<body><p><a href="../dev/r/">13.0.0.9000 (dev)</a></p>
+<p><a href="../r/">13.0.0.1 (release)</a></p>
+<p><a href="../12.0/r/">12.0.1.1</a></p>
 <p><a href="../11.0/r/">11.0.0.3</a></p>
 <p><a href="../10.0/r/">10.0.1</a></p>
 <p><a href="../9.0/r/">9.0.0</a></p>
diff --git a/r/pkgdown/assets/versions.json b/r/pkgdown/assets/versions.json
index 565f67b9730a4..b7c6984e3c660 100644
--- a/r/pkgdown/assets/versions.json
+++ b/r/pkgdown/assets/versions.json
@@ -4,7 +4,7 @@
         "version": "dev/"
     },
     {
-        "name": "13.0.0 (release)",
+        "name": "13.0.0.1 (release)",
         "version": ""
     },
     {

From c703b874417d1165b8afc0a42265d5513d5786d7 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Fri, 29 Sep 2023 11:20:59 +0200
Subject: [PATCH 432/749] MINOR: [CI][Dev] Fix crossbow badge url (#37946)

Github has changed the badge url so all crossbow badges where showing up as grey.

Authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/archery/archery/crossbow/reports.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/archery/archery/crossbow/reports.py b/dev/archery/archery/crossbow/reports.py
index 1cf19841c6939..ea10e75ad3478 100644
--- a/dev/archery/archery/crossbow/reports.py
+++ b/dev/archery/archery/crossbow/reports.py
@@ -284,7 +284,7 @@ class CommentReport(Report):
         'github': _markdown_badge.format(
             title='Github Actions',
             badge=(
-                'https://github.com/{repo}/workflows/Crossbow/'
+                'https://github.com/{repo}/actions/workflows/crossbow.yml/'
                 'badge.svg?branch={branch}'
             ),
         ),

From 141559816eea8474ed96680a60eceae574d499c3 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 29 Sep 2023 13:31:38 +0100
Subject: [PATCH 433/749] GH-37950: [R] tests fail on R < 4.0 due to test
 calling data.frame() without specifying stringsAsFactors=FALSE (#37951)

### Rationale for this change

Tests failing on R < 4.0 builds due to the default value of the the `data.frame()` parameter `stringsAsFactors` between older and newer versions of R

### What changes are included in this PR?

Update a test using `data.frame()` to manually specify the value of `stringsAsFactors` as `FALSE`.

### Are these changes tested?

No

### Are there any user-facing changes?

No
* Closes: #37950

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/test-schema.R | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/r/tests/testthat/test-schema.R b/r/tests/testthat/test-schema.R
index b1dc06592955e..15342add38fae 100644
--- a/r/tests/testthat/test-schema.R
+++ b/r/tests/testthat/test-schema.R
@@ -300,7 +300,11 @@ test_that("schema extraction", {
   expect_equal(schema(example_data), tbl$schema)
   expect_equal(schema(tbl), tbl$schema)
 
-  expect_equal(schema(data.frame(a = 1, a = "x", check.names = FALSE)), schema(a = double(), a = string()))
+  expect_equal(
+    schema(data.frame(a = 1, a = "x", check.names = FALSE, stringsAsFactors = FALSE)),
+    schema(a = double(), a = string())
+  )
+
   expect_equal(schema(data.frame()), schema())
 
   ds <- InMemoryDataset$create(example_data)

From 72c6497dd02f1d0c3caeff54fdc7bf4c3b846a70 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 29 Sep 2023 13:32:41 +0100
Subject: [PATCH 434/749] GH-37813: [R] add quoted_na argument to
 open_delim_dataset() (#37828)

### Rationale for this change

The `open_delim_dataset()` family of functions were implemented to have the same arguments as the `read_delim_arrow()` functions where possible, but `quoted_na` was missed.

### What changes are included in this PR?

Adding `quoted_na` to those functions.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes

**This PR includes breaking changes to public APIs.**

Empty strings in input datasets now default to being read in by `open_delim_dataset()` and its derivates as NAs and not empty string

* Closes: #37813

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/dataset-format.R                | 15 ++++++++++-----
 r/R/dataset.R                       | 13 ++++++++-----
 r/man/open_delim_dataset.Rd         | 15 +++++++++++----
 r/tests/testthat/test-dataset-csv.R | 14 ++++++++++++--
 4 files changed, 41 insertions(+), 16 deletions(-)

diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R
index 5dd00b9344014..cdaaf08827bfd 100644
--- a/r/R/dataset-format.R
+++ b/r/R/dataset-format.R
@@ -239,7 +239,7 @@ check_unsupported_args <- function(args) {
   opt_names <- get_opt_names(args)
 
   # Filter out arguments meant for CsvConvertOptions/CsvReadOptions
-  supported_convert_opts <- c(names(formals(CsvConvertOptions$create)), "na")
+  supported_convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na")
 
   supported_read_opts <- c(
     names(formals(CsvReadOptions$create)),
@@ -312,7 +312,8 @@ check_unrecognised_args <- function(opts) {
   readr_opts <- c(
     names(formals(readr_to_csv_parse_options)),
     names(formals(readr_to_csv_read_options)),
-    "na"
+    "na",
+    "quoted_na"
   )
 
   is_arrow_opt <- !is.na(pmatch(opt_names, arrow_opts))
@@ -394,7 +395,7 @@ check_schema <- function(schema, partitioning, column_names) {
 csv_file_format_parse_opts <- function(...) {
   opts <- list(...)
   # Filter out arguments meant for CsvConvertOptions/CsvReadOptions
-  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "convert_options")
+  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options")
   read_opts <- c(
     names(formals(CsvReadOptions$create)),
     names(formals(readr_to_csv_read_options)),
@@ -452,6 +453,11 @@ csv_file_format_convert_opts <- function(...) {
     opts[["na"]] <- NULL
   }
 
+  if ("quoted_na" %in% names(opts)) {
+    opts[["strings_can_be_null"]] <- opts[["quoted_na"]]
+    opts[["quoted_na"]] <- NULL
+  }
+
   do.call(CsvConvertOptions$create, opts)
 }
 
@@ -461,7 +467,7 @@ csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) {
   # Filter out arguments meant for CsvParseOptions/CsvConvertOptions
   arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options")
   readr_opts <- names(formals(readr_to_csv_parse_options))
-  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "convert_options")
+  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options")
   opts[arrow_opts] <- NULL
   opts[readr_opts] <- NULL
   opts[convert_opts] <- NULL
@@ -473,7 +479,6 @@ csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) {
 
   is_arrow_opt <- !is.na(match(opt_names, arrow_opts))
   is_readr_opt <- !is.na(match(opt_names, readr_opts))
-
   check_ambiguous_options(opt_names, arrow_opts, readr_opts)
 
   null_or_true <- function(x) {
diff --git a/r/R/dataset.R b/r/R/dataset.R
index b7728ff897fff..9d91839c220bb 100644
--- a/r/R/dataset.R
+++ b/r/R/dataset.R
@@ -240,7 +240,6 @@ open_dataset <- function(sources,
 #' @section Options currently supported by [read_delim_arrow()] which are not supported here:
 #' * `file` (instead, please specify files in `sources`)
 #' * `col_select` (instead, subset columns after dataset creation)
-#' * `quoted_na`
 #' * `as_data_frame` (instead, convert to data frame after dataset creation)
 #' * `parse_options`
 #'
@@ -276,7 +275,8 @@ open_delim_dataset <- function(sources,
                                skip = 0L,
                                convert_options = NULL,
                                read_options = NULL,
-                               timestamp_parsers = NULL) {
+                               timestamp_parsers = NULL,
+                               quoted_na = TRUE) {
   open_dataset(
     sources = sources,
     schema = schema,
@@ -296,7 +296,8 @@ open_delim_dataset <- function(sources,
     skip = skip,
     convert_options = convert_options,
     read_options = read_options,
-    timestamp_parsers = timestamp_parsers
+    timestamp_parsers = timestamp_parsers,
+    quoted_na = quoted_na
   )
 }
 
@@ -318,7 +319,8 @@ open_csv_dataset <- function(sources,
                              skip = 0L,
                              convert_options = NULL,
                              read_options = NULL,
-                             timestamp_parsers = NULL) {
+                             timestamp_parsers = NULL,
+                             quoted_na = TRUE) {
   mc <- match.call()
   mc$delim <- ","
   mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow"))
@@ -343,7 +345,8 @@ open_tsv_dataset <- function(sources,
                              skip = 0L,
                              convert_options = NULL,
                              read_options = NULL,
-                             timestamp_parsers = NULL) {
+                             timestamp_parsers = NULL,
+                             quoted_na = TRUE) {
   mc <- match.call()
   mc$delim <- "\t"
   mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow"))
diff --git a/r/man/open_delim_dataset.Rd b/r/man/open_delim_dataset.Rd
index 2bfd047040a8b..cf08302cc6436 100644
--- a/r/man/open_delim_dataset.Rd
+++ b/r/man/open_delim_dataset.Rd
@@ -24,7 +24,8 @@ open_delim_dataset(
   skip = 0L,
   convert_options = NULL,
   read_options = NULL,
-  timestamp_parsers = NULL
+  timestamp_parsers = NULL,
+  quoted_na = TRUE
 )
 
 open_csv_dataset(
@@ -44,7 +45,8 @@ open_csv_dataset(
   skip = 0L,
   convert_options = NULL,
   read_options = NULL,
-  timestamp_parsers = NULL
+  timestamp_parsers = NULL,
+  quoted_na = TRUE
 )
 
 open_tsv_dataset(
@@ -64,7 +66,8 @@ open_tsv_dataset(
   skip = 0L,
   convert_options = NULL,
   read_options = NULL,
-  timestamp_parsers = NULL
+  timestamp_parsers = NULL,
+  quoted_na = TRUE
 )
 }
 \arguments{
@@ -178,6 +181,11 @@ starting from the beginning of this vector. Possible values are:
 \item a character vector of \link[base:strptime]{strptime} parse strings
 \item a list of \link{TimestampParser} objects
 }}
+
+\item{quoted_na}{Should missing values inside quotes be treated as missing
+values (the default) or strings. (Note that this is different from the
+the Arrow C++ default for the corresponding convert option,
+\code{strings_can_be_null}.)}
 }
 \description{
 A wrapper around \link{open_dataset} which explicitly includes parameters mirroring \code{\link[=read_csv_arrow]{read_csv_arrow()}},
@@ -189,7 +197,6 @@ for opening single files and functions for opening datasets.
 \itemize{
 \item \code{file} (instead, please specify files in \code{sources})
 \item \code{col_select} (instead, subset columns after dataset creation)
-\item \code{quoted_na}
 \item \code{as_data_frame} (instead, convert to data frame after dataset creation)
 \item \code{parse_options}
 }
diff --git a/r/tests/testthat/test-dataset-csv.R b/r/tests/testthat/test-dataset-csv.R
index ff1712646a472..e8e7c61fc8848 100644
--- a/r/tests/testthat/test-dataset-csv.R
+++ b/r/tests/testthat/test-dataset-csv.R
@@ -220,7 +220,7 @@ test_that("readr parse options", {
 
   # With not yet supported readr parse options
   expect_error(
-    open_dataset(tsv_dir, partitioning = "part", delim = "\t", quoted_na = TRUE),
+    open_dataset(tsv_dir, partitioning = "part", delim = "\t", col_select = "integer"),
     "supported"
   )
 
@@ -253,7 +253,7 @@ test_that("readr parse options", {
       tsv_dir,
       partitioning = "part",
       format = "text",
-      quo = "\"",
+      del = ","
     ),
     "Ambiguous"
   )
@@ -561,6 +561,16 @@ test_that("open_delim_dataset params passed through to open_dataset", {
 
   expect_named(ds, c("int", "dbl", "lgl", "chr", "fct", "ts"))
 
+  # quoted_na
+  dst_dir <- make_temp_dir()
+  dst_file <- file.path(dst_dir, "data.csv")
+  writeLines("text,num\none,1\ntwo,2\n,3\nfour,4", dst_file)
+  ds <- open_csv_dataset(dst_dir, quoted_na = TRUE) %>% collect()
+  expect_equal(ds$text, c("one", "two", NA, "four"))
+
+  ds <- open_csv_dataset(dst_dir, quoted_na = FALSE) %>% collect()
+  expect_equal(ds$text, c("one", "two", "", "four"))
+
   # timestamp_parsers
   skip("GH-33708: timestamp_parsers don't appear to be working properly")
 

From a0041027902ac71f00572d5b31022ee98502ed6a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 29 Sep 2023 06:11:12 -0700
Subject: [PATCH 435/749] GH-37702: [Java] Add vector validation consistent
 with C++ (#37942)

### Rationale for this change
Make vector validation code more consistent with C++. Add missing checks and have the entry point
be the same so that the code is easier to read/write when working with both languages.

### What changes are included in this PR?
Make vector validation more consistent with Array::Validate() in C++:
* Add validate() and validateFull() instance methods to vectors.
* Validate that VarCharVector and LargeVarCharVector contents are valid UTF-8.
* Validate that DecimalVector and Decimal256Vector contents fit within the supplied precision and scale.
* Validate that NullVectors contain only nulls.
* Validate that FixedSizeBinaryVector values have the correct length.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #37702

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/vector/BaseFixedWidthVector.java    |  7 ++
 .../vector/BaseLargeVariableWidthVector.java  |  7 ++
 .../arrow/vector/BaseVariableWidthVector.java |  7 ++
 .../apache/arrow/vector/Decimal256Vector.java | 13 ++++
 .../apache/arrow/vector/DecimalVector.java    | 13 ++++
 .../arrow/vector/FixedSizeBinaryVector.java   | 13 ++++
 .../arrow/vector/LargeVarCharVector.java      | 12 +++
 .../org/apache/arrow/vector/ValueVector.java  |  9 +++
 .../apache/arrow/vector/VarCharVector.java    | 12 +++
 .../arrow/vector/util/DecimalUtility.java     | 10 ++-
 .../org/apache/arrow/vector/util/Text.java    | 50 ++++++++++---
 .../validate/ValidateVectorDataVisitor.java   |  5 ++
 .../vector/validate/TestValidateVector.java   | 14 ++++
 .../validate/TestValidateVectorFull.java      | 74 +++++++++++++++++++
 14 files changed, 233 insertions(+), 13 deletions(-)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
index 223ae9aa8cb1c..04a038a0b5dfd 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
@@ -550,6 +550,13 @@ private void setReaderAndWriterIndex() {
     }
   }
 
+  /**
+   * Validate the scalar values held by this vector.
+   */
+  public void validateScalars() {
+    // No validation by default.
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param ref name of the target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
index 90694db830cd6..4d5a8a5119c53 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
@@ -643,6 +643,13 @@ public ArrowBuf[] getBuffers(boolean clear) {
     return buffers;
   }
 
+  /**
+   * Validate the scalar values held by this vector.
+   */
+  public void validateScalars() {
+    // No validation by default.
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param ref name of the target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
index 2a89590bf8440..d7f5ff05a935d 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
@@ -685,6 +685,13 @@ public ArrowBuf[] getBuffers(boolean clear) {
     return buffers;
   }
 
+  /**
+   * Validate the scalar values held by this vector.
+   */
+  public void validateScalars() {
+    // No validation by default.
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param ref name of the target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java b/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
index 70a895ff40496..79a9badc3955d 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/Decimal256Vector.java
@@ -35,6 +35,7 @@
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.DecimalUtility;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.validate.ValidateUtil;
 
 
 /**
@@ -527,6 +528,18 @@ public void setSafe(int index, int isSet, long start, ArrowBuf buffer) {
     set(index, isSet, start, buffer);
   }
 
+  @Override
+  public void validateScalars() {
+    for (int i = 0; i < getValueCount(); ++i) {
+      BigDecimal value = getObject(i);
+      if (value != null) {
+        ValidateUtil.validateOrThrow(DecimalUtility.checkPrecisionAndScaleNoThrow(value, getPrecision(), getScale()),
+            "Invalid value for Decimal256Vector at position " + i + ". Value does not fit in precision " +
+                getPrecision() + " and scale " + getScale() + ".");
+      }
+    }
+  }
+
   /*----------------------------------------------------------------*
    |                                                                |
    |                      vector transfer                           |
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java b/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
index 6a3ec60afc52e..d1a3bfc3afb10 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/DecimalVector.java
@@ -35,6 +35,7 @@
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.DecimalUtility;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.validate.ValidateUtil;
 
 /**
  * DecimalVector implements a fixed width vector (16 bytes) of
@@ -526,6 +527,18 @@ public void setSafe(int index, int isSet, long start, ArrowBuf buffer) {
     set(index, isSet, start, buffer);
   }
 
+  @Override
+  public void validateScalars() {
+    for (int i = 0; i < getValueCount(); ++i) {
+      BigDecimal value = getObject(i);
+      if (value != null) {
+        ValidateUtil.validateOrThrow(DecimalUtility.checkPrecisionAndScaleNoThrow(value, getPrecision(), getScale()),
+            "Invalid value for DecimalVector at position " + i + ". Value does not fit in precision " +
+                getPrecision() + " and scale " + getScale() + ".");
+      }
+    }
+  }
+
   /*----------------------------------------------------------------*
    |                                                                |
    |                      vector transfer                           |
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
index 3ce2bb77ccc55..967d560d78dea 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
@@ -31,6 +31,7 @@
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.validate.ValidateUtil;
 
 /**
  * FixedSizeBinaryVector implements a fixed width vector of
@@ -320,6 +321,18 @@ public static byte[] get(final ArrowBuf buffer, final int index, final int byteW
     return dst;
   }
 
+  @Override
+  public void validateScalars() {
+    for (int i = 0; i < getValueCount(); ++i) {
+      byte[] value = get(i);
+      if (value != null) {
+        ValidateUtil.validateOrThrow(value.length == byteWidth,
+            "Invalid value for FixedSizeBinaryVector at position " + i + ". The length was " +
+                value.length + " but the length of each element should be " + byteWidth + ".");
+      }
+    }
+  }
+
   /*----------------------------------------------------------------*
    |                                                                |
    |                      vector transfer                           |
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
index 1f8d9b7d3a85c..e9472c9f2c71e 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
@@ -27,6 +27,7 @@
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.validate.ValidateUtil;
 
 /**
  * LargeVarCharVector implements a variable width vector of VARCHAR
@@ -261,6 +262,17 @@ public void setSafe(int index, Text text) {
     setSafe(index, text.getBytes(), 0, text.getLength());
   }
 
+  @Override
+  public void validateScalars() {
+    for (int i = 0; i < getValueCount(); ++i) {
+      byte[] value = get(i);
+      if (value != null) {
+        ValidateUtil.validateOrThrow(Text.validateUTF8NoThrow(value),
+            "Non-UTF-8 data in VarCharVector at position " + i + ".");
+      }
+    }
+  }
+
   /*----------------------------------------------------------------*
    |                                                                |
    |                      vector transfer                           |
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java b/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
index aa29c29314e33..462b512c65436 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
@@ -29,6 +29,7 @@
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.util.CallBack;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.util.ValueVectorUtility;
 
 /**
  * An abstraction that is used to store a sequence of values in an individual column.
@@ -282,4 +283,12 @@ public interface ValueVector extends Closeable, Iterable<ValueVector> {
    * @return the name of the vector.
    */
   String getName();
+
+  default void validate() {
+    ValueVectorUtility.validate(this);
+  }
+
+  default void validateFull() {
+    ValueVectorUtility.validateFull(this);
+  }
 }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
index bc5c68b29f310..2c83893819a1e 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
@@ -29,6 +29,7 @@
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
+import org.apache.arrow.vector.validate.ValidateUtil;
 
 /**
  * VarCharVector implements a variable width vector of VARCHAR
@@ -261,6 +262,17 @@ public void setSafe(int index, Text text) {
     setSafe(index, text.getBytes(), 0, text.getLength());
   }
 
+  @Override
+  public void validateScalars() {
+    for (int i = 0; i < getValueCount(); ++i) {
+      byte[] value = get(i);
+      if (value != null) {
+        ValidateUtil.validateOrThrow(Text.validateUTF8NoThrow(value),
+            "Non-UTF-8 data in VarCharVector at position " + i + ".");
+      }
+    }
+  }
+
   /*----------------------------------------------------------------*
    |                                                                |
    |                      vector transfer                           |
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/DecimalUtility.java b/java/vector/src/main/java/org/apache/arrow/vector/util/DecimalUtility.java
index 137ac746f4aee..a81169b8f7d73 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/DecimalUtility.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/DecimalUtility.java
@@ -95,11 +95,19 @@ public static boolean checkPrecisionAndScale(BigDecimal value, int vectorPrecisi
     }
     if (value.precision() > vectorPrecision) {
       throw new UnsupportedOperationException("BigDecimal precision can not be greater than that in the Arrow " +
-        "vector: " + value.precision() + " > " + vectorPrecision);
+          "vector: " + value.precision() + " > " + vectorPrecision);
     }
     return true;
   }
 
+  /**
+   * Check that the BigDecimal scale equals the vectorScale and that the BigDecimal precision is
+   * less than or equal to the vectorPrecision. Return true if so, otherwise return false.
+   */
+  public static boolean checkPrecisionAndScaleNoThrow(BigDecimal value, int vectorPrecision, int vectorScale) {
+    return value.scale() == vectorScale && value.precision() < vectorPrecision;
+  }
+
   /**
    * Check that the decimal scale equals the vectorScale and that the decimal precision is
    * less than or equal to the vectorPrecision. If not, then an UnsupportedOperationException is
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java b/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
index b479305c6e39b..778af0ca956df 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
@@ -30,6 +30,7 @@
 import java.text.CharacterIterator;
 import java.text.StringCharacterIterator;
 import java.util.Arrays;
+import java.util.Optional;
 
 import com.fasterxml.jackson.core.JsonGenerationException;
 import com.fasterxml.jackson.core.JsonGenerator;
@@ -466,6 +467,16 @@ public static ByteBuffer encode(String string, boolean replace)
 
   private static final int TRAIL_BYTE = 2;
 
+  /**
+   * Check if a byte array contains valid utf-8.
+   *
+   * @param utf8 byte array
+   * @return true if the input is valid UTF-8. False otherwise.
+   */
+  public static boolean validateUTF8NoThrow(byte[] utf8) {
+    return !validateUTF8Internal(utf8, 0, utf8.length).isPresent();
+  }
+
   /**
    * Check if a byte array contains valid utf-8.
    *
@@ -484,8 +495,22 @@ public static void validateUTF8(byte[] utf8) throws MalformedInputException {
    * @param len   the length of the byte sequence
    * @throws MalformedInputException if the byte array contains invalid bytes
    */
-  public static void validateUTF8(byte[] utf8, int start, int len)
-      throws MalformedInputException {
+  public static void validateUTF8(byte[] utf8, int start, int len) throws MalformedInputException {
+    Optional<Integer> result = validateUTF8Internal(utf8, start, len);
+    if (result.isPresent()) {
+      throw new MalformedInputException(result.get());
+    }
+  }
+
+  /**
+   * Check to see if a byte array is valid utf-8.
+   *
+   * @param utf8  the array of bytes
+   * @param start the offset of the first byte in the array
+   * @param len   the length of the byte sequence
+   * @return the position where a malformed byte occurred or Optional.empty() if the byte array was valid UTF-8.
+   */
+  private static Optional<Integer> validateUTF8Internal(byte[] utf8, int start, int len) {
     int count = start;
     int leadByte = 0;
     int length = 0;
@@ -501,51 +526,51 @@ public static void validateUTF8(byte[] utf8, int start, int len)
           switch (length) {
             case 0: // check for ASCII
               if (leadByte > 0x7F) {
-                throw new MalformedInputException(count);
+                return Optional.of(count);
               }
               break;
             case 1:
               if (leadByte < 0xC2 || leadByte > 0xDF) {
-                throw new MalformedInputException(count);
+                return Optional.of(count);
               }
               state = TRAIL_BYTE_1;
               break;
             case 2:
               if (leadByte < 0xE0 || leadByte > 0xEF) {
-                throw new MalformedInputException(count);
+                return Optional.of(count);
               }
               state = TRAIL_BYTE_1;
               break;
             case 3:
               if (leadByte < 0xF0 || leadByte > 0xF4) {
-                throw new MalformedInputException(count);
+                return Optional.of(count);
               }
               state = TRAIL_BYTE_1;
               break;
             default:
               // too long! Longest valid UTF-8 is 4 bytes (lead + three)
               // or if < 0 we got a trail byte in the lead byte position
-              throw new MalformedInputException(count);
+              return Optional.of(count);
           } // switch (length)
           break;
 
         case TRAIL_BYTE_1:
           if (leadByte == 0xF0 && aByte < 0x90) {
-            throw new MalformedInputException(count);
+            return Optional.of(count);
           }
           if (leadByte == 0xF4 && aByte > 0x8F) {
-            throw new MalformedInputException(count);
+            return Optional.of(count);
           }
           if (leadByte == 0xE0 && aByte < 0xA0) {
-            throw new MalformedInputException(count);
+            return Optional.of(count);
           }
           if (leadByte == 0xED && aByte > 0x9F) {
-            throw new MalformedInputException(count);
+            return Optional.of(count);
           }
           // falls through to regular trail-byte test!!
         case TRAIL_BYTE:
           if (aByte < 0x80 || aByte > 0xBF) {
-            throw new MalformedInputException(count);
+            return Optional.of(count);
           }
           if (--length == 0) {
             state = LEAD_BYTE;
@@ -558,6 +583,7 @@ public static void validateUTF8(byte[] utf8, int start, int len)
       } // switch (state)
       count++;
     }
+    return Optional.empty();
   }
 
   /**
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/validate/ValidateVectorDataVisitor.java b/java/vector/src/main/java/org/apache/arrow/vector/validate/ValidateVectorDataVisitor.java
index cdeb4f1eaa1ca..6d33be7a0dbac 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/validate/ValidateVectorDataVisitor.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/validate/ValidateVectorDataVisitor.java
@@ -85,18 +85,21 @@ private void validateTypeBuffer(ArrowBuf typeBuf, int valueCount) {
 
   @Override
   public Void visit(BaseFixedWidthVector vector, Void value) {
+    vector.validateScalars();
     return null;
   }
 
   @Override
   public Void visit(BaseVariableWidthVector vector, Void value) {
     validateOffsetBuffer(vector, vector.getValueCount());
+    vector.validateScalars();
     return null;
   }
 
   @Override
   public Void visit(BaseLargeVariableWidthVector vector, Void value) {
     validateLargeOffsetBuffer(vector, vector.getValueCount());
+    vector.validateScalars();
     return null;
   }
 
@@ -169,6 +172,8 @@ public Void visit(DenseUnionVector vector, Void value) {
 
   @Override
   public Void visit(NullVector vector, Void value) {
+    ValidateUtil.validateOrThrow(vector.getNullCount() == vector.getValueCount(),
+        "NullVector should have only null entries.");
     return null;
   }
 
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVector.java b/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVector.java
index 2354b281ed41d..20492036dab99 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVector.java
@@ -251,6 +251,20 @@ public void testDenseUnionVector() {
     }
   }
 
+  @Test
+  public void testBaseFixedWidthVectorInstanceMethod() {
+    try (final IntVector vector = new IntVector("v", allocator)) {
+      vector.validate();
+      setVector(vector, 1, 2, 3);
+      vector.validate();
+
+      vector.getDataBuffer().capacity(0);
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          () -> vector.validate());
+      assertTrue(e.getMessage().contains("Not enough capacity for fixed width data buffer"));
+    }
+  }
+
   private void writeStructVector(NullableStructWriter writer, int value1, long value2) {
     writer.start();
     writer.integer("f0").writeInt(value1);
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVectorFull.java b/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVectorFull.java
index 4241a0d9cff93..ca71a622bb8ea 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVectorFull.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/validate/TestValidateVectorFull.java
@@ -23,11 +23,14 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.Decimal256Vector;
+import org.apache.arrow.vector.DecimalVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.LargeVarCharVector;
@@ -231,4 +234,75 @@ public void testDenseUnionVector() {
       assertTrue(e.getMessage().contains("Dense union vector offset exceeds sub-vector boundary"));
     }
   }
+
+  @Test
+  public void testBaseVariableWidthVectorInstanceMethod() {
+    try (final VarCharVector vector = new VarCharVector("v", allocator)) {
+      vector.validateFull();
+      setVector(vector, "aaa", "bbb", "ccc");
+      vector.validateFull();
+
+      ArrowBuf offsetBuf = vector.getOffsetBuffer();
+      offsetBuf.setInt(0, 100);
+      offsetBuf.setInt(4, 50);
+
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          vector::validateFull);
+      assertTrue(e.getMessage().contains("The values in positions 0 and 1 of the offset buffer are decreasing"));
+    }
+  }
+
+  @Test
+  public void testValidateVarCharUTF8() {
+    try (final VarCharVector vector = new VarCharVector("v", allocator)) {
+      vector.validateFull();
+      setVector(vector, "aaa".getBytes(StandardCharsets.UTF_8), "bbb".getBytes(StandardCharsets.UTF_8),
+          new byte[] {(byte) 0xFF, (byte) 0xFE});
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          vector::validateFull);
+      assertTrue(e.getMessage().contains("UTF"));
+    }
+  }
+
+  @Test
+  public void testValidateLargeVarCharUTF8() {
+    try (final LargeVarCharVector vector = new LargeVarCharVector("v", allocator)) {
+      vector.validateFull();
+      setVector(vector, "aaa".getBytes(StandardCharsets.UTF_8), "bbb".getBytes(StandardCharsets.UTF_8),
+          new byte[] {(byte) 0xFF, (byte) 0xFE});
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          vector::validateFull);
+      assertTrue(e.getMessage().contains("UTF"));
+    }
+  }
+
+  @Test
+  public void testValidateDecimal() {
+    try (final DecimalVector vector = new DecimalVector(Field.nullable("v",
+        new ArrowType.Decimal(2, 0, DecimalVector.TYPE_WIDTH * 8)), allocator)) {
+      vector.validateFull();
+      setVector(vector, 1L);
+      vector.validateFull();
+      vector.clear();
+      setVector(vector, Long.MAX_VALUE);
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          vector::validateFull);
+      assertTrue(e.getMessage().contains("Decimal"));
+    }
+  }
+
+  @Test
+  public void testValidateDecimal256() {
+    try (final Decimal256Vector vector = new Decimal256Vector(Field.nullable("v",
+        new ArrowType.Decimal(2, 0, DecimalVector.TYPE_WIDTH * 8)), allocator)) {
+      vector.validateFull();
+      setVector(vector, 1L);
+      vector.validateFull();
+      vector.clear();
+      setVector(vector, Long.MAX_VALUE);
+      ValidateUtil.ValidateException e = assertThrows(ValidateUtil.ValidateException.class,
+          vector::validateFull);
+      assertTrue(e.getMessage().contains("Decimal"));
+    }
+  }
 }

From 816eac4579775b45771fd0f462b73f5a68a87d4b Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Sat, 30 Sep 2023 01:11:33 +0800
Subject: [PATCH 436/749] GH-37851: [C++] IPC: ArrayLoader style enhancement
 (#37872)

### Rationale for this change

Enhance the style of `arrow::ipc::ArrayLoader`'s `SkipField`

### What changes are included in this PR?

Set `out_` to `nullptr` when `SkipField` is called.

### Are these changes tested?

No

### Are there any user-facing changes?

No

* Closes: #37851

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/ipc/reader.cc | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index 0def0e036e3c1..6e801e1f8adb7 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -205,7 +205,10 @@ class ArrayLoader {
     }
   }
 
-  Status LoadType(const DataType& type) { return VisitTypeInline(type, this); }
+  Status LoadType(const DataType& type) {
+    DCHECK_NE(out_, nullptr);
+    return VisitTypeInline(type, this);
+  }
 
   Status Load(const Field* field, ArrayData* out) {
     if (max_recursion_depth_ <= 0) {
@@ -223,6 +226,9 @@ class ArrayLoader {
     skip_io_ = true;
     Status status = Load(field, &dummy);
     skip_io_ = false;
+    // GH-37851: Reset state. Load will set `out_` to `&dummy`, which would
+    // be a dangling pointer.
+    out_ = nullptr;
     return status;
   }
 
@@ -258,6 +264,7 @@ class ArrayLoader {
   }
 
   Status LoadCommon(Type::type type_id) {
+    DCHECK_NE(out_, nullptr);
     // This only contains the length and null count, which we need to figure
     // out what to do with the buffers. For example, if null_count == 0, then
     // we can skip that buffer without reading from shared memory
@@ -276,6 +283,7 @@ class ArrayLoader {
 
   template <typename TYPE>
   Status LoadPrimitive(Type::type type_id) {
+    DCHECK_NE(out_, nullptr);
     out_->buffers.resize(2);
 
     RETURN_NOT_OK(LoadCommon(type_id));
@@ -290,6 +298,7 @@ class ArrayLoader {
 
   template <typename TYPE>
   Status LoadBinary(Type::type type_id) {
+    DCHECK_NE(out_, nullptr);
     out_->buffers.resize(3);
 
     RETURN_NOT_OK(LoadCommon(type_id));
@@ -299,6 +308,7 @@ class ArrayLoader {
 
   template <typename TYPE>
   Status LoadList(const TYPE& type) {
+    DCHECK_NE(out_, nullptr);
     out_->buffers.resize(2);
 
     RETURN_NOT_OK(LoadCommon(type.id()));
@@ -313,6 +323,7 @@ class ArrayLoader {
   }
 
   Status LoadChildren(const std::vector<std::shared_ptr<Field>>& child_fields) {
+    DCHECK_NE(out_, nullptr);
     ArrayData* parent = out_;
 
     parent->child_data.resize(child_fields.size());
@@ -2010,7 +2021,7 @@ class StreamDecoder::StreamDecoderImpl : public StreamDecoderInternal {
 };
 
 StreamDecoder::StreamDecoder(std::shared_ptr<Listener> listener, IpcReadOptions options) {
-  impl_.reset(new StreamDecoderImpl(std::move(listener), options));
+  impl_ = std::make_unique<StreamDecoderImpl>(std::move(listener), options);
 }
 
 StreamDecoder::~StreamDecoder() {}

From 1bd3cba84a1187e594655b2ba4880214dcc73e63 Mon Sep 17 00:00:00 2001
From: Angela Li <angela-li@users.noreply.github.com>
Date: Fri, 29 Sep 2023 15:37:39 -0400
Subject: [PATCH 437/749] MINOR: [R][Documentation] Add default descriptions in
 CsvParseOptions$create() docs (#37909)

### Rationale for this change

Add more function documentation for folks who want to manually change `quote_char` or `escape_char` options in `CsvParseOptions$create()`, as I did in #37908.

I had to go through the source code to arrow/r/R/csv.R - [line 587](https://github.com/apache/arrow/blob/7dc9f69a8a77345d0ec7920af9224ef96d7f5f78/r/R/csv.R#L587) to find the default argument, which was a pain.

### What changes are included in this PR?

Documentation changes

### Are these changes tested?

No - not changing underlying code. Maintainers might need to rebuild package to include these changes in man/ folder

### Are there any user-facing changes?

Yes, on documentation of methods.

Lead-authored-by: Angela Li <angela-li@users.noreply.github.com>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/csv.R               | 4 ++--
 r/man/CsvReadOptions.Rd | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index b119d16a84c06..116c620f83490 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -404,10 +404,10 @@ CsvTableReader$create <- function(file,
 #'
 #' - `delimiter` Field delimiting character (default `","`)
 #' - `quoting` Logical: are strings quoted? (default `TRUE`)
-#' - `quote_char` Quoting character, if `quoting` is `TRUE`
+#' - `quote_char` Quoting character, if `quoting` is `TRUE` (default `'"'`)
 #' - `double_quote` Logical: are quotes inside values double-quoted? (default `TRUE`)
 #' - `escaping` Logical: whether escaping is used (default `FALSE`)
-#' - `escape_char` Escaping character, if `escaping` is `TRUE`
+#' - `escape_char` Escaping character, if `escaping` is `TRUE` (default `"\\"`)
 #' - `newlines_in_values` Logical: are values allowed to contain CR (`0x0d`)
 #'    and LF (`0x0a`) characters? (default `FALSE`)
 #' - `ignore_empty_lines` Logical: should empty lines be ignored (default) or
diff --git a/r/man/CsvReadOptions.Rd b/r/man/CsvReadOptions.Rd
index a18ff959ce7e5..6ebb2355184c1 100644
--- a/r/man/CsvReadOptions.Rd
+++ b/r/man/CsvReadOptions.Rd
@@ -52,10 +52,10 @@ The order of application is as follows:
 \itemize{
 \item \code{delimiter} Field delimiting character (default \code{","})
 \item \code{quoting} Logical: are strings quoted? (default \code{TRUE})
-\item \code{quote_char} Quoting character, if \code{quoting} is \code{TRUE}
+\item \code{quote_char} Quoting character, if \code{quoting} is \code{TRUE} (default \code{'"'})
 \item \code{double_quote} Logical: are quotes inside values double-quoted? (default \code{TRUE})
 \item \code{escaping} Logical: whether escaping is used (default \code{FALSE})
-\item \code{escape_char} Escaping character, if \code{escaping} is \code{TRUE}
+\item \code{escape_char} Escaping character, if \code{escaping} is \code{TRUE} (default \code{"\\\\"})
 \item \code{newlines_in_values} Logical: are values allowed to contain CR (\code{0x0d})
 and LF (\code{0x0a}) characters? (default \code{FALSE})
 \item \code{ignore_empty_lines} Logical: should empty lines be ignored (default) or

From 00efb06dc0de9c40907576811ebb546198b7f528 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 29 Sep 2023 16:16:50 -0400
Subject: [PATCH 438/749] GH-37835: [MATLAB] Improve `arrow.tabular.Schema`
 display (#37836)

### Rationale for this change

We would like to change how `arrow.tabular.Schema`s are displayed in the Command Window. Below is the current display:

```matlab
>> field1 =  arrow.field("A", arrow.time32());
>> field2 = arrow.field("B", arrow.boolean());
>>s = arrow.schema([field1 field2])

s =

A: time32[s]
B: bool
```

This display is not very MATLAB-like.

### What changes are included in this PR?

1. Updated the display of `arrow.tabular.Schema`. Below is the new display:

```matlab
>> field1 =  arrow.field("A", arrow.time32());
>> field2 = arrow.field("B", arrow.boolean());
>> s = arrow.schema([field1 field2])

s =

  Arrow Schema with 2 fields:

    A: Time32 | B: Boolean
```

When MATLAB is opened in desktop mode, `Schema`, `Time32`, and `Boolean` are hyperlinks users can click on to view the help text for the different class types.

### Are these changes tested?

Yes. Added three new test cases to `tSchema.m`:
1. `TestDisplaySchemaZeroFields`
2. `TestDisplaySchemaOneField`
3. `TestDisplaySchemaMultipleFields`

### Are there any user-facing changes?

Yes. `arrow.tabular.Schema`s will be displayed differently in the Command Window.

### Notes

Once #37826 is merged, I will rebase my changes and mark this PR as ready for review.
* Closes: #37835

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../cpp/arrow/matlab/tabular/proxy/schema.cc  | 11 ----
 .../cpp/arrow/matlab/tabular/proxy/schema.h   |  1 -
 .../+arrow/+tabular/+internal/displaySchema.m | 50 +++++++++++++++
 matlab/src/matlab/+arrow/+tabular/Schema.m    | 25 +++++---
 matlab/test/arrow/tabular/tSchema.m           | 63 +++++++++++++++++++
 5 files changed, 131 insertions(+), 19 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m

diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
index ec1ac1eecb2fd..023381e005969 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.cc
@@ -34,7 +34,6 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(Schema, getFieldByName);
         REGISTER_METHOD(Schema, getNumFields);
         REGISTER_METHOD(Schema, getFieldNames);
-        REGISTER_METHOD(Schema, toString);
     }
 
     libmexclass::proxy::MakeResult Schema::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
@@ -141,14 +140,4 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = field_names_mda;
     }
 
-    void Schema::toString(libmexclass::proxy::method::Context& context) {
-        namespace mda = ::matlab::data;
-        mda::ArrayFactory factory;
-
-        const auto str_utf8 = schema->ToString();
-        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
-        auto str_mda = factory.createScalar(str_utf16);
-        context.outputs[0] = str_mda;
-    }
-
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
index 30883bc2a85ac..9ca4a94e53071 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/schema.h
@@ -39,7 +39,6 @@ namespace arrow::matlab::tabular::proxy {
             void getFieldByName(libmexclass::proxy::method::Context& context);
             void getNumFields(libmexclass::proxy::method::Context& context);
             void getFieldNames(libmexclass::proxy::method::Context& context);
-            void toString(libmexclass::proxy::method::Context& context);
 
             std::shared_ptr<arrow::Schema> schema;
     };
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m b/matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m
new file mode 100644
index 0000000000000..8d6740b195abc
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m
@@ -0,0 +1,50 @@
+%DISPLAYSCHEMA Generates arrow.tabular.Schema display text.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function text = displaySchema(schema)
+    fields = schema.Fields;
+    names = [fields.Name];
+    types = [fields.Type];
+    typeIDs = string([types.ID]);
+
+    % Use <empty> as the sentinel for field names with zero characters.
+    idx = strlength(names) == 0;
+    names(idx) = "<empty>";
+
+    if usejava("desktop")
+        % When in desktop mode, the Command Window can interpret HTML tags
+        % to display bold font and hyperlinks.
+        names = compose("<strong>%s</strong>", names);
+        classNames = arrayfun(@(type) string(class(type)), types);
+
+        % Creates a string array with the following form:
+        %  
+        % ["arrow.type.BooleanType" "Boolean" "arrow.type.StringType" "String" ...]
+        %
+        % This string array is passed to the compose call below. The 
+        % format specifier operator supplied to compose contains two 
+        % formatting operators (%s), so compose uses two elements from the
+        % string array (classNameAndIDs) at a time.
+        classNameAndIDs = strings([1 numel(typeIDs) * 2]);
+        classNameAndIDs(1:2:end-1) = classNames;
+        classNameAndIDs(2:2:end) = typeIDs;
+        typeIDs = compose("<a href=""matlab:helpPopup %s"" style=""font-weight:bold"">%s</a>", classNameAndIDs);
+    end
+
+    text = names + ": " + typeIDs;
+    text = "    " + strjoin(text, " | ");
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index f679b1e0bc22c..3ee40f0e14293 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -97,18 +97,29 @@
         end
     end
 
-    methods (Access = private)
+    methods (Access=protected)
 
-        function str = toString(obj)
-            str = obj.Proxy.toString();
+        function header = getHeader(obj)
+            name = matlab.mixin.CustomDisplay.getClassNameForHeader(obj);
+            numFields = obj.NumFields;
+            if numFields == 0
+                header = compose("  Arrow %s with 0 fields" + newline, name);
+            elseif numFields == 1
+                header = compose("  Arrow %s with %d field:" + newline, name, numFields);
+            else
+                header = compose("  Arrow %s with %d fields:" + newline, name, numFields);
+            end
         end
 
-    end
+        function displayScalarObject(obj)
+            disp(getHeader(obj));
+            numFields = obj.NumFields;
 
-    methods (Access=protected)
+            if numFields > 0
+                text = arrow.tabular.internal.displaySchema(obj);
+                disp(text + newline);
+            end
 
-        function displayScalarObject(obj)
-            disp(obj.toString());
         end
 
     end
diff --git a/matlab/test/arrow/tabular/tSchema.m b/matlab/test/arrow/tabular/tSchema.m
index e4c706d9a3d6c..bb95c1823b9fc 100644
--- a/matlab/test/arrow/tabular/tSchema.m
+++ b/matlab/test/arrow/tabular/tSchema.m
@@ -526,7 +526,70 @@ function TestIsEqualFalse(testCase)
 
             % Compare schema to double
             testCase.verifyFalse(isequal(schema4, 5));
+        end
+
+        function TestDisplaySchemaZeroFields(testCase)
+            import arrow.internal.test.display.makeLinkString
+
+            schema = arrow.schema(arrow.type.Field.empty(0, 0)); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.tabular.Schema",...
+                                            ClassName="Schema", BoldFont=true);
+            expectedDisplay = "  Arrow " + classnameLink + " with 0 fields" + newline;
+            expectedDisplay = char(expectedDisplay + newline);
+            actualDisplay = evalc('disp(schema)');
+            testCase.verifyEqual(actualDisplay, char(expectedDisplay));
+        end
+
+        function TestDisplaySchemaOneField(testCase)
+            import arrow.internal.test.display.makeLinkString
+
+            schema = arrow.schema(arrow.field("TestField", arrow.boolean())); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.tabular.Schema",...
+                                            ClassName="Schema", BoldFont=true);
+            header = "  Arrow " + classnameLink + " with 1 field:" + newline;
+            indent = "    ";
+
+            if usejava("desktop")
+                type = makeLinkString(FullClassName="arrow.type.BooleanType", ...
+                                      ClassName="Boolean", BoldFont=true);
+                name = "<strong>TestField</strong>: ";
+                fieldLine = indent + name + type + newline;
+            else
+                fieldLine = indent + "TestField: Boolean" + newline;
+            end
+            expectedDisplay = join([header, fieldLine], newline);
+            expectedDisplay = char(expectedDisplay + newline);
+            actualDisplay = evalc('disp(schema)');
+            testCase.verifyEqual(actualDisplay, char(expectedDisplay));
+        end
 
+        function TestDisplaySchemaField(testCase)
+            import arrow.internal.test.display.makeLinkString
+
+            field1 = arrow.field("Field1", arrow.timestamp());
+            field2 = arrow.field("Field2", arrow.string());
+            schema = arrow.schema([field1, field2]); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.tabular.Schema",...
+                                            ClassName="Schema", BoldFont=true);
+            header = "  Arrow " + classnameLink + " with 2 fields:" + newline;
+
+            indent = "    ";
+            if usejava("desktop")
+                type1 = makeLinkString(FullClassName="arrow.type.TimestampType", ...
+                                       ClassName="Timestamp", BoldFont=true);
+                field1String = "<strong>Field1</strong>: " + type1;
+                type2 = makeLinkString(FullClassName="arrow.type.StringType", ...
+                                      ClassName="String", BoldFont=true);
+                field2String = "<strong>Field2</strong>: " + type2;
+                fieldLine = indent + field1String + " | " + field2String + newline;
+            else
+                fieldLine = indent + "Field1: Timestamp | Field2: String" + newline;
+            end
+
+            expectedDisplay = join([header, fieldLine], newline);
+            expectedDisplay = char(expectedDisplay + newline);
+            actualDisplay = evalc('disp(schema)');
+            testCase.verifyEqual(actualDisplay, char(expectedDisplay));
         end
 
     end

From ffdb9274abb7401289a671274b52ae10ce830b00 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 04:42:13 +0900
Subject: [PATCH 439/749] MINOR: [JS] Bump eslint-plugin-jest from 27.2.3 to
 27.4.2 in /js (#37963)

Bumps [eslint-plugin-jest](https://github.com/jest-community/eslint-plugin-jest) from 27.2.3 to 27.4.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/jest-community/eslint-plugin-jest/releases">eslint-plugin-jest's releases</a>.</em></p>
<blockquote>
<h2>v27.4.2</h2>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.4.1...v27.4.2">27.4.2</a> (2023-09-29)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>make rule message punctuation consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1444">#1444</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/84121eee018cc8cc32e6c7a267fc27efd3a4a0a0">84121ee</a>)</li>
</ul>
<h2>v27.4.1</h2>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.4.0...v27.4.1">27.4.1</a> (2023-09-29)</h2>
<h3>Bug Fixes</h3>
<ul>
<li><strong>no-focused-tests:</strong> make reporting location consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1443">#1443</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/a87177504430d1c469af70d6fc3b674a388291d8">a871775</a>)</li>
</ul>
<h2>v27.4.0</h2>
<h1><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.3.0...v27.4.0">27.4.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li><strong>valid-title:</strong> support ignoring leading and trailing whitespace (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1433">#1433</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/bc96473488e004885d8926dc716ef96f889c3d1b">bc96473</a>)</li>
</ul>
<h2>v27.3.0</h2>
<h1><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.3...v27.3.0">27.3.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li>add <code>no-confusing-set-time</code> rule (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1425">#1425</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/ff8e482380b36bf8423dac7f9fb6340aca8ae313">ff8e482</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/jest-community/eslint-plugin-jest/blob/main/CHANGELOG.md">eslint-plugin-jest's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.4.1...v27.4.2">27.4.2</a> (2023-09-29)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>make rule message punctuation consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1444">#1444</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/84121eee018cc8cc32e6c7a267fc27efd3a4a0a0">84121ee</a>)</li>
</ul>
<h2><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.4.0...v27.4.1">27.4.1</a> (2023-09-29)</h2>
<h3>Bug Fixes</h3>
<ul>
<li><strong>no-focused-tests:</strong> make reporting location consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1443">#1443</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/a87177504430d1c469af70d6fc3b674a388291d8">a871775</a>)</li>
</ul>
<h1><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.3.0...v27.4.0">27.4.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li><strong>valid-title:</strong> support ignoring leading and trailing whitespace (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1433">#1433</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/bc96473488e004885d8926dc716ef96f889c3d1b">bc96473</a>)</li>
</ul>
<h1><a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.3...v27.3.0">27.3.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li>add <code>no-confusing-set-time</code> rule (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1425">#1425</a>) (<a href="https://github.com/jest-community/eslint-plugin-jest/commit/ff8e482380b36bf8423dac7f9fb6340aca8ae313">ff8e482</a>)</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/094ac10d0734a6bfb1560e328b3a3f2ce83773fe"><code>094ac10</code></a> chore(release): 27.4.2 [skip ci]</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/0ec155aecfbd23868dde003a337f8c36f017497a"><code>0ec155a</code></a> chore(deps): update dependency semantic-release to v22 (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1434">#1434</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/84121eee018cc8cc32e6c7a267fc27efd3a4a0a0"><code>84121ee</code></a> fix: make rule message punctuation consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1444">#1444</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/90488deeb78d31ce5fce5efda99e87db1283f103"><code>90488de</code></a> chore(release): 27.4.1 [skip ci]</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/a87177504430d1c469af70d6fc3b674a388291d8"><code>a871775</code></a> fix(no-focused-tests): make reporting location consistent (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1443">#1443</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/1ee0087d634b4081c07726acf27cfbd0e7cede1b"><code>1ee0087</code></a> refactor(max-nested-describe): simplify implementation (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1442">#1442</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/c846f7f59b737f66c32ddc18182b69e39fff4e65"><code>c846f7f</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/e7901934fcb11a06287d1b8394ae376554c25138"><code>e790193</code></a> chore(deps): update danger/danger-js action to v11.3.0 (<a href="https://redirect.github.com/jest-community/eslint-plugin-jest/issues/1437">#1437</a>)</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/225c3cff96ebd4f5fce27abf31f15af2f534137f"><code>225c3cf</code></a> chore(deps): lock file maintenance</li>
<li><a href="https://github.com/jest-community/eslint-plugin-jest/commit/42fec488a0185015a7643e56cc28e3ca96a59b2b"><code>42fec48</code></a> chore(release): 27.4.0 [skip ci]</li>
<li>Additional commits viewable in <a href="https://github.com/jest-community/eslint-plugin-jest/compare/v27.2.3...v27.4.2">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=eslint-plugin-jest&package-manager=npm_and_yarn&previous-version=27.2.3&new-version=27.4.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json | 2 +-
 js/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/package.json b/js/package.json
index 11bbe24f0244c..d3b06ae43f23f 100644
--- a/js/package.json
+++ b/js/package.json
@@ -82,7 +82,7 @@
     "esbuild": "0.19.2",
     "esbuild-plugin-alias": "0.2.1",
     "eslint": "8.42.0",
-    "eslint-plugin-jest": "27.2.3",
+    "eslint-plugin-jest": "27.4.2",
     "eslint-plugin-unicorn": "47.0.0",
     "esm": "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz",
     "glob": "10.2.7",
diff --git a/js/yarn.lock b/js/yarn.lock
index 66ede59a598b1..9805f706946f2 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -2766,10 +2766,10 @@ escape-string-regexp@^4.0.0:
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
-eslint-plugin-jest@27.2.3:
-  version "27.2.3"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jest/-/eslint-plugin-jest-27.2.3.tgz#6f8a4bb2ca82c0c5d481d1b3be256ab001f5a3ec"
-  integrity sha512-sRLlSCpICzWuje66Gl9zvdF6mwD5X86I4u55hJyFBsxYOsBCmT5+kSUjf+fkFWVMMgpzNEupjW8WzUqi83hJAQ==
+eslint-plugin-jest@27.4.2:
+  version "27.4.2"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jest/-/eslint-plugin-jest-27.4.2.tgz#181d999ac67a9b6040db1d27935887cf5a2882ed"
+  integrity sha512-3Nfvv3wbq2+PZlRTf2oaAWXWwbdBejFRBR2O8tAO67o+P8zno+QGbcDYaAXODlreXVg+9gvWhKKmG2rgfb8GEg==
   dependencies:
     "@typescript-eslint/utils" "^5.10.0"
 

From ff98e7d43de44caa6650a5cfbc395986809900f2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 04:43:07 +0900
Subject: [PATCH 440/749] MINOR: [JS] Bump memfs from 4.2.1 to 4.5.0 in /js
 (#37964)

Bumps [memfs](https://github.com/streamich/memfs) from 4.2.1 to 4.5.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/streamich/memfs/releases">memfs's releases</a>.</em></p>
<blockquote>
<h2>v4.5.0</h2>
<h1><a href="https://github.com/streamich/memfs/compare/v4.4.0...v4.5.0">4.5.0</a> (2023-09-25)</h1>
<h3>Features</h3>
<ul>
<li><strong>volume:</strong> <code>fromJSON</code> now accepts <code>Buffer</code> as volume content (<a href="https://redirect.github.com/streamich/memfs/issues/880">#880</a>) (<a href="https://github.com/streamich/memfs/commit/9c0a6ffbc2bd1f1ffdfd2c8ec3c75e382713e698">9c0a6ff</a>)</li>
</ul>
<h2>v4.4.0</h2>
<h1><a href="https://github.com/streamich/memfs/compare/v4.3.0...v4.4.0">4.4.0</a> (2023-09-22)</h1>
<h3>Features</h3>
<ul>
<li><strong>volume:</strong> <code>toJSON</code> now accepts the <code>asBuffer</code> parameter (<a href="https://redirect.github.com/streamich/memfs/issues/952">#952</a>) (<a href="https://github.com/streamich/memfs/commit/91a3742276f00bfb2dda245c364780682c0b1784">91a3742</a>)</li>
<li><strong>volume:</strong> implement readv and writev (<a href="https://redirect.github.com/streamich/memfs/issues/946">#946</a>) (<a href="https://github.com/streamich/memfs/commit/966e17ef5a00c041be88d9b2fd60cfdd83dffac7">966e17e</a>)</li>
</ul>
<h2>v4.3.0</h2>
<h1><a href="https://github.com/streamich/memfs/compare/v4.2.3...v4.3.0">4.3.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li>add support for <code>O_SYMLINK</code> (<a href="https://redirect.github.com/streamich/memfs/issues/944">#944</a>) (<a href="https://github.com/streamich/memfs/commit/96cbce4145891af9d943d00868b3357969508330">96cbce4</a>)</li>
</ul>
<h2>v4.2.3</h2>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.2...v4.2.3">4.2.3</a> (2023-09-15)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>add missing nanosecond-precision properties to Stats (<a href="https://redirect.github.com/streamich/memfs/issues/943">#943</a>) (<a href="https://github.com/streamich/memfs/commit/b9d4c6daf19f75784ade8ebb8ac17afefe6442e9">b9d4c6d</a>)</li>
</ul>
<h2>v4.2.2</h2>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.1...v4.2.2">4.2.2</a> (2023-09-15)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>support directories named <code>__proto__</code> (<a href="https://redirect.github.com/streamich/memfs/issues/945">#945</a>) (<a href="https://github.com/streamich/memfs/commit/8d92a0b0501eab18622febb7c4e551026b515c3b">8d92a0b</a>), closes <a href="https://redirect.github.com/streamich/memfs/issues/938">#938</a></li>
</ul>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/streamich/memfs/blob/master/CHANGELOG.md">memfs's changelog</a>.</em></p>
<blockquote>
<h1><a href="https://github.com/streamich/memfs/compare/v4.4.0...v4.5.0">4.5.0</a> (2023-09-25)</h1>
<h3>Features</h3>
<ul>
<li><strong>volume:</strong> <code>fromJSON</code> now accepts <code>Buffer</code> as volume content (<a href="https://redirect.github.com/streamich/memfs/issues/880">#880</a>) (<a href="https://github.com/streamich/memfs/commit/9c0a6ffbc2bd1f1ffdfd2c8ec3c75e382713e698">9c0a6ff</a>)</li>
</ul>
<h1><a href="https://github.com/streamich/memfs/compare/v4.3.0...v4.4.0">4.4.0</a> (2023-09-22)</h1>
<h3>Features</h3>
<ul>
<li><strong>volume:</strong> <code>toJSON</code> now accepts the <code>asBuffer</code> parameter (<a href="https://redirect.github.com/streamich/memfs/issues/952">#952</a>) (<a href="https://github.com/streamich/memfs/commit/91a3742276f00bfb2dda245c364780682c0b1784">91a3742</a>)</li>
<li><strong>volume:</strong> implement readv and writev (<a href="https://redirect.github.com/streamich/memfs/issues/946">#946</a>) (<a href="https://github.com/streamich/memfs/commit/966e17ef5a00c041be88d9b2fd60cfdd83dffac7">966e17e</a>)</li>
</ul>
<h1><a href="https://github.com/streamich/memfs/compare/v4.2.3...v4.3.0">4.3.0</a> (2023-09-15)</h1>
<h3>Features</h3>
<ul>
<li>add support for <code>O_SYMLINK</code> (<a href="https://redirect.github.com/streamich/memfs/issues/944">#944</a>) (<a href="https://github.com/streamich/memfs/commit/96cbce4145891af9d943d00868b3357969508330">96cbce4</a>)</li>
</ul>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.2...v4.2.3">4.2.3</a> (2023-09-15)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>add missing nanosecond-precision properties to Stats (<a href="https://redirect.github.com/streamich/memfs/issues/943">#943</a>) (<a href="https://github.com/streamich/memfs/commit/b9d4c6daf19f75784ade8ebb8ac17afefe6442e9">b9d4c6d</a>)</li>
</ul>
<h2><a href="https://github.com/streamich/memfs/compare/v4.2.1...v4.2.2">4.2.2</a> (2023-09-15)</h2>
<h3>Bug Fixes</h3>
<ul>
<li>support directories named <code>__proto__</code> (<a href="https://redirect.github.com/streamich/memfs/issues/945">#945</a>) (<a href="https://github.com/streamich/memfs/commit/8d92a0b0501eab18622febb7c4e551026b515c3b">8d92a0b</a>), closes <a href="https://redirect.github.com/streamich/memfs/issues/938">#938</a></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/streamich/memfs/commit/7fc1f7edd48b5a7101fdca5257ab8c95c4dee785"><code>7fc1f7e</code></a> chore(release): 4.5.0 [skip ci]</li>
<li><a href="https://github.com/streamich/memfs/commit/9c0a6ffbc2bd1f1ffdfd2c8ec3c75e382713e698"><code>9c0a6ff</code></a> feat(volume): <code>fromJSON</code> now accepts <code>Buffer</code> as volume content (<a href="https://redirect.github.com/streamich/memfs/issues/880">#880</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/d1d66f6dbbe0eeca5a576f7f727a3aaf400b6adb"><code>d1d66f6</code></a> chore(release): 4.4.0 [skip ci]</li>
<li><a href="https://github.com/streamich/memfs/commit/91a3742276f00bfb2dda245c364780682c0b1784"><code>91a3742</code></a> feat(volume): <code>toJSON</code> now accepts the <code>asBuffer</code> parameter (<a href="https://redirect.github.com/streamich/memfs/issues/952">#952</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/966e17ef5a00c041be88d9b2fd60cfdd83dffac7"><code>966e17e</code></a> feat(volume): implement readv and writev (<a href="https://redirect.github.com/streamich/memfs/issues/946">#946</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/125a9968afaa5caa2e7068f4446fe1372f298591"><code>125a996</code></a> chore: sort package.json (<a href="https://redirect.github.com/streamich/memfs/issues/950">#950</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/539a78d1ab2b2143e3f496610b0407959d51b575"><code>539a78d</code></a> chore(deps): update jest monorepo to v29 (major) (<a href="https://redirect.github.com/streamich/memfs/issues/844">#844</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/b15a80ebff5fb2746e43ccc8db98d4dbab5fdc7b"><code>b15a80e</code></a> chore(release): 4.3.0 [skip ci]</li>
<li><a href="https://github.com/streamich/memfs/commit/96cbce4145891af9d943d00868b3357969508330"><code>96cbce4</code></a> feat: add support for <code>O_SYMLINK</code> (<a href="https://redirect.github.com/streamich/memfs/issues/944">#944</a>)</li>
<li><a href="https://github.com/streamich/memfs/commit/f6d988df8cb40cabed7dbf662319048c0dfeb960"><code>f6d988d</code></a> chore(release): 4.2.3 [skip ci]</li>
<li>Additional commits viewable in <a href="https://github.com/streamich/memfs/compare/v4.2.1...v4.5.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=memfs&package-manager=npm_and_yarn&previous-version=4.2.1&new-version=4.5.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json | 2 +-
 js/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/package.json b/js/package.json
index d3b06ae43f23f..e3c3b946a0b12 100644
--- a/js/package.json
+++ b/js/package.json
@@ -99,7 +99,7 @@
     "ix": "5.0.0",
     "jest": "29.6.2",
     "jest-silent-reporter": "0.5.0",
-    "memfs": "4.2.1",
+    "memfs": "4.5.0",
     "mkdirp": "3.0.1",
     "multistream": "4.1.0",
     "randomatic": "3.1.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index 9805f706946f2..d16bcf191e9d6 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -4931,10 +4931,10 @@ math-random@^1.0.1:
   resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
   integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==
 
-memfs@4.2.1:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/memfs/-/memfs-4.2.1.tgz#8c5a48707a460dde8e734b15e405e8377db2bec5"
-  integrity sha512-CINEB6cNAAhLUfRGrB4lj2Pj47ygerEmw3jxPb6R1gkD6Jfp484gJLteQ6MzqIjGWtFWuVzDl+KN7HiipMuKSw==
+memfs@4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/memfs/-/memfs-4.5.0.tgz#03082709987760022275e0d3bc0f24545b7fe279"
+  integrity sha512-8QePW5iXi/ZCySFTo39h3ujKGT0rYVnZywuSo5AzR7POAuy4uBEFZKziYkkrlGdWuxACUxKAJ0L/sry3DSG+TA==
   dependencies:
     json-joy "^9.2.0"
     thingies "^1.11.1"

From a381c05d596cddd341437de6b277520345f9bb8e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 04:44:34 +0900
Subject: [PATCH 441/749] MINOR: [JS] Bump del from 7.0.0 to 7.1.0 in /js
 (#37967)

Bumps [del](https://github.com/sindresorhus/del) from 7.0.0 to 7.1.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/sindresorhus/del/releases">del's releases</a>.</em></p>
<blockquote>
<h2>v7.1.0</h2>
<ul>
<li>Add <code>path</code> to <code>onProgress</code> event (<a href="https://redirect.github.com/sindresorhus/del/issues/155">#155</a>)  f5d31e6</li>
</ul>
<p><a href="https://github.com/sindresorhus/del/compare/v7.0.0...v7.1.0">https://github.com/sindresorhus/del/compare/v7.0.0...v7.1.0</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/sindresorhus/del/commit/7df7949f4fc98477b904fec0e3e444536d579ddb"><code>7df7949</code></a> 7.1.0</li>
<li><a href="https://github.com/sindresorhus/del/commit/f5d31e6136bc675b33375edddc0bdda93046615a"><code>f5d31e6</code></a> Add <code>path</code> to <code>onProgress</code> event (<a href="https://redirect.github.com/sindresorhus/del/issues/155">#155</a>)</li>
<li><a href="https://github.com/sindresorhus/del/commit/e9b0d71d1bd4f00b112a12e7daef441482cedb1c"><code>e9b0d71</code></a> Fix CI</li>
<li><a href="https://github.com/sindresorhus/del/commit/9e17de8ea4517d88ccd7eac227ea9e0939ffe445"><code>9e17de8</code></a> Document <code>dot</code> option (<a href="https://redirect.github.com/sindresorhus/del/issues/148">#148</a>)</li>
<li>See full diff in <a href="https://github.com/sindresorhus/del/compare/v7.0.0...v7.1.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=del&package-manager=npm_and_yarn&previous-version=7.0.0&new-version=7.1.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 16 +---------------
 2 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/js/package.json b/js/package.json
index e3c3b946a0b12..dfb17d24c2f41 100644
--- a/js/package.json
+++ b/js/package.json
@@ -77,7 +77,7 @@
     "async-done": "2.0.0",
     "benny": "3.7.1",
     "cross-env": "7.0.3",
-    "del": "7.0.0",
+    "del": "7.1.0",
     "del-cli": "5.1.0",
     "esbuild": "0.19.2",
     "esbuild-plugin-alias": "0.2.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index d16bcf191e9d6..647b696931bb0 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -2495,21 +2495,7 @@ del-cli@5.1.0:
     del "^7.1.0"
     meow "^10.1.3"
 
-del@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/del/-/del-7.0.0.tgz#79db048bec96f83f344b46c1a66e35d9c09fe8ac"
-  integrity sha512-tQbV/4u5WVB8HMJr08pgw0b6nG4RGt/tj+7Numvq+zqcvUFeMaIWWOUFltiU+6go8BSO2/ogsB4EasDaj0y68Q==
-  dependencies:
-    globby "^13.1.2"
-    graceful-fs "^4.2.10"
-    is-glob "^4.0.3"
-    is-path-cwd "^3.0.0"
-    is-path-inside "^4.0.0"
-    p-map "^5.5.0"
-    rimraf "^3.0.2"
-    slash "^4.0.0"
-
-del@^7.1.0:
+del@7.1.0, del@^7.1.0:
   version "7.1.0"
   resolved "https://registry.yarnpkg.com/del/-/del-7.1.0.tgz#0de0044d556b649ff05387f1fa7c885e155fd1b6"
   integrity sha512-v2KyNk7efxhlyHpjEvfyxaAihKKK0nWCuf6ZtqZcFFpQRG0bJ12Qsr0RpvsICMjAAZ8DOVCxrlqpxISlMHC4Kg==

From b0eb0216be3ac365e31ba34151cdaaf193c96244 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 06:46:59 +0900
Subject: [PATCH 442/749] MINOR: [JS] Bump google-closure-compiler from
 20230502.0.0 to 20230802.0.0 in /js (#37965)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [google-closure-compiler](https://github.com/google/closure-compiler-npm) from 20230502.0.0 to 20230802.0.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/google/closure-compiler-npm/releases">google-closure-compiler's releases</a>.</em></p>
<blockquote>
<h2>20230802.0.0</h2>
<p>Closure-compiler 20230802 release</p>
<h2>What's Changed</h2>
<ul>
<li>Change writing of Stack Overflow (closure-compiler/README.md) by <a href="https://github.com/Irian3x3"><code>@​Irian3x3</code></a> in <a href="https://redirect.github.com/google/closure-compiler-npm/pull/287">google/closure-compiler-npm#287</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/Irian3x3"><code>@​Irian3x3</code></a> made their first contribution in <a href="https://redirect.github.com/google/closure-compiler-npm/pull/287">google/closure-compiler-npm#287</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/google/closure-compiler-npm/compare/v20230502.0.0...v20230802.0.0">https://github.com/google/closure-compiler-npm/compare/v20230502.0.0...v20230802.0.0</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/google/closure-compiler-npm/commit/c17c1dddc726132d4928db9942d3eb7b3c30ea81"><code>c17c1dd</code></a> v20230802.0.0</li>
<li><a href="https://github.com/google/closure-compiler-npm/commit/ad80c5100967f18251d5de0f2a93a6f39c11ee28"><code>ad80c51</code></a> Merge pull request <a href="https://redirect.github.com/google/closure-compiler-npm/issues/287">#287</a> from Irian3x3/master</li>
<li><a href="https://github.com/google/closure-compiler-npm/commit/73e6aa3d7f69aa896a45719511e821e10b6457d6"><code>73e6aa3</code></a> Change writing of Stack Overflow</li>
<li>See full diff in <a href="https://github.com/google/closure-compiler-npm/compare/v20230502.0.0...v20230802.0.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=google-closure-compiler&package-manager=npm_and_yarn&previous-version=20230502.0.0&new-version=20230802.0.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 56 ++++++++++++++++++++++++-------------------------
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/js/package.json b/js/package.json
index dfb17d24c2f41..14f26c74d29f3 100644
--- a/js/package.json
+++ b/js/package.json
@@ -86,7 +86,7 @@
     "eslint-plugin-unicorn": "47.0.0",
     "esm": "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz",
     "glob": "10.2.7",
-    "google-closure-compiler": "20230502.0.0",
+    "google-closure-compiler": "20230802.0.0",
     "gulp": "4.0.2",
     "gulp-esbuild": "0.11.1",
     "gulp-json-transform": "0.4.8",
diff --git a/js/yarn.lock b/js/yarn.lock
index 647b696931bb0..f027be218245f 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -3447,40 +3447,40 @@ glogg@^1.0.0:
   dependencies:
     sparkles "^1.0.0"
 
-google-closure-compiler-java@^20230502.0.0:
-  version "20230502.0.0"
-  resolved "https://registry.yarnpkg.com/google-closure-compiler-java/-/google-closure-compiler-java-20230502.0.0.tgz#111240655adf9d64a0ac7eb16f73e896f3f9cefd"
-  integrity sha512-2nMQPQz2ppU9jvHhz2zpUP5jBDAqZp4gFVOEvirEyfUuLLkHwAvU2Tl1c7xaKX+Z4uMxpxttxcwdIjQhV2g8eQ==
-
-google-closure-compiler-linux@^20230502.0.0:
-  version "20230502.0.0"
-  resolved "https://registry.yarnpkg.com/google-closure-compiler-linux/-/google-closure-compiler-linux-20230502.0.0.tgz#c71114611b7ca47febd6feb1289ae152ca020b92"
-  integrity sha512-4NDgPKJXQHUxEyJoVFPVMQPJs5at7ThOXa9u3+9UeYk2K+vtW5wVZlmW07VOy8Mk/O/n2dp+Vl+wuE35BIiHAA==
-
-google-closure-compiler-osx@^20230502.0.0:
-  version "20230502.0.0"
-  resolved "https://registry.yarnpkg.com/google-closure-compiler-osx/-/google-closure-compiler-osx-20230502.0.0.tgz#9ea082f0c6ad40b829802f0993f2e5b4b0e079e8"
-  integrity sha512-jB13dcbu8O02cG3JcCCVZku1oI0ZirJc/Sr9xcGHY5MMyw3qEMlXb3IU97W6UXLcg2wCRawMWadOwL9K4L9lfQ==
-
-google-closure-compiler-windows@^20230502.0.0:
-  version "20230502.0.0"
-  resolved "https://registry.yarnpkg.com/google-closure-compiler-windows/-/google-closure-compiler-windows-20230502.0.0.tgz#81eef5de8b86364716b77a2d8068afba8b0e8244"
-  integrity sha512-wW5/liBxejvUViiBNo8/C9Vnhw+Lm+n3RdfE4spNkmdH9bcpKM+KQBLrPPakW17P3HbAPOPZ0L1RsrmyLYA5Cg==
-
-google-closure-compiler@20230502.0.0:
-  version "20230502.0.0"
-  resolved "https://registry.yarnpkg.com/google-closure-compiler/-/google-closure-compiler-20230502.0.0.tgz#65b19e673255b4b4dad4271724932e0970b11a97"
-  integrity sha512-C2WZkuRnXpNjU2nc0W/Cgxm6t2VlwEyUJOTaGHaLr6qZCXK0L1uhOneKWN2X7AORKdzyLW6Tq8ONxRc7eODGJg==
+google-closure-compiler-java@^20230802.0.0:
+  version "20230802.0.0"
+  resolved "https://registry.yarnpkg.com/google-closure-compiler-java/-/google-closure-compiler-java-20230802.0.0.tgz#5de4679f3d014b6b66471a48fb82c2772db4c872"
+  integrity sha512-PWKLMLwj7pR/U0yYbiy649LLqAscu+F1gyY4Y/jK6CmSLb8cIJbL8BTJd00828TzTNfWnYwxbkcQw0y9C2YsGw==
+
+google-closure-compiler-linux@^20230802.0.0:
+  version "20230802.0.0"
+  resolved "https://registry.yarnpkg.com/google-closure-compiler-linux/-/google-closure-compiler-linux-20230802.0.0.tgz#1acaf12ef386e5c1dcb5ff5796d4ae9f48ebce46"
+  integrity sha512-F13U4iSXiWeGtHOFS25LVem1s6zI+pJvXVPVR7zSib5ppoUJ0JXnABJQezUR3FnpxmnkALG4oIGW0syH9zPLZA==
+
+google-closure-compiler-osx@^20230802.0.0:
+  version "20230802.0.0"
+  resolved "https://registry.yarnpkg.com/google-closure-compiler-osx/-/google-closure-compiler-osx-20230802.0.0.tgz#10746ecfa81ad6eecc4d42d4ce9d0ed3ca8071e7"
+  integrity sha512-ANAi/ux92Tt+Na7vFDLeK2hRzotjC5j+nxoPtE0OcuNcbjji5dREKoJxkq7r0YwRTCzAFZszK5ip/NPdTOdCEg==
+
+google-closure-compiler-windows@^20230802.0.0:
+  version "20230802.0.0"
+  resolved "https://registry.yarnpkg.com/google-closure-compiler-windows/-/google-closure-compiler-windows-20230802.0.0.tgz#d57968dc24d5e0d538840b4313e1bec7c71b18d6"
+  integrity sha512-ZQPujoNiiUyTGl8zEGR/0yAygWnbMtX/NQ/S/EHVgq5nmYkvDEVuiVbgpPAmO9lzBTq0hvUTRRATZbTU2ISxgA==
+
+google-closure-compiler@20230802.0.0:
+  version "20230802.0.0"
+  resolved "https://registry.yarnpkg.com/google-closure-compiler/-/google-closure-compiler-20230802.0.0.tgz#849181359823f8c9130faec9a1597377680823d6"
+  integrity sha512-o2fYoc8lqOBdhm95Ick0vWrtwH2Icd5yLZhbTcQ0T7NfGiBepYvx1BB63hR8ebgzEZemz9Fh+O6Kg/3Mjm28ww==
   dependencies:
     chalk "4.x"
-    google-closure-compiler-java "^20230502.0.0"
+    google-closure-compiler-java "^20230802.0.0"
     minimist "1.x"
     vinyl "2.x"
     vinyl-sourcemaps-apply "^0.2.0"
   optionalDependencies:
-    google-closure-compiler-linux "^20230502.0.0"
-    google-closure-compiler-osx "^20230502.0.0"
-    google-closure-compiler-windows "^20230502.0.0"
+    google-closure-compiler-linux "^20230802.0.0"
+    google-closure-compiler-osx "^20230802.0.0"
+    google-closure-compiler-windows "^20230802.0.0"
 
 graceful-fs@^4.0.0, graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4, graceful-fs@^4.2.9:
   version "4.2.11"

From 22df70a0caf888084ae13d7f3e0178a477d1e7d7 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 2 Oct 2023 22:51:50 +0800
Subject: [PATCH 443/749] GH-37799: [C++] Compute: CommonTemporal support
 time32 and time64 casting (#37949)

### Rationale for this change

The original problem in mentioned in https://github.com/apache/arrow/issues/37799

1. `SECOND` in Parquet would always cast to `MILLS`
2. `eq` not support `eq(time32[s], time32[ms)`

This patch is as advice in https://github.com/apache/arrow/issues/37799#issuecomment-1737747352 . We tent to add time32 and time64 in `CommonTemporal`.

### What changes are included in this PR?

Support time32 and time64 with different time unit in `arrow::compute::internal::CommonTemporal`.

### Are these changes tested?

Yes

### Are there any user-facing changes?

bugfix

* Closes: #37799

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 .../arrow/compute/kernels/codegen_internal.cc | 49 +++++++++++++++----
 .../compute/kernels/codegen_internal_test.cc  | 12 +++++
 cpp/src/arrow/dataset/file_parquet_test.cc    | 25 ++++++++++
 3 files changed, 77 insertions(+), 9 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/codegen_internal.cc b/cpp/src/arrow/compute/kernels/codegen_internal.cc
index 8e2669bd3dfb9..00a833742f957 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal.cc
+++ b/cpp/src/arrow/compute/kernels/codegen_internal.cc
@@ -251,6 +251,7 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
   bool saw_date32 = false;
   bool saw_date64 = false;
   bool saw_duration = false;
+  bool saw_time_since_midnight = false;
   const TypeHolder* end = begin + count;
   for (auto it = begin; it != end; it++) {
     auto id = it->type->id();
@@ -271,6 +272,18 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
         finest_unit = std::max(finest_unit, ty.unit());
         continue;
       }
+      case Type::TIME32: {
+        const auto& type = checked_cast<const Time32Type&>(*it->type);
+        finest_unit = std::max(finest_unit, type.unit());
+        saw_time_since_midnight = true;
+        continue;
+      }
+      case Type::TIME64: {
+        const auto& type = checked_cast<const Time64Type&>(*it->type);
+        finest_unit = std::max(finest_unit, type.unit());
+        saw_time_since_midnight = true;
+        continue;
+      }
       case Type::DURATION: {
         const auto& ty = checked_cast<const DurationType&>(*it->type);
         finest_unit = std::max(finest_unit, ty.unit());
@@ -282,15 +295,33 @@ TypeHolder CommonTemporal(const TypeHolder* begin, size_t count) {
     }
   }
 
-  if (timezone) {
-    // At least one timestamp seen
-    return timestamp(finest_unit, *timezone);
-  } else if (saw_date64) {
-    return date64();
-  } else if (saw_date32) {
-    return date32();
-  } else if (saw_duration) {
-    return duration(finest_unit);
+  bool saw_timestamp_or_date = timezone || saw_date64 || saw_date32 || saw_duration;
+
+  if (saw_time_since_midnight && saw_timestamp_or_date) {
+    // Cannot find common type
+    return TypeHolder(nullptr);
+  }
+  if (saw_timestamp_or_date) {
+    if (timezone) {
+      // At least one timestamp seen
+      return timestamp(finest_unit, *timezone);
+    } else if (saw_date64) {
+      return date64();
+    } else if (saw_date32) {
+      return date32();
+    } else if (saw_duration) {
+      return duration(finest_unit);
+    }
+  }
+  if (saw_time_since_midnight) {
+    switch (finest_unit) {
+      case TimeUnit::SECOND:
+      case TimeUnit::MILLI:
+        return time32(finest_unit);
+      case TimeUnit::MICRO:
+      case TimeUnit::NANO:
+        return time64(finest_unit);
+    }
   }
   return TypeHolder(nullptr);
 }
diff --git a/cpp/src/arrow/compute/kernels/codegen_internal_test.cc b/cpp/src/arrow/compute/kernels/codegen_internal_test.cc
index af024fb8d6e08..6bb5568d2ff38 100644
--- a/cpp/src/arrow/compute/kernels/codegen_internal_test.cc
+++ b/cpp/src/arrow/compute/kernels/codegen_internal_test.cc
@@ -159,6 +159,18 @@ TEST(TestDispatchBest, CommonTemporal) {
   args = {timestamp(TimeUnit::SECOND, "America/Phoenix"),
           timestamp(TimeUnit::SECOND, "UTC")};
   ASSERT_EQ(CommonTemporal(args.data(), args.size()), nullptr);
+
+  args = {time32(TimeUnit::SECOND), time32(TimeUnit::MILLI)};
+  AssertTypeEqual(*time32(TimeUnit::MILLI), *CommonTemporal(args.data(), args.size()));
+
+  args = {time32(TimeUnit::SECOND), time64(TimeUnit::NANO)};
+  AssertTypeEqual(*time64(TimeUnit::NANO), *CommonTemporal(args.data(), args.size()));
+
+  args = {date32(), time32(TimeUnit::SECOND)};
+  ASSERT_EQ(CommonTemporal(args.data(), args.size()), nullptr);
+
+  args = {timestamp(TimeUnit::SECOND), time32(TimeUnit::SECOND)};
+  ASSERT_EQ(CommonTemporal(args.data(), args.size()), nullptr);
 }
 
 TEST(TestDispatchBest, CommonTemporalResolution) {
diff --git a/cpp/src/arrow/dataset/file_parquet_test.cc b/cpp/src/arrow/dataset/file_parquet_test.cc
index 177ca824179a8..dc9e085df3c4c 100644
--- a/cpp/src/arrow/dataset/file_parquet_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_test.cc
@@ -730,6 +730,31 @@ TEST_P(TestParquetFileFormatScan, PredicatePushdownRowGroupFragmentsUsingDuratio
   CountRowGroupsInFragment(fragment, {0}, expr);
 }
 
+TEST_P(TestParquetFileFormatScan,
+       PredicatePushdownRowGroupFragmentsUsingTimestampColumn) {
+  // GH-37799: Parquet arrow will change TimeUnit::SECOND to TimeUnit::MILLI
+  // because parquet LogicalType doesn't support SECOND.
+  for (auto time_unit : {TimeUnit::MILLI, TimeUnit::SECOND}) {
+    auto table = TableFromJSON(schema({field("t", time32(time_unit))}),
+                               {
+                                   R"([{"t": 1}])",
+                                   R"([{"t": 2}, {"t": 3}])",
+                               });
+    TableBatchReader table_reader(*table);
+    ARROW_SCOPED_TRACE("time_unit=", time_unit);
+    ASSERT_OK_AND_ASSIGN(
+        auto source,
+        ParquetFormatHelper::Write(
+            &table_reader, ArrowWriterProperties::Builder().store_schema()->build())
+            .As<FileSource>());
+    SetSchema({field("t", time32(time_unit))});
+    ASSERT_OK_AND_ASSIGN(auto fragment, format_->MakeFragment(source));
+
+    auto expr = equal(field_ref("t"), literal(::arrow::Time32Scalar(1, time_unit)));
+    CountRowGroupsInFragment(fragment, {0}, expr);
+  }
+}
+
 // Tests projection with nested/indexed FieldRefs.
 // https://github.com/apache/arrow/issues/35579
 TEST_P(TestParquetFileFormatScan, ProjectWithNonNamedFieldRefs) {

From 7667b81bffcb5b361fab6d61c42ce396d98cc6e1 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Mon, 2 Oct 2023 18:07:59 +0200
Subject: [PATCH 444/749] GH-37906: [Integration][C#] Implement C Data
 Interface integration testing for C# (#37904)

### Rationale for this change

All Arrow implementations supporting the C Data Interface should also implement integration testing, to ensure proper interoperability.

### What changes are included in this PR?

* Implement C Data Interface integration testing for C#
* Fix bugs in the C Data Interface implementation for C#

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

No.
* Closes: #37906

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/scripts/integration_arrow.sh               |   5 +
 csharp/src/Apache.Arrow/ArrowBuffer.cs        |   3 +-
 csharp/src/Apache.Arrow/C/CArrowArray.cs      |  13 +-
 .../src/Apache.Arrow/C/CArrowArrayExporter.cs |  53 +-
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |  10 +-
 .../Memory/ExportedAllocationOwner.cs         |  22 +
 .../Apache.Arrow.IntegrationTest.csproj       |   3 +-
 .../CDataInterface.cs                         |  77 +++
 .../IntegrationCommand.cs                     | 606 +----------------
 .../Apache.Arrow.IntegrationTest/JsonFile.cs  | 640 +++++++++++++++++-
 .../CDataInterfacePythonTests.cs              |   4 +-
 dev/archery/archery/integration/runner.py     |  11 +-
 dev/archery/archery/integration/tester.py     |   6 +-
 dev/archery/archery/integration/tester_cpp.py |   6 +-
 .../archery/integration/tester_csharp.py      | 138 +++-
 dev/archery/archery/integration/tester_go.py  |   6 +-
 16 files changed, 958 insertions(+), 645 deletions(-)
 create mode 100644 csharp/test/Apache.Arrow.IntegrationTest/CDataInterface.cs

diff --git a/ci/scripts/integration_arrow.sh b/ci/scripts/integration_arrow.sh
index a165f8027bf8f..289d376a4db9b 100755
--- a/ci/scripts/integration_arrow.sh
+++ b/ci/scripts/integration_arrow.sh
@@ -23,6 +23,11 @@ arrow_dir=${1}
 gold_dir=$arrow_dir/testing/data/arrow-ipc-stream/integration
 
 pip install -e $arrow_dir/dev/archery[integration]
+# For C# C Data Interface testing
+pip install pythonnet
+
+# Get more detailed context on crashes
+export PYTHONFAULTHANDLER=1
 
 # Rust can be enabled by exporting ARCHERY_INTEGRATION_WITH_RUST=1
 time archery integration \
diff --git a/csharp/src/Apache.Arrow/ArrowBuffer.cs b/csharp/src/Apache.Arrow/ArrowBuffer.cs
index dbd97fc3aec9e..ef98bdc853b88 100644
--- a/csharp/src/Apache.Arrow/ArrowBuffer.cs
+++ b/csharp/src/Apache.Arrow/ArrowBuffer.cs
@@ -75,8 +75,9 @@ public void Dispose()
 
         internal bool TryExport(ExportedAllocationOwner newOwner, out IntPtr ptr)
         {
-            if (_memoryOwner == null && IsEmpty)
+            if (IsEmpty)
             {
+                // _memoryOwner could be anything (for example null or a NullMemoryOwner), but it doesn't matter here
                 ptr = IntPtr.Zero;
                 return true;
             }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArray.cs b/csharp/src/Apache.Arrow/C/CArrowArray.cs
index fc609f10fdfa5..882ca8caa503d 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArray.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArray.cs
@@ -16,6 +16,7 @@
 // under the License.
 
 using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 namespace Apache.Arrow.C
@@ -67,6 +68,15 @@ public unsafe struct CArrowArray
         /// Do not call this on a pointer that was allocated elsewhere.
         /// </remarks>
         public static void Free(CArrowArray* array)
+        {
+            CallReleaseFunc(array);
+            Marshal.FreeHGlobal((IntPtr)array);
+        }
+
+        /// <summary>
+        /// Call the array's release func, if set.
+        /// </summary>
+        public static void CallReleaseFunc(CArrowArray* array)
         {
             if (array->release != default)
             {
@@ -76,8 +86,9 @@ public static void Free(CArrowArray* array)
 #else
                 Marshal.GetDelegateForFunctionPointer<CArrowArrayExporter.ReleaseArrowArray>(array->release)(array);
 #endif
+                Debug.Assert(array->release == default,
+                             "Calling the CArrowArray release func should have set it to NULL");
             }
-            Marshal.FreeHGlobal((IntPtr)array);
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
index 16aaa3874b370..2d9febea33f54 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayExporter.cs
@@ -15,6 +15,7 @@
 
 
 using System;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Apache.Arrow.Memory;
@@ -59,8 +60,6 @@ public static unsafe void ExportArray(IArrowArray array, CArrowArray* cArray)
             try
             {
                 ConvertArray(allocationOwner, array.Data, cArray);
-                cArray->release = ReleaseArrayPtr;
-                cArray->private_data = FromDisposable(allocationOwner);
                 allocationOwner = null;
             }
             finally
@@ -102,8 +101,6 @@ public static unsafe void ExportRecordBatch(RecordBatch batch, CArrowArray* cArr
             try
             {
                 ConvertRecordBatch(allocationOwner, batch, cArray);
-                cArray->release = ReleaseArrayPtr;
-                cArray->private_data = FromDisposable(allocationOwner);
                 allocationOwner = null;
             }
             finally
@@ -118,7 +115,7 @@ private unsafe static void ConvertArray(ExportedAllocationOwner sharedOwner, Arr
             cArray->offset = array.Offset;
             cArray->null_count = array.NullCount;
             cArray->release = ReleaseArrayPtr;
-            cArray->private_data = null;
+            cArray->private_data = MakePrivateData(sharedOwner);
 
             cArray->n_buffers = array.Buffers?.Length ?? 0;
             cArray->buffers = null;
@@ -131,7 +128,7 @@ private unsafe static void ConvertArray(ExportedAllocationOwner sharedOwner, Arr
                     IntPtr ptr;
                     if (!buffer.TryExport(sharedOwner, out ptr))
                     {
-                        throw new NotSupportedException($"An ArrowArray of type {array.DataType.TypeId} could not be exported");
+                        throw new NotSupportedException($"An ArrowArray of type {array.DataType.TypeId} could not be exported: failed on buffer #{i}");
                     }
                     cArray->buffers[i] = (byte*)ptr;
                 }
@@ -144,7 +141,7 @@ private unsafe static void ConvertArray(ExportedAllocationOwner sharedOwner, Arr
                 cArray->children = (CArrowArray**)sharedOwner.Allocate(IntPtr.Size * array.Children.Length);
                 for (int i = 0; i < array.Children.Length; i++)
                 {
-                    cArray->children[i] = CArrowArray.Create();
+                    cArray->children[i] = MakeArray(sharedOwner);
                     ConvertArray(sharedOwner, array.Children[i], cArray->children[i]);
                 }
             }
@@ -152,7 +149,7 @@ private unsafe static void ConvertArray(ExportedAllocationOwner sharedOwner, Arr
             cArray->dictionary = null;
             if (array.Dictionary != null)
             {
-                cArray->dictionary = CArrowArray.Create();
+                cArray->dictionary = MakeArray(sharedOwner);
                 ConvertArray(sharedOwner, array.Dictionary, cArray->dictionary);
             }
         }
@@ -163,20 +160,24 @@ private unsafe static void ConvertRecordBatch(ExportedAllocationOwner sharedOwne
             cArray->offset = 0;
             cArray->null_count = 0;
             cArray->release = ReleaseArrayPtr;
-            cArray->private_data = null;
+            cArray->private_data = MakePrivateData(sharedOwner);
 
             cArray->n_buffers = 1;
             cArray->buffers = (byte**)sharedOwner.Allocate(IntPtr.Size);
 
             cArray->n_children = batch.ColumnCount;
             cArray->children = null;
+            // XXX sharing the same ExportedAllocationOwner for all columns
+            // and child arrays makes memory tracking inflexible.
+            // If the consumer keeps only a single record batch column,
+            // the entire record batch memory is nevertheless kept alive.
             if (cArray->n_children > 0)
             {
                 cArray->children = (CArrowArray**)sharedOwner.Allocate(IntPtr.Size * batch.ColumnCount);
                 int i = 0;
                 foreach (IArrowArray child in batch.Arrays)
                 {
-                    cArray->children[i] = CArrowArray.Create();
+                    cArray->children[i] = MakeArray(sharedOwner);
                     ConvertArray(sharedOwner, child.Data, cArray->children[i]);
                     i++;
                 }
@@ -190,26 +191,44 @@ private unsafe static void ConvertRecordBatch(ExportedAllocationOwner sharedOwne
 #endif
         private unsafe static void ReleaseArray(CArrowArray* cArray)
         {
-            Dispose(&cArray->private_data);
+            for (long i = 0; i < cArray->n_children; i++)
+            {
+                CArrowArray.CallReleaseFunc(cArray->children[i]);
+            }
+            if (cArray->dictionary != null)
+            {
+                CArrowArray.CallReleaseFunc(cArray->dictionary);
+            }
+            DisposePrivateData(&cArray->private_data);
             cArray->release = default;
         }
 
-        private unsafe static void* FromDisposable(IDisposable disposable)
+        private unsafe static CArrowArray* MakeArray(ExportedAllocationOwner sharedOwner)
+        {
+            var array = (CArrowArray*)sharedOwner.Allocate(sizeof(CArrowArray));
+            *array = default;
+            return array;
+        }
+
+        private unsafe static void* MakePrivateData(ExportedAllocationOwner sharedOwner)
         {
-            GCHandle gch = GCHandle.Alloc(disposable);
+            GCHandle gch = GCHandle.Alloc(sharedOwner);
+            sharedOwner.IncRef();
             return (void*)GCHandle.ToIntPtr(gch);
         }
 
-        private unsafe static void Dispose(void** ptr)
+        private unsafe static void DisposePrivateData(void** ptr)
         {
-            GCHandle gch = GCHandle.FromIntPtr((IntPtr)(*ptr));
+            GCHandle gch = GCHandle.FromIntPtr((IntPtr) (*ptr));
             if (!gch.IsAllocated)
             {
                 return;
             }
-            ((IDisposable)gch.Target).Dispose();
+            // We can't call IDisposable.Dispose() here as we create multiple
+            // GCHandles to the same object. Instead, refcounting ensures
+            // timely memory deallocation when all GCHandles are freed.
+            ((ExportedAllocationOwner) gch.Target).DecRef();
             gch.Free();
-            *ptr = null;
         }
     }
 }
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index 42c8cdd5ef548..f7216df869abd 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -37,7 +37,7 @@ public static class CArrowSchemaImporter
         /// Typically, you will allocate an uninitialized CArrowSchema pointer,
         /// pass that to external function, and then use this method to import
         /// the result.
-        /// 
+        ///
         /// <code>
         /// CArrowSchema* importedPtr = CArrowSchema.Create();
         /// foreign_export_function(importedPtr);
@@ -62,7 +62,7 @@ public static unsafe ArrowType ImportType(CArrowSchema* ptr)
         /// Typically, you will allocate an uninitialized CArrowSchema pointer,
         /// pass that to external function, and then use this method to import
         /// the result.
-        /// 
+        ///
         /// <code>
         /// CArrowSchema* importedPtr = CArrowSchema.Create();
         /// foreign_export_function(importedPtr);
@@ -87,7 +87,7 @@ public static unsafe Field ImportField(CArrowSchema* ptr)
         /// Typically, you will allocate an uninitialized CArrowSchema pointer,
         /// pass that to external function, and then use this method to import
         /// the result.
-        /// 
+        ///
         /// <code>
         /// CArrowSchema* importedPtr = CArrowSchema.Create();
         /// foreign_export_function(importedPtr);
@@ -241,6 +241,10 @@ public ArrowType GetAsType()
                     };
 
                     string timezone = format.Substring(format.IndexOf(':') + 1);
+                    if (timezone.Length == 0)
+                    {
+                        timezone = null;
+                    }
                     return new TimestampType(timeUnit, timezone);
                 }
 
diff --git a/csharp/src/Apache.Arrow/Memory/ExportedAllocationOwner.cs b/csharp/src/Apache.Arrow/Memory/ExportedAllocationOwner.cs
index e872dc5425e06..05529899e410c 100644
--- a/csharp/src/Apache.Arrow/Memory/ExportedAllocationOwner.cs
+++ b/csharp/src/Apache.Arrow/Memory/ExportedAllocationOwner.cs
@@ -14,8 +14,10 @@
 // limitations under the License.
 
 using System;
+using System.Diagnostics;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace Apache.Arrow.Memory
 {
@@ -23,6 +25,8 @@ internal sealed class ExportedAllocationOwner : INativeAllocationOwner, IDisposa
     {
         private readonly List<IntPtr> _pointers = new List<IntPtr>();
         private int _allocationSize;
+        private long _referenceCount;
+        private bool _disposed;
 
         ~ExportedAllocationOwner()
         {
@@ -47,8 +51,25 @@ public void Release(IntPtr ptr, int offset, int length)
             throw new InvalidOperationException();
         }
 
+        public void IncRef()
+        {
+            Interlocked.Increment(ref _referenceCount);
+        }
+
+        public void DecRef()
+        {
+            if (Interlocked.Decrement(ref _referenceCount) == 0)
+            {
+                Dispose();
+            }
+        }
+
         public void Dispose()
         {
+            if (_disposed)
+            {
+                return;
+            }
             for (int i = 0; i < _pointers.Count; i++)
             {
                 if (_pointers[i] != IntPtr.Zero)
@@ -59,6 +80,7 @@ public void Dispose()
             }
             GC.RemoveMemoryPressure(_allocationSize);
             GC.SuppressFinalize(this);
+            _disposed = true;
         }
     }
 }
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/Apache.Arrow.IntegrationTest.csproj b/csharp/test/Apache.Arrow.IntegrationTest/Apache.Arrow.IntegrationTest.csproj
index a6c635a79a45f..cb7f7ae896ee2 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/Apache.Arrow.IntegrationTest.csproj
+++ b/csharp/test/Apache.Arrow.IntegrationTest/Apache.Arrow.IntegrationTest.csproj
@@ -3,6 +3,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <TargetFrameworks>net7.0</TargetFrameworks>
   </PropertyGroup>
 
@@ -13,4 +14,4 @@
     <ProjectReference Include="..\Apache.Arrow.Tests\Apache.Arrow.Tests.csproj" />
   </ItemGroup>
 
-</Project>
\ No newline at end of file
+</Project>
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/CDataInterface.cs b/csharp/test/Apache.Arrow.IntegrationTest/CDataInterface.cs
new file mode 100644
index 0000000000000..2fabae1a2a3b3
--- /dev/null
+++ b/csharp/test/Apache.Arrow.IntegrationTest/CDataInterface.cs
@@ -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.
+
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Diagnostics;
+using System.IO;
+using Apache.Arrow.C;
+using Apache.Arrow.Arrays;
+using Apache.Arrow.Types;
+
+namespace Apache.Arrow.IntegrationTest
+{
+    /// <summary>
+    /// Bridge for C Data Interface integration testing.
+    /// These methods are called from the Python integration testing
+    /// harness provided by Archery.
+    /// </summary>
+    public static class CDataInterface
+    {
+        // Archery uses the `pythonnet` library (*) to invoke .Net DLLs.
+        // `pythonnet` is only able to marshal simple types such as int and
+        // str, which is why we provide trivial wrappers around other APIs.
+        //
+        // (*) https://pythonnet.github.io/
+
+        public static void Initialize()
+        {
+            // Allow debugging using Debug.WriteLine()
+            Trace.Listeners.Add(new ConsoleTraceListener());
+        }
+
+        public static unsafe Schema ImportSchema(long ptr)
+        {
+            return CArrowSchemaImporter.ImportSchema((CArrowSchema*) ptr);
+        }
+
+        public static unsafe void ExportSchema(Schema schema, long ptr)
+        {
+            CArrowSchemaExporter.ExportSchema(schema, (CArrowSchema*) ptr);
+        }
+
+        public static unsafe RecordBatch ImportRecordBatch(long ptr, Schema schema)
+        {
+            return CArrowArrayImporter.ImportRecordBatch((CArrowArray*) ptr, schema);
+        }
+
+        public static unsafe void ExportRecordBatch(RecordBatch batch, long ptr)
+        {
+            CArrowArrayExporter.ExportRecordBatch(batch, (CArrowArray*) ptr);
+        }
+
+        public static JsonFile ParseJsonFile(string jsonPath)
+        {
+            return JsonFile.Parse(new FileInfo(jsonPath));
+        }
+
+        public static void RunGC()
+        {
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+        }
+    }
+}
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
index 1e76ee505a516..d19d19f1ce7c1 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/IntegrationCommand.cs
@@ -72,7 +72,7 @@ private async Task<int> Validate()
                 return -1;
             }
 
-            Schema jsonFileSchema = CreateSchema(jsonFile.Schema);
+            Schema jsonFileSchema = jsonFile.Schema.ToArrow();
             Schema arrowFileSchema = reader.Schema;
 
             SchemaComparer.Compare(jsonFileSchema, arrowFileSchema);
@@ -80,7 +80,7 @@ private async Task<int> Validate()
             for (int i = 0; i < batchCount; i++)
             {
                 RecordBatch arrowFileRecordBatch = reader.ReadNextRecordBatch();
-                RecordBatch jsonFileRecordBatch = CreateRecordBatch(jsonFileSchema, jsonFile.Batches[i]);
+                RecordBatch jsonFileRecordBatch = jsonFile.Batches[i].ToArrow(jsonFileSchema);
 
                 ArrowReaderVerifier.CompareBatches(jsonFileRecordBatch, arrowFileRecordBatch, strictCompare: false);
             }
@@ -98,7 +98,7 @@ private async Task<int> Validate()
         private async Task<int> JsonToArrow()
         {
             JsonFile jsonFile = await ParseJsonFile();
-            Schema schema = CreateSchema(jsonFile.Schema);
+            Schema schema = jsonFile.Schema.ToArrow();
 
             using (FileStream fs = ArrowFileInfo.Create())
             {
@@ -107,7 +107,7 @@ private async Task<int> JsonToArrow()
 
                 foreach (var jsonRecordBatch in jsonFile.Batches)
                 {
-                    RecordBatch batch = CreateRecordBatch(schema, jsonRecordBatch);
+                    RecordBatch batch = jsonRecordBatch.ToArrow(schema);
                     await writer.WriteRecordBatchAsync(batch);
                 }
                 await writer.WriteEndAsync();
@@ -117,595 +117,6 @@ private async Task<int> JsonToArrow()
             return 0;
         }
 
-        private RecordBatch CreateRecordBatch(Schema schema, JsonRecordBatch jsonRecordBatch)
-        {
-            if (schema.FieldsList.Count != jsonRecordBatch.Columns.Count)
-            {
-                throw new NotSupportedException($"jsonRecordBatch.Columns.Count '{jsonRecordBatch.Columns.Count}' doesn't match schema field count '{schema.FieldsList.Count}'");
-            }
-
-            List<IArrowArray> arrays = new List<IArrowArray>(jsonRecordBatch.Columns.Count);
-            for (int i = 0; i < jsonRecordBatch.Columns.Count; i++)
-            {
-                JsonFieldData data = jsonRecordBatch.Columns[i];
-                Field field = schema.FieldsList[i];
-                ArrayCreator creator = new ArrayCreator(data);
-                field.DataType.Accept(creator);
-                arrays.Add(creator.Array);
-            }
-
-            return new RecordBatch(schema, arrays, jsonRecordBatch.Count);
-        }
-
-        private static Schema CreateSchema(JsonSchema jsonSchema)
-        {
-            Schema.Builder builder = new Schema.Builder();
-            for (int i = 0; i < jsonSchema.Fields.Count; i++)
-            {
-                builder.Field(f => CreateField(f, jsonSchema.Fields[i]));
-            }
-            return builder.Build();
-        }
-
-        private static void CreateField(Field.Builder builder, JsonField jsonField)
-        {
-            Field[] children = null;
-            if (jsonField.Children?.Count > 0)
-            {
-                children = new Field[jsonField.Children.Count];
-                for (int i = 0; i < jsonField.Children.Count; i++)
-                {
-                    Field.Builder field = new Field.Builder();
-                    CreateField(field, jsonField.Children[i]);
-                    children[i] = field.Build();
-                }
-            }
-
-            builder.Name(jsonField.Name)
-                .DataType(ToArrowType(jsonField.Type, children))
-                .Nullable(jsonField.Nullable);
-
-            if (jsonField.Metadata != null)
-            {
-                builder.Metadata(jsonField.Metadata);
-            }
-        }
-
-        private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
-        {
-            return type.Name switch
-            {
-                "bool" => BooleanType.Default,
-                "int" => ToIntArrowType(type),
-                "floatingpoint" => ToFloatingPointArrowType(type),
-                "decimal" => ToDecimalArrowType(type),
-                "binary" => BinaryType.Default,
-                "utf8" => StringType.Default,
-                "fixedsizebinary" => new FixedSizeBinaryType(type.ByteWidth),
-                "date" => ToDateArrowType(type),
-                "time" => ToTimeArrowType(type),
-                "timestamp" => ToTimestampArrowType(type),
-                "list" => ToListArrowType(type, children),
-                "fixedsizelist" => ToFixedSizeListArrowType(type, children),
-                "struct" => ToStructArrowType(type, children),
-                "union" => ToUnionArrowType(type, children),
-                "null" => NullType.Default,
-                _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}")
-            };
-        }
-
-        private static IArrowType ToIntArrowType(JsonArrowType type)
-        {
-            return (type.BitWidth, type.IsSigned) switch
-            {
-                (8, true) => Int8Type.Default,
-                (8, false) => UInt8Type.Default,
-                (16, true) => Int16Type.Default,
-                (16, false) => UInt16Type.Default,
-                (32, true) => Int32Type.Default,
-                (32, false) => UInt32Type.Default,
-                (64, true) => Int64Type.Default,
-                (64, false) => UInt64Type.Default,
-                _ => throw new NotSupportedException($"Int type not supported: {type.BitWidth}, {type.IsSigned}")
-            };
-        }
-
-        private static IArrowType ToFloatingPointArrowType(JsonArrowType type)
-        {
-            return type.FloatingPointPrecision switch
-            {
-                "SINGLE" => FloatType.Default,
-                "DOUBLE" => DoubleType.Default,
-                _ => throw new NotSupportedException($"FloatingPoint type not supported: {type.FloatingPointPrecision}")
-            };
-        }
-
-        private static IArrowType ToDecimalArrowType(JsonArrowType type)
-        {
-            return type.BitWidth switch
-            {
-                256 => new Decimal256Type(type.DecimalPrecision, type.Scale),
-                _ => new Decimal128Type(type.DecimalPrecision, type.Scale),
-            };
-        }
-
-        private static IArrowType ToDateArrowType(JsonArrowType type)
-        {
-            return type.Unit switch
-            {
-                "DAY" => Date32Type.Default,
-                "MILLISECOND" => Date64Type.Default,
-                _ => throw new NotSupportedException($"Date type not supported: {type.Unit}")
-            };
-        }
-
-        private static IArrowType ToTimeArrowType(JsonArrowType type)
-        {
-            return (type.Unit, type.BitWidth) switch
-            {
-                ("SECOND", 32) => new Time32Type(TimeUnit.Second),
-                ("SECOND", 64) => new Time64Type(TimeUnit.Second),
-                ("MILLISECOND", 32) => new Time32Type(TimeUnit.Millisecond),
-                ("MILLISECOND", 64) => new Time64Type(TimeUnit.Millisecond),
-                ("MICROSECOND", 32) => new Time32Type(TimeUnit.Microsecond),
-                ("MICROSECOND", 64) => new Time64Type(TimeUnit.Microsecond),
-                ("NANOSECOND", 32) => new Time32Type(TimeUnit.Nanosecond),
-                ("NANOSECOND", 64) => new Time64Type(TimeUnit.Nanosecond),
-                _ => throw new NotSupportedException($"Time type not supported: {type.Unit}, {type.BitWidth}")
-            };
-        }
-
-        private static IArrowType ToTimestampArrowType(JsonArrowType type)
-        {
-            return type.Unit switch
-            {
-                "SECOND" => new TimestampType(TimeUnit.Second, type.Timezone),
-                "MILLISECOND" => new TimestampType(TimeUnit.Millisecond, type.Timezone),
-                "MICROSECOND" => new TimestampType(TimeUnit.Microsecond, type.Timezone),
-                "NANOSECOND" => new TimestampType(TimeUnit.Nanosecond, type.Timezone),
-                _ => throw new NotSupportedException($"Time type not supported: {type.Unit}, {type.BitWidth}")
-            };
-        }
-
-        private static IArrowType ToListArrowType(JsonArrowType type, Field[] children)
-        {
-            return new ListType(children[0]);
-        }
-
-        private static IArrowType ToFixedSizeListArrowType(JsonArrowType type, Field[] children)
-        {
-            return new FixedSizeListType(children[0], type.ListSize);
-        }
-
-        private static IArrowType ToStructArrowType(JsonArrowType type, Field[] children)
-        {
-            return new StructType(children);
-        }
-
-        private static IArrowType ToUnionArrowType(JsonArrowType type, Field[] children)
-        {
-            UnionMode mode = type.Mode switch
-            {
-                "SPARSE" => UnionMode.Sparse,
-                "DENSE" => UnionMode.Dense,
-                _ => throw new NotSupportedException($"Union mode not supported: {type.Mode}"),
-            };
-            return new UnionType(children, type.TypeIds, mode);
-        }
-
-        private class ArrayCreator :
-            IArrowTypeVisitor<BooleanType>,
-            IArrowTypeVisitor<Int8Type>,
-            IArrowTypeVisitor<Int16Type>,
-            IArrowTypeVisitor<Int32Type>,
-            IArrowTypeVisitor<Int64Type>,
-            IArrowTypeVisitor<UInt8Type>,
-            IArrowTypeVisitor<UInt16Type>,
-            IArrowTypeVisitor<UInt32Type>,
-            IArrowTypeVisitor<UInt64Type>,
-            IArrowTypeVisitor<FloatType>,
-            IArrowTypeVisitor<DoubleType>,
-            IArrowTypeVisitor<Decimal128Type>,
-            IArrowTypeVisitor<Decimal256Type>,
-            IArrowTypeVisitor<Date32Type>,
-            IArrowTypeVisitor<Date64Type>,
-            IArrowTypeVisitor<Time32Type>,
-            IArrowTypeVisitor<Time64Type>,
-            IArrowTypeVisitor<TimestampType>,
-            IArrowTypeVisitor<StringType>,
-            IArrowTypeVisitor<BinaryType>,
-            IArrowTypeVisitor<FixedSizeBinaryType>,
-            IArrowTypeVisitor<ListType>,
-            IArrowTypeVisitor<FixedSizeListType>,
-            IArrowTypeVisitor<StructType>,
-            IArrowTypeVisitor<UnionType>,
-            IArrowTypeVisitor<NullType>
-        {
-            private JsonFieldData JsonFieldData { get; set; }
-            public IArrowArray Array { get; private set; }
-
-            public ArrayCreator(JsonFieldData jsonFieldData)
-            {
-                JsonFieldData = jsonFieldData;
-            }
-
-            public void Visit(BooleanType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-                ArrowBuffer.BitmapBuilder valueBuilder = new ArrowBuffer.BitmapBuilder(validityBuffer.Length);
-
-                var json = JsonFieldData.Data.GetRawText();
-                bool[] values = JsonSerializer.Deserialize<bool[]>(json);
-
-                foreach (bool value in values)
-                {
-                    valueBuilder.Append(value);
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = new BooleanArray(
-                    valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            public void Visit(Int8Type type) => GenerateArray<sbyte, Int8Array>((v, n, c, nc, o) => new Int8Array(v, n, c, nc, o));
-            public void Visit(Int16Type type) => GenerateArray<short, Int16Array>((v, n, c, nc, o) => new Int16Array(v, n, c, nc, o));
-            public void Visit(Int32Type type) => GenerateArray<int, Int32Array>((v, n, c, nc, o) => new Int32Array(v, n, c, nc, o));
-            public void Visit(Int64Type type) => GenerateLongArray<long, Int64Array>((v, n, c, nc, o) => new Int64Array(v, n, c, nc, o), s => long.Parse(s));
-            public void Visit(UInt8Type type) => GenerateArray<byte, UInt8Array>((v, n, c, nc, o) => new UInt8Array(v, n, c, nc, o));
-            public void Visit(UInt16Type type) => GenerateArray<ushort, UInt16Array>((v, n, c, nc, o) => new UInt16Array(v, n, c, nc, o));
-            public void Visit(UInt32Type type) => GenerateArray<uint, UInt32Array>((v, n, c, nc, o) => new UInt32Array(v, n, c, nc, o));
-            public void Visit(UInt64Type type) => GenerateLongArray<ulong, UInt64Array>((v, n, c, nc, o) => new UInt64Array(v, n, c, nc, o), s => ulong.Parse(s));
-            public void Visit(FloatType type) => GenerateArray<float, FloatArray>((v, n, c, nc, o) => new FloatArray(v, n, c, nc, o));
-            public void Visit(DoubleType type) => GenerateArray<double, DoubleArray>((v, n, c, nc, o) => new DoubleArray(v, n, c, nc, o));
-            public void Visit(Time32Type type) => GenerateArray<int, Time32Array>((v, n, c, nc, o) => new Time32Array(type, v, n, c, nc, o));
-            public void Visit(Time64Type type) => GenerateLongArray<long, Time64Array>((v, n, c, nc, o) => new Time64Array(type, v, n, c, nc, o), s => long.Parse(s));
-
-            public void Visit(Decimal128Type type)
-            {
-                Array = new Decimal128Array(GetDecimalArrayData(type));
-            }
-
-            public void Visit(Decimal256Type type)
-            {
-                Array = new Decimal256Array(GetDecimalArrayData(type));
-            }
-
-            public void Visit(NullType type)
-            {
-                Array = new NullArray(JsonFieldData.Count);
-            }
-
-            private ArrayData GetDecimalArrayData(FixedSizeBinaryType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                Span<byte> buffer = stackalloc byte[type.ByteWidth];
-
-                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
-                foreach (string value in values)
-                {
-                    buffer.Fill(0);
-
-                    BigInteger bigInteger = BigInteger.Parse(value);
-                    if (!bigInteger.TryWriteBytes(buffer, out int bytesWritten, false, !BitConverter.IsLittleEndian))
-                    {
-                        throw new InvalidDataException($"Decimal data was too big to fit into {type.BitWidth} bits.");
-                    }
-
-                    if (bigInteger.Sign == -1)
-                    {
-                        buffer.Slice(bytesWritten).Fill(255);
-                    }
-
-                    valueBuilder.Append(buffer);
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build(default);
-
-                return new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, valueBuffer });
-            }
-
-            public void Visit(Date32Type type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrowBuffer.Builder<int> valueBuilder = new ArrowBuffer.Builder<int>(JsonFieldData.Count);
-                var json = JsonFieldData.Data.GetRawText();
-                int[] values = JsonSerializer.Deserialize<int[]>(json, s_options);
-
-                foreach (int value in values)
-                {
-                    valueBuilder.Append(value);
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = new Date32Array(
-                    valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            public void Visit(Date64Type type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrowBuffer.Builder<long> valueBuilder = new ArrowBuffer.Builder<long>(JsonFieldData.Count);
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(long.Parse(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = new Date64Array(
-                    valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            public void Visit(TimestampType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrowBuffer.Builder<long> valueBuilder = new ArrowBuffer.Builder<long>(JsonFieldData.Count);
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(long.Parse(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = new TimestampArray(
-                    type, valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            public void Visit(StringType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-                ArrowBuffer offsetBuffer = GetOffsetBuffer();
-
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(Encoding.UTF8.GetBytes(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build(default);
-
-                Array = new StringArray(JsonFieldData.Count, offsetBuffer, valueBuffer, validityBuffer, nullCount);
-            }
-
-            public void Visit(BinaryType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-                ArrowBuffer offsetBuffer = GetOffsetBuffer();
-
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(ConvertHexStringToByteArray(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build(default);
-
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, offsetBuffer, valueBuffer });
-                Array = new BinaryArray(arrayData);
-            }
-
-            public void Visit(FixedSizeBinaryType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
-
-                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(ConvertHexStringToByteArray(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build(default);
-
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, valueBuffer });
-                Array = new FixedSizeBinaryArray(arrayData);
-            }
-
-            public void Visit(ListType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-                ArrowBuffer offsetBuffer = GetOffsetBuffer();
-
-                var data = JsonFieldData;
-                JsonFieldData = data.Children[0];
-                type.ValueDataType.Accept(this);
-                JsonFieldData = data;
-
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
-                    new[] { validityBuffer, offsetBuffer }, new[] { Array.Data });
-                Array = new ListArray(arrayData);
-            }
-
-            public void Visit(FixedSizeListType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                var data = JsonFieldData;
-                JsonFieldData = data.Children[0];
-                type.ValueDataType.Accept(this);
-                JsonFieldData = data;
-
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
-                    new[] { validityBuffer }, new[] { Array.Data });
-                Array = new FixedSizeListArray(arrayData);
-            }
-
-            public void Visit(StructType type)
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrayData[] children = new ArrayData[type.Fields.Count];
-
-                var data = JsonFieldData;
-                for (int i = 0; i < children.Length; i++)
-                {
-                    JsonFieldData = data.Children[i];
-                    type.Fields[i].DataType.Accept(this);
-                    children[i] = Array.Data;
-                }
-                JsonFieldData = data;
-
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
-                    new[] { validityBuffer }, children);
-                Array = new StructArray(arrayData);
-            }
-
-            public void Visit(UnionType type)
-            {
-                ArrowBuffer[] buffers;
-                if (type.Mode == UnionMode.Dense)
-                {
-                    buffers = new ArrowBuffer[2];
-                    buffers[1] = GetOffsetBuffer();
-                }
-                else
-                {
-                    buffers = new ArrowBuffer[1];
-                }
-                buffers[0] = GetTypeIdBuffer();
-
-                ArrayData[] children = GetChildren(type);
-
-                int nullCount = 0;
-                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, buffers, children);
-                Array = UnionArray.Create(arrayData);
-            }
-
-            private ArrayData[] GetChildren(NestedType type)
-            {
-                ArrayData[] children = new ArrayData[type.Fields.Count];
-
-                var data = JsonFieldData;
-                for (int i = 0; i < children.Length; i++)
-                {
-                    JsonFieldData = data.Children[i];
-                    type.Fields[i].DataType.Accept(this);
-                    children[i] = Array.Data;
-                }
-                JsonFieldData = data;
-
-                return children;
-            }
-
-            private static byte[] ConvertHexStringToByteArray(string hexString)
-            {
-                byte[] data = new byte[hexString.Length / 2];
-                for (int index = 0; index < data.Length; index++)
-                {
-                    data[index] = byte.Parse(hexString.AsSpan(index * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
-                }
-
-                return data;
-            }
-
-            private static readonly JsonSerializerOptions s_options = new JsonSerializerOptions()
-            {
-                Converters =
-                {
-                    new ByteArrayConverter()
-                }
-            };
-
-            private void GenerateArray<T, TArray>(Func<ArrowBuffer, ArrowBuffer, int, int, int, TArray> createArray)
-                where TArray : PrimitiveArray<T>
-                where T : struct
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrowBuffer.Builder<T> valueBuilder = new ArrowBuffer.Builder<T>(JsonFieldData.Count);
-                var json = JsonFieldData.Data.GetRawText();
-                T[] values = JsonSerializer.Deserialize<T[]>(json, s_options);
-
-                foreach (T value in values)
-                {
-                    valueBuilder.Append(value);
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = createArray(
-                    valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            private void GenerateLongArray<T, TArray>(Func<ArrowBuffer, ArrowBuffer, int, int, int, TArray> createArray, Func<string, T> parse)
-                where TArray : PrimitiveArray<T>
-                where T : struct
-            {
-                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
-
-                ArrowBuffer.Builder<T> valueBuilder = new ArrowBuffer.Builder<T>(JsonFieldData.Count);
-                var json = JsonFieldData.Data.GetRawText();
-                string[] values = JsonSerializer.Deserialize<string[]>(json);
-
-                foreach (string value in values)
-                {
-                    valueBuilder.Append(parse(value));
-                }
-                ArrowBuffer valueBuffer = valueBuilder.Build();
-
-                Array = createArray(
-                    valueBuffer, validityBuffer,
-                    JsonFieldData.Count, nullCount, 0);
-            }
-
-            private ArrowBuffer GetOffsetBuffer()
-            {
-                if (JsonFieldData.Count == 0) { return ArrowBuffer.Empty; }
-                ArrowBuffer.Builder<int> valueOffsets = new ArrowBuffer.Builder<int>(JsonFieldData.Offset.Length);
-                valueOffsets.AppendRange(JsonFieldData.Offset);
-                return valueOffsets.Build(default);
-            }
-
-            private ArrowBuffer GetTypeIdBuffer()
-            {
-                ArrowBuffer.Builder<byte> typeIds = new ArrowBuffer.Builder<byte>(JsonFieldData.TypeId.Length);
-                for (int i = 0; i < JsonFieldData.TypeId.Length; i++)
-                {
-                    typeIds.Append(checked((byte)JsonFieldData.TypeId[i]));
-                }
-                return typeIds.Build(default);
-            }
-
-            private ArrowBuffer GetValidityBuffer(out int nullCount)
-            {
-                if (JsonFieldData.Validity == null)
-                {
-                    nullCount = 0;
-                    return ArrowBuffer.Empty;
-                }
-
-                ArrowBuffer.BitmapBuilder validityBuilder = new ArrowBuffer.BitmapBuilder(JsonFieldData.Validity.Length);
-                validityBuilder.AppendRange(JsonFieldData.Validity);
-
-                nullCount = validityBuilder.UnsetBitCount;
-                return validityBuilder.Build();
-            }
-
-            public void Visit(IArrowType type)
-            {
-                throw new NotImplementedException($"{type.Name} not implemented");
-            }
-        }
-
         private async Task<int> StreamToFile()
         {
             using ArrowStreamReader reader = new ArrowStreamReader(Console.OpenStandardInput());
@@ -752,14 +163,7 @@ private async Task<int> FileToStream()
 
         private async ValueTask<JsonFile> ParseJsonFile()
         {
-            using var fileStream = JsonFileInfo.OpenRead();
-            JsonSerializerOptions options = new JsonSerializerOptions()
-            {
-                PropertyNamingPolicy = JsonFileNamingPolicy.Instance,
-            };
-            options.Converters.Add(new ValidityConverter());
-
-            return await JsonSerializer.DeserializeAsync<JsonFile>(fileStream, options);
+            return await JsonFile.ParseAsync(JsonFileInfo);
         }
     }
 }
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
index 112eeabcb9931..85f66890edf47 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
@@ -15,8 +15,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Numerics;
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Apache.Arrow.Arrays;
+using Apache.Arrow.Types;
 
 namespace Apache.Arrow.IntegrationTest
 {
@@ -25,12 +33,200 @@ public class JsonFile
         public JsonSchema Schema { get; set; }
         public List<JsonRecordBatch> Batches { get; set; }
         //public List<DictionaryBatch> Dictionaries {get;set;}
+
+        public static async ValueTask<JsonFile> ParseAsync(FileInfo fileInfo)
+        {
+            using var fileStream = fileInfo.OpenRead();
+            var options = GetJsonOptions();
+            return await JsonSerializer.DeserializeAsync<JsonFile>(fileStream, options);
+        }
+
+        public static JsonFile Parse(FileInfo fileInfo)
+        {
+            using var fileStream = fileInfo.OpenRead();
+            var options = GetJsonOptions();
+            return JsonSerializer.Deserialize<JsonFile>(fileStream, options);
+        }
+
+        private static JsonSerializerOptions GetJsonOptions()
+        {
+            JsonSerializerOptions options = new JsonSerializerOptions()
+            {
+                PropertyNamingPolicy = JsonFileNamingPolicy.Instance,
+            };
+            options.Converters.Add(new ValidityConverter());
+            return options;
+        }
     }
 
     public class JsonSchema
     {
         public List<JsonField> Fields { get; set; }
         public JsonMetadata Metadata { get; set; }
+
+        /// <summary>
+        /// Decode this JSON schema as a Schema instance.
+        /// </summary>
+        public Schema ToArrow()
+        {
+            return CreateSchema(this);
+        }
+
+        private static Schema CreateSchema(JsonSchema jsonSchema)
+        {
+            Schema.Builder builder = new Schema.Builder();
+            for (int i = 0; i < jsonSchema.Fields.Count; i++)
+            {
+                builder.Field(f => CreateField(f, jsonSchema.Fields[i]));
+            }
+            return builder.Build();
+        }
+
+        private static void CreateField(Field.Builder builder, JsonField jsonField)
+        {
+            Field[] children = null;
+            if (jsonField.Children?.Count > 0)
+            {
+                children = new Field[jsonField.Children.Count];
+                for (int i = 0; i < jsonField.Children.Count; i++)
+                {
+                    Field.Builder field = new Field.Builder();
+                    CreateField(field, jsonField.Children[i]);
+                    children[i] = field.Build();
+                }
+            }
+
+            builder.Name(jsonField.Name)
+                .DataType(ToArrowType(jsonField.Type, children))
+                .Nullable(jsonField.Nullable);
+
+            if (jsonField.Metadata != null)
+            {
+                builder.Metadata(jsonField.Metadata);
+            }
+        }
+
+        private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
+        {
+            return type.Name switch
+            {
+                "bool" => BooleanType.Default,
+                "int" => ToIntArrowType(type),
+                "floatingpoint" => ToFloatingPointArrowType(type),
+                "decimal" => ToDecimalArrowType(type),
+                "binary" => BinaryType.Default,
+                "utf8" => StringType.Default,
+                "fixedsizebinary" => new FixedSizeBinaryType(type.ByteWidth),
+                "date" => ToDateArrowType(type),
+                "time" => ToTimeArrowType(type),
+                "timestamp" => ToTimestampArrowType(type),
+                "list" => ToListArrowType(type, children),
+                "fixedsizelist" => ToFixedSizeListArrowType(type, children),
+                "struct" => ToStructArrowType(type, children),
+                "union" => ToUnionArrowType(type, children),
+                "null" => NullType.Default,
+                _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}")
+            };
+        }
+
+        private static IArrowType ToIntArrowType(JsonArrowType type)
+        {
+            return (type.BitWidth, type.IsSigned) switch
+            {
+                (8, true) => Int8Type.Default,
+                (8, false) => UInt8Type.Default,
+                (16, true) => Int16Type.Default,
+                (16, false) => UInt16Type.Default,
+                (32, true) => Int32Type.Default,
+                (32, false) => UInt32Type.Default,
+                (64, true) => Int64Type.Default,
+                (64, false) => UInt64Type.Default,
+                _ => throw new NotSupportedException($"Int type not supported: {type.BitWidth}, {type.IsSigned}")
+            };
+        }
+
+        private static IArrowType ToFloatingPointArrowType(JsonArrowType type)
+        {
+            return type.FloatingPointPrecision switch
+            {
+                "SINGLE" => FloatType.Default,
+                "DOUBLE" => DoubleType.Default,
+                _ => throw new NotSupportedException($"FloatingPoint type not supported: {type.FloatingPointPrecision}")
+            };
+        }
+
+        private static IArrowType ToDecimalArrowType(JsonArrowType type)
+        {
+            return type.BitWidth switch
+            {
+                256 => new Decimal256Type(type.DecimalPrecision, type.Scale),
+                _ => new Decimal128Type(type.DecimalPrecision, type.Scale),
+            };
+        }
+
+        private static IArrowType ToDateArrowType(JsonArrowType type)
+        {
+            return type.Unit switch
+            {
+                "DAY" => Date32Type.Default,
+                "MILLISECOND" => Date64Type.Default,
+                _ => throw new NotSupportedException($"Date type not supported: {type.Unit}")
+            };
+        }
+
+        private static IArrowType ToTimeArrowType(JsonArrowType type)
+        {
+            return (type.Unit, type.BitWidth) switch
+            {
+                ("SECOND", 32) => new Time32Type(TimeUnit.Second),
+                ("SECOND", 64) => new Time64Type(TimeUnit.Second),
+                ("MILLISECOND", 32) => new Time32Type(TimeUnit.Millisecond),
+                ("MILLISECOND", 64) => new Time64Type(TimeUnit.Millisecond),
+                ("MICROSECOND", 32) => new Time32Type(TimeUnit.Microsecond),
+                ("MICROSECOND", 64) => new Time64Type(TimeUnit.Microsecond),
+                ("NANOSECOND", 32) => new Time32Type(TimeUnit.Nanosecond),
+                ("NANOSECOND", 64) => new Time64Type(TimeUnit.Nanosecond),
+                _ => throw new NotSupportedException($"Time type not supported: {type.Unit}, {type.BitWidth}")
+            };
+        }
+
+        private static IArrowType ToTimestampArrowType(JsonArrowType type)
+        {
+            return type.Unit switch
+            {
+                "SECOND" => new TimestampType(TimeUnit.Second, type.Timezone),
+                "MILLISECOND" => new TimestampType(TimeUnit.Millisecond, type.Timezone),
+                "MICROSECOND" => new TimestampType(TimeUnit.Microsecond, type.Timezone),
+                "NANOSECOND" => new TimestampType(TimeUnit.Nanosecond, type.Timezone),
+                _ => throw new NotSupportedException($"Time type not supported: {type.Unit}, {type.BitWidth}")
+            };
+        }
+
+        private static IArrowType ToListArrowType(JsonArrowType type, Field[] children)
+        {
+            return new ListType(children[0]);
+        }
+
+        private static IArrowType ToFixedSizeListArrowType(JsonArrowType type, Field[] children)
+        {
+            return new FixedSizeListType(children[0], type.ListSize);
+        }
+
+        private static IArrowType ToStructArrowType(JsonArrowType type, Field[] children)
+        {
+            return new StructType(children);
+        }
+
+        private static IArrowType ToUnionArrowType(JsonArrowType type, Field[] children)
+        {
+            UnionMode mode = type.Mode switch
+            {
+                "SPARSE" => UnionMode.Sparse,
+                "DENSE" => UnionMode.Dense,
+                _ => throw new NotSupportedException($"Union mode not supported: {type.Mode}"),
+            };
+            return new UnionType(children, type.TypeIds, mode);
+        }
     }
 
     public class JsonField
@@ -60,7 +256,7 @@ public class JsonArrowType
         public int DecimalPrecision => ExtensionData["precision"].GetInt32();
         public int Scale { get; set; }
 
-        // date and time fields 
+        // date and time fields
         public string Unit { get; set; }
         // timestamp fields
         public string Timezone { get; set; }
@@ -74,7 +270,7 @@ public class JsonArrowType
         // union fields
         public string Mode { get; set; }
         public int[] TypeIds { get; set; }
-        
+
         [JsonExtensionData]
         public Dictionary<string, JsonElement> ExtensionData { get; set; }
     }
@@ -94,6 +290,446 @@ public class JsonRecordBatch
     {
         public int Count { get; set; }
         public List<JsonFieldData> Columns { get; set; }
+
+        /// <summary>
+        /// Decode this JSON record batch as a RecordBatch instance.
+        /// </summary>
+        public RecordBatch ToArrow(Schema schema)
+        {
+            return CreateRecordBatch(schema, this);
+        }
+
+        private RecordBatch CreateRecordBatch(Schema schema, JsonRecordBatch jsonRecordBatch)
+        {
+            if (schema.FieldsList.Count != jsonRecordBatch.Columns.Count)
+            {
+                throw new NotSupportedException($"jsonRecordBatch.Columns.Count '{jsonRecordBatch.Columns.Count}' doesn't match schema field count '{schema.FieldsList.Count}'");
+            }
+
+            List<IArrowArray> arrays = new List<IArrowArray>(jsonRecordBatch.Columns.Count);
+            for (int i = 0; i < jsonRecordBatch.Columns.Count; i++)
+            {
+                JsonFieldData data = jsonRecordBatch.Columns[i];
+                Field field = schema.FieldsList[i];
+                ArrayCreator creator = new ArrayCreator(data);
+                field.DataType.Accept(creator);
+                arrays.Add(creator.Array);
+            }
+
+            return new RecordBatch(schema, arrays, jsonRecordBatch.Count);
+        }
+
+        private class ArrayCreator :
+            IArrowTypeVisitor<BooleanType>,
+            IArrowTypeVisitor<Int8Type>,
+            IArrowTypeVisitor<Int16Type>,
+            IArrowTypeVisitor<Int32Type>,
+            IArrowTypeVisitor<Int64Type>,
+            IArrowTypeVisitor<UInt8Type>,
+            IArrowTypeVisitor<UInt16Type>,
+            IArrowTypeVisitor<UInt32Type>,
+            IArrowTypeVisitor<UInt64Type>,
+            IArrowTypeVisitor<FloatType>,
+            IArrowTypeVisitor<DoubleType>,
+            IArrowTypeVisitor<Decimal128Type>,
+            IArrowTypeVisitor<Decimal256Type>,
+            IArrowTypeVisitor<Date32Type>,
+            IArrowTypeVisitor<Date64Type>,
+            IArrowTypeVisitor<Time32Type>,
+            IArrowTypeVisitor<Time64Type>,
+            IArrowTypeVisitor<TimestampType>,
+            IArrowTypeVisitor<StringType>,
+            IArrowTypeVisitor<BinaryType>,
+            IArrowTypeVisitor<FixedSizeBinaryType>,
+            IArrowTypeVisitor<ListType>,
+            IArrowTypeVisitor<FixedSizeListType>,
+            IArrowTypeVisitor<StructType>,
+            IArrowTypeVisitor<UnionType>,
+            IArrowTypeVisitor<NullType>
+        {
+            private JsonFieldData JsonFieldData { get; set; }
+            public IArrowArray Array { get; private set; }
+
+            public ArrayCreator(JsonFieldData jsonFieldData)
+            {
+                JsonFieldData = jsonFieldData;
+            }
+
+            public void Visit(BooleanType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer.BitmapBuilder valueBuilder = new ArrowBuffer.BitmapBuilder(validityBuffer.Length);
+
+                var json = JsonFieldData.Data.GetRawText();
+                bool[] values = JsonSerializer.Deserialize<bool[]>(json);
+
+                foreach (bool value in values)
+                {
+                    valueBuilder.Append(value);
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = new BooleanArray(
+                    valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            public void Visit(Int8Type type) => GenerateArray<sbyte, Int8Array>((v, n, c, nc, o) => new Int8Array(v, n, c, nc, o));
+            public void Visit(Int16Type type) => GenerateArray<short, Int16Array>((v, n, c, nc, o) => new Int16Array(v, n, c, nc, o));
+            public void Visit(Int32Type type) => GenerateArray<int, Int32Array>((v, n, c, nc, o) => new Int32Array(v, n, c, nc, o));
+            public void Visit(Int64Type type) => GenerateLongArray<long, Int64Array>((v, n, c, nc, o) => new Int64Array(v, n, c, nc, o), s => long.Parse(s));
+            public void Visit(UInt8Type type) => GenerateArray<byte, UInt8Array>((v, n, c, nc, o) => new UInt8Array(v, n, c, nc, o));
+            public void Visit(UInt16Type type) => GenerateArray<ushort, UInt16Array>((v, n, c, nc, o) => new UInt16Array(v, n, c, nc, o));
+            public void Visit(UInt32Type type) => GenerateArray<uint, UInt32Array>((v, n, c, nc, o) => new UInt32Array(v, n, c, nc, o));
+            public void Visit(UInt64Type type) => GenerateLongArray<ulong, UInt64Array>((v, n, c, nc, o) => new UInt64Array(v, n, c, nc, o), s => ulong.Parse(s));
+            public void Visit(FloatType type) => GenerateArray<float, FloatArray>((v, n, c, nc, o) => new FloatArray(v, n, c, nc, o));
+            public void Visit(DoubleType type) => GenerateArray<double, DoubleArray>((v, n, c, nc, o) => new DoubleArray(v, n, c, nc, o));
+            public void Visit(Time32Type type) => GenerateArray<int, Time32Array>((v, n, c, nc, o) => new Time32Array(type, v, n, c, nc, o));
+            public void Visit(Time64Type type) => GenerateLongArray<long, Time64Array>((v, n, c, nc, o) => new Time64Array(type, v, n, c, nc, o), s => long.Parse(s));
+
+            public void Visit(Decimal128Type type)
+            {
+                Array = new Decimal128Array(GetDecimalArrayData(type));
+            }
+
+            public void Visit(Decimal256Type type)
+            {
+                Array = new Decimal256Array(GetDecimalArrayData(type));
+            }
+
+            public void Visit(NullType type)
+            {
+                Array = new NullArray(JsonFieldData.Count);
+            }
+
+            private ArrayData GetDecimalArrayData(FixedSizeBinaryType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                Span<byte> buffer = stackalloc byte[type.ByteWidth];
+
+                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
+                foreach (string value in values)
+                {
+                    buffer.Fill(0);
+
+                    BigInteger bigInteger = BigInteger.Parse(value);
+                    if (!bigInteger.TryWriteBytes(buffer, out int bytesWritten, false, !BitConverter.IsLittleEndian))
+                    {
+                        throw new InvalidDataException($"Decimal data was too big to fit into {type.BitWidth} bits.");
+                    }
+
+                    if (bigInteger.Sign == -1)
+                    {
+                        buffer.Slice(bytesWritten).Fill(255);
+                    }
+
+                    valueBuilder.Append(buffer);
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build(default);
+
+                return new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, valueBuffer });
+            }
+
+            public void Visit(Date32Type type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrowBuffer.Builder<int> valueBuilder = new ArrowBuffer.Builder<int>(JsonFieldData.Count);
+                var json = JsonFieldData.Data.GetRawText();
+                int[] values = JsonSerializer.Deserialize<int[]>(json, s_options);
+
+                foreach (int value in values)
+                {
+                    valueBuilder.Append(value);
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = new Date32Array(
+                    valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            public void Visit(Date64Type type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrowBuffer.Builder<long> valueBuilder = new ArrowBuffer.Builder<long>(JsonFieldData.Count);
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(long.Parse(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = new Date64Array(
+                    valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            public void Visit(TimestampType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrowBuffer.Builder<long> valueBuilder = new ArrowBuffer.Builder<long>(JsonFieldData.Count);
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(long.Parse(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = new TimestampArray(
+                    type, valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            public void Visit(StringType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer offsetBuffer = GetOffsetBuffer();
+
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(Encoding.UTF8.GetBytes(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build(default);
+
+                Array = new StringArray(JsonFieldData.Count, offsetBuffer, valueBuffer, validityBuffer, nullCount);
+            }
+
+            public void Visit(BinaryType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer offsetBuffer = GetOffsetBuffer();
+
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(ConvertHexStringToByteArray(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build(default);
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, offsetBuffer, valueBuffer });
+                Array = new BinaryArray(arrayData);
+            }
+
+            public void Visit(FixedSizeBinaryType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json, s_options);
+
+                ArrowBuffer.Builder<byte> valueBuilder = new ArrowBuffer.Builder<byte>();
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(ConvertHexStringToByteArray(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build(default);
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, new[] { validityBuffer, valueBuffer });
+                Array = new FixedSizeBinaryArray(arrayData);
+            }
+
+            public void Visit(ListType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer offsetBuffer = GetOffsetBuffer();
+
+                var data = JsonFieldData;
+                JsonFieldData = data.Children[0];
+                type.ValueDataType.Accept(this);
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer, offsetBuffer }, new[] { Array.Data });
+                Array = new ListArray(arrayData);
+            }
+
+            public void Visit(FixedSizeListType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                var data = JsonFieldData;
+                JsonFieldData = data.Children[0];
+                type.ValueDataType.Accept(this);
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer }, new[] { Array.Data });
+                Array = new FixedSizeListArray(arrayData);
+            }
+
+            public void Visit(StructType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrayData[] children = new ArrayData[type.Fields.Count];
+
+                var data = JsonFieldData;
+                for (int i = 0; i < children.Length; i++)
+                {
+                    JsonFieldData = data.Children[i];
+                    type.Fields[i].DataType.Accept(this);
+                    children[i] = Array.Data;
+                }
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer }, children);
+                Array = new StructArray(arrayData);
+            }
+
+            public void Visit(UnionType type)
+            {
+                ArrowBuffer[] buffers;
+                if (type.Mode == UnionMode.Dense)
+                {
+                    buffers = new ArrowBuffer[2];
+                    buffers[1] = GetOffsetBuffer();
+                }
+                else
+                {
+                    buffers = new ArrowBuffer[1];
+                }
+                buffers[0] = GetTypeIdBuffer();
+
+                ArrayData[] children = GetChildren(type);
+
+                int nullCount = 0;
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0, buffers, children);
+                Array = UnionArray.Create(arrayData);
+            }
+
+            private ArrayData[] GetChildren(NestedType type)
+            {
+                ArrayData[] children = new ArrayData[type.Fields.Count];
+
+                var data = JsonFieldData;
+                for (int i = 0; i < children.Length; i++)
+                {
+                    JsonFieldData = data.Children[i];
+                    type.Fields[i].DataType.Accept(this);
+                    children[i] = Array.Data;
+                }
+                JsonFieldData = data;
+
+                return children;
+            }
+
+            private static byte[] ConvertHexStringToByteArray(string hexString)
+            {
+                byte[] data = new byte[hexString.Length / 2];
+                for (int index = 0; index < data.Length; index++)
+                {
+                    data[index] = byte.Parse(hexString.AsSpan(index * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+                }
+
+                return data;
+            }
+
+            private static readonly JsonSerializerOptions s_options = new JsonSerializerOptions()
+            {
+                Converters =
+                {
+                    new ByteArrayConverter()
+                }
+            };
+
+            private void GenerateArray<T, TArray>(Func<ArrowBuffer, ArrowBuffer, int, int, int, TArray> createArray)
+                where TArray : PrimitiveArray<T>
+                where T : struct
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrowBuffer.Builder<T> valueBuilder = new ArrowBuffer.Builder<T>(JsonFieldData.Count);
+                var json = JsonFieldData.Data.GetRawText();
+                T[] values = JsonSerializer.Deserialize<T[]>(json, s_options);
+
+                foreach (T value in values)
+                {
+                    valueBuilder.Append(value);
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = createArray(
+                    valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            private void GenerateLongArray<T, TArray>(Func<ArrowBuffer, ArrowBuffer, int, int, int, TArray> createArray, Func<string, T> parse)
+                where TArray : PrimitiveArray<T>
+                where T : struct
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+
+                ArrowBuffer.Builder<T> valueBuilder = new ArrowBuffer.Builder<T>(JsonFieldData.Count);
+                var json = JsonFieldData.Data.GetRawText();
+                string[] values = JsonSerializer.Deserialize<string[]>(json);
+
+                foreach (string value in values)
+                {
+                    valueBuilder.Append(parse(value));
+                }
+                ArrowBuffer valueBuffer = valueBuilder.Build();
+
+                Array = createArray(
+                    valueBuffer, validityBuffer,
+                    JsonFieldData.Count, nullCount, 0);
+            }
+
+            private ArrowBuffer GetOffsetBuffer()
+            {
+                ArrowBuffer.Builder<int> valueOffsets = new ArrowBuffer.Builder<int>(JsonFieldData.Offset.Length);
+                valueOffsets.AppendRange(JsonFieldData.Offset);
+                return valueOffsets.Build(default);
+            }
+
+            private ArrowBuffer GetTypeIdBuffer()
+            {
+                ArrowBuffer.Builder<byte> typeIds = new ArrowBuffer.Builder<byte>(JsonFieldData.TypeId.Length);
+                for (int i = 0; i < JsonFieldData.TypeId.Length; i++)
+                {
+                    typeIds.Append(checked((byte)JsonFieldData.TypeId[i]));
+                }
+                return typeIds.Build(default);
+            }
+
+            private ArrowBuffer GetValidityBuffer(out int nullCount)
+            {
+                if (JsonFieldData.Validity == null)
+                {
+                    nullCount = 0;
+                    return ArrowBuffer.Empty;
+                }
+
+                ArrowBuffer.BitmapBuilder validityBuilder = new ArrowBuffer.BitmapBuilder(JsonFieldData.Validity.Length);
+                validityBuilder.AppendRange(JsonFieldData.Validity);
+
+                nullCount = validityBuilder.UnsetBitCount;
+                return validityBuilder.Build();
+            }
+
+            public void Visit(IArrowType type)
+            {
+                throw new NotImplementedException($"{type.Name} not implemented");
+            }
+        }
     }
 
     public class JsonFieldData
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index f28b89a9cd17e..b6b65a582d953 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -99,8 +99,8 @@ private static Schema GetTestSchema()
                     .Field(f => f.Name("time64_us").DataType(new Time64Type(TimeUnit.Microsecond)).Nullable(false))
                     .Field(f => f.Name("time64_ns").DataType(new Time64Type(TimeUnit.Nanosecond)).Nullable(false))
 
-                    .Field(f => f.Name("timestamp_ns").DataType(new TimestampType(TimeUnit.Nanosecond, "")).Nullable(false))
-                    .Field(f => f.Name("timestamp_us").DataType(new TimestampType(TimeUnit.Microsecond, "")).Nullable(false))
+                    .Field(f => f.Name("timestamp_ns").DataType(new TimestampType(TimeUnit.Nanosecond, (string) null)).Nullable(false))
+                    .Field(f => f.Name("timestamp_us").DataType(new TimestampType(TimeUnit.Microsecond, (string) null)).Nullable(false))
                     .Field(f => f.Name("timestamp_us_paris").DataType(new TimestampType(TimeUnit.Microsecond, "Europe/Paris")).Nullable(true))
 
                     .Field(f => f.Name("list_string").DataType(new ListType(StringType.Default)).Nullable(false))
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index a780d33cbf323..67f0693df14aa 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -124,8 +124,8 @@ def run_c_data(self):
         enabled implementations.
         """
         for producer, consumer in itertools.product(
-                filter(lambda t: t.C_DATA_EXPORTER, self.testers),
-                filter(lambda t: t.C_DATA_IMPORTER, self.testers)):
+                filter(lambda t: t.C_DATA_SCHEMA_EXPORTER, self.testers),
+                filter(lambda t: t.C_DATA_SCHEMA_IMPORTER, self.testers)):
             self._compare_c_data_implementations(producer, consumer)
         log('\n')
 
@@ -428,9 +428,10 @@ def _compare_c_data_implementations(
                               exporter, importer)
         self._run_test_cases(case_runner, self.json_files, serial=serial)
 
-        case_runner = partial(self._run_c_array_test_cases, producer, consumer,
-                              exporter, importer)
-        self._run_test_cases(case_runner, self.json_files, serial=serial)
+        if producer.C_DATA_ARRAY_EXPORTER and consumer.C_DATA_ARRAY_IMPORTER:
+            case_runner = partial(self._run_c_array_test_cases, producer, consumer,
+                                  exporter, importer)
+            self._run_test_cases(case_runner, self.json_files, serial=serial)
 
     def _run_c_schema_test_case(self,
                                 producer: Tester, consumer: Tester,
diff --git a/dev/archery/archery/integration/tester.py b/dev/archery/archery/integration/tester.py
index 6a3061992d006..6cde20e61b321 100644
--- a/dev/archery/archery/integration/tester.py
+++ b/dev/archery/archery/integration/tester.py
@@ -204,9 +204,11 @@ class Tester:
     # whether the language supports receiving Flight
     FLIGHT_CLIENT = False
     # whether the language supports the C Data Interface as an exporter
-    C_DATA_EXPORTER = False
+    C_DATA_SCHEMA_EXPORTER = False
+    C_DATA_ARRAY_EXPORTER = False
     # whether the language supports the C Data Interface as an importer
-    C_DATA_IMPORTER = False
+    C_DATA_SCHEMA_IMPORTER = False
+    C_DATA_ARRAY_IMPORTER = False
 
     # the name used for skipping and shown in the logs
     name = "unknown"
diff --git a/dev/archery/archery/integration/tester_cpp.py b/dev/archery/archery/integration/tester_cpp.py
index 9ddc3c480002a..ab642c31aacc6 100644
--- a/dev/archery/archery/integration/tester_cpp.py
+++ b/dev/archery/archery/integration/tester_cpp.py
@@ -52,8 +52,10 @@ class CppTester(Tester):
     CONSUMER = True
     FLIGHT_SERVER = True
     FLIGHT_CLIENT = True
-    C_DATA_EXPORTER = True
-    C_DATA_IMPORTER = True
+    C_DATA_SCHEMA_EXPORTER = True
+    C_DATA_ARRAY_EXPORTER = True
+    C_DATA_SCHEMA_IMPORTER = True
+    C_DATA_ARRAY_IMPORTER = True
 
     name = 'C++'
 
diff --git a/dev/archery/archery/integration/tester_csharp.py b/dev/archery/archery/integration/tester_csharp.py
index 018731d573cac..83b07495f9907 100644
--- a/dev/archery/archery/integration/tester_csharp.py
+++ b/dev/archery/archery/integration/tester_csharp.py
@@ -15,23 +15,143 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from contextlib import contextmanager
+import gc
 import os
 
-from .tester import Tester
+from . import cdata
+from .tester import Tester, CDataExporter, CDataImporter
 from .util import run_cmd, log
 from ..utils.source import ARROW_ROOT_DEFAULT
 
 
-_EXE_PATH = os.path.join(
-    ARROW_ROOT_DEFAULT,
-    "csharp/artifacts/Apache.Arrow.IntegrationTest",
-    "Debug/net7.0/Apache.Arrow.IntegrationTest",
-)
+_ARTIFACTS_PATH = os.path.join(ARROW_ROOT_DEFAULT, "csharp/artifacts")
+
+_EXE_PATH = os.path.join(_ARTIFACTS_PATH,
+                         "Apache.Arrow.IntegrationTest",
+                         "Debug/net7.0/Apache.Arrow.IntegrationTest",
+                         )
+
+_clr_loaded = False
+
+
+def _load_clr():
+    global _clr_loaded
+    if not _clr_loaded:
+        _clr_loaded = True
+        import pythonnet
+        pythonnet.load("coreclr")
+        import clr
+        clr.AddReference(
+            f"{_ARTIFACTS_PATH}/Apache.Arrow.IntegrationTest/"
+            f"Debug/net7.0/Apache.Arrow.IntegrationTest.dll")
+        clr.AddReference(
+            f"{_ARTIFACTS_PATH}/Apache.Arrow.Tests/"
+            f"Debug/net7.0/Apache.Arrow.Tests.dll")
+
+        from Apache.Arrow.IntegrationTest import CDataInterface
+        CDataInterface.Initialize()
+
+
+@contextmanager
+def _disposing(disposable):
+    """
+    Ensure the IDisposable object is disposed of when the enclosed block exits.
+    """
+    try:
+        yield disposable
+    finally:
+        disposable.Dispose()
+
+
+class _CDataBase:
+
+    def __init__(self, debug, args):
+        self.debug = debug
+        self.args = args
+        self.ffi = cdata.ffi()
+        _load_clr()
+
+    def _pointer_to_int(self, c_ptr):
+        return int(self.ffi.cast('uintptr_t', c_ptr))
+
+    def _read_batch_from_json(self, json_path, num_batch):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+
+        jf = CDataInterface.ParseJsonFile(json_path)
+        schema = jf.Schema.ToArrow()
+        return schema, jf.Batches[num_batch].ToArrow(schema)
+
+
+class CSharpCDataExporter(CDataExporter, _CDataBase):
+
+    def export_schema_from_json(self, json_path, c_schema_ptr):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+
+        jf = CDataInterface.ParseJsonFile(json_path)
+        CDataInterface.ExportSchema(jf.Schema.ToArrow(),
+                                    self._pointer_to_int(c_schema_ptr))
+
+    def export_batch_from_json(self, json_path, num_batch, c_array_ptr):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+
+        _, batch = self._read_batch_from_json(json_path, num_batch)
+        with _disposing(batch):
+            CDataInterface.ExportRecordBatch(batch,
+                                             self._pointer_to_int(c_array_ptr))
+
+    @property
+    def supports_releasing_memory(self):
+        # XXX the C# GC doesn't give reliable allocation measurements
+        return False
+
+
+class CSharpCDataImporter(CDataImporter, _CDataBase):
+
+    def import_schema_and_compare_to_json(self, json_path, c_schema_ptr):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+        from Apache.Arrow.Tests import SchemaComparer
+
+        jf = CDataInterface.ParseJsonFile(json_path)
+        imported_schema = CDataInterface.ImportSchema(
+            self._pointer_to_int(c_schema_ptr))
+        SchemaComparer.Compare(jf.Schema.ToArrow(), imported_schema)
+
+    def import_batch_and_compare_to_json(self, json_path, num_batch,
+                                         c_array_ptr):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+        from Apache.Arrow.Tests import ArrowReaderVerifier
+
+        schema, batch = self._read_batch_from_json(json_path, num_batch)
+        with _disposing(batch):
+            imported_batch = CDataInterface.ImportRecordBatch(
+                self._pointer_to_int(c_array_ptr), schema)
+            with _disposing(imported_batch):
+                ArrowReaderVerifier.CompareBatches(batch, imported_batch,
+                                                   strictCompare=False)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def gc_until(self, predicate):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+        for i in range(3):
+            if predicate():
+                return True
+            # Collect any C# objects hanging around through Python
+            gc.collect()
+            CDataInterface.RunGC()
+        return predicate()
 
 
 class CSharpTester(Tester):
     PRODUCER = True
     CONSUMER = True
+    C_DATA_SCHEMA_EXPORTER = True
+    C_DATA_SCHEMA_IMPORTER = True
+    C_DATA_ARRAY_EXPORTER = True
+    C_DATA_ARRAY_IMPORTER = True
 
     name = 'C#'
 
@@ -68,3 +188,9 @@ def file_to_stream(self, file_path, stream_path):
         cmd.extend(['--mode', 'file-to-stream'])
         cmd.extend(['-a', file_path, '>', stream_path])
         self.run_shell_command(cmd)
+
+    def make_c_data_exporter(self):
+        return CSharpCDataExporter(self.debug, self.args)
+
+    def make_c_data_importer(self):
+        return CSharpCDataImporter(self.debug, self.args)
diff --git a/dev/archery/archery/integration/tester_go.py b/dev/archery/archery/integration/tester_go.py
index 6fa26ea02b8e7..75333db8d66d5 100644
--- a/dev/archery/archery/integration/tester_go.py
+++ b/dev/archery/archery/integration/tester_go.py
@@ -55,8 +55,10 @@ class GoTester(Tester):
     CONSUMER = True
     FLIGHT_SERVER = True
     FLIGHT_CLIENT = True
-    C_DATA_EXPORTER = True
-    C_DATA_IMPORTER = True
+    C_DATA_SCHEMA_EXPORTER = True
+    C_DATA_ARRAY_EXPORTER = True
+    C_DATA_SCHEMA_IMPORTER = True
+    C_DATA_ARRAY_IMPORTER = True
 
     name = 'Go'
 

From 50de296b0b62e54ee3a67401f277afba9b9d0433 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 3 Oct 2023 10:13:45 +0900
Subject: [PATCH 445/749] GH-37971: [CI][Java] Don't use cache for nightly
 upload (#37980)

### Rationale for this change

It's too large (8.6 GB) and it's always re-created because it uses github.run_id for key. It expires other caches soon.

### What changes are included in this PR?

Remove actions/cache.

### Are these changes tested?

No.

### Are there any user-facing changes?

No.
* Closes: #37971

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/java_nightly.yml | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/.github/workflows/java_nightly.yml b/.github/workflows/java_nightly.yml
index 4440d36d18f73..41843d663051a 100644
--- a/.github/workflows/java_nightly.yml
+++ b/.github/workflows/java_nightly.yml
@@ -73,12 +73,6 @@ jobs:
           fi
           echo $PREFIX
           archery crossbow download-artifacts -f java-jars -t binaries  $PREFIX
-      - name: Cache Repo
-        uses: actions/cache@v3
-        with:
-          path: repo
-          key: java-nightly-${{ github.run_id }}
-          restore-keys: java-nightly
       - name: Sync from Remote
         uses: ./arrow/.github/actions/sync-nightlies
         with:

From d428ef4682d3a9ce4cfc2b1ab4653deeafd92a3e Mon Sep 17 00:00:00 2001
From: Yue <niyue.com@gmail.com>
Date: Tue, 3 Oct 2023 15:21:45 +0800
Subject: [PATCH 446/749] GH-37834: [Gandiva] Migrate to new LLVM PassManager
 API (#37867)

### Rationale for this change
In https://github.com/apache/arrow/issues/37834, to support LLVM 17, we need to migrate to use the new LLVM PassManager API.

### What changes are included in this PR?

 This PR tries to migrate the legacy PassManager to the new PassManager.

### Are these changes tested?
It should be covered by existing unit tests. But more performance tests may be needed to verify this change.

### Are there any user-facing changes?
No

* Closes: #37834

Lead-authored-by: Yue Ni <niyue.com@gmail.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/CMakeLists.txt                  |   1 +
 cpp/cmake_modules/FindLLVMAlt.cmake |  24 ++---
 cpp/src/gandiva/CMakeLists.txt      |   2 -
 cpp/src/gandiva/engine.cc           | 130 +++++++++++++++++++++-------
 4 files changed, 115 insertions(+), 42 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index f2906b960eba6..f0acab0389b19 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -152,6 +152,7 @@ set(ARROW_DOC_DIR "share/doc/${PROJECT_NAME}")
 set(BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build-support")
 
 set(ARROW_LLVM_VERSIONS
+    "17.0"
     "16.0"
     "15.0"
     "14.0"
diff --git a/cpp/cmake_modules/FindLLVMAlt.cmake b/cpp/cmake_modules/FindLLVMAlt.cmake
index e980f53fd3407..69f680824b082 100644
--- a/cpp/cmake_modules/FindLLVMAlt.cmake
+++ b/cpp/cmake_modules/FindLLVMAlt.cmake
@@ -86,16 +86,20 @@ if(LLVM_FOUND)
     target_link_libraries(LLVM::LLVM_LIBS INTERFACE LLVM)
   else()
     # Find the libraries that correspond to the LLVM components
-    llvm_map_components_to_libnames(LLVM_LIBS
-                                    core
-                                    mcjit
-                                    native
-                                    ipo
-                                    bitreader
-                                    target
-                                    linker
-                                    analysis
-                                    debuginfodwarf)
+    set(LLVM_TARGET_COMPONENTS
+        analysis
+        bitreader
+        core
+        debuginfodwarf
+        ipo
+        linker
+        mcjit
+        native
+        target)
+    if(LLVM_VERSION_MAJOR GREATER_EQUAL 14)
+      list(APPEND LLVM_TARGET_COMPONENTS passes)
+    endif()
+    llvm_map_components_to_libnames(LLVM_LIBS ${LLVM_TARGET_COMPONENTS})
     target_link_libraries(LLVM::LLVM_LIBS INTERFACE ${LLVM_LIBS})
 
     if(TARGET LLVMSupport AND NOT ARROW_ZSTD_USE_SHARED)
diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index db260b5acc933..d2810c39f723c 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -31,8 +31,6 @@ if(ARROW_WITH_ZSTD AND "${zstd_SOURCE}" STREQUAL "SYSTEM")
   provide_find_module(zstdAlt "Gandiva")
 endif()
 
-add_definitions(-DGANDIVA_LLVM_VERSION=${LLVM_VERSION_MAJOR})
-
 # Set the path where the bitcode file generated, see precompiled/CMakeLists.txt
 set(GANDIVA_PRECOMPILED_BC_PATH "${CMAKE_CURRENT_BINARY_DIR}/irhelpers.bc")
 set(GANDIVA_PRECOMPILED_CC_PATH "${CMAKE_CURRENT_BINARY_DIR}/precompiled_bitcode.cc")
diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index 7d75793a3e9e7..b6c78da89d575 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -53,18 +53,33 @@
 #include <llvm/IR/LegacyPassManager.h>
 #include <llvm/IR/Verifier.h>
 #include <llvm/Linker/Linker.h>
+#if LLVM_VERSION_MAJOR >= 17
+#include <llvm/TargetParser/SubtargetFeature.h>
+#else
 #include <llvm/MC/SubtargetFeature.h>
+#endif
+#include <llvm/Passes/PassBuilder.h>
 #include <llvm/Support/DynamicLibrary.h>
 #include <llvm/Support/Host.h>
+#include <llvm/Transforms/IPO/GlobalDCE.h>
+#include <llvm/Transforms/IPO/Internalize.h>
 #if LLVM_VERSION_MAJOR >= 14
+#include <llvm/IR/PassManager.h>
 #include <llvm/MC/TargetRegistry.h>
+#include <llvm/Passes/PassPlugin.h>
+#include <llvm/Transforms/IPO/GlobalOpt.h>
+#include <llvm/Transforms/Scalar/NewGVN.h>
+#include <llvm/Transforms/Scalar/SimplifyCFG.h>
+#include <llvm/Transforms/Utils/Mem2Reg.h>
+#include <llvm/Transforms/Vectorize/LoopVectorize.h>
+#include <llvm/Transforms/Vectorize/SLPVectorizer.h>
 #else
 #include <llvm/Support/TargetRegistry.h>
+#include <llvm/Transforms/IPO/PassManagerBuilder.h>
 #endif
 #include <llvm/Support/TargetSelect.h>
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Transforms/IPO.h>
-#include <llvm/Transforms/IPO/PassManagerBuilder.h>
 #include <llvm/Transforms/InstCombine/InstCombine.h>
 #include <llvm/Transforms/Scalar.h>
 #include <llvm/Transforms/Scalar/GVN.h>
@@ -268,49 +283,104 @@ Status Engine::LoadPreCompiledIR() {
 // a pass for dead code elimination.
 Status Engine::RemoveUnusedFunctions() {
   // Setup an optimiser pipeline
-  std::unique_ptr<llvm::legacy::PassManager> pass_manager(
-      new llvm::legacy::PassManager());
+  llvm::PassBuilder pass_builder;
+  llvm::ModuleAnalysisManager module_am;
+
+  pass_builder.registerModuleAnalyses(module_am);
+  llvm::ModulePassManager module_pm;
 
   std::unordered_set<std::string> used_functions;
   used_functions.insert(functions_to_compile_.begin(), functions_to_compile_.end());
 
-  pass_manager->add(
-      llvm::createInternalizePass([&used_functions](const llvm::GlobalValue& func) {
-        return (used_functions.find(func.getName().str()) != used_functions.end());
+  module_pm.addPass(
+      llvm::InternalizePass([&used_functions](const llvm::GlobalValue& variable) -> bool {
+        return used_functions.find(variable.getName().str()) != used_functions.end();
       }));
-  pass_manager->add(llvm::createGlobalDCEPass());
-  pass_manager->run(*module_);
+  module_pm.addPass(llvm::GlobalDCEPass());
+
+  module_pm.run(*module_, module_am);
   return Status::OK();
 }
 
+// several passes requiring LLVM 14+ that are not available in the legacy pass manager
+#if LLVM_VERSION_MAJOR >= 14
+static void OptimizeModuleWithNewPassManager(llvm::Module& module,
+                                             llvm::TargetIRAnalysis target_analysis) {
+  // Setup an optimiser pipeline
+  llvm::PassBuilder pass_builder;
+  llvm::LoopAnalysisManager loop_am;
+  llvm::FunctionAnalysisManager function_am;
+  llvm::CGSCCAnalysisManager cgscc_am;
+  llvm::ModuleAnalysisManager module_am;
+
+  function_am.registerPass([&] { return target_analysis; });
+
+  // Register required analysis managers
+  pass_builder.registerModuleAnalyses(module_am);
+  pass_builder.registerCGSCCAnalyses(cgscc_am);
+  pass_builder.registerFunctionAnalyses(function_am);
+  pass_builder.registerLoopAnalyses(loop_am);
+  pass_builder.crossRegisterProxies(loop_am, function_am, cgscc_am, module_am);
+
+  pass_builder.registerPipelineStartEPCallback([&](llvm::ModulePassManager& module_pm,
+                                                   llvm::OptimizationLevel Level) {
+    module_pm.addPass(llvm::ModuleInlinerPass());
+
+    llvm::FunctionPassManager function_pm;
+    function_pm.addPass(llvm::InstCombinePass());
+    function_pm.addPass(llvm::PromotePass());
+    function_pm.addPass(llvm::GVNPass());
+    function_pm.addPass(llvm::NewGVNPass());
+    function_pm.addPass(llvm::SimplifyCFGPass());
+    function_pm.addPass(llvm::LoopVectorizePass());
+    function_pm.addPass(llvm::SLPVectorizerPass());
+    module_pm.addPass(llvm::createModuleToFunctionPassAdaptor(std::move(function_pm)));
+
+    module_pm.addPass(llvm::GlobalOptPass());
+  });
+
+  pass_builder.buildPerModuleDefaultPipeline(llvm::OptimizationLevel::O3)
+      .run(module, module_am);
+}
+#else
+static void OptimizeModuleWithLegacyPassManager(llvm::Module& module,
+                                                llvm::TargetIRAnalysis target_analysis) {
+  std::unique_ptr<llvm::legacy::PassManager> pass_manager(
+      new llvm::legacy::PassManager());
+
+  pass_manager->add(llvm::createTargetTransformInfoWrapperPass(target_analysis));
+  pass_manager->add(llvm::createFunctionInliningPass());
+  pass_manager->add(llvm::createInstructionCombiningPass());
+  pass_manager->add(llvm::createPromoteMemoryToRegisterPass());
+  pass_manager->add(llvm::createGVNPass());
+  pass_manager->add(llvm::createNewGVNPass());
+  pass_manager->add(llvm::createCFGSimplificationPass());
+  pass_manager->add(llvm::createLoopVectorizePass());
+  pass_manager->add(llvm::createSLPVectorizerPass());
+  pass_manager->add(llvm::createGlobalOptimizerPass());
+
+  // run the optimiser
+  llvm::PassManagerBuilder pass_builder;
+  pass_builder.OptLevel = 3;
+  pass_builder.populateModulePassManager(*pass_manager);
+  pass_manager->run(module);
+}
+#endif
+
 // Optimise and compile the module.
 Status Engine::FinalizeModule() {
   if (!cached_) {
     ARROW_RETURN_NOT_OK(RemoveUnusedFunctions());
 
     if (optimize_) {
-      // misc passes to allow for inlining, vectorization, ..
-      std::unique_ptr<llvm::legacy::PassManager> pass_manager(
-          new llvm::legacy::PassManager());
-
-      llvm::TargetIRAnalysis target_analysis =
-          execution_engine_->getTargetMachine()->getTargetIRAnalysis();
-      pass_manager->add(llvm::createTargetTransformInfoWrapperPass(target_analysis));
-      pass_manager->add(llvm::createFunctionInliningPass());
-      pass_manager->add(llvm::createInstructionCombiningPass());
-      pass_manager->add(llvm::createPromoteMemoryToRegisterPass());
-      pass_manager->add(llvm::createGVNPass());
-      pass_manager->add(llvm::createNewGVNPass());
-      pass_manager->add(llvm::createCFGSimplificationPass());
-      pass_manager->add(llvm::createLoopVectorizePass());
-      pass_manager->add(llvm::createSLPVectorizerPass());
-      pass_manager->add(llvm::createGlobalOptimizerPass());
-
-      // run the optimiser
-      llvm::PassManagerBuilder pass_builder;
-      pass_builder.OptLevel = 3;
-      pass_builder.populateModulePassManager(*pass_manager);
-      pass_manager->run(*module_);
+      auto target_analysis = execution_engine_->getTargetMachine()->getTargetIRAnalysis();
+
+// misc passes to allow for inlining, vectorization, ..
+#if LLVM_VERSION_MAJOR >= 14
+      OptimizeModuleWithNewPassManager(*module_, target_analysis);
+#else
+      OptimizeModuleWithLegacyPassManager(*module_, target_analysis);
+#endif
     }
 
     ARROW_RETURN_IF(llvm::verifyModule(*module_, &llvm::errs()),

From 14a433aa65dc684e68dfa3a8d3f73cfce313d0eb Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Tue, 3 Oct 2023 21:43:16 +0800
Subject: [PATCH 447/749] GH-37873: [C++][Parquet] DELTA_BYTE_ARRAY: avoid
 copying data when possible (#37874)

### Rationale for this change

When decoding DELTA_BYTE_ARRAY data, if the prefix (respectively suffix) is empty, we don't need to recreate the original string by copying the data into a new buffer, we can just point to the existing suffix (respectively suffix).

### What changes are included in this PR?

Avoid spurious memory copies in the DELTA_BYTE_ARRAY decoder (also reducing the memory footprint when decoding).

Benchmark numbers show that decoding can be up to 2x faster.

### Are these changes tested?

Yes, already tested.

### Are there any user-facing changes?

No.

* Closes: #37873

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc | 66 ++++++++++++++++++++++++++++++-------
 1 file changed, 55 insertions(+), 11 deletions(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 0564ea2b93f3f..9f705768e4eff 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -3346,6 +3346,43 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecode
   }
 
  protected:
+  template <bool is_first_run>
+  static void BuildBufferInternal(const int32_t* prefix_len_ptr, int i, ByteArray* buffer,
+                                  std::string_view* prefix, uint8_t** data_ptr) {
+    if (ARROW_PREDICT_FALSE(static_cast<size_t>(prefix_len_ptr[i]) > prefix->length())) {
+      throw ParquetException("prefix length too large in DELTA_BYTE_ARRAY");
+    }
+    // For now, `buffer` points to string suffixes, and the suffix decoder
+    // ensures that the suffix data has sufficient lifetime.
+    if (prefix_len_ptr[i] == 0) {
+      // prefix is empty: buffer[i] already points to the suffix.
+      *prefix = std::string_view{buffer[i]};
+      return;
+    }
+    DCHECK_EQ(is_first_run, i == 0);
+    if constexpr (!is_first_run) {
+      if (buffer[i].len == 0) {
+        // suffix is empty: buffer[i] can simply point to the prefix.
+        // This is not possible for the first run since the prefix
+        // would point to the mutable `last_value_`.
+        *prefix = prefix->substr(0, prefix_len_ptr[i]);
+        buffer[i] = ByteArray(*prefix);
+        return;
+      }
+    }
+    // Both prefix and suffix are non-empty, so we need to decode the string
+    // into `data_ptr`.
+    // 1. Copy the prefix
+    memcpy(*data_ptr, prefix->data(), prefix_len_ptr[i]);
+    // 2. Copy the suffix.
+    memcpy(*data_ptr + prefix_len_ptr[i], buffer[i].ptr, buffer[i].len);
+    // 3. Point buffer[i] to the decoded string.
+    buffer[i].ptr = *data_ptr;
+    buffer[i].len += prefix_len_ptr[i];
+    *data_ptr += buffer[i].len;
+    *prefix = std::string_view{buffer[i]};
+  }
+
   int GetInternal(ByteArray* buffer, int max_values) {
     // Decode up to `max_values` strings into an internal buffer
     // and reference them into `buffer`.
@@ -3366,9 +3403,19 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecode
         reinterpret_cast<const int32_t*>(buffered_prefix_length_->data()) +
         prefix_len_offset_;
     for (int i = 0; i < max_values; ++i) {
+      if (prefix_len_ptr[i] == 0) {
+        // We don't need to copy the suffix if the prefix length is 0.
+        continue;
+      }
       if (ARROW_PREDICT_FALSE(prefix_len_ptr[i] < 0)) {
         throw ParquetException("negative prefix length in DELTA_BYTE_ARRAY");
       }
+      if (buffer[i].len == 0 && i != 0) {
+        // We don't need to copy the prefix if the suffix length is 0
+        // and this is not the first run (that is, the prefix doesn't point
+        // to the mutable `last_value_`).
+        continue;
+      }
       if (ARROW_PREDICT_FALSE(AddWithOverflow(data_size, prefix_len_ptr[i], &data_size) ||
                               AddWithOverflow(data_size, buffer[i].len, &data_size))) {
         throw ParquetException("excess expansion in DELTA_BYTE_ARRAY");
@@ -3378,18 +3425,15 @@ class DeltaByteArrayDecoderImpl : public DecoderImpl, virtual public TypedDecode
 
     string_view prefix{last_value_};
     uint8_t* data_ptr = buffered_data_->mutable_data();
-    for (int i = 0; i < max_values; ++i) {
-      if (ARROW_PREDICT_FALSE(static_cast<size_t>(prefix_len_ptr[i]) > prefix.length())) {
-        throw ParquetException("prefix length too large in DELTA_BYTE_ARRAY");
-      }
-      memcpy(data_ptr, prefix.data(), prefix_len_ptr[i]);
-      // buffer[i] currently points to the string suffix
-      memcpy(data_ptr + prefix_len_ptr[i], buffer[i].ptr, buffer[i].len);
-      buffer[i].ptr = data_ptr;
-      buffer[i].len += prefix_len_ptr[i];
-      data_ptr += buffer[i].len;
-      prefix = std::string_view{buffer[i]};
+    if (max_values > 0) {
+      BuildBufferInternal</*is_first_run=*/true>(prefix_len_ptr, 0, buffer, &prefix,
+                                                 &data_ptr);
+    }
+    for (int i = 1; i < max_values; ++i) {
+      BuildBufferInternal</*is_first_run=*/false>(prefix_len_ptr, i, buffer, &prefix,
+                                                  &data_ptr);
     }
+    DCHECK_EQ(data_ptr - buffered_data_->mutable_data(), data_size);
     prefix_len_offset_ += max_values;
     this->num_values_ -= max_values;
     num_valid_values_ -= max_values;

From f6afc33a9e1b4cbd336982bf99b330ccacbf8566 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 3 Oct 2023 17:12:02 +0200
Subject: [PATCH 448/749] GH-37993: [CI] Fix conda-integration build (#37990)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

The conda-integration build has recently started failing:
https://github.com/apache/arrow/actions/runs/6393852866/job/17353952453

Apparently this is because conda-forge is now providing Python 3.12 by default, and pythonnet [does not support it yet](https://github.com/pythonnet/pythonnet/pull/2249).

### What changes are included in this PR?

Avoid using Python 3.12 for Archery in conda-integration build.

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

No.
* Closes: #37993

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 ci/docker/conda-integration.dockerfile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/ci/docker/conda-integration.dockerfile b/ci/docker/conda-integration.dockerfile
index a306790b5cb6d..074021677d6fd 100644
--- a/ci/docker/conda-integration.dockerfile
+++ b/ci/docker/conda-integration.dockerfile
@@ -29,9 +29,11 @@ ARG go=1.19.13
 # Install Archery and integration dependencies
 COPY ci/conda_env_archery.txt /arrow/ci/
 
+# Pin Python until pythonnet is made compatible with 3.12
+# (https://github.com/pythonnet/pythonnet/pull/2249)
 RUN mamba install -q -y \
         --file arrow/ci/conda_env_archery.txt \
-        "python>=3.7" \
+        "python < 3.12" \
         numpy \
         compilers \
         maven=${maven} \

From 92de9a3028fdfb76e0ca1e216845e09bf68ab4ac Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 3 Oct 2023 13:49:50 -0400
Subject: [PATCH 449/749] GH-37635: [Format][C++][Go] Add app_metadata to
 FlightInfo and FlightEndpoint (#37679)

### Rationale for this change
As suggested here: https://github.com/apache/arrow/issues/37635#issuecomment-1712146541 this just adds an `app_metadata` field to FlightInfo and FlightEndpoint

### What changes are included in this PR?
Just the updated proto file and the generated Go code from the proto

### Are there any user-facing changes?

Yes.

**This PR includes breaking changes to public APIs.**

* Closes: #37635

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/arrow/flight/flight_internals_test.cc |  69 ++-
 .../flight_integration_test.cc                |   4 +
 .../integration_tests/test_integration.cc     |  61 ++
 cpp/src/arrow/flight/perf_server.cc           |   2 +-
 .../arrow/flight/serialization_internal.cc    |   4 +
 cpp/src/arrow/flight/sql/server.cc            |   2 +-
 cpp/src/arrow/flight/test_util.cc             |  26 +-
 cpp/src/arrow/flight/test_util.h              |   3 +-
 cpp/src/arrow/flight/types.cc                 |  11 +-
 cpp/src/arrow/flight/types.h                  |  10 +-
 dev/archery/archery/integration/runner.py     |   5 +
 format/Flight.proto                           |  22 +
 go/arrow/array/numericbuilder.gen.go          |  28 +-
 go/arrow/flight/gen.go                        |   2 +-
 go/arrow/flight/gen/flight/Flight.pb.go       | 328 +++++-----
 go/arrow/flight/gen/flight/FlightSql.pb.go    | 564 ++++++++++--------
 go/arrow/flight/gen/flight/Flight_grpc.pb.go  |  48 +-
 .../internal/flight_integration/scenario.go   |  64 +-
 18 files changed, 803 insertions(+), 450 deletions(-)

diff --git a/cpp/src/arrow/flight/flight_internals_test.cc b/cpp/src/arrow/flight/flight_internals_test.cc
index b32036a2c973f..5feb310fc14a2 100644
--- a/cpp/src/arrow/flight/flight_internals_test.cc
+++ b/cpp/src/arrow/flight/flight_internals_test.cc
@@ -191,33 +191,33 @@ TEST(FlightTypes, FlightEndpoint) {
   Timestamp expiration_time(
       std::chrono::duration_cast<Timestamp::duration>(expiration_time_duration));
   std::vector<FlightEndpoint> values = {
-      {{""}, {}, std::nullopt},
-      {{"foo"}, {}, std::nullopt},
-      {{"bar"}, {}, std::nullopt},
-      {{"foo"}, {}, expiration_time},
-      {{"foo"}, {location1}, std::nullopt},
-      {{"bar"}, {location1}, std::nullopt},
-      {{"foo"}, {location2}, std::nullopt},
-      {{"foo"}, {location1, location2}, std::nullopt},
+      {{""}, {}, std::nullopt, {}},
+      {{"foo"}, {}, std::nullopt, {}},
+      {{"bar"}, {}, std::nullopt, {"\xDE\xAD\xBE\xEF"}},
+      {{"foo"}, {}, expiration_time, {}},
+      {{"foo"}, {location1}, std::nullopt, {}},
+      {{"bar"}, {location1}, std::nullopt, {}},
+      {{"foo"}, {location2}, std::nullopt, {}},
+      {{"foo"}, {location1, location2}, std::nullopt, {"\xba\xdd\xca\xfe"}},
   };
   std::vector<std::string> reprs = {
       "<FlightEndpoint ticket=<Ticket ticket=''> locations=[] "
-      "expiration_time=null>",
+      "expiration_time=null app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='foo'> locations=[] "
-      "expiration_time=null>",
+      "expiration_time=null app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='bar'> locations=[] "
-      "expiration_time=null>",
+      "expiration_time=null app_metadata='DEADBEEF'>",
       "<FlightEndpoint ticket=<Ticket ticket='foo'> locations=[] "
-      "expiration_time=2023-06-19 03:14:06.004339000>",
+      "expiration_time=2023-06-19 03:14:06.004339000 app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='foo'> locations="
-      "[grpc+tcp://localhost:1024] expiration_time=null>",
+      "[grpc+tcp://localhost:1024] expiration_time=null app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='bar'> locations="
-      "[grpc+tcp://localhost:1024] expiration_time=null>",
+      "[grpc+tcp://localhost:1024] expiration_time=null app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='foo'> locations="
-      "[grpc+tls://localhost:1024] expiration_time=null>",
+      "[grpc+tls://localhost:1024] expiration_time=null app_metadata=''>",
       "<FlightEndpoint ticket=<Ticket ticket='foo'> locations="
       "[grpc+tcp://localhost:1024, grpc+tls://localhost:1024] "
-      "expiration_time=null>",
+      "expiration_time=null app_metadata='BADDCAFE'>",
   };
 
   ASSERT_NO_FATAL_FAILURE(TestRoundtrip<pb::FlightEndpoint>(values, reprs));
@@ -229,30 +229,35 @@ TEST(FlightTypes, FlightInfo) {
   Schema schema2({});
   auto desc1 = FlightDescriptor::Command("foo");
   auto desc2 = FlightDescriptor::Command("bar");
-  auto endpoint1 = FlightEndpoint{Ticket{"foo"}, {}, std::nullopt};
-  auto endpoint2 = FlightEndpoint{Ticket{"foo"}, {location}, std::nullopt};
+  auto endpoint1 = FlightEndpoint{Ticket{"foo"}, {}, std::nullopt, ""};
+  auto endpoint2 =
+      FlightEndpoint{Ticket{"foo"}, {location}, std::nullopt, "\xCA\xFE\xD0\x0D"};
   std::vector<FlightInfo> values = {
-      MakeFlightInfo(schema1, desc1, {}, -1, -1, false),
-      MakeFlightInfo(schema1, desc2, {}, -1, -1, true),
-      MakeFlightInfo(schema2, desc1, {}, -1, -1, false),
-      MakeFlightInfo(schema1, desc1, {endpoint1}, -1, 42, true),
-      MakeFlightInfo(schema1, desc2, {endpoint1, endpoint2}, 64, -1, false),
+      MakeFlightInfo(schema1, desc1, {}, -1, -1, false, ""),
+      MakeFlightInfo(schema1, desc2, {}, -1, -1, true, ""),
+      MakeFlightInfo(schema2, desc1, {}, -1, -1, false, ""),
+      MakeFlightInfo(schema1, desc1, {endpoint1}, -1, 42, true, ""),
+      MakeFlightInfo(schema1, desc2, {endpoint1, endpoint2}, 64, -1, false,
+                     "\xDE\xAD\xC0\xDE"),
   };
   std::vector<std::string> reprs = {
       "<FlightInfo schema=(serialized) descriptor=<FlightDescriptor cmd='foo'> "
-      "endpoints=[] total_records=-1 total_bytes=-1 ordered=false>",
+      "endpoints=[] total_records=-1 total_bytes=-1 ordered=false app_metadata=''>",
       "<FlightInfo schema=(serialized) descriptor=<FlightDescriptor cmd='bar'> "
-      "endpoints=[] total_records=-1 total_bytes=-1 ordered=true>",
+      "endpoints=[] total_records=-1 total_bytes=-1 ordered=true app_metadata=''>",
       "<FlightInfo schema=(serialized) descriptor=<FlightDescriptor cmd='foo'> "
-      "endpoints=[] total_records=-1 total_bytes=-1 ordered=false>",
+      "endpoints=[] total_records=-1 total_bytes=-1 ordered=false app_metadata=''>",
       "<FlightInfo schema=(serialized) descriptor=<FlightDescriptor cmd='foo'> "
       "endpoints=[<FlightEndpoint ticket=<Ticket ticket='foo'> locations=[] "
-      "expiration_time=null>] total_records=-1 total_bytes=42 ordered=true>",
+      "expiration_time=null app_metadata=''>] total_records=-1 total_bytes=42 "
+      "ordered=true app_metadata=''>",
       "<FlightInfo schema=(serialized) descriptor=<FlightDescriptor cmd='bar'> "
       "endpoints=[<FlightEndpoint ticket=<Ticket ticket='foo'> locations=[] "
-      "expiration_time=null>, <FlightEndpoint ticket=<Ticket ticket='foo'> "
-      "locations=[grpc+tcp://localhost:1234] expiration_time=null>] "
-      "total_records=64 total_bytes=-1 ordered=false>",
+      "expiration_time=null app_metadata=''>, <FlightEndpoint ticket=<Ticket "
+      "ticket='foo'> "
+      "locations=[grpc+tcp://localhost:1234] expiration_time=null "
+      "app_metadata='CAFED00D'>] "
+      "total_records=64 total_bytes=-1 ordered=false app_metadata='DEADC0DE'>",
   };
 
   ASSERT_NO_FATAL_FAILURE(TestRoundtrip<pb::FlightInfo>(values, reprs));
@@ -262,8 +267,8 @@ TEST(FlightTypes, PollInfo) {
   ASSERT_OK_AND_ASSIGN(auto location, Location::ForGrpcTcp("localhost", 1234));
   Schema schema({field("ints", int64())});
   auto desc = FlightDescriptor::Command("foo");
-  auto endpoint = FlightEndpoint{Ticket{"foo"}, {}, std::nullopt};
-  auto info = MakeFlightInfo(schema, desc, {endpoint}, -1, 42, true);
+  auto endpoint = FlightEndpoint{Ticket{"foo"}, {}, std::nullopt, ""};
+  auto info = MakeFlightInfo(schema, desc, {endpoint}, -1, 42, true, "");
   // 2023-06-19 03:14:06.004330100
   // We must use microsecond resolution here for portability.
   // std::chrono::system_clock::time_point may not provide nanosecond
diff --git a/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc b/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
index 4a49dea31b99d..67c7ee85f59d3 100644
--- a/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
+++ b/cpp/src/arrow/flight/integration_tests/flight_integration_test.cc
@@ -73,6 +73,10 @@ TEST(FlightIntegration, ExpirationTimeRenewFlightEndpoint) {
 
 TEST(FlightIntegration, PollFlightInfo) { ASSERT_OK(RunScenario("poll_flight_info")); }
 
+TEST(FlightIntegration, AppMetadataFlightInfoEndpoint) {
+  ASSERT_OK(RunScenario("app_metadata_flight_info_endpoint"));
+}
+
 TEST(FlightIntegration, FlightSql) { ASSERT_OK(RunScenario("flight_sql")); }
 
 TEST(FlightIntegration, FlightSqlExtension) {
diff --git a/cpp/src/arrow/flight/integration_tests/test_integration.cc b/cpp/src/arrow/flight/integration_tests/test_integration.cc
index 03e352ffa6770..31bffd7704474 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration.cc
@@ -815,6 +815,64 @@ class PollFlightInfoScenario : public Scenario {
   }
 };
 
+/// \brief The server used for testing app_metadata in FlightInfo and FlightEndpoint
+class AppMetadataFlightInfoEndpointServer : public FlightServerBase {
+ public:
+  AppMetadataFlightInfoEndpointServer() : FlightServerBase() {}
+
+  Status GetFlightInfo(const ServerCallContext& context, const FlightDescriptor& request,
+                       std::unique_ptr<FlightInfo>* info) override {
+    if (request.type != FlightDescriptor::CMD) {
+      return Status::Invalid("request descriptor should be of type CMD");
+    }
+
+    auto schema = arrow::schema({arrow::field("number", arrow::uint32(), false)});
+    std::vector<FlightEndpoint> endpoints = {
+        FlightEndpoint{{}, {}, std::nullopt, request.cmd}};
+    ARROW_ASSIGN_OR_RAISE(auto result, FlightInfo::Make(*schema, request, endpoints, -1,
+                                                        -1, false, request.cmd));
+    *info = std::make_unique<FlightInfo>(std::move(result));
+    return Status::OK();
+  }
+};
+
+/// \brief The AppMetadataFlightInfoEndpoint scenario.
+///
+/// This tests that the client can receive and use the `app_metadata` field in
+/// the FlightInfo and FlightEndpoint messages.
+///
+/// The server only implements GetFlightInfo and will return a FlightInfo with a non-
+/// empty app_metadata value that should match the app_metadata field in the
+/// included FlightEndpoint. The value should be the same as the cmd bytes passed
+/// in the call to GetFlightInfo by the client.
+class AppMetadataFlightInfoEndpointScenario : public Scenario {
+  Status MakeServer(std::unique_ptr<FlightServerBase>* server,
+                    FlightServerOptions* options) override {
+    *server = std::make_unique<AppMetadataFlightInfoEndpointServer>();
+    return Status::OK();
+  }
+
+  Status MakeClient(FlightClientOptions* options) override { return Status::OK(); }
+
+  Status RunClient(std::unique_ptr<FlightClient> client) override {
+    ARROW_ASSIGN_OR_RAISE(auto info,
+                          client->GetFlightInfo(FlightDescriptor::Command("foobar")));
+    if (info->app_metadata() != "foobar") {
+      return Status::Invalid("app_metadata should have been 'foobar', got: ",
+                             info->app_metadata());
+    }
+    if (info->endpoints().size() != 1) {
+      return Status::Invalid("should have gotten exactly one FlightEndpoint back, got: ",
+                             info->endpoints().size());
+    }
+    if (info->endpoints()[0].app_metadata != "foobar") {
+      return Status::Invalid("FlightEndpoint app_metadata should be 'foobar', got: ",
+                             info->endpoints()[0].app_metadata);
+    }
+    return Status::OK();
+  }
+};
+
 /// \brief Schema to be returned for mocking the statement/prepared statement results.
 ///
 /// Must be the same across all languages.
@@ -1897,6 +1955,9 @@ Status GetScenario(const std::string& scenario_name, std::shared_ptr<Scenario>*
   } else if (scenario_name == "poll_flight_info") {
     *out = std::make_shared<PollFlightInfoScenario>();
     return Status::OK();
+  } else if (scenario_name == "app_metadata_flight_info_endpoint") {
+    *out = std::make_shared<AppMetadataFlightInfoEndpointScenario>();
+    return Status::OK();
   } else if (scenario_name == "flight_sql") {
     *out = std::make_shared<FlightSqlScenario>();
     return Status::OK();
diff --git a/cpp/src/arrow/flight/perf_server.cc b/cpp/src/arrow/flight/perf_server.cc
index a768840c0295d..40f6cbcbf0d82 100644
--- a/cpp/src/arrow/flight/perf_server.cc
+++ b/cpp/src/arrow/flight/perf_server.cc
@@ -196,7 +196,7 @@ class FlightPerfServer : public FlightServerBase {
         perf_request.stream_count() * perf_request.records_per_stream();
 
     *info = std::make_unique<FlightInfo>(
-        MakeFlightInfo(*perf_schema_, request, endpoints, total_records, -1, false));
+        MakeFlightInfo(*perf_schema_, request, endpoints, total_records, -1, false, ""));
     return Status::OK();
   }
 
diff --git a/cpp/src/arrow/flight/serialization_internal.cc b/cpp/src/arrow/flight/serialization_internal.cc
index f85b451dccec3..64a40564afd72 100644
--- a/cpp/src/arrow/flight/serialization_internal.cc
+++ b/cpp/src/arrow/flight/serialization_internal.cc
@@ -177,6 +177,7 @@ Status FromProto(const pb::FlightEndpoint& pb_endpoint, FlightEndpoint* endpoint
     RETURN_NOT_OK(FromProto(pb_endpoint.expiration_time(), &expiration_time));
     endpoint->expiration_time = std::move(expiration_time);
   }
+  endpoint->app_metadata = pb_endpoint.app_metadata();
   return Status::OK();
 }
 
@@ -190,6 +191,7 @@ Status ToProto(const FlightEndpoint& endpoint, pb::FlightEndpoint* pb_endpoint)
     RETURN_NOT_OK(ToProto(endpoint.expiration_time.value(),
                           pb_endpoint->mutable_expiration_time()));
   }
+  pb_endpoint->set_app_metadata(endpoint.app_metadata);
   return Status::OK();
 }
 
@@ -255,6 +257,7 @@ arrow::Result<FlightInfo> FromProto(const pb::FlightInfo& pb_info) {
   info.total_records = pb_info.total_records();
   info.total_bytes = pb_info.total_bytes();
   info.ordered = pb_info.ordered();
+  info.app_metadata = pb_info.app_metadata();
   return FlightInfo(std::move(info));
 }
 
@@ -296,6 +299,7 @@ Status ToProto(const FlightInfo& info, pb::FlightInfo* pb_info) {
   pb_info->set_total_records(info.total_records());
   pb_info->set_total_bytes(info.total_bytes());
   pb_info->set_ordered(info.ordered());
+  pb_info->set_app_metadata(info.app_metadata());
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/flight/sql/server.cc b/cpp/src/arrow/flight/sql/server.cc
index 7a1c394fb413b..a6d197d15b2c0 100644
--- a/cpp/src/arrow/flight/sql/server.cc
+++ b/cpp/src/arrow/flight/sql/server.cc
@@ -930,7 +930,7 @@ arrow::Result<std::unique_ptr<FlightInfo>> FlightSqlServerBase::GetFlightInfoSql
   }
 
   std::vector<FlightEndpoint> endpoints{
-      FlightEndpoint{{descriptor.cmd}, {}, std::nullopt}};
+      FlightEndpoint{{descriptor.cmd}, {}, std::nullopt, {}}};
   ARROW_ASSIGN_OR_RAISE(
       auto result, FlightInfo::Make(*SqlSchema::GetSqlInfoSchema(), descriptor, endpoints,
                                     -1, -1, false))
diff --git a/cpp/src/arrow/flight/test_util.cc b/cpp/src/arrow/flight/test_util.cc
index fed2b59abf56d..bf2f4c2b4effc 100644
--- a/cpp/src/arrow/flight/test_util.cc
+++ b/cpp/src/arrow/flight/test_util.cc
@@ -531,9 +531,11 @@ std::unique_ptr<FlightServerBase> ExampleTestServer() {
 
 FlightInfo MakeFlightInfo(const Schema& schema, const FlightDescriptor& descriptor,
                           const std::vector<FlightEndpoint>& endpoints,
-                          int64_t total_records, int64_t total_bytes, bool ordered) {
-  EXPECT_OK_AND_ASSIGN(auto info, FlightInfo::Make(schema, descriptor, endpoints,
-                                                   total_records, total_bytes, ordered));
+                          int64_t total_records, int64_t total_bytes, bool ordered,
+                          std::string app_metadata) {
+  EXPECT_OK_AND_ASSIGN(auto info,
+                       FlightInfo::Make(schema, descriptor, endpoints, total_records,
+                                        total_bytes, ordered, std::move(app_metadata)));
   return info;
 }
 
@@ -602,11 +604,11 @@ std::vector<FlightInfo> ExampleFlightInfo() {
   Location location4 = *Location::ForGrpcTcp("foo4.bar.com", 12345);
   Location location5 = *Location::ForGrpcTcp("foo5.bar.com", 12345);
 
-  FlightEndpoint endpoint1({{"ticket-ints-1"}, {location1}, std::nullopt});
-  FlightEndpoint endpoint2({{"ticket-ints-2"}, {location2}, std::nullopt});
-  FlightEndpoint endpoint3({{"ticket-cmd"}, {location3}, std::nullopt});
-  FlightEndpoint endpoint4({{"ticket-dicts-1"}, {location4}, std::nullopt});
-  FlightEndpoint endpoint5({{"ticket-floats-1"}, {location5}, std::nullopt});
+  FlightEndpoint endpoint1({{"ticket-ints-1"}, {location1}, std::nullopt, {}});
+  FlightEndpoint endpoint2({{"ticket-ints-2"}, {location2}, std::nullopt, {}});
+  FlightEndpoint endpoint3({{"ticket-cmd"}, {location3}, std::nullopt, {}});
+  FlightEndpoint endpoint4({{"ticket-dicts-1"}, {location4}, std::nullopt, {}});
+  FlightEndpoint endpoint5({{"ticket-floats-1"}, {location5}, std::nullopt, {}});
 
   FlightDescriptor descr1{FlightDescriptor::PATH, "", {"examples", "ints"}};
   FlightDescriptor descr2{FlightDescriptor::CMD, "my_command", {}};
@@ -619,10 +621,10 @@ std::vector<FlightInfo> ExampleFlightInfo() {
   auto schema4 = ExampleFloatSchema();
 
   return {
-      MakeFlightInfo(*schema1, descr1, {endpoint1, endpoint2}, 1000, 100000, false),
-      MakeFlightInfo(*schema2, descr2, {endpoint3}, 1000, 100000, false),
-      MakeFlightInfo(*schema3, descr3, {endpoint4}, -1, -1, false),
-      MakeFlightInfo(*schema4, descr4, {endpoint5}, 1000, 100000, false),
+      MakeFlightInfo(*schema1, descr1, {endpoint1, endpoint2}, 1000, 100000, false, ""),
+      MakeFlightInfo(*schema2, descr2, {endpoint3}, 1000, 100000, false, ""),
+      MakeFlightInfo(*schema3, descr3, {endpoint4}, -1, -1, false, ""),
+      MakeFlightInfo(*schema4, descr4, {endpoint5}, 1000, 100000, false, ""),
   };
 }
 
diff --git a/cpp/src/arrow/flight/test_util.h b/cpp/src/arrow/flight/test_util.h
index f299d358c539e..c0b42d9b90c5a 100644
--- a/cpp/src/arrow/flight/test_util.h
+++ b/cpp/src/arrow/flight/test_util.h
@@ -192,7 +192,8 @@ std::vector<ActionType> ExampleActionTypes();
 ARROW_FLIGHT_EXPORT
 FlightInfo MakeFlightInfo(const Schema& schema, const FlightDescriptor& descriptor,
                           const std::vector<FlightEndpoint>& endpoints,
-                          int64_t total_records, int64_t total_bytes, bool ordered);
+                          int64_t total_records, int64_t total_bytes, bool ordered,
+                          std::string app_metadata);
 
 // ----------------------------------------------------------------------
 // A pair of authentication handlers that check for a predefined password
diff --git a/cpp/src/arrow/flight/types.cc b/cpp/src/arrow/flight/types.cc
index a24a9ef8758ab..9da83fa8a11f2 100644
--- a/cpp/src/arrow/flight/types.cc
+++ b/cpp/src/arrow/flight/types.cc
@@ -260,13 +260,14 @@ arrow::Result<FlightInfo> FlightInfo::Make(const Schema& schema,
                                            const FlightDescriptor& descriptor,
                                            const std::vector<FlightEndpoint>& endpoints,
                                            int64_t total_records, int64_t total_bytes,
-                                           bool ordered) {
+                                           bool ordered, std::string app_metadata) {
   FlightInfo::Data data;
   data.descriptor = descriptor;
   data.endpoints = endpoints;
   data.total_records = total_records;
   data.total_bytes = total_bytes;
   data.ordered = ordered;
+  data.app_metadata = std::move(app_metadata);
   RETURN_NOT_OK(internal::SchemaToString(schema, &data.schema));
   return FlightInfo(data);
 }
@@ -328,6 +329,7 @@ std::string FlightInfo::ToString() const {
   ss << "] total_records=" << data_.total_records;
   ss << " total_bytes=" << data_.total_bytes;
   ss << " ordered=" << (data_.ordered ? "true" : "false");
+  ss << " app_metadata='" << HexEncode(data_.app_metadata) << "'";
   ss << '>';
   return ss.str();
 }
@@ -338,7 +340,8 @@ bool FlightInfo::Equals(const FlightInfo& other) const {
          data_.endpoints == other.data_.endpoints &&
          data_.total_records == other.data_.total_records &&
          data_.total_bytes == other.data_.total_bytes &&
-         data_.ordered == other.data_.ordered;
+         data_.ordered == other.data_.ordered &&
+         data_.app_metadata == other.data_.app_metadata;
 }
 
 arrow::Result<std::string> PollInfo::SerializeToString() const {
@@ -535,6 +538,7 @@ std::string FlightEndpoint::ToString() const {
   } else {
     ss << "null";
   }
+  ss << " app_metadata='" << HexEncode(app_metadata) << "'";
   ss << ">";
   return ss.str();
 }
@@ -554,6 +558,9 @@ bool FlightEndpoint::Equals(const FlightEndpoint& other) const {
       return false;
     }
   }
+  if (app_metadata != other.app_metadata) {
+    return false;
+  }
   return true;
 }
 
diff --git a/cpp/src/arrow/flight/types.h b/cpp/src/arrow/flight/types.h
index 70e7c90676b73..40a0787d14a7a 100644
--- a/cpp/src/arrow/flight/types.h
+++ b/cpp/src/arrow/flight/types.h
@@ -481,6 +481,9 @@ struct ARROW_FLIGHT_EXPORT FlightEndpoint {
   /// retrying DoGet requests.
   std::optional<Timestamp> expiration_time;
 
+  /// Opaque Application-defined metadata
+  std::string app_metadata;
+
   std::string ToString() const;
   bool Equals(const FlightEndpoint& other) const;
 
@@ -583,6 +586,7 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
     int64_t total_records = -1;
     int64_t total_bytes = -1;
     bool ordered = false;
+    std::string app_metadata;
   };
 
   explicit FlightInfo(Data data) : data_(std::move(data)), reconstructed_schema_(false) {}
@@ -592,7 +596,8 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
                                         const FlightDescriptor& descriptor,
                                         const std::vector<FlightEndpoint>& endpoints,
                                         int64_t total_records, int64_t total_bytes,
-                                        bool ordered = false);
+                                        bool ordered = false,
+                                        std::string app_metadata = "");
 
   /// \brief Deserialize the Arrow schema of the dataset. Populate any
   ///   dictionary encoded fields into a DictionaryMemo for
@@ -621,6 +626,9 @@ class ARROW_FLIGHT_EXPORT FlightInfo {
   /// Whether endpoints are in the same order as the data.
   bool ordered() const { return data_.ordered; }
 
+  /// Application-defined opaque metadata
+  const std::string& app_metadata() const { return data_.app_metadata; }
+
   /// \brief Get the wire-format representation of this type.
   ///
   /// Useful when interoperating with non-Flight systems (e.g. REST
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index 67f0693df14aa..eb2e26951cd88 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -611,6 +611,11 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
             description="Ensure PollFlightInfo is supported.",
             skip_testers={"JS", "C#", "Rust"}
         ),
+        Scenario(
+            "app_metadata_flight_info_endpoint",
+            description="Ensure support FlightInfo and Endpoint app_metadata",
+            skip_testers={"JS", "C#", "Rust", "Java"}
+        ),
         Scenario(
             "flight_sql",
             description="Ensure Flight SQL protocol is working as expected.",
diff --git a/format/Flight.proto b/format/Flight.proto
index baf2733d81048..de3794f05ba83 100644
--- a/format/Flight.proto
+++ b/format/Flight.proto
@@ -366,6 +366,17 @@ message FlightInfo {
    * 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;
 }
 
 /*
@@ -446,6 +457,17 @@ message FlightEndpoint {
    * 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;
 }
 
 /*
diff --git a/go/arrow/array/numericbuilder.gen.go b/go/arrow/array/numericbuilder.gen.go
index d3648f0b1fbc4..7f01180f55957 100644
--- a/go/arrow/array/numericbuilder.gen.go
+++ b/go/arrow/array/numericbuilder.gen.go
@@ -86,7 +86,7 @@ func (b *Int64Builder) AppendEmptyValue() {
 }
 
 func (b *Int64Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -564,7 +564,7 @@ func (b *Float64Builder) AppendEmptyValue() {
 }
 
 func (b *Float64Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -803,7 +803,7 @@ func (b *Int32Builder) AppendEmptyValue() {
 }
 
 func (b *Int32Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -1042,7 +1042,7 @@ func (b *Uint32Builder) AppendEmptyValue() {
 }
 
 func (b *Uint32Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -1281,7 +1281,7 @@ func (b *Float32Builder) AppendEmptyValue() {
 }
 
 func (b *Float32Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -1520,7 +1520,7 @@ func (b *Int16Builder) AppendEmptyValue() {
 }
 
 func (b *Int16Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -1759,7 +1759,7 @@ func (b *Uint16Builder) AppendEmptyValue() {
 }
 
 func (b *Uint16Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -1998,7 +1998,7 @@ func (b *Int8Builder) AppendEmptyValue() {
 }
 
 func (b *Int8Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -2237,7 +2237,7 @@ func (b *Uint8Builder) AppendEmptyValue() {
 }
 
 func (b *Uint8Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -2477,7 +2477,7 @@ func (b *Time32Builder) AppendEmptyValue() {
 }
 
 func (b *Time32Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -2717,7 +2717,7 @@ func (b *Time64Builder) AppendEmptyValue() {
 }
 
 func (b *Time64Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -2956,7 +2956,7 @@ func (b *Date32Builder) AppendEmptyValue() {
 }
 
 func (b *Date32Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -3195,7 +3195,7 @@ func (b *Date64Builder) AppendEmptyValue() {
 }
 
 func (b *Date64Builder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
@@ -3435,7 +3435,7 @@ func (b *DurationBuilder) AppendEmptyValue() {
 }
 
 func (b *DurationBuilder) AppendEmptyValues(n int) {
-	for i := 0; i < n; i ++ {
+	for i := 0; i < n; i++ {
 		b.AppendEmptyValue()
 	}
 }
diff --git a/go/arrow/flight/gen.go b/go/arrow/flight/gen.go
index cfdd0e036703a..29ae54b38f427 100644
--- a/go/arrow/flight/gen.go
+++ b/go/arrow/flight/gen.go
@@ -16,5 +16,5 @@
 
 package flight
 
-//go:generate protoc -I../../../format --go_out=./gen/flight --go-grpc_out=./gen/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative Flight.proto
+//go:generate protoc --experimental_allow_proto3_optional -I../../../format --go_out=./gen/flight --go-grpc_out=./gen/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative Flight.proto
 //go:generate protoc --experimental_allow_proto3_optional -I../../../format --go_out=./gen/flight --go-grpc_out=./gen/flight --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative FlightSql.proto
diff --git a/go/arrow/flight/gen/flight/Flight.pb.go b/go/arrow/flight/gen/flight/Flight.pb.go
index 861b37d90d088..0438bca28be50 100644
--- a/go/arrow/flight/gen/flight/Flight.pb.go
+++ b/go/arrow/flight/gen/flight/Flight.pb.go
@@ -18,7 +18,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.21.12
+// 	protoc        v4.23.4
 // source: Flight.proto
 
 package flight
@@ -38,6 +38,7 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+//
 // The result of a cancel operation.
 //
 // This is used by CancelFlightInfoResult.status.
@@ -102,17 +103,19 @@ func (CancelStatus) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{0}
 }
 
+//
 // Describes what type of descriptor is defined.
 type FlightDescriptor_DescriptorType int32
 
 const (
 	// Protobuf pattern, not used.
 	FlightDescriptor_UNKNOWN FlightDescriptor_DescriptorType = 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.
+	//  similar to a path inside a filesystem.
 	FlightDescriptor_PATH FlightDescriptor_DescriptorType = 1
+	//
 	// An opaque command to generate a dataset.
 	FlightDescriptor_CMD FlightDescriptor_DescriptorType = 2
 )
@@ -158,14 +161,17 @@ func (FlightDescriptor_DescriptorType) EnumDescriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{12, 0}
 }
 
+//
 // The request that a client provides to a server on handshake.
 type HandshakeRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
+	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -221,8 +227,10 @@ type HandshakeResponse struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// A defined protocol version
 	ProtocolVersion uint64 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
+	//
 	// Arbitrary auth/handshake info.
 	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"`
 }
@@ -273,6 +281,7 @@ func (x *HandshakeResponse) GetPayload() []byte {
 	return nil
 }
 
+//
 // A message for doing simple auth.
 type BasicAuth struct {
 	state         protoimpl.MessageState
@@ -367,6 +376,7 @@ func (*Empty) Descriptor() ([]byte, []int) {
 	return file_Flight_proto_rawDescGZIP(), []int{3}
 }
 
+//
 // Describes an available action, including both the name used for execution
 // along with a short description of the purpose of the action.
 type ActionType struct {
@@ -424,6 +434,7 @@ func (x *ActionType) GetDescription() string {
 	return ""
 }
 
+//
 // A service specific expression that can be used to return a limited set
 // of available Arrow Flight streams.
 type Criteria struct {
@@ -473,6 +484,7 @@ func (x *Criteria) GetExpression() []byte {
 	return nil
 }
 
+//
 // An opaque action specific for the service.
 type Action struct {
 	state         protoimpl.MessageState
@@ -529,6 +541,7 @@ func (x *Action) GetBody() []byte {
 	return nil
 }
 
+//
 // The request of the CancelFlightInfo action.
 //
 // The request should be stored in Action.body.
@@ -579,6 +592,7 @@ func (x *CancelFlightInfoRequest) GetInfo() *FlightInfo {
 	return nil
 }
 
+//
 // The request of the RenewFlightEndpoint action.
 //
 // The request should be stored in Action.body.
@@ -629,6 +643,7 @@ func (x *RenewFlightEndpointRequest) GetEndpoint() *FlightEndpoint {
 	return nil
 }
 
+//
 // An opaque result returned after executing an action.
 type Result struct {
 	state         protoimpl.MessageState
@@ -677,6 +692,7 @@ func (x *Result) GetBody() []byte {
 	return nil
 }
 
+//
 // The result of the CancelFlightInfo action.
 //
 // The result should be stored in Result.body.
@@ -727,6 +743,7 @@ func (x *CancelFlightInfoResult) GetStatus() CancelStatus {
 	return CancelStatus_CANCEL_STATUS_UNSPECIFIED
 }
 
+//
 // Wrap the result of a getSchema call
 type SchemaResult struct {
 	state         protoimpl.MessageState
@@ -734,10 +751,9 @@ type SchemaResult struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
+	//   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//   4 bytes - the byte length of the payload
+	//   a flatbuffer Message whose header is the Schema
 	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
 }
 
@@ -780,6 +796,7 @@ func (x *SchemaResult) GetSchema() []byte {
 	return nil
 }
 
+//
 // 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.
 type FlightDescriptor struct {
@@ -788,9 +805,11 @@ type FlightDescriptor struct {
 	unknownFields protoimpl.UnknownFields
 
 	Type FlightDescriptor_DescriptorType `protobuf:"varint,1,opt,name=type,proto3,enum=arrow.flight.protocol.FlightDescriptor_DescriptorType" json:"type,omitempty"`
+	//
 	// Opaque value used to express a command. Should only be defined when
 	// type = CMD.
 	Cmd []byte `protobuf:"bytes,2,opt,name=cmd,proto3" json:"cmd,omitempty"`
+	//
 	// List of strings identifying a particular dataset. Should only be defined
 	// when type = PATH.
 	Path []string `protobuf:"bytes,3,rep,name=path,proto3" json:"path,omitempty"`
@@ -849,6 +868,7 @@ func (x *FlightDescriptor) GetPath() []string {
 	return nil
 }
 
+//
 // The access coordinates for retrieval of a dataset. With a FlightInfo, a
 // consumer is able to determine how to retrieve a dataset.
 type FlightInfo struct {
@@ -857,13 +877,14 @@ type FlightInfo struct {
 	unknownFields protoimpl.UnknownFields
 
 	// 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
+	//   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+	//   4 bytes - the byte length of the payload
+	//   a flatbuffer Message whose header is the Schema
 	Schema []byte `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
+	//
 	// The descriptor associated with this info.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,2,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	//
 	// 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.
@@ -883,15 +904,19 @@ type FlightInfo struct {
 	// 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.
+	// * An application requires that all clients must read data in
+	//   returned endpoints order.
+	// * An application must return the all data in a single endpoint.
 	Endpoint []*FlightEndpoint `protobuf:"bytes,3,rep,name=endpoint,proto3" json:"endpoint,omitempty"`
 	// Set these to -1 if unknown.
 	TotalRecords int64 `protobuf:"varint,4,opt,name=total_records,json=totalRecords,proto3" json:"total_records,omitempty"`
 	TotalBytes   int64 `protobuf:"varint,5,opt,name=total_bytes,json=totalBytes,proto3" json:"total_bytes,omitempty"`
+	//
 	// FlightEndpoints are in the same order as the data.
 	Ordered bool `protobuf:"varint,6,opt,name=ordered,proto3" json:"ordered,omitempty"`
+	//
+	// Application-defined metadata.
+	AppMetadata []byte `protobuf:"bytes,7,opt,name=app_metadata,json=appMetadata,proto3" json:"app_metadata,omitempty"`
 }
 
 func (x *FlightInfo) Reset() {
@@ -968,12 +993,21 @@ func (x *FlightInfo) GetOrdered() bool {
 	return false
 }
 
+func (x *FlightInfo) GetAppMetadata() []byte {
+	if x != nil {
+		return x.AppMetadata
+	}
+	return nil
+}
+
+//
 // The information to process a long-running query.
 type PollInfo struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// The currently available results.
 	//
 	// If "flight_descriptor" is not specified, the query is complete
@@ -991,12 +1025,15 @@ type PollInfo struct {
 	// ticket in the info before the query is
 	// completed. FlightInfo.ordered is also valid.
 	Info *FlightInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"`
+	//
 	// The descriptor the client should use on the next try.
 	// If unset, the query is complete.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,2,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	//
 	// Query progress. If known, must be in [0.0, 1.0] but need not be
 	// monotonic or nondecreasing. If unknown, do not set.
 	Progress *float64 `protobuf:"fixed64,3,opt,name=progress,proto3,oneof" json:"progress,omitempty"`
+	//
 	// 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.
@@ -1063,14 +1100,17 @@ func (x *PollInfo) GetExpirationTime() *timestamppb.Timestamp {
 	return nil
 }
 
+//
 // A particular stream or split associated with a flight.
 type FlightEndpoint struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// Token used to retrieve this stream.
 	Ticket *Ticket `protobuf:"bytes,1,opt,name=ticket,proto3" json:"ticket,omitempty"`
+	//
 	// 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
@@ -1086,10 +1126,14 @@ type FlightEndpoint struct {
 	// In other words, an application can use multiple locations to
 	// represent redundant and/or load balanced services.
 	Location []*Location `protobuf:"bytes,2,rep,name=location,proto3" json:"location,omitempty"`
+	//
 	// 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.
 	ExpirationTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=expiration_time,json=expirationTime,proto3" json:"expiration_time,omitempty"`
+	//
+	// Application-defined metadata.
+	AppMetadata []byte `protobuf:"bytes,4,opt,name=app_metadata,json=appMetadata,proto3" json:"app_metadata,omitempty"`
 }
 
 func (x *FlightEndpoint) Reset() {
@@ -1145,6 +1189,14 @@ func (x *FlightEndpoint) GetExpirationTime() *timestamppb.Timestamp {
 	return nil
 }
 
+func (x *FlightEndpoint) GetAppMetadata() []byte {
+	if x != nil {
+		return x.AppMetadata
+	}
+	return nil
+}
+
+//
 // A location where a Flight service will accept retrieval of a particular
 // stream given a ticket.
 type Location struct {
@@ -1194,6 +1246,7 @@ func (x *Location) GetUri() string {
 	return ""
 }
 
+//
 // An opaque identifier that the service can use to retrieve a particular
 // portion of a stream.
 //
@@ -1246,19 +1299,24 @@ func (x *Ticket) GetTicket() []byte {
 	return nil
 }
 
+//
 // A batch of Arrow data as part of a stream of batches.
 type FlightData struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// The descriptor of the data. This is only relevant when a client is
 	// starting a new DoPut stream.
 	FlightDescriptor *FlightDescriptor `protobuf:"bytes,1,opt,name=flight_descriptor,json=flightDescriptor,proto3" json:"flight_descriptor,omitempty"`
+	//
 	// Header for message data as described in Message.fbs::Message.
 	DataHeader []byte `protobuf:"bytes,2,opt,name=data_header,json=dataHeader,proto3" json:"data_header,omitempty"`
+	//
 	// Application-defined metadata.
 	AppMetadata []byte `protobuf:"bytes,3,opt,name=app_metadata,json=appMetadata,proto3" json:"app_metadata,omitempty"`
+	//
 	// 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
@@ -1326,7 +1384,7 @@ func (x *FlightData) GetDataBody() []byte {
 	return nil
 }
 
-// *
+//*
 // The response message associated with the submission of a DoPut.
 type PutResult struct {
 	state         protoimpl.MessageState
@@ -1441,7 +1499,7 @@ var file_Flight_proto_rawDesc = []byte{
 	0x22, 0x30, 0x0a, 0x0e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x79,
 	0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12,
 	0x08, 0x0a, 0x04, 0x50, 0x41, 0x54, 0x48, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x43, 0x4d, 0x44,
-	0x10, 0x02, 0x22, 0x9d, 0x02, 0x0a, 0x0a, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66,
+	0x10, 0x02, 0x22, 0xc0, 0x02, 0x0a, 0x0a, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66,
 	0x6f, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28,
 	0x0c, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c, 0x69,
 	0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02,
@@ -1459,129 +1517,133 @@ var file_Flight_proto_rawDesc = []byte{
 	0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x74, 0x6f,
 	0x74, 0x61, 0x6c, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x72, 0x64, 0x65,
 	0x72, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72,
-	0x65, 0x64, 0x22, 0x8a, 0x02, 0x0a, 0x08, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12,
-	0x35, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e,
-	0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
-	0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x66, 0x6c, 0x69, 0x67,
-	0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x08,
-	0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00,
-	0x52, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x88, 0x01, 0x01, 0x12, 0x43, 0x0a,
-	0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
-	0x6d, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69,
-	0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22,
-	0xc9, 0x01, 0x0a, 0x0e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69,
-	0x6e, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65,
-	0x74, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x3b, 0x0a, 0x08, 0x6c, 0x6f, 0x63,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x72,
+	0x65, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61,
+	0x74, 0x61, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0x22, 0x8a, 0x02, 0x0a, 0x08, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e,
+	0x66, 0x6f, 0x12, 0x35, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49,
+	0x6e, 0x66, 0x6f, 0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x66,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12,
+	0x1f, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x01, 0x48, 0x00, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x88, 0x01, 0x01,
+	0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74,
+	0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
+	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x54, 0x69, 0x6d, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65,
+	0x73, 0x73, 0x22, 0xec, 0x01, 0x0a, 0x0e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x45, 0x6e, 0x64,
+	0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x35, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69,
+	0x63, 0x6b, 0x65, 0x74, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x3b, 0x0a, 0x08,
+	0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f,
+	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
+	0x08, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78, 0x70,
+	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0e,
+	0x65, 0x78, 0x70, 0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x21,
+	0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
+	0x61, 0x22, 0x1c, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a,
+	0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x22,
+	0x20, 0x0a, 0x06, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x69, 0x63,
+	0x6b, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65,
+	0x74, 0x22, 0xc4, 0x01, 0x0a, 0x0a, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61,
+	0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72,
 	0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x63, 0x6f, 0x6c, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x6c, 0x6f,
-	0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x43, 0x0a, 0x0f, 0x65, 0x78, 0x70, 0x69, 0x72, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0e, 0x65, 0x78, 0x70,
-	0x69, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x1c, 0x0a, 0x08, 0x4c,
-	0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x22, 0x20, 0x0a, 0x06, 0x54, 0x69, 0x63,
-	0x6b, 0x65, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x06, 0x74, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x22, 0xc4, 0x01, 0x0a, 0x0a,
-	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x54, 0x0a, 0x11, 0x66, 0x6c,
-	0x69, 0x67, 0x68, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c,
-	0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c,
-	0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x10,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72,
-	0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x48, 0x65, 0x61, 0x64, 0x65,
-	0x72, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74,
-	0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74, 0x61,
-	0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x62, 0x6f, 0x64,
-	0x79, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61, 0x42, 0x6f,
-	0x64, 0x79, 0x22, 0x2e, 0x0a, 0x09, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12,
-	0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61,
-	0x74, 0x61, 0x2a, 0x8b, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x53, 0x74, 0x61,
-	0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54,
-	0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44,
-	0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41,
-	0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x45, 0x44, 0x10, 0x01, 0x12,
-	0x1c, 0x0a, 0x18, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53,
-	0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x21, 0x0a,
-	0x1d, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x4e,
-	0x4f, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x03,
-	0x32, 0x85, 0x07, 0x0a, 0x0d, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69,
-	0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12,
+	0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69,
+	0x70, 0x74, 0x6f, 0x72, 0x52, 0x10, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63,
+	0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x68,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x64, 0x61, 0x74,
+	0x61, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d,
+	0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61,
+	0x70, 0x70, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x61,
+	0x74, 0x61, 0x5f, 0x62, 0x6f, 0x64, 0x79, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08,
+	0x64, 0x61, 0x74, 0x61, 0x42, 0x6f, 0x64, 0x79, 0x22, 0x2e, 0x0a, 0x09, 0x50, 0x75, 0x74, 0x52,
+	0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x70, 0x70, 0x5f, 0x6d, 0x65, 0x74,
+	0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x70, 0x70,
+	0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2a, 0x8b, 0x01, 0x0a, 0x0c, 0x43, 0x61, 0x6e,
+	0x63, 0x65, 0x6c, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x19, 0x43, 0x41, 0x4e,
+	0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45,
+	0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x1b, 0x0a, 0x17, 0x43, 0x41, 0x4e, 0x43,
+	0x45, 0x4c, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c,
+	0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x1c, 0x0a, 0x18, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f,
+	0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c, 0x49, 0x4e,
+	0x47, 0x10, 0x02, 0x12, 0x21, 0x0a, 0x1d, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x5f, 0x53, 0x54,
+	0x41, 0x54, 0x55, 0x53, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x4c,
+	0x41, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x32, 0x85, 0x07, 0x0a, 0x0d, 0x46, 0x6c, 0x69, 0x67, 0x68,
+	0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64,
+	0x73, 0x68, 0x61, 0x6b, 0x65, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61,
+	0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28,
+	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x55,
+	0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x1f, 0x2e,
+	0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x43, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x1a, 0x21,
+	0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66,
+	0x6f, 0x22, 0x00, 0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a,
+	0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e,
+	0x66, 0x6f, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0e, 0x50, 0x6f, 0x6c, 0x6c, 0x46, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46,
+	0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a,
+	0x1f, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f,
+	0x22, 0x00, 0x12, 0x5b, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12,
 	0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b,
-	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65,
+	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x23, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
 	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
-	0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x55, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74,
-	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x12, 0x1f, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
-	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
-	0x43, 0x72, 0x69, 0x74, 0x65, 0x72, 0x69, 0x61, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x12,
+	0x4d, 0x0a, 0x05, 0x44, 0x6f, 0x47, 0x65, 0x74, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
 	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
-	0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x30, 0x01, 0x12,
-	0x5d, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
-	0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f,
-	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
-	0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x12, 0x5c,
-	0x0a, 0x0e, 0x50, 0x6f, 0x6c, 0x6c, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x49, 0x6e, 0x66, 0x6f,
-	0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
+	0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65, 0x74, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
+	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52,
+	0x0a, 0x05, 0x44, 0x6f, 0x50, 0x75, 0x74, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
+	0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x20, 0x2e, 0x61, 0x72, 0x72,
+	0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
+	0x6f, 0x6c, 0x2e, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x28, 0x01,
+	0x30, 0x01, 0x12, 0x58, 0x0a, 0x0a, 0x44, 0x6f, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65,
+	0x12, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e,
 	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44,
-	0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x1f, 0x2e, 0x61, 0x72, 0x72, 0x6f,
-	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
-	0x6c, 0x2e, 0x50, 0x6f, 0x6c, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x09,
-	0x47, 0x65, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x27, 0x2e, 0x61, 0x72, 0x72, 0x6f,
+	0x61, 0x74, 0x61, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x4c, 0x0a, 0x08,
+	0x44, 0x6f, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c,
+	0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
+	0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x0b, 0x4c, 0x69,
+	0x73, 0x74, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x1c, 0x2e, 0x61, 0x72, 0x72, 0x6f,
 	0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
-	0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
-	0x6f, 0x72, 0x1a, 0x23, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x6d,
-	0x61, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x12, 0x4d, 0x0a, 0x05, 0x44, 0x6f, 0x47,
-	0x65, 0x74, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x54, 0x69, 0x63, 0x6b, 0x65,
-	0x74, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x44, 0x61, 0x74, 0x61, 0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x05, 0x44, 0x6f, 0x50, 0x75,
-	0x74, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x44, 0x61, 0x74, 0x61, 0x1a, 0x20, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69,
-	0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x50, 0x75, 0x74,
-	0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x58, 0x0a, 0x0a,
-	0x44, 0x6f, 0x45, 0x78, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x21, 0x2e, 0x61, 0x72, 0x72,
-	0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63,
-	0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x21, 0x2e,
-	0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x44, 0x61, 0x74, 0x61,
-	0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x12, 0x4c, 0x0a, 0x08, 0x44, 0x6f, 0x41, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x12, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f,
-	0x6e, 0x1a, 0x1d, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
-	0x22, 0x00, 0x30, 0x01, 0x12, 0x52, 0x0a, 0x0b, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x63, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x12, 0x1c, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67,
-	0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74,
-	0x79, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-	0x54, 0x79, 0x70, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0x71, 0x0a, 0x1c, 0x6f, 0x72, 0x67, 0x2e,
-	0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69,
-	0x67, 0x68, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2f, 0x61, 0x72, 0x72, 0x6f,
-	0x77, 0x2f, 0x67, 0x6f, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68,
-	0x74, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0xaa, 0x02, 0x1c, 0x41,
-	0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x41, 0x72, 0x72, 0x6f, 0x77, 0x2e, 0x46, 0x6c, 0x69, 0x67,
-	0x68, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x33,
+	0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x21, 0x2e, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2e,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2e,
+	0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x22, 0x00, 0x30, 0x01, 0x42, 0x71,
+	0x0a, 0x1c, 0x6f, 0x72, 0x67, 0x2e, 0x61, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x61, 0x72, 0x72,
+	0x6f, 0x77, 0x2e, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x69, 0x6d, 0x70, 0x6c, 0x5a, 0x32,
+	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68,
+	0x65, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77, 0x2f, 0x67, 0x6f, 0x2f, 0x61, 0x72, 0x72, 0x6f, 0x77,
+	0x2f, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x66, 0x6c, 0x69, 0x67,
+	0x68, 0x74, 0xaa, 0x02, 0x1c, 0x41, 0x70, 0x61, 0x63, 0x68, 0x65, 0x2e, 0x41, 0x72, 0x72, 0x6f,
+	0x77, 0x2e, 0x46, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f,
+	0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/go/arrow/flight/gen/flight/FlightSql.pb.go b/go/arrow/flight/gen/flight/FlightSql.pb.go
index 95faa719a9488..494bf8bcca115 100644
--- a/go/arrow/flight/gen/flight/FlightSql.pb.go
+++ b/go/arrow/flight/gen/flight/FlightSql.pb.go
@@ -18,7 +18,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.28.1
-// 	protoc        v3.21.12
+// 	protoc        v4.23.4
 // source: FlightSql.proto
 
 package flight
@@ -48,27 +48,33 @@ const (
 	SqlInfo_FLIGHT_SQL_SERVER_VERSION SqlInfo = 1
 	// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
 	SqlInfo_FLIGHT_SQL_SERVER_ARROW_VERSION SqlInfo = 2
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
 	//
 	// Returns:
 	// - false: if read-write
 	// - true: if read only
 	SqlInfo_FLIGHT_SQL_SERVER_READ_ONLY SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_SQL SqlInfo = 4
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
 	// Substrait plans.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT SqlInfo = 5
+	//
 	// Retrieves a string value indicating the minimum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION SqlInfo = 6
+	//
 	// Retrieves a string value indicating the maximum supported Substrait version, or null
 	// if Substrait is not supported.
 	SqlInfo_FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION SqlInfo = 7
+	//
 	// Retrieves an int32 indicating whether the Flight SQL Server supports the
 	// BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
 	//
@@ -78,51 +84,61 @@ const (
 	//
 	// The possible values are listed in `SqlSupportedTransaction`.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION SqlInfo = 8
+	//
 	// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
 	// query cancellation (the CancelQuery action).
 	SqlInfo_FLIGHT_SQL_SERVER_CANCEL SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT SqlInfo = 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.
 	SqlInfo_FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT SqlInfo = 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.
 	SqlInfo_SQL_DDL_CATALOG SqlInfo = 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.
 	SqlInfo_SQL_DDL_SCHEMA SqlInfo = 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.
 	SqlInfo_SQL_DDL_TABLE SqlInfo = 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`.
 	SqlInfo_SQL_IDENTIFIER_CASE SqlInfo = 503
 	// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
 	SqlInfo_SQL_IDENTIFIER_QUOTE_CHAR SqlInfo = 504
+	//
 	// Retrieves a int32 describing the case sensitivity of quoted identifiers.
 	//
 	// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
 	SqlInfo_SQL_QUOTED_IDENTIFIER_CASE SqlInfo = 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.
 	SqlInfo_SQL_ALL_TABLES_ARE_SELECTABLE SqlInfo = 506
+	//
 	// Retrieves the null ordering.
 	//
 	// Returns a int32 ordinal for the null ordering being used, as described in
@@ -138,15 +154,18 @@ const (
 	SqlInfo_SQL_SYSTEM_FUNCTIONS SqlInfo = 511
 	// Retrieves a UTF-8 string list with values of the supported datetime functions.
 	SqlInfo_SQL_DATETIME_FUNCTIONS SqlInfo = 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.
 	SqlInfo_SQL_SEARCH_STRING_ESCAPE SqlInfo = 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 _).
 	SqlInfo_SQL_EXTRA_NAME_CHARACTERS SqlInfo = 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.
@@ -155,6 +174,7 @@ const (
 	// - false: if column aliasing is unsupported;
 	// - true: if column aliasing is supported.
 	SqlInfo_SQL_SUPPORTS_COLUMN_ALIASING SqlInfo = 515
+	//
 	// Retrieves a boolean value indicating whether concatenations between null and non-null values being
 	// null are supported.
 	//
@@ -162,11 +182,13 @@ const (
 	// - 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.
 	SqlInfo_SQL_NULL_PLUS_NULL_IS_NULL SqlInfo = 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>>
 	SqlInfo_SQL_SUPPORTS_CONVERT SqlInfo = 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.
 	//
@@ -174,6 +196,7 @@ const (
 	// - false: if table correlation names are unsupported;
 	// - true: if table correlation names are supported.
 	SqlInfo_SQL_SUPPORTS_TABLE_CORRELATION_NAMES SqlInfo = 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.
 	//
@@ -181,12 +204,14 @@ const (
 	// - false: if different table correlation names are unsupported;
 	// - true: if different table correlation names are supported
 	SqlInfo_SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES SqlInfo = 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;
 	SqlInfo_SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY SqlInfo = 520
+	//
 	// Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
 	// clause is supported.
 	//
@@ -194,6 +219,7 @@ const (
 	// - 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.
 	SqlInfo_SQL_SUPPORTS_ORDER_BY_UNRELATED SqlInfo = 521
+	//
 	// Retrieves the supported GROUP BY commands;
 	//
 	// Returns an int32 bitmask value representing the supported commands.
@@ -206,18 +232,21 @@ const (
 	// - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
 	// Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
 	SqlInfo_SQL_SUPPORTED_GROUP_BY SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_NON_NULLABLE_COLUMNS SqlInfo = 524
+	//
 	// Retrieves the supported SQL grammar level as per the ODBC specification.
 	//
 	// Returns an int32 bitmask value representing the supported SQL grammar level.
@@ -234,6 +263,7 @@ const (
 	// - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
 	// Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
 	SqlInfo_SQL_SUPPORTED_GRAMMAR SqlInfo = 525
+	//
 	// Retrieves the supported ANSI92 SQL grammar level.
 	//
 	// Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
@@ -250,12 +280,14 @@ const (
 	// - 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`.
 	SqlInfo_SQL_ANSI92_SUPPORTED_LEVEL SqlInfo = 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.
 	SqlInfo_SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY SqlInfo = 527
+	//
 	// Retrieves the support level for SQL OUTER JOINs.
 	//
 	// Returns a int32 ordinal for the SQL ordering being used, as described in
@@ -265,14 +297,17 @@ const (
 	SqlInfo_SQL_SCHEMA_TERM SqlInfo = 529
 	// Retrieves a UTF-8 string with the preferred term for "procedure".
 	SqlInfo_SQL_PROCEDURE_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_TERM SqlInfo = 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.
 	SqlInfo_SQL_CATALOG_AT_START SqlInfo = 532
+	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL schema.
@@ -289,6 +324,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SCHEMAS_SUPPORTED_ACTIONS SqlInfo = 533
+	//
 	// Retrieves the supported actions for a SQL schema.
 	//
 	// Returns an int32 bitmask value representing the supported actions for a SQL catalog.
@@ -305,6 +341,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_CATALOGS_SUPPORTED_ACTIONS SqlInfo = 534
+	//
 	// Retrieves the supported SQL positioned commands.
 	//
 	// Returns an int32 bitmask value representing the supported SQL positioned commands.
@@ -317,12 +354,14 @@ const (
 	// - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
 	SqlInfo_SQL_SUPPORTED_POSITIONED_COMMANDS SqlInfo = 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.
 	SqlInfo_SQL_SELECT_FOR_UPDATE_SUPPORTED SqlInfo = 536
+	//
 	// Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
 	// are supported.
 	//
@@ -330,6 +369,7 @@ const (
 	// - 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.
 	SqlInfo_SQL_STORED_PROCEDURES_SUPPORTED SqlInfo = 537
+	//
 	// Retrieves the supported SQL subqueries.
 	//
 	// Returns an int32 bitmask value representing the supported SQL subqueries.
@@ -355,12 +395,14 @@ const (
 	// - ...
 	// Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
 	SqlInfo_SQL_SUPPORTED_SUBQUERIES SqlInfo = 538
+	//
 	// Retrieves a boolean value indicating whether correlated subqueries are supported.
 	//
 	// Returns:
 	// - false: if correlated subqueries are unsupported;
 	// - true: if correlated subqueries are supported.
 	SqlInfo_SQL_CORRELATED_SUBQUERIES_SUPPORTED SqlInfo = 539
+	//
 	// Retrieves the supported SQL UNIONs.
 	//
 	// Returns an int32 bitmask value representing the supported SQL UNIONs.
@@ -393,6 +435,7 @@ const (
 	SqlInfo_SQL_MAX_CONNECTIONS SqlInfo = 549
 	// Retrieves a int64 value the maximum number of characters allowed in a cursor name.
 	SqlInfo_SQL_MAX_CURSOR_NAME_LENGTH SqlInfo = 550
+	//
 	// Retrieves a int64 value representing the maximum number of bytes allowed for an index,
 	// including all of the parts of the index.
 	SqlInfo_SQL_MAX_INDEX_LENGTH SqlInfo = 551
@@ -404,15 +447,17 @@ const (
 	SqlInfo_SQL_MAX_CATALOG_NAME_LENGTH SqlInfo = 554
 	// Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
 	SqlInfo_SQL_MAX_ROW_SIZE SqlInfo = 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.
+	// - 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.
 	SqlInfo_SQL_MAX_ROW_SIZE_INCLUDES_BLOBS SqlInfo = 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.
 	SqlInfo_SQL_MAX_STATEMENT_LENGTH SqlInfo = 557
@@ -424,11 +469,13 @@ const (
 	SqlInfo_SQL_MAX_TABLES_IN_SELECT SqlInfo = 560
 	// Retrieves a int64 value representing the maximum number of characters allowed in a user name.
 	SqlInfo_SQL_MAX_USERNAME_LENGTH SqlInfo = 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.
 	SqlInfo_SQL_DEFAULT_TRANSACTION_ISOLATION SqlInfo = 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`.
 	//
@@ -436,6 +483,7 @@ const (
 	// - false: if transactions are unsupported;
 	// - true: if transactions are supported.
 	SqlInfo_SQL_TRANSACTIONS_SUPPORTED SqlInfo = 563
+	//
 	// Retrieves the supported transactions isolation levels.
 	//
 	// Returns an int32 bitmask value representing the supported transactions isolation levels.
@@ -462,6 +510,7 @@ const (
 	// - ...
 	// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
 	SqlInfo_SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS SqlInfo = 564
+	//
 	// Retrieves a boolean value indicating whether a data definition statement within a transaction forces
 	// the transaction to commit.
 	//
@@ -469,12 +518,14 @@ const (
 	// - 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.
 	SqlInfo_SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT SqlInfo = 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.
 	SqlInfo_SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED SqlInfo = 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.
 	//
@@ -491,6 +542,7 @@ const (
 	// - ...
 	// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
 	SqlInfo_SQL_SUPPORTED_RESULT_SET_TYPES SqlInfo = 567
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
 	//
@@ -505,6 +557,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED SqlInfo = 568
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
 	//
@@ -519,6 +572,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY SqlInfo = 569
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
 	//
@@ -533,6 +587,7 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE SqlInfo = 570
+	//
 	// Returns an int32 bitmask value concurrency types supported for
 	// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
 	//
@@ -547,29 +602,34 @@ const (
 	// - 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`.
 	SqlInfo_SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE SqlInfo = 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.
 	SqlInfo_SQL_BATCH_UPDATES_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_SAVEPOINTS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_NAMED_PARAMETERS_SUPPORTED SqlInfo = 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.
 	SqlInfo_SQL_LOCATORS_UPDATE_COPY SqlInfo = 575
+	//
 	// Retrieves a boolean value indicating whether invoking user-defined or vendor functions
 	// using the stored procedure escape syntax is supported.
 	//
@@ -1642,7 +1702,7 @@ func (SqlSupportsConvert) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{16}
 }
 
-// *
+//*
 // The JDBC/ODBC-defined type of any object.
 // All the values here are the sames as in the JDBC and ODBC specs.
 type XdbcDataType int32
@@ -1757,7 +1817,7 @@ func (XdbcDataType) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{17}
 }
 
-// *
+//*
 // Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
 type XdbcDatetimeSubcode int32
 
@@ -1898,13 +1958,13 @@ func (XdbcDatetimeSubcode) EnumDescriptor() ([]byte, []int) {
 type Nullable int32
 
 const (
-	// *
+	//*
 	// Indicates that the fields does not allow the use of null values.
 	Nullable_NULLABILITY_NO_NULLS Nullable = 0
-	// *
+	//*
 	// Indicates that the fields allow the use of null values.
 	Nullable_NULLABILITY_NULLABLE Nullable = 1
-	// *
+	//*
 	// Indicates that nullability of the fields can not be determined.
 	Nullable_NULLABILITY_UNKNOWN Nullable = 2
 )
@@ -1953,21 +2013,21 @@ func (Nullable) EnumDescriptor() ([]byte, []int) {
 type Searchable int32
 
 const (
-	// *
+	//*
 	// Indicates that column can not be used in a WHERE clause.
 	Searchable_SEARCHABLE_NONE Searchable = 0
-	// *
+	//*
 	// Indicates that the column can be used in a WHERE clause if it is using a
 	// LIKE operator.
 	Searchable_SEARCHABLE_CHAR Searchable = 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.
+	// - Allowed operators: comparison, quantified comparison, BETWEEN,
+	//                      DISTINCT, IN, MATCH, and UNIQUE.
 	Searchable_SEARCHABLE_BASIC Searchable = 2
-	// *
+	//*
 	// Indicates that the column can be used in a WHERE clause using any operator.
 	Searchable_SEARCHABLE_FULL Searchable = 3
 )
@@ -2233,23 +2293,22 @@ func (ActionCancelQueryResult_CancelResult) EnumDescriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{29, 0}
 }
 
+//
 // 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.
+//  - 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>>
-//
+//  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.
 type CommandGetSqlInfo struct {
@@ -2257,6 +2316,7 @@ type CommandGetSqlInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
@@ -2316,62 +2376,61 @@ func (x *CommandGetSqlInfo) GetInfo() []uint32 {
 	return nil
 }
 
+//
 // 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.
+//  - 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).
-//
+//   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.
 type CommandGetXdbcTypeInfo struct {
@@ -2379,6 +2438,7 @@ type CommandGetXdbcTypeInfo struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// Specifies the data type to search for the info.
 	DataType *int32 `protobuf:"varint,1,opt,name=data_type,json=dataType,proto3,oneof" json:"data_type,omitempty"`
 }
@@ -2422,17 +2482,16 @@ func (x *CommandGetXdbcTypeInfo) GetDataType() int32 {
 	return 0
 }
 
+//
 // 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.
+//  - 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
-//
+//  catalog_name: utf8 not null
 // >
 // The returned data should be ordered by catalog_name.
 type CommandGetCatalogs struct {
@@ -2473,18 +2532,17 @@ func (*CommandGetCatalogs) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{2}
 }
 
+//
 // 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.
+//  - 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
-//
+//  catalog_name: utf8,
+//  db_schema_name: utf8 not null
 // >
 // The returned data should be ordered by catalog_name, then db_schema_name.
 type CommandGetDbSchemas struct {
@@ -2492,15 +2550,17 @@ type CommandGetDbSchemas struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
 }
 
@@ -2550,56 +2610,58 @@ func (x *CommandGetDbSchemas) GetDbSchemaFilterPattern() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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.)
-//
+//  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.
-//
+//  - 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.
 type CommandGetTables struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	DbSchemaFilterPattern *string `protobuf:"bytes,2,opt,name=db_schema_filter_pattern,json=dbSchemaFilterPattern,proto3,oneof" json:"db_schema_filter_pattern,omitempty"`
+	//
 	// 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.
+	//    - "%" means to match any substring with 0 or more characters.
+	//    - "_" means to match any one character.
 	TableNameFilterPattern *string `protobuf:"bytes,3,opt,name=table_name_filter_pattern,json=tableNameFilterPattern,proto3,oneof" json:"table_name_filter_pattern,omitempty"`
+	//
 	// 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.
@@ -2675,18 +2737,17 @@ func (x *CommandGetTables) GetIncludeSchema() bool {
 	return false
 }
 
+//
 // 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.
+//  - 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
-//
+//  table_type: utf8 not null
 // >
 // The returned data should be ordered by table_type.
 type CommandGetTableTypes struct {
@@ -2727,21 +2788,20 @@ func (*CommandGetTableTypes) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{5}
 }
 
+//
 // 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.
+//  - 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
-//
+//  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.
 type CommandGetPrimaryKeys struct {
@@ -2749,10 +2809,12 @@ type CommandGetPrimaryKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -2814,29 +2876,28 @@ func (x *CommandGetPrimaryKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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.
@@ -2845,10 +2906,12 @@ type CommandGetExportedKeys struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -2910,45 +2973,46 @@ func (x *CommandGetExportedKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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
+//    - 0 = CASCADE
+//    - 1 = RESTRICT
+//    - 2 = SET NULL
+//    - 3 = NO ACTION
+//    - 4 = SET DEFAULT
 type CommandGetImportedKeys struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
+	//
 	// 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.
 	Catalog *string `protobuf:"bytes,1,opt,name=catalog,proto3,oneof" json:"catalog,omitempty"`
+	//
 	// 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.
@@ -3010,67 +3074,66 @@ func (x *CommandGetImportedKeys) GetTable() string {
 	return ""
 }
 
+//
 // 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.
+//  - 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
-//
+//  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
+//    - 0 = CASCADE
+//    - 1 = RESTRICT
+//    - 2 = SET NULL
+//    - 3 = NO ACTION
+//    - 4 = SET DEFAULT
 type CommandGetCrossReference struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	// *
+	//*
 	// 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.
 	PkCatalog *string `protobuf:"bytes,1,opt,name=pk_catalog,json=pkCatalog,proto3,oneof" json:"pk_catalog,omitempty"`
-	// *
+	//*
 	// 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.
 	PkDbSchema *string `protobuf:"bytes,2,opt,name=pk_db_schema,json=pkDbSchema,proto3,oneof" json:"pk_db_schema,omitempty"`
-	// *
+	//*
 	// The parent table name. It cannot be null.
 	PkTable string `protobuf:"bytes,3,opt,name=pk_table,json=pkTable,proto3" json:"pk_table,omitempty"`
-	// *
+	//*
 	// 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.
 	FkCatalog *string `protobuf:"bytes,4,opt,name=fk_catalog,json=fkCatalog,proto3,oneof" json:"fk_catalog,omitempty"`
-	// *
+	//*
 	// 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.
 	FkDbSchema *string `protobuf:"bytes,5,opt,name=fk_db_schema,json=fkDbSchema,proto3,oneof" json:"fk_db_schema,omitempty"`
-	// *
+	//*
 	// The foreign table name. It cannot be null.
 	FkTable string `protobuf:"bytes,6,opt,name=fk_table,json=fkTable,proto3" json:"fk_table,omitempty"`
 }
@@ -3149,6 +3212,7 @@ func (x *CommandGetCrossReference) GetFkTable() string {
 	return ""
 }
 
+//
 // Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
 type ActionCreatePreparedStatementRequest struct {
 	state         protoimpl.MessageState
@@ -3208,6 +3272,7 @@ func (x *ActionCreatePreparedStatementRequest) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // An embedded message describing a Substrait plan to execute.
 type SubstraitPlan struct {
 	state         protoimpl.MessageState
@@ -3271,6 +3336,7 @@ func (x *SubstraitPlan) GetVersion() string {
 	return ""
 }
 
+//
 // Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
 type ActionCreatePreparedSubstraitPlanRequest struct {
 	state         protoimpl.MessageState
@@ -3330,6 +3396,7 @@ func (x *ActionCreatePreparedSubstraitPlanRequest) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
 //
 // The resultant PreparedStatement can be closed either:
@@ -3405,6 +3472,7 @@ func (x *ActionCreatePreparedStatementResult) GetParameterSchema() []byte {
 	return nil
 }
 
+//
 // Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
 // Closes server resources associated with the prepared statement handle.
 type ActionClosePreparedStatementRequest struct {
@@ -3455,6 +3523,7 @@ func (x *ActionClosePreparedStatementRequest) GetPreparedStatementHandle() []byt
 	return nil
 }
 
+//
 // Request message for the "BeginTransaction" action.
 // Begins a transaction.
 type ActionBeginTransactionRequest struct {
@@ -3495,6 +3564,7 @@ func (*ActionBeginTransactionRequest) Descriptor() ([]byte, []int) {
 	return file_FlightSql_proto_rawDescGZIP(), []int{15}
 }
 
+//
 // Request message for the "BeginSavepoint" action.
 // Creates a savepoint within a transaction.
 //
@@ -3557,6 +3627,7 @@ func (x *ActionBeginSavepointRequest) GetName() string {
 	return ""
 }
 
+//
 // The result of a "BeginTransaction" action.
 //
 // The transaction can be manipulated with the "EndTransaction" action, or
@@ -3612,6 +3683,7 @@ func (x *ActionBeginTransactionResult) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // The result of a "BeginSavepoint" action.
 //
 // The transaction can be manipulated with the "EndSavepoint" action.
@@ -3667,6 +3739,7 @@ func (x *ActionBeginSavepointResult) GetSavepointId() []byte {
 	return nil
 }
 
+//
 // Request message for the "EndTransaction" action.
 //
 // Commit (COMMIT) or rollback (ROLLBACK) the transaction.
@@ -3730,6 +3803,7 @@ func (x *ActionEndTransactionRequest) GetAction() ActionEndTransactionRequest_En
 	return ActionEndTransactionRequest_END_TRANSACTION_UNSPECIFIED
 }
 
+//
 // Request message for the "EndSavepoint" action.
 //
 // Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
@@ -3795,21 +3869,22 @@ func (x *ActionEndSavepointRequest) GetAction() ActionEndSavepointRequest_EndSav
 	return ActionEndSavepointRequest_END_SAVEPOINT_UNSPECIFIED
 }
 
+//
 // 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.
+//  - 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.
 type CommandStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3867,22 +3942,23 @@ func (x *CommandStatementQuery) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // 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.
+//  - 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.
 type CommandStatementSubstraitPlan struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -3940,7 +4016,7 @@ func (x *CommandStatementSubstraitPlan) GetTransactionId() []byte {
 	return nil
 }
 
-// *
+//*
 // 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.
 type TicketStatementQuery struct {
@@ -3991,22 +4067,23 @@ func (x *TicketStatementQuery) GetStatementHandle() []byte {
 	return nil
 }
 
+//
 // 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.
-//   - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
-//   - GetFlightInfo: execute the prepared statement instance.
+//  - 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.
+//  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+//  - GetFlightInfo: execute the prepared statement instance.
 type CommandPreparedStatementQuery struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -4055,6 +4132,7 @@ func (x *CommandPreparedStatementQuery) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
+//
 // 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.
 type CommandStatementUpdate struct {
@@ -4114,6 +4192,7 @@ func (x *CommandStatementUpdate) GetTransactionId() []byte {
 	return nil
 }
 
+//
 // 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.
@@ -4165,6 +4244,7 @@ func (x *CommandPreparedStatementUpdate) GetPreparedStatementHandle() []byte {
 	return nil
 }
 
+//
 // Returned from the RPC call DoPut when a CommandStatementUpdate
 // CommandPreparedStatementUpdate was in the request, containing
 // results from the update.
@@ -4217,6 +4297,7 @@ func (x *DoPutUpdateResult) GetRecordCount() int64 {
 	return 0
 }
 
+//
 // Request message for the "CancelQuery" action.
 //
 // Explicitly cancel a running query.
@@ -4285,6 +4366,7 @@ func (x *ActionCancelQueryRequest) GetInfo() []byte {
 	return nil
 }
 
+//
 // The result of cancelling a query.
 //
 // The result should be wrapped in a google.protobuf.Any message.
diff --git a/go/arrow/flight/gen/flight/Flight_grpc.pb.go b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
index 150de71a1113b..87d9abc5926eb 100644
--- a/go/arrow/flight/gen/flight/Flight_grpc.pb.go
+++ b/go/arrow/flight/gen/flight/Flight_grpc.pb.go
@@ -1,4 +1,8 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.2.0
+// - protoc             v4.23.4
+// source: Flight.proto
 
 package flight
 
@@ -11,17 +15,20 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.32.0 or later.
 const _ = grpc.SupportPackageIsVersion7
 
 // FlightServiceClient is the client API for FlightService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type FlightServiceClient interface {
+	//
 	// 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.
 	Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error)
+	//
 	// 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
@@ -29,6 +36,7 @@ type FlightServiceClient interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error)
+	//
 	// 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
@@ -40,6 +48,7 @@ type FlightServiceClient interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*FlightInfo, error)
+	//
 	// 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
@@ -63,16 +72,19 @@ type FlightServiceClient interface {
 	// A client may use the CancelFlightInfo action with
 	// PollInfo.info to cancel the running query.
 	PollFlightInfo(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*PollInfo, error)
+	//
 	// 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.
 	GetSchema(ctx context.Context, in *FlightDescriptor, opts ...grpc.CallOption) (*SchemaResult, error)
+	//
 	// 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.
 	DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error)
+	//
 	// 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
@@ -80,12 +92,14 @@ type FlightServiceClient interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error)
+	//
 	// 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.
 	DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error)
+	//
 	// 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
@@ -93,6 +107,7 @@ type FlightServiceClient interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error)
+	//
 	// 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.
@@ -108,7 +123,7 @@ func NewFlightServiceClient(cc grpc.ClientConnInterface) FlightServiceClient {
 }
 
 func (c *flightServiceClient) Handshake(ctx context.Context, opts ...grpc.CallOption) (FlightService_HandshakeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[0], "/arrow.flight.protocol.FlightService/Handshake", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -139,7 +154,7 @@ func (x *flightServiceHandshakeClient) Recv() (*HandshakeResponse, error) {
 }
 
 func (c *flightServiceClient) ListFlights(ctx context.Context, in *Criteria, opts ...grpc.CallOption) (FlightService_ListFlightsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[1], "/arrow.flight.protocol.FlightService/ListFlights", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -198,7 +213,7 @@ func (c *flightServiceClient) GetSchema(ctx context.Context, in *FlightDescripto
 }
 
 func (c *flightServiceClient) DoGet(ctx context.Context, in *Ticket, opts ...grpc.CallOption) (FlightService_DoGetClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[2], "/arrow.flight.protocol.FlightService/DoGet", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -230,7 +245,7 @@ func (x *flightServiceDoGetClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoPut(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoPutClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[3], "/arrow.flight.protocol.FlightService/DoPut", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -261,7 +276,7 @@ func (x *flightServiceDoPutClient) Recv() (*PutResult, error) {
 }
 
 func (c *flightServiceClient) DoExchange(ctx context.Context, opts ...grpc.CallOption) (FlightService_DoExchangeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[4], "/arrow.flight.protocol.FlightService/DoExchange", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -292,7 +307,7 @@ func (x *flightServiceDoExchangeClient) Recv() (*FlightData, error) {
 }
 
 func (c *flightServiceClient) DoAction(ctx context.Context, in *Action, opts ...grpc.CallOption) (FlightService_DoActionClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[5], "/arrow.flight.protocol.FlightService/DoAction", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -324,7 +339,7 @@ func (x *flightServiceDoActionClient) Recv() (*Result, error) {
 }
 
 func (c *flightServiceClient) ListActions(ctx context.Context, in *Empty, opts ...grpc.CallOption) (FlightService_ListActionsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_FlightService_serviceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
+	stream, err := c.cc.NewStream(ctx, &FlightService_ServiceDesc.Streams[6], "/arrow.flight.protocol.FlightService/ListActions", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -359,11 +374,13 @@ func (x *flightServiceListActionsClient) Recv() (*ActionType, error) {
 // All implementations must embed UnimplementedFlightServiceServer
 // for forward compatibility
 type FlightServiceServer interface {
+	//
 	// 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.
 	Handshake(FlightService_HandshakeServer) error
+	//
 	// 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
@@ -371,6 +388,7 @@ type FlightServiceServer interface {
 	// the subset of streams that can be listed via this interface. Each flight
 	// service allows its own definition of how to consume criteria.
 	ListFlights(*Criteria, FlightService_ListFlightsServer) error
+	//
 	// 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
@@ -382,6 +400,7 @@ type FlightServiceServer interface {
 	// available for consumption for the duration defined by the specific flight
 	// service.
 	GetFlightInfo(context.Context, *FlightDescriptor) (*FlightInfo, error)
+	//
 	// 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
@@ -405,16 +424,19 @@ type FlightServiceServer interface {
 	// A client may use the CancelFlightInfo action with
 	// PollInfo.info to cancel the running query.
 	PollFlightInfo(context.Context, *FlightDescriptor) (*PollInfo, error)
+	//
 	// 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.
 	GetSchema(context.Context, *FlightDescriptor) (*SchemaResult, error)
+	//
 	// 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.
 	DoGet(*Ticket, FlightService_DoGetServer) error
+	//
 	// 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
@@ -422,12 +444,14 @@ type FlightServiceServer interface {
 	// number. In the latter, the service might implement a 'seal' action that
 	// can be applied to a descriptor once all streams are uploaded.
 	DoPut(FlightService_DoPutServer) error
+	//
 	// 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.
 	DoExchange(FlightService_DoExchangeServer) error
+	//
 	// 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
@@ -435,6 +459,7 @@ type FlightServiceServer interface {
 	// opaque request and response objects that are specific to the type action
 	// being undertaken.
 	DoAction(*Action, FlightService_DoActionServer) error
+	//
 	// 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.
@@ -485,8 +510,8 @@ type UnsafeFlightServiceServer interface {
 	mustEmbedUnimplementedFlightServiceServer()
 }
 
-func RegisterFlightServiceServer(s *grpc.Server, srv FlightServiceServer) {
-	s.RegisterService(&_FlightService_serviceDesc, srv)
+func RegisterFlightServiceServer(s grpc.ServiceRegistrar, srv FlightServiceServer) {
+	s.RegisterService(&FlightService_ServiceDesc, srv)
 }
 
 func _FlightService_Handshake_Handler(srv interface{}, stream grpc.ServerStream) error {
@@ -705,7 +730,10 @@ func (x *flightServiceListActionsServer) Send(m *ActionType) error {
 	return x.ServerStream.SendMsg(m)
 }
 
-var _FlightService_serviceDesc = grpc.ServiceDesc{
+// FlightService_ServiceDesc is the grpc.ServiceDesc for FlightService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var FlightService_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "arrow.flight.protocol.FlightService",
 	HandlerType: (*FlightServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 4108cf8124245..4f47d7fd506ee 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -71,6 +71,8 @@ func GetScenario(name string, args ...string) Scenario {
 		return &expirationTimeRenewFlightEndpointScenarioTester{}
 	case "poll_flight_info":
 		return &pollFlightInfoScenarioTester{}
+	case "app_metadata_flight_info_endpoint":
+		return &appMetadataFlightInfoEndpointScenarioTester{}
 	case "flight_sql":
 		return &flightSqlScenarioTester{}
 	case "flight_sql:extension":
@@ -1153,7 +1155,7 @@ func (tester *pollFlightInfoScenarioTester) PollFlightInfo(ctx context.Context,
 		nil,
 	)
 	endpoints := []*flight.FlightEndpoint{
-		&flight.FlightEndpoint{
+		{
 			Ticket:   &flight.Ticket{Ticket: []byte("long-running query")},
 			Location: []*flight.Location{},
 		},
@@ -1236,6 +1238,66 @@ func (tester *pollFlightInfoScenarioTester) RunClient(addr string, opts ...grpc.
 	return nil
 }
 
+type appMetadataFlightInfoEndpointScenarioTester struct {
+	flight.BaseFlightServer
+}
+
+func (tester *appMetadataFlightInfoEndpointScenarioTester) MakeServer(port int) flight.Server {
+	srv := flight.NewServerWithMiddleware(nil)
+	srv.RegisterFlightService(tester)
+	initServer(port, srv)
+	return srv
+}
+
+func (tester *appMetadataFlightInfoEndpointScenarioTester) GetFlightInfo(ctx context.Context, desc *flight.FlightDescriptor) (*flight.FlightInfo, error) {
+	schema := arrow.NewSchema(
+		[]arrow.Field{
+			{Name: "number", Type: arrow.PrimitiveTypes.Uint32},
+		},
+		nil,
+	)
+
+	if desc.Type != flight.DescriptorCMD {
+		return nil, fmt.Errorf("%w: should have received CMD descriptor", arrow.ErrInvalid)
+	}
+	endpoints := []*flight.FlightEndpoint{{AppMetadata: desc.Cmd}}
+	return &flight.FlightInfo{
+		Schema:           flight.SerializeSchema(schema, memory.DefaultAllocator),
+		FlightDescriptor: desc,
+		Endpoint:         endpoints,
+		TotalRecords:     -1,
+		TotalBytes:       -1,
+		AppMetadata:      desc.Cmd,
+	}, nil
+}
+
+func (tester *appMetadataFlightInfoEndpointScenarioTester) RunClient(addr string, opts ...grpc.DialOption) error {
+	client, err := flight.NewClientWithMiddleware(addr, nil, nil, opts...)
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	ctx := context.Background()
+	desc := flight.FlightDescriptor{
+		Type: flight.DescriptorCMD,
+		Cmd:  []byte("foobar"),
+	}
+	info, err := client.GetFlightInfo(ctx, &desc)
+	if err != nil {
+		return err
+	}
+	switch {
+	case !bytes.Equal(desc.Cmd, info.AppMetadata):
+		return fmt.Errorf("invalid flight info app_metadata: %s, expected: %s", info.AppMetadata, desc.Cmd)
+	case len(info.Endpoint) != 1:
+		return fmt.Errorf("expected exactly 1 flight endpoint, got: %d", len(info.Endpoint))
+	case !bytes.Equal(desc.Cmd, info.Endpoint[0].AppMetadata):
+		return fmt.Errorf("invalid flight endpoint app_metadata: %s, expected: %s", info.Endpoint[0].AppMetadata, desc.Cmd)
+	}
+	return nil
+}
+
 const (
 	updateStatementExpectedRows                        int64 = 10000
 	updateStatementWithTransactionExpectedRows         int64 = 15000

From 5514b223ebc1345c7bbd501fe3cc57dcac668e86 Mon Sep 17 00:00:00 2001
From: Ed Seidl <etseidl@users.noreply.github.com>
Date: Tue, 3 Oct 2023 12:14:50 -0700
Subject: [PATCH 450/749] GH-37939: [C++] Use signed arithmetic for frame of
 reference when encoding DELTA_BINARY_PACKED (#37940)

Closes #37939.

### What changes are included in this PR?

This PR changes values used in the `DELTA_BINARY_PACKED` encoder to signed types. To gracefully handle overflow, arithmetic is still performed in the unsigned domain, but other operations such as computing the min and max deltas are done in the signed domain.

Using signed types ensures the optimal number of bits is used when encoding the deltas, which was not the case before if any negative deltas were encountered (which is obviously common).

### Are these changes tested?
I've included two tests that result in overflow.

### Are there any user-facing changes?
No

* Closes: #37939

Authored-by: seidl <seidl2@llnl.gov>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc      | 27 ++++++++------
 cpp/src/parquet/encoding_test.cc | 64 ++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+), 12 deletions(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 9f705768e4eff..931b9fd10729f 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -57,6 +57,7 @@ using arrow::VisitNullBitmapInline;
 using arrow::internal::AddWithOverflow;
 using arrow::internal::checked_cast;
 using arrow::internal::MultiplyWithOverflow;
+using arrow::internal::SafeSignedSubtract;
 using arrow::internal::SubtractWithOverflow;
 using arrow::util::SafeLoad;
 using arrow::util::SafeLoadAs;
@@ -2189,9 +2190,9 @@ class DeltaBitPackEncoder : public EncoderImpl, virtual public TypedEncoder<DTyp
   const uint32_t values_per_mini_block_;
   uint32_t values_current_block_{0};
   uint32_t total_value_count_{0};
-  UT first_value_{0};
-  UT current_value_{0};
-  ArrowPoolVector<UT> deltas_;
+  T first_value_{0};
+  T current_value_{0};
+  ArrowPoolVector<T> deltas_;
   std::shared_ptr<ResizableBuffer> bits_buffer_;
   ::arrow::BufferBuilder sink_;
   ::arrow::bit_util::BitWriter bit_writer_;
@@ -2212,12 +2213,12 @@ void DeltaBitPackEncoder<DType>::Put(const T* src, int num_values) {
   total_value_count_ += num_values;
 
   while (idx < num_values) {
-    UT value = static_cast<UT>(src[idx]);
+    T value = src[idx];
     // Calculate deltas. The possible overflow is handled by use of unsigned integers
     // making subtraction operations well-defined and correct even in case of overflow.
     // Encoded integers will wrap back around on decoding.
     // See http://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n
-    deltas_[values_current_block_] = value - current_value_;
+    deltas_[values_current_block_] = SafeSignedSubtract(value, current_value_);
     current_value_ = value;
     idx++;
     values_current_block_++;
@@ -2233,9 +2234,11 @@ void DeltaBitPackEncoder<DType>::FlushBlock() {
     return;
   }
 
-  const UT min_delta =
+  // Calculate the frame of reference for this miniblock. This value will be subtracted
+  // from all deltas to guarantee all deltas are positive for encoding.
+  const T min_delta =
       *std::min_element(deltas_.begin(), deltas_.begin() + values_current_block_);
-  bit_writer_.PutZigZagVlqInt(static_cast<T>(min_delta));
+  bit_writer_.PutZigZagVlqInt(min_delta);
 
   // Call to GetNextBytePtr reserves mini_blocks_per_block_ bytes of space to write
   // bit widths of miniblocks as they become known during the encoding.
@@ -2250,17 +2253,17 @@ void DeltaBitPackEncoder<DType>::FlushBlock() {
         std::min(values_per_mini_block_, values_current_block_);
 
     const uint32_t start = i * values_per_mini_block_;
-    const UT max_delta = *std::max_element(
+    const T max_delta = *std::max_element(
         deltas_.begin() + start, deltas_.begin() + start + values_current_mini_block);
 
     // The minimum number of bits required to write any of values in deltas_ vector.
     // See overflow comment above.
-    const auto bit_width = bit_width_data[i] =
-        bit_util::NumRequiredBits(max_delta - min_delta);
+    const auto bit_width = bit_width_data[i] = bit_util::NumRequiredBits(
+        static_cast<UT>(max_delta) - static_cast<UT>(min_delta));
 
     for (uint32_t j = start; j < start + values_current_mini_block; j++) {
-      // See overflow comment above.
-      const UT value = deltas_[j] - min_delta;
+      // Convert delta to frame of reference. See overflow comment above.
+      const UT value = static_cast<UT>(deltas_[j]) - static_cast<UT>(min_delta);
       bit_writer_.PutValue(value, bit_width);
     }
     // If there are not enough values to fill the last mini block, we pad the mini block
diff --git a/cpp/src/parquet/encoding_test.cc b/cpp/src/parquet/encoding_test.cc
index 71dc40d33ac47..9861c317c80d9 100644
--- a/cpp/src/parquet/encoding_test.cc
+++ b/cpp/src/parquet/encoding_test.cc
@@ -1634,6 +1634,70 @@ TYPED_TEST(TestDeltaBitPackEncoding, NonZeroPaddedMiniblockBitWidth) {
   }
 }
 
+// Test that the DELTA_BINARY_PACKED encoding works properply in the presence of values
+// that will cause integer overflow (see GH-37939).
+TYPED_TEST(TestDeltaBitPackEncoding, DeltaBitPackedWrapping) {
+  using T = typename TypeParam::c_type;
+
+  // Values that should wrap when converted to deltas, and then when converted to the
+  // frame of reference.
+  std::vector<T> int_values = {std::numeric_limits<T>::min(),
+                               std::numeric_limits<T>::max(),
+                               std::numeric_limits<T>::min(),
+                               std::numeric_limits<T>::max(),
+                               0,
+                               -1,
+                               0,
+                               1,
+                               -1,
+                               1};
+  const int num_values = static_cast<int>(int_values.size());
+
+  auto const encoder = MakeTypedEncoder<TypeParam>(
+      Encoding::DELTA_BINARY_PACKED, /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(int_values, num_values);
+  auto const encoded = encoder->FlushValues();
+
+  auto const decoder =
+      MakeTypedDecoder<TypeParam>(Encoding::DELTA_BINARY_PACKED, this->descr_.get());
+
+  std::vector<T> decoded(num_values);
+  decoder->SetData(num_values, encoded->data(), static_cast<int>(encoded->size()));
+
+  const int values_decoded = decoder->Decode(decoded.data(), num_values);
+
+  ASSERT_EQ(num_values, values_decoded);
+  ASSERT_NO_FATAL_FAILURE(
+      VerifyResults<T>(decoded.data(), int_values.data(), num_values));
+}
+
+// Test that the DELTA_BINARY_PACKED encoding does not use more bits to encode than
+// necessary (see GH-37939).
+TYPED_TEST(TestDeltaBitPackEncoding, DeltaBitPackedSize) {
+  using T = typename TypeParam::c_type;
+  constexpr int num_values = 128;
+  // 128 values should be <= 1 block of values encoded with 2 bits
+  // delta header should be 0x8001|0x8002 0x04 0x8001 0x02 (6 bytes)
+  // mini-block header should be 0x01 0x02020202 (5 bytes)
+  constexpr int encoded_size = 2 * num_values / 8 + 6 + 5;
+
+  // Create a run of {1, 0, -1, 0, 1, 0, ...}.
+  // min_delta is -1, max_delta is 1, max_delta - min_delta is 2, so this requires 2 bits
+  // to encode.
+  std::vector<T> int_values(num_values);
+  std::iota(int_values.begin(), int_values.end(), 0);
+  std::transform(int_values.begin(), int_values.end(), int_values.begin(), [](T idx) {
+    return (idx % 2) == 1 ? 0 : (idx % 4) == 0 ? 1 : -1;
+  });
+
+  auto const encoder = MakeTypedEncoder<TypeParam>(
+      Encoding::DELTA_BINARY_PACKED, /*use_dictionary=*/false, this->descr_.get());
+  encoder->Put(int_values, num_values);
+  auto const encoded = encoder->FlushValues();
+
+  ASSERT_EQ(encoded->size(), encoded_size);
+}
+
 // ----------------------------------------------------------------------
 // Rle for Boolean encode/decode tests.
 

From 45588a77af3548720dc64fc8ae917e469e6f106a Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 4 Oct 2023 05:32:13 +0900
Subject: [PATCH 451/749] GH-37984: [Release] Use ISO 8601 format for YAML date
 value (#37985)

### Rationale for this change

If we use ISO 8601 format for date value, we can use the value as a `Date` object in Jekyll. It's easy to reuse.

Use case: https://github.com/apache/arrow-site/pull/408

### What changes are included in this PR?

Use ISO 8601 format.

### Are these changes tested?

No.

### Are there any user-facing changes?

No.
* Closes: #37984

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/post-03-website.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dev/release/post-03-website.sh b/dev/release/post-03-website.sh
index faf79625952cc..cb605aee83523 100755
--- a/dev/release/post-03-website.sh
+++ b/dev/release/post-03-website.sh
@@ -58,6 +58,7 @@ fi
 
 export TZ=UTC
 release_date=$(LC_TIME=C date "+%-d %B %Y")
+release_date_iso8601=$(LC_TIME=C date "+%Y-%m-%d")
 previous_tag_date=$(git log -n 1 --pretty=%aI apache-arrow-${previous_version})
 rough_previous_release_date=$(date --date "${previous_tag_date}" +%s)
 rough_release_date=$(date +%s)
@@ -257,7 +258,7 @@ current:
   number: '${version}'
   pinned_number: '${pinned_version}'
   major_number: '${major_version}'
-  date: '${release_date}'
+  date: '${release_date_iso8601}'
   git-tag: '${git_tag_hash}'
   github-tag-link: 'https://github.com/apache/arrow/releases/tag/${git_tag}'
   release-notes: 'https://arrow.apache.org/release/${version}.html'

From 081e354e6fc9ded8f7d3d19d8a785cff31fa5cfb Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 3 Oct 2023 16:35:43 -0400
Subject: [PATCH 452/749] GH-37996: [MATLAB] Add a static constructor method
 named `fromMATLAB` to `arrow.array.StructArray`  (#37998)

### Rationale for this change

Right now, the only way to construct an `arrow.array.StructArray` is to call its static method `fromArrays` method. Doing so requires users to first construct the individual field arrays before creating the `StructArray`.

```matlab
>> a1 = arrow.array([1 2 3 4]);
>> a2 = arrow.array(["A" "B" "C" "D"]);
>> s1 = arrow.array.StructArray.fromArrays(a1, a2, FieldNames=["Number" "String"]);
>> class(s1)

ans =

    'arrow.array.StructArray'
```

It would be nice if users could construct `StructArray`s from MATLAB `table`s by either calling `arrow.array.StructArray.fromMATLAB()` or by passing a `table` to `arrow.array()`:

```matlab
>> t = table([1 2 3 4]', ["A1" "A2" "A3" "A4"]', VariableNames=["Number", "String"])

% Call fromMATLAB method
>> s1 = arrow.array.StructArray.fromMATLAB(t);
>> class(s1)

ans =

    'arrow.array.StructArray'

% Pass table to arrow.array()
>> class(s2)

ans =

    'arrow.array.StructArray'
```

### What changes are included in this PR?

1. Added static constructor method `fromMATLAB` to `arrow.array.StructArray`. It accepts a `table` as input and optionally two name-value pairs: `FieldNames` and `Valid`.
2.  Set the `ArrayStaticConstructor` property of `arrow.type.traits.StructTraits` to `@ arrow.array.StructArray.fromMATLAB`. Previously, it was set to `missing`.
3. Updated `arrow.type.traits.traits(className)` to return `StructTraits` if `className` is the string `"table"`.
4. Updated `arrow.array` to accept  a MATLAB `table` as input and return an `arrow.array.StructArray` if given a `table`.
5. Changed the signature of `arrow.array()` to accept `varargin` instead of pre-determined name-value pairs. The name-value pairs accepted depends on the type of array being constructed. For example, you can supply `TimeUnit` when constructing an `arrow.array.TimestampArray`, but  `TimeUnit` will not be accepted when creating an `arrow.array.Int8Array`.

### Are these changes tested?

Yes. Added new tests cases to `tArray.m`, `tStructArray.m`, `ttraits.m`, and `tStructTraits.m`.

### Are there any user-facing changes?

Yes, users can now create `StructArray`s directly from MATLAB `table`s by calling either `arrow.array()` or `arrow.array.StructArray.fromMATLAB`.

* Closes: #37996

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/matlab/+arrow/+array/StructArray.m | 33 +++++++
 .../+arrow/+type/+traits/StructTraits.m       |  5 +-
 .../src/matlab/+arrow/+type/+traits/traits.m  |  2 +
 matlab/src/matlab/+arrow/array.m              | 38 ++++----
 matlab/test/arrow/array/tArray.m              |  5 +-
 matlab/test/arrow/array/tStructArray.m        | 86 +++++++++++++++++++
 matlab/test/arrow/type/traits/tStructTraits.m |  2 +-
 matlab/test/arrow/type/traits/ttraits.m       | 11 +++
 8 files changed, 154 insertions(+), 28 deletions(-)

diff --git a/matlab/src/matlab/+arrow/+array/StructArray.m b/matlab/src/matlab/+arrow/+array/StructArray.m
index 589e39fecd015..800e34fe746ec 100644
--- a/matlab/src/matlab/+arrow/+array/StructArray.m
+++ b/matlab/src/matlab/+arrow/+array/StructArray.m
@@ -142,5 +142,38 @@
             proxy = arrow.internal.proxy.create(proxyName, args);
             array = arrow.array.StructArray(proxy);
         end
+
+        function array = fromMATLAB(T, opts)
+            arguments
+                T table
+                opts.FieldNames(1, :) string {mustBeNonmissing} = T.Properties.VariableNames
+                opts.Valid
+            end
+
+            import arrow.tabular.internal.decompose
+            import arrow.tabular.internal.validateColumnNames
+            import arrow.array.internal.getArrayProxyIDs
+            import arrow.internal.validate.parseValid
+
+            if width(T) == 0
+                % StructArrays require at least one field
+                error("arrow:struct:ZeroVariables", ...
+                    "Input table T must have at least one variable.");
+            end
+
+            % If FieldNames was provided, make sure the number of field
+            % names is equal to the width of the table.
+            validateColumnNames(opts.FieldNames, width(T));
+
+            arrowArrays = decompose(T);
+            arrayProxyIDs = getArrayProxyIDs(arrowArrays);
+            validElements = parseValid(opts, height(T));
+
+            args = struct(ArrayProxyIDs=arrayProxyIDs, ...
+                FieldNames=opts.FieldNames, Valid=validElements);
+            proxyName = "arrow.array.proxy.StructArray";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            array = arrow.array.StructArray(proxy);
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
index 0f8b7b3a2a663..adab036f27855 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/StructTraits.m
@@ -19,10 +19,7 @@
         ArrayConstructor = @arrow.array.StructArray
         ArrayClassName = "arrow.array.StructArray"
         ArrayProxyClassName = "arrow.array.proxy.StructArray"
-
-        % TODO: Implement fromMATLAB
-        ArrayStaticConstructor = missing
-
+        ArrayStaticConstructor = @arrow.array.StructArray.fromMATLAB
         TypeConstructor = @arrow.type.StructType
         TypeClassName = "arrow.type.StructType"
         TypeProxyClassName = "arrow.type.proxy.StructType"
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index f737108ce5f76..9badf63eebb81 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -91,6 +91,8 @@
                 typeTraits = TimestampTraits();
             case "duration"
                 typeTraits = Time64Traits();
+            case "table"
+                typeTraits = StructTraits();
             otherwise
                 error("arrow:type:traits:UnsupportedMatlabClass", "Unsupported MATLAB class: " + type);
         end
diff --git a/matlab/src/matlab/+arrow/array.m b/matlab/src/matlab/+arrow/array.m
index 983b3c88680c4..e34eb8b3fcc6c 100644
--- a/matlab/src/matlab/+arrow/array.m
+++ b/matlab/src/matlab/+arrow/array.m
@@ -13,46 +13,42 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-function arrowArray = array(data, opts)
-    arguments
-        data
-        opts.InferNulls(1, 1) logical = true
-        opts.Valid
-    end
+function arrowArray = array(data, varargin)
 
     data = convertCellstrToString(data);
     classname = string(class(data));
-    args = namedargs2cell(opts);
 
     switch (classname)
         case "logical"
-            arrowArray = arrow.array.BooleanArray.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.BooleanArray.fromMATLAB(data, varargin{:});
         case "uint8"
-            arrowArray = arrow.array.UInt8Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.UInt8Array.fromMATLAB(data, varargin{:});
         case "uint16"
-            arrowArray = arrow.array.UInt16Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.UInt16Array.fromMATLAB(data, varargin{:});
         case "uint32"
-            arrowArray = arrow.array.UInt32Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.UInt32Array.fromMATLAB(data, varargin{:});
         case "uint64"
-            arrowArray = arrow.array.UInt64Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.UInt64Array.fromMATLAB(data, varargin{:});
         case "int8"
-            arrowArray = arrow.array.Int8Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Int8Array.fromMATLAB(data, varargin{:});
         case "int16"
-            arrowArray = arrow.array.Int16Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Int16Array.fromMATLAB(data, varargin{:});
         case "int32"
-            arrowArray = arrow.array.Int32Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Int32Array.fromMATLAB(data, varargin{:});
         case "int64"
-            arrowArray = arrow.array.Int64Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Int64Array.fromMATLAB(data, varargin{:});
         case "single"
-            arrowArray = arrow.array.Float32Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Float32Array.fromMATLAB(data, varargin{:});
         case "double"
-            arrowArray = arrow.array.Float64Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Float64Array.fromMATLAB(data, varargin{:});
         case "string"
-            arrowArray = arrow.array.StringArray.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.StringArray.fromMATLAB(data, varargin{:});
         case "datetime"
-            arrowArray = arrow.array.TimestampArray.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.TimestampArray.fromMATLAB(data, varargin{:});
         case "duration"
-            arrowArray = arrow.array.Time64Array.fromMATLAB(data, args{:});
+            arrowArray = arrow.array.Time64Array.fromMATLAB(data, varargin{:});
+        case "table"
+            arrowArray = arrow.array.StructArray.fromMATLAB(data, varargin{:});
         otherwise
             errid = "arrow:array:UnsupportedMATLABType";
             msg = join(["Unable to convert MATLAB type" classname "to arrow array."]);
diff --git a/matlab/test/arrow/array/tArray.m b/matlab/test/arrow/array/tArray.m
index 54b31270b25d2..545d382ddf7f4 100644
--- a/matlab/test/arrow/array/tArray.m
+++ b/matlab/test/arrow/array/tArray.m
@@ -32,7 +32,8 @@
             {[1 2],                "arrow.array.Float64Array"}, ...
             {datetime(2022, 1, 1), "arrow.array.TimestampArray"}, ...
             {seconds([1 2]),       "arrow.array.Time64Array"}, ...
-            {["A" "B"],            "arrow.array.StringArray"}};
+            {["A" "B"],            "arrow.array.StringArray"}, ...
+            {table(["A" "B"]'),    "arrow.array.StructArray"}};
     end
 
     methods(Test)        
@@ -50,7 +51,7 @@ function UnsupportedMATLABTypeError(testCase)
         % Verify arrow.array throws an error with the identifier
         % "arrow:array:UnsupportedMATLABType" if the input array is not one
         % we support converting into an Arrow array.
-            matlabArray = table;
+            matlabArray = {table};
             fcn = @() arrow.array(matlabArray);
             errID = "arrow:array:UnsupportedMATLABType";
             testCase.verifyError(fcn, errID);
diff --git a/matlab/test/arrow/array/tStructArray.m b/matlab/test/arrow/array/tStructArray.m
index 639df65befbf5..83e902ee2fa23 100644
--- a/matlab/test/arrow/array/tStructArray.m
+++ b/matlab/test/arrow/array/tStructArray.m
@@ -273,5 +273,91 @@ function IsEqualFalse(tc)
             tc.verifyFalse(isequal(array1, array3));
         end
 
+        function FromMATLABBasic(tc)
+            % Verify StructArray.fromMATLAB returns the expected
+            % StructArray.
+            import arrow.array.StructArray
+
+            T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
+            array = StructArray.fromMATLAB(T);
+            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumFields, int32(2));
+            tc.verifyEqual(array.FieldNames, ["Number" "String"]);
+
+            field1 = arrow.array([1 2]');
+            field2 = arrow.array(["A1" "A2"]');
+
+            tc.verifyEqual(field1, array.field(1));
+            tc.verifyEqual(field2, array.field(2));
+        end
+
+        function FromMATLABFieldNames(tc)
+            % Verify StructArray.fromMATLAB returns the expected
+            % StructArray when the FieldNames nv-pair is supplied.
+            import arrow.array.StructArray
+
+            T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
+            array = StructArray.fromMATLAB(T, FieldNames=["Custom" "Name"]);
+            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumFields, int32(2));
+            tc.verifyEqual(array.FieldNames, ["Custom" "Name"]);
+            tc.verifyEqual(array.Valid, [true; true]);
+
+            field1 = arrow.array([1 2]');
+            field2 = arrow.array(["A1" "A2"]');
+
+            tc.verifyEqual(field1, array.field(1));
+            tc.verifyEqual(field2, array.field(2));
+        end
+
+        function FromMATLABValid(tc)
+            % Verify StructArray.fromMATLAB returns the expected
+            % StructArray when the Valid nv-pair is supplied.
+
+            import arrow.array.StructArray
+
+            T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
+            array = StructArray.fromMATLAB(T, Valid=2);
+            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumFields, int32(2));
+            tc.verifyEqual(array.FieldNames, ["Number" "String"]);
+            tc.verifyEqual(array.Valid, [false; true]);
+
+            field1 = arrow.array([1 2]');
+            field2 = arrow.array(["A1" "A2"]');
+
+            tc.verifyEqual(field1, array.field(1));
+            tc.verifyEqual(field2, array.field(2));
+        end
+
+        function FromMATLABZeroVariablesError(tc)
+            % Verify StructArray.fromMATLAB throws an error when the input
+            % table T has zero variables.
+            import arrow.array.StructArray
+
+            fcn = @() StructArray.fromMATLAB(table);
+            tc.verifyError(fcn, "arrow:struct:ZeroVariables");
+        end
+
+        function FromMATLABWrongNumberFieldNames(tc)
+            % Verify StructArray.fromMATLAB throws an error when the 
+            % FieldNames nv-pair is provided and its number of elements
+            % does not equal the number of variables in the input table T.
+
+            import arrow.array.StructArray
+
+            fcn = @() StructArray.fromMATLAB(table(1), FieldNames=["A" "B"]);
+            tc.verifyError(fcn, "arrow:tabular:WrongNumberColumnNames");
+        end
+
+        function FromMATLABValidNVPairBadIndex(tc)
+            % Verify StructArray.fromMATLAB throws an error when the 
+            % Valid nv-pair is provided and it contains an invalid index.
+
+            import arrow.array.StructArray
+
+            fcn = @() StructArray.fromMATLAB(table(1), Valid=2);
+            tc.verifyError(fcn, "MATLAB:notLessEqual");
+        end
     end
 end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/tStructTraits.m b/matlab/test/arrow/type/traits/tStructTraits.m
index 07833aca162b5..dad9ec012f3e5 100644
--- a/matlab/test/arrow/type/traits/tStructTraits.m
+++ b/matlab/test/arrow/type/traits/tStructTraits.m
@@ -20,7 +20,7 @@
         ArrayConstructor = @arrow.array.StructArray
         ArrayClassName = "arrow.array.StructArray"
         ArrayProxyClassName = "arrow.array.proxy.StructArray"
-        ArrayStaticConstructor = missing
+        ArrayStaticConstructor = @arrow.array.StructArray.fromMATLAB
         TypeConstructor = @arrow.type.StructType
         TypeClassName = "arrow.type.StructType"
         TypeProxyClassName = "arrow.type.proxy.StructType"
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index 2880645f2957c..d2d80b3f8f8f5 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -365,6 +365,17 @@ function TestMatlabDuration(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestMatlabTable(testCase)
+            import arrow.type.traits.*
+
+            type = "table";
+            expectedTraits = StructTraits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestErrorIfUnsupportedMatlabClass(testCase)
             import arrow.type.traits.*
 

From 57e9386d4a3a18dfa3c5269c49efaee93aabea2b Mon Sep 17 00:00:00 2001
From: Erik McKelvey <Erik.McKelvey.is@gmail.com>
Date: Tue, 3 Oct 2023 17:43:21 -0700
Subject: [PATCH 453/749] MINOR: [Python][Docs] Fix two typos in data.rst
 (#37997)

### What changes are included in this PR?

Fixed two minor typos in data.rst

Authored-by: Erik McKelvey <Erik.McKelvey.is@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/python/data.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/source/python/data.rst b/docs/source/python/data.rst
index 75d1e88970c29..0ce2ddd698414 100644
--- a/docs/source/python/data.rst
+++ b/docs/source/python/data.rst
@@ -216,7 +216,7 @@ value during the conversion. If an integer input is supplied to
 
 To handle better compatibility with Pandas, we support interpreting NaN values as
 null elements. This is enabled automatically on all ``from_pandas`` function and
-can be enable on the other conversion functions by passing ``from_pandas=True``
+can be enabled on the other conversion functions by passing ``from_pandas=True``
 as a function parameter.
 
 List arrays
@@ -510,7 +510,7 @@ a new schema and cast the data to this schema:
    t2.schema.field("f1").metadata
    t2.schema.metadata
 
-Metadata key and value pair are ``std::string`` objects in the C++ implementation
+Metadata key and value pairs are ``std::string`` objects in the C++ implementation
 and so they are bytes objects (``b'...'``) in Python.
 
 Record Batch Readers

From 532ab464db39da0e6b03e4b046355e7bf499730a Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Wed, 4 Oct 2023 11:00:50 +0100
Subject: [PATCH 454/749] MINOR: [R] Skip tests which use with_language() on
 CRAN  (#37810)

### Rationale for this change

Tests which use `with_language()` are failing on CRAN

### What changes are included in this PR?

Skip those tests on CRAN for now until we find the source of the problem

### Are these changes tested?

No

### Are there any user-facing changes?

No

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/tests/testthat/helper-arrow.R | 1 +
 1 file changed, 1 insertion(+)

diff --git a/r/tests/testthat/helper-arrow.R b/r/tests/testthat/helper-arrow.R
index 6812a3eec0a4e..8d39f7252ee21 100644
--- a/r/tests/testthat/helper-arrow.R
+++ b/r/tests/testthat/helper-arrow.R
@@ -34,6 +34,7 @@ Sys.setenv(LANGUAGE = "en")
 options(arrow.pull_as_vector = FALSE)
 
 with_language <- function(lang, expr) {
+  skip_on_cran()
   old <- Sys.getenv("LANGUAGE")
   # Check what this message is before changing languages; this will
   # trigger caching the transations if the OS does that (some do).

From 0abb672a23a8de520154e7b8d25f9eda96e217da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 4 Oct 2023 16:39:59 +0200
Subject: [PATCH 455/749] GH-37999: [CI][Archery] Install python3-dev on ARM
 jobs to have access to Python.h (#38009)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
Currently CI on ARM is failing due to ruamel.yaml requiring Python.h

### What changes are included in this PR?

Install python3-dev

### Are these changes tested?

Yes, CI
### Are there any user-facing changes?

No
* Closes: #37999

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 .github/workflows/cpp.yml | 3 ++-
 .github/workflows/go.yml  | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index fc8d0bad58e9f..5451cbe064b59 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -108,7 +108,8 @@ jobs:
           restore-keys: ${{ matrix.image }}-
       - name: Setup Python
         run: |
-          sudo apt install -y --no-install-recommends python3 python3-pip
+          sudo apt update
+          sudo apt install -y --no-install-recommends python3 python3-dev python3-pip
       - name: Setup Archery
         run: python3 -m pip install -e dev/archery[docker]
       - name: Execute Docker Build
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index ad8fedb9bd9e4..a0dfb9fea1673 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -79,7 +79,8 @@ jobs:
           submodules: recursive
       - name: Setup Python
         run: |
-          sudo apt install -y --no-install-recommends python3 python3-pip
+          sudo apt update
+          sudo apt install -y --no-install-recommends python3 python3-dev python3-pip
       - name: Setup Archery
         run: python3 -m pip install -e dev/archery[docker]
       - name: Execute Docker Build

From 02de3c1789460304e958936b78d60f824921c250 Mon Sep 17 00:00:00 2001
From: Eero Lihavainen <eeelliha@gmail.com>
Date: Wed, 4 Oct 2023 17:52:04 +0300
Subject: [PATCH 456/749] GH-37917: [Parquet] Add OpenAsync for FileSource
 (#37918)

### Rationale for this change

Improves performance of file reads with an expensive Open operation.

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?
No

* Closes: #37917

Authored-by: Eero Lihavainen <eero.lihavainen@nitor.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/dataset/file_base.cc    | 14 ++++++++
 cpp/src/arrow/dataset/file_base.h     |  1 +
 cpp/src/arrow/dataset/file_parquet.cc | 50 +++++++++++++++------------
 3 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/cpp/src/arrow/dataset/file_base.cc b/cpp/src/arrow/dataset/file_base.cc
index 2fcd57d2f3622..6a97b51cf2815 100644
--- a/cpp/src/arrow/dataset/file_base.cc
+++ b/cpp/src/arrow/dataset/file_base.cc
@@ -81,6 +81,20 @@ Result<std::shared_ptr<io::RandomAccessFile>> FileSource::Open() const {
   return custom_open_();
 }
 
+Future<std::shared_ptr<io::RandomAccessFile>> FileSource::OpenAsync() const {
+  if (filesystem_) {
+    return filesystem_->OpenInputFileAsync(file_info_);
+  }
+
+  if (buffer_) {
+    return Future<std::shared_ptr<io::RandomAccessFile>>::MakeFinished(
+        std::make_shared<io::BufferReader>(buffer_));
+  }
+
+  // TODO(GH-37962): custom_open_ should not block
+  return Future<std::shared_ptr<io::RandomAccessFile>>::MakeFinished(custom_open_());
+}
+
 int64_t FileSource::Size() const {
   if (filesystem_) {
     return file_info_.size();
diff --git a/cpp/src/arrow/dataset/file_base.h b/cpp/src/arrow/dataset/file_base.h
index d33d88e9966fe..46fc8ebc40db0 100644
--- a/cpp/src/arrow/dataset/file_base.h
+++ b/cpp/src/arrow/dataset/file_base.h
@@ -115,6 +115,7 @@ class ARROW_DS_EXPORT FileSource : public util::EqualityComparable<FileSource> {
 
   /// \brief Get a RandomAccessFile which views this file source
   Result<std::shared_ptr<io::RandomAccessFile>> Open() const;
+  Future<std::shared_ptr<io::RandomAccessFile>> OpenAsync() const;
 
   /// \brief Get the size (in bytes) of the file or buffer
   /// If the file is compressed this should be the compressed (on-disk) size.
diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index 751937e93b937..3cad1ddd8321f 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -479,29 +479,35 @@ Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
                                                          default_fragment_scan_options));
   auto properties =
       MakeReaderProperties(*this, parquet_scan_options.get(), options->pool);
-  ARROW_ASSIGN_OR_RAISE(auto input, source.Open());
-  // TODO(ARROW-12259): workaround since we have Future<(move-only type)>
-  auto reader_fut = parquet::ParquetFileReader::OpenAsync(
-      std::move(input), std::move(properties), metadata);
-  auto path = source.path();
+
   auto self = checked_pointer_cast<const ParquetFileFormat>(shared_from_this());
-  return reader_fut.Then(
-      [=](const std::unique_ptr<parquet::ParquetFileReader>&) mutable
-      -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
-        ARROW_ASSIGN_OR_RAISE(std::unique_ptr<parquet::ParquetFileReader> reader,
-                              reader_fut.MoveResult());
-        std::shared_ptr<parquet::FileMetaData> metadata = reader->metadata();
-        auto arrow_properties =
-            MakeArrowReaderProperties(*this, *metadata, *options, *parquet_scan_options);
-        std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
-        RETURN_NOT_OK(parquet::arrow::FileReader::Make(options->pool, std::move(reader),
-                                                       std::move(arrow_properties),
-                                                       &arrow_reader));
-        return std::move(arrow_reader);
-      },
-      [path](
-          const Status& status) -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
-        return WrapSourceError(status, path);
+
+  return source.OpenAsync().Then(
+      [=](const std::shared_ptr<io::RandomAccessFile>& input) mutable {
+        return parquet::ParquetFileReader::OpenAsync(input, std::move(properties),
+                                                     metadata)
+            .Then(
+                [=](const std::unique_ptr<parquet::ParquetFileReader>& reader) mutable
+                -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
+                  auto arrow_properties = MakeArrowReaderProperties(
+                      *self, *reader->metadata(), *options, *parquet_scan_options);
+
+                  std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
+                  RETURN_NOT_OK(parquet::arrow::FileReader::Make(
+                      options->pool,
+                      // TODO(ARROW-12259): workaround since we have Future<(move-only
+                      // type)> It *wouldn't* be safe to const_cast reader except that
+                      // here we know there are no other waiters on the reader.
+                      std::move(const_cast<std::unique_ptr<parquet::ParquetFileReader>&>(
+                          reader)),
+                      std::move(arrow_properties), &arrow_reader));
+
+                  return std::move(arrow_reader);
+                },
+                [path = source.path()](const Status& status)
+                    -> Result<std::shared_ptr<parquet::arrow::FileReader>> {
+                  return WrapSourceError(status, path);
+                });
       });
 }
 

From 7d834d65c37c17d1c19bfb497eadb983893c9ea0 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 5 Oct 2023 09:21:56 +0200
Subject: [PATCH 457/749] GH-36709: [Python] Allow to specify use_threads=False
 in Table.group_by to have stable ordering (#36768)

### Rationale for this change

Add a `use_threads` keyword to the `group_by` method on Table, and passes this through to the Declaration.to_table call. This also allows to specify `use_threads=False` to get stable ordering of the output, and which is also required to specify for certain aggregations (eg `"first"` will fail with the default of `use_threads=True`)

### Are these changes tested?

Yes, added a test (similar to the one we have for this for `filter`), that would fail (>50% of the times) if the output was no longer ordered.

* Closes: #36709

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/acero.py                |  4 ++--
 python/pyarrow/table.pxi               | 20 +++++++++++++++-----
 python/pyarrow/tests/test_exec_plan.py | 14 ++++++++++++++
 python/pyarrow/tests/test_table.py     | 15 +++++++++++++++
 4 files changed, 46 insertions(+), 7 deletions(-)

diff --git a/python/pyarrow/acero.py b/python/pyarrow/acero.py
index 63da0a37864b2..0609e45753f0d 100644
--- a/python/pyarrow/acero.py
+++ b/python/pyarrow/acero.py
@@ -299,10 +299,10 @@ def _sort_source(table_or_dataset, sort_keys, output_type=Table, **kwargs):
         raise TypeError("Unsupported output type")
 
 
-def _group_by(table, aggregates, keys):
+def _group_by(table, aggregates, keys, use_threads=True):
 
     decl = Declaration.from_sequence([
         Declaration("table_source", TableSourceNodeOptions(table)),
         Declaration("aggregate", AggregateNodeOptions(aggregates, keys=keys))
     ])
-    return decl.to_table(use_threads=True)
+    return decl.to_table(use_threads=use_threads)
diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index 2eae38485dca4..36601130b3f12 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -4599,8 +4599,9 @@ cdef class Table(_Tabular):
         """
         return self.drop_columns(columns)
 
-    def group_by(self, keys):
-        """Declare a grouping over the columns of the table.
+    def group_by(self, keys, use_threads=True):
+        """
+        Declare a grouping over the columns of the table.
 
         Resulting grouping can then be used to perform aggregations
         with a subsequent ``aggregate()`` method.
@@ -4609,6 +4610,9 @@ cdef class Table(_Tabular):
         ----------
         keys : str or list[str]
             Name of the columns that should be used as the grouping key.
+        use_threads : bool, default True
+            Whether to use multithreading or not. When set to True (the
+            default), no stable ordering of the output is guaranteed.
 
         Returns
         -------
@@ -4635,7 +4639,7 @@ cdef class Table(_Tabular):
         year: [[2020,2022,2021,2019]]
         n_legs_sum: [[2,6,104,5]]
         """
-        return TableGroupBy(self, keys)
+        return TableGroupBy(self, keys, use_threads=use_threads)
 
     def join(self, right_table, keys, right_keys=None, join_type="left outer",
              left_suffix=None, right_suffix=None, coalesce_keys=True,
@@ -5183,6 +5187,9 @@ class TableGroupBy:
         Input table to execute the aggregation on.
     keys : str or list[str]
         Name of the grouped columns.
+    use_threads : bool, default True
+        Whether to use multithreading or not. When set to True (the default),
+        no stable ordering of the output is guaranteed.
 
     Examples
     --------
@@ -5208,12 +5215,13 @@ class TableGroupBy:
     values_sum: [[3,7,5]]
     """
 
-    def __init__(self, table, keys):
+    def __init__(self, table, keys, use_threads=True):
         if isinstance(keys, str):
             keys = [keys]
 
         self._table = table
         self.keys = keys
+        self._use_threads = use_threads
 
     def aggregate(self, aggregations):
         """
@@ -5328,4 +5336,6 @@ list[tuple(str, str, FunctionOptions)]
                 aggr_name = "_".join(target) + "_" + func_nohash
             group_by_aggrs.append((target, func, opt, aggr_name))
 
-        return _pac()._group_by(self._table, group_by_aggrs, self.keys)
+        return _pac()._group_by(
+            self._table, group_by_aggrs, self.keys, use_threads=self._use_threads
+        )
diff --git a/python/pyarrow/tests/test_exec_plan.py b/python/pyarrow/tests/test_exec_plan.py
index 58c618179b601..d85a2c2152481 100644
--- a/python/pyarrow/tests/test_exec_plan.py
+++ b/python/pyarrow/tests/test_exec_plan.py
@@ -321,3 +321,17 @@ def test_join_extension_array_column():
     result = _perform_join(
         "left outer", t1, ["colB"], t3, ["colC"])
     assert result["colB"] == pa.chunked_array(ext_array)
+
+
+def test_group_by_ordering():
+    # GH-36709 - preserve ordering in groupby by setting use_threads=False
+    table1 = pa.table({'a': [1, 2, 3, 4], 'b': ['a'] * 4})
+    table2 = pa.table({'a': [1, 2, 3, 4], 'b': ['b'] * 4})
+    table = pa.concat_tables([table1, table2])
+
+    for _ in range(50):
+        # 50 seems to consistently cause errors when order is not preserved.
+        # If the order problem is reintroduced this test will become flaky
+        # which is still a signal that the order is not preserved.
+        result = table.group_by("b", use_threads=False).aggregate([])
+        assert result["b"] == pa.chunked_array([["a"], ["b"]])
diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py
index f93c6bbc2c204..b9e0d692196fb 100644
--- a/python/pyarrow/tests/test_table.py
+++ b/python/pyarrow/tests/test_table.py
@@ -2175,6 +2175,21 @@ def sorted_by_keys(d):
     }
 
 
+@pytest.mark.acero
+def test_table_group_by_first():
+    # "first" is an ordered aggregation -> requires to specify use_threads=False
+    table1 = pa.table({'a': [1, 2, 3, 4], 'b': ['a', 'b'] * 2})
+    table2 = pa.table({'a': [1, 2, 3, 4], 'b': ['b', 'a'] * 2})
+    table = pa.concat_tables([table1, table2])
+
+    with pytest.raises(NotImplementedError):
+        table.group_by("b").aggregate([("a", "first")])
+
+    result = table.group_by("b", use_threads=False).aggregate([("a", "first")])
+    expected = pa.table({"b": ["a", "b"], "a_first": [1, 2]})
+    assert result.equals(expected)
+
+
 def test_table_to_recordbatchreader():
     table = pa.Table.from_pydict({'x': [1, 2, 3]})
     reader = table.to_reader()

From 41705f9eca36e667fe66607a470b31e3c5c03ffe Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 5 Oct 2023 10:00:48 +0200
Subject: [PATCH 458/749] GH-35600: [Python] Allow setting path to timezone db
 through python API (#37436)

### Rationale for this change

Add a function to change the path where timezone db should be found as a small wrapper around the setting of a C++ option `GlobalOptions`.

### What changes are included in this PR?

New function `configure_tzdb`.

### Are these changes tested?

### Are there any user-facing changes?

No.
* Closes: #35600

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 ci/appveyor-cpp-build.bat            | 13 +++++++++++++
 python/pyarrow/__init__.py           |  8 ++++----
 python/pyarrow/config.pxi            | 19 +++++++++++++++++++
 python/pyarrow/includes/libarrow.pxd |  5 +++++
 python/pyarrow/tests/conftest.py     |  7 +++++++
 python/pyarrow/tests/test_misc.py    | 12 ++++++++++++
 python/pyarrow/tests/util.py         | 10 ++++++++--
 7 files changed, 68 insertions(+), 6 deletions(-)

diff --git a/ci/appveyor-cpp-build.bat b/ci/appveyor-cpp-build.bat
index e69c7bf2516d9..5e561a0461ea3 100644
--- a/ci/appveyor-cpp-build.bat
+++ b/ci/appveyor-cpp-build.bat
@@ -132,6 +132,19 @@ set ARROW_HOME=%CONDA_PREFIX%\Library
 @rem ARROW-3075; pkgconfig is broken for Parquet for now
 set PARQUET_HOME=%CONDA_PREFIX%\Library
 
+@rem Download IANA Timezone Database to a non-standard location to
+@rem test the configurability of the timezone database path
+curl https://data.iana.org/time-zones/releases/tzdata2021e.tar.gz --output tzdata.tar.gz || exit /B
+mkdir %USERPROFILE%\Downloads\test\tzdata
+tar --extract --file tzdata.tar.gz --directory %USERPROFILE%\Downloads\test\tzdata
+curl https://raw.githubusercontent.com/unicode-org/cldr/master/common/supplemental/windowsZones.xml ^
+  --output %USERPROFILE%\Downloads\test\tzdata\windowsZones.xml || exit /B
+@rem Remove the database from the default location
+rmdir /s /q %USERPROFILE%\Downloads\tzdata
+@rem Set the env var for the non-standard location of the database
+@rem (only needed for testing purposes)
+set PYARROW_TZDATA_PATH=%USERPROFILE%\Downloads\test\tzdata
+
 python setup.py develop -q || exit /B
 
 set PYTHONDEVMODE=1
diff --git a/python/pyarrow/__init__.py b/python/pyarrow/__init__.py
index ee0d07bb2c811..cd66abcb44840 100644
--- a/python/pyarrow/__init__.py
+++ b/python/pyarrow/__init__.py
@@ -66,10 +66,10 @@ def parse_git(root, **kwargs):
 if _gc_enabled:
     _gc.enable()
 
-from pyarrow.lib import (BuildInfo, RuntimeInfo, MonthDayNano,
-                         VersionInfo, cpp_build_info, cpp_version,
-                         cpp_version_info, runtime_info, cpu_count,
-                         set_cpu_count, enable_signal_handlers,
+from pyarrow.lib import (BuildInfo, RuntimeInfo, set_timezone_db_path,
+                         MonthDayNano, VersionInfo, cpp_build_info,
+                         cpp_version, cpp_version_info, runtime_info,
+                         cpu_count, set_cpu_count, enable_signal_handlers,
                          io_thread_count, set_io_thread_count)
 
 
diff --git a/python/pyarrow/config.pxi b/python/pyarrow/config.pxi
index fb9526ba89735..cf751b810cad1 100644
--- a/python/pyarrow/config.pxi
+++ b/python/pyarrow/config.pxi
@@ -18,6 +18,7 @@
 from pyarrow.includes.libarrow cimport GetBuildInfo
 
 from collections import namedtuple
+import os
 
 
 VersionInfo = namedtuple('VersionInfo', ('major', 'minor', 'patch'))
@@ -74,3 +75,21 @@ def runtime_info():
     return RuntimeInfo(
         simd_level=frombytes(c_info.simd_level),
         detected_simd_level=frombytes(c_info.detected_simd_level))
+
+
+def set_timezone_db_path(path):
+    """
+    Configure the path to text timezone database on Windows.
+
+    Parameters
+    ----------
+    path : str
+        Path to text timezone database.
+    """
+    cdef:
+        CGlobalOptions options
+
+    if path is not None:
+        options.timezone_db_path = <c_string>tobytes(path)
+
+    check_status(Initialize(options))
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index f4d6541fa724c..482a6e91ba929 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -80,6 +80,11 @@ cdef extern from "arrow/config.h" namespace "arrow" nogil:
 
     CRuntimeInfo GetRuntimeInfo()
 
+    cdef cppclass CGlobalOptions" arrow::GlobalOptions":
+        optional[c_string] timezone_db_path
+
+    CStatus Initialize(const CGlobalOptions& options)
+
 
 cdef extern from "arrow/util/future.h" namespace "arrow" nogil:
     cdef cppclass CFuture_Void" arrow::Future<>":
diff --git a/python/pyarrow/tests/conftest.py b/python/pyarrow/tests/conftest.py
index 241ae4814a5ae..a5941e8c8d1a8 100644
--- a/python/pyarrow/tests/conftest.py
+++ b/python/pyarrow/tests/conftest.py
@@ -28,6 +28,7 @@
 import hypothesis as h
 from ..conftest import groups, defaults
 
+from pyarrow import set_timezone_db_path
 from pyarrow.util import find_free_port
 
 
@@ -48,6 +49,12 @@
 os.environ['AWS_CONFIG_FILE'] = "/dev/null"
 
 
+if sys.platform == 'win32':
+    tzdata_set_path = os.environ.get('PYARROW_TZDATA_PATH', None)
+    if tzdata_set_path:
+        set_timezone_db_path(tzdata_set_path)
+
+
 def pytest_addoption(parser):
     # Create options to selectively enable test groups
     def bool_env(name, default=None):
diff --git a/python/pyarrow/tests/test_misc.py b/python/pyarrow/tests/test_misc.py
index 86cbf013cd5b4..9b9dfdd554806 100644
--- a/python/pyarrow/tests/test_misc.py
+++ b/python/pyarrow/tests/test_misc.py
@@ -22,6 +22,7 @@
 import pytest
 
 import pyarrow as pa
+from pyarrow.lib import ArrowInvalid
 
 
 def test_get_include():
@@ -116,6 +117,17 @@ def test_runtime_info():
         subprocess.check_call([sys.executable, "-c", code], env=env)
 
 
+@pytest.mark.skipif(sys.platform == "win32",
+                    reason="Path to timezone database is not configurable "
+                           "on non-Windows platforms")
+def test_set_timezone_db_path_non_windows():
+    # set_timezone_db_path raises an error on non-Windows platforms
+    with pytest.raises(ArrowInvalid,
+                       match="Arrow was set to use OS timezone "
+                             "database at compile time"):
+        pa.set_timezone_db_path("path")
+
+
 @pytest.mark.parametrize('klass', [
     pa.Field,
     pa.Schema,
diff --git a/python/pyarrow/tests/util.py b/python/pyarrow/tests/util.py
index 0b69deb73ba28..638eee9807335 100644
--- a/python/pyarrow/tests/util.py
+++ b/python/pyarrow/tests/util.py
@@ -455,5 +455,11 @@ def windows_has_tzdata():
     This is the default location where tz.cpp will look for (until we make
     this configurable at run-time)
     """
-    tzdata_path = os.path.expandvars(r"%USERPROFILE%\Downloads\tzdata")
-    return os.path.exists(tzdata_path)
+    tzdata_bool = False
+    if "PYARROW_TZDATA_PATH" in os.environ:
+        tzdata_bool = os.path.exists(os.environ['PYARROW_TZDATA_PATH'])
+    if not tzdata_bool:
+        tzdata_path = os.path.expandvars(r"%USERPROFILE%\Downloads\tzdata")
+        tzdata_bool = os.path.exists(tzdata_path)
+
+    return tzdata_bool

From 334c93726f3c9d9e69eb51136c7f354974c739fd Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 5 Oct 2023 11:02:23 +0200
Subject: [PATCH 459/749] GH-37598: [Python][Interchange Protocol] Fix the
 from_dataframe implementation to use the column dtype (#37986)

### Rationale for this change

We have been defining buffer dtypes for string and timestamp types incorrectly in the DataFrame Interchange Protocol implementation. This PR is the first step to fix the error and is dealing with the `from_dataframe` part. The next two steps to solve the connected issue are:

2. Make sure other libraries have also updated their `from_dataframe` implementation
3. Fix the data buffer dtypes for strings and timestamps.

### What changes are included in this PR?

Fix the `from_dataframe` implementation to use the column dtype rather than the data buffer dtype to interpret the buffers. Only for the indices of the categorical column we still use buffer data type in order to convert the indices when constructing the `DictionaryArray`.

### Are these changes tested?

No new tests are added but all the existing tests should pass and with that the stability of the change is tested.

### Are there any user-facing changes?

No.
* Closes: #37598

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/interchange/from_dataframe.py | 23 +++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/python/pyarrow/interchange/from_dataframe.py b/python/pyarrow/interchange/from_dataframe.py
index 1d41aa8d7eef3..d653054e910a6 100644
--- a/python/pyarrow/interchange/from_dataframe.py
+++ b/python/pyarrow/interchange/from_dataframe.py
@@ -19,6 +19,7 @@
 
 from typing import (
     Any,
+    Tuple,
 )
 
 from pyarrow.interchange.column import (
@@ -204,7 +205,9 @@ def column_to_array(
     pa.Array
     """
     buffers = col.get_buffers()
-    data = buffers_to_array(buffers, col.size(),
+    data_type = col.dtype
+    data = buffers_to_array(buffers, data_type,
+                            col.size(),
                             col.describe_null,
                             col.offset,
                             allow_copy)
@@ -236,7 +239,9 @@ def bool_column_to_array(
         )
 
     buffers = col.get_buffers()
-    data = buffers_to_array(buffers, col.size(),
+    data_type = col.dtype
+    data = buffers_to_array(buffers, data_type,
+                            col.size(),
                             col.describe_null,
                             col.offset)
     data = pc.cast(data, pa.bool_())
@@ -274,11 +279,15 @@ def categorical_column_to_dictionary(
         raise NotImplementedError(
             "Non-dictionary categoricals not supported yet")
 
+    # We need to first convert the dictionary column
     cat_column = categorical["categories"]
     dictionary = column_to_array(cat_column)
-
+    # Then we need to convert the indices
+    # Here we need to use the buffer data type!
     buffers = col.get_buffers()
-    indices = buffers_to_array(buffers, col.size(),
+    _, data_type = buffers["data"]
+    indices = buffers_to_array(buffers, data_type,
+                               col.size(),
                                col.describe_null,
                                col.offset)
 
@@ -326,6 +335,7 @@ def map_date_type(data_type):
 
 def buffers_to_array(
     buffers: ColumnBuffers,
+    data_type: Tuple[DtypeKind, int, str, str],
     length: int,
     describe_null: ColumnNullType,
     offset: int = 0,
@@ -339,6 +349,9 @@ def buffers_to_array(
     buffer : ColumnBuffers
         Dictionary containing tuples of underlying buffers and
         their associated dtype.
+    data_type : Tuple[DtypeKind, int, str, str],
+        Dtype description of the column as a tuple ``(kind, bit-width, format string,
+        endianness)``.
     length : int
         The number of values in the array.
     describe_null: ColumnNullType
@@ -360,7 +373,7 @@ def buffers_to_array(
     is responsible for keeping the memory owner object alive as long as
     the returned PyArrow array is being used.
     """
-    data_buff, data_type = buffers["data"]
+    data_buff, _ = buffers["data"]
     try:
         validity_buff, validity_dtype = buffers["validity"]
     except TypeError:

From 2360cb92e71c88a66a2808c7b4cc50dc6660cb10 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 5 Oct 2023 13:56:15 +0200
Subject: [PATCH 460/749] GH-32483: [Docs][Python] Clarify you need to use
 conda-forge for installing nightly conda package (#37948)

### Rationale for this change

Our nightly packages don't work with the defaults channel from Anaconda.

* Closes: #32483

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/developers/python.rst | 3 +++
 docs/source/python/install.rst    | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/docs/source/developers/python.rst b/docs/source/developers/python.rst
index 23bbb835a3044..e4699a65e211e 100644
--- a/docs/source/developers/python.rst
+++ b/docs/source/developers/python.rst
@@ -717,6 +717,9 @@ Install the development version of PyArrow from `arrow-nightlies
 
     conda install -c arrow-nightlies pyarrow
 
+Note that this requires to use the ``conda-forge`` channel for all other
+packages (``conda config --add channels conda-forge``).
+
 Install the development version from an `alternative PyPI
 <https://gemfury.com/arrow-nightlies>`_ index:
 
diff --git a/docs/source/python/install.rst b/docs/source/python/install.rst
index ef4353415fa21..99d1c43b024aa 100644
--- a/docs/source/python/install.rst
+++ b/docs/source/python/install.rst
@@ -56,8 +56,8 @@ need to install the `Visual C++ Redistributable for Visual Studio 2015
 .. warning::
    On Linux, you will need pip >= 19.0 to detect the prebuilt binary packages.
 
-Installing from source
-----------------------
+Installing nightly packages or from source
+------------------------------------------
 
 See :ref:`python-development`.
 

From 0fbfffbf42a42577c4855cfdd232cf069e76ae87 Mon Sep 17 00:00:00 2001
From: Adam Reeve <adreeve@gmail.com>
Date: Fri, 6 Oct 2023 01:44:17 +1300
Subject: [PATCH 461/749] GH-38039: [C++][Parquet] Fix segfault getting
 compression level for a Parquet column (#38025)

### Rationale for this change

After the changes in #35886, getting the compression level for a Parquet column segfaults if the compression level or other options weren't previously set

### What changes are included in this PR?

Adds a null check on the codec options of the column  properties before trying to access the compression level.

### Are these changes tested?

Yes, I added a unit test.

### Are there any user-facing changes?

This fixes a regression added after 13.0.0 so isn't a user-facing fix
* Closes: #38039

Authored-by: Adam Reeve <adreeve@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/properties.h       | 7 ++++++-
 cpp/src/parquet/properties_test.cc | 9 +++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index bdc5b15332d09..9344181d3f82f 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -196,7 +196,12 @@ class PARQUET_EXPORT ColumnProperties {
 
   size_t max_statistics_size() const { return max_stats_size_; }
 
-  int compression_level() const { return codec_options_->compression_level; }
+  int compression_level() const {
+    if (!codec_options_) {
+      return ::arrow::util::kUseDefaultCompressionLevel;
+    }
+    return codec_options_->compression_level;
+  }
 
   const std::shared_ptr<CodecOptions>& codec_options() const { return codec_options_; }
 
diff --git a/cpp/src/parquet/properties_test.cc b/cpp/src/parquet/properties_test.cc
index 96c3a63b831eb..b2c574413abf7 100644
--- a/cpp/src/parquet/properties_test.cc
+++ b/cpp/src/parquet/properties_test.cc
@@ -49,6 +49,15 @@ TEST(TestWriterProperties, Basics) {
   ASSERT_FALSE(props->page_checksum_enabled());
 }
 
+TEST(TestWriterProperties, DefaultCompression) {
+  std::shared_ptr<WriterProperties> props = WriterProperties::Builder().build();
+
+  ASSERT_EQ(props->compression(ColumnPath::FromDotString("any")),
+            Compression::UNCOMPRESSED);
+  ASSERT_EQ(props->compression_level(ColumnPath::FromDotString("any")),
+            ::arrow::util::kUseDefaultCompressionLevel);
+}
+
 TEST(TestWriterProperties, AdvancedHandling) {
   WriterProperties::Builder builder;
   builder.compression("gzip", Compression::GZIP);

From dd8734dc8ff21e7f8463b239e800aeac0ddcb764 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Thu, 5 Oct 2023 14:48:44 +0200
Subject: [PATCH 462/749] GH-37923: [R] Move macOS build system to nixlibs.R
 (#37684)

This PR modifies the build system of the R package to no longer rely on auto/homebrew. Instead this PR adds the infrastructure and code paths to use the same type of  pre-compiled libarrow binaries as we use for Linux. The main difference is the use of the binaries even on CRAN (as we previously also used binaries in form of brew bottles).

The addition of the new artifacts to tasks.yml should ensure that they get uploaded to the nightly repo as well as to the artifactory during the release (@ kou please confirm).

A summary of the changes in this PR:
- update `r/configure` and `r/tools/nixlibs.R` to enable the source build on macOS and usage of precompiled binaries using the existing mechanism to test compile a program to detect the exisitng openssl version
- added tests for the changes in nixlibs.R
- update the binary allow-list
- Add the build jobs for libarrow binaries for arm64 and x86_64 macos with openssl 1.1 and 3.0 to the `r-binary-packages` job
- Use the binaries to build the nightly packages
- bump snappy version to 1.1.10 (and patch it on 10.13) due to build issues with the current version. This also touches on a number of issues in regards to a sanitizer issue we have had for a long time: #32562 #31766
- Disable the centos binary test step: #37922

Follow up issues:
- #37921
- #37941
- #37945
* Closes: #37923

Lead-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 cpp/Brewfile                                |  6 ++
 cpp/cmake_modules/SetupCxxFlags.cmake       | 15 +++-
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 21 ++++++
 cpp/cmake_modules/snappy.diff               | 12 +++
 cpp/thirdparty/versions.txt                 |  5 +-
 dev/release/rat_exclude_files.txt           |  1 +
 dev/tasks/macros.jinja                      | 14 +++-
 dev/tasks/r/github.packages.yml             | 83 +++++++++++++++++---
 dev/tasks/tasks.yml                         |  4 +
 r/configure                                 | 55 ++------------
 r/tools/nixlibs-allowlist.txt               |  1 +
 r/tools/nixlibs.R                           | 84 ++++++++++++++++-----
 r/tools/test-nixlibs.R                      | 64 +++++++++++++---
 13 files changed, 268 insertions(+), 97 deletions(-)
 create mode 100644 cpp/cmake_modules/snappy.diff

diff --git a/cpp/Brewfile b/cpp/Brewfile
index 58015d2121b5b..0f5527985364c 100644
--- a/cpp/Brewfile
+++ b/cpp/Brewfile
@@ -19,7 +19,9 @@ brew "aws-sdk-cpp"
 brew "bash"
 brew "boost"
 brew "brotli"
+brew "bzip2"
 brew "c-ares"
+brew "curl"
 brew "ccache"
 brew "cmake"
 brew "flatbuffers"
@@ -29,14 +31,18 @@ brew "googletest"
 brew "grpc"
 brew "llvm@14"
 brew "lz4"
+brew "mimalloc"
 brew "ninja"
 brew "node"
 brew "openssl@3"
+brew "pkg-config"
 brew "protobuf"
 brew "python"
 brew "rapidjson"
+brew "re2"
 brew "snappy"
 brew "thrift"
+brew "utf8proc"
 brew "wget"
 brew "xsimd"
 brew "zstd"
diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index 5531415ac2277..e90c00612caa3 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -456,11 +456,18 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STRE
   # Don't complain about optimization passes that were not possible
   set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-pass-failed")
 
-  # Avoid clang / libc++ error about C++17 aligned allocation on macOS.
-  # See https://chromium.googlesource.com/chromium/src/+/eee44569858fc650b635779c4e34be5cb0c73186%5E%21/#F0
-  # for details.
   if(APPLE)
-    set(CXX_ONLY_FLAGS "${CXX_ONLY_FLAGS} -fno-aligned-new")
+    # Avoid clang / libc++ error about C++17 aligned allocation on macOS.
+    # See https://chromium.googlesource.com/chromium/src/+/eee44569858fc650b635779c4e34be5cb0c73186%5E%21/#F0
+    # for details.
+    string(APPEND CXX_ONLY_FLAGS " -fno-aligned-new")
+
+    if(CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 20)
+      # Avoid C++17 std::get 'not available' issue on macOS 10.13
+      # This will be required until atleast R 4.4 is released and
+      # CRAN (hopefully) stops checking on 10.13
+      string(APPEND CXX_ONLY_FLAGS " -D_LIBCPP_DISABLE_AVAILABILITY")
+    endif()
   endif()
 endif()
 
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 85c0337d108be..6d6a2bf7751ee 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -1308,6 +1308,26 @@ macro(build_snappy)
   set(SNAPPY_CMAKE_ARGS
       ${EP_COMMON_CMAKE_ARGS} -DSNAPPY_BUILD_TESTS=OFF -DSNAPPY_BUILD_BENCHMARKS=OFF
       "-DCMAKE_INSTALL_PREFIX=${SNAPPY_PREFIX}")
+  # Snappy unconditionaly enables Werror when building with clang this can lead
+  # to build failues by way of new compiler warnings. This adds a flag to disable
+  # Werror to the very end of the invocation to override the snappy internal setting.
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    foreach(CONFIG DEBUG MINSIZEREL RELEASE RELWITHDEBINFO)
+      list(APPEND
+           SNAPPY_CMAKE_ARGS
+           "-DCMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_CXX_FLAGS_${CONFIG}} -Wno-error"
+      )
+    endforeach()
+  endif()
+
+  if(APPLE AND CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 20)
+    # On macOS 10.13 we need to explicitly add <functional> to avoid a missing include error
+    # This can be removed once CRAN no longer checks on macOS 10.13
+    find_program(PATCH patch REQUIRED)
+    set(SNAPPY_PATCH_COMMAND ${PATCH} -p1 -i ${CMAKE_CURRENT_LIST_DIR}/snappy.diff)
+  else()
+    set(SNAPPY_PATCH_COMMAND)
+  endif()
 
   externalproject_add(snappy_ep
                       ${EP_COMMON_OPTIONS}
@@ -1315,6 +1335,7 @@ macro(build_snappy)
                       INSTALL_DIR ${SNAPPY_PREFIX}
                       URL ${SNAPPY_SOURCE_URL}
                       URL_HASH "SHA256=${ARROW_SNAPPY_BUILD_SHA256_CHECKSUM}"
+                      PATCH_COMMAND ${SNAPPY_PATCH_COMMAND}
                       CMAKE_ARGS ${SNAPPY_CMAKE_ARGS}
                       BUILD_BYPRODUCTS "${SNAPPY_STATIC_LIB}")
 
diff --git a/cpp/cmake_modules/snappy.diff b/cpp/cmake_modules/snappy.diff
new file mode 100644
index 0000000000000..f86e2bb19780c
--- /dev/null
+++ b/cpp/cmake_modules/snappy.diff
@@ -0,0 +1,12 @@
+diff --git a/snappy.cc b/snappy.cc
+index d414718..5b0d0d6 100644
+--- a/snappy.cc
++++ b/snappy.cc
+@@ -83,6 +83,7 @@
+ #include <string>
+ #include <utility>
+ #include <vector>
++#include <functional>
+ 
+ namespace snappy {
+ 
diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt
index 52d302592b55c..56163f35d2499 100644
--- a/cpp/thirdparty/versions.txt
+++ b/cpp/thirdparty/versions.txt
@@ -101,9 +101,8 @@ ARROW_RAPIDJSON_BUILD_VERSION=232389d4f1012dddec4ef84861face2d2ba85709
 ARROW_RAPIDJSON_BUILD_SHA256_CHECKSUM=b9290a9a6d444c8e049bd589ab804e0ccf2b05dc5984a19ed5ae75d090064806
 ARROW_RE2_BUILD_VERSION=2022-06-01
 ARROW_RE2_BUILD_SHA256_CHECKSUM=f89c61410a072e5cbcf8c27e3a778da7d6fd2f2b5b1445cd4f4508bee946ab0f
-# 1.1.9 is patched to implement https://github.com/google/snappy/pull/148 if this is bumped, remove the patch
-ARROW_SNAPPY_BUILD_VERSION=1.1.9
-ARROW_SNAPPY_BUILD_SHA256_CHECKSUM=75c1fbb3d618dd3a0483bff0e26d0a92b495bbe5059c8b4f1c962b478b6e06e7
+ARROW_SNAPPY_BUILD_VERSION=1.1.10
+ARROW_SNAPPY_BUILD_SHA256_CHECKSUM=49d831bffcc5f3d01482340fe5af59852ca2fe76c3e05df0e67203ebbe0f1d90
 ARROW_SUBSTRAIT_BUILD_VERSION=v0.27.0
 ARROW_SUBSTRAIT_BUILD_SHA256_CHECKSUM=4ed375f69d972a57fdc5ec406c17003a111831d8640d3f1733eccd4b3ff45628
 ARROW_S2N_TLS_BUILD_VERSION=v1.3.35
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index aebe321d613ab..af084ea215621 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -24,6 +24,7 @@ cpp/build-support/iwyu/*
 cpp/cmake_modules/FindPythonLibsNew.cmake
 cpp/cmake_modules/SnappyCMakeLists.txt
 cpp/cmake_modules/SnappyConfig.h
+cpp/cmake_modules/snappy.diff
 cpp/examples/parquet/parquet-arrow/cmake_modules/FindArrow.cmake
 cpp/src/parquet/.parquetcppversion
 cpp/src/generated/parquet_constants.cpp
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index faf77a1168d1b..54f676fd49cd9 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -307,7 +307,8 @@ on:
   stopifnot(packageVersion("arrow") == {{ '"${{needs.source.outputs.pkg_version}}"' }})
 {% endmacro %}
 
-{%- macro github_setup_local_r_repo(get_nix, get_win) -%}
+{%- macro github_setup_local_r_repo(get_nix, get_win, get_mac=False) -%}
+# TODO: improve arg handling
   - name: Setup local repo
     shell: bash
     run: mkdir repo
@@ -327,6 +328,17 @@ on:
       path: repo/libarrow/bin/linux-openssl-{{ openssl_version }}
     {% endfor %}
   {% endif %}
+  {% if get_mac %}
+    {% for openssl_version in ["1.1", "3.0"] %}
+      {% for arch in ["x86_64", "arm64"] %}
+  - name: Get macOS {{ arch }} OpenSSL {{ openssl_version }} binary
+    uses: actions/download-artifact@v3
+    with:
+      name: r-lib__libarrow__bin__darwin-{{arch}}-openssl-{{ openssl_version }}
+      path: repo/libarrow/bin/darwin-{{ arch }}-openssl-{{ openssl_version }}
+      {% endfor %}
+    {% endfor %}
+  {% endif %}
   - name: Get src pkg
     uses: actions/download-artifact@v3
     with:
diff --git a/dev/tasks/r/github.packages.yml b/dev/tasks/r/github.packages.yml
index dbe21ffb6b160..760e3b6da448d 100644
--- a/dev/tasks/r/github.packages.yml
+++ b/dev/tasks/r/github.packages.yml
@@ -56,6 +56,59 @@ jobs:
           name: r-pkg__src__contrib
           path: arrow/r/arrow_*.tar.gz
 
+  macos-cpp:
+    name: C++ Binary macOS OpenSSL {{ '${{ matrix.openssl }}' }} {{ '${{ matrix.platform.arch }}' }}
+
+    runs-on: {{ '${{ matrix.platform.runs_on }}' }}
+
+    needs: source
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - { runs_on: ["self-hosted", "macos-10.13"], arch: "x86_64" }
+
+          - { runs_on: ["self-hosted", "macOS", "arm64", "devops-managed"], arch: "arm64" }
+        openssl: ['3.0', '1.1']
+
+    steps:
+      {{ macros.github_checkout_arrow(action_v="3")|indent }}
+      {{ macros.github_change_r_pkg_version(is_fork, '${{ needs.source.outputs.pkg_version }}')|indent }}
+      - name: Install Deps
+        if: {{ "${{ !contains(matrix.platform.runs_on, 'macos-10.13') }}" }}
+        run: |
+          brew install sccache ninja
+          brew install openssl@{{ '${{ matrix.openssl }}' }}
+      - name: Build libarrow
+        shell: bash
+        env:
+        {{ macros.github_set_sccache_envvars()|indent(8) }}
+          MACOSX_DEPLOYMENT_TARGET: "10.13"
+          ARROW_S3: ON
+          ARROW_GCS: ON
+          ARROW_DEPENDENCY_SOURCE: BUNDLED
+          CMAKE_GENERATOR: Ninja
+          LIBARROW_MINIMAL: false
+        run: |
+          sccache --start-server
+          export EXTRA_CMAKE_FLAGS="-DOPENSSL_ROOT_DIR=$(brew --prefix openssl@{{ '${{ matrix.openssl }}' }})"
+          cd arrow
+          r/inst/build_arrow_static.sh
+      - name: Bundle libarrow
+        shell: bash
+        env:
+          PKG_FILE: arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip
+          VERSION: {{ '${{ needs.source.outputs.pkg_version }}' }}
+        run: |
+          cd arrow/r/libarrow/dist
+          zip -r $PKG_FILE lib/ include/
+
+      - name: Upload binary artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: r-lib__libarrow__bin__darwin-{{ '${{ matrix.platform.arch }}' }}-openssl-{{ '${{ matrix.openssl }}' }}
+          path: arrow/r/libarrow/dist/arrow-*.zip
+
   linux-cpp:
     name: C++ Binary Linux OpenSSL {{ '${{ matrix.openssl }}' }}
     runs-on: ubuntu-latest
@@ -135,7 +188,7 @@ jobs:
           path: build/arrow-*.zip
 
   r-packages:
-    needs: [source, windows-cpp]
+    needs: [source, windows-cpp, macos-cpp]
     name: {{ '${{ matrix.platform.name }} ${{ matrix.r_version.r }}' }}
     runs-on: {{ '${{ matrix.platform.runs_on }}' }}
     strategy:
@@ -167,7 +220,7 @@ jobs:
 
           rig system setup-user-lib
           rig system add-pak
-      {{ macros.github_setup_local_r_repo(false, true)|indent }}
+      {{ macros.github_setup_local_r_repo(false, true, true)|indent }}
       - name: Prepare Dependency Installation
 
         shell: bash
@@ -178,18 +231,19 @@ jobs:
         with:
            working-directory: 'arrow'
            extra-packages: cpp11
-      - name: Install sccache
-        if: startsWith(matrix.platform, 'macos')
-        run: brew install sccache
+      - name: Set CRAN like openssl
+        if: contains(matrix.platform.runs_on, 'arm64')
+        run: |
+          # The arm64 runners contain openssl 1.1.1t in this path that is always included first so we need to override the
+          # default setting of the brew --prefix as root dir to avoid version conflicts.
+          echo "OPENSSL_ROOT_DIR=/opt/R/arm64" >> $GITHUB_ENV
       - name: Build Binary
         id: build
         shell: Rscript {0}
         env:
-          NOT_CRAN: "true" # actions/setup-r sets this implicitly
+          NOT_CRAN: "false" # actions/setup-r sets this implicitly
           ARROW_R_DEV: "true"
-          FORCE_AUTOBREW: "true" # this is ignored on windows
-          # sccache for macos
-        {{ macros.github_set_sccache_envvars()|indent(8) }}
+          LIBARROW_BINARY: "true" # has to be set as long as allowlist not updated
         run: |
           on_windows <- tolower(Sys.info()[["sysname"]]) == "windows"
 
@@ -213,8 +267,10 @@ jobs:
             INSTALL_opts = INSTALL_opts
           )
 
+
           # Test
           library(arrow)
+          arrow_info()
           read_parquet(system.file("v0.7.1.parquet", package = "arrow"))
 
           # encode contrib.url for artifact name
@@ -233,7 +289,6 @@ jobs:
         with:
           name: r-pkg{{ '${{ steps.build.outputs.path }}' }}
           path: arrow_*
-
   test-linux-binary:
     needs: [source, linux-cpp]
     name: Test binary {{ '${{ matrix.config.image }}' }}
@@ -291,7 +346,10 @@ jobs:
         with:
           name: r-pkg_centos7
           path: arrow_*
+
   test-centos-binary:
+    # arrow binary package not on ppm currently see #37922
+    if: false
     needs: test-linux-binary
     runs-on: ubuntu-latest
     container: "rstudio/r-base:4.2-centos7"
@@ -317,7 +375,8 @@ jobs:
           read_parquet(system.file("v0.7.1.parquet", package = "arrow"))
           print(arrow_info())
 
-  test-source:
+  #TODO test macos source build?
+  test-linux-source:
     needs: source
     name: Test linux source build
     runs-on: ubuntu-latest
@@ -367,7 +426,7 @@ jobs:
 
   upload-binaries:
     # Only upload binaries if all tests pass.
-    needs: [r-packages, test-source, test-linux-binary, test-centos-binary]
+    needs: [r-packages, test-linux-source, test-linux-binary]
     name: Upload artifacts
     runs-on: ubuntu-latest
     steps:
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 859ff8ddb5b44..798932db23323 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -994,6 +994,10 @@ tasks:
       - r-lib__libarrow__bin__linux-openssl-1.0__arrow-{no_rc_r_version}\.zip
       - r-lib__libarrow__bin__linux-openssl-1.1__arrow-{no_rc_r_version}\.zip
       - r-lib__libarrow__bin__linux-openssl-3.0__arrow-{no_rc_r_version}\.zip
+      - r-lib__libarrow__bin__darwin-arm64-openssl-1.1__arrow-{no_rc_r_version}\.zip
+      - r-lib__libarrow__bin__darwin-arm64-openssl-3.0__arrow-{no_rc_r_version}\.zip
+      - r-lib__libarrow__bin__darwin-x86_64-openssl-1.1__arrow-{no_rc_r_version}\.zip
+      - r-lib__libarrow__bin__darwin-x86_64-openssl-3.0__arrow-{no_rc_r_version}\.zip
       - r-pkg__bin__windows__contrib__4.1__arrow_{no_rc_r_version}\.zip
       - r-pkg__bin__windows__contrib__4.2__arrow_{no_rc_r_version}\.zip
       - r-pkg__bin__macosx__contrib__4.1__arrow_{no_rc_r_version}\.tgz
diff --git a/r/configure b/r/configure
index 593f60bbddad9..d244b1a7c148f 100755
--- a/r/configure
+++ b/r/configure
@@ -39,8 +39,8 @@
 #
 # * Installing a released version from source, as from CRAN, with
 #   no other prior setup
-#   * On macOS, autobrew is used to retrieve libarrow and dependencies
-#   * On Linux, the nixlibs.R build script will download or build
+#   * On macOS and Linux, the nixlibs.R build script will download
+#     or build libarrow and dependencies
 # * Installing a released version but first installing libarrow.
 #   It will use pkg-config and brew to search for libraries.
 # * Installing a development version from source as a user.
@@ -65,8 +65,6 @@ PKG_TEST_HEADER="<arrow/api.h>"
 # Some env vars that control the build (all logical, case insensitive)
 # Development mode, also increases verbosity in the bundled build
 ARROW_R_DEV=`echo $ARROW_R_DEV | tr '[:upper:]' '[:lower:]'`
-# autobrew is how mac binaries are built on CRAN; FORCE ensures we use it here
-FORCE_AUTOBREW=`echo $FORCE_AUTOBREW | tr '[:upper:]' '[:lower:]'`
 # The bundled build compiles arrow C++ from source; FORCE ensures we don't pick up
 # any other packages that may be found on the system
 FORCE_BUNDLED_BUILD=`echo $FORCE_BUNDLED_BUILD | tr '[:upper:]' '[:lower:]'`
@@ -141,19 +139,11 @@ fi
 find_or_build_libarrow () {
   if [ "$FORCE_BUNDLED_BUILD" = "true" ]; then
     do_bundled_build
-  elif [ "$FORCE_AUTOBREW" = "true" ]; then
-    do_autobrew
   else
     find_arrow
     if [ "$_LIBARROW_FOUND" = "false" ]; then
       # If we haven't found a suitable version of libarrow, build it
-      if [ "$UNAME" = "Darwin" ] && ! echo $VERSION | grep -q "000"; then
-        # Only autobrew on release version (for testing, use FORCE_AUTOBREW above)
-        # (dev versions end in .9000, and nightly gets something like .10000xxx)
-        do_autobrew
-      else
-        do_bundled_build
-      fi
+      do_bundled_build
     fi
   fi
 }
@@ -175,12 +165,6 @@ find_arrow () {
     # 2. Use pkg-config to find arrow on the system
     _LIBARROW_FOUND="`${PKG_CONFIG} --variable=prefix --silence-errors ${PKG_CONFIG_NAME}`"
     echo "*** Trying Arrow C++ found by pkg-config: $_LIBARROW_FOUND"
-  elif brew --prefix ${PKG_BREW_NAME} > /dev/null 2>&1; then
-    # 3. On macOS, look for Homebrew apache-arrow
-    #    (note that if you have pkg-config, homebrew arrow may have already been found)
-    _LIBARROW_FOUND=`brew --prefix ${PKG_BREW_NAME}`
-    echo "*** Trying Arrow C++ found by Homebrew: ${_LIBARROW_FOUND}"
-    export PKG_CONFIG_PATH="${_LIBARROW_FOUND}/lib/pkgconfig${PKG_CONFIG_PATH:+:${PKG_CONFIG_PATH}}"
   else
     _LIBARROW_FOUND="false"
   fi
@@ -247,34 +231,6 @@ do_bundled_build () {
   fi
 }
 
-do_autobrew () {
-  echo "*** Downloading ${PKG_BREW_NAME}"
-
-  # Setup for local autobrew testing
-  if [ -f "tools/apache-arrow.rb" ]; then
-    # If you want to use a local apache-arrow.rb formula, do
-    # $ cp ../dev/tasks/homebrew-formulae/autobrew/apache-arrow*.rb tools
-    # before R CMD build or INSTALL (assuming a local checkout of the apache/arrow repository).
-    # If you have this, you should use the local autobrew script so they match.
-    cp tools/autobrew .
-  fi
-
-  if [ -f "autobrew" ]; then
-    echo "**** Using local manifest for ${PKG_BREW_NAME}"
-  else
-    if ! curl -sfL "https://autobrew.github.io/scripts/$PKG_BREW_NAME" > autobrew; then
-      echo "Failed to download manifest for ${PKG_BREW_NAME}"
-      # Fall back to the local copy
-      cp tools/autobrew .
-    fi
-  fi
-  if ! . autobrew; then
-    echo "Failed to retrieve binary for ${PKG_BREW_NAME}"
-  fi
-  # autobrew sets `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS`
-  # TODO: move PKG_LIBS and PKG_CFLAGS out of autobrew and use set_pkg_vars
-}
-
 # Once libarrow is obtained, this function sets `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS`
 # either from pkg-config or by inferring things about the directory in $1
 set_pkg_vars () {
@@ -298,6 +254,11 @@ set_pkg_vars () {
   if [ "$ARROW_R_CXXFLAGS" ]; then
     PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"
   fi
+
+  if [ "$UNAME" = "Darwin" ] && expr $(sw_vers -productVersion) : '10\.13'; then
+    # avoid C++17 availability warnings on macOS < 11
+    PKG_CFLAGS="$PKG_CFLAGS -D_LIBCPP_DISABLE_AVAILABILITY"
+  fi
 }
 
 # If we have pkg-config, it will tell us what libarrow needs
diff --git a/r/tools/nixlibs-allowlist.txt b/r/tools/nixlibs-allowlist.txt
index bd9f0c1b2c084..9c368e6ed15a2 100644
--- a/r/tools/nixlibs-allowlist.txt
+++ b/r/tools/nixlibs-allowlist.txt
@@ -2,3 +2,4 @@ ubuntu
 centos
 redhat
 rhel
+darwin
diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 3d908c05cab07..60deca05cd172 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -28,6 +28,8 @@ if (test_mode && is.na(VERSION)) {
 }
 
 dev_version <- package_version(VERSION)[1, 4]
+on_macos <- tolower(Sys.info()[["sysname"]]) == "darwin"
+
 
 # Small dev versions are added for R-only changes during CRAN submission.
 if (is.na(dev_version) || dev_version < "100") {
@@ -94,8 +96,10 @@ download_binary <- function(lib) {
     }
   } else {
     if (!quietly) {
-      cat(sprintf("*** Downloading libarrow binary failed for version %s (%s)\n    at %s\n",
-                  VERSION, lib, binary_url))
+      cat(sprintf(
+        "*** Downloading libarrow binary failed for version %s (%s)\n    at %s\n",
+        VERSION, lib, binary_url
+      ))
     }
     libfile <- NULL
   }
@@ -114,6 +118,10 @@ download_binary <- function(lib) {
 #    * "linux-openssl-1.0" (OpenSSL 1.0)
 #    * "linux-openssl-1.1" (OpenSSL 1.1)
 #    * "linux-openssl-3.0" (OpenSSL 3.0)
+#    * "macos-amd64-openssl-1.1" (OpenSSL 1.1)
+#    * "macos-amd64-openssl-3.0" (OpenSSL 3.0)
+#    * "macos-arm64-openssl-1.1" (OpenSSL 1.1)
+#    * "macos-arm64-openssl-3.0" (OpenSSL 3.0)
 #   These string values, along with `NULL`, are the potential return values of
 #   this function.
 identify_binary <- function(lib = Sys.getenv("LIBARROW_BINARY"), info = distro()) {
@@ -142,7 +150,7 @@ check_allowlist <- function(os, allowed = "https://raw.githubusercontent.com/apa
     # Try a remote allowlist so that we can add/remove without a release
     suppressWarnings(readLines(allowed)),
     # Fallback to default: allowed only on Ubuntu and CentOS/RHEL
-    error = function(e) c("ubuntu", "centos", "redhat", "rhel")
+    error = function(e) c("ubuntu", "centos", "redhat", "rhel", "darwin")
   )
   # allowlist should contain valid regular expressions (plain strings ok too)
   any(grepl(paste(allowlist, collapse = "|"), os))
@@ -151,14 +159,16 @@ check_allowlist <- function(os, allowed = "https://raw.githubusercontent.com/apa
 select_binary <- function(os = tolower(Sys.info()[["sysname"]]),
                           arch = tolower(Sys.info()[["machine"]]),
                           test_program = test_for_curl_and_openssl) {
-  if (identical(os, "linux") && identical(arch, "x86_64")) {
-    # We only host x86 linux binaries today
-    tryCatch(
+  if (identical(os, "darwin") || (identical(os, "linux") && identical(arch, "x86_64"))) {
+    # We only host x86 linux binaries and x86 & arm64 macos today
+    binary <- tryCatch(
       # Somehow the test program system2 call errors on the sanitizer builds
       # so globally handle the possibility that this could fail
       {
         errs <- compile_test_program(test_program)
-        determine_binary_from_stderr(errs)
+        openssl_version <- determine_binary_from_stderr(errs)
+        arch <- ifelse(identical(os, "darwin"), paste0("-", arch, "-"), "-")
+        ifelse(is.null(openssl_version), NULL, paste0(os, arch, openssl_version))
       },
       error = function(e) {
         cat("*** Unable to find libcurl and openssl\n")
@@ -168,17 +178,20 @@ select_binary <- function(os = tolower(Sys.info()[["sysname"]]),
   } else {
     # No binary available for arch
     cat(sprintf("*** Building on %s %s\n", os, arch))
-    NULL
+    binary <- NULL
   }
+  return(binary)
 }
 
 # This tests that curl and OpenSSL are present (bc we can include their headers)
 # and it checks for other versions/features and raises errors that we grep for
 test_for_curl_and_openssl <- "
+#ifndef __APPLE__
 #include <ciso646>
 #ifdef _LIBCPP_VERSION
 #error Using libc++
 #endif
+#endif
 
 #include <curl/curl.h>
 #include <openssl/opensslv.h>
@@ -194,11 +207,14 @@ test_for_curl_and_openssl <- "
 "
 
 compile_test_program <- function(code) {
-  # Note: if we wanted to check for openssl on macOS, we'd have to set the brew
-  # path as a -I directory. But since we (currently) only run this code to
-  # determine whether we can download a Linux binary, it's not relevant.
+  openssl_dir <- ""
+  if (on_macos) {
+    openssl_root_dir <- get_macos_openssl_dir()
+    openssl_dir <- paste0("-I", openssl_root_dir, "/include")
+  }
   runner <- paste(
     R_CMD_config("CXX17"),
+    openssl_dir,
     R_CMD_config("CPPFLAGS"),
     R_CMD_config("CXX17FLAGS"),
     R_CMD_config("CXX17STD"),
@@ -208,17 +224,34 @@ compile_test_program <- function(code) {
   suppressWarnings(system2("echo", sprintf('"%s" | %s -', code, runner), stdout = FALSE, stderr = TRUE))
 }
 
+get_macos_openssl_dir <- function() {
+  openssl_root_dir <- Sys.getenv("OPENSSL_ROOT_DIR", NA)
+  header <- "openssl/opensslv.h"
+  if (is.na(openssl_root_dir) || !file.exists(file.path(openssl_root_dir, "include", header))) {
+    # try to guess default openssl include dir based on CRAN's build script
+    # https://github.com/R-macos/recipes/blob/master/build.sh#L35
+    if (identical(Sys.info()["machine"], "arm64") && file.exists(file.path("/opt/R/arm64/include", header))) {
+      openssl_root_dir <- "/opt/R/arm64"
+    } else if (identical(Sys.info()["machine"], "x86_64") && file.exists(file.path("/opt/R/x86_64/include", header))) {
+      openssl_root_dir <- "/opt/R/x86_64"
+    } else {
+      openssl_root_dir <- "/usr/local"
+    }
+  }
+  return(openssl_root_dir)
+}
+
 # (built with newer devtoolset but older glibc (2.17) for broader compatibility,# like manylinux2014)
 determine_binary_from_stderr <- function(errs) {
   if (is.null(attr(errs, "status"))) {
     # There was no error in compiling: so we found libcurl and OpenSSL >= 1.1,
     # openssl is < 3.0
     cat("*** Found libcurl and OpenSSL >= 1.1\n")
-    return("linux-openssl-1.1")
+    return("openssl-1.1")
     # Else, check for dealbreakers:
-  } else if (any(grepl("Using libc++", errs, fixed = TRUE))) {
-    # Our binaries are all built with GNU stdlib so they fail with libc++
-    cat("*** Found libc++\n")
+  } else if (!on_macos && any(grepl("Using libc++", errs, fixed = TRUE))) {
+    # Our linux binaries are all built with GNU stdlib so they fail with libc++
+    cat("*** Linux binaries incompatible with libc++\n")
     return(NULL)
   } else if (header_not_found("curl/curl", errs)) {
     cat("*** libcurl not found\n")
@@ -231,11 +264,15 @@ determine_binary_from_stderr <- function(errs) {
     return(NULL)
     # Else, determine which other binary will work
   } else if (any(grepl("Using OpenSSL version 1.0", errs))) {
+    if (on_macos) {
+      cat("*** OpenSSL 1.0 is not supported on macOS\n")
+      return(NULL)
+    }
     cat("*** Found libcurl and OpenSSL < 1.1\n")
-    return("linux-openssl-1.0")
+    return("openssl-1.0")
   } else if (any(grepl("Using OpenSSL version 3", errs))) {
     cat("*** Found libcurl and OpenSSL >= 3.0.0\n")
-    return("linux-openssl-3.0")
+    return("openssl-3.0")
   }
   NULL
 }
@@ -248,6 +285,11 @@ header_not_found <- function(header, errs) {
 #### start distro ####
 
 distro <- function() {
+  # This is not part of distro but needed to enable prebuilt binaries on macos
+  if (on_macos) {
+    return(list(id = "darwin", arch = tolower(Sys.info()[["machine"]])))
+  }
+
   # The code in this script is a (potentially stale) copy of the distro package
   if (requireNamespace("distro", quietly = TRUE)) {
     # Use the version from the package, which may be updated from this
@@ -487,8 +529,10 @@ build_libarrow <- function(src_dir, dst_dir) {
     # It failed :(
     cat("**** Error building Arrow C++.", "\n")
     if (quietly) {
-      cat("**** Printing contents of build log because the build failed", 
-          "while ARROW_R_DEV was set to FALSE\n")
+      cat(
+        "**** Printing contents of build log because the build failed",
+        "while ARROW_R_DEV was set to FALSE\n"
+      )
       cat(readLines(build_log_path), sep = "\n")
       cat("**** Complete build log may still be present at", build_log_path, "\n")
     }
@@ -503,7 +547,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
     # If not found, download it
     cat("**** cmake\n")
     CMAKE_VERSION <- Sys.getenv("CMAKE_VERSION", "3.26.4")
-    if (tolower(Sys.info()[["sysname"]]) %in% "darwin") {
+    if (on_macos) {
       postfix <- "-macos-universal.tar.gz"
     } else if (tolower(Sys.info()[["machine"]]) %in% c("arm64", "aarch64")) {
       postfix <- "-linux-aarch64.tar.gz"
diff --git a/r/tools/test-nixlibs.R b/r/tools/test-nixlibs.R
index e099dcdad4acf..c9571b58b7bbf 100644
--- a/r/tools/test-nixlibs.R
+++ b/r/tools/test-nixlibs.R
@@ -21,8 +21,10 @@
 # Flag so that we just load the functions and don't evaluate them like we do
 # when called from configure.R
 TESTING <- TRUE
-
-source("nixlibs.R", local = TRUE)
+# The functions use `on_macos` from the env they were sourced in, so we need tool
+# explicitly set it in that environment.
+nixlibs_env <- environment()
+source("nixlibs.R", local = nixlibs_env)
 
 test_that("identify_binary() based on LIBARROW_BINARY", {
   expect_null(identify_binary("FALSE"))
@@ -31,10 +33,6 @@ test_that("identify_binary() based on LIBARROW_BINARY", {
 })
 
 test_that("select_binary() based on system", {
-  expect_output(
-    expect_null(select_binary("darwin", "x86_64")), # Not built today
-    "Building on darwin x86_64"
-  )
   expect_output(
     expect_null(select_binary("linux", arch = "aarch64")), # Not built today
     "Building on linux aarch64"
@@ -52,21 +50,30 @@ test_that("determine_binary_from_stderr", {
   expect_output(
     expect_identical(
       determine_binary_from_stderr(compile_test_program("int a;")),
-      "linux-openssl-1.1"
+      "openssl-1.1"
     ),
     "Found libcurl and OpenSSL >= 1.1"
   )
+
+  nixlibs_env$on_macos <- FALSE
   expect_output(
     expect_identical(
       determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 1.0")),
-      "linux-openssl-1.0"
+      "openssl-1.0"
     ),
     "Found libcurl and OpenSSL < 1.1"
   )
+  nixlibs_env$on_macos <- TRUE
+  expect_output(
+    expect_null(
+      determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 1.0"))
+    ),
+    "OpenSSL 1.0 is not supported on macOS"
+  )
   expect_output(
     expect_identical(
       determine_binary_from_stderr(compile_test_program("#error Using OpenSSL version 3")),
-      "linux-openssl-3.0"
+      "openssl-3.0"
     ),
     "Found libcurl and OpenSSL >= 3.0.0"
   )
@@ -79,6 +86,7 @@ test_that("determine_binary_from_stderr", {
 })
 
 test_that("select_binary() with test program", {
+  nixlibs_env$on_macos <- FALSE
   expect_output(
     expect_identical(
       select_binary("linux", "x86_64", "int a;"),
@@ -100,13 +108,49 @@ test_that("select_binary() with test program", {
     ),
     "Found libcurl and OpenSSL >= 3.0.0"
   )
+  nixlibs_env$on_macos <- TRUE
+  expect_output(
+    expect_identical(
+      select_binary("darwin", "x86_64", "int a;"),
+      "darwin-x86_64-openssl-1.1"
+    ),
+    "Found libcurl and OpenSSL >= 1.1"
+  )
+  expect_output(
+    expect_identical(
+      select_binary("darwin", "x86_64", "#error Using OpenSSL version 3"),
+      "darwin-x86_64-openssl-3.0"
+    ),
+    "Found libcurl and OpenSSL >= 3.0.0"
+  )
+  expect_output(
+    expect_identical(
+      select_binary("darwin", "arm64", "int a;"),
+      "darwin-arm64-openssl-1.1"
+    ),
+    "Found libcurl and OpenSSL >= 1.1"
+  )
+  expect_output(
+    expect_identical(
+      select_binary("darwin", "arm64", "#error Using OpenSSL version 3"),
+      "darwin-arm64-openssl-3.0"
+    ),
+    "Found libcurl and OpenSSL >= 3.0.0"
+  )
+  expect_output(
+    expect_null(
+      select_binary("darwin", "x86_64", "#error Using OpenSSL version 1.0")
+    ),
+    "OpenSSL 1.0 is not supported on macOS"
+  )
 })
 
 test_that("check_allowlist", {
   tf <- tempfile()
-  cat("tu$\n^cent\n", file = tf)
+  cat("tu$\n^cent\n^dar\n", file = tf)
   expect_true(check_allowlist("ubuntu", tf))
   expect_true(check_allowlist("centos", tf))
+  expect_true(check_allowlist("darwin", tf))
   expect_false(check_allowlist("redhat", tf)) # remote allowlist doesn't have this
   expect_true(check_allowlist("redhat", tempfile())) # remote allowlist doesn't exist, so we fall back to the default list, which contains redhat
   expect_false(check_allowlist("debian", tempfile()))

From f7530de9fe20f8a3731b465af07a79a56640fe79 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Thu, 5 Oct 2023 10:26:13 -0400
Subject: [PATCH 463/749] GH-37712: [Go][Parquet] Fix ARM64 assembly for bitmap
 extract bits (#37785)

### Rationale for this change
The linked issue discovered a problem with the ARM64 implementation of the extractBits functionality which was being hidden because until `go1.21`, it looks like `golang.org/x/sys/cpu` wasn't properly detecting the ASIMD bit flag on the ARM processors and so it was using the pure go implementation. So we fix the assembly and add a test which was able to reproduce the failure without the fix on an ARM64 machine.

### What changes are included in this PR?
There was a problem with the assembly as it existed as the short circuit case where the selection bitmap is 0 wasn't actually setting the 0 value back onto the stack as a return. The assembly which initialized that register to 0 only occurred AFTER the `CBZ` instruction which would jump to the bottom and return. This means that we *actually* returned whatever happened to be on the stack at that location (i.e. garbage!). This only occurred if you were using the ARM64-specific assembly implementation, not the amd64 or pure go versions.

We also include a test to ensure we get the correct values for a variety of bitmaps and selections, along with this ensuring there's enough data on the stack so that if this problem re-occured we would catch it in this test.

### Are these changes tested?
Test is added.

* Closes: #37712

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/internal/bmi/_lib/bitmap_bmi2.c    |     6 +
 go/parquet/internal/bmi/_lib/bitmap_neon.s    |    32 -
 go/parquet/internal/bmi/bitmap_neon_arm64.go  |    10 +-
 go/parquet/internal/bmi/bitmap_neon_arm64.s   |    30 -
 go/parquet/internal/bmi/bmi_arm64.go          |    49 +-
 go/parquet/internal/bmi/bmi_test.go           |    47 +
 go/parquet/internal/utils/Makefile            |    18 +-
 go/parquet/internal/utils/_lib/README.md      |   154 +
 .../internal/utils/_lib/bit_packing_neon.c    |    28 +-
 go/parquet/internal/utils/_lib/script.sed     |    22 +
 .../internal/utils/bit_packing_arm64.go       |    29 +-
 .../internal/utils/bit_packing_neon_arm64.s   | 10229 +++++++++++-----
 go/parquet/internal/utils/clib_amd64.s        |    18 +
 13 files changed, 7209 insertions(+), 3463 deletions(-)
 create mode 100644 go/parquet/internal/bmi/bmi_test.go
 create mode 100644 go/parquet/internal/utils/_lib/README.md
 create mode 100644 go/parquet/internal/utils/_lib/script.sed
 mode change 100755 => 100644 go/parquet/internal/utils/bit_packing_neon_arm64.s

diff --git a/go/parquet/internal/bmi/_lib/bitmap_bmi2.c b/go/parquet/internal/bmi/_lib/bitmap_bmi2.c
index cc345d5798b8c..a020294fd6a38 100644
--- a/go/parquet/internal/bmi/_lib/bitmap_bmi2.c
+++ b/go/parquet/internal/bmi/_lib/bitmap_bmi2.c
@@ -17,6 +17,10 @@
 #include <arch.h>
 #include <stdint.h>
 
+#if !defined(__ARM_NEON) && !defined(__ARM_NEON__)
+// don't compile this for ARM, the pure go lookup table version
+// is more performant anyways since ARM doesn't have a BMI2/pext_u64
+// instruction we can call directly.
 uint64_t FULL_NAME(extract_bits)(uint64_t bitmap, uint64_t select_bitmap) {
 #if defined(__BMI2__)
    return (uint64_t)(_pext_u64(bitmap, select_bitmap));
@@ -32,6 +36,8 @@ uint64_t FULL_NAME(extract_bits)(uint64_t bitmap, uint64_t select_bitmap) {
 #endif
 }
 
+#endif
+
 uint64_t FULL_NAME(levels_to_bitmap)(const int16_t* levels, const int num_levels, const int16_t rhs) {
   uint64_t mask = 0;
   for (int x = 0; x < num_levels; x++) {
diff --git a/go/parquet/internal/bmi/_lib/bitmap_neon.s b/go/parquet/internal/bmi/_lib/bitmap_neon.s
index f6d4e751be63a..d1d146f55cfab 100644
--- a/go/parquet/internal/bmi/_lib/bitmap_neon.s
+++ b/go/parquet/internal/bmi/_lib/bitmap_neon.s
@@ -1,37 +1,5 @@
 	.text
 	.file	"bitmap_bmi2.c"
-	.globl	extract_bits_neon       // -- Begin function extract_bits_neon
-	.p2align	2
-	.type	extract_bits_neon,@function
-extract_bits_neon:                      // @extract_bits_neon
-// %bb.0:
-	stp	x29, x30, [sp, #-16]!   // 16-byte Folded Spill
-	mov	x29, sp
-	cbz	x1, .LBB0_4
-// %bb.1:
-	mov	x8, x0
-	mov	x0, xzr
-	mov	w9, #1
-.LBB0_2:                                // =>This Inner Loop Header: Depth=1
-	and	x10, x1, x8
-	neg	x11, x1
-	tst	x10, x11
-	sub	x12, x1, #1             // =1
-	csel	x10, xzr, x9, eq
-	ands	x1, x12, x1
-	orr	x0, x10, x0
-	lsl	x9, x9, #1
-	b.ne	.LBB0_2
-// %bb.3:
-	ldp	x29, x30, [sp], #16     // 16-byte Folded Reload
-	ret
-.LBB0_4:
-	mov	x0, xzr
-	ldp	x29, x30, [sp], #16     // 16-byte Folded Reload
-	ret
-.Lfunc_end0:
-	.size	extract_bits_neon, .Lfunc_end0-extract_bits_neon
-                                        // -- End function
 	.section	.rodata.cst16,"aM",@progbits,16
 	.p2align	4               // -- Begin function levels_to_bitmap_neon
 .LCPI1_0:
diff --git a/go/parquet/internal/bmi/bitmap_neon_arm64.go b/go/parquet/internal/bmi/bitmap_neon_arm64.go
index b3b0b093734be..65471d35288c3 100755
--- a/go/parquet/internal/bmi/bitmap_neon_arm64.go
+++ b/go/parquet/internal/bmi/bitmap_neon_arm64.go
@@ -14,21 +14,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !noasm
 // +build !noasm
 
 package bmi
 
 import "unsafe"
 
-//go:noescape
-func _extract_bits_neon(bitmap, selectBitmap uint64) (res uint64)
-
-// There is no single instruction similar with 'pext' on Arm64.
-// The equivalent of 'pext' was implemented with Arm64 Neon for Parallel Bits Extract 
-func extractBitsNEON(bitmap, selectBitmap uint64) uint64 {
-	return _extract_bits_neon(bitmap, selectBitmap)
-}
-
 //go:noescape
 func _levels_to_bitmap_neon(levels unsafe.Pointer, numLevels int, rhs int16) (res uint64)
 
diff --git a/go/parquet/internal/bmi/bitmap_neon_arm64.s b/go/parquet/internal/bmi/bitmap_neon_arm64.s
index 019aaef5d99b8..abde5843c68e2 100755
--- a/go/parquet/internal/bmi/bitmap_neon_arm64.s
+++ b/go/parquet/internal/bmi/bitmap_neon_arm64.s
@@ -1,36 +1,6 @@
 //+build !noasm !appengine
 
 // (C2GOASM doesn't work correctly for Arm64)
-// func _extract_bits_neon(bitmap, selectBitmap uint64) (res uint64)
-TEXT ·_extract_bits_neon(SB), $0-24
-
-    MOVD bitmap+0(FP), R0
-    MOVD selectBitmap+8(FP), R1
-
-    WORD $0xa9bf7bfd // stp    x29, x30, [sp, #-16]!
-    WORD $0x910003fd // mov    x29, sp
-    CBZ R1, LBB0_4
-    WORD $0xaa0003e8 // mov    x8, x0
-    WORD $0xaa1f03e0 // mov    x0, xzr
-    WORD $0x52800029 // mov    w9, #1
-LBB0_2:
-    WORD $0x8a08002a // and    x10, x1, x8
-    WORD $0xcb0103eb // neg    x11, x1
-    WORD $0xea0b015f // tst    x10, x11
-    WORD $0xd100042c // sub    x12, x1, #1
-    WORD $0x9a8903ea // csel    x10, xzr, x9, eq
-    WORD $0xea010181 // ands    x1, x12, x1
-    WORD $0xaa000140 // orr    x0, x10, x0
-    WORD $0xd37ff929 // lsl    x9, x9, #1
-    BNE LBB0_2
-    WORD $0xa8c17bfd // ldp    x29, x30, [sp], #16
-    MOVD R0, res+16(FP)
-    RET
-LBB0_4:
-    WORD $0xaa1f03e0 // mov    x0, xzr
-    WORD $0xa8c17bfd // ldp    x29, x30, [sp], #16
-    RET
-
 // func _levels_to_bitmap_neon(levels unsafe.Pointer, numLevels int, rhs int16) (res uint64)
 TEXT ·_levels_to_bitmap_neon(SB), $0-32
 
diff --git a/go/parquet/internal/bmi/bmi_arm64.go b/go/parquet/internal/bmi/bmi_arm64.go
index a436fadf72651..4174f6d06d989 100755
--- a/go/parquet/internal/bmi/bmi_arm64.go
+++ b/go/parquet/internal/bmi/bmi_arm64.go
@@ -14,44 +14,51 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !noasm
 // +build !noasm
 
 package bmi
 
 import (
+	"fmt"
 	"os"
 	"strings"
-)
-import (
-	"golang.org/x/sys/cpu"
+
+	"github.com/klauspost/cpuid/v2"
 )
 
 func init() {
-    // Added ability to enable extension via environment:
+	// Added ability to enable extension via environment:
 	// ARM_ENABLE_EXT=NEON go test
 	if ext, ok := os.LookupEnv("ARM_ENABLE_EXT"); ok {
-		exts := strings.Split(ext, ",")
-
-		for _, x := range exts {
-			switch x {
-			case "NEON":
-				cpu.ARM64.HasASIMD = true
-			case "AES":
-				cpu.ARM64.HasAES = true
-			case "PMULL":
-				cpu.ARM64.HasPMULL = true
-			default:
-				cpu.ARM64.HasASIMD = false
-				cpu.ARM64.HasAES = false
-				cpu.ARM64.HasPMULL = false
+		if ext == "DISABLE" {
+			cpuid.CPU.Disable(cpuid.ASIMD, cpuid.AESARM, cpuid.PMULL)
+		} else {
+			exts := strings.Split(ext, ",")
+
+			for _, x := range exts {
+				switch x {
+				case "NEON":
+					cpuid.CPU.Enable(cpuid.ASIMD)
+				case "AES":
+					cpuid.CPU.Enable(cpuid.AESARM)
+				case "PMULL":
+					cpuid.CPU.Enable(cpuid.PMULL)
+				default:
+					fmt.Fprintln(os.Stderr, "unrecognized value for ARM_ENABLE_EXT:", x)
+				}
 			}
 		}
 	}
-	if cpu.ARM64.HasASIMD {
-		funclist.extractBits = extractBitsNEON
+
+	// after benchmarking, turns out the pure go lookup table version
+	// is nearly twice as fast as the non-lookup table assembly
+	// because arm doesn't have a PEXT instruction.
+	funclist.extractBits = extractBitsGo
+
+	if cpuid.CPU.Has(cpuid.ASIMD) {
 		funclist.gtbitmap = greaterThanBitmapNEON
 	} else {
-		funclist.extractBits = extractBitsGo
 		funclist.gtbitmap = greaterThanBitmapGo
 	}
 }
diff --git a/go/parquet/internal/bmi/bmi_test.go b/go/parquet/internal/bmi/bmi_test.go
new file mode 100644
index 0000000000000..460c6ec4e24c6
--- /dev/null
+++ b/go/parquet/internal/bmi/bmi_test.go
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT 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 bmi_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/stretchr/testify/assert"
+)
+
+// Testing the issue in GH-37712
+func TestBasicExtractBits(t *testing.T) {
+	tests := []struct {
+		bitmap, selection uint64
+		expected          uint64
+	}{
+		{0, 0, 0},
+		{0xFF, 0, 0},
+		{0xFF, ^uint64(0), 0xFF},
+		{0xFF00FF, 0xAAAA, 0x000F},
+		{0xFF0AFF, 0xAFAA, 0x00AF},
+		{0xFFAAFF, 0xAFAA, 0x03AF},
+		{0xFECBDA9876543210, 0xF00FF00FF00FF00F, 0xFBD87430},
+	}
+
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("%d-%d=>%d", tt.bitmap, tt.selection, tt.expected), func(t *testing.T) {
+			assert.Equal(t, tt.expected, bmi.ExtractBits(tt.bitmap, tt.selection))
+		})
+	}
+}
diff --git a/go/parquet/internal/utils/Makefile b/go/parquet/internal/utils/Makefile
index 58643223876ea..f6dce46197fef 100644
--- a/go/parquet/internal/utils/Makefile
+++ b/go/parquet/internal/utils/Makefile
@@ -32,11 +32,14 @@ C_FLAGS_NEON=-O3 -fvectorize -mllvm -force-vector-width=16 -fno-asynchronous-unw
 GO_SOURCES  := $(shell find . -path ./_lib -prune -o -name '*.go' -not -name '*_test.go')
 ALL_SOURCES := $(shell find . -path ./_lib -prune -o -name '*.go' -name '*.s' -not -name '*_test.go')
 
-.PHONEY: assembly
+.PHONY: assembly
 
 INTEL_SOURCES := \
-	bit_packing_avx2.s \
-	unpack_bool_avx2.s unpack_bool_sse4.s
+	bit_packing_avx2_amd64.s \
+	unpack_bool_avx2_amd64.s unpack_bool_sse4_amd64.s
+
+ARM_SOURCES := \
+	bit_packing_neon_arm64.s unpack_bool_neon_arm64.s
 
 #
 # ARROW-15336: DO NOT add the assembly target for Arm64 (ARM_SOURCES) until c2goasm added the Arm64 support.
@@ -58,13 +61,16 @@ _lib/unpack_bool_sse4.s: _lib/unpack_bool.c
 _lib/unpack_bool_neon.s: _lib/unpack_bool.c
 	$(CC) -S $(C_FLAGS_NEON) $^ -o $@ ; $(PERL_FIXUP_ROTATE) $@
 
-bit_packing_avx2.s: _lib/bit_packing_avx2.s
+_lib/bit_packing_neon.s: _lib/bit_packing_neon.c
+	$(CC) -S $(C_FLAGS_NEON) $^ -o $@
+
+bit_packing_avx2_amd64.s: _lib/bit_packing_avx2.s
 	$(C2GOASM) -a -f $^ $@
 
-unpack_bool_avx2.s: _lib/unpack_bool_avx2.s
+unpack_bool_avx2_amd64.s: _lib/unpack_bool_avx2.s
 	$(C2GOASM) -a -f $^ $@
 
-unpack_bool_sse4.s: _lib/unpack_bool_sse4.s
+unpack_bool_sse4_amd64.s: _lib/unpack_bool_sse4.s
 	$(C2GOASM) -a -f $^ $@
 
 clean:
diff --git a/go/parquet/internal/utils/_lib/README.md b/go/parquet/internal/utils/_lib/README.md
new file mode 100644
index 0000000000000..10cc9a257e055
--- /dev/null
+++ b/go/parquet/internal/utils/_lib/README.md
@@ -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.
+-->
+
+# SIMD Bit Packing Implementation
+
+Go doesn't have any SIMD intrinsics so for some low-level optimizations we can 
+leverage auto-vectorization by C++ compilers and the fact that Go lets you specify the body of a
+function in assembly to benefit from SIMD.
+
+In here we have implementations using SIMD intrinsics for AVX (amd64) and NEON (arm64).
+
+## Generating the Go assembly
+
+c2goasm and asm2plan9s are two projects which can be used in conjunction to generate
+compatible Go assembly from C assembly.
+
+First the tools need to be installed:
+
+```bash
+go install github.com/klauspost/asmfmt/cmd/asmfmt@latest
+go install github.com/minio/asm2plan9s@latest
+go install github.com/minio/c2goasm@latest
+```
+
+### Generating for amd64
+
+The Makefile in the directory above will work for amd64. `make assembly` will compile
+the c sources and then call `c2goasm` to generate the Go assembly for amd64 
+architectures.
+
+### Generating for arm64
+
+Unfortunately there are some caveats for arm64. c2goasm / asm2plan9s doesn't fully
+support arm64 correctly. However, proper assembly can be created with some slight
+manipulation of the result.
+
+The Makefile has the NEON flags for compiling the assembly by using 
+`make _lib/bit_packing_neon.s` and `make _lib/unpack_bool_neon.s` to generate the
+raw assembly sources. 
+
+Before calling `c2goasm` there's a few things that need to be modified in the assembly:
+
+* x86-64 assembly uses `#` for comments while arm64 assembly uses `//` for comments.
+  `c2goasm` assumes `#` for comments and splits lines based on them. For most lines
+  this isn't an issue, but for any constants this is important and will need to have
+  the comment character converted from `//` to `#`.
+* A `word` for x86-64 is 16 bits, a `double` word is 32 bits, and a `quad` is 64 bits.
+  For arm64, a `word` is 32 bits. This means that constants in the assembly need to be
+  modified. `c2goasm` and `asm2plan9s` expect the x86-64 meaning for the sizes, so
+  usage of `.word ######` needs to be converted to `.long #####` before running
+  `c2goasm`. In addition, `.xword` is an 8-byte value and as such should be changed to
+  `.quad` before running `c2goasm`.
+* Because of this change in bits, `MOVQ` instructions will also be converted to 
+  `MOVD` instructions.
+
+After running `c2goasm` there will still need to be modifications made to the 
+resulting assembly.
+
+* Most of the ARM instructions will be converted to using the Go assembly construction
+  of `WORD $0x########` to provide an instruction directly to the processor rather than
+  going through the Go assembler. Some of the instructions, however, aren't recognized
+  by `c2goasm` and will need to added. If you look at the assembly, you'll see these
+  as assembly that is commented out without any `WORD` instruction. For example:
+  ```asm
+  // stp x29, x30, [sp, #-48]!
+  WORD $0x11007c48 // add  w8, w2, #31
+  ```
+  The `stp` instruction needs to be added. This can be done in one of two ways:
+  1. Many instructions are properly handled by the Go assembler correctly. You can
+     find the arm-specific caveats to Go's assembly [here](https://pkg.go.dev/cmd/internal/obj/arm64). In this case, the instruction would be `STP.W (R29, R30), -48(RSP)`.
+  2. Assuming that the GNU assembler is installed, you can use it to generate the
+     correct byte sequence. Create a file named `neon.asm` with a single line 
+     (the instruction) and call `as -o neon.o neon.asm`. Then you can run
+     `objdump -S neon.o` to get the value to use. The output should look something 
+     like:
+     ```
+     Disassembly of section .text:
+
+     0000000000000000 <.text>:
+     0:   11 00 7c 48    add  w8, w2, #31
+     ```
+     And then update the assembly as `WORD $0x11007c48 // add w8, w2, #31`
+* Labels used in instructions won't work when using the `WORD $0x#########` syntax.
+  They need to be the actual instructions for the labels. So all lines that have a
+  label will need to be converted. This is two-fold:
+  1. Any lines for branching such as those which end with `// b.le LBB0_10` are updated
+     to be `BLE LBB0_10`. The same is true for `b.gt`, `b.ge`, `b.ne`, and `b.eq`. `b` 
+     instructions are instead converted to `JMP` calls.
+  2. References to constants need to be updated, for example `LCPI0_192`. By default,
+     these will get converted to global data instructions like 
+     `DATA LCDATA1<>+0xc68(SB)/8, $0x0000000000000000`. Unfortunately, these seem to 
+     have issues with being referenced by the assembler. The pattern to look for in 
+     the assembly is an `adrp x9, .LCPI0_192` instruction that is later followed by 
+     an instruction that looks like `str d4, [x9, 0:lo12:.LCPI0_192]`. These will
+     need to be converted to a macro and a `VMOV` instruction. 
+     * In the original assembly, you'll see blocks like:
+       ```asm
+       .LCPI0_0
+          .word 1           // 0x00000001
+          .word 2           // 0x00000002
+       .LCPI0_1
+          .word 4294967265  // 0xffffffe1
+          .word 4294967266  // 0xffffffe2
+       ```
+       which were converted to the `DATA LCDATA1`.... lines. Instead they should get
+       converted to a macro and a vector instruction:
+       ```asm
+       #define LCPI0_0 $0x0000000200000001
+       #define LCPI0_1 $0xffffffe2ffffffe1
+       ```
+       Notice the lower/higher bits!
+       Then replace the `str`/`ldr`/`mov` instruction as `VMOVD LCPI0_0, v4`. Because
+       the original instruction storing the value in `d4`, we use `VMOVD` and `V4`. 
+       Alternately we might find a prefix of `q` instead of `d`, in which case it we
+       need to use `VMOVQ` and pass the lower bytes followed by the higher bytes.
+       ```asm
+       #define LCPI0_48L $0x0000000d00000008
+       #define LCPI0_48H $0x0000001700000012
+       ...
+       VMOVQ LCPI0_48L, LCPI0_48H, V4
+       ```
+       After replacing the instructions, both the `adrp` and the `str`/`ldr`/`mov` 
+       instructions should be removed/commented out.
+       There might also be a `LEAQ LCDATA1<>(SB), BP` instruction at the top of the
+       function. That should be removed/commented out as we are replacing the constants
+       with macros.
+* Finally, if the function has a return value, make sure that at the end of the 
+  function, ends with something akin to `MOVD R0, num+32(FP)`. Where `num` is the
+  local variable name of the return value, and `32` is the byte size of the arguments.
+
+To faciliate some automation, a `script.sed` file is provided in this directory which
+can be run against the generated assembly from `c2goasm` as 
+`sed -f _lib/script.sed -i bit_packing_neon_arm64.s` which will perform several of 
+these steps on the generated assembly such as convering `b.le`/etc calls with labels
+to proper `BLE LBB0_....` lines, and converting `adrp`/`ldr` pairs to `VMOVD` and 
+`VMOVQ` instructions.
+
+This should be sufficient to ensuring the assembly is generated and works properly!
\ No newline at end of file
diff --git a/go/parquet/internal/utils/_lib/bit_packing_neon.c b/go/parquet/internal/utils/_lib/bit_packing_neon.c
index c333a346c3ac9..c8dd97c2a36a2 100755
--- a/go/parquet/internal/utils/_lib/bit_packing_neon.c
+++ b/go/parquet/internal/utils/_lib/bit_packing_neon.c
@@ -20,8 +20,9 @@
 #include "arm_neon.h"
 
 inline const uint32_t* unpack0_32_neon(const uint32_t* in, uint32_t* out) {
-  memset(out, 0x0, 32 * sizeof(*out));
-  out += 32;
+  for (const uint32_t* end = out + 32; out != end; out++) {
+    *out = 0;
+  }
 
   return in;
 }
@@ -647,7 +648,7 @@ inline static const uint32_t* unpack7_32_neon(const uint32_t* in, uint32_t* out)
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = (in[0] >> 28 | in[1] << 4) >> shifts_2nd[0];
+  ind[0] = (in[0] >> 28 | in[1] << 4) >> shifts_2nd[0];
   ind[1] = in[1] >> shifts_2nd[1];
   ind[2] = in[1] >> shifts_2nd[2];
   ind[3] = in[1] >> shifts_2nd[3];
@@ -842,7 +843,7 @@ inline static const uint32_t* unpack9_32_neon(const uint32_t* in, uint32_t* out)
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = in[1] >> shifts_2nd[0];
+  ind[0] = in[1] >> shifts_2nd[0];
   ind[1] = in[1] >> shifts_2nd[1];
   ind[2] = in[1] >> shifts_2nd[2];
   ind[3] = (in[1] >> 31 | in[2] << 1) >> shifts_2nd[3];
@@ -939,7 +940,7 @@ inline static const uint32_t* unpack10_32_neon(const uint32_t* in, uint32_t* out
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = in[1] >> shifts_2nd[0];
+  ind[0] = in[1] >> shifts_2nd[0];
   ind[1] = in[1] >> shifts_2nd[1];
   ind[2] = (in[1] >> 28 | in[2] << 4) >> shifts_2nd[2];
   ind[3] = in[2] >> shifts_2nd[3];
@@ -1040,7 +1041,7 @@ inline static const uint32_t* unpack11_32_neon(const uint32_t* in, uint32_t* out
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = in[1] >> shifts_2nd[0];
+  ind[0] = in[1] >> shifts_2nd[0];
   ind[1] = (in[1] >> 23 | in[2] << 9) >> shifts_2nd[1];
   ind[2] = in[2] >> shifts_2nd[2];
   ind[3] = in[2] >> shifts_2nd[3];
@@ -1135,7 +1136,7 @@ inline static const uint32_t* unpack12_32_neon(const uint32_t* in, uint32_t* out
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = in[1] >> shifts_2nd[0];
+  ind[0] = in[1] >> shifts_2nd[0];
   ind[1] = (in[1] >> 28 | in[2] << 4) >> shifts_2nd[1];
   ind[2] = in[2] >> shifts_2nd[2];
   ind[3] = in[2] >> shifts_2nd[3];
@@ -1236,7 +1237,7 @@ inline static const uint32_t* unpack13_32_neon(const uint32_t* in, uint32_t* out
   out += 4;
 
   // shift the 2nd 4 outs
-  ind[2] = (in[1] >> 20 | in[2] << 12) >> shifts_2nd[0];
+  ind[0] = (in[1] >> 20 | in[2] << 12) >> shifts_2nd[0];
   ind[1] = in[2] >> shifts_2nd[1];
   ind[2] = in[2] >> shifts_2nd[2];
   ind[3] = (in[2] >> 27 | in[3] << 5) >> shifts_2nd[3];
@@ -1698,7 +1699,6 @@ inline static const uint32_t* unpack17_32_neon(const uint32_t* in, uint32_t* out
   vst1q_u32(out, results);
   out += 4;
 
-
   in += 17;
 
   return in;
@@ -1908,7 +1908,7 @@ inline static const uint32_t* unpack20_32_neon(const uint32_t* in, uint32_t* out
   uint32_t shifts_1st[4] = {0, 0, 8, 0};
   uint32_t shifts_2nd[4] = {0, 4, 0, 12};
   uint32x4_t reg_shft, reg_masks;
-  uint32x4_t results; 
+  uint32x4_t results;
 
   reg_masks = vdupq_n_u32(mask);
 
@@ -2093,7 +2093,6 @@ inline static const uint32_t* unpack21_32_neon(const uint32_t* in, uint32_t* out
   vst1q_u32(out, results);
   out += 4;
 
-
   in += 21;
 
   return in;
@@ -3079,9 +3078,10 @@ inline static const uint32_t* unpack31_32_neon(const uint32_t* in, uint32_t* out
 }
 
 inline const uint32_t* unpack32_32_neon(const uint32_t* in, uint32_t* out) {
-  memcpy(out, in, 32 * sizeof(*out));
-  in += 32;
-  out += 32;
+  for (const uint32_t* end = out + 32; out != end; out++) {
+    *out = *in;
+    in++;
+  }
 
   return in;
 }
diff --git a/go/parquet/internal/utils/_lib/script.sed b/go/parquet/internal/utils/_lib/script.sed
new file mode 100644
index 0000000000000..908cce695a5ba
--- /dev/null
+++ b/go/parquet/internal/utils/_lib/script.sed
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+s|WORD $0x54[0-9a-f]\+[[:space:]]\+//[[:space:]]\+b.\([leqgtnso]\+\)[[:space:]]\+.\(LBB0_[0-9]\+\)|B\U\1 \2|
+s|WORD $0x14000000[[:space:]]\+//[[:space:]]\+b[[:space:]]\+.\(LBB0_[0-9]\+\)|JMP \1|
+s|\(WORD $0x9[0-9a-f]\+ // adrp.*\)|// \1|
+s|WORD $0x[0-9a-f]\+ // ldr[[:space:]]\+d\([0-9]\+\), \[x[0-9]\+, :lo[0-9]\+:.\(LCPI0_[0-9]\+\)\]|VMOVD \2, V\1|
+s|WORD $0x[0-9a-f]\+ // ldr[[:space:]]\+q\([0-9]\+\), \[x[0-9]\+, :lo[0-9]\+:.\(LCPI0_[0-9]\+\)\]|VMOVQ \2L, \2H, V\1|
diff --git a/go/parquet/internal/utils/bit_packing_arm64.go b/go/parquet/internal/utils/bit_packing_arm64.go
index 61eead02633ca..92fe0f97b77c3 100644
--- a/go/parquet/internal/utils/bit_packing_arm64.go
+++ b/go/parquet/internal/utils/bit_packing_arm64.go
@@ -20,33 +20,14 @@
 package utils
 
 import (
-	"os"
-	"strings"
-
-	"golang.org/x/sys/cpu"
+	"github.com/klauspost/cpuid/v2"
+	// import for side effect of initializing feature flags
+	// based on ARM_ENABLE_EXT env var
+	_ "github.com/apache/arrow/go/v14/parquet/internal/bmi"
 )
 
 func init() {
-	cpu.ARM64.HasASIMD = false
-	cpu.ARM64.HasAES = false
-	cpu.ARM64.HasPMULL = false
-	// Added ability to enable extension via environment:
-	if ext, ok := os.LookupEnv("ARM_ENABLE_EXT"); ok {
-		exts := strings.Split(ext, ",")
-
-		for _, x := range exts {
-			switch x {
-			case "NEON":
-				cpu.ARM64.HasASIMD = true
-			case "AES":
-				cpu.ARM64.HasAES = true
-			case "PMULL":
-				cpu.ARM64.HasPMULL = true
-			default:
-			}
-		}
-	}
-	if cpu.ARM64.HasASIMD {
+	if cpuid.CPU.Has(cpuid.ASIMD) {
 		unpack32 = unpack32NEON
 	} else { // default to the pure go implementation if no avx2 available
 		unpack32 = unpack32Default
diff --git a/go/parquet/internal/utils/bit_packing_neon_arm64.s b/go/parquet/internal/utils/bit_packing_neon_arm64.s
old mode 100755
new mode 100644
index 047e5b720e4a0..2d18dccdb573b
--- a/go/parquet/internal/utils/bit_packing_neon_arm64.s
+++ b/go/parquet/internal/utils/bit_packing_neon_arm64.s
@@ -1,3351 +1,6926 @@
 //+build !noasm !appengine
+// AUTO-GENERATED BY C2GOASM -- DO NOT EDIT
+
+#include "go_asm.h"
+#include "textflag.h"
+
+#define LCPI0_0L $0x000000000000000e
+#define LCPI0_0H $0x000000000000000f
+#define LCPI0_1L $0x000000000000000c
+#define LCPI0_1H $0x000000000000000d
+#define LCPI0_2L $0x000000000000000a
+#define LCPI0_2H $0x000000000000000b
+#define LCPI0_3L $0x0000000000000008
+#define LCPI0_3H $0x0000000000000009
+#define LCPI0_4L $0x0000000000000006
+#define LCPI0_4H $0x0000000000000007
+#define LCPI0_5L $0x0000000000000004
+#define LCPI0_5H $0x0000000000000005
+#define LCPI0_6L $0x0000000000000002
+#define LCPI0_6H $0x0000000000000003
+#define LCPI0_7L $0x0000000000000000
+#define LCPI0_7H $0x0000000000000001
+
+#define LCPI0_10L $0x0000000500000004
+#define LCPI0_10H $0x0000000700000006
+#define LCPI0_11L $0xffffffe5ffffffe4
+#define LCPI0_11H $0xffffffe7ffffffe6
+#define LCPI0_12L $0x0000000900000008
+#define LCPI0_12H $0x0000000b0000000a
+#define LCPI0_13L $0xffffffe9ffffffe8
+#define LCPI0_13H $0xffffffebffffffea
+#define LCPI0_14L $0x0000000d0000000c
+#define LCPI0_14H $0x0000000f0000000e
+#define LCPI0_15L $0xffffffedffffffec
+#define LCPI0_15H $0xffffffefffffffee
+#define LCPI0_16L $0x0000001100000010
+#define LCPI0_16H $0x0000001300000012
+#define LCPI0_17L $0xfffffff1fffffff0
+#define LCPI0_17H $0xfffffff3fffffff2
+#define LCPI0_18L $0x0000001500000014
+#define LCPI0_18H $0x0000001700000016
+#define LCPI0_19L $0xfffffff5fffffff4
+#define LCPI0_19H $0xfffffff7fffffff6
+#define LCPI0_20L $0x0000001900000018
+#define LCPI0_20H $0x0000001b0000001a
+#define LCPI0_21L $0xfffffff9fffffff8
+#define LCPI0_21H $0xfffffffbfffffffa
+#define LCPI0_26L $0x0000000a00000008
+#define LCPI0_26H $0x0000000e0000000c
+#define LCPI0_27L $0xffffffeaffffffe8
+#define LCPI0_27H $0xffffffeeffffffec
+#define LCPI0_28L $0x0000001200000010
+#define LCPI0_28H $0x0000001600000014
+#define LCPI0_29L $0xfffffff2fffffff0
+#define LCPI0_29H $0xfffffff6fffffff4
+#define LCPI0_34L $0x0000000f0000000c
+#define LCPI0_34H $0x0000001500000012
+#define LCPI0_35L $0xffffffefffffffec
+#define LCPI0_35H $0xfffffff5fffffff2
+#define LCPI0_38L $0x0000000700000004
+#define LCPI0_38H $0x0000000d0000000a
+#define LCPI0_39L $0xffffffe7ffffffe4
+#define LCPI0_39H $0xffffffedffffffea
+#define LCPI0_40L $0x0000001300000010
+#define LCPI0_40H $0x0000001900000016
+#define LCPI0_41L $0xfffffff3fffffff0
+#define LCPI0_41H $0xfffffff9fffffff6
+#define LCPI0_44L $0x0000000b00000008
+#define LCPI0_44H $0x000000110000000e
+#define LCPI0_45L $0xffffffebffffffe8
+#define LCPI0_45H $0xfffffff1ffffffee
+#define LCPI0_56L $0x0000000d00000008
+#define LCPI0_56H $0x0000001700000012
+#define LCPI0_57L $0xffffffedffffffe8
+#define LCPI0_57H $0xfffffff7fffffff2
+#define LCPI0_62L $0x0000000900000004
+#define LCPI0_62H $0x000000130000000e
+#define LCPI0_63L $0xffffffe9ffffffe4
+#define LCPI0_63H $0xfffffff3ffffffee
+#define LCPI0_173L $0xfffffff5fffffffc
+#define LCPI0_173H $0xffffffe7ffffffee
+#define LCPI0_177L $0xfffffff2fffffff8
+#define LCPI0_177H $0xffffffe6ffffffec
+#define LCPI0_180L $0xfffffff3fffffff8
+#define LCPI0_180H $0xffffffe9ffffffee
+#define LCPI0_183L $0xfffffff7fffffffc
+#define LCPI0_183H $0xffffffedfffffff2
+#define LCPI0_185L $0xffffffeffffffff4
+#define LCPI0_185H $0xffffffe5ffffffea
+#define LCPI0_187L $0xffffffecfffffff0
+#define LCPI0_187H $0xffffffe4ffffffe8
+#define LCPI0_189L $0xfffffff1fffffff4
+#define LCPI0_189H $0xffffffebffffffee
+#define LCPI0_191L $0xfffffff9fffffffc
+#define LCPI0_191H $0xfffffff3fffffff6
+#define LCPI0_192L $0xffffffedfffffff0
+#define LCPI0_192H $0xffffffe7ffffffea
+#define LCPI0_194L $0xfffffff5fffffff8
+#define LCPI0_194H $0xffffffeffffffff2
+#define LCPI0_195L $0xffffffe9ffffffec
+#define LCPI0_195H $0xffffffe3ffffffe6
+#define LCPI0_197L $0xfffffff6fffffff8
+#define LCPI0_197H $0xfffffff2fffffff4
+#define LCPI0_198L $0xffffffeefffffff0
+#define LCPI0_198H $0xffffffeaffffffec
+#define LCPI0_199L $0xffffffe6ffffffe8
+#define LCPI0_199H $0xffffffe2ffffffe4
+#define LCPI0_201L $0xfffffffbfffffffc
+#define LCPI0_201H $0xfffffff9fffffffa
+#define LCPI0_202L $0xfffffff7fffffff8
+#define LCPI0_202H $0xfffffff5fffffff6
+#define LCPI0_203L $0xfffffff3fffffff4
+#define LCPI0_203H $0xfffffff1fffffff2
+#define LCPI0_204L $0xffffffeffffffff0
+#define LCPI0_204H $0xffffffedffffffee
+#define LCPI0_205L $0xffffffebffffffec
+#define LCPI0_205H $0xffffffe9ffffffea
+#define LCPI0_206L $0xffffffe7ffffffe8
+#define LCPI0_206H $0xffffffe5ffffffe6
+#define LCPI0_207L $0xffffffe3ffffffe4
+#define LCPI0_207H $0xffffffe1ffffffe2
+
+#define LCPI0_8 $0x0000000200000001
+#define LCPI0_9 $0xffffffe2ffffffe1
+#define LCPI0_22 $0x0000001d0000001c
+#define LCPI0_23 $0xfffffffdfffffffc
+#define LCPI0_24 $0x0000000400000002
+#define LCPI0_25 $0xffffffe4ffffffe2
+#define LCPI0_30 $0x0000001a00000018
+#define LCPI0_31 $0xfffffffafffffff8
+#define LCPI0_32 $0x0000000600000003
+#define LCPI0_33 $0xffffffe6ffffffe3
+#define LCPI0_36 $0x0000001b00000018
+#define LCPI0_37 $0xfffffffbfffffff8
+#define LCPI0_42 $0x0000000500000002
+#define LCPI0_43 $0xffffffe5ffffffe2
+#define LCPI0_46 $0x0000001700000014
+#define LCPI0_47 $0xfffffff7fffffff4
+#define LCPI0_48 $0x0000000800000004
+#define LCPI0_49 $0xffffffe8ffffffe4
+#define LCPI0_50 $0x0000001400000010
+#define LCPI0_51 $0xfffffff4fffffff0
+#define LCPI0_52 $0x0000000a00000005
+#define LCPI0_53 $0xffffffeaffffffe5
+#define LCPI0_54 $0x0000001900000014
+#define LCPI0_55 $0xfffffff9fffffff4
+#define LCPI0_58 $0x0000000600000001
+#define LCPI0_59 $0xffffffe6ffffffe1
+#define LCPI0_60 $0x0000001500000010
+#define LCPI0_61 $0xfffffff5fffffff0
+#define LCPI0_64 $0x0000000700000002
+#define LCPI0_65 $0xffffffe7ffffffe2
+#define LCPI0_66 $0x000000110000000c
+#define LCPI0_67 $0xfffffff1ffffffec
+#define LCPI0_68 $0x0000000c00000006
+#define LCPI0_69 $0xffffffecffffffe6
+#define LCPI0_70 $0x0000000a00000004
+#define LCPI0_71 $0xffffffeaffffffe4
+#define LCPI0_72 $0x0000001600000010
+#define LCPI0_73 $0xfffffff6fffffff0
+#define LCPI0_74 $0x0000000e00000008
+#define LCPI0_75 $0xffffffeeffffffe8
+#define LCPI0_76 $0x0000000e00000007
+#define LCPI0_77 $0xffffffeeffffffe7
+#define LCPI0_78 $0x0000000a00000003
+#define LCPI0_79 $0xffffffeaffffffe3
+#define LCPI0_80 $0x0000000d00000006
+#define LCPI0_81 $0xffffffedffffffe6
+#define LCPI0_82 $0x0000000900000002
+#define LCPI0_83 $0xffffffe9ffffffe2
+#define LCPI0_84 $0x0000001700000010
+#define LCPI0_85 $0xfffffff7fffffff0
+#define LCPI0_86 $0x000000130000000c
+#define LCPI0_87 $0xfffffff3ffffffec
+#define LCPI0_88 $0x0000000f00000008
+#define LCPI0_89 $0xffffffefffffffe8
+#define LCPI0_90 $0x0000000b00000004
+#define LCPI0_91 $0xffffffebffffffe4
+#define LCPI0_92 $0x0000001000000008
+#define LCPI0_93 $0xfffffff0ffffffe8
+#define LCPI0_94 $0x0000001200000009
+#define LCPI0_95 $0xfffffff2ffffffe9
+#define LCPI0_96 $0x0000000d00000004
+#define LCPI0_97 $0xffffffedffffffe4
+#define LCPI0_98 $0x0000001100000008
+#define LCPI0_99 $0xfffffff1ffffffe8
+#define LCPI0_100 $0x000000150000000c
+#define LCPI0_101 $0xfffffff5ffffffec
+#define LCPI0_102 $0x0000000b00000002
+#define LCPI0_103 $0xffffffebffffffe2
+#define LCPI0_104 $0x0000000f00000006
+#define LCPI0_105 $0xffffffefffffffe6
+#define LCPI0_106 $0x0000000a00000001
+#define LCPI0_107 $0xffffffeaffffffe1
+#define LCPI0_108 $0x0000000e00000005
+#define LCPI0_109 $0xffffffeeffffffe5
+#define LCPI0_110 $0x000000140000000a
+#define LCPI0_111 $0xfffffff4ffffffea
+#define LCPI0_112 $0x0000001200000008
+#define LCPI0_113 $0xfffffff2ffffffe8
+#define LCPI0_114 $0x0000000e00000004
+#define LCPI0_115 $0xffffffeeffffffe4
+#define LCPI0_116 $0x0000000c00000002
+#define LCPI0_117 $0xffffffecffffffe2
+#define LCPI0_118 $0x0000000d00000002
+#define LCPI0_119 $0xffffffedffffffe2
+#define LCPI0_120 $0x0000000e00000003
+#define LCPI0_121 $0xffffffeeffffffe3
+#define LCPI0_122 $0x0000000f00000004
+#define LCPI0_123 $0xffffffefffffffe4
+#define LCPI0_124 $0x0000001100000006
+#define LCPI0_125 $0xfffffff1ffffffe6
+#define LCPI0_126 $0x0000001200000007
+#define LCPI0_127 $0xfffffff2ffffffe7
+#define LCPI0_128 $0x0000001300000008
+#define LCPI0_129 $0xfffffff3ffffffe8
+#define LCPI0_130 $0x0000000e00000001
+#define LCPI0_131 $0xffffffeeffffffe1
+#define LCPI0_132 $0x0000000f00000002
+#define LCPI0_133 $0xffffffefffffffe2
+#define LCPI0_134 $0x0000001100000004
+#define LCPI0_135 $0xfffffff1ffffffe4
+#define LCPI0_136 $0x0000001200000005
+#define LCPI0_137 $0xfffffff2ffffffe5
+#define LCPI0_138 $0xffffffeffffffffe
+#define LCPI0_139 $0xffffffeefffffffc
+#define LCPI0_140 $0xfffffff2ffffffff
+#define LCPI0_141 $0xfffffff1fffffffe
+#define LCPI0_142 $0xffffffeffffffffc
+#define LCPI0_143 $0xffffffeefffffffb
+#define LCPI0_144 $0xffffffedfffffffa
+#define LCPI0_145 $0xffffffecfffffff8
+#define LCPI0_146 $0xfffffff3fffffffe
+#define LCPI0_147 $0xfffffff2fffffffd
+#define LCPI0_148 $0xfffffff1fffffffc
+#define LCPI0_149 $0xffffffeffffffffa
+#define LCPI0_150 $0xffffffeefffffff9
+#define LCPI0_151 $0xffffffedfffffff8
+#define LCPI0_152 $0xffffffebfffffff6
+#define LCPI0_153 $0xffffffecfffffff6
+#define LCPI0_154 $0xffffffeefffffff8
+#define LCPI0_155 $0xfffffff2fffffffc
+#define LCPI0_156 $0xfffffff4fffffffe
+#define LCPI0_157 $0xffffffeefffffff7
+#define LCPI0_158 $0xfffffff3fffffffc
+#define LCPI0_159 $0xffffffeffffffff8
+#define LCPI0_160 $0xffffffebfffffff4
+#define LCPI0_161 $0xfffffff5fffffffe
+#define LCPI0_162 $0xfffffff1fffffffa
+#define LCPI0_163 $0xfffffff6ffffffff
+#define LCPI0_164 $0xfffffff2fffffffb
+#define LCPI0_165 $0xfffffff0fffffff8
+#define LCPI0_166 $0xfffffff2fffffff9
+#define LCPI0_167 $0xfffffff6fffffffd
+#define LCPI0_168 $0xfffffff3fffffffa
+#define LCPI0_169 $0xfffffff7fffffffe
+#define LCPI0_170 $0xffffffe9fffffff0
+#define LCPI0_171 $0xffffffedfffffff4
+#define LCPI0_172 $0xfffffff1fffffff8
+#define LCPI0_174 $0xfffffff4fffffffa
+#define LCPI0_175 $0xfffffff6fffffffc
+#define LCPI0_176 $0xffffffeafffffff0
+#define LCPI0_178 $0xfffffff6fffffffb
+#define LCPI0_179 $0xffffffe7ffffffec
+#define LCPI0_181 $0xfffffffaffffffff
+#define LCPI0_182 $0xffffffebfffffff0
+#define LCPI0_184 $0xfffffff9fffffffe
+#define LCPI0_186 $0xfffffff8fffffffc
+#define LCPI0_188 $0xfffffffafffffffd
+#define LCPI0_190 $0xffffffe5ffffffe8
+#define LCPI0_193 $0xfffffffbfffffffe
+#define LCPI0_196 $0xfffffffcfffffffe
+#define LCPI0_200 $0xfffffffeffffffff
+
+TEXT ·_unpack32_neon(SB), $0-40
+
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	MOVD batchSize+16(FP), R2
+	MOVD nbits+24(FP), R3
+	// LEAQ LCDATA1<>(SB), BP
+
+	// %bb.0:
+	WORD $0xa9ba7bfd // stp    x29, x30, [sp, #-96]!
+	WORD $0xd10643e9 // sub    x9, sp, #400
+	WORD $0xa9016ffc // stp    x28, x27, [sp, #16]
+	WORD $0xa90267fa // stp    x26, x25, [sp, #32]
+	WORD $0x910003fd // mov    x29, sp
+	WORD $0xa9035ff8 // stp    x24, x23, [sp, #48]
+	WORD $0xa90457f6 // stp    x22, x21, [sp, #64]
+	WORD $0xa9054ff4 // stp    x20, x19, [sp, #80]
+	WORD $0x927df13f // and    sp, x9, #0xfffffffffffffff8
+	WORD $0x11007c48 // add    w8, w2, #31
+	WORD $0x7100005f // cmp    w2, #0
+	WORD $0x1a82b108 // csel    w8, w8, w2, lt
+	WORD $0xaa0103fa // mov    x26, x1
+	WORD $0x13057d13 // asr    w19, w8, #5
+	WORD $0x71003c7f // cmp    w3, #15
+	BLE LBB0_14
+
+	// %bb.1:
+	WORD $0x71005c7f // cmp    w3, #23
+	BLE LBB0_22
+
+	// %bb.2:
+	WORD $0x71006c7f // cmp    w3, #27
+	BLE LBB0_36
+
+	// %bb.3:
+	WORD $0x7100747f // cmp    w3, #29
+	BLE LBB0_60
+
+	// %bb.4:
+	WORD $0x7100787f // cmp    w3, #30
+	BEQ LBB0_148
+
+	// %bb.5:
+	WORD $0x71007c7f // cmp    w3, #31
+	BEQ LBB0_100
+
+	// %bb.6:
+	WORD $0x7100807f // cmp    w3, #32
+	BNE LBB0_156
+
+	// %bb.7:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.8:
+	WORD $0x7100427f // cmp    w19, #16
+	BLO LBB0_11
+
+	// %bb.9:
+	WORD $0xd379e268 // lsl    x8, x19, #7
+	WORD $0x8b080009 // add    x9, x0, x8
+	WORD $0xeb1a013f // cmp    x9, x26
+	BLS LBB0_157
+
+	// %bb.10:
+	WORD $0x8b080348 // add    x8, x26, x8
+	WORD $0xeb00011f // cmp    x8, x0
+	BLS LBB0_157
+
+LBB0_11:
+	WORD $0xf9000fff // str    xzr, [sp, #24]
 
-// ARROW-15336
-// (C2GOASM doesn't work correctly for Arm64)
-// Partly GENERATED BY asm2plan9s.
-
-DATA LJTI<>+0x000(SB)/2, $0
-DATA LJTI<>+0x002(SB)/2, $9
-DATA LJTI<>+0x004(SB)/2, $72
-DATA LJTI<>+0x006(SB)/2, $133
-DATA LJTI<>+0x008(SB)/2, $210
-DATA LJTI<>+0x00a(SB)/2, $291
-DATA LJTI<>+0x00c(SB)/2, $390
-DATA LJTI<>+0x00e(SB)/2, $474
-DATA LJTI<>+0x010(SB)/2, $567
-DATA LJTI<>+0x012(SB)/2, $657
-DATA LJTI<>+0x014(SB)/2, $758
-DATA LJTI<>+0x016(SB)/2, $854
-DATA LJTI<>+0x018(SB)/2, $957
-DATA LJTI<>+0x01a(SB)/2, $1048
-DATA LJTI<>+0x01c(SB)/2, $4601
-DATA LJTI<>+0x01e(SB)/2, $1250
-DATA LJTI<>+0x020(SB)/2, $1354
-DATA LJTI<>+0x022(SB)/2, $1436
-DATA LJTI<>+0x024(SB)/2, $1541
-DATA LJTI<>+0x026(SB)/2, $1645
-DATA LJTI<>+0x028(SB)/2, $1773
-DATA LJTI<>+0x02a(SB)/2, $1875
-DATA LJTI<>+0x02c(SB)/2, $2015
-DATA LJTI<>+0x02e(SB)/2, $2145
-DATA LJTI<>+0x030(SB)/2, $2292
-DATA LJTI<>+0x032(SB)/2, $2390
-DATA LJTI<>+0x034(SB)/2, $3140
-DATA LJTI<>+0x036(SB)/2, $2533
-DATA LJTI<>+0x038(SB)/2, $2667
-DATA LJTI<>+0x03a(SB)/2, $2781
-DATA LJTI<>+0x03c(SB)/2, $2902
-DATA LJTI<>+0x03e(SB)/2, $3008
-DATA LJTI<>+0x040(SB)/2, $3117
-GLOBL LJTI<>+0(SB), 8, $66
-
-
-// func _unpack32_neon(in, out unsafe.Pointer, batchSize, nbits int) (num int)
-TEXT ·_unpack32_neon(SB), $24-40
-
-    MOVD    in+0(FP), R0
-    MOVD    out+8(FP), R1
-    MOVD    batchSize+16(FP), R2
-    MOVD    nbits+24(FP), R3
-
-    WORD $0xa9be7bfd // stp    x29, x30, [sp, #-32]!
-    WORD $0x11007c48 // add    w8, w2, #31
-    WORD $0x7100005f // cmp    w2, #0
-    WORD $0x1a82b108 // csel    w8, w8, w2, lt
-    WORD $0xf9000bf3 // str    x19, [sp, #16]
-    WORD $0x7100807f // cmp    w3, #32
-    WORD $0x121b6913 // and    w19, w8, #0xffffffe0
-    WORD $0x910003fd // mov    x29, sp
-    BHI LBB0_99
-    WORD $0x2a0303e9 // mov    w9, w3
-    MOVD LJTI<>+0x00(SB), R10
-    WORD $0x1000000b // adr    x11, LBB0_2
-    WORD $0x7869794c // ldrh    w12, [x10, x9, lsl #1]
-    WORD $0x8b0c096b // add    x11, x11, x12, lsl #2
-    WORD $0x13057d08 // asr    w8, w8, #5
-    WORD $0xd61f0160 // br    x11
-LBB0_2:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x51000508 // sub    w8, w8, #1
-    WORD $0xd379e108 // lsl    x8, x8, #7
-    WORD $0x91020102 // add    x2, x8, #128
-    WORD $0xaa0103e0 // mov    x0, x1
-    WORD $0x2a1f03e1 // mov    w1, wzr
-    WORD $0x94000000 // bl    memset
-	JMP LBB0_99
-LBB0_4:
-    WORD $0x7100805f // cmp    w2, #32
-	BLT LBB0_99
-    VMOVQ $0x0000000500000004, $0x0000000700000006, V1 // LCPI0_1
-    VMOVQ $0x0000000900000008, $0x0000000b0000000a, V2 // LCPI0_3
-    VMOVQ $0x0000000d0000000c, $0x0000000f0000000e, V3 // LCPI0_5
-    VMOVQ $0x0000001100000010, $0x0000001300000012, V4 // LCPI0_7
-    VMOVQ $0x0000001500000014, $0x0000001700000016, V5 // LCPI0_9
-    VMOVQ $0x0000001900000018, $0x0000001b0000001a, V6 // LCPI0_11
-    VMOVQ $0x0000001d0000001c, $0x0000001f0000001e, V7 // LCPI0_121
-    WORD $0x91010029 // add    x9, x1, #64 
-    WORD $0x4f000420 // movi    v0.4s, #1
-    WORD $0x6ea0b821 // neg    v1.4s, v1.4s
-    WORD $0x6ea0b842 // neg    v2.4s, v2.4s
-    WORD $0x6ea0b863 // neg    v3.4s, v3.4s
-    WORD $0x6ea0b884 // neg    v4.4s, v4.4s
-    WORD $0x6ea0b8a5 // neg    v5.4s, v5.4s
-    WORD $0x6ea0b8c6 // neg    v6.4s, v6.4s
-    WORD $0x6ea0b8e7 // neg    v7.4s, v7.4s
-    WORD $0xaa0003ea // mov    x10, x0
-LBB0_6:
-    WORD $0xb940000b // ldr    w11, [x0]
-    WORD $0xf1000508 // subs    x8, x8, #1
-    WORD $0x53017d6c // lsr    w12, w11, #1
-    WORD $0x1e270170 // fmov    s16, w11
-    WORD $0x53027d6d // lsr    w13, w11, #2
-    WORD $0x4e0c1d90 // mov    v16.s[1], w12
-    WORD $0x53037d6e // lsr    w14, w11, #3
-    WORD $0x4e141db0 // mov    v16.s[2], w13
-    WORD $0x4e1c1dd0 // mov    v16.s[3], w14
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9c0130 // stur    q16, [x9, #-64]
-    WORD $0x4ddfc950 // ld1r    { v16.4s }, [x10], #4
-    WORD $0x6ea14610 // ushl    v16.4s, v16.4s, v1.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9d0130 // stur    q16, [x9, #-48]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0x6ea24610 // ushl    v16.4s, v16.4s, v2.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9e0130 // stur    q16, [x9, #-32]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0x6ea34610 // ushl    v16.4s, v16.4s, v3.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9f0130 // stur    q16, [x9, #-16]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0x6ea44610 // ushl    v16.4s, v16.4s, v4.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800130 // str    q16, [x9]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0x6ea54610 // ushl    v16.4s, v16.4s, v5.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800530 // str    q16, [x9, #16]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0x6ea64610 // ushl    v16.4s, v16.4s, v6.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800930 // str    q16, [x9, #32]
-    WORD $0x4d40c810 // ld1r    { v16.4s }, [x0]
-    WORD $0xaa0a03e0 // mov    x0, x10
-    WORD $0x6ea74610 // ushl    v16.4s, v16.4s, v7.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800d30 // str    q16, [x9, #48]
-    WORD $0x91020129 // add    x9, x9, #128
-    BNE LBB0_6
-    JMP LBB0_99
-LBB0_7:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000000a00000008, $0x0000000e0000000c, V1 // LCPI0_15
-    VMOVQ $0x0000001200000010, $0x0000001600000014, V2 // LCPI0_17
-    VMOVQ $0x0000001a00000018, $0x0000001e0000001c, V3 // LCPI0_120
-    WORD $0x91010029 // add    x9, x1, #64
-    WORD $0x4f000460 // movi    v0.4s, #3
-    WORD $0x6ea0b821 // neg    v1.4s, v1.4s
-    WORD $0x6ea0b842 // neg    v2.4s, v2.4s
-    WORD $0x6ea0b863 // neg    v3.4s, v3.4s
-LBB0_9:
-    WORD $0xb940000a // ldr    w10, [x0]
-    WORD $0xaa0003eb // mov    x11, x0
-    WORD $0xf1000508 // subs    x8, x8, #1
-    WORD $0x53027d4c // lsr    w12, w10, #2
-    WORD $0x1e270144 // fmov    s4, w10
-    WORD $0x53047d4d // lsr    w13, w10, #4
-    WORD $0x4e0c1d84 // mov    v4.s[1], w12
-    WORD $0x53067d4e // lsr    w14, w10, #6
-    WORD $0x4e141da4 // mov    v4.s[2], w13
-    WORD $0x4e1c1dc4 // mov    v4.s[3], w14
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9c0124 // stur    q4, [x9, #-64]
-    WORD $0x4ddfc964 // ld1r    { v4.4s }, [x11], #4
-    WORD $0x6ea14484 // ushl    v4.4s, v4.4s, v1.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9d0124 // stur    q4, [x9, #-48]
-    WORD $0x4d40c804 // ld1r    { v4.4s }, [x0]
-    WORD $0x6ea24484 // ushl    v4.4s, v4.4s, v2.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9e0124 // stur    q4, [x9, #-32]
-    WORD $0xb840840a // ldr    w10, [x0], #8
-    WORD $0x4e040d44 // dup    v4.4s, w10
-    WORD $0x6ea34484 // ushl    v4.4s, v4.4s, v3.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9f0124 // stur    q4, [x9, #-16]
-    WORD $0xb940016a // ldr    w10, [x11]
-    WORD $0x53027d4c // lsr    w12, w10, #2
-    WORD $0x1e270144 // fmov    s4, w10
-    WORD $0x53047d4d // lsr    w13, w10, #4
-    WORD $0x4e0c1d84 // mov    v4.s[1], w12
-    WORD $0x53067d4e // lsr    w14, w10, #6
-    WORD $0x4e141da4 // mov    v4.s[2], w13
-    WORD $0x4e1c1dc4 // mov    v4.s[3], w14
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800124 // str    q4, [x9]
-    WORD $0x4d40c964 // ld1r    { v4.4s }, [x11]
-    WORD $0x6ea14484 // ushl    v4.4s, v4.4s, v1.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800524 // str    q4, [x9, #16]
-    WORD $0x4d40c964 // ld1r    { v4.4s }, [x11]
-    WORD $0x6ea24484 // ushl    v4.4s, v4.4s, v2.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800924 // str    q4, [x9, #32]
-    WORD $0x4d40c964 // ld1r    { v4.4s }, [x11]
-    WORD $0x6ea34484 // ushl    v4.4s, v4.4s, v3.4s
-    WORD $0x4e201c84 // and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800d24 // str    q4, [x9, #48]
-    WORD $0x91020129 // add    x9, x9, #128
-    BNE LBB0_9
-    JMP LBB0_99
-LBB0_10:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000000f0000000c, $0x0000001500000012, V1 // LCPI0_21
-    MOVD $0x0000001b00000018, R2 // LCPI0_23
-    VMOVQ $0x0000000700000004, $0x0000000d0000000a, V3 // LCPI0_25
-    VMOVQ $0x0000001300000010, $0x0000001900000016, V4 // LCPI0_27
-    MOVD $0x0000000500000002, R5 // LCPI0_29
-    VMOVQ $0x0000000b00000008, $0x000000110000000e, V6 // LCPI0_31
-    VMOVQ $0x0000001700000014, $0x0000001d0000001a, V7 // LCPI0_119
-    WORD $0x91010029 // add    x9, x1, #64 
-    WORD $0x4f0004e0 // movi    v0.4s, #7
-    WORD $0x6ea0b821 // neg    v1.4s, v1.4s
-    WORD $0x2ea0b842 // neg    v2.2s, v2.2s
-    WORD $0x6ea0b863 // neg    v3.4s, v3.4s
-    WORD $0x6ea0b884 // neg    v4.4s, v4.4s
-    WORD $0x2ea0b8a5 // neg    v5.2s, v5.2s
-    WORD $0x6ea0b8c6 // neg    v6.4s, v6.4s
-    WORD $0x6ea0b8e7 // neg    v7.4s, v7.4s
 LBB0_12:
-    WORD $0xb940000a // ldr    w10, [x0]
-    WORD $0xf1000508 // subs    x8, x8, #1
-    WORD $0x53037d4b // lsr    w11, w10, #3
-    WORD $0x1e270150 // fmov    s16, w10
-    WORD $0x53067d4c // lsr    w12, w10, #6
-    WORD $0x4e0c1d70 // mov    v16.s[1], w11
-    WORD $0x53097d4d // lsr    w13, w10, #9
-    WORD $0x4e141d90 // mov    v16.s[2], w12
-    WORD $0x4e1c1db0 // mov    v16.s[3], w13
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0xaa0003ea // mov    x10, x0
-    WORD $0x3c9c0130 // stur    q16, [x9, #-64]
-    WORD $0x4ddfc950 // ld1r    { v16.4s }, [x10], #4
-    WORD $0x6ea14610 // ushl    v16.4s, v16.4s, v1.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9d0130 // stur    q16, [x9, #-48]
-    WORD $0xb940000b // ldr    w11, [x0]
-    WORD $0xb940014c // ldr    w12, [x10]
-    WORD $0x0e040d70 // dup    v16.2s, w11
-    WORD $0x138b798b // extr    w11, w12, w11, #30
-    WORD $0x2ea24610 // ushl    v16.2s, v16.2s, v2.2s
-    WORD $0x53017d8c // lsr    w12, w12, #1
-    WORD $0x4e141d70 // mov    v16.s[2], w11
-    WORD $0x4e1c1d90 // mov    v16.s[3], w12
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9e0130 // stur    q16, [x9, #-32]
-    WORD $0x4d40c950 // ld1r    { v16.4s }, [x10]
-    WORD $0x9100200c // add    x12, x0, #8 
-    WORD $0x6ea34610 // ushl    v16.4s, v16.4s, v3.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9f0130 // stur    q16, [x9, #-16]
-    WORD $0x4d40c950 // ld1r    { v16.4s }, [x10]
-    WORD $0x6ea44610 // ushl    v16.4s, v16.4s, v4.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800130 // str    q16, [x9]
-    WORD $0xb940014a // ldr    w10, [x10]
-    WORD $0xb940080b // ldr    w11, [x0, #8]
-    WORD $0x91003000 // add    x0, x0, #12 
-    WORD $0x531c7d4d // lsr    w13, w10, #28
-    WORD $0x138a7d6a // extr    w10, w11, w10, #31
-    WORD $0x0e040d70 // dup    v16.2s, w11
-    WORD $0x1e2701b1 // fmov    s17, w13
-    WORD $0x2ea54610 // ushl    v16.2s, v16.2s, v5.2s
-    WORD $0x4e0c1d51 // mov    v17.s[1], w10
-    WORD $0x6e180611 // mov    v17.d[1], v16.d[0]
-    WORD $0x4e201e30 // and    v16.16b, v17.16b, v0.16b
-    WORD $0x3d800530 // str    q16, [x9, #16]
-    WORD $0x4d40c990 // ld1r    { v16.4s }, [x12]
-    WORD $0x6ea64610 // ushl    v16.4s, v16.4s, v6.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800930 // str    q16, [x9, #32]
-    WORD $0x4d40c990 // ld1r    { v16.4s }, [x12]
-    WORD $0x6ea74610 // ushl    v16.4s, v16.4s, v7.4s
-    WORD $0x4e201e10 // and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800d30 // str    q16, [x9, #48]
-    WORD $0x91020129 // add    x9, x9, #128
-    BNE LBB0_12
-    JMP LBB0_99
+	WORD $0xf9400fe8 // ldr    x8, [sp, #24]
+	WORD $0x8b081f4a // add    x10, x26, x8, lsl #7
+	WORD $0xcb080268 // sub    x8, x19, x8
+	WORD $0x9101014a // add    x10, x10, #64
+
 LBB0_13:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000001400000010, $0x0000001c00000018, V1 // LCPI0_118
-    WORD $0x91010029 // add    x9, x1, #64
-    WORD $0x4f0005e0 // movi    v0.4s, #15
-    WORD $0x6ea0b821 // neg    v1.4s, v1.4s
-LBB0_15:
-    WORD $0xb940000a // ldr    w10, [x0]
-    WORD $0xaa0003eb // mov    x11, x0
-    WORD $0xf1000508 // subs    x8, x8, #1
-    WORD $0x53047d4c // lsr    w12, w10, #4
-    WORD $0x1e270142 // fmov    s2, w10
-    WORD $0x53087d4d // lsr    w13, w10, #8
-    WORD $0x4e0c1d82 // mov    v2.s[1], w12
-    WORD $0x530c7d4e // lsr    w14, w10, #12
-    WORD $0x4e141da2 // mov    v2.s[2], w13
-    WORD $0x4e1c1dc2 // mov    v2.s[3], w14
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9c0122 // stur    q2, [x9, #-64]
-    WORD $0x4ddfc962 // ld1r    { v2.4s }, [x11], #4
-    WORD $0x6ea14442 // ushl    v2.4s, v2.4s, v1.4s
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9d0122 // stur    q2, [x9, #-48]
-    WORD $0xb940016a // ldr    w10, [x11]
-    WORD $0x53047d4c // lsr    w12, w10, #4
-    WORD $0x1e270142 // fmov    s2, w10
-    WORD $0x53087d4d // lsr    w13, w10, #8
-    WORD $0x4e0c1d82 // mov    v2.s[1], w12
-    WORD $0x530c7d4e // lsr    w14, w10, #12
-    WORD $0x4e141da2 // mov    v2.s[2], w13
-    WORD $0x4e1c1dc2 // mov    v2.s[3], w14
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9e0122 // stur    q2, [x9, #-32]
-    WORD $0x4d40c962 // ld1r    { v2.4s }, [x11]
-    WORD $0x9100200b // add    x11, x0, #8 
-    WORD $0x6ea14442 // ushl    v2.4s, v2.4s, v1.4s
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9f0122 // stur    q2, [x9, #-16]
-    WORD $0xb940080a // ldr    w10, [x0, #8]
-    WORD $0x53047d4c // lsr    w12, w10, #4
-    WORD $0x1e270142 // fmov    s2, w10
-    WORD $0x53087d4d // lsr    w13, w10, #8
-    WORD $0x4e0c1d82 // mov    v2.s[1], w12
-    WORD $0x530c7d4e // lsr    w14, w10, #12
-    WORD $0x4e141da2 // mov    v2.s[2], w13
-    WORD $0x4e1c1dc2 // mov    v2.s[3], w14
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9f0122 // stur    q2, [x9, #-16]
-    WORD $0xb940080a // ldr    w10, [x0, #8]
-    WORD $0x53047d4c // lsr    w12, w10, #4
-    WORD $0x1e270142 // fmov    s2, w10
-    WORD $0x53087d4d // lsr    w13, w10, #8
-    WORD $0x4e0c1d82 // mov    v2.s[1], w12
-    WORD $0x530c7d4e // lsr    w14, w10, #12
-    WORD $0x4e141da2 // mov    v2.s[2], w13
-    WORD $0x4e1c1dc2 // mov    v2.s[3], w14
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800122 // str    q2, [x9]
-    WORD $0x4d40c962 // ld1r    { v2.4s }, [x11]
-    WORD $0x9100300b // add    x11, x0, #12
-    WORD $0x6ea14442 // ushl    v2.4s, v2.4s, v1.4s
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800522 // str    q2, [x9, #16]
-    WORD $0xb9400c0a // ldr    w10, [x0, #12]
-    WORD $0x91004000 // add    x0, x0, #16             
-    WORD $0x53047d4c // lsr    w12, w10, #4
-    WORD $0x1e270142 // fmov    s2, w10
-    WORD $0x53087d4d // lsr    w13, w10, #8
-    WORD $0x4e0c1d82 // mov    v2.s[1], w12
-    WORD $0x530c7d4e // lsr    w14, w10, #12
-    WORD $0x4e141da2 // mov    v2.s[2], w13
-    WORD $0x4e1c1dc2 // mov    v2.s[3], w14
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800922 // str    q2, [x9, #32]
-    WORD $0x4d40c962 // ld1r    { v2.4s }, [x11]
-    WORD $0x6ea14442 // ushl    v2.4s, v2.4s, v1.4s
-    WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800d22 // str    q2, [x9, #48]
-    WORD $0x91020129 //add    x9, x9, #128
-    BNE LBB0_15
-    JMP LBB0_99
-LBB0_16:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000001900000014, R1 // LCPI0_37
-    VMOVQ $0x0000000d00000008, $0x0000001700000012, V2 // LCPI0_39
-    MOVD $0x0000000600000001, R3 // LCPI0_41
-    MOVD $0x0000001500000010, R4 // LCPI0_43
-    VMOVQ $0x0000000900000004, $0x000000130000000e, V5 // LCPI0_45
-    MOVD $0x0000000700000002, R6 // LCPI0_47
-    VMOVQ $0x000000110000000c, $0x0000001b00000016, V7 // LCPI0_117
-    WORD $0x91010029 // add    x9, x1, #64
-    WORD $0x4f0007e0 // movi    v0.4s, #31
-    WORD $0x2ea0b821 //neg    v1.2s, v1.2s
-    WORD $0x6ea0b842 //neg    v2.4s, v2.4s
-    WORD $0x2ea0b863 //neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //neg    v4.2s, v4.2s
-    WORD $0x6ea0b8a5 //neg    v5.4s, v5.4s
-    WORD $0x2ea0b8c6 //neg    v6.2s, v6.2s
-    WORD $0x6ea0b8e7 //neg    v7.4s, v7.4s
-LBB0_18:
-    WORD $0xb940000a //ldr    w10, [x0]
-    WORD $0xf1000508 //subs    x8, x8, #1
-    WORD $0x53057d4b //lsr    w11, w10, #5
-    WORD $0x1e270150 //fmov    s16, w10
-    WORD $0x530a7d4c //lsr    w12, w10, #10
-    WORD $0x4e0c1d70 //mov    v16.s[1], w11
-    WORD $0x530f7d4d //lsr    w13, w10, #15
-    WORD $0x4e141d90 //mov    v16.s[2], w12
-    WORD $0x4e1c1db0 //mov    v16.s[3], w13
-    WORD $0x4e201e10 //and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9c0130 //    stur    q16, [x9, #-64]
-    WORD $0x29402c0a //ldp    w10, w11, [x0]
-    WORD $0x9100100c //add    x12, x0, #4
-    WORD $0x0e040d50 //    dup    v16.2s, w10
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x2ea14610 //    ushl    v16.2s, v16.2s, v1.2s
-    WORD $0x53037d6b //    lsr    w11, w11, #3
-    WORD $0x4e141d50 //    mov    v16.s[2], w10
-    WORD $0x4e1c1d70 //    mov    v16.s[3], w11
-    WORD $0x4e201e10 //    and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9d0130 //    stur    q16, [x9, #-48]
-    WORD $0x4d40c990 //    ld1r    { v16.4s }, [x12]
-    WORD $0x9100300c //    add    x12, x0, #12
-    WORD $0x6ea24610 //    ushl    v16.4s, v16.4s, v2.4s
-    WORD $0x4e201e10 //    and    v16.16b, v16.16b, v0.16b
-    WORD $0x3c9e0130 //    stur    q16, [x9, #-32]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d70 //    dup    v16.2s, w11
-    WORD $0x2ea34610 //    ushl    v16.2s, v16.2s, v3.2s
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x6e0c0611 //    mov    v17.s[1], v16.s[0]
-    WORD $0x530b7d6b //    lsr    w11, w11, #11
-    WORD $0x6e142611 //    mov    v17.s[2], v16.s[1]
-    WORD $0x4e1c1d71 //    mov    v17.s[3], w11
-    WORD $0x4e201e30 //    and    v16.16b, v17.16b, v0.16b
-    WORD $0x3c9f0130 //    stur    q16, [x9, #-16]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0x0e040d50 //    dup    v16.2s, w10
-    WORD $0x531a7d4d //    lsr    w13, w10, #26
-    WORD $0x2ea44610 //    ushl    v16.2s, v16.2s, v4.2s
-    WORD $0x138a7d6a //    extr    w10, w11, w10, #31
-    WORD $0x4e141db0 //    mov    v16.s[2], w13
-    WORD $0x4e1c1d50 //    mov    v16.s[3], w10
-    WORD $0x4e201e10 //    and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800130 //    str    q16, [x9]
-    WORD $0x4d40c990 //    ld1r    { v16.4s }, [x12]
-    WORD $0x9100400c //    add    x12, x0, #16
-    WORD $0x6ea54610 //    ushl    v16.4s, v16.4s, v5.4s
-    WORD $0x4e201e10 //    and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800530 //    str    q16, [x9, #16]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x91005000 //    add    x0, x0, #20
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x138a756a //    extr    w10, w11, w10, #29
-    WORD $0x0e040d70 //    dup    v16.2s, w11
-    WORD $0x1e2701b1 //    fmov    s17, w13
-    WORD $0x2ea64610 //    ushl    v16.2s, v16.2s, v6.2s
-    WORD $0x4e0c1d51 //    mov    v17.s[1], w10
-    WORD $0x6e180611 //    mov    v17.d[1], v16.d[0]
-    WORD $0x4e201e30 //    and    v16.16b, v17.16b, v0.16b
-    WORD $0x3d800930 //    str    q16, [x9, #32]
-    WORD $0x4d40c990 //    ld1r    { v16.4s }, [x12]
-    WORD $0x6ea74610 //    ushl    v16.4s, v16.4s, v7.4s
-    WORD $0x4e201e10 //    and    v16.16b, v16.16b, v0.16b
-    WORD $0x3d800d30 //    str    q16, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_18
-    JMP LBB0_99
-LBB0_19:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000a00000004, R1 // LCPI0_51
-    MOVD $0x0000001600000010, R2 // LCPI0_53
-    VMOVQ $0x0000000e00000008, $0x0000001a00000014, V3 // LCPI0_116
-    WORD $0x91010029 // add    x9, x1, #64
-    WORD $0x4f0107e0 // movi    v0.4s, #63
-    WORD $0x2ea0b821 // neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 // neg    v2.2s, v2.2s
-    WORD $0x6ea0b863 // neg    v3.4s, v3.4s
+	WORD $0xb940000b // ldr    w11, [x0]
+	WORD $0xf1000508 // subs    x8, x8, #1
+	WORD $0xb81c014b // stur    w11, [x10, #-64]
+	WORD $0xb940040b // ldr    w11, [x0, #4]
+	WORD $0xb81c414b // stur    w11, [x10, #-60]
+	WORD $0xb940080b // ldr    w11, [x0, #8]
+	WORD $0xb81c814b // stur    w11, [x10, #-56]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0xb81cc14b // stur    w11, [x10, #-52]
+	WORD $0xb940100b // ldr    w11, [x0, #16]
+	WORD $0xb81d014b // stur    w11, [x10, #-48]
+	WORD $0xb940140b // ldr    w11, [x0, #20]
+	WORD $0xb81d414b // stur    w11, [x10, #-44]
+	WORD $0xb940180b // ldr    w11, [x0, #24]
+	WORD $0xb81d814b // stur    w11, [x10, #-40]
+	WORD $0xb9401c0b // ldr    w11, [x0, #28]
+	WORD $0xb81dc14b // stur    w11, [x10, #-36]
+	WORD $0xb940200b // ldr    w11, [x0, #32]
+	WORD $0xb81e014b // stur    w11, [x10, #-32]
+	WORD $0xb940240b // ldr    w11, [x0, #36]
+	WORD $0xb81e414b // stur    w11, [x10, #-28]
+	WORD $0xb940280b // ldr    w11, [x0, #40]
+	WORD $0xb81e814b // stur    w11, [x10, #-24]
+	WORD $0xb9402c0b // ldr    w11, [x0, #44]
+	WORD $0xb81ec14b // stur    w11, [x10, #-20]
+	WORD $0xb940300b // ldr    w11, [x0, #48]
+	WORD $0xb81f014b // stur    w11, [x10, #-16]
+	WORD $0xb940340b // ldr    w11, [x0, #52]
+	WORD $0xb81f414b // stur    w11, [x10, #-12]
+	WORD $0xb940380b // ldr    w11, [x0, #56]
+	WORD $0xb81f814b // stur    w11, [x10, #-8]
+	WORD $0xb9403c0b // ldr    w11, [x0, #60]
+	WORD $0xb81fc14b // stur    w11, [x10, #-4]
+	WORD $0xb940400b // ldr    w11, [x0, #64]
+	WORD $0xb900014b // str    w11, [x10]
+	WORD $0xb940440b // ldr    w11, [x0, #68]
+	WORD $0xb900054b // str    w11, [x10, #4]
+	WORD $0xb940480b // ldr    w11, [x0, #72]
+	WORD $0xb900094b // str    w11, [x10, #8]
+	WORD $0xb9404c0b // ldr    w11, [x0, #76]
+	WORD $0xb9000d4b // str    w11, [x10, #12]
+	WORD $0xb940500b // ldr    w11, [x0, #80]
+	WORD $0xb900114b // str    w11, [x10, #16]
+	WORD $0xb940540b // ldr    w11, [x0, #84]
+	WORD $0xb900154b // str    w11, [x10, #20]
+	WORD $0xb940580b // ldr    w11, [x0, #88]
+	WORD $0xb900194b // str    w11, [x10, #24]
+	WORD $0xb9405c0b // ldr    w11, [x0, #92]
+	WORD $0xb9001d4b // str    w11, [x10, #28]
+	WORD $0xb940600b // ldr    w11, [x0, #96]
+	WORD $0xb900214b // str    w11, [x10, #32]
+	WORD $0xb940640b // ldr    w11, [x0, #100]
+	WORD $0xb900254b // str    w11, [x10, #36]
+	WORD $0xb940680b // ldr    w11, [x0, #104]
+	WORD $0xb900294b // str    w11, [x10, #40]
+	WORD $0xb9406c0b // ldr    w11, [x0, #108]
+	WORD $0xb9002d4b // str    w11, [x10, #44]
+	WORD $0xb940700b // ldr    w11, [x0, #112]
+	WORD $0xb900314b // str    w11, [x10, #48]
+	WORD $0xb940740b // ldr    w11, [x0, #116]
+	WORD $0xb900354b // str    w11, [x10, #52]
+	WORD $0xb940780b // ldr    w11, [x0, #120]
+	WORD $0xb900394b // str    w11, [x10, #56]
+	WORD $0xb9407c0b // ldr    w11, [x0, #124]
+	WORD $0x91020000 // add    x0, x0, #128
+	WORD $0xb9003d4b // str    w11, [x10, #60]
+	WORD $0x9102014a // add    x10, x10, #128
+	BNE LBB0_13
+	JMP LBB0_156
+
+LBB0_14:
+	WORD $0x71001c7f // cmp    w3, #7
+	BGT LBB0_29
+
+	// %bb.15:
+	WORD $0x71000c7f // cmp    w3, #3
+	BGT LBB0_42
+
+	// %bb.16:
+	WORD $0x7100047f // cmp    w3, #1
+	BGT LBB0_65
+
+	// %bb.17:
+	WORD $0x34000003 // cbz    w3, .LBB0_103
+
+	// %bb.18:
+	WORD $0x7100047f // cmp    w3, #1
+	BNE LBB0_156
+
+	// %bb.19:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.20:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_201
+	// WORD $0x90000008 // adrp    x8, .LCPI0_200
+	// WORD $0x9000000a // adrp    x10, .LCPI0_202
+	// WORD $0x9000000b // adrp    x11, .LCPI0_206
+	WORD $0x4f000427 // movi    v7.4s, #1
+	VMOVQ LCPI0_201L, LCPI0_201H, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_204
+	VMOVD LCPI0_200, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_203
+	VMOVQ LCPI0_202L, LCPI0_202H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_205
+	VMOVQ LCPI0_204L, LCPI0_204H, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_207
+	VMOVQ LCPI0_203L, LCPI0_203H, V3
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_205L, LCPI0_205H, V5
+	WORD $0xaa0003ea // mov    x10, x0
+	VMOVQ LCPI0_206L, LCPI0_206H, V6
+	VMOVQ LCPI0_207L, LCPI0_207H, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_21:
-    WORD $0xb940000a //    ldr    w10, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x53067d4b //    lsr    w11, w10, #6
-    WORD $0x1e270144 //    fmov    s4, w10
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x4e0c1d64 //    mov    v4.s[1], w11
-    WORD $0x53127d4d //    lsr    w13, w10, #18
-    WORD $0x4e141d84 //    mov    v4.s[2], w12
-    WORD $0x4e1c1da4 //    mov    v4.s[3], w13
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9c0124 //    stur    q4, [x9, #-64]
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x53187d4c //    lsr    w12, w10, #24
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x1e270185 //    fmov    s5, w12
-    WORD $0x2ea14484 //    ushl    v4.2s, v4.2s, v1.2s
-    WORD $0x4e0c1d45 //    mov    v5.s[1], w10
-    WORD $0x6e180485 //    mov    v5.d[1], v4.d[0]
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3c9d0124 //    stur    q4, [x9, #-48]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x9100200c //    add    x12, x0, #8
-    WORD $0x0e040d44 //    dup    v4.2s, w10
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x2ea24484 //    ushl    v4.2s, v4.2s, v2.2s
-    WORD $0x53027d6b //    lsr    w11, w11, #2
-    WORD $0x4e141d44 //    mov    v4.s[2], w10
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9e0124 //    stur    q4, [x9, #-32]
-    WORD $0x4d40c984 //    ld1r    { v4.4s }, [x12]
-    WORD $0x6ea34484 //    ushl    v4.4s, v4.4s, v3.4s
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9f0124 //    stur    q4, [x9, #-16]
-    WORD $0xb9400c0a //    ldr    w10, [x0, #12]
-    WORD $0x53067d4b //    lsr    w11, w10, #6
-    WORD $0x1e270144 //    fmov    s4, w10
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x4e0c1d64 //    mov    v4.s[1], w11
-    WORD $0x53127d4d //    lsr    w13, w10, #18
-    WORD $0x4e141d84 //    mov    v4.s[2], w12
-    WORD $0x4e1c1da4 //    mov    v4.s[3], w13
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800124 //    str    q4, [x9]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x53187d4c //    lsr    w12, w10, #24
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x1e270185 //    fmov    s5, w12
-    WORD $0x2ea14484 //    ushl    v4.2s, v4.2s, v1.2s
-    WORD $0x4e0c1d45 //    mov    v5.s[1], w10
-    WORD $0x6e180485 //    mov    v5.d[1], v4.d[0]
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3d800524 //    str    q4, [x9, #16]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0x9100500c //    add    x12, x0, #20
-    WORD $0x91006000 //    add    x0, x0, #24
-    WORD $0x0e040d44 //    dup    v4.2s, w10
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x2ea24484 //    ushl    v4.2s, v4.2s, v2.2s
-    WORD $0x53027d6b //    lsr    w11, w11, #2
-    WORD $0x4e141d44 //    mov    v4.s[2], w10
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800924 //    str    q4, [x9, #32]
-    WORD $0x4d40c984 //    ld1r    { v4.4s }, [x12]
-    WORD $0x6ea34484 //    ushl    v4.4s, v4.4s, v3.4s
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800d24 //    str    q4, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_21
-    JMP LBB0_99
+	WORD $0xb940000b // ldr    w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270172 // fmov    s18, w11
+	WORD $0x53037d6b // lsr    w11, w11, #3
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x2ea04631 // ushl    v17.2s, v17.2s, v0.2s
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d71 // mov    v17.s[3], w11
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0x4ddfc951 // ld1r    { v17.4s }, [x10], #4
+	WORD $0x6ea14631 // ushl    v17.4s, v17.4s, v1.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0x6ea24631 // ushl    v17.4s, v17.4s, v2.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0x6ea34631 // ushl    v17.4s, v17.4s, v3.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0x6ea44631 // ushl    v17.4s, v17.4s, v4.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0x6ea54631 // ushl    v17.4s, v17.4s, v5.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0x6ea64631 // ushl    v17.4s, v17.4s, v6.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x4d40c811 // ld1r    { v17.4s }, [x0]
+	WORD $0xaa0a03e0 // mov    x0, x10
+	WORD $0x6eb04631 // ushl    v17.4s, v17.4s, v16.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_21
+	JMP LBB0_156
+
 LBB0_22:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000d00000006, R1 // LCPI0_59
-    MOVD $0x0000000900000002, R2 // LCPI0_61
-    MOVD $0x0000001700000010, R3 // LCPI0_63
-    MOVD $0x000000130000000c, R4 // LCPI0_65
-    MOVD $0x0000000f00000008, R5 // LCPI0_67
-    VMOVQ $0x0000000b00000004, $0x0000001900000012, V6 // LCPI0_115
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f0307e0 //    movi    v0.4s, #127
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 //    neg    v2.2s, v2.2s
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-    WORD $0x6ea0b8c6 //    neg    v6.4s, v6.4s
-LBB0_24:
-    WORD $0xb940000a //     ldr    w10, [x0]
-    WORD $0xf1000508 //     subs    x8, x8, #1
-    WORD $0x53077d4b //     lsr    w11, w10, #7
-    WORD $0x1e270147 //     fmov    s7, w10
-    WORD $0x530e7d4c //     lsr    w12, w10, #14
-    WORD $0x4e0c1d67 //     mov    v7.s[1], w11
-    WORD $0x53157d4d //     lsr    w13, w10, #21
-    WORD $0x4e141d87 //     mov    v7.s[2], w12
-    WORD $0x4e1c1da7 //     mov    v7.s[3], w13
-    WORD $0x4e201cf0 //     and    v16.16b, v7.16b, v0.16b
-    WORD $0x3c9c0130 //     stur    q16, [x9, #-64]
-    WORD $0xb940040a //     ldr    w10, [x0, #4]
-    WORD $0x53037d4b //     lsr    w11, w10, #3
-    WORD $0x530a7d4c //     lsr    w12, w10, #10
-    WORD $0x4e0c1d67 //     mov    v7.s[1], w11
-    WORD $0x53117d4a //     lsr    w10, w10, #17
-    WORD $0x4e141d87 //     mov    v7.s[2], w12
-    WORD $0x4e1c1d47 //     mov    v7.s[3], w10
-    WORD $0x4e201ce7 //     and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9d0127 //     stur    q7, [x9, #-48]
-    WORD $0x2940ac0a //     ldp    w10, w11, [x0, #4]
-    WORD $0x53187d4c //     lsr    w12, w10, #24
-    WORD $0x138a7d6a //     extr    w10, w11, w10, #31
-    WORD $0x0e040d67 //     dup    v7.2s, w11
-    WORD $0x1e270190 //     fmov    s16, w12
-    WORD $0x2ea144e7 //     ushl    v7.2s, v7.2s, v1.2s
-    WORD $0x4e0c1d50 //     mov    v16.s[1], w10
-    WORD $0x6e1804f0 //     mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //     and    v7.16b, v16.16b, v0.16b
-    WORD $0x3c9e0127 //     stur    q7, [x9, #-32]
-    WORD $0x29412c0a //     ldp    w10, w11, [x0, #8]
-    WORD $0x53147d4c //     lsr    w12, w10, #20
-    WORD $0x138a6d6a //     extr    w10, w11, w10, #27
-    WORD $0x0e040d67 //     dup    v7.2s, w11
-    WORD $0x1e270190 //     fmov    s16, w12
-    WORD $0x2ea244e7 //     ushl    v7.2s, v7.2s, v2.2s
-    WORD $0x4e0c1d50 //     mov    v16.s[1], w10
-    WORD $0x6e1804f0 //     mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //     and    v7.16b, v16.16b, v0.16b
-    WORD $0x3c9f0127 //     stur    q7, [x9, #-16]
-    WORD $0x2941ac0a //     ldp    w10, w11, [x0, #12]
-    WORD $0x9100600c //     add    x12, x0, #24
-    WORD $0x0e040d47 //     dup    v7.2s, w10
-    WORD $0x138a796a //     extr    w10, w11, w10, #30
-    WORD $0x2ea344e7 //     ushl    v7.2s, v7.2s, v3.2s
-    WORD $0x53057d6b //     lsr    w11, w11, #5
-    WORD $0x4e141d47 //     mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //     mov    v7.s[3], w11
-    WORD $0x4e201ce7 //     and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800127 //     str    q7, [x9]
-    WORD $0x29422c0a //     ldp    w10, w11, [x0, #16]
-    WORD $0x0e040d47 //     dup    v7.2s, w10
-    WORD $0x138a696a //     extr    w10, w11, w10, #26
-    WORD $0x2ea444e7 //     ushl    v7.2s, v7.2s, v4.2s
-    WORD $0x53017d6b //     lsr    w11, w11, #1
-    WORD $0x4e141d47 //     mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //     mov    v7.s[3], w11
-    WORD $0x4e201ce7 //     and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800527 //     str    q7, [x9, #16]
-    WORD $0x2942ac0a //     ldp    w10, w11, [x0, #20]
-    WORD $0x91007000 //     add    x0, x0, #28
-    WORD $0x0e040d47 //     dup    v7.2s, w10
-    WORD $0x53167d4d //     lsr    w13, w10, #22
-    WORD $0x2ea544e7 //     ushl    v7.2s, v7.2s, v5.2s
-    WORD $0x138a756a //     extr    w10, w11, w10, #29
-    WORD $0x4e141da7 //     mov    v7.s[2], w13
-    WORD $0x4e1c1d47 //     mov    v7.s[3], w10
-    WORD $0x4e201ce7 //     and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800927 //     str    q7, [x9, #32]
-    WORD $0x4d40c987 //     ld1r    { v7.4s }, [x12]
-    WORD $0x6ea644e7 //     ushl    v7.4s, v7.4s, v6.4s
-    WORD $0x4e201ce7 //     and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800d27 //     str    q7, [x9, #48]
-    WORD $0x91020129 //     add    x9, x9, #128
-    BNE LBB0_24
-    JMP LBB0_99
-LBB0_25:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x91010029 // add    x9, x1, #64
-    WORD $0x6f00e620 // movi    v0.2d, #0x0000ff000000ff
-LBB0_27:
-    WORD $0xb940000a //    ldr    w10, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9c0121 //    stur    q1, [x9, #-64]
-    WORD $0xb940040a //    ldr    w10, [x0, #4]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9d0121 //    stur    q1, [x9, #-48]
-    WORD $0xb940080a //    ldr    w10, [x0, #8]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9e0121 //    stur    q1, [x9, #-32]
-    WORD $0xb9400c0a //    ldr    w10, [x0, #12]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9f0121 //    stur    q1, [x9, #-16]
-    WORD $0xb940100a //    ldr    w10, [x0, #16]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800121 //    str    q1, [x9]
-    WORD $0xb940140a //    ldr    w10, [x0, #20]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800521 //    str    q1, [x9, #16]
-    WORD $0xb940180a //    ldr    w10, [x0, #24]
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800921 //    str    q1, [x9, #32]
-    WORD $0xb9401c0a //    ldr    w10, [x0, #28]
-    WORD $0x91008000 //    add    x0, x0, #32
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x4e0c1d61 //    mov    v1.s[1], w11
-    WORD $0x53187d4d //    lsr    w13, w10, #24
-    WORD $0x4e141d81 //    mov    v1.s[2], w12
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800d21 //    str    q1, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_27
-    JMP LBB0_99
+	WORD $0x71004c7f // cmp    w3, #19
+	BGT LBB0_48
+
+	// %bb.23:
+	WORD $0x7100447f // cmp    w3, #17
+	BGT LBB0_70
+
+	// %bb.24:
+	WORD $0x7100407f // cmp    w3, #16
+	BEQ LBB0_106
+
+	// %bb.25:
+	WORD $0x7100447f // cmp    w3, #17
+	BNE LBB0_156
+
+	// %bb.26:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.27:
+	WORD $0x4f00d420 // movi    v0.4s, #1, msl #16
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_28:
-    WORD $0x7100805f // cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000001100000008, R1 // LCPI0_73
-    MOVD $0x000000150000000C, R2 // LCPI0_75
-    MOVD $0x0000000b00000002, R3 // LCPI0_77
-    MOVD $0x0000000f00000006, R4 // LCPI0_79
-    MOVD $0x0000000a00000001, R5 // LCPI0_81
-    MOVD $0x0000000e00000005, R6 // LCPI0_83
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00c420 //    movi    v0.4s, #1, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 //    neg    v2.2s, v2.2s
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-    WORD $0x2ea0b8c6 //    neg    v6.2s, v6.2s
-LBB0_30:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x53097d4c //    lsr    w12, w10, #9
-    WORD $0x1e270147 //    fmov    s7, w10
-    WORD $0x53127d4d //    lsr    w13, w10, #18
-    WORD $0x4e0c1d87 //    mov    v7.s[1], w12
-    WORD $0x138a6d6b //    extr    w11, w11, w10, #27
-    WORD $0x4e141da7 //    mov    v7.s[2], w13
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201cf0 //    and    v16.16b, v7.16b, v0.16b
-    WORD $0x3c9c0130 //    stur    q16, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x530d7d4c //    lsr    w12, w10, #13
-    WORD $0x53167d4d //    lsr    w13, w10, #22
-    WORD $0x4e0c1d87 //    mov    v7.s[1], w12
-    WORD $0x138a7d6a //    extr    w10, w11, w10, #31
-    WORD $0x4e141da7 //    mov    v7.s[2], w13
-    WORD $0x4e1c1d47 //    mov    v7.s[3], w10
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9d0127 //    stur    q7, [x9, #-48]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0x0e040d47 //    dup    v7.2s, w10
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x2ea144e7 //    ushl    v7.2s, v7.2s, v1.2s
-    WORD $0x53037d6b //    lsr    w11, w11, #3
-    WORD $0x4e141d47 //    mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9e0127 //    stur    q7, [x9, #-32]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x0e040d47 //    dup    v7.2s, w10
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x2ea244e7 //    ushl    v7.2s, v7.2s, v2.2s
-    WORD $0x53077d6b //    lsr    w11, w11, #7
-    WORD $0x4e141d47 //    mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9f0127 //    stur    q7, [x9, #-16]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a656a //    extr    w10, w11, w10, #25
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x1e270190 //    fmov    s16, w12
-    WORD $0x2ea344e7 //    ushl    v7.2s, v7.2s, v3.2s
-    WORD $0x4e0c1d50 //    mov    v16.s[1], w10
-    WORD $0x6e1804f0 //    mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800127 //    str    q7, [x9]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0x53147d4c //    lsr    w12, w10, #20
-    WORD $0x138a756a //    extr    w10, w11, w10, #29
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x1e270190 //    fmov    s16, w12
-    WORD $0x2ea444e7 //    ushl    v7.2s, v7.2s, v4.2s
-    WORD $0x4e0c1d50 //    mov    v16.s[1], w10
-    WORD $0x6e1804f0 //    mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800527 //    str    q7, [x9, #16]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x2ea544e7 //    ushl    v7.2s, v7.2s, v5.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x53137d6b //    lsr    w11, w11, #19
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d70 //    mov    v16.s[3], w11
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800927 //    str    q7, [x9, #32]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0x91009000 //    add    x0, x0, #36
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x2ea644e7 //    ushl    v7.2s, v7.2s, v6.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x53177d6b //    lsr    w11, w11, #23
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d70 //    mov    v16.s[3], w11
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800d27 //    str    q7, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_30
-    JMP LBB0_99
-LBB0_31:
-    WORD $0x7100805f //cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000e00000004, R1 // LCPI0_87
-    MOVD $0x0000000c00000002, R2 // LCPI0_89
-    MOVD $0x0000001200000008, R3 // LCPI0_85
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00c460 //    movi    v0.4s, #3, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 //    neg    v2.2s, v2.2s
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-LBB0_33:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530a7d4c //    lsr    w12, w10, #10
-    WORD $0x1e270144 //    fmov    s4, w10
-    WORD $0x53147d4d //    lsr    w13, w10, #20
-    WORD $0x4e0c1d84 //    mov    v4.s[1], w12
-    WORD $0x138a796b //    extr    w11, w11, w10, #30
-    WORD $0x4e141da4 //    mov    v4.s[2], w13
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c85 //    and    v5.16b, v4.16b, v0.16b
-    WORD $0x3c9c0125 //    stur    q5, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x53127d4c //    lsr    w12, w10, #18
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x4e0c1d84 //    mov    v4.s[1], w12
-    WORD $0x53067d6b //    lsr    w11, w11, #6
-    WORD $0x4e141d44 //    mov    v4.s[2], w10
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3c9d0124 //    stur    q4, [x9, #-48]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x1e270185 //    fmov    s5, w12
-    WORD $0x2ea14484 //    ushl    v4.2s, v4.2s, v1.2s
-    WORD $0x4e0c1d45 //    mov    v5.s[1], w10
-    WORD $0x6e180485 //    mov    v5.d[1], v4.d[0]
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3c9e0124 //    stur    q4, [x9, #-32]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x2ea24484 //    ushl    v4.2s, v4.2s, v2.2s
-    WORD $0x1e270145 //    fmov    s5, w10
-    WORD $0x6e0c0485 //    mov    v5.s[1], v4.s[0]
-    WORD $0x53167d6b //    lsr    w11, w11, #22
-    WORD $0x6e142485 //    mov    v5.s[2], v4.s[1]
-    WORD $0x4e1c1d65 //    mov    v5.s[3], w11
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3c9f0124 //    stur    q4, [x9, #-16]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0x530a7d4c //    lsr    w12, w10, #10
-    WORD $0x1e270144 //    fmov    s4, w10
-    WORD $0x53147d4d //    lsr    w13, w10, #20
-    WORD $0x4e0c1d84 //    mov    v4.s[1], w12
-    WORD $0x138a796b //    extr    w11, w11, w10, #30
-    WORD $0x4e141da4 //    mov    v4.s[2], w13
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800124 //    str    q4, [x9]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0x0e040d44 //    dup    v4.2s, w10
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x2ea34484 //    ushl    v4.2s, v4.2s, v3.2s
-    WORD $0x53067d6b //    lsr    w11, w11, #6
-    WORD $0x4e141d44 //    mov    v4.s[2], w10
-    WORD $0x4e1c1d64 //    mov    v4.s[3], w11
-    WORD $0x4e201c84 //    and    v4.16b, v4.16b, v0.16b
-    WORD $0x3d800524 //    str    q4, [x9, #16]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x1e270185 //    fmov    s5, w12
-    WORD $0x2ea14484 //    ushl    v4.2s, v4.2s, v1.2s
-    WORD $0x4e0c1d45 //    mov    v5.s[1], w10
-    WORD $0x6e180485 //    mov    v5.d[1], v4.d[0]
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3d800924 //    str    q4, [x9, #32]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0x9100a000 //    add    x0, x0, #40
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e040d64 //    dup    v4.2s, w11
-    WORD $0x2ea24484 //    ushl    v4.2s, v4.2s, v2.2s
-    WORD $0x1e270145 //    fmov    s5, w10
-    WORD $0x6e0c0485 //    mov    v5.s[1], v4.s[0]
-    WORD $0x53167d6b //    lsr    w11, w11, #22
-    WORD $0x6e142485 //    mov    v5.s[2], v4.s[1]
-    WORD $0x4e1c1d65 //    mov    v5.s[3], w11
-    WORD $0x4e201ca4 //    and    v4.16b, v5.16b, v0.16b
-    WORD $0x3d800d24 //    str    q4, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_33
-    JMP LBB0_99
-LBB0_34:
-    WORD $0x7100805f //    cmp    w2, #32
-    BL LBB0_99
-    MOVD $0x0000000e00000003, R1 // LCPI0_93
-    MOVD $0x0000000f00000004, R2 // LCPI0_95
-    MOVD $0x0000001100000006, R3 // LCPI0_97
-    MOVD $0x0000001200000007, R4 // LCPI0_99
-    MOVD $0x0000001300000008, R5 // LCPI0_101
-    MOVD $0x000000150000000a, R6 // LCPI0_114
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00c4e0 //    movi    v0.4s, #7, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 //    neg    v2.2s, v2.2s
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-    WORD $0x2ea0b8c6 //    neg    v6.2s, v6.2s
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x138a456c // extr    w12, w11, w10, #17
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53027d6a // lsr    w10, w11, #2
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb940080c // ldr    w12, [x0, #8]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b4d8a // extr    w10, w12, w11, #19
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9c0101 // stur    q1, [x8, #-64]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x53047d4c // lsr    w12, w10, #4
+	WORD $0x138a556a // extr    w10, w11, w10, #21
+	WORD $0x1e270181 // fmov    s1, w12
+	WORD $0xb940100c // ldr    w12, [x0, #16]
+	WORD $0x4e0c1d41 // mov    v1.s[1], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b5d8a // extr    w10, w12, w11, #23
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9d0101 // stur    q1, [x8, #-48]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x138a656a // extr    w10, w11, w10, #25
+	WORD $0x1e270181 // fmov    s1, w12
+	WORD $0xb940180c // ldr    w12, [x0, #24]
+	WORD $0x4e0c1d41 // mov    v1.s[1], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b6d8a // extr    w10, w12, w11, #27
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9e0101 // stur    q1, [x8, #-32]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x1e270181 // fmov    s1, w12
+	WORD $0xb940200c // ldr    w12, [x0, #32]
+	WORD $0x4e0c1d41 // mov    v1.s[1], w10
+	WORD $0x530e7d6a // lsr    w10, w11, #14
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b7d8a // extr    w10, w12, w11, #31
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9f0101 // stur    q1, [x8, #-16]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53017d6c // lsr    w12, w11, #1
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940280a // ldr    w10, [x0, #40]
+	WORD $0x138b494b // extr    w11, w10, w11, #18
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x53037d4a // lsr    w10, w10, #3
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800101 // str    q1, [x8]
+	WORD $0x29452c0a // ldp    w10, w11, [x0, #40]
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x53057d6c // lsr    w12, w11, #5
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940300a // ldr    w10, [x0, #48]
+	WORD $0x138b594b // extr    w11, w10, w11, #22
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x53077d4a // lsr    w10, w10, #7
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800501 // str    q1, [x8, #16]
+	WORD $0x29462c0a // ldp    w10, w11, [x0, #48]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x53097d6c // lsr    w12, w11, #9
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940380a // ldr    w10, [x0, #56]
+	WORD $0x138b694b // extr    w11, w10, w11, #26
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530b7d4a // lsr    w10, w10, #11
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800901 // str    q1, [x8, #32]
+	WORD $0x29472c0a // ldp    w10, w11, [x0, #56]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x530d7d6c // lsr    w12, w11, #13
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940400a // ldr    w10, [x0, #64]
+	WORD $0x91011000 // add    x0, x0, #68
+	WORD $0x138b794b // extr    w11, w10, w11, #30
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530f7d4a // lsr    w10, w10, #15
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800d01 // str    q1, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_28
+	JMP LBB0_156
+
+LBB0_29:
+	WORD $0x71002c7f // cmp    w3, #11
+	BGT LBB0_54
+
+	// %bb.30:
+	WORD $0x7100247f // cmp    w3, #9
+	BGT LBB0_75
+
+	// %bb.31:
+	WORD $0x7100207f // cmp    w3, #8
+	BEQ LBB0_109
+
+	// %bb.32:
+	WORD $0x7100247f // cmp    w3, #9
+	BNE LBB0_156
+
+	// %bb.33:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.34:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_157
+	// WORD $0x90000009 // adrp    x9, .LCPI0_158
+	// WORD $0x9000000a // adrp    x10, .LCPI0_159
+	WORD $0x4f00c427 // movi    v7.4s, #1, msl #8
+	VMOVD LCPI0_157, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_160
+	VMOVD LCPI0_158, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_161
+	VMOVD LCPI0_159, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_162
+	VMOVD LCPI0_160, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_163
+	VMOVD LCPI0_161, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_164
+	VMOVD LCPI0_162, V5
+	VMOVD LCPI0_163, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_164, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_35:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x138a6d6a // extr    w10, w11, w10, #27
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x2ea04631 // ushl    v17.2s, v17.2s, v0.2s
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x53167d4c // lsr    w12, w10, #22
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x4e141d91 // mov    v17.s[2], w12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x2ea24631 // ushl    v17.2s, v17.2s, v2.2s
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x53037d6a // lsr    w10, w11, #3
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x2ea34631 // ushl    v17.2s, v17.2s, v3.2s
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x53077d6a // lsr    w10, w11, #7
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138a656a // extr    w10, w11, w10, #25
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea44631 // ushl    v17.2s, v17.2s, v4.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x53147d4c // lsr    w12, w10, #20
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea54631 // ushl    v17.2s, v17.2s, v5.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53137d6a // lsr    w10, w11, #19
+	WORD $0x2ea64631 // ushl    v17.2s, v17.2s, v6.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x91009000 // add    x0, x0, #36
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53177d6a // lsr    w10, w11, #23
+	WORD $0x2eb04631 // ushl    v17.2s, v17.2s, v16.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_35
+	JMP LBB0_156
+
 LBB0_36:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530b7d4c //    lsr    w12, w10, #11
-    WORD $0x1e270147 //    fmov    s7, w10
-    WORD $0x138a596d //    extr    w13, w11, w10, #22
-    WORD $0x4e0c1d87 //    mov    v7.s[1], w12
-    WORD $0x53017d6b //    lsr    w11, w11, #1
-    WORD $0x4e141da7 //    mov    v7.s[2], w13
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201cf0 //    and    v16.16b, v7.16b, v0.16b
-    WORD $0x3c9c0130 //    stur    q16, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x138a5d6a //    extr    w10, w11, w10, #23
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x4e0c1d47 //    mov    v7.s[1], w10
-    WORD $0x530d7d6b //    lsr    w11, w11, #13
-    WORD $0x4e141d87 //    mov    v7.s[2], w12
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9d0127 //    stur    q7, [x9, #-48]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0xb940100c //    ldr    w12, [x0, #16]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x2ea144e7 //    ushl    v7.2s, v7.2s, v1.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x138b658b //    extr    w11, w12, w11, #25
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d70 //    mov    v16.s[3], w11
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3c9e0127 //    stur    q7, [x9, #-32]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0x0e040d47 //    dup    v7.2s, w10
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x2ea244e7 //    ushl    v7.2s, v7.2s, v2.2s
-    WORD $0x53057d6b //    lsr    w11, w11, #5
-    WORD $0x4e141d47 //    mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9f0127 //    stur    q7, [x9, #-16]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a6d6a //    extr    w10, w11, w10, #27
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x1e270190 //    fmov    s16, w12
-    WORD $0x2ea344e7 //    ushl    v7.2s, v7.2s, v3.2s
-    WORD $0x4e0c1d50 //    mov    v16.s[1], w10
-    WORD $0x6e1804f0 //    mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800127 //    str    q7, [x9]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xb940200c //    ldr    w12, [x0, #32]
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x2ea444e7 //    ushl    v7.2s, v7.2s, v4.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x138b758b //    extr    w11, w12, w11, #29
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d70 //    mov    v16.s[3], w11
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800527 //    str    q7, [x9, #16]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0x0e040d47 //    dup    v7.2s, w10
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x2ea544e7 //    ushl    v7.2s, v7.2s, v5.2s
-    WORD $0x53097d6b //    lsr    w11, w11, #9
-    WORD $0x4e141d47 //    mov    v7.s[2], w10
-    WORD $0x4e1c1d67 //    mov    v7.s[3], w11
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800927 //    str    q7, [x9, #32]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0x9100b000 //    add    x0, x0, #44
-    WORD $0x53147d4c //    lsr    w12, w10, #20
-    WORD $0x138a7d6a //    extr    w10, w11, w10, #31
-    WORD $0x0e040d67 //    dup    v7.2s, w11
-    WORD $0x1e270190 //    fmov    s16, w12
-    WORD $0x2ea644e7 //    ushl    v7.2s, v7.2s, v6.2s
-    WORD $0x4e0c1d50 //    mov    v16.s[1], w10
-    WORD $0x6e1804f0 //    mov    v16.d[1], v7.d[0]
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800d27 //    str    q7, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_36
-    JMP LBB0_99
-LBB0_37:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000e00000003, R1 // LCPI0_113
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00c5e0 //    movi    v0.4s, #15, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-LBB0_39:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x53047d6b //    lsr    w11, w11, #4
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c43 //    and    v3.16b, v2.16b, v0.16b
-    WORD $0x3c9c0123 //    stur    q3, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x53087d6c //    lsr    w12, w11, #8
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x53147d6b //    lsr    w11, w11, #20
-    WORD $0x4e141d82 //    mov    v2.s[2], w12
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9d0122 //    stur    q2, [x9, #-48]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x53047d6b //    lsr    w11, w11, #4
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9e0122 //    stur    q2, [x9, #-32]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3c9f0122 //    stur    q2, [x9, #-16]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x53047d6b //    lsr    w11, w11, #4
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800122 //    str    q2, [x9]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3d800522 //    str    q2, [x9, #16]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x53047d6b //    lsr    w11, w11, #4
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800922 //    str    q2, [x9, #32]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0x9100c000 //    add    x0, x0, #48
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3d800d22 //    str    q2, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_39
-    JMP LBB0_99
-LBB0_40:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000f00000002, R1 // LCPI0_105
-    MOVD $0x0000001100000004, R2 // LCPI0_107
-    MOVD $0x0000001200000005, R3 // LCPI0_109
-    MOVD $0x0000001300000006, R4 // LCPI0_112
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00c7e0 //    movi    v0.4s, #31, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-    WORD $0x2ea0b842 //    neg    v2.2s, v2.2s
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
+	WORD $0x7100647f // cmp    w3, #25
+	BGT LBB0_80
+
+	// %bb.37:
+	WORD $0x7100607f // cmp    w3, #24
+	BEQ LBB0_112
+
+	// %bb.38:
+	WORD $0x7100647f // cmp    w3, #25
+	BNE LBB0_156
+
+	// %bb.39:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.40:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_76
+	// WORD $0x90000009 // adrp    x9, .LCPI0_77
+	// WORD $0x9000000a // adrp    x10, .LCPI0_78
+	// WORD $0x9000000b // adrp    x11, .LCPI0_91
+	VMOVD LCPI0_76, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_79
+	VMOVD LCPI0_77, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_80
+	VMOVD LCPI0_78, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_81
+	VMOVD LCPI0_79, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_82
+	VMOVD LCPI0_80, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_83
+	VMOVD LCPI0_81, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_84
+	VMOVD LCPI0_82, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_85
+	VMOVD LCPI0_83, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_86
+	VMOVD LCPI0_84, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_87
+	VMOVD LCPI0_85, V17
+	// WORD $0x90000008 // adrp    x8, .LCPI0_88
+	VMOVD LCPI0_86, V18
+	// WORD $0x90000009 // adrp    x9, .LCPI0_89
+	VMOVD LCPI0_87, V19
+	// WORD $0x9000000a // adrp    x10, .LCPI0_90
+	VMOVD LCPI0_88, V20
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_89, V21
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_90, V22
+	VMOVD LCPI0_91, V23
+
+LBB0_41:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404018 // ldur    d24, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x2ea0471b // ushl    v27.2s, v24.2s, v0.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x6e1a235a // ext    v26.16b, v26.16b, v26.16b, #4
+	WORD $0x138a2d6a // extr    w10, w11, w10, #11
+	WORD $0x2ea14739 // ushl    v25.2s, v25.2s, v1.2s
+	WORD $0x0eb91f79 // orr    v25.8b, v27.8b, v25.8b
+	WORD $0x6e196358 // ext    v24.16b, v26.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3c9c0118 // stur    q24, [x8, #-64]
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0xfd400818 // ldr    d24, [x0, #16]
+	WORD $0xb940180b // ldr    w11, [x0, #24]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x53047d4a // lsr    w10, w10, #4
+	WORD $0x2ea2471a // ushl    v26.2s, v24.2s, v2.2s
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x1e27015b // fmov    s27, w10
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x6e1b237b // ext    v27.16b, v27.16b, v27.16b, #4
+	WORD $0x2ea34739 // ushl    v25.2s, v25.2s, v3.2s
+	WORD $0x138a3d6a // extr    w10, w11, w10, #15
+	WORD $0x0eb91f59 // orr    v25.8b, v26.8b, v25.8b
+	WORD $0x6e196378 // ext    v24.16b, v27.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3c9d0118 // stur    q24, [x8, #-48]
+	WORD $0x2943280b // ldp    w11, w10, [x0, #24]
+	WORD $0xfd401018 // ldr    d24, [x0, #32]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x138b214b // extr    w11, w10, w11, #8
+	WORD $0x53017d4a // lsr    w10, w10, #1
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x2ea44718 // ushl    v24.2s, v24.2s, v4.2s
+	WORD $0x1e27017a // fmov    s26, w11
+	WORD $0x2ea54739 // ushl    v25.2s, v25.2s, v5.2s
+	WORD $0x4e0c1d5a // mov    v26.s[1], w10
+	WORD $0x0eb91f18 // orr    v24.8b, v24.8b, v25.8b
+	WORD $0x6e18071a // mov    v26.d[1], v24.d[0]
+	WORD $0x6f0777da // bic    v26.4s, #254, lsl #24
+	WORD $0x3c9e011a // stur    q26, [x8, #-32]
+	WORD $0x2944a80b // ldp    w11, w10, [x0, #36]
+	WORD $0xfc42c018 // ldur    d24, [x0, #44]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x138b314b // extr    w11, w10, w11, #12
+	WORD $0x53057d4a // lsr    w10, w10, #5
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x2ea64718 // ushl    v24.2s, v24.2s, v6.2s
+	WORD $0x1e27017a // fmov    s26, w11
+	WORD $0x2ea74739 // ushl    v25.2s, v25.2s, v7.2s
+	WORD $0x4e0c1d5a // mov    v26.s[1], w10
+	WORD $0x0eb91f18 // orr    v24.8b, v24.8b, v25.8b
+	WORD $0x6e18071a // mov    v26.d[1], v24.d[0]
+	WORD $0x6f0777da // bic    v26.4s, #254, lsl #24
+	WORD $0x3c9f011a // stur    q26, [x8, #-16]
+	WORD $0xfc434018 // ldur    d24, [x0, #52]
+	WORD $0xbd403019 // ldr    s25, [x0, #48]
+	WORD $0xb9403c0c // ldr    w12, [x0, #60]
+	WORD $0x2eb0471a // ushl    v26.2s, v24.2s, v16.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a6d8a // extr    w10, w12, w10, #27
+	WORD $0x2eb14739 // ushl    v25.2s, v25.2s, v17.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d78 // mov    v24.s[2], w11
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3d800118 // str    q24, [x8]
+	WORD $0xfd402018 // ldr    d24, [x0, #64]
+	WORD $0xbd403c19 // ldr    s25, [x0, #60]
+	WORD $0xb940480c // ldr    w12, [x0, #72]
+	WORD $0x2eb2471a // ushl    v26.2s, v24.2s, v18.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x53067d4b // lsr    w11, w10, #6
+	WORD $0x138a7d8a // extr    w10, w12, w10, #31
+	WORD $0x2eb34739 // ushl    v25.2s, v25.2s, v19.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d78 // mov    v24.s[2], w11
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3d800518 // str    q24, [x8, #16]
+	WORD $0xfc44c018 // ldur    d24, [x0, #76]
+	WORD $0xbd404819 // ldr    s25, [x0, #72]
+	WORD $0xb940540b // ldr    w11, [x0, #84]
+	WORD $0x2eb4471a // ushl    v26.2s, v24.2s, v20.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a296a // extr    w10, w11, w10, #10
+	WORD $0x2eb54739 // ushl    v25.2s, v25.2s, v21.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53037d6a // lsr    w10, w11, #3
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3d800918 // str    q24, [x8, #32]
+	WORD $0xfd402c18 // ldr    d24, [x0, #88]
+	WORD $0xbd405419 // ldr    s25, [x0, #84]
+	WORD $0xb940600b // ldr    w11, [x0, #96]
+	WORD $0x91019000 // add    x0, x0, #100
+	WORD $0x2eb6471a // ushl    v26.2s, v24.2s, v22.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a396a // extr    w10, w11, w10, #14
+	WORD $0x2eb74739 // ushl    v25.2s, v25.2s, v23.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53077d6a // lsr    w10, w11, #7
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f0777d8 // bic    v24.4s, #254, lsl #24
+	WORD $0x3d800d18 // str    q24, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_41
+	JMP LBB0_156
+
 LBB0_42:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530d7d4c //    lsr    w12, w10, #13
-    WORD $0x1e270145 //    fmov    s5, w10
-    WORD $0x138a696d //    extr    w13, w11, w10, #26
-    WORD $0x4e0c1d85 //    mov    v5.s[1], w12
-    WORD $0x53077d6b //    lsr    w11, w11, #7
-    WORD $0x4e141da5 //    mov    v5.s[2], w13
-    WORD $0x4e1c1d65 //    mov    v5.s[3], w11
-    WORD $0x4e201ca6 //    and    v6.16b, v5.16b, v0.16b
-    WORD $0x3c9c0126 //    stur    q6, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0x53017d4c //    lsr    w12, w10, #1
-    WORD $0x530e7d4d //    lsr    w13, w10, #14
-    WORD $0x4e0c1d85 //    mov    v5.s[1], w12
-    WORD $0x138a6d6a //    extr    w10, w11, w10, #27
-    WORD $0x4e141da5 //    mov    v5.s[2], w13
-    WORD $0x4e1c1d45 //    mov    v5.s[3], w10
-    WORD $0x4e201ca5 //    and    v5.16b, v5.16b, v0.16b
-    WORD $0x3c9d0125 //    stur    q5, [x9, #-48]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0x53087d4c //    lsr    w12, w10, #8
-    WORD $0x138a556a //    extr    w10, w11, w10, #21
-    WORD $0x0e040d65 //    dup    v5.2s, w11
-    WORD $0x1e270186 //    fmov    s6, w12
-    WORD $0x2ea144a5 //    ushl    v5.2s, v5.2s, v1.2s
-    WORD $0x4e0c1d46 //    mov    v6.s[1], w10
-    WORD $0x6e1804a6 //    mov    v6.d[1], v5.d[0]
-    WORD $0x4e201cc5 //    and    v5.16b, v6.16b, v0.16b
-    WORD $0x3c9e0125 //    stur    q5, [x9, #-32]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0xb940180c //    ldr    w12, [x0, #24]
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x53097d6d //    lsr    w13, w11, #9
-    WORD $0x1e270145 //    fmov    s5, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1da5 //    mov    v5.s[1], w13
-    WORD $0x53037d8c //    lsr    w12, w12, #3
-    WORD $0x4e141d65 //    mov    v5.s[2], w11
-    WORD $0x4e1c1d85 //    mov    v5.s[3], w12
-    WORD $0x4e201ca5 //    and    v5.16b, v5.16b, v0.16b
-    WORD $0x3c9f0125 //    stur    q5, [x9, #-16]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xb940200c //    ldr    w12, [x0, #32]
-    WORD $0x53107d4d //    lsr    w13, w10, #16
-    WORD $0x138a756a //    extr    w10, w11, w10, #29
-    WORD $0x1e2701a5 //    fmov    s5, w13
-    WORD $0x530a7d6e //    lsr    w14, w11, #10
-    WORD $0x4e0c1d45 //    mov    v5.s[1], w10
-    WORD $0x138b5d8b //    extr    w11, w12, w11, #23
-    WORD $0x4e141dc5 //    mov    v5.s[2], w14
-    WORD $0x4e1c1d65 //    mov    v5.s[3], w11
-    WORD $0x4e201ca5 //    and    v5.16b, v5.16b, v0.16b
-    WORD $0x3d800125 //    str    q5, [x9]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0x0e040d45 //    dup    v5.2s, w10
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x2ea244a5 //    ushl    v5.2s, v5.2s, v2.2s
-    WORD $0x530b7d6b //    lsr    w11, w11, #11
-    WORD $0x4e141d45 //    mov    v5.s[2], w10
-    WORD $0x4e1c1d65 //    mov    v5.s[3], w11
-    WORD $0x4e201ca5 //    and    v5.16b, v5.16b, v0.16b
-    WORD $0x3d800525 //    str    q5, [x9, #16]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xb9402c0c //    ldr    w12, [x0, #44]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e040d65 //    dup    v5.2s, w11
-    WORD $0x2ea344a5 //    ushl    v5.2s, v5.2s, v3.2s
-    WORD $0x1e270146 //    fmov    s6, w10
-    WORD $0x6e0c04a6 //    mov    v6.s[1], v5.s[0]
-    WORD $0x138b7d8b //    extr    w11, w12, w11, #31
-    WORD $0x6e1424a6 //    mov    v6.s[2], v5.s[1]
-    WORD $0x4e1c1d66 //    mov    v6.s[3], w11
-    WORD $0x4e201cc5 //    and    v5.16b, v6.16b, v0.16b
-    WORD $0x3d800925 //    str    q5, [x9, #32]
-    WORD $0x2945ac0a //    ldp    w10, w11, [x0, #44]
-    WORD $0x9100d000 //    add    x0, x0, #52
-    WORD $0x530c7d4c //    lsr    w12, w10, #12
-    WORD $0x138a656a //    extr    w10, w11, w10, #25
-    WORD $0x0e040d65 //    dup    v5.2s, w11
-    WORD $0x1e270186 //    fmov    s6, w12
-    WORD $0x2ea444a5 //    ushl    v5.2s, v5.2s, v4.2s
-    WORD $0x4e0c1d46 //    mov    v6.s[1], w10
-    WORD $0x6e1804a6 //    mov    v6.d[1], v5.d[0]
-    WORD $0x4e201cc5 //    and    v5.16b, v6.16b, v0.16b
-    WORD $0x3d800d25 //    str    q5, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_42
-    JMP LBB0_99
-LBB0_43:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000001200000004, R1 // LCPI0_111
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f01c7e0 //    movi    v0.4s, #63, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
-LBB0_45:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530e7d4c //    lsr    w12, w10, #14
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a716d //    extr    w13, w11, w10, #28
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x530a7d6b //    lsr    w11, w11, #10
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9c0122 //    stur    q2, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0xb9400c0c //    ldr    w12, [x0, #12]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x53067d6d //    lsr    w13, w11, #6
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1da2 //    mov    v2.s[1], w13
-    WORD $0x53027d8c //    lsr    w12, w12, #2
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9d0122 //    stur    q2, [x9, #-48]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0xb940140c //    ldr    w12, [x0, #20]
-    WORD $0x53107d4d //    lsr    w13, w10, #16
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x1e2701a2 //    fmov    s2, w13
-    WORD $0x530c7d6e //    lsr    w14, w11, #12
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e141dc2 //    mov    v2.s[2], w14
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9e0122 //    stur    q2, [x9, #-32]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0x53087d4c //    lsr    w12, w10, #8
-    WORD $0x138a596a //    extr    w10, w11, w10, #22
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3c9f0122 //    stur    q2, [x9, #-16]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0x530e7d4c //    lsr    w12, w10, #14
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a716d //    extr    w13, w11, w10, #28
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x530a7d6b //    lsr    w11, w11, #10
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800122 //    str    q2, [x9]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0xb940280c //    ldr    w12, [x0, #40]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x53067d6d //    lsr    w13, w11, #6
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1da2 //    mov    v2.s[1], w13
-    WORD $0x53027d8c //    lsr    w12, w12, #2
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800522 //    str    q2, [x9, #16]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0xb940300c //    ldr    w12, [x0, #48]
-    WORD $0x53107d4d //    lsr    w13, w10, #16
-    WORD $0x138a796a //    extr    w10, w11, w10, #30
-    WORD $0x1e2701a2 //    fmov    s2, w13
-    WORD $0x530c7d6e //    lsr    w14, w11, #12
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e141dc2 //    mov    v2.s[2], w14
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800922 //    str    q2, [x9, #32]
-    WORD $0x29462c0a //    ldp    w10, w11, [x0, #48]
-    WORD $0x9100e000 //    add    x0, x0, #56
-    WORD $0x53087d4c //    lsr    w12, w10, #8
-    WORD $0x138a596a //    extr    w10, w11, w10, #22
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3d800d22 //    str    q2, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_45
-    JMP LBB0_99
-LBB0_46:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000001100000002, R1 // LCPI0_110
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f03c7e0 //    movi    v0.4s, #127, msl #8
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
+	WORD $0x7100147f // cmp    w3, #5
+	BGT LBB0_85
+
+	// %bb.43:
+	WORD $0x7100107f // cmp    w3, #4
+	BEQ LBB0_115
+
+	// %bb.44:
+	WORD $0x7100147f // cmp    w3, #5
+	BNE LBB0_156
+
+	// %bb.45:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.46:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_178
+	// WORD $0x90000009 // adrp    x9, .LCPI0_179
+	// WORD $0x9000000a // adrp    x10, .LCPI0_180
+	WORD $0x4f0007e7 // movi    v7.4s, #31
+	VMOVD LCPI0_178, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_181
+	VMOVD LCPI0_179, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_182
+	VMOVQ LCPI0_180L, LCPI0_180H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_183
+	VMOVD LCPI0_181, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_184
+	VMOVD LCPI0_182, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_185
+	VMOVQ LCPI0_183L, LCPI0_183H, V5
+	VMOVD LCPI0_184, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_185L, LCPI0_185H, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_47:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x530f7d4a // lsr    w10, w10, #15
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x2ea04631 // ushl    v17.2s, v17.2s, v0.2s
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x53037d6a // lsr    w10, w11, #3
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x9100100a // add    x10, x0, #4
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6ea24631 // ushl    v17.4s, v17.4s, v2.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x530b7d6a // lsr    w10, w11, #11
+	WORD $0x2ea34631 // ushl    v17.2s, v17.2s, v3.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x531a7d4c // lsr    w12, w10, #26
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x2ea44631 // ushl    v17.2s, v17.2s, v4.2s
+	WORD $0x4e141d91 // mov    v17.s[2], w12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x9100300a // add    x10, x0, #12
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6ea54631 // ushl    v17.4s, v17.4s, v5.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x53187d4c // lsr    w12, w10, #24
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea64631 // ushl    v17.2s, v17.2s, v6.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x9100400a // add    x10, x0, #16
+	WORD $0x91005000 // add    x0, x0, #20
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6eb04631 // ushl    v17.4s, v17.4s, v16.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_47
+	JMP LBB0_156
+
 LBB0_48:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x530f7d4c //    lsr    w12, w10, #15
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138a796d //    extr    w13, w11, w10, #30
-    WORD $0x4e0c1d82 //    mov    v2.s[1], w12
-    WORD $0x530d7d6b //    lsr    w11, w11, #13
-    WORD $0x4e141da2 //    mov    v2.s[2], w13
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9c0122 //    stur    q2, [x9, #-64]
-    WORD $0x2940ac0a //    ldp    w10, w11, [x0, #4]
-    WORD $0xb9400c0c //    ldr    w12, [x0, #12]
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x530b7d6d //    lsr    w13, w11, #11
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e0c1da2 //    mov    v2.s[1], w13
-    WORD $0x53097d8c //    lsr    w12, w12, #9
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9d0122 //    stur    q2, [x9, #-48]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0xb940140c //    ldr    w12, [x0, #20]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x53077d6d //    lsr    w13, w11, #7
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1da2 //    mov    v2.s[1], w13
-    WORD $0x53057d8c //    lsr    w12, w12, #5
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9e0122 //    stur    q2, [x9, #-32]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0xb9401c0c //    ldr    w12, [x0, #28]
-    WORD $0x138a516a //    extr    w10, w11, w10, #20
-    WORD $0x53037d6d //    lsr    w13, w11, #3
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b498b //    extr    w11, w12, w11, #18
-    WORD $0x4e0c1da2 //    mov    v2.s[1], w13
-    WORD $0x53017d8c //    lsr    w12, w12, #1
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3c9f0122 //    stur    q2, [x9, #-16]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0xb940240c //    ldr    w12, [x0, #36]
-    WORD $0x53107d4d //    lsr    w13, w10, #16
-    WORD $0x138a7d6a //    extr    w10, w11, w10, #31
-    WORD $0x1e2701a2 //    fmov    s2, w13
-    WORD $0x530e7d6e //    lsr    w14, w11, #14
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x138b758b //    extr    w11, w12, w11, #29
-    WORD $0x4e141dc2 //    mov    v2.s[2], w14
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800122 //    str    q2, [x9]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xb9402c0c //    ldr    w12, [x0, #44]
-    WORD $0x530c7d4d //    lsr    w13, w10, #12
-    WORD $0x138a6d6a //    extr    w10, w11, w10, #27
-    WORD $0x1e2701a2 //    fmov    s2, w13
-    WORD $0x530a7d6e //    lsr    w14, w11, #10
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x138b658b //    extr    w11, w12, w11, #25
-    WORD $0x4e141dc2 //    mov    v2.s[2], w14
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800522 //    str    q2, [x9, #16]
-    WORD $0x2945ac0a //    ldp    w10, w11, [x0, #44]
-    WORD $0xb940340c //    ldr    w12, [x0, #52]
-    WORD $0x53087d4d //    lsr    w13, w10, #8
-    WORD $0x138a5d6a //    extr    w10, w11, w10, #23
-    WORD $0x1e2701a2 //    fmov    s2, w13
-    WORD $0x53067d6e //    lsr    w14, w11, #6
-    WORD $0x4e0c1d42 //    mov    v2.s[1], w10
-    WORD $0x138b558b //    extr    w11, w12, w11, #21
-    WORD $0x4e141dc2 //    mov    v2.s[2], w14
-    WORD $0x4e1c1d62 //    mov    v2.s[3], w11
-    WORD $0x4e201c42 //    and    v2.16b, v2.16b, v0.16b
-    WORD $0x3d800922 //    str    q2, [x9, #32]
-    WORD $0x2946ac0a //    ldp    w10, w11, [x0, #52]
-    WORD $0x9100f000 //    add    x0, x0, #60
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x138a4d6a //    extr    w10, w11, w10, #19
-    WORD $0x0e040d62 //    dup    v2.2s, w11
-    WORD $0x1e270183 //    fmov    s3, w12
-    WORD $0x2ea14442 //    ushl    v2.2s, v2.2s, v1.2s
-    WORD $0x4e0c1d43 //    mov    v3.s[1], w10
-    WORD $0x6e180443 //    mov    v3.d[1], v2.d[0]
-    WORD $0x4e201c62 //    and    v2.16b, v3.16b, v0.16b
-    WORD $0x3d800d22 //    str    q2, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_48
-    JMP LBB0_99
-LBB0_49:
-    WORD $0x7100805f //    cmp    w2, #32 
-    BLT LBB0_99
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x6f01e660 //    movi    v0.2d, #0x00ffff0000ffff
-LBB0_51:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9c0121 //    stur    q1, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9d0121 //    stur    q1, [x9, #-48]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9e0121 //    stur    q1, [x9, #-32]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9f0121 //    stur    q1, [x9, #-16]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800121 //    str    q1, [x9]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800521 //    str    q1, [x9, #16]
-    WORD $0x29462c0a //    ldp    w10, w11, [x0, #48]
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800921 //    str    q1, [x9, #32]
-    WORD $0x29472c0a //    ldp    w10, w11, [x0, #56]
-    WORD $0x91010000 //    add    x0, x0, #64
-    WORD $0x53107d4c //    lsr    w12, w10, #16
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x4e0c1d81 //    mov    v1.s[1], w12
-    WORD $0x53107d6d //    lsr    w13, w11, #16
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1da1 //    mov    v1.s[3], w13
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800d21 //    str    q1, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_51
-    JMP LBB0_99
-LBB0_52:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00d420 //    movi    v0.4s, #1, msl #16
+	WORD $0x7100547f // cmp    w3, #21
+	BGT LBB0_90
+
+	// %bb.49:
+	WORD $0x7100507f // cmp    w3, #20
+	BEQ LBB0_118
+
+	// %bb.50:
+	WORD $0x7100547f // cmp    w3, #21
+	BNE LBB0_156
+
+	// %bb.51:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.52:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_118
+	// WORD $0x90000009 // adrp    x9, .LCPI0_119
+	// WORD $0x9000000a // adrp    x10, .LCPI0_120
+	WORD $0x4f00d7f3 // movi    v19.4s, #31, msl #16
+	VMOVD LCPI0_118, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_121
+	VMOVD LCPI0_119, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_122
+	VMOVD LCPI0_120, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_123
+	VMOVD LCPI0_121, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_124
+	VMOVD LCPI0_122, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_125
+	VMOVD LCPI0_123, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_126
+	VMOVD LCPI0_124, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_127
+	VMOVD LCPI0_125, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_128
+	VMOVD LCPI0_126, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_129
+	VMOVD LCPI0_127, V17
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_128, V18
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_129, V20
+
+LBB0_53:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x138a556c // extr    w12, w11, w10, #21
+	WORD $0x1e270155 // fmov    s21, w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e0c1d95 // mov    v21.s[1], w12
+	WORD $0xb940080c // ldr    w12, [x0, #8]
+	WORD $0x4e141d55 // mov    v21.s[2], w10
+	WORD $0x138b7d8a // extr    w10, w12, w11, #31
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3c9c0115 // stur    q21, [x8, #-64]
+	WORD $0x2941280b // ldp    w11, w10, [x0, #8]
+	WORD $0xfd400815 // ldr    d21, [x0, #16]
+	WORD $0x1e270156 // fmov    s22, w10
+	WORD $0x138b514b // extr    w11, w10, w11, #20
+	WORD $0x53097d4a // lsr    w10, w10, #9
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x2ea046b5 // ushl    v21.2s, v21.2s, v0.2s
+	WORD $0x1e270177 // fmov    s23, w11
+	WORD $0x2ea146d6 // ushl    v22.2s, v22.2s, v1.2s
+	WORD $0x4e0c1d57 // mov    v23.s[1], w10
+	WORD $0x0eb61eb5 // orr    v21.8b, v21.8b, v22.8b
+	WORD $0x6e1806b7 // mov    v23.d[1], v21.d[0]
+	WORD $0x4e331ef5 // and    v21.16b, v23.16b, v19.16b
+	WORD $0x3c9d0115 // stur    q21, [x8, #-48]
+	WORD $0xb940140a // ldr    w10, [x0, #20]
+	WORD $0xfd400c15 // ldr    d21, [x0, #24]
+	WORD $0x1e270156 // fmov    s22, w10
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea246b7 // ushl    v23.2s, v21.2s, v2.2s
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x1e270158 // fmov    s24, w10
+	WORD $0x0e0c3eaa // mov    w10, v21.s[1]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x2ea346d6 // ushl    v22.2s, v22.2s, v3.2s
+	WORD $0x53077d4a // lsr    w10, w10, #7
+	WORD $0x0eb61ef6 // orr    v22.8b, v23.8b, v22.8b
+	WORD $0x6e166315 // ext    v21.16b, v24.16b, v22.16b, #12
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3c9e0115 // stur    q21, [x8, #-32]
+	WORD $0xfd401015 // ldr    d21, [x0, #32]
+	WORD $0xbd401c16 // ldr    s22, [x0, #28]
+	WORD $0xb940280c // ldr    w12, [x0, #40]
+	WORD $0x2ea446b7 // ushl    v23.2s, v21.2s, v4.2s
+	WORD $0x0e0c3eaa // mov    w10, v21.s[1]
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x53067d4b // lsr    w11, w10, #6
+	WORD $0x138a6d8a // extr    w10, w12, w10, #27
+	WORD $0x2ea546d6 // ushl    v22.2s, v22.2s, v5.2s
+	WORD $0x0eb61ef5 // orr    v21.8b, v23.8b, v22.8b
+	WORD $0x4e141d75 // mov    v21.s[2], w11
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3c9f0115 // stur    q21, [x8, #-16]
+	WORD $0x2945280b // ldp    w11, w10, [x0, #40]
+	WORD $0xfd401815 // ldr    d21, [x0, #48]
+	WORD $0x1e270156 // fmov    s22, w10
+	WORD $0x138b414b // extr    w11, w10, w11, #16
+	WORD $0x53057d4a // lsr    w10, w10, #5
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x2ea646b5 // ushl    v21.2s, v21.2s, v6.2s
+	WORD $0x1e270177 // fmov    s23, w11
+	WORD $0x2ea746d6 // ushl    v22.2s, v22.2s, v7.2s
+	WORD $0x4e0c1d57 // mov    v23.s[1], w10
+	WORD $0x0eb61eb5 // orr    v21.8b, v21.8b, v22.8b
+	WORD $0x6e1806b7 // mov    v23.d[1], v21.d[0]
+	WORD $0x4e331ef5 // and    v21.16b, v23.16b, v19.16b
+	WORD $0x3d800115 // str    q21, [x8]
+	WORD $0xb940340a // ldr    w10, [x0, #52]
+	WORD $0xfd401c15 // ldr    d21, [x0, #56]
+	WORD $0x1e270156 // fmov    s22, w10
+	WORD $0x53047d4a // lsr    w10, w10, #4
+	WORD $0x2eb046b7 // ushl    v23.2s, v21.2s, v16.2s
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x1e270158 // fmov    s24, w10
+	WORD $0x0e0c3eaa // mov    w10, v21.s[1]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x2eb146d6 // ushl    v22.2s, v22.2s, v17.2s
+	WORD $0x53037d4a // lsr    w10, w10, #3
+	WORD $0x0eb61ef6 // orr    v22.8b, v23.8b, v22.8b
+	WORD $0x6e166315 // ext    v21.16b, v24.16b, v22.16b, #12
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3d800515 // str    q21, [x8, #16]
+	WORD $0xfd402015 // ldr    d21, [x0, #64]
+	WORD $0xbd403c16 // ldr    s22, [x0, #60]
+	WORD $0xb940480c // ldr    w12, [x0, #72]
+	WORD $0x2eb246b7 // ushl    v23.2s, v21.2s, v18.2s
+	WORD $0x0e0c3eaa // mov    w10, v21.s[1]
+	WORD $0x0e953ad6 // zip1    v22.2s, v22.2s, v21.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a5d8a // extr    w10, w12, w10, #23
+	WORD $0x2eb446d6 // ushl    v22.2s, v22.2s, v20.2s
+	WORD $0x0eb61ef5 // orr    v21.8b, v23.8b, v22.8b
+	WORD $0x4e141d75 // mov    v21.s[2], w11
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3d800915 // str    q21, [x8, #32]
+	WORD $0x29492c0a // ldp    w10, w11, [x0, #72]
+	WORD $0x138a316a // extr    w10, w11, w10, #12
+	WORD $0x53017d6c // lsr    w12, w11, #1
+	WORD $0x1e270155 // fmov    s21, w10
+	WORD $0xb940500a // ldr    w10, [x0, #80]
+	WORD $0x91015000 // add    x0, x0, #84
+	WORD $0x138b594b // extr    w11, w10, w11, #22
+	WORD $0x4e0c1d95 // mov    v21.s[1], w12
+	WORD $0x530b7d4a // lsr    w10, w10, #11
+	WORD $0x4e141d75 // mov    v21.s[2], w11
+	WORD $0x4e1c1d55 // mov    v21.s[3], w10
+	WORD $0x4e331eb5 // and    v21.16b, v21.16b, v19.16b
+	WORD $0x3d800d15 // str    q21, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_53
+	JMP LBB0_156
+
 LBB0_54:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a456d //    extr    w13, w11, w10, #17
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53027d6e //    lsr    w14, w11, #2
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b4d8b //    extr    w11, w12, w11, #19
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9c0121 //    stur    q1, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0xb940100c //    ldr    w12, [x0, #16]
-    WORD $0x53047d4d //    lsr    w13, w10, #4
-    WORD $0x138a556a //    extr    w10, w11, w10, #21
-    WORD $0x1e2701a1 //    fmov    s1, w13
-    WORD $0x53067d6e //    lsr    w14, w11, #6
-    WORD $0x4e0c1d41 //    mov    v1.s[1], w10
-    WORD $0x138b5d8b //    extr    w11, w12, w11, #23
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9d0121 //    stur    q1, [x9, #-48]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0xb940180c //    ldr    w12, [x0, #24]
-    WORD $0x53087d4d //    lsr    w13, w10, #8
-    WORD $0x138a656a //    extr    w10, w11, w10, #25
-    WORD $0x1e2701a1 //    fmov    s1, w13
-    WORD $0x530a7d6e //    lsr    w14, w11, #10
-    WORD $0x4e0c1d41 //    mov    v1.s[1], w10
-    WORD $0x138b6d8b //    extr    w11, w12, w11, #27
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9e0121 //    stur    q1, [x9, #-32]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xb940200c //    ldr    w12, [x0, #32]
-    WORD $0x530c7d4d //    lsr    w13, w10, #12
-    WORD $0x138a756a //    extr    w10, w11, w10, #29
-    WORD $0x1e2701a1 //    fmov    s1, w13
-    WORD $0x530e7d6e //    lsr    w14, w11, #14
-    WORD $0x4e0c1d41 //    mov    v1.s[1], w10
-    WORD $0x138b7d8b //    extr    w11, w12, w11, #31
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9f0121 //    stur    q1, [x9, #-16]
-    WORD $0x29442c0a //    ldp    w10, w11, [x0, #32]
-    WORD $0xb940280c //    ldr    w12, [x0, #40]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53017d6d //    lsr    w13, w11, #1
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b498b //    extr    w11, w12, w11, #18
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x53037d8c //    lsr    w12, w12, #3
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800121 //    str    q1, [x9]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0xb940300c //    ldr    w12, [x0, #48]
-    WORD $0x138a516a //    extr    w10, w11, w10, #20
-    WORD $0x53057d6d //    lsr    w13, w11, #5
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x53077d8c //    lsr    w12, w12, #7
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800521 //    str    q1, [x9, #16]
-    WORD $0x29462c0a //    ldp    w10, w11, [x0, #48]
-    WORD $0xb940380c //    ldr    w12, [x0, #56]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x53097d6d //    lsr    w13, w11, #9
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530b7d8c //    lsr    w12, w12, #11
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800921 //    str    q1, [x9, #32]
-    WORD $0x29472c0a //    ldp    w10, w11, [x0, #56]
-    WORD $0xb940400c //    ldr    w12, [x0, #64]
-    WORD $0x91011000 //    add    x0, x0, #68
-    WORD $0x138a716a //    extr    w10, w11, w10, #28
-    WORD $0x530d7d6d //    lsr    w13, w11, #13
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b798b //    extr    w11, w12, w11, #30
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530f7d8c //    lsr    w12, w12, #15
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800d21 //    str    q1, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_54
-    JMP LBB0_99
-LBB0_55:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00d460 //    movi    v0.4s, #3, msl #16
-LBB0_57:        
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a496d //    extr    w13, w11, w10, #18
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53047d6e //    lsr    w14, w11, #4
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9c0121 //    stur    q1, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0xb940100c //    ldr    w12, [x0, #16]
-    WORD $0x53087d4d //    lsr    w13, w10, #8
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x1e2701a1 //    fmov    s1, w13
-    WORD $0x530c7d6e //    lsr    w14, w11, #12
-    WORD $0x4e0c1d41 //    mov    v1.s[1], w10
-    WORD $0x138b798b //    extr    w11, w12, w11, #30
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9d0121 //    stur    q1, [x9, #-48]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0xb940180c //    ldr    w12, [x0, #24]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53027d6d //    lsr    w13, w11, #2
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x53067d8c //    lsr    w12, w12, #6
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9e0121 //    stur    q1, [x9, #-32]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xb940200c //    ldr    w12, [x0, #32]
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x530a7d6d //    lsr    w13, w11, #10
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530e7d8c //    lsr    w12, w12, #14
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9f0121 //    stur    q1, [x9, #-16]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xb9402c0c //    ldr    w12, [x0, #44]
-    WORD $0x138a496d //    extr    w13, w11, w10, #18
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53047d6e //    lsr    w14, w11, #4
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800121 //    str    q1, [x9]
-    WORD $0x2945ac0a //    ldp    w10, w11, [x0, #44]
-    WORD $0xb940340c //    ldr    w12, [x0, #52]
-    WORD $0x53087d4d //    lsr    w13, w10, #8
-    WORD $0x138a696a //    extr    w10, w11, w10, #26
-    WORD $0x1e2701a1 //    fmov    s1, w13
-    WORD $0x530c7d6e //    lsr    w14, w11, #12
-    WORD $0x4e0c1d41 //    mov    v1.s[1], w10
-    WORD $0x138b798b //    extr    w11, w12, w11, #30
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800521 //    str    q1, [x9, #16]
-    WORD $0x2946ac0a //    ldp    w10, w11, [x0, #52]
-    WORD $0xb9403c0c //    ldr    w12, [x0, #60]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53027d6d //    lsr    w13, w11, #2
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x53067d8c //    lsr    w12, w12, #6
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800921 //    str    q1, [x9, #32]
-    WORD $0x2947ac0a //    ldp    w10, w11, [x0, #60]
-    WORD $0xb940440c //    ldr    w12, [x0, #68]
-    WORD $0x91012000 //    add    x0, x0, #72
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x530a7d6d //    lsr    w13, w11, #10
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530e7d8c //    lsr    w12, w12, #14
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800d21 //    str    q1, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_57
-    JMP LBB0_99
-LBB0_58:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000120000001f, R5 // LCPI0_102
-    MOVD $0x0000000e00000001, R1 // LCPI0_103
-    MOVD $0x000000110000001e, R6 // LCPI0_104
-    MOVD $0x0000000f00000002, R2 // LCPI0_105
-    MOVD $0x0000000f0000001c, R7 // LCPI0_106
-    MOVD $0x0000001100000004, R3 // LCPI0_107
-    MOVD $0x0000000e0000001b, R16 // LCPI0_108
-    MOVD $0x0000001200000005, R4 // LCPI0_109
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00d4e0 //    movi    v0.4s, #7, msl #16
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-    WORD $0x2ea0b8c6 //    neg    v6.2s, v6.2s
-    WORD $0x2ea0b8e7 //    neg    v7.2s, v7.2s
-    WORD $0x2ea0ba10 //    neg    v16.2s, v16.2s
+	WORD $0x7100347f // cmp    w3, #13
+	BGT LBB0_95
+
+	// %bb.55:
+	WORD $0x7100307f // cmp    w3, #12
+	BEQ LBB0_121
+
+	// %bb.56:
+	WORD $0x7100347f // cmp    w3, #13
+	BNE LBB0_156
+
+	// %bb.57:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.58:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_140
+	// WORD $0x90000009 // adrp    x9, .LCPI0_141
+	// WORD $0x9000000a // adrp    x10, .LCPI0_142
+	// WORD $0x9000000b // adrp    x11, .LCPI0_143
+	// WORD $0x9000000c // adrp    x12, .LCPI0_144
+	WORD $0x4f00c7e3 // movi    v3.4s, #31, msl #8
+	VMOVD LCPI0_140, V0
+	VMOVD LCPI0_141, V1
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_142, V2
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_143, V4
+	VMOVD LCPI0_144, V5
+
+LBB0_59:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x530d7d4c // lsr    w12, w10, #13
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x4e0c1d86 // mov    v6.s[1], w12
+	WORD $0x4e141d46 // mov    v6.s[2], w10
+	WORD $0x53077d6a // lsr    w10, w11, #7
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3c9c0106 // stur    q6, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x0e040d66 // dup    v6.2s, w11
+	WORD $0x1e270147 // fmov    s7, w10
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x2ea044c6 // ushl    v6.2s, v6.2s, v0.2s
+	WORD $0x138b6d4a // extr    w10, w10, w11, #27
+	WORD $0x6e0720e7 // ext    v7.16b, v7.16b, v7.16b, #4
+	WORD $0x6e0660e6 // ext    v6.16b, v7.16b, v6.16b, #12
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3c9d0106 // stur    q6, [x8, #-48]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x0e040d66 // dup    v6.2s, w11
+	WORD $0x138a556a // extr    w10, w11, w10, #21
+	WORD $0x1e270187 // fmov    s7, w12
+	WORD $0x2ea144c6 // ushl    v6.2s, v6.2s, v1.2s
+	WORD $0x4e0c1d47 // mov    v7.s[1], w10
+	WORD $0x6e1804c7 // mov    v7.d[1], v6.d[0]
+	WORD $0x4e231ce6 // and    v6.16b, v7.16b, v3.16b
+	WORD $0x3c9e0106 // stur    q6, [x8, #-32]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x53097d6c // lsr    w12, w11, #9
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0xb940180a // ldr    w10, [x0, #24]
+	WORD $0x138b594b // extr    w11, w10, w11, #22
+	WORD $0x4e0c1d86 // mov    v6.s[1], w12
+	WORD $0x53037d4a // lsr    w10, w10, #3
+	WORD $0x4e141d66 // mov    v6.s[2], w11
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3c9f0106 // stur    q6, [x8, #-16]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x1e270186 // fmov    s6, w12
+	WORD $0xb940200c // ldr    w12, [x0, #32]
+	WORD $0x4e0c1d46 // mov    v6.s[1], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e141d46 // mov    v6.s[2], w10
+	WORD $0x138b5d8a // extr    w10, w12, w11, #23
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3d800106 // str    q6, [x8]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x0e040d46 // dup    v6.2s, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x2ea244c6 // ushl    v6.2s, v6.2s, v2.2s
+	WORD $0x4e141d46 // mov    v6.s[2], w10
+	WORD $0x530b7d6a // lsr    w10, w11, #11
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3d800506 // str    q6, [x8, #16]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x0e040d66 // dup    v6.2s, w11
+	WORD $0x1e270147 // fmov    s7, w10
+	WORD $0xb9402c0a // ldr    w10, [x0, #44]
+	WORD $0x2ea444c6 // ushl    v6.2s, v6.2s, v4.2s
+	WORD $0x138b7d4a // extr    w10, w10, w11, #31
+	WORD $0x6e0720e7 // ext    v7.16b, v7.16b, v7.16b, #4
+	WORD $0x6e0660e6 // ext    v6.16b, v7.16b, v6.16b, #12
+	WORD $0x4e1c1d46 // mov    v6.s[3], w10
+	WORD $0x4e231cc6 // and    v6.16b, v6.16b, v3.16b
+	WORD $0x3d800906 // str    q6, [x8, #32]
+	WORD $0x2945ac0a // ldp    w10, w11, [x0, #44]
+	WORD $0x9100d000 // add    x0, x0, #52
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x0e040d66 // dup    v6.2s, w11
+	WORD $0x138a656a // extr    w10, w11, w10, #25
+	WORD $0x1e270187 // fmov    s7, w12
+	WORD $0x2ea544c6 // ushl    v6.2s, v6.2s, v5.2s
+	WORD $0x4e0c1d47 // mov    v7.s[1], w10
+	WORD $0x6e1804c7 // mov    v7.d[1], v6.d[0]
+	WORD $0x4e231ce6 // and    v6.16b, v7.16b, v3.16b
+	WORD $0x3d800d06 // str    q6, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_59
+	JMP LBB0_156
+
 LBB0_60:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a4d6d //    extr    w13, w11, w10, #19
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x53067d6e //    lsr    w14, w11, #6
-    WORD $0x4e0c1db1 //    mov    v17.s[1], w13
-    WORD $0x138b658b //    extr    w11, w12, w11, #25
-    WORD $0x4e141dd1 //    mov    v17.s[2], w14
-    WORD $0x4e1c1d71 //    mov    v17.s[3], w11
-    WORD $0x4e201e31 //    and    v17.16b, v17.16b, v0.16b
-    WORD $0x3c9c0131 //    stur    q17, [x9, #-64]
-    WORD $0xb940080a //    ldr    w10, [x0, #8]
-    WORD $0xfc40c011 //    ldur    d17, [x0, #12]
-    WORD $0x1e270152 //    fmov    s18, w10
-    WORD $0x0e913a52 //    zip1    v25.2s, v25.2s, v17.2s
-    WORD $0x530c7d4b //    lsr    w11, w10, #12
-    WORD $0x2ea14633 //    ushl    v19.2s, v17.2s, v1.2s
-    WORD $0x0e0c3e2a //    mov    w10, v17.s[1]
-    WORD $0x2ea54651 //    ushl    v17.2s, v25.2s, v5.2s
-    WORD $0x1e270172 //    fmov    s18, w11
-    WORD $0x0eb11e71 //    orr    v17.8b, v19.8b, v17.8b
-    WORD $0x6e0c0632 //    mov    v25.s[1], v17.s[0]
-    WORD $0x53057d4a //    lsr    w10, w10, #5
-    WORD $0x6e142632 //    mov    v25.s[2], v17.s[1]
-    WORD $0x4e1c1d52 //    mov    v25.s[3], w10
-    WORD $0x4e201e51 //    and    v17.16b, v25.16b, v0.16b
-    WORD $0x3c9d0131 //    stur    q17, [x9, #-48]
-    WORD $0x29422c0a //    ldp    w10, w11, [x0, #16]
-    WORD $0xfd400c11 //    ldr    d17, [x0, #24]
-    WORD $0x1e270172 //    fmov    s18, w11
-    WORD $0x138a616a //    extr    w10, w11, w10, #24
-    WORD $0x0e913a52 //    zip1    v25.2s, v25.2s, v17.2s
-    WORD $0x530b7d6c //    lsr    w12, w11, #11
-    WORD $0x2ea24631 //    ushl    v17.2s, v17.2s, v2.2s
-    WORD $0x1e270153 //    fmov    s19, w10
-    WORD $0x2ea64652 //    ushl    v25.2s, v25.2s, v6.2s
-    WORD $0x4e0c1d93 //    mov    v19.s[1], w12
-    WORD $0x0eb21e31 //    orr    v17.8b, v17.8b, v25.8b
-    WORD $0x6e180633 //    mov    v19.d[1], v17.d[0]
-    WORD $0x4e201e71 //    and    v17.16b, v19.16b, v0.16b
-    WORD $0x3c9e0131 //    stur    q17, [x9, #-32]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0xb940240c //    ldr    w12, [x0, #36]
-    WORD $0x53047d4d //    lsr    w13, w10, #4
-    WORD $0x138a5d6a //    extr    w10, w11, w10, #23
-    WORD $0x1e2701b1 //    fmov    s17, w13
-    WORD $0x530a7d6e //    lsr    w14, w11, #10
-    WORD $0x4e0c1d51 //    mov    v17.s[1], w10
-    WORD $0x138b758b //    extr    w11, w12, w11, #29
-    WORD $0x4e141dd1 //    mov    v17.s[2], w14
-    WORD $0x4e1c1d71 //    mov    v17.s[3], w11
-    WORD $0x4e201e31 //    and    v17.16b, v17.16b, v0.16b
-    WORD $0x3c9f0131 //    stur    q17, [x9, #-16]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xb9402c0c //    ldr    w12, [x0, #44]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53037d6d //    lsr    w13, w11, #3
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1db1 //    mov    v17.s[1], w13
-    WORD $0x53097d8c //    lsr    w12, w12, #9
-    WORD $0x4e141d71 //    mov    v17.s[2], w11
-    WORD $0x4e1c1d91 //    mov    v17.s[3], w12
-    WORD $0x4e201e31 //    and    v17.16b, v17.16b, v0.16b
-    WORD $0x3d800131 //    str    q17, [x9]
-    WORD $0xfd401811 //    ldr    d17, [x0, #48]
-    WORD $0xbd402c12 //    ldr    s18, [x0, #44]
-    WORD $0xb940380a //    ldr    w10, [x0, #56]
-    WORD $0x2ea34633 //    ushl    v19.2s, v17.2s, v3.2s
-    WORD $0x0e913a52 //    zip1    v25.2s, v25.2s, v17.2s
-    WORD $0x0e0c3e2b //    mov    w11, v17.s[1]
-    WORD $0x2ea74651 //    ushl    v17.2s, v25.2s, v7.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb11e71 //    orr    v17.8b, v19.8b, v17.8b
-    WORD $0x138b554a //    extr    w10, w10, w11, #21
-    WORD $0x4e141d91 //    mov    v17.s[2], w12
-    WORD $0x4e1c1d51 //    mov    v17.s[3], w10
-    WORD $0x4e201e31 //    and    v17.16b, v17.16b, v0.16b
-    WORD $0x3d800531 //    str    q17, [x9, #16]
-    WORD $0xb940380a //    ldr    w10, [x0, #56]
-    WORD $0xfc43c011 //    ldur    d17, [x0, #60]
-    WORD $0x1e270152 //    fmov    s18, w10
-    WORD $0x0e913a52 //    zip1    v25.2s, v25.2s, v17.2s
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x2ea44633 //    ushl    v19.2s, v17.2s, v4.2s
-    WORD $0x0e0c3e2a //    mov    w10, v17.s[1]
-    WORD $0x2eb04651 //    ushl    v17.2s, v25.2s, v16.2s
-    WORD $0x1e270172 //    fmov    s18, w11
-    WORD $0x0eb11e71 //    orr    v17.8b, v19.8b, v17.8b
-    WORD $0x6e0c0632 //    mov    v25.s[1], v17.s[0]
-    WORD $0x53017d4a //    lsr    w10, w10, #1
-    WORD $0x6e142632 //    mov    v25.s[2], v17.s[1]
-    WORD $0x4e1c1d52 //    mov    v25.s[3], w10
-    WORD $0x4e201e51 //    and    v17.16b, v25.16b, v0.16b
-    WORD $0x3d800931 //    str    q17, [x9, #32]
-    WORD $0x29482c0a //    ldp    w10, w11, [x0, #64]
-    WORD $0xb940480c //    ldr    w12, [x0, #72]
-    WORD $0x91013000 //    add    x0, x0, #76
-    WORD $0x138a516a //    extr    w10, w11, w10, #20
-    WORD $0x53077d6d //    lsr    w13, w11, #7
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e0c1db1 //    mov    v17.s[1], w13
-    WORD $0x530d7d8c //    lsr    w12, w12, #13
-    WORD $0x4e141d71 //    mov    v17.s[2], w11
-    WORD $0x4e1c1d91 //    mov    v17.s[3], w12
-    WORD $0x4e201e31 //    and    v17.16b, v17.16b, v0.16b
-    WORD $0x3d800d31 //    str    q17, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_60
-    JMP LBB0_99
-LBB0_61:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00d5e0 //    movi    v0.4s, #15, msl #16
-LBB0_63:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a516d //    extr    w13, w11, w10, #20
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53087d6e //    lsr    w14, w11, #8
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9c0121 //    stur    q1, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0xb940100c //    ldr    w12, [x0, #16]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53047d6d //    lsr    w13, w11, #4
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530c7d8c //    lsr    w12, w12, #12
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9d0121 //    stur    q1, [x9, #-48]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0xb9401c0c //    ldr    w12, [x0, #28]
-    WORD $0x138a516d //    extr    w13, w11, w10, #20
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53087d6e //    lsr    w14, w11, #8
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9e0121 //    stur    q1, [x9, #-32]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0xb940240c //    ldr    w12, [x0, #36]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53047d6d //    lsr    w13, w11, #4
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530c7d8c //    lsr    w12, w12, #12
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3c9f0121 //    stur    q1, [x9, #-16]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0xb940300c //    ldr    w12, [x0, #48]
-    WORD $0x138a516d //    extr    w13, w11, w10, #20
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53087d6e //    lsr    w14, w11, #8
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800121 //    str    q1, [x9]
-    WORD $0x29462c0a //    ldp    w10, w11, [x0, #48]
-    WORD $0xb940380c //    ldr    w12, [x0, #56]
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53047d6d //    lsr    w13, w11, #4
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530c7d8c //    lsr    w12, w12, #12
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800521 //    str    q1, [x9, #16]
-    WORD $0x2947ac0a //    ldp    w10, w11, [x0, #60]
-    WORD $0xb940440c //    ldr    w12, [x0, #68]
-    WORD $0x138a516d //    extr    w13, w11, w10, #20
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x53087d6e //    lsr    w14, w11, #8
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e141dc1 //    mov    v1.s[2], w14
-    WORD $0x4e1c1d61 //    mov    v1.s[3], w11
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800921 //    str    q1, [x9, #32]
-    WORD $0x2948ac0a //    ldp    w10, w11, [x0, #68]
-    WORD $0xb9404c0c //    ldr    w12, [x0, #76]
-    WORD $0x91014000 //    add    x0, x0, #80
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x53047d6d //    lsr    w13, w11, #4
-    WORD $0x1e270141 //    fmov    s1, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1da1 //    mov    v1.s[1], w13
-    WORD $0x530c7d8c //    lsr    w12, w12, #12
-    WORD $0x4e141d61 //    mov    v1.s[2], w11
-    WORD $0x4e1c1d81 //    mov    v1.s[3], w12
-    WORD $0x4e201c21 //    and    v1.16b, v1.16b, v0.16b
-    WORD $0x3d800d21 //    str    q1, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-    BNE LBB0_63
-    JMP LBB0_99
+	WORD $0x7100707f // cmp    w3, #28
+	BEQ LBB0_124
+
+	// %bb.61:
+	WORD $0x7100747f // cmp    w3, #29
+	BNE LBB0_156
+
+	// %bb.62:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.63:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_32
+	// WORD $0x90000009 // adrp    x9, .LCPI0_33
+	// WORD $0x9000000a // adrp    x10, .LCPI0_34
+	// WORD $0x9000000b // adrp    x11, .LCPI0_47
+	VMOVD LCPI0_32, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_35
+	VMOVD LCPI0_33, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_36
+	VMOVQ LCPI0_34L, LCPI0_34H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_37
+	VMOVQ LCPI0_35L, LCPI0_35H, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_38
+	VMOVD LCPI0_36, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_39
+	VMOVD LCPI0_37, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_40
+	VMOVQ LCPI0_38L, LCPI0_38H, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_41
+	VMOVQ LCPI0_39L, LCPI0_39H, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_42
+	VMOVQ LCPI0_40L, LCPI0_40H, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_43
+	VMOVQ LCPI0_41L, LCPI0_41H, V17
+	// WORD $0x90000008 // adrp    x8, .LCPI0_44
+	VMOVD LCPI0_42, V18
+	// WORD $0x90000009 // adrp    x9, .LCPI0_45
+	VMOVD LCPI0_43, V19
+	// WORD $0x9000000a // adrp    x10, .LCPI0_46
+	VMOVQ LCPI0_44L, LCPI0_44H, V20
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_45L, LCPI0_45H, V21
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_46, V22
+	VMOVD LCPI0_47, V23
+
 LBB0_64:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000130000001e, R7 // LCPI0_90
-    MOVD $0x0000000d00000002, R1 // LCPI0_91
-    MOVD $0x000000120000001d, R16 // LCPI0_92
-    MOVD $0x0000000e00000003, R2 // LCPI0_93
-    MOVD $0x000000110000001c, R17 // LCPI0_94
-    MOVD $0x0000000f00000004, R3 // LCPI0_95
-    MOVD $0x0000000f0000001a, R25 // LCPI0_96
-    MOVD $0x0000001100000006, R4 // LCPI0_97
-    MOVD $0x0000000e00000019, R19 // LCPI0_98
-    MOVD $0x0000001200000007, R5 // LCPI0_99
-    MOVD $0x0000000d00000018, R20 // LCPI0_100
-    MOVD $0x0000001300000008, R6 // LCPI0_101
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f00d7e0 //    movi    v0.4s, #31, msl #16
-    WORD $0x2ea0b8e7 //    neg    v7.2s, v7.2s
-    WORD $0x2ea0ba10 //    neg    v16.2s, v16.2s
-    WORD $0x2ea0ba31 //    neg    v17.2s, v17.2s
-    WORD $0x2ea0bb39 // neg    v25.2s, v25.2s
-    WORD $0x2ea0ba73 //    neg    v19.2s, v19.2s
-    WORD $0x2ea0ba94 //    neg    v20.2s, v20.2s
-LBB0_66:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a556d //    extr    w13, w11, w10, #21
-    WORD $0x1e270155 //    fmov    s21, w10
-    WORD $0x530a7d6e //    lsr    w14, w11, #10
-    WORD $0x4e0c1db5 //    mov    v21.s[1], w13
-    WORD $0x138b7d8b //    extr    w11, w12, w11, #31
-    WORD $0x4e141dd5 //    mov    v21.s[2], w14
-    WORD $0x4e1c1d75 //    mov    v21.s[3], w11
-    WORD $0x4e201eb5 //    and    v21.16b, v21.16b, v0.16b
-    WORD $0x3c9c0135 //    stur    q21, [x9, #-64]
-    WORD $0x29412c0a //    ldp    w10, w11, [x0, #8]
-    WORD $0xfd400815 //    ldr    d21, [x0, #16]
-    WORD $0x1e270176 //    fmov    s22, w11
-    WORD $0x138a516a //    extr    w10, w11, w10, #20
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x53097d6c //    lsr    w12, w11, #9
-    WORD $0x2ea146b5 //    ushl    v21.2s, v21.2s, v1.2s
-    WORD $0x1e270157 //    fmov    s23, w10
-    WORD $0x2ea746d6 //    ushl    v22.2s, v22.2s, v7.2s
-    WORD $0x4e0c1d97 //    mov    v23.s[1], w12
-    WORD $0x0eb61eb5 //    orr    v21.8b, v21.8b, v22.8b
-    WORD $0x6e1806b7 //    mov    v23.d[1], v21.d[0]
-    WORD $0x4e201ef5 //    and    v21.16b, v23.16b, v0.16b
-    WORD $0x3c9d0135 //    stur    q21, [x9, #-48]
-    WORD $0xb940140a //    ldr    w10, [x0, #20]
-    WORD $0xfd400c15 //    ldr    d21, [x0, #24]
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x2ea246b7 //    ushl    v23.2s, v21.2s, v2.2s
-    WORD $0x0e0c3eaa //    mov    w10, v21.s[1]
-    WORD $0x2eb046d5 //    ushl    v21.2s, v22.2s, v16.2s
-    WORD $0x1e270176 //    fmov    s22, w11
-    WORD $0x0eb51ef5 //    orr    v21.8b, v23.8b, v21.8b
-    WORD $0x6e0c06b6 //    mov    v22.s[1], v21.s[0]
-    WORD $0x53077d4a //    lsr    w10, w10, #7
-    WORD $0x6e1426b6 //    mov    v22.s[2], v21.s[1]
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x4e201ed5 //    and    v21.16b, v22.16b, v0.16b
-    WORD $0x3c9e0135 //    stur    q21, [x9, #-32]
-    WORD $0xfd401015 //    ldr    d21, [x0, #32]
-    WORD $0xbd401c16 //    ldr    s22, [x0, #28]
-    WORD $0xb940280a //    ldr    w10, [x0, #40]
-    WORD $0x2ea346b7 //    ushl    v23.2s, v21.2s, v3.2s
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x0e0c3eab //    mov    w11, v21.s[1]
-    WORD $0x2eb146d5 //    ushl    v21.2s, v22.2s, v17.2s
-    WORD $0x53067d6c //    lsr    w12, w11, #6
-    WORD $0x0eb51ef5 //    orr    v21.8b, v23.8b, v21.8b
-    WORD $0x138b6d4a //    extr    w10, w10, w11, #27
-    WORD $0x4e141d95 //    mov    v21.s[2], w12
-    WORD $0x4e1c1d55 //    mov    v21.s[3], w10
-    WORD $0x4e201eb5 //    and    v21.16b, v21.16b, v0.16b
-    WORD $0x3c9f0135 //    stur    q21, [x9, #-16]
-    WORD $0x29452c0a //    ldp    w10, w11, [x0, #40]
-    WORD $0xfd401815 //    ldr    d21, [x0, #48]
-    WORD $0x1e270176 //    fmov    s22, w11
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x53057d6c //    lsr    w12, w11, #5
-    WORD $0x2ea446b5 //    ushl    v21.2s, v21.2s, v4.2s
-    WORD $0x1e270157 //    fmov    s23, w10
-    WORD $0x2eb246d6 //    ushl    v22.2s, v22.2s, v25.2s
-    WORD $0x4e0c1d97 //    mov    v23.s[1], w12
-    WORD $0x0eb61eb5 //    orr    v21.8b, v21.8b, v22.8b
-    WORD $0x6e1806b7 //    mov    v23.d[1], v21.d[0]
-    WORD $0x4e201ef5 //    and    v21.16b, v23.16b, v0.16b
-    WORD $0x3d800135 //    str    q21, [x9]
-    WORD $0xb940340a //    ldr    w10, [x0, #52]
-    WORD $0xfd401c15 //    ldr    d21, [x0, #56]
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x53047d4b //    lsr    w11, w10, #4
-    WORD $0x2ea546b7 //    ushl    v23.2s, v21.2s, v5.2s
-    WORD $0x0e0c3eaa //    mov    w10, v21.s[1]
-    WORD $0x2eb346d5 //    ushl    v21.2s, v22.2s, v19.2s
-    WORD $0x1e270176 //    fmov    s22, w11
-    WORD $0x0eb51ef5 //    orr    v21.8b, v23.8b, v21.8b
-    WORD $0x6e0c06b6 //    mov    v22.s[1], v21.s[0]
-    WORD $0x53037d4a //    lsr    w10, w10, #3
-    WORD $0x6e1426b6 //    mov    v22.s[2], v21.s[1]
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x4e201ed5 //    and    v21.16b, v22.16b, v0.16b
-    WORD $0x3d800535 //    str    q21, [x9, #16]
-    WORD $0xfd402015 //    ldr    d21, [x0, #64]
-    WORD $0xbd403c16 //    ldr    s22, [x0, #60]
-    WORD $0xb940480a //    ldr    w10, [x0, #72]
-    WORD $0x2ea646b7 //    ushl    v23.2s, v21.2s, v6.2s
-    WORD $0x0e953ad6 //    zip1    v22.2s, v22.2s, v21.2s
-    WORD $0x0e0c3eab //    mov    w11, v21.s[1]
-    WORD $0x2eb446d5 //    ushl    v21.2s, v22.2s, v20.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb51ef5 //    orr    v21.8b, v23.8b, v21.8b
-    WORD $0x138b5d4a //    extr    w10, w10, w11, #23
-    WORD $0x4e141d95 //    mov    v21.s[2], w12
-    WORD $0x4e1c1d55 //    mov    v21.s[3], w10
-    WORD $0x4e201eb5 //    and    v21.16b, v21.16b, v0.16b
-    WORD $0x3d800935 //    str    q21, [x9, #32]
-    WORD $0x29492c0a //    ldp    w10, w11, [x0, #72]
-    WORD $0xb940500c //    ldr    w12, [x0, #80]
-    WORD $0x91015000 //    add    x0, x0, #84
-    WORD $0x138a316a //    extr    w10, w11, w10, #12
-    WORD $0x53017d6d //    lsr    w13, w11, #1
-    WORD $0x1e270155 //    fmov    s21, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1db5 //    mov    v21.s[1], w13
-    WORD $0x530b7d8c //    lsr    w12, w12, #11
-    WORD $0x4e141d75 //    mov    v21.s[2], w11
-    WORD $0x4e1c1d95 //    mov    v21.s[3], w12
-    WORD $0x4e201eb5 //    and    v21.16b, v21.16b, v0.16b
-    WORD $0x3d800d35 //    str    q21, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_66
-    JMP LBB0_99
-LBB0_67:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000e00000018, R4 // LCPI0_84
-    MOVD $0x0000001200000008, R1 // LCPI0_85
-    MOVD $0x000000120000001c, R5 // LCPI0_86
-    MOVD $0x0000000e00000004, R2 // LCPI0_87
-    MOVD $0x000000140000001e, R6 // LCPI0_88
-    MOVD $0x0000000c00000002, R3 // LCPI0_89
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f01d7e0 //    movi    v0.4s, #63, msl #16
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-    WORD $0x2ea0b8c6 //    neg    v6.2s, v6.2s
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404018 // ldur    d24, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x2ea0471b // ushl    v27.2s, v24.2s, v0.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x6e1a235a // ext    v26.16b, v26.16b, v26.16b, #4
+	WORD $0x138a5d6a // extr    w10, w11, w10, #23
+	WORD $0x2ea14739 // ushl    v25.2s, v25.2s, v1.2s
+	WORD $0x0eb91f79 // orr    v25.8b, v27.8b, v25.8b
+	WORD $0x6e196358 // ext    v24.16b, v26.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3c9c0118 // stur    q24, [x8, #-64]
+	WORD $0xbd400c18 // ldr    s24, [x0, #12]
+	WORD $0x3dc00419 // ldr    q25, [x0, #16]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea24739 // ushl    v25.4s, v25.4s, v2.4s
+	WORD $0x6ea34718 // ushl    v24.4s, v24.4s, v3.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3c9d0118 // stur    q24, [x8, #-48]
+	WORD $0xfd401018 // ldr    d24, [x0, #32]
+	WORD $0xbd401c19 // ldr    s25, [x0, #28]
+	WORD $0xb940280c // ldr    w12, [x0, #40]
+	WORD $0x2ea4471a // ushl    v26.2s, v24.2s, v4.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a7d8a // extr    w10, w12, w10, #31
+	WORD $0x2ea54739 // ushl    v25.2s, v25.2s, v5.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d78 // mov    v24.s[2], w11
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3c9e0118 // stur    q24, [x8, #-32]
+	WORD $0xbd402818 // ldr    s24, [x0, #40]
+	WORD $0x3cc2c019 // ldur    q25, [x0, #44]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea64739 // ushl    v25.4s, v25.4s, v6.4s
+	WORD $0x6ea74718 // ushl    v24.4s, v24.4s, v7.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3c9f0118 // stur    q24, [x8, #-16]
+	WORD $0xbd403818 // ldr    s24, [x0, #56]
+	WORD $0x3cc3c019 // ldur    q25, [x0, #60]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb04739 // ushl    v25.4s, v25.4s, v16.4s
+	WORD $0x6eb14718 // ushl    v24.4s, v24.4s, v17.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3d800118 // str    q24, [x8]
+	WORD $0x2949280b // ldp    w11, w10, [x0, #72]
+	WORD $0xfd402818 // ldr    d24, [x0, #80]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x138b114b // extr    w11, w10, w11, #4
+	WORD $0x53017d4a // lsr    w10, w10, #1
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x2eb24718 // ushl    v24.2s, v24.2s, v18.2s
+	WORD $0x1e27017a // fmov    s26, w11
+	WORD $0x2eb34739 // ushl    v25.2s, v25.2s, v19.2s
+	WORD $0x4e0c1d5a // mov    v26.s[1], w10
+	WORD $0x0eb91f18 // orr    v24.8b, v24.8b, v25.8b
+	WORD $0x6e18071a // mov    v26.d[1], v24.d[0]
+	WORD $0x6f07741a // bic    v26.4s, #224, lsl #24
+	WORD $0x3d80051a // str    q26, [x8, #16]
+	WORD $0xbd405418 // ldr    s24, [x0, #84]
+	WORD $0x3cc58019 // ldur    q25, [x0, #88]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb44739 // ushl    v25.4s, v25.4s, v20.4s
+	WORD $0x6eb54718 // ushl    v24.4s, v24.4s, v21.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3d800918 // str    q24, [x8, #32]
+	WORD $0xfd403418 // ldr    d24, [x0, #104]
+	WORD $0xbd406419 // ldr    s25, [x0, #100]
+	WORD $0xb940700b // ldr    w11, [x0, #112]
+	WORD $0x9101d000 // add    x0, x0, #116
+	WORD $0x2eb6471a // ushl    v26.2s, v24.2s, v22.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a196a // extr    w10, w11, w10, #6
+	WORD $0x2eb74739 // ushl    v25.2s, v25.2s, v23.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53037d6a // lsr    w10, w11, #3
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077418 // bic    v24.4s, #224, lsl #24
+	WORD $0x3d800d18 // str    q24, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_64
+	JMP LBB0_156
+
+LBB0_65:
+	WORD $0x7100087f // cmp    w3, #2
+	BEQ LBB0_127
+
+	// %bb.66:
+	WORD $0x71000c7f // cmp    w3, #3
+	BNE LBB0_156
+
+	// %bb.67:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.68:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_188
+	// WORD $0x90000009 // adrp    x9, .LCPI0_189
+	// WORD $0x9000000a // adrp    x10, .LCPI0_190
+	WORD $0x4f0004e7 // movi    v7.4s, #7
+	VMOVD LCPI0_188, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_191
+	VMOVQ LCPI0_189L, LCPI0_189H, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_192
+	VMOVD LCPI0_190, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_193
+	VMOVQ LCPI0_191L, LCPI0_191H, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_194
+	VMOVQ LCPI0_192L, LCPI0_192H, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_195
+	VMOVD LCPI0_193, V5
+	VMOVQ LCPI0_194L, LCPI0_194H, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_195L, LCPI0_195H, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_69:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a596d //    extr    w13, w11, w10, #22
-    WORD $0x1e270147 //    fmov    s7, w10
-    WORD $0x138b318b //    extr    w11, w12, w11, #12
-    WORD $0x4e0c1da7 //    mov    v7.s[1], w13
-    WORD $0x53027d8c //    lsr    w12, w12, #2
-    WORD $0x4e141d67 //    mov    v7.s[2], w11
-    WORD $0x4e1c1d87 //    mov    v7.s[3], w12
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9c0127 //    stur    q7, [x9, #-64]
-    WORD $0xfc40c007 //    ldur    d7, [x0, #12]
-    WORD $0xbd400810 //    ldr    s16, [x0, #8]
-    WORD $0xb940140a //    ldr    w10, [x0, #20]
-    WORD $0x2ea144f1 //    ushl    v17.2s, v7.2s, v1.2s
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x0e0c3ceb //    mov    w11, v7.s[1]
-    WORD $0x2ea44607 //    ushl    v7.2s, v16.2s, v4.2s
-    WORD $0x53047d6c //    lsr    w12, w11, #4
-    WORD $0x0ea71e27 //    orr    v7.8b, v17.8b, v7.8b
-    WORD $0x138b694a //    extr    w10, w10, w11, #26
-    WORD $0x4e141d87 //    mov    v7.s[2], w12
-    WORD $0x4e1c1d47 //    mov    v7.s[3], w10
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3c9d0127 //    stur    q7, [x9, #-48]
-    WORD $0x2942ac0a //    ldp    w10, w11, [x0, #20]
-    WORD $0xfc41c007 //    ldur    d7, [x0, #28]
-    WORD $0x1e270170 //    fmov    s16, w11
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x53067d6c //    lsr    w12, w11, #6
-    WORD $0x2ea244e7 //    ushl    v7.2s, v7.2s, v2.2s
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x2ea54610 //    ushl    v16.2s, v16.2s, v5.2s
-    WORD $0x4e0c1d91 //    mov    v17.s[1], w12
-    WORD $0x0eb01ce7 //    orr    v7.8b, v7.8b, v16.8b
-    WORD $0x6e1804f1 //    mov    v17.d[1], v7.d[0]
-    WORD $0x4e201e27 //    and    v7.16b, v17.16b, v0.16b
-    WORD $0x3c9e0127 //    stur    q7, [x9, #-32]
-    WORD $0xb940200a //    ldr    w10, [x0, #32]
-    WORD $0xfc424007 //    ldur    d7, [x0, #36]
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x2ea344f1 //    ushl    v17.2s, v7.2s, v3.2s
-    WORD $0x0e0c3cea //    mov    w10, v7.s[1]
-    WORD $0x2ea64607 //    ushl    v7.2s, v16.2s, v6.2s
-    WORD $0x1e270170 //    fmov    s16, w11
-    WORD $0x0ea71e27 //    orr    v7.8b, v17.8b, v7.8b
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x530a7d4a //    lsr    w10, w10, #10
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d50 //    mov    v16.s[3], w10
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3c9f0127 //    stur    q7, [x9, #-16]
-    WORD $0x2945ac0a //    ldp    w10, w11, [x0, #44]
-    WORD $0x138a596d //    extr    w13, w11, w10, #22
-    WORD $0x1e270147 //    fmov    s7, w10
-    WORD $0x138b318b //    extr    w11, w12, w11, #12
-    WORD $0x4e0c1da7 //    mov    v7.s[1], w13
-    WORD $0x53027d8c //    lsr    w12, w12, #2
-    WORD $0x4e141d67 //    mov    v7.s[2], w11
-    WORD $0x4e1c1d87 //    mov    v7.s[3], w12
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800127 //    str    q7, [x9]
-    WORD $0xfd401c07 //    ldr    d7, [x0, #56]
-    WORD $0xbd403410 //    ldr    s16, [x0, #52]
-    WORD $0xb940400a //    ldr    w10, [x0, #64]
-    WORD $0x2ea144f1 //    ushl    v17.2s, v7.2s, v1.2s
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x0e0c3ceb //    mov    w11, v7.s[1]
-    WORD $0x2ea44607 //    ushl    v7.2s, v16.2s, v4.2s
-    WORD $0x53047d6c //    lsr    w12, w11, #4
-    WORD $0x0ea71e27 //    orr    v7.8b, v17.8b, v7.8b
-    WORD $0x138b694a //    extr    w10, w10, w11, #26
-    WORD $0x4e141d87 //    mov    v7.s[2], w12
-    WORD $0x4e1c1d47 //    mov    v7.s[3], w10
-    WORD $0x4e201ce7 //    and    v7.16b, v7.16b, v0.16b
-    WORD $0x3d800527 //    str    q7, [x9, #16]
-    WORD $0x29482c0a //    ldp    w10, w11, [x0, #64]
-    WORD $0xfd402407 //    ldr    d7, [x0, #72]
-    WORD $0x1e270170 //    fmov    s16, w11
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x53067d6c //    lsr    w12, w11, #6
-    WORD $0x2ea244e7 //    ushl    v7.2s, v7.2s, v2.2s
-    WORD $0x1e270151 //    fmov    s17, w10
-    WORD $0x2ea54610 //    ushl    v16.2s, v16.2s, v5.2s
-    WORD $0x4e0c1d91 //    mov    v17.s[1], w12
-    WORD $0x0eb01ce7 //    orr    v7.8b, v7.8b, v16.8b
-    WORD $0x6e1804f1 //    mov    v17.d[1], v7.d[0]
-    WORD $0x4e201e27 //    and    v7.16b, v17.16b, v0.16b
-    WORD $0x3d800927 //    str    q7, [x9, #32]
-    WORD $0xb9404c0a //    ldr    w10, [x0, #76]
-    WORD $0xfd402807 //    ldr    d7, [x0, #80]
-    WORD $0x91016000 //    add    x0, x0, #88
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x0e873a10 //    zip1    v16.2s, v16.2s, v7.2s
-    WORD $0x53087d4b //    lsr    w11, w10, #8
-    WORD $0x2ea344f1 //    ushl    v17.2s, v7.2s, v3.2s
-    WORD $0x0e0c3cea //    mov    w10, v7.s[1]
-    WORD $0x2ea64607 //    ushl    v7.2s, v16.2s, v6.2s
-    WORD $0x1e270170 //    fmov    s16, w11
-    WORD $0x0ea71e27 //    orr    v7.8b, v17.8b, v7.8b
-    WORD $0x6e0c04f0 //    mov    v16.s[1], v7.s[0]
-    WORD $0x530a7d4a //    lsr    w10, w10, #10
-    WORD $0x6e1424f0 //    mov    v16.s[2], v7.s[1]
-    WORD $0x4e1c1d50 //    mov    v16.s[3], w10
-    WORD $0x4e201e07 //    and    v7.16b, v16.16b, v0.16b
-    WORD $0x3d800d27 //    str    q7, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_69
-    JMP LBB0_99
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53097d4a // lsr    w10, w10, #9
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x2ea04631 // ushl    v17.2s, v17.2s, v0.2s
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0xaa0003ea // mov    x10, x0
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0x4ddfc951 // ld1r    { v17.4s }, [x10], #4
+	WORD $0x6ea14631 // ushl    v17.4s, v17.4s, v1.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0xb940000b // ldr    w11, [x0]
+	WORD $0xb940014c // ldr    w12, [x10]
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138b798b // extr    w11, w12, w11, #30
+	WORD $0x2ea24631 // ushl    v17.2s, v17.2s, v2.2s
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x53017d8b // lsr    w11, w12, #1
+	WORD $0x4e1c1d71 // mov    v17.s[3], w11
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6ea34631 // ushl    v17.4s, v17.4s, v3.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6ea44631 // ushl    v17.4s, v17.4s, v4.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0xb940014a // ldr    w10, [x10]
+	WORD $0xb940080b // ldr    w11, [x0, #8]
+	WORD $0x531c7d4c // lsr    w12, w10, #28
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea54631 // ushl    v17.2s, v17.2s, v5.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x9100200a // add    x10, x0, #8
+	WORD $0x91003000 // add    x0, x0, #12
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6ea64631 // ushl    v17.4s, v17.4s, v6.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6eb04631 // ushl    v17.4s, v17.4s, v16.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_69
+	JMP LBB0_156
+
 LBB0_70:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000130000001c, R16 // LCPI0_70
-    MOVD $0x0000000d00000004, R1 // LCPI0_71
-    MOVD $0x0000000f00000018, R17 // LCPI0_72
-    MOVD $0x0000001100000008, R2 // LCPI0_73
-    MOVD $0x0000000b00000014, R25 // LCPI0_74
-    MOVD $0x000000150000000c, R3 // LCPI0_75
-    MOVD $0x000000150000001e, R19 // LCPI0_76
-    MOVD $0x0000000b00000002, R4 // LCPI0_77
-    MOVD $0x000000110000001a, R20 // LCPI0_78
-    MOVD $0x0000000f00000006, R5 // LCPI0_79
-    MOVD $0x000000160000001f, R21 // LCPI0_80
-    MOVD $0x0000000a00000001, R6 // LCPI0_81
-    MOVD $0x000000120000001b, R22 // LCPI0_82
-    MOVD $0x0000000e00000005, R7 // LCPI0_83
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x4f03d7e0 //    movi    v0.4s, #127, msl #16
-    WORD $0x2ea0ba10 //    neg    v16.2s, v16.2s
-    WORD $0x2ea0ba31 //    neg    v17.2s, v17.2s
-    WORD $0x2ea0bb39 //neg    v25.2s, v25.2s
-    WORD $0x2ea0ba73 //    neg    v19.2s, v19.2s
-    WORD $0x2ea0ba94 //    neg    v20.2s, v20.2s
-    WORD $0x2ea0bab5 //    neg    v21.2s, v21.2s
-    WORD $0x2ea0bad6 //    neg    v22.2s, v22.2s
-LBB0_72: 
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a5d6d //    extr    w13, w11, w10, #23
-    WORD $0x1e270157 //    fmov    s23, w10
-    WORD $0x138b398b //    extr    w11, w12, w11, #14
-    WORD $0x4e0c1db7 //    mov    v23.s[1], w13
-    WORD $0x53057d8c //    lsr    w12, w12, #5
-    WORD $0x4e141d77 //    mov    v23.s[2], w11
-    WORD $0x4e1c1d97 //    mov    v23.s[3], w12
-    WORD $0x4e201ef7 //    and    v23.16b, v23.16b, v0.16b
-    WORD $0x3c9c0137 //    stur    q23, [x9, #-64]
-    WORD $0xfc40c017 //    ldur    d23, [x0, #12]
-    WORD $0xbd400818 //    ldr    s24, [x0, #8]
-    WORD $0xb940140a //    ldr    w10, [x0, #20]
-    WORD $0x2ea146f9 //    ushl    v25.2s, v23.2s, v1.2s
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x0e0c3eeb //    mov    w11, v23.s[1]
-    WORD $0x2eb04717 //    ushl    v23.2s, v24.2s, v16.2s
-    WORD $0x53017d4c //    lsr    w12, w10, #1
-    WORD $0x138b294a //    extr    w10, w10, w11, #10
-    WORD $0x0eb71f37 //    orr    v23.8b, v25.8b, v23.8b
-    WORD $0x4e141d57 //    mov    v23.s[2], w10
-    WORD $0x4e1c1d97 //    mov    v23.s[3], w12
-    WORD $0x4e201ef7 //    and    v23.16b, v23.16b, v0.16b
-    WORD $0x3c9d0137 //    stur    q23, [x9, #-48]
-    WORD $0xfd400c17 //    ldr    d23, [x0, #24]
-    WORD $0xbd401418 //    ldr    s24, [x0, #20]
-    WORD $0xb940200a //    ldr    w10, [x0, #32]
-    WORD $0x2ea246f9 //    ushl    v25.2s, v23.2s, v2.2s
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x0e0c3eeb //    mov    w11, v23.s[1]
-    WORD $0x2eb14717 //    ushl    v23.2s, v24.2s, v17.2s
-    WORD $0x53067d6c //    lsr    w12, w11, #6
-    WORD $0x0eb71f37 //    orr    v23.8b, v25.8b, v23.8b
-    WORD $0x138b754a //    extr    w10, w10, w11, #29
-    WORD $0x4e141d97 //    mov    v23.s[2], w12
-    WORD $0x4e1c1d57 //    mov    v23.s[3], w10
-    WORD $0x4e201ef7 //    and    v23.16b, v23.16b, v0.16b
-    WORD $0x3c9e0137 //    stur    q23, [x9, #-32]
-    WORD $0xfc424017 //    ldur    d23, [x0, #36]
-    WORD $0xbd402018 //    ldr    s24, [x0, #32]
-    WORD $0xb9402c0a //    ldr    w10, [x0, #44]
-    WORD $0x2ea346f9 //    ushl    v25.2s, v23.2s, v3.2s
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x0e0c3eeb //    mov    w11, v23.s[1]
-    WORD $0x2eb24717 //    ushl    v23.2s, v24.2s, v25.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb71f37 //    orr    v23.8b, v25.8b, v23.8b
-    WORD $0x138b654a //    extr    w10, w10, w11, #25
-    WORD $0x4e141d97 //    mov    v23.s[2], w12
-    WORD $0x4e1c1d57 //    mov    v23.s[3], w10
-    WORD $0x4e201ef7 //    and    v23.16b, v23.16b, v0.16b
-    WORD $0x3c9f0137 //    stur    q23, [x9, #-16]
-    WORD $0x2945ac0a //    ldp    w10, w11, [x0, #44]
-    WORD $0xfc434017 //    ldur    d23, [x0, #52]
-    WORD $0x1e270178 //    fmov    s24, w11
-    WORD $0x138a416a //    extr    w10, w11, w10, #16
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x53077d6c //    lsr    w12, w11, #7
-    WORD $0x2ea446f7 //    ushl    v23.2s, v23.2s, v4.2s
-    WORD $0x1e270159 //    fmov    s25, w10
-    WORD $0x2eb34718 //    ushl    v24.2s, v24.2s, v19.2s
-    WORD $0x4e0c1d99 //    mov    v25.s[1], w12
-    WORD $0x0eb81ef7 //    orr    v23.8b, v23.8b, v24.8b
-    WORD $0x6e1806f9 //    mov    v25.d[1], v23.d[0]
-    WORD $0x4e201f37 //    and    v23.16b, v25.16b, v0.16b
-    WORD $0x3d800137 //    str    q23, [x9]
-    WORD $0x29472c0a //    ldp    w10, w11, [x0, #56]
-    WORD $0xfd402017 //    ldr    d23, [x0, #64]
-    WORD $0x1e270178 //    fmov    s24, w11
-    WORD $0x138a316a //    extr    w10, w11, w10, #12
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x53037d6c //    lsr    w12, w11, #3
-    WORD $0x2ea546f7 //    ushl    v23.2s, v23.2s, v5.2s
-    WORD $0x1e270159 //    fmov    s25, w10
-    WORD $0x2eb44718 //    ushl    v24.2s, v24.2s, v20.2s
-    WORD $0x4e0c1d99 //    mov    v25.s[1], w12
-    WORD $0x0eb81ef7 //    orr    v23.8b, v23.8b, v24.8b
-    WORD $0x6e1806f9 //    mov    v25.d[1], v23.d[0]
-    WORD $0x4e201f37 //    and    v23.16b, v25.16b, v0.16b
-    WORD $0x3d800537 //    str    q23, [x9, #16]
-    WORD $0xb940440a //    ldr    w10, [x0, #68]
-    WORD $0xfd402417 //    ldr    d23, [x0, #72]
-    WORD $0xb940500b //    ldr    w11, [x0, #80]
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x53087d4c //    lsr    w12, w10, #8
-    WORD $0x2ea646f9 //    ushl    v25.2s, v23.2s, v6.2s
-    WORD $0x0e0c3eea //    mov    w10, v23.s[1]
-    WORD $0x2eb54717 //    ushl    v23.2s, v24.2s, v21.2s
-    WORD $0x1e270198 //    fmov    s24, w12
-    WORD $0x0eb71f37 //    orr    v23.8b, v25.8b, v23.8b
-    WORD $0x6e0c06f8 //    mov    v24.s[1], v23.s[0]
-    WORD $0x138a356a //    extr    w10, w11, w10, #13
-    WORD $0x6e1426f8 //    mov    v24.s[2], v23.s[1]
-    WORD $0x4e1c1d58 //    mov    v24.s[3], w10
-    WORD $0x4e201f17 //    and    v23.16b, v24.16b, v0.16b
-    WORD $0x3d800937 //    str    q23, [x9, #32]
-    WORD $0xb940500a //    ldr    w10, [x0, #80]
-    WORD $0xfc454017 //    ldur    d23, [x0, #84]
-    WORD $0x91017000 //    add    x0, x0, #92
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x0e973b18 //    zip1    v24.2s, v24.2s, v23.2s
-    WORD $0x53047d4b //    lsr    w11, w10, #4
-    WORD $0x2ea746f9 //    ushl    v25.2s, v23.2s, v7.2s
-    WORD $0x0e0c3eea //    mov    w10, v23.s[1]
-    WORD $0x2eb64717 //    ushl    v23.2s, v24.2s, v22.2s
-    WORD $0x1e270178 //    fmov    s24, w11
-    WORD $0x0eb71f37 //    orr    v23.8b, v25.8b, v23.8b
-    WORD $0x6e0c06f8 //    mov    v24.s[1], v23.s[0]
-    WORD $0x53097d4a //    lsr    w10, w10, #9
-    WORD $0x6e1426f8 //    mov    v24.s[2], v23.s[1]
-    WORD $0x4e1c1d58 //    mov    v24.s[3], w10
-    WORD $0x4e201f17 //    and    v23.16b, v24.16b, v0.16b
-    WORD $0x3d800d37 //    str    q23, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_72
-    JMP LBB0_99
-LBB0_73:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    WORD $0x91001829 //    add    x9, x1, #6
+	WORD $0x7100487f // cmp    w3, #18
+	BEQ LBB0_130
+
+	// %bb.71:
+	WORD $0x71004c7f // cmp    w3, #19
+	BNE LBB0_156
+
+	// %bb.72:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.73:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_130
+	// WORD $0x90000009 // adrp    x9, .LCPI0_131
+	// WORD $0x9000000a // adrp    x10, .LCPI0_132
+	WORD $0x4f00d4e7 // movi    v7.4s, #7, msl #16
+	VMOVD LCPI0_130, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_133
+	VMOVD LCPI0_131, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_134
+	VMOVD LCPI0_132, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_135
+	VMOVD LCPI0_133, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_136
+	VMOVD LCPI0_134, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_137
+	VMOVD LCPI0_135, V5
+	VMOVD LCPI0_136, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_137, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_74:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x138a4d6c // extr    w12, w11, w10, #19
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e0c1d91 // mov    v17.s[1], w12
+	WORD $0xb940080c // ldr    w12, [x0, #8]
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x138b658a // extr    w10, w12, w11, #25
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0xb940080a // ldr    w10, [x0, #8]
+	WORD $0xfc40c011 // ldur    d17, [x0, #12]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x2ea04633 // ushl    v19.2s, v17.2s, v0.2s
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x1e270154 // fmov    s20, w10
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x6e142294 // ext    v20.16b, v20.16b, v20.16b, #4
+	WORD $0x2ea14652 // ushl    v18.2s, v18.2s, v1.2s
+	WORD $0x53057d4a // lsr    w10, w10, #5
+	WORD $0x0eb21e72 // orr    v18.8b, v19.8b, v18.8b
+	WORD $0x6e126291 // ext    v17.16b, v20.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x2942280b // ldp    w11, w10, [x0, #16]
+	WORD $0xfd400c11 // ldr    d17, [x0, #24]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x138b614b // extr    w11, w10, w11, #24
+	WORD $0x530b7d4a // lsr    w10, w10, #11
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x2ea24631 // ushl    v17.2s, v17.2s, v2.2s
+	WORD $0x1e270173 // fmov    s19, w11
+	WORD $0x2ea34652 // ushl    v18.2s, v18.2s, v3.2s
+	WORD $0x4e0c1d53 // mov    v19.s[1], w10
+	WORD $0x0eb21e31 // orr    v17.8b, v17.8b, v18.8b
+	WORD $0x6e180633 // mov    v19.d[1], v17.d[0]
+	WORD $0x4e271e71 // and    v17.16b, v19.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x53047d4c // lsr    w12, w10, #4
+	WORD $0x138a5d6a // extr    w10, w11, w10, #23
+	WORD $0x1e270191 // fmov    s17, w12
+	WORD $0xb940240c // ldr    w12, [x0, #36]
+	WORD $0x4e0c1d51 // mov    v17.s[1], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x138b758a // extr    w10, w12, w11, #29
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53037d6c // lsr    w12, w11, #3
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0xb9402c0a // ldr    w10, [x0, #44]
+	WORD $0x138b594b // extr    w11, w10, w11, #22
+	WORD $0x4e0c1d91 // mov    v17.s[1], w12
+	WORD $0x53097d4a // lsr    w10, w10, #9
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0xfd401811 // ldr    d17, [x0, #48]
+	WORD $0xbd402c12 // ldr    s18, [x0, #44]
+	WORD $0xb940380c // ldr    w12, [x0, #56]
+	WORD $0x2ea44633 // ushl    v19.2s, v17.2s, v4.2s
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a558a // extr    w10, w12, w10, #21
+	WORD $0x2ea54652 // ushl    v18.2s, v18.2s, v5.2s
+	WORD $0x0eb21e71 // orr    v17.8b, v19.8b, v18.8b
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0xb940380a // ldr    w10, [x0, #56]
+	WORD $0xfc43c011 // ldur    d17, [x0, #60]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea64633 // ushl    v19.2s, v17.2s, v6.2s
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x1e270154 // fmov    s20, w10
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x6e142294 // ext    v20.16b, v20.16b, v20.16b, #4
+	WORD $0x2eb04652 // ushl    v18.2s, v18.2s, v16.2s
+	WORD $0x53017d4a // lsr    w10, w10, #1
+	WORD $0x0eb21e72 // orr    v18.8b, v19.8b, v18.8b
+	WORD $0x6e126291 // ext    v17.16b, v20.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x29482c0a // ldp    w10, w11, [x0, #64]
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x53077d6c // lsr    w12, w11, #7
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0xb940480a // ldr    w10, [x0, #72]
+	WORD $0x91013000 // add    x0, x0, #76
+	WORD $0x138b694b // extr    w11, w10, w11, #26
+	WORD $0x4e0c1d91 // mov    v17.s[1], w12
+	WORD $0x530d7d4a // lsr    w10, w10, #13
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_74
+	JMP LBB0_156
+
 LBB0_75:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0xb940080c //    ldr    w12, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3c9c0120 //    stur    q0, [x9, #-64]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0xb940140c //    ldr    w12, [x0, #20]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3c9d0120 //    stur    q0, [x9, #-48]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xb940200c //    ldr    w12, [x0, #32]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3c9e0120 //    stur    q0, [x9, #-32]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xb9402c0c //    ldr    w12, [x0, #44]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3c9f0120 //    stur    q0, [x9, #-16]
-    WORD $0x29462c0a //    ldp    w10, w11, [x0, #48]
-    WORD $0xb940380c //    ldr    w12, [x0, #56]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3d800120 //    str    q0, [x9]
-    WORD $0x2947ac0a //    ldp    w10, w11, [x0, #60]
-    WORD $0xb940440c //    ldr    w12, [x0, #68]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3d800520 //    str    q0, [x9, #16]
-    WORD $0x29492c0a //    ldp    w10, w11, [x0, #72]
-    WORD $0xb940500c //    ldr    w12, [x0, #80]
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3d800920 //    str    q0, [x9, #32]
-    WORD $0x294aac0a //    ldp    w10, w11, [x0, #84]
-    WORD $0xb9405c0c //    ldr    w12, [x0, #92]
-    WORD $0x91018000 //    add    x0, x0, #96
-    WORD $0x138a616d //    extr    w13, w11, w10, #24
-    WORD $0x1e270140 //    fmov    s0, w10
-    WORD $0x138b418b //    extr    w11, w12, w11, #16
-    WORD $0x4e0c1da0 //    mov    v0.s[1], w13
-    WORD $0x53087d8c //    lsr    w12, w12, #8
-    WORD $0x4e141d60 //    mov    v0.s[2], w11
-    WORD $0x4e1c1d80 //    mov    v0.s[3], w12
-    WORD $0x6f0777e0 //    bic    v0.4s, #255, lsl #24
-    WORD $0x3d800d20 //    str    q0, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_75
-    JMP LBB0_99
-LBB0_76:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000160000001d, R7 // LCPI0_56
-    MOVD $0x0000000a00000003, R0 // LCPI0_57
-    MOVD $0x000000130000001a, R16 // LCPI0_58
-    MOVD $0x0000000d00000006, R1 // LCPI0_59
-    MOVD $0x000000170000001e, R17 // LCPI0_60
-    MOVD $0x0000000900000002, R2 // LCPI0_61
-    MOVD $0x0000000900000010, R25 // LCPI0_62
-    MOVD $0x0000001700000010, R3 // LCPI0_63
-    MOVD $0x0000000d00000014, R19 // LCPI0_64
-    MOVD $0x000000130000000c, R4 // LCPI0_65
-    MOVD $0x0000001100000018, R20 // LCPI0_66
-    MOVD $0x0000000f00000008, R5 // LCPI0_67
-    MOVD $0x000000150000001c, R21 // LCPI0_68
-    MOVD $0x0000000b00000004, R6 // LCPI0_69
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x2ea0b8e7 //    neg    v7.2s, v7.2s
-    WORD $0x2ea0ba10 //    neg    v16.2s, v16.2s
-    WORD $0x2ea0ba31 //    neg    v17.2s, v17.2s
-    WORD $0x2ea0bb39 //    neg    v25.2s, v25.2s
-    WORD $0x2ea0ba73 //    neg    v19.2s, v19.2s
-    WORD $0x2ea0ba94 //    neg    v20.2s, v20.2s
-    WORD $0x2ea0bab5 //    neg    v21.2s, v21.2s
-LBB0_78:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a656e //    extr    w14, w11, w10, #25
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x138b498b //    extr    w11, w12, w11, #18
-    WORD $0x4e0c1dd6 //    mov    v22.s[1], w14
-    WORD $0x138c2dac //    extr    w12, w13, w12, #11
-    WORD $0x4e141d76 //    mov    v22.s[2], w11
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f0777d6 //    bic    v22.4s, #254, lsl #24
-    WORD $0x3c9c0136 //    stur    q22, [x9, #-64]
-    WORD $0xb9400c0a //    ldr    w10, [x0, #12]
-    WORD $0xfd400816 //    ldr    d22, [x0, #16]
-    WORD $0xb940180b //    ldr    w11, [x0, #24]
-    WORD $0x1e270157 //    fmov    s23, w10
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x2ea046d8 //    ushl    v24.2s, v22.2s, v0.2s
-    WORD $0x0e0c3eca //    mov    w10, v22.s[1]
-    WORD $0x2ea746f6 //    ushl    v22.2s, v23.2s, v7.2s
-    WORD $0x1e270197 //    fmov    s23, w12
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x6e0c06d7 //    mov    v23.s[1], v22.s[0]
-    WORD $0x138a3d6a //    extr    w10, w11, w10, #15
-    WORD $0x6e1426d7 //    mov    v23.s[2], v22.s[1]
-    WORD $0x4e1c1d57 //    mov    v23.s[3], w10
-    WORD $0x6f0777d7 //    bic    v23.4s, #254, lsl #24
-    WORD $0x3c9d0137 //    stur    q23, [x9, #-48]
-    WORD $0x29432c0a //    ldp    w10, w11, [x0, #24]
-    WORD $0xfd401016 //    ldr    d22, [x0, #32]
-    WORD $0x1e270177 //    fmov    s23, w11
-    WORD $0x138a216a //    extr    w10, w11, w10, #8
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53017d6c //    lsr    w12, w11, #1
-    WORD $0x2ea146d6 //    ushl    v22.2s, v22.2s, v1.2s
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x2eb046f7 //    ushl    v23.2s, v23.2s, v16.2s
-    WORD $0x4e0c1d98 //    mov    v24.s[1], w12
-    WORD $0x0eb71ed6 //    orr    v22.8b, v22.8b, v23.8b
-    WORD $0x6e1806d8 //    mov    v24.d[1], v22.d[0]
-    WORD $0x6f0777d8 //    bic    v24.4s, #254, lsl #24
-    WORD $0x3c9e0138 //    stur    q24, [x9, #-32]
-    WORD $0x2944ac0a //    ldp    w10, w11, [x0, #36]
-    WORD $0xfc42c016 //    ldur    d22, [x0, #44]
-    WORD $0x1e270177 //    fmov    s23, w11
-    WORD $0x138a316a //    extr    w10, w11, w10, #12
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53057d6c //    lsr    w12, w11, #5
-    WORD $0x2ea246d6 //    ushl    v22.2s, v22.2s, v2.2s
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x2eb146f7 //    ushl    v23.2s, v23.2s, v17.2s
-    WORD $0x4e0c1d98 //    mov    v24.s[1], w12
-    WORD $0x0eb71ed6 //    orr    v22.8b, v22.8b, v23.8b
-    WORD $0x6e1806d8 //    mov    v24.d[1], v22.d[0]
-    WORD $0x6f0777d8 //    bic    v24.4s, #254, lsl #24
-    WORD $0x3c9f0138 //    stur    q24, [x9, #-16]
-    WORD $0xfc434016 //    ldur    d22, [x0, #52]
-    WORD $0xbd403017 //    ldr    s23, [x0, #48]
-    WORD $0xb9403c0a //    ldr    w10, [x0, #60]
-    WORD $0x2ea346d8 //    ushl    v24.2s, v22.2s, v3.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb246f6 //    ushl    v22.2s, v23.2s, v25.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x138b6d4a //    extr    w10, w10, w11, #27
-    WORD $0x4e141d96 //    mov    v22.s[2], w12
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x6f0777d6 //    bic    v22.4s, #254, lsl #24
-    WORD $0x3d800136 //    str    q22, [x9]
-    WORD $0xfd402016 //    ldr    d22, [x0, #64]
-    WORD $0xbd403c17 //    ldr    s23, [x0, #60]
-    WORD $0xb940480a //    ldr    w10, [x0, #72]
-    WORD $0x2ea446d8 //    ushl    v24.2s, v22.2s, v4.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb346f6 //    ushl    v22.2s, v23.2s, v19.2s
-    WORD $0x53067d6c //    lsr    w12, w11, #6
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x138b7d4a //    extr    w10, w10, w11, #31
-    WORD $0x4e141d96 //    mov    v22.s[2], w12
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x6f0777d6 //    bic    v22.4s, #254, lsl #24
-    WORD $0x3d800536 //    str    q22, [x9, #16]
-    WORD $0xfc44c016 //    ldur    d22, [x0, #76]
-    WORD $0xbd404817 //    ldr    s23, [x0, #72]
-    WORD $0xb940540a //    ldr    w10, [x0, #84]
-    WORD $0x2ea546d8 //    ushl    v24.2s, v22.2s, v5.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb446f6 //    ushl    v22.2s, v23.2s, v20.2s
-    WORD $0x53037d4c //    lsr    w12, w10, #3
-    WORD $0x138b294a //    extr    w10, w10, w11, #10
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f0777d6 //    bic    v22.4s, #254, lsl #24
-    WORD $0x3d800936 //    str    q22, [x9, #32]
-    WORD $0xfd402c16 //    ldr    d22, [x0, #88]
-    WORD $0xbd405417 //    ldr    s23, [x0, #84]
-    WORD $0xb940600a //    ldr    w10, [x0, #96]
-    WORD $0x91019000 //    add    x0, x0, #100
-    WORD $0x2ea646d8 //    ushl    v24.2s, v22.2s, v6.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb546f6 //    ushl    v22.2s, v23.2s, v21.2s
-    WORD $0x138b394a //    extr    w10, w10, w11, #14
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f0777d6 //    bic    v22.4s, #254, lsl #24
-    WORD $0x3d800d36 //    str    q22, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_78
-    JMP LBB0_99
+	WORD $0x7100287f // cmp    w3, #10
+	BEQ LBB0_133
+
+	// %bb.76:
+	WORD $0x71002c7f // cmp    w3, #11
+	BNE LBB0_156
+
+	// %bb.77:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.78:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_147
+	// WORD $0x90000008 // adrp    x8, .LCPI0_146
+	// WORD $0x9000000a // adrp    x10, .LCPI0_148
+	WORD $0x4f00c4e6 // movi    v6.4s, #7, msl #8
+	VMOVD LCPI0_147, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_150
+	VMOVD LCPI0_146, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_149
+	VMOVD LCPI0_148, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_151
+	VMOVD LCPI0_150, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_152
+	VMOVD LCPI0_149, V3
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_151, V5
+	VMOVD LCPI0_152, V7
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_79:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000070000000c, R7 // LCPI0_36
-    MOVD $0x0000001900000014, R0 // LCPI0_37
-    VMOVQ $0x0000001300000018, $0x000000090000000e, V16 // LCPI0_38
-    VMOVQ $0x0000000d00000008, $0x0000001700000012, V1 // LCPI0_39
-    MOVD $0x0000001a0000001f, R17 // LCPI0_40
-    MOVD $0x0000000600000001, R2 // LCPI0_41
-    MOVD $0x0000000b00000010, R25 // LCPI0_42
-    MOVD $0x0000001500000010, R3 // LCPI0_43
-    VMOVQ $0x000000170000001c, $0x0000000d00000012, V19 // LCPI0_44
-    VMOVQ $0x0000000900000004, $0x000000130000000e, V4 // LCPI0_45
-    MOVD $0x000000190000001e, R20 // LCPI0_46
-    MOVD $0x0000000700000002, R5 // LCPI0_47
-    MOVD $0x0000000f00000014, R21 // LCPI0_48
-    MOVD $0x000000110000000c, R6 // LCPI0_49
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x2ea0b8e7 //    neg    v7.2s, v7.2s
-    WORD $0x6ea0ba10 //    neg    v16.4s, v16.4s
-    WORD $0x2ea0ba31 //    neg    v17.2s, v17.2s
-    WORD $0x2ea0bb39 //    neg    v25.2s, v25.2s
-    WORD $0x6ea0ba73 //    neg    v19.4s, v19.4s
-    WORD $0x2ea0ba94 //    neg    v20.2s, v20.2s
-    WORD $0x2ea0bab5 //    neg    v21.2s, v21.2s
-LBB0_81: 
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a6d6e //    extr    w14, w11, w10, #27
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x138b598b //    extr    w11, w12, w11, #22
-    WORD $0x4e0c1dd6 //    mov    v22.s[1], w14
-    WORD $0x138c45ac //    extr    w12, w13, w12, #17
-    WORD $0x4e141d76 //    mov    v22.s[2], w11
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3c9c0136 //    stur    q22, [x9, #-64]
-    WORD $0xfd400816 //    ldr    d22, [x0, #16]
-    WORD $0xbd400c17 //    ldr    s23, [x0, #12]
-    WORD $0xb940180a //    ldr    w10, [x0, #24]
-    WORD $0x2ea046d8 //    ushl    v24.2s, v22.2s, v0.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2ea746f6 //    ushl    v22.2s, v23.2s, v7.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x138b754a //    extr    w10, w10, w11, #29
-    WORD $0x4e141d96 //    mov    v22.s[2], w12
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3c9d0136 //    stur    q22, [x9, #-48]
-    WORD $0xbd401816 //    ldr    s22, [x0, #24]
-    WORD $0x3cc1c017 //    ldur    q23, [x0, #28]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6ea146f8 //    ushl    v24.4s, v23.4s, v1.4s
-    WORD $0x6eb046d6 //    ushl    v22.4s, v22.4s, v16.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3c9e0136 //    stur    q22, [x9, #-32]
-    WORD $0xb940280a //    ldr    w10, [x0, #40]
-    WORD $0xfc42c016 //    ldur    d22, [x0, #44]
-    WORD $0xb940340b //    ldr    w11, [x0, #52]
-    WORD $0x1e270157 //    fmov    s23, w10
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x2ea246d8 //    ushl    v24.2s, v22.2s, v2.2s
-    WORD $0x0e0c3eca //    mov    w10, v22.s[1]
-    WORD $0x2eb146f6 //    ushl    v22.2s, v23.2s, v17.2s
-    WORD $0x1e270197 //    fmov    s23, w12
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x6e0c06d7 //    mov    v23.s[1], v22.s[0]
-    WORD $0x138a556a //    extr    w10, w11, w10, #21
-    WORD $0x6e1426d7 //    mov    v23.s[2], v22.s[1]
-    WORD $0x4e1c1d57 //    mov    v23.s[3], w10
-    WORD $0x6f077717 //    bic    v23.4s, #248, lsl #24
-    WORD $0x3c9f0137 //    stur    q23, [x9, #-16]
-    WORD $0xfd401c16 //    ldr    d22, [x0, #56]
-    WORD $0xbd403417 //    ldr    s23, [x0, #52]
-    WORD $0xb940400a //    ldr    w10, [x0, #64]
-    WORD $0x2ea346d8 //    ushl    v24.2s, v22.2s, v3.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb246f6 //    ushl    v22.2s, v23.2s, v25.2s
-    WORD $0x53017d4c //    lsr    w12, w10, #1
-    WORD $0x138b194a //    extr    w10, w10, w11, #6
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3d800136 //    str    q22, [x9]
-    WORD $0xbd404016 //    ldr    s22, [x0, #64]
-    WORD $0x3cc44017 //    ldur    q23, [x0, #68]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6ea446f8 //    ushl    v24.4s, v23.4s, v4.4s
-    WORD $0x6eb346d6 //    ushl    v22.4s, v22.4s, v19.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3d800536 //    str    q22, [x9, #16]
-    WORD $0x294a2c0a //    ldp    w10, w11, [x0, #80]
-    WORD $0xfd402c16 //    ldr    d22, [x0, #88]
-    WORD $0x1e270177 //    fmov    s23, w11
-    WORD $0x138a216a //    extr    w10, w11, w10, #8
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53037d6c //    lsr    w12, w11, #3
-    WORD $0x2ea546d6 //    ushl    v22.2s, v22.2s, v5.2s
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x2eb446f7 //    ushl    v23.2s, v23.2s, v20.2s
-    WORD $0x4e0c1d98 //    mov    v24.s[1], w12
-    WORD $0x0eb71ed6 //    orr    v22.8b, v22.8b, v23.8b
-    WORD $0x6e1806d8 //    mov    v24.d[1], v22.d[0]
-    WORD $0x6f077718 //    bic    v24.4s, #248, lsl #24
-    WORD $0x3d800938 //    str    q24, [x9, #32]
-    WORD $0xfd403016 //    ldr    d22, [x0, #96]
-    WORD $0xbd405c17 //    ldr    s23, [x0, #92]
-    WORD $0xb940680a //    ldr    w10, [x0, #104]
-    WORD $0x9101b000 //    add    x0, x0, #108
-    WORD $0x2ea646d8 //    ushl    v24.2s, v22.2s, v6.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb546f6 //    ushl    v22.2s, v23.2s, v21.2s
-    WORD $0x53057d4c //    lsr    w12, w10, #5
-    WORD $0x138b294a //    extr    w10, w10, w11, #10
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f077716 //    bic    v22.4s, #248, lsl #24
-    WORD $0x3d800d36 //    str    q22, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128 
-
-    BNE LBB0_81
-    JMP LBB0_99
-LBB0_82:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x0000000c00000010, R1 // LCPI0_34
-    MOVD $0x0000001400000010, R0 // LCPI0_35
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x2ea0b821 //    neg    v1.2s, v1.2s
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x530b7d4c // lsr    w12, w10, #11
+	WORD $0x1e270150 // fmov    s16, w10
+	WORD $0x138a596a // extr    w10, w11, w10, #22
+	WORD $0x4e0c1d90 // mov    v16.s[1], w12
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53017d6a // lsr    w10, w11, #1
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x4e261e10 // and    v16.16b, v16.16b, v6.16b
+	WORD $0x3c9c0110 // stur    q16, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x0e040d70 // dup    v16.2s, w11
+	WORD $0x138a5d6a // extr    w10, w11, w10, #23
+	WORD $0x1e270191 // fmov    s17, w12
+	WORD $0x2ea04610 // ushl    v16.2s, v16.2s, v0.2s
+	WORD $0x4e0c1d51 // mov    v17.s[1], w10
+	WORD $0x6e180611 // mov    v17.d[1], v16.d[0]
+	WORD $0x4e261e30 // and    v16.16b, v17.16b, v6.16b
+	WORD $0x3c9d0110 // stur    q16, [x8, #-48]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x0e040d70 // dup    v16.2s, w11
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0xb940100a // ldr    w10, [x0, #16]
+	WORD $0x2ea14610 // ushl    v16.2s, v16.2s, v1.2s
+	WORD $0x138b654a // extr    w10, w10, w11, #25
+	WORD $0x6e112231 // ext    v17.16b, v17.16b, v17.16b, #4
+	WORD $0x6e106230 // ext    v16.16b, v17.16b, v16.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x4e261e10 // and    v16.16b, v16.16b, v6.16b
+	WORD $0x3c9e0110 // stur    q16, [x8, #-32]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x0e040d50 // dup    v16.2s, w10
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x2ea24610 // ushl    v16.2s, v16.2s, v2.2s
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53057d6a // lsr    w10, w11, #5
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x4e261e10 // and    v16.16b, v16.16b, v6.16b
+	WORD $0x3c9f0110 // stur    q16, [x8, #-16]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d70 // dup    v16.2s, w11
+	WORD $0x138a6d6a // extr    w10, w11, w10, #27
+	WORD $0x1e270191 // fmov    s17, w12
+	WORD $0x2ea34610 // ushl    v16.2s, v16.2s, v3.2s
+	WORD $0x4e0c1d51 // mov    v17.s[1], w10
+	WORD $0x6e180611 // mov    v17.d[1], v16.d[0]
+	WORD $0x4e261e30 // and    v16.16b, v17.16b, v6.16b
+	WORD $0x3d800110 // str    q16, [x8]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x0e040d70 // dup    v16.2s, w11
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0xb940200a // ldr    w10, [x0, #32]
+	WORD $0x2ea44610 // ushl    v16.2s, v16.2s, v4.2s
+	WORD $0x138b754a // extr    w10, w10, w11, #29
+	WORD $0x6e112231 // ext    v17.16b, v17.16b, v17.16b, #4
+	WORD $0x6e106230 // ext    v16.16b, v17.16b, v16.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x4e261e10 // and    v16.16b, v16.16b, v6.16b
+	WORD $0x3d800510 // str    q16, [x8, #16]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x0e040d50 // dup    v16.2s, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x2ea54610 // ushl    v16.2s, v16.2s, v5.2s
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53097d6a // lsr    w10, w11, #9
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x4e261e10 // and    v16.16b, v16.16b, v6.16b
+	WORD $0x3d800910 // str    q16, [x8, #32]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x9100b000 // add    x0, x0, #44
+	WORD $0x53147d4c // lsr    w12, w10, #20
+	WORD $0x0e040d70 // dup    v16.2s, w11
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x1e270191 // fmov    s17, w12
+	WORD $0x2ea74610 // ushl    v16.2s, v16.2s, v7.2s
+	WORD $0x4e0c1d51 // mov    v17.s[1], w10
+	WORD $0x6e180611 // mov    v17.d[1], v16.d[0]
+	WORD $0x4e261e30 // and    v16.16b, v17.16b, v6.16b
+	WORD $0x3d800d10 // str    q16, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_79
+	JMP LBB0_156
+
+LBB0_80:
+	WORD $0x7100687f // cmp    w3, #26
+	BEQ LBB0_136
+
+	// %bb.81:
+	WORD $0x71006c7f // cmp    w3, #27
+	BNE LBB0_156
+
+	// %bb.82:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.83:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_52
+	// WORD $0x90000009 // adrp    x9, .LCPI0_53
+	// WORD $0x9000000a // adrp    x10, .LCPI0_54
+	// WORD $0x9000000b // adrp    x11, .LCPI0_67
+	VMOVD LCPI0_52, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_55
+	VMOVD LCPI0_53, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_56
+	VMOVD LCPI0_54, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_57
+	VMOVD LCPI0_55, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_58
+	VMOVQ LCPI0_56L, LCPI0_56H, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_59
+	VMOVQ LCPI0_57L, LCPI0_57H, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_60
+	VMOVD LCPI0_58, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_61
+	VMOVD LCPI0_59, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_62
+	VMOVD LCPI0_60, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_63
+	VMOVD LCPI0_61, V17
+	// WORD $0x90000008 // adrp    x8, .LCPI0_64
+	VMOVQ LCPI0_62L, LCPI0_62H, V18
+	// WORD $0x90000009 // adrp    x9, .LCPI0_65
+	VMOVQ LCPI0_63L, LCPI0_63H, V19
+	// WORD $0x9000000a // adrp    x10, .LCPI0_66
+	VMOVD LCPI0_64, V20
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_65, V21
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_66, V22
+	VMOVD LCPI0_67, V23
+
 LBB0_84:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a716e //    extr    w14, w11, w10, #28
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1dc2 //    mov    v2.s[1], w14
-    WORD $0x138c51ac //    extr    w12, w13, w12, #20
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3c9c0122 //    stur    q2, [x9, #-64]
-    WORD $0xfd400802 //    ldr    d2, [x0, #16]
-    WORD $0xbd400c03 //    ldr    s3, [x0, #12]
-    WORD $0xb940180a //    ldr    w10, [x0, #24]
-    WORD $0x2ea04444 //    ushl    v4.2s, v2.2s, v0.2s
-    WORD $0x0e823863 //    zip1    v3.2s, v3.2s, v2.2s
-    WORD $0x0e0c3c4b //    mov    w11, v2.s[1]
-    WORD $0x2ea14462 //    ushl    v2.2s, v3.2s, v1.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x138b214a //    extr    w10, w10, w11, #8
-    WORD $0x0ea21c82 //    orr    v2.8b, v4.8b, v2.8b
-    WORD $0x4e141d42 //    mov    v2.s[2], w10
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3c9d0122 //    stur    q2, [x9, #-48]
-    WORD $0x2943ac0a //    ldp    w10, w11, [x0, #28]
-    WORD $0x2944b40c //    ldp    w12, w13, [x0, #36]
-    WORD $0x138a716e //    extr    w14, w11, w10, #28
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1dc2 //    mov    v2.s[1], w14
-    WORD $0x138c51ac //    extr    w12, w13, w12, #20
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3c9e0122 //    stur    q2, [x9, #-32]
-    WORD $0xfc42c002 //    ldur    d2, [x0, #44]
-    WORD $0xbd402803 //    ldr    s3, [x0, #40]
-    WORD $0xb940340a //    ldr    w10, [x0, #52]
-    WORD $0x2ea04444 //    ushl    v4.2s, v2.2s, v0.2s
-    WORD $0x0e823863 //    zip1    v3.2s, v3.2s, v2.2s
-    WORD $0x0e0c3c4b //    mov    w11, v2.s[1]
-    WORD $0x2ea14462 //    ushl    v2.2s, v3.2s, v1.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x138b214a //    extr    w10, w10, w11, #8
-    WORD $0x0ea21c82 //    orr    v2.8b, v4.8b, v2.8b
-    WORD $0x4e141d42 //    mov    v2.s[2], w10
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3c9f0122 //    stur    q2, [x9, #-16]
-    WORD $0x29472c0a //    ldp    w10, w11, [x0, #56]
-    WORD $0x2948340c //    ldp    w12, w13, [x0, #64]
-    WORD $0x138a716e //    extr    w14, w11, w10, #28
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1dc2 //    mov    v2.s[1], w14
-    WORD $0x138c51ac //    extr    w12, w13, w12, #20
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3d800122 //    str    q2, [x9]
-    WORD $0xfd402402 //    ldr    d2, [x0, #72]
-    WORD $0xbd404403 //    ldr    s3, [x0, #68]
-    WORD $0xb940500a //    ldr    w10, [x0, #80]
-    WORD $0x2ea04444 //    ushl    v4.2s, v2.2s, v0.2s
-    WORD $0x0e823863 //    zip1    v3.2s, v3.2s, v2.2s
-    WORD $0x0e0c3c4b //    mov    w11, v2.s[1]
-    WORD $0x2ea14462 //    ushl    v2.2s, v3.2s, v1.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x138b214a //    extr    w10, w10, w11, #8
-    WORD $0x0ea21c82 //    orr    v2.8b, v4.8b, v2.8b
-    WORD $0x4e141d42 //    mov    v2.s[2], w10
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3d800522 //    str    q2, [x9, #16]
-    WORD $0x294aac0a //    ldp    w10, w11, [x0, #84]
-    WORD $0x294bb40c //    ldp    w12, w13, [x0, #92]
-    WORD $0x138a716e //    extr    w14, w11, w10, #28
-    WORD $0x1e270142 //    fmov    s2, w10
-    WORD $0x138b618b //    extr    w11, w12, w11, #24
-    WORD $0x4e0c1dc2 //    mov    v2.s[1], w14
-    WORD $0x138c51ac //    extr    w12, w13, w12, #20
-    WORD $0x4e141d62 //    mov    v2.s[2], w11
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3d800922 //    str    q2, [x9, #32]
-    WORD $0xfc464002 //    ldur    d2, [x0, #100]
-    WORD $0xbd406003 //    ldr    s3, [x0, #96]
-    WORD $0xb9406c0a //    ldr    w10, [x0, #108]
-    WORD $0x9101c000 //    add    x0, x0, #112
-    WORD $0x2ea04444 //    ushl    v4.2s, v2.2s, v0.2s
-    WORD $0x0e823863 //    zip1    v3.2s, v3.2s, v2.2s
-    WORD $0x0e0c3c4b //    mov    w11, v2.s[1]
-    WORD $0x2ea14462 //    ushl    v2.2s, v3.2s, v1.2s
-    WORD $0x53047d4c //    lsr    w12, w10, #4
-    WORD $0x138b214a //    extr    w10, w10, w11, #8
-    WORD $0x0ea21c82 //    orr    v2.8b, v4.8b, v2.8b
-    WORD $0x4e141d42 //    mov    v2.s[2], w10
-    WORD $0x4e1c1d82 //    mov    v2.s[3], w12
-    WORD $0x6f077602 //    bic    v2.4s, #240, lsl #24
-    WORD $0x3d800d22 //    str    q2, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_84
-    JMP LBB0_99
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404018 // ldur    d24, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x2ea0471b // ushl    v27.2s, v24.2s, v0.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x6e1a235a // ext    v26.16b, v26.16b, v26.16b, #4
+	WORD $0x138a456a // extr    w10, w11, w10, #17
+	WORD $0x2ea14739 // ushl    v25.2s, v25.2s, v1.2s
+	WORD $0x0eb91f79 // orr    v25.8b, v27.8b, v25.8b
+	WORD $0x6e196358 // ext    v24.16b, v26.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3c9c0118 // stur    q24, [x8, #-64]
+	WORD $0xfd400818 // ldr    d24, [x0, #16]
+	WORD $0xbd400c19 // ldr    s25, [x0, #12]
+	WORD $0xb940180c // ldr    w12, [x0, #24]
+	WORD $0x2ea2471a // ushl    v26.2s, v24.2s, v2.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a758a // extr    w10, w12, w10, #29
+	WORD $0x2ea34739 // ushl    v25.2s, v25.2s, v3.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d78 // mov    v24.s[2], w11
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3c9d0118 // stur    q24, [x8, #-48]
+	WORD $0xbd401818 // ldr    s24, [x0, #24]
+	WORD $0x3cc1c019 // ldur    q25, [x0, #28]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea44739 // ushl    v25.4s, v25.4s, v4.4s
+	WORD $0x6ea54718 // ushl    v24.4s, v24.4s, v5.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3c9e0118 // stur    q24, [x8, #-32]
+	WORD $0xb940280a // ldr    w10, [x0, #40]
+	WORD $0xfc42c018 // ldur    d24, [x0, #44]
+	WORD $0xb940340b // ldr    w11, [x0, #52]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x53047d4a // lsr    w10, w10, #4
+	WORD $0x2ea6471a // ushl    v26.2s, v24.2s, v6.2s
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x1e27015b // fmov    s27, w10
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x6e1b237b // ext    v27.16b, v27.16b, v27.16b, #4
+	WORD $0x2ea74739 // ushl    v25.2s, v25.2s, v7.2s
+	WORD $0x138a556a // extr    w10, w11, w10, #21
+	WORD $0x0eb91f59 // orr    v25.8b, v26.8b, v25.8b
+	WORD $0x6e196378 // ext    v24.16b, v27.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3c9f0118 // stur    q24, [x8, #-16]
+	WORD $0xfd401c18 // ldr    d24, [x0, #56]
+	WORD $0xbd403419 // ldr    s25, [x0, #52]
+	WORD $0xb940400b // ldr    w11, [x0, #64]
+	WORD $0x2eb0471a // ushl    v26.2s, v24.2s, v16.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a196a // extr    w10, w11, w10, #6
+	WORD $0x2eb14739 // ushl    v25.2s, v25.2s, v17.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53017d6a // lsr    w10, w11, #1
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3d800118 // str    q24, [x8]
+	WORD $0xbd404018 // ldr    s24, [x0, #64]
+	WORD $0x3cc44019 // ldur    q25, [x0, #68]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb24739 // ushl    v25.4s, v25.4s, v18.4s
+	WORD $0x6eb34718 // ushl    v24.4s, v24.4s, v19.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3d800518 // str    q24, [x8, #16]
+	WORD $0x294a280b // ldp    w11, w10, [x0, #80]
+	WORD $0xfd402c18 // ldr    d24, [x0, #88]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x138b214b // extr    w11, w10, w11, #8
+	WORD $0x53037d4a // lsr    w10, w10, #3
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x2eb44718 // ushl    v24.2s, v24.2s, v20.2s
+	WORD $0x1e27017a // fmov    s26, w11
+	WORD $0x2eb54739 // ushl    v25.2s, v25.2s, v21.2s
+	WORD $0x4e0c1d5a // mov    v26.s[1], w10
+	WORD $0x0eb91f18 // orr    v24.8b, v24.8b, v25.8b
+	WORD $0x6e18071a // mov    v26.d[1], v24.d[0]
+	WORD $0x6f07771a // bic    v26.4s, #248, lsl #24
+	WORD $0x3d80091a // str    q26, [x8, #32]
+	WORD $0xfd403018 // ldr    d24, [x0, #96]
+	WORD $0xbd405c19 // ldr    s25, [x0, #92]
+	WORD $0xb940680b // ldr    w11, [x0, #104]
+	WORD $0x9101b000 // add    x0, x0, #108
+	WORD $0x2eb6471a // ushl    v26.2s, v24.2s, v22.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a296a // extr    w10, w11, w10, #10
+	WORD $0x2eb74739 // ushl    v25.2s, v25.2s, v23.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53057d6a // lsr    w10, w11, #5
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f077718 // bic    v24.4s, #248, lsl #24
+	WORD $0x3d800d18 // str    q24, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_84
+	JMP LBB0_156
+
 LBB0_85:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000001100000014, $0x0000000b0000000e, V7 // LCPI0_20
-    VMOVQ $0x0000000f0000000c, $0x0000001500000012, V0 // LCPI0_21
-    MOVD $0x0000000500000008, R16 // LCPI0_22
-    MOVD $0x0000001b00000018, R1 // LCPI0_23
-    VMOVQ $0x000000190000001c, $0x0000001300000016, V17 // LCPI0_24
-    VMOVQ $0x0000000700000004, $0x0000000d0000000a, V2 // LCPI0_25
-    VMOVQ $0x0000000d00000010, $0x000000070000000a, V25 // LCPI0_26
-    VMOVQ $0x0000001300000010, $0x0000001900000016, V3 // LCPI0_27
-    MOVD $0x0000001b0000001e, R19 // LCPI0_28
-    MOVD $0x0000000500000002, R4 // LCPI0_29
-    VMOVQ $0x0000001500000018, $0x0000000f00000012, V20 // LCPI0_30
-    VMOVQ $0x0000000b00000008, $0x000000110000000e, V5 // LCPI0_31
-    MOVD $0x000000090000000c, R21 // LCPI0_32
-    MOVD $0x0000001700000014, R6 // LCPI0_33
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x6ea0b8e7 //    neg    v7.4s, v7.4s
-    WORD $0x2ea0ba10 //    neg    v16.2s, v16.2s
-    WORD $0x6ea0ba31 //    neg    v17.4s, v17.4s
-    WORD $0x6ea0ba52 //    neg    v25.4s, v25.4s
-    WORD $0x2ea0ba73 //    neg    v19.2s, v19.2s
-    WORD $0x6ea0ba94 //    neg    v20.4s, v20.4s
-    WORD $0x2ea0bab5 //    neg    v21.2s, v21.2s
-LBB0_87:   
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a756e //    extr    w14, w11, w10, #29
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x138b698b //    extr    w11, w12, w11, #26
-    WORD $0x4e0c1dd6 //    mov    v22.s[1], w14
-    WORD $0x138c5dac //    extr    w12, w13, w12, #23
-    WORD $0x4e141d76 //    mov    v22.s[2], w11
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3c9c0136 //    stur    q22, [x9, #-64]
-    WORD $0xbd400c16 //    ldr    s22, [x0, #12]
-    WORD $0x3dc00417 //    ldr    q23, [x0, #16]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6ea046f8 //    ushl    v24.4s, v23.4s, v0.4s
-    WORD $0x6ea746d6 //    ushl    v22.4s, v22.4s, v7.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3c9d0136 //    stur    q22, [x9, #-48]
-    WORD $0xfd401016 //    ldr    d22, [x0, #32]
-    WORD $0xbd401c17 //    ldr    s23, [x0, #28]
-    WORD $0xb940280a //    ldr    w10, [x0, #40]
-    WORD $0x2ea146d8 //    ushl    v24.2s, v22.2s, v1.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb046f6 //    ushl    v22.2s, v23.2s, v16.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x138b7d4a //    extr    w10, w10, w11, #31
-    WORD $0x4e141d96 //    mov    v22.s[2], w12
-    WORD $0x4e1c1d56 //    mov    v22.s[3], w10
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3c9e0136 //    stur    q22, [x9, #-32]
-    WORD $0xbd402816 //    ldr    s22, [x0, #40]
-    WORD $0x3cc2c017 //    ldur    q23, [x0, #44]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea246f8 //    ushl    v24.4s, v23.4s, v2.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f077418 //    bic    v24.4s, #224, lsl #24
-    WORD $0x6eb146d6 //    ushl    v22.4s, v22.4s, v17.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3c9f0136 //    stur    q22, [x9, #-16]
-    WORD $0xbd403816 //    ldr    s22, [x0, #56]
-    WORD $0x3cc3c017 //    ldur    q23, [x0, #60]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6ea346f8 //    ushl    v24.4s, v23.4s, v3.4s
-    WORD $0x6eb246d6 //    ushl    v22.4s, v22.4s, v25.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3d800136 //    str    q22, [x9]
-    WORD $0x29492c0a //    ldp    w10, w11, [x0, #72]
-    WORD $0xfd402816 //    ldr    d22, [x0, #80]
-    WORD $0x1e270177 //    fmov    s23, w11
-    WORD $0x138a116a //    extr    w10, w11, w10, #4
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x53017d6c //    lsr    w12, w11, #1
-    WORD $0x2ea446d6 //    ushl    v22.2s, v22.2s, v4.2s
-    WORD $0x1e270158 //    fmov    s24, w10
-    WORD $0x2eb346f7 //    ushl    v23.2s, v23.2s, v19.2s
-    WORD $0x4e0c1d98 //    mov    v24.s[1], w12
-    WORD $0x0eb71ed6 //    orr    v22.8b, v22.8b, v23.8b
-    WORD $0x6e1806d8 //    mov    v24.d[1], v22.d[0]
-    WORD $0x6f077418 //    bic    v24.4s, #224, lsl #24
-    WORD $0x3d800538 //    str    q24, [x9, #16]
-    WORD $0xbd405416 //    ldr    s22, [x0, #84]
-    WORD $0x3cc58017 //    ldur    q23, [x0, #88]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6ea546f8 //    ushl    v24.4s, v23.4s, v5.4s
-    WORD $0x6eb446d6 //    ushl    v22.4s, v22.4s, v20.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3d800936 //    str    q22, [x9, #32]
-    WORD $0xfd403416 //    ldr    d22, [x0, #104]
-    WORD $0xbd406417 //    ldr    s23, [x0, #100]
-    WORD $0xb940700a //    ldr    w10, [x0, #112]
-    WORD $0x9101d000 //    add    x0, x0, #116
-    WORD $0x2ea646d8 //    ushl    v24.2s, v22.2s, v6.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb546f6 //    ushl    v22.2s, v23.2s, v21.2s
-    WORD $0x53037d4c //    lsr    w12, w10, #3
-    WORD $0x138b194a //    extr    w10, w10, w11, #6
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f077416 //    bic    v22.4s, #224, lsl #24
-    WORD $0x3d800d36 //    str    q22, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128 
-
-    BNE LBB0_87
-    JMP LBB0_99
-LBB0_88:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000001600000018, $0x0000001200000014, V3 // LCPI0_14
-    VMOVQ $0x0000000a00000008, $0x0000000e0000000c, V0 // LCPI0_15
-    VMOVQ $0x0000000e00000010, $0x0000000a0000000c, V4 // LCPI0_16
-    VMOVQ $0x0000001200000010, $0x0000001600000014, V1 // LCPI0_17
-    MOVD $0x0000000600000008, R5 // LCPI0_18
-    MOVD $0x0000001a00000018, R2 // LCPI0_19
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x6ea0b863 //    neg    v3.4s, v3.4s
-    WORD $0x6ea0b884 //    neg    v4.4s, v4.4s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
+	WORD $0x7100187f // cmp    w3, #6
+	BEQ LBB0_139
+
+	// %bb.86:
+	WORD $0x71001c7f // cmp    w3, #7
+	BNE LBB0_156
+
+	// %bb.87:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.88:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_166
+	// WORD $0x90000009 // adrp    x9, .LCPI0_167
+	// WORD $0x9000000a // adrp    x10, .LCPI0_168
+	WORD $0x4f0307e7 // movi    v7.4s, #127
+	VMOVD LCPI0_166, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_169
+	VMOVD LCPI0_167, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_170
+	VMOVD LCPI0_168, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_171
+	VMOVD LCPI0_169, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_172
+	VMOVD LCPI0_170, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_173
+	VMOVD LCPI0_171, V5
+	VMOVD LCPI0_172, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_173L, LCPI0_173H, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_89:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53157d4a // lsr    w10, w10, #21
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x2ea04631 // ushl    v17.2s, v17.2s, v0.2s
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53117d6a // lsr    w10, w11, #17
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x6e116251 // ext    v17.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x53187d4c // lsr    w12, w10, #24
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea24631 // ushl    v17.2s, v17.2s, v2.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x53147d4c // lsr    w12, w10, #20
+	WORD $0x0e040d71 // dup    v17.2s, w11
+	WORD $0x138a6d6a // extr    w10, w11, w10, #27
+	WORD $0x1e270192 // fmov    s18, w12
+	WORD $0x2ea34631 // ushl    v17.2s, v17.2s, v3.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x6e180632 // mov    v18.d[1], v17.d[0]
+	WORD $0x4e271e51 // and    v17.16b, v18.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x2ea44631 // ushl    v17.2s, v17.2s, v4.2s
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x53057d6a // lsr    w10, w11, #5
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x2ea54631 // ushl    v17.2s, v17.2s, v5.2s
+	WORD $0x4e141d51 // mov    v17.s[2], w10
+	WORD $0x53017d6a // lsr    w10, w11, #1
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x0e040d51 // dup    v17.2s, w10
+	WORD $0x53167d4c // lsr    w12, w10, #22
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x2ea64631 // ushl    v17.2s, v17.2s, v6.2s
+	WORD $0x4e141d91 // mov    v17.s[2], w12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x9100600a // add    x10, x0, #24
+	WORD $0x91007000 // add    x0, x0, #28
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0x4d40c951 // ld1r    { v17.4s }, [x10]
+	WORD $0x6eb04631 // ushl    v17.4s, v17.4s, v16.4s
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_89
+	JMP LBB0_156
+
 LBB0_90:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a796e //    extr    w14, w11, w10, #30
-    WORD $0x1e270146 //    fmov    s6, w10
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e0c1dc6 //    mov    v6.s[1], w14
-    WORD $0x138c69ac //    extr    w12, w13, w12, #26
-    WORD $0x4e141d66 //    mov    v6.s[2], w11
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f067406 //    bic    v6.4s, #192, lsl #24
-    WORD $0x3c9c0126 //    stur    q6, [x9, #-64]
-    WORD $0xbd400c06 //    ldr    s6, [x0, #12]
-    WORD $0x3dc00407 //    ldr    q7, [x0, #16]
-    WORD $0x6e0620c6 //    ext    v6.16b, v6.16b, v6.16b, #4
-    WORD $0x6ea044f0 //    ushl    v16.4s, v7.4s, v0.4s
-    WORD $0x6e0760c6 //    ext    v6.16b, v6.16b, v7.16b, #12
-    WORD $0x6f067410 //    bic    v16.4s, #192, lsl #24
-    WORD $0x6ea344c6 //    ushl    v6.4s, v6.4s, v3.4s
-    WORD $0x4ea61e06 //    orr    v6.16b, v16.16b, v6.16b
-    WORD $0x3c9d0126 //    stur    q6, [x9, #-48]
-    WORD $0xbd401c06 //    ldr    s6, [x0, #28]
-    WORD $0x3dc00807 //    ldr    q7, [x0, #32]
-    WORD $0x6e0620c6 //    ext    v6.16b, v6.16b, v6.16b, #4
-    WORD $0x6ea144f0 //    ushl    v16.4s, v7.4s, v1.4s
-    WORD $0x6e0760c6 //    ext    v6.16b, v6.16b, v7.16b, #12
-    WORD $0x6f067410 //    bic    v16.4s, #192, lsl #24
-    WORD $0x6ea444c6 //    ushl    v6.4s, v6.4s, v4.4s
-    WORD $0x4ea61e06 //    orr    v6.16b, v16.16b, v6.16b
-    WORD $0x3c9e0126 //    stur    q6, [x9, #-32]
-    WORD $0xfd401806 //    ldr    d6, [x0, #48]
-    WORD $0xbd402c07 //    ldr    s7, [x0, #44]
-    WORD $0xb940380a //    ldr    w10, [x0, #56]
-    WORD $0x2ea244d0 //    ushl    v16.2s, v6.2s, v2.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea544e6 //    ushl    v6.2s, v7.2s, v5.2s
-    WORD $0x53027d4c //    lsr    w12, w10, #2
-    WORD $0x138b114a //    extr    w10, w10, w11, #4
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x4e141d46 //    mov    v6.s[2], w10
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f067406 //    bic    v6.4s, #192, lsl #24
-    WORD $0x3c9f0126 //    stur    q6, [x9, #-16]
-    WORD $0x2947ac0a //    ldp    w10, w11, [x0, #60]
-    WORD $0x2948b40c //    ldp    w12, w13, [x0, #68]
-    WORD $0x138a796e //    extr    w14, w11, w10, #30
-    WORD $0x1e270146 //    fmov    s6, w10
-    WORD $0x138b718b //    extr    w11, w12, w11, #28
-    WORD $0x4e0c1dc6 //    mov    v6.s[1], w14
-    WORD $0x138c69ac //    extr    w12, w13, w12, #26
-    WORD $0x4e141d66 //    mov    v6.s[2], w11
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f067406 //    bic    v6.4s, #192, lsl #24
-    WORD $0x3d800126 //    str    q6, [x9]
-    WORD $0xbd404806 //    ldr    s6, [x0, #72]
-    WORD $0x3cc4c007 //    ldur    q7, [x0, #76]
-    WORD $0x6e0620c6 //    ext    v6.16b, v6.16b, v6.16b, #4
-    WORD $0x6ea044f0 //    ushl    v16.4s, v7.4s, v0.4s
-    WORD $0x6e0760c6 //    ext    v6.16b, v6.16b, v7.16b, #12
-    WORD $0x6f067410 //    bic    v16.4s, #192, lsl #24
-    WORD $0x6ea344c6 //    ushl    v6.4s, v6.4s, v3.4s
-    WORD $0x4ea61e06 //    orr    v6.16b, v16.16b, v6.16b
-    WORD $0x3d800526 //    str    q6, [x9, #16]
-    WORD $0xbd405806 //    ldr    s6, [x0, #88]
-    WORD $0x3cc5c007 //    ldur    q7, [x0, #92]
-    WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
-    WORD $0x6ea144f0 //    ushl    v16.4s, v7.4s, v1.4s
-    WORD $0x6e0760c6 //    ext    v6.16b, v6.16b, v7.16b, #12
-    WORD $0x6f067410 //    bic    v16.4s, #192, lsl #24
-    WORD $0x6ea444c6 //    ushl    v6.4s, v6.4s, v4.4s
-    WORD $0x4ea61e06 //    orr    v6.16b, v16.16b, v6.16b
-    WORD $0x3d800926 //    str    q6, [x9, #32]
-    WORD $0xfc46c006 //    ldur    d6, [x0, #108]
-    WORD $0xbd406807 //    ldr    s7, [x0, #104]
-    WORD $0xb940740a //    ldr    w10, [x0, #116]
-    WORD $0x9101e000 //    add    x0, x0, #120
-    WORD $0x2ea244d0 //    ushl    v16.2s, v6.2s, v2.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea544e6 //    ushl    v6.2s, v7.2s, v5.2s
-    WORD $0x53027d4c //    lsr    w12, w10, #2
-    WORD $0x138b114a //    extr    w10, w10, w11, #4
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x4e141d46 //    mov    v6.s[2], w10
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f067406 //    bic    v6.4s, #192, lsl #24
-    WORD $0x3d800d26 //    str    q6, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128 
-
-    BNE LBB0_90
-    JMP LBB0_99
-LBB0_91:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    VMOVQ $0x0000001b0000001c, $0x000000190000001a, V7 // LCPI0_0
-    VMOVQ $0x0000000500000004, $0x0000000700000006, V0 // LCPI0_1
-    VMOVQ $0x0000001700000018, $0x0000001500000016, V16 // LCPI0_2
-    VMOVQ $0x0000000900000008, $0x0000000b0000000a, V1 // LCPI0_3
-    VMOVQ $0x0000001300000014, $0x0000001100000012, V17 // LCPI0_4
-    VMOVQ $0x0000000d0000000c, $0x0000000f0000000e, V2 // LCPI0_5
-    VMOVQ $0x0000000f00000010, $0x0000000d0000000e, V25 // LCPI0_6
-    VMOVQ $0x0000001100000010, $0x0000001300000012, V3 // LCPI0_7
-    VMOVQ $0x0000000b0000000c, $0x000000090000000a, V19 // LCPI0_8
-    VMOVQ $0x0000001500000014, $0x0000001700000016, V4 // LCPI0_9
-    VMOVQ $0x0000000700000008, $0x0000000500000006, V20 // LCPI0_10
-    VMOVQ $0x0000001900000018, $0x0000001b0000001a, V5 // LCPI0_11
-    MOVD $0x0000000300000004, R21 // LCPI0_12
-    MOVD $0x0000001d0000001c, R6 // LCPI0_13
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x6ea0b8e7 //    neg    v7.4s, v7.4s
-    WORD $0x6ea0ba10 //    neg    v16.4s, v16.4s
-    WORD $0x6ea0ba31 //    neg    v17.4s, v17.4s
-    WORD $0x6ea0ba52 //    neg    v25.4s, v25.4s
-    WORD $0x6ea0ba73 //    neg    v19.4s, v19.4s
-    WORD $0x6ea0ba94 //    neg    v20.4s, v20.4s
-    WORD $0x2ea0bab5 //    neg    v21.2s, v21.2s
-LBB0_93:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a7d6e //    extr    w14, w11, w10, #31
-    WORD $0x1e270156 //    fmov    s22, w10
-    WORD $0x4e0c1dd6 //    mov    v22.s[1], w14
-    WORD $0x138c75ac //    extr    w12, w13, w12, #29
-    WORD $0x4e141d76 //    mov    v22.s[2], w11
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f047416 //    bic    v22.4s, #128, lsl #24
-    WORD $0x3c9c0136 //    stur    q22, [x9, #-64]
-    WORD $0xbd400c16 //    ldr    s22, [x0, #12]
-    WORD $0x3dc00417 //    ldr    q23, [x0, #16]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea046f8 //    ushl    v24.4s, v23.4s, v0.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x6ea746d6 //    ushl    v22.4s, v22.4s, v7.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3c9d0136 //    stur    q22, [x9, #-48]
-    WORD $0xbd401c16 //    ldr    s22, [x0, #28]
-    WORD $0x3dc00817 //    ldr    q23, [x0, #32]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea146f8 //    ushl    v24.4s, v23.4s, v1.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x6eb046d6 //    ushl    v22.4s, v22.4s, v16.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3c9e0136 //    stur    q22, [x9, #-32]
-    WORD $0xbd402c16 //    ldr    s22, [x0, #44]
-    WORD $0x3dc00c17 //    ldr    q23, [x0, #48]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea246f8 //    ushl    v24.4s, v23.4s, v2.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3c9f0136 //    stur    q22, [x9, #-16]
-    WORD $0xbd403c16 //    ldr    s22, [x0, #60]
-    WORD $0x3dc01017 //    ldr    q23, [x0, #64]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea346f8 //    ushl    v24.4s, v23.4s, v3.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x6eb246d6 //    ushl    v22.4s, v22.4s, v25.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3d800136 //    str    q22, [x9]
-    WORD $0xbd404c16 //    ldr    s22, [x0, #76]
-    WORD $0x3dc01417 //    ldr    q23, [x0, #80]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea446f8 //    ushl    v24.4s, v23.4s, v4.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x6eb346d6 //    ushl    v22.4s, v22.4s, v19.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3d800536 //    str    q22, [x9, #16]
-    WORD $0xbd405c16 //    ldr    s22, [x0, #92]
-    WORD $0x3dc01817 //    ldr    q23, [x0, #96]
-    WORD $0x6e1622d6 //    ext    v22.16b, v22.16b, v22.16b, #4
-    WORD $0x6ea546f8 //    ushl    v24.4s, v23.4s, v5.4s
-    WORD $0x6e1762d6 //    ext    v22.16b, v22.16b, v23.16b, #12
-    WORD $0x6f047418 //    bic    v24.4s, #128, lsl #24
-    WORD $0x6eb446d6 //    ushl    v22.4s, v22.4s, v20.4s
-    WORD $0x4eb61f16 //    orr    v22.16b, v24.16b, v22.16b
-    WORD $0x3d800936 //    str    q22, [x9, #32]
-    WORD $0xfd403816 //    ldr    d22, [x0, #112]
-    WORD $0xbd406c17 //    ldr    s23, [x0, #108]
-    WORD $0xb940780a //    ldr    w10, [x0, #120]
-    WORD $0x9101f000 //    add    x0, x0, #124
-    WORD $0x2ea646d8 //    ushl    v24.2s, v22.2s, v6.2s
-    WORD $0x0e963af7 //    zip1    v23.2s, v23.2s, v22.2s
-    WORD $0x0e0c3ecb //    mov    w11, v22.s[1]
-    WORD $0x2eb546f6 //    ushl    v22.2s, v23.2s, v21.2s
-    WORD $0x53017d4c //    lsr    w12, w10, #1
-    WORD $0x138b094a //    extr    w10, w10, w11, #2
-    WORD $0x0eb61f16 //    orr    v22.8b, v24.8b, v22.8b
-    WORD $0x4e141d56 //    mov    v22.s[2], w10
-    WORD $0x4e1c1d96 //    mov    v22.s[3], w12
-    WORD $0x6f047416 //    bic    v22.4s, #128, lsl #24
-    WORD $0x3d800d36 //    str    q22, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128 
-
-    BNE LBB0_93
-    JMP LBB0_99
+	WORD $0x7100587f // cmp    w3, #22
+	BEQ LBB0_142
+
+	// %bb.91:
+	WORD $0x71005c7f // cmp    w3, #23
+	BNE LBB0_156
+
+	// %bb.92:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.93:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_95
+	// WORD $0x90000008 // adrp    x8, .LCPI0_94
+	// WORD $0x9000000a // adrp    x10, .LCPI0_96
+	WORD $0x4f03d7f7 // movi    v23.4s, #127, msl #16
+	VMOVD LCPI0_95, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_98
+	VMOVD LCPI0_94, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_97
+	VMOVD LCPI0_96, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_99
+	VMOVD LCPI0_98, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_101
+	VMOVD LCPI0_97, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_100
+	VMOVD LCPI0_99, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_102
+	VMOVD LCPI0_101, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_104
+	VMOVD LCPI0_100, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_103
+	VMOVD LCPI0_102, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_105
+	VMOVD LCPI0_104, V18
+	// WORD $0x90000009 // adrp    x9, .LCPI0_107
+	VMOVD LCPI0_103, V17
+	// WORD $0x90000008 // adrp    x8, .LCPI0_106
+	VMOVD LCPI0_105, V19
+	// WORD $0x9000000a // adrp    x10, .LCPI0_108
+	VMOVD LCPI0_107, V21
+	// WORD $0x90000009 // adrp    x9, .LCPI0_109
+	VMOVD LCPI0_106, V20
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_108, V22
+	VMOVD LCPI0_109, V24
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_94:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404019 // ldur    d25, [x0, #4]
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x1e27015b // fmov    s27, w10
+	WORD $0x2ea0473c // ushl    v28.2s, v25.2s, v0.2s
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x6e1b237b // ext    v27.16b, v27.16b, v27.16b, #4
+	WORD $0x53057d4a // lsr    w10, w10, #5
+	WORD $0x2ea1475a // ushl    v26.2s, v26.2s, v1.2s
+	WORD $0x0eba1f9a // orr    v26.8b, v28.8b, v26.8b
+	WORD $0x6e1a6379 // ext    v25.16b, v27.16b, v26.16b, #12
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3c9c0119 // stur    q25, [x8, #-64]
+	WORD $0xfc40c019 // ldur    d25, [x0, #12]
+	WORD $0xbd40081a // ldr    s26, [x0, #8]
+	WORD $0xb940140b // ldr    w11, [x0, #20]
+	WORD $0x2ea2473b // ushl    v27.2s, v25.2s, v2.2s
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x138a296a // extr    w10, w11, w10, #10
+	WORD $0x2ea3475a // ushl    v26.2s, v26.2s, v3.2s
+	WORD $0x0eba1f79 // orr    v25.8b, v27.8b, v26.8b
+	WORD $0x4e141d59 // mov    v25.s[2], w10
+	WORD $0x53017d6a // lsr    w10, w11, #1
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3c9d0119 // stur    q25, [x8, #-48]
+	WORD $0xfd400c19 // ldr    d25, [x0, #24]
+	WORD $0xbd40141a // ldr    s26, [x0, #20]
+	WORD $0xb940200c // ldr    w12, [x0, #32]
+	WORD $0x2ea4473b // ushl    v27.2s, v25.2s, v4.2s
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x53067d4b // lsr    w11, w10, #6
+	WORD $0x138a758a // extr    w10, w12, w10, #29
+	WORD $0x2ea5475a // ushl    v26.2s, v26.2s, v5.2s
+	WORD $0x0eba1f79 // orr    v25.8b, v27.8b, v26.8b
+	WORD $0x4e141d79 // mov    v25.s[2], w11
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3c9e0119 // stur    q25, [x8, #-32]
+	WORD $0xfc424019 // ldur    d25, [x0, #36]
+	WORD $0xbd40201a // ldr    s26, [x0, #32]
+	WORD $0xb9402c0c // ldr    w12, [x0, #44]
+	WORD $0x2ea6473b // ushl    v27.2s, v25.2s, v6.2s
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x53027d4b // lsr    w11, w10, #2
+	WORD $0x138a658a // extr    w10, w12, w10, #25
+	WORD $0x2ea7475a // ushl    v26.2s, v26.2s, v7.2s
+	WORD $0x0eba1f79 // orr    v25.8b, v27.8b, v26.8b
+	WORD $0x4e141d79 // mov    v25.s[2], w11
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3c9f0119 // stur    q25, [x8, #-16]
+	WORD $0x2945a80b // ldp    w11, w10, [x0, #44]
+	WORD $0xfc434019 // ldur    d25, [x0, #52]
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x138b414b // extr    w11, w10, w11, #16
+	WORD $0x53077d4a // lsr    w10, w10, #7
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x2eb04739 // ushl    v25.2s, v25.2s, v16.2s
+	WORD $0x1e27017b // fmov    s27, w11
+	WORD $0x2eb1475a // ushl    v26.2s, v26.2s, v17.2s
+	WORD $0x4e0c1d5b // mov    v27.s[1], w10
+	WORD $0x0eba1f39 // orr    v25.8b, v25.8b, v26.8b
+	WORD $0x6e18073b // mov    v27.d[1], v25.d[0]
+	WORD $0x4e371f79 // and    v25.16b, v27.16b, v23.16b
+	WORD $0x3d800119 // str    q25, [x8]
+	WORD $0x2947280b // ldp    w11, w10, [x0, #56]
+	WORD $0xfd402019 // ldr    d25, [x0, #64]
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x138b314b // extr    w11, w10, w11, #12
+	WORD $0x53037d4a // lsr    w10, w10, #3
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x2eb24739 // ushl    v25.2s, v25.2s, v18.2s
+	WORD $0x1e27017b // fmov    s27, w11
+	WORD $0x2eb3475a // ushl    v26.2s, v26.2s, v19.2s
+	WORD $0x4e0c1d5b // mov    v27.s[1], w10
+	WORD $0x0eba1f39 // orr    v25.8b, v25.8b, v26.8b
+	WORD $0x6e18073b // mov    v27.d[1], v25.d[0]
+	WORD $0x4e371f79 // and    v25.16b, v27.16b, v23.16b
+	WORD $0x3d800519 // str    q25, [x8, #16]
+	WORD $0xb940440a // ldr    w10, [x0, #68]
+	WORD $0xfd402419 // ldr    d25, [x0, #72]
+	WORD $0xb940500b // ldr    w11, [x0, #80]
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2eb4473b // ushl    v27.2s, v25.2s, v20.2s
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x1e27015c // fmov    s28, w10
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x6e1c239c // ext    v28.16b, v28.16b, v28.16b, #4
+	WORD $0x2eb5475a // ushl    v26.2s, v26.2s, v21.2s
+	WORD $0x138a356a // extr    w10, w11, w10, #13
+	WORD $0x0eba1f7a // orr    v26.8b, v27.8b, v26.8b
+	WORD $0x6e1a6399 // ext    v25.16b, v28.16b, v26.16b, #12
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3d800919 // str    q25, [x8, #32]
+	WORD $0xb940500a // ldr    w10, [x0, #80]
+	WORD $0xfc454019 // ldur    d25, [x0, #84]
+	WORD $0x91017000 // add    x0, x0, #92
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x53047d4a // lsr    w10, w10, #4
+	WORD $0x2eb6473b // ushl    v27.2s, v25.2s, v22.2s
+	WORD $0x0e993b5a // zip1    v26.2s, v26.2s, v25.2s
+	WORD $0x1e27015c // fmov    s28, w10
+	WORD $0x0e0c3f2a // mov    w10, v25.s[1]
+	WORD $0x6e1c239c // ext    v28.16b, v28.16b, v28.16b, #4
+	WORD $0x2eb8475a // ushl    v26.2s, v26.2s, v24.2s
+	WORD $0x53097d4a // lsr    w10, w10, #9
+	WORD $0x0eba1f7a // orr    v26.8b, v27.8b, v26.8b
+	WORD $0x6e1a6399 // ext    v25.16b, v28.16b, v26.16b, #12
+	WORD $0x4e1c1d59 // mov    v25.s[3], w10
+	WORD $0x4e371f39 // and    v25.16b, v25.16b, v23.16b
+	WORD $0x3d800d19 // str    q25, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_94
+	JMP LBB0_156
+
 LBB0_95:
-    WORD $0xad410400 //    ldp    q0, q1, [x0, #32]
-    WORD $0xad400c02 //    ldp    q2, q3, [x0]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0xad010420 //    stp    q0, q1, [x1, #32]
-    WORD $0xad000c22 //    stp    q2, q3, [x1]
-    WORD $0xad430400 //    ldp    q0, q1, [x0, #96]
-    WORD $0xad420c02 //    ldp    q2, q3, [x0, #64]
-    WORD $0x91020000 //    add    x0, x0, #128
-    WORD $0xad030420 //    stp    q0, q1, [x1, #96]
-    WORD $0xad020c22 //    stp    q2, q3, [x1, #64]
-    WORD $0x91020021 //    add    x1, x1, #128
-
-    BNE LBB0_95
-    JMP LBB0_99
-LBB0_96:
-    WORD $0x7100805f //    cmp    w2, #32
-    BLT LBB0_99
-    MOVD $0x000000160000001c, R3 // LCPI0_50
-    MOVD $0x0000000a00000004, R0 // LCPI0_51
-    MOVD $0x0000000a00000010, R4 // LCPI0_52
-    MOVD $0x0000001600000010, R1 // LCPI0_53
-    MOVD $0x0000001200000018, R5 // LCPI0_54
-    MOVD $0x0000000e00000008, R2 // LCPI0_55
-
-    WORD $0x91010029 //    add    x9, x1, #64
-    WORD $0x2ea0b863 //    neg    v3.2s, v3.2s
-    WORD $0x2ea0b884 //    neg    v4.2s, v4.2s
-    WORD $0x2ea0b8a5 //    neg    v5.2s, v5.2s
-LBB0_98:
-    WORD $0x29402c0a //    ldp    w10, w11, [x0]
-    WORD $0x2941340c //    ldp    w12, w13, [x0, #8]
-    WORD $0xf1000508 //    subs    x8, x8, #1
-    WORD $0x138a696e //    extr    w14, w11, w10, #26
-    WORD $0x1e270146 //    fmov    s6, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1dc6 //    mov    v6.s[1], w14
-    WORD $0x138c39ac //    extr    w12, w13, w12, #14
-    WORD $0x4e141d66 //    mov    v6.s[2], w11
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3c9c0126 //    stur    q6, [x9, #-64]
-    WORD $0x2941ac0a //    ldp    w10, w11, [x0, #12]
-    WORD $0xfc414006 //    ldur    d6, [x0, #20]
-    WORD $0x1e270167 //    fmov    s7, w11
-    WORD $0x138a216a //    extr    w10, w11, w10, #8
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x53027d6c //    lsr    w12, w11, #2
-    WORD $0x2ea044c6 //    ushl    v6.2s, v6.2s, v0.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x2ea344e7 //    ushl    v7.2s, v7.2s, v3.2s
-    WORD $0x4e0c1d90 //    mov    v16.s[1], w12
-    WORD $0x0ea71cc6 //    orr    v6.8b, v6.8b, v7.8b
-    WORD $0x6e1804d0 //    mov    v16.d[1], v6.d[0]
-    WORD $0x6f077790 //    bic    v16.4s, #252, lsl #24
-    WORD $0x3c9d0130 //    stur    q16, [x9, #-48]
-    WORD $0xfc41c006 //    ldur    d6, [x0, #28]
-    WORD $0xbd401807 //    ldr    s7, [x0, #24]
-    WORD $0xb940240a //    ldr    w10, [x0, #36]
-    WORD $0x2ea144d0 //    ushl    v16.2s, v6.2s, v1.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea444e6 //    ushl    v6.2s, v7.2s, v4.2s
-    WORD $0x53047d6c //    lsr    w12, w11, #4
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x138b794a //    extr    w10, w10, w11, #30
-    WORD $0x4e141d86 //    mov    v6.s[2], w12
-    WORD $0x4e1c1d46 //    mov    v6.s[3], w10
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3c9e0126 //    stur    q6, [x9, #-32]
-    WORD $0xfd401406 //    ldr    d6, [x0, #40]
-    WORD $0xbd402407 //    ldr    s7, [x0, #36]
-    WORD $0xb940300a //    ldr    w10, [x0, #48]
-    WORD $0x2ea244d0 //    ushl    v16.2s, v6.2s, v2.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea544e6 //    ushl    v6.2s, v7.2s, v5.2s
-    WORD $0x138b314a //    extr    w10, w10, w11, #12
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x4e141d46 //    mov    v6.s[2], w10
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3c9f0126 //    stur    q6, [x9, #-16]
-    WORD $0x2946ac0a //    ldp    w10, w11, [x0, #52]
-    WORD $0x2947b40c //    ldp    w12, w13, [x0, #60]
-    WORD $0x138a696e //    extr    w14, w11, w10, #26
-    WORD $0x1e270146 //    fmov    s6, w10
-    WORD $0x138b518b //    extr    w11, w12, w11, #20
-    WORD $0x4e0c1dc6 //    mov    v6.s[1], w14
-    WORD $0x138c39ac //    extr    w12, w13, w12, #14
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3d800126 //    str    q6, [x9]
-    WORD $0x29482c0a //    ldp    w10, w11, [x0, #64]
-    WORD $0xfd402406 //    ldr    d6, [x0, #72]
-    WORD $0x1e270167 //    fmov    s7, w11
-    WORD $0x138a216a //    extr    w10, w11, w10, #8
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x2ea044c6 //    ushl    v6.2s, v6.2s, v0.2s
-    WORD $0x1e270150 //    fmov    s16, w10
-    WORD $0x2ea344e7 //    ushl    v7.2s, v7.2s, v3.2s
-    WORD $0x4e0c1d90 //    mov    v16.s[1], w12
-    WORD $0x0ea71cc6 //    orr    v6.8b, v6.8b, v7.8b
-    WORD $0x6e1804d0 //    mov    v16.d[1], v6.d[0]
-    WORD $0x6f077790 //    bic    v16.4s, #252, lsl #24
-    WORD $0x3d800530 //    str    q16, [x9, #16]
-    WORD $0xfd402806 //    ldr    d6, [x0, #80]
-    WORD $0xbd404c07 //    ldr    s7, [x0, #76]
-    WORD $0xb940580a //    ldr    w10, [x0, #88]
-    WORD $0x2ea144d0 //    ushl    v16.2s, v6.2s, v1.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea444e6 //    ushl    v6.2s, v7.2s, v4.2s
-    WORD $0x53047d6c //    lsr    w12, w11, #4
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x138b794a //    extr    w10, w10, w11, #30
-    WORD $0x4e141d86 //    mov    v6.s[2], w12
-    WORD $0x4e1c1d46 //    mov    v6.s[3], w10
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3d800926 //    str    q6, [x9, #32]
-    WORD $0xfc45c006 //    ldur    d6, [x0, #92]
-    WORD $0xbd405807 //    ldr    s7, [x0, #88]
-    WORD $0xb940640a //    ldr    w10, [x0, #100]
-    WORD $0x9101a000 //    add    x0, x0, #104
-    WORD $0x2ea244d0 //    ushl    v16.2s, v6.2s, v2.2s
-    WORD $0x0e8638e7 //    zip1    v7.2s, v7.2s, v6.2s
-    WORD $0x0e0c3ccb //    mov    w11, v6.s[1]
-    WORD $0x2ea544e6 //    ushl    v6.2s, v7.2s, v5.2s
-    WORD $0x53067d4c //    lsr    w12, w10, #6
-    WORD $0x138b314a //    extr    w10, w10, w11, #12
-    WORD $0x0ea61e06 //    orr    v6.8b, v16.8b, v6.8b
-    WORD $0x4e141d46 //    mov    v6.s[2], w10
-    WORD $0x4e1c1d86 //    mov    v6.s[3], w12
-    WORD $0x6f077786 //    bic    v6.4s, #252, lsl #24
-    WORD $0x3d800d26 //    str    q6, [x9, #48]
-    WORD $0x91020129 //    add    x9, x9, #128
-
-    BNE LBB0_98
+	WORD $0x7100387f // cmp    w3, #14
+	BEQ LBB0_145
+
+	// %bb.96:
+	WORD $0x71003c7f // cmp    w3, #15
+	BNE LBB0_156
+
+	// %bb.97:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.98:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_138
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0x4f03c7e0 // movi    v0.4s, #127, msl #8
+	VMOVD LCPI0_138, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+
 LBB0_99:
-    MOVD R19, num+32(FP)
-    WORD $0xf9400bf3 //    ldr    x19, [sp, #16]
-    WORD $0xa8c27bfd //    ldp    x29, x30, [sp], #32
-    RET
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x530f7d4c // lsr    w12, w10, #15
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x530d7d6a // lsr    w10, w11, #13
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9c0102 // stur    q2, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x530b7d6c // lsr    w12, w11, #11
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x138b694b // extr    w11, w10, w11, #26
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x53097d4a // lsr    w10, w10, #9
+	WORD $0x4e141d62 // mov    v2.s[2], w11
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9d0102 // stur    q2, [x8, #-48]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x53077d6c // lsr    w12, w11, #7
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0xb940140a // ldr    w10, [x0, #20]
+	WORD $0x138b594b // extr    w11, w10, w11, #22
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x53057d4a // lsr    w10, w10, #5
+	WORD $0x4e141d62 // mov    v2.s[2], w11
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9e0102 // stur    q2, [x8, #-32]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x53037d6c // lsr    w12, w11, #3
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0xb9401c0a // ldr    w10, [x0, #28]
+	WORD $0x138b494b // extr    w11, w10, w11, #18
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x53017d4a // lsr    w10, w10, #1
+	WORD $0x4e141d62 // mov    v2.s[2], w11
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9f0102 // stur    q2, [x8, #-16]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x138a7d6a // extr    w10, w11, w10, #31
+	WORD $0x1e270182 // fmov    s2, w12
+	WORD $0xb940240c // ldr    w12, [x0, #36]
+	WORD $0x4e0c1d42 // mov    v2.s[1], w10
+	WORD $0x530e7d6a // lsr    w10, w11, #14
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x138b758a // extr    w10, w12, w11, #29
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800102 // str    q2, [x8]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x138a6d6a // extr    w10, w11, w10, #27
+	WORD $0x1e270182 // fmov    s2, w12
+	WORD $0xb9402c0c // ldr    w12, [x0, #44]
+	WORD $0x4e0c1d42 // mov    v2.s[1], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x138b658a // extr    w10, w12, w11, #25
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800502 // str    q2, [x8, #16]
+	WORD $0x2945ac0a // ldp    w10, w11, [x0, #44]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x138a5d6a // extr    w10, w11, w10, #23
+	WORD $0x1e270182 // fmov    s2, w12
+	WORD $0xb940340c // ldr    w12, [x0, #52]
+	WORD $0x4e0c1d42 // mov    v2.s[1], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x138b558a // extr    w10, w12, w11, #21
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800902 // str    q2, [x8, #32]
+	WORD $0x2946ac0a // ldp    w10, w11, [x0, #52]
+	WORD $0x9100f000 // add    x0, x0, #60
+	WORD $0x53047d4c // lsr    w12, w10, #4
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a4d6a // extr    w10, w11, w10, #19
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3d800d02 // str    q2, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_99
+	JMP LBB0_156
+
+LBB0_100:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.101:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_8
+	// WORD $0x90000009 // adrp    x9, .LCPI0_9
+	// WORD $0x9000000a // adrp    x10, .LCPI0_10
+	// WORD $0x9000000b // adrp    x11, .LCPI0_23
+	VMOVD LCPI0_8, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_11
+	VMOVD LCPI0_9, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_12
+	VMOVQ LCPI0_10L, LCPI0_10H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_13
+	VMOVQ LCPI0_11L, LCPI0_11H, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_14
+	VMOVQ LCPI0_12L, LCPI0_12H, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_15
+	VMOVQ LCPI0_13L, LCPI0_13H, V5
+	// WORD $0x9000000a // adrp    x10, .LCPI0_16
+	VMOVQ LCPI0_14L, LCPI0_14H, V6
+	// WORD $0x90000008 // adrp    x8, .LCPI0_17
+	VMOVQ LCPI0_15L, LCPI0_15H, V7
+	// WORD $0x90000009 // adrp    x9, .LCPI0_18
+	VMOVQ LCPI0_16L, LCPI0_16H, V16
+	// WORD $0x9000000a // adrp    x10, .LCPI0_19
+	VMOVQ LCPI0_17L, LCPI0_17H, V17
+	// WORD $0x90000008 // adrp    x8, .LCPI0_20
+	VMOVQ LCPI0_18L, LCPI0_18H, V18
+	// WORD $0x90000009 // adrp    x9, .LCPI0_21
+	VMOVQ LCPI0_19L, LCPI0_19H, V19
+	// WORD $0x9000000a // adrp    x10, .LCPI0_22
+	VMOVQ LCPI0_20L, LCPI0_20H, V20
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_21L, LCPI0_21H, V21
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_22, V22
+	VMOVD LCPI0_23, V23
+
+LBB0_102:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404018 // ldur    d24, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270159 // fmov    s25, w10
+	WORD $0x1e27015a // fmov    s26, w10
+	WORD $0x2ea0471b // ushl    v27.2s, v24.2s, v0.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x6e1a235a // ext    v26.16b, v26.16b, v26.16b, #4
+	WORD $0x138a756a // extr    w10, w11, w10, #29
+	WORD $0x2ea14739 // ushl    v25.2s, v25.2s, v1.2s
+	WORD $0x0eb91f79 // orr    v25.8b, v27.8b, v25.8b
+	WORD $0x6e196358 // ext    v24.16b, v26.16b, v25.16b, #12
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3c9c0118 // stur    q24, [x8, #-64]
+	WORD $0xbd400c18 // ldr    s24, [x0, #12]
+	WORD $0x3dc00419 // ldr    q25, [x0, #16]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea24739 // ushl    v25.4s, v25.4s, v2.4s
+	WORD $0x6ea34718 // ushl    v24.4s, v24.4s, v3.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3c9d0118 // stur    q24, [x8, #-48]
+	WORD $0xbd401c18 // ldr    s24, [x0, #28]
+	WORD $0x3dc00819 // ldr    q25, [x0, #32]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea44739 // ushl    v25.4s, v25.4s, v4.4s
+	WORD $0x6ea54718 // ushl    v24.4s, v24.4s, v5.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3c9e0118 // stur    q24, [x8, #-32]
+	WORD $0xbd402c18 // ldr    s24, [x0, #44]
+	WORD $0x3dc00c19 // ldr    q25, [x0, #48]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6ea64739 // ushl    v25.4s, v25.4s, v6.4s
+	WORD $0x6ea74718 // ushl    v24.4s, v24.4s, v7.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3c9f0118 // stur    q24, [x8, #-16]
+	WORD $0xbd403c18 // ldr    s24, [x0, #60]
+	WORD $0x3dc01019 // ldr    q25, [x0, #64]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb04739 // ushl    v25.4s, v25.4s, v16.4s
+	WORD $0x6eb14718 // ushl    v24.4s, v24.4s, v17.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3d800118 // str    q24, [x8]
+	WORD $0xbd404c18 // ldr    s24, [x0, #76]
+	WORD $0x3dc01419 // ldr    q25, [x0, #80]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb24739 // ushl    v25.4s, v25.4s, v18.4s
+	WORD $0x6eb34718 // ushl    v24.4s, v24.4s, v19.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3d800518 // str    q24, [x8, #16]
+	WORD $0xbd405c18 // ldr    s24, [x0, #92]
+	WORD $0x3dc01819 // ldr    q25, [x0, #96]
+	WORD $0x6e182318 // ext    v24.16b, v24.16b, v24.16b, #4
+	WORD $0x6e196318 // ext    v24.16b, v24.16b, v25.16b, #12
+	WORD $0x6eb44739 // ushl    v25.4s, v25.4s, v20.4s
+	WORD $0x6eb54718 // ushl    v24.4s, v24.4s, v21.4s
+	WORD $0x4eb81f38 // orr    v24.16b, v25.16b, v24.16b
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3d800918 // str    q24, [x8, #32]
+	WORD $0xfd403818 // ldr    d24, [x0, #112]
+	WORD $0xbd406c19 // ldr    s25, [x0, #108]
+	WORD $0xb940780b // ldr    w11, [x0, #120]
+	WORD $0x9101f000 // add    x0, x0, #124
+	WORD $0x2eb6471a // ushl    v26.2s, v24.2s, v22.2s
+	WORD $0x0e0c3f0a // mov    w10, v24.s[1]
+	WORD $0x0e983b39 // zip1    v25.2s, v25.2s, v24.2s
+	WORD $0x138a096a // extr    w10, w11, w10, #2
+	WORD $0x2eb74739 // ushl    v25.2s, v25.2s, v23.2s
+	WORD $0x0eb91f58 // orr    v24.8b, v26.8b, v25.8b
+	WORD $0x4e141d58 // mov    v24.s[2], w10
+	WORD $0x53017d6a // lsr    w10, w11, #1
+	WORD $0x4e1c1d58 // mov    v24.s[3], w10
+	WORD $0x6f047418 // bic    v24.4s, #128, lsl #24
+	WORD $0x3d800d18 // str    q24, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_102
+	JMP LBB0_156
+
+LBB0_103:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.104:
+	WORD $0x7100427f // cmp    w19, #16
+	WORD $0x54000002 // b.hs    .LBB0_151
+
+	// %bb.105:
+	WORD $0xaa1f03e8 // mov    x8, xzr
+	JMP LBB0_154
+
+LBB0_106:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.107:
+	WORD $0x6f01e660 // movi    v0.2d, #0x00ffff0000ffff
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_108:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9c0101 // stur    q1, [x8, #-64]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9d0101 // stur    q1, [x8, #-48]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9e0101 // stur    q1, [x8, #-32]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9f0101 // stur    q1, [x8, #-16]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800101 // str    q1, [x8]
+	WORD $0x29452c0a // ldp    w10, w11, [x0, #40]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800501 // str    q1, [x8, #16]
+	WORD $0x29462c0a // ldp    w10, w11, [x0, #48]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800901 // str    q1, [x8, #32]
+	WORD $0x29472c0a // ldp    w10, w11, [x0, #56]
+	WORD $0x91010000 // add    x0, x0, #64
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53107d6a // lsr    w10, w11, #16
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800d01 // str    q1, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_108
+	JMP LBB0_156
+
+LBB0_109:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.110:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_165
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0x6f00e620 // movi    v0.2d, #0x0000ff000000ff
+	VMOVD LCPI0_165, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_111:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9c0102 // stur    q2, [x8, #-64]
+	WORD $0xb940040a // ldr    w10, [x0, #4]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9d0102 // stur    q2, [x8, #-48]
+	WORD $0xb940080a // ldr    w10, [x0, #8]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9e0102 // stur    q2, [x8, #-32]
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9f0102 // stur    q2, [x8, #-16]
+	WORD $0xb940100a // ldr    w10, [x0, #16]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800102 // str    q2, [x8]
+	WORD $0xb940140a // ldr    w10, [x0, #20]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800502 // str    q2, [x8, #16]
+	WORD $0xb940180a // ldr    w10, [x0, #24]
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800902 // str    q2, [x8, #32]
+	WORD $0xb9401c0a // ldr    w10, [x0, #28]
+	WORD $0x91008000 // add    x0, x0, #32
+	WORD $0x0e040d42 // dup    v2.2s, w10
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x53187d4a // lsr    w10, w10, #24
+	WORD $0x6e032063 // ext    v3.16b, v3.16b, v3.16b, #4
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x6e026062 // ext    v2.16b, v3.16b, v2.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800d02 // str    q2, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_111
+	JMP LBB0_156
+
+LBB0_112:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.113:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_92
+	// WORD $0x9000000a // adrp    x10, .LCPI0_93
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_92, V0
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_93, V1
+
+LBB0_114:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404002 // ldur    d2, [x0, #4]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3c9c0102 // stur    q2, [x8, #-64]
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0xfd400802 // ldr    d2, [x0, #16]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3c9d0102 // stur    q2, [x8, #-48]
+	WORD $0xb940180a // ldr    w10, [x0, #24]
+	WORD $0xfc41c002 // ldur    d2, [x0, #28]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3c9e0102 // stur    q2, [x8, #-32]
+	WORD $0xb940240a // ldr    w10, [x0, #36]
+	WORD $0xfd401402 // ldr    d2, [x0, #40]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3c9f0102 // stur    q2, [x8, #-16]
+	WORD $0xb940300a // ldr    w10, [x0, #48]
+	WORD $0xfc434002 // ldur    d2, [x0, #52]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3d800102 // str    q2, [x8]
+	WORD $0xb9403c0a // ldr    w10, [x0, #60]
+	WORD $0xfd402002 // ldr    d2, [x0, #64]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3d800502 // str    q2, [x8, #16]
+	WORD $0xb940480a // ldr    w10, [x0, #72]
+	WORD $0xfc44c002 // ldur    d2, [x0, #76]
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3d800902 // str    q2, [x8, #32]
+	WORD $0xb940540a // ldr    w10, [x0, #84]
+	WORD $0xfd402c02 // ldr    d2, [x0, #88]
+	WORD $0x91018000 // add    x0, x0, #96
+	WORD $0x1e270143 // fmov    s3, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x2ea04445 // ushl    v5.2s, v2.2s, v0.2s
+	WORD $0x0e0c3c4a // mov    w10, v2.s[1]
+	WORD $0x0e823863 // zip1    v3.2s, v3.2s, v2.2s
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x0ea31ca3 // orr    v3.8b, v5.8b, v3.8b
+	WORD $0x6e036082 // ext    v2.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x6f0777e2 // bic    v2.4s, #255, lsl #24
+	WORD $0x3d800d02 // str    q2, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_114
+	JMP LBB0_156
+
+LBB0_115:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.116:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_186
+	// WORD $0x9000000a // adrp    x10, .LCPI0_187
+	WORD $0x4f0005e0 // movi    v0.4s, #15
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_186, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVQ LCPI0_187L, LCPI0_187H, V2
+
+LBB0_117:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d43 // dup    v3.2s, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x6e036083 // ext    v3.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d43 // mov    v3.s[3], w10
+	WORD $0xaa0003ea // mov    x10, x0
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3c9c0103 // stur    q3, [x8, #-64]
+	WORD $0x4ddfc943 // ld1r    { v3.4s }, [x10], #4
+	WORD $0x6ea24463 // ushl    v3.4s, v3.4s, v2.4s
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3c9d0103 // stur    q3, [x8, #-48]
+	WORD $0xb940014b // ldr    w11, [x10]
+	WORD $0x0e040d63 // dup    v3.2s, w11
+	WORD $0x1e270164 // fmov    s4, w11
+	WORD $0x530c7d6b // lsr    w11, w11, #12
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x6e036083 // ext    v3.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d63 // mov    v3.s[3], w11
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3c9e0103 // stur    q3, [x8, #-32]
+	WORD $0x4d40c943 // ld1r    { v3.4s }, [x10]
+	WORD $0x6ea24463 // ushl    v3.4s, v3.4s, v2.4s
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3c9f0103 // stur    q3, [x8, #-16]
+	WORD $0xb940080a // ldr    w10, [x0, #8]
+	WORD $0x0e040d43 // dup    v3.2s, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x6e036083 // ext    v3.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d43 // mov    v3.s[3], w10
+	WORD $0x9100200a // add    x10, x0, #8
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3d800103 // str    q3, [x8]
+	WORD $0x4d40c943 // ld1r    { v3.4s }, [x10]
+	WORD $0x6ea24463 // ushl    v3.4s, v3.4s, v2.4s
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3d800503 // str    q3, [x8, #16]
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x0e040d43 // dup    v3.2s, w10
+	WORD $0x1e270144 // fmov    s4, w10
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x6e042084 // ext    v4.16b, v4.16b, v4.16b, #4
+	WORD $0x2ea14463 // ushl    v3.2s, v3.2s, v1.2s
+	WORD $0x6e036083 // ext    v3.16b, v4.16b, v3.16b, #12
+	WORD $0x4e1c1d43 // mov    v3.s[3], w10
+	WORD $0x9100300a // add    x10, x0, #12
+	WORD $0x91004000 // add    x0, x0, #16
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3d800903 // str    q3, [x8, #32]
+	WORD $0x4d40c943 // ld1r    { v3.4s }, [x10]
+	WORD $0x6ea24463 // ushl    v3.4s, v3.4s, v2.4s
+	WORD $0x4e201c63 // and    v3.16b, v3.16b, v0.16b
+	WORD $0x3d800d03 // str    q3, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_117
+	JMP LBB0_156
+
+LBB0_118:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.119:
+	WORD $0x4f00d5e0 // movi    v0.4s, #15, msl #16
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_120:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x138a516c // extr    w12, w11, w10, #20
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53087d6a // lsr    w10, w11, #8
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb940080c // ldr    w12, [x0, #8]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b718a // extr    w10, w12, w11, #28
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9c0101 // stur    q1, [x8, #-64]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53047d6c // lsr    w12, w11, #4
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940100a // ldr    w10, [x0, #16]
+	WORD $0x138b614b // extr    w11, w10, w11, #24
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9d0101 // stur    q1, [x8, #-48]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x138a516c // extr    w12, w11, w10, #20
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53087d6a // lsr    w10, w11, #8
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb9401c0c // ldr    w12, [x0, #28]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b718a // extr    w10, w12, w11, #28
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9e0101 // stur    q1, [x8, #-32]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53047d6c // lsr    w12, w11, #4
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940240a // ldr    w10, [x0, #36]
+	WORD $0x138b614b // extr    w11, w10, w11, #24
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9f0101 // stur    q1, [x8, #-16]
+	WORD $0x29452c0a // ldp    w10, w11, [x0, #40]
+	WORD $0x138a516c // extr    w12, w11, w10, #20
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53087d6a // lsr    w10, w11, #8
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb940300c // ldr    w12, [x0, #48]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b718a // extr    w10, w12, w11, #28
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800101 // str    q1, [x8]
+	WORD $0x29462c0a // ldp    w10, w11, [x0, #48]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53047d6c // lsr    w12, w11, #4
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940380a // ldr    w10, [x0, #56]
+	WORD $0x138b614b // extr    w11, w10, w11, #24
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800501 // str    q1, [x8, #16]
+	WORD $0x2947ac0a // ldp    w10, w11, [x0, #60]
+	WORD $0x138a516c // extr    w12, w11, w10, #20
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53087d6a // lsr    w10, w11, #8
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb940440c // ldr    w12, [x0, #68]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b718a // extr    w10, w12, w11, #28
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800901 // str    q1, [x8, #32]
+	WORD $0x2948ac0a // ldp    w10, w11, [x0, #68]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53047d6c // lsr    w12, w11, #4
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb9404c0a // ldr    w10, [x0, #76]
+	WORD $0x91014000 // add    x0, x0, #80
+	WORD $0x138b614b // extr    w11, w10, w11, #24
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530c7d4a // lsr    w10, w10, #12
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800d01 // str    q1, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_120
+	JMP LBB0_156
+
+LBB0_121:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.122:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_145
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0x4f00c5e0 // movi    v0.4s, #15, msl #8
+	VMOVD LCPI0_145, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_123:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9c0102 // stur    q2, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3c9d0102 // stur    q2, [x8, #-48]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9e0102 // stur    q2, [x8, #-32]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3c9f0102 // stur    q2, [x8, #-16]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800102 // str    q2, [x8]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3d800502 // str    q2, [x8, #16]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x530c7d4c // lsr    w12, w10, #12
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800902 // str    q2, [x8, #32]
+	WORD $0x29452c0a // ldp    w10, w11, [x0, #40]
+	WORD $0x9100c000 // add    x0, x0, #48
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3d800d02 // str    q2, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_123
+	JMP LBB0_156
+
+LBB0_124:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.125:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_48
+	// WORD $0x90000009 // adrp    x9, .LCPI0_49
+	// WORD $0x9000000a // adrp    x10, .LCPI0_50
+	// WORD $0x9000000b // adrp    x11, .LCPI0_51
+	VMOVD LCPI0_48, V0
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_49, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_50, V2
+	VMOVD LCPI0_51, V3
+
+LBB0_126:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404004 // ldur    d4, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270145 // fmov    s5, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x2ea04487 // ushl    v7.2s, v4.2s, v0.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x0ea51ce5 // orr    v5.8b, v7.8b, v5.8b
+	WORD $0x6e0560c4 // ext    v4.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3c9c0104 // stur    q4, [x8, #-64]
+	WORD $0xfd400804 // ldr    d4, [x0, #16]
+	WORD $0xbd400c05 // ldr    s5, [x0, #12]
+	WORD $0xb940180b // ldr    w11, [x0, #24]
+	WORD $0x2ea24486 // ushl    v6.2s, v4.2s, v2.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x138a216a // extr    w10, w11, w10, #8
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x0ea51cc4 // orr    v4.8b, v6.8b, v5.8b
+	WORD $0x4e141d44 // mov    v4.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3c9d0104 // stur    q4, [x8, #-48]
+	WORD $0xb9401c0a // ldr    w10, [x0, #28]
+	WORD $0xfd401004 // ldr    d4, [x0, #32]
+	WORD $0xb940280b // ldr    w11, [x0, #40]
+	WORD $0x1e270145 // fmov    s5, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x2ea04487 // ushl    v7.2s, v4.2s, v0.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x0ea51ce5 // orr    v5.8b, v7.8b, v5.8b
+	WORD $0x6e0560c4 // ext    v4.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3c9e0104 // stur    q4, [x8, #-32]
+	WORD $0xfc42c004 // ldur    d4, [x0, #44]
+	WORD $0xbd402805 // ldr    s5, [x0, #40]
+	WORD $0xb940340b // ldr    w11, [x0, #52]
+	WORD $0x2ea24486 // ushl    v6.2s, v4.2s, v2.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x138a216a // extr    w10, w11, w10, #8
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x0ea51cc4 // orr    v4.8b, v6.8b, v5.8b
+	WORD $0x4e141d44 // mov    v4.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3c9f0104 // stur    q4, [x8, #-16]
+	WORD $0xb940380a // ldr    w10, [x0, #56]
+	WORD $0xfc43c004 // ldur    d4, [x0, #60]
+	WORD $0xb940440b // ldr    w11, [x0, #68]
+	WORD $0x1e270145 // fmov    s5, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x2ea04487 // ushl    v7.2s, v4.2s, v0.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x0ea51ce5 // orr    v5.8b, v7.8b, v5.8b
+	WORD $0x6e0560c4 // ext    v4.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3d800104 // str    q4, [x8]
+	WORD $0xfd402404 // ldr    d4, [x0, #72]
+	WORD $0xbd404405 // ldr    s5, [x0, #68]
+	WORD $0xb940500b // ldr    w11, [x0, #80]
+	WORD $0x2ea24486 // ushl    v6.2s, v4.2s, v2.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x138a216a // extr    w10, w11, w10, #8
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x0ea51cc4 // orr    v4.8b, v6.8b, v5.8b
+	WORD $0x4e141d44 // mov    v4.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3d800504 // str    q4, [x8, #16]
+	WORD $0xb940540a // ldr    w10, [x0, #84]
+	WORD $0xfd402c04 // ldr    d4, [x0, #88]
+	WORD $0xb940600b // ldr    w11, [x0, #96]
+	WORD $0x1e270145 // fmov    s5, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x2ea04487 // ushl    v7.2s, v4.2s, v0.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x138a516a // extr    w10, w11, w10, #20
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x0ea51ce5 // orr    v5.8b, v7.8b, v5.8b
+	WORD $0x6e0560c4 // ext    v4.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3d800904 // str    q4, [x8, #32]
+	WORD $0xfc464004 // ldur    d4, [x0, #100]
+	WORD $0xbd406005 // ldr    s5, [x0, #96]
+	WORD $0xb9406c0b // ldr    w11, [x0, #108]
+	WORD $0x9101c000 // add    x0, x0, #112
+	WORD $0x2ea24486 // ushl    v6.2s, v4.2s, v2.2s
+	WORD $0x0e0c3c8a // mov    w10, v4.s[1]
+	WORD $0x0e8438a5 // zip1    v5.2s, v5.2s, v4.2s
+	WORD $0x138a216a // extr    w10, w11, w10, #8
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x0ea51cc4 // orr    v4.8b, v6.8b, v5.8b
+	WORD $0x4e141d44 // mov    v4.s[2], w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e1c1d44 // mov    v4.s[3], w10
+	WORD $0x6f077604 // bic    v4.4s, #240, lsl #24
+	WORD $0x3d800d04 // str    q4, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_126
+	JMP LBB0_156
+
+LBB0_127:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.128:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_196
+	// WORD $0x90000009 // adrp    x9, .LCPI0_197
+	// WORD $0x9000000a // adrp    x10, .LCPI0_198
+	// WORD $0x9000000b // adrp    x11, .LCPI0_199
+	WORD $0x4f000462 // movi    v2.4s, #3
+	VMOVD LCPI0_196, V0
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVQ LCPI0_197L, LCPI0_197H, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVQ LCPI0_198L, LCPI0_198H, V3
+	VMOVQ LCPI0_199L, LCPI0_199H, V4
+
+LBB0_129:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x53067d4a // lsr    w10, w10, #6
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0xaa0003ea // mov    x10, x0
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9c0105 // stur    q5, [x8, #-64]
+	WORD $0x4ddfc945 // ld1r    { v5.4s }, [x10], #4
+	WORD $0x6ea144a5 // ushl    v5.4s, v5.4s, v1.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9d0105 // stur    q5, [x8, #-48]
+	WORD $0x4d40c805 // ld1r    { v5.4s }, [x0]
+	WORD $0x6ea344a5 // ushl    v5.4s, v5.4s, v3.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9e0105 // stur    q5, [x8, #-32]
+	WORD $0xb840840b // ldr    w11, [x0], #8
+	WORD $0x4e040d65 // dup    v5.4s, w11
+	WORD $0x6ea444a5 // ushl    v5.4s, v5.4s, v4.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9f0105 // stur    q5, [x8, #-16]
+	WORD $0xb940014b // ldr    w11, [x10]
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x1e270166 // fmov    s6, w11
+	WORD $0x53067d6b // lsr    w11, w11, #6
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d65 // mov    v5.s[3], w11
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800105 // str    q5, [x8]
+	WORD $0x4d40c945 // ld1r    { v5.4s }, [x10]
+	WORD $0x6ea144a5 // ushl    v5.4s, v5.4s, v1.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800505 // str    q5, [x8, #16]
+	WORD $0x4d40c945 // ld1r    { v5.4s }, [x10]
+	WORD $0x6ea344a5 // ushl    v5.4s, v5.4s, v3.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800905 // str    q5, [x8, #32]
+	WORD $0x4d40c945 // ld1r    { v5.4s }, [x10]
+	WORD $0x6ea444a5 // ushl    v5.4s, v5.4s, v4.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800d05 // str    q5, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_129
+	JMP LBB0_156
+
+LBB0_130:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.131:
+	WORD $0x4f00d460 // movi    v0.4s, #3, msl #16
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_132:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x138a496c // extr    w12, w11, w10, #18
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb940080c // ldr    w12, [x0, #8]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b598a // extr    w10, w12, w11, #22
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9c0101 // stur    q1, [x8, #-64]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x1e270181 // fmov    s1, w12
+	WORD $0xb940100c // ldr    w12, [x0, #16]
+	WORD $0x4e0c1d41 // mov    v1.s[1], w10
+	WORD $0x530c7d6a // lsr    w10, w11, #12
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b798a // extr    w10, w12, w11, #30
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9d0101 // stur    q1, [x8, #-48]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53027d6c // lsr    w12, w11, #2
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940180a // ldr    w10, [x0, #24]
+	WORD $0x138b514b // extr    w11, w10, w11, #20
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x53067d4a // lsr    w10, w10, #6
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9e0101 // stur    q1, [x8, #-32]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x530a7d6c // lsr    w12, w11, #10
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940200a // ldr    w10, [x0, #32]
+	WORD $0x138b714b // extr    w11, w10, w11, #28
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530e7d4a // lsr    w10, w10, #14
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3c9f0101 // stur    q1, [x8, #-16]
+	WORD $0x2944ac0a // ldp    w10, w11, [x0, #36]
+	WORD $0x138a496c // extr    w12, w11, w10, #18
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0x53047d6a // lsr    w10, w11, #4
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0xb9402c0c // ldr    w12, [x0, #44]
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b598a // extr    w10, w12, w11, #22
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800101 // str    q1, [x8]
+	WORD $0x2945ac0a // ldp    w10, w11, [x0, #44]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x1e270181 // fmov    s1, w12
+	WORD $0xb940340c // ldr    w12, [x0, #52]
+	WORD $0x4e0c1d41 // mov    v1.s[1], w10
+	WORD $0x530c7d6a // lsr    w10, w11, #12
+	WORD $0x4e141d41 // mov    v1.s[2], w10
+	WORD $0x138b798a // extr    w10, w12, w11, #30
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800501 // str    q1, [x8, #16]
+	WORD $0x2946ac0a // ldp    w10, w11, [x0, #52]
+	WORD $0x138a416a // extr    w10, w11, w10, #16
+	WORD $0x53027d6c // lsr    w12, w11, #2
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb9403c0a // ldr    w10, [x0, #60]
+	WORD $0x138b514b // extr    w11, w10, w11, #20
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x53067d4a // lsr    w10, w10, #6
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800901 // str    q1, [x8, #32]
+	WORD $0x2947ac0a // ldp    w10, w11, [x0, #60]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x530a7d6c // lsr    w12, w11, #10
+	WORD $0x1e270141 // fmov    s1, w10
+	WORD $0xb940440a // ldr    w10, [x0, #68]
+	WORD $0x91012000 // add    x0, x0, #72
+	WORD $0x138b714b // extr    w11, w10, w11, #28
+	WORD $0x4e0c1d81 // mov    v1.s[1], w12
+	WORD $0x530e7d4a // lsr    w10, w10, #14
+	WORD $0x4e141d61 // mov    v1.s[2], w11
+	WORD $0x4e1c1d41 // mov    v1.s[3], w10
+	WORD $0x4e201c21 // and    v1.16b, v1.16b, v0.16b
+	WORD $0x3d800d01 // str    q1, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_132
+	JMP LBB0_156
+
+LBB0_133:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.134:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_153
+	// WORD $0x90000009 // adrp    x9, .LCPI0_154
+	// WORD $0x9000000a // adrp    x10, .LCPI0_155
+	// WORD $0x9000000b // adrp    x11, .LCPI0_156
+	WORD $0x4f00c462 // movi    v2.4s, #3, msl #8
+	VMOVD LCPI0_153, V0
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_154, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_155, V3
+	VMOVD LCPI0_156, V4
+
+LBB0_135:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9c0105 // stur    q5, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x4e141d45 // mov    v5.s[2], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9d0105 // stur    q5, [x8, #-48]
+	WORD $0x29412c0a // ldp    w10, w11, [x0, #8]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x1e270186 // fmov    s6, w12
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x4e0c1d46 // mov    v6.s[1], w10
+	WORD $0x6e1804a6 // mov    v6.d[1], v5.d[0]
+	WORD $0x4e221cc5 // and    v5.16b, v6.16b, v2.16b
+	WORD $0x3c9e0105 // stur    q5, [x8, #-32]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x53167d6a // lsr    w10, w11, #22
+	WORD $0x2ea444a5 // ushl    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9f0105 // stur    q5, [x8, #-16]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800105 // str    q5, [x8]
+	WORD $0x29432c0a // ldp    w10, w11, [x0, #24]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x4e141d45 // mov    v5.s[2], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800505 // str    q5, [x8, #16]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x1e270186 // fmov    s6, w12
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x4e0c1d46 // mov    v6.s[1], w10
+	WORD $0x6e1804a6 // mov    v6.d[1], v5.d[0]
+	WORD $0x4e221cc5 // and    v5.16b, v6.16b, v2.16b
+	WORD $0x3d800905 // str    q5, [x8, #32]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x9100a000 // add    x0, x0, #40
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x53167d6a // lsr    w10, w11, #22
+	WORD $0x2ea444a5 // ushl    v5.2s, v5.2s, v4.2s
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800d05 // str    q5, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_135
+	JMP LBB0_156
+
+LBB0_136:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.137:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_68
+	// WORD $0x90000009 // adrp    x9, .LCPI0_69
+	// WORD $0x9000000a // adrp    x10, .LCPI0_70
+	VMOVD LCPI0_68, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_71
+	VMOVD LCPI0_69, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_72
+	VMOVD LCPI0_70, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_73
+	VMOVD LCPI0_71, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_74
+	VMOVD LCPI0_72, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_75
+	VMOVD LCPI0_73, V5
+	VMOVD LCPI0_74, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_75, V7
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_138:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404010 // ldur    d16, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x2ea04613 // ushl    v19.2s, v16.2s, v0.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x138a396a // extr    w10, w11, w10, #14
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x0eb11e71 // orr    v17.8b, v19.8b, v17.8b
+	WORD $0x6e116250 // ext    v16.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3c9c0110 // stur    q16, [x8, #-64]
+	WORD $0x2941a80b // ldp    w11, w10, [x0, #12]
+	WORD $0xfc414010 // ldur    d16, [x0, #20]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x138b214b // extr    w11, w10, w11, #8
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x2ea24610 // ushl    v16.2s, v16.2s, v2.2s
+	WORD $0x1e270172 // fmov    s18, w11
+	WORD $0x2ea34631 // ushl    v17.2s, v17.2s, v3.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x0eb11e10 // orr    v16.8b, v16.8b, v17.8b
+	WORD $0x6e180612 // mov    v18.d[1], v16.d[0]
+	WORD $0x6f077792 // bic    v18.4s, #252, lsl #24
+	WORD $0x3c9d0112 // stur    q18, [x8, #-48]
+	WORD $0xfc41c010 // ldur    d16, [x0, #28]
+	WORD $0xbd401811 // ldr    s17, [x0, #24]
+	WORD $0xb940240c // ldr    w12, [x0, #36]
+	WORD $0x2ea44612 // ushl    v18.2s, v16.2s, v4.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x53047d4b // lsr    w11, w10, #4
+	WORD $0x138a798a // extr    w10, w12, w10, #30
+	WORD $0x2ea54631 // ushl    v17.2s, v17.2s, v5.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d70 // mov    v16.s[2], w11
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3c9e0110 // stur    q16, [x8, #-32]
+	WORD $0xfd401410 // ldr    d16, [x0, #40]
+	WORD $0xbd402411 // ldr    s17, [x0, #36]
+	WORD $0xb940300b // ldr    w11, [x0, #48]
+	WORD $0x2ea64612 // ushl    v18.2s, v16.2s, v6.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x138a316a // extr    w10, w11, w10, #12
+	WORD $0x2ea74631 // ushl    v17.2s, v17.2s, v7.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3c9f0110 // stur    q16, [x8, #-16]
+	WORD $0xb940340a // ldr    w10, [x0, #52]
+	WORD $0xfd401c10 // ldr    d16, [x0, #56]
+	WORD $0xb940400b // ldr    w11, [x0, #64]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x2ea04613 // ushl    v19.2s, v16.2s, v0.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x138a396a // extr    w10, w11, w10, #14
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x0eb11e71 // orr    v17.8b, v19.8b, v17.8b
+	WORD $0x6e116250 // ext    v16.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3d800110 // str    q16, [x8]
+	WORD $0x2948280b // ldp    w11, w10, [x0, #64]
+	WORD $0xfd402410 // ldr    d16, [x0, #72]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x138b214b // extr    w11, w10, w11, #8
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x2ea24610 // ushl    v16.2s, v16.2s, v2.2s
+	WORD $0x1e270172 // fmov    s18, w11
+	WORD $0x2ea34631 // ushl    v17.2s, v17.2s, v3.2s
+	WORD $0x4e0c1d52 // mov    v18.s[1], w10
+	WORD $0x0eb11e10 // orr    v16.8b, v16.8b, v17.8b
+	WORD $0x6e180612 // mov    v18.d[1], v16.d[0]
+	WORD $0x6f077792 // bic    v18.4s, #252, lsl #24
+	WORD $0x3d800512 // str    q18, [x8, #16]
+	WORD $0xfd402810 // ldr    d16, [x0, #80]
+	WORD $0xbd404c11 // ldr    s17, [x0, #76]
+	WORD $0xb940580c // ldr    w12, [x0, #88]
+	WORD $0x2ea44612 // ushl    v18.2s, v16.2s, v4.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x53047d4b // lsr    w11, w10, #4
+	WORD $0x138a798a // extr    w10, w12, w10, #30
+	WORD $0x2ea54631 // ushl    v17.2s, v17.2s, v5.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d70 // mov    v16.s[2], w11
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3d800910 // str    q16, [x8, #32]
+	WORD $0xfc45c010 // ldur    d16, [x0, #92]
+	WORD $0xbd405811 // ldr    s17, [x0, #88]
+	WORD $0xb940640b // ldr    w11, [x0, #100]
+	WORD $0x9101a000 // add    x0, x0, #104
+	WORD $0x2ea64612 // ushl    v18.2s, v16.2s, v6.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x138a316a // extr    w10, w11, w10, #12
+	WORD $0x2ea74631 // ushl    v17.2s, v17.2s, v7.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53067d6a // lsr    w10, w11, #6
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f077790 // bic    v16.4s, #252, lsl #24
+	WORD $0x3d800d10 // str    q16, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_138
+	JMP LBB0_156
+
+LBB0_139:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.140:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_174
+	// WORD $0x90000009 // adrp    x9, .LCPI0_175
+	// WORD $0x9000000a // adrp    x10, .LCPI0_176
+	// WORD $0x9000000b // adrp    x11, .LCPI0_177
+	WORD $0x4f0107e2 // movi    v2.4s, #63
+	VMOVD LCPI0_174, V0
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_175, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+	VMOVD LCPI0_176, V3
+	VMOVQ LCPI0_177L, LCPI0_177H, V4
+
+LBB0_141:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x53127d4a // lsr    w10, w10, #18
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9c0105 // stur    q5, [x8, #-64]
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0x53187d4c // lsr    w12, w10, #24
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x1e270186 // fmov    s6, w12
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x4e0c1d46 // mov    v6.s[1], w10
+	WORD $0x6e1804a6 // mov    v6.d[1], v5.d[0]
+	WORD $0x4e221cc5 // and    v5.16b, v6.16b, v2.16b
+	WORD $0x3c9d0105 // stur    q5, [x8, #-48]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x4e141d45 // mov    v5.s[2], w10
+	WORD $0x53027d6a // lsr    w10, w11, #2
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x9100200a // add    x10, x0, #8
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9e0105 // stur    q5, [x8, #-32]
+	WORD $0x4d40c945 // ld1r    { v5.4s }, [x10]
+	WORD $0x6ea444a5 // ushl    v5.4s, v5.4s, v4.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3c9f0105 // stur    q5, [x8, #-16]
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x1e270146 // fmov    s6, w10
+	WORD $0x53127d4a // lsr    w10, w10, #18
+	WORD $0x6e0620c6 // ext    v6.16b, v6.16b, v6.16b, #4
+	WORD $0x2ea044a5 // ushl    v5.2s, v5.2s, v0.2s
+	WORD $0x6e0560c5 // ext    v5.16b, v6.16b, v5.16b, #12
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800105 // str    q5, [x8]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x53187d4c // lsr    w12, w10, #24
+	WORD $0x0e040d65 // dup    v5.2s, w11
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x1e270186 // fmov    s6, w12
+	WORD $0x2ea144a5 // ushl    v5.2s, v5.2s, v1.2s
+	WORD $0x4e0c1d46 // mov    v6.s[1], w10
+	WORD $0x6e1804a6 // mov    v6.d[1], v5.d[0]
+	WORD $0x4e221cc5 // and    v5.16b, v6.16b, v2.16b
+	WORD $0x3d800505 // str    q5, [x8, #16]
+	WORD $0x29422c0a // ldp    w10, w11, [x0, #16]
+	WORD $0x0e040d45 // dup    v5.2s, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x2ea344a5 // ushl    v5.2s, v5.2s, v3.2s
+	WORD $0x4e141d45 // mov    v5.s[2], w10
+	WORD $0x53027d6a // lsr    w10, w11, #2
+	WORD $0x4e1c1d45 // mov    v5.s[3], w10
+	WORD $0x9100500a // add    x10, x0, #20
+	WORD $0x91006000 // add    x0, x0, #24
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800905 // str    q5, [x8, #32]
+	WORD $0x4d40c945 // ld1r    { v5.4s }, [x10]
+	WORD $0x6ea444a5 // ushl    v5.4s, v5.4s, v4.4s
+	WORD $0x4e221ca5 // and    v5.16b, v5.16b, v2.16b
+	WORD $0x3d800d05 // str    q5, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_141
+	JMP LBB0_156
+
+LBB0_142:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.143:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_110
+	// WORD $0x90000009 // adrp    x9, .LCPI0_111
+	// WORD $0x9000000a // adrp    x10, .LCPI0_112
+	WORD $0x4f01d7e7 // movi    v7.4s, #63, msl #16
+	VMOVD LCPI0_110, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_113
+	VMOVD LCPI0_111, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_114
+	VMOVD LCPI0_112, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_115
+	VMOVD LCPI0_113, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_116
+	VMOVD LCPI0_114, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_117
+	VMOVD LCPI0_115, V5
+	VMOVD LCPI0_116, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_117, V16
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_144:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404011 // ldur    d17, [x0, #4]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x1e270153 // fmov    s19, w10
+	WORD $0x2ea04634 // ushl    v20.2s, v17.2s, v0.2s
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x6e132273 // ext    v19.16b, v19.16b, v19.16b, #4
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x2ea14652 // ushl    v18.2s, v18.2s, v1.2s
+	WORD $0x0eb21e92 // orr    v18.8b, v20.8b, v18.8b
+	WORD $0x6e126271 // ext    v17.16b, v19.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9c0111 // stur    q17, [x8, #-64]
+	WORD $0xfc40c011 // ldur    d17, [x0, #12]
+	WORD $0xbd400812 // ldr    s18, [x0, #8]
+	WORD $0xb940140c // ldr    w12, [x0, #20]
+	WORD $0x2ea24633 // ushl    v19.2s, v17.2s, v2.2s
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x53047d4b // lsr    w11, w10, #4
+	WORD $0x138a698a // extr    w10, w12, w10, #26
+	WORD $0x2ea34652 // ushl    v18.2s, v18.2s, v3.2s
+	WORD $0x0eb21e71 // orr    v17.8b, v19.8b, v18.8b
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9d0111 // stur    q17, [x8, #-48]
+	WORD $0x2942a80b // ldp    w11, w10, [x0, #20]
+	WORD $0xfc41c011 // ldur    d17, [x0, #28]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x138b414b // extr    w11, w10, w11, #16
+	WORD $0x53067d4a // lsr    w10, w10, #6
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x2ea44631 // ushl    v17.2s, v17.2s, v4.2s
+	WORD $0x1e270173 // fmov    s19, w11
+	WORD $0x2ea54652 // ushl    v18.2s, v18.2s, v5.2s
+	WORD $0x4e0c1d53 // mov    v19.s[1], w10
+	WORD $0x0eb21e31 // orr    v17.8b, v17.8b, v18.8b
+	WORD $0x6e180633 // mov    v19.d[1], v17.d[0]
+	WORD $0x4e271e71 // and    v17.16b, v19.16b, v7.16b
+	WORD $0x3c9e0111 // stur    q17, [x8, #-32]
+	WORD $0xb940200a // ldr    w10, [x0, #32]
+	WORD $0xfc424011 // ldur    d17, [x0, #36]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea64633 // ushl    v19.2s, v17.2s, v6.2s
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x1e270154 // fmov    s20, w10
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x6e142294 // ext    v20.16b, v20.16b, v20.16b, #4
+	WORD $0x2eb04652 // ushl    v18.2s, v18.2s, v16.2s
+	WORD $0x530a7d4a // lsr    w10, w10, #10
+	WORD $0x0eb21e72 // orr    v18.8b, v19.8b, v18.8b
+	WORD $0x6e126291 // ext    v17.16b, v20.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3c9f0111 // stur    q17, [x8, #-16]
+	WORD $0xb9402c0a // ldr    w10, [x0, #44]
+	WORD $0xfd401811 // ldr    d17, [x0, #48]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x1e270153 // fmov    s19, w10
+	WORD $0x2ea04634 // ushl    v20.2s, v17.2s, v0.2s
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x6e132273 // ext    v19.16b, v19.16b, v19.16b, #4
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x2ea14652 // ushl    v18.2s, v18.2s, v1.2s
+	WORD $0x0eb21e92 // orr    v18.8b, v20.8b, v18.8b
+	WORD $0x6e126271 // ext    v17.16b, v19.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800111 // str    q17, [x8]
+	WORD $0xfd401c11 // ldr    d17, [x0, #56]
+	WORD $0xbd403412 // ldr    s18, [x0, #52]
+	WORD $0xb940400c // ldr    w12, [x0, #64]
+	WORD $0x2ea24633 // ushl    v19.2s, v17.2s, v2.2s
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x53047d4b // lsr    w11, w10, #4
+	WORD $0x138a698a // extr    w10, w12, w10, #26
+	WORD $0x2ea34652 // ushl    v18.2s, v18.2s, v3.2s
+	WORD $0x0eb21e71 // orr    v17.8b, v19.8b, v18.8b
+	WORD $0x4e141d71 // mov    v17.s[2], w11
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800511 // str    q17, [x8, #16]
+	WORD $0x2948280b // ldp    w11, w10, [x0, #64]
+	WORD $0xfd402411 // ldr    d17, [x0, #72]
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x138b414b // extr    w11, w10, w11, #16
+	WORD $0x53067d4a // lsr    w10, w10, #6
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x2ea44631 // ushl    v17.2s, v17.2s, v4.2s
+	WORD $0x1e270173 // fmov    s19, w11
+	WORD $0x2ea54652 // ushl    v18.2s, v18.2s, v5.2s
+	WORD $0x4e0c1d53 // mov    v19.s[1], w10
+	WORD $0x0eb21e31 // orr    v17.8b, v17.8b, v18.8b
+	WORD $0x6e180633 // mov    v19.d[1], v17.d[0]
+	WORD $0x4e271e71 // and    v17.16b, v19.16b, v7.16b
+	WORD $0x3d800911 // str    q17, [x8, #32]
+	WORD $0xb9404c0a // ldr    w10, [x0, #76]
+	WORD $0xfd402811 // ldr    d17, [x0, #80]
+	WORD $0x91016000 // add    x0, x0, #88
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x53087d4a // lsr    w10, w10, #8
+	WORD $0x2ea64633 // ushl    v19.2s, v17.2s, v6.2s
+	WORD $0x0e913a52 // zip1    v18.2s, v18.2s, v17.2s
+	WORD $0x1e270154 // fmov    s20, w10
+	WORD $0x0e0c3e2a // mov    w10, v17.s[1]
+	WORD $0x6e142294 // ext    v20.16b, v20.16b, v20.16b, #4
+	WORD $0x2eb04652 // ushl    v18.2s, v18.2s, v16.2s
+	WORD $0x530a7d4a // lsr    w10, w10, #10
+	WORD $0x0eb21e72 // orr    v18.8b, v19.8b, v18.8b
+	WORD $0x6e126291 // ext    v17.16b, v20.16b, v18.16b, #12
+	WORD $0x4e1c1d51 // mov    v17.s[3], w10
+	WORD $0x4e271e31 // and    v17.16b, v17.16b, v7.16b
+	WORD $0x3d800d11 // str    q17, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_144
+	JMP LBB0_156
+
+LBB0_145:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.146:
+	// WORD $0x90000009 // adrp    x9, .LCPI0_139
+	WORD $0x91010348 // add    x8, x26, #64
+	WORD $0x4f01c7e0 // movi    v0.4s, #63, msl #8
+	VMOVD LCPI0_139, V1
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_147:
+	WORD $0x29402c0a // ldp    w10, w11, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0x530e7d4c // lsr    w12, w10, #14
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9c0102 // stur    q2, [x8, #-64]
+	WORD $0x2940ac0a // ldp    w10, w11, [x0, #4]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x53067d6c // lsr    w12, w11, #6
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0xb9400c0a // ldr    w10, [x0, #12]
+	WORD $0x138b514b // extr    w11, w10, w11, #20
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x4e141d62 // mov    v2.s[2], w11
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9d0102 // stur    q2, [x8, #-48]
+	WORD $0x2941ac0a // ldp    w10, w11, [x0, #12]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x1e270182 // fmov    s2, w12
+	WORD $0xb940140c // ldr    w12, [x0, #20]
+	WORD $0x4e0c1d42 // mov    v2.s[1], w10
+	WORD $0x530c7d6a // lsr    w10, w11, #12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x138b698a // extr    w10, w12, w11, #26
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3c9e0102 // stur    q2, [x8, #-32]
+	WORD $0x2942ac0a // ldp    w10, w11, [x0, #20]
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a596a // extr    w10, w11, w10, #22
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3c9f0102 // stur    q2, [x8, #-16]
+	WORD $0x2943ac0a // ldp    w10, w11, [x0, #28]
+	WORD $0x530e7d4c // lsr    w12, w10, #14
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0x138a716a // extr    w10, w11, w10, #28
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x530a7d6a // lsr    w10, w11, #10
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800102 // str    q2, [x8]
+	WORD $0x29442c0a // ldp    w10, w11, [x0, #32]
+	WORD $0x138a616a // extr    w10, w11, w10, #24
+	WORD $0x53067d6c // lsr    w12, w11, #6
+	WORD $0x1e270142 // fmov    s2, w10
+	WORD $0xb940280a // ldr    w10, [x0, #40]
+	WORD $0x138b514b // extr    w11, w10, w11, #20
+	WORD $0x4e0c1d82 // mov    v2.s[1], w12
+	WORD $0x53027d4a // lsr    w10, w10, #2
+	WORD $0x4e141d62 // mov    v2.s[2], w11
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800502 // str    q2, [x8, #16]
+	WORD $0x29452c0a // ldp    w10, w11, [x0, #40]
+	WORD $0x53107d4c // lsr    w12, w10, #16
+	WORD $0x138a796a // extr    w10, w11, w10, #30
+	WORD $0x1e270182 // fmov    s2, w12
+	WORD $0xb940300c // ldr    w12, [x0, #48]
+	WORD $0x4e0c1d42 // mov    v2.s[1], w10
+	WORD $0x530c7d6a // lsr    w10, w11, #12
+	WORD $0x4e141d42 // mov    v2.s[2], w10
+	WORD $0x138b698a // extr    w10, w12, w11, #26
+	WORD $0x4e1c1d42 // mov    v2.s[3], w10
+	WORD $0x4e201c42 // and    v2.16b, v2.16b, v0.16b
+	WORD $0x3d800902 // str    q2, [x8, #32]
+	WORD $0x29462c0a // ldp    w10, w11, [x0, #48]
+	WORD $0x9100e000 // add    x0, x0, #56
+	WORD $0x53087d4c // lsr    w12, w10, #8
+	WORD $0x0e040d62 // dup    v2.2s, w11
+	WORD $0x138a596a // extr    w10, w11, w10, #22
+	WORD $0x1e270183 // fmov    s3, w12
+	WORD $0x2ea14442 // ushl    v2.2s, v2.2s, v1.2s
+	WORD $0x4e0c1d43 // mov    v3.s[1], w10
+	WORD $0x6e180443 // mov    v3.d[1], v2.d[0]
+	WORD $0x4e201c62 // and    v2.16b, v3.16b, v0.16b
+	WORD $0x3d800d02 // str    q2, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_147
+	JMP LBB0_156
+
+LBB0_148:
+	WORD $0x7100805f // cmp    w2, #32
+	BLT LBB0_156
+
+	// %bb.149:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_24
+	// WORD $0x90000009 // adrp    x9, .LCPI0_25
+	// WORD $0x9000000a // adrp    x10, .LCPI0_26
+	VMOVD LCPI0_24, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_27
+	VMOVD LCPI0_25, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_28
+	VMOVQ LCPI0_26L, LCPI0_26H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_29
+	VMOVQ LCPI0_27L, LCPI0_27H, V3
+	// WORD $0x90000008 // adrp    x8, .LCPI0_30
+	VMOVQ LCPI0_28L, LCPI0_28H, V4
+	// WORD $0x90000009 // adrp    x9, .LCPI0_31
+	VMOVQ LCPI0_29L, LCPI0_29H, V5
+	VMOVD LCPI0_30, V6
+	WORD $0x91010348 // add    x8, x26, #64
+	VMOVD LCPI0_31, V7
+	WORD $0xaa1303e9 // mov    x9, x19
+
+LBB0_150:
+	WORD $0xb940000a // ldr    w10, [x0]
+	WORD $0xf1000529 // subs    x9, x9, #1
+	WORD $0xfc404010 // ldur    d16, [x0, #4]
+	WORD $0xb9400c0b // ldr    w11, [x0, #12]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x2ea04613 // ushl    v19.2s, v16.2s, v0.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x0eb11e71 // orr    v17.8b, v19.8b, v17.8b
+	WORD $0x6e116250 // ext    v16.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3c9c0110 // stur    q16, [x8, #-64]
+	WORD $0xbd400c10 // ldr    s16, [x0, #12]
+	WORD $0x3dc00411 // ldr    q17, [x0, #16]
+	WORD $0x6e102210 // ext    v16.16b, v16.16b, v16.16b, #4
+	WORD $0x6e116210 // ext    v16.16b, v16.16b, v17.16b, #12
+	WORD $0x6ea24631 // ushl    v17.4s, v17.4s, v2.4s
+	WORD $0x6ea34610 // ushl    v16.4s, v16.4s, v3.4s
+	WORD $0x4eb01e30 // orr    v16.16b, v17.16b, v16.16b
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3c9d0110 // stur    q16, [x8, #-48]
+	WORD $0xbd401c10 // ldr    s16, [x0, #28]
+	WORD $0x3dc00811 // ldr    q17, [x0, #32]
+	WORD $0x6e102210 // ext    v16.16b, v16.16b, v16.16b, #4
+	WORD $0x6e116210 // ext    v16.16b, v16.16b, v17.16b, #12
+	WORD $0x6ea44631 // ushl    v17.4s, v17.4s, v4.4s
+	WORD $0x6ea54610 // ushl    v16.4s, v16.4s, v5.4s
+	WORD $0x4eb01e30 // orr    v16.16b, v17.16b, v16.16b
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3c9e0110 // stur    q16, [x8, #-32]
+	WORD $0xfd401810 // ldr    d16, [x0, #48]
+	WORD $0xbd402c11 // ldr    s17, [x0, #44]
+	WORD $0xb940380b // ldr    w11, [x0, #56]
+	WORD $0x2ea64612 // ushl    v18.2s, v16.2s, v6.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x138a116a // extr    w10, w11, w10, #4
+	WORD $0x2ea74631 // ushl    v17.2s, v17.2s, v7.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53027d6a // lsr    w10, w11, #2
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3c9f0110 // stur    q16, [x8, #-16]
+	WORD $0xb9403c0a // ldr    w10, [x0, #60]
+	WORD $0xfd402010 // ldr    d16, [x0, #64]
+	WORD $0xb940480b // ldr    w11, [x0, #72]
+	WORD $0x1e270151 // fmov    s17, w10
+	WORD $0x1e270152 // fmov    s18, w10
+	WORD $0x2ea04613 // ushl    v19.2s, v16.2s, v0.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x6e122252 // ext    v18.16b, v18.16b, v18.16b, #4
+	WORD $0x138a696a // extr    w10, w11, w10, #26
+	WORD $0x2ea14631 // ushl    v17.2s, v17.2s, v1.2s
+	WORD $0x0eb11e71 // orr    v17.8b, v19.8b, v17.8b
+	WORD $0x6e116250 // ext    v16.16b, v18.16b, v17.16b, #12
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3d800110 // str    q16, [x8]
+	WORD $0xbd404810 // ldr    s16, [x0, #72]
+	WORD $0x3cc4c011 // ldur    q17, [x0, #76]
+	WORD $0x6e102210 // ext    v16.16b, v16.16b, v16.16b, #4
+	WORD $0x6e116210 // ext    v16.16b, v16.16b, v17.16b, #12
+	WORD $0x6ea24631 // ushl    v17.4s, v17.4s, v2.4s
+	WORD $0x6ea34610 // ushl    v16.4s, v16.4s, v3.4s
+	WORD $0x4eb01e30 // orr    v16.16b, v17.16b, v16.16b
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3d800510 // str    q16, [x8, #16]
+	WORD $0xbd405810 // ldr    s16, [x0, #88]
+	WORD $0x3cc5c011 // ldur    q17, [x0, #92]
+	WORD $0x6e102210 // ext    v16.16b, v16.16b, v16.16b, #4
+	WORD $0x6e116210 // ext    v16.16b, v16.16b, v17.16b, #12
+	WORD $0x6ea44631 // ushl    v17.4s, v17.4s, v4.4s
+	WORD $0x6ea54610 // ushl    v16.4s, v16.4s, v5.4s
+	WORD $0x4eb01e30 // orr    v16.16b, v17.16b, v16.16b
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3d800910 // str    q16, [x8, #32]
+	WORD $0xfc46c010 // ldur    d16, [x0, #108]
+	WORD $0xbd406811 // ldr    s17, [x0, #104]
+	WORD $0xb940740b // ldr    w11, [x0, #116]
+	WORD $0x9101e000 // add    x0, x0, #120
+	WORD $0x2ea64612 // ushl    v18.2s, v16.2s, v6.2s
+	WORD $0x0e0c3e0a // mov    w10, v16.s[1]
+	WORD $0x0e903a31 // zip1    v17.2s, v17.2s, v16.2s
+	WORD $0x138a116a // extr    w10, w11, w10, #4
+	WORD $0x2ea74631 // ushl    v17.2s, v17.2s, v7.2s
+	WORD $0x0eb11e50 // orr    v16.8b, v18.8b, v17.8b
+	WORD $0x4e141d50 // mov    v16.s[2], w10
+	WORD $0x53027d6a // lsr    w10, w11, #2
+	WORD $0x4e1c1d50 // mov    v16.s[3], w10
+	WORD $0x6f067410 // bic    v16.4s, #192, lsl #24
+	WORD $0x3d800d10 // str    q16, [x8, #48]
+	WORD $0x91020108 // add    x8, x8, #128
+	BNE LBB0_150
+	JMP LBB0_156
+
+LBB0_151:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_0
+	// WORD $0x90000009 // adrp    x9, .LCPI0_1
+	// WORD $0x9000000a // adrp    x10, .LCPI0_2
+	// WORD $0x9000000b // adrp    x11, .LCPI0_3
+	WORD $0x5280020c // mov    w12, #16
+	VMOVQ LCPI0_0L, LCPI0_0H, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_4
+	VMOVQ LCPI0_1L, LCPI0_1H, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_5
+	VMOVQ LCPI0_2L, LCPI0_2H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_6
+	VMOVQ LCPI0_3L, LCPI0_3H, V3
+	// WORD $0x9000000b // adrp    x11, .LCPI0_7
+	VMOVQ LCPI0_4L, LCPI0_4H, V4
+	WORD $0x927c6e68 // and    x8, x19, #0xfffffff0
+	VMOVQ LCPI0_5L, LCPI0_5H, V5
+	WORD $0xaa0803e9 // mov    x9, x8
+	VMOVQ LCPI0_6L, LCPI0_6H, V6
+	WORD $0x4e080d90 // dup    v16.2d, x12
+	VMOVQ LCPI0_7L, LCPI0_7H, V7
+
+LBB0_152:
+	WORD $0x4f4554f1 // shl    v17.2d, v7.2d, #5
+	WORD $0xf1004129 // subs    x9, x9, #16
+	WORD $0x4f4554d2 // shl    v18.2d, v6.2d, #5
+	WORD $0x4f4554b3 // shl    v19.2d, v5.2d, #5
+	WORD $0x4f455494 // shl    v20.2d, v4.2d, #5
+	WORD $0x4e183e2d // mov    x13, v17.d[1]
+	WORD $0x9e66022a // fmov    x10, d17
+	WORD $0x4e183e4e // mov    x14, v18.d[1]
+	WORD $0x9e66026f // fmov    x15, d19
+	WORD $0x4e183e70 // mov    x16, v19.d[1]
+	WORD $0x4f455471 // shl    v17.2d, v3.2d, #5
+	WORD $0x8b0a0b4c // add    x12, x26, x10, lsl #2
+	WORD $0x9e660280 // fmov    x0, d20
+	WORD $0x8b0f0b4a // add    x10, x26, x15, lsl #2
+	WORD $0x4f455453 // shl    v19.2d, v2.2d, #5
+	WORD $0x9e66024b // fmov    x11, d18
+	WORD $0x8b0d0b51 // add    x17, x26, x13, lsl #2
+	WORD $0x8b0e0b4f // add    x15, x26, x14, lsl #2
+	WORD $0x4f455412 // shl    v18.2d, v0.2d, #5
+	WORD $0x8b100b4d // add    x13, x26, x16, lsl #2
+	WORD $0x8b000b4e // add    x14, x26, x0, lsl #2
+	WORD $0x9e660230 // fmov    x16, d17
+	WORD $0x4e183e20 // mov    x0, v17.d[1]
+	WORD $0x9e660263 // fmov    x3, d19
+	WORD $0x4f455431 // shl    v17.2d, v1.2d, #5
+	WORD $0x8b0b0b4b // add    x11, x26, x11, lsl #2
+	WORD $0x4e183e92 // mov    x18, v20.d[1]
+	WORD $0x8b100b50 // add    x16, x26, x16, lsl #2
+	WORD $0x4e183e62 // mov    x2, v19.d[1]
+	WORD $0x8b030b54 // add    x20, x26, x3, lsl #2
+	WORD $0x4e183e46 // mov    x6, v18.d[1]
+	WORD $0x8b000b40 // add    x0, x26, x0, lsl #2
+	WORD $0x4e183e23 // mov    x3, v17.d[1]
+	WORD $0xb900019f // str    wzr, [x12]
+	WORD $0x9e660225 // fmov    x5, d17
+	WORD $0x8b120b52 // add    x18, x26, x18, lsl #2
+	WORD $0x9e660247 // fmov    x7, d18
+	WORD $0x8b020b44 // add    x4, x26, x2, lsl #2
+	WORD $0x4ef084a5 // add    v5.2d, v5.2d, v16.2d
+	WORD $0x8b060b46 // add    x6, x26, x6, lsl #2
+	WORD $0x4ef084c6 // add    v6.2d, v6.2d, v16.2d
+	WORD $0x8b050b45 // add    x5, x26, x5, lsl #2
+	WORD $0x4ef084e7 // add    v7.2d, v7.2d, v16.2d
+	WORD $0x8b030b42 // add    x2, x26, x3, lsl #2
+	WORD $0x4ef08484 // add    v4.2d, v4.2d, v16.2d
+	WORD $0x8b070b43 // add    x3, x26, x7, lsl #2
+	WORD $0x4ef08463 // add    v3.2d, v3.2d, v16.2d
+	WORD $0xb900023f // str    wzr, [x17]
+	WORD $0x4ef08442 // add    v2.2d, v2.2d, v16.2d
+	WORD $0xb900017f // str    wzr, [x11]
+	WORD $0x4ef08421 // add    v1.2d, v1.2d, v16.2d
+	WORD $0xb90001ff // str    wzr, [x15]
+	WORD $0x4ef08400 // add    v0.2d, v0.2d, v16.2d
+	WORD $0xb900015f // str    wzr, [x10]
+	WORD $0xb90001bf // str    wzr, [x13]
+	WORD $0xb90001df // str    wzr, [x14]
+	WORD $0xb900025f // str    wzr, [x18]
+	WORD $0xb900021f // str    wzr, [x16]
+	WORD $0xb900001f // str    wzr, [x0]
+	WORD $0xb900029f // str    wzr, [x20]
+	WORD $0xb900009f // str    wzr, [x4]
+	WORD $0xb90000bf // str    wzr, [x5]
+	WORD $0xb900005f // str    wzr, [x2]
+	WORD $0xb900007f // str    wzr, [x3]
+	WORD $0xb90000df // str    wzr, [x6]
+	WORD $0xb900059f // str    wzr, [x12, #4]
+	WORD $0xb900063f // str    wzr, [x17, #4]
+	WORD $0xb900057f // str    wzr, [x11, #4]
+	WORD $0xb90005ff // str    wzr, [x15, #4]
+	WORD $0xb900055f // str    wzr, [x10, #4]
+	WORD $0xb90005bf // str    wzr, [x13, #4]
+	WORD $0xb90005df // str    wzr, [x14, #4]
+	WORD $0xb900065f // str    wzr, [x18, #4]
+	WORD $0xb900061f // str    wzr, [x16, #4]
+	WORD $0xb900041f // str    wzr, [x0, #4]
+	WORD $0xb900069f // str    wzr, [x20, #4]
+	WORD $0xb900049f // str    wzr, [x4, #4]
+	WORD $0xb90004bf // str    wzr, [x5, #4]
+	WORD $0xb900045f // str    wzr, [x2, #4]
+	WORD $0xb900047f // str    wzr, [x3, #4]
+	WORD $0xb90004df // str    wzr, [x6, #4]
+	WORD $0xb900099f // str    wzr, [x12, #8]
+	WORD $0xb9000a3f // str    wzr, [x17, #8]
+	WORD $0xb900097f // str    wzr, [x11, #8]
+	WORD $0xb90009ff // str    wzr, [x15, #8]
+	WORD $0xb900095f // str    wzr, [x10, #8]
+	WORD $0xb90009bf // str    wzr, [x13, #8]
+	WORD $0xb90009df // str    wzr, [x14, #8]
+	WORD $0xb9000a5f // str    wzr, [x18, #8]
+	WORD $0xb9000a1f // str    wzr, [x16, #8]
+	WORD $0xb900081f // str    wzr, [x0, #8]
+	WORD $0xb9000a9f // str    wzr, [x20, #8]
+	WORD $0xb900089f // str    wzr, [x4, #8]
+	WORD $0xb90008bf // str    wzr, [x5, #8]
+	WORD $0xb900085f // str    wzr, [x2, #8]
+	WORD $0xb900087f // str    wzr, [x3, #8]
+	WORD $0xb90008df // str    wzr, [x6, #8]
+	WORD $0xb9000d9f // str    wzr, [x12, #12]
+	WORD $0xb9000e3f // str    wzr, [x17, #12]
+	WORD $0xb9000d7f // str    wzr, [x11, #12]
+	WORD $0xb9000dff // str    wzr, [x15, #12]
+	WORD $0xb9000d5f // str    wzr, [x10, #12]
+	WORD $0xb9000dbf // str    wzr, [x13, #12]
+	WORD $0xb9000ddf // str    wzr, [x14, #12]
+	WORD $0xb9000e5f // str    wzr, [x18, #12]
+	WORD $0xb9000e1f // str    wzr, [x16, #12]
+	WORD $0xb9000c1f // str    wzr, [x0, #12]
+	WORD $0xb9000e9f // str    wzr, [x20, #12]
+	WORD $0xb9000c9f // str    wzr, [x4, #12]
+	WORD $0xb9000cbf // str    wzr, [x5, #12]
+	WORD $0xb9000c5f // str    wzr, [x2, #12]
+	WORD $0xb9000c7f // str    wzr, [x3, #12]
+	WORD $0xb9000cdf // str    wzr, [x6, #12]
+	WORD $0xb900119f // str    wzr, [x12, #16]
+	WORD $0xb900123f // str    wzr, [x17, #16]
+	WORD $0xb900117f // str    wzr, [x11, #16]
+	WORD $0xb90011ff // str    wzr, [x15, #16]
+	WORD $0xb900115f // str    wzr, [x10, #16]
+	WORD $0xb90011bf // str    wzr, [x13, #16]
+	WORD $0xb90011df // str    wzr, [x14, #16]
+	WORD $0xb900125f // str    wzr, [x18, #16]
+	WORD $0xb900121f // str    wzr, [x16, #16]
+	WORD $0xb900101f // str    wzr, [x0, #16]
+	WORD $0xb900129f // str    wzr, [x20, #16]
+	WORD $0xb900109f // str    wzr, [x4, #16]
+	WORD $0xb90010bf // str    wzr, [x5, #16]
+	WORD $0xb900105f // str    wzr, [x2, #16]
+	WORD $0xb900107f // str    wzr, [x3, #16]
+	WORD $0xb90010df // str    wzr, [x6, #16]
+	WORD $0xb900159f // str    wzr, [x12, #20]
+	WORD $0xb900163f // str    wzr, [x17, #20]
+	WORD $0xb900157f // str    wzr, [x11, #20]
+	WORD $0xb90015ff // str    wzr, [x15, #20]
+	WORD $0xb900155f // str    wzr, [x10, #20]
+	WORD $0xb90015bf // str    wzr, [x13, #20]
+	WORD $0xb90015df // str    wzr, [x14, #20]
+	WORD $0xb900165f // str    wzr, [x18, #20]
+	WORD $0xb900161f // str    wzr, [x16, #20]
+	WORD $0xb900141f // str    wzr, [x0, #20]
+	WORD $0xb900169f // str    wzr, [x20, #20]
+	WORD $0xb900149f // str    wzr, [x4, #20]
+	WORD $0xb90014bf // str    wzr, [x5, #20]
+	WORD $0xb900145f // str    wzr, [x2, #20]
+	WORD $0xb900147f // str    wzr, [x3, #20]
+	WORD $0xb90014df // str    wzr, [x6, #20]
+	WORD $0xb900199f // str    wzr, [x12, #24]
+	WORD $0xb9001a3f // str    wzr, [x17, #24]
+	WORD $0xb900197f // str    wzr, [x11, #24]
+	WORD $0xb90019ff // str    wzr, [x15, #24]
+	WORD $0xb900195f // str    wzr, [x10, #24]
+	WORD $0xb90019bf // str    wzr, [x13, #24]
+	WORD $0xb90019df // str    wzr, [x14, #24]
+	WORD $0xb9001a5f // str    wzr, [x18, #24]
+	WORD $0xb9001a1f // str    wzr, [x16, #24]
+	WORD $0xb900181f // str    wzr, [x0, #24]
+	WORD $0xb9001a9f // str    wzr, [x20, #24]
+	WORD $0xb900189f // str    wzr, [x4, #24]
+	WORD $0xb90018bf // str    wzr, [x5, #24]
+	WORD $0xb900185f // str    wzr, [x2, #24]
+	WORD $0xb900187f // str    wzr, [x3, #24]
+	WORD $0xb90018df // str    wzr, [x6, #24]
+	WORD $0xb9001d9f // str    wzr, [x12, #28]
+	WORD $0xb9001e3f // str    wzr, [x17, #28]
+	WORD $0xb9001d7f // str    wzr, [x11, #28]
+	WORD $0xb9001dff // str    wzr, [x15, #28]
+	WORD $0xb9001d5f // str    wzr, [x10, #28]
+	WORD $0xb9001dbf // str    wzr, [x13, #28]
+	WORD $0xb9001ddf // str    wzr, [x14, #28]
+	WORD $0xb9001e5f // str    wzr, [x18, #28]
+	WORD $0xb9001e1f // str    wzr, [x16, #28]
+	WORD $0xb9001c1f // str    wzr, [x0, #28]
+	WORD $0xb9001e9f // str    wzr, [x20, #28]
+	WORD $0xb9001c9f // str    wzr, [x4, #28]
+	WORD $0xb9001cbf // str    wzr, [x5, #28]
+	WORD $0xb9001c5f // str    wzr, [x2, #28]
+	WORD $0xb9001c7f // str    wzr, [x3, #28]
+	WORD $0xb9001cdf // str    wzr, [x6, #28]
+	WORD $0xb900219f // str    wzr, [x12, #32]
+	WORD $0xb900223f // str    wzr, [x17, #32]
+	WORD $0xb900217f // str    wzr, [x11, #32]
+	WORD $0xb90021ff // str    wzr, [x15, #32]
+	WORD $0xb900215f // str    wzr, [x10, #32]
+	WORD $0xb90021bf // str    wzr, [x13, #32]
+	WORD $0xb90021df // str    wzr, [x14, #32]
+	WORD $0xb900225f // str    wzr, [x18, #32]
+	WORD $0xb900221f // str    wzr, [x16, #32]
+	WORD $0xb900201f // str    wzr, [x0, #32]
+	WORD $0xb900229f // str    wzr, [x20, #32]
+	WORD $0xb900209f // str    wzr, [x4, #32]
+	WORD $0xb90020bf // str    wzr, [x5, #32]
+	WORD $0xb900205f // str    wzr, [x2, #32]
+	WORD $0xb900207f // str    wzr, [x3, #32]
+	WORD $0xb90020df // str    wzr, [x6, #32]
+	WORD $0xb900259f // str    wzr, [x12, #36]
+	WORD $0xb900263f // str    wzr, [x17, #36]
+	WORD $0xb900257f // str    wzr, [x11, #36]
+	WORD $0xb90025ff // str    wzr, [x15, #36]
+	WORD $0xb900255f // str    wzr, [x10, #36]
+	WORD $0xb90025bf // str    wzr, [x13, #36]
+	WORD $0xb90025df // str    wzr, [x14, #36]
+	WORD $0xb900265f // str    wzr, [x18, #36]
+	WORD $0xb900261f // str    wzr, [x16, #36]
+	WORD $0xb900241f // str    wzr, [x0, #36]
+	WORD $0xb900269f // str    wzr, [x20, #36]
+	WORD $0xb900249f // str    wzr, [x4, #36]
+	WORD $0xb90024bf // str    wzr, [x5, #36]
+	WORD $0xb900245f // str    wzr, [x2, #36]
+	WORD $0xb900247f // str    wzr, [x3, #36]
+	WORD $0xb90024df // str    wzr, [x6, #36]
+	WORD $0xb900299f // str    wzr, [x12, #40]
+	WORD $0xb9002a3f // str    wzr, [x17, #40]
+	WORD $0xb900297f // str    wzr, [x11, #40]
+	WORD $0xb90029ff // str    wzr, [x15, #40]
+	WORD $0xb900295f // str    wzr, [x10, #40]
+	WORD $0xb90029bf // str    wzr, [x13, #40]
+	WORD $0xb90029df // str    wzr, [x14, #40]
+	WORD $0xb9002a5f // str    wzr, [x18, #40]
+	WORD $0xb9002a1f // str    wzr, [x16, #40]
+	WORD $0xb900281f // str    wzr, [x0, #40]
+	WORD $0xb9002a9f // str    wzr, [x20, #40]
+	WORD $0xb900289f // str    wzr, [x4, #40]
+	WORD $0xb90028bf // str    wzr, [x5, #40]
+	WORD $0xb900285f // str    wzr, [x2, #40]
+	WORD $0xb900287f // str    wzr, [x3, #40]
+	WORD $0xb90028df // str    wzr, [x6, #40]
+	WORD $0xb9002d9f // str    wzr, [x12, #44]
+	WORD $0xb9002e3f // str    wzr, [x17, #44]
+	WORD $0xb9002d7f // str    wzr, [x11, #44]
+	WORD $0xb9002dff // str    wzr, [x15, #44]
+	WORD $0xb9002d5f // str    wzr, [x10, #44]
+	WORD $0xb9002dbf // str    wzr, [x13, #44]
+	WORD $0xb9002ddf // str    wzr, [x14, #44]
+	WORD $0xb9002e5f // str    wzr, [x18, #44]
+	WORD $0xb9002e1f // str    wzr, [x16, #44]
+	WORD $0xb9002c1f // str    wzr, [x0, #44]
+	WORD $0xb9002e9f // str    wzr, [x20, #44]
+	WORD $0xb9002c9f // str    wzr, [x4, #44]
+	WORD $0xb9002cbf // str    wzr, [x5, #44]
+	WORD $0xb9002c5f // str    wzr, [x2, #44]
+	WORD $0xb9002c7f // str    wzr, [x3, #44]
+	WORD $0xb9002cdf // str    wzr, [x6, #44]
+	WORD $0xb900319f // str    wzr, [x12, #48]
+	WORD $0xb900323f // str    wzr, [x17, #48]
+	WORD $0xb900317f // str    wzr, [x11, #48]
+	WORD $0xb90031ff // str    wzr, [x15, #48]
+	WORD $0xb900315f // str    wzr, [x10, #48]
+	WORD $0xb90031bf // str    wzr, [x13, #48]
+	WORD $0xb90031df // str    wzr, [x14, #48]
+	WORD $0xb900325f // str    wzr, [x18, #48]
+	WORD $0xb900321f // str    wzr, [x16, #48]
+	WORD $0xb900301f // str    wzr, [x0, #48]
+	WORD $0xb900329f // str    wzr, [x20, #48]
+	WORD $0xb900309f // str    wzr, [x4, #48]
+	WORD $0xb90030bf // str    wzr, [x5, #48]
+	WORD $0xb900305f // str    wzr, [x2, #48]
+	WORD $0xb900307f // str    wzr, [x3, #48]
+	WORD $0xb90030df // str    wzr, [x6, #48]
+	WORD $0xb900359f // str    wzr, [x12, #52]
+	WORD $0xb900363f // str    wzr, [x17, #52]
+	WORD $0xb900357f // str    wzr, [x11, #52]
+	WORD $0xb90035ff // str    wzr, [x15, #52]
+	WORD $0xb900355f // str    wzr, [x10, #52]
+	WORD $0xb90035bf // str    wzr, [x13, #52]
+	WORD $0xb90035df // str    wzr, [x14, #52]
+	WORD $0xb900365f // str    wzr, [x18, #52]
+	WORD $0xb900361f // str    wzr, [x16, #52]
+	WORD $0xb900341f // str    wzr, [x0, #52]
+	WORD $0xb900369f // str    wzr, [x20, #52]
+	WORD $0xb900349f // str    wzr, [x4, #52]
+	WORD $0xb90034bf // str    wzr, [x5, #52]
+	WORD $0xb900345f // str    wzr, [x2, #52]
+	WORD $0xb900347f // str    wzr, [x3, #52]
+	WORD $0xb90034df // str    wzr, [x6, #52]
+	WORD $0xb900399f // str    wzr, [x12, #56]
+	WORD $0xb9003a3f // str    wzr, [x17, #56]
+	WORD $0xb900397f // str    wzr, [x11, #56]
+	WORD $0xb90039ff // str    wzr, [x15, #56]
+	WORD $0xb900395f // str    wzr, [x10, #56]
+	WORD $0xb90039bf // str    wzr, [x13, #56]
+	WORD $0xb90039df // str    wzr, [x14, #56]
+	WORD $0xb9003a5f // str    wzr, [x18, #56]
+	WORD $0xb9003a1f // str    wzr, [x16, #56]
+	WORD $0xb900381f // str    wzr, [x0, #56]
+	WORD $0xb9003a9f // str    wzr, [x20, #56]
+	WORD $0xb900389f // str    wzr, [x4, #56]
+	WORD $0xb90038bf // str    wzr, [x5, #56]
+	WORD $0xb900385f // str    wzr, [x2, #56]
+	WORD $0xb900387f // str    wzr, [x3, #56]
+	WORD $0xb90038df // str    wzr, [x6, #56]
+	WORD $0xb9003d9f // str    wzr, [x12, #60]
+	WORD $0xb9003e3f // str    wzr, [x17, #60]
+	WORD $0xb9003d7f // str    wzr, [x11, #60]
+	WORD $0xb9003dff // str    wzr, [x15, #60]
+	WORD $0xb9003d5f // str    wzr, [x10, #60]
+	WORD $0xb9003dbf // str    wzr, [x13, #60]
+	WORD $0xb9003ddf // str    wzr, [x14, #60]
+	WORD $0xb9003e5f // str    wzr, [x18, #60]
+	WORD $0xb9003e1f // str    wzr, [x16, #60]
+	WORD $0xb9003c1f // str    wzr, [x0, #60]
+	WORD $0xb9003e9f // str    wzr, [x20, #60]
+	WORD $0xb9003c9f // str    wzr, [x4, #60]
+	WORD $0xb9003cbf // str    wzr, [x5, #60]
+	WORD $0xb9003c5f // str    wzr, [x2, #60]
+	WORD $0xb9003c7f // str    wzr, [x3, #60]
+	WORD $0xb9003cdf // str    wzr, [x6, #60]
+	WORD $0xb900419f // str    wzr, [x12, #64]
+	WORD $0xb900423f // str    wzr, [x17, #64]
+	WORD $0xb900417f // str    wzr, [x11, #64]
+	WORD $0xb90041ff // str    wzr, [x15, #64]
+	WORD $0xb900415f // str    wzr, [x10, #64]
+	WORD $0xb90041bf // str    wzr, [x13, #64]
+	WORD $0xb90041df // str    wzr, [x14, #64]
+	WORD $0xb900425f // str    wzr, [x18, #64]
+	WORD $0xb900421f // str    wzr, [x16, #64]
+	WORD $0xb900401f // str    wzr, [x0, #64]
+	WORD $0xb900429f // str    wzr, [x20, #64]
+	WORD $0xb900409f // str    wzr, [x4, #64]
+	WORD $0xb90040bf // str    wzr, [x5, #64]
+	WORD $0xb900405f // str    wzr, [x2, #64]
+	WORD $0xb900407f // str    wzr, [x3, #64]
+	WORD $0xb90040df // str    wzr, [x6, #64]
+	WORD $0xb900459f // str    wzr, [x12, #68]
+	WORD $0xb900463f // str    wzr, [x17, #68]
+	WORD $0xb900457f // str    wzr, [x11, #68]
+	WORD $0xb90045ff // str    wzr, [x15, #68]
+	WORD $0xb900455f // str    wzr, [x10, #68]
+	WORD $0xb90045bf // str    wzr, [x13, #68]
+	WORD $0xb90045df // str    wzr, [x14, #68]
+	WORD $0xb900465f // str    wzr, [x18, #68]
+	WORD $0xb900461f // str    wzr, [x16, #68]
+	WORD $0xb900441f // str    wzr, [x0, #68]
+	WORD $0xb900469f // str    wzr, [x20, #68]
+	WORD $0xb900449f // str    wzr, [x4, #68]
+	WORD $0xb90044bf // str    wzr, [x5, #68]
+	WORD $0xb900445f // str    wzr, [x2, #68]
+	WORD $0xb900447f // str    wzr, [x3, #68]
+	WORD $0xb90044df // str    wzr, [x6, #68]
+	WORD $0xb900499f // str    wzr, [x12, #72]
+	WORD $0xb9004a3f // str    wzr, [x17, #72]
+	WORD $0xb900497f // str    wzr, [x11, #72]
+	WORD $0xb90049ff // str    wzr, [x15, #72]
+	WORD $0xb900495f // str    wzr, [x10, #72]
+	WORD $0xb90049bf // str    wzr, [x13, #72]
+	WORD $0xb90049df // str    wzr, [x14, #72]
+	WORD $0xb9004a5f // str    wzr, [x18, #72]
+	WORD $0xb9004a1f // str    wzr, [x16, #72]
+	WORD $0xb900481f // str    wzr, [x0, #72]
+	WORD $0xb9004a9f // str    wzr, [x20, #72]
+	WORD $0xb900489f // str    wzr, [x4, #72]
+	WORD $0xb90048bf // str    wzr, [x5, #72]
+	WORD $0xb900485f // str    wzr, [x2, #72]
+	WORD $0xb900487f // str    wzr, [x3, #72]
+	WORD $0xb90048df // str    wzr, [x6, #72]
+	WORD $0xb9004d9f // str    wzr, [x12, #76]
+	WORD $0xb9004e3f // str    wzr, [x17, #76]
+	WORD $0xb9004d7f // str    wzr, [x11, #76]
+	WORD $0xb9004dff // str    wzr, [x15, #76]
+	WORD $0xb9004d5f // str    wzr, [x10, #76]
+	WORD $0xb9004dbf // str    wzr, [x13, #76]
+	WORD $0xb9004ddf // str    wzr, [x14, #76]
+	WORD $0xb9004e5f // str    wzr, [x18, #76]
+	WORD $0xb9004e1f // str    wzr, [x16, #76]
+	WORD $0xb9004c1f // str    wzr, [x0, #76]
+	WORD $0xb9004e9f // str    wzr, [x20, #76]
+	WORD $0xb9004c9f // str    wzr, [x4, #76]
+	WORD $0xb9004cbf // str    wzr, [x5, #76]
+	WORD $0xb9004c5f // str    wzr, [x2, #76]
+	WORD $0xb9004c7f // str    wzr, [x3, #76]
+	WORD $0xb9004cdf // str    wzr, [x6, #76]
+	WORD $0xb900519f // str    wzr, [x12, #80]
+	WORD $0xb900523f // str    wzr, [x17, #80]
+	WORD $0xb900517f // str    wzr, [x11, #80]
+	WORD $0xb90051ff // str    wzr, [x15, #80]
+	WORD $0xb900515f // str    wzr, [x10, #80]
+	WORD $0xb90051bf // str    wzr, [x13, #80]
+	WORD $0xb90051df // str    wzr, [x14, #80]
+	WORD $0xb900525f // str    wzr, [x18, #80]
+	WORD $0xb900521f // str    wzr, [x16, #80]
+	WORD $0xb900501f // str    wzr, [x0, #80]
+	WORD $0xb900529f // str    wzr, [x20, #80]
+	WORD $0xb900509f // str    wzr, [x4, #80]
+	WORD $0xb90050bf // str    wzr, [x5, #80]
+	WORD $0xb900505f // str    wzr, [x2, #80]
+	WORD $0xb900507f // str    wzr, [x3, #80]
+	WORD $0xb90050df // str    wzr, [x6, #80]
+	WORD $0xb900559f // str    wzr, [x12, #84]
+	WORD $0xb900563f // str    wzr, [x17, #84]
+	WORD $0xb900557f // str    wzr, [x11, #84]
+	WORD $0xb90055ff // str    wzr, [x15, #84]
+	WORD $0xb900555f // str    wzr, [x10, #84]
+	WORD $0xb90055bf // str    wzr, [x13, #84]
+	WORD $0xb90055df // str    wzr, [x14, #84]
+	WORD $0xb900565f // str    wzr, [x18, #84]
+	WORD $0xb900561f // str    wzr, [x16, #84]
+	WORD $0xb900541f // str    wzr, [x0, #84]
+	WORD $0xb900569f // str    wzr, [x20, #84]
+	WORD $0xb900549f // str    wzr, [x4, #84]
+	WORD $0xb90054bf // str    wzr, [x5, #84]
+	WORD $0xb900545f // str    wzr, [x2, #84]
+	WORD $0xb900547f // str    wzr, [x3, #84]
+	WORD $0xb90054df // str    wzr, [x6, #84]
+	WORD $0xb900599f // str    wzr, [x12, #88]
+	WORD $0xb9005a3f // str    wzr, [x17, #88]
+	WORD $0xb900597f // str    wzr, [x11, #88]
+	WORD $0xb90059ff // str    wzr, [x15, #88]
+	WORD $0xb900595f // str    wzr, [x10, #88]
+	WORD $0xb90059bf // str    wzr, [x13, #88]
+	WORD $0xb90059df // str    wzr, [x14, #88]
+	WORD $0xb9005a5f // str    wzr, [x18, #88]
+	WORD $0xb9005a1f // str    wzr, [x16, #88]
+	WORD $0xb900581f // str    wzr, [x0, #88]
+	WORD $0xb9005a9f // str    wzr, [x20, #88]
+	WORD $0xb900589f // str    wzr, [x4, #88]
+	WORD $0xb90058bf // str    wzr, [x5, #88]
+	WORD $0xb900585f // str    wzr, [x2, #88]
+	WORD $0xb900587f // str    wzr, [x3, #88]
+	WORD $0xb90058df // str    wzr, [x6, #88]
+	WORD $0xb9005d9f // str    wzr, [x12, #92]
+	WORD $0xb9005e3f // str    wzr, [x17, #92]
+	WORD $0xb9005d7f // str    wzr, [x11, #92]
+	WORD $0xb9005dff // str    wzr, [x15, #92]
+	WORD $0xb9005d5f // str    wzr, [x10, #92]
+	WORD $0xb9005dbf // str    wzr, [x13, #92]
+	WORD $0xb9005ddf // str    wzr, [x14, #92]
+	WORD $0xb9005e5f // str    wzr, [x18, #92]
+	WORD $0xb9005e1f // str    wzr, [x16, #92]
+	WORD $0xb9005c1f // str    wzr, [x0, #92]
+	WORD $0xb9005e9f // str    wzr, [x20, #92]
+	WORD $0xb9005c9f // str    wzr, [x4, #92]
+	WORD $0xb9005cbf // str    wzr, [x5, #92]
+	WORD $0xb9005c5f // str    wzr, [x2, #92]
+	WORD $0xb9005c7f // str    wzr, [x3, #92]
+	WORD $0xb9005cdf // str    wzr, [x6, #92]
+	WORD $0xb900619f // str    wzr, [x12, #96]
+	WORD $0xb900623f // str    wzr, [x17, #96]
+	WORD $0xb900617f // str    wzr, [x11, #96]
+	WORD $0xb90061ff // str    wzr, [x15, #96]
+	WORD $0xb900615f // str    wzr, [x10, #96]
+	WORD $0xb90061bf // str    wzr, [x13, #96]
+	WORD $0xb90061df // str    wzr, [x14, #96]
+	WORD $0xb900625f // str    wzr, [x18, #96]
+	WORD $0xb900621f // str    wzr, [x16, #96]
+	WORD $0xb900601f // str    wzr, [x0, #96]
+	WORD $0xb900629f // str    wzr, [x20, #96]
+	WORD $0xb900609f // str    wzr, [x4, #96]
+	WORD $0xb90060bf // str    wzr, [x5, #96]
+	WORD $0xb900605f // str    wzr, [x2, #96]
+	WORD $0xb900607f // str    wzr, [x3, #96]
+	WORD $0xb90060df // str    wzr, [x6, #96]
+	WORD $0xb900659f // str    wzr, [x12, #100]
+	WORD $0xb900663f // str    wzr, [x17, #100]
+	WORD $0xb900657f // str    wzr, [x11, #100]
+	WORD $0xb90065ff // str    wzr, [x15, #100]
+	WORD $0xb900655f // str    wzr, [x10, #100]
+	WORD $0xb90065bf // str    wzr, [x13, #100]
+	WORD $0xb90065df // str    wzr, [x14, #100]
+	WORD $0xb900665f // str    wzr, [x18, #100]
+	WORD $0xb900661f // str    wzr, [x16, #100]
+	WORD $0xb900641f // str    wzr, [x0, #100]
+	WORD $0xb900669f // str    wzr, [x20, #100]
+	WORD $0xb900649f // str    wzr, [x4, #100]
+	WORD $0xb90064bf // str    wzr, [x5, #100]
+	WORD $0xb900645f // str    wzr, [x2, #100]
+	WORD $0xb900647f // str    wzr, [x3, #100]
+	WORD $0xb90064df // str    wzr, [x6, #100]
+	WORD $0xb900699f // str    wzr, [x12, #104]
+	WORD $0xb9006a3f // str    wzr, [x17, #104]
+	WORD $0xb900697f // str    wzr, [x11, #104]
+	WORD $0xb90069ff // str    wzr, [x15, #104]
+	WORD $0xb900695f // str    wzr, [x10, #104]
+	WORD $0xb90069bf // str    wzr, [x13, #104]
+	WORD $0xb90069df // str    wzr, [x14, #104]
+	WORD $0xb9006a5f // str    wzr, [x18, #104]
+	WORD $0xb9006a1f // str    wzr, [x16, #104]
+	WORD $0xb900681f // str    wzr, [x0, #104]
+	WORD $0xb9006a9f // str    wzr, [x20, #104]
+	WORD $0xb900689f // str    wzr, [x4, #104]
+	WORD $0xb90068bf // str    wzr, [x5, #104]
+	WORD $0xb900685f // str    wzr, [x2, #104]
+	WORD $0xb900687f // str    wzr, [x3, #104]
+	WORD $0xb90068df // str    wzr, [x6, #104]
+	WORD $0xb9006d9f // str    wzr, [x12, #108]
+	WORD $0xb9006e3f // str    wzr, [x17, #108]
+	WORD $0xb9006d7f // str    wzr, [x11, #108]
+	WORD $0xb9006dff // str    wzr, [x15, #108]
+	WORD $0xb9006d5f // str    wzr, [x10, #108]
+	WORD $0xb9006dbf // str    wzr, [x13, #108]
+	WORD $0xb9006ddf // str    wzr, [x14, #108]
+	WORD $0xb9006e5f // str    wzr, [x18, #108]
+	WORD $0xb9006e1f // str    wzr, [x16, #108]
+	WORD $0xb9006c1f // str    wzr, [x0, #108]
+	WORD $0xb9006e9f // str    wzr, [x20, #108]
+	WORD $0xb9006c9f // str    wzr, [x4, #108]
+	WORD $0xb9006cbf // str    wzr, [x5, #108]
+	WORD $0xb9006c5f // str    wzr, [x2, #108]
+	WORD $0xb9006c7f // str    wzr, [x3, #108]
+	WORD $0xb9006cdf // str    wzr, [x6, #108]
+	WORD $0xb900719f // str    wzr, [x12, #112]
+	WORD $0xb900723f // str    wzr, [x17, #112]
+	WORD $0xb900717f // str    wzr, [x11, #112]
+	WORD $0xb90071ff // str    wzr, [x15, #112]
+	WORD $0xb900715f // str    wzr, [x10, #112]
+	WORD $0xb90071bf // str    wzr, [x13, #112]
+	WORD $0xb90071df // str    wzr, [x14, #112]
+	WORD $0xb900725f // str    wzr, [x18, #112]
+	WORD $0xb900721f // str    wzr, [x16, #112]
+	WORD $0xb900701f // str    wzr, [x0, #112]
+	WORD $0xb900729f // str    wzr, [x20, #112]
+	WORD $0xb900709f // str    wzr, [x4, #112]
+	WORD $0xb90070bf // str    wzr, [x5, #112]
+	WORD $0xb900705f // str    wzr, [x2, #112]
+	WORD $0xb900707f // str    wzr, [x3, #112]
+	WORD $0xb90070df // str    wzr, [x6, #112]
+	WORD $0xb900759f // str    wzr, [x12, #116]
+	WORD $0xb900763f // str    wzr, [x17, #116]
+	WORD $0xb900757f // str    wzr, [x11, #116]
+	WORD $0xb90075ff // str    wzr, [x15, #116]
+	WORD $0xb900755f // str    wzr, [x10, #116]
+	WORD $0xb90075bf // str    wzr, [x13, #116]
+	WORD $0xb90075df // str    wzr, [x14, #116]
+	WORD $0xb900765f // str    wzr, [x18, #116]
+	WORD $0xb900761f // str    wzr, [x16, #116]
+	WORD $0xb900741f // str    wzr, [x0, #116]
+	WORD $0xb900769f // str    wzr, [x20, #116]
+	WORD $0xb900749f // str    wzr, [x4, #116]
+	WORD $0xb90074bf // str    wzr, [x5, #116]
+	WORD $0xb900745f // str    wzr, [x2, #116]
+	WORD $0xb900747f // str    wzr, [x3, #116]
+	WORD $0xb90074df // str    wzr, [x6, #116]
+	WORD $0xb900799f // str    wzr, [x12, #120]
+	WORD $0xb9007a3f // str    wzr, [x17, #120]
+	WORD $0xb900797f // str    wzr, [x11, #120]
+	WORD $0xb90079ff // str    wzr, [x15, #120]
+	WORD $0xb900795f // str    wzr, [x10, #120]
+	WORD $0xb90079bf // str    wzr, [x13, #120]
+	WORD $0xb90079df // str    wzr, [x14, #120]
+	WORD $0xb9007a5f // str    wzr, [x18, #120]
+	WORD $0xb9007a1f // str    wzr, [x16, #120]
+	WORD $0xb900781f // str    wzr, [x0, #120]
+	WORD $0xb9007a9f // str    wzr, [x20, #120]
+	WORD $0xb900789f // str    wzr, [x4, #120]
+	WORD $0xb90078bf // str    wzr, [x5, #120]
+	WORD $0xb900785f // str    wzr, [x2, #120]
+	WORD $0xb900787f // str    wzr, [x3, #120]
+	WORD $0xb90078df // str    wzr, [x6, #120]
+	WORD $0xb9007d9f // str    wzr, [x12, #124]
+	WORD $0xb9007e3f // str    wzr, [x17, #124]
+	WORD $0xb9007d7f // str    wzr, [x11, #124]
+	WORD $0xb9007dff // str    wzr, [x15, #124]
+	WORD $0xb9007d5f // str    wzr, [x10, #124]
+	WORD $0xb9007dbf // str    wzr, [x13, #124]
+	WORD $0xb9007ddf // str    wzr, [x14, #124]
+	WORD $0xb9007e5f // str    wzr, [x18, #124]
+	WORD $0xb9007e1f // str    wzr, [x16, #124]
+	WORD $0xb9007c1f // str    wzr, [x0, #124]
+	WORD $0xb9007e9f // str    wzr, [x20, #124]
+	WORD $0xb9007c9f // str    wzr, [x4, #124]
+	WORD $0xb9007cbf // str    wzr, [x5, #124]
+	WORD $0xb9007c5f // str    wzr, [x2, #124]
+	WORD $0xb9007c7f // str    wzr, [x3, #124]
+	WORD $0xb9007cdf // str    wzr, [x6, #124]
+	BNE LBB0_152
+
+	// %bb.153:
+	WORD $0xeb13011f // cmp    x8, x19
+	BEQ LBB0_156
+
+LBB0_154:
+	WORD $0x8b081f49 // add    x9, x26, x8, lsl #7
+	WORD $0xcb080268 // sub    x8, x19, x8
+	WORD $0x6f00e400 // movi    v0.2d, #0000000000000000
+	WORD $0x91010129 // add    x9, x9, #64
+
+LBB0_155:
+	WORD $0xad3e0120 // stp    q0, q0, [x9, #-64]
+	WORD $0xf1000508 // subs    x8, x8, #1
+	WORD $0xad3f0120 // stp    q0, q0, [x9, #-32]
+	WORD $0xad000120 // stp    q0, q0, [x9]
+	WORD $0xad010120 // stp    q0, q0, [x9, #32]
+	WORD $0x91020129 // add    x9, x9, #128
+	BNE LBB0_155
+
+LBB0_157:
+	// WORD $0x90000008 // adrp    x8, .LCPI0_0
+	// WORD $0x90000009 // adrp    x9, .LCPI0_1
+	// WORD $0x9000000a // adrp    x10, .LCPI0_2
+	// WORD $0x9000000b // adrp    x11, .LCPI0_3
+	WORD $0xaa1f03ec // mov    x12, xzr
+	WORD $0xf9000bf3 // str    x19, [sp, #16]
+	VMOVQ LCPI0_0L, LCPI0_0H, V0
+	// WORD $0x90000008 // adrp    x8, .LCPI0_4
+	VMOVQ LCPI0_1L, LCPI0_1H, V1
+	// WORD $0x90000009 // adrp    x9, .LCPI0_5
+	VMOVQ LCPI0_2L, LCPI0_2H, V2
+	// WORD $0x9000000a // adrp    x10, .LCPI0_6
+	VMOVQ LCPI0_4L, LCPI0_4H, V4
+	// WORD $0x90000008 // adrp    x8, .LCPI0_7
+	VMOVQ LCPI0_3L, LCPI0_3H, V3
+	WORD $0x927c6e6b // and    x11, x19, #0xfffffff0
+	VMOVQ LCPI0_5L, LCPI0_5H, V5
+	WORD $0xf90047fa // str    x26, [sp, #136]
+	VMOVQ LCPI0_7L, LCPI0_7H, V7
+	WORD $0x52800208 // mov    w8, #16
+	VMOVQ LCPI0_6L, LCPI0_6H, V6
+	WORD $0x8b0b1c09 // add    x9, x0, x11, lsl #7
+	WORD $0xf9000feb // str    x11, [sp, #24]
+	WORD $0x4e080d10 // dup    v16.2d, x8
+	WORD $0xf90007e9 // str    x9, [sp, #8]
+
+LBB0_158:
+	WORD $0x4f4554f2 // shl    v18.2d, v7.2d, #5
+	WORD $0xd379e188 // lsl    x8, x12, #7
+	WORD $0x4f4554d3 // shl    v19.2d, v6.2d, #5
+	WORD $0xb278010b // orr    x11, x8, #0x100
+	WORD $0x4f4554b4 // shl    v20.2d, v5.2d, #5
+	WORD $0xf90043ec // str    x12, [sp, #128]
+	WORD $0x8b0b0010 // add    x16, x0, x11
+	WORD $0x8b080003 // add    x3, x0, x8
+	WORD $0x4e183e4b // mov    x11, v18.d[1]
+	WORD $0x9e66024c // fmov    x12, d18
+	WORD $0x4f455492 // shl    v18.2d, v4.2d, #5
+	WORD $0xb279010a // orr    x10, x8, #0x80
+	WORD $0x4e183e6d // mov    x13, v19.d[1]
+	WORD $0x8b0a0014 // add    x20, x0, x10
+	WORD $0x8b0c0b49 // add    x9, x26, x12, lsl #2
+	WORD $0x9e66028c // fmov    x12, d20
+	WORD $0x8b0b0b5b // add    x27, x26, x11, lsl #2
+	WORD $0xb279050a // orr    x10, x8, #0x180
+	WORD $0x4e183e8b // mov    x11, v20.d[1]
+	WORD $0x9e66026e // fmov    x14, d19
+	WORD $0x9e66024f // fmov    x15, d18
+	WORD $0x8b0a0013 // add    x19, x0, x10
+	WORD $0xb277010a // orr    x10, x8, #0x200
+	WORD $0x8b0d0b57 // add    x23, x26, x13, lsl #2
+	WORD $0x8b0c0b5c // add    x28, x26, x12, lsl #2
+	WORD $0x8b0a0011 // add    x17, x0, x10
+	WORD $0x2940306d // ldp    w13, w12, [x3]
+	WORD $0x5280500a // mov    w10, #640
+	WORD $0x8b0e0b41 // add    x1, x26, x14, lsl #2
+	WORD $0xaa0a010a // orr    x10, x8, x10
+	WORD $0xf900bbe3 // str    x3, [sp, #368]
+	WORD $0x2940168e // ldp    w14, w5, [x20]
+	WORD $0x8b0b0b43 // add    x3, x26, x11, lsl #2
+	WORD $0x8b0f0b44 // add    x4, x26, x15, lsl #2
+	WORD $0x29403e0b // ldp    w11, w15, [x16]
+	WORD $0x8b0a0006 // add    x6, x0, x10
+	WORD $0xb90057ec // str    w12, [sp, #84]
+	WORD $0x4e183e4c // mov    x12, v18.d[1]
+	WORD $0xb278050a // orr    x10, x8, #0x300
+	WORD $0x8b0a0007 // add    x7, x0, x10
+	WORD $0xb900012d // str    w13, [x9]
+	WORD $0xb900036e // str    w14, [x27]
+	WORD $0xb279090a // orr    x10, x8, #0x380
+	WORD $0xb900002b // str    w11, [x1]
+	WORD $0x29402ccd // ldp    w13, w11, [x6]
+	WORD $0x4f455471 // shl    v17.2d, v3.2d, #5
+	WORD $0xa91453f0 // stp    x16, x20, [sp, #320]
+	WORD $0x290f17ef // stp    w15, w5, [sp, #120]
+	WORD $0x8b0c0b45 // add    x5, x26, x12, lsl #2
+	WORD $0x2940426c // ldp    w12, w16, [x19]
+	WORD $0x8b0a0012 // add    x18, x0, x10
+	WORD $0xf9009ff3 // str    x19, [sp, #312]
+	WORD $0xaa1103f3 // mov    x19, x17
+	WORD $0xa9181ff1 // stp    x17, x7, [sp, #384]
+	WORD $0xb9400231 // ldr    w17, [x17]
+	WORD $0xb90067eb // str    w11, [sp, #100]
+	WORD $0xb276010a // orr    x10, x8, #0x400
+	WORD $0xb94000eb // ldr    w11, [x7]
+	WORD $0x8b0a0002 // add    x2, x0, x10
+	WORD $0xb90077f0 // str    w16, [sp, #116]
+	WORD $0x9e660230 // fmov    x16, d17
+	WORD $0xb90002ec // str    w12, [x23]
+	WORD $0xb94004ee // ldr    w14, [x7, #4]
+	WORD $0xb9000391 // str    w17, [x28]
+	WORD $0x5280900a // mov    w10, #1152
+	WORD $0xb900006d // str    w13, [x3]
+	WORD $0xaa0a010a // orr    x10, x8, x10
+	WORD $0xb900008b // str    w11, [x4]
+	WORD $0x29402e4c // ldp    w12, w11, [x18]
+	WORD $0x4e183e2f // mov    x15, v17.d[1]
+	WORD $0x8b100b4d // add    x13, x26, x16, lsl #2
+	WORD $0xa90c27f7 // stp    x23, x9, [sp, #192]
+	WORD $0x290bbbeb // stp    w11, w14, [sp, #92]
+	WORD $0xb940004b // ldr    w11, [x2]
+	WORD $0x8b0a000e // add    x14, x0, x10
+	WORD $0x5280a00a // mov    w10, #1280
+	WORD $0x4f455451 // shl    v17.2d, v2.2d, #5
+	WORD $0xf9004fed // str    x13, [sp, #152]
+	WORD $0xb90000ac // str    w12, [x5]
+	WORD $0xaa0a010a // orr    x10, x8, x10
+	WORD $0xb90001ab // str    w11, [x13]
+	WORD $0xb9400669 // ldr    w9, [x19, #4]
+	WORD $0x294035cb // ldp    w11, w13, [x14]
+	WORD $0x8b0a0011 // add    x17, x0, x10
+	WORD $0x8b0f0b4c // add    x12, x26, x15, lsl #2
+	WORD $0x9e660230 // fmov    x16, d17
+	WORD $0x5280b00a // mov    w10, #1408
+	WORD $0xaa0a010a // orr    x10, x8, x10
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0xaa0103e9 // mov    x9, x1
+	WORD $0xaa0603e1 // mov    x1, x6
+	WORD $0xa911cbe6 // stp    x6, x18, [sp, #280]
+	WORD $0x8b0a0006 // add    x6, x0, x10
+	WORD $0xf9006fec // str    x12, [sp, #216]
+	WORD $0xb9400452 // ldr    w18, [x2, #4]
+	WORD $0x4e183e2f // mov    x15, v17.d[1]
+	WORD $0xb900018b // str    w11, [x12]
+	WORD $0x4f455431 // shl    v17.2d, v1.2d, #5
+	WORD $0x8b100b4c // add    x12, x26, x16, lsl #2
+	WORD $0x2940422a // ldp    w10, w16, [x17]
+	WORD $0xb277050b // orr    x11, x8, #0x600
+	WORD $0xaa0c03fe // mov    x30, x12
+	WORD $0x8b0b000b // add    x11, x0, x11
+	WORD $0xf90073ec // str    x12, [sp, #224]
+	WORD $0x2909cbed // stp    w13, w18, [sp, #76]
+	WORD $0x8b0f0b4d // add    x13, x26, x15, lsl #2
+	WORD $0xb900018a // str    w10, [x12]
+	WORD $0x9e66022a // fmov    x10, d17
+	WORD $0x294030cf // ldp    w15, w12, [x6]
+	WORD $0xaa0e03f3 // mov    x19, x14
+	WORD $0xf900b3ee // str    x14, [sp, #352]
+	WORD $0x8b0a0b4e // add    x14, x26, x10, lsl #2
+	WORD $0xb940016a // ldr    w10, [x11]
+	WORD $0xb9006bec // str    w12, [sp, #104]
+	WORD $0xaa0b03ec // mov    x12, x11
+	WORD $0x5280d00b // mov    w11, #1664
+	WORD $0xb90001af // str    w15, [x13]
+	WORD $0xaa0d03f9 // mov    x25, x13
+	WORD $0xf9005fed // str    x13, [sp, #184]
+	WORD $0xaa0b010d // orr    x13, x8, x11
+	WORD $0xb90073f0 // str    w16, [sp, #112]
+	WORD $0x8b0d0012 // add    x18, x0, x13
+	WORD $0xb90001ca // str    w10, [x14]
+	WORD $0x4e183e30 // mov    x16, v17.d[1]
+	WORD $0xb278090a // orr    x10, x8, #0x700
+	WORD $0x4f455412 // shl    v18.2d, v0.2d, #5
+	WORD $0xb2790d08 // orr    x8, x8, #0x780
+	WORD $0xf90053e5 // str    x5, [sp, #160]
+	WORD $0xb940058b // ldr    w11, [x12, #4]
+	WORD $0xaa0c03f6 // mov    x22, x12
+	WORD $0xf9009bec // str    x12, [sp, #304]
+	WORD $0x8b08000c // add    x12, x0, x8
+	WORD $0x8b0a0007 // add    x7, x0, x10
+	WORD $0x29401648 // ldp    w8, w5, [x18]
+	WORD $0x8b100b4d // add    x13, x26, x16, lsl #2
+	WORD $0xf90077e3 // str    x3, [sp, #232]
+	WORD $0x9e660243 // fmov    x3, d18
+	WORD $0xf900abe2 // str    x2, [sp, #336]
+	WORD $0x4e183e42 // mov    x2, v18.d[1]
+	WORD $0xb9005beb // str    w11, [sp, #88]
+	WORD $0xf94047eb // ldr    x11, [sp, #136]
+	WORD $0xb90001a8 // str    w8, [x13]
+	WORD $0x294040ea // ldp    w10, w16, [x7]
+	WORD $0xa9103be4 // stp    x4, x14, [sp, #256]
+	WORD $0xb9400588 // ldr    w8, [x12, #4]
+	WORD $0x8b030b4e // add    x14, x26, x3, lsl #2
+	WORD $0xa94c0fe4 // ldp    x4, x3, [sp, #192]
+	WORD $0x8b02096f // add    x15, x11, x2, lsl #2
+	WORD $0x290843e8 // stp    w8, w16, [sp, #64]
+	WORD $0xb940018b // ldr    w11, [x12]
+	WORD $0xb90001ca // str    w10, [x14]
+	WORD $0xb94057e8 // ldr    w8, [sp, #84]
+	WORD $0xf90097f1 // str    x17, [sp, #296]
+	WORD $0xf940a3f1 // ldr    x17, [sp, #320]
+	WORD $0xaa1203f7 // mov    x23, x18
+	WORD $0xb90001eb // str    w11, [x15]
+	WORD $0xf94077eb // ldr    x11, [sp, #232]
+	WORD $0xb9000468 // str    w8, [x3, #4]
+	WORD $0xb9400a88 // ldr    w8, [x20, #8]
+	WORD $0xaa0903f4 // mov    x20, x9
+	WORD $0xf900b7f2 // str    x18, [sp, #360]
+	WORD $0xa9580bf2 // ldp    x18, x2, [sp, #384]
+	WORD $0xb90057e8 // str    w8, [sp, #84]
+	WORD $0xaa0d03f8 // mov    x24, x13
+	WORD $0xb9407fe8 // ldr    w8, [sp, #124]
+	WORD $0xf900bfec // str    x12, [sp, #376]
+	WORD $0xa95243ed // ldp    x13, x16, [sp, #288]
+	WORD $0xaa0f03fa // mov    x26, x15
+	WORD $0xf9006bef // str    x15, [sp, #208]
+	WORD $0xb9000768 // str    w8, [x27, #4]
+	WORD $0xb9400a28 // ldr    w8, [x17, #8]
+	WORD $0xb9400a4a // ldr    w10, [x18, #8]
+	WORD $0xa90f3bfb // stp    x27, x14, [sp, #240]
+	WORD $0xaa0703f5 // mov    x21, x7
+	WORD $0xb9004be8 // str    w8, [sp, #72]
+	WORD $0xb9407be8 // ldr    w8, [sp, #120]
+	WORD $0xf940abee // ldr    x14, [sp, #336]
+	WORD $0xa90ae3f4 // stp    x20, x24, [sp, #168]
+	WORD $0xa9501fec // ldp    x12, x7, [sp, #256]
+	WORD $0xf900aff5 // str    x21, [sp, #344]
+	WORD $0xb9000528 // str    w8, [x9, #4]
+	WORD $0xf9409fe8 // ldr    x8, [sp, #312]
+	WORD $0xf9004bfc // str    x28, [sp, #144]
+	WORD $0xb9400909 // ldr    w9, [x8, #8]
+	WORD $0x4ef084a5 // add    v5.2d, v5.2d, v16.2d
+	WORD $0x4ef084c6 // add    v6.2d, v6.2d, v16.2d
+	WORD $0xb90033e9 // str    w9, [sp, #48]
+	WORD $0xb94077e9 // ldr    w9, [sp, #116]
+	WORD $0x4ef084e7 // add    v7.2d, v7.2d, v16.2d
+	WORD $0x4ef08484 // add    v4.2d, v4.2d, v16.2d
+	WORD $0xb9000489 // str    w9, [x4, #4]
+	WORD $0xb9406fe9 // ldr    w9, [sp, #108]
+	WORD $0x4ef08463 // add    v3.2d, v3.2d, v16.2d
+	WORD $0x4ef08442 // add    v2.2d, v2.2d, v16.2d
+	WORD $0xb9000789 // str    w9, [x28, #4]
+	WORD $0xb9400829 // ldr    w9, [x1, #8]
+	WORD $0xf9406fe1 // ldr    x1, [sp, #216]
+	WORD $0x4ef08421 // add    v1.2d, v1.2d, v16.2d
+	WORD $0x29072be9 // stp    w9, w10, [sp, #56]
+	WORD $0xb94067e9 // ldr    w9, [sp, #100]
+	WORD $0xa949abef // ldp    x15, x10, [sp, #152]
+	WORD $0x4ef08400 // add    v0.2d, v0.2d, v16.2d
+	WORD $0xb9000569 // str    w9, [x11, #4]
+	WORD $0xb9400849 // ldr    w9, [x2, #8]
+	WORD $0xb9007be9 // str    w9, [sp, #120]
+	WORD $0xb94063e9 // ldr    w9, [sp, #96]
+	WORD $0xb9000589 // str    w9, [x12, #4]
+	WORD $0xb94009a9 // ldr    w9, [x13, #8]
+	WORD $0xb90037e9 // str    w9, [sp, #52]
+	WORD $0xb9405fe9 // ldr    w9, [sp, #92]
+	WORD $0xb9000549 // str    w9, [x10, #4]
+	WORD $0xb94009c9 // ldr    w9, [x14, #8]
+	WORD $0xb9005fe9 // str    w9, [sp, #92]
+	WORD $0xb94053e9 // ldr    w9, [sp, #80]
+	WORD $0xb90005e9 // str    w9, [x15, #4]
+	WORD $0xb9400a69 // ldr    w9, [x19, #8]
+	WORD $0xb94047f3 // ldr    w19, [sp, #68]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xb9404fe9 // ldr    w9, [sp, #76]
+	WORD $0xb9000429 // str    w9, [x1, #4]
+	WORD $0xb9400a09 // ldr    w9, [x16, #8]
+	WORD $0xb90077e9 // str    w9, [sp, #116]
+	WORD $0xb94073e9 // ldr    w9, [sp, #112]
+	WORD $0xb90007c9 // str    w9, [x30, #4]
+	WORD $0xb9406be9 // ldr    w9, [sp, #104]
+	WORD $0xb94008de // ldr    w30, [x6, #8]
+	WORD $0xb9000729 // str    w9, [x25, #4]
+	WORD $0xb9400ac9 // ldr    w9, [x22, #8]
+	WORD $0xaa1803f6 // mov    x22, x24
+	WORD $0xb9007fe9 // str    w9, [sp, #124]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xb90004e9 // str    w9, [x7, #4]
+	WORD $0xb9400ae9 // ldr    w9, [x23, #8]
+	WORD $0xf9407ff7 // ldr    x23, [sp, #248]
+	WORD $0xb9000705 // str    w5, [x24, #4]
+	WORD $0xaa1503f8 // mov    x24, x21
+	WORD $0xb9006be9 // str    w9, [sp, #104]
+	WORD $0xf940bbe9 // ldr    x9, [sp, #368]
+	WORD $0xb90006f3 // str    w19, [x23, #4]
+	WORD $0xb9400ab3 // ldr    w19, [x21, #8]
+	WORD $0xf9408ff5 // ldr    x21, [sp, #280]
+	WORD $0x29416525 // ldp    w5, w25, [x9, #8]
+	WORD $0xb90073f3 // str    w19, [sp, #112]
+	WORD $0xb94043f3 // ldr    w19, [sp, #64]
+	WORD $0xb9000753 // str    w19, [x26, #4]
+	WORD $0xaa0f03f3 // mov    x19, x15
+	WORD $0xb9000865 // str    w5, [x3, #8]
+	WORD $0xf940a7e3 // ldr    x3, [sp, #328]
+	WORD $0xaa0403fa // mov    x26, x4
+	WORD $0xb9400c69 // ldr    w9, [x3, #12]
+	WORD $0xaa0603e3 // mov    x3, x6
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0xb94057e9 // ldr    w9, [sp, #84]
+	WORD $0xb9000b69 // str    w9, [x27, #8]
+	WORD $0xb9404be9 // ldr    w9, [sp, #72]
+	WORD $0xb9400e3b // ldr    w27, [x17, #12]
+	WORD $0xaa0703f1 // mov    x17, x7
+	WORD $0xb9000a89 // str    w9, [x20, #8]
+	WORD $0xb9400d09 // ldr    w9, [x8, #12]
+	WORD $0xb94033e8 // ldr    w8, [sp, #48]
+	WORD $0xb9000888 // str    w8, [x4, #8]
+	WORD $0xb9400e48 // ldr    w8, [x18, #12]
+	WORD $0xaa0103e4 // mov    x4, x1
+	WORD $0x2908a7e8 // stp    w8, w9, [sp, #68]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xaa0a03e9 // mov    x9, x10
+	WORD $0xb9000b88 // str    w8, [x28, #8]
+	WORD $0xb9400ea8 // ldr    w8, [x21, #12]
+	WORD $0xb90063e8 // str    w8, [sp, #96]
+	WORD $0xb9403be8 // ldr    w8, [sp, #56]
+	WORD $0xb9000968 // str    w8, [x11, #8]
+	WORD $0xb9407be8 // ldr    w8, [sp, #120]
+	WORD $0xb9400c4b // ldr    w11, [x2, #12]
+	WORD $0xaa1003e2 // mov    x2, x16
+	WORD $0xb9000988 // str    w8, [x12, #8]
+	WORD $0xb9400da8 // ldr    w8, [x13, #12]
+	WORD $0xf94073ec // ldr    x12, [sp, #224]
+	WORD $0xb9407fed // ldr    w13, [sp, #124]
+	WORD $0xb9007be8 // str    w8, [sp, #120]
+	WORD $0xb94037e8 // ldr    w8, [sp, #52]
+	WORD $0xb9000948 // str    w8, [x10, #8]
+	WORD $0xb9400dc8 // ldr    w8, [x14, #12]
+	WORD $0xf940b3ea // ldr    x10, [sp, #352]
+	WORD $0x290623eb // stp    w11, w8, [sp, #48]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9400e0b // ldr    w11, [x16, #12]
+	WORD $0xb90009e8 // str    w8, [x15, #8]
+	WORD $0xb9400d48 // ldr    w8, [x10, #12]
+	WORD $0xb9002fe8 // str    w8, [sp, #44]
+	WORD $0xb94067e8 // ldr    w8, [sp, #100]
+	WORD $0xb9000828 // str    w8, [x1, #8]
+	WORD $0xb94077e8 // ldr    w8, [sp, #116]
+	WORD $0xaa1703e1 // mov    x1, x23
+	WORD $0xb9000988 // str    w8, [x12, #8]
+	WORD $0xb9400cc8 // ldr    w8, [x6, #12]
+	WORD $0x290aafe8 // stp    w8, w11, [sp, #84]
+	WORD $0xf9405feb // ldr    x11, [sp, #184]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb900097e // str    w30, [x11, #8]
+	WORD $0xf940b7fe // ldr    x30, [sp, #360]
+	WORD $0xb9400d0f // ldr    w15, [x8, #12]
+	WORD $0xb90008ed // str    w13, [x7, #8]
+	WORD $0xf940bfed // ldr    x13, [sp, #376]
+	WORD $0xb9400fce // ldr    w14, [x30, #12]
+	WORD $0xf940a7e7 // ldr    x7, [sp, #328]
+	WORD $0xb94009a5 // ldr    w5, [x13, #8]
+	WORD $0x2909bfee // stp    w14, w15, [sp, #76]
+	WORD $0xb9406bee // ldr    w14, [sp, #104]
+	WORD $0xb94010ef // ldr    w15, [x7, #16]
+	WORD $0xb9000ace // str    w14, [x22, #8]
+	WORD $0xb9400f0e // ldr    w14, [x24, #12]
+	WORD $0xa94ec3f6 // ldp    x22, x16, [sp, #232]
+	WORD $0xb9006bee // str    w14, [sp, #104]
+	WORD $0xb9400db8 // ldr    w24, [x13, #12]
+	WORD $0x294dbbed // ldp    w13, w14, [sp, #108]
+	WORD $0xb9000aee // str    w14, [x23, #8]
+	WORD $0xa94cdff2 // ldp    x18, x23, [sp, #200]
+	WORD $0xb9000ae5 // str    w5, [x23, #8]
+	WORD $0xb9000e59 // str    w25, [x18, #12]
+	WORD $0xb9000e0d // str    w13, [x16, #12]
+	WORD $0xa953b7e5 // ldp    x5, x13, [sp, #312]
+	WORD $0xb9000e9b // str    w27, [x20, #12]
+	WORD $0xf940c3fb // ldr    x27, [sp, #384]
+	WORD $0xb94011ae // ldr    w14, [x13, #16]
+	WORD $0x29073fee // stp    w14, w15, [sp, #56]
+	WORD $0xb94010ae // ldr    w14, [x5, #16]
+	WORD $0xb94012af // ldr    w15, [x21, #16]
+	WORD $0xb90067ee // str    w14, [sp, #100]
+	WORD $0xb9404bee // ldr    w14, [sp, #72]
+	WORD $0xb90043ef // str    w15, [sp, #64]
+	WORD $0xb94063ef // ldr    w15, [sp, #96]
+	WORD $0xb9000f4e // str    w14, [x26, #12]
+	WORD $0xb940136e // ldr    w14, [x27, #16]
+	WORD $0xb9005fee // str    w14, [sp, #92]
+	WORD $0xb94047ee // ldr    w14, [sp, #68]
+	WORD $0xb9000f8e // str    w14, [x28, #12]
+	WORD $0xaa1503ee // mov    x14, x21
+	WORD $0xb9000ecf // str    w15, [x22, #12]
+	WORD $0xf940c7ef // ldr    x15, [sp, #392]
+	WORD $0xf94083f5 // ldr    x21, [sp, #256]
+	WORD $0xb94011e6 // ldr    w6, [x15, #16]
+	WORD $0xb9006fe6 // str    w6, [sp, #108]
+	WORD $0xb94033e6 // ldr    w6, [sp, #48]
+	WORD $0xb9000ea6 // str    w6, [x21, #12]
+	WORD $0xf94093e6 // ldr    x6, [sp, #288]
+	WORD $0xb94010d9 // ldr    w25, [x6, #16]
+	WORD $0xb90047f9 // str    w25, [sp, #68]
+	WORD $0xb9407bf9 // ldr    w25, [sp, #120]
+	WORD $0xb9000d39 // str    w25, [x9, #12]
+	WORD $0xf940abf9 // ldr    x25, [sp, #336]
+	WORD $0xb9401329 // ldr    w9, [x25, #16]
+	WORD $0xb90077e9 // str    w9, [sp, #116]
+	WORD $0xb94037e9 // ldr    w9, [sp, #52]
+	WORD $0xb9000e69 // str    w9, [x19, #12]
+	WORD $0xb9401149 // ldr    w9, [x10, #16]
+	WORD $0xf940bbea // ldr    x10, [sp, #368]
+	WORD $0xaa1603f3 // mov    x19, x22
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xb9402fe9 // ldr    w9, [sp, #44]
+	WORD $0xb9000c89 // str    w9, [x4, #12]
+	WORD $0xb9401049 // ldr    w9, [x2, #16]
+	WORD $0xb9401544 // ldr    w4, [x10, #20]
+	WORD $0xaa1403e2 // mov    x2, x20
+	WORD $0xb9004be9 // str    w9, [sp, #72]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xb9000d89 // str    w9, [x12, #12]
+	WORD $0xb9401069 // ldr    w9, [x3, #16]
+	WORD $0xaa0303ec // mov    x12, x3
+	WORD $0xaa0b03e3 // mov    x3, x11
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xb94057e9 // ldr    w9, [sp, #84]
+	WORD $0xf9008bec // str    x12, [sp, #272]
+	WORD $0xb9000d69 // str    w9, [x11, #12]
+	WORD $0xb9401109 // ldr    w9, [x8, #16]
+	WORD $0xb94053e8 // ldr    w8, [sp, #80]
+	WORD $0xb9406beb // ldr    w11, [sp, #104]
+	WORD $0xb9000e28 // str    w8, [x17, #12]
+	WORD $0xb94013c8 // ldr    w8, [x30, #16]
+	WORD $0xf94087fe // ldr    x30, [sp, #264]
+	WORD $0x290f23e9 // stp    w9, w8, [sp, #120]
+	WORD $0xf9405be9 // ldr    x9, [sp, #176]
+	WORD $0xb9404fe8 // ldr    w8, [sp, #76]
+	WORD $0xb9000d28 // str    w8, [x9, #12]
+	WORD $0xb9401148 // ldr    w8, [x10, #16]
+	WORD $0xb9000c2b // str    w11, [x1, #12]
+	WORD $0xb94015aa // ldr    w10, [x13, #20]
+	WORD $0xb9000ef8 // str    w24, [x23, #12]
+	WORD $0xb940172d // ldr    w13, [x25, #20]
+	WORD $0xb9001248 // str    w8, [x18, #16]
+	WORD $0xb94014e8 // ldr    w8, [x7, #20]
+	WORD $0xa9559fe1 // ldp    x1, x7, [sp, #344]
+	WORD $0xaa0503eb // mov    x11, x5
+	WORD $0xb9006be8 // str    w8, [sp, #104]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xb9401031 // ldr    w17, [x1, #16]
+	WORD $0xb9001208 // str    w8, [x16, #16]
+	WORD $0xb9403be8 // ldr    w8, [sp, #56]
+	WORD $0xb94014d0 // ldr    w16, [x6, #20]
+	WORD $0xb9001288 // str    w8, [x20, #16]
+	WORD $0xb94014a8 // ldr    w8, [x5, #20]
+	WORD $0x2909c3ed // stp    w13, w16, [sp, #76]
+	WORD $0xb94077ed // ldr    w13, [sp, #116]
+	WORD $0xaa0f03e5 // mov    x5, x15
+	WORD $0xf940bff0 // ldr    x16, [sp, #376]
+	WORD $0x29062be8 // stp    w8, w10, [sp, #48]
+	WORD $0xb94067e8 // ldr    w8, [sp, #100]
+	WORD $0xb94015ca // ldr    w10, [x14, #20]
+	WORD $0xb9001348 // str    w8, [x26, #16]
+	WORD $0xb9401768 // ldr    w8, [x27, #20]
+	WORD $0xaa0903fb // mov    x27, x9
+	WORD $0xb9407fe9 // ldr    w9, [sp, #124]
+	WORD $0xb9002fe8 // str    w8, [sp, #44]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9001388 // str    w8, [x28, #16]
+	WORD $0xb94043e8 // ldr    w8, [sp, #64]
+	WORD $0xaa0e03fc // mov    x28, x14
+	WORD $0xa94dbbf8 // ldp    x24, x14, [sp, #216]
+	WORD $0xb90012c8 // str    w8, [x22, #16]
+	WORD $0xb94015e8 // ldr    w8, [x15, #20]
+	WORD $0xa949dff6 // ldp    x22, x23, [sp, #152]
+	WORD $0x290aabe8 // stp    w8, w10, [sp, #84]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb94047ea // ldr    w10, [sp, #68]
+	WORD $0xa952bff4 // ldp    x20, x15, [sp, #296]
+	WORD $0xb90012a8 // str    w8, [x21, #16]
+	WORD $0xaa0603e8 // mov    x8, x6
+	WORD $0xb90012ea // str    w10, [x23, #16]
+	WORD $0xaa1903ea // mov    x10, x25
+	WORD $0xb90012cd // str    w13, [x22, #16]
+	WORD $0xb94014ed // ldr    w13, [x7, #20]
+	WORD $0xa94f67fa // ldp    x26, x25, [sp, #240]
+	WORD $0xb90077ed // str    w13, [sp, #116]
+	WORD $0xb94063ed // ldr    w13, [sp, #96]
+	WORD $0xb900130d // str    w13, [x24, #16]
+	WORD $0xb940168d // ldr    w13, [x20, #20]
+	WORD $0xb9003fed // str    w13, [sp, #60]
+	WORD $0xb9404bed // ldr    w13, [sp, #72]
+	WORD $0xb90011cd // str    w13, [x14, #16]
+	WORD $0xb940158d // ldr    w13, [x12, #20]
+	WORD $0xb90067ed // str    w13, [sp, #100]
+	WORD $0xb94073ed // ldr    w13, [sp, #112]
+	WORD $0xb900106d // str    w13, [x3, #16]
+	WORD $0xb94015ed // ldr    w13, [x15, #20]
+	WORD $0xb9401203 // ldr    w3, [x16, #16]
+	WORD $0xb9004bed // str    w13, [sp, #72]
+	WORD $0xb9407bed // ldr    w13, [sp, #120]
+	WORD $0xb90013cd // str    w13, [x30, #16]
+	WORD $0xf940b7ed // ldr    x13, [sp, #360]
+	WORD $0xb9001369 // str    w9, [x27, #16]
+	WORD $0xb9401429 // ldr    w9, [x1, #20]
+	WORD $0xb9001331 // str    w17, [x25, #16]
+	WORD $0xaa1403e1 // mov    x1, x20
+	WORD $0xb94015a6 // ldr    w6, [x13, #20]
+	WORD $0xb9007fe9 // str    w9, [sp, #124]
+	WORD $0xb9003be6 // str    w6, [sp, #56]
+	WORD $0xb9401606 // ldr    w6, [x16, #20]
+	WORD $0xf9406bf0 // ldr    x16, [sp, #208]
+	WORD $0xb9001203 // str    w3, [x16, #16]
+	WORD $0xa95447e3 // ldp    x3, x17, [sp, #320]
+	WORD $0xb9001644 // str    w4, [x18, #20]
+	WORD $0xaa0d03e4 // mov    x4, x13
+	WORD $0xb9401a29 // ldr    w9, [x17, #24]
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xb9406be9 // ldr    w9, [sp, #104]
+	WORD $0xb9001749 // str    w9, [x26, #20]
+	WORD $0xb9401869 // ldr    w9, [x3, #24]
+	WORD $0xb9005fe9 // str    w9, [sp, #92]
+	WORD $0xb94037e9 // ldr    w9, [sp, #52]
+	WORD $0xb9001449 // str    w9, [x2, #20]
+	WORD $0xb9401969 // ldr    w9, [x11, #24]
+	WORD $0xf94063e2 // ldr    x2, [sp, #192]
+	WORD $0xf940c3eb // ldr    x11, [sp, #384]
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0xb94033e9 // ldr    w9, [sp, #48]
+	WORD $0xb9001449 // str    w9, [x2, #20]
+	WORD $0xb9401969 // ldr    w9, [x11, #24]
+	WORD $0xf9404beb // ldr    x11, [sp, #144]
+	WORD $0xb9006be9 // str    w9, [sp, #104]
+	WORD $0xb9402fe9 // ldr    w9, [sp, #44]
+	WORD $0xb9001569 // str    w9, [x11, #20]
+	WORD $0xb9401b89 // ldr    w9, [x28, #24]
+	WORD $0xf940bbfc // ldr    x28, [sp, #368]
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xb9001669 // str    w9, [x19, #20]
+	WORD $0xb94018a9 // ldr    w9, [x5, #24]
+	WORD $0xaa1803e5 // mov    x5, x24
+	WORD $0xaa1603f3 // mov    x19, x22
+	WORD $0xb9005be9 // str    w9, [sp, #88]
+	WORD $0xb94057e9 // ldr    w9, [sp, #84]
+	WORD $0xb90016a9 // str    w9, [x21, #20]
+	WORD $0xb9401909 // ldr    w9, [x8, #24]
+	WORD $0xb94053e8 // ldr    w8, [sp, #80]
+	WORD $0xaa1203f5 // mov    x21, x18
+	WORD $0xb90016e8 // str    w8, [x23, #20]
+	WORD $0xb9401948 // ldr    w8, [x10, #24]
+	WORD $0xb940198a // ldr    w10, [x12, #24]
+	WORD $0xf940afec // ldr    x12, [sp, #344]
+	WORD $0x290a27e8 // stp    w8, w9, [sp, #80]
+	WORD $0xb9404fe8 // ldr    w8, [sp, #76]
+	WORD $0xb94018e9 // ldr    w9, [x7, #24]
+	WORD $0xb90016c8 // str    w8, [x22, #20]
+	WORD $0xb94077e8 // ldr    w8, [sp, #116]
+	WORD $0xb9001708 // str    w8, [x24, #20]
+	WORD $0xb9401a88 // ldr    w8, [x20, #24]
+	WORD $0xa9585ff8 // ldp    x24, x23, [sp, #384]
+	WORD $0xaa0203f4 // mov    x20, x2
+	WORD $0x290827e8 // stp    w8, w9, [sp, #64]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xb94067e9 // ldr    w9, [sp, #100]
+	WORD $0xb90015c8 // str    w8, [x14, #20]
+	WORD $0xf9405fe8 // ldr    x8, [sp, #184]
+	WORD $0xb9405bee // ldr    w14, [sp, #88]
+	WORD $0xb9001509 // str    w9, [x8, #20]
+	WORD $0xb94019e9 // ldr    w9, [x15, #24]
+	WORD $0xf9409fef // ldr    x15, [sp, #312]
+	WORD $0x290ea7ea // stp    w10, w9, [sp, #116]
+	WORD $0xb9404be9 // ldr    w9, [sp, #72]
+	WORD $0xb9401b8a // ldr    w10, [x28, #24]
+	WORD $0xb90017c9 // str    w9, [x30, #20]
+	WORD $0xb94019a9 // ldr    w9, [x13, #24]
+	WORD $0xf94053fe // ldr    x30, [sp, #160]
+	WORD $0xb9004fe9 // str    w9, [sp, #76]
+	WORD $0xb9403be9 // ldr    w9, [sp, #56]
+	WORD $0xb9001769 // str    w9, [x27, #20]
+	WORD $0xb9407fe9 // ldr    w9, [sp, #124]
+	WORD $0xaa0803fb // mov    x27, x8
+	WORD $0xb9001729 // str    w9, [x25, #20]
+	WORD $0xb9401989 // ldr    w9, [x12, #24]
+	WORD $0xb9001606 // str    w6, [x16, #20]
+	WORD $0xb9401df0 // ldr    w16, [x15, #28]
+	WORD $0xb9001a4a // str    w10, [x18, #24]
+	WORD $0xb9401e2a // ldr    w10, [x17, #28]
+	WORD $0xaa1a03f2 // mov    x18, x26
+	WORD $0xb9007fe9 // str    w9, [sp, #124]
+	WORD $0xb9401f86 // ldr    w6, [x28, #28]
+	WORD $0xaa1c03e9 // mov    x9, x28
+	WORD $0xb90067ea // str    w10, [sp, #100]
+	WORD $0xb94073ea // ldr    w10, [sp, #112]
+	WORD $0xaa1103fc // mov    x28, x17
+	WORD $0xa94e37f9 // ldp    x25, x13, [sp, #224]
+	WORD $0xa951c7f6 // ldp    x22, x17, [sp, #280]
+	WORD $0xb9001b4a // str    w10, [x26, #24]
+	WORD $0xaa0303fa // mov    x26, x3
+	WORD $0xb9401c6a // ldr    w10, [x3, #28]
+	WORD $0xf94057e3 // ldr    x3, [sp, #168]
+	WORD $0xb9401d8c // ldr    w12, [x12, #28]
+	WORD $0xb9004bea // str    w10, [sp, #72]
+	WORD $0xb9405fea // ldr    w10, [sp, #92]
+	WORD $0xb900186a // str    w10, [x3, #24]
+	WORD $0xb9406fea // ldr    w10, [sp, #108]
+	WORD $0xb900184a // str    w10, [x2, #24]
+	WORD $0xb9401f0a // ldr    w10, [x24, #28]
+	WORD $0xaa0703e2 // mov    x2, x7
+	WORD $0x2906c3ea // stp    w10, w16, [sp, #52]
+	WORD $0xaa0b03ea // mov    x10, x11
+	WORD $0xb9406beb // ldr    w11, [sp, #104]
+	WORD $0xb9401ef0 // ldr    w16, [x23, #28]
+	WORD $0xb900194b // str    w11, [x10, #24]
+	WORD $0xb9401ec8 // ldr    w8, [x22, #28]
+	WORD $0xb94063eb // ldr    w11, [sp, #96]
+	WORD $0xb90019ab // str    w11, [x13, #24]
+	WORD $0xf94083eb // ldr    x11, [sp, #256]
+	WORD $0xb900196e // str    w14, [x11, #24]
+	WORD $0xb9401e2e // ldr    w14, [x17, #28]
+	WORD $0x2905bbf0 // stp    w16, w14, [sp, #44]
+	WORD $0xb94057ee // ldr    w14, [sp, #84]
+	WORD $0xb90057ec // str    w12, [sp, #84]
+	WORD $0xf9407fec // ldr    x12, [sp, #248]
+	WORD $0xb9001bce // str    w14, [x30, #24]
+	WORD $0xf940abee // ldr    x14, [sp, #336]
+	WORD $0xb9401dd0 // ldr    w16, [x14, #28]
+	WORD $0xb9003ff0 // str    w16, [sp, #60]
+	WORD $0xb94053f0 // ldr    w16, [sp, #80]
+	WORD $0xb9001a70 // str    w16, [x19, #24]
+	WORD $0xb9401cf0 // ldr    w16, [x7, #28]
+	WORD $0xf9409be7 // ldr    x7, [sp, #304]
+	WORD $0x290b23f0 // stp    w16, w8, [sp, #88]
+	WORD $0xb94047f0 // ldr    w16, [sp, #68]
+	WORD $0xb90018b0 // str    w16, [x5, #24]
+	WORD $0xb9401c30 // ldr    w16, [x1, #28]
+	WORD $0xf9408be5 // ldr    x5, [sp, #272]
+	WORD $0xb90063f0 // str    w16, [sp, #96]
+	WORD $0xb94043f0 // ldr    w16, [sp, #64]
+	WORD $0xb9001b30 // str    w16, [x25, #24]
+	WORD $0xb9401cb0 // ldr    w16, [x5, #28]
+	WORD $0xb90053f0 // str    w16, [sp, #80]
+	WORD $0x294ec3e8 // ldp    w8, w16, [sp, #116]
+	WORD $0xb9001b68 // str    w8, [x27, #24]
+	WORD $0xb9401ce8 // ldr    w8, [x7, #28]
+	WORD $0xb90077e8 // str    w8, [sp, #116]
+	WORD $0xf94087e8 // ldr    x8, [sp, #264]
+	WORD $0xb9001910 // str    w16, [x8, #24]
+	WORD $0xb9401c90 // ldr    w16, [x4, #28]
+	WORD $0xf940bfe8 // ldr    x8, [sp, #376]
+	WORD $0xb9404fe4 // ldr    w4, [sp, #76]
+	WORD $0xb9006bf0 // str    w16, [sp, #104]
+	WORD $0xf9405bf0 // ldr    x16, [sp, #176]
+	WORD $0x29432101 // ldp    w1, w8, [x8, #24]
+	WORD $0xb9001a04 // str    w4, [x16, #24]
+	WORD $0xb9407fe4 // ldr    w4, [sp, #124]
+	WORD $0xb90073e8 // str    w8, [sp, #112]
+	WORD $0xf9406be8 // ldr    x8, [sp, #208]
+	WORD $0xb9001984 // str    w4, [x12, #24]
+	WORD $0xb94067e4 // ldr    w4, [sp, #100]
+	WORD $0xb9001901 // str    w1, [x8, #24]
+	WORD $0xb9402381 // ldr    w1, [x28, #32]
+	WORD $0xb9001ea6 // str    w6, [x21, #28]
+	WORD $0xaa0703f5 // mov    x21, x7
+	WORD $0xb9001e44 // str    w4, [x18, #28]
+	WORD $0xb9402352 // ldr    w18, [x26, #32]
+	WORD $0xf94097fa // ldr    x26, [sp, #296]
+	WORD $0xb9006fe1 // str    w1, [sp, #108]
+	WORD $0xaa1c03e1 // mov    x1, x28
+	WORD $0xb9402126 // ldr    w6, [x9, #32]
+	WORD $0xb9007ff2 // str    w18, [sp, #124]
+	WORD $0xb9404bf2 // ldr    w18, [sp, #72]
+	WORD $0xf940affc // ldr    x28, [sp, #344]
+	WORD $0xb9001c72 // str    w18, [x3, #28]
+	WORD $0xb94021f2 // ldr    w18, [x15, #32]
+	WORD $0xb9402384 // ldr    w4, [x28, #32]
+	WORD $0xb90067f2 // str    w18, [sp, #100]
+	WORD $0xaa0f03f2 // mov    x18, x15
+	WORD $0x2946bfe3 // ldp    w3, w15, [sp, #52]
+	WORD $0xb9001e8f // str    w15, [x20, #28]
+	WORD $0xf94057f4 // ldr    x20, [sp, #168]
+	WORD $0xb9001d43 // str    w3, [x10, #28]
+	WORD $0xaa0a03e3 // mov    x3, x10
+	WORD $0xb94022ca // ldr    w10, [x22, #32]
+	WORD $0xb940230f // ldr    w15, [x24, #32]
+	WORD $0x29093fea // stp    w10, w15, [sp, #72]
+	WORD $0xb9405fea // ldr    w10, [sp, #92]
+	WORD $0xaa1803ef // mov    x15, x24
+	WORD $0xaa0203f8 // mov    x24, x2
+	WORD $0xb9001daa // str    w10, [x13, #28]
+	WORD $0xb94022ea // ldr    w10, [x23, #32]
+	WORD $0xf9406ff7 // ldr    x23, [sp, #216]
+	WORD $0xb9003bea // str    w10, [sp, #56]
+	WORD $0x2945b7ea // ldp    w10, w13, [sp, #44]
+	WORD $0xb9001d6a // str    w10, [x11, #28]
+	WORD $0xb940222a // ldr    w10, [x17, #32]
+	WORD $0xb9001fcd // str    w13, [x30, #28]
+	WORD $0xb94021cd // ldr    w13, [x14, #32]
+	WORD $0xb940204e // ldr    w14, [x2, #32]
+	WORD $0xaa1103eb // mov    x11, x17
+	WORD $0xb90037ea // str    w10, [sp, #52]
+	WORD $0xaa1e03ea // mov    x10, x30
+	WORD $0xb9005fed // str    w13, [sp, #92]
+	WORD $0xb9403fed // ldr    w13, [sp, #60]
+	WORD $0xaa1b03f1 // mov    x17, x27
+	WORD $0xf94087fe // ldr    x30, [sp, #264]
+	WORD $0xaa1903e2 // mov    x2, x25
+	WORD $0xb940256b // ldr    w11, [x11, #36]
+	WORD $0xb9001e6d // str    w13, [x19, #28]
+	WORD $0xb9405bed // ldr    w13, [sp, #88]
+	WORD $0xb9001eed // str    w13, [x23, #28]
+	WORD $0xb940234d // ldr    w13, [x26, #32]
+	WORD $0xb9005bed // str    w13, [sp, #88]
+	WORD $0xb94063ed // ldr    w13, [sp, #96]
+	WORD $0xb9001f2d // str    w13, [x25, #28]
+	WORD $0xb94020ad // ldr    w13, [x5, #32]
+	WORD $0xaa0503f9 // mov    x25, x5
+	WORD $0x29083bed // stp    w13, w14, [sp, #64]
+	WORD $0xb94020ee // ldr    w14, [x7, #32]
+	WORD $0xaa0903e7 // mov    x7, x9
+	WORD $0x294a27ed // ldp    w13, w9, [sp, #80]
+	WORD $0xb9001f6d // str    w13, [x27, #28]
+	WORD $0xb94077ed // ldr    w13, [sp, #116]
+	WORD $0xf940b7fb // ldr    x27, [sp, #360]
+	WORD $0xb94024e5 // ldr    w5, [x7, #36]
+	WORD $0xb9001fcd // str    w13, [x30, #28]
+	WORD $0xb940236d // ldr    w13, [x27, #32]
+	WORD $0x290ebbed // stp    w13, w14, [sp, #116]
+	WORD $0xb9406bed // ldr    w13, [sp, #104]
+	WORD $0xb9006beb // str    w11, [sp, #104]
+	WORD $0xb94037eb // ldr    w11, [sp, #52]
+	WORD $0xb9001e0d // str    w13, [x16, #28]
+	WORD $0xf94083f0 // ldr    x16, [sp, #256]
+	WORD $0xb9001d89 // str    w9, [x12, #28]
+	WORD $0xb940242c // ldr    w12, [x1, #36]
+	WORD $0x294da7ed // ldp    w13, w9, [sp, #108]
+	WORD $0xb90073ec // str    w12, [sp, #112]
+	WORD $0xa94eb3e1 // ldp    x1, x12, [sp, #232]
+	WORD $0xb9001d09 // str    w9, [x8, #28]
+	WORD $0xaa0703e9 // mov    x9, x7
+	WORD $0xf94067e8 // ldr    x8, [sp, #200]
+	WORD $0xaa0f03e7 // mov    x7, x15
+	WORD $0xb9002106 // str    w6, [x8, #32]
+	WORD $0xf94063e6 // ldr    x6, [sp, #192]
+	WORD $0xb900218d // str    w13, [x12, #32]
+	WORD $0xf940a3ed // ldr    x13, [sp, #320]
+	WORD $0xb94025ae // ldr    w14, [x13, #36]
+	WORD $0xb90053ee // str    w14, [sp, #80]
+	WORD $0xb9407fee // ldr    w14, [sp, #124]
+	WORD $0xb900228e // str    w14, [x20, #32]
+	WORD $0xb940264e // ldr    w14, [x18, #36]
+	WORD $0xaa0a03f2 // mov    x18, x10
+	WORD $0xb90063ee // str    w14, [sp, #96]
+	WORD $0xb94067ee // ldr    w14, [sp, #100]
+	WORD $0xb90020ce // str    w14, [x6, #32]
+	WORD $0xb94025ee // ldr    w14, [x15, #36]
+	WORD $0xb9006fee // str    w14, [sp, #108]
+	WORD $0xb9404fee // ldr    w14, [sp, #76]
+	WORD $0xb900206e // str    w14, [x3, #32]
+	WORD $0xb94026ce // ldr    w14, [x22, #36]
+	WORD $0xb9007fee // str    w14, [sp, #124]
+	WORD $0xb9404bee // ldr    w14, [sp, #72]
+	WORD $0xb900202e // str    w14, [x1, #32]
+	WORD $0xf940c7ee // ldr    x14, [sp, #392]
+	WORD $0xb94025cf // ldr    w15, [x14, #36]
+	WORD $0xb9003fef // str    w15, [sp, #60]
+	WORD $0xb9403bef // ldr    w15, [sp, #56]
+	WORD $0xb900220f // str    w15, [x16, #32]
+	WORD $0xaa0203ef // mov    x15, x2
+	WORD $0xb900214b // str    w11, [x10, #32]
+	WORD $0xf940abea // ldr    x10, [sp, #336]
+	WORD $0xb940254b // ldr    w11, [x10, #36]
+	WORD $0xb9004feb // str    w11, [sp, #76]
+	WORD $0xb9405feb // ldr    w11, [sp, #92]
+	WORD $0xb900226b // str    w11, [x19, #32]
+	WORD $0xb940270b // ldr    w11, [x24, #36]
+	WORD $0xaa1503f3 // mov    x19, x21
+	WORD $0xaa1e03f8 // mov    x24, x30
+	WORD $0xb9004beb // str    w11, [sp, #72]
+	WORD $0xb94047eb // ldr    w11, [sp, #68]
+	WORD $0xb90022eb // str    w11, [x23, #32]
+	WORD $0xb940274b // ldr    w11, [x26, #36]
+	WORD $0xf9405bfa // ldr    x26, [sp, #176]
+	WORD $0xb90067eb // str    w11, [sp, #100]
+	WORD $0xb9405beb // ldr    w11, [sp, #88]
+	WORD $0xb900204b // str    w11, [x2, #32]
+	WORD $0xb940272b // ldr    w11, [x25, #36]
+	WORD $0xb9402762 // ldr    w2, [x27, #36]
+	WORD $0xb9005feb // str    w11, [sp, #92]
+	WORD $0xaa1103eb // mov    x11, x17
+	WORD $0xb94043f1 // ldr    w17, [sp, #64]
+	WORD $0xb9002171 // str    w17, [x11, #32]
+	WORD $0xb94026b1 // ldr    w17, [x21, #36]
+	WORD $0xf940bff5 // ldr    x21, [sp, #376]
+	WORD $0xb9005bf1 // str    w17, [sp, #88]
+	WORD $0x294ec7f9 // ldp    w25, w17, [sp, #116]
+	WORD $0xb9007be2 // str    w2, [sp, #120]
+	WORD $0xaa1b03e2 // mov    x2, x27
+	WORD $0xf9407ffb // ldr    x27, [sp, #248]
+	WORD $0xb90023d1 // str    w17, [x30, #32]
+	WORD $0xb94022b1 // ldr    w17, [x21, #32]
+	WORD $0xb9002359 // str    w25, [x26, #32]
+	WORD $0xb9402799 // ldr    w25, [x28, #36]
+	WORD $0xb9002364 // str    w4, [x27, #32]
+	WORD $0xb94026a4 // ldr    w4, [x21, #36]
+	WORD $0xf9409ffe // ldr    x30, [sp, #312]
+	WORD $0xb90057f9 // str    w25, [sp, #84]
+	WORD $0xf9406bf9 // ldr    x25, [sp, #208]
+	WORD $0xb90077e4 // str    w4, [sp, #116]
+	WORD $0xaa0803e4 // mov    x4, x8
+	WORD $0xf940a7f5 // ldr    x21, [sp, #328]
+	WORD $0xb9002331 // str    w17, [x25, #32]
+	WORD $0xb9002505 // str    w5, [x8, #36]
+	WORD $0xb94073e8 // ldr    w8, [sp, #112]
+	WORD $0xb9402ab1 // ldr    w17, [x21, #40]
+	WORD $0xaa1603e5 // mov    x5, x22
+	WORD $0xb9002588 // str    w8, [x12, #36]
+	WORD $0xb94029a8 // ldr    w8, [x13, #40]
+	WORD $0xb90073e8 // str    w8, [sp, #112]
+	WORD $0xb94053e8 // ldr    w8, [sp, #80]
+	WORD $0xb9002688 // str    w8, [x20, #36]
+	WORD $0xb9402bc8 // ldr    w8, [x30, #40]
+	WORD $0xaa0303f4 // mov    x20, x3
+	WORD $0xb90047e8 // str    w8, [sp, #68]
+	WORD $0xb94063e8 // ldr    w8, [sp, #96]
+	WORD $0xb90024c8 // str    w8, [x6, #36]
+	WORD $0xb94028e8 // ldr    w8, [x7, #40]
+	WORD $0xaa1a03e7 // mov    x7, x26
+	WORD $0xb90063e8 // str    w8, [sp, #96]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb9002468 // str    w8, [x3, #36]
+	WORD $0xb9402ac8 // ldr    w8, [x22, #40]
+	WORD $0xaa1303f6 // mov    x22, x19
+	WORD $0xb90053e8 // str    w8, [sp, #80]
+	WORD $0xb9407fe8 // ldr    w8, [sp, #124]
+	WORD $0xb9002428 // str    w8, [x1, #36]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xb94029c1 // ldr    w1, [x14, #40]
+	WORD $0xf940b3ee // ldr    x14, [sp, #352]
+	WORD $0xb9002608 // str    w8, [x16, #36]
+	WORD $0xa95243e3 // ldp    x3, x16, [sp, #288]
+	WORD $0xb9402868 // ldr    w8, [x3, #40]
+	WORD $0xb9003be8 // str    w8, [sp, #56]
+	WORD $0xb9406be8 // ldr    w8, [sp, #104]
+	WORD $0xb9002648 // str    w8, [x18, #36]
+	WORD $0xb9402948 // ldr    w8, [x10, #40]
+	WORD $0xf9404fea // ldr    x10, [sp, #152]
+	WORD $0xb9402932 // ldr    w18, [x9, #40]
+	WORD $0xb90043e8 // str    w8, [sp, #64]
+	WORD $0xb9404fe8 // ldr    w8, [sp, #76]
+	WORD $0xb9002548 // str    w8, [x10, #36]
+	WORD $0xb94029c8 // ldr    w8, [x14, #40]
+	WORD $0xb90037e8 // str    w8, [sp, #52]
+	WORD $0xb9404be8 // ldr    w8, [sp, #72]
+	WORD $0xb90026e8 // str    w8, [x23, #36]
+	WORD $0xb9402a08 // ldr    w8, [x16, #40]
+	WORD $0xb9004fe8 // str    w8, [sp, #76]
+	WORD $0xb94067e8 // ldr    w8, [sp, #100]
+	WORD $0xb90025e8 // str    w8, [x15, #36]
+	WORD $0xf9408bef // ldr    x15, [sp, #272]
+	WORD $0xb94029e8 // ldr    w8, [x15, #40]
+	WORD $0xb90067e8 // str    w8, [sp, #100]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9002568 // str    w8, [x11, #36]
+	WORD $0xb9405be8 // ldr    w8, [sp, #88]
+	WORD $0xb9402a6b // ldr    w11, [x19, #40]
+	WORD $0xf9405ff3 // ldr    x19, [sp, #184]
+	WORD $0xb9002708 // str    w8, [x24, #36]
+	WORD $0xb9402848 // ldr    w8, [x2, #40]
+	WORD $0xaa1403f8 // mov    x24, x20
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0xb9407be8 // ldr    w8, [sp, #120]
+	WORD $0xb9002748 // str    w8, [x26, #36]
+	WORD $0xaa0903e8 // mov    x8, x9
+	WORD $0xb94057e9 // ldr    w9, [sp, #84]
+	WORD $0xaa1c03fa // mov    x26, x28
+	WORD $0xb9402d02 // ldr    w2, [x8, #44]
+	WORD $0xaa0403e8 // mov    x8, x4
+	WORD $0xb9002769 // str    w9, [x27, #36]
+	WORD $0xb9402b89 // ldr    w9, [x28, #40]
+	WORD $0xaa0303fb // mov    x27, x3
+	WORD $0x290f2fe9 // stp    w9, w11, [sp, #120]
+	WORD $0xb94077e9 // ldr    w9, [sp, #116]
+	WORD $0xaa1503eb // mov    x11, x21
+	WORD $0xb9002729 // str    w9, [x25, #36]
+	WORD $0xb9402ea9 // ldr    w9, [x21, #44]
+	WORD $0xb9002892 // str    w18, [x4, #40]
+	WORD $0xf94057f2 // ldr    x18, [sp, #168]
+	WORD $0xb9002991 // str    w17, [x12, #40]
+	WORD $0xaa0603e4 // mov    x4, x6
+	WORD $0xb9003fe9 // str    w9, [sp, #60]
+	WORD $0xb9402da9 // ldr    w9, [x13, #44]
+	WORD $0xaa0c03f9 // mov    x25, x12
+	WORD $0xb9402cb1 // ldr    w17, [x5, #44]
+	WORD $0xb9005be9 // str    w9, [sp, #88]
+	WORD $0xb94073e9 // ldr    w9, [sp, #112]
+	WORD $0xa95037ec // ldp    x12, x13, [sp, #256]
+	WORD $0xb9002a49 // str    w9, [x18, #40]
+	WORD $0xb9402fc9 // ldr    w9, [x30, #44]
+	WORD $0xf940abfe // ldr    x30, [sp, #336]
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xb94047e9 // ldr    w9, [sp, #68]
+	WORD $0xb90028c9 // str    w9, [x6, #40]
+	WORD $0xa9581bfc // ldp    x28, x6, [sp, #384]
+	WORD $0xb9402f89 // ldr    w9, [x28, #44]
+	WORD $0xb9006be9 // str    w9, [sp, #104]
+	WORD $0xb94063e9 // ldr    w9, [sp, #96]
+	WORD $0xb9002a89 // str    w9, [x20, #40]
+	WORD $0xb94053e9 // ldr    w9, [sp, #80]
+	WORD $0xa94e57f4 // ldp    x20, x21, [sp, #224]
+	WORD $0xb9002aa9 // str    w9, [x21, #40]
+	WORD $0xb9402cc9 // ldr    w9, [x6, #44]
+	WORD $0xb9002981 // str    w1, [x12, #40]
+	WORD $0xaa1703e1 // mov    x1, x23
+	WORD $0x290bc7e9 // stp    w9, w17, [sp, #92]
+	WORD $0xb9402c69 // ldr    w9, [x3, #44]
+	WORD $0xf94053f1 // ldr    x17, [sp, #160]
+	WORD $0xaa0a03e3 // mov    x3, x10
+	WORD $0xb90033e9 // str    w9, [sp, #48]
+	WORD $0xb9403be9 // ldr    w9, [sp, #56]
+	WORD $0xb9002a29 // str    w9, [x17, #40]
+	WORD $0xb9402fc9 // ldr    w9, [x30, #44]
+	WORD $0xb90077e9 // str    w9, [sp, #116]
+	WORD $0xb94043e9 // ldr    w9, [sp, #64]
+	WORD $0xb9002949 // str    w9, [x10, #40]
+	WORD $0xb94037e9 // ldr    w9, [sp, #52]
+	WORD $0xb9402dca // ldr    w10, [x14, #44]
+	WORD $0xf9406bee // ldr    x14, [sp, #208]
+	WORD $0xb9002ae9 // str    w9, [x23, #40]
+	WORD $0xb9402e09 // ldr    w9, [x16, #44]
+	WORD $0xf940b7f0 // ldr    x16, [sp, #360]
+	WORD $0xaa0303f7 // mov    x23, x3
+	WORD $0x2906abe9 // stp    w9, w10, [sp, #52]
+	WORD $0xb9404fe9 // ldr    w9, [sp, #76]
+	WORD $0xb9402dea // ldr    w10, [x15, #44]
+	WORD $0xb9002a89 // str    w9, [x20, #40]
+	WORD $0xb94067e9 // ldr    w9, [sp, #100]
+	WORD $0xb9002a69 // str    w9, [x19, #40]
+	WORD $0xb9402ec9 // ldr    w9, [x22, #44]
+	WORD $0xaa1c03f6 // mov    x22, x28
+	WORD $0x29082be9 // stp    w9, w10, [sp, #64]
+	WORD $0xb9407fe9 // ldr    w9, [sp, #124]
+	WORD $0xf940bfea // ldr    x10, [sp, #376]
+	WORD $0xb90029a9 // str    w9, [x13, #40]
+	WORD $0xb9402e09 // ldr    w9, [x16, #44]
+	WORD $0xb940294f // ldr    w15, [x10, #40]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xb9406fe9 // ldr    w9, [sp, #108]
+	WORD $0xb90028e9 // str    w9, [x7, #40]
+	WORD $0xb9402f49 // ldr    w9, [x26, #44]
+	WORD $0xf9407ffa // ldr    x26, [sp, #248]
+	WORD $0xb9004be9 // str    w9, [sp, #72]
+	WORD $0xb9407be9 // ldr    w9, [sp, #120]
+	WORD $0xb9002b49 // str    w9, [x26, #40]
+	WORD $0xb9402d49 // ldr    w9, [x10, #44]
+	WORD $0xb90029cf // str    w15, [x14, #40]
+	WORD $0xf940a3ea // ldr    x10, [sp, #320]
+	WORD $0xb9002d02 // str    w2, [x8, #44]
+	WORD $0xb9403168 // ldr    w8, [x11, #48]
+	WORD $0xaa0c03e2 // mov    x2, x12
+	WORD $0xf940afef // ldr    x15, [sp, #344]
+	WORD $0xb9004fe8 // str    w8, [sp, #76]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xb9002f28 // str    w8, [x25, #44]
+	WORD $0xb9403148 // ldr    w8, [x10, #48]
+	WORD $0x290a27e8 // stp    w8, w9, [sp, #80]
+	WORD $0xb9405be8 // ldr    w8, [sp, #88]
+	WORD $0xb9403389 // ldr    w9, [x28, #48]
+	WORD $0xaa0503fc // mov    x28, x5
+	WORD $0xb9002e48 // str    w8, [x18, #44]
+	WORD $0xf9409ff2 // ldr    x18, [sp, #312]
+	WORD $0xb9403248 // ldr    w8, [x18, #48]
+	WORD $0xb9005be8 // str    w8, [sp, #88]
+	WORD $0xb94073e8 // ldr    w8, [sp, #112]
+	WORD $0xb9002c88 // str    w8, [x4, #44]
+	WORD $0xb9406be8 // ldr    w8, [sp, #104]
+	WORD $0xaa0e03e4 // mov    x4, x14
+	WORD $0xb9002f08 // str    w8, [x24, #44]
+	WORD $0xb94030a8 // ldr    w8, [x5, #48]
+	WORD $0xf9408bf8 // ldr    x24, [sp, #272]
+	WORD $0xaa1a03e5 // mov    x5, x26
+	WORD $0xb9006be8 // str    w8, [sp, #104]
+	WORD $0xb94063e8 // ldr    w8, [sp, #96]
+	WORD $0xb9002ea8 // str    w8, [x21, #44]
+	WORD $0xb94030c8 // ldr    w8, [x6, #48]
+	WORD $0x290f27e8 // stp    w8, w9, [sp, #120]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9002d88 // str    w8, [x12, #44]
+	WORD $0xb9403368 // ldr    w8, [x27, #48]
+	WORD $0xa952b3f5 // ldp    x21, x12, [sp, #296]
+	WORD $0xb90073e8 // str    w8, [sp, #112]
+	WORD $0xb94033e8 // ldr    w8, [sp, #48]
+	WORD $0xb9002e28 // str    w8, [x17, #44]
+	WORD $0xb94033c8 // ldr    w8, [x30, #48]
+	WORD $0xb90033e8 // str    w8, [sp, #48]
+	WORD $0xb94077e8 // ldr    w8, [sp, #116]
+	WORD $0xb9002c68 // str    w8, [x3, #44]
+	WORD $0xf940b3e8 // ldr    x8, [sp, #352]
+	WORD $0xaa1303e3 // mov    x3, x19
+	WORD $0x29462109 // ldp    w9, w8, [x8, #48]
+	WORD $0xb90077e9 // str    w9, [sp, #116]
+	WORD $0xb9403be9 // ldr    w9, [sp, #56]
+	WORD $0xb9002c29 // str    w9, [x1, #44]
+	WORD $0xb94032a9 // ldr    w9, [x21, #48]
+	WORD $0xf94077e1 // ldr    x1, [sp, #232]
+	WORD $0xb9003fe9 // str    w9, [sp, #60]
+	WORD $0xb94037e9 // ldr    w9, [sp, #52]
+	WORD $0xb9002e89 // str    w9, [x20, #44]
+	WORD $0xb9403309 // ldr    w9, [x24, #48]
+	WORD $0xb9003be9 // str    w9, [sp, #56]
+	WORD $0xb94047e9 // ldr    w9, [sp, #68]
+	WORD $0xb9002e69 // str    w9, [x19, #44]
+	WORD $0xb9403189 // ldr    w9, [x12, #48]
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0xb94043e9 // ldr    w9, [sp, #64]
+	WORD $0xb90043e8 // str    w8, [sp, #64]
+	WORD $0xb94077e8 // ldr    w8, [sp, #116]
+	WORD $0xb9002da9 // str    w9, [x13, #44]
+	WORD $0xb9403209 // ldr    w9, [x16, #48]
+	WORD $0xb9404bed // ldr    w13, [sp, #72]
+	WORD $0xb90047e9 // str    w9, [sp, #68]
+	WORD $0xb94067e9 // ldr    w9, [sp, #100]
+	WORD $0xb9002ce9 // str    w9, [x7, #44]
+	WORD $0xf940bbe9 // ldr    x9, [sp, #368]
+	WORD $0xb9002f4d // str    w13, [x26, #44]
+	WORD $0xb94031ed // ldr    w13, [x15, #48]
+	WORD $0xa94c6bf4 // ldp    x20, x26, [sp, #192]
+	WORD $0x29464126 // ldp    w6, w16, [x9, #48]
+	WORD $0xb90063ed // str    w13, [sp, #96]
+	WORD $0xb9403569 // ldr    w9, [x11, #52]
+	WORD $0xb94057ed // ldr    w13, [sp, #84]
+	WORD $0xb940364b // ldr    w11, [x18, #52]
+	WORD $0xb9005fe9 // str    w9, [sp, #92]
+	WORD $0xb9404fe9 // ldr    w9, [sp, #76]
+	WORD $0xb9002dcd // str    w13, [x14, #44]
+	WORD $0xb9403772 // ldr    w18, [x27, #52]
+	WORD $0xb9003346 // str    w6, [x26, #48]
+	WORD $0xaa1603ed // mov    x13, x22
+	WORD $0xb9003329 // str    w9, [x25, #48]
+	WORD $0xb9403549 // ldr    w9, [x10, #52]
+	WORD $0xf94057ea // ldr    x10, [sp, #168]
+	WORD $0xaa1803e6 // mov    x6, x24
+	WORD $0xaa0203ee // mov    x14, x2
+	WORD $0xb90037e9 // str    w9, [sp, #52]
+	WORD $0xb94053e9 // ldr    w9, [sp, #80]
+	WORD $0xb9003149 // str    w9, [x10, #48]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xb9003289 // str    w9, [x20, #48]
+	WORD $0xb94036c9 // ldr    w9, [x22, #52]
+	WORD $0xaa1103f6 // mov    x22, x17
+	WORD $0x2909afe9 // stp    w9, w11, [sp, #76]
+	WORD $0xf9404beb // ldr    x11, [sp, #144]
+	WORD $0xb9407fe9 // ldr    w9, [sp, #124]
+	WORD $0xb9003169 // str    w9, [x11, #48]
+	WORD $0xb9403789 // ldr    w9, [x28, #52]
+	WORD $0xf940c7fc // ldr    x28, [sp, #392]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xb9406be9 // ldr    w9, [sp, #104]
+	WORD $0xb9003029 // str    w9, [x1, #48]
+	WORD $0xb9403789 // ldr    w9, [x28, #52]
+	WORD $0xb9004be9 // str    w9, [sp, #72]
+	WORD $0xb9407be9 // ldr    w9, [sp, #120]
+	WORD $0xb9003049 // str    w9, [x2, #48]
+	WORD $0xb94073e9 // ldr    w9, [sp, #112]
+	WORD $0xaa0c03e2 // mov    x2, x12
+	WORD $0xb9003229 // str    w9, [x17, #48]
+	WORD $0xb94037c9 // ldr    w9, [x30, #52]
+	WORD $0xaa1703f1 // mov    x17, x23
+	WORD $0x290acbe9 // stp    w9, w18, [sp, #84]
+	WORD $0xb94033e9 // ldr    w9, [sp, #48]
+	WORD $0xf94087f2 // ldr    x18, [sp, #264]
+	WORD $0xb90032e9 // str    w9, [x23, #48]
+	WORD $0xb9403709 // ldr    w9, [x24, #52]
+	WORD $0xa94ddff3 // ldp    x19, x23, [sp, #216]
+	WORD $0xf940b7f8 // ldr    x24, [sp, #360]
+	WORD $0xb9003268 // str    w8, [x19, #48]
+	WORD $0xb94036a8 // ldr    w8, [x21, #52]
+	WORD $0xb9006be8 // str    w8, [sp, #104]
+	WORD $0xb9403fe8 // ldr    w8, [sp, #60]
+	WORD $0xb90032e8 // str    w8, [x23, #48]
+	WORD $0xb9403be8 // ldr    w8, [sp, #56]
+	WORD $0xb9003068 // str    w8, [x3, #48]
+	WORD $0xb9403588 // ldr    w8, [x12, #52]
+	WORD $0x2904a7e8 // stp    w8, w9, [sp, #36]
+	WORD $0xb9403709 // ldr    w9, [x24, #52]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb90023e9 // str    w9, [sp, #32]
+	WORD $0xb94047e9 // ldr    w9, [sp, #68]
+	WORD $0xb9003248 // str    w8, [x18, #48]
+	WORD $0xf940bfe8 // ldr    x8, [sp, #376]
+	WORD $0xb90030e9 // str    w9, [x7, #48]
+	WORD $0xb94035e9 // ldr    w9, [x15, #52]
+	WORD $0xb940310c // ldr    w12, [x8, #48]
+	WORD $0xaa0103ef // mov    x15, x1
+	WORD $0xb9003be9 // str    w9, [sp, #56]
+	WORD $0xb94063e9 // ldr    w9, [sp, #96]
+	WORD $0xb90030a9 // str    w9, [x5, #48]
+	WORD $0xb9403509 // ldr    w9, [x8, #52]
+	WORD $0xb900308c // str    w12, [x4, #48]
+	WORD $0xaa1c03e5 // mov    x5, x28
+	WORD $0xb9003750 // str    w16, [x26, #52]
+	WORD $0xf9409ffa // ldr    x26, [sp, #312]
+	WORD $0xa95433f0 // ldp    x16, x12, [sp, #320]
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0xaa0803e9 // mov    x9, x8
+	WORD $0xaa1b03e4 // mov    x4, x27
+	WORD $0xb9403988 // ldr    w8, [x12, #56]
+	WORD $0xb90033e8 // str    w8, [sp, #48]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9003728 // str    w8, [x25, #52]
+	WORD $0xb9403a08 // ldr    w8, [x16, #56]
+	WORD $0xaa1203f9 // mov    x25, x18
+	WORD $0xb9007be8 // str    w8, [sp, #120]
+	WORD $0xb94037e8 // ldr    w8, [sp, #52]
+	WORD $0xb9003548 // str    w8, [x10, #52]
+	WORD $0xb9403b48 // ldr    w8, [x26, #56]
+	WORD $0xf9408fea // ldr    x10, [sp, #280]
+	WORD $0xb9005fe8 // str    w8, [sp, #92]
+	WORD $0xb94053e8 // ldr    w8, [sp, #80]
+	WORD $0xb9003688 // str    w8, [x20, #52]
+	WORD $0xb94039a8 // ldr    w8, [x13, #56]
+	WORD $0xaa1e03ed // mov    x13, x30
+	WORD $0xf94057f4 // ldr    x20, [sp, #168]
+	WORD $0xb9007fe8 // str    w8, [sp, #124]
+	WORD $0xb9404fe8 // ldr    w8, [sp, #76]
+	WORD $0xb9003568 // str    w8, [x11, #52]
+	WORD $0x29472948 // ldp    w8, w10, [x10, #56]
+	WORD $0xb9403b8b // ldr    w11, [x28, #56]
+	WORD $0xb90047e8 // str    w8, [sp, #68]
+	WORD $0xb94067e8 // ldr    w8, [sp, #100]
+	WORD $0xb9003428 // str    w8, [x1, #52]
+	WORD $0xb9404be8 // ldr    w8, [sp, #72]
+	WORD $0xb90035c8 // str    w8, [x14, #52]
+	WORD $0xb9403b68 // ldr    w8, [x27, #56]
+	WORD $0xb9003fe8 // str    w8, [sp, #60]
+	WORD $0xb9405be8 // ldr    w8, [sp, #88]
+	WORD $0xb90036c8 // str    w8, [x22, #52]
+	WORD $0xb9403bc8 // ldr    w8, [x30, #56]
+	WORD $0xa95587fe // ldp    x30, x1, [sp, #344]
+	WORD $0xb9403e16 // ldr    w22, [x16, #60]
+	WORD $0x290e2fe8 // stp    w8, w11, [sp, #112]
+	WORD $0xb94057e8 // ldr    w8, [sp, #84]
+	WORD $0xb9402beb // ldr    w11, [sp, #40]
+	WORD $0xb9003628 // str    w8, [x17, #52]
+	WORD $0xb9403828 // ldr    w8, [x1, #56]
+	WORD $0xaa0603f1 // mov    x17, x6
+	WORD $0xb9004be8 // str    w8, [sp, #72]
+	WORD $0xb94043e8 // ldr    w8, [sp, #64]
+	WORD $0xb9003668 // str    w8, [x19, #52]
+	WORD $0xb9403aa8 // ldr    w8, [x21, #56]
+	WORD $0xa94f4ffc // ldp    x28, x19, [sp, #240]
+	WORD $0xb90043e8 // str    w8, [sp, #64]
+	WORD $0xb9406be8 // ldr    w8, [sp, #104]
+	WORD $0xb90036e8 // str    w8, [x23, #52]
+	WORD $0xb94038c8 // ldr    w8, [x6, #56]
+	WORD $0xb900346b // str    w11, [x3, #52]
+	WORD $0xb940384b // ldr    w11, [x2, #56]
+	WORD $0xa94ceff7 // ldp    x23, x27, [sp, #200]
+	WORD $0xb9002fe8 // str    w8, [sp, #44]
+	WORD $0xaa0303e8 // mov    x8, x3
+	WORD $0xb90063eb // str    w11, [sp, #96]
+	WORD $0xf94083e3 // ldr    x3, [sp, #256]
+	WORD $0x29442fee // ldp    w14, w11, [sp, #32]
+	WORD $0xa94943e2 // ldp    x2, x16, [sp, #144]
+	WORD $0xb900364b // str    w11, [x18, #52]
+	WORD $0xb9403bf2 // ldr    w18, [sp, #56]
+	WORD $0xb90034ee // str    w14, [x7, #52]
+	WORD $0xf940bbee // ldr    x14, [sp, #368]
+	WORD $0xb9403b0b // ldr    w11, [x24, #56]
+	WORD $0xb9003672 // str    w18, [x19, #52]
+	WORD $0xb9403bd2 // ldr    w18, [x30, #56]
+	WORD $0x294739c6 // ldp    w6, w14, [x14, #56]
+	WORD $0xb90037eb // str    w11, [sp, #52]
+	WORD $0xaa1803eb // mov    x11, x24
+	WORD $0xb9004ff2 // str    w18, [sp, #76]
+	WORD $0xb9406ff2 // ldr    w18, [sp, #108]
+	WORD $0xaa0703f8 // mov    x24, x7
+	WORD $0xf94063e7 // ldr    x7, [sp, #192]
+	WORD $0xb9003772 // str    w18, [x27, #52]
+	WORD $0xf94053f2 // ldr    x18, [sp, #160]
+	WORD $0xb9003ae6 // str    w6, [x23, #56]
+	WORD $0xb9403d86 // ldr    w6, [x12, #60]
+	WORD $0xb94033ec // ldr    w12, [sp, #48]
+	WORD $0xb9003b8c // str    w12, [x28, #56]
+	WORD $0xb9407bec // ldr    w12, [sp, #120]
+	WORD $0xb9007bea // str    w10, [sp, #120]
+	WORD $0xb94047ea // ldr    w10, [sp, #68]
+	WORD $0xb9003a8c // str    w12, [x20, #56]
+	WORD $0xb9403f4c // ldr    w12, [x26, #60]
+	WORD $0xb90053ec // str    w12, [sp, #80]
+	WORD $0xb9405fec // ldr    w12, [sp, #92]
+	WORD $0xb90038ec // str    w12, [x7, #56]
+	WORD $0xf940c3ec // ldr    x12, [sp, #384]
+	WORD $0xb9403d8c // ldr    w12, [x12, #60]
+	WORD $0xb90057ec // str    w12, [sp, #84]
+	WORD $0xb9407fec // ldr    w12, [sp, #124]
+	WORD $0xb900384c // str    w12, [x2, #56]
+	WORD $0xb940392c // ldr    w12, [x9, #56]
+	WORD $0xb90039ea // str    w10, [x15, #56]
+	WORD $0xb9403caa // ldr    w10, [x5, #60]
+	WORD $0xb9403ea5 // ldr    w5, [x21, #60]
+	WORD $0xb9005bea // str    w10, [sp, #88]
+	WORD $0xb94077ea // ldr    w10, [sp, #116]
+	WORD $0xb900386a // str    w10, [x3, #56]
+	WORD $0xb9403c8a // ldr    w10, [x4, #60]
+	WORD $0xb90067ea // str    w10, [sp, #100]
+	WORD $0xb9403fea // ldr    w10, [sp, #60]
+	WORD $0xb9003a4a // str    w10, [x18, #56]
+	WORD $0xb9403daa // ldr    w10, [x13, #60]
+	WORD $0xaa1203ed // mov    x13, x18
+	WORD $0xb9005fea // str    w10, [sp, #92]
+	WORD $0xb94073ea // ldr    w10, [sp, #112]
+	WORD $0xb9003a0a // str    w10, [x16, #56]
+	WORD $0xb9403c2a // ldr    w10, [x1, #60]
+	WORD $0xa94d93e1 // ldp    x1, x4, [sp, #216]
+	WORD $0xb90073ea // str    w10, [sp, #112]
+	WORD $0xb9404bea // ldr    w10, [sp, #72]
+	WORD $0xb900382a // str    w10, [x1, #56]
+	WORD $0xb94043ea // ldr    w10, [sp, #64]
+	WORD $0xb900388a // str    w10, [x4, #56]
+	WORD $0xb9403e2a // ldr    w10, [x17, #60]
+	WORD $0xb9006bea // str    w10, [sp, #104]
+	WORD $0xb9402fea // ldr    w10, [sp, #44]
+	WORD $0xb900390a // str    w10, [x8, #56]
+	WORD $0xf9409bea // ldr    x10, [sp, #304]
+	WORD $0xb9403d48 // ldr    w8, [x10, #60]
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0xb94063e8 // ldr    w8, [sp, #96]
+	WORD $0xb9003b28 // str    w8, [x25, #56]
+	WORD $0xaa0903e8 // mov    x8, x9
+	WORD $0xb9403d69 // ldr    w9, [x11, #60]
+	WORD $0xb9403fcb // ldr    w11, [x30, #60]
+	WORD $0xb9403d08 // ldr    w8, [x8, #60]
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xb94037e9 // ldr    w9, [sp, #52]
+	WORD $0xb90077eb // str    w11, [sp, #116]
+	WORD $0xaa0303eb // mov    x11, x3
+	WORD $0xb9007fe8 // str    w8, [sp, #124]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb9003b09 // str    w9, [x24, #56]
+	WORD $0xb9404fe9 // ldr    w9, [sp, #76]
+	WORD $0xf9405ffe // ldr    x30, [sp, #184]
+	WORD $0xb9404515 // ldr    w21, [x8, #68]
+	WORD $0xb9003a69 // str    w9, [x19, #56]
+	WORD $0xb9404149 // ldr    w9, [x10, #64]
+	WORD $0xb9404113 // ldr    w19, [x8, #64]
+	WORD $0xb9003b6c // str    w12, [x27, #56]
+	WORD $0x294a23ea // ldp    w10, w8, [sp, #80]
+	WORD $0xb9003eee // str    w14, [x23, #60]
+	WORD $0xb9003f86 // str    w6, [x28, #60]
+	WORD $0xb9003e96 // str    w22, [x20, #60]
+	WORD $0xb94073ec // ldr    w12, [sp, #112]
+	WORD $0xb9003cea // str    w10, [x7, #60]
+	WORD $0xb9407bea // ldr    w10, [sp, #120]
+	WORD $0xb9003c48 // str    w8, [x2, #60]
+	WORD $0xf940a7e8 // ldr    x8, [sp, #328]
+	WORD $0xaa1903fc // mov    x28, x25
+	WORD $0xaa0203ee // mov    x14, x2
+	WORD $0xb9003dea // str    w10, [x15, #60]
+	WORD $0xb94067ea // ldr    w10, [sp, #100]
+	WORD $0x29485116 // ldp    w22, w20, [x8, #64]
+	WORD $0xaa0403f7 // mov    x23, x4
+	WORD $0xb9405be8 // ldr    w8, [sp, #88]
+	WORD $0xb940435b // ldr    w27, [x26, #64]
+	WORD $0xb9003c68 // str    w8, [x3, #60]
+	WORD $0xf940a3e8 // ldr    x8, [sp, #320]
+	WORD $0xb9003e4a // str    w10, [x18, #60]
+	WORD $0xaa1003ea // mov    x10, x16
+	WORD $0x29482111 // ldp    w17, w8, [x8, #64]
+	WORD $0xb9007be8 // str    w8, [sp, #120]
+	WORD $0xb9405fe8 // ldr    w8, [sp, #92]
+	WORD $0xb9003e08 // str    w8, [x16, #60]
+	WORD $0xb9406bf0 // ldr    w16, [sp, #104]
+	WORD $0xb9003c2c // str    w12, [x1, #60]
+	WORD $0xb940474c // ldr    w12, [x26, #68]
+	WORD $0xb9003c85 // str    w5, [x4, #60]
+	WORD $0xaa0103e8 // mov    x8, x1
+	WORD $0xb9003fd0 // str    w16, [x30, #60]
+	WORD $0xb94063f0 // ldr    w16, [sp, #96]
+	WORD $0xb90073ec // str    w12, [sp, #112]
+	WORD $0xb9407fe1 // ldr    w1, [sp, #124]
+	WORD $0xa9584bec // ldp    x12, x18, [sp, #384]
+	WORD $0xa94cebe5 // ldp    x5, x26, [sp, #200]
+	WORD $0x29483183 // ldp    w3, w12, [x12, #64]
+	WORD $0xf940abe4 // ldr    x4, [sp, #336]
+	WORD $0xb9006bec // str    w12, [sp, #104]
+	WORD $0xb9406fec // ldr    w12, [sp, #108]
+	WORD $0xb9003f2c // str    w12, [x25, #60]
+	WORD $0xf9408fec // ldr    x12, [sp, #280]
+	WORD $0xb9003f10 // str    w16, [x24, #60]
+	WORD $0xa94f43e6 // ldp    x6, x16, [sp, #240]
+	WORD $0x29483199 // ldp    w25, w12, [x12, #64]
+	WORD $0xb90063ec // str    w12, [sp, #96]
+	WORD $0xb94077ec // ldr    w12, [sp, #116]
+	WORD $0xb9003e0c // str    w12, [x16, #60]
+	WORD $0x29484a4c // ldp    w12, w18, [x18, #64]
+	WORD $0xb9003f41 // str    w1, [x26, #60]
+	WORD $0xb90040b3 // str    w19, [x5, #64]
+	WORD $0xaa0703e1 // mov    x1, x7
+	WORD $0xb90040d6 // str    w22, [x6, #64]
+	WORD $0xaa1e03f6 // mov    x22, x30
+	WORD $0xb9007ff2 // str    w18, [sp, #124]
+	WORD $0xf94093f2 // ldr    x18, [sp, #288]
+	WORD $0x29484a42 // ldp    w2, w18, [x18, #64]
+	WORD $0xb9006ff2 // str    w18, [sp, #108]
+	WORD $0xf94057f2 // ldr    x18, [sp, #168]
+	WORD $0xb9004251 // str    w17, [x18, #64]
+	WORD $0xb9404091 // ldr    w17, [x4, #64]
+	WORD $0xb90040fb // str    w27, [x7, #64]
+	WORD $0xb9404487 // ldr    w7, [x4, #68]
+	WORD $0xb90041c3 // str    w3, [x14, #64]
+	WORD $0xf940b3e4 // ldr    x4, [sp, #352]
+	WORD $0xb90041f9 // str    w25, [x15, #64]
+	WORD $0xaa0b03f9 // mov    x25, x11
+	WORD $0xb900416c // str    w12, [x11, #64]
+	WORD $0xf94097ec // ldr    x12, [sp, #296]
+	WORD $0xb9404083 // ldr    w3, [x4, #64]
+	WORD $0xb90041a2 // str    w2, [x13, #64]
+	WORD $0xb9004151 // str    w17, [x10, #64]
+	WORD $0xf940afe2 // ldr    x2, [sp, #344]
+	WORD $0x2948318b // ldp    w11, w12, [x12, #64]
+	WORD $0xb9004103 // str    w3, [x8, #64]
+	WORD $0xf940b7e3 // ldr    x3, [sp, #360]
+	WORD $0xb90042eb // str    w11, [x23, #64]
+	WORD $0xb9404484 // ldr    w4, [x4, #68]
+	WORD $0xb9005fec // str    w12, [sp, #92]
+	WORD $0xf9408bec // ldr    x12, [sp, #272]
+	WORD $0x29480c6b // ldp    w11, w3, [x3, #64]
+	WORD $0xb90067e4 // str    w4, [sp, #100]
+	WORD $0x29482191 // ldp    w17, w8, [x12, #64]
+	WORD $0xb9005be8 // str    w8, [sp, #88]
+	WORD $0xf940bfe8 // ldr    x8, [sp, #376]
+	WORD $0xb90043d1 // str    w17, [x30, #64]
+	WORD $0xb9404051 // ldr    w17, [x2, #64]
+	WORD $0xb9004389 // str    w9, [x28, #64]
+	WORD $0xaa0e03fc // mov    x28, x14
+	WORD $0xb940410c // ldr    w12, [x8, #64]
+	WORD $0xb900430b // str    w11, [x24, #64]
+	WORD $0xb9004211 // str    w17, [x16, #64]
+	WORD $0xb9404513 // ldr    w19, [x8, #68]
+	WORD $0xaa0503e8 // mov    x8, x5
+	WORD $0xb94073f1 // ldr    w17, [sp, #112]
+	WORD $0xb900434c // str    w12, [x26, #64]
+	WORD $0xb9406bee // ldr    w14, [sp, #104]
+	WORD $0xb90044b5 // str    w21, [x5, #68]
+	WORD $0xf9409be5 // ldr    x5, [sp, #304]
+	WORD $0xb90044d4 // str    w20, [x6, #68]
+	WORD $0xb94063e9 // ldr    w9, [sp, #96]
+	WORD $0xb940444b // ldr    w11, [x2, #68]
+	WORD $0xaa0f03fe // mov    x30, x15
+	WORD $0x2948c0ac // ldp    w12, w16, [x5, #68]
+	WORD $0xaa1703f5 // mov    x21, x23
+	WORD $0xaa0503e6 // mov    x6, x5
+	WORD $0xf940c3e5 // ldr    x5, [sp, #384]
+	WORD $0xb90077f0 // str    w16, [sp, #116]
+	WORD $0xb9407bf0 // ldr    w16, [sp, #120]
+	WORD $0xb9004650 // str    w16, [x18, #68]
+	WORD $0xaa1203f0 // mov    x16, x18
+	WORD $0xb9004431 // str    w17, [x1, #68]
+	WORD $0xf940bbf2 // ldr    x18, [sp, #368]
+	WORD $0xb900478e // str    w14, [x28, #68]
+	WORD $0xf940a7ee // ldr    x14, [sp, #328]
+	WORD $0xb90045e9 // str    w9, [x15, #68]
+	WORD $0xb9406fe9 // ldr    w9, [sp, #108]
+	WORD $0x29490a5b // ldp    w27, w2, [x18, #72]
+	WORD $0xaa1903e1 // mov    x1, x25
+	WORD $0x294911d4 // ldp    w20, w4, [x14, #72]
+	WORD $0xb9407fee // ldr    w14, [sp, #124]
+	WORD $0xaa0a03f2 // mov    x18, x10
+	WORD $0xf940a3ef // ldr    x15, [sp, #320]
+	WORD $0xb900472e // str    w14, [x25, #68]
+	WORD $0xaa0d03f9 // mov    x25, x13
+	WORD $0xb90045a9 // str    w9, [x13, #68]
+	WORD $0xb94067e9 // ldr    w9, [sp, #100]
+	WORD $0xb9004547 // str    w7, [x10, #68]
+	WORD $0xf9406fea // ldr    x10, [sp, #216]
+	WORD $0xb9404ded // ldr    w13, [x15, #76]
+	WORD $0xf9407fe7 // ldr    x7, [sp, #248]
+	WORD $0xb9004549 // str    w9, [x10, #68]
+	WORD $0xb9405fe9 // ldr    w9, [sp, #92]
+	WORD $0xb9007bed // str    w13, [sp, #120]
+	WORD $0xf9409fed // ldr    x13, [sp, #312]
+	WORD $0xb94049ee // ldr    w14, [x15, #72]
+	WORD $0xb90046e9 // str    w9, [x23, #68]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xf94087f7 // ldr    x23, [sp, #264]
+	WORD $0xb94049af // ldr    w15, [x13, #72]
+	WORD $0xb90046c9 // str    w9, [x22, #68]
+	WORD $0xb9404db1 // ldr    w17, [x13, #76]
+	WORD $0xb90046ec // str    w12, [x23, #68]
+	WORD $0xb94048ad // ldr    w13, [x5, #72]
+	WORD $0xb9004703 // str    w3, [x24, #68]
+	WORD $0xf940c7e3 // ldr    x3, [sp, #392]
+	WORD $0xb9404ca9 // ldr    w9, [x5, #76]
+	WORD $0xb90044eb // str    w11, [x7, #68]
+	WORD $0xf9408fe5 // ldr    x5, [sp, #280]
+	WORD $0xb9004753 // str    w19, [x26, #68]
+	WORD $0xb940486b // ldr    w11, [x3, #72]
+	WORD $0xb900491b // str    w27, [x8, #72]
+	WORD $0xb9404c63 // ldr    w3, [x3, #76]
+	WORD $0xb9006fe9 // str    w9, [sp, #108]
+	WORD $0x294924ac // ldp    w12, w9, [x5, #72]
+	WORD $0xaa0803fb // mov    x27, x8
+	WORD $0xf9407be8 // ldr    x8, [sp, #240]
+	WORD $0xb9007fe3 // str    w3, [sp, #124]
+	WORD $0xf94093e3 // ldr    x3, [sp, #288]
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xb9004914 // str    w20, [x8, #72]
+	WORD $0xaa1003f4 // mov    x20, x16
+	WORD $0xb9404c69 // ldr    w9, [x3, #76]
+	WORD $0xb9004a0e // str    w14, [x16, #72]
+	WORD $0xf940abf0 // ldr    x16, [sp, #336]
+	WORD $0xaa1a03e5 // mov    x5, x26
+	WORD $0xb940487a // ldr    w26, [x3, #72]
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xf94063e3 // ldr    x3, [sp, #192]
+	WORD $0x2949260e // ldp    w14, w9, [x16, #72]
+	WORD $0xb900486f // str    w15, [x3, #72]
+	WORD $0xf94097ef // ldr    x15, [sp, #296]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xf940b3e9 // ldr    x9, [sp, #352]
+	WORD $0xb9004b8d // str    w13, [x28, #72]
+	WORD $0xb9004bcc // str    w12, [x30, #72]
+	WORD $0xaa1e03ec // mov    x12, x30
+	WORD $0xb940492d // ldr    w13, [x9, #72]
+	WORD $0xb900482b // str    w11, [x1, #72]
+	WORD $0xb94049eb // ldr    w11, [x15, #72]
+	WORD $0xb9004b3a // str    w26, [x25, #72]
+	WORD $0xb9404dfe // ldr    w30, [x15, #76]
+	WORD $0xb9004a4e // str    w14, [x18, #72]
+	WORD $0xf9408bef // ldr    x15, [sp, #272]
+	WORD $0xb900494d // str    w13, [x10, #72]
+	WORD $0xb9004aab // str    w11, [x21, #72]
+	WORD $0xf940b7ed // ldr    x13, [sp, #360]
+	WORD $0xaa1703fa // mov    x26, x23
+	WORD $0xaa1903e1 // mov    x1, x25
+	WORD $0x294929ee // ldp    w14, w10, [x15, #72]
+	WORD $0xaa1403f9 // mov    x25, x20
+	WORD $0xaa0103f5 // mov    x21, x1
+	WORD $0xf940afef // ldr    x15, [sp, #344]
+	WORD $0xb9005fea // str    w10, [sp, #92]
+	WORD $0xb94077ea // ldr    w10, [sp, #116]
+	WORD $0xb9004ace // str    w14, [x22, #72]
+	WORD $0xb94049ab // ldr    w11, [x13, #72]
+	WORD $0xb94049ee // ldr    w14, [x15, #72]
+	WORD $0xaa0503f6 // mov    x22, x5
+	WORD $0xb9004aea // str    w10, [x23, #72]
+	WORD $0xf940bfea // ldr    x10, [sp, #376]
+	WORD $0xb9004b0b // str    w11, [x24, #72]
+	WORD $0xb9404deb // ldr    w11, [x15, #76]
+	WORD $0xb90048ee // str    w14, [x7, #72]
+	WORD $0xf94083f7 // ldr    x23, [sp, #256]
+	WORD $0x29493950 // ldp    w16, w14, [x10, #72]
+	WORD $0xaa1203e7 // mov    x7, x18
+	WORD $0xaa0603ea // mov    x10, x6
+	WORD $0xb94063ea // ldr    w10, [sp, #96]
+	WORD $0xb90077eb // str    w11, [sp, #116]
+	WORD $0xb90048b0 // str    w16, [x5, #72]
+	WORD $0xb9404d29 // ldr    w9, [x9, #76]
+	WORD $0xb9004f62 // str    w2, [x27, #76]
+	WORD $0xaa0303e2 // mov    x2, x3
+	WORD $0xb9004d04 // str    w4, [x8, #76]
+	WORD $0x2949a0d0 // ldp    w16, w8, [x6, #76]
+	WORD $0xaa0c03f8 // mov    x24, x12
+	WORD $0xb9404dad // ldr    w13, [x13, #76]
+	WORD $0xaa1c03e6 // mov    x6, x28
+	WORD $0xb9006be8 // str    w8, [sp, #104]
+	WORD $0xb9407be8 // ldr    w8, [sp, #120]
+	WORD $0xf940c3eb // ldr    x11, [sp, #384]
+	WORD $0xaa1603e4 // mov    x4, x22
+	WORD $0xb9004e88 // str    w8, [x20, #76]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb9004c71 // str    w17, [x3, #76]
+	WORD $0x294a4d0f // ldp    w15, w19, [x8, #80]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb9004f88 // str    w8, [x28, #76]
+	WORD $0xf940a7e8 // ldr    x8, [sp, #328]
+	WORD $0xb9004d8a // str    w10, [x12, #76]
+	WORD $0xb94073ea // ldr    w10, [sp, #112]
+	WORD $0xaa1a03fc // mov    x28, x26
+	WORD $0x294a1503 // ldp    w3, w5, [x8, #80]
+	WORD $0xb9407fe8 // ldr    w8, [sp, #124]
+	WORD $0xb9004ee8 // str    w8, [x23, #76]
+	WORD $0xf940a3e8 // ldr    x8, [sp, #320]
+	WORD $0xb9004c2a // str    w10, [x1, #76]
+	WORD $0xa94dabf4 // ldp    x20, x10, [sp, #216]
+	WORD $0x294a2111 // ldp    w17, w8, [x8, #80]
+	WORD $0xb9007be8 // str    w8, [sp, #120]
+	WORD $0xb94067e8 // ldr    w8, [sp, #100]
+	WORD $0xb9004e48 // str    w8, [x18, #76]
+	WORD $0xf9409fe8 // ldr    x8, [sp, #312]
+	WORD $0xb9004e89 // str    w9, [x20, #76]
+	WORD $0xb9405fe9 // ldr    w9, [sp, #92]
+	WORD $0xb9004d5e // str    w30, [x10, #76]
+	WORD $0xb9405172 // ldr    w18, [x11, #80]
+	WORD $0x294a2101 // ldp    w1, w8, [x8, #80]
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0xf9405fe8 // ldr    x8, [sp, #184]
+	WORD $0xb9004d09 // str    w9, [x8, #76]
+	WORD $0xb9405569 // ldr    w9, [x11, #84]
+	WORD $0xb9004f50 // str    w16, [x26, #76]
+	WORD $0xf9405bf0 // ldr    x16, [sp, #176]
+	WORD $0xf9408feb // ldr    x11, [sp, #280]
+	WORD $0xaa1703fa // mov    x26, x23
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xb9004e0d // str    w13, [x16, #76]
+	WORD $0xf940c7ed // ldr    x13, [sp, #392]
+	WORD $0x294a257e // ldp    w30, w9, [x11, #80]
+	WORD $0x294a35ac // ldp    w12, w13, [x13, #80]
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xf9407feb // ldr    x11, [sp, #248]
+	WORD $0xb94077e9 // ldr    w9, [sp, #116]
+	WORD $0xb9007fed // str    w13, [sp, #124]
+	WORD $0xf94093ed // ldr    x13, [sp, #288]
+	WORD $0xb9004d69 // str    w9, [x11, #76]
+	WORD $0xb9004ece // str    w14, [x22, #76]
+	WORD $0xf9407bee // ldr    x14, [sp, #240]
+	WORD $0xb900536f // str    w15, [x27, #80]
+	WORD $0x294a35af // ldp    w15, w13, [x13, #80]
+	WORD $0xaa1b03f6 // mov    x22, x27
+	WORD $0xb90051c3 // str    w3, [x14, #80]
+	WORD $0xaa1903e3 // mov    x3, x25
+	WORD $0xb9005331 // str    w17, [x25, #80]
+	WORD $0xaa0b03fb // mov    x27, x11
+	WORD $0xb90073ed // str    w13, [sp, #112]
+	WORD $0xf940abed // ldr    x13, [sp, #336]
+	WORD $0xb9005041 // str    w1, [x2, #80]
+	WORD $0xaa0203e1 // mov    x1, x2
+	WORD $0xb90050d2 // str    w18, [x6, #80]
+	WORD $0xaa0603f9 // mov    x25, x6
+	WORD $0xb94051b1 // ldr    w17, [x13, #80]
+	WORD $0xb900531e // str    w30, [x24, #80]
+	WORD $0xb94055a9 // ldr    w9, [x13, #84]
+	WORD $0xb90052ec // str    w12, [x23, #80]
+	WORD $0xf940b3ed // ldr    x13, [sp, #352]
+	WORD $0xb90052af // str    w15, [x21, #80]
+	WORD $0xb90050f1 // str    w17, [x7, #80]
+	WORD $0xaa0a03fe // mov    x30, x10
+	WORD $0xaa0703ef // mov    x15, x7
+	WORD $0xaa0e03e7 // mov    x7, x14
+	WORD $0x294a35b2 // ldp    w18, w13, [x13, #80]
+	WORD $0xaa0103f7 // mov    x23, x1
+	WORD $0xb9005292 // str    w18, [x20, #80]
+	WORD $0xb90077ed // str    w13, [sp, #116]
+	WORD $0xf94097ed // ldr    x13, [sp, #296]
+	WORD $0x294a35ac // ldp    w12, w13, [x13, #80]
+	WORD $0xb900514c // str    w12, [x10, #80]
+	WORD $0xb9406bec // ldr    w12, [sp, #104]
+	WORD $0xb9005fed // str    w13, [sp, #92]
+	WORD $0xf9408bed // ldr    x13, [sp, #272]
+	WORD $0x294a35b1 // ldp    w17, w13, [x13, #80]
+	WORD $0xb9005111 // str    w17, [x8, #80]
+	WORD $0xf940afe8 // ldr    x8, [sp, #344]
+	WORD $0xb9005bed // str    w13, [sp, #88]
+	WORD $0xf940b7ed // ldr    x13, [sp, #360]
+	WORD $0xb900538c // str    w12, [x28, #80]
+	WORD $0xf940bfec // ldr    x12, [sp, #376]
+	WORD $0x294a2111 // ldp    w17, w8, [x8, #80]
+	WORD $0xaa1903fc // mov    x28, x25
+	WORD $0xb94051aa // ldr    w10, [x13, #80]
+	WORD $0xb9405182 // ldr    w2, [x12, #80]
+	WORD $0xb90057e8 // str    w8, [sp, #84]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb900520a // str    w10, [x16, #80]
+	WORD $0xb9405586 // ldr    w6, [x12, #84]
+	WORD $0xb9005171 // str    w17, [x11, #80]
+	WORD $0xb94055b2 // ldr    w18, [x13, #84]
+	WORD $0xb9005082 // str    w2, [x4, #80]
+	WORD $0x294a890b // ldp    w11, w2, [x8, #84]
+	WORD $0xb90056d3 // str    w19, [x22, #84]
+	WORD $0x294ea3ed // ldp    w13, w8, [sp, #116]
+	WORD $0xb90055c5 // str    w5, [x14, #84]
+	WORD $0x294db3ea // ldp    w10, w12, [sp, #108]
+	WORD $0xb9005468 // str    w8, [x3, #84]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xf9406be5 // ldr    x5, [sp, #208]
+	WORD $0xb900542a // str    w10, [x1, #84]
+	WORD $0x294b2110 // ldp    w16, w8, [x8, #88]
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0x294c23ea // ldp    w10, w8, [sp, #96]
+	WORD $0xb9005728 // str    w8, [x25, #84]
+	WORD $0xf940a7e8 // ldr    x8, [sp, #328]
+	WORD $0xb900570a // str    w10, [x24, #84]
+	WORD $0xaa1503ea // mov    x10, x21
+	WORD $0x294b1111 // ldp    w17, w4, [x8, #88]
+	WORD $0xb9407fe8 // ldr    w8, [sp, #124]
+	WORD $0xb9005748 // str    w8, [x26, #84]
+	WORD $0xf940a3e8 // ldr    x8, [sp, #320]
+	WORD $0xb90056ac // str    w12, [x21, #84]
+	WORD $0xaa1403ec // mov    x12, x20
+	WORD $0xb90055e9 // str    w9, [x15, #84]
+	WORD $0xb940590e // ldr    w14, [x8, #88]
+	WORD $0xb900568d // str    w13, [x20, #84]
+	WORD $0xb9405d09 // ldr    w9, [x8, #92]
+	WORD $0xf940c3ed // ldr    x13, [sp, #384]
+	WORD $0xf9409fe8 // ldr    x8, [sp, #312]
+	WORD $0xb94059b4 // ldr    w20, [x13, #88]
+	WORD $0x294b2101 // ldp    w1, w8, [x8, #88]
+	WORD $0x290ca7e8 // stp    w8, w9, [sp, #100]
+	WORD $0x294b23e9 // ldp    w9, w8, [sp, #88]
+	WORD $0xb90057c8 // str    w8, [x30, #84]
+	WORD $0xa94b23f3 // ldp    x19, x8, [sp, #176]
+	WORD $0xb9005509 // str    w9, [x8, #84]
+	WORD $0xb9405da9 // ldr    w9, [x13, #92]
+	WORD $0xf94087ed // ldr    x13, [sp, #264]
+	WORD $0xb90077e9 // str    w9, [sp, #116]
+	WORD $0xb90055ab // str    w11, [x13, #84]
+	WORD $0xf9408feb // ldr    x11, [sp, #280]
+	WORD $0xb9005672 // str    w18, [x19, #84]
+	WORD $0xf940c7f2 // ldr    x18, [sp, #392]
+	WORD $0x294b2575 // ldp    w21, w9, [x11, #88]
+	WORD $0xb9405a59 // ldr    w25, [x18, #88]
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xb94057e9 // ldr    w9, [sp, #84]
+	WORD $0xb9005769 // str    w9, [x27, #84]
+	WORD $0xb9405e49 // ldr    w9, [x18, #92]
+	WORD $0xf94093f2 // ldr    x18, [sp, #288]
+	WORD $0xb90054a6 // str    w6, [x5, #84]
+	WORD $0xb9005ad0 // str    w16, [x22, #88]
+	WORD $0xaa0a03e6 // mov    x6, x10
+	WORD $0xb90058f1 // str    w17, [x7, #88]
+	WORD $0xaa1703f1 // mov    x17, x23
+	WORD $0xb9405a50 // ldr    w16, [x18, #88]
+	WORD $0xb900586e // str    w14, [x3, #88]
+	WORD $0xb9405e4b // ldr    w11, [x18, #92]
+	WORD $0xb9005ae1 // str    w1, [x23, #88]
+	WORD $0xf940abf2 // ldr    x18, [sp, #336]
+	WORD $0xb9005b94 // str    w20, [x28, #88]
+	WORD $0xb9005b15 // str    w21, [x24, #88]
+	WORD $0xb9005b59 // str    w25, [x26, #88]
+	WORD $0xaa0803f5 // mov    x21, x8
+	WORD $0xb9405a4e // ldr    w14, [x18, #88]
+	WORD $0xb9005950 // str    w16, [x10, #88]
+	WORD $0xb9405e52 // ldr    w18, [x18, #92]
+	WORD $0xaa1b03f8 // mov    x24, x27
+	WORD $0xf9408bea // ldr    x10, [sp, #272]
+	WORD $0xaa1e03f4 // mov    x20, x30
+	WORD $0xb90059ee // str    w14, [x15, #88]
+	WORD $0xa95587f0 // ldp    x16, x1, [sp, #344]
+	WORD $0x290f2ff2 // stp    w18, w11, [sp, #120]
+	WORD $0x294b0432 // ldp    w18, w1, [x1, #88]
+	WORD $0x294b294e // ldp    w14, w10, [x10, #88]
+	WORD $0xb9005992 // str    w18, [x12, #88]
+	WORD $0x290b87ea // stp    w10, w1, [sp, #92]
+	WORD $0xf94097e1 // ldr    x1, [sp, #296]
+	WORD $0xaa0603f2 // mov    x18, x6
+	WORD $0x294b6437 // ldp    w23, w25, [x1, #88]
+	WORD $0xaa0f03e1 // mov    x1, x15
+	WORD $0xf940b7ef // ldr    x15, [sp, #360]
+	WORD $0xb9005bd7 // str    w23, [x30, #88]
+	WORD $0xb9405e1e // ldr    w30, [x16, #92]
+	WORD $0xb900590e // str    w14, [x8, #88]
+	WORD $0xf940bfe8 // ldr    x8, [sp, #376]
+	WORD $0xb94059ea // ldr    w10, [x15, #88]
+	WORD $0xb90059a2 // str    w2, [x13, #88]
+	WORD $0xb9405a0e // ldr    w14, [x16, #88]
+	WORD $0xaa1103f0 // mov    x16, x17
+	WORD $0xb9405902 // ldr    w2, [x8, #88]
+	WORD $0xaa0503f7 // mov    x23, x5
+	WORD $0xb9005a6a // str    w10, [x19, #88]
+	WORD $0xb9405d0a // ldr    w10, [x8, #92]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb9005b6e // str    w14, [x27, #88]
+	WORD $0xb90058a2 // str    w2, [x5, #88]
+	WORD $0xaa0303fb // mov    x27, x3
+	WORD $0xb9407fe5 // ldr    w5, [sp, #124]
+	WORD $0xb9005ec8 // str    w8, [x22, #92]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb9005ce4 // str    w4, [x7, #92]
+	WORD $0xb9405def // ldr    w15, [x15, #92]
+	WORD $0xaa1503e7 // mov    x7, x21
+	WORD $0x294b891a // ldp    w26, w2, [x8, #92]
+	WORD $0x294ca3eb // ldp    w11, w8, [sp, #100]
+	WORD $0xb9005c68 // str    w8, [x3, #92]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb9005e2b // str    w11, [x17, #92]
+	WORD $0xf94077eb // ldr    x11, [sp, #232]
+	WORD $0x294c2103 // ldp    w3, w8, [x8, #96]
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0x294e23ed // ldp    w13, w8, [sp, #112]
+	WORD $0xb9005f88 // str    w8, [x28, #92]
+	WORD $0xb9005d6d // str    w13, [x11, #92]
+	WORD $0xa95423ed // ldp    x13, x8, [sp, #320]
+	WORD $0x294c110e // ldp    w14, w4, [x8, #96]
+	WORD $0x294c35b1 // ldp    w17, w13, [x13, #96]
+	WORD $0xf94083e8 // ldr    x8, [sp, #256]
+	WORD $0xb90077ed // str    w13, [sp, #116]
+	WORD $0xb9407bed // ldr    w13, [sp, #120]
+	WORD $0xb9005d09 // str    w9, [x8, #92]
+	WORD $0xb94063e9 // ldr    w9, [sp, #96]
+	WORD $0xb9005cc5 // str    w5, [x6, #92]
+	WORD $0xf940c3e5 // ldr    x5, [sp, #384]
+	WORD $0xb9005c2d // str    w13, [x1, #92]
+	WORD $0xf9409fed // ldr    x13, [sp, #312]
+	WORD $0xb9005d89 // str    w9, [x12, #92]
+	WORD $0xb9405fe9 // ldr    w9, [sp, #92]
+	WORD $0xb9005e99 // str    w25, [x20, #92]
+	WORD $0x294c35a6 // ldp    w6, w13, [x13, #96]
+	WORD $0xb9005ea9 // str    w9, [x21, #92]
+	WORD $0xf94087f5 // ldr    x21, [sp, #264]
+	WORD $0xb9007fed // str    w13, [sp, #124]
+	WORD $0x294c24ad // ldp    w13, w9, [x5, #96]
+	WORD $0xf9408fe5 // ldr    x5, [sp, #280]
+	WORD $0xb9006be9 // str    w9, [sp, #104]
+	WORD $0xb9005eba // str    w26, [x21, #92]
+	WORD $0xb9005e6f // str    w15, [x19, #92]
+	WORD $0xf940c7ef // ldr    x15, [sp, #392]
+	WORD $0xb94064a9 // ldr    w9, [x5, #100]
+	WORD $0xb9005f1e // str    w30, [x24, #92]
+	WORD $0xb9005eea // str    w10, [x23, #92]
+	WORD $0xf9407bea // ldr    x10, [sp, #240]
+	WORD $0xb94061f9 // ldr    w25, [x15, #96]
+	WORD $0xb90062c3 // str    w3, [x22, #96]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xb94065e9 // ldr    w9, [x15, #100]
+	WORD $0xb900614e // str    w14, [x10, #96]
+	WORD $0xb9006371 // str    w17, [x27, #96]
+	WORD $0xb94060ba // ldr    w26, [x5, #96]
+	WORD $0xb9006206 // str    w6, [x16, #96]
+	WORD $0xa9521bef // ldp    x15, x6, [sp, #288]
+	WORD $0xb94061e3 // ldr    w3, [x15, #96]
+	WORD $0xb900638d // str    w13, [x28, #96]
+	WORD $0xb94065ee // ldr    w14, [x15, #100]
+	WORD $0xb900617a // str    w26, [x11, #96]
+	WORD $0xf940abef // ldr    x15, [sp, #336]
+	WORD $0xb9006119 // str    w25, [x8, #96]
+	WORD $0xb94060cb // ldr    w11, [x6, #96]
+	WORD $0xb9006243 // str    w3, [x18, #96]
+	WORD $0xf9408be8 // ldr    x8, [sp, #272]
+	WORD $0xaa1803e5 // mov    x5, x24
+	WORD $0x294c3df1 // ldp    w17, w15, [x15, #96]
+	WORD $0xb9007bee // str    w14, [sp, #120]
+	WORD $0xaa1b03ee // mov    x14, x27
+	WORD $0xb9406510 // ldr    w16, [x8, #100]
+	WORD $0xb90063e9 // str    w9, [sp, #96]
+	WORD $0xb9006031 // str    w17, [x1, #96]
+	WORD $0xb9406111 // ldr    w17, [x8, #96]
+	WORD $0xb90073ef // str    w15, [sp, #112]
+	WORD $0xa955bfe8 // ldp    x8, x15, [sp, #344]
+	WORD $0xaa0503fe // mov    x30, x5
+	WORD $0xaa1203e3 // mov    x3, x18
+	WORD $0xaa1503f8 // mov    x24, x21
+	WORD $0x294c25ed // ldp    w13, w9, [x15, #96]
+	WORD $0xaa1703f2 // mov    x18, x23
+	WORD $0xaa0603fc // mov    x28, x6
+	WORD $0xf94063ef // ldr    x15, [sp, #192]
+	WORD $0xaa1403fa // mov    x26, x20
+	WORD $0xb900618d // str    w13, [x12, #96]
+	WORD $0xf940b7ec // ldr    x12, [sp, #360]
+	WORD $0xb900628b // str    w11, [x20, #96]
+	WORD $0xf940bfed // ldr    x13, [sp, #376]
+	WORD $0xb90060f1 // str    w17, [x7, #96]
+	WORD $0xb9406111 // ldr    w17, [x8, #96]
+	WORD $0xb940618b // ldr    w11, [x12, #96]
+	WORD $0xb90062a2 // str    w2, [x21, #96]
+	WORD $0xb940658c // ldr    w12, [x12, #100]
+	WORD $0xaa0703f4 // mov    x20, x7
+	WORD $0xb94061a2 // ldr    w2, [x13, #96]
+	WORD $0xaa0103e7 // mov    x7, x1
+	WORD $0xb900626b // str    w11, [x19, #96]
+	WORD $0xb94065b9 // ldr    w25, [x13, #100]
+	WORD $0x290b33f0 // stp    w16, w12, [sp, #88]
+	WORD $0xb940650c // ldr    w12, [x8, #100]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb90060b1 // str    w17, [x5, #96]
+	WORD $0xb90062e2 // str    w2, [x23, #96]
+	WORD $0xaa0a03f1 // mov    x17, x10
+	WORD $0xaa0e03e5 // mov    x5, x14
+	WORD $0xf940a7eb // ldr    x11, [sp, #328]
+	WORD $0xb90066c8 // str    w8, [x22, #100]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb9006544 // str    w4, [x10, #100]
+	WORD $0xb9407fea // ldr    w10, [sp, #124]
+	WORD $0xf94077f7 // ldr    x23, [sp, #232]
+	WORD $0x294c8910 // ldp    w16, w2, [x8, #100]
+	WORD $0xb94077e8 // ldr    w8, [sp, #116]
+	WORD $0xb9406d64 // ldr    w4, [x11, #108]
+	WORD $0xf94083f5 // ldr    x21, [sp, #256]
+	WORD $0xb90065c8 // str    w8, [x14, #100]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb90065ea // str    w10, [x15, #100]
+	WORD $0xf9404bea // ldr    x10, [sp, #144]
+	WORD $0xb94064db // ldr    w27, [x6, #100]
+	WORD $0xaa1303e6 // mov    x6, x19
+	WORD $0x294d210d // ldp    w13, w8, [x8, #104]
+	WORD $0xaa0303f3 // mov    x19, x3
+	WORD $0xb9407be3 // ldr    w3, [sp, #120]
+	WORD $0xf9406ff6 // ldr    x22, [sp, #216]
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0x294ca3ee // ldp    w14, w8, [sp, #100]
+	WORD $0xb9006548 // str    w8, [x10, #100]
+	WORD $0xb9406968 // ldr    w8, [x11, #104]
+	WORD $0xb94063eb // ldr    w11, [sp, #96]
+	WORD $0xb90066ee // str    w14, [x23, #100]
+	WORD $0xb90066ab // str    w11, [x21, #100]
+	WORD $0xf940a3eb // ldr    x11, [sp, #320]
+	WORD $0xb9006663 // str    w3, [x19, #100]
+	WORD $0x294d2d6e // ldp    w14, w11, [x11, #104]
+	WORD $0xb9007feb // str    w11, [sp, #124]
+	WORD $0xb94073eb // ldr    w11, [sp, #112]
+	WORD $0xb900642b // str    w11, [x1, #100]
+	WORD $0xf9409feb // ldr    x11, [sp, #312]
+	WORD $0xb90066c9 // str    w9, [x22, #100]
+	WORD $0xb9405be9 // ldr    w9, [sp, #88]
+	WORD $0xb900675b // str    w27, [x26, #100]
+	WORD $0x294d2d61 // ldp    w1, w11, [x11, #104]
+	WORD $0xb9006689 // str    w9, [x20, #100]
+	WORD $0xb9006710 // str    w16, [x24, #100]
+	WORD $0xb9007beb // str    w11, [sp, #120]
+	WORD $0xaa1a03eb // mov    x11, x26
+	WORD $0xf940c3fa // ldr    x26, [sp, #384]
+	WORD $0x294d2743 // ldp    w3, w9, [x26, #104]
+	WORD $0xf9408ffa // ldr    x26, [sp, #280]
+	WORD $0xb90073e9 // str    w9, [sp, #112]
+	WORD $0xb9405fe9 // ldr    w9, [sp, #92]
+	WORD $0xb9406b50 // ldr    w16, [x26, #104]
+	WORD $0xb90064c9 // str    w9, [x6, #100]
+	WORD $0xb9406f49 // ldr    w9, [x26, #108]
+	WORD $0xb90067cc // str    w12, [x30, #100]
+	WORD $0xf940c7ec // ldr    x12, [sp, #392]
+	WORD $0xb9006659 // str    w25, [x18, #100]
+	WORD $0xf94093f9 // ldr    x25, [sp, #288]
+	WORD $0xb90067e9 // str    w9, [sp, #100]
+	WORD $0xaa1503fa // mov    x26, x21
+	WORD $0x294d259b // ldp    w27, w9, [x12, #104]
+	WORD $0xaa1e03fa // mov    x26, x30
+	WORD $0xb9006be9 // str    w9, [sp, #104]
+	WORD $0xf94067e9 // ldr    x9, [sp, #200]
+	WORD $0xb900692d // str    w13, [x9, #104]
+	WORD $0xb9406b2d // ldr    w13, [x25, #104]
+	WORD $0xb9006a28 // str    w8, [x17, #104]
+	WORD $0xb9406f28 // ldr    w8, [x25, #108]
+	WORD $0xb90068ae // str    w14, [x5, #104]
+	WORD $0xaa1303f9 // mov    x25, x19
+	WORD $0xb90069e1 // str    w1, [x15, #104]
+	WORD $0xaa0a03e1 // mov    x1, x10
+	WORD $0xb90063e8 // str    w8, [sp, #96]
+	WORD $0xf940abe8 // ldr    x8, [sp, #336]
+	WORD $0xb9006943 // str    w3, [x10, #104]
+	WORD $0xb9406b8a // ldr    w10, [x28, #104]
+	WORD $0xb9006af0 // str    w16, [x23, #104]
+	WORD $0xb940690e // ldr    w14, [x8, #104]
+	WORD $0xb9006abb // str    w27, [x21, #104]
+	WORD $0xb9406d08 // ldr    w8, [x8, #108]
+	WORD $0xb9006a6d // str    w13, [x19, #104]
+	WORD $0xaa0703fb // mov    x27, x7
+	WORD $0xb9406f8d // ldr    w13, [x28, #108]
+	WORD $0xb90068ee // str    w14, [x7, #104]
+	WORD $0xaa0103e7 // mov    x7, x1
+	WORD $0xb90077e8 // str    w8, [sp, #116]
+	WORD $0xf940b3e8 // ldr    x8, [sp, #352]
+	WORD $0xaa1403f3 // mov    x19, x20
+	WORD $0x294d4103 // ldp    w3, w16, [x8, #104]
+	WORD $0xaa1c03e8 // mov    x8, x28
+	WORD $0xf9408be8 // ldr    x8, [sp, #272]
+	WORD $0xaa1603fc // mov    x28, x22
+	WORD $0xb9006ac3 // str    w3, [x22, #104]
+	WORD $0xf940bfe3 // ldr    x3, [sp, #376]
+	WORD $0xb900696a // str    w10, [x11, #104]
+	WORD $0xaa1803eb // mov    x11, x24
+	WORD $0x294d210e // ldp    w14, w8, [x8, #104]
+	WORD $0xaa1103f6 // mov    x22, x17
+	WORD $0xf9405beb // ldr    x11, [sp, #176]
+	WORD $0xb9006a8e // str    w14, [x20, #104]
+	WORD $0xf94073f4 // ldr    x20, [sp, #224]
+	WORD $0x290a23f0 // stp    w16, w8, [sp, #80]
+	WORD $0xf940afe8 // ldr    x8, [sp, #344]
+	WORD $0xf940b7f0 // ldr    x16, [sp, #360]
+	WORD $0xb9006b02 // str    w2, [x24, #104]
+	WORD $0xb9406862 // ldr    w2, [x3, #104]
+	WORD $0x294d210e // ldp    w14, w8, [x8, #104]
+	WORD $0x294d320a // ldp    w10, w12, [x16, #104]
+	WORD $0xaa0503f0 // mov    x16, x5
+	WORD $0xb9005fe8 // str    w8, [sp, #92]
+	WORD $0xb9406fe8 // ldr    w8, [sp, #108]
+	WORD $0xb90068ca // str    w10, [x6, #104]
+	WORD $0xaa0f03e6 // mov    x6, x15
+	WORD $0xb9006bce // str    w14, [x30, #104]
+	WORD $0xb9406c6e // ldr    w14, [x3, #108]
+	WORD $0xb9006a42 // str    w2, [x18, #104]
+	WORD $0xaa1203e3 // mov    x3, x18
+	WORD $0xb9006d28 // str    w8, [x9, #108]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb9004bec // str    w12, [sp, #72]
+	WORD $0xaa1503e2 // mov    x2, x21
+	WORD $0xb9006e24 // str    w4, [x17, #108]
+	WORD $0xaa1903e4 // mov    x4, x25
+	WORD $0x294da50a // ldp    w10, w9, [x8, #108]
+	WORD $0x294f23ec // ldp    w12, w8, [sp, #120]
+	WORD $0xb9006ca8 // str    w8, [x5, #108]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb9006dec // str    w12, [x15, #108]
+	WORD $0xb94067ef // ldr    w15, [sp, #100]
+	WORD $0xa95433e5 // ldp    x5, x12, [sp, #320]
+	WORD $0x294e2112 // ldp    w18, w8, [x8, #112]
+	WORD $0xb94070b1 // ldr    w17, [x5, #112]
+	WORD $0xb9005be8 // str    w8, [sp, #88]
+	WORD $0xb94073e8 // ldr    w8, [sp, #112]
+	WORD $0xb9006c28 // str    w8, [x1, #108]
+	WORD $0x294e3188 // ldp    w8, w12, [x12, #112]
+	WORD $0xb9006eef // str    w15, [x23, #108]
+	WORD $0xb94053ef // ldr    w15, [sp, #80]
+	WORD $0xb9004fec // str    w12, [sp, #76]
+	WORD $0xb9406bec // ldr    w12, [sp, #104]
+	WORD $0xb9006eac // str    w12, [x21, #108]
+	WORD $0xb94063ec // ldr    w12, [sp, #96]
+	WORD $0xb9006f2c // str    w12, [x25, #108]
+	WORD $0xb94074ac // ldr    w12, [x5, #116]
+	WORD $0xaa1b03f9 // mov    x25, x27
+	WORD $0xb9007fec // str    w12, [sp, #124]
+	WORD $0xb94077ec // ldr    w12, [sp, #116]
+	WORD $0xb9006f6c // str    w12, [x27, #108]
+	WORD $0xf9409fec // ldr    x12, [sp, #312]
+	WORD $0xb9006f8f // str    w15, [x28, #108]
+	WORD $0xb94057ef // ldr    w15, [sp, #84]
+	WORD $0xb9006e8d // str    w13, [x20, #108]
+	WORD $0xaa1c03fb // mov    x27, x28
+	WORD $0x294e3181 // ldp    w1, w12, [x12, #112]
+	WORD $0xaa1603fc // mov    x28, x22
+	WORD $0xb9006e6f // str    w15, [x19, #108]
+	WORD $0xb9006f0a // str    w10, [x24, #108]
+	WORD $0xf9408fea // ldr    x10, [sp, #280]
+	WORD $0xb9404bef // ldr    w15, [sp, #72]
+	WORD $0xb90067ec // str    w12, [sp, #100]
+	WORD $0xb9006d6f // str    w15, [x11, #108]
+	WORD $0xa9583fec // ldp    x12, x15, [sp, #384]
+	WORD $0x294e318d // ldp    w13, w12, [x12, #112]
+	WORD $0xb9007bec // str    w12, [sp, #120]
+	WORD $0x294e294c // ldp    w12, w10, [x10, #112]
+	WORD $0xb90077ea // str    w10, [sp, #116]
+	WORD $0xb9405fea // ldr    w10, [sp, #92]
+	WORD $0xb9006fca // str    w10, [x30, #108]
+	WORD $0xb94071ea // ldr    w10, [x15, #112]
+	WORD $0xb9006c6e // str    w14, [x3, #108]
+	WORD $0xb94075ee // ldr    w14, [x15, #116]
+	WORD $0xf94067ef // ldr    x15, [sp, #200]
+	WORD $0xb90057ee // str    w14, [sp, #84]
+	WORD $0xf94093ee // ldr    x14, [sp, #288]
+	WORD $0xb90071f2 // str    w18, [x15, #112]
+	WORD $0xb90072c8 // str    w8, [x22, #112]
+	WORD $0xaa1703f6 // mov    x22, x23
+	WORD $0xb94075c8 // ldr    w8, [x14, #116]
+	WORD $0xb9007211 // str    w17, [x16, #112]
+	WORD $0xb90070c1 // str    w1, [x6, #112]
+	WORD $0xb94071d2 // ldr    w18, [x14, #112]
+	WORD $0xb90070ed // str    w13, [x7, #112]
+	WORD $0xaa0603ee // mov    x14, x6
+	WORD $0xb90073e8 // str    w8, [sp, #112]
+	WORD $0xb90072ec // str    w12, [x23, #112]
+	WORD $0xaa0703e1 // mov    x1, x7
+	WORD $0xb90072aa // str    w10, [x21, #112]
+	WORD $0xa9552be8 // ldp    x8, x10, [sp, #336]
+	WORD $0xb9407111 // ldr    w17, [x8, #112]
+	WORD $0xb9007092 // str    w18, [x4, #112]
+	WORD $0xb9407508 // ldr    w8, [x8, #116]
+	WORD $0xaa1903f2 // mov    x18, x25
+	WORD $0xaa0403f7 // mov    x23, x4
+	WORD $0xaa1803e7 // mov    x7, x24
+	WORD $0xb9007331 // str    w17, [x25, #112]
+	WORD $0xaa1403f9 // mov    x25, x20
+	WORD $0xb9006fe8 // str    w8, [sp, #108]
+	WORD $0xf940b3e8 // ldr    x8, [sp, #352]
+	WORD $0xaa1003e4 // mov    x4, x16
+	WORD $0xaa1303e6 // mov    x6, x19
+	WORD $0x294e210d // ldp    w13, w8, [x8, #112]
+	WORD $0xb900736d // str    w13, [x27, #112]
+	WORD $0xb9404fed // ldr    w13, [sp, #76]
+	WORD $0xb90053e8 // str    w8, [sp, #80]
+	WORD $0xf94097e8 // ldr    x8, [sp, #296]
+	WORD $0x294e210c // ldp    w12, w8, [x8, #112]
+	WORD $0xb900728c // str    w12, [x20, #112]
+	WORD $0xaa0303f4 // mov    x20, x3
+	WORD $0xb9005fe8 // str    w8, [sp, #92]
+	WORD $0xf9408be8 // ldr    x8, [sp, #272]
+	WORD $0x294e2111 // ldp    w17, w8, [x8, #112]
+	WORD $0xb9007271 // str    w17, [x19, #112]
+	WORD $0xb9407151 // ldr    w17, [x10, #112]
+	WORD $0xb9006be8 // str    w8, [sp, #104]
+	WORD $0xf940b7e8 // ldr    x8, [sp, #360]
+	WORD $0xb9007309 // str    w9, [x24, #112]
+	WORD $0xf940bfe9 // ldr    x9, [sp, #376]
+	WORD $0xb940754a // ldr    w10, [x10, #116]
+	WORD $0xaa1c03f8 // mov    x24, x28
+	WORD $0x294e210c // ldp    w12, w8, [x8, #112]
+	WORD $0xb9407122 // ldr    w2, [x9, #112]
+	WORD $0xb900716c // str    w12, [x11, #112]
+	WORD $0xb90063e8 // str    w8, [sp, #96]
+	WORD $0xb9407528 // ldr    w8, [x9, #116]
+	WORD $0xb90073d1 // str    w17, [x30, #112]
+	WORD $0xaa0f03fe // mov    x30, x15
+	WORD $0xb9007062 // str    w2, [x3, #112]
+	WORD $0xb94078a3 // ldr    w3, [x5, #120]
+	WORD $0xb9004be8 // str    w8, [sp, #72]
+	WORD $0xb9405be8 // ldr    w8, [sp, #88]
+	WORD $0xb90075e8 // str    w8, [x15, #116]
+	WORD $0xf940bbe8 // ldr    x8, [sp, #368]
+	WORD $0xb900778d // str    w13, [x28, #116]
+	WORD $0xf940a7ed // ldr    x13, [sp, #328]
+	WORD $0xf940c3ef // ldr    x15, [sp, #384]
+	WORD $0xaa1a03fc // mov    x28, x26
+	WORD $0x294f210c // ldp    w12, w8, [x8, #120]
+	WORD $0x294f35b1 // ldp    w17, w13, [x13, #120]
+	WORD $0xb90173e8 // str    w8, [sp, #368]
+	WORD $0xb9014bed // str    w13, [sp, #328]
+	WORD $0x294f23ed // ldp    w13, w8, [sp, #120]
+	WORD $0xb9007608 // str    w8, [x16, #116]
+	WORD $0xaa0e03e8 // mov    x8, x14
+	WORD $0xb94067ee // ldr    w14, [sp, #100]
+	WORD $0xb9405ff0 // ldr    w16, [sp, #92]
+	WORD $0xb900750e // str    w14, [x8, #116]
+	WORD $0xb900742d // str    w13, [x1, #116]
+	WORD $0x294e37ee // ldp    w14, w13, [sp, #112]
+	WORD $0xb90076cd // str    w13, [x22, #116]
+	WORD $0xb9407cad // ldr    w13, [x5, #124]
+	WORD $0xb90143ed // str    w13, [sp, #320]
+	WORD $0xb94057ed // ldr    w13, [sp, #84]
+	WORD $0xb90076ad // str    w13, [x21, #116]
+	WORD $0xa95337e5 // ldp    x5, x13, [sp, #304]
+	WORD $0xb90076ee // str    w14, [x23, #116]
+	WORD $0xb94074ae // ldr    w14, [x5, #116]
+	WORD $0x294f35a2 // ldp    w2, w13, [x13, #120]
+	WORD $0xb9007fed // str    w13, [sp, #124]
+	WORD $0xb9406fed // ldr    w13, [sp, #108]
+	WORD $0xb900764d // str    w13, [x18, #116]
+	WORD $0xb94053ed // ldr    w13, [sp, #80]
+	WORD $0xb900776d // str    w13, [x27, #116]
+	WORD $0x294f3ded // ldp    w13, w15, [x15, #120]
+	WORD $0xb9007730 // str    w16, [x25, #116]
+	WORD $0xb9013bef // str    w15, [sp, #312]
+	WORD $0xb9406bef // ldr    w15, [sp, #104]
+	WORD $0xb900766f // str    w15, [x19, #116]
+	WORD $0xb94078b3 // ldr    w19, [x5, #120]
+	WORD $0xb90074ee // str    w14, [x7, #116]
+	WORD $0xf9408fee // ldr    x14, [sp, #280]
+	WORD $0xb94063ef // ldr    w15, [sp, #96]
+	WORD $0xf940c7e5 // ldr    x5, [sp, #392]
+	WORD $0x294f39d0 // ldp    w16, w14, [x14, #120]
+	WORD $0xb900756f // str    w15, [x11, #116]
+	WORD $0xb9404bef // ldr    w15, [sp, #72]
+	WORD $0xb900774a // str    w10, [x26, #116]
+	WORD $0xaa1403ea // mov    x10, x20
+	WORD $0xb90183ee // str    w14, [sp, #384]
+	WORD $0x294f68ae // ldp    w14, w26, [x5, #120]
+	WORD $0xb900768f // str    w15, [x20, #116]
+	WORD $0xf94093e5 // ldr    x5, [sp, #288]
+	WORD $0xb9007bcc // str    w12, [x30, #120]
+	WORD $0xaa1e03ef // mov    x15, x30
+	WORD $0xb9007b11 // str    w17, [x24, #120]
+	WORD $0xf940abf1 // ldr    x17, [sp, #336]
+	WORD $0xb9007883 // str    w3, [x4, #120]
+	WORD $0xb94078ac // ldr    w12, [x5, #120]
+	WORD $0xb9007902 // str    w2, [x8, #120]
+	WORD $0xaa0803e2 // mov    x2, x8
+	WORD $0xb900782d // str    w13, [x1, #120]
+	WORD $0xf940b3e8 // ldr    x8, [sp, #352]
+	WORD $0xb9007ad0 // str    w16, [x22, #120]
+	WORD $0xaa1803fe // mov    x30, x24
+	WORD $0xb9007aae // str    w14, [x21, #120]
+	WORD $0xf94097ee // ldr    x14, [sp, #296]
+	WORD $0xb9407cb8 // ldr    w24, [x5, #124]
+	WORD $0xb9007aec // str    w12, [x23, #120]
+	WORD $0x294f5223 // ldp    w3, w20, [x17, #120]
+	WORD $0x294f150d // ldp    w13, w5, [x8, #120]
+	WORD $0xb9007a43 // str    w3, [x18, #120]
+	WORD $0x294f45c8 // ldp    w8, w17, [x14, #120]
+	WORD $0xb9007b6d // str    w13, [x27, #120]
+	WORD $0xf9408bee // ldr    x14, [sp, #272]
+	WORD $0xf940b7f0 // ldr    x16, [sp, #360]
+	WORD $0xb9007b28 // str    w8, [x25, #120]
+	WORD $0xf940afe8 // ldr    x8, [sp, #344]
+	WORD $0xb94079c3 // ldr    w3, [x14, #120]
+	WORD $0xb9407a0c // ldr    w12, [x16, #120]
+	WORD $0xb940792d // ldr    w13, [x9, #120]
+	WORD $0xb90078c3 // str    w3, [x6, #120]
+	WORD $0xb9407903 // ldr    w3, [x8, #120]
+	WORD $0xb90078f3 // str    w19, [x7, #120]
+	WORD $0xb9407e13 // ldr    w19, [x16, #124]
+	WORD $0xb900796c // str    w12, [x11, #120]
+	WORD $0xaa0b03f0 // mov    x16, x11
+	WORD $0xb9407d0b // ldr    w11, [x8, #124]
+	WORD $0xb9007b83 // str    w3, [x28, #120]
+	WORD $0xb94173e8 // ldr    w8, [sp, #368]
+	WORD $0xb900794d // str    w13, [x10, #120]
+	WORD $0xb9407dce // ldr    w14, [x14, #124]
+	WORD $0xb9407d23 // ldr    w3, [x9, #124]
+	WORD $0xb9007de8 // str    w8, [x15, #124]
+	WORD $0xb9414be8 // ldr    w8, [sp, #328]
+	WORD $0xb9007fc8 // str    w8, [x30, #124]
+	WORD $0xb94143e8 // ldr    w8, [sp, #320]
+	WORD $0xb9007c88 // str    w8, [x4, #124]
+	WORD $0xb9407fe8 // ldr    w8, [sp, #124]
+	WORD $0xb9007c48 // str    w8, [x2, #124]
+	WORD $0xb9413be8 // ldr    w8, [sp, #312]
+	WORD $0xb9007c28 // str    w8, [x1, #124]
+	WORD $0xb94183e8 // ldr    w8, [sp, #384]
+	WORD $0xb9007ec8 // str    w8, [x22, #124]
+	WORD $0xf9409be8 // ldr    x8, [sp, #304]
+	WORD $0xb9007eba // str    w26, [x21, #124]
+	WORD $0xa9486bec // ldp    x12, x26, [sp, #128]
+	WORD $0xb9007ef8 // str    w24, [x23, #124]
+	WORD $0xb9407d08 // ldr    w8, [x8, #124]
+	WORD $0xb9007e54 // str    w20, [x18, #124]
+	WORD $0xb9007f65 // str    w5, [x27, #124]
+	WORD $0xb9007f31 // str    w17, [x25, #124]
+	WORD $0x9100418c // add    x12, x12, #16
+	WORD $0xb9007cce // str    w14, [x6, #124]
+	WORD $0xb9007ce8 // str    w8, [x7, #124]
+	WORD $0xf9400fe8 // ldr    x8, [sp, #24]
+	WORD $0xb9007e13 // str    w19, [x16, #124]
+	WORD $0xb9007f8b // str    w11, [x28, #124]
+	WORD $0xeb08019f // cmp    x12, x8
+	WORD $0xb9007d43 // str    w3, [x10, #124]
+	BNE LBB0_158
+
+	// %bb.159:
+	WORD $0xa94123f3 // ldp    x19, x8, [sp, #16]
+	WORD $0xf94007e0 // ldr    x0, [sp, #8]
+	WORD $0xeb13011f // cmp    x8, x19
+	BEQ LBB0_156
+	JMP LBB0_12
 
+LBB0_156:
+	WORD $0x531b6a60    // lsl    w0, w19, #5
+	WORD $0x910003bf    // mov    sp, x29
+	WORD $0xa9454ff4    // ldp    x20, x19, [sp, #80]
+	WORD $0xa94457f6    // ldp    x22, x21, [sp, #64]
+	WORD $0xa9435ff8    // ldp    x24, x23, [sp, #48]
+	WORD $0xa94267fa    // ldp    x26, x25, [sp, #32]
+	WORD $0xa9416ffc    // ldp    x28, x27, [sp, #16]
+	WORD $0xa8c67bfd    // ldp    x29, x30, [sp], #96
+	MOVD R0, num+32(FP)
+	RET
diff --git a/go/parquet/internal/utils/clib_amd64.s b/go/parquet/internal/utils/clib_amd64.s
index 07258bd2f9652..b1534d4cf18f6 100644
--- a/go/parquet/internal/utils/clib_amd64.s
+++ b/go/parquet/internal/utils/clib_amd64.s
@@ -44,6 +44,15 @@ MEMCPY_BYTE_DONE:
 	POPQ R8
 	RET
 
+// func _ClibMemcpy(dst, src unsafe.Pointer, n uint) unsafe.Pointer
+TEXT ·_ClibMemcpy(SB), NOSPLIT|NOFRAME, $16-24
+	MOVQ arg1+0(FP), DI
+	MOVQ arg2+8(FP), SI
+	MOVQ arg3+16(FP), DX
+	CALL clib·_memcpy(SB)
+	MOVQ AX, ret+24(FP)
+	RET
+
 // void *memset(void *str, int c, size_t n)
 // DI = str, SI = c, DX = size
 TEXT clib·_memset(SB), $16-0
@@ -85,3 +94,12 @@ MEMSET_BYTE_DONE:
 	MOVQ DI, AX // set return value
 	POPQ CX
 	RET
+
+// func _ClibMemset(dst unsafe.Pointer, c int, n uint) unsafe.Pointer
+TEXT ·_ClibMemset(SB), NOSPLIT|NOFRAME, $16-24
+	MOVQ arg1+0(FP), DI
+	MOVQ arg2+8(FP), SI
+	MOVQ arg3+16(FP), DX
+	CALL clib·_memset(SB)
+	MOVQ AX, ret+24(FP)
+	RET

From 161510e4131976712ea1588c7649b4ccdebdb5e0 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 5 Oct 2023 17:16:09 +0200
Subject: [PATCH 464/749] GH-37145: [Python] support boolean columns with
 bitsize 1 in from_dataframe (#37975)

### Rationale for this change

Bit-packed booleans are currently not supported in the `from_dataframe` of the Dataframe Interchange Protocol.

Note: We currently represent booleans in the pyarrow implementation as `uint8` which will also need to be changed in a follow-up PR (see https://github.com/data-apis/dataframe-api/issues/227).

### What changes are included in this PR?

This PR adds the support for bit-packed booleans when consuming a dataframe interchange object.

### Are these changes tested?

Only locally, currently!
* Closes: #37145

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/interchange/from_dataframe.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/python/pyarrow/interchange/from_dataframe.py b/python/pyarrow/interchange/from_dataframe.py
index d653054e910a6..e97e91e44fb52 100644
--- a/python/pyarrow/interchange/from_dataframe.py
+++ b/python/pyarrow/interchange/from_dataframe.py
@@ -54,7 +54,8 @@
     DtypeKind.FLOAT: {16: pa.float16(),
                       32: pa.float32(),
                       64: pa.float64()},
-    DtypeKind.BOOL: {8: pa.uint8()},
+    DtypeKind.BOOL: {1: pa.bool_(),
+                     8: pa.uint8()},
     DtypeKind.STRING: {8: pa.string()},
 }
 
@@ -232,19 +233,23 @@ def bool_column_to_array(
     -------
     pa.Array
     """
-    if not allow_copy:
+    buffers = col.get_buffers()
+    size = buffers["data"][1][1]
+
+    # If booleans are byte-packed a copy to bit-packed will be made
+    if size == 8 and not allow_copy:
         raise RuntimeError(
             "Boolean column will be casted from uint8 and a copy "
             "is required which is forbidden by allow_copy=False"
         )
 
-    buffers = col.get_buffers()
     data_type = col.dtype
     data = buffers_to_array(buffers, data_type,
                             col.size(),
                             col.describe_null,
                             col.offset)
-    data = pc.cast(data, pa.bool_())
+    if size == 8:
+        data = pc.cast(data, pa.bool_())
 
     return data
 

From 1b262a29e5cddb2534457fadfe0b77bd7767f297 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 5 Oct 2023 17:27:20 +0200
Subject: [PATCH 465/749] GH-37437: [C++] Fix MakeArrayOfNull for list array
 with large string values type (#37467)

### Rationale for this change

`MakeArrayOfNull` for list type was assuming that the values child field didn't need to be considered, but those values could also require a minimum buffer size (eg for offsets) and which could be of greater size than the list offsets if those are int32 offsets.

### Are these changes tested?

Yes

* Closes: #37437

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/array/array_test.cc | 5 +++++
 cpp/src/arrow/array/util.cc       | 6 ++++--
 cpp/src/arrow/array/validate.cc   | 4 +++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 0b82a82fbdb26..2bef9d725d37f 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -388,7 +388,12 @@ static std::vector<std::shared_ptr<DataType>> TestArrayUtilitiesAgainstTheseType
       large_utf8(),
       list(utf8()),
       list(int64()),  // NOTE: Regression case for ARROW-9071/MakeArrayOfNull
+      list(large_utf8()),
+      list(list(int64())),
+      list(list(large_utf8())),
+      large_list(utf8()),
       large_list(large_utf8()),
+      large_list(list(large_utf8())),
       fixed_size_list(utf8(), 3),
       fixed_size_list(int64(), 4),
       dictionary(int32(), utf8()),
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index e84ab404ad6e3..98e9d51b5fc75 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -366,9 +366,11 @@ class NullArrayFactory {
     }
 
     template <typename T>
-    enable_if_var_size_list<T, Status> Visit(const T&) {
+    enable_if_var_size_list<T, Status> Visit(const T& type) {
       // values array may be empty, but there must be at least one offset of 0
-      return MaxOf(sizeof(typename T::offset_type) * (length_ + 1));
+      RETURN_NOT_OK(MaxOf(sizeof(typename T::offset_type) * (length_ + 1)));
+      RETURN_NOT_OK(MaxOf(GetBufferLength(type.value_type(), length_)));
+      return Status::OK();
     }
 
     template <typename T>
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 0f2bd4583574e..19ff8e28b536c 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -713,8 +713,10 @@ struct ValidateArrayImpl {
     }
 
     // An empty list array can have 0 offsets
-    const auto required_offsets = (data.length > 0) ? data.length + data.offset + 1 : 0;
     const auto offsets_byte_size = data.buffers[1]->size();
+    const auto required_offsets = ((data.length > 0) || (offsets_byte_size > 0))
+                                      ? data.length + data.offset + 1
+                                      : 0;
     if (offsets_byte_size / static_cast<int32_t>(sizeof(offset_type)) <
         required_offsets) {
       return Status::Invalid("Offsets buffer size (bytes): ", offsets_byte_size,

From 1eec38d833ca57ad826cea57f85d68532172c88c Mon Sep 17 00:00:00 2001
From: Thomas Grainger <tagrain@gmail.com>
Date: Thu, 5 Oct 2023 09:24:40 -0700
Subject: [PATCH 466/749] GH-37574: [Python] Compatibilty with numpy 2.0
 (#38040)

### What changes are included in this PR?

support for numpy 2
install numpy 2 and pandas 2.2.0.dev0 from scientific-python-nightly-wheels

### Are these changes tested?
I tested this locally with numpy==2.0.0.dev0 and pandas==2.2.0.dev0+325.g6c58a217f5

### Are there any user-facing changes?
No

* Closes: #37574

Authored-by: Thomas Grainger <tagrain@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 ci/scripts/install_pandas.sh         |  4 ++--
 python/pyarrow/pandas_compat.py      |  7 ++++---
 python/pyarrow/tests/test_pandas.py  | 22 +++++++++++++++-------
 python/pyarrow/tests/test_scalars.py |  4 +++-
 4 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/ci/scripts/install_pandas.sh b/ci/scripts/install_pandas.sh
index f0cb76fb663e0..6a506a86514fa 100755
--- a/ci/scripts/install_pandas.sh
+++ b/ci/scripts/install_pandas.sh
@@ -28,7 +28,7 @@ pandas=$1
 numpy=${2:-"latest"}
 
 if [ "${numpy}" = "nightly" ]; then
-  pip install --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple --pre numpy
+  pip install --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --pre numpy
 elif [ "${numpy}" = "latest" ]; then
   pip install numpy
 else
@@ -38,7 +38,7 @@ fi
 if [ "${pandas}" = "upstream_devel" ]; then
   pip install git+https://github.com/pandas-dev/pandas.git
 elif [ "${pandas}" = "nightly" ]; then
-  pip install --extra-index-url https://pypi.anaconda.org/scipy-wheels-nightly/simple --pre pandas
+  pip install --extra-index-url https://pypi.anaconda.org/scientific-python-nightly-wheels/simple --pre pandas
 elif [ "${pandas}" = "latest" ]; then
   pip install pandas
 else
diff --git a/python/pyarrow/pandas_compat.py b/python/pyarrow/pandas_compat.py
index 4e5c868efd4c8..e232603ba45ac 100644
--- a/python/pyarrow/pandas_compat.py
+++ b/python/pyarrow/pandas_compat.py
@@ -31,6 +31,7 @@
 import warnings
 
 import numpy as np
+from numpy.core.numerictypes import sctypes as _np_sctypes
 
 import pyarrow as pa
 from pyarrow.lib import _pandas_api, frombytes  # noqa
@@ -98,7 +99,7 @@ def get_logical_type(arrow_type):
     np.float32: 'float32',
     np.float64: 'float64',
     'datetime64[D]': 'date',
-    np.unicode_: 'string',
+    np.str_: 'string',
     np.bytes_: 'bytes',
 }
 
@@ -780,7 +781,7 @@ def table_to_blockmanager(options, table, categories=None,
 # dataframe (complex not included since not supported by Arrow)
 _pandas_supported_numpy_types = {
     str(np.dtype(typ))
-    for typ in (np.sctypes['int'] + np.sctypes['uint'] + np.sctypes['float'] +
+    for typ in (_np_sctypes['int'] + _np_sctypes['uint'] + _np_sctypes['float'] +
                 ['object', 'bool'])
 }
 
@@ -1010,7 +1011,7 @@ def _is_generated_index_name(name):
     'date': 'datetime64[D]',
     'datetime': 'datetime64[ns]',
     'datetimetz': 'datetime64[ns]',
-    'unicode': np.unicode_,
+    'unicode': np.str_,
     'bytes': np.bytes_,
     'string': np.str_,
     'integer': np.int64,
diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index 67502af443302..0d01928f44734 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -50,6 +50,14 @@
     pass
 
 
+try:
+    _np_VisibleDeprecationWarning = np.VisibleDeprecationWarning
+except AttributeError:
+    from numpy.exceptions import (
+        VisibleDeprecationWarning as _np_VisibleDeprecationWarning
+    )
+
+
 # Marks all of the tests in this module
 pytestmark = pytest.mark.pandas
 
@@ -706,7 +714,7 @@ def test_float_nulls(self):
 
     def test_float_nulls_to_ints(self):
         # ARROW-2135
-        df = pd.DataFrame({"a": [1.0, 2.0, np.NaN]})
+        df = pd.DataFrame({"a": [1.0, 2.0, np.nan]})
         schema = pa.schema([pa.field("a", pa.int16(), nullable=True)])
         table = pa.Table.from_pandas(df, schema=schema, safe=False)
         assert table[0].to_pylist() == [1, 2, None]
@@ -2329,7 +2337,7 @@ def test_nested_large_list(self):
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore",
                                     "Creating an ndarray from ragged nested",
-                                    np.VisibleDeprecationWarning)
+                                    _np_VisibleDeprecationWarning)
             warnings.filterwarnings("ignore", "elementwise comparison failed",
                                     DeprecationWarning)
             tm.assert_series_equal(
@@ -2441,26 +2449,26 @@ def test_list_no_duplicate_base(self):
         np_arr = chunked_arr.to_numpy()
 
         expected = np.array([[1., 2.], [3., 4., 5.], None,
-                            [6., np.NaN]], dtype="object")
+                            [6., np.nan]], dtype="object")
         for left, right in zip(np_arr, expected):
             if right is None:
                 assert left == right
             else:
                 npt.assert_array_equal(left, right)
 
-        expected_base = np.array([[1., 2., 3., 4., 5., 6., np.NaN]])
+        expected_base = np.array([[1., 2., 3., 4., 5., 6., np.nan]])
         npt.assert_array_equal(np_arr[0].base, expected_base)
 
         np_arr_sliced = chunked_arr.slice(1, 3).to_numpy()
 
-        expected = np.array([[3, 4, 5], None, [6, np.NaN]], dtype="object")
+        expected = np.array([[3, 4, 5], None, [6, np.nan]], dtype="object")
         for left, right in zip(np_arr_sliced, expected):
             if right is None:
                 assert left == right
             else:
                 npt.assert_array_equal(left, right)
 
-        expected_base = np.array([[3., 4., 5., 6., np.NaN]])
+        expected_base = np.array([[3., 4., 5., 6., np.nan]])
         npt.assert_array_equal(np_arr_sliced[0].base, expected_base)
 
     def test_list_values_behind_null(self):
@@ -2471,7 +2479,7 @@ def test_list_values_behind_null(self):
         )
         np_arr = arr.to_numpy(zero_copy_only=False)
 
-        expected = np.array([[1., 2.], None, [3., np.NaN]], dtype="object")
+        expected = np.array([[1., 2.], None, [3., np.nan]], dtype="object")
         for left, right in zip(np_arr, expected):
             if right is None:
                 assert left == right
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index 8a1dcfb057f74..1d8d77f50dac8 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -204,7 +204,9 @@ def test_numerics():
     # float16
     s = pa.scalar(np.float16(0.5), type='float16')
     assert isinstance(s, pa.HalfFloatScalar)
-    assert repr(s) == "<pyarrow.HalfFloatScalar: 0.5>"
+    # on numpy2 repr(np.float16(0.5)) == "np.float16(0.5)"
+    # on numpy1 repr(np.float16(0.5)) == "0.5"
+    assert repr(s) == f"<pyarrow.HalfFloatScalar: {np.float16(0.5)!r}>"
     assert str(s) == "0.5"
     assert s.as_py() == 0.5
 

From f5e40dc45ba3465dfaf1c32af020b63a294b6982 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Thu, 5 Oct 2023 12:25:56 -0400
Subject: [PATCH 467/749] GH-37978: [C++] Add support for specifying custom
 Array element delimiter to `arrow::PrettyPrintOptions` (#37981)

### Rationale for this change

In order to make the [`arrow::PrettyPrint`](https://github.com/apache/arrow/blob/7667b81bffcb5b361fab6d61c42ce396d98cc6e1/cpp/src/arrow/pretty_print.h#L101) functionality for `arrow::Array`/`arrow::ChunkedArray` more flexible, it would be useful to be able to specify a custom element delimiter other than `","`.

For example, the MATLAB interface wraps the Arrow C++ libraries and being able to specify a custom `Array` element delimiter, would make it possible to make the display of MATLAB `arrow.array.Array` objects more MATLAB-like.

For the MATLAB interface, we would like to enable display that looks something like the following (note the ` | ` between individual `Array` elements):

```matlab
% Make a MATLAB array.
>> A = 1:5

A =

     1     2     3     4     5

% Make an Arrow array from the MATLAB array.
>> B = arrow.array(A)

B =

    [ 1 | 2 | 3 | 4 | 5 ]
```

In order to support custom `Array` element delimiters, this pull request adds a new `struct` type `PrettyPrintDelimiters`. The `PrettyPrintDelimiters` type has one property `element` (of type `std::string`), which allows client code to control the delimiter used to distinguish between individual elements of an `arrow::Array` / `arrow::ChunkedArray`.

In a future pull request, we plan to add more properties like `open` and `close` to allow client code to specify the opening and closing delimiters to use when printing an `arrow::Array` / `arrow::ChunkedArray` (e.g. `"<"` rather than `"["` and `">"` rather than `"]"`).

### What changes are included in this PR?

1. Added a new `struct` type `PrettyPrintDelimiters` with one property `element` (of type `std::string`). The `element` property allows client code to specify any string value as the delimiter to distinguish between individual elements of an `arrow::Array` or `arrow::ChunkedArray` when printing using `arrow::PrettyPrint`.
2. Added two new properties to `arrow::PrettyPrintOptions` - (1) `array_delimiters` (of type `arrow::PrettyPrintDelimiters`) and `chunked_array_delimiters` (of type `arrow::PrettyPrintDelimiters`). These properties can be modified to customize how `arrow::Arrow`/`arrow::ChunkedArray` are printed when using `arrow::PrettyPrint`.

### Are these changes tested?

Yes.

1. Added new tests `ArrayCustomElementDelimiter` and `ChunkedArrayCustomElementDelimiter` to `pretty_print_test.cc`.
2. All existing `PrettyPrint`-related C++ tests pass.

### Are there any user-facing changes?

Yes.

1. User's can now specify a custom element delimiter to use when printing `arrow::Array`s / `arrow::ChunkedArray`s using  [`arrow::PrettyPrint`](https://github.com/apache/arrow/blob/7667b81bffcb5b361fab6d61c42ce396d98cc6e1/cpp/src/arrow/pretty_print.h#L101) by modifying the `array_delimiters` or `chunked_array_delimiters` properties of `arrow::PrettyPrintOptions`.

**Example**:

```cpp
auto array = ...;
auto stream = ...
arrow::PrettyPrintOptions options = arrow::PrettyPrintOptions::Defaults();
// Use " | " as the element-wise (element = scalar value) delimiter for arrow::Array.
options.array_delimiters.element = " | ";
// Use "';" as the element-wise (element = chunk) delimiter for arrow::ChunkedArray.
options.chunked_array_delimiters.element = ";";
arrow::PrettyPrint(array, options, stream);
```

### Future Directions

1. To keep this pull request small and focused, I intentionally chose not to include changes related to specifying custom opening and closing `Array` delimiters (e.g. use `<` and `>` instead of `[` and `]`). I've captured the idea of supporting custom opening and closing `Array` delimiters in #37979. I will follow up with a future PR to address this.

### Notes

1. This pull request was motivated by our desire to improve the display of Arrow related classes in the MATLAB interface, but it is hopefully a generic enough change that it may benefit other use cases too.
3. @ rok helpfully pointed out in https://github.com/apache/arrow/issues/37978#issuecomment-1743715458 that a similar attempt to modify the default `Array` element delimiter to be `", "` (note the space after the comma) was taken in #30951. However, this issue appears to have gone stale and the PR (https://github.com/apache/arrow/pull/12420) that was opened also seems to have gone stale. If these changes get merged, it may make sense to close out this issue since this one seems to at least partially address it (although, it isn't exactly the same, since it doesn't change the default delimiter to be `", "`. However, for `PyArrow`, `array_delimiters.element` and `chunked_array_delimiters.element` could just be set to `", "` after merging these changes to change the default display if that is still desirable).
* Closes: #37978

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 cpp/src/arrow/pretty_print.cc      |  19 ++---
 cpp/src/arrow/pretty_print.h       |  23 +++++-
 cpp/src/arrow/pretty_print_test.cc | 111 +++++++++++++++++++++++++++++
 3 files changed, 143 insertions(+), 10 deletions(-)

diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index 03e2051c2fb88..a4a1fa90c2878 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -151,14 +151,14 @@ class ArrayPrinter : public PrettyPrinter {
         IndentAfterNewline();
         (*sink_) << "...";
         if (!is_last && options_.skip_new_lines) {
-          (*sink_) << ",";
+          (*sink_) << options_.array_delimiters.element;
         }
         i = array.length() - window - 1;
       } else if (array.IsNull(i)) {
         IndentAfterNewline();
         (*sink_) << options_.null_rep;
         if (!is_last) {
-          (*sink_) << ",";
+          (*sink_) << options_.array_delimiters.element;
         }
       } else {
         if (indent_non_null_values) {
@@ -166,7 +166,7 @@ class ArrayPrinter : public PrettyPrinter {
         }
         RETURN_NOT_OK(func(i));
         if (!is_last) {
-          (*sink_) << ",";
+          (*sink_) << options_.array_delimiters.element;
         }
       }
       Newline();
@@ -453,12 +453,12 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op
   if (!skip_new_lines) {
     *sink << "\n";
   }
-  bool skip_comma = true;
+  bool skip_element_delimiter = true;
   for (int i = 0; i < num_chunks; ++i) {
-    if (skip_comma) {
-      skip_comma = false;
+    if (skip_element_delimiter) {
+      skip_element_delimiter = false;
     } else {
-      (*sink) << ",";
+      (*sink) << options.chunked_array_delimiters.element;
       if (!skip_new_lines) {
         *sink << "\n";
       }
@@ -467,12 +467,13 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op
       for (int i = 0; i < indent; ++i) {
         (*sink) << " ";
       }
-      (*sink) << "...,";
+      (*sink) << "...";
+      (*sink) << options.chunked_array_delimiters.element;
       if (!skip_new_lines) {
         *sink << "\n";
       }
       i = num_chunks - window - 1;
-      skip_comma = true;
+      skip_element_delimiter = true;
     } else {
       PrettyPrintOptions chunk_options = options;
       chunk_options.indent += options.indent_size;
diff --git a/cpp/src/arrow/pretty_print.h b/cpp/src/arrow/pretty_print.h
index 5d22fd5c51ab8..96a214c68b8a6 100644
--- a/cpp/src/arrow/pretty_print.h
+++ b/cpp/src/arrow/pretty_print.h
@@ -32,7 +32,21 @@ class Schema;
 class Status;
 class Table;
 
-struct PrettyPrintOptions {
+/// \class PrettyPrintDelimiters
+/// \brief Options for controlling which delimiters to use when printing
+/// an Array or ChunkedArray.
+struct ARROW_EXPORT PrettyPrintDelimiters {
+  /// Delimiter for separating individual elements of an Array (e.g. ","),
+  /// or individual chunks of a ChunkedArray
+  std::string element = ",";
+
+  /// Create a PrettyPrintDelimiters instance with default values
+  static PrettyPrintDelimiters Defaults() { return PrettyPrintDelimiters(); }
+};
+
+/// \class PrettyPrintOptions
+/// \brief Options for controlling how various Arrow types should be printed.
+struct ARROW_EXPORT PrettyPrintOptions {
   PrettyPrintOptions() = default;
 
   PrettyPrintOptions(int indent,  // NOLINT runtime/explicit
@@ -47,6 +61,7 @@ struct PrettyPrintOptions {
         skip_new_lines(skip_new_lines),
         truncate_metadata(truncate_metadata) {}
 
+  /// Create a PrettyPrintOptions instance with default values
   static PrettyPrintOptions Defaults() { return PrettyPrintOptions(); }
 
   /// Number of spaces to shift entire formatted object to the right
@@ -77,6 +92,12 @@ struct PrettyPrintOptions {
 
   /// If true, display schema metadata when pretty-printing a Schema
   bool show_schema_metadata = true;
+
+  /// Delimiters to use when printing an Array
+  PrettyPrintDelimiters array_delimiters = PrettyPrintDelimiters::Defaults();
+
+  /// Delimiters to use when printing a ChunkedArray
+  PrettyPrintDelimiters chunked_array_delimiters = PrettyPrintDelimiters::Defaults();
 };
 
 /// \brief Print human-readable representation of RecordBatch
diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index 9a6e347c0bdb2..45bb4ecffe054 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -200,6 +200,65 @@ TEST_F(TestPrettyPrint, PrimitiveTypeNoNewlines) {
   CheckPrimitive<Int32Type, int32_t>(options, is_valid, values, expected, false);
 }
 
+TEST_F(TestPrettyPrint, ArrayCustomElementDelimiter) {
+  PrettyPrintOptions options{};
+  // Use a custom array element delimiter of " | ",
+  // rather than the default delimiter (i.e. ",").
+  options.array_delimiters.element = " | ";
+
+  // Short array without ellipsis
+  {
+    std::vector<bool> is_valid = {true, true, false, true, false};
+    std::vector<int32_t> values = {1, 2, 3, 4, 5};
+    static const char* expected = R"expected([
+  1 | 
+  2 | 
+  null | 
+  4 | 
+  null
+])expected";
+    CheckPrimitive<Int32Type, int32_t>(options, is_valid, values, expected, false);
+  }
+
+  // Longer array with ellipsis
+  {
+    std::vector<bool> is_valid = {true, false, true};
+    std::vector<int32_t> values = {1, 2, 3};
+    // Append 20 copies of the value "10" to the end of the values vector.
+    values.insert(values.end(), 20, 10);
+    // Append 20 copies of the value "true" to the end of the validity bitmap vector.
+    is_valid.insert(is_valid.end(), 20, true);
+    // Append the values 4, 5, and 6 to the end of the values vector.
+    values.insert(values.end(), {4, 5, 6});
+    // Append the values true, false, and true to the end of the validity bitmap vector.
+    is_valid.insert(is_valid.end(), {true, false, true});
+    static const char* expected = R"expected([
+  1 | 
+  null | 
+  3 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  ...
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  10 | 
+  4 | 
+  null | 
+  6
+])expected";
+    CheckPrimitive<Int32Type, int32_t>(options, is_valid, values, expected, false);
+  }
+}
+
 TEST_F(TestPrettyPrint, Int8) {
   static const char* expected = R"expected([
   0,
@@ -1020,6 +1079,58 @@ TEST_F(TestPrettyPrint, ChunkedArrayPrimitiveType) {
   CheckStream(chunked_array_2, {0}, expected_2);
 }
 
+TEST_F(TestPrettyPrint, ChunkedArrayCustomElementDelimiter) {
+  PrettyPrintOptions options{};
+  // Use a custom ChunkedArray element delimiter of ";",
+  // rather than the default delimiter (i.e. ",").
+  options.chunked_array_delimiters.element = ";";
+  // Use a custom Array element delimiter of " | ",
+  // rather than the default delimiter (i.e. ",").
+  options.array_delimiters.element = " | ";
+
+  const auto chunk = ArrayFromJSON(int32(), "[1, 2, null, 4, null]");
+
+  // ChunkedArray with 1 chunk
+  {
+    const ChunkedArray chunked_array(chunk);
+
+    static const char* expected = R"expected([
+  [
+    1 | 
+    2 | 
+    null | 
+    4 | 
+    null
+  ]
+])expected";
+    CheckStream(chunked_array, options, expected);
+  }
+
+  // ChunkedArray with 2 chunks
+  {
+    const ChunkedArray chunked_array({chunk, chunk});
+
+    static const char* expected = R"expected([
+  [
+    1 | 
+    2 | 
+    null | 
+    4 | 
+    null
+  ];
+  [
+    1 | 
+    2 | 
+    null | 
+    4 | 
+    null
+  ]
+])expected";
+
+    CheckStream(chunked_array, options, expected);
+  }
+}
+
 TEST_F(TestPrettyPrint, TablePrimitive) {
   std::shared_ptr<Field> int_field = field("column", int32());
   auto array = ArrayFromJSON(int_field->type(), "[0, 1, null, 3, null]");

From 4b795ece70a424c4b9f163d07f1dbac5bc9f7f33 Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Thu, 5 Oct 2023 09:42:46 -0700
Subject: [PATCH 468/749] GH-35243: [C#] Implement MapType (#37885)

### What changes are included in this PR?

This change includes the original work by `@ Platob` from #35263, updated with the latest changes in the main branch. Additionally, it includes support in the C API for the Map type and fills a few gaps in functionality from the original change (for instance, ArrowArrayConcentrator support). Finally, it fixes a bug in the ArrowArrayConcentrator.Concatenate which prevented it from working correctly for structs. (This bug was discovered in the course of creating a test for concatenating maps.)

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Maps are now supported in the C# implementation.

Closes #35243
* Closes: #35243

Lead-authored-by: Platob <nfillot.pro@gmail.com>
Co-authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../Arrays/ArrayDataConcatenator.cs           |  28 +--
 .../Arrays/ArrayDataTypeComparer.cs           |  13 +-
 .../Apache.Arrow/Arrays/ArrowArrayFactory.cs  |   3 +-
 csharp/src/Apache.Arrow/Arrays/BinaryArray.cs |   4 +-
 .../Arrays/FixedSizeBinaryArray.cs            |   4 +-
 csharp/src/Apache.Arrow/Arrays/ListArray.cs   |  12 +-
 csharp/src/Apache.Arrow/Arrays/MapArray.cs    | 174 ++++++++++++++++++
 .../src/Apache.Arrow/C/CArrowArrayImporter.cs |   3 +
 .../Apache.Arrow/C/CArrowSchemaExporter.cs    |   6 +-
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |   8 +-
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |  10 +-
 .../src/Apache.Arrow/Ipc/MessageSerializer.cs |   7 +
 csharp/src/Apache.Arrow/Types/ListType.cs     |   2 -
 csharp/src/Apache.Arrow/Types/MapType.cs      |  58 ++++++
 .../Apache.Arrow.IntegrationTest/JsonFile.cs  |  25 +++
 .../Apache.Arrow.Tests/ArrayTypeComparer.cs   |  13 +-
 .../ArrowArrayConcatenatorTests.cs            |  51 ++++-
 .../CDataInterfacePythonTests.cs              |  15 +-
 .../test/Apache.Arrow.Tests/MapArrayTests.cs  |  92 +++++++++
 csharp/test/Apache.Arrow.Tests/TableTests.cs  |   2 +-
 csharp/test/Apache.Arrow.Tests/TestData.cs    |  23 ++-
 .../Apache.Arrow.Tests/Types/MapTypeTests.cs  |  57 ++++++
 dev/archery/archery/integration/datagen.py    |   3 +-
 docs/source/status.rst                        |   2 +-
 24 files changed, 577 insertions(+), 38 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Arrays/MapArray.cs
 create mode 100644 csharp/src/Apache.Arrow/Types/MapType.cs
 create mode 100644 csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
 create mode 100644 csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
index 806defdc7ce66..a3b39923809bb 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
@@ -50,7 +50,8 @@ private class ArrayDataConcatenationVisitor :
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
-            IArrowTypeVisitor<UnionType>
+            IArrowTypeVisitor<UnionType>,
+            IArrowTypeVisitor<MapType>
         {
             public ArrayData Result { get; private set; }
             private readonly IReadOnlyList<ArrayData> _arrayDataList;
@@ -92,15 +93,7 @@ public void Visit(FixedWidthType type)
 
             public void Visit(StringType type) => ConcatenateVariableBinaryArrayData(type);
 
-            public void Visit(ListType type)
-            {
-                CheckData(type, 2);
-                ArrowBuffer validityBuffer = ConcatenateValidityBuffer();
-                ArrowBuffer offsetBuffer = ConcatenateOffsetBuffer();
-                ArrayData child = Concatenate(SelectChildren(0), _allocator);
-
-                Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer }, new[] { child });
-            }
+            public void Visit(ListType type) => ConcatenateLists(type);
 
             public void Visit(FixedSizeListType type)
             {
@@ -114,6 +107,7 @@ public void Visit(FixedSizeListType type)
             public void Visit(StructType type)
             {
                 CheckData(type, 1);
+                ArrowBuffer validityBuffer = ConcatenateValidityBuffer();
                 List<ArrayData> children = new List<ArrayData>(type.Fields.Count);
 
                 for (int i = 0; i < type.Fields.Count; i++)
@@ -121,7 +115,7 @@ public void Visit(StructType type)
                     children.Add(Concatenate(SelectChildren(i), _allocator));
                 }
 
-                Result = new ArrayData(type, _arrayDataList[0].Length, _arrayDataList[0].NullCount, 0, _arrayDataList[0].Buffers, children);
+                Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer }, children);
             }
 
             public void Visit(UnionType type)
@@ -151,6 +145,8 @@ public void Visit(UnionType type)
                 Result = new ArrayData(type, _totalLength, _totalNullCount, 0, buffers, children);
             }
 
+            public void Visit(MapType type) => ConcatenateLists(type.UnsortedKey()); /* Can't tell if the output is still sorted */
+
             public void Visit(IArrowType type)
             {
                 throw new NotImplementedException($"Concatenation for {type.Name} is not supported yet.");
@@ -175,6 +171,16 @@ private void ConcatenateVariableBinaryArrayData(IArrowType type)
                 Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer, valueBuffer });
             }
 
+            private void ConcatenateLists(NestedType type)
+            {
+                CheckData(type, 2);
+                ArrowBuffer validityBuffer = ConcatenateValidityBuffer();
+                ArrowBuffer offsetBuffer = ConcatenateOffsetBuffer();
+                ArrayData child = Concatenate(SelectChildren(0), _allocator);
+
+                Result = new ArrayData(type, _totalLength, _totalNullCount, 0, new ArrowBuffer[] { validityBuffer, offsetBuffer }, new[] { child });
+            }
+
             private ArrowBuffer ConcatenateValidityBuffer()
             {
                 if (_totalNullCount == 0)
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
index 6b54ec1edb573..1698e0672fb60 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
@@ -28,7 +28,8 @@ internal sealed class ArrayDataTypeComparer :
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
         IArrowTypeVisitor<StructType>,
-        IArrowTypeVisitor<UnionType>
+        IArrowTypeVisitor<UnionType>,
+        IArrowTypeVisitor<MapType>
     {
         private readonly IArrowType _expectedType;
         private bool _dataTypeMatch;
@@ -132,6 +133,16 @@ public void Visit(UnionType actualType)
             }
         }
 
+        public void Visit(MapType actualType)
+        {
+            if (_expectedType is MapType expectedType
+                && expectedType.KeySorted == actualType.KeySorted
+                && CompareNested(expectedType, actualType))
+            {
+                _dataTypeMatch = true;
+            }
+        }
+
         private static bool CompareNested(NestedType expectedType, NestedType actualType)
         {
             if (expectedType.Fields.Count != actualType.Fields.Count)
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
index aa407203d1858..d3b7d65185abe 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
@@ -59,6 +59,8 @@ public static IArrowArray BuildArray(ArrayData data)
                     return new TimestampArray(data);
                 case ArrowTypeId.List:
                     return new ListArray(data);
+                case ArrowTypeId.Map:
+                    return new MapArray(data);
                 case ArrowTypeId.Struct:
                     return new StructArray(data);
                 case ArrowTypeId.Union:
@@ -86,7 +88,6 @@ public static IArrowArray BuildArray(ArrayData data)
                 case ArrowTypeId.FixedSizeList:
                     return new FixedSizeListArray(data);
                 case ArrowTypeId.Interval:
-                case ArrowTypeId.Map:
                 default:
                     throw new NotSupportedException($"An ArrowArray cannot be built for type {data.DataType.TypeId}.");
             }
diff --git a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
index 4fd8059f6fe70..20fe0342cca40 100644
--- a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
@@ -237,7 +237,7 @@ public TBuilder Reserve(int capacity)
                 // TODO: [ARROW-9366] Reserve capacity in the value buffer in a more sensible way.
                 ValueOffsets.Reserve(capacity + 1);
                 ValueBuffer.Reserve(capacity);
-                ValidityBuffer.Reserve(capacity + 1);
+                ValidityBuffer.Reserve(capacity);
                 return Instance;
             }
 
@@ -246,7 +246,7 @@ public TBuilder Resize(int length)
                 // TODO: [ARROW-9366] Resize the value buffer to a safe length based on offsets, not `length`.
                 ValueOffsets.Resize(length + 1);
                 ValueBuffer.Resize(length);
-                ValidityBuffer.Resize(length + 1);
+                ValidityBuffer.Resize(length);
                 return Instance;
             }
 
diff --git a/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs
index 7d3d8754747e9..866a674bc9df8 100644
--- a/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/FixedSizeBinaryArray.cs
@@ -111,14 +111,14 @@ public TArray Build(MemoryAllocator allocator = default)
             public TBuilder Reserve(int capacity)
             {
                 ValueBuffer.Reserve(capacity * ByteWidth);
-                ValidityBuffer.Reserve(capacity + 1);
+                ValidityBuffer.Reserve(capacity);
                 return Instance;
             }
 
             public TBuilder Resize(int length)
             {
                 ValueBuffer.Resize(length * ByteWidth);
-                ValidityBuffer.Resize(length + 1);
+                ValidityBuffer.Resize(length);
                 return Instance;
             }
 
diff --git a/csharp/src/Apache.Arrow/Arrays/ListArray.cs b/csharp/src/Apache.Arrow/Arrays/ListArray.cs
index 97673cb48e6a8..4d2ff96a3d005 100644
--- a/csharp/src/Apache.Arrow/Arrays/ListArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ListArray.cs
@@ -91,14 +91,14 @@ public ListArray Build(MemoryAllocator allocator = default)
             public Builder Reserve(int capacity)
             {
                 ValueOffsetsBufferBuilder.Reserve(capacity + 1);
-                ValidityBufferBuilder.Reserve(capacity + 1);
+                ValidityBufferBuilder.Reserve(capacity);
                 return this;
             }
 
             public Builder Resize(int length)
             {
                 ValueOffsetsBufferBuilder.Resize(length + 1);
-                ValidityBufferBuilder.Resize(length + 1);
+                ValidityBufferBuilder.Resize(length);
                 return this;
             }
 
@@ -139,6 +139,14 @@ private ListArray(ArrayData data, IArrowArray values) : base(data)
             Values = values;
         }
 
+        // Constructor for child MapArray
+        internal ListArray(ArrayData data, IArrowArray values, ArrowTypeId typeId) : base(data)
+        {
+            data.EnsureBufferCount(2);
+            data.EnsureDataType(typeId);
+            Values = values;
+        }
+
         public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor);
 
 
diff --git a/csharp/src/Apache.Arrow/Arrays/MapArray.cs b/csharp/src/Apache.Arrow/Arrays/MapArray.cs
new file mode 100644
index 0000000000000..a6676b134e34a
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/MapArray.cs
@@ -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.
+
+using System;
+using System.Collections.Generic;
+using Apache.Arrow.Memory;
+using Apache.Arrow.Types;
+
+namespace Apache.Arrow
+{
+    public class MapArray : ListArray // MapArray = ListArray(StructArray("key", "value")) 
+    {
+        // Same as ListArray.Builder, but with KeyBuilder
+        public new class Builder : IArrowArrayBuilder<MapArray, Builder>
+        {
+            public IArrowArrayBuilder<IArrowArray, IArrowArrayBuilder<IArrowArray>> KeyBuilder { get; }
+            public IArrowArrayBuilder<IArrowArray, IArrowArrayBuilder<IArrowArray>> ValueBuilder { get; }
+
+            public int Length => ValueOffsetsBufferBuilder.Length;
+
+            private ArrowBuffer.Builder<int> ValueOffsetsBufferBuilder { get; }
+
+            private ArrowBuffer.BitmapBuilder ValidityBufferBuilder { get; }
+
+            public int NullCount { get; protected set; }
+
+            public MapType DataType { get; }
+
+            public Builder(MapType type)
+            {
+                KeyBuilder = ArrowArrayBuilderFactory.Build(type.KeyField.DataType);
+                ValueBuilder = ArrowArrayBuilderFactory.Build(type.ValueField.DataType);
+                ValueOffsetsBufferBuilder = new ArrowBuffer.Builder<int>();
+                ValidityBufferBuilder = new ArrowBuffer.BitmapBuilder();
+                DataType = type;
+            }
+
+            /// <summary>
+            /// Start a new variable-length list slot
+            ///
+            /// This function should be called before beginning to append elements to the
+            /// value builder
+            /// </summary>
+            /// <returns></returns>
+            public Builder Append()
+            {
+                ValueOffsetsBufferBuilder.Append(KeyBuilder.Length);
+                ValidityBufferBuilder.Append(true);
+
+                return this;
+            }
+
+            public Builder AppendNull()
+            {
+                ValueOffsetsBufferBuilder.Append(KeyBuilder.Length);
+                ValidityBufferBuilder.Append(false);
+                NullCount++;
+
+                return this;
+            }
+
+            public MapArray Build(MemoryAllocator allocator = default)
+            {
+                ValueOffsetsBufferBuilder.Append(KeyBuilder.Length);
+
+                ArrowBuffer validityBuffer = NullCount > 0 ? ValidityBufferBuilder.Build(allocator) : ArrowBuffer.Empty;
+
+                StructArray structs = new StructArray(
+                    DataType.KeyValueType, KeyBuilder.Length,
+                    new IArrowArray[] { KeyBuilder.Build(allocator), ValueBuilder.Build(allocator) },
+                    ArrowBuffer.Empty, 0
+                );
+
+                return new MapArray(DataType, Length - 1, ValueOffsetsBufferBuilder.Build(allocator), structs, validityBuffer, NullCount);
+            }
+
+            public Builder Reserve(int capacity)
+            {
+                ValueOffsetsBufferBuilder.Reserve(capacity + 1);
+                ValidityBufferBuilder.Reserve(capacity);
+                return this;
+            }
+
+            public Builder Resize(int length)
+            {
+                ValueOffsetsBufferBuilder.Resize(length + 1);
+                ValidityBufferBuilder.Resize(length);
+                return this;
+            }
+
+            public Builder Clear()
+            {
+                ValueOffsetsBufferBuilder.Clear();
+                KeyBuilder.Clear();
+                ValueBuilder.Clear();
+                ValidityBufferBuilder.Clear();
+                return this;
+            }
+
+        }
+
+        public StructArray KeyValues => base.Values as StructArray;
+        public IArrowArray Keys => KeyValues.Fields[0];
+        public new IArrowArray Values => KeyValues.Fields[1];
+
+        public MapArray(IArrowType dataType, int length,
+            ArrowBuffer valueOffsetsBuffer, IArrowArray structs,
+            ArrowBuffer nullBitmapBuffer, int nullCount = 0, int offset = 0)
+            : this(
+                  new ArrayData(
+                      dataType, length, nullCount, offset, new[] { nullBitmapBuffer, valueOffsetsBuffer },
+                      new[] { structs.Data }
+                  ), structs)
+        {
+        }
+
+        public MapArray(ArrayData data)
+            : this(data, ArrowArrayFactory.BuildArray(data.Children[0]))
+        {
+        }
+
+        private MapArray(ArrayData data, IArrowArray structs) : base(data, structs, ArrowTypeId.Map)
+        {
+        }
+
+        public IEnumerable<Tuple<K, V>> GetTuples<TKeyArray, K, TValueArray, V>(int index, Func<TKeyArray, int, K> getKey, Func<TValueArray, int, V> getValue)
+            where TKeyArray : Array where TValueArray : Array
+        {
+            ReadOnlySpan<int> offsets = ValueOffsets;
+            // Get key values
+            int start = offsets[index];
+            int end = offsets[index + 1];
+            StructArray array = KeyValues.Slice(start, end - start) as StructArray;
+
+            TKeyArray keyArray = array.Fields[0] as TKeyArray;
+            TValueArray valueArray = array.Fields[1] as TValueArray;
+
+            for (int i = start; i < end; i++)
+            {
+                yield return new Tuple<K, V>(getKey(keyArray, i), getValue(valueArray, i));
+            }
+        }
+
+        public IEnumerable<KeyValuePair<K,V>> GetKeyValuePairs<TKeyArray, K, TValueArray, V>(int index, Func<TKeyArray, int, K> getKey, Func<TValueArray, int, V> getValue)
+            where TKeyArray : Array where TValueArray : Array
+        {
+            ReadOnlySpan<int> offsets = ValueOffsets;
+            // Get key values
+            int start = offsets[index];
+            int end = offsets[index + 1];
+            StructArray array = KeyValues.Slice(start, end - start) as StructArray;
+
+            TKeyArray keyArray = array.Fields[0] as TKeyArray;
+            TValueArray valueArray = array.Fields[1] as TValueArray;
+
+            for (int i = start; i < end; i++)
+            {
+                yield return new KeyValuePair<K,V>(getKey(keyArray, i), getValue(valueArray, i));
+            }
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
index da1b0f31b8f08..1b40ec49658bb 100644
--- a/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowArrayImporter.cs
@@ -180,6 +180,9 @@ private ArrayData GetAsArrayData(CArrowArray* cArray, IArrowType type)
                         }; ;
                         break;
                     case ArrowTypeId.Map:
+                        MapType mapType = (MapType)type;
+                        children = ProcessListChildren(cArray, mapType.Fields[0].DataType);
+                        buffers = ImportListBuffers(cArray);
                         break;
                     case ArrowTypeId.Null:
                         buffers = System.Array.Empty<ArrowBuffer>();
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
index c1a12362a942a..f3479903889d1 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
@@ -188,6 +188,7 @@ private static string GetFormat(IArrowType datatype)
                     return $"+w:{fixedListType.ListSize}";
                 case StructType _: return "+s";
                 case UnionType u: return FormatUnion(u);
+                case MapType _: return "+m";
                 // Dictionary
                 case DictionaryType dictionaryType:
                     return GetFormat(dictionaryType.IndexType);
@@ -212,10 +213,9 @@ private static long GetFlags(IArrowType datatype, bool nullable = true)
                 }
             }
 
-            if (datatype.TypeId == ArrowTypeId.Map)
+            if (datatype is MapType mapType && mapType.KeySorted)
             {
-                // TODO: when we implement MapType, make sure to set the KEYS_SORTED flag.
-                throw new NotSupportedException("Exporting MapTypes is not supported.");
+                flags |= CArrowSchema.ArrowFlagMapKeysSorted;
             }
 
             return flags;
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index f7216df869abd..f2a08f5e4a40b 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -206,8 +206,14 @@ public ArrowType GetAsType()
 
                     return new FixedSizeListType(childField, width);
                 }
+                else if (format == "+m")
+                {
+                    return new MapType(
+                        ParseChildren("map").Single(),
+                        (_cSchema->flags & CArrowSchema.ArrowFlagMapKeysSorted) != 0);
+                }
 
-                // TODO: Map type and large list type
+                // TODO: Large list type
 
                 // Decimals
                 if (format.StartsWith("d:"))
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index b11467538dd04..425d9326addfe 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -67,6 +67,7 @@ class TypeVisitor :
             IArrowTypeVisitor<Decimal256Type>,
             IArrowTypeVisitor<DictionaryType>,
             IArrowTypeVisitor<FixedSizeBinaryType>,
+            IArrowTypeVisitor<MapType>,
             IArrowTypeVisitor<NullType>
         {
             private FlatBufferBuilder Builder { get; }
@@ -229,6 +230,13 @@ public void Visit(FixedSizeBinaryType type)
                     Flatbuf.FixedSizeBinary.CreateFixedSizeBinary(Builder, type.ByteWidth));
             }
 
+            public void Visit(MapType type)
+            {
+                Result = FieldType.Build(
+                    Flatbuf.Type.Map,
+                    Flatbuf.Map.CreateMap(Builder, type.KeySorted));
+            }
+
             public void Visit(NullType type)
             {
                 Flatbuf.Null.StartNull(Builder);
@@ -239,7 +247,7 @@ public void Visit(NullType type)
 
             public void Visit(IArrowType type)
             {
-                throw new NotImplementedException();
+                throw new NotImplementedException($"Cannot visit type {type}");
             }
         }
 
diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
index 6249063ba81f4..9847c376cf82e 100644
--- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
+++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
@@ -207,6 +207,13 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                     Debug.Assert(childFields != null);
                     Flatbuf.Union unionMetadata = field.Type<Flatbuf.Union>().Value;
                     return new Types.UnionType(childFields, unionMetadata.GetTypeIdsArray(), unionMetadata.Mode.ToArrow());
+                case Flatbuf.Type.Map:
+                    if (childFields == null || childFields.Length != 1)
+                    {
+                        throw new InvalidDataException($"Map type must have exactly one struct child.");
+                    }
+                    Flatbuf.Map meta = field.Type<Flatbuf.Map>().Value;
+                    return new Types.MapType(childFields[0], meta.KeysSorted);
                 default:
                     throw new InvalidDataException($"Arrow primitive '{field.TypeType}' is unsupported.");
             }
diff --git a/csharp/src/Apache.Arrow/Types/ListType.cs b/csharp/src/Apache.Arrow/Types/ListType.cs
index a006c2282dd11..b467934ec541d 100644
--- a/csharp/src/Apache.Arrow/Types/ListType.cs
+++ b/csharp/src/Apache.Arrow/Types/ListType.cs
@@ -13,8 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System;
-
 namespace Apache.Arrow.Types
 {
     public sealed class ListType : NestedType
diff --git a/csharp/src/Apache.Arrow/Types/MapType.cs b/csharp/src/Apache.Arrow/Types/MapType.cs
new file mode 100644
index 0000000000000..73112c815bfbf
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Types/MapType.cs
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Collections.Generic;
+
+namespace Apache.Arrow.Types
+{
+    public sealed class MapType : NestedType // MapType = ListType(StructType("key", "value")) 
+    {
+        public override ArrowTypeId TypeId => ArrowTypeId.Map;
+        public override string Name => "map";
+        public readonly bool KeySorted;
+
+        public StructType KeyValueType => Fields[0].DataType as StructType;
+        public Field KeyField => KeyValueType.Fields[0];
+        public Field ValueField => KeyValueType.Fields[1];
+
+        public MapType(IArrowType key, IArrowType value, bool nullable = true, bool keySorted = false)
+            : this(new Field("key", key, false), new Field("value", value, nullable), keySorted)
+        {
+        }
+
+        public MapType(Field key, Field value, bool keySorted = false)
+            : this(new StructType(new List<Field>() { key, value }), keySorted)
+        {
+        }
+
+        public MapType(StructType entries, bool keySorted = false) : this(new Field("entries", entries, false), keySorted)
+        {
+        }
+
+        public MapType(Field entries, bool keySorted = false) : base(entries)
+        {
+            KeySorted = keySorted;
+        }
+
+        public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor);
+
+        public MapType UnsortedKey()
+        {
+            if (!KeySorted) { return this; }
+
+            return new MapType(Fields[0], keySorted: false);
+        }
+    }
+}
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
index 85f66890edf47..d06249bef2661 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
@@ -124,6 +124,7 @@ private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
                 "fixedsizelist" => ToFixedSizeListArrowType(type, children),
                 "struct" => ToStructArrowType(type, children),
                 "union" => ToUnionArrowType(type, children),
+                "map" => ToMapArrowType(type, children),
                 "null" => NullType.Default,
                 _ => throw new NotSupportedException($"JsonArrowType not supported: {type.Name}")
             };
@@ -227,6 +228,11 @@ private static IArrowType ToUnionArrowType(JsonArrowType type, Field[] children)
             };
             return new UnionType(children, type.TypeIds, mode);
         }
+
+        private static IArrowType ToMapArrowType(JsonArrowType type, Field[] children)
+        {
+            return new MapType(children[0], type.KeysSorted);
+        }
     }
 
     public class JsonField
@@ -271,6 +277,9 @@ public class JsonArrowType
         public string Mode { get; set; }
         public int[] TypeIds { get; set; }
 
+        // map fields
+        public bool KeysSorted { get; set; }
+
         [JsonExtensionData]
         public Dictionary<string, JsonElement> ExtensionData { get; set; }
     }
@@ -345,6 +354,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
             IArrowTypeVisitor<UnionType>,
+            IArrowTypeVisitor<MapType>,
             IArrowTypeVisitor<NullType>
         {
             private JsonFieldData JsonFieldData { get; set; }
@@ -616,6 +626,21 @@ public void Visit(UnionType type)
                 Array = UnionArray.Create(arrayData);
             }
 
+            public void Visit(MapType type)
+            {
+                ArrowBuffer validityBuffer = GetValidityBuffer(out int nullCount);
+                ArrowBuffer offsetBuffer = GetOffsetBuffer();
+
+                var data = JsonFieldData;
+                JsonFieldData = data.Children[0];
+                type.KeyValueType.Accept(this);
+                JsonFieldData = data;
+
+                ArrayData arrayData = new ArrayData(type, JsonFieldData.Count, nullCount, 0,
+                    new[] { validityBuffer, offsetBuffer }, new[] { Array.Data });
+                Array = new MapArray(arrayData);
+            }
+
             private ArrayData[] GetChildren(NestedType type)
             {
                 ArrayData[] children = new ArrayData[type.Fields.Count];
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
index c8bcc3cee0f99..ad3527c47807b 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
@@ -29,7 +29,8 @@ public class ArrayTypeComparer :
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
         IArrowTypeVisitor<StructType>,
-        IArrowTypeVisitor<UnionType>
+        IArrowTypeVisitor<UnionType>,
+        IArrowTypeVisitor<MapType>
     {
         private readonly IArrowType _expectedType;
 
@@ -131,6 +132,16 @@ public void Visit(UnionType actualType)
             CompareNested(expectedType, actualType);
         }
 
+        public void Visit(MapType actualType)
+        {
+            Assert.IsAssignableFrom<MapType>(_expectedType);
+            var expectedType = (MapType)_expectedType;
+
+            Assert.Equal(expectedType.KeySorted, actualType.KeySorted);
+
+            CompareNested(expectedType, actualType);
+        }
+
         private static void CompareNested(NestedType expectedType, NestedType actualType)
         {
             Assert.Equal(expectedType.Fields.Count, actualType.Fields.Count);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
index f5a2c345e2ae6..f1dcbb5d37b8f 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
@@ -93,6 +93,10 @@ private static IEnumerable<Tuple<List<IArrowArray>, IArrowArray>> GenerateTestDa
                         new[] { 0, 1 },
                         UnionMode.Dense
                     ),
+                    new MapType(
+                        new Field.Builder().Name("key").DataType(StringType.Default).Nullable(false).Build(),
+                        new Field.Builder().Name("value").DataType(Int32Type.Default).Nullable(true).Build(),
+                        keySorted: false),
                 };
 
             foreach (IArrowType type in targetTypes)
@@ -136,7 +140,8 @@ private class TestDataGenerator :
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
             IArrowTypeVisitor<StructType>,
-            IArrowTypeVisitor<UnionType>
+            IArrowTypeVisitor<UnionType>,
+            IArrowTypeVisitor<MapType>
         {
 
             private List<List<int?>> _baseData;
@@ -310,7 +315,6 @@ public void Visit(StringType type)
             public void Visit(ListType type)
             {
                 ListArray.Builder resultBuilder = new ListArray.Builder(type.ValueDataType).Reserve(_baseDataTotalElementCount);
-                //Todo : Support various types
                 Int64Array.Builder resultValueBuilder = (Int64Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount);
 
                 for (int i = 0; i < _baseDataListCount; i++)
@@ -346,7 +350,6 @@ public void Visit(ListType type)
             public void Visit(FixedSizeListType type)
             {
                 FixedSizeListArray.Builder resultBuilder = new FixedSizeListArray.Builder(type.ValueDataType, type.ListSize).Reserve(_baseDataTotalElementCount);
-                //Todo : Support various types
                 Int32Array.Builder resultValueBuilder = (Int32Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount);
 
                 for (int i = 0; i < _baseDataListCount; i++)
@@ -406,7 +409,7 @@ public void Visit(StructType type)
                 StringArray resultStringArray = resultStringBuilder.Build();
                 Int32Array resultInt32Array = resultInt32Builder.Build();
 
-                ExpectedArray = new StructArray(type, 3, new List<Array> { resultStringArray, resultInt32Array }, nullBitmapBuffer, 1);
+                ExpectedArray = new StructArray(type, 9, new List<Array> { resultStringArray, resultInt32Array }, nullBitmapBuffer, 3);
             }
 
             public void Visit(UnionType type)
@@ -495,6 +498,46 @@ public void Visit(UnionType type)
                         new[] { stringResultBuilder.Build().Data, intResultBuilder.Build().Data }));
             }
 
+            public void Visit(MapType type)
+            {
+                MapArray.Builder resultBuilder = new MapArray.Builder(type).Reserve(_baseDataTotalElementCount);
+                StringArray.Builder resultKeyBuilder = (StringArray.Builder)resultBuilder.KeyBuilder.Reserve(_baseDataTotalElementCount);
+                Int32Array.Builder resultValueBuilder = (Int32Array.Builder)resultBuilder.ValueBuilder.Reserve(_baseDataTotalElementCount);
+                ArrowBuffer nullBitmapBuilder = new ArrowBuffer.BitmapBuilder().Append(true).Append(true).Append(false).Build();
+
+                for (int i = 0; i < _baseData.Count; i++)
+                {
+                    List<int?> dataList = _baseData[i];
+
+                    MapArray.Builder builder = new MapArray.Builder(type).Reserve(dataList.Count);
+                    StringArray.Builder keyBuilder = (StringArray.Builder)builder.KeyBuilder.Reserve(dataList.Count);
+                    Int32Array.Builder valueBuilder = (Int32Array.Builder)builder.ValueBuilder.Reserve(dataList.Count);
+
+                    foreach (int? value in dataList)
+                    {
+                        if (value.HasValue)
+                        {
+                            builder.Append();
+                            resultBuilder.Append();
+
+                            keyBuilder.Append(value.Value.ToString());
+                            valueBuilder.Append(value.Value);
+                            resultKeyBuilder.Append(value.Value.ToString());
+                            resultValueBuilder.Append(value.Value);
+                        }
+                        else
+                        {
+                            builder.AppendNull();
+                            resultBuilder.AppendNull();
+                        }
+                    }
+
+                    TestTargetArrayList.Add(builder.Build());
+                }
+
+                ExpectedArray = resultBuilder.Build();
+            }
+
             public void Visit(IArrowType type)
             {
                 throw new NotImplementedException();
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index b6b65a582d953..7aee37b8212c3 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -115,6 +115,8 @@ private static Schema GetTestSchema()
                     .Field(f => f.Name("dense_union").DataType(new UnionType(new[] { new Field("i64", Int64Type.Default, false), new Field("f32", FloatType.Default, true), }, new[] { 0, 1 }, UnionMode.Dense)))
                     .Field(f => f.Name("sparse_union").DataType(new UnionType(new[] { new Field("i32", Int32Type.Default, true), new Field("f64", DoubleType.Default, false), }, new[] { 0, 1 }, UnionMode.Sparse)))
 
+                    .Field(f => f.Name("map").DataType(new MapType(StringType.Default, Int32Type.Default)).Nullable(false))
+
                     // Checking wider characters.
                     .Field(f => f.Name("hello 你好 😄").DataType(BooleanType.Default).Nullable(true))
 
@@ -178,6 +180,8 @@ private static IEnumerable<dynamic> GetPythonFields()
                 yield return pa.field("dense_union", pa.dense_union(List(pa.field("i64", pa.int64(), false), pa.field("f32", pa.float32(), true))));
                 yield return pa.field("sparse_union", pa.sparse_union(List(pa.field("i32", pa.int32(), true), pa.field("f64", pa.float64(), false))));
 
+                yield return pa.field("map", pa.map_(pa.@string(), pa.int32()), false);
+
                 yield return pa.field("hello 你好 😄", pa.bool_(), true);
             }
         }
@@ -512,8 +516,12 @@ public unsafe void ImportRecordBatch()
                             ),
                             /* field name */ List("i32", "s"),
                             /* type codes */ List(3, 2)),
+                        pa.MapArray.from_arrays(
+                            List(0, 0, 1, 2, 4, 10),
+                            pa.array(List("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")),
+                            pa.array(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))),
                     }),
-                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9" });
+                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9", "col10" });
 
                 dynamic batch = table.to_batches()[0];
 
@@ -585,6 +593,11 @@ public unsafe void ImportRecordBatch()
             UnionArray col9 = (UnionArray)recordBatch.Column("col9");
             Assert.Equal(5, col9.Length);
             Assert.True(col9 is DenseUnionArray);
+
+            MapArray col10 = (MapArray)recordBatch.Column("col10");
+            Assert.Equal(5, col10.Length);
+            Assert.Equal(new int[] { 0, 0, 1, 2, 4, 10}, col10.ValueOffsets.ToArray());
+            Assert.Equal(new long?[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, ((Int64Array)col10.Values).ToList().ToArray());
         }
 
         [SkippableFact]
diff --git a/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
new file mode 100644
index 0000000000000..034f120f3f016
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
@@ -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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Apache.Arrow.Types;
+using Xunit;
+
+namespace Apache.Arrow.Tests
+{
+    public class MapArrayTests
+    {
+        [Fact]
+        public void MapArray_Should_GetTuple()
+        {
+            MapType type = new MapType(StringType.Default, Int64Type.Default);
+            MapArray.Builder builder = new MapArray.Builder(type);
+            var keyBuilder = builder.KeyBuilder as StringArray.Builder;
+            var valueBuilder = builder.ValueBuilder as Int64Array.Builder;
+
+            Tuple<string, long?> kv0 = Tuple.Create("test", (long?)1);
+            Tuple<string, long?> kv1 = Tuple.Create("other", (long?)123);
+            Tuple<string, long?> kv2 = Tuple.Create("kv", (long?)null);
+
+            builder.Append();
+            keyBuilder.Append("test");
+            valueBuilder.Append(1);
+
+            builder.AppendNull();
+
+            builder.Append();
+            keyBuilder.Append("other");
+            valueBuilder.Append(123);
+            keyBuilder.Append("kv");
+            valueBuilder.AppendNull();
+
+            MapArray array = builder.Build();
+
+            Assert.Equal(new Tuple<string, long?>[] { kv0 }, array.GetTuples<StringArray, string, Int64Array, long?>(0, GetKey, GetValue).ToArray());
+            Assert.True(array.IsNull(1));
+            Assert.Equal(new Tuple<string, long?>[] { kv1, kv2 }, array.GetTuples<StringArray, string, Int64Array, long?>(2, GetKey, GetValue).ToArray());
+        }
+
+        [Fact]
+        public void MapArray_Should_GetKeyValuePairs()
+        {
+            MapType type = new MapType(StringType.Default, Int32Type.Default);
+            MapArray.Builder builder = new MapArray.Builder(type);
+            var keyBuilder = builder.KeyBuilder as StringArray.Builder;
+            var valueBuilder = builder.ValueBuilder as Int32Array.Builder;
+
+            KeyValuePair<string, int?> kv0 = KeyValuePair.Create("test", (int?)1);
+            KeyValuePair<string, int?> kv1 = KeyValuePair.Create("other", (int?)123);
+            KeyValuePair<string, int?> kv2 = KeyValuePair.Create("kv", (int?)null);
+
+            builder.Append();
+            keyBuilder.Append("test");
+            valueBuilder.Append(1);
+
+            builder.AppendNull();
+
+            builder.Append();
+            keyBuilder.Append("other");
+            valueBuilder.Append(123);
+            keyBuilder.Append("kv");
+            valueBuilder.AppendNull();
+
+            MapArray array = builder.Build();
+
+            Assert.Equal(new KeyValuePair<string, int?>[] { kv0 }, array.GetKeyValuePairs<StringArray, string, Int32Array, int?>(0, GetKey, GetValue).ToArray());
+            Assert.True(array.IsNull(1));
+            Assert.Equal(new KeyValuePair<string, int?>[] { kv1, kv2 }, array.GetKeyValuePairs<StringArray, string, Int32Array, int?>(2, GetKey, GetValue).ToArray());
+        }
+
+        private static string GetKey(StringArray array, int index) => array.GetString(index);
+        private static int? GetValue(Int32Array array, int index) => array.GetValue(index);
+        private static long? GetValue(Int64Array array, int index) => array.GetValue(index);
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Tests/TableTests.cs b/csharp/test/Apache.Arrow.Tests/TableTests.cs
index 8b07a38c1b8c0..234dd63a79cd2 100644
--- a/csharp/test/Apache.Arrow.Tests/TableTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/TableTests.cs
@@ -60,7 +60,7 @@ public void TestTableFromRecordBatches()
 
             Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches);
             Assert.Equal(20, table1.RowCount);
-            Assert.Equal(26, table1.ColumnCount);
+            Assert.Equal(27, table1.ColumnCount);
 
             FixedSizeBinaryType type = new FixedSizeBinaryType(17);
             Field newField1 = new Field(type.Name, type, false);
diff --git a/csharp/test/Apache.Arrow.Tests/TestData.cs b/csharp/test/Apache.Arrow.Tests/TestData.cs
index 9e2061e3428a9..e3a40dbdafd61 100644
--- a/csharp/test/Apache.Arrow.Tests/TestData.cs
+++ b/csharp/test/Apache.Arrow.Tests/TestData.cs
@@ -54,6 +54,7 @@ public static RecordBatch CreateSampleRecordBatch(int length, int columnSetCount
                 builder.Field(CreateField(new StructType(new List<Field> { CreateField(StringType.Default, i), CreateField(Int32Type.Default, i) }), i));
                 builder.Field(CreateField(new Decimal128Type(10, 6), i));
                 builder.Field(CreateField(new Decimal256Type(16, 8), i));
+                builder.Field(CreateField(new MapType(StringType.Default, Int32Type.Default), i));
 
                 if (createAdvancedTypeArrays)
                 {
@@ -132,6 +133,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<Decimal256Type>,
             IArrowTypeVisitor<DictionaryType>,
             IArrowTypeVisitor<FixedSizeBinaryType>,
+            IArrowTypeVisitor<MapType>,
             IArrowTypeVisitor<NullType>
         {
             private int Length { get; }
@@ -261,7 +263,6 @@ public void Visit(ListType type)
             {
                 var builder = new ListArray.Builder(type.ValueField).Reserve(Length);
 
-                //Todo : Support various types
                 var valueBuilder = (Int64Array.Builder)builder.ValueBuilder.Reserve(Length + 1);
 
                 for (var i = 0; i < Length; i++)
@@ -279,7 +280,6 @@ public void Visit(FixedSizeListType type)
             {
                 var builder = new FixedSizeListArray.Builder(type.ValueField, type.ListSize).Reserve(Length);
 
-                //Todo : Support various types
                 var valueBuilder = (Int32Array.Builder)builder.ValueBuilder;
 
                 for (var i = 0; i < Length; i++)
@@ -410,6 +410,25 @@ public void Visit(FixedSizeBinaryType type)
                 Array = new FixedSizeBinaryArray(arrayData);
             }
 
+            public void Visit(MapType type)
+            {
+                MapArray.Builder builder = new MapArray.Builder(type).Reserve(Length);
+                var keyBuilder = builder.KeyBuilder.Reserve(Length + 1) as StringArray.Builder;
+                var valueBuilder = builder.ValueBuilder.Reserve(Length + 1) as Int32Array.Builder;
+
+                for (var i = 0; i < Length; i++)
+                {
+                    builder.Append();
+                    keyBuilder.Append(i.ToString());
+                    valueBuilder.Append(i);
+                }
+                //Add a value to check if Values.Length can exceed MapArray.Length
+                keyBuilder.Append("0");
+                valueBuilder.Append(0);
+
+                Array = builder.Build();
+            }
+
             public void Visit(NullType type)
             {
                 Array = new NullArray(Length);
diff --git a/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs b/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs
new file mode 100644
index 0000000000000..ba306ec104e79
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/Types/MapTypeTests.cs
@@ -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.
+
+using Apache.Arrow.Types;
+using Xunit;
+
+namespace Apache.Arrow.Tests.Types
+{
+    public class MapTypeTests
+    {
+        [Fact]
+        public void MapType_Should_HaveCorrectTypeId()
+        {
+            var type = new MapType(StringType.Default, Int32Type.Default);
+            Assert.Equal(ArrowTypeId.Map, type.TypeId);
+        }
+
+        [Fact]
+        public void MapType_Should_HaveCorrectStructType()
+        {
+            var type = new MapType(BooleanType.Default, Int32Type.Default, true);
+            Assert.IsType<StructType>(type.Fields[0].DataType);
+            Assert.Equal(2, type.KeyValueType.Fields.Count);
+
+            Assert.Equal("entries", type.Fields[0].Name);
+            Assert.Equal("key", type.KeyField.Name);
+            Assert.Equal("value", type.ValueField.Name);
+
+            Assert.False(type.Fields[0].IsNullable);
+            Assert.False(type.KeyField.IsNullable);
+            Assert.True(type.ValueField.IsNullable);
+            Assert.False(new MapType(BooleanType.Default, Int32Type.Default, false).ValueField.IsNullable);
+
+            Assert.IsType<BooleanType>(type.KeyField.DataType);
+            Assert.IsType<Int32Type>(type.ValueField.DataType);
+        }
+
+        [Fact]
+        public void MapType_Should_SetKeySorted()
+        {
+            Assert.False(new MapType(BooleanType.Default, Int32Type.Default).KeySorted);
+            Assert.True(new MapType(StringType.Default, Int32Type.Default, true, true).KeySorted);
+        }
+    }
+}
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 8d0cc6b0b01a8..01672fbe7488a 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1815,8 +1815,7 @@ def _temp_path():
         .skip_tester('C#')
         .skip_tester('JS'),
 
-        generate_map_case()
-        .skip_tester('C#'),
+        generate_map_case(),
 
         generate_non_canonical_map_case()
         .skip_tester('C#')
diff --git a/docs/source/status.rst b/docs/source/status.rst
index e2b3852e2229f..6024c1d3172bb 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -81,7 +81,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Struct            | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Map               | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Map               | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Dense Union       | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+

From 1cad7a787847add45261abe5acdd3ba080e54a75 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Thu, 5 Oct 2023 12:49:15 -0400
Subject: [PATCH 469/749] GH-35328: [Go][FlightSQL] Fix flaky test for
 FlightSql driver (#38044)

### Rationale for this change
Fixing a flaky test that is *very* difficult to reproduce.

### What changes are included in this PR?
Adding an explicit call to drain the remaining batches from the parameter batch reader in the `DoPutPreparedStatementQuery` of the `MockServer` in the tests. This ensures that the gRPC connection doesn't close on us in between the client writing the schema message and writing the record batch message producing an `io.EOF` error. This is an extremely rare occurence based on goroutine scheduling due to the client and mockserver both running in the same process for the tests, in local testing i was only able to get it to happen 1 - 4 times per 5000 runs of the test.

### Are there any user-facing changes?
No

* Closes: #35328

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/flight/flightsql/driver/driver_test.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go
index 3ec8533979a32..4449b390974a7 100644
--- a/go/arrow/flight/flightsql/driver/driver_test.go
+++ b/go/arrow/flight/flightsql/driver/driver_test.go
@@ -812,6 +812,17 @@ func (s *MockServer) DoPutPreparedStatementQuery(ctx context.Context, qry flight
 		return fmt.Errorf("parameter schema: %w", arrow.ErrInvalid)
 	}
 
+	// GH-35328: it's rare, but this function can complete execution and return
+	// closing the reader *after* the schema is written but *before* the parameter batch
+	// is written (race condition based on goroutine scheduling). In that situation,
+	// the client call to Write the parameter record batch will return an io.EOF because
+	// this end of the connection will have closed before it attempted to send the batch.
+	// This created a flaky test situation that was difficult to reproduce (1-4 failures
+	// in 5000 runs). We can avoid this flakiness by simply *explicitly* draining the
+	// record batch messages from the reader before returning.
+	for r.Next() {
+	}
+
 	return nil
 }
 

From 6d551aa88237325978f51dbe02773a0aec2bfe9d Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 5 Oct 2023 14:50:42 -0300
Subject: [PATCH 470/749] GH-37876: [Format] Add list-view specification to
 arrow format (#37877)

### Rationale for this change

More details in the draft implementations of this spec:

 - C++: #35345
 - Go: #37468

### What changes are included in this PR?

 - Some unrelated fixes to the spec text (I can extract these to another PR if necessary)
 - Changes to the spec text
 - Additions to the Flatbuffers specifications of the Arrow format

### Are these changes tested?

N/A.

### Are there any user-facing changes?

Changes in documentation and backwards compatible additions to the format spec.

* Closes: #37876

Lead-authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 docs/source/format/Columnar.rst | 125 ++++++++++++++++++++++++++++++--
 format/Schema.fbs               |  16 +++-
 2 files changed, 132 insertions(+), 9 deletions(-)

diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst
index afbe2a08ee28c..3f8cd946292ea 100644
--- a/docs/source/format/Columnar.rst
+++ b/docs/source/format/Columnar.rst
@@ -108,7 +108,7 @@ the different physical layouts defined by Arrow:
 * **Variable-size Binary**: a sequence of values each having a variable
   byte length. Two variants of this layout are supported using 32-bit
   and 64-bit length encoding.
-* **Views of Variable-size Binary**: a sequence of values each having a
+* **View of Variable-size Binary**: a sequence of values each having a
   variable byte length. In contrast to Variable-size Binary, the values
   of this layout are distributed across potentially multiple buffers
   instead of densely and sequentially packed in a single buffer.
@@ -118,6 +118,11 @@ the different physical layouts defined by Arrow:
   variable-length sequence of values taken from a child data type. Two
   variants of this layout are supported using 32-bit and 64-bit length
   encoding.
+* **View of Variable-size List**: a nested layout where each value is a
+  variable-length sequence of values taken from a child data type. This
+  layout differs from **Variable-size List** by having an additional
+  buffer containing the sizes of each list value. This removes a constraint
+  on the offsets buffer — it does not need to be in order.
 * **Struct**: a nested layout consisting of a collection of named
   child **fields** each having the same length but possibly different
   types.
@@ -382,7 +387,7 @@ In both the long and short string cases, the first four bytes encode the
 length of the string and can be used to determine how the rest of the view
 should be interpreted.
 
-In the short string case the string's bytes are inlined- stored inside the
+In the short string case the string's bytes are inlined — stored inside the
 view itself, in the twelve bytes which follow the length.
 
 In the long string case, a buffer index indicates which data buffer
@@ -405,7 +410,14 @@ Variable-size List Layout
 -------------------------
 
 List is a nested type which is semantically similar to variable-size
-binary. It is defined by two buffers, a validity bitmap and an offsets
+binary. There are two list layout variations — "list" and "list-view" —
+and each variation can be delimited by either 32-bit or 64-bit offsets
+integers.
+
+List Layout
+~~~~~~~~~~~
+
+The List layout is defined by two buffers, a validity bitmap and an offsets
 buffer, and a child array. The offsets are the same as in the
 variable-size binary case, and both 32-bit and 64-bit signed integer
 offsets are supported options for the offsets. Rather than referencing
@@ -441,7 +453,7 @@ will have the following representation: ::
       |------------|-------------|-------------|-------------|-------------|-----------------------|
       | 0          | 3           | 3           | 7           | 7           | unspecified (padding) |
 
-    * Values array (Int8array):
+    * Values array (Int8Array):
       * Length: 7,  Null count: 0
       * Validity bitmap buffer: Not required
       * Values buffer (int8)
@@ -487,6 +499,103 @@ will be represented as follows: ::
           |-------------------------------|-----------------------|
           | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | unspecified (padding) |
 
+ListView Layout
+~~~~~~~~~~~~~~~
+
+The ListView layout is defined by three buffers: a validity bitmap, an offsets
+buffer, and an additional sizes buffer. Sizes and offsets have the identical bit
+width and both 32-bit and 64-bit signed integer options are supported.
+
+As in the List layout, the offsets encode the start position of each slot in the
+child array. In contrast to the List layout, list lengths are stored explicitly
+in the sizes buffer instead of inferred. This allows offsets to be out of order.
+Elements of the child array do not have to be stored in the same order they
+logically appear in the list elements of the parent array.
+
+Every list-view value, including null values, has to guarantee the following
+invariants: ::
+
+    0 <= offsets[i] <= length of the child array
+    0 <= offsets[i] + size[i] <= length of the child array
+
+A list-view type is specified like ``ListView<T>``, where ``T`` is any type
+(primitive or nested). In these examples we use 32-bit offsets and sizes where
+the 64-bit version would be denoted by ``LargeListView<T>``.
+
+**Example Layout: ``ListView<Int8>`` Array**
+
+We illustrate an example of ``ListView<Int8>`` with length 4 having values::
+
+    [[12, -7, 25], null, [0, -127, 127, 50], []]
+
+It may have the following representation: ::
+
+    * Length: 4, Null count: 1
+    * Validity bitmap buffer:
+
+      | Byte 0 (validity bitmap) | Bytes 1-63            |
+      |--------------------------|-----------------------|
+      | 00001101                 | 0 (padding)           |
+
+    * Offsets buffer (int32)
+
+      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-63           |
+      |------------|-------------|-------------|-------------|-----------------------|
+      | 0          | 7           | 3           | 0           | unspecified (padding) |
+
+    * Sizes buffer (int32)
+
+      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-63           |
+      |------------|-------------|-------------|-------------|-----------------------|
+      | 3          | 0           | 4           | 0           | unspecified (padding) |
+
+    * Values array (Int8Array):
+      * Length: 7,  Null count: 0
+      * Validity bitmap buffer: Not required
+      * Values buffer (int8)
+
+        | Bytes 0-6                    | Bytes 7-63            |
+        |------------------------------|-----------------------|
+        | 12, -7, 25, 0, -127, 127, 50 | unspecified (padding) |
+
+**Example Layout: ``ListView<Int8>`` Array**
+
+We continue with the ``ListView<Int8>`` type, but this instance illustrates out
+of order offsets and sharing of child array values. It is an array with length 5
+having logical values::
+
+    [[12, -7, 25], null, [0, -127, 127, 50], [], [50, 12]]
+
+It may have the following representation: ::
+
+    * Length: 4, Null count: 1
+    * Validity bitmap buffer:
+
+      | Byte 0 (validity bitmap) | Bytes 1-63            |
+      |--------------------------|-----------------------|
+      | 00011101                 | 0 (padding)           |
+
+    * Offsets buffer (int32)
+
+      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63           |
+      |------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 4          | 7           | 0           | 0           | 3           | unspecified (padding) |
+
+    * Sizes buffer (int32)
+
+      | Bytes 0-3  | Bytes 4-7   | Bytes 8-11  | Bytes 12-15 | Bytes 16-19 | Bytes 20-63           |
+      |------------|-------------|-------------|-------------|-------------|-----------------------|
+      | 3          | 0           | 4           | 0           | 2           | unspecified (padding) |
+
+    * Values array (Int8Array):
+      * Length: 7,  Null count: 0
+      * Validity bitmap buffer: Not required
+      * Values buffer (int8)
+
+        | Bytes 0-6                    | Bytes 7-63            |
+        |------------------------------|-----------------------|
+        | 0, -127, 127, 50, 12, -7, 25 | unspecified (padding) |
+
 Fixed-Size List Layout
 ----------------------
 
@@ -858,19 +967,19 @@ are held in the second child array.
 For the purposes of determining field names and schemas, these child arrays
 are prescribed the standard names of **run_ends** and **values** respectively.
 
-The values in the first child array represent the accumulated length of all runs 
+The values in the first child array represent the accumulated length of all runs
 from the first to the current one, i.e. the logical index where the
 current run ends. This allows relatively efficient random access from a logical
 index using binary search. The length of an individual run can be determined by
 subtracting two adjacent values. (Contrast this with run-length encoding, in
 which the lengths of the runs are represented directly, and in which random
-access is less efficient.) 
+access is less efficient.)
 
 .. note::
    Because the ``run_ends`` child array cannot have nulls, it's reasonable
    to consider why the ``run_ends`` are a child array instead of just a
    buffer, like the offsets for a :ref:`variable-size-list-layout`. This
-   layout was considered, but it was decided to use the child arrays. 
+   layout was considered, but it was decided to use the child arrays.
 
    Child arrays allow us to keep the "logical length" (the decoded length)
    associated with the parent array and the "physical length" (the number
@@ -1122,7 +1231,7 @@ addresses between libraries, it is recommended to set ``size`` to the actual
 memory size rather than the padded size.
 
 Variadic buffers
-^^^^^^^^^^^^^^^^
+----------------
 
 Some types such as Utf8View are represented using a variable number of buffers.
 For each such Field in the pre-ordered flattened logical schema, there will be
diff --git a/format/Schema.fbs b/format/Schema.fbs
index fdaf623931760..70d9634463d61 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -22,7 +22,8 @@
 /// Version 1.1 - Add Decimal256.
 /// Version 1.2 - Add Interval MONTH_DAY_NANO.
 /// Version 1.3 - Add Run-End Encoded.
-/// Version 1.4 - Add BinaryView, Utf8View, and variadicBufferCounts.
+/// Version 1.4 - Add BinaryView, Utf8View, variadicBufferCounts, ListView, and
+/// LargeListView.
 
 namespace org.apache.arrow.flatbuf;
 
@@ -97,6 +98,17 @@ table List {
 table LargeList {
 }
 
+/// Represents the same logical types that List can, but contains offsets and
+/// sizes allowing for writes in any order and sharing of child values among
+/// list values.
+table ListView {
+}
+
+/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+/// extremely large data values.
+table LargeListView {
+}
+
 table FixedSizeList {
   /// Number of list items per value
   listSize: int;
@@ -451,6 +463,8 @@ union Type {
   RunEndEncoded,
   BinaryView,
   Utf8View,
+  ListView,
+  LargeListView,
 }
 
 /// ----------------------------------------------------------------------

From 47f547749a524086c592d87d3c1f48f12730d74e Mon Sep 17 00:00:00 2001
From: david dali susanibar arce <davi.sarces@gmail.com>
Date: Thu, 5 Oct 2023 13:35:55 -0500
Subject: [PATCH 471/749] GH-38005: [Java] disable the debug log when running
 Java tests (#38006)

### Rationale for this change

To disable the debug log when running Java tests

### What changes are included in this PR?

Java Testing resource that configure SLF4J API and adapters.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #38005

Authored-by: David Susanibar Arce <dsusanibar@Voltron.local>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/developers/java/development.rst   | 14 ++++++++++
 .../avro/src/test/resources/logback.xml       | 28 +++++++++++++++++++
 java/algorithm/src/test/resources/logback.xml | 28 +++++++++++++++++++
 .../src/test/resources/logback.xml            | 28 +++++++++++++++++++
 .../src/test/resources/logback.xml            | 28 +++++++++++++++++++
 .../src/test/resources/logback.xml            | 28 +++++++++++++++++++
 .../flight-sql/src/test/resources/logback.xml | 28 +++++++++++++++++++
 .../src/test/resources/logback.xml            | 28 +++++++++++++++++++
 .../src/test/resources/logback.xml            | 28 +++++++++++++++++++
 9 files changed, 238 insertions(+)
 create mode 100644 java/adapter/avro/src/test/resources/logback.xml
 create mode 100644 java/algorithm/src/test/resources/logback.xml
 create mode 100644 java/compression/src/test/resources/logback.xml
 create mode 100644 java/flight/flight-grpc/src/test/resources/logback.xml
 create mode 100644 java/flight/flight-integration-tests/src/test/resources/logback.xml
 create mode 100644 java/flight/flight-sql/src/test/resources/logback.xml
 create mode 100644 java/memory/memory-core/src/test/resources/logback.xml
 create mode 100644 java/memory/memory-unsafe/src/test/resources/logback.xml

diff --git a/docs/source/developers/java/development.rst b/docs/source/developers/java/development.rst
index ce7e1704f641c..f7b19d73da2e2 100644
--- a/docs/source/developers/java/development.rst
+++ b/docs/source/developers/java/development.rst
@@ -23,6 +23,20 @@ Development Guidelines
 
 .. contents::
 
+Logger Abstraction
+==================
+
+Apache Arrow Java uses the SLF4J API, so please configure SLF4J to see logs (e.g. via Logback/Apache Log4j):
+
+1. If no jar dependencies are added by the user via Logback or Apache Log4j then SLF4J will default
+   to no-operation (NOP) logging.
+
+2. If a user adds any dependencies via Logback or Apache Log4j but does not configure/add/define
+   logback.xml/log4j2.xml, then logs will default to DEBUG mode.
+
+3. To disable debug logs, the user must define their own rules within their logback.xml/log4j2.xml
+   and define their own loggers.
+
 Unit Testing
 ============
 Unit tests are run by Maven during the build.
diff --git a/java/adapter/avro/src/test/resources/logback.xml b/java/adapter/avro/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/adapter/avro/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/algorithm/src/test/resources/logback.xml b/java/algorithm/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/algorithm/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/compression/src/test/resources/logback.xml b/java/compression/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/compression/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/flight/flight-grpc/src/test/resources/logback.xml b/java/flight/flight-grpc/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/flight/flight-grpc/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/flight/flight-integration-tests/src/test/resources/logback.xml b/java/flight/flight-integration-tests/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..95fb0b37dc5d3
--- /dev/null
+++ b/java/flight/flight-integration-tests/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.deno.apache.arrow" additivity="false">
+    <level value="debug" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/flight/flight-sql/src/test/resources/logback.xml b/java/flight/flight-sql/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/flight/flight-sql/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/memory/memory-core/src/test/resources/logback.xml b/java/memory/memory-core/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/memory/memory-core/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>
diff --git a/java/memory/memory-unsafe/src/test/resources/logback.xml b/java/memory/memory-unsafe/src/test/resources/logback.xml
new file mode 100644
index 0000000000000..4c54d18a210ff
--- /dev/null
+++ b/java/memory/memory-unsafe/src/test/resources/logback.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+
+<configuration>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener"/>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <!-- encoders are assigned the type
+         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+
+  <logger name="org.apache.arrow" additivity="false">
+    <level value="info" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+</configuration>

From 050ccee9ff4e967a9e604f8e4829a2b400688ee1 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 6 Oct 2023 04:19:09 +0800
Subject: [PATCH 472/749] GH-38011: [C++][Dataset] Change force close to tend
 to close on write (#38030)

### Rationale for this change

`CloseLargestFile()` will failed to close when non of the file has written any rows.

### What changes are included in this PR?

Change `CloseLargestFile()` to `TryCloseLargestFile()`, and not throw error when it cannot find a file that haven't write any rows.

### Are these changes tested?

no

### Are there any user-facing changes?

bugfix

* Closes: #38011

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/dataset/dataset_writer.cc | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/dataset/dataset_writer.cc b/cpp/src/arrow/dataset/dataset_writer.cc
index 686c7712fe183..a2096d691b4bf 100644
--- a/cpp/src/arrow/dataset/dataset_writer.cc
+++ b/cpp/src/arrow/dataset/dataset_writer.cc
@@ -139,7 +139,7 @@ class DatasetWriterFileQueue {
       : options_(options), schema_(schema), writer_state_(writer_state) {}
 
   void Start(util::AsyncTaskScheduler* file_tasks, const std::string& filename) {
-    file_tasks_ = std::move(file_tasks);
+    file_tasks_ = file_tasks;
     // Because the scheduler runs one task at a time we know the writer will
     // be opened before any attempt to write
     file_tasks_->AddSimpleTask(
@@ -575,7 +575,7 @@ class DatasetWriter::DatasetWriterImpl {
   }
 
  protected:
-  Status CloseLargestFile() {
+  Status TryCloseLargestFile() {
     std::shared_ptr<DatasetWriterDirectoryQueue> largest = nullptr;
     uint64_t largest_num_rows = 0;
     for (auto& dir_queue : directory_queues_) {
@@ -584,7 +584,10 @@ class DatasetWriter::DatasetWriterImpl {
         largest = dir_queue.second;
       }
     }
-    DCHECK_NE(largest, nullptr);
+    if (largest == nullptr) {
+      // GH-38011: If all written files has written 0 rows, we should not close any file
+      return Status::OK();
+    }
     return largest->FinishCurrentFile();
   }
 
@@ -618,7 +621,7 @@ class DatasetWriter::DatasetWriterImpl {
         backpressure = writer_state_.open_files_throttle.Acquire(1);
         if (!backpressure.is_finished()) {
           EVENT_ON_CURRENT_SPAN("DatasetWriter::Backpressure::TooManyOpenFiles");
-          RETURN_NOT_OK(CloseLargestFile());
+          RETURN_NOT_OK(TryCloseLargestFile());
           break;
         }
       }

From 10843823ea7e8856c0ae1eb19143b7d786d334e7 Mon Sep 17 00:00:00 2001
From: Miguel Pragier <miguelpragier@gmail.com>
Date: Thu, 5 Oct 2023 22:36:25 +0200
Subject: [PATCH 473/749] GH-38017: [Go][FlightSQL] Increment types handled by
 internal converter (#38028)

### Rationale for this change
This PR targets flightsql.Driver, that complies with sql.Driver interface, from the stdlib. <br>

The driver has a resultset iterator: the type [Rows](https://github.com/apache/arrow/blob/7d834d65c37c17d1c19bfb497eadb983893c9ea0/go/arrow/flight/flightsql/driver/driver.go#L39). <br>

The method [Rows.Next()](https://github.com/apache/arrow/blob/7d834d65c37c17d1c19bfb497eadb983893c9ea0/go/arrow/flight/flightsql/driver/driver.go#L81), which populates the next row of data, lacks handling/treatment of some common types, as described in the [issue](https://github.com/apache/arrow/issues/38017). <br>

### What changes are included in this PR?
This PR includes the missing common basic data types for Rows.Next() method. <br>

### Are these changes tested?
The driver is already tested, but I also included unitary tests that cover not only the new types, but all the implemented types. <br>

### Are there any user-facing changes?
All the contracts and signatures, and the current types were preserved. <br>

Closes #38017

Authored-by: miguel pragier <miguel.pragier@ebnerstolz.de>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/flight/flightsql/driver/utils.go     |  50 ++++---
 .../flight/flightsql/driver/utils_test.go     | 126 ++++++++++++++++++
 2 files changed, 156 insertions(+), 20 deletions(-)
 create mode 100644 go/arrow/flight/flightsql/driver/utils_test.go

diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go
index a2ed4ef26e227..99352e7251c53 100644
--- a/go/arrow/flight/flightsql/driver/utils.go
+++ b/go/arrow/flight/flightsql/driver/utils.go
@@ -58,46 +58,56 @@ func (g grpcCredentials) RequireTransportSecurity() bool {
 
 // *** Type conversions ***
 func fromArrowType(arr arrow.Array, idx int) (interface{}, error) {
+	if arr.IsNull(idx) {
+		return nil, nil
+	}
+
 	switch c := arr.(type) {
 	case *array.Boolean:
 		return c.Value(idx), nil
 	case *array.Float16:
-		return float64(c.Value(idx).Float32()), nil
+		return c.Value(idx), nil
 	case *array.Float32:
-		return float64(c.Value(idx)), nil
+		return c.Value(idx), nil
 	case *array.Float64:
 		return c.Value(idx), nil
+	case *array.Decimal128:
+		v := arr.DataType().(*arrow.Decimal128Type)
+		return c.Value(idx).ToFloat64(v.Scale), nil
+	case *array.Decimal256:
+		v := arr.DataType().(*arrow.Decimal256Type)
+		return c.Value(idx).ToFloat64(v.Scale), nil
 	case *array.Int8:
-		return int64(c.Value(idx)), nil
+		return c.Value(idx), nil
 	case *array.Int16:
-		return int64(c.Value(idx)), nil
+		return c.Value(idx), nil
 	case *array.Int32:
-		return int64(c.Value(idx)), nil
+		return c.Value(idx), nil
 	case *array.Int64:
 		return c.Value(idx), nil
+	case *array.Binary:
+		return c.Value(idx), nil
 	case *array.String:
 		return c.Value(idx), nil
 	case *array.Time32:
-		dt, ok := arr.DataType().(*arrow.Time32Type)
-		if !ok {
-			return nil, fmt.Errorf("datatype %T not matching time32", arr.DataType())
-		}
+		d32 := arr.DataType().(*arrow.Time32Type)
 		v := c.Value(idx)
-		return v.ToTime(dt.TimeUnit()), nil
+		return v.ToTime(d32.TimeUnit()), nil
 	case *array.Time64:
-		dt, ok := arr.DataType().(*arrow.Time64Type)
-		if !ok {
-			return nil, fmt.Errorf("datatype %T not matching time64", arr.DataType())
-		}
+		d64 := arr.DataType().(*arrow.Time64Type)
 		v := c.Value(idx)
-		return v.ToTime(dt.TimeUnit()), nil
+		return v.ToTime(d64.TimeUnit()), nil
 	case *array.Timestamp:
-		dt, ok := arr.DataType().(*arrow.TimestampType)
-		if !ok {
-			return nil, fmt.Errorf("datatype %T not matching timestamp", arr.DataType())
-		}
+		ts := arr.DataType().(*arrow.TimestampType)
 		v := c.Value(idx)
-		return v.ToTime(dt.TimeUnit()), nil
+		return v.ToTime(ts.TimeUnit()), nil
+	case *array.Date64:
+		return c.Value(idx).ToTime(), nil
+	case *array.DayTimeInterval:
+		durationDays := time.Duration(c.Value(idx).Days*24) * time.Hour
+		duration := time.Duration(c.Value(idx).Milliseconds) * time.Millisecond
+
+		return durationDays + duration, nil
 	}
 
 	return nil, fmt.Errorf("type %T: %w", arr, ErrNotSupported)
diff --git a/go/arrow/flight/flightsql/driver/utils_test.go b/go/arrow/flight/flightsql/driver/utils_test.go
new file mode 100644
index 0000000000000..355c888f56cc4
--- /dev/null
+++ b/go/arrow/flight/flightsql/driver/utils_test.go
@@ -0,0 +1,126 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT 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 driver
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_fromArrowType(t *testing.T) {
+	fields := []arrow.Field{
+		{Name: "f1-bool", Type: arrow.FixedWidthTypes.Boolean},
+		{Name: "f2-f16", Type: arrow.FixedWidthTypes.Float16},
+		{Name: "f3-f32", Type: arrow.PrimitiveTypes.Float32},
+		{Name: "f4-f64", Type: arrow.PrimitiveTypes.Float64},
+		{Name: "f5-d128", Type: &arrow.Decimal128Type{}},
+		{Name: "f6-d256", Type: &arrow.Decimal256Type{}},
+		{Name: "f7-i8", Type: arrow.PrimitiveTypes.Int8},
+		{Name: "f8-i16", Type: arrow.PrimitiveTypes.Int16},
+		{Name: "f9-i32", Type: arrow.PrimitiveTypes.Int32},
+		{Name: "f10-i64", Type: arrow.PrimitiveTypes.Int64},
+		{Name: "f11-binary", Type: arrow.BinaryTypes.Binary},
+		{Name: "f12-string", Type: arrow.BinaryTypes.String},
+		{Name: "f13-t32s", Type: arrow.FixedWidthTypes.Time32s},
+		{Name: "f14-t64us", Type: arrow.FixedWidthTypes.Time64us},
+		{Name: "f15-ts_us", Type: arrow.FixedWidthTypes.Timestamp_ns},
+		{Name: "f16-d64", Type: arrow.FixedWidthTypes.Date64},
+		{Name: "f17-dti", Type: arrow.FixedWidthTypes.DayTimeInterval},
+	}
+
+	schema := arrow.NewSchema(fields, nil)
+	pool := memory.NewGoAllocator()
+	b := array.NewRecordBuilder(pool, schema)
+	defer b.Release()
+
+	b.Field(0).(*array.BooleanBuilder).Append(true)
+	b.Field(1).(*array.Float16Builder).Append(float16.New(1))
+	b.Field(2).(*array.Float32Builder).Append(1)
+	b.Field(3).(*array.Float64Builder).Append(1)
+	b.Field(4).(*array.Decimal128Builder).Append(decimal128.FromBigInt(big.NewInt(1)))
+	b.Field(5).(*array.Decimal256Builder).Append(decimal256.FromBigInt(big.NewInt(1)))
+	b.Field(6).(*array.Int8Builder).Append(1)
+	b.Field(7).(*array.Int16Builder).Append(1)
+	b.Field(8).(*array.Int32Builder).Append(1)
+	b.Field(9).(*array.Int64Builder).Append(1)
+	b.Field(10).(*array.BinaryBuilder).Append([]byte("a"))
+	b.Field(11).(*array.StringBuilder).Append("a")
+
+	t32, err := arrow.Time32FromString("12:30:00", arrow.Second)
+	require.NoError(t, err)
+
+	b.Field(12).(*array.Time32Builder).Append(t32)
+
+	t64, err := arrow.Time64FromString("12:00:00", arrow.Microsecond)
+	require.NoError(t, err)
+
+	b.Field(13).(*array.Time64Builder).Append(t64)
+
+	ts, err := arrow.TimestampFromString("1970-01-01T12:00:00", arrow.Nanosecond)
+	require.NoError(t, err)
+
+	fmt.Println(ts.ToTime(arrow.Nanosecond))
+
+	b.Field(14).(*array.TimestampBuilder).Append(ts)
+
+	testTime := time.Now()
+	b.Field(15).(*array.Date64Builder).Append(arrow.Date64FromTime(testTime))
+	b.Field(16).(*array.DayTimeIntervalBuilder).Append(arrow.DayTimeInterval{Days: 1, Milliseconds: 1000})
+
+	rec := b.NewRecord()
+	defer rec.Release()
+
+	tf := func(t *testing.T, idx int, want any) {
+		t.Run(fmt.Sprintf("fromArrowType %v %s", fields[idx].Type, fields[idx].Name), func(t *testing.T) {
+			v, err := fromArrowType(rec.Column(idx), 0)
+			if err != nil {
+				t.Fatalf("err when converting from arrow: %s", err)
+			}
+			if !reflect.DeepEqual(v, want) {
+				t.Fatalf("test failed, wanted %T %v got %T %v", want, want, v, v)
+			}
+		})
+	}
+
+	tf(t, 0, true)                                           // "f1-bool"
+	tf(t, 1, float16.New(1))                                 // "f2-f16"
+	tf(t, 2, float32(1))                                     // "f3-f32"
+	tf(t, 3, float64(1))                                     // "f4-f64"
+	tf(t, 4, float64(1))                                     // "f5-d128"
+	tf(t, 5, float64(1))                                     // "f6-d256"
+	tf(t, 6, int8(1))                                        // "f7-i8"
+	tf(t, 7, int16(1))                                       // "f8-i16"
+	tf(t, 8, int32(1))                                       // "f9-i32"
+	tf(t, 9, int64(1))                                       // "f10-i64"
+	tf(t, 10, []byte("a"))                                   // "f11-binary"
+	tf(t, 11, "a")                                           // "f12-string"
+	tf(t, 12, time.Date(1970, 1, 1, 12, 30, 0, 0, time.UTC)) // "f13-t32s"
+	tf(t, 13, time.Date(1970, 1, 1, 12, 0, 0, 0, time.UTC))  // "f14-t64us"
+	tf(t, 14, time.Date(1970, 1, 1, 12, 0, 0, 0, time.UTC))  // "f15-ts_us"
+	tf(t, 15, testTime.In(time.UTC).Truncate(24*time.Hour))  // "f16-d64"
+	tf(t, 16, time.Duration(24*time.Hour+time.Second))       // "f17-dti"
+}

From 41359dc070c63e8bfa83ca8095266e5426cc6c43 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 5 Oct 2023 17:56:31 -0400
Subject: [PATCH 474/749] GH-37742: [Python] Enable Cython 3 (#37743)

### Rationale for this change

Enable Cython 3.

### What changes are included in this PR?

* Unpin Cython version in builds.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes, pyarrow will build with cython 3 by default.
* Closes: #37742

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 .github/workflows/dev.yml               | 2 +-
 ci/conda_env_python.txt                 | 2 +-
 dev/release/verify-release-candidate.sh | 2 +-
 python/pyproject.toml                   | 2 +-
 python/requirements-build.txt           | 2 +-
 python/requirements-wheel-build.txt     | 2 +-
 python/setup.py                         | 6 +++---
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index cee3c74762c3c..cfa9ffb49d7ad 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -103,7 +103,7 @@ jobs:
         shell: bash
         run: |
           gem install test-unit
-          pip install "cython<3" setuptools six pytest jira
+          pip install "cython>=0.29.31" setuptools six pytest jira
       - name: Run Release Test
         env:
           ARROW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/ci/conda_env_python.txt b/ci/conda_env_python.txt
index d914229ec58c0..da52b5ea689be 100644
--- a/ci/conda_env_python.txt
+++ b/ci/conda_env_python.txt
@@ -18,7 +18,7 @@
 # don't add pandas here, because it is not a mandatory test dependency
 boto3  # not a direct dependency of s3fs, but needed for our s3fs fixture
 cffi
-cython<3
+cython>=0.29.31
 cloudpickle
 fsspec
 hypothesis
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index ae28ebe792404..21a3b84a875f4 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -666,7 +666,7 @@ test_python() {
   show_header "Build and test Python libraries"
 
   # Build and test Python
-  maybe_setup_virtualenv "cython<3" numpy "setuptools_scm<8.0.0" setuptools || exit 1
+  maybe_setup_virtualenv "cython>=0.29.31" numpy "setuptools_scm<8.0.0" setuptools || exit 1
   maybe_setup_conda --file ci/conda_env_python.txt || exit 1
 
   if [ "${USE_CONDA}" -gt 0 ]; then
diff --git a/python/pyproject.toml b/python/pyproject.toml
index a1de6ac4f1c7e..437de105ab8e7 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -17,7 +17,7 @@
 
 [build-system]
 requires = [
-    "cython >= 0.29.31,<3",
+    "cython >= 0.29.31",
     "oldest-supported-numpy>=0.14",
     "setuptools_scm < 8.0.0",
     "setuptools >= 40.1.0",
diff --git a/python/requirements-build.txt b/python/requirements-build.txt
index efd653ec470d5..56e9d479ee9ba 100644
--- a/python/requirements-build.txt
+++ b/python/requirements-build.txt
@@ -1,4 +1,4 @@
-cython>=0.29.31,<3
+cython>=0.29.31
 oldest-supported-numpy>=0.14
 setuptools_scm<8.0.0
 setuptools>=38.6.0
diff --git a/python/requirements-wheel-build.txt b/python/requirements-wheel-build.txt
index 00504b0c731a1..f42ee4a018f3c 100644
--- a/python/requirements-wheel-build.txt
+++ b/python/requirements-wheel-build.txt
@@ -1,4 +1,4 @@
-cython>=0.29.31,<3
+cython>=0.29.31
 oldest-supported-numpy>=0.14
 setuptools_scm<8.0.0
 setuptools>=58
diff --git a/python/setup.py b/python/setup.py
index 062aac307b1e4..6934161fe6d2c 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -40,9 +40,9 @@
 # Check if we're running 64-bit Python
 is_64_bit = sys.maxsize > 2**32
 
-if Cython.__version__ < '0.29.31' or Cython.__version__ >= '3.0':
+if Cython.__version__ < '0.29.31':
     raise Exception(
-        'Please update your Cython version. Supported Cython >= 0.29.31, < 3.0')
+        'Please update your Cython version. Supported Cython >= 0.29.31')
 
 setup_dir = os.path.abspath(os.path.dirname(__file__))
 
@@ -492,7 +492,7 @@ def has_ext_modules(foo):
                                  'pyarrow/_generated_version.py'),
         'version_scheme': guess_next_dev_version
     },
-    setup_requires=['setuptools_scm < 8.0.0', 'cython >= 0.29.31,<3'] + setup_requires,
+    setup_requires=['setuptools_scm < 8.0.0', 'cython >= 0.29.31'] + setup_requires,
     install_requires=install_requires,
     tests_require=['pytest', 'pandas', 'hypothesis'],
     python_requires='>=3.8',

From bcbc70794101bff37ff9d02259bdc6533c91850a Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 5 Oct 2023 20:07:18 -0400
Subject: [PATCH 475/749] GH-38057: [Python][CI] Fix flaky hypothesis tests
 (#38058)

### Rationale for this change

Some hypothesis tests are consistently flaky due to taking too long to generate examples. "Too long" is ~2 seconds so let's just suppress the warnings. It is suppressed only for a small number of tests.

### What changes are included in this PR?

* Suppress hypothesis warnings for test data generation being too slow (> 2 seconds).

### Are these changes tested?

Will test the hypothesis CI job here.

### Are there any user-facing changes?

No
* Closes: #38057

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/tests/test_array.py | 1 +
 python/pyarrow/tests/test_types.py | 1 +
 2 files changed, 2 insertions(+)

diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py
index fca094b519fa5..cd565a72bc19f 100644
--- a/python/pyarrow/tests/test_array.py
+++ b/python/pyarrow/tests/test_array.py
@@ -2020,6 +2020,7 @@ def test_array_pickle_dictionary(pickle_module):
         assert array.equals(result)
 
 
+@h.settings(suppress_health_check=(h.HealthCheck.too_slow,))
 @h.given(
     past.arrays(
         past.all_types,
diff --git a/python/pyarrow/tests/test_types.py b/python/pyarrow/tests/test_types.py
index f3b6001003d9c..660765f3361ae 100644
--- a/python/pyarrow/tests/test_types.py
+++ b/python/pyarrow/tests/test_types.py
@@ -1184,6 +1184,7 @@ def test_is_boolean_value():
     assert pa.types.is_boolean_value(np.bool_(False))
 
 
+@h.settings(suppress_health_check=(h.HealthCheck.too_slow,))
 @h.given(
     past.all_types |
     past.all_fields |

From d7017dd0dc567969c79d14aefc3d5a638e66270a Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Fri, 6 Oct 2023 09:26:14 +0200
Subject: [PATCH 476/749] GH-36765: [Python][Dataset] Change default of
 pre_buffer to True for reading Parquet files (#37854)

### Rationale for this change

Enabling `pre_buffer` can give a significant speed-up on filesystems like S3, while it doesn't give noticeable slowdown on local filesystems, based on benchmarks in the issue. Therefore simply enabling it by default seems the best default.

The option was already enabled by default in the `pyarrow.parquet.read_table` interface, this PR aligns the defaults when using `pyarrow.dataset` directly.
* Closes: #36765

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/parquet/arrow/arrow_reader_writer_test.cc |  7 ++++---
 cpp/src/parquet/properties.h                      |  4 ++--
 python/pyarrow/_dataset_parquet.pyx               |  9 ++++++---
 python/pyarrow/parquet/core.py                    |  5 +++--
 python/pyarrow/tests/test_dataset.py              | 10 +++++-----
 5 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 8585b1ccf11aa..7a94b1f3a1c14 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -2354,10 +2354,11 @@ void TestGetRecordBatchReader(
 
 TEST(TestArrowReadWrite, GetRecordBatchReader) { TestGetRecordBatchReader(); }
 
-// Same as the test above, but using coalesced reads.
-TEST(TestArrowReadWrite, CoalescedReads) {
+// Same as the test above, but using non-coalesced reads.
+TEST(TestArrowReadWrite, NoneCoalescedReads) {
   ArrowReaderProperties arrow_properties = default_arrow_reader_properties();
-  arrow_properties.set_pre_buffer(true);
+  arrow_properties.set_pre_buffer(false);
+  arrow_properties.set_cache_options(::arrow::io::CacheOptions::Defaults())
   TestGetRecordBatchReader(arrow_properties);
 }
 
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index 9344181d3f82f..c15ada0a8060f 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -836,8 +836,8 @@ class PARQUET_EXPORT ArrowReaderProperties {
       : use_threads_(use_threads),
         read_dict_indices_(),
         batch_size_(kArrowDefaultBatchSize),
-        pre_buffer_(false),
-        cache_options_(::arrow::io::CacheOptions::Defaults()),
+        pre_buffer_(true),
+        cache_options_(::arrow::io::CacheOptions::LazyDefaults()),
         coerce_int96_timestamp_unit_(::arrow::TimeUnit::NANO) {}
 
   /// \brief Set whether to use the IO thread pool to parse columns in parallel.
diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx
index cf5c44c1c964a..9d85142564011 100644
--- a/python/pyarrow/_dataset_parquet.pyx
+++ b/python/pyarrow/_dataset_parquet.pyx
@@ -666,10 +666,13 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
         Disabled by default.
     buffer_size : int, default 8192
         Size of buffered stream, if enabled. Default is 8KB.
-    pre_buffer : bool, default False
+    pre_buffer : bool, default True
         If enabled, pre-buffer the raw Parquet data instead of issuing one
         read per column chunk. This can improve performance on high-latency
-        filesystems.
+        filesystems (e.g. S3, GCS) by coalesing and issuing file reads in
+        parallel using a background I/O thread pool.
+        Set to False if you want to prioritize minimal memory usage
+        over maximum speed.
     thrift_string_size_limit : int, default None
         If not None, override the maximum total string size allocated
         when decoding Thrift structures. The default limit should be
@@ -688,7 +691,7 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
 
     def __init__(self, *, bint use_buffered_stream=False,
                  buffer_size=8192,
-                 bint pre_buffer=False,
+                 bint pre_buffer=True,
                  thrift_string_size_limit=None,
                  thrift_container_size_limit=None):
         self.init(shared_ptr[CFragmentScanOptions](
diff --git a/python/pyarrow/parquet/core.py b/python/pyarrow/parquet/core.py
index e0cdfee62ef4b..a3e5ef76c99b6 100644
--- a/python/pyarrow/parquet/core.py
+++ b/python/pyarrow/parquet/core.py
@@ -1742,11 +1742,12 @@ class ParquetDataset:
     different partitioning schemes, etc.
 pre_buffer : bool, default True
     Coalesce and issue file reads in parallel to improve performance on
-    high-latency filesystems (e.g. S3). If True, Arrow will use a
+    high-latency filesystems (e.g. S3, GCS). If True, Arrow will use a
     background I/O thread pool. This option is only supported for
     use_legacy_dataset=False. If using a filesystem layer that itself
     performs readahead (e.g. fsspec's S3FS), disable readahead for best
-    results.
+    results. Set to False if you want to prioritize minimal memory usage
+    over maximum speed.
 coerce_int96_timestamp_unit : str, default None
     Cast timestamps that are stored in INT96 format to a particular resolution
     (e.g. 'ms'). Setting to None is equivalent to 'ns' and therefore INT96
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index 39c3c43daea37..671405d1ee6a0 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -784,28 +784,28 @@ def test_parquet_scan_options():
     opts2 = ds.ParquetFragmentScanOptions(buffer_size=4096)
     opts3 = ds.ParquetFragmentScanOptions(
         buffer_size=2**13, use_buffered_stream=True)
-    opts4 = ds.ParquetFragmentScanOptions(buffer_size=2**13, pre_buffer=True)
+    opts4 = ds.ParquetFragmentScanOptions(buffer_size=2**13, pre_buffer=False)
     opts5 = ds.ParquetFragmentScanOptions(
         thrift_string_size_limit=123456,
         thrift_container_size_limit=987654,)
 
     assert opts1.use_buffered_stream is False
     assert opts1.buffer_size == 2**13
-    assert opts1.pre_buffer is False
+    assert opts1.pre_buffer is True
     assert opts1.thrift_string_size_limit == 100_000_000  # default in C++
     assert opts1.thrift_container_size_limit == 1_000_000  # default in C++
 
     assert opts2.use_buffered_stream is False
     assert opts2.buffer_size == 2**12
-    assert opts2.pre_buffer is False
+    assert opts2.pre_buffer is True
 
     assert opts3.use_buffered_stream is True
     assert opts3.buffer_size == 2**13
-    assert opts3.pre_buffer is False
+    assert opts3.pre_buffer is True
 
     assert opts4.use_buffered_stream is False
     assert opts4.buffer_size == 2**13
-    assert opts4.pre_buffer is True
+    assert opts4.pre_buffer is False
 
     assert opts5.thrift_string_size_limit == 123456
     assert opts5.thrift_container_size_limit == 987654

From e1d7459bce3f10c941cec1665b15d3388cbe5adb Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Fri, 6 Oct 2023 10:07:54 +0200
Subject: [PATCH 477/749] GH-36666: [Python][CI] Re-enable skipped dask
 test_pandas_timestamp_overflow_pyarrow test (#38066)

* Closes: #36666

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/integration_dask.sh | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/ci/scripts/integration_dask.sh b/ci/scripts/integration_dask.sh
index 5b57fb486aa6c..f91d21b921708 100755
--- a/ci/scripts/integration_dask.sh
+++ b/ci/scripts/integration_dask.sh
@@ -34,10 +34,7 @@ python -c "import dask.dataframe"
 # The "skip_with_pyarrow_strings" marker is meant to skip automatically, but that doesn't work with --pyargs, so de-selecting manually
 pytest -v --pyargs dask.dataframe.tests.test_dataframe -m "not skip_with_pyarrow_strings"
 pytest -v --pyargs dask.dataframe.io.tests.test_orc
-# skip failing parquet tests
-# test_pandas_timestamp_overflow_pyarrow is skipped because of GH-33321.
 pytest -v --pyargs dask.dataframe.io.tests.test_parquet \
-  -k "not test_pandas_timestamp_overflow_pyarrow" \
   -m "not skip_with_pyarrow_strings and not xfail_with_pyarrow_strings"
 # this file contains parquet tests that use S3 filesystem
 pytest -v --pyargs dask.bytes.tests.test_s3

From b30d9616bb5056692b4b90a5e67b9a5ac206b2d0 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 6 Oct 2023 19:41:14 +0800
Subject: [PATCH 478/749] GH-38068: [C++][CI] Fixing Parquet unittest
 `arrow_reader_writer_test.cc` compile (#38069)

### Rationale for this change

This is introduced in a previous patch. This patch fixed the compile. ( https://github.com/apache/arrow/pull/37854 )

### What changes are included in this PR?

a one-line fixing.

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #38068

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/parquet/arrow/arrow_reader_writer_test.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 7a94b1f3a1c14..315405ef1e569 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -2358,7 +2358,7 @@ TEST(TestArrowReadWrite, GetRecordBatchReader) { TestGetRecordBatchReader(); }
 TEST(TestArrowReadWrite, NoneCoalescedReads) {
   ArrowReaderProperties arrow_properties = default_arrow_reader_properties();
   arrow_properties.set_pre_buffer(false);
-  arrow_properties.set_cache_options(::arrow::io::CacheOptions::Defaults())
+  arrow_properties.set_cache_options(::arrow::io::CacheOptions::Defaults());
   TestGetRecordBatchReader(arrow_properties);
 }
 

From fdecb6a0bee5fb482705de14c161853fe2ea2b41 Mon Sep 17 00:00:00 2001
From: Jonathan Keane <jkeane@gmail.com>
Date: Fri, 6 Oct 2023 09:21:31 -0500
Subject: [PATCH 479/749] GH-38049: [R] Prevent `on_rosetta()` from warning
 (#38052)

### Rationale for this change

Stop extraneous warnings.

### What changes are included in this PR?

Prevent warning when detecting translation, but on x86

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes, there will be fewer extraneous warnings.
* Closes: #38049

Authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/R/arrow-package.R                   |  5 +++--
 r/tests/testthat/test-arrow-pacakge.R | 21 +++++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 r/tests/testthat/test-arrow-pacakge.R

diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R
index 09183250ba3e0..54218bbf85476 100644
--- a/r/R/arrow-package.R
+++ b/r/R/arrow-package.R
@@ -183,7 +183,7 @@ configure_tzdb <- function() {
   # Just to be extra safe, let's wrap this in a try();
   # we don't want a failed startup message to prevent the package from loading
   try({
-        # On MacOS only, Check if we are running in under emulation, and warn this will not work
+    # On MacOS only, Check if we are running in under emulation, and warn this will not work
     if (on_rosetta()) {
       packageStartupMessage(
         paste(
@@ -242,8 +242,9 @@ on_macos_10_13_or_lower <- function() {
 }
 
 on_rosetta <- function() {
+  # make sure to suppress warnings and ignore the stdout + stderr so that this is silent
   identical(tolower(Sys.info()[["sysname"]]), "darwin") &&
-    identical(system("sysctl -n sysctl.proc_translated", intern = TRUE), "1")
+    identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)), "1")
 }
 
 option_use_threads <- function() {
diff --git a/r/tests/testthat/test-arrow-pacakge.R b/r/tests/testthat/test-arrow-pacakge.R
new file mode 100644
index 0000000000000..2d79467fa30a9
--- /dev/null
+++ b/r/tests/testthat/test-arrow-pacakge.R
@@ -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.
+
+test_that("on_rosetta() does not warn", {
+  # There is no warning
+  expect_warning(on_rosetta(), NA)
+})

From 0d89741771a69ed5ea4ce34a224c26dfca09f26d Mon Sep 17 00:00:00 2001
From: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Date: Fri, 6 Oct 2023 10:31:16 -0400
Subject: [PATCH 480/749] GH-37651: [C#] expose
 ArrowArrayConcatenator.Concatenate (#37652)

### Rationale for this change

New C# drivers need the ability to concatenate arrays, particularly for metadata calls.

### What changes are included in this PR?

Converts a previously internal class and method to a public class and method.

### Are these changes tested?

No substantive product changes were made. All tests still pass.

### Are there any user-facing changes?

It exposes previously hidden functionality.

Resolves https://github.com/apache/arrow/issues/37651

* Closes: #37651

Lead-authored-by: David Coe <coedavid@umich.edu>
Co-authored-by: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../Arrays/ArrowArrayConcatenator.cs          |  4 ++--
 .../ArrowArrayConcatenatorTests.cs            | 19 ++++---------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs
index cc151210aec6b..ac8252211eae4 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayConcatenator.cs
@@ -18,9 +18,9 @@
 
 namespace Apache.Arrow
 {
-    static class ArrowArrayConcatenator
+    public static class ArrowArrayConcatenator
     {
-        internal static IArrowArray Concatenate(IReadOnlyList<IArrowArray> arrowArrayList , MemoryAllocator allocator = default)
+        public static IArrowArray Concatenate(IReadOnlyList<IArrowArray> arrowArrayList , MemoryAllocator allocator = default)
         {
             if(arrowArrayList == null || arrowArrayList.Count == 0)
             {
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
index f1dcbb5d37b8f..6f4c17a959981 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
@@ -30,7 +30,7 @@ public void TestStandardCases()
         {
             foreach ((List<IArrowArray> testTargetArrayList, IArrowArray expectedArray) in GenerateTestData())
             {
-                IArrowArray actualArray = ArrowArrayConcatenatorReflector.InvokeConcatenate(testTargetArrayList);
+                IArrowArray actualArray = ArrowArrayConcatenator.Concatenate(testTargetArrayList);
                 ArrowReaderVerifier.CompareArrays(expectedArray, actualArray);
             }
         }
@@ -38,15 +38,15 @@ public void TestStandardCases()
         [Fact]
         public void TestNullOrEmpty()
         {
-            Assert.Null(ArrowArrayConcatenatorReflector.InvokeConcatenate(null));
-            Assert.Null(ArrowArrayConcatenatorReflector.InvokeConcatenate(new List<IArrowArray>()));
+            Assert.Null(ArrowArrayConcatenator.Concatenate(null));
+            Assert.Null(ArrowArrayConcatenator.Concatenate(new List<IArrowArray>()));
         }
 
         [Fact]
         public void TestSingleElement()
         {
             Int32Array array = new Int32Array.Builder().Append(1).Append(2).Build();
-            IArrowArray actualArray = ArrowArrayConcatenatorReflector.InvokeConcatenate(new[] { array });
+            IArrowArray actualArray = ArrowArrayConcatenator.Concatenate(new[] { array });
             ArrowReaderVerifier.CompareArrays(array, actualArray);
         }
 
@@ -107,17 +107,6 @@ private static IEnumerable<Tuple<List<IArrowArray>, IArrowArray>> GenerateTestDa
             }
         }
 
-        private static class ArrowArrayConcatenatorReflector
-        {
-            private static readonly MethodInfo s_concatenateInfo = typeof(ArrayData).Assembly.GetType("Apache.Arrow.ArrowArrayConcatenator")
-                .GetMethod("Concatenate", BindingFlags.Static | BindingFlags.NonPublic);
-
-            internal static IArrowArray InvokeConcatenate(IReadOnlyList<IArrowArray> arrowArrayList, MemoryAllocator allocator = default)
-            {
-                return s_concatenateInfo.Invoke(null, new object[] { arrowArrayList, allocator }) as IArrowArray;
-            }
-        }
-
         private class TestDataGenerator :
             IArrowTypeVisitor<BooleanType>,
             IArrowTypeVisitor<Int8Type>,

From 5ad1cae024a0f3bc67ac49fa6d4d72d36afb2384 Mon Sep 17 00:00:00 2001
From: Jonathan Keane <jkeane@gmail.com>
Date: Fri, 6 Oct 2023 12:01:13 -0500
Subject: [PATCH 481/749] MINOR: [R] Fix the error of ignoring stdout in
 `on_rosetta()` (#38083)

### Rationale for this change

A follow on to #38052 which introduced a small bug

### What changes are included in this PR?

Don't ignore the stdout which is the mechanism to tell if under emulation.

### Are these changes tested?

I tested these locally:

On an M2 with emulation:

```
> identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)), "1")
[1] FALSE
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)
character(0)
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)
[1] "1"
> identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
[1] TRUE
```

On an M2 without emulation:

```
> identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)), "1")
[1] FALSE
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)
character(0)
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)
[1] "0"
> identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
[1] FALSE
```

On an x86 (note the warning message suppression is what #38052 resolved):

```
>  identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)), "1")
[1] FALSE
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)
character(0)
attr(,"status")
[1] 1
Warning message:
In system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE,  :
  running command 'sysctl -n sysctl.proc_translated >/dev/null 2>/dev/null' had status 1
> system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)
character(0)
attr(,"status")
[1] 1
Warning message:
In system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE) :
  running command 'sysctl -n sysctl.proc_translated 2>/dev/null' had status 1
> identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
[1] FALSE
```

### Are there any user-facing changes?

No / the functionality is restored

Authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/R/arrow-package.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R
index 54218bbf85476..8655bf5a1cc68 100644
--- a/r/R/arrow-package.R
+++ b/r/R/arrow-package.R
@@ -244,7 +244,7 @@ on_macos_10_13_or_lower <- function() {
 on_rosetta <- function() {
   # make sure to suppress warnings and ignore the stdout + stderr so that this is silent
   identical(tolower(Sys.info()[["sysname"]]), "darwin") &&
-    identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE, ignore.stdout = TRUE)), "1")
+    identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
 }
 
 option_use_threads <- function() {

From 629ecbd8fd62173b62758282ca113a331940be4f Mon Sep 17 00:00:00 2001
From: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Date: Fri, 6 Oct 2023 14:30:56 -0400
Subject: [PATCH 482/749] GH-37730: [C#] throw OverflowException in
 DecimalUtility if fractionalPart is too large (#37731)

### Rationale for this change

In BigQuery, the BIGNUMERIC supports very large precision and scale values, which causes an error in the DecimalUtility due to the `fractionalPart` of the value being larger than .NET's maximum decimal value.

### What changes are included in this PR?

1. Throws an OverflowException with the entire original value
2. Changes the original OverflowException to also include the original value (which can be parsed as a string by downstream drivers).

### Are these changes tested?

Yes, tests are added for this scenario.

### Are there any user-facing changes?

* Closes: #37730

Lead-authored-by: David Coe <coedavid@umich.edu>
Co-authored-by: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 csharp/src/Apache.Arrow/DecimalUtility.cs     | 15 +++++++++++++--
 .../Apache.Arrow.Tests/DecimalUtilityTests.cs | 19 +++++++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/csharp/src/Apache.Arrow/DecimalUtility.cs b/csharp/src/Apache.Arrow/DecimalUtility.cs
index c117c263612fe..4a29d068c6eff 100644
--- a/csharp/src/Apache.Arrow/DecimalUtility.cs
+++ b/csharp/src/Apache.Arrow/DecimalUtility.cs
@@ -50,10 +50,21 @@ internal static decimal GetDecimal(in ArrowBuffer valueBuffer, int index, int sc
             {
                 BigInteger scaleBy = BigInteger.Pow(10, scale);
                 BigInteger integerPart = BigInteger.DivRem(integerValue, scaleBy, out BigInteger fractionalPart);
-                if (integerPart > _maxDecimal || integerPart < _minDecimal) // decimal overflow, not much we can do here - C# needs a BigDecimal
+
+                // decimal overflow, not much we can do here - C# needs a BigDecimal
+                if (integerPart > _maxDecimal)
+                {
+                    throw new OverflowException($"Value: {integerPart} of {integerValue} is too big be represented as a decimal");
+                }
+                else if (integerPart < _minDecimal) 
                 {
-                    throw new OverflowException($"Value: {integerPart} too big or too small to be represented as a decimal");
+                    throw new OverflowException($"Value: {integerPart} of {integerValue} is too small be represented as a decimal");
                 }
+                else if (fractionalPart > _maxDecimal || fractionalPart < _minDecimal)
+                {
+                    throw new OverflowException($"Value: {fractionalPart} of {integerValue} is too precise be represented as a decimal");
+                }
+
                 return (decimal)integerPart + DivideByScale(fractionalPart, scale);
             }
             else
diff --git a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
index d235524d9110c..9c7e5b587cb9d 100644
--- a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
@@ -46,6 +46,25 @@ public void HasExpectedResultOrThrows(decimal d, int precision , int scale, bool
                     Assert.Equal(d, result.GetValue(0));
                 }
             }
+
+            [Theory]
+            [InlineData(4.56, 38, 9, false)]
+            [InlineData(7.89, 76, 38, true)]
+            public void Decimal256HasExpectedResultOrThrows(decimal d, int precision, int scale, bool shouldThrow)
+            {
+                var builder = new Decimal256Array.Builder(new Decimal256Type(precision, scale));
+                builder.Append(d);
+                Decimal256Array result = builder.Build(new TestMemoryAllocator()); ;
+                
+                if (shouldThrow)
+                {
+                    Assert.Throws<OverflowException>(() => result.GetValue(0));
+                }
+                else
+                {
+                    Assert.Equal(d, result.GetValue(0));
+                }
+            }
         }
     }
 }

From f525b99b0fa0c49da656b0f45c4a0689934621d5 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Fri, 6 Oct 2023 17:09:26 -0300
Subject: [PATCH 483/749] GH-38084: [R] Do not memory map when explicitly
 checking for file removal (#38085)

### Rationale for this change

We have failing CI on Windows because removing files that have memory mapped sections is not allowed.

### What changes are included in this PR?

Pass `mmap = FALSE` when we explicitly check for removal. I think the other cases are OK because `unlink()` fails silently (which is maybe why we haven't seen mass CI failures because of this issue before).

### Are these changes tested?

The changes are covered by existing tests.

### Are there any user-facing changes?

No.

* Closes: #38084

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/R/parquet.R                             |  6 ++++--
 r/man/read_parquet.Rd                     |  3 +++
 r/tests/testthat/test-parquet.R           | 20 +++++++++++++-------
 r/tests/testthat/test-read-record-batch.R |  2 +-
 4 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/r/R/parquet.R b/r/R/parquet.R
index a58f7810b6ec7..74f51767a29c4 100644
--- a/r/R/parquet.R
+++ b/r/R/parquet.R
@@ -22,6 +22,7 @@
 #'
 #' @inheritParams read_feather
 #' @param props [ParquetArrowReaderProperties]
+#' @param mmap Use TRUE to use memory mapping where possible
 #' @param ... Additional arguments passed to `ParquetFileReader$create()`
 #'
 #' @return A `tibble` if `as_data_frame` is `TRUE` (the default), or an
@@ -43,14 +44,15 @@ read_parquet <- function(file,
                          # Assembling `props` yourself is something you do with
                          # ParquetFileReader but not here.
                          props = ParquetArrowReaderProperties$create(),
+                         mmap = TRUE,
                          ...) {
   if (!inherits(file, "RandomAccessFile")) {
     # Compression is handled inside the parquet file format, so we don't need
     # to detect from the file extension and wrap in a CompressedInputStream
-    file <- make_readable_file(file)
+    file <- make_readable_file(file, mmap = mmap)
     on.exit(file$close())
   }
-  reader <- ParquetFileReader$create(file, props = props, ...)
+  reader <- ParquetFileReader$create(file, props = props, mmap = mmap, ...)
 
   col_select <- enquo(col_select)
   if (!quo_is_null(col_select)) {
diff --git a/r/man/read_parquet.Rd b/r/man/read_parquet.Rd
index 3bb76cc2e30ca..4f1936529531a 100644
--- a/r/man/read_parquet.Rd
+++ b/r/man/read_parquet.Rd
@@ -9,6 +9,7 @@ read_parquet(
   col_select = NULL,
   as_data_frame = TRUE,
   props = ParquetArrowReaderProperties$create(),
+  mmap = TRUE,
   ...
 )
 }
@@ -29,6 +30,8 @@ an Arrow \link{Table}?}
 
 \item{props}{\link{ParquetArrowReaderProperties}}
 
+\item{mmap}{Use TRUE to use memory mapping where possible}
+
 \item{...}{Additional arguments passed to \code{ParquetFileReader$create()}}
 }
 \value{
diff --git a/r/tests/testthat/test-parquet.R b/r/tests/testthat/test-parquet.R
index dbc4a0473561f..f2359116fdaf1 100644
--- a/r/tests/testthat/test-parquet.R
+++ b/r/tests/testthat/test-parquet.R
@@ -32,7 +32,7 @@ test_that("simple int column roundtrip", {
   pq_tmp_file <- tempfile() # You can specify the .parquet here but that's probably not necessary
 
   write_parquet(df, pq_tmp_file)
-  df_read <- read_parquet(pq_tmp_file)
+  df_read <- read_parquet(pq_tmp_file, mmap = FALSE)
   expect_equal(df, df_read)
   # Make sure file connection is cleaned up
   expect_error(file.remove(pq_tmp_file), NA)
@@ -288,15 +288,21 @@ test_that("write_parquet() returns its input", {
 
 test_that("write_parquet() handles version argument", {
   df <- tibble::tibble(x = 1:5)
-  tf <- tempfile()
-  on.exit(unlink(tf))
 
-  purrr::walk(list("1.0", "2.4", "2.6", "latest", 1.0, 2.4, 2.6, 1L), ~ {
-    write_parquet(df, tf, version = .x)
+  versions <- list("1.0", "2.4", "2.6", "latest", 1.0, 2.4, 2.6, 1L)
+  purrr::walk(versions, function(x) {
+    tf <- tempfile()
+    on.exit(unlink(tf))
+
+    write_parquet(df, tf, version = x)
     expect_identical(read_parquet(tf), df)
   })
-  purrr::walk(list("3.0", 3.0, 3L, "A"), ~ {
-    expect_error(write_parquet(df, tf, version = .x))
+
+  invalid_versions <- list("3.0", 3.0, 3L, "A")
+  purrr::walk(invalid_versions, function(x) {
+    tf <- tempfile()
+    on.exit(unlink(tf))
+    expect_error(write_parquet(df, tf, version = x))
   })
 })
 
diff --git a/r/tests/testthat/test-read-record-batch.R b/r/tests/testthat/test-read-record-batch.R
index ba109da6c6b0a..f62330ae0e039 100644
--- a/r/tests/testthat/test-read-record-batch.R
+++ b/r/tests/testthat/test-read-record-batch.R
@@ -38,7 +38,7 @@ test_that("RecordBatchFileWriter / RecordBatchFileReader roundtrips", {
   writer$close()
   stream$close()
 
-  expect_equal(read_feather(tf, as_data_frame = FALSE), tab)
+  expect_equal(read_feather(tf, as_data_frame = FALSE, mmap = FALSE), tab)
   # Make sure connections are closed
   expect_error(file.remove(tf), NA)
   skip_on_os("windows") # This should pass, we've closed the stream

From 3697bcdd514fc5a0472dabd3928f6b4731554cda Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Fri, 6 Oct 2023 16:54:52 -0400
Subject: [PATCH 484/749] GH-38060: [Python][CI] Upgrade Spark versions
 (#38082)

### Rationale for this change

Spark released 3.5.0 and dropped support for Java 8 and 11 on main.

### What changes are included in this PR?

* Upgrade Spark integration tests from v3.4.1 -> 3.5.0
* Use JDK 17 for Spark latest

### Are these changes tested?

Will test in CI

### Are there any user-facing changes?

No
* Closes: #38060

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/tasks/tasks.yml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 798932db23323..bb6cdb212500a 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1611,9 +1611,9 @@ tasks:
       image: conda-python-hdfs
 {% endfor %}
 
-{% for python_version, spark_version, test_pyarrow_only, numpy_version in [("3.8", "v3.4.1", "false", "latest"),
-                                                                           ("3.10", "v3.4.1", "false", "1.23"),
-                                                                           ("3.11", "master", "false", "latest")] %}
+{% for python_version, spark_version, test_pyarrow_only, numpy_version, jdk_version in [("3.8", "v3.5.0", "false", "latest", "8"),
+                                                                                        ("3.10", "v3.5.0", "false", "1.23", "8"),
+                                                                                        ("3.11", "master", "false", "latest", "17")] %}
   test-conda-python-{{ python_version }}-spark-{{ spark_version }}:
     ci: github
     template: docker-tests/github.linux.yml
@@ -1623,6 +1623,7 @@ tasks:
         SPARK: "{{ spark_version }}"
         TEST_PYARROW_ONLY: "{{ test_pyarrow_only }}"
         NUMPY: "{{ numpy_version }}"
+        JDK: "{{ jdk_version }}"
       # use the branch-3.0 of spark, so prevent reusing any layers
       flags: --no-leaf-cache
       image: conda-python-spark

From 839137e53078953d4dc8d0d71d9c9a04996e24df Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Sun, 8 Oct 2023 07:29:39 +0900
Subject: [PATCH 485/749] GH-38090: [C++][Emscripten] orc: Suppress
 shorten-64-to-32 warnings (#38097)

### Rationale for this change

We need explicit cast to use `int64_t` for `size_t` on Emscripten.

### What changes are included in this PR?

Explicit casts.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38090

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/adapters/orc/adapter.cc | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/cpp/src/arrow/adapters/orc/adapter.cc b/cpp/src/arrow/adapters/orc/adapter.cc
index 2466e7433abce..31fba1a9bd50e 100644
--- a/cpp/src/arrow/adapters/orc/adapter.cc
+++ b/cpp/src/arrow/adapters/orc/adapter.cc
@@ -204,7 +204,7 @@ class ORCFileReader::Impl {
 
   Status Init() {
     int64_t nstripes = reader_->getNumberOfStripes();
-    stripes_.resize(nstripes);
+    stripes_.resize(static_cast<size_t>(nstripes));
     std::unique_ptr<liborc::StripeInformation> stripe;
     uint64_t first_row_of_stripe = 0;
     for (int i = 0; i < nstripes; ++i) {
@@ -222,7 +222,9 @@ class ORCFileReader::Impl {
 
   int64_t NumberOfRows() { return static_cast<int64_t>(reader_->getNumberOfRows()); }
 
-  StripeInformation GetStripeInformation(int64_t stripe) { return stripes_[stripe]; }
+  StripeInformation GetStripeInformation(int64_t stripe) {
+    return stripes_[static_cast<size_t>(stripe)];
+  }
 
   FileVersion GetFileVersion() {
     liborc::FileVersion orc_file_version = reader_->getFormatVersion();
@@ -365,7 +367,7 @@ class ORCFileReader::Impl {
     liborc::RowReaderOptions opts = default_row_reader_options();
     RETURN_NOT_OK(SelectStripe(&opts, stripe));
     ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts));
-    return ReadBatch(opts, schema, stripes_[stripe].num_rows);
+    return ReadBatch(opts, schema, stripes_[static_cast<size_t>(stripe)].num_rows);
   }
 
   Result<std::shared_ptr<RecordBatch>> ReadStripe(
@@ -374,7 +376,7 @@ class ORCFileReader::Impl {
     RETURN_NOT_OK(SelectIndices(&opts, include_indices));
     RETURN_NOT_OK(SelectStripe(&opts, stripe));
     ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts));
-    return ReadBatch(opts, schema, stripes_[stripe].num_rows);
+    return ReadBatch(opts, schema, stripes_[static_cast<size_t>(stripe)].num_rows);
   }
 
   Result<std::shared_ptr<RecordBatch>> ReadStripe(
@@ -383,15 +385,15 @@ class ORCFileReader::Impl {
     RETURN_NOT_OK(SelectNames(&opts, include_names));
     RETURN_NOT_OK(SelectStripe(&opts, stripe));
     ARROW_ASSIGN_OR_RAISE(auto schema, ReadSchema(opts));
-    return ReadBatch(opts, schema, stripes_[stripe].num_rows);
+    return ReadBatch(opts, schema, stripes_[static_cast<size_t>(stripe)].num_rows);
   }
 
   Status SelectStripe(liborc::RowReaderOptions* opts, int64_t stripe) {
     ARROW_RETURN_IF(stripe < 0 || stripe >= NumberOfStripes(),
                     Status::Invalid("Out of bounds stripe: ", stripe));
 
-    opts->range(static_cast<uint64_t>(stripes_[stripe].offset),
-                static_cast<uint64_t>(stripes_[stripe].length));
+    opts->range(static_cast<uint64_t>(stripes_[static_cast<size_t>(stripe)].offset),
+                static_cast<uint64_t>(stripes_[static_cast<size_t>(stripe)].length));
     return Status::OK();
   }
 

From 60916fe658672bfc8330eaa488d960ae4bca1451 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 9 Oct 2023 06:05:28 +0900
Subject: [PATCH 486/749] GH-38090: [C++][Emscripten][Parquet] Suppress
 shorten-64-to-32 warnings (#38129)

### Rationale for this change

We need explicit cast to use `int64_t` for `size_t` on Emscripten.

### What changes are included in this PR?

Explicit casts.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38090

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/parquet/arrow/reader.cc          | 3 ++-
 cpp/src/parquet/arrow/reader_internal.cc | 2 +-
 cpp/src/parquet/bloom_filter.cc          | 2 +-
 cpp/src/parquet/column_reader.cc         | 4 ++--
 cpp/src/parquet/column_scanner.h         | 6 ++++--
 cpp/src/parquet/column_writer.cc         | 8 +++++---
 cpp/src/parquet/encoding.cc              | 8 ++++----
 cpp/src/parquet/file_reader.cc           | 2 +-
 cpp/src/parquet/metadata.cc              | 3 ++-
 cpp/src/parquet/statistics.cc            | 2 +-
 10 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/cpp/src/parquet/arrow/reader.cc b/cpp/src/parquet/arrow/reader.cc
index 142119b770b8c..99b8a9ccef1fa 100644
--- a/cpp/src/parquet/arrow/reader.cc
+++ b/cpp/src/parquet/arrow/reader.cc
@@ -999,7 +999,8 @@ Status FileReaderImpl::GetRecordBatchReader(const std::vector<int>& row_groups,
     for (int row_group : row_groups) {
       int64_t num_rows = parquet_reader()->metadata()->RowGroup(row_group)->num_rows();
 
-      batches.insert(batches.end(), num_rows / batch_size, max_sized_batch);
+      batches.insert(batches.end(), static_cast<size_t>(num_rows / batch_size),
+                     max_sized_batch);
 
       if (int64_t trailing_rows = num_rows % batch_size) {
         batches.push_back(max_sized_batch->Slice(0, trailing_rows));
diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc
index 7034f5839e1ea..5146aa12c2c36 100644
--- a/cpp/src/parquet/arrow/reader_internal.cc
+++ b/cpp/src/parquet/arrow/reader_internal.cc
@@ -365,7 +365,7 @@ Status TransferBool(RecordReader* reader, bool nullable, MemoryPool* pool, Datum
   // Transfer boolean values to packed bitmap
   auto values = reinterpret_cast<const bool*>(reader->values());
   uint8_t* data_ptr = data->mutable_data();
-  memset(data_ptr, 0, buffer_size);
+  memset(data_ptr, 0, static_cast<size_t>(buffer_size));
 
   for (int64_t i = 0; i < length; i++) {
     if (values[i]) {
diff --git a/cpp/src/parquet/bloom_filter.cc b/cpp/src/parquet/bloom_filter.cc
index e5095515e7d82..427e73b9e6428 100644
--- a/cpp/src/parquet/bloom_filter.cc
+++ b/cpp/src/parquet/bloom_filter.cc
@@ -143,7 +143,7 @@ BlockSplitBloomFilter BlockSplitBloomFilter::Deserialize(
   const auto bloom_filter_bytes_in_header = header_buf->size() - header_size;
   if (bloom_filter_bytes_in_header > 0) {
     std::memcpy(buffer->mutable_data(), header_buf->data() + header_size,
-                bloom_filter_bytes_in_header);
+                static_cast<size_t>(bloom_filter_bytes_in_header));
   }
 
   const auto required_read_size = bloom_filter_size - bloom_filter_bytes_in_header;
diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index fa013dd2ea583..e09369effb698 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -1792,7 +1792,7 @@ class TypedRecordReader : public TypedColumnReaderImpl<DType>,
 
         // Avoid valgrind warnings
         memset(valid_bits_->mutable_data() + valid_bytes_old, 0,
-               valid_bytes_new - valid_bytes_old);
+               static_cast<size_t>(valid_bytes_new - valid_bytes_old));
       }
     }
   }
@@ -1935,7 +1935,7 @@ class TypedRecordReader : public TypedColumnReaderImpl<DType>,
     // Conservative upper bound
     const int64_t possible_num_values =
         std::max<int64_t>(num_records, levels_written_ - levels_position_);
-    ReserveValues(possible_num_values);
+    ReserveValues(static_cast<size_t>(possible_num_values));
 
     const int64_t start_levels_position = levels_position_;
 
diff --git a/cpp/src/parquet/column_scanner.h b/cpp/src/parquet/column_scanner.h
index d53435f03cd32..a9953866fab22 100644
--- a/cpp/src/parquet/column_scanner.h
+++ b/cpp/src/parquet/column_scanner.h
@@ -48,8 +48,10 @@ class PARQUET_EXPORT Scanner {
         value_offset_(0),
         values_buffered_(0),
         reader_(std::move(reader)) {
-    def_levels_.resize(descr()->max_definition_level() > 0 ? batch_size_ : 0);
-    rep_levels_.resize(descr()->max_repetition_level() > 0 ? batch_size_ : 0);
+    def_levels_.resize(
+        descr()->max_definition_level() > 0 ? static_cast<size_t>(batch_size_) : 0);
+    rep_levels_.resize(
+        descr()->max_repetition_level() > 0 ? static_cast<size_t>(batch_size_) : 0);
   }
 
   virtual ~Scanner() {}
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index a0aedeee9e968..be1881d00e035 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -895,11 +895,13 @@ class ColumnWriterImpl {
   void ConcatenateBuffers(int64_t definition_levels_rle_size,
                           int64_t repetition_levels_rle_size,
                           const std::shared_ptr<Buffer>& values, uint8_t* combined) {
-    memcpy(combined, repetition_levels_rle_->data(), repetition_levels_rle_size);
+    memcpy(combined, repetition_levels_rle_->data(),
+           static_cast<size_t>(repetition_levels_rle_size));
     combined += repetition_levels_rle_size;
-    memcpy(combined, definition_levels_rle_->data(), definition_levels_rle_size);
+    memcpy(combined, definition_levels_rle_->data(),
+           static_cast<size_t>(definition_levels_rle_size));
     combined += definition_levels_rle_size;
-    memcpy(combined, values->data(), values->size());
+    memcpy(combined, values->data(), static_cast<size_t>(values->size()));
   }
 };
 
diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 931b9fd10729f..c136671bd1327 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -850,8 +850,8 @@ std::shared_ptr<Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
       AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
   uint8_t* output_buffer_raw = output_buffer->mutable_data();
   const uint8_t* raw_values = sink_.data();
-  ::arrow::util::internal::ByteStreamSplitEncode<T>(raw_values, num_values_in_buffer_,
-                                                    output_buffer_raw);
+  ::arrow::util::internal::ByteStreamSplitEncode<T>(
+      raw_values, static_cast<size_t>(num_values_in_buffer_), output_buffer_raw);
   sink_.Reset();
   num_values_in_buffer_ = 0;
   return std::move(output_buffer);
@@ -1018,7 +1018,7 @@ inline int DecodePlain(const uint8_t* data, int64_t data_size, int num_values,
   }
   // If bytes_to_decode == 0, data could be null
   if (bytes_to_decode > 0) {
-    memcpy(out, data, bytes_to_decode);
+    memcpy(out, data, static_cast<size_t>(bytes_to_decode));
   }
   return static_cast<int>(bytes_to_decode);
 }
@@ -1574,7 +1574,7 @@ class DictDecoderImpl : public DecoderImpl, virtual public DictDecoder<Type> {
 
     // XXX(wesm): Cannot append "valid bits" directly to the builder
     std::vector<uint8_t> valid_bytes(num_values, 0);
-    int64_t i = 0;
+    size_t i = 0;
     VisitNullBitmapInline(
         valid_bits, valid_bits_offset, num_values, null_count,
         [&]() { valid_bytes[i++] = 1; }, [&]() { ++i; });
diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index 5247b9d4b543d..2beb4f1845886 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -918,7 +918,7 @@ int64_t ScanFileContents(std::vector<int> columns, const int32_t column_batch_si
             ScanAllValues(column_batch_size, def_levels.data(), rep_levels.data(),
                           values.data(), &values_read, col_reader.get());
         if (col_reader->descr()->max_repetition_level() > 0) {
-          for (int64_t i = 0; i < levels_read; i++) {
+          for (size_t i = 0; i < static_cast<size_t>(levels_read); i++) {
             if (rep_levels[i] == 0) {
               total_rows[col]++;
             }
diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc
index 4ef2151fee59d..8697cd52515ae 100644
--- a/cpp/src/parquet/metadata.cc
+++ b/cpp/src/parquet/metadata.cc
@@ -1843,7 +1843,8 @@ class FileMetaDataBuilder::FileMetaDataBuilderImpl {
         key_value_metadata_ = key_value_metadata_->Merge(*key_value_metadata);
       }
       metadata_->key_value_metadata.clear();
-      metadata_->key_value_metadata.reserve(key_value_metadata_->size());
+      metadata_->key_value_metadata.reserve(
+          static_cast<size_t>(key_value_metadata_->size()));
       for (int64_t i = 0; i < key_value_metadata_->size(); ++i) {
         format::KeyValue kv_pair;
         kv_pair.__set_key(key_value_metadata_->key(i));
diff --git a/cpp/src/parquet/statistics.cc b/cpp/src/parquet/statistics.cc
index d5fc71b3958e1..ccfb69c487d40 100644
--- a/cpp/src/parquet/statistics.cc
+++ b/cpp/src/parquet/statistics.cc
@@ -771,7 +771,7 @@ void TypedStatisticsImpl<DType>::PlainEncode(const T& src, std::string* dst) con
   encoder->Put(&src, 1);
   auto buffer = encoder->FlushValues();
   auto ptr = reinterpret_cast<const char*>(buffer->data());
-  dst->assign(ptr, buffer->size());
+  dst->assign(ptr, static_cast<size_t>(buffer->size()));
 }
 
 template <typename DType>

From 0b9f81771b30c5ebdd215b28eb41889efa2d76ed Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Mon, 9 Oct 2023 05:36:44 +0800
Subject: [PATCH 487/749] GH-38071: [C++][CI] Fix Overlap column chunk ranges
 for pre-buffer (#38073)

### Rationale for this change

The C++ Parquet Arrow fuzz will generate bad Parquet file with bad row-range, this patch change the `CoalesceReadRanges` to return `Result<>`.

### What changes are included in this PR?

Just a checking, change `CoalesceReadRanges` to return `Result<>`.

### Are these changes tested?

No.

### Are there any user-facing changes?

No.

* Closes: #38071

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/io/caching.cc      |  5 +++--
 cpp/src/arrow/io/interfaces.cc   | 12 +++++++-----
 cpp/src/arrow/io/util_internal.h |  6 +++---
 cpp/src/parquet/file_reader.cc   |  6 ++++--
 4 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/cpp/src/arrow/io/caching.cc b/cpp/src/arrow/io/caching.cc
index 307b933d16ee3..bd61c40693a27 100644
--- a/cpp/src/arrow/io/caching.cc
+++ b/cpp/src/arrow/io/caching.cc
@@ -174,8 +174,9 @@ struct ReadRangeCache::Impl {
 
   // Add the given ranges to the cache, coalescing them where possible
   virtual Status Cache(std::vector<ReadRange> ranges) {
-    ranges = internal::CoalesceReadRanges(std::move(ranges), options.hole_size_limit,
-                                          options.range_size_limit);
+    ARROW_ASSIGN_OR_RAISE(
+        ranges, internal::CoalesceReadRanges(std::move(ranges), options.hole_size_limit,
+                                             options.range_size_limit));
     std::vector<RangeCacheEntry> new_entries = MakeCacheEntries(ranges);
     // Add new entries, themselves ordered by offset
     if (entries.size() > 0) {
diff --git a/cpp/src/arrow/io/interfaces.cc b/cpp/src/arrow/io/interfaces.cc
index d3229fd067cbe..1d35549cc4345 100644
--- a/cpp/src/arrow/io/interfaces.cc
+++ b/cpp/src/arrow/io/interfaces.cc
@@ -425,7 +425,7 @@ ThreadPool* GetIOThreadPool() {
 namespace {
 
 struct ReadRangeCombiner {
-  std::vector<ReadRange> Coalesce(std::vector<ReadRange> ranges) {
+  Result<std::vector<ReadRange>> Coalesce(std::vector<ReadRange> ranges) {
     if (ranges.empty()) {
       return ranges;
     }
@@ -454,7 +454,9 @@ struct ReadRangeCombiner {
       const auto& left = ranges[i];
       const auto& right = ranges[i + 1];
       DCHECK_LE(left.offset, right.offset);
-      DCHECK_LE(left.offset + left.length, right.offset) << "Some read ranges overlap";
+      if (left.offset + left.length > right.offset) {
+        return Status::IOError("Some read ranges overlap");
+      }
     }
 #endif
 
@@ -509,9 +511,9 @@ struct ReadRangeCombiner {
 
 };  // namespace
 
-std::vector<ReadRange> CoalesceReadRanges(std::vector<ReadRange> ranges,
-                                          int64_t hole_size_limit,
-                                          int64_t range_size_limit) {
+Result<std::vector<ReadRange>> CoalesceReadRanges(std::vector<ReadRange> ranges,
+                                                  int64_t hole_size_limit,
+                                                  int64_t range_size_limit) {
   DCHECK_GT(range_size_limit, hole_size_limit);
 
   ReadRangeCombiner combiner{hole_size_limit, range_size_limit};
diff --git a/cpp/src/arrow/io/util_internal.h b/cpp/src/arrow/io/util_internal.h
index b1d75d1d0bd1f..2015f6a211292 100644
--- a/cpp/src/arrow/io/util_internal.h
+++ b/cpp/src/arrow/io/util_internal.h
@@ -45,9 +45,9 @@ ARROW_EXPORT Status ValidateWriteRange(int64_t offset, int64_t size, int64_t fil
 ARROW_EXPORT Status ValidateRange(int64_t offset, int64_t size);
 
 ARROW_EXPORT
-std::vector<ReadRange> CoalesceReadRanges(std::vector<ReadRange> ranges,
-                                          int64_t hole_size_limit,
-                                          int64_t range_size_limit);
+Result<std::vector<ReadRange>> CoalesceReadRanges(std::vector<ReadRange> ranges,
+                                                  int64_t hole_size_limit,
+                                                  int64_t range_size_limit);
 
 ARROW_EXPORT
 ::arrow::internal::ThreadPool* GetIOThreadPool();
diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index 2beb4f1845886..7318b5640c0a0 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -139,8 +139,10 @@ const RowGroupMetaData* RowGroupReader::metadata() const { return contents_->met
 ::arrow::io::ReadRange ComputeColumnChunkRange(FileMetaData* file_metadata,
                                                int64_t source_size, int row_group_index,
                                                int column_index) {
-  auto row_group_metadata = file_metadata->RowGroup(row_group_index);
-  auto column_metadata = row_group_metadata->ColumnChunk(column_index);
+  std::unique_ptr<RowGroupMetaData> row_group_metadata =
+      file_metadata->RowGroup(row_group_index);
+  std::unique_ptr<ColumnChunkMetaData> column_metadata =
+      row_group_metadata->ColumnChunk(column_index);
 
   int64_t col_start = column_metadata->data_page_offset();
   if (column_metadata->has_dictionary_page() &&

From 9df80fdb81a2af37dfa75fe225c939fba5b122a4 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Sun, 8 Oct 2023 23:39:58 -0300
Subject: [PATCH 488/749] GH-38088: [R] Remove outdated references to brew and
 autobrew (#38089)

### Rationale for this change

We no longer use autobrew to install on MacOS, so we no longer need CI jobs or helper scripts that had previously been referenced from this install path.

### What changes are included in this PR?

This PR removes references to autobrew that are no longer needed. It also removes the R homebrew CI job, which has been failing for several months. We had supported homebrew because `brew install apache-arrow --HEAD` was one method of avoiding a full binary install for potential MacOS contributors; however, downloading nightly static libraries (e.g., #38080) is an even faster way to get a compatible libarrow built for the R package and works on MacOS, Windows, and Linux.

### Are these changes tested?

These changes remove tests and infrastructure that are no longer relevant.

### Are there any user-facing changes?

No.
* Closes: #38088

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 LICENSE.txt                                   | 13 ---
 dev/release/01-prepare-test.rb                |  7 --
 dev/release/post-11-bump-versions-test.rb     |  7 --
 dev/release/utils-prepare.sh                  |  5 -
 dev/tasks/conda-recipes/r-arrow/build.sh      |  2 -
 .../autobrew/apache-arrow-static.rb           | 99 -------------------
 .../autobrew/apache-arrow.rb                  | 92 -----------------
 dev/tasks/macros.jinja                        | 22 +----
 dev/tasks/r/github.macos-linux.local.yml      |  6 +-
 dev/tasks/r/github.macos.autobrew.yml         | 88 -----------------
 dev/tasks/r/github.macos.brew.yml             | 84 ----------------
 dev/tasks/tasks.yml                           | 26 -----
 go/LICENSE.txt                                | 11 ---
 r/.Rbuildignore                               |  2 -
 r/PACKAGING.md                                | 39 +-------
 r/configure                                   |  2 -
 r/tools/autobrew                              | 80 ---------------
 17 files changed, 9 insertions(+), 576 deletions(-)
 delete mode 100644 dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb
 delete mode 100644 dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
 delete mode 100644 dev/tasks/r/github.macos.autobrew.yml
 delete mode 100644 dev/tasks/r/github.macos.brew.yml
 delete mode 100644 r/tools/autobrew

diff --git a/LICENSE.txt b/LICENSE.txt
index c2b0a996fedd1..0423854567b26 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -1889,19 +1889,6 @@ for PyArrow. Ibis is released under the Apache License, Version 2.0.
 
 --------------------------------------------------------------------------------
 
-This project includes code from the autobrew project.
-
-The following files are based on code from the autobrew project:
-* r/tools/autobrew
-* dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
-* dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb 
-
-Copyright (c) 2019, Jeroen Ooms
-License: MIT
-Homepage: https://github.com/autobrew/
-
---------------------------------------------------------------------------------
-
 dev/tasks/homebrew-formulae/apache-arrow.rb has the following license:
 
 BSD 2-Clause License
diff --git a/dev/release/01-prepare-test.rb b/dev/release/01-prepare-test.rb
index 54437e9da60ce..8fb23f45f0f3a 100644
--- a/dev/release/01-prepare-test.rb
+++ b/dev/release/01-prepare-test.rb
@@ -150,13 +150,6 @@ def test_version_pre_tag
            "+  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}/apache-arrow-#{@release_version}.tar.gz\""],
         ],
       },
-      {
-        path: "dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb",
-        hunks: [
-          ["-  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@previous_version}.9000/apache-arrow-#{@previous_version}.9000.tar.gz\"",
-           "+  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}/apache-arrow-#{@release_version}.tar.gz\""],
-        ],
-      },
     ]
     unless release_type == :patch
       expected_changes += [
diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb
index 8253472ccc5b9..a017d2d70a167 100644
--- a/dev/release/post-11-bump-versions-test.rb
+++ b/dev/release/post-11-bump-versions-test.rb
@@ -128,13 +128,6 @@ def test_version_post_tag
            "+  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@next_snapshot_version}/apache-arrow-#{@next_snapshot_version}.tar.gz\""],
         ],
       },
-      {
-        path: "dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb",
-        hunks: [
-          ["-  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@previous_version}.9000/apache-arrow-#{@previous_version}.9000.tar.gz\"",
-           "+  url \"https://www.apache.org/dyn/closer.lua?path=arrow/arrow-#{@release_version}.9000/apache-arrow-#{@release_version}.9000.tar.gz\""],
-        ],
-      },
     ]
     unless release_type == :patch
       expected_changes += [
diff --git a/dev/release/utils-prepare.sh b/dev/release/utils-prepare.sh
index 464702b811d8b..23c89ad54eb01 100644
--- a/dev/release/utils-prepare.sh
+++ b/dev/release/utils-prepare.sh
@@ -80,11 +80,6 @@ update_versions() {
   popd
 
   pushd "${ARROW_DIR}/dev/tasks/homebrew-formulae"
-  sed -i.bak -E -e \
-    "s/arrow-[0-9.]+[0-9]+/arrow-${r_version}/g" \
-    autobrew/apache-arrow.rb
-  rm -f autobrew/apache-arrow.rb.bak
-  git add autobrew/apache-arrow.rb
   sed -i.bak -E -e \
     "s/arrow-[0-9.\-]+[0-9SNAPHOT]+/arrow-${version}/g" \
     apache-arrow-glib.rb \
diff --git a/dev/tasks/conda-recipes/r-arrow/build.sh b/dev/tasks/conda-recipes/r-arrow/build.sh
index 340b2196a2c8f..9f5255cbaeee3 100755
--- a/dev/tasks/conda-recipes/r-arrow/build.sh
+++ b/dev/tasks/conda-recipes/r-arrow/build.sh
@@ -1,8 +1,6 @@
 #!/bin/bash
 set -ex
 
-export DISABLE_AUTOBREW=1
-
 # arrow uses C++17
 export ARROW_R_CXXFLAGS="${ARROW_R_CXXFLAGS} -std=c++17"
 export LIBARROW_BUILD=false
diff --git a/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb b/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb
deleted file mode 100644
index 4586649d0c0bc..0000000000000
--- a/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb
+++ /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.
-
-# Cloned from https://github.com/autobrew/homebrew-core/blob/high-sierra/Formula/apache-arrow.rb
-# Upstream any relevant changes (dependencies, build args ...)
-
-class ApacheArrowStatic < Formula
-  desc "Columnar in-memory analytics layer designed to accelerate big data"
-  homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-8.0.0.9000/apache-arrow-8.0.0.9000.tar.gz"
-  # Uncomment and update to test on a release candidate
-  # mirror "https://dist.apache.org/repos/dist/dev/arrow/apache-arrow-8.0.0-rc1/apache-arrow-8.0.0.tar.gz"
-  sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
-  head "https://github.com/apache/arrow.git", branch: "main"
-
-  bottle do
-    sha256 cellar: :any, arm64_big_sur: "ef89d21a110b89840cc6148add685d407e75bd633bc8f79625eb33d00e3694b4"
-    sha256 cellar: :any, big_sur:       "6fcb9f55d44eb61d295a8020e039a0622bdc044b220cfffef855f3e3ab8057a1"
-    sha256 cellar: :any, catalina:      "bf71b17766688077fb9b4e679f309742c16524015287dd3633758c679752c977"
-  end
-
-  depends_on "boost" => :build
-  depends_on "cmake" => :build
-  depends_on "aws-sdk-cpp-static"
-  depends_on "brotli"
-  depends_on "lz4"
-  depends_on "snappy"
-  depends_on "thrift"
-  depends_on "zstd"
-
-  conflicts_with "apache-arrow", because: "both install Arrow"
-
-  def install
-    ENV.cxx11
-    # https://github.com/Homebrew/homebrew-core/issues/94724
-    # https://issues.apache.org/jira/browse/ARROW-15664
-    ENV["HOMEBREW_OPTIMIZATION_LEVEL"] = "O2"
-
-    args = %W[
-      -DARROW_BUILD_SHARED=OFF
-      -DARROW_BUILD_UTILITIES=ON
-      -DARROW_ACERO=ON
-      -DARROW_COMPUTE=ON
-      -DARROW_CSV=ON
-      -DARROW_DATASET=ON
-      -DARROW_FILESYSTEM=ON
-      -DARROW_GCS=ON
-      -DARROW_JEMALLOC=ON
-      -DARROW_JSON=ON
-      -DARROW_MIMALLOC=ON
-      -DARROW_PARQUET=ON
-      -DARROW_S3=ON
-      -DARROW_VERBOSE_THIRDPARTY_BUILD=ON
-      -DARROW_WITH_BROTLI=ON
-      -DARROW_WITH_BZ2=ON
-      -DARROW_WITH_LZ4=ON
-      -DARROW_WITH_SNAPPY=ON
-      -DARROW_WITH_ZLIB=ON
-      -DARROW_WITH_ZSTD=ON
-      -DLZ4_HOME=#{Formula["lz4"].prefix}
-      -DPARQUET_BUILD_EXECUTABLES=ON
-      -DTHRIFT_HOME=#{Formula["thrift"].prefix}
-    ]
-
-    mkdir "build"
-    cd "build" do
-      system "cmake", "../cpp", *std_cmake_args, *args
-      system "make"
-      system "make", "install"
-    end
-  end
-
-  test do
-    (testpath/"test.cpp").write <<~EOS
-      #include "arrow/api.h"
-      int main(void) {
-        arrow::int64();
-        return 0;
-      }
-    EOS
-    system ENV.cxx, "test.cpp", "-std=c++17", "-I#{include}", "-L#{lib}", \
-      "-larrow", "-larrow_bundled_dependencies", "-o", "test"
-    system "./test"
-  end
-end
diff --git a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb b/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
deleted file mode 100644
index 387759edf27e6..0000000000000
--- a/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
+++ /dev/null
@@ -1,92 +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.
-
-# https://github.com/autobrew/homebrew-core/blob/-/Formula/apache-arrow.rb
-class ApacheArrow < Formula
-  desc "Columnar in-memory analytics layer designed to accelerate big data"
-  homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-13.0.0.9000/apache-arrow-13.0.0.9000.tar.gz"
-  sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
-  head "https://github.com/apache/arrow.git", branch: "main"
-
-  bottle do
-    cellar :any
-    sha256 "9cd44700798638b5e3ee8774b3929f3fad815290d05572d1f39f01d6423eaad0" => :high_sierra
-    root_url "https://autobrew.github.io/bottles"
-  end
-
-  # NOTE: if you add something here, be sure to add to PKG_LIBS in r/tools/autobrew
-  depends_on "boost" => :build
-  depends_on "cmake" => :build
-  depends_on "aws-sdk-cpp"
-  depends_on "brotli"
-  depends_on "lz4"
-  depends_on "openssl@1.1"
-  depends_on "snappy"
-  depends_on "thrift"
-  depends_on "zstd"
-
-  def install
-    ENV.cxx11
-    args = %W[
-      -DARROW_BUILD_SHARED=OFF
-      -DARROW_BUILD_UTILITIES=ON
-      -DARROW_ACERO=ON
-      -DARROW_COMPUTE=ON
-      -DARROW_CSV=ON
-      -DARROW_CXXFLAGS="-D_LIBCPP_DISABLE_AVAILABILITY"
-      -DARROW_DATASET=ON
-      -DARROW_FILESYSTEM=ON
-      -DARROW_GCS=ON
-      -DARROW_JEMALLOC=ON
-      -DARROW_JSON=ON
-      -DARROW_MIMALLOC=ON
-      -DARROW_PARQUET=ON
-      -DARROW_S3=ON
-      -DARROW_VERBOSE_THIRDPARTY_BUILD=ON
-      -DARROW_WITH_BROTLI=ON
-      -DARROW_WITH_BZ2=ON
-      -DARROW_WITH_LZ4=ON
-      -DARROW_WITH_SNAPPY=ON
-      -DARROW_WITH_ZLIB=ON
-      -DARROW_WITH_ZSTD=ON
-      -DLZ4_HOME=#{Formula["lz4"].prefix}
-      -DPARQUET_BUILD_EXECUTABLES=ON
-      -DTHRIFT_HOME=#{Formula["thrift"].prefix}
-    ]
-
-    mkdir "build"
-    cd "build" do
-      system "cmake", "../cpp", *std_cmake_args, *args
-      system "make"
-      system "make", "install"
-    end
-  end
-
-  test do
-    (testpath/"test.cpp").write <<~EOS
-      #include "arrow/api.h"
-      int main(void) {
-        arrow::int64();
-        return 0;
-      }
-    EOS
-    system ENV.cxx, "test.cpp", "-std=c++17", "-I#{include}", "-L#{lib}", \
-      "-larrow", "-larrow_bundled_dependencies", "-o", "test"
-    system "./test"
-  end
-end
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 54f676fd49cd9..2a6cbe3e61109 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -256,22 +256,6 @@ on:
       done
 {% endmacro %}
 
-{%- macro pin_brew_formulae(is_fork = false) -%}
-{#- This macro expects the cwd to be arrow/r -#}
-      # Copy all *brew formulae
-      cp ../dev/tasks/homebrew-formulae/autobrew/apache-arrow*.rb tools/
-
-      # Pin the git commit in the formula to match
-      pushd tools
-      if [ "{{ is_fork }}" == "true" ]; then
-        sed -i.bak -E -e 's/apache\/arrow.git", branch: "main"$/{{ arrow.github_repo.split("/") | join("\/") }}.git", :revision => "'"{{ arrow.head }}"'"/' apache-arrow*.rb
-      else
-        sed -i.bak -E -e 's/arrow.git", branch: "main"$/arrow.git", :revision => "'"{{ arrow.head }}"'"/' apache-arrow*.rb
-      fi
-      rm -f apache-arrow*.rb.bak
-      popd
-{% endmacro %}
-
 {%- macro github_change_r_pkg_version(is_fork, version) -%}
   - name: Modify version
     shell: bash
@@ -282,8 +266,6 @@ on:
         DESCRIPTION
       head DESCRIPTION
       rm -f DESCRIPTION.bak
-
-      {{ pin_brew_formulae(is_fork) }}
 {% endmacro %}
 
 {%- macro github_test_r_src_pkg() -%}
@@ -392,7 +374,7 @@ on:
             "AWS_SECRET_ACCESS_KEY": '${{ secrets.AWS_SECRET_ACCESS_KEY }}',
             "SCCACHE_BUCKET": '${{ secrets.SCCACHE_BUCKET }}',
             "SCCACHE_REGION": '${{ secrets.SCCACHE_REGION }}',
-            "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix 
+            "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix
           }
  %}
   {% for key, value in sccache_vars.items() %}
@@ -406,7 +388,7 @@ on:
             "AWS_SECRET_ACCESS_KEY": '$(AWS_SECRET_ACCESS_KEY)',
             "SCCACHE_BUCKET": '$(SCCACHE_BUCKET)',
             "SCCACHE_REGION": '$(SCCACHE_REGION)',
-            "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix 
+            "SCCACHE_S3_KEY_PREFIX": sccache_key_prefix
           }
   %}
   {% for key, value in sccache_vars.items() %}
diff --git a/dev/tasks/r/github.macos-linux.local.yml b/dev/tasks/r/github.macos-linux.local.yml
index f39471d5c5742..c65eb79f613c4 100644
--- a/dev/tasks/r/github.macos-linux.local.yml
+++ b/dev/tasks/r/github.macos-linux.local.yml
@@ -20,7 +20,7 @@
 {{ macros.github_header() }}
 
 jobs:
-  autobrew:
+  local:
     name: "install from local source"
     runs-on: {{ "${{ matrix.os }}" }}
   {% if env is defined %}
@@ -37,14 +37,14 @@ jobs:
     steps:
       {{ macros.github_checkout_arrow()|indent }}
 
-      - name: Configure non-autobrew dependencies (macos)
+      - name: Configure dependencies (macos)
         if: contains(matrix.os, 'macOS')
         run: |
           brew install openssl
           # disable sccache on macos as it timesout for unknown reasons
           # see GH-33721
           # brew install sccache
-      - name: Configure non-autobrew dependencies (linux)
+      - name: Configure dependencies (linux)
         if: contains(matrix.os, 'ubuntu')
         run: |
           sudo env \
diff --git a/dev/tasks/r/github.macos.autobrew.yml b/dev/tasks/r/github.macos.autobrew.yml
deleted file mode 100644
index b8e23690e2090..0000000000000
--- a/dev/tasks/r/github.macos.autobrew.yml
+++ /dev/null
@@ -1,88 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-{% import 'macros.jinja' as macros with context %}
-{% set is_fork = macros.is_fork %}
-
-{{ macros.github_header() }}
-
-jobs:
-  autobrew:
-    name: "Autobrew {{ '${{ matrix.platform }} R ${{ matrix.r-version }}' }}"
-    runs-on: {{ "${{ matrix.platform }}" }}
-    strategy:
-      fail-fast: false
-      matrix:
-          platform:
-            - macos-11
-            - macos-10.13 # self-hosted
-          r-version:
-            - "{{ macros.r_release.ver }}"
-            - "{{ macros.r_oldrel.ver }}"
-    steps:
-      {{ macros.github_checkout_arrow(action_v='3')|indent }}
-      - name: Configure autobrew script
-        run: |
-          # minio and sccache are pre-installed on the self-hosted 10.13 runner
-          if [ {{ '${{ matrix.platform }}' }} != macos-10.13  ]; then
-            # install minio for tests
-            brew install minio
-            brew install sccache
-          fi
-          cd arrow/r
-          {{ macros.pin_brew_formulae(is_fork)|indent }}
-      - uses: r-lib/actions/setup-r@v2
-        if: matrix.platform != 'macos-10.13'
-        with:
-          r-version: {{ '${{ matrix.r-version }}' }}
-          use-public-rspm: true
-      - name: Setup R
-        if: matrix.platform == 'macos-10.13'
-        run: |
-          # rig is a system utility that allows for switching
-          # between pre-installed R version on the self-hosted runners
-          rig default {{ '${{ matrix.r-version }}' }}
-          rig system setup-user-lib
-          rig system add-pak 
-      - uses: r-lib/actions/setup-r-dependencies@v2
-        with:
-          working-directory: 'arrow/r'
-          extra-packages: |
-            any::rcmdcheck
-            any::sys
-            any::readr
-      - name: Check
-        env:
-          _R_CHECK_CRAN_INCOMING_: false
-          NOT_CRAN: true
-          ARROW_USE_PKG_CONFIG: false
-          ARROW_R_DEV: true
-          FORCE_AUTOBREW: true
-        {{ macros.github_set_sccache_envvars()|indent(8)}}  
-        run: arrow/ci/scripts/r_test.sh arrow
-      - name: Dump install logs
-        run: cat arrow/r/check/arrow.Rcheck/00install.out
-        if: always()
-      - name: Dump test logs
-        run: cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
-        if: always()
-      - name: Save the test output
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: test-output
-          path: arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
diff --git a/dev/tasks/r/github.macos.brew.yml b/dev/tasks/r/github.macos.brew.yml
deleted file mode 100644
index 285eefa293eaa..0000000000000
--- a/dev/tasks/r/github.macos.brew.yml
+++ /dev/null
@@ -1,84 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-{% import 'macros.jinja' as macros with context %}
-
-{{ macros.github_header() }}
-
-jobs:
-  autobrew:
-    name: "Homebrew + R package"
-    runs-on: macOS-11
-    steps:
-      - name: Show system information
-        run: |
-          sysctl hw.optional machdep.cpu
-
-      {{ macros.github_checkout_arrow()|indent }}
-
-      {{ macros.configure_homebrew_arrow(formula)|indent }}
-      - name: Install apache-arrow
-        env:
-        {{ macros.github_set_sccache_envvars()|indent(8)}}
-        run: |
-          brew install sccache
-          # for testing
-          brew install minio
-
-          # TODO(ARROW-16907): apache/arrow@main seems to be installed already
-          # so this does nothing on a branch/PR
-          brew install -v --HEAD {{ '$(brew --repository homebrew/core)/Formula/a/apache-arrow.rb' }}
-
-          mkdir -p homebrew-logs
-          cp -a ~/Library/Logs/Homebrew/apache-arrow homebrew-logs/
-      - name: Save logs
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: homebrew-logs
-          path: homebrew-logs
-
-      - uses: r-lib/actions/setup-r@v2
-      - name: Install dependencies
-        run: |
-          install.packages("remotes")
-          remotes::install_deps("arrow/r", dependencies = TRUE)
-          remotes::install_cran(c("rcmdcheck", "sys", "sessioninfo"))
-        shell: Rscript {0}
-      - name: Session info
-        run: |
-          options(width = 100)
-          pkgs <- installed.packages()[, "Package"]
-          sessioninfo::session_info(pkgs, include_base = TRUE)
-        shell: Rscript {0}
-      - name: Check
-        env:
-          _R_CHECK_CRAN_INCOMING_: false
-          ARROW_R_VERBOSE_TEST: true
-        run: arrow/ci/scripts/r_test.sh arrow
-      - name: Dump install logs
-        run: cat arrow/r/check/arrow.Rcheck/00install.out
-        if: always()
-      - name: Dump test logs
-        run: cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
-        if: always()
-      - name: Save the test output
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: test-output
-          path: arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index bb6cdb212500a..e32e61bfbce46 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -82,8 +82,6 @@ groups:
 
   r:
     - test*-r-*
-    - homebrew-r-autobrew
-    - homebrew-r-brew
     # r-conda tasks
     - conda-linux-x64-cpu-r*
     - conda-linux-aarch64-cpu-r*
@@ -149,10 +147,7 @@ groups:
     - conan-*
     - conda-*
     - java-jars
-    # List the homebrews explicitly because we don't care about running homebrew-cpp-autobrew
     - homebrew-cpp
-    - homebrew-r-autobrew
-    - homebrew-r-brew
     - nuget
     - test-*
     - example-*
@@ -172,10 +167,7 @@ groups:
     - conda-*
     - conan-*
     - java-jars
-    # List the homebrews explicitly because we don't care about running homebrew-cpp-autobrew
     - homebrew-cpp
-    - homebrew-r-autobrew
-    - homebrew-r-brew
     - nuget
     - wheel-*
     - python-sdist
@@ -779,24 +771,6 @@ tasks:
     params:
       formula: apache-arrow.rb
 
-  homebrew-cpp-autobrew:
-    ci: github
-    template: homebrew-formulae/github.macos.yml
-    params:
-      formula: autobrew/apache-arrow.rb
-
-  homebrew-r-autobrew:
-    # This tests that the autobrew formula + script work in practice
-    ci: github
-    template: r/github.macos.autobrew.yml
-
-  homebrew-r-brew:
-    # This tests that the autobrew formula + script work in practice
-    ci: github
-    template: r/github.macos.brew.yml
-    params:
-      formula: apache-arrow.rb
-
   ############################## Arrow JAR's ##################################
 
   java-jars:
diff --git a/go/LICENSE.txt b/go/LICENSE.txt
index 9ea2e1f4497fb..57310329835da 100644
--- a/go/LICENSE.txt
+++ b/go/LICENSE.txt
@@ -1681,17 +1681,6 @@ 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
diff --git a/r/.Rbuildignore b/r/.Rbuildignore
index b8f768a8372b6..f5eeba4117454 100644
--- a/r/.Rbuildignore
+++ b/r/.Rbuildignore
@@ -20,8 +20,6 @@ clang_format.sh
 ^Makefile$
 ^.*\.orig$
 ^.*\.cmd$
-^autobrew$
-^apache-arrow.rb$
 ^.*\.Rhistory$
 ^extra-tests
 STYLE.md
diff --git a/r/PACKAGING.md b/r/PACKAGING.md
index edfca651e9d38..64423b4d8eb9b 100644
--- a/r/PACKAGING.md
+++ b/r/PACKAGING.md
@@ -38,32 +38,8 @@ For a high-level overview of the release process see the
 Wait for the release candidate to be cut:
 
 ## After release candidate has been cut
-- [ ] Create a CRAN-release branch from the release candidate commit
 
-## Optional: PRs for autobrew and rtools (release candidate)
-
-Make pull requests into the [autobrew](https://github.com/autobrew) and
-[rtools-packages](https://github.com/r-windows/rtools-packages) repositories
-used by the configure script on MacOS and Windows. These pull requests will
-use the release candidate as the source.
-
-- [ ] Pull request to modify
-  [the apache-arrow autobrew formula]( https://github.com/autobrew/homebrew-core/blob/high-sierra/Formula/apache-arrow.rb) 
-  to update the release version, SHA256 checksum of the release source file (which can be found in the same directory as the release source file), and any changes to dependencies and build steps that have changed in the
-  [copy of the formula we have of that formula in the Arrow repo](https://github.com/apache/arrow/blob/main/dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb)
-- [ ] Pull request to modify
-  [the apache-arrow-static autobrew formula](https://github.com/autobrew/homebrew-cran/blob/master/Formula/apache-arrow-static.rb)
-  to update the version, SHA, and any changes to dependencies and build steps that have changed in the
-  [copy of the formula we have of that formula in the Arrow repo](https://github.com/apache/arrow/blob/main/dev/tasks/homebrew-formulae/autobrew/apache-arrow-static.rb)
-- [ ] Pull request to modify the 
-  [autobrew script](https://github.com/autobrew/scripts/blob/master/apache-arrow)
-  to include any additions made to
-  [r/tools/autobrew](https://github.com/apache/arrow/blob/main/r/tools/autobrew).
-- [ ] Pull request to modify the
-  [RTools PKGBUILD script](https://github.com/r-windows/rtools-packages/blob/master/mingw-w64-arrow/PKGBUILD)
-  to reflect changes in
-  [ci/PKGBUILD](https://github.com/apache/arrow/blob/main/ci/scripts/PKGBUILD),
-  uncommenting the line that says "uncomment to test the rc".
+- [ ] Create a CRAN-release branch from the release candidate commit
 
 ## Prepare and check the .tar.gz that will be released to CRAN.
 
@@ -77,19 +53,11 @@ use the release candidate as the source.
 - [ ] Run reverse dependency checks using `archery docker run r-revdepcheck`.
 
 ## Release vote
-- [ ] Release vote passed!
-
-## PRs for autobrew and rtools (official release)
 
-Create new autobrew and r-windows PRs such that they use the *release*
-instead of the *release candidate*:
-
-- [ ] PR into autobrew/homebrew-core (apache-arrow autobrew formula)
-- [ ] PR into autobrew/homebrew-core (apache-arrow-static autobrew formula)
-- [ ] PR into autobrew/scripts
-- [ ] PR into r-windows/rtools-packages
+- [ ] Release vote passed!
 
 ## Generate R package to submit to CRAN
+
 - [ ] If the release candidate commit updated, rebase the CRAN release branch
   on that commit.
 - [ ] Pick any commits that were made to main since the release commit that
@@ -107,6 +75,7 @@ Ensure linux binary packages are available:
   https://apache.jfrog.io/ui/repos/tree/General/arrow/r
 
 ## Check binary Arrow C++ distributions specific to the R package
+
 - [ ] Upload the .tar.gz to [win-builder](https://win-builder.r-project.org/upload.aspx) (r-devel only)
   and confirm (with Nic, who will automatically receive an email about the results) that the check is clean.
   This step cannot be completed before Jeroen has put the binaries in the MinGW repository, i.e. [here](https://ftp.opencpu.org/rtools/ucrt64/), [here](https://ftp.opencpu.org/rtools/mingw64/), and [here](https://ftp.opencpu.org/rtools/mingw32/).
diff --git a/r/configure b/r/configure
index d244b1a7c148f..ced3b40a68901 100755
--- a/r/configure
+++ b/r/configure
@@ -373,8 +373,6 @@ find_or_build_libarrow
 
 # We should have a valid libarrow build in $_LIBARROW_FOUND
 # Now set `PKG_LIBS`, `PKG_DIRS`, and `PKG_CFLAGS` based on that.
-# _LIBARROW_FOUND should only be unset in the FORCE_AUTOBREW case,
-# and autobrew sets its own PKG_* vars. (See the TODO about changing that.)
 if [ "$_LIBARROW_FOUND" != "false" ] && [ "$_LIBARROW_FOUND" != "" ]; then
   set_pkg_vars ${_LIBARROW_FOUND}
 fi
diff --git a/r/tools/autobrew b/r/tools/autobrew
deleted file mode 100644
index 35ffebcab3796..0000000000000
--- a/r/tools/autobrew
+++ /dev/null
@@ -1,80 +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.
-
-# https://github.com/jeroen/autobrew/blob/gh-pages/apache-arrow
-export HOMEBREW_NO_ANALYTICS=1
-export HOMEBREW_NO_AUTO_UPDATE=1
-
-if [[ ${OSTYPE:6} -ge 20 ]]; then
-  # We are on a modern enough macOS, we can use the real brew
-  UPSTREAM_ORG="homebrew"
-  PKG_BREW_NAME="$PKG_BREW_NAME-static"
-else
-  # Official Homebrew no longer supports El-Capitan
-  # so we need to use the forked autobrew version of brew that supports old macOSes
-  UPSTREAM_ORG="autobrew"
-fi
-
-if [ "$DISABLE_AUTOBREW" ]; then return 0; fi
-AUTOBREW=${TMPDIR-/tmp}
-export HOMEBREW_TEMP="$AUTOBREW/hbtmp"
-BREWDIR="$AUTOBREW/build-$PKG_BREW_NAME"
-BREW="$BREWDIR/bin/brew"
-rm -Rf $BREWDIR
-mkdir -p $BREWDIR
-echo "$(date): Auto-brewing $PKG_BREW_NAME in $BREWDIR..."
-curl -fsSL https://github.com/$UPSTREAM_ORG/brew/tarball/master | tar xz --strip 1 -C $BREWDIR
-
-# Install bottle + dependencies
-export HOMEBREW_CACHE="$AUTOBREW"
-LOCAL_FORMULA="tools/${PKG_BREW_NAME}.rb"
-if [ -f "$LOCAL_FORMULA" ]; then
-  if [[ ${OSTYPE:6} -ge 20 ]]; then
-    $BREW tap
-
-    # Tap https://github.com/autobrew/homebrew-cran so that we can get dependencies from there
-    $BREW tap autobrew/cran
-  fi
-
-  # Use the local brew formula and install --HEAD
-  $BREW deps -n "$LOCAL_FORMULA" 2>/dev/null
-  BREW_DEPS=$($BREW deps -n "$LOCAL_FORMULA" 2>/dev/null)
-  $BREW install --force-bottle $BREW_DEPS 2>&1 | perl -pe 's/Warning/Note/gi'
-  $BREW install -v --build-from-source --HEAD "$LOCAL_FORMULA" 2>&1 | perl -pe 's/Warning/Note/gi'
-else
-  $BREW install --force-bottle $BREW_DEPS $PKG_BREW_NAME 2>&1 | perl -pe 's/Warning/Note/gi'
-fi
-
-# Hardcode this for my custom autobrew build
-rm -f $BREWDIR/lib/*.dylib
-AWS_LIBS="-laws-cpp-sdk-config -laws-cpp-sdk-transfer -laws-cpp-sdk-identity-management -laws-cpp-sdk-cognito-identity -laws-cpp-sdk-sts -laws-cpp-sdk-s3 -laws-cpp-sdk-core -laws-c-event-stream -laws-checksums -laws-c-common -laws-crt-cpp -laws-c-io -laws-c-s3 -laws-c-auth -laws-c-http -laws-c-cal -laws-c-compression -laws-c-mqtt -lpthread -lcurl"
-PKG_LIBS="-lparquet -larrow_dataset -larrow_acero -larrow -larrow_bundled_dependencies -lthrift -lbrotlienc-static -lbrotlidec-static -lbrotlicommon-static -llz4 -lsnappy -lzstd $AWS_LIBS -lssl -lcrypto"
-PKG_DIRS="-L$BREWDIR/lib"
-
-# Prevent CRAN builder from linking against old libs in /usr/local/lib
-for FILE in $BREWDIR/Cellar/*/*/lib/*.a; do
-  BASENAME=`basename $FILE`
-  LIBNAME=`echo "${BASENAME%.*}" | cut -c4-`
-  cp -f $FILE $BREWDIR/lib/libbrew$LIBNAME.a
-  echo "created $BREWDIR/lib/libbrew$LIBNAME.a"
-  PKG_LIBS=`echo $PKG_LIBS | sed "s/-l$LIBNAME/-lbrew$LIBNAME/g"`
-done
-
-PKG_CFLAGS="-I$BREWDIR/opt/$PKG_BREW_NAME/include -DARROW_R_WITH_PARQUET -DARROW_R_WITH_ACERO -DARROW_R_WITH_DATASET -DARROW_R_WITH_JSON -DARROW_R_WITH_S3 -DARROW_R_WITH_GCS -D_LIBCPP_DISABLE_AVAILABILITY"
-
-unset HOMEBREW_NO_ANALYTICS
-unset HOMEBREW_NO_AUTO_UPDATE

From 76f987eb94d2832bc959de455847a03387cab41a Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Mon, 9 Oct 2023 05:50:22 +0200
Subject: [PATCH 489/749] GH-35623: [C++][Python]
 FixedShapeTensorType.ToString() should print the type's parameters (#36496)

### Rationale for this change

The string representation of two different `FixedShapeTensorType` objects is currently the same: `extension<arrow.fixed_shape_tensor>`.

### What changes are included in this PR?

Override general type `ToString()` method for `FixedShapeTensorType`. The string representation of a tensor in this PR is proposed as follows:

```
extension<arrow.fixed_shape_tensor[value_type=*, shape=[*]]
```
### Are these changes tested?

Yes, in Python and in C++.

### Are there any user-facing changes?

No.
* Closes: #35623

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Alenka Frim <AlenkaF@users.noreply.github.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 cpp/src/arrow/extension/fixed_shape_tensor.cc | 18 ++++++++++++
 cpp/src/arrow/extension/fixed_shape_tensor.h  |  1 +
 .../extension/fixed_shape_tensor_test.cc      | 28 +++++++++++++++++++
 cpp/src/arrow/util/print.h                    | 26 +++++++++++++++++
 docs/source/python/extending_types.rst        |  4 +--
 python/pyarrow/tests/test_extension_type.py   | 19 +++++++++++++
 python/pyarrow/types.pxi                      |  6 ++--
 7 files changed, 97 insertions(+), 5 deletions(-)

diff --git a/cpp/src/arrow/extension/fixed_shape_tensor.cc b/cpp/src/arrow/extension/fixed_shape_tensor.cc
index e4195ea9e6656..af8305a025291 100644
--- a/cpp/src/arrow/extension/fixed_shape_tensor.cc
+++ b/cpp/src/arrow/extension/fixed_shape_tensor.cc
@@ -26,7 +26,9 @@
 #include "arrow/tensor.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/print.h"
 #include "arrow/util/sort.h"
+#include "arrow/util/string.h"
 
 #include <rapidjson/document.h>
 #include <rapidjson/writer.h>
@@ -104,6 +106,22 @@ bool FixedShapeTensorType::ExtensionEquals(const ExtensionType& other) const {
          permutation_equivalent;
 }
 
+std::string FixedShapeTensorType::ToString() const {
+  std::stringstream ss;
+  ss << "extension<" << this->extension_name()
+     << "[value_type=" << value_type_->ToString()
+     << ", shape=" << ::arrow::internal::PrintVector{shape_, ","};
+
+  if (!permutation_.empty()) {
+    ss << ", permutation=" << ::arrow::internal::PrintVector{permutation_, ","};
+  }
+  if (!dim_names_.empty()) {
+    ss << ", dim_names=[" << internal::JoinStrings(dim_names_, ",") << "]";
+  }
+  ss << "]>";
+  return ss.str();
+}
+
 std::string FixedShapeTensorType::Serialize() const {
   rj::Document document;
   document.SetObject();
diff --git a/cpp/src/arrow/extension/fixed_shape_tensor.h b/cpp/src/arrow/extension/fixed_shape_tensor.h
index 93837f13002aa..fcfb1ebbab96a 100644
--- a/cpp/src/arrow/extension/fixed_shape_tensor.h
+++ b/cpp/src/arrow/extension/fixed_shape_tensor.h
@@ -61,6 +61,7 @@ class ARROW_EXPORT FixedShapeTensorType : public ExtensionType {
         dim_names_(dim_names) {}
 
   std::string extension_name() const override { return "arrow.fixed_shape_tensor"; }
+  std::string ToString() const override;
 
   /// Number of dimensions of tensor elements
   size_t ndim() { return shape_.size(); }
diff --git a/cpp/src/arrow/extension/fixed_shape_tensor_test.cc b/cpp/src/arrow/extension/fixed_shape_tensor_test.cc
index c3c97bc6e5790..b8be1edc49e60 100644
--- a/cpp/src/arrow/extension/fixed_shape_tensor_test.cc
+++ b/cpp/src/arrow/extension/fixed_shape_tensor_test.cc
@@ -434,4 +434,32 @@ TEST_F(TestExtensionType, ComputeStrides) {
   ASSERT_EQ(ext_type_7->Serialize(), R"({"shape":[3,4,7],"permutation":[2,0,1]})");
 }
 
+TEST_F(TestExtensionType, ToString) {
+  auto exact_ext_type = internal::checked_pointer_cast<FixedShapeTensorType>(ext_type_);
+
+  auto ext_type_1 = internal::checked_pointer_cast<FixedShapeTensorType>(
+      fixed_shape_tensor(int16(), {3, 4, 7}));
+  auto ext_type_2 = internal::checked_pointer_cast<FixedShapeTensorType>(
+      fixed_shape_tensor(int32(), {3, 4, 7}, {1, 0, 2}));
+  auto ext_type_3 = internal::checked_pointer_cast<FixedShapeTensorType>(
+      fixed_shape_tensor(int64(), {3, 4, 7}, {}, {"C", "H", "W"}));
+
+  std::string result_1 = ext_type_1->ToString();
+  std::string expected_1 =
+      "extension<arrow.fixed_shape_tensor[value_type=int16, shape=[3,4,7]]>";
+  ASSERT_EQ(expected_1, result_1);
+
+  std::string result_2 = ext_type_2->ToString();
+  std::string expected_2 =
+      "extension<arrow.fixed_shape_tensor[value_type=int32, shape=[3,4,7], "
+      "permutation=[1,0,2]]>";
+  ASSERT_EQ(expected_2, result_2);
+
+  std::string result_3 = ext_type_3->ToString();
+  std::string expected_3 =
+      "extension<arrow.fixed_shape_tensor[value_type=int64, shape=[3,4,7], "
+      "dim_names=[C,H,W]]>";
+  ASSERT_EQ(expected_3, result_3);
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/util/print.h b/cpp/src/arrow/util/print.h
index d11aa443a95a3..82cea473c5b27 100644
--- a/cpp/src/arrow/util/print.h
+++ b/cpp/src/arrow/util/print.h
@@ -18,6 +18,9 @@
 #pragma once
 
 #include <tuple>
+#include "arrow/util/string.h"
+
+using arrow::internal::ToChars;
 
 namespace arrow {
 namespace internal {
@@ -47,5 +50,28 @@ void PrintTuple(OStream* os, const std::tuple<Args&...>& tup) {
   detail::TuplePrinter<OStream, std::tuple<Args&...>, sizeof...(Args)>::Print(os, tup);
 }
 
+template <typename Range, typename Separator>
+struct PrintVector {
+  const Range& range_;
+  const Separator& separator_;
+
+  template <typename Os>  // template to dodge inclusion of <ostream>
+  friend Os& operator<<(Os& os, PrintVector l) {
+    bool first = true;
+    os << "[";
+    for (const auto& element : l.range_) {
+      if (first) {
+        first = false;
+      } else {
+        os << l.separator_;
+      }
+      os << ToChars(element);  // use ToChars to avoid locale dependence
+    }
+    os << "]";
+    return os;
+  }
+};
+template <typename Range, typename Separator>
+PrintVector(const Range&, const Separator&) -> PrintVector<Range, Separator>;
 }  // namespace internal
 }  // namespace arrow
diff --git a/docs/source/python/extending_types.rst b/docs/source/python/extending_types.rst
index 53ce70e13b4d1..87f04f37dc69c 100644
--- a/docs/source/python/extending_types.rst
+++ b/docs/source/python/extending_types.rst
@@ -419,8 +419,8 @@ Extension arrays can be used as columns in  ``pyarrow.Table`` or
    f0: int8
    f1: string
    f2: bool
-   tensors_int: extension<arrow.fixed_size_tensor>
-   tensors_float: extension<arrow.fixed_size_tensor>
+   tensors_int: extension<arrow.fixed_shape_tensor[value_type=int32, shape=[2,2]]>
+   tensors_float: extension<arrow.fixed_shape_tensor[value_type=float, shape=[2,2]]>
    ----
    f0: [[1,2,3]]
    f1: [["foo","bar",null]]
diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py
index 1eb7d5fa76188..ce575d984e41c 100644
--- a/python/pyarrow/tests/test_extension_type.py
+++ b/python/pyarrow/tests/test_extension_type.py
@@ -1351,3 +1351,22 @@ def test_tensor_type_is_picklable(pickle_module):
     result = pickle_module.loads(pickle_module.dumps(expected_arr))
 
     assert result == expected_arr
+
+
+@pytest.mark.parametrize(("tensor_type", "text"), [
+    (
+        pa.fixed_shape_tensor(pa.int8(), [2, 2, 3]),
+        'fixed_shape_tensor[value_type=int8, shape=[2,2,3]]'
+    ),
+    (
+        pa.fixed_shape_tensor(pa.int32(), [2, 2, 3], permutation=[0, 2, 1]),
+        'fixed_shape_tensor[value_type=int32, shape=[2,2,3], permutation=[0,2,1]]'
+    ),
+    (
+        pa.fixed_shape_tensor(pa.int64(), [2, 2, 3], dim_names=['C', 'H', 'W']),
+        'fixed_shape_tensor[value_type=int64, shape=[2,2,3], dim_names=[C,H,W]]'
+    )
+])
+def test_tensor_type_str(tensor_type, text):
+    tensor_type_str = tensor_type.__str__()
+    assert text in tensor_type_str
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index 9f8b347d56294..bd34726adb0db 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -1558,7 +1558,7 @@ cdef class FixedShapeTensorType(BaseExtensionType):
 
     >>> import pyarrow as pa
     >>> pa.fixed_shape_tensor(pa.int32(), [2, 2])
-    FixedShapeTensorType(extension<arrow.fixed_shape_tensor>)
+    FixedShapeTensorType(extension<arrow.fixed_shape_tensor[value_type=int32, shape=[2,2]]>)
 
     Create an instance of fixed shape tensor extension type with
     permutation:
@@ -4746,7 +4746,7 @@ def fixed_shape_tensor(DataType value_type, shape, dim_names=None, permutation=N
     >>> import pyarrow as pa
     >>> tensor_type = pa.fixed_shape_tensor(pa.int32(), [2, 2])
     >>> tensor_type
-    FixedShapeTensorType(extension<arrow.fixed_shape_tensor>)
+    FixedShapeTensorType(extension<arrow.fixed_shape_tensor[value_type=int32, shape=[2,2]]>)
 
     Inspect the data type:
 
@@ -4762,7 +4762,7 @@ def fixed_shape_tensor(DataType value_type, shape, dim_names=None, permutation=N
     >>> tensor = pa.ExtensionArray.from_storage(tensor_type, storage)
     >>> pa.table([tensor], names=["tensor_array"])
     pyarrow.Table
-    tensor_array: extension<arrow.fixed_shape_tensor>
+    tensor_array: extension<arrow.fixed_shape_tensor[value_type=int32, shape=[2,2]]>
     ----
     tensor_array: [[[1,2,3,4],[10,20,30,40],[100,200,300,400]]]
 

From 293819c48b06c840ce57da25836ef911c5786398 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 9 Oct 2023 10:56:53 +0200
Subject: [PATCH 490/749] GH-37994: [R] Create wrapper functions for the
 CSV*Options classes  (#37995)

### Rationale for this change

It's hard to find the docs for the R6 objects for the CSV reading/writing etc options classes

### What changes are included in this PR?

Create wrapper functions, which are more easily documented

### Are these changes tested?

Yep, I've swapped some existing tests to using the wrappers

### Are there any user-facing changes?

Yes
* Closes: #37994

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                         |   4 +
 r/R/csv.R                           | 264 ++++++++++++++++++++--------
 r/R/dataset-format.R                |  46 ++---
 r/R/dataset.R                       |  12 +-
 r/_pkgdown.yml                      |   5 +
 r/man/CsvReadOptions.Rd             |   5 +
 r/man/csv_convert_options.Rd        |  69 ++++++++
 r/man/csv_parse_options.Rd          |  46 +++++
 r/man/csv_read_options.Rd           |  51 ++++++
 r/man/csv_write_options.Rd          |  38 ++++
 r/man/open_delim_dataset.Rd         |  17 +-
 r/man/read_delim_arrow.Rd           |   6 +-
 r/man/write_csv_arrow.Rd            |   2 +-
 r/tests/testthat/test-csv.R         |  10 +-
 r/tests/testthat/test-dataset-csv.R |  22 ++-
 15 files changed, 475 insertions(+), 122 deletions(-)
 create mode 100644 r/man/csv_convert_options.Rd
 create mode 100644 r/man/csv_parse_options.Rd
 create mode 100644 r/man/csv_read_options.Rd
 create mode 100644 r/man/csv_write_options.Rd

diff --git a/r/NAMESPACE b/r/NAMESPACE
index d49255f781f94..b675952d01a30 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -308,6 +308,10 @@ export(contains)
 export(copy_files)
 export(cpu_count)
 export(create_package_with_all_dependencies)
+export(csv_convert_options)
+export(csv_parse_options)
+export(csv_read_options)
+export(csv_write_options)
 export(dataset_factory)
 export(date32)
 export(date64)
diff --git a/r/R/csv.R b/r/R/csv.R
index 116c620f83490..e68a05720da64 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -122,11 +122,11 @@
 #'  - `NULL`: the default, which uses the ISO-8601 parser
 #'  - a character vector of [strptime][base::strptime()] parse strings
 #'  - a list of [TimestampParser] objects
-#' @param parse_options see [file reader options][CsvReadOptions].
+#' @param parse_options see [CSV parsing options][csv_parse_options()].
 #' If given, this overrides any
 #' parsing options provided in other arguments (e.g. `delim`, `quote`, etc.).
-#' @param convert_options see [file reader options][CsvReadOptions]
-#' @param read_options see [file reader options][CsvReadOptions]
+#' @param convert_options see [CSV conversion options][csv_convert_options()]
+#' @param read_options see [CSV reading options][csv_read_options()]
 #' @param as_data_frame Should the function return a `tibble` (default) or
 #' an Arrow [Table]?
 #'
@@ -337,22 +337,22 @@ CsvTableReader <- R6Class("CsvTableReader",
   )
 )
 CsvTableReader$create <- function(file,
-                                  read_options = CsvReadOptions$create(),
-                                  parse_options = CsvParseOptions$create(),
-                                  convert_options = CsvConvertOptions$create(),
+                                  read_options = csv_read_options(),
+                                  parse_options = csv_parse_options(),
+                                  convert_options = csv_convert_options(),
                                   ...) {
   assert_is(file, "InputStream")
 
   if (is.list(read_options)) {
-    read_options <- do.call(CsvReadOptions$create, read_options)
+    read_options <- do.call(csv_read_options, read_options)
   }
 
   if (is.list(parse_options)) {
-    parse_options <- do.call(CsvParseOptions$create, parse_options)
+    parse_options <- do.call(csv_parse_options, parse_options)
   }
 
   if (is.list(convert_options)) {
-    convert_options <- do.call(CsvConvertOptions$create, convert_options)
+    convert_options <- do.call(csv_convert_options, convert_options)
   }
 
   if (!(tolower(read_options$encoding) %in% c("utf-8", "utf8"))) {
@@ -362,6 +362,58 @@ CsvTableReader$create <- function(file,
   csv___TableReader__Make(file, read_options, parse_options, convert_options)
 }
 
+#' CSV Reading Options
+#'
+#' @param use_threads Whether to use the global CPU thread pool
+#' @param block_size Block size we request from the IO layer; also determines
+#'  the size of chunks when use_threads is `TRUE`.
+#' @param skip_rows Number of lines to skip before reading data (default 0).
+#' @param column_names Character vector to supply column names. If length-0
+#' (the default), the first non-skipped row will be parsed to generate column
+#' names, unless `autogenerate_column_names` is `TRUE`.
+#' @param autogenerate_column_names Logical: generate column names instead of
+#' using the first non-skipped row (the default)? If `TRUE`, column names will
+#' be "f0", "f1", ..., "fN".
+#' @param encoding The file encoding. (default `"UTF-8"`)
+#' @param skip_rows_after_names Number of lines to skip after the column names (default 0).
+#'    This number can be larger than the number of rows in one block, and empty rows are counted.
+#'    The order of application is as follows:
+#'      - `skip_rows` is applied (if non-zero);
+#'      - column names are read (unless `column_names` is set);
+#'      - `skip_rows_after_names` is applied (if non-zero).
+#'
+#' @examples
+#' tf <- tempfile()
+#' on.exit(unlink(tf))
+#' writeLines("my file has a non-data header\nx\n1\n2", tf)
+#' read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1))
+#' open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1))
+#' @export
+csv_read_options <- function(use_threads = option_use_threads(),
+                             block_size = 1048576L,
+                             skip_rows = 0L,
+                             column_names = character(0),
+                             autogenerate_column_names = FALSE,
+                             encoding = "UTF-8",
+                             skip_rows_after_names = 0L) {
+  assert_that(is.string(encoding))
+
+  options <- csv___ReadOptions__initialize(
+    list(
+      use_threads = use_threads,
+      block_size = block_size,
+      skip_rows = skip_rows,
+      skip_rows_after_names = skip_rows_after_names,
+      column_names = column_names,
+      autogenerate_column_names = autogenerate_column_names
+    )
+  )
+
+  options$encoding <- encoding
+
+  options
+}
+
 #' @title File reader options
 #' @rdname CsvReadOptions
 #' @name CsvReadOptions
@@ -455,6 +507,11 @@ CsvTableReader$create <- function(file,
 #' - `batch_size` Maximum number of rows processed at a time. Default is 1024.
 #' - `null_string` The string to be written for null values. Must not contain
 #'   quotation marks. Default is an empty string (`""`).
+#' - `eol` The end of line character to use for ending rows.
+#' - `delimiter` Field delimiter
+#' - `quoting_style` Quoting style: "Needed" (Only enclose values in quotes which need them, because their CSV
+#'    rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in
+#'    quotes), or "None" (Do not enclose any values in quotes).
 #'
 #' @section Active bindings:
 #'
@@ -485,30 +542,8 @@ CsvReadOptions <- R6Class("CsvReadOptions",
     skip_rows_after_names = function() csv___ReadOptions__skip_rows_after_names(self)
   )
 )
-CsvReadOptions$create <- function(use_threads = option_use_threads(),
-                                  block_size = 1048576L,
-                                  skip_rows = 0L,
-                                  column_names = character(0),
-                                  autogenerate_column_names = FALSE,
-                                  encoding = "UTF-8",
-                                  skip_rows_after_names = 0L) {
-  assert_that(is.string(encoding))
 
-  options <- csv___ReadOptions__initialize(
-    list(
-      use_threads = use_threads,
-      block_size = block_size,
-      skip_rows = skip_rows,
-      skip_rows_after_names = skip_rows_after_names,
-      column_names = column_names,
-      autogenerate_column_names = autogenerate_column_names
-    )
-  )
-
-  options$encoding <- encoding
-
-  options
-}
+CsvReadOptions$create <- csv_read_options
 
 readr_to_csv_write_options <- function(col_names = TRUE,
                                        batch_size = 1024L,
@@ -520,7 +555,7 @@ readr_to_csv_write_options <- function(col_names = TRUE,
   quote <- match(match.arg(quote), c("needed", "all", "none"))
   quote <- quoting_style_arrow_opts[quote]
 
-  CsvWriteOptions$create(
+  csv_write_options(
     include_header = col_names,
     batch_size = batch_size,
     delimiter = delim,
@@ -530,15 +565,28 @@ readr_to_csv_write_options <- function(col_names = TRUE,
   )
 }
 
-#' @rdname CsvReadOptions
+#' CSV Writing Options
+#'
+#' @param include_header Whether to write an initial header line with column names
+#' @param batch_size Maximum number of rows processed at a time.
+#' @param null_string The string to be written for null values. Must not contain quotation marks.
+#' @param delimiter Field delimiter
+#' @param eol The end of line character to use for ending rows
+#' @param quoting_style How to handle quotes. "Needed" (Only enclose values in quotes which need them, because their CSV
+#'    rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in
+#'    quotes), or "None" (Do not enclose any values in quotes).
+#'
+#' @examples
+#' tf <- tempfile()
+#' on.exit(unlink(tf))
+#' write_csv_arrow(airquality, tf, write_options = csv_write_options(null_string = "-99"))
 #' @export
-CsvWriteOptions <- R6Class("CsvWriteOptions", inherit = ArrowObject)
-CsvWriteOptions$create <- function(include_header = TRUE,
-                                   batch_size = 1024L,
-                                   null_string = "",
-                                   delimiter = ",",
-                                   eol = "\n",
-                                   quoting_style = c("Needed", "AllValid", "None")) {
+csv_write_options <- function(include_header = TRUE,
+                              batch_size = 1024L,
+                              null_string = "",
+                              delimiter = ",",
+                              eol = "\n",
+                              quoting_style = c("Needed", "AllValid", "None")) {
   quoting_style <- match.arg(quoting_style)
   quoting_style_opts <- c("Needed", "AllValid", "None")
   quoting_style <- match(quoting_style, quoting_style_opts) - 1L
@@ -564,32 +612,50 @@ CsvWriteOptions$create <- function(include_header = TRUE,
   )
 }
 
+#' @rdname CsvReadOptions
+#' @export
+CsvWriteOptions <- R6Class("CsvWriteOptions", inherit = ArrowObject)
+CsvWriteOptions$create <- csv_write_options
+
 readr_to_csv_read_options <- function(skip = 0, col_names = TRUE) {
   if (isTRUE(col_names)) {
     # C++ default to parse is 0-length string array
     col_names <- character(0)
   }
   if (identical(col_names, FALSE)) {
-    CsvReadOptions$create(skip_rows = skip, autogenerate_column_names = TRUE)
+    csv_read_options(skip_rows = skip, autogenerate_column_names = TRUE)
   } else {
-    CsvReadOptions$create(skip_rows = skip, column_names = col_names)
+    csv_read_options(skip_rows = skip, column_names = col_names)
   }
 }
 
-#' @rdname CsvReadOptions
-#' @usage NULL
-#' @format NULL
-#' @docType class
+#' CSV Parsing Options
+#'
+#' @param delimiter Field delimiting character
+#' @param quoting Logical: are strings quoted?
+#' @param quote_char Quoting character, if `quoting` is `TRUE`
+#' @param double_quote Logical: are quotes inside values double-quoted?
+#' @param escaping Logical: whether escaping is used
+#' @param escape_char Escaping character, if `escaping` is `TRUE`
+#' @param newlines_in_values Logical: are values allowed to contain CR (`0x0d`)
+#'    and LF (`0x0a`) characters?
+#' @param ignore_empty_lines Logical: should empty lines be ignored (default) or
+#'    generate a row of missing values (if `FALSE`)?
+#' @examples
+#' tf <- tempfile()
+#' on.exit(unlink(tf))
+#' writeLines("x\n1\n\n2", tf)
+#' read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
+#' open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
 #' @export
-CsvParseOptions <- R6Class("CsvParseOptions", inherit = ArrowObject)
-CsvParseOptions$create <- function(delimiter = ",",
-                                   quoting = TRUE,
-                                   quote_char = '"',
-                                   double_quote = TRUE,
-                                   escaping = FALSE,
-                                   escape_char = "\\",
-                                   newlines_in_values = FALSE,
-                                   ignore_empty_lines = TRUE) {
+csv_parse_options <- function(delimiter = ",",
+                              quoting = TRUE,
+                              quote_char = '"',
+                              double_quote = TRUE,
+                              escaping = FALSE,
+                              escape_char = "\\",
+                              newlines_in_values = FALSE,
+                              ignore_empty_lines = TRUE) {
   csv___ParseOptions__initialize(
     list(
       delimiter = delimiter,
@@ -604,6 +670,14 @@ CsvParseOptions$create <- function(delimiter = ",",
   )
 }
 
+#' @rdname CsvReadOptions
+#' @usage NULL
+#' @format NULL
+#' @docType class
+#' @export
+CsvParseOptions <- R6Class("CsvParseOptions", inherit = ArrowObject)
+CsvParseOptions$create <- csv_parse_options
+
 readr_to_csv_parse_options <- function(delim = ",",
                                        quote = '"',
                                        escape_double = TRUE,
@@ -611,7 +685,7 @@ readr_to_csv_parse_options <- function(delim = ",",
                                        skip_empty_rows = TRUE) {
   # This function translates from the readr argument list to the arrow arg names
   # TODO: validate inputs
-  CsvParseOptions$create(
+  csv_parse_options(
     delimiter = delim,
     quoting = nzchar(quote),
     quote_char = quote,
@@ -643,23 +717,55 @@ TimestampParser$create <- function(format = NULL) {
   }
 }
 
-#' @rdname CsvReadOptions
-#' @usage NULL
-#' @format NULL
-#' @docType class
+
+#' CSV Convert Options
+#'
+#' @param check_utf8 Logical: check UTF8 validity of string columns?
+#' @param null_values Character vector of recognized spellings for null values.
+#'    Analogous to the `na.strings` argument to
+#'    [`read.csv()`][utils::read.csv()] or `na` in [readr::read_csv()].
+#' @param strings_can_be_null Logical: can string / binary columns have
+#'    null values? Similar to the `quoted_na` argument to [readr::read_csv()]
+#' @param true_values Character vector of recognized spellings for `TRUE` values
+#' @param false_values Character vector of recognized spellings for `FALSE` values
+#' @param col_types A `Schema` or `NULL` to infer types
+#' @param auto_dict_encode Logical: Whether to try to automatically
+#'    dictionary-encode string / binary data (think `stringsAsFactors`).
+#'    This setting is ignored for non-inferred columns (those in `col_types`).
+#' @param auto_dict_max_cardinality If `auto_dict_encode`, string/binary columns
+#'    are dictionary-encoded up to this number of unique values (default 50),
+#'    after which it switches to regular encoding.
+#' @param include_columns If non-empty, indicates the names of columns from the
+#'    CSV file that should be actually read and converted (in the vector's order).
+#' @param include_missing_columns Logical: if `include_columns` is provided, should
+#'    columns named in it but not found in the data be included as a column of
+#'    type `null()`? The default (`FALSE`) means that the reader will instead
+#'    raise an error.
+#' @param timestamp_parsers User-defined timestamp parsers. If more than one
+#'    parser is specified, the CSV conversion logic will try parsing values
+#'    starting from the beginning of this vector. Possible values are
+#'    (a) `NULL`, the default, which uses the ISO-8601 parser;
+#'    (b) a character vector of [strptime][base::strptime()] parse strings; or
+#'    (c) a list of [TimestampParser] objects.
+#'
+#' @examples
+#' tf <- tempfile()
+#' on.exit(unlink(tf))
+#' writeLines("x\n1\nNULL\n2\nNA", tf)
+#' read_csv_arrow(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
+#' open_csv_dataset(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
 #' @export
-CsvConvertOptions <- R6Class("CsvConvertOptions", inherit = ArrowObject)
-CsvConvertOptions$create <- function(check_utf8 = TRUE,
-                                     null_values = c("", "NA"),
-                                     true_values = c("T", "true", "TRUE"),
-                                     false_values = c("F", "false", "FALSE"),
-                                     strings_can_be_null = FALSE,
-                                     col_types = NULL,
-                                     auto_dict_encode = FALSE,
-                                     auto_dict_max_cardinality = 50L,
-                                     include_columns = character(),
-                                     include_missing_columns = FALSE,
-                                     timestamp_parsers = NULL) {
+csv_convert_options <- function(check_utf8 = TRUE,
+                                null_values = c("", "NA"),
+                                true_values = c("T", "true", "TRUE"),
+                                false_values = c("F", "false", "FALSE"),
+                                strings_can_be_null = FALSE,
+                                col_types = NULL,
+                                auto_dict_encode = FALSE,
+                                auto_dict_max_cardinality = 50L,
+                                include_columns = character(),
+                                include_missing_columns = FALSE,
+                                timestamp_parsers = NULL) {
   if (!is.null(col_types) && !inherits(col_types, "Schema")) {
     abort(c(
       "Unsupported `col_types` specification.",
@@ -684,6 +790,14 @@ CsvConvertOptions$create <- function(check_utf8 = TRUE,
   )
 }
 
+#' @rdname CsvReadOptions
+#' @usage NULL
+#' @format NULL
+#' @docType class
+#' @export
+CsvConvertOptions <- R6Class("CsvConvertOptions", inherit = ArrowObject)
+CsvConvertOptions$create <- csv_convert_options
+
 readr_to_csv_convert_options <- function(na,
                                          quoted_na,
                                          col_types = NULL,
@@ -732,7 +846,7 @@ readr_to_csv_convert_options <- function(na,
       include_columns <- setdiff(col_names, names(col_types)[nulls])
     }
   }
-  CsvConvertOptions$create(
+  csv_convert_options(
     null_values = na,
     strings_can_be_null = quoted_na,
     col_types = col_types,
@@ -753,7 +867,7 @@ readr_to_csv_convert_options <- function(na,
 #' @param batch_size Maximum number of rows processed at a time. Default is 1024.
 #' @param na value to write for NA values. Must not contain quote marks. Default
 #'     is `""`.
-#' @param write_options see [file reader options][CsvWriteOptions]
+#' @param write_options see [CSV write options][csv_write_options]
 #' @param ... additional parameters
 #'
 #' @return The input `x`, invisibly. Note that if `sink` is an [OutputStream],
diff --git a/r/R/dataset-format.R b/r/R/dataset-format.R
index cdaaf08827bfd..c25a505f89403 100644
--- a/r/R/dataset-format.R
+++ b/r/R/dataset-format.R
@@ -217,19 +217,19 @@ check_csv_file_format_args <- function(args, partitioning = NULL) {
   if (is.null(args$parse_options)) {
     options$parse_options <- do.call(csv_file_format_parse_opts, args)
   } else if (is.list(args$parse_options)) {
-    options$parse_options <- do.call(CsvParseOptions$create, args$parse_options)
+    options$parse_options <- do.call(csv_parse_options, args$parse_options)
   }
 
   if (is.null(args$convert_options)) {
     options$convert_options <- do.call(csv_file_format_convert_opts, args)
   } else if (is.list(args$convert_options)) {
-    options$convert_options <- do.call(CsvConvertOptions$create, args$convert_options)
+    options$convert_options <- do.call(csv_convert_options, args$convert_options)
   }
 
   if (is.null(args$read_options)) {
     options$read_options <- do.call(csv_file_format_read_opts, c(args, list(partitioning = partitioning)))
   } else if (is.list(args$read_options)) {
-    options$read_options <- do.call(CsvReadOptions$create, args$read_options)
+    options$read_options <- do.call(csv_read_options, args$read_options)
   }
 
   options
@@ -239,16 +239,16 @@ check_unsupported_args <- function(args) {
   opt_names <- get_opt_names(args)
 
   # Filter out arguments meant for CsvConvertOptions/CsvReadOptions
-  supported_convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na")
+  supported_convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na")
 
   supported_read_opts <- c(
-    names(formals(CsvReadOptions$create)),
+    names(formals(csv_read_options)),
     names(formals(readr_to_csv_read_options))
   )
 
   # We only currently support all of the readr options for parseoptions
   supported_parse_opts <- c(
-    names(formals(CsvParseOptions$create)),
+    names(formals(csv_parse_options)),
     names(formals(readr_to_csv_parse_options))
   )
 
@@ -303,9 +303,9 @@ check_unrecognised_args <- function(opts) {
   opt_names <- get_opt_names(opts)
 
   arrow_opts <- c(
-    names(formals(CsvParseOptions$create)),
-    names(formals(CsvReadOptions$create)),
-    names(formals(CsvConvertOptions$create)),
+    names(formals(csv_parse_options)),
+    names(formals(csv_read_options)),
+    names(formals(csv_convert_options)),
     "schema"
   )
 
@@ -395,9 +395,9 @@ check_schema <- function(schema, partitioning, column_names) {
 csv_file_format_parse_opts <- function(...) {
   opts <- list(...)
   # Filter out arguments meant for CsvConvertOptions/CsvReadOptions
-  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options")
+  convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na", "convert_options")
   read_opts <- c(
-    names(formals(CsvReadOptions$create)),
+    names(formals(csv_read_options)),
     names(formals(readr_to_csv_read_options)),
     "read_options"
   )
@@ -407,7 +407,7 @@ csv_file_format_parse_opts <- function(...) {
   opts[["parse_options"]] <- NULL
   opt_names <- get_opt_names(opts)
 
-  arrow_opts <- c(names(formals(CsvParseOptions$create)))
+  arrow_opts <- c(names(formals(csv_parse_options)))
   readr_opts <- c(names(formals(readr_to_csv_parse_options)))
 
   is_arrow_opt <- !is.na(pmatch(opt_names, arrow_opts))
@@ -427,17 +427,17 @@ csv_file_format_parse_opts <- function(...) {
     }
     do.call(readr_to_csv_parse_options, opts) # all options have readr-style names
   } else {
-    do.call(CsvParseOptions$create, opts) # all options have Arrow C++ names
+    do.call(csv_parse_options, opts) # all options have Arrow C++ names
   }
 }
 
 csv_file_format_convert_opts <- function(...) {
   opts <- list(...)
   # Filter out arguments meant for CsvParseOptions/CsvReadOptions
-  arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options")
+  arrow_opts <- c(names(formals(csv_parse_options)), "parse_options")
   readr_opts <- names(formals(readr_to_csv_parse_options))
   read_opts <- c(
-    names(formals(CsvReadOptions$create)),
+    names(formals(csv_read_options)),
     names(formals(readr_to_csv_read_options)),
     "read_options"
   )
@@ -458,23 +458,23 @@ csv_file_format_convert_opts <- function(...) {
     opts[["quoted_na"]] <- NULL
   }
 
-  do.call(CsvConvertOptions$create, opts)
+  do.call(csv_convert_options, opts)
 }
 
 csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) {
 
   opts <- list(...)
   # Filter out arguments meant for CsvParseOptions/CsvConvertOptions
-  arrow_opts <- c(names(formals(CsvParseOptions$create)), "parse_options")
+  arrow_opts <- c(names(formals(csv_parse_options)), "parse_options")
   readr_opts <- names(formals(readr_to_csv_parse_options))
-  convert_opts <- c(names(formals(CsvConvertOptions$create)), "na", "quoted_na", "convert_options")
+  convert_opts <- c(names(formals(csv_convert_options)), "na", "quoted_na", "convert_options")
   opts[arrow_opts] <- NULL
   opts[readr_opts] <- NULL
   opts[convert_opts] <- NULL
   opts[["read_options"]] <- NULL
 
   opt_names <- names(opts)
-  arrow_opts <- c(names(formals(CsvReadOptions$create)))
+  arrow_opts <- c(names(formals(csv_read_options)))
   readr_opts <- c(names(formals(readr_to_csv_read_options)))
 
   is_arrow_opt <- !is.na(match(opt_names, arrow_opts))
@@ -505,7 +505,7 @@ csv_file_format_read_opts <- function(schema = NULL, partitioning = NULL, ...) {
     }
     do.call(readr_to_csv_read_options, opts) # all options have readr-style names
   } else {
-    do.call(CsvReadOptions$create, opts) # all options have Arrow C++ names
+    do.call(csv_read_options, opts) # all options have Arrow C++ names
   }
 }
 
@@ -648,7 +648,7 @@ FileWriteOptions <- R6Class("FileWriteOptions",
           )
         } else if (format %in% c("csv", "tsv", "txt", "text")) {
           supported_args <- c(
-            names(formals(CsvWriteOptions$create)),
+            names(formals(csv_write_options)),
             names(formals(readr_to_csv_write_options))
           )
         }
@@ -703,7 +703,7 @@ FileWriteOptions <- R6Class("FileWriteOptions",
           )
         }
       } else if (self$type %in% c("csv", "tsv", "txt", "text")) {
-        arrow_opts <- names(formals(CsvWriteOptions$create))
+        arrow_opts <- names(formals(csv_write_options))
         readr_opts <- names(formals(readr_to_csv_write_options))
         readr_only_opts <- setdiff(readr_opts, arrow_opts)
         arrow_only_opts <- setdiff(arrow_opts, readr_opts)
@@ -727,7 +727,7 @@ FileWriteOptions <- R6Class("FileWriteOptions",
         } else {
           dataset___CsvFileWriteOptions__update(
             self,
-            do.call(CsvWriteOptions$create, args[is_arrow_opt])
+            do.call(csv_write_options, args[is_arrow_opt])
           )
         }
       }
diff --git a/r/R/dataset.R b/r/R/dataset.R
index 9d91839c220bb..90e6516927e5d 100644
--- a/r/R/dataset.R
+++ b/r/R/dataset.R
@@ -276,7 +276,8 @@ open_delim_dataset <- function(sources,
                                convert_options = NULL,
                                read_options = NULL,
                                timestamp_parsers = NULL,
-                               quoted_na = TRUE) {
+                               quoted_na = TRUE,
+                               parse_options = NULL) {
   open_dataset(
     sources = sources,
     schema = schema,
@@ -297,7 +298,8 @@ open_delim_dataset <- function(sources,
     convert_options = convert_options,
     read_options = read_options,
     timestamp_parsers = timestamp_parsers,
-    quoted_na = quoted_na
+    quoted_na = quoted_na,
+    parse_options = parse_options
   )
 }
 
@@ -320,7 +322,8 @@ open_csv_dataset <- function(sources,
                              convert_options = NULL,
                              read_options = NULL,
                              timestamp_parsers = NULL,
-                             quoted_na = TRUE) {
+                             quoted_na = TRUE,
+                             parse_options = NULL) {
   mc <- match.call()
   mc$delim <- ","
   mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow"))
@@ -346,7 +349,8 @@ open_tsv_dataset <- function(sources,
                              convert_options = NULL,
                              read_options = NULL,
                              timestamp_parsers = NULL,
-                             quoted_na = TRUE) {
+                             quoted_na = TRUE,
+                             parse_options = NULL) {
   mc <- match.call()
   mc$delim <- "\t"
   mc[[1]] <- get("open_delim_dataset", envir = asNamespace("arrow"))
diff --git a/r/_pkgdown.yml b/r/_pkgdown.yml
index 57c21e3c0f2cb..84111e599c457 100644
--- a/r/_pkgdown.yml
+++ b/r/_pkgdown.yml
@@ -146,6 +146,10 @@ reference:
   - open_delim_dataset
   - open_csv_dataset
   - open_tsv_dataset
+  - csv_read_options
+  - csv_parse_options
+  - csv_convert_options
+
 
 - title: Write datasets
   desc: >
@@ -155,6 +159,7 @@ reference:
   - write_delim_dataset
   - write_csv_dataset
   - write_tsv_dataset
+  - csv_write_options
 
 - title: Read files
   desc: >
diff --git a/r/man/CsvReadOptions.Rd b/r/man/CsvReadOptions.Rd
index 6ebb2355184c1..32742280cc4d9 100644
--- a/r/man/CsvReadOptions.Rd
+++ b/r/man/CsvReadOptions.Rd
@@ -106,6 +106,11 @@ The \code{CsvWriteOptions$create()} factory method takes the following arguments
 \item \code{batch_size} Maximum number of rows processed at a time. Default is 1024.
 \item \code{null_string} The string to be written for null values. Must not contain
 quotation marks. Default is an empty string (\code{""}).
+\item \code{eol} The end of line character to use for ending rows.
+\item \code{delimiter} Field delimiter
+\item \code{quoting_style} Quoting style: "Needed" (Only enclose values in quotes which need them, because their CSV
+rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in
+quotes), or "None" (Do not enclose any values in quotes).
 }
 }
 
diff --git a/r/man/csv_convert_options.Rd b/r/man/csv_convert_options.Rd
new file mode 100644
index 0000000000000..4fd6eac1c3e82
--- /dev/null
+++ b/r/man/csv_convert_options.Rd
@@ -0,0 +1,69 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/csv.R
+\name{csv_convert_options}
+\alias{csv_convert_options}
+\title{CSV Convert Options}
+\usage{
+csv_convert_options(
+  check_utf8 = TRUE,
+  null_values = c("", "NA"),
+  true_values = c("T", "true", "TRUE"),
+  false_values = c("F", "false", "FALSE"),
+  strings_can_be_null = FALSE,
+  col_types = NULL,
+  auto_dict_encode = FALSE,
+  auto_dict_max_cardinality = 50L,
+  include_columns = character(),
+  include_missing_columns = FALSE,
+  timestamp_parsers = NULL
+)
+}
+\arguments{
+\item{check_utf8}{Logical: check UTF8 validity of string columns?}
+
+\item{null_values}{Character vector of recognized spellings for null values.
+Analogous to the \code{na.strings} argument to
+\code{\link[utils:read.table]{read.csv()}} or \code{na} in \code{\link[readr:read_delim]{readr::read_csv()}}.}
+
+\item{true_values}{Character vector of recognized spellings for \code{TRUE} values}
+
+\item{false_values}{Character vector of recognized spellings for \code{FALSE} values}
+
+\item{strings_can_be_null}{Logical: can string / binary columns have
+null values? Similar to the \code{quoted_na} argument to \code{\link[readr:read_delim]{readr::read_csv()}}}
+
+\item{col_types}{A \code{Schema} or \code{NULL} to infer types}
+
+\item{auto_dict_encode}{Logical: Whether to try to automatically
+dictionary-encode string / binary data (think \code{stringsAsFactors}).
+This setting is ignored for non-inferred columns (those in \code{col_types}).}
+
+\item{auto_dict_max_cardinality}{If \code{auto_dict_encode}, string/binary columns
+are dictionary-encoded up to this number of unique values (default 50),
+after which it switches to regular encoding.}
+
+\item{include_columns}{If non-empty, indicates the names of columns from the
+CSV file that should be actually read and converted (in the vector's order).}
+
+\item{include_missing_columns}{Logical: if \code{include_columns} is provided, should
+columns named in it but not found in the data be included as a column of
+type \code{null()}? The default (\code{FALSE}) means that the reader will instead
+raise an error.}
+
+\item{timestamp_parsers}{User-defined timestamp parsers. If more than one
+parser is specified, the CSV conversion logic will try parsing values
+starting from the beginning of this vector. Possible values are
+(a) \code{NULL}, the default, which uses the ISO-8601 parser;
+(b) a character vector of \link[base:strptime]{strptime} parse strings; or
+(c) a list of \link{TimestampParser} objects.}
+}
+\description{
+CSV Convert Options
+}
+\examples{
+tf <- tempfile()
+on.exit(unlink(tf))
+writeLines('x\n1\nNULL\n2\nNA', tf)
+read_csv_arrow(tf, convert_options = csv_convert_options(null_values =  c("", "NA", "NULL")))
+open_csv_dataset(tf, convert_options = csv_convert_options(null_values =  c("", "NA", "NULL")))
+}
diff --git a/r/man/csv_parse_options.Rd b/r/man/csv_parse_options.Rd
new file mode 100644
index 0000000000000..e2e8fd19a5916
--- /dev/null
+++ b/r/man/csv_parse_options.Rd
@@ -0,0 +1,46 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/csv.R
+\name{csv_parse_options}
+\alias{csv_parse_options}
+\title{CSV Parsing Options}
+\usage{
+csv_parse_options(
+  delimiter = ",",
+  quoting = TRUE,
+  quote_char = "\\"",
+  double_quote = TRUE,
+  escaping = FALSE,
+  escape_char = "\\\\",
+  newlines_in_values = FALSE,
+  ignore_empty_lines = TRUE
+)
+}
+\arguments{
+\item{delimiter}{Field delimiting character}
+
+\item{quoting}{Logical: are strings quoted?}
+
+\item{quote_char}{Quoting character, if \code{quoting} is \code{TRUE}}
+
+\item{double_quote}{Logical: are quotes inside values double-quoted?}
+
+\item{escaping}{Logical: whether escaping is used}
+
+\item{escape_char}{Escaping character, if \code{escaping} is \code{TRUE}}
+
+\item{newlines_in_values}{Logical: are values allowed to contain CR (\code{0x0d})
+and LF (\code{0x0a}) characters?}
+
+\item{ignore_empty_lines}{Logical: should empty lines be ignored (default) or
+generate a row of missing values (if \code{FALSE})?}
+}
+\description{
+CSV Parsing Options
+}
+\examples{
+tf <- tempfile()
+on.exit(unlink(tf))
+writeLines('x\n1\n\n2', tf)
+read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines =  FALSE))
+open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines =  FALSE))
+}
diff --git a/r/man/csv_read_options.Rd b/r/man/csv_read_options.Rd
new file mode 100644
index 0000000000000..ed2436f316f57
--- /dev/null
+++ b/r/man/csv_read_options.Rd
@@ -0,0 +1,51 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/csv.R
+\name{csv_read_options}
+\alias{csv_read_options}
+\title{CSV Reading Options}
+\usage{
+csv_read_options(
+  use_threads = option_use_threads(),
+  block_size = 1048576L,
+  skip_rows = 0L,
+  column_names = character(0),
+  autogenerate_column_names = FALSE,
+  encoding = "UTF-8",
+  skip_rows_after_names = 0L
+)
+}
+\arguments{
+\item{use_threads}{Whether to use the global CPU thread pool}
+
+\item{block_size}{Block size we request from the IO layer; also determines
+the size of chunks when use_threads is \code{TRUE}.}
+
+\item{skip_rows}{Number of lines to skip before reading data (default 0).}
+
+\item{column_names}{Character vector to supply column names. If length-0
+(the default), the first non-skipped row will be parsed to generate column
+names, unless \code{autogenerate_column_names} is \code{TRUE}.}
+
+\item{autogenerate_column_names}{Logical: generate column names instead of
+using the first non-skipped row (the default)? If \code{TRUE}, column names will
+be "f0", "f1", ..., "fN".}
+
+\item{encoding}{The file encoding. (default \code{"UTF-8"})}
+
+\item{skip_rows_after_names}{Number of lines to skip after the column names (default 0).
+This number can be larger than the number of rows in one block, and empty rows are counted.
+The order of application is as follows:
+- \code{skip_rows} is applied (if non-zero);
+- column names are read (unless \code{column_names} is set);
+- \code{skip_rows_after_names} is applied (if non-zero).}
+}
+\description{
+CSV Reading Options
+}
+\examples{
+tf <- tempfile()
+on.exit(unlink(tf))
+writeLines('my file has a non-data header\nx\n1\n2', tf)
+read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1))
+open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1))
+}
diff --git a/r/man/csv_write_options.Rd b/r/man/csv_write_options.Rd
new file mode 100644
index 0000000000000..a42905dd18d3a
--- /dev/null
+++ b/r/man/csv_write_options.Rd
@@ -0,0 +1,38 @@
+% Generated by roxygen2: do not edit by hand
+% Please edit documentation in R/csv.R
+\name{csv_write_options}
+\alias{csv_write_options}
+\title{CSV Writing Options}
+\usage{
+csv_write_options(
+  include_header = TRUE,
+  batch_size = 1024L,
+  null_string = "",
+  delimiter = ",",
+  eol = "\\n",
+  quoting_style = c("Needed", "AllValid", "None")
+)
+}
+\arguments{
+\item{include_header}{Whether to write an initial header line with column names}
+
+\item{batch_size}{Maximum number of rows processed at a time.}
+
+\item{null_string}{The string to be written for null values. Must not contain quotation marks.}
+
+\item{delimiter}{Field delimiter}
+
+\item{eol}{The end of line character to use for ending rows}
+
+\item{quoting_style}{How to handle quotes. "Needed" (Only enclose values in quotes which need them, because their CSV
+rendering can contain quotes itself (e.g. strings or binary values)), "AllValid" (Enclose all valid values in
+quotes), or "None" (Do not enclose any values in quotes).}
+}
+\description{
+CSV Writing Options
+}
+\examples{
+tf <- tempfile()
+on.exit(unlink(tf))
+write_csv_arrow(airquality, tf, write_options = csv_write_options(null_string = "-99"))
+}
diff --git a/r/man/open_delim_dataset.Rd b/r/man/open_delim_dataset.Rd
index cf08302cc6436..7b81f0033ea35 100644
--- a/r/man/open_delim_dataset.Rd
+++ b/r/man/open_delim_dataset.Rd
@@ -25,7 +25,8 @@ open_delim_dataset(
   convert_options = NULL,
   read_options = NULL,
   timestamp_parsers = NULL,
-  quoted_na = TRUE
+  quoted_na = TRUE,
+  parse_options = NULL
 )
 
 open_csv_dataset(
@@ -46,7 +47,8 @@ open_csv_dataset(
   convert_options = NULL,
   read_options = NULL,
   timestamp_parsers = NULL,
-  quoted_na = TRUE
+  quoted_na = TRUE,
+  parse_options = NULL
 )
 
 open_tsv_dataset(
@@ -67,7 +69,8 @@ open_tsv_dataset(
   convert_options = NULL,
   read_options = NULL,
   timestamp_parsers = NULL,
-  quoted_na = TRUE
+  quoted_na = TRUE,
+  parse_options = NULL
 )
 }
 \arguments{
@@ -169,9 +172,9 @@ filled with missings.}
 
 \item{skip}{Number of lines to skip before reading data.}
 
-\item{convert_options}{see \link[=CsvReadOptions]{file reader options}}
+\item{convert_options}{see \link[=csv_convert_options]{CSV conversion options}}
 
-\item{read_options}{see \link[=CsvReadOptions]{file reader options}}
+\item{read_options}{see \link[=csv_read_options]{CSV reading options}}
 
 \item{timestamp_parsers}{User-defined timestamp parsers. If more than one
 parser is specified, the CSV conversion logic will try parsing values
@@ -186,6 +189,10 @@ starting from the beginning of this vector. Possible values are:
 values (the default) or strings. (Note that this is different from the
 the Arrow C++ default for the corresponding convert option,
 \code{strings_can_be_null}.)}
+
+\item{parse_options}{see \link[=csv_parse_options]{CSV parsing options}.
+If given, this overrides any
+parsing options provided in other arguments (e.g. \code{delim}, \code{quote}, etc.).}
 }
 \description{
 A wrapper around \link{open_dataset} which explicitly includes parameters mirroring \code{\link[=read_csv_arrow]{read_csv_arrow()}},
diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd
index cd07c8ad07e5f..09c20fa0139af 100644
--- a/r/man/read_delim_arrow.Rd
+++ b/r/man/read_delim_arrow.Rd
@@ -120,13 +120,13 @@ filled with missings.}
 
 \item{skip}{Number of lines to skip before reading data.}
 
-\item{parse_options}{see \link[=CsvReadOptions]{file reader options}.
+\item{parse_options}{see \link[=csv_parse_options]{CSV parsing options}.
 If given, this overrides any
 parsing options provided in other arguments (e.g. \code{delim}, \code{quote}, etc.).}
 
-\item{convert_options}{see \link[=CsvReadOptions]{file reader options}}
+\item{convert_options}{see \link[=csv_convert_options]{CSV conversion options}}
 
-\item{read_options}{see \link[=CsvReadOptions]{file reader options}}
+\item{read_options}{see \link[=csv_read_options]{CSV reading options}}
 
 \item{as_data_frame}{Should the function return a \code{tibble} (default) or
 an Arrow \link{Table}?}
diff --git a/r/man/write_csv_arrow.Rd b/r/man/write_csv_arrow.Rd
index 2b0d09ba748c9..9fcca49fadc05 100644
--- a/r/man/write_csv_arrow.Rd
+++ b/r/man/write_csv_arrow.Rd
@@ -34,7 +34,7 @@ system (\code{SubTreeFileSystem})}
 \item{na}{value to write for NA values. Must not contain quote marks. Default
 is \code{""}.}
 
-\item{write_options}{see \link[=CsvWriteOptions]{file reader options}}
+\item{write_options}{see \link[=csv_write_options]{CSV write options}}
 
 \item{...}{additional parameters}
 }
diff --git a/r/tests/testthat/test-csv.R b/r/tests/testthat/test-csv.R
index 38f79c63979f1..22ccc7950f7ea 100644
--- a/r/tests/testthat/test-csv.R
+++ b/r/tests/testthat/test-csv.R
@@ -336,7 +336,7 @@ test_that("CSV reader works on files with non-UTF-8 encoding", {
   fs <- LocalFileSystem$create()
   reader <- CsvTableReader$create(
     fs$OpenInputStream(tf),
-    read_options = CsvReadOptions$create(encoding = "UTF-16LE")
+    read_options = csv_read_options(encoding = "UTF-16LE")
   )
 
   table <- reader$Read()
@@ -435,7 +435,7 @@ test_that("Write a CSV with custom NA value", {
 
   # Also can use null_value in CsvWriteOptions
   tbl_out1 <- write_csv_arrow(tbl_no_dates, csv_file,
-    write_options = CsvWriteOptions$create(null_string = "another_null")
+    write_options = csv_write_options(null_string = "another_null")
   )
   csv_contents <- readLines(csv_file)
   expect_true(any(grepl("another_null", csv_contents)))
@@ -680,9 +680,9 @@ test_that("CSV reading/parsing/convert options can be passed in as lists", {
 
   tab2 <- read_csv_arrow(
     tf,
-    convert_options = CsvConvertOptions$create(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE),
-    parse_options = CsvParseOptions$create(ignore_empty_lines = FALSE),
-    read_options = CsvReadOptions$create(skip_rows = 1L)
+    convert_options = csv_convert_options(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE),
+    parse_options = csv_parse_options(ignore_empty_lines = FALSE),
+    read_options = csv_read_options(skip_rows = 1L)
   )
 
   expect_equal(tab1, tab2)
diff --git a/r/tests/testthat/test-dataset-csv.R b/r/tests/testthat/test-dataset-csv.R
index e8e7c61fc8848..bee701e5ef9f9 100644
--- a/r/tests/testthat/test-dataset-csv.R
+++ b/r/tests/testthat/test-dataset-csv.R
@@ -206,7 +206,7 @@ test_that("Other text delimited dataset", {
 })
 
 test_that("readr parse options", {
-  arrow_opts <- names(formals(CsvParseOptions$create))
+  arrow_opts <- names(formals(csv_parse_options))
   readr_opts <- names(formals(readr_to_csv_parse_options))
 
   # Arrow and readr parse options must be mutually exclusive, or else the code
@@ -469,8 +469,8 @@ test_that("CSV reading/parsing/convert options can be passed in as lists", {
   ds2 <- open_dataset(
     tf,
     format = "csv",
-    convert_options = CsvConvertOptions$create(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE),
-    read_options = CsvReadOptions$create(skip_rows = 1L)
+    convert_options = csv_convert_options(null_values = c(NA, "NA", "NULL"), strings_can_be_null = TRUE),
+    read_options = csv_read_options(skip_rows = 1L)
   ) %>%
     collect()
 
@@ -571,6 +571,16 @@ test_that("open_delim_dataset params passed through to open_dataset", {
   ds <- open_csv_dataset(dst_dir, quoted_na = FALSE) %>% collect()
   expect_equal(ds$text, c("one", "two", "", "four"))
 
+  # parse_options
+  dst_dir <- make_temp_dir()
+  dst_file <- file.path(dst_dir, "data.csv")
+  writeLines("x\n\n1\n\n\n2\n\n3", dst_file)
+  ds <- open_csv_dataset(
+    dst_dir,
+    parse_options = csv_parse_options(ignore_empty_lines = FALSE)
+  ) %>% collect()
+  expect_equal(ds$x, c(NA, 1L, NA, NA, 2L, NA, 3L))
+
   # timestamp_parsers
   skip("GH-33708: timestamp_parsers don't appear to be working properly")
 
@@ -586,15 +596,15 @@ test_that("open_delim_dataset params passed through to open_dataset", {
 })
 
 test_that("CSVReadOptions printing", {
-  default_read_options <- CsvReadOptions$create()
-  custom_read_options <- CsvReadOptions$create(skip_rows = 102)
+  default_read_options <- csv_read_options()
+  custom_read_options <- csv_read_options(skip_rows = 102)
 
   expect_output(print(default_read_options), "skip_rows: 0")
   expect_output(print(custom_read_options), "skip_rows: 102")
 })
 
 test_that("CSVReadOptions field access", {
-  options <- CsvReadOptions$create()
+  options <- csv_read_options()
   expect_equal(options$skip_rows, 0)
   expect_equal(options$autogenerate_column_names, FALSE)
   expect_equal(options$skip_rows_after_names, 0)

From adcbe2b86daae5c21cd14743c8e1fc3f525d67ec Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Mon, 9 Oct 2023 11:00:10 -0300
Subject: [PATCH 491/749] GH-38138: [R] Add curl to suggests for use of
 `skip_if_offline()` (#38140)

### Rationale for this change

testthat now requires the curl package for `skip_if_offline()`. Previously tests were skipped; how the tests fail (although the message is somewhat bizarre).

### What changes are included in this PR?

Include curl explicitly as an optional dependency so that our dependency install step picks it up.

### Are these changes tested?

Covered by existing tests

### Are there any user-facing changes?

No.
* Closes: #38138

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 r/DESCRIPTION | 1 +
 1 file changed, 1 insertion(+)

diff --git a/r/DESCRIPTION b/r/DESCRIPTION
index 0088e590803a6..6e66c3bc7b707 100644
--- a/r/DESCRIPTION
+++ b/r/DESCRIPTION
@@ -45,6 +45,7 @@ RoxygenNote: 7.2.3
 Config/testthat/edition: 3
 Suggests:
     blob,
+    curl,
     cli,
     DBI,
     dbplyr,

From d353826b30ce5a500c90d7a9fcc6c7c454c33a19 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 9 Oct 2023 11:19:34 -0300
Subject: [PATCH 492/749] GH-38053: [C++][Go] Re-generate sources from
 Schema.fbs (#38054)

### Rationale for this change

Re-generate Go and C++ sources from Flatbuffers specs now including string-view and list-view types.

### What changes are included in this PR?

Documentation fixes on the .fbs files and the generated C++ and Go source files.

### Are these changes tested?

The files should be correct by construction. Existing tests guarantee that no mistake was made in re-generating the files.
* Closes: #38053

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/generated/File_generated.h         |  10 +-
 cpp/src/generated/Message_generated.h      |  45 +++-
 cpp/src/generated/Schema_generated.h       | 264 ++++++++++++++++++++-
 cpp/src/generated/SparseTensor_generated.h |  32 +++
 cpp/src/generated/Tensor_generated.h       |  30 +++
 cpp/src/generated/feather_generated.h      |   7 +
 format/Message.fbs                         |   4 +-
 format/Schema.fbs                          |   2 +-
 go/arrow/internal/flatbuf/BinaryView.go    |  57 +++++
 go/arrow/internal/flatbuf/LargeListView.go |  52 ++++
 go/arrow/internal/flatbuf/ListView.go      |  53 +++++
 go/arrow/internal/flatbuf/RecordBatch.go   |  62 ++++-
 go/arrow/internal/flatbuf/Type.go          |  12 +
 go/arrow/internal/flatbuf/Utf8View.go      |  57 +++++
 14 files changed, 662 insertions(+), 25 deletions(-)
 create mode 100644 go/arrow/internal/flatbuf/BinaryView.go
 create mode 100644 go/arrow/internal/flatbuf/LargeListView.go
 create mode 100644 go/arrow/internal/flatbuf/ListView.go
 create mode 100644 go/arrow/internal/flatbuf/Utf8View.go

diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h
index 5b219f1eb0ed1..06953c4a04044 100644
--- a/cpp/src/generated/File_generated.h
+++ b/cpp/src/generated/File_generated.h
@@ -26,18 +26,15 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
   int64_t bodyLength_;
 
  public:
-  Block()
-      : offset_(0),
-        metaDataLength_(0),
-        padding0__(0),
-        bodyLength_(0) {
-    (void)padding0__;
+  Block() {
+    memset(static_cast<void *>(this), 0, sizeof(Block));
   }
   Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
       : offset_(flatbuffers::EndianScalar(_offset)),
         metaDataLength_(flatbuffers::EndianScalar(_metaDataLength)),
         padding0__(0),
         bodyLength_(flatbuffers::EndianScalar(_bodyLength)) {
+    (void)padding0__;
   }
   /// Index to the start of the RecordBlock (note this is past the Message header)
   int64_t offset() const {
@@ -122,6 +119,7 @@ struct FooterBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FooterBuilder &operator=(const FooterBuilder &);
   flatbuffers::Offset<Footer> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Footer>(end);
diff --git a/cpp/src/generated/Message_generated.h b/cpp/src/generated/Message_generated.h
index d0c71e04294a9..55c6f33769381 100644
--- a/cpp/src/generated/Message_generated.h
+++ b/cpp/src/generated/Message_generated.h
@@ -188,9 +188,8 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
   int64_t null_count_;
 
  public:
-  FieldNode()
-      : length_(0),
-        null_count_(0) {
+  FieldNode() {
+    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
   }
   FieldNode(int64_t _length, int64_t _null_count)
       : length_(flatbuffers::EndianScalar(_length)),
@@ -250,6 +249,7 @@ struct BodyCompressionBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BodyCompressionBuilder &operator=(const BodyCompressionBuilder &);
   flatbuffers::Offset<BodyCompression> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<BodyCompression>(end);
@@ -276,7 +276,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_LENGTH = 4,
     VT_NODES = 6,
     VT_BUFFERS = 8,
-    VT_COMPRESSION = 10
+    VT_COMPRESSION = 10,
+    VT_VARIADICBUFFERCOUNTS = 12
   };
   /// number of records / rows. The arrays in the batch should all have this
   /// length
@@ -300,6 +301,23 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::BodyCompression *compression() const {
     return GetPointer<const org::apache::arrow::flatbuf::BodyCompression *>(VT_COMPRESSION);
   }
+  /// Some types such as Utf8View are represented using a variable number of buffers.
+  /// For each such Field in the pre-ordered flattened logical schema, there will be
+  /// an entry in variadicBufferCounts to indicate the number of number of variadic
+  /// buffers which belong to that Field in the current RecordBatch.
+  ///
+  /// For example, the schema
+  ///     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+  ///     col2: Utf8View
+  /// contains two Fields with variadic buffers so variadicBufferCounts will have
+  /// two entries, the first counting the variadic buffers of `col1.beta` and the
+  /// second counting `col2`'s.
+  ///
+  /// This field may be omitted if and only if the schema contains no Fields with
+  /// a variable number of buffers, such as BinaryView and Utf8View.
+  const flatbuffers::Vector<int64_t> *variadicBufferCounts() const {
+    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_VARIADICBUFFERCOUNTS);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int64_t>(verifier, VT_LENGTH) &&
@@ -309,6 +327,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVector(buffers()) &&
            VerifyOffset(verifier, VT_COMPRESSION) &&
            verifier.VerifyTable(compression()) &&
+           VerifyOffset(verifier, VT_VARIADICBUFFERCOUNTS) &&
+           verifier.VerifyVector(variadicBufferCounts()) &&
            verifier.EndTable();
   }
 };
@@ -329,10 +349,14 @@ struct RecordBatchBuilder {
   void add_compression(flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) {
     fbb_.AddOffset(RecordBatch::VT_COMPRESSION, compression);
   }
+  void add_variadicBufferCounts(flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicBufferCounts) {
+    fbb_.AddOffset(RecordBatch::VT_VARIADICBUFFERCOUNTS, variadicBufferCounts);
+  }
   explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  RecordBatchBuilder &operator=(const RecordBatchBuilder &);
   flatbuffers::Offset<RecordBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<RecordBatch>(end);
@@ -345,9 +369,11 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
     int64_t length = 0,
     flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0,
     flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicBufferCounts = 0) {
   RecordBatchBuilder builder_(_fbb);
   builder_.add_length(length);
+  builder_.add_variadicBufferCounts(variadicBufferCounts);
   builder_.add_compression(compression);
   builder_.add_buffers(buffers);
   builder_.add_nodes(nodes);
@@ -359,15 +385,18 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
     int64_t length = 0,
     const std::vector<org::apache::arrow::flatbuf::FieldNode> *nodes = nullptr,
     const std::vector<org::apache::arrow::flatbuf::Buffer> *buffers = nullptr,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    const std::vector<int64_t> *variadicBufferCounts = nullptr) {
   auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::FieldNode>(*nodes) : 0;
   auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*buffers) : 0;
+  auto variadicBufferCounts__ = variadicBufferCounts ? _fbb.CreateVector<int64_t>(*variadicBufferCounts) : 0;
   return org::apache::arrow::flatbuf::CreateRecordBatch(
       _fbb,
       length,
       nodes__,
       buffers__,
-      compression);
+      compression,
+      variadicBufferCounts__);
 }
 
 /// For sending dictionary encoding information. Any Field can be
@@ -422,6 +451,7 @@ struct DictionaryBatchBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &);
   flatbuffers::Offset<DictionaryBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DictionaryBatch>(end);
@@ -538,6 +568,7 @@ struct MessageBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  MessageBuilder &operator=(const MessageBuilder &);
   flatbuffers::Offset<Message> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Message>(end);
diff --git a/cpp/src/generated/Schema_generated.h b/cpp/src/generated/Schema_generated.h
index 89204c894aa4b..a8165f0a89903 100644
--- a/cpp/src/generated/Schema_generated.h
+++ b/cpp/src/generated/Schema_generated.h
@@ -23,6 +23,12 @@ struct ListBuilder;
 struct LargeList;
 struct LargeListBuilder;
 
+struct ListView;
+struct ListViewBuilder;
+
+struct LargeListView;
+struct LargeListViewBuilder;
+
 struct FixedSizeList;
 struct FixedSizeListBuilder;
 
@@ -50,6 +56,12 @@ struct LargeUtf8Builder;
 struct LargeBinary;
 struct LargeBinaryBuilder;
 
+struct Utf8View;
+struct Utf8ViewBuilder;
+
+struct BinaryView;
+struct BinaryViewBuilder;
+
 struct FixedSizeBinary;
 struct FixedSizeBinaryBuilder;
 
@@ -386,11 +398,15 @@ enum class Type : uint8_t {
   LargeUtf8 = 20,
   LargeList = 21,
   RunEndEncoded = 22,
+  BinaryView = 23,
+  Utf8View = 24,
+  ListView = 25,
+  LargeListView = 26,
   MIN = NONE,
-  MAX = RunEndEncoded
+  MAX = LargeListView
 };
 
-inline const Type (&EnumValuesType())[23] {
+inline const Type (&EnumValuesType())[27] {
   static const Type values[] = {
     Type::NONE,
     Type::Null,
@@ -414,13 +430,17 @@ inline const Type (&EnumValuesType())[23] {
     Type::LargeBinary,
     Type::LargeUtf8,
     Type::LargeList,
-    Type::RunEndEncoded
+    Type::RunEndEncoded,
+    Type::BinaryView,
+    Type::Utf8View,
+    Type::ListView,
+    Type::LargeListView
   };
   return values;
 }
 
 inline const char * const *EnumNamesType() {
-  static const char * const names[24] = {
+  static const char * const names[28] = {
     "NONE",
     "Null",
     "Int",
@@ -444,13 +464,17 @@ inline const char * const *EnumNamesType() {
     "LargeUtf8",
     "LargeList",
     "RunEndEncoded",
+    "BinaryView",
+    "Utf8View",
+    "ListView",
+    "LargeListView",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::NONE, Type::RunEndEncoded)) return "";
+  if (flatbuffers::IsOutRange(e, Type::NONE, Type::LargeListView)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -547,6 +571,22 @@ template<> struct TypeTraits<org::apache::arrow::flatbuf::RunEndEncoded> {
   static const Type enum_value = Type::RunEndEncoded;
 };
 
+template<> struct TypeTraits<org::apache::arrow::flatbuf::BinaryView> {
+  static const Type enum_value = Type::BinaryView;
+};
+
+template<> struct TypeTraits<org::apache::arrow::flatbuf::Utf8View> {
+  static const Type enum_value = Type::Utf8View;
+};
+
+template<> struct TypeTraits<org::apache::arrow::flatbuf::ListView> {
+  static const Type enum_value = Type::ListView;
+};
+
+template<> struct TypeTraits<org::apache::arrow::flatbuf::LargeListView> {
+  static const Type enum_value = Type::LargeListView;
+};
+
 bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type);
 bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
@@ -622,9 +662,8 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   int64_t length_;
 
  public:
-  Buffer()
-      : offset_(0),
-        length_(0) {
+  Buffer() {
+    memset(static_cast<void *>(this), 0, sizeof(Buffer));
   }
   Buffer(int64_t _offset, int64_t _length)
       : offset_(flatbuffers::EndianScalar(_offset)),
@@ -663,6 +702,7 @@ struct NullBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  NullBuilder &operator=(const NullBuilder &);
   flatbuffers::Offset<Null> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Null>(end);
@@ -695,6 +735,7 @@ struct Struct_Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Struct_Builder &operator=(const Struct_Builder &);
   flatbuffers::Offset<Struct_> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Struct_>(end);
@@ -724,6 +765,7 @@ struct ListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  ListBuilder &operator=(const ListBuilder &);
   flatbuffers::Offset<List> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<List>(end);
@@ -755,6 +797,7 @@ struct LargeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeListBuilder &operator=(const LargeListBuilder &);
   flatbuffers::Offset<LargeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeList>(end);
@@ -768,6 +811,71 @@ inline flatbuffers::Offset<LargeList> CreateLargeList(
   return builder_.Finish();
 }
 
+/// Represents the same logical types that List can, but contains offsets and
+/// sizes allowing for writes in any order and sharing of child values among
+/// list values.
+struct ListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef ListViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct ListViewBuilder {
+  typedef ListView Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit ListViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ListViewBuilder &operator=(const ListViewBuilder &);
+  flatbuffers::Offset<ListView> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<ListView>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<ListView> CreateListView(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  ListViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+/// extremely large data values.
+struct LargeListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LargeListViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct LargeListViewBuilder {
+  typedef LargeListView Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit LargeListViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LargeListViewBuilder &operator=(const LargeListViewBuilder &);
+  flatbuffers::Offset<LargeListView> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<LargeListView>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LargeListView> CreateLargeListView(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  LargeListViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef FixedSizeListBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -795,6 +903,7 @@ struct FixedSizeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FixedSizeListBuilder &operator=(const FixedSizeListBuilder &);
   flatbuffers::Offset<FixedSizeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeList>(end);
@@ -862,6 +971,7 @@ struct MapBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  MapBuilder &operator=(const MapBuilder &);
   flatbuffers::Offset<Map> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Map>(end);
@@ -916,6 +1026,7 @@ struct UnionBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  UnionBuilder &operator=(const UnionBuilder &);
   flatbuffers::Offset<Union> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Union>(end);
@@ -978,6 +1089,7 @@ struct IntBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  IntBuilder &operator=(const IntBuilder &);
   flatbuffers::Offset<Int> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Int>(end);
@@ -1021,6 +1133,7 @@ struct FloatingPointBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FloatingPointBuilder &operator=(const FloatingPointBuilder &);
   flatbuffers::Offset<FloatingPoint> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FloatingPoint>(end);
@@ -1053,6 +1166,7 @@ struct Utf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  Utf8Builder &operator=(const Utf8Builder &);
   flatbuffers::Offset<Utf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Utf8>(end);
@@ -1083,6 +1197,7 @@ struct BinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BinaryBuilder &operator=(const BinaryBuilder &);
   flatbuffers::Offset<Binary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Binary>(end);
@@ -1114,6 +1229,7 @@ struct LargeUtf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeUtf8Builder &operator=(const LargeUtf8Builder &);
   flatbuffers::Offset<LargeUtf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeUtf8>(end);
@@ -1145,6 +1261,7 @@ struct LargeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  LargeBinaryBuilder &operator=(const LargeBinaryBuilder &);
   flatbuffers::Offset<LargeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeBinary>(end);
@@ -1158,6 +1275,80 @@ inline flatbuffers::Offset<LargeBinary> CreateLargeBinary(
   return builder_.Finish();
 }
 
+/// Logically the same as Utf8, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+struct Utf8View FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef Utf8ViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct Utf8ViewBuilder {
+  typedef Utf8View Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit Utf8ViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  Utf8ViewBuilder &operator=(const Utf8ViewBuilder &);
+  flatbuffers::Offset<Utf8View> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Utf8View>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Utf8View> CreateUtf8View(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  Utf8ViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Logically the same as Binary, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+struct BinaryView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef BinaryViewBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct BinaryViewBuilder {
+  typedef BinaryView Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit BinaryViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BinaryViewBuilder &operator=(const BinaryViewBuilder &);
+  flatbuffers::Offset<BinaryView> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<BinaryView>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<BinaryView> CreateBinaryView(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  BinaryViewBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   typedef FixedSizeBinaryBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -1185,6 +1376,7 @@ struct FixedSizeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FixedSizeBinaryBuilder &operator=(const FixedSizeBinaryBuilder &);
   flatbuffers::Offset<FixedSizeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeBinary>(end);
@@ -1216,6 +1408,7 @@ struct BoolBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  BoolBuilder &operator=(const BoolBuilder &);
   flatbuffers::Offset<Bool> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Bool>(end);
@@ -1250,6 +1443,7 @@ struct RunEndEncodedBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  RunEndEncodedBuilder &operator=(const RunEndEncodedBuilder &);
   flatbuffers::Offset<RunEndEncoded> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<RunEndEncoded>(end);
@@ -1313,6 +1507,7 @@ struct DecimalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DecimalBuilder &operator=(const DecimalBuilder &);
   flatbuffers::Offset<Decimal> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Decimal>(end);
@@ -1364,6 +1559,7 @@ struct DateBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DateBuilder &operator=(const DateBuilder &);
   flatbuffers::Offset<Date> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Date>(end);
@@ -1427,6 +1623,7 @@ struct TimeBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimeBuilder &operator=(const TimeBuilder &);
   flatbuffers::Offset<Time> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Time>(end);
@@ -1594,6 +1791,7 @@ struct TimestampBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimestampBuilder &operator=(const TimestampBuilder &);
   flatbuffers::Offset<Timestamp> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Timestamp>(end);
@@ -1648,6 +1846,7 @@ struct IntervalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  IntervalBuilder &operator=(const IntervalBuilder &);
   flatbuffers::Offset<Interval> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Interval>(end);
@@ -1689,6 +1888,7 @@ struct DurationBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DurationBuilder &operator=(const DurationBuilder &);
   flatbuffers::Offset<Duration> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Duration>(end);
@@ -1743,6 +1943,7 @@ struct KeyValueBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  KeyValueBuilder &operator=(const KeyValueBuilder &);
   flatbuffers::Offset<KeyValue> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<KeyValue>(end);
@@ -1835,6 +2036,7 @@ struct DictionaryEncodingBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DictionaryEncodingBuilder &operator=(const DictionaryEncodingBuilder &);
   flatbuffers::Offset<DictionaryEncoding> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DictionaryEncoding>(end);
@@ -1952,6 +2154,18 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::ListView *type_as_ListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::ListView ? static_cast<const org::apache::arrow::flatbuf::ListView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::LargeListView *type_as_LargeListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::LargeListView ? static_cast<const org::apache::arrow::flatbuf::LargeListView *>(type()) : nullptr;
+  }
   /// Present only if the field is dictionary encoded.
   const org::apache::arrow::flatbuf::DictionaryEncoding *dictionary() const {
     return GetPointer<const org::apache::arrow::flatbuf::DictionaryEncoding *>(VT_DICTIONARY);
@@ -2073,6 +2287,22 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Field::type_
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *Field::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *Field::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
+template<> inline const org::apache::arrow::flatbuf::ListView *Field::type_as<org::apache::arrow::flatbuf::ListView>() const {
+  return type_as_ListView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::LargeListView *Field::type_as<org::apache::arrow::flatbuf::LargeListView>() const {
+  return type_as_LargeListView();
+}
+
 struct FieldBuilder {
   typedef Field Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -2102,6 +2332,7 @@ struct FieldBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  FieldBuilder &operator=(const FieldBuilder &);
   flatbuffers::Offset<Field> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Field>(end);
@@ -2213,6 +2444,7 @@ struct SchemaBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SchemaBuilder &operator=(const SchemaBuilder &);
   flatbuffers::Offset<Schema> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Schema>(end);
@@ -2344,6 +2576,22 @@ inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type ty
       auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Type::BinaryView: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::BinaryView *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type::Utf8View: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Utf8View *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type::ListView: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::ListView *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type::LargeListView: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::LargeListView *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
diff --git a/cpp/src/generated/SparseTensor_generated.h b/cpp/src/generated/SparseTensor_generated.h
index b3fa2dbff467d..514bc0704dadd 100644
--- a/cpp/src/generated/SparseTensor_generated.h
+++ b/cpp/src/generated/SparseTensor_generated.h
@@ -204,6 +204,7 @@ struct SparseTensorIndexCOOBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorIndexCOOBuilder &operator=(const SparseTensorIndexCOOBuilder &);
   flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCOO>(end);
@@ -338,6 +339,7 @@ struct SparseMatrixIndexCSXBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseMatrixIndexCSXBuilder &operator=(const SparseMatrixIndexCSXBuilder &);
   flatbuffers::Offset<SparseMatrixIndexCSX> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseMatrixIndexCSX>(end);
@@ -492,6 +494,7 @@ struct SparseTensorIndexCSFBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorIndexCSFBuilder &operator=(const SparseTensorIndexCSFBuilder &);
   flatbuffers::Offset<SparseTensorIndexCSF> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCSF>(end);
@@ -626,6 +629,18 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::ListView *type_as_ListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::ListView ? static_cast<const org::apache::arrow::flatbuf::ListView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::LargeListView *type_as_LargeListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::LargeListView ? static_cast<const org::apache::arrow::flatbuf::LargeListView *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named.
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -760,6 +775,22 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *SparseTensor
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *SparseTensor::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *SparseTensor::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
+template<> inline const org::apache::arrow::flatbuf::ListView *SparseTensor::type_as<org::apache::arrow::flatbuf::ListView>() const {
+  return type_as_ListView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::LargeListView *SparseTensor::type_as<org::apache::arrow::flatbuf::LargeListView>() const {
+  return type_as_LargeListView();
+}
+
 template<> inline const org::apache::arrow::flatbuf::SparseTensorIndexCOO *SparseTensor::sparseIndex_as<org::apache::arrow::flatbuf::SparseTensorIndexCOO>() const {
   return sparseIndex_as_SparseTensorIndexCOO();
 }
@@ -801,6 +832,7 @@ struct SparseTensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  SparseTensorBuilder &operator=(const SparseTensorBuilder &);
   flatbuffers::Offset<SparseTensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensor>(end);
diff --git a/cpp/src/generated/Tensor_generated.h b/cpp/src/generated/Tensor_generated.h
index 572b922e20f08..d3393553fa4d2 100644
--- a/cpp/src/generated/Tensor_generated.h
+++ b/cpp/src/generated/Tensor_generated.h
@@ -59,6 +59,7 @@ struct TensorDimBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TensorDimBuilder &operator=(const TensorDimBuilder &);
   flatbuffers::Offset<TensorDim> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TensorDim>(end);
@@ -171,6 +172,18 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
     return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::BinaryView *type_as_BinaryView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::BinaryView ? static_cast<const org::apache::arrow::flatbuf::BinaryView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Utf8View *type_as_Utf8View() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::Utf8View ? static_cast<const org::apache::arrow::flatbuf::Utf8View *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::ListView *type_as_ListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::ListView ? static_cast<const org::apache::arrow::flatbuf::ListView *>(type()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::LargeListView *type_as_LargeListView() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::LargeListView ? static_cast<const org::apache::arrow::flatbuf::LargeListView *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -287,6 +300,22 @@ template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Tensor::type
   return type_as_RunEndEncoded();
 }
 
+template<> inline const org::apache::arrow::flatbuf::BinaryView *Tensor::type_as<org::apache::arrow::flatbuf::BinaryView>() const {
+  return type_as_BinaryView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Utf8View *Tensor::type_as<org::apache::arrow::flatbuf::Utf8View>() const {
+  return type_as_Utf8View();
+}
+
+template<> inline const org::apache::arrow::flatbuf::ListView *Tensor::type_as<org::apache::arrow::flatbuf::ListView>() const {
+  return type_as_ListView();
+}
+
+template<> inline const org::apache::arrow::flatbuf::LargeListView *Tensor::type_as<org::apache::arrow::flatbuf::LargeListView>() const {
+  return type_as_LargeListView();
+}
+
 struct TensorBuilder {
   typedef Tensor Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -310,6 +339,7 @@ struct TensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TensorBuilder &operator=(const TensorBuilder &);
   flatbuffers::Offset<Tensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Tensor>(end);
diff --git a/cpp/src/generated/feather_generated.h b/cpp/src/generated/feather_generated.h
index 3696188b0f55d..b925eb2bc6a00 100644
--- a/cpp/src/generated/feather_generated.h
+++ b/cpp/src/generated/feather_generated.h
@@ -324,6 +324,7 @@ struct PrimitiveArrayBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  PrimitiveArrayBuilder &operator=(const PrimitiveArrayBuilder &);
   flatbuffers::Offset<PrimitiveArray> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PrimitiveArray>(end);
@@ -386,6 +387,7 @@ struct CategoryMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  CategoryMetadataBuilder &operator=(const CategoryMetadataBuilder &);
   flatbuffers::Offset<CategoryMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CategoryMetadata>(end);
@@ -440,6 +442,7 @@ struct TimestampMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimestampMetadataBuilder &operator=(const TimestampMetadataBuilder &);
   flatbuffers::Offset<TimestampMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimestampMetadata>(end);
@@ -484,6 +487,7 @@ struct DateMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  DateMetadataBuilder &operator=(const DateMetadataBuilder &);
   flatbuffers::Offset<DateMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DateMetadata>(end);
@@ -523,6 +527,7 @@ struct TimeMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  TimeMetadataBuilder &operator=(const TimeMetadataBuilder &);
   flatbuffers::Offset<TimeMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimeMetadata>(end);
@@ -630,6 +635,7 @@ struct ColumnBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  ColumnBuilder &operator=(const ColumnBuilder &);
   flatbuffers::Offset<Column> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Column>(end);
@@ -739,6 +745,7 @@ struct CTableBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
+  CTableBuilder &operator=(const CTableBuilder &);
   flatbuffers::Offset<CTable> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CTable>(end);
diff --git a/format/Message.fbs b/format/Message.fbs
index 92a629f3f9d95..be57533d88bfa 100644
--- a/format/Message.fbs
+++ b/format/Message.fbs
@@ -106,10 +106,10 @@ table RecordBatch {
   /// buffers which belong to that Field in the current RecordBatch.
   ///
   /// For example, the schema
-  ///     col1: Struct<a: Int32, b: BinaryView, c: Float64>
+  ///     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
   ///     col2: Utf8View
   /// contains two Fields with variadic buffers so variadicBufferCounts will have
-  /// two entries, the first counting the variadic buffers of `col1.b` and the
+  /// two entries, the first counting the variadic buffers of `col1.beta` and the
   /// second counting `col2`'s.
   ///
   /// This field may be omitted if and only if the schema contains no Fields with
diff --git a/format/Schema.fbs b/format/Schema.fbs
index 70d9634463d61..6adbcb115cde3 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -194,7 +194,7 @@ table LargeBinary {
 table Utf8View {
 }
 
-/// Logically the same as Binary, but the internal representation uses a header
+/// Logically the same as Binary, but the internal representation uses a view
 /// struct that contains the string length and either the string's entire data
 /// inline (for small strings) or an inlined prefix, an index of another buffer,
 /// and an offset pointing to a slice in that buffer (for non-small strings).
diff --git a/go/arrow/internal/flatbuf/BinaryView.go b/go/arrow/internal/flatbuf/BinaryView.go
new file mode 100644
index 0000000000000..09ca5e7db9601
--- /dev/null
+++ b/go/arrow/internal/flatbuf/BinaryView.go
@@ -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.
+
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatbuf
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+/// Logically the same as Binary, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+type BinaryView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsBinaryView(buf []byte, offset flatbuffers.UOffsetT) *BinaryView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &BinaryView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func (rcv *BinaryView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *BinaryView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func BinaryViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func BinaryViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
diff --git a/go/arrow/internal/flatbuf/LargeListView.go b/go/arrow/internal/flatbuf/LargeListView.go
new file mode 100644
index 0000000000000..5b1df149cd1e2
--- /dev/null
+++ b/go/arrow/internal/flatbuf/LargeListView.go
@@ -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.
+
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatbuf
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+/// extremely large data values.
+type LargeListView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsLargeListView(buf []byte, offset flatbuffers.UOffsetT) *LargeListView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &LargeListView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func (rcv *LargeListView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *LargeListView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func LargeListViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func LargeListViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
diff --git a/go/arrow/internal/flatbuf/ListView.go b/go/arrow/internal/flatbuf/ListView.go
new file mode 100644
index 0000000000000..46b1e0b3cbf2f
--- /dev/null
+++ b/go/arrow/internal/flatbuf/ListView.go
@@ -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.
+
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatbuf
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+/// Represents the same logical types that List can, but contains offsets and
+/// sizes allowing for writes in any order and sharing of child values among
+/// list values.
+type ListView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsListView(buf []byte, offset flatbuffers.UOffsetT) *ListView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ListView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func (rcv *ListView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ListView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func ListViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func ListViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
diff --git a/go/arrow/internal/flatbuf/RecordBatch.go b/go/arrow/internal/flatbuf/RecordBatch.go
index bb6aca9a0614d..c50f4a6e868ea 100644
--- a/go/arrow/internal/flatbuf/RecordBatch.go
+++ b/go/arrow/internal/flatbuf/RecordBatch.go
@@ -128,8 +128,62 @@ func (rcv *RecordBatch) Compression(obj *BodyCompression) *BodyCompression {
 }
 
 /// Optional compression of the message body
+/// Some types such as Utf8View are represented using a variable number of buffers.
+/// For each such Field in the pre-ordered flattened logical schema, there will be
+/// an entry in variadicBufferCounts to indicate the number of number of variadic
+/// buffers which belong to that Field in the current RecordBatch.
+///
+/// For example, the schema
+///     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+///     col2: Utf8View
+/// contains two Fields with variadic buffers so variadicBufferCounts will have
+/// two entries, the first counting the variadic buffers of `col1.beta` and the
+/// second counting `col2`'s.
+///
+/// This field may be omitted if and only if the schema contains no Fields with
+/// a variable number of buffers, such as BinaryView and Utf8View.
+func (rcv *RecordBatch) VariadicBufferCounts(j int) int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.GetInt64(a + flatbuffers.UOffsetT(j*8))
+	}
+	return 0
+}
+
+func (rcv *RecordBatch) VariadicBufferCountsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+/// Some types such as Utf8View are represented using a variable number of buffers.
+/// For each such Field in the pre-ordered flattened logical schema, there will be
+/// an entry in variadicBufferCounts to indicate the number of number of variadic
+/// buffers which belong to that Field in the current RecordBatch.
+///
+/// For example, the schema
+///     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+///     col2: Utf8View
+/// contains two Fields with variadic buffers so variadicBufferCounts will have
+/// two entries, the first counting the variadic buffers of `col1.beta` and the
+/// second counting `col2`'s.
+///
+/// This field may be omitted if and only if the schema contains no Fields with
+/// a variable number of buffers, such as BinaryView and Utf8View.
+func (rcv *RecordBatch) MutateVariadicBufferCounts(j int, n int64) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		a := rcv._tab.Vector(o)
+		return rcv._tab.MutateInt64(a+flatbuffers.UOffsetT(j*8), n)
+	}
+	return false
+}
+
 func RecordBatchStart(builder *flatbuffers.Builder) {
-	builder.StartObject(4)
+	builder.StartObject(5)
 }
 func RecordBatchAddLength(builder *flatbuffers.Builder, length int64) {
 	builder.PrependInt64Slot(0, length, 0)
@@ -149,6 +203,12 @@ func RecordBatchStartBuffersVector(builder *flatbuffers.Builder, numElems int) f
 func RecordBatchAddCompression(builder *flatbuffers.Builder, compression flatbuffers.UOffsetT) {
 	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(compression), 0)
 }
+func RecordBatchAddVariadicBufferCounts(builder *flatbuffers.Builder, variadicBufferCounts flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(variadicBufferCounts), 0)
+}
+func RecordBatchStartVariadicBufferCountsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(8, numElems, 8)
+}
 func RecordBatchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	return builder.EndObject()
 }
diff --git a/go/arrow/internal/flatbuf/Type.go b/go/arrow/internal/flatbuf/Type.go
index 707444b8e1ecd..ab2bce9c63657 100644
--- a/go/arrow/internal/flatbuf/Type.go
+++ b/go/arrow/internal/flatbuf/Type.go
@@ -49,6 +49,10 @@ const (
 	TypeLargeUtf8       Type = 20
 	TypeLargeList       Type = 21
 	TypeRunEndEncoded   Type = 22
+	TypeBinaryView      Type = 23
+	TypeUtf8View        Type = 24
+	TypeListView        Type = 25
+	TypeLargeListView   Type = 26
 )
 
 var EnumNamesType = map[Type]string{
@@ -75,6 +79,10 @@ var EnumNamesType = map[Type]string{
 	TypeLargeUtf8:       "LargeUtf8",
 	TypeLargeList:       "LargeList",
 	TypeRunEndEncoded:   "RunEndEncoded",
+	TypeBinaryView:      "BinaryView",
+	TypeUtf8View:        "Utf8View",
+	TypeListView:        "ListView",
+	TypeLargeListView:   "LargeListView",
 }
 
 var EnumValuesType = map[string]Type{
@@ -101,6 +109,10 @@ var EnumValuesType = map[string]Type{
 	"LargeUtf8":       TypeLargeUtf8,
 	"LargeList":       TypeLargeList,
 	"RunEndEncoded":   TypeRunEndEncoded,
+	"BinaryView":      TypeBinaryView,
+	"Utf8View":        TypeUtf8View,
+	"ListView":        TypeListView,
+	"LargeListView":   TypeLargeListView,
 }
 
 func (v Type) String() string {
diff --git a/go/arrow/internal/flatbuf/Utf8View.go b/go/arrow/internal/flatbuf/Utf8View.go
new file mode 100644
index 0000000000000..9cf821490198f
--- /dev/null
+++ b/go/arrow/internal/flatbuf/Utf8View.go
@@ -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.
+
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatbuf
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+/// Logically the same as Utf8, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+type Utf8View struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUtf8View(buf []byte, offset flatbuffers.UOffsetT) *Utf8View {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Utf8View{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func (rcv *Utf8View) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Utf8View) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func Utf8ViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func Utf8ViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

From b3362f2d241248a435ce53ae85bf3cf5c65d1432 Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Mon, 9 Oct 2023 18:13:56 +0200
Subject: [PATCH 493/749] GH-29184: [R] Read CSV with comma as decimal mark
 (#38002)

### Rationale for this change

Allow customisable decimal points when reading data

### What changes are included in this PR?

Expose the C++ option in R

### Are these changes tested?

Aye

### Are there any user-facing changes?

Indeed
* Closes: #29184

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                         |  1 +
 r/R/csv.R                           | 50 +++++++++++++++++++++++++----
 r/man/CsvReadOptions.Rd             |  1 +
 r/man/csv_convert_options.Rd        | 11 ++++---
 r/man/csv_parse_options.Rd          |  6 ++--
 r/man/csv_read_options.Rd           |  2 +-
 r/man/read_delim_arrow.Rd           | 29 +++++++++++++++--
 r/src/csv.cpp                       |  2 ++
 r/tests/testthat/test-csv.R         |  7 ++++
 r/tests/testthat/test-dataset-csv.R | 15 +++++++++
 10 files changed, 107 insertions(+), 17 deletions(-)

diff --git a/r/NAMESPACE b/r/NAMESPACE
index b675952d01a30..dac2cbda9cb5e 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -371,6 +371,7 @@ export(open_csv_dataset)
 export(open_dataset)
 export(open_delim_dataset)
 export(open_tsv_dataset)
+export(read_csv2_arrow)
 export(read_csv_arrow)
 export(read_delim_arrow)
 export(read_feather)
diff --git a/r/R/csv.R b/r/R/csv.R
index e68a05720da64..89df75a4b0aeb 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -22,7 +22,8 @@
 #' `readr::read_delim()`, and `col_select` was inspired by `vroom::vroom()`.
 #'
 #' `read_csv_arrow()` and `read_tsv_arrow()` are wrappers around
-#' `read_delim_arrow()` that specify a delimiter.
+#' `read_delim_arrow()` that specify a delimiter. `read_csv2_arrow()` uses `;`⁠ for
+#' the delimiter and `,` for the decimal point.
 #'
 #' Note that not all `readr` options are currently implemented here. Please file
 #' an issue if you encounter one that `arrow` should support.
@@ -129,6 +130,7 @@
 #' @param read_options see [CSV reading options][csv_read_options()]
 #' @param as_data_frame Should the function return a `tibble` (default) or
 #' an Arrow [Table]?
+#' @param decimal_point Character to use for decimal point in floating point numbers.
 #'
 #' @return A `tibble`, or a Table if `as_data_frame = FALSE`.
 #' @export
@@ -178,7 +180,8 @@ read_delim_arrow <- function(file,
                              convert_options = NULL,
                              read_options = NULL,
                              as_data_frame = TRUE,
-                             timestamp_parsers = NULL) {
+                             timestamp_parsers = NULL,
+                             decimal_point = ".") {
   if (inherits(schema, "Schema")) {
     col_names <- names(schema)
     col_types <- schema
@@ -197,8 +200,9 @@ read_delim_arrow <- function(file,
   }
   if (is.null(convert_options)) {
     convert_options <- readr_to_csv_convert_options(
-      na,
-      quoted_na,
+      na = na,
+      quoted_na = quoted_na,
+      decimal_point = decimal_point,
       col_types = col_types,
       col_names = read_options$column_names,
       timestamp_parsers = timestamp_parsers
@@ -279,6 +283,32 @@ read_csv_arrow <- function(file,
   eval.parent(mc)
 }
 
+#' @rdname read_delim_arrow
+#' @export
+read_csv2_arrow <- function(file,
+                            quote = '"',
+                            escape_double = TRUE,
+                            escape_backslash = FALSE,
+                            schema = NULL,
+                            col_names = TRUE,
+                            col_types = NULL,
+                            col_select = NULL,
+                            na = c("", "NA"),
+                            quoted_na = TRUE,
+                            skip_empty_rows = TRUE,
+                            skip = 0L,
+                            parse_options = NULL,
+                            convert_options = NULL,
+                            read_options = NULL,
+                            as_data_frame = TRUE,
+                            timestamp_parsers = NULL) {
+  mc <- match.call()
+  mc$delim <- ";"
+  mc$decimal_point = ","
+  mc[[1]] <- get("read_delim_arrow", envir = asNamespace("arrow"))
+  eval.parent(mc)
+}
+
 #' @rdname read_delim_arrow
 #' @export
 read_tsv_arrow <- function(file,
@@ -497,6 +527,7 @@ csv_read_options <- function(use_threads = option_use_threads(),
 #'    (a) `NULL`, the default, which uses the ISO-8601 parser;
 #'    (b) a character vector of [strptime][base::strptime()] parse strings; or
 #'    (c) a list of [TimestampParser] objects.
+#' - `decimal_point` Character to use for decimal point in floating point numbers. Default: "."
 #'
 #' `TimestampParser$create()` takes an optional `format` string argument.
 #' See [`strptime()`][base::strptime()] for example syntax.
@@ -747,6 +778,7 @@ TimestampParser$create <- function(format = NULL) {
 #'    (a) `NULL`, the default, which uses the ISO-8601 parser;
 #'    (b) a character vector of [strptime][base::strptime()] parse strings; or
 #'    (c) a list of [TimestampParser] objects.
+#' @param decimal_point Character to use for decimal point in floating point numbers.
 #'
 #' @examples
 #' tf <- tempfile()
@@ -765,7 +797,8 @@ csv_convert_options <- function(check_utf8 = TRUE,
                                 auto_dict_max_cardinality = 50L,
                                 include_columns = character(),
                                 include_missing_columns = FALSE,
-                                timestamp_parsers = NULL) {
+                                timestamp_parsers = NULL,
+                                decimal_point = ".") {
   if (!is.null(col_types) && !inherits(col_types, "Schema")) {
     abort(c(
       "Unsupported `col_types` specification.",
@@ -785,7 +818,8 @@ csv_convert_options <- function(check_utf8 = TRUE,
       auto_dict_max_cardinality = auto_dict_max_cardinality,
       include_columns = include_columns,
       include_missing_columns = include_missing_columns,
-      timestamp_parsers = timestamp_parsers
+      timestamp_parsers = timestamp_parsers,
+      decimal_point = decimal_point
     )
   )
 }
@@ -800,6 +834,7 @@ CsvConvertOptions$create <- csv_convert_options
 
 readr_to_csv_convert_options <- function(na,
                                          quoted_na,
+                                         decimal_point,
                                          col_types = NULL,
                                          col_names = NULL,
                                          timestamp_parsers = NULL) {
@@ -851,7 +886,8 @@ readr_to_csv_convert_options <- function(na,
     strings_can_be_null = quoted_na,
     col_types = col_types,
     timestamp_parsers = timestamp_parsers,
-    include_columns = include_columns
+    include_columns = include_columns,
+    decimal_point = decimal_point
   )
 }
 
diff --git a/r/man/CsvReadOptions.Rd b/r/man/CsvReadOptions.Rd
index 32742280cc4d9..d4544cf829f28 100644
--- a/r/man/CsvReadOptions.Rd
+++ b/r/man/CsvReadOptions.Rd
@@ -94,6 +94,7 @@ starting from the beginning of this vector. Possible values are
 (a) \code{NULL}, the default, which uses the ISO-8601 parser;
 (b) a character vector of \link[base:strptime]{strptime} parse strings; or
 (c) a list of \link{TimestampParser} objects.
+\item \code{decimal_point} Character to use for decimal point in floating point numbers. Default: "."
 }
 
 \code{TimestampParser$create()} takes an optional \code{format} string argument.
diff --git a/r/man/csv_convert_options.Rd b/r/man/csv_convert_options.Rd
index 4fd6eac1c3e82..f48da56eaa015 100644
--- a/r/man/csv_convert_options.Rd
+++ b/r/man/csv_convert_options.Rd
@@ -15,7 +15,8 @@ csv_convert_options(
   auto_dict_max_cardinality = 50L,
   include_columns = character(),
   include_missing_columns = FALSE,
-  timestamp_parsers = NULL
+  timestamp_parsers = NULL,
+  decimal_point = "."
 )
 }
 \arguments{
@@ -56,6 +57,8 @@ starting from the beginning of this vector. Possible values are
 (a) \code{NULL}, the default, which uses the ISO-8601 parser;
 (b) a character vector of \link[base:strptime]{strptime} parse strings; or
 (c) a list of \link{TimestampParser} objects.}
+
+\item{decimal_point}{Character to use for decimal point in floating point numbers.}
 }
 \description{
 CSV Convert Options
@@ -63,7 +66,7 @@ CSV Convert Options
 \examples{
 tf <- tempfile()
 on.exit(unlink(tf))
-writeLines('x\n1\nNULL\n2\nNA', tf)
-read_csv_arrow(tf, convert_options = csv_convert_options(null_values =  c("", "NA", "NULL")))
-open_csv_dataset(tf, convert_options = csv_convert_options(null_values =  c("", "NA", "NULL")))
+writeLines("x\n1\nNULL\n2\nNA", tf)
+read_csv_arrow(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
+open_csv_dataset(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
 }
diff --git a/r/man/csv_parse_options.Rd b/r/man/csv_parse_options.Rd
index e2e8fd19a5916..23c647470b299 100644
--- a/r/man/csv_parse_options.Rd
+++ b/r/man/csv_parse_options.Rd
@@ -40,7 +40,7 @@ CSV Parsing Options
 \examples{
 tf <- tempfile()
 on.exit(unlink(tf))
-writeLines('x\n1\n\n2', tf)
-read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines =  FALSE))
-open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines =  FALSE))
+writeLines("x\n1\n\n2", tf)
+read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
+open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
 }
diff --git a/r/man/csv_read_options.Rd b/r/man/csv_read_options.Rd
index ed2436f316f57..622e8d5e5be86 100644
--- a/r/man/csv_read_options.Rd
+++ b/r/man/csv_read_options.Rd
@@ -45,7 +45,7 @@ CSV Reading Options
 \examples{
 tf <- tempfile()
 on.exit(unlink(tf))
-writeLines('my file has a non-data header\nx\n1\n2', tf)
+writeLines("my file has a non-data header\nx\n1\n2", tf)
 read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1))
 open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1))
 }
diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd
index 09c20fa0139af..04447fefc79b1 100644
--- a/r/man/read_delim_arrow.Rd
+++ b/r/man/read_delim_arrow.Rd
@@ -3,6 +3,7 @@
 \name{read_delim_arrow}
 \alias{read_delim_arrow}
 \alias{read_csv_arrow}
+\alias{read_csv2_arrow}
 \alias{read_tsv_arrow}
 \title{Read a CSV or other delimited file with Arrow}
 \usage{
@@ -24,7 +25,8 @@ read_delim_arrow(
   convert_options = NULL,
   read_options = NULL,
   as_data_frame = TRUE,
-  timestamp_parsers = NULL
+  timestamp_parsers = NULL,
+  decimal_point = "."
 )
 
 read_csv_arrow(
@@ -47,6 +49,26 @@ read_csv_arrow(
   timestamp_parsers = NULL
 )
 
+read_csv2_arrow(
+  file,
+  quote = "\\"",
+  escape_double = TRUE,
+  escape_backslash = FALSE,
+  schema = NULL,
+  col_names = TRUE,
+  col_types = NULL,
+  col_select = NULL,
+  na = c("", "NA"),
+  quoted_na = TRUE,
+  skip_empty_rows = TRUE,
+  skip = 0L,
+  parse_options = NULL,
+  convert_options = NULL,
+  read_options = NULL,
+  as_data_frame = TRUE,
+  timestamp_parsers = NULL
+)
+
 read_tsv_arrow(
   file,
   quote = "\\"",
@@ -139,6 +161,8 @@ starting from the beginning of this vector. Possible values are:
 \item a character vector of \link[base:strptime]{strptime} parse strings
 \item a list of \link{TimestampParser} objects
 }}
+
+\item{decimal_point}{Character to use for decimal point in floating point numbers.}
 }
 \value{
 A \code{tibble}, or a Table if \code{as_data_frame = FALSE}.
@@ -150,7 +174,8 @@ Arrow C++ options have been mapped to argument names that follow those of
 }
 \details{
 \code{read_csv_arrow()} and \code{read_tsv_arrow()} are wrappers around
-\code{read_delim_arrow()} that specify a delimiter.
+\code{read_delim_arrow()} that specify a delimiter. \code{read_csv2_arrow()} uses \verb{;}⁠ for
+the delimiter and \verb{,} for the decimal point.
 
 Note that not all \code{readr} options are currently implemented here. Please file
 an issue if you encounter one that \code{arrow} should support.
diff --git a/r/src/csv.cpp b/r/src/csv.cpp
index ffb8a11e6b4ef..d253aa878bc39 100644
--- a/r/src/csv.cpp
+++ b/r/src/csv.cpp
@@ -181,6 +181,8 @@ std::shared_ptr<arrow::csv::ConvertOptions> csv___ConvertOptions__initialize(
     res->timestamp_parsers = timestamp_parsers;
   }
 
+  res->decimal_point = cpp11::as_cpp<char>(options["decimal_point"]);
+
   return res;
 }
 
diff --git a/r/tests/testthat/test-csv.R b/r/tests/testthat/test-csv.R
index 22ccc7950f7ea..36f1f229a6085 100644
--- a/r/tests/testthat/test-csv.R
+++ b/r/tests/testthat/test-csv.R
@@ -733,3 +733,10 @@ test_that("Can read CSV files from a URL", {
   expect_true(tibble::is_tibble(cu))
   expect_identical(dim(cu), c(100L, 13L))
 })
+
+test_that("read_csv2_arrow correctly parses comma decimals", {
+  tf <- tempfile()
+  writeLines("x;y\n1,2;c", con = tf)
+  expect_equal(read_csv2_arrow(tf), tibble(x = 1.2, y = "c"))
+
+})
diff --git a/r/tests/testthat/test-dataset-csv.R b/r/tests/testthat/test-dataset-csv.R
index bee701e5ef9f9..2698cd854ae65 100644
--- a/r/tests/testthat/test-dataset-csv.R
+++ b/r/tests/testthat/test-dataset-csv.R
@@ -647,3 +647,18 @@ test_that("GH-34640 - CSV datasets are read in correctly when both schema and pa
       summarize(mean = mean(integer))
   )
 })
+
+test_that("open_dataset() with `decimal_point` argument", {
+  temp_dir <- make_temp_dir()
+  writeLines("x\ty\n1,2\tc", con = file.path(temp_dir, "file1.csv"))
+
+  expect_equal(
+    open_dataset(temp_dir, format = "tsv") %>% collect(),
+    tibble(x = "1,2", y = "c")
+  )
+
+  expect_equal(
+    open_dataset(temp_dir, format = "tsv", decimal_point = ",") %>% collect(),
+    tibble(x = 1.2, y = "c")
+  )
+})

From 832511a529d498f8c7fb10e99f4f28201293d8e5 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Mon, 9 Oct 2023 18:26:53 +0200
Subject: [PATCH 494/749] GH-37936: [CI] Fix integration testing in rc-verify
 nightly builds (#37933)

* Closes: #37936

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/scripts/go_build.sh                        |  4 ++--
 dev/archery/archery/integration/tester_cpp.py |  8 +++++++-
 dev/archery/archery/integration/tester_go.py  |  8 +++++++-
 dev/archery/generate_files_for_endian_test.sh |  2 +-
 dev/release/verify-release-candidate.sh       | 19 ++++++++++++++++++-
 go/go.sum                                     |  4 ++++
 6 files changed, 39 insertions(+), 6 deletions(-)

diff --git a/ci/scripts/go_build.sh b/ci/scripts/go_build.sh
index 2a38901337c56..7c5ca3230c96e 100755
--- a/ci/scripts/go_build.sh
+++ b/ci/scripts/go_build.sh
@@ -50,13 +50,13 @@ if [[ -n "${ARROW_GO_INTEGRATION}" ]]; then
             go_lib="arrow_go_integration.so"
             ;;
         Darwin)
-            go_lib="arrow_go_integration.so"
+            go_lib="arrow_go_integration.dylib"
             ;;
         MINGW*)
             go_lib="arrow_go_integration.dll"
             ;;
     esac
-    go build -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
+    go build -buildvcs=false -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
 
     popd
 fi
diff --git a/dev/archery/archery/integration/tester_cpp.py b/dev/archery/archery/integration/tester_cpp.py
index ab642c31aacc6..866fc225d220a 100644
--- a/dev/archery/archery/integration/tester_cpp.py
+++ b/dev/archery/archery/integration/tester_cpp.py
@@ -18,6 +18,7 @@
 import contextlib
 import functools
 import os
+import sys
 import subprocess
 
 from . import cdata
@@ -41,7 +42,12 @@
     "localhost",
 ]
 
-_dll_suffix = ".dll" if os.name == "nt" else ".so"
+if sys.platform == "darwin":
+    _dll_suffix = ".dylib"
+elif os.name == "nt":
+    _dll_suffix = ".dll"
+else:
+    _dll_suffix = ".so"
 
 _DLL_PATH = _EXE_PATH
 _ARROW_DLL = os.path.join(_DLL_PATH, "libarrow" + _dll_suffix)
diff --git a/dev/archery/archery/integration/tester_go.py b/dev/archery/archery/integration/tester_go.py
index 75333db8d66d5..b7af233f5d6e2 100644
--- a/dev/archery/archery/integration/tester_go.py
+++ b/dev/archery/archery/integration/tester_go.py
@@ -18,6 +18,7 @@
 import contextlib
 import functools
 import os
+import sys
 import subprocess
 
 from . import cdata
@@ -42,7 +43,12 @@
     "localhost",
 ]
 
-_dll_suffix = ".dll" if os.name == "nt" else ".so"
+if sys.platform == "darwin":
+    _dll_suffix = ".dylib"
+elif os.name == "nt":
+    _dll_suffix = ".dll"
+else:
+    _dll_suffix = ".so"
 
 _DLL_PATH = os.path.join(
     ARROW_ROOT_DEFAULT,
diff --git a/dev/archery/generate_files_for_endian_test.sh b/dev/archery/generate_files_for_endian_test.sh
index ba3ce9f167e63..9f82c60bb796b 100755
--- a/dev/archery/generate_files_for_endian_test.sh
+++ b/dev/archery/generate_files_for_endian_test.sh
@@ -29,7 +29,7 @@ set -e
 json_dir=$TMP_DIR/arrow.$$
 mkdir -p $json_dir
 
-archery integration --stop-on-error --with-cpp=1 --tempdir=$json_dir
+archery integration --stop-on-error --run-ipc --with-cpp=1 --tempdir=$json_dir
 
 for f in $json_dir/*.json ; do
     $ARROW_CPP_EXE_PATH/arrow-json-integration-test -mode JSON_TO_ARROW -json $f -arrow ${f%.*}.arrow_file -integration true ;
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 21a3b84a875f4..a107c53b8354f 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -868,6 +868,22 @@ test_go() {
   go test ./...
   go install -buildvcs=false ./...
   go clean -modcache
+  pushd arrow/internal/cdata_integration
+
+  case "$(uname)" in
+    Linux)
+      go_lib="arrow_go_integration.so"
+      ;;
+    Darwin)
+      go_lib="arrow_go_integration.dylib"
+      ;;
+    MINGW*)
+      go_lib="arrow_go_integration.dll"
+      ;;
+  esac
+  go build -buildvcs=false -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
+
+  popd
   popd
 }
 
@@ -878,7 +894,7 @@ test_integration() {
   maybe_setup_conda || exit 1
   maybe_setup_virtualenv || exit 1
 
-  pip install -e dev/archery
+  pip install -e dev/archery[integration]
 
   JAVA_DIR=$ARROW_SOURCE_DIR/java
   CPP_BUILD_DIR=$ARROW_TMPDIR/cpp-build
@@ -894,6 +910,7 @@ test_integration() {
 
   # Flight integration test executable have runtime dependency on release/libgtest.so
   LD_LIBRARY_PATH=$ARROW_CPP_EXE_PATH:$LD_LIBRARY_PATH archery integration \
+    --run-ipc --run-flight --run-c-data \
     --with-cpp=${TEST_INTEGRATION_CPP} \
     --with-java=${TEST_INTEGRATION_JAVA} \
     --with-js=${TEST_INTEGRATION_JS} \
diff --git a/go/go.sum b/go/go.sum
index 609cf7173ef98..2a310bf894b8f 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -19,8 +19,11 @@ github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+m
 github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
 github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
+github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goccy/go-yaml v1.11.0 h1:n7Z+zx8S9f9KgzG6KtQKf+kwqXZlLNR2F6018Dgau54=
@@ -50,6 +53,7 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=

From ad26f3ff2348292be8d723be64f443553c3703f3 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Mon, 9 Oct 2023 13:31:10 -0300
Subject: [PATCH 495/749] GH-37952: [C++] Make unique->shared explicit to fix
 build failure on at least one compiler (#38136)

### Rationale for this change

The [test-r-rstudio-r-base-4.1-opensuse153](https://github.com/ursacomputing/crossbow/runs/17162402631) nightly has been failing with a compile error for many days.

### What changes are included in this PR?

Made the unique->shared conversion explicit.

### Are these changes tested?

Yes (by existing tests)

### Are there any user-facing changes?

No.
* Closes: #37952

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/dataset/file_parquet.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index 3cad1ddd8321f..9c187f12f67cf 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -462,7 +462,7 @@ Result<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
   std::unique_ptr<parquet::arrow::FileReader> arrow_reader;
   RETURN_NOT_OK(parquet::arrow::FileReader::Make(
       options->pool, std::move(reader), std::move(arrow_properties), &arrow_reader));
-  return arrow_reader;
+  return std::move(arrow_reader);
 }
 
 Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReaderAsync(

From d602d401569697a61e0dc1ea1fabcf829fc09142 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 10 Oct 2023 05:25:24 +0900
Subject: [PATCH 496/749] GH-38077: [C++] Output bundled GoogleTest to
 ${BUILD_DIR}/${CONFIG} (#38132)

### Rationale for this change

To find DLLs on Windows, we need to add a directory of these DLLs to PATH or put these DLLs to the same directory of the target .exe.

### What changes are included in this PR?

Output bundled GoogleTest's DLLs to the same directory of the test .exe.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38077

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 6d6a2bf7751ee..d194c455eaaaa 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -2139,10 +2139,22 @@ function(build_gtest)
             FORCE)
   string(APPEND CMAKE_INSTALL_INCLUDEDIR "/arrow-gtest")
   fetchcontent_makeavailable(googletest)
-  set_target_properties(gmock PROPERTIES OUTPUT_NAME "arrow_gmock")
-  set_target_properties(gmock_main PROPERTIES OUTPUT_NAME "arrow_gmock_main")
-  set_target_properties(gtest PROPERTIES OUTPUT_NAME "arrow_gtest")
-  set_target_properties(gtest_main PROPERTIES OUTPUT_NAME "arrow_gtest_main")
+  foreach(target gmock gmock_main gtest gtest_main)
+    set_target_properties(${target}
+                          PROPERTIES OUTPUT_NAME "arrow_${target}"
+                                     PDB_NAME "arrow_${target}"
+                                     PDB_NAME_DEBUG "arrow_${target}d"
+                                     COMPILE_PDB_NAME "arrow_${target}"
+                                     COMPILE_PDB_NAME_DEBUG "arrow_${target}d"
+                                     RUNTIME_OUTPUT_DIRECTORY
+                                     "${BUILD_OUTPUT_ROOT_DIRECTORY}"
+                                     LIBRARY_OUTPUT_DIRECTORY
+                                     "${BUILD_OUTPUT_ROOT_DIRECTORY}"
+                                     ARCHIVE_OUTPUT_DIRECTORY
+                                     "${BUILD_OUTPUT_ROOT_DIRECTORY}"
+                                     PDB_OUTPUT_DIRECTORY
+                                     "${BUILD_OUTPUT_ROOT_DIRECTORY}")
+  endforeach()
   install(DIRECTORY "${googletest_SOURCE_DIR}/googlemock/include/"
                     "${googletest_SOURCE_DIR}/googletest/include/"
           DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")

From 34eb21df5aa5799bf5ecca42a0542ae0124a439e Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 10 Oct 2023 05:26:56 +0900
Subject: [PATCH 497/749] GH-38063: [C++] Use absolute path for external
 project's ar/ranlib (#38064)

### Rationale for this change

If we use relative path, CMake try using relative path from a build directory.

### What changes are included in this PR?

Ensure using absolute path.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38063

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index d194c455eaaaa..7e98db8b154d2 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -921,11 +921,18 @@ set(EP_COMMON_TOOLCHAIN "-DCMAKE_C_COMPILER=${EP_C_COMPILER}"
                         "-DCMAKE_CXX_COMPILER=${EP_CXX_COMPILER}")
 
 if(CMAKE_AR)
-  list(APPEND EP_COMMON_TOOLCHAIN -DCMAKE_AR=${CMAKE_AR})
+  # Ensure using absolute path.
+  find_program(EP_CMAKE_AR ${CMAKE_AR} REQUIRED)
+  list(APPEND EP_COMMON_TOOLCHAIN -DCMAKE_AR=${EP_CMAKE_AR})
 endif()
 
-if(CMAKE_RANLIB)
-  list(APPEND EP_COMMON_TOOLCHAIN -DCMAKE_RANLIB=${CMAKE_RANLIB})
+# RANLIB isn't used for MSVC
+if(NOT MSVC)
+  if(CMAKE_RANLIB)
+    # Ensure using absolute path.
+    find_program(EP_CMAKE_RANLIB ${CMAKE_RANLIB} REQUIRED)
+    list(APPEND EP_COMMON_TOOLCHAIN -DCMAKE_RANLIB=${EP_CMAKE_RANLIB})
+  endif()
 endif()
 
 # External projects are still able to override the following declarations.

From fae16c850a206d97ff23df73ba54bb8991fb35bc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 10 Oct 2023 05:47:12 +0900
Subject: [PATCH 498/749] MINOR: [C#] Bump BenchmarkDotNet from 0.13.8 to
 0.13.9 in /csharp (#38161)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet) from 0.13.8 to 0.13.9.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet's releases</a>.</em></p>
<blockquote>
<h2>0.13.9</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.9.html">https://benchmarkdotnet.org/changelog/v0.13.9.html</a></p>
<p>In the <a href="https://github.com/dotnet/BenchmarkDotNet/issues?q=milestone:v0.13.9">v0.13.9</a> scope, 3 issues were resolved and 7 pull requests were merged. This release includes 26 commits by 5 contributors.</p>
<h2>Resolved issues (3)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2054">#2054</a> Custom logging/visualization during the benchmark run (assignee: <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2404">#2404</a> Using <code>DisassemblyDiagnoser</code> in GitHub Actions (assignee: <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a> Something went wrong with outliers when using <code>--launchCount</code> (assignee: <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>
<h2>Merged pull requests (7)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/1882">#1882</a> use coalesce instead of join (by <a href="https://github.com/askazakov"><code>@​askazakov</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2413">#2413</a> Fix linux crash from disassembler (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2420">#2420</a> Add event processor functionality (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2421">#2421</a> More nullability warnings fixes (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2433">#2433</a> Fix build errors with latest sdk (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2434">#2434</a> Fix Event Processors not being copied in ManualConfig.Add (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2435">#2435</a> Treat warnings not as errors in manual test project (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
</ul>
<h2>Commits (26)</h2>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ece5ccfc91d92b610338b05da73d2a91508e2837">ece5cc</a> Set next BenchmarkDotNet version: 0.13.9 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ad937654174e521741aac620e16635a8ff14b1c9">ad9376</a> Add event processor functionality (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2420">#2420</a>) (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8227bbfa5f4d22c51f9c3856576d3680d8fc0a92">8227bb</a> Address PR feedback (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2434">#2434</a>) (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/46b3c0171709c48f58966fdf2665b5f292ff6467">46b3c0</a> Fix linux crash from disassembler (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2413">#2413</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/967a975773ebd7a9744f3875220c7db8fa647957">967a97</a> Fix build errors with latest sdk. (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2433">#2433</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/dd7a9b7cd132e522951eeb6916a3aa27a24ebf59">dd7a9b</a> Treat warnings not as errors in manual test project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2435">#2435</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/58387457bd67c62fda9c831329401fe0de4ae86f">583874</a> Print full stacktrace for GenerateException, see <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/6e3a159d3d3ae0d7eecc759c23a7bb0124e673df">6e3a15</a> Support WSL detection in RuntimeInformation (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8986e053c2fbc0befdef7d6e1a116a7bc83da282">8986e0</a> Update myget url in README (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/516bd68238c38bb6f622f71039d7b91f3f33776d">516bd6</a> Enabled nullability for BenchmarkDotNet.Diagnostics.dotTrace.csproj (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/5428ebdb8b6e9a847bb8ae6cf129b7dd9d784454">5428eb</a> Fixed nullability warnings in methods signatures (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7fbbc9f506cee0048f2ea6e7af15fbe1aa0bd7f7">7fbbc9</a> Removed CanBeNull attribute (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9d7350c21b30c2655705ede68929243846b8a407">9d7350</a> Fixed warnings on null assignments (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/b43d280f1673526dff865f5fbfc1848c846eacdd">b43d28</a> Fixed warnings in EngineEventLogParser (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/148165baf92233a3e3e67efc552e7528edb2fc78">148165</a> Removed an unnecessary check (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/465aaf196a43d21b516edf6e9028c672c39937b9">465aaf</a> Fixed empty catch warning (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9a7bb7d5d6c72a01f991d869b9106364c26b1fce">9a7bb7</a> [build] Bump: Microsoft.DocAsCode.App 2.67.5 -&gt; Docfx.App 2.71.0 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9dd7b6f4b2511bbd30ba0f6d4999f7f58cf161a6">9dd7b6</a> Fix license badge link in README (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/134b8edd09ad7dad0a17728eae4e9f50e16d3fe0">134b8e</a> [build] Automatic NextVersion evaluation (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8090d995e847c3c3d84db1fd5acbee312a75cf81">8090d9</a> Suppress NETSDK1138 (TFM out of support warning) (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af610eec251bfa74f7317eaec915df9b905c979b">af610e</a> Bump .NET SDK: 7.0.305-&gt;7.0.401 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8838ed4bf74377642d32774c558c0955e67c0faf">8838ed</a> [build] Fix docfx build warnings (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d379b37310983dbe645a2129066d9af65d9e0d7">2d379b</a> Remove outlier consistency check, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/00628ab31b79a78e1c22c298ca0086bdf28065a7">00628a</a> use coalesce instead of join (by <a href="https://github.com/askazakov"><code>@​askazakov</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/411a6e7594c45c9ffa55b0b6caecb7f6ed1b3081">411a6e</a> Prepare v0.13.9 changelog (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/228a464e8be6c580ad9408e98f18813f6407fb5a">228a46</a> Rollback docfx.json (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/228a464e8be6c580ad9408e98f18813f6407fb5a"><code>228a464</code></a> Rollback docfx.json</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/411a6e7594c45c9ffa55b0b6caecb7f6ed1b3081"><code>411a6e7</code></a> Prepare v0.13.9 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/00628ab31b79a78e1c22c298ca0086bdf28065a7"><code>00628ab</code></a> use coalesce instead of join</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d379b37310983dbe645a2129066d9af65d9e0d7"><code>2d379b3</code></a> Remove outlier consistency check, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a></li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8838ed4bf74377642d32774c558c0955e67c0faf"><code>8838ed4</code></a> [build] Fix docfx build warnings</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af610eec251bfa74f7317eaec915df9b905c979b"><code>af610ee</code></a> Bump .NET SDK: 7.0.305-&gt;7.0.401</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8090d995e847c3c3d84db1fd5acbee312a75cf81"><code>8090d99</code></a> Suppress NETSDK1138 (TFM out of support warning)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/134b8edd09ad7dad0a17728eae4e9f50e16d3fe0"><code>134b8ed</code></a> [build] Automatic NextVersion evaluation</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9dd7b6f4b2511bbd30ba0f6d4999f7f58cf161a6"><code>9dd7b6f</code></a> Fix license badge link in README</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9a7bb7d5d6c72a01f991d869b9106364c26b1fce"><code>9a7bb7d</code></a> [build] Bump: Microsoft.DocAsCode.App 2.67.5 -&gt; Docfx.App 2.71.0</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.8...v0.13.9">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet&package-manager=nuget&previous-version=0.13.8&new-version=0.13.9)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index 35f17270e0b04..b5f56464f71cf 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.8" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
     <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.8" />
   </ItemGroup>
 

From 33ef508029b0718b507e49672abfc99068431675 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 10 Oct 2023 08:47:36 +0900
Subject: [PATCH 499/749] MINOR: [C#] Bump BenchmarkDotNet.Diagnostics.Windows
 from 0.13.8 to 0.13.9 in /csharp (#38160)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet.Diagnostics.Windows](https://github.com/dotnet/BenchmarkDotNet) from 0.13.8 to 0.13.9.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet.Diagnostics.Windows's releases</a>.</em></p>
<blockquote>
<h2>0.13.9</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.9.html">https://benchmarkdotnet.org/changelog/v0.13.9.html</a></p>
<p>In the <a href="https://github.com/dotnet/BenchmarkDotNet/issues?q=milestone:v0.13.9">v0.13.9</a> scope, 3 issues were resolved and 7 pull requests were merged. This release includes 26 commits by 5 contributors.</p>
<h2>Resolved issues (3)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2054">#2054</a> Custom logging/visualization during the benchmark run (assignee: <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2404">#2404</a> Using <code>DisassemblyDiagnoser</code> in GitHub Actions (assignee: <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a> Something went wrong with outliers when using <code>--launchCount</code> (assignee: <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>
<h2>Merged pull requests (7)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/1882">#1882</a> use coalesce instead of join (by <a href="https://github.com/askazakov"><code>@​askazakov</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2413">#2413</a> Fix linux crash from disassembler (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2420">#2420</a> Add event processor functionality (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2421">#2421</a> More nullability warnings fixes (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2433">#2433</a> Fix build errors with latest sdk (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2434">#2434</a> Fix Event Processors not being copied in ManualConfig.Add (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2435">#2435</a> Treat warnings not as errors in manual test project (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
</ul>
<h2>Commits (26)</h2>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ece5ccfc91d92b610338b05da73d2a91508e2837">ece5cc</a> Set next BenchmarkDotNet version: 0.13.9 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ad937654174e521741aac620e16635a8ff14b1c9">ad9376</a> Add event processor functionality (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2420">#2420</a>) (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8227bbfa5f4d22c51f9c3856576d3680d8fc0a92">8227bb</a> Address PR feedback (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2434">#2434</a>) (by <a href="https://github.com/caaavik-msft"><code>@​caaavik-msft</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/46b3c0171709c48f58966fdf2665b5f292ff6467">46b3c0</a> Fix linux crash from disassembler (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2413">#2413</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/967a975773ebd7a9744f3875220c7db8fa647957">967a97</a> Fix build errors with latest sdk. (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2433">#2433</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/dd7a9b7cd132e522951eeb6916a3aa27a24ebf59">dd7a9b</a> Treat warnings not as errors in manual test project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2435">#2435</a>) (by <a href="https://github.com/timcassell"><code>@​timcassell</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/58387457bd67c62fda9c831329401fe0de4ae86f">583874</a> Print full stacktrace for GenerateException, see <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/6e3a159d3d3ae0d7eecc759c23a7bb0124e673df">6e3a15</a> Support WSL detection in RuntimeInformation (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8986e053c2fbc0befdef7d6e1a116a7bc83da282">8986e0</a> Update myget url in README (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/516bd68238c38bb6f622f71039d7b91f3f33776d">516bd6</a> Enabled nullability for BenchmarkDotNet.Diagnostics.dotTrace.csproj (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/5428ebdb8b6e9a847bb8ae6cf129b7dd9d784454">5428eb</a> Fixed nullability warnings in methods signatures (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7fbbc9f506cee0048f2ea6e7af15fbe1aa0bd7f7">7fbbc9</a> Removed CanBeNull attribute (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9d7350c21b30c2655705ede68929243846b8a407">9d7350</a> Fixed warnings on null assignments (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/b43d280f1673526dff865f5fbfc1848c846eacdd">b43d28</a> Fixed warnings in EngineEventLogParser (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/148165baf92233a3e3e67efc552e7528edb2fc78">148165</a> Removed an unnecessary check (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/465aaf196a43d21b516edf6e9028c672c39937b9">465aaf</a> Fixed empty catch warning (by <a href="https://github.com/alinasmirnova"><code>@​alinasmirnova</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9a7bb7d5d6c72a01f991d869b9106364c26b1fce">9a7bb7</a> [build] Bump: Microsoft.DocAsCode.App 2.67.5 -&gt; Docfx.App 2.71.0 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9dd7b6f4b2511bbd30ba0f6d4999f7f58cf161a6">9dd7b6</a> Fix license badge link in README (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/134b8edd09ad7dad0a17728eae4e9f50e16d3fe0">134b8e</a> [build] Automatic NextVersion evaluation (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8090d995e847c3c3d84db1fd5acbee312a75cf81">8090d9</a> Suppress NETSDK1138 (TFM out of support warning) (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af610eec251bfa74f7317eaec915df9b905c979b">af610e</a> Bump .NET SDK: 7.0.305-&gt;7.0.401 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8838ed4bf74377642d32774c558c0955e67c0faf">8838ed</a> [build] Fix docfx build warnings (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d379b37310983dbe645a2129066d9af65d9e0d7">2d379b</a> Remove outlier consistency check, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/00628ab31b79a78e1c22c298ca0086bdf28065a7">00628a</a> use coalesce instead of join (by <a href="https://github.com/askazakov"><code>@​askazakov</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/411a6e7594c45c9ffa55b0b6caecb7f6ed1b3081">411a6e</a> Prepare v0.13.9 changelog (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/228a464e8be6c580ad9408e98f18813f6407fb5a">228a46</a> Rollback docfx.json (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/228a464e8be6c580ad9408e98f18813f6407fb5a"><code>228a464</code></a> Rollback docfx.json</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/411a6e7594c45c9ffa55b0b6caecb7f6ed1b3081"><code>411a6e7</code></a> Prepare v0.13.9 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/00628ab31b79a78e1c22c298ca0086bdf28065a7"><code>00628ab</code></a> use coalesce instead of join</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2d379b37310983dbe645a2129066d9af65d9e0d7"><code>2d379b3</code></a> Remove outlier consistency check, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2432">#2432</a></li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8838ed4bf74377642d32774c558c0955e67c0faf"><code>8838ed4</code></a> [build] Fix docfx build warnings</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af610eec251bfa74f7317eaec915df9b905c979b"><code>af610ee</code></a> Bump .NET SDK: 7.0.305-&gt;7.0.401</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/8090d995e847c3c3d84db1fd5acbee312a75cf81"><code>8090d99</code></a> Suppress NETSDK1138 (TFM out of support warning)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/134b8edd09ad7dad0a17728eae4e9f50e16d3fe0"><code>134b8ed</code></a> [build] Automatic NextVersion evaluation</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9dd7b6f4b2511bbd30ba0f6d4999f7f58cf161a6"><code>9dd7b6f</code></a> Fix license badge link in README</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/9a7bb7d5d6c72a01f991d869b9106364c26b1fce"><code>9a7bb7d</code></a> [build] Bump: Microsoft.DocAsCode.App 2.67.5 -&gt; Docfx.App 2.71.0</li>
<li>Additional commits viewable in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.8...v0.13.9">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet.Diagnostics.Windows&package-manager=nuget&previous-version=0.13.8&new-version=0.13.9)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index b5f56464f71cf..5c2c1823fec99 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.8" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.9" />
   </ItemGroup>
 
   <ItemGroup>

From 9f18a255ee26d725b66ae96df7d9fb426904d94e Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Mon, 9 Oct 2023 20:16:17 -0400
Subject: [PATCH 500/749] GH-38059: [Python][CI] Upgrade CUDA to 11.2.2
 (#38081)

### Rationale for this change

Numba v0.58 requires cuda-toolkit >= v11.2

### What changes are included in this PR?

* Upgrade CUDA from 11.0.3 -> 11.2.2

### Are these changes tested?

Will test in CI

### Are there any user-facing changes?

Yes
* Closes: #38059

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .env | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.env b/.env
index 014bad3fe2a7a..a551e2120a6fb 100644
--- a/.env
+++ b/.env
@@ -54,7 +54,7 @@ UBUNTU=20.04
 
 # Default versions for various dependencies
 CLANG_TOOLS=14
-CUDA=11.0.3
+CUDA=11.2.2
 DASK=latest
 DOTNET=7.0
 GCC_VERSION=""

From ae5b30e74b1f02166591feb6f99c85e3c6d5fd87 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 10 Oct 2023 11:24:40 +0900
Subject: [PATCH 501/749] GH-38055: [C++] Don't find/use Threads::Threads with
 ARROW_ENABLE_THREADING=OFF (#38056)

### Rationale for this change

We don't need `Threads::Threads` with `ARROW_ENABLE_THREADING=OFF`.

### What changes are included in this PR?

* Don't run `find_package(Threads)` with `ARROW_ENABLE_THREADING=OFF`
* Report an error for building jemalloc/mimalloc/gRPC/aws-sdk-cpp/google-cloud-cpp/OpenTelemetry with `ARROW_ENABLE_THREADING=OFF`
* Use `target_link_libraries(INTERFACE)` instead of `set_target_properties(INTERFACE_LINK_LIBRARIES)`
  * This is not required. It's just for modernizing CMake codes.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38055

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/cpp_build.sh                     |  10 +
 cpp/CMakeLists.txt                          |   4 +-
 cpp/cmake_modules/DefineOptions.cmake       |   6 +-
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 194 ++++++++++----------
 cpp/src/arrow/ArrowConfig.cmake.in          |   8 +-
 5 files changed, 123 insertions(+), 99 deletions(-)

diff --git a/ci/scripts/cpp_build.sh b/ci/scripts/cpp_build.sh
index 1f5596e2a50e1..69d86e871ac5f 100755
--- a/ci/scripts/cpp_build.sh
+++ b/ci/scripts/cpp_build.sh
@@ -53,6 +53,16 @@ if [ "${GITHUB_ACTIONS:-false}" = "true" ]; then
   esac
 fi
 
+if [ "${ARROW_ENABLE_THREADING:-ON}" = "OFF" ]; then
+  ARROW_FLIGHT=OFF
+  ARROW_FLIGHT_SQL=OFF
+  ARROW_GCS=OFF
+  ARROW_JEMALLOC=OFF
+  ARROW_MIMALLOC=OFF
+  ARROW_S3=OFF
+  ARROW_WITH_OPENTELEMETRY=OFF
+fi
+
 if [ "${ARROW_USE_CCACHE}" == "ON" ]; then
     echo -e "===\n=== ccache statistics before build\n==="
     ccache -sv 2>/dev/null || ccache -s
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index f0acab0389b19..8566508406bd4 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -961,7 +961,9 @@ endif()
 
 set(ARROW_SYSTEM_LINK_LIBS)
 
-list(APPEND ARROW_SYSTEM_LINK_LIBS Threads::Threads)
+if(ARROW_ENABLE_THREADING)
+  list(APPEND ARROW_SYSTEM_LINK_LIBS Threads::Threads)
+endif()
 if(CMAKE_THREAD_LIBS_INIT)
   string(APPEND ARROW_PC_LIBS_PRIVATE " ${CMAKE_THREAD_LIBS_INIT}")
 endif()
diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index 6e6a74c9c78f8..38d33a611ec70 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -340,12 +340,16 @@ takes precedence over ccache if a storage backend is configured" ON)
   define_option(ARROW_IPC "Build the Arrow IPC extensions" ON)
 
   set(ARROW_JEMALLOC_DESCRIPTION "Build the Arrow jemalloc-based allocator")
-  if(WIN32 OR "${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD")
+  if(WIN32
+     OR "${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD"
+     OR NOT ARROW_ENABLE_THREADING)
     # jemalloc is not supported on Windows.
     #
     # jemalloc is the default malloc implementation on FreeBSD and can't
     # be built with --disable-libdl on FreeBSD. Because lazy-lock feature
     # is required on FreeBSD. Lazy-lock feature requires libdl.
+    #
+    # jemalloc requires thread.
     define_option(ARROW_JEMALLOC ${ARROW_JEMALLOC_DESCRIPTION} OFF)
   else()
     define_option(ARROW_JEMALLOC ${ARROW_JEMALLOC_DESCRIPTION} ON)
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 7e98db8b154d2..a6b5db382421a 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -1023,8 +1023,10 @@ endmacro()
 # ----------------------------------------------------------------------
 # Find pthreads
 
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads REQUIRED)
+if(ARROW_ENABLE_THREADING)
+  set(THREADS_PREFER_PTHREAD_FLAG ON)
+  find_package(Threads REQUIRED)
+endif()
 
 # ----------------------------------------------------------------------
 # Add Boost dependencies (code adapted from Apache Kudu)
@@ -2045,9 +2047,9 @@ macro(build_jemalloc)
   # The include directory must exist before it is referenced by a target.
   file(MAKE_DIRECTORY "${JEMALLOC_INCLUDE_DIR}")
   add_library(jemalloc::jemalloc STATIC IMPORTED)
-  set_target_properties(jemalloc::jemalloc
-                        PROPERTIES INTERFACE_LINK_LIBRARIES Threads::Threads
-                                   IMPORTED_LOCATION "${JEMALLOC_STATIC_LIB}")
+  set_target_properties(jemalloc::jemalloc PROPERTIES IMPORTED_LOCATION
+                                                      "${JEMALLOC_STATIC_LIB}")
+  target_link_libraries(jemalloc::jemalloc INTERFACE Threads::Threads)
   target_include_directories(jemalloc::jemalloc BEFORE
                              INTERFACE "${JEMALLOC_INCLUDE_DIR}")
   add_dependencies(jemalloc::jemalloc jemalloc_ep)
@@ -2060,6 +2062,9 @@ macro(build_jemalloc)
 endmacro()
 
 if(ARROW_JEMALLOC)
+  if(NOT ARROW_ENABLE_THREADING)
+    message(FATAL_ERROR "Can't use jemalloc with ARROW_ENABLE_THREADING=OFF")
+  endif()
   resolve_dependency(jemalloc HAVE_ALT TRUE)
 endif()
 
@@ -2067,6 +2072,10 @@ endif()
 # mimalloc - Cross-platform high-performance allocator, from Microsoft
 
 if(ARROW_MIMALLOC)
+  if(NOT ARROW_ENABLE_THREADING)
+    message(FATAL_ERROR "Can't use mimalloc with ARROW_ENABLE_THREADING=OFF")
+  endif()
+
   message(STATUS "Building (vendored) mimalloc from source")
   # We only use a vendored mimalloc as we want to control its build options.
 
@@ -2103,15 +2112,13 @@ if(ARROW_MIMALLOC)
   file(MAKE_DIRECTORY ${MIMALLOC_INCLUDE_DIR})
 
   add_library(mimalloc::mimalloc STATIC IMPORTED)
-  set_target_properties(mimalloc::mimalloc
-                        PROPERTIES INTERFACE_LINK_LIBRARIES Threads::Threads
-                                   IMPORTED_LOCATION "${MIMALLOC_STATIC_LIB}")
+  set_target_properties(mimalloc::mimalloc PROPERTIES IMPORTED_LOCATION
+                                                      "${MIMALLOC_STATIC_LIB}")
   target_include_directories(mimalloc::mimalloc BEFORE
                              INTERFACE "${MIMALLOC_INCLUDE_DIR}")
+  target_link_libraries(mimalloc::mimalloc INTERFACE Threads::Threads)
   if(WIN32)
-    set_property(TARGET mimalloc::mimalloc
-                 APPEND
-                 PROPERTY INTERFACE_LINK_LIBRARIES "bcrypt.lib" "psapi.lib")
+    target_link_libraries(mimalloc::mimalloc INTERFACE "bcrypt.lib" "psapi.lib")
   endif()
   add_dependencies(mimalloc::mimalloc mimalloc_ep)
   add_dependencies(toolchain mimalloc_ep)
@@ -3918,9 +3925,9 @@ macro(build_grpc)
       absl::log_severity)
 
   add_library(gRPC::gpr STATIC IMPORTED)
-  set_target_properties(gRPC::gpr
-                        PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GPR}"
-                                   INTERFACE_LINK_LIBRARIES "${GRPC_GPR_ABSL_LIBRARIES}")
+  set_target_properties(gRPC::gpr PROPERTIES IMPORTED_LOCATION
+                                             "${GRPC_STATIC_LIBRARY_GPR}")
+  target_link_libraries(gRPC::gpr INTERFACE ${GRPC_GPR_ABSL_LIBRARIES})
   target_include_directories(gRPC::gpr BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::address_sorting STATIC IMPORTED)
@@ -3937,25 +3944,23 @@ macro(build_grpc)
                              INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::grpc STATIC IMPORTED)
-  set(GRPC_LINK_LIBRARIES
-      gRPC::gpr
-      gRPC::upb
-      gRPC::address_sorting
-      re2::re2
-      c-ares::cares
-      ZLIB::ZLIB
-      OpenSSL::SSL
-      Threads::Threads)
-  set_target_properties(gRPC::grpc
-                        PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GRPC}"
-                                   INTERFACE_LINK_LIBRARIES "${GRPC_LINK_LIBRARIES}")
+  set_target_properties(gRPC::grpc PROPERTIES IMPORTED_LOCATION
+                                              "${GRPC_STATIC_LIBRARY_GRPC}")
+  target_link_libraries(gRPC::grpc
+                        INTERFACE gRPC::gpr
+                                  gRPC::upb
+                                  gRPC::address_sorting
+                                  re2::re2
+                                  c-ares::cares
+                                  ZLIB::ZLIB
+                                  OpenSSL::SSL
+                                  Threads::Threads)
   target_include_directories(gRPC::grpc BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_library(gRPC::grpc++ STATIC IMPORTED)
-  set(GRPCPP_LINK_LIBRARIES gRPC::grpc ${ARROW_PROTOBUF_LIBPROTOBUF})
-  set_target_properties(gRPC::grpc++
-                        PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIBRARY_GRPCPP}"
-                                   INTERFACE_LINK_LIBRARIES "${GRPCPP_LINK_LIBRARIES}")
+  set_target_properties(gRPC::grpc++ PROPERTIES IMPORTED_LOCATION
+                                                "${GRPC_STATIC_LIBRARY_GRPCPP}")
+  target_link_libraries(gRPC::grpc++ INTERFACE gRPC::grpc ${ARROW_PROTOBUF_LIBPROTOBUF})
   target_include_directories(gRPC::grpc++ BEFORE INTERFACE "${GRPC_INCLUDE_DIR}")
 
   add_executable(gRPC::grpc_cpp_plugin IMPORTED)
@@ -4002,6 +4007,10 @@ macro(build_grpc)
 endmacro()
 
 if(ARROW_WITH_GRPC)
+  if(NOT ARROW_ENABLE_THREADING)
+    message(FATAL_ERROR "Can't use gRPC with ARROW_ENABLE_THREADING=OFF")
+  endif()
+
   set(ARROW_GRPC_REQUIRED_VERSION "1.30.0")
   if(NOT Protobuf_SOURCE STREQUAL gRPC_SOURCE)
     # ARROW-15495: Protobuf/gRPC must come from the same source
@@ -4220,17 +4229,16 @@ macro(build_google_cloud_cpp_storage)
   # (subsitute `main` for the SHA of the version we use)
   # Version 1.39.0 is at a different place (they refactored after):
   # https://github.com/googleapis/google-cloud-cpp/blob/29e5af8ca9b26cec62106d189b50549f4dc1c598/google/cloud/CMakeLists.txt#L146-L155
-  set_property(TARGET google-cloud-cpp::common
-               PROPERTY INTERFACE_LINK_LIBRARIES
-                        absl::base
-                        absl::cord
-                        absl::memory
-                        absl::optional
-                        absl::span
-                        absl::time
-                        absl::variant
-                        Threads::Threads
-                        OpenSSL::Crypto)
+  target_link_libraries(google-cloud-cpp::common
+                        INTERFACE absl::base
+                                  absl::cord
+                                  absl::memory
+                                  absl::optional
+                                  absl::span
+                                  absl::time
+                                  absl::variant
+                                  Threads::Threads
+                                  OpenSSL::Crypto)
 
   add_library(google-cloud-cpp::rest-internal STATIC IMPORTED)
   set_target_properties(google-cloud-cpp::rest-internal
@@ -4238,14 +4246,13 @@ macro(build_google_cloud_cpp_storage)
                                    "${GOOGLE_CLOUD_CPP_STATIC_LIBRARY_REST_INTERNAL}")
   target_include_directories(google-cloud-cpp::rest-internal BEFORE
                              INTERFACE "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
-  set_property(TARGET google-cloud-cpp::rest-internal
-               PROPERTY INTERFACE_LINK_LIBRARIES
-                        absl::span
-                        google-cloud-cpp::common
-                        CURL::libcurl
-                        nlohmann_json::nlohmann_json
-                        OpenSSL::SSL
-                        OpenSSL::Crypto)
+  target_link_libraries(google-cloud-cpp::rest-internal
+                        INTERFACE absl::span
+                                  google-cloud-cpp::common
+                                  CURL::libcurl
+                                  nlohmann_json::nlohmann_json
+                                  OpenSSL::SSL
+                                  OpenSSL::Crypto)
 
   add_library(google-cloud-cpp::storage STATIC IMPORTED)
   set_target_properties(google-cloud-cpp::storage
@@ -4254,22 +4261,21 @@ macro(build_google_cloud_cpp_storage)
   target_include_directories(google-cloud-cpp::storage BEFORE
                              INTERFACE "${GOOGLE_CLOUD_CPP_INCLUDE_DIR}")
   # Update this from https://github.com/googleapis/google-cloud-cpp/blob/main/google/cloud/storage/google_cloud_cpp_storage.cmake
-  set_property(TARGET google-cloud-cpp::storage
-               PROPERTY INTERFACE_LINK_LIBRARIES
-                        google-cloud-cpp::common
-                        google-cloud-cpp::rest-internal
-                        absl::memory
-                        absl::strings
-                        absl::str_format
-                        absl::time
-                        absl::variant
-                        nlohmann_json::nlohmann_json
-                        Crc32c::crc32c
-                        CURL::libcurl
-                        Threads::Threads
-                        OpenSSL::SSL
-                        OpenSSL::Crypto
-                        ZLIB::ZLIB)
+  target_link_libraries(google-cloud-cpp::storage
+                        INTERFACE google-cloud-cpp::common
+                                  google-cloud-cpp::rest-internal
+                                  absl::memory
+                                  absl::strings
+                                  absl::str_format
+                                  absl::time
+                                  absl::variant
+                                  nlohmann_json::nlohmann_json
+                                  Crc32c::crc32c
+                                  CURL::libcurl
+                                  Threads::Threads
+                                  OpenSSL::SSL
+                                  OpenSSL::Crypto
+                                  ZLIB::ZLIB)
   add_dependencies(google-cloud-cpp::storage google_cloud_cpp_ep)
 
   list(APPEND
@@ -4316,6 +4322,11 @@ macro(build_google_cloud_cpp_storage)
 endmacro()
 
 if(ARROW_WITH_GOOGLE_CLOUD_CPP)
+  if(NOT ARROW_ENABLE_THREADING)
+    message(FATAL_ERROR "Can't use Google Cloud Platform C++ Client Libraries with ARROW_ENABLE_THREADING=OFF"
+    )
+  endif()
+
   resolve_dependency(google_cloud_cpp_storage PC_PACKAGE_NAMES google_cloud_cpp_storage)
   get_target_property(google_cloud_cpp_storage_INCLUDE_DIR google-cloud-cpp::storage
                       INTERFACE_INCLUDE_DIRECTORIES)
@@ -4422,7 +4433,7 @@ macro(build_orc)
     list(APPEND ORC_LINK_LIBRARIES absl::log_internal_check_op)
   endif()
   if(NOT MSVC)
-    if(NOT APPLE)
+    if(NOT APPLE AND ARROW_ENABLE_THREADING)
       list(APPEND ORC_LINK_LIBRARIES Threads::Threads)
     endif()
     list(APPEND ORC_LINK_LIBRARIES ${CMAKE_DL_LIBS})
@@ -4601,34 +4612,25 @@ macro(build_opentelemetry)
 
   set(OPENTELEMETRY_VENDORED 1)
 
-  set_target_properties(opentelemetry-cpp::common
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::api;opentelemetry-cpp::sdk;Threads::Threads"
-  )
-  set_target_properties(opentelemetry-cpp::resources
-                        PROPERTIES INTERFACE_LINK_LIBRARIES "opentelemetry-cpp::common")
-  set_target_properties(opentelemetry-cpp::trace
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::common;opentelemetry-cpp::resources"
-  )
-  set_target_properties(opentelemetry-cpp::http_client_curl
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::ext;CURL::libcurl")
-  set_target_properties(opentelemetry-cpp::proto
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "${ARROW_PROTOBUF_LIBPROTOBUF}")
-  set_target_properties(opentelemetry-cpp::otlp_recordable
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::trace;opentelemetry-cpp::resources;opentelemetry-cpp::proto"
-  )
-  set_target_properties(opentelemetry-cpp::otlp_http_client
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::sdk;opentelemetry-cpp::proto;opentelemetry-cpp::http_client_curl;nlohmann_json::nlohmann_json"
-  )
-  set_target_properties(opentelemetry-cpp::otlp_http_exporter
-                        PROPERTIES INTERFACE_LINK_LIBRARIES
-                                   "opentelemetry-cpp::otlp_recordable;opentelemetry-cpp::otlp_http_client"
-  )
+  target_link_libraries(opentelemetry-cpp::common
+                        INTERFACE opentelemetry-cpp::api opentelemetry-cpp::sdk
+                                  Threads::Threads)
+  target_link_libraries(opentelemetry-cpp::resources INTERFACE opentelemetry-cpp::common)
+  target_link_libraries(opentelemetry-cpp::trace INTERFACE opentelemetry-cpp::common
+                                                           opentelemetry-cpp::resources)
+  target_link_libraries(opentelemetry-cpp::http_client_curl
+                        INTERFACE opentelemetry-cpp::ext CURL::libcurl)
+  target_link_libraries(opentelemetry-cpp::proto INTERFACE ${ARROW_PROTOBUF_LIBPROTOBUF})
+  target_link_libraries(opentelemetry-cpp::otlp_recordable
+                        INTERFACE opentelemetry-cpp::trace opentelemetry-cpp::resources
+                                  opentelemetry-cpp::proto)
+  target_link_libraries(opentelemetry-cpp::otlp_http_client
+                        INTERFACE opentelemetry-cpp::sdk opentelemetry-cpp::proto
+                                  opentelemetry-cpp::http_client_curl
+                                  nlohmann_json::nlohmann_json)
+  target_link_libraries(opentelemetry-cpp::otlp_http_exporter
+                        INTERFACE opentelemetry-cpp::otlp_recordable
+                                  opentelemetry-cpp::otlp_http_client)
 
   foreach(_OPENTELEMETRY_LIB ${_OPENTELEMETRY_LIBS})
     add_dependencies(opentelemetry-cpp::${_OPENTELEMETRY_LIB} opentelemetry_ep)
@@ -4640,6 +4642,10 @@ macro(build_opentelemetry)
 endmacro()
 
 if(ARROW_WITH_OPENTELEMETRY)
+  if(NOT ARROW_ENABLE_THREADING)
+    message(FATAL_ERROR "Can't use OpenTelemetry with ARROW_ENABLE_THREADING=OFF")
+  endif()
+
   # cURL is required whether we build from source or use an existing installation
   # (OTel's cmake files do not call find_curl for you)
   find_curl()
diff --git a/cpp/src/arrow/ArrowConfig.cmake.in b/cpp/src/arrow/ArrowConfig.cmake.in
index 7bd19fb41a31f..27910b3f3c311 100644
--- a/cpp/src/arrow/ArrowConfig.cmake.in
+++ b/cpp/src/arrow/ArrowConfig.cmake.in
@@ -89,9 +89,11 @@ endmacro()
 if(ARROW_BUILD_STATIC)
   include(CMakeFindDependencyMacro)
 
-  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
-  find_dependency(Threads)
+  if(ARROW_ENABLE_THREADING)
+    set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+    set(THREADS_PREFER_PTHREAD_FLAG TRUE)
+    find_dependency(Threads)
+  endif()
 
   arrow_find_dependencies("${ARROW_SYSTEM_DEPENDENCIES}")
 endif()

From 4f06beb737c3d1401e011e0a2ef33b159ab25995 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Mon, 9 Oct 2023 23:26:10 -0300
Subject: [PATCH 502/749] MINOR: [R] Fix lint error (#38170)

### Rationale for this change

The CI job is failing on Windows after #38002. This was masked in review because the Windows job was failing for another reason (which is also now fixed).

### What changes are included in this PR?

The error is fixed.

### Are these changes tested?

Covered by existing tests

### Are there any user-facing changes?

No

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 r/R/csv.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index 89df75a4b0aeb..ef35c7d6d5661 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -304,7 +304,7 @@ read_csv2_arrow <- function(file,
                             timestamp_parsers = NULL) {
   mc <- match.call()
   mc$delim <- ";"
-  mc$decimal_point = ","
+  mc$decimal_point <- ","
   mc[[1]] <- get("read_delim_arrow", envir = asNamespace("arrow"))
   eval.parent(mc)
 }

From db420c9cb6d0d93ce13aec06c59a9ae2d4c775f6 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Tue, 10 Oct 2023 06:05:24 +0200
Subject: [PATCH 503/749] GH-38034: [Python] DataFrame Interchange Protocol -
 correct dtype information for categorical columns (#38065)

### Rationale for this change
See: https://github.com/apache/arrow/issues/38034#issue-1927839216

### What changes are included in this PR?

The `f_string` for the columns with categorical dtype is now corrected to reflect the type of the indices from the dictionary data type. Bit width has been correct before. From the spec:

> For categoricals, the format string describes the type of the
              categorical in the data buffer. In case of a separate encoding of
              the categorical (e.g. an integer to string mapping), this can
              be derived from ``self.describe_categorical``.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38034

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 python/pyarrow/interchange/column.py          |  4 +++-
 .../interchange/test_interchange_spec.py      | 20 +++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/python/pyarrow/interchange/column.py b/python/pyarrow/interchange/column.py
index a9b89586165fa..eaf7834d5b563 100644
--- a/python/pyarrow/interchange/column.py
+++ b/python/pyarrow/interchange/column.py
@@ -312,7 +312,9 @@ def _dtype_from_arrowdtype(
             return kind, bit_width, f_string, Endianness.NATIVE
         elif pa.types.is_dictionary(dtype):
             kind = DtypeKind.CATEGORICAL
-            f_string = "L"
+            arr = self._col
+            indices_dtype = arr.indices.type
+            _, f_string = _PYARROW_KINDS.get(indices_dtype)
             return kind, bit_width, f_string, Endianness.NATIVE
         else:
             kind, f_string = _PYARROW_KINDS.get(dtype, (None, None))
diff --git a/python/pyarrow/tests/interchange/test_interchange_spec.py b/python/pyarrow/tests/interchange/test_interchange_spec.py
index 7b2b8eb7208de..826089652bca6 100644
--- a/python/pyarrow/tests/interchange/test_interchange_spec.py
+++ b/python/pyarrow/tests/interchange/test_interchange_spec.py
@@ -266,3 +266,23 @@ def test_buffer(int, use_batch):
         for idx, truth in enumerate(arr):
             val = ctype.from_address(dataBuf.ptr + idx * (bitwidth // 8)).value
             assert val == truth, f"Buffer at index {idx} mismatch"
+
+
+@pytest.mark.parametrize(
+    "indices_type, bitwidth, f_string", [
+        (pa.int8(), 8, "c"),
+        (pa.int16(), 16, "s"),
+        (pa.int32(), 32, "i"),
+        (pa.int64(), 64, "l")
+    ]
+)
+def test_categorical_dtype(indices_type, bitwidth, f_string):
+    type = pa.dictionary(indices_type, pa.string())
+    arr = pa.array(["a", "b", None, "d"], type)
+    table = pa.table({'a': arr})
+
+    df = table.__dataframe__()
+    col = df.get_column(0)
+    assert col.dtype[0] == 23  # <DtypeKind.CATEGORICAL: 23>
+    assert col.dtype[1] == bitwidth
+    assert col.dtype[2] == f_string

From 72bfe496448fcef1c9b8aaa42626784bf5143ccc Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 10 Oct 2023 13:55:25 +0900
Subject: [PATCH 504/749] GH-37735: [C++][FreeBSD] Suppress a shorten-64-to-32
 warning (#38004)

### Rationale for this change

It's caused by `backtrace()` and `backtrace_symbols_fd()` signatures are different on Linux and FreeBSD (`int` vs `size_t`).

Linux:

```c
extern int backtrace (void **__array, int __size) __nonnull ((1));
extern void backtrace_symbols_fd (void *const *__array, int __size, int __fd)
     __THROW __nonnull ((1));
```

FreeBSD:

```c
size_t backtrace(void **, size_t);
int backtrace_symbols_fd(void *const *, size_t, int);
```

### What changes are included in this PR?

Use `auto` to ignore the difference.

### Are these changes tested?

Yes on FreeBSD 12.

### Are there any user-facing changes?

No.
* Closes: #37735

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/logging.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/util/logging.cc b/cpp/src/arrow/util/logging.cc
index 04fcf3d3ed618..6d275fa2864a2 100644
--- a/cpp/src/arrow/util/logging.cc
+++ b/cpp/src/arrow/util/logging.cc
@@ -94,7 +94,8 @@ class CerrLog {
   void PrintBackTrace() {
 #ifdef ARROW_WITH_BACKTRACE
     void* buffer[255];
-    const int calls = backtrace(buffer, static_cast<int>(sizeof(buffer) / sizeof(void*)));
+    const auto calls =
+        backtrace(buffer, static_cast<int>(sizeof(buffer) / sizeof(void*)));
     backtrace_symbols_fd(buffer, calls, 1);
 #endif
   }

From 036de9183f3e883793f2c6b96dd38b0eff284c04 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 10 Oct 2023 16:15:16 +0900
Subject: [PATCH 505/749] MINOR: [C#] Bump Google.Protobuf from 3.24.3 to
 3.24.4 in /csharp (#38162)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.24.3 to 3.24.4.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/7789b3ac85248ad75631a1919071fa268e466210"><code>7789b3a</code></a> Updating version.json and repo version numbers to: 24.4</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/0006601261bdba91668fc454f782ffc8a3ca32e9"><code>0006601</code></a> Update upb dependency (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14277">#14277</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/b9cf19ba5ec4aa6ff108933fa4a1adb075f8c4fb"><code>b9cf19b</code></a> Automated rollback of commit 2a55706f9d36afd1742c97fd0d611ea8af0ac3f8. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14246">#14246</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/e4baf96abe5a2d854ba1102ce1911eba467ef65a"><code>e4baf96</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14240">#14240</a> from vthib/backport-cython-fix</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/fe87c909399c45d54374817a52af40d6cfd8e063"><code>fe87c90</code></a> fix python code generation compatibility with Cython</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/b2b7a51158418f41cff0520894836c15b1738721"><code>b2b7a51</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14054">#14054</a> from mkruskal-google/iwyu-fix2</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/955d371eacedc37eeff8bf61a1046d694a5fbc8a"><code>955d371</code></a> <code>Printer</code>: Include Abseil's <code>str_cat.h</code> for <code>absl::AlphaNum</code></li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/0d22de520bf3fdb0978a962ae90b72db2f560cef"><code>0d22de5</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14042">#14042</a> from mkruskal-google/iwyu-fix</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/96c1a7d47702f6c82b96e2a0ff112b30ea85c330"><code>96c1a7d</code></a> Add dependency on absl::layout, and explicitly include absl layout includes</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/d3c44a42c218213d6d5a9fbd66afdd9e8946bfce"><code>d3c44a4</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/13898">#13898</a> from protocolbuffers/24.x-202309071538</li>
<li>Additional commits viewable in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.24.3...v3.24.4">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.24.3&new-version=3.24.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 3a3a7d406b128..633e61f90aecc 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.24.3" />
+    <PackageReference Include="Google.Protobuf" Version="3.24.4" />
     <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
     <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
   </ItemGroup>

From 11d5ab64676f022e85c3386ffd9560c680a282a4 Mon Sep 17 00:00:00 2001
From: patrick <100629128+p-a-a-a-trick@users.noreply.github.com>
Date: Tue, 10 Oct 2023 05:44:17 -0400
Subject: [PATCH 506/749] GH-37650: [Python] Check filter inputs in
 FilterMetaFunction (#38075)

### Rationale for this change
Prevent a segfault upon passing a non-(chunked_)array object into `Table.filter`. See #37650.

### What changes are included in this PR?
1. Check filter Datum kind to make sure that it is an array or a chunked array
2. test that attempting to filter a table with another table raises a not implemented error

### Are these changes tested?
In PyArrow, yes

### Are there any user-facing changes?
Raises an error if a non-array or non-chunked_array object is passed into `Table.filter`

* Closes: #37650

Lead-authored-by: Patrick Clarke <prclarke@protonmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../compute/kernels/vector_selection_filter_internal.cc     | 6 +++++-
 python/pyarrow/tests/test_compute.py                        | 5 +++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
index be6d1653b5722..4a5e579fb155e 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_filter_internal.cc
@@ -942,7 +942,7 @@ Result<std::shared_ptr<Table>> FilterTable(const Table& table, const Datum& filt
       inputs.back() = filter.chunked_array()->chunks();
       break;
     default:
-      return Status::NotImplemented("Filter should be array-like");
+      return Status::TypeError("Filter should be array-like");
   }
 
   // Rechunk inputs to allow consistent iteration over their respective chunks
@@ -998,6 +998,10 @@ class FilterMetaFunction : public MetaFunction {
   Result<Datum> ExecuteImpl(const std::vector<Datum>& args,
                             const FunctionOptions* options,
                             ExecContext* ctx) const override {
+    if (args[1].kind() != Datum::ARRAY && args[1].kind() != Datum::CHUNKED_ARRAY) {
+      return Status::TypeError("Filter should be array-like");
+    }
+
     const auto& filter_type = *args[1].type();
     const bool filter_is_plain_bool = filter_type.id() == Type::BOOL;
     const bool filter_is_ree_bool =
diff --git a/python/pyarrow/tests/test_compute.py b/python/pyarrow/tests/test_compute.py
index 152cae1be1fe9..4b2144d702ca5 100644
--- a/python/pyarrow/tests/test_compute.py
+++ b/python/pyarrow/tests/test_compute.py
@@ -1378,6 +1378,11 @@ def test_filter_errors():
                            match="must all be the same length"):
             obj.filter(mask)
 
+    scalar = pa.scalar(True)
+    for filt in [batch, table, scalar]:
+        with pytest.raises(TypeError):
+            table.filter(filt)
+
 
 def test_filter_null_type():
     # ARROW-10027

From 9afa848e640fbd7539e7a188657fcf2ae6e45245 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Tue, 10 Oct 2023 13:18:35 +0200
Subject: [PATCH 507/749] GH-37050: [Python][Interchange protocol] Add a
 workaround for empty dataframes (#38037)

### Rationale for this change

The implementation of the DataFrame Interchange Protocol does not currently support consumption of dataframes with 0 number of chunks (empty dataframes).

### What changes are included in this PR?

Add a workaround to not error in this case.

### Are these changes tested?

Yes, added `test_empty_dataframe` in `python/pyarrow/tests/interchange/test_conversion.py`.

### Are there any user-facing changes?
No.
* Closes: #37050

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/interchange/from_dataframe.py        | 4 ++++
 python/pyarrow/tests/interchange/test_conversion.py | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/python/pyarrow/interchange/from_dataframe.py b/python/pyarrow/interchange/from_dataframe.py
index e97e91e44fb52..3767b18f2a87e 100644
--- a/python/pyarrow/interchange/from_dataframe.py
+++ b/python/pyarrow/interchange/from_dataframe.py
@@ -136,6 +136,10 @@ def _from_dataframe(df: DataFrameObject, allow_copy=True):
         batch = protocol_df_chunk_to_pyarrow(chunk, allow_copy)
         batches.append(batch)
 
+    if not batches:
+        batch = protocol_df_chunk_to_pyarrow(df)
+        batches.append(batch)
+
     return pa.Table.from_batches(batches)
 
 
diff --git a/python/pyarrow/tests/interchange/test_conversion.py b/python/pyarrow/tests/interchange/test_conversion.py
index 225210d8c7389..b1e0fa0d1c651 100644
--- a/python/pyarrow/tests/interchange/test_conversion.py
+++ b/python/pyarrow/tests/interchange/test_conversion.py
@@ -513,3 +513,10 @@ def test_allow_copy_false_bool_categorical():
     df = df.astype("category")
     with pytest.raises(RuntimeError):
         pi.from_dataframe(df, allow_copy=False)
+
+
+def test_empty_dataframe():
+    schema = pa.schema([('col1', pa.int8())])
+    df = pa.table([[]], schema=schema)
+    dfi = df.__dataframe__()
+    assert pi.from_dataframe(dfi) == df

From 94b7258c7e1dc500c53f873b17d97457752f95c7 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Tue, 10 Oct 2023 13:21:02 +0200
Subject: [PATCH 508/749] GH-36983: [Python] Different get_file_info behaviour
 between pyarrow.fs.S3FileSystem and s3fs (#37768)

### What changes are included in this PR?

Update `test_get_file_info_with_selector ` to check that the base directory is not included in the `S3FileSystem` or `s3fs` filesystem. Also remove old comments and flexible checks.

* Closes: #36983

Lead-authored-by: AlenkaF <frim.alenka@gmail.com>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/tests/test_fs.py | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/python/pyarrow/tests/test_fs.py b/python/pyarrow/tests/test_fs.py
index 8135f70f6905c..72545bf0c6d92 100644
--- a/python/pyarrow/tests/test_fs.py
+++ b/python/pyarrow/tests/test_fs.py
@@ -699,10 +699,8 @@ def test_get_file_info_with_selector(fs, pathfn):
 
         infos = fs.get_file_info(selector)
         if fs.type_name == "py::fsspec+s3":
-            # s3fs only lists directories if they are not empty, but depending
-            # on the s3fs/fsspec version combo, it includes the base_dir
-            # (https://github.com/dask/s3fs/issues/393)
-            assert (len(infos) == 4) or (len(infos) == 5)
+            # s3fs only lists directories if they are not empty
+            len(infos) == 4
         else:
             assert len(infos) == 5
 
@@ -713,10 +711,6 @@ def test_get_file_info_with_selector(fs, pathfn):
             elif (info.path.rstrip("/").endswith(dir_a) or
                   info.path.rstrip("/").endswith(dir_b)):
                 assert info.type == FileType.Directory
-            elif (fs.type_name == "py::fsspec+s3" and
-                  info.path.rstrip("/").endswith("selector-dir")):
-                # s3fs can include base dir, see above
-                assert info.type == FileType.Directory
             else:
                 raise ValueError('unexpected path {}'.format(info.path))
             check_mtime_or_absent(info)
@@ -727,10 +721,7 @@ def test_get_file_info_with_selector(fs, pathfn):
         infos = fs.get_file_info(selector)
         if fs.type_name == "py::fsspec+s3":
             # s3fs only lists directories if they are not empty
-            # + for s3fs 0.5.2 all directories are dropped because of buggy
-            # side-effect of previous find() call
-            # (https://github.com/dask/s3fs/issues/410)
-            assert (len(infos) == 3) or (len(infos) == 2)
+            assert len(infos) == 3
         else:
             assert len(infos) == 4
 

From 5d950072ef8bc41a3e9b6c12912f4816876d234f Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Tue, 10 Oct 2023 13:21:55 +0200
Subject: [PATCH 509/749] GH-38145: [Docs][Python] Add tzdata on Windows
 subsection in Python install docs (#38146)

### What changes are included in this PR?

The option to set custom path to timezone database through python API has been implemented in https://github.com/apache/arrow/issues/35600 and is documented in `docs/source/python/install.rst` with this PR.

* Closes: #38145

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/python/install.rst | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/source/python/install.rst b/docs/source/python/install.rst
index 99d1c43b024aa..4555977ece107 100644
--- a/docs/source/python/install.rst
+++ b/docs/source/python/install.rst
@@ -75,3 +75,20 @@ Optional dependencies
 
 Additional packages PyArrow is compatible with are :ref:`fsspec <filesystem-fsspec>`
 and **pytz**, **dateutil** or **tzdata** package for timezones.
+
+tzdata on Windows
+^^^^^^^^^^^^^^^^^
+
+While Arrow uses the OS-provided timezone database on Linux and macOS, it requires a
+user-provided database on Windows. To download and extract the text version of
+the IANA timezone database follow the instructions in the C++
+:ref:`download-timezone-database`.
+
+By default, the timezone database will be detected at ``%USERPROFILE%\Downloads\tzdata``.
+If the database has been downloaded in a different location, you will need to set
+a custom path to the database from Python:
+
+.. code-block:: python
+
+   >>> import pyarrow as pa
+   >>> pa.set_timezone_db_path("custom_path")

From 0f7c569268c974a40a5b9ce44f6fa726b883ec5e Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 10 Oct 2023 21:12:47 +0900
Subject: [PATCH 510/749] GH-38172: [CI][C++] Use system GoogleTest on Ubuntu
 22.04 (#38173)

### Rationale for this change

It will reduce build time.

### What changes are included in this PR?

Install GoogleTest by apt.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38172

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/docker/ubuntu-22.04-cpp.dockerfile | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ci/docker/ubuntu-22.04-cpp.dockerfile b/ci/docker/ubuntu-22.04-cpp.dockerfile
index fffafe2b0521d..848f62ab8aef8 100644
--- a/ci/docker/ubuntu-22.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-22.04-cpp.dockerfile
@@ -79,6 +79,7 @@ RUN apt-get update -y -q && \
         libc-ares-dev \
         libcurl4-openssl-dev \
         libgflags-dev \
+        libgmock-dev \
         libgoogle-glog-dev \
         libgrpc++-dev \
         libidn2-dev \
@@ -166,7 +167,6 @@ RUN /arrow/ci/scripts/install_sccache.sh unknown-linux-musl /usr/local/bin
 # provided by the distribution:
 # - Abseil is old
 # - libc-ares-dev does not install CMake config files
-# - libgtest-dev only provide sources
 ENV absl_SOURCE=BUNDLED \
     ARROW_ACERO=ON \
     ARROW_AZURE=ON \
@@ -200,7 +200,6 @@ ENV absl_SOURCE=BUNDLED \
     AWSSDK_SOURCE=BUNDLED \
     Azure_SOURCE=BUNDLED \
     google_cloud_cpp_storage_SOURCE=BUNDLED \
-    GTest_SOURCE=BUNDLED \
     ORC_SOURCE=BUNDLED \
     PARQUET_BUILD_EXAMPLES=ON \
     PARQUET_BUILD_EXECUTABLES=ON \

From 5f57219ec2730d06ffbe0676175c35b234b08d33 Mon Sep 17 00:00:00 2001
From: Fokko Driesprong <fokko@tabular.io>
Date: Tue, 10 Oct 2023 15:13:00 +0200
Subject: [PATCH 511/749] GH-36845: [C++][Python] Allow type promotion on
 `pa.concat_tables` (#36846)

Revival of https://github.com/apache/arrow/pull/12000/

### Rationale for this change

It would be great to be able to do promotions when `concat`'ing a table, such as:

```python
def test_concat_tables_with_promotion_int():
    import pyarrow as pa
    t1 = pa.Table.from_arrays(
        [pa.array([1, 2], type=pa.int64())], ["int"])
    t2 = pa.Table.from_arrays(
        [pa.array([3, 4], type=pa.int32())], ["int"])

    result = pa.concat_tables([t1, t2], promote=True)

    assert result.equals(pa.Table.from_arrays([
        pa.array([1, 2, 3, 4], type=pa.int64())
    ], ["int"]))
```

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

* Closes: #36845

Lead-authored-by: Fokko Driesprong <fokko@tabular.io>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 .../test-file-system-dataset-factory.rb       |   4 +-
 cpp/src/arrow/dataset/discovery.cc            |   2 +-
 cpp/src/arrow/dataset/discovery.h             |   4 +
 cpp/src/arrow/dataset/discovery_test.cc       |  20 +-
 cpp/src/arrow/table.cc                        |  24 +-
 cpp/src/arrow/table.h                         |  39 +-
 cpp/src/arrow/table_test.cc                   |  40 +-
 cpp/src/arrow/type.cc                         | 513 +++++++++++++++++-
 cpp/src/arrow/type.h                          |  64 ++-
 cpp/src/arrow/type_test.cc                    | 415 +++++++++++++-
 cpp/src/arrow/type_traits.h                   |  46 ++
 python/pyarrow/includes/libarrow.pxd          |   9 +-
 python/pyarrow/table.pxi                      |  29 +-
 python/pyarrow/tests/test_dataset.py          |   2 +-
 python/pyarrow/tests/test_schema.py           |   5 +-
 python/pyarrow/tests/test_table.py            |  55 +-
 python/pyarrow/types.pxi                      |  20 +-
 17 files changed, 1220 insertions(+), 71 deletions(-)

diff --git a/c_glib/test/dataset/test-file-system-dataset-factory.rb b/c_glib/test/dataset/test-file-system-dataset-factory.rb
index 30944ccd3bba4..c1fd128a40b00 100644
--- a/c_glib/test/dataset/test-file-system-dataset-factory.rb
+++ b/c_glib/test/dataset/test-file-system-dataset-factory.rb
@@ -109,9 +109,9 @@ def test_validate_fragments
                                     point: Arrow::Int16DataType.new)
       options.validate_fragments = true
       message = "[file-system-dataset-factory][finish]: " +
-                "Invalid: Unable to merge: " +
+                "Type error: Unable to merge: " +
                 "Field point has incompatible types: int16 vs int32"
-      error = assert_raise(Arrow::Error::Invalid) do
+      error = assert_raise(Arrow::Error::Type) do
         @factory.finish(options)
       end
       assert_equal(message, error.message.lines(chomp: true).first)
diff --git a/cpp/src/arrow/dataset/discovery.cc b/cpp/src/arrow/dataset/discovery.cc
index 2aca85e6adcfd..7e5acba992bec 100644
--- a/cpp/src/arrow/dataset/discovery.cc
+++ b/cpp/src/arrow/dataset/discovery.cc
@@ -47,7 +47,7 @@ Result<std::shared_ptr<Schema>> DatasetFactory::Inspect(InspectOptions options)
     return arrow::schema({});
   }
 
-  return UnifySchemas(schemas);
+  return UnifySchemas(schemas, options.field_merge_options);
 }
 
 Result<std::shared_ptr<Dataset>> DatasetFactory::Finish() {
diff --git a/cpp/src/arrow/dataset/discovery.h b/cpp/src/arrow/dataset/discovery.h
index 238b33e40fe25..6d76dcef727e7 100644
--- a/cpp/src/arrow/dataset/discovery.h
+++ b/cpp/src/arrow/dataset/discovery.h
@@ -58,6 +58,10 @@ struct InspectOptions {
   /// `kInspectAllFragments`. A value of `0` disables inspection of fragments
   /// altogether so only the partitioning schema will be inspected.
   int fragments = 1;
+
+  /// Control how to unify types. By default, types are merged strictly (the
+  /// type must match exactly, except nulls can be merged with other types).
+  Field::MergeOptions field_merge_options = Field::MergeOptions::Defaults();
 };
 
 struct FinishOptions {
diff --git a/cpp/src/arrow/dataset/discovery_test.cc b/cpp/src/arrow/dataset/discovery_test.cc
index 5b0590a277346..92cec7f324963 100644
--- a/cpp/src/arrow/dataset/discovery_test.cc
+++ b/cpp/src/arrow/dataset/discovery_test.cc
@@ -117,9 +117,15 @@ TEST_F(MockDatasetFactoryTest, UnifySchemas) {
 
   MakeFactory({schema({i32, f64}), schema({f64, i32_fake})});
   // Unification fails when fields with the same name have clashing types.
-  ASSERT_RAISES(Invalid, factory_->Inspect());
+  ASSERT_RAISES(TypeError, factory_->Inspect());
   // Return the individual schema for closer inspection should not fail.
   AssertInspectSchemas({schema({i32, f64}), schema({f64, i32_fake})});
+
+  MakeFactory({schema({field("num", int32())}), schema({field("num", float64())})});
+  ASSERT_RAISES(TypeError, factory_->Inspect());
+  InspectOptions permissive_options;
+  permissive_options.field_merge_options = Field::MergeOptions::Permissive();
+  AssertInspect(schema({field("num", float64())}), permissive_options);
 }
 
 class FileSystemDatasetFactoryTest : public DatasetFactoryTest {
@@ -335,7 +341,7 @@ TEST_F(FileSystemDatasetFactoryTest, FinishWithIncompatibleSchemaShouldFail) {
   ASSERT_OK_AND_ASSIGN(auto dataset, factory_->Finish(options));
 
   MakeFactory({fs::File("test")});
-  ASSERT_RAISES(Invalid, factory_->Finish(options));
+  ASSERT_RAISES(TypeError, factory_->Finish(options));
 
   // Disable validation
   options.validate_fragments = false;
@@ -463,8 +469,8 @@ TEST(UnionDatasetFactoryTest, ConflictingSchemas) {
                            {dataset_factory_1, dataset_factory_2, dataset_factory_3}));
 
   // schema_3 conflicts with other, Inspect/Finish should not work
-  ASSERT_RAISES(Invalid, factory->Inspect());
-  ASSERT_RAISES(Invalid, factory->Finish());
+  ASSERT_RAISES(TypeError, factory->Inspect());
+  ASSERT_RAISES(TypeError, factory->Finish());
 
   // The user can inspect without error
   ASSERT_OK_AND_ASSIGN(auto schemas, factory->InspectSchemas({}));
@@ -474,6 +480,12 @@ TEST(UnionDatasetFactoryTest, ConflictingSchemas) {
   auto i32_schema = schema({i32});
   ASSERT_OK_AND_ASSIGN(auto dataset, factory->Finish(i32_schema));
   EXPECT_EQ(*dataset->schema(), *i32_schema);
+
+  // The user decided to allow merging the types.
+  FinishOptions options;
+  options.inspect_options.field_merge_options = Field::MergeOptions::Permissive();
+  ASSERT_OK_AND_ASSIGN(dataset, factory->Finish(options));
+  EXPECT_EQ(*dataset->schema(), *schema({f64, i32}));
 }
 
 }  // namespace dataset
diff --git a/cpp/src/arrow/table.cc b/cpp/src/arrow/table.cc
index 47f82631782e4..967e78f6b4db1 100644
--- a/cpp/src/arrow/table.cc
+++ b/cpp/src/arrow/table.cc
@@ -30,6 +30,7 @@
 #include "arrow/array/concatenate.h"
 #include "arrow/array/util.h"
 #include "arrow/chunked_array.h"
+#include "arrow/compute/cast.h"
 #include "arrow/pretty_print.h"
 #include "arrow/record_batch.h"
 #include "arrow/result.h"
@@ -450,6 +451,13 @@ Result<std::shared_ptr<Table>> ConcatenateTables(
 Result<std::shared_ptr<Table>> PromoteTableToSchema(const std::shared_ptr<Table>& table,
                                                     const std::shared_ptr<Schema>& schema,
                                                     MemoryPool* pool) {
+  return PromoteTableToSchema(table, schema, compute::CastOptions::Safe(), pool);
+}
+
+Result<std::shared_ptr<Table>> PromoteTableToSchema(const std::shared_ptr<Table>& table,
+                                                    const std::shared_ptr<Schema>& schema,
+                                                    const compute::CastOptions& options,
+                                                    MemoryPool* pool) {
   const std::shared_ptr<Schema> current_schema = table->schema();
   if (current_schema->Equals(*schema, /*check_metadata=*/false)) {
     return table->ReplaceSchemaMetadata(schema->metadata());
@@ -487,8 +495,8 @@ Result<std::shared_ptr<Table>> PromoteTableToSchema(const std::shared_ptr<Table>
     const int field_index = field_indices[0];
     const auto& current_field = current_schema->field(field_index);
     if (!field->nullable() && current_field->nullable()) {
-      return Status::Invalid("Unable to promote field ", current_field->name(),
-                             ": it was nullable but the target schema was not.");
+      return Status::TypeError("Unable to promote field ", current_field->name(),
+                               ": it was nullable but the target schema was not.");
     }
 
     fields_seen[field_index] = true;
@@ -502,9 +510,15 @@ Result<std::shared_ptr<Table>> PromoteTableToSchema(const std::shared_ptr<Table>
       continue;
     }
 
-    return Status::Invalid("Unable to promote field ", field->name(),
-                           ": incompatible types: ", field->type()->ToString(), " vs ",
-                           current_field->type()->ToString());
+    if (!compute::CanCast(*current_field->type(), *field->type())) {
+      return Status::TypeError("Unable to promote field ", field->name(),
+                               ": incompatible types: ", field->type()->ToString(),
+                               " vs ", current_field->type()->ToString());
+    }
+    compute::ExecContext ctx(pool);
+    ARROW_ASSIGN_OR_RAISE(auto casted, compute::Cast(table->column(field_index),
+                                                     field->type(), options, &ctx));
+    columns.push_back(casted.chunked_array());
   }
 
   auto unseen_field_iter = std::find(fields_seen.begin(), fields_seen.end(), false);
diff --git a/cpp/src/arrow/table.h b/cpp/src/arrow/table.h
index 940ff73ae983f..551880f237586 100644
--- a/cpp/src/arrow/table.h
+++ b/cpp/src/arrow/table.h
@@ -313,16 +313,23 @@ Result<std::shared_ptr<Table>> ConcatenateTables(
     ConcatenateTablesOptions options = ConcatenateTablesOptions::Defaults(),
     MemoryPool* memory_pool = default_memory_pool());
 
+namespace compute {
+class CastOptions;
+}
+
 /// \brief Promotes a table to conform to the given schema.
 ///
-/// If a field in the schema does not have a corresponding column in the
-/// table, a column of nulls will be added to the resulting table.
-/// If the corresponding column is of type Null, it will be promoted to
-/// the type specified by schema, with null values filled.
+/// If a field in the schema does not have a corresponding column in
+/// the table, a column of nulls will be added to the resulting table.
+/// If the corresponding column is of type Null, it will be promoted
+/// to the type specified by schema, with null values filled. The
+/// column will be casted to the type specified by the schema.
+///
 /// Returns an error:
 /// - if the corresponding column's type is not compatible with the
 ///   schema.
 /// - if there is a column in the table that does not exist in the schema.
+/// - if the cast fails or casting would be required but is not available.
 ///
 /// \param[in] table the input Table
 /// \param[in] schema the target schema to promote to
@@ -333,4 +340,28 @@ Result<std::shared_ptr<Table>> PromoteTableToSchema(
     const std::shared_ptr<Table>& table, const std::shared_ptr<Schema>& schema,
     MemoryPool* pool = default_memory_pool());
 
+/// \brief Promotes a table to conform to the given schema.
+///
+/// If a field in the schema does not have a corresponding column in
+/// the table, a column of nulls will be added to the resulting table.
+/// If the corresponding column is of type Null, it will be promoted
+/// to the type specified by schema, with null values filled. The column
+/// will be casted to the type specified by the schema.
+///
+/// Returns an error:
+/// - if the corresponding column's type is not compatible with the
+///   schema.
+/// - if there is a column in the table that does not exist in the schema.
+/// - if the cast fails or casting would be required but is not available.
+///
+/// \param[in] table the input Table
+/// \param[in] schema the target schema to promote to
+/// \param[in] options The cast options to allow promotion of types
+/// \param[in] pool The memory pool to be used if null-filled arrays need to
+/// be created.
+ARROW_EXPORT
+Result<std::shared_ptr<Table>> PromoteTableToSchema(
+    const std::shared_ptr<Table>& table, const std::shared_ptr<Schema>& schema,
+    const compute::CastOptions& options, MemoryPool* pool = default_memory_pool());
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/table_test.cc b/cpp/src/arrow/table_test.cc
index 925a1ce12643f..3949caa402846 100644
--- a/cpp/src/arrow/table_test.cc
+++ b/cpp/src/arrow/table_test.cc
@@ -29,6 +29,7 @@
 #include "arrow/array/data.h"
 #include "arrow/array/util.h"
 #include "arrow/chunked_array.h"
+#include "arrow/compute/cast.h"
 #include "arrow/record_batch.h"
 #include "arrow/status.h"
 #include "arrow/testing/gtest_util.h"
@@ -418,16 +419,17 @@ TEST_F(TestPromoteTableToSchema, IncompatibleTypes) {
   auto table = MakeTableWithOneNullFilledColumn("field", int32(), length);
 
   // Invalid promotion: int32 to null.
-  ASSERT_RAISES(Invalid, PromoteTableToSchema(table, schema({field("field", null())})));
+  ASSERT_RAISES(TypeError, PromoteTableToSchema(table, schema({field("field", null())})));
 
-  // Invalid promotion: int32 to uint32.
-  ASSERT_RAISES(Invalid, PromoteTableToSchema(table, schema({field("field", uint32())})));
+  // Invalid promotion: int32 to list.
+  ASSERT_RAISES(TypeError,
+                PromoteTableToSchema(table, schema({field("field", list(int32()))})));
 }
 
 TEST_F(TestPromoteTableToSchema, IncompatibleNullity) {
   const int length = 10;
   auto table = MakeTableWithOneNullFilledColumn("field", int32(), length);
-  ASSERT_RAISES(Invalid,
+  ASSERT_RAISES(TypeError,
                 PromoteTableToSchema(
                     table, schema({field("field", uint32())->WithNullable(false)})));
 }
@@ -520,6 +522,36 @@ TEST_F(ConcatenateTablesWithPromotionTest, Simple) {
   AssertTablesEqualUnorderedFields(*expected, *result);
 }
 
+TEST_F(ConcatenateTablesWithPromotionTest, Unify) {
+  auto t_i32 = TableFromJSON(schema({field("f0", int32())}), {"[[0], [1]]"});
+  auto t_i64 = TableFromJSON(schema({field("f0", int64())}), {"[[2], [3]]"});
+  auto t_null = TableFromJSON(schema({field("f0", null())}), {"[[null], [null]]"});
+
+  auto expected_int64 =
+      TableFromJSON(schema({field("f0", int64())}), {"[[0], [1], [2], [3]]"});
+  auto expected_null =
+      TableFromJSON(schema({field("f0", int32())}), {"[[0], [1], [null], [null]]"});
+
+  ConcatenateTablesOptions options;
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
+                                  ::testing::HasSubstr("Schema at index 1 was different"),
+                                  ConcatenateTables({t_i32, t_i64}, options));
+  EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid,
+                                  ::testing::HasSubstr("Schema at index 1 was different"),
+                                  ConcatenateTables({t_i32, t_null}, options));
+
+  options.unify_schemas = true;
+  EXPECT_RAISES_WITH_MESSAGE_THAT(TypeError,
+                                  ::testing::HasSubstr("Field f0 has incompatible types"),
+                                  ConcatenateTables({t_i64, t_i32}, options));
+  ASSERT_OK_AND_ASSIGN(auto actual, ConcatenateTables({t_i32, t_null}, options));
+  AssertTablesEqual(*expected_null, *actual, /*same_chunk_layout=*/false);
+
+  options.field_merge_options.promote_numeric_width = true;
+  ASSERT_OK_AND_ASSIGN(actual, ConcatenateTables({t_i32, t_i64}, options));
+  AssertTablesEqual(*expected_int64, *actual, /*same_chunk_layout=*/false);
+}
+
 TEST_F(TestTable, Slice) {
   const int64_t length = 10;
 
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 47bf52660ffe9..a4f43256827da 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -39,17 +39,21 @@
 #include "arrow/status.h"
 #include "arrow/table.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/decimal.h"
 #include "arrow/util/hash_util.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/range.h"
 #include "arrow/util/string.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/util/vector.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
 
+using internal::checked_cast;
+
 constexpr Type::type NullType::type_id;
 constexpr Type::type ListType::type_id;
 constexpr Type::type LargeListType::type_id;
@@ -261,22 +265,6 @@ namespace {
 
 using internal::checked_cast;
 
-// Merges `existing` and `other` if one of them is of NullType, otherwise
-// returns nullptr.
-//   - if `other` if of NullType or is nullable, the unified field will be nullable.
-//   - if `existing` is of NullType but other is not, the unified field will
-//     have `other`'s type and will be nullable
-std::shared_ptr<Field> MaybePromoteNullTypes(const Field& existing, const Field& other) {
-  if (existing.type()->id() != Type::NA && other.type()->id() != Type::NA) {
-    return nullptr;
-  }
-  if (existing.type()->id() == Type::NA) {
-    return other.WithNullable(true)->WithMetadata(existing.metadata());
-  }
-  // `other` must be null.
-  return existing.WithNullable(true);
-}
-
 FieldVector MakeFields(
     std::initializer_list<std::pair<std::string, std::shared_ptr<DataType>>> init_list) {
   FieldVector fields;
@@ -327,6 +315,459 @@ std::shared_ptr<Field> Field::WithNullable(const bool nullable) const {
   return std::make_shared<Field>(name_, type_, nullable, metadata_);
 }
 
+Field::MergeOptions Field::MergeOptions::Permissive() {
+  MergeOptions options = Defaults();
+  options.promote_nullability = true;
+  options.promote_decimal = true;
+  options.promote_decimal_to_float = true;
+  options.promote_integer_to_decimal = true;
+  options.promote_integer_to_float = true;
+  options.promote_integer_sign = true;
+  options.promote_numeric_width = true;
+  options.promote_binary = true;
+  options.promote_temporal_unit = true;
+  options.promote_list = true;
+  options.promote_dictionary = true;
+  options.promote_dictionary_ordered = false;
+  return options;
+}
+
+std::string Field::MergeOptions::ToString() const {
+  std::stringstream ss;
+  ss << "MergeOptions{";
+  ss << "promote_nullability=" << (promote_nullability ? "true" : "false");
+  ss << ", promote_decimal=" << (promote_decimal ? "true" : "false");
+  ss << ", promote_decimal_to_float=" << (promote_decimal_to_float ? "true" : "false");
+  ss << ", promote_integer_to_decimal="
+     << (promote_integer_to_decimal ? "true" : "false");
+  ss << ", promote_integer_to_float=" << (promote_integer_to_float ? "true" : "false");
+  ss << ", promote_integer_sign=" << (promote_integer_sign ? "true" : "false");
+  ss << ", promote_numeric_width=" << (promote_numeric_width ? "true" : "false");
+  ss << ", promote_binary=" << (promote_binary ? "true" : "false");
+  ss << ", promote_temporal_unit=" << (promote_temporal_unit ? "true" : "false");
+  ss << ", promote_list=" << (promote_list ? "true" : "false");
+  ss << ", promote_dictionary=" << (promote_dictionary ? "true" : "false");
+  ss << ", promote_dictionary_ordered="
+     << (promote_dictionary_ordered ? "true" : "false");
+  ss << '}';
+  return ss.str();
+}
+
+namespace {
+// Utilities for Field::MergeWith
+
+std::shared_ptr<DataType> MakeBinary(const DataType& type) {
+  switch (type.id()) {
+    case Type::BINARY:
+    case Type::STRING:
+      return binary();
+    case Type::LARGE_BINARY:
+    case Type::LARGE_STRING:
+      return large_binary();
+    default:
+      Unreachable("Hit an unknown type");
+  }
+  return nullptr;
+}
+
+Result<std::shared_ptr<DataType>> WidenDecimals(
+    const std::shared_ptr<DataType>& promoted_type,
+    const std::shared_ptr<DataType>& other_type, const Field::MergeOptions& options) {
+  const auto& left = checked_cast<const DecimalType&>(*promoted_type);
+  const auto& right = checked_cast<const DecimalType&>(*other_type);
+  if (!options.promote_numeric_width && left.bit_width() != right.bit_width()) {
+    return Status::TypeError(
+        "Cannot promote decimal128 to decimal256 without promote_numeric_width=true");
+  }
+  const int32_t max_scale = std::max<int32_t>(left.scale(), right.scale());
+  const int32_t common_precision =
+      std::max<int32_t>(left.precision() + max_scale - left.scale(),
+                        right.precision() + max_scale - right.scale());
+  if (left.id() == Type::DECIMAL256 || right.id() == Type::DECIMAL256 ||
+      common_precision > BasicDecimal128::kMaxPrecision) {
+    return DecimalType::Make(Type::DECIMAL256, common_precision, max_scale);
+  }
+  return DecimalType::Make(Type::DECIMAL128, common_precision, max_scale);
+}
+
+Result<std::shared_ptr<DataType>> MergeTypes(std::shared_ptr<DataType> promoted_type,
+                                             std::shared_ptr<DataType> other_type,
+                                             const Field::MergeOptions& options);
+
+// Merge temporal types based on options. Returns nullptr for non-temporal types.
+Result<std::shared_ptr<DataType>> MaybeMergeTemporalTypes(
+    const std::shared_ptr<DataType>& promoted_type,
+    const std::shared_ptr<DataType>& other_type, const Field::MergeOptions& options) {
+  if (options.promote_temporal_unit) {
+    if (promoted_type->id() == Type::DATE32 && other_type->id() == Type::DATE64) {
+      return date64();
+    }
+    if (promoted_type->id() == Type::DATE64 && other_type->id() == Type::DATE32) {
+      return date64();
+    }
+
+    if (promoted_type->id() == Type::DURATION && other_type->id() == Type::DURATION) {
+      const auto& left = checked_cast<const DurationType&>(*promoted_type);
+      const auto& right = checked_cast<const DurationType&>(*other_type);
+      return duration(std::max(left.unit(), right.unit()));
+    }
+
+    if (is_time(promoted_type->id()) && is_time(other_type->id())) {
+      const auto& left = checked_cast<const TimeType&>(*promoted_type);
+      const auto& right = checked_cast<const TimeType&>(*other_type);
+      const auto unit = std::max(left.unit(), right.unit());
+      if (unit == TimeUnit::MICRO || unit == TimeUnit::NANO) {
+        return time64(unit);
+      }
+      return time32(unit);
+    }
+  }
+
+  if (promoted_type->id() == Type::TIMESTAMP && other_type->id() == Type::TIMESTAMP) {
+    const auto& left = checked_cast<const TimestampType&>(*promoted_type);
+    const auto& right = checked_cast<const TimestampType&>(*other_type);
+    if (left.timezone().empty() ^ right.timezone().empty()) {
+      return Status::TypeError(
+          "Cannot merge timestamp with timezone and timestamp without timezone");
+    }
+    if (left.timezone() != right.timezone()) {
+      return Status::TypeError("Cannot merge timestamps with differing timezones");
+    }
+    if (options.promote_temporal_unit) {
+      return timestamp(std::max(left.unit(), right.unit()), left.timezone());
+    }
+  }
+
+  return nullptr;
+}
+
+// Merge numeric types based on options. Returns nullptr for non-numeric types.
+Result<std::shared_ptr<DataType>> MaybeMergeNumericTypes(
+    std::shared_ptr<DataType> promoted_type, std::shared_ptr<DataType> other_type,
+    const Field::MergeOptions& options) {
+  bool promoted = false;
+  if (options.promote_decimal_to_float) {
+    if (is_decimal(promoted_type->id()) && is_floating(other_type->id())) {
+      promoted_type = other_type;
+      promoted = true;
+    } else if (is_floating(promoted_type->id()) && is_decimal(other_type->id())) {
+      other_type = promoted_type;
+      promoted = true;
+    }
+  }
+
+  if (options.promote_integer_to_decimal &&
+      ((is_decimal(promoted_type->id()) && is_integer(other_type->id())) ||
+       (is_decimal(other_type->id()) && is_integer(promoted_type->id())))) {
+    if (is_integer(promoted_type->id()) && is_decimal(other_type->id())) {
+      // Other type is always the int
+      promoted_type.swap(other_type);
+    }
+    ARROW_ASSIGN_OR_RAISE(const int32_t precision,
+                          MaxDecimalDigitsForInteger(other_type->id()));
+    ARROW_ASSIGN_OR_RAISE(const auto promoted_decimal,
+                          DecimalType::Make(promoted_type->id(), precision, 0));
+    ARROW_ASSIGN_OR_RAISE(promoted_type,
+                          WidenDecimals(promoted_type, promoted_decimal, options));
+    return promoted_type;
+  }
+
+  if (options.promote_decimal && is_decimal(promoted_type->id()) &&
+      is_decimal(other_type->id())) {
+    ARROW_ASSIGN_OR_RAISE(promoted_type,
+                          WidenDecimals(promoted_type, other_type, options));
+    return promoted_type;
+  }
+
+  if (options.promote_integer_sign && ((is_unsigned_integer(promoted_type->id()) &&
+                                        is_signed_integer(other_type->id())) ||
+                                       (is_signed_integer(promoted_type->id()) &&
+                                        is_unsigned_integer(other_type->id())))) {
+    if (is_signed_integer(promoted_type->id()) && is_unsigned_integer(other_type->id())) {
+      // Other type is always the signed int
+      promoted_type.swap(other_type);
+    }
+
+    if (!options.promote_numeric_width &&
+        bit_width(promoted_type->id()) < bit_width(other_type->id())) {
+      return Status::TypeError(
+          "Cannot widen signed integers without promote_numeric_width=true");
+    }
+    int max_width =
+        std::max<int>(bit_width(promoted_type->id()), bit_width(other_type->id()));
+
+    // If the unsigned one is bigger or equal to the signed one, we need another bit
+    if (bit_width(promoted_type->id()) >= bit_width(other_type->id())) {
+      ++max_width;
+    }
+
+    if (max_width > 32) {
+      promoted_type = int64();
+    } else if (max_width > 16) {
+      promoted_type = int32();
+    } else if (max_width > 8) {
+      promoted_type = int16();
+    } else {
+      promoted_type = int8();
+    }
+    return promoted_type;
+  }
+
+  if (options.promote_integer_to_float &&
+      ((is_floating(promoted_type->id()) && is_integer(other_type->id())) ||
+       (is_integer(promoted_type->id()) && is_floating(other_type->id())))) {
+    if (is_integer(promoted_type->id()) && is_floating(other_type->id())) {
+      // Other type is always the int
+      promoted_type.swap(other_type);
+    }
+
+    const int int_width = bit_width(other_type->id());
+    promoted = true;
+    if (int_width <= 8) {
+      other_type = float16();
+    } else if (int_width <= 16) {
+      other_type = float32();
+    } else {
+      other_type = float64();
+    }
+
+    if (!options.promote_numeric_width &&
+        bit_width(promoted_type->id()) != bit_width(other_type->id())) {
+      return Status::TypeError("Cannot widen float without promote_numeric_width=true");
+    }
+  }
+
+  if (options.promote_numeric_width) {
+    const int max_width =
+        std::max<int>(bit_width(promoted_type->id()), bit_width(other_type->id()));
+    if (is_floating(promoted_type->id()) && is_floating(other_type->id())) {
+      promoted = true;
+      if (max_width >= 64) {
+        promoted_type = float64();
+      } else if (max_width >= 32) {
+        promoted_type = float32();
+      } else {
+        promoted_type = float16();
+      }
+    } else if (is_signed_integer(promoted_type->id()) &&
+               is_signed_integer(other_type->id())) {
+      promoted = true;
+      if (max_width >= 64) {
+        promoted_type = int64();
+      } else if (max_width >= 32) {
+        promoted_type = int32();
+      } else if (max_width >= 16) {
+        promoted_type = int16();
+      } else {
+        promoted_type = int8();
+      }
+    } else if (is_unsigned_integer(promoted_type->id()) &&
+               is_unsigned_integer(other_type->id())) {
+      promoted = true;
+      if (max_width >= 64) {
+        promoted_type = uint64();
+      } else if (max_width >= 32) {
+        promoted_type = uint32();
+      } else if (max_width >= 16) {
+        promoted_type = uint16();
+      } else {
+        promoted_type = uint8();
+      }
+    }
+  }
+
+  return promoted ? promoted_type : nullptr;
+}
+
+// Merge two dictionary types, or else give an error.
+Result<std::shared_ptr<DataType>> MergeDictionaryTypes(
+    const std::shared_ptr<DataType>& promoted_type,
+    const std::shared_ptr<DataType>& other_type, const Field::MergeOptions& options) {
+  const auto& left = checked_cast<const DictionaryType&>(*promoted_type);
+  const auto& right = checked_cast<const DictionaryType&>(*other_type);
+  if (!options.promote_dictionary_ordered && left.ordered() != right.ordered()) {
+    return Status::TypeError(
+        "Cannot merge ordered and unordered dictionary unless "
+        "promote_dictionary_ordered=true");
+  }
+  Field::MergeOptions index_options = options;
+  index_options.promote_integer_sign = true;
+  index_options.promote_numeric_width = true;
+  ARROW_ASSIGN_OR_RAISE(
+      auto indices,
+      MaybeMergeNumericTypes(left.index_type(), right.index_type(), index_options));
+  ARROW_ASSIGN_OR_RAISE(auto values,
+                        MergeTypes(left.value_type(), right.value_type(), options));
+  auto ordered = left.ordered() && right.ordered();
+  if (indices && values) {
+    return dictionary(indices, values, ordered);
+  } else if (values) {
+    return Status::TypeError("Could not merge dictionary index types");
+  }
+  return Status::TypeError("Could not merge dictionary value types");
+}
+
+// Merge temporal types based on options. Returns nullptr for non-binary types.
+Result<std::shared_ptr<DataType>> MaybeMergeBinaryTypes(
+    std::shared_ptr<DataType>& promoted_type, std::shared_ptr<DataType>& other_type,
+    const Field::MergeOptions& options) {
+  if (options.promote_binary) {
+    if (other_type->id() == Type::FIXED_SIZE_BINARY &&
+        is_base_binary_like(promoted_type->id())) {
+      return MakeBinary(*promoted_type);
+    } else if (promoted_type->id() == Type::FIXED_SIZE_BINARY &&
+               is_base_binary_like(other_type->id())) {
+      return MakeBinary(*other_type);
+    } else if (promoted_type->id() == Type::FIXED_SIZE_BINARY &&
+               other_type->id() == Type::FIXED_SIZE_BINARY) {
+      return binary();
+    }
+
+    if ((other_type->id() == Type::LARGE_STRING ||
+         other_type->id() == Type::LARGE_BINARY) &&
+        (promoted_type->id() == Type::STRING || promoted_type->id() == Type::BINARY)
+
+    ) {
+      // Promoted type is always large in case there are regular and large types
+      promoted_type.swap(other_type);
+    }
+
+    // When one field is binary and the other a string
+    if (is_string(promoted_type->id()) && is_binary(other_type->id())) {
+      return MakeBinary(*promoted_type);
+    } else if (is_binary(promoted_type->id()) && is_string(other_type->id())) {
+      return MakeBinary(*promoted_type);
+    }
+
+    // When the types are the same, but one is large
+    if ((promoted_type->id() == Type::STRING && other_type->id() == Type::LARGE_STRING) ||
+        (promoted_type->id() == Type::LARGE_STRING && other_type->id() == Type::STRING)) {
+      return large_utf8();
+    } else if ((promoted_type->id() == Type::BINARY &&
+                other_type->id() == Type::LARGE_BINARY) ||
+               (promoted_type->id() == Type::LARGE_BINARY &&
+                other_type->id() == Type::BINARY)) {
+      return large_binary();
+    }
+  }
+
+  return nullptr;
+}
+
+// Merge list types based on options. Returns nullptr for non-list types.
+Result<std::shared_ptr<DataType>> MergeStructs(
+    const std::shared_ptr<DataType>& promoted_type,
+    const std::shared_ptr<DataType>& other_type, const Field::MergeOptions& options) {
+  SchemaBuilder builder(SchemaBuilder::CONFLICT_APPEND, options);
+  // Add the LHS fields. Duplicates will be preserved.
+  RETURN_NOT_OK(builder.AddFields(promoted_type->fields()));
+
+  // Add the RHS fields. Duplicates will be merged, unless the field was
+  // already a duplicate, in which case we error (since we don't know which
+  // field to merge with).
+  builder.SetPolicy(SchemaBuilder::CONFLICT_MERGE);
+  RETURN_NOT_OK(builder.AddFields(other_type->fields()));
+
+  ARROW_ASSIGN_OR_RAISE(auto schema, builder.Finish());
+  return struct_(schema->fields());
+}
+
+// Merge list types based on options. Returns nullptr for non-list types.
+Result<std::shared_ptr<DataType>> MaybeMergeListTypes(
+    const std::shared_ptr<DataType>& promoted_type,
+    const std::shared_ptr<DataType>& other_type, const Field::MergeOptions& options) {
+  if (promoted_type->id() == Type::FIXED_SIZE_LIST &&
+      other_type->id() == Type::FIXED_SIZE_LIST) {
+    const auto& left = checked_cast<const FixedSizeListType&>(*promoted_type);
+    const auto& right = checked_cast<const FixedSizeListType&>(*other_type);
+    ARROW_ASSIGN_OR_RAISE(
+        auto value_field,
+        left.value_field()->MergeWith(
+            *right.value_field()->WithName(left.value_field()->name()), options));
+    if (left.list_size() == right.list_size()) {
+      return fixed_size_list(std::move(value_field), left.list_size());
+    } else {
+      return list(std::move(value_field));
+    }
+  } else if (is_list(promoted_type->id()) && is_list(other_type->id())) {
+    const auto& left = checked_cast<const BaseListType&>(*promoted_type);
+    const auto& right = checked_cast<const BaseListType&>(*other_type);
+    ARROW_ASSIGN_OR_RAISE(
+        auto value_field,
+        left.value_field()->MergeWith(
+            *right.value_field()->WithName(left.value_field()->name()), options));
+
+    if (!options.promote_list && promoted_type->id() != other_type->id()) {
+      return Status::TypeError("Cannot merge lists unless promote_list=true");
+    }
+
+    if (promoted_type->id() == Type::LARGE_LIST || other_type->id() == Type::LARGE_LIST) {
+      return large_list(std::move(value_field));
+    } else {
+      return list(std::move(value_field));
+    }
+  } else if (promoted_type->id() == Type::MAP && other_type->id() == Type::MAP) {
+    const auto& left = checked_cast<const MapType&>(*promoted_type);
+    const auto& right = checked_cast<const MapType&>(*other_type);
+    ARROW_ASSIGN_OR_RAISE(
+        auto key_field,
+        left.key_field()->MergeWith(
+            *right.key_field()->WithName(left.key_field()->name()), options));
+    ARROW_ASSIGN_OR_RAISE(
+        auto item_field,
+        left.item_field()->MergeWith(
+            *right.item_field()->WithName(left.item_field()->name()), options));
+    return map(std::move(key_field->type()), std::move(item_field),
+               /*keys_sorted=*/left.keys_sorted() && right.keys_sorted());
+  } else if (promoted_type->id() == Type::STRUCT && other_type->id() == Type::STRUCT) {
+    return MergeStructs(promoted_type, other_type, options);
+  }
+
+  return nullptr;
+}
+
+Result<std::shared_ptr<DataType>> MergeTypes(std::shared_ptr<DataType> promoted_type,
+                                             std::shared_ptr<DataType> other_type,
+                                             const Field::MergeOptions& options) {
+  if (promoted_type->Equals(*other_type)) return promoted_type;
+
+  bool promoted = false;
+  if (options.promote_nullability) {
+    if (promoted_type->id() == Type::NA) {
+      return other_type;
+    } else if (other_type->id() == Type::NA) {
+      return promoted_type;
+    }
+  } else if (promoted_type->id() == Type::NA || other_type->id() == Type::NA) {
+    return Status::TypeError(
+        "Cannot merge type with null unless promote_nullability=true");
+  }
+
+  if (options.promote_dictionary && is_dictionary(promoted_type->id()) &&
+      is_dictionary(other_type->id())) {
+    return MergeDictionaryTypes(promoted_type, other_type, options);
+  }
+
+  ARROW_ASSIGN_OR_RAISE(auto maybe_promoted,
+                        MaybeMergeTemporalTypes(promoted_type, other_type, options));
+  if (maybe_promoted) return maybe_promoted;
+
+  ARROW_ASSIGN_OR_RAISE(maybe_promoted,
+                        MaybeMergeNumericTypes(promoted_type, other_type, options));
+  if (maybe_promoted) return maybe_promoted;
+
+  ARROW_ASSIGN_OR_RAISE(maybe_promoted,
+                        MaybeMergeBinaryTypes(promoted_type, other_type, options));
+  if (maybe_promoted) return maybe_promoted;
+
+  ARROW_ASSIGN_OR_RAISE(maybe_promoted,
+                        MaybeMergeListTypes(promoted_type, other_type, options));
+  if (maybe_promoted) return maybe_promoted;
+
+  return promoted ? promoted_type : nullptr;
+}
+}  // namespace
+
 Result<std::shared_ptr<Field>> Field::MergeWith(const Field& other,
                                                 MergeOptions options) const {
   if (name() != other.name()) {
@@ -338,17 +779,30 @@ Result<std::shared_ptr<Field>> Field::MergeWith(const Field& other,
     return Copy();
   }
 
-  if (options.promote_nullability) {
-    if (type()->Equals(other.type())) {
-      return Copy()->WithNullable(nullable() || other.nullable());
+  auto maybe_promoted_type = MergeTypes(type_, other.type(), options);
+  if (!maybe_promoted_type.ok()) {
+    return maybe_promoted_type.status().WithMessage(
+        "Unable to merge: Field ", name(),
+        " has incompatible types: ", type()->ToString(), " vs ", other.type()->ToString(),
+        ": ", maybe_promoted_type.status().message());
+  }
+  auto promoted_type = *std::move(maybe_promoted_type);
+  if (promoted_type) {
+    bool nullable = nullable_;
+    if (options.promote_nullability) {
+      nullable = nullable || other.nullable() || type_->id() == Type::NA ||
+                 other.type()->id() == Type::NA;
+    } else if (nullable_ != other.nullable()) {
+      return Status::TypeError("Unable to merge: Field ", name(),
+                               " has incompatible nullability: ", nullable_, " vs ",
+                               other.nullable());
     }
-    std::shared_ptr<Field> promoted = MaybePromoteNullTypes(*this, other);
-    if (promoted) return promoted;
-  }
 
-  return Status::Invalid("Unable to merge: Field ", name(),
-                         " has incompatible types: ", type()->ToString(), " vs ",
-                         other.type()->ToString());
+    return std::make_shared<Field>(name_, promoted_type, nullable, metadata_);
+  }
+  return Status::TypeError("Unable to merge: Field ", name(),
+                           " has incompatible types: ", type()->ToString(), " vs ",
+                           other.type()->ToString());
 }
 
 Result<std::shared_ptr<Field>> Field::MergeWith(const std::shared_ptr<Field>& other,
@@ -2022,7 +2476,8 @@ class SchemaBuilder::Impl {
     if (policy_ == CONFLICT_REPLACE) {
       fields_[i] = field;
     } else if (policy_ == CONFLICT_MERGE) {
-      ARROW_ASSIGN_OR_RAISE(fields_[i], fields_[i]->MergeWith(field));
+      ARROW_ASSIGN_OR_RAISE(fields_[i],
+                            fields_[i]->MergeWith(field, field_merge_options_));
     }
 
     return Status::OK();
@@ -2643,6 +3098,12 @@ std::shared_ptr<DataType> map(std::shared_ptr<DataType> key_type,
                                    keys_sorted);
 }
 
+std::shared_ptr<DataType> map(std::shared_ptr<Field> key_field,
+                              std::shared_ptr<Field> item_field, bool keys_sorted) {
+  return std::make_shared<MapType>(std::move(key_field), std::move(item_field),
+                                   keys_sorted);
+}
+
 std::shared_ptr<DataType> fixed_size_list(const std::shared_ptr<DataType>& value_type,
                                           int32_t list_size) {
   return std::make_shared<FixedSizeListType>(value_type, list_size);
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 19910979287cc..3f4dd5c9b21fa 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -397,14 +397,76 @@ class ARROW_EXPORT Field : public detail::Fingerprintable,
   /// \brief Options that control the behavior of `MergeWith`.
   /// Options are to be added to allow type conversions, including integer
   /// widening, promotion from integer to float, or conversion to or from boolean.
-  struct MergeOptions {
+  struct ARROW_EXPORT MergeOptions : public util::ToStringOstreamable<MergeOptions> {
     /// If true, a Field of NullType can be unified with a Field of another type.
     /// The unified field will be of the other type and become nullable.
     /// Nullability will be promoted to the looser option (nullable if one is not
     /// nullable).
     bool promote_nullability = true;
 
+    /// Allow a decimal to be unified with another decimal of the same
+    /// width, adjusting scale and precision as appropriate. May fail
+    /// if the adjustment is not possible.
+    bool promote_decimal = false;
+
+    /// Allow a decimal to be promoted to a float. The float type will
+    /// not itself be promoted (e.g. Decimal128 + Float32 = Float32).
+    bool promote_decimal_to_float = false;
+
+    /// Allow an integer to be promoted to a decimal.
+    ///
+    /// May fail if the decimal has insufficient precision to
+    /// accommodate the integer (see promote_numeric_width).
+    bool promote_integer_to_decimal = false;
+
+    /// Allow an integer of a given bit width to be promoted to a
+    /// float; the result will be a float of an equal or greater bit
+    /// width to both of the inputs. Examples:
+    ///  - int8 + float32 = float32
+    ///  - int32 + float32 = float64
+    ///  - int32 + float64 = float64
+    /// Because an int32 cannot always be represented exactly in the
+    /// 24 bits of a float32 mantissa.
+    bool promote_integer_to_float = false;
+
+    /// Allow an unsigned integer of a given bit width to be promoted
+    /// to a signed integer that fits into the signed type:
+    /// uint + int16 = int16
+    /// When widening is needed, set promote_numeric_width to true:
+    /// uint16 + int16 = int32
+    bool promote_integer_sign = false;
+
+    /// Allow an integer, float, or decimal of a given bit width to be
+    /// promoted to an equivalent type of a greater bit width.
+    bool promote_numeric_width = false;
+
+    /// Allow strings to be promoted to binary types. Promotion of fixed size
+    /// binary types to variable sized formats, and binary to large binary,
+    /// and string to large string.
+    bool promote_binary = false;
+
+    /// Second to millisecond, Time32 to Time64, Time32(SECOND) to Time32(MILLI), etc
+    bool promote_temporal_unit = false;
+
+    /// Allow promotion from a list to a large-list and from a fixed-size list to a
+    /// variable sized list
+    bool promote_list = false;
+
+    /// Unify dictionary index types and dictionary value types.
+    bool promote_dictionary = false;
+
+    /// Allow merging ordered and non-ordered dictionaries.
+    /// The result will be ordered if and only if both inputs
+    /// are ordered.
+    bool promote_dictionary_ordered = false;
+
+    /// Get default options. Only NullType will be merged with other types.
     static MergeOptions Defaults() { return MergeOptions(); }
+    /// Get permissive options. All options are enabled, except
+    /// promote_dictionary_ordered.
+    static MergeOptions Permissive();
+    /// Get a human-readable representation of the options.
+    std::string ToString() const;
   };
 
   /// \brief Merge the current field with a field of the same name.
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index 3dbefdcf0c564..9ba8cf98dea4f 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -328,11 +328,11 @@ TEST(TestField, TestMerge) {
     auto null_field = field("f", null());
     Field::MergeOptions options;
     options.promote_nullability = false;
-    ASSERT_RAISES(Invalid, f->MergeWith(null_field, options));
-    ASSERT_RAISES(Invalid, null_field->MergeWith(f, options));
+    ASSERT_RAISES(TypeError, f->MergeWith(null_field, options));
+    ASSERT_RAISES(TypeError, null_field->MergeWith(f, options));
 
     // Also rejects fields with different nullability.
-    ASSERT_RAISES(Invalid,
+    ASSERT_RAISES(TypeError,
                   f->WithNullable(true)->MergeWith(f->WithNullable(false), options));
   }
   {
@@ -349,7 +349,7 @@ TEST(TestField, TestMerge) {
     ASSERT_TRUE(result->Equals(f->WithNullable(true)->WithMetadata(metadata2)));
   }
   {
-    // promote_nullability == true; merge a nullable field and a in-nullable field.
+    // promote_nullability == true; merge a nullable field and an in-nullable field.
     Field::MergeOptions options;
     options.promote_nullability = true;
     auto f1 = field("f", int32())->WithNullable(false);
@@ -840,7 +840,7 @@ TEST(TestSchemaBuilder, PolicyMerge) {
   AssertSchemaBuilderYield(builder, schema({f0_opt, f1}));
 
   // Unsupported merge with a different type
-  ASSERT_RAISES(Invalid, builder.AddField(f0_other));
+  ASSERT_RAISES(TypeError, builder.AddField(f0_other));
   // Builder should still contain state
   AssertSchemaBuilderYield(builder, schema({f0, f1}));
 
@@ -895,8 +895,8 @@ TEST(TestSchemaBuilder, Merge) {
   ASSERT_OK_AND_ASSIGN(schema, SchemaBuilder::Merge({s2, s3, s1}));
   AssertSchemaEqual(schema, ::arrow::schema({f1, f0_opt}));
 
-  ASSERT_RAISES(Invalid, SchemaBuilder::Merge({s3, broken}));
-  ASSERT_RAISES(Invalid, SchemaBuilder::AreCompatible({s3, broken}));
+  ASSERT_RAISES(TypeError, SchemaBuilder::Merge({s3, broken}));
+  ASSERT_RAISES(TypeError, SchemaBuilder::AreCompatible({s3, broken}));
 }
 
 class TestUnifySchemas : public TestSchema {
@@ -917,6 +917,159 @@ class TestUnifySchemas : public TestSchema {
           << lhs_field->ToString() << " vs " << rhs_field->ToString();
     }
   }
+
+  void CheckUnifyAsymmetric(
+      const std::shared_ptr<Field>& field1, const std::shared_ptr<Field>& field2,
+      const std::shared_ptr<Field>& expected,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    ARROW_SCOPED_TRACE("options: ", options);
+    ARROW_SCOPED_TRACE("field2: ", field2->ToString());
+    ARROW_SCOPED_TRACE("field1: ", field1->ToString());
+    ASSERT_OK_AND_ASSIGN(auto merged, field1->MergeWith(field2, options));
+    AssertFieldEqual(merged, expected);
+  }
+
+  void CheckPromoteTo(
+      const std::shared_ptr<Field>& field1, const std::shared_ptr<Field>& field2,
+      const std::shared_ptr<Field>& expected,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    CheckUnifyAsymmetric(field1, field2, expected, options);
+    CheckUnifyAsymmetric(field2, field1, expected, options);
+  }
+
+  void CheckUnifyFailsInvalid(
+      const std::shared_ptr<Field>& field1, const std::shared_ptr<Field>& field2,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults(),
+      const std::string& match_message = "") {
+    ARROW_SCOPED_TRACE("options: ", options);
+    ARROW_SCOPED_TRACE("field2: ", field2->ToString());
+    ARROW_SCOPED_TRACE("field1: ", field1->ToString());
+    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, ::testing::HasSubstr(match_message),
+                                    field1->MergeWith(field2, options));
+    EXPECT_RAISES_WITH_MESSAGE_THAT(Invalid, ::testing::HasSubstr(match_message),
+                                    field2->MergeWith(field1, options));
+  }
+
+  void CheckUnifyFailsTypeError(
+      const std::shared_ptr<Field>& field1, const std::shared_ptr<Field>& field2,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults(),
+      const std::string& match_message = "") {
+    ARROW_SCOPED_TRACE("options: ", options);
+    ARROW_SCOPED_TRACE("field2: ", field2->ToString());
+    ARROW_SCOPED_TRACE("field1: ", field1->ToString());
+    ASSERT_RAISES(TypeError, field1->MergeWith(field2, options));
+    ASSERT_RAISES(TypeError, field2->MergeWith(field1, options));
+    EXPECT_RAISES_WITH_MESSAGE_THAT(TypeError, ::testing::HasSubstr(match_message),
+                                    field1->MergeWith(field2, options));
+    EXPECT_RAISES_WITH_MESSAGE_THAT(TypeError, ::testing::HasSubstr(match_message),
+                                    field2->MergeWith(field1, options));
+  }
+
+  void CheckPromoteTo(
+      const std::shared_ptr<DataType>& left, const std::shared_ptr<DataType>& right,
+      const std::shared_ptr<DataType>& expected,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    auto field1 = field("a", left);
+    auto field2 = field("a", right);
+    CheckPromoteTo(field1, field2, field("a", expected), options);
+
+    field1 = field("a", left, /*nullable=*/false);
+    field2 = field("a", right, /*nullable=*/false);
+    CheckPromoteTo(field1, field2, field("a", expected, /*nullable=*/false), options);
+
+    field1 = field("a", left);
+    field2 = field("a", right, /*nullable=*/false);
+    CheckPromoteTo(field1, field2, field("a", expected, /*nullable=*/true), options);
+
+    field1 = field("a", left, /*nullable=*/false);
+    field2 = field("a", right);
+    CheckPromoteTo(field1, field2, field("a", expected, /*nullable=*/true), options);
+  }
+
+  void CheckUnifyAsymmetric(
+      const std::shared_ptr<DataType>& left, const std::shared_ptr<DataType>& right,
+      const std::shared_ptr<DataType>& expected,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    auto field1 = field("a", left);
+    auto field2 = field("a", right);
+    CheckUnifyAsymmetric(field1, field2, field("a", expected), options);
+
+    field1 = field("a", left, /*nullable=*/false);
+    field2 = field("a", right, /*nullable=*/false);
+    CheckUnifyAsymmetric(field1, field2, field("a", expected, /*nullable=*/false),
+                         options);
+
+    field1 = field("a", left);
+    field2 = field("a", right, /*nullable=*/false);
+    CheckUnifyAsymmetric(field1, field2, field("a", expected, /*nullable=*/true),
+                         options);
+
+    field1 = field("a", left, /*nullable=*/false);
+    field2 = field("a", right);
+    CheckUnifyAsymmetric(field1, field2, field("a", expected, /*nullable=*/true),
+                         options);
+  }
+
+  void CheckPromoteTo(
+      const std::shared_ptr<DataType>& from,
+      const std::vector<std::shared_ptr<DataType>>& to,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    for (const auto& ty : to) {
+      CheckPromoteTo(from, ty, ty, options);
+    }
+  }
+
+  void CheckUnifyFailsInvalid(
+      const std::shared_ptr<DataType>& left, const std::shared_ptr<DataType>& right,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    auto field1 = field("a", left);
+    auto field2 = field("a", right);
+    CheckUnifyFailsInvalid(field1, field2, options);
+  }
+
+  void CheckUnifyFailsInvalid(
+      const std::shared_ptr<DataType>& from,
+      const std::vector<std::shared_ptr<DataType>>& to,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    for (const auto& ty : to) {
+      CheckUnifyFailsInvalid(from, ty, options);
+    }
+  }
+
+  void CheckUnifyFailsInvalid(
+      const std::vector<std::shared_ptr<DataType>>& from,
+      const std::vector<std::shared_ptr<DataType>>& to,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    for (const auto& ty : from) {
+      CheckUnifyFailsInvalid(ty, to, options);
+    }
+  }
+
+  void CheckUnifyFailsTypeError(
+      const std::shared_ptr<DataType>& left, const std::shared_ptr<DataType>& right,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    auto field1 = field("a", left);
+    auto field2 = field("a", right);
+    CheckUnifyFailsTypeError(field1, field2, options);
+  }
+
+  void CheckUnifyFailsTypeError(
+      const std::shared_ptr<DataType>& from,
+      const std::vector<std::shared_ptr<DataType>>& to,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    for (const auto& ty : to) {
+      CheckUnifyFailsTypeError(from, ty, options);
+    }
+  }
+
+  void CheckUnifyFailsTypeError(
+      const std::vector<std::shared_ptr<DataType>>& from,
+      const std::vector<std::shared_ptr<DataType>>& to,
+      const Field::MergeOptions& options = Field::MergeOptions::Defaults()) {
+    for (const auto& ty : from) {
+      CheckUnifyFailsTypeError(ty, to, options);
+    }
+  }
 };
 
 TEST_F(TestUnifySchemas, EmptyInput) { ASSERT_RAISES(Invalid, UnifySchemas({})); }
@@ -1008,6 +1161,252 @@ TEST_F(TestUnifySchemas, MoreSchemas) {
                         utf8_field->WithNullable(true)}));
 }
 
+TEST_F(TestUnifySchemas, Numeric) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_numeric_width = true;
+  options.promote_integer_to_float = true;
+  options.promote_integer_sign = true;
+  CheckPromoteTo(
+      uint8(),
+      {uint16(), int16(), uint32(), int32(), uint64(), int64(), float32(), float64()},
+      options);
+  CheckPromoteTo(int8(), {int16(), int32(), int64(), float32(), float64()}, options);
+  CheckPromoteTo(uint16(), {uint32(), int32(), uint64(), int64(), float32(), float64()},
+                 options);
+  CheckPromoteTo(int16(), {int32(), int64(), float32(), float64()}, options);
+  CheckPromoteTo(uint32(), {uint64(), int64(), float64()}, options);
+  CheckPromoteTo(int32(), {int64(), float64()}, options);
+  CheckPromoteTo(uint64(), {int64(), float64()}, options);
+  CheckPromoteTo(int64(), {float64()}, options);
+  CheckPromoteTo(float16(), {float32(), float64()}, options);
+  CheckPromoteTo(float32(), {float64()}, options);
+  CheckPromoteTo(uint64(), float32(), float64(), options);
+  CheckPromoteTo(int64(), float32(), float64(), options);
+
+  options.promote_integer_sign = false;
+  CheckPromoteTo(uint8(), {uint16(), uint32(), uint64()}, options);
+  CheckPromoteTo(int8(), {int16(), int32(), int64()}, options);
+  CheckUnifyFailsTypeError(uint8(), {int8(), int16(), int32(), int64()}, options);
+  CheckPromoteTo(uint16(), {uint32(), uint64()}, options);
+  CheckPromoteTo(int16(), {int32(), int64()}, options);
+  CheckUnifyFailsTypeError(uint16(), {int16(), int32(), int64()}, options);
+  CheckPromoteTo(uint32(), {uint64()}, options);
+  CheckPromoteTo(int32(), {int64()}, options);
+  CheckUnifyFailsTypeError(uint32(), {int32(), int64()}, options);
+  CheckUnifyFailsTypeError(uint64(), {int64()}, options);
+
+  options.promote_integer_sign = true;
+  options.promote_integer_to_float = false;
+  CheckUnifyFailsTypeError(IntTypes(), FloatingPointTypes(), options);
+
+  options.promote_integer_to_float = true;
+  options.promote_numeric_width = false;
+  CheckUnifyFailsTypeError(int8(), {int16(), int32(), int64()}, options);
+  CheckUnifyFailsTypeError(int16(), {int32(), int64()}, options);
+  CheckUnifyFailsTypeError(int32(), {int64()}, options);
+  CheckUnifyFailsTypeError(int32(), {float16(), float32()}, options);
+  CheckPromoteTo(int32(), {float64()}, options);
+  CheckPromoteTo(int64(), {float64()}, options);
+
+  CheckPromoteTo(uint8(), int8(), int16(), options);
+  CheckPromoteTo(uint16(), int8(), int32(), options);
+  CheckPromoteTo(uint32(), int8(), int64(), options);
+  CheckPromoteTo(uint32(), int32(), int64(), options);
+}
+
+TEST_F(TestUnifySchemas, Decimal) {
+  auto options = Field::MergeOptions::Defaults();
+
+  options.promote_decimal_to_float = true;
+  CheckPromoteTo(decimal128(3, 2), {float32(), float64()}, options);
+  CheckPromoteTo(decimal256(3, 2), {float32(), float64()}, options);
+
+  options.promote_integer_to_decimal = true;
+  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(12, 2), options);
+  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(10, 0), options);
+
+  options.promote_decimal = true;
+  CheckPromoteTo(decimal128(3, 2), decimal128(5, 2), decimal128(5, 2), options);
+  CheckPromoteTo(decimal128(3, 2), decimal128(5, 3), decimal128(5, 3), options);
+  CheckPromoteTo(decimal128(3, 2), decimal128(5, 1), decimal128(6, 2), options);
+  CheckPromoteTo(decimal128(3, 2), decimal128(5, -2), decimal128(9, 2), options);
+  CheckPromoteTo(decimal128(3, -2), decimal128(5, -2), decimal128(5, -2), options);
+  CheckPromoteTo(decimal128(38, 10), decimal128(38, 5), decimal256(43, 10), options);
+
+  CheckPromoteTo(decimal256(3, 2), decimal256(5, 2), decimal256(5, 2), options);
+  CheckPromoteTo(decimal256(3, 2), decimal256(5, 3), decimal256(5, 3), options);
+  CheckPromoteTo(decimal256(3, 2), decimal256(5, 1), decimal256(6, 2), options);
+  CheckPromoteTo(decimal256(3, 2), decimal256(5, -2), decimal256(9, 2), options);
+  CheckPromoteTo(decimal256(3, -2), decimal256(5, -2), decimal256(5, -2), options);
+
+  // int32() is essentially decimal128(10, 0)
+  CheckPromoteTo(int32(), decimal128(3, 2), decimal128(12, 2), options);
+  CheckPromoteTo(int32(), decimal128(3, -2), decimal128(10, 0), options);
+  CheckPromoteTo(int64(), decimal128(38, 37), decimal256(56, 37), options);
+
+  CheckUnifyFailsTypeError(decimal256(1, 0), decimal128(1, 0), options);
+
+  options.promote_numeric_width = true;
+  CheckPromoteTo(decimal128(3, 2), decimal256(5, 2), decimal256(5, 2), options);
+  CheckPromoteTo(int32(), decimal128(38, 37), decimal256(47, 37), options);
+  CheckUnifyFailsInvalid(decimal128(38, 10), decimal256(76, 5), options);
+
+  CheckUnifyFailsInvalid(int64(), decimal256(76, 75), options);
+}
+
+TEST_F(TestUnifySchemas, Temporal) {
+  auto options = Field::MergeOptions::Defaults();
+
+  options.promote_temporal_unit = true;
+  CheckPromoteTo(date32(), {date64()}, options);
+
+  CheckPromoteTo(
+      time32(TimeUnit::SECOND),
+      {time32(TimeUnit::MILLI), time64(TimeUnit::MICRO), time64(TimeUnit::NANO)},
+      options);
+  CheckPromoteTo(time32(TimeUnit::MILLI),
+                 {time64(TimeUnit::MICRO), time64(TimeUnit::NANO)}, options);
+  CheckPromoteTo(time64(TimeUnit::MICRO), {time64(TimeUnit::NANO)}, options);
+
+  CheckPromoteTo(
+      duration(TimeUnit::SECOND),
+      {duration(TimeUnit::MILLI), duration(TimeUnit::MICRO), duration(TimeUnit::NANO)},
+      options);
+  CheckPromoteTo(duration(TimeUnit::MILLI),
+                 {duration(TimeUnit::MICRO), duration(TimeUnit::NANO)}, options);
+  CheckPromoteTo(duration(TimeUnit::MICRO), {duration(TimeUnit::NANO)}, options);
+
+  CheckPromoteTo(
+      timestamp(TimeUnit::SECOND),
+      {timestamp(TimeUnit::MILLI), timestamp(TimeUnit::MICRO), timestamp(TimeUnit::NANO)},
+      options);
+  CheckPromoteTo(timestamp(TimeUnit::MILLI),
+                 {timestamp(TimeUnit::MICRO), timestamp(TimeUnit::NANO)}, options);
+  CheckPromoteTo(timestamp(TimeUnit::MICRO), {timestamp(TimeUnit::NANO)}, options);
+
+  CheckUnifyFailsTypeError(timestamp(TimeUnit::SECOND),
+                           timestamp(TimeUnit::SECOND, "UTC"), options);
+  CheckUnifyFailsTypeError(timestamp(TimeUnit::SECOND, "America/New_York"),
+                           timestamp(TimeUnit::SECOND, "UTC"), options);
+
+  options.promote_temporal_unit = false;
+  CheckUnifyFailsTypeError(timestamp(TimeUnit::MICRO), timestamp(TimeUnit::NANO),
+                           options);
+}
+
+TEST_F(TestUnifySchemas, Binary) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_binary = true;
+  CheckPromoteTo(utf8(), {large_utf8(), binary(), large_binary()}, options);
+  CheckPromoteTo(binary(), {large_binary()}, options);
+  CheckPromoteTo(fixed_size_binary(2), {fixed_size_binary(2), binary(), large_binary()},
+                 options);
+  CheckPromoteTo(fixed_size_binary(2), fixed_size_binary(4), binary(), options);
+
+  options.promote_binary = false;
+  CheckUnifyFailsTypeError({utf8(), binary()}, {large_utf8(), large_binary()});
+  CheckUnifyFailsTypeError(fixed_size_binary(2), BaseBinaryTypes());
+  CheckUnifyFailsTypeError(utf8(), {binary(), large_binary(), fixed_size_binary(2)});
+}
+
+TEST_F(TestUnifySchemas, List) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_list = true;
+
+  CheckPromoteTo(fixed_size_list(int8(), 2), fixed_size_list(int8(), 3), list(int8()));
+
+  CheckPromoteTo(list(int8()), {large_list(int8())}, options);
+  CheckPromoteTo(fixed_size_list(int8(), 2), {list(int8()), large_list(int8())}, options);
+
+  options.promote_numeric_width = true;
+  CheckPromoteTo(list(int8()), {list(int16()), list(int32()), list(int64())}, options);
+  CheckPromoteTo(
+      fixed_size_list(int8(), 2),
+      {fixed_size_list(int16(), 2), list(int16()), list(int32()), list(int64())},
+      options);
+  CheckPromoteTo(fixed_size_list(int16(), 2), list(int8()), list(int16()), options);
+
+  auto ty = list(field("foo", int8(), /*nullable=*/false));
+  CheckUnifyAsymmetric(ty, list(int8()), list(field("foo", int8(), /*nullable=*/true)),
+                       options);
+  CheckUnifyAsymmetric(ty, list(field("bar", int16(), /*nullable=*/false)),
+                       list(field("foo", int16(), /*nullable=*/false)), options);
+
+  options.promote_list = false;
+  CheckUnifyFailsTypeError(list(int8()), large_list(int8()));
+}
+
+TEST_F(TestUnifySchemas, Map) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_numeric_width = true;
+
+  CheckPromoteTo(map(int8(), int32()),
+                 {map(int8(), int64()), map(int16(), int32()), map(int64(), int64())},
+                 options);
+
+  // Do not test field names, since MapType intentionally ignores them in comparisons
+  // See ARROW-7173, ARROW-14999
+  auto ty = map(int8(), field("value", int32(), /*nullable=*/false));
+  CheckPromoteTo(ty, map(int8(), int32()),
+                 map(int8(), field("value", int32(), /*nullable=*/true)), options);
+  CheckPromoteTo(ty, map(int16(), field("value", int64(), /*nullable=*/false)),
+                 map(int16(), field("value", int64(), /*nullable=*/false)), options);
+}
+
+TEST_F(TestUnifySchemas, Struct) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_numeric_width = true;
+  options.promote_binary = true;
+
+  CheckPromoteTo(struct_({}), struct_({field("a", int8())}),
+                 struct_({field("a", int8())}), options);
+
+  CheckUnifyAsymmetric(struct_({field("b", utf8())}), struct_({field("a", int8())}),
+                       struct_({field("b", utf8()), field("a", int8())}), options);
+  CheckUnifyAsymmetric(struct_({field("a", int8())}), struct_({field("b", utf8())}),
+                       struct_({field("a", int8()), field("b", utf8())}), options);
+
+  CheckPromoteTo(struct_({field("b", utf8())}), struct_({field("b", binary())}),
+                 struct_({field("b", binary())}), options);
+
+  CheckUnifyAsymmetric(
+      struct_({field("a", int8()), field("b", utf8()), field("a", int64())}),
+      struct_({field("b", binary())}),
+      struct_({field("a", int8()), field("b", binary()), field("a", int64())}), options);
+
+  ASSERT_RAISES(
+      Invalid,
+      field("foo", struct_({field("a", int8()), field("b", utf8()), field("a", int64())}))
+          ->MergeWith(field("foo", struct_({field("a", int64())})), options));
+}
+
+TEST_F(TestUnifySchemas, Dictionary) {
+  auto options = Field::MergeOptions::Defaults();
+  options.promote_dictionary = true;
+  options.promote_binary = true;
+
+  CheckPromoteTo(dictionary(int8(), utf8()),
+                 {
+                     dictionary(int64(), utf8()),
+                     dictionary(int8(), large_utf8()),
+                 },
+                 options);
+  CheckPromoteTo(dictionary(int64(), utf8()), dictionary(int8(), large_utf8()),
+                 dictionary(int64(), large_utf8()), options);
+  CheckPromoteTo(dictionary(int8(), utf8(), /*ordered=*/true),
+                 {
+                     dictionary(int64(), utf8(), /*ordered=*/true),
+                     dictionary(int8(), large_utf8(), /*ordered=*/true),
+                 },
+                 options);
+  CheckUnifyFailsTypeError(dictionary(int8(), utf8()),
+                           dictionary(int8(), utf8(), /*ordered=*/true), options);
+
+  options.promote_dictionary_ordered = true;
+  CheckPromoteTo(dictionary(int8(), utf8()), dictionary(int8(), utf8(), /*ordered=*/true),
+                 dictionary(int8(), utf8(), /*ordered=*/false), options);
+}
+
 TEST_F(TestUnifySchemas, IncompatibleTypes) {
   auto int32_field = field("f", int32());
   auto uint8_field = field("f", uint8(), false);
@@ -1015,7 +1414,7 @@ TEST_F(TestUnifySchemas, IncompatibleTypes) {
   auto schema1 = schema({int32_field});
   auto schema2 = schema({uint8_field});
 
-  ASSERT_RAISES(Invalid, UnifySchemas({schema1, schema2}));
+  ASSERT_RAISES(TypeError, UnifySchemas({schema1, schema2}));
 }
 
 TEST_F(TestUnifySchemas, DuplicateFieldNames) {
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index fdceca00a3f39..bcbde23ae4a4b 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -1132,6 +1132,36 @@ constexpr bool is_temporal(Type::type type_id) {
   return false;
 }
 
+/// \brief Check for a time type
+///
+/// \param[in] type_id the type-id to check
+/// \return whether type-id is a primitive type one
+constexpr bool is_time(Type::type type_id) {
+  switch (type_id) {
+    case Type::TIME32:
+    case Type::TIME64:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
+/// \brief Check for a date type
+///
+/// \param[in] type_id the type-id to check
+/// \return whether type-id is a primitive type one
+constexpr bool is_date(Type::type type_id) {
+  switch (type_id) {
+    case Type::DATE32:
+    case Type::DATE64:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
 /// \brief Check for an interval type
 ///
 /// \param[in] type_id the type-id to check
@@ -1195,6 +1225,22 @@ constexpr bool is_var_length_list(Type::type type_id) {
   return false;
 }
 
+/// \brief Check for a list type
+///
+/// \param[in] type_id the type-id to check
+/// \return whether type-id is a list type one
+constexpr bool is_list(Type::type type_id) {
+  switch (type_id) {
+    case Type::LIST:
+    case Type::LARGE_LIST:
+    case Type::FIXED_SIZE_LIST:
+      return true;
+    default:
+      break;
+  }
+  return false;
+}
+
 /// \brief Check for a list-like type
 ///
 /// \param[in] type_id the type-id to check
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index 482a6e91ba929..ad79c0edcd8a1 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -409,12 +409,16 @@ cdef extern from "arrow/api.h" namespace "arrow" nogil:
         const shared_ptr[CDataType]& value_type()
 
     cdef cppclass CField" arrow::Field":
-        cppclass CMergeOptions "arrow::Field::MergeOptions":
+        cppclass CMergeOptions "MergeOptions":
+            CMergeOptions()
             c_bool promote_nullability
 
             @staticmethod
             CMergeOptions Defaults()
 
+            @staticmethod
+            CMergeOptions Permissive()
+
         const c_string& name()
         shared_ptr[CDataType] type()
         c_bool nullable()
@@ -514,7 +518,8 @@ cdef extern from "arrow/api.h" namespace "arrow" nogil:
         shared_ptr[CSchema] RemoveMetadata()
 
     CResult[shared_ptr[CSchema]] UnifySchemas(
-        const vector[shared_ptr[CSchema]]& schemas)
+        const vector[shared_ptr[CSchema]]& schemas,
+        CField.CMergeOptions field_merge_options)
 
     cdef cppclass PrettyPrintOptions:
         PrettyPrintOptions()
diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index 36601130b3f12..72af5a2deea9c 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -5024,16 +5024,16 @@ def table(data, names=None, schema=None, metadata=None, nthreads=None):
             "Expected pandas DataFrame, python dictionary or list of arrays")
 
 
-def concat_tables(tables, c_bool promote=False, MemoryPool memory_pool=None):
+def concat_tables(tables, MemoryPool memory_pool=None, str promote_options="none", **kwargs):
     """
     Concatenate pyarrow.Table objects.
 
-    If promote==False, a zero-copy concatenation will be performed. The schemas
+    If promote_options="none", a zero-copy concatenation will be performed. The schemas
     of all the Tables must be the same (except the metadata), otherwise an
     exception will be raised. The result Table will share the metadata with the
     first table.
 
-    If promote==True, any null type arrays will be casted to the type of other
+    If promote_options="default", any null type arrays will be casted to the type of other
     arrays in the column of the same name. If a table is missing a particular
     field, null values of the appropriate type will be generated to take the
     place of the missing field. The new schema will share the metadata with the
@@ -5041,14 +5041,18 @@ def concat_tables(tables, c_bool promote=False, MemoryPool memory_pool=None):
     first table which has the field defined. Note that type promotions may
     involve additional allocations on the given ``memory_pool``.
 
+    If promote_options="permissive", the behavior of default plus types will be promoted
+    to the common denominator that fits all the fields.
+
     Parameters
     ----------
     tables : iterable of pyarrow.Table objects
         Pyarrow tables to concatenate into a single Table.
-    promote : bool, default False
-        If True, concatenate tables with null-filling and null type promotion.
     memory_pool : MemoryPool, default None
         For memory allocations, if required, otherwise use default pool.
+    promote_options : str, default none
+        Accepts strings "none", "default" and "permissive".
+    **kwargs : dict, optional
 
     Examples
     --------
@@ -5078,11 +5082,24 @@ def concat_tables(tables, c_bool promote=False, MemoryPool memory_pool=None):
         CConcatenateTablesOptions options = (
             CConcatenateTablesOptions.Defaults())
 
+    if "promote" in kwargs:
+        warnings.warn(
+            "promote has been superseded by mode='default'.", FutureWarning, stacklevel=2)
+        if kwargs['promote'] is True:
+            promote_options = "default"
+
     for table in tables:
         c_tables.push_back(table.sp_table)
 
+    if promote_options == "permissive":
+        options.field_merge_options = CField.CMergeOptions.Permissive()
+    elif promote_options in {"default", "none"}:
+        options.field_merge_options = CField.CMergeOptions.Defaults()
+    else:
+        raise ValueError(f"Invalid promote options: {promote_options}")
+
     with nogil:
-        options.unify_schemas = promote
+        options.unify_schemas = promote_options != "none"
         c_result_table = GetResultValue(
             ConcatenateTables(c_tables, options, pool))
 
diff --git a/python/pyarrow/tests/test_dataset.py b/python/pyarrow/tests/test_dataset.py
index 671405d1ee6a0..6f3b54b0cd681 100644
--- a/python/pyarrow/tests/test_dataset.py
+++ b/python/pyarrow/tests/test_dataset.py
@@ -2921,7 +2921,7 @@ def test_union_dataset_from_other_datasets(tempdir, multisourcefs):
     _, path = _create_single_file(tempdir, table=table)
     child4 = ds.dataset(path)
 
-    with pytest.raises(pa.ArrowInvalid, match='Unable to merge'):
+    with pytest.raises(pa.ArrowTypeError, match='Unable to merge'):
         ds.dataset([child1, child4])
 
 
diff --git a/python/pyarrow/tests/test_schema.py b/python/pyarrow/tests/test_schema.py
index e28e0ac445ef8..fa75fcea30db7 100644
--- a/python/pyarrow/tests/test_schema.py
+++ b/python/pyarrow/tests/test_schema.py
@@ -717,13 +717,16 @@ def test_schema_merge():
     ])
     assert result.equals(expected)
 
-    with pytest.raises(pa.ArrowInvalid):
+    with pytest.raises(pa.ArrowTypeError):
         pa.unify_schemas([b, d])
 
     # ARROW-14002: Try with tuple instead of list
     result = pa.unify_schemas((a, b, c))
     assert result.equals(expected)
 
+    result = pa.unify_schemas([b, d], promote_options="permissive")
+    assert result.equals(d)
+
     # raise proper error when passing a non-Schema value
     with pytest.raises(TypeError):
         pa.unify_schemas([a, 1])
diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py
index b9e0d692196fb..6b48633b91f8e 100644
--- a/python/pyarrow/tests/test_table.py
+++ b/python/pyarrow/tests/test_table.py
@@ -1330,6 +1330,23 @@ def test_concat_tables():
     assert result.equals(expected)
 
 
+def test_concat_tables_permissive():
+    t1 = pa.Table.from_arrays([list(range(10))], names=('a',))
+    t2 = pa.Table.from_arrays([list(('a', 'b', 'c'))], names=('a',))
+
+    with pytest.raises(
+            pa.ArrowTypeError,
+            match="Unable to merge: Field a has incompatible types: int64 vs string"):
+        _ = pa.concat_tables([t1, t2], promote_options="permissive")
+
+
+def test_concat_tables_invalid_option():
+    t = pa.Table.from_arrays([list(range(10))], names=('a',))
+
+    with pytest.raises(ValueError, match="Invalid promote options: invalid"):
+        pa.concat_tables([t, t], promote_options="invalid")
+
+
 def test_concat_tables_none_table():
     # ARROW-11997
     with pytest.raises(AttributeError):
@@ -1359,19 +1376,51 @@ def test_concat_tables_with_different_schema_metadata():
     assert table2.schema.equals(table3.schema)
 
 
+def test_concat_tables_with_promote_option():
+    t1 = pa.Table.from_arrays(
+        [pa.array([1, 2], type=pa.int64())], ["int64_field"])
+    t2 = pa.Table.from_arrays(
+        [pa.array([1.0, 2.0], type=pa.float32())], ["float_field"])
+
+    with pytest.warns(FutureWarning):
+        result = pa.concat_tables([t1, t2], promote=True)
+
+    assert result.equals(pa.Table.from_arrays([
+        pa.array([1, 2, None, None], type=pa.int64()),
+        pa.array([None, None, 1.0, 2.0], type=pa.float32()),
+    ], ["int64_field", "float_field"]))
+
+    t1 = pa.Table.from_arrays(
+        [pa.array([1, 2], type=pa.int64())], ["f"])
+    t2 = pa.Table.from_arrays(
+        [pa.array([1, 2], type=pa.float32())], ["f"])
+
+    with pytest.raises(pa.ArrowInvalid, match="Schema at index 1 was different:"):
+        with pytest.warns(FutureWarning):
+            pa.concat_tables([t1, t2], promote=False)
+
+
 def test_concat_tables_with_promotion():
     t1 = pa.Table.from_arrays(
         [pa.array([1, 2], type=pa.int64())], ["int64_field"])
     t2 = pa.Table.from_arrays(
         [pa.array([1.0, 2.0], type=pa.float32())], ["float_field"])
 
-    result = pa.concat_tables([t1, t2], promote=True)
+    result = pa.concat_tables([t1, t2], promote_options="default")
 
     assert result.equals(pa.Table.from_arrays([
         pa.array([1, 2, None, None], type=pa.int64()),
         pa.array([None, None, 1.0, 2.0], type=pa.float32()),
     ], ["int64_field", "float_field"]))
 
+    t3 = pa.Table.from_arrays(
+        [pa.array([1, 2], type=pa.int32())], ["int64_field"])
+    result = pa.concat_tables(
+        [t1, t3], promote_options="permissive")
+    assert result.equals(pa.Table.from_arrays([
+        pa.array([1, 2, 1, 2], type=pa.int64()),
+    ], ["int64_field"]))
+
 
 def test_concat_tables_with_promotion_error():
     t1 = pa.Table.from_arrays(
@@ -1379,8 +1428,8 @@ def test_concat_tables_with_promotion_error():
     t2 = pa.Table.from_arrays(
         [pa.array([1, 2], type=pa.float32())], ["f"])
 
-    with pytest.raises(pa.ArrowInvalid):
-        pa.concat_tables([t1, t2], promote=True)
+    with pytest.raises(pa.ArrowTypeError, match="Unable to merge:"):
+        pa.concat_tables([t1, t2], promote_options="default")
 
 
 def test_table_negative_indexing():
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index bd34726adb0db..764cb8e7b5d8b 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -3154,13 +3154,13 @@ cdef class Schema(_Weakrefable):
         return self.__str__()
 
 
-def unify_schemas(schemas):
+def unify_schemas(schemas, *, promote_options="default"):
     """
     Unify schemas by merging fields by name.
 
     The resulting schema will contain the union of fields from all schemas.
     Fields with the same name will be merged. Note that two fields with
-    different types will fail merging.
+    different types will fail merging by default.
 
     - The unified field will inherit the metadata from the schema where
         that field is first defined.
@@ -3174,6 +3174,10 @@ def unify_schemas(schemas):
     ----------
     schemas : list of Schema
         Schemas to merge into a single one.
+    promote_options : str, default default
+        Accepts strings "default" and "permissive".
+        Default: null and only null can be unified with another type.
+        Permissive: types are promoted to the greater common denominator.
 
     Returns
     -------
@@ -3187,12 +3191,22 @@ def unify_schemas(schemas):
     """
     cdef:
         Schema schema
+        CField.CMergeOptions c_options
         vector[shared_ptr[CSchema]] c_schemas
     for schema in schemas:
         if not isinstance(schema, Schema):
             raise TypeError("Expected Schema, got {}".format(type(schema)))
         c_schemas.push_back(pyarrow_unwrap_schema(schema))
-    return pyarrow_wrap_schema(GetResultValue(UnifySchemas(c_schemas)))
+
+    if promote_options == "default":
+        c_options = CField.CMergeOptions.Defaults()
+    elif promote_options == "permissive":
+        c_options = CField.CMergeOptions.Permissive()
+    else:
+        raise ValueError(f"Invalid merge mode: {promote_options}")
+
+    return pyarrow_wrap_schema(
+        GetResultValue(UnifySchemas(c_schemas, c_options)))
 
 
 cdef dict _type_cache = {}

From c37059ad7b87f0cbb681f6388aca0e3f02860351 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 10 Oct 2023 10:29:24 -0400
Subject: [PATCH 512/749] GH-38015: [MATLAB] Add `arrow.buffer.Buffer` class to
 the MATLAB Interface (#38020)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

To unblock use cases that are not satisfied by the default Arrow -> MATLAB conversions (i.e. the `toMATLAB()` on `arrow.array.Array`), we would like expose the underlying Arrow data representation as a property on `arrow.array.Array`. One possible name for this property would be `DataLayout`, which would be an `arrow.array.DataLayout` object. Note, this class does not yet exist, so we would have to add it.

For example, the `DataLayout` property for temporal array types would return an object of the following class type:

```matlab
classdef TemporalDataLayout < arrow.array.DataLayout
    properties
       Values % an arrow.array.Int32Array or an arrow.array.Int64Array
       Valid  % an arrow.buffer.Buffer
    end
end
```

However, the `Valid` property on this class would need to be an `arrow.buffer.Buffer` object, which does not yet exist in the MATLAB interface.  Therefore, it would be helpful to first add the `arrow.buffer.Buffer` class before adding the `DataLayout` property/class hierarchy. It's worth mentioning that adding `arrow.buffer.Buffer` will open up additional advanced use cases in the future.

### What changes are included in this PR?

Added `arrow.buffer.Buffer` MATLAB class.

*Properties of `arrow.buffer.Buffer`*
 1. `NumBytes` - a  scalar `int64` value representing the size of the buffer in bytes.

*Methods of `arrow.buffer.Buffer`*
1. `toMATLAB` - returns the data in the buffer as `Nx1` `uint8` vector, where `N` is the number of bytes.
2. `fromMATLAB(data)` - Static method that creates an `arrow.buffer.Buffer` from a numeric array.

**Example:**
```matlab
>> dataIn = [1 2];
>> buffer = arrow.buffer.Buffer.fromMATLAB(dataIn)

buffer =

  Buffer with properties:

    NumBytes: 16

>> dataOut = toMATLAB(buffer)

dataOut =

  16×1 uint8 column vector

     0
     0
     0
     0
     0
     0
   240
    63
     0
     0
     0
     0
     0
     0
     0
    64

% Reinterpret bit pattern as a double array
>> toDouble = typecast(dataOut, "double")

toDouble =

     1
     2
```

### Are these changes tested?

Yes. Added a new test class called `tBuffer.m`

### Are there any user-facing changes?

Yes. Users can now create `arrow.buffer.Buffer` objects via the `fromMATLAB` static method. However, there's not much users can do with this object as of now. We implemented this class to facilitate adding `DataLayout` property to `arrow.array.Array`, as described in the **Rational for this change** section.

* Closes: #38015

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../cpp/arrow/matlab/buffer/proxy/buffer.cc   |  96 ++++++++
 .../cpp/arrow/matlab/buffer/proxy/buffer.h    |  46 ++++
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 matlab/src/matlab/+arrow/+buffer/Buffer.m     |  81 +++++++
 matlab/test/arrow/buffer/tBuffer.m            | 209 ++++++++++++++++++
 .../cmake/BuildMatlabArrowInterface.cmake     |   4 +-
 7 files changed, 438 insertions(+), 1 deletion(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.h
 create mode 100644 matlab/src/matlab/+arrow/+buffer/Buffer.m
 create mode 100644 matlab/test/arrow/buffer/tBuffer.m

diff --git a/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.cc b/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.cc
new file mode 100644
index 0000000000000..633b82d9fa127
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.cc
@@ -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.
+
+
+#include "arrow/matlab/buffer/proxy/buffer.h"
+#include "arrow/matlab/buffer/matlab_buffer.h"
+#include "arrow/matlab/error/error.h"
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::buffer::proxy {
+
+    Buffer::Buffer(std::shared_ptr<arrow::Buffer> buffer) : buffer{std::move(buffer)} {
+        REGISTER_METHOD(Buffer, getNumBytes);
+        REGISTER_METHOD(Buffer, isEqual);
+        REGISTER_METHOD(Buffer, toMATLAB);
+    }
+
+    libmexclass::proxy::MakeResult Buffer::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using BufferProxy = proxy::Buffer;
+        using MatlabBuffer = arrow::matlab::buffer::MatlabBuffer;
+
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::TypedArray<uint8_t> values_mda = opts[0]["Values"];
+        auto buffer = std::make_shared<MatlabBuffer>(values_mda);
+        return std::make_shared<BufferProxy>(std::move(buffer));
+    }
+
+    std::shared_ptr<arrow::Buffer> Buffer::unwrap() {
+        return buffer;
+    }
+
+    void Buffer::getNumBytes(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;        
+        auto num_bytes_mda = factory.createScalar(buffer->size());
+        context.outputs[0] = num_bytes_mda; 
+    }
+
+    void Buffer::isEqual(libmexclass::proxy::method::Context& context) { 
+        namespace mda = ::matlab::data;
+
+        bool is_equal = true;
+        const mda::TypedArray<uint64_t> buffer_proxy_ids = context.inputs[0];
+        for (const auto& buffer_proxy_id : buffer_proxy_ids) {
+            // Retrieve the Buffer proxy from the ProxyManager
+            auto proxy = libmexclass::proxy::ProxyManager::getProxy(buffer_proxy_id);
+            auto buffer_proxy = std::static_pointer_cast<proxy::Buffer>(proxy);
+            auto buffer_to_compare = buffer_proxy->unwrap();
+
+            if (!buffer->Equals(*buffer_to_compare)) {
+                is_equal = false;
+                break;
+            }
+        }
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(is_equal);
+    }
+
+    void Buffer::toMATLAB(libmexclass::proxy::method::Context& context) { 
+        namespace mda = ::matlab::data;
+
+        // If buffer->is_cpu() returns false, invoking buffer->data() may cause a crash.
+        // Avoid this potential crash by first invoking ViewOrCopy(buffer, memory_manager_device).
+        // This function tries to create a no-copy view of the buffer on the given memory
+        // manager device. If not possible, then ViewOrCopy copies the buffer's contents.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(
+            auto cpu_buffer, 
+            arrow::Buffer::ViewOrCopy(buffer, arrow::default_cpu_memory_manager()),
+            context, error::BUFFER_VIEW_OR_COPY_FAILED
+        );
+
+        const auto* data_begin = cpu_buffer->data();
+        const auto num_bytes = cpu_buffer->size();
+        // data_begin is a uint8_t*, so num_bytes is equal to the number of elements
+        const auto* data_end = data_begin + num_bytes;
+
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createArray<uint8_t>({static_cast<size_t>(num_bytes), 1}, data_begin, data_end);
+    }
+
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.h b/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.h
new file mode 100644
index 0000000000000..bb6dc5e4c5d2c
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/buffer/proxy/buffer.h
@@ -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.
+
+#pragma once
+
+#include "arrow/buffer.h"
+
+#include "libmexclass/proxy/Proxy.h"
+
+namespace arrow::matlab::buffer::proxy {
+
+class Buffer : public libmexclass::proxy::Proxy {
+    public:
+        Buffer(std::shared_ptr<arrow::Buffer> buffer);
+    
+        ~Buffer() {}
+
+        std::shared_ptr<arrow::Buffer> unwrap();
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+        void getNumBytes(libmexclass::proxy::method::Context& context);
+
+        void toMATLAB(libmexclass::proxy::method::Context& context);
+
+        void isEqual(libmexclass::proxy::method::Context& context);
+
+        std::shared_ptr<arrow::Buffer> buffer;
+};
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 347bc25b5f3a6..b8376c0a06ecb 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -198,4 +198,5 @@ namespace arrow::matlab::error {
     static const char* STRUCT_ARRAY_MAKE_FAILED = "arrow:array:StructArrayMakeFailed";
     static const char* INDEX_EMPTY_CONTAINER = "arrow:index:EmptyContainer";
     static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
+    static const char* BUFFER_VIEW_OR_COPY_FAILED = "arrow:buffer:ViewOrCopyFailed";
 }
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 62ed84fedcf6a..3091d248f8ca1 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -40,6 +40,7 @@
 #include "arrow/matlab/io/feather/proxy/reader.h"
 #include "arrow/matlab/io/csv/proxy/table_writer.h"
 #include "arrow/matlab/io/csv/proxy/table_reader.h"
+#include "arrow/matlab/buffer/proxy/buffer.h"
 
 #include "factory.h"
 
@@ -65,6 +66,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.Date32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date32Type>);
     REGISTER_PROXY(arrow.array.proxy.Date64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Date64Type>);
     REGISTER_PROXY(arrow.array.proxy.ChunkedArray  , arrow::matlab::array::proxy::ChunkedArray);
+    REGISTER_PROXY(arrow.buffer.proxy.Buffer       , arrow::matlab::buffer::proxy::Buffer);
     REGISTER_PROXY(arrow.tabular.proxy.RecordBatch , arrow::matlab::tabular::proxy::RecordBatch);
     REGISTER_PROXY(arrow.tabular.proxy.Table       , arrow::matlab::tabular::proxy::Table);
     REGISTER_PROXY(arrow.tabular.proxy.Schema      , arrow::matlab::tabular::proxy::Schema);
diff --git a/matlab/src/matlab/+arrow/+buffer/Buffer.m b/matlab/src/matlab/+arrow/+buffer/Buffer.m
new file mode 100644
index 0000000000000..6c46276810299
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+buffer/Buffer.m
@@ -0,0 +1,81 @@
+%BUFFER Represents a block of contiguous memory with a specified size.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Buffer < matlab.mixin.Scalar
+
+    properties (Dependent, GetAccess=public, SetAccess=private)
+        NumBytes
+    end
+
+    properties (Hidden, GetAccess=public, SetAccess=private)
+        Proxy
+    end
+
+    methods
+        function obj = Buffer(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.buffer.proxy.Buffer")}
+            end
+            import arrow.internal.proxy.validate
+            obj.Proxy = proxy;
+        end
+
+        function numBytes = get.NumBytes(obj)
+            numBytes = obj.Proxy.getNumBytes();
+        end
+
+        function data = toMATLAB(obj)
+            data = obj.Proxy.toMATLAB();
+        end
+
+        function tf = isequal(obj, varargin)
+            narginchk(2, inf);
+            tf = false;
+
+            bufferProxyIDs = zeros([1 numel(varargin)], "uint64");
+            for ii = 1:numel(varargin)
+                maybeBuffer = varargin{ii};
+                if ~isa(maybeBuffer, "arrow.buffer.Buffer")
+                    % If maybeBuffer is not an instance of
+                    % arrow.buffer.Buffer, return false early.
+                    return;
+                end
+                % Otherwise, extract the proxy ID associated with
+                % maybeBuffer.
+                bufferProxyIDs(ii) = maybeBuffer.Proxy.ID;
+            end
+
+            % Invoke the isEqual method on the Buffer Proxy class.
+            tf = obj.Proxy.isEqual(bufferProxyIDs);
+        end
+    end
+
+    methods (Static, Hidden)
+        function buffer = fromMATLAB(data)
+            arguments
+                data(:, 1) {mustBeNumeric, mustBeNonsparse, mustBeReal}
+            end
+
+            % Re-interpret bit pattern as uint8s without changing the
+            % underlying data.
+            data = typecast(data, "uint8");
+            args = struct(Values=data);
+            proxy = arrow.internal.proxy.create("arrow.buffer.proxy.Buffer", args);
+            buffer = arrow.buffer.Buffer(proxy);
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/buffer/tBuffer.m b/matlab/test/arrow/buffer/tBuffer.m
new file mode 100644
index 0000000000000..d58af2fc9d22d
--- /dev/null
+++ b/matlab/test/arrow/buffer/tBuffer.m
@@ -0,0 +1,209 @@
+%TBUFFER Unit tests for arrow.buffer.Buffer
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tBuffer < matlab.unittest.TestCase
+
+    methods (Test)
+        function Smoke(testCase)
+            import arrow.buffer.Buffer
+            
+            source = uint8([1 2 3]);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyInstanceOf(buffer, "arrow.buffer.Buffer");
+        end
+
+        function fromMATLABUInt8Scalar(testCase)
+            % Verifies fromMATLAB returns the expected arrow.buffer.Buffer
+            % instance when given a scalar uint8 value.
+
+            import arrow.buffer.Buffer
+            
+            source = uint8(20);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(1));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, source);
+        end
+
+        function fromMATLABFromEmptyUInt8(testCase)
+            % Verifies fromMATLAB returns the expected arrow.buffer.Buffer
+            % value when given an empty uint8 array.
+
+            import arrow.buffer.Buffer
+            
+            % Create buffer from 0x0 uint8 array
+            source = uint8.empty(0, 0);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(0));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, uint8.empty(0, 1));
+
+            % Create buffer from 0x1 uint8 array
+            source = uint8.empty(0, 1);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(0));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, uint8.empty(0, 1));
+
+            % Create buffer from 1x0 uint8 array
+            source = uint8.empty(1, 0);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(0));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, uint8.empty(0, 1));
+        end
+
+        function fromMATLABUInt8Vector(testCase)
+            % Verifies fromMATLAB returns the expected arrow.buffer.Buffer
+            % value when given a uint8 vector.
+
+            import arrow.buffer.Buffer
+            
+            % Create buffer from 1x3 uint8 array
+            source = uint8([3 9 27]);
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(3));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, uint8([3 9 27]'));
+
+            % Create buffer from 3x1 uint8 array
+            source =  uint8([3 9 27]');
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(3));
+            values = toMATLAB(buffer);
+            testCase.verifyEqual(values, uint8([3 9 27]'));
+        end
+
+        function fromMATLABDoubleVector(testCase)
+            % Verifies fromMATLAB returns the expected arrow.buffer.Buffer
+            % value when given a double vector.
+
+            import arrow.buffer.Buffer
+            
+            % Create buffer from 1x3 double array
+            source = [3 9 27];
+            buffer = Buffer.fromMATLAB(source);
+            % Since the input vector is a 1x3 double (i.e. 64-bit floating 
+            % point value)  array - each of the 3 elements takes up 8 bytes
+            % (3 elements * 8 bytes per element = 24 bytes).
+            testCase.verifyEqual(buffer.NumBytes, int64(24));
+            values = toMATLAB(buffer);
+            expected = typecast(source', "uint8");
+            testCase.verifyEqual(values, expected);
+            testCase.verifyEqual(typecast(values, "double"), source');
+
+            % Create buffer from 3x1 double array
+            source =  [3 9 27]';
+            buffer = Buffer.fromMATLAB(source);
+            testCase.verifyEqual(buffer.NumBytes, int64(24));
+            values = toMATLAB(buffer);
+            expected = typecast(source, "uint8");
+            testCase.verifyEqual(values, expected);
+            testCase.verifyEqual(typecast(values, "double"), source);
+        end
+
+        function fromMATLABNonNumericError(testCase)
+            % Verify fromMATLAB throws an error if given a non-numeric
+            % array as input.
+            import arrow.buffer.Buffer
+
+            fcn = @() Buffer.fromMATLAB(true);
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNumeric");
+
+            fcn = @() Buffer.fromMATLAB("A");
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNumeric");
+
+            fcn = @() Buffer.fromMATLAB(datetime(2023, 1, 1));
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNumeric");
+        end
+
+        function fromMATLABNonRealError(testCase)
+            % Verify fromMATLAB throws an error if given a complex
+            % numeric  array as input.
+            import arrow.buffer.Buffer
+
+            fcn = @() Buffer.fromMATLAB(10 + 3i);
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeReal");
+        end
+
+        function fromMATLABNonSparseError(testCase)
+            % Verify fromMATLAB throws an error if given a sparse
+            % numeric array as input.
+            import arrow.buffer.Buffer
+
+            fcn = @() Buffer.fromMATLAB(sparse(ones([5 1])));
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNonsparse");
+        end
+
+        function NumBytesNoSetter(testCase)
+            % Verifies the NumBytes property is not settable.
+
+            import arrow.buffer.Buffer
+
+            buffer = Buffer.fromMATLAB([1 2 3]);
+            fcn = @() setfield(buffer, "NumBytes", int64(1));
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function IsEqualTrue(testCase)
+            % Verifies two buffers are considered equal if
+            %   1. They have the same size (NumBytes)
+            %   2. They contain the same bytes
+
+            import arrow.buffer.Buffer
+
+            % Compare two non-empty buffers
+            buffer1 = Buffer.fromMATLAB([1 2 3]);
+            buffer2 = Buffer.fromMATLAB([1 2 3]);
+            testCase.verifyTrue(isequal(buffer1, buffer2));
+
+            % Compare two buffers, one of which was created from a double 
+            % array and the other created from a uint8 array. However, both
+            % arrays have the same bit pattern.
+            data = zeros([1 24], "uint8");
+            data([7 8 16 23 24]) = [240 63 64  8 64];
+            buffer3 = Buffer.fromMATLAB(data);
+            testCase.verifyTrue(isequal(buffer1, buffer3));
+
+            % Compare two empty buffers 
+            buffer4 = Buffer.fromMATLAB([]);
+            buffer5 = Buffer.fromMATLAB([]);
+            testCase.verifyTrue(isequal(buffer4, buffer5));
+
+            % Compare more than two buffers
+            testCase.verifyTrue(isequal(buffer1, buffer2, buffer3));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verifies two buffers are not considered equal if
+            %   1. They do not have the same size (NumBytes) OR
+            %   2. They do not contain the same bytes
+
+            import arrow.buffer.Buffer
+                
+            buffer1 = Buffer.fromMATLAB([1 2 3]);
+            buffer2 = Buffer.fromMATLAB([1 3 2]);
+            buffer3 = Buffer.fromMATLAB([1 2 3 4]);
+            testCase.verifyFalse(isequal(buffer1, buffer2));
+            testCase.verifyFalse(isequal(buffer1, buffer3));
+            testCase.verifyFalse(isequal(buffer1, buffer2, buffer3));
+
+            % Compare a buffer to a string
+            testCase.verifyFalse(isequal(buffer1, "A"));
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 149a688b27e15..50daab65324f4 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -73,7 +73,9 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/reader.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/csv/proxy/table_writer.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/csv/proxy/table_reader.cc"
-                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/index/validate.cc")
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/index/validate.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/buffer/proxy/buffer.cc")
+
 
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy")
 set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_FACTORY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/proxy/factory.cc")

From 907723663e6e20033d0c2fef4eb0f880daacdb09 Mon Sep 17 00:00:00 2001
From: Alexander Grueneberg <com.github@agrueneberg.info>
Date: Tue, 10 Oct 2023 17:08:33 +0200
Subject: [PATCH 513/749] MINOR: [Python] Fix typo: represenation ->
 representation (#38180)

Fix typo: represenation -> representation.

Authored-by: Alexander Grueneberg <git@agrueneberg.info>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/_parquet.pyx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/pyarrow/_parquet.pyx b/python/pyarrow/_parquet.pyx
index 50b4ed8e86e65..48091367b2ff8 100644
--- a/python/pyarrow/_parquet.pyx
+++ b/python/pyarrow/_parquet.pyx
@@ -74,7 +74,7 @@ cdef class Statistics(_Weakrefable):
 
     def to_dict(self):
         """
-        Get dictionary represenation of statistics.
+        Get dictionary representation of statistics.
 
         Returns
         -------
@@ -349,7 +349,7 @@ cdef class ColumnChunkMetaData(_Weakrefable):
 
     def to_dict(self):
         """
-        Get dictionary represenation of the column chunk metadata.
+        Get dictionary representation of the column chunk metadata.
 
         Returns
         -------
@@ -571,7 +571,7 @@ cdef class RowGroupMetaData(_Weakrefable):
 
     def to_dict(self):
         """
-        Get dictionary represenation of the row group metadata.
+        Get dictionary representation of the row group metadata.
 
         Returns
         -------
@@ -647,7 +647,7 @@ cdef class FileMetaData(_Weakrefable):
 
     def to_dict(self):
         """
-        Get dictionary represenation of the file metadata.
+        Get dictionary representation of the file metadata.
 
         Returns
         -------

From 8cdce281634a29b8f79fcc4725f7fad643fa6f7a Mon Sep 17 00:00:00 2001
From: Michael Lui <mikelui@users.noreply.github.com>
Date: Tue, 10 Oct 2023 12:59:36 -0400
Subject: [PATCH 514/749] GH-32439: [Python] Fix off by one bug when chunking
 nested structs (#37376)

### Rationale for this change

See: #32439

### What changes are included in this PR?

During conversion from Python to Arrow, when a struct's child hits a capacity error and chunking is triggered, this can leave the Finish'd chunk in an invalid state since the struct's length does not match the length of its children.

This change simply tries to Append the children first, and only if successful will Append the struct. This is safe because the order of Append'ing between the struct and its child is not specified. It is only specified that they must be consistent with each other.

This is per:

https://github.com/apache/arrow/blob/86b7a84c9317fa08222eb63f6930bbb54c2e6d0b/cpp/src/arrow/array/builder_nested.h#L507-L508

### Are these changes tested?

A unit test is added that would previously have an invalid data error.

```
>       tab = pa.Table.from_pandas(df)

pyarrow/tests/test_pandas.py:4970:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
pyarrow/table.pxi:3788: in pyarrow.lib.Table.from_pandas
    return cls.from_arrays(arrays, schema=schema)
pyarrow/table.pxi:3890: in pyarrow.lib.Table.from_arrays
    result.validate()
pyarrow/table.pxi:3170: in pyarrow.lib.Table.validate
    check_status(self.table.Validate())

# ...

FAILED pyarrow/tests/test_pandas.py::test_nested_chunking_valid - pyarrow.lib.ArrowInvalid: Column 0: In chunk 0: Invalid: List child array invalid: Invalid: Struct child array #0 has length smaller than expected for struct array (2 < 3)
```

NOTE: This unit test uses about 7GB of memory (max RSS) on my macbook pro. This might make CI challenging; I'm open to suggestions to limit it.

### Are there any user-facing changes?

No
* Closes: #32439

Lead-authored-by: Mike Lui <mikelui@meta.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../src/arrow/python/python_to_arrow.cc       | 16 ++++---
 python/pyarrow/tests/test_pandas.py           | 44 +++++++++++++++++++
 2 files changed, 54 insertions(+), 6 deletions(-)

diff --git a/python/pyarrow/src/arrow/python/python_to_arrow.cc b/python/pyarrow/src/arrow/python/python_to_arrow.cc
index 486bd840775b6..2143129356fd5 100644
--- a/python/pyarrow/src/arrow/python/python_to_arrow.cc
+++ b/python/pyarrow/src/arrow/python/python_to_arrow.cc
@@ -926,14 +926,14 @@ class PyStructConverter : public StructConverter<PyConverter, PyConverterTrait>
     }
     switch (input_kind_) {
       case InputKind::DICT:
-        RETURN_NOT_OK(this->struct_builder_->Append());
-        return AppendDict(value);
+        RETURN_NOT_OK(AppendDict(value));
+        return this->struct_builder_->Append();
       case InputKind::TUPLE:
-        RETURN_NOT_OK(this->struct_builder_->Append());
-        return AppendTuple(value);
+        RETURN_NOT_OK(AppendTuple(value));
+        return this->struct_builder_->Append();
       case InputKind::ITEMS:
-        RETURN_NOT_OK(this->struct_builder_->Append());
-        return AppendItems(value);
+        RETURN_NOT_OK(AppendItems(value));
+        return this->struct_builder_->Append();
       default:
         RETURN_NOT_OK(InferInputKind(value));
         return Append(value);
@@ -944,6 +944,10 @@ class PyStructConverter : public StructConverter<PyConverter, PyConverterTrait>
   Status Init(MemoryPool* pool) override {
     RETURN_NOT_OK((StructConverter<PyConverter, PyConverterTrait>::Init(pool)));
 
+    // This implementation will check the child values before appending itself,
+    // so no rewind is necessary
+    this->rewind_on_overflow_ = false;
+
     // Store the field names as a PyObjects for dict matching
     num_fields_ = this->struct_type_->num_fields();
     bytes_field_names_.reset(PyList_New(num_fields_));
diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index 0d01928f44734..62a9443953a3d 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -1691,6 +1691,7 @@ def test_auto_chunking_pandas_series_of_strings(self, char):
             'strings': [[v1]] * 20 + [[v2]] + [[b'x']]
         })
         arr = pa.array(df['strings'], from_pandas=True)
+        arr.validate(full=True)
         assert isinstance(arr, pa.ChunkedArray)
         assert arr.num_chunks == 2
         assert len(arr.chunk(0)) == 21
@@ -2381,6 +2382,7 @@ def test_auto_chunking_on_list_overflow(self):
             "b": range(n)
         })
         table = pa.Table.from_pandas(df)
+        table.validate(full=True)
 
         column_a = table[0]
         assert column_a.num_chunks == 2
@@ -2623,6 +2625,7 @@ def test_from_numpy_large(self):
         ty = pa.struct([pa.field('x', pa.float64()),
                         pa.field('y', pa.binary())])
         arr = pa.array(data, type=ty, from_pandas=True)
+        arr.validate(full=True)
         assert arr.num_chunks == 2
 
         def iter_chunked_array(arr):
@@ -2655,6 +2658,7 @@ def check(arr, data, mask=None):
         # Now with explicit mask
         mask = np.random.random_sample(n) < 0.2
         arr = pa.array(data, type=ty, mask=mask, from_pandas=True)
+        arr.validate(full=True)
         assert arr.num_chunks == 2
 
         check(arr, data, mask)
@@ -4826,6 +4830,7 @@ def test_roundtrip_nested_map_array_with_pydicts_sliced():
 
     def assert_roundtrip(series: pd.Series, data) -> None:
         array_roundtrip = pa.chunked_array(pa.Array.from_pandas(series, type=ty))
+        array_roundtrip.validate(full=True)
         assert data.equals(array_roundtrip)
 
     assert_roundtrip(series_default, chunked_array)
@@ -4944,3 +4949,42 @@ def test_array_conversion_for_datetime():
 
     result = arr.to_pandas()
     tm.assert_series_equal(result, series)
+
+
+@pytest.mark.large_memory
+def test_nested_chunking_valid():
+    # GH-32439: Chunking can cause arrays to be in invalid state
+    # when nested types are involved.
+    # Here we simply ensure we validate correctly.
+
+    def roundtrip(df, schema=None):
+        tab = pa.Table.from_pandas(df, schema=schema)
+        tab.validate(full=True)
+        # we expect to trigger chunking internally
+        # an assertion failure here may just mean this threshold has changed
+        num_chunks = tab.column(0).num_chunks
+        assert num_chunks > 1
+        tm.assert_frame_equal(tab.to_pandas(self_destruct=True,
+                                            maps_as_pydicts="strict"), df)
+
+    x = b"0" * 720000000
+    roundtrip(pd.DataFrame({"strings": [x, x, x]}))
+
+    struct = {"struct_field": x}
+    roundtrip(pd.DataFrame({"structs": [struct, struct, struct]}))
+
+    lists = [x]
+    roundtrip(pd.DataFrame({"lists": [lists, lists, lists]}))
+
+    los = [struct]
+    roundtrip(pd.DataFrame({"los": [los, los, los]}))
+
+    sol = {"struct_field": lists}
+    roundtrip(pd.DataFrame({"sol": [sol, sol, sol]}))
+
+    map_of_los = {"a": los}
+    map_type = pa.map_(pa.string(),
+                       pa.list_(pa.struct([("struct_field", pa.binary())])))
+    schema = pa.schema([("maps", map_type)])
+    roundtrip(pd.DataFrame({"maps": [map_of_los, map_of_los, map_of_los]}),
+              schema=schema)

From 241b99acbb97df93cfa02429cc712391a37de5e3 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Tue, 10 Oct 2023 19:44:49 +0200
Subject: [PATCH 515/749] GH-37411: [C++][Python] Add string -> date cast
 kernel (fix python scalar cast) (#38038)

### Rationale for this change

Adding `string -> date32/date64` cast kernels, which then also fixes the pyarrow scalar cast method (which was earlier refactored to rely on the general cast kernels)

* Closes: #37411

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../compute/kernels/scalar_cast_numeric.cc    |  3 +-
 .../compute/kernels/scalar_cast_temporal.cc   | 49 ++++++++++++++++
 .../arrow/compute/kernels/scalar_cast_test.cc | 21 ++++++-
 cpp/src/arrow/util/value_parsing.h            | 58 +++++++++----------
 python/pyarrow/tests/test_scalars.py          |  7 +++
 5 files changed, 106 insertions(+), 32 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
index a02f83351b306..b054e57f04d12 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_numeric.cc
@@ -286,7 +286,8 @@ struct ParseString {
 };
 
 template <typename O, typename I>
-struct CastFunctor<O, I, enable_if_base_binary<I>> {
+struct CastFunctor<
+    O, I, enable_if_t<(is_number_type<O>::value && is_base_binary_type<I>::value)>> {
   static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
     return applicator::ScalarUnaryNotNull<O, I, ParseString<O>>::Exec(ctx, batch, out);
   }
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_temporal.cc b/cpp/src/arrow/compute/kernels/scalar_cast_temporal.cc
index 50d24ecab02e6..a5612643913aa 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_temporal.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_temporal.cc
@@ -30,6 +30,7 @@
 namespace arrow {
 
 using internal::ParseTimestampISO8601;
+using internal::ParseYYYY_MM_DD;
 
 namespace compute {
 namespace internal {
@@ -451,6 +452,44 @@ struct CastFunctor<TimestampType, I, enable_if_t<is_base_binary_type<I>::value>>
   }
 };
 
+template <typename DateType>
+struct ParseDate {
+  using value_type = typename DateType::c_type;
+
+  using duration_type =
+      typename std::conditional<std::is_same<DateType, Date32Type>::value,
+                                arrow_vendored::date::days,
+                                std::chrono::milliseconds>::type;
+
+  template <typename OutValue, typename Arg0Value>
+  OutValue Call(KernelContext* ctx, Arg0Value val, Status* st) const {
+    OutValue result = OutValue(0);
+
+    if (ARROW_PREDICT_FALSE(val.size() != 10)) {
+      *st = Status::Invalid("Failed to parse string: '", val, "' as a scalar of type ",
+                            TypeTraits<DateType>::type_singleton()->ToString());
+      return result;
+    }
+
+    duration_type since_epoch;
+    if (ARROW_PREDICT_FALSE(!ParseYYYY_MM_DD(val.data(), &since_epoch))) {
+      *st = Status::Invalid("Failed to parse string: '", val, "' as a scalar of type ",
+                            TypeTraits<DateType>::type_singleton()->ToString());
+    } else {
+      result = static_cast<value_type>(since_epoch.count());
+    }
+    return result;
+  }
+};
+
+template <typename O, typename I>
+struct CastFunctor<O, I,
+                   enable_if_t<(is_date_type<O>::value && is_string_type<I>::value)>> {
+  static Status Exec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
+    return applicator::ScalarUnaryNotNull<O, I, ParseDate<O>>::Exec(ctx, batch, out);
+  }
+};
+
 template <typename Type>
 void AddCrossUnitCast(CastFunction* func) {
   ScalarKernel kernel;
@@ -483,6 +522,11 @@ std::shared_ptr<CastFunction> GetDate32Cast() {
   // timestamp -> date32
   AddSimpleCast<TimestampType, Date32Type>(InputType(Type::TIMESTAMP), date32(),
                                            func.get());
+
+  // string -> date32
+  AddSimpleCast<StringType, Date32Type>(utf8(), date32(), func.get());
+  AddSimpleCast<LargeStringType, Date32Type>(large_utf8(), date32(), func.get());
+
   return func;
 }
 
@@ -500,6 +544,11 @@ std::shared_ptr<CastFunction> GetDate64Cast() {
   // timestamp -> date64
   AddSimpleCast<TimestampType, Date64Type>(InputType(Type::TIMESTAMP), date64(),
                                            func.get());
+
+  // string -> date64
+  AddSimpleCast<StringType, Date64Type>(utf8(), date64(), func.get());
+  AddSimpleCast<LargeStringType, Date64Type>(large_utf8(), date64(), func.get());
+
   return func;
 }
 
diff --git a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
index 57cd3ad5ed5fc..c84125bbdd19e 100644
--- a/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_cast_test.cc
@@ -211,8 +211,8 @@ TEST(Cast, CanCast) {
     ExpectCannotCast(from_base_binary, {null()});
   }
 
-  ExpectCanCast(utf8(), {timestamp(TimeUnit::MILLI)});
-  ExpectCanCast(large_utf8(), {timestamp(TimeUnit::NANO)});
+  ExpectCanCast(utf8(), {timestamp(TimeUnit::MILLI), date32(), date64()});
+  ExpectCanCast(large_utf8(), {timestamp(TimeUnit::NANO), date32(), date64()});
   ExpectCannotCast(timestamp(TimeUnit::MICRO),
                    {binary(), large_binary()});  // no formatting supported
 
@@ -2016,6 +2016,23 @@ TEST(Cast, StringToTimestamp) {
   }
 }
 
+TEST(Cast, StringToDate) {
+  for (auto string_type : {utf8(), large_utf8()}) {
+    auto strings = ArrayFromJSON(string_type, R"(["1970-01-01", null, "2000-02-29"])");
+
+    CheckCast(strings, ArrayFromJSON(date32(), "[0, null, 11016]"));
+    CheckCast(strings, ArrayFromJSON(date64(), "[0, null, 951782400000]"));
+
+    for (auto date_type : {date32(), date64()}) {
+      for (std::string not_ts : {"", "2012-01-xx", "2012-01-01 09:00:00"}) {
+        auto options = CastOptions::Safe(date_type);
+        CheckCastFails(ArrayFromJSON(string_type, "[\"" + not_ts + "\"]"), options);
+      }
+    }
+    // NOTE: YYYY-MM-DD parsing is tested comprehensively in value_parsing_test.cc
+  }
+}
+
 static void AssertBinaryZeroCopy(std::shared_ptr<Array> lhs, std::shared_ptr<Array> rhs) {
   // null bitmap and data buffers are always zero-copied
   AssertBufferSame(*lhs, *rhs, 0);
diff --git a/cpp/src/arrow/util/value_parsing.h b/cpp/src/arrow/util/value_parsing.h
index d4bbf206659ba..b3c711840f3e2 100644
--- a/cpp/src/arrow/util/value_parsing.h
+++ b/cpp/src/arrow/util/value_parsing.h
@@ -443,33 +443,6 @@ namespace detail {
 
 using ts_type = TimestampType::c_type;
 
-template <typename Duration>
-static inline bool ParseYYYY_MM_DD(const char* s, Duration* since_epoch) {
-  uint16_t year = 0;
-  uint8_t month = 0;
-  uint8_t day = 0;
-  if (ARROW_PREDICT_FALSE(s[4] != '-') || ARROW_PREDICT_FALSE(s[7] != '-')) {
-    return false;
-  }
-  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 0, 4, &year))) {
-    return false;
-  }
-  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 5, 2, &month))) {
-    return false;
-  }
-  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 8, 2, &day))) {
-    return false;
-  }
-  arrow_vendored::date::year_month_day ymd{arrow_vendored::date::year{year},
-                                           arrow_vendored::date::month{month},
-                                           arrow_vendored::date::day{day}};
-  if (ARROW_PREDICT_FALSE(!ymd.ok())) return false;
-
-  *since_epoch = std::chrono::duration_cast<Duration>(
-      arrow_vendored::date::sys_days{ymd}.time_since_epoch());
-  return true;
-}
-
 template <typename Duration>
 static inline bool ParseHH(const char* s, Duration* out) {
   uint8_t hours = 0;
@@ -641,6 +614,33 @@ static inline bool ParseSubSeconds(const char* s, size_t length, TimeUnit::type
 
 }  // namespace detail
 
+template <typename Duration>
+static inline bool ParseYYYY_MM_DD(const char* s, Duration* since_epoch) {
+  uint16_t year = 0;
+  uint8_t month = 0;
+  uint8_t day = 0;
+  if (ARROW_PREDICT_FALSE(s[4] != '-') || ARROW_PREDICT_FALSE(s[7] != '-')) {
+    return false;
+  }
+  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 0, 4, &year))) {
+    return false;
+  }
+  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 5, 2, &month))) {
+    return false;
+  }
+  if (ARROW_PREDICT_FALSE(!ParseUnsigned(s + 8, 2, &day))) {
+    return false;
+  }
+  arrow_vendored::date::year_month_day ymd{arrow_vendored::date::year{year},
+                                           arrow_vendored::date::month{month},
+                                           arrow_vendored::date::day{day}};
+  if (ARROW_PREDICT_FALSE(!ymd.ok())) return false;
+
+  *since_epoch = std::chrono::duration_cast<Duration>(
+      arrow_vendored::date::sys_days{ymd}.time_since_epoch());
+  return true;
+}
+
 static inline bool ParseTimestampISO8601(const char* s, size_t length,
                                          TimeUnit::type unit, TimestampType::c_type* out,
                                          bool* out_zone_offset_present = NULLPTR) {
@@ -672,7 +672,7 @@ static inline bool ParseTimestampISO8601(const char* s, size_t length,
   if (ARROW_PREDICT_FALSE(length < 10)) return false;
 
   seconds_type seconds_since_epoch;
-  if (ARROW_PREDICT_FALSE(!detail::ParseYYYY_MM_DD(s, &seconds_since_epoch))) {
+  if (ARROW_PREDICT_FALSE(!ParseYYYY_MM_DD(s, &seconds_since_epoch))) {
     return false;
   }
 
@@ -843,7 +843,7 @@ struct StringConverter<DATE_TYPE, enable_if_date<DATE_TYPE>> {
     }
 
     duration_type since_epoch;
-    if (ARROW_PREDICT_FALSE(!detail::ParseYYYY_MM_DD(s, &since_epoch))) {
+    if (ARROW_PREDICT_FALSE(!ParseYYYY_MM_DD(s, &since_epoch))) {
       return false;
     }
 
diff --git a/python/pyarrow/tests/test_scalars.py b/python/pyarrow/tests/test_scalars.py
index 1d8d77f50dac8..d7585d1415479 100644
--- a/python/pyarrow/tests/test_scalars.py
+++ b/python/pyarrow/tests/test_scalars.py
@@ -352,6 +352,13 @@ def test_cast_int_to_float():
         int_scalar.cast(pa.float64())  # verify default is safe cast
 
 
+@pytest.mark.parametrize("typ", [pa.date32(), pa.date64()])
+def test_cast_string_to_date(typ):
+    scalar = pa.scalar('2021-01-01')
+    result = scalar.cast(typ)
+    assert result == pa.scalar(datetime.date(2021, 1, 1), type=typ)
+
+
 @pytest.mark.pandas
 def test_timestamp():
     import pandas as pd

From 64c7caea0cf0002017bd3922147fe5a831cfaecd Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 11 Oct 2023 01:56:36 +0800
Subject: [PATCH 516/749] GH-36882: [C++][Parquet] Use RLE as BOOLEAN default
 encoding when both data page and version is V2 (#38163)

### Rationale for this change

Only use RLE as BOOLEAN default encoding when data page is V2.

Previous patch ( https://github.com/apache/arrow/pull/36955 ) set RLE encoding for Boolean type by default.  However, parquet-cpp might write format v2 file with page v1 by default. This might cause parquet-cpp generating RLE encoding for boolean type by default. As https://issues.apache.org/jira/browse/PARQUET-2222 says, we still need some talks about that. So, we:

1. Still allow writing RLE on DataPage V2. This keeps same as parquet rust
2. If DataPage V1 is used, don't use RLE as default Boolean encoding.

### What changes are included in this PR?

Only use RLE as BOOLEAN default encoding when both data page and version is V2.

### Are these changes tested?

Yes

### Are there any user-facing changes?

RLE encoding change for Boolean.

* Closes: #36882

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/column_writer.cc              |  3 +-
 cpp/src/parquet/column_writer_test.cc         | 78 +++++++++++++------
 cpp/src/parquet/metadata.cc                   | 22 +++---
 python/pyarrow/tests/parquet/test_metadata.py |  2 +-
 4 files changed, 66 insertions(+), 39 deletions(-)

diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index be1881d00e035..88829ef5d98f9 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -2336,7 +2336,8 @@ std::shared_ptr<ColumnWriter> ColumnWriter::Make(ColumnChunkMetaDataBuilder* met
   Encoding::type encoding = properties->encoding(descr->path());
   if (encoding == Encoding::UNKNOWN) {
     encoding = (descr->physical_type() == Type::BOOLEAN &&
-                properties->version() != ParquetVersion::PARQUET_1_0)
+                properties->version() != ParquetVersion::PARQUET_1_0 &&
+                properties->data_page_version() == ParquetDataPageVersion::V2)
                    ? Encoding::RLE
                    : Encoding::PLAIN;
   }
diff --git a/cpp/src/parquet/column_writer_test.cc b/cpp/src/parquet/column_writer_test.cc
index b2fd9cf930823..0d354f5c1ac0c 100644
--- a/cpp/src/parquet/column_writer_test.cc
+++ b/cpp/src/parquet/column_writer_test.cc
@@ -98,10 +98,11 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
       int64_t output_size = SMALL_SIZE,
       const ColumnProperties& column_properties = ColumnProperties(),
       const ParquetVersion::type version = ParquetVersion::PARQUET_1_0,
+      const ParquetDataPageVersion data_page_version = ParquetDataPageVersion::V1,
       bool enable_checksum = false) {
     sink_ = CreateOutputStream();
     WriterProperties::Builder wp_builder;
-    wp_builder.version(version);
+    wp_builder.version(version)->data_page_version(data_page_version);
     if (column_properties.encoding() == Encoding::PLAIN_DICTIONARY ||
         column_properties.encoding() == Encoding::RLE_DICTIONARY) {
       wp_builder.enable_dictionary();
@@ -176,7 +177,8 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     ASSERT_NO_FATAL_FAILURE(this->ReadAndCompare(compression, num_rows, enable_checksum));
   }
 
-  void TestDictionaryFallbackEncoding(ParquetVersion::type version) {
+  void TestDictionaryFallbackEncoding(ParquetVersion::type version,
+                                      ParquetDataPageVersion data_page_version) {
     this->GenerateData(VERY_LARGE_SIZE);
     ColumnProperties column_properties;
     column_properties.set_dictionary_enabled(true);
@@ -187,7 +189,8 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
       column_properties.set_encoding(Encoding::RLE_DICTIONARY);
     }
 
-    auto writer = this->BuildWriter(VERY_LARGE_SIZE, column_properties, version);
+    auto writer =
+        this->BuildWriter(VERY_LARGE_SIZE, column_properties, version, data_page_version);
 
     writer->WriteBatch(this->values_.size(), nullptr, nullptr, this->values_ptr_);
     writer->Close();
@@ -204,13 +207,15 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
     if (this->type_num() == Type::BOOLEAN) {
       // Dictionary encoding is not allowed for boolean type
       std::set<Encoding::type> expected;
-      if (version == ParquetVersion::PARQUET_1_0) {
+      if (version != ParquetVersion::PARQUET_1_0 &&
+          data_page_version == ParquetDataPageVersion::V2) {
+        // There is only 1 encoding (RLE) in a fallback case for version 2.0 and data page
+        // v2 enabled.
+        expected = {Encoding::RLE};
+      } else {
         // There are 2 encodings (PLAIN, RLE) in a non dictionary encoding case for
-        // version 1.0. Note that RLE is used for DL/RL.
+        // version 1.0 or data page v1. Note that RLE is used for DL/RL.
         expected = {Encoding::PLAIN, Encoding::RLE};
-      } else {
-        // There is only 1 encoding (RLE) in a fallback case for version 2.0
-        expected = {Encoding::RLE};
       }
       ASSERT_EQ(encodings, expected);
     } else if (version == ParquetVersion::PARQUET_1_0) {
@@ -231,7 +236,10 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
         this->metadata_encoding_stats();
     if (this->type_num() == Type::BOOLEAN) {
       ASSERT_EQ(encoding_stats[0].encoding,
-                version == ParquetVersion::PARQUET_1_0 ? Encoding::PLAIN : Encoding::RLE);
+                version != ParquetVersion::PARQUET_1_0 &&
+                        data_page_version == ParquetDataPageVersion::V2
+                    ? Encoding::RLE
+                    : Encoding::PLAIN);
       ASSERT_EQ(encoding_stats[0].page_type, PageType::DATA_PAGE);
     } else if (version == ParquetVersion::PARQUET_1_0) {
       std::vector<Encoding::type> expected(
@@ -262,8 +270,9 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
                                        enable_statistics);
     column_properties.set_codec_options(
         std::make_shared<CodecOptions>(compression_level));
-    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->BuildWriter(
-        num_rows, column_properties, ParquetVersion::PARQUET_1_0, enable_checksum);
+    std::shared_ptr<TypedColumnWriter<TestType>> writer =
+        this->BuildWriter(num_rows, column_properties, ParquetVersion::PARQUET_1_0,
+                          ParquetDataPageVersion::V1, enable_checksum);
     writer->WriteBatch(this->values_.size(), nullptr, nullptr, this->values_ptr_);
     // The behaviour should be independent from the number of Close() calls
     writer->Close();
@@ -281,8 +290,9 @@ class TestPrimitiveWriter : public PrimitiveTypedTest<TestType> {
                                        enable_statistics);
     column_properties.set_codec_options(
         std::make_shared<CodecOptions>(compression_level));
-    std::shared_ptr<TypedColumnWriter<TestType>> writer = this->BuildWriter(
-        num_rows, column_properties, ParquetVersion::PARQUET_1_0, enable_checksum);
+    std::shared_ptr<TypedColumnWriter<TestType>> writer =
+        this->BuildWriter(num_rows, column_properties, ParquetVersion::PARQUET_1_0,
+                          ParquetDataPageVersion::V1, enable_checksum);
     writer->WriteBatchSpaced(this->values_.size(), nullptr, nullptr, valid_bits.data(), 0,
                              this->values_ptr_);
     // The behaviour should be independent from the number of Close() calls
@@ -693,12 +703,19 @@ TYPED_TEST(TestPrimitiveWriter, RequiredLargeChunk) {
 
 // Test cases for dictionary fallback encoding
 TYPED_TEST(TestPrimitiveWriter, DictionaryFallbackVersion1_0) {
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_1_0);
+  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_1_0,
+                                       ParquetDataPageVersion::V1);
 }
 
 TYPED_TEST(TestPrimitiveWriter, DictionaryFallbackVersion2_0) {
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_4);
-  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_6);
+  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_4,
+                                       ParquetDataPageVersion::V1);
+  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_4,
+                                       ParquetDataPageVersion::V2);
+  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_6,
+                                       ParquetDataPageVersion::V1);
+  this->TestDictionaryFallbackEncoding(ParquetVersion::PARQUET_2_6,
+                                       ParquetDataPageVersion::V2);
 }
 
 TEST(TestWriter, NullValuesBuffer) {
@@ -767,10 +784,13 @@ TEST_F(TestValuesWriterInt32Type, OptionalNullValueChunk) {
 
 class TestBooleanValuesWriter : public TestPrimitiveWriter<BooleanType> {
  public:
-  void TestWithEncoding(ParquetVersion::type version, Encoding::type encoding) {
+  void TestWithEncoding(ParquetVersion::type version,
+                        ParquetDataPageVersion data_page_version,
+                        const std::set<Encoding::type>& expected_encodings) {
     this->SetUpSchema(Repetition::REQUIRED);
-    auto writer = this->BuildWriter(SMALL_SIZE, ColumnProperties(), version,
-                                    /*enable_checksum*/ false);
+    auto writer =
+        this->BuildWriter(SMALL_SIZE, ColumnProperties(), version, data_page_version,
+                          /*enable_checksum*/ false);
     for (int i = 0; i < SMALL_SIZE; i++) {
       bool value = (i % 2 == 0) ? true : false;
       writer->WriteBatch(1, nullptr, nullptr, &value);
@@ -780,21 +800,29 @@ class TestBooleanValuesWriter : public TestPrimitiveWriter<BooleanType> {
     for (int i = 0; i < SMALL_SIZE; i++) {
       ASSERT_EQ((i % 2 == 0) ? true : false, this->values_out_[i]) << i;
     }
-    const auto& encodings = this->metadata_encodings();
-    auto iter = std::find(encodings.begin(), encodings.end(), encoding);
-    ASSERT_TRUE(iter != encodings.end());
+    auto metadata_encodings = this->metadata_encodings();
+    std::set<Encoding::type> metadata_encodings_set{metadata_encodings.begin(),
+                                                    metadata_encodings.end()};
+    EXPECT_EQ(expected_encodings, metadata_encodings_set);
   }
 };
 
 // PARQUET-764
 // Correct bitpacking for boolean write at non-byte boundaries
 TEST_F(TestBooleanValuesWriter, AlternateBooleanValues) {
-  TestWithEncoding(ParquetVersion::PARQUET_1_0, Encoding::PLAIN);
+  for (auto data_page_version :
+       {ParquetDataPageVersion::V1, ParquetDataPageVersion::V2}) {
+    TestWithEncoding(ParquetVersion::PARQUET_1_0, data_page_version,
+                     {Encoding::PLAIN, Encoding::RLE});
+  }
 }
 
-// Default encoding for boolean is RLE when using V2 pages
+// Default encoding for boolean is RLE when both V2 format and V2 pages enabled.
 TEST_F(TestBooleanValuesWriter, RleEncodedBooleanValues) {
-  TestWithEncoding(ParquetVersion::PARQUET_2_4, Encoding::RLE);
+  TestWithEncoding(ParquetVersion::PARQUET_2_4, ParquetDataPageVersion::V1,
+                   {Encoding::PLAIN, Encoding::RLE});
+  TestWithEncoding(ParquetVersion::PARQUET_2_4, ParquetDataPageVersion::V2,
+                   {Encoding::RLE});
 }
 
 // PARQUET-979
diff --git a/cpp/src/parquet/metadata.cc b/cpp/src/parquet/metadata.cc
index 8697cd52515ae..f43187c2dd4e5 100644
--- a/cpp/src/parquet/metadata.cc
+++ b/cpp/src/parquet/metadata.cc
@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <cinttypes>
+#include <memory>
 #include <ostream>
 #include <string>
 #include <string_view>
@@ -1501,8 +1502,8 @@ class ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilderImpl {
       thrift_encoding_stats.push_back(data_enc_stat);
       add_encoding(data_encoding);
     }
-    column_chunk_->meta_data.__set_encodings(thrift_encodings);
-    column_chunk_->meta_data.__set_encoding_stats(thrift_encoding_stats);
+    column_chunk_->meta_data.__set_encodings(std::move(thrift_encodings));
+    column_chunk_->meta_data.__set_encoding_stats(std::move(thrift_encoding_stats));
 
     const auto& encrypt_md =
         properties_->column_encryption_properties(column_->path()->ToDotString());
@@ -1521,7 +1522,7 @@ class ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilderImpl {
         ccmd.__isset.ENCRYPTION_WITH_COLUMN_KEY = true;
         ccmd.__set_ENCRYPTION_WITH_COLUMN_KEY(eck);
       }
-      column_chunk_->__set_crypto_metadata(ccmd);
+      column_chunk_->__set_crypto_metadata(std::move(ccmd));
 
       bool encrypted_footer =
           properties_->file_encryption_properties()->encrypted_footer();
@@ -1601,16 +1602,13 @@ std::unique_ptr<ColumnChunkMetaDataBuilder> ColumnChunkMetaDataBuilder::Make(
 
 ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilder(
     std::shared_ptr<WriterProperties> props, const ColumnDescriptor* column)
-    : impl_{std::unique_ptr<ColumnChunkMetaDataBuilderImpl>(
-          new ColumnChunkMetaDataBuilderImpl(std::move(props), column))} {}
+    : impl_{std::make_unique<ColumnChunkMetaDataBuilderImpl>(std::move(props), column)} {}
 
 ColumnChunkMetaDataBuilder::ColumnChunkMetaDataBuilder(
     std::shared_ptr<WriterProperties> props, const ColumnDescriptor* column,
     void* contents)
-    : impl_{std::unique_ptr<ColumnChunkMetaDataBuilderImpl>(
-          new ColumnChunkMetaDataBuilderImpl(
-              std::move(props), column,
-              reinterpret_cast<format::ColumnChunk*>(contents)))} {}
+    : impl_{std::make_unique<ColumnChunkMetaDataBuilderImpl>(
+          std::move(props), column, reinterpret_cast<format::ColumnChunk*>(contents))} {}
 
 ColumnChunkMetaDataBuilder::~ColumnChunkMetaDataBuilder() = default;
 
@@ -1782,7 +1780,7 @@ class FileMetaDataBuilder::FileMetaDataBuilderImpl {
         key_value_metadata_(std::move(key_value_metadata)) {
     if (properties_->file_encryption_properties() != nullptr &&
         properties_->file_encryption_properties()->encrypted_footer()) {
-      crypto_metadata_.reset(new format::FileCryptoMetaData());
+      crypto_metadata_ = std::make_unique<format::FileCryptoMetaData>();
     }
   }
 
@@ -1956,8 +1954,8 @@ std::unique_ptr<FileMetaDataBuilder> FileMetaDataBuilder::Make(
 FileMetaDataBuilder::FileMetaDataBuilder(
     const SchemaDescriptor* schema, std::shared_ptr<WriterProperties> props,
     std::shared_ptr<const KeyValueMetadata> key_value_metadata)
-    : impl_{std::unique_ptr<FileMetaDataBuilderImpl>(new FileMetaDataBuilderImpl(
-          schema, std::move(props), std::move(key_value_metadata)))} {}
+    : impl_{std::make_unique<FileMetaDataBuilderImpl>(schema, std::move(props),
+                                                      std::move(key_value_metadata))} {}
 
 FileMetaDataBuilder::~FileMetaDataBuilder() = default;
 
diff --git a/python/pyarrow/tests/parquet/test_metadata.py b/python/pyarrow/tests/parquet/test_metadata.py
index 82182b0449afd..3efaf1dbf5526 100644
--- a/python/pyarrow/tests/parquet/test_metadata.py
+++ b/python/pyarrow/tests/parquet/test_metadata.py
@@ -128,7 +128,7 @@ def test_parquet_metadata_api():
     assert col_meta.is_stats_set is True
     assert isinstance(col_meta.statistics, pq.Statistics)
     assert col_meta.compression == 'SNAPPY'
-    assert set(col_meta.encodings) == {'RLE'}
+    assert set(col_meta.encodings) == {'PLAIN', 'RLE'}
     assert col_meta.has_dictionary_page is False
     assert col_meta.dictionary_page_offset is None
     assert col_meta.data_page_offset > 0

From 44ea2220956f8d6c34b8054702931540032fe7e6 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Tue, 10 Oct 2023 18:43:35 -0300
Subject: [PATCH 517/749] GH-35344: [Go][Format] Implementation of the
 LIST_VIEW and LARGE_LIST_VIEW array formats (#37468)

### Rationale for this change

Go implementation of #35345.

### What changes are included in this PR?

- [x] Add `LIST_VIEW` and `LARGE_LIST_VIEW` to datatype.go
- [x] Add `ListView` and `LargeListView` to list.go
- [x] Add `ListViewType` and `LargeListViewType` to datatype_nested.go
- [x] Add list-view builders
- [x] Implement list-view comparison in compare.go
- [x] String conversion in both directions
- [x] Validation of list-view arrays
- [x] Generation of random list-view arrays
- [x] Concatenation of list-view arrays in concat.go
- [x] JSON serialization/deserialization
- [x] Add data used for tests in `arrdata.go`
- [x] Add Flatbuffer changes
- [x] Add IPC support

### Are these changes tested?

Yes. Existing tests are being changed to also cover list-view variations as well as new tests focused solely on the list-view format.

### Are there any user-facing changes?

New structs and functions introduced.
* Closes: #35344

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/array/array.go                       |    2 +
 go/arrow/array/builder.go                     |    6 +
 go/arrow/array/compare.go                     |   50 +
 go/arrow/array/concat.go                      |  171 +++
 go/arrow/array/concat_test.go                 |   21 +
 go/arrow/array/list.go                        | 1080 ++++++++++++++++-
 go/arrow/array/list_test.go                   |  645 ++++++++--
 go/arrow/array/map.go                         |    4 +
 go/arrow/datatype.go                          |   15 +-
 go/arrow/datatype_nested.go                   |  147 +++
 go/arrow/internal/arrdata/arrdata.go          |   82 ++
 go/arrow/internal/arrjson/arrjson.go          |  132 +-
 go/arrow/internal/arrjson/arrjson_test.go     |  236 +++-
 .../internal/testing/gen/random_array_gen.go  |  151 +++
 go/arrow/ipc/file_reader.go                   |   17 +
 go/arrow/ipc/metadata.go                      |   26 +
 go/arrow/ipc/writer.go                        |  137 ++-
 go/arrow/ipc/writer_test.go                   |    6 +-
 go/arrow/type_string.go                       |    8 +-
 19 files changed, 2809 insertions(+), 127 deletions(-)

diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index 418f67034583d..1ee04c7aa2bcc 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -176,6 +176,8 @@ func init() {
 		arrow.LARGE_LIST:              func(data arrow.ArrayData) arrow.Array { return NewLargeListData(data) },
 		arrow.INTERVAL_MONTH_DAY_NANO: func(data arrow.ArrayData) arrow.Array { return NewMonthDayNanoIntervalData(data) },
 		arrow.RUN_END_ENCODED:         func(data arrow.ArrayData) arrow.Array { return NewRunEndEncodedData(data) },
+		arrow.LIST_VIEW:               func(data arrow.ArrayData) arrow.Array { return NewListViewData(data) },
+		arrow.LARGE_LIST_VIEW:         func(data arrow.ArrayData) arrow.Array { return NewLargeListViewData(data) },
 
 		// invalid data types to fill out array to size 2^6 - 1
 		63: invalidDataType,
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index 58d4a0f4b8895..2f15ac965e07c 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -342,6 +342,12 @@ func NewBuilder(mem memory.Allocator, dtype arrow.DataType) Builder {
 	case arrow.MAP:
 		typ := dtype.(*arrow.MapType)
 		return NewMapBuilderWithType(mem, typ)
+	case arrow.LIST_VIEW:
+		typ := dtype.(*arrow.ListViewType)
+		return NewListViewBuilderWithField(mem, typ.ElemField())
+	case arrow.LARGE_LIST_VIEW:
+		typ := dtype.(*arrow.LargeListViewType)
+		return NewLargeListViewBuilderWithField(mem, typ.ElemField())
 	case arrow.EXTENSION:
 		typ := dtype.(arrow.ExtensionType)
 		bldr := NewExtensionBuilder(mem, typ)
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index 7dca60688d490..e70716bee91a7 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -292,6 +292,12 @@ func Equal(left, right arrow.Array) bool {
 	case *LargeList:
 		r := right.(*LargeList)
 		return arrayEqualLargeList(l, r)
+	case *ListView:
+		r := right.(*ListView)
+		return arrayEqualListView(l, r)
+	case *LargeListView:
+		r := right.(*LargeListView)
+		return arrayEqualLargeListView(l, r)
 	case *FixedSizeList:
 		r := right.(*FixedSizeList)
 		return arrayEqualFixedSizeList(l, r)
@@ -536,6 +542,12 @@ func arrayApproxEqual(left, right arrow.Array, opt equalOption) bool {
 	case *LargeList:
 		r := right.(*LargeList)
 		return arrayApproxEqualLargeList(l, r, opt)
+	case *ListView:
+		r := right.(*ListView)
+		return arrayApproxEqualListView(l, r, opt)
+	case *LargeListView:
+		r := right.(*LargeListView)
+		return arrayApproxEqualLargeListView(l, r, opt)
 	case *FixedSizeList:
 		r := right.(*FixedSizeList)
 		return arrayApproxEqualFixedSizeList(l, r, opt)
@@ -682,6 +694,44 @@ func arrayApproxEqualLargeList(left, right *LargeList, opt equalOption) bool {
 	return true
 }
 
+func arrayApproxEqualListView(left, right *ListView, opt equalOption) bool {
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		o := func() bool {
+			l := left.newListValue(i)
+			defer l.Release()
+			r := right.newListValue(i)
+			defer r.Release()
+			return arrayApproxEqual(l, r, opt)
+		}()
+		if !o {
+			return false
+		}
+	}
+	return true
+}
+
+func arrayApproxEqualLargeListView(left, right *LargeListView, opt equalOption) bool {
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		o := func() bool {
+			l := left.newListValue(i)
+			defer l.Release()
+			r := right.newListValue(i)
+			defer r.Release()
+			return arrayApproxEqual(l, r, opt)
+		}()
+		if !o {
+			return false
+		}
+	}
+	return true
+}
+
 func arrayApproxEqualFixedSizeList(left, right *FixedSizeList, opt equalOption) bool {
 	for i := 0; i < left.Len(); i++ {
 		if left.IsNull(i) {
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index f00a36fec1171..9d815023c4b76 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"math"
 	"math/bits"
+	"unsafe"
 
 	"github.com/apache/arrow/go/v14/arrow"
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
@@ -355,6 +356,164 @@ func concatOffsets(buffers []*memory.Buffer, byteWidth int, mem memory.Allocator
 	}
 }
 
+func sumArraySizes(data []arrow.ArrayData) int {
+	outSize := 0
+	for _, arr := range data {
+		outSize += arr.Len()
+	}
+	return outSize
+}
+
+func getListViewBufferValues[T int32 | int64](data arrow.ArrayData, i int) []T {
+	bytes := data.Buffers()[i].Bytes()
+	base := (*T)(unsafe.Pointer(&bytes[0]))
+	ret := unsafe.Slice(base, data.Offset()+data.Len())
+	return ret[data.Offset():]
+}
+
+func putListViewOffsets32(in arrow.ArrayData, displacement int32, out *memory.Buffer, outOff int) {
+	debug.Assert(in.DataType().ID() == arrow.LIST_VIEW, "putListViewOffsets32: expected LIST_VIEW data")
+	inOff, inLen := in.Offset(), in.Len()
+	if inLen == 0 {
+		return
+	}
+	bitmap := in.Buffers()[0]
+	srcOffsets := getListViewBufferValues[int32](in, 1)
+	srcSizes := getListViewBufferValues[int32](in, 2)
+	isValidAndNonEmpty := func(i int) bool {
+		return (bitmap == nil || bitutil.BitIsSet(bitmap.Bytes(), inOff+i)) && srcSizes[i] > 0
+	}
+
+	dstOffsets := arrow.Int32Traits.CastFromBytes(out.Bytes())
+	for i, offset := range srcOffsets {
+		if isValidAndNonEmpty(i) {
+			// This is guaranteed by RangeOfValuesUsed returning the smallest offset
+			// of valid and non-empty list-views.
+			debug.Assert(offset+displacement >= 0, "putListViewOffsets32: offset underflow while concatenating arrays")
+			dstOffsets[outOff+i] = offset + displacement
+		} else {
+			dstOffsets[outOff+i] = 0
+		}
+	}
+}
+
+func putListViewOffsets64(in arrow.ArrayData, displacement int64, out *memory.Buffer, outOff int) {
+	debug.Assert(in.DataType().ID() == arrow.LARGE_LIST_VIEW, "putListViewOffsets64: expected LARGE_LIST_VIEW data")
+	inOff, inLen := in.Offset(), in.Len()
+	if inLen == 0 {
+		return
+	}
+	bitmap := in.Buffers()[0]
+	srcOffsets := getListViewBufferValues[int64](in, 1)
+	srcSizes := getListViewBufferValues[int64](in, 2)
+	isValidAndNonEmpty := func(i int) bool {
+		return (bitmap == nil || bitutil.BitIsSet(bitmap.Bytes(), inOff+i)) && srcSizes[i] > 0
+	}
+
+	dstOffsets := arrow.Int64Traits.CastFromBytes(out.Bytes())
+	for i, offset := range srcOffsets {
+		if isValidAndNonEmpty(i) {
+			// This is guaranteed by RangeOfValuesUsed returning the smallest offset
+			// of valid and non-empty list-views.
+			debug.Assert(offset+displacement >= 0, "putListViewOffsets64: offset underflow while concatenating arrays")
+			dstOffsets[outOff+i] = offset + displacement
+		} else {
+			dstOffsets[outOff+i] = 0
+		}
+	}
+}
+
+// Concatenate buffers holding list-view offsets into a single buffer of offsets
+//
+// valueRanges contains the relevant ranges of values in the child array actually
+// referenced to by the views. Most commonly, these ranges will start from 0,
+// but when that is not the case, we need to adjust the displacement of offsets.
+// The concatenated child array does not contain values from the beginning
+// if they are not referenced to by any view.
+func concatListViewOffsets(data []arrow.ArrayData, byteWidth int, valueRanges []rng, mem memory.Allocator) (*memory.Buffer, error) {
+	outSize := sumArraySizes(data)
+	if byteWidth == 4 && outSize > math.MaxInt32 {
+		return nil, fmt.Errorf("%w: offset overflow while concatenating arrays", arrow.ErrInvalid)
+	}
+	out := memory.NewResizableBuffer(mem)
+	out.Resize(byteWidth * outSize)
+
+	numChildValues, elementsLength := 0, 0
+	for i, arr := range data {
+		displacement := numChildValues - valueRanges[i].offset
+		if byteWidth == 4 {
+			putListViewOffsets32(arr, int32(displacement), out, elementsLength)
+		} else {
+			putListViewOffsets64(arr, int64(displacement), out, elementsLength)
+		}
+		elementsLength += arr.Len()
+		numChildValues += valueRanges[i].len
+	}
+	debug.Assert(elementsLength == outSize, "implementation error")
+
+	return out, nil
+}
+
+func zeroNullListViewSizes[T int32 | int64](data arrow.ArrayData) {
+	if data.Len() == 0 || data.Buffers()[0] == nil {
+		return
+	}
+	validity := data.Buffers()[0].Bytes()
+	sizes := getListViewBufferValues[T](data, 2)
+
+	for i := 0; i < data.Len(); i++ {
+		if !bitutil.BitIsSet(validity, data.Offset()+i) {
+			sizes[i] = 0
+		}
+	}
+}
+
+func concatListView(data []arrow.ArrayData, offsetType arrow.FixedWidthDataType, out *Data, mem memory.Allocator) (err error) {
+	// Calculate the ranges of values that each list-view array uses
+	valueRanges := make([]rng, len(data))
+	for i, input := range data {
+		offset, len := rangeOfValuesUsed(input)
+		valueRanges[i].offset = offset
+		valueRanges[i].len = len
+	}
+
+	// Gather the children ranges of each input array
+	childData := gatherChildrenRanges(data, 0, valueRanges)
+	for _, c := range childData {
+		defer c.Release()
+	}
+
+	// Concatenate the values
+	values, err := concat(childData, mem)
+	if err != nil {
+		return err
+	}
+
+	// Concatenate the offsets
+	offsetBuffer, err := concatListViewOffsets(data, offsetType.Bytes(), valueRanges, mem)
+	if err != nil {
+		return err
+	}
+
+	// Concatenate the sizes
+	sizeBuffers := gatherBuffersFixedWidthType(data, 2, offsetType)
+	sizeBuffer := concatBuffers(sizeBuffers, mem)
+
+	out.childData = []arrow.ArrayData{values}
+	out.buffers[1] = offsetBuffer
+	out.buffers[2] = sizeBuffer
+
+	// To make sure the sizes don't reference values that are not in the new
+	// concatenated values array, we zero the sizes of null list-view values.
+	if offsetType.ID() == arrow.INT32 {
+		zeroNullListViewSizes[int32](out)
+	} else {
+		zeroNullListViewSizes[int64](out)
+	}
+
+	return nil
+}
+
 // concat is the implementation for actually performing the concatenation of the arrow.ArrayData
 // objects that we can call internally for nested types.
 func concat(data []arrow.ArrayData, mem memory.Allocator) (arr arrow.ArrayData, err error) {
@@ -483,6 +642,18 @@ func concat(data []arrow.ArrayData, mem memory.Allocator) (arr arrow.ArrayData,
 		if err != nil {
 			return nil, err
 		}
+	case *arrow.ListViewType:
+		offsetType := arrow.PrimitiveTypes.Int32.(arrow.FixedWidthDataType)
+		err := concatListView(data, offsetType, out, mem)
+		if err != nil {
+			return nil, err
+		}
+	case *arrow.LargeListViewType:
+		offsetType := arrow.PrimitiveTypes.Int64.(arrow.FixedWidthDataType)
+		err := concatListView(data, offsetType, out, mem)
+		if err != nil {
+			return nil, err
+		}
 	case *arrow.FixedSizeListType:
 		childData := gatherChildrenMultiplier(data, 0, int(dt.Len()))
 		for _, c := range childData {
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index cc4d29cf42460..c80844f05bacd 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -78,6 +78,8 @@ func TestConcatenate(t *testing.T) {
 		{arrow.BinaryTypes.LargeString},
 		{arrow.ListOf(arrow.PrimitiveTypes.Int8)},
 		{arrow.LargeListOf(arrow.PrimitiveTypes.Int8)},
+		{arrow.ListViewOf(arrow.PrimitiveTypes.Int8)},
+		{arrow.LargeListViewOf(arrow.PrimitiveTypes.Int8)},
 		{arrow.FixedSizeListOf(3, arrow.PrimitiveTypes.Int8)},
 		{arrow.StructOf()},
 		{arrow.MapOf(arrow.PrimitiveTypes.Uint16, arrow.PrimitiveTypes.Int8)},
@@ -200,6 +202,16 @@ func (cts *ConcatTestSuite) generateArr(size int64, nullprob float64) arrow.Arra
 			}
 		}
 		return bldr.NewArray()
+	case arrow.LIST_VIEW:
+		arr := cts.rng.ListView(cts.dt.(arrow.VarLenListLikeType), size, 0, 20, nullprob)
+		err := arr.ValidateFull()
+		cts.NoError(err)
+		return arr
+	case arrow.LARGE_LIST_VIEW:
+		arr := cts.rng.LargeListView(cts.dt.(arrow.VarLenListLikeType), size, 0, 20, nullprob)
+		err := arr.ValidateFull()
+		cts.NoError(err)
+		return arr
 	case arrow.FIXED_SIZE_LIST:
 		const listsize = 3
 		valuesSize := size * listsize
@@ -317,11 +329,20 @@ func (cts *ConcatTestSuite) TestCheckConcat() {
 
 					slices := cts.slices(arr, offsets)
 					for _, s := range slices {
+						if s.DataType().ID() == arrow.LIST_VIEW {
+							err := s.(*array.ListView).ValidateFull()
+							cts.NoError(err)
+						}
 						defer s.Release()
 					}
 
 					actual, err := array.Concatenate(slices, cts.mem)
 					cts.NoError(err)
+					if arr.DataType().ID() == arrow.LIST_VIEW {
+						lv := actual.(*array.ListView)
+						err := lv.ValidateFull()
+						cts.NoError(err)
+					}
 					defer actual.Release()
 
 					cts.Truef(array.Equal(expected, actual), "expected: %s\ngot: %s\n", expected, actual)
diff --git a/go/arrow/array/list.go b/go/arrow/array/list.go
index 36035dd2f01a8..d8d8b8c76165a 100644
--- a/go/arrow/array/list.go
+++ b/go/arrow/array/list.go
@@ -19,6 +19,7 @@ package array
 import (
 	"bytes"
 	"fmt"
+	"math"
 	"strings"
 	"sync/atomic"
 
@@ -35,6 +36,10 @@ type ListLike interface {
 	ValueOffsets(i int) (start, end int64)
 }
 
+type VarLenListLike interface {
+	ListLike
+}
+
 // List represents an immutable sequence of array values.
 type List struct {
 	array
@@ -68,7 +73,7 @@ func (a *List) String() string {
 		if i > 0 {
 			o.WriteString(" ")
 		}
-		if !a.IsValid(i) {
+		if a.IsNull(i) {
 			o.WriteString(NullValueStr)
 			continue
 		}
@@ -86,6 +91,7 @@ func (a *List) newListValue(i int) arrow.Array {
 }
 
 func (a *List) setData(data *Data) {
+	debug.Assert(len(data.buffers) >= 2, "list data should have 2 buffers")
 	a.array.setData(data)
 	vals := data.buffers[1]
 	if vals != nil {
@@ -199,7 +205,7 @@ func (a *LargeList) String() string {
 		if i > 0 {
 			o.WriteString(" ")
 		}
-		if !a.IsValid(i) {
+		if a.IsNull(i) {
 			o.WriteString(NullValueStr)
 			continue
 		}
@@ -217,6 +223,7 @@ func (a *LargeList) newListValue(i int) arrow.Array {
 }
 
 func (a *LargeList) setData(data *Data) {
+	debug.Assert(len(data.buffers) >= 2, "list data should have 2 buffers")
 	a.array.setData(data)
 	vals := data.buffers[1]
 	if vals != nil {
@@ -314,6 +321,11 @@ type ListLikeBuilder interface {
 	Append(bool)
 }
 
+type VarLenListLikeBuilder interface {
+	ListLikeBuilder
+	AppendWithSize(bool, int)
+}
+
 type ListBuilder struct {
 	baseListBuilder
 }
@@ -422,6 +434,10 @@ func (b *baseListBuilder) Append(v bool) {
 	b.appendNextOffset()
 }
 
+func (b *baseListBuilder) AppendWithSize(v bool, _ int) {
+	b.Append(v)
+}
+
 func (b *baseListBuilder) AppendNull() {
 	b.Reserve(1)
 	b.unsafeAppendBoolToBitmap(false)
@@ -618,19 +634,1055 @@ func (b *baseListBuilder) UnmarshalJSON(data []byte) error {
 	return b.Unmarshal(dec)
 }
 
+// ListView represents an immutable sequence of array values defined by an
+// offset into a child array and a length.
+type ListView struct {
+	array
+	values  arrow.Array
+	offsets []int32
+	sizes   []int32
+}
+
+var _ VarLenListLike = (*ListView)(nil)
+
+func NewListViewData(data arrow.ArrayData) *ListView {
+	a := &ListView{}
+	a.refCount = 1
+	a.setData(data.(*Data))
+	return a
+}
+
+func (a *ListView) ListValues() arrow.Array { return a.values }
+
+func (a *ListView) ValueStr(i int) string {
+	if !a.IsValid(i) {
+		return NullValueStr
+	}
+	return string(a.GetOneForMarshal(i).(json.RawMessage))
+}
+
+func (a *ListView) String() string {
+	o := new(strings.Builder)
+	o.WriteString("[")
+	for i := 0; i < a.Len(); i++ {
+		if i > 0 {
+			o.WriteString(" ")
+		}
+		if a.IsNull(i) {
+			o.WriteString(NullValueStr)
+			continue
+		}
+		sub := a.newListValue(i)
+		fmt.Fprintf(o, "%v", sub)
+		sub.Release()
+	}
+	o.WriteString("]")
+	return o.String()
+}
+
+func (a *ListView) newListValue(i int) arrow.Array {
+	beg, end := a.ValueOffsets(i)
+	return NewSlice(a.values, beg, end)
+}
+
+func (a *ListView) setData(data *Data) {
+	debug.Assert(len(data.buffers) >= 3, "list-view data should have 3 buffers")
+	a.array.setData(data)
+	offsets := data.buffers[1]
+	if offsets != nil {
+		a.offsets = arrow.Int32Traits.CastFromBytes(offsets.Bytes())
+	}
+	sizes := data.buffers[2]
+	if sizes != nil {
+		a.sizes = arrow.Int32Traits.CastFromBytes(sizes.Bytes())
+	}
+	a.values = MakeFromData(data.childData[0])
+}
+
+func (a *ListView) GetOneForMarshal(i int) interface{} {
+	if a.IsNull(i) {
+		return nil
+	}
+
+	slice := a.newListValue(i)
+	defer slice.Release()
+	v, err := json.Marshal(slice)
+	if err != nil {
+		panic(err)
+	}
+	return json.RawMessage(v)
+}
+
+func (a *ListView) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+
+	buf.WriteByte('[')
+	for i := 0; i < a.Len(); i++ {
+		if i != 0 {
+			buf.WriteByte(',')
+		}
+		if err := enc.Encode(a.GetOneForMarshal(i)); err != nil {
+			return nil, err
+		}
+	}
+	buf.WriteByte(']')
+	return buf.Bytes(), nil
+}
+
+func arrayEqualListView(left, right *ListView) bool {
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		o := func() bool {
+			l := left.newListValue(i)
+			defer l.Release()
+			r := right.newListValue(i)
+			defer r.Release()
+			return Equal(l, r)
+		}()
+		if !o {
+			return false
+		}
+	}
+	return true
+}
+
+// Len returns the number of elements in the array.
+func (a *ListView) Len() int { return a.array.Len() }
+
+func (a *ListView) Offsets() []int32 { return a.offsets }
+
+func (a *ListView) Sizes() []int32 { return a.sizes }
+
+func (a *ListView) Retain() {
+	a.array.Retain()
+	a.values.Retain()
+}
+
+func (a *ListView) Release() {
+	a.array.Release()
+	a.values.Release()
+}
+
+func (a *ListView) ValueOffsets(i int) (start, end int64) {
+	debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
+	j := i + a.array.data.offset
+	size := int64(a.sizes[j])
+	// If size is 0, skip accessing offsets.
+	if size == 0 {
+		start, end = 0, 0
+		return
+	}
+	start = int64(a.offsets[j])
+	end = start + size
+	return
+}
+
+// LargeListView represents an immutable sequence of array values defined by an
+// offset into a child array and a length.
+type LargeListView struct {
+	array
+	values  arrow.Array
+	offsets []int64
+	sizes   []int64
+}
+
+var _ VarLenListLike = (*LargeListView)(nil)
+
+// NewLargeListViewData returns a new LargeListView array value, from data.
+func NewLargeListViewData(data arrow.ArrayData) *LargeListView {
+	a := new(LargeListView)
+	a.refCount = 1
+	a.setData(data.(*Data))
+	return a
+}
+
+func (a *LargeListView) ListValues() arrow.Array { return a.values }
+
+func (a *LargeListView) ValueStr(i int) string {
+	if !a.IsValid(i) {
+		return NullValueStr
+	}
+	return string(a.GetOneForMarshal(i).(json.RawMessage))
+}
+
+func (a *LargeListView) String() string {
+	o := new(strings.Builder)
+	o.WriteString("[")
+	for i := 0; i < a.Len(); i++ {
+		if i > 0 {
+			o.WriteString(" ")
+		}
+		if a.IsNull(i) {
+			o.WriteString(NullValueStr)
+			continue
+		}
+		sub := a.newListValue(i)
+		fmt.Fprintf(o, "%v", sub)
+		sub.Release()
+	}
+	o.WriteString("]")
+	return o.String()
+}
+
+func (a *LargeListView) newListValue(i int) arrow.Array {
+	beg, end := a.ValueOffsets(i)
+	return NewSlice(a.values, beg, end)
+}
+
+func (a *LargeListView) setData(data *Data) {
+	debug.Assert(len(data.buffers) >= 3, "list-view data should have 3 buffers")
+	a.array.setData(data)
+	offsets := data.buffers[1]
+	if offsets != nil {
+		a.offsets = arrow.Int64Traits.CastFromBytes(offsets.Bytes())
+	}
+	sizes := data.buffers[2]
+	if sizes != nil {
+		a.sizes = arrow.Int64Traits.CastFromBytes(sizes.Bytes())
+	}
+	a.values = MakeFromData(data.childData[0])
+}
+
+func (a *LargeListView) GetOneForMarshal(i int) interface{} {
+	if a.IsNull(i) {
+		return nil
+	}
+
+	slice := a.newListValue(i)
+	defer slice.Release()
+	v, err := json.Marshal(slice)
+	if err != nil {
+		panic(err)
+	}
+	return json.RawMessage(v)
+}
+
+func (a *LargeListView) MarshalJSON() ([]byte, error) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+
+	buf.WriteByte('[')
+	for i := 0; i < a.Len(); i++ {
+		if i != 0 {
+			buf.WriteByte(',')
+		}
+		if err := enc.Encode(a.GetOneForMarshal(i)); err != nil {
+			return nil, err
+		}
+	}
+	buf.WriteByte(']')
+	return buf.Bytes(), nil
+}
+
+func arrayEqualLargeListView(left, right *LargeListView) bool {
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		o := func() bool {
+			l := left.newListValue(i)
+			defer l.Release()
+			r := right.newListValue(i)
+			defer r.Release()
+			return Equal(l, r)
+		}()
+		if !o {
+			return false
+		}
+	}
+	return true
+}
+
+// Len returns the number of elements in the array.
+func (a *LargeListView) Len() int { return a.array.Len() }
+
+func (a *LargeListView) Offsets() []int64 { return a.offsets }
+
+func (a *LargeListView) Sizes() []int64 { return a.sizes }
+
+func (a *LargeListView) ValueOffsets(i int) (start, end int64) {
+	debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
+	j := i + a.array.data.offset
+	size := a.sizes[j]
+	// If size is 0, skip accessing offsets.
+	if size == 0 {
+		return 0, 0
+	}
+	start = a.offsets[j]
+	end = start + size
+	return
+}
+
+func (a *LargeListView) Retain() {
+	a.array.Retain()
+	a.values.Retain()
+}
+
+func (a *LargeListView) Release() {
+	a.array.Release()
+	a.values.Release()
+}
+
+// Acessors for offsets and sizes to make ListView and LargeListView validation generic.
+type offsetsAndSizes interface {
+	offsetAt(slot int64) int64
+	sizeAt(slot int64) int64
+}
+
+var _ offsetsAndSizes = (*ListView)(nil)
+var _ offsetsAndSizes = (*LargeListView)(nil)
+
+func (a *ListView) offsetAt(slot int64) int64 { return int64(a.offsets[int64(a.data.offset)+slot]) }
+
+func (a *ListView) sizeAt(slot int64) int64 { return int64(a.sizes[int64(a.data.offset)+slot]) }
+
+func (a *LargeListView) offsetAt(slot int64) int64 { return a.offsets[int64(a.data.offset)+slot] }
+
+func (a *LargeListView) sizeAt(slot int64) int64 { return a.sizes[int64(a.data.offset)+slot] }
+
+func outOfBoundsListViewOffset(l offsetsAndSizes, slot int64, offsetLimit int64) error {
+	offset := l.offsetAt(slot)
+	return fmt.Errorf("%w: Offset invariant failure: offset for slot %d out of bounds. Expected %d to be at least 0 and less than %d", arrow.ErrInvalid, slot, offset, offsetLimit)
+}
+
+func outOfBoundsListViewSize(l offsetsAndSizes, slot int64, offsetLimit int64) error {
+	size := l.sizeAt(slot)
+	if size < 0 {
+		return fmt.Errorf("%w: Offset invariant failure: size for slot %d out of bounds: %d < 0", arrow.ErrInvalid, slot, size)
+	}
+	offset := l.offsetAt(slot)
+	return fmt.Errorf("%w: Offset invariant failure: size for slot %d out of bounds: %d + %d > %d", arrow.ErrInvalid, slot, offset, size, offsetLimit)
+}
+
+// Pre-condition: Basic validation has already been performed
+func (a *array) fullyValidateOffsetsAndSizes(l offsetsAndSizes, offsetLimit int64) error {
+	for slot := int64(0); slot < int64(a.Len()); slot += 1 {
+		size := l.sizeAt(slot)
+		if size > 0 {
+			offset := l.offsetAt(slot)
+			if offset < 0 || offset > offsetLimit {
+				return outOfBoundsListViewOffset(l, slot, offsetLimit)
+			}
+			if size > offsetLimit-int64(offset) {
+				return outOfBoundsListViewSize(l, slot, offsetLimit)
+			}
+		} else if size < 0 {
+			return outOfBoundsListViewSize(l, slot, offsetLimit)
+		}
+	}
+
+	return nil
+}
+
+func (a *array) validateOffsetsAndMaybeSizes(l offsetsAndSizes, offsetByteWidth int, isListView bool, offsetLimit int64, fullValidation bool) error {
+	nonEmpty := a.Len() > 0
+	if a.data.buffers[1] == nil {
+		// For length 0, an empty offsets buffer is accepted (ARROW-544).
+		if nonEmpty {
+			return fmt.Errorf("non-empty array but offsets are null")
+		}
+		return nil
+	}
+	if isListView && a.data.buffers[2] == nil {
+		if nonEmpty {
+			return fmt.Errorf("non-empty array but sizes are null")
+		}
+		return nil
+	}
+
+	var requiredOffsets int
+	if nonEmpty {
+		requiredOffsets = a.Len() + a.Offset()
+		if !isListView {
+			requiredOffsets += 1
+		}
+	} else {
+		requiredOffsets = 0
+	}
+	offsetsByteSize := a.data.buffers[1].Len()
+	if offsetsByteSize/offsetByteWidth < requiredOffsets {
+		return fmt.Errorf("offsets buffer size (bytes): %d isn't large enough for length: %d and offset: %d",
+			offsetsByteSize, a.Len(), a.Offset())
+	}
+	if isListView {
+		requiredSizes := a.Len() + a.Offset()
+		sizesBytesSize := a.data.buffers[2].Len()
+		if sizesBytesSize/offsetByteWidth < requiredSizes {
+			return fmt.Errorf("sizes buffer size (bytes): %d isn't large enough for length: %d and offset: %d",
+				sizesBytesSize, a.Len(), a.Offset())
+		}
+	}
+
+	if fullValidation && requiredOffsets > 0 {
+		if isListView {
+			return a.fullyValidateOffsetsAndSizes(l, offsetLimit)
+		}
+		// TODO: implement validation of List and LargeList
+		// return fullyValidateOffsets(offset_limit)
+		return nil
+	}
+	return nil
+}
+
+func (a *ListView) validate(fullValidation bool) error {
+	values := a.array.data.childData[0]
+	offsetLimit := values.Len()
+	return a.array.validateOffsetsAndMaybeSizes(a, 4, true, int64(offsetLimit), fullValidation)
+}
+
+func (a *ListView) Validate() error {
+	return a.validate(false)
+}
+
+func (a *ListView) ValidateFull() error {
+	return a.validate(true)
+}
+
+func (a *LargeListView) validate(fullValidation bool) error {
+	values := a.array.data.childData[0]
+	offsetLimit := values.Len()
+	return a.array.validateOffsetsAndMaybeSizes(a, 8, true, int64(offsetLimit), fullValidation)
+}
+
+func (a *LargeListView) Validate() error {
+	return a.validate(false)
+}
+
+func (a *LargeListView) ValidateFull() error {
+	return a.validate(true)
+}
+
+type baseListViewBuilder struct {
+	builder
+
+	values  Builder // value builder for the list-view's elements.
+	offsets Builder
+	sizes   Builder
+
+	// actual list-view type
+	dt              arrow.DataType
+	appendOffsetVal func(int)
+	appendSizeVal   func(int)
+}
+
+type ListViewBuilder struct {
+	baseListViewBuilder
+}
+
+type LargeListViewBuilder struct {
+	baseListViewBuilder
+}
+
+// NewListViewBuilder returns a builder, using the provided memory allocator.
+// The created list-view builder will create a list whose elements will be
+// of type etype.
+func NewListViewBuilder(mem memory.Allocator, etype arrow.DataType) *ListViewBuilder {
+	offsetBldr := NewInt32Builder(mem)
+	sizeBldr := NewInt32Builder(mem)
+	return &ListViewBuilder{
+		baseListViewBuilder{
+			builder:         builder{refCount: 1, mem: mem},
+			values:          NewBuilder(mem, etype),
+			offsets:         offsetBldr,
+			sizes:           sizeBldr,
+			dt:              arrow.ListViewOf(etype),
+			appendOffsetVal: func(o int) { offsetBldr.Append(int32(o)) },
+			appendSizeVal:   func(s int) { sizeBldr.Append(int32(s)) },
+		},
+	}
+}
+
+// NewListViewBuilderWithField takes a field to use for the child rather than just
+// a datatype to allow for more customization.
+func NewListViewBuilderWithField(mem memory.Allocator, field arrow.Field) *ListViewBuilder {
+	offsetBldr := NewInt32Builder(mem)
+	sizeBldr := NewInt32Builder(mem)
+	return &ListViewBuilder{
+		baseListViewBuilder{
+			builder:         builder{refCount: 1, mem: mem},
+			values:          NewBuilder(mem, field.Type),
+			offsets:         offsetBldr,
+			sizes:           sizeBldr,
+			dt:              arrow.ListViewOfField(field),
+			appendOffsetVal: func(o int) { offsetBldr.Append(int32(o)) },
+			appendSizeVal:   func(s int) { sizeBldr.Append(int32(s)) },
+		},
+	}
+}
+
+func (b *baseListViewBuilder) Type() arrow.DataType {
+	switch dt := b.dt.(type) {
+	case *arrow.ListViewType:
+		f := dt.ElemField()
+		f.Type = b.values.Type()
+		return arrow.ListViewOfField(f)
+	case *arrow.LargeListViewType:
+		f := dt.ElemField()
+		f.Type = b.values.Type()
+		return arrow.LargeListViewOfField(f)
+	}
+	return nil
+}
+
+// NewLargeListViewBuilder returns a builder, using the provided memory allocator.
+// The created list-view builder will create a list whose elements will be of type etype.
+func NewLargeListViewBuilder(mem memory.Allocator, etype arrow.DataType) *LargeListViewBuilder {
+	offsetBldr := NewInt64Builder(mem)
+	sizeBldr := NewInt64Builder(mem)
+	return &LargeListViewBuilder{
+		baseListViewBuilder{
+			builder:         builder{refCount: 1, mem: mem},
+			values:          NewBuilder(mem, etype),
+			offsets:         offsetBldr,
+			sizes:           sizeBldr,
+			dt:              arrow.LargeListViewOf(etype),
+			appendOffsetVal: func(o int) { offsetBldr.Append(int64(o)) },
+			appendSizeVal:   func(s int) { sizeBldr.Append(int64(s)) },
+		},
+	}
+}
+
+// NewLargeListViewBuilderWithField takes a field rather than just an element type
+// to allow for more customization of the final type of the LargeListView Array
+func NewLargeListViewBuilderWithField(mem memory.Allocator, field arrow.Field) *LargeListViewBuilder {
+	offsetBldr := NewInt64Builder(mem)
+	sizeBldr := NewInt64Builder(mem)
+	return &LargeListViewBuilder{
+		baseListViewBuilder{
+			builder:         builder{refCount: 1, mem: mem},
+			values:          NewBuilder(mem, field.Type),
+			offsets:         offsetBldr,
+			sizes:           sizeBldr,
+			dt:              arrow.LargeListViewOfField(field),
+			appendOffsetVal: func(o int) { offsetBldr.Append(int64(o)) },
+			appendSizeVal:   func(o int) { sizeBldr.Append(int64(o)) },
+		},
+	}
+}
+
+// Release decreases the reference count by 1.
+// When the reference count goes to zero, the memory is freed.
+func (b *baseListViewBuilder) Release() {
+	debug.Assert(atomic.LoadInt64(&b.refCount) > 0, "too many releases")
+
+	if atomic.AddInt64(&b.refCount, -1) == 0 {
+		if b.nullBitmap != nil {
+			b.nullBitmap.Release()
+			b.nullBitmap = nil
+		}
+		b.values.Release()
+		b.offsets.Release()
+		b.sizes.Release()
+	}
+}
+
+func (b *baseListViewBuilder) AppendDimensions(offset int, listSize int) {
+	b.Reserve(1)
+	b.unsafeAppendBoolToBitmap(true)
+	b.appendOffsetVal(offset)
+	b.appendSizeVal(listSize)
+}
+
+func (b *baseListViewBuilder) Append(v bool) {
+	debug.Assert(false, "baseListViewBuilder.Append should never be called -- use AppendWithSize instead")
+}
+
+func (b *baseListViewBuilder) AppendWithSize(v bool, listSize int) {
+	debug.Assert(v || listSize == 0, "invalid list-view should have size 0")
+	b.Reserve(1)
+	b.unsafeAppendBoolToBitmap(v)
+	b.appendOffsetVal(b.values.Len())
+	b.appendSizeVal(listSize)
+}
+
+func (b *baseListViewBuilder) AppendNull() {
+	b.AppendWithSize(false, 0)
+}
+
+func (b *baseListViewBuilder) AppendNulls(n int) {
+	for i := 0; i < n; i++ {
+		b.AppendNull()
+	}
+}
+
+func (b *baseListViewBuilder) AppendEmptyValue() {
+	b.AppendWithSize(true, 0)
+}
+
+func (b *baseListViewBuilder) AppendEmptyValues(n int) {
+	for i := 0; i < n; i++ {
+		b.AppendEmptyValue()
+	}
+}
+
+func (b *ListViewBuilder) AppendValuesWithSizes(offsets []int32, sizes []int32, valid []bool) {
+	b.Reserve(len(valid))
+	b.offsets.(*Int32Builder).AppendValues(offsets, nil)
+	b.sizes.(*Int32Builder).AppendValues(sizes, nil)
+	b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+}
+
+func (b *LargeListViewBuilder) AppendValuesWithSizes(offsets []int64, sizes []int64, valid []bool) {
+	b.Reserve(len(valid))
+	b.offsets.(*Int64Builder).AppendValues(offsets, nil)
+	b.sizes.(*Int64Builder).AppendValues(sizes, nil)
+	b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+}
+
+func (b *baseListViewBuilder) unsafeAppendBoolToBitmap(isValid bool) {
+	if isValid {
+		bitutil.SetBit(b.nullBitmap.Bytes(), b.length)
+	} else {
+		b.nulls++
+	}
+	b.length++
+}
+
+func (b *baseListViewBuilder) init(capacity int) {
+	b.builder.init(capacity)
+	b.offsets.init(capacity)
+	b.sizes.init(capacity)
+}
+
+// Reserve ensures there is enough space for appending n elements
+// by checking the capacity and calling Resize if necessary.
+func (b *baseListViewBuilder) Reserve(n int) {
+	b.builder.reserve(n, b.resizeHelper)
+	b.offsets.Reserve(n)
+	b.sizes.Reserve(n)
+}
+
+// Resize adjusts the space allocated by b to n elements. If n is greater than b.Cap(),
+// additional memory will be allocated. If n is smaller, the allocated memory may reduced.
+func (b *baseListViewBuilder) Resize(n int) {
+	b.resizeHelper(n)
+	b.offsets.Resize(n)
+	b.sizes.Resize(n)
+}
+
+func (b *baseListViewBuilder) resizeHelper(n int) {
+	if n < minBuilderCapacity {
+		n = minBuilderCapacity
+	}
+
+	if b.capacity == 0 {
+		b.init(n)
+	} else {
+		b.builder.resize(n, b.builder.init)
+	}
+}
+
+func (b *baseListViewBuilder) ValueBuilder() Builder {
+	return b.values
+}
+
+// NewArray creates a ListView array from the memory buffers used by the builder and
+// resets the ListViewBuilder so it can be used to build a new array.
+func (b *ListViewBuilder) NewArray() arrow.Array {
+	return b.NewListViewArray()
+}
+
+// NewArray creates a LargeListView array from the memory buffers used by the builder
+// and resets the LargeListViewBuilder so it can be used to build a new array.
+func (b *LargeListViewBuilder) NewArray() arrow.Array {
+	return b.NewLargeListViewArray()
+}
+
+// NewListViewArray creates a ListView array from the memory buffers used by the builder
+// and resets the ListViewBuilder so it can be used to build a new array.
+func (b *ListViewBuilder) NewListViewArray() (a *ListView) {
+	data := b.newData()
+	a = NewListViewData(data)
+	data.Release()
+	return
+}
+
+// NewLargeListViewArray creates a ListView array from the memory buffers used by the
+// builder and resets the LargeListViewBuilder so it can be used to build a new array.
+func (b *LargeListViewBuilder) NewLargeListViewArray() (a *LargeListView) {
+	data := b.newData()
+	a = NewLargeListViewData(data)
+	data.Release()
+	return
+}
+
+func (b *baseListViewBuilder) newData() (data *Data) {
+	values := b.values.NewArray()
+	defer values.Release()
+
+	var offsets *memory.Buffer
+	if b.offsets != nil {
+		arr := b.offsets.NewArray()
+		defer arr.Release()
+		offsets = arr.Data().Buffers()[1]
+	}
+
+	var sizes *memory.Buffer
+	if b.sizes != nil {
+		arr := b.sizes.NewArray()
+		defer arr.Release()
+		sizes = arr.Data().Buffers()[1]
+	}
+
+	data = NewData(
+		b.Type(), b.length,
+		[]*memory.Buffer{
+			b.nullBitmap,
+			offsets,
+			sizes,
+		},
+		[]arrow.ArrayData{values.Data()},
+		b.nulls,
+		0,
+	)
+	b.reset()
+
+	return
+}
+
+func (b *baseListViewBuilder) AppendValueFromString(s string) error {
+	if s == NullValueStr {
+		b.AppendNull()
+		return nil
+	}
+
+	return b.UnmarshalOne(json.NewDecoder(strings.NewReader(s)))
+}
+
+func (b *baseListViewBuilder) UnmarshalOne(dec *json.Decoder) error {
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch t {
+	case json.Delim('['):
+		offset := b.values.Len()
+		// 0 is a placeholder size as we don't know the actual size yet
+		b.AppendWithSize(true, 0)
+		if err := b.values.Unmarshal(dec); err != nil {
+			return err
+		}
+		// consume ']'
+		_, err := dec.Token()
+		// replace the last size with the actual size
+		switch b.sizes.(type) {
+		case *Int32Builder:
+			b.sizes.(*Int32Builder).rawData[b.sizes.Len()-1] = int32(b.values.Len() - offset)
+		case *Int64Builder:
+			b.sizes.(*Int64Builder).rawData[b.sizes.Len()-1] = int64(b.values.Len() - offset)
+		}
+		return err
+	case nil:
+		b.AppendNull()
+	default:
+		return &json.UnmarshalTypeError{
+			Value:  fmt.Sprint(t),
+			Struct: b.dt.String(),
+		}
+	}
+
+	return nil
+}
+
+func (b *baseListViewBuilder) Unmarshal(dec *json.Decoder) error {
+	for dec.More() {
+		if err := b.UnmarshalOne(dec); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (b *baseListViewBuilder) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if delim, ok := t.(json.Delim); !ok || delim != '[' {
+		return fmt.Errorf("list-view builder must unpack from json array, found %s", delim)
+	}
+
+	return b.Unmarshal(dec)
+}
+
+// Pre-conditions:
+//
+//	input.DataType() is ListViewType
+//	input.Len() > 0 && input.NullN() != input.Len()
+func minListViewOffset32(input arrow.ArrayData) int32 {
+	var bitmap []byte
+	if input.Buffers()[0] != nil {
+		bitmap = input.Buffers()[0].Bytes()
+	}
+	offsets := arrow.Int32Traits.CastFromBytes(input.Buffers()[1].Bytes())[input.Offset():]
+	sizes := arrow.Int32Traits.CastFromBytes(input.Buffers()[2].Bytes())[input.Offset():]
+
+	isNull := func(i int) bool {
+		return bitmap != nil && bitutil.BitIsNotSet(bitmap, input.Offset()+i)
+	}
+
+	// It's very likely that the first non-null non-empty list-view starts at
+	// offset 0 of the child array.
+	i := 0
+	for i < input.Len() && (isNull(i) || sizes[i] == 0) {
+		i += 1
+	}
+	if i >= input.Len() {
+		return 0
+	}
+	minOffset := offsets[i]
+	if minOffset == 0 {
+		// early exit: offset 0 found already
+		return 0
+	}
+
+	// Slow path: scan the buffers entirely.
+	i += 1
+	for ; i < input.Len(); i += 1 {
+		if isNull(i) {
+			continue
+		}
+		offset := offsets[i]
+		if offset < minOffset && sizes[i] > 0 {
+			minOffset = offset
+		}
+	}
+	return minOffset
+}
+
+// Find the maximum offset+size in a LIST_VIEW array.
+//
+// Pre-conditions:
+//
+//	input.DataType() is ListViewType
+//	input.Len() > 0 && input.NullN() != input.Len()
+func maxListViewOffset32(input arrow.ArrayData) int {
+	inputOffset := input.Offset()
+	var bitmap []byte
+	if input.Buffers()[0] != nil {
+		bitmap = input.Buffers()[0].Bytes()
+	}
+	offsets := arrow.Int32Traits.CastFromBytes(input.Buffers()[1].Bytes())[inputOffset:]
+	sizes := arrow.Int32Traits.CastFromBytes(input.Buffers()[2].Bytes())[inputOffset:]
+
+	isNull := func(i int) bool {
+		return bitmap != nil && bitutil.BitIsNotSet(bitmap, inputOffset+i)
+	}
+
+	i := input.Len() - 1 // safe because input.Len() > 0
+	for i != 0 && (isNull(i) || sizes[i] == 0) {
+		i -= 1
+	}
+	offset := offsets[i]
+	size := sizes[i]
+	if i == 0 {
+		if isNull(i) || sizes[i] == 0 {
+			return 0
+		} else {
+			return int(offset + size)
+		}
+	}
+
+	values := input.Children()[0]
+	maxEnd := int(offsets[i] + sizes[i])
+	if maxEnd == values.Len() {
+		// Early-exit: maximum possible view-end found already.
+		return maxEnd
+	}
+
+	// Slow path: scan the buffers entirely.
+	for ; i >= 0; i -= 1 {
+		offset := offsets[i]
+		size := sizes[i]
+		if size > 0 && !isNull(i) {
+			if int(offset+size) > maxEnd {
+				maxEnd = int(offset + size)
+				if maxEnd == values.Len() {
+					return maxEnd
+				}
+			}
+		}
+	}
+	return maxEnd
+}
+
+// Pre-conditions:
+//
+//	input.DataType() is LargeListViewType
+//	input.Len() > 0 && input.NullN() != input.Len()
+func minLargeListViewOffset64(input arrow.ArrayData) int64 {
+	var bitmap []byte
+	if input.Buffers()[0] != nil {
+		bitmap = input.Buffers()[0].Bytes()
+	}
+	offsets := arrow.Int64Traits.CastFromBytes(input.Buffers()[1].Bytes())[input.Offset():]
+	sizes := arrow.Int64Traits.CastFromBytes(input.Buffers()[2].Bytes())[input.Offset():]
+
+	isNull := func(i int) bool {
+		return bitmap != nil && bitutil.BitIsNotSet(bitmap, input.Offset()+i)
+	}
+
+	// It's very likely that the first non-null non-empty list-view starts at
+	// offset 0 of the child array.
+	i := 0
+	for i < input.Len() && (isNull(i) || sizes[i] == 0) {
+		i += 1
+	}
+	if i >= input.Len() {
+		return 0
+	}
+	minOffset := offsets[i]
+	if minOffset == 0 {
+		// early exit: offset 0 found already
+		return 0
+	}
+
+	// Slow path: scan the buffers entirely.
+	i += 1
+	for ; i < input.Len(); i += 1 {
+		if isNull(i) {
+			continue
+		}
+		offset := offsets[i]
+		if offset < minOffset && sizes[i] > 0 {
+			minOffset = offset
+		}
+	}
+	return minOffset
+}
+
+// Find the maximum offset+size in a LARGE_LIST_VIEW array.
+//
+// Pre-conditions:
+//
+//	input.DataType() is LargeListViewType
+//	input.Len() > 0 && input.NullN() != input.Len()
+func maxLargeListViewOffset64(input arrow.ArrayData) int64 {
+	inputOffset := input.Offset()
+	var bitmap []byte
+	if input.Buffers()[0] != nil {
+		bitmap = input.Buffers()[0].Bytes()
+	}
+	offsets := arrow.Int64Traits.CastFromBytes(input.Buffers()[1].Bytes())[inputOffset:]
+	sizes := arrow.Int64Traits.CastFromBytes(input.Buffers()[2].Bytes())[inputOffset:]
+
+	isNull := func(i int) bool {
+		return bitmap != nil && bitutil.BitIsNotSet(bitmap, inputOffset+i)
+	}
+
+	// It's very likely that the first non-null non-empty list-view starts at
+	// offset zero, so we check that first and potentially early-return a 0.
+	i := input.Len() - 1 // safe because input.Len() > 0
+	for i != 0 && (isNull(i) || sizes[i] == 0) {
+		i -= 1
+	}
+	offset := offsets[i]
+	size := sizes[i]
+	if i == 0 {
+		if isNull(i) || sizes[i] == 0 {
+			return 0
+		} else {
+			return offset + size
+		}
+	}
+
+	if offset > math.MaxInt64-size {
+		// Early-exit: 64-bit overflow detected. This is not possible on a
+		// valid list-view, but we return the maximum possible value to
+		// avoid undefined behavior.
+		return math.MaxInt64
+	}
+	values := input.Children()[0]
+	maxEnd := offsets[i] + sizes[i]
+	if maxEnd == int64(values.Len()) {
+		// Early-exit: maximum possible view-end found already.
+		return maxEnd
+	}
+
+	// Slow path: scan the buffers entirely.
+	for ; i >= 0; i -= 1 {
+		offset := offsets[i]
+		size := sizes[i]
+		if size > 0 && !isNull(i) {
+			if offset+size > maxEnd {
+				if offset > math.MaxInt64-size {
+					// 64-bit overflow detected. This is not possible on a valid list-view,
+					// but we saturate maxEnd to the maximum possible value to avoid
+					// undefined behavior.
+					return math.MaxInt64
+				}
+				maxEnd = offset + size
+				if maxEnd == int64(values.Len()) {
+					return maxEnd
+				}
+			}
+		}
+	}
+	return maxEnd
+}
+
+func rangeOfValuesUsed(input arrow.ArrayData) (int, int) {
+	if input.Len() == 0 || input.NullN() == input.Len() {
+		return 0, 0
+	}
+	var minOffset, maxEnd int
+	switch input.DataType().(type) {
+	case *arrow.ListViewType:
+		minOffset = int(minListViewOffset32(input))
+		maxEnd = maxListViewOffset32(input)
+	case *arrow.LargeListViewType:
+		minOffset = int(minLargeListViewOffset64(input))
+		maxEnd = int(maxLargeListViewOffset64(input))
+	case *arrow.ListType:
+		offsets := arrow.Int32Traits.CastFromBytes(input.Buffers()[1].Bytes())[input.Offset():]
+		minOffset = int(offsets[0])
+		maxEnd = int(offsets[len(offsets)-1])
+	case *arrow.LargeListType:
+		offsets := arrow.Int64Traits.CastFromBytes(input.Buffers()[1].Bytes())[input.Offset():]
+		minOffset = int(offsets[0])
+		maxEnd = int(offsets[len(offsets)-1])
+	case *arrow.MapType:
+		offsets := arrow.Int32Traits.CastFromBytes(input.Buffers()[1].Bytes())[input.Offset():]
+		minOffset = int(offsets[0])
+		maxEnd = int(offsets[len(offsets)-1])
+	}
+	return minOffset, maxEnd - minOffset
+}
+
+// Returns the smallest contiguous range of values of the child array that are
+// referenced by all the list values in the input array.
+func RangeOfValuesUsed(input VarLenListLike) (int, int) {
+	return rangeOfValuesUsed(input.Data())
+}
+
 var (
 	_ arrow.Array = (*List)(nil)
 	_ arrow.Array = (*LargeList)(nil)
-	_ Builder     = (*ListBuilder)(nil)
-	_ Builder     = (*LargeListBuilder)(nil)
-
-	_ ListLike = (*List)(nil)
-	_ ListLike = (*LargeList)(nil)
-	_ ListLike = (*FixedSizeList)(nil)
-	_ ListLike = (*Map)(nil)
-
-	_ ListLikeBuilder = (*ListBuilder)(nil)
-	_ ListLikeBuilder = (*LargeListBuilder)(nil)
-	_ ListLikeBuilder = (*FixedSizeListBuilder)(nil)
-	_ ListLikeBuilder = (*MapBuilder)(nil)
+	_ arrow.Array = (*ListView)(nil)
+	_ arrow.Array = (*LargeListView)(nil)
+
+	_ Builder = (*ListBuilder)(nil)
+	_ Builder = (*LargeListBuilder)(nil)
+	_ Builder = (*ListViewBuilder)(nil)
+	_ Builder = (*LargeListViewBuilder)(nil)
+
+	_ VarLenListLike = (*List)(nil)
+	_ VarLenListLike = (*LargeList)(nil)
+	_ VarLenListLike = (*Map)(nil)
+	_ VarLenListLike = (*ListView)(nil)
+	_ VarLenListLike = (*LargeListView)(nil)
+	_ ListLike       = (*FixedSizeList)(nil)
+
+	_ VarLenListLikeBuilder = (*ListBuilder)(nil)
+	_ VarLenListLikeBuilder = (*LargeListBuilder)(nil)
+	_ VarLenListLikeBuilder = (*ListBuilder)(nil)
+	_ VarLenListLikeBuilder = (*LargeListBuilder)(nil)
+	_ VarLenListLikeBuilder = (*MapBuilder)(nil)
+	_ ListLikeBuilder       = (*FixedSizeListBuilder)(nil)
 )
diff --git a/go/arrow/array/list_test.go b/go/arrow/array/list_test.go
index 9f193fe19aabd..bf3555b3f6603 100644
--- a/go/arrow/array/list_test.go
+++ b/go/arrow/array/list_test.go
@@ -30,12 +30,15 @@ func TestListArray(t *testing.T) {
 	tests := []struct {
 		typeID  arrow.Type
 		offsets interface{}
+		sizes   interface{}
 		dt      arrow.DataType
 	}{
-		{arrow.LIST, []int32{0, 3, 3, 3, 7}, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
-		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
-		{arrow.LIST, []int32{0, 3, 3, 3, 7}, arrow.ListOfField(arrow.Field{Name: "item", Type: arrow.PrimitiveTypes.Int32, Nullable: true})},
-		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, arrow.LargeListOfField(arrow.Field{Name: "item", Type: arrow.PrimitiveTypes.Int32, Nullable: true})},
+		{arrow.LIST, []int32{0, 3, 3, 3, 7}, nil, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, nil, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LIST, []int32{0, 3, 3, 3, 7}, nil, arrow.ListOfField(arrow.Field{Name: "item", Type: arrow.PrimitiveTypes.Int32, Nullable: true})},
+		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, nil, arrow.LargeListOfField(arrow.Field{Name: "item", Type: arrow.PrimitiveTypes.Int32, Nullable: true})},
+		{arrow.LIST_VIEW, []int32{0, 3, 3, 3}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{0, 3, 3, 3}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
 	}
 
 	for _, tt := range tests {
@@ -49,7 +52,7 @@ func TestListArray(t *testing.T) {
 				isValid = []bool{true, false, true, true}
 			)
 
-			lb := array.NewBuilder(pool, tt.dt).(array.ListLikeBuilder)
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
 			defer lb.Release()
 
 			for i := 0; i < 10; i++ {
@@ -58,7 +61,7 @@ func TestListArray(t *testing.T) {
 
 				pos := 0
 				for i, length := range lengths {
-					lb.Append(isValid[i])
+					lb.AppendWithSize(isValid[i], length)
 					for j := 0; j < length; j++ {
 						vb.Append(vs[pos])
 						pos++
@@ -88,18 +91,32 @@ func TestListArray(t *testing.T) {
 					}
 				}
 
-				var got interface{}
+				var gotOffsets, gotSizes interface{}
 				switch tt.typeID {
 				case arrow.LIST:
 					arr := arr.(*array.List)
-					got = arr.Offsets()
+					gotOffsets = arr.Offsets()
 				case arrow.LARGE_LIST:
 					arr := arr.(*array.LargeList)
-					got = arr.Offsets()
+					gotOffsets = arr.Offsets()
+				case arrow.LIST_VIEW:
+					arr := arr.(*array.ListView)
+					gotOffsets = arr.Offsets()
+					gotSizes = arr.Sizes()
+				case arrow.LARGE_LIST_VIEW:
+					arr := arr.(*array.LargeListView)
+					gotOffsets = arr.Offsets()
+					gotSizes = arr.Sizes()
 				}
 
-				if !reflect.DeepEqual(got, tt.offsets) {
-					t.Fatalf("got=%v, want=%v", got, tt.offsets)
+				if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+					t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+				}
+
+				if tt.typeID == arrow.LIST_VIEW || tt.typeID == arrow.LARGE_LIST_VIEW {
+					if !reflect.DeepEqual(gotSizes, tt.sizes) {
+						t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
+					}
 				}
 
 				varr := arr.ListValues().(*array.Int32)
@@ -109,13 +126,110 @@ func TestListArray(t *testing.T) {
 			}
 		})
 	}
+}
+
+// Like the list-view tests in TestListArray, but with out-of-order offsets.
+func TestListViewArray(t *testing.T) {
+	tests := []struct {
+		typeID  arrow.Type
+		offsets interface{}
+		sizes   interface{}
+		dt      arrow.DataType
+	}{
+		{arrow.LIST_VIEW, []int32{5, 0, 0, 1}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{5, 0, 0, 1}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.typeID.String(), func(t *testing.T) {
+			pool := memory.NewCheckedAllocator(memory.NewGoAllocator())
+			defer pool.AssertSize(t, 0)
 
+			var (
+				vs      = []int32{-1, 3, 4, 5, 6, 0, 1, 2}
+				lengths = []int{3, 0, 0, 4}
+				isValid = []bool{true, false, true, true}
+			)
+
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
+			defer lb.Release()
+
+			for i := 0; i < 10; i++ {
+				switch lvb := lb.(type) {
+				case *array.ListViewBuilder:
+					lvb.AppendDimensions(5, 3)
+					lb.AppendNull()
+					lvb.AppendDimensions(0, 0)
+					lvb.AppendDimensions(1, 4)
+				case *array.LargeListViewBuilder:
+					lvb.AppendDimensions(5, 3)
+					lb.AppendNull()
+					lvb.AppendDimensions(0, 0)
+					lvb.AppendDimensions(1, 4)
+				}
+
+				vb := lb.ValueBuilder().(*array.Int32Builder)
+				vb.Reserve(len(vs))
+				vb.AppendValues(vs, []bool{false, true, true, true, true, true, true, true})
+
+				arr := lb.NewArray().(array.ListLike)
+				defer arr.Release()
+
+				arr.Retain()
+				arr.Release()
+
+				if got, want := arr.DataType().ID(), tt.typeID; got != want {
+					t.Fatalf("got=%v, want=%v", got, want)
+				}
+
+				if got, want := arr.Len(), len(isValid); got != want {
+					t.Fatalf("got=%d, want=%d", got, want)
+				}
+
+				for i := range lengths {
+					if got, want := arr.IsValid(i), isValid[i]; got != want {
+						t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+					}
+					if got, want := arr.IsNull(i), !isValid[i]; got != want {
+						t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+					}
+				}
+
+				var gotOffsets, gotSizes interface{}
+				switch tt.typeID {
+				case arrow.LIST_VIEW:
+					arr := arr.(*array.ListView)
+					gotOffsets = arr.Offsets()
+					gotSizes = arr.Sizes()
+				case arrow.LARGE_LIST_VIEW:
+					arr := arr.(*array.LargeListView)
+					gotOffsets = arr.Offsets()
+					gotSizes = arr.Sizes()
+				}
+
+				if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+					t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+				}
+
+				if !reflect.DeepEqual(gotSizes, tt.sizes) {
+					t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
+				}
+
+				varr := arr.ListValues().(*array.Int32)
+				if got, want := varr.Int32Values(), vs; !reflect.DeepEqual(got, want) {
+					t.Fatalf("got=%v, want=%v", got, want)
+				}
+			}
+		})
+	}
 }
 
 func TestListArrayEmpty(t *testing.T) {
 	typ := []arrow.DataType{
 		arrow.ListOf(arrow.PrimitiveTypes.Int32),
 		arrow.LargeListOf(arrow.PrimitiveTypes.Int32),
+		arrow.ListViewOf(arrow.PrimitiveTypes.Int32),
+		arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32),
 	}
 
 	for _, dt := range typ {
@@ -138,10 +252,13 @@ func TestListArrayBulkAppend(t *testing.T) {
 	tests := []struct {
 		typeID  arrow.Type
 		offsets interface{}
+		sizes   interface{}
 		dt      arrow.DataType
 	}{
-		{arrow.LIST, []int32{0, 3, 3, 3, 7}, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
-		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LIST, []int32{0, 3, 3, 3, 7}, nil, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, nil, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LIST_VIEW, []int32{0, 3, 3, 3}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{0, 3, 3, 3}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
 	}
 
 	for _, tt := range tests {
@@ -155,7 +272,7 @@ func TestListArrayBulkAppend(t *testing.T) {
 				isValid = []bool{true, false, true, true}
 			)
 
-			lb := array.NewBuilder(pool, tt.dt).(array.ListLikeBuilder)
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
 			defer lb.Release()
 			vb := lb.ValueBuilder().(*array.Int32Builder)
 			vb.Reserve(len(vs))
@@ -165,12 +282,16 @@ func TestListArrayBulkAppend(t *testing.T) {
 				lb.(*array.ListBuilder).AppendValues(tt.offsets.([]int32), isValid)
 			case arrow.LARGE_LIST:
 				lb.(*array.LargeListBuilder).AppendValues(tt.offsets.([]int64), isValid)
+			case arrow.LIST_VIEW:
+				lb.(*array.ListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int32), tt.sizes.([]int32), isValid)
+			case arrow.LARGE_LIST_VIEW:
+				lb.(*array.LargeListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int64), tt.sizes.([]int64), isValid)
 			}
 			for _, v := range vs {
 				vb.Append(v)
 			}
 
-			arr := lb.NewArray().(array.ListLike)
+			arr := lb.NewArray().(array.VarLenListLike)
 			defer arr.Release()
 
 			if got, want := arr.DataType().ID(), tt.typeID; got != want {
@@ -190,18 +311,115 @@ func TestListArrayBulkAppend(t *testing.T) {
 				}
 			}
 
-			var got interface{}
+			var gotOffsets, gotSizes interface{}
 			switch tt.typeID {
 			case arrow.LIST:
 				arr := arr.(*array.List)
-				got = arr.Offsets()
+				gotOffsets = arr.Offsets()
 			case arrow.LARGE_LIST:
 				arr := arr.(*array.LargeList)
-				got = arr.Offsets()
+				gotOffsets = arr.Offsets()
+			case arrow.LIST_VIEW:
+				arr := arr.(*array.ListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			case arrow.LARGE_LIST_VIEW:
+				arr := arr.(*array.LargeListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			}
+
+			if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+				t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+			}
+			if tt.typeID == arrow.LIST_VIEW || tt.typeID == arrow.LARGE_LIST_VIEW {
+				if !reflect.DeepEqual(gotSizes, tt.sizes) {
+					t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
+				}
+			}
+
+			varr := arr.ListValues().(*array.Int32)
+			if got, want := varr.Int32Values(), vs; !reflect.DeepEqual(got, want) {
+				t.Fatalf("got=%v, want=%v", got, want)
+			}
+		})
+	}
+}
+
+func TestListViewArrayBulkAppend(t *testing.T) {
+	tests := []struct {
+		typeID  arrow.Type
+		offsets interface{}
+		sizes   interface{}
+		dt      arrow.DataType
+	}{
+		{arrow.LIST_VIEW, []int32{5, 0, 0, 1}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{5, 0, 0, 1}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.typeID.String(), func(t *testing.T) {
+			pool := memory.NewCheckedAllocator(memory.NewGoAllocator())
+			defer pool.AssertSize(t, 0)
+
+			var (
+				vs      = []int32{-1, 3, 4, 5, 6, 0, 1, 2}
+				lengths = []int{3, 0, 0, 4}
+				isValid = []bool{true, false, true, true}
+			)
+
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
+			defer lb.Release()
+			vb := lb.ValueBuilder().(*array.Int32Builder)
+			vb.Reserve(len(vs))
+
+			switch tt.typeID {
+			case arrow.LIST_VIEW:
+				lb.(*array.ListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int32), tt.sizes.([]int32), isValid)
+			case arrow.LARGE_LIST_VIEW:
+				lb.(*array.LargeListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int64), tt.sizes.([]int64), isValid)
+			}
+			for _, v := range vs {
+				vb.Append(v)
+			}
+
+			arr := lb.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+
+			if got, want := arr.DataType().ID(), tt.typeID; got != want {
+				t.Fatalf("got=%v, want=%v", got, want)
+			}
+
+			if got, want := arr.Len(), len(isValid); got != want {
+				t.Fatalf("got=%d, want=%d", got, want)
+			}
+
+			for i := range lengths {
+				if got, want := arr.IsValid(i), isValid[i]; got != want {
+					t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+				}
+				if got, want := arr.IsNull(i), !isValid[i]; got != want {
+					t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+				}
+			}
+
+			var gotOffsets, gotSizes interface{}
+			switch tt.typeID {
+			case arrow.LIST_VIEW:
+				arr := arr.(*array.ListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			case arrow.LARGE_LIST_VIEW:
+				arr := arr.(*array.LargeListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
 			}
 
-			if !reflect.DeepEqual(got, tt.offsets) {
-				t.Fatalf("got=%v, want=%v", got, tt.offsets)
+			if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+				t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+			}
+			if !reflect.DeepEqual(gotSizes, tt.sizes) {
+				t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
 			}
 
 			varr := arr.ListValues().(*array.Int32)
@@ -216,10 +434,13 @@ func TestListArraySlice(t *testing.T) {
 	tests := []struct {
 		typeID  arrow.Type
 		offsets interface{}
+		sizes   interface{}
 		dt      arrow.DataType
 	}{
-		{arrow.LIST, []int32{0, 3, 3, 3, 7}, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
-		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LIST, []int32{0, 3, 3, 3, 7}, nil, arrow.ListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST, []int64{0, 3, 3, 3, 7}, nil, arrow.LargeListOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LIST_VIEW, []int32{0, 3, 3, 3, 7}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{0, 3, 3, 3, 7}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
 	}
 
 	for _, tt := range tests {
@@ -233,7 +454,7 @@ func TestListArraySlice(t *testing.T) {
 				isValid = []bool{true, false, true, true}
 			)
 
-			lb := array.NewBuilder(pool, tt.dt).(array.ListLikeBuilder)
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
 			defer lb.Release()
 			vb := lb.ValueBuilder().(*array.Int32Builder)
 			vb.Reserve(len(vs))
@@ -243,12 +464,16 @@ func TestListArraySlice(t *testing.T) {
 				lb.(*array.ListBuilder).AppendValues(tt.offsets.([]int32), isValid)
 			case arrow.LARGE_LIST:
 				lb.(*array.LargeListBuilder).AppendValues(tt.offsets.([]int64), isValid)
+			case arrow.LIST_VIEW:
+				lb.(*array.ListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int32), tt.sizes.([]int32), isValid)
+			case arrow.LARGE_LIST_VIEW:
+				lb.(*array.LargeListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int64), tt.sizes.([]int64), isValid)
 			}
 			for _, v := range vs {
 				vb.Append(v)
 			}
 
-			arr := lb.NewArray().(array.ListLike)
+			arr := lb.NewArray().(array.VarLenListLike)
 			defer arr.Release()
 
 			if got, want := arr.DataType().ID(), tt.typeID; got != want {
@@ -268,18 +493,129 @@ func TestListArraySlice(t *testing.T) {
 				}
 			}
 
-			var got interface{}
+			var gotOffsets, gotSizes interface{}
 			switch tt.typeID {
 			case arrow.LIST:
 				arr := arr.(*array.List)
-				got = arr.Offsets()
+				gotOffsets = arr.Offsets()
 			case arrow.LARGE_LIST:
 				arr := arr.(*array.LargeList)
-				got = arr.Offsets()
+				gotOffsets = arr.Offsets()
+			case arrow.LIST_VIEW:
+				arr := arr.(*array.ListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			case arrow.LARGE_LIST_VIEW:
+				arr := arr.(*array.LargeListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			}
+
+			if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+				t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+			}
+
+			if tt.typeID == arrow.LIST_VIEW || tt.typeID == arrow.LARGE_LIST_VIEW {
+				if !reflect.DeepEqual(gotSizes, tt.sizes) {
+					t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
+				}
+			}
+
+			varr := arr.ListValues().(*array.Int32)
+			if got, want := varr.Int32Values(), vs; !reflect.DeepEqual(got, want) {
+				t.Fatalf("got=%v, want=%v", got, want)
+			}
+
+			if got, want := arr.String(), `[[0 1 2] (null) [] [3 4 5 6]]`; got != want {
+				t.Fatalf("got=%q, want=%q", got, want)
+			}
+			assert.Equal(t, "[0,1,2]", arr.ValueStr(0))
+
+			sub := array.NewSlice(arr, 1, 4).(array.ListLike)
+			defer sub.Release()
+
+			if got, want := sub.String(), `[(null) [] [3 4 5 6]]`; got != want {
+				t.Fatalf("got=%q, want=%q", got, want)
+			}
+		})
+	}
+}
+
+func TestLisViewtArraySlice(t *testing.T) {
+	tests := []struct {
+		typeID  arrow.Type
+		offsets interface{}
+		sizes   interface{}
+		dt      arrow.DataType
+	}{
+		{arrow.LIST_VIEW, []int32{5, 0, 0, 1}, []int32{3, 0, 0, 4}, arrow.ListViewOf(arrow.PrimitiveTypes.Int32)},
+		{arrow.LARGE_LIST_VIEW, []int64{5, 0, 0, 1}, []int64{3, 0, 0, 4}, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int32)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.typeID.String(), func(t *testing.T) {
+			pool := memory.NewCheckedAllocator(memory.NewGoAllocator())
+			defer pool.AssertSize(t, 0)
+
+			var (
+				vs      = []int32{-1, 3, 4, 5, 6, 0, 1, 2}
+				lengths = []int{3, 0, 0, 4}
+				isValid = []bool{true, false, true, true}
+			)
+
+			lb := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
+			defer lb.Release()
+			vb := lb.ValueBuilder().(*array.Int32Builder)
+			vb.Reserve(len(vs))
+
+			switch tt.typeID {
+			case arrow.LIST_VIEW:
+				lb.(*array.ListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int32), tt.sizes.([]int32), isValid)
+			case arrow.LARGE_LIST_VIEW:
+				lb.(*array.LargeListViewBuilder).AppendValuesWithSizes(tt.offsets.([]int64), tt.sizes.([]int64), isValid)
+			}
+			for _, v := range vs {
+				vb.Append(v)
+			}
+
+			arr := lb.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+
+			if got, want := arr.DataType().ID(), tt.typeID; got != want {
+				t.Fatalf("got=%v, want=%v", got, want)
+			}
+
+			if got, want := arr.Len(), len(isValid); got != want {
+				t.Fatalf("got=%d, want=%d", got, want)
 			}
 
-			if !reflect.DeepEqual(got, tt.offsets) {
-				t.Fatalf("got=%v, want=%v", got, tt.offsets)
+			for i := range lengths {
+				if got, want := arr.IsValid(i), isValid[i]; got != want {
+					t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+				}
+				if got, want := arr.IsNull(i), !isValid[i]; got != want {
+					t.Fatalf("got[%d]=%v, want[%d]=%v", i, got, i, want)
+				}
+			}
+
+			var gotOffsets, gotSizes interface{}
+			switch tt.typeID {
+			case arrow.LIST_VIEW:
+				arr := arr.(*array.ListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			case arrow.LARGE_LIST_VIEW:
+				arr := arr.(*array.LargeListView)
+				gotOffsets = arr.Offsets()
+				gotSizes = arr.Sizes()
+			}
+
+			if !reflect.DeepEqual(gotOffsets, tt.offsets) {
+				t.Fatalf("got=%v, want=%v", gotOffsets, tt.offsets)
+			}
+
+			if !reflect.DeepEqual(gotSizes, tt.sizes) {
+				t.Fatalf("got=%v, want=%v", gotSizes, tt.sizes)
 			}
 
 			varr := arr.ListValues().(*array.Int32)
@@ -302,86 +638,227 @@ func TestListArraySlice(t *testing.T) {
 	}
 }
 
-func TestListStringRoundTrip(t *testing.T) {
+func TestVarLenListLikeStringRoundTrip(t *testing.T) {
 	// 1. create array
 	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
 	defer mem.AssertSize(t, 0)
 
-	b := array.NewListBuilder(mem, arrow.PrimitiveTypes.Int32)
-	defer b.Release()
-	vb := b.ValueBuilder().(*array.Int32Builder)
+	builders := []array.VarLenListLikeBuilder{
+		array.NewListBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+	}
 
-	var values = [][]int32{
-		{0, 1, 2, 3, 4, 5, 6},
-		{1, 2, 3, 4, 5, 6, 7},
-		{2, 3, 4, 5, 6, 7, 8},
-		{3, 4, 5, 6, 7, 8, 9},
+	builders1 := []array.VarLenListLikeBuilder{
+		array.NewListBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
 	}
-	for _, value := range values {
-		b.AppendNull()
-		b.Append(true)
-		for _, el := range value {
-			vb.Append(el)
-			vb.AppendNull()
+
+	for i, b := range builders {
+		defer b.Release()
+
+		vb := b.ValueBuilder().(*array.Int32Builder)
+
+		var values = [][]int32{
+			{0, 1, 2, 3, 4, 5, 6},
+			{1, 2, 3, 4, 5, 6, 7},
+			{2, 3, 4, 5, 6, 7, 8},
+			{3, 4, 5, 6, 7, 8, 9},
+		}
+		for _, value := range values {
+			b.AppendNull()
+			b.AppendWithSize(true, 2*len(value))
+			for _, el := range value {
+				vb.Append(el)
+				vb.AppendNull()
+			}
+			b.AppendWithSize(false, 0)
 		}
-		b.Append(false)
-	}
 
-	arr := b.NewArray().(*array.List)
-	defer arr.Release()
+		arr := b.NewArray()
+		defer arr.Release()
 
-	// 2. create array via AppendValueFromString
-	b1 := array.NewListBuilder(mem, arrow.PrimitiveTypes.Int32)
-	defer b1.Release()
+		// 2. create array via AppendValueFromString
+		b1 := builders1[i]
+		defer b1.Release()
 
-	for i := 0; i < arr.Len(); i++ {
-		assert.NoError(t, b1.AppendValueFromString(arr.ValueStr(i)))
-	}
+		for i := 0; i < arr.Len(); i++ {
+			assert.NoError(t, b1.AppendValueFromString(arr.ValueStr(i)))
+		}
 
-	arr1 := b1.NewArray().(*array.List)
-	defer arr1.Release()
+		arr1 := b1.NewArray()
+		defer arr1.Release()
 
-	assert.True(t, array.Equal(arr, arr1))
+		assert.True(t, array.Equal(arr, arr1))
+	}
 }
 
-func TestLargeListStringRoundTrip(t *testing.T) {
+// Test the string roun-trip for a list-view containing out-of-order offsets.
+func TestListViewStringRoundTrip(t *testing.T) {
 	// 1. create array
 	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
 	defer mem.AssertSize(t, 0)
 
-	b := array.NewLargeListBuilder(mem, arrow.PrimitiveTypes.Int32)
-	defer b.Release()
-	vb := b.ValueBuilder().(*array.Int32Builder)
+	builders := []array.VarLenListLikeBuilder{
+		array.NewListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+	}
 
-	var values = [][]int32{
-		{0, 1, 2, 3, 4, 5, 6},
-		{1, 2, 3, 4, 5, 6, 7},
-		{2, 3, 4, 5, 6, 7, 8},
-		{3, 4, 5, 6, 7, 8, 9},
+	builders1 := []array.VarLenListLikeBuilder{
+		array.NewListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
+		array.NewLargeListViewBuilder(mem, arrow.PrimitiveTypes.Int32),
 	}
-	for _, value := range values {
-		b.AppendNull()
-		b.Append(true)
-		for _, el := range value {
-			vb.Append(el)
-			vb.AppendNull()
+
+	for i, b := range builders {
+		defer b.Release()
+
+		switch lvb := b.(type) {
+		case *array.ListViewBuilder:
+			lvb.AppendDimensions(5, 3)
+			b.AppendNull()
+			lvb.AppendDimensions(0, 0)
+			lvb.AppendDimensions(1, 4)
+		case *array.LargeListViewBuilder:
+			lvb.AppendDimensions(5, 3)
+			b.AppendNull()
+			lvb.AppendDimensions(0, 0)
+			lvb.AppendDimensions(1, 4)
 		}
-		b.Append(false)
-	}
 
-	arr := b.NewArray().(*array.LargeList)
-	defer arr.Release()
+		vb := b.ValueBuilder().(*array.Int32Builder)
+
+		vs := []int32{-1, 3, 4, 5, 6, 0, 1, 2}
+		isValid := []bool{false, true, true, true, true, true, true, true}
+		vb.Reserve(len(vs))
+		vb.AppendValues(vs, isValid)
+
+		arr := b.NewArray()
+		defer arr.Release()
+
+		// 2. create array via AppendValueFromString
+		b1 := builders1[i]
+		defer b1.Release()
+
+		for i := 0; i < arr.Len(); i++ {
+			assert.NoError(t, b1.AppendValueFromString(arr.ValueStr(i)))
+		}
 
-	// 2. create array via AppendValueFromString
-	b1 := array.NewLargeListBuilder(mem, arrow.PrimitiveTypes.Int32)
-	defer b1.Release()
+		arr1 := b1.NewArray()
+		defer arr1.Release()
 
-	for i := 0; i < arr.Len(); i++ {
-		assert.NoError(t, b1.AppendValueFromString(arr.ValueStr(i)))
+		assert.True(t, array.Equal(arr, arr1))
 	}
+}
+
+func TestRangeOfValuesUsed(t *testing.T) {
+	tests := []struct {
+		typeID arrow.Type
+		dt     arrow.DataType
+	}{
+		{arrow.LIST, arrow.ListOf(arrow.PrimitiveTypes.Int16)},
+		{arrow.LARGE_LIST, arrow.LargeListOf(arrow.PrimitiveTypes.Int16)},
+		{arrow.LIST_VIEW, arrow.ListViewOf(arrow.PrimitiveTypes.Int16)},
+		{arrow.LARGE_LIST_VIEW, arrow.LargeListViewOf(arrow.PrimitiveTypes.Int16)},
+	}
+	for _, tt := range tests {
+		t.Run(tt.typeID.String(), func(t *testing.T) {
+			pool := memory.NewCheckedAllocator(memory.NewGoAllocator())
+			defer pool.AssertSize(t, 0)
+
+			isListView := tt.typeID == arrow.LIST_VIEW || tt.typeID == arrow.LARGE_LIST_VIEW
+
+			bldr := array.NewBuilder(pool, tt.dt).(array.VarLenListLikeBuilder)
+			defer bldr.Release()
 
-	arr1 := b1.NewArray().(*array.LargeList)
-	defer arr1.Release()
+			var arr array.VarLenListLike
 
-	assert.True(t, array.Equal(arr, arr1))
+			// Empty array
+			arr = bldr.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+			offset, len := array.RangeOfValuesUsed(arr)
+			assert.Equal(t, 0, offset)
+			assert.Equal(t, 0, len)
+
+			// List-like array with only nulls
+			bldr.AppendNulls(3)
+			arr = bldr.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+			offset, len = array.RangeOfValuesUsed(arr)
+			assert.Equal(t, 0, offset)
+			assert.Equal(t, 0, len)
+
+			// Array with nulls and non-nulls (starting at a non-zero offset)
+			vb := bldr.ValueBuilder().(*array.Int16Builder)
+			vb.Append(-2)
+			vb.Append(-1)
+			bldr.AppendWithSize(false, 0)
+			bldr.AppendWithSize(true, 2)
+			vb.Append(0)
+			vb.Append(1)
+			bldr.AppendWithSize(true, 3)
+			vb.Append(2)
+			vb.Append(3)
+			vb.Append(4)
+			if isListView {
+				vb.Append(10)
+				vb.Append(11)
+			}
+			arr = bldr.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+			offset, len = array.RangeOfValuesUsed(arr)
+			assert.Equal(t, 2, offset)
+			assert.Equal(t, 5, len)
+
+			// Overlapping list-views
+			// [null, [0, 1, 2, 3, 4, 5], [1, 2], null, [4], null, null]
+			vb = bldr.ValueBuilder().(*array.Int16Builder)
+			vb.Append(-2)
+			vb.Append(-1)
+			bldr.AppendWithSize(false, 0)
+			if isListView {
+				bldr.AppendWithSize(true, 6)
+				vb.Append(0)
+				bldr.AppendWithSize(true, 2)
+				vb.Append(1)
+				vb.Append(2)
+				vb.Append(3)
+				bldr.AppendWithSize(false, 0)
+				bldr.AppendWithSize(true, 1)
+				vb.Append(4)
+				vb.Append(5)
+				// -- used range ends here --
+				vb.Append(10)
+				vb.Append(11)
+			} else {
+				bldr.AppendWithSize(true, 6)
+				vb.Append(0)
+				vb.Append(1)
+				vb.Append(2)
+				vb.Append(3)
+				vb.Append(4)
+				vb.Append(5)
+				bldr.AppendWithSize(true, 2)
+				vb.Append(1)
+				vb.Append(2)
+				bldr.AppendWithSize(false, 0)
+				bldr.AppendWithSize(true, 1)
+				vb.Append(4)
+			}
+			bldr.AppendNulls(2)
+			arr = bldr.NewArray().(array.VarLenListLike)
+			defer arr.Release()
+
+			// Check the range
+			offset, len = array.RangeOfValuesUsed(arr)
+			assert.Equal(t, 2, offset)
+			if isListView {
+				assert.Equal(t, 6, len)
+			} else {
+				assert.Equal(t, 9, len)
+			}
+		})
+	}
 }
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index 4fe860f26ef61..9945a90ce495e 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -222,6 +222,10 @@ func (b *MapBuilder) Append(v bool) {
 	b.listBuilder.Append(v)
 }
 
+func (b *MapBuilder) AppendWithSize(v bool, _ int) {
+	b.Append(v)
+}
+
 // AppendNull adds a null map entry to the array.
 func (b *MapBuilder) AppendNull() {
 	b.Append(false)
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index d784c2bfe0767..f0fb24ec873c5 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -152,6 +152,19 @@ const (
 
 	RUN_END_ENCODED
 
+	// String (UTF8) view type with 4-byte prefix and inline
+	// small string optimizations
+	STRING_VIEW
+
+	// Bytes view with 4-byte prefix and inline small byte arrays optimization
+	BINARY_VIEW
+
+	// LIST_VIEW is a list of some logical data type represented with offsets and sizes
+	LIST_VIEW
+
+	// like LIST but with 64-bit offsets
+	LARGE_LIST_VIEW
+
 	// Alias to ensure we do not break any consumers
 	DECIMAL = DECIMAL128
 )
@@ -384,7 +397,7 @@ func IsListLike(t Type) bool {
 // IsNested returns true for List, LargeList, FixedSizeList, Map, Struct, and Unions
 func IsNested(t Type) bool {
 	switch t {
-	case LIST, LARGE_LIST, FIXED_SIZE_LIST, MAP, STRUCT, SPARSE_UNION, DENSE_UNION:
+	case LIST, LARGE_LIST, FIXED_SIZE_LIST, MAP, LIST_VIEW, LARGE_LIST_VIEW, STRUCT, SPARSE_UNION, DENSE_UNION:
 		return true
 	}
 	return false
diff --git a/go/arrow/datatype_nested.go b/go/arrow/datatype_nested.go
index 50777929c00a6..4ae4880334620 100644
--- a/go/arrow/datatype_nested.go
+++ b/go/arrow/datatype_nested.go
@@ -39,6 +39,10 @@ type (
 		Elem() DataType
 		ElemField() Field
 	}
+
+	VarLenListLikeType interface {
+		ListLikeType
+	}
 )
 
 // ListType describes a nested type in which each array slot contains
@@ -242,6 +246,142 @@ func (*FixedSizeListType) Layout() DataTypeLayout {
 	return DataTypeLayout{Buffers: []BufferSpec{SpecBitmap()}}
 }
 
+type ListViewType struct {
+	elem Field
+}
+
+func ListViewOfField(f Field) *ListViewType {
+	if f.Type == nil {
+		panic("arrow: nil DataType")
+	}
+	return &ListViewType{elem: f}
+}
+
+// ListViewOf returns the list-view type with element type t.
+// For example, if t represents int32, ListViewOf(t) represents []int32.
+//
+// ListViewOf panics if t is nil or invalid. NullableElem defaults to true
+func ListViewOf(t DataType) *ListViewType {
+	if t == nil {
+		panic("arrow: nil DataType")
+	}
+	return &ListViewType{elem: Field{Name: "item", Type: t, Nullable: true}}
+}
+
+// ListViewOfNonNullable is like ListViewOf but NullableElem defaults to false, indicating
+// that the child type should be marked as non-nullable.
+func ListViewOfNonNullable(t DataType) *ListViewType {
+	if t == nil {
+		panic("arrow: nil DataType")
+	}
+	return &ListViewType{elem: Field{Name: "item", Type: t, Nullable: false}}
+}
+
+func (*ListViewType) ID() Type     { return LIST_VIEW }
+func (*ListViewType) Name() string { return "list_view" }
+
+func (t *ListViewType) String() string {
+	if t.elem.Nullable {
+		return fmt.Sprintf("list_view<%s: %s, nullable>", t.elem.Name, t.elem.Type)
+	}
+	return fmt.Sprintf("list_view<%s: %s>", t.elem.Name, t.elem.Type)
+}
+
+func (t *ListViewType) Fingerprint() string {
+	child := t.elem.Type.Fingerprint()
+	if len(child) > 0 {
+		return typeFingerprint(t) + "{" + child + "}"
+	}
+	return ""
+}
+
+func (t *ListViewType) SetElemMetadata(md Metadata) { t.elem.Metadata = md }
+
+func (t *ListViewType) SetElemNullable(n bool) { t.elem.Nullable = n }
+
+// Elem returns the ListViewType's element type.
+func (t *ListViewType) Elem() DataType { return t.elem.Type }
+
+func (t *ListViewType) ElemField() Field {
+	return t.elem
+}
+
+func (t *ListViewType) Fields() []Field { return []Field{t.ElemField()} }
+
+func (*ListViewType) Layout() DataTypeLayout {
+	return DataTypeLayout{Buffers: []BufferSpec{SpecBitmap(), SpecFixedWidth(Int32SizeBytes), SpecFixedWidth(Int32SizeBytes)}}
+}
+
+func (*ListViewType) OffsetTypeTraits() OffsetTraits { return Int32Traits }
+
+type LargeListViewType struct {
+	elem Field
+}
+
+func LargeListViewOfField(f Field) *LargeListViewType {
+	if f.Type == nil {
+		panic("arrow: nil DataType")
+	}
+	return &LargeListViewType{elem: f}
+}
+
+// LargeListViewOf returns the list-view type with element type t.
+// For example, if t represents int32, LargeListViewOf(t) represents []int32.
+//
+// LargeListViewOf panics if t is nil or invalid. NullableElem defaults to true
+func LargeListViewOf(t DataType) *LargeListViewType {
+	if t == nil {
+		panic("arrow: nil DataType")
+	}
+	return &LargeListViewType{elem: Field{Name: "item", Type: t, Nullable: true}}
+}
+
+// LargeListViewOfNonNullable is like LargeListViewOf but NullableElem defaults
+// to false, indicating that the child type should be marked as non-nullable.
+func LargeListViewOfNonNullable(t DataType) *LargeListViewType {
+	if t == nil {
+		panic("arrow: nil DataType")
+	}
+	return &LargeListViewType{elem: Field{Name: "item", Type: t, Nullable: false}}
+}
+
+func (*LargeListViewType) ID() Type     { return LARGE_LIST_VIEW }
+func (*LargeListViewType) Name() string { return "large_list_view" }
+
+func (t *LargeListViewType) String() string {
+	if t.elem.Nullable {
+		return fmt.Sprintf("large_list_view<%s: %s, nullable>", t.elem.Name, t.elem.Type)
+	}
+	return fmt.Sprintf("large_list_view<%s: %s>", t.elem.Name, t.elem.Type)
+}
+
+func (t *LargeListViewType) Fingerprint() string {
+	child := t.elem.Type.Fingerprint()
+	if len(child) > 0 {
+		return typeFingerprint(t) + "{" + child + "}"
+	}
+	return ""
+}
+
+func (t *LargeListViewType) SetElemMetadata(md Metadata) { t.elem.Metadata = md }
+
+func (t *LargeListViewType) SetElemNullable(n bool) { t.elem.Nullable = n }
+
+// Elem returns the LargeListViewType's element type.
+func (t *LargeListViewType) Elem() DataType { return t.elem.Type }
+
+func (t *LargeListViewType) ElemField() Field {
+	return t.elem
+}
+
+func (t *LargeListViewType) Fields() []Field { return []Field{t.ElemField()} }
+
+func (*LargeListViewType) Layout() DataTypeLayout {
+	return DataTypeLayout{Buffers: []BufferSpec{SpecBitmap(), SpecFixedWidth(Int64SizeBytes), SpecFixedWidth(Int64SizeBytes)}}
+}
+
+func (*LargeListViewType) OffsetTypeTraits() OffsetTraits { return Int64Traits }
+
 // StructType describes a nested type parameterized by an ordered sequence
 // of relative types, called its fields.
 type StructType struct {
@@ -827,4 +967,11 @@ var (
 	_ ListLikeType = (*LargeListType)(nil)
 	_ ListLikeType = (*FixedSizeListType)(nil)
 	_ ListLikeType = (*MapType)(nil)
+
+	_ VarLenListLikeType = (*ListType)(nil)
+	_ VarLenListLikeType = (*LargeListType)(nil)
+	_ VarLenListLikeType = (*ListViewType)(nil)
+	_ VarLenListLikeType = (*LargeListViewType)(nil)
+	_ VarLenListLikeType = (*FixedSizeListType)(nil)
+	_ VarLenListLikeType = (*MapType)(nil)
 )
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 3b592cf3992aa..0851bff0fe0da 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -41,6 +41,7 @@ func init() {
 	Records["primitives"] = makePrimitiveRecords()
 	Records["structs"] = makeStructsRecords()
 	Records["lists"] = makeListsRecords()
+	Records["list_views"] = makeListViewsRecords()
 	Records["strings"] = makeStringsRecords()
 	Records["fixed_size_lists"] = makeFixedSizeListsRecords()
 	Records["fixed_width_types"] = makeFixedWidthTypesRecords()
@@ -321,6 +322,63 @@ func makeListsRecords() []arrow.Record {
 	return recs
 }
 
+func makeListViewsRecords() []arrow.Record {
+	mem := memory.NewGoAllocator()
+	dtype := arrow.ListViewOf(arrow.PrimitiveTypes.Int32)
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "list_view_nullable", Type: dtype, Nullable: true},
+	}, nil)
+
+	mask := []bool{true, false, false, true, true}
+
+	chunks := [][]arrow.Array{
+		{
+			listViewOf(mem, []arrow.Array{
+				arrayOf(mem, []int32{1, 2, 3, 4, 5}, mask),
+				arrayOf(mem, []int32{11, 12, 13, 14, 15}, mask),
+				arrayOf(mem, []int32{21, 22, 23, 24, 25}, mask),
+			}, nil),
+		},
+		{
+			listViewOf(mem, []arrow.Array{
+				arrayOf(mem, []int32{-1, -2, -3, -4, -5}, mask),
+				arrayOf(mem, []int32{-11, -12, -13, -14, -15}, mask),
+				arrayOf(mem, []int32{-21, -22, -23, -24, -25}, mask),
+			}, nil),
+		},
+		{
+			listViewOf(mem, []arrow.Array{
+				arrayOf(mem, []int32{-1, -2, -3, -4, -5}, mask),
+				arrayOf(mem, []int32{}, []bool{}),
+				arrayOf(mem, []int32{-21, -22, -23, -24, -25}, mask),
+			}, []bool{true, false, true}),
+		},
+		{
+			func() arrow.Array {
+				bldr := array.NewListViewBuilder(mem, arrow.PrimitiveTypes.Int32)
+				defer bldr.Release()
+
+				return bldr.NewListViewArray()
+			}(),
+		},
+	}
+
+	defer func() {
+		for _, chunk := range chunks {
+			for _, col := range chunk {
+				col.Release()
+			}
+		}
+	}()
+
+	recs := make([]arrow.Record, len(chunks))
+	for i, chunk := range chunks {
+		recs[i] = array.NewRecord(schema, chunk, -1)
+	}
+
+	return recs
+}
+
 func makeFixedSizeListsRecords() []arrow.Record {
 	mem := memory.NewGoAllocator()
 	const N = 3
@@ -1439,6 +1497,30 @@ func listOf(mem memory.Allocator, values []arrow.Array, valids []bool) *array.Li
 	return bldr.NewListArray()
 }
 
+func listViewOf(mem memory.Allocator, values []arrow.Array, valids []bool) *array.ListView {
+	if mem == nil {
+		mem = memory.NewGoAllocator()
+	}
+
+	bldr := array.NewListViewBuilder(mem, values[0].DataType())
+	defer bldr.Release()
+
+	valid := func(i int) bool {
+		return valids[i]
+	}
+
+	if valids == nil {
+		valid = func(i int) bool { return true }
+	}
+
+	for i, value := range values {
+		bldr.AppendWithSize(valid(i), value.Len())
+		buildArray(bldr.ValueBuilder(), value)
+	}
+
+	return bldr.NewListViewArray()
+}
+
 func fixedSizeListOf(mem memory.Allocator, n int32, values []arrow.Array, valids []bool) *array.FixedSizeList {
 	if mem == nil {
 		mem = memory.NewGoAllocator()
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index fa4438276f186..ad87b73fc4ddb 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -208,6 +208,10 @@ func typeToJSON(arrowType arrow.DataType) (json.RawMessage, error) {
 		typ = nameJSON{"list"}
 	case *arrow.LargeListType:
 		typ = nameJSON{"largelist"}
+	case *arrow.ListViewType:
+		typ = nameJSON{"listview"}
+	case *arrow.LargeListViewType:
+		typ = nameJSON{"largelistview"}
 	case *arrow.MapType:
 		typ = mapJSON{Name: "map", KeysSorted: dt.KeysSorted}
 	case *arrow.StructType:
@@ -400,6 +404,20 @@ func typeFromJSON(typ json.RawMessage, children []FieldWrapper) (arrowType arrow
 			Metadata: children[0].arrowMeta,
 			Nullable: children[0].Nullable,
 		})
+	case "listview":
+		arrowType = arrow.ListViewOfField(arrow.Field{
+			Name:     children[0].Name,
+			Type:     children[0].arrowType,
+			Metadata: children[0].arrowMeta,
+			Nullable: children[0].Nullable,
+		})
+	case "largelistview":
+		arrowType = arrow.LargeListViewOfField(arrow.Field{
+			Name:     children[0].Name,
+			Type:     children[0].arrowType,
+			Metadata: children[0].arrowMeta,
+			Nullable: children[0].Nullable,
+		})
 	case "map":
 		t := mapJSON{}
 		if err = json.Unmarshal(typ, &t); err != nil {
@@ -798,6 +816,7 @@ type Array struct {
 	Data     []interface{}         `json:"DATA,omitempty"`
 	TypeID   []arrow.UnionTypeCode `json:"TYPE_ID,omitempty"`
 	Offset   interface{}           `json:"OFFSET,omitempty"`
+	Size     interface{}           `json:"SIZE,omitempty"`
 	Children []Array               `json:"children,omitempty"`
 }
 
@@ -806,7 +825,8 @@ func (a *Array) MarshalJSON() ([]byte, error) {
 	aux := struct {
 		*Alias
 		OutOffset interface{} `json:"OFFSET,omitempty"`
-	}{Alias: (*Alias)(a), OutOffset: a.Offset}
+		OutSize   interface{} `json:"SIZE,omitempty"`
+	}{Alias: (*Alias)(a), OutOffset: a.Offset, OutSize: a.Size}
 	return json.Marshal(aux)
 }
 
@@ -815,6 +835,7 @@ func (a *Array) UnmarshalJSON(b []byte) (err error) {
 	aux := &struct {
 		*Alias
 		RawOffset json.RawMessage `json:"OFFSET,omitempty"`
+		RawSize   json.RawMessage `json:"SIZE,omitempty"`
 	}{Alias: (*Alias)(a)}
 
 	dec := json.NewDecoder(bytes.NewReader(b))
@@ -824,6 +845,7 @@ func (a *Array) UnmarshalJSON(b []byte) (err error) {
 		return
 	}
 
+	// Offsets
 	if len(aux.RawOffset) == 0 {
 		return
 	}
@@ -855,6 +877,38 @@ func (a *Array) UnmarshalJSON(b []byte) (err error) {
 		a.Offset = out
 	}
 
+	if len(aux.RawSize) == 0 {
+		return
+	}
+
+	// Sizes
+	var rawSizes []interface{}
+	if err = json.Unmarshal(aux.RawSize, &rawSizes); err != nil {
+		return
+	}
+
+	if len(rawSizes) == 0 {
+		return
+	}
+
+	switch rawSizes[0].(type) {
+	case string:
+		out := make([]int64, len(rawSizes))
+		for i, o := range rawSizes {
+			out[i], err = strconv.ParseInt(o.(string), 10, 64)
+			if err != nil {
+				return
+			}
+		}
+		a.Size = out
+	case float64:
+		out := make([]int32, len(rawSizes))
+		for i, o := range rawSizes {
+			out[i] = int32(o.(float64))
+		}
+		a.Size = out
+	}
+
 	return nil
 }
 
@@ -1050,6 +1104,44 @@ func arrayFromJSON(mem memory.Allocator, dt arrow.DataType, arr Array) arrow.Arr
 			memory.NewBufferBytes(arrow.Int64Traits.CastToBytes(arr.Offset.([]int64)))},
 			[]arrow.ArrayData{elems}, nulls, 0)
 
+	case *arrow.ListViewType:
+		valids := validsFromJSON(arr.Valids)
+		elems := arrayFromJSON(mem, dt.Elem(), arr.Children[0])
+		defer elems.Release()
+
+		bitmap := validsToBitmap(valids, mem)
+		defer bitmap.Release()
+
+		nulls := arr.Count - bitutil.CountSetBits(bitmap.Bytes(), 0, arr.Count)
+		var offsets, sizes *memory.Buffer
+		if arr.Count == 0 {
+			emptyBuffer := memory.NewBufferBytes(nil)
+			offsets, sizes = emptyBuffer, emptyBuffer
+		} else {
+			offsets = memory.NewBufferBytes(arrow.Int32Traits.CastToBytes(arr.Offset.([]int32)))
+			sizes = memory.NewBufferBytes(arrow.Int32Traits.CastToBytes(arr.Size.([]int32)))
+		}
+		return array.NewData(dt, arr.Count, []*memory.Buffer{bitmap, offsets, sizes}, []arrow.ArrayData{elems}, nulls, 0)
+
+	case *arrow.LargeListViewType:
+		valids := validsFromJSON(arr.Valids)
+		elems := arrayFromJSON(mem, dt.Elem(), arr.Children[0])
+		defer elems.Release()
+
+		bitmap := validsToBitmap(valids, mem)
+		defer bitmap.Release()
+
+		nulls := arr.Count - bitutil.CountSetBits(bitmap.Bytes(), 0, arr.Count)
+		var offsets, sizes *memory.Buffer
+		if arr.Count == 0 {
+			emptyBuffer := memory.NewBufferBytes(nil)
+			offsets, sizes = emptyBuffer, emptyBuffer
+		} else {
+			offsets = memory.NewBufferBytes(arrow.Int64Traits.CastToBytes(arr.Offset.([]int64)))
+			sizes = memory.NewBufferBytes(arrow.Int64Traits.CastToBytes(arr.Size.([]int64)))
+		}
+		return array.NewData(dt, arr.Count, []*memory.Buffer{bitmap, offsets, sizes}, []arrow.ArrayData{elems}, nulls, 0)
+
 	case *arrow.FixedSizeListType:
 		valids := validsFromJSON(arr.Valids)
 		elems := arrayFromJSON(mem, dt.Elem(), arr.Children[0])
@@ -1422,6 +1514,44 @@ func arrayToJSON(field arrow.Field, arr arrow.Array) Array {
 			},
 		}
 
+	case *array.ListView:
+		o := Array{
+			Name:   field.Name,
+			Count:  arr.Len(),
+			Valids: validsToJSON(arr),
+			Offset: arr.Offsets(),
+			Size:   arr.Sizes(),
+			Children: []Array{
+				arrayToJSON(arrow.Field{Name: "item", Type: arr.DataType().(*arrow.ListViewType).Elem()}, arr.ListValues()),
+			},
+		}
+		if arr.Len() == 0 {
+			o.Offset, o.Size = []int32{}, []int32{}
+		}
+		return o
+
+	case *array.LargeListView:
+		offsets := arr.Offsets()
+		strOffsets := make([]string, len(offsets))
+		for i, o := range offsets {
+			strOffsets[i] = strconv.FormatInt(o, 10)
+		}
+		sizes := arr.Sizes()
+		strSizes := make([]string, len(sizes))
+		for i, s := range sizes {
+			strSizes[i] = strconv.FormatInt(s, 10)
+		}
+		return Array{
+			Name:   field.Name,
+			Count:  arr.Len(),
+			Valids: validsToJSON(arr),
+			Offset: strOffsets,
+			Size:   strSizes,
+			Children: []Array{
+				arrayToJSON(arrow.Field{Name: "item", Type: arr.DataType().(*arrow.LargeListViewType).Elem()}, arr.ListValues()),
+			},
+		}
+
 	case *array.Map:
 		o := Array{
 			Name:   field.Name,
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index 882dc9a0d860a..ee85d431805ab 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -34,6 +34,7 @@ func TestReadWrite(t *testing.T) {
 	wantJSONs["primitives"] = makePrimitiveWantJSONs()
 	wantJSONs["structs"] = makeStructsWantJSONs()
 	wantJSONs["lists"] = makeListsWantJSONs()
+	wantJSONs["list_views"] = makeListViewsWantJSONs()
 	wantJSONs["strings"] = makeStringsWantJSONs()
 	wantJSONs["fixed_size_lists"] = makeFixedSizeListsWantJSONs()
 	wantJSONs["fixed_width_types"] = makeFixedWidthTypesWantJSONs()
@@ -1366,7 +1367,7 @@ func makeListsWantJSONs() string {
             1,
             1,
             1
-          ],          
+          ],
           "children": [
             {
               "name": "item",
@@ -1558,6 +1559,237 @@ func makeListsWantJSONs() string {
 }`
 }
 
+func makeListViewsWantJSONs() string {
+	return `{
+  "schema": {
+    "fields": [
+      {
+        "name": "list_view_nullable",
+        "type": {
+          "name": "listview"
+        },
+        "nullable": true,
+        "children": [
+          {
+            "name": "item",
+            "type": {
+              "name": "int",
+              "isSigned": true,
+              "bitWidth": 32
+            },
+            "nullable": true,
+            "children": []
+          }
+        ]
+      }
+    ]
+  },
+  "batches": [
+    {
+      "count": 3,
+      "columns": [
+        {
+          "name": "list_view_nullable",
+          "count": 3,
+          "VALIDITY": [
+            1,
+            1,
+            1
+          ],
+          "children": [
+            {
+              "name": "item",
+              "count": 15,
+              "VALIDITY": [
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1
+              ],
+              "DATA": [
+                1,
+                0,
+                0,
+                4,
+                5,
+                11,
+                0,
+                0,
+                14,
+                15,
+                21,
+                0,
+                0,
+                24,
+                25
+              ]
+            }
+          ],
+          "OFFSET": [
+            0,
+            5,
+            10
+          ],
+          "SIZE": [
+            5,
+            5,
+            5
+          ]
+        }
+      ]
+    },
+    {
+      "count": 3,
+      "columns": [
+        {
+          "name": "list_view_nullable",
+          "count": 3,
+          "VALIDITY": [
+            1,
+            1,
+            1
+          ],
+          "children": [
+            {
+              "name": "item",
+              "count": 15,
+              "VALIDITY": [
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1
+              ],
+              "DATA": [
+                -1,
+                0,
+                0,
+                -4,
+                -5,
+                -11,
+                0,
+                0,
+                -14,
+                -15,
+                -21,
+                0,
+                0,
+                -24,
+                -25
+              ]
+            }
+          ],
+          "OFFSET": [
+            0,
+            5,
+            10
+          ],
+          "SIZE": [
+            5,
+            5,
+            5
+          ]
+        }
+      ]
+    },
+    {
+      "count": 3,
+      "columns": [
+        {
+          "name": "list_view_nullable",
+          "count": 3,
+          "VALIDITY": [
+            1,
+            0,
+            1
+          ],
+          "children": [
+            {
+              "name": "item",
+              "count": 10,
+              "VALIDITY": [
+                1,
+                0,
+                0,
+                1,
+                1,
+                1,
+                0,
+                0,
+                1,
+                1
+              ],
+              "DATA": [
+                -1,
+                0,
+                0,
+                -4,
+                -5,
+                -21,
+                0,
+                0,
+                -24,
+                -25
+              ]
+            }
+          ],
+          "OFFSET": [
+            0,
+            5,
+            5
+          ],
+          "SIZE": [
+            5,
+            0,
+            5
+          ]
+        }
+      ]
+    },
+    {
+      "count": 0,
+      "columns": [
+        {
+          "name": "list_view_nullable",
+          "count": 0,
+          "children": [
+            {
+              "name": "item",
+              "count": 0
+            }
+          ],
+          "OFFSET": [
+          ],
+          "SIZE": [
+          ]
+        }
+      ]
+    }
+  ]
+}`
+}
+
 func makeFixedSizeListsWantJSONs() string {
 	return `{
   "schema": {
@@ -3575,7 +3807,7 @@ func makeMapsWantJSONs() string {
           "VALIDITY": [
             1,
             0
-          ],          
+          ],
           "children": [
             {
               "name": "entries",
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index ab9e015163730..41f2578209a7f 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -22,6 +22,7 @@ import (
 	"github.com/apache/arrow/go/v14/arrow"
 	"github.com/apache/arrow/go/v14/arrow/array"
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
@@ -376,6 +377,156 @@ func (r *RandomArrayGenerator) Numeric(dt arrow.Type, size int64, min, max int64
 	panic("invalid type for random numeric array")
 }
 
+// Generate an array of random offsets based on a given sizes array for
+// list-view arrays.
+//
+// Pre-condition: every non-null sizes[i] <= valuesLength.
+func viewOffsetsFromLengthsArray32(
+	seed uint64, avgLength int32, valuesLength int32,
+	sizesArray *array.Int32, forceEmptyNulls bool,
+	zeroUndefinedOffsets bool) *memory.Buffer {
+	sizes := sizesArray.Int32Values()
+	offsets := make([]int32, sizesArray.Len())
+
+	offsetDeltaRand := rand.New(rand.NewSource(seed))
+	sampleOffset := func(offsetBase int32) int32 {
+		delta := int32(offsetDeltaRand.Int63n(2*int64(avgLength)) - int64(avgLength))
+		offset := offsetBase + delta
+		if offset < 0 {
+			return 0
+		}
+		return offset
+	}
+	offsetBase := int32(0)
+	for i := 0; i < sizesArray.Len(); i += 1 {
+		isNull := sizesArray.IsNull(i)
+		if forceEmptyNulls && isNull {
+			sizes[i] = 0
+		}
+		if zeroUndefinedOffsets && (isNull || sizes[i] == 0) {
+			offsets[i] = 0
+		} else {
+			offset := sampleOffset(offsetBase)
+			if offset > valuesLength-sizes[i] {
+				offset = valuesLength - sizes[i]
+			}
+			offsets[i] = offset
+		}
+		offsetBase += avgLength
+	}
+
+	return memory.NewBufferBytes(arrow.Int32Traits.CastToBytes(offsets))
+}
+
+// Generate an array of random offsets based on a given sizes array for
+// large list-view arrays.
+//
+// Pre-condition: every non-null sizes[i] <= valuesLength.
+func viewOffsetsFromLengthsArray64(
+	seed uint64, avgLength int64, valuesLength int64,
+	sizesArray *array.Int64, forceEmptyNulls bool,
+	zeroUndefinedOffsets bool) *memory.Buffer {
+	sizes := sizesArray.Int64Values()
+	offsets := make([]int64, sizesArray.Len())
+
+	offsetDeltaRand := rand.New(rand.NewSource(seed))
+	sampleOffset := func(offsetBase int64) int64 {
+		delta := int64(offsetDeltaRand.Int63n(2*avgLength) - avgLength)
+		offset := offsetBase + delta
+		if offset < 0 {
+			return 0
+		}
+		return offset
+	}
+	offsetBase := int64(0)
+	for i := 0; i < sizesArray.Len(); i += 1 {
+		isNull := sizesArray.IsNull(i)
+		if forceEmptyNulls && isNull {
+			sizes[i] = 0
+		}
+		if zeroUndefinedOffsets && (isNull || sizes[i] == 0) {
+			offsets[i] = 0
+		} else {
+			offset := sampleOffset(offsetBase)
+			if offset > valuesLength-sizes[i] {
+				offset = valuesLength - sizes[i]
+			}
+			offsets[i] = offset
+		}
+		offsetBase += avgLength
+	}
+
+	return memory.NewBufferBytes(arrow.Int64Traits.CastToBytes(offsets))
+}
+
+// Generate a random data for ListView or LargeListView arrays.
+func (r *RandomArrayGenerator) genListViewData(dt arrow.VarLenListLikeType, length int64,
+	minLength, maxLength int, nullprob float64,
+	forceEmptyNulls bool, zeroUndefinedOffsets bool) arrow.ArrayData {
+	offsetByteWidth := dt.Layout().Buffers[1].ByteWidth
+	var lengths arrow.Array
+	if offsetByteWidth == 4 {
+		lengths = r.Int32(length, int32(minLength), int32(maxLength), nullprob)
+	} else {
+		lengths = r.Int64(length, int64(minLength), int64(maxLength), nullprob)
+	}
+	defer lengths.Release()
+
+	// List-views don't have to be disjoint, so let's make the valuesLength a
+	// multiple of the average list-view size. To make sure every list view
+	// into the values array can fit, it should be at least maxLength.
+	avgLength := minLength + (maxLength-minLength)/2
+	valuesLength := int64(avgLength) * (length - int64(lengths.NullN()))
+	if valuesLength < int64(maxLength) {
+		valuesLength = int64(maxLength)
+	}
+	debug.Assert(offsetByteWidth == 8 || valuesLength < math.MaxInt32,
+		"valuesLength must be less than math.MaxInt32")
+
+	values := r.ArrayOf(dt.Elem().ID(), int64(valuesLength), 0.0)
+	defer values.Release()
+
+	var offsets *memory.Buffer
+	if offsetByteWidth == 4 {
+		lengths32 := lengths.(*array.Int32)
+		offsets = viewOffsetsFromLengthsArray32(r.seed, int32(avgLength), int32(valuesLength), lengths32,
+			forceEmptyNulls, zeroUndefinedOffsets)
+	} else {
+		lengths64 := lengths.(*array.Int64)
+		offsets = viewOffsetsFromLengthsArray64(r.seed, int64(avgLength), int64(valuesLength), lengths64,
+			forceEmptyNulls, zeroUndefinedOffsets)
+	}
+	defer offsets.Release()
+
+	buffers := []*memory.Buffer{
+		memory.NewBufferBytes(lengths.NullBitmapBytes()),
+		offsets,
+		memory.NewBufferBytes(lengths.Data().Buffers()[1].Bytes()),
+	}
+	childData := []arrow.ArrayData{values.Data()}
+	return array.NewData(dt, int(length), buffers, childData, int(lengths.NullN()), 0)
+}
+
+func (r *RandomArrayGenerator) ListView(dt arrow.VarLenListLikeType, length int64,
+	minLength, maxLength int32, nullprob float64) *array.ListView {
+	forceEmptyNulls := false
+	zeroUndefineOffsets := false
+	data := r.genListViewData(dt, length, int(minLength), int(maxLength), nullprob,
+		forceEmptyNulls, zeroUndefineOffsets)
+	defer data.Release()
+	return array.NewListViewData(data)
+}
+
+func (r *RandomArrayGenerator) LargeListView(dt arrow.VarLenListLikeType, length int64,
+	minLength, maxLength int64, nullprob float64) *array.LargeListView {
+	forceEmptyNulls := false
+	zeroUndefineOffsets := false
+	data := r.genListViewData(dt, length, int(minLength), int(maxLength), nullprob,
+		forceEmptyNulls, zeroUndefineOffsets)
+	defer data.Release()
+	return array.NewLargeListViewData(data)
+}
+
 func (r *RandomArrayGenerator) ArrayOf(dt arrow.Type, size int64, nullprob float64) arrow.Array {
 	switch dt {
 	case arrow.BOOL:
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index 7d799149c2a69..10cb2cae764e6 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -485,6 +485,12 @@ func (ctx *arrayLoaderContext) loadArray(dt arrow.DataType) arrow.ArrayData {
 	case *arrow.LargeListType:
 		return ctx.loadList(dt)
 
+	case *arrow.ListViewType:
+		return ctx.loadListView(dt)
+
+	case *arrow.LargeListViewType:
+		return ctx.loadListView(dt)
+
 	case *arrow.FixedSizeListType:
 		return ctx.loadFixedSizeList(dt)
 
@@ -606,6 +612,17 @@ func (ctx *arrayLoaderContext) loadList(dt arrow.ListLikeType) arrow.ArrayData {
 	return array.NewData(dt, int(field.Length()), buffers, []arrow.ArrayData{sub}, int(field.NullCount()), 0)
 }
 
+func (ctx *arrayLoaderContext) loadListView(dt arrow.VarLenListLikeType) arrow.ArrayData {
+	field, buffers := ctx.loadCommon(dt.ID(), 3)
+	buffers = append(buffers, ctx.buffer(), ctx.buffer())
+	defer releaseBuffers(buffers)
+
+	sub := ctx.loadChild(dt.Elem())
+	defer sub.Release()
+
+	return array.NewData(dt, int(field.Length()), buffers, []arrow.ArrayData{sub}, int(field.NullCount()), 0)
+}
+
 func (ctx *arrayLoaderContext) loadFixedSizeList(dt *arrow.FixedSizeListType) arrow.ArrayData {
 	field, buffers := ctx.loadCommon(dt.ID(), 1)
 	defer releaseBuffers(buffers)
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index 5c5e41833aea1..9bab47d6fa0cd 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -386,6 +386,18 @@ func (fv *fieldVisitor) visit(field arrow.Field) {
 		flatbuf.LargeListStart(fv.b)
 		fv.offset = flatbuf.LargeListEnd(fv.b)
 
+	case *arrow.ListViewType:
+		fv.dtype = flatbuf.TypeListView
+		fv.kids = append(fv.kids, fieldToFB(fv.b, fv.pos.Child(0), dt.ElemField(), fv.memo))
+		flatbuf.ListViewStart(fv.b)
+		fv.offset = flatbuf.ListViewEnd(fv.b)
+
+	case *arrow.LargeListViewType:
+		fv.dtype = flatbuf.TypeLargeListView
+		fv.kids = append(fv.kids, fieldToFB(fv.b, fv.pos.Child(0), dt.ElemField(), fv.memo))
+		flatbuf.LargeListViewStart(fv.b)
+		fv.offset = flatbuf.LargeListViewEnd(fv.b)
+
 	case *arrow.FixedSizeListType:
 		fv.dtype = flatbuf.TypeFixedSizeList
 		fv.kids = append(fv.kids, fieldToFB(fv.b, fv.pos.Child(0), dt.ElemField(), fv.memo))
@@ -718,6 +730,20 @@ func concreteTypeFromFB(typ flatbuf.Type, data flatbuffers.Table, children []arr
 		dt := arrow.LargeListOfField(children[0])
 		return dt, nil
 
+	case flatbuf.TypeListView:
+		if len(children) != 1 {
+			return nil, fmt.Errorf("arrow/ipc: ListView must have exactly 1 child field (got=%d)", len(children))
+		}
+		dt := arrow.ListViewOfField(children[0])
+		return dt, nil
+
+	case flatbuf.TypeLargeListView:
+		if len(children) != 1 {
+			return nil, fmt.Errorf("arrow/ipc: LargeListView must have exactly 1 child field (got=%d)", len(children))
+		}
+		dt := arrow.LargeListViewOfField(children[0])
+		return dt, nil
+
 	case flatbuf.TypeFixedSizeList:
 		var dt flatbuf.FixedSizeList
 		dt.Init(data.Bytes, data.Pos)
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index 7866ec2b41011..a97f47ef4aa43 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -577,10 +577,7 @@ func (w *recordEncoder) visit(p *Payload, arr arrow.Array) error {
 
 	case *arrow.BinaryType, *arrow.LargeBinaryType, *arrow.StringType, *arrow.LargeStringType:
 		arr := arr.(array.BinaryLike)
-		voffsets, err := w.getZeroBasedValueOffsets(arr)
-		if err != nil {
-			return fmt.Errorf("could not retrieve zero-based value offsets from %T: %w", arr, err)
-		}
+		voffsets := w.getZeroBasedValueOffsets(arr)
 		data := arr.Data()
 		values := data.Buffers()[2]
 
@@ -687,10 +684,7 @@ func (w *recordEncoder) visit(p *Payload, arr arrow.Array) error {
 		w.depth++
 	case *arrow.MapType, *arrow.ListType, *arrow.LargeListType:
 		arr := arr.(array.ListLike)
-		voffsets, err := w.getZeroBasedValueOffsets(arr)
-		if err != nil {
-			return fmt.Errorf("could not retrieve zero-based value offsets for array %T: %w", arr, err)
-		}
+		voffsets := w.getZeroBasedValueOffsets(arr)
 		p.body = append(p.body, voffsets)
 
 		w.depth--
@@ -716,7 +710,52 @@ func (w *recordEncoder) visit(p *Payload, arr arrow.Array) error {
 			values = array.NewSlice(values, values_offset, values_end)
 			mustRelease = true
 		}
-		err = w.visit(p, values)
+		err := w.visit(p, values)
+
+		if err != nil {
+			return fmt.Errorf("could not visit list element for array %T: %w", arr, err)
+		}
+		w.depth++
+
+	case *arrow.ListViewType, *arrow.LargeListViewType:
+		data := arr.Data()
+		arr := arr.(array.VarLenListLike)
+		offsetTraits := arr.DataType().(arrow.OffsetsDataType).OffsetTypeTraits()
+		rngOff, rngLen := array.RangeOfValuesUsed(arr)
+		voffsets := w.getValueOffsetsAtBaseValue(arr, rngOff)
+		p.body = append(p.body, voffsets)
+
+		vsizes := data.Buffers()[2]
+		if vsizes != nil {
+			if data.Offset() != 0 || vsizes.Len() > offsetTraits.BytesRequired(arr.Len()) {
+				beg := offsetTraits.BytesRequired(data.Offset())
+				end := beg + offsetTraits.BytesRequired(data.Len())
+				vsizes = memory.NewBufferBytes(vsizes.Bytes()[beg:end])
+			} else {
+				vsizes.Retain()
+			}
+		}
+		p.body = append(p.body, vsizes)
+
+		w.depth--
+		var (
+			values        = arr.ListValues()
+			mustRelease   = false
+			values_offset = int64(rngOff)
+			values_end    = int64(rngOff + rngLen)
+		)
+		defer func() {
+			if mustRelease {
+				values.Release()
+			}
+		}()
+
+		if arr.Len() > 0 && values_end < int64(values.Len()) {
+			// must also slice the values
+			values = array.NewSlice(values, values_offset, values_end)
+			mustRelease = true
+		}
+		err := w.visit(p, values)
 
 		if err != nil {
 			return fmt.Errorf("could not visit list element for array %T: %w", arr, err)
@@ -764,19 +803,25 @@ func (w *recordEncoder) visit(p *Payload, arr arrow.Array) error {
 	return nil
 }
 
-func (w *recordEncoder) getZeroBasedValueOffsets(arr arrow.Array) (*memory.Buffer, error) {
+func (w *recordEncoder) getZeroBasedValueOffsets(arr arrow.Array) *memory.Buffer {
 	data := arr.Data()
 	voffsets := data.Buffers()[1]
 	offsetTraits := arr.DataType().(arrow.OffsetsDataType).OffsetTypeTraits()
 	offsetBytesNeeded := offsetTraits.BytesRequired(data.Len() + 1)
 
-	if data.Offset() != 0 || offsetBytesNeeded < voffsets.Len() {
-		// if we have a non-zero offset, then the value offsets do not start at
-		// zero. we must a) create a new offsets array with shifted offsets and
-		// b) slice the values array accordingly
-		//
-		// or if there are more value offsets than values (the array has been sliced)
-		// we need to trim off the trailing offsets
+	if voffsets == nil || voffsets.Len() == 0 {
+		return nil
+	}
+
+	// if we have a non-zero offset, then the value offsets do not start at
+	// zero. we must a) create a new offsets array with shifted offsets and
+	// b) slice the values array accordingly
+	//
+	// or if there are more value offsets than values (the array has been sliced)
+	// we need to trim off the trailing offsets
+	needsTruncateAndShift := data.Offset() != 0 || offsetBytesNeeded < voffsets.Len()
+
+	if needsTruncateAndShift {
 		shiftedOffsets := memory.NewResizableBuffer(w.mem)
 		shiftedOffsets.Resize(offsetBytesNeeded)
 
@@ -805,11 +850,65 @@ func (w *recordEncoder) getZeroBasedValueOffsets(arr arrow.Array) (*memory.Buffe
 	} else {
 		voffsets.Retain()
 	}
+
+	return voffsets
+}
+
+// Truncates the offsets if needed and shifts the values if minOffset > 0.
+// The offsets returned are corrected assuming the child values are truncated
+// and now start at minOffset.
+//
+// This function only works on offset buffers of ListViews and LargeListViews.
+// TODO(felipecrv): Unify this with getZeroBasedValueOffsets.
+func (w *recordEncoder) getValueOffsetsAtBaseValue(arr arrow.Array, minOffset int) *memory.Buffer {
+	data := arr.Data()
+	voffsets := data.Buffers()[1]
+	offsetTraits := arr.DataType().(arrow.OffsetsDataType).OffsetTypeTraits()
+	offsetBytesNeeded := offsetTraits.BytesRequired(data.Len())
+
 	if voffsets == nil || voffsets.Len() == 0 {
-		return nil, nil
+		return nil
+	}
+
+	needsTruncate := data.Offset() != 0 || offsetBytesNeeded < voffsets.Len()
+	needsShift := minOffset > 0
+
+	if needsTruncate || needsShift {
+		shiftedOffsets := memory.NewResizableBuffer(w.mem)
+		shiftedOffsets.Resize(offsetBytesNeeded)
+
+		switch arr.DataType().Layout().Buffers[1].ByteWidth {
+		case 8:
+			dest := arrow.Int64Traits.CastFromBytes(shiftedOffsets.Bytes())
+			offsets := arrow.Int64Traits.CastFromBytes(voffsets.Bytes())[data.Offset() : data.Offset()+data.Len()]
+
+			if minOffset > 0 {
+				for i, o := range offsets {
+					dest[i] = o - int64(minOffset)
+				}
+			} else {
+				copy(dest, offsets)
+			}
+		default:
+			debug.Assert(arr.DataType().Layout().Buffers[1].ByteWidth == 4, "invalid offset bytewidth")
+			dest := arrow.Int32Traits.CastFromBytes(shiftedOffsets.Bytes())
+			offsets := arrow.Int32Traits.CastFromBytes(voffsets.Bytes())[data.Offset() : data.Offset()+data.Len()]
+
+			if minOffset > 0 {
+				for i, o := range offsets {
+					dest[i] = o - int32(minOffset)
+				}
+			} else {
+				copy(dest, offsets)
+			}
+		}
+
+		voffsets = shiftedOffsets
+	} else {
+		voffsets.Retain()
 	}
 
-	return voffsets, nil
+	return voffsets
 }
 
 func (w *recordEncoder) rebaseDenseUnionValueOffsets(arr *array.DenseUnion, offsets, lengths []int32) *memory.Buffer {
diff --git a/go/arrow/ipc/writer_test.go b/go/arrow/ipc/writer_test.go
index 47aa29db91082..da461c3d52272 100644
--- a/go/arrow/ipc/writer_test.go
+++ b/go/arrow/ipc/writer_test.go
@@ -112,16 +112,14 @@ func TestGetZeroBasedValueOffsets(t *testing.T) {
 
 	env := &recordEncoder{mem: alloc}
 
-	offsets, err := env.getZeroBasedValueOffsets(arr)
-	require.NoError(t, err)
+	offsets := env.getZeroBasedValueOffsets(arr)
 	defer offsets.Release()
 	assert.Equal(t, 44, offsets.Len(), "include all offsets if array is not sliced")
 
 	sl := array.NewSlice(arr, 0, 4)
 	defer sl.Release()
 
-	offsets, err = env.getZeroBasedValueOffsets(sl)
-	require.NoError(t, err)
+	offsets = env.getZeroBasedValueOffsets(sl)
 	defer offsets.Release()
 	assert.Equal(t, 20, offsets.Len(), "trim trailing offsets after slice")
 }
diff --git a/go/arrow/type_string.go b/go/arrow/type_string.go
index 41a407386357a..ee3ccb7ef9f0a 100644
--- a/go/arrow/type_string.go
+++ b/go/arrow/type_string.go
@@ -47,11 +47,15 @@ func _() {
 	_ = x[LARGE_LIST-36]
 	_ = x[INTERVAL_MONTH_DAY_NANO-37]
 	_ = x[RUN_END_ENCODED-38]
+	_ = x[STRING_VIEW-39]
+	_ = x[BINARY_VIEW-40]
+	_ = x[LIST_VIEW-41]
+	_ = x[LARGE_LIST_VIEW-42]
 }
 
-const _Type_name = "NULLBOOLUINT8INT8UINT16INT16UINT32INT32UINT64INT64FLOAT16FLOAT32FLOAT64STRINGBINARYFIXED_SIZE_BINARYDATE32DATE64TIMESTAMPTIME32TIME64INTERVAL_MONTHSINTERVAL_DAY_TIMEDECIMAL128DECIMAL256LISTSTRUCTSPARSE_UNIONDENSE_UNIONDICTIONARYMAPEXTENSIONFIXED_SIZE_LISTDURATIONLARGE_STRINGLARGE_BINARYLARGE_LISTINTERVAL_MONTH_DAY_NANORUN_END_ENCODED"
+const _Type_name = "NULLBOOLUINT8INT8UINT16INT16UINT32INT32UINT64INT64FLOAT16FLOAT32FLOAT64STRINGBINARYFIXED_SIZE_BINARYDATE32DATE64TIMESTAMPTIME32TIME64INTERVAL_MONTHSINTERVAL_DAY_TIMEDECIMAL128DECIMAL256LISTSTRUCTSPARSE_UNIONDENSE_UNIONDICTIONARYMAPEXTENSIONFIXED_SIZE_LISTDURATIONLARGE_STRINGLARGE_BINARYLARGE_LISTINTERVAL_MONTH_DAY_NANORUN_END_ENCODEDSTRING_VIEWBINARY_VIEWLIST_VIEWLARGE_LIST_VIEW"
 
-var _Type_index = [...]uint16{0, 4, 8, 13, 17, 23, 28, 34, 39, 45, 50, 57, 64, 71, 77, 83, 100, 106, 112, 121, 127, 133, 148, 165, 175, 185, 189, 195, 207, 218, 228, 231, 240, 255, 263, 275, 287, 297, 320, 335}
+var _Type_index = [...]uint16{0, 4, 8, 13, 17, 23, 28, 34, 39, 45, 50, 57, 64, 71, 77, 83, 100, 106, 112, 121, 127, 133, 148, 165, 175, 185, 189, 195, 207, 218, 228, 231, 240, 255, 263, 275, 287, 297, 320, 335, 346, 357, 366, 381}
 
 func (i Type) String() string {
 	if i < 0 || i >= Type(len(_Type_index)-1) {

From c5454d5ee1e4c376d29786b10058198cab5085f6 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 11 Oct 2023 09:50:29 +0900
Subject: [PATCH 518/749] GH-38174: [C++] Update bundled Azure SDK for C++ to
 1.10.3 (#38175)

### Rationale for this change

It has g++ 13 support.

### What changes are included in this PR?

Update version and checksum.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #38174

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/thirdparty/versions.txt | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt
index 56163f35d2499..01cb836ea2a86 100644
--- a/cpp/thirdparty/versions.txt
+++ b/cpp/thirdparty/versions.txt
@@ -54,8 +54,8 @@ ARROW_AWS_LC_BUILD_SHA256_CHECKSUM=ae96a3567161552744fc0cae8b4d68ed88b1ec0f3d3c9
 ARROW_AWSSDK_BUILD_VERSION=1.10.55
 ARROW_AWSSDK_BUILD_SHA256_CHECKSUM=2d552fb1a84bef4a9b65e34aa7031851ed2aef5319e02cc6e4cb735c48aa30de
 # Despite the confusing version name this is still the whole Azure SDK for C++ including core, keyvault, storage-common, etc.
-ARROW_AZURE_SDK_BUILD_VERSION=azure-core_1.10.2
-ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM=36557dae87de4cdd257d9b441d9a7f043290eae6666fb1065e0fa486ae3e58a0
+ARROW_AZURE_SDK_BUILD_VERSION=azure-core_1.10.3
+ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM=dd624c2f86adf474d2d0a23066be6e27af9cbd7e3f8d9d8fd7bf981e884b7b48
 ARROW_BOOST_BUILD_VERSION=1.81.0
 ARROW_BOOST_BUILD_SHA256_CHECKSUM=9e0ffae35528c35f90468997bc8d99500bf179cbae355415a89a600c38e13574
 ARROW_BROTLI_BUILD_VERSION=v1.0.9

From 277b168a95f32cd716fba29956784ed5ac2e977d Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 11 Oct 2023 10:31:37 +0900
Subject: [PATCH 519/749] GH-37767: [C++][CMake] Don't touch .git/index
 (#38003)

### Rationale for this change

We run "git describe --tag --dirty" implicitly in
cpp/cmake_modules/DefineOptions.cmake. If we use "--dirty", .git/index's owner may be changed. Because "git describe" touches .git/index for "--dirty".

We can avoid changing .git/index's owner by not using "--dirty".

### What changes are included in this PR?

Remove "--dirty".

### Are these changes tested?

Yes. I used "strace git describe ...".

### Are there any user-facing changes?

No.
* Closes: #37767

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 cpp/cmake_modules/DefineOptions.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake
index 38d33a611ec70..cce21b6bdba24 100644
--- a/cpp/cmake_modules/DefineOptions.cmake
+++ b/cpp/cmake_modules/DefineOptions.cmake
@@ -751,7 +751,7 @@ if(NOT ARROW_GIT_ID)
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
 endif()
 if(NOT ARROW_GIT_DESCRIPTION)
-  execute_process(COMMAND "git" "describe" "--tags" "--dirty"
+  execute_process(COMMAND "git" "describe" "--tags"
                   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
                   ERROR_QUIET
                   OUTPUT_VARIABLE ARROW_GIT_DESCRIPTION

From abbb26ffc8636dfaa330c07ec796a2c94028402f Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Wed, 11 Oct 2023 06:09:31 +0200
Subject: [PATCH 520/749] MINOR: [R] Add Jacob Wujciak-Jens as author (#38188)

### Rationale for this change

Add Jacob Wujciak-Jens as one of the R package authors

### What changes are included in this PR?

Add Jacob Wujciak-Jens as one of the R package authors

### Are these changes tested?

No

### Are there any user-facing changes?

No

Lead-authored-by: Nic Crane <thisisnic@gmail.com>
Co-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 r/DESCRIPTION | 1 +
 1 file changed, 1 insertion(+)

diff --git a/r/DESCRIPTION b/r/DESCRIPTION
index 6e66c3bc7b707..72e1c4334ce8f 100644
--- a/r/DESCRIPTION
+++ b/r/DESCRIPTION
@@ -10,6 +10,7 @@ Authors@R: c(
     person("Jonathan", "Keane", email = "jkeane@gmail.com", role = c("aut")),
     person("Drago\u0219", "Moldovan-Gr\u00fcnfeld", email = "dragos.mold@gmail.com", role = c("aut")),
     person("Jeroen", "Ooms", email = "jeroen@berkeley.edu", role = c("aut")),
+    person("Jacob", "Wujciak-Jens", email = "jacob@wujciak.de", role = c("aut")),
     person("Javier", "Luraschi", email = "javier@rstudio.com", role = c("ctb")),
     person("Karl", "Dunkle Werner", email = "karldw@users.noreply.github.com", role = c("ctb"), comment = c(ORCID = "0000-0003-0523-7309")),
     person("Jeffrey", "Wong", email = "jeffreyw@netflix.com", role = c("ctb")),

From 4c29a8f7e2c816977c0c7f18e61b8496b2579c95 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 11 Oct 2023 14:16:25 +0900
Subject: [PATCH 521/749] GH-38193: [CI][Java] Free up disk space for "AMD64
 manylinux2014 Java JNI" (#38194)

### Rationale for this change

We don't have enough disk space.

### What changes are included in this PR?

Remove unused pre-installed software.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38193

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/java_jni.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/java_jni.yml b/.github/workflows/java_jni.yml
index 0e75468cd374b..4ebfccbe84c89 100644
--- a/.github/workflows/java_jni.yml
+++ b/.github/workflows/java_jni.yml
@@ -60,6 +60,9 @@ jobs:
         with:
           fetch-depth: 0
           submodules: recursive
+      - name: Free up disk space
+        run: |
+          ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
         uses: actions/cache@v3
         with:

From 14abb2c65280a24996afb33289a49500d7ef4a39 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 11 Oct 2023 14:17:59 +0900
Subject: [PATCH 522/749] GH-38159: [CI][Release] Run only integration tests on
 integration test mode (#38177)

### Rationale for this change

Unit tests for each implementations are done on unit test mode.

### What changes are included in this PR?

Detect integration test only mode.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38159

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/verify-release-candidate.sh | 93 ++++++++++++++-----------
 1 file changed, 54 insertions(+), 39 deletions(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index a107c53b8354f..2e5aa1c3936de 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -572,7 +572,9 @@ test_package_java() {
   maybe_setup_conda maven openjdk=17.0.3 || exit 1
 
   pushd java
-  mvn test
+  if [ ${TEST_JAVA} -gt 0 ]; then
+    mvn test
+  fi
   mvn package
   popd
 }
@@ -605,11 +607,20 @@ test_and_install_cpp() {
     ARROW_CMAKE_OPTIONS="${ARROW_CMAKE_OPTIONS:-} -G ${CMAKE_GENERATOR}"
   fi
 
+  local ARROW_BUILD_INTEGRATION=OFF
+  local ARROW_BUILD_TESTS=OFF
+  if [ ${TEST_INTEGRATION_CPP} -gt 0 ]; then
+    ARROW_BUILD_INTEGRATION=ON
+  fi
+  if [ ${TEST_CPP} -gt 0 ]; then
+    ARROW_BUILD_TESTS=ON
+  fi
+
   cmake \
     -DARROW_BOOST_USE_SHARED=ON \
     -DARROW_BUILD_EXAMPLES=OFF \
-    -DARROW_BUILD_INTEGRATION=ON \
-    -DARROW_BUILD_TESTS=ON \
+    -DARROW_BUILD_INTEGRATION=${ARROW_BUILD_INTEGRATION} \
+    -DARROW_BUILD_TESTS=${ARROW_BUILD_TESTS} \
     -DARROW_BUILD_UTILITIES=ON \
     -DARROW_COMPUTE=ON \
     -DARROW_CSV=ON \
@@ -649,15 +660,13 @@ test_and_install_cpp() {
   export CMAKE_BUILD_PARALLEL_LEVEL=${CMAKE_BUILD_PARALLEL_LEVEL:-${NPROC}}
   cmake --build . --target install
 
-  # Explicitly set site-package directory, otherwise the C++ tests are unable
-  # to load numpy in a python virtualenv
-  local pythonpath=$(python -c "import site; print(site.getsitepackages()[0])")
-
-  LD_LIBRARY_PATH=$PWD/release:$LD_LIBRARY_PATH PYTHONPATH=$pythonpath ctest \
-    --label-regex unittest \
-    --output-on-failure \
-    --parallel $NPROC \
-    --timeout 300
+  if [ ${TEST_CPP} -gt 0 ]; then
+    LD_LIBRARY_PATH=$PWD/release:$LD_LIBRARY_PATH ctest \
+      --label-regex unittest \
+      --output-on-failure \
+      --parallel $NPROC \
+      --timeout 300
+  fi
 
   popd
 }
@@ -852,8 +861,10 @@ test_js() {
   yarn clean:all
   yarn lint
   yarn build
-  yarn test
-  yarn test:bundle
+  if [ ${TEST_JS} -gt 0 ]; then
+    yarn test
+    yarn test:bundle
+  fi
   popd
 }
 
@@ -865,25 +876,29 @@ test_go() {
 
   pushd go
   go get -v ./...
-  go test ./...
+  if [ ${TEST_GO} -gt 0 ]; then
+    go test ./...
+  fi
   go install -buildvcs=false ./...
   go clean -modcache
-  pushd arrow/internal/cdata_integration
-
-  case "$(uname)" in
-    Linux)
-      go_lib="arrow_go_integration.so"
-      ;;
-    Darwin)
-      go_lib="arrow_go_integration.dylib"
-      ;;
-    MINGW*)
-      go_lib="arrow_go_integration.dll"
-      ;;
-  esac
-  go build -buildvcs=false -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
 
-  popd
+  if [ ${TEST_INTEGRATION_GO} -gt 0 ]; then
+    pushd arrow/internal/cdata_integration
+    case "$(uname)" in
+      Linux)
+        go_lib="arrow_go_integration.so"
+        ;;
+      Darwin)
+        go_lib="arrow_go_integration.dylib"
+        ;;
+      MINGW*)
+        go_lib="arrow_go_integration.dll"
+        ;;
+    esac
+    go build -buildvcs=false -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
+    popd
+  fi
+
   popd
 }
 
@@ -979,16 +994,16 @@ test_source_distribution() {
 
   pushd $ARROW_SOURCE_DIR
 
-  if [ ${TEST_GO} -gt 0 ]; then
+  if [ ${BUILD_GO} -gt 0 ]; then
     test_go
   fi
   if [ ${TEST_CSHARP} -gt 0 ]; then
     test_csharp
   fi
-  if [ ${TEST_JS} -gt 0 ]; then
+  if [ ${BUILD_JS} -gt 0 ]; then
     test_js
   fi
-  if [ ${TEST_CPP} -gt 0 ]; then
+  if [ ${BUILD_CPP} -gt 0 ]; then
     test_and_install_cpp
   fi
   if [ ${TEST_PYTHON} -gt 0 ]; then
@@ -1000,7 +1015,7 @@ test_source_distribution() {
   if [ ${TEST_RUBY} -gt 0 ]; then
     test_ruby
   fi
-  if [ ${TEST_JAVA} -gt 0 ]; then
+  if [ ${BUILD_JAVA} -gt 0 ]; then
     test_package_java
   fi
   if [ ${TEST_INTEGRATION} -gt 0 ]; then
@@ -1181,12 +1196,12 @@ test_jars() {
 : ${TEST_INTEGRATION_JS:=${TEST_INTEGRATION}}
 : ${TEST_INTEGRATION_GO:=${TEST_INTEGRATION}}
 
-# Automatically test if its activated by a dependent
+# Automatically build/test if its activated by a dependent
 TEST_GLIB=$((${TEST_GLIB} + ${TEST_RUBY}))
-TEST_CPP=$((${TEST_CPP} + ${TEST_GLIB} + ${TEST_PYTHON} + ${TEST_INTEGRATION_CPP}))
-TEST_JAVA=$((${TEST_JAVA} + ${TEST_INTEGRATION_JAVA}))
-TEST_JS=$((${TEST_JS} + ${TEST_INTEGRATION_JS}))
-TEST_GO=$((${TEST_GO} + ${TEST_INTEGRATION_GO}))
+BUILD_CPP=$((${TEST_CPP} + ${TEST_GLIB} + ${TEST_PYTHON} + ${TEST_INTEGRATION_CPP}))
+BUILD_JAVA=$((${TEST_JAVA} + ${TEST_INTEGRATION_JAVA}))
+BUILD_JS=$((${TEST_JS} + ${TEST_INTEGRATION_JS}))
+BUILD_GO=$((${TEST_GO} + ${TEST_INTEGRATION_GO}))
 TEST_INTEGRATION=$((${TEST_INTEGRATION} + ${TEST_INTEGRATION_CPP} + ${TEST_INTEGRATION_JAVA} + ${TEST_INTEGRATION_JS} + ${TEST_INTEGRATION_GO}))
 
 # Execute tests in a conda enviroment

From b20e0ae779756e70cc256c7076733f29ce48e6f3 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Wed, 11 Oct 2023 12:24:43 +0200
Subject: [PATCH 523/749] GH-37941: [R][CI][Release] Add checksum verification
 for pre-compiled binaries (#38115)

### Rationale for this change

This change is to restore parity with the previous solution on macOS (brew does cs validation) and improve security for windows and linux. This also align with CRAN policy.

### What changes are included in this PR?

This PR adds a script that can be run after the arrow release (once all files have been pushed to the artifactory) before the CRAN submission to download the checksum files for the pre-compiled binaries which are already added through the usual release. *libs.R have been extended to use these checksum files to validate the downloaded binaries.

### Are these changes tested?

The r-binary-packages nightlies generate checksums and use them when building binary packages, this way the code path is tested. They do not modify the actual src package though.

### Are there any user-facing changes?
no (outside of log messages)
* Closes: #37941

Authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 dev/tasks/r/github.packages.yml |  34 ++++++---
 r/.gitignore                    |   4 ++
 r/Makefile                      |   2 +-
 r/PACKAGING.md                  |   1 +
 r/tools/nixlibs.R               |  43 +++++++++++-
 r/tools/update-checksums.R      |  67 ++++++++++++++++++
 r/tools/winlibs.R               | 119 ++++++++++++++++++++------------
 7 files changed, 213 insertions(+), 57 deletions(-)
 create mode 100644 r/tools/update-checksums.R

diff --git a/dev/tasks/r/github.packages.yml b/dev/tasks/r/github.packages.yml
index 760e3b6da448d..89526bccdf5d5 100644
--- a/dev/tasks/r/github.packages.yml
+++ b/dev/tasks/r/github.packages.yml
@@ -102,12 +102,16 @@ jobs:
         run: |
           cd arrow/r/libarrow/dist
           zip -r $PKG_FILE lib/ include/
-
+      - name: Create Checksum
+        shell: bash
+        run: |
+          cd arrow/r/libarrow/dist
+          shasum -a 512 arrow-*.zip > arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip.sha512
       - name: Upload binary artifact
         uses: actions/upload-artifact@v3
         with:
           name: r-lib__libarrow__bin__darwin-{{ '${{ matrix.platform.arch }}' }}-openssl-{{ '${{ matrix.openssl }}' }}
-          path: arrow/r/libarrow/dist/arrow-*.zip
+          path: arrow/r/libarrow/dist/arrow-*.zip*
 
   linux-cpp:
     name: C++ Binary Linux OpenSSL {{ '${{ matrix.openssl }}' }}
@@ -149,15 +153,21 @@ jobs:
           PKG_FILE: arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip
           VERSION: {{ '${{ needs.source.outputs.pkg_version }}' }}
         run: |
-          cd arrow/r/libarrow/dist
-          # These files were created by the docker user so we have to sudo to get them
-          sudo -E zip -r $PKG_FILE lib/ include/
+          # These files were created by the docker user so we have to chown them 
+          sudo chown -R $USER:$USER arrow/r/libarrow
 
+          cd arrow/r/libarrow/dist
+          zip -r $PKG_FILE lib/ include/
+      - name: Create Checksum
+        shell: bash
+        run: |
+          cd arrow/r/libarrow/dist
+          shasum -a 512 arrow-*.zip > arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip.sha512
       - name: Upload binary artifact
         uses: actions/upload-artifact@v3
         with:
           name: r-lib__libarrow__bin__linux-openssl-{{ '${{ matrix.openssl }}' }}
-          path: arrow/r/libarrow/dist/arrow-*.zip
+          path: arrow/r/libarrow/dist/arrow-*.zip*
 
   windows-cpp:
     name: C++ Binary Windows RTools (40 only)
@@ -181,11 +191,16 @@ jobs:
           ARROW_HOME: "arrow"
         {{ macros.github_set_sccache_envvars()|indent(8) }}
         run: arrow/ci/scripts/r_windows_build.sh
+      - name: Create Checksum
+        shell: bash
+        run: |
+          cd build
+          sha512sum arrow-*.zip > arrow-{{ '${{ needs.source.outputs.pkg_version }}' }}.zip.sha512
       - name: Upload binary artifact
         uses: actions/upload-artifact@v3
         with:
           name: r-lib__libarrow__bin__windows
-          path: build/arrow-*.zip
+          path: build/arrow-*.zip*
 
   r-packages:
     needs: [source, windows-cpp, macos-cpp]
@@ -222,7 +237,6 @@ jobs:
           rig system add-pak
       {{ macros.github_setup_local_r_repo(false, true, true)|indent }}
       - name: Prepare Dependency Installation
-
         shell: bash
         run: |
           tar -xzf repo/src/contrib/arrow_*.tar.gz arrow/DESCRIPTION
@@ -244,6 +258,8 @@ jobs:
           NOT_CRAN: "false" # actions/setup-r sets this implicitly
           ARROW_R_DEV: "true"
           LIBARROW_BINARY: "true" # has to be set as long as allowlist not updated
+          ARROW_R_ENFORCE_CHECKSUM: "true"
+          ARROW_R_CHECKSUM_PATH: "{{ '${{ github.workspace }}' }}/repo/libarrow/bin"
         run: |
           on_windows <- tolower(Sys.info()[["sysname"]]) == "windows"
 
@@ -335,6 +351,8 @@ jobs:
           ARROW_R_DEV: "TRUE"
           LIBARROW_BUILD: "FALSE"
           LIBARROW_BINARY: {{ '${{ matrix.config.libarrow_binary }}' }}
+          ARROW_R_ENFORCE_CHECKSUM: "true"
+          ARROW_R_CHECKSUM_PATH: "{{ '${{ github.workspace }}' }}/repo/libarrow/bin"
         shell: bash
         run: |
           Rscript -e '
diff --git a/r/.gitignore b/r/.gitignore
index e607d2662f24f..d680fb42ddd6f 100644
--- a/r/.gitignore
+++ b/r/.gitignore
@@ -20,6 +20,10 @@ arrow_*.tgz
 extra-tests/files
 .deps
 
+# Checksums for the precompiled binaries will be added just before CRAN submission
+# use `tools/update-checksums.R` to download them.
+/tools/checksums/
+
 # C++ sources for an offline build. They're copied from the ../cpp directory, so ignore them here.
 /tools/cpp/
 # cmake expects dotenv, NOTICE.txt, and LICENSE.txt to be available one level up
diff --git a/r/Makefile b/r/Makefile
index 3679840ca9f7e..514f5adf4e144 100644
--- a/r/Makefile
+++ b/r/Makefile
@@ -67,5 +67,5 @@ clean:
 	-rm src/Makevars.win
 	-rm -rf arrow.Rcheck/
 	-rm -rf libarrow/
-	-rm -rf tools/cpp/ tools/.env tools/NOTICE.txt tools/LICENSE.txt
+	-rm -rf tools/cpp/ tools/.env tools/NOTICE.txt tools/LICENSE.txt tools/checksums
 	-find . -name "*.orig" -delete
diff --git a/r/PACKAGING.md b/r/PACKAGING.md
index 64423b4d8eb9b..7f42ecf562e59 100644
--- a/r/PACKAGING.md
+++ b/r/PACKAGING.md
@@ -68,6 +68,7 @@ Wait for the release candidate to be cut:
 - [ ] Create a PR entitled `WIP: [R] Verify CRAN release-10.0.1-rc0`. Add
   a comment `@github-actions crossbow submit --group r` to run all R crossbow
   jobs against the CRAN-specific release branch.
+- [ ] Run `Rscript tools/update-checksums.R <libarrow version>` to download the checksums for the pre-compiled binaries from the ASF artifactory into the tools directory.
 - [ ] Regenerate arrow_X.X.X.tar.gz (i.e., `make build`)
 
 Ensure linux binary packages are available:
diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 60deca05cd172..1346e209d8d14 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -28,11 +28,12 @@ if (test_mode && is.na(VERSION)) {
 }
 
 dev_version <- package_version(VERSION)[1, 4]
+is_release <- is.na(dev_version) || dev_version < "100"
 on_macos <- tolower(Sys.info()[["sysname"]]) == "darwin"
-
+checksum_path <- Sys.getenv("ARROW_R_CHECKSUM_PATH", "tools/checksums")
 
 # Small dev versions are added for R-only changes during CRAN submission.
-if (is.na(dev_version) || dev_version < "100") {
+if (is_release) {
   VERSION <- package_version(VERSION)[1, 1:3]
   arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
 } else {
@@ -88,7 +89,7 @@ thirdparty_dependency_dir <- Sys.getenv("ARROW_THIRDPARTY_DEPENDENCY_DIR", "tool
 
 
 download_binary <- function(lib) {
-  libfile <- tempfile()
+  libfile <- paste0("arrow-", VERSION, ".zip")
   binary_url <- paste0(arrow_repo, "bin/", lib, "/arrow-", VERSION, ".zip")
   if (try_download(binary_url, libfile)) {
     if (!quietly) {
@@ -103,6 +104,42 @@ download_binary <- function(lib) {
     }
     libfile <- NULL
   }
+  # Explicitly setting the env var to "false" will skip checksum validation
+  # e.g. in case the included checksums are stale.
+  skip_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "false")
+  enforce_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "true")
+  # validate binary checksum for CRAN release only
+  if (!skip_checksum && dir.exists(checksum_path) && is_release ||
+    enforce_checksum) {
+    checksum_file <- sub(".+/bin/(.+\\.zip)", "\\1\\.sha512", binary_url)
+    checksum_file <- file.path(checksum_path, checksum_file)
+    checksum_cmd <- "shasum"
+    checksum_args <- c("--status", "-a", "512", "-c", checksum_file)
+
+    # shasum is not available on all linux versions
+    status_shasum <- try(
+      suppressWarnings(
+        system2("shasum", args = c("--help"), stdout = FALSE, stderr = FALSE)
+      ),
+      silent = TRUE
+    )
+
+    if (inherits(status_shasum, "try-error") || is.integer(status_shasum) && status_shasum != 0) {
+      checksum_cmd <- "sha512sum"
+      checksum_args <- c("--status", "-c", checksum_file)
+    }
+
+    checksum_ok <- system2(checksum_cmd, args = checksum_args)
+
+    if (checksum_ok != 0) {
+      cat("*** Checksum validation failed for libarrow binary: ", libfile, "\n")
+      unlink(libfile)
+      libfile <- NULL
+    } else {
+      cat("*** Checksum validated successfully for libarrow binary: ", libfile, "\n")
+    }
+  }
+
   libfile
 }
 
diff --git a/r/tools/update-checksums.R b/r/tools/update-checksums.R
new file mode 100644
index 0000000000000..2aa9df317166f
--- /dev/null
+++ b/r/tools/update-checksums.R
@@ -0,0 +1,67 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Run this script AFTER the release was voted and the artifacts
+# are moved into the final dir. This script will download the checksum
+# files and save them to the tools/checksums directory mirroring the
+# artifactory layout. *libs.R uses these files to validated the downloaded
+# binaries when installing the package.
+#
+# Run this script from the r/ directory of the arrow repo with the version
+# as the first argument$ Rscript tools/update-checksum.R 14.0.0
+
+args <- commandArgs(TRUE)
+VERSION <- args[1]
+tools_root <- ""
+
+if (length(args) != 1) {
+  stop("Usage: Rscript tools/update-checksums.R <version>")
+}
+
+tasks_yml <- "../dev/tasks/tasks.yml"
+
+if (!file.exists(tasks_yml)) {
+  stop("Run this script from the r/ directory of the arrow repo")
+}
+
+# Get the libarrow binary paths from the tasks.yml file
+binary_paths <- readLines(tasks_yml) |>
+  grep("r-lib__libarrow", x = _, value = TRUE) |>
+  sub(".+r-lib__libarrow__bin__(.+\\.zip)", "\\1", x = _) |>
+  sub("{no_rc_r_version}", VERSION, fixed = TRUE, x = _) |>
+  sub("__", "/", x = _) |>
+  sub("\\.zip", ".zip", fixed = TRUE, x = _)
+
+artifactory_root <- "https://apache.jfrog.io/artifactory/arrow/r/%s/libarrow/bin/%s"
+
+# Get the checksuym file from the artifactory
+for (path in binary_paths) {
+  sha_path <- paste0(path, ".sha512")
+  file <- file.path("tools/checksums", sha_path)
+  dirname(file) |> dir.create(path = _, recursive = TRUE, showWarnings = FALSE)
+
+  url <- sprintf(artifactory_root, VERSION, sha_path)
+  download.file(url, file, quiet = TRUE, cacheOK = FALSE)
+
+  if (grepl("windows", path)) {
+    # UNIX style line endings cause errors with mysys2 sha512sum
+    sed_status <- system2("sed", args = c("-i", "s/\\r//", file))
+    if (sed_status != 0) {
+      stop("Failed to remove \\r from windows checksum file. Exit code: ", sed_status)
+    }
+  }
+}
diff --git a/r/tools/winlibs.R b/r/tools/winlibs.R
index b554770e40c9b..314062044dcf2 100644
--- a/r/tools/winlibs.R
+++ b/r/tools/winlibs.R
@@ -17,55 +17,84 @@
 
 args <- commandArgs(TRUE)
 VERSION <- args[1]
-if (!file.exists(sprintf("windows/arrow-%s/include/arrow/api.h", VERSION))) {
-  if (length(args) > 1) {
-    # Arg 2 would be the path/to/lib.zip
-    localfile <- args[2]
-    cat(sprintf("*** Using RWINLIB_LOCAL %s\n", localfile))
-    if (!file.exists(localfile)) {
-      cat(sprintf("*** %s does not exist; build will fail\n", localfile))
-    }
-    file.copy(localfile, "lib.zip")
-  } else {
-    # Download static arrow from the apache artifactory
-    quietly <- !identical(tolower(Sys.getenv("ARROW_R_DEV")), "true")
-    get_file <- function(template, version) {
-      try(
-        suppressWarnings(
-          download.file(sprintf(template, version), "lib.zip", quiet = quietly)
-        ),
-        silent = quietly
-      )
-    }
+dev_version <- package_version(VERSION)[1, 4]
+# Small dev versions are added for R-only changes during CRAN submission
+is_release <- is.na(dev_version) || dev_version < "100"
+env_is <- function(var, value) identical(tolower(Sys.getenv(var)), value)
+# We want to log the message in the style of the configure script
+# not as an R error. Use `return` to exit the script after logging.
+lg <- function(...) {
+  cat("*** ", sprintf(...), "\n")
+}
 
-    # URL templates
-    nightly <- paste0(
-      getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"),
-      "/libarrow/bin/windows/arrow-%s.zip"
-    )
-    # %1$s uses the first variable for both substitutions
-    artifactory <- paste0(
-      getOption("arrow.repo", "https://apache.jfrog.io/artifactory/arrow/r/%1$s"),
-      "/libarrow/bin/windows/arrow-%1$s.zip"
-    )
-    rwinlib <- "https://github.com/rwinlib/arrow/archive/v%s.zip"
+if (is_release) {
+  # This is a release version, so we need to use the major.minor.patch version without
+  # the CRAN suffix/dev_version
+  VERSION <- package_version(VERSION)[1, 1:3]
+  # %1$s uses the first variable for both substitutions
+  url_template <- paste0(
+    getOption("arrow.repo", "https://apache.jfrog.io/artifactory/arrow/r/%1$s"),
+    "/libarrow/bin/windows/arrow-%1$s.zip"
+  )
+} else {
+  url_template <- paste0(
+    getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"),
+    "/libarrow/bin/windows/arrow-%s.zip"
+  )
+}
 
-    dev_version <- package_version(VERSION)[1, 4]
+if (file.exists(sprintf("windows/arrow-%s/include/arrow/api.h", VERSION))) {
+  lg("Found local Arrow %s!", VERSION)
+  return()
+}
 
-    # Small dev versions are added for R-only changes during CRAN submission.
-    if (is.na(dev_version) || dev_version < "100") {
-      VERSION <- package_version(VERSION)[1, 1:3]
-      get_file(rwinlib, VERSION)
+zip_file <- sprintf("arrow-%s.zip", VERSION)
 
-      # If not found, fall back to apache artifactory
-      if (!file.exists("lib.zip")) {
-        get_file(artifactory, VERSION)
-      }
-    } else {
-      get_file(nightly, VERSION)
+if (length(args) > 1) {
+  # Arg 2 would be the path/to/lib.zip
+  localfile <- args[2]
+  if (!file.exists(localfile)) {
+    lg("RWINLIB_LOCAL '%s' does not exist. Build will fail.", localfile)
+    return()
+  } else {
+    lg("Using RWINLIB_LOCAL %s", localfile)
+  }
+  file.copy(localfile, zip_file)
+} else {
+  quietly <- !identical(tolower(Sys.getenv("ARROW_R_DEV")), "true")
+  binary_url <- sprintf(url_template, VERSION)
+  try(
+    suppressWarnings(
+      download.file(binary_url, zip_file, quiet = quietly)
+    ),
+    silent = quietly
+  )
+
+  if (!file.exists(zip_file) || file.size(zip_file) == 0) {
+    lg("Failed to download libarrow binary from %s. Build will fail.", binary_url)
+    return()
+  }
+
+  checksum_path <- Sys.getenv("ARROW_R_CHECKSUM_PATH", "tools/checksums")
+  # Explicitly setting the env var to "false" will skip checksum validation
+  # e.g. in case the included checksums are stale.
+  skip_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "false")
+  enforce_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "true")
+  # validate binary checksum for CRAN release only
+  if (!skip_checksum && dir.exists(checksum_path) && is_release ||
+    enforce_checksum) {
+    checksum_file <- sprintf("%s/windows/arrow-%s.zip.sha512", checksum_path, VERSION)
+    # rtools does not have shasum with default config
+    checksum_ok <- system2("sha512sum", args = c("--status", "-c", checksum_file))
+
+    if (checksum_ok != 0) {
+      lg("Checksum validation failed for libarrow binary: %s", zip_file)
+      return()
     }
+    lg("Checksum validated successfully for libarrow binary: %s", zip_file)
   }
-  dir.create("windows", showWarnings = FALSE)
-  unzip("lib.zip", exdir = "windows")
-  unlink("lib.zip")
 }
+
+dir.create("windows", showWarnings = FALSE)
+unzip(zip_file, exdir = "windows")
+unlink(zip_file)

From 0793432ad0ef5cb598b7b1e61071cd4991bd1b8b Mon Sep 17 00:00:00 2001
From: Donald Tolley <tolleybot@gmail.com>
Date: Wed, 11 Oct 2023 07:06:58 -0400
Subject: [PATCH 524/749] GH-29238 [C++][Dataset][Parquet] Support parquet
 modular encryption in the new Dataset API (#34616)

### Rationale for this change

The purpose of this pull request is to support modular encryption in the new Dataset API.  See [https://docs.google.com/document/d/13EysCNC6-Nu9wnJ8YpdzmD-aMLn4i2KXUJTNqIihy7A/edit#](url) for supporting document.

### What changes are included in this PR?

I made improvements to the C++ and Python code to enable the Dataset API to have per-file settings for each file saved. Previously, the Dataset API applied the same encryption properties to all saved files, but now I've updated the code to allow for greater flexibility. In the Python code, I've added support for the changes by updating the ParquetFormat class to accept DatasetEncryptionConfiguration and DatasetDecryptionConfiguration structures. With these changes, you can pass the format object to the write_dataset function, giving you the ability to set unique encryption properties for each file in your Dataset.

### Are these changes tested?

Yes, unit tests are included. I have also included a python sample project.

### Are there any user-facing changes?

Yes,  as stated above the ParquetFormat class has optional parameters for DatasetEncryptionConfiguration and DatasetDecryptionConfiguration through setters and getters.  The Dataset now has the option using this to set different file encryption properties per file

* Closes: #29238

Lead-authored-by: Don <tolleybot@gmail.com>
Co-authored-by: Donald Tolley <tolleybot@gmail.com>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Co-authored-by: anjakefala <anja@voltrondata.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Co-authored-by: Gang Wu <ustcwg@gmail.com>
Co-authored-by: scoder <stefan_ml@behnel.de>
Co-authored-by: Will Jones <willjones127@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/dataset/CMakeLists.txt          |   7 +
 cpp/src/arrow/dataset/file_parquet.cc         |  75 +++++-
 cpp/src/arrow/dataset/file_parquet.h          |   8 +
 .../dataset/file_parquet_encryption_test.cc   | 216 ++++++++++++++++++
 cpp/src/arrow/dataset/file_parquet_test.cc    |  27 +++
 .../arrow/dataset/parquet_encryption_config.h |  75 ++++++
 cpp/src/arrow/util/config.h.cmake             |   1 +
 cpp/src/parquet/properties.h                  |  46 +++-
 python/CMakeLists.txt                         |   6 +
 .../dataset/write_dataset_encrypted.py        |  93 ++++++++
 python/pyarrow/_dataset_parquet.pxd           |  42 ++++
 python/pyarrow/_dataset_parquet.pyx           |  63 ++++-
 .../pyarrow/_dataset_parquet_encryption.pyx   | 170 ++++++++++++++
 python/pyarrow/_parquet_encryption.pxd        | 119 ++--------
 python/pyarrow/_parquet_encryption.pyx        |  42 ++--
 python/pyarrow/dataset.py                     |   9 +
 .../includes/libarrow_dataset_parquet.pxd     |  16 ++
 .../includes/libparquet_encryption.pxd        | 130 +++++++++++
 .../pyarrow/tests/test_dataset_encryption.py  | 148 ++++++++++++
 19 files changed, 1152 insertions(+), 141 deletions(-)
 create mode 100644 cpp/src/arrow/dataset/file_parquet_encryption_test.cc
 create mode 100644 cpp/src/arrow/dataset/parquet_encryption_config.h
 create mode 100644 python/examples/dataset/write_dataset_encrypted.py
 create mode 100644 python/pyarrow/_dataset_parquet.pxd
 create mode 100644 python/pyarrow/_dataset_parquet_encryption.pyx
 create mode 100644 python/pyarrow/includes/libparquet_encryption.pxd
 create mode 100644 python/pyarrow/tests/test_dataset_encryption.py

diff --git a/cpp/src/arrow/dataset/CMakeLists.txt b/cpp/src/arrow/dataset/CMakeLists.txt
index 81cc97781316a..eb8fb54803aa9 100644
--- a/cpp/src/arrow/dataset/CMakeLists.txt
+++ b/cpp/src/arrow/dataset/CMakeLists.txt
@@ -175,6 +175,13 @@ endif()
 
 if(ARROW_PARQUET)
   add_arrow_dataset_test(file_parquet_test)
+  if(PARQUET_REQUIRE_ENCRYPTION AND ARROW_DATASET)
+    add_arrow_dataset_test(file_parquet_encryption_test
+                           SOURCES
+                           file_parquet_encryption_test.cc
+                           ${PROJECT_SOURCE_DIR}/src/parquet/encryption/test_in_memory_kms.cc
+    )
+  endif()
 endif()
 
 if(ARROW_BUILD_BENCHMARKS)
diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index 9c187f12f67cf..d486f194f38a3 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -26,6 +26,7 @@
 
 #include "arrow/compute/exec.h"
 #include "arrow/dataset/dataset_internal.h"
+#include "arrow/dataset/parquet_encryption_config.h"
 #include "arrow/dataset/scanner.h"
 #include "arrow/filesystem/path_util.h"
 #include "arrow/table.h"
@@ -38,6 +39,9 @@
 #include "parquet/arrow/reader.h"
 #include "parquet/arrow/schema.h"
 #include "parquet/arrow/writer.h"
+#include "parquet/encryption/crypto_factory.h"
+#include "parquet/encryption/encryption.h"
+#include "parquet/encryption/kms_client.h"
 #include "parquet/file_reader.h"
 #include "parquet/properties.h"
 #include "parquet/statistics.h"
@@ -58,6 +62,7 @@ namespace {
 
 parquet::ReaderProperties MakeReaderProperties(
     const ParquetFileFormat& format, ParquetFragmentScanOptions* parquet_scan_options,
+    const std::string& path = "", std::shared_ptr<fs::FileSystem> filesystem = nullptr,
     MemoryPool* pool = default_memory_pool()) {
   // Can't mutate pool after construction
   parquet::ReaderProperties properties(pool);
@@ -67,8 +72,28 @@ parquet::ReaderProperties MakeReaderProperties(
     properties.disable_buffered_stream();
   }
   properties.set_buffer_size(parquet_scan_options->reader_properties->buffer_size());
+
+#ifdef PARQUET_REQUIRE_ENCRYPTION
+  auto parquet_decrypt_config = parquet_scan_options->parquet_decryption_config;
+
+  if (parquet_decrypt_config != nullptr) {
+    auto file_decryption_prop =
+        parquet_decrypt_config->crypto_factory->GetFileDecryptionProperties(
+            *parquet_decrypt_config->kms_connection_config,
+            *parquet_decrypt_config->decryption_config, path, filesystem);
+
+    parquet_scan_options->reader_properties->file_decryption_properties(
+        std::move(file_decryption_prop));
+  }
+#else
+  if (parquet_scan_options->parquet_decryption_config != nullptr) {
+    parquet::ParquetException::NYI("Encryption is not supported in this build.");
+  }
+#endif
+
   properties.file_decryption_properties(
       parquet_scan_options->reader_properties->file_decryption_properties());
+
   properties.set_thrift_string_size_limit(
       parquet_scan_options->reader_properties->thrift_string_size_limit());
   properties.set_thrift_container_size_limit(
@@ -438,7 +463,7 @@ Result<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
       GetFragmentScanOptions<ParquetFragmentScanOptions>(kParquetTypeName, options.get(),
                                                          default_fragment_scan_options));
   auto properties =
-      MakeReaderProperties(*this, parquet_scan_options.get(), options->pool);
+      MakeReaderProperties(*this, parquet_scan_options.get(), "", nullptr, options->pool);
   ARROW_ASSIGN_OR_RAISE(auto input, source.Open());
   // `parquet::ParquetFileReader::Open` will not wrap the exception as status,
   // so using `open_parquet_file` to wrap it.
@@ -477,9 +502,13 @@ Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
       auto parquet_scan_options,
       GetFragmentScanOptions<ParquetFragmentScanOptions>(kParquetTypeName, options.get(),
                                                          default_fragment_scan_options));
-  auto properties =
-      MakeReaderProperties(*this, parquet_scan_options.get(), options->pool);
-
+  auto properties = MakeReaderProperties(*this, parquet_scan_options.get(), source.path(),
+                                         source.filesystem(), options->pool);
+  ARROW_ASSIGN_OR_RAISE(auto input, source.Open());
+  // TODO(ARROW-12259): workaround since we have Future<(move-only type)>
+  auto reader_fut = parquet::ParquetFileReader::OpenAsync(
+      std::move(input), std::move(properties), metadata);
+  auto path = source.path();
   auto self = checked_pointer_cast<const ParquetFileFormat>(shared_from_this());
 
   return source.OpenAsync().Then(
@@ -666,10 +695,40 @@ Result<std::shared_ptr<FileWriter>> ParquetFileFormat::MakeWriter(
   auto parquet_options = checked_pointer_cast<ParquetFileWriteOptions>(options);
 
   std::unique_ptr<parquet::arrow::FileWriter> parquet_writer;
-  ARROW_ASSIGN_OR_RAISE(parquet_writer, parquet::arrow::FileWriter::Open(
-                                            *schema, default_memory_pool(), destination,
-                                            parquet_options->writer_properties,
-                                            parquet_options->arrow_writer_properties));
+
+#ifdef PARQUET_REQUIRE_ENCRYPTION
+  auto parquet_encrypt_config = parquet_options->parquet_encryption_config;
+
+  if (parquet_encrypt_config != nullptr) {
+    auto file_encryption_prop =
+        parquet_encrypt_config->crypto_factory->GetFileEncryptionProperties(
+            *parquet_encrypt_config->kms_connection_config,
+            *parquet_encrypt_config->encryption_config, destination_locator.path,
+            destination_locator.filesystem);
+
+    auto writer_properties =
+        parquet::WriterProperties::Builder(*parquet_options->writer_properties)
+            .encryption(std::move(file_encryption_prop))
+            ->build();
+
+    ARROW_ASSIGN_OR_RAISE(
+        parquet_writer, parquet::arrow::FileWriter::Open(
+                            *schema, writer_properties->memory_pool(), destination,
+                            writer_properties, parquet_options->arrow_writer_properties));
+  }
+#else
+  if (parquet_options->parquet_encryption_config != nullptr) {
+    return Status::NotImplemented("Encryption is not supported in this build.");
+  }
+#endif
+
+  if (parquet_writer == nullptr) {
+    ARROW_ASSIGN_OR_RAISE(parquet_writer,
+                          parquet::arrow::FileWriter::Open(
+                              *schema, parquet_options->writer_properties->memory_pool(),
+                              destination, parquet_options->writer_properties,
+                              parquet_options->arrow_writer_properties));
+  }
 
   return std::shared_ptr<FileWriter>(
       new ParquetFileWriter(std::move(destination), std::move(parquet_writer),
diff --git a/cpp/src/arrow/dataset/file_parquet.h b/cpp/src/arrow/dataset/file_parquet.h
index f33190bd93347..5132a805bb4d6 100644
--- a/cpp/src/arrow/dataset/file_parquet.h
+++ b/cpp/src/arrow/dataset/file_parquet.h
@@ -57,6 +57,9 @@ struct SchemaManifest;
 namespace arrow {
 namespace dataset {
 
+struct ParquetDecryptionConfig;
+struct ParquetEncryptionConfig;
+
 /// \addtogroup dataset-file-formats
 ///
 /// @{
@@ -226,6 +229,8 @@ class ARROW_DS_EXPORT ParquetFragmentScanOptions : public FragmentScanOptions {
   /// ScanOptions. Additionally, dictionary columns come from
   /// ParquetFileFormat::ReaderOptions::dict_columns.
   std::shared_ptr<parquet::ArrowReaderProperties> arrow_reader_properties;
+  /// A configuration structure that provides decryption properties for a dataset
+  std::shared_ptr<ParquetDecryptionConfig> parquet_decryption_config = NULLPTR;
 };
 
 class ARROW_DS_EXPORT ParquetFileWriteOptions : public FileWriteOptions {
@@ -236,6 +241,9 @@ class ARROW_DS_EXPORT ParquetFileWriteOptions : public FileWriteOptions {
   /// \brief Parquet Arrow writer properties.
   std::shared_ptr<parquet::ArrowWriterProperties> arrow_writer_properties;
 
+  // A configuration structure that provides encryption properties for a dataset
+  std::shared_ptr<ParquetEncryptionConfig> parquet_encryption_config = NULLPTR;
+
  protected:
   explicit ParquetFileWriteOptions(std::shared_ptr<FileFormat> format)
       : FileWriteOptions(std::move(format)) {}
diff --git a/cpp/src/arrow/dataset/file_parquet_encryption_test.cc b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc
new file mode 100644
index 0000000000000..572f15e100dcb
--- /dev/null
+++ b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc
@@ -0,0 +1,216 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <string_view>
+
+#include "gtest/gtest.h"
+
+#include <arrow/dataset/dataset.h>
+#include <arrow/dataset/file_base.h>
+#include <arrow/dataset/file_parquet.h>
+#include "arrow/array.h"
+#include "arrow/dataset/parquet_encryption_config.h"
+#include "arrow/dataset/partition.h"
+#include "arrow/filesystem/mockfs.h"
+#include "arrow/io/api.h"
+#include "arrow/status.h"
+#include "arrow/table.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/type.h"
+#include "parquet/arrow/reader.h"
+#include "parquet/encryption/crypto_factory.h"
+#include "parquet/encryption/encryption.h"
+#include "parquet/encryption/kms_client.h"
+#include "parquet/encryption/test_in_memory_kms.h"
+
+constexpr std::string_view kFooterKeyMasterKey = "0123456789012345";
+constexpr std::string_view kFooterKeyMasterKeyId = "footer_key";
+constexpr std::string_view kFooterKeyName = "footer_key";
+constexpr std::string_view kColumnMasterKey = "1234567890123450";
+constexpr std::string_view kColumnMasterKeyId = "col_key";
+constexpr std::string_view kColumnKeyMapping = "col_key: a";
+constexpr std::string_view kBaseDir = "";
+
+using arrow::internal::checked_pointer_cast;
+
+namespace arrow {
+namespace dataset {
+
+class DatasetEncryptionTest : public ::testing::Test {
+ public:
+  // This function creates a mock file system using the current time point, creates a
+  // directory with the given base directory path, and writes a dataset to it using
+  // provided Parquet file write options. The dataset is partitioned using a Hive
+  // partitioning scheme. The function also checks if the written files exist in the file
+  // system.
+  static void SetUpTestSuite() {
+    // Creates a mock file system using the current time point.
+    EXPECT_OK_AND_ASSIGN(file_system_, fs::internal::MockFileSystem::Make(
+                                           std::chrono::system_clock::now(), {}));
+    ASSERT_OK(file_system_->CreateDir(std::string(kBaseDir)));
+
+    // Prepare table data.
+    auto table_schema = schema({field("a", int64()), field("c", int64()),
+                                field("e", int64()), field("part", utf8())});
+    table_ = TableFromJSON(table_schema, {R"([
+                          [ 0, 9, 1, "a" ],
+                          [ 1, 8, 2, "a" ],
+                          [ 2, 7, 1, "c" ],
+                          [ 3, 6, 2, "c" ],
+                          [ 4, 5, 1, "e" ],
+                          [ 5, 4, 2, "e" ],
+                          [ 6, 3, 1, "g" ],
+                          [ 7, 2, 2, "g" ],
+                          [ 8, 1, 1, "i" ],
+                          [ 9, 0, 2, "i" ]
+                        ])"});
+
+    // Use a Hive-style partitioning scheme.
+    partitioning_ = std::make_shared<HivePartitioning>(schema({field("part", utf8())}));
+
+    // Prepare encryption properties.
+    std::unordered_map<std::string, std::string> key_map;
+    key_map.emplace(kColumnMasterKeyId, kColumnMasterKey);
+    key_map.emplace(kFooterKeyMasterKeyId, kFooterKeyMasterKey);
+
+    crypto_factory_ = std::make_shared<parquet::encryption::CryptoFactory>();
+    auto kms_client_factory =
+        std::make_shared<parquet::encryption::TestOnlyInMemoryKmsClientFactory>(
+            /*wrap_locally=*/true, key_map);
+    crypto_factory_->RegisterKmsClientFactory(std::move(kms_client_factory));
+    kms_connection_config_ = std::make_shared<parquet::encryption::KmsConnectionConfig>();
+
+    // Set write options with encryption configuration.
+    auto encryption_config =
+        std::make_shared<parquet::encryption::EncryptionConfiguration>(
+            std::string(kFooterKeyName));
+    encryption_config->column_keys = kColumnKeyMapping;
+    auto parquet_encryption_config = std::make_shared<ParquetEncryptionConfig>();
+    // Directly assign shared_ptr objects to ParquetEncryptionConfig members
+    parquet_encryption_config->crypto_factory = crypto_factory_;
+    parquet_encryption_config->kms_connection_config = kms_connection_config_;
+    parquet_encryption_config->encryption_config = std::move(encryption_config);
+
+    auto file_format = std::make_shared<ParquetFileFormat>();
+    auto parquet_file_write_options =
+        checked_pointer_cast<ParquetFileWriteOptions>(file_format->DefaultWriteOptions());
+    parquet_file_write_options->parquet_encryption_config =
+        std::move(parquet_encryption_config);
+
+    // Write dataset.
+    auto dataset = std::make_shared<InMemoryDataset>(table_);
+    EXPECT_OK_AND_ASSIGN(auto scanner_builder, dataset->NewScan());
+    EXPECT_OK_AND_ASSIGN(auto scanner, scanner_builder->Finish());
+
+    FileSystemDatasetWriteOptions write_options;
+    write_options.file_write_options = parquet_file_write_options;
+    write_options.filesystem = file_system_;
+    write_options.base_dir = kBaseDir;
+    write_options.partitioning = partitioning_;
+    write_options.basename_template = "part{i}.parquet";
+    ASSERT_OK(FileSystemDataset::Write(write_options, std::move(scanner)));
+  }
+
+ protected:
+  inline static std::shared_ptr<fs::FileSystem> file_system_;
+  inline static std::shared_ptr<Table> table_;
+  inline static std::shared_ptr<HivePartitioning> partitioning_;
+  inline static std::shared_ptr<parquet::encryption::CryptoFactory> crypto_factory_;
+  inline static std::shared_ptr<parquet::encryption::KmsConnectionConfig>
+      kms_connection_config_;
+};
+
+// This test demonstrates the process of writing a partitioned Parquet file with the same
+// encryption properties applied to each file within the dataset. The encryption
+// properties are determined based on the selected columns. After writing the dataset, the
+// test reads the data back and verifies that it can be successfully decrypted and
+// scanned.
+TEST_F(DatasetEncryptionTest, WriteReadDatasetWithEncryption) {
+  // Create decryption properties.
+  auto decryption_config =
+      std::make_shared<parquet::encryption::DecryptionConfiguration>();
+  auto parquet_decryption_config = std::make_shared<ParquetDecryptionConfig>();
+  parquet_decryption_config->crypto_factory = crypto_factory_;
+  parquet_decryption_config->kms_connection_config = kms_connection_config_;
+  parquet_decryption_config->decryption_config = std::move(decryption_config);
+
+  // Set scan options.
+  auto parquet_scan_options = std::make_shared<ParquetFragmentScanOptions>();
+  parquet_scan_options->parquet_decryption_config = std::move(parquet_decryption_config);
+
+  auto file_format = std::make_shared<ParquetFileFormat>();
+  file_format->default_fragment_scan_options = std::move(parquet_scan_options);
+
+  // Get FileInfo objects for all files under the base directory
+  fs::FileSelector selector;
+  selector.base_dir = kBaseDir;
+  selector.recursive = true;
+
+  FileSystemFactoryOptions factory_options;
+  factory_options.partitioning = partitioning_;
+  factory_options.partition_base_dir = kBaseDir;
+  ASSERT_OK_AND_ASSIGN(auto dataset_factory,
+                       FileSystemDatasetFactory::Make(file_system_, selector, file_format,
+                                                      factory_options));
+
+  // Read dataset into table
+  ASSERT_OK_AND_ASSIGN(auto dataset, dataset_factory->Finish());
+  ASSERT_OK_AND_ASSIGN(auto scanner_builder, dataset->NewScan());
+  ASSERT_OK_AND_ASSIGN(auto scanner, scanner_builder->Finish());
+  ASSERT_OK_AND_ASSIGN(auto read_table, scanner->ToTable());
+
+  // Verify the data was read correctly
+  ASSERT_OK_AND_ASSIGN(auto combined_table, read_table->CombineChunks());
+  // Validate the table
+  ASSERT_OK(combined_table->ValidateFull());
+  AssertTablesEqual(*combined_table, *table_);
+}
+
+// Read a single parquet file with and without decryption properties.
+TEST_F(DatasetEncryptionTest, ReadSingleFile) {
+  // Open the Parquet file.
+  ASSERT_OK_AND_ASSIGN(auto input, file_system_->OpenInputFile("part=a/part0.parquet"));
+
+  // Try to read metadata without providing decryption properties
+  // when the footer is encrypted.
+  ASSERT_THROW(parquet::ReadMetaData(input), parquet::ParquetException);
+
+  // Create the ReaderProperties object using the FileDecryptionProperties object
+  auto decryption_config =
+      std::make_shared<parquet::encryption::DecryptionConfiguration>();
+  auto file_decryption_properties = crypto_factory_->GetFileDecryptionProperties(
+      *kms_connection_config_, *decryption_config);
+  auto reader_properties = parquet::default_reader_properties();
+  reader_properties.file_decryption_properties(file_decryption_properties);
+
+  // Read entire file as a single Arrow table
+  parquet::arrow::FileReaderBuilder reader_builder;
+  ASSERT_OK(reader_builder.Open(input, reader_properties));
+  ASSERT_OK_AND_ASSIGN(auto arrow_reader, reader_builder.Build());
+  std::shared_ptr<Table> table;
+  ASSERT_OK(arrow_reader->ReadTable(&table));
+
+  // Check the contents of the table
+  ASSERT_EQ(table->num_rows(), 2);
+  ASSERT_EQ(table->num_columns(), 3);
+  ASSERT_EQ(checked_pointer_cast<Int64Array>(table->column(0)->chunk(0))->GetView(0), 0);
+  ASSERT_EQ(checked_pointer_cast<Int64Array>(table->column(1)->chunk(0))->GetView(0), 9);
+  ASSERT_EQ(checked_pointer_cast<Int64Array>(table->column(2)->chunk(0))->GetView(0), 1);
+}
+
+}  // namespace dataset
+}  // namespace arrow
diff --git a/cpp/src/arrow/dataset/file_parquet_test.cc b/cpp/src/arrow/dataset/file_parquet_test.cc
index dc9e085df3c4c..c22cf33eb35f7 100644
--- a/cpp/src/arrow/dataset/file_parquet_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_test.cc
@@ -24,6 +24,7 @@
 
 #include "arrow/compute/api_scalar.h"
 #include "arrow/dataset/dataset_internal.h"
+#include "arrow/dataset/parquet_encryption_config.h"
 #include "arrow/dataset/test_util_internal.h"
 #include "arrow/io/interfaces.h"
 #include "arrow/io/memory.h"
@@ -424,6 +425,32 @@ TEST_F(TestParquetFileSystemDataset, WriteWithEmptyPartitioningSchema) {
   TestWriteWithEmptyPartitioningSchema();
 }
 
+TEST_F(TestParquetFileSystemDataset, WriteWithEncryptionConfigNotSupported) {
+#ifndef PARQUET_REQUIRE_ENCRYPTION
+  // Create a dummy ParquetEncryptionConfig
+  std::shared_ptr<ParquetEncryptionConfig> encryption_config =
+      std::make_shared<ParquetEncryptionConfig>();
+
+  auto options =
+      checked_pointer_cast<ParquetFileWriteOptions>(format_->DefaultWriteOptions());
+
+  // Set the encryption config in the options
+  options->parquet_encryption_config = encryption_config;
+
+  // Setup mock filesystem and test data
+  auto mock_fs = std::make_shared<fs::internal::MockFileSystem>(fs::kNoTime);
+  std::shared_ptr<Schema> test_schema = schema({field("x", int32())});
+  std::shared_ptr<RecordBatch> batch = RecordBatchFromJSON(test_schema, "[[0]]");
+  ASSERT_OK_AND_ASSIGN(std::shared_ptr<io::OutputStream> out_stream,
+                       mock_fs->OpenOutputStream("/foo.parquet"));
+  // Try to create a writer with the encryption config
+  auto result =
+      format_->MakeWriter(out_stream, test_schema, options, {mock_fs, "/foo.parquet"});
+  // Expect an error if encryption is not supported in the build
+  EXPECT_TRUE(result.status().IsNotImplemented());
+#endif
+}
+
 class TestParquetFileFormatScan : public FileFormatScanMixin<ParquetFormatHelper> {
  public:
   std::shared_ptr<RecordBatch> SingleBatch(std::shared_ptr<Fragment> fragment) {
diff --git a/cpp/src/arrow/dataset/parquet_encryption_config.h b/cpp/src/arrow/dataset/parquet_encryption_config.h
new file mode 100644
index 0000000000000..96200b8a3118b
--- /dev/null
+++ b/cpp/src/arrow/dataset/parquet_encryption_config.h
@@ -0,0 +1,75 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/dataset/type_fwd.h"
+
+namespace parquet::encryption {
+class CryptoFactory;
+struct KmsConnectionConfig;
+struct EncryptionConfiguration;
+struct DecryptionConfiguration;
+}  // namespace parquet::encryption
+
+namespace arrow {
+namespace dataset {
+
+/// \brief Core configuration class encapsulating parameters for high-level encryption
+/// within Parquet framework.
+///
+/// ParquetEncryptionConfig serves as a bridge, passing encryption-related
+/// parameters to appropriate components within the Parquet library. It holds references
+/// to objects defining encryption strategy, Key Management Service (KMS) configuration,
+/// and specific encryption configurations for Parquet data.
+struct ARROW_DS_EXPORT ParquetEncryptionConfig {
+  ///  Shared pointer to CryptoFactory object, responsible for creating cryptographic
+  ///  components like encryptors and decryptors.
+  std::shared_ptr<parquet::encryption::CryptoFactory> crypto_factory;
+
+  ///  Shared pointer to KmsConnectionConfig object, holding configuration parameters for
+  ///  connecting to a Key Management Service (KMS).
+  std::shared_ptr<parquet::encryption::KmsConnectionConfig> kms_connection_config;
+
+  ///  Shared pointer to EncryptionConfiguration object, defining specific encryption
+  ///  settings for Parquet data, like keys for different columns.
+  std::shared_ptr<parquet::encryption::EncryptionConfiguration> encryption_config;
+};
+
+/// \brief Core configuration class encapsulating parameters for high-level decryption
+/// within Parquet framework.
+///
+/// ParquetDecryptionConfig is designed to pass decryption-related parameters to
+/// appropriate decryption components within Parquet library. It holds references to
+/// objects defining decryption strategy, Key Management Service (KMS) configuration,
+/// and specific decryption configurations for reading encrypted Parquet data.
+struct ARROW_DS_EXPORT ParquetDecryptionConfig {
+  ///  Shared pointer to CryptoFactory object, pivotal in creating cryptographic
+  ///  components for decryption process.
+  std::shared_ptr<parquet::encryption::CryptoFactory> crypto_factory;
+
+  ///  Shared pointer to KmsConnectionConfig object, containing parameters for connecting
+  ///  to a Key Management Service (KMS) during decryption.
+  std::shared_ptr<parquet::encryption::KmsConnectionConfig> kms_connection_config;
+
+  ///  Shared pointer to DecryptionConfiguration object, specifying decryption settings
+  ///  for reading encrypted Parquet data.
+  std::shared_ptr<parquet::encryption::DecryptionConfiguration> decryption_config;
+};
+
+}  // namespace dataset
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/config.h.cmake b/cpp/src/arrow/util/config.h.cmake
index f7125cfd8a235..6c8c31ffb856f 100644
--- a/cpp/src/arrow/util/config.h.cmake
+++ b/cpp/src/arrow/util/config.h.cmake
@@ -58,3 +58,4 @@
 #cmakedefine ARROW_WITH_MUSL
 #cmakedefine ARROW_WITH_OPENTELEMETRY
 #cmakedefine ARROW_WITH_UCX
+#cmakedefine PARQUET_REQUIRE_ENCRYPTION
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index c15ada0a8060f..6d3d5aa4f44b4 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -232,6 +232,21 @@ class PARQUET_EXPORT WriterProperties {
           created_by_(DEFAULT_CREATED_BY),
           store_decimal_as_integer_(false),
           page_checksum_enabled_(false) {}
+
+    explicit Builder(const WriterProperties& properties)
+        : pool_(properties.memory_pool()),
+          dictionary_pagesize_limit_(properties.dictionary_pagesize_limit()),
+          write_batch_size_(properties.write_batch_size()),
+          max_row_group_length_(properties.max_row_group_length()),
+          pagesize_(properties.data_pagesize()),
+          version_(properties.version()),
+          data_page_version_(properties.data_page_version()),
+          created_by_(properties.created_by()),
+          store_decimal_as_integer_(properties.store_decimal_as_integer()),
+          page_checksum_enabled_(properties.page_checksum_enabled()),
+          sorting_columns_(properties.sorting_columns()),
+          default_column_properties_(properties.default_column_properties()) {}
+
     virtual ~Builder() {}
 
     /// Specify the memory pool for the writer. Default default_memory_pool.
@@ -240,36 +255,42 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
-    /// Enable dictionary encoding in general for all columns. Default enabled.
+    /// Enable dictionary encoding in general for all columns. Default
+    /// enabled.
     Builder* enable_dictionary() {
       default_column_properties_.set_dictionary_enabled(true);
       return this;
     }
 
-    /// Disable dictionary encoding in general for all columns. Default enabled.
+    /// Disable dictionary encoding in general for all columns. Default
+    /// enabled.
     Builder* disable_dictionary() {
       default_column_properties_.set_dictionary_enabled(false);
       return this;
     }
 
-    /// Enable dictionary encoding for column specified by `path`. Default enabled.
+    /// Enable dictionary encoding for column specified by `path`. Default
+    /// enabled.
     Builder* enable_dictionary(const std::string& path) {
       dictionary_enabled_[path] = true;
       return this;
     }
 
-    /// Enable dictionary encoding for column specified by `path`. Default enabled.
+    /// Enable dictionary encoding for column specified by `path`. Default
+    /// enabled.
     Builder* enable_dictionary(const std::shared_ptr<schema::ColumnPath>& path) {
       return this->enable_dictionary(path->ToDotString());
     }
 
-    /// Disable dictionary encoding for column specified by `path`. Default enabled.
+    /// Disable dictionary encoding for column specified by `path`. Default
+    /// enabled.
     Builder* disable_dictionary(const std::string& path) {
       dictionary_enabled_[path] = false;
       return this;
     }
 
-    /// Disable dictionary encoding for column specified by `path`. Default enabled.
+    /// Disable dictionary encoding for column specified by `path`. Default
+    /// enabled.
     Builder* disable_dictionary(const std::shared_ptr<schema::ColumnPath>& path) {
       return this->disable_dictionary(path->ToDotString());
     }
@@ -280,8 +301,8 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
-    /// Specify the write batch size while writing batches of Arrow values into Parquet.
-    /// Default 1024.
+    /// Specify the write batch size while writing batches of Arrow values
+    /// into Parquet. Default 1024.
     Builder* write_batch_size(int64_t write_batch_size) {
       write_batch_size_ = write_batch_size;
       return this;
@@ -560,8 +581,8 @@ class PARQUET_EXPORT WriterProperties {
       return this;
     }
 
-    /// Disable decimal logical type with 1 <= precision <= 18 to be stored as
-    /// integer physical type.
+    /// Disable decimal logical type with 1 <= precision <= 18 to be stored
+    /// as integer physical type.
     ///
     /// Default disabled.
     Builder* disable_store_decimal_as_integer() {
@@ -775,6 +796,11 @@ class PARQUET_EXPORT WriterProperties {
     }
   }
 
+  // \brief Return the default column properties
+  const ColumnProperties& default_column_properties() const {
+    return default_column_properties_;
+  }
+
  private:
   explicit WriterProperties(
       MemoryPool* pool, int64_t dictionary_pagesize_limit, int64_t write_batch_size,
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 29f8d2da72f3a..2a430055a5a86 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -340,9 +340,12 @@ if(PYARROW_BUILD_PARQUET_ENCRYPTION)
     else()
       list(APPEND PYARROW_CPP_LINK_LIBS Parquet::parquet_static)
     endif()
+    message(STATUS "Parquet Encryption Enabled")
   else()
     message(FATAL_ERROR "You must build Arrow C++ with PARQUET_REQUIRE_ENCRYPTION=ON")
   endif()
+else()
+  message(STATUS "Parquet Encryption is NOT Enabled")
 endif()
 
 if(PYARROW_BUILD_HDFS)
@@ -627,6 +630,9 @@ if(PYARROW_BUILD_PARQUET)
   endif()
   if(PYARROW_BUILD_DATASET)
     list(APPEND CYTHON_EXTENSIONS _dataset_parquet)
+    if(PYARROW_BUILD_PARQUET_ENCRYPTION)
+      list(APPEND CYTHON_EXTENSIONS _dataset_parquet_encryption)
+    endif()
   endif()
 endif()
 
diff --git a/python/examples/dataset/write_dataset_encrypted.py b/python/examples/dataset/write_dataset_encrypted.py
new file mode 100644
index 0000000000000..910559939e65e
--- /dev/null
+++ b/python/examples/dataset/write_dataset_encrypted.py
@@ -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.
+
+import shutil
+import os
+from datetime import timedelta
+
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pyarrow.parquet.encryption as pe
+from pyarrow.tests.parquet.encryption import InMemoryKmsClient
+
+""" A sample to demonstrate parquet dataset encryption and decryption"""
+
+# create a list of dictionaries that will represent our dataset
+table = pa.table({'year': [2020, 2022, 2021, 2022, 2019, 2021],
+                  'n_legs': [2, 2, 4, 4, 5, 100],
+                  'animal': ["Flamingo", "Parrot", "Dog", "Horse",
+                             "Brittle stars", "Centipede"]})
+
+# create a PyArrow dataset from the table
+dataset = ds.dataset(table)
+
+FOOTER_KEY = b"0123456789112345"
+FOOTER_KEY_NAME = "footer_key"
+COL_KEY = b"1234567890123450"
+COL_KEY_NAME = "col_key"
+
+encryption_config = pe.EncryptionConfiguration(
+    footer_key=FOOTER_KEY_NAME,
+    plaintext_footer=False,
+    # Use COL_KEY_NAME to encrypt `n_legs` and `animal` columns.
+    column_keys={
+        COL_KEY_NAME: ["n_legs", "animal"],
+    },
+    encryption_algorithm="AES_GCM_V1",
+    # requires timedelta or an assertion is raised
+    cache_lifetime=timedelta(minutes=5.0),
+    data_key_length_bits=256)
+
+kms_connection_config = pe.KmsConnectionConfig(
+    custom_kms_conf={
+        FOOTER_KEY_NAME: FOOTER_KEY.decode("UTF-8"),
+        COL_KEY_NAME: COL_KEY.decode("UTF-8"),
+    }
+)
+
+decryption_config = pe.DecryptionConfiguration(cache_lifetime=300)
+
+
+def kms_factory(kms_connection_configuration):
+    return InMemoryKmsClient(kms_connection_configuration)
+
+
+crypto_factory = pe.CryptoFactory(kms_factory)
+parquet_encryption_cfg = ds.ParquetEncryptionConfig(
+    crypto_factory, kms_connection_config, encryption_config)
+parquet_decryption_cfg = ds.ParquetDecryptionConfig(crypto_factory,
+                                                    kms_connection_config,
+                                                    decryption_config)
+
+# set encryption config for parquet fragment scan options
+pq_scan_opts = ds.ParquetFragmentScanOptions()
+pq_scan_opts.parquet_decryption_config = parquet_decryption_cfg
+pformat = pa.dataset.ParquetFileFormat(default_fragment_scan_options=pq_scan_opts)
+
+if os.path.exists('sample_dataset'):
+    shutil.rmtree('sample_dataset')
+
+write_options = pformat.make_write_options(
+    encryption_config=parquet_encryption_cfg)
+
+ds.write_dataset(data=dataset, base_dir="sample_dataset",
+                 partitioning=['year'], format=pformat, file_options=write_options)
+# read the dataset back
+dataset = ds.dataset('sample_dataset', format=pformat)
+
+# print the dataset
+print(dataset.to_table())
diff --git a/python/pyarrow/_dataset_parquet.pxd b/python/pyarrow/_dataset_parquet.pxd
new file mode 100644
index 0000000000000..d5bc172d324d5
--- /dev/null
+++ b/python/pyarrow/_dataset_parquet.pxd
@@ -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.
+
+# cython: language_level = 3
+
+"""Dataset support for Parquet file format."""
+
+from pyarrow.includes.libarrow_dataset cimport *
+from pyarrow.includes.libarrow_dataset_parquet cimport *
+
+from pyarrow._dataset cimport FragmentScanOptions, FileWriteOptions
+
+
+cdef class ParquetFragmentScanOptions(FragmentScanOptions):
+    cdef:
+        CParquetFragmentScanOptions* parquet_options
+        object _parquet_decryption_config
+
+    cdef void init(self, const shared_ptr[CFragmentScanOptions]& sp)
+    cdef CReaderProperties* reader_properties(self)
+    cdef ArrowReaderProperties* arrow_reader_properties(self)
+
+
+cdef class ParquetFileWriteOptions(FileWriteOptions):
+
+    cdef:
+        CParquetFileWriteOptions* parquet_options
+        object _properties
diff --git a/python/pyarrow/_dataset_parquet.pyx b/python/pyarrow/_dataset_parquet.pyx
index 9d85142564011..31aa058706a87 100644
--- a/python/pyarrow/_dataset_parquet.pyx
+++ b/python/pyarrow/_dataset_parquet.pyx
@@ -17,7 +17,7 @@
 
 # cython: language_level = 3
 
-"""Dataset support for Parquest file format."""
+"""Dataset support for Parquet file format."""
 
 from cython cimport binding
 from cython.operator cimport dereference as deref
@@ -47,16 +47,23 @@ from pyarrow._dataset cimport (
     WrittenFile
 )
 
-
 from pyarrow._parquet cimport (
     _create_writer_properties, _create_arrow_writer_properties,
     FileMetaData,
 )
 
 
-cdef Expression _true = Expression._scalar(True)
+try:
+    from pyarrow._dataset_parquet_encryption import (
+        set_encryption_config, set_decryption_config
+    )
+    parquet_encryption_enabled = True
+except ImportError:
+    parquet_encryption_enabled = False
 
 
+cdef Expression _true = Expression._scalar(True)
+
 ctypedef CParquetFileWriter* _CParquetFileWriterPtr
 
 
@@ -78,7 +85,8 @@ cdef class ParquetFileFormat(FileFormat):
         CParquetFileFormat* parquet_format
 
     def __init__(self, read_options=None,
-                 default_fragment_scan_options=None, **kwargs):
+                 default_fragment_scan_options=None,
+                 **kwargs):
         cdef:
             shared_ptr[CParquetFileFormat] wrapped
             CParquetFileFormatReaderOptions* options
@@ -130,6 +138,7 @@ cdef class ParquetFileFormat(FileFormat):
                             'ParquetFragmentScanOptions')
 
         wrapped = make_shared[CParquetFileFormat]()
+
         options = &(wrapped.get().reader_options)
         if read_options.dictionary_columns is not None:
             for column in read_options.dictionary_columns:
@@ -550,10 +559,6 @@ cdef class ParquetReadOptions(_Weakrefable):
 
 cdef class ParquetFileWriteOptions(FileWriteOptions):
 
-    cdef:
-        CParquetFileWriteOptions* parquet_options
-        object _properties
-
     def update(self, **kwargs):
         """
         Parameters
@@ -574,6 +579,8 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
             self._properties[name] = value
             if name in arrow_fields:
                 setters.add(self._set_arrow_properties)
+            elif name == "encryption_config" and value is not None:
+                setters.add(self._set_encryption_config)
             else:
                 setters.add(self._set_properties)
 
@@ -618,6 +625,14 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
             )
         )
 
+    def _set_encryption_config(self):
+        if not parquet_encryption_enabled:
+            raise NotImplementedError(
+                "Encryption is not enabled in your installation of pyarrow, but an "
+                "encryption_config was provided."
+            )
+        set_encryption_config(self, self._properties["encryption_config"])
+
     cdef void init(self, const shared_ptr[CFileWriteOptions]& sp):
         FileWriteOptions.init(self, sp)
         self.parquet_options = <CParquetFileWriteOptions*> sp.get()
@@ -639,7 +654,9 @@ cdef class ParquetFileWriteOptions(FileWriteOptions):
             write_batch_size=None,
             dictionary_pagesize_limit=None,
             write_page_index=False,
+            encryption_config=None,
         )
+
         self._set_properties()
         self._set_arrow_properties()
 
@@ -681,11 +698,11 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
         If not None, override the maximum total size of containers allocated
         when decoding Thrift structures. The default limit should be
         sufficient for most Parquet files.
+    decryption_config : pyarrow.dataset.ParquetDecryptionConfig, default None
+        If not None, use the provided ParquetDecryptionConfig to decrypt the
+        Parquet file.
     """
 
-    cdef:
-        CParquetFragmentScanOptions* parquet_options
-
     # Avoid mistakingly creating attributes
     __slots__ = ()
 
@@ -693,7 +710,8 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
                  buffer_size=8192,
                  bint pre_buffer=True,
                  thrift_string_size_limit=None,
-                 thrift_container_size_limit=None):
+                 thrift_container_size_limit=None,
+                 decryption_config=None):
         self.init(shared_ptr[CFragmentScanOptions](
             new CParquetFragmentScanOptions()))
         self.use_buffered_stream = use_buffered_stream
@@ -703,6 +721,8 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
             self.thrift_string_size_limit = thrift_string_size_limit
         if thrift_container_size_limit is not None:
             self.thrift_container_size_limit = thrift_container_size_limit
+        if decryption_config is not None:
+            self.parquet_decryption_config = decryption_config
 
     cdef void init(self, const shared_ptr[CFragmentScanOptions]& sp):
         FragmentScanOptions.init(self, sp)
@@ -763,6 +783,25 @@ cdef class ParquetFragmentScanOptions(FragmentScanOptions):
             raise ValueError("size must be larger than zero")
         self.reader_properties().set_thrift_container_size_limit(size)
 
+    @property
+    def parquet_decryption_config(self):
+        if not parquet_encryption_enabled:
+            raise NotImplementedError(
+                "Unable to access encryption features. "
+                "Encryption is not enabled in your installation of pyarrow."
+            )
+        return self._parquet_decryption_config
+
+    @parquet_decryption_config.setter
+    def parquet_decryption_config(self, config):
+        if not parquet_encryption_enabled:
+            raise NotImplementedError(
+                "Encryption is not enabled in your installation of pyarrow, but a "
+                "decryption_config was provided."
+            )
+        set_decryption_config(self, config)
+        self._parquet_decryption_config = config
+
     def equals(self, ParquetFragmentScanOptions other):
         """
         Parameters
diff --git a/python/pyarrow/_dataset_parquet_encryption.pyx b/python/pyarrow/_dataset_parquet_encryption.pyx
new file mode 100644
index 0000000000000..11a7174eb3c9d
--- /dev/null
+++ b/python/pyarrow/_dataset_parquet_encryption.pyx
@@ -0,0 +1,170 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# cython: language_level = 3
+
+"""Dataset support for Parquet encryption."""
+
+from pyarrow.includes.libarrow_dataset_parquet cimport *
+from pyarrow._parquet_encryption cimport *
+from pyarrow._dataset_parquet cimport ParquetFragmentScanOptions, ParquetFileWriteOptions
+
+
+cdef class ParquetEncryptionConfig(_Weakrefable):
+    """
+    Core configuration class encapsulating parameters for high-level encryption
+    within the Parquet framework.
+
+    The ParquetEncryptionConfig class serves as a bridge for passing encryption-related
+    parameters to the appropriate components within the Parquet library. It maintains references
+    to objects that define the encryption strategy, Key Management Service (KMS) configuration,
+    and specific encryption configurations for Parquet data.
+
+    Parameters
+    ----------
+    crypto_factory : pyarrow.parquet.encryption.CryptoFactory
+        Shared pointer to a `CryptoFactory` object. The `CryptoFactory` is responsible for
+        creating cryptographic components, such as encryptors and decryptors.
+    kms_connection_config : pyarrow.parquet.encryption.KmsConnectionConfig
+        Shared pointer to a `KmsConnectionConfig` object. This object holds the configuration
+        parameters necessary for connecting to a Key Management Service (KMS).
+    encryption_config : pyarrow.parquet.encryption.EncryptionConfiguration
+        Shared pointer to an `EncryptionConfiguration` object. This object defines specific
+        encryption settings for Parquet data, including the keys assigned to different columns.
+
+    Raises
+    ------
+    ValueError
+        Raised if `encryption_config` is None.
+    """
+    cdef:
+        shared_ptr[CParquetEncryptionConfig] c_config
+
+    # Avoid mistakenly creating attributes
+    __slots__ = ()
+
+    def __cinit__(self, CryptoFactory crypto_factory, KmsConnectionConfig kms_connection_config,
+                  EncryptionConfiguration encryption_config):
+
+        cdef shared_ptr[CEncryptionConfiguration] c_encryption_config
+
+        if crypto_factory is None:
+            raise ValueError("crypto_factory cannot be None")
+
+        if kms_connection_config is None:
+            raise ValueError("kms_connection_config cannot be None")
+
+        if encryption_config is None:
+            raise ValueError("encryption_config cannot be None")
+
+        self.c_config.reset(new CParquetEncryptionConfig())
+
+        c_encryption_config = pyarrow_unwrap_encryptionconfig(
+            encryption_config)
+
+        self.c_config.get().crypto_factory = pyarrow_unwrap_cryptofactory(crypto_factory)
+        self.c_config.get().kms_connection_config = pyarrow_unwrap_kmsconnectionconfig(
+            kms_connection_config)
+        self.c_config.get().encryption_config = c_encryption_config
+
+    @staticmethod
+    cdef wrap(shared_ptr[CParquetEncryptionConfig] c_config):
+        cdef ParquetEncryptionConfig python_config = ParquetEncryptionConfig.__new__(ParquetEncryptionConfig)
+        python_config.c_config = c_config
+        return python_config
+
+    cdef shared_ptr[CParquetEncryptionConfig] unwrap(self):
+        return self.c_config
+
+
+cdef class ParquetDecryptionConfig(_Weakrefable):
+    """
+    Core configuration class encapsulating parameters for high-level decryption
+    within the Parquet framework.
+
+    ParquetDecryptionConfig is designed to pass decryption-related parameters to
+    the appropriate decryption components within the Parquet library. It holds references to
+    objects that define the decryption strategy, Key Management Service (KMS) configuration,
+    and specific decryption configurations for reading encrypted Parquet data.
+
+    Parameters
+    ----------
+    crypto_factory : pyarrow.parquet.encryption.CryptoFactory
+        Shared pointer to a `CryptoFactory` object, pivotal in creating cryptographic
+        components for the decryption process.
+    kms_connection_config : pyarrow.parquet.encryption.KmsConnectionConfig
+        Shared pointer to a `KmsConnectionConfig` object, containing parameters necessary
+        for connecting to a Key Management Service (KMS) during decryption.
+    decryption_config : pyarrow.parquet.encryption.DecryptionConfiguration
+        Shared pointer to a `DecryptionConfiguration` object, specifying decryption settings
+        for reading encrypted Parquet data.
+
+    Raises
+    ------
+    ValueError
+        Raised if `decryption_config` is None.
+    """
+
+    cdef:
+        shared_ptr[CParquetDecryptionConfig] c_config
+
+    # Avoid mistakingly creating attributes
+    __slots__ = ()
+
+    def __cinit__(self, CryptoFactory crypto_factory, KmsConnectionConfig kms_connection_config,
+                  DecryptionConfiguration decryption_config):
+
+        cdef shared_ptr[CDecryptionConfiguration] c_decryption_config
+
+        if decryption_config is None:
+            raise ValueError(
+                "decryption_config cannot be None")
+
+        self.c_config.reset(new CParquetDecryptionConfig())
+
+        c_decryption_config = pyarrow_unwrap_decryptionconfig(
+            decryption_config)
+
+        self.c_config.get().crypto_factory = pyarrow_unwrap_cryptofactory(crypto_factory)
+        self.c_config.get().kms_connection_config = pyarrow_unwrap_kmsconnectionconfig(
+            kms_connection_config)
+        self.c_config.get().decryption_config = c_decryption_config
+
+    @staticmethod
+    cdef wrap(shared_ptr[CParquetDecryptionConfig] c_config):
+        cdef ParquetDecryptionConfig python_config = ParquetDecryptionConfig.__new__(ParquetDecryptionConfig)
+        python_config.c_config = c_config
+        return python_config
+
+    cdef shared_ptr[CParquetDecryptionConfig] unwrap(self):
+        return self.c_config
+
+
+def set_encryption_config(
+    ParquetFileWriteOptions opts not None,
+    ParquetEncryptionConfig config not None
+):
+    cdef shared_ptr[CParquetEncryptionConfig] c_config = config.unwrap()
+    opts.parquet_options.parquet_encryption_config = c_config
+
+
+def set_decryption_config(
+    ParquetFragmentScanOptions opts not None,
+    ParquetDecryptionConfig config not None
+):
+    cdef shared_ptr[CParquetDecryptionConfig] c_config = config.unwrap()
+    opts.parquet_options.parquet_decryption_config = c_config
diff --git a/python/pyarrow/_parquet_encryption.pxd b/python/pyarrow/_parquet_encryption.pxd
index a05312be533f2..d52669501a404 100644
--- a/python/pyarrow/_parquet_encryption.pxd
+++ b/python/pyarrow/_parquet_encryption.pxd
@@ -19,6 +19,7 @@
 # cython: language_level = 3
 
 from pyarrow.includes.common cimport *
+from pyarrow.includes.libparquet_encryption cimport *
 from pyarrow._parquet cimport (ParquetCipher,
                                CFileEncryptionProperties,
                                CFileDecryptionProperties,
@@ -26,108 +27,30 @@ from pyarrow._parquet cimport (ParquetCipher,
                                FileDecryptionProperties,
                                ParquetCipher_AES_GCM_V1,
                                ParquetCipher_AES_GCM_CTR_V1)
+from pyarrow.lib cimport _Weakrefable
 
+cdef class CryptoFactory(_Weakrefable):
+    cdef shared_ptr[CPyCryptoFactory] factory
+    cdef init(self, callable_client_factory)
+    cdef inline shared_ptr[CPyCryptoFactory] unwrap(self)
 
-cdef extern from "parquet/encryption/kms_client.h" \
-        namespace "parquet::encryption" nogil:
-    cdef cppclass CKmsClient" parquet::encryption::KmsClient":
-        c_string WrapKey(const c_string& key_bytes,
-                         const c_string& master_key_identifier) except +
-        c_string UnwrapKey(const c_string& wrapped_key,
-                           const c_string& master_key_identifier) except +
+cdef class EncryptionConfiguration(_Weakrefable):
+    cdef shared_ptr[CEncryptionConfiguration] configuration
+    cdef inline shared_ptr[CEncryptionConfiguration] unwrap(self) nogil
 
-    cdef cppclass CKeyAccessToken" parquet::encryption::KeyAccessToken":
-        CKeyAccessToken(const c_string value)
-        void Refresh(const c_string& new_value)
-        const c_string& value() const
+cdef class DecryptionConfiguration(_Weakrefable):
+    cdef shared_ptr[CDecryptionConfiguration] configuration
+    cdef inline shared_ptr[CDecryptionConfiguration] unwrap(self) nogil
 
-    cdef cppclass CKmsConnectionConfig \
-            " parquet::encryption::KmsConnectionConfig":
-        CKmsConnectionConfig()
-        c_string kms_instance_id
-        c_string kms_instance_url
-        shared_ptr[CKeyAccessToken] refreshable_key_access_token
-        unordered_map[c_string, c_string] custom_kms_conf
+cdef class KmsConnectionConfig(_Weakrefable):
+    cdef shared_ptr[CKmsConnectionConfig] configuration
+    cdef inline shared_ptr[CKmsConnectionConfig] unwrap(self) nogil
 
-# Callbacks for implementing Python kms clients
-# Use typedef to emulate syntax for std::function<void(..)>
-ctypedef void CallbackWrapKey(
-    object, const c_string&, const c_string&, c_string*)
-ctypedef void CallbackUnwrapKey(
-    object, const c_string&, const c_string&, c_string*)
+    @staticmethod
+    cdef wrap(const CKmsConnectionConfig& config)
 
-cdef extern from "parquet/encryption/kms_client_factory.h" \
-        namespace "parquet::encryption" nogil:
-    cdef cppclass CKmsClientFactory" parquet::encryption::KmsClientFactory":
-        shared_ptr[CKmsClient] CreateKmsClient(
-            const CKmsConnectionConfig& kms_connection_config) except +
 
-# Callbacks for implementing Python kms client factories
-# Use typedef to emulate syntax for std::function<void(..)>
-ctypedef void CallbackCreateKmsClient(
-    object,
-    const CKmsConnectionConfig&, shared_ptr[CKmsClient]*)
-
-cdef extern from "parquet/encryption/crypto_factory.h" \
-        namespace "parquet::encryption" nogil:
-    cdef cppclass CEncryptionConfiguration\
-            " parquet::encryption::EncryptionConfiguration":
-        CEncryptionConfiguration(const c_string& footer_key) except +
-        c_string footer_key
-        c_string column_keys
-        ParquetCipher encryption_algorithm
-        c_bool plaintext_footer
-        c_bool double_wrapping
-        double cache_lifetime_seconds
-        c_bool internal_key_material
-        int32_t data_key_length_bits
-
-    cdef cppclass CDecryptionConfiguration\
-            " parquet::encryption::DecryptionConfiguration":
-        CDecryptionConfiguration() except +
-        double cache_lifetime_seconds
-
-    cdef cppclass CCryptoFactory" parquet::encryption::CryptoFactory":
-        void RegisterKmsClientFactory(
-            shared_ptr[CKmsClientFactory] kms_client_factory) except +
-        shared_ptr[CFileEncryptionProperties] GetFileEncryptionProperties(
-            const CKmsConnectionConfig& kms_connection_config,
-            const CEncryptionConfiguration& encryption_config) except +*
-        shared_ptr[CFileDecryptionProperties] GetFileDecryptionProperties(
-            const CKmsConnectionConfig& kms_connection_config,
-            const CDecryptionConfiguration& decryption_config) except +*
-        void RemoveCacheEntriesForToken(const c_string& access_token) except +
-        void RemoveCacheEntriesForAllTokens() except +
-
-cdef extern from "arrow/python/parquet_encryption.h" \
-        namespace "arrow::py::parquet::encryption" nogil:
-    cdef cppclass CPyKmsClientVtable \
-            " arrow::py::parquet::encryption::PyKmsClientVtable":
-        CPyKmsClientVtable()
-        function[CallbackWrapKey] wrap_key
-        function[CallbackUnwrapKey] unwrap_key
-
-    cdef cppclass CPyKmsClient\
-            " arrow::py::parquet::encryption::PyKmsClient"(CKmsClient):
-        CPyKmsClient(object handler, CPyKmsClientVtable vtable)
-
-    cdef cppclass CPyKmsClientFactoryVtable\
-            " arrow::py::parquet::encryption::PyKmsClientFactoryVtable":
-        CPyKmsClientFactoryVtable()
-        function[CallbackCreateKmsClient] create_kms_client
-
-    cdef cppclass CPyKmsClientFactory\
-            " arrow::py::parquet::encryption::PyKmsClientFactory"(
-                CKmsClientFactory):
-        CPyKmsClientFactory(object handler, CPyKmsClientFactoryVtable vtable)
-
-    cdef cppclass CPyCryptoFactory\
-            " arrow::py::parquet::encryption::PyCryptoFactory"(CCryptoFactory):
-        CResult[shared_ptr[CFileEncryptionProperties]] \
-            SafeGetFileEncryptionProperties(
-            const CKmsConnectionConfig& kms_connection_config,
-            const CEncryptionConfiguration& encryption_config)
-        CResult[shared_ptr[CFileDecryptionProperties]] \
-            SafeGetFileDecryptionProperties(
-            const CKmsConnectionConfig& kms_connection_config,
-            const CDecryptionConfiguration& decryption_config)
+cdef shared_ptr[CCryptoFactory] pyarrow_unwrap_cryptofactory(object crypto_factory) except *
+cdef shared_ptr[CKmsConnectionConfig] pyarrow_unwrap_kmsconnectionconfig(object kmsconnectionconfig) except *
+cdef shared_ptr[CEncryptionConfiguration] pyarrow_unwrap_encryptionconfig(object encryptionconfig) except *
+cdef shared_ptr[CDecryptionConfiguration] pyarrow_unwrap_decryptionconfig(object decryptionconfig) except *
diff --git a/python/pyarrow/_parquet_encryption.pyx b/python/pyarrow/_parquet_encryption.pyx
index db29a022118dd..d0a9a6612328c 100644
--- a/python/pyarrow/_parquet_encryption.pyx
+++ b/python/pyarrow/_parquet_encryption.pyx
@@ -21,10 +21,10 @@
 from datetime import timedelta
 
 from cython.operator cimport dereference as deref
+from libcpp.memory cimport shared_ptr
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
 from pyarrow.lib cimport _Weakrefable
-
 from pyarrow.lib import tobytes, frombytes
 
 
@@ -48,9 +48,6 @@ cdef cipher_to_name(ParquetCipher cipher):
 
 cdef class EncryptionConfiguration(_Weakrefable):
     """Configuration of the encryption, such as which columns to encrypt"""
-    cdef:
-        shared_ptr[CEncryptionConfiguration] configuration
-
     # Avoid mistakingly creating attributes
     __slots__ = ()
 
@@ -180,9 +177,6 @@ cdef class EncryptionConfiguration(_Weakrefable):
 
 cdef class DecryptionConfiguration(_Weakrefable):
     """Configuration of the decryption, such as cache timeout."""
-    cdef:
-        shared_ptr[CDecryptionConfiguration] configuration
-
     # Avoid mistakingly creating attributes
     __slots__ = ()
 
@@ -206,9 +200,6 @@ cdef class DecryptionConfiguration(_Weakrefable):
 
 cdef class KmsConnectionConfig(_Weakrefable):
     """Configuration of the connection to the Key Management Service (KMS)"""
-    cdef:
-        shared_ptr[CKmsConnectionConfig] configuration
-
     # Avoid mistakingly creating attributes
     __slots__ = ()
 
@@ -358,9 +349,6 @@ cdef void _cb_create_kms_client(
 cdef class CryptoFactory(_Weakrefable):
     """ A factory that produces the low-level FileEncryptionProperties and
     FileDecryptionProperties objects, from the high-level parameters."""
-    cdef:
-        unique_ptr[CPyCryptoFactory] factory
-
     # Avoid mistakingly creating attributes
     __slots__ = ()
 
@@ -466,3 +454,31 @@ cdef class CryptoFactory(_Weakrefable):
 
     def remove_cache_entries_for_all_tokens(self):
         self.factory.get().RemoveCacheEntriesForAllTokens()
+
+    cdef inline shared_ptr[CPyCryptoFactory] unwrap(self):
+        return self.factory
+
+
+cdef shared_ptr[CCryptoFactory] pyarrow_unwrap_cryptofactory(object crypto_factory) except *:
+    if isinstance(crypto_factory, CryptoFactory):
+        pycf = (<CryptoFactory> crypto_factory).unwrap()
+        return static_pointer_cast[CCryptoFactory, CPyCryptoFactory](pycf)
+    raise TypeError("Expected CryptoFactory, got %s" % type(crypto_factory))
+
+
+cdef shared_ptr[CKmsConnectionConfig] pyarrow_unwrap_kmsconnectionconfig(object kmsconnectionconfig) except *:
+    if isinstance(kmsconnectionconfig, KmsConnectionConfig):
+        return (<KmsConnectionConfig> kmsconnectionconfig).unwrap()
+    raise TypeError("Expected KmsConnectionConfig, got %s" % type(kmsconnectionconfig))
+
+
+cdef shared_ptr[CEncryptionConfiguration] pyarrow_unwrap_encryptionconfig(object encryptionconfig) except *:
+    if isinstance(encryptionconfig, EncryptionConfiguration):
+        return (<EncryptionConfiguration> encryptionconfig).unwrap()
+    raise TypeError("Expected EncryptionConfiguration, got %s" % type(encryptionconfig))
+
+
+cdef shared_ptr[CDecryptionConfiguration] pyarrow_unwrap_decryptionconfig(object decryptionconfig) except *:
+    if isinstance(decryptionconfig, DecryptionConfiguration):
+        return (<DecryptionConfiguration> decryptionconfig).unwrap()
+    raise TypeError("Expected DecryptionConfiguration, got %s" % type(decryptionconfig))
diff --git a/python/pyarrow/dataset.py b/python/pyarrow/dataset.py
index 435137c7f2993..adf21814a2c99 100644
--- a/python/pyarrow/dataset.py
+++ b/python/pyarrow/dataset.py
@@ -97,6 +97,15 @@
     pass
 
 
+try:
+    from pyarrow._dataset_parquet_encryption import (  # noqa
+        ParquetDecryptionConfig,
+        ParquetEncryptionConfig,
+    )
+except ImportError:
+    pass
+
+
 def __getattr__(name):
     if name == "OrcFileFormat" and not _orc_available:
         raise ImportError(_orc_msg)
diff --git a/python/pyarrow/includes/libarrow_dataset_parquet.pxd b/python/pyarrow/includes/libarrow_dataset_parquet.pxd
index cc753d66a94f7..e5389b3135faf 100644
--- a/python/pyarrow/includes/libarrow_dataset_parquet.pxd
+++ b/python/pyarrow/includes/libarrow_dataset_parquet.pxd
@@ -18,9 +18,23 @@
 # distutils: language = c++
 
 from pyarrow.includes.libarrow_dataset cimport *
+from pyarrow.includes.libparquet_encryption cimport *
+
 from pyarrow._parquet cimport *
 
 
+cdef extern from "arrow/dataset/parquet_encryption_config.h" namespace "arrow::dataset" nogil:
+    cdef cppclass CParquetEncryptionConfig "arrow::dataset::ParquetEncryptionConfig":
+        shared_ptr[CCryptoFactory] crypto_factory
+        shared_ptr[CKmsConnectionConfig] kms_connection_config
+        shared_ptr[CEncryptionConfiguration] encryption_config
+
+    cdef cppclass CParquetDecryptionConfig "arrow::dataset::ParquetDecryptionConfig":
+        shared_ptr[CCryptoFactory] crypto_factory
+        shared_ptr[CKmsConnectionConfig] kms_connection_config
+        shared_ptr[CDecryptionConfiguration] decryption_config
+
+
 cdef extern from "arrow/dataset/api.h" namespace "arrow::dataset" nogil:
 
     cdef cppclass CParquetFileWriter \
@@ -31,6 +45,7 @@ cdef extern from "arrow/dataset/api.h" namespace "arrow::dataset" nogil:
             "arrow::dataset::ParquetFileWriteOptions"(CFileWriteOptions):
         shared_ptr[WriterProperties] writer_properties
         shared_ptr[ArrowWriterProperties] arrow_writer_properties
+        shared_ptr[CParquetEncryptionConfig] parquet_encryption_config
 
     cdef cppclass CParquetFileFragment "arrow::dataset::ParquetFileFragment"(
             CFileFragment):
@@ -62,6 +77,7 @@ cdef extern from "arrow/dataset/api.h" namespace "arrow::dataset" nogil:
             "arrow::dataset::ParquetFragmentScanOptions"(CFragmentScanOptions):
         shared_ptr[CReaderProperties] reader_properties
         shared_ptr[ArrowReaderProperties] arrow_reader_properties
+        shared_ptr[CParquetDecryptionConfig] parquet_decryption_config
 
     cdef cppclass CParquetFactoryOptions \
             "arrow::dataset::ParquetFactoryOptions":
diff --git a/python/pyarrow/includes/libparquet_encryption.pxd b/python/pyarrow/includes/libparquet_encryption.pxd
new file mode 100644
index 0000000000000..2b40414ce5383
--- /dev/null
+++ b/python/pyarrow/includes/libparquet_encryption.pxd
@@ -0,0 +1,130 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# distutils: language = c++
+
+from pyarrow.includes.common cimport *
+from pyarrow._parquet cimport (ParquetCipher,
+                               CFileEncryptionProperties,
+                               CFileDecryptionProperties,
+                               ParquetCipher_AES_GCM_V1,
+                               ParquetCipher_AES_GCM_CTR_V1)
+
+
+cdef extern from "parquet/encryption/kms_client.h" \
+        namespace "parquet::encryption" nogil:
+    cdef cppclass CKmsClient" parquet::encryption::KmsClient":
+        c_string WrapKey(const c_string& key_bytes,
+                         const c_string& master_key_identifier) except +
+        c_string UnwrapKey(const c_string& wrapped_key,
+                           const c_string& master_key_identifier) except +
+
+    cdef cppclass CKeyAccessToken" parquet::encryption::KeyAccessToken":
+        CKeyAccessToken(const c_string value)
+        void Refresh(const c_string& new_value)
+        const c_string& value() const
+
+    cdef cppclass CKmsConnectionConfig \
+            " parquet::encryption::KmsConnectionConfig":
+        CKmsConnectionConfig()
+        c_string kms_instance_id
+        c_string kms_instance_url
+        shared_ptr[CKeyAccessToken] refreshable_key_access_token
+        unordered_map[c_string, c_string] custom_kms_conf
+
+# Callbacks for implementing Python kms clients
+# Use typedef to emulate syntax for std::function<void(..)>
+ctypedef void CallbackWrapKey(
+    object, const c_string&, const c_string&, c_string*)
+ctypedef void CallbackUnwrapKey(
+    object, const c_string&, const c_string&, c_string*)
+
+cdef extern from "parquet/encryption/kms_client_factory.h" \
+        namespace "parquet::encryption" nogil:
+    cdef cppclass CKmsClientFactory" parquet::encryption::KmsClientFactory":
+        shared_ptr[CKmsClient] CreateKmsClient(
+            const CKmsConnectionConfig& kms_connection_config) except +
+
+# Callbacks for implementing Python kms client factories
+# Use typedef to emulate syntax for std::function<void(..)>
+ctypedef void CallbackCreateKmsClient(
+    object,
+    const CKmsConnectionConfig&, shared_ptr[CKmsClient]*)
+
+cdef extern from "parquet/encryption/crypto_factory.h" \
+        namespace "parquet::encryption" nogil:
+    cdef cppclass CEncryptionConfiguration\
+            " parquet::encryption::EncryptionConfiguration":
+        CEncryptionConfiguration(const c_string& footer_key) except +
+        c_string footer_key
+        c_string column_keys
+        ParquetCipher encryption_algorithm
+        c_bool plaintext_footer
+        c_bool double_wrapping
+        double cache_lifetime_seconds
+        c_bool internal_key_material
+        int32_t data_key_length_bits
+
+    cdef cppclass CDecryptionConfiguration\
+            " parquet::encryption::DecryptionConfiguration":
+        CDecryptionConfiguration() except +
+        double cache_lifetime_seconds
+
+    cdef cppclass CCryptoFactory" parquet::encryption::CryptoFactory":
+        void RegisterKmsClientFactory(
+            shared_ptr[CKmsClientFactory] kms_client_factory) except +
+        shared_ptr[CFileEncryptionProperties] GetFileEncryptionProperties(
+            const CKmsConnectionConfig& kms_connection_config,
+            const CEncryptionConfiguration& encryption_config) except +*
+        shared_ptr[CFileDecryptionProperties] GetFileDecryptionProperties(
+            const CKmsConnectionConfig& kms_connection_config,
+            const CDecryptionConfiguration& decryption_config) except +*
+        void RemoveCacheEntriesForToken(const c_string& access_token) except +
+        void RemoveCacheEntriesForAllTokens() except +
+
+cdef extern from "arrow/python/parquet_encryption.h" \
+        namespace "arrow::py::parquet::encryption" nogil:
+    cdef cppclass CPyKmsClientVtable \
+            " arrow::py::parquet::encryption::PyKmsClientVtable":
+        CPyKmsClientVtable()
+        function[CallbackWrapKey] wrap_key
+        function[CallbackUnwrapKey] unwrap_key
+
+    cdef cppclass CPyKmsClient\
+            " arrow::py::parquet::encryption::PyKmsClient"(CKmsClient):
+        CPyKmsClient(object handler, CPyKmsClientVtable vtable)
+
+    cdef cppclass CPyKmsClientFactoryVtable\
+            " arrow::py::parquet::encryption::PyKmsClientFactoryVtable":
+        CPyKmsClientFactoryVtable()
+        function[CallbackCreateKmsClient] create_kms_client
+
+    cdef cppclass CPyKmsClientFactory\
+            " arrow::py::parquet::encryption::PyKmsClientFactory"(
+                CKmsClientFactory):
+        CPyKmsClientFactory(object handler, CPyKmsClientFactoryVtable vtable)
+
+    cdef cppclass CPyCryptoFactory\
+            " arrow::py::parquet::encryption::PyCryptoFactory"(CCryptoFactory):
+        CResult[shared_ptr[CFileEncryptionProperties]] \
+            SafeGetFileEncryptionProperties(
+            const CKmsConnectionConfig& kms_connection_config,
+            const CEncryptionConfiguration& encryption_config)
+        CResult[shared_ptr[CFileDecryptionProperties]] \
+            SafeGetFileDecryptionProperties(
+            const CKmsConnectionConfig& kms_connection_config,
+            const CDecryptionConfiguration& decryption_config)
diff --git a/python/pyarrow/tests/test_dataset_encryption.py b/python/pyarrow/tests/test_dataset_encryption.py
new file mode 100644
index 0000000000000..cf9c07a06b813
--- /dev/null
+++ b/python/pyarrow/tests/test_dataset_encryption.py
@@ -0,0 +1,148 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from datetime import timedelta
+import pyarrow.fs as fs
+import pyarrow as pa
+import pytest
+
+encryption_unavailable = False
+
+try:
+    import pyarrow.dataset as ds
+except ImportError:
+    ds = None
+
+try:
+    from pyarrow.tests.parquet.encryption import InMemoryKmsClient
+    import pyarrow.parquet.encryption as pe
+except ImportError:
+    encryption_unavailable = True
+
+FOOTER_KEY = b"0123456789112345"
+FOOTER_KEY_NAME = "footer_key"
+COL_KEY = b"1234567890123450"
+COL_KEY_NAME = "col_key"
+
+
+def create_sample_table():
+    return pa.table(
+        {
+            "year": [2020, 2022, 2021, 2022, 2019, 2021],
+            "n_legs": [2, 2, 4, 4, 5, 100],
+            "animal": [
+                "Flamingo",
+                "Parrot",
+                "Dog",
+                "Horse",
+                "Brittle stars",
+                "Centipede",
+            ],
+        }
+    )
+
+
+def create_encryption_config():
+    return pe.EncryptionConfiguration(
+        footer_key=FOOTER_KEY_NAME,
+        plaintext_footer=False,
+        column_keys={COL_KEY_NAME: ["n_legs", "animal"]},
+        encryption_algorithm="AES_GCM_V1",
+        # requires timedelta or an assertion is raised
+        cache_lifetime=timedelta(minutes=5.0),
+        data_key_length_bits=256,
+    )
+
+
+def create_decryption_config():
+    return pe.DecryptionConfiguration(cache_lifetime=300)
+
+
+def create_kms_connection_config():
+    return pe.KmsConnectionConfig(
+        custom_kms_conf={
+            FOOTER_KEY_NAME: FOOTER_KEY.decode("UTF-8"),
+            COL_KEY_NAME: COL_KEY.decode("UTF-8"),
+        }
+    )
+
+
+def kms_factory(kms_connection_configuration):
+    return InMemoryKmsClient(kms_connection_configuration)
+
+
+@pytest.mark.skipif(
+    encryption_unavailable, reason="Parquet Encryption is not currently enabled"
+)
+def test_dataset_encryption_decryption():
+    table = create_sample_table()
+
+    encryption_config = create_encryption_config()
+    decryption_config = create_decryption_config()
+    kms_connection_config = create_kms_connection_config()
+
+    crypto_factory = pe.CryptoFactory(kms_factory)
+    parquet_encryption_cfg = ds.ParquetEncryptionConfig(
+        crypto_factory, kms_connection_config, encryption_config
+    )
+    parquet_decryption_cfg = ds.ParquetDecryptionConfig(
+        crypto_factory, kms_connection_config, decryption_config
+    )
+
+    # create write_options with dataset encryption config
+    pformat = pa.dataset.ParquetFileFormat()
+    write_options = pformat.make_write_options(encryption_config=parquet_encryption_cfg)
+
+    mockfs = fs._MockFileSystem()
+    mockfs.create_dir("/")
+
+    ds.write_dataset(
+        data=table,
+        base_dir="sample_dataset",
+        format=pformat,
+        file_options=write_options,
+        filesystem=mockfs,
+    )
+
+    # read without descryption config -> should error is dataset was properly encrypted
+    pformat = pa.dataset.ParquetFileFormat()
+    with pytest.raises(IOError, match=r"no decryption"):
+        ds.dataset("sample_dataset", format=pformat, filesystem=mockfs)
+
+    # set decryption config for parquet fragment scan options
+    pq_scan_opts = ds.ParquetFragmentScanOptions(
+        decryption_config=parquet_decryption_cfg
+    )
+    pformat = pa.dataset.ParquetFileFormat(default_fragment_scan_options=pq_scan_opts)
+    dataset = ds.dataset("sample_dataset", format=pformat, filesystem=mockfs)
+
+    assert table.equals(dataset.to_table())
+
+
+@pytest.mark.skipif(
+    not encryption_unavailable, reason="Parquet Encryption is currently enabled"
+)
+def test_write_dataset_parquet_without_encryption():
+    """Test write_dataset with ParquetFileFormat and test if an exception is thrown
+    if you try to set encryption_config using make_write_options"""
+
+    # Set the encryption configuration using ParquetFileFormat
+    # and make_write_options
+    pformat = pa.dataset.ParquetFileFormat()
+
+    with pytest.raises(NotImplementedError):
+        _ = pformat.make_write_options(encryption_config="some value")

From e74d3a9de953c1bbf83e12ae26917a22bbd6ad86 Mon Sep 17 00:00:00 2001
From: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Date: Wed, 11 Oct 2023 09:44:11 -0400
Subject: [PATCH 525/749] GH-38153: [C#] expose
 ArrayDataConcatenator.Concatenate  (#38154)

### Rationale for this change

New C# drivers need the ability to concatenate array data, particularly for metadata calls.

### What changes are included in this PR?

Converts a previously internal class and method to a public class and method.

### Are these changes tested?

Yes

### Are there any user-facing changes?

It exposes previously hidden functionality.

Resolves https://github.com/apache/arrow/issues/38153
* Closes: #38153

Lead-authored-by: David Coe <coedavid@umich.edu>
Co-authored-by: davidhcoe <13318837+davidhcoe@users.noreply.github.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../Apache.Arrow/Arrays/ArrayDataConcatenator.cs |  4 ++--
 .../ArrayDataConcatenatorTests.cs                | 16 +++-------------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
index a3b39923809bb..463ca49e29c94 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataConcatenator.cs
@@ -20,9 +20,9 @@
 
 namespace Apache.Arrow
 {
-    static class ArrayDataConcatenator
+    public class ArrayDataConcatenator
     {
-        internal static ArrayData Concatenate(IReadOnlyList<ArrayData> arrayDataList, MemoryAllocator allocator = default)
+        public static ArrayData Concatenate(IReadOnlyList<ArrayData> arrayDataList, MemoryAllocator allocator = default)
         {
             if (arrayDataList == null || arrayDataList.Count == 0)
             {
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayDataConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrayDataConcatenatorTests.cs
index 9f034b9d0c955..86719f3bef6f4 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayDataConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayDataConcatenatorTests.cs
@@ -26,27 +26,17 @@ public class ArrayDataConcatenatorTests
         [Fact]
         public void TestNullOrEmpty()
         {
-            Assert.Null(ArrayDataConcatenatorReflector.InvokeConcatenate(null));
-            Assert.Null(ArrayDataConcatenatorReflector.InvokeConcatenate(new List<ArrayData>()));
+            Assert.Null(ArrayDataConcatenator.Concatenate(null));
+            Assert.Null(ArrayDataConcatenator.Concatenate(new List<ArrayData>()));
         }
 
         [Fact]
         public void TestSingleElement()
         {
             Int32Array array = new Int32Array.Builder().Append(1).Append(2).Build();
-            ArrayData actualArray = ArrayDataConcatenatorReflector.InvokeConcatenate(new[] { array.Data });
+            ArrayData actualArray = ArrayDataConcatenator.Concatenate(new[] { array.Data });
             ArrowReaderVerifier.CompareArrays(array, ArrowArrayFactory.BuildArray(actualArray));
         }
 
-        private static class ArrayDataConcatenatorReflector
-        {
-            private static readonly MethodInfo s_concatenateInfo = typeof(ArrayData).Assembly.GetType("Apache.Arrow.ArrayDataConcatenator")
-                .GetMethod("Concatenate", BindingFlags.Static | BindingFlags.NonPublic);
-
-            internal static ArrayData InvokeConcatenate(IReadOnlyList<ArrayData> arrayDataList, MemoryAllocator allocator = default)
-            {
-                return s_concatenateInfo.Invoke(null, new object[] { arrayDataList, allocator }) as ArrayData;
-            }
-        }
     }
 }

From 223739a5f235cc39c4ae89d041ff352e9cee5678 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Wed, 11 Oct 2023 09:56:15 -0400
Subject: [PATCH 526/749] GH-38164: [MATLAB] Rename `Length` property on
 `arrow.array.Array` and  `arrow.array.ChunkedArray` to `NumElements` (#38190)

### Rationale for this change

We would like to rename the `Length` property on `arrow.array.Array` (and `arrow.array.ChunkedArray`) to `NumElements` because MATLAB has a function called `length(A)`, which returns the length of the largest array dimension in `A`.
Because `arrow.array.Array` inherits from `matlab.mixin.Scalar`, it's size is always `1x1`, so the `length()` function always returns `1`. This may confuse users because the `Length` property of `arrow.array.Array` returns the number of elements within the array, which may not be `1`.

```matlab
>> array = arrow.array([1 2 3 4 5]);

% The length property returns the number of elements in the array
>> array.Length

ans =

  int64

   5

% The length method returns the length of the largest dimension
>> length(array)

ans =

     1
```

I suspect this inconsistency will confuse users, so we should rename the `Length` property to `NumElements`.

### What changes are included in this PR?

1. Renamed `Length` property on `arrow.array.Array` to `NumElements`
2. Renamed `Length` property on `arrow.array.ChunkedArray` to `NumElements`

### Are these changes tested?

Yes. I modified the existing `Length` test cases to now test the `NumElements` property.

### Are there any user-facing changes?

Yes. Please note this is a breaking change because `Length` is no longer a property on either `arrow.array.Array` or `arrow.array.ChunkedArray`. However, we have not yet cut an initial release of the MATLAB interface, so we don't expect this change should affect too many users at this point.

* Closes: #38164

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc |  4 +-
 .../src/cpp/arrow/matlab/array/proxy/array.h  |  2 +-
 .../arrow/matlab/array/proxy/chunked_array.cc |  8 +--
 .../arrow/matlab/array/proxy/chunked_array.h  |  2 +-
 matlab/src/matlab/+arrow/+array/Array.m       |  6 +-
 .../src/matlab/+arrow/+array/ChunkedArray.m   | 10 ++--
 matlab/src/matlab/+arrow/+array/StructArray.m |  2 +-
 .../+tabular/+internal/validateArrayLengths.m | 10 ++--
 matlab/test/arrow/array/hNumericArray.m       |  6 +-
 matlab/test/arrow/array/tBooleanArray.m       |  6 +-
 matlab/test/arrow/array/tChunkedArray.m       | 58 +++++++++----------
 matlab/test/arrow/array/tDate32Array.m        | 16 ++---
 matlab/test/arrow/array/tDate64Array.m        | 16 ++---
 matlab/test/arrow/array/tStringArray.m        |  6 +-
 matlab/test/arrow/array/tStructArray.m        | 19 +++---
 matlab/test/arrow/array/tTime32Array.m        | 18 +++---
 matlab/test/arrow/array/tTime64Array.m        | 18 +++---
 matlab/test/arrow/array/tTimestampArray.m     | 18 +++---
 matlab/test/arrow/tabular/tTable.m            | 52 ++++++++---------
 19 files changed, 138 insertions(+), 139 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index 5fa533632f928..bd8e9dc842513 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -31,7 +31,7 @@ namespace arrow::matlab::array::proxy {
 
         // Register Proxy methods.
         REGISTER_METHOD(Array, toString);
-        REGISTER_METHOD(Array, getLength);
+        REGISTER_METHOD(Array, getNumElements);
         REGISTER_METHOD(Array, getValid);
         REGISTER_METHOD(Array, getType);
         REGISTER_METHOD(Array, isEqual);
@@ -50,7 +50,7 @@ namespace arrow::matlab::array::proxy {
         context.outputs[0] = str_mda;
     }
 
-    void Array::getLength(libmexclass::proxy::method::Context& context) {
+    void Array::getNumElements(libmexclass::proxy::method::Context& context) {
         ::matlab::data::ArrayFactory factory;
         auto length_mda = factory.createScalar(array->length());
         context.outputs[0] = length_mda;
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index 46e1fa5a81380..0ab7b279bc92e 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -36,7 +36,7 @@ class Array : public libmexclass::proxy::Proxy {
 
         void toString(libmexclass::proxy::method::Context& context);
 
-        void getLength(libmexclass::proxy::method::Context& context);
+        void getNumElements(libmexclass::proxy::method::Context& context);
 
         void getValid(libmexclass::proxy::method::Context& context);
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
index 2b15fed675d18..dea824fd04c5b 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.cc
@@ -47,7 +47,7 @@ namespace arrow::matlab::array::proxy {
     ChunkedArray::ChunkedArray(std::shared_ptr<arrow::ChunkedArray> chunked_array) : chunked_array{std::move(chunked_array)} {
 
         // Register Proxy methods.
-        REGISTER_METHOD(ChunkedArray, getLength);
+        REGISTER_METHOD(ChunkedArray, getNumElements);
         REGISTER_METHOD(ChunkedArray, getNumChunks);
         REGISTER_METHOD(ChunkedArray, getChunk);
         REGISTER_METHOD(ChunkedArray, getType);
@@ -86,11 +86,11 @@ namespace arrow::matlab::array::proxy {
         return chunked_array;
     }
 
-    void ChunkedArray::getLength(libmexclass::proxy::method::Context& context) {
+    void ChunkedArray::getNumElements(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
-        auto length_mda = factory.createScalar(chunked_array->length());
-        context.outputs[0] = length_mda;
+        auto num_elements_mda = factory.createScalar(chunked_array->length());
+        context.outputs[0] = num_elements_mda;
     }
 
     void ChunkedArray::getNumChunks(libmexclass::proxy::method::Context& context) {
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
index ff47644182a89..74cc5d6859de4 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/chunked_array.h
@@ -35,7 +35,7 @@ class ChunkedArray : public libmexclass::proxy::Proxy {
 
     protected:
 
-        void getLength(libmexclass::proxy::method::Context& context);
+        void getNumElements(libmexclass::proxy::method::Context& context);
 
         void getNumChunks(libmexclass::proxy::method::Context& context);
 
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 436d5b80aa6a8..381e7349831d8 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -22,7 +22,7 @@
     end
 
     properties(Dependent, SetAccess=private, GetAccess=public)
-        Length
+        NumElements
         Valid % Validity bitmap
         Type(1, 1) arrow.type.Type
     end
@@ -35,8 +35,8 @@
             obj.Proxy = proxy;
         end
 
-        function numElements = get.Length(obj)
-            numElements = obj.Proxy.getLength();
+        function numElements = get.NumElements(obj)
+            numElements = obj.Proxy.getNumElements();
         end
 
         function validElements = get.Valid(obj)
diff --git a/matlab/src/matlab/+arrow/+array/ChunkedArray.m b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
index ede95323f4865..f0754bf391a30 100644
--- a/matlab/src/matlab/+arrow/+array/ChunkedArray.m
+++ b/matlab/src/matlab/+arrow/+array/ChunkedArray.m
@@ -25,7 +25,7 @@
     properties(Dependent, SetAccess=private, GetAccess=public)
         Type
         NumChunks
-        Length
+        NumElements
     end
 
     methods
@@ -41,8 +41,8 @@
             numChunks = obj.Proxy.getNumChunks();
         end
 
-        function length = get.Length(obj)
-            length = obj.Proxy.getLength();
+        function numElements = get.NumElements(obj)
+            numElements = obj.Proxy.getNumElements();
         end
 
         function type = get.Type(obj)
@@ -61,11 +61,11 @@
         end
 
         function data = toMATLAB(obj)
-            data = preallocateMATLABArray(obj.Type,  obj.Length);
+            data = preallocateMATLABArray(obj.Type,  obj.NumElements);
             startIndex = 1;
             for ii = 1:obj.NumChunks
                 chunk = obj.chunk(ii);
-                endIndex = startIndex + chunk.Length - 1;
+                endIndex = startIndex + chunk.NumElements - 1;
                 % Use 2D indexing to support tabular MATLAB types.
                 data(startIndex:endIndex, :) = toMATLAB(chunk);
                 startIndex = endIndex + 1;
diff --git a/matlab/src/matlab/+arrow/+array/StructArray.m b/matlab/src/matlab/+arrow/+array/StructArray.m
index 800e34fe746ec..a92243faaadd1 100644
--- a/matlab/src/matlab/+arrow/+array/StructArray.m
+++ b/matlab/src/matlab/+arrow/+array/StructArray.m
@@ -133,7 +133,7 @@
 
             validateArrayLengths(arrowArrays);
             validateColumnNames(opts.FieldNames, numel(arrowArrays));
-            validElements = parseValid(opts, arrowArrays{1}.Length);
+            validElements = parseValid(opts, arrowArrays{1}.NumElements);
 
             arrayProxyIDs = getArrayProxyIDs(arrowArrays);
             args = struct(ArrayProxyIDs=arrayProxyIDs, ...
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m b/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
index d891f12a64871..968b0132abe5a 100644
--- a/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/validateArrayLengths.m
@@ -24,14 +24,14 @@ function validateArrayLengths(arrowArrays)
         return;
     end
 
-    expectedLength = arrowArrays{1}.Length;
+    expectedNumElements = arrowArrays{1}.NumElements;
 
     for ii = 2:numel(arrowArrays)
-        if arrowArrays{ii}.Length ~= expectedLength
+        if arrowArrays{ii}.NumElements ~= expectedNumElements
             errid = "arrow:tabular:UnequalArrayLengths";
-            msg = compose("Expected all arrays to have a length of %d," + ...
-                " but the array at position %d has a length of %d.", ...
-                expectedLength, ii, arrowArrays{ii}.Length);
+            msg = compose("Expected all arrays to have %d elements," + ...
+                " but the array at position %d has %d elements.", ...
+                    expectedNumElements, ii, arrowArrays{ii}.NumElements);
             error(errid, msg);
         end
     end
diff --git a/matlab/test/arrow/array/hNumericArray.m b/matlab/test/arrow/array/hNumericArray.m
index 2780ae5668ad0..29e2ab5f2abdc 100644
--- a/matlab/test/arrow/array/hNumericArray.m
+++ b/matlab/test/arrow/array/hNumericArray.m
@@ -105,7 +105,7 @@ function ErrorIfNonVector(tc)
         function AllowNDimensionalEmptyArray(tc)
             data = tc.MatlabArrayFcn(reshape([], [1 0 0]));
             A = tc.ArrowArrayConstructorFcn(data);
-            tc.verifyEqual(A.Length, int64(0));
+            tc.verifyEqual(A.NumElements, int64(0));
             tc.verifyEqual(toMATLAB(A), tc.MatlabArrayFcn(reshape([], [0 1])));
         end
 
@@ -154,7 +154,7 @@ function TestIsEqualTrue(tc)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
 
@@ -191,7 +191,7 @@ function TestIsEqualFalse(tc)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tBooleanArray.m b/matlab/test/arrow/array/tBooleanArray.m
index 0a488039a0ab7..5f192a761213a 100644
--- a/matlab/test/arrow/array/tBooleanArray.m
+++ b/matlab/test/arrow/array/tBooleanArray.m
@@ -142,7 +142,7 @@ function ErrorIfNonVector(tc)
         function AllowNDimensionalEmptyArray(tc)
             data = tc.MatlabArrayFcn(reshape([], [1 0 0]));
             A = tc.ArrowArrayConstructorFcn(data);
-            tc.verifyEqual(A.Length, int64(0));
+            tc.verifyEqual(A.NumElements, int64(0));
             tc.verifyEqual(toMATLAB(A), tc.MatlabArrayFcn(reshape([], [0 1])));
         end
 
@@ -163,7 +163,7 @@ function TestIsEqualTrue(tc)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
 
@@ -202,7 +202,7 @@ function TestIsEqualFalse(tc)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tChunkedArray.m b/matlab/test/arrow/array/tChunkedArray.m
index 3c7a52501f181..cf11412ebb36b 100644
--- a/matlab/test/arrow/array/tChunkedArray.m
+++ b/matlab/test/arrow/array/tChunkedArray.m
@@ -112,7 +112,7 @@ function TestIsEqualTrue(testCase)
             % Verifies ChunkedArrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. Their Length properties ar eequal
+            %  2. Their NumElements properties ar eequal
             %  3. The same elements are considered null
             %  4. All corresponding valid elements have the same values
             %
@@ -156,7 +156,7 @@ function TestIsEqualFalse(testCase)
             % Compare ChunkedArrays that have NaN values.
             testCase.verifyFalse(isequal(chunkedArray2, chunkedArray2));
 
-            % Compare ChunkedArrays with different Length values.
+            % Compare ChunkedArrays with different NumElements values.
             chunkedArray3 = ChunkedArray.fromArrays(testCase.Float64Array1);
             testCase.verifyFalse(isequal(chunkedArray1, chunkedArray3));
 
@@ -192,15 +192,15 @@ function TypeNoSetter(testCase)
             testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
         end
 
-        function LengthNoSetter(testCase)
+        function NumElementsNoSetter(testCase)
             % Verify an error is thrown when trying to set the value
-            % of the Length property.
+            % of the NumElements property.
             import arrow.array.ChunkedArray
 
             arrays = {testCase.Float64Array1, testCase.Float64Array2, testCase.Float64Array3};
             chunkedArray = ChunkedArray.fromArrays(arrays{:});
             
-            fcn = @() setfield(chunkedArray, "Length", int64(100));
+            fcn = @() setfield(chunkedArray, "NumElements", int64(100));
             testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
         end
 
@@ -267,19 +267,19 @@ function ToMATLABBooleanType(testCase)
             a2 = arrow.array(bools(8:7));
             a3 = arrow.array(bools(9:11));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = bools';
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = logical.empty(0, 1);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = logical.empty(0, 1);
@@ -295,19 +295,19 @@ function ToMATLABIntegerTypes(testCase, IntegerMatlabClass)
             a2 = arrow.array(cast([], IntegerMatlabClass));
             a3 = arrow.array(cast([5 6 7 8 9], IntegerMatlabClass));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = cast((1:9)', IntegerMatlabClass);
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = cast(double.empty(0, 1), IntegerMatlabClass);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = cast(double.empty(0, 1), IntegerMatlabClass);
@@ -323,20 +323,20 @@ function ToMATLABFloatTypes(testCase, FloatMatlabClass)
             a2 = arrow.array(cast([], FloatMatlabClass));
             a3 = arrow.array(cast([5 6 7 NaN 9], FloatMatlabClass));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = cast((1:9)', FloatMatlabClass);
             expectedArray1([2 8]) = NaN;
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = cast(double.empty(0, 1), FloatMatlabClass);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = cast(double.empty(0, 1), FloatMatlabClass);
@@ -352,20 +352,20 @@ function ToMATLABTimeTypes(testCase)
             a2 = arrow.array(seconds([]));
             a3 = arrow.array(seconds([5 6 7 NaN 9]));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = seconds((1:9)');
             expectedArray1([2 8]) = NaN;
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = duration.empty(0, 1);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = duration.empty(0, 1);
@@ -383,19 +383,19 @@ function ToMATLABDateTypes(testCase)
             a2 = Date64Array.fromMATLAB(dates(6:5));
             a3 = Date64Array.fromMATLAB(dates(6:end));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = dates';
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = datetime.empty(0, 1);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = datetime.empty(0, 1);
@@ -413,20 +413,20 @@ function ToMATLABTimestampType(testCase, TimeZone)
             a2 = arrow.array(dates(6:5));
             a3 = arrow.array(dates(6:end));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and at least one element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = dates';
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = datetime.empty(0, 1);
             expectedArray2.TimeZone = TimeZone;
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = datetime.empty(0, 1);
@@ -445,19 +445,19 @@ function ToMATLABStringType(testCase)
             a2 = arrow.array(strs(7:6));
             a3 = arrow.array(strs(8:11));
 
-            % ChunkedArray with three chunks and nonzero length
+            % ChunkedArray with three chunks and nonzero at least 1 element
             chunkedArray1 = ChunkedArray.fromArrays(a1, a2, a3);
             actualArray1 = toMATLAB(chunkedArray1);
             expectedArray1 = strs';
             testCase.verifyEqual(actualArray1, expectedArray1);
 
-            % ChunkedArray with zero chunks and zero length
+            % ChunkedArray with zero chunks and zero elements
             chunkedArray2 = ChunkedArray.fromArrays(Type=a1.Type);
             actualArray2 = toMATLAB(chunkedArray2);
             expectedArray2 = string.empty(0, 1);
             testCase.verifyEqual(actualArray2, expectedArray2);
 
-            % ChunkedArray with two chunks and zero length
+            % ChunkedArray with two chunks and zero elements
             chunkedArray3 = ChunkedArray.fromArrays(a2, a2);
             actualArray3 = toMATLAB(chunkedArray3);
             expectedArray3 = string.empty(0, 1);
@@ -475,11 +475,11 @@ function verifyChunkedArray(testCase, chunkedArray, opts)
                 opts.Arrays(1, :) cell
             end
             testCase.assertTrue(numel(opts.Arrays) == opts.NumChunks); 
-            allLengths = cellfun(@(a) a.Length, opts.Arrays, UniformOutput=true);
-            expectedLengths = int64(sum(allLengths));
+            allNumElements = cellfun(@(a) a.NumElements, opts.Arrays, UniformOutput=true);
+            expectedNumElements = int64(sum(allNumElements));
 
             testCase.verifyEqual(chunkedArray.NumChunks, opts.NumChunks);
-            testCase.verifyEqual(chunkedArray.Length, expectedLengths);
+            testCase.verifyEqual(chunkedArray.NumElements, expectedNumElements);
             testCase.verifyEqual(chunkedArray.Type, opts.Type);
 
             for ii = 1:opts.NumChunks
diff --git a/matlab/test/arrow/array/tDate32Array.m b/matlab/test/arrow/array/tDate32Array.m
index d7289c1df857e..e696efdb63e0c 100644
--- a/matlab/test/arrow/array/tDate32Array.m
+++ b/matlab/test/arrow/array/tDate32Array.m
@@ -40,18 +40,18 @@ function TestTypeIsDate32(testCase)
             testCase.verifyDate32Type(array.Type);
         end
 
-        function TestLength(testCase)
+        function TestNumElements(testCase)
             dates = datetime.empty(0, 1);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
 
             dates = datetime(2023, 1, 1);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(1));
+            testCase.verifyEqual(array.NumElements, int64(1));
 
             dates = testCase.UnixEpoch + days(1:10);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(10));
+            testCase.verifyEqual(array.NumElements, int64(10));
         end
 
         function TestToMATLAB(testCase)
@@ -132,14 +132,14 @@ function TestEmptyDatetimeVector(testCase)
 
             dates = datetime.empty(0, 0);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
 
             % Test with an N-Dimensional empty array
             dates = datetime.empty(0, 1, 0);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
         end
@@ -284,7 +284,7 @@ function TestIsEqualTrue(tc)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
 
@@ -323,7 +323,7 @@ function TestIsEqualFalse(tc)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tDate64Array.m b/matlab/test/arrow/array/tDate64Array.m
index 57eb3b0ca7d95..124bae50a97d7 100644
--- a/matlab/test/arrow/array/tDate64Array.m
+++ b/matlab/test/arrow/array/tDate64Array.m
@@ -40,18 +40,18 @@ function TestTypeIsDate64(testCase)
             testCase.verifyDate64Type(array.Type);
         end
 
-        function TestLength(testCase)
+        function TestNumElements(testCase)
             dates = datetime.empty(0, 1);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
 
             dates = datetime(2023, 1, 1);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(1));
+            testCase.verifyEqual(array.NumElements, int64(1));
 
             dates = testCase.UnixEpoch + days(1:10);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(10));
+            testCase.verifyEqual(array.NumElements, int64(10));
         end
 
         function TestToMATLAB(testCase)
@@ -132,14 +132,14 @@ function TestEmptyDatetimeVector(testCase)
 
             dates = datetime.empty(0, 0);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
 
             % Test with an N-Dimensional empty array
             dates = datetime.empty(0, 1, 0);
             array = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), datetime.empty(0, 1));
         end
@@ -253,7 +253,7 @@ function TestIsEqualTrue(tc)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
 
@@ -291,7 +291,7 @@ function TestIsEqualFalse(tc)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tStringArray.m b/matlab/test/arrow/array/tStringArray.m
index f042a21ff87af..5933b5a52228b 100644
--- a/matlab/test/arrow/array/tStringArray.m
+++ b/matlab/test/arrow/array/tStringArray.m
@@ -142,7 +142,7 @@ function ErrorIfNonVector(tc)
         function AllowNDimensionalEmptyArray(tc)
             data = tc.MatlabArrayFcn(reshape(string.empty(0, 0), [1 0 0]));
             arrowArray = tc.ArrowArrayConstructorFcn(data);
-            tc.verifyEqual(arrowArray.Length, int64(0));
+            tc.verifyEqual(arrowArray.NumElements, int64(0));
             tc.verifyEqual(toMATLAB(arrowArray), string.empty(0, 1));
         end
 
@@ -233,7 +233,7 @@ function TestIsEqualTrue(tc)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
             
@@ -270,7 +270,7 @@ function TestIsEqualFalse(tc)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tStructArray.m b/matlab/test/arrow/array/tStructArray.m
index 83e902ee2fa23..5dd153d3223d5 100644
--- a/matlab/test/arrow/array/tStructArray.m
+++ b/matlab/test/arrow/array/tStructArray.m
@@ -112,7 +112,6 @@ function ValidNVPairError(tc)
             tc.verifyError(fcn, "MATLAB:notLessEqual");
 
             % Provided a logical vector with more elements than the array
-            % length
             fcn = @() StructArray.fromArrays(tc.Float64Array, tc.StringArray, Valid=false([7 1]));
             tc.verifyError(fcn, "MATLAB:incorrectNumel");
          end
@@ -126,20 +125,20 @@ function ValidNoSetter(tc)
             tc.verifyError(fcn, "MATLAB:class:SetProhibited");
         end
 
-        function Length(tc)
-            % Verify the Length property is set to the expected value.
+        function NumElements(tc)
+            % Verify the NumElements property is set to the expected value.
             import arrow.array.StructArray
 
             array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
-            tc.verifyEqual(array.Length, int64(5));
+            tc.verifyEqual(array.NumElements, int64(5));
         end
 
-        function LengthNoSetter(tc)
-            % Verify the Length property is read-only.
+        function NumElementsNoSetter(tc)
+            % Verify the NumElements property is read-only.
             import arrow.array.StructArray
 
             array = StructArray.fromArrays(tc.Float64Array, tc.StringArray);
-            fcn = @() setfield(array, "Length", 1);
+            fcn = @() setfield(array, "NumElements", 1);
             tc.verifyError(fcn, "MATLAB:class:SetProhibited");
         end
 
@@ -280,7 +279,7 @@ function FromMATLABBasic(tc)
 
             T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
             array = StructArray.fromMATLAB(T);
-            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumElements, int64(2));
             tc.verifyEqual(array.NumFields, int32(2));
             tc.verifyEqual(array.FieldNames, ["Number" "String"]);
 
@@ -298,7 +297,7 @@ function FromMATLABFieldNames(tc)
 
             T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
             array = StructArray.fromMATLAB(T, FieldNames=["Custom" "Name"]);
-            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumElements, int64(2));
             tc.verifyEqual(array.NumFields, int32(2));
             tc.verifyEqual(array.FieldNames, ["Custom" "Name"]);
             tc.verifyEqual(array.Valid, [true; true]);
@@ -318,7 +317,7 @@ function FromMATLABValid(tc)
 
             T = table([1 2]', ["A1" "A2"]', VariableNames=["Number" "String"]);
             array = StructArray.fromMATLAB(T, Valid=2);
-            tc.verifyEqual(array.Length, int64(2));
+            tc.verifyEqual(array.NumElements, int64(2));
             tc.verifyEqual(array.NumFields, int32(2));
             tc.verifyEqual(array.FieldNames, ["Number" "String"]);
             tc.verifyEqual(array.Valid, [false; true]);
diff --git a/matlab/test/arrow/array/tTime32Array.m b/matlab/test/arrow/array/tTime32Array.m
index b593b2630c709..cc2fad64b2a28 100644
--- a/matlab/test/arrow/array/tTime32Array.m
+++ b/matlab/test/arrow/array/tTime32Array.m
@@ -73,20 +73,20 @@ function UnsupportedTimeUnitError(tc)
             tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime32TimeUnit");
         end
 
-        function TestLength(testCase)
-            % Verify the Length property.
+        function TestNumElements(testCase)
+            % Verify the NumElements property.
 
             times = duration.empty(0, 1);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
 
             times = duration(1, 2, 3);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(1));
+            testCase.verifyEqual(array.NumElements, int64(1));
 
             times = duration(1, 2, 3) + hours(0:4);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(5));
+            testCase.verifyEqual(array.NumElements, int64(5));
         end
 
         function TestToMATLAB(testCase, Unit)
@@ -170,14 +170,14 @@ function EmptyDurationVector(testCase)
 
             times = duration.empty(0, 0);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
 
             % Test with an N-Dimensional empty array
             times = duration.empty(0, 1, 0);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
         end
@@ -213,7 +213,7 @@ function TestIsEqualTrue(tc, Unit)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
 
@@ -252,7 +252,7 @@ function TestIsEqualFalse(tc, Unit)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tTime64Array.m b/matlab/test/arrow/array/tTime64Array.m
index ea4fec3da6c8f..a078c5e2173f3 100644
--- a/matlab/test/arrow/array/tTime64Array.m
+++ b/matlab/test/arrow/array/tTime64Array.m
@@ -73,20 +73,20 @@ function UnsupportedTimeUnitError(tc)
             tc.verifyError(fcn, "arrow:validate:temporal:UnsupportedTime64TimeUnit");
         end
 
-        function TestLength(testCase)
-            % Verify the Length property.
+        function TestNumElements(testCase)
+            % Verify the NumElements property.
 
             times = duration.empty(0, 1);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
 
             times = duration(1, 2, 3);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(1));
+            testCase.verifyEqual(array.NumElements, int64(1));
 
             times = duration(1, 2, 3) + hours(0:4);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(5));
+            testCase.verifyEqual(array.NumElements, int64(5));
         end
 
         function TestToMATLAB(testCase, Unit)
@@ -170,14 +170,14 @@ function EmptyDurationVector(testCase)
 
             times = duration.empty(0, 0);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
 
             % Test with an N-Dimensional empty array
             times = duration.empty(0, 1, 0);
             array = testCase.ArrowArrayConstructorFcn(times);
-            testCase.verifyEqual(array.Length, int64(0));
+            testCase.verifyEqual(array.NumElements, int64(0));
             testCase.verifyEqual(array.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(array), duration.empty(0, 1));
         end
@@ -229,7 +229,7 @@ function TestIsEqualTrue(tc, Unit)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
             
@@ -269,7 +269,7 @@ function TestIsEqualFalse(tc, Unit)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/array/tTimestampArray.m b/matlab/test/arrow/array/tTimestampArray.m
index cf273b3de2041..54af192f935a5 100644
--- a/matlab/test/arrow/array/tTimestampArray.m
+++ b/matlab/test/arrow/array/tTimestampArray.m
@@ -34,21 +34,21 @@ function Basic(tc, TimeZone)
             tc.verifyEqual(className, "arrow.array.TimestampArray");
         end
 
-        function TestLength(testCase, TimeZone)
-        % Verify the Length property.
+        function TestNumElements(testCase, TimeZone)
+        % Verify the NumElements property.
 
             dates = datetime.empty(0, 1);
             dates.TimeZone = TimeZone;
             arrowArray = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(arrowArray.Length, int64(0));
+            testCase.verifyEqual(arrowArray.NumElements, int64(0));
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone);
             arrowArray = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(arrowArray.Length, int64(1));
+            testCase.verifyEqual(arrowArray.NumElements, int64(1));
 
             dates = datetime(2023, 6, 22, TimeZone=TimeZone) + days(0:4);
             arrowArray = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(arrowArray.Length, int64(5));
+            testCase.verifyEqual(arrowArray.NumElements, int64(5));
         end
 
         function TestDefaultTimestampType(testCase, TimeZone)
@@ -169,14 +169,14 @@ function EmptyDatetimeVector(testCase)
 
             dates = datetime.empty(0, 0);
             arrowArray = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(arrowArray.Length, int64(0));
+            testCase.verifyEqual(arrowArray.NumElements, int64(0));
             testCase.verifyEqual(arrowArray.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(arrowArray), datetime.empty(0, 1));
 
             % test with NDimensional empty array
             dates = datetime.empty(0, 1, 0);
             arrowArray = testCase.ArrowArrayConstructorFcn(dates);
-            testCase.verifyEqual(arrowArray.Length, int64(0));
+            testCase.verifyEqual(arrowArray.NumElements, int64(0));
             testCase.verifyEqual(arrowArray.Valid, logical.empty(0, 1));
             testCase.verifyEqual(toMATLAB(arrowArray), datetime.empty(0, 1));
         end
@@ -185,7 +185,7 @@ function TestIsEqualTrue(tc, TimeZone)
             % Verifies arrays are considered equal if:
             %
             %  1. Their Type properties are equal
-            %  2. They have the same length (i.e. their Length properties are equal)
+            %  2. They have the same number of elements (i.e. their NumElements properties are equal)
             %  3. They have the same validity bitmap (i.e. their Valid properties are equal)
             %  4. All corresponding valid elements have the same values
             
@@ -224,7 +224,7 @@ function TestIsEqualFalse(tc, TimeZone)
             % Their Type properties are not equal
             tc.verifyFalse(isequal(array1, array4));
 
-            % Their Length properties are not equal
+            % Their NumElements properties are not equal
             tc.verifyFalse(isequal(array1, array5));
 
             % Comparing an arrow.array.Array to a MATLAB double
diff --git a/matlab/test/arrow/tabular/tTable.m b/matlab/test/arrow/tabular/tTable.m
index 7bb366a6043aa..ee3cc572f2af8 100644
--- a/matlab/test/arrow/tabular/tTable.m
+++ b/matlab/test/arrow/tabular/tTable.m
@@ -208,32 +208,32 @@ function GetColumnByName(testCase)
 
             column = arrowTable.column("A");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.float64();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray1, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             column = arrowTable.column("B");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.string();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray2, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             column = arrowTable.column("C");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.boolean();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray3, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
         end
 
@@ -257,12 +257,12 @@ function GetColumnByNameWithEmptyString(testCase)
 
             column = arrowTable.column("");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.string();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray2, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
         end
 
@@ -286,32 +286,32 @@ function GetColumnByNameWithWhitespace(testCase)
 
             column = arrowTable.column(" ");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.float64();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray1, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             column = arrowTable.column("  ");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.string();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray2, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             column = arrowTable.column("   ");
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.boolean();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray3, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
         end
 
@@ -392,58 +392,58 @@ function GetColumnByNameWithChar(testCase)
             name = char.empty(0, 0);
             column = arrowTable.column(name);
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.float64();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray1, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             name = char.empty(0, 1);
             column = arrowTable.column(name);
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.float64();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray1, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             name = char.empty(1, 0);
             column = arrowTable.column(name);
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.float64();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray1, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             % Should match the second column whose name is "B".
             name = 'B';
             column = arrowTable.column(name);
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.string();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray2, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
 
             % Should match the third column whose name is "123".
             name = '123';
             column = arrowTable.column(name);
             expectedNumChunks = int32(1);
-            expectedLength = int64(3);
+            expectedNumElements = int64(3);
             expectedArrowType = arrow.boolean();
             testCase.verifyChunkedArray(column, ...
                                         matlabArray3, ...
                                         expectedNumChunks, ...
-                                        expectedLength, ...
+                                        expectedNumElements, ...
                                         expectedArrowType);
         end
 
@@ -680,11 +680,11 @@ function verifyTable(testCase, arrowTable, expectedColumnNames, expectedArrayCla
             end
         end
 
-        function verifyChunkedArray(testCase, chunkedArray, expectedMatlabData, expectedNumChunks, expectedLength, expectedArrowType)
+        function verifyChunkedArray(testCase, chunkedArray, expectedMatlabData, expectedNumChunks, expectedNumElements, expectedArrowType)
             testCase.verifyInstanceOf(chunkedArray, "arrow.array.ChunkedArray");
             testCase.verifyEqual(toMATLAB(chunkedArray), expectedMatlabData);
             testCase.verifyEqual(chunkedArray.NumChunks, expectedNumChunks)
-            testCase.verifyEqual(chunkedArray.Length, expectedLength);
+            testCase.verifyEqual(chunkedArray.NumElements, expectedNumElements);
             testCase.verifyEqual(chunkedArray.Type, expectedArrowType);
         end
 

From a7fab04cdd45e59d7f3af11e1233bdcb835ff043 Mon Sep 17 00:00:00 2001
From: Rok Mihevc <rok@mihevc.org>
Date: Wed, 11 Oct 2023 16:18:04 +0200
Subject: [PATCH 527/749] GH-24868: [C++] Add a Tensor logical value type with
 varying dimensions, implemented using ExtensionType (#37166)

### Rationale for this change

For use cases where underlying datatype and number of dimensions in tensors are equal but not the actual shape we want to add a `VariableShapeTensorType`.
See https://github.com/apache/arrow/issues/24868 and https://github.com/huggingface/datasets/issues/5272

### What changes are included in this PR?

This introduces definition of `arrow.variable_shape_tensor` extension and it's C++ implementation and a Python wrapper.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

This introduces new extension type to the user.
* Closes: #24868

Lead-authored-by: Rok Mihevc <rok@mihevc.org>
Co-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/format/CanonicalExtensions.rst | 103 +++++++++++++++++++++
 1 file changed, 103 insertions(+)

diff --git a/docs/source/format/CanonicalExtensions.rst b/docs/source/format/CanonicalExtensions.rst
index 9f7948cbfe980..084b6e62895fd 100644
--- a/docs/source/format/CanonicalExtensions.rst
+++ b/docs/source/format/CanonicalExtensions.rst
@@ -148,6 +148,109 @@ Fixed shape tensor
   by this specification. Instead, this extension type lets one use fixed shape tensors
   as elements in a field of a RecordBatch or a Table.
 
+.. _variable_shape_tensor_extension:
+
+Variable shape tensor
+=====================
+
+* Extension name: `arrow.variable_shape_tensor`.
+
+* The storage type of the extension is: ``StructArray`` where struct
+  is composed of **data** and **shape** fields describing a single
+  tensor per row:
+
+  * **data** is a ``List`` holding tensor elements (each list element is
+    a single tensor). The List's value type is the value type of the tensor,
+    such as an integer or floating-point type.
+  * **shape** is a ``FixedSizeList<int32>[ndim]`` of the tensor shape where
+    the size of the list ``ndim`` is equal to the number of dimensions of the
+    tensor.
+
+* Extension type parameters:
+
+  * **value_type** = the Arrow data type of individual tensor elements.
+
+  Optional parameters describing the logical layout:
+
+  * **dim_names** = explicit names to tensor dimensions
+    as an array. The length of it should be equal to the shape
+    length and equal to the number of dimensions.
+
+    ``dim_names`` can be used if the dimensions have well-known
+    names and they map to the physical layout (row-major).
+
+  * **permutation**  = indices of the desired ordering of the
+    original dimensions, defined as an array.
+
+    The indices contain a permutation of the values [0, 1, .., N-1] where
+    N is the number of dimensions. The permutation indicates which
+    dimension of the logical layout corresponds to which dimension of the
+    physical tensor (the i-th dimension of the logical view corresponds
+    to the dimension with number ``permutations[i]`` of the physical tensor).
+
+    Permutation can be useful in case the logical order of
+    the tensor is a permutation of the physical order (row-major).
+
+    When logical and physical layout are equal, the permutation will always
+    be ([0, 1, .., N-1]) and can therefore be left out.
+
+  * **uniform_shape** = sizes of individual tensor's dimensions which are
+    guaranteed to stay constant in uniform dimensions and can vary in
+    non-uniform dimensions. This holds over all tensors in the array.
+    Sizes in uniform dimensions are represented with int32 values, while
+    sizes of the non-uniform dimensions are not known in advance and are
+    represented with null. If ``uniform_shape`` is not provided it is assumed
+    that all dimensions are non-uniform.
+    An array containing a tensor with shape (2, 3, 4) and whose first and
+    last dimensions are uniform would have ``uniform_shape`` (2, null, 4).
+    This allows for interpreting the tensor correctly without accounting for
+    uniform dimensions while still permitting optional optimizations that
+    take advantage of the uniformity.
+
+* Description of the serialization:
+
+  The metadata must be a valid JSON object that optionally includes
+  dimension names with keys **"dim_names"** and  ordering of dimensions
+  with key **"permutation"**.
+  Shapes of tensors can be defined in a subset of dimensions by providing
+  key **"uniform_shape"**.
+  Minimal metadata is an empty string.
+
+  - Example with ``dim_names`` metadata for NCHW ordered data (note that the first
+    logical dimension, ``N``, is mapped to the **data** List array: each element in the List
+    is a CHW tensor and the List of tensors implicitly constitutes a single NCHW tensor):
+
+    ``{ "dim_names": ["C", "H", "W"] }``
+
+  - Example with ``uniform_shape`` metadata for a set of color images
+    with fixed height, variable width and three color channels:
+
+    ``{ "dim_names": ["H", "W", "C"], "uniform_shape": [400, null, 3] }``
+
+  - Example of permuted 3-dimensional tensor:
+
+    ``{ "permutation": [2, 0, 1] }``
+
+    For example, if the physical **shape** of an individual tensor
+    is ``[100, 200, 500]``, this permutation would denote a logical shape
+    of ``[500, 100, 200]``.
+
+.. note::
+
+  With the exception of ``permutation``, the parameters and storage
+  of VariableShapeTensor relate to the *physical* storage of the tensor.
+
+  For example, consider a tensor with::
+    shape = [10, 20, 30]
+    dim_names = [x, y, z]
+    permutations = [2, 0, 1]
+
+  This means the logical tensor has names [z, x, y] and shape [30, 10, 20].
+
+.. note::
+   Values inside each **data** tensor element are stored in row-major/C-contiguous
+   order according to the corresponding **shape**.
+
 =========================
 Community Extension Types
 =========================

From 7695935a2ea7d59cbe3d8405a3beedb5721ce20a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 11 Oct 2023 16:33:18 +0200
Subject: [PATCH 528/749] GH-37880: [CI][Python][Packaging] Add support for
 Python 3.12 (#37901)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Python 3.12 will be released in the next couple of weeks. We should add the wheels for pyarrow on our 14.0.0 release.

### What changes are included in this PR?

This PR adds jobs to build pyarrow wheels for Python 3.12.

### Are these changes tested?

They will be tested via archery tasks

### Are there any user-facing changes?

No but users will be able to use pyarrow with Python 3.12

* Closes: #37880

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .github/workflows/cpp.yml                           |  8 ++++++++
 .github/workflows/java_jni.yml                      |  2 +-
 ci/docker/linux-apt-lint.dockerfile                 |  6 +-----
 .../python-wheel-windows-test-vs2017.dockerfile     |  5 +++--
 ci/docker/python-wheel-windows-vs2017.dockerfile    |  5 +++--
 ci/scripts/install_gcs_testbench.sh                 |  4 +++-
 ci/scripts/install_python.sh                        |  7 ++++---
 ci/vcpkg/ports.patch                                | 13 +++++++++++++
 dev/release/verify-release-candidate.sh             |  6 +++---
 dev/tasks/python-wheels/github.osx.arm64.yml        |  4 ++--
 dev/tasks/tasks.yml                                 |  7 ++++---
 docker-compose.yml                                  |  7 ++++---
 python/requirements-wheel-test.txt                  |  7 ++-----
 python/setup.py                                     |  1 +
 14 files changed, 52 insertions(+), 30 deletions(-)

diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index 5451cbe064b59..a9361f9f51378 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -204,6 +204,10 @@ jobs:
         run: |
           $(brew --prefix bash)/bin/bash \
             ci/scripts/install_minio.sh latest /usr/local
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.9
       - name: Install Google Cloud Storage Testbench
         run: ci/scripts/install_gcs_testbench.sh default
       - name: Install Azurite Storage Emulator
@@ -427,6 +431,10 @@ jobs:
             --output-document /usr/local/bin/minio.exe \
             https://dl.min.io/server/minio/release/windows-amd64/archive/minio.RELEASE.2022-05-26T05-48-41Z
           chmod +x /usr/local/bin/minio.exe
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.9
       - name: Install Google Cloud Storage Testbench
         shell: bash
         run: |
diff --git a/.github/workflows/java_jni.yml b/.github/workflows/java_jni.yml
index 4ebfccbe84c89..467e8a88af5d3 100644
--- a/.github/workflows/java_jni.yml
+++ b/.github/workflows/java_jni.yml
@@ -53,7 +53,7 @@ jobs:
     name: AMD64 manylinux2014 Java JNI
     runs-on: ubuntu-latest
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
-    timeout-minutes: 90
+    timeout-minutes: 500
     steps:
       - name: Checkout Arrow
         uses: actions/checkout@v4
diff --git a/ci/docker/linux-apt-lint.dockerfile b/ci/docker/linux-apt-lint.dockerfile
index 8a679be2ebc08..2b94a48871847 100644
--- a/ci/docker/linux-apt-lint.dockerfile
+++ b/ci/docker/linux-apt-lint.dockerfile
@@ -67,11 +67,7 @@ COPY ci/scripts/install_iwyu.sh /arrow/ci/scripts/
 RUN arrow/ci/scripts/install_iwyu.sh /tmp/iwyu /usr/local ${clang_tools}
 
 # Use python3 by default in scripts
-RUN ln -s /usr/bin/python3 /usr/local/bin/python && \
-    ln -s /usr/bin/pip3 /usr/local/bin/pip
-
-COPY dev/archery/setup.py /arrow/dev/archery/
-RUN pip install -e arrow/dev/archery[lint]
+RUN ln -s /usr/bin/python3 /usr/local/bin/python
 
 ENV LC_ALL=C.UTF-8 \
     LANG=C.UTF-8
diff --git a/ci/docker/python-wheel-windows-test-vs2017.dockerfile b/ci/docker/python-wheel-windows-test-vs2017.dockerfile
index 4aa5363ff7d62..e842ede18454b 100644
--- a/ci/docker/python-wheel-windows-test-vs2017.dockerfile
+++ b/ci/docker/python-wheel-windows-test-vs2017.dockerfile
@@ -37,7 +37,8 @@ RUN wmic product where "name like 'python%%'" call uninstall /nointeractive && \
 ARG python=3.8
 RUN (if "%python%"=="3.8" setx PYTHON_VERSION "3.8.10" && setx PATH "%PATH%;C:\Python38;C:\Python38\Scripts") & \
     (if "%python%"=="3.9" setx PYTHON_VERSION "3.9.13" && setx PATH "%PATH%;C:\Python39;C:\Python39\Scripts") & \
-    (if "%python%"=="3.10" setx PYTHON_VERSION "3.10.8" && setx PATH "%PATH%;C:\Python310;C:\Python310\Scripts") & \
-    (if "%python%"=="3.11" setx PYTHON_VERSION "3.11.0" && setx PATH "%PATH%;C:\Python311;C:\Python311\Scripts")
+    (if "%python%"=="3.10" setx PYTHON_VERSION "3.10.11" && setx PATH "%PATH%;C:\Python310;C:\Python310\Scripts") & \
+    (if "%python%"=="3.11" setx PYTHON_VERSION "3.11.5" && setx PATH "%PATH%;C:\Python311;C:\Python311\Scripts") & \
+    (if "%python%"=="3.12" setx PYTHON_VERSION "3.12.0" && setx PATH "%PATH%;C:\Python312;C:\Python312\Scripts")
 RUN choco install -r -y --no-progress python --version=%PYTHON_VERSION%
 RUN python -m pip install -U pip setuptools
diff --git a/ci/docker/python-wheel-windows-vs2017.dockerfile b/ci/docker/python-wheel-windows-vs2017.dockerfile
index 531c4e678fafe..b6a8125a5c4fc 100644
--- a/ci/docker/python-wheel-windows-vs2017.dockerfile
+++ b/ci/docker/python-wheel-windows-vs2017.dockerfile
@@ -81,8 +81,9 @@ RUN wmic product where "name like 'python%%'" call uninstall /nointeractive && \
 ARG python=3.8
 RUN (if "%python%"=="3.8" setx PYTHON_VERSION "3.8.10" && setx PATH "%PATH%;C:\Python38;C:\Python38\Scripts") & \
     (if "%python%"=="3.9" setx PYTHON_VERSION "3.9.13" && setx PATH "%PATH%;C:\Python39;C:\Python39\Scripts") & \
-    (if "%python%"=="3.10" setx PYTHON_VERSION "3.10.8" && setx PATH "%PATH%;C:\Python310;C:\Python310\Scripts") & \
-    (if "%python%"=="3.11" setx PYTHON_VERSION "3.11.0" && setx PATH "%PATH%;C:\Python311;C:\Python311\Scripts")
+    (if "%python%"=="3.10" setx PYTHON_VERSION "3.10.11" && setx PATH "%PATH%;C:\Python310;C:\Python310\Scripts") & \
+    (if "%python%"=="3.11" setx PYTHON_VERSION "3.11.5" && setx PATH "%PATH%;C:\Python311;C:\Python311\Scripts") & \
+    (if "%python%"=="3.12" setx PYTHON_VERSION "3.12.0" && setx PATH "%PATH%;C:\Python312;C:\Python312\Scripts")
 RUN choco install -r -y --no-progress python --version=%PYTHON_VERSION%
 RUN python -m pip install -U pip setuptools
 
diff --git a/ci/scripts/install_gcs_testbench.sh b/ci/scripts/install_gcs_testbench.sh
index 26fca3c946f8a..0aa6d20975b49 100755
--- a/ci/scripts/install_gcs_testbench.sh
+++ b/ci/scripts/install_gcs_testbench.sh
@@ -36,7 +36,9 @@ esac
 
 version=$1
 if [[ "${version}" -eq "default" ]]; then
-  version="v0.36.0"
+  version="v0.39.0"
+  # Latests versions of Testbench require newer setuptools
+  ${PYTHON:-python3} -m pip install --upgrade setuptools
 fi
 
 ${PYTHON:-python3} -m pip install \
diff --git a/ci/scripts/install_python.sh b/ci/scripts/install_python.sh
index 599c238c97803..8487090f7ad26 100755
--- a/ci/scripts/install_python.sh
+++ b/ci/scripts/install_python.sh
@@ -27,8 +27,9 @@ platforms=([windows]=Windows
 declare -A versions
 versions=([3.8]=3.8.10
           [3.9]=3.9.13
-          [3.10]=3.10.8
-          [3.11]=3.11.0)
+          [3.10]=3.10.11
+          [3.11]=3.11.5
+          [3.12]=3.12.0)
 
 if [ "$#" -ne 2 ]; then
   echo "Usage: $0 <platform> <version>"
@@ -45,7 +46,7 @@ full_version=${versions[$2]}
 if [ $platform = "MacOSX" ]; then
     echo "Downloading Python installer..."
 
-    if [ "$(uname -m)" = "arm64" ] || [ "$version" = "3.10" ] || [ "$version" = "3.11" ]; then
+    if [ "$(uname -m)" = "arm64" ] || [ "$version" = "3.10" ] || [ "$version" = "3.11" ] || [ "$version" = "3.12" ]; then
         fname="python-${full_version}-macos11.pkg"
     else
         fname="python-${full_version}-macosx10.9.pkg"
diff --git a/ci/vcpkg/ports.patch b/ci/vcpkg/ports.patch
index 45feb3ba0e1a1..68f6cae5addc9 100644
--- a/ci/vcpkg/ports.patch
+++ b/ci/vcpkg/ports.patch
@@ -51,3 +51,16 @@ index 0000000..a57ce0c
 + }
 + 
 + static inline bool LeftShiftOverflows(uint8_t value, uint32_t shift) {
+diff --git a/ports/llvm/portfile.cmake b/ports/llvm/portfile.cmake
+index 4d7e26a..1f054a2 100644
+--- a/ports/llvm/portfile.cmake
++++ b/ports/llvm/portfile.cmake
+@@ -274,6 +274,8 @@ vcpkg_cmake_configure(
+         COMPILER_RT_ENABLE_IOS
+         OPENMP_TOOLS_INSTALL_DIR
+         MLIR_TOOLS_INSTALL_DIR
++        BOLT_TOOLS_INSTALL_DIR
++        LIBOMP_INSTALL_ALIASES
+ )
+ 
+ vcpkg_cmake_install(ADD_BIN_TO_PATH)
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 2e5aa1c3936de..6397cd4c32450 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -1052,7 +1052,7 @@ test_linux_wheels() {
     local arch="x86_64"
   fi
 
-  local python_versions="${TEST_PYTHON_VERSIONS:-3.8 3.9 3.10 3.11}"
+  local python_versions="${TEST_PYTHON_VERSIONS:-3.8 3.9 3.10 3.11 3.12}"
   local platform_tags="${TEST_WHEEL_PLATFORM_TAGS:-manylinux_2_17_${arch}.manylinux2014_${arch} manylinux_2_28_${arch}}"
 
   for python in ${python_versions}; do
@@ -1074,11 +1074,11 @@ test_macos_wheels() {
 
   # apple silicon processor
   if [ "$(uname -m)" = "arm64" ]; then
-    local python_versions="3.8 3.9 3.10 3.11"
+    local python_versions="3.8 3.9 3.10 3.11 3.12"
     local platform_tags="macosx_11_0_arm64"
     local check_flight=OFF
   else
-    local python_versions="3.8 3.9 3.10 3.11"
+    local python_versions="3.8 3.9 3.10 3.11 3.12"
     local platform_tags="macosx_10_14_x86_64"
   fi
 
diff --git a/dev/tasks/python-wheels/github.osx.arm64.yml b/dev/tasks/python-wheels/github.osx.arm64.yml
index 2c796d162debf..c217f5901b583 100644
--- a/dev/tasks/python-wheels/github.osx.arm64.yml
+++ b/dev/tasks/python-wheels/github.osx.arm64.yml
@@ -104,9 +104,9 @@ jobs:
           # the cffi wheel. We build cffi with the flags pointing to the correct libffi location.
           LDFLAGS=-L$(brew --prefix libffi)/lib CFLAGS=-I$(brew --prefix libffi)/include \
              pip install cffi --no-binary :all:
-           pip install -r arrow/python/requirements-wheel-test.txt
+          pip install -r arrow/python/requirements-wheel-test.txt
           PYTHON=python  arrow/ci/scripts/install_gcs_testbench.sh default
-           arrow/ci/scripts/python_wheel_unix_test.sh $(pwd)/arrow
+          arrow/ci/scripts/python_wheel_unix_test.sh $(pwd)/arrow
 
       - name: Upload artifacts
         shell: bash
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index e32e61bfbce46..0950378875645 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -467,7 +467,8 @@ tasks:
 {% for python_version, python_tag, abi_tag in [("3.8", "cp38", "cp38"),
                                                ("3.9", "cp39", "cp39"),
                                                ("3.10", "cp310", "cp310"),
-                                               ("3.11", "cp311", "cp311")] %}
+                                               ("3.11", "cp311", "cp311"),
+                                               ("3.12", "cp312", "cp312")] %}
 
 {############################## Wheel Linux ##################################}
 
@@ -533,7 +534,7 @@ tasks:
     artifacts:
       - pyarrow-{no_rc_version}-cp38-cp38-macosx_11_0_arm64.whl
 
-{% for python_version, python_tag in [("3.9", "cp39"), ("3.10", "cp310"), ("3.11", "cp311")] %}
+{% for python_version, python_tag in [("3.9", "cp39"), ("3.10", "cp310"), ("3.11", "cp311"), ("3.12", "cp312")] %}
   wheel-macos-big-sur-{{ python_tag }}-arm64:
     ci: github
     template: python-wheels/github.osx.arm64.yml
@@ -1233,7 +1234,7 @@ tasks:
       flags: "-e ARROW_CSV=ON -e ARROW_PARQUET=ON"
       image: ubuntu-cpp-minimal
 
-{% for python_version in ["3.8", "3.9", "3.10", "3.11"] %}
+{% for python_version in ["3.8", "3.9", "3.10", "3.11", "3.12"] %}
   test-conda-python-{{ python_version }}:
     ci: github
     template: docker-tests/github.linux.yml
diff --git a/docker-compose.yml b/docker-compose.yml
index 62e5aee0a841c..10e2b9fa8e205 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1033,7 +1033,7 @@ services:
       args:
         arch: ${ARCH}
         arch_short: ${ARCH_SHORT}
-        base: quay.io/pypa/manylinux2014_${ARCH_ALIAS}:2022-10-25-fbea779
+        base: quay.io/pypa/manylinux2014_${ARCH_ALIAS}:2023-10-03-72cdc42
         vcpkg: ${VCPKG}
         python: ${PYTHON}
         manylinux: 2014
@@ -1056,7 +1056,7 @@ services:
       args:
         arch: ${ARCH}
         arch_short: ${ARCH_SHORT}
-        base: quay.io/pypa/manylinux_2_28_${ARCH_ALIAS}:2023-01-14-103cb93
+        base: quay.io/pypa/manylinux_2_28_${ARCH_ALIAS}:2023-10-03-72cdc42
         vcpkg: ${VCPKG}
         python: ${PYTHON}
         manylinux: 2_28
@@ -1807,7 +1807,8 @@ services:
     command: >
       /bin/bash -c "
         git config --global --add safe.directory /arrow &&
-        archery lint --all --no-clang-tidy --no-iwyu --no-numpydoc"
+        pip install arrow/dev/archery[lint] &&
+        archery lint --all --no-clang-tidy --no-iwyu --no-numpydoc --src /arrow"
 
   ######################### Integration Tests #################################
 
diff --git a/python/requirements-wheel-test.txt b/python/requirements-wheel-test.txt
index 9de0acb754079..516ec0fccc2e9 100644
--- a/python/requirements-wheel-test.txt
+++ b/python/requirements-wheel-test.txt
@@ -7,18 +7,15 @@ pytz
 tzdata; sys_platform == 'win32'
 
 numpy==1.21.3; platform_system == "Linux"   and platform_machine == "aarch64" and python_version < "3.11"
-numpy==1.23.4; platform_system == "Linux"   and platform_machine == "aarch64" and python_version >= "3.11"
+numpy==1.23.4;                                                                    python_version == "3.11"
+numpy==1.26.0;                                                                    python_version >= "3.12"
 numpy==1.19.5; platform_system == "Linux"   and platform_machine != "aarch64" and python_version <  "3.9"
 numpy==1.21.3; platform_system == "Linux"   and platform_machine != "aarch64" and python_version >= "3.9" and python_version < "3.11"
-numpy==1.23.4; platform_system == "Linux"   and platform_machine != "aarch64" and python_version >= "3.11"
 numpy==1.21.3; platform_system == "Darwin"  and platform_machine == "arm64"   and python_version <  "3.11"
-numpy==1.23.4; platform_system == "Darwin"  and platform_machine == "arm64"   and python_version >= "3.11"
 numpy==1.19.5; platform_system == "Darwin"  and platform_machine != "arm64"   and python_version <  "3.9"
 numpy==1.21.3; platform_system == "Darwin"  and platform_machine != "arm64"   and python_version >= "3.9" and python_version < "3.11"
-numpy==1.23.4; platform_system == "Darwin"  and platform_machine != "arm64"   and python_version >= "3.11"
 numpy==1.19.5; platform_system == "Windows"                                   and python_version <  "3.9"
 numpy==1.21.3; platform_system == "Windows"                                   and python_version >= "3.9" and python_version < "3.11"
-numpy==1.23.4; platform_system == "Windows"                                   and python_version >= "3.11"
 
 pandas<1.1.0;  platform_system == "Linux"   and platform_machine != "aarch64" and python_version <  "3.8"
 pandas;        platform_system == "Linux"   and platform_machine != "aarch64" and python_version >= "3.8"
diff --git a/python/setup.py b/python/setup.py
index 6934161fe6d2c..3686dc4573cf7 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -505,6 +505,7 @@ def has_ext_modules(foo):
         'Programming Language :: Python :: 3.9',
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
     ],
     license='Apache License, Version 2.0',
     maintainer='Apache Arrow Developers',

From 96d09e17bd85faa79937e0167a4500c2951d8193 Mon Sep 17 00:00:00 2001
From: Phillip LeBlanc <phillip@leblanc.tech>
Date: Wed, 11 Oct 2023 23:55:00 +0900
Subject: [PATCH 529/749] GH-38198: [Go] Fix AuthenticateBasicToken to be
 reliable behind proxies (#38199)

### Rationale for this change

Fixes a bug in the Go Flight client library that makes using AuthenticateBasicToken unreliable behind proxies.

### What changes are included in this PR?

Closes the sending side of the bi-directional stream for the Flight Handshake RPC call before trying to read the headers. This matches the C++ implementation.

<img width="609" alt="Screenshot 2023-10-11 at 6 18 40 PM" src="https://github.com/apache/arrow/assets/879445/05e23c6a-0ff8-41fc-825b-8add7fe938bc">

### Are these changes tested?

I've tested these changes against my service deployed behind CloudFlare and verified the error listed in the linked issue disappears.

### Are there any user-facing changes?

No
* Closes: #38198

Authored-by: Phillip LeBlanc <phillip@leblanc.tech>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/flight/client.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index c4a5843ea10f4..c9a1417accab4 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -312,18 +312,18 @@ func (c *client) AuthenticateBasicToken(ctx context.Context, username, password
 		return ctx, err
 	}
 
-	header, err := stream.Header()
+	err = stream.CloseSend()
 	if err != nil {
 		return ctx, err
 	}
 
-	_, err = stream.Recv()
-	if err != nil && err != io.EOF {
+	header, err := stream.Header()
+	if err != nil {
 		return ctx, err
 	}
 
-	err = stream.CloseSend()
-	if err != nil {
+	_, err = stream.Recv()
+	if err != nil && err != io.EOF {
 		return ctx, err
 	}
 

From 757cf3e9c6a65f8a4ef11648c5504012dae60d31 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 11 Oct 2023 17:27:14 +0200
Subject: [PATCH 530/749] GH-38201: [CI][Packaging] Pin zlib 1.2.13 when using
 thrift on conan (#38202)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
There is a conflict between the required Zlib version when using both thrift and GRPC.

### What changes are included in this PR?

Pinning zlib when using thrifht.

### Are these changes tested?

Via archery

### Are there any user-facing changes?

No
* Closes: #38201

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 ci/conan/all/conanfile.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ci/conan/all/conanfile.py b/ci/conan/all/conanfile.py
index 663c92e4a03d6..b32219f63c8e5 100644
--- a/ci/conan/all/conanfile.py
+++ b/ci/conan/all/conanfile.py
@@ -358,6 +358,7 @@ def _with_rapidjson(self):
 
     def requirements(self):
         if self._with_thrift():
+            self.requires("zlib/1.2.13")
             self.requires("thrift/0.17.0")
         if self._with_protobuf():
             self.requires("protobuf/3.21.4")

From 852f09d54b4fb92b392ad7fa29364e6add13bd3b Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 11 Oct 2023 11:33:24 -0400
Subject: [PATCH 531/749] GH-37812: [MATLAB] Add `arrow.type.ListType` MATLAB
 class (#38189)

### Rationale for this change

In support of adding an [`arrow.array.ListArray`](https://github.com/apache/arrow/issues/37815) MATLAB class, this pull request adds a new `arrow.type.ListType` MATLAB class.

### What changes are included in this PR?

1. New `arrow.list(<type>)` MATLAB construction function.
2. New `arrow.list.ListType` MATLAB class. `ListType` has a property named `Type` which indicates the inner type of the `List`. `Type` can be set to any subclass `arrow.type.Type` (including `arrow.type.ListType`, to support nested lists).
3. New `arrow.type.ID.List` type ID enumeration value.
4. New `arrow.type.traits.ListTraits` type traits class. Some of the properties, such as `ArrayConstructor` and `ArrayProxyClassName`, are set to `missing` because they are dependent on adding [`arrow.array.ListArray`](https://github.com/apache/arrow/issues/37815) first.

**Example**
```matlab
% Create a simple List<String> type.
>> stringListType = arrow.list(arrow.string())

stringListType =

  ListType with properties:

      ID: List
    Type: [1x1 arrow.type.StringType]

% Create a nested List<List<Boolean>> type.
>> nestedListType = arrow.list(arrow.list(arrow.boolean()))

nestedListType =

  ListType with properties:

      ID: List
    Type: [1x1 arrow.type.ListType]

% Extract the first-level, inner type, which is List<Boolean>.
>> innerType = nestedListType.Type

innerType =

  ListType with properties:

      ID: List
    Type: [1x1 arrow.type.BooleanType]

% Extract the second-level, nested inner type, which is Boolean.
>> innerType.Type

ans =

  BooleanType with properties:

    ID: Boolean
```

### Are these changes tested?

Yes.

1. Added `tListType.m`.
2. Added `tListTraits.m`.
3. Updated `tField.m` to include `arrow.list`.
4. Updated `tID.m` to include `arrow.type.ID.List`.
6. Updated `tTypeDisplay.m` to include `arrow.type.ListType`.
7. Updated `ttraits.m` to include `arrow.type.traits.ListTraits`.

### Are there any user-facing changes?

Yes.

Client MATLAB code can now creates instances of `arrow.type.ListType` by using the `arrow.list(<type>)` construction function.

### Future Directions

1. #37815
* Closes: #37812

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 .../cpp/arrow/matlab/type/proxy/list_type.cc  |  64 ++++++++
 .../cpp/arrow/matlab/type/proxy/list_type.h   |  36 +++++
 .../cpp/arrow/matlab/type/proxy/struct_type.h |   4 +-
 .../src/cpp/arrow/matlab/type/proxy/wrap.cc   |   5 +-
 .../matlab/+arrow/+type/+traits/ListTraits.m  |  30 ++++
 .../src/matlab/+arrow/+type/+traits/traits.m  |   4 +-
 matlab/src/matlab/+arrow/+type/ID.m           |  40 ++---
 matlab/src/matlab/+arrow/+type/ListType.m     |  57 +++++++
 matlab/src/matlab/+arrow/list.m               |  26 ++++
 matlab/test/arrow/type/tField.m               |   1 +
 matlab/test/arrow/type/tID.m                  |   1 +
 matlab/test/arrow/type/tListType.m            | 143 ++++++++++++++++++
 matlab/test/arrow/type/tTypeDisplay.m         |  29 ++++
 matlab/test/arrow/type/traits/tListTraits.m   |  31 ++++
 matlab/test/arrow/type/traits/ttraits.m       |  12 ++
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 18 files changed, 463 insertions(+), 24 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/list_type.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/type/proxy/list_type.h
 create mode 100644 matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
 create mode 100644 matlab/src/matlab/+arrow/+type/ListType.m
 create mode 100644 matlab/src/matlab/+arrow/list.m
 create mode 100644 matlab/test/arrow/type/tListType.m
 create mode 100644 matlab/test/arrow/type/traits/tListTraits.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index b8376c0a06ecb..7dcecfa433567 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -174,6 +174,7 @@ namespace arrow::matlab::error {
     static const char* INVALID_TIME_UNIT = "arrow:type:InvalidTimeUnit";
     static const char* FIELD_FAILED_TO_CREATE_TYPE_PROXY = "arrow:field:FailedToCreateTypeProxy";
     static const char* ARRAY_FAILED_TO_CREATE_TYPE_PROXY = "arrow:array:FailedToCreateTypeProxy";
+    static const char* LIST_TYPE_FAILED_TO_CREATE_VALUE_TYPE_PROXY = "arrow:type:list:FailedToCreateValueTypeProxy";
     static const char* ARROW_TABULAR_SCHEMA_AMBIGUOUS_FIELD_NAME = "arrow:tabular:schema:AmbiguousFieldName";
     static const char* UNKNOWN_PROXY_FOR_ARRAY_TYPE = "arrow:array:UnknownProxyForArrayType";
     static const char* RECORD_BATCH_NUMERIC_INDEX_WITH_EMPTY_RECORD_BATCH = "arrow:tabular:recordbatch:NumericIndexWithEmptyRecordBatch";
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 3091d248f8ca1..5caf8d9fc8f2d 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -35,6 +35,7 @@
 #include "arrow/matlab/type/proxy/time32_type.h"
 #include "arrow/matlab/type/proxy/time64_type.h"
 #include "arrow/matlab/type/proxy/struct_type.h"
+#include "arrow/matlab/type/proxy/list_type.h"
 #include "arrow/matlab/type/proxy/field.h"
 #include "arrow/matlab/io/feather/proxy/writer.h"
 #include "arrow/matlab/io/feather/proxy/reader.h"
@@ -89,6 +90,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.type.proxy.Date32Type     , arrow::matlab::type::proxy::Date32Type);
     REGISTER_PROXY(arrow.type.proxy.Date64Type     , arrow::matlab::type::proxy::Date64Type);
     REGISTER_PROXY(arrow.type.proxy.StructType     , arrow::matlab::type::proxy::StructType);
+    REGISTER_PROXY(arrow.type.proxy.ListType       , arrow::matlab::type::proxy::ListType);
     REGISTER_PROXY(arrow.io.feather.proxy.Writer   , arrow::matlab::io::feather::proxy::Writer);
     REGISTER_PROXY(arrow.io.feather.proxy.Reader   , arrow::matlab::io::feather::proxy::Reader);
     REGISTER_PROXY(arrow.io.csv.proxy.TableWriter  , arrow::matlab::io::csv::proxy::TableWriter);
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/list_type.cc b/matlab/src/cpp/arrow/matlab/type/proxy/list_type.cc
new file mode 100644
index 0000000000000..141a7a18750b6
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/list_type.cc
@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/matlab/type/proxy/list_type.h"
+#include "arrow/matlab/type/proxy/wrap.h"
+#include "libmexclass/proxy/ProxyManager.h"
+#include "arrow/matlab/error/error.h"
+
+namespace arrow::matlab::type::proxy {
+
+    ListType::ListType(std::shared_ptr<arrow::ListType> list_type) : Type(std::move(list_type)) {
+        REGISTER_METHOD(ListType, getValueType);
+    }
+
+    void ListType::getValueType(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+
+        const auto list_type = std::static_pointer_cast<arrow::ListType>(data_type);
+        const auto value_type = list_type->value_type();
+        const auto value_type_id = static_cast<int32_t>(value_type->id());
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto value_type_proxy,
+                                    type::proxy::wrap(value_type),
+                                    context,
+                                    error::LIST_TYPE_FAILED_TO_CREATE_VALUE_TYPE_PROXY);
+        const auto value_type_proxy_id = libmexclass::proxy::ProxyManager::manageProxy(value_type_proxy);
+
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ValueTypeProxyID", "ValueTypeID"});
+        output[0]["ValueTypeProxyID"] = factory.createScalar(value_type_proxy_id);
+        output[0]["ValueTypeID"] = factory.createScalar(value_type_id);
+
+        context.outputs[0] = output;
+    }
+
+    libmexclass::proxy::MakeResult ListType::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        using ListTypeProxy = arrow::matlab::type::proxy::ListType;
+
+        mda::StructArray args = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> value_type_proxy_id_mda = args[0]["ValueTypeProxyID"];
+        const auto value_type_proxy_id = value_type_proxy_id_mda[0];
+        const auto proxy = ProxyManager::getProxy(value_type_proxy_id);
+        const auto value_type_proxy = std::static_pointer_cast<type::proxy::Type>(proxy);
+        const auto value_type = value_type_proxy->unwrap();
+        const auto list_type = std::static_pointer_cast<arrow::ListType>(arrow::list(value_type));
+        return std::make_shared<ListTypeProxy>(std::move(list_type));
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/list_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/list_type.h
new file mode 100644
index 0000000000000..1d7599e0537a3
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/list_type.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/type/proxy/type.h"
+
+namespace arrow::matlab::type::proxy {
+
+    class ListType : public arrow::matlab::type::proxy::Type {
+
+    public:
+        ListType(std::shared_ptr<arrow::ListType> list_type);
+
+        ~ListType() {}
+
+        void getValueType(libmexclass::proxy::method::Context& context);
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
index 8ec6217b34278..d3659e5784242 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/struct_type.h
@@ -29,6 +29,6 @@ namespace arrow::matlab::type::proxy {
         ~StructType() {}
 
         static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
-};
+    };
 
-}
\ No newline at end of file
+}
diff --git a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
index 3dd86e91409fa..df2d561b69df7 100644
--- a/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/type/proxy/wrap.cc
@@ -24,6 +24,7 @@
 #include "arrow/matlab/type/proxy/date32_type.h"
 #include "arrow/matlab/type/proxy/date64_type.h"
 #include "arrow/matlab/type/proxy/string_type.h"
+#include "arrow/matlab/type/proxy/list_type.h"
 #include "arrow/matlab/type/proxy/struct_type.h"
 
 namespace arrow::matlab::type::proxy {
@@ -65,7 +66,9 @@ namespace arrow::matlab::type::proxy {
                 return std::make_shared<Date64Type>(std::static_pointer_cast<arrow::Date64Type>(type));
             case ID::STRING:
                 return std::make_shared<StringType>(std::static_pointer_cast<arrow::StringType>(type));
-           case ID::STRUCT:
+            case ID::LIST:
+                return std::make_shared<ListType>(std::static_pointer_cast<arrow::ListType>(type));
+            case ID::STRUCT:
                 return std::make_shared<StructType>(std::static_pointer_cast<arrow::StructType>(type));
             default:
                 return arrow::Status::NotImplemented("Unsupported DataType: " + type->ToString());
diff --git a/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
new file mode 100644
index 0000000000000..c1c87790342ea
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
@@ -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.
+
+classdef ListTraits < arrow.type.traits.TypeTraits
+
+    properties (Constant)
+        ArrayConstructor = missing
+        ArrayClassName = missing
+        ArrayProxyClassName = missing
+        ArrayStaticConstructor = missing
+        TypeConstructor = @arrow.type.ListType
+        TypeClassName = "arrow.type.ListType"
+        TypeProxyClassName = "arrow.type.proxy.ListType"
+        MatlabConstructor = missing
+        MatlabClassName = missing
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+type/+traits/traits.m b/matlab/src/matlab/+arrow/+type/+traits/traits.m
index 9badf63eebb81..d7de576486c99 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/traits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/traits.m
@@ -56,6 +56,8 @@
                 typeTraits = Date32Traits();
             case ID.Date64
                 typeTraits = Date64Traits();
+            case ID.List
+                typeTraits = ListTraits();
             case ID.Struct
                 typeTraits = StructTraits();
             otherwise
@@ -100,4 +102,4 @@
         error("arrow:type:traits:UnsupportedInputType", "The input argument to the traits function " + ...
                                                         "must be a MATLAB class string or an arrow.type.ID enumeration.");
     end
-end
\ No newline at end of file
+end
diff --git a/matlab/src/matlab/+arrow/+type/ID.m b/matlab/src/matlab/+arrow/+type/ID.m
index b2c4facbe4065..deddd3ae3b74a 100644
--- a/matlab/src/matlab/+arrow/+type/ID.m
+++ b/matlab/src/matlab/+arrow/+type/ID.m
@@ -17,31 +17,31 @@
 
 classdef ID < uint64
     enumeration
-        Boolean (1)
-        UInt8   (2)
-        Int8    (3)
-        UInt16  (4)
-        Int16   (5)
-        UInt32  (6)
-        Int32   (7)
-        UInt64  (8)
-        Int64   (9)
-        % Float16 (10) not yet supported
-        Float32 (11)
-        Float64 (12)
-        String  (13)
-        % Binary (14)
+        Boolean           (1)
+        UInt8             (2)
+        Int8              (3)
+        UInt16            (4)
+        Int16             (5)
+        UInt32            (6)
+        Int32             (7)
+        UInt64            (8)
+        Int64             (9)
+        % Float16         (10)
+        Float32           (11)
+        Float64           (12)
+        String            (13)
+        % Binary          (14)
         % FixedSizeBinary (15)
-        Date32 (16)
-        Date64 (17)
-        Timestamp (18)
-        Time32    (19)
-        Time64    (20)
+        Date32            (16)
+        Date64            (17)
+        Timestamp         (18)
+        Time32            (19)
+        Time64            (20)
         % IntervalMonths  (21)
         % IntervalDayTime (22)
         % Decimal128      (23)
         % Decimal256      (24)
-        % List            (25)
+        List              (25)
         Struct            (26)
     end
 end
diff --git a/matlab/src/matlab/+arrow/+type/ListType.m b/matlab/src/matlab/+arrow/+type/ListType.m
new file mode 100644
index 0000000000000..4166cfd5a809a
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+type/ListType.m
@@ -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.
+
+classdef ListType < arrow.type.Type
+
+    properties (Dependent, GetAccess=public, SetAccess=private)
+        % The inner element type T of the List<T>.
+        % For example: for List<UInt64>, ValueType = UInt64.
+        ValueType
+    end
+
+    methods
+        function obj = ListType(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.type.proxy.ListType")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.type.Type(proxy);
+        end
+    end
+
+    methods(Access = protected)
+        function groups = getDisplayPropertyGroups(~)
+            targets = ["ID", "ValueType"];
+            groups = matlab.mixin.util.PropertyGroup(targets);
+        end
+    end
+
+
+    methods
+        function valueType = get.ValueType(obj)
+            valueTypeStruct = obj.Proxy.getValueType();
+            traits = arrow.type.traits.traits(arrow.type.ID(valueTypeStruct.ValueTypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.TypeProxyClassName, ID=valueTypeStruct.ValueTypeProxyID);
+            valueType = traits.TypeConstructor(proxy);
+        end
+    end
+
+    methods (Hidden)
+        function data = preallocateMATLABArray(~, numElements)
+            % Preallocate an empty cell array.
+            data = cell(numElements, 1);
+        end
+    end
+end
diff --git a/matlab/src/matlab/+arrow/list.m b/matlab/src/matlab/+arrow/list.m
new file mode 100644
index 0000000000000..bdee4558853e8
--- /dev/null
+++ b/matlab/src/matlab/+arrow/list.m
@@ -0,0 +1,26 @@
+%LIST Creates an arrow.type.ListType object
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+function listType = list(valueType)
+    arguments
+        valueType(1, 1) arrow.type.Type
+    end
+
+    valueTypeProxyID = valueType.Proxy.ID;
+    args = struct(ValueTypeProxyID=valueTypeProxyID);
+    proxy = arrow.internal.proxy.create("arrow.type.proxy.ListType", args);
+    listType = arrow.type.ListType(proxy);
+end
diff --git a/matlab/test/arrow/type/tField.m b/matlab/test/arrow/type/tField.m
index f84034d032c23..2176316b79cfd 100644
--- a/matlab/test/arrow/type/tField.m
+++ b/matlab/test/arrow/type/tField.m
@@ -42,6 +42,7 @@ function TestSupportedTypes(testCase)
                                  arrow.float64, ...
                                  arrow.string, ...
                                  arrow.timestamp, ...
+                                 arrow.list(arrow.uint64()), ...
                                  arrow.struct(arrow.field("A", arrow.float32()))
                              };
             for ii = 1:numel(supportedTypes)
diff --git a/matlab/test/arrow/type/tID.m b/matlab/test/arrow/type/tID.m
index e97d77e81c124..67197dfdaa60c 100644
--- a/matlab/test/arrow/type/tID.m
+++ b/matlab/test/arrow/type/tID.m
@@ -47,6 +47,7 @@ function CastToUInt64(testCase)
                 ID.Timestamp, 18, ...
                 ID.Time32,    19, ...
                 ID.Time64,    20, ...
+                ID.List,      25, ...
                 ID.Struct,    26 ...
             );
 
diff --git a/matlab/test/arrow/type/tListType.m b/matlab/test/arrow/type/tListType.m
new file mode 100644
index 0000000000000..e0d528a6a7da5
--- /dev/null
+++ b/matlab/test/arrow/type/tListType.m
@@ -0,0 +1,143 @@
+% TLISTTYPE Tests for arrow.type.ListType
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tListType < matlab.unittest.TestCase
+
+    properties (Constant)
+        BasicList = arrow.list(arrow.int8())
+        NestedList = arrow.list(arrow.list(arrow.list(arrow.uint64())))
+        ConstructionFcn = @arrow.list
+        TypeID = arrow.type.ID.List
+        ClassName = "arrow.type.ListType"
+    end
+
+    methods (Test)
+
+        function ConstructionFcnBasic(testCase)
+            % Verify construction function returns an instance of the
+            % expected arrow.type.Type subclass.
+            type = testCase.BasicList;
+            testCase.verifyInstanceOf(type, testCase.ClassName);
+        end
+
+        function ConstructionFcnTooFewInputsError(testCase)
+            % Verify construction function errors if given too few input arguments.
+            fcn = @() testCase.ConstructionFcn();
+            testCase.verifyError(fcn, "MATLAB:minrhs");
+        end
+
+        function ConstructionFcnTooManyInputsError(testCase)
+            % Verify construction function errors if given too many input arguments.
+            fcn = @() testCase.ConstructionFcn(1, 2);
+            testCase.verifyError(fcn, "MATLAB:TooManyInputs");
+        end
+
+        function ConstructionFcnInvalidValueTypeError(testCase)
+            % Verify construction function errors if the supplied
+            % valueType is not an arrow.type.Type object.
+            valueType = "abc";
+            fcn = @() testCase.ConstructionFcn(valueType);
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function ConstructionFcnEmptyValueTypeError(testCase)
+            % Verify construction function errors if given an empty
+            % arrow.type.Type array as the valueType input argument.
+            valueType = arrow.type.Type.empty(0, 0);
+            fcn = @() testCase.ConstructionFcn(valueType);
+            testCase.verifyError(fcn, "MATLAB:validation:IncompatibleSize");
+        end
+
+        function ValueTypeGetter(testCase)
+            % Verify the ValueType property getter returns the expected value.
+            valueType = arrow.int8();
+            type = arrow.list(valueType);
+            testCase.verifyEqual(type.ValueType, valueType);
+
+            valueType = arrow.list(arrow.uint64());
+            type = arrow.list(valueType);
+            testCase.verifyEqual(type.ValueType, valueType);
+        end
+
+        function ValueTypeNoSetter(testCase)
+            % Verify the ValueType property is not settable.
+            type = testCase.BasicList;
+            fcn = @() setfield(type, "ValueType", arrow.string());
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function IDGetter(testCase)
+            % Verify the ID property getter returns the expected enum value.
+            type = testCase.BasicList;
+            actual = type.ID;
+            expected = testCase.TypeID;
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function IDNoSetter(testCase)
+            % Verify the ID property is not settable.
+            type = testCase.BasicList;
+            fcn = @() setfield(type, "ID", arrow.type.ID.Boolean);
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function IsEqualTrue(testCase)
+            % Verify two ListTypes are considered equal if their
+            % ValueType properties are equal.
+
+            valueType = arrow.string();
+            type1 = arrow.list(arrow.list(valueType));
+            type2 = arrow.list(arrow.list(valueType));
+            testCase.verifyTrue(isequal(type1, type2));
+
+            % Non-scalar arrow.type.ListType arrays
+            type3 = [type1 type2];
+            type4 = [type1 type2];
+            testCase.verifyTrue(isequal(type3, type4));
+        end
+
+        function IsEqualFalse(testCase)
+            % Verify isequal returns false when expected.
+
+            valueType = arrow.time32();
+            type1 = arrow.list(valueType);
+
+            valueType = arrow.time64();
+            type2 = arrow.list(valueType);
+
+            valueType = arrow.timestamp();
+            type3 = arrow.list(valueType);
+
+            valueType = arrow.list(arrow.timestamp());
+            type4 = arrow.list(valueType);
+
+            % ValueType properties are different.
+            testCase.verifyFalse(isequal(type1, type2));
+            testCase.verifyFalse(isequal(type3, type4));
+
+            % Non-scalar arrow.type.ListType arrays
+            type5 = [type1 type2];
+            type6 = [type1; type2];
+            type7 = [type3 type4];
+            type8 = [type4 type3];
+            testCase.verifyFalse(isequal(type5, type6));
+            testCase.verifyFalse(isequal(type7, type8));
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/tTypeDisplay.m b/matlab/test/arrow/type/tTypeDisplay.m
index 6f5a4bcd97717..0445fcd74a4eb 100644
--- a/matlab/test/arrow/type/tTypeDisplay.m
+++ b/matlab/test/arrow/type/tTypeDisplay.m
@@ -265,5 +265,34 @@ function StructTypeDisplay(testCase)
             actualDisplay = evalc('disp(type)');
             verify(testCase, actualDisplay, expectedDisplay);
         end
+
+        function ListTypeDisplay(testCase)
+            % Verify the display of ListType objects.
+            %
+            % Example:
+            %
+            %  ListType with properties:
+            %
+            %          ID: Struct
+            %   ValueType: [1x1 arrow.type.StringType]
+
+            import arrow.internal.test.display.verify
+            import arrow.internal.test.display.makeLinkString
+            import arrow.internal.test.display.makeDimensionString
+
+            valueType = arrow.string();
+            type = arrow.list(valueType); %#ok<NASGU>
+            classnameLink = makeLinkString(FullClassName="arrow.type.ListType", ClassName="ListType", BoldFont=true);
+            header = "  " + classnameLink + " with properties:" + newline;
+            body = strjust(pad(["ID:"; "ValueType:"]));
+            dimensionString = makeDimensionString([1 1]);
+            typeString = compose("[%s %s]", dimensionString, string(class(valueType)));
+            body = body + " " + ["List"; typeString];
+            body = "    " + body;
+            footer = string(newline);
+            expectedDisplay = char(strjoin([header body' footer], newline));
+            actualDisplay = evalc('disp(type)');
+            verify(testCase, actualDisplay, expectedDisplay);
+        end
     end
 end
diff --git a/matlab/test/arrow/type/traits/tListTraits.m b/matlab/test/arrow/type/traits/tListTraits.m
new file mode 100644
index 0000000000000..93a8d8a0d10c5
--- /dev/null
+++ b/matlab/test/arrow/type/traits/tListTraits.m
@@ -0,0 +1,31 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tListTraits < hTypeTraits
+
+    properties
+        TraitsConstructor = @arrow.type.traits.ListTraits
+        ArrayConstructor = missing
+        ArrayClassName = missing
+        ArrayProxyClassName = missing
+        ArrayStaticConstructor = missing
+        TypeConstructor = @arrow.type.ListType
+        TypeClassName = "arrow.type.ListType"
+        TypeProxyClassName = "arrow.type.proxy.ListType"
+        MatlabConstructor = missing
+        MatlabClassName = missing
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/type/traits/ttraits.m b/matlab/test/arrow/type/traits/ttraits.m
index d2d80b3f8f8f5..9acf72bf56130 100644
--- a/matlab/test/arrow/type/traits/ttraits.m
+++ b/matlab/test/arrow/type/traits/ttraits.m
@@ -211,6 +211,18 @@ function TestStruct(testCase)
             testCase.verifyEqual(actualTraits, expectedTraits);
         end
 
+        function TestList(testCase)
+            import arrow.type.traits.*
+            import arrow.type.*
+
+            type = ID.List;
+            expectedTraits = ListTraits();
+
+            actualTraits = traits(type);
+
+            testCase.verifyEqual(actualTraits, expectedTraits);
+        end
+
         function TestMatlabUInt8(testCase)
             import arrow.type.traits.*
 
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index 50daab65324f4..c3940933679a5 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -67,6 +67,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time32_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/time64_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/struct_type.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/list_type.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/field.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/type/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/io/feather/proxy/writer.cc"

From e085b98dc48ee4e198378a129c03c60fbb9042e1 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Wed, 11 Oct 2023 12:56:49 -0300
Subject: [PATCH 532/749] GH-38142: [R] Add NEWS for 14.0.0 (#38143)

### Rationale for this change

The NEWS file needs updating for 14.0.0.

### What changes are included in this PR?

The NEWS file is updated with commits since 13.0.0.

### Are these changes tested?

N/A

### Are there any user-facing changes?

No
* Closes: #38142

Lead-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Co-authored-by: Dewey Dunnington <dewey@voltrondata.com>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/NEWS.md | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/r/NEWS.md b/r/NEWS.md
index 2e2db1ad5d3fa..34875cce55ab8 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -19,6 +19,49 @@
 
 # arrow 13.0.0.9000
 
+## New features
+
+* When reading partitioned CSV datasets and supplying a schema to
+  `open_dataset()`, the partition variables are now included in the resulting
+  dataset (#37658).
+* New function `write_csv_dataset()` now wraps `write_dataset()` and mirrors
+  the syntax of `write_csv_arrow()` (@dgreiss, #36436).
+* `open_delim_dataset()` now accepts `quoted_na` argument to empty strings
+  to be parsed as NA values (#37828).
+* `schema()` can now be called on `data.frame` objects to retrieve their
+  inferred Arrow schema  (#37843).
+* CSVs with a comma or other character as decimal mark can now be read in
+  by the dataset reading functions and new function `read_csv2_arrow()` 
+  (#38002).
+
+## Minor improvements and fixes
+
+* Documentation for `CsvParseOptions` object creation now contains more
+  information about default values (@angela-li, #37909).
+* Fixed a code path which may have resulted in R code being called from a
+  non-R thread after a failed allocation (#37565).
+* Fixed a bug where large Parquet files could not be read from R connections
+  (#37274).
+* Bindings to stringr helpers (e.g., `fixed()`, `regex()` etc.) now allow
+  variables to be reliably used in their arguments (#36784).
+* Thrift string and container size limits can now be configured via newly
+  exposed `ParquetReaderProperties`, allowing users to work with Parquet files
+  with unusually large metadata (#36992).
+* Error messages resulting from use of `add_filename()` are improved
+  (@amoeba, #37372).
+
+## Installation
+
+* MacOS builds now use the same installation pathway as on Linux (@assignUser,
+  #37684).
+* A warning message is now issued on package load when running under emulation
+  on MacOS (i.e., use of x86 installation of R on M1/aarch64; #37777).
+* R scripts that run during configuration and installation are now run
+  using the correct R interpreter (@meztez, #37225).
+* Failed libarrow builds now return more detailed output (@amoeba, #37727).
+* `create_package_with_all_dependencies()` now properly escapes paths on
+  Windows (#37226).
+
 # arrow 13.0.0.1
 
 * Remove reference to legacy timezones to prevent CRAN check failures (#37671)

From 1cc0f14bf5312cb54841c8f75a3b86f068f3d127 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 11 Oct 2023 18:18:25 +0200
Subject: [PATCH 533/749] GH-38209: [Docs] Reduce width of header items and
 keep header height default (small) on smaller screens (#38148)

### Rationale for this change

The Sphinx theme we have been using (PyData Sphinx Theme) has been pinned to an older version for a while now and with the https://github.com/apache/arrow/pull/36591 we have updated the code and are now using version 0.14.0 for the dev docs.

This PR fixes bugs we have encountered after the PR updating the theme has been merged.

### What changes are included in this PR?

- Have default header size for smaller screens and keep it increased for bigger screens.

* Closes: #38209

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/_static/theme_overrides.css | 10 ++++++++--
 docs/source/conf.py                     |  2 +-
 docs/source/format/index.rst            |  4 ++--
 docs/source/index.rst                   |  4 ++--
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/docs/source/_static/theme_overrides.css b/docs/source/_static/theme_overrides.css
index eeba0ef4cce6e..bf84267aea97b 100644
--- a/docs/source/_static/theme_overrides.css
+++ b/docs/source/_static/theme_overrides.css
@@ -21,12 +21,18 @@
 /* Customizing with theme CSS variables */
 
 :root {
-  /* Change header hight to make the logo a bit larger */
-  --pst-header-height: 6rem;
   /* Make headings more bold */
   --pst-font-weight-heading: 600;
 }
 
+/* Change header hight to make the logo a bit larger */
+/* only on wider screens */
+@media only screen and (min-width: 1170px){
+  :root {
+    --pst-header-height: 6rem;
+  }
+}
+
 /* Contibuting landing page overview cards */
 
 .contrib-card {
diff --git a/docs/source/conf.py b/docs/source/conf.py
index e9e8969f55254..89a0ba08826cd 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -296,7 +296,7 @@
       "image_dark": "_static/arrow-dark.png",
     },
     "header_links_before_dropdown": 2,
-    "header_dropdown_text": "Language implementations",
+    "header_dropdown_text": "Implementations",
     "navbar_end": ["version-switcher", "theme-switcher", "navbar-icon-links"],
     "icon_links": [
         {
diff --git a/docs/source/format/index.rst b/docs/source/format/index.rst
index ae2baf128b472..2c953a7298db4 100644
--- a/docs/source/format/index.rst
+++ b/docs/source/format/index.rst
@@ -17,8 +17,8 @@
 
 .. _format:
 
-Specifications and Protocols
-============================
+Specifications
+==============
 
 .. toctree::
    :maxdepth: 2
diff --git a/docs/source/index.rst b/docs/source/index.rst
index e8cdf50c5b1ec..d01c74f9a482e 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -42,7 +42,7 @@ target environment.**
    :padding: 2 2 0 0
    :class-container: sd-text-center
 
-   .. grid-item-card:: Specifications and Protocols
+   .. grid-item-card:: Specifications
       :class-card: contrib-card
       :shadow: none
 
@@ -57,7 +57,7 @@ target environment.**
          :color: primary
          :expand:
 
-         To the Specifications and Protocols
+         To the Specifications
 
    .. grid-item-card:: Development
       :class-card: contrib-card

From 73454b7040fbea3a187c1bfabd7ea02d46ca3c41 Mon Sep 17 00:00:00 2001
From: Junming Chen <junming.chen.r@outlook.com>
Date: Thu, 12 Oct 2023 01:30:47 +0800
Subject: [PATCH 534/749] GH-37378: [C++] Add A Dictionary Compaction Function
 For DictionaryArray (#37418)

### Rationale for this change
A Dictionary Compaction Function for DictionaryArray is supported.

### What changes are included in this PR?
Add a Function for Dictionary Compaction

### Are these changes tested?
Yes

Are there any user-facing changes?
No
* Closes: #37378

Lead-authored-by: Junming Chen <junming.chen.r@outlook.com>
Co-authored-by: Ben Harkins <60872452+benibus@users.noreply.github.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/array/array_dict.cc      | 114 +++++++++++++++++++++++++
 cpp/src/arrow/array/array_dict.h       |   2 +
 cpp/src/arrow/array/array_dict_test.cc |  71 +++++++++++++++
 3 files changed, 187 insertions(+)

diff --git a/cpp/src/arrow/array/array_dict.cc b/cpp/src/arrow/array/array_dict.cc
index c9e2f93cde66f..28fccdbfcffee 100644
--- a/cpp/src/arrow/array/array_dict.cc
+++ b/cpp/src/arrow/array/array_dict.cc
@@ -30,6 +30,7 @@
 #include "arrow/array/util.h"
 #include "arrow/buffer.h"
 #include "arrow/chunked_array.h"
+#include "arrow/compute/api.h"
 #include "arrow/datum.h"
 #include "arrow/status.h"
 #include "arrow/table.h"
@@ -211,6 +212,106 @@ Result<std::shared_ptr<ArrayData>> TransposeDictIndices(
   return out_data;
 }
 
+struct CompactTransposeMapVistor {
+  const std::shared_ptr<ArrayData>& data;
+  arrow::MemoryPool* pool;
+  std::unique_ptr<Buffer> output_map;
+  std::shared_ptr<Array> out_compact_dictionary;
+
+  template <typename IndexArrowType>
+  Status CompactTransposeMapImpl() {
+    int64_t index_length = data->length;
+    int64_t dict_length = data->dictionary->length;
+    if (dict_length == 0) {
+      output_map = nullptr;
+      out_compact_dictionary = nullptr;
+      return Status::OK();
+    } else if (index_length == 0) {
+      ARROW_ASSIGN_OR_RAISE(out_compact_dictionary,
+                            MakeEmptyArray(data->dictionary->type, pool));
+      ARROW_ASSIGN_OR_RAISE(output_map, AllocateBuffer(0, pool))
+      return Status::OK();
+    }
+
+    using CType = typename IndexArrowType::c_type;
+    const CType* indices_data = data->GetValues<CType>(1);
+    std::vector<bool> dict_used(dict_length, false);
+    CType dict_len = static_cast<CType>(dict_length);
+    int64_t dict_used_count = 0;
+    for (int64_t i = 0; i < index_length; i++) {
+      if (data->IsNull(i)) {
+        continue;
+      }
+
+      CType current_index = indices_data[i];
+      if (current_index < 0 || current_index >= dict_len) {
+        return Status::IndexError(
+            "Index out of bounds while compacting dictionary array: ", current_index,
+            "(dictionary is ", dict_length, " long) at position ", i);
+      }
+      if (dict_used[current_index]) continue;
+      dict_used[current_index] = true;
+      dict_used_count++;
+
+      if (dict_used_count == dict_length) {
+        // The dictionary is already compact, so just return here
+        output_map = nullptr;
+        out_compact_dictionary = nullptr;
+        return Status::OK();
+      }
+    }
+
+    using BuilderType = NumericBuilder<IndexArrowType>;
+    using arrow::compute::Take;
+    using arrow::compute::TakeOptions;
+    BuilderType dict_indices_builder(pool);
+    ARROW_RETURN_NOT_OK(dict_indices_builder.Reserve(dict_used_count));
+    ARROW_ASSIGN_OR_RAISE(output_map,
+                          AllocateBuffer(dict_length * sizeof(int32_t), pool));
+    auto* output_map_raw = output_map->mutable_data_as<int32_t>();
+    int32_t current_index = 0;
+    for (CType i = 0; i < dict_len; i++) {
+      if (dict_used[i]) {
+        dict_indices_builder.UnsafeAppend(i);
+        output_map_raw[i] = current_index;
+        current_index++;
+      } else {
+        output_map_raw[i] = -1;
+      }
+    }
+    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<arrow::Array> compacted_dict_indices,
+                          dict_indices_builder.Finish());
+    ARROW_ASSIGN_OR_RAISE(auto compacted_dict_res,
+                          Take(Datum(data->dictionary), compacted_dict_indices,
+                               TakeOptions::NoBoundsCheck()));
+    out_compact_dictionary = compacted_dict_res.make_array();
+    return Status::OK();
+  }
+
+  template <typename Type>
+  enable_if_integer<Type, Status> Visit(const Type&) {
+    return CompactTransposeMapImpl<Type>();
+  }
+
+  Status Visit(const DataType& type) {
+    return Status::TypeError("Expected an Index Type of Int or UInt");
+  }
+};
+
+Result<std::unique_ptr<Buffer>> CompactTransposeMap(
+    const std::shared_ptr<ArrayData>& data, MemoryPool* pool,
+    std::shared_ptr<Array>& out_compact_dictionary) {
+  if (data->type->id() != Type::DICTIONARY) {
+    return Status::TypeError("Expected dictionary type");
+  }
+
+  const auto& dict_type = checked_cast<const DictionaryType&>(*data->type);
+  CompactTransposeMapVistor vistor{data, pool, nullptr, nullptr};
+  RETURN_NOT_OK(VisitTypeInline(*dict_type.index_type(), &vistor));
+
+  out_compact_dictionary = vistor.out_compact_dictionary;
+  return std::move(vistor.output_map);
+}
 }  // namespace
 
 Result<std::shared_ptr<Array>> DictionaryArray::Transpose(
@@ -222,6 +323,19 @@ Result<std::shared_ptr<Array>> DictionaryArray::Transpose(
   return MakeArray(std::move(transposed));
 }
 
+Result<std::shared_ptr<Array>> DictionaryArray::Compact(MemoryPool* pool) const {
+  std::shared_ptr<Array> compact_dictionary;
+  ARROW_ASSIGN_OR_RAISE(std::unique_ptr<Buffer> transpose_map,
+                        CompactTransposeMap(this->data_, pool, compact_dictionary));
+
+  if (transpose_map == nullptr) {
+    return std::make_shared<DictionaryArray>(this->data_);
+  } else {
+    return this->Transpose(this->type(), compact_dictionary,
+                           transpose_map->data_as<int32_t>(), pool);
+  }
+}
+
 // ----------------------------------------------------------------------
 // Dictionary unification
 
diff --git a/cpp/src/arrow/array/array_dict.h b/cpp/src/arrow/array/array_dict.h
index b7d4db4b415b4..9aa0a7bcc2d66 100644
--- a/cpp/src/arrow/array/array_dict.h
+++ b/cpp/src/arrow/array/array_dict.h
@@ -96,6 +96,8 @@ class ARROW_EXPORT DictionaryArray : public Array {
       const std::shared_ptr<DataType>& type, const std::shared_ptr<Array>& dictionary,
       const int32_t* transpose_map, MemoryPool* pool = default_memory_pool()) const;
 
+  Result<std::shared_ptr<Array>> Compact(MemoryPool* pool = default_memory_pool()) const;
+
   /// \brief Determine whether dictionary arrays may be compared without unification
   bool CanCompareIndices(const DictionaryArray& other) const;
 
diff --git a/cpp/src/arrow/array/array_dict_test.cc b/cpp/src/arrow/array/array_dict_test.cc
index 3c1a1aaa86d2d..2f3ee6e2d49a5 100644
--- a/cpp/src/arrow/array/array_dict_test.cc
+++ b/cpp/src/arrow/array/array_dict_test.cc
@@ -1428,6 +1428,77 @@ TEST(TestDictionary, IndicesArray) {
   ASSERT_OK(arr->indices()->ValidateFull());
 }
 
+void CheckDictionaryCompact(const std::shared_ptr<DataType>& dict_type,
+                            const std::string& input_dictionary_json,
+                            const std::string& input_index_json,
+                            const std::string& expected_dictionary_json,
+                            const std::string& expected_index_json) {
+  auto input = DictArrayFromJSON(dict_type, input_index_json, input_dictionary_json);
+  const DictionaryArray& input_ref = checked_cast<const DictionaryArray&>(*input);
+
+  auto expected =
+      DictArrayFromJSON(dict_type, expected_index_json, expected_dictionary_json);
+
+  ASSERT_OK_AND_ASSIGN(std::shared_ptr<Array> actual, input_ref.Compact());
+  AssertArraysEqual(*expected, *actual, /*verbose=*/true);
+}
+
+TEST(TestDictionary, Compact) {
+  std::shared_ptr<arrow::DataType> type;
+  std::shared_ptr<arrow::DataType> dict_type;
+
+  for (const auto& index_type : all_dictionary_index_types()) {
+    ARROW_SCOPED_TRACE("index_type = ", index_type->ToString());
+
+    type = boolean();
+    dict_type = dictionary(index_type, type);
+
+    // input is compacted
+    CheckDictionaryCompact(dict_type, "[]", "[]", "[]", "[]");
+    CheckDictionaryCompact(dict_type, "[true, false]", "[0, 1, 0]", "[true, false]",
+                           "[0, 1, 0]");
+    CheckDictionaryCompact(dict_type, "[true, null, false]", "[2, 1, 0]",
+                           "[true, null, false]", "[2, 1, 0]");
+    CheckDictionaryCompact(dict_type, "[true, false]", "[0, null, 1, 0]", "[true, false]",
+                           "[0, null, 1, 0]");
+    CheckDictionaryCompact(dict_type, "[true, null, false]", "[2, null, 1, 0]",
+                           "[true, null, false]", "[2, null, 1, 0]");
+
+    // input isn't compacted
+    CheckDictionaryCompact(dict_type, "[null]", "[]", "[]", "[]");
+    CheckDictionaryCompact(dict_type, "[false]", "[null]", "[]", "[null]");
+    CheckDictionaryCompact(dict_type, "[true, false]", "[0]", "[true]", "[0]");
+    CheckDictionaryCompact(dict_type, "[true, false]", "[0, null]", "[true]",
+                           "[0, null]");
+
+    // input isn't compacted && its indices needs to be adjusted
+    CheckDictionaryCompact(dict_type, "[true, null, false]", "[2, 1]", "[null, false]",
+                           "[1, 0]");
+    CheckDictionaryCompact(dict_type, "[true, null, false]", "[2, null, 1]",
+                           "[null, false]", "[1, null, 0]");
+
+    // indices out of bound
+    auto temp_indices = ArrayFromJSON(index_type, "[8, 0]");
+    auto temp_dictionary = ArrayFromJSON(type, "[true, false]");
+    DictionaryArray input(dict_type, temp_indices, temp_dictionary);
+    ASSERT_RAISES(IndexError, input.Compact());
+
+    type = int64();
+    dict_type = dictionary(index_type, type);
+
+    // input isn't compacted && its indices needs to be adjusted
+    CheckDictionaryCompact(dict_type, "[3, 4, 7, 0, 12, 191, 21, 8]",
+                           "[0, 2, 4, 4, 6, 4, 2, 0, 6]", "[3, 7, 12, 21]",
+                           "[0, 1, 2, 2, 3, 2, 1, 0, 3]");
+    CheckDictionaryCompact(dict_type, "[3, 4, 7, 0, 12, 191, 21, 8]",
+                           "[4, 6, 7, 7, 6, 4, 6, 6, 6]", "[12, 21, 8]",
+                           "[0, 1, 2, 2, 1, 0, 1, 1, 1]");
+    CheckDictionaryCompact(dict_type, "[3, 4, 7, 0, 12, 191, 21, 8]",
+                           "[7, 4, 7, 7, 7, 7, 4, 7, 7]", "[12, 8]",
+                           "[1, 0, 1, 1, 1, 1, 0, 1, 1]");
+  }
+}
+
 TEST(TestDictionaryUnifier, Numeric) {
   auto dict_ty = int64();
 

From ef02417d40af7b970c5eafe809f256380cda2fab Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Wed, 11 Oct 2023 15:07:10 -0400
Subject: [PATCH 535/749] GH-37592: [MATLAB] Add `NumRows` property to
 `arrow.tabular.RecordBatch` (#38215)

### Rationale for this change

Currently, there is a `NumColumns` property on `arrow.tabular.RecordBatch`, but no `NumRows` property. It would be useful to be able to query the number of rows in a `RecordBatch`.

This pull request adds a `NumRows` property to `arrow.tabular.RecordBatch` to mirror the design of `arrow.tabular.Table`.

### What changes are included in this PR?

1. Added new `NumRows` property to `arrow.tabular.RecordBatch`

**Example**
```matlab
>> matlabTable = array2table(rand(10, 5))

matlabTable =

  10x5 table

      Var1        Var2       Var3       Var4        Var5
    ________    ________    _______    _______    ________

     0.76062     0.12009    0.98898    0.29974     0.42165
     0.64994     0.85116    0.71768    0.58693     0.31061
     0.33593     0.87823    0.87766    0.38206     0.45742
    0.031364      0.8336    0.71528    0.14987      0.3618
      0.5986     0.81193    0.25784    0.21073     0.76715
     0.46493     0.40281    0.39729    0.16737     0.94521
     0.18738     0.16351    0.46437    0.45545     0.40774
     0.67682      0.3577    0.94882     0.1295    0.022501
     0.29368     0.47122    0.99682    0.46011     0.34275
      0.6849    0.064717    0.89719    0.38302      0.4523

>> arrowRecordBatch = arrow.recordBatch(matlabTable);

>> arrowRecordBatch.NumRows

ans =

  int64

   10
```

### Are these changes tested?

Yes.

1. Added `NumRows` test to `tRecordBatch` test class.
3. Updated `EmptyTable` test (renamed to `EmptyRecordBatch`) in `tRecordBatch` test class.
4. Added  `FromArraysNoInputs` test to mirror the `FromArraysNoInputs` test in `tTable` test class.

### Are there any user-facing changes?

Yes.

This pull request adds a new public `NumRows` property to the `arrow.tabular.RecordBatch` class. Users can query the number of rows in an `arrow.tabular.RecordBatch` by accessing the `NumRows` property.

### Future Directions

1. #38214
3. #38213
* Closes: #37592

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../matlab/tabular/proxy/record_batch.cc      |  9 ++++
 .../arrow/matlab/tabular/proxy/record_batch.h |  1 +
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |  5 ++
 matlab/test/arrow/tabular/tRecordBatch.m      | 48 +++++++++++++++++--
 4 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index c3fc6a429d9ff..679c7382f6532 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -52,6 +52,7 @@ namespace arrow::matlab::tabular::proxy {
 
     RecordBatch::RecordBatch(std::shared_ptr<arrow::RecordBatch> record_batch) : record_batch{record_batch} {
         REGISTER_METHOD(RecordBatch, toString);
+        REGISTER_METHOD(RecordBatch, getNumRows);
         REGISTER_METHOD(RecordBatch, getNumColumns);
         REGISTER_METHOD(RecordBatch, getColumnNames);
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
@@ -104,6 +105,14 @@ namespace arrow::matlab::tabular::proxy {
         return record_batch_proxy;
     }
 
+    void RecordBatch::getNumRows(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::ArrayFactory factory;
+        const auto num_rows = record_batch->num_rows();
+        auto num_rows_mda = factory.createScalar(num_rows);
+        context.outputs[0] = num_rows_mda;
+    }
+
     void RecordBatch::getNumColumns(libmexclass::proxy::method::Context& context) {
         namespace mda = ::matlab::data;
         mda::ArrayFactory factory;
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index bac1298e35c39..b136ad1ea5db1 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -35,6 +35,7 @@ namespace arrow::matlab::tabular::proxy {
     
         protected:
             void toString(libmexclass::proxy::method::Context& context);
+            void getNumRows(libmexclass::proxy::method::Context& context);
             void getNumColumns(libmexclass::proxy::method::Context& context);
             void getColumnNames(libmexclass::proxy::method::Context& context);
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index 725039e87e426..fdedaecb5eb3a 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -21,6 +21,7 @@
                        matlab.mixin.Scalar
 
     properties (Dependent, SetAccess=private, GetAccess=public)
+        NumRows
         NumColumns
         ColumnNames
         Schema
@@ -39,6 +40,10 @@
             obj.Proxy = proxy;
         end
 
+        function numRows = get.NumRows(obj)
+            numRows = obj.Proxy.getNumRows();
+        end
+
         function numColumns = get.NumColumns(obj)
             numColumns = obj.Proxy.getNumColumns();
         end
diff --git a/matlab/test/arrow/tabular/tRecordBatch.m b/matlab/test/arrow/tabular/tRecordBatch.m
index b26729012a359..700d1aac4c7c8 100644
--- a/matlab/test/arrow/tabular/tRecordBatch.m
+++ b/matlab/test/arrow/tabular/tRecordBatch.m
@@ -62,6 +62,19 @@ function ColumnNames(tc)
             tc.verifyEqual(arrowRecordBatch.ColumnNames, columnNames);
         end
 
+        function NumRows(testCase)
+            % Verify that the NumRows property of arrow.tabular.RecordBatch
+            % returns the expected number of rows.
+            numRows = int64([1, 5, 100]);
+
+            for expectedNumRows = numRows
+                matlabTable = array2table(ones(expectedNumRows, 1));
+                arrowRecordBatch = arrow.recordBatch(matlabTable);
+                testCase.verifyEqual(arrowRecordBatch.NumRows, expectedNumRows);
+            end
+
+        end
+
         function NumColumns(tc)
             numColumns = int32([1, 5, 100]);
 
@@ -84,11 +97,27 @@ function UnicodeColumnNames(tc)
             tc.verifyEqual(TOriginal, TConverted);
         end
 
-        function EmptyTable(tc)
-            TOriginal = table();
-            arrowRecordBatch = arrow.recordBatch(TOriginal);
-            TConverted = arrowRecordBatch.toMATLAB();
-            tc.verifyEqual(TOriginal, TConverted);
+        function EmptyRecordBatch(testCase)
+            % Verify that an arrow.tabular.RecordBatch can be created from
+            % an empty MATLAB table.
+            matlabTable = table.empty(0, 0);
+            arrowRecordBatch = arrow.recordBatch(matlabTable);
+            testCase.verifyEqual(arrowRecordBatch.NumRows, int64(0));
+            testCase.verifyEqual(arrowRecordBatch.NumColumns, int32(0));
+            testCase.verifyEqual(arrowRecordBatch.ColumnNames, string.empty(1, 0));
+            testCase.verifyEqual(toMATLAB(arrowRecordBatch), matlabTable);
+
+            matlabTable = table.empty(1, 0);
+            arrowRecordBatch = arrow.recordBatch(matlabTable);
+            testCase.verifyEqual(arrowRecordBatch.NumRows, int64(0));
+            testCase.verifyEqual(arrowRecordBatch.NumColumns, int32(0));
+            testCase.verifyEqual(arrowRecordBatch.ColumnNames, string.empty(1, 0));
+
+            matlabTable = table.empty(0, 1);
+            arrowRecordBatch = arrow.recordBatch(matlabTable);
+            testCase.verifyEqual(arrowRecordBatch.NumRows, int64(0));
+            testCase.verifyEqual(arrowRecordBatch.NumColumns, int32(1));
+            testCase.verifyEqual(arrowRecordBatch.ColumnNames, "Var1");
         end
 
         function EmptyRecordBatchColumnIndexError(tc)
@@ -196,6 +225,15 @@ function FromArraysColumnNamesHasMissingString(tc)
             tc.verifyError(fcn, "MATLAB:validators:mustBeNonmissing");
         end
 
+        function FromArraysNoInputs(testCase)
+            % Verify that an empty RecordBatch is returned when calling
+            % fromArrays with no input arguments.
+            arrowRecordBatch = arrow.tabular.RecordBatch.fromArrays();
+            testCase.verifyEqual(arrowRecordBatch.NumRows, int64(0));
+            testCase.verifyEqual(arrowRecordBatch.NumColumns, int32(0));
+            testCase.verifyEqual(arrowRecordBatch.ColumnNames, string.empty(1, 0));
+        end
+
         function Schema(tc)
         % Verify that the public Schema property returns an approprate
         % instance of arrow.tabular.Schema.

From 7047e63f6f5fca43f6f5f58cf0f711b4590f92b4 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 12 Oct 2023 05:38:43 +0900
Subject: [PATCH 536/749] GH-37510: [C++] Don't install bundled Azure SDK for
 C++ (#38176)

### Rationale for this change

It's an internal bundled library. We should not install it as a part of Arrow.

### What changes are included in this PR?

Exclude all Azure SDK for C++ jobs including install jobs aren't executed by default. Building jobs are executed because they are required to build Arrow.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37510

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/docker/ubuntu-20.04-cpp.dockerfile       |  2 +-
 cpp/cmake_modules/ThirdpartyToolchain.cmake | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/ci/docker/ubuntu-20.04-cpp.dockerfile b/ci/docker/ubuntu-20.04-cpp.dockerfile
index 1e0a1e4807402..3e3b7ac3a6d99 100644
--- a/ci/docker/ubuntu-20.04-cpp.dockerfile
+++ b/ci/docker/ubuntu-20.04-cpp.dockerfile
@@ -146,7 +146,7 @@ RUN /arrow/ci/scripts/install_sccache.sh unknown-linux-musl /usr/local/bin
 # static Arrow to run Flight/Flight SQL tests
 ENV absl_SOURCE=BUNDLED \
     ARROW_ACERO=ON \
-    ARROW_AZURE=ON \
+    ARROW_AZURE=OFF \
     ARROW_BUILD_STATIC=ON \
     ARROW_BUILD_TESTS=ON \
     ARROW_DEPENDENCY_SOURCE=SYSTEM \
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index a6b5db382421a..ffc3c2514a295 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -5070,8 +5070,20 @@ endif()
 # Azure SDK for C++
 
 function(build_azure_sdk)
+  if(CMAKE_VERSION VERSION_LESS 3.22)
+    # We can't disable installing Azure SDK for C++ by
+    # "set_property(DIRECTORY ${azure_sdk_SOURCE_DIR} PROPERTY
+    # EXCLUDE_FROM_ALL TRUE)" with CMake 3.16.
+    #
+    # At least CMake 3.22 on Ubuntu 22.04 works. So we use 3.22
+    # here. We may be able to use more earlier version here.
+    message(FATAL_ERROR "Building Azure SDK for C++ requires at least CMake 3.22. "
+                        "(At least we can't use CMake 3.16)")
+  endif()
   message(STATUS "Building Azure SDK for C++ from source")
   fetchcontent_declare(azure_sdk
+                       # EXCLUDE_FROM_ALL is available since CMake 3.28
+                       # EXCLUDE_FROM_ALL TRUE
                        URL ${ARROW_AZURE_SDK_URL}
                        URL_HASH "SHA256=${ARROW_AZURE_SDK_BUILD_SHA256_CHECKSUM}")
   prepare_fetchcontent()
@@ -5084,6 +5096,9 @@ function(build_azure_sdk)
   set(ENV{AZURE_SDK_DISABLE_AUTO_VCPKG} TRUE)
   set(WARNINGS_AS_ERRORS FALSE)
   fetchcontent_makeavailable(azure_sdk)
+  if(CMAKE_VERSION VERSION_LESS 3.28)
+    set_property(DIRECTORY ${azure_sdk_SOURCE_DIR} PROPERTY EXCLUDE_FROM_ALL TRUE)
+  endif()
   set(AZURE_SDK_VENDORED
       TRUE
       PARENT_SCOPE)

From bb5ebbf0debd5851aa11c97ba432ecc3fa7424cb Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 12 Oct 2023 09:25:56 +0900
Subject: [PATCH 537/749] GH-38200: [CI][Release][Go] Ensure removing all
 module caches (#38222)

### Rationale for this change

Module caches don't have write permission by owner. So we can remove them by `rm -rf`.

### What changes are included in this PR?

Run `go clean -modcache` after all builds.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38200

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/verify-release-candidate.sh | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 6397cd4c32450..241beb16963ad 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -880,8 +880,6 @@ test_go() {
     go test ./...
   fi
   go install -buildvcs=false ./...
-  go clean -modcache
-
   if [ ${TEST_INTEGRATION_GO} -gt 0 ]; then
     pushd arrow/internal/cdata_integration
     case "$(uname)" in
@@ -898,7 +896,7 @@ test_go() {
     go build -buildvcs=false -tags cdata_integration,assert -buildmode=c-shared -o ${go_lib} .
     popd
   fi
-
+  go clean -modcache
   popd
 }
 
@@ -1204,7 +1202,7 @@ BUILD_JS=$((${TEST_JS} + ${TEST_INTEGRATION_JS}))
 BUILD_GO=$((${TEST_GO} + ${TEST_INTEGRATION_GO}))
 TEST_INTEGRATION=$((${TEST_INTEGRATION} + ${TEST_INTEGRATION_CPP} + ${TEST_INTEGRATION_JAVA} + ${TEST_INTEGRATION_JS} + ${TEST_INTEGRATION_GO}))
 
-# Execute tests in a conda enviroment
+# Execute tests in a conda environment
 : ${USE_CONDA:=0}
 
 # Build options for the C++ library

From ec08625717c209ff3dfa88f107f9675ba39ce97e Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Wed, 11 Oct 2023 23:21:09 -0300
Subject: [PATCH 538/749] GH-38226: [R] Remove R 3.5 from test-r-versions
 (#38230)

### Rationale for this change

The test-r-versions job is failing because not all of our dependencies support R 3.5. We follow the tidyverse support policy where possible, which means we only support R 3.6 and above. Thus, we can drop the test for R 3.5.

### What changes are included in this PR?

R 3.5 was removed from the test matrix for test-r-versions

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #38226

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/tasks/r/github.linux.versions.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/dev/tasks/r/github.linux.versions.yml b/dev/tasks/r/github.linux.versions.yml
index e3a5cce741d56..48093e9fd5b32 100644
--- a/dev/tasks/r/github.linux.versions.yml
+++ b/dev/tasks/r/github.linux.versions.yml
@@ -30,8 +30,6 @@ jobs:
         r_version:
           # We test devel, release, and oldrel in regular CI.
           # This is for older versions
-          # glue depends on R >= 3.4, and vctrs depends on glue
-          - "3.5"
           - "3.6"
           - "4.0"
           - "4.1"

From 8d9bab3234f4d7c747b32b82de03011663479b57 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Thu, 12 Oct 2023 14:07:42 +0200
Subject: [PATCH 539/749] GH-38243: [CI][Python] Add missing dataset marker for
 dataset encryption tests (#38244)

* Closes: #38243

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/tests/test_dataset_encryption.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/python/pyarrow/tests/test_dataset_encryption.py b/python/pyarrow/tests/test_dataset_encryption.py
index cf9c07a06b813..b5d6f510dbc8d 100644
--- a/python/pyarrow/tests/test_dataset_encryption.py
+++ b/python/pyarrow/tests/test_dataset_encryption.py
@@ -33,6 +33,11 @@
 except ImportError:
     encryption_unavailable = True
 
+
+# Marks all of the tests in this module
+pytestmark = pytest.mark.dataset
+
+
 FOOTER_KEY = b"0123456789112345"
 FOOTER_KEY_NAME = "footer_key"
 COL_KEY = b"1234567890123450"

From cc1dc6a63f4f4128d110d86ca8a21693c894cb9f Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Thu, 12 Oct 2023 08:19:31 -0400
Subject: [PATCH 540/749] GH-37979: [C++] Add support for specifying custom
 Array opening and closing delimiters to `arrow::PrettyPrintDelimiters`
 (#38187)

### Rationale for this change

This is a follow up to  #37981.

in order to make the [`arrow::PrettyPrint`](https://github.com/apache/arrow/blob/7667b81bffcb5b361fab6d61c42ce396d98cc6e1/cpp/src/arrow/pretty_print.h#L101) functionality for `arrow::Array` more flexible, it would be useful to be able to specify a custom `Array` opening and closing delimiter other than `"["` and `"]"`.

For example, the MATLAB interface wraps the Arrow C++ libraries and being able to specify a custom opening and closing delimiter for `Array` would make it possible to make the display of MATLAB `arrow.array.Array` objects more MATLAB-like.

In order to support custom `Array` opening and closing delimiters, this pull request adds two new properties, `open` and `close`, to the [`arrow::PrettyPrintDelimiters`](https://github.com/apache/arrow/blob/c37059ad7b87f0cbb681f6388aca0e3f02860351/cpp/src/arrow/pretty_print.h#L38) struct.

This enable use cases like the ability to display an `arrow::Array` as `<1,2,3>` instead of `[1,2,3]`, by setting `options.array_delimiters.open = "<"` and `options.array_delimiters.close = ">"`.

### What changes are included in this PR?

This pull request adds two new properties to the [`arrow::PrettyPrintDelimiters`](https://github.com/apache/arrow/blob/c37059ad7b87f0cbb681f6388aca0e3f02860351/cpp/src/arrow/pretty_print.h#L38) struct:

1. `open` - the opening delimiter to use for an `Array` or `ChunkedArray` (default = `[`).
1. `close` - the closing delimiter to use for an `Array` or `ChunkedArray` (default = `]`).

### Are these changes tested?

Yes.

1. Added two new tests: (1) `ArrayCustomOpenCloseDelimiter` and (2) `ChunkedArrayCustomOpenCloseDelimiter`.
2. All existing tests related to `arrow::PrettyPrint` pass.

### Are there any user-facing changes?

Yes.

This pull request adds two new public, user-facing properties, (1) `open` (of type `std::string`) and (2) `close` (also of type `std::string`) to the `PrettyPrintDelimiters` struct. This enables client code to specify custom opening and closing delimiters to use when printing an `arrow::Array` or `arrow::ChunkedArray` by changing the values of the nested `open` and `close` properties of the `array_delimiters`/`chunked_array_delimiters` properties of `PrettyPrintOptions`.

### Notes

1. This pull request was motivated by our desire to improve the display of Arrow related classes in the MATLAB interface, but it is hopefully a generic enough change that it may benefit other use cases too.

### Future Directions

1. Now that client code can easily specify custom opening, closing, and element delimiters, it may make sense to address #30951.
* Closes: #37979

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 cpp/src/arrow/pretty_print.cc      |  8 ++--
 cpp/src/arrow/pretty_print.h       |  6 +++
 cpp/src/arrow/pretty_print_test.cc | 73 ++++++++++++++++++++++++++++++
 3 files changed, 83 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index a4a1fa90c2878..a5410df7e9ae2 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -87,7 +87,7 @@ void PrettyPrinter::OpenArray(const Array& array) {
   if (!options_.skip_new_lines) {
     Indent();
   }
-  (*sink_) << "[";
+  (*sink_) << options_.array_delimiters.open;
   if (array.length() > 0) {
     Newline();
     indent_ += options_.indent_size;
@@ -101,7 +101,7 @@ void PrettyPrinter::CloseArray(const Array& array) {
       Indent();
     }
   }
-  (*sink_) << "]";
+  (*sink_) << options_.array_delimiters.close;
 }
 
 void PrettyPrinter::Write(std::string_view data) { (*sink_) << data; }
@@ -449,7 +449,7 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op
   for (int i = 0; i < indent; ++i) {
     (*sink) << " ";
   }
-  (*sink) << "[";
+  (*sink) << options.chunked_array_delimiters.open;
   if (!skip_new_lines) {
     *sink << "\n";
   }
@@ -488,7 +488,7 @@ Status PrettyPrint(const ChunkedArray& chunked_arr, const PrettyPrintOptions& op
   for (int i = 0; i < indent; ++i) {
     (*sink) << " ";
   }
-  (*sink) << "]";
+  (*sink) << options.chunked_array_delimiters.close;
 
   return Status::OK();
 }
diff --git a/cpp/src/arrow/pretty_print.h b/cpp/src/arrow/pretty_print.h
index 96a214c68b8a6..ad68726716cc7 100644
--- a/cpp/src/arrow/pretty_print.h
+++ b/cpp/src/arrow/pretty_print.h
@@ -36,6 +36,12 @@ class Table;
 /// \brief Options for controlling which delimiters to use when printing
 /// an Array or ChunkedArray.
 struct ARROW_EXPORT PrettyPrintDelimiters {
+  /// Delimiter to use when opening an Array or ChunkedArray (e.g. "[")
+  std::string open = "[";
+
+  /// Delimiter to use when closing an Array or ChunkedArray (e.g. "]")
+  std::string close = "]";
+
   /// Delimiter for separating individual elements of an Array (e.g. ","),
   /// or individual chunks of a ChunkedArray
   std::string element = ",";
diff --git a/cpp/src/arrow/pretty_print_test.cc b/cpp/src/arrow/pretty_print_test.cc
index 45bb4ecffe054..9217e190d5b62 100644
--- a/cpp/src/arrow/pretty_print_test.cc
+++ b/cpp/src/arrow/pretty_print_test.cc
@@ -259,6 +259,25 @@ TEST_F(TestPrettyPrint, ArrayCustomElementDelimiter) {
   }
 }
 
+TEST_F(TestPrettyPrint, ArrayCustomOpenCloseDelimiter) {
+  PrettyPrintOptions options{};
+  // Use a custom opening Array delimiter of "{", rather than the default "]".
+  options.array_delimiters.open = "{";
+  // Use a custom closing Array delimiter of "}", rather than the default "]".
+  options.array_delimiters.close = "}";
+
+  std::vector<bool> is_valid = {true, true, false, true, false};
+  std::vector<int32_t> values = {1, 2, 3, 4, 5};
+  static const char* expected = R"expected({
+  1,
+  2,
+  null,
+  4,
+  null
+})expected";
+  CheckPrimitive<Int32Type, int32_t>(options, is_valid, values, expected, false);
+}
+
 TEST_F(TestPrettyPrint, Int8) {
   static const char* expected = R"expected([
   0,
@@ -1131,6 +1150,60 @@ TEST_F(TestPrettyPrint, ChunkedArrayCustomElementDelimiter) {
   }
 }
 
+TEST_F(TestPrettyPrint, ChunkedArrayCustomOpenCloseDelimiter) {
+  PrettyPrintOptions options{};
+  // Use a custom opening Array delimiter of "{", rather than the default "]".
+  options.array_delimiters.open = "{";
+  // Use a custom closing Array delimiter of "}", rather than the default "]".
+  options.array_delimiters.close = "}";
+  // Use a custom opening ChunkedArray delimiter of "<", rather than the default "]".
+  options.chunked_array_delimiters.open = "<";
+  // Use a custom closing ChunkedArray delimiter of ">", rather than the default "]".
+  options.chunked_array_delimiters.close = ">";
+
+  const auto chunk = ArrayFromJSON(int32(), "[1, 2, null, 4, null]");
+
+  // ChunkedArray with 1 chunk
+  {
+    const ChunkedArray chunked_array(chunk);
+
+    static const char* expected = R"expected(<
+  {
+    1,
+    2,
+    null,
+    4,
+    null
+  }
+>)expected";
+    CheckStream(chunked_array, options, expected);
+  }
+
+  // ChunkedArray with 2 chunks
+  {
+    const ChunkedArray chunked_array({chunk, chunk});
+
+    static const char* expected = R"expected(<
+  {
+    1,
+    2,
+    null,
+    4,
+    null
+  },
+  {
+    1,
+    2,
+    null,
+    4,
+    null
+  }
+>)expected";
+
+    CheckStream(chunked_array, options, expected);
+  }
+}
+
 TEST_F(TestPrettyPrint, TablePrimitive) {
   std::shared_ptr<Field> int_field = field("column", int32());
   auto array = ArrayFromJSON(int_field->type(), "[0, 1, null, 3, null]");

From 84a4ab18209ae3677a1227cc42e5a52d91fc6f86 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Thu, 12 Oct 2023 09:43:12 -0300
Subject: [PATCH 541/749] GH-38228: [R] Fence examples that need dataset with
 `examplesIf` (#38229)

### Rationale for this change

The minimal nightly build are failing with examples that won't run without the dataset feature

### What changes are included in this PR?

- Added `examplesIf` where needed
- Redocumented

### Are these changes tested?

Yes, by all R CMD check jobs

### Are there any user-facing changes?

No
* Closes: #38228

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 r/R/csv.R                    | 6 +++---
 r/man/arrow-package.Rd       | 1 +
 r/man/csv_convert_options.Rd | 2 ++
 r/man/csv_parse_options.Rd   | 2 ++
 r/man/csv_read_options.Rd    | 2 ++
 5 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index ef35c7d6d5661..11e5b5d808696 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -412,7 +412,7 @@ CsvTableReader$create <- function(file,
 #'      - column names are read (unless `column_names` is set);
 #'      - `skip_rows_after_names` is applied (if non-zero).
 #'
-#' @examples
+#' @examplesIf arrow_with_dataset()
 #' tf <- tempfile()
 #' on.exit(unlink(tf))
 #' writeLines("my file has a non-data header\nx\n1\n2", tf)
@@ -672,7 +672,7 @@ readr_to_csv_read_options <- function(skip = 0, col_names = TRUE) {
 #'    and LF (`0x0a`) characters?
 #' @param ignore_empty_lines Logical: should empty lines be ignored (default) or
 #'    generate a row of missing values (if `FALSE`)?
-#' @examples
+#' @examplesIf arrow_with_dataset()
 #' tf <- tempfile()
 #' on.exit(unlink(tf))
 #' writeLines("x\n1\n\n2", tf)
@@ -780,7 +780,7 @@ TimestampParser$create <- function(format = NULL) {
 #'    (c) a list of [TimestampParser] objects.
 #' @param decimal_point Character to use for decimal point in floating point numbers.
 #'
-#' @examples
+#' @examplesIf arrow_with_dataset()
 #' tf <- tempfile()
 #' on.exit(unlink(tf))
 #' writeLines("x\n1\nNULL\n2\nNA", tf)
diff --git a/r/man/arrow-package.Rd b/r/man/arrow-package.Rd
index 2edd09dfb282e..15f672a1fe949 100644
--- a/r/man/arrow-package.Rd
+++ b/r/man/arrow-package.Rd
@@ -29,6 +29,7 @@ Authors:
   \item Jonathan Keane \email{jkeane@gmail.com}
   \item Dragoș Moldovan-Grünfeld \email{dragos.mold@gmail.com}
   \item Jeroen Ooms \email{jeroen@berkeley.edu}
+  \item Jacob Wujciak-Jens \email{jacob@wujciak.de}
   \item Apache Arrow \email{dev@arrow.apache.org} [copyright holder]
 }
 
diff --git a/r/man/csv_convert_options.Rd b/r/man/csv_convert_options.Rd
index f48da56eaa015..664a19ce15707 100644
--- a/r/man/csv_convert_options.Rd
+++ b/r/man/csv_convert_options.Rd
@@ -64,9 +64,11 @@ starting from the beginning of this vector. Possible values are
 CSV Convert Options
 }
 \examples{
+\dontshow{if (arrow_with_dataset()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 tf <- tempfile()
 on.exit(unlink(tf))
 writeLines("x\n1\nNULL\n2\nNA", tf)
 read_csv_arrow(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
 open_csv_dataset(tf, convert_options = csv_convert_options(null_values = c("", "NA", "NULL")))
+\dontshow{\}) # examplesIf}
 }
diff --git a/r/man/csv_parse_options.Rd b/r/man/csv_parse_options.Rd
index 23c647470b299..57b2b5784b4a8 100644
--- a/r/man/csv_parse_options.Rd
+++ b/r/man/csv_parse_options.Rd
@@ -38,9 +38,11 @@ generate a row of missing values (if \code{FALSE})?}
 CSV Parsing Options
 }
 \examples{
+\dontshow{if (arrow_with_dataset()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 tf <- tempfile()
 on.exit(unlink(tf))
 writeLines("x\n1\n\n2", tf)
 read_csv_arrow(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
 open_csv_dataset(tf, parse_options = csv_parse_options(ignore_empty_lines = FALSE))
+\dontshow{\}) # examplesIf}
 }
diff --git a/r/man/csv_read_options.Rd b/r/man/csv_read_options.Rd
index 622e8d5e5be86..af38fe457bd6f 100644
--- a/r/man/csv_read_options.Rd
+++ b/r/man/csv_read_options.Rd
@@ -43,9 +43,11 @@ The order of application is as follows:
 CSV Reading Options
 }
 \examples{
+\dontshow{if (arrow_with_dataset()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 tf <- tempfile()
 on.exit(unlink(tf))
 writeLines("my file has a non-data header\nx\n1\n2", tf)
 read_csv_arrow(tf, read_options = csv_read_options(skip_rows = 1))
 open_csv_dataset(tf, read_options = csv_read_options(skip_rows = 1))
+\dontshow{\}) # examplesIf}
 }

From 0640f948997428985cc880c0d798bc7f933aeed0 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Thu, 12 Oct 2023 09:59:29 -0300
Subject: [PATCH 542/749] GH-38197: [R] Update actions that used setup-r@v1 to
 use setup-r@v2 (#38218)

### Rationale for this change

CI jobs that used setup-r@ v1 no longer run without error.

### What changes are included in this PR?

- Updated the rchk job to use the `setup-r@ v2`
- Updated the devdocs job to use `setup-r@ v2`. To make this work, we needed to remove the Windows build because it was installing an old version of R. It seems that the job has been running an outdated and unsable (for most users) for a very long time.

### Are these changes tested?

Will be covered by crossbow jobs submitted below.

### Are there any user-facing changes?

No.
* Closes: #38197

Lead-authored-by: Dewey Dunnington <dewey@voltrondata.com>
Co-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Dewey Dunnington <dewey@voltrondata.com>
---
 dev/tasks/r/github.devdocs.yml    | 27 +++------------------------
 dev/tasks/r/github.linux.rchk.yml | 14 +++++++-------
 2 files changed, 10 insertions(+), 31 deletions(-)

diff --git a/dev/tasks/r/github.devdocs.yml b/dev/tasks/r/github.devdocs.yml
index 0839e7fc6afcf..92e94c6c97637 100644
--- a/dev/tasks/r/github.devdocs.yml
+++ b/dev/tasks/r/github.devdocs.yml
@@ -26,17 +26,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macOS-latest, ubuntu-20.04, windows-latest]
+        os: [macOS-latest, ubuntu-20.04]
 
     steps:
       {{ macros.github_checkout_arrow()|indent }}
-      # TODO (ARROW-16376): Switch to v2 once we use UCRT
-      - uses: r-lib/actions/setup-r@v1
-        with:
-          # temp workaround the fact that R 4.2 requires UCRT which isn't
-          # currently part of this build.
-          # remove after https://issues.apache.org/jira/browse/ARROW-16376
-          r-version: '4.1'
+      - uses: r-lib/actions/setup-r@v2
       - uses: r-lib/actions/setup-pandoc@v2
       - uses: r-lib/actions/setup-r-dependencies@v2
         with:
@@ -47,15 +41,11 @@ jobs:
           pkgs <- installed.packages()[, "Package"]
           sessioninfo::session_info(pkgs, include_base = TRUE)
         shell: Rscript {0}
-      - name: Remove system gfortran so that brew can install gcc successfully
-        run: rm -f /usr/local/bin/gfortran
-        if: {{ "${{ !contains(matrix.os, 'windows') }}" }}
       - name: Write the install script
         env:
           RUN_DEVDOCS: TRUE
           DEVDOCS_MACOS: {{ "${{contains(matrix.os, 'macOS')}}" }}
           DEVDOCS_UBUNTU: {{ "${{contains(matrix.os, 'ubuntu')}}" }}
-          DEVDOCS_WINDOWS: {{ "${{contains(matrix.os, 'windows')}}" }}
         run: |
           # This isn't actually rendering the docs, but will save arrow/r/vignettes/developers/script.sh
           # which can be sourced to install arrow.
@@ -65,21 +55,10 @@ jobs:
         env:
           LIBARROW_BINARY: FALSE
           ARROW_R_DEV: TRUE
-          DEVDOCS_WINDOWS: {{ "${{contains(matrix.os, 'windows')}}" }}
         run: |
-          if [ $DEVDOCS_WINDOWS == "true" ]; then
-            # Part of Path, including the path to R's bin, needs to be reformatted
-            # from Windows paths (C:\R\bin) to Unix paths (/c/r/bin)
-            echo export PATH=\"$(cygpath --path "$PATH")\" >> ~/.bash_profile
-            # This starts a special mingw64 Git Bash shell
-            $RTOOLS40_HOME/msys2_shell.cmd -here -mingw64 -no-start -defterm -full-path arrow/r/vignettes/developers/script.sh
-          else
-            bash arrow/r/vignettes/developers/script.sh
-          fi
+          bash arrow/r/vignettes/developers/script.sh
         shell: bash
       - name: Ensure that the Arrow package is loadable and we have the correct one
-        env:
-          DEVDOCS_WINDOWS: {{ "${{contains(matrix.os, 'windows')}}" }}
         run: |
           echo $LD_LIBRARY_PATH
           R --no-save <<EOF
diff --git a/dev/tasks/r/github.linux.rchk.yml b/dev/tasks/r/github.linux.rchk.yml
index 2e2c91061afc8..a673304ff238d 100644
--- a/dev/tasks/r/github.linux.rchk.yml
+++ b/dev/tasks/r/github.linux.rchk.yml
@@ -31,13 +31,13 @@ jobs:
     steps:
       {{ macros.github_checkout_arrow()|indent }}
 
-      - uses: r-lib/actions/setup-r@v1
-      - uses: r-lib/actions/setup-pandoc@v1
-      - name: Install dependencies
-        run: |
-          install.packages("remotes")
-          remotes::install_deps("arrow/r", dependencies = TRUE)
-        shell: Rscript {0}
+      - uses: r-lib/actions/setup-r@v2
+      - uses: r-lib/actions/setup-pandoc@v2
+      - uses: r-lib/actions/setup-r-dependencies@v2
+        with:
+          working-directory: 'arrow/r'
+          extra-packages: |
+            any::rcmdcheck
       - name: Build arrow package
         run: |
           R CMD build --no-build-vignettes arrow/r

From 71a4ef4b1014c22e8bc7627bb9c66efa20e1b453 Mon Sep 17 00:00:00 2001
From: Bryan Cutler <cutlerb@gmail.com>
Date: Thu, 12 Oct 2023 07:35:55 -0700
Subject: [PATCH 543/749] GH-38096: [Java] FlightStream with metadata can cause
 error when closing (#38110)

### Rationale for this change

The Java FlightStream can raise an error if metadata is transferred and ends up being closed twice.

```
java.lang.IllegalStateException: RefCnt has gone negative
	at org.apache.arrow.util.Preconditions.checkState(Preconditions.java:458)
	at org.apache.arrow.memory.BufferLedger.release(BufferLedger.java:130)
	at org.apache.arrow.memory.BufferLedger.release(BufferLedger.java:104)
	at org.apache.arrow.memory.ArrowBuf.close(ArrowBuf.java:1044)
	at org.apache.arrow.util.AutoCloseables.close(AutoCloseables.java:97)
	at org.apache.arrow.flight.FlightStream.close(FlightStream.java:208)
```

### What changes are included in this PR?

When FlightStream is closed, remove any reference of previous metadata to prevent reference count going negative if closed again. Also added `ExchangeReaderWriter.getResult()` for convenience and clear up ambiguity on error handling.

### Are these changes tested?

Unit tests added for closing with metadata and

### Are there any user-facing changes?

Added `ExchangeReaderWriter.getResult()`
* Closes: #38096

Authored-by: Bryan Cutler <cutlerb@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../org/apache/arrow/flight/FlightClient.java | 10 ++
 .../org/apache/arrow/flight/FlightStream.java |  2 +
 .../apache/arrow/flight/TestDoExchange.java   | 91 +++++++++++++++++++
 3 files changed, 103 insertions(+)

diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
index 422ed01c394d1..91e3b4d052f39 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightClient.java
@@ -429,6 +429,16 @@ public ClientStreamListener getWriter() {
       return writer;
     }
 
+    /**
+     * Make sure stream is drained. You must call this to be notified of any errors that may have
+     * happened after the exchange is complete. This should be called after `getWriter().completed()`
+     * and instead of `getWriter().getResult()`.
+     */
+    public void getResult() {
+      // After exchange is complete, make sure stream is drained to propagate errors through reader
+      while (reader.next()) { };
+    }
+
     /** Shut down the streams in this call. */
     @Override
     public void close() throws Exception {
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightStream.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightStream.java
index 03ce13c9780e3..ad4ffcbebdec1 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightStream.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightStream.java
@@ -207,6 +207,8 @@ public void close() throws Exception {
         } else {
           AutoCloseables.close(closeables);
         }
+        // Remove any metadata after closing to prevent negative refcnt
+        applicationMetadata = null;
       } finally {
         // The value of this CompletableFuture is meaningless, only whether it's completed (or has an exception)
         // No-op if already complete
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestDoExchange.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestDoExchange.java
index c2f8e75596904..f9db9bfd23a88 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestDoExchange.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestDoExchange.java
@@ -55,6 +55,7 @@ public class TestDoExchange {
   static byte[] EXCHANGE_METADATA_ONLY = "only-metadata".getBytes(StandardCharsets.UTF_8);
   static byte[] EXCHANGE_TRANSFORM = "transform".getBytes(StandardCharsets.UTF_8);
   static byte[] EXCHANGE_CANCEL = "cancel".getBytes(StandardCharsets.UTF_8);
+  static byte[] EXCHANGE_ERROR = "error".getBytes(StandardCharsets.UTF_8);
 
   private BufferAllocator allocator;
   private FlightServer server;
@@ -365,6 +366,37 @@ public void testClientCancel() throws Exception {
     }
   }
 
+  /** Test a DoExchange error handling. */
+  @Test
+  public void testDoExchangeError() throws Exception {
+    final Schema schema = new Schema(Collections.singletonList(Field.nullable("a", new ArrowType.Int(32, true))));
+    try (final FlightClient.ExchangeReaderWriter stream = client.doExchange(FlightDescriptor.command(EXCHANGE_ERROR));
+         final VectorSchemaRoot root = VectorSchemaRoot.create(schema, allocator)) {
+      final FlightStream reader = stream.getReader();
+
+      // Write data and check that it gets echoed back.
+      IntVector iv = (IntVector) root.getVector("a");
+      iv.allocateNew();
+      stream.getWriter().start(root);
+      for (int i = 0; i < 10; i++) {
+        iv.setSafe(0, i);
+        root.setRowCount(1);
+        stream.getWriter().putNext();
+
+        assertTrue(reader.next());
+        assertEquals(root.getSchema(), reader.getSchema());
+        assertEquals(i, ((IntVector) reader.getRoot().getVector("a")).get(0));
+      }
+
+      // Complete the stream so that the server knows not to expect any more messages from us.
+      stream.getWriter().completed();
+
+      // Must call reader.next() to get any errors after exchange, will return false if no error
+      final FlightRuntimeException fre = assertThrows(FlightRuntimeException.class, stream::getResult);
+      assertEquals("error completing exchange", fre.status().description());
+    }
+  }
+
   /** Have the client close the stream without reading; ensure memory is not leaked. */
   @Test
   public void testClientClose() throws Exception {
@@ -381,6 +413,38 @@ public void testClientClose() throws Exception {
     client = null;
   }
 
+  /** Test closing with Metadata can't lead to error. */
+  @Test
+  public void testCloseWithMetadata() throws Exception {
+    // Send a particular descriptor to the server and check for a particular response pattern.
+    try (final FlightClient.ExchangeReaderWriter stream =
+                 client.doExchange(FlightDescriptor.command(EXCHANGE_METADATA_ONLY))) {
+      final FlightStream reader = stream.getReader();
+
+      // Server starts by sending a message without data (hence no VectorSchemaRoot should be present)
+      assertTrue(reader.next());
+      assertFalse(reader.hasRoot());
+      assertEquals(42, reader.getLatestMetadata().getInt(0));
+
+      // Write a metadata message to the server (without sending any data)
+      ArrowBuf buf = allocator.buffer(4);
+      buf.writeInt(84);
+      stream.getWriter().putMetadata(buf);
+
+      // Check that the server echoed the metadata back to us
+      assertTrue(reader.next());
+      assertFalse(reader.hasRoot());
+      assertEquals(84, reader.getLatestMetadata().getInt(0));
+
+      // Close our write channel and ensure the server also closes theirs
+      stream.getWriter().completed();
+      stream.getResult();
+
+      // Not necessary to close reader here, but check closing twice doesn't lead to negative refcnt from metadata
+      stream.getReader().close();
+    }
+  }
+
   static class Producer extends NoOpFlightProducer {
     static final Schema SCHEMA = new Schema(
         Collections.singletonList(Field.nullable("a", new ArrowType.Int(32, true))));
@@ -404,6 +468,8 @@ public void doExchange(CallContext context, FlightStream reader, ServerStreamLis
         transform(context, reader, writer);
       } else if (Arrays.equals(reader.getDescriptor().getCommand(), EXCHANGE_CANCEL)) {
         cancel(context, reader, writer);
+      } else if (Arrays.equals(reader.getDescriptor().getCommand(), EXCHANGE_ERROR)) {
+        error(context, reader, writer);
       } else {
         writer.error(CallStatus.UNIMPLEMENTED.withDescription("Command not implemented").toRuntimeException());
       }
@@ -534,5 +600,30 @@ private void transform(CallContext context, FlightStream reader, ServerStreamLis
     private void cancel(CallContext context, FlightStream reader, ServerStreamListener writer) {
       writer.error(CallStatus.CANCELLED.withDescription("expected").toRuntimeException());
     }
+
+    private void error(CallContext context, FlightStream reader, ServerStreamListener writer) {
+      VectorSchemaRoot root = null;
+      VectorLoader loader = null;
+      while (reader.next()) {
+
+        if (root == null) {
+          root = VectorSchemaRoot.create(reader.getSchema(), allocator);
+          loader = new VectorLoader(root);
+          writer.start(root);
+        }
+        VectorUnloader unloader = new VectorUnloader(reader.getRoot());
+        try (final ArrowRecordBatch arb = unloader.getRecordBatch()) {
+          loader.load(arb);
+        }
+
+        writer.putNext();
+      }
+      if (root != null) {
+        root.close();
+      }
+
+      // An error occurs before completing the writer
+      writer.error(CallStatus.INTERNAL.withDescription("error completing exchange").toRuntimeException());
+    }
   }
 }

From ed97d5c0d88784fc8f5cf4119ca1ba590a2c8b14 Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Fri, 13 Oct 2023 00:02:55 +0900
Subject: [PATCH 544/749] GH-38210: [C++][FlightRPC] Add missing app_metadata
 arguments (#38231)

### Rationale for this change

I have fixed the error occurring when using the "DARROW_FLIGHT_SQL=ON" option on a Mac with ARM Architecture CPU.

### What changes are included in this PR?

It seems that implicit values are not recognized in this environment (Mac ARM), so I have added values explicitly.

### Are these changes tested?

yes (build and run unit test)

### Are there any user-facing changes?

No

* Closes: #38210

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../integration_tests/test_integration.cc     | 24 +++++++++----------
 .../test_integration_server.cc                |  2 +-
 .../arrow/flight/sql/example/acero_server.cc  |  5 ++--
 .../arrow/flight/sql/example/sqlite_server.cc |  6 ++---
 4 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/cpp/src/arrow/flight/integration_tests/test_integration.cc b/cpp/src/arrow/flight/integration_tests/test_integration.cc
index 31bffd7704474..b693662f60740 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration.cc
@@ -215,7 +215,7 @@ class MiddlewareServer : public FlightServerBase {
       // Return a fake location - the test doesn't read it
       ARROW_ASSIGN_OR_RAISE(auto location, Location::ForGrpcTcp("localhost", 10010));
       std::vector<FlightEndpoint> endpoints{
-          FlightEndpoint{{"foo"}, {location}, std::nullopt}};
+          FlightEndpoint{{"foo"}, {location}, std::nullopt, ""}};
       ARROW_ASSIGN_OR_RAISE(
           auto info, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false));
       *result = std::make_unique<FlightInfo>(info);
@@ -296,13 +296,13 @@ class OrderedServer : public FlightServerBase {
     auto schema = BuildSchema();
     std::vector<FlightEndpoint> endpoints;
     if (ordered) {
-      endpoints.push_back(FlightEndpoint{{"1"}, {}, std::nullopt});
-      endpoints.push_back(FlightEndpoint{{"2"}, {}, std::nullopt});
-      endpoints.push_back(FlightEndpoint{{"3"}, {}, std::nullopt});
+      endpoints.push_back(FlightEndpoint{{"1"}, {}, std::nullopt, ""});
+      endpoints.push_back(FlightEndpoint{{"2"}, {}, std::nullopt, ""});
+      endpoints.push_back(FlightEndpoint{{"3"}, {}, std::nullopt, ""});
     } else {
-      endpoints.push_back(FlightEndpoint{{"1"}, {}, std::nullopt});
-      endpoints.push_back(FlightEndpoint{{"3"}, {}, std::nullopt});
-      endpoints.push_back(FlightEndpoint{{"2"}, {}, std::nullopt});
+      endpoints.push_back(FlightEndpoint{{"1"}, {}, std::nullopt, ""});
+      endpoints.push_back(FlightEndpoint{{"3"}, {}, std::nullopt, ""});
+      endpoints.push_back(FlightEndpoint{{"2"}, {}, std::nullopt, ""});
     }
     ARROW_ASSIGN_OR_RAISE(
         auto info, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, ordered));
@@ -557,7 +557,7 @@ class ExpirationTimeServer : public FlightServerBase {
   void AddEndpoint(std::vector<FlightEndpoint>& endpoints, std::string ticket,
                    std::optional<Timestamp> expiration_time) {
     endpoints.push_back(FlightEndpoint{
-        {std::to_string(statuses_.size()) + ": " + ticket}, {}, expiration_time});
+        {std::to_string(statuses_.size()) + ": " + ticket}, {}, expiration_time, ""});
     statuses_.emplace_back(expiration_time);
   }
 
@@ -754,7 +754,7 @@ class PollFlightInfoServer : public FlightServerBase {
                         std::unique_ptr<PollInfo>* result) override {
     auto schema = arrow::schema({arrow::field("number", arrow::uint32(), false)});
     std::vector<FlightEndpoint> endpoints = {
-        FlightEndpoint{{"long-running query"}, {}, std::nullopt}};
+        FlightEndpoint{{"long-running query"}, {}, std::nullopt, ""}};
     ARROW_ASSIGN_OR_RAISE(
         auto info, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false));
     if (descriptor == FlightDescriptor::Command("poll")) {
@@ -983,7 +983,7 @@ class FlightSqlScenarioServer : public sql::FlightSqlServerBase {
       schema = GetQueryWithTransactionSchema().get();
     }
     ARROW_ASSIGN_OR_RAISE(auto handle, sql::CreateStatementQueryTicket(ticket));
-    std::vector<FlightEndpoint> endpoints{FlightEndpoint{{handle}, {}, std::nullopt}};
+    std::vector<FlightEndpoint> endpoints{FlightEndpoint{{handle}, {}, std::nullopt, ""}};
     ARROW_ASSIGN_OR_RAISE(
         auto result, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false));
     return std::make_unique<FlightInfo>(result);
@@ -1008,7 +1008,7 @@ class FlightSqlScenarioServer : public sql::FlightSqlServerBase {
       schema = GetQueryWithTransactionSchema().get();
     }
     ARROW_ASSIGN_OR_RAISE(auto handle, sql::CreateStatementQueryTicket(ticket));
-    std::vector<FlightEndpoint> endpoints{FlightEndpoint{{handle}, {}, std::nullopt}};
+    std::vector<FlightEndpoint> endpoints{FlightEndpoint{{handle}, {}, std::nullopt, ""}};
     ARROW_ASSIGN_OR_RAISE(
         auto result, FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false));
     return std::make_unique<FlightInfo>(result);
@@ -1452,7 +1452,7 @@ class FlightSqlScenarioServer : public sql::FlightSqlServerBase {
   arrow::Result<std::unique_ptr<FlightInfo>> GetFlightInfoForCommand(
       const FlightDescriptor& descriptor, const std::shared_ptr<Schema>& schema) {
     std::vector<FlightEndpoint> endpoints{
-        FlightEndpoint{{descriptor.cmd}, {}, std::nullopt}};
+        FlightEndpoint{{descriptor.cmd}, {}, std::nullopt, ""}};
     ARROW_ASSIGN_OR_RAISE(auto result,
                           FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false))
 
diff --git a/cpp/src/arrow/flight/integration_tests/test_integration_server.cc b/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
index be65edf78d8cb..6f31b82d1a9f4 100644
--- a/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
+++ b/cpp/src/arrow/flight/integration_tests/test_integration_server.cc
@@ -89,7 +89,7 @@ class FlightIntegrationTestServer : public FlightServerBase {
 
       ARROW_ASSIGN_OR_RAISE(auto server_location,
                             Location::ForGrpcTcp("127.0.0.1", port()));
-      FlightEndpoint endpoint1({{request.path[0]}, {server_location}, std::nullopt});
+      FlightEndpoint endpoint1({{request.path[0]}, {server_location}, std::nullopt, ""});
 
       FlightInfo::Data flight_data;
       RETURN_NOT_OK(internal::SchemaToString(*flight.schema, &flight_data.schema));
diff --git a/cpp/src/arrow/flight/sql/example/acero_server.cc b/cpp/src/arrow/flight/sql/example/acero_server.cc
index 27e4c89fdac3e..3f588a741ba79 100644
--- a/cpp/src/arrow/flight/sql/example/acero_server.cc
+++ b/cpp/src/arrow/flight/sql/example/acero_server.cc
@@ -165,8 +165,9 @@ class AceroFlightSqlServer : public FlightSqlServerBase {
   arrow::Result<std::unique_ptr<FlightInfo>> MakeFlightInfo(
       const std::string& plan, const FlightDescriptor& descriptor, const Schema& schema) {
     ARROW_ASSIGN_OR_RAISE(auto ticket, CreateStatementQueryTicket(plan));
-    std::vector<FlightEndpoint> endpoints{FlightEndpoint{
-        Ticket{std::move(ticket)}, /*locations=*/{}, /*expiration_time=*/std::nullopt}};
+    std::vector<FlightEndpoint> endpoints{
+        FlightEndpoint{Ticket{std::move(ticket)}, /*locations=*/{},
+                       /*expiration_time=*/std::nullopt, ""}};
     ARROW_ASSIGN_OR_RAISE(
         auto info,
         FlightInfo::Make(schema, descriptor, std::move(endpoints),
diff --git a/cpp/src/arrow/flight/sql/example/sqlite_server.cc b/cpp/src/arrow/flight/sql/example/sqlite_server.cc
index 2c34eb9164a29..5e1043713295f 100644
--- a/cpp/src/arrow/flight/sql/example/sqlite_server.cc
+++ b/cpp/src/arrow/flight/sql/example/sqlite_server.cc
@@ -126,7 +126,7 @@ arrow::Result<std::unique_ptr<FlightDataStream>> DoGetSQLiteQuery(
 arrow::Result<std::unique_ptr<FlightInfo>> GetFlightInfoForCommand(
     const FlightDescriptor& descriptor, const std::shared_ptr<Schema>& schema) {
   std::vector<FlightEndpoint> endpoints{
-      FlightEndpoint{{descriptor.cmd}, {}, std::nullopt}};
+      FlightEndpoint{{descriptor.cmd}, {}, std::nullopt, ""}};
   ARROW_ASSIGN_OR_RAISE(auto result,
                         FlightInfo::Make(*schema, descriptor, endpoints, -1, -1, false))
 
@@ -305,7 +305,7 @@ class SQLiteFlightSqlServer::Impl {
     ARROW_ASSIGN_OR_RAISE(auto ticket,
                           EncodeTransactionQuery(query, command.transaction_id));
     std::vector<FlightEndpoint> endpoints{
-        FlightEndpoint{std::move(ticket), {}, std::nullopt}};
+        FlightEndpoint{std::move(ticket), {}, std::nullopt, ""}};
     // TODO: Set true only when "ORDER BY" is used in a main "SELECT"
     // in the given query.
     const bool ordered = false;
@@ -389,7 +389,7 @@ class SQLiteFlightSqlServer::Impl {
       const ServerCallContext& context, const GetTables& command,
       const FlightDescriptor& descriptor) {
     std::vector<FlightEndpoint> endpoints{
-        FlightEndpoint{{descriptor.cmd}, {}, std::nullopt}};
+        FlightEndpoint{{descriptor.cmd}, {}, std::nullopt, ""}};
 
     bool include_schema = command.include_schema;
     ARROW_LOG(INFO) << "GetTables include_schema=" << include_schema;

From a2561e3499d8d20c26c118979703425b3e755155 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Thu, 12 Oct 2023 12:15:38 -0300
Subject: [PATCH 545/749] GH-38227: [R] Fix non-unicode character errors in
 nightly builds (#38232)

### Rationale for this change

We have several nightly builds failing with errors building the manual as a result of unicode characters. The unicode characters aren't new, so I'm not sure why this happened now.

### What changes are included in this PR?

Install a distribution of latex that supports unicode characters (maybe)?

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #38227

Lead-authored-by: Dewey Dunnington <dewey@voltrondata.com>
Co-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 r/R/csv.R                 | 4 ++--
 r/man/read_delim_arrow.Rd | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index 11e5b5d808696..1850eb255a480 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -22,8 +22,8 @@
 #' `readr::read_delim()`, and `col_select` was inspired by `vroom::vroom()`.
 #'
 #' `read_csv_arrow()` and `read_tsv_arrow()` are wrappers around
-#' `read_delim_arrow()` that specify a delimiter. `read_csv2_arrow()` uses `;`⁠ for
-#' the delimiter and `,` for the decimal point.
+#' `read_delim_arrow()` that specify a delimeter. `read_csv2_arrow()` uses `;` for
+#' the delimeter and `,` for the decimal point.
 #'
 #' Note that not all `readr` options are currently implemented here. Please file
 #' an issue if you encounter one that `arrow` should support.
diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd
index 04447fefc79b1..3ee9f6ea118a4 100644
--- a/r/man/read_delim_arrow.Rd
+++ b/r/man/read_delim_arrow.Rd
@@ -174,8 +174,8 @@ Arrow C++ options have been mapped to argument names that follow those of
 }
 \details{
 \code{read_csv_arrow()} and \code{read_tsv_arrow()} are wrappers around
-\code{read_delim_arrow()} that specify a delimiter. \code{read_csv2_arrow()} uses \verb{;}⁠ for
-the delimiter and \verb{,} for the decimal point.
+\code{read_delim_arrow()} that specify a delimeter. \code{read_csv2_arrow()} uses \verb{;} for
+the delimeter and \verb{,} for the decimal point.
 
 Note that not all \code{readr} options are currently implemented here. Please file
 an issue if you encounter one that \code{arrow} should support.

From bead40a362766c61bd64ed8a0d5c1569f70cc116 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 12 Oct 2023 12:26:21 -0400
Subject: [PATCH 546/749] MINOR: [Go] Bump golang.org/x/net from 0.15.0 to
 0.17.0 in /go (#38225)

Bumps [golang.org/x/net](https://github.com/golang/net) from 0.15.0 to 0.17.0.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/golang/net/commit/b225e7ca6dde1ef5a5ae5ce922861bda011cfabd"><code>b225e7c</code></a> http2: limit maximum handler goroutines to MaxConcurrentStreams</li>
<li><a href="https://github.com/golang/net/commit/88194ad8ab44a02ea952c169883c3f57db6cf9f4"><code>88194ad</code></a> go.mod: update golang.org/x dependencies</li>
<li><a href="https://github.com/golang/net/commit/2b60a61f1e4cf3a5ecded0bd7e77ea168289e6de"><code>2b60a61</code></a> quic: fix several bugs in flow control accounting</li>
<li><a href="https://github.com/golang/net/commit/73d82efb96cacc0c378bc150b56675fc191894b9"><code>73d82ef</code></a> quic: handle DATA_BLOCKED frames</li>
<li><a href="https://github.com/golang/net/commit/5d5a036a503f8accd748f7453c0162115187be13"><code>5d5a036</code></a> quic: handle streams moving from the data queue to the meta queue</li>
<li><a href="https://github.com/golang/net/commit/350aad2603e57013fafb1a9e2089a382fe67dc80"><code>350aad2</code></a> quic: correctly extend peer's flow control window after MAX_DATA</li>
<li><a href="https://github.com/golang/net/commit/21814e71db756f39b69fb1a3e06350fa555a79b1"><code>21814e7</code></a> quic: validate connection id transport parameters</li>
<li><a href="https://github.com/golang/net/commit/a600b3518eed7a9a4e24380b4b249cb986d9b64d"><code>a600b35</code></a> quic: avoid redundant MAX_DATA updates</li>
<li><a href="https://github.com/golang/net/commit/ea633599b58dc6a50d33c7f5438edfaa8bc313df"><code>ea63359</code></a> http2: check stream body is present on read timeout</li>
<li><a href="https://github.com/golang/net/commit/ddd8598e5694aa5e966e44573a53e895f6fa5eb2"><code>ddd8598</code></a> quic: version negotiation</li>
<li>Additional commits viewable in <a href="https://github.com/golang/net/compare/v0.15.0...v0.17.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=golang.org/x/net&package-manager=go_modules&previous-version=0.15.0&new-version=0.17.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/apache/arrow/network/alerts).

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/go.mod |  4 ++--
 go/go.sum | 14 +++++---------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/go/go.mod b/go/go.mod
index a5581eb3925ca..2f32ff7e42fde 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -36,7 +36,7 @@ require (
 	github.com/zeebo/xxh3 v1.0.2
 	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
 	golang.org/x/sync v0.3.0
-	golang.org/x/sys v0.12.0
+	golang.org/x/sys v0.13.0
 	golang.org/x/tools v0.13.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gonum.org/v1/gonum v0.12.0
@@ -66,7 +66,7 @@ require (
 	github.com/rogpeppe/go-internal v1.9.0 // indirect
 	github.com/stretchr/objx v0.5.0 // indirect
 	golang.org/x/mod v0.12.0 // indirect
-	golang.org/x/net v0.15.0 // indirect
+	golang.org/x/net v0.17.0 // indirect
 	golang.org/x/text v0.13.0 // indirect
 	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go/go.sum b/go/go.sum
index 2a310bf894b8f..1a83f1fa106f5 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -19,11 +19,8 @@ github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+m
 github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs=
 github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
-github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
-github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
-github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goccy/go-yaml v1.11.0 h1:n7Z+zx8S9f9KgzG6KtQKf+kwqXZlLNR2F6018Dgau54=
@@ -53,7 +50,6 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
-github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
@@ -86,20 +82,20 @@ github.com/substrait-io/substrait-go v0.4.2/go.mod h1:qhpnLmrcvAnlZsUyPXZRqldiHa
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
-golang.org/x/crypto v0.13.0 h1:mvySKfSWJ+UKUii46M40LOvyWfN0s2U+46/jDd0e6Ck=
+golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
 golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
 golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/net v0.15.0 h1:ugBLEUaxABaB5AJqW9enI0ACdci2RUd4eP51NTBvuJ8=
-golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
+golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
 golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
+golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
 golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=

From 01b42d51ba97cb12c17e5b001c65b38741ea83ba Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 12 Oct 2023 13:43:17 -0300
Subject: [PATCH 547/749] GH-35497: [C++] Use the latest tagged version of
 flatbuffers (#38192)

### Rationale for this change

To use a more modern version of `flatc` in Arrow.

### What changes are included in this PR?

1) Re-generating the the C++ files with a `flatc` based on the latest tag on the `flatbuffer` repo.
2) Copy the minimal set of includes to our vendored folder
3) Manually re-apply the patches that have been applied to the previous headers to fix issues

### Are these changes tested?

Tested by building everything correctly.
* Closes: #35497

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/generated/File_generated.h            |  102 +-
 cpp/src/generated/Message_generated.h         |  204 +-
 cpp/src/generated/Schema_generated.h          |  816 +++--
 cpp/src/generated/SparseTensor_generated.h    |  238 +-
 cpp/src/generated/Tensor_generated.h          |  113 +-
 cpp/src/generated/feather_generated.h         |  278 +-
 cpp/thirdparty/flatbuffers/README.md          |  506 +++-
 .../include/flatbuffers/allocator.h           |   74 +
 .../flatbuffers/include/flatbuffers/array.h   |  262 ++
 .../flatbuffers/include/flatbuffers/base.h    |  178 +-
 .../flatbuffers/include/flatbuffers/buffer.h  |  205 ++
 .../include/flatbuffers/buffer_ref.h          |   59 +
 .../include/flatbuffers/default_allocator.h   |   70 +
 .../include/flatbuffers/detached_buffer.h     |  120 +
 .../include/flatbuffers/flatbuffer_builder.h  | 1473 ++++++++++
 .../include/flatbuffers/flatbuffers.h         | 2613 +----------------
 .../include/flatbuffers/stl_emulation.h       |  656 +++--
 .../flatbuffers/include/flatbuffers/string.h  |   72 +
 .../flatbuffers/include/flatbuffers/struct.h  |   61 +
 .../flatbuffers/include/flatbuffers/table.h   |  196 ++
 .../flatbuffers/include/flatbuffers/vector.h  |  405 +++
 .../include/flatbuffers/vector_downward.h     |  297 ++
 .../include/flatbuffers/verifier.h            |  340 +++
 23 files changed, 5575 insertions(+), 3763 deletions(-)
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
 create mode 100644 cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h

diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h
index 06953c4a04044..fb2757edf0d97 100644
--- a/cpp/src/generated/File_generated.h
+++ b/cpp/src/generated/File_generated.h
@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 #include "Schema_generated.h"
 
 namespace org {
@@ -26,28 +33,32 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
   int64_t bodyLength_;
 
  public:
-  Block() {
-    memset(static_cast<void *>(this), 0, sizeof(Block));
+  Block()
+      : offset_(0),
+        metaDataLength_(0),
+        padding0__(0),
+        bodyLength_(0) {
+    (void)padding0__;
   }
   Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
-      : offset_(flatbuffers::EndianScalar(_offset)),
-        metaDataLength_(flatbuffers::EndianScalar(_metaDataLength)),
+      : offset_(::flatbuffers::EndianScalar(_offset)),
+        metaDataLength_(::flatbuffers::EndianScalar(_metaDataLength)),
         padding0__(0),
-        bodyLength_(flatbuffers::EndianScalar(_bodyLength)) {
+        bodyLength_(::flatbuffers::EndianScalar(_bodyLength)) {
     (void)padding0__;
   }
   /// Index to the start of the RecordBlock (note this is past the Message header)
   int64_t offset() const {
-    return flatbuffers::EndianScalar(offset_);
+    return ::flatbuffers::EndianScalar(offset_);
   }
   /// Length of the metadata
   int32_t metaDataLength() const {
-    return flatbuffers::EndianScalar(metaDataLength_);
+    return ::flatbuffers::EndianScalar(metaDataLength_);
   }
   /// Length of the data (this is aligned so there can be a gap between this and
   /// the metadata).
   int64_t bodyLength() const {
-    return flatbuffers::EndianScalar(bodyLength_);
+    return ::flatbuffers::EndianScalar(bodyLength_);
   }
 };
 FLATBUFFERS_STRUCT_END(Block, 24);
@@ -55,7 +66,7 @@ FLATBUFFERS_STRUCT_END(Block, 24);
 /// ----------------------------------------------------------------------
 /// Arrow File metadata
 ///
-struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Footer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef FooterBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_VERSION = 4,
@@ -70,19 +81,19 @@ struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::Schema *schema() const {
     return GetPointer<const org::apache::arrow::flatbuf::Schema *>(VT_SCHEMA);
   }
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *dictionaries() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *>(VT_DICTIONARIES);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *dictionaries() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *>(VT_DICTIONARIES);
   }
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *recordBatches() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *>(VT_RECORDBATCHES);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *recordBatches() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *> *>(VT_RECORDBATCHES);
   }
   /// User-defined metadata
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_VERSION) &&
+           VerifyField<int16_t>(verifier, VT_VERSION, 2) &&
            VerifyOffset(verifier, VT_SCHEMA) &&
            verifier.VerifyTable(schema()) &&
            VerifyOffset(verifier, VT_DICTIONARIES) &&
@@ -98,42 +109,41 @@ struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct FooterBuilder {
   typedef Footer Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_version(org::apache::arrow::flatbuf::MetadataVersion version) {
     fbb_.AddElement<int16_t>(Footer::VT_VERSION, static_cast<int16_t>(version), 0);
   }
-  void add_schema(flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema) {
+  void add_schema(::flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema) {
     fbb_.AddOffset(Footer::VT_SCHEMA, schema);
   }
-  void add_dictionaries(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> dictionaries) {
+  void add_dictionaries(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> dictionaries) {
     fbb_.AddOffset(Footer::VT_DICTIONARIES, dictionaries);
   }
-  void add_recordBatches(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> recordBatches) {
+  void add_recordBatches(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> recordBatches) {
     fbb_.AddOffset(Footer::VT_RECORDBATCHES, recordBatches);
   }
-  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
+  void add_custom_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
     fbb_.AddOffset(Footer::VT_CUSTOM_METADATA, custom_metadata);
   }
-  explicit FooterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit FooterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FooterBuilder &operator=(const FooterBuilder &);
-  flatbuffers::Offset<Footer> Finish() {
+  ::flatbuffers::Offset<Footer> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Footer>(end);
+    auto o = ::flatbuffers::Offset<Footer>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Footer> CreateFooter(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Footer> CreateFooter(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> dictionaries = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> recordBatches = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> dictionaries = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Block *>> recordBatches = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
   FooterBuilder builder_(_fbb);
   builder_.add_custom_metadata(custom_metadata);
   builder_.add_recordBatches(recordBatches);
@@ -143,16 +153,16 @@ inline flatbuffers::Offset<Footer> CreateFooter(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Footer> CreateFooterDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Footer> CreateFooterDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> schema = 0,
     const std::vector<org::apache::arrow::flatbuf::Block> *dictionaries = nullptr,
     const std::vector<org::apache::arrow::flatbuf::Block> *recordBatches = nullptr,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
   auto dictionaries__ = dictionaries ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Block>(*dictionaries) : 0;
   auto recordBatches__ = recordBatches ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Block>(*recordBatches) : 0;
-  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
   return org::apache::arrow::flatbuf::CreateFooter(
       _fbb,
       version,
@@ -163,32 +173,32 @@ inline flatbuffers::Offset<Footer> CreateFooterDirect(
 }
 
 inline const org::apache::arrow::flatbuf::Footer *GetFooter(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Footer>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::Footer>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::Footer *GetSizePrefixedFooter(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Footer>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Footer>(buf);
 }
 
 inline bool VerifyFooterBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Footer>(nullptr);
 }
 
 inline bool VerifySizePrefixedFooterBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Footer>(nullptr);
 }
 
 inline void FinishFooterBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedFooterBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/src/generated/Message_generated.h b/cpp/src/generated/Message_generated.h
index 55c6f33769381..8db692fd041de 100644
--- a/cpp/src/generated/Message_generated.h
+++ b/cpp/src/generated/Message_generated.h
@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 #include "Schema_generated.h"
 #include "SparseTensor_generated.h"
 #include "Tensor_generated.h"
@@ -54,7 +61,7 @@ inline const char * const *EnumNamesCompressionType() {
 }
 
 inline const char *EnumNameCompressionType(CompressionType e) {
-  if (flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::ZSTD)) return "";
+  if (::flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::ZSTD)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesCompressionType()[index];
 }
@@ -91,7 +98,7 @@ inline const char * const *EnumNamesBodyCompressionMethod() {
 }
 
 inline const char *EnumNameBodyCompressionMethod(BodyCompressionMethod e) {
-  if (flatbuffers::IsOutRange(e, BodyCompressionMethod::BUFFER, BodyCompressionMethod::BUFFER)) return "";
+  if (::flatbuffers::IsOutRange(e, BodyCompressionMethod::BUFFER, BodyCompressionMethod::BUFFER)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesBodyCompressionMethod()[index];
 }
@@ -141,7 +148,7 @@ inline const char * const *EnumNamesMessageHeader() {
 }
 
 inline const char *EnumNameMessageHeader(MessageHeader e) {
-  if (flatbuffers::IsOutRange(e, MessageHeader::NONE, MessageHeader::SparseTensor)) return "";
+  if (::flatbuffers::IsOutRange(e, MessageHeader::NONE, MessageHeader::SparseTensor)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesMessageHeader()[index];
 }
@@ -170,8 +177,8 @@ template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::SparseTensor>
   static const MessageHeader enum_value = MessageHeader::SparseTensor;
 };
 
-bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type);
-bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyMessageHeader(::flatbuffers::Verifier &verifier, const void *obj, MessageHeader type);
+bool VerifyMessageHeaderVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<MessageHeader> *types);
 
 /// ----------------------------------------------------------------------
 /// Data structures for describing a table row batch (a collection of
@@ -188,23 +195,24 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
   int64_t null_count_;
 
  public:
-  FieldNode() {
-    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
+  FieldNode()
+      : length_(0),
+        null_count_(0) {
   }
   FieldNode(int64_t _length, int64_t _null_count)
-      : length_(flatbuffers::EndianScalar(_length)),
-        null_count_(flatbuffers::EndianScalar(_null_count)) {
+      : length_(::flatbuffers::EndianScalar(_length)),
+        null_count_(::flatbuffers::EndianScalar(_null_count)) {
   }
   /// The number of value slots in the Arrow array at this level of a nested
   /// tree
   int64_t length() const {
-    return flatbuffers::EndianScalar(length_);
+    return ::flatbuffers::EndianScalar(length_);
   }
   /// The number of observed nulls. Fields with null_count == 0 may choose not
   /// to write their physical validity bitmap out as a materialized buffer,
   /// instead setting the length of the bitmap buffer to 0.
   int64_t null_count() const {
-    return flatbuffers::EndianScalar(null_count_);
+    return ::flatbuffers::EndianScalar(null_count_);
   }
 };
 FLATBUFFERS_STRUCT_END(FieldNode, 16);
@@ -212,7 +220,7 @@ FLATBUFFERS_STRUCT_END(FieldNode, 16);
 /// Optional compression for the memory buffers constituting IPC message
 /// bodies. Intended for use with RecordBatch but could be used for other
 /// message types
-struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct BodyCompression FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef BodyCompressionBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_CODEC = 4,
@@ -227,38 +235,37 @@ struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::BodyCompressionMethod method() const {
     return static_cast<org::apache::arrow::flatbuf::BodyCompressionMethod>(GetField<int8_t>(VT_METHOD, 0));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int8_t>(verifier, VT_CODEC) &&
-           VerifyField<int8_t>(verifier, VT_METHOD) &&
+           VerifyField<int8_t>(verifier, VT_CODEC, 1) &&
+           VerifyField<int8_t>(verifier, VT_METHOD, 1) &&
            verifier.EndTable();
   }
 };
 
 struct BodyCompressionBuilder {
   typedef BodyCompression Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_codec(org::apache::arrow::flatbuf::CompressionType codec) {
     fbb_.AddElement<int8_t>(BodyCompression::VT_CODEC, static_cast<int8_t>(codec), 0);
   }
   void add_method(org::apache::arrow::flatbuf::BodyCompressionMethod method) {
     fbb_.AddElement<int8_t>(BodyCompression::VT_METHOD, static_cast<int8_t>(method), 0);
   }
-  explicit BodyCompressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit BodyCompressionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BodyCompressionBuilder &operator=(const BodyCompressionBuilder &);
-  flatbuffers::Offset<BodyCompression> Finish() {
+  ::flatbuffers::Offset<BodyCompression> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<BodyCompression>(end);
+    auto o = ::flatbuffers::Offset<BodyCompression>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<BodyCompression> CreateBodyCompression(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<BodyCompression> CreateBodyCompression(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::CompressionType codec = org::apache::arrow::flatbuf::CompressionType::LZ4_FRAME,
     org::apache::arrow::flatbuf::BodyCompressionMethod method = org::apache::arrow::flatbuf::BodyCompressionMethod::BUFFER) {
   BodyCompressionBuilder builder_(_fbb);
@@ -270,7 +277,7 @@ inline flatbuffers::Offset<BodyCompression> CreateBodyCompression(
 /// A data header describing the shared memory layout of a "record" or "row"
 /// batch. Some systems call this a "row batch" internally and others a "record
 /// batch".
-struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct RecordBatch FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef RecordBatchBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_LENGTH = 4,
@@ -285,8 +292,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return GetField<int64_t>(VT_LENGTH, 0);
   }
   /// Nodes correspond to the pre-ordered flattened logical schema
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *nodes() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *>(VT_NODES);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *nodes() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *>(VT_NODES);
   }
   /// Buffers correspond to the pre-ordered flattened buffer tree
   ///
@@ -294,8 +301,8 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   /// example, most primitive arrays will have 2 buffers, 1 for the validity
   /// bitmap and 1 for the values. For struct arrays, there will only be a
   /// single buffer for the validity (nulls) bitmap
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *buffers() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_BUFFERS);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *buffers() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_BUFFERS);
   }
   /// Optional compression of the message body
   const org::apache::arrow::flatbuf::BodyCompression *compression() const {
@@ -315,12 +322,12 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   ///
   /// This field may be omitted if and only if the schema contains no Fields with
   /// a variable number of buffers, such as BinaryView and Utf8View.
-  const flatbuffers::Vector<int64_t> *variadicBufferCounts() const {
-    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_VARIADICBUFFERCOUNTS);
+  const ::flatbuffers::Vector<int64_t> *variadicBufferCounts() const {
+    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VARIADICBUFFERCOUNTS);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int64_t>(verifier, VT_LENGTH) &&
+           VerifyField<int64_t>(verifier, VT_LENGTH, 8) &&
            VerifyOffset(verifier, VT_NODES) &&
            verifier.VerifyVector(nodes()) &&
            VerifyOffset(verifier, VT_BUFFERS) &&
@@ -335,42 +342,41 @@ struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct RecordBatchBuilder {
   typedef RecordBatch Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_length(int64_t length) {
     fbb_.AddElement<int64_t>(RecordBatch::VT_LENGTH, length, 0);
   }
-  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes) {
+  void add_nodes(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes) {
     fbb_.AddOffset(RecordBatch::VT_NODES, nodes);
   }
-  void add_buffers(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers) {
+  void add_buffers(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers) {
     fbb_.AddOffset(RecordBatch::VT_BUFFERS, buffers);
   }
-  void add_compression(flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) {
+  void add_compression(::flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) {
     fbb_.AddOffset(RecordBatch::VT_COMPRESSION, compression);
   }
-  void add_variadicBufferCounts(flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicBufferCounts) {
+  void add_variadicBufferCounts(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variadicBufferCounts) {
     fbb_.AddOffset(RecordBatch::VT_VARIADICBUFFERCOUNTS, variadicBufferCounts);
   }
-  explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit RecordBatchBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  RecordBatchBuilder &operator=(const RecordBatchBuilder &);
-  flatbuffers::Offset<RecordBatch> Finish() {
+  ::flatbuffers::Offset<RecordBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<RecordBatch>(end);
+    auto o = ::flatbuffers::Offset<RecordBatch>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<RecordBatch> CreateRecordBatch(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t length = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int64_t>> variadicBufferCounts = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variadicBufferCounts = 0) {
   RecordBatchBuilder builder_(_fbb);
   builder_.add_length(length);
   builder_.add_variadicBufferCounts(variadicBufferCounts);
@@ -380,12 +386,12 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t length = 0,
     const std::vector<org::apache::arrow::flatbuf::FieldNode> *nodes = nullptr,
     const std::vector<org::apache::arrow::flatbuf::Buffer> *buffers = nullptr,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0,
     const std::vector<int64_t> *variadicBufferCounts = nullptr) {
   auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::FieldNode>(*nodes) : 0;
   auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*buffers) : 0;
@@ -405,7 +411,7 @@ inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
 /// There is one vector / column per dictionary, but that vector / column
 /// may be spread across multiple dictionary batches by using the isDelta
 /// flag
-struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DictionaryBatchBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ID = 4,
@@ -424,45 +430,44 @@ struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool isDelta() const {
     return GetField<uint8_t>(VT_ISDELTA, 0) != 0;
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int64_t>(verifier, VT_ID) &&
+           VerifyField<int64_t>(verifier, VT_ID, 8) &&
            VerifyOffset(verifier, VT_DATA) &&
            verifier.VerifyTable(data()) &&
-           VerifyField<uint8_t>(verifier, VT_ISDELTA) &&
+           VerifyField<uint8_t>(verifier, VT_ISDELTA, 1) &&
            verifier.EndTable();
   }
 };
 
 struct DictionaryBatchBuilder {
   typedef DictionaryBatch Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_id(int64_t id) {
     fbb_.AddElement<int64_t>(DictionaryBatch::VT_ID, id, 0);
   }
-  void add_data(flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data) {
+  void add_data(::flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data) {
     fbb_.AddOffset(DictionaryBatch::VT_DATA, data);
   }
   void add_isDelta(bool isDelta) {
     fbb_.AddElement<uint8_t>(DictionaryBatch::VT_ISDELTA, static_cast<uint8_t>(isDelta), 0);
   }
-  explicit DictionaryBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DictionaryBatchBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &);
-  flatbuffers::Offset<DictionaryBatch> Finish() {
+  ::flatbuffers::Offset<DictionaryBatch> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<DictionaryBatch>(end);
+    auto o = ::flatbuffers::Offset<DictionaryBatch>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t id = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data = 0,
     bool isDelta = false) {
   DictionaryBatchBuilder builder_(_fbb);
   builder_.add_id(id);
@@ -471,7 +476,7 @@ inline flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch(
   return builder_.Finish();
 }
 
-struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Message FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef MessageBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_VERSION = 4,
@@ -508,16 +513,16 @@ struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int64_t bodyLength() const {
     return GetField<int64_t>(VT_BODYLENGTH, 0);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_VERSION) &&
-           VerifyField<uint8_t>(verifier, VT_HEADER_TYPE) &&
+           VerifyField<int16_t>(verifier, VT_VERSION, 2) &&
+           VerifyField<uint8_t>(verifier, VT_HEADER_TYPE, 1) &&
            VerifyOffset(verifier, VT_HEADER) &&
            VerifyMessageHeader(verifier, header(), header_type()) &&
-           VerifyField<int64_t>(verifier, VT_BODYLENGTH) &&
+           VerifyField<int64_t>(verifier, VT_BODYLENGTH, 8) &&
            VerifyOffset(verifier, VT_CUSTOM_METADATA) &&
            verifier.VerifyVector(custom_metadata()) &&
            verifier.VerifyVectorOfTables(custom_metadata()) &&
@@ -547,42 +552,41 @@ template<> inline const org::apache::arrow::flatbuf::SparseTensor *Message::head
 
 struct MessageBuilder {
   typedef Message Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_version(org::apache::arrow::flatbuf::MetadataVersion version) {
     fbb_.AddElement<int16_t>(Message::VT_VERSION, static_cast<int16_t>(version), 0);
   }
   void add_header_type(org::apache::arrow::flatbuf::MessageHeader header_type) {
     fbb_.AddElement<uint8_t>(Message::VT_HEADER_TYPE, static_cast<uint8_t>(header_type), 0);
   }
-  void add_header(flatbuffers::Offset<void> header) {
+  void add_header(::flatbuffers::Offset<void> header) {
     fbb_.AddOffset(Message::VT_HEADER, header);
   }
   void add_bodyLength(int64_t bodyLength) {
     fbb_.AddElement<int64_t>(Message::VT_BODYLENGTH, bodyLength, 0);
   }
-  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
+  void add_custom_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
     fbb_.AddOffset(Message::VT_CUSTOM_METADATA, custom_metadata);
   }
-  explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit MessageBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  MessageBuilder &operator=(const MessageBuilder &);
-  flatbuffers::Offset<Message> Finish() {
+  ::flatbuffers::Offset<Message> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Message>(end);
+    auto o = ::flatbuffers::Offset<Message>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Message> CreateMessage(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Message> CreateMessage(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
     org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE,
-    flatbuffers::Offset<void> header = 0,
+    ::flatbuffers::Offset<void> header = 0,
     int64_t bodyLength = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
   MessageBuilder builder_(_fbb);
   builder_.add_bodyLength(bodyLength);
   builder_.add_custom_metadata(custom_metadata);
@@ -592,14 +596,14 @@ inline flatbuffers::Offset<Message> CreateMessage(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Message> CreateMessageDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Message> CreateMessageDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
     org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE,
-    flatbuffers::Offset<void> header = 0,
+    ::flatbuffers::Offset<void> header = 0,
     int64_t bodyLength = 0,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
-  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
   return org::apache::arrow::flatbuf::CreateMessage(
       _fbb,
       version,
@@ -609,7 +613,7 @@ inline flatbuffers::Offset<Message> CreateMessageDirect(
       custom_metadata__);
 }
 
-inline bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type) {
+inline bool VerifyMessageHeader(::flatbuffers::Verifier &verifier, const void *obj, MessageHeader type) {
   switch (type) {
     case MessageHeader::NONE: {
       return true;
@@ -638,10 +642,10 @@ inline bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj
   }
 }
 
-inline bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyMessageHeaderVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<MessageHeader> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
-  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
     if (!VerifyMessageHeader(
         verifier,  values->Get(i), types->GetEnum<MessageHeader>(i))) {
       return false;
@@ -651,32 +655,32 @@ inline bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const fla
 }
 
 inline const org::apache::arrow::flatbuf::Message *GetMessage(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Message>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::Message>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::Message *GetSizePrefixedMessage(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Message>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Message>(buf);
 }
 
 inline bool VerifyMessageBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
 }
 
 inline bool VerifySizePrefixedMessageBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
 }
 
 inline void FinishMessageBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedMessageBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/src/generated/Schema_generated.h b/cpp/src/generated/Schema_generated.h
index a8165f0a89903..eeeeac68f0a45 100644
--- a/cpp/src/generated/Schema_generated.h
+++ b/cpp/src/generated/Schema_generated.h
@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 namespace org {
 namespace apache {
 namespace arrow {
@@ -148,7 +155,7 @@ inline const char * const *EnumNamesMetadataVersion() {
 }
 
 inline const char *EnumNameMetadataVersion(MetadataVersion e) {
-  if (flatbuffers::IsOutRange(e, MetadataVersion::V1, MetadataVersion::V5)) return "";
+  if (::flatbuffers::IsOutRange(e, MetadataVersion::V1, MetadataVersion::V5)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesMetadataVersion()[index];
 }
@@ -204,7 +211,7 @@ inline const char * const *EnumNamesFeature() {
 }
 
 inline const char *EnumNameFeature(Feature e) {
-  if (flatbuffers::IsOutRange(e, Feature::UNUSED, Feature::COMPRESSED_BODY)) return "";
+  if (::flatbuffers::IsOutRange(e, Feature::UNUSED, Feature::COMPRESSED_BODY)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesFeature()[index];
 }
@@ -234,7 +241,7 @@ inline const char * const *EnumNamesUnionMode() {
 }
 
 inline const char *EnumNameUnionMode(UnionMode e) {
-  if (flatbuffers::IsOutRange(e, UnionMode::Sparse, UnionMode::Dense)) return "";
+  if (::flatbuffers::IsOutRange(e, UnionMode::Sparse, UnionMode::Dense)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesUnionMode()[index];
 }
@@ -267,7 +274,7 @@ inline const char * const *EnumNamesPrecision() {
 }
 
 inline const char *EnumNamePrecision(Precision e) {
-  if (flatbuffers::IsOutRange(e, Precision::HALF, Precision::DOUBLE)) return "";
+  if (::flatbuffers::IsOutRange(e, Precision::HALF, Precision::DOUBLE)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesPrecision()[index];
 }
@@ -297,7 +304,7 @@ inline const char * const *EnumNamesDateUnit() {
 }
 
 inline const char *EnumNameDateUnit(DateUnit e) {
-  if (flatbuffers::IsOutRange(e, DateUnit::DAY, DateUnit::MILLISECOND)) return "";
+  if (::flatbuffers::IsOutRange(e, DateUnit::DAY, DateUnit::MILLISECOND)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesDateUnit()[index];
 }
@@ -333,7 +340,7 @@ inline const char * const *EnumNamesTimeUnit() {
 }
 
 inline const char *EnumNameTimeUnit(TimeUnit e) {
-  if (flatbuffers::IsOutRange(e, TimeUnit::SECOND, TimeUnit::NANOSECOND)) return "";
+  if (::flatbuffers::IsOutRange(e, TimeUnit::SECOND, TimeUnit::NANOSECOND)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesTimeUnit()[index];
 }
@@ -366,7 +373,7 @@ inline const char * const *EnumNamesIntervalUnit() {
 }
 
 inline const char *EnumNameIntervalUnit(IntervalUnit e) {
-  if (flatbuffers::IsOutRange(e, IntervalUnit::YEAR_MONTH, IntervalUnit::MONTH_DAY_NANO)) return "";
+  if (::flatbuffers::IsOutRange(e, IntervalUnit::YEAR_MONTH, IntervalUnit::MONTH_DAY_NANO)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesIntervalUnit()[index];
 }
@@ -474,7 +481,7 @@ inline const char * const *EnumNamesType() {
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::NONE, Type::LargeListView)) return "";
+  if (::flatbuffers::IsOutRange(e, Type::NONE, Type::LargeListView)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -587,8 +594,8 @@ template<> struct TypeTraits<org::apache::arrow::flatbuf::LargeListView> {
   static const Type enum_value = Type::LargeListView;
 };
 
-bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type);
-bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyType(::flatbuffers::Verifier &verifier, const void *obj, Type type);
+bool VerifyTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Type> *types);
 
 /// ----------------------------------------------------------------------
 /// Dictionary encoding metadata
@@ -617,7 +624,7 @@ inline const char * const *EnumNamesDictionaryKind() {
 }
 
 inline const char *EnumNameDictionaryKind(DictionaryKind e) {
-  if (flatbuffers::IsOutRange(e, DictionaryKind::DenseArray, DictionaryKind::DenseArray)) return "";
+  if (::flatbuffers::IsOutRange(e, DictionaryKind::DenseArray, DictionaryKind::DenseArray)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesDictionaryKind()[index];
 }
@@ -649,7 +656,7 @@ inline const char * const *EnumNamesEndianness() {
 }
 
 inline const char *EnumNameEndianness(Endianness e) {
-  if (flatbuffers::IsOutRange(e, Endianness::Little, Endianness::Big)) return "";
+  if (::flatbuffers::IsOutRange(e, Endianness::Little, Endianness::Big)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesEndianness()[index];
 }
@@ -662,17 +669,18 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   int64_t length_;
 
  public:
-  Buffer() {
-    memset(static_cast<void *>(this), 0, sizeof(Buffer));
+  Buffer()
+      : offset_(0),
+        length_(0) {
   }
   Buffer(int64_t _offset, int64_t _length)
-      : offset_(flatbuffers::EndianScalar(_offset)),
-        length_(flatbuffers::EndianScalar(_length)) {
+      : offset_(::flatbuffers::EndianScalar(_offset)),
+        length_(::flatbuffers::EndianScalar(_length)) {
   }
   /// The relative offset into the shared memory page where the bytes for this
   /// buffer starts
   int64_t offset() const {
-    return flatbuffers::EndianScalar(offset_);
+    return ::flatbuffers::EndianScalar(offset_);
   }
   /// The absolute length (in bytes) of the memory buffer. The memory is found
   /// from offset (inclusive) to offset + length (non-inclusive). When building
@@ -680,15 +688,15 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   /// after a buffer, but such padding bytes do not need to be accounted for in
   /// the size here.
   int64_t length() const {
-    return flatbuffers::EndianScalar(length_);
+    return ::flatbuffers::EndianScalar(length_);
   }
 };
 FLATBUFFERS_STRUCT_END(Buffer, 16);
 
 /// These are stored in the flatbuffer in the Type union below
-struct Null FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Null FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef NullBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -696,22 +704,21 @@ struct Null FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct NullBuilder {
   typedef Null Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit NullBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit NullBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  NullBuilder &operator=(const NullBuilder &);
-  flatbuffers::Offset<Null> Finish() {
+  ::flatbuffers::Offset<Null> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Null>(end);
+    auto o = ::flatbuffers::Offset<Null>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Null> CreateNull(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Null> CreateNull(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   NullBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -719,9 +726,9 @@ inline flatbuffers::Offset<Null> CreateNull(
 /// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
 /// (according to the physical memory layout). We used Struct_ here as
 /// Struct is a reserved word in Flatbuffers
-struct Struct_ FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Struct_ FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef Struct_Builder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -729,29 +736,28 @@ struct Struct_ FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct Struct_Builder {
   typedef Struct_ Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit Struct_Builder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit Struct_Builder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  Struct_Builder &operator=(const Struct_Builder &);
-  flatbuffers::Offset<Struct_> Finish() {
+  ::flatbuffers::Offset<Struct_> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Struct_>(end);
+    auto o = ::flatbuffers::Offset<Struct_>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Struct_> CreateStruct_(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Struct_> CreateStruct_(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   Struct_Builder builder_(_fbb);
   return builder_.Finish();
 }
 
-struct List FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct List FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ListBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -759,31 +765,30 @@ struct List FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct ListBuilder {
   typedef List Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit ListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit ListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ListBuilder &operator=(const ListBuilder &);
-  flatbuffers::Offset<List> Finish() {
+  ::flatbuffers::Offset<List> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<List>(end);
+    auto o = ::flatbuffers::Offset<List>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<List> CreateList(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<List> CreateList(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   ListBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
 /// Same as List, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
-struct LargeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct LargeList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef LargeListBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -791,22 +796,21 @@ struct LargeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct LargeListBuilder {
   typedef LargeList Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit LargeListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit LargeListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeListBuilder &operator=(const LargeListBuilder &);
-  flatbuffers::Offset<LargeList> Finish() {
+  ::flatbuffers::Offset<LargeList> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<LargeList>(end);
+    auto o = ::flatbuffers::Offset<LargeList>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<LargeList> CreateLargeList(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LargeList> CreateLargeList(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   LargeListBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -814,9 +818,9 @@ inline flatbuffers::Offset<LargeList> CreateLargeList(
 /// Represents the same logical types that List can, but contains offsets and
 /// sizes allowing for writes in any order and sharing of child values among
 /// list values.
-struct ListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct ListView FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ListViewBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -824,31 +828,30 @@ struct ListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct ListViewBuilder {
   typedef ListView Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit ListViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit ListViewBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ListViewBuilder &operator=(const ListViewBuilder &);
-  flatbuffers::Offset<ListView> Finish() {
+  ::flatbuffers::Offset<ListView> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<ListView>(end);
+    auto o = ::flatbuffers::Offset<ListView>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<ListView> CreateListView(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<ListView> CreateListView(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   ListViewBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
 /// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
 /// extremely large data values.
-struct LargeListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct LargeListView FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef LargeListViewBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -856,27 +859,26 @@ struct LargeListView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct LargeListViewBuilder {
   typedef LargeListView Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit LargeListViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit LargeListViewBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeListViewBuilder &operator=(const LargeListViewBuilder &);
-  flatbuffers::Offset<LargeListView> Finish() {
+  ::flatbuffers::Offset<LargeListView> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<LargeListView>(end);
+    auto o = ::flatbuffers::Offset<LargeListView>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<LargeListView> CreateLargeListView(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LargeListView> CreateLargeListView(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   LargeListViewBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
-struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef FixedSizeListBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_LISTSIZE = 4
@@ -885,34 +887,33 @@ struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t listSize() const {
     return GetField<int32_t>(VT_LISTSIZE, 0);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int32_t>(verifier, VT_LISTSIZE) &&
+           VerifyField<int32_t>(verifier, VT_LISTSIZE, 4) &&
            verifier.EndTable();
   }
 };
 
 struct FixedSizeListBuilder {
   typedef FixedSizeList Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_listSize(int32_t listSize) {
     fbb_.AddElement<int32_t>(FixedSizeList::VT_LISTSIZE, listSize, 0);
   }
-  explicit FixedSizeListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit FixedSizeListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FixedSizeListBuilder &operator=(const FixedSizeListBuilder &);
-  flatbuffers::Offset<FixedSizeList> Finish() {
+  ::flatbuffers::Offset<FixedSizeList> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<FixedSizeList>(end);
+    auto o = ::flatbuffers::Offset<FixedSizeList>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<FixedSizeList> CreateFixedSizeList(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<FixedSizeList> CreateFixedSizeList(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t listSize = 0) {
   FixedSizeListBuilder builder_(_fbb);
   builder_.add_listSize(listSize);
@@ -944,7 +945,7 @@ inline flatbuffers::Offset<FixedSizeList> CreateFixedSizeList(
 /// The metadata is structured so that Arrow systems without special handling
 /// for Map can make Map an alias for List. The "layout" attribute for the Map
 /// field must have the same contents as a List.
-struct Map FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Map FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef MapBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_KEYSSORTED = 4
@@ -953,34 +954,33 @@ struct Map FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool keysSorted() const {
     return GetField<uint8_t>(VT_KEYSSORTED, 0) != 0;
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<uint8_t>(verifier, VT_KEYSSORTED) &&
+           VerifyField<uint8_t>(verifier, VT_KEYSSORTED, 1) &&
            verifier.EndTable();
   }
 };
 
 struct MapBuilder {
   typedef Map Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_keysSorted(bool keysSorted) {
     fbb_.AddElement<uint8_t>(Map::VT_KEYSSORTED, static_cast<uint8_t>(keysSorted), 0);
   }
-  explicit MapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit MapBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  MapBuilder &operator=(const MapBuilder &);
-  flatbuffers::Offset<Map> Finish() {
+  ::flatbuffers::Offset<Map> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Map>(end);
+    auto o = ::flatbuffers::Offset<Map>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Map> CreateMap(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Map> CreateMap(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     bool keysSorted = false) {
   MapBuilder builder_(_fbb);
   builder_.add_keysSorted(keysSorted);
@@ -991,7 +991,7 @@ inline flatbuffers::Offset<Map> CreateMap(
 /// By default ids in the type vector refer to the offsets in the children
 /// optionally typeIds provides an indirection between the child offset and the type id
 /// for each child `typeIds[offset]` is the id used in the type vector
-struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Union FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef UnionBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_MODE = 4,
@@ -1000,12 +1000,12 @@ struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::UnionMode mode() const {
     return static_cast<org::apache::arrow::flatbuf::UnionMode>(GetField<int16_t>(VT_MODE, 0));
   }
-  const flatbuffers::Vector<int32_t> *typeIds() const {
-    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TYPEIDS);
+  const ::flatbuffers::Vector<int32_t> *typeIds() const {
+    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_TYPEIDS);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_MODE) &&
+           VerifyField<int16_t>(verifier, VT_MODE, 2) &&
            VerifyOffset(verifier, VT_TYPEIDS) &&
            verifier.VerifyVector(typeIds()) &&
            verifier.EndTable();
@@ -1014,38 +1014,37 @@ struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct UnionBuilder {
   typedef Union Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_mode(org::apache::arrow::flatbuf::UnionMode mode) {
     fbb_.AddElement<int16_t>(Union::VT_MODE, static_cast<int16_t>(mode), 0);
   }
-  void add_typeIds(flatbuffers::Offset<flatbuffers::Vector<int32_t>> typeIds) {
+  void add_typeIds(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> typeIds) {
     fbb_.AddOffset(Union::VT_TYPEIDS, typeIds);
   }
-  explicit UnionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit UnionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  UnionBuilder &operator=(const UnionBuilder &);
-  flatbuffers::Offset<Union> Finish() {
+  ::flatbuffers::Offset<Union> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Union>(end);
+    auto o = ::flatbuffers::Offset<Union>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Union> CreateUnion(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Union> CreateUnion(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::UnionMode mode = org::apache::arrow::flatbuf::UnionMode::Sparse,
-    flatbuffers::Offset<flatbuffers::Vector<int32_t>> typeIds = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> typeIds = 0) {
   UnionBuilder builder_(_fbb);
   builder_.add_typeIds(typeIds);
   builder_.add_mode(mode);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Union> CreateUnionDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Union> CreateUnionDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::UnionMode mode = org::apache::arrow::flatbuf::UnionMode::Sparse,
     const std::vector<int32_t> *typeIds = nullptr) {
   auto typeIds__ = typeIds ? _fbb.CreateVector<int32_t>(*typeIds) : 0;
@@ -1055,7 +1054,7 @@ inline flatbuffers::Offset<Union> CreateUnionDirect(
       typeIds__);
 }
 
-struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Int FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef IntBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_BITWIDTH = 4,
@@ -1067,38 +1066,37 @@ struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool is_signed() const {
     return GetField<uint8_t>(VT_IS_SIGNED, 0) != 0;
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int32_t>(verifier, VT_BITWIDTH) &&
-           VerifyField<uint8_t>(verifier, VT_IS_SIGNED) &&
+           VerifyField<int32_t>(verifier, VT_BITWIDTH, 4) &&
+           VerifyField<uint8_t>(verifier, VT_IS_SIGNED, 1) &&
            verifier.EndTable();
   }
 };
 
 struct IntBuilder {
   typedef Int Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_bitWidth(int32_t bitWidth) {
     fbb_.AddElement<int32_t>(Int::VT_BITWIDTH, bitWidth, 0);
   }
   void add_is_signed(bool is_signed) {
     fbb_.AddElement<uint8_t>(Int::VT_IS_SIGNED, static_cast<uint8_t>(is_signed), 0);
   }
-  explicit IntBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit IntBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  IntBuilder &operator=(const IntBuilder &);
-  flatbuffers::Offset<Int> Finish() {
+  ::flatbuffers::Offset<Int> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Int>(end);
+    auto o = ::flatbuffers::Offset<Int>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Int> CreateInt(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Int> CreateInt(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t bitWidth = 0,
     bool is_signed = false) {
   IntBuilder builder_(_fbb);
@@ -1107,7 +1105,7 @@ inline flatbuffers::Offset<Int> CreateInt(
   return builder_.Finish();
 }
 
-struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef FloatingPointBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_PRECISION = 4
@@ -1115,34 +1113,33 @@ struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::Precision precision() const {
     return static_cast<org::apache::arrow::flatbuf::Precision>(GetField<int16_t>(VT_PRECISION, 0));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_PRECISION) &&
+           VerifyField<int16_t>(verifier, VT_PRECISION, 2) &&
            verifier.EndTable();
   }
 };
 
 struct FloatingPointBuilder {
   typedef FloatingPoint Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_precision(org::apache::arrow::flatbuf::Precision precision) {
     fbb_.AddElement<int16_t>(FloatingPoint::VT_PRECISION, static_cast<int16_t>(precision), 0);
   }
-  explicit FloatingPointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit FloatingPointBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FloatingPointBuilder &operator=(const FloatingPointBuilder &);
-  flatbuffers::Offset<FloatingPoint> Finish() {
+  ::flatbuffers::Offset<FloatingPoint> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<FloatingPoint>(end);
+    auto o = ::flatbuffers::Offset<FloatingPoint>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<FloatingPoint> CreateFloatingPoint(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<FloatingPoint> CreateFloatingPoint(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Precision precision = org::apache::arrow::flatbuf::Precision::HALF) {
   FloatingPointBuilder builder_(_fbb);
   builder_.add_precision(precision);
@@ -1150,9 +1147,9 @@ inline flatbuffers::Offset<FloatingPoint> CreateFloatingPoint(
 }
 
 /// Unicode with UTF-8 encoding
-struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Utf8 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef Utf8Builder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1160,30 +1157,29 @@ struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct Utf8Builder {
   typedef Utf8 Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit Utf8Builder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit Utf8Builder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  Utf8Builder &operator=(const Utf8Builder &);
-  flatbuffers::Offset<Utf8> Finish() {
+  ::flatbuffers::Offset<Utf8> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Utf8>(end);
+    auto o = ::flatbuffers::Offset<Utf8>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Utf8> CreateUtf8(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Utf8> CreateUtf8(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   Utf8Builder builder_(_fbb);
   return builder_.Finish();
 }
 
 /// Opaque binary data
-struct Binary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Binary FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef BinaryBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1191,31 +1187,30 @@ struct Binary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct BinaryBuilder {
   typedef Binary Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit BinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit BinaryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BinaryBuilder &operator=(const BinaryBuilder &);
-  flatbuffers::Offset<Binary> Finish() {
+  ::flatbuffers::Offset<Binary> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Binary>(end);
+    auto o = ::flatbuffers::Offset<Binary>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Binary> CreateBinary(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Binary> CreateBinary(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   BinaryBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
 /// Same as Utf8, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
-struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef LargeUtf8Builder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1223,31 +1218,30 @@ struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct LargeUtf8Builder {
   typedef LargeUtf8 Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit LargeUtf8Builder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit LargeUtf8Builder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeUtf8Builder &operator=(const LargeUtf8Builder &);
-  flatbuffers::Offset<LargeUtf8> Finish() {
+  ::flatbuffers::Offset<LargeUtf8> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<LargeUtf8>(end);
+    auto o = ::flatbuffers::Offset<LargeUtf8>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<LargeUtf8> CreateLargeUtf8(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LargeUtf8> CreateLargeUtf8(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   LargeUtf8Builder builder_(_fbb);
   return builder_.Finish();
 }
 
 /// Same as Binary, but with 64-bit offsets, allowing to represent
 /// extremely large data values.
-struct LargeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct LargeBinary FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef LargeBinaryBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1255,22 +1249,21 @@ struct LargeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct LargeBinaryBuilder {
   typedef LargeBinary Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit LargeBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit LargeBinaryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeBinaryBuilder &operator=(const LargeBinaryBuilder &);
-  flatbuffers::Offset<LargeBinary> Finish() {
+  ::flatbuffers::Offset<LargeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<LargeBinary>(end);
+    auto o = ::flatbuffers::Offset<LargeBinary>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<LargeBinary> CreateLargeBinary(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<LargeBinary> CreateLargeBinary(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   LargeBinaryBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -1282,9 +1275,9 @@ inline flatbuffers::Offset<LargeBinary> CreateLargeBinary(
 ///
 /// Since it uses a variable number of data buffers, each Field with this type
 /// must have a corresponding entry in `variadicBufferCounts`.
-struct Utf8View FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Utf8View FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef Utf8ViewBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1292,22 +1285,21 @@ struct Utf8View FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct Utf8ViewBuilder {
   typedef Utf8View Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit Utf8ViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit Utf8ViewBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  Utf8ViewBuilder &operator=(const Utf8ViewBuilder &);
-  flatbuffers::Offset<Utf8View> Finish() {
+  ::flatbuffers::Offset<Utf8View> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Utf8View>(end);
+    auto o = ::flatbuffers::Offset<Utf8View>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Utf8View> CreateUtf8View(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Utf8View> CreateUtf8View(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   Utf8ViewBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -1319,9 +1311,9 @@ inline flatbuffers::Offset<Utf8View> CreateUtf8View(
 ///
 /// Since it uses a variable number of data buffers, each Field with this type
 /// must have a corresponding entry in `variadicBufferCounts`.
-struct BinaryView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct BinaryView FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef BinaryViewBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1329,27 +1321,26 @@ struct BinaryView FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct BinaryViewBuilder {
   typedef BinaryView Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit BinaryViewBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit BinaryViewBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BinaryViewBuilder &operator=(const BinaryViewBuilder &);
-  flatbuffers::Offset<BinaryView> Finish() {
+  ::flatbuffers::Offset<BinaryView> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<BinaryView>(end);
+    auto o = ::flatbuffers::Offset<BinaryView>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<BinaryView> CreateBinaryView(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<BinaryView> CreateBinaryView(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   BinaryViewBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
-struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef FixedSizeBinaryBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_BYTEWIDTH = 4
@@ -1358,43 +1349,42 @@ struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t byteWidth() const {
     return GetField<int32_t>(VT_BYTEWIDTH, 0);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int32_t>(verifier, VT_BYTEWIDTH) &&
+           VerifyField<int32_t>(verifier, VT_BYTEWIDTH, 4) &&
            verifier.EndTable();
   }
 };
 
 struct FixedSizeBinaryBuilder {
   typedef FixedSizeBinary Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_byteWidth(int32_t byteWidth) {
     fbb_.AddElement<int32_t>(FixedSizeBinary::VT_BYTEWIDTH, byteWidth, 0);
   }
-  explicit FixedSizeBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit FixedSizeBinaryBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FixedSizeBinaryBuilder &operator=(const FixedSizeBinaryBuilder &);
-  flatbuffers::Offset<FixedSizeBinary> Finish() {
+  ::flatbuffers::Offset<FixedSizeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<FixedSizeBinary>(end);
+    auto o = ::flatbuffers::Offset<FixedSizeBinary>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<FixedSizeBinary> CreateFixedSizeBinary(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<FixedSizeBinary> CreateFixedSizeBinary(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t byteWidth = 0) {
   FixedSizeBinaryBuilder builder_(_fbb);
   builder_.add_byteWidth(byteWidth);
   return builder_.Finish();
 }
 
-struct Bool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Bool FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef BoolBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1402,22 +1392,21 @@ struct Bool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct BoolBuilder {
   typedef Bool Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit BoolBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit BoolBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BoolBuilder &operator=(const BoolBuilder &);
-  flatbuffers::Offset<Bool> Finish() {
+  ::flatbuffers::Offset<Bool> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Bool>(end);
+    auto o = ::flatbuffers::Offset<Bool>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Bool> CreateBool(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<Bool> CreateBool(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   BoolBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -1427,9 +1416,9 @@ inline flatbuffers::Offset<Bool> CreateBool(
 /// 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.
-struct RunEndEncoded FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct RunEndEncoded FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef RunEndEncodedBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1437,22 +1426,21 @@ struct RunEndEncoded FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct RunEndEncodedBuilder {
   typedef RunEndEncoded Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit RunEndEncodedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit RunEndEncodedBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  RunEndEncodedBuilder &operator=(const RunEndEncodedBuilder &);
-  flatbuffers::Offset<RunEndEncoded> Finish() {
+  ::flatbuffers::Offset<RunEndEncoded> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<RunEndEncoded>(end);
+    auto o = ::flatbuffers::Offset<RunEndEncoded>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<RunEndEncoded> CreateRunEndEncoded(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<RunEndEncoded> CreateRunEndEncoded(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   RunEndEncodedBuilder builder_(_fbb);
   return builder_.Finish();
 }
@@ -1461,7 +1449,7 @@ inline flatbuffers::Offset<RunEndEncoded> CreateRunEndEncoded(
 /// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
 /// are used. The representation uses the endianness indicated
 /// in the Schema.
-struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Decimal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DecimalBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_PRECISION = 4,
@@ -1481,19 +1469,19 @@ struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t bitWidth() const {
     return GetField<int32_t>(VT_BITWIDTH, 128);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int32_t>(verifier, VT_PRECISION) &&
-           VerifyField<int32_t>(verifier, VT_SCALE) &&
-           VerifyField<int32_t>(verifier, VT_BITWIDTH) &&
+           VerifyField<int32_t>(verifier, VT_PRECISION, 4) &&
+           VerifyField<int32_t>(verifier, VT_SCALE, 4) &&
+           VerifyField<int32_t>(verifier, VT_BITWIDTH, 4) &&
            verifier.EndTable();
   }
 };
 
 struct DecimalBuilder {
   typedef Decimal Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_precision(int32_t precision) {
     fbb_.AddElement<int32_t>(Decimal::VT_PRECISION, precision, 0);
   }
@@ -1503,20 +1491,19 @@ struct DecimalBuilder {
   void add_bitWidth(int32_t bitWidth) {
     fbb_.AddElement<int32_t>(Decimal::VT_BITWIDTH, bitWidth, 128);
   }
-  explicit DecimalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DecimalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DecimalBuilder &operator=(const DecimalBuilder &);
-  flatbuffers::Offset<Decimal> Finish() {
+  ::flatbuffers::Offset<Decimal> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Decimal>(end);
+    auto o = ::flatbuffers::Offset<Decimal>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Decimal> CreateDecimal(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Decimal> CreateDecimal(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t precision = 0,
     int32_t scale = 0,
     int32_t bitWidth = 128) {
@@ -1533,7 +1520,7 @@ inline flatbuffers::Offset<Decimal> CreateDecimal(
 /// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
 ///   leap seconds), where the values are evenly divisible by 86400000
 /// * Days (32 bits) since the UNIX epoch
-struct Date FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Date FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DateBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4
@@ -1541,34 +1528,33 @@ struct Date FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::DateUnit unit() const {
     return static_cast<org::apache::arrow::flatbuf::DateUnit>(GetField<int16_t>(VT_UNIT, 1));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyField<int16_t>(verifier, VT_UNIT, 2) &&
            verifier.EndTable();
   }
 };
 
 struct DateBuilder {
   typedef Date Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(org::apache::arrow::flatbuf::DateUnit unit) {
     fbb_.AddElement<int16_t>(Date::VT_UNIT, static_cast<int16_t>(unit), 1);
   }
-  explicit DateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DateBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DateBuilder &operator=(const DateBuilder &);
-  flatbuffers::Offset<Date> Finish() {
+  ::flatbuffers::Offset<Date> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Date>(end);
+    auto o = ::flatbuffers::Offset<Date>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Date> CreateDate(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Date> CreateDate(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::DateUnit unit = org::apache::arrow::flatbuf::DateUnit::MILLISECOND) {
   DateBuilder builder_(_fbb);
   builder_.add_unit(unit);
@@ -1589,7 +1575,7 @@ inline flatbuffers::Offset<Date> CreateDate(
 /// 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).
-struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Time FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TimeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4,
@@ -1601,38 +1587,37 @@ struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int32_t bitWidth() const {
     return GetField<int32_t>(VT_BITWIDTH, 32);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_UNIT) &&
-           VerifyField<int32_t>(verifier, VT_BITWIDTH) &&
+           VerifyField<int16_t>(verifier, VT_UNIT, 2) &&
+           VerifyField<int32_t>(verifier, VT_BITWIDTH, 4) &&
            verifier.EndTable();
   }
 };
 
 struct TimeBuilder {
   typedef Time Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) {
     fbb_.AddElement<int16_t>(Time::VT_UNIT, static_cast<int16_t>(unit), 1);
   }
   void add_bitWidth(int32_t bitWidth) {
     fbb_.AddElement<int32_t>(Time::VT_BITWIDTH, bitWidth, 32);
   }
-  explicit TimeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TimeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimeBuilder &operator=(const TimeBuilder &);
-  flatbuffers::Offset<Time> Finish() {
+  ::flatbuffers::Offset<Time> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Time>(end);
+    auto o = ::flatbuffers::Offset<Time>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Time> CreateTime(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Time> CreateTime(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::MILLISECOND,
     int32_t bitWidth = 32) {
   TimeBuilder builder_(_fbb);
@@ -1746,7 +1731,7 @@ inline flatbuffers::Offset<Time> CreateTime(
 /// 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.
-struct Timestamp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Timestamp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TimestampBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4,
@@ -1765,12 +1750,12 @@ struct Timestamp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   ///
   /// Whether a timezone string is present indicates different semantics about
   /// the data (see above).
-  const flatbuffers::String *timezone() const {
-    return GetPointer<const flatbuffers::String *>(VT_TIMEZONE);
+  const ::flatbuffers::String *timezone() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_TIMEZONE);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyField<int16_t>(verifier, VT_UNIT, 2) &&
            VerifyOffset(verifier, VT_TIMEZONE) &&
            verifier.VerifyString(timezone()) &&
            verifier.EndTable();
@@ -1779,38 +1764,37 @@ struct Timestamp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct TimestampBuilder {
   typedef Timestamp Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) {
     fbb_.AddElement<int16_t>(Timestamp::VT_UNIT, static_cast<int16_t>(unit), 0);
   }
-  void add_timezone(flatbuffers::Offset<flatbuffers::String> timezone) {
+  void add_timezone(::flatbuffers::Offset<::flatbuffers::String> timezone) {
     fbb_.AddOffset(Timestamp::VT_TIMEZONE, timezone);
   }
-  explicit TimestampBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TimestampBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimestampBuilder &operator=(const TimestampBuilder &);
-  flatbuffers::Offset<Timestamp> Finish() {
+  ::flatbuffers::Offset<Timestamp> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Timestamp>(end);
+    auto o = ::flatbuffers::Offset<Timestamp>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Timestamp> CreateTimestamp(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Timestamp> CreateTimestamp(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::SECOND,
-    flatbuffers::Offset<flatbuffers::String> timezone = 0) {
+    ::flatbuffers::Offset<::flatbuffers::String> timezone = 0) {
   TimestampBuilder builder_(_fbb);
   builder_.add_timezone(timezone);
   builder_.add_unit(unit);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Timestamp> CreateTimestampDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Timestamp> CreateTimestampDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::SECOND,
     const char *timezone = nullptr) {
   auto timezone__ = timezone ? _fbb.CreateString(timezone) : 0;
@@ -1820,7 +1804,7 @@ inline flatbuffers::Offset<Timestamp> CreateTimestampDirect(
       timezone__);
 }
 
-struct Interval FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Interval FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef IntervalBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4
@@ -1828,41 +1812,40 @@ struct Interval FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::IntervalUnit unit() const {
     return static_cast<org::apache::arrow::flatbuf::IntervalUnit>(GetField<int16_t>(VT_UNIT, 0));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyField<int16_t>(verifier, VT_UNIT, 2) &&
            verifier.EndTable();
   }
 };
 
 struct IntervalBuilder {
   typedef Interval Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(org::apache::arrow::flatbuf::IntervalUnit unit) {
     fbb_.AddElement<int16_t>(Interval::VT_UNIT, static_cast<int16_t>(unit), 0);
   }
-  explicit IntervalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit IntervalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  IntervalBuilder &operator=(const IntervalBuilder &);
-  flatbuffers::Offset<Interval> Finish() {
+  ::flatbuffers::Offset<Interval> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Interval>(end);
+    auto o = ::flatbuffers::Offset<Interval>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Interval> CreateInterval(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Interval> CreateInterval(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::IntervalUnit unit = org::apache::arrow::flatbuf::IntervalUnit::YEAR_MONTH) {
   IntervalBuilder builder_(_fbb);
   builder_.add_unit(unit);
   return builder_.Finish();
 }
 
-struct Duration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Duration FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DurationBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4
@@ -1870,34 +1853,33 @@ struct Duration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::TimeUnit unit() const {
     return static_cast<org::apache::arrow::flatbuf::TimeUnit>(GetField<int16_t>(VT_UNIT, 1));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyField<int16_t>(verifier, VT_UNIT, 2) &&
            verifier.EndTable();
   }
 };
 
 struct DurationBuilder {
   typedef Duration Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(org::apache::arrow::flatbuf::TimeUnit unit) {
     fbb_.AddElement<int16_t>(Duration::VT_UNIT, static_cast<int16_t>(unit), 1);
   }
-  explicit DurationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DurationBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DurationBuilder &operator=(const DurationBuilder &);
-  flatbuffers::Offset<Duration> Finish() {
+  ::flatbuffers::Offset<Duration> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Duration>(end);
+    auto o = ::flatbuffers::Offset<Duration>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Duration> CreateDuration(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Duration> CreateDuration(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::TimeUnit unit = org::apache::arrow::flatbuf::TimeUnit::MILLISECOND) {
   DurationBuilder builder_(_fbb);
   builder_.add_unit(unit);
@@ -1907,19 +1889,19 @@ inline flatbuffers::Offset<Duration> CreateDuration(
 /// ----------------------------------------------------------------------
 /// user defined key value pairs to add custom metadata to arrow
 /// key namespacing is the responsibility of the user
-struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef KeyValueBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_KEY = 4,
     VT_VALUE = 6
   };
-  const flatbuffers::String *key() const {
-    return GetPointer<const flatbuffers::String *>(VT_KEY);
+  const ::flatbuffers::String *key() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_KEY);
   }
-  const flatbuffers::String *value() const {
-    return GetPointer<const flatbuffers::String *>(VT_VALUE);
+  const ::flatbuffers::String *value() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_KEY) &&
            verifier.VerifyString(key()) &&
@@ -1931,38 +1913,37 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct KeyValueBuilder {
   typedef KeyValue Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_key(flatbuffers::Offset<flatbuffers::String> key) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_key(::flatbuffers::Offset<::flatbuffers::String> key) {
     fbb_.AddOffset(KeyValue::VT_KEY, key);
   }
-  void add_value(flatbuffers::Offset<flatbuffers::String> value) {
+  void add_value(::flatbuffers::Offset<::flatbuffers::String> value) {
     fbb_.AddOffset(KeyValue::VT_VALUE, value);
   }
-  explicit KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit KeyValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  KeyValueBuilder &operator=(const KeyValueBuilder &);
-  flatbuffers::Offset<KeyValue> Finish() {
+  ::flatbuffers::Offset<KeyValue> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<KeyValue>(end);
+    auto o = ::flatbuffers::Offset<KeyValue>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<KeyValue> CreateKeyValue(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::String> key = 0,
-    flatbuffers::Offset<flatbuffers::String> value = 0) {
+inline ::flatbuffers::Offset<KeyValue> CreateKeyValue(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> key = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> value = 0) {
   KeyValueBuilder builder_(_fbb);
   builder_.add_value(value);
   builder_.add_key(key);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     const char *key = nullptr,
     const char *value = nullptr) {
   auto key__ = key ? _fbb.CreateString(key) : 0;
@@ -1973,7 +1954,7 @@ inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
       value__);
 }
 
-struct DictionaryEncoding FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct DictionaryEncoding FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DictionaryEncodingBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ID = 4,
@@ -2005,25 +1986,25 @@ struct DictionaryEncoding FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::DictionaryKind dictionaryKind() const {
     return static_cast<org::apache::arrow::flatbuf::DictionaryKind>(GetField<int16_t>(VT_DICTIONARYKIND, 0));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int64_t>(verifier, VT_ID) &&
+           VerifyField<int64_t>(verifier, VT_ID, 8) &&
            VerifyOffset(verifier, VT_INDEXTYPE) &&
            verifier.VerifyTable(indexType()) &&
-           VerifyField<uint8_t>(verifier, VT_ISORDERED) &&
-           VerifyField<int16_t>(verifier, VT_DICTIONARYKIND) &&
+           VerifyField<uint8_t>(verifier, VT_ISORDERED, 1) &&
+           VerifyField<int16_t>(verifier, VT_DICTIONARYKIND, 2) &&
            verifier.EndTable();
   }
 };
 
 struct DictionaryEncodingBuilder {
   typedef DictionaryEncoding Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_id(int64_t id) {
     fbb_.AddElement<int64_t>(DictionaryEncoding::VT_ID, id, 0);
   }
-  void add_indexType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indexType) {
+  void add_indexType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indexType) {
     fbb_.AddOffset(DictionaryEncoding::VT_INDEXTYPE, indexType);
   }
   void add_isOrdered(bool isOrdered) {
@@ -2032,22 +2013,21 @@ struct DictionaryEncodingBuilder {
   void add_dictionaryKind(org::apache::arrow::flatbuf::DictionaryKind dictionaryKind) {
     fbb_.AddElement<int16_t>(DictionaryEncoding::VT_DICTIONARYKIND, static_cast<int16_t>(dictionaryKind), 0);
   }
-  explicit DictionaryEncodingBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DictionaryEncodingBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DictionaryEncodingBuilder &operator=(const DictionaryEncodingBuilder &);
-  flatbuffers::Offset<DictionaryEncoding> Finish() {
+  ::flatbuffers::Offset<DictionaryEncoding> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<DictionaryEncoding>(end);
+    auto o = ::flatbuffers::Offset<DictionaryEncoding>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<DictionaryEncoding> CreateDictionaryEncoding(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<DictionaryEncoding> CreateDictionaryEncoding(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t id = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indexType = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indexType = 0,
     bool isOrdered = false,
     org::apache::arrow::flatbuf::DictionaryKind dictionaryKind = org::apache::arrow::flatbuf::DictionaryKind::DenseArray) {
   DictionaryEncodingBuilder builder_(_fbb);
@@ -2061,7 +2041,7 @@ inline flatbuffers::Offset<DictionaryEncoding> CreateDictionaryEncoding(
 /// ----------------------------------------------------------------------
 /// A field represents a named column in a record / row batch or child of a
 /// nested type.
-struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef FieldBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_NAME = 4,
@@ -2073,8 +2053,8 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_CUSTOM_METADATA = 16
   };
   /// Name is not required, in i.e. a List
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
   }
   /// Whether or not this field can contain nulls. Should be true in general.
   bool nullable() const {
@@ -2172,19 +2152,19 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
   /// children apply only to nested data types like Struct, List and Union. For
   /// primitive types children will have length 0.
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *children() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *>(VT_CHILDREN);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *children() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *>(VT_CHILDREN);
   }
   /// User-defined metadata
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
-           VerifyField<uint8_t>(verifier, VT_NULLABLE) &&
-           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyField<uint8_t>(verifier, VT_NULLABLE, 1) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE, 1) &&
            VerifyOffset(verifier, VT_TYPE) &&
            VerifyType(verifier, type(), type_type()) &&
            VerifyOffset(verifier, VT_DICTIONARY) &&
@@ -2305,9 +2285,9 @@ template<> inline const org::apache::arrow::flatbuf::LargeListView *Field::type_
 
 struct FieldBuilder {
   typedef Field Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
     fbb_.AddOffset(Field::VT_NAME, name);
   }
   void add_nullable(bool nullable) {
@@ -2316,39 +2296,38 @@ struct FieldBuilder {
   void add_type_type(org::apache::arrow::flatbuf::Type type_type) {
     fbb_.AddElement<uint8_t>(Field::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
   }
-  void add_type(flatbuffers::Offset<void> type) {
+  void add_type(::flatbuffers::Offset<void> type) {
     fbb_.AddOffset(Field::VT_TYPE, type);
   }
-  void add_dictionary(flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary) {
+  void add_dictionary(::flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary) {
     fbb_.AddOffset(Field::VT_DICTIONARY, dictionary);
   }
-  void add_children(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> children) {
+  void add_children(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> children) {
     fbb_.AddOffset(Field::VT_CHILDREN, children);
   }
-  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
+  void add_custom_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
     fbb_.AddOffset(Field::VT_CUSTOM_METADATA, custom_metadata);
   }
-  explicit FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FieldBuilder &operator=(const FieldBuilder &);
-  flatbuffers::Offset<Field> Finish() {
+  ::flatbuffers::Offset<Field> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Field>(end);
+    auto o = ::flatbuffers::Offset<Field>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Field> CreateField(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::String> name = 0,
+inline ::flatbuffers::Offset<Field> CreateField(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
     bool nullable = false,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> children = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
+    ::flatbuffers::Offset<void> type = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> children = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
   FieldBuilder builder_(_fbb);
   builder_.add_custom_metadata(custom_metadata);
   builder_.add_children(children);
@@ -2360,18 +2339,18 @@ inline flatbuffers::Offset<Field> CreateField(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Field> CreateFieldDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Field> CreateFieldDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     const char *name = nullptr,
     bool nullable = false,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary = 0,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *children = nullptr,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
+    ::flatbuffers::Offset<void> type = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::DictionaryEncoding> dictionary = 0,
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *children = nullptr,
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
-  auto children__ = children ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>(*children) : 0;
-  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
+  auto children__ = children ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>(*children) : 0;
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
   return org::apache::arrow::flatbuf::CreateField(
       _fbb,
       name__,
@@ -2385,7 +2364,7 @@ inline flatbuffers::Offset<Field> CreateFieldDirect(
 
 /// ----------------------------------------------------------------------
 /// A Schema describes the columns in a row batch
-struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SchemaBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ENDIANNESS = 4,
@@ -2399,19 +2378,19 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   org::apache::arrow::flatbuf::Endianness endianness() const {
     return static_cast<org::apache::arrow::flatbuf::Endianness>(GetField<int16_t>(VT_ENDIANNESS, 0));
   }
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *fields() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *>(VT_FIELDS);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *fields() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *>(VT_FIELDS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
   }
   /// Features used in the stream/file.
-  const flatbuffers::Vector<int64_t> *features() const {
-    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_FEATURES);
+  const ::flatbuffers::Vector<org::apache::arrow::flatbuf::Feature> *features() const {
+    return GetPointer<const ::flatbuffers::Vector<org::apache::arrow::flatbuf::Feature> *>(VT_FEATURES);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_ENDIANNESS) &&
+           VerifyField<int16_t>(verifier, VT_ENDIANNESS, 2) &&
            VerifyOffset(verifier, VT_FIELDS) &&
            verifier.VerifyVector(fields()) &&
            verifier.VerifyVectorOfTables(fields()) &&
@@ -2426,38 +2405,37 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct SchemaBuilder {
   typedef Schema Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_endianness(org::apache::arrow::flatbuf::Endianness endianness) {
     fbb_.AddElement<int16_t>(Schema::VT_ENDIANNESS, static_cast<int16_t>(endianness), 0);
   }
-  void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> fields) {
+  void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> fields) {
     fbb_.AddOffset(Schema::VT_FIELDS, fields);
   }
-  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
+  void add_custom_metadata(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
     fbb_.AddOffset(Schema::VT_CUSTOM_METADATA, custom_metadata);
   }
-  void add_features(flatbuffers::Offset<flatbuffers::Vector<int64_t>> features) {
+  void add_features(::flatbuffers::Offset<::flatbuffers::Vector<org::apache::arrow::flatbuf::Feature>> features) {
     fbb_.AddOffset(Schema::VT_FEATURES, features);
   }
-  explicit SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SchemaBuilder &operator=(const SchemaBuilder &);
-  flatbuffers::Offset<Schema> Finish() {
+  ::flatbuffers::Offset<Schema> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Schema>(end);
+    auto o = ::flatbuffers::Offset<Schema>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Schema> CreateSchema(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Schema> CreateSchema(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Endianness endianness = org::apache::arrow::flatbuf::Endianness::Little,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> fields = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int64_t>> features = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>> fields = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<org::apache::arrow::flatbuf::Feature>> features = 0) {
   SchemaBuilder builder_(_fbb);
   builder_.add_features(features);
   builder_.add_custom_metadata(custom_metadata);
@@ -2466,15 +2444,15 @@ inline flatbuffers::Offset<Schema> CreateSchema(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Schema> CreateSchemaDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Schema> CreateSchemaDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Endianness endianness = org::apache::arrow::flatbuf::Endianness::Little,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *fields = nullptr,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr,
-    const std::vector<int64_t> *features = nullptr) {
-  auto fields__ = fields ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>(*fields) : 0;
-  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
-  auto features__ = features ? _fbb.CreateVector<int64_t>(*features) : 0;
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>> *fields = nullptr,
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr,
+    const std::vector<org::apache::arrow::flatbuf::Feature> *features = nullptr) {
+  auto fields__ = fields ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::Field>>(*fields) : 0;
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
+  auto features__ = features ? _fbb.CreateVector<org::apache::arrow::flatbuf::Feature>(*features) : 0;
   return org::apache::arrow::flatbuf::CreateSchema(
       _fbb,
       endianness,
@@ -2483,7 +2461,7 @@ inline flatbuffers::Offset<Schema> CreateSchemaDirect(
       features__);
 }
 
-inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type) {
+inline bool VerifyType(::flatbuffers::Verifier &verifier, const void *obj, Type type) {
   switch (type) {
     case Type::NONE: {
       return true;
@@ -2596,10 +2574,10 @@ inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type ty
   }
 }
 
-inline bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyTypeVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Type> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
-  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
     if (!VerifyType(
         verifier,  values->Get(i), types->GetEnum<Type>(i))) {
       return false;
@@ -2609,32 +2587,32 @@ inline bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers:
 }
 
 inline const org::apache::arrow::flatbuf::Schema *GetSchema(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Schema>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::Schema>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::Schema *GetSizePrefixedSchema(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Schema>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Schema>(buf);
 }
 
 inline bool VerifySchemaBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Schema>(nullptr);
 }
 
 inline bool VerifySizePrefixedSchemaBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Schema>(nullptr);
 }
 
 inline void FinishSchemaBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedSchemaBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/src/generated/SparseTensor_generated.h b/cpp/src/generated/SparseTensor_generated.h
index 514bc0704dadd..17378d602ad77 100644
--- a/cpp/src/generated/SparseTensor_generated.h
+++ b/cpp/src/generated/SparseTensor_generated.h
@@ -6,7 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
-#include "Schema_generated.h"
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 #include "Tensor_generated.h"
 
 namespace org {
@@ -51,7 +57,7 @@ inline const char * const *EnumNamesSparseMatrixCompressedAxis() {
 }
 
 inline const char *EnumNameSparseMatrixCompressedAxis(SparseMatrixCompressedAxis e) {
-  if (flatbuffers::IsOutRange(e, SparseMatrixCompressedAxis::Row, SparseMatrixCompressedAxis::Column)) return "";
+  if (::flatbuffers::IsOutRange(e, SparseMatrixCompressedAxis::Row, SparseMatrixCompressedAxis::Column)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesSparseMatrixCompressedAxis()[index];
 }
@@ -87,7 +93,7 @@ inline const char * const *EnumNamesSparseTensorIndex() {
 }
 
 inline const char *EnumNameSparseTensorIndex(SparseTensorIndex e) {
-  if (flatbuffers::IsOutRange(e, SparseTensorIndex::NONE, SparseTensorIndex::SparseTensorIndexCSF)) return "";
+  if (::flatbuffers::IsOutRange(e, SparseTensorIndex::NONE, SparseTensorIndex::SparseTensorIndexCSF)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesSparseTensorIndex()[index];
 }
@@ -108,8 +114,8 @@ template<> struct SparseTensorIndexTraits<org::apache::arrow::flatbuf::SparseTen
   static const SparseTensorIndex enum_value = SparseTensorIndex::SparseTensorIndexCSF;
 };
 
-bool VerifySparseTensorIndex(flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type);
-bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifySparseTensorIndex(::flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type);
+bool VerifySparseTensorIndexVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<SparseTensorIndex> *types);
 
 /// ----------------------------------------------------------------------
 /// EXPERIMENTAL: Data structures for sparse tensors
@@ -143,7 +149,7 @@ bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbu
 /// When isCanonical is true, the indices is sorted in lexicographical order
 /// (row-major order), and it does not have duplicated entries.  Otherwise,
 /// the indices may not be sorted, or may have duplicated entries.
-struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SparseTensorIndexCOOBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_INDICESTYPE = 4,
@@ -157,8 +163,8 @@ struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   }
   /// Non-negative byte offsets to advance one value cell along each dimension
   /// If omitted, default to row-major order (C-like).
-  const flatbuffers::Vector<int64_t> *indicesStrides() const {
-    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INDICESSTRIDES);
+  const ::flatbuffers::Vector<int64_t> *indicesStrides() const {
+    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_INDICESSTRIDES);
   }
   /// The location and size of the indices matrix's data
   const org::apache::arrow::flatbuf::Buffer *indicesBuffer() const {
@@ -172,26 +178,26 @@ struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   bool isCanonical() const {
     return GetField<uint8_t>(VT_ISCANONICAL, 0) != 0;
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_INDICESTYPE) &&
            verifier.VerifyTable(indicesType()) &&
            VerifyOffset(verifier, VT_INDICESSTRIDES) &&
            verifier.VerifyVector(indicesStrides()) &&
-           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDICESBUFFER) &&
-           VerifyField<uint8_t>(verifier, VT_ISCANONICAL) &&
+           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDICESBUFFER, 8) &&
+           VerifyField<uint8_t>(verifier, VT_ISCANONICAL, 1) &&
            verifier.EndTable();
   }
 };
 
 struct SparseTensorIndexCOOBuilder {
   typedef SparseTensorIndexCOO Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_indicesType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_indicesType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
     fbb_.AddOffset(SparseTensorIndexCOO::VT_INDICESTYPE, indicesType);
   }
-  void add_indicesStrides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> indicesStrides) {
+  void add_indicesStrides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> indicesStrides) {
     fbb_.AddOffset(SparseTensorIndexCOO::VT_INDICESSTRIDES, indicesStrides);
   }
   void add_indicesBuffer(const org::apache::arrow::flatbuf::Buffer *indicesBuffer) {
@@ -200,25 +206,24 @@ struct SparseTensorIndexCOOBuilder {
   void add_isCanonical(bool isCanonical) {
     fbb_.AddElement<uint8_t>(SparseTensorIndexCOO::VT_ISCANONICAL, static_cast<uint8_t>(isCanonical), 0);
   }
-  explicit SparseTensorIndexCOOBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit SparseTensorIndexCOOBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorIndexCOOBuilder &operator=(const SparseTensorIndexCOOBuilder &);
-  flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
+  ::flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<SparseTensorIndexCOO>(end);
+    auto o = ::flatbuffers::Offset<SparseTensorIndexCOO>(end);
     fbb_.Required(o, SparseTensorIndexCOO::VT_INDICESTYPE);
     fbb_.Required(o, SparseTensorIndexCOO::VT_INDICESBUFFER);
     return o;
   }
 };
 
-inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOO(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int64_t>> indicesStrides = 0,
-    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = 0,
+inline ::flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOO(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> indicesStrides = 0,
+    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = nullptr,
     bool isCanonical = false) {
   SparseTensorIndexCOOBuilder builder_(_fbb);
   builder_.add_indicesBuffer(indicesBuffer);
@@ -228,11 +233,11 @@ inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOO(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOODirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
+inline ::flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOODirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
     const std::vector<int64_t> *indicesStrides = nullptr,
-    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = 0,
+    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = nullptr,
     bool isCanonical = false) {
   auto indicesStrides__ = indicesStrides ? _fbb.CreateVector<int64_t>(*indicesStrides) : 0;
   return org::apache::arrow::flatbuf::CreateSparseTensorIndexCOO(
@@ -244,7 +249,7 @@ inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOODirec
 }
 
 /// Compressed Sparse format, that is matrix-specific.
-struct SparseMatrixIndexCSX FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct SparseMatrixIndexCSX FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SparseMatrixIndexCSXBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_COMPRESSEDAXIS = 4,
@@ -303,46 +308,45 @@ struct SparseMatrixIndexCSX FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   const org::apache::arrow::flatbuf::Buffer *indicesBuffer() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_INDICESBUFFER);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int16_t>(verifier, VT_COMPRESSEDAXIS) &&
+           VerifyField<int16_t>(verifier, VT_COMPRESSEDAXIS, 2) &&
            VerifyOffsetRequired(verifier, VT_INDPTRTYPE) &&
            verifier.VerifyTable(indptrType()) &&
-           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDPTRBUFFER) &&
+           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDPTRBUFFER, 8) &&
            VerifyOffsetRequired(verifier, VT_INDICESTYPE) &&
            verifier.VerifyTable(indicesType()) &&
-           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDICESBUFFER) &&
+           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_INDICESBUFFER, 8) &&
            verifier.EndTable();
   }
 };
 
 struct SparseMatrixIndexCSXBuilder {
   typedef SparseMatrixIndexCSX Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_compressedAxis(org::apache::arrow::flatbuf::SparseMatrixCompressedAxis compressedAxis) {
     fbb_.AddElement<int16_t>(SparseMatrixIndexCSX::VT_COMPRESSEDAXIS, static_cast<int16_t>(compressedAxis), 0);
   }
-  void add_indptrType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType) {
+  void add_indptrType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType) {
     fbb_.AddOffset(SparseMatrixIndexCSX::VT_INDPTRTYPE, indptrType);
   }
   void add_indptrBuffer(const org::apache::arrow::flatbuf::Buffer *indptrBuffer) {
     fbb_.AddStruct(SparseMatrixIndexCSX::VT_INDPTRBUFFER, indptrBuffer);
   }
-  void add_indicesType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
+  void add_indicesType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
     fbb_.AddOffset(SparseMatrixIndexCSX::VT_INDICESTYPE, indicesType);
   }
   void add_indicesBuffer(const org::apache::arrow::flatbuf::Buffer *indicesBuffer) {
     fbb_.AddStruct(SparseMatrixIndexCSX::VT_INDICESBUFFER, indicesBuffer);
   }
-  explicit SparseMatrixIndexCSXBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit SparseMatrixIndexCSXBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseMatrixIndexCSXBuilder &operator=(const SparseMatrixIndexCSXBuilder &);
-  flatbuffers::Offset<SparseMatrixIndexCSX> Finish() {
+  ::flatbuffers::Offset<SparseMatrixIndexCSX> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<SparseMatrixIndexCSX>(end);
+    auto o = ::flatbuffers::Offset<SparseMatrixIndexCSX>(end);
     fbb_.Required(o, SparseMatrixIndexCSX::VT_INDPTRTYPE);
     fbb_.Required(o, SparseMatrixIndexCSX::VT_INDPTRBUFFER);
     fbb_.Required(o, SparseMatrixIndexCSX::VT_INDICESTYPE);
@@ -351,13 +355,13 @@ struct SparseMatrixIndexCSXBuilder {
   }
 };
 
-inline flatbuffers::Offset<SparseMatrixIndexCSX> CreateSparseMatrixIndexCSX(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SparseMatrixIndexCSX> CreateSparseMatrixIndexCSX(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::SparseMatrixCompressedAxis compressedAxis = org::apache::arrow::flatbuf::SparseMatrixCompressedAxis::Row,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
-    const org::apache::arrow::flatbuf::Buffer *indptrBuffer = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
-    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = 0) {
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
+    const org::apache::arrow::flatbuf::Buffer *indptrBuffer = nullptr,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
+    const org::apache::arrow::flatbuf::Buffer *indicesBuffer = nullptr) {
   SparseMatrixIndexCSXBuilder builder_(_fbb);
   builder_.add_indicesBuffer(indicesBuffer);
   builder_.add_indicesType(indicesType);
@@ -368,7 +372,7 @@ inline flatbuffers::Offset<SparseMatrixIndexCSX> CreateSparseMatrixIndexCSX(
 }
 
 /// Compressed Sparse Fiber (CSF) sparse tensor index.
-struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SparseTensorIndexCSFBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_INDPTRTYPE = 4,
@@ -425,8 +429,8 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   ///                       [0, 2, 4, 5, 8]
   ///                     ].
   /// ```
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indptrBuffers() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDPTRBUFFERS);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indptrBuffers() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDPTRBUFFERS);
   }
   /// The type of values in indicesBuffers
   const org::apache::arrow::flatbuf::Int *indicesType() const {
@@ -443,8 +447,8 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   ///                        [1, 2, 0, 2, 0, 0, 1, 2]
   ///                      ].
   /// ```
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indicesBuffers() const {
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDICESBUFFERS);
+  const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *indicesBuffers() const {
+    return GetPointer<const ::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_INDICESBUFFERS);
   }
   /// axisOrder stores the sequence in which dimensions were traversed to
   /// produce the prefix tree.
@@ -452,10 +456,10 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
   /// ```text
   ///   axisOrder(X) = [0, 1, 2, 3].
   /// ```
-  const flatbuffers::Vector<int32_t> *axisOrder() const {
-    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_AXISORDER);
+  const ::flatbuffers::Vector<int32_t> *axisOrder() const {
+    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_AXISORDER);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_INDPTRTYPE) &&
            verifier.VerifyTable(indptrType()) &&
@@ -473,31 +477,30 @@ struct SparseTensorIndexCSF FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 
 struct SparseTensorIndexCSFBuilder {
   typedef SparseTensorIndexCSF Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_indptrType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_indptrType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType) {
     fbb_.AddOffset(SparseTensorIndexCSF::VT_INDPTRTYPE, indptrType);
   }
-  void add_indptrBuffers(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indptrBuffers) {
+  void add_indptrBuffers(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indptrBuffers) {
     fbb_.AddOffset(SparseTensorIndexCSF::VT_INDPTRBUFFERS, indptrBuffers);
   }
-  void add_indicesType(flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
+  void add_indicesType(::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType) {
     fbb_.AddOffset(SparseTensorIndexCSF::VT_INDICESTYPE, indicesType);
   }
-  void add_indicesBuffers(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indicesBuffers) {
+  void add_indicesBuffers(::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indicesBuffers) {
     fbb_.AddOffset(SparseTensorIndexCSF::VT_INDICESBUFFERS, indicesBuffers);
   }
-  void add_axisOrder(flatbuffers::Offset<flatbuffers::Vector<int32_t>> axisOrder) {
+  void add_axisOrder(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> axisOrder) {
     fbb_.AddOffset(SparseTensorIndexCSF::VT_AXISORDER, axisOrder);
   }
-  explicit SparseTensorIndexCSFBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit SparseTensorIndexCSFBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorIndexCSFBuilder &operator=(const SparseTensorIndexCSFBuilder &);
-  flatbuffers::Offset<SparseTensorIndexCSF> Finish() {
+  ::flatbuffers::Offset<SparseTensorIndexCSF> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<SparseTensorIndexCSF>(end);
+    auto o = ::flatbuffers::Offset<SparseTensorIndexCSF>(end);
     fbb_.Required(o, SparseTensorIndexCSF::VT_INDPTRTYPE);
     fbb_.Required(o, SparseTensorIndexCSF::VT_INDPTRBUFFERS);
     fbb_.Required(o, SparseTensorIndexCSF::VT_INDICESTYPE);
@@ -507,13 +510,13 @@ struct SparseTensorIndexCSFBuilder {
   }
 };
 
-inline flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSF(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indptrBuffers = 0,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indicesBuffers = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int32_t>> axisOrder = 0) {
+inline ::flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSF(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indptrBuffers = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> indicesBuffers = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> axisOrder = 0) {
   SparseTensorIndexCSFBuilder builder_(_fbb);
   builder_.add_axisOrder(axisOrder);
   builder_.add_indicesBuffers(indicesBuffers);
@@ -523,11 +526,11 @@ inline flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSF(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSFDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
+inline ::flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSFDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indptrType = 0,
     const std::vector<org::apache::arrow::flatbuf::Buffer> *indptrBuffers = nullptr,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Int> indicesType = 0,
     const std::vector<org::apache::arrow::flatbuf::Buffer> *indicesBuffers = nullptr,
     const std::vector<int32_t> *axisOrder = nullptr) {
   auto indptrBuffers__ = indptrBuffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*indptrBuffers) : 0;
@@ -542,7 +545,7 @@ inline flatbuffers::Offset<SparseTensorIndexCSF> CreateSparseTensorIndexCSFDirec
       axisOrder__);
 }
 
-struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct SparseTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef SparseTensorBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_TYPE_TYPE = 4,
@@ -642,8 +645,8 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeListView ? static_cast<const org::apache::arrow::flatbuf::LargeListView *>(type()) : nullptr;
   }
   /// The dimensions of the tensor, optionally named.
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
   }
   /// The number of non-zero values in a sparse tensor.
   int64_t non_zero_length() const {
@@ -670,19 +673,19 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::Buffer *data() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_DATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE, 1) &&
            VerifyOffsetRequired(verifier, VT_TYPE) &&
            VerifyType(verifier, type(), type_type()) &&
            VerifyOffsetRequired(verifier, VT_SHAPE) &&
            verifier.VerifyVector(shape()) &&
            verifier.VerifyVectorOfTables(shape()) &&
-           VerifyField<int64_t>(verifier, VT_NON_ZERO_LENGTH) &&
-           VerifyField<uint8_t>(verifier, VT_SPARSEINDEX_TYPE) &&
+           VerifyField<int64_t>(verifier, VT_NON_ZERO_LENGTH, 8) &&
+           VerifyField<uint8_t>(verifier, VT_SPARSEINDEX_TYPE, 1) &&
            VerifyOffsetRequired(verifier, VT_SPARSEINDEX) &&
            VerifySparseTensorIndex(verifier, sparseIndex(), sparseIndex_type()) &&
-           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_DATA) &&
+           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_DATA, 8) &&
            verifier.EndTable();
   }
 };
@@ -805,15 +808,15 @@ template<> inline const org::apache::arrow::flatbuf::SparseTensorIndexCSF *Spars
 
 struct SparseTensorBuilder {
   typedef SparseTensor Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_type_type(org::apache::arrow::flatbuf::Type type_type) {
     fbb_.AddElement<uint8_t>(SparseTensor::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
   }
-  void add_type(flatbuffers::Offset<void> type) {
+  void add_type(::flatbuffers::Offset<void> type) {
     fbb_.AddOffset(SparseTensor::VT_TYPE, type);
   }
-  void add_shape(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape) {
+  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape) {
     fbb_.AddOffset(SparseTensor::VT_SHAPE, shape);
   }
   void add_non_zero_length(int64_t non_zero_length) {
@@ -822,20 +825,19 @@ struct SparseTensorBuilder {
   void add_sparseIndex_type(org::apache::arrow::flatbuf::SparseTensorIndex sparseIndex_type) {
     fbb_.AddElement<uint8_t>(SparseTensor::VT_SPARSEINDEX_TYPE, static_cast<uint8_t>(sparseIndex_type), 0);
   }
-  void add_sparseIndex(flatbuffers::Offset<void> sparseIndex) {
+  void add_sparseIndex(::flatbuffers::Offset<void> sparseIndex) {
     fbb_.AddOffset(SparseTensor::VT_SPARSEINDEX, sparseIndex);
   }
   void add_data(const org::apache::arrow::flatbuf::Buffer *data) {
     fbb_.AddStruct(SparseTensor::VT_DATA, data);
   }
-  explicit SparseTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit SparseTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorBuilder &operator=(const SparseTensorBuilder &);
-  flatbuffers::Offset<SparseTensor> Finish() {
+  ::flatbuffers::Offset<SparseTensor> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<SparseTensor>(end);
+    auto o = ::flatbuffers::Offset<SparseTensor>(end);
     fbb_.Required(o, SparseTensor::VT_TYPE);
     fbb_.Required(o, SparseTensor::VT_SHAPE);
     fbb_.Required(o, SparseTensor::VT_SPARSEINDEX);
@@ -844,15 +846,15 @@ struct SparseTensorBuilder {
   }
 };
 
-inline flatbuffers::Offset<SparseTensor> CreateSparseTensor(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SparseTensor> CreateSparseTensor(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape = 0,
+    ::flatbuffers::Offset<void> type = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape = 0,
     int64_t non_zero_length = 0,
     org::apache::arrow::flatbuf::SparseTensorIndex sparseIndex_type = org::apache::arrow::flatbuf::SparseTensorIndex::NONE,
-    flatbuffers::Offset<void> sparseIndex = 0,
-    const org::apache::arrow::flatbuf::Buffer *data = 0) {
+    ::flatbuffers::Offset<void> sparseIndex = 0,
+    const org::apache::arrow::flatbuf::Buffer *data = nullptr) {
   SparseTensorBuilder builder_(_fbb);
   builder_.add_non_zero_length(non_zero_length);
   builder_.add_data(data);
@@ -864,16 +866,16 @@ inline flatbuffers::Offset<SparseTensor> CreateSparseTensor(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<SparseTensor> CreateSparseTensorDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<SparseTensor> CreateSparseTensorDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape = nullptr,
+    ::flatbuffers::Offset<void> type = 0,
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape = nullptr,
     int64_t non_zero_length = 0,
     org::apache::arrow::flatbuf::SparseTensorIndex sparseIndex_type = org::apache::arrow::flatbuf::SparseTensorIndex::NONE,
-    flatbuffers::Offset<void> sparseIndex = 0,
-    const org::apache::arrow::flatbuf::Buffer *data = 0) {
-  auto shape__ = shape ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>(*shape) : 0;
+    ::flatbuffers::Offset<void> sparseIndex = 0,
+    const org::apache::arrow::flatbuf::Buffer *data = nullptr) {
+  auto shape__ = shape ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>(*shape) : 0;
   return org::apache::arrow::flatbuf::CreateSparseTensor(
       _fbb,
       type_type,
@@ -885,7 +887,7 @@ inline flatbuffers::Offset<SparseTensor> CreateSparseTensorDirect(
       data);
 }
 
-inline bool VerifySparseTensorIndex(flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type) {
+inline bool VerifySparseTensorIndex(::flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type) {
   switch (type) {
     case SparseTensorIndex::NONE: {
       return true;
@@ -906,10 +908,10 @@ inline bool VerifySparseTensorIndex(flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifySparseTensorIndexVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<SparseTensorIndex> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
-  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
     if (!VerifySparseTensorIndex(
         verifier,  values->Get(i), types->GetEnum<SparseTensorIndex>(i))) {
       return false;
@@ -919,32 +921,32 @@ inline bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const
 }
 
 inline const org::apache::arrow::flatbuf::SparseTensor *GetSparseTensor(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::SparseTensor *GetSizePrefixedSparseTensor(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
 }
 
 inline bool VerifySparseTensorBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::SparseTensor>(nullptr);
 }
 
 inline bool VerifySizePrefixedSparseTensorBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::SparseTensor>(nullptr);
 }
 
 inline void FinishSparseTensorBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedSparseTensorBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/src/generated/Tensor_generated.h b/cpp/src/generated/Tensor_generated.h
index d3393553fa4d2..37d6ef2ce30a4 100644
--- a/cpp/src/generated/Tensor_generated.h
+++ b/cpp/src/generated/Tensor_generated.h
@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 #include "Schema_generated.h"
 
 namespace org {
@@ -22,7 +29,7 @@ struct TensorBuilder;
 /// ----------------------------------------------------------------------
 /// Data structures for dense tensors
 /// Shape data for a single axis in a tensor
-struct TensorDim FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct TensorDim FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TensorDimBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_SIZE = 4,
@@ -33,12 +40,12 @@ struct TensorDim FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return GetField<int64_t>(VT_SIZE, 0);
   }
   /// Name of the dimension, optional
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int64_t>(verifier, VT_SIZE) &&
+           VerifyField<int64_t>(verifier, VT_SIZE, 8) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
            verifier.EndTable();
@@ -47,38 +54,37 @@ struct TensorDim FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct TensorDimBuilder {
   typedef TensorDim Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_size(int64_t size) {
     fbb_.AddElement<int64_t>(TensorDim::VT_SIZE, size, 0);
   }
-  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
     fbb_.AddOffset(TensorDim::VT_NAME, name);
   }
-  explicit TensorDimBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TensorDimBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TensorDimBuilder &operator=(const TensorDimBuilder &);
-  flatbuffers::Offset<TensorDim> Finish() {
+  ::flatbuffers::Offset<TensorDim> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<TensorDim>(end);
+    auto o = ::flatbuffers::Offset<TensorDim>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<TensorDim> CreateTensorDim(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TensorDim> CreateTensorDim(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t size = 0,
-    flatbuffers::Offset<flatbuffers::String> name = 0) {
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
   TensorDimBuilder builder_(_fbb);
   builder_.add_size(size);
   builder_.add_name(name);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<TensorDim> CreateTensorDimDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TensorDim> CreateTensorDimDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t size = 0,
     const char *name = nullptr) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
@@ -88,7 +94,7 @@ inline flatbuffers::Offset<TensorDim> CreateTensorDimDirect(
       name__);
 }
 
-struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Tensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TensorBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_TYPE_TYPE = 4,
@@ -185,21 +191,21 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeListView ? static_cast<const org::apache::arrow::flatbuf::LargeListView *>(type()) : nullptr;
   }
   /// The dimensions of the tensor, optionally named
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
   }
   /// Non-negative byte offsets to advance one value cell along each dimension
   /// If omitted, default to row-major order (C-like).
-  const flatbuffers::Vector<int64_t> *strides() const {
-    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_STRIDES);
+  const ::flatbuffers::Vector<int64_t> *strides() const {
+    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_STRIDES);
   }
   /// The location and size of the tensor's data
   const org::apache::arrow::flatbuf::Buffer *data() const {
     return GetStruct<const org::apache::arrow::flatbuf::Buffer *>(VT_DATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE, 1) &&
            VerifyOffsetRequired(verifier, VT_TYPE) &&
            VerifyType(verifier, type(), type_type()) &&
            VerifyOffsetRequired(verifier, VT_SHAPE) &&
@@ -207,7 +213,7 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyVectorOfTables(shape()) &&
            VerifyOffset(verifier, VT_STRIDES) &&
            verifier.VerifyVector(strides()) &&
-           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_DATA) &&
+           VerifyFieldRequired<org::apache::arrow::flatbuf::Buffer>(verifier, VT_DATA, 8) &&
            verifier.EndTable();
   }
 };
@@ -318,31 +324,30 @@ template<> inline const org::apache::arrow::flatbuf::LargeListView *Tensor::type
 
 struct TensorBuilder {
   typedef Tensor Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_type_type(org::apache::arrow::flatbuf::Type type_type) {
     fbb_.AddElement<uint8_t>(Tensor::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
   }
-  void add_type(flatbuffers::Offset<void> type) {
+  void add_type(::flatbuffers::Offset<void> type) {
     fbb_.AddOffset(Tensor::VT_TYPE, type);
   }
-  void add_shape(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape) {
+  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape) {
     fbb_.AddOffset(Tensor::VT_SHAPE, shape);
   }
-  void add_strides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides) {
+  void add_strides(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides) {
     fbb_.AddOffset(Tensor::VT_STRIDES, strides);
   }
   void add_data(const org::apache::arrow::flatbuf::Buffer *data) {
     fbb_.AddStruct(Tensor::VT_DATA, data);
   }
-  explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TensorBuilder &operator=(const TensorBuilder &);
-  flatbuffers::Offset<Tensor> Finish() {
+  ::flatbuffers::Offset<Tensor> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Tensor>(end);
+    auto o = ::flatbuffers::Offset<Tensor>(end);
     fbb_.Required(o, Tensor::VT_TYPE);
     fbb_.Required(o, Tensor::VT_SHAPE);
     fbb_.Required(o, Tensor::VT_DATA);
@@ -350,13 +355,13 @@ struct TensorBuilder {
   }
 };
 
-inline flatbuffers::Offset<Tensor> CreateTensor(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Tensor> CreateTensor(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape = 0,
-    flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides = 0,
-    const org::apache::arrow::flatbuf::Buffer *data = 0) {
+    ::flatbuffers::Offset<void> type = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>> shape = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> strides = 0,
+    const org::apache::arrow::flatbuf::Buffer *data = nullptr) {
   TensorBuilder builder_(_fbb);
   builder_.add_data(data);
   builder_.add_strides(strides);
@@ -366,14 +371,14 @@ inline flatbuffers::Offset<Tensor> CreateTensor(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Tensor> CreateTensorDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Tensor> CreateTensorDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     org::apache::arrow::flatbuf::Type type_type = org::apache::arrow::flatbuf::Type::NONE,
-    flatbuffers::Offset<void> type = 0,
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape = nullptr,
+    ::flatbuffers::Offset<void> type = 0,
+    const std::vector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape = nullptr,
     const std::vector<int64_t> *strides = nullptr,
-    const org::apache::arrow::flatbuf::Buffer *data = 0) {
-  auto shape__ = shape ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>(*shape) : 0;
+    const org::apache::arrow::flatbuf::Buffer *data = nullptr) {
+  auto shape__ = shape ? _fbb.CreateVector<::flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>>(*shape) : 0;
   auto strides__ = strides ? _fbb.CreateVector<int64_t>(*strides) : 0;
   return org::apache::arrow::flatbuf::CreateTensor(
       _fbb,
@@ -385,32 +390,32 @@ inline flatbuffers::Offset<Tensor> CreateTensorDirect(
 }
 
 inline const org::apache::arrow::flatbuf::Tensor *GetTensor(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Tensor>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::Tensor>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::Tensor *GetSizePrefixedTensor(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Tensor>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Tensor>(buf);
 }
 
 inline bool VerifyTensorBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Tensor>(nullptr);
 }
 
 inline bool VerifySizePrefixedTensorBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Tensor>(nullptr);
 }
 
 inline void FinishTensorBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedTensorBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/src/generated/feather_generated.h b/cpp/src/generated/feather_generated.h
index b925eb2bc6a00..cc76b40501a47 100644
--- a/cpp/src/generated/feather_generated.h
+++ b/cpp/src/generated/feather_generated.h
@@ -6,6 +6,13 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 namespace arrow {
 namespace ipc {
 namespace feather {
@@ -114,7 +121,7 @@ inline const char * const *EnumNamesType() {
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::BOOL, Type::LARGE_BINARY)) return "";
+  if (::flatbuffers::IsOutRange(e, Type::BOOL, Type::LARGE_BINARY)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -150,7 +157,7 @@ inline const char * const *EnumNamesEncoding() {
 }
 
 inline const char *EnumNameEncoding(Encoding e) {
-  if (flatbuffers::IsOutRange(e, Encoding::PLAIN, Encoding::DICTIONARY)) return "";
+  if (::flatbuffers::IsOutRange(e, Encoding::PLAIN, Encoding::DICTIONARY)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesEncoding()[index];
 }
@@ -186,7 +193,7 @@ inline const char * const *EnumNamesTimeUnit() {
 }
 
 inline const char *EnumNameTimeUnit(TimeUnit e) {
-  if (flatbuffers::IsOutRange(e, TimeUnit::SECOND, TimeUnit::NANOSECOND)) return "";
+  if (::flatbuffers::IsOutRange(e, TimeUnit::SECOND, TimeUnit::NANOSECOND)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesTimeUnit()[index];
 }
@@ -225,7 +232,7 @@ inline const char * const *EnumNamesTypeMetadata() {
 }
 
 inline const char *EnumNameTypeMetadata(TypeMetadata e) {
-  if (flatbuffers::IsOutRange(e, TypeMetadata::NONE, TypeMetadata::TimeMetadata)) return "";
+  if (::flatbuffers::IsOutRange(e, TypeMetadata::NONE, TypeMetadata::TimeMetadata)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesTypeMetadata()[index];
 }
@@ -250,10 +257,10 @@ template<> struct TypeMetadataTraits<arrow::ipc::feather::fbs::TimeMetadata> {
   static const TypeMetadata enum_value = TypeMetadata::TimeMetadata;
 };
 
-bool VerifyTypeMetadata(flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type);
-bool VerifyTypeMetadataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+bool VerifyTypeMetadata(::flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type);
+bool VerifyTypeMetadataVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<TypeMetadata> *types);
 
-struct PrimitiveArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct PrimitiveArray FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef PrimitiveArrayBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_TYPE = 4,
@@ -286,22 +293,22 @@ struct PrimitiveArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int64_t total_bytes() const {
     return GetField<int64_t>(VT_TOTAL_BYTES, 0);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int8_t>(verifier, VT_TYPE) &&
-           VerifyField<int8_t>(verifier, VT_ENCODING) &&
-           VerifyField<int64_t>(verifier, VT_OFFSET) &&
-           VerifyField<int64_t>(verifier, VT_LENGTH) &&
-           VerifyField<int64_t>(verifier, VT_NULL_COUNT) &&
-           VerifyField<int64_t>(verifier, VT_TOTAL_BYTES) &&
+           VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
+           VerifyField<int8_t>(verifier, VT_ENCODING, 1) &&
+           VerifyField<int64_t>(verifier, VT_OFFSET, 8) &&
+           VerifyField<int64_t>(verifier, VT_LENGTH, 8) &&
+           VerifyField<int64_t>(verifier, VT_NULL_COUNT, 8) &&
+           VerifyField<int64_t>(verifier, VT_TOTAL_BYTES, 8) &&
            verifier.EndTable();
   }
 };
 
 struct PrimitiveArrayBuilder {
   typedef PrimitiveArray Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_type(arrow::ipc::feather::fbs::Type type) {
     fbb_.AddElement<int8_t>(PrimitiveArray::VT_TYPE, static_cast<int8_t>(type), 0);
   }
@@ -320,20 +327,19 @@ struct PrimitiveArrayBuilder {
   void add_total_bytes(int64_t total_bytes) {
     fbb_.AddElement<int64_t>(PrimitiveArray::VT_TOTAL_BYTES, total_bytes, 0);
   }
-  explicit PrimitiveArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit PrimitiveArrayBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PrimitiveArrayBuilder &operator=(const PrimitiveArrayBuilder &);
-  flatbuffers::Offset<PrimitiveArray> Finish() {
+  ::flatbuffers::Offset<PrimitiveArray> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<PrimitiveArray>(end);
+    auto o = ::flatbuffers::Offset<PrimitiveArray>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<PrimitiveArray> CreatePrimitiveArray(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<PrimitiveArray> CreatePrimitiveArray(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     arrow::ipc::feather::fbs::Type type = arrow::ipc::feather::fbs::Type::BOOL,
     arrow::ipc::feather::fbs::Encoding encoding = arrow::ipc::feather::fbs::Encoding::PLAIN,
     int64_t offset = 0,
@@ -350,7 +356,7 @@ inline flatbuffers::Offset<PrimitiveArray> CreatePrimitiveArray(
   return builder_.Finish();
 }
 
-struct CategoryMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct CategoryMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef CategoryMetadataBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_LEVELS = 4,
@@ -364,40 +370,39 @@ struct CategoryMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool ordered() const {
     return GetField<uint8_t>(VT_ORDERED, 0) != 0;
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_LEVELS) &&
            verifier.VerifyTable(levels()) &&
-           VerifyField<uint8_t>(verifier, VT_ORDERED) &&
+           VerifyField<uint8_t>(verifier, VT_ORDERED, 1) &&
            verifier.EndTable();
   }
 };
 
 struct CategoryMetadataBuilder {
   typedef CategoryMetadata Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_levels(flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> levels) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_levels(::flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> levels) {
     fbb_.AddOffset(CategoryMetadata::VT_LEVELS, levels);
   }
   void add_ordered(bool ordered) {
     fbb_.AddElement<uint8_t>(CategoryMetadata::VT_ORDERED, static_cast<uint8_t>(ordered), 0);
   }
-  explicit CategoryMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit CategoryMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  CategoryMetadataBuilder &operator=(const CategoryMetadataBuilder &);
-  flatbuffers::Offset<CategoryMetadata> Finish() {
+  ::flatbuffers::Offset<CategoryMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<CategoryMetadata>(end);
+    auto o = ::flatbuffers::Offset<CategoryMetadata>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<CategoryMetadata> CreateCategoryMetadata(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> levels = 0,
+inline ::flatbuffers::Offset<CategoryMetadata> CreateCategoryMetadata(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> levels = 0,
     bool ordered = false) {
   CategoryMetadataBuilder builder_(_fbb);
   builder_.add_levels(levels);
@@ -405,7 +410,7 @@ inline flatbuffers::Offset<CategoryMetadata> CreateCategoryMetadata(
   return builder_.Finish();
 }
 
-struct TimestampMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct TimestampMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TimestampMetadataBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4,
@@ -416,12 +421,12 @@ struct TimestampMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   }
   /// Timestamp data is assumed to be UTC, but the time zone is stored here for
   /// presentation as localized
-  const flatbuffers::String *timezone() const {
-    return GetPointer<const flatbuffers::String *>(VT_TIMEZONE);
+  const ::flatbuffers::String *timezone() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_TIMEZONE);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int8_t>(verifier, VT_UNIT) &&
+           VerifyField<int8_t>(verifier, VT_UNIT, 1) &&
            VerifyOffset(verifier, VT_TIMEZONE) &&
            verifier.VerifyString(timezone()) &&
            verifier.EndTable();
@@ -430,38 +435,37 @@ struct TimestampMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct TimestampMetadataBuilder {
   typedef TimestampMetadata Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(arrow::ipc::feather::fbs::TimeUnit unit) {
     fbb_.AddElement<int8_t>(TimestampMetadata::VT_UNIT, static_cast<int8_t>(unit), 0);
   }
-  void add_timezone(flatbuffers::Offset<flatbuffers::String> timezone) {
+  void add_timezone(::flatbuffers::Offset<::flatbuffers::String> timezone) {
     fbb_.AddOffset(TimestampMetadata::VT_TIMEZONE, timezone);
   }
-  explicit TimestampMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TimestampMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimestampMetadataBuilder &operator=(const TimestampMetadataBuilder &);
-  flatbuffers::Offset<TimestampMetadata> Finish() {
+  ::flatbuffers::Offset<TimestampMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<TimestampMetadata>(end);
+    auto o = ::flatbuffers::Offset<TimestampMetadata>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadata(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadata(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     arrow::ipc::feather::fbs::TimeUnit unit = arrow::ipc::feather::fbs::TimeUnit::SECOND,
-    flatbuffers::Offset<flatbuffers::String> timezone = 0) {
+    ::flatbuffers::Offset<::flatbuffers::String> timezone = 0) {
   TimestampMetadataBuilder builder_(_fbb);
   builder_.add_timezone(timezone);
   builder_.add_unit(unit);
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadataDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadataDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     arrow::ipc::feather::fbs::TimeUnit unit = arrow::ipc::feather::fbs::TimeUnit::SECOND,
     const char *timezone = nullptr) {
   auto timezone__ = timezone ? _fbb.CreateString(timezone) : 0;
@@ -471,9 +475,9 @@ inline flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadataDirect(
       timezone__);
 }
 
-struct DateMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct DateMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef DateMetadataBuilder Builder;
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -481,27 +485,26 @@ struct DateMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct DateMetadataBuilder {
   typedef DateMetadata Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  explicit DateMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  explicit DateMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DateMetadataBuilder &operator=(const DateMetadataBuilder &);
-  flatbuffers::Offset<DateMetadata> Finish() {
+  ::flatbuffers::Offset<DateMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<DateMetadata>(end);
+    auto o = ::flatbuffers::Offset<DateMetadata>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<DateMetadata> CreateDateMetadata(
-    flatbuffers::FlatBufferBuilder &_fbb) {
+inline ::flatbuffers::Offset<DateMetadata> CreateDateMetadata(
+    ::flatbuffers::FlatBufferBuilder &_fbb) {
   DateMetadataBuilder builder_(_fbb);
   return builder_.Finish();
 }
 
-struct TimeMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct TimeMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef TimeMetadataBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_UNIT = 4
@@ -509,41 +512,40 @@ struct TimeMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   arrow::ipc::feather::fbs::TimeUnit unit() const {
     return static_cast<arrow::ipc::feather::fbs::TimeUnit>(GetField<int8_t>(VT_UNIT, 0));
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int8_t>(verifier, VT_UNIT) &&
+           VerifyField<int8_t>(verifier, VT_UNIT, 1) &&
            verifier.EndTable();
   }
 };
 
 struct TimeMetadataBuilder {
   typedef TimeMetadata Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_unit(arrow::ipc::feather::fbs::TimeUnit unit) {
     fbb_.AddElement<int8_t>(TimeMetadata::VT_UNIT, static_cast<int8_t>(unit), 0);
   }
-  explicit TimeMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TimeMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimeMetadataBuilder &operator=(const TimeMetadataBuilder &);
-  flatbuffers::Offset<TimeMetadata> Finish() {
+  ::flatbuffers::Offset<TimeMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<TimeMetadata>(end);
+    auto o = ::flatbuffers::Offset<TimeMetadata>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<TimeMetadata> CreateTimeMetadata(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<TimeMetadata> CreateTimeMetadata(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     arrow::ipc::feather::fbs::TimeUnit unit = arrow::ipc::feather::fbs::TimeUnit::SECOND) {
   TimeMetadataBuilder builder_(_fbb);
   builder_.add_unit(unit);
   return builder_.Finish();
 }
 
-struct Column FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct Column FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ColumnBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_NAME = 4,
@@ -552,8 +554,8 @@ struct Column FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_METADATA = 10,
     VT_USER_METADATA = 12
   };
-  const flatbuffers::String *name() const {
-    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
   }
   const arrow::ipc::feather::fbs::PrimitiveArray *values() const {
     return GetPointer<const arrow::ipc::feather::fbs::PrimitiveArray *>(VT_VALUES);
@@ -578,16 +580,16 @@ struct Column FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return metadata_type() == arrow::ipc::feather::fbs::TypeMetadata::TimeMetadata ? static_cast<const arrow::ipc::feather::fbs::TimeMetadata *>(metadata()) : nullptr;
   }
   /// This should (probably) be JSON
-  const flatbuffers::String *user_metadata() const {
-    return GetPointer<const flatbuffers::String *>(VT_USER_METADATA);
+  const ::flatbuffers::String *user_metadata() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_USER_METADATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
            VerifyOffset(verifier, VT_VALUES) &&
            verifier.VerifyTable(values()) &&
-           VerifyField<uint8_t>(verifier, VT_METADATA_TYPE) &&
+           VerifyField<uint8_t>(verifier, VT_METADATA_TYPE, 1) &&
            VerifyOffset(verifier, VT_METADATA) &&
            VerifyTypeMetadata(verifier, metadata(), metadata_type()) &&
            VerifyOffset(verifier, VT_USER_METADATA) &&
@@ -614,42 +616,41 @@ template<> inline const arrow::ipc::feather::fbs::TimeMetadata *Column::metadata
 
 struct ColumnBuilder {
   typedef Column Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
     fbb_.AddOffset(Column::VT_NAME, name);
   }
-  void add_values(flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values) {
+  void add_values(::flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values) {
     fbb_.AddOffset(Column::VT_VALUES, values);
   }
   void add_metadata_type(arrow::ipc::feather::fbs::TypeMetadata metadata_type) {
     fbb_.AddElement<uint8_t>(Column::VT_METADATA_TYPE, static_cast<uint8_t>(metadata_type), 0);
   }
-  void add_metadata(flatbuffers::Offset<void> metadata) {
+  void add_metadata(::flatbuffers::Offset<void> metadata) {
     fbb_.AddOffset(Column::VT_METADATA, metadata);
   }
-  void add_user_metadata(flatbuffers::Offset<flatbuffers::String> user_metadata) {
+  void add_user_metadata(::flatbuffers::Offset<::flatbuffers::String> user_metadata) {
     fbb_.AddOffset(Column::VT_USER_METADATA, user_metadata);
   }
-  explicit ColumnBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit ColumnBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ColumnBuilder &operator=(const ColumnBuilder &);
-  flatbuffers::Offset<Column> Finish() {
+  ::flatbuffers::Offset<Column> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<Column>(end);
+    auto o = ::flatbuffers::Offset<Column>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<Column> CreateColumn(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::String> name = 0,
-    flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values = 0,
+inline ::flatbuffers::Offset<Column> CreateColumn(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
+    ::flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values = 0,
     arrow::ipc::feather::fbs::TypeMetadata metadata_type = arrow::ipc::feather::fbs::TypeMetadata::NONE,
-    flatbuffers::Offset<void> metadata = 0,
-    flatbuffers::Offset<flatbuffers::String> user_metadata = 0) {
+    ::flatbuffers::Offset<void> metadata = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> user_metadata = 0) {
   ColumnBuilder builder_(_fbb);
   builder_.add_user_metadata(user_metadata);
   builder_.add_metadata(metadata);
@@ -659,12 +660,12 @@ inline flatbuffers::Offset<Column> CreateColumn(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<Column> CreateColumnDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<Column> CreateColumnDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     const char *name = nullptr,
-    flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values = 0,
+    ::flatbuffers::Offset<arrow::ipc::feather::fbs::PrimitiveArray> values = 0,
     arrow::ipc::feather::fbs::TypeMetadata metadata_type = arrow::ipc::feather::fbs::TypeMetadata::NONE,
-    flatbuffers::Offset<void> metadata = 0,
+    ::flatbuffers::Offset<void> metadata = 0,
     const char *user_metadata = nullptr) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto user_metadata__ = user_metadata ? _fbb.CreateString(user_metadata) : 0;
@@ -677,7 +678,7 @@ inline flatbuffers::Offset<Column> CreateColumnDirect(
       user_metadata__);
 }
 
-struct CTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct CTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef CTableBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_DESCRIPTION = 4,
@@ -687,14 +688,14 @@ struct CTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_METADATA = 12
   };
   /// Some text (or a name) metadata about what the file is, optional
-  const flatbuffers::String *description() const {
-    return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
+  const ::flatbuffers::String *description() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_DESCRIPTION);
   }
   int64_t num_rows() const {
     return GetField<int64_t>(VT_NUM_ROWS, 0);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *columns() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *>(VT_COLUMNS);
+  const ::flatbuffers::Vector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *columns() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *>(VT_COLUMNS);
   }
   /// Version number of the Feather format
   ///
@@ -704,18 +705,18 @@ struct CTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     return GetField<int32_t>(VT_VERSION, 0);
   }
   /// Table metadata (likely JSON), not yet used
-  const flatbuffers::String *metadata() const {
-    return GetPointer<const flatbuffers::String *>(VT_METADATA);
+  const ::flatbuffers::String *metadata() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_METADATA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_DESCRIPTION) &&
            verifier.VerifyString(description()) &&
-           VerifyField<int64_t>(verifier, VT_NUM_ROWS) &&
+           VerifyField<int64_t>(verifier, VT_NUM_ROWS, 8) &&
            VerifyOffset(verifier, VT_COLUMNS) &&
            verifier.VerifyVector(columns()) &&
            verifier.VerifyVectorOfTables(columns()) &&
-           VerifyField<int32_t>(verifier, VT_VERSION) &&
+           VerifyField<int32_t>(verifier, VT_VERSION, 4) &&
            VerifyOffset(verifier, VT_METADATA) &&
            verifier.VerifyString(metadata()) &&
            verifier.EndTable();
@@ -724,42 +725,41 @@ struct CTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 
 struct CTableBuilder {
   typedef CTable Table;
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
-  void add_description(flatbuffers::Offset<flatbuffers::String> description) {
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_description(::flatbuffers::Offset<::flatbuffers::String> description) {
     fbb_.AddOffset(CTable::VT_DESCRIPTION, description);
   }
   void add_num_rows(int64_t num_rows) {
     fbb_.AddElement<int64_t>(CTable::VT_NUM_ROWS, num_rows, 0);
   }
-  void add_columns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>> columns) {
+  void add_columns(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>> columns) {
     fbb_.AddOffset(CTable::VT_COLUMNS, columns);
   }
   void add_version(int32_t version) {
     fbb_.AddElement<int32_t>(CTable::VT_VERSION, version, 0);
   }
-  void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
+  void add_metadata(::flatbuffers::Offset<::flatbuffers::String> metadata) {
     fbb_.AddOffset(CTable::VT_METADATA, metadata);
   }
-  explicit CTableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit CTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  CTableBuilder &operator=(const CTableBuilder &);
-  flatbuffers::Offset<CTable> Finish() {
+  ::flatbuffers::Offset<CTable> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<CTable>(end);
+    auto o = ::flatbuffers::Offset<CTable>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<CTable> CreateCTable(
-    flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::String> description = 0,
+inline ::flatbuffers::Offset<CTable> CreateCTable(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    ::flatbuffers::Offset<::flatbuffers::String> description = 0,
     int64_t num_rows = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>> columns = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>> columns = 0,
     int32_t version = 0,
-    flatbuffers::Offset<flatbuffers::String> metadata = 0) {
+    ::flatbuffers::Offset<::flatbuffers::String> metadata = 0) {
   CTableBuilder builder_(_fbb);
   builder_.add_num_rows(num_rows);
   builder_.add_metadata(metadata);
@@ -769,15 +769,15 @@ inline flatbuffers::Offset<CTable> CreateCTable(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<CTable> CreateCTableDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<CTable> CreateCTableDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     const char *description = nullptr,
     int64_t num_rows = 0,
-    const std::vector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *columns = nullptr,
+    const std::vector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>> *columns = nullptr,
     int32_t version = 0,
     const char *metadata = nullptr) {
   auto description__ = description ? _fbb.CreateString(description) : 0;
-  auto columns__ = columns ? _fbb.CreateVector<flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>(*columns) : 0;
+  auto columns__ = columns ? _fbb.CreateVector<::flatbuffers::Offset<arrow::ipc::feather::fbs::Column>>(*columns) : 0;
   auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
   return arrow::ipc::feather::fbs::CreateCTable(
       _fbb,
@@ -788,7 +788,7 @@ inline flatbuffers::Offset<CTable> CreateCTableDirect(
       metadata__);
 }
 
-inline bool VerifyTypeMetadata(flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type) {
+inline bool VerifyTypeMetadata(::flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type) {
   switch (type) {
     case TypeMetadata::NONE: {
       return true;
@@ -813,10 +813,10 @@ inline bool VerifyTypeMetadata(flatbuffers::Verifier &verifier, const void *obj,
   }
 }
 
-inline bool VerifyTypeMetadataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+inline bool VerifyTypeMetadataVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<TypeMetadata> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
-  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
     if (!VerifyTypeMetadata(
         verifier,  values->Get(i), types->GetEnum<TypeMetadata>(i))) {
       return false;
@@ -826,32 +826,32 @@ inline bool VerifyTypeMetadataVector(flatbuffers::Verifier &verifier, const flat
 }
 
 inline const arrow::ipc::feather::fbs::CTable *GetCTable(const void *buf) {
-  return flatbuffers::GetRoot<arrow::ipc::feather::fbs::CTable>(buf);
+  return ::flatbuffers::GetRoot<arrow::ipc::feather::fbs::CTable>(buf);
 }
 
 inline const arrow::ipc::feather::fbs::CTable *GetSizePrefixedCTable(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<arrow::ipc::feather::fbs::CTable>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<arrow::ipc::feather::fbs::CTable>(buf);
 }
 
 inline bool VerifyCTableBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<arrow::ipc::feather::fbs::CTable>(nullptr);
 }
 
 inline bool VerifySizePrefixedCTableBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<arrow::ipc::feather::fbs::CTable>(nullptr);
 }
 
 inline void FinishCTableBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedCTableBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
   fbb.FinishSizePrefixed(root);
 }
 
diff --git a/cpp/thirdparty/flatbuffers/README.md b/cpp/thirdparty/flatbuffers/README.md
index 447ad818a178a..53375048b35a3 100644
--- a/cpp/thirdparty/flatbuffers/README.md
+++ b/cpp/thirdparty/flatbuffers/README.md
@@ -18,54 +18,94 @@
 -->
 
 This directory contains a vendored version of Flatbuffers
-(unknown changeset), with two patches: the first patch
-for ARROW-15388 and the second patch for ARROW-17280.
-
-```diff
-diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
-index 955738067..fccce42f6 100644
---- a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
-+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
-@@ -212,13 +212,6 @@ namespace flatbuffers {
-         typedef std::experimental::string_view string_view;
-       }
-       #define FLATBUFFERS_HAS_STRING_VIEW 1
--    // Check for absl::string_view
--    #elif __has_include("absl/strings/string_view.h")
--      #include "absl/strings/string_view.h"
--      namespace flatbuffers {
--        typedef absl::string_view string_view;
--      }
--      #define FLATBUFFERS_HAS_STRING_VIEW 1
-     #endif
-   #endif // __has_include
- #endif // !FLATBUFFERS_HAS_STRING_VIEW
-```
+(v23.5.26), with a patch for ARROW-17280.
 
 ```diff
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
+index 30427190b..f0e91d0a3 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
+@@ -17,9 +17,15 @@
+ #ifndef FLATBUFFERS_ALLOCATOR_H_
+ #define FLATBUFFERS_ALLOCATOR_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // Allocator interface. This is flatbuffers-specific and meant only for
+ // `vector_downward` usage.
+@@ -63,6 +69,6 @@ class Allocator {
+   }
+ };
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_ALLOCATOR_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
+index f4bfbf054..f8e78243a 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
+@@ -17,6 +17,12 @@
+ #ifndef FLATBUFFERS_ARRAY_H_
+ #define FLATBUFFERS_ARRAY_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include <cstdint>
+ #include <memory>
+ 
+@@ -24,7 +30,7 @@
+ #include "flatbuffers/stl_emulation.h"
+ #include "flatbuffers/vector.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // This is used as a helper type for accessing arrays.
+ template<typename T, uint16_t length> class Array {
+@@ -251,6 +257,6 @@ bool operator==(const Array<T, length> &lhs,
+           std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);
+ }
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_ARRAY_H_
 diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
-index fccce42f6..a00d5b0fd 100644
+index 5c4cae791..1b0c7d987 100644
 --- a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
 +++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
-@@ -1,6 +1,14 @@
+@@ -1,6 +1,12 @@
  #ifndef FLATBUFFERS_BASE_H_
  #define FLATBUFFERS_BASE_H_
  
 +// Move this vendored copy of flatbuffers to a private namespace,
 +// but continue to access it through the "flatbuffers" alias.
-+namespace arrow_vendored_private {
-+namespace flatbuffers {
-+}
++namespace arrow_vendored_private::flatbuffers {
 +}
 +namespace flatbuffers = arrow_vendored_private::flatbuffers;
 +
  // clang-format off
  
  // If activate should be declared and included first.
-@@ -144,10 +152,12 @@
- #define FLATBUFFERS_VERSION_REVISION 0
+@@ -144,10 +150,13 @@
+ #define FLATBUFFERS_VERSION_REVISION 26
  #define FLATBUFFERS_STRING_EXPAND(X) #X
  #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
++
 +namespace arrow_vendored_private {
  namespace flatbuffers {
    // Returns version as string  "MAJOR.MINOR.REVISION".
@@ -75,28 +115,33 @@ index fccce42f6..a00d5b0fd 100644
  
  #if (!defined(_MSC_VER) || _MSC_VER > 1600) && \
      (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 407)) || \
-@@ -201,16 +211,20 @@ namespace flatbuffers {
+@@ -222,14 +231,14 @@ namespace flatbuffers {
      // Check for std::string_view (in c++17)
      #if __has_include(<string_view>) && (__cplusplus >= 201606 || (defined(_HAS_CXX17) && _HAS_CXX17))
        #include <string_view>
-+      namespace arrow_vendored_private {
-       namespace flatbuffers {
+-      namespace flatbuffers {
++      namespace arrow_vendored_private::flatbuffers {
          typedef std::string_view string_view;
        }
-+      }
        #define FLATBUFFERS_HAS_STRING_VIEW 1
      // Check for std::experimental::string_view (in c++14, compiler-dependent)
      #elif __has_include(<experimental/string_view>) && (__cplusplus >= 201411)
        #include <experimental/string_view>
-+      namespace arrow_vendored_private {
-       namespace flatbuffers {
+-      namespace flatbuffers {
++      namespace arrow_vendored_private::flatbuffers {
          typedef std::experimental::string_view string_view;
        }
-+      }
        #define FLATBUFFERS_HAS_STRING_VIEW 1
-     #endif
-   #endif // __has_include
-@@ -278,6 +292,7 @@ template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
+@@ -240,7 +249,7 @@ namespace flatbuffers {
+       #include "absl/base/config.h"
+       #if !defined(ABSL_USES_STD_STRING_VIEW)
+         #include "absl/strings/string_view.h"
+-        namespace flatbuffers {
++        namespace arrow_vendored_private::flatbuffers {
+           typedef absl::string_view string_view;
+         }
+         #define FLATBUFFERS_HAS_STRING_VIEW 1
+@@ -317,6 +326,7 @@ template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
  /// @endcond
  
  /// @file
@@ -104,33 +149,193 @@ index fccce42f6..a00d5b0fd 100644
  namespace flatbuffers {
  
  /// @cond FLATBUFFERS_INTERNAL
-@@ -388,4 +403,5 @@ inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
+@@ -492,4 +502,6 @@ inline bool IsInRange(const T &v, const T &low, const T &high) {
  }
  
  }  // namespace flatbuffers
 +}  // namespace arrow_vendored_private
++
  #endif  // FLATBUFFERS_BASE_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
+index 94d4f7903..e791c3007 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
+@@ -17,11 +17,17 @@
+ #ifndef FLATBUFFERS_BUFFER_H_
+ #define FLATBUFFERS_BUFFER_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include <algorithm>
+ 
+ #include "flatbuffers/base.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // Wrapper for uoffset_t to allow safe template specialization.
+ // Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
+@@ -194,6 +200,6 @@ const T *GetSizePrefixedRoot(const void *buf) {
+   return GetRoot<T>(reinterpret_cast<const uint8_t *>(buf) + sizeof(SizeT));
+ }
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_BUFFER_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
+index f70941fc6..8a4a43f81 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
+@@ -17,10 +17,16 @@
+ #ifndef FLATBUFFERS_BUFFER_REF_H_
+ #define FLATBUFFERS_BUFFER_REF_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/verifier.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // Convenient way to bundle a buffer and its length, to pass it around
+ // typed by its root.
+@@ -48,6 +54,6 @@ template<typename T> struct BufferRef : BufferRefBase {
+   bool must_free;
+ };
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_BUFFER_REF_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
+index d4724122c..fd2dc60a9 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
+@@ -17,10 +17,16 @@
+ #ifndef FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+ #define FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/allocator.h"
+ #include "flatbuffers/base.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // DefaultAllocator uses new/delete to allocate memory regions
+ class DefaultAllocator : public Allocator {
+@@ -59,6 +65,6 @@ inline uint8_t *ReallocateDownward(Allocator *allocator, uint8_t *old_p,
+                          old_p, old_size, new_size, in_use_back, in_use_front);
+ }
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
+index 5e900baeb..4779545b3 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
+@@ -17,11 +17,17 @@
+ #ifndef FLATBUFFERS_DETACHED_BUFFER_H_
+ #define FLATBUFFERS_DETACHED_BUFFER_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/allocator.h"
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/default_allocator.h"
+ 
+-namespace flatbuffers {
++namespace arrow_vendored_private::flatbuffers {
+ 
+ // DetachedBuffer is a finished flatbuffer memory region, detached from its
+ // builder. The original memory region and allocator are also stored so that
+@@ -109,6 +115,6 @@ class DetachedBuffer {
+   }
+ };
+ 
+-}  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_DETACHED_BUFFER_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
+index 0a38b4ac3..5825cc05c 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
+@@ -17,6 +17,12 @@
+ #ifndef FLATBUFFERS_FLATBUFFER_BUILDER_H_
+ #define FLATBUFFERS_FLATBUFFER_BUILDER_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include <algorithm>
+ #include <cstdint>
+ #include <functional>
+@@ -38,6 +44,7 @@
+ #include "flatbuffers/vector_downward.h"
+ #include "flatbuffers/verifier.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ // Converts a Field ID to a virtual table offset.
+@@ -1461,5 +1468,6 @@ const T *GetTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
+ }
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_FLATBUFFER_BUILDER_H_
 diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
-index c4dc5bcd0..2f7eb5fcf 100644
+index bc828a313..8aa19a65c 100644
 --- a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
 +++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
-@@ -23,6 +23,15 @@
- #  include <cmath>
- #endif
+@@ -17,6 +17,12 @@
+ #ifndef FLATBUFFERS_H_
+ #define FLATBUFFERS_H_
  
 +// Move this vendored copy of flatbuffers to a private namespace,
 +// but continue to access it through the "flatbuffers" alias.
-+namespace arrow_vendored_private {
-+namespace flatbuffers {
-+}
++namespace arrow_vendored_private::flatbuffers {
 +}
 +namespace flatbuffers = arrow_vendored_private::flatbuffers;
 +
+ #include <algorithm>
+ 
+ // TODO: These includes are for mitigating the pains of users editing their
+@@ -35,6 +41,7 @@
+ #include "flatbuffers/vector_downward.h"
+ #include "flatbuffers/verifier.h"
+ 
 +namespace arrow_vendored_private {
  namespace flatbuffers {
- // Generic 'operator==' with conditional specialisations.
- // T e - new value of a scalar field.
-@@ -2777,6 +2786,7 @@ volatile __attribute__((weak)) const char *flatbuffer_version_string =
+ 
+ /// @brief This can compute the start of a FlatBuffer from a root pointer, i.e.
+@@ -278,6 +285,7 @@ inline const char *flatbuffers_version_string() {
      }
  /// @endcond
  }  // namespace flatbuffers
@@ -139,39 +344,210 @@ index c4dc5bcd0..2f7eb5fcf 100644
  // clang-format on
  
 diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
-index 8bae61bfd..7e5a95233 100644
+index fd3a8cda7..dcbe23347 100644
 --- a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
 +++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
-@@ -25,6 +25,14 @@
+@@ -26,6 +26,12 @@
  #include <memory>
  #include <limits>
  
 +// Move this vendored copy of flatbuffers to a private namespace,
 +// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #ifndef FLATBUFFERS_USE_STD_OPTIONAL
+   // Detect C++17 compatible compiler.
+   // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+@@ -64,6 +70,7 @@
+ #endif // defined(FLATBUFFERS_USE_STD_SPAN)
+ 
+ // This header provides backwards compatibility for older versions of the STL.
 +namespace arrow_vendored_private {
-+namespace flatbuffers {
+ namespace flatbuffers {
+ 
+ #if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+@@ -509,5 +516,6 @@ flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType
+ #endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_STL_EMULATION_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
+index 97e399fd6..1cdba4588 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
+@@ -17,9 +17,16 @@
+ #ifndef FLATBUFFERS_STRING_H_
+ #define FLATBUFFERS_STRING_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
 +}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/vector.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ struct String : public Vector<char> {
+@@ -60,5 +67,6 @@ static inline flatbuffers::string_view GetStringView(const String *str) {
+ #endif  // FLATBUFFERS_HAS_STRING_VIEW
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_STRING_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
+index abacc8a9a..92a8e80bf 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
+@@ -17,8 +17,15 @@
+ #ifndef FLATBUFFERS_STRUCT_H_
+ #define FLATBUFFERS_STRUCT_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
 +}
 +namespace flatbuffers = arrow_vendored_private::flatbuffers;
 +
- #if defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL)
-   #define FLATBUFFERS_CPP98_STL
- #endif  // defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL)
-@@ -44,6 +52,7 @@
- #endif
+ #include "flatbuffers/base.h"
  
- // This header provides backwards compatibility for C++98 STLs like stlport.
 +namespace arrow_vendored_private {
  namespace flatbuffers {
  
- // Retrieve ::back() from a string in a way that is compatible with pre C++11
-@@ -303,5 +312,6 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
- #endif  // !FLATBUFFERS_CPP98_STL
+ // "structs" are flat structures that do not have an offset table, thus
+@@ -49,5 +56,6 @@ class Struct FLATBUFFERS_FINAL_CLASS {
+ };
  
  }  // namespace flatbuffers
 +}  // namespace arrow_vendored_private
  
- #endif  // FLATBUFFERS_STL_EMULATION_H_
+ #endif  // FLATBUFFERS_STRUCT_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
+index e92d8ae8e..762563daf 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
+@@ -17,9 +17,16 @@
+ #ifndef FLATBUFFERS_TABLE_H_
+ #define FLATBUFFERS_TABLE_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/verifier.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ // "tables" use an offset table (possibly shared) that allows fields to be
+@@ -184,5 +191,6 @@ inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
+ }
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_TABLE_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
+index ae52b9382..94591859a 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
+@@ -17,10 +17,17 @@
+ #ifndef FLATBUFFERS_VECTOR_H_
+ #define FLATBUFFERS_VECTOR_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/buffer.h"
+ #include "flatbuffers/stl_emulation.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ struct String;
+@@ -393,5 +400,6 @@ template<typename T> static inline size_t VectorLength(const Vector<T> *v) {
+ }
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_VERIFIER_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
+index 2b5a92cf1..a87b17b66 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
+@@ -17,6 +17,12 @@
+ #ifndef FLATBUFFERS_VECTOR_DOWNWARD_H_
+ #define FLATBUFFERS_VECTOR_DOWNWARD_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include <algorithm>
+ #include <cstdint>
+ 
+@@ -24,6 +30,7 @@
+ #include "flatbuffers/default_allocator.h"
+ #include "flatbuffers/detached_buffer.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ // This is a minimal replication of std::vector<uint8_t> functionality,
+@@ -285,5 +292,6 @@ template<typename SizeT = uoffset_t> class vector_downward {
+ };
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_VECTOR_DOWNWARD_H_
+diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h
+index de1146be9..f6f5ac7f2 100644
+--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h
++++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h
+@@ -17,9 +17,16 @@
+ #ifndef FLATBUFFERS_VERIFIER_H_
+ #define FLATBUFFERS_VERIFIER_H_
+ 
++// Move this vendored copy of flatbuffers to a private namespace,
++// but continue to access it through the "flatbuffers" alias.
++namespace arrow_vendored_private::flatbuffers {
++}
++namespace flatbuffers = arrow_vendored_private::flatbuffers;
++
+ #include "flatbuffers/base.h"
+ #include "flatbuffers/vector.h"
+ 
++namespace arrow_vendored_private {
+ namespace flatbuffers {
+ 
+ // Helper class to verify the integrity of a FlatBuffer
+@@ -328,5 +335,6 @@ inline size_t Verifier::VerifyOffset<uoffset64_t>(const size_t start) const {
+ }
+ 
+ }  // namespace flatbuffers
++}  // namespace arrow_vendored_private
+ 
+ #endif  // FLATBUFFERS_VERIFIER_H_
 -- 
-2.25.1
+2.34.1
+
 ```
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
new file mode 100644
index 0000000000000..f0e91d0a31a53
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/allocator.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_ALLOCATOR_H_
+#define FLATBUFFERS_ALLOCATOR_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// Allocator interface. This is flatbuffers-specific and meant only for
+// `vector_downward` usage.
+class Allocator {
+ public:
+  virtual ~Allocator() {}
+
+  // Allocate `size` bytes of memory.
+  virtual uint8_t *allocate(size_t size) = 0;
+
+  // Deallocate `size` bytes of memory at `p` allocated by this allocator.
+  virtual void deallocate(uint8_t *p, size_t size) = 0;
+
+  // Reallocate `new_size` bytes of memory, replacing the old region of size
+  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
+  // and is intended specifcally for `vector_downward` use.
+  // `in_use_back` and `in_use_front` indicate how much of `old_size` is
+  // actually in use at each end, and needs to be copied.
+  virtual uint8_t *reallocate_downward(uint8_t *old_p, size_t old_size,
+                                       size_t new_size, size_t in_use_back,
+                                       size_t in_use_front) {
+    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
+    uint8_t *new_p = allocate(new_size);
+    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
+                    in_use_front);
+    deallocate(old_p, old_size);
+    return new_p;
+  }
+
+ protected:
+  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`
+  // to `new_p` of `new_size`. Only memory of size `in_use_front` and
+  // `in_use_back` will be copied from the front and back of the old memory
+  // allocation.
+  void memcpy_downward(uint8_t *old_p, size_t old_size, uint8_t *new_p,
+                       size_t new_size, size_t in_use_back,
+                       size_t in_use_front) {
+    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,
+           in_use_back);
+    memcpy(new_p, old_p, in_use_front);
+  }
+};
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_ALLOCATOR_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
new file mode 100644
index 0000000000000..f8e78243a461a
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/array.h
@@ -0,0 +1,262 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_ARRAY_H_
+#define FLATBUFFERS_ARRAY_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include <cstdint>
+#include <memory>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/vector.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// This is used as a helper type for accessing arrays.
+template<typename T, uint16_t length> class Array {
+  // Array<T> can carry only POD data types (scalars or structs).
+  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
+      scalar_tag;
+  typedef
+      typename flatbuffers::conditional<scalar_tag::value, T, const T *>::type
+          IndirectHelperType;
+
+ public:
+  typedef uint16_t size_type;
+  typedef typename IndirectHelper<IndirectHelperType>::return_type return_type;
+  typedef VectorConstIterator<T, return_type, uoffset_t> const_iterator;
+  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
+
+  // If T is a LE-scalar or a struct (!scalar_tag::value).
+  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
+      (scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
+      !scalar_tag::value;
+
+  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
+
+  return_type Get(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return IndirectHelper<IndirectHelperType>::Read(Data(), i);
+  }
+
+  return_type operator[](uoffset_t i) const { return Get(i); }
+
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template<typename E> E GetEnum(uoffset_t i) const {
+    return static_cast<E>(Get(i));
+  }
+
+  const_iterator begin() const { return const_iterator(Data(), 0); }
+  const_iterator end() const { return const_iterator(Data(), size()); }
+
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  const_reverse_iterator crend() const { return rend(); }
+
+  // Get a mutable pointer to elements inside this array.
+  // This method used to mutate arrays of structs followed by a @p Mutate
+  // operation. For primitive types use @p Mutate directly.
+  // @warning Assignments and reads to/from the dereferenced pointer are not
+  //  automatically converted to the correct endianness.
+  typename flatbuffers::conditional<scalar_tag::value, void, T *>::type
+  GetMutablePointer(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return const_cast<T *>(&data()[i]);
+  }
+
+  // Change elements if you have a non-const pointer to this object.
+  void Mutate(uoffset_t i, const T &val) { MutateImpl(scalar_tag(), i, val); }
+
+  // The raw data in little endian format. Use with care.
+  const uint8_t *Data() const { return data_; }
+
+  uint8_t *Data() { return data_; }
+
+  // Similarly, but typed, much like std::vector::data
+  const T *data() const { return reinterpret_cast<const T *>(Data()); }
+  T *data() { return reinterpret_cast<T *>(Data()); }
+
+  // Copy data from a span with endian conversion.
+  // If this Array and the span overlap, the behavior is undefined.
+  void CopyFromSpan(flatbuffers::span<const T, length> src) {
+    const auto p1 = reinterpret_cast<const uint8_t *>(src.data());
+    const auto p2 = Data();
+    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
+                       !(p2 >= p1 && p2 < (p1 + length)));
+    (void)p1;
+    (void)p2;
+    CopyFromSpanImpl(flatbuffers::bool_constant<is_span_observable>(), src);
+  }
+
+ protected:
+  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T &val) {
+    FLATBUFFERS_ASSERT(i < size());
+    WriteScalar(data() + i, val);
+  }
+
+  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T &val) {
+    *(GetMutablePointer(i)) = val;
+  }
+
+  void CopyFromSpanImpl(flatbuffers::true_type,
+                        flatbuffers::span<const T, length> src) {
+    // Use std::memcpy() instead of std::copy() to avoid performance degradation
+    // due to aliasing if T is char or unsigned char.
+    // The size is known at compile time, so memcpy would be inlined.
+    std::memcpy(data(), src.data(), length * sizeof(T));
+  }
+
+  // Copy data from flatbuffers::span with endian conversion.
+  void CopyFromSpanImpl(flatbuffers::false_type,
+                        flatbuffers::span<const T, length> src) {
+    for (size_type k = 0; k < length; k++) { Mutate(k, src[k]); }
+  }
+
+  // This class is only used to access pre-existing data. Don't ever
+  // try to construct these manually.
+  // 'constexpr' allows us to use 'size()' at compile time.
+  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on
+  //  a constructor.
+#if defined(__cpp_constexpr)
+  constexpr Array();
+#else
+  Array();
+#endif
+
+  uint8_t data_[length * sizeof(T)];
+
+ private:
+  // This class is a pointer. Copying will therefore create an invalid object.
+  // Private and unimplemented copy constructor.
+  Array(const Array &);
+  Array &operator=(const Array &);
+};
+
+// Specialization for Array[struct] with access using Offset<void> pointer.
+// This specialization used by idl_gen_text.cpp.
+template<typename T, uint16_t length, template<typename> class OffsetT>
+class Array<OffsetT<T>, length> {
+  static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
+
+ public:
+  typedef const void *return_type;
+  typedef uint16_t size_type;
+
+  const uint8_t *Data() const { return data_; }
+
+  // Make idl_gen_text.cpp::PrintContainer happy.
+  return_type operator[](uoffset_t) const {
+    FLATBUFFERS_ASSERT(false);
+    return nullptr;
+  }
+
+ private:
+  // This class is only used to access pre-existing data.
+  Array();
+  Array(const Array &);
+  Array &operator=(const Array &);
+
+  uint8_t data_[1];
+};
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N> &arr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<U, N>(arr.data(), N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U, N> make_span(
+    const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<const U, N>(arr.data(), N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t, sizeof(U) * N>
+make_bytes_span(Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t, sizeof(U) * N>
+make_bytes_span(const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+// Cast a raw T[length] to a raw flatbuffers::Array<T, length>
+// without endian conversion. Use with care.
+// TODO: move these Cast-methods to `internal` namespace.
+template<typename T, uint16_t length>
+Array<T, length> &CastToArray(T (&arr)[length]) {
+  return *reinterpret_cast<Array<T, length> *>(arr);
+}
+
+template<typename T, uint16_t length>
+const Array<T, length> &CastToArray(const T (&arr)[length]) {
+  return *reinterpret_cast<const Array<T, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+Array<E, length> &CastToArrayOfEnum(T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<Array<E, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+const Array<E, length> &CastToArrayOfEnum(const T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<const Array<E, length> *>(arr);
+}
+
+template<typename T, uint16_t length>
+bool operator==(const Array<T, length> &lhs,
+                const Array<T, length> &rhs) noexcept {
+  return std::addressof(lhs) == std::addressof(rhs) ||
+         (lhs.size() == rhs.size() &&
+          std::memcmp(lhs.Data(), rhs.Data(), rhs.size() * sizeof(T)) == 0);
+}
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_ARRAY_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
index a00d5b0fd2a59..1b0c7d9877e39 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/base.h
@@ -3,9 +3,7 @@
 
 // Move this vendored copy of flatbuffers to a private namespace,
 // but continue to access it through the "flatbuffers" alias.
-namespace arrow_vendored_private {
-namespace flatbuffers {
-}
+namespace arrow_vendored_private::flatbuffers {
 }
 namespace flatbuffers = arrow_vendored_private::flatbuffers;
 
@@ -40,7 +38,7 @@ namespace flatbuffers = arrow_vendored_private::flatbuffers;
 #include <cstdlib>
 #include <cstring>
 
-#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H)
+#if defined(ARDUINO) && !defined(ARDUINOSTL_M_H) && defined(__AVR__)
   #include <utility.h>
 #else
   #include <utility>
@@ -51,17 +49,17 @@ namespace flatbuffers = arrow_vendored_private::flatbuffers;
 #include <vector>
 #include <set>
 #include <algorithm>
+#include <limits>
 #include <iterator>
 #include <memory>
 
-#ifdef _STLPORT_VERSION
-  #define FLATBUFFERS_CPP98_STL
-#endif
-#ifndef FLATBUFFERS_CPP98_STL
-  #include <functional>
+#if defined(__unix__) && !defined(FLATBUFFERS_LOCALE_INDEPENDENT)
+  #include <unistd.h>
 #endif
 
-#include "flatbuffers/stl_emulation.h"
+#ifdef __ANDROID__
+  #include <android/api-level.h>
+#endif
 
 #if defined(__ICCARM__)
 #include <intrinsics.h>
@@ -147,11 +145,12 @@ namespace flatbuffers = arrow_vendored_private::flatbuffers;
   #endif
 #endif // !defined(FLATBUFFERS_LITTLEENDIAN)
 
-#define FLATBUFFERS_VERSION_MAJOR 1
-#define FLATBUFFERS_VERSION_MINOR 12
-#define FLATBUFFERS_VERSION_REVISION 0
+#define FLATBUFFERS_VERSION_MAJOR 23
+#define FLATBUFFERS_VERSION_MINOR 5
+#define FLATBUFFERS_VERSION_REVISION 26
 #define FLATBUFFERS_STRING_EXPAND(X) #X
 #define FLATBUFFERS_STRING(X) FLATBUFFERS_STRING_EXPAND(X)
+
 namespace arrow_vendored_private {
 namespace flatbuffers {
   // Returns version as string  "MAJOR.MINOR.REVISION".
@@ -164,10 +163,12 @@ namespace flatbuffers {
     defined(__clang__)
   #define FLATBUFFERS_FINAL_CLASS final
   #define FLATBUFFERS_OVERRIDE override
+  #define FLATBUFFERS_EXPLICIT_CPP11 explicit
   #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE : flatbuffers::voffset_t
 #else
   #define FLATBUFFERS_FINAL_CLASS
   #define FLATBUFFERS_OVERRIDE
+  #define FLATBUFFERS_EXPLICIT_CPP11
   #define FLATBUFFERS_VTABLE_UNDERLYING_TYPE
 #endif
 
@@ -175,13 +176,16 @@ namespace flatbuffers {
     (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 406)) || \
     (defined(__cpp_constexpr) && __cpp_constexpr >= 200704)
   #define FLATBUFFERS_CONSTEXPR constexpr
+  #define FLATBUFFERS_CONSTEXPR_CPP11 constexpr
+  #define FLATBUFFERS_CONSTEXPR_DEFINED
 #else
   #define FLATBUFFERS_CONSTEXPR const
+  #define FLATBUFFERS_CONSTEXPR_CPP11
 #endif
 
 #if (defined(__cplusplus) && __cplusplus >= 201402L) || \
     (defined(__cpp_constexpr) && __cpp_constexpr >= 201304)
-  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR
+  #define FLATBUFFERS_CONSTEXPR_CPP14 FLATBUFFERS_CONSTEXPR_CPP11
 #else
   #define FLATBUFFERS_CONSTEXPR_CPP14
 #endif
@@ -199,9 +203,25 @@ namespace flatbuffers {
 #if (!defined(_MSC_VER) || _MSC_FULL_VER >= 180020827) && \
     (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 404)) || \
     defined(__clang__)
-  #define FLATBUFFERS_DELETE_FUNC(func) func = delete;
+  #define FLATBUFFERS_DELETE_FUNC(func) func = delete
 #else
-  #define FLATBUFFERS_DELETE_FUNC(func) private: func;
+  #define FLATBUFFERS_DELETE_FUNC(func) private: func
+#endif
+
+#if (!defined(_MSC_VER) || _MSC_VER >= 1900) && \
+    (!defined(__GNUC__) || (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)) || \
+    defined(__clang__)
+  #define FLATBUFFERS_DEFAULT_DECLARATION
+#endif
+
+// Check if we can use template aliases
+// Not possible if Microsoft Compiler before 2012
+// Possible is the language feature __cpp_alias_templates is defined well
+// Or possible if the C++ std is C+11 or newer
+#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
+    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
+    || (defined(__cplusplus) && __cplusplus >= 201103L)
+  #define FLATBUFFERS_TEMPLATES_ALIASES
 #endif
 
 #ifndef FLATBUFFERS_HAS_STRING_VIEW
@@ -211,25 +231,38 @@ namespace flatbuffers {
     // Check for std::string_view (in c++17)
     #if __has_include(<string_view>) && (__cplusplus >= 201606 || (defined(_HAS_CXX17) && _HAS_CXX17))
       #include <string_view>
-      namespace arrow_vendored_private {
-      namespace flatbuffers {
+      namespace arrow_vendored_private::flatbuffers {
         typedef std::string_view string_view;
       }
-      }
       #define FLATBUFFERS_HAS_STRING_VIEW 1
     // Check for std::experimental::string_view (in c++14, compiler-dependent)
     #elif __has_include(<experimental/string_view>) && (__cplusplus >= 201411)
       #include <experimental/string_view>
-      namespace arrow_vendored_private {
-      namespace flatbuffers {
+      namespace arrow_vendored_private::flatbuffers {
         typedef std::experimental::string_view string_view;
       }
-      }
       #define FLATBUFFERS_HAS_STRING_VIEW 1
+    // Check for absl::string_view
+    #elif __has_include("absl/strings/string_view.h") && \
+          __has_include("absl/base/config.h") && \
+          (__cplusplus >= 201411)
+      #include "absl/base/config.h"
+      #if !defined(ABSL_USES_STD_STRING_VIEW)
+        #include "absl/strings/string_view.h"
+        namespace arrow_vendored_private::flatbuffers {
+          typedef absl::string_view string_view;
+        }
+        #define FLATBUFFERS_HAS_STRING_VIEW 1
+      #endif
     #endif
   #endif // __has_include
 #endif // !FLATBUFFERS_HAS_STRING_VIEW
 
+#ifndef FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+  // Allow heap allocations to be used
+  #define FLATBUFFERS_GENERAL_HEAP_ALLOC_OK 1
+#endif // !FLATBUFFERS_GENERAL_HEAP_ALLOC_OK
+
 #ifndef FLATBUFFERS_HAS_NEW_STRTOD
   // Modern (C++11) strtod and strtof functions are available for use.
   // 1) nan/inf strings as argument of strtod;
@@ -242,11 +275,12 @@ namespace flatbuffers {
 #endif // !FLATBUFFERS_HAS_NEW_STRTOD
 
 #ifndef FLATBUFFERS_LOCALE_INDEPENDENT
-  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l, strtoull_l}.
-  // They are part of the POSIX-2008 but not part of the C/C++ standard.
-  // GCC/Clang have definition (_XOPEN_SOURCE>=700) if POSIX-2008.
-  #if ((defined(_MSC_VER) && _MSC_VER >= 1800)            || \
-       (defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE>=700)))
+  // Enable locale independent functions {strtof_l, strtod_l,strtoll_l,
+  // strtoull_l}.
+  #if (defined(_MSC_VER) && _MSC_VER >= 1800) || \
+      (defined(__ANDROID_API__) && __ANDROID_API__>= 21) || \
+      (defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 700)) && \
+        (!defined(__Fuchsia__) && !defined(__ANDROID_API__))
     #define FLATBUFFERS_LOCALE_INDEPENDENT 1
   #else
     #define FLATBUFFERS_LOCALE_INDEPENDENT 0
@@ -254,14 +288,14 @@ namespace flatbuffers {
 #endif  // !FLATBUFFERS_LOCALE_INDEPENDENT
 
 // Suppress Undefined Behavior Sanitizer (recoverable only). Usage:
-// - __supress_ubsan__("undefined")
-// - __supress_ubsan__("signed-integer-overflow")
+// - FLATBUFFERS_SUPPRESS_UBSAN("undefined")
+// - FLATBUFFERS_SUPPRESS_UBSAN("signed-integer-overflow")
 #if defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >=7))
-  #define __supress_ubsan__(type) __attribute__((no_sanitize(type)))
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize(type)))
 #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 409)
-  #define __supress_ubsan__(type) __attribute__((no_sanitize_undefined))
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type) __attribute__((no_sanitize_undefined))
 #else
-  #define __supress_ubsan__(type)
+  #define FLATBUFFERS_SUPPRESS_UBSAN(type)
 #endif
 
 // This is constexpr function used for checking compile-time constants.
@@ -274,7 +308,7 @@ template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConstTrue(T t) {
 #if ((__cplusplus >= 201703L) \
     || (defined(_MSVC_LANG) &&  (_MSVC_LANG >= 201703L)))
   // All attributes unknown to an implementation are ignored without causing an error.
-  #define FLATBUFFERS_ATTRIBUTE(attr) [[attr]]
+  #define FLATBUFFERS_ATTRIBUTE(attr) attr
 
   #define FLATBUFFERS_FALLTHROUGH() [[fallthrough]]
 #else
@@ -300,9 +334,11 @@ namespace flatbuffers {
 // Also, using a consistent offset type maintains compatibility of serialized
 // offset values between 32bit and 64bit systems.
 typedef uint32_t uoffset_t;
+typedef uint64_t uoffset64_t;
 
 // Signed offsets for references that can go in both directions.
 typedef int32_t soffset_t;
+typedef int64_t soffset64_t;
 
 // Offset/index used in v-tables, can be changed to uint8_t in
 // format forks to save a bit of space if desired.
@@ -311,12 +347,31 @@ typedef uint16_t voffset_t;
 typedef uintmax_t largest_scalar_t;
 
 // In 32bits, this evaluates to 2GB - 1
-#define FLATBUFFERS_MAX_BUFFER_SIZE ((1ULL << (sizeof(::flatbuffers::soffset_t) * 8 - 1)) - 1)
+#define FLATBUFFERS_MAX_BUFFER_SIZE std::numeric_limits<::flatbuffers::soffset_t>::max()
+#define FLATBUFFERS_MAX_64_BUFFER_SIZE std::numeric_limits<::flatbuffers::soffset64_t>::max()
+
+// The minimum size buffer that can be a valid flatbuffer.
+// Includes the offset to the root table (uoffset_t), the offset to the vtable
+// of the root table (soffset_t), the size of the vtable (uint16_t), and the
+// size of the referring table (uint16_t).
+#define FLATBUFFERS_MIN_BUFFER_SIZE sizeof(uoffset_t) + sizeof(soffset_t) + \
+   sizeof(uint16_t) + sizeof(uint16_t)
 
 // We support aligning the contents of buffers up to this size.
-#define FLATBUFFERS_MAX_ALIGNMENT 16
+#ifndef FLATBUFFERS_MAX_ALIGNMENT
+  #define FLATBUFFERS_MAX_ALIGNMENT 32
+#endif
+
+/// @brief The length of a FlatBuffer file header.
+static const size_t kFileIdentifierLength = 4;
+
+inline bool VerifyAlignmentRequirements(size_t align, size_t min_align = 1) {
+  return (min_align <= align) && (align <= (FLATBUFFERS_MAX_ALIGNMENT)) &&
+         (align & (align - 1)) == 0;  // must be power of 2
+}
 
 #if defined(_MSC_VER)
+  #pragma warning(disable: 4351) // C4351: new behavior: elements of array ... will be default initialized
   #pragma warning(push)
   #pragma warning(disable: 4127) // C4127: conditional expression is constant
 #endif
@@ -377,31 +432,76 @@ template<typename T> T EndianScalar(T t) {
 
 template<typename T>
 // UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-__supress_ubsan__("alignment")
+FLATBUFFERS_SUPPRESS_UBSAN("alignment")
 T ReadScalar(const void *p) {
   return EndianScalar(*reinterpret_cast<const T *>(p));
 }
 
+// See https://github.com/google/flatbuffers/issues/5950
+
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
 template<typename T>
 // UBSAN: C++ aliasing type rules, see std::bit_cast<> for details.
-__supress_ubsan__("alignment")
+FLATBUFFERS_SUPPRESS_UBSAN("alignment")
 void WriteScalar(void *p, T t) {
   *reinterpret_cast<T *>(p) = EndianScalar(t);
 }
 
 template<typename T> struct Offset;
-template<typename T> __supress_ubsan__("alignment") void WriteScalar(void *p, Offset<T> t) {
+template<typename T> FLATBUFFERS_SUPPRESS_UBSAN("alignment") void WriteScalar(void *p, Offset<T> t) {
   *reinterpret_cast<uoffset_t *>(p) = EndianScalar(t.o);
 }
 
+#if (FLATBUFFERS_GCC >= 100000) && (FLATBUFFERS_GCC < 110000)
+  #pragma GCC diagnostic pop
+#endif
+
 // Computes how many bytes you'd have to pad to be able to write an
 // "scalar_size" scalar if the buffer had grown to "buf_size" (downwards in
 // memory).
-__supress_ubsan__("unsigned-integer-overflow")
+FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
 inline size_t PaddingBytes(size_t buf_size, size_t scalar_size) {
   return ((~buf_size) + 1) & (scalar_size - 1);
 }
 
+// Generic 'operator==' with conditional specialisations.
+// T e - new value of a scalar field.
+// T def - default of scalar (is known at compile-time).
+template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
+
+#if defined(FLATBUFFERS_NAN_DEFAULTS) && \
+    defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
+// Like `operator==(e, def)` with weak NaN if T=(float|double).
+template<typename T> inline bool IsFloatTheSameAs(T e, T def) {
+  return (e == def) || ((def != def) && (e != e));
+}
+template<> inline bool IsTheSameAs<float>(float e, float def) {
+  return IsFloatTheSameAs(e, def);
+}
+template<> inline bool IsTheSameAs<double>(double e, double def) {
+  return IsFloatTheSameAs(e, def);
+}
+#endif
+
+// Check 'v' is out of closed range [low; high].
+// Workaround for GCC warning [-Werror=type-limits]:
+// comparison is always true due to limited range of data type.
+template<typename T>
+inline bool IsOutRange(const T &v, const T &low, const T &high) {
+  return (v < low) || (high < v);
+}
+
+// Check 'v' is in closed range [low; high].
+template<typename T>
+inline bool IsInRange(const T &v, const T &low, const T &high) {
+  return !IsOutRange(v, low, high);
+}
+
 }  // namespace flatbuffers
 }  // namespace arrow_vendored_private
+
 #endif  // FLATBUFFERS_BASE_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
new file mode 100644
index 0000000000000..e791c3007d88f
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer.h
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_BUFFER_H_
+#define FLATBUFFERS_BUFFER_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include <algorithm>
+
+#include "flatbuffers/base.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// Wrapper for uoffset_t to allow safe template specialization.
+// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
+template<typename T = void> struct Offset {
+  // The type of offset to use.
+  typedef uoffset_t offset_type;
+
+  offset_type o;
+  Offset() : o(0) {}
+  Offset(const offset_type _o) : o(_o) {}
+  Offset<> Union() const { return o; }
+  bool IsNull() const { return !o; }
+};
+
+// Wrapper for uoffset64_t Offsets.
+template<typename T = void> struct Offset64 {
+  // The type of offset to use.
+  typedef uoffset64_t offset_type;
+
+  offset_type o;
+  Offset64() : o(0) {}
+  Offset64(const offset_type offset) : o(offset) {}
+  Offset64<> Union() const { return o; }
+  bool IsNull() const { return !o; }
+};
+
+// Litmus check for ensuring the Offsets are the expected size.
+static_assert(sizeof(Offset<>) == 4, "Offset has wrong size");
+static_assert(sizeof(Offset64<>) == 8, "Offset64 has wrong size");
+
+inline void EndianCheck() {
+  int endiantest = 1;
+  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
+  FLATBUFFERS_ASSERT(*reinterpret_cast<char *>(&endiantest) ==
+                     FLATBUFFERS_LITTLEENDIAN);
+  (void)endiantest;
+}
+
+template<typename T> FLATBUFFERS_CONSTEXPR size_t AlignOf() {
+  // clang-format off
+  #ifdef _MSC_VER
+    return __alignof(T);
+  #else
+    #ifndef alignof
+      return __alignof__(T);
+    #else
+      return alignof(T);
+    #endif
+  #endif
+  // clang-format on
+}
+
+// Lexicographically compare two strings (possibly containing nulls), and
+// return true if the first is less than the second.
+static inline bool StringLessThan(const char *a_data, uoffset_t a_size,
+                                  const char *b_data, uoffset_t b_size) {
+  const auto cmp = memcmp(a_data, b_data, (std::min)(a_size, b_size));
+  return cmp == 0 ? a_size < b_size : cmp < 0;
+}
+
+// When we read serialized data from memory, in the case of most scalars,
+// we want to just read T, but in the case of Offset, we want to actually
+// perform the indirection and return a pointer.
+// The template specialization below does just that.
+// It is wrapped in a struct since function templates can't overload on the
+// return type like this.
+// The typedef is for the convenience of callers of this function
+// (avoiding the need for a trailing return decltype)
+template<typename T> struct IndirectHelper {
+  typedef T return_type;
+  typedef T mutable_return_type;
+  static const size_t element_stride = sizeof(T);
+
+  static return_type Read(const uint8_t *p, const size_t i) {
+    return EndianScalar((reinterpret_cast<const T *>(p))[i]);
+  }
+  static mutable_return_type Read(uint8_t *p, const size_t i) {
+    return reinterpret_cast<mutable_return_type>(
+        Read(const_cast<const uint8_t *>(p), i));
+  }
+};
+
+// For vector of Offsets.
+template<typename T, template<typename> class OffsetT>
+struct IndirectHelper<OffsetT<T>> {
+  typedef const T *return_type;
+  typedef T *mutable_return_type;
+  typedef typename OffsetT<T>::offset_type offset_type;
+  static const offset_type element_stride = sizeof(offset_type);
+
+  static return_type Read(const uint8_t *const p, const offset_type i) {
+    // Offsets are relative to themselves, so first update the pointer to
+    // point to the offset location.
+    const uint8_t *const offset_location = p + i * element_stride;
+
+    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
+    // then determine the relative location from the offset location.
+    return reinterpret_cast<return_type>(
+        offset_location + ReadScalar<offset_type>(offset_location));
+  }
+  static mutable_return_type Read(uint8_t *const p, const offset_type i) {
+    // Offsets are relative to themselves, so first update the pointer to
+    // point to the offset location.
+    uint8_t *const offset_location = p + i * element_stride;
+
+    // Then read the scalar value of the offset (which may be 32 or 64-bits) and
+    // then determine the relative location from the offset location.
+    return reinterpret_cast<mutable_return_type>(
+        offset_location + ReadScalar<offset_type>(offset_location));
+  }
+};
+
+// For vector of structs.
+template<typename T> struct IndirectHelper<const T *> {
+  typedef const T *return_type;
+  typedef T *mutable_return_type;
+  static const size_t element_stride = sizeof(T);
+
+  static return_type Read(const uint8_t *const p, const size_t i) {
+    // Structs are stored inline, relative to the first struct pointer.
+    return reinterpret_cast<return_type>(p + i * element_stride);
+  }
+  static mutable_return_type Read(uint8_t *const p, const size_t i) {
+    // Structs are stored inline, relative to the first struct pointer.
+    return reinterpret_cast<mutable_return_type>(p + i * element_stride);
+  }
+};
+
+/// @brief Get a pointer to the file_identifier section of the buffer.
+/// @return Returns a const char pointer to the start of the file_identifier
+/// characters in the buffer.  The returned char * has length
+/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.
+/// This function is UNDEFINED for FlatBuffers whose schema does not include
+/// a file_identifier (likely points at padding or the start of a the root
+/// vtable).
+inline const char *GetBufferIdentifier(const void *buf,
+                                       bool size_prefixed = false) {
+  return reinterpret_cast<const char *>(buf) +
+         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
+}
+
+// Helper to see if the identifier in a buffer has the expected value.
+inline bool BufferHasIdentifier(const void *buf, const char *identifier,
+                                bool size_prefixed = false) {
+  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
+                 flatbuffers::kFileIdentifierLength) == 0;
+}
+
+/// @cond FLATBUFFERS_INTERNAL
+// Helpers to get a typed pointer to the root object contained in the buffer.
+template<typename T> T *GetMutableRoot(void *buf) {
+  if (!buf) return nullptr;
+  EndianCheck();
+  return reinterpret_cast<T *>(
+      reinterpret_cast<uint8_t *>(buf) +
+      EndianScalar(*reinterpret_cast<uoffset_t *>(buf)));
+}
+
+template<typename T, typename SizeT = uoffset_t>
+T *GetMutableSizePrefixedRoot(void *buf) {
+  return GetMutableRoot<T>(reinterpret_cast<uint8_t *>(buf) + sizeof(SizeT));
+}
+
+template<typename T> const T *GetRoot(const void *buf) {
+  return GetMutableRoot<T>(const_cast<void *>(buf));
+}
+
+template<typename T, typename SizeT = uoffset_t>
+const T *GetSizePrefixedRoot(const void *buf) {
+  return GetRoot<T>(reinterpret_cast<const uint8_t *>(buf) + sizeof(SizeT));
+}
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_BUFFER_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
new file mode 100644
index 0000000000000..8a4a43f81eebc
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/buffer_ref.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_BUFFER_REF_H_
+#define FLATBUFFERS_BUFFER_REF_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/verifier.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// Convenient way to bundle a buffer and its length, to pass it around
+// typed by its root.
+// A BufferRef does not own its buffer.
+struct BufferRefBase {};  // for std::is_base_of
+
+template<typename T> struct BufferRef : BufferRefBase {
+  BufferRef() : buf(nullptr), len(0), must_free(false) {}
+  BufferRef(uint8_t *_buf, uoffset_t _len)
+      : buf(_buf), len(_len), must_free(false) {}
+
+  ~BufferRef() {
+    if (must_free) free(buf);
+  }
+
+  const T *GetRoot() const { return flatbuffers::GetRoot<T>(buf); }
+
+  bool Verify() {
+    Verifier verifier(buf, len);
+    return verifier.VerifyBuffer<T>(nullptr);
+  }
+
+  uint8_t *buf;
+  uoffset_t len;
+  bool must_free;
+};
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_BUFFER_REF_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
new file mode 100644
index 0000000000000..fd2dc60a98d8c
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/default_allocator.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+#define FLATBUFFERS_DEFAULT_ALLOCATOR_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/base.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// DefaultAllocator uses new/delete to allocate memory regions
+class DefaultAllocator : public Allocator {
+ public:
+  uint8_t *allocate(size_t size) FLATBUFFERS_OVERRIDE {
+    return new uint8_t[size];
+  }
+
+  void deallocate(uint8_t *p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; }
+
+  static void dealloc(void *p, size_t) { delete[] static_cast<uint8_t *>(p); }
+};
+
+// These functions allow for a null allocator to mean use the default allocator,
+// as used by DetachedBuffer and vector_downward below.
+// This is to avoid having a statically or dynamically allocated default
+// allocator, or having to move it between the classes that may own it.
+inline uint8_t *Allocate(Allocator *allocator, size_t size) {
+  return allocator ? allocator->allocate(size)
+                   : DefaultAllocator().allocate(size);
+}
+
+inline void Deallocate(Allocator *allocator, uint8_t *p, size_t size) {
+  if (allocator)
+    allocator->deallocate(p, size);
+  else
+    DefaultAllocator().deallocate(p, size);
+}
+
+inline uint8_t *ReallocateDownward(Allocator *allocator, uint8_t *old_p,
+                                   size_t old_size, size_t new_size,
+                                   size_t in_use_back, size_t in_use_front) {
+  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,
+                                                    in_use_back, in_use_front)
+                   : DefaultAllocator().reallocate_downward(
+                         old_p, old_size, new_size, in_use_back, in_use_front);
+}
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_DEFAULT_ALLOCATOR_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
new file mode 100644
index 0000000000000..4779545b38e9b
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/detached_buffer.h
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_DETACHED_BUFFER_H_
+#define FLATBUFFERS_DETACHED_BUFFER_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/default_allocator.h"
+
+namespace arrow_vendored_private::flatbuffers {
+
+// DetachedBuffer is a finished flatbuffer memory region, detached from its
+// builder. The original memory region and allocator are also stored so that
+// the DetachedBuffer can manage the memory lifetime.
+class DetachedBuffer {
+ public:
+  DetachedBuffer()
+      : allocator_(nullptr),
+        own_allocator_(false),
+        buf_(nullptr),
+        reserved_(0),
+        cur_(nullptr),
+        size_(0) {}
+
+  DetachedBuffer(Allocator *allocator, bool own_allocator, uint8_t *buf,
+                 size_t reserved, uint8_t *cur, size_t sz)
+      : allocator_(allocator),
+        own_allocator_(own_allocator),
+        buf_(buf),
+        reserved_(reserved),
+        cur_(cur),
+        size_(sz) {}
+
+  DetachedBuffer(DetachedBuffer &&other) noexcept
+      : allocator_(other.allocator_),
+        own_allocator_(other.own_allocator_),
+        buf_(other.buf_),
+        reserved_(other.reserved_),
+        cur_(other.cur_),
+        size_(other.size_) {
+    other.reset();
+  }
+
+  DetachedBuffer &operator=(DetachedBuffer &&other) noexcept {
+    if (this == &other) return *this;
+
+    destroy();
+
+    allocator_ = other.allocator_;
+    own_allocator_ = other.own_allocator_;
+    buf_ = other.buf_;
+    reserved_ = other.reserved_;
+    cur_ = other.cur_;
+    size_ = other.size_;
+
+    other.reset();
+
+    return *this;
+  }
+
+  ~DetachedBuffer() { destroy(); }
+
+  const uint8_t *data() const { return cur_; }
+
+  uint8_t *data() { return cur_; }
+
+  size_t size() const { return size_; }
+
+  // These may change access mode, leave these at end of public section
+  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer &other));
+  FLATBUFFERS_DELETE_FUNC(
+      DetachedBuffer &operator=(const DetachedBuffer &other));
+
+ protected:
+  Allocator *allocator_;
+  bool own_allocator_;
+  uint8_t *buf_;
+  size_t reserved_;
+  uint8_t *cur_;
+  size_t size_;
+
+  inline void destroy() {
+    if (buf_) Deallocate(allocator_, buf_, reserved_);
+    if (own_allocator_ && allocator_) { delete allocator_; }
+    reset();
+  }
+
+  inline void reset() {
+    allocator_ = nullptr;
+    own_allocator_ = false;
+    buf_ = nullptr;
+    reserved_ = 0;
+    cur_ = nullptr;
+    size_ = 0;
+  }
+};
+
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_DETACHED_BUFFER_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
new file mode 100644
index 0000000000000..5825cc05c3764
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffer_builder.h
@@ -0,0 +1,1473 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_FLATBUFFER_BUILDER_H_
+#define FLATBUFFERS_FLATBUFFER_BUILDER_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <type_traits>
+
+#include "flatbuffers/allocator.h"
+#include "flatbuffers/array.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/buffer_ref.h"
+#include "flatbuffers/default_allocator.h"
+#include "flatbuffers/detached_buffer.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/string.h"
+#include "flatbuffers/struct.h"
+#include "flatbuffers/table.h"
+#include "flatbuffers/vector.h"
+#include "flatbuffers/vector_downward.h"
+#include "flatbuffers/verifier.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+// Converts a Field ID to a virtual table offset.
+inline voffset_t FieldIndexToOffset(voffset_t field_id) {
+  // Should correspond to what EndTable() below builds up.
+  const voffset_t fixed_fields =
+      2 * sizeof(voffset_t);  // Vtable size and Object Size.
+  return fixed_fields + field_id * sizeof(voffset_t);
+}
+
+template<typename T, typename Alloc = std::allocator<T>>
+const T *data(const std::vector<T, Alloc> &v) {
+  // Eventually the returned pointer gets passed down to memcpy, so
+  // we need it to be non-null to avoid undefined behavior.
+  static uint8_t t;
+  return v.empty() ? reinterpret_cast<const T *>(&t) : &v.front();
+}
+template<typename T, typename Alloc = std::allocator<T>>
+T *data(std::vector<T, Alloc> &v) {
+  // Eventually the returned pointer gets passed down to memcpy, so
+  // we need it to be non-null to avoid undefined behavior.
+  static uint8_t t;
+  return v.empty() ? reinterpret_cast<T *>(&t) : &v.front();
+}
+
+/// @addtogroup flatbuffers_cpp_api
+/// @{
+/// @class FlatBufferBuilder
+/// @brief Helper class to hold data needed in creation of a FlatBuffer.
+/// To serialize data, you typically call one of the `Create*()` functions in
+/// the generated code, which in turn call a sequence of `StartTable`/
+/// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/
+/// `CreateVector` functions. Do this is depth-first order to build up a tree to
+/// the root. `Finish()` wraps up the buffer ready for transport.
+template<bool Is64Aware = false> class FlatBufferBuilderImpl {
+ public:
+  // This switches the size type of the builder, based on if its 64-bit aware
+  // (uoffset64_t) or not (uoffset_t).
+  typedef
+      typename std::conditional<Is64Aware, uoffset64_t, uoffset_t>::type SizeT;
+
+  /// @brief Default constructor for FlatBufferBuilder.
+  /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults
+  /// to `1024`.
+  /// @param[in] allocator An `Allocator` to use. If null will use
+  /// `DefaultAllocator`.
+  /// @param[in] own_allocator Whether the builder/vector should own the
+  /// allocator. Defaults to / `false`.
+  /// @param[in] buffer_minalign Force the buffer to be aligned to the given
+  /// minimum alignment upon reallocation. Only needed if you intend to store
+  /// types with custom alignment AND you wish to read the buffer in-place
+  /// directly after creation.
+  explicit FlatBufferBuilderImpl(
+      size_t initial_size = 1024, Allocator *allocator = nullptr,
+      bool own_allocator = false,
+      size_t buffer_minalign = AlignOf<largest_scalar_t>())
+      : buf_(initial_size, allocator, own_allocator, buffer_minalign,
+             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
+                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
+        num_field_loc(0),
+        max_voffset_(0),
+        length_of_64_bit_region_(0),
+        nested(false),
+        finished(false),
+        minalign_(1),
+        force_defaults_(false),
+        dedup_vtables_(true),
+        string_pool(nullptr) {
+    EndianCheck();
+  }
+
+  /// @brief Move constructor for FlatBufferBuilder.
+  FlatBufferBuilderImpl(FlatBufferBuilderImpl &&other) noexcept
+      : buf_(1024, nullptr, false, AlignOf<largest_scalar_t>(),
+             static_cast<SizeT>(Is64Aware ? FLATBUFFERS_MAX_64_BUFFER_SIZE
+                                          : FLATBUFFERS_MAX_BUFFER_SIZE)),
+        num_field_loc(0),
+        max_voffset_(0),
+        length_of_64_bit_region_(0),
+        nested(false),
+        finished(false),
+        minalign_(1),
+        force_defaults_(false),
+        dedup_vtables_(true),
+        string_pool(nullptr) {
+    EndianCheck();
+    // Default construct and swap idiom.
+    // Lack of delegating constructors in vs2010 makes it more verbose than
+    // needed.
+    Swap(other);
+  }
+
+  /// @brief Move assignment operator for FlatBufferBuilder.
+  FlatBufferBuilderImpl &operator=(FlatBufferBuilderImpl &&other) noexcept {
+    // Move construct a temporary and swap idiom
+    FlatBufferBuilderImpl temp(std::move(other));
+    Swap(temp);
+    return *this;
+  }
+
+  void Swap(FlatBufferBuilderImpl &other) {
+    using std::swap;
+    buf_.swap(other.buf_);
+    swap(num_field_loc, other.num_field_loc);
+    swap(max_voffset_, other.max_voffset_);
+    swap(length_of_64_bit_region_, other.length_of_64_bit_region_);
+    swap(nested, other.nested);
+    swap(finished, other.finished);
+    swap(minalign_, other.minalign_);
+    swap(force_defaults_, other.force_defaults_);
+    swap(dedup_vtables_, other.dedup_vtables_);
+    swap(string_pool, other.string_pool);
+  }
+
+  ~FlatBufferBuilderImpl() {
+    if (string_pool) delete string_pool;
+  }
+
+  void Reset() {
+    Clear();       // clear builder state
+    buf_.reset();  // deallocate buffer
+  }
+
+  /// @brief Reset all the state in this FlatBufferBuilder so it can be reused
+  /// to construct another buffer.
+  void Clear() {
+    ClearOffsets();
+    buf_.clear();
+    nested = false;
+    finished = false;
+    minalign_ = 1;
+    length_of_64_bit_region_ = 0;
+    if (string_pool) string_pool->clear();
+  }
+
+  /// @brief The current size of the serialized buffer, counting from the end.
+  /// @return Returns an `SizeT` with the current size of the buffer.
+  SizeT GetSize() const { return buf_.size(); }
+
+  /// @brief The current size of the serialized buffer relative to the end of
+  /// the 32-bit region.
+  /// @return Returns an `uoffset_t` with the current size of the buffer.
+  template<bool is_64 = Is64Aware>
+  // Only enable this method for the 64-bit builder, as only that builder is
+  // concerned with the 32/64-bit boundary, and should be the one to bare any
+  // run time costs.
+  typename std::enable_if<is_64, uoffset_t>::type GetSizeRelative32BitRegion()
+      const {
+    //[32-bit region][64-bit region]
+    //         [XXXXXXXXXXXXXXXXXXX] GetSize()
+    //               [YYYYYYYYYYYYY] length_of_64_bit_region_
+    //         [ZZZZ]                return size
+    return static_cast<uoffset_t>(GetSize() - length_of_64_bit_region_);
+  }
+
+  template<bool is_64 = Is64Aware>
+  // Only enable this method for the 32-bit builder.
+  typename std::enable_if<!is_64, uoffset_t>::type GetSizeRelative32BitRegion()
+      const {
+    return static_cast<uoffset_t>(GetSize());
+  }
+
+  /// @brief Get the serialized buffer (after you call `Finish()`).
+  /// @return Returns an `uint8_t` pointer to the FlatBuffer data inside the
+  /// buffer.
+  uint8_t *GetBufferPointer() const {
+    Finished();
+    return buf_.data();
+  }
+
+  /// @brief Get the serialized buffer (after you call `Finish()`) as a span.
+  /// @return Returns a constructed flatbuffers::span that is a view over the
+  /// FlatBuffer data inside the buffer.
+  flatbuffers::span<uint8_t> GetBufferSpan() const {
+    Finished();
+    return flatbuffers::span<uint8_t>(buf_.data(), buf_.size());
+  }
+
+  /// @brief Get a pointer to an unfinished buffer.
+  /// @return Returns a `uint8_t` pointer to the unfinished buffer.
+  uint8_t *GetCurrentBufferPointer() const { return buf_.data(); }
+
+  /// @brief Get the released pointer to the serialized buffer.
+  /// @warning Do NOT attempt to use this FlatBufferBuilder afterwards!
+  /// @return A `FlatBuffer` that owns the buffer and its allocator and
+  /// behaves similar to a `unique_ptr` with a deleter.
+  FLATBUFFERS_ATTRIBUTE([[deprecated("use Release() instead")]])
+  DetachedBuffer ReleaseBufferPointer() {
+    Finished();
+    return buf_.release();
+  }
+
+  /// @brief Get the released DetachedBuffer.
+  /// @return A `DetachedBuffer` that owns the buffer and its allocator.
+  DetachedBuffer Release() {
+    Finished();
+    return buf_.release();
+  }
+
+  /// @brief Get the released pointer to the serialized buffer.
+  /// @param size The size of the memory block containing
+  /// the serialized `FlatBuffer`.
+  /// @param offset The offset from the released pointer where the finished
+  /// `FlatBuffer` starts.
+  /// @return A raw pointer to the start of the memory block containing
+  /// the serialized `FlatBuffer`.
+  /// @remark If the allocator is owned, it gets deleted when the destructor is
+  /// called..
+  uint8_t *ReleaseRaw(size_t &size, size_t &offset) {
+    Finished();
+    return buf_.release_raw(size, offset);
+  }
+
+  /// @brief get the minimum alignment this buffer needs to be accessed
+  /// properly. This is only known once all elements have been written (after
+  /// you call Finish()). You can use this information if you need to embed
+  /// a FlatBuffer in some other buffer, such that you can later read it
+  /// without first having to copy it into its own buffer.
+  size_t GetBufferMinAlignment() const {
+    Finished();
+    return minalign_;
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  void Finished() const {
+    // If you get this assert, you're attempting to get access a buffer
+    // which hasn't been finished yet. Be sure to call
+    // FlatBufferBuilder::Finish with your root table.
+    // If you really need to access an unfinished buffer, call
+    // GetCurrentBufferPointer instead.
+    FLATBUFFERS_ASSERT(finished);
+  }
+  /// @endcond
+
+  /// @brief In order to save space, fields that are set to their default value
+  /// don't get serialized into the buffer.
+  /// @param[in] fd When set to `true`, always serializes default values that
+  /// are set. Optional fields which are not set explicitly, will still not be
+  /// serialized.
+  void ForceDefaults(bool fd) { force_defaults_ = fd; }
+
+  /// @brief By default vtables are deduped in order to save space.
+  /// @param[in] dedup When set to `true`, dedup vtables.
+  void DedupVtables(bool dedup) { dedup_vtables_ = dedup; }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  void Pad(size_t num_bytes) { buf_.fill(num_bytes); }
+
+  void TrackMinAlign(size_t elem_size) {
+    if (elem_size > minalign_) minalign_ = elem_size;
+  }
+
+  void Align(size_t elem_size) {
+    TrackMinAlign(elem_size);
+    buf_.fill(PaddingBytes(buf_.size(), elem_size));
+  }
+
+  void PushFlatBuffer(const uint8_t *bytes, size_t size) {
+    PushBytes(bytes, size);
+    finished = true;
+  }
+
+  void PushBytes(const uint8_t *bytes, size_t size) { buf_.push(bytes, size); }
+
+  void PopBytes(size_t amount) { buf_.pop(amount); }
+
+  template<typename T> void AssertScalarT() {
+    // The code assumes power of 2 sizes and endian-swap-ability.
+    static_assert(flatbuffers::is_scalar<T>::value, "T must be a scalar type");
+  }
+
+  // Write a single aligned scalar to the buffer
+  template<typename T, typename ReturnT = uoffset_t>
+  ReturnT PushElement(T element) {
+    AssertScalarT<T>();
+    Align(sizeof(T));
+    buf_.push_small(EndianScalar(element));
+    return CalculateOffset<ReturnT>();
+  }
+
+  template<typename T, template<typename> class OffsetT = Offset>
+  uoffset_t PushElement(OffsetT<T> off) {
+    // Special case for offsets: see ReferTo below.
+    return PushElement(ReferTo(off.o));
+  }
+
+  // When writing fields, we track where they are, so we can create correct
+  // vtables later.
+  void TrackField(voffset_t field, uoffset_t off) {
+    FieldLoc fl = { off, field };
+    buf_.scratch_push_small(fl);
+    num_field_loc++;
+    if (field > max_voffset_) { max_voffset_ = field; }
+  }
+
+  // Like PushElement, but additionally tracks the field this represents.
+  template<typename T> void AddElement(voffset_t field, T e, T def) {
+    // We don't serialize values equal to the default.
+    if (IsTheSameAs(e, def) && !force_defaults_) return;
+    TrackField(field, PushElement(e));
+  }
+
+  template<typename T> void AddElement(voffset_t field, T e) {
+    TrackField(field, PushElement(e));
+  }
+
+  template<typename T> void AddOffset(voffset_t field, Offset<T> off) {
+    if (off.IsNull()) return;  // Don't store.
+    AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
+  }
+
+  template<typename T> void AddOffset(voffset_t field, Offset64<T> off) {
+    if (off.IsNull()) return;  // Don't store.
+    AddElement(field, ReferTo(off.o), static_cast<uoffset64_t>(0));
+  }
+
+  template<typename T> void AddStruct(voffset_t field, const T *structptr) {
+    if (!structptr) return;  // Default, don't store.
+    Align(AlignOf<T>());
+    buf_.push_small(*structptr);
+    TrackField(field, CalculateOffset<uoffset_t>());
+  }
+
+  void AddStructOffset(voffset_t field, uoffset_t off) {
+    TrackField(field, off);
+  }
+
+  // Offsets initially are relative to the end of the buffer (downwards).
+  // This function converts them to be relative to the current location
+  // in the buffer (when stored here), pointing upwards.
+  uoffset_t ReferTo(uoffset_t off) {
+    // Align to ensure GetSizeRelative32BitRegion() below is correct.
+    Align(sizeof(uoffset_t));
+    // 32-bit offsets are relative to the tail of the 32-bit region of the
+    // buffer. For most cases (without 64-bit entities) this is equivalent to
+    // size of the whole buffer (e.g. GetSize())
+    return ReferTo(off, GetSizeRelative32BitRegion());
+  }
+
+  uoffset64_t ReferTo(uoffset64_t off) {
+    // Align to ensure GetSize() below is correct.
+    Align(sizeof(uoffset64_t));
+    // 64-bit offsets are relative to tail of the whole buffer
+    return ReferTo(off, GetSize());
+  }
+
+  template<typename T, typename T2> T ReferTo(const T off, const T2 size) {
+    FLATBUFFERS_ASSERT(off && off <= size);
+    return size - off + static_cast<T>(sizeof(T));
+  }
+
+  template<typename T> T ReferTo(const T off, const T size) {
+    FLATBUFFERS_ASSERT(off && off <= size);
+    return size - off + static_cast<T>(sizeof(T));
+  }
+
+  void NotNested() {
+    // If you hit this, you're trying to construct a Table/Vector/String
+    // during the construction of its parent table (between the MyTableBuilder
+    // and table.Finish().
+    // Move the creation of these sub-objects to above the MyTableBuilder to
+    // not get this assert.
+    // Ignoring this assert may appear to work in simple cases, but the reason
+    // it is here is that storing objects in-line may cause vtable offsets
+    // to not fit anymore. It also leads to vtable duplication.
+    FLATBUFFERS_ASSERT(!nested);
+    // If you hit this, fields were added outside the scope of a table.
+    FLATBUFFERS_ASSERT(!num_field_loc);
+  }
+
+  // From generated code (or from the parser), we call StartTable/EndTable
+  // with a sequence of AddElement calls in between.
+  uoffset_t StartTable() {
+    NotNested();
+    nested = true;
+    return GetSizeRelative32BitRegion();
+  }
+
+  // This finishes one serialized object by generating the vtable if it's a
+  // table, comparing it against existing vtables, and writing the
+  // resulting vtable offset.
+  uoffset_t EndTable(uoffset_t start) {
+    // If you get this assert, a corresponding StartTable wasn't called.
+    FLATBUFFERS_ASSERT(nested);
+    // Write the vtable offset, which is the start of any Table.
+    // We fill its value later.
+    // This is relative to the end of the 32-bit region.
+    const uoffset_t vtable_offset_loc =
+        static_cast<uoffset_t>(PushElement<soffset_t>(0));
+    // Write a vtable, which consists entirely of voffset_t elements.
+    // It starts with the number of offsets, followed by a type id, followed
+    // by the offsets themselves. In reverse:
+    // Include space for the last offset and ensure empty tables have a
+    // minimum size.
+    max_voffset_ =
+        (std::max)(static_cast<voffset_t>(max_voffset_ + sizeof(voffset_t)),
+                   FieldIndexToOffset(0));
+    buf_.fill_big(max_voffset_);
+    const uoffset_t table_object_size = vtable_offset_loc - start;
+    // Vtable use 16bit offsets.
+    FLATBUFFERS_ASSERT(table_object_size < 0x10000);
+    WriteScalar<voffset_t>(buf_.data() + sizeof(voffset_t),
+                           static_cast<voffset_t>(table_object_size));
+    WriteScalar<voffset_t>(buf_.data(), max_voffset_);
+    // Write the offsets into the table
+    for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc);
+         it < buf_.scratch_end(); it += sizeof(FieldLoc)) {
+      auto field_location = reinterpret_cast<FieldLoc *>(it);
+      const voffset_t pos =
+          static_cast<voffset_t>(vtable_offset_loc - field_location->off);
+      // If this asserts, it means you've set a field twice.
+      FLATBUFFERS_ASSERT(
+          !ReadScalar<voffset_t>(buf_.data() + field_location->id));
+      WriteScalar<voffset_t>(buf_.data() + field_location->id, pos);
+    }
+    ClearOffsets();
+    auto vt1 = reinterpret_cast<voffset_t *>(buf_.data());
+    auto vt1_size = ReadScalar<voffset_t>(vt1);
+    auto vt_use = GetSizeRelative32BitRegion();
+    // See if we already have generated a vtable with this exact same
+    // layout before. If so, make it point to the old one, remove this one.
+    if (dedup_vtables_) {
+      for (auto it = buf_.scratch_data(); it < buf_.scratch_end();
+           it += sizeof(uoffset_t)) {
+        auto vt_offset_ptr = reinterpret_cast<uoffset_t *>(it);
+        auto vt2 = reinterpret_cast<voffset_t *>(buf_.data_at(*vt_offset_ptr));
+        auto vt2_size = ReadScalar<voffset_t>(vt2);
+        if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;
+        vt_use = *vt_offset_ptr;
+        buf_.pop(GetSizeRelative32BitRegion() - vtable_offset_loc);
+        break;
+      }
+    }
+    // If this is a new vtable, remember it.
+    if (vt_use == GetSizeRelative32BitRegion()) {
+      buf_.scratch_push_small(vt_use);
+    }
+    // Fill the vtable offset we created above.
+    // The offset points from the beginning of the object to where the vtable is
+    // stored.
+    // Offsets default direction is downward in memory for future format
+    // flexibility (storing all vtables at the start of the file).
+    WriteScalar(buf_.data_at(vtable_offset_loc + length_of_64_bit_region_),
+                static_cast<soffset_t>(vt_use) -
+                    static_cast<soffset_t>(vtable_offset_loc));
+    nested = false;
+    return vtable_offset_loc;
+  }
+
+  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
+  uoffset_t EndTable(uoffset_t start, voffset_t /*numfields*/) {
+    return EndTable(start);
+  }
+
+  // This checks a required field has been set in a given table that has
+  // just been constructed.
+  template<typename T> void Required(Offset<T> table, voffset_t field) {
+    auto table_ptr = reinterpret_cast<const Table *>(buf_.data_at(table.o));
+    bool ok = table_ptr->GetOptionalFieldOffset(field) != 0;
+    // If this fails, the caller will show what field needs to be set.
+    FLATBUFFERS_ASSERT(ok);
+    (void)ok;
+  }
+
+  uoffset_t StartStruct(size_t alignment) {
+    Align(alignment);
+    return GetSizeRelative32BitRegion();
+  }
+
+  uoffset_t EndStruct() { return GetSizeRelative32BitRegion(); }
+
+  void ClearOffsets() {
+    buf_.scratch_pop(num_field_loc * sizeof(FieldLoc));
+    num_field_loc = 0;
+    max_voffset_ = 0;
+  }
+
+  // Aligns such that when "len" bytes are written, an object can be written
+  // after it (forward in the buffer) with "alignment" without padding.
+  void PreAlign(size_t len, size_t alignment) {
+    if (len == 0) return;
+    TrackMinAlign(alignment);
+    buf_.fill(PaddingBytes(GetSize() + len, alignment));
+  }
+
+  // Aligns such than when "len" bytes are written, an object of type `AlignT`
+  // can be written after it (forward in the buffer) without padding.
+  template<typename AlignT> void PreAlign(size_t len) {
+    AssertScalarT<AlignT>();
+    PreAlign(len, AlignOf<AlignT>());
+  }
+  /// @endcond
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template<typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const char *str, size_t len) {
+    CreateStringImpl(str, len);
+    return OffsetT<String>(
+        CalculateOffset<typename OffsetT<String>::offset_type>());
+  }
+
+  /// @brief Store a string in the buffer, which is null-terminated.
+  /// @param[in] str A const char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template<typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const char *str) {
+    return CreateString<OffsetT>(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which is null-terminated.
+  /// @param[in] str A char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template<typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(char *str) {
+    return CreateString<OffsetT>(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const reference to a std::string to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template<typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const std::string &str) {
+    return CreateString<OffsetT>(str.c_str(), str.length());
+  }
+
+  // clang-format off
+  #ifdef FLATBUFFERS_HAS_STRING_VIEW
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const string_view to copy in to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template <typename> class OffsetT = Offset>
+  OffsetT<String>CreateString(flatbuffers::string_view str) {
+    return CreateString<OffsetT>(str.data(), str.size());
+  }
+  #endif // FLATBUFFERS_HAS_STRING_VIEW
+  // clang-format on
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  template<template<typename> class OffsetT = Offset>
+  OffsetT<String> CreateString(const String *str) {
+    return str ? CreateString<OffsetT>(str->c_str(), str->size()) : 0;
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const reference to a std::string like type with support
+  /// of T::c_str() and T::length() to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  template<template<typename> class OffsetT = Offset,
+           // No need to explicitly declare the T type, let the compiler deduce
+           // it.
+           int &...ExplicitArgumentBarrier, typename T>
+  OffsetT<String> CreateString(const T &str) {
+    return CreateString<OffsetT>(str.c_str(), str.length());
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const char *str, size_t len) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    if (!string_pool) {
+      string_pool = new StringOffsetMap(StringOffsetCompare(buf_));
+    }
+
+    const size_t size_before_string = buf_.size();
+    // Must first serialize the string, since the set is all offsets into
+    // buffer.
+    const Offset<String> off = CreateString<Offset>(str, len);
+    auto it = string_pool->find(off);
+    // If it exists we reuse existing serialized data!
+    if (it != string_pool->end()) {
+      // We can remove the string we serialized.
+      buf_.pop(buf_.size() - size_before_string);
+      return *it;
+    }
+    // Record this string for future use.
+    string_pool->insert(off);
+    return off;
+  }
+
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const std::string_view to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  Offset<String> CreateSharedString(const flatbuffers::string_view str) {
+    return CreateSharedString(str.data(), str.size());
+  }
+#else
+  /// @brief Store a string in the buffer, which null-terminated.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const char pointer to a C-string to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const char *str) {
+    return CreateSharedString(str, strlen(str));
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const reference to a std::string to store in the buffer.
+  /// @return Returns the offset in the buffer where the string starts.
+  Offset<String> CreateSharedString(const std::string &str) {
+    return CreateSharedString(str.c_str(), str.length());
+  }
+#endif
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// If a string with this exact contents has already been serialized before,
+  /// instead simply returns the offset of the existing string. This uses a map
+  /// stored on the heap, but only stores the numerical offsets.
+  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
+  /// @return Returns the offset in the buffer where the string starts
+  Offset<String> CreateSharedString(const String *str) {
+    return str ? CreateSharedString(str->c_str(), str->size()) : 0;
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template<typename LenT = uoffset_t, typename ReturnT = uoffset_t>
+  ReturnT EndVector(size_t len) {
+    FLATBUFFERS_ASSERT(nested);  // Hit if no corresponding StartVector.
+    nested = false;
+    return PushElement<LenT, ReturnT>(static_cast<LenT>(len));
+  }
+
+  template<template<typename> class OffsetT = Offset, typename LenT = uint32_t>
+  void StartVector(size_t len, size_t elemsize, size_t alignment) {
+    NotNested();
+    nested = true;
+    // Align to the Length type of the vector (either 32-bit or 64-bit), so
+    // that the length of the buffer can be added without padding.
+    PreAlign<LenT>(len * elemsize);
+    PreAlign(len * elemsize, alignment);  // Just in case elemsize > uoffset_t.
+  }
+
+  template<typename T, template<typename> class OffsetT = Offset,
+           typename LenT = uint32_t>
+  void StartVector(size_t len) {
+    return StartVector<OffsetT, LenT>(len, sizeof(T), AlignOf<T>());
+  }
+
+  // Call this right before StartVector/CreateVector if you want to force the
+  // alignment to be something different than what the element size would
+  // normally dictate.
+  // This is useful when storing a nested_flatbuffer in a vector of bytes,
+  // or when storing SIMD floats, etc.
+  void ForceVectorAlignment(size_t len, size_t elemsize, size_t alignment) {
+    if (len == 0) return;
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
+    PreAlign(len * elemsize, alignment);
+  }
+
+  // Similar to ForceVectorAlignment but for String fields.
+  void ForceStringAlignment(size_t len, size_t alignment) {
+    if (len == 0) return;
+    FLATBUFFERS_ASSERT(VerifyAlignmentRequirements(alignment));
+    PreAlign((len + 1) * sizeof(char), alignment);
+  }
+
+  /// @endcond
+
+  /// @brief Serialize an array into a FlatBuffer `vector`.
+  /// @tparam T The data type of the array elements.
+  /// @tparam OffsetT the type of offset to return
+  /// @tparam VectorT the type of vector to cast to.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `TOffset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, template<typename...> class OffsetT = Offset,
+           template<typename...> class VectorT = Vector>
+  OffsetT<VectorT<T>> CreateVector(const T *v, size_t len) {
+    // The type of the length field in the vector.
+    typedef typename VectorT<T>::size_type LenT;
+    typedef typename OffsetT<VectorT<T>>::offset_type offset_type;
+    // If this assert hits, you're specifying a template argument that is
+    // causing the wrong overload to be selected, remove it.
+    AssertScalarT<T>();
+    StartVector<T, OffsetT, LenT>(len);
+    if (len > 0) {
+      // clang-format off
+      #if FLATBUFFERS_LITTLEENDIAN
+        PushBytes(reinterpret_cast<const uint8_t *>(v), len * sizeof(T));
+      #else
+        if (sizeof(T) == 1) {
+          PushBytes(reinterpret_cast<const uint8_t *>(v), len);
+        } else {
+          for (auto i = len; i > 0; ) {
+            PushElement(v[--i]);
+          }
+        }
+      #endif
+      // clang-format on
+    }
+    return OffsetT<VectorT<T>>(EndVector<LenT, offset_type>(len));
+  }
+
+  /// @brief Serialize an array like object into a FlatBuffer `vector`.
+  /// @tparam T The data type of the array elements.
+  /// @tparam C The type of the array.
+  /// @param[in] array A reference to an array like object of type `T` to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, class C> Offset<Vector<T>> CreateVector(const C &array) {
+    return CreateVector(array.data(), array.size());
+  }
+
+  /// @brief Serialize an initializer list into a FlatBuffer `vector`.
+  /// @tparam T The data type of the initializer list elements.
+  /// @param[in] v The value of the initializer list.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T>
+  Offset<Vector<T>> CreateVector(std::initializer_list<T> v) {
+    return CreateVector(v.begin(), v.size());
+  }
+
+  template<typename T>
+  Offset<Vector<Offset<T>>> CreateVector(const Offset<T> *v, size_t len) {
+    StartVector<Offset<T>>(len);
+    for (auto i = len; i > 0;) { PushElement(v[--i]); }
+    return Offset<Vector<Offset<T>>>(EndVector(len));
+  }
+
+  /// @brief Serialize a `std::vector` into a FlatBuffer `vector`.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param v A const reference to the `std::vector` to serialize into the
+  /// buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<T>> CreateVector(const std::vector<T, Alloc> &v) {
+    return CreateVector(data(v), v.size());
+  }
+
+  template<template<typename...> class VectorT = Vector64,
+           int &...ExplicitArgumentBarrier, typename T>
+  Offset64<VectorT<T>> CreateVector64(const std::vector<T> &v) {
+    return CreateVector<T, Offset64, VectorT>(data(v), v.size());
+  }
+
+  // vector<bool> may be implemented using a bit-set, so we can't access it as
+  // an array. Instead, read elements manually.
+  // Background: https://isocpp.org/blog/2012/11/on-vectorbool
+  Offset<Vector<uint8_t>> CreateVector(const std::vector<bool> &v) {
+    StartVector<uint8_t>(v.size());
+    for (auto i = v.size(); i > 0;) {
+      PushElement(static_cast<uint8_t>(v[--i]));
+    }
+    return Offset<Vector<uint8_t>>(EndVector(v.size()));
+  }
+
+  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
+  /// This is a convenience function that takes care of iteration for you.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param f A function that takes the current iteration 0..vector_size-1 and
+  /// returns any type that you can construct a FlatBuffers vector out of.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T>
+  Offset<Vector<T>> CreateVector(size_t vector_size,
+                                 const std::function<T(size_t i)> &f) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    std::vector<T> elems(vector_size);
+    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i);
+    return CreateVector(elems);
+  }
+
+  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
+  /// This is a convenience function that takes care of iteration for you. This
+  /// uses a vector stored on the heap to store the intermediate results of the
+  /// iteration.
+  /// @tparam T The data type of the `std::vector` elements.
+  /// @param f A function that takes the current iteration 0..vector_size-1,
+  /// and the state parameter returning any type that you can construct a
+  /// FlatBuffers vector out of.
+  /// @param state State passed to f.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename F, typename S>
+  Offset<Vector<T>> CreateVector(size_t vector_size, F f, S *state) {
+    FLATBUFFERS_ASSERT(FLATBUFFERS_GENERAL_HEAP_ALLOC_OK);
+    std::vector<T> elems(vector_size);
+    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state);
+    return CreateVector(elems);
+  }
+
+  /// @brief Serialize a `std::vector<StringType>` into a FlatBuffer `vector`.
+  /// whereas StringType is any type that is accepted by the CreateString()
+  /// overloads.
+  /// This is a convenience function for a common case.
+  /// @param v A const reference to the `std::vector` to serialize into the
+  /// buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename StringType = std::string,
+           typename Alloc = std::allocator<StringType>>
+  Offset<Vector<Offset<String>>> CreateVectorOfStrings(
+      const std::vector<StringType, Alloc> &v) {
+    return CreateVectorOfStrings(v.cbegin(), v.cend());
+  }
+
+  /// @brief Serialize a collection of Strings into a FlatBuffer `vector`.
+  /// This is a convenience function for a common case.
+  /// @param begin The beginning iterator of the collection
+  /// @param end The ending iterator of the collection
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<class It>
+  Offset<Vector<Offset<String>>> CreateVectorOfStrings(It begin, It end) {
+    auto size = std::distance(begin, end);
+    auto scratch_buffer_usage = size * sizeof(Offset<String>);
+    // If there is not enough space to store the offsets, there definitely won't
+    // be enough space to store all the strings. So ensuring space for the
+    // scratch region is OK, for if it fails, it would have failed later.
+    buf_.ensure_space(scratch_buffer_usage);
+    for (auto it = begin; it != end; ++it) {
+      buf_.scratch_push_small(CreateString(*it));
+    }
+    StartVector<Offset<String>>(size);
+    for (auto i = 1; i <= size; i++) {
+      // Note we re-evaluate the buf location each iteration to account for any
+      // underlying buffer resizing that may occur.
+      PushElement(*reinterpret_cast<Offset<String> *>(
+          buf_.scratch_end() - i * sizeof(Offset<String>)));
+    }
+    buf_.scratch_pop(scratch_buffer_usage);
+    return Offset<Vector<Offset<String>>>(EndVector(size));
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, template<typename...> class OffsetT = Offset,
+           template<typename...> class VectorT = Vector>
+  OffsetT<VectorT<const T *>> CreateVectorOfStructs(const T *v, size_t len) {
+    // The type of the length field in the vector.
+    typedef typename VectorT<T>::size_type LenT;
+    typedef typename OffsetT<VectorT<const T *>>::offset_type offset_type;
+
+    StartVector<OffsetT, LenT>(len * sizeof(T) / AlignOf<T>(), sizeof(T),
+                               AlignOf<T>());
+    if (len > 0) {
+      PushBytes(reinterpret_cast<const uint8_t *>(v), sizeof(T) * len);
+    }
+    return OffsetT<VectorT<const T *>>(EndVector<LenT, offset_type>(len));
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] filler A function that takes the current iteration
+  /// 0..vector_size-1 and a pointer to the struct that must be filled.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  /// This is mostly useful when flatbuffers are generated with mutation
+  /// accessors.
+  template<typename T>
+  Offset<Vector<const T *>> CreateVectorOfStructs(
+      size_t vector_size, const std::function<void(size_t i, T *)> &filler) {
+    T *structs = StartVectorOfStructs<T>(vector_size);
+    for (size_t i = 0; i < vector_size; i++) {
+      filler(i, structs);
+      structs++;
+    }
+    return EndVectorOfStructs<T>(vector_size);
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] f A function that takes the current iteration 0..vector_size-1,
+  /// a pointer to the struct that must be filled and the state argument.
+  /// @param[in] state Arbitrary state to pass to f.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  /// This is mostly useful when flatbuffers are generated with mutation
+  /// accessors.
+  template<typename T, typename F, typename S>
+  Offset<Vector<const T *>> CreateVectorOfStructs(size_t vector_size, F f,
+                                                  S *state) {
+    T *structs = StartVectorOfStructs<T>(vector_size);
+    for (size_t i = 0; i < vector_size; i++) {
+      f(i, structs, state);
+      structs++;
+    }
+    return EndVectorOfStructs<T>(vector_size);
+  }
+
+  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, template<typename...> class OffsetT = Offset,
+           template<typename...> class VectorT = Vector,
+           typename Alloc = std::allocator<T>>
+  OffsetT<VectorT<const T *>> CreateVectorOfStructs(
+      const std::vector<T, Alloc> &v) {
+    return CreateVectorOfStructs<T, OffsetT, VectorT>(data(v), v.size());
+  }
+
+  template<template<typename...> class VectorT = Vector64, int &..., typename T>
+  Offset64<VectorT<const T *>> CreateVectorOfStructs64(
+      const std::vector<T> &v) {
+    return CreateVectorOfStructs<T, Offset64, VectorT>(data(v), v.size());
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
+      const S *v, size_t len, T (*const pack_func)(const S &)) {
+    FLATBUFFERS_ASSERT(pack_func);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) { structs[i] = pack_func(v[i]); }
+    return EndVectorOfStructs<T>(len);
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(const S *v,
+                                                        size_t len) {
+    extern T Pack(const S &);
+    return CreateVectorOfNativeStructs(v, len, Pack);
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @param[in] pack_func Pointer to a function to convert the native struct
+  /// to the FlatBuffer struct.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
+      const std::vector<S, Alloc> &v, T (*const pack_func)(const S &)) {
+    return CreateVectorOfNativeStructs<T, S>(data(v), v.size(), pack_func);
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector`.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S, typename Alloc = std::allocator<S>>
+  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
+      const std::vector<S, Alloc> &v) {
+    return CreateVectorOfNativeStructs<T, S>(data(v), v.size());
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template<typename T> struct StructKeyComparator {
+    bool operator()(const T &a, const T &b) const {
+      return a.KeyCompareLessThan(&b);
+    }
+  };
+  /// @endcond
+
+  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`
+  /// in sorted order.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T *>> CreateVectorOfSortedStructs(
+      std::vector<T, Alloc> *v) {
+    return CreateVectorOfSortedStructs(data(*v), v->size());
+  }
+
+  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
+  /// `vector` in sorted order.
+  /// @tparam T The data type of the `std::vector` struct elements.
+  /// @tparam S The data type of the `std::vector` native struct elements.
+  /// @param[in] v A const reference to the `std::vector` of structs to
+  /// serialize into the buffer as a `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S, typename Alloc = std::allocator<T>>
+  Offset<Vector<const T *>> CreateVectorOfSortedNativeStructs(
+      std::vector<S, Alloc> *v) {
+    return CreateVectorOfSortedNativeStructs<T, S>(data(*v), v->size());
+  }
+
+  /// @brief Serialize an array of structs into a FlatBuffer `vector` in sorted
+  /// order.
+  /// @tparam T The data type of the struct array elements.
+  /// @param[in] v A pointer to the array of type `T` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T>
+  Offset<Vector<const T *>> CreateVectorOfSortedStructs(T *v, size_t len) {
+    std::stable_sort(v, v + len, StructKeyComparator<T>());
+    return CreateVectorOfStructs(v, len);
+  }
+
+  /// @brief Serialize an array of native structs into a FlatBuffer `vector` in
+  /// sorted order.
+  /// @tparam T The data type of the struct array elements.
+  /// @tparam S The data type of the native struct array elements.
+  /// @param[in] v A pointer to the array of type `S` to serialize into the
+  /// buffer as a `vector`.
+  /// @param[in] len The number of elements to serialize.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename S>
+  Offset<Vector<const T *>> CreateVectorOfSortedNativeStructs(S *v,
+                                                              size_t len) {
+    extern T Pack(const S &);
+    auto structs = StartVectorOfStructs<T>(len);
+    for (size_t i = 0; i < len; i++) { structs[i] = Pack(v[i]); }
+    std::stable_sort(structs, structs + len, StructKeyComparator<T>());
+    return EndVectorOfStructs<T>(len);
+  }
+
+  /// @cond FLATBUFFERS_INTERNAL
+  template<typename T> struct TableKeyComparator {
+    explicit TableKeyComparator(vector_downward<SizeT> &buf) : buf_(buf) {}
+    TableKeyComparator(const TableKeyComparator &other) : buf_(other.buf_) {}
+    bool operator()(const Offset<T> &a, const Offset<T> &b) const {
+      auto table_a = reinterpret_cast<T *>(buf_.data_at(a.o));
+      auto table_b = reinterpret_cast<T *>(buf_.data_at(b.o));
+      return table_a->KeyCompareLessThan(table_b);
+    }
+    vector_downward<SizeT> &buf_;
+
+   private:
+    FLATBUFFERS_DELETE_FUNC(
+        TableKeyComparator &operator=(const TableKeyComparator &other));
+  };
+  /// @endcond
+
+  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
+  /// in sorted order.
+  /// @tparam T The data type that the offset refers to.
+  /// @param[in] v An array of type `Offset<T>` that contains the `table`
+  /// offsets to store in the buffer in sorted order.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T>
+  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(Offset<T> *v,
+                                                       size_t len) {
+    std::stable_sort(v, v + len, TableKeyComparator<T>(buf_));
+    return CreateVector(v, len);
+  }
+
+  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
+  /// in sorted order.
+  /// @tparam T The data type that the offset refers to.
+  /// @param[in] v An array of type `Offset<T>` that contains the `table`
+  /// offsets to store in the buffer in sorted order.
+  /// @return Returns a typed `Offset` into the serialized data indicating
+  /// where the vector is stored.
+  template<typename T, typename Alloc = std::allocator<T>>
+  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(
+      std::vector<Offset<T>, Alloc> *v) {
+    return CreateVectorOfSortedTables(data(*v), v->size());
+  }
+
+  /// @brief Specialized version of `CreateVector` for non-copying use cases.
+  /// Write the data any time later to the returned buffer pointer `buf`.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @param[in] elemsize The size of each element in the `vector`.
+  /// @param[out] buf A pointer to a `uint8_t` pointer that can be
+  /// written to at a later time to serialize the data into a `vector`
+  /// in the buffer.
+  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
+                                      size_t alignment, uint8_t **buf) {
+    NotNested();
+    StartVector(len, elemsize, alignment);
+    buf_.make_space(len * elemsize);
+    const uoffset_t vec_start = GetSizeRelative32BitRegion();
+    auto vec_end = EndVector(len);
+    *buf = buf_.data_at(vec_start);
+    return vec_end;
+  }
+
+  FLATBUFFERS_ATTRIBUTE([[deprecated("call the version above instead")]])
+  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
+                                      uint8_t **buf) {
+    return CreateUninitializedVector(len, elemsize, elemsize, buf);
+  }
+
+  /// @brief Specialized version of `CreateVector` for non-copying use cases.
+  /// Write the data any time later to the returned buffer pointer `buf`.
+  /// @tparam T The data type of the data that will be stored in the buffer
+  /// as a `vector`.
+  /// @param[in] len The number of elements to store in the `vector`.
+  /// @param[out] buf A pointer to a pointer of type `T` that can be
+  /// written to at a later time to serialize the data into a `vector`
+  /// in the buffer.
+  template<typename T>
+  Offset<Vector<T>> CreateUninitializedVector(size_t len, T **buf) {
+    AssertScalarT<T>();
+    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
+                                     reinterpret_cast<uint8_t **>(buf));
+  }
+
+  template<typename T>
+  Offset<Vector<const T *>> CreateUninitializedVectorOfStructs(size_t len,
+                                                               T **buf) {
+    return CreateUninitializedVector(len, sizeof(T), AlignOf<T>(),
+                                     reinterpret_cast<uint8_t **>(buf));
+  }
+
+  // @brief Create a vector of scalar type T given as input a vector of scalar
+  // type U, useful with e.g. pre "enum class" enums, or any existing scalar
+  // data of the wrong type.
+  template<typename T, typename U>
+  Offset<Vector<T>> CreateVectorScalarCast(const U *v, size_t len) {
+    AssertScalarT<T>();
+    AssertScalarT<U>();
+    StartVector<T>(len);
+    for (auto i = len; i > 0;) { PushElement(static_cast<T>(v[--i])); }
+    return Offset<Vector<T>>(EndVector(len));
+  }
+
+  /// @brief Write a struct by itself, typically to be part of a union.
+  template<typename T> Offset<const T *> CreateStruct(const T &structobj) {
+    NotNested();
+    Align(AlignOf<T>());
+    buf_.push_small(structobj);
+    return Offset<const T *>(
+        CalculateOffset<typename Offset<const T *>::offset_type>());
+  }
+
+  /// @brief Finish serializing a buffer by writing the root offset.
+  /// @param[in] file_identifier If a `file_identifier` is given, the buffer
+  /// will be prefixed with a standard FlatBuffers file header.
+  template<typename T>
+  void Finish(Offset<T> root, const char *file_identifier = nullptr) {
+    Finish(root.o, file_identifier, false);
+  }
+
+  /// @brief Finish a buffer with a 32 bit size field pre-fixed (size of the
+  /// buffer following the size field). These buffers are NOT compatible
+  /// with standard buffers created by Finish, i.e. you can't call GetRoot
+  /// on them, you have to use GetSizePrefixedRoot instead.
+  /// All >32 bit quantities in this buffer will be aligned when the whole
+  /// size pre-fixed buffer is aligned.
+  /// These kinds of buffers are useful for creating a stream of FlatBuffers.
+  template<typename T>
+  void FinishSizePrefixed(Offset<T> root,
+                          const char *file_identifier = nullptr) {
+    Finish(root.o, file_identifier, true);
+  }
+
+  void SwapBufAllocator(FlatBufferBuilderImpl &other) {
+    buf_.swap_allocator(other.buf_);
+  }
+
+  /// @brief The length of a FlatBuffer file header.
+  static const size_t kFileIdentifierLength =
+      ::flatbuffers::kFileIdentifierLength;
+
+ protected:
+  // You shouldn't really be copying instances of this class.
+  FlatBufferBuilderImpl(const FlatBufferBuilderImpl &);
+  FlatBufferBuilderImpl &operator=(const FlatBufferBuilderImpl &);
+
+  void Finish(uoffset_t root, const char *file_identifier, bool size_prefix) {
+    NotNested();
+    buf_.clear_scratch();
+
+    const size_t prefix_size = size_prefix ? sizeof(SizeT) : 0;
+    // Make sure we track the alignment of the size prefix.
+    TrackMinAlign(prefix_size);
+
+    const size_t root_offset_size = sizeof(uoffset_t);
+    const size_t file_id_size = file_identifier ? kFileIdentifierLength : 0;
+
+    // This will cause the whole buffer to be aligned.
+    PreAlign(prefix_size + root_offset_size + file_id_size, minalign_);
+
+    if (file_identifier) {
+      FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength);
+      PushBytes(reinterpret_cast<const uint8_t *>(file_identifier),
+                kFileIdentifierLength);
+    }
+    PushElement(ReferTo(root));  // Location of root.
+    if (size_prefix) { PushElement(GetSize()); }
+    finished = true;
+  }
+
+  struct FieldLoc {
+    uoffset_t off;
+    voffset_t id;
+  };
+
+  vector_downward<SizeT> buf_;
+
+  // Accumulating offsets of table members while it is being built.
+  // We store these in the scratch pad of buf_, after the vtable offsets.
+  uoffset_t num_field_loc;
+  // Track how much of the vtable is in use, so we can output the most compact
+  // possible vtable.
+  voffset_t max_voffset_;
+
+  // This is the length of the 64-bit region of the buffer. The buffer supports
+  // 64-bit offsets by forcing serialization of those elements in the "tail"
+  // region of the buffer (i.e. "64-bit region"). To properly keep track of
+  // offsets that are referenced from the tail of the buffer to not overflow
+  // their size (e.g. Offset is a uint32_t type), the boundary of the 32-/64-bit
+  // regions must be tracked.
+  //
+  // [    Complete FlatBuffer     ]
+  // [32-bit region][64-bit region]
+  //               ^              ^
+  //               |              Tail of the buffer.
+  //               |
+  //               Tail of the 32-bit region of the buffer.
+  //
+  // This keeps track of the size of the 64-bit region so that the tail of the
+  // 32-bit region can be calculated as `GetSize() - length_of_64_bit_region_`.
+  //
+  // This will remain 0 if no 64-bit offset types are added to the buffer.
+  size_t length_of_64_bit_region_;
+
+  // Ensure objects are not nested.
+  bool nested;
+
+  // Ensure the buffer is finished before it is being accessed.
+  bool finished;
+
+  size_t minalign_;
+
+  bool force_defaults_;  // Serialize values equal to their defaults anyway.
+
+  bool dedup_vtables_;
+
+  struct StringOffsetCompare {
+    explicit StringOffsetCompare(const vector_downward<SizeT> &buf)
+        : buf_(&buf) {}
+    bool operator()(const Offset<String> &a, const Offset<String> &b) const {
+      auto stra = reinterpret_cast<const String *>(buf_->data_at(a.o));
+      auto strb = reinterpret_cast<const String *>(buf_->data_at(b.o));
+      return StringLessThan(stra->data(), stra->size(), strb->data(),
+                            strb->size());
+    }
+    const vector_downward<SizeT> *buf_;
+  };
+
+  // For use with CreateSharedString. Instantiated on first use only.
+  typedef std::set<Offset<String>, StringOffsetCompare> StringOffsetMap;
+  StringOffsetMap *string_pool;
+
+ private:
+  void CanAddOffset64() {
+    // If you hit this assertion, you are attempting to add a 64-bit offset to
+    // a 32-bit only builder. This is because the builder has overloads that
+    // differ only on the offset size returned: e.g.:
+    //
+    //   FlatBufferBuilder builder;
+    //   Offset64<String> string_offset = builder.CreateString<Offset64>();
+    //
+    // Either use a 64-bit aware builder, or don't try to create an Offset64
+    // return type.
+    //
+    // TODO(derekbailey): we can probably do more enable_if to avoid this
+    // looking like its possible to the user.
+    static_assert(Is64Aware, "cannot add 64-bit offset to a 32-bit builder");
+
+    // If you hit this assertion, you are attempting to add an 64-bit offset
+    // item after already serializing a 32-bit item. All 64-bit offsets have to
+    // added to the tail of the buffer before any 32-bit items can be added.
+    // Otherwise some items might not be addressable due to the maximum range of
+    // the 32-bit offset.
+    FLATBUFFERS_ASSERT(GetSize() == length_of_64_bit_region_);
+  }
+
+  /// @brief Store a string in the buffer, which can contain any binary data.
+  /// @param[in] str A const char pointer to the data to be stored as a string.
+  /// @param[in] len The number of bytes that should be stored from `str`.
+  /// @return Returns the offset in the buffer where the string starts.
+  void CreateStringImpl(const char *str, size_t len) {
+    NotNested();
+    PreAlign<uoffset_t>(len + 1);  // Always 0-terminated.
+    buf_.fill(1);
+    PushBytes(reinterpret_cast<const uint8_t *>(str), len);
+    PushElement(static_cast<uoffset_t>(len));
+  }
+
+  // Allocates space for a vector of structures.
+  // Must be completed with EndVectorOfStructs().
+  template<typename T, template<typename> class OffsetT = Offset>
+  T *StartVectorOfStructs(size_t vector_size) {
+    StartVector<OffsetT>(vector_size * sizeof(T) / AlignOf<T>(), sizeof(T),
+                         AlignOf<T>());
+    return reinterpret_cast<T *>(buf_.make_space(vector_size * sizeof(T)));
+  }
+
+  // End the vector of structures in the flatbuffers.
+  // Vector should have previously be started with StartVectorOfStructs().
+  template<typename T, template<typename> class OffsetT = Offset>
+  OffsetT<Vector<const T *>> EndVectorOfStructs(size_t vector_size) {
+    return OffsetT<Vector<const T *>>(
+        EndVector<typename Vector<const T *>::size_type,
+                  typename OffsetT<Vector<const T *>>::offset_type>(
+            vector_size));
+  }
+
+  template<typename T>
+  typename std::enable_if<std::is_same<T, uoffset_t>::value, T>::type
+  CalculateOffset() {
+    // Default to the end of the 32-bit region. This may or may not be the end
+    // of the buffer, depending on if any 64-bit offsets have been added.
+    return GetSizeRelative32BitRegion();
+  }
+
+  // Specializations to handle the 64-bit CalculateOffset, which is relative to
+  // end of the buffer.
+  template<typename T>
+  typename std::enable_if<std::is_same<T, uoffset64_t>::value, T>::type
+  CalculateOffset() {
+    // This should never be compiled in when not using a 64-bit builder.
+    static_assert(Is64Aware, "invalid 64-bit offset in 32-bit builder");
+
+    // Store how big the 64-bit region of the buffer is, so we can determine
+    // where the 32/64 bit boundary is.
+    length_of_64_bit_region_ = GetSize();
+
+    return length_of_64_bit_region_;
+  }
+};
+/// @}
+
+// Hack to `FlatBufferBuilder` mean `FlatBufferBuilder<false>` or
+// `FlatBufferBuilder<>`, where the template < > syntax is required.
+using FlatBufferBuilder = FlatBufferBuilderImpl<false>;
+using FlatBufferBuilder64 = FlatBufferBuilderImpl<true>;
+
+// These are external due to GCC not allowing them in the class.
+// See: https://stackoverflow.com/q/8061456/868247
+template<>
+template<>
+inline Offset64<String> FlatBufferBuilder64::CreateString(const char *str,
+                                                          size_t len) {
+  CanAddOffset64();
+  CreateStringImpl(str, len);
+  return Offset64<String>(
+      CalculateOffset<typename Offset64<String>::offset_type>());
+}
+
+// Used to distinguish from real Offsets.
+template<typename T = void> struct EmptyOffset {};
+
+// TODO(derekbailey): it would be nice to combine these two methods.
+template<>
+template<>
+inline void FlatBufferBuilder64::StartVector<Offset64, uint32_t>(
+    size_t len, size_t elemsize, size_t alignment) {
+  CanAddOffset64();
+  StartVector<EmptyOffset, uint32_t>(len, elemsize, alignment);
+}
+
+template<>
+template<>
+inline void FlatBufferBuilder64::StartVector<Offset64, uint64_t>(
+    size_t len, size_t elemsize, size_t alignment) {
+  CanAddOffset64();
+  StartVector<EmptyOffset, uint64_t>(len, elemsize, alignment);
+}
+
+/// Helpers to get a typed pointer to objects that are currently being built.
+/// @warning Creating new objects will lead to reallocations and invalidates
+/// the pointer!
+template<typename T>
+T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
+  return reinterpret_cast<T *>(fbb.GetCurrentBufferPointer() + fbb.GetSize() -
+                               offset.o);
+}
+
+template<typename T>
+const T *GetTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
+  return GetMutableTemporaryPointer<T>(fbb, offset);
+}
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_FLATBUFFER_BUILDER_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
index 2f7eb5fcf5197..8aa19a65cd9e9 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/flatbuffers.h
@@ -17,2531 +17,32 @@
 #ifndef FLATBUFFERS_H_
 #define FLATBUFFERS_H_
 
-#include "flatbuffers/base.h"
-
-#if defined(FLATBUFFERS_NAN_DEFAULTS)
-#  include <cmath>
-#endif
-
-// Move this vendored copy of flatbuffers to a private namespace,
-// but continue to access it through the "flatbuffers" alias.
-namespace arrow_vendored_private {
-namespace flatbuffers {
-}
-}
-namespace flatbuffers = arrow_vendored_private::flatbuffers;
-
-namespace arrow_vendored_private {
-namespace flatbuffers {
-// Generic 'operator==' with conditional specialisations.
-// T e - new value of a scalar field.
-// T def - default of scalar (is known at compile-time).
-template<typename T> inline bool IsTheSameAs(T e, T def) { return e == def; }
-
-#if defined(FLATBUFFERS_NAN_DEFAULTS) && \
-    defined(FLATBUFFERS_HAS_NEW_STRTOD) && (FLATBUFFERS_HAS_NEW_STRTOD > 0)
-// Like `operator==(e, def)` with weak NaN if T=(float|double).
-template<typename T> inline bool IsFloatTheSameAs(T e, T def) {
-  return (e == def) || ((def != def) && (e != e));
-}
-template<> inline bool IsTheSameAs<float>(float e, float def) {
-  return IsFloatTheSameAs(e, def);
-}
-template<> inline bool IsTheSameAs<double>(double e, double def) {
-  return IsFloatTheSameAs(e, def);
-}
-#endif
-
-// Check 'v' is out of closed range [low; high].
-// Workaround for GCC warning [-Werror=type-limits]:
-// comparison is always true due to limited range of data type.
-template<typename T>
-inline bool IsOutRange(const T &v, const T &low, const T &high) {
-  return (v < low) || (high < v);
-}
-
-// Check 'v' is in closed range [low; high].
-template<typename T>
-inline bool IsInRange(const T &v, const T &low, const T &high) {
-  return !IsOutRange(v, low, high);
-}
-
-// Wrapper for uoffset_t to allow safe template specialization.
-// Value is allowed to be 0 to indicate a null object (see e.g. AddOffset).
-template<typename T> struct Offset {
-  uoffset_t o;
-  Offset() : o(0) {}
-  Offset(uoffset_t _o) : o(_o) {}
-  Offset<void> Union() const { return Offset<void>(o); }
-  bool IsNull() const { return !o; }
-};
-
-inline void EndianCheck() {
-  int endiantest = 1;
-  // If this fails, see FLATBUFFERS_LITTLEENDIAN above.
-  FLATBUFFERS_ASSERT(*reinterpret_cast<char *>(&endiantest) ==
-                     FLATBUFFERS_LITTLEENDIAN);
-  (void)endiantest;
-}
-
-template<typename T> FLATBUFFERS_CONSTEXPR size_t AlignOf() {
-  // clang-format off
-  #ifdef _MSC_VER
-    return __alignof(T);
-  #else
-    #ifndef alignof
-      return __alignof__(T);
-    #else
-      return alignof(T);
-    #endif
-  #endif
-  // clang-format on
-}
-
-// When we read serialized data from memory, in the case of most scalars,
-// we want to just read T, but in the case of Offset, we want to actually
-// perform the indirection and return a pointer.
-// The template specialization below does just that.
-// It is wrapped in a struct since function templates can't overload on the
-// return type like this.
-// The typedef is for the convenience of callers of this function
-// (avoiding the need for a trailing return decltype)
-template<typename T> struct IndirectHelper {
-  typedef T return_type;
-  typedef T mutable_return_type;
-  static const size_t element_stride = sizeof(T);
-  static return_type Read(const uint8_t *p, uoffset_t i) {
-    return EndianScalar((reinterpret_cast<const T *>(p))[i]);
-  }
-};
-template<typename T> struct IndirectHelper<Offset<T>> {
-  typedef const T *return_type;
-  typedef T *mutable_return_type;
-  static const size_t element_stride = sizeof(uoffset_t);
-  static return_type Read(const uint8_t *p, uoffset_t i) {
-    p += i * sizeof(uoffset_t);
-    return reinterpret_cast<return_type>(p + ReadScalar<uoffset_t>(p));
-  }
-};
-template<typename T> struct IndirectHelper<const T *> {
-  typedef const T *return_type;
-  typedef T *mutable_return_type;
-  static const size_t element_stride = sizeof(T);
-  static return_type Read(const uint8_t *p, uoffset_t i) {
-    return reinterpret_cast<const T *>(p + i * sizeof(T));
-  }
-};
-
-// An STL compatible iterator implementation for Vector below, effectively
-// calling Get() for every element.
-template<typename T, typename IT> struct VectorIterator {
-  typedef std::random_access_iterator_tag iterator_category;
-  typedef IT value_type;
-  typedef ptrdiff_t difference_type;
-  typedef IT *pointer;
-  typedef IT &reference;
-
-  VectorIterator(const uint8_t *data, uoffset_t i)
-      : data_(data + IndirectHelper<T>::element_stride * i) {}
-  VectorIterator(const VectorIterator &other) : data_(other.data_) {}
-  VectorIterator() : data_(nullptr) {}
-
-  VectorIterator &operator=(const VectorIterator &other) {
-    data_ = other.data_;
-    return *this;
-  }
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  VectorIterator &operator=(VectorIterator &&other) {
-    data_ = other.data_;
-    return *this;
-  }
-  #endif  // !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
-  bool operator==(const VectorIterator &other) const {
-    return data_ == other.data_;
-  }
-
-  bool operator<(const VectorIterator &other) const {
-    return data_ < other.data_;
-  }
-
-  bool operator!=(const VectorIterator &other) const {
-    return data_ != other.data_;
-  }
-
-  difference_type operator-(const VectorIterator &other) const {
-    return (data_ - other.data_) / IndirectHelper<T>::element_stride;
-  }
-
-  IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
-
-  IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
-
-  VectorIterator &operator++() {
-    data_ += IndirectHelper<T>::element_stride;
-    return *this;
-  }
-
-  VectorIterator operator++(int) {
-    VectorIterator temp(data_, 0);
-    data_ += IndirectHelper<T>::element_stride;
-    return temp;
-  }
-
-  VectorIterator operator+(const uoffset_t &offset) const {
-    return VectorIterator(data_ + offset * IndirectHelper<T>::element_stride,
-                          0);
-  }
-
-  VectorIterator &operator+=(const uoffset_t &offset) {
-    data_ += offset * IndirectHelper<T>::element_stride;
-    return *this;
-  }
-
-  VectorIterator &operator--() {
-    data_ -= IndirectHelper<T>::element_stride;
-    return *this;
-  }
-
-  VectorIterator operator--(int) {
-    VectorIterator temp(data_, 0);
-    data_ -= IndirectHelper<T>::element_stride;
-    return temp;
-  }
-
-  VectorIterator operator-(const uoffset_t &offset) const {
-    return VectorIterator(data_ - offset * IndirectHelper<T>::element_stride,
-                          0);
-  }
-
-  VectorIterator &operator-=(const uoffset_t &offset) {
-    data_ -= offset * IndirectHelper<T>::element_stride;
-    return *this;
-  }
-
- private:
-  const uint8_t *data_;
-};
-
-template<typename Iterator>
-struct VectorReverseIterator : public std::reverse_iterator<Iterator> {
-  explicit VectorReverseIterator(Iterator iter)
-      : std::reverse_iterator<Iterator>(iter) {}
-
-  typename Iterator::value_type operator*() const {
-    return *(std::reverse_iterator<Iterator>::current);
-  }
-
-  typename Iterator::value_type operator->() const {
-    return *(std::reverse_iterator<Iterator>::current);
-  }
-};
-
-struct String;
-
-// This is used as a helper type for accessing vectors.
-// Vector::data() assumes the vector elements start after the length field.
-template<typename T> class Vector {
- public:
-  typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type>
-      iterator;
-  typedef VectorIterator<T, typename IndirectHelper<T>::return_type>
-      const_iterator;
-  typedef VectorReverseIterator<iterator> reverse_iterator;
-  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
-
-  uoffset_t size() const { return EndianScalar(length_); }
-
-  // Deprecated: use size(). Here for backwards compatibility.
-  FLATBUFFERS_ATTRIBUTE(deprecated("use size() instead"))
-  uoffset_t Length() const { return size(); }
-
-  typedef typename IndirectHelper<T>::return_type return_type;
-  typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
-
-  return_type Get(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return IndirectHelper<T>::Read(Data(), i);
-  }
-
-  return_type operator[](uoffset_t i) const { return Get(i); }
-
-  // If this is a Vector of enums, T will be its storage type, not the enum
-  // type. This function makes it convenient to retrieve value with enum
-  // type E.
-  template<typename E> E GetEnum(uoffset_t i) const {
-    return static_cast<E>(Get(i));
-  }
-
-  // If this a vector of unions, this does the cast for you. There's no check
-  // to make sure this is the right type!
-  template<typename U> const U *GetAs(uoffset_t i) const {
-    return reinterpret_cast<const U *>(Get(i));
-  }
-
-  // If this a vector of unions, this does the cast for you. There's no check
-  // to make sure this is actually a string!
-  const String *GetAsString(uoffset_t i) const {
-    return reinterpret_cast<const String *>(Get(i));
-  }
-
-  const void *GetStructFromOffset(size_t o) const {
-    return reinterpret_cast<const void *>(Data() + o);
-  }
-
-  iterator begin() { return iterator(Data(), 0); }
-  const_iterator begin() const { return const_iterator(Data(), 0); }
-
-  iterator end() { return iterator(Data(), size()); }
-  const_iterator end() const { return const_iterator(Data(), size()); }
-
-  reverse_iterator rbegin() { return reverse_iterator(end() - 1); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end() - 1);
-  }
-
-  reverse_iterator rend() { return reverse_iterator(begin() - 1); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin() - 1);
-  }
-
-  const_iterator cbegin() const { return begin(); }
-
-  const_iterator cend() const { return end(); }
-
-  const_reverse_iterator crbegin() const { return rbegin(); }
-
-  const_reverse_iterator crend() const { return rend(); }
-
-  // Change elements if you have a non-const pointer to this object.
-  // Scalars only. See reflection.h, and the documentation.
-  void Mutate(uoffset_t i, const T &val) {
-    FLATBUFFERS_ASSERT(i < size());
-    WriteScalar(data() + i, val);
-  }
-
-  // Change an element of a vector of tables (or strings).
-  // "val" points to the new table/string, as you can obtain from
-  // e.g. reflection::AddFlatBuffer().
-  void MutateOffset(uoffset_t i, const uint8_t *val) {
-    FLATBUFFERS_ASSERT(i < size());
-    static_assert(sizeof(T) == sizeof(uoffset_t), "Unrelated types");
-    WriteScalar(data() + i,
-                static_cast<uoffset_t>(val - (Data() + i * sizeof(uoffset_t))));
-  }
-
-  // Get a mutable pointer to tables/strings inside this vector.
-  mutable_return_type GetMutableObject(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return const_cast<mutable_return_type>(IndirectHelper<T>::Read(Data(), i));
-  }
-
-  // The raw data in little endian format. Use with care.
-  const uint8_t *Data() const {
-    return reinterpret_cast<const uint8_t *>(&length_ + 1);
-  }
-
-  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
-
-  // Similarly, but typed, much like std::vector::data
-  const T *data() const { return reinterpret_cast<const T *>(Data()); }
-  T *data() { return reinterpret_cast<T *>(Data()); }
-
-  template<typename K> return_type LookupByKey(K key) const {
-    void *search_result = std::bsearch(
-        &key, Data(), size(), IndirectHelper<T>::element_stride, KeyCompare<K>);
-
-    if (!search_result) {
-      return nullptr;  // Key not found.
-    }
-
-    const uint8_t *element = reinterpret_cast<const uint8_t *>(search_result);
-
-    return IndirectHelper<T>::Read(element, 0);
-  }
-
- protected:
-  // This class is only used to access pre-existing data. Don't ever
-  // try to construct these manually.
-  Vector();
-
-  uoffset_t length_;
-
- private:
-  // This class is a pointer. Copying will therefore create an invalid object.
-  // Private and unimplemented copy constructor.
-  Vector(const Vector &);
-  Vector &operator=(const Vector &);
-
-  template<typename K> static int KeyCompare(const void *ap, const void *bp) {
-    const K *key = reinterpret_cast<const K *>(ap);
-    const uint8_t *data = reinterpret_cast<const uint8_t *>(bp);
-    auto table = IndirectHelper<T>::Read(data, 0);
-
-    // std::bsearch compares with the operands transposed, so we negate the
-    // result here.
-    return -table->KeyCompareWithValue(*key);
-  }
-};
-
-// Represent a vector much like the template above, but in this case we
-// don't know what the element types are (used with reflection.h).
-class VectorOfAny {
- public:
-  uoffset_t size() const { return EndianScalar(length_); }
-
-  const uint8_t *Data() const {
-    return reinterpret_cast<const uint8_t *>(&length_ + 1);
-  }
-  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
-
- protected:
-  VectorOfAny();
-
-  uoffset_t length_;
-
- private:
-  VectorOfAny(const VectorOfAny &);
-  VectorOfAny &operator=(const VectorOfAny &);
-};
-
-#ifndef FLATBUFFERS_CPP98_STL
-template<typename T, typename U>
-Vector<Offset<T>> *VectorCast(Vector<Offset<U>> *ptr) {
-  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
-  return reinterpret_cast<Vector<Offset<T>> *>(ptr);
-}
-
-template<typename T, typename U>
-const Vector<Offset<T>> *VectorCast(const Vector<Offset<U>> *ptr) {
-  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
-  return reinterpret_cast<const Vector<Offset<T>> *>(ptr);
-}
-#endif
-
-// Convenient helper function to get the length of any vector, regardless
-// of whether it is null or not (the field is not set).
-template<typename T> static inline size_t VectorLength(const Vector<T> *v) {
-  return v ? v->size() : 0;
-}
-
-// This is used as a helper type for accessing arrays.
-template<typename T, uint16_t length> class Array {
-  typedef
-      typename flatbuffers::integral_constant<bool,
-                                              flatbuffers::is_scalar<T>::value>
-          scalar_tag;
-  typedef
-      typename flatbuffers::conditional<scalar_tag::value, T, const T *>::type
-          IndirectHelperType;
-
- public:
-  typedef typename IndirectHelper<IndirectHelperType>::return_type return_type;
-  typedef VectorIterator<T, return_type> const_iterator;
-  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
-
-  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
-
-  return_type Get(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return IndirectHelper<IndirectHelperType>::Read(Data(), i);
-  }
-
-  return_type operator[](uoffset_t i) const { return Get(i); }
-
-  // If this is a Vector of enums, T will be its storage type, not the enum
-  // type. This function makes it convenient to retrieve value with enum
-  // type E.
-  template<typename E> E GetEnum(uoffset_t i) const {
-    return static_cast<E>(Get(i));
-  }
-
-  const_iterator begin() const { return const_iterator(Data(), 0); }
-  const_iterator end() const { return const_iterator(Data(), size()); }
-
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator rend() const { return const_reverse_iterator(end()); }
-
-  const_iterator cbegin() const { return begin(); }
-  const_iterator cend() const { return end(); }
-
-  const_reverse_iterator crbegin() const { return rbegin(); }
-  const_reverse_iterator crend() const { return rend(); }
-
-  // Get a mutable pointer to elements inside this array.
-  // This method used to mutate arrays of structs followed by a @p Mutate
-  // operation. For primitive types use @p Mutate directly.
-  // @warning Assignments and reads to/from the dereferenced pointer are not
-  //  automatically converted to the correct endianness.
-  typename flatbuffers::conditional<scalar_tag::value, void, T *>::type
-  GetMutablePointer(uoffset_t i) const {
-    FLATBUFFERS_ASSERT(i < size());
-    return const_cast<T *>(&data()[i]);
-  }
-
-  // Change elements if you have a non-const pointer to this object.
-  void Mutate(uoffset_t i, const T &val) { MutateImpl(scalar_tag(), i, val); }
-
-  // The raw data in little endian format. Use with care.
-  const uint8_t *Data() const { return data_; }
-
-  uint8_t *Data() { return data_; }
-
-  // Similarly, but typed, much like std::vector::data
-  const T *data() const { return reinterpret_cast<const T *>(Data()); }
-  T *data() { return reinterpret_cast<T *>(Data()); }
-
- protected:
-  void MutateImpl(flatbuffers::integral_constant<bool, true>, uoffset_t i,
-                  const T &val) {
-    FLATBUFFERS_ASSERT(i < size());
-    WriteScalar(data() + i, val);
-  }
-
-  void MutateImpl(flatbuffers::integral_constant<bool, false>, uoffset_t i,
-                  const T &val) {
-    *(GetMutablePointer(i)) = val;
-  }
-
-  // This class is only used to access pre-existing data. Don't ever
-  // try to construct these manually.
-  // 'constexpr' allows us to use 'size()' at compile time.
-  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on
-  //  a constructor.
-#if defined(__cpp_constexpr)
-  constexpr Array();
-#else
-  Array();
-#endif
-
-  uint8_t data_[length * sizeof(T)];
-
- private:
-  // This class is a pointer. Copying will therefore create an invalid object.
-  // Private and unimplemented copy constructor.
-  Array(const Array &);
-  Array &operator=(const Array &);
-};
-
-// Specialization for Array[struct] with access using Offset<void> pointer.
-// This specialization used by idl_gen_text.cpp.
-template<typename T, uint16_t length> class Array<Offset<T>, length> {
-  static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
-
- public:
-  typedef const void *return_type;
-
-  const uint8_t *Data() const { return data_; }
-
-  // Make idl_gen_text.cpp::PrintContainer happy.
-  return_type operator[](uoffset_t) const {
-    FLATBUFFERS_ASSERT(false);
-    return nullptr;
-  }
-
- private:
-  // This class is only used to access pre-existing data.
-  Array();
-  Array(const Array &);
-  Array &operator=(const Array &);
-
-  uint8_t data_[1];
-};
-
-// Lexicographically compare two strings (possibly containing nulls), and
-// return true if the first is less than the second.
-static inline bool StringLessThan(const char *a_data, uoffset_t a_size,
-                                  const char *b_data, uoffset_t b_size) {
-  const auto cmp = memcmp(a_data, b_data, (std::min)(a_size, b_size));
-  return cmp == 0 ? a_size < b_size : cmp < 0;
-}
-
-struct String : public Vector<char> {
-  const char *c_str() const { return reinterpret_cast<const char *>(Data()); }
-  std::string str() const { return std::string(c_str(), size()); }
-
-  // clang-format off
-  #ifdef FLATBUFFERS_HAS_STRING_VIEW
-  flatbuffers::string_view string_view() const {
-    return flatbuffers::string_view(c_str(), size());
-  }
-  #endif // FLATBUFFERS_HAS_STRING_VIEW
-  // clang-format on
-
-  bool operator<(const String &o) const {
-    return StringLessThan(this->data(), this->size(), o.data(), o.size());
-  }
-};
-
-// Convenience function to get std::string from a String returning an empty
-// string on null pointer.
-static inline std::string GetString(const String *str) {
-  return str ? str->str() : "";
-}
-
-// Convenience function to get char* from a String returning an empty string on
-// null pointer.
-static inline const char *GetCstring(const String *str) {
-  return str ? str->c_str() : "";
-}
-
-// Allocator interface. This is flatbuffers-specific and meant only for
-// `vector_downward` usage.
-class Allocator {
- public:
-  virtual ~Allocator() {}
-
-  // Allocate `size` bytes of memory.
-  virtual uint8_t *allocate(size_t size) = 0;
-
-  // Deallocate `size` bytes of memory at `p` allocated by this allocator.
-  virtual void deallocate(uint8_t *p, size_t size) = 0;
-
-  // Reallocate `new_size` bytes of memory, replacing the old region of size
-  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
-  // and is intended specifcally for `vector_downward` use.
-  // `in_use_back` and `in_use_front` indicate how much of `old_size` is
-  // actually in use at each end, and needs to be copied.
-  virtual uint8_t *reallocate_downward(uint8_t *old_p, size_t old_size,
-                                       size_t new_size, size_t in_use_back,
-                                       size_t in_use_front) {
-    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
-    uint8_t *new_p = allocate(new_size);
-    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
-                    in_use_front);
-    deallocate(old_p, old_size);
-    return new_p;
-  }
-
- protected:
-  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`
-  // to `new_p` of `new_size`. Only memory of size `in_use_front` and
-  // `in_use_back` will be copied from the front and back of the old memory
-  // allocation.
-  void memcpy_downward(uint8_t *old_p, size_t old_size, uint8_t *new_p,
-                       size_t new_size, size_t in_use_back,
-                       size_t in_use_front) {
-    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,
-           in_use_back);
-    memcpy(new_p, old_p, in_use_front);
-  }
-};
-
-// DefaultAllocator uses new/delete to allocate memory regions
-class DefaultAllocator : public Allocator {
- public:
-  uint8_t *allocate(size_t size) FLATBUFFERS_OVERRIDE {
-    return new uint8_t[size];
-  }
-
-  void deallocate(uint8_t *p, size_t) FLATBUFFERS_OVERRIDE { delete[] p; }
-
-  static void dealloc(void *p, size_t) { delete[] static_cast<uint8_t *>(p); }
-};
-
-// These functions allow for a null allocator to mean use the default allocator,
-// as used by DetachedBuffer and vector_downward below.
-// This is to avoid having a statically or dynamically allocated default
-// allocator, or having to move it between the classes that may own it.
-inline uint8_t *Allocate(Allocator *allocator, size_t size) {
-  return allocator ? allocator->allocate(size)
-                   : DefaultAllocator().allocate(size);
-}
-
-inline void Deallocate(Allocator *allocator, uint8_t *p, size_t size) {
-  if (allocator)
-    allocator->deallocate(p, size);
-  else
-    DefaultAllocator().deallocate(p, size);
-}
-
-inline uint8_t *ReallocateDownward(Allocator *allocator, uint8_t *old_p,
-                                   size_t old_size, size_t new_size,
-                                   size_t in_use_back, size_t in_use_front) {
-  return allocator ? allocator->reallocate_downward(old_p, old_size, new_size,
-                                                    in_use_back, in_use_front)
-                   : DefaultAllocator().reallocate_downward(
-                         old_p, old_size, new_size, in_use_back, in_use_front);
-}
-
-// DetachedBuffer is a finished flatbuffer memory region, detached from its
-// builder. The original memory region and allocator are also stored so that
-// the DetachedBuffer can manage the memory lifetime.
-class DetachedBuffer {
- public:
-  DetachedBuffer()
-      : allocator_(nullptr),
-        own_allocator_(false),
-        buf_(nullptr),
-        reserved_(0),
-        cur_(nullptr),
-        size_(0) {}
-
-  DetachedBuffer(Allocator *allocator, bool own_allocator, uint8_t *buf,
-                 size_t reserved, uint8_t *cur, size_t sz)
-      : allocator_(allocator),
-        own_allocator_(own_allocator),
-        buf_(buf),
-        reserved_(reserved),
-        cur_(cur),
-        size_(sz) {}
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-  DetachedBuffer(DetachedBuffer &&other)
-      : allocator_(other.allocator_),
-        own_allocator_(other.own_allocator_),
-        buf_(other.buf_),
-        reserved_(other.reserved_),
-        cur_(other.cur_),
-        size_(other.size_) {
-    other.reset();
-  }
-  // clang-format off
-  #endif  // !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-  DetachedBuffer &operator=(DetachedBuffer &&other) {
-    if (this == &other) return *this;
-
-    destroy();
-
-    allocator_ = other.allocator_;
-    own_allocator_ = other.own_allocator_;
-    buf_ = other.buf_;
-    reserved_ = other.reserved_;
-    cur_ = other.cur_;
-    size_ = other.size_;
-
-    other.reset();
-
-    return *this;
-  }
-  // clang-format off
-  #endif  // !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
-  ~DetachedBuffer() { destroy(); }
-
-  const uint8_t *data() const { return cur_; }
-
-  uint8_t *data() { return cur_; }
-
-  size_t size() const { return size_; }
-
-  // clang-format off
-  #if 0  // disabled for now due to the ordering of classes in this header
-  template <class T>
-  bool Verify() const {
-    Verifier verifier(data(), size());
-    return verifier.Verify<T>(nullptr);
-  }
-
-  template <class T>
-  const T* GetRoot() const {
-    return flatbuffers::GetRoot<T>(data());
-  }
-
-  template <class T>
-  T* GetRoot() {
-    return flatbuffers::GetRoot<T>(data());
-  }
-  #endif
-  // clang-format on
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-  // These may change access mode, leave these at end of public section
-  FLATBUFFERS_DELETE_FUNC(DetachedBuffer(const DetachedBuffer &other))
-  FLATBUFFERS_DELETE_FUNC(
-      DetachedBuffer &operator=(const DetachedBuffer &other))
-  // clang-format off
-  #endif  // !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
- protected:
-  Allocator *allocator_;
-  bool own_allocator_;
-  uint8_t *buf_;
-  size_t reserved_;
-  uint8_t *cur_;
-  size_t size_;
-
-  inline void destroy() {
-    if (buf_) Deallocate(allocator_, buf_, reserved_);
-    if (own_allocator_ && allocator_) { delete allocator_; }
-    reset();
-  }
-
-  inline void reset() {
-    allocator_ = nullptr;
-    own_allocator_ = false;
-    buf_ = nullptr;
-    reserved_ = 0;
-    cur_ = nullptr;
-    size_ = 0;
-  }
-};
-
-// This is a minimal replication of std::vector<uint8_t> functionality,
-// except growing from higher to lower addresses. i.e push_back() inserts data
-// in the lowest address in the vector.
-// Since this vector leaves the lower part unused, we support a "scratch-pad"
-// that can be stored there for temporary data, to share the allocated space.
-// Essentially, this supports 2 std::vectors in a single buffer.
-class vector_downward {
- public:
-  explicit vector_downward(size_t initial_size, Allocator *allocator,
-                           bool own_allocator, size_t buffer_minalign)
-      : allocator_(allocator),
-        own_allocator_(own_allocator),
-        initial_size_(initial_size),
-        buffer_minalign_(buffer_minalign),
-        reserved_(0),
-        buf_(nullptr),
-        cur_(nullptr),
-        scratch_(nullptr) {}
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  vector_downward(vector_downward &&other)
-  #else
-  vector_downward(vector_downward &other)
-  #endif  // defined(FLATBUFFERS_CPP98_STL)
-      // clang-format on
-      : allocator_(other.allocator_),
-        own_allocator_(other.own_allocator_),
-        initial_size_(other.initial_size_),
-        buffer_minalign_(other.buffer_minalign_),
-        reserved_(other.reserved_),
-        buf_(other.buf_),
-        cur_(other.cur_),
-        scratch_(other.scratch_) {
-    // No change in other.allocator_
-    // No change in other.initial_size_
-    // No change in other.buffer_minalign_
-    other.own_allocator_ = false;
-    other.reserved_ = 0;
-    other.buf_ = nullptr;
-    other.cur_ = nullptr;
-    other.scratch_ = nullptr;
-  }
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-  vector_downward &operator=(vector_downward &&other) {
-    // Move construct a temporary and swap idiom
-    vector_downward temp(std::move(other));
-    swap(temp);
-    return *this;
-  }
-  // clang-format off
-  #endif  // defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
-  ~vector_downward() {
-    clear_buffer();
-    clear_allocator();
-  }
-
-  void reset() {
-    clear_buffer();
-    clear();
-  }
-
-  void clear() {
-    if (buf_) {
-      cur_ = buf_ + reserved_;
-    } else {
-      reserved_ = 0;
-      cur_ = nullptr;
-    }
-    clear_scratch();
-  }
-
-  void clear_scratch() { scratch_ = buf_; }
-
-  void clear_allocator() {
-    if (own_allocator_ && allocator_) { delete allocator_; }
-    allocator_ = nullptr;
-    own_allocator_ = false;
-  }
-
-  void clear_buffer() {
-    if (buf_) Deallocate(allocator_, buf_, reserved_);
-    buf_ = nullptr;
-  }
-
-  // Relinquish the pointer to the caller.
-  uint8_t *release_raw(size_t &allocated_bytes, size_t &offset) {
-    auto *buf = buf_;
-    allocated_bytes = reserved_;
-    offset = static_cast<size_t>(cur_ - buf_);
-
-    // release_raw only relinquishes the buffer ownership.
-    // Does not deallocate or reset the allocator. Destructor will do that.
-    buf_ = nullptr;
-    clear();
-    return buf;
-  }
-
-  // Relinquish the pointer to the caller.
-  DetachedBuffer release() {
-    // allocator ownership (if any) is transferred to DetachedBuffer.
-    DetachedBuffer fb(allocator_, own_allocator_, buf_, reserved_, cur_,
-                      size());
-    if (own_allocator_) {
-      allocator_ = nullptr;
-      own_allocator_ = false;
-    }
-    buf_ = nullptr;
-    clear();
-    return fb;
-  }
-
-  size_t ensure_space(size_t len) {
-    FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_);
-    if (len > static_cast<size_t>(cur_ - scratch_)) { reallocate(len); }
-    // Beyond this, signed offsets may not have enough range:
-    // (FlatBuffers > 2GB not supported).
-    FLATBUFFERS_ASSERT(size() < FLATBUFFERS_MAX_BUFFER_SIZE);
-    return len;
-  }
-
-  inline uint8_t *make_space(size_t len) {
-    size_t space = ensure_space(len);
-    cur_ -= space;
-    return cur_;
-  }
-
-  // Returns nullptr if using the DefaultAllocator.
-  Allocator *get_custom_allocator() { return allocator_; }
-
-  uoffset_t size() const {
-    return static_cast<uoffset_t>(reserved_ - (cur_ - buf_));
-  }
-
-  uoffset_t scratch_size() const {
-    return static_cast<uoffset_t>(scratch_ - buf_);
-  }
-
-  size_t capacity() const { return reserved_; }
-
-  uint8_t *data() const {
-    FLATBUFFERS_ASSERT(cur_);
-    return cur_;
-  }
-
-  uint8_t *scratch_data() const {
-    FLATBUFFERS_ASSERT(buf_);
-    return buf_;
-  }
-
-  uint8_t *scratch_end() const {
-    FLATBUFFERS_ASSERT(scratch_);
-    return scratch_;
-  }
-
-  uint8_t *data_at(size_t offset) const { return buf_ + reserved_ - offset; }
-
-  void push(const uint8_t *bytes, size_t num) {
-    if (num > 0) { memcpy(make_space(num), bytes, num); }
-  }
-
-  // Specialized version of push() that avoids memcpy call for small data.
-  template<typename T> void push_small(const T &little_endian_t) {
-    make_space(sizeof(T));
-    *reinterpret_cast<T *>(cur_) = little_endian_t;
-  }
-
-  template<typename T> void scratch_push_small(const T &t) {
-    ensure_space(sizeof(T));
-    *reinterpret_cast<T *>(scratch_) = t;
-    scratch_ += sizeof(T);
-  }
-
-  // fill() is most frequently called with small byte counts (<= 4),
-  // which is why we're using loops rather than calling memset.
-  void fill(size_t zero_pad_bytes) {
-    make_space(zero_pad_bytes);
-    for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0;
-  }
-
-  // Version for when we know the size is larger.
-  // Precondition: zero_pad_bytes > 0
-  void fill_big(size_t zero_pad_bytes) {
-    memset(make_space(zero_pad_bytes), 0, zero_pad_bytes);
-  }
-
-  void pop(size_t bytes_to_remove) { cur_ += bytes_to_remove; }
-  void scratch_pop(size_t bytes_to_remove) { scratch_ -= bytes_to_remove; }
-
-  void swap(vector_downward &other) {
-    using std::swap;
-    swap(allocator_, other.allocator_);
-    swap(own_allocator_, other.own_allocator_);
-    swap(initial_size_, other.initial_size_);
-    swap(buffer_minalign_, other.buffer_minalign_);
-    swap(reserved_, other.reserved_);
-    swap(buf_, other.buf_);
-    swap(cur_, other.cur_);
-    swap(scratch_, other.scratch_);
-  }
-
-  void swap_allocator(vector_downward &other) {
-    using std::swap;
-    swap(allocator_, other.allocator_);
-    swap(own_allocator_, other.own_allocator_);
-  }
-
- private:
-  // You shouldn't really be copying instances of this class.
-  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward &))
-  FLATBUFFERS_DELETE_FUNC(vector_downward &operator=(const vector_downward &))
-
-  Allocator *allocator_;
-  bool own_allocator_;
-  size_t initial_size_;
-  size_t buffer_minalign_;
-  size_t reserved_;
-  uint8_t *buf_;
-  uint8_t *cur_;  // Points at location between empty (below) and used (above).
-  uint8_t *scratch_;  // Points to the end of the scratchpad in use.
-
-  void reallocate(size_t len) {
-    auto old_reserved = reserved_;
-    auto old_size = size();
-    auto old_scratch_size = scratch_size();
-    reserved_ +=
-        (std::max)(len, old_reserved ? old_reserved / 2 : initial_size_);
-    reserved_ = (reserved_ + buffer_minalign_ - 1) & ~(buffer_minalign_ - 1);
-    if (buf_) {
-      buf_ = ReallocateDownward(allocator_, buf_, old_reserved, reserved_,
-                                old_size, old_scratch_size);
-    } else {
-      buf_ = Allocate(allocator_, reserved_);
-    }
-    cur_ = buf_ + reserved_ - old_size;
-    scratch_ = buf_ + old_scratch_size;
-  }
-};
-
-// Converts a Field ID to a virtual table offset.
-inline voffset_t FieldIndexToOffset(voffset_t field_id) {
-  // Should correspond to what EndTable() below builds up.
-  const int fixed_fields = 2;  // Vtable size and Object Size.
-  return static_cast<voffset_t>((field_id + fixed_fields) * sizeof(voffset_t));
-}
-
-template<typename T, typename Alloc>
-const T *data(const std::vector<T, Alloc> &v) {
-  // Eventually the returned pointer gets passed down to memcpy, so
-  // we need it to be non-null to avoid undefined behavior.
-  static uint8_t t;
-  return v.empty() ? reinterpret_cast<const T *>(&t) : &v.front();
-}
-template<typename T, typename Alloc> T *data(std::vector<T, Alloc> &v) {
-  // Eventually the returned pointer gets passed down to memcpy, so
-  // we need it to be non-null to avoid undefined behavior.
-  static uint8_t t;
-  return v.empty() ? reinterpret_cast<T *>(&t) : &v.front();
-}
-
-/// @endcond
-
-/// @addtogroup flatbuffers_cpp_api
-/// @{
-/// @class FlatBufferBuilder
-/// @brief Helper class to hold data needed in creation of a FlatBuffer.
-/// To serialize data, you typically call one of the `Create*()` functions in
-/// the generated code, which in turn call a sequence of `StartTable`/
-/// `PushElement`/`AddElement`/`EndTable`, or the builtin `CreateString`/
-/// `CreateVector` functions. Do this is depth-first order to build up a tree to
-/// the root. `Finish()` wraps up the buffer ready for transport.
-class FlatBufferBuilder {
- public:
-  /// @brief Default constructor for FlatBufferBuilder.
-  /// @param[in] initial_size The initial size of the buffer, in bytes. Defaults
-  /// to `1024`.
-  /// @param[in] allocator An `Allocator` to use. If null will use
-  /// `DefaultAllocator`.
-  /// @param[in] own_allocator Whether the builder/vector should own the
-  /// allocator. Defaults to / `false`.
-  /// @param[in] buffer_minalign Force the buffer to be aligned to the given
-  /// minimum alignment upon reallocation. Only needed if you intend to store
-  /// types with custom alignment AND you wish to read the buffer in-place
-  /// directly after creation.
-  explicit FlatBufferBuilder(
-      size_t initial_size = 1024, Allocator *allocator = nullptr,
-      bool own_allocator = false,
-      size_t buffer_minalign = AlignOf<largest_scalar_t>())
-      : buf_(initial_size, allocator, own_allocator, buffer_minalign),
-        num_field_loc(0),
-        max_voffset_(0),
-        nested(false),
-        finished(false),
-        minalign_(1),
-        force_defaults_(false),
-        dedup_vtables_(true),
-        string_pool(nullptr) {
-    EndianCheck();
-  }
-
-  // clang-format off
-  /// @brief Move constructor for FlatBufferBuilder.
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  FlatBufferBuilder(FlatBufferBuilder &&other)
-  #else
-  FlatBufferBuilder(FlatBufferBuilder &other)
-  #endif  // #if !defined(FLATBUFFERS_CPP98_STL)
-    : buf_(1024, nullptr, false, AlignOf<largest_scalar_t>()),
-      num_field_loc(0),
-      max_voffset_(0),
-      nested(false),
-      finished(false),
-      minalign_(1),
-      force_defaults_(false),
-      dedup_vtables_(true),
-      string_pool(nullptr) {
-    EndianCheck();
-    // Default construct and swap idiom.
-    // Lack of delegating constructors in vs2010 makes it more verbose than needed.
-    Swap(other);
-  }
-  // clang-format on
-
-  // clang-format off
-  #if !defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-  /// @brief Move assignment operator for FlatBufferBuilder.
-  FlatBufferBuilder &operator=(FlatBufferBuilder &&other) {
-    // Move construct a temporary and swap idiom
-    FlatBufferBuilder temp(std::move(other));
-    Swap(temp);
-    return *this;
-  }
-  // clang-format off
-  #endif  // defined(FLATBUFFERS_CPP98_STL)
-  // clang-format on
-
-  void Swap(FlatBufferBuilder &other) {
-    using std::swap;
-    buf_.swap(other.buf_);
-    swap(num_field_loc, other.num_field_loc);
-    swap(max_voffset_, other.max_voffset_);
-    swap(nested, other.nested);
-    swap(finished, other.finished);
-    swap(minalign_, other.minalign_);
-    swap(force_defaults_, other.force_defaults_);
-    swap(dedup_vtables_, other.dedup_vtables_);
-    swap(string_pool, other.string_pool);
-  }
-
-  ~FlatBufferBuilder() {
-    if (string_pool) delete string_pool;
-  }
-
-  void Reset() {
-    Clear();       // clear builder state
-    buf_.reset();  // deallocate buffer
-  }
-
-  /// @brief Reset all the state in this FlatBufferBuilder so it can be reused
-  /// to construct another buffer.
-  void Clear() {
-    ClearOffsets();
-    buf_.clear();
-    nested = false;
-    finished = false;
-    minalign_ = 1;
-    if (string_pool) string_pool->clear();
-  }
-
-  /// @brief The current size of the serialized buffer, counting from the end.
-  /// @return Returns an `uoffset_t` with the current size of the buffer.
-  uoffset_t GetSize() const { return buf_.size(); }
-
-  /// @brief Get the serialized buffer (after you call `Finish()`).
-  /// @return Returns an `uint8_t` pointer to the FlatBuffer data inside the
-  /// buffer.
-  uint8_t *GetBufferPointer() const {
-    Finished();
-    return buf_.data();
-  }
-
-  /// @brief Get a pointer to an unfinished buffer.
-  /// @return Returns a `uint8_t` pointer to the unfinished buffer.
-  uint8_t *GetCurrentBufferPointer() const { return buf_.data(); }
-
-  /// @brief Get the released pointer to the serialized buffer.
-  /// @warning Do NOT attempt to use this FlatBufferBuilder afterwards!
-  /// @return A `FlatBuffer` that owns the buffer and its allocator and
-  /// behaves similar to a `unique_ptr` with a deleter.
-  FLATBUFFERS_ATTRIBUTE(deprecated("use Release() instead"))
-  DetachedBuffer ReleaseBufferPointer() {
-    Finished();
-    return buf_.release();
-  }
-
-  /// @brief Get the released DetachedBuffer.
-  /// @return A `DetachedBuffer` that owns the buffer and its allocator.
-  DetachedBuffer Release() {
-    Finished();
-    return buf_.release();
-  }
-
-  /// @brief Get the released pointer to the serialized buffer.
-  /// @param size The size of the memory block containing
-  /// the serialized `FlatBuffer`.
-  /// @param offset The offset from the released pointer where the finished
-  /// `FlatBuffer` starts.
-  /// @return A raw pointer to the start of the memory block containing
-  /// the serialized `FlatBuffer`.
-  /// @remark If the allocator is owned, it gets deleted when the destructor is
-  /// called..
-  uint8_t *ReleaseRaw(size_t &size, size_t &offset) {
-    Finished();
-    return buf_.release_raw(size, offset);
-  }
-
-  /// @brief get the minimum alignment this buffer needs to be accessed
-  /// properly. This is only known once all elements have been written (after
-  /// you call Finish()). You can use this information if you need to embed
-  /// a FlatBuffer in some other buffer, such that you can later read it
-  /// without first having to copy it into its own buffer.
-  size_t GetBufferMinAlignment() {
-    Finished();
-    return minalign_;
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  void Finished() const {
-    // If you get this assert, you're attempting to get access a buffer
-    // which hasn't been finished yet. Be sure to call
-    // FlatBufferBuilder::Finish with your root table.
-    // If you really need to access an unfinished buffer, call
-    // GetCurrentBufferPointer instead.
-    FLATBUFFERS_ASSERT(finished);
-  }
-  /// @endcond
-
-  /// @brief In order to save space, fields that are set to their default value
-  /// don't get serialized into the buffer.
-  /// @param[in] fd When set to `true`, always serializes default values that
-  /// are set. Optional fields which are not set explicitly, will still not be
-  /// serialized.
-  void ForceDefaults(bool fd) { force_defaults_ = fd; }
-
-  /// @brief By default vtables are deduped in order to save space.
-  /// @param[in] dedup When set to `true`, dedup vtables.
-  void DedupVtables(bool dedup) { dedup_vtables_ = dedup; }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  void Pad(size_t num_bytes) { buf_.fill(num_bytes); }
-
-  void TrackMinAlign(size_t elem_size) {
-    if (elem_size > minalign_) minalign_ = elem_size;
-  }
-
-  void Align(size_t elem_size) {
-    TrackMinAlign(elem_size);
-    buf_.fill(PaddingBytes(buf_.size(), elem_size));
-  }
-
-  void PushFlatBuffer(const uint8_t *bytes, size_t size) {
-    PushBytes(bytes, size);
-    finished = true;
-  }
-
-  void PushBytes(const uint8_t *bytes, size_t size) { buf_.push(bytes, size); }
-
-  void PopBytes(size_t amount) { buf_.pop(amount); }
-
-  template<typename T> void AssertScalarT() {
-    // The code assumes power of 2 sizes and endian-swap-ability.
-    static_assert(flatbuffers::is_scalar<T>::value, "T must be a scalar type");
-  }
-
-  // Write a single aligned scalar to the buffer
-  template<typename T> uoffset_t PushElement(T element) {
-    AssertScalarT<T>();
-    T litle_endian_element = EndianScalar(element);
-    Align(sizeof(T));
-    buf_.push_small(litle_endian_element);
-    return GetSize();
-  }
-
-  template<typename T> uoffset_t PushElement(Offset<T> off) {
-    // Special case for offsets: see ReferTo below.
-    return PushElement(ReferTo(off.o));
-  }
-
-  // When writing fields, we track where they are, so we can create correct
-  // vtables later.
-  void TrackField(voffset_t field, uoffset_t off) {
-    FieldLoc fl = { off, field };
-    buf_.scratch_push_small(fl);
-    num_field_loc++;
-    max_voffset_ = (std::max)(max_voffset_, field);
-  }
-
-  // Like PushElement, but additionally tracks the field this represents.
-  template<typename T> void AddElement(voffset_t field, T e, T def) {
-    // We don't serialize values equal to the default.
-    if (IsTheSameAs(e, def) && !force_defaults_) return;
-    auto off = PushElement(e);
-    TrackField(field, off);
-  }
-
-  template<typename T> void AddOffset(voffset_t field, Offset<T> off) {
-    if (off.IsNull()) return;  // Don't store.
-    AddElement(field, ReferTo(off.o), static_cast<uoffset_t>(0));
-  }
-
-  template<typename T> void AddStruct(voffset_t field, const T *structptr) {
-    if (!structptr) return;  // Default, don't store.
-    Align(AlignOf<T>());
-    buf_.push_small(*structptr);
-    TrackField(field, GetSize());
-  }
-
-  void AddStructOffset(voffset_t field, uoffset_t off) {
-    TrackField(field, off);
-  }
-
-  // Offsets initially are relative to the end of the buffer (downwards).
-  // This function converts them to be relative to the current location
-  // in the buffer (when stored here), pointing upwards.
-  uoffset_t ReferTo(uoffset_t off) {
-    // Align to ensure GetSize() below is correct.
-    Align(sizeof(uoffset_t));
-    // Offset must refer to something already in buffer.
-    FLATBUFFERS_ASSERT(off && off <= GetSize());
-    return GetSize() - off + static_cast<uoffset_t>(sizeof(uoffset_t));
-  }
-
-  void NotNested() {
-    // If you hit this, you're trying to construct a Table/Vector/String
-    // during the construction of its parent table (between the MyTableBuilder
-    // and table.Finish().
-    // Move the creation of these sub-objects to above the MyTableBuilder to
-    // not get this assert.
-    // Ignoring this assert may appear to work in simple cases, but the reason
-    // it is here is that storing objects in-line may cause vtable offsets
-    // to not fit anymore. It also leads to vtable duplication.
-    FLATBUFFERS_ASSERT(!nested);
-    // If you hit this, fields were added outside the scope of a table.
-    FLATBUFFERS_ASSERT(!num_field_loc);
-  }
-
-  // From generated code (or from the parser), we call StartTable/EndTable
-  // with a sequence of AddElement calls in between.
-  uoffset_t StartTable() {
-    NotNested();
-    nested = true;
-    return GetSize();
-  }
-
-  // This finishes one serialized object by generating the vtable if it's a
-  // table, comparing it against existing vtables, and writing the
-  // resulting vtable offset.
-  uoffset_t EndTable(uoffset_t start) {
-    // If you get this assert, a corresponding StartTable wasn't called.
-    FLATBUFFERS_ASSERT(nested);
-    // Write the vtable offset, which is the start of any Table.
-    // We fill it's value later.
-    auto vtableoffsetloc = PushElement<soffset_t>(0);
-    // Write a vtable, which consists entirely of voffset_t elements.
-    // It starts with the number of offsets, followed by a type id, followed
-    // by the offsets themselves. In reverse:
-    // Include space for the last offset and ensure empty tables have a
-    // minimum size.
-    max_voffset_ =
-        (std::max)(static_cast<voffset_t>(max_voffset_ + sizeof(voffset_t)),
-                   FieldIndexToOffset(0));
-    buf_.fill_big(max_voffset_);
-    auto table_object_size = vtableoffsetloc - start;
-    // Vtable use 16bit offsets.
-    FLATBUFFERS_ASSERT(table_object_size < 0x10000);
-    WriteScalar<voffset_t>(buf_.data() + sizeof(voffset_t),
-                           static_cast<voffset_t>(table_object_size));
-    WriteScalar<voffset_t>(buf_.data(), max_voffset_);
-    // Write the offsets into the table
-    for (auto it = buf_.scratch_end() - num_field_loc * sizeof(FieldLoc);
-         it < buf_.scratch_end(); it += sizeof(FieldLoc)) {
-      auto field_location = reinterpret_cast<FieldLoc *>(it);
-      auto pos = static_cast<voffset_t>(vtableoffsetloc - field_location->off);
-      // If this asserts, it means you've set a field twice.
-      FLATBUFFERS_ASSERT(
-          !ReadScalar<voffset_t>(buf_.data() + field_location->id));
-      WriteScalar<voffset_t>(buf_.data() + field_location->id, pos);
-    }
-    ClearOffsets();
-    auto vt1 = reinterpret_cast<voffset_t *>(buf_.data());
-    auto vt1_size = ReadScalar<voffset_t>(vt1);
-    auto vt_use = GetSize();
-    // See if we already have generated a vtable with this exact same
-    // layout before. If so, make it point to the old one, remove this one.
-    if (dedup_vtables_) {
-      for (auto it = buf_.scratch_data(); it < buf_.scratch_end();
-           it += sizeof(uoffset_t)) {
-        auto vt_offset_ptr = reinterpret_cast<uoffset_t *>(it);
-        auto vt2 = reinterpret_cast<voffset_t *>(buf_.data_at(*vt_offset_ptr));
-        auto vt2_size = ReadScalar<voffset_t>(vt2);
-        if (vt1_size != vt2_size || 0 != memcmp(vt2, vt1, vt1_size)) continue;
-        vt_use = *vt_offset_ptr;
-        buf_.pop(GetSize() - vtableoffsetloc);
-        break;
-      }
-    }
-    // If this is a new vtable, remember it.
-    if (vt_use == GetSize()) { buf_.scratch_push_small(vt_use); }
-    // Fill the vtable offset we created above.
-    // The offset points from the beginning of the object to where the
-    // vtable is stored.
-    // Offsets default direction is downward in memory for future format
-    // flexibility (storing all vtables at the start of the file).
-    WriteScalar(buf_.data_at(vtableoffsetloc),
-                static_cast<soffset_t>(vt_use) -
-                    static_cast<soffset_t>(vtableoffsetloc));
-
-    nested = false;
-    return vtableoffsetloc;
-  }
-
-  FLATBUFFERS_ATTRIBUTE(deprecated("call the version above instead"))
-  uoffset_t EndTable(uoffset_t start, voffset_t /*numfields*/) {
-    return EndTable(start);
-  }
-
-  // This checks a required field has been set in a given table that has
-  // just been constructed.
-  template<typename T> void Required(Offset<T> table, voffset_t field);
-
-  uoffset_t StartStruct(size_t alignment) {
-    Align(alignment);
-    return GetSize();
-  }
-
-  uoffset_t EndStruct() { return GetSize(); }
-
-  void ClearOffsets() {
-    buf_.scratch_pop(num_field_loc * sizeof(FieldLoc));
-    num_field_loc = 0;
-    max_voffset_ = 0;
-  }
-
-  // Aligns such that when "len" bytes are written, an object can be written
-  // after it with "alignment" without padding.
-  void PreAlign(size_t len, size_t alignment) {
-    TrackMinAlign(alignment);
-    buf_.fill(PaddingBytes(GetSize() + len, alignment));
-  }
-  template<typename T> void PreAlign(size_t len) {
-    AssertScalarT<T>();
-    PreAlign(len, sizeof(T));
-  }
-  /// @endcond
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const char pointer to the data to be stored as a string.
-  /// @param[in] len The number of bytes that should be stored from `str`.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateString(const char *str, size_t len) {
-    NotNested();
-    PreAlign<uoffset_t>(len + 1);  // Always 0-terminated.
-    buf_.fill(1);
-    PushBytes(reinterpret_cast<const uint8_t *>(str), len);
-    PushElement(static_cast<uoffset_t>(len));
-    return Offset<String>(GetSize());
-  }
-
-  /// @brief Store a string in the buffer, which is null-terminated.
-  /// @param[in] str A const char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateString(const char *str) {
-    return CreateString(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which is null-terminated.
-  /// @param[in] str A char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateString(char *str) {
-    return CreateString(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const reference to a std::string to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateString(const std::string &str) {
-    return CreateString(str.c_str(), str.length());
-  }
-
-  // clang-format off
-  #ifdef FLATBUFFERS_HAS_STRING_VIEW
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const string_view to copy in to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateString(flatbuffers::string_view str) {
-    return CreateString(str.data(), str.size());
-  }
-  #endif // FLATBUFFERS_HAS_STRING_VIEW
-  // clang-format on
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts
-  Offset<String> CreateString(const String *str) {
-    return str ? CreateString(str->c_str(), str->size()) : 0;
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// @param[in] str A const reference to a std::string like type with support
-  /// of T::c_str() and T::length() to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  template<typename T> Offset<String> CreateString(const T &str) {
-    return CreateString(str.c_str(), str.length());
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
-  /// @param[in] str A const char pointer to the data to be stored as a string.
-  /// @param[in] len The number of bytes that should be stored from `str`.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const char *str, size_t len) {
-    if (!string_pool)
-      string_pool = new StringOffsetMap(StringOffsetCompare(buf_));
-    auto size_before_string = buf_.size();
-    // Must first serialize the string, since the set is all offsets into
-    // buffer.
-    auto off = CreateString(str, len);
-    auto it = string_pool->find(off);
-    // If it exists we reuse existing serialized data!
-    if (it != string_pool->end()) {
-      // We can remove the string we serialized.
-      buf_.pop(buf_.size() - size_before_string);
-      return *it;
-    }
-    // Record this string for future use.
-    string_pool->insert(off);
-    return off;
-  }
-
-  /// @brief Store a string in the buffer, which null-terminated.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
-  /// @param[in] str A const char pointer to a C-string to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const char *str) {
-    return CreateSharedString(str, strlen(str));
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
-  /// @param[in] str A const reference to a std::string to store in the buffer.
-  /// @return Returns the offset in the buffer where the string starts.
-  Offset<String> CreateSharedString(const std::string &str) {
-    return CreateSharedString(str.c_str(), str.length());
-  }
-
-  /// @brief Store a string in the buffer, which can contain any binary data.
-  /// If a string with this exact contents has already been serialized before,
-  /// instead simply returns the offset of the existing string.
-  /// @param[in] str A const pointer to a `String` struct to add to the buffer.
-  /// @return Returns the offset in the buffer where the string starts
-  Offset<String> CreateSharedString(const String *str) {
-    return CreateSharedString(str->c_str(), str->size());
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  uoffset_t EndVector(size_t len) {
-    FLATBUFFERS_ASSERT(nested);  // Hit if no corresponding StartVector.
-    nested = false;
-    return PushElement(static_cast<uoffset_t>(len));
-  }
-
-  void StartVector(size_t len, size_t elemsize) {
-    NotNested();
-    nested = true;
-    PreAlign<uoffset_t>(len * elemsize);
-    PreAlign(len * elemsize, elemsize);  // Just in case elemsize > uoffset_t.
-  }
-
-  // Call this right before StartVector/CreateVector if you want to force the
-  // alignment to be something different than what the element size would
-  // normally dictate.
-  // This is useful when storing a nested_flatbuffer in a vector of bytes,
-  // or when storing SIMD floats, etc.
-  void ForceVectorAlignment(size_t len, size_t elemsize, size_t alignment) {
-    PreAlign(len * elemsize, alignment);
-  }
-
-  // Similar to ForceVectorAlignment but for String fields.
-  void ForceStringAlignment(size_t len, size_t alignment) {
-    PreAlign((len + 1) * sizeof(char), alignment);
-  }
-
-  /// @endcond
-
-  /// @brief Serialize an array into a FlatBuffer `vector`.
-  /// @tparam T The data type of the array elements.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T> Offset<Vector<T>> CreateVector(const T *v, size_t len) {
-    // If this assert hits, you're specifying a template argument that is
-    // causing the wrong overload to be selected, remove it.
-    AssertScalarT<T>();
-    StartVector(len, sizeof(T));
-    // clang-format off
-    #if FLATBUFFERS_LITTLEENDIAN
-      PushBytes(reinterpret_cast<const uint8_t *>(v), len * sizeof(T));
-    #else
-      if (sizeof(T) == 1) {
-        PushBytes(reinterpret_cast<const uint8_t *>(v), len);
-      } else {
-        for (auto i = len; i > 0; ) {
-          PushElement(v[--i]);
-        }
-      }
-    #endif
-    // clang-format on
-    return Offset<Vector<T>>(EndVector(len));
-  }
-
-  template<typename T>
-  Offset<Vector<Offset<T>>> CreateVector(const Offset<T> *v, size_t len) {
-    StartVector(len, sizeof(Offset<T>));
-    for (auto i = len; i > 0;) { PushElement(v[--i]); }
-    return Offset<Vector<Offset<T>>>(EndVector(len));
-  }
-
-  /// @brief Serialize a `std::vector` into a FlatBuffer `vector`.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param v A const reference to the `std::vector` to serialize into the
-  /// buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T> Offset<Vector<T>> CreateVector(const std::vector<T> &v) {
-    return CreateVector(data(v), v.size());
-  }
-
-  // vector<bool> may be implemented using a bit-set, so we can't access it as
-  // an array. Instead, read elements manually.
-  // Background: https://isocpp.org/blog/2012/11/on-vectorbool
-  Offset<Vector<uint8_t>> CreateVector(const std::vector<bool> &v) {
-    StartVector(v.size(), sizeof(uint8_t));
-    for (auto i = v.size(); i > 0;) {
-      PushElement(static_cast<uint8_t>(v[--i]));
-    }
-    return Offset<Vector<uint8_t>>(EndVector(v.size()));
-  }
-
-  // clang-format off
-  #ifndef FLATBUFFERS_CPP98_STL
-  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
-  /// This is a convenience function that takes care of iteration for you.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param f A function that takes the current iteration 0..vector_size-1 and
-  /// returns any type that you can construct a FlatBuffers vector out of.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T> Offset<Vector<T>> CreateVector(size_t vector_size,
-      const std::function<T (size_t i)> &f) {
-    std::vector<T> elems(vector_size);
-    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i);
-    return CreateVector(elems);
-  }
-  #endif
-  // clang-format on
-
-  /// @brief Serialize values returned by a function into a FlatBuffer `vector`.
-  /// This is a convenience function that takes care of iteration for you.
-  /// @tparam T The data type of the `std::vector` elements.
-  /// @param f A function that takes the current iteration 0..vector_size-1,
-  /// and the state parameter returning any type that you can construct a
-  /// FlatBuffers vector out of.
-  /// @param state State passed to f.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename F, typename S>
-  Offset<Vector<T>> CreateVector(size_t vector_size, F f, S *state) {
-    std::vector<T> elems(vector_size);
-    for (size_t i = 0; i < vector_size; i++) elems[i] = f(i, state);
-    return CreateVector(elems);
-  }
-
-  /// @brief Serialize a `std::vector<std::string>` into a FlatBuffer `vector`.
-  /// This is a convenience function for a common case.
-  /// @param v A const reference to the `std::vector` to serialize into the
-  /// buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  Offset<Vector<Offset<String>>> CreateVectorOfStrings(
-      const std::vector<std::string> &v) {
-    std::vector<Offset<String>> offsets(v.size());
-    for (size_t i = 0; i < v.size(); i++) offsets[i] = CreateString(v[i]);
-    return CreateVector(offsets);
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T>
-  Offset<Vector<const T *>> CreateVectorOfStructs(const T *v, size_t len) {
-    StartVector(len * sizeof(T) / AlignOf<T>(), AlignOf<T>());
-    PushBytes(reinterpret_cast<const uint8_t *>(v), sizeof(T) * len);
-    return Offset<Vector<const T *>>(EndVector(len));
-  }
-
-  /// @brief Serialize an array of native structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @tparam S The data type of the native struct array elements.
-  /// @param[in] v A pointer to the array of type `S` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename S>
-  Offset<Vector<const T *>> CreateVectorOfNativeStructs(const S *v,
-                                                        size_t len) {
-    extern T Pack(const S &);
-    std::vector<T> vv(len);
-    std::transform(v, v + len, vv.begin(), Pack);
-    return CreateVectorOfStructs<T>(data(vv), vv.size());
-  }
-
-  // clang-format off
-  #ifndef FLATBUFFERS_CPP98_STL
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] filler A function that takes the current iteration 0..vector_size-1
-  /// and a pointer to the struct that must be filled.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  /// This is mostly useful when flatbuffers are generated with mutation
-  /// accessors.
-  template<typename T> Offset<Vector<const T *>> CreateVectorOfStructs(
-      size_t vector_size, const std::function<void(size_t i, T *)> &filler) {
-    T* structs = StartVectorOfStructs<T>(vector_size);
-    for (size_t i = 0; i < vector_size; i++) {
-      filler(i, structs);
-      structs++;
-    }
-    return EndVectorOfStructs<T>(vector_size);
-  }
-  #endif
-  // clang-format on
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] f A function that takes the current iteration 0..vector_size-1,
-  /// a pointer to the struct that must be filled and the state argument.
-  /// @param[in] state Arbitrary state to pass to f.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  /// This is mostly useful when flatbuffers are generated with mutation
-  /// accessors.
-  template<typename T, typename F, typename S>
-  Offset<Vector<const T *>> CreateVectorOfStructs(size_t vector_size, F f,
-                                                  S *state) {
-    T *structs = StartVectorOfStructs<T>(vector_size);
-    for (size_t i = 0; i < vector_size; i++) {
-      f(i, structs, state);
-      structs++;
-    }
-    return EndVectorOfStructs<T>(vector_size);
-  }
-
-  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename Alloc>
-  Offset<Vector<const T *>> CreateVectorOfStructs(
-      const std::vector<T, Alloc> &v) {
-    return CreateVectorOfStructs(data(v), v.size());
-  }
-
-  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
-  /// `vector`.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @tparam S The data type of the `std::vector` native struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename S>
-  Offset<Vector<const T *>> CreateVectorOfNativeStructs(
-      const std::vector<S> &v) {
-    return CreateVectorOfNativeStructs<T, S>(data(v), v.size());
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  template<typename T> struct StructKeyComparator {
-    bool operator()(const T &a, const T &b) const {
-      return a.KeyCompareLessThan(&b);
-    }
-
-   private:
-    StructKeyComparator &operator=(const StructKeyComparator &);
-  };
-  /// @endcond
-
-  /// @brief Serialize a `std::vector` of structs into a FlatBuffer `vector`
-  /// in sorted order.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T>
-  Offset<Vector<const T *>> CreateVectorOfSortedStructs(std::vector<T> *v) {
-    return CreateVectorOfSortedStructs(data(*v), v->size());
-  }
-
-  /// @brief Serialize a `std::vector` of native structs into a FlatBuffer
-  /// `vector` in sorted order.
-  /// @tparam T The data type of the `std::vector` struct elements.
-  /// @tparam S The data type of the `std::vector` native struct elements.
-  /// @param[in] v A const reference to the `std::vector` of structs to
-  /// serialize into the buffer as a `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename S>
-  Offset<Vector<const T *>> CreateVectorOfSortedNativeStructs(
-      std::vector<S> *v) {
-    return CreateVectorOfSortedNativeStructs<T, S>(data(*v), v->size());
-  }
-
-  /// @brief Serialize an array of structs into a FlatBuffer `vector` in sorted
-  /// order.
-  /// @tparam T The data type of the struct array elements.
-  /// @param[in] v A pointer to the array of type `T` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T>
-  Offset<Vector<const T *>> CreateVectorOfSortedStructs(T *v, size_t len) {
-    std::sort(v, v + len, StructKeyComparator<T>());
-    return CreateVectorOfStructs(v, len);
-  }
-
-  /// @brief Serialize an array of native structs into a FlatBuffer `vector` in
-  /// sorted order.
-  /// @tparam T The data type of the struct array elements.
-  /// @tparam S The data type of the native struct array elements.
-  /// @param[in] v A pointer to the array of type `S` to serialize into the
-  /// buffer as a `vector`.
-  /// @param[in] len The number of elements to serialize.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T, typename S>
-  Offset<Vector<const T *>> CreateVectorOfSortedNativeStructs(S *v,
-                                                              size_t len) {
-    extern T Pack(const S &);
-    typedef T (*Pack_t)(const S &);
-    std::vector<T> vv(len);
-    std::transform(v, v + len, vv.begin(), static_cast<Pack_t &>(Pack));
-    return CreateVectorOfSortedStructs<T>(vv, len);
-  }
-
-  /// @cond FLATBUFFERS_INTERNAL
-  template<typename T> struct TableKeyComparator {
-    TableKeyComparator(vector_downward &buf) : buf_(buf) {}
-    TableKeyComparator(const TableKeyComparator &other) : buf_(other.buf_) {}
-    bool operator()(const Offset<T> &a, const Offset<T> &b) const {
-      auto table_a = reinterpret_cast<T *>(buf_.data_at(a.o));
-      auto table_b = reinterpret_cast<T *>(buf_.data_at(b.o));
-      return table_a->KeyCompareLessThan(table_b);
-    }
-    vector_downward &buf_;
-
-   private:
-    TableKeyComparator &operator=(const TableKeyComparator &other) {
-      buf_ = other.buf_;
-      return *this;
-    }
-  };
-  /// @endcond
-
-  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
-  /// in sorted order.
-  /// @tparam T The data type that the offset refers to.
-  /// @param[in] v An array of type `Offset<T>` that contains the `table`
-  /// offsets to store in the buffer in sorted order.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T>
-  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(Offset<T> *v,
-                                                       size_t len) {
-    std::sort(v, v + len, TableKeyComparator<T>(buf_));
-    return CreateVector(v, len);
-  }
-
-  /// @brief Serialize an array of `table` offsets as a `vector` in the buffer
-  /// in sorted order.
-  /// @tparam T The data type that the offset refers to.
-  /// @param[in] v An array of type `Offset<T>` that contains the `table`
-  /// offsets to store in the buffer in sorted order.
-  /// @return Returns a typed `Offset` into the serialized data indicating
-  /// where the vector is stored.
-  template<typename T>
-  Offset<Vector<Offset<T>>> CreateVectorOfSortedTables(
-      std::vector<Offset<T>> *v) {
-    return CreateVectorOfSortedTables(data(*v), v->size());
-  }
-
-  /// @brief Specialized version of `CreateVector` for non-copying use cases.
-  /// Write the data any time later to the returned buffer pointer `buf`.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @param[in] elemsize The size of each element in the `vector`.
-  /// @param[out] buf A pointer to a `uint8_t` pointer that can be
-  /// written to at a later time to serialize the data into a `vector`
-  /// in the buffer.
-  uoffset_t CreateUninitializedVector(size_t len, size_t elemsize,
-                                      uint8_t **buf) {
-    NotNested();
-    StartVector(len, elemsize);
-    buf_.make_space(len * elemsize);
-    auto vec_start = GetSize();
-    auto vec_end = EndVector(len);
-    *buf = buf_.data_at(vec_start);
-    return vec_end;
-  }
-
-  /// @brief Specialized version of `CreateVector` for non-copying use cases.
-  /// Write the data any time later to the returned buffer pointer `buf`.
-  /// @tparam T The data type of the data that will be stored in the buffer
-  /// as a `vector`.
-  /// @param[in] len The number of elements to store in the `vector`.
-  /// @param[out] buf A pointer to a pointer of type `T` that can be
-  /// written to at a later time to serialize the data into a `vector`
-  /// in the buffer.
-  template<typename T>
-  Offset<Vector<T>> CreateUninitializedVector(size_t len, T **buf) {
-    AssertScalarT<T>();
-    return CreateUninitializedVector(len, sizeof(T),
-                                     reinterpret_cast<uint8_t **>(buf));
-  }
-
-  template<typename T>
-  Offset<Vector<const T *>> CreateUninitializedVectorOfStructs(size_t len,
-                                                               T **buf) {
-    return CreateUninitializedVector(len, sizeof(T),
-                                     reinterpret_cast<uint8_t **>(buf));
-  }
-
-  // @brief Create a vector of scalar type T given as input a vector of scalar
-  // type U, useful with e.g. pre "enum class" enums, or any existing scalar
-  // data of the wrong type.
-  template<typename T, typename U>
-  Offset<Vector<T>> CreateVectorScalarCast(const U *v, size_t len) {
-    AssertScalarT<T>();
-    AssertScalarT<U>();
-    StartVector(len, sizeof(T));
-    for (auto i = len; i > 0;) { PushElement(static_cast<T>(v[--i])); }
-    return Offset<Vector<T>>(EndVector(len));
-  }
-
-  /// @brief Write a struct by itself, typically to be part of a union.
-  template<typename T> Offset<const T *> CreateStruct(const T &structobj) {
-    NotNested();
-    Align(AlignOf<T>());
-    buf_.push_small(structobj);
-    return Offset<const T *>(GetSize());
-  }
-
-  /// @brief The length of a FlatBuffer file header.
-  static const size_t kFileIdentifierLength = 4;
-
-  /// @brief Finish serializing a buffer by writing the root offset.
-  /// @param[in] file_identifier If a `file_identifier` is given, the buffer
-  /// will be prefixed with a standard FlatBuffers file header.
-  template<typename T>
-  void Finish(Offset<T> root, const char *file_identifier = nullptr) {
-    Finish(root.o, file_identifier, false);
-  }
-
-  /// @brief Finish a buffer with a 32 bit size field pre-fixed (size of the
-  /// buffer following the size field). These buffers are NOT compatible
-  /// with standard buffers created by Finish, i.e. you can't call GetRoot
-  /// on them, you have to use GetSizePrefixedRoot instead.
-  /// All >32 bit quantities in this buffer will be aligned when the whole
-  /// size pre-fixed buffer is aligned.
-  /// These kinds of buffers are useful for creating a stream of FlatBuffers.
-  template<typename T>
-  void FinishSizePrefixed(Offset<T> root,
-                          const char *file_identifier = nullptr) {
-    Finish(root.o, file_identifier, true);
-  }
-
-  void SwapBufAllocator(FlatBufferBuilder &other) {
-    buf_.swap_allocator(other.buf_);
-  }
-
- protected:
-  // You shouldn't really be copying instances of this class.
-  FlatBufferBuilder(const FlatBufferBuilder &);
-  FlatBufferBuilder &operator=(const FlatBufferBuilder &);
-
-  void Finish(uoffset_t root, const char *file_identifier, bool size_prefix) {
-    NotNested();
-    buf_.clear_scratch();
-    // This will cause the whole buffer to be aligned.
-    PreAlign((size_prefix ? sizeof(uoffset_t) : 0) + sizeof(uoffset_t) +
-                 (file_identifier ? kFileIdentifierLength : 0),
-             minalign_);
-    if (file_identifier) {
-      FLATBUFFERS_ASSERT(strlen(file_identifier) == kFileIdentifierLength);
-      PushBytes(reinterpret_cast<const uint8_t *>(file_identifier),
-                kFileIdentifierLength);
-    }
-    PushElement(ReferTo(root));  // Location of root.
-    if (size_prefix) { PushElement(GetSize()); }
-    finished = true;
-  }
-
-  struct FieldLoc {
-    uoffset_t off;
-    voffset_t id;
-  };
-
-  vector_downward buf_;
-
-  // Accumulating offsets of table members while it is being built.
-  // We store these in the scratch pad of buf_, after the vtable offsets.
-  uoffset_t num_field_loc;
-  // Track how much of the vtable is in use, so we can output the most compact
-  // possible vtable.
-  voffset_t max_voffset_;
-
-  // Ensure objects are not nested.
-  bool nested;
-
-  // Ensure the buffer is finished before it is being accessed.
-  bool finished;
-
-  size_t minalign_;
-
-  bool force_defaults_;  // Serialize values equal to their defaults anyway.
-
-  bool dedup_vtables_;
-
-  struct StringOffsetCompare {
-    StringOffsetCompare(const vector_downward &buf) : buf_(&buf) {}
-    bool operator()(const Offset<String> &a, const Offset<String> &b) const {
-      auto stra = reinterpret_cast<const String *>(buf_->data_at(a.o));
-      auto strb = reinterpret_cast<const String *>(buf_->data_at(b.o));
-      return StringLessThan(stra->data(), stra->size(), strb->data(),
-                            strb->size());
-    }
-    const vector_downward *buf_;
-  };
-
-  // For use with CreateSharedString. Instantiated on first use only.
-  typedef std::set<Offset<String>, StringOffsetCompare> StringOffsetMap;
-  StringOffsetMap *string_pool;
-
- private:
-  // Allocates space for a vector of structures.
-  // Must be completed with EndVectorOfStructs().
-  template<typename T> T *StartVectorOfStructs(size_t vector_size) {
-    StartVector(vector_size * sizeof(T) / AlignOf<T>(), AlignOf<T>());
-    return reinterpret_cast<T *>(buf_.make_space(vector_size * sizeof(T)));
-  }
-
-  // End the vector of structues in the flatbuffers.
-  // Vector should have previously be started with StartVectorOfStructs().
-  template<typename T>
-  Offset<Vector<const T *>> EndVectorOfStructs(size_t vector_size) {
-    return Offset<Vector<const T *>>(EndVector(vector_size));
-  }
-};
-/// @}
-
-/// @cond FLATBUFFERS_INTERNAL
-// Helpers to get a typed pointer to the root object contained in the buffer.
-template<typename T> T *GetMutableRoot(void *buf) {
-  EndianCheck();
-  return reinterpret_cast<T *>(
-      reinterpret_cast<uint8_t *>(buf) +
-      EndianScalar(*reinterpret_cast<uoffset_t *>(buf)));
-}
-
-template<typename T> const T *GetRoot(const void *buf) {
-  return GetMutableRoot<T>(const_cast<void *>(buf));
-}
-
-template<typename T> const T *GetSizePrefixedRoot(const void *buf) {
-  return GetRoot<T>(reinterpret_cast<const uint8_t *>(buf) + sizeof(uoffset_t));
-}
-
-/// Helpers to get a typed pointer to objects that are currently being built.
-/// @warning Creating new objects will lead to reallocations and invalidates
-/// the pointer!
-template<typename T>
-T *GetMutableTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
-  return reinterpret_cast<T *>(fbb.GetCurrentBufferPointer() + fbb.GetSize() -
-                               offset.o);
-}
-
-template<typename T>
-const T *GetTemporaryPointer(FlatBufferBuilder &fbb, Offset<T> offset) {
-  return GetMutableTemporaryPointer<T>(fbb, offset);
-}
-
-/// @brief Get a pointer to the the file_identifier section of the buffer.
-/// @return Returns a const char pointer to the start of the file_identifier
-/// characters in the buffer.  The returned char * has length
-/// 'flatbuffers::FlatBufferBuilder::kFileIdentifierLength'.
-/// This function is UNDEFINED for FlatBuffers whose schema does not include
-/// a file_identifier (likely points at padding or the start of a the root
-/// vtable).
-inline const char *GetBufferIdentifier(const void *buf,
-                                       bool size_prefixed = false) {
-  return reinterpret_cast<const char *>(buf) +
-         ((size_prefixed) ? 2 * sizeof(uoffset_t) : sizeof(uoffset_t));
-}
-
-// Helper to see if the identifier in a buffer has the expected value.
-inline bool BufferHasIdentifier(const void *buf, const char *identifier,
-                                bool size_prefixed = false) {
-  return strncmp(GetBufferIdentifier(buf, size_prefixed), identifier,
-                 FlatBufferBuilder::kFileIdentifierLength) == 0;
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
 }
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
 
-// Helper class to verify the integrity of a FlatBuffer
-class Verifier FLATBUFFERS_FINAL_CLASS {
- public:
-  Verifier(const uint8_t *buf, size_t buf_len, uoffset_t _max_depth = 64,
-           uoffset_t _max_tables = 1000000, bool _check_alignment = true)
-      : buf_(buf),
-        size_(buf_len),
-        depth_(0),
-        max_depth_(_max_depth),
-        num_tables_(0),
-        max_tables_(_max_tables),
-        upper_bound_(0),
-        check_alignment_(_check_alignment) {
-    FLATBUFFERS_ASSERT(size_ < FLATBUFFERS_MAX_BUFFER_SIZE);
-  }
-
-  // Central location where any verification failures register.
-  bool Check(bool ok) const {
-    // clang-format off
-    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
-      FLATBUFFERS_ASSERT(ok);
-    #endif
-    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-      if (!ok)
-        upper_bound_ = 0;
-    #endif
-    // clang-format on
-    return ok;
-  }
-
-  // Verify any range within the buffer.
-  bool Verify(size_t elem, size_t elem_len) const {
-    // clang-format off
-    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-      auto upper_bound = elem + elem_len;
-      if (upper_bound_ < upper_bound)
-        upper_bound_ =  upper_bound;
-    #endif
-    // clang-format on
-    return Check(elem_len < size_ && elem <= size_ - elem_len);
-  }
-
-  template<typename T> bool VerifyAlignment(size_t elem) const {
-    return Check((elem & (sizeof(T) - 1)) == 0 || !check_alignment_);
-  }
-
-  // Verify a range indicated by sizeof(T).
-  template<typename T> bool Verify(size_t elem) const {
-    return VerifyAlignment<T>(elem) && Verify(elem, sizeof(T));
-  }
-
-  bool VerifyFromPointer(const uint8_t *p, size_t len) {
-    auto o = static_cast<size_t>(p - buf_);
-    return Verify(o, len);
-  }
-
-  // Verify relative to a known-good base pointer.
-  bool Verify(const uint8_t *base, voffset_t elem_off, size_t elem_len) const {
-    return Verify(static_cast<size_t>(base - buf_) + elem_off, elem_len);
-  }
-
-  template<typename T>
-  bool Verify(const uint8_t *base, voffset_t elem_off) const {
-    return Verify(static_cast<size_t>(base - buf_) + elem_off, sizeof(T));
-  }
-
-  // Verify a pointer (may be NULL) of a table type.
-  template<typename T> bool VerifyTable(const T *table) {
-    return !table || table->Verify(*this);
-  }
-
-  // Verify a pointer (may be NULL) of any vector type.
-  template<typename T> bool VerifyVector(const Vector<T> *vec) const {
-    return !vec || VerifyVectorOrString(reinterpret_cast<const uint8_t *>(vec),
-                                        sizeof(T));
-  }
-
-  // Verify a pointer (may be NULL) of a vector to struct.
-  template<typename T> bool VerifyVector(const Vector<const T *> *vec) const {
-    return VerifyVector(reinterpret_cast<const Vector<T> *>(vec));
-  }
-
-  // Verify a pointer (may be NULL) to string.
-  bool VerifyString(const String *str) const {
-    size_t end;
-    return !str || (VerifyVectorOrString(reinterpret_cast<const uint8_t *>(str),
-                                         1, &end) &&
-                    Verify(end, 1) &&           // Must have terminator
-                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
-  }
-
-  // Common code between vectors and strings.
-  bool VerifyVectorOrString(const uint8_t *vec, size_t elem_size,
-                            size_t *end = nullptr) const {
-    auto veco = static_cast<size_t>(vec - buf_);
-    // Check we can read the size field.
-    if (!Verify<uoffset_t>(veco)) return false;
-    // Check the whole array. If this is a string, the byte past the array
-    // must be 0.
-    auto size = ReadScalar<uoffset_t>(vec);
-    auto max_elems = FLATBUFFERS_MAX_BUFFER_SIZE / elem_size;
-    if (!Check(size < max_elems))
-      return false;  // Protect against byte_size overflowing.
-    auto byte_size = sizeof(size) + elem_size * size;
-    if (end) *end = veco + byte_size;
-    return Verify(veco, byte_size);
-  }
-
-  // Special case for string contents, after the above has been called.
-  bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const {
-    if (vec) {
-      for (uoffset_t i = 0; i < vec->size(); i++) {
-        if (!VerifyString(vec->Get(i))) return false;
-      }
-    }
-    return true;
-  }
-
-  // Special case for table contents, after the above has been called.
-  template<typename T> bool VerifyVectorOfTables(const Vector<Offset<T>> *vec) {
-    if (vec) {
-      for (uoffset_t i = 0; i < vec->size(); i++) {
-        if (!vec->Get(i)->Verify(*this)) return false;
-      }
-    }
-    return true;
-  }
-
-  __supress_ubsan__("unsigned-integer-overflow") bool VerifyTableStart(
-      const uint8_t *table) {
-    // Check the vtable offset.
-    auto tableo = static_cast<size_t>(table - buf_);
-    if (!Verify<soffset_t>(tableo)) return false;
-    // This offset may be signed, but doing the subtraction unsigned always
-    // gives the result we want.
-    auto vtableo = tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
-    // Check the vtable size field, then check vtable fits in its entirety.
-    return VerifyComplexity() && Verify<voffset_t>(vtableo) &&
-           VerifyAlignment<voffset_t>(ReadScalar<voffset_t>(buf_ + vtableo)) &&
-           Verify(vtableo, ReadScalar<voffset_t>(buf_ + vtableo));
-  }
-
-  template<typename T>
-  bool VerifyBufferFromStart(const char *identifier, size_t start) {
-    if (identifier && (size_ < 2 * sizeof(flatbuffers::uoffset_t) ||
-                       !BufferHasIdentifier(buf_ + start, identifier))) {
-      return false;
-    }
-
-    // Call T::Verify, which must be in the generated code for this type.
-    auto o = VerifyOffset(start);
-    return o && reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
-    // clang-format off
-    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-           && GetComputedSize()
-    #endif
-        ;
-    // clang-format on
-  }
-
-  // Verify this whole buffer, starting with root type T.
-  template<typename T> bool VerifyBuffer() { return VerifyBuffer<T>(nullptr); }
-
-  template<typename T> bool VerifyBuffer(const char *identifier) {
-    return VerifyBufferFromStart<T>(identifier, 0);
-  }
-
-  template<typename T> bool VerifySizePrefixedBuffer(const char *identifier) {
-    return Verify<uoffset_t>(0U) &&
-           ReadScalar<uoffset_t>(buf_) == size_ - sizeof(uoffset_t) &&
-           VerifyBufferFromStart<T>(identifier, sizeof(uoffset_t));
-  }
-
-  uoffset_t VerifyOffset(size_t start) const {
-    if (!Verify<uoffset_t>(start)) return 0;
-    auto o = ReadScalar<uoffset_t>(buf_ + start);
-    // May not point to itself.
-    if (!Check(o != 0)) return 0;
-    // Can't wrap around / buffers are max 2GB.
-    if (!Check(static_cast<soffset_t>(o) >= 0)) return 0;
-    // Must be inside the buffer to create a pointer from it (pointer outside
-    // buffer is UB).
-    if (!Verify(start + o, 1)) return 0;
-    return o;
-  }
-
-  uoffset_t VerifyOffset(const uint8_t *base, voffset_t start) const {
-    return VerifyOffset(static_cast<size_t>(base - buf_) + start);
-  }
-
-  // Called at the start of a table to increase counters measuring data
-  // structure depth and amount, and possibly bails out with false if
-  // limits set by the constructor have been hit. Needs to be balanced
-  // with EndTable().
-  bool VerifyComplexity() {
-    depth_++;
-    num_tables_++;
-    return Check(depth_ <= max_depth_ && num_tables_ <= max_tables_);
-  }
-
-  // Called at the end of a table to pop the depth count.
-  bool EndTable() {
-    depth_--;
-    return true;
-  }
-
-  // Returns the message size in bytes
-  size_t GetComputedSize() const {
-    // clang-format off
-    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
-      uintptr_t size = upper_bound_;
-      // Align the size to uoffset_t
-      size = (size - 1 + sizeof(uoffset_t)) & ~(sizeof(uoffset_t) - 1);
-      return (size > size_) ?  0 : size;
-    #else
-      // Must turn on FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE for this to work.
-      (void)upper_bound_;
-      FLATBUFFERS_ASSERT(false);
-      return 0;
-    #endif
-    // clang-format on
-  }
-
- private:
-  const uint8_t *buf_;
-  size_t size_;
-  uoffset_t depth_;
-  uoffset_t max_depth_;
-  uoffset_t num_tables_;
-  uoffset_t max_tables_;
-  mutable size_t upper_bound_;
-  bool check_alignment_;
-};
-
-// Convenient way to bundle a buffer and its length, to pass it around
-// typed by its root.
-// A BufferRef does not own its buffer.
-struct BufferRefBase {};  // for std::is_base_of
-template<typename T> struct BufferRef : BufferRefBase {
-  BufferRef() : buf(nullptr), len(0), must_free(false) {}
-  BufferRef(uint8_t *_buf, uoffset_t _len)
-      : buf(_buf), len(_len), must_free(false) {}
-
-  ~BufferRef() {
-    if (must_free) free(buf);
-  }
-
-  const T *GetRoot() const { return flatbuffers::GetRoot<T>(buf); }
-
-  bool Verify() {
-    Verifier verifier(buf, len);
-    return verifier.VerifyBuffer<T>(nullptr);
-  }
-
-  uint8_t *buf;
-  uoffset_t len;
-  bool must_free;
-};
-
-// "structs" are flat structures that do not have an offset table, thus
-// always have all members present and do not support forwards/backwards
-// compatible extensions.
-
-class Struct FLATBUFFERS_FINAL_CLASS {
- public:
-  template<typename T> T GetField(uoffset_t o) const {
-    return ReadScalar<T>(&data_[o]);
-  }
-
-  template<typename T> T GetStruct(uoffset_t o) const {
-    return reinterpret_cast<T>(&data_[o]);
-  }
-
-  const uint8_t *GetAddressOf(uoffset_t o) const { return &data_[o]; }
-  uint8_t *GetAddressOf(uoffset_t o) { return &data_[o]; }
-
- private:
-  // private constructor & copy constructor: you obtain instances of this
-  // class by pointing to existing data only
-  Struct();
-  Struct(const Struct &);
-  Struct &operator=(const Struct &);
-
-  uint8_t data_[1];
-};
-
-// "tables" use an offset table (possibly shared) that allows fields to be
-// omitted and added at will, but uses an extra indirection to read.
-class Table {
- public:
-  const uint8_t *GetVTable() const {
-    return data_ - ReadScalar<soffset_t>(data_);
-  }
-
-  // This gets the field offset for any of the functions below it, or 0
-  // if the field was not present.
-  voffset_t GetOptionalFieldOffset(voffset_t field) const {
-    // The vtable offset is always at the start.
-    auto vtable = GetVTable();
-    // The first element is the size of the vtable (fields + type id + itself).
-    auto vtsize = ReadScalar<voffset_t>(vtable);
-    // If the field we're accessing is outside the vtable, we're reading older
-    // data, so it's the same as if the offset was 0 (not present).
-    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
-  }
-
-  template<typename T> T GetField(voffset_t field, T defaultval) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
-  }
-
-  template<typename P> P GetPointer(voffset_t field) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    auto p = data_ + field_offset;
-    return field_offset ? reinterpret_cast<P>(p + ReadScalar<uoffset_t>(p))
-                        : nullptr;
-  }
-  template<typename P> P GetPointer(voffset_t field) const {
-    return const_cast<Table *>(this)->GetPointer<P>(field);
-  }
-
-  template<typename P> P GetStruct(voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    auto p = const_cast<uint8_t *>(data_ + field_offset);
-    return field_offset ? reinterpret_cast<P>(p) : nullptr;
-  }
-
-  template<typename T> bool SetField(voffset_t field, T val, T def) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    if (!field_offset) return IsTheSameAs(val, def);
-    WriteScalar(data_ + field_offset, val);
-    return true;
-  }
-
-  bool SetPointer(voffset_t field, const uint8_t *val) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    if (!field_offset) return false;
-    WriteScalar(data_ + field_offset,
-                static_cast<uoffset_t>(val - (data_ + field_offset)));
-    return true;
-  }
-
-  uint8_t *GetAddressOf(voffset_t field) {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return field_offset ? data_ + field_offset : nullptr;
-  }
-  const uint8_t *GetAddressOf(voffset_t field) const {
-    return const_cast<Table *>(this)->GetAddressOf(field);
-  }
-
-  bool CheckField(voffset_t field) const {
-    return GetOptionalFieldOffset(field) != 0;
-  }
-
-  // Verify the vtable of this table.
-  // Call this once per table, followed by VerifyField once per field.
-  bool VerifyTableStart(Verifier &verifier) const {
-    return verifier.VerifyTableStart(data_);
-  }
-
-  // Verify a particular field.
-  template<typename T>
-  bool VerifyField(const Verifier &verifier, voffset_t field) const {
-    // Calling GetOptionalFieldOffset should be safe now thanks to
-    // VerifyTable().
-    auto field_offset = GetOptionalFieldOffset(field);
-    // Check the actual field.
-    return !field_offset || verifier.Verify<T>(data_, field_offset);
-  }
-
-  // VerifyField for required fields.
-  template<typename T>
-  bool VerifyFieldRequired(const Verifier &verifier, voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return verifier.Check(field_offset != 0) &&
-           verifier.Verify<T>(data_, field_offset);
-  }
-
-  // Versions for offsets.
-  bool VerifyOffset(const Verifier &verifier, voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return !field_offset || verifier.VerifyOffset(data_, field_offset);
-  }
-
-  bool VerifyOffsetRequired(const Verifier &verifier, voffset_t field) const {
-    auto field_offset = GetOptionalFieldOffset(field);
-    return verifier.Check(field_offset != 0) &&
-           verifier.VerifyOffset(data_, field_offset);
-  }
-
- private:
-  // private constructor & copy constructor: you obtain instances of this
-  // class by pointing to existing data only
-  Table();
-  Table(const Table &other);
-  Table &operator=(const Table &);
+#include <algorithm>
 
-  uint8_t data_[1];
-};
+// TODO: These includes are for mitigating the pains of users editing their
+// source because they relied on flatbuffers.h to include everything for them.
+#include "flatbuffers/array.h"
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/buffer_ref.h"
+#include "flatbuffers/detached_buffer.h"
+#include "flatbuffers/flatbuffer_builder.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/string.h"
+#include "flatbuffers/struct.h"
+#include "flatbuffers/table.h"
+#include "flatbuffers/vector.h"
+#include "flatbuffers/vector_downward.h"
+#include "flatbuffers/verifier.h"
 
-template<typename T>
-void FlatBufferBuilder::Required(Offset<T> table, voffset_t field) {
-  auto table_ptr = reinterpret_cast<const Table *>(buf_.data_at(table.o));
-  bool ok = table_ptr->GetOptionalFieldOffset(field) != 0;
-  // If this fails, the caller will show what field needs to be set.
-  FLATBUFFERS_ASSERT(ok);
-  (void)ok;
-}
+namespace arrow_vendored_private {
+namespace flatbuffers {
 
 /// @brief This can compute the start of a FlatBuffer from a root pointer, i.e.
 /// it is the opposite transformation of GetRoot().
@@ -2564,7 +65,7 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) {
   // file_identifier, and alignment padding) to see which points to the root.
   // None of the other values can "impersonate" the root since they will either
   // be 0 or four ASCII characters.
-  static_assert(FlatBufferBuilder::kFileIdentifierLength == sizeof(uoffset_t),
+  static_assert(flatbuffers::kFileIdentifierLength == sizeof(uoffset_t),
                 "file_identifier is assumed to be the same size as uoffset_t");
   for (auto possible_roots = FLATBUFFERS_MAX_ALIGNMENT / sizeof(uoffset_t) + 1;
        possible_roots; possible_roots--) {
@@ -2582,8 +83,20 @@ inline const uint8_t *GetBufferStartFromRootPointer(const void *root) {
 }
 
 /// @brief This return the prefixed size of a FlatBuffer.
-inline uoffset_t GetPrefixedSize(const uint8_t *buf) {
-  return ReadScalar<uoffset_t>(buf);
+template<typename SizeT = uoffset_t>
+inline SizeT GetPrefixedSize(const uint8_t *buf) {
+  return ReadScalar<SizeT>(buf);
+}
+
+// Gets the total length of the buffer given a sized prefixed FlatBuffer.
+//
+// This includes the size of the prefix as well as the buffer:
+//
+//  [size prefix][flatbuffer]
+//  |---------length--------|
+template<typename SizeT = uoffset_t>
+inline SizeT GetSizePrefixedBufferLength(const uint8_t *const buf) {
+  return ReadScalar<SizeT>(buf) + sizeof(SizeT);
 }
 
 // Base class for native objects (FlatBuffer data de-serialized into native
@@ -2600,16 +113,9 @@ struct NativeTable {};
 /// if you wish. The resolver does the opposite lookup, for when the object
 /// is being serialized again.
 typedef uint64_t hash_value_t;
-// clang-format off
-#ifdef FLATBUFFERS_CPP98_STL
-  typedef void (*resolver_function_t)(void **pointer_adr, hash_value_t hash);
-  typedef hash_value_t (*rehasher_function_t)(void *pointer);
-#else
-  typedef std::function<void (void **pointer_adr, hash_value_t hash)>
-          resolver_function_t;
-  typedef std::function<hash_value_t (void *pointer)> rehasher_function_t;
-#endif
-// clang-format on
+typedef std::function<void(void **pointer_adr, hash_value_t hash)>
+    resolver_function_t;
+typedef std::function<hash_value_t(void *pointer)> rehasher_function_t;
 
 // Helper function to test if a field is present, using any of the field
 // enums in the generated code.
@@ -2666,7 +172,7 @@ inline int LookupEnum(const char **names, const char *name) {
 
 // Minimal reflection via code generation.
 // Besides full-fat reflection (see reflection.h) and parsing/printing by
-// loading schemas (see idl.h), we can also have code generation for mimimal
+// loading schemas (see idl.h), we can also have code generation for minimal
 // reflection data which allows pretty-printing and other uses without needing
 // a schema or a parser.
 // Generate code with --reflect-types (types only) or --reflect-names (names
@@ -2711,10 +217,16 @@ inline const char * const *ElementaryTypeNames() {
 // clang-format on
 
 // Basic type info cost just 16bits per field!
+// We're explicitly defining the signedness since the signedness of integer
+// bitfields is otherwise implementation-defined and causes warnings on older
+// GCC compilers.
 struct TypeCode {
-  uint16_t base_type : 4;  // ElementaryType
-  uint16_t is_vector : 1;
-  int16_t sequence_ref : 11;  // Index into type_refs below, or -1 for none.
+  // ElementaryType
+  unsigned short base_type : 4;
+  // Either vector (in table) or array (in struct)
+  unsigned short is_repeating : 1;
+  // Index into type_refs below, or -1 for none.
+  signed short sequence_ref : 11;
 };
 
 static_assert(sizeof(TypeCode) == 2, "TypeCode");
@@ -2729,32 +241,19 @@ struct TypeTable {
   size_t num_elems;  // of type_codes, values, names (but not type_refs).
   const TypeCode *type_codes;     // num_elems count
   const TypeFunction *type_refs;  // less than num_elems entries (see TypeCode).
+  const int16_t *array_sizes;     // less than num_elems entries (see TypeCode).
   const int64_t *values;  // Only set for non-consecutive enum/union or structs.
   const char *const *names;  // Only set if compiled with --reflect-names.
 };
 
 // String which identifies the current version of FlatBuffers.
-// flatbuffer_version_string is used by Google developers to identify which
-// applications uploaded to Google Play are using this library.  This allows
-// the development team at Google to determine the popularity of the library.
-// How it works: Applications that are uploaded to the Google Play Store are
-// scanned for this version string.  We track which applications are using it
-// to measure popularity.  You are free to remove it (of course) but we would
-// appreciate if you left it in.
+inline const char *flatbuffers_version_string() {
+  return "FlatBuffers " FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
+      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
+      FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
+}
 
-// Weak linkage is culled by VS & doesn't work on cygwin.
 // clang-format off
-#if !defined(_WIN32) && !defined(__CYGWIN__)
-
-extern volatile __attribute__((weak)) const char *flatbuffer_version_string;
-volatile __attribute__((weak)) const char *flatbuffer_version_string =
-  "FlatBuffers "
-  FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MAJOR) "."
-  FLATBUFFERS_STRING(FLATBUFFERS_VERSION_MINOR) "."
-  FLATBUFFERS_STRING(FLATBUFFERS_VERSION_REVISION);
-
-#endif  // !defined(_WIN32) && !defined(__CYGWIN__)
-
 #define FLATBUFFERS_DEFINE_BITMASK_OPERATORS(E, T)\
     inline E operator | (E lhs, E rhs){\
         return E(T(lhs) | T(rhs));\
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
index 7e5a95233b0bc..dcbe23347d5ea 100644
--- a/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/stl_emulation.h
@@ -18,6 +18,7 @@
 #define FLATBUFFERS_STL_EMULATION_H_
 
 // clang-format off
+#include "flatbuffers/base.h"
 
 #include <string>
 #include <type_traits>
@@ -27,156 +28,74 @@
 
 // Move this vendored copy of flatbuffers to a private namespace,
 // but continue to access it through the "flatbuffers" alias.
-namespace arrow_vendored_private {
-namespace flatbuffers {
-}
+namespace arrow_vendored_private::flatbuffers {
 }
 namespace flatbuffers = arrow_vendored_private::flatbuffers;
 
-#if defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL)
-  #define FLATBUFFERS_CPP98_STL
-#endif  // defined(_STLPORT_VERSION) && !defined(FLATBUFFERS_CPP98_STL)
-
-#if defined(FLATBUFFERS_CPP98_STL)
-  #include <cctype>
-#endif  // defined(FLATBUFFERS_CPP98_STL)
-
-// Check if we can use template aliases
-// Not possible if Microsoft Compiler before 2012
-// Possible is the language feature __cpp_alias_templates is defined well
-// Or possible if the C++ std is C+11 or newer
-#if (defined(_MSC_VER) && _MSC_VER > 1700 /* MSVC2012 */) \
-    || (defined(__cpp_alias_templates) && __cpp_alias_templates >= 200704) \
-    || (defined(__cplusplus) && __cplusplus >= 201103L)
-  #define FLATBUFFERS_TEMPLATES_ALIASES
+#ifndef FLATBUFFERS_USE_STD_OPTIONAL
+  // Detect C++17 compatible compiler.
+  // __cplusplus >= 201703L - a compiler has support of 'static inline' variables.
+  #if (defined(__cplusplus) && __cplusplus >= 201703L) \
+      || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #define FLATBUFFERS_USE_STD_OPTIONAL 1
+  #else
+    #define FLATBUFFERS_USE_STD_OPTIONAL 0
+  #endif // (defined(__cplusplus) && __cplusplus >= 201703L) ...
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+#if FLATBUFFERS_USE_STD_OPTIONAL
+  #include <optional>
 #endif
 
-// This header provides backwards compatibility for C++98 STLs like stlport.
+#ifndef FLATBUFFERS_USE_STD_SPAN
+  // Testing __cpp_lib_span requires including either <version> or <span>,
+  // both of which were added in C++20.
+  // See: https://en.cppreference.com/w/cpp/utility/feature_test
+  #if defined(__cplusplus) && __cplusplus >= 202002L
+    #define FLATBUFFERS_USE_STD_SPAN 1
+  #endif
+#endif // FLATBUFFERS_USE_STD_SPAN
+
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+  #include <array>
+  #include <span>
+#else
+  // Disable non-trivial ctors if FLATBUFFERS_SPAN_MINIMAL defined.
+  #if !defined(FLATBUFFERS_TEMPLATES_ALIASES)
+    #define FLATBUFFERS_SPAN_MINIMAL
+  #else
+    // Enable implicit construction of a span<T,N> from a std::array<T,N>.
+    #include <array>
+  #endif
+#endif // defined(FLATBUFFERS_USE_STD_SPAN)
+
+// This header provides backwards compatibility for older versions of the STL.
 namespace arrow_vendored_private {
 namespace flatbuffers {
 
-// Retrieve ::back() from a string in a way that is compatible with pre C++11
-// STLs (e.g stlport).
-inline char& string_back(std::string &value) {
-  return value[value.length() - 1];
-}
-
-inline char string_back(const std::string &value) {
-  return value[value.length() - 1];
-}
-
-// Helper method that retrieves ::data() from a vector in a way that is
-// compatible with pre C++11 STLs (e.g stlport).
-template <typename T> inline T *vector_data(std::vector<T> &vector) {
-  // In some debug environments, operator[] does bounds checking, so &vector[0]
-  // can't be used.
-  return vector.empty() ? nullptr : &vector[0];
-}
-
-template <typename T> inline const T *vector_data(
-    const std::vector<T> &vector) {
-  return vector.empty() ? nullptr : &vector[0];
-}
-
-template <typename T, typename V>
-inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
-  #if defined(FLATBUFFERS_CPP98_STL)
-    vector->push_back(data);
-  #else
-    vector->emplace_back(std::forward<V>(data));
-  #endif  // defined(FLATBUFFERS_CPP98_STL)
-}
-
-#ifndef FLATBUFFERS_CPP98_STL
-  #if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-    template <typename T>
-    using numeric_limits = std::numeric_limits<T>;
-  #else
-    template <typename T> class numeric_limits :
-      public std::numeric_limits<T> {};
-  #endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
+#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+  template <typename T>
+  using numeric_limits = std::numeric_limits<T>;
 #else
   template <typename T> class numeric_limits :
-      public std::numeric_limits<T> {
-    public:
-      // Android NDK fix.
-      static T lowest() {
-        return std::numeric_limits<T>::min();
-      }
-  };
-
-  template <> class numeric_limits<float> :
-      public std::numeric_limits<float> {
-    public:
-      static float lowest() { return -FLT_MAX; }
-  };
-
-  template <> class numeric_limits<double> :
-      public std::numeric_limits<double> {
-    public:
-      static double lowest() { return -DBL_MAX; }
-  };
-
-  template <> class numeric_limits<unsigned long long> {
-   public:
-    static unsigned long long min() { return 0ULL; }
-    static unsigned long long max() { return ~0ULL; }
-    static unsigned long long lowest() {
-      return numeric_limits<unsigned long long>::min();
-    }
-  };
-
-  template <> class numeric_limits<long long> {
-   public:
-    static long long min() {
-      return static_cast<long long>(1ULL << ((sizeof(long long) << 3) - 1));
-    }
-    static long long max() {
-      return static_cast<long long>(
-          (1ULL << ((sizeof(long long) << 3) - 1)) - 1);
-    }
-    static long long lowest() {
-      return numeric_limits<long long>::min();
-    }
-  };
-#endif  // FLATBUFFERS_CPP98_STL
+    public std::numeric_limits<T> {};
+#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
 
 #if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-  #ifndef FLATBUFFERS_CPP98_STL
-    template <typename T> using is_scalar = std::is_scalar<T>;
-    template <typename T, typename U> using is_same = std::is_same<T,U>;
-    template <typename T> using is_floating_point = std::is_floating_point<T>;
-    template <typename T> using is_unsigned = std::is_unsigned<T>;
-    template <typename T> using is_enum = std::is_enum<T>;
-    template <typename T> using make_unsigned = std::make_unsigned<T>;
-    template<bool B, class T, class F>
-    using conditional = std::conditional<B, T, F>;
-    template<class T, T v>
-    using integral_constant = std::integral_constant<T, v>;
-  #else
-    // Map C++ TR1 templates defined by stlport.
-    template <typename T> using is_scalar = std::tr1::is_scalar<T>;
-    template <typename T, typename U> using is_same = std::tr1::is_same<T,U>;
-    template <typename T> using is_floating_point =
-        std::tr1::is_floating_point<T>;
-    template <typename T> using is_unsigned = std::tr1::is_unsigned<T>;
-    template <typename T> using is_enum = std::tr1::is_enum<T>;
-    // Android NDK doesn't have std::make_unsigned or std::tr1::make_unsigned.
-    template<typename T> struct make_unsigned {
-      static_assert(is_unsigned<T>::value, "Specialization not implemented!");
-      using type = T;
-    };
-    template<> struct make_unsigned<char> { using type = unsigned char; };
-    template<> struct make_unsigned<short> { using type = unsigned short; };
-    template<> struct make_unsigned<int> { using type = unsigned int; };
-    template<> struct make_unsigned<long> { using type = unsigned long; };
-    template<>
-    struct make_unsigned<long long> { using type = unsigned long long; };
-    template<bool B, class T, class F>
-    using conditional = std::tr1::conditional<B, T, F>;
-    template<class T, T v>
-    using integral_constant = std::tr1::integral_constant<T, v>;
-  #endif  // !FLATBUFFERS_CPP98_STL
+  template <typename T> using is_scalar = std::is_scalar<T>;
+  template <typename T, typename U> using is_same = std::is_same<T,U>;
+  template <typename T> using is_floating_point = std::is_floating_point<T>;
+  template <typename T> using is_unsigned = std::is_unsigned<T>;
+  template <typename T> using is_enum = std::is_enum<T>;
+  template <typename T> using make_unsigned = std::make_unsigned<T>;
+  template<bool B, class T, class F>
+  using conditional = std::conditional<B, T, F>;
+  template<class T, T v>
+  using integral_constant = std::integral_constant<T, v>;
+  template <bool B>
+  using bool_constant = integral_constant<bool, B>;
+  using true_type  = std::true_type;
+  using false_type = std::false_type;
 #else
   // MSVC 2010 doesn't support C++11 aliases.
   template <typename T> struct is_scalar : public std::is_scalar<T> {};
@@ -190,126 +109,411 @@ inline void vector_emplace_back(std::vector<T> *vector, V &&data) {
   struct conditional : public std::conditional<B, T, F> {};
   template<class T, T v>
   struct integral_constant : public std::integral_constant<T, v> {};
+  template <bool B>
+  struct bool_constant : public integral_constant<bool, B> {};
+  typedef bool_constant<true>  true_type;
+  typedef bool_constant<false> false_type;
 #endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
 
-#ifndef FLATBUFFERS_CPP98_STL
-  #if defined(FLATBUFFERS_TEMPLATES_ALIASES)
-    template <class T> using unique_ptr = std::unique_ptr<T>;
-  #else
-    // MSVC 2010 doesn't support C++11 aliases.
-    // We're manually "aliasing" the class here as we want to bring unique_ptr
-    // into the flatbuffers namespace.  We have unique_ptr in the flatbuffers
-    // namespace we have a completely independent implemenation (see below)
-    // for C++98 STL implementations.
-    template <class T> class unique_ptr : public std::unique_ptr<T> {
-     public:
-      unique_ptr() {}
-      explicit unique_ptr(T* p) : std::unique_ptr<T>(p) {}
-      unique_ptr(std::unique_ptr<T>&& u) { *this = std::move(u); }
-      unique_ptr(unique_ptr&& u) { *this = std::move(u); }
-      unique_ptr& operator=(std::unique_ptr<T>&& u) {
-        std::unique_ptr<T>::reset(u.release());
-        return *this;
-      }
-      unique_ptr& operator=(unique_ptr&& u) {
-        std::unique_ptr<T>::reset(u.release());
-        return *this;
-      }
-      unique_ptr& operator=(T* p) {
-        return std::unique_ptr<T>::operator=(p);
-      }
-    };
-  #endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
+#if defined(FLATBUFFERS_TEMPLATES_ALIASES)
+  template <class T> using unique_ptr = std::unique_ptr<T>;
 #else
-  // Very limited implementation of unique_ptr.
-  // This is provided simply to allow the C++ code generated from the default
-  // settings to function in C++98 environments with no modifications.
-  template <class T> class unique_ptr {
-   public:
-    typedef T element_type;
-
-    unique_ptr() : ptr_(nullptr) {}
-    explicit unique_ptr(T* p) : ptr_(p) {}
-    unique_ptr(unique_ptr&& u) : ptr_(nullptr) { reset(u.release()); }
-    unique_ptr(const unique_ptr& u) : ptr_(nullptr) {
-      reset(const_cast<unique_ptr*>(&u)->release());
-    }
-    ~unique_ptr() { reset(); }
-
-    unique_ptr& operator=(const unique_ptr& u) {
-      reset(const_cast<unique_ptr*>(&u)->release());
+  // MSVC 2010 doesn't support C++11 aliases.
+  // We're manually "aliasing" the class here as we want to bring unique_ptr
+  // into the flatbuffers namespace.  We have unique_ptr in the flatbuffers
+  // namespace we have a completely independent implementation (see below)
+  // for C++98 STL implementations.
+  template <class T> class unique_ptr : public std::unique_ptr<T> {
+    public:
+    unique_ptr() {}
+    explicit unique_ptr(T* p) : std::unique_ptr<T>(p) {}
+    unique_ptr(std::unique_ptr<T>&& u) { *this = std::move(u); }
+    unique_ptr(unique_ptr&& u) { *this = std::move(u); }
+    unique_ptr& operator=(std::unique_ptr<T>&& u) {
+      std::unique_ptr<T>::reset(u.release());
       return *this;
     }
-
     unique_ptr& operator=(unique_ptr&& u) {
-      reset(u.release());
+      std::unique_ptr<T>::reset(u.release());
       return *this;
     }
-
     unique_ptr& operator=(T* p) {
-      reset(p);
-      return *this;
+      return std::unique_ptr<T>::operator=(p);
     }
+  };
+#endif  // defined(FLATBUFFERS_TEMPLATES_ALIASES)
 
-    const T& operator*() const { return *ptr_; }
-    T* operator->() const { return ptr_; }
-    T* get() const noexcept { return ptr_; }
-    explicit operator bool() const { return ptr_ != nullptr; }
+#if FLATBUFFERS_USE_STD_OPTIONAL
+template<class T>
+using Optional = std::optional<T>;
+using nullopt_t = std::nullopt_t;
+inline constexpr nullopt_t nullopt = std::nullopt;
 
-    // modifiers
-    T* release() {
-      T* value = ptr_;
-      ptr_ = nullptr;
-      return value;
-    }
+#else
+// Limited implementation of Optional<T> type for a scalar T.
+// This implementation limited by trivial types compatible with
+// std::is_arithmetic<T> or std::is_enum<T> type traits.
+
+// A tag to indicate an empty flatbuffers::optional<T>.
+struct nullopt_t {
+  explicit FLATBUFFERS_CONSTEXPR_CPP11 nullopt_t(int) {}
+};
+
+#if defined(FLATBUFFERS_CONSTEXPR_DEFINED)
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static constexpr nullopt_t instance_ = nullopt_t(0);
+    };
+    template<class Dummy>
+    constexpr nullopt_t nullopt_holder<Dummy>::instance_;
+  }
+  static constexpr const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
 
-    void reset(T* p = nullptr) {
-      T* value = ptr_;
-      ptr_ = p;
-      if (value) delete value;
-    }
+#else
+  namespace internal {
+    template <class> struct nullopt_holder {
+      static const nullopt_t instance_;
+    };
+    template<class Dummy>
+    const nullopt_t nullopt_holder<Dummy>::instance_  = nullopt_t(0);
+  }
+  static const nullopt_t &nullopt = internal::nullopt_holder<void>::instance_;
 
-    void swap(unique_ptr& u) {
-      T* temp_ptr = ptr_;
-      ptr_ = u.ptr_;
-      u.ptr_ = temp_ptr;
-    }
+#endif
+
+template<class T>
+class Optional FLATBUFFERS_FINAL_CLASS {
+  // Non-scalar 'T' would extremely complicated Optional<T>.
+  // Use is_scalar<T> checking because flatbuffers flatbuffers::is_arithmetic<T>
+  // isn't implemented.
+  static_assert(flatbuffers::is_scalar<T>::value, "unexpected type T");
+
+ public:
+  ~Optional() {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional() FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(nullopt_t) FLATBUFFERS_NOEXCEPT
+    : value_(), has_value_(false) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(T val) FLATBUFFERS_NOEXCEPT
+    : value_(val), has_value_(true) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP11 Optional(const Optional &other) FLATBUFFERS_NOEXCEPT
+    : value_(other.value_), has_value_(other.has_value_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(const Optional &other) FLATBUFFERS_NOEXCEPT {
+    value_ = other.value_;
+    has_value_ = other.has_value_;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(nullopt_t) FLATBUFFERS_NOEXCEPT {
+    value_ = T();
+    has_value_ = false;
+    return *this;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP14 Optional &operator=(T val) FLATBUFFERS_NOEXCEPT {
+    value_ = val;
+    has_value_ = true;
+    return *this;
+  }
+
+  void reset() FLATBUFFERS_NOEXCEPT {
+    *this = nullopt;
+  }
+
+  void swap(Optional &other) FLATBUFFERS_NOEXCEPT {
+    std::swap(value_, other.value_);
+    std::swap(has_value_, other.has_value_);
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 FLATBUFFERS_EXPLICIT_CPP11 operator bool() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 bool has_value() const FLATBUFFERS_NOEXCEPT {
+    return has_value_;
+  }
+
+  FLATBUFFERS_CONSTEXPR_CPP11 const T& operator*() const FLATBUFFERS_NOEXCEPT {
+    return value_;
+  }
+
+  const T& value() const {
+    FLATBUFFERS_ASSERT(has_value());
+    return value_;
+  }
+
+  T value_or(T default_value) const FLATBUFFERS_NOEXCEPT {
+    return has_value() ? value_ : default_value;
+  }
+
+ private:
+  T value_;
+  bool has_value_;
+};
+
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& opt, nullopt_t) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+template<class T>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(nullopt_t, const Optional<T>& opt) FLATBUFFERS_NOEXCEPT {
+  return !opt;
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const U& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) && (*lhs == rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const T& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(rhs) && (lhs == *rhs);
+}
+
+template<class T, class U>
+FLATBUFFERS_CONSTEXPR_CPP11 bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) FLATBUFFERS_NOEXCEPT {
+  return static_cast<bool>(lhs) != static_cast<bool>(rhs)
+              ? false
+              : !static_cast<bool>(lhs) ? false : (*lhs == *rhs);
+}
+#endif // FLATBUFFERS_USE_STD_OPTIONAL
+
+
+// Very limited and naive partial implementation of C++20 std::span<T,Extent>.
+#if defined(FLATBUFFERS_USE_STD_SPAN)
+  inline constexpr std::size_t dynamic_extent = std::dynamic_extent;
+  template<class T, std::size_t Extent = std::dynamic_extent>
+  using span = std::span<T, Extent>;
+
+#else // !defined(FLATBUFFERS_USE_STD_SPAN)
+FLATBUFFERS_CONSTEXPR std::size_t dynamic_extent = static_cast<std::size_t>(-1);
+
+// Exclude this code if MSVC2010 or non-STL Android is active.
+// The non-STL Android doesn't have `std::is_convertible` required for SFINAE.
+#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+namespace internal {
+  // This is SFINAE helper class for checking of a common condition:
+  // > This overload only participates in overload resolution
+  // > Check whether a pointer to an array of From can be converted
+  // > to a pointer to an array of To.
+  // This helper is used for checking of 'From -> const From'.
+  template<class To, std::size_t Extent, class From, std::size_t N>
+  struct is_span_convertible {
+    using type =
+      typename std::conditional<std::is_convertible<From (*)[], To (*)[]>::value
+                                && (Extent == dynamic_extent || N == Extent),
+                                int, void>::type;
+  };
+
+  template<typename T>
+  struct SpanIterator {
+    // TODO: upgrade to std::random_access_iterator_tag.
+    using iterator_category = std::forward_iterator_tag;
+    using difference_type  = std::ptrdiff_t;
+    using value_type = typename std::remove_cv<T>::type;
+    using reference = T&;
+    using pointer   = T*;
+
+    // Convince MSVC compiler that this iterator is trusted (it is verified).
+    #ifdef _MSC_VER
+      using _Unchecked_type = pointer;
+    #endif // _MSC_VER
+
+    SpanIterator(pointer ptr) : ptr_(ptr) {}
+    reference operator*() const { return *ptr_; }
+    pointer operator->() { return ptr_; }
+    SpanIterator& operator++() { ptr_++; return *this; }  
+    SpanIterator  operator++(int) { auto tmp = *this; ++(*this); return tmp; }
+
+    friend bool operator== (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ == rhs.ptr_; }
+    friend bool operator!= (const SpanIterator& lhs, const SpanIterator& rhs) { return lhs.ptr_ != rhs.ptr_; }
 
    private:
-    T* ptr_;
+    pointer ptr_;
   };
+}  // namespace internal
+#endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+// T - element type; must be a complete type that is not an abstract
+// class type.
+// Extent - the number of elements in the sequence, or dynamic.
+template<class T, std::size_t Extent = dynamic_extent>
+class span FLATBUFFERS_FINAL_CLASS {
+ public:
+  typedef T element_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef T* pointer;
+  typedef const T* const_pointer;
+  typedef std::size_t size_type;
+
+  static FLATBUFFERS_CONSTEXPR size_type extent = Extent;
+
+  // Returns the number of elements in the span.
+  FLATBUFFERS_CONSTEXPR_CPP11 size_type size() const FLATBUFFERS_NOEXCEPT {
+    return count_;
+  }
+
+  // Returns the size of the sequence in bytes.
+  FLATBUFFERS_CONSTEXPR_CPP11
+  size_type size_bytes() const FLATBUFFERS_NOEXCEPT {
+    return size() * sizeof(element_type);
+  }
 
-  template <class T> bool operator==(const unique_ptr<T>& x,
-                                     const unique_ptr<T>& y) {
-    return x.get() == y.get();
+  // Checks if the span is empty.
+  FLATBUFFERS_CONSTEXPR_CPP11 bool empty() const FLATBUFFERS_NOEXCEPT {
+    return size() == 0;
   }
 
-  template <class T, class D> bool operator==(const unique_ptr<T>& x,
-                                              const D* y) {
-    return static_cast<D*>(x.get()) == y;
+  // Returns a pointer to the beginning of the sequence.
+  FLATBUFFERS_CONSTEXPR_CPP11 pointer data() const FLATBUFFERS_NOEXCEPT {
+    return data_;
   }
 
-  template <class T> bool operator==(const unique_ptr<T>& x, intptr_t y) {
-    return reinterpret_cast<intptr_t>(x.get()) == y;
+  #if !defined(FLATBUFFERS_SPAN_MINIMAL)
+    using Iterator = internal::SpanIterator<T>;
+
+    Iterator begin() const { return Iterator(data()); }
+    Iterator end() const   { return Iterator(data() + size()); }
+  #endif
+
+  // Returns a reference to the idx-th element of the sequence.
+  // The behavior is undefined if the idx is greater than or equal to size().
+  FLATBUFFERS_CONSTEXPR_CPP11 reference operator[](size_type idx) const {
+    return data()[idx];
   }
 
-  template <class T> bool operator!=(const unique_ptr<T>& x, decltype(nullptr)) {
-    return !!x;
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const span &other) FLATBUFFERS_NOEXCEPT
+      : data_(other.data_), count_(other.count_) {}
+
+  FLATBUFFERS_CONSTEXPR_CPP14 span &operator=(const span &other)
+      FLATBUFFERS_NOEXCEPT {
+    data_ = other.data_;
+    count_ = other.count_;
   }
 
-  template <class T> bool operator!=(decltype(nullptr), const unique_ptr<T>& x) {
-    return !!x;
+  // Limited implementation of
+  // `template <class It> constexpr std::span(It first, size_type count);`.
+  //
+  // Constructs a span that is a view over the range [first, first + count);
+  // the resulting span has: data() == first and size() == count.
+  // The behavior is undefined if [first, first + count) is not a valid range,
+  // or if (extent != flatbuffers::dynamic_extent && count != extent).
+  FLATBUFFERS_CONSTEXPR_CPP11
+  explicit span(pointer first, size_type count) FLATBUFFERS_NOEXCEPT
+    : data_ (Extent == dynamic_extent ? first : (Extent == count ? first : nullptr)),
+      count_(Extent == dynamic_extent ? count : (Extent == count ? Extent : 0)) {
+      // Make span empty if the count argument is incompatible with span<T,N>.
   }
 
-  template <class T> bool operator==(const unique_ptr<T>& x, decltype(nullptr)) {
-    return !x;
+  // Exclude this code if MSVC2010 is active. The MSVC2010 isn't C++11
+  // compliant, it doesn't support default template arguments for functions.
+  #if defined(FLATBUFFERS_SPAN_MINIMAL)
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
   }
 
-  template <class T> bool operator==(decltype(nullptr), const unique_ptr<T>& x) {
-    return !x;
+  #else
+  // Constructs an empty span whose data() == nullptr and size() == 0.
+  // This overload only participates in overload resolution if
+  // extent == 0 || extent == flatbuffers::dynamic_extent.
+  // A dummy template argument N is need dependency for SFINAE.
+  template<std::size_t N = 0,
+    typename internal::is_span_convertible<element_type, Extent, element_type, (N - N)>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span() FLATBUFFERS_NOEXCEPT : data_(nullptr),
+                                                            count_(0) {
+    static_assert(extent == 0 || extent == dynamic_extent, "invalid span");
   }
 
-#endif  // !FLATBUFFERS_CPP98_STL
+  // Constructs a span that is a view over the array arr; the resulting span
+  // has size() == N and data() == std::data(arr). These overloads only
+  // participate in overload resolution if
+  // extent == std::dynamic_extent || N == extent is true and
+  // std::remove_pointer_t<decltype(std::data(arr))>(*)[]
+  // is convertible to element_type (*)[].
+  template<std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, element_type, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(element_type (&arr)[N]) FLATBUFFERS_NOEXCEPT
+      : data_(arr), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+     : data_(arr.data()), count_(N) {}
+
+  //template<class U, std::size_t N,
+  //  int = 0>
+  //FLATBUFFERS_CONSTEXPR_CPP11 span(std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+  //   : data_(arr.data()), count_(N) {}
+
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const std::array<U, N> &arr) FLATBUFFERS_NOEXCEPT
+    : data_(arr.data()), count_(N) {}
+
+  // Converting constructor from another span s;
+  // the resulting span has size() == s.size() and data() == s.data().
+  // This overload only participates in overload resolution
+  // if extent == std::dynamic_extent || N == extent is true and U (*)[]
+  // is convertible to element_type (*)[].
+  template<class U, std::size_t N,
+    typename internal::is_span_convertible<element_type, Extent, U, N>::type = 0>
+  FLATBUFFERS_CONSTEXPR_CPP11 span(const flatbuffers::span<U, N> &s) FLATBUFFERS_NOEXCEPT
+      : span(s.data(), s.size()) {
+  }
+
+  #endif  // !defined(FLATBUFFERS_SPAN_MINIMAL)
+
+ private:
+  // This is a naive implementation with 'count_' member even if (Extent != dynamic_extent).
+  pointer const data_;
+  size_type count_;
+};
+#endif  // defined(FLATBUFFERS_USE_STD_SPAN)
+
+#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, Extent> make_span(const ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, Extent> make_span(std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, Extent> make_span(const std::array<ElementType, Extent> &arr) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, Extent>(arr);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<ElementType, dynamic_extent> make_span(ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+  return span<ElementType, dynamic_extent>(first, count);
+}
+
+template<class ElementType, std::size_t Extent>
+FLATBUFFERS_CONSTEXPR_CPP11
+flatbuffers::span<const ElementType, dynamic_extent> make_span(const ElementType *first, std::size_t count) FLATBUFFERS_NOEXCEPT {
+  return span<const ElementType, dynamic_extent>(first, count);
+}
+#endif // !defined(FLATBUFFERS_SPAN_MINIMAL)
 
 }  // namespace flatbuffers
 }  // namespace arrow_vendored_private
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
new file mode 100644
index 0000000000000..1cdba458878d9
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/string.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_STRING_H_
+#define FLATBUFFERS_STRING_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+struct String : public Vector<char> {
+  const char *c_str() const { return reinterpret_cast<const char *>(Data()); }
+  std::string str() const { return std::string(c_str(), size()); }
+
+  // clang-format off
+  #ifdef FLATBUFFERS_HAS_STRING_VIEW
+  flatbuffers::string_view string_view() const {
+    return flatbuffers::string_view(c_str(), size());
+  }
+  #endif // FLATBUFFERS_HAS_STRING_VIEW
+  // clang-format on
+
+  bool operator<(const String &o) const {
+    return StringLessThan(this->data(), this->size(), o.data(), o.size());
+  }
+};
+
+// Convenience function to get std::string from a String returning an empty
+// string on null pointer.
+static inline std::string GetString(const String *str) {
+  return str ? str->str() : "";
+}
+
+// Convenience function to get char* from a String returning an empty string on
+// null pointer.
+static inline const char *GetCstring(const String *str) {
+  return str ? str->c_str() : "";
+}
+
+#ifdef FLATBUFFERS_HAS_STRING_VIEW
+// Convenience function to get string_view from a String returning an empty
+// string_view on null pointer.
+static inline flatbuffers::string_view GetStringView(const String *str) {
+  return str ? str->string_view() : flatbuffers::string_view();
+}
+#endif  // FLATBUFFERS_HAS_STRING_VIEW
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_STRING_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
new file mode 100644
index 0000000000000..92a8e80bf7d91
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/struct.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_STRUCT_H_
+#define FLATBUFFERS_STRUCT_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+// "structs" are flat structures that do not have an offset table, thus
+// always have all members present and do not support forwards/backwards
+// compatible extensions.
+
+class Struct FLATBUFFERS_FINAL_CLASS {
+ public:
+  template<typename T> T GetField(uoffset_t o) const {
+    return ReadScalar<T>(&data_[o]);
+  }
+
+  template<typename T> T GetStruct(uoffset_t o) const {
+    return reinterpret_cast<T>(&data_[o]);
+  }
+
+  const uint8_t *GetAddressOf(uoffset_t o) const { return &data_[o]; }
+  uint8_t *GetAddressOf(uoffset_t o) { return &data_[o]; }
+
+ private:
+  // private constructor & copy constructor: you obtain instances of this
+  // class by pointing to existing data only
+  Struct();
+  Struct(const Struct &);
+  Struct &operator=(const Struct &);
+
+  uint8_t data_[1];
+};
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_STRUCT_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
new file mode 100644
index 0000000000000..762563daf9eee
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/table.h
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_TABLE_H_
+#define FLATBUFFERS_TABLE_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/verifier.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+// "tables" use an offset table (possibly shared) that allows fields to be
+// omitted and added at will, but uses an extra indirection to read.
+class Table {
+ public:
+  const uint8_t *GetVTable() const {
+    return data_ - ReadScalar<soffset_t>(data_);
+  }
+
+  // This gets the field offset for any of the functions below it, or 0
+  // if the field was not present.
+  voffset_t GetOptionalFieldOffset(voffset_t field) const {
+    // The vtable offset is always at the start.
+    auto vtable = GetVTable();
+    // The first element is the size of the vtable (fields + type id + itself).
+    auto vtsize = ReadScalar<voffset_t>(vtable);
+    // If the field we're accessing is outside the vtable, we're reading older
+    // data, so it's the same as if the offset was 0 (not present).
+    return field < vtsize ? ReadScalar<voffset_t>(vtable + field) : 0;
+  }
+
+  template<typename T> T GetField(voffset_t field, T defaultval) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset ? ReadScalar<T>(data_ + field_offset) : defaultval;
+  }
+
+  template<typename P, typename OffsetSize = uoffset_t>
+  P GetPointer(voffset_t field) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = data_ + field_offset;
+    return field_offset ? reinterpret_cast<P>(p + ReadScalar<OffsetSize>(p))
+                        : nullptr;
+  }
+  template<typename P, typename OffsetSize = uoffset_t>
+  P GetPointer(voffset_t field) const {
+    return const_cast<Table *>(this)->GetPointer<P, OffsetSize>(field);
+  }
+
+  template<typename P> P GetPointer64(voffset_t field) {
+    return GetPointer<P, uoffset64_t>(field);
+  }
+
+  template<typename P> P GetPointer64(voffset_t field) const {
+    return GetPointer<P, uoffset64_t>(field);
+  }
+
+  template<typename P> P GetStruct(voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = const_cast<uint8_t *>(data_ + field_offset);
+    return field_offset ? reinterpret_cast<P>(p) : nullptr;
+  }
+
+  template<typename Raw, typename Face>
+  flatbuffers::Optional<Face> GetOptional(voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    auto p = data_ + field_offset;
+    return field_offset ? Optional<Face>(static_cast<Face>(ReadScalar<Raw>(p)))
+                        : Optional<Face>();
+  }
+
+  template<typename T> bool SetField(voffset_t field, T val, T def) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return IsTheSameAs(val, def);
+    WriteScalar(data_ + field_offset, val);
+    return true;
+  }
+  template<typename T> bool SetField(voffset_t field, T val) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return false;
+    WriteScalar(data_ + field_offset, val);
+    return true;
+  }
+
+  bool SetPointer(voffset_t field, const uint8_t *val) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    if (!field_offset) return false;
+    WriteScalar(data_ + field_offset,
+                static_cast<uoffset_t>(val - (data_ + field_offset)));
+    return true;
+  }
+
+  uint8_t *GetAddressOf(voffset_t field) {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return field_offset ? data_ + field_offset : nullptr;
+  }
+  const uint8_t *GetAddressOf(voffset_t field) const {
+    return const_cast<Table *>(this)->GetAddressOf(field);
+  }
+
+  bool CheckField(voffset_t field) const {
+    return GetOptionalFieldOffset(field) != 0;
+  }
+
+  // Verify the vtable of this table.
+  // Call this once per table, followed by VerifyField once per field.
+  bool VerifyTableStart(Verifier &verifier) const {
+    return verifier.VerifyTableStart(data_);
+  }
+
+  // Verify a particular field.
+  template<typename T>
+  bool VerifyField(const Verifier &verifier, voffset_t field,
+                   size_t align) const {
+    // Calling GetOptionalFieldOffset should be safe now thanks to
+    // VerifyTable().
+    auto field_offset = GetOptionalFieldOffset(field);
+    // Check the actual field.
+    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
+  }
+
+  // VerifyField for required fields.
+  template<typename T>
+  bool VerifyFieldRequired(const Verifier &verifier, voffset_t field,
+                           size_t align) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return verifier.Check(field_offset != 0) &&
+           verifier.VerifyField<T>(data_, field_offset, align);
+  }
+
+  // Versions for offsets.
+  template<typename OffsetT = uoffset_t>
+  bool VerifyOffset(const Verifier &verifier, voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return !field_offset || verifier.VerifyOffset<OffsetT>(data_, field_offset);
+  }
+
+  template<typename OffsetT = uoffset_t>
+  bool VerifyOffsetRequired(const Verifier &verifier, voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return verifier.Check(field_offset != 0) &&
+           verifier.VerifyOffset<OffsetT>(data_, field_offset);
+  }
+
+  bool VerifyOffset64(const Verifier &verifier, voffset_t field) const {
+    return VerifyOffset<uoffset64_t>(verifier, field);
+  }
+
+  bool VerifyOffset64Required(const Verifier &verifier, voffset_t field) const {
+    return VerifyOffsetRequired<uoffset64_t>(verifier, field);
+  }
+
+ private:
+  // private constructor & copy constructor: you obtain instances of this
+  // class by pointing to existing data only
+  Table();
+  Table(const Table &other);
+  Table &operator=(const Table &);
+
+  uint8_t data_[1];
+};
+
+// This specialization allows avoiding warnings like:
+// MSVC C4800: type: forcing value to bool 'true' or 'false'.
+template<>
+inline flatbuffers::Optional<bool> Table::GetOptional<uint8_t, bool>(
+    voffset_t field) const {
+  auto field_offset = GetOptionalFieldOffset(field);
+  auto p = data_ + field_offset;
+  return field_offset ? Optional<bool>(ReadScalar<uint8_t>(p) != 0)
+                      : Optional<bool>();
+}
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_TABLE_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
new file mode 100644
index 0000000000000..94591859a54ca
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector.h
@@ -0,0 +1,405 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_VECTOR_H_
+#define FLATBUFFERS_VECTOR_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/stl_emulation.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+struct String;
+
+// An STL compatible iterator implementation for Vector below, effectively
+// calling Get() for every element.
+template<typename T, typename IT, typename Data = uint8_t *,
+         typename SizeT = uoffset_t>
+struct VectorIterator {
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef IT value_type;
+  typedef ptrdiff_t difference_type;
+  typedef IT *pointer;
+  typedef IT &reference;
+
+  static const SizeT element_stride = IndirectHelper<T>::element_stride;
+
+  VectorIterator(Data data, SizeT i) : data_(data + element_stride * i) {}
+  VectorIterator(const VectorIterator &other) : data_(other.data_) {}
+  VectorIterator() : data_(nullptr) {}
+
+  VectorIterator &operator=(const VectorIterator &other) {
+    data_ = other.data_;
+    return *this;
+  }
+
+  VectorIterator &operator=(VectorIterator &&other) {
+    data_ = other.data_;
+    return *this;
+  }
+
+  bool operator==(const VectorIterator &other) const {
+    return data_ == other.data_;
+  }
+
+  bool operator<(const VectorIterator &other) const {
+    return data_ < other.data_;
+  }
+
+  bool operator!=(const VectorIterator &other) const {
+    return data_ != other.data_;
+  }
+
+  difference_type operator-(const VectorIterator &other) const {
+    return (data_ - other.data_) / element_stride;
+  }
+
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
+  IT operator*() const { return IndirectHelper<T>::Read(data_, 0); }
+
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
+  IT operator->() const { return IndirectHelper<T>::Read(data_, 0); }
+
+  VectorIterator &operator++() {
+    data_ += element_stride;
+    return *this;
+  }
+
+  VectorIterator operator++(int) {
+    VectorIterator temp(data_, 0);
+    data_ += element_stride;
+    return temp;
+  }
+
+  VectorIterator operator+(const SizeT &offset) const {
+    return VectorIterator(data_ + offset * element_stride, 0);
+  }
+
+  VectorIterator &operator+=(const SizeT &offset) {
+    data_ += offset * element_stride;
+    return *this;
+  }
+
+  VectorIterator &operator--() {
+    data_ -= element_stride;
+    return *this;
+  }
+
+  VectorIterator operator--(int) {
+    VectorIterator temp(data_, 0);
+    data_ -= element_stride;
+    return temp;
+  }
+
+  VectorIterator operator-(const SizeT &offset) const {
+    return VectorIterator(data_ - offset * element_stride, 0);
+  }
+
+  VectorIterator &operator-=(const SizeT &offset) {
+    data_ -= offset * element_stride;
+    return *this;
+  }
+
+ private:
+  Data data_;
+};
+
+template<typename T, typename IT, typename SizeT = uoffset_t>
+using VectorConstIterator = VectorIterator<T, IT, const uint8_t *, SizeT>;
+
+template<typename Iterator>
+struct VectorReverseIterator : public std::reverse_iterator<Iterator> {
+  explicit VectorReverseIterator(Iterator iter)
+      : std::reverse_iterator<Iterator>(iter) {}
+
+  // Note: return type is incompatible with the standard
+  // `reference operator*()`.
+  typename Iterator::value_type operator*() const {
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
+  }
+
+  // Note: return type is incompatible with the standard
+  // `pointer operator->()`.
+  typename Iterator::value_type operator->() const {
+    auto tmp = std::reverse_iterator<Iterator>::current;
+    return *--tmp;
+  }
+};
+
+// This is used as a helper type for accessing vectors.
+// Vector::data() assumes the vector elements start after the length field.
+template<typename T, typename SizeT = uoffset_t> class Vector {
+ public:
+  typedef VectorIterator<T, typename IndirectHelper<T>::mutable_return_type,
+                         uint8_t *, SizeT>
+      iterator;
+  typedef VectorConstIterator<T, typename IndirectHelper<T>::return_type, SizeT>
+      const_iterator;
+  typedef VectorReverseIterator<iterator> reverse_iterator;
+  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
+
+  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
+      scalar_tag;
+
+  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
+      scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1);
+
+  SizeT size() const { return EndianScalar(length_); }
+
+  // Deprecated: use size(). Here for backwards compatibility.
+  FLATBUFFERS_ATTRIBUTE([[deprecated("use size() instead")]])
+  SizeT Length() const { return size(); }
+
+  typedef SizeT size_type;
+  typedef typename IndirectHelper<T>::return_type return_type;
+  typedef typename IndirectHelper<T>::mutable_return_type mutable_return_type;
+  typedef return_type value_type;
+
+  return_type Get(SizeT i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return IndirectHelper<T>::Read(Data(), i);
+  }
+
+  return_type operator[](SizeT i) const { return Get(i); }
+
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template<typename E> E GetEnum(SizeT i) const {
+    return static_cast<E>(Get(i));
+  }
+
+  // If this a vector of unions, this does the cast for you. There's no check
+  // to make sure this is the right type!
+  template<typename U> const U *GetAs(SizeT i) const {
+    return reinterpret_cast<const U *>(Get(i));
+  }
+
+  // If this a vector of unions, this does the cast for you. There's no check
+  // to make sure this is actually a string!
+  const String *GetAsString(SizeT i) const {
+    return reinterpret_cast<const String *>(Get(i));
+  }
+
+  const void *GetStructFromOffset(size_t o) const {
+    return reinterpret_cast<const void *>(Data() + o);
+  }
+
+  iterator begin() { return iterator(Data(), 0); }
+  const_iterator begin() const { return const_iterator(Data(), 0); }
+
+  iterator end() { return iterator(Data(), size()); }
+  const_iterator end() const { return const_iterator(Data(), size()); }
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  const_iterator cbegin() const { return begin(); }
+
+  const_iterator cend() const { return end(); }
+
+  const_reverse_iterator crbegin() const { return rbegin(); }
+
+  const_reverse_iterator crend() const { return rend(); }
+
+  // Change elements if you have a non-const pointer to this object.
+  // Scalars only. See reflection.h, and the documentation.
+  void Mutate(SizeT i, const T &val) {
+    FLATBUFFERS_ASSERT(i < size());
+    WriteScalar(data() + i, val);
+  }
+
+  // Change an element of a vector of tables (or strings).
+  // "val" points to the new table/string, as you can obtain from
+  // e.g. reflection::AddFlatBuffer().
+  void MutateOffset(SizeT i, const uint8_t *val) {
+    FLATBUFFERS_ASSERT(i < size());
+    static_assert(sizeof(T) == sizeof(SizeT), "Unrelated types");
+    WriteScalar(data() + i,
+                static_cast<SizeT>(val - (Data() + i * sizeof(SizeT))));
+  }
+
+  // Get a mutable pointer to tables/strings inside this vector.
+  mutable_return_type GetMutableObject(SizeT i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return const_cast<mutable_return_type>(IndirectHelper<T>::Read(Data(), i));
+  }
+
+  // The raw data in little endian format. Use with care.
+  const uint8_t *Data() const {
+    return reinterpret_cast<const uint8_t *>(&length_ + 1);
+  }
+
+  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
+
+  // Similarly, but typed, much like std::vector::data
+  const T *data() const { return reinterpret_cast<const T *>(Data()); }
+  T *data() { return reinterpret_cast<T *>(Data()); }
+
+  template<typename K> return_type LookupByKey(K key) const {
+    void *search_result = std::bsearch(
+        &key, Data(), size(), IndirectHelper<T>::element_stride, KeyCompare<K>);
+
+    if (!search_result) {
+      return nullptr;  // Key not found.
+    }
+
+    const uint8_t *element = reinterpret_cast<const uint8_t *>(search_result);
+
+    return IndirectHelper<T>::Read(element, 0);
+  }
+
+  template<typename K> mutable_return_type MutableLookupByKey(K key) {
+    return const_cast<mutable_return_type>(LookupByKey(key));
+  }
+
+ protected:
+  // This class is only used to access pre-existing data. Don't ever
+  // try to construct these manually.
+  Vector();
+
+  SizeT length_;
+
+ private:
+  // This class is a pointer. Copying will therefore create an invalid object.
+  // Private and unimplemented copy constructor.
+  Vector(const Vector &);
+  Vector &operator=(const Vector &);
+
+  template<typename K> static int KeyCompare(const void *ap, const void *bp) {
+    const K *key = reinterpret_cast<const K *>(ap);
+    const uint8_t *data = reinterpret_cast<const uint8_t *>(bp);
+    auto table = IndirectHelper<T>::Read(data, 0);
+
+    // std::bsearch compares with the operands transposed, so we negate the
+    // result here.
+    return -table->KeyCompareWithValue(*key);
+  }
+};
+
+template<typename T> using Vector64 = Vector<T, uoffset64_t>;
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U> &vec)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<U>(vec.data(), vec.size());
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+    const Vector<U> &vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<const U>(vec.data(), vec.size());
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t> make_bytes_span(
+    Vector<U> &vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::scalar_tag::value,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<uint8_t>(vec.Data(), vec.size() * sizeof(U));
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t> make_bytes_span(
+    const Vector<U> &vec) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::scalar_tag::value,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return span<const uint8_t>(vec.Data(), vec.size() * sizeof(U));
+}
+
+// Convenient helper functions to get a span of any vector, regardless
+// of whether it is null or not (the field is not set).
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U> make_span(Vector<U> *ptr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<U>();
+}
+
+template<class U>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U> make_span(
+    const Vector<U> *ptr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Vector<U>::is_span_observable,
+                "wrong type U, only LE-scalar, or byte types are allowed");
+  return ptr ? make_span(*ptr) : span<const U>();
+}
+
+// Represent a vector much like the template above, but in this case we
+// don't know what the element types are (used with reflection.h).
+class VectorOfAny {
+ public:
+  uoffset_t size() const { return EndianScalar(length_); }
+
+  const uint8_t *Data() const {
+    return reinterpret_cast<const uint8_t *>(&length_ + 1);
+  }
+  uint8_t *Data() { return reinterpret_cast<uint8_t *>(&length_ + 1); }
+
+ protected:
+  VectorOfAny();
+
+  uoffset_t length_;
+
+ private:
+  VectorOfAny(const VectorOfAny &);
+  VectorOfAny &operator=(const VectorOfAny &);
+};
+
+template<typename T, typename U>
+Vector<Offset<T>> *VectorCast(Vector<Offset<U>> *ptr) {
+  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
+  return reinterpret_cast<Vector<Offset<T>> *>(ptr);
+}
+
+template<typename T, typename U>
+const Vector<Offset<T>> *VectorCast(const Vector<Offset<U>> *ptr) {
+  static_assert(std::is_base_of<T, U>::value, "Unrelated types");
+  return reinterpret_cast<const Vector<Offset<T>> *>(ptr);
+}
+
+// Convenient helper function to get the length of any vector, regardless
+// of whether it is null or not (the field is not set).
+template<typename T> static inline size_t VectorLength(const Vector<T> *v) {
+  return v ? v->size() : 0;
+}
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_VERIFIER_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
new file mode 100644
index 0000000000000..a87b17b663285
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/vector_downward.h
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_VECTOR_DOWNWARD_H_
+#define FLATBUFFERS_VECTOR_DOWNWARD_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include <algorithm>
+#include <cstdint>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/default_allocator.h"
+#include "flatbuffers/detached_buffer.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+// This is a minimal replication of std::vector<uint8_t> functionality,
+// except growing from higher to lower addresses. i.e. push_back() inserts data
+// in the lowest address in the vector.
+// Since this vector leaves the lower part unused, we support a "scratch-pad"
+// that can be stored there for temporary data, to share the allocated space.
+// Essentially, this supports 2 std::vectors in a single buffer.
+template<typename SizeT = uoffset_t> class vector_downward {
+ public:
+  explicit vector_downward(size_t initial_size, Allocator *allocator,
+                           bool own_allocator, size_t buffer_minalign,
+                           const SizeT max_size = FLATBUFFERS_MAX_BUFFER_SIZE)
+      : allocator_(allocator),
+        own_allocator_(own_allocator),
+        initial_size_(initial_size),
+        max_size_(max_size),
+        buffer_minalign_(buffer_minalign),
+        reserved_(0),
+        size_(0),
+        buf_(nullptr),
+        cur_(nullptr),
+        scratch_(nullptr) {}
+
+  vector_downward(vector_downward &&other) noexcept
+      // clang-format on
+      : allocator_(other.allocator_),
+        own_allocator_(other.own_allocator_),
+        initial_size_(other.initial_size_),
+        max_size_(other.max_size_),
+        buffer_minalign_(other.buffer_minalign_),
+        reserved_(other.reserved_),
+        size_(other.size_),
+        buf_(other.buf_),
+        cur_(other.cur_),
+        scratch_(other.scratch_) {
+    // No change in other.allocator_
+    // No change in other.initial_size_
+    // No change in other.buffer_minalign_
+    other.own_allocator_ = false;
+    other.reserved_ = 0;
+    other.buf_ = nullptr;
+    other.cur_ = nullptr;
+    other.scratch_ = nullptr;
+  }
+
+  vector_downward &operator=(vector_downward &&other) noexcept {
+    // Move construct a temporary and swap idiom
+    vector_downward temp(std::move(other));
+    swap(temp);
+    return *this;
+  }
+
+  ~vector_downward() {
+    clear_buffer();
+    clear_allocator();
+  }
+
+  void reset() {
+    clear_buffer();
+    clear();
+  }
+
+  void clear() {
+    if (buf_) {
+      cur_ = buf_ + reserved_;
+    } else {
+      reserved_ = 0;
+      cur_ = nullptr;
+    }
+    size_ = 0;
+    clear_scratch();
+  }
+
+  void clear_scratch() { scratch_ = buf_; }
+
+  void clear_allocator() {
+    if (own_allocator_ && allocator_) { delete allocator_; }
+    allocator_ = nullptr;
+    own_allocator_ = false;
+  }
+
+  void clear_buffer() {
+    if (buf_) Deallocate(allocator_, buf_, reserved_);
+    buf_ = nullptr;
+  }
+
+  // Relinquish the pointer to the caller.
+  uint8_t *release_raw(size_t &allocated_bytes, size_t &offset) {
+    auto *buf = buf_;
+    allocated_bytes = reserved_;
+    offset = vector_downward::offset();
+
+    // release_raw only relinquishes the buffer ownership.
+    // Does not deallocate or reset the allocator. Destructor will do that.
+    buf_ = nullptr;
+    clear();
+    return buf;
+  }
+
+  // Relinquish the pointer to the caller.
+  DetachedBuffer release() {
+    // allocator ownership (if any) is transferred to DetachedBuffer.
+    DetachedBuffer fb(allocator_, own_allocator_, buf_, reserved_, cur_,
+                      size());
+    if (own_allocator_) {
+      allocator_ = nullptr;
+      own_allocator_ = false;
+    }
+    buf_ = nullptr;
+    clear();
+    return fb;
+  }
+
+  size_t ensure_space(size_t len) {
+    FLATBUFFERS_ASSERT(cur_ >= scratch_ && scratch_ >= buf_);
+    // If the length is larger than the unused part of the buffer, we need to
+    // grow.
+    if (len > unused_buffer_size()) { reallocate(len); }
+    FLATBUFFERS_ASSERT(size() < max_size_);
+    return len;
+  }
+
+  inline uint8_t *make_space(size_t len) {
+    if (len) {
+      ensure_space(len);
+      cur_ -= len;
+      size_ += static_cast<SizeT>(len);
+    }
+    return cur_;
+  }
+
+  // Returns nullptr if using the DefaultAllocator.
+  Allocator *get_custom_allocator() { return allocator_; }
+
+  // The current offset into the buffer.
+  size_t offset() const { return cur_ - buf_; }
+
+  // The total size of the vector (both the buffer and scratch parts).
+  inline SizeT size() const { return size_; }
+
+  // The size of the buffer part of the vector that is currently unused.
+  SizeT unused_buffer_size() const {
+    return static_cast<SizeT>(cur_ - scratch_);
+  }
+
+  // The size of the scratch part of the vector.
+  SizeT scratch_size() const { return static_cast<SizeT>(scratch_ - buf_); }
+
+  size_t capacity() const { return reserved_; }
+
+  uint8_t *data() const {
+    FLATBUFFERS_ASSERT(cur_);
+    return cur_;
+  }
+
+  uint8_t *scratch_data() const {
+    FLATBUFFERS_ASSERT(buf_);
+    return buf_;
+  }
+
+  uint8_t *scratch_end() const {
+    FLATBUFFERS_ASSERT(scratch_);
+    return scratch_;
+  }
+
+  uint8_t *data_at(size_t offset) const { return buf_ + reserved_ - offset; }
+
+  void push(const uint8_t *bytes, size_t num) {
+    if (num > 0) { memcpy(make_space(num), bytes, num); }
+  }
+
+  // Specialized version of push() that avoids memcpy call for small data.
+  template<typename T> void push_small(const T &little_endian_t) {
+    make_space(sizeof(T));
+    *reinterpret_cast<T *>(cur_) = little_endian_t;
+  }
+
+  template<typename T> void scratch_push_small(const T &t) {
+    ensure_space(sizeof(T));
+    *reinterpret_cast<T *>(scratch_) = t;
+    scratch_ += sizeof(T);
+  }
+
+  // fill() is most frequently called with small byte counts (<= 4),
+  // which is why we're using loops rather than calling memset.
+  void fill(size_t zero_pad_bytes) {
+    make_space(zero_pad_bytes);
+    for (size_t i = 0; i < zero_pad_bytes; i++) cur_[i] = 0;
+  }
+
+  // Version for when we know the size is larger.
+  // Precondition: zero_pad_bytes > 0
+  void fill_big(size_t zero_pad_bytes) {
+    memset(make_space(zero_pad_bytes), 0, zero_pad_bytes);
+  }
+
+  void pop(size_t bytes_to_remove) {
+    cur_ += bytes_to_remove;
+    size_ -= static_cast<SizeT>(bytes_to_remove);
+  }
+
+  void scratch_pop(size_t bytes_to_remove) { scratch_ -= bytes_to_remove; }
+
+  void swap(vector_downward &other) {
+    using std::swap;
+    swap(allocator_, other.allocator_);
+    swap(own_allocator_, other.own_allocator_);
+    swap(initial_size_, other.initial_size_);
+    swap(buffer_minalign_, other.buffer_minalign_);
+    swap(reserved_, other.reserved_);
+    swap(size_, other.size_);
+    swap(max_size_, other.max_size_);
+    swap(buf_, other.buf_);
+    swap(cur_, other.cur_);
+    swap(scratch_, other.scratch_);
+  }
+
+  void swap_allocator(vector_downward &other) {
+    using std::swap;
+    swap(allocator_, other.allocator_);
+    swap(own_allocator_, other.own_allocator_);
+  }
+
+ private:
+  // You shouldn't really be copying instances of this class.
+  FLATBUFFERS_DELETE_FUNC(vector_downward(const vector_downward &));
+  FLATBUFFERS_DELETE_FUNC(vector_downward &operator=(const vector_downward &));
+
+  Allocator *allocator_;
+  bool own_allocator_;
+  size_t initial_size_;
+
+  // The maximum size the vector can be.
+  SizeT max_size_;
+  size_t buffer_minalign_;
+  size_t reserved_;
+  SizeT size_;
+  uint8_t *buf_;
+  uint8_t *cur_;  // Points at location between empty (below) and used (above).
+  uint8_t *scratch_;  // Points to the end of the scratchpad in use.
+
+  void reallocate(size_t len) {
+    auto old_reserved = reserved_;
+    auto old_size = size();
+    auto old_scratch_size = scratch_size();
+    reserved_ +=
+        (std::max)(len, old_reserved ? old_reserved / 2 : initial_size_);
+    reserved_ = (reserved_ + buffer_minalign_ - 1) & ~(buffer_minalign_ - 1);
+    if (buf_) {
+      buf_ = ReallocateDownward(allocator_, buf_, old_reserved, reserved_,
+                                old_size, old_scratch_size);
+    } else {
+      buf_ = Allocate(allocator_, reserved_);
+    }
+    cur_ = buf_ + reserved_ - old_size;
+    scratch_ = buf_ + old_scratch_size;
+  }
+};
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_VECTOR_DOWNWARD_H_
diff --git a/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h b/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h
new file mode 100644
index 0000000000000..f6f5ac7f294f2
--- /dev/null
+++ b/cpp/thirdparty/flatbuffers/include/flatbuffers/verifier.h
@@ -0,0 +1,340 @@
+/*
+ * Copyright 2021 Google Inc. 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.
+ */
+
+#ifndef FLATBUFFERS_VERIFIER_H_
+#define FLATBUFFERS_VERIFIER_H_
+
+// Move this vendored copy of flatbuffers to a private namespace,
+// but continue to access it through the "flatbuffers" alias.
+namespace arrow_vendored_private::flatbuffers {
+}
+namespace flatbuffers = arrow_vendored_private::flatbuffers;
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/vector.h"
+
+namespace arrow_vendored_private {
+namespace flatbuffers {
+
+// Helper class to verify the integrity of a FlatBuffer
+class Verifier FLATBUFFERS_FINAL_CLASS {
+ public:
+  struct Options {
+    // The maximum nesting of tables and vectors before we call it invalid.
+    uoffset_t max_depth = 64;
+    // The maximum number of tables we will verify before we call it invalid.
+    uoffset_t max_tables = 1000000;
+    // If true, verify all data is aligned.
+    bool check_alignment = true;
+    // If true, run verifier on nested flatbuffers
+    bool check_nested_flatbuffers = true;
+    // The maximum size of a buffer.
+    size_t max_size = FLATBUFFERS_MAX_BUFFER_SIZE;
+    // Use assertions to check for errors.
+    bool assert = false;
+  };
+
+  explicit Verifier(const uint8_t *const buf, const size_t buf_len,
+                    const Options &opts)
+      : buf_(buf), size_(buf_len), opts_(opts) {
+    FLATBUFFERS_ASSERT(size_ < opts.max_size);
+  }
+
+  // Deprecated API, please construct with Verifier::Options.
+  Verifier(const uint8_t *const buf, const size_t buf_len,
+           const uoffset_t max_depth = 64, const uoffset_t max_tables = 1000000,
+           const bool check_alignment = true)
+      : Verifier(buf, buf_len, [&] {
+          Options opts;
+          opts.max_depth = max_depth;
+          opts.max_tables = max_tables;
+          opts.check_alignment = check_alignment;
+          return opts;
+        }()) {}
+
+  // Central location where any verification failures register.
+  bool Check(const bool ok) const {
+    // clang-format off
+    #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
+       if (opts_.assert) { FLATBUFFERS_ASSERT(ok); }
+    #endif
+    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
+      if (!ok)
+        upper_bound_ = 0;
+    #endif
+    // clang-format on
+    return ok;
+  }
+
+  // Verify any range within the buffer.
+  bool Verify(const size_t elem, const size_t elem_len) const {
+    // clang-format off
+    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
+      auto upper_bound = elem + elem_len;
+      if (upper_bound_ < upper_bound)
+        upper_bound_ =  upper_bound;
+    #endif
+    // clang-format on
+    return Check(elem_len < size_ && elem <= size_ - elem_len);
+  }
+
+  bool VerifyAlignment(const size_t elem, const size_t align) const {
+    return Check((elem & (align - 1)) == 0 || !opts_.check_alignment);
+  }
+
+  // Verify a range indicated by sizeof(T).
+  template<typename T> bool Verify(const size_t elem) const {
+    return VerifyAlignment(elem, sizeof(T)) && Verify(elem, sizeof(T));
+  }
+
+  bool VerifyFromPointer(const uint8_t *const p, const size_t len) {
+    return Verify(static_cast<size_t>(p - buf_), len);
+  }
+
+  // Verify relative to a known-good base pointer.
+  bool VerifyFieldStruct(const uint8_t *const base, const voffset_t elem_off,
+                         const size_t elem_len, const size_t align) const {
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
+    return VerifyAlignment(f, align) && Verify(f, elem_len);
+  }
+
+  template<typename T>
+  bool VerifyField(const uint8_t *const base, const voffset_t elem_off,
+                   const size_t align) const {
+    const auto f = static_cast<size_t>(base - buf_) + elem_off;
+    return VerifyAlignment(f, align) && Verify(f, sizeof(T));
+  }
+
+  // Verify a pointer (may be NULL) of a table type.
+  template<typename T> bool VerifyTable(const T *const table) {
+    return !table || table->Verify(*this);
+  }
+
+  // Verify a pointer (may be NULL) of any vector type.
+  template<int &..., typename T, typename LenT>
+  bool VerifyVector(const Vector<T, LenT> *const vec) const {
+    return !vec || VerifyVectorOrString<LenT>(
+                       reinterpret_cast<const uint8_t *>(vec), sizeof(T));
+  }
+
+  // Verify a pointer (may be NULL) of a vector to struct.
+  template<int &..., typename T, typename LenT>
+  bool VerifyVector(const Vector<const T *, LenT> *const vec) const {
+    return VerifyVector(reinterpret_cast<const Vector<T, LenT> *>(vec));
+  }
+
+  // Verify a pointer (may be NULL) to string.
+  bool VerifyString(const String *const str) const {
+    size_t end;
+    return !str || (VerifyVectorOrString<uoffset_t>(
+                        reinterpret_cast<const uint8_t *>(str), 1, &end) &&
+                    Verify(end, 1) &&           // Must have terminator
+                    Check(buf_[end] == '\0'));  // Terminating byte must be 0.
+  }
+
+  // Common code between vectors and strings.
+  template<typename LenT = uoffset_t>
+  bool VerifyVectorOrString(const uint8_t *const vec, const size_t elem_size,
+                            size_t *const end = nullptr) const {
+    const auto vec_offset = static_cast<size_t>(vec - buf_);
+    // Check we can read the size field.
+    if (!Verify<LenT>(vec_offset)) return false;
+    // Check the whole array. If this is a string, the byte past the array must
+    // be 0.
+    const LenT size = ReadScalar<LenT>(vec);
+    const auto max_elems = opts_.max_size / elem_size;
+    if (!Check(size < max_elems))
+      return false;  // Protect against byte_size overflowing.
+    const auto byte_size = sizeof(LenT) + elem_size * size;
+    if (end) *end = vec_offset + byte_size;
+    return Verify(vec_offset, byte_size);
+  }
+
+  // Special case for string contents, after the above has been called.
+  bool VerifyVectorOfStrings(const Vector<Offset<String>> *const vec) const {
+    if (vec) {
+      for (uoffset_t i = 0; i < vec->size(); i++) {
+        if (!VerifyString(vec->Get(i))) return false;
+      }
+    }
+    return true;
+  }
+
+  // Special case for table contents, after the above has been called.
+  template<typename T>
+  bool VerifyVectorOfTables(const Vector<Offset<T>> *const vec) {
+    if (vec) {
+      for (uoffset_t i = 0; i < vec->size(); i++) {
+        if (!vec->Get(i)->Verify(*this)) return false;
+      }
+    }
+    return true;
+  }
+
+  FLATBUFFERS_SUPPRESS_UBSAN("unsigned-integer-overflow")
+  bool VerifyTableStart(const uint8_t *const table) {
+    // Check the vtable offset.
+    const auto tableo = static_cast<size_t>(table - buf_);
+    if (!Verify<soffset_t>(tableo)) return false;
+    // This offset may be signed, but doing the subtraction unsigned always
+    // gives the result we want.
+    const auto vtableo =
+        tableo - static_cast<size_t>(ReadScalar<soffset_t>(table));
+    // Check the vtable size field, then check vtable fits in its entirety.
+    if (!(VerifyComplexity() && Verify<voffset_t>(vtableo) &&
+          VerifyAlignment(ReadScalar<voffset_t>(buf_ + vtableo),
+                          sizeof(voffset_t))))
+      return false;
+    const auto vsize = ReadScalar<voffset_t>(buf_ + vtableo);
+    return Check((vsize & 1) == 0) && Verify(vtableo, vsize);
+  }
+
+  template<typename T>
+  bool VerifyBufferFromStart(const char *const identifier, const size_t start) {
+    // Buffers have to be of some size to be valid. The reason it is a runtime
+    // check instead of static_assert, is that nested flatbuffers go through
+    // this call and their size is determined at runtime.
+    if (!Check(size_ >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+    // If an identifier is provided, check that we have a buffer
+    if (identifier && !Check((size_ >= 2 * sizeof(flatbuffers::uoffset_t) &&
+                              BufferHasIdentifier(buf_ + start, identifier)))) {
+      return false;
+    }
+
+    // Call T::Verify, which must be in the generated code for this type.
+    const auto o = VerifyOffset<uoffset_t>(start);
+    return Check(o != 0) &&
+           reinterpret_cast<const T *>(buf_ + start + o)->Verify(*this)
+    // clang-format off
+    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
+           && GetComputedSize()
+    #endif
+        ;
+    // clang-format on
+  }
+
+  template<typename T, int &..., typename SizeT>
+  bool VerifyNestedFlatBuffer(const Vector<uint8_t, SizeT> *const buf,
+                              const char *const identifier) {
+    // Caller opted out of this.
+    if (!opts_.check_nested_flatbuffers) return true;
+
+    // An empty buffer is OK as it indicates not present.
+    if (!buf) return true;
+
+    // If there is a nested buffer, it must be greater than the min size.
+    if (!Check(buf->size() >= FLATBUFFERS_MIN_BUFFER_SIZE)) return false;
+
+    Verifier nested_verifier(buf->data(), buf->size(), opts_);
+    return nested_verifier.VerifyBuffer<T>(identifier);
+  }
+
+  // Verify this whole buffer, starting with root type T.
+  template<typename T> bool VerifyBuffer() { return VerifyBuffer<T>(nullptr); }
+
+  template<typename T> bool VerifyBuffer(const char *const identifier) {
+    return VerifyBufferFromStart<T>(identifier, 0);
+  }
+
+  template<typename T, typename SizeT = uoffset_t>
+  bool VerifySizePrefixedBuffer(const char *const identifier) {
+    return Verify<SizeT>(0U) &&
+           // Ensure the prefixed size is within the bounds of the provided
+           // length.
+           Check(ReadScalar<SizeT>(buf_) + sizeof(SizeT) <= size_) &&
+           VerifyBufferFromStart<T>(identifier, sizeof(SizeT));
+  }
+
+  template<typename OffsetT = uoffset_t, typename SOffsetT = soffset_t>
+  size_t VerifyOffset(const size_t start) const {
+    if (!Verify<OffsetT>(start)) return 0;
+    const auto o = ReadScalar<OffsetT>(buf_ + start);
+    // May not point to itself.
+    if (!Check(o != 0)) return 0;
+    // Can't wrap around larger than the max size.
+    if (!Check(static_cast<SOffsetT>(o) >= 0)) return 0;
+    // Must be inside the buffer to create a pointer from it (pointer outside
+    // buffer is UB).
+    if (!Verify(start + o, 1)) return 0;
+    return o;
+  }
+
+  template<typename OffsetT = uoffset_t>
+  size_t VerifyOffset(const uint8_t *const base, const voffset_t start) const {
+    return VerifyOffset<OffsetT>(static_cast<size_t>(base - buf_) + start);
+  }
+
+  // Called at the start of a table to increase counters measuring data
+  // structure depth and amount, and possibly bails out with false if limits set
+  // by the constructor have been hit. Needs to be balanced with EndTable().
+  bool VerifyComplexity() {
+    depth_++;
+    num_tables_++;
+    return Check(depth_ <= opts_.max_depth && num_tables_ <= opts_.max_tables);
+  }
+
+  // Called at the end of a table to pop the depth count.
+  bool EndTable() {
+    depth_--;
+    return true;
+  }
+
+  // Returns the message size in bytes
+  size_t GetComputedSize() const {
+    // clang-format off
+    #ifdef FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE
+      uintptr_t size = upper_bound_;
+      // Align the size to uoffset_t
+      size = (size - 1 + sizeof(uoffset_t)) & ~(sizeof(uoffset_t) - 1);
+      return (size > size_) ?  0 : size;
+    #else
+      // Must turn on FLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE for this to work.
+      (void)upper_bound_;
+      FLATBUFFERS_ASSERT(false);
+      return 0;
+    #endif
+    // clang-format on
+  }
+
+  std::vector<uint8_t> *GetFlexReuseTracker() { return flex_reuse_tracker_; }
+
+  void SetFlexReuseTracker(std::vector<uint8_t> *const rt) {
+    flex_reuse_tracker_ = rt;
+  }
+
+ private:
+  const uint8_t *buf_;
+  const size_t size_;
+  const Options opts_;
+
+  mutable size_t upper_bound_ = 0;
+
+  uoffset_t depth_ = 0;
+  uoffset_t num_tables_ = 0;
+  std::vector<uint8_t> *flex_reuse_tracker_ = nullptr;
+};
+
+// Specialization for 64-bit offsets.
+template<>
+inline size_t Verifier::VerifyOffset<uoffset64_t>(const size_t start) const {
+  return VerifyOffset<uoffset64_t, soffset64_t>(start);
+}
+
+}  // namespace flatbuffers
+}  // namespace arrow_vendored_private
+
+#endif  // FLATBUFFERS_VERIFIER_H_

From 7b7bbdc49250a1a91df079995a38208d55d45d42 Mon Sep 17 00:00:00 2001
From: Fernando Mayer <fernandomayer@gmail.com>
Date: Fri, 13 Oct 2023 00:23:42 +0100
Subject: [PATCH 548/749] GH-37907: [R] Setting rosetta variable is missing
 (#37961)

### Rationale for this change

The latest version of `r/R/install-arrow.R`  was not working properly, since it was relying on the `on_rosetta()` function, which is not defined elsewhere. I just fixed the identification of rosetta in the script.

With the current code, the following gives an error

````r
> source("https://raw.githubusercontent.com/apache/arrow/master/r/R/install-arrow.R")
> install_arrow()
Error in on_rosetta() : could not find function "on_rosetta"
````

### What changes are included in this PR?

It only removed the `on_rosetta()` function, which was not defined elsewhere, and reverted back to the `rosetta` object to identify if rosetta is present or not on a user's system.

### Are these changes tested?

Yes. It was tested with the current code and the proposed PR. The proposed PR works as expected.

### Are there any user-facing changes?

No.

* Closes: #37907

Lead-authored-by: Fernando Mayer <fernandomayer@gmail.com>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/arrow-package.R                   |  6 ------
 r/R/install-arrow.R                   |  9 ++++++++-
 r/tests/testthat/test-arrow-pacakge.R | 21 ---------------------
 r/tests/testthat/test-install-arrow.R |  5 +++++
 4 files changed, 13 insertions(+), 28 deletions(-)
 delete mode 100644 r/tests/testthat/test-arrow-pacakge.R

diff --git a/r/R/arrow-package.R b/r/R/arrow-package.R
index 8655bf5a1cc68..eec95b8282bfd 100644
--- a/r/R/arrow-package.R
+++ b/r/R/arrow-package.R
@@ -241,12 +241,6 @@ on_macos_10_13_or_lower <- function() {
     package_version(unname(Sys.info()["release"])) < "18.0.0"
 }
 
-on_rosetta <- function() {
-  # make sure to suppress warnings and ignore the stdout + stderr so that this is silent
-  identical(tolower(Sys.info()[["sysname"]]), "darwin") &&
-    identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
-}
-
 option_use_threads <- function() {
   !is_false(getOption("arrow.use_threads"))
 }
diff --git a/r/R/install-arrow.R b/r/R/install-arrow.R
index 715478f6d0542..6db6f2b0adaa3 100644
--- a/r/R/install-arrow.R
+++ b/r/R/install-arrow.R
@@ -79,7 +79,8 @@ install_arrow <- function(nightly = FALSE,
     # On the M1, we can't use the usual autobrew, which pulls Intel dependencies
     apple_m1 <- grepl("arm-apple|aarch64.*darwin", R.Version()$platform)
     # On Rosetta, we have to build without JEMALLOC, so we also can't autobrew
-    if (on_rosetta()) {
+    rosetta <- on_rosetta()
+    if (rosetta) {
       Sys.setenv(ARROW_JEMALLOC = "OFF")
     }
     if (apple_m1 || rosetta) {
@@ -267,3 +268,9 @@ wslify_path <- function(path) {
   end_path <- strsplit(path, drive_expr)[[1]][-1]
   file.path(wslified_drive, end_path)
 }
+
+on_rosetta <- function() {
+  # make sure to suppress warnings and ignore the stderr so that this is silent where proc_translated doesn't exist
+  identical(tolower(Sys.info()[["sysname"]]), "darwin") &&
+    identical(suppressWarnings(system("sysctl -n sysctl.proc_translated", intern = TRUE, ignore.stderr = TRUE)), "1")
+}
diff --git a/r/tests/testthat/test-arrow-pacakge.R b/r/tests/testthat/test-arrow-pacakge.R
deleted file mode 100644
index 2d79467fa30a9..0000000000000
--- a/r/tests/testthat/test-arrow-pacakge.R
+++ /dev/null
@@ -1,21 +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.
-
-test_that("on_rosetta() does not warn", {
-  # There is no warning
-  expect_warning(on_rosetta(), NA)
-})
diff --git a/r/tests/testthat/test-install-arrow.R b/r/tests/testthat/test-install-arrow.R
index 787c8ea2c018c..5415fc27581cc 100644
--- a/r/tests/testthat/test-install-arrow.R
+++ b/r/tests/testthat/test-install-arrow.R
@@ -33,3 +33,8 @@ test_that("arrow_repos", {
     expect_identical(arrow_repos(c(ours, other), nightly = TRUE), c(ours, other))
   })
 })
+
+test_that("on_rosetta() does not warn", {
+  # There is no warning
+  expect_warning(on_rosetta(), NA)
+})

From 057453513f1a013e19c78bc75e8759068ebffabc Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Thu, 12 Oct 2023 22:07:11 -0300
Subject: [PATCH 549/749] GH-37945: [R] Update developer documentation (#38220)

### Rationale for this change

Several PRs over the last few months have update the build system to be more friendly for developers. During this process it has also come to light that we haven't supported the Windows development setup documented here since R 4.1 (released in spring 2021). I had to remove Windows from the test-r-devdocs job because the approach used there was not compatible with the `setup-r@ v2` action, and the job was failing with the `@ v1` action.

### What changes are included in this PR?

- Updated the sections on using pre-built static libraries and bundled builds
- Removed the Windows section regarding the bundled build. This section would need rewriting to support the last two minor releases of R but in the meantime I think it is mostly confusing.

### Are these changes tested?

They are documentation changes. They are also slightly optimisitc: we can fix problems with the developer setup incrementally between releases, but it's more difficult to update our documentation. This PR documents the intended behaviour after https://github.com/apache/arrow/pull/38236 .

### Are there any user-facing changes?

No.
* Closes: #37945

Lead-authored-by: Dewey Dunnington <dewey@voltrondata.com>
Co-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Co-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/vignettes/developers/setup.Rmd | 136 ++++++-------------------------
 1 file changed, 26 insertions(+), 110 deletions(-)

diff --git a/r/vignettes/developers/setup.Rmd b/r/vignettes/developers/setup.Rmd
index 479af577aa848..de33e72407792 100644
--- a/r/vignettes/developers/setup.Rmd
+++ b/r/vignettes/developers/setup.Rmd
@@ -38,50 +38,32 @@ set -e
 set -x
 ```
 
-
-```{bash, save=run & windows, hide=TRUE}
-# For some reason CRAN Mirror goes missing in CI
-echo 'options(repos=structure(c(CRAN="https://cloud.r-project.org")))' > $HOME/.Rprofile
-```
-
-Windows and macOS users who wish to contribute to the R package and
-don't need to alter libarrow (Arrow's C++ library) may be able to obtain a
-recent version of the library without building from source.
-
-### Linux
-
-On Linux, you can download a .zip file containing libarrow from the
-[nightly repository](https://nightlies.apache.org/arrow/r/libarrow/bin/).
-
-The directory names correspond to the OpenSSL version the binaries built with:
-- "linux-openssl-1.0" (OpenSSL 1.0)
-- "linux-openssl-1.1" (OpenSSL 1.1)
-- "linux-openssl-3.0" (OpenSSL 3.0)
-
-Version numbers in that repository correspond to dates.
-
-You'll need to create a `libarrow` directory inside the R package directory and unzip the zip file containing the compiled libarrow binary files into it.
-
-### macOS
-On macOS, you can install libarrow using [Homebrew](https://brew.sh/):
-
-```bash
-# For the released version:
-brew install apache-arrow
-# Or for a development version, you can try:
-brew install apache-arrow --HEAD
-```
-
-### Windows
-
-On Windows, you can download a .zip file containing libarrow from the
-[nightly repository](https://nightlies.apache.org/arrow/r/libarrow/bin/windows/).
-
-Version numbers in that repository correspond to dates.
-
-You can set the `RWINLIB_LOCAL` environment variable to point to the zip file containing libarrow before installing the arrow R package.
-
-## R and C++
+The Arrow R package is unique compared to other R packages that you may have
+contributed to because it builds on top of the large and feature-rich Arrow C++
+implementation. Because the R package integrates tightly with Arrow C++,
+it typically requires a dedicated copy of the library (i.e., it is usually
+not possible to link to a system version of libarrow during development).
+
+## Option 1: Using nightly libarrow binaries
+
+On Linux, MacOS, and Windows you can use the same workflow you might use for another
+package that contains compiled code (e.g., `R CMD INSTALL .` from
+a terminal, `devtools::load_all()` from an R prompt, or `Install & Restart` from
+RStudio). If the `arrow/r/libarrow` directory is not populated, the configure script will
+attempt to download the latest nightly libarrow binary, extract it to the
+`arrow/r/libarrow` directory (MacOS, Linux) or `arrow/r/windows`
+directory (Windows), and continue building the R package as usual.
+
+Most of the time, you won't need to update your version of libarrow because
+the R package rarely changes with updates to the C++ library; however, if you
+start to get errors when rebuilding the R package, you may have to remove the
+`libarrow` directory (MacOS, Linux) or `windows` directory (Windows)
+and do a "clean" rebuild. You can do this from a terminal with
+`R CMD INSTALL . --preclean`, from RStudio using the "Clean and Install"
+option from "Build" tab, or using `make clean` if you are using the `Makefile`
+located in the root of the R package.
+
+## Option 2: Use a local Arrow C++ development build
 
 If you need to alter both libarrow and the R package code, or if you can't get a binary version of the latest libarrow elsewhere, you'll need to build it from source. This section discusses how to set up a C++ libarrow build configured to work with the R package. For more general resources, see the [Arrow C++ developer guide](https://arrow.apache.org/docs/developers/cpp/building.html).
 
@@ -103,43 +85,6 @@ sudo apt install -y cmake libcurl4-openssl-dev libssl-dev
 brew install cmake openssl
 ```
 
-#### Windows
-
-The package can be built on Windows using [RTools 4](https://cran.r-project.org/bin/windows/Rtools/). It can be built for mingw32 (i386), mingw64 (x64), or ucrt64 (UCRT x64). mingw64 is the recommended 64-bit installation.
-
-Open the corresponding RTools Bash, for example "Rtools MinGW 64-bit" for mingw64.
-
-Install CMake, ccache, and Ninja with:
-
-```{bash, save=run & windows}
-pacman --sync --refresh --noconfirm \
-  ${MINGW_PACKAGE_PREFIX}-{ccache,cmake,ninja,openssl}
-export CMAKE_GENERATOR=Ninja
-```
-
-You will need to add R to your path. For a user-level installation, R will be at something like `~/Documents/R/R-4.1.2/bin`. For a global installation, R will be at something like `/c/Program\ Files/R/R-4.1.2/bin`. The R on your path needs to match the architecture you are compiling for, so if you are compiling on 32-bit specify `.../bin/i386` instead of `.../bin/x64`.
-
-```{bash}
-export PATH=~/Documents/R/R-4.1.2/bin/x64:$PATH
-```
-
-You can install additional dependencies like so. Note that you are limited to the packages in [the RTools repo](https://github.com/r-windows/rtools-packages), which does not contain every dependency used by Arrow.
-
-```{bash, save=run & windows}
-pacman --sync --refresh --noconfirm \
-  ${MINGW_PACKAGE_PREFIX}-boost \
-  ${MINGW_PACKAGE_PREFIX}-brotli \
-  ${MINGW_PACKAGE_PREFIX}-lz4 \
-  ${MINGW_PACKAGE_PREFIX}-protobuf \
-  ${MINGW_PACKAGE_PREFIX}-snappy \
-  ${MINGW_PACKAGE_PREFIX}-thrift \
-  ${MINGW_PACKAGE_PREFIX}-zlib \
-  ${MINGW_PACKAGE_PREFIX}-zstd \
-  ${MINGW_PACKAGE_PREFIX}-aws-sdk-cpp \
-  ${MINGW_PACKAGE_PREFIX}-re2 \
-  ${MINGW_PACKAGE_PREFIX}-libutf8proc
-```
-
 ### Step 2 - Configure the libarrow build
 
 We recommend that you configure libarrow to be built to a user-level directory rather than a system directory for your development work.  This is so that the development version you are using doesn't overwrite a released version of libarrow you may already have installed, and so that you are also able work with more than one version of libarrow (by using different `ARROW_HOME` directories for the different versions).
@@ -158,13 +103,6 @@ export LD_LIBRARY_PATH=$ARROW_HOME/lib:$LD_LIBRARY_PATH
 echo "export LD_LIBRARY_PATH=$ARROW_HOME/lib:$LD_LIBRARY_PATH" >> ~/.bash_profile
 ```
 
-_Special instructions on Windows:_ You will need to add `$ARROW_HOME/bin` to your `PATH` if you are using dynamic libraries (which is recommended).
-
-```{bash, save=run & windows}
-export PATH=$ARROW_HOME/bin:$PATH
-echo "export PATH=\"$ARROW_HOME/bin:$PATH\"" >> ~/.bash_profile
-```
-
 Start by navigating in a terminal to the arrow repository. You will need to create a directory into which the C++ build will put its contents. We recommend that you make a `build` directory inside of the `cpp` directory of the Arrow git repository (it is git-ignored, so you won't accidentally check it in). Next, change directories to be inside `cpp/build`:
 
 ```{bash, save=run & !sys_install}
@@ -197,32 +135,10 @@ cmake \
   ..
 ```
 
-##### Windows
-
-```{bash, save=run & !sys_install & windows}
-cmake \
-  -DCMAKE_INSTALL_PREFIX=$ARROW_HOME \
-  -DCMAKE_INSTALL_LIBDIR=lib \
-  -DARROW_COMPUTE=ON \
-  -DARROW_CSV=ON \
-  -DARROW_DATASET=ON \
-  -DARROW_EXTRA_ERROR_CONTEXT=ON \
-  -DARROW_FILESYSTEM=ON \
-  -DARROW_MIMALLOC=ON \
-  -DARROW_JSON=ON \
-  -DARROW_PARQUET=ON \
-  -DARROW_WITH_SNAPPY=OFF \
-  -DARROW_WITH_ZLIB=ON \
-  ..
-```
-
 #### {-}
 
 `..` refers to the C++ source directory: you're in `cpp/build` and the source is in `cpp`.
 
-**For Windows**: some options, including `-DARROW_JEMALLOC`, are not supported on Windows.
-
-
 ```{bash, save=run & !sys_install, hide=TRUE}
 # For testing purposes, build with only shared libraries
 cmake \

From 4bf777a6ad716e3d60f96446b0c37bc4752990b4 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Fri, 13 Oct 2023 06:47:32 +0200
Subject: [PATCH 550/749] GH-38043: [R] Enable all features by default on macOS
 (#38195)

### Rationale for this change

Previously GCS/S3 support would need to be explicitly enabled in source builds (when they are build without `NOT_CRAN`). As we want the macos binaries to be fully featured we should turn the features on when the dependencies exists.

### What changes are included in this PR?

This PR enables this behavior for macOS only, on Linux setting `NOT_CRAN` or  `LIBARROW_MINIMAL=false` is still required.

### Are these changes tested?

Crossbow and locally (thanks @ paleolimbot )
* Closes: #38043

Lead-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Co-authored-by: Dewey Dunnington <dewey@dunnington.ca>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 cpp/cmake_modules/ThirdpartyToolchain.cmake |  4 +--
 dev/tasks/macros.jinja                      |  1 +
 dev/tasks/r/github.packages.yml             | 36 +++++++++++----------
 r/configure                                 | 21 ++++++++----
 r/tools/nixlibs.R                           |  9 ++----
 5 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index ffc3c2514a295..559ddf14f6a91 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -4086,6 +4086,7 @@ macro(build_crc32c_once)
                                                     ${_CRC32C_STATIC_LIBRARY})
     target_include_directories(Crc32c::crc32c BEFORE INTERFACE "${CRC32C_INCLUDE_DIR}")
     add_dependencies(Crc32c::crc32c crc32c_ep)
+    list(APPEND ARROW_BUNDLED_STATIC_LIBS Crc32c::crc32c)
   endif()
 endmacro()
 
@@ -4316,8 +4317,7 @@ macro(build_google_cloud_cpp_storage)
          absl::synchronization
          absl::throw_delegate
          absl::time
-         absl::time_zone
-         Crc32c::crc32c)
+         absl::time_zone)
   endif()
 endmacro()
 
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 2a6cbe3e61109..3bcff2f63541f 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -278,6 +278,7 @@ on:
     "arrow",
     repos = c(getOption("arrow.dev_repo"), getOption("repos")),
     verbose = TRUE,
+    type = "source",
     INSTALL_opts = "--build"
   )
 
diff --git a/dev/tasks/r/github.packages.yml b/dev/tasks/r/github.packages.yml
index 89526bccdf5d5..22dddabc10fab 100644
--- a/dev/tasks/r/github.packages.yml
+++ b/dev/tasks/r/github.packages.yml
@@ -393,36 +393,38 @@ jobs:
           read_parquet(system.file("v0.7.1.parquet", package = "arrow"))
           print(arrow_info())
 
-  #TODO test macos source build?
-  test-linux-source:
+  test-source:
     needs: source
-    name: Test linux source build
-    runs-on: ubuntu-latest
+    name: Test {{ '${{ matrix.platform.name }}' }} source build
+    runs-on: {{ '${{ matrix.platform.runs_on }}' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - {runs_on: "ubuntu-latest", name: "Linux"}
+          - {runs_on: ["self-hosted", "macos-10.13"] , name: "macOS"}
     steps:
       - name: Install R
+        if: matrix.platform.name == 'Linux'
         uses: r-lib/actions/setup-r@v2
-        with:
-          install-r: false
       {{ macros.github_setup_local_r_repo(false, false)|indent }}
-      {{ macros.github_checkout_arrow()|indent }}
+      {{ macros.github_checkout_arrow(action_v="3")|indent }}
       - name: Install sccache
+        if: matrix.platform.name == 'Linux'
         shell: bash
         run: |
           arrow/ci/scripts/install_sccache.sh unknown-linux-musl /usr/local/bin
-      - name: Install R package system dependencies
-        run: |
-          sudo arrow/ci/scripts/r_install_system_dependencies.sh
-        env:
-          ARROW_GCS: "ON"
-          ARROW_S3: "ON"
-          ARROW_SOURCE_HOME: arrow
+      - name: Install R package system dependencies (Linux)
+        if: matrix.platform.name == 'Linux'
+        run: sudo apt-get install -y libcurl4-openssl-dev libssl-dev
       - name: Remove arrow/
         run: |
           rm -rf arrow/
       - name: Enable parallel build
         run: |
-          echo "MAKEFLAGS=-j$(nproc)" >> $GITHUB_ENV
-      - name: Install arrow from nightly repo
+          cores=`nproc || sysctl -n hw.logicalcpu`
+          echo "MAKEFLAGS=-j$cores" >> $GITHUB_ENV
+      - name: Install arrow source package
         env:
           # Test source build so be sure not to download a binary
           LIBARROW_BINARY: "FALSE"
@@ -444,7 +446,7 @@ jobs:
 
   upload-binaries:
     # Only upload binaries if all tests pass.
-    needs: [r-packages, test-linux-source, test-linux-binary]
+    needs: [r-packages, test-source, test-linux-binary]
     name: Upload artifacts
     runs-on: ubuntu-latest
     steps:
diff --git a/r/configure b/r/configure
index ced3b40a68901..addf7b59c7fbf 100755
--- a/r/configure
+++ b/r/configure
@@ -121,16 +121,25 @@ else
   ARROW_USE_PKG_CONFIG="false"
 fi
 
-# find openssl on macos. macOS ships with libressl. openssl is installable
-# with brew, but it is generally not linked. We can over-ride this and find
-# openssl but setting OPENSSL_ROOT_DIR (which cmake will pick up later in
-# the installation process). FWIW, arrow's cmake process uses this
-# same process to find openssl, but doing it now allows us to catch it in
-# nixlibs.R and throw a nicer error.
+## Find openssl
+# Arrow's cmake process uses this same process to find openssl,
+# but doing it now allows us to catch it in
+# nixlibs.R and activate S3 and GCS support for the source build.
+
+# macOS ships with libressl. openssl is installable with brew, but it is 
+# generally not linked. We can over-ride this and find
+# openssl by setting OPENSSL_ROOT_DIR (which cmake will pick up later in
+# the installation process).
 if [ "${OPENSSL_ROOT_DIR}" = "" ] && brew --prefix openssl >/dev/null 2>&1; then
   export OPENSSL_ROOT_DIR="`brew --prefix openssl`"
   export PKG_CONFIG_PATH="${OPENSSL_ROOT_DIR}/lib/pkgconfig${PKG_CONFIG_PATH:+:${PKG_CONFIG_PATH}}"
 fi
+# Look for openssl with pkg-config for non-brew sources(e.g. CRAN) and Linux
+if [ "${OPENSSL_ROOT_DIR}" = "" -a "${PKG_CONFIG_AVAILABLE}" = "true" ]; then
+  if ${PKG_CONFIG} --exists openssl; then
+    export OPENSSL_ROOT_DIR="`${PKG_CONFIG} --variable=prefix openssl`"
+  fi
+fi
 
 #############
 # Functions #
diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 1346e209d8d14..3d651ec6ac9ea 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -57,7 +57,8 @@ try_download <- function(from_url, to_file, hush = quietly) {
 }
 
 not_cran <- env_is("NOT_CRAN", "true")
-if (not_cran) {
+# enable full featured builds and binaries for macOS (or if the NOT_CRAN variable has been set)
+if (not_cran || on_macos) {
   # Set more eager defaults
   if (env_is("LIBARROW_BINARY", "")) {
     Sys.setenv(LIBARROW_BINARY = "true")
@@ -759,6 +760,7 @@ is_feature_requested <- function(env_varname, default = env_is("LIBARROW_MINIMAL
 with_cloud_support <- function(env_var_list) {
   arrow_s3 <- is_feature_requested("ARROW_S3")
   arrow_gcs <- is_feature_requested("ARROW_GCS")
+
   if (arrow_s3 || arrow_gcs) {
     # User wants S3 or GCS support.
     # Make sure that we have curl and openssl system libs
@@ -773,11 +775,6 @@ with_cloud_support <- function(env_var_list) {
       cat("**** ", start_msg, " support ", msg, "; building with ", off_flags, "\n")
     }
 
-    # Check the features
-    # This duplicates what we do with the test program above when we check
-    # capabilities for using binaries. We could consider consolidating this
-    # logic, though these use cmake in order to match exactly what we do in the
-    # libarrow build, and maybe that increases the fidelity.
     if (!cmake_find_package("CURL", NULL, env_var_list)) {
       # curl on macos should be installed, so no need to alter this for macos
       # TODO: check for apt/yum/etc. and message the right thing?

From e9aac8a4ce4b8833667efe52957fb0881a488c4b Mon Sep 17 00:00:00 2001
From: Nic Crane <thisisnic@gmail.com>
Date: Fri, 13 Oct 2023 09:47:39 +0100
Subject: [PATCH 551/749] MINOR: [R] Fix spelling of delimiter (#38257)

### Rationale for this change

Fix typo in docs introduced in #38232

### What changes are included in this PR?

Change spelling of "delimeter" to "delimiter"

### Are these changes tested?

No
### Are there any user-facing changes?

Just docs

Authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/csv.R                 | 4 ++--
 r/man/read_delim_arrow.Rd | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/r/R/csv.R b/r/R/csv.R
index 1850eb255a480..a024c4531e748 100644
--- a/r/R/csv.R
+++ b/r/R/csv.R
@@ -22,8 +22,8 @@
 #' `readr::read_delim()`, and `col_select` was inspired by `vroom::vroom()`.
 #'
 #' `read_csv_arrow()` and `read_tsv_arrow()` are wrappers around
-#' `read_delim_arrow()` that specify a delimeter. `read_csv2_arrow()` uses `;` for
-#' the delimeter and `,` for the decimal point.
+#' `read_delim_arrow()` that specify a delimiter. `read_csv2_arrow()` uses `;` for
+#' the delimiter and `,` for the decimal point.
 #'
 #' Note that not all `readr` options are currently implemented here. Please file
 #' an issue if you encounter one that `arrow` should support.
diff --git a/r/man/read_delim_arrow.Rd b/r/man/read_delim_arrow.Rd
index 3ee9f6ea118a4..999f2d265b7fd 100644
--- a/r/man/read_delim_arrow.Rd
+++ b/r/man/read_delim_arrow.Rd
@@ -174,8 +174,8 @@ Arrow C++ options have been mapped to argument names that follow those of
 }
 \details{
 \code{read_csv_arrow()} and \code{read_tsv_arrow()} are wrappers around
-\code{read_delim_arrow()} that specify a delimeter. \code{read_csv2_arrow()} uses \verb{;} for
-the delimeter and \verb{,} for the decimal point.
+\code{read_delim_arrow()} that specify a delimiter. \code{read_csv2_arrow()} uses \verb{;} for
+the delimiter and \verb{,} for the decimal point.
 
 Note that not all \code{readr} options are currently implemented here. Please file
 an issue if you encounter one that \code{arrow} should support.

From c5bce96ba626ad2558e10acddf8ef19ea06940e8 Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Sat, 14 Oct 2023 01:57:49 +0800
Subject: [PATCH 552/749] GH-37895: [C++] Feature: support concatenate
 recordbatches. (#37896)

### Rationale for this change

User scenario: When we use acero plan, many smaller batches may be generated through agg and hashjoin. In addition, due to the mpp database, there is data distribution. When there are many segments, each segment data is compared at this time. Small, in order to improve performance, we hope to merge multiple fragmented small batches into one large batch for calculation together.

### What changes are included in this PR?

record_batch.cc
record_batch.h
record_batch_test.cc

### Are these changes tested?

yes, see record_batch_test.cc

### Are there any user-facing changes?

yes

* Closes: #37895

Authored-by: light-city <455954986@qq.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/record_batch.cc      | 33 ++++++++++++++++++++++++++
 cpp/src/arrow/record_batch.h       | 14 +++++++++++
 cpp/src/arrow/record_batch_test.cc | 37 ++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+)

diff --git a/cpp/src/arrow/record_batch.cc b/cpp/src/arrow/record_batch.cc
index f0ee295c6347d..457135fa400d5 100644
--- a/cpp/src/arrow/record_batch.cc
+++ b/cpp/src/arrow/record_batch.cc
@@ -25,6 +25,7 @@
 #include <utility>
 
 #include "arrow/array.h"
+#include "arrow/array/concatenate.h"
 #include "arrow/array/validate.h"
 #include "arrow/pretty_print.h"
 #include "arrow/status.h"
@@ -432,4 +433,36 @@ RecordBatchReader::~RecordBatchReader() {
   ARROW_WARN_NOT_OK(this->Close(), "Implicitly called RecordBatchReader::Close failed");
 }
 
+Result<std::shared_ptr<RecordBatch>> ConcatenateRecordBatches(
+    const RecordBatchVector& batches, MemoryPool* pool) {
+  int64_t length = 0;
+  size_t n = batches.size();
+  if (n == 0) {
+    return Status::Invalid("Must pass at least one recordbatch");
+  }
+  int cols = batches[0]->num_columns();
+  auto schema = batches[0]->schema();
+  for (size_t i = 0; i < batches.size(); ++i) {
+    length += batches[i]->num_rows();
+    if (!schema->Equals(batches[i]->schema())) {
+      return Status::Invalid(
+          "Schema of RecordBatch index ", i, " is ", batches[i]->schema()->ToString(),
+          ", which does not match index 0 recordbatch schema: ", schema->ToString());
+    }
+  }
+
+  std::vector<std::shared_ptr<Array>> concatenated_columns;
+  concatenated_columns.reserve(cols);
+  for (int col = 0; col < cols; ++col) {
+    ArrayVector column_arrays;
+    column_arrays.reserve(batches.size());
+    for (const auto& batch : batches) {
+      column_arrays.emplace_back(batch->column(col));
+    }
+    ARROW_ASSIGN_OR_RAISE(auto concatenated_column, Concatenate(column_arrays, pool))
+    concatenated_columns.emplace_back(std::move(concatenated_column));
+  }
+  return RecordBatch::Make(std::move(schema), length, std::move(concatenated_columns));
+}
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/record_batch.h b/cpp/src/arrow/record_batch.h
index cb1f6d54f7cff..1a66fc3fb5629 100644
--- a/cpp/src/arrow/record_batch.h
+++ b/cpp/src/arrow/record_batch.h
@@ -350,4 +350,18 @@ class ARROW_EXPORT RecordBatchReader {
       Iterator<std::shared_ptr<RecordBatch>> batches, std::shared_ptr<Schema> schema);
 };
 
+/// \brief Concatenate record batches
+///
+/// The columns of the new batch are formed by concatenate the same columns of each input
+/// batch. Concatenate multiple batches into a new batch requires that the schema must be
+/// consistent. It supports merging batches without columns (only length, scenarios such
+/// as count(*)).
+///
+/// \param[in] batches a vector of record batches to be concatenated
+/// \param[in] pool memory to store the result will be allocated from this memory pool
+/// \return the concatenated record batch
+ARROW_EXPORT
+Result<std::shared_ptr<RecordBatch>> ConcatenateRecordBatches(
+    const RecordBatchVector& batches, MemoryPool* pool = default_memory_pool());
+
 }  // namespace arrow
diff --git a/cpp/src/arrow/record_batch_test.cc b/cpp/src/arrow/record_batch_test.cc
index bc923a1444160..db3a2d3def73f 100644
--- a/cpp/src/arrow/record_batch_test.cc
+++ b/cpp/src/arrow/record_batch_test.cc
@@ -555,4 +555,41 @@ TEST_F(TestRecordBatch, ReplaceSchema) {
   ASSERT_RAISES(Invalid, b1->ReplaceSchema(schema));
 }
 
+TEST_F(TestRecordBatch, ConcatenateRecordBatches) {
+  int length = 10;
+
+  auto f0 = field("f0", int32());
+  auto f1 = field("f1", uint8());
+
+  auto schema = ::arrow::schema({f0, f1});
+
+  random::RandomArrayGenerator gen(42);
+
+  auto b1 = gen.BatchOf(schema->fields(), length);
+
+  length = 5;
+
+  auto b2 = gen.BatchOf(schema->fields(), length);
+
+  ASSERT_OK_AND_ASSIGN(auto batch, ConcatenateRecordBatches({b1, b2}));
+  ASSERT_EQ(batch->num_rows(), b1->num_rows() + b2->num_rows());
+  ASSERT_BATCHES_EQUAL(*batch->Slice(0, b1->num_rows()), *b1);
+  ASSERT_BATCHES_EQUAL(*batch->Slice(b1->num_rows()), *b2);
+
+  f0 = field("fd0", int32());
+  f1 = field("fd1", uint8());
+
+  schema = ::arrow::schema({f0, f1});
+
+  auto b3 = gen.BatchOf(schema->fields(), length);
+
+  ASSERT_RAISES(Invalid, ConcatenateRecordBatches({b1, b3}));
+
+  auto null_batch = RecordBatch::Make(::arrow::schema({}), length,
+                                      std::vector<std::shared_ptr<ArrayData>>{});
+  ASSERT_OK_AND_ASSIGN(batch, ConcatenateRecordBatches({null_batch}));
+  ASSERT_EQ(batch->num_rows(), null_batch->num_rows());
+  ASSERT_BATCHES_EQUAL(*batch, *null_batch);
+}
+
 }  // namespace arrow

From f325ce95a29a4e36567aeaaac0718ad94ab8e125 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Mon, 16 Oct 2023 10:33:22 +0200
Subject: [PATCH 553/749] GH-38239: [CI][Python] Disable -W error on Python CI
 jobs temporarily (#38238)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Closes: #38239

Lead-authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Co-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Co-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/tasks/tasks.yml | 3 ++-
 python/setup.cfg    | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 0950378875645..04afe79d4d906 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1241,7 +1241,8 @@ tasks:
     params:
       env:
         PYTHON: "{{ python_version }}"
-        PYTEST_ARGS: "-W error"
+        # Temporarily disable error on Warning: https://github.com/apache/arrow/issues/38239
+        # PYTEST_ARGS: "-W error -W 'ignore:Setting custom ClientSession:DeprecationWarning'"
       image: conda-python
 {% endfor %}
 
diff --git a/python/setup.cfg b/python/setup.cfg
index 618fa475cd90d..3df4ff27ef87a 100644
--- a/python/setup.cfg
+++ b/python/setup.cfg
@@ -28,6 +28,8 @@ build-dir  = doc/_build
 addopts = --ignore=scripts
 filterwarnings =
     error:The SparseDataFrame:FutureWarning
+    # https://github.com/apache/arrow/issues/38239
+    ignore:Setting custom ClientSession:DeprecationWarning
 # Get a debug traceback when a test takes a really long time
 faulthandler_timeout = 300
 

From 47314e8cbf1a2ae8636ac511a368a4e8784397f2 Mon Sep 17 00:00:00 2001
From: Yue <niyue.com@gmail.com>
Date: Mon, 16 Oct 2023 16:54:17 +0800
Subject: [PATCH 554/749] GH-37751: [C++][Gandiva] Avoid registering exported
 functions multiple times in gandiva (#37752)

### Rationale for this change
Try to fix https://github.com/apache/arrow/issues/37751

### What changes are included in this PR?

The exported functions defined in gandiva are registered multiple times unnecessarily. This PR tries to address this issue.

### Are these changes tested?

Yes.

### Are there any user-facing changes?
No

Authored-by: Yue Ni <niyue.com@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/gandiva/CMakeLists.txt                |  2 ++
 cpp/src/gandiva/engine.cc                     |  3 ++
 cpp/src/gandiva/exported_funcs.cc             | 30 +++++++++++++++++++
 cpp/src/gandiva/exported_funcs.h              |  9 ++----
 cpp/src/gandiva/exported_funcs_registry.cc    | 11 ++++++-
 cpp/src/gandiva/exported_funcs_registry.h     | 17 ++++++-----
 .../gandiva/exported_funcs_registry_test.cc   | 28 +++++++++++++++++
 7 files changed, 84 insertions(+), 16 deletions(-)
 create mode 100644 cpp/src/gandiva/exported_funcs.cc
 create mode 100644 cpp/src/gandiva/exported_funcs_registry_test.cc

diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index d2810c39f723c..6b6743bc8e52f 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -58,6 +58,7 @@ set(SRC_FILES
     expression.cc
     expression_registry.cc
     exported_funcs_registry.cc
+    exported_funcs.cc
     filter.cc
     function_ir_builder.cc
     function_registry.cc
@@ -237,6 +238,7 @@ add_gandiva_test(internals-test
                  tree_expr_test.cc
                  encrypt_utils_test.cc
                  expr_decomposer_test.cc
+                 exported_funcs_registry_test.cc
                  expression_registry_test.cc
                  selection_vector_test.cc
                  lru_cache_test.cc
diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index b6c78da89d575..8ebe927437567 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -92,6 +92,7 @@
 
 #include "gandiva/configuration.h"
 #include "gandiva/decimal_ir.h"
+#include "gandiva/exported_funcs.h"
 #include "gandiva/exported_funcs_registry.h"
 
 namespace gandiva {
@@ -103,6 +104,7 @@ std::once_flag llvm_init_once_flag;
 static bool llvm_init = false;
 static llvm::StringRef cpu_name;
 static llvm::SmallVector<std::string, 10> cpu_attrs;
+std::once_flag register_exported_funcs_flag;
 
 void Engine::InitOnce() {
   DCHECK_EQ(llvm_init, false);
@@ -142,6 +144,7 @@ Engine::Engine(const std::shared_ptr<Configuration>& conf,
       cached_(cached) {}
 
 Status Engine::Init() {
+  std::call_once(register_exported_funcs_flag, gandiva::RegisterExportedFuncs);
   // Add mappings for global functions that can be accessed from LLVM/IR module.
   AddGlobalMappings();
 
diff --git a/cpp/src/gandiva/exported_funcs.cc b/cpp/src/gandiva/exported_funcs.cc
new file mode 100644
index 0000000000000..5b04b7c22c9c3
--- /dev/null
+++ b/cpp/src/gandiva/exported_funcs.cc
@@ -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.
+
+#include <gandiva/exported_funcs.h>
+#include <gandiva/exported_funcs_registry.h>
+
+namespace gandiva {
+void RegisterExportedFuncs() {
+  REGISTER_EXPORTED_FUNCS(ExportedStubFunctions);
+  REGISTER_EXPORTED_FUNCS(ExportedContextFunctions);
+  REGISTER_EXPORTED_FUNCS(ExportedTimeFunctions);
+  REGISTER_EXPORTED_FUNCS(ExportedDecimalFunctions);
+  REGISTER_EXPORTED_FUNCS(ExportedStringFunctions);
+  REGISTER_EXPORTED_FUNCS(ExportedHashFunctions);
+}
+}  // namespace gandiva
diff --git a/cpp/src/gandiva/exported_funcs.h b/cpp/src/gandiva/exported_funcs.h
index 5a14c52162156..82aa020a210c0 100644
--- a/cpp/src/gandiva/exported_funcs.h
+++ b/cpp/src/gandiva/exported_funcs.h
@@ -17,8 +17,8 @@
 
 #pragma once
 
-#include <gandiva/exported_funcs_registry.h>
 #include <vector>
+#include "gandiva/visibility.h"
 
 namespace gandiva {
 
@@ -36,36 +36,31 @@ class ExportedFuncsBase {
 class ExportedStubFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedStubFunctions);
 
 // Class for exporting Context functions
 class ExportedContextFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedContextFunctions);
 
 // Class for exporting Time functions
 class ExportedTimeFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedTimeFunctions);
 
 // Class for exporting Decimal functions
 class ExportedDecimalFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedDecimalFunctions);
 
 // Class for exporting String functions
 class ExportedStringFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedStringFunctions);
 
 // Class for exporting Hash functions
 class ExportedHashFunctions : public ExportedFuncsBase {
   void AddMappings(Engine* engine) const override;
 };
-REGISTER_EXPORTED_FUNCS(ExportedHashFunctions);
 
+GANDIVA_EXPORT void RegisterExportedFuncs();
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/exported_funcs_registry.cc b/cpp/src/gandiva/exported_funcs_registry.cc
index 4c87c4d40764b..2c928a7a2a46f 100644
--- a/cpp/src/gandiva/exported_funcs_registry.cc
+++ b/cpp/src/gandiva/exported_funcs_registry.cc
@@ -22,9 +22,18 @@
 namespace gandiva {
 
 void ExportedFuncsRegistry::AddMappings(Engine* engine) {
-  for (auto entry : registered()) {
+  for (const auto& entry : *registered()) {
     entry->AddMappings(engine);
   }
 }
 
+const ExportedFuncsRegistry::list_type& ExportedFuncsRegistry::Registered() {
+  return *registered();
+}
+
+ExportedFuncsRegistry::list_type* ExportedFuncsRegistry::registered() {
+  static list_type registered_list;
+  return &registered_list;
+}
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/exported_funcs_registry.h b/cpp/src/gandiva/exported_funcs_registry.h
index 1504f213005a9..08c45aec6a1ed 100644
--- a/cpp/src/gandiva/exported_funcs_registry.h
+++ b/cpp/src/gandiva/exported_funcs_registry.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include <gandiva/engine.h>
+#include <gandiva/visibility.h>
 
 namespace gandiva {
 
@@ -28,7 +29,7 @@ class ExportedFuncsBase;
 
 /// Registry for classes that export functions which can be accessed by
 /// LLVM/IR code.
-class ExportedFuncsRegistry {
+class GANDIVA_EXPORT ExportedFuncsRegistry {
  public:
   using list_type = std::vector<std::shared_ptr<ExportedFuncsBase>>;
 
@@ -36,19 +37,19 @@ class ExportedFuncsRegistry {
   static void AddMappings(Engine* engine);
 
   static bool Register(std::shared_ptr<ExportedFuncsBase> entry) {
-    registered().push_back(entry);
+    registered()->emplace_back(std::move(entry));
     return true;
   }
 
+  // list all the registered ExportedFuncsBase
+  static const list_type& Registered();
+
  private:
-  static list_type& registered() {
-    static list_type registered_list;
-    return registered_list;
-  }
+  static list_type* registered();
 };
 
-#define REGISTER_EXPORTED_FUNCS(classname) \
-  static bool _registered_##classname =    \
+#define REGISTER_EXPORTED_FUNCS(classname)               \
+  [[maybe_unused]] static bool _registered_##classname = \
       ExportedFuncsRegistry::Register(std::make_shared<classname>())
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/exported_funcs_registry_test.cc b/cpp/src/gandiva/exported_funcs_registry_test.cc
new file mode 100644
index 0000000000000..6941201e912df
--- /dev/null
+++ b/cpp/src/gandiva/exported_funcs_registry_test.cc
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "gandiva/exported_funcs_registry.h"
+#include <gtest/gtest.h>
+#include "gandiva/exported_funcs.h"
+
+namespace gandiva {
+TEST(ExportedFuncsRegistry, RegistrationOnlyOnce) {
+  gandiva::RegisterExportedFuncs();
+  auto const& registered_list = ExportedFuncsRegistry::Registered();
+  EXPECT_EQ(registered_list.size(), 6);
+}
+}  // namespace gandiva

From fb2617833200d9c90b6d79a85ae9e840b41938da Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Mon, 16 Oct 2023 17:57:09 +0900
Subject: [PATCH 555/749] GH-38074: [C++] Fix Offset Size Calculation for
 Slicing Large String and Binary Types in Hash Join (#38147)

### Rationale for this change

We found that the wrong results in inner joins during hash join operations were caused by a problem with how large strings and binary types were handled. The `Slice` function was not calculating their sizes correctly.

To fix this, I changed the `Slice` function to calculate the sizes correctly, based on the type of data for large string and binary.

* Issue raised: #37729

### What changes are included in this PR?

* The `Slice` function has been updated to correctly calculate the offset for Large String and Large Binary types, and assertion statements have been added to improve maintainability.
* Unit tests (`TEST(KeyColumnArray, SliceBinaryTest)`)for the Slice function have been added.
* During random tests for Hash Join (`TEST(HashJoin, Random)`), modifications were made to allow the creation of Large String as key column values.

### Are these changes tested?

Yes

### Are there any user-facing changes?

Acero might not have a large user base as it is an experimental feature, but I deemed the issue of incorrect join results as critical and have addressed the bug.

* Closes: #38074

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/acero/hash_join_node_test.cc | 27 ++++++++--
 cpp/src/arrow/compute/light_array.cc       | 12 +++--
 cpp/src/arrow/compute/light_array.h        | 25 +++++++++
 cpp/src/arrow/compute/light_array_test.cc  | 60 ++++++++++++++++++++++
 4 files changed, 116 insertions(+), 8 deletions(-)

diff --git a/cpp/src/arrow/acero/hash_join_node_test.cc b/cpp/src/arrow/acero/hash_join_node_test.cc
index 960d3838fb8fd..58551f4eca00a 100644
--- a/cpp/src/arrow/acero/hash_join_node_test.cc
+++ b/cpp/src/arrow/acero/hash_join_node_test.cc
@@ -253,7 +253,8 @@ struct RandomDataTypeConstraints {
   int max_string_length;
 
   void Default() {
-    data_type_enabled_mask = kInt1 | kInt2 | kInt4 | kInt8 | kBool | kBinary | kString;
+    data_type_enabled_mask =
+        kInt1 | kInt2 | kInt4 | kInt8 | kBool | kBinary | kString | kLargeString;
     min_null_probability = 0.0;
     max_null_probability = 0.2;
     min_binary_length = 1;
@@ -289,6 +290,7 @@ struct RandomDataTypeConstraints {
   static constexpr int64_t kBool = 16;
   static constexpr int64_t kBinary = 32;
   static constexpr int64_t kString = 64;
+  static constexpr int64_t kLargeString = 128;
 };
 
 struct RandomDataType {
@@ -297,6 +299,7 @@ struct RandomDataType {
   int fixed_length;
   int min_string_length;
   int max_string_length;
+  bool is_large_string;
 
   static RandomDataType Random(Random64Bit& rng,
                                const RandomDataTypeConstraints& constraints) {
@@ -312,6 +315,15 @@ struct RandomDataType {
     } else {
       result.is_fixed_length = true;
     }
+
+    if (!result.is_fixed_length &&
+        (constraints.data_type_enabled_mask & constraints.kLargeString) != 0) {
+      // When selecting the string type, there's a 50% chance of choosing a large string.
+      result.is_large_string = ((rng.next() % 2) == 0);
+    } else {
+      result.is_large_string = false;
+    }
+
     if (constraints.max_null_probability > 0.0) {
       // 25% chance of no nulls
       // Uniform distribution of null probability from min to max
@@ -405,9 +417,16 @@ std::vector<std::shared_ptr<Array>> GenRandomRecords(
           break;
       }
     } else {
-      result.push_back(rag.String(num_rows, data_types[i].min_string_length,
-                                  data_types[i].max_string_length,
-                                  data_types[i].null_probability));
+      if (data_types[i].is_large_string) {
+        // Generate LargeString if is_large_string flag is true
+        result.push_back(rag.LargeString(num_rows, data_types[i].min_string_length,
+                                         data_types[i].max_string_length,
+                                         data_types[i].null_probability));
+      } else {
+        result.push_back(rag.String(num_rows, data_types[i].min_string_length,
+                                    data_types[i].max_string_length,
+                                    data_types[i].null_probability));
+      }
     }
   }
   return result;
diff --git a/cpp/src/arrow/compute/light_array.cc b/cpp/src/arrow/compute/light_array.cc
index 37d4421fd79f7..4e8b2b2d7cc3a 100644
--- a/cpp/src/arrow/compute/light_array.cc
+++ b/cpp/src/arrow/compute/light_array.cc
@@ -80,8 +80,7 @@ KeyColumnArray KeyColumnArray::Slice(int64_t offset, int64_t length) const {
   KeyColumnArray sliced;
   sliced.metadata_ = metadata_;
   sliced.length_ = length;
-  uint32_t fixed_size =
-      !metadata_.is_fixed_length ? sizeof(uint32_t) : metadata_.fixed_length;
+  uint32_t fixed_size = metadata_.fixed_length;
 
   sliced.buffers_[0] =
       buffers_[0] ? buffers_[0] + (bit_offset_[0] + offset) / 8 : nullptr;
@@ -89,18 +88,23 @@ KeyColumnArray KeyColumnArray::Slice(int64_t offset, int64_t length) const {
       mutable_buffers_[0] ? mutable_buffers_[0] + (bit_offset_[0] + offset) / 8 : nullptr;
   sliced.bit_offset_[0] = (bit_offset_[0] + offset) % 8;
 
-  if (fixed_size == 0 && !metadata_.is_null_type) {
+  if (metadata_.fixed_length == 0 && !metadata_.is_null_type) {
+    ARROW_DCHECK(is_bool_type()) << "Expected BOOL type type but got a different type.";
     sliced.buffers_[1] =
         buffers_[1] ? buffers_[1] + (bit_offset_[1] + offset) / 8 : nullptr;
     sliced.mutable_buffers_[1] = mutable_buffers_[1]
                                      ? mutable_buffers_[1] + (bit_offset_[1] + offset) / 8
                                      : nullptr;
     sliced.bit_offset_[1] = (bit_offset_[1] + offset) % 8;
-  } else {
+  } else if (metadata_.fixed_length > 0) {
+    ARROW_DCHECK(is_binary_type() || is_large_binary_type() || is_fixed_width_types())
+        << "Expected (LARGE) BINARY or FIXED WIDTH type but got a different type.";
     sliced.buffers_[1] = buffers_[1] ? buffers_[1] + offset * fixed_size : nullptr;
     sliced.mutable_buffers_[1] =
         mutable_buffers_[1] ? mutable_buffers_[1] + offset * fixed_size : nullptr;
     sliced.bit_offset_[1] = 0;
+  } else {
+    ARROW_DCHECK(is_null_type()) << "Expected Null type but got a different type.";
   }
 
   sliced.buffers_[2] = buffers_[2];
diff --git a/cpp/src/arrow/compute/light_array.h b/cpp/src/arrow/compute/light_array.h
index 3dd328c22eedf..87f6b6c76a12c 100644
--- a/cpp/src/arrow/compute/light_array.h
+++ b/cpp/src/arrow/compute/light_array.h
@@ -183,6 +183,31 @@ class ARROW_EXPORT KeyColumnArray {
   // Starting bit offset within the first byte (between 0 and 7)
   // to be used when accessing buffers that store bit vectors.
   int bit_offset_[kMaxBuffers - 1];
+
+  bool is_bool_type() const {
+    return metadata_.is_fixed_length && metadata_.fixed_length == 0 &&
+           !metadata_.is_null_type;
+  }
+
+  bool is_fixed_width_types() const {
+    return metadata_.is_fixed_length && metadata_.fixed_length != 0 &&
+           !metadata_.is_null_type;
+  }
+
+  bool is_binary_type() const {
+    return !metadata_.is_fixed_length && metadata_.fixed_length == sizeof(uint32_t) &&
+           !metadata_.is_null_type;
+  }
+
+  bool is_large_binary_type() const {
+    return !metadata_.is_fixed_length && metadata_.fixed_length == sizeof(uint64_t) &&
+           !metadata_.is_null_type;
+  }
+
+  bool is_null_type() const {
+    return metadata_.is_fixed_length && metadata_.fixed_length == 0 &&
+           metadata_.is_null_type;
+  }
 };
 
 /// \brief Create KeyColumnMetadata from a DataType
diff --git a/cpp/src/arrow/compute/light_array_test.cc b/cpp/src/arrow/compute/light_array_test.cc
index 71d228bf3f614..4e33f7b578ea8 100644
--- a/cpp/src/arrow/compute/light_array_test.cc
+++ b/cpp/src/arrow/compute/light_array_test.cc
@@ -226,6 +226,66 @@ TEST(KeyColumnArray, SliceBool) {
   }
 }
 
+struct SliceTestCase {
+  int offset;
+  int length;
+  std::vector<std::string> expected;
+};
+
+template <typename OffsetType>
+void GenericTestSlice(const std::shared_ptr<DataType>& type, const char* json_data,
+                      const std::vector<SliceTestCase>& testCases) {
+  auto array = ArrayFromJSON(type, json_data);
+  KeyColumnArray kc_array =
+      ColumnArrayFromArrayData(array->data(), 0, array->length()).ValueOrDie();
+
+  for (const auto& testCase : testCases) {
+    ARROW_SCOPED_TRACE("Offset: ", testCase.offset, " Length: ", testCase.length);
+    KeyColumnArray sliced = kc_array.Slice(testCase.offset, testCase.length);
+
+    // Extract binary data from the sliced KeyColumnArray
+    std::vector<std::string> sliced_data;
+    const auto* offset_data = reinterpret_cast<const OffsetType*>(sliced.data(1));
+    const auto* string_data = reinterpret_cast<const char*>(sliced.data(2));
+
+    for (auto i = 0; i < testCase.length; ++i) {
+      auto start = offset_data[i];
+      auto end = offset_data[i + 1];
+      sliced_data.push_back(std::string(string_data + start, string_data + end));
+    }
+
+    // Compare the sliced values to the expected string
+    ASSERT_EQ(testCase.expected, sliced_data);
+  }
+}
+
+TEST(KeyColumnArray, SliceBinaryTest) {
+  const char* json_test_strings = R"(["Hello", "World", "Slice", "Binary", "Test"])";
+  std::vector<SliceTestCase> testCases = {
+      {0, 1, {"Hello"}},
+      {1, 1, {"World"}},
+      {2, 1, {"Slice"}},
+      {3, 1, {"Binary"}},
+      {4, 1, {"Test"}},
+      {0, 2, {"Hello", "World"}},
+      {1, 2, {"World", "Slice"}},
+      {2, 2, {"Slice", "Binary"}},
+      {3, 2, {"Binary", "Test"}},
+      {0, 3, {"Hello", "World", "Slice"}},
+      {1, 3, {"World", "Slice", "Binary"}},
+      {2, 3, {"Slice", "Binary", "Test"}},
+      {0, 4, {"Hello", "World", "Slice", "Binary"}},
+      {1, 4, {"World", "Slice", "Binary", "Test"}},
+      {0, 5, {"Hello", "World", "Slice", "Binary", "Test"}},
+  };
+
+  // Run tests with binary type
+  GenericTestSlice<int32_t>(binary(), json_test_strings, testCases);
+
+  // Run tests with large binary type
+  GenericTestSlice<int64_t>(large_binary(), json_test_strings, testCases);
+}
+
 TEST(ResizableArrayData, Basic) {
   std::unique_ptr<MemoryPool> pool = MemoryPool::CreateDefault();
   for (const auto& type : kSampleFixedDataTypes) {

From 93ca3b2fdfb813542b14759c4d918553500bc307 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 16 Oct 2023 06:05:57 -0300
Subject: [PATCH 556/749] GH-38263 [C++]: Prefer to call string_view::data()
 instead of begin() where a char pointer is expected (#38265)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

The MSVC compiler doesn't seem to allow user code to assume `std::string_view::const_iterator` is `const char*`, so using only `re2::StringPiece` and preferring to call `.data()` instead of `.begin()` should make things more uniform across different compilers and STL implementations.

### What changes are included in this PR?

 - Using `re2::StringPiece` instead of `std::string_view` to interact with `re2`
 - Use `data()` instead of `begin()` where a `char*` is expected

### Are these changes tested?

Yes, by existing tests.
* Closes: #38263

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 cpp/src/arrow/compute/kernels/scalar_string_ascii.cc | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
index a90a7282bb390..90f5d40b984f4 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
@@ -2063,12 +2063,12 @@ struct RegexSubstringReplacer {
         regex_find_("(" + options_.pattern + ")", MakeRE2Options<Type>()),
         regex_replacement_(options_.pattern, MakeRE2Options<Type>()) {}
 
-  Status ReplaceString(std::string_view s, TypedBufferBuilder<uint8_t>* builder) const {
+  Status ReplaceString(re2::StringPiece s, TypedBufferBuilder<uint8_t>* builder) const {
     re2::StringPiece replacement(options_.replacement);
 
     // If s is empty, then it's essentially global
     if (options_.max_replacements == -1 || s.empty()) {
-      std::string s_copy(s);
+      std::string s_copy{s.data(), s.length()};
       RE2::GlobalReplace(&s_copy, regex_replacement_, replacement);
       return builder->Append(reinterpret_cast<const uint8_t*>(s_copy.data()),
                              s_copy.length());
@@ -2079,18 +2079,18 @@ struct RegexSubstringReplacer {
     // We might do this faster similar to RE2::GlobalReplace using Match and Rewrite
     const char* i = s.data();
     const char* end = s.data() + s.length();
-    re2::StringPiece piece(s.data(), s.length());
+    re2::StringPiece mutable_s{s};
 
     int64_t max_replacements = options_.max_replacements;
     while ((i < end) && (max_replacements != 0)) {
       std::string found;
-      if (!RE2::FindAndConsume(&piece, regex_find_, &found)) {
+      if (!RE2::FindAndConsume(&mutable_s, regex_find_, &found)) {
         RETURN_NOT_OK(builder->Append(reinterpret_cast<const uint8_t*>(i),
                                       static_cast<int64_t>(end - i)));
         i = end;
       } else {
         // wind back to the beginning of the match
-        const char* pos = piece.begin() - found.length();
+        const char* pos = mutable_s.data() - found.length();
         // the string before the pattern
         RETURN_NOT_OK(builder->Append(reinterpret_cast<const uint8_t*>(i),
                                       static_cast<int64_t>(pos - i)));
@@ -2101,7 +2101,7 @@ struct RegexSubstringReplacer {
         RETURN_NOT_OK(builder->Append(reinterpret_cast<const uint8_t*>(found.data()),
                                       static_cast<int64_t>(found.length())));
         // skip pattern
-        i = piece.begin();
+        i = mutable_s.data();
         max_replacements--;
       }
     }

From 732d4000c803675e2c75069f0b08ac73806ce8be Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 16 Oct 2023 18:50:15 +0900
Subject: [PATCH 557/749] GH-38206: [CI] Remove more pre-installed files
 (#38233)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

We need more disk space...

### What changes are included in this PR?

Remove more pre-installed files.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38206

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 ci/scripts/util_free_space.sh | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/ci/scripts/util_free_space.sh b/ci/scripts/util_free_space.sh
index 54445d0d49172..acea074feec63 100755
--- a/ci/scripts/util_free_space.sh
+++ b/ci/scripts/util_free_space.sh
@@ -24,12 +24,19 @@ if [ "${GITHUB_ACTIONS}" = "true" ]; then
   echo "::group::/usr/local/*"
   du -hsc /usr/local/*
   echo "::endgroup::"
+  # ~1GB
+  sudo rm -rf \
+    /usr/local/aws-cli \
+    /usr/local/aws-sam-cil \
+    /usr/local/julia* || :
   echo "::group::/usr/local/bin/*"
   du -hsc /usr/local/bin/*
   echo "::endgroup::"
   # ~1GB (From 1.2GB to 214MB)
   sudo rm -rf \
     /usr/local/bin/aliyun \
+    /usr/local/bin/aws \
+    /usr/local/bin/aws_completer \
     /usr/local/bin/azcopy \
     /usr/local/bin/bicep \
     /usr/local/bin/cmake-gui \
@@ -41,16 +48,37 @@ if [ "${GITHUB_ACTIONS}" = "true" ]; then
     /usr/local/bin/node \
     /usr/local/bin/packer \
     /usr/local/bin/pulumi* \
+    /usr/local/bin/sam \
     /usr/local/bin/stack \
     /usr/local/bin/terraform || :
+  # 142M
+  sudo rm -rf /usr/local/bin/oc || : \
   echo "::group::/usr/local/share/*"
   du -hsc /usr/local/share/*
   echo "::endgroup::"
+  # 506MB
+  sudo rm -rf /usr/local/share/chromium || :
   # 1.3GB
   sudo rm -rf /usr/local/share/powershell || :
+  echo "::group::/usr/local/lib/*"
+  du -hsc /usr/local/lib/*
+  echo "::endgroup::"
+  # 15GB
+  sudo rm -rf /usr/local/lib/android || :
+  # 341MB
+  sudo rm -rf /usr/local/lib/heroku || :
+  # 1.2GB
+  sudo rm -rf /usr/local/lib/node_modules || :
   echo "::group::/opt/*"
   du -hsc /opt/*
   echo "::endgroup::"
+  # 679MB
+  sudo rm -rf /opt/az || :
+  echo "::group::/opt/microsoft/*"
+  du -hsc /opt/microsoft/*
+  echo "::endgroup::"
+  # 197MB
+  sudo rm -rf /opt/microsoft/powershell || :
   echo "::group::/opt/hostedtoolcache/*"
   du -hsc /opt/hostedtoolcache/*
   echo "::endgroup::"

From cbf1bb50875cc9716fccbb55b3d4cf9e8a33e4cd Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Mon, 16 Oct 2023 11:28:34 -0400
Subject: [PATCH 558/749] GH-38285: [Go] Slight deps and docs update (#38284)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
Making sure the documentation that shows up on pkg.go.dev will show that the package is compatible with go1.19+

### What changes are included in this PR?
slight patch/minor version updates of some dependencies along with a documentation update in `doc.go`.
* Closes: #38285

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 go/arrow/doc.go |  7 +++----
 go/go.mod       | 14 +++++++-------
 go/go.sum       | 28 ++++++++++++++--------------
 3 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/go/arrow/doc.go b/go/arrow/doc.go
index ad03f2eca8ca1..4a5f5a3c9ef72 100644
--- a/go/arrow/doc.go
+++ b/go/arrow/doc.go
@@ -22,16 +22,15 @@ language-independent columnar memory format for flat and hierarchical data, orga
 operations on modern hardware. It also provides computational libraries and zero-copy streaming
 messaging and inter-process communication.
 
-Basics
+# Basics
 
 The fundamental data structure in Arrow is an Array, which holds a sequence of values of the same type. An array
 consists of memory holding the data and an additional validity bitmap that indicates if the corresponding entry in the
 array is valid (not null). If the array has no null entries, it is possible to omit this bitmap.
 
-Requirements
+# Requirements
 
-Despite the go.mod stating go1.18, everything except for the compute package
-is able to be built with go1.17 (and most is also compatible with go1.16).
+Despite the go.mod stating go1.20, everything is able to be built with go1.19 or higher.
 
 To build with tinygo include the noasm build tag.
 */
diff --git a/go/go.mod b/go/go.mod
index 2f32ff7e42fde..bf685eef910ed 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -34,19 +34,19 @@ require (
 	github.com/pierrec/lz4/v4 v4.1.18
 	github.com/stretchr/testify v1.8.4
 	github.com/zeebo/xxh3 v1.0.2
-	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
-	golang.org/x/sync v0.3.0
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d
+	golang.org/x/sync v0.4.0
 	golang.org/x/sys v0.13.0
-	golang.org/x/tools v0.13.0
+	golang.org/x/tools v0.14.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gonum.org/v1/gonum v0.12.0
-	google.golang.org/grpc v1.54.0
+	google.golang.org/grpc v1.58.2
 	google.golang.org/protobuf v1.31.0
 	modernc.org/sqlite v1.21.2
 )
 
 require (
-	github.com/google/uuid v1.3.0
+	github.com/google/uuid v1.3.1
 	github.com/substrait-io/substrait-go v0.4.2
 )
 
@@ -65,10 +65,10 @@ require (
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rogpeppe/go-internal v1.9.0 // indirect
 	github.com/stretchr/objx v0.5.0 // indirect
-	golang.org/x/mod v0.12.0 // indirect
+	golang.org/x/mod v0.13.0 // indirect
 	golang.org/x/net v0.17.0 // indirect
 	golang.org/x/text v0.13.0 // indirect
-	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	lukechampine.com/uint128 v1.3.0 // indirect
 	modernc.org/cc/v3 v3.40.0 // indirect
diff --git a/go/go.sum b/go/go.sum
index 1a83f1fa106f5..d1e8884e7a2f6 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -35,8 +35,8 @@ github.com/google/flatbuffers v23.5.26+incompatible/go.mod h1:1AeVuKshWv4vARoZat
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
+github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
@@ -83,14 +83,14 @@ github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
 github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
 golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
-golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
-golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
-golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
+golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY=
+golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
 golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
+golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -98,17 +98,17 @@ golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
 golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
 golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/tools v0.13.0 h1:Iey4qkscZuv0VvIt8E0neZjtPVQFSc870HQ448QgEmQ=
-golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc=
+golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
 golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 gonum.org/v1/gonum v0.12.0 h1:xKuo6hzt+gMav00meVPUlXwSdoEJP46BR+wdxQEFK2o=
 gonum.org/v1/gonum v0.12.0/go.mod h1:73TDxJfAAHeA8Mk9mf8NlIppyhQNo5GLTcYeqgo2lvY=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU=
-google.golang.org/grpc v1.54.0 h1:EhTqbhiYeixwWQtAEZAxmV9MGqcjEU2mFx52xCzNyag=
-google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 h1:6GQBEOdGkX6MMTLT9V+TjtIRZCw9VPD5Z+yHY9wMgS0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY=
+google.golang.org/grpc v1.58.2 h1:SXUpjxeVF3FKrTYQI4f4KvbGD5u2xccdYdurwowix5I=
+google.golang.org/grpc v1.58.2/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=

From 20e120b2a71e7da7ecc5ed9b32c7b5ea9558fa00 Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 16 Oct 2023 09:24:23 -0700
Subject: [PATCH 559/749] GH-38061: [C#] Implement Duration support (#38062)

### What changes are included in this PR?

Complete support for the Duration array type in the C# implementation.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

The Duration array type is now supported in the C# library. This also
does some slight refactoring of classes which could impact edge cases of
user scenarios.
* Closes: #38061
---
 .../Arrays/ArrayDataTypeComparer.cs           |  18 +--
 .../Arrays/ArrowArrayBuilderFactory.cs        |   2 +
 .../Apache.Arrow/Arrays/ArrowArrayFactory.cs  |   2 +
 .../src/Apache.Arrow/Arrays/DurationArray.cs  |  84 +++++++++++
 csharp/src/Apache.Arrow/Arrays/Time64Array.cs |  19 +--
 .../Apache.Arrow/C/CArrowSchemaExporter.cs    |   3 +
 .../Apache.Arrow/C/CArrowSchemaImporter.cs    |   5 +-
 .../src/Apache.Arrow/Ipc/ArrowStreamWriter.cs |   2 +
 .../Ipc/ArrowTypeFlatbufferBuilder.cs         |   8 ++
 .../src/Apache.Arrow/Ipc/MessageSerializer.cs |   3 +
 .../src/Apache.Arrow/RecordBatch.Builder.cs   |   2 +
 csharp/src/Apache.Arrow/Types/DurationType.cs |  42 ++++++
 csharp/src/Apache.Arrow/Types/IArrowType.cs   |   1 +
 .../src/Apache.Arrow/Types/TimeBasedType.cs   |  27 ++++
 csharp/src/Apache.Arrow/Types/TimeType.cs     |  15 +-
 csharp/src/Apache.Arrow/Types/TimeUnit.cs     |  58 ++++++++
 .../src/Apache.Arrow/Types/TimestampType.cs   |   7 +-
 .../Apache.Arrow.IntegrationTest/JsonFile.cs  |  15 ++
 .../Apache.Arrow.Tests/ArrayTypeComparer.cs   |  18 +--
 .../ArrowArrayConcatenatorTests.cs            |  28 ++++
 .../Apache.Arrow.Tests/ArrowArrayTests.cs     |   2 +
 .../Apache.Arrow.Tests/ArrowReaderVerifier.cs |   2 +
 .../CDataInterfacePythonTests.cs              |  16 ++-
 .../Apache.Arrow.Tests/DurationArrayTests.cs  | 134 ++++++++++++++++++
 csharp/test/Apache.Arrow.Tests/TestData.cs    |  13 ++
 dev/archery/archery/integration/datagen.py    |   3 +-
 docs/source/status.rst                        |   2 +-
 27 files changed, 465 insertions(+), 66 deletions(-)
 create mode 100644 csharp/src/Apache.Arrow/Arrays/DurationArray.cs
 create mode 100644 csharp/src/Apache.Arrow/Types/DurationType.cs
 create mode 100644 csharp/src/Apache.Arrow/Types/TimeBasedType.cs
 create mode 100644 csharp/src/Apache.Arrow/Types/TimeUnit.cs
 create mode 100644 csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
index 1698e0672fb60..1abaa7f043b64 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrayDataTypeComparer.cs
@@ -13,7 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System;
 using Apache.Arrow.Types;
 
 namespace Apache.Arrow
@@ -22,8 +21,7 @@ internal sealed class ArrayDataTypeComparer :
         IArrowTypeVisitor<TimestampType>,
         IArrowTypeVisitor<Date32Type>,
         IArrowTypeVisitor<Date64Type>,
-        IArrowTypeVisitor<Time32Type>,
-        IArrowTypeVisitor<Time64Type>,
+        IArrowTypeVisitor<TimeBasedType>,
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
@@ -69,18 +67,10 @@ public void Visit(Date64Type actualType)
             }
         }
 
-        public void Visit(Time32Type actualType)
+        public void Visit(TimeBasedType actualType)
         {
-            if (_expectedType is Time32Type expectedType
-                && expectedType.Unit == actualType.Unit)
-            {
-                _dataTypeMatch = true;
-            }
-        }
-
-        public void Visit(Time64Type actualType)
-        {
-            if (_expectedType is Time64Type expectedType
+            if (_expectedType.TypeId == actualType.TypeId
+                && _expectedType is TimeBasedType expectedType
                 && expectedType.Unit == actualType.Unit)
             {
                 _dataTypeMatch = true;
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
index 1b972d01874ca..af5a524798396 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayBuilderFactory.cs
@@ -66,6 +66,8 @@ internal static IArrowArrayBuilder<IArrowArray, IArrowArrayBuilder<IArrowArray>>
                     return new Time32Array.Builder(dataType as Time32Type);
                 case ArrowTypeId.Time64:
                     return new Time64Array.Builder(dataType as Time64Type);
+                case ArrowTypeId.Duration:
+                    return new DurationArray.Builder(dataType as DurationType);
                 case ArrowTypeId.List:
                     return new ListArray.Builder(dataType as ListType);
                 case ArrowTypeId.FixedSizeList:
diff --git a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
index d3b7d65185abe..0520513334db3 100644
--- a/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
+++ b/csharp/src/Apache.Arrow/Arrays/ArrowArrayFactory.cs
@@ -73,6 +73,8 @@ public static IArrowArray BuildArray(ArrayData data)
                     return new Time32Array(data);
                 case ArrowTypeId.Time64:
                     return new Time64Array(data);
+                case ArrowTypeId.Duration:
+                    return new DurationArray(data);
                 case ArrowTypeId.Decimal128:
                     return new Decimal128Array(data);
                 case ArrowTypeId.Decimal256:
diff --git a/csharp/src/Apache.Arrow/Arrays/DurationArray.cs b/csharp/src/Apache.Arrow/Arrays/DurationArray.cs
new file mode 100644
index 0000000000000..3649dda50cd97
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Arrays/DurationArray.cs
@@ -0,0 +1,84 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using Apache.Arrow.Types;
+
+namespace Apache.Arrow
+{
+    public class DurationArray : PrimitiveArray<long>
+    {
+        public class Builder : PrimitiveArrayBuilder<long, DurationArray, Builder>
+        {
+            public DurationType DataType { get; }
+
+            public Builder(DurationType dataType)
+            {
+                DataType = dataType;
+            }
+
+            protected override DurationArray Build(
+                ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
+                int length, int nullCount, int offset) =>
+                new DurationArray(DataType, valueBuffer, nullBitmapBuffer, length, nullCount, offset);
+
+            /// <summary>
+            /// Append a duration in the form of a <see cref="TimeSpan"/> object to the array.
+            /// </summary>
+            /// <param name="value">TimeSpan to add.</param>
+            /// <returns>Returns the builder (for fluent-style composition).</returns>
+            public Builder Append(TimeSpan value)
+            {
+                Append(DataType.Unit.ConvertFromTicks(value.Ticks));
+                return this;
+            }
+
+            /// <summary>
+            /// Append a duration in the form of a <see cref="TimeSpan"/> object to the array.
+            /// </summary>
+            /// <param name="value">TimeSpan to add.</param>
+            /// <returns>Returns the builder (for fluent-style composition).</returns>
+            public Builder Append(TimeSpan? value) =>
+                (value == null) ? AppendNull() : Append(value.Value);
+        }
+
+        public DurationArray(
+            DurationType type,
+            ArrowBuffer valueBuffer, ArrowBuffer nullBitmapBuffer,
+            int length, int nullCount, int offset)
+            : this(new ArrayData(type, length, nullCount, offset,
+                new[] { nullBitmapBuffer, valueBuffer }))
+        { }
+
+        public DurationArray(ArrayData data)
+            : base(data)
+        {
+            data.EnsureDataType(ArrowTypeId.Duration);
+        }
+
+        public DurationType DataType => (DurationType)this.Data.DataType;
+
+        public TimeSpan? GetTimeSpan(int index)
+        {
+            if (index < 0 || index >= Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+            return IsValid(index) ? new TimeSpan(DataType.Unit.ConvertToTicks(Values[index])) : null;
+        }
+
+        public override void Accept(IArrowArrayVisitor visitor) => Accept(this, visitor);
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
index 9fc2ae4be1563..3369893304414 100644
--- a/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Time64Array.cs
@@ -25,9 +25,6 @@ namespace Apache.Arrow
     /// </summary>
     public class Time64Array : PrimitiveArray<long>
     {
-        private const long TicksPerMicrosecond = 10;
-        private const long NanosecondsPerTick = 100;
-
         /// <summary>
         /// The <see cref="Builder"/> class can be used to fluently build <see cref="Time64Array"/> objects.
         /// </summary>
@@ -62,13 +59,7 @@ public Builder(Time64Type type)
 #if NET6_0_OR_GREATER
             protected override long Convert(TimeOnly time)
             {
-                var unit = ((TimeBuilder)InnerBuilder).DataType.Unit;
-                return unit switch
-                {
-                    TimeUnit.Microsecond => (long)(time.Ticks / TicksPerMicrosecond),
-                    TimeUnit.Nanosecond => (long)(time.Ticks * NanosecondsPerTick),
-                    _ => throw new InvalidDataException($"Unsupported time unit for Time32Type: {unit}")
-                };
+                return ((TimeBuilder)InnerBuilder).DataType.Unit.ConvertFromTicks(time.Ticks);
             }
 #endif
         }
@@ -153,13 +144,7 @@ public Time64Array(ArrayData data)
                 return null;
             }
 
-            var unit = ((Time64Type)Data.DataType).Unit;
-            return unit switch
-            {
-                TimeUnit.Microsecond => new TimeOnly(value.Value * TicksPerMicrosecond),
-                TimeUnit.Nanosecond => new TimeOnly(value.Value / NanosecondsPerTick),
-                _ => throw new InvalidDataException($"Unsupported time unit for Time64Type: {unit}")
-            };
+            return new TimeOnly(((Time64Type)Data.DataType).Unit.ConvertToTicks(value.Value));
         }
 #endif
     }
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
index f3479903889d1..d805e9afc4c8b 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaExporter.cs
@@ -179,6 +179,9 @@ private static string GetFormat(IArrowType datatype)
                 case Time64Type timeType:
                     // Same prefix as Time32, but allowed time units are different.
                     return String.Format("tt{0}", FormatTimeUnit(timeType.Unit));
+                // Duration
+                case DurationType durationType:
+                    return String.Format("tD{0}", FormatTimeUnit(durationType.Unit));
                 // Timestamp
                 case TimestampType timestampType:
                     return String.Format("ts{0}:{1}", FormatTimeUnit(timestampType.Unit), timestampType.Timezone);
diff --git a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
index f2a08f5e4a40b..12545c9831a04 100644
--- a/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
+++ b/csharp/src/Apache.Arrow/C/CArrowSchemaImporter.cs
@@ -313,7 +313,10 @@ public ArrowType GetAsType()
                     "ttm" => TimeType.Millisecond,
                     "ttu" => TimeType.Microsecond,
                     "ttn" => TimeType.Nanosecond,
-                    // TODO: duration not yet implemented
+                    "tDs" => DurationType.Second,
+                    "tDm" => DurationType.Millisecond,
+                    "tDu" => DurationType.Microsecond,
+                    "tDn" => DurationType.Nanosecond,
                     "tiM" => IntervalType.YearMonth,
                     "tiD" => IntervalType.DayTime,
                     //"tin" => IntervalType.MonthDayNanosecond, // Not yet implemented
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
index 2b3815af71142..dcb8852bc1f65 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowStreamWriter.cs
@@ -49,6 +49,7 @@ internal class ArrowRecordBatchFlatBufferBuilder :
             IArrowArrayVisitor<Date64Array>,
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
+            IArrowArrayVisitor<DurationArray>,
             IArrowArrayVisitor<ListArray>,
             IArrowArrayVisitor<FixedSizeListArray>,
             IArrowArrayVisitor<StringArray>,
@@ -104,6 +105,7 @@ public ArrowRecordBatchFlatBufferBuilder()
             public void Visit(Date64Array array) => CreateBuffers(array);
             public void Visit(Time32Array array) => CreateBuffers(array);
             public void Visit(Time64Array array) => CreateBuffers(array);
+            public void Visit(DurationArray array) => CreateBuffers(array);
 
             public void Visit(ListArray array)
             {
diff --git a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
index 425d9326addfe..1397eb3e00f3c 100644
--- a/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
+++ b/csharp/src/Apache.Arrow/Ipc/ArrowTypeFlatbufferBuilder.cs
@@ -57,6 +57,7 @@ class TypeVisitor :
             IArrowTypeVisitor<Date64Type>,
             IArrowTypeVisitor<Time32Type>,
             IArrowTypeVisitor<Time64Type>,
+            IArrowTypeVisitor<DurationType>,
             IArrowTypeVisitor<BinaryType>,
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<ListType>,
@@ -188,6 +189,13 @@ public void Visit(Time64Type type)
                     Flatbuf.Time.CreateTime(Builder, ToFlatBuffer(type.Unit), 64));
             }
 
+            public void Visit(DurationType type)
+            {
+                Result = FieldType.Build(
+                    Flatbuf.Type.Duration,
+                    Flatbuf.Duration.CreateDuration(Builder, ToFlatBuffer(type.Unit)));
+            }
+
             public void Visit(StructType type)
             {
                 Flatbuf.Struct_.StartStruct_(Builder);
diff --git a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
index 9847c376cf82e..3f504cf3b975a 100644
--- a/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
+++ b/csharp/src/Apache.Arrow/Ipc/MessageSerializer.cs
@@ -177,6 +177,9 @@ private static Types.IArrowType GetFieldArrowType(Flatbuf.Field field, Field[] c
                     Types.TimeUnit unit = timestampTypeMetadata.Unit.ToArrow();
                     string timezone = timestampTypeMetadata.Timezone;
                     return new Types.TimestampType(unit, timezone);
+                case Flatbuf.Type.Duration:
+                    Flatbuf.Duration durationMeta = field.Type<Flatbuf.Duration>().Value;
+                    return DurationType.FromTimeUnit(durationMeta.Unit.ToArrow());
                 case Flatbuf.Type.Interval:
                     Flatbuf.Interval intervalMetadata = field.Type<Flatbuf.Interval>().Value;
                     return Types.IntervalType.FromIntervalUnit(intervalMetadata.Unit.ToArrow());
diff --git a/csharp/src/Apache.Arrow/RecordBatch.Builder.cs b/csharp/src/Apache.Arrow/RecordBatch.Builder.cs
index b5d5ec9ea0bbf..8e0d17ae06f49 100644
--- a/csharp/src/Apache.Arrow/RecordBatch.Builder.cs
+++ b/csharp/src/Apache.Arrow/RecordBatch.Builder.cs
@@ -63,6 +63,8 @@ public Time32Array Time32(Time32Type type, Action<Time32Array.Builder> action) =
             public Time64Array Time64(Time64Type type, Action<Time64Array.Builder> action) =>
                 Build<Time64Array, Time64Array.Builder>(
                     new Time64Array.Builder(type), action);
+            public DurationArray Duration(DurationType type, Action<DurationArray.Builder> action) =>
+                Build<DurationArray, DurationArray.Builder>(new DurationArray.Builder(type), action);
             public BinaryArray Binary(Action<BinaryArray.Builder> action) => Build<BinaryArray, BinaryArray.Builder>(new BinaryArray.Builder(), action);
             public StringArray String(Action<StringArray.Builder> action) => Build<StringArray, StringArray.Builder>(new StringArray.Builder(), action);
             public TimestampArray Timestamp(Action<TimestampArray.Builder> action) => Build<TimestampArray, TimestampArray.Builder>(new TimestampArray.Builder(), action);
diff --git a/csharp/src/Apache.Arrow/Types/DurationType.cs b/csharp/src/Apache.Arrow/Types/DurationType.cs
new file mode 100644
index 0000000000000..7e937a6e72e0b
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Types/DurationType.cs
@@ -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.
+
+namespace Apache.Arrow.Types
+{
+    public sealed class DurationType : TimeBasedType
+    {
+        public static readonly DurationType Second = new DurationType(TimeUnit.Second);
+        public static readonly DurationType Millisecond = new DurationType(TimeUnit.Millisecond);
+        public static readonly DurationType Microsecond = new DurationType(TimeUnit.Microsecond);
+        public static readonly DurationType Nanosecond = new DurationType(TimeUnit.Nanosecond);
+        private static readonly DurationType[] _types = new DurationType[] { Second, Millisecond, Microsecond, Nanosecond };
+
+        private DurationType(TimeUnit unit)
+            : base(unit)
+        {
+        }
+
+        public override ArrowTypeId TypeId => ArrowTypeId.Duration;
+        public override string Name => "duration";
+        public override int BitWidth => 64;
+
+        public static DurationType FromTimeUnit(TimeUnit unit)
+        {
+            return _types[(int)unit];
+        }
+
+        public override void Accept(IArrowTypeVisitor visitor) => Accept(this, visitor);
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Types/IArrowType.cs b/csharp/src/Apache.Arrow/Types/IArrowType.cs
index 447db47329829..cdf423e56f7a8 100644
--- a/csharp/src/Apache.Arrow/Types/IArrowType.cs
+++ b/csharp/src/Apache.Arrow/Types/IArrowType.cs
@@ -48,6 +48,7 @@ public enum ArrowTypeId
         Dictionary,
         Map,
         FixedSizeList,
+        Duration,
     }
 
     public interface IArrowType
diff --git a/csharp/src/Apache.Arrow/Types/TimeBasedType.cs b/csharp/src/Apache.Arrow/Types/TimeBasedType.cs
new file mode 100644
index 0000000000000..ffcd3f5a7ab63
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Types/TimeBasedType.cs
@@ -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.
+
+namespace Apache.Arrow.Types
+{
+    public abstract class TimeBasedType : FixedWidthType
+    {
+        public TimeUnit Unit { get; }
+
+        protected TimeBasedType(TimeUnit unit)
+        {
+            Unit = unit;
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Types/TimeType.cs b/csharp/src/Apache.Arrow/Types/TimeType.cs
index 48c7fdb5f1bea..b317df265d56f 100644
--- a/csharp/src/Apache.Arrow/Types/TimeType.cs
+++ b/csharp/src/Apache.Arrow/Types/TimeType.cs
@@ -13,18 +13,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-
 namespace Apache.Arrow.Types
 {
-    public enum TimeUnit
-    {
-        Second,
-        Millisecond,
-        Microsecond,
-        Nanosecond
-    }
-
-    public abstract class TimeType: FixedWidthType
+    public abstract class TimeType : TimeBasedType
     {
         public static readonly Time32Type Second = new Time32Type(TimeUnit.Second);
         public static readonly Time32Type Millisecond = new Time32Type(TimeUnit.Millisecond);
@@ -32,11 +23,9 @@ public abstract class TimeType: FixedWidthType
         public static readonly Time64Type Nanosecond = new Time64Type(TimeUnit.Nanosecond);
         private static readonly TimeType[] _types = new TimeType[] { Second, Millisecond, Microsecond, Nanosecond };
 
-        public TimeUnit Unit { get; }
-
         protected TimeType(TimeUnit unit)
+            : base(unit)
         {
-            Unit = unit;
         }
 
         public static TimeType FromTimeUnit(TimeUnit unit)
diff --git a/csharp/src/Apache.Arrow/Types/TimeUnit.cs b/csharp/src/Apache.Arrow/Types/TimeUnit.cs
new file mode 100644
index 0000000000000..ba60fa9bb8371
--- /dev/null
+++ b/csharp/src/Apache.Arrow/Types/TimeUnit.cs
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to You under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.IO;
+using System;
+
+namespace Apache.Arrow.Types
+{
+    public enum TimeUnit
+    {
+        Second,
+        Millisecond,
+        Microsecond,
+        Nanosecond
+    }
+
+    internal static class TimeUnitExtensions
+    {
+        private const long TicksPerMicrosecond = 10;
+        private const long NanosecondsPerTick = 100;
+
+        public static long ConvertFromTicks(this TimeUnit unit, long ticks)
+        {
+            return unit switch
+            {
+                TimeUnit.Second => ticks / TimeSpan.TicksPerSecond,
+                TimeUnit.Millisecond => ticks / TimeSpan.TicksPerMillisecond,
+                TimeUnit.Microsecond => ticks / TicksPerMicrosecond,
+                TimeUnit.Nanosecond => ticks * NanosecondsPerTick,
+                _ => throw new InvalidDataException($"Unsupported time unit: {unit}")
+            };
+        }
+
+        public static long ConvertToTicks(this TimeUnit unit, long units)
+        {
+            return unit switch
+            {
+                TimeUnit.Second => units * TimeSpan.TicksPerSecond,
+                TimeUnit.Millisecond => units * TimeSpan.TicksPerMillisecond,
+                TimeUnit.Microsecond => units * TicksPerMicrosecond,
+                TimeUnit.Nanosecond => units / NanosecondsPerTick,
+                _ => throw new InvalidDataException($"Unsupported time unit: {unit}")
+            };
+        }
+    }
+}
diff --git a/csharp/src/Apache.Arrow/Types/TimestampType.cs b/csharp/src/Apache.Arrow/Types/TimestampType.cs
index 66b6ca60971cb..565eb62bb799b 100644
--- a/csharp/src/Apache.Arrow/Types/TimestampType.cs
+++ b/csharp/src/Apache.Arrow/Types/TimestampType.cs
@@ -18,7 +18,7 @@
 
 namespace Apache.Arrow.Types
 {
-    public sealed class TimestampType : FixedWidthType
+    public sealed class TimestampType : TimeBasedType
     {
         public static readonly TimestampType Default = new TimestampType(TimeUnit.Millisecond, "+00:00");
 
@@ -26,7 +26,6 @@ public sealed class TimestampType : FixedWidthType
         public override string Name => "timestamp";
         public override int BitWidth => 64;
 
-        public TimeUnit Unit { get; }
         public string Timezone { get; }
 
         public bool IsTimeZoneAware => !string.IsNullOrWhiteSpace(Timezone);
@@ -34,16 +33,16 @@ public sealed class TimestampType : FixedWidthType
         public TimestampType(
             TimeUnit unit = TimeUnit.Millisecond,
             string timezone = default)
+            : base(unit)
         {
-            Unit = unit;
             Timezone = timezone;
         }
 
         public TimestampType(
             TimeUnit unit = TimeUnit.Millisecond,
             TimeZoneInfo timezone = default)
+            : base(unit)
         {
-            Unit = unit;
             Timezone = timezone?.BaseUtcOffset.ToTimeZoneOffsetString();
         }
 
diff --git a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
index d06249bef2661..987a236a10191 100644
--- a/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
+++ b/csharp/test/Apache.Arrow.IntegrationTest/JsonFile.cs
@@ -119,6 +119,7 @@ private static IArrowType ToArrowType(JsonArrowType type, Field[] children)
                 "fixedsizebinary" => new FixedSizeBinaryType(type.ByteWidth),
                 "date" => ToDateArrowType(type),
                 "time" => ToTimeArrowType(type),
+                "duration" => ToDurationArrowType(type),
                 "timestamp" => ToTimestampArrowType(type),
                 "list" => ToListArrowType(type, children),
                 "fixedsizelist" => ToFixedSizeListArrowType(type, children),
@@ -191,6 +192,18 @@ private static IArrowType ToTimeArrowType(JsonArrowType type)
             };
         }
 
+        private static IArrowType ToDurationArrowType(JsonArrowType type)
+        {
+            return type.Unit switch
+            {
+                "SECOND" => DurationType.Second,
+                "MILLISECOND" => DurationType.Millisecond,
+                "MICROSECOND" => DurationType.Microsecond,
+                "NANOSECOND" => DurationType.Nanosecond,
+                _ => throw new NotSupportedException($"Time type not supported: {type.Unit}, {type.BitWidth}")
+            };
+        }
+
         private static IArrowType ToTimestampArrowType(JsonArrowType type)
         {
             return type.Unit switch
@@ -346,6 +359,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<Date64Type>,
             IArrowTypeVisitor<Time32Type>,
             IArrowTypeVisitor<Time64Type>,
+            IArrowTypeVisitor<DurationType>,
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<StringType>,
             IArrowTypeVisitor<BinaryType>,
@@ -396,6 +410,7 @@ public void Visit(BooleanType type)
             public void Visit(DoubleType type) => GenerateArray<double, DoubleArray>((v, n, c, nc, o) => new DoubleArray(v, n, c, nc, o));
             public void Visit(Time32Type type) => GenerateArray<int, Time32Array>((v, n, c, nc, o) => new Time32Array(type, v, n, c, nc, o));
             public void Visit(Time64Type type) => GenerateLongArray<long, Time64Array>((v, n, c, nc, o) => new Time64Array(type, v, n, c, nc, o), s => long.Parse(s));
+            public void Visit(DurationType type) => GenerateLongArray<long, DurationArray>((v, n, c, nc, o) => new DurationArray(type, v, n, c, nc, o), s => long.Parse(s));
 
             public void Visit(Decimal128Type type)
             {
diff --git a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
index ad3527c47807b..ceeffe42c6297 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrayTypeComparer.cs
@@ -23,8 +23,7 @@ public class ArrayTypeComparer :
         IArrowTypeVisitor<TimestampType>,
         IArrowTypeVisitor<Date32Type>,
         IArrowTypeVisitor<Date64Type>,
-        IArrowTypeVisitor<Time32Type>,
-        IArrowTypeVisitor<Time64Type>,
+        IArrowTypeVisitor<TimeBasedType>,
         IArrowTypeVisitor<FixedSizeBinaryType>,
         IArrowTypeVisitor<ListType>,
         IArrowTypeVisitor<FixedSizeListType>,
@@ -66,18 +65,11 @@ public void Visit(Date64Type actualType)
             Assert.Equal(expectedType.Unit, actualType.Unit);
         }
 
-        public void Visit(Time32Type actualType)
+        public void Visit(TimeBasedType actualType)
         {
-            Assert.IsAssignableFrom<Time32Type>(_expectedType);
-            var expectedType = (Time32Type)_expectedType;
-
-            Assert.Equal(expectedType.Unit, actualType.Unit);
-        }
-
-        public void Visit(Time64Type actualType)
-        {
-            Assert.IsAssignableFrom<Time64Type>(_expectedType);
-            var expectedType = (Time64Type)_expectedType;
+            Assert.IsAssignableFrom<TimeBasedType>(_expectedType);
+            Assert.Equal(_expectedType.TypeId, actualType.TypeId);
+            var expectedType = (TimeBasedType)_expectedType;
 
             Assert.Equal(expectedType.Unit, actualType.Unit);
         }
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
index 6f4c17a959981..1d108d2123c10 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayConcatenatorTests.cs
@@ -125,6 +125,7 @@ private class TestDataGenerator :
             IArrowTypeVisitor<Decimal256Type>,
             IArrowTypeVisitor<Date32Type>,
             IArrowTypeVisitor<Date64Type>,
+            IArrowTypeVisitor<DurationType>,
             IArrowTypeVisitor<TimestampType>,
             IArrowTypeVisitor<ListType>,
             IArrowTypeVisitor<FixedSizeListType>,
@@ -252,6 +253,33 @@ public void Visit(TimestampType type)
                 ExpectedArray = resultBuilder.Build();
             }
 
+            public void Visit(DurationType type)
+            {
+                DurationArray.Builder resultBuilder = new DurationArray.Builder(type).Reserve(_baseDataTotalElementCount);
+                DateTimeOffset basis = DateTimeOffset.UtcNow;
+
+                for (int i = 0; i < _baseDataListCount; i++)
+                {
+                    List<int?> dataList = _baseData[i];
+                    DurationArray.Builder builder = new DurationArray.Builder(type).Reserve(dataList.Count);
+                    foreach (int? value in dataList)
+                    {
+                        if (value.HasValue)
+                        {
+                            builder.Append(value.Value);
+                            resultBuilder.Append(value.Value);
+                        }
+                        else
+                        {
+                            builder.AppendNull();
+                            resultBuilder.AppendNull();
+                        }
+                    }
+                    TestTargetArrayList.Add(builder.Build());
+                }
+
+                ExpectedArray = resultBuilder.Build();
+            }
 
             public void Visit(BinaryType type)
             {
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
index d4f0d8dfd0383..96918ff091639 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowArrayTests.cs
@@ -200,6 +200,7 @@ private class ArraySliceValidator :
             IArrowArrayVisitor<Date64Array>,
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
+            IArrowArrayVisitor<DurationArray>,
 #if NET5_0_OR_GREATER
             IArrowArrayVisitor<HalfFloatArray>,
 #endif
@@ -243,6 +244,7 @@ public void Visit(Date64Array array)
             }
             public void Visit(Time32Array array) => ValidateArrays(array);
             public void Visit(Time64Array array) => ValidateArrays(array);
+            public void Visit(DurationArray array) => ValidateArrays(array);
 
 #if NET5_0_OR_GREATER
             public void Visit(HalfFloatArray array) => ValidateArrays(array);
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
index 8b41763a70ac8..75d62b25d7b88 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowReaderVerifier.cs
@@ -85,6 +85,7 @@ private class ArrayComparer :
             IArrowArrayVisitor<Date64Array>,
             IArrowArrayVisitor<Time32Array>,
             IArrowArrayVisitor<Time64Array>,
+            IArrowArrayVisitor<DurationArray>,
             IArrowArrayVisitor<ListArray>,
             IArrowArrayVisitor<FixedSizeListArray>,
             IArrowArrayVisitor<StringArray>,
@@ -127,6 +128,7 @@ public ArrayComparer(IArrowArray expectedArray, bool strictCompare)
             public void Visit(Date64Array array) => CompareArrays(array);
             public void Visit(Time32Array array) => CompareArrays(array);
             public void Visit(Time64Array array) => CompareArrays(array);
+            public void Visit(DurationArray array) => CompareArrays(array);
             public void Visit(ListArray array) => CompareArrays(array);
             public void Visit(FixedSizeListArray array) => CompareArrays(array);
             public void Visit(FixedSizeBinaryArray array) => CompareArrays(array);
diff --git a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
index 7aee37b8212c3..4efa94e8c7363 100644
--- a/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/CDataInterfacePythonTests.cs
@@ -117,6 +117,11 @@ private static Schema GetTestSchema()
 
                     .Field(f => f.Name("map").DataType(new MapType(StringType.Default, Int32Type.Default)).Nullable(false))
 
+                    .Field(f => f.Name("duration_s").DataType(DurationType.Second).Nullable(false))
+                    .Field(f => f.Name("duration_ms").DataType(DurationType.Millisecond).Nullable(true))
+                    .Field(f => f.Name("duration_us").DataType(DurationType.Microsecond).Nullable(false))
+                    .Field(f => f.Name("duration_ns").DataType(DurationType.Nanosecond).Nullable(true))
+
                     // Checking wider characters.
                     .Field(f => f.Name("hello 你好 😄").DataType(BooleanType.Default).Nullable(true))
 
@@ -182,6 +187,11 @@ private static IEnumerable<dynamic> GetPythonFields()
 
                 yield return pa.field("map", pa.map_(pa.@string(), pa.int32()), false);
 
+                yield return pa.field("duration_s", pa.duration("s"), false);
+                yield return pa.field("duration_ms", pa.duration("ms"), true);
+                yield return pa.field("duration_us", pa.duration("us"), false);
+                yield return pa.field("duration_ns", pa.duration("ns"), true);
+
                 yield return pa.field("hello 你好 😄", pa.bool_(), true);
             }
         }
@@ -520,8 +530,9 @@ public unsafe void ImportRecordBatch()
                             List(0, 0, 1, 2, 4, 10),
                             pa.array(List("one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten")),
                             pa.array(List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))),
+                        pa.array(List(1234, 2345, 3456, null, 6789), pa.duration("ms")),
                     }),
-                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9", "col10" });
+                    new[] { "col1", "col2", "col3", "col4", "col5", "col6", "col7", "col8", "col9", "col10", "col11" });
 
                 dynamic batch = table.to_batches()[0];
 
@@ -598,6 +609,9 @@ public unsafe void ImportRecordBatch()
             Assert.Equal(5, col10.Length);
             Assert.Equal(new int[] { 0, 0, 1, 2, 4, 10}, col10.ValueOffsets.ToArray());
             Assert.Equal(new long?[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, ((Int64Array)col10.Values).ToList().ToArray());
+
+            DurationArray col11 = (DurationArray)recordBatch.Column("col11");
+            Assert.Equal(5, col11.Length);
         }
 
         [SkippableFact]
diff --git a/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs b/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs
new file mode 100644
index 0000000000000..0890d356b8e90
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs
@@ -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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Apache.Arrow.Types;
+using Xunit;
+
+namespace Apache.Arrow.Tests
+{
+    public class DurationArrayTests
+    {
+        private const long TicksPerMicrosecond = 10;
+
+        private static readonly TimeSpan?[] _exampleTimeSpans =
+        {
+            null,
+            TimeSpan.FromDays(10.5),
+            TimeSpan.FromHours(10.5),
+            TimeSpan.FromMinutes(10.5),
+            TimeSpan.FromSeconds(10.5),
+            TimeSpan.FromMilliseconds(10.5),
+            TimeSpan.FromTicks(11),
+        };
+
+        private static readonly long?[] _exampleDurations =
+        {
+            null,
+            1,
+            1000,
+            1000000,
+            1000000000,
+            1000000000000,
+        };
+
+        private static readonly DurationType[] _durationTypes =
+        {
+            DurationType.Second,
+            DurationType.Millisecond,
+            DurationType.Microsecond,
+            DurationType.Nanosecond,
+        };
+
+        public static IEnumerable<object[]> GetTimeSpansData() =>
+            from timeSpan in _exampleTimeSpans
+            from type in _durationTypes
+            where type.Unit >= RequiredPrecision(timeSpan)
+            select new object[] { timeSpan, type };
+
+        public static IEnumerable<object[]> GetDurationsData() =>
+            from duration in _exampleDurations
+            from type in _durationTypes
+            select new object[] { duration, type };
+
+        static TimeUnit RequiredPrecision(TimeSpan? timeSpan)
+        {
+            if (timeSpan == null) { return TimeUnit.Second; }
+            if ((timeSpan.Value.Ticks % TicksPerMicrosecond) > 0) { return TimeUnit.Nanosecond; }
+            if (timeSpan.Value.Microseconds > 0) { return TimeUnit.Microsecond; }
+            if (timeSpan.Value.Milliseconds > 0) { return TimeUnit.Millisecond; }
+            return TimeUnit.Second;
+        }
+
+        public class AppendNull
+        {
+            [Fact]
+            public void AppendThenGetGivesNull()
+            {
+                // Arrange
+                var builder = new DurationArray.Builder(DurationType.Millisecond);
+
+                // Act
+                builder = builder.AppendNull();
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Null(array.GetValue(0));
+                Assert.Null(array.GetTimeSpan(0));
+            }
+        }
+
+        public class AppendTimeSpan
+        {
+            [Theory]
+            [MemberData(nameof(GetTimeSpansData), MemberType = typeof(DurationArrayTests))]
+            public void AppendTimeSpanGivesSameTimeSpan(TimeSpan? timeSpan, DurationType type)
+            {
+                // Arrange
+                var builder = new DurationArray.Builder(type);
+
+                // Act
+                builder = builder.Append(timeSpan);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(timeSpan, array.GetTimeSpan(0));
+            }
+        }
+
+        public class AppendDuration
+        {
+            [Theory]
+            [MemberData(nameof(GetDurationsData), MemberType = typeof(DurationArrayTests))]
+            public void AppendDurationGivesSameDuration(long? duration, DurationType type)
+            {
+                // Arrange
+                var builder = new DurationArray.Builder(type);
+
+                // Act
+                builder = builder.Append(duration);
+
+                // Assert
+                var array = builder.Build();
+                Assert.Equal(1, array.Length);
+                Assert.Equal(duration, array.GetValue(0));
+            }
+        }
+    }
+}
diff --git a/csharp/test/Apache.Arrow.Tests/TestData.cs b/csharp/test/Apache.Arrow.Tests/TestData.cs
index e3a40dbdafd61..3af6efb97b437 100644
--- a/csharp/test/Apache.Arrow.Tests/TestData.cs
+++ b/csharp/test/Apache.Arrow.Tests/TestData.cs
@@ -113,6 +113,7 @@ private class ArrayCreator :
             IArrowTypeVisitor<Date64Type>,
             IArrowTypeVisitor<Time32Type>,
             IArrowTypeVisitor<Time64Type>,
+            IArrowTypeVisitor<DurationType>,
             IArrowTypeVisitor<Int8Type>,
             IArrowTypeVisitor<Int16Type>,
             IArrowTypeVisitor<Int32Type>,
@@ -233,6 +234,18 @@ public void Visit(Time64Type type)
                 Array = builder.Build();
             }
 
+            public void Visit(DurationType type)
+            {
+                var builder = new DurationArray.Builder(type).Reserve(Length);
+
+                for (var i = 0; i < Length; i++)
+                {
+                    builder.Append(i);
+                }
+
+                Array = builder.Build();
+            }
+
             public void Visit(TimestampType type)
             {
                 var builder = new TimestampArray.Builder().Reserve(Length);
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 01672fbe7488a..f229012366e1f 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1804,8 +1804,7 @@ def _temp_path():
 
         generate_datetime_case(),
 
-        generate_duration_case()
-        .skip_tester('C#'),
+        generate_duration_case(),
 
         generate_interval_case()
         .skip_tester('C#')
diff --git a/docs/source/status.rst b/docs/source/status.rst
index 6024c1d3172bb..c8c0e6dfc1dfe 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -54,7 +54,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Timestamp         | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Duration          | ✓     | ✓     | ✓     | ✓          |       |  ✓    | ✓     |       |
+| Duration          | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Interval          | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+

From ded3295cb6a29fe571e8cd9371746f59a05ba0e7 Mon Sep 17 00:00:00 2001
From: Paul Spangler <7519484+spanglerco@users.noreply.github.com>
Date: Mon, 16 Oct 2023 11:43:15 -0500
Subject: [PATCH 560/749] GH-37861: [C#] Fix StringArray.GetString returning
 null instead of empty (#37862)

### Rationale for this change

Fixes #37861.

### What changes are included in this PR?

Add `BinaryArray.GetBytes(int, out bool)` overload that enables
`StringArray.GetString` to reliably determine if the value is null or
empty without needing an additional call to `IsNull`.

### Are these changes tested?

Added a test for `StringArray.GetString` (which didn't appear to have
any existing tests). Two of the cases fail without this change. I also
updated the tests that call `BinaryArray.GetBytes` to use the new
overload instead of a separate call to `IsNull` as extra validation.

### Are there any user-facing changes?

New public overload to an existing API.
* Closes: #37861
---
 csharp/src/Apache.Arrow/Arrays/BinaryArray.cs | 20 +++++--
 csharp/src/Apache.Arrow/Arrays/StringArray.cs |  6 +--
 .../BinaryArrayBuilderTests.cs                |  3 +-
 .../Apache.Arrow.Tests/StringArrayTests.cs    | 54 +++++++++++++++++++
 4 files changed, 75 insertions(+), 8 deletions(-)
 create mode 100644 csharp/test/Apache.Arrow.Tests/StringArrayTests.cs

diff --git a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
index 20fe0342cca40..a7ddb14af6a10 100644
--- a/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/BinaryArray.cs
@@ -331,20 +331,33 @@ public int GetValueLength(int index)
         /// <remarks>
         /// Note that this method cannot reliably identify null values, which are indistinguishable from empty byte
         /// collection values when seen in the context of this method's return type of <see cref="ReadOnlySpan{Byte}"/>.
-        /// Use the <see cref="Array.IsNull"/> method instead to reliably determine null values.
+        /// Use the <see cref="Array.IsNull"/> method or the <see cref="GetBytes(int, out bool)"/> overload instead
+        /// to reliably determine null values.
         /// </remarks>
         /// <param name="index">Index at which to get bytes.</param>
         /// <returns>Returns a <see cref="ReadOnlySpan{Byte}"/> object.</returns>
         /// <exception cref="ArgumentOutOfRangeException">If the index is negative or beyond the length of the array.
         /// </exception>
-        public ReadOnlySpan<byte> GetBytes(int index)
+        public ReadOnlySpan<byte> GetBytes(int index) => GetBytes(index, out _);
+
+        /// <summary>
+        /// Get the collection of bytes, as a read-only span, at a given index in the array.
+        /// </summary>
+        /// <param name="index">Index at which to get bytes.</param>
+        /// <param name="isNull">Set to <see langword="true"/> if the value at the given index is null.</param>
+        /// <returns>Returns a <see cref="ReadOnlySpan{Byte}"/> object.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">If the index is negative or beyond the length of the array.
+        /// </exception>
+        public ReadOnlySpan<byte> GetBytes(int index, out bool isNull)
         {
             if (index < 0 || index >= Length)
             {
                 throw new ArgumentOutOfRangeException(nameof(index));
             }
 
-            if (IsNull(index))
+            isNull = IsNull(index);
+
+            if (isNull)
             {
                 // Note that `return null;` is valid syntax, but would be misleading as `null` in the context of a span
                 // is actually returned as an empty span.
@@ -353,6 +366,5 @@ public ReadOnlySpan<byte> GetBytes(int index)
 
             return ValueBuffer.Span.Slice(ValueOffsets[index], GetValueLength(index));
         }
-
     }
 }
diff --git a/csharp/src/Apache.Arrow/Arrays/StringArray.cs b/csharp/src/Apache.Arrow/Arrays/StringArray.cs
index f008f56fa8477..42104b27175a9 100644
--- a/csharp/src/Apache.Arrow/Arrays/StringArray.cs
+++ b/csharp/src/Apache.Arrow/Arrays/StringArray.cs
@@ -72,11 +72,11 @@ public StringArray(int length,
 
         public string GetString(int index, Encoding encoding = default)
         {
-            encoding = encoding ?? DefaultEncoding;
+            encoding ??= DefaultEncoding;
 
-            ReadOnlySpan<byte> bytes = GetBytes(index);
+            ReadOnlySpan<byte> bytes = GetBytes(index, out bool isNull);
 
-            if (bytes == default)
+            if (isNull)
             {
                 return null;
             }
diff --git a/csharp/test/Apache.Arrow.Tests/BinaryArrayBuilderTests.cs b/csharp/test/Apache.Arrow.Tests/BinaryArrayBuilderTests.cs
index 7f45ce8578fc3..4c2b050d0c8ba 100644
--- a/csharp/test/Apache.Arrow.Tests/BinaryArrayBuilderTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/BinaryArrayBuilderTests.cs
@@ -481,7 +481,8 @@ private static void AssertArrayContents(IEnumerable<byte[]> expectedContents, Bi
             for (int i = 0; i < array.Length; i++)
             {
                 var expectedArray = expectedContentsArr[i];
-                var actualArray = array.IsNull(i) ? null : array.GetBytes(i).ToArray();
+                var actualSpan = array.GetBytes(i, out bool isNull);
+                var actualArray = isNull ? null : actualSpan.ToArray();
                 Assert.Equal(expectedArray, actualArray);
             }
         }
diff --git a/csharp/test/Apache.Arrow.Tests/StringArrayTests.cs b/csharp/test/Apache.Arrow.Tests/StringArrayTests.cs
new file mode 100644
index 0000000000000..0fd3d3d105a70
--- /dev/null
+++ b/csharp/test/Apache.Arrow.Tests/StringArrayTests.cs
@@ -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.
+
+using Xunit;
+
+namespace Apache.Arrow.Tests
+{
+    public class StringArrayTests
+    {
+        public class GetString
+        {
+            [Theory]
+            [InlineData(null, null)]
+            [InlineData(null, "")]
+            [InlineData(null, "value")]
+            [InlineData("", null)]
+            [InlineData("", "")]
+            [InlineData("", "value")]
+            [InlineData("value", null)]
+            [InlineData("value", "")]
+            [InlineData("value", "value")]
+            public void ReturnsAppendedValue(string firstValue, string secondValue)
+            {
+                // Arrange
+                // Create an array with two elements. The second element being null,
+                // empty, or non-empty may influence the underlying BinaryArray
+                // storage such that retrieving an empty first element could result
+                // in an empty span or a 0-length span backed by storage.
+                var array = new StringArray.Builder()
+                    .Append(firstValue)
+                    .Append(secondValue)
+                    .Build();
+
+                // Act
+                var retrievedValue = array.GetString(0);
+
+                // Assert
+                Assert.Equal(firstValue, retrievedValue);
+            }
+        }
+    }
+}

From 6b118bbcca2139c479814854c8b246552f1ac9a0 Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 16 Oct 2023 14:02:18 -0300
Subject: [PATCH 561/749] GH-38282 [C++]: Implement ReplaceString with the
 right type signature (#38283)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

The type signature of `ReplaceString` should be identical when arrow is compiled with or without `ARROW_WITH_RE2`.

### What changes are included in this PR?

The right signature + delegating to the implementation that takes `re2::StringPiece`. The conversion should be a no-op when compiled and optimized.

### Are these changes tested?

By existing tests and CI checks.

* Closes: #38282

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 cpp/src/arrow/compute/kernels/scalar_string_ascii.cc | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
index 90f5d40b984f4..6764845dfca81 100644
--- a/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_string_ascii.cc
@@ -2063,7 +2063,13 @@ struct RegexSubstringReplacer {
         regex_find_("(" + options_.pattern + ")", MakeRE2Options<Type>()),
         regex_replacement_(options_.pattern, MakeRE2Options<Type>()) {}
 
-  Status ReplaceString(re2::StringPiece s, TypedBufferBuilder<uint8_t>* builder) const {
+  Status ReplaceString(std::string_view s, TypedBufferBuilder<uint8_t>* builder) const {
+    re2::StringPiece piece(s.data(), s.length());
+    return ReplaceStringImpl(piece, builder);
+  }
+
+  Status ReplaceStringImpl(re2::StringPiece s,
+                           TypedBufferBuilder<uint8_t>* builder) const {
     re2::StringPiece replacement(options_.replacement);
 
     // If s is empty, then it's essentially global

From 834da69cd610264aaeb34c151f8c4da8f7b0cb17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Mon, 16 Oct 2023 22:56:58 +0200
Subject: [PATCH 562/749] GH-38286: [CI][R] Clean GitHub runner disk for
 ubuntu-r-only-r images (#38287)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change
Fix CI failures for job that is getting out of space.

### What changes are included in this PR?

Using our free disk space script to add space for the ubuntu-r-only-r images.

### Are these changes tested?

On CI

### Are there any user-facing changes?
No
* Closes: #38286

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/tasks/docker-tests/github.linux.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dev/tasks/docker-tests/github.linux.yml b/dev/tasks/docker-tests/github.linux.yml
index 30a6814895f29..2050c86994b2d 100644
--- a/dev/tasks/docker-tests/github.linux.yml
+++ b/dev/tasks/docker-tests/github.linux.yml
@@ -27,6 +27,9 @@ jobs:
 {{ macros.github_set_env(env) }}
     steps:
       {{ macros.github_checkout_arrow(fetch_depth=fetch_depth|default(1))|indent }}
+    {% if image in ["ubuntu-r-only-r"] %}
+      {{ macros.github_free_space()|indent }}
+    {% endif %}
       {{ macros.github_install_archery()|indent }}
 
       - name: Execute Docker Build

From 85671b3690e2ca6cfa1bc510d1da3c9b7887761c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Mon, 16 Oct 2023 23:00:28 +0200
Subject: [PATCH 563/749] MINOR: [Go] Bump go versions for testing nightly
 tasks (#38289)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### What changes are included in this PR?

Bump versions of Go for our nightly tests to match supported Go versions

### Are these changes tested?
Via archery

### Are there any user-facing changes?

No

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/tasks/tasks.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 04afe79d4d906..326c94558a9c2 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1484,7 +1484,7 @@ tasks:
         R_PRUNE_DEPS: TRUE
       image: fedora-r-clang-sanitizer
 
-  {% for go_version, staticcheck in [("1.17", "v0.2.2"), ("1.20", "latest")] %}
+  {% for go_version, staticcheck in [("1.19", "v0.4.5"), ("1.21", "latest")] %}
   test-debian-11-go-{{ go_version }}:
     ci: azure
     template: docker-tests/azure.linux.yml

From 2ee862b30a6d865d53a1ef43e44e193fb2534d1f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 17 Oct 2023 06:01:13 +0900
Subject: [PATCH 564/749] MINOR: [C#] Bump xunit.runner.visualstudio from 2.5.1
 to 2.5.3 in /csharp (#38290)

Bumps [xunit.runner.visualstudio](https://github.com/xunit/visualstudio.xunit) from 2.5.1 to 2.5.3.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/6b60a9e56a82a4010e2c65481cfa40c227f97fd5"><code>6b60a9e</code></a> v2.5.3</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/48d5ef68535d44fc58641a51c6844da6e4e3f7b7"><code>48d5ef6</code></a> Add diagnostic messages around DiaSession failures</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/32b7c99f6023cc12552833c740ca2a2fce3bdbd6"><code>32b7c99</code></a> Incorrect URL for Git repository in .nuspec file</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/ce0f849c747ee27ba6c947e71e483f730293a0fd"><code>ce0f849</code></a> Bump up to v2.5.3-pre</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/b56611bde0cdc1513d5420f4a066b63df0de7870"><code>b56611b</code></a> v2.5.2</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/9b843e136f0d5a385846b88ccfae89d667c6093b"><code>9b843e1</code></a> Add Microsoft.TestPlatform.ObjectModel as a dependency in the nuspec for .NET...</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/9d2800688c5a5007fdb9f0f073c9a4b749e62ef4"><code>9d28006</code></a> Add /.vscode/tasks.json for builds inside VS Code</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/af96d96e2cf2f15ce18a21df462553053558d8e0"><code>af96d96</code></a> Latest dependencies</li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/2dd69895010eaff737e38e567f7f792996cd3ba4"><code>2dd6989</code></a> Undo the assembly merge from <a href="https://redirect.github.com/xunit/visualstudio.xunit/issues/383">#383</a></li>
<li><a href="https://github.com/xunit/visualstudio.xunit/commit/1c51d513e6479ba76856ce976433478bf75818ed"><code>1c51d51</code></a> Latest dependencies</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/visualstudio.xunit/compare/2.5.1...2.5.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit.runner.visualstudio&package-manager=nuget&previous-version=2.5.1&new-version=2.5.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index fc21b06ced689..79b3c3ab5934e 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 48ba93f58b973..c32930095e00b 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -8,7 +8,7 @@
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
       <PackageReference Include="xunit" Version="2.5.1" />
-      <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
+      <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 6dd816ac73e86..410723b9d97ea 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -8,7 +8,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index e7af9e2246276..e1a584cce6713 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -12,7 +12,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.1">
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

From cee2fa8bf0ebeecaaa58c5f7c37c892fd6099615 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 17 Oct 2023 06:15:30 +0900
Subject: [PATCH 565/749] MINOR: [C#] Bump pythonnet from 3.0.2 to 3.0.3 in
 /csharp (#38291)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [pythonnet](https://github.com/pythonnet/pythonnet) from 3.0.2 to 3.0.3.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/pythonnet/pythonnet/releases">pythonnet's releases</a>.</em></p>
<blockquote>
<h2>v3.0.3</h2>
<h2>What's Changed</h2>
<ul>
<li>change PyScope to PyModule by <a href="https://github.com/OmkarBorhade98"><code>@​OmkarBorhade98</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2231">pythonnet/pythonnet#2231</a></li>
<li>use enum name in repr by <a href="https://github.com/koubaa"><code>@​koubaa</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2239">pythonnet/pythonnet#2239</a></li>
<li>ARM CI fix by <a href="https://github.com/lostmsu"><code>@​lostmsu</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2256">pythonnet/pythonnet#2256</a></li>
<li>Python 3.12 by <a href="https://github.com/filmor"><code>@​filmor</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2249">pythonnet/pythonnet#2249</a></li>
<li>Only run docs CI/main CI for corresponding changes by <a href="https://github.com/lostmsu"><code>@​lostmsu</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2257">pythonnet/pythonnet#2257</a></li>
<li>Revert &quot;Only run docs CI/main CI for corresponding changes&quot; by <a href="https://github.com/filmor"><code>@​filmor</code></a> in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2260">pythonnet/pythonnet#2260</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/OmkarBorhade98"><code>@​OmkarBorhade98</code></a> made their first contribution in <a href="https://redirect.github.com/pythonnet/pythonnet/pull/2231">pythonnet/pythonnet#2231</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/pythonnet/pythonnet/compare/v3.0.2...v3.0.3">https://github.com/pythonnet/pythonnet/compare/v3.0.2...v3.0.3</a></p>
</blockquote>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/pythonnet/pythonnet/blob/master/CHANGELOG.md">pythonnet's changelog</a>.</em></p>
<blockquote>
<h2><a href="https://github.com/pythonnet/pythonnet/releases/tag/v3.0.3">3.0.3</a> - 2023-10-11</h2>
<h3>Added</h3>
<ul>
<li>Support for Python 3.12</li>
</ul>
<h3>Changed</h3>
<ul>
<li>Use enum name in <code>repr</code></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/pythonnet/pythonnet/commit/0a5a63ccc4ee1e104ab0aae75ede8aa3441a3481"><code>0a5a63c</code></a> Release 3.0.3</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/5a4a986f9e2b9f4f505db68809f45a63c39b1418"><code>5a4a986</code></a> Revert &quot;only run docs CI/main CI for corresponding changes (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2257">#2257</a>)&quot; (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2260">#2260</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/04670ea1c8a761944e19ac89acd18a43a82cc352"><code>04670ea</code></a> only run docs CI/main CI for corresponding changes (<a href="https://redirect.github.com/pythonnet/pythonnet/issues/2257">#2257</a>)</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/88418da6a87f3dcdd861ff0022d8beb6164ae3ee"><code>88418da</code></a> Merge pull request <a href="https://redirect.github.com/pythonnet/pythonnet/issues/2249">#2249</a> from pythonnet/python-3.12</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/293f8b1d810db1e63253b950a4b4844b35c38bab"><code>293f8b1</code></a> Python 3.12 has been released, use final version</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/fb494705652af998a4f346aeb88ebff836c72eb4"><code>fb49470</code></a> Ignore test-case on Python 3.12</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/080d1bd59f2b231db2081474cf126e46aa039505"><code>080d1bd</code></a> For now skip over &quot;new style&quot; weakrefs in clear</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/8dfe4080d642397a7efcb52b8d3aa69da1675713"><code>8dfe408</code></a> Remove deprecated function call</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/d057724e5167d7088a3dc77310a37c38473e318d"><code>d057724</code></a> Update changelog</li>
<li><a href="https://github.com/pythonnet/pythonnet/commit/7a31d38755c71d0385bf28e758ab9cf96a2db481"><code>7a31d38</code></a> Add 3.12 to CI and metadata</li>
<li>Additional commits viewable in <a href="https://github.com/pythonnet/pythonnet/compare/v3.0.2...v3.0.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=pythonnet&package-manager=nuget&previous-version=3.0.2&new-version=3.0.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index e1a584cce6713..6d805b6fe3f0e 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -17,7 +17,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
     <PackageReference Include="xunit.skippablefact" Version="1.4.13" />
-    <PackageReference Include="pythonnet" Version="3.0.2" />
+    <PackageReference Include="pythonnet" Version="3.0.3" />
   </ItemGroup>
 
   <ItemGroup>

From 71a76c340c6dfe1fcde51b22f718a26da4edd7bc Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 16 Oct 2023 16:01:27 -0700
Subject: [PATCH 566/749] GH-38297: [C#] Fix build for .NET 4.7.2 (#38299)

### What changes are included in this PR?

Fixes #38297

### Are these changes tested?

Yes
* Closes: #38297
---
 csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs | 4 ++++
 csharp/test/Apache.Arrow.Tests/MapArrayTests.cs      | 6 +++---
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs b/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs
index 0890d356b8e90..3395ca7bc9ad7 100644
--- a/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/DurationArrayTests.cs
@@ -69,7 +69,11 @@ static TimeUnit RequiredPrecision(TimeSpan? timeSpan)
         {
             if (timeSpan == null) { return TimeUnit.Second; }
             if ((timeSpan.Value.Ticks % TicksPerMicrosecond) > 0) { return TimeUnit.Nanosecond; }
+#if NET5_0_OR_GREATER
             if (timeSpan.Value.Microseconds > 0) { return TimeUnit.Microsecond; }
+#else
+            if ((timeSpan.Value.Ticks % (TicksPerMicrosecond * 1000)) > 0) { return TimeUnit.Microsecond; }
+#endif
             if (timeSpan.Value.Milliseconds > 0) { return TimeUnit.Millisecond; }
             return TimeUnit.Second;
         }
diff --git a/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
index 034f120f3f016..7f35f104267dc 100644
--- a/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/MapArrayTests.cs
@@ -62,9 +62,9 @@ public void MapArray_Should_GetKeyValuePairs()
             var keyBuilder = builder.KeyBuilder as StringArray.Builder;
             var valueBuilder = builder.ValueBuilder as Int32Array.Builder;
 
-            KeyValuePair<string, int?> kv0 = KeyValuePair.Create("test", (int?)1);
-            KeyValuePair<string, int?> kv1 = KeyValuePair.Create("other", (int?)123);
-            KeyValuePair<string, int?> kv2 = KeyValuePair.Create("kv", (int?)null);
+            KeyValuePair<string, int?> kv0 = new KeyValuePair<string, int?>("test", (int?)1);
+            KeyValuePair<string, int?> kv1 = new KeyValuePair<string, int?>("other", (int?)123);
+            KeyValuePair<string, int?> kv2 = new KeyValuePair<string, int?>("kv", (int?)null);
 
             builder.Append();
             keyBuilder.Append("test");

From c24447398d7868858d5b72f83293221e070bfaa6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 16:34:34 -0700
Subject: [PATCH 567/749] MINOR: [C#] Bump xunit from 2.5.1 to 2.5.2 in /csharp
 (#38292)

Bumps [xunit](https://github.com/xunit/xunit) from 2.5.1 to 2.5.2.
<details>
<summary>Commits</summary>
<ul>
<li><a
href="https://github.com/xunit/xunit/commit/32931855e213ccb74d75a899af76f40388b2131b"><code>3293185</code></a>
v2.5.2</li>
<li><a
href="https://github.com/xunit/xunit/commit/4d9d4fcc5d5f0e09445026674f62415993a3fe73"><code>4d9d4fc</code></a>
Roll back singleton NullMessageSink and
NullSourceInformationProvider</li>
<li><a
href="https://github.com/xunit/xunit/commit/45078f3a86e04e495dbbe3e434a8dddc1ce42a8d"><code>45078f3</code></a>
Pick up latest analyzers</li>
<li><a
href="https://github.com/xunit/xunit/commit/8ae0d067bb8f427f38c5524b4f3c47f99e844f77"><code>8ae0d06</code></a>
Remove VisualStudioSourceInformationProvider and DiaSession-related
classes</li>
<li><a
href="https://github.com/xunit/xunit/commit/4a35ce7722aa3ac01a1e04fc3757c448d454aaa5"><code>4a35ce7</code></a>
Missing comparer pass-through on DictionaryExtensions</li>
<li><a
href="https://github.com/xunit/xunit/commit/9ab4ecef596b9677bcc53bdb3b5e1117b0a83bf4"><code>9ab4ece</code></a>
<a href="https://redirect.github.com/xunit/xunit/issues/2755">#2755</a>:
Tests for another embedded collection regression (v2)</li>
<li><a
href="https://github.com/xunit/xunit/commit/e499f14da33189d3c197b5f4abf3a6f769e0a80e"><code>e499f14</code></a>
Bump up to v2.5.2-pre</li>
<li>See full diff in <a
href="https://github.com/xunit/xunit/compare/2.5.1...2.5.2">compare
view</a></li>
</ul>
</details>
<br />


[![Dependabot compatibility
score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.5.1&new-version=2.5.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't
alter it yourself. You can also trigger a rebase manually by commenting
`@dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits
that have been made to it
- `@dependabot merge` will merge this PR after your CI passes on it
- `@dependabot squash and merge` will squash and merge this PR after
your CI passes on it
- `@dependabot cancel merge` will cancel a previously requested merge
and block automerging
- `@dependabot reopen` will reopen this PR if it is closed
- `@dependabot close` will close this PR and stop Dependabot recreating
it. You can achieve the same result by closing it manually
- `@dependabot show <dependency name> ignore conditions` will show all
of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop
Dependabot creating any more for this major version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop
Dependabot creating any more for this minor version (unless you reopen
the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop
Dependabot creating any more for this dependency (unless you reopen the
PR or upgrade to it yourself)


</details>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 79b3c3ab5934e..44c6ef4e98238 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.1" />
+    <PackageReference Include="xunit" Version="2.5.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index c32930095e00b..2839911a61d18 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -7,7 +7,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-      <PackageReference Include="xunit" Version="2.5.1" />
+      <PackageReference Include="xunit" Version="2.5.2" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 410723b9d97ea..5029e3696f14f 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.1" />
+    <PackageReference Include="xunit" Version="2.5.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 6d805b6fe3f0e..d07cd233afbd3 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -11,7 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.1" />
+    <PackageReference Include="xunit" Version="2.5.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

From b3b958e029623d7bdf353b7a1c4238eb89dfbc17 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Mon, 16 Oct 2023 21:38:34 -0300
Subject: [PATCH 568/749] GH-38293: [R] Fix non-deterministic duckdb test
 (#38294)

### Rationale for this change

The test fail with the latest version of duckdb (0.9.1).

### What changes are included in this PR?

The test was changed so that it did not depend on non-deterministic behaviour. We sort all of the other expectations involving a group_by to avoid this problem...we hadn't changed this one yet because it didn't fail in any previous version of duckdb.

### Are these changes tested?

Yes

### Are there any user-facing changes?

No
* Closes: #38293

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/tests/testthat/test-duckdb.R | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/r/tests/testthat/test-duckdb.R b/r/tests/testthat/test-duckdb.R
index d5bf3d9271349..13cffa1423767 100644
--- a/r/tests/testthat/test-duckdb.R
+++ b/r/tests/testthat/test-duckdb.R
@@ -248,11 +248,12 @@ test_that("to_duckdb with a table", {
         int_mean = mean(int, na.rm = TRUE),
         dbl_mean = mean(dbl, na.rm = TRUE)
       ) %>%
-      collect(),
+      collect() %>%
+      arrange(int_mean),
     tibble::tibble(
-      "int > 4" = c(FALSE, NA, TRUE),
-      int_mean = c(2, NA, 7.5),
-      dbl_mean = c(2.1, 4.1, 7.3)
+      "int > 4" = c(FALSE, TRUE, NA),
+      int_mean = c(2, 7.5, NA),
+      dbl_mean = c(2.1, 7.3, 4.1)
     )
   )
 })

From d3a576d03ad943773d9c55974f9c797a5042b4a8 Mon Sep 17 00:00:00 2001
From: Fatemah Panahi <fatemehp@users.noreply.github.com>
Date: Mon, 16 Oct 2023 18:16:52 -0700
Subject: [PATCH 569/749] GH-37002: [C++][Parquet] Add api to get RecordReader
 from RowGroupReader (#37003)

Currently we only can get a ColumnReader for a column from RowGroupReader. We need an API to return a RecordReader for the column.

Moved ComputeLevelInfo from column_writer to level_conversion so that it can be shared between column_writer and file_reader.
* Closes: #37002

Lead-authored-by: Fatemah Panahi <panahi@google.com>
Co-authored-by: Fatemah Panahi <fatemehp@users.noreply.github.com>
Signed-off-by: Gang Wu <ustcwg@gmail.com>
---
 cpp/src/parquet/column_writer.cc   | 19 +---------------
 cpp/src/parquet/file_reader.cc     | 20 +++++++++++++++++
 cpp/src/parquet/file_reader.h      |  8 +++++++
 cpp/src/parquet/level_conversion.h | 18 +++++++++++++++
 cpp/src/parquet/properties.h       |  6 +++++
 cpp/src/parquet/reader_test.cc     | 36 ++++++++++++++++++++++++++++++
 6 files changed, 89 insertions(+), 18 deletions(-)

diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 88829ef5d98f9..72e984d7736fa 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -140,23 +140,6 @@ struct ValueBufferSlicer {
   MemoryPool* pool_;
 };
 
-internal::LevelInfo ComputeLevelInfo(const ColumnDescriptor* descr) {
-  internal::LevelInfo level_info;
-  level_info.def_level = descr->max_definition_level();
-  level_info.rep_level = descr->max_repetition_level();
-
-  int16_t min_spaced_def_level = descr->max_definition_level();
-  const ::parquet::schema::Node* node = descr->schema_node().get();
-  while (node != nullptr && !node->is_repeated()) {
-    if (node->is_optional()) {
-      min_spaced_def_level--;
-    }
-    node = node->parent();
-  }
-  level_info.repeated_ancestor_def_level = min_spaced_def_level;
-  return level_info;
-}
-
 template <class T>
 inline const T* AddIfNotNull(const T* base, int64_t offset) {
   if (base != nullptr) {
@@ -738,7 +721,7 @@ class ColumnWriterImpl {
                    Encoding::type encoding, const WriterProperties* properties)
       : metadata_(metadata),
         descr_(metadata->descr()),
-        level_info_(ComputeLevelInfo(metadata->descr())),
+        level_info_(internal::LevelInfo::ComputeLevelInfo(metadata->descr())),
         pager_(std::move(pager)),
         has_dictionary_(use_dictionary),
         encoding_(encoding),
diff --git a/cpp/src/parquet/file_reader.cc b/cpp/src/parquet/file_reader.cc
index 7318b5640c0a0..1d972b78fb99c 100644
--- a/cpp/src/parquet/file_reader.cc
+++ b/cpp/src/parquet/file_reader.cc
@@ -82,6 +82,26 @@ std::shared_ptr<ColumnReader> RowGroupReader::Column(int i) {
       const_cast<ReaderProperties*>(contents_->properties())->memory_pool());
 }
 
+std::shared_ptr<internal::RecordReader> RowGroupReader::RecordReader(int i) {
+  if (i >= metadata()->num_columns()) {
+    std::stringstream ss;
+    ss << "Trying to read column index " << i << " but row group metadata has only "
+       << metadata()->num_columns() << " columns";
+    throw ParquetException(ss.str());
+  }
+  const ColumnDescriptor* descr = metadata()->schema()->Column(i);
+
+  std::unique_ptr<PageReader> page_reader = contents_->GetColumnPageReader(i);
+
+  internal::LevelInfo level_info = internal::LevelInfo::ComputeLevelInfo(descr);
+
+  auto reader = internal::RecordReader::Make(
+      descr, level_info, contents_->properties()->memory_pool(),
+      /* read_dictionary = */ false, contents_->properties()->read_dense_for_nullable());
+  reader->SetPageReader(std::move(page_reader));
+  return reader;
+}
+
 std::shared_ptr<ColumnReader> RowGroupReader::ColumnWithExposeEncoding(
     int i, ExposedEncoding encoding_to_expose) {
   std::shared_ptr<ColumnReader> reader = Column(i);
diff --git a/cpp/src/parquet/file_reader.h b/cpp/src/parquet/file_reader.h
index 13fcd196c4459..da85b73fc2dfe 100644
--- a/cpp/src/parquet/file_reader.h
+++ b/cpp/src/parquet/file_reader.h
@@ -37,6 +37,10 @@ class BloomFilterReader;
 class PageReader;
 class RowGroupMetaData;
 
+namespace internal {
+class RecordReader;
+}
+
 class PARQUET_EXPORT RowGroupReader {
  public:
   // Forward declare a virtual class 'Contents' to aid dependency injection and more
@@ -58,6 +62,10 @@ class PARQUET_EXPORT RowGroupReader {
   // column. Ownership is shared with the RowGroupReader.
   std::shared_ptr<ColumnReader> Column(int i);
 
+  // EXPERIMENTAL: Construct a RecordReader for the indicated column of the row group.
+  // Ownership is shared with the RowGroupReader.
+  std::shared_ptr<internal::RecordReader> RecordReader(int i);
+
   // Construct a ColumnReader, trying to enable exposed encoding.
   //
   // For dictionary encoding, currently we only support column chunks that are fully
diff --git a/cpp/src/parquet/level_conversion.h b/cpp/src/parquet/level_conversion.h
index 3f56b2de36a78..2c6f628319fc4 100644
--- a/cpp/src/parquet/level_conversion.h
+++ b/cpp/src/parquet/level_conversion.h
@@ -121,6 +121,24 @@ struct PARQUET_EXPORT LevelInfo {
     return last_repeated_ancestor;
   }
 
+  // Calculates and returns LevelInfo for a column descriptor.
+  static LevelInfo ComputeLevelInfo(const ColumnDescriptor* descr) {
+    LevelInfo level_info;
+    level_info.def_level = descr->max_definition_level();
+    level_info.rep_level = descr->max_repetition_level();
+
+    int16_t min_spaced_def_level = descr->max_definition_level();
+    const ::parquet::schema::Node* node = descr->schema_node().get();
+    while (node && !node->is_repeated()) {
+      if (node->is_optional()) {
+        min_spaced_def_level--;
+      }
+      node = node->parent();
+    }
+    level_info.repeated_ancestor_def_level = min_spaced_def_level;
+    return level_info;
+  }
+
   friend std::ostream& operator<<(std::ostream& os, const LevelInfo& levels) {
     // This print method is to silence valgrind issues.  What's printed
     // is not important because all asserts happen directly on
diff --git a/cpp/src/parquet/properties.h b/cpp/src/parquet/properties.h
index 6d3d5aa4f44b4..4d3acb491e390 100644
--- a/cpp/src/parquet/properties.h
+++ b/cpp/src/parquet/properties.h
@@ -79,6 +79,10 @@ class PARQUET_EXPORT ReaderProperties {
   /// Disable buffered stream reading.
   void disable_buffered_stream() { buffered_stream_enabled_ = false; }
 
+  bool read_dense_for_nullable() const { return read_dense_for_nullable_; }
+  void enable_read_dense_for_nullable() { read_dense_for_nullable_ = true; }
+  void disable_read_dense_for_nullable() { read_dense_for_nullable_ = false; }
+
   /// Return the size of the buffered stream buffer.
   int64_t buffer_size() const { return buffer_size_; }
   /// Set the size of the buffered stream buffer in bytes.
@@ -123,6 +127,8 @@ class PARQUET_EXPORT ReaderProperties {
   int32_t thrift_container_size_limit_ = kDefaultThriftContainerSizeLimit;
   bool buffered_stream_enabled_ = false;
   bool page_checksum_verification_ = false;
+  // Used with a RecordReader.
+  bool read_dense_for_nullable_ = false;
   std::shared_ptr<FileDecryptionProperties> file_decryption_properties_;
 };
 
diff --git a/cpp/src/parquet/reader_test.cc b/cpp/src/parquet/reader_test.cc
index 0a73002846add..8fe12d3de0b6c 100644
--- a/cpp/src/parquet/reader_test.cc
+++ b/cpp/src/parquet/reader_test.cc
@@ -502,6 +502,42 @@ TEST_F(TestAllTypesPlain, ColumnSelectionOutOfRange) {
   ASSERT_THROW(printer2.DebugPrint(ss, columns), ParquetException);
 }
 
+// Tests that read_dense_for_nullable is passed down to the record
+// reader. The functionality of read_dense_for_nullable is tested
+// elsewhere.
+TEST(TestFileReader, RecordReaderReadDenseForNullable) {
+  // We test the default which is false, and also test enabling and disabling
+  // read_dense_for_nullable.
+  std::vector<ReaderProperties> reader_properties(3);
+  reader_properties[1].enable_read_dense_for_nullable();
+  reader_properties[2].disable_read_dense_for_nullable();
+  for (const auto& reader_props : reader_properties) {
+    std::unique_ptr<ParquetFileReader> file_reader = ParquetFileReader::OpenFile(
+        alltypes_plain(), /* memory_map = */ false, reader_props);
+    std::shared_ptr<RowGroupReader> group = file_reader->RowGroup(0);
+    std::shared_ptr<internal::RecordReader> col_record_reader = group->RecordReader(0);
+    ASSERT_EQ(reader_props.read_dense_for_nullable(),
+              col_record_reader->read_dense_for_nullable());
+  }
+}
+
+// Tests getting a record reader from a row group reader.
+TEST(TestFileReader, GetRecordReader) {
+  ReaderProperties reader_props;
+  std::unique_ptr<ParquetFileReader> file_reader = ParquetFileReader::OpenFile(
+      alltypes_plain(), /* memory_map = */ false, reader_props);
+  std::shared_ptr<RowGroupReader> group = file_reader->RowGroup(0);
+
+  std::shared_ptr<internal::RecordReader> col_record_reader_ = group->RecordReader(0);
+
+  ASSERT_TRUE(col_record_reader_->HasMoreData());
+  auto records_read = col_record_reader_->ReadRecords(4);
+  ASSERT_EQ(records_read, 4);
+  ASSERT_EQ(4, col_record_reader_->values_written());
+  ASSERT_EQ(4, col_record_reader_->levels_position());
+  ASSERT_EQ(8, col_record_reader_->levels_written());
+}
+
 class TestLocalFile : public ::testing::Test {
  public:
   void SetUp() {

From 4011058f4a56bdcf160f46373355ffa0e22bcd2c Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 16 Oct 2023 19:53:50 -0700
Subject: [PATCH 570/749] GH-36815: [C#]: Enable net472 tests under Windows
 (#36818)

### What changes are included in this PR?

The primary C# test project is updated to run for .NET 4.7.2 only on Windows platforms.

### Are these changes tested?

Yes.
* Closes: #36815

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Curt Hagenlocher <curt@hagenlocher.org>
---
 csharp/src/Apache.Arrow/Types/Time32Type.cs          |  2 +-
 csharp/src/Apache.Arrow/Types/Time64Type.cs          |  2 +-
 .../Apache.Arrow.Tests/Apache.Arrow.Tests.csproj     | 12 ++++++++----
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Types/Time32Type.cs b/csharp/src/Apache.Arrow/Types/Time32Type.cs
index 80a23d49344ae..7eb3c261879a7 100644
--- a/csharp/src/Apache.Arrow/Types/Time32Type.cs
+++ b/csharp/src/Apache.Arrow/Types/Time32Type.cs
@@ -18,7 +18,7 @@ namespace Apache.Arrow.Types
 {
     public sealed class Time32Type : TimeType
     {
-        public static readonly Time32Type Default = Millisecond;
+        public static Time32Type Default => Millisecond;
 
         public override ArrowTypeId TypeId => ArrowTypeId.Time32;
         public override string Name => "time32";
diff --git a/csharp/src/Apache.Arrow/Types/Time64Type.cs b/csharp/src/Apache.Arrow/Types/Time64Type.cs
index e7d911c2772b4..f674c25e44c51 100644
--- a/csharp/src/Apache.Arrow/Types/Time64Type.cs
+++ b/csharp/src/Apache.Arrow/Types/Time64Type.cs
@@ -18,7 +18,7 @@ namespace Apache.Arrow.Types
 {
     public sealed class Time64Type : TimeType
     {
-        public static readonly Time64Type Default = Nanosecond;
+        public static Time64Type Default => Nanosecond;
 
         public override ArrowTypeId TypeId => ArrowTypeId.Time64;
         public override string Name => "time64";
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index d07cd233afbd3..2d705323425fd 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -2,13 +2,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0</TargetFrameworks>
-    <!-- TODO: CI can't run with net472 on non-Windows platforms
-    <TargetFrameworks>net7.0;net472</TargetFrameworks>
-    -->
+    <IsWindows Condition="'$([System.Runtime.InteropServices.RuntimeInformation]::IsOSPlatform($([System.Runtime.InteropServices.OSPlatform]::Windows)))' == 'true'">true</IsWindows>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(IsWindows)'=='true'">
+    <TargetFrameworks>net7.0;net472</TargetFrameworks>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(IsWindows)'!='true'">
+    <TargetFrameworks>net7.0</TargetFrameworks>
+  </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageReference Include="xunit" Version="2.5.2" />

From 1e9f224520ad1ffe836c9bab3c438c3d110c00ea Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Mon, 16 Oct 2023 23:31:48 -0800
Subject: [PATCH 571/749] GH-35260: [C++][Python][R] Allow users to adjust S3
 log level by environment variable (#38267)

### Rationale for this change

It's useful when troubleshooting issues with Arrow's S3 filesystem implementation to raise the log level. Currently, this can only be done in C++ and Python, but not from R. In addition, the log level can only be set during S3 initialization and not directly so the user has to introduce explicit S3 initialization code to turn on logging and must make sure this code is called before S3 initialization.

While discussing exposing control of log level to R, we realized that allowing the log level to be controlled by environment variable may be more intuitive and useful and would just be a good addition for C++, Python, and R.

### What changes are included in this PR?

- A new environment variable `AWS_S3_LOG_LEVEL` with documentation for controlling S3 log level
- Updated documentation for C++, Python, and R
- A new `InitializeS3()` as a quality-of-life thing for C++ users. Feel free to ask me to remove this.

No changes are needed directly for Python and R because these implementation uses the internal implicit initializer `EnsureS3Initialized` rather than the explicit form, `InitializeS3`. And it's the behavior of the `EnsureS3Initialized` routine that's changed here.

### Are these changes tested?

Yes. I added a unit test for the new `GetS3LogLevelFromEnvOrDefault` and tested from Python and R manually. I didn't add a test to make sure the underlying `AwsInstance` gets set up correctly because it looked like it would require a refactor and didn't seem worth it.

### Are there any user-facing changes?

Yes. A new way to turn on logging for S3 and matching docs in C++, Python, and R.

* Closes: #35260

Lead-authored-by: Bryce Mecum <petridish@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/filesystem/s3fs.cc      | 32 ++++++++++++++++++++++++++-
 cpp/src/arrow/filesystem/s3fs.h       |  8 ++++++-
 cpp/src/arrow/filesystem/s3fs_test.cc | 26 ++++++++++++++++++++++
 docs/source/cpp/api/filesystem.rst    |  2 ++
 docs/source/cpp/env_vars.rst          | 22 ++++++++++++++++++
 docs/source/python/filesystems.rst    |  8 +++++++
 r/R/filesystem.R                      | 22 ++++++++++++++++++
 r/man/FileSystem.Rd                   |  8 +++++++
 r/man/s3_bucket.Rd                    | 13 +++++++++++
 9 files changed, 139 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/filesystem/s3fs.cc b/cpp/src/arrow/filesystem/s3fs.cc
index 08fbcde6fd9de..26a1530660781 100644
--- a/cpp/src/arrow/filesystem/s3fs.cc
+++ b/cpp/src/arrow/filesystem/s3fs.cc
@@ -2987,7 +2987,7 @@ Status InitializeS3(const S3GlobalOptions& options) {
 }
 
 Status EnsureS3Initialized() {
-  return EnsureAwsInstanceInitialized({S3LogLevel::Fatal}).status();
+  return EnsureAwsInstanceInitialized(S3GlobalOptions::Defaults()).status();
 }
 
 Status FinalizeS3() {
@@ -3001,6 +3001,36 @@ bool IsS3Initialized() { return GetAwsInstance()->IsInitialized(); }
 
 bool IsS3Finalized() { return GetAwsInstance()->IsFinalized(); }
 
+S3GlobalOptions S3GlobalOptions::Defaults() {
+  auto log_level = S3LogLevel::Fatal;
+
+  auto result = arrow::internal::GetEnvVar("ARROW_S3_LOG_LEVEL");
+
+  if (result.ok()) {
+    // Extract, trim, and downcase the value of the enivronment variable
+    auto value =
+        arrow::internal::AsciiToLower(arrow::internal::TrimString(result.ValueUnsafe()));
+
+    if (value == "fatal") {
+      log_level = S3LogLevel::Fatal;
+    } else if (value == "error") {
+      log_level = S3LogLevel::Error;
+    } else if (value == "warn") {
+      log_level = S3LogLevel::Warn;
+    } else if (value == "info") {
+      log_level = S3LogLevel::Info;
+    } else if (value == "debug") {
+      log_level = S3LogLevel::Debug;
+    } else if (value == "trace") {
+      log_level = S3LogLevel::Trace;
+    } else if (value == "off") {
+      log_level = S3LogLevel::Off;
+    }
+  }
+
+  return S3GlobalOptions{log_level};
+}
+
 // -----------------------------------------------------------------------
 // Top-level utility functions
 
diff --git a/cpp/src/arrow/filesystem/s3fs.h b/cpp/src/arrow/filesystem/s3fs.h
index cc870c5abea0d..9900a9a1c0aa5 100644
--- a/cpp/src/arrow/filesystem/s3fs.h
+++ b/cpp/src/arrow/filesystem/s3fs.h
@@ -332,9 +332,15 @@ struct ARROW_EXPORT S3GlobalOptions {
   ///
   /// For more details see Aws::Crt::Io::EventLoopGroup
   int num_event_loop_threads = 1;
+
+  /// \brief Initialize with default options
+  ///
+  /// For log_level, this method first tries to extract a suitable value from the
+  /// environment variable ARROW_S3_LOG_LEVEL.
+  static S3GlobalOptions Defaults();
 };
 
-/// \brief Initialize the S3 APIs.
+/// \brief Initialize the S3 APIs with the specified set of options.
 ///
 /// It is required to call this function at least once before using S3FileSystem.
 ///
diff --git a/cpp/src/arrow/filesystem/s3fs_test.cc b/cpp/src/arrow/filesystem/s3fs_test.cc
index f88ee7eef9332..b789845bd1aac 100644
--- a/cpp/src/arrow/filesystem/s3fs_test.cc
+++ b/cpp/src/arrow/filesystem/s3fs_test.cc
@@ -1380,5 +1380,31 @@ class TestS3FSGeneric : public S3TestMixin, public GenericFileSystemTest {
 
 GENERIC_FS_TEST_FUNCTIONS(TestS3FSGeneric);
 
+////////////////////////////////////////////////////////////////////////////
+// S3GlobalOptions::Defaults tests
+
+TEST(S3GlobalOptions, DefaultsLogLevel) {
+  // Verify we get the default value of Fatal
+  ASSERT_EQ(S3LogLevel::Fatal, arrow::fs::S3GlobalOptions::Defaults().log_level);
+
+  // Verify we get the value specified by env var and not the default
+  {
+    EnvVarGuard log_level_guard("ARROW_S3_LOG_LEVEL", "ERROR");
+    ASSERT_EQ(S3LogLevel::Error, arrow::fs::S3GlobalOptions::Defaults().log_level);
+  }
+
+  // Verify we trim and case-insensitively compare the environment variable's value
+  {
+    EnvVarGuard log_level_guard("ARROW_S3_LOG_LEVEL", " eRrOr ");
+    ASSERT_EQ(S3LogLevel::Error, arrow::fs::S3GlobalOptions::Defaults().log_level);
+  }
+
+  // Verify we get the default value of Fatal if our env var is invalid
+  {
+    EnvVarGuard log_level_guard("ARROW_S3_LOG_LEVEL", "invalid");
+    ASSERT_EQ(S3LogLevel::Fatal, arrow::fs::S3GlobalOptions::Defaults().log_level);
+  }
+}
+
 }  // namespace fs
 }  // namespace arrow
diff --git a/docs/source/cpp/api/filesystem.rst b/docs/source/cpp/api/filesystem.rst
index 71e102b0f698c..8132af42e2495 100644
--- a/docs/source/cpp/api/filesystem.rst
+++ b/docs/source/cpp/api/filesystem.rst
@@ -66,6 +66,8 @@ S3 filesystem
 .. doxygenclass:: arrow::fs::S3FileSystem
    :members:
 
+.. doxygenfunction:: arrow::fs::InitializeS3(const S3GlobalOptions& options)
+
 Hadoop filesystem
 -----------------
 
diff --git a/docs/source/cpp/env_vars.rst b/docs/source/cpp/env_vars.rst
index b4d93c7eadd9b..f116effeb258e 100644
--- a/docs/source/cpp/env_vars.rst
+++ b/docs/source/cpp/env_vars.rst
@@ -85,6 +85,28 @@ that changing their value later will have an effect.
    ``libhdfs.dylib`` on macOS, ``libhdfs.so`` on other platforms).
    Alternatively, one can set :envvar:`HADOOP_HOME`.
 
+.. envvar:: ARROW_S3_LOG_LEVEL
+
+   Controls the verbosity of logging produced by S3 calls. Defaults to ``FATAL``
+   which only produces output in the case of fatal errors. ``DEBUG`` is recommended
+   when you're trying to troubleshoot issues.
+
+   Possible values include:
+
+   - ``FATAL`` (the default)
+   - ``ERROR``
+   - ``WARN``
+   - ``INFO``
+   - ``DEBUG``
+   - ``TRACE``
+   - ``OFF``
+
+   .. seealso::
+
+      `Logging - AWS SDK For C++
+      <https://docs.aws.amazon.com/sdk-for-cpp/v1/developer-guide/logging.html>`__
+
+
 .. envvar:: ARROW_TRACING_BACKEND
 
    The backend where to export `OpenTelemetry <https://opentelemetry.io/>`_-based
diff --git a/docs/source/python/filesystems.rst b/docs/source/python/filesystems.rst
index 3fc10dc7718d3..5309250351d8e 100644
--- a/docs/source/python/filesystems.rst
+++ b/docs/source/python/filesystems.rst
@@ -207,6 +207,14 @@ Here are a couple examples in code::
 
    :func:`pyarrow.fs.resolve_s3_region` for resolving region from a bucket name.
 
+Troubleshooting
+~~~~~~~~~~~~~~~
+
+When using :class:`S3FileSystem`, output is only produced for fatal errors or
+when printing return values. For troubleshooting, the log level can be set using
+the environment variable ``ARROW_S3_LOG_LEVEL``. The log level must be set prior
+to running any code that interacts with S3. Possible values include ``FATAL`` (the
+default), ``ERROR``, ``WARN``, ``INFO``, ``DEBUG`` (recommended), ``TRACE``, and ``OFF``.
 
 .. _filesystem-gcs:
 
diff --git a/r/R/filesystem.R b/r/R/filesystem.R
index eed9e95162bc3..e0f370ad601b3 100644
--- a/r/R/filesystem.R
+++ b/r/R/filesystem.R
@@ -239,6 +239,14 @@ FileSelector$create <- function(base_dir, allow_not_found = FALSE, recursive = F
 #' and no resource tags. To have more control over how buckets are created,
 #' use a different API to create them.
 #'
+#' On S3FileSystem, output is only produced for fatal errors or when printing
+#' return values. For troubleshooting, the log level can be set using the
+#' environment variable `ARROW_S3_LOG_LEVEL` (e.g.,
+#' `Sys.setenv("ARROW_S3_LOG_LEVEL"="DEBUG")`). The log level must be set prior
+#' to running any code that interacts with S3. Possible values include 'FATAL'
+#' (the default), 'ERROR', 'WARN', 'INFO', 'DEBUG' (recommended), 'TRACE', and
+#' 'OFF'.
+#'
 #' @usage NULL
 #' @format NULL
 #' @docType class
@@ -462,11 +470,25 @@ default_s3_options <- list(
 #'
 #' @param bucket string S3 bucket name or path
 #' @param ... Additional connection options, passed to `S3FileSystem$create()`
+#'
+#' @details By default, \code{\link{s3_bucket}} and other
+#' \code{\link{S3FileSystem}} functions only produce output for fatal errors
+#' or when printing their return values. When troubleshooting problems, it may
+#' be useful to increase the log level. See the Notes section in
+#' \code{\link{S3FileSystem}} for more information or see Examples below.
+#'
 #' @return A `SubTreeFileSystem` containing an `S3FileSystem` and the bucket's
 #' relative path. Note that this function's success does not guarantee that you
 #' are authorized to access the bucket's contents.
 #' @examplesIf FALSE
 #' bucket <- s3_bucket("voltrondata-labs-datasets")
+#'
+#' @examplesIf FALSE
+#' # Turn on debug logging. The following line of code should be run in a fresh
+#' # R session prior to any calls to `s3_bucket()` (or other S3 functions)
+#' Sys.setenv("ARROW_S3_LOG_LEVEL", "DEBUG")
+#' bucket <- s3_bucket("voltrondata-labs-datasets")
+#'
 #' @export
 s3_bucket <- function(bucket, ...) {
   assert_that(is.string(bucket))
diff --git a/r/man/FileSystem.Rd b/r/man/FileSystem.Rd
index 6ebbecd992bbe..b71d95f423ee3 100644
--- a/r/man/FileSystem.Rd
+++ b/r/man/FileSystem.Rd
@@ -149,5 +149,13 @@ it does not pass any non-default settings. In AWS S3, the bucket and all
 objects will be not publicly visible, and will have no bucket policies
 and no resource tags. To have more control over how buckets are created,
 use a different API to create them.
+
+On S3FileSystem, output is only produced for fatal errors or when printing
+return values. For troubleshooting, the log level can be set using the
+environment variable \code{ARROW_S3_LOG_LEVEL} (e.g.,
+\code{Sys.setenv("ARROW_S3_LOG_LEVEL"="DEBUG")}). The log level must be set prior
+to running any code that interacts with S3. Possible values include 'FATAL'
+(the default), 'ERROR', 'WARN', 'INFO', 'DEBUG' (recommended), 'TRACE', and
+'OFF'.
 }
 
diff --git a/r/man/s3_bucket.Rd b/r/man/s3_bucket.Rd
index 2ab7d4962ed35..1b30a5cde1177 100644
--- a/r/man/s3_bucket.Rd
+++ b/r/man/s3_bucket.Rd
@@ -21,8 +21,21 @@ are authorized to access the bucket's contents.
 that automatically detects the bucket's AWS region and holding onto the its
 relative path.
 }
+\details{
+By default, \code{\link{s3_bucket}} and other
+\code{\link{S3FileSystem}} functions only produce output for fatal errors
+or when printing their return values. When troubleshooting problems, it may
+be useful to increase the log level. See the Notes section in
+\code{\link{S3FileSystem}} for more information or see Examples below.
+}
 \examples{
 \dontshow{if (FALSE) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 bucket <- s3_bucket("voltrondata-labs-datasets")
 \dontshow{\}) # examplesIf}
+\dontshow{if (FALSE) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
+# Turn on debug logging. The following line of code should be run in a fresh
+# R session prior to any calls to `s3_bucket()` (or other S3 functions)
+Sys.setenv("ARROW_S3_LOG_LEVEL", "DEBUG")
+bucket <- s3_bucket("voltrondata-labs-datasets")
+\dontshow{\}) # examplesIf}
 }

From ecd38717077b57a81c7e569694876a787fb9d435 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Tue, 17 Oct 2023 09:57:25 +0200
Subject: [PATCH 572/749] GH-38240: [Docs] version_match should match the
 version from versions.json (#38241)

This PR corrects the version for the `version_match` to be equal to the version defined in versions.json. This way the text is correctly displayed in the version switcher button.
* Closes: #38240

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/conf.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/docs/source/conf.py b/docs/source/conf.py
index 89a0ba08826cd..f11d78fe05682 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -288,6 +288,14 @@
 # documentation.
 #
 
+switcher_version = version
+if ".dev" in version:
+    switcher_version = "dev/"
+else:
+    # If we are not building dev version of the docs, we are building
+    # docs for the stable version
+    switcher_version = ""
+
 html_theme_options = {
     "show_toc_level": 2,
     "use_edit_page_button": True,
@@ -313,7 +321,7 @@
     "show_version_warning_banner": True,
     "switcher": {
         "json_url": "/docs/_static/versions.json",
-        "version_match": version,
+        "version_match": switcher_version,
     },
 }
 

From 94ed8aa5408bf9a344478de69ca012b65262ebf6 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 17 Oct 2023 18:12:29 +0900
Subject: [PATCH 573/749] GH-38295: [CI][R] Free up disk space for Azure
 Pipelines jobs (#38302)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

test-r-rhub-ubuntu-gcc-release-latest doesn't have enough disk space.

### What changes are included in this PR?

Remove pre-installed files on Azure Pipelines too.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38295

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 ci/scripts/util_free_space.sh | 154 +++++++++++++++++-----------------
 dev/tasks/macros.jinja        |   5 ++
 dev/tasks/r/azure.linux.yml   | 103 +++++++++++------------
 3 files changed, 130 insertions(+), 132 deletions(-)

diff --git a/ci/scripts/util_free_space.sh b/ci/scripts/util_free_space.sh
index acea074feec63..0518869d06993 100755
--- a/ci/scripts/util_free_space.sh
+++ b/ci/scripts/util_free_space.sh
@@ -19,81 +19,79 @@
 
 set -eux
 
-if [ "${GITHUB_ACTIONS}" = "true" ]; then
-  df -h
-  echo "::group::/usr/local/*"
-  du -hsc /usr/local/*
-  echo "::endgroup::"
-  # ~1GB
-  sudo rm -rf \
-    /usr/local/aws-cli \
-    /usr/local/aws-sam-cil \
-    /usr/local/julia* || :
-  echo "::group::/usr/local/bin/*"
-  du -hsc /usr/local/bin/*
-  echo "::endgroup::"
-  # ~1GB (From 1.2GB to 214MB)
-  sudo rm -rf \
-    /usr/local/bin/aliyun \
-    /usr/local/bin/aws \
-    /usr/local/bin/aws_completer \
-    /usr/local/bin/azcopy \
-    /usr/local/bin/bicep \
-    /usr/local/bin/cmake-gui \
-    /usr/local/bin/cpack \
-    /usr/local/bin/helm \
-    /usr/local/bin/hub \
-    /usr/local/bin/kubectl \
-    /usr/local/bin/minikube \
-    /usr/local/bin/node \
-    /usr/local/bin/packer \
-    /usr/local/bin/pulumi* \
-    /usr/local/bin/sam \
-    /usr/local/bin/stack \
-    /usr/local/bin/terraform || :
-  # 142M
-  sudo rm -rf /usr/local/bin/oc || : \
-  echo "::group::/usr/local/share/*"
-  du -hsc /usr/local/share/*
-  echo "::endgroup::"
-  # 506MB
-  sudo rm -rf /usr/local/share/chromium || :
-  # 1.3GB
-  sudo rm -rf /usr/local/share/powershell || :
-  echo "::group::/usr/local/lib/*"
-  du -hsc /usr/local/lib/*
-  echo "::endgroup::"
-  # 15GB
-  sudo rm -rf /usr/local/lib/android || :
-  # 341MB
-  sudo rm -rf /usr/local/lib/heroku || :
-  # 1.2GB
-  sudo rm -rf /usr/local/lib/node_modules || :
-  echo "::group::/opt/*"
-  du -hsc /opt/*
-  echo "::endgroup::"
-  # 679MB
-  sudo rm -rf /opt/az || :
-  echo "::group::/opt/microsoft/*"
-  du -hsc /opt/microsoft/*
-  echo "::endgroup::"
-  # 197MB
-  sudo rm -rf /opt/microsoft/powershell || :
-  echo "::group::/opt/hostedtoolcache/*"
-  du -hsc /opt/hostedtoolcache/*
-  echo "::endgroup::"
-  # 5.3GB
-  sudo rm -rf /opt/hostedtoolcache/CodeQL || :
-  # 1.4GB
-  sudo rm -rf /opt/hostedtoolcache/go || :
-  # 489MB
-  sudo rm -rf /opt/hostedtoolcache/PyPy || :
-  # 376MB
-  sudo rm -rf /opt/hostedtoolcache/node || :
-  # Remove Web browser packages
-  sudo apt purge -y \
-    firefox \
-    google-chrome-stable \
-    microsoft-edge-stable
-  df -h
-fi
+df -h
+echo "::group::/usr/local/*"
+du -hsc /usr/local/*
+echo "::endgroup::"
+# ~1GB
+sudo rm -rf \
+  /usr/local/aws-cli \
+  /usr/local/aws-sam-cil \
+  /usr/local/julia* || :
+echo "::group::/usr/local/bin/*"
+du -hsc /usr/local/bin/*
+echo "::endgroup::"
+# ~1GB (From 1.2GB to 214MB)
+sudo rm -rf \
+  /usr/local/bin/aliyun \
+  /usr/local/bin/aws \
+  /usr/local/bin/aws_completer \
+  /usr/local/bin/azcopy \
+  /usr/local/bin/bicep \
+  /usr/local/bin/cmake-gui \
+  /usr/local/bin/cpack \
+  /usr/local/bin/helm \
+  /usr/local/bin/hub \
+  /usr/local/bin/kubectl \
+  /usr/local/bin/minikube \
+  /usr/local/bin/node \
+  /usr/local/bin/packer \
+  /usr/local/bin/pulumi* \
+  /usr/local/bin/sam \
+  /usr/local/bin/stack \
+  /usr/local/bin/terraform || :
+# 142M
+sudo rm -rf /usr/local/bin/oc || : \
+echo "::group::/usr/local/share/*"
+du -hsc /usr/local/share/*
+echo "::endgroup::"
+# 506MB
+sudo rm -rf /usr/local/share/chromium || :
+# 1.3GB
+sudo rm -rf /usr/local/share/powershell || :
+echo "::group::/usr/local/lib/*"
+du -hsc /usr/local/lib/*
+echo "::endgroup::"
+# 15GB
+sudo rm -rf /usr/local/lib/android || :
+# 341MB
+sudo rm -rf /usr/local/lib/heroku || :
+# 1.2GB
+sudo rm -rf /usr/local/lib/node_modules || :
+echo "::group::/opt/*"
+du -hsc /opt/*
+echo "::endgroup::"
+# 679MB
+sudo rm -rf /opt/az || :
+echo "::group::/opt/microsoft/*"
+du -hsc /opt/microsoft/*
+echo "::endgroup::"
+# 197MB
+sudo rm -rf /opt/microsoft/powershell || :
+echo "::group::/opt/hostedtoolcache/*"
+du -hsc /opt/hostedtoolcache/*
+echo "::endgroup::"
+# 5.3GB
+sudo rm -rf /opt/hostedtoolcache/CodeQL || :
+# 1.4GB
+sudo rm -rf /opt/hostedtoolcache/go || :
+# 489MB
+sudo rm -rf /opt/hostedtoolcache/PyPy || :
+# 376MB
+sudo rm -rf /opt/hostedtoolcache/node || :
+# Remove Web browser packages
+sudo apt purge -y \
+  firefox \
+  google-chrome-stable \
+  microsoft-edge-stable
+df -h
diff --git a/dev/tasks/macros.jinja b/dev/tasks/macros.jinja
index 3bcff2f63541f..9ee95dec15a14 100644
--- a/dev/tasks/macros.jinja
+++ b/dev/tasks/macros.jinja
@@ -182,6 +182,11 @@ on:
     displayName: Clone arrow
 {% endmacro %}
 
+{%- macro azure_free_space() -%}
+  - script: arrow/ci/scripts/util_free_space.sh
+    displayName: Free up disk space
+{% endmacro %}
+
 {%- macro azure_upload_releases(pattern) -%}
   - task: UsePythonVersion@0
     inputs:
diff --git a/dev/tasks/r/azure.linux.yml b/dev/tasks/r/azure.linux.yml
index 0cbc70ed00b52..e26a59629fa1a 100644
--- a/dev/tasks/r/azure.linux.yml
+++ b/dev/tasks/r/azure.linux.yml
@@ -16,62 +16,57 @@
 {% import 'macros.jinja' as macros with context %}
 
 jobs:
-  - job: linux
-    pool:
-      vmImage: ubuntu-latest
-    timeoutInMinutes: 360
-    {% if env is defined %}
-    variables:
+- job: linux
+  pool:
+    vmImage: ubuntu-latest
+  timeoutInMinutes: 360
+  {% if env is defined %}
+  variables:
     {% for key, value in env.items() %}
-      {{ key }}: {{ value }}
+    {{ key }}: {{ value }}
     {% endfor %}
-    {% endif %}
-    steps:
-      - script: |
-          set -ex
-          git clone --no-checkout {{ arrow.remote }} arrow
-          git -C arrow fetch -t {{ arrow.remote }} {{ arrow.branch }}
-          git -C arrow checkout FETCH_HEAD
-          git -C arrow submodule update --init --recursive
-        displayName: Clone arrow
+  {% endif %}
+  steps:
+  {{ macros.azure_checkout_arrow() }}
+  {{ macros.azure_free_space() }}
 
-      - script: |
-          set -ex
-          docker -v
-          docker-compose -v
-          cd arrow
-          export R_ORG={{ r_org }}
-          export R_IMAGE={{ r_image }}
-          export R_TAG={{ r_tag }}
-          export DEVTOOLSET_VERSION={{ devtoolset_version|default("") }}
-          export R_CUSTOM_CCACHE={{ r_custom_ccache|default("false") }}
-          docker-compose pull --ignore-pull-failures r
-          docker-compose build r
-        displayName: Docker build
-        env:
-        {{ macros.azure_set_sccache_envvars()|indent(8) }}
+  - script: |
+      set -ex
+      docker -v
+      docker-compose -v
+      cd arrow
+      export R_ORG={{ r_org }}
+      export R_IMAGE={{ r_image }}
+      export R_TAG={{ r_tag }}
+      export DEVTOOLSET_VERSION={{ devtoolset_version|default("") }}
+      export R_CUSTOM_CCACHE={{ r_custom_ccache|default("false") }}
+      docker-compose pull --ignore-pull-failures r
+      docker-compose build r
+    displayName: Docker build
+    env:
+    {{ macros.azure_set_sccache_envvars()|indent(4) }}
 
-      - script: |
-          set -ex
-          cd arrow
-          export R_ORG={{ r_org }}
-          export R_IMAGE={{ r_image }}
-          export R_TAG={{ r_tag }}
-          export ARROW_R_DEV={{ not_cran|default("TRUE") }}
-          # Note that by default, ci/scripts/r_test.sh sets NOT_CRAN=true
-          # if ARROW_R_DEV=TRUE. Pass `-e NOT_CRAN=false` to turn that off.
-          docker-compose run {{ flags|default("") }} r
-        displayName: Docker run
-        env:
-        {{ macros.azure_set_sccache_envvars()|indent(8) }}
+  - script: |
+      set -ex
+      cd arrow
+      export R_ORG={{ r_org }}
+      export R_IMAGE={{ r_image }}
+      export R_TAG={{ r_tag }}
+      export ARROW_R_DEV={{ not_cran|default("TRUE") }}
+      # Note that by default, ci/scripts/r_test.sh sets NOT_CRAN=true
+      # if ARROW_R_DEV=TRUE. Pass `-e NOT_CRAN=false` to turn that off.
+      docker-compose run {{ flags|default("") }} r
+    displayName: Docker run
+    env:
+    {{ macros.azure_set_sccache_envvars()|indent(4) }}
 
-      - script: |
-          set -ex
-          cat arrow/r/check/arrow.Rcheck/00install.out
-        displayName: Dump install logs
-        condition: succeededOrFailed()
-      - script: |
-          set -ex
-          cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
-        displayName: Dump test logs
-        condition: succeededOrFailed()
+  - script: |
+      set -ex
+      cat arrow/r/check/arrow.Rcheck/00install.out
+    displayName: Dump install logs
+    condition: succeededOrFailed()
+  - script: |
+      set -ex
+      cat arrow/r/check/arrow.Rcheck/tests/testthat.Rout*
+    displayName: Dump test logs
+    condition: succeededOrFailed()

From 39298febcd6aa2dc06cd3f10614772688e5deb64 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Tue, 17 Oct 2023 05:33:11 -0400
Subject: [PATCH 574/749] GH-36994: [Java] Use JDK 21 in CI (#38219)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Verify JDK 21 in CI in time for the Arrow v14 release.

### What changes are included in this PR?

* Bump latest Java version from 20 -> 21 in CI

### Are these changes tested?

Yes, via CI.

### Are there any user-facing changes?

No.
* Closes: #36994

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 .github/workflows/java.yml                          | 12 ++++++------
 dev/release/verify-release-candidate.sh             |  6 +-----
 docker-compose.yml                                  |  4 ++--
 docs/source/java/install.rst                        |  2 +-
 java/flight/flight-sql-jdbc-core/pom.xml            |  4 ++--
 java/flight/flight-sql-jdbc-driver/pom.xml          |  4 ++--
 java/flight/pom.xml                                 | 13 +++++++++++++
 java/pom.xml                                        |  4 +++-
 .../arrow/vector/dictionary/DictionaryEncoder.java  |  3 ++-
 9 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 4c144955fbe93..76bc57a6c712c 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -57,7 +57,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        jdk: [8, 11, 17, 20]
+        jdk: [8, 11, 17, 21]
         include:
         - jdk: 8
           title: AMD64 Debian 9 Java JDK 8 Maven 3.5.4
@@ -68,12 +68,12 @@ jobs:
           maven: 3.6.2
           image: debian-java
         - jdk: 17
-          title: AMD64 Ubuntu 22.04 Java JDK 17 Maven 3.9.3
-          maven: 3.9.3
+          title: AMD64 Ubuntu 22.04 Java JDK 17 Maven 3.9.4
+          maven: 3.9.4
           image: eclipse-java
-        - jdk: 20
-          title: AMD64 Ubuntu 22.04 Java JDK 20 Maven 3.9.3
-          maven: 3.9.3
+        - jdk: 21
+          title: AMD64 Ubuntu 22.04 Java JDK 21 Maven 3.9.4
+          maven: 3.9.4
           image: eclipse-java
     env:
       JDK: ${{ matrix.jdk }}
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 241beb16963ad..0c6ac075b636e 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -565,11 +565,7 @@ maybe_setup_nodejs() {
 test_package_java() {
   show_header "Build and test Java libraries"
 
-  # Build and test Java (Requires newer Maven -- I used 3.3.9)
-  # Pin OpenJDK 17 since OpenJDK 20 is incompatible with our versions
-  # of things like Mockito, and we also can't update Mockito due to
-  # not supporting Java 8 anymore
-  maybe_setup_conda maven openjdk=17.0.3 || exit 1
+  maybe_setup_conda maven openjdk || exit 1
 
   pushd java
   if [ ${TEST_JAVA} -gt 0 ]; then
diff --git a/docker-compose.yml b/docker-compose.yml
index 10e2b9fa8e205..0e5034346e780 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1698,8 +1698,8 @@ services:
     #   docker-compose build eclipse-java
     #   docker-compose run eclipse-java
     # Parameters:
-    #   MAVEN: 3.9.3
-    #   JDK: 17, 20
+    #   MAVEN: 3.9.4
+    #   JDK: 17, 21
     image: ${ARCH}/maven:${MAVEN}-eclipse-temurin-${JDK}
     shm_size: *shm-size
     volumes: *java-volumes
diff --git a/docs/source/java/install.rst b/docs/source/java/install.rst
index b0ae9e19c690d..47e91fb39ec7b 100644
--- a/docs/source/java/install.rst
+++ b/docs/source/java/install.rst
@@ -30,7 +30,7 @@ Java Compatibility
 ==================
 
 Java modules are compatible with JDK 8 and above.
-Currently, JDK 8, 11, 17, and 18 are tested in CI.
+Currently, JDK 8, 11, 17, and 21 are tested in CI.
 
 When using Java 9 or later, some JDK internals must be exposed by
 adding ``--add-opens=java.base/java.nio=ALL-UNNAMED`` to the ``java`` command:
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index 106d4f968dbda..34d7c26818775 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -107,14 +107,14 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>4.11.0</version>
+            <version>${mockito.core.version}</version>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-inline</artifactId>
-            <version>4.11.0</version>
+            <version>${mockito.inline.version}</version>
             <scope>test</scope>
         </dependency>
 
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 1fd9222be3747..03fb22db9601c 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -68,14 +68,14 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>4.11.0</version>
+            <version>${mockito.core.version}</version>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-inline</artifactId>
-            <version>4.11.0</version>
+            <version>${mockito.inline.version}</version>
             <scope>test</scope>
         </dependency>
 
diff --git a/java/flight/pom.xml b/java/flight/pom.xml
index b1e1f4d317467..b6b84278c1960 100644
--- a/java/flight/pom.xml
+++ b/java/flight/pom.xml
@@ -52,4 +52,17 @@
             </plugins>
         </pluginManagement>
     </build>
+
+    <profiles>
+        <profile>
+            <id>pin-mockito-jdk8</id>
+            <activation>
+                <jdk>1.8</jdk>
+            </activation>
+            <properties>
+                <mockito.core.version>4.11.0</mockito.core.version>
+                <mockito.inline.version>4.11.0</mockito.inline.version>
+            </properties>
+        </profile>
+    </profiles>
 </project>
diff --git a/java/pom.xml b/java/pom.xml
index cbfe723436af4..b5ec6a61a7e70 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -44,8 +44,10 @@
     <forkCount>2</forkCount>
     <checkstyle.failOnViolation>true</checkstyle.failOnViolation>
     <errorprone.javac.version>9+181-r4173-1</errorprone.javac.version>
-    <error_prone_core.version>2.16</error_prone_core.version>
+    <error_prone_core.version>2.22.0</error_prone_core.version>
     <maven-compiler-plugin.version>3.10.1</maven-compiler-plugin.version>
+    <mockito.core.version>5.5.0</mockito.core.version>
+    <mockito.inline.version>5.2.0</mockito.inline.version>
   </properties>
 
   <scm>
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryEncoder.java b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryEncoder.java
index c44d106f536f5..4368501ffc7b5 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryEncoder.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryEncoder.java
@@ -112,13 +112,14 @@ public static ValueVector decode(ValueVector indices, Dictionary dictionary, Buf
    * @param valueCount dictionary vector valueCount.
    * @return index type.
    */
+  @SuppressWarnings("ComparisonOutOfRange")
   public static ArrowType.Int getIndexType(int valueCount) {
     Preconditions.checkArgument(valueCount >= 0);
     if (valueCount <= Byte.MAX_VALUE) {
       return new ArrowType.Int(8, true);
     } else if (valueCount <= Character.MAX_VALUE) {
       return new ArrowType.Int(16, true);
-    } else if (valueCount <= Integer.MAX_VALUE) {
+    } else if (valueCount <= Integer.MAX_VALUE) { //this comparison will always evaluate to true
       return new ArrowType.Int(32, true);
     } else {
       return new ArrowType.Int(64, true);

From 44a00fc4fe2425d1942121a776ec72494622f54a Mon Sep 17 00:00:00 2001
From: Divyansh200102 <146909065+Divyansh200102@users.noreply.github.com>
Date: Tue, 17 Oct 2023 18:48:41 +0530
Subject: [PATCH 575/749] GH-36044: [Python][Docs] Added ParquetFileFragment to
 the API reference docs (#38277)

* Closes: #36044

Authored-by: Divyansh200102 <divyanshkhatri200102@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/python/api/dataset.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/source/python/api/dataset.rst b/docs/source/python/api/dataset.rst
index ef6484185c20e..3575846c35390 100644
--- a/docs/source/python/api/dataset.rst
+++ b/docs/source/python/api/dataset.rst
@@ -48,6 +48,7 @@ Classes
    ParquetFileFormat
    ParquetReadOptions
    ParquetFragmentScanOptions
+   ParquetFileFragment
    OrcFileFormat
    Partitioning
    PartitioningFactory

From a5043e710939e7691bdd57087bf475df3bc0aa48 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Tue, 17 Oct 2023 21:21:01 +0800
Subject: [PATCH 576/749] GH-37312: [Python][Docs] Update Python docstrings to
 reflect new parquet encoding option (#38070)

### Rationale for this change

Since parquet C++ has complete all encoding, we can publish this in Python doc.

### What changes are included in this PR?

Add encoding in document.

### Are these changes tested?

No

### Are there any user-facing changes?

No

* Closes: #37312

Lead-authored-by: mwish <maplewish117@gmail.com>
Co-authored-by: mwish <1506118561@qq.com>
Co-authored-by: Rok Mihevc <rok@mihevc.org>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/parquet/core.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/python/pyarrow/parquet/core.py b/python/pyarrow/parquet/core.py
index a3e5ef76c99b6..51ad955d19f78 100644
--- a/python/pyarrow/parquet/core.py
+++ b/python/pyarrow/parquet/core.py
@@ -767,13 +767,16 @@ def _sanitize_table(table, new_schema, flavor):
     Other features such as compression algorithms or the new serialized
     data page format must be enabled separately (see 'compression' and
     'data_page_version').
-use_dictionary : bool or list
+use_dictionary : bool or list, default True
     Specify if we should use dictionary encoding in general or only for
     some columns.
-compression : str or dict
+    When encoding the column, if the dictionary size is too large, the
+    column will fallback to ``PLAIN`` encoding. Specially, ``BOOLEAN`` type
+    doesn't support dictionary encoding.
+compression : str or dict, default 'snappy'
     Specify the compression codec, either on a general basis or per-column.
     Valid values: {'NONE', 'SNAPPY', 'GZIP', 'BROTLI', 'LZ4', 'ZSTD'}.
-write_statistics : bool or list
+write_statistics : bool or list, default True
     Specify if we should write statistics in general (default is True) or only
     for some columns.
 use_deprecated_int96_timestamps : bool, default None
@@ -821,7 +824,10 @@ def _sanitize_table(table, new_schema, flavor):
     and should be combined with a compression codec.
 column_encoding : string or dict, default None
     Specify the encoding scheme on a per column basis.
-    Currently supported values: {'PLAIN', 'BYTE_STREAM_SPLIT'}.
+    Can only be used when when ``use_dictionary`` is set to False, and
+    cannot be used in combination with ``use_byte_stream_split``.
+    Currently supported values: {'PLAIN', 'BYTE_STREAM_SPLIT',
+    'DELTA_BINARY_PACKED', 'DELTA_LENGTH_BYTE_ARRAY', 'DELTA_BYTE_ARRAY'}.
     Certain encodings are only compatible with certain data types.
     Please refer to the encodings section of `Reading and writing Parquet
     files <https://arrow.apache.org/docs/cpp/parquet.html#encodings>`_.

From 40571db03cc7f819f33a05dd421ef86816fe0502 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Tue, 17 Oct 2023 17:22:18 +0200
Subject: [PATCH 577/749] MINOR: [R] Avoid stray output from expr when checking
 for 10.13 (#38303)

### Rationale for this change

`expr` was printing the number of matching chars which showed up as noise in the log (which we want to avoid as much as possible to avoid any false positive checks)
See https://github.com/apache/arrow/pull/38236#issuecomment-1761679457 for @ jonkeane's investigation.

### What changes are included in this PR?

Replace use of expr with test.

### Are these changes tested?
Crossbow

Lead-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Jonathan Keane <jkeane@gmail.com>
---
 r/configure | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/r/configure b/r/configure
index addf7b59c7fbf..c957c9946fba0 100755
--- a/r/configure
+++ b/r/configure
@@ -264,7 +264,10 @@ set_pkg_vars () {
     PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"
   fi
 
-  if [ "$UNAME" = "Darwin" ] && expr $(sw_vers -productVersion) : '10\.13'; then
+  # We use expr because the product version returns more than just 10.13 and we want to 
+  # match the substring. However, expr always outputs the number of matched characters
+  # to stdout, to avoid noise in the log we redirect the output to /dev/null
+  if [ "$UNAME" = "Darwin" ] && expr $(sw_vers -productVersion) : '10\.13' >/dev/null 2>&1; then
     # avoid C++17 availability warnings on macOS < 11
     PKG_CFLAGS="$PKG_CFLAGS -D_LIBCPP_DISABLE_AVAILABILITY"
   fi

From ac581fd2a87b35c872cf334bb147851fe1287714 Mon Sep 17 00:00:00 2001
From: Divyansh200102 <146909065+Divyansh200102@users.noreply.github.com>
Date: Tue, 17 Oct 2023 23:47:32 +0530
Subject: [PATCH 578/749] GH-38216: [R] open_dataset(format = "json") not
 documented (#38258)

fixes #38216
* Closes: #38216

Lead-authored-by: Divyansh200102 <divyanshkhatri200102@gmail.com>
Co-authored-by: Divyansh200102 <146909065+Divyansh200102@users.noreply.github.com>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Jonathan Keane <jkeane@gmail.com>
---
 r/R/dataset.R         | 3 ++-
 r/man/open_dataset.Rd | 7 ++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/r/R/dataset.R b/r/R/dataset.R
index 90e6516927e5d..2400d0839351b 100644
--- a/r/R/dataset.R
+++ b/r/R/dataset.R
@@ -112,7 +112,8 @@
 #' * "csv"/"text", aliases for the same thing (because comma is the default
 #'   delimiter for text files
 #' * "tsv", equivalent to passing `format = "text", delimiter = "\t"`
-#'
+#' * "json", for JSON format datasets Note: only newline-delimited JSON (aka ND-JSON) datasets
+#'   are currently supported
 #' Default is "parquet", unless a `delimiter` is also specified, in which case
 #' it is assumed to be "text".
 #' @param ... additional arguments passed to `dataset_factory()` when `sources`
diff --git a/r/man/open_dataset.Rd b/r/man/open_dataset.Rd
index 94b537a1d38c6..7c3d32289f73e 100644
--- a/r/man/open_dataset.Rd
+++ b/r/man/open_dataset.Rd
@@ -74,10 +74,11 @@ only version 2 files are supported
 \item "csv"/"text", aliases for the same thing (because comma is the default
 delimiter for text files
 \item "tsv", equivalent to passing \verb{format = "text", delimiter = "\\t"}
-}
-
+\item "json", for JSON format datasets Note: only newline-delimited JSON (aka ND-JSON) datasets
+are currently supported
 Default is "parquet", unless a \code{delimiter} is also specified, in which case
-it is assumed to be "text".}
+it is assumed to be "text".
+}}
 
 \item{factory_options}{list of optional FileSystemFactoryOptions:
 \itemize{

From f1a32a510a3d822e2ce60f0ee95988147830c9a3 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Wed, 18 Oct 2023 08:47:27 +0200
Subject: [PATCH 579/749] GH-38312: [Docs] Add the Arrow C Device data
 interface page to the sidebar TOC (#38313)

* Closes: #38312

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 docs/source/format/ADBC.rst  | 2 +-
 docs/source/format/index.rst | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/source/format/ADBC.rst b/docs/source/format/ADBC.rst
index 3bf4360a70665..0bd835e97db08 100644
--- a/docs/source/format/ADBC.rst
+++ b/docs/source/format/ADBC.rst
@@ -19,7 +19,7 @@
 ADBC: Arrow Database Connectivity
 =================================
 
-Full Documentation on ADBC can be found at `https://arrow.apache.org/adbc/`_.
+Full Documentation on ADBC can be found at https://arrow.apache.org/adbc/.
 
 Rationale
 =========
diff --git a/docs/source/format/index.rst b/docs/source/format/index.rst
index 2c953a7298db4..856830d863243 100644
--- a/docs/source/format/index.rst
+++ b/docs/source/format/index.rst
@@ -29,6 +29,7 @@ Specifications
    Other
    CDataInterface
    CStreamInterface
+   CDeviceDataInterface
    Flight
    FlightSql
    ADBC

From 58546e2002df0d49832061925d099736a510505e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 18 Oct 2023 16:34:37 +0900
Subject: [PATCH 580/749] MINOR: [JS] Bump @babel/traverse from 7.22.5 to
 7.23.2 in /js (#38288)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [@ babel/traverse](https://github.com/babel/babel/tree/HEAD/packages/babel-traverse) from 7.22.5 to 7.23.2.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/babel/babel/releases"><code>@​babel/traverse</code>'s releases</a>.</em></p>
<blockquote>
<h2>v7.23.2 (2023-10-11)</h2>
<p><strong>NOTE</strong>: This release also re-publishes <code>@ babel/core</code>, even if it does not appear in the linked release commit.</p>
<p>Thanks <a href="https://github.com/jimmydief"><code>@​jimmydief</code></a> for your first PR!</p>
<h4>:bug: Bug Fix</h4>
<ul>
<li><code>babel-traverse</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16033">#16033</a> Only evaluate own String/Number/Math methods (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-preset-typescript</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16022">#16022</a> Rewrite <code>.tsx</code> extension when using <code>rewriteImportExtensions</code> (<a href="https://github.com/jimmydief"><code>@​jimmydief</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16017">#16017</a> Fix: fallback to typeof when toString is applied to incompatible object (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16025">#16025</a> Avoid override mistake in namespace imports (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
</ul>
<h4>Committers: 5</h4>
<ul>
<li>Babel Bot (<a href="https://github.com/babel-bot"><code>@​babel-bot</code></a>)</li>
<li>Huáng Jùnliàng (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
<li>James Diefenderfer (<a href="https://github.com/jimmydief"><code>@​jimmydief</code></a>)</li>
<li>Nicolò Ribaudo (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
<li><a href="https://github.com/liuxingbaoyu"><code>@​liuxingbaoyu</code></a></li>
</ul>
<h2>v7.23.1 (2023-09-25)</h2>
<p>Re-publishing <code>@ babel/helpers</code> due to a publishing error in 7.23.0.</p>
<h2>v7.23.0 (2023-09-25)</h2>
<p>Thanks <a href="https://github.com/lorenzoferre"><code>@​lorenzoferre</code></a> and <a href="https://github.com/RajShukla1"><code>@​RajShukla1</code></a> for your first PRs!</p>
<h4>:rocket: New Feature</h4>
<ul>
<li><code>babel-plugin-proposal-import-wasm-source</code>, <code>babel-plugin-syntax-import-source</code>, <code>babel-plugin-transform-dynamic-import</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15870">#15870</a> Support transforming <code>import source</code> for wasm (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-helper-module-transforms</code>, <code>babel-helpers</code>, <code>babel-plugin-proposal-import-defer</code>, <code>babel-plugin-syntax-import-defer</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>, <code>babel-standalone</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15878">#15878</a> Implement <code>import defer</code> proposal transform support (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-generator</code>, <code>babel-parser</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15845">#15845</a> Implement <code>import defer</code> parsing support (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
<li><a href="https://redirect.github.com/babel/babel/pull/15829">#15829</a> Add parsing support for the &quot;source phase imports&quot; proposal (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-generator</code>, <code>babel-helper-module-transforms</code>, <code>babel-parser</code>, <code>babel-plugin-transform-dynamic-import</code>, <code>babel-plugin-transform-modules-amd</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-plugin-transform-modules-systemjs</code>, <code>babel-traverse</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15682">#15682</a> Add <code>createImportExpressions</code> parser option (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-standalone</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15671">#15671</a> Pass through nonce to the transformed script element (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-helper-function-name</code>, <code>babel-helper-member-expression-to-functions</code>, <code>babel-helpers</code>, <code>babel-parser</code>, <code>babel-plugin-proposal-destructuring-private</code>, <code>babel-plugin-proposal-optional-chaining-assign</code>, <code>babel-plugin-syntax-optional-chaining-assign</code>, <code>babel-plugin-transform-destructuring</code>, <code>babel-plugin-transform-optional-chaining</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>, <code>babel-standalone</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15751">#15751</a> Add support for optional chain in assignments (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>, <code>babel-plugin-proposal-decorators</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15895">#15895</a> Implement the &quot;decorator metadata&quot; proposal (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-traverse</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15893">#15893</a> Add <code>t.buildUndefinedNode</code> (<a href="https://github.com/liuxingbaoyu"><code>@​liuxingbaoyu</code></a>)</li>
</ul>
</li>
<li><code>babel-preset-typescript</code></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/babel/babel/blob/main/CHANGELOG.md"><code>@​babel/traverse</code>'s changelog</a>.</em></p>
<blockquote>
<h2>v7.23.2 (2023-10-11)</h2>
<h4>:bug: Bug Fix</h4>
<ul>
<li><code>babel-traverse</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16033">#16033</a> Only evaluate own String/Number/Math methods (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-preset-typescript</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16022">#16022</a> Rewrite <code>.tsx</code> extension when using <code>rewriteImportExtensions</code> (<a href="https://github.com/jimmydief"><code>@​jimmydief</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16017">#16017</a> Fix: fallback to typeof when toString is applied to incompatible object (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/16025">#16025</a> Avoid override mistake in namespace imports (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
</ul>
<h2>v7.23.0 (2023-09-25)</h2>
<h4>:rocket: New Feature</h4>
<ul>
<li><code>babel-plugin-proposal-import-wasm-source</code>, <code>babel-plugin-syntax-import-source</code>, <code>babel-plugin-transform-dynamic-import</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15870">#15870</a> Support transforming <code>import source</code> for wasm (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-helper-module-transforms</code>, <code>babel-helpers</code>, <code>babel-plugin-proposal-import-defer</code>, <code>babel-plugin-syntax-import-defer</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>, <code>babel-standalone</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15878">#15878</a> Implement <code>import defer</code> proposal transform support (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-generator</code>, <code>babel-parser</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15845">#15845</a> Implement <code>import defer</code> parsing support (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
<li><a href="https://redirect.github.com/babel/babel/pull/15829">#15829</a> Add parsing support for the &quot;source phase imports&quot; proposal (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-generator</code>, <code>babel-helper-module-transforms</code>, <code>babel-parser</code>, <code>babel-plugin-transform-dynamic-import</code>, <code>babel-plugin-transform-modules-amd</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-plugin-transform-modules-systemjs</code>, <code>babel-traverse</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15682">#15682</a> Add <code>createImportExpressions</code> parser option (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-standalone</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15671">#15671</a> Pass through nonce to the transformed script element (<a href="https://github.com/JLHwung"><code>@​JLHwung</code></a>)</li>
</ul>
</li>
<li><code>babel-helper-function-name</code>, <code>babel-helper-member-expression-to-functions</code>, <code>babel-helpers</code>, <code>babel-parser</code>, <code>babel-plugin-proposal-destructuring-private</code>, <code>babel-plugin-proposal-optional-chaining-assign</code>, <code>babel-plugin-syntax-optional-chaining-assign</code>, <code>babel-plugin-transform-destructuring</code>, <code>babel-plugin-transform-optional-chaining</code>, <code>babel-runtime-corejs2</code>, <code>babel-runtime-corejs3</code>, <code>babel-runtime</code>, <code>babel-standalone</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15751">#15751</a> Add support for optional chain in assignments (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-helpers</code>, <code>babel-plugin-proposal-decorators</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15895">#15895</a> Implement the &quot;decorator metadata&quot; proposal (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-traverse</code>, <code>babel-types</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15893">#15893</a> Add <code>t.buildUndefinedNode</code> (<a href="https://github.com/liuxingbaoyu"><code>@​liuxingbaoyu</code></a>)</li>
</ul>
</li>
<li><code>babel-preset-typescript</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15913">#15913</a> Add <code>rewriteImportExtensions</code> option to TS preset (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
<li><code>babel-parser</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15896">#15896</a> Allow TS tuples to have both labeled and unlabeled elements (<a href="https://github.com/yukukotani"><code>@​yukukotani</code></a>)</li>
</ul>
</li>
</ul>
<h4>:bug: Bug Fix</h4>
<ul>
<li><code>babel-plugin-transform-block-scoping</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15962">#15962</a> fix: <code>transform-block-scoping</code> captures the variables of the method in the loop (<a href="https://github.com/liuxingbaoyu"><code>@​liuxingbaoyu</code></a>)</li>
</ul>
</li>
</ul>
<h4>:nail_care: Polish</h4>
<ul>
<li><code>babel-traverse</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15797">#15797</a> Expand evaluation of global built-ins in <code>@ babel/traverse</code> (<a href="https://github.com/lorenzoferre"><code>@​lorenzoferre</code></a>)</li>
</ul>
</li>
<li><code>babel-plugin-proposal-explicit-resource-management</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15985">#15985</a> Improve source maps for blocks with <code>using</code> declarations (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
</ul>
<h4>:microscope: Output optimization</h4>
<ul>
<li><code>babel-core</code>, <code>babel-helper-module-transforms</code>, <code>babel-plugin-transform-async-to-generator</code>, <code>babel-plugin-transform-classes</code>, <code>babel-plugin-transform-dynamic-import</code>, <code>babel-plugin-transform-function-name</code>, <code>babel-plugin-transform-modules-amd</code>, <code>babel-plugin-transform-modules-commonjs</code>, <code>babel-plugin-transform-modules-umd</code>, <code>babel-plugin-transform-parameters</code>, <code>babel-plugin-transform-react-constant-elements</code>, <code>babel-plugin-transform-react-inline-elements</code>, <code>babel-plugin-transform-runtime</code>, <code>babel-plugin-transform-typescript</code>, <code>babel-preset-env</code>
<ul>
<li><a href="https://redirect.github.com/babel/babel/pull/15984">#15984</a> Inline <code>exports.XXX =</code> update in simple variable declarations (<a href="https://github.com/nicolo-ribaudo"><code>@​nicolo-ribaudo</code></a>)</li>
</ul>
</li>
</ul>
<h2>v7.22.20 (2023-09-16)</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/babel/babel/commit/b4b9942a6cde0685c222eb3412347880aae40ad5"><code>b4b9942</code></a> v7.23.2</li>
<li><a href="https://github.com/babel/babel/commit/b13376b346946e3f62fc0848c1d2a23223314c82"><code>b13376b</code></a> Only evaluate own String/Number/Math methods (<a href="https://github.com/babel/babel/tree/HEAD/packages/babel-traverse/issues/16033">#16033</a>)</li>
<li><a href="https://github.com/babel/babel/commit/ca58ec15cb6dde6812c36997477e44880bec0bba"><code>ca58ec1</code></a> v7.23.0</li>
<li><a href="https://github.com/babel/babel/commit/0f333dafcf470f1970083e4e695ced6aec8bead0"><code>0f333da</code></a> Add <code>createImportExpressions</code> parser option (<a href="https://github.com/babel/babel/tree/HEAD/packages/babel-traverse/issues/15682">#15682</a>)</li>
<li><a href="https://github.com/babel/babel/commit/3744545649fdc21688a2f3c97e1e39dbebff0d21"><code>3744545</code></a> Fix linting</li>
<li><a href="https://github.com/babel/babel/commit/c7e6806e2194deb36c330f543409c792592b22d4"><code>c7e6806</code></a> Add <code>t.buildUndefinedNode</code> (<a href="https://github.com/babel/babel/tree/HEAD/packages/babel-traverse/issues/15893">#15893</a>)</li>
<li><a href="https://github.com/babel/babel/commit/38ee8b4dd693f1e2bd00107bbc1167ce84736ea0"><code>38ee8b4</code></a> Expand evaluation of global built-ins in <code>@ babel/traverse</code> (<a href="https://github.com/babel/babel/tree/HEAD/packages/babel-traverse/issues/15797">#15797</a>)</li>
<li><a href="https://github.com/babel/babel/commit/9f3dfd90211472cf0083a3234dd1a1b857ce3624"><code>9f3dfd9</code></a> v7.22.20</li>
<li><a href="https://github.com/babel/babel/commit/3ed28b29c1fb15588369bdd55187b69f1248e87d"><code>3ed28b2</code></a> Fully support <code>||</code> and <code>&amp;&amp;</code> in <code>pluginToggleBooleanFlag</code> (<a href="https://github.com/babel/babel/tree/HEAD/packages/babel-traverse/issues/15961">#15961</a>)</li>
<li><a href="https://github.com/babel/babel/commit/77b0d7359909c94f3797c24006f244847fbc8d6d"><code>77b0d73</code></a> v7.22.19</li>
<li>Additional commits viewable in <a href="https://github.com/babel/babel/commits/v7.23.2/packages/babel-traverse">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=@ babel/traverse&package-manager=npm_and_yarn&previous-version=7.22.5&new-version=7.23.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/apache/arrow/network/alerts).

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/yarn.lock | 103 ++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 85 insertions(+), 18 deletions(-)

diff --git a/js/yarn.lock b/js/yarn.lock
index f027be218245f..6677772086ad5 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -59,6 +59,14 @@
   dependencies:
     "@babel/highlight" "^7.22.5"
 
+"@babel/code-frame@^7.22.13":
+  version "7.22.13"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.22.13.tgz#e3c1c099402598483b7a8c46a721d1038803755e"
+  integrity sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==
+  dependencies:
+    "@babel/highlight" "^7.22.13"
+    chalk "^2.4.2"
+
 "@babel/compat-data@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.22.5.tgz#b1f6c86a02d85d2dd3368a2b67c09add8cd0c255"
@@ -95,6 +103,16 @@
     "@jridgewell/trace-mapping" "^0.3.17"
     jsesc "^2.5.1"
 
+"@babel/generator@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.23.0.tgz#df5c386e2218be505b34837acbcb874d7a983420"
+  integrity sha512-lN85QRR+5IbYrMWM6Y4pE/noaQtg4pNiqeNGX60eqOfo6gtEj6uw/JagelB8vVztSd7R6M5n1+PQkDbHbBRU4g==
+  dependencies:
+    "@babel/types" "^7.23.0"
+    "@jridgewell/gen-mapping" "^0.3.2"
+    "@jridgewell/trace-mapping" "^0.3.17"
+    jsesc "^2.5.1"
+
 "@babel/helper-compilation-targets@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.5.tgz#fc7319fc54c5e2fa14b2909cf3c5fd3046813e02"
@@ -106,18 +124,23 @@
     lru-cache "^5.1.1"
     semver "^6.3.0"
 
+"@babel/helper-environment-visitor@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.20.tgz#96159db61d34a29dba454c959f5ae4a649ba9167"
+  integrity sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==
+
 "@babel/helper-environment-visitor@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz#f06dd41b7c1f44e1f8da6c4055b41ab3a09a7e98"
   integrity sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==
 
-"@babel/helper-function-name@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.22.5.tgz#ede300828905bb15e582c037162f99d5183af1be"
-  integrity sha512-wtHSq6jMRE3uF2otvfuD3DIvVhOsSNshQl0Qrd7qC9oQJzHvOL4qQXlQn2916+CXGywIjpGuIkoyZRRxHPiNQQ==
+"@babel/helper-function-name@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.23.0.tgz#1f9a3cdbd5b2698a670c30d2735f9af95ed52759"
+  integrity sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==
   dependencies:
-    "@babel/template" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/template" "^7.22.15"
+    "@babel/types" "^7.23.0"
 
 "@babel/helper-hoist-variables@^7.22.5":
   version "7.22.5"
@@ -166,6 +189,13 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
+"@babel/helper-split-export-declaration@^7.22.6":
+  version "7.22.6"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c"
+  integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==
+  dependencies:
+    "@babel/types" "^7.22.5"
+
 "@babel/helper-string-parser@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f"
@@ -176,6 +206,11 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz#9544ef6a33999343c8740fa51350f30eeaaaf193"
   integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==
 
+"@babel/helper-validator-identifier@^7.22.20":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz#c4ae002c61d2879e724581d96665583dbc1dc0e0"
+  integrity sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==
+
 "@babel/helper-validator-option@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz#de52000a15a177413c8234fa3a8af4ee8102d0ac"
@@ -190,6 +225,15 @@
     "@babel/traverse" "^7.22.5"
     "@babel/types" "^7.22.5"
 
+"@babel/highlight@^7.22.13":
+  version "7.22.20"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.22.20.tgz#4ca92b71d80554b01427815e06f2df965b9c1f54"
+  integrity sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.22.20"
+    chalk "^2.4.2"
+    js-tokens "^4.0.0"
+
 "@babel/highlight@^7.22.5":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.22.5.tgz#aa6c05c5407a67ebce408162b7ede789b4d22031"
@@ -204,6 +248,11 @@
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.5.tgz#721fd042f3ce1896238cf1b341c77eb7dee7dbea"
   integrity sha512-DFZMC9LJUG9PLOclRC32G63UXwzqS2koQC8dkx+PLdmt1xSePYpbT/NbsrJy8Q/muXz7o/h/d4A7Fuyixm559Q==
 
+"@babel/parser@^7.22.15", "@babel/parser@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.23.0.tgz#da950e622420bf96ca0d0f2909cdddac3acd8719"
+  integrity sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==
+
 "@babel/plugin-syntax-async-generators@^7.8.4":
   version "7.8.4"
   resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
@@ -302,6 +351,15 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
+"@babel/template@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.22.15.tgz#09576efc3830f0430f4548ef971dde1350ef2f38"
+  integrity sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==
+  dependencies:
+    "@babel/code-frame" "^7.22.13"
+    "@babel/parser" "^7.22.15"
+    "@babel/types" "^7.22.15"
+
 "@babel/template@^7.22.5", "@babel/template@^7.3.3":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.22.5.tgz#0c8c4d944509875849bd0344ff0050756eefc6ec"
@@ -312,18 +370,18 @@
     "@babel/types" "^7.22.5"
 
 "@babel/traverse@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.22.5.tgz#44bd276690db6f4940fdb84e1cb4abd2f729ccd1"
-  integrity sha512-7DuIjPgERaNo6r+PZwItpjCZEa5vyw4eJGufeLxrPdBXBoLcCJCIasvK6pK/9DVNrLZTLFhUGqaC6X/PA007TQ==
-  dependencies:
-    "@babel/code-frame" "^7.22.5"
-    "@babel/generator" "^7.22.5"
-    "@babel/helper-environment-visitor" "^7.22.5"
-    "@babel/helper-function-name" "^7.22.5"
+  version "7.23.2"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.23.2.tgz#329c7a06735e144a506bdb2cad0268b7f46f4ad8"
+  integrity sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==
+  dependencies:
+    "@babel/code-frame" "^7.22.13"
+    "@babel/generator" "^7.23.0"
+    "@babel/helper-environment-visitor" "^7.22.20"
+    "@babel/helper-function-name" "^7.23.0"
     "@babel/helper-hoist-variables" "^7.22.5"
-    "@babel/helper-split-export-declaration" "^7.22.5"
-    "@babel/parser" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    "@babel/parser" "^7.23.0"
+    "@babel/types" "^7.23.0"
     debug "^4.1.0"
     globals "^11.1.0"
 
@@ -336,6 +394,15 @@
     "@babel/helper-validator-identifier" "^7.22.5"
     to-fast-properties "^2.0.0"
 
+"@babel/types@^7.22.15", "@babel/types@^7.23.0":
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.23.0.tgz#8c1f020c9df0e737e4e247c0619f58c68458aaeb"
+  integrity sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==
+  dependencies:
+    "@babel/helper-string-parser" "^7.22.5"
+    "@babel/helper-validator-identifier" "^7.22.20"
+    to-fast-properties "^2.0.0"
+
 "@bcoe/v8-coverage@^0.2.3":
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
@@ -2064,7 +2131,7 @@ chalk@4.x, chalk@^4.0.0, chalk@^4.1.2:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^2.0.0:
+chalk@^2.0.0, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==

From fd57b7ae1cc29bad579dc0d2661f3417bada0334 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 18 Oct 2023 12:04:50 +0200
Subject: [PATCH 581/749] GH-38304: [C++][Parquet] Fix Valgrind memory leak in
 arrow-dataset-file-parquet-encryption-test (#38306)

If OpenSSL initializes itself from a non-main thread, it can fail deallocating all memory at shutdown.

This is really a benign leak, but we don't want any spurious CI errors.

* Closes: #38304

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../dataset/file_parquet_encryption_test.cc   |  8 +++++
 cpp/src/parquet/CMakeLists.txt                |  3 +-
 .../parquet/encryption/encryption_internal.cc | 13 ++++++-
 .../parquet/encryption/encryption_internal.h  |  8 +++++
 .../encryption/encryption_internal_nossl.cc   |  2 ++
 .../parquet/encryption/openssl_internal.cc    | 34 +++++++++++++++++++
 cpp/src/parquet/encryption/openssl_internal.h | 28 +++++++++++++++
 7 files changed, 94 insertions(+), 2 deletions(-)
 create mode 100644 cpp/src/parquet/encryption/openssl_internal.cc
 create mode 100644 cpp/src/parquet/encryption/openssl_internal.h

diff --git a/cpp/src/arrow/dataset/file_parquet_encryption_test.cc b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc
index 572f15e100dcb..87028eb6e2fac 100644
--- a/cpp/src/arrow/dataset/file_parquet_encryption_test.cc
+++ b/cpp/src/arrow/dataset/file_parquet_encryption_test.cc
@@ -34,6 +34,7 @@
 #include "parquet/arrow/reader.h"
 #include "parquet/encryption/crypto_factory.h"
 #include "parquet/encryption/encryption.h"
+#include "parquet/encryption/encryption_internal.h"
 #include "parquet/encryption/kms_client.h"
 #include "parquet/encryption/test_in_memory_kms.h"
 
@@ -58,6 +59,13 @@ class DatasetEncryptionTest : public ::testing::Test {
   // partitioning scheme. The function also checks if the written files exist in the file
   // system.
   static void SetUpTestSuite() {
+#ifdef ARROW_VALGRIND
+    // Not necessary otherwise, but prevents a Valgrind leak by making sure
+    // OpenSSL initialization is done from the main thread
+    // (see GH-38304 for analysis).
+    ::parquet::encryption::EnsureBackendInitialized();
+#endif
+
     // Creates a mock file system using the current time point.
     EXPECT_OK_AND_ASSIGN(file_system_, fs::internal::MockFileSystem::Make(
                                            std::chrono::system_clock::now(), {}));
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index 3cdd24dbe9eb9..0d04ec3e306e5 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -234,7 +234,8 @@ if(ARROW_HAVE_RUNTIME_AVX2)
 endif()
 
 if(PARQUET_REQUIRE_ENCRYPTION)
-  set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal.cc)
+  set(PARQUET_SRCS ${PARQUET_SRCS} encryption/encryption_internal.cc
+                   encryption/openssl_internal.cc)
   # Encryption key management
   set(PARQUET_SRCS
       ${PARQUET_SRCS}
diff --git a/cpp/src/parquet/encryption/encryption_internal.cc b/cpp/src/parquet/encryption/encryption_internal.cc
index 6e66efeff6326..b1770be53358d 100644
--- a/cpp/src/parquet/encryption/encryption_internal.cc
+++ b/cpp/src/parquet/encryption/encryption_internal.cc
@@ -16,6 +16,7 @@
 // under the License.
 
 #include "parquet/encryption/encryption_internal.h"
+
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/rand.h>
@@ -27,6 +28,7 @@
 #include <string>
 #include <vector>
 
+#include "parquet/encryption/openssl_internal.h"
 #include "parquet/exception.h"
 
 using parquet::ParquetException;
@@ -92,6 +94,8 @@ class AesEncryptor::AesEncryptorImpl {
 
 AesEncryptor::AesEncryptorImpl::AesEncryptorImpl(ParquetCipher::type alg_id, int key_len,
                                                  bool metadata, bool write_length) {
+  openssl::EnsureInitialized();
+
   ctx_ = nullptr;
 
   length_buffer_length_ = write_length ? kBufferSizeLength : 0;
@@ -358,6 +362,8 @@ AesDecryptor::~AesDecryptor() {}
 
 AesDecryptor::AesDecryptorImpl::AesDecryptorImpl(ParquetCipher::type alg_id, int key_len,
                                                  bool metadata, bool contains_length) {
+  openssl::EnsureInitialized();
+
   ctx_ = nullptr;
   length_buffer_length_ = contains_length ? kBufferSizeLength : 0;
   ciphertext_size_delta_ = length_buffer_length_ + kNonceLength;
@@ -646,6 +652,11 @@ void QuickUpdatePageAad(int32_t new_page_ordinal, std::string* AAD) {
   std::memcpy(AAD->data() + AAD->length() - 2, page_ordinal_bytes.data(), 2);
 }
 
-void RandBytes(unsigned char* buf, int num) { RAND_bytes(buf, num); }
+void RandBytes(unsigned char* buf, int num) {
+  openssl::EnsureInitialized();
+  RAND_bytes(buf, num);
+}
+
+void EnsureBackendInitialized() { openssl::EnsureInitialized(); }
 
 }  // namespace parquet::encryption
diff --git a/cpp/src/parquet/encryption/encryption_internal.h b/cpp/src/parquet/encryption/encryption_internal.h
index 77921d8731d25..1bdf47c56f291 100644
--- a/cpp/src/parquet/encryption/encryption_internal.h
+++ b/cpp/src/parquet/encryption/encryption_internal.h
@@ -130,4 +130,12 @@ void QuickUpdatePageAad(int32_t new_page_ordinal, std::string* AAD);
 // Wraps OpenSSL RAND_bytes function
 void RandBytes(unsigned char* buf, int num);
 
+// Ensure OpenSSL is initialized.
+//
+// This is only necessary in specific situations since OpenSSL otherwise
+// initializes itself automatically. For example, under Valgrind, a memory
+// leak will be reported if OpenSSL is initialized for the first time from
+// a worker thread; calling this function from the main thread prevents this.
+void EnsureBackendInitialized();
+
 }  // namespace parquet::encryption
diff --git a/cpp/src/parquet/encryption/encryption_internal_nossl.cc b/cpp/src/parquet/encryption/encryption_internal_nossl.cc
index 0241923474de9..ead868643baae 100644
--- a/cpp/src/parquet/encryption/encryption_internal_nossl.cc
+++ b/cpp/src/parquet/encryption/encryption_internal_nossl.cc
@@ -114,4 +114,6 @@ void QuickUpdatePageAad(int32_t new_page_ordinal, std::string* AAD) {
 
 void RandBytes(unsigned char* buf, int num) { ThrowOpenSSLRequiredException(); }
 
+void EnsureBackendInitialized() {}
+
 }  // namespace parquet::encryption
diff --git a/cpp/src/parquet/encryption/openssl_internal.cc b/cpp/src/parquet/encryption/openssl_internal.cc
new file mode 100644
index 0000000000000..05f2773532353
--- /dev/null
+++ b/cpp/src/parquet/encryption/openssl_internal.cc
@@ -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.
+
+#include "parquet/encryption/openssl_internal.h"
+
+#include <openssl/crypto.h>
+
+#include "parquet/exception.h"
+
+namespace parquet::encryption::openssl {
+
+void EnsureInitialized() {
+  // Initialize ciphers and random engines
+  if (!OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN | OPENSSL_INIT_ADD_ALL_CIPHERS,
+                           NULL)) {
+    throw ParquetException("OpenSSL initialization failed");
+  }
+}
+
+}  // namespace parquet::encryption::openssl
diff --git a/cpp/src/parquet/encryption/openssl_internal.h b/cpp/src/parquet/encryption/openssl_internal.h
new file mode 100644
index 0000000000000..096aaf9640463
--- /dev/null
+++ b/cpp/src/parquet/encryption/openssl_internal.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace parquet::encryption::openssl {
+
+void EnsureInitialized();
+
+}  // namespace parquet::encryption::openssl

From b7fdeaa6fc188f1ca8fb275802c9e71cf2e55e8e Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 18 Oct 2023 13:05:08 +0200
Subject: [PATCH 582/749] MINOR: Update dev docs link on README.md (#38322)

### Rationale for this change

Broken link on the [arrow/README.md](https://github.com/apache/arrow/blob/main/README.md?plain=1#L102) after the landing page for the dev docs has been changed in https://github.com/apache/arrow/pull/36591.
### What changes are included in this PR?

Update the link.

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 98e1512bacb50..664ada289bd4d 100644
--- a/README.md
+++ b/README.md
@@ -99,4 +99,4 @@ integrations in other projects, we'd be happy to have you involved:
 [2]: https://github.com/apache/arrow/tree/main/format
 [3]: https://github.com/apache/arrow/issues
 [4]: https://github.com/apache/arrow
-[5]: https://arrow.apache.org/docs/dev/developers/contributing.html
+[5]: https://arrow.apache.org/docs/dev/developers/index.html

From d68f8e21643e8aec9ed253094edfd15c0a08f1c1 Mon Sep 17 00:00:00 2001
From: Will Jones <willjones127@gmail.com>
Date: Wed, 18 Oct 2023 04:44:50 -0700
Subject: [PATCH 583/749] GH-35531: [Python] C Data Interface PyCapsule
 Protocol (#37797)

### Rationale for this change

### What changes are included in this PR?

* A new specification for Arrow PyCapsules and related dunder methods
* Implementing the dunder methods for `DataType`, `Field`, `Schema`, `Array`, `RecordBatch`, `Table`, and `RecordBatchReader`.

### Are these changes tested?

Yes, I've added various roundtrip tests for each of the types.

### Are there any user-facing changes?

This introduces some new APIs and documents them.

* Closes: #34031
* Closes: #35531

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 docs/source/format/CDataInterface.rst         |  11 +
 .../CDataInterface/PyCapsuleInterface.rst     | 433 ++++++++++++++++++
 docs/source/python/extending_types.rst        |   9 +
 docs/source/python/interchange_protocol.rst   |   2 +
 python/pyarrow/array.pxi                      |  81 +++-
 python/pyarrow/includes/libarrow.pxd          |   6 +-
 python/pyarrow/ipc.pxi                        |  68 ++-
 python/pyarrow/table.pxi                      | 148 +++++-
 python/pyarrow/tests/test_array.py            |  18 +
 python/pyarrow/tests/test_cffi.py             | 126 ++++-
 python/pyarrow/tests/test_table.py            |  87 ++++
 python/pyarrow/tests/test_types.py            |  14 +
 python/pyarrow/types.pxi                      | 185 +++++++-
 13 files changed, 1177 insertions(+), 11 deletions(-)
 create mode 100644 docs/source/format/CDataInterface/PyCapsuleInterface.rst

diff --git a/docs/source/format/CDataInterface.rst b/docs/source/format/CDataInterface.rst
index 8f491470965b0..e0884686acf6c 100644
--- a/docs/source/format/CDataInterface.rst
+++ b/docs/source/format/CDataInterface.rst
@@ -990,3 +990,14 @@ adaptation cost.
 
 
 .. _Python buffer protocol: https://www.python.org/dev/peps/pep-3118/
+
+Language-specific protocols
+===========================
+
+Some languages may define additional protocols on top of the Arrow C data
+interface.
+
+.. toctree::
+   :maxdepth: 1
+
+   CDataInterface/PyCapsuleInterface
diff --git a/docs/source/format/CDataInterface/PyCapsuleInterface.rst b/docs/source/format/CDataInterface/PyCapsuleInterface.rst
new file mode 100644
index 0000000000000..263c428c1ef0e
--- /dev/null
+++ b/docs/source/format/CDataInterface/PyCapsuleInterface.rst
@@ -0,0 +1,433 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements.  See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership.  The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License.  You may obtain a copy of the License at
+
+..   http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT 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 Arrow PyCapsule Interface
+=============================
+
+.. warning:: The Arrow PyCapsule Interface should be considered experimental
+
+Rationale
+=========
+
+The :ref:`C data interface <c-data-interface>` and
+:ref:`C stream interface <c-stream-interface>` allow moving Arrow data between
+different implementations of Arrow. However, these interfaces don't specify how
+Python libraries should expose these structs to other libraries. Prior to this,
+many libraries simply provided export to PyArrow data structures, using the
+``_import_from_c`` and ``_export_from_c`` methods. However, this always required
+PyArrow to be installed. In addition, those APIs could cause memory leaks if
+handled improperly.
+
+This interface allows any library to export Arrow data structures to other
+libraries that understand the same protocol.
+
+Goals
+-----
+
+* Standardize the `PyCapsule`_ objects that represent ``ArrowSchema``, ``ArrowArray``,
+  and ``ArrowArrayStream``.
+* Define standard methods that export Arrow data into such capsule objects,
+  so that any Python library wanting to accept Arrow data as input can call the
+  corresponding method instead of hardcoding support for specific Arrow
+  producers.
+
+
+Non-goals
+---------
+
+* Standardize what public APIs should be used for import. This is left up to
+  individual libraries.
+
+PyCapsule Standard
+==================
+
+When exporting Arrow data through Python, the C Data Interface / C Stream Interface
+structures should be wrapped in capsules. Capsules avoid invalid access by
+attaching a name to the pointer and avoid memory leaks by attaching a destructor.
+Thus, they are much safer than passing pointers as integers.
+
+`PyCapsule`_ allows for a ``name`` to be associated with the capsule, allowing 
+consumers to verify that the capsule contains the expected kind of data. To make sure
+Arrow structures are recognized, the following names must be used:
+
+.. list-table::
+   :widths: 25 25
+   :header-rows: 1
+
+   * - C Interface Type
+     - PyCapsule Name
+   * - ArrowSchema
+     - ``arrow_schema``
+   * - ArrowArray
+     - ``arrow_array``
+   * - ArrowArrayStream
+     - ``arrow_array_stream``
+
+
+Lifetime Semantics
+------------------
+
+The exported PyCapsules should have a destructor that calls the
+:ref:`release callback <c-data-interface-released>`
+of the Arrow struct, if it is not already null. This prevents a memory leak in
+case the capsule was never passed to another consumer.
+
+If the capsule has been passed to a consumer, the consumer should have moved
+the data and marked the release callback as null, so there isn’t a risk of
+releasing data the consumer is using.
+:ref:`Read more in the C Data Interface specification <c-data-interface-released>`.
+
+Just like in the C Data Interface, the PyCapsule objects defined here can only
+be consumed once.
+
+For an example of a PyCapsule with a destructor, see `Create a PyCapsule`_.
+
+
+Export Protocol
+===============
+
+The interface consists of three separate protocols:
+
+* ``ArrowSchemaExportable``, which defines the ``__arrow_c_schema__`` method.
+* ``ArrowArrayExportable``, which defines the ``__arrow_c_array__`` method.
+* ``ArrowStreamExportable``, which defines the ``__arrow_c_stream__`` method.
+
+ArrowSchema Export
+------------------
+
+Schemas, fields, and data types can implement the method ``__arrow_c_schema__``.
+
+.. py:method:: __arrow_c_schema__(self) -> object
+
+    Export the object as an ArrowSchema.
+
+    :return: A PyCapsule containing a C ArrowSchema representation of the
+        object. The capsule must have a name of ``"arrow_schema"``.
+
+
+ArrowArray Export
+-----------------
+
+Arrays and record batches (contiguous tables) can implement the method
+``__arrow_c_array__``.
+
+.. py:method:: __arrow_c_array__(self, requested_schema: object | None = None) -> Tuple[object, object]
+
+    Export the object as a pair of ArrowSchema and ArrowArray structures.
+
+    :param requested_schema: A PyCapsule containing a C ArrowSchema representation 
+        of a requested schema. Conversion to this schema is best-effort. See 
+        `Schema Requests`_.
+    :type requested_schema: PyCapsule or None
+
+    :return: A pair of PyCapsules containing a C ArrowSchema and ArrowArray,
+        respectively. The schema capsule should have the name ``"arrow_schema"``
+        and the array capsule should have the name ``"arrow_array"``.
+
+
+ArrowStream Export
+------------------
+
+Tables / DataFrames and streams can implement the method ``__arrow_c_stream__``.
+
+.. py:method:: __arrow_c_stream__(self, requested_schema: object | None = None) -> object
+
+    Export the object as an ArrowArrayStream.
+
+    :param requested_schema: A PyCapsule containing a C ArrowSchema representation 
+        of a requested schema. Conversion to this schema is best-effort. See 
+        `Schema Requests`_.
+    :type requested_schema: PyCapsule or None
+
+    :return: A PyCapsule containing a C ArrowArrayStream representation of the
+        object. The capsule must have a name of ``"arrow_array_stream"``.
+
+Schema Requests
+---------------
+
+In some cases, there might be multiple possible Arrow representations of the
+same data. For example, a library might have a single integer type, but Arrow
+has multiple integer types with different sizes and sign. As another example,
+Arrow has several possible encodings for an array of strings: 32-bit offsets,
+64-bit offsets, string view, and dictionary-encoded. A sequence of strings could
+export to any one of these Arrow representations.
+
+In order to allow the caller to request a specific representation, the
+:meth:`__arrow_c_array__` and :meth:`__arrow_c_stream__` methods take an optional
+``requested_schema`` parameter. This parameter is a PyCapsule containing an
+``ArrowSchema``.
+
+The callee should attempt to provide the data in the requested schema. However,
+if the callee cannot provide the data in the requested schema, they may return
+with the same schema as if ``None`` were passed to ``requested_schema``.
+
+If the caller requests a schema that is not compatible with the data,
+say requesting a schema with a different number of fields, the callee should
+raise an exception. The requested schema mechanism is only meant to negotiate
+between different representations of the same data and not to allow arbitrary
+schema transformations.
+
+
+.. _PyCapsule: https://docs.python.org/3/c-api/capsule.html
+
+
+Protocol Typehints
+------------------
+
+The following typehints can be copied into your library to annotate that a 
+function accepts an object implementing one of these protocols.
+
+.. code-block:: python
+
+    from typing import Tuple, Protocol
+    from typing_extensions import Self
+
+    class ArrowSchemaExportable(Protocol):
+        def __arrow_c_schema__(self) -> object: ...
+
+    class ArrowArrayExportable(Protocol):
+        def __arrow_c_array__(
+            self,
+            requested_schema: object | None = None
+        ) -> Tuple[object, object]:
+            ...
+
+    class ArrowStreamExportable(Protocol):
+        def __arrow_c_stream__(
+            self,
+            requested_schema: object | None = None
+        ) -> object:
+            ...
+
+Examples
+========
+
+Create a PyCapsule
+------------------
+
+
+To create a PyCapsule, use the `PyCapsule_New <https://docs.python.org/3/c-api/capsule.html#c.PyCapsule_New>`_
+function. The function must be passed a destructor function that will be called
+to release the data the capsule points to. It must first call the release
+callback if it is not null, then free the struct.
+
+Below is the code to create a PyCapsule for an ``ArrowSchema``. The code for
+``ArrowArray`` and ``ArrowArrayStream`` is similar.
+
+.. tab-set::
+
+   .. tab-item:: C
+
+      .. code-block:: c
+
+         #include <Python.h>
+
+         void ReleaseArrowSchemaPyCapsule(PyObject* capsule) {
+             struct ArrowSchema* schema =
+                 (struct ArrowSchema*)PyCapsule_GetPointer(capsule, "arrow_schema");
+             if (schema->release != NULL) {
+                 schema->release(schema);
+             }
+             free(schema);
+         }
+         
+         PyObject* ExportArrowSchemaPyCapsule() {
+             struct ArrowSchema* schema =
+                 (struct ArrowSchema*)malloc(sizeof(struct ArrowSchema));
+             // Fill in ArrowSchema fields
+             // ...
+             return PyCapsule_New(schema, "arrow_schema", ReleaseArrowSchemaPyCapsule);
+         }
+
+   .. tab-item:: Cython
+
+      .. code-block:: cython
+
+         cimport cpython
+         from libc.stdlib cimport malloc, free
+
+         cdef void release_arrow_schema_py_capsule(object schema_capsule):
+             cdef ArrowSchema* schema = <ArrowSchema*>cpython.PyCapsule_GetPointer(
+                 schema_capsule, 'arrow_schema'
+             )
+             if schema.release != NULL:
+                 schema.release(schema)
+         
+             free(schema)
+         
+         cdef object export_arrow_schema_py_capsule():
+             cdef ArrowSchema* schema = <ArrowSchema*>malloc(sizeof(ArrowSchema))
+             # It's recommended to immediately wrap the struct in a capsule, so
+             # if subsequent lines raise an exception memory will not be leaked.
+             schema.release = NULL
+             capsule = cpython.PyCapsule_New(
+                 <void*>schema, 'arrow_schema', release_arrow_schema_py_capsule
+             )
+             # Fill in ArrowSchema fields:
+             # schema.format = ...
+             # ...
+             return capsule
+
+
+Consume a PyCapsule
+-------------------
+
+To consume a PyCapsule, use the `PyCapsule_GetPointer <https://docs.python.org/3/c-api/capsule.html#c.PyCapsule_GetPointer>`_ function
+to get the pointer to the underlying struct. Import the struct using your
+system's Arrow C Data Interface import function. Only after that should the
+capsule be freed.
+
+The below example shows how to consume a PyCapsule for an ``ArrowSchema``. The
+code for ``ArrowArray`` and ``ArrowArrayStream`` is similar.
+
+.. tab-set::
+
+   .. tab-item:: C
+
+      .. code-block:: c
+
+         #include <Python.h>
+         
+         // If the capsule is not an ArrowSchema, will return NULL and set an exception.
+         struct ArrowSchema* GetArrowSchemaPyCapsule(PyObject* capsule) {
+           return PyCapsule_GetPointer(capsule, "arrow_schema");
+         }
+
+   .. tab-item:: Cython
+
+      .. code-block:: cython
+
+         cimport cpython
+        
+         cdef ArrowSchema* get_arrow_schema_py_capsule(object capsule) except NULL:
+             return <ArrowSchema*>cpython.PyCapsule_GetPointer(capsule, 'arrow_schema')
+
+Backwards Compatibility with PyArrow
+------------------------------------
+
+When interacting with PyArrow, the PyCapsule interface should be preferred over
+the ``_export_to_c`` and ``_import_from_c`` methods. However, many libraries will
+want to support a range of PyArrow versions. This can be done via Duck typing.
+
+For example, if your library had an import method such as:
+
+.. code-block:: python
+
+   # OLD METHOD
+   def from_arrow(arr: pa.Array)
+       array_import_ptr = make_array_import_ptr()
+       schema_import_ptr = make_schema_import_ptr()
+       arr._export_to_c(array_import_ptr, schema_import_ptr)
+       return import_c_data(array_import_ptr, schema_import_ptr)
+
+You can rewrite this method to support both PyArrow and other libraries that
+implement the PyCapsule interface:
+
+.. code-block:: python
+
+   # NEW METHOD
+   def from_arrow(arr)
+       # Newer versions of PyArrow as well as other libraries with Arrow data
+       # implement this method, so prefer it over _export_to_c.
+       if hasattr(arr, "__arrow_c_array__"):
+            schema_ptr, array_ptr = arr.__arrow_c_array__()
+            return import_c_capsule_data(schema_ptr, array_ptr)
+       elif isinstance(arr, pa.Array):
+            # Deprecated method, used for older versions of PyArrow
+            array_import_ptr = make_array_import_ptr()
+            schema_import_ptr = make_schema_import_ptr()
+            arr._export_to_c(array_import_ptr, schema_import_ptr)
+            return import_c_data(array_import_ptr, schema_import_ptr)
+       else:
+           raise TypeError(f"Cannot import {type(arr)} as Arrow array data.")
+
+You may also wish to accept objects implementing the protocol in your
+constructors. For example, in PyArrow, the :func:`array` and :func:`record_batch`
+constructors accept any object that implements the :meth:`__arrow_c_array__` method
+protocol. Similarly, the PyArrow's :func:`schema` constructor accepts any object
+that implements the :meth:`__arrow_c_schema__` method.
+
+Now if your library has an export to PyArrow function, such as:
+
+.. code-block:: python
+
+   # OLD METHOD
+   def to_arrow(self) -> pa.Array:
+       array_export_ptr = make_array_export_ptr()
+       schema_export_ptr = make_schema_export_ptr()
+       self.export_c_data(array_export_ptr, schema_export_ptr)
+       return pa.Array._import_from_c(array_export_ptr, schema_export_ptr)
+
+You can rewrite this function to use the PyCapsule interface by passing your
+object to the :py:func:`array` constructor, which accepts any object that
+implements the protocol. An easy way to check if the PyArrow version is new
+enough to support this is to check whether ``pa.Array`` has the
+``__arrow_c_array__`` method.
+
+.. code-block:: python
+
+  import warnings
+
+  # NEW METHOD
+  def to_arrow(self) -> pa.Array:
+      # PyArrow added support for constructing arrays from objects implementing
+      # __arrow_c_array__ in the same version it added the method for it's own
+      # arrays. So we can use hasattr to check if the method is available as
+      # a proxy for checking the PyArrow version.
+      if hasattr(pa.Array, "__arrow_c_array__"):
+          return pa.array(self)
+      else:
+          array_export_ptr = make_array_export_ptr()
+          schema_export_ptr = make_schema_export_ptr()
+          self.export_c_data(array_export_ptr, schema_export_ptr)
+          return pa.Array._import_from_c(array_export_ptr, schema_export_ptr)
+
+
+Comparison with Other Protocols
+===============================
+
+Comparison to DataFrame Interchange Protocol
+--------------------------------------------
+
+`The DataFrame Interchange Protocol <https://data-apis.org/dataframe-protocol/latest/>`_
+is another protocol in Python that allows for the sharing of data between libraries.
+This protocol is complementary to the DataFrame Interchange Protocol. Many of
+the objects that implement this protocol will also implement the DataFrame
+Interchange Protocol.
+
+This protocol is specific to Arrow-based data structures, while the DataFrame
+Interchange Protocol allows non-Arrow data frames and arrays to be shared as well.
+Because of this, these PyCapsules can support Arrow-specific features such as
+nested columns.
+
+This protocol is also much more minimal than the DataFrame Interchange Protocol.
+It just handles data export, rather than defining accessors for details like
+number of rows or columns.
+
+In summary, if you are implementing this protocol, you should also consider
+implementing the DataFrame Interchange Protocol.
+
+
+Comparison to ``__arrow_array__`` protocol
+------------------------------------------
+
+The :ref:`arrow_array_protocol` protocol is a dunder method that 
+defines how PyArrow should import an object as an Arrow array. Unlike this
+protocol, it is specific to PyArrow and isn't used by other libraries. It is
+also limited to arrays and does not support schemas, tabular structures, or streams.
\ No newline at end of file
diff --git a/docs/source/python/extending_types.rst b/docs/source/python/extending_types.rst
index 87f04f37dc69c..b9e875ceebc74 100644
--- a/docs/source/python/extending_types.rst
+++ b/docs/source/python/extending_types.rst
@@ -21,6 +21,8 @@
 Extending pyarrow
 =================
 
+.. _arrow_array_protocol:
+
 Controlling conversion to pyarrow.Array with the ``__arrow_array__`` protocol
 -----------------------------------------------------------------------------
 
@@ -46,6 +48,13 @@ The ``__arrow_array__`` method takes an optional `type` keyword which is passed
 through from :func:`pyarrow.array`. The method is allowed to return either
 a :class:`~pyarrow.Array` or a :class:`~pyarrow.ChunkedArray`.
 
+.. note::
+
+    For a more general way to control the conversion of Python objects to Arrow
+    data consider the :doc:`/format/CDataInterface/PyCapsuleInterface`. It is
+    not specific to PyArrow and supports converting other objects such as tables
+    and schemas.
+
 
 Defining extension types ("user-defined types")
 -----------------------------------------------
diff --git a/docs/source/python/interchange_protocol.rst b/docs/source/python/interchange_protocol.rst
index 7784d78619e6e..e293699220c27 100644
--- a/docs/source/python/interchange_protocol.rst
+++ b/docs/source/python/interchange_protocol.rst
@@ -15,6 +15,8 @@
 .. specific language governing permissions and limitations
 .. under the License.
 
+.. _pyarrow-dataframe-interchange-protocol:
+
 Dataframe Interchange Protocol
 ==============================
 
diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index e36d8b2f04315..2e9750382277a 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -15,8 +15,11 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer, PyCapsule_New
+
 import os
 import warnings
+from cython import sizeof
 
 
 cdef _sequence_to_array(object sequence, object mask, object size,
@@ -123,9 +126,11 @@ def array(object obj, type=None, mask=None, size=None, from_pandas=None,
 
     Parameters
     ----------
-    obj : sequence, iterable, ndarray or pandas.Series
+    obj : sequence, iterable, ndarray, pandas.Series, Arrow-compatible array
         If both type and size are specified may be a single use iterable. If
         not strongly-typed, Arrow type will be inferred for resulting array.
+        Any Arrow-compatible array that implements the Arrow PyCapsule Protocol
+        (has an ``__arrow_c_array__`` method) can be passed as well.
     type : pyarrow.DataType
         Explicit type to attempt to coerce to, otherwise will be inferred from
         the data.
@@ -241,6 +246,18 @@ def array(object obj, type=None, mask=None, size=None, from_pandas=None,
 
     if hasattr(obj, '__arrow_array__'):
         return _handle_arrow_array_protocol(obj, type, mask, size)
+    elif hasattr(obj, '__arrow_c_array__'):
+        if type is not None:
+            requested_type = type.__arrow_c_schema__()
+        else:
+            requested_type = None
+        schema_capsule, array_capsule = obj.__arrow_c_array__(requested_type)
+        out_array = Array._import_from_c_capsule(schema_capsule, array_capsule)
+        if type is not None and out_array.type != type:
+            # PyCapsule interface type coersion is best effort, so we need to
+            # check the type of the returned array and cast if necessary
+            out_array = array.cast(type, safe=safe, memory_pool=memory_pool)
+        return out_array
     elif _is_array_like(obj):
         if mask is not None:
             if _is_array_like(mask):
@@ -1699,6 +1716,68 @@ cdef class Array(_PandasConvertible):
                                                      c_type))
         return pyarrow_wrap_array(c_array)
 
+    def __arrow_c_array__(self, requested_schema=None):
+        """
+        Get a pair of PyCapsules containing a C ArrowArray representation of the object.
+
+        Parameters
+        ----------
+        requested_schema : PyCapsule | None
+            A PyCapsule containing a C ArrowSchema representation of a requested
+            schema. PyArrow will attempt to cast the array to this data type.
+            If None, the array will be returned as-is, with a type matching the
+            one returned by :meth:`__arrow_c_schema__()`.
+
+        Returns
+        -------
+        Tuple[PyCapsule, PyCapsule]
+            A pair of PyCapsules containing a C ArrowSchema and ArrowArray,
+            respectively.
+        """
+        cdef:
+            ArrowArray* c_array
+            ArrowSchema* c_schema
+            shared_ptr[CArray] inner_array
+
+        if requested_schema is not None:
+            target_type = DataType._import_from_c_capsule(requested_schema)
+
+            if target_type != self.type:
+                try:
+                    casted_array = _pc().cast(self, target_type, safe=True)
+                    inner_array = pyarrow_unwrap_array(casted_array)
+                except ArrowInvalid as e:
+                    raise ValueError(
+                        f"Could not cast {self.type} to requested type {target_type}: {e}"
+                    )
+            else:
+                inner_array = self.sp_array
+        else:
+            inner_array = self.sp_array
+
+        schema_capsule = alloc_c_schema(&c_schema)
+        array_capsule = alloc_c_array(&c_array)
+
+        with nogil:
+            check_status(ExportArray(deref(inner_array), c_array, c_schema))
+
+        return schema_capsule, array_capsule
+
+    @staticmethod
+    def _import_from_c_capsule(schema_capsule, array_capsule):
+        cdef:
+            ArrowSchema* c_schema
+            ArrowArray* c_array
+            shared_ptr[CArray] array
+
+        c_schema = <ArrowSchema*> PyCapsule_GetPointer(schema_capsule, 'arrow_schema')
+        c_array = <ArrowArray*> PyCapsule_GetPointer(array_capsule, 'arrow_array')
+
+        with nogil:
+            array = GetResultValue(ImportArray(c_array, c_schema))
+
+        return pyarrow_wrap_array(array)
+
 
 cdef _array_like_to_pandas(obj, options, types_mapper):
     cdef:
diff --git a/python/pyarrow/includes/libarrow.pxd b/python/pyarrow/includes/libarrow.pxd
index ad79c0edcd8a1..fda9d4449763e 100644
--- a/python/pyarrow/includes/libarrow.pxd
+++ b/python/pyarrow/includes/libarrow.pxd
@@ -2743,13 +2743,13 @@ cdef extern from "arrow/array/concatenate.h" namespace "arrow" nogil:
 
 cdef extern from "arrow/c/abi.h":
     cdef struct ArrowSchema:
-        pass
+        void (*release)(ArrowSchema*) noexcept nogil
 
     cdef struct ArrowArray:
-        pass
+        void (*release)(ArrowArray*) noexcept nogil
 
     cdef struct ArrowArrayStream:
-        pass
+        void (*release)(ArrowArrayStream*) noexcept nogil
 
 cdef extern from "arrow/c/bridge.h" namespace "arrow" nogil:
     CStatus ExportType(CDataType&, ArrowSchema* out)
diff --git a/python/pyarrow/ipc.pxi b/python/pyarrow/ipc.pxi
index 53e521fc11468..deb3bb728aea9 100644
--- a/python/pyarrow/ipc.pxi
+++ b/python/pyarrow/ipc.pxi
@@ -15,9 +15,11 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer, PyCapsule_New
+
 from collections import namedtuple
 import warnings
-
+from cython import sizeof
 
 cpdef enum MetadataVersion:
     V1 = <char> CMetadataVersion_V1
@@ -815,6 +817,70 @@ cdef class RecordBatchReader(_Weakrefable):
         self.reader = c_reader
         return self
 
+    def __arrow_c_stream__(self, requested_schema=None):
+        """
+        Export to a C ArrowArrayStream PyCapsule.
+
+        Parameters
+        ----------
+        requested_schema: Schema, default None
+            The schema to which the stream should be casted. Currently, this is
+            not supported and will raise a NotImplementedError if the schema 
+            doesn't match the current schema.
+
+        Returns
+        -------
+        PyCapsule
+            A capsule containing a C ArrowArrayStream struct.
+        """
+        cdef:
+            ArrowArrayStream* c_stream
+
+        if requested_schema is not None:
+            out_schema = Schema._import_from_c_capsule(requested_schema)
+            # TODO: figure out a way to check if one schema is castable to
+            # another. Once we have that, we can perform validation here and
+            # if successful creating a wrapping reader that casts each batch.
+            if self.schema != out_schema:
+                raise NotImplementedError("Casting to requested_schema")
+
+        stream_capsule = alloc_c_stream(&c_stream)
+
+        with nogil:
+            check_status(ExportRecordBatchReader(self.reader, c_stream))
+
+        return stream_capsule
+
+    @staticmethod
+    def _import_from_c_capsule(stream):
+        """
+        Import RecordBatchReader from a C ArrowArrayStream PyCapsule.
+
+        Parameters
+        ----------
+        stream: PyCapsule
+            A capsule containing a C ArrowArrayStream PyCapsule.
+
+        Returns
+        -------
+        RecordBatchReader
+        """
+        cdef:
+            ArrowArrayStream* c_stream
+            shared_ptr[CRecordBatchReader] c_reader
+            RecordBatchReader self
+
+        c_stream = <ArrowArrayStream*>PyCapsule_GetPointer(
+            stream, 'arrow_array_stream'
+        )
+
+        with nogil:
+            c_reader = GetResultValue(ImportRecordBatchReader(c_stream))
+
+        self = RecordBatchReader.__new__(RecordBatchReader)
+        self.reader = c_reader
+        return self
+
     @staticmethod
     def from_batches(Schema schema not None, batches):
         """
diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index 72af5a2deea9c..bbf60416de995 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -15,8 +15,10 @@
 # specific language governing permissions and limitations
 # under the License.
 
-import warnings
+from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer, PyCapsule_New
 
+import warnings
+from cython import sizeof
 
 cdef class ChunkedArray(_PandasConvertible):
     """
@@ -2983,6 +2985,100 @@ cdef class RecordBatch(_Tabular):
                     <ArrowArray*> c_ptr, c_schema))
         return pyarrow_wrap_batch(c_batch)
 
+    def __arrow_c_array__(self, requested_schema=None):
+        """
+        Get a pair of PyCapsules containing a C ArrowArray representation of the object.
+
+        Parameters
+        ----------
+        requested_schema : PyCapsule | None
+            A PyCapsule containing a C ArrowSchema representation of a requested
+            schema. PyArrow will attempt to cast the batch to this schema.
+            If None, the schema will be returned as-is, with a schema matching the
+            one returned by :meth:`__arrow_c_schema__()`.
+
+        Returns
+        -------
+        Tuple[PyCapsule, PyCapsule]
+            A pair of PyCapsules containing a C ArrowSchema and ArrowArray,
+            respectively.
+        """
+        cdef:
+            ArrowArray* c_array
+            ArrowSchema* c_schema
+
+        if requested_schema is not None:
+            target_schema = Schema._import_from_c_capsule(requested_schema)
+
+            if target_schema != self.schema:
+                try:
+                    # We don't expose .cast() on RecordBatch, only on Table.
+                    casted_batch = Table.from_batches([self]).cast(
+                        target_schema, safe=True).to_batches()[0]
+                    inner_batch = pyarrow_unwrap_batch(casted_batch)
+                except ArrowInvalid as e:
+                    raise ValueError(
+                        f"Could not cast {self.schema} to requested schema {target_schema}: {e}"
+                    )
+            else:
+                inner_batch = self.sp_batch
+        else:
+            inner_batch = self.sp_batch
+
+        schema_capsule = alloc_c_schema(&c_schema)
+        array_capsule = alloc_c_array(&c_array)
+
+        with nogil:
+            check_status(ExportRecordBatch(deref(inner_batch), c_array, c_schema))
+
+        return schema_capsule, array_capsule
+
+    def __arrow_c_stream__(self, requested_schema=None):
+        """
+        Export the batch as an Arrow C stream PyCapsule.
+
+        Parameters
+        ----------
+        requested_schema : pyarrow.lib.Schema, default None
+            A schema to attempt to cast the streamed data to. This is currently
+            unsupported and will raise an error.
+
+        Returns
+        -------
+        PyCapsule
+        """
+        return Table.from_batches([self]).__arrow_c_stream__(requested_schema)
+
+    @staticmethod
+    def _import_from_c_capsule(schema_capsule, array_capsule):
+        """
+        Import RecordBatch from a pair of PyCapsules containing a C ArrowArray
+        and ArrowSchema, respectively.
+
+        Parameters
+        ----------
+        schema_capsule : PyCapsule
+            A PyCapsule containing a C ArrowSchema representation of the schema.
+        array_capsule : PyCapsule
+            A PyCapsule containing a C ArrowArray representation of the array.
+
+        Returns
+        -------
+        pyarrow.RecordBatch
+        """
+        cdef:
+            ArrowSchema* c_schema
+            ArrowArray* c_array
+            shared_ptr[CRecordBatch] c_batch
+
+        c_schema = <ArrowSchema*> PyCapsule_GetPointer(schema_capsule, 'arrow_schema')
+        c_array = <ArrowArray*> PyCapsule_GetPointer(array_capsule, 'arrow_array')
+
+        with nogil:
+            c_batch = GetResultValue(ImportRecordBatch(c_array, c_schema))
+
+        return pyarrow_wrap_batch(c_batch)
+
 
 def _reconstruct_record_batch(columns, schema):
     """
@@ -4757,6 +4853,22 @@ cdef class Table(_Tabular):
             output_type=Table
         )
 
+    def __arrow_c_stream__(self, requested_schema=None):
+        """
+        Export the table as an Arrow C stream PyCapsule.
+
+        Parameters
+        ----------
+        requested_schema : pyarrow.lib.Schema, default None
+            A schema to attempt to cast the streamed data to. This is currently
+            unsupported and will raise an error.
+
+        Returns
+        -------
+        PyCapsule
+        """
+        return self.to_reader().__arrow_c_stream__(requested_schema)
+
 
 def _reconstruct_table(arrays, schema):
     """
@@ -4772,8 +4884,10 @@ def record_batch(data, names=None, schema=None, metadata=None):
 
     Parameters
     ----------
-    data : pandas.DataFrame, list
-        A DataFrame or list of arrays or chunked arrays.
+    data : pandas.DataFrame, list, Arrow-compatible table
+        A DataFrame, list of arrays or chunked arrays, or a tabular object
+        implementing the Arrow PyCapsule Protocol (has an
+        ``__arrow_c_array__`` method).
     names : list, default None
         Column names if list of arrays passed as data. Mutually exclusive with
         'schema' argument.
@@ -4892,6 +5006,18 @@ def record_batch(data, names=None, schema=None, metadata=None):
     if isinstance(data, (list, tuple)):
         return RecordBatch.from_arrays(data, names=names, schema=schema,
                                        metadata=metadata)
+    elif hasattr(data, "__arrow_c_array__"):
+        if schema is not None:
+            requested_schema = schema.__arrow_c_schema__()
+        else:
+            requested_schema = None
+        schema_capsule, array_capsule = data.__arrow_c_array__(requested_schema)
+        batch = RecordBatch._import_from_c_capsule(schema_capsule, array_capsule)
+        if schema is not None and batch.schema != schema:
+            # __arrow_c_array__ coerces schema with best effort, so we might
+            # need to cast it if the producer wasn't able to cast to exact schema.
+            batch = Table.from_batches([batch]).cast(schema).to_batches()[0]
+        return batch
     elif _pandas_api.is_data_frame(data):
         return RecordBatch.from_pandas(data, schema=schema)
     else:
@@ -5013,6 +5139,22 @@ def table(data, names=None, schema=None, metadata=None, nthreads=None):
             raise ValueError(
                 "The 'names' argument is not valid when passing a dictionary")
         return Table.from_pydict(data, schema=schema, metadata=metadata)
+    elif hasattr(data, "__arrow_c_stream__"):
+        if schema is not None:
+            requested = schema.__arrow_c_schema__()
+        else:
+            requested = None
+        capsule = data.__arrow_c_stream__(requested)
+        reader = RecordBatchReader._import_from_c_capsule(capsule)
+        table = reader.read_all()
+        if schema is not None and table.schema != schema:
+            # __arrow_c_array__ coerces schema with best effort, so we might
+            # need to cast it if the producer wasn't able to cast to exact schema.
+            table = table.cast(schema)
+        return table
+    elif hasattr(data, "__arrow_c_array__"):
+        batch = record_batch(data, schema)
+        return Table.from_batches([batch])
     elif _pandas_api.is_data_frame(data):
         if names is not None or metadata is not None:
             raise ValueError(
diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py
index cd565a72bc19f..2f9727922b49a 100644
--- a/python/pyarrow/tests/test_array.py
+++ b/python/pyarrow/tests/test_array.py
@@ -3336,6 +3336,24 @@ def __arrow_array__(self, type=None):
     assert result.equals(expected)
 
 
+def test_c_array_protocol():
+    class ArrayWrapper:
+        def __init__(self, data):
+            self.data = data
+
+        def __arrow_c_array__(self, requested_type=None):
+            return self.data.__arrow_c_array__(requested_type)
+
+    # Can roundtrip through the C array protocol
+    arr = ArrayWrapper(pa.array([1, 2, 3], type=pa.int64()))
+    result = pa.array(arr)
+    assert result == arr.data
+
+    # Will case to requested type
+    result = pa.array(arr, type=pa.int32())
+    assert result == pa.array([1, 2, 3], type=pa.int32())
+
+
 def test_concat_array():
     concatenated = pa.concat_arrays(
         [pa.array([1, 2]), pa.array([3, 4])])
diff --git a/python/pyarrow/tests/test_cffi.py b/python/pyarrow/tests/test_cffi.py
index 9b0e24fa46251..55bab4359bffc 100644
--- a/python/pyarrow/tests/test_cffi.py
+++ b/python/pyarrow/tests/test_cffi.py
@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import ctypes
 import gc
 
 import pyarrow as pa
@@ -36,7 +37,6 @@
 needs_cffi = pytest.mark.skipif(ffi is None,
                                 reason="test needs cffi package installed")
 
-
 assert_schema_released = pytest.raises(
     ValueError, match="Cannot import released ArrowSchema")
 
@@ -47,6 +47,10 @@
     ValueError, match="Cannot import released ArrowArrayStream")
 
 
+def PyCapsule_IsValid(capsule, name):
+    return ctypes.pythonapi.PyCapsule_IsValid(ctypes.py_object(capsule), name) == 1
+
+
 class ParamExtType(pa.PyExtensionType):
 
     def __init__(self, width):
@@ -411,3 +415,123 @@ def test_imported_batch_reader_error():
                        match="Expected to be able to read 16 bytes "
                              "for message body, got 8"):
         reader_new.read_all()
+
+
+@pytest.mark.parametrize('obj', [pa.int32(), pa.field('foo', pa.int32()),
+                                 pa.schema({'foo': pa.int32()})],
+                         ids=['type', 'field', 'schema'])
+def test_roundtrip_schema_capsule(obj):
+    gc.collect()  # Make sure no Arrow data dangles in a ref cycle
+    old_allocated = pa.total_allocated_bytes()
+
+    capsule = obj.__arrow_c_schema__()
+    assert PyCapsule_IsValid(capsule, b"arrow_schema") == 1
+    assert pa.total_allocated_bytes() > old_allocated
+    obj_out = type(obj)._import_from_c_capsule(capsule)
+    assert obj_out == obj
+
+    assert pa.total_allocated_bytes() == old_allocated
+
+    capsule = obj.__arrow_c_schema__()
+
+    assert pa.total_allocated_bytes() > old_allocated
+    del capsule
+    assert pa.total_allocated_bytes() == old_allocated
+
+
+@pytest.mark.parametrize('arr,schema_accessor,bad_type,good_type', [
+    (pa.array(['a', 'b', 'c']), lambda x: x.type, pa.int32(), pa.string()),
+    (
+        pa.record_batch([pa.array(['a', 'b', 'c'])], names=['x']),
+        lambda x: x.schema,
+        pa.schema({'x': pa.int32()}),
+        pa.schema({'x': pa.string()})
+    ),
+], ids=['array', 'record_batch'])
+def test_roundtrip_array_capsule(arr, schema_accessor, bad_type, good_type):
+    gc.collect()  # Make sure no Arrow data dangles in a ref cycle
+    old_allocated = pa.total_allocated_bytes()
+
+    import_array = type(arr)._import_from_c_capsule
+
+    schema_capsule, capsule = arr.__arrow_c_array__()
+    assert PyCapsule_IsValid(schema_capsule, b"arrow_schema") == 1
+    assert PyCapsule_IsValid(capsule, b"arrow_array") == 1
+    arr_out = import_array(schema_capsule, capsule)
+    assert arr_out.equals(arr)
+
+    assert pa.total_allocated_bytes() > old_allocated
+    del arr_out
+
+    assert pa.total_allocated_bytes() == old_allocated
+
+    capsule = arr.__arrow_c_array__()
+
+    assert pa.total_allocated_bytes() > old_allocated
+    del capsule
+    assert pa.total_allocated_bytes() == old_allocated
+
+    with pytest.raises(ValueError,
+                       match=r"Could not cast.* string to requested .* int32"):
+        arr.__arrow_c_array__(bad_type.__arrow_c_schema__())
+
+    schema_capsule, array_capsule = arr.__arrow_c_array__(
+        good_type.__arrow_c_schema__())
+    arr_out = import_array(schema_capsule, array_capsule)
+    assert schema_accessor(arr_out) == good_type
+
+
+# TODO: implement requested_schema for stream
+@pytest.mark.parametrize('constructor', [
+    pa.RecordBatchReader.from_batches,
+    # Use a lambda because we need to re-order the parameters
+    lambda schema, batches: pa.Table.from_batches(batches, schema),
+], ids=['recordbatchreader', 'table'])
+def test_roundtrip_reader_capsule(constructor):
+    batches = make_batches()
+    schema = batches[0].schema
+
+    gc.collect()  # Make sure no Arrow data dangles in a ref cycle
+    old_allocated = pa.total_allocated_bytes()
+
+    obj = constructor(schema, batches)
+
+    capsule = obj.__arrow_c_stream__()
+    assert PyCapsule_IsValid(capsule, b"arrow_array_stream") == 1
+    imported_reader = pa.RecordBatchReader._import_from_c_capsule(capsule)
+    assert imported_reader.schema == schema
+    imported_batches = list(imported_reader)
+    assert len(imported_batches) == len(batches)
+    for batch, expected in zip(imported_batches, batches):
+        assert batch.equals(expected)
+
+    del obj, imported_reader, batch, expected, imported_batches
+
+    assert pa.total_allocated_bytes() == old_allocated
+
+    obj = constructor(schema, batches)
+
+    # TODO: turn this to ValueError once we implement validation.
+    bad_schema = pa.schema({'ints': pa.int32()})
+    with pytest.raises(NotImplementedError):
+        obj.__arrow_c_stream__(bad_schema.__arrow_c_schema__())
+
+    # Can work with matching schema
+    matching_schema = pa.schema({'ints': pa.list_(pa.int32())})
+    capsule = obj.__arrow_c_stream__(matching_schema.__arrow_c_schema__())
+    imported_reader = pa.RecordBatchReader._import_from_c_capsule(capsule)
+    assert imported_reader.schema == matching_schema
+    for batch, expected in zip(imported_reader, batches):
+        assert batch.equals(expected)
+
+
+def test_roundtrip_batch_reader_capsule():
+    batch = make_batch()
+
+    capsule = batch.__arrow_c_stream__()
+    assert PyCapsule_IsValid(capsule, b"arrow_array_stream") == 1
+    imported_reader = pa.RecordBatchReader._import_from_c_capsule(capsule)
+    assert imported_reader.schema == batch.schema
+    assert imported_reader.read_next_batch().equals(batch)
+    with pytest.raises(StopIteration):
+        imported_reader.read_next_batch()
diff --git a/python/pyarrow/tests/test_table.py b/python/pyarrow/tests/test_table.py
index 6b48633b91f8e..a678f521e38d5 100644
--- a/python/pyarrow/tests/test_table.py
+++ b/python/pyarrow/tests/test_table.py
@@ -553,6 +553,93 @@ def test_recordbatch_dunder_init():
         pa.RecordBatch()
 
 
+def test_recordbatch_c_array_interface():
+    class BatchWrapper:
+        def __init__(self, batch):
+            self.batch = batch
+
+        def __arrow_c_array__(self, requested_type=None):
+            return self.batch.__arrow_c_array__(requested_type)
+
+    data = pa.record_batch([
+        pa.array([1, 2, 3], type=pa.int64())
+    ], names=['a'])
+    wrapper = BatchWrapper(data)
+
+    # Can roundtrip through the wrapper.
+    result = pa.record_batch(wrapper)
+    assert result == data
+
+    # Can also import with a schema that implementer can cast to.
+    castable_schema = pa.schema([
+        pa.field('a', pa.int32())
+    ])
+    result = pa.record_batch(wrapper, schema=castable_schema)
+    expected = pa.record_batch([
+        pa.array([1, 2, 3], type=pa.int32())
+    ], names=['a'])
+    assert result == expected
+
+
+def test_table_c_array_interface():
+    class BatchWrapper:
+        def __init__(self, batch):
+            self.batch = batch
+
+        def __arrow_c_array__(self, requested_type=None):
+            return self.batch.__arrow_c_array__(requested_type)
+
+    data = pa.record_batch([
+        pa.array([1, 2, 3], type=pa.int64())
+    ], names=['a'])
+    wrapper = BatchWrapper(data)
+
+    # Can roundtrip through the wrapper.
+    result = pa.table(wrapper)
+    expected = pa.Table.from_batches([data])
+    assert result == expected
+
+    # Can also import with a schema that implementer can cast to.
+    castable_schema = pa.schema([
+        pa.field('a', pa.int32())
+    ])
+    result = pa.table(wrapper, schema=castable_schema)
+    expected = pa.table({
+        'a': pa.array([1, 2, 3], type=pa.int32())
+    })
+    assert result == expected
+
+
+def test_table_c_stream_interface():
+    class StreamWrapper:
+        def __init__(self, batches):
+            self.batches = batches
+
+        def __arrow_c_stream__(self, requested_type=None):
+            reader = pa.RecordBatchReader.from_batches(
+                self.batches[0].schema, self.batches)
+            return reader.__arrow_c_stream__(requested_type)
+
+    data = [
+        pa.record_batch([pa.array([1, 2, 3], type=pa.int64())], names=['a']),
+        pa.record_batch([pa.array([4, 5, 6], type=pa.int64())], names=['a'])
+    ]
+    wrapper = StreamWrapper(data)
+
+    # Can roundtrip through the wrapper.
+    result = pa.table(wrapper)
+    expected = pa.Table.from_batches(data)
+    assert result == expected
+
+    # Passing schema works if already that schema
+    result = pa.table(wrapper, schema=data[0].schema)
+    assert result == expected
+
+    # If schema doesn't match, raises NotImplementedError
+    with pytest.raises(NotImplementedError):
+        pa.table(wrapper, schema=pa.schema([pa.field('a', pa.int32())]))
+
+
 def test_recordbatch_itercolumns():
     data = [
         pa.array(range(5), type='int16'),
diff --git a/python/pyarrow/tests/test_types.py b/python/pyarrow/tests/test_types.py
index 660765f3361ae..16343eae61245 100644
--- a/python/pyarrow/tests/test_types.py
+++ b/python/pyarrow/tests/test_types.py
@@ -1225,3 +1225,17 @@ def test_types_come_back_with_specific_type():
         schema = pa.schema([pa.field("field_name", arrow_type)])
         type_back = schema.field("field_name").type
         assert type(type_back) is type(arrow_type)
+
+
+def test_schema_import_c_schema_interface():
+    class Wrapper:
+        def __init__(self, schema):
+            self.schema = schema
+
+        def __arrow_c_schema__(self):
+            return self.schema.__arrow_c_schema__()
+
+    schema = pa.schema([pa.field("field_name", pa.int32())])
+    wrapped_schema = Wrapper(schema)
+
+    assert pa.schema(wrapped_schema) == schema
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index 764cb8e7b5d8b..d394b803e7fc2 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer
+from cpython.pycapsule cimport PyCapsule_CheckExact, PyCapsule_GetPointer, PyCapsule_New, PyCapsule_IsValid
 
 import atexit
 from collections.abc import Mapping
@@ -23,7 +23,7 @@ import pickle
 import re
 import sys
 import warnings
-
+from cython import sizeof
 
 # These are imprecise because the type (in pandas 0.x) depends on the presence
 # of nulls
@@ -357,6 +357,46 @@ cdef class DataType(_Weakrefable):
                                            _as_c_pointer(in_ptr)))
         return pyarrow_wrap_data_type(result)
 
+    def __arrow_c_schema__(self):
+        """
+        Export to a ArrowSchema PyCapsule
+
+        Unlike _export_to_c, this will not leak memory if the capsule is not used.
+        """
+        cdef ArrowSchema* c_schema
+        capsule = alloc_c_schema(&c_schema)
+
+        with nogil:
+            check_status(ExportType(deref(self.type), c_schema))
+
+        return capsule
+
+    @staticmethod
+    def _import_from_c_capsule(schema):
+        """
+        Import a DataType from a ArrowSchema PyCapsule
+
+        Parameters
+        ----------
+        schema : PyCapsule
+            A valid PyCapsule with name 'arrow_schema' containing an
+            ArrowSchema pointer.
+        """
+        cdef:
+            ArrowSchema* c_schema
+            shared_ptr[CDataType] c_type
+
+        if not PyCapsule_IsValid(schema, 'arrow_schema'):
+            raise TypeError(
+                "Not an ArrowSchema object"
+            )
+        c_schema = <ArrowSchema*> PyCapsule_GetPointer(schema, 'arrow_schema')
+
+        with nogil:
+            c_type = GetResultValue(ImportType(c_schema))
+
+        return pyarrow_wrap_data_type(c_type)
+
 
 cdef class DictionaryMemo(_Weakrefable):
     """
@@ -2369,6 +2409,46 @@ cdef class Field(_Weakrefable):
             result = GetResultValue(ImportField(<ArrowSchema*> c_ptr))
         return pyarrow_wrap_field(result)
 
+    def __arrow_c_schema__(self):
+        """
+        Export to a ArrowSchema PyCapsule
+
+        Unlike _export_to_c, this will not leak memory if the capsule is not used.
+        """
+        cdef ArrowSchema* c_schema
+        capsule = alloc_c_schema(&c_schema)
+
+        with nogil:
+            check_status(ExportField(deref(self.field), c_schema))
+
+        return capsule
+
+    @staticmethod
+    def _import_from_c_capsule(schema):
+        """
+        Import a Field from a ArrowSchema PyCapsule
+
+        Parameters
+        ----------
+        schema : PyCapsule
+            A valid PyCapsule with name 'arrow_schema' containing an
+            ArrowSchema pointer.
+        """
+        cdef:
+            ArrowSchema* c_schema
+            shared_ptr[CField] c_field
+
+        if not PyCapsule_IsValid(schema, 'arrow_schema'):
+            raise ValueError(
+                "Not an ArrowSchema object"
+            )
+        c_schema = <ArrowSchema*> PyCapsule_GetPointer(schema, 'arrow_schema')
+
+        with nogil:
+            c_field = GetResultValue(ImportField(c_schema))
+
+        return pyarrow_wrap_field(c_field)
+
 
 cdef class Schema(_Weakrefable):
     """
@@ -3153,6 +3233,45 @@ cdef class Schema(_Weakrefable):
     def __repr__(self):
         return self.__str__()
 
+    def __arrow_c_schema__(self):
+        """
+        Export to a ArrowSchema PyCapsule
+
+        Unlike _export_to_c, this will not leak memory if the capsule is not used.
+        """
+        cdef ArrowSchema* c_schema
+        capsule = alloc_c_schema(&c_schema)
+
+        with nogil:
+            check_status(ExportSchema(deref(self.schema), c_schema))
+
+        return capsule
+
+    @staticmethod
+    def _import_from_c_capsule(schema):
+        """
+        Import a Schema from a ArrowSchema PyCapsule
+
+        Parameters
+        ----------
+        schema : PyCapsule
+            A valid PyCapsule with name 'arrow_schema' containing an
+            ArrowSchema pointer.
+        """
+        cdef:
+            ArrowSchema* c_schema
+
+        if not PyCapsule_IsValid(schema, 'arrow_schema'):
+            raise ValueError(
+                "Not an ArrowSchema object"
+            )
+        c_schema = <ArrowSchema*> PyCapsule_GetPointer(schema, 'arrow_schema')
+
+        with nogil:
+            result = GetResultValue(ImportSchema(c_schema))
+
+        return pyarrow_wrap_schema(result)
+
 
 def unify_schemas(schemas, *, promote_options="default"):
     """
@@ -4930,6 +5049,8 @@ def schema(fields, metadata=None):
     Parameters
     ----------
     fields : iterable of Fields or tuples, or mapping of strings to DataTypes
+        Can also pass an object that implements the Arrow PyCapsule Protocol
+        for schemas (has an ``__arrow_c_schema__`` method).
     metadata : dict, default None
         Keys and values must be coercible to bytes.
 
@@ -4969,6 +5090,8 @@ def schema(fields, metadata=None):
 
     if isinstance(fields, Mapping):
         fields = fields.items()
+    elif hasattr(fields, "__arrow_c_schema__"):
+        return Schema._import_from_c_capsule(fields.__arrow_c_schema__())
 
     for item in fields:
         if isinstance(item, tuple):
@@ -5103,3 +5226,61 @@ def _unregister_py_extension_types():
 
 _register_py_extension_type()
 atexit.register(_unregister_py_extension_types)
+
+
+#
+# PyCapsule export utilities
+#
+
+cdef void pycapsule_schema_deleter(object schema_capsule) noexcept:
+    cdef ArrowSchema* schema = <ArrowSchema*>PyCapsule_GetPointer(
+        schema_capsule, 'arrow_schema'
+    )
+    if schema.release != NULL:
+        schema.release(schema)
+
+    free(schema)
+
+cdef object alloc_c_schema(ArrowSchema** c_schema) noexcept:
+    c_schema[0] = <ArrowSchema*> malloc(sizeof(ArrowSchema))
+    # Ensure the capsule destructor doesn't call a random release pointer
+    c_schema[0].release = NULL
+    return PyCapsule_New(c_schema[0], 'arrow_schema', &pycapsule_schema_deleter)
+
+
+cdef void pycapsule_array_deleter(object array_capsule) noexcept:
+    cdef:
+        ArrowArray* array
+    # Do not invoke the deleter on a used/moved capsule
+    array = <ArrowArray*>cpython.PyCapsule_GetPointer(
+        array_capsule, 'arrow_array'
+    )
+    if array.release != NULL:
+        array.release(array)
+
+    free(array)
+
+cdef object alloc_c_array(ArrowArray** c_array) noexcept:
+    c_array[0] = <ArrowArray*> malloc(sizeof(ArrowArray))
+    # Ensure the capsule destructor doesn't call a random release pointer
+    c_array[0].release = NULL
+    return PyCapsule_New(c_array[0], 'arrow_array', &pycapsule_array_deleter)
+
+
+cdef void pycapsule_stream_deleter(object stream_capsule) noexcept:
+    cdef:
+        ArrowArrayStream* stream
+    # Do not invoke the deleter on a used/moved capsule
+    stream = <ArrowArrayStream*>PyCapsule_GetPointer(
+        stream_capsule, 'arrow_array_stream'
+    )
+    if stream.release != NULL:
+        stream.release(stream)
+
+    free(stream)
+
+cdef object alloc_c_stream(ArrowArrayStream** c_stream) noexcept:
+    c_stream[0] = <ArrowArrayStream*> malloc(sizeof(ArrowArrayStream))
+    # Ensure the capsule destructor doesn't call a random release pointer
+    c_stream[0].release = NULL
+    return PyCapsule_New(c_stream[0], 'arrow_array_stream', &pycapsule_stream_deleter)

From 0428c5ea35c78aff658fd5783a67ba4a6e90703e Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Wed, 18 Oct 2023 13:23:03 -0400
Subject: [PATCH 584/749] GH-38281: [Go] Ensure CData imported arrays are freed
 on release (#38314)

### Rationale for this change
The usage of `SetFinalizer` means that it's not *guaranteed* that calling `Release()` on an imported Record or Array will actually free the memory during the lifetime of the process. Instead we can leverage a shared buffer count, atomic ref counting and a custom allocator to ensure proper and more timely memory releasing when importing from C Data interface.

### What changes are included in this PR?
* Some simplifications of code to use `unsafe.Slice` instead of the deprecated handling of `reflect.SliceHeader` to improve readability
* Updating tests using `mallocator.Mallocator` in order to easily allow testing to ensure that memory is being cleaned up and freed
* Fixing a series of memory leaks subsequently found by the previous change of using the `mallocator.Mallocator` to track the allocations used for testing arrays.

### Are these changes tested?
Yes, unit tests are updated and included.

* Closes: #38281

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/cdata/cdata.go                | 112 +++++++++++++------
 go/arrow/cdata/cdata_fulltest.c        |  12 ++
 go/arrow/cdata/cdata_test.go           |  29 +++--
 go/arrow/cdata/cdata_test_framework.go | 145 ++++++++++++++++++-------
 go/arrow/cdata/exports.go              |  14 +--
 go/arrow/cdata/import_allocator.go     |  58 ++++++++++
 go/arrow/cdata/interface.go            |   1 +
 go/arrow/cdata/utils.h                 |  11 --
 go/arrow/memory/buffer.go              |  12 ++
 9 files changed, 292 insertions(+), 102 deletions(-)
 create mode 100644 go/arrow/cdata/import_allocator.go

diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index dc8825a7edb67..1d454c57f722e 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -40,7 +40,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
@@ -152,13 +151,8 @@ func importSchema(schema *CArrowSchema) (ret arrow.Field, err error) {
 	var childFields []arrow.Field
 	if schema.n_children > 0 {
 		// call ourselves recursively if there are children.
-		var schemaChildren []*CArrowSchema
 		// set up a slice to reference safely
-		s := (*reflect.SliceHeader)(unsafe.Pointer(&schemaChildren))
-		s.Data = uintptr(unsafe.Pointer(schema.children))
-		s.Len = int(schema.n_children)
-		s.Cap = int(schema.n_children)
-
+		schemaChildren := unsafe.Slice(schema.children, schema.n_children)
 		childFields = make([]arrow.Field, schema.n_children)
 		for i, c := range schemaChildren {
 			childFields[i], err = importSchema((*CArrowSchema)(c))
@@ -341,21 +335,18 @@ type cimporter struct {
 	parent   *cimporter
 	children []cimporter
 	cbuffers []*C.void
+
+	alloc *importAllocator
 }
 
 func (imp *cimporter) importChild(parent *cimporter, src *CArrowArray) error {
-	imp.parent = parent
-	return imp.doImport(src)
+	imp.parent, imp.arr, imp.alloc = parent, src, parent.alloc
+	return imp.doImport()
 }
 
 // import any child arrays for lists, structs, and so on.
 func (imp *cimporter) doImportChildren() error {
-	var children []*CArrowArray
-	// create a proper slice for our children
-	s := (*reflect.SliceHeader)(unsafe.Pointer(&children))
-	s.Data = uintptr(unsafe.Pointer(imp.arr.children))
-	s.Len = int(imp.arr.n_children)
-	s.Cap = int(imp.arr.n_children)
+	children := unsafe.Slice(imp.arr.children, imp.arr.n_children)
 
 	if len(children) > 0 {
 		imp.children = make([]cimporter, len(children))
@@ -418,26 +409,44 @@ func (imp *cimporter) doImportChildren() error {
 
 func (imp *cimporter) initarr() {
 	imp.arr = C.get_arr()
+	if imp.alloc == nil {
+		imp.alloc = &importAllocator{arr: imp.arr}
+	}
+}
+
+func (imp *cimporter) doImportArr(src *CArrowArray) error {
+	imp.arr = C.get_arr()
+	C.ArrowArrayMove(src, imp.arr)
+	if imp.alloc == nil {
+		imp.alloc = &importAllocator{arr: imp.arr}
+	}
+
+	// we tie the releasing of the array to when the buffers are
+	// cleaned up, so if there are no buffers that we've imported
+	// such as for a null array or a nested array with no bitmap
+	// and only null columns, then we can release the CArrowArray
+	// struct immediately after import, since we have no imported
+	// memory that we have to track the lifetime of.
+	defer func() {
+		if imp.alloc.bufCount == 0 {
+			C.ArrowArrayRelease(imp.arr)
+		}
+	}()
+
+	return imp.doImport()
 }
 
 // import is called recursively as needed for importing an array and its children
 // in order to generate array.Data objects
-func (imp *cimporter) doImport(src *CArrowArray) error {
-	imp.initarr()
+func (imp *cimporter) doImport() error {
 	// move the array from the src object passed in to the one referenced by
 	// this importer. That way we can set up a finalizer on the created
 	// arrow.ArrayData object so we clean up our Array's memory when garbage collected.
-	C.ArrowArrayMove(src, imp.arr)
 	defer func(arr *CArrowArray) {
-		if imp.data != nil {
-			runtime.SetFinalizer(imp.data, func(arrow.ArrayData) {
-				defer C.free(unsafe.Pointer(arr))
-				C.ArrowArrayRelease(arr)
-				if C.ArrowArrayIsReleased(arr) != 1 {
-					panic("did not release C mem")
-				}
-			})
-		} else {
+		// this should only occur in the case of an error happening
+		// during import, at which point we need to clean up the
+		// ArrowArray struct we allocated.
+		if imp.data == nil {
 			C.free(unsafe.Pointer(arr))
 		}
 	}(imp.arr)
@@ -447,6 +456,12 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 		return err
 	}
 
+	for _, c := range imp.children {
+		if c.data != nil {
+			defer c.data.Release()
+		}
+	}
+
 	if imp.arr.n_buffers > 0 {
 		// get a view of the buffers, zero-copy. we're just looking at the pointers
 		imp.cbuffers = unsafe.Slice((**C.void)(unsafe.Pointer(imp.arr.buffers)), imp.arr.n_buffers)
@@ -458,6 +473,7 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 		if err := imp.checkNoChildren(); err != nil {
 			return err
 		}
+
 		imp.data = array.NewData(dt, int(imp.arr.length), nil, nil, int(imp.arr.null_count), int(imp.arr.offset))
 	case arrow.FixedWidthDataType:
 		return imp.importFixedSizePrimitive()
@@ -488,6 +504,9 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 		if err != nil {
 			return err
 		}
+		if nulls != nil {
+			defer nulls.Release()
+		}
 
 		imp.data = array.NewData(dt, int(imp.arr.length), []*memory.Buffer{nulls}, []arrow.ArrayData{imp.children[0].data}, int(imp.arr.null_count), int(imp.arr.offset))
 	case *arrow.StructType:
@@ -499,6 +518,9 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 		if err != nil {
 			return err
 		}
+		if nulls != nil {
+			defer nulls.Release()
+		}
 
 		children := make([]arrow.ArrayData, len(imp.children))
 		for i := range imp.children {
@@ -529,9 +551,11 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 			if bufs[1], err = imp.importFixedSizeBuffer(1, 1); err != nil {
 				return err
 			}
+			defer bufs[1].Release()
 			if bufs[2], err = imp.importFixedSizeBuffer(2, int64(arrow.Int32SizeBytes)); err != nil {
 				return err
 			}
+			defer bufs[2].Release()
 		} else {
 			if err := imp.checkNumBuffers(2); err != nil {
 				return err
@@ -540,9 +564,11 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 			if bufs[1], err = imp.importFixedSizeBuffer(0, 1); err != nil {
 				return err
 			}
+			defer bufs[1].Release()
 			if bufs[2], err = imp.importFixedSizeBuffer(1, int64(arrow.Int32SizeBytes)); err != nil {
 				return err
 			}
+			defer bufs[2].Release()
 		}
 
 		children := make([]arrow.ArrayData, len(imp.children))
@@ -562,6 +588,7 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 			if buf, err = imp.importFixedSizeBuffer(1, 1); err != nil {
 				return err
 			}
+			defer buf.Release()
 		} else {
 			if err := imp.checkNumBuffers(1); err != nil {
 				return err
@@ -570,6 +597,7 @@ func (imp *cimporter) doImport(src *CArrowArray) error {
 			if buf, err = imp.importFixedSizeBuffer(0, 1); err != nil {
 				return err
 			}
+			defer buf.Release()
 		}
 
 		children := make([]arrow.ArrayData, len(imp.children))
@@ -596,14 +624,17 @@ func (imp *cimporter) importStringLike(offsetByteWidth int64) (err error) {
 	var (
 		nulls, offsets, values *memory.Buffer
 	)
-
 	if nulls, err = imp.importNullBitmap(0); err != nil {
 		return
 	}
+	if nulls != nil {
+		defer nulls.Release()
+	}
 
 	if offsets, err = imp.importOffsetsBuffer(1, offsetByteWidth); err != nil {
 		return
 	}
+	defer offsets.Release()
 
 	var nvals int64
 	switch offsetByteWidth {
@@ -617,6 +648,8 @@ func (imp *cimporter) importStringLike(offsetByteWidth int64) (err error) {
 	if values, err = imp.importVariableValuesBuffer(2, 1, nvals); err != nil {
 		return
 	}
+	defer values.Release()
+
 	imp.data = array.NewData(imp.dt, int(imp.arr.length), []*memory.Buffer{nulls, offsets, values}, nil, int(imp.arr.null_count), int(imp.arr.offset))
 	return
 }
@@ -634,11 +667,17 @@ func (imp *cimporter) importListLike() (err error) {
 	if nulls, err = imp.importNullBitmap(0); err != nil {
 		return
 	}
+	if nulls != nil {
+		defer nulls.Release()
+	}
 
 	offsetSize := imp.dt.Layout().Buffers[1].ByteWidth
 	if offsets, err = imp.importOffsetsBuffer(1, int64(offsetSize)); err != nil {
 		return
 	}
+	if offsets != nil {
+		defer offsets.Release()
+	}
 
 	imp.data = array.NewData(imp.dt, int(imp.arr.length), []*memory.Buffer{nulls, offsets}, []arrow.ArrayData{imp.children[0].data}, int(imp.arr.null_count), int(imp.arr.offset))
 	return
@@ -677,7 +716,7 @@ func (imp *cimporter) importFixedSizePrimitive() error {
 	var dict *array.Data
 	if dt, ok := imp.dt.(*arrow.DictionaryType); ok {
 		dictImp := &cimporter{dt: dt.ValueType}
-		if err := dictImp.doImport(imp.arr.dictionary); err != nil {
+		if err := dictImp.importChild(imp, imp.arr.dictionary); err != nil {
 			return err
 		}
 		defer dictImp.data.Release()
@@ -685,6 +724,13 @@ func (imp *cimporter) importFixedSizePrimitive() error {
 		dict = dictImp.data.(*array.Data)
 	}
 
+	if nulls != nil {
+		defer nulls.Release()
+	}
+	if values != nil {
+		defer values.Release()
+	}
+
 	imp.data = array.NewDataWithDictionary(imp.dt, int(imp.arr.length), []*memory.Buffer{nulls, values}, int(imp.arr.null_count), int(imp.arr.offset), dict)
 	return nil
 }
@@ -721,9 +767,9 @@ func (imp *cimporter) importBuffer(bufferID int, sz int64) (*memory.Buffer, erro
 		}
 		return memory.NewBufferBytes([]byte{}), nil
 	}
-	const maxLen = 0x7fffffff
-	data := (*[maxLen]byte)(unsafe.Pointer(imp.cbuffers[bufferID]))[:sz:sz]
-	return memory.NewBufferBytes(data), nil
+	data := unsafe.Slice((*byte)(unsafe.Pointer(imp.cbuffers[bufferID])), sz)
+	imp.alloc.addBuffer()
+	return memory.NewBufferWithAllocator(data, imp.alloc), nil
 }
 
 func (imp *cimporter) importBitsBuffer(bufferID int) (*memory.Buffer, error) {
@@ -760,7 +806,7 @@ func (imp *cimporter) importVariableValuesBuffer(bufferID int, byteWidth, nvals
 
 func importCArrayAsType(arr *CArrowArray, dt arrow.DataType) (imp *cimporter, err error) {
 	imp = &cimporter{dt: dt}
-	err = imp.doImport(arr)
+	err = imp.doImportArr(arr)
 	return
 }
 
diff --git a/go/arrow/cdata/cdata_fulltest.c b/go/arrow/cdata/cdata_fulltest.c
index 7aed597942b51..4291cfff865b5 100644
--- a/go/arrow/cdata/cdata_fulltest.c
+++ b/go/arrow/cdata/cdata_fulltest.c
@@ -27,8 +27,20 @@
 #include "arrow/c/helpers.h"
 #include "utils.h"
 
+int is_little_endian()
+{
+  unsigned int x = 1;
+  char *c = (char*) &x;
+  return (int)*c;
+}
+
 static const int64_t kDefaultFlags = ARROW_FLAG_NULLABLE;
 
+extern void releaseTestArr(struct ArrowArray* array);
+void goReleaseTestArray(struct ArrowArray* array) {
+  releaseTestArr(array);
+}
+
 static void release_int32_type(struct ArrowSchema* schema) {
     // mark released
     schema->release = NULL;
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index af05649b1c541..f09fa3ff2f6fa 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -40,6 +40,7 @@ import (
 	"github.com/apache/arrow/go/v14/arrow/decimal128"
 	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
 	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -488,8 +489,11 @@ func TestPrimitiveArrs(t *testing.T) {
 			arr := tt.fn()
 			defer arr.Release()
 
-			carr := createCArr(arr)
-			defer freeTestArr(carr)
+			mem := mallocator.NewMallocator()
+			defer mem.AssertSize(t, 0)
+
+			carr := createCArr(arr, mem)
+			defer freeTestMallocatorArr(carr, mem)
 
 			imported, err := ImportCArrayWithType(carr, arr.DataType())
 			assert.NoError(t, err)
@@ -508,8 +512,11 @@ func TestPrimitiveSliced(t *testing.T) {
 	sl := array.NewSlice(arr, 1, 2)
 	defer sl.Release()
 
-	carr := createCArr(sl)
-	defer freeTestArr(carr)
+	mem := mallocator.NewMallocator()
+	defer mem.AssertSize(t, 0)
+
+	carr := createCArr(sl, mem)
+	defer freeTestMallocatorArr(carr, mem)
 
 	imported, err := ImportCArrayWithType(carr, arr.DataType())
 	assert.NoError(t, err)
@@ -687,8 +694,11 @@ func TestNestedArrays(t *testing.T) {
 			arr := tt.fn()
 			defer arr.Release()
 
-			carr := createCArr(arr)
-			defer freeTestArr(carr)
+			mem := mallocator.NewMallocator()
+			defer mem.AssertSize(t, 0)
+
+			carr := createCArr(arr, mem)
+			defer freeTestMallocatorArr(carr, mem)
 
 			imported, err := ImportCArrayWithType(carr, arr.DataType())
 			assert.NoError(t, err)
@@ -701,11 +711,14 @@ func TestNestedArrays(t *testing.T) {
 }
 
 func TestRecordBatch(t *testing.T) {
+	mem := mallocator.NewMallocator()
+	defer mem.AssertSize(t, 0)
+
 	arr := createTestStructArr()
 	defer arr.Release()
 
-	carr := createCArr(arr)
-	defer freeTestArr(carr)
+	carr := createCArr(arr, mem)
+	defer freeTestMallocatorArr(carr, mem)
 
 	sc := testStruct([]string{"+s", "c", "u"}, []string{"", "a", "b"}, []int64{0, flagIsNullable, flagIsNullable})
 	defer freeMallocedSchemas(sc)
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index 7dd23926a607a..2df52dcb3cd40 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -26,25 +26,20 @@ package cdata
 // #include "arrow/c/helpers.h"
 //
 // void setup_array_stream_test(const int n_batches, struct ArrowArrayStream* out);
-// struct ArrowArray* get_test_arr() {
+// static struct ArrowArray* get_test_arr() {
 //   struct ArrowArray* array = (struct ArrowArray*)malloc(sizeof(struct ArrowArray));
 //   memset(array, 0, sizeof(*array));
 //   return array;
 // }
-// struct ArrowArrayStream* get_test_stream() {
+// static struct ArrowArrayStream* get_test_stream() {
 //	struct ArrowArrayStream* out = (struct ArrowArrayStream*)malloc(sizeof(struct ArrowArrayStream));
 //	memset(out, 0, sizeof(struct ArrowArrayStream));
 //	return out;
 // }
 //
-// void release_test_arr(struct ArrowArray* arr) {
-//  for (int i = 0; i < arr->n_buffers; ++i) {
-//		free((void*)arr->buffers[i]);
-//	}
-//  ArrowArrayMarkReleased(arr);
-// }
+// void release_test_arr(struct ArrowArray* arr);
 //
-// int32_t* get_data() {
+// static int32_t* get_data() {
 //	int32_t* data = malloc(sizeof(int32_t)*10);
 //  for (int i = 0; i < 10; ++i) { data[i] = i+1; }
 //	return data;
@@ -62,16 +57,22 @@ package cdata
 // int test_exported_stream(struct ArrowArrayStream* stream);
 // void test_stream_schema_fallible(struct ArrowArrayStream* stream);
 // int confuse_go_gc(struct ArrowArrayStream* stream, unsigned int seed);
+// extern void releaseTestArr(struct ArrowArray* array);
+// extern void goReleaseTestArray(struct ArrowArray* array);
 import "C"
+
 import (
 	"errors"
 	"fmt"
 	"io"
 	"math/rand"
+	"runtime/cgo"
 	"unsafe"
 
 	"github.com/apache/arrow/go/v14/arrow"
 	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 )
 
 const (
@@ -227,50 +228,103 @@ func testSchema(fmts, names []string, flags []int64) **CArrowSchema {
 	return C.test_schema((**C.char)(unsafe.Pointer(&cfmts[0])), (**C.char)(unsafe.Pointer(&cnames[0])), (*C.int64_t)(unsafe.Pointer(&cflags[0])), C.int(len(fmts)))
 }
 
-func freeTestArr(carr *CArrowArray) {
-	C.free(unsafe.Pointer(carr))
+func freeAny[T any](alloc *mallocator.Mallocator, p *T, n int) {
+	raw := unsafe.Slice((*byte)(unsafe.Pointer(p)), int(unsafe.Sizeof(*p))*n)
+	alloc.Free(raw)
+}
+
+func freeTestMallocatorArr(carr *CArrowArray, alloc *mallocator.Mallocator) {
+	freeAny(alloc, carr, 1)
+}
+
+func getTestArr(alloc *mallocator.Mallocator) *CArrowArray {
+	raw := alloc.Allocate(C.sizeof_struct_ArrowArray)
+	return (*CArrowArray)(unsafe.Pointer(&raw[0]))
+}
+
+type testReleaser struct {
+	alloc *mallocator.Mallocator
+	bufs  [][]byte
+}
+
+//export releaseTestArr
+func releaseTestArr(arr *CArrowArray) {
+	if C.ArrowArrayIsReleased(arr) == 1 {
+		return
+	}
+	defer C.ArrowArrayMarkReleased(arr)
+
+	h := getHandle(arr.private_data)
+	tr := h.Value().(*testReleaser)
+
+	alloc := tr.alloc
+	for _, b := range tr.bufs {
+		alloc.Free(b)
+	}
+
+	if arr.n_buffers > 0 {
+		freeAny(alloc, arr.buffers, int(arr.n_buffers))
+	}
+
+	if arr.dictionary != nil {
+		C.ArrowArrayRelease(arr.dictionary)
+		freeAny(alloc, arr.dictionary, 1)
+	}
+
+	if arr.n_children > 0 {
+		children := unsafe.Slice(arr.children, arr.n_children)
+		for _, c := range children {
+			C.ArrowArrayRelease(c)
+			freeTestMallocatorArr(c, alloc)
+		}
+
+		freeAny(alloc, arr.children, int(arr.n_children))
+	}
+
+	h.Delete()
+	C.free(unsafe.Pointer(arr.private_data))
+}
+
+func allocateBufferMallocatorPtrArr(alloc *mallocator.Mallocator, n int) []*C.void {
+	raw := alloc.Allocate(int(unsafe.Sizeof((*C.void)(nil))) * n)
+	return unsafe.Slice((**C.void)(unsafe.Pointer(&raw[0])), n)
+}
+
+func allocateChildrenPtrArr(alloc *mallocator.Mallocator, n int) []*CArrowArray {
+	raw := alloc.Allocate(int(unsafe.Sizeof((*CArrowArray)(nil))) * n)
+	return unsafe.Slice((**CArrowArray)(unsafe.Pointer(&raw[0])), n)
 }
 
-func createCArr(arr arrow.Array) *CArrowArray {
+func createCArr(arr arrow.Array, alloc *mallocator.Mallocator) *CArrowArray {
 	var (
-		carr      = C.get_test_arr()
+		carr      = getTestArr(alloc)
 		children  = (**CArrowArray)(nil)
 		nchildren = C.int64_t(0)
 	)
 
 	switch arr := arr.(type) {
-	case *array.List:
-		clist := []*CArrowArray{createCArr(arr.ListValues())}
-		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
-		nchildren += 1
-	case *array.LargeList:
-		clist := []*CArrowArray{createCArr(arr.ListValues())}
-		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
-		nchildren += 1
-	case *array.FixedSizeList:
-		clist := []*CArrowArray{createCArr(arr.ListValues())}
+	case array.ListLike:
+		clist := allocateChildrenPtrArr(alloc, 1)
+		clist[0] = createCArr(arr.ListValues(), alloc)
 		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
 		nchildren += 1
 	case *array.Struct:
-		clist := []*CArrowArray{}
+		clist := allocateChildrenPtrArr(alloc, arr.NumField())
 		for i := 0; i < arr.NumField(); i++ {
-			clist = append(clist, createCArr(arr.Field(i)))
+			clist[i] = createCArr(arr.Field(i), alloc)
 			nchildren += 1
 		}
 		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
-	case *array.Map:
-		clist := []*CArrowArray{createCArr(arr.ListValues())}
-		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
-		nchildren += 1
 	case *array.RunEndEncoded:
-		clist := []*CArrowArray{createCArr(arr.RunEndsArr()),
-			createCArr(arr.Values())}
+		clist := allocateChildrenPtrArr(alloc, 2)
+		clist[0] = createCArr(arr.RunEndsArr(), alloc)
+		clist[1] = createCArr(arr.Values(), alloc)
 		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
 		nchildren += 2
 	case array.Union:
-		clist := []*CArrowArray{}
+		clist := allocateChildrenPtrArr(alloc, arr.NumFields())
 		for i := 0; i < arr.NumFields(); i++ {
-			clist = append(clist, createCArr(arr.Field(i)))
+			clist[i] = createCArr(arr.Field(i), alloc)
 			nchildren += 1
 		}
 		children = (**CArrowArray)(unsafe.Pointer(&clist[0]))
@@ -282,21 +336,36 @@ func createCArr(arr arrow.Array) *CArrowArray {
 	carr.length = C.int64_t(arr.Len())
 	carr.null_count = C.int64_t(arr.NullN())
 	carr.offset = C.int64_t(arr.Data().Offset())
-	carr.release = (*[0]byte)(C.release_test_arr)
+	carr.release = (*[0]byte)(C.goReleaseTestArray)
+	tr := &testReleaser{alloc: alloc}
+	h := cgo.NewHandle(tr)
+	carr.private_data = createHandle(h)
 
 	buffers := arr.Data().Buffers()
-	if len(buffers) == 0 {
+	bufOffset, nbuffers := 0, len(buffers)
+	hasValidityBitmap := internal.DefaultHasValidityBitmap(arr.DataType().ID())
+	if nbuffers > 0 && !hasValidityBitmap {
+		nbuffers--
+		bufOffset++
+	}
+
+	if nbuffers == 0 {
 		return carr
 	}
 
-	cbufs := allocateBufferPtrArr(len(buffers))
-	for i, b := range buffers {
+	tr.bufs = make([][]byte, 0, nbuffers)
+	cbufs := allocateBufferMallocatorPtrArr(alloc, nbuffers)
+	for i, b := range buffers[bufOffset:] {
 		if b != nil {
-			cbufs[i] = (*C.void)(C.CBytes(b.Bytes()))
+			raw := alloc.Allocate(b.Len())
+			copy(raw, b.Bytes())
+			tr.bufs = append(tr.bufs, raw)
+			cbufs[i] = (*C.void)(unsafe.Pointer(&raw[0]))
 		} else {
 			cbufs[i] = nil
 		}
 	}
+
 	carr.n_buffers = C.int64_t(len(cbufs))
 	if len(cbufs) > 0 {
 		carr.buffers = (*unsafe.Pointer)(unsafe.Pointer(&cbufs[0]))
diff --git a/go/arrow/cdata/exports.go b/go/arrow/cdata/exports.go
index 4dc2364da2913..9d2576818e31c 100644
--- a/go/arrow/cdata/exports.go
+++ b/go/arrow/cdata/exports.go
@@ -17,7 +17,6 @@
 package cdata
 
 import (
-	"reflect"
 	"runtime/cgo"
 	"unsafe"
 
@@ -59,12 +58,7 @@ func releaseExportedSchema(schema *CArrowSchema) {
 		C.free(unsafe.Pointer(schema.dictionary))
 	}
 
-	var children []*CArrowSchema
-	s := (*reflect.SliceHeader)(unsafe.Pointer(&children))
-	s.Data = uintptr(unsafe.Pointer(schema.children))
-	s.Len = int(schema.n_children)
-	s.Cap = int(schema.n_children)
-
+	children := unsafe.Slice(schema.children, schema.n_children)
 	for _, c := range children {
 		C.ArrowSchemaRelease(c)
 	}
@@ -106,11 +100,7 @@ func releaseExportedArray(arr *CArrowArray) {
 	}
 
 	if arr.n_children > 0 {
-		var children []*CArrowArray
-		s := (*reflect.SliceHeader)(unsafe.Pointer(&children))
-		s.Data = uintptr(unsafe.Pointer(arr.children))
-		s.Len = int(arr.n_children)
-		s.Cap = int(arr.n_children)
+		children := unsafe.Slice(arr.children, arr.n_children)
 
 		for _, c := range children {
 			C.ArrowArrayRelease(c)
diff --git a/go/arrow/cdata/import_allocator.go b/go/arrow/cdata/import_allocator.go
new file mode 100644
index 0000000000000..eff8c7517caef
--- /dev/null
+++ b/go/arrow/cdata/import_allocator.go
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT 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 cdata
+
+import (
+	"sync/atomic"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+)
+
+// #include "arrow/c/helpers.h"
+// #include <stdlib.h>
+import "C"
+
+type importAllocator struct {
+	bufCount int64
+
+	arr *CArrowArray
+}
+
+func (i *importAllocator) addBuffer() {
+	atomic.AddInt64(&i.bufCount, 1)
+}
+
+func (*importAllocator) Allocate(int) []byte {
+	panic("cannot allocate from importAllocator")
+}
+
+func (*importAllocator) Reallocate(int, []byte) []byte {
+	panic("cannot reallocate from importAllocator")
+}
+
+func (i *importAllocator) Free([]byte) {
+	debug.Assert(atomic.LoadInt64(&i.bufCount) > 0, "too many releases")
+
+	if atomic.AddInt64(&i.bufCount, -1) == 0 {
+		defer C.free(unsafe.Pointer(i.arr))
+		C.ArrowArrayRelease(i.arr)
+		if C.ArrowArrayIsReleased(i.arr) != 1 {
+			panic("did not release C mem")
+		}
+	}
+}
diff --git a/go/arrow/cdata/interface.go b/go/arrow/cdata/interface.go
index c7e81dde9f063..bf5c5270bae2f 100644
--- a/go/arrow/cdata/interface.go
+++ b/go/arrow/cdata/interface.go
@@ -116,6 +116,7 @@ func ImportCRecordBatchWithSchema(arr *CArrowArray, sc *arrow.Schema) (arrow.Rec
 	if err != nil {
 		return nil, err
 	}
+	defer imp.data.Release()
 
 	st := array.NewStructData(imp.data)
 	defer st.Release()
diff --git a/go/arrow/cdata/utils.h b/go/arrow/cdata/utils.h
index f38281057b495..dda46b72b728b 100644
--- a/go/arrow/cdata/utils.h
+++ b/go/arrow/cdata/utils.h
@@ -17,17 +17,6 @@
 // +build cgo
 // +build test
 
-/* 
-   Function check_for_endianness() returns 1, if architecture 
-   is little endian, 0 in case of big endian.
-*/
-inline int is_little_endian()
-{
-  unsigned int x = 1;
-  char *c = (char*) &x;
-  return (int)*c;
-}
-
 // metadata keys 1: {"key1", "key2"}
 // metadata values 1: {"", "bar"}
 static const char kEncodedMeta1LE[] = {
diff --git a/go/arrow/memory/buffer.go b/go/arrow/memory/buffer.go
index 2ddb3f829c833..5a2b4297031f0 100644
--- a/go/arrow/memory/buffer.go
+++ b/go/arrow/memory/buffer.go
@@ -33,6 +33,18 @@ type Buffer struct {
 	parent *Buffer
 }
 
+// NewBufferWithAllocator returns a buffer with the mutable flag set
+// as false. The intention here is to allow wrapping a byte slice along
+// with an allocator as a buffer to track the lifetime via refcounts
+// in order to call Free when the refcount goes to zero.
+//
+// The primary example this is used for, is currently importing data
+// through the c data interface and tracking the lifetime of the
+// imported buffers.
+func NewBufferWithAllocator(data []byte, mem Allocator) *Buffer {
+	return &Buffer{refCount: 1, buf: data, length: len(data), mem: mem}
+}
+
 // NewBufferBytes creates a fixed-size buffer from the specified data.
 func NewBufferBytes(data []byte) *Buffer {
 	return &Buffer{refCount: 0, buf: data, length: len(data)}

From 63840f297df681e710a0b1a822235eca54f1c2fb Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 19 Oct 2023 10:39:18 +0900
Subject: [PATCH 585/749] GH-36594: [C++] Don't use MSVC_VERSION to determin
 -fms-compatibility-version (#36595)

### Rationale for this change

`MSVC_VERSION` isn't used correctly.

### What changes are included in this PR?

* Remove MSVC 2013 or earlier check because it reached EOL
* Don't change `-fms-compatibility-version` depending on `MSVC_VERSION`
   * Always use the lowest supported Visual Studio version for it

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #36594

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/cmake_modules/SetupCxxFlags.cmake      |  5 -----
 cpp/src/gandiva/precompiled/CMakeLists.txt | 22 ++++++++--------------
 2 files changed, 8 insertions(+), 19 deletions(-)

diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake
index e90c00612caa3..8e8f687d06539 100644
--- a/cpp/cmake_modules/SetupCxxFlags.cmake
+++ b/cpp/cmake_modules/SetupCxxFlags.cmake
@@ -177,11 +177,6 @@ if(WIN32)
   add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)
 
   if(MSVC)
-    if(MSVC_VERSION VERSION_LESS 19)
-      message(FATAL_ERROR "Only MSVC 2015 (Version 19.0) and later are supported
-      by Arrow. Found version ${CMAKE_CXX_COMPILER_VERSION}.")
-    endif()
-
     # ARROW-1931 See https://github.com/google/googletest/issues/1318
     #
     # This is added to CMAKE_CXX_FLAGS instead of CXX_COMMON_FLAGS since only the
diff --git a/cpp/src/gandiva/precompiled/CMakeLists.txt b/cpp/src/gandiva/precompiled/CMakeLists.txt
index 4ca5cc655b2a7..3e41640861123 100644
--- a/cpp/src/gandiva/precompiled/CMakeLists.txt
+++ b/cpp/src/gandiva/precompiled/CMakeLists.txt
@@ -30,23 +30,17 @@ set(PRECOMPILED_SRCS
     timestamp_arithmetic.cc
     ../../arrow/util/basic_decimal.cc)
 
+set(PLATFORM_CLANG_OPTIONS -std=c++17)
 if(MSVC)
-  # clang pretends to be a particular version of MSVC. Thestandard
-  # library uses C++14 features, so we have to use that -std version
-  # to get the IR compilation to work.
+  # "19.20" means that it's compatible with Visual Studio 16 2019.
+  # We can update this to "19.30" when we dropped support for Visual
+  # Studio 16 2019.
+  #
   # See https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
   # for MSVC_VERSION and Visual Studio version.
-  if(MSVC_VERSION LESS 1930)
-    set(FMS_COMPATIBILITY 19.20)
-  elseif(MSVC_VERSION LESS 1920)
-    set(FMS_COMPATIBILITY 19.10)
-  else()
-    message(FATAL_ERROR "Unsupported MSVC_VERSION=${MSVC_VERSION}")
-  endif()
-  set(PLATFORM_CLANG_OPTIONS -std=c++17 -fms-compatibility
-                             -fms-compatibility-version=${FMS_COMPATIBILITY})
-else()
-  set(PLATFORM_CLANG_OPTIONS -std=c++17)
+  set(FMS_COMPATIBILITY 19.20)
+  list(APPEND PLATFORM_CLANG_OPTIONS -fms-compatibility
+       -fms-compatibility-version=${FMS_COMPATIBILITY})
 endif()
 
 # Create bitcode for each of the source files.

From 3cf96b39d04adfd4b9f2cf8ff762d8326312a129 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 19 Oct 2023 18:10:05 +0900
Subject: [PATCH 586/749] GH-38332: [CI][Release] Resolve symlinks in RAT lint
 (#38337)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Our release script (`dev/release/02-source.sh`) resolves symlinks in source archive but our lint script (`dev/archery/archery/utils/source.py`) doesn't resolve symlinks. So we may detect RAT problem by our CI.

### What changes are included in this PR?

Resolve symlinks in our lint script too.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38332

Lead-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Co-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 cpp/cmake_modules/snappy.diff       | 19 +++++++++++++++++++
 dev/archery/archery/utils/source.py | 18 +++++++++++++++---
 dev/release/02-source.sh            |  4 +++-
 dev/release/rat_exclude_files.txt   |  5 -----
 4 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/cpp/cmake_modules/snappy.diff b/cpp/cmake_modules/snappy.diff
index f86e2bb19780c..e763636e1dab7 100644
--- a/cpp/cmake_modules/snappy.diff
+++ b/cpp/cmake_modules/snappy.diff
@@ -1,3 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# https://github.com/google/snappy/pull/172
+
 diff --git a/snappy.cc b/snappy.cc
 index d414718..5b0d0d6 100644
 --- a/snappy.cc
diff --git a/dev/archery/archery/utils/source.py b/dev/archery/archery/utils/source.py
index 37d8cd502a3a0..1915b8f2ef305 100644
--- a/dev/archery/archery/utils/source.py
+++ b/dev/archery/archery/utils/source.py
@@ -18,7 +18,9 @@
 import os
 from pathlib import Path
 import subprocess
+import tempfile
 
+from .command import Command
 from .git import git
 
 
@@ -117,10 +119,20 @@ def archive(self, path, dereference=False, compressor=None, revision=None):
             raise ValueError("{} is not backed by git".format(self))
 
         rev = revision if revision else "HEAD"
-        archive = git.archive("--prefix=apache-arrow/", rev,
+        archive = git.archive("--prefix=apache-arrow.tmp/", rev,
                               git_dir=self.path)
-
-        # TODO(fsaintjacques): fix dereference for
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            tar_path = tmp / "apache-arrow.tar"
+            with open(tar_path, "wb") as tar:
+                tar.write(archive)
+            Command("tar").run("xf", tar_path, "-C", tmp)
+            # Must use the same logic in dev/release/02-source.sh
+            Command("cp").run("-R", "-L", tmp /
+                              "apache-arrow.tmp", tmp / "apache-arrow")
+            Command("tar").run("cf", tar_path, "-C", tmp, "apache-arrow")
+            with open(tar_path, "rb") as tar:
+                archive = tar.read()
 
         if compressor:
             archive = compressor(archive)
diff --git a/dev/release/02-source.sh b/dev/release/02-source.sh
index e9cd7126361cd..a3441b23bf539 100755
--- a/dev/release/02-source.sh
+++ b/dev/release/02-source.sh
@@ -65,7 +65,9 @@ rm -rf ${tag}
   git archive ${release_hash} --prefix ${tag}/) | \
   tar xf -
 
-# Resolve all hard and symbolic links
+# Resolve all hard and symbolic links.
+# If we change this, we must change ArrowSources.archive in
+# dev/archery/archery/utils/source.py too.
 rm -rf ${tag}.tmp
 mv ${tag} ${tag}.tmp
 cp -R -L ${tag}.tmp ${tag}
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index af084ea215621..ce637bf839232 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -22,9 +22,6 @@ cpp/build-support/cpplint.py
 cpp/build-support/lint_exclusions.txt
 cpp/build-support/iwyu/*
 cpp/cmake_modules/FindPythonLibsNew.cmake
-cpp/cmake_modules/SnappyCMakeLists.txt
-cpp/cmake_modules/SnappyConfig.h
-cpp/cmake_modules/snappy.diff
 cpp/examples/parquet/parquet-arrow/cmake_modules/FindArrow.cmake
 cpp/src/parquet/.parquetcppversion
 cpp/src/generated/parquet_constants.cpp
@@ -89,8 +86,6 @@ js/yarn.lock
 js/.eslintignore
 python/cmake_modules
 python/cmake_modules/FindPythonLibsNew.cmake
-python/cmake_modules/SnappyCMakeLists.txt
-python/cmake_modules/SnappyConfig.h
 python/MANIFEST.in
 python/manylinux1/.dockerignore
 python/pyarrow/includes/__init__.pxd

From 883a439076233f3f2836f281614ebe01601ccab9 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 19 Oct 2023 11:28:42 +0200
Subject: [PATCH 587/749] GH-38323: [CI][Python] Use system gdb on
 test-conda-python (#38324)

### Rationale for this change

gdb on conda-forge frequently conflicts with the newest Python version (example for Python 3.12: https://github.com/conda-forge/gdb-feedstock/issues/66)

### What changes are included in this PR?

Use the system-provided gdb instead of trying to install it from conda-forge.

This works because the Python interpreter used for gdb is entirely independent from the Python interpreter under test, and gdb itself can debug any binary, regardless of binutils version.

However, there is a complication: if the system Python version and the conda-forge Python version are the same, then for some reason `pyarrow/tests/test_gdb.py` would fail with the system gdb. In that case we still install the conda-forge gdb.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #38323

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/docker/conda-python.dockerfile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/ci/docker/conda-python.dockerfile b/ci/docker/conda-python.dockerfile
index ca0ceee5f9227..5d37c53386e7d 100644
--- a/ci/docker/conda-python.dockerfile
+++ b/ci/docker/conda-python.dockerfile
@@ -23,9 +23,11 @@ FROM ${repo}:${arch}-conda-cpp
 ARG python=3.8
 COPY ci/conda_env_python.txt \
      /arrow/ci/
+# If the Python version being tested is the same as the Python used by the system gdb,
+# we need to install the conda-forge gdb instead (GH-38323).
 RUN mamba install -q -y \
         --file arrow/ci/conda_env_python.txt \
-        gdb \
+        $([ "$python" == $(gdb --batch --eval-command 'python import sys; print(f"{sys.version_info.major}.{sys.version_info.minor}")') ] && echo "gdb") \
         python=${python} \
         nomkl && \
     mamba clean --all

From ea936e3506e5b408ff39a2ef762ab5fa7aba72ae Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 19 Oct 2023 14:00:28 +0200
Subject: [PATCH 588/749] GH-37910: [Java][Integration] Implement C Data
 Interface integration testing (#38248)

### Rationale for this change

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

* Closes: #37910

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 ci/scripts/integration_arrow.sh               |   4 +-
 dev/archery/archery/integration/cdata.py      |  18 +-
 dev/archery/archery/integration/datagen.py    |   1 -
 dev/archery/archery/integration/runner.py     |  23 +--
 dev/archery/archery/integration/tester.py     | 104 +++++-----
 dev/archery/archery/integration/tester_cpp.py |  11 --
 .../archery/integration/tester_csharp.py      |  19 +-
 dev/archery/archery/integration/tester_go.py  |  18 +-
 .../archery/integration/tester_java.py        | 177 +++++++++++++++++-
 docker-compose.yml                            |  11 +-
 .../arrow/c/BufferImportTypeVisitor.java      |   4 +-
 .../main/java/org/apache/arrow/c/Format.java  |   4 +
 .../org/apache/arrow/c/SchemaImporter.java    |   2 +-
 .../org/apache/arrow/c/DictionaryTest.java    |   4 +-
 .../java/org/apache/arrow/c/StreamTest.java   |   2 +-
 .../org/apache/arrow/vector/NullVector.java   |   1 +
 .../vector/compare/RangeEqualsVisitor.java    |   6 +-
 .../vector/dictionary/DictionaryProvider.java |  29 ++-
 .../arrow/vector/ipc/JsonFileReader.java      |  38 +++-
 .../vector/ipc/message/ArrowRecordBatch.java  |   4 +-
 .../apache/arrow/vector/util/Validator.java   |  26 +++
 21 files changed, 372 insertions(+), 134 deletions(-)

diff --git a/ci/scripts/integration_arrow.sh b/ci/scripts/integration_arrow.sh
index 289d376a4db9b..2861b1c09d479 100755
--- a/ci/scripts/integration_arrow.sh
+++ b/ci/scripts/integration_arrow.sh
@@ -23,8 +23,8 @@ arrow_dir=${1}
 gold_dir=$arrow_dir/testing/data/arrow-ipc-stream/integration
 
 pip install -e $arrow_dir/dev/archery[integration]
-# For C# C Data Interface testing
-pip install pythonnet
+# For C Data Interface testing
+pip install jpype1 pythonnet
 
 # Get more detailed context on crashes
 export PYTHONFAULTHANDLER=1
diff --git a/dev/archery/archery/integration/cdata.py b/dev/archery/archery/integration/cdata.py
index c201f5f867f8f..8e5550fcdb9c5 100644
--- a/dev/archery/archery/integration/cdata.py
+++ b/dev/archery/archery/integration/cdata.py
@@ -80,6 +80,15 @@ def ffi() -> cffi.FFI:
     return ffi
 
 
+def _release_memory_steps(exporter: CDataExporter, importer: CDataImporter):
+    yield
+    for i in range(max(exporter.required_gc_runs, importer.required_gc_runs)):
+        importer.run_gc()
+        yield
+        exporter.run_gc()
+        yield
+
+
 @contextmanager
 def check_memory_released(exporter: CDataExporter, importer: CDataImporter):
     """
@@ -96,12 +105,13 @@ def check_memory_released(exporter: CDataExporter, importer: CDataImporter):
     if do_check:
         before = exporter.record_allocation_state()
     yield
-    # We don't use a `finally` clause: if the enclosed block raised an
-    # exception, no need to add another one.
+    # Only check for memory state if `yield` didn't raise.
     if do_check:
-        ok = exporter.compare_allocation_state(before, importer.gc_until)
-        if not ok:
+        for _ in _release_memory_steps(exporter, importer):
             after = exporter.record_allocation_state()
+            if after == before:
+                break
+        if after != before:
             raise RuntimeError(
                 f"Memory was not released correctly after roundtrip: "
                 f"before = {before}, after = {after} (should have been equal)")
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index f229012366e1f..7635cfd98feda 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1722,7 +1722,6 @@ def generate_dictionary_unsigned_case():
 
     # TODO: JavaScript does not support uint64 dictionary indices, so disabled
     # for now
-
     # dict3 = Dictionary(3, StringField('dictionary3'), size=5, name='DICT3')
     fields = [
         DictionaryField('f0', get_field('', 'uint8'), dict0),
diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index eb2e26951cd88..841633f94cdba 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -421,17 +421,18 @@ def _compare_c_data_implementations(
         # Serial execution is required for proper memory accounting
         serial = True
 
-        exporter = producer.make_c_data_exporter()
-        importer = consumer.make_c_data_importer()
-
-        case_runner = partial(self._run_c_schema_test_case, producer, consumer,
-                              exporter, importer)
-        self._run_test_cases(case_runner, self.json_files, serial=serial)
-
-        if producer.C_DATA_ARRAY_EXPORTER and consumer.C_DATA_ARRAY_IMPORTER:
-            case_runner = partial(self._run_c_array_test_cases, producer, consumer,
-                                  exporter, importer)
-            self._run_test_cases(case_runner, self.json_files, serial=serial)
+        with producer.make_c_data_exporter() as exporter:
+            with consumer.make_c_data_importer() as importer:
+                case_runner = partial(self._run_c_schema_test_case,
+                                      producer, consumer,
+                                      exporter, importer)
+                self._run_test_cases(case_runner, self.json_files, serial=serial)
+
+                if producer.C_DATA_ARRAY_EXPORTER and consumer.C_DATA_ARRAY_IMPORTER:
+                    case_runner = partial(self._run_c_array_test_cases,
+                                          producer, consumer,
+                                          exporter, importer)
+                    self._run_test_cases(case_runner, self.json_files, serial=serial)
 
     def _run_c_schema_test_case(self,
                                 producer: Tester, consumer: Tester,
diff --git a/dev/archery/archery/integration/tester.py b/dev/archery/archery/integration/tester.py
index 6cde20e61b321..eadb953a61b50 100644
--- a/dev/archery/archery/integration/tester.py
+++ b/dev/archery/archery/integration/tester.py
@@ -68,52 +68,52 @@ def supports_releasing_memory(self) -> bool:
         Whether the implementation is able to release memory deterministically.
 
         Here, "release memory" means that, after the `release` callback of
-        a C Data Interface export is called, `compare_allocation_state` is
-        able to trigger the deallocation of the memory underlying the export
-        (for example buffer data).
+        a C Data Interface export is called, `run_gc` is able to trigger
+        the deallocation of the memory underlying the export (such as buffer data).
 
-        If false, then `record_allocation_state` and `compare_allocation_state`
-        are allowed to raise NotImplementedError.
+        If false, then `record_allocation_state` is allowed to raise
+        NotImplementedError.
         """
 
     def record_allocation_state(self) -> object:
         """
-        Record the current memory allocation state.
+        Return the current memory allocation state.
 
         Returns
         -------
         state : object
-            Opaque object representing the allocation state,
-            for example the number of allocated bytes.
+            Equality-comparable object representing the allocation state,
+            for example the number of allocated or exported bytes.
         """
         raise NotImplementedError
 
-    def compare_allocation_state(self, recorded: object,
-                                 gc_until: typing.Callable[[_Predicate], bool]
-                                 ) -> bool:
+    def run_gc(self):
         """
-        Compare the current memory allocation state with the recorded one.
+        Run the GC if necessary.
 
-        Parameters
-        ----------
-        recorded : object
-            The previous allocation state returned by
-            `record_allocation_state()`
-        gc_until : callable
-            A callable itself accepting a callable predicate, and
-            returning a boolean.
-            `gc_until` should try to release memory until the predicate
-            becomes true, or until it decides to give up. The final value
-            of the predicate should be returned.
-            `gc_until` is typically provided by the C Data Interface importer.
+        This should ensure that any temporary objects and data created by
+        previous exporter calls are collected.
+        """
 
-        Returns
-        -------
-        success : bool
-            Whether memory allocation state finally reached its previously
-            recorded value.
+    @property
+    def required_gc_runs(self):
         """
-        raise NotImplementedError
+        The maximum number of calls to `run_gc` that need to be issued to
+        ensure proper deallocation. Some implementations may require this
+        to be greater than one.
+        """
+        return 1
+
+    def close(self):
+        """
+        Final cleanup after usage.
+        """
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
 
 
 class CDataImporter(ABC):
@@ -163,32 +163,40 @@ def supports_releasing_memory(self) -> bool:
         """
         Whether the implementation is able to release memory deterministically.
 
-        Here, "release memory" means calling the `release` callback of
-        a C Data Interface export (which should then trigger a deallocation
-        mechanism on the exporter).
+        Here, "release memory" means `run_gc()` is able to trigger the
+        `release` callback of a C Data Interface export (which would then
+        induce a deallocation mechanism on the exporter).
+        """
 
-        If false, then `gc_until` is allowed to raise NotImplementedError.
+    def run_gc(self):
         """
+        Run the GC if necessary.
 
-    def gc_until(self, predicate: _Predicate):
+        This should ensure that any imported data has its release callback called.
         """
-        Try to release memory until the predicate becomes true, or fail.
 
-        Depending on the CDataImporter implementation, this may for example
-        try once, or run a garbage collector a given number of times, or
-        any other implementation-specific strategy for releasing memory.
+    @property
+    def required_gc_runs(self):
+        """
+        The maximum number of calls to `run_gc` that need to be issued to
+        ensure release callbacks are triggered. Some implementations may
+        require this to be greater than one.
+        """
+        return 1
 
-        The running time should be kept reasonable and compatible with
-        execution of multiple C Data integration tests.
+    def close(self):
+        """
+        Final cleanup after usage.
+        """
 
-        This should not raise if `supports_releasing_memory` is true.
+    def __enter__(self):
+        return self
 
-        Returns
-        -------
-        success : bool
-            The final value of the predicate.
-        """
-        raise NotImplementedError
+    def __exit__(self, *exc):
+        # Make sure any exported data is released.
+        for i in range(self.required_gc_runs):
+            self.run_gc()
+        self.close()
 
 
 class Tester:
diff --git a/dev/archery/archery/integration/tester_cpp.py b/dev/archery/archery/integration/tester_cpp.py
index 866fc225d220a..658e71330155e 100644
--- a/dev/archery/archery/integration/tester_cpp.py
+++ b/dev/archery/archery/integration/tester_cpp.py
@@ -223,13 +223,6 @@ def supports_releasing_memory(self):
     def record_allocation_state(self):
         return self.dll.ArrowCpp_BytesAllocated()
 
-    def compare_allocation_state(self, recorded, gc_until):
-        def pred():
-            # No GC on our side, so just compare allocation state
-            return self.record_allocation_state() == recorded
-
-        return gc_until(pred)
-
 
 class CppCDataImporter(CDataImporter, _CDataBase):
 
@@ -247,7 +240,3 @@ def import_batch_and_compare_to_json(self, json_path, num_batch,
     @property
     def supports_releasing_memory(self):
         return True
-
-    def gc_until(self, predicate):
-        # No GC on our side, so can evaluate predicate immediately
-        return predicate()
diff --git a/dev/archery/archery/integration/tester_csharp.py b/dev/archery/archery/integration/tester_csharp.py
index 83b07495f9907..7dca525673ba6 100644
--- a/dev/archery/archery/integration/tester_csharp.py
+++ b/dev/archery/archery/integration/tester_csharp.py
@@ -16,7 +16,6 @@
 # under the License.
 
 from contextlib import contextmanager
-import gc
 import os
 
 from . import cdata
@@ -82,6 +81,10 @@ def _read_batch_from_json(self, json_path, num_batch):
         schema = jf.Schema.ToArrow()
         return schema, jf.Batches[num_batch].ToArrow(schema)
 
+    def _run_gc(self):
+        from Apache.Arrow.IntegrationTest import CDataInterface
+        CDataInterface.RunGC()
+
 
 class CSharpCDataExporter(CDataExporter, _CDataBase):
 
@@ -105,6 +108,9 @@ def supports_releasing_memory(self):
         # XXX the C# GC doesn't give reliable allocation measurements
         return False
 
+    def run_gc(self):
+        self._run_gc()
+
 
 class CSharpCDataImporter(CDataImporter, _CDataBase):
 
@@ -134,15 +140,8 @@ def import_batch_and_compare_to_json(self, json_path, num_batch,
     def supports_releasing_memory(self):
         return True
 
-    def gc_until(self, predicate):
-        from Apache.Arrow.IntegrationTest import CDataInterface
-        for i in range(3):
-            if predicate():
-                return True
-            # Collect any C# objects hanging around through Python
-            gc.collect()
-            CDataInterface.RunGC()
-        return predicate()
+    def run_gc(self):
+        self._run_gc()
 
 
 class CSharpTester(Tester):
diff --git a/dev/archery/archery/integration/tester_go.py b/dev/archery/archery/integration/tester_go.py
index b7af233f5d6e2..2b3dc3a1be336 100644
--- a/dev/archery/archery/integration/tester_go.py
+++ b/dev/archery/archery/integration/tester_go.py
@@ -200,9 +200,6 @@ def _check_go_error(self, go_error):
             finally:
                 self.dll.ArrowGo_FreeError(go_error)
 
-    def _run_gc(self):
-        self.dll.ArrowGo_RunGC()
-
 
 class GoCDataExporter(CDataExporter, _CDataBase):
     # Note: the Arrow Go C Data export functions expect their output
@@ -225,14 +222,10 @@ def supports_releasing_memory(self):
         return True
 
     def record_allocation_state(self):
-        self._run_gc()
         return self.dll.ArrowGo_BytesAllocated()
 
-    def compare_allocation_state(self, recorded, gc_until):
-        def pred():
-            return self.record_allocation_state() == recorded
-
-        return gc_until(pred)
+    # Note: no need to call the Go GC anywhere thanks to Arrow Go's
+    # explicit refcounting.
 
 
 class GoCDataImporter(CDataImporter, _CDataBase):
@@ -252,10 +245,3 @@ def import_batch_and_compare_to_json(self, json_path, num_batch,
     @property
     def supports_releasing_memory(self):
         return True
-
-    def gc_until(self, predicate):
-        for i in range(10):
-            if predicate():
-                return True
-            self._run_gc()
-        return False
diff --git a/dev/archery/archery/integration/tester_java.py b/dev/archery/archery/integration/tester_java.py
index 45855079eb72e..5684798d794ad 100644
--- a/dev/archery/archery/integration/tester_java.py
+++ b/dev/archery/archery/integration/tester_java.py
@@ -16,10 +16,12 @@
 # under the License.
 
 import contextlib
+import functools
 import os
 import subprocess
 
-from .tester import Tester
+from . import cdata
+from .tester import Tester, CDataExporter, CDataImporter
 from .util import run_cmd, log
 from ..utils.source import ARROW_ROOT_DEFAULT
 
@@ -32,6 +34,8 @@ def load_version_from_pom():
     return version_tag.text
 
 
+# XXX Should we add "-Darrow.memory.debug.allocator=true"? It adds a couple
+# minutes to total CPU usage of the integration test suite.
 _JAVA_OPTS = [
     "-Dio.netty.tryReflectionSetAccessible=true",
     "-Darrow.struct.conflict.policy=CONFLICT_APPEND",
@@ -42,18 +46,25 @@ def load_version_from_pom():
     "ARROW_JAVA_INTEGRATION_JAR",
     os.path.join(
         ARROW_ROOT_DEFAULT,
-        "java/tools/target/arrow-tools-{}-"
-        "jar-with-dependencies.jar".format(_arrow_version),
-    ),
+        "java/tools/target",
+        f"arrow-tools-{_arrow_version}-jar-with-dependencies.jar"
+    )
+)
+_ARROW_C_DATA_JAR = os.environ.get(
+    "ARROW_C_DATA_JAVA_INTEGRATION_JAR",
+    os.path.join(
+        ARROW_ROOT_DEFAULT,
+        "java/c/target",
+        f"arrow-c-data-{_arrow_version}.jar"
+    )
 )
 _ARROW_FLIGHT_JAR = os.environ.get(
     "ARROW_FLIGHT_JAVA_INTEGRATION_JAR",
     os.path.join(
         ARROW_ROOT_DEFAULT,
-        "java/flight/flight-integration-tests/target/"
-        "flight-integration-tests-{}-jar-with-dependencies.jar".format(
-            _arrow_version),
-    ),
+        "java/flight/flight-integration-tests/target",
+        f"flight-integration-tests-{_arrow_version}-jar-with-dependencies.jar"
+    )
 )
 _ARROW_FLIGHT_SERVER = (
     "org.apache.arrow.flight.integration.tests.IntegrationTestServer"
@@ -63,11 +74,155 @@ def load_version_from_pom():
 )
 
 
+@functools.lru_cache
+def setup_jpype():
+    import jpype
+    jar_path = f"{_ARROW_TOOLS_JAR}:{_ARROW_C_DATA_JAR}"
+    # XXX Didn't manage to tone down the logging level here (DEBUG -> INFO)
+    jpype.startJVM(jpype.getDefaultJVMPath(),
+                   "-Djava.class.path=" + jar_path, *_JAVA_OPTS)
+
+
+class _CDataBase:
+
+    def __init__(self, debug, args):
+        import jpype
+        self.debug = debug
+        self.args = args
+        self.ffi = cdata.ffi()
+        setup_jpype()
+        # JPype pointers to java.io, org.apache.arrow...
+        self.java_io = jpype.JPackage("java").io
+        self.java_arrow = jpype.JPackage("org").apache.arrow
+        self.java_allocator = self._make_java_allocator()
+
+    def _pointer_to_int(self, c_ptr):
+        return int(self.ffi.cast('uintptr_t', c_ptr))
+
+    def _wrap_c_schema_ptr(self, c_schema_ptr):
+        return self.java_arrow.c.ArrowSchema.wrap(
+            self._pointer_to_int(c_schema_ptr))
+
+    def _wrap_c_array_ptr(self, c_array_ptr):
+        return self.java_arrow.c.ArrowArray.wrap(
+            self._pointer_to_int(c_array_ptr))
+
+    def _make_java_allocator(self):
+        # Return a new allocator
+        return self.java_arrow.memory.RootAllocator()
+
+    def _assert_schemas_equal(self, expected, actual):
+        # XXX This is fragile for dictionaries, as Schema.equals compares
+        # dictionary ids.
+        self.java_arrow.vector.util.Validator.compareSchemas(
+            expected, actual)
+
+    def _assert_batches_equal(self, expected, actual):
+        self.java_arrow.vector.util.Validator.compareVectorSchemaRoot(
+            expected, actual)
+
+    def _assert_dict_providers_equal(self, expected, actual):
+        self.java_arrow.vector.util.Validator.compareDictionaryProviders(
+            expected, actual)
+
+    # Note: no need to call the Java GC anywhere thanks to AutoCloseable
+
+
+class JavaCDataExporter(CDataExporter, _CDataBase):
+
+    def export_schema_from_json(self, json_path, c_schema_ptr):
+        json_file = self.java_io.File(json_path)
+        with self.java_arrow.vector.ipc.JsonFileReader(
+                json_file, self.java_allocator) as json_reader:
+            schema = json_reader.start()
+            dict_provider = json_reader
+            self.java_arrow.c.Data.exportSchema(
+                self.java_allocator, schema, dict_provider,
+                self._wrap_c_schema_ptr(c_schema_ptr)
+            )
+
+    def export_batch_from_json(self, json_path, num_batch, c_array_ptr):
+        json_file = self.java_io.File(json_path)
+        with self.java_arrow.vector.ipc.JsonFileReader(
+                json_file, self.java_allocator) as json_reader:
+            json_reader.start()
+            if num_batch > 0:
+                actually_skipped = json_reader.skip(num_batch)
+                assert actually_skipped == num_batch
+            with json_reader.read() as batch:
+                dict_provider = json_reader
+                self.java_arrow.c.Data.exportVectorSchemaRoot(
+                    self.java_allocator, batch, dict_provider,
+                    self._wrap_c_array_ptr(c_array_ptr))
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def record_allocation_state(self):
+        return self.java_allocator.getAllocatedMemory()
+
+    def close(self):
+        self.java_allocator.close()
+
+
+class JavaCDataImporter(CDataImporter, _CDataBase):
+
+    def import_schema_and_compare_to_json(self, json_path, c_schema_ptr):
+        json_file = self.java_io.File(json_path)
+        with self.java_arrow.vector.ipc.JsonFileReader(
+                json_file, self.java_allocator) as json_reader:
+            json_schema = json_reader.start()
+            with self.java_arrow.c.CDataDictionaryProvider() as dict_provider:
+                imported_schema = self.java_arrow.c.Data.importSchema(
+                    self.java_allocator,
+                    self._wrap_c_schema_ptr(c_schema_ptr),
+                    dict_provider)
+                self._assert_schemas_equal(json_schema, imported_schema)
+
+    def import_batch_and_compare_to_json(self, json_path, num_batch,
+                                         c_array_ptr):
+        json_file = self.java_io.File(json_path)
+        with self.java_arrow.vector.ipc.JsonFileReader(
+                json_file, self.java_allocator) as json_reader:
+            schema = json_reader.start()
+            if num_batch > 0:
+                actually_skipped = json_reader.skip(num_batch)
+                assert actually_skipped == num_batch
+            with json_reader.read() as batch:
+                with self.java_arrow.vector.VectorSchemaRoot.create(
+                        schema, self.java_allocator) as imported_batch:
+                    # We need to pass a dict provider primed with dictionary ids
+                    # matching those in the schema, hence an empty
+                    # CDataDictionaryProvider would not work here.
+                    dict_provider = (self.java_arrow.vector.dictionary
+                                     .DictionaryProvider.MapDictionaryProvider())
+                    dict_provider.copyStructureFrom(json_reader, self.java_allocator)
+                    with dict_provider:
+                        self.java_arrow.c.Data.importIntoVectorSchemaRoot(
+                            self.java_allocator,
+                            self._wrap_c_array_ptr(c_array_ptr),
+                            imported_batch, dict_provider)
+                        self._assert_batches_equal(batch, imported_batch)
+                        self._assert_dict_providers_equal(json_reader, dict_provider)
+
+    @property
+    def supports_releasing_memory(self):
+        return True
+
+    def close(self):
+        self.java_allocator.close()
+
+
 class JavaTester(Tester):
     PRODUCER = True
     CONSUMER = True
     FLIGHT_SERVER = True
     FLIGHT_CLIENT = True
+    C_DATA_SCHEMA_EXPORTER = True
+    C_DATA_SCHEMA_IMPORTER = True
+    C_DATA_ARRAY_EXPORTER = True
+    C_DATA_ARRAY_IMPORTER = True
 
     name = 'Java'
 
@@ -186,3 +341,9 @@ def flight_server(self, scenario_name=None):
         finally:
             server.kill()
             server.wait(5)
+
+    def make_c_data_exporter(self):
+        return JavaCDataExporter(self.debug, self.args)
+
+    def make_c_data_importer(self):
+        return JavaCDataImporter(self.debug, self.args)
diff --git a/docker-compose.yml b/docker-compose.yml
index 0e5034346e780..e54c609e54138 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1730,16 +1730,21 @@ services:
     volumes: *conda-volumes
     environment:
       <<: [*common, *ccache]
-      # tell archery where the arrow binaries are located
+      ARCHERY_INTEGRATION_WITH_RUST: 0
+      # Tell Archery where the arrow C++ binaries are located
       ARROW_CPP_EXE_PATH: /build/cpp/debug
       ARROW_GO_INTEGRATION: 1
-      ARCHERY_INTEGRATION_WITH_RUST: 0
+      ARROW_JAVA_CDATA: "ON"
+      JAVA_JNI_CMAKE_ARGS: >-
+        -DARROW_JAVA_JNI_ENABLE_DEFAULT=OFF
+        -DARROW_JAVA_JNI_ENABLE_C=ON
     command:
       ["/arrow/ci/scripts/rust_build.sh /arrow /build &&
         /arrow/ci/scripts/cpp_build.sh /arrow /build &&
         /arrow/ci/scripts/csharp_build.sh /arrow /build &&
         /arrow/ci/scripts/go_build.sh /arrow &&
-        /arrow/ci/scripts/java_build.sh /arrow /build &&
+        /arrow/ci/scripts/java_jni_build.sh /arrow $${ARROW_HOME} /build /tmp/dist/java/$$(arch) &&
+        /arrow/ci/scripts/java_build.sh /arrow /build /tmp/dist/java &&
         /arrow/ci/scripts/js_build.sh /arrow /build &&
         /arrow/ci/scripts/integration_arrow.sh /arrow /build"]
 
diff --git a/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java b/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
index 7408bf71136fa..cd2a464f4fa17 100644
--- a/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
+++ b/java/c/src/main/java/org/apache/arrow/c/BufferImportTypeVisitor.java
@@ -165,9 +165,9 @@ public List<ArrowBuf> visit(ArrowType.Union type) {
         return Collections.singletonList(importFixedBytes(type, 0, UnionVector.TYPE_WIDTH));
       case Dense:
         return Arrays.asList(importFixedBytes(type, 0, DenseUnionVector.TYPE_WIDTH),
-            importFixedBytes(type, 0, DenseUnionVector.OFFSET_WIDTH));
+            importFixedBytes(type, 1, DenseUnionVector.OFFSET_WIDTH));
       default:
-        throw new UnsupportedOperationException("Importing buffers for type: " + type);
+        throw new UnsupportedOperationException("Importing buffers for union type: " + type);
     }
   }
 
diff --git a/java/c/src/main/java/org/apache/arrow/c/Format.java b/java/c/src/main/java/org/apache/arrow/c/Format.java
index 315d3caad7da2..2875e46f749c4 100644
--- a/java/c/src/main/java/org/apache/arrow/c/Format.java
+++ b/java/c/src/main/java/org/apache/arrow/c/Format.java
@@ -138,6 +138,8 @@ static String asString(ArrowType arrowType) {
             return "tiD";
           case YEAR_MONTH:
             return "tiM";
+          case MONTH_DAY_NANO:
+            return "tin";
           default:
             throw new UnsupportedOperationException(
                 String.format("Interval type with unit %s is unsupported", type.getUnit()));
@@ -277,6 +279,8 @@ static ArrowType asType(String format, long flags)
         return new ArrowType.Interval(IntervalUnit.YEAR_MONTH);
       case "tiD":
         return new ArrowType.Interval(IntervalUnit.DAY_TIME);
+      case "tin":
+        return new ArrowType.Interval(IntervalUnit.MONTH_DAY_NANO);
       case "+l":
         return new ArrowType.List();
       case "+L":
diff --git a/java/c/src/main/java/org/apache/arrow/c/SchemaImporter.java b/java/c/src/main/java/org/apache/arrow/c/SchemaImporter.java
index 21d88f6cd4ba5..09a6afafa0a46 100644
--- a/java/c/src/main/java/org/apache/arrow/c/SchemaImporter.java
+++ b/java/c/src/main/java/org/apache/arrow/c/SchemaImporter.java
@@ -44,7 +44,7 @@ final class SchemaImporter {
   private static final Logger logger = LoggerFactory.getLogger(SchemaImporter.class);
 
   private static final int MAX_IMPORT_RECURSION_LEVEL = 64;
-  private long nextDictionaryID = 1L;
+  private long nextDictionaryID = 0L;
 
   private final BufferAllocator allocator;
 
diff --git a/java/c/src/test/java/org/apache/arrow/c/DictionaryTest.java b/java/c/src/test/java/org/apache/arrow/c/DictionaryTest.java
index 3f793f836d634..9dcb262af4616 100644
--- a/java/c/src/test/java/org/apache/arrow/c/DictionaryTest.java
+++ b/java/c/src/test/java/org/apache/arrow/c/DictionaryTest.java
@@ -100,7 +100,7 @@ public void testWithDictionary() throws Exception {
     dictVector.setSafe(2, "cc".getBytes());
     dictVector.setValueCount(3);
 
-    Dictionary dictionary = new Dictionary(dictVector, new DictionaryEncoding(1L, false, /* indexType= */null));
+    Dictionary dictionary = new Dictionary(dictVector, new DictionaryEncoding(0L, false, /* indexType= */null));
     provider.put(dictionary);
 
     // create vector and encode it
@@ -169,7 +169,7 @@ private ArrowStreamReader createMultiBatchReader() throws IOException {
       dictVector.setSafe(3, "dd".getBytes());
       dictVector.setSafe(4, "ee".getBytes());
       dictVector.setValueCount(5);
-      Dictionary dictionary = new Dictionary(dictVector, new DictionaryEncoding(1L, false, /* indexType= */null));
+      Dictionary dictionary = new Dictionary(dictVector, new DictionaryEncoding(0L, false, /* indexType= */null));
       provider.put(dictionary);
 
       Schema schema = new Schema(Collections.singletonList(vector.getField()));
diff --git a/java/c/src/test/java/org/apache/arrow/c/StreamTest.java b/java/c/src/test/java/org/apache/arrow/c/StreamTest.java
index 06401687a5a66..68d4fc2a81e68 100644
--- a/java/c/src/test/java/org/apache/arrow/c/StreamTest.java
+++ b/java/c/src/test/java/org/apache/arrow/c/StreamTest.java
@@ -135,7 +135,7 @@ public void roundtripStrings() throws Exception {
   @Test
   public void roundtripDictionary() throws Exception {
     final ArrowType.Int indexType = new ArrowType.Int(32, true);
-    final DictionaryEncoding encoding = new DictionaryEncoding(1L, false, indexType);
+    final DictionaryEncoding encoding = new DictionaryEncoding(0L, false, indexType);
     final Schema schema = new Schema(Collections.singletonList(
         new Field("dict", new FieldType(/*nullable=*/true, indexType, encoding), Collections.emptyList())));
     final List<ArrowRecordBatch> batches = new ArrayList<>();
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java b/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
index 6e4c2764bdcc4..1badf4b4ca808 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
@@ -192,6 +192,7 @@ public List<FieldVector> getChildrenFromFields() {
   @Override
   public void loadFieldBuffers(ArrowFieldNode fieldNode, List<ArrowBuf> ownBuffers) {
     Preconditions.checkArgument(ownBuffers.isEmpty(), "Null vector has no buffers");
+    valueCount = fieldNode.getLength();
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java b/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java
index 698ddac466041..5323ddda838c8 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java
@@ -121,9 +121,11 @@ public boolean rangeEquals(Range range) {
         "rightStart %s must be non negative.", range.getRightStart());
 
     Preconditions.checkArgument(range.getRightStart() + range.getLength() <= right.getValueCount(),
-        "(rightStart + length) %s out of range[0, %s].", 0, right.getValueCount());
+        "(rightStart + length) %s out of range[0, %s].",
+        range.getRightStart() + range.getLength(), right.getValueCount());
     Preconditions.checkArgument(range.getLeftStart() + range.getLength() <= left.getValueCount(),
-        "(leftStart + length) %s out of range[0, %s].", 0, left.getValueCount());
+        "(leftStart + length) %s out of range[0, %s].",
+        range.getLeftStart() + range.getLength(), left.getValueCount());
 
     return left.accept(this, range);
   }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryProvider.java b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryProvider.java
index 76e1eb9f66d25..f64c32be0f3e9 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryProvider.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryProvider.java
@@ -21,6 +21,9 @@
 import java.util.Map;
 import java.util.Set;
 
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.util.VisibleForTesting;
+
 /**
  * A manager for association of dictionary IDs to their corresponding {@link Dictionary}.
  */
@@ -35,7 +38,7 @@ public interface DictionaryProvider {
   /**
    * Implementation of {@link DictionaryProvider} that is backed by a hash-map.
    */
-  class MapDictionaryProvider implements DictionaryProvider {
+  class MapDictionaryProvider implements AutoCloseable, DictionaryProvider {
 
     private final Map<Long, Dictionary> map;
 
@@ -49,6 +52,23 @@ public MapDictionaryProvider(Dictionary... dictionaries) {
       }
     }
 
+    /**
+     * Initialize the map structure from another provider, but with empty vectors.
+     *
+     * @param other the {@link DictionaryProvider} to copy the ids and fields from
+     * @param allocator allocator to create the empty vectors
+     */
+    // This is currently called using JPype by the integration tests.
+    @VisibleForTesting
+    public void copyStructureFrom(DictionaryProvider other, BufferAllocator allocator) {
+      for (Long id : other.getDictionaryIds()) {
+        Dictionary otherDict = other.lookup(id);
+        Dictionary newDict = new Dictionary(otherDict.getVector().getField().createVector(allocator),
+                otherDict.getEncoding());
+        put(newDict);
+      }
+    }
+
     public void put(Dictionary dictionary) {
       map.put(dictionary.getEncoding().getId(), dictionary);
     }
@@ -62,5 +82,12 @@ public final Set<Long> getDictionaryIds() {
     public Dictionary lookup(long id) {
       return map.get(id);
     }
+
+    @Override
+    public void close() {
+      for (Dictionary dictionary : map.values()) {
+        dictionary.getVector().close();
+      }
+    }
   }
 }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ipc/JsonFileReader.java b/java/vector/src/main/java/org/apache/arrow/vector/ipc/JsonFileReader.java
index 742daeef255f8..0c23a664f62d6 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/ipc/JsonFileReader.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/ipc/JsonFileReader.java
@@ -237,6 +237,28 @@ public VectorSchemaRoot read() throws IOException {
     }
   }
 
+  /**
+   * Skips a number of record batches in the file.
+   *
+   * @param numBatches the number of batches to skip
+   * @return the actual number of skipped batches.
+   */
+  // This is currently called using JPype by the integration tests.
+  public int skip(int numBatches) throws IOException {
+    for (int i = 0; i < numBatches; ++i) {
+      JsonToken t = parser.nextToken();
+      if (t == START_OBJECT) {
+        parser.skipChildren();
+        assert parser.getCurrentToken() == END_OBJECT;
+      } else if (t == END_ARRAY) {
+        return i;
+      } else {
+        throw new IllegalArgumentException("Invalid token: " + t);
+      }
+    }
+    return numBatches;
+  }
+
   private abstract class BufferReader {
     protected abstract ArrowBuf read(BufferAllocator allocator, int count) throws IOException;
 
@@ -692,7 +714,8 @@ private ArrowBuf readIntoBuffer(BufferAllocator allocator, BufferType bufferType
   }
 
   private void readFromJsonIntoVector(Field field, FieldVector vector) throws JsonParseException, IOException {
-    TypeLayout typeLayout = TypeLayout.getTypeLayout(field.getType());
+    ArrowType type = field.getType();
+    TypeLayout typeLayout = TypeLayout.getTypeLayout(type);
     List<BufferType> vectorTypes = typeLayout.getBufferTypes();
     ArrowBuf[] vectorBuffers = new ArrowBuf[vectorTypes.size()];
     /*
@@ -728,21 +751,18 @@ private void readFromJsonIntoVector(Field field, FieldVector vector) throws Json
         BufferType bufferType = vectorTypes.get(v);
         nextFieldIs(bufferType.getName());
         int innerBufferValueCount = valueCount;
-        if (bufferType.equals(OFFSET) && !field.getType().getTypeID().equals(ArrowType.ArrowTypeID.Union)) {
-          /* offset buffer has 1 additional value capacity */
+        if (bufferType.equals(OFFSET) && !(type instanceof ArrowType.Union)) {
+          /* offset buffer has 1 additional value capacity except for dense unions */
           innerBufferValueCount = valueCount + 1;
         }
 
         vectorBuffers[v] = readIntoBuffer(allocator, bufferType, vector.getMinorType(), innerBufferValueCount);
       }
 
-      if (vectorBuffers.length == 0) {
-        readToken(END_OBJECT);
-        return;
-      }
-
       int nullCount = 0;
-      if (!(vector.getField().getFieldType().getType() instanceof ArrowType.Union)) {
+      if (type instanceof ArrowType.Null) {
+        nullCount = valueCount;
+      } else if (!(type instanceof ArrowType.Union)) {
         nullCount = BitVectorHelper.getNullCount(vectorBuffers[0], valueCount);
       }
       final ArrowFieldNode fieldNode = new ArrowFieldNode(valueCount, nullCount);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ipc/message/ArrowRecordBatch.java b/java/vector/src/main/java/org/apache/arrow/vector/ipc/message/ArrowRecordBatch.java
index 83a8ece0bfb06..f81d049a9257f 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/ipc/message/ArrowRecordBatch.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/ipc/message/ArrowRecordBatch.java
@@ -112,8 +112,8 @@ public ArrowRecordBatch(
       }
       long size = arrowBuf.readableBytes();
       arrowBuffers.add(new ArrowBuffer(offset, size));
-      if (LOGGER.isDebugEnabled()) {
-        LOGGER.debug("Buffer in RecordBatch at {}, length: {}", offset, size);
+      if (LOGGER.isTraceEnabled()) {
+        LOGGER.trace("Buffer in RecordBatch at {}, length: {}", offset, size);
       }
       offset += size;
       if (alignBuffers) { // align on 8 byte boundaries
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/Validator.java b/java/vector/src/main/java/org/apache/arrow/vector/util/Validator.java
index 741972b4ad2a8..0c9ad1e2753f1 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/Validator.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/Validator.java
@@ -17,6 +17,7 @@
 
 package org.apache.arrow.vector.util;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
@@ -85,6 +86,31 @@ public static void compareDictionaries(
     }
   }
 
+  /**
+   * Validate two dictionary providers are equal in structure and contents.
+   */
+  public static void compareDictionaryProviders(
+          DictionaryProvider provider1,
+          DictionaryProvider provider2) {
+    List<Long> ids1 = new ArrayList(provider1.getDictionaryIds());
+    List<Long> ids2 = new ArrayList(provider2.getDictionaryIds());
+    java.util.Collections.sort(ids1);
+    java.util.Collections.sort(ids2);
+    if (!ids1.equals(ids2)) {
+      throw new IllegalArgumentException("Different ids in dictionary providers:\n" +
+              ids1 + "\n" + ids2);
+    }
+    for (long id : ids1) {
+      Dictionary dict1 = provider1.lookup(id);
+      Dictionary dict2 = provider2.lookup(id);
+      try {
+        compareFieldVectors(dict1.getVector(), dict2.getVector());
+      } catch (IllegalArgumentException e) {
+        throw new IllegalArgumentException("Different dictionaries:\n" + dict1 + "\n" + dict2, e);
+      }
+    }
+  }
+
   /**
    * Validate two arrow vectorSchemaRoot are equal.
    *

From 23dfd0e8643799b803b286e88ca6253303ecb703 Mon Sep 17 00:00:00 2001
From: Thomas Newton <thomas.w.newton@gmail.com>
Date: Thu, 19 Oct 2023 13:50:35 +0100
Subject: [PATCH 589/749] GH-37511: [C++] Implement file reads for Azure
 filesystem (#38269)

### Rationale for this change

We want a C++ implementation of an Azure filesystem. Reading files is the first step.

### What changes are included in this PR?

Adds an implementation of `io::RandomAccessFile` for Azure blob storage (with or without hierarchical namespace (HNS) a.k.a datalake gen 2). This is largely copied from https://github.com/apache/arrow/pull/12914. Using this `io::RandomAccessFile` implementation we implement the input file and stream methods of the `AzureFileSystem`.

I've made a few changes to the implementation from https://github.com/apache/arrow/pull/12914. The biggest one is removing use of the Azure SDK datalake APIs. These APIs cannot be tested with `azurite`, they are only beneficial for listing operations on HNS enabled accounts and detecting a HNS enabled account is quite difficult (unless you use significantly elevated Azure permissions). Adding 2 different code paths for normal blob storage and datalake gen 2 seems like a bad idea to me except in cases where there is a performance advantage. I also made a few other tweaks to some of the error handling and to make things more consistent with the S3 or GCS filesystems.

### Are these changes tested?

Yes. The tests are all based on the tests from the GCS filesystem with minimal chantges. I remember reading a review comment on https://github.com/apache/arrow/pull/12914 which recommended this approach.
There are a few places where the GCS tests relied on file writes or file info methods so I've replaced those with direct calls to the Azure blob client and left TODO comments saying to switch them to use the AzureFilesystem when the relevant methods are implemented.

### Are there any user-facing changes?

Yes. File reads using the Azure filesystem are now supported.

* Closes: #37511

Lead-authored-by: Thomas Newton <thomas.w.newton@gmail.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/filesystem/azurefs.cc      | 335 ++++++++++++++++++--
 cpp/src/arrow/filesystem/azurefs.h       |   3 +
 cpp/src/arrow/filesystem/azurefs_test.cc | 371 ++++++++++++++++++++---
 3 files changed, 658 insertions(+), 51 deletions(-)

diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc
index fcbae332d2397..179be069b2acf 100644
--- a/cpp/src/arrow/filesystem/azurefs.cc
+++ b/cpp/src/arrow/filesystem/azurefs.cc
@@ -17,11 +17,17 @@
 
 #include "arrow/filesystem/azurefs.h"
 
-#include <azure/identity/default_azure_credential.hpp>
 #include <azure/storage/blobs.hpp>
 
+#include "arrow/buffer.h"
+#include "arrow/filesystem/path_util.h"
+#include "arrow/filesystem/util_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/future.h"
+#include "arrow/util/key_value_metadata.h"
+#include "arrow/util/logging.h"
+#include "arrow/util/string.h"
 
 namespace arrow {
 namespace fs {
@@ -37,34 +43,329 @@ bool AzureOptions::Equals(const AzureOptions& other) const {
           credentials_kind == other.credentials_kind);
 }
 
+Status AzureOptions::ConfigureAccountKeyCredentials(const std::string& account_name,
+                                                    const std::string& account_key) {
+  if (this->backend == AzureBackend::Azurite) {
+    account_blob_url = "http://127.0.0.1:10000/" + account_name + "/";
+    account_dfs_url = "http://127.0.0.1:10000/" + account_name + "/";
+  } else {
+    account_dfs_url = "https://" + account_name + ".dfs.core.windows.net/";
+    account_blob_url = "https://" + account_name + ".blob.core.windows.net/";
+  }
+  storage_credentials_provider =
+      std::make_shared<Azure::Storage::StorageSharedKeyCredential>(account_name,
+                                                                   account_key);
+  credentials_kind = AzureCredentialsKind::StorageCredentials;
+  return Status::OK();
+}
+namespace {
+
+// An AzureFileSystem represents a single Azure storage account. AzurePath describes a
+// container and path within that storage account.
+struct AzurePath {
+  std::string full_path;
+  std::string container;
+  std::string path_to_file;
+  std::vector<std::string> path_to_file_parts;
+
+  static Result<AzurePath> FromString(const std::string& s) {
+    // Example expected string format: testcontainer/testdir/testfile.txt
+    // container = testcontainer
+    // path_to_file = testdir/testfile.txt
+    // path_to_file_parts = [testdir, testfile.txt]
+    if (internal::IsLikelyUri(s)) {
+      return Status::Invalid(
+          "Expected an Azure object path of the form 'container/path...', got a URI: '",
+          s, "'");
+    }
+    const auto src = internal::RemoveTrailingSlash(s);
+    auto first_sep = src.find_first_of(internal::kSep);
+    if (first_sep == 0) {
+      return Status::Invalid("Path cannot start with a separator ('", s, "')");
+    }
+    if (first_sep == std::string::npos) {
+      return AzurePath{std::string(src), std::string(src), "", {}};
+    }
+    AzurePath path;
+    path.full_path = std::string(src);
+    path.container = std::string(src.substr(0, first_sep));
+    path.path_to_file = std::string(src.substr(first_sep + 1));
+    path.path_to_file_parts = internal::SplitAbstractPath(path.path_to_file);
+    RETURN_NOT_OK(Validate(path));
+    return path;
+  }
+
+  static Status Validate(const AzurePath& path) {
+    auto status = internal::ValidateAbstractPathParts(path.path_to_file_parts);
+    if (!status.ok()) {
+      return Status::Invalid(status.message(), " in path ", path.full_path);
+    } else {
+      return status;
+    }
+  }
+
+  AzurePath parent() const {
+    DCHECK(has_parent());
+    auto parent = AzurePath{"", container, "", path_to_file_parts};
+    parent.path_to_file_parts.pop_back();
+    parent.path_to_file = internal::JoinAbstractPath(parent.path_to_file_parts);
+    if (parent.path_to_file.empty()) {
+      parent.full_path = parent.container;
+    } else {
+      parent.full_path = parent.container + internal::kSep + parent.path_to_file;
+    }
+    return parent;
+  }
+
+  bool has_parent() const { return !path_to_file.empty(); }
+
+  bool empty() const { return container.empty() && path_to_file.empty(); }
+
+  bool operator==(const AzurePath& other) const {
+    return container == other.container && path_to_file == other.path_to_file;
+  }
+};
+
+Status PathNotFound(const AzurePath& path) {
+  return ::arrow::fs::internal::PathNotFound(path.full_path);
+}
+
+Status NotAFile(const AzurePath& path) {
+  return ::arrow::fs::internal::NotAFile(path.full_path);
+}
+
+Status ValidateFilePath(const AzurePath& path) {
+  if (path.container.empty()) {
+    return PathNotFound(path);
+  }
+
+  if (path.path_to_file.empty()) {
+    return NotAFile(path);
+  }
+  return Status::OK();
+}
+
+Status ErrorToStatus(const std::string& prefix,
+                     const Azure::Storage::StorageException& exception) {
+  return Status::IOError(prefix, " Azure Error: ", exception.what());
+}
+
+template <typename ObjectResult>
+std::shared_ptr<const KeyValueMetadata> GetObjectMetadata(const ObjectResult& result) {
+  auto md = std::make_shared<KeyValueMetadata>();
+  for (auto prop : result) {
+    md->Append(prop.first, prop.second);
+  }
+  return md;
+}
+
+class ObjectInputFile final : public io::RandomAccessFile {
+ public:
+  ObjectInputFile(std::shared_ptr<Azure::Storage::Blobs::BlobClient> blob_client,
+                  const io::IOContext& io_context, AzurePath path, int64_t size = kNoSize)
+      : blob_client_(std::move(blob_client)),
+        io_context_(io_context),
+        path_(std::move(path)),
+        content_length_(size) {}
+
+  Status Init() {
+    if (content_length_ != kNoSize) {
+      DCHECK_GE(content_length_, 0);
+      return Status::OK();
+    }
+    try {
+      auto properties = blob_client_->GetProperties();
+      content_length_ = properties.Value.BlobSize;
+      metadata_ = GetObjectMetadata(properties.Value.Metadata);
+      return Status::OK();
+    } catch (const Azure::Storage::StorageException& exception) {
+      if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
+        // Could be either container or blob not found.
+        return PathNotFound(path_);
+      }
+      return ErrorToStatus(
+          "When fetching properties for '" + blob_client_->GetUrl() + "': ", exception);
+    }
+  }
+
+  Status CheckClosed(const char* action) const {
+    if (closed_) {
+      return Status::Invalid("Cannot ", action, " on closed file.");
+    }
+    return Status::OK();
+  }
+
+  Status CheckPosition(int64_t position, const char* action) const {
+    DCHECK_GE(content_length_, 0);
+    if (position < 0) {
+      return Status::Invalid("Cannot ", action, " from negative position");
+    }
+    if (position > content_length_) {
+      return Status::IOError("Cannot ", action, " past end of file");
+    }
+    return Status::OK();
+  }
+
+  // RandomAccessFile APIs
+
+  Result<std::shared_ptr<const KeyValueMetadata>> ReadMetadata() override {
+    return metadata_;
+  }
+
+  Future<std::shared_ptr<const KeyValueMetadata>> ReadMetadataAsync(
+      const io::IOContext& io_context) override {
+    return metadata_;
+  }
+
+  Status Close() override {
+    blob_client_ = nullptr;
+    closed_ = true;
+    return Status::OK();
+  }
+
+  bool closed() const override { return closed_; }
+
+  Result<int64_t> Tell() const override {
+    RETURN_NOT_OK(CheckClosed("tell"));
+    return pos_;
+  }
+
+  Result<int64_t> GetSize() override {
+    RETURN_NOT_OK(CheckClosed("size"));
+    return content_length_;
+  }
+
+  Status Seek(int64_t position) override {
+    RETURN_NOT_OK(CheckClosed("seek"));
+    RETURN_NOT_OK(CheckPosition(position, "seek"));
+
+    pos_ = position;
+    return Status::OK();
+  }
+
+  Result<int64_t> ReadAt(int64_t position, int64_t nbytes, void* out) override {
+    RETURN_NOT_OK(CheckClosed("read"));
+    RETURN_NOT_OK(CheckPosition(position, "read"));
+
+    nbytes = std::min(nbytes, content_length_ - position);
+    if (nbytes == 0) {
+      return 0;
+    }
+
+    // Read the desired range of bytes
+    Azure::Core::Http::HttpRange range{position, nbytes};
+    Azure::Storage::Blobs::DownloadBlobToOptions download_options;
+    download_options.Range = range;
+    try {
+      return blob_client_
+          ->DownloadTo(reinterpret_cast<uint8_t*>(out), nbytes, download_options)
+          .Value.ContentRange.Length.Value();
+    } catch (const Azure::Storage::StorageException& exception) {
+      return ErrorToStatus("When reading from '" + blob_client_->GetUrl() +
+                               "' at position " + std::to_string(position) + " for " +
+                               std::to_string(nbytes) + " bytes: ",
+                           exception);
+    }
+  }
+
+  Result<std::shared_ptr<Buffer>> ReadAt(int64_t position, int64_t nbytes) override {
+    RETURN_NOT_OK(CheckClosed("read"));
+    RETURN_NOT_OK(CheckPosition(position, "read"));
+
+    // No need to allocate more than the remaining number of bytes
+    nbytes = std::min(nbytes, content_length_ - position);
+
+    ARROW_ASSIGN_OR_RAISE(auto buffer,
+                          AllocateResizableBuffer(nbytes, io_context_.pool()));
+    if (nbytes > 0) {
+      ARROW_ASSIGN_OR_RAISE(int64_t bytes_read,
+                            ReadAt(position, nbytes, buffer->mutable_data()));
+      DCHECK_LE(bytes_read, nbytes);
+      RETURN_NOT_OK(buffer->Resize(bytes_read));
+    }
+    return std::move(buffer);
+  }
+
+  Result<int64_t> Read(int64_t nbytes, void* out) override {
+    ARROW_ASSIGN_OR_RAISE(int64_t bytes_read, ReadAt(pos_, nbytes, out));
+    pos_ += bytes_read;
+    return bytes_read;
+  }
+
+  Result<std::shared_ptr<Buffer>> Read(int64_t nbytes) override {
+    ARROW_ASSIGN_OR_RAISE(auto buffer, ReadAt(pos_, nbytes));
+    pos_ += buffer->size();
+    return std::move(buffer);
+  }
+
+ private:
+  std::shared_ptr<Azure::Storage::Blobs::BlobClient> blob_client_;
+  const io::IOContext io_context_;
+  AzurePath path_;
+
+  bool closed_ = false;
+  int64_t pos_ = 0;
+  int64_t content_length_ = kNoSize;
+  std::shared_ptr<const KeyValueMetadata> metadata_;
+};
+
+}  // namespace
+
 // -----------------------------------------------------------------------
 // AzureFilesystem Implementation
 
 class AzureFileSystem::Impl {
  public:
   io::IOContext io_context_;
-  bool is_hierarchical_namespace_enabled_;
+  std::shared_ptr<Azure::Storage::Blobs::BlobServiceClient> service_client_;
   AzureOptions options_;
 
   explicit Impl(AzureOptions options, io::IOContext io_context)
       : io_context_(io_context), options_(std::move(options)) {}
 
   Status Init() {
-    // TODO: GH-18014 Delete this once we have a proper implementation. This just
-    // initializes a pointless Azure blob service client with a fake endpoint to ensure
-    // the build will fail if the Azure SDK build is broken.
-    auto default_credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
-    auto service_client = Azure::Storage::Blobs::BlobServiceClient(
-        "http://fake-blob-storage-endpoint", default_credential);
-    if (options_.backend == AzureBackend::Azurite) {
-      // gen1Client_->GetAccountInfo().Value.IsHierarchicalNamespaceEnabled
-      // throws error in azurite
-      is_hierarchical_namespace_enabled_ = false;
-    }
+    service_client_ = std::make_shared<Azure::Storage::Blobs::BlobServiceClient>(
+        options_.account_blob_url, options_.storage_credentials_provider);
     return Status::OK();
   }
 
   const AzureOptions& options() const { return options_; }
+
+  Result<std::shared_ptr<ObjectInputFile>> OpenInputFile(const std::string& s,
+                                                         AzureFileSystem* fs) {
+    ARROW_RETURN_NOT_OK(internal::AssertNoTrailingSlash(s));
+    ARROW_ASSIGN_OR_RAISE(auto path, AzurePath::FromString(s));
+    RETURN_NOT_OK(ValidateFilePath(path));
+    auto blob_client = std::make_shared<Azure::Storage::Blobs::BlobClient>(
+        service_client_->GetBlobContainerClient(path.container)
+            .GetBlobClient(path.path_to_file));
+
+    auto ptr =
+        std::make_shared<ObjectInputFile>(blob_client, fs->io_context(), std::move(path));
+    RETURN_NOT_OK(ptr->Init());
+    return ptr;
+  }
+
+  Result<std::shared_ptr<ObjectInputFile>> OpenInputFile(const FileInfo& info,
+                                                         AzureFileSystem* fs) {
+    ARROW_RETURN_NOT_OK(internal::AssertNoTrailingSlash(info.path()));
+    if (info.type() == FileType::NotFound) {
+      return ::arrow::fs::internal::PathNotFound(info.path());
+    }
+    if (info.type() != FileType::File && info.type() != FileType::Unknown) {
+      return ::arrow::fs::internal::NotAFile(info.path());
+    }
+    ARROW_ASSIGN_OR_RAISE(auto path, AzurePath::FromString(info.path()));
+    RETURN_NOT_OK(ValidateFilePath(path));
+    auto blob_client = std::make_shared<Azure::Storage::Blobs::BlobClient>(
+        service_client_->GetBlobContainerClient(path.container)
+            .GetBlobClient(path.path_to_file));
+
+    auto ptr = std::make_shared<ObjectInputFile>(blob_client, fs->io_context(),
+                                                 std::move(path), info.size());
+    RETURN_NOT_OK(ptr->Init());
+    return ptr;
+  }
 };
 
 const AzureOptions& AzureFileSystem::options() const { return impl_->options(); }
@@ -118,22 +419,22 @@ Status AzureFileSystem::CopyFile(const std::string& src, const std::string& dest
 
 Result<std::shared_ptr<io::InputStream>> AzureFileSystem::OpenInputStream(
     const std::string& path) {
-  return Status::NotImplemented("The Azure FileSystem is not fully implemented");
+  return impl_->OpenInputFile(path, this);
 }
 
 Result<std::shared_ptr<io::InputStream>> AzureFileSystem::OpenInputStream(
     const FileInfo& info) {
-  return Status::NotImplemented("The Azure FileSystem is not fully implemented");
+  return impl_->OpenInputFile(info, this);
 }
 
 Result<std::shared_ptr<io::RandomAccessFile>> AzureFileSystem::OpenInputFile(
     const std::string& path) {
-  return Status::NotImplemented("The Azure FileSystem is not fully implemented");
+  return impl_->OpenInputFile(path, this);
 }
 
 Result<std::shared_ptr<io::RandomAccessFile>> AzureFileSystem::OpenInputFile(
     const FileInfo& info) {
-  return Status::NotImplemented("The Azure FileSystem is not fully implemented");
+  return impl_->OpenInputFile(info, this);
 }
 
 Result<std::shared_ptr<io::OutputStream>> AzureFileSystem::OpenOutputStream(
diff --git a/cpp/src/arrow/filesystem/azurefs.h b/cpp/src/arrow/filesystem/azurefs.h
index e5af4d23aabe5..1f7047ff94c56 100644
--- a/cpp/src/arrow/filesystem/azurefs.h
+++ b/cpp/src/arrow/filesystem/azurefs.h
@@ -79,6 +79,9 @@ struct ARROW_EXPORT AzureOptions {
 
   AzureOptions();
 
+  Status ConfigureAccountKeyCredentials(const std::string& account_name,
+                                        const std::string& account_key);
+
   bool Equals(const AzureOptions& other) const;
 };
 
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index 9bf7cb8e753ec..5d454bdc33f47 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -34,23 +34,24 @@
 #include <boost/process.hpp>
 
 #include "arrow/filesystem/azurefs.h"
-#include "arrow/util/io_util.h"
+
+#include <random>
+#include <string>
 
 #include <gmock/gmock-matchers.h>
 #include <gmock/gmock-more-matchers.h>
 #include <gtest/gtest.h>
-
-#include <string>
-
-#include "arrow/testing/gtest_util.h"
-#include "arrow/testing/util.h"
-
 #include <azure/identity/client_secret_credential.hpp>
 #include <azure/identity/default_azure_credential.hpp>
 #include <azure/identity/managed_identity_credential.hpp>
 #include <azure/storage/blobs.hpp>
 #include <azure/storage/common/storage_credential.hpp>
 
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/util.h"
+#include "arrow/util/io_util.h"
+#include "arrow/util/key_value_metadata.h"
+
 namespace arrow {
 using internal::TemporaryDir;
 namespace fs {
@@ -61,6 +62,15 @@ using ::testing::IsEmpty;
 using ::testing::Not;
 using ::testing::NotNull;
 
+auto const* kLoremIpsum = R"""(
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
+incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis
+nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu
+fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
+culpa qui officia deserunt mollit anim id est laborum.
+)""";
+
 class AzuriteEnv : public ::testing::Environment {
  public:
   AzuriteEnv() {
@@ -113,33 +123,6 @@ AzuriteEnv* GetAzuriteEnv() {
 
 // Placeholder tests
 // TODO: GH-18014 Remove once a proper test is added
-TEST(AzureFileSystem, UploadThenDownload) {
-  const std::string container_name = "sample-container";
-  const std::string blob_name = "sample-blob.txt";
-  const std::string blob_content = "Hello Azure!";
-
-  const std::string& account_name = GetAzuriteEnv()->account_name();
-  const std::string& account_key = GetAzuriteEnv()->account_key();
-
-  auto credential = std::make_shared<Azure::Storage::StorageSharedKeyCredential>(
-      account_name, account_key);
-
-  auto service_client = Azure::Storage::Blobs::BlobServiceClient(
-      std::string("http://127.0.0.1:10000/") + account_name, credential);
-  auto container_client = service_client.GetBlobContainerClient(container_name);
-  container_client.CreateIfNotExists();
-  auto blob_client = container_client.GetBlockBlobClient(blob_name);
-
-  std::vector<uint8_t> buffer(blob_content.begin(), blob_content.end());
-  blob_client.UploadFrom(buffer.data(), buffer.size());
-
-  std::vector<uint8_t> downloaded_content(blob_content.size());
-  blob_client.DownloadTo(downloaded_content.data(), downloaded_content.size());
-
-  EXPECT_EQ(std::string(downloaded_content.begin(), downloaded_content.end()),
-            blob_content);
-}
-
 TEST(AzureFileSystem, InitializeCredentials) {
   auto default_credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
   auto managed_identity_credential =
@@ -154,6 +137,326 @@ TEST(AzureFileSystem, OptionsCompare) {
   EXPECT_TRUE(options.Equals(options));
 }
 
+class TestAzureFileSystem : public ::testing::Test {
+ public:
+  std::shared_ptr<FileSystem> fs_;
+  std::shared_ptr<Azure::Storage::Blobs::BlobServiceClient> service_client_;
+  std::mt19937_64 generator_;
+  std::string container_name_;
+
+  TestAzureFileSystem() : generator_(std::random_device()()) {}
+
+  AzureOptions MakeOptions() {
+    const std::string& account_name = GetAzuriteEnv()->account_name();
+    const std::string& account_key = GetAzuriteEnv()->account_key();
+    AzureOptions options;
+    options.backend = AzureBackend::Azurite;
+    ARROW_EXPECT_OK(options.ConfigureAccountKeyCredentials(account_name, account_key));
+    return options;
+  }
+
+  void SetUp() override {
+    ASSERT_THAT(GetAzuriteEnv(), NotNull());
+    ASSERT_OK(GetAzuriteEnv()->status());
+
+    container_name_ = RandomChars(32);
+    auto options = MakeOptions();
+    service_client_ = std::make_shared<Azure::Storage::Blobs::BlobServiceClient>(
+        options.account_blob_url, options.storage_credentials_provider);
+    ASSERT_OK_AND_ASSIGN(fs_, AzureFileSystem::Make(options));
+    auto container_client = service_client_->GetBlobContainerClient(container_name_);
+    container_client.CreateIfNotExists();
+
+    auto blob_client = container_client.GetBlockBlobClient(PreexistingObjectName());
+    blob_client.UploadFrom(reinterpret_cast<const uint8_t*>(kLoremIpsum),
+                           strlen(kLoremIpsum));
+  }
+
+  void TearDown() override {
+    auto containers = service_client_->ListBlobContainers();
+    for (auto container : containers.BlobContainers) {
+      auto container_client = service_client_->GetBlobContainerClient(container.Name);
+      container_client.DeleteIfExists();
+    }
+  }
+
+  std::string PreexistingContainerName() const { return container_name_; }
+
+  std::string PreexistingContainerPath() const {
+    return PreexistingContainerName() + '/';
+  }
+
+  static std::string PreexistingObjectName() { return "test-object-name"; }
+
+  std::string PreexistingObjectPath() const {
+    return PreexistingContainerPath() + PreexistingObjectName();
+  }
+
+  std::string NotFoundObjectPath() { return PreexistingContainerPath() + "not-found"; }
+
+  std::string RandomLine(int lineno, std::size_t width) {
+    auto line = std::to_string(lineno) + ":    ";
+    line += RandomChars(width - line.size() - 1);
+    line += '\n';
+    return line;
+  }
+
+  std::size_t RandomIndex(std::size_t end) {
+    return std::uniform_int_distribution<std::size_t>(0, end - 1)(generator_);
+  }
+
+  std::string RandomChars(std::size_t count) {
+    auto const fillers = std::string("abcdefghijlkmnopqrstuvwxyz0123456789");
+    std::uniform_int_distribution<std::size_t> d(0, fillers.size() - 1);
+    std::string s;
+    std::generate_n(std::back_inserter(s), count, [&] { return fillers[d(generator_)]; });
+    return s;
+  }
+
+  void UploadLines(const std::vector<std::string>& lines, const char* path_to_file,
+                   int total_size) {
+    // TODO(GH-38333): Switch to using Azure filesystem to write once its implemented.
+    auto blob_client = service_client_->GetBlobContainerClient(PreexistingContainerName())
+                           .GetBlockBlobClient(path_to_file);
+    std::string all_lines = std::accumulate(lines.begin(), lines.end(), std::string(""));
+    blob_client.UploadFrom(reinterpret_cast<const uint8_t*>(all_lines.data()),
+                           total_size);
+  }
+};
+
+TEST_F(TestAzureFileSystem, OpenInputStreamString) {
+  std::shared_ptr<io::InputStream> stream;
+  ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
+
+  ASSERT_OK_AND_ASSIGN(auto buffer, stream->Read(1024));
+  EXPECT_EQ(buffer->ToString(), kLoremIpsum);
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamStringBuffers) {
+  std::shared_ptr<io::InputStream> stream;
+  ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
+
+  std::string contents;
+  std::shared_ptr<Buffer> buffer;
+  do {
+    ASSERT_OK_AND_ASSIGN(buffer, stream->Read(16));
+    contents.append(buffer->ToString());
+  } while (buffer && buffer->size() != 0);
+
+  EXPECT_EQ(contents, kLoremIpsum);
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamInfo) {
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(PreexistingObjectPath()));
+  arrow::fs::FileInfo info(PreexistingObjectPath(), FileType::File);
+
+  std::shared_ptr<io::InputStream> stream;
+  ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(info));
+
+  ASSERT_OK_AND_ASSIGN(auto buffer, stream->Read(1024));
+  EXPECT_EQ(buffer->ToString(), kLoremIpsum);
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamEmpty) {
+  const auto path_to_file = "empty-object.txt";
+  const auto path = PreexistingContainerPath() + path_to_file;
+  service_client_->GetBlobContainerClient(PreexistingContainerName())
+      .GetBlockBlobClient(path_to_file)
+      .UploadFrom(nullptr, 0);
+
+  ASSERT_OK_AND_ASSIGN(auto stream, fs_->OpenInputStream(path));
+  std::array<char, 1024> buffer{};
+  std::int64_t size;
+  ASSERT_OK_AND_ASSIGN(size, stream->Read(buffer.size(), buffer.data()));
+  EXPECT_EQ(size, 0);
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamNotFound) {
+  ASSERT_RAISES(IOError, fs_->OpenInputStream(NotFoundObjectPath()));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamInfoInvalid) {
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(PreexistingBucketPath()));
+  arrow::fs::FileInfo info(PreexistingContainerPath(), FileType::Directory);
+  ASSERT_RAISES(IOError, fs_->OpenInputStream(info));
+
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(NotFoundObjectPath()));
+  arrow::fs::FileInfo info2(PreexistingContainerPath(), FileType::NotFound);
+  ASSERT_RAISES(IOError, fs_->OpenInputStream(info2));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamUri) {
+  ASSERT_RAISES(Invalid, fs_->OpenInputStream("abfss://" + PreexistingObjectPath()));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamTrailingSlash) {
+  ASSERT_RAISES(IOError, fs_->OpenInputStream(PreexistingObjectPath() + '/'));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamReadMetadata) {
+  const std::string object_name = "OpenInputStreamMetadataTest/simple.txt";
+
+  service_client_->GetBlobContainerClient(PreexistingContainerName())
+      .GetBlobClient(PreexistingObjectName())
+      .SetMetadata(Azure::Storage::Metadata{{"key0", "value0"}});
+
+  std::shared_ptr<io::InputStream> stream;
+  ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
+
+  std::shared_ptr<const KeyValueMetadata> actual;
+  ASSERT_OK_AND_ASSIGN(actual, stream->ReadMetadata());
+  // TODO(GH-38330): This is asserting that the user defined metadata is returned but this
+  // is probably not the correct behaviour.
+  ASSERT_OK_AND_EQ("value0", actual->Get("key0"));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputStreamClosed) {
+  ASSERT_OK_AND_ASSIGN(auto stream, fs_->OpenInputStream(PreexistingObjectPath()));
+  ASSERT_OK(stream->Close());
+  std::array<char, 16> buffer{};
+  ASSERT_RAISES(Invalid, stream->Read(buffer.size(), buffer.data()));
+  ASSERT_RAISES(Invalid, stream->Read(buffer.size()));
+  ASSERT_RAISES(Invalid, stream->Tell());
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileMixedReadVsReadAt) {
+  // Create a file large enough to make the random access tests non-trivial.
+  auto constexpr kLineWidth = 100;
+  auto constexpr kLineCount = 4096;
+  std::vector<std::string> lines(kLineCount);
+  int lineno = 0;
+  std::generate_n(lines.begin(), lines.size(),
+                  [&] { return RandomLine(++lineno, kLineWidth); });
+
+  const auto path_to_file = "OpenInputFileMixedReadVsReadAt/object-name";
+  const auto path = PreexistingContainerPath() + path_to_file;
+
+  UploadLines(lines, path_to_file, kLineCount * kLineWidth);
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs_->OpenInputFile(path));
+  for (int i = 0; i != 32; ++i) {
+    SCOPED_TRACE("Iteration " + std::to_string(i));
+    // Verify sequential reads work as expected.
+    std::array<char, kLineWidth> buffer{};
+    std::int64_t size;
+    {
+      ASSERT_OK_AND_ASSIGN(auto actual, file->Read(kLineWidth));
+      EXPECT_EQ(lines[2 * i], actual->ToString());
+    }
+    {
+      ASSERT_OK_AND_ASSIGN(size, file->Read(buffer.size(), buffer.data()));
+      EXPECT_EQ(size, kLineWidth);
+      auto actual = std::string{buffer.begin(), buffer.end()};
+      EXPECT_EQ(lines[2 * i + 1], actual);
+    }
+
+    // Verify random reads interleave too.
+    auto const index = RandomIndex(kLineCount);
+    auto const position = index * kLineWidth;
+    ASSERT_OK_AND_ASSIGN(size, file->ReadAt(position, buffer.size(), buffer.data()));
+    EXPECT_EQ(size, kLineWidth);
+    auto actual = std::string{buffer.begin(), buffer.end()};
+    EXPECT_EQ(lines[index], actual);
+
+    // Verify random reads using buffers work.
+    ASSERT_OK_AND_ASSIGN(auto b, file->ReadAt(position, kLineWidth));
+    EXPECT_EQ(lines[index], b->ToString());
+  }
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileRandomSeek) {
+  // Create a file large enough to make the random access tests non-trivial.
+  auto constexpr kLineWidth = 100;
+  auto constexpr kLineCount = 4096;
+  std::vector<std::string> lines(kLineCount);
+  int lineno = 0;
+  std::generate_n(lines.begin(), lines.size(),
+                  [&] { return RandomLine(++lineno, kLineWidth); });
+
+  const auto path_to_file = "OpenInputFileRandomSeek/object-name";
+  const auto path = PreexistingContainerPath() + path_to_file;
+  std::shared_ptr<io::OutputStream> output;
+
+  UploadLines(lines, path_to_file, kLineCount * kLineWidth);
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs_->OpenInputFile(path));
+  for (int i = 0; i != 32; ++i) {
+    SCOPED_TRACE("Iteration " + std::to_string(i));
+    // Verify sequential reads work as expected.
+    auto const index = RandomIndex(kLineCount);
+    auto const position = index * kLineWidth;
+    ASSERT_OK(file->Seek(position));
+    ASSERT_OK_AND_ASSIGN(auto actual, file->Read(kLineWidth));
+    EXPECT_EQ(lines[index], actual->ToString());
+  }
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileIoContext) {
+  // Create a test file.
+  const auto path_to_file = "OpenInputFileIoContext/object-name";
+  const auto path = PreexistingContainerPath() + path_to_file;
+  const std::string contents = "The quick brown fox jumps over the lazy dog";
+
+  auto blob_client = service_client_->GetBlobContainerClient(PreexistingContainerName())
+                         .GetBlockBlobClient(path_to_file);
+  blob_client.UploadFrom(reinterpret_cast<const uint8_t*>(contents.data()),
+                         contents.length());
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs_->OpenInputFile(path));
+  EXPECT_EQ(fs_->io_context().external_id(), file->io_context().external_id());
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileInfo) {
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(PreexistingObjectPath()));
+  arrow::fs::FileInfo info(PreexistingObjectPath(), FileType::File);
+
+  std::shared_ptr<io::RandomAccessFile> file;
+  ASSERT_OK_AND_ASSIGN(file, fs_->OpenInputFile(info));
+
+  std::array<char, 1024> buffer{};
+  std::int64_t size;
+  auto constexpr kStart = 16;
+  ASSERT_OK_AND_ASSIGN(size, file->ReadAt(kStart, buffer.size(), buffer.data()));
+
+  auto const expected = std::string(kLoremIpsum).substr(kStart);
+  EXPECT_EQ(std::string(buffer.data(), size), expected);
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileNotFound) {
+  ASSERT_RAISES(IOError, fs_->OpenInputFile(NotFoundObjectPath()));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileInfoInvalid) {
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(PreexistingContainerPath()));
+  arrow::fs::FileInfo info(PreexistingContainerPath(), FileType::File);
+  ASSERT_RAISES(IOError, fs_->OpenInputFile(info));
+
+  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
+  // fs->GetFileInfo(NotFoundObjectPath()));
+  arrow::fs::FileInfo info2(NotFoundObjectPath(), FileType::NotFound);
+  ASSERT_RAISES(IOError, fs_->OpenInputFile(info2));
+}
+
+TEST_F(TestAzureFileSystem, OpenInputFileClosed) {
+  ASSERT_OK_AND_ASSIGN(auto stream, fs_->OpenInputFile(PreexistingObjectPath()));
+  ASSERT_OK(stream->Close());
+  std::array<char, 16> buffer{};
+  ASSERT_RAISES(Invalid, stream->Tell());
+  ASSERT_RAISES(Invalid, stream->Read(buffer.size(), buffer.data()));
+  ASSERT_RAISES(Invalid, stream->Read(buffer.size()));
+  ASSERT_RAISES(Invalid, stream->ReadAt(1, buffer.size(), buffer.data()));
+  ASSERT_RAISES(Invalid, stream->ReadAt(1, 1));
+  ASSERT_RAISES(Invalid, stream->Seek(2));
+}
+
 }  // namespace
 }  // namespace fs
 }  // namespace arrow

From 4712daba56a282137bc72e05f10a3db152ee2534 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 20 Oct 2023 00:29:52 +0800
Subject: [PATCH 590/749] GH-38326: [C++][Parquet] check the decompressed page
 size same as size in page header (#38327)

### Rationale for this change

As mentioned in issue, currently we only decompress the page without checking the decompress size.
This patch add a checkings.

### What changes are included in this PR?

Throw exception when size not matches in `SerializedPageReader::DecompressIfNeeded`

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Non-conforming files may throw an exception while they would silently return invalid results before.

* Closes: #38326

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/column_reader.cc         | 15 ++++++---
 cpp/src/parquet/column_reader_test.cc    |  4 +--
 cpp/src/parquet/file_deserialize_test.cc | 42 ++++++++++++++++++++++++
 3 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/cpp/src/parquet/column_reader.cc b/cpp/src/parquet/column_reader.cc
index e09369effb698..ecc48811e46fc 100644
--- a/cpp/src/parquet/column_reader.cc
+++ b/cpp/src/parquet/column_reader.cc
@@ -594,10 +594,17 @@ std::shared_ptr<Buffer> SerializedPageReader::DecompressIfNeeded(
   }
 
   // Decompress the values
-  PARQUET_THROW_NOT_OK(decompressor_->Decompress(
-      compressed_len - levels_byte_len, page_buffer->data() + levels_byte_len,
-      uncompressed_len - levels_byte_len,
-      decompression_buffer_->mutable_data() + levels_byte_len));
+  PARQUET_ASSIGN_OR_THROW(
+      auto decompressed_len,
+      decompressor_->Decompress(compressed_len - levels_byte_len,
+                                page_buffer->data() + levels_byte_len,
+                                uncompressed_len - levels_byte_len,
+                                decompression_buffer_->mutable_data() + levels_byte_len));
+  if (decompressed_len != uncompressed_len - levels_byte_len) {
+    throw ParquetException("Page didn't decompress to expected size, expected: " +
+                           std::to_string(uncompressed_len - levels_byte_len) +
+                           ", but got:" + std::to_string(decompressed_len));
+  }
 
   return decompression_buffer_;
 }
diff --git a/cpp/src/parquet/column_reader_test.cc b/cpp/src/parquet/column_reader_test.cc
index b3b75a7bb58d2..bed7e06786e70 100644
--- a/cpp/src/parquet/column_reader_test.cc
+++ b/cpp/src/parquet/column_reader_test.cc
@@ -1587,8 +1587,8 @@ class ByteArrayRecordReaderTest : public ::testing::TestWithParam<bool> {
 };
 
 // Tests reading and skipping a ByteArray field.
-// The binary readers only differ in DeocdeDense and DecodeSpaced functions, so
-// testing optional is sufficient in excercising those code paths.
+// The binary readers only differ in DecodeDense and DecodeSpaced functions, so
+// testing optional is sufficient in exercising those code paths.
 TEST_P(ByteArrayRecordReaderTest, ReadAndSkipOptional) {
   MakeRecordReader(/*levels_per_page=*/90, /*num_pages=*/1);
 
diff --git a/cpp/src/parquet/file_deserialize_test.cc b/cpp/src/parquet/file_deserialize_test.cc
index b2a918915e4e6..4377e714a240b 100644
--- a/cpp/src/parquet/file_deserialize_test.cc
+++ b/cpp/src/parquet/file_deserialize_test.cc
@@ -879,6 +879,48 @@ TEST_F(TestPageSerde, DataPageV2CrcCheckNonExistent) {
                          /* write_data_page_v2 */ true);
 }
 
+TEST_F(TestPageSerde, BadCompressedPageSize) {
+  // GH-38326: an exception should be raised if a compressed data page
+  // decompresses to a smaller size than declared in the data page header.
+  auto codec_types = GetSupportedCodecTypes();
+  const int data_page_bytes = 8192;
+  const int32_t num_rows = 32;  // dummy value
+  data_page_header_.num_values = num_rows;
+  std::vector<uint8_t> faux_data;
+  // A well-compressible piece of data
+  faux_data.resize(data_page_bytes, 1);
+  for (auto codec_type : codec_types) {
+    auto codec = GetCodec(codec_type);
+    std::vector<uint8_t> buffer;
+    const uint8_t* data = faux_data.data();
+    int data_size = static_cast<int>(faux_data.size());
+
+    int64_t max_compressed_size = codec->MaxCompressedLen(data_size, data);
+    buffer.resize(max_compressed_size);
+
+    int64_t actual_size;
+    ASSERT_OK_AND_ASSIGN(
+        actual_size, codec->Compress(data_size, data, max_compressed_size, &buffer[0]));
+    // Write a data page header declaring a larger decompressed size than actual
+    ASSERT_NO_FATAL_FAILURE(WriteDataPageHeader(data_page_bytes, data_size + 1,
+                                                static_cast<int32_t>(actual_size)));
+    ASSERT_OK(out_stream_->Write(buffer.data(), actual_size));
+    InitSerializedPageReader(num_rows, codec_type);
+
+    EXPECT_THROW_THAT(
+        [&]() { page_reader_->NextPage(); }, ParquetException,
+        ::testing::AnyOf(
+            ::testing::Property(
+                &ParquetException::what,
+                ::testing::HasSubstr("Page didn't decompress to expected size")),
+            // Some decompressor, like zstd, might be able to detect the error
+            // before checking the page size.
+            ::testing::Property(&ParquetException::what,
+                                ::testing::HasSubstr("IOError"))));
+    ResetStream();
+  }
+}
+
 // ----------------------------------------------------------------------
 // File structure tests
 

From 02ad5ae6cb24cf02f76fabc818e94539059078ba Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Fri, 20 Oct 2023 00:43:45 +0800
Subject: [PATCH 591/749] GH-38117: [C++][Parquet] Change DictEncoder dtor
 checking to warning log (#38118)

### Rationale for this change

This is a minor change, just change `DCHECK` to warning log.

### What changes are included in this PR?

change `DCHECK` to warning log.

### Are these changes tested?

no, I don't know how to test this, any idea is welcome.

### Are there any user-facing changes?

no

* Closes: #38117

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/parquet/encoding.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index c136671bd1327..5221f2588c0d3 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -442,7 +442,7 @@ class DictEncoderImpl : public EncoderImpl, virtual public DictEncoder<DType> {
         dict_encoded_size_(0),
         memo_table_(pool, kInitialHashTableSize) {}
 
-  ~DictEncoderImpl() override { DCHECK(buffered_indices_.empty()); }
+  ~DictEncoderImpl() = default;
 
   int dict_encoded_size() const override { return dict_encoded_size_; }
 

From a0e58f18dc643f9bfd4efa32331ddf477643fed2 Mon Sep 17 00:00:00 2001
From: orgadish <48453207+orgadish@users.noreply.github.com>
Date: Thu, 19 Oct 2023 14:43:48 -0400
Subject: [PATCH 592/749] GH-38033: [R] Allow `code()` to return package name
 prefix. (#38144)

### Rationale for this change
#38033

### What changes are included in this PR?
- ~~Added `get_pkg_ns()` helper.~~
- ~~Added `call_name` private method to `DataType` class to store the string name used in the code call. Refactored `code()` public method to use `call_name`.~~
- Converted all `$code() call(...)` to `$code(namespace = FALSE) call2(..., .ns = if(namespace) "arrow")` in `DataType`, `Schema`, and `DictionaryType`.
- Added `code` to `Schema` docstring.
- Updated `expect_code_roundtrip` to test roundtrip with and without namespace, and check match/no match for `arrow::` depending on namespace argument.

### Are these changes tested?
* All tests pass, including lintr checks.

### Are there any user-facing changes?
Yes, user-facing changes, but no breaking changes to any public APIs.
* Closes: #38033

Lead-authored-by: orgadish <48453207+orgadish@users.noreply.github.com>
Co-authored-by: Nic Crane <thisisnic@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/dictionary.R                    |  8 ++--
 r/R/schema.R                        |  8 ++--
 r/R/type.R                          | 62 +++++++++++++++--------------
 r/man/DataType-class.Rd             |  2 +-
 r/man/Schema-class.Rd               |  1 +
 r/tests/testthat/helper-roundtrip.R | 10 ++++-
 6 files changed, 52 insertions(+), 39 deletions(-)

diff --git a/r/R/dictionary.R b/r/R/dictionary.R
index df94ada035e14..d42a10ad596c7 100644
--- a/r/R/dictionary.R
+++ b/r/R/dictionary.R
@@ -35,18 +35,18 @@ DictionaryType <- R6Class("DictionaryType",
     ToString = function() {
       prettier_dictionary_type(DataType__ToString(self))
     },
-    code = function() {
+    code = function(namespace = FALSE) {
       details <- list()
       if (self$index_type != int32()) {
-        details$index_type <- self$index_type$code()
+        details$index_type <- self$index_type$code(namespace)
       }
       if (self$value_type != utf8()) {
-        details$value_type <- self$value_type$code()
+        details$value_type <- self$value_type$code(namespace)
       }
       if (isTRUE(self$ordered)) {
         details$ordered <- TRUE
       }
-      call2("dictionary", !!!details)
+      call2("dictionary", !!!details, .ns = if (namespace) "arrow")
     }
   ),
   active = list(
diff --git a/r/R/schema.R b/r/R/schema.R
index ac0604b2b345c..75623668d9621 100644
--- a/r/R/schema.R
+++ b/r/R/schema.R
@@ -39,6 +39,7 @@
 #' - `$WithMetadata(metadata)`: returns a new `Schema` with the key-value
 #'    `metadata` set. Note that all list elements in `metadata` will be coerced
 #'    to `character`.
+#' - `$code(namespace)`: returns the R code needed to generate this schema. Use `namespace=TRUE` to call with `arrow::`.
 #'
 #' @section Active bindings:
 #'
@@ -107,14 +108,13 @@ Schema <- R6Class("Schema",
       inherits(other, "Schema") && Schema__Equals(self, other, isTRUE(check_metadata))
     },
     export_to_c = function(ptr) ExportSchema(self, ptr),
-    code = function() {
+    code = function(namespace = FALSE) {
       names <- self$names
       codes <- map2(names, self$fields, function(name, field) {
-        field$type$code()
+        field$type$code(namespace)
       })
       codes <- set_names(codes, names)
-
-      call2("schema", !!!codes)
+      call2("schema", !!!codes, .ns = if (namespace) "arrow")
     },
     WithNames = function(names) {
       if (!inherits(names, "character")) {
diff --git a/r/R/type.R b/r/R/type.R
index 58d3267243220..d6db6f146edcd 100644
--- a/r/R/type.R
+++ b/r/R/type.R
@@ -27,7 +27,7 @@
 #' - `$ToString()`: String representation of the DataType
 #' - `$Equals(other)`: Is the DataType equal to `other`
 #' - `$fields()`: The children fields associated with this type
-#' - `$code()`: Produces an R call of the data type.
+#' - `$code(namespace)`: Produces an R call of the data type. Use `namespace=TRUE` to call with `arrow::`.
 #'
 #' There are also some active bindings:
 #' - `$id`: integer Arrow type id.
@@ -51,7 +51,7 @@ DataType <- R6Class("DataType",
       DataType__fields(self)
     },
     export_to_c = function(ptr) ExportType(self, ptr),
-    code = function() call("stop", paste0("Unsupported type: <", self$ToString(), ">."))
+    code = function(namespace = FALSE) call("stop", paste0("Unsupported type: <", self$ToString(), ">."))
   ),
   active = list(
     id = function() DataType__id(self),
@@ -158,7 +158,7 @@ infer_type.Expression <- function(x, ...) x$type()
 FixedWidthType <- R6Class("FixedWidthType",
   inherit = DataType,
   public = list(
-    code = function() call(tolower(self$name))
+    code = function(namespace = FALSE) call2(tolower(self$name), .ns = if (namespace) "arrow")
   ),
   active = list(
     bit_width = function() FixedWidthType__bit_width(self)
@@ -178,45 +178,47 @@ Float32 <- R6Class("Float32", inherit = FixedWidthType)
 Float64 <- R6Class("Float64",
   inherit = FixedWidthType,
   public = list(
-    code = function() call("float64")
+    code = function(namespace = FALSE) call2("float64", .ns = if (namespace) "arrow")
   )
 )
 Boolean <- R6Class("Boolean", inherit = FixedWidthType)
 Utf8 <- R6Class("Utf8",
   inherit = DataType,
   public = list(
-    code = function() call("utf8")
+    code = function(namespace = FALSE) call2("utf8", .ns = if (namespace) "arrow")
   )
 )
 LargeUtf8 <- R6Class("LargeUtf8",
   inherit = DataType,
   public = list(
-    code = function() call("large_utf8")
+    code = function(namespace = FALSE) call2("large_utf8", .ns = if (namespace) "arrow")
   )
 )
 Binary <- R6Class("Binary",
   inherit = DataType,
   public = list(
-    code = function() call("binary")
+    code = function(namespace = FALSE) call2("binary", .ns = if (namespace) "arrow")
   )
 )
 LargeBinary <- R6Class("LargeBinary",
   inherit = DataType, public = list(
-    code = function() call("large_binary")
+    code = function(namespace = FALSE) call2("large_binary", .ns = if (namespace) "arrow")
   )
 )
 FixedSizeBinary <- R6Class("FixedSizeBinary",
   inherit = FixedWidthType,
   public = list(
     byte_width = function() FixedSizeBinary__byte_width(self),
-    code = function() call2("fixed_size_binary", byte_width = self$byte_width())
+    code = function(namespace = FALSE) {
+      call2("fixed_size_binary", byte_width = self$byte_width(), .ns = if (namespace) "arrow")
+    }
   )
 )
 
 DateType <- R6Class("DateType",
   inherit = FixedWidthType,
   public = list(
-    code = function() call2(tolower(self$name)),
+    code = function(namespace = FALSE) call2(tolower(self$name), .ns = if (namespace) "arrow"),
     unit = function() DateType__unit(self)
   )
 )
@@ -232,26 +234,26 @@ TimeType <- R6Class("TimeType",
 Time32 <- R6Class("Time32",
   inherit = TimeType,
   public = list(
-    code = function() {
+    code = function(namespace = FALSE) {
       unit <- if (self$unit() == TimeUnit$MILLI) {
         "ms"
       } else {
         "s"
       }
-      call2("time32", unit = unit)
+      call2("time32", unit = unit, .ns = if (namespace) "arrow")
     }
   )
 )
 Time64 <- R6Class("Time64",
   inherit = TimeType,
   public = list(
-    code = function() {
+    code = function(namespace = FALSE) {
       unit <- if (self$unit() == TimeUnit$NANO) {
         "ns"
       } else {
         "us"
       }
-      call2("time64", unit = unit)
+      call2("time64", unit = unit, .ns = if (namespace) "arrow")
     }
   )
 )
@@ -266,20 +268,20 @@ DurationType <- R6Class("DurationType",
 Null <- R6Class("Null",
   inherit = DataType,
   public = list(
-    code = function() call("null")
+    code = function(namespace = FALSE) call2("null", .ns = if (namespace) "arrow")
   )
 )
 
 Timestamp <- R6Class("Timestamp",
   inherit = FixedWidthType,
   public = list(
-    code = function() {
+    code = function(namespace = FALSE) {
       unit <- c("s", "ms", "us", "ns")[self$unit() + 1L]
       tz <- self$timezone()
       if (identical(tz, "")) {
-        call2("timestamp", unit = unit)
+        call2("timestamp", unit = unit, .ns = if (namespace) "arrow")
       } else {
-        call2("timestamp", unit = unit, timezone = tz)
+        call2("timestamp", unit = unit, timezone = tz, .ns = if (namespace) "arrow")
       }
     },
     timezone = function() TimestampType__timezone(self),
@@ -290,8 +292,8 @@ Timestamp <- R6Class("Timestamp",
 DecimalType <- R6Class("DecimalType",
   inherit = FixedWidthType,
   public = list(
-    code = function() {
-      call2("decimal", precision = self$precision(), scale = self$scale())
+    code = function(namespace = FALSE) {
+      call2("decimal", precision = self$precision(), scale = self$scale(), .ns = if (namespace) "arrow")
     },
     precision = function() DecimalType__precision(self),
     scale = function() DecimalType__scale(self)
@@ -624,13 +626,13 @@ check_decimal_args <- function(precision, scale) {
 StructType <- R6Class("StructType",
   inherit = NestedType,
   public = list(
-    code = function() {
+    code = function(namespace = FALSE) {
       field_names <- StructType__field_names(self)
       codes <- map(field_names, function(name) {
-        self$GetFieldByName(name)$type$code()
+        self$GetFieldByName(name)$type$code(namespace)
       })
       codes <- set_names(codes, field_names)
-      call2("struct", !!!codes)
+      call2("struct", !!!codes, .ns = if (namespace) "arrow")
     },
     GetFieldByName = function(name) StructType__GetFieldByName(self, name),
     GetFieldIndex = function(name) StructType__GetFieldIndex(self, name)
@@ -648,8 +650,8 @@ names.StructType <- function(x) StructType__field_names(x)
 ListType <- R6Class("ListType",
   inherit = NestedType,
   public = list(
-    code = function() {
-      call("list_of", self$value_type$code())
+    code = function(namespace = FALSE) {
+      call2("list_of", self$value_type$code(namespace), .ns = if (namespace) "arrow")
     }
   ),
   active = list(
@@ -665,8 +667,8 @@ list_of <- function(type) list__(type)
 LargeListType <- R6Class("LargeListType",
   inherit = NestedType,
   public = list(
-    code = function() {
-      call2("large_list_of", self$value_type$code())
+    code = function(namespace = FALSE) {
+      call2("large_list_of", self$value_type$code(namespace), .ns = if (namespace) "arrow")
     }
   ),
   active = list(
@@ -684,8 +686,10 @@ large_list_of <- function(type) large_list__(type)
 FixedSizeListType <- R6Class("FixedSizeListType",
   inherit = NestedType,
   public = list(
-    code = function() {
-      call2("fixed_size_list_of", self$value_type$code(), list_size = self$list_size)
+    code = function(namespace = FALSE) {
+      call2("fixed_size_list_of", self$value_type$code(namespace),
+        list_size = self$list_size, .ns = if (namespace) "arrow"
+      )
     }
   ),
   active = list(
diff --git a/r/man/DataType-class.Rd b/r/man/DataType-class.Rd
index 4f95578133bd1..5c17c072f92b5 100644
--- a/r/man/DataType-class.Rd
+++ b/r/man/DataType-class.Rd
@@ -13,7 +13,7 @@ DataType class
 \item \verb{$ToString()}: String representation of the DataType
 \item \verb{$Equals(other)}: Is the DataType equal to \code{other}
 \item \verb{$fields()}: The children fields associated with this type
-\item \verb{$code()}: Produces an R call of the data type.
+\item \verb{$code(namespace)}: Produces an R call of the data type. Use \code{namespace=TRUE} to call with \verb{arrow::}.
 }
 
 There are also some active bindings:
diff --git a/r/man/Schema-class.Rd b/r/man/Schema-class.Rd
index 32250cdfe7d05..ecd216af07d78 100644
--- a/r/man/Schema-class.Rd
+++ b/r/man/Schema-class.Rd
@@ -24,6 +24,7 @@ Many Arrow objects, including \link{Table} and \link{Dataset}, have a \verb{$sch
 \item \verb{$WithMetadata(metadata)}: returns a new \code{Schema} with the key-value
 \code{metadata} set. Note that all list elements in \code{metadata} will be coerced
 to \code{character}.
+\item \verb{$code(namespace)}: returns the R code needed to generate this schema. Use \code{namespace=TRUE} to call with \verb{arrow::}.
 }
 }
 
diff --git a/r/tests/testthat/helper-roundtrip.R b/r/tests/testthat/helper-roundtrip.R
index d6b965ca6597d..449a30dd9dbf1 100644
--- a/r/tests/testthat/helper-roundtrip.R
+++ b/r/tests/testthat/helper-roundtrip.R
@@ -44,5 +44,13 @@ expect_array_roundtrip <- function(x, type, as = NULL) {
 }
 
 expect_code_roundtrip <- function(x) {
-  expect_equal(eval(x$code()), x)
+  code <- x$code()
+  code_with_ns <- x$code(namespace = TRUE)
+
+  pkg_prefix_pattern <- "^arrow[:][:]"
+  expect_no_match(as.character(code), pkg_prefix_pattern)
+  expect_match(as.character(code_with_ns)[1], pkg_prefix_pattern)
+
+  expect_equal(eval(code), x)
+  expect_equal(eval(code_with_ns), x)
 }

From 717a851b1bd9a79ec8923b0d82ad85caa45b7d49 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 20 Oct 2023 10:46:12 +0900
Subject: [PATCH 593/749] GH-38363: [Release][CI] Omit tests for
 main/maintenance branches on RC branch (#38365)

### Rationale for this change

Tests of deb package names for the following patterns are only for main/maintenance branches:

* `dev/release/post-11-bump-versions.sh 14.1.0 15.0.0` (minor release -> major release)
* `dev/release/post-11-bump-versions.sh 14.0.1 15.0.0` (patch release -> major release)

### What changes are included in this PR?

Omit these patterns.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38363

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/post-11-bump-versions-test.rb | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/dev/release/post-11-bump-versions-test.rb b/dev/release/post-11-bump-versions-test.rb
index a017d2d70a167..4b6933d6102a9 100644
--- a/dev/release/post-11-bump-versions-test.rb
+++ b/dev/release/post-11-bump-versions-test.rb
@@ -54,12 +54,12 @@ def bump_versions(*targets)
     end
     env = env.merge(additional_env)
     case bump_type
-    when :minor_on_main, :patch_on_main
+    when :minor, :patch
       previous_version_components = @previous_version.split(".")
       case bump_type
-      when :minor_on_main
+      when :minor
         previous_version_components[1].succ!
-      when :patch_on_main
+      when :patch
         previous_version_components[2].succ!
       end
       sh(env,
@@ -323,8 +323,9 @@ def test_version_post_tag
                  "Output:\n#{stdout}")
   end
 
-  data(:bump_type, [nil, :minor_on_main, :patch_on_main])
+  data(:bump_type, [nil, :minor, :patch])
   def test_deb_package_names
+    omit_on_release_branch unless bump_type.nil?
     current_commit = git_current_commit
     stdout = bump_versions("DEB_PACKAGE_NAMES")
     changes = parse_patch(git("log", "-p", "#{current_commit}.."))

From 394966b22b54bdde62ea6dfb83bc97223a63d3fb Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 20 Oct 2023 17:48:21 +0900
Subject: [PATCH 594/749] GH-38345: [Release] Use local test data for
 verification if possible (#38362)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

We have external test data repositories, apache/arrow-testing and apache/parquet-testing. We use them as submodule. apache/arrow may not use the latest test data repositories. But our verification script always use the latest test data repositories. It may cause test failures.

### What changes are included in this PR?

Use local test data if they exist.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38345

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/release/verify-release-candidate.sh | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 0c6ac075b636e..287c557fb5ef4 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -959,12 +959,26 @@ ensure_source_directory() {
     fi
   fi
 
-  # Ensure that the testing repositories are cloned
-  if [ ! -d "${ARROW_SOURCE_DIR}/testing/data" ]; then
-    git clone https://github.com/apache/arrow-testing.git ${ARROW_SOURCE_DIR}/testing
+  # Ensure that the testing repositories are prepared
+  if [ ! -d ${ARROW_SOURCE_DIR}/testing/data ]; then
+    if [ -d ${SOURCE_DIR}/../../testing/data ]; then
+      cp -a ${SOURCE_DIR}/../../testing/ ${ARROW_SOURCE_DIR}/
+    else
+      git clone \
+        https://github.com/apache/arrow-testing.git \
+        ${ARROW_SOURCE_DIR}/testing
+    fi
   fi
-  if [ ! -d "${ARROW_SOURCE_DIR}/cpp/submodules/parquet-testing/data" ]; then
-    git clone https://github.com/apache/parquet-testing.git ${ARROW_SOURCE_DIR}/cpp/submodules/parquet-testing
+  if [ ! -d ${ARROW_SOURCE_DIR}/cpp/submodules/parquet-testing/data ]; then
+    if [ -d ${SOURCE_DIR}/../../cpp/submodules/parquet-testing/data ]; then
+      cp -a \
+         ${SOURCE_DIR}/../../cpp/submodules/parquet-testing/ \
+         ${ARROW_SOURCE_DIR}/cpp/submodules/
+    else
+      git clone \
+        https://github.com/apache/parquet-testing.git \
+        ${ARROW_SOURCE_DIR}/cpp/submodules/parquet-testing
+    fi
   fi
 
   export ARROW_TEST_DATA=$ARROW_SOURCE_DIR/testing/data

From cda7ffc67abf6c8b9170cc2606acf1a704b161eb Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 20 Oct 2023 07:17:35 -0700
Subject: [PATCH 595/749] GH-38268: [Java] Disable flaky TestFlightSqlStreams
 (#38319)

### Rationale for this change
The TestFlightSqlStreams test is failing sporadically in CI.

### What changes are included in this PR?
Disables the tests for now.

### Are these changes tested?
N/A

### Are there any user-facing changes?
No.

* Closes: #38268

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../java/org/apache/arrow/flight/TestFlightSqlStreams.java  | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
index 4672e0a141832..11d00742fd243 100644
--- a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
@@ -46,6 +46,7 @@
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.ImmutableList;
@@ -211,6 +212,7 @@ public static void tearDown() throws Exception {
     close(sqlClient, server, allocator);
   }
 
+  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTablesResultNoSchema() throws Exception {
     try (final FlightStream stream =
@@ -230,6 +232,7 @@ public void testGetTablesResultNoSchema() throws Exception {
     }
   }
 
+  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTableTypesResult() throws Exception {
     try (final FlightStream stream =
@@ -248,6 +251,7 @@ public void testGetTableTypesResult() throws Exception {
     }
   }
 
+  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetSqlInfoResults() throws Exception {
     final FlightInfo info = sqlClient.getSqlInfo();
@@ -259,6 +263,7 @@ public void testGetSqlInfoResults() throws Exception {
     }
   }
 
+  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTypeInfo() throws Exception {
     FlightInfo flightInfo = sqlClient.getXdbcTypeInfo();
@@ -275,6 +280,7 @@ public void testGetTypeInfo() throws Exception {
     }
   }
 
+  @Disabled("Memory leak GH-38268")
   @Test
   public void testExecuteQuery() throws Exception {
     try (final FlightStream stream = sqlClient

From 110fb968be76618e831089978eaa377c6ba8862b Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 20 Oct 2023 07:35:29 -0700
Subject: [PATCH 596/749] GH-37943: [Java] Add parquet file with all supported
 types (#38249)

### Rationale for this change
Validate the types the Dataset APIs support when generating Parquet files.

### What changes are included in this PR?
Add a reference file with all supported types and corresponding test case to validate that the Dataset API generates this consistently.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.
* Closes: #37943

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/dataset/pom.xml                          |   7 +
 .../apache/arrow/dataset/TestAllTypes.java    | 262 ++++++++++++++++++
 .../org/apache/arrow/dataset/TestDataset.java |  41 +++
 .../dataset/file/TestDatasetFileWriter.java   |  41 ---
 .../apache/arrow/flight/FlightTestUtil.java   |  17 +-
 .../apache/arrow/util/ArrowTestDataUtil.java  |  43 +++
 testing                                       |   2 +-
 7 files changed, 356 insertions(+), 57 deletions(-)
 create mode 100644 java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
 create mode 100644 java/vector/src/test/java/org/apache/arrow/util/ArrowTestDataUtil.java

diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index 055fa1cabd4d9..e971a918e4a9d 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -74,6 +74,13 @@
             <version>${parquet.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.arrow</groupId>
+            <artifactId>arrow-vector</artifactId>
+            <version>${project.version}</version>
+            <scope>test</scope>
+            <classifier>tests</classifier>
+        </dependency>
         <dependency>
             <groupId>org.apache.hadoop</groupId>
             <artifactId>hadoop-common</artifactId>
diff --git a/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java b/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
new file mode 100644
index 0000000000000..d0163bec3674c
--- /dev/null
+++ b/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
@@ -0,0 +1,262 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.dataset;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.nio.channels.Channels;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.channels.WritableByteChannel;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import org.apache.arrow.dataset.file.DatasetFileWriter;
+import org.apache.arrow.dataset.file.FileFormat;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.util.ArrowTestDataUtil;
+import org.apache.arrow.vector.BigIntVector;
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.DateMilliVector;
+import org.apache.arrow.vector.Decimal256Vector;
+import org.apache.arrow.vector.DecimalVector;
+import org.apache.arrow.vector.DurationVector;
+import org.apache.arrow.vector.FixedSizeBinaryVector;
+import org.apache.arrow.vector.Float4Vector;
+import org.apache.arrow.vector.Float8Vector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.LargeVarCharVector;
+import org.apache.arrow.vector.SmallIntVector;
+import org.apache.arrow.vector.TimeMilliVector;
+import org.apache.arrow.vector.TimeNanoVector;
+import org.apache.arrow.vector.TimeStampMilliTZVector;
+import org.apache.arrow.vector.TimeStampMilliVector;
+import org.apache.arrow.vector.TimeStampNanoTZVector;
+import org.apache.arrow.vector.TimeStampNanoVector;
+import org.apache.arrow.vector.TinyIntVector;
+import org.apache.arrow.vector.UInt1Vector;
+import org.apache.arrow.vector.UInt2Vector;
+import org.apache.arrow.vector.UInt4Vector;
+import org.apache.arrow.vector.UInt8Vector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.complex.FixedSizeListVector;
+import org.apache.arrow.vector.complex.LargeListVector;
+import org.apache.arrow.vector.complex.ListVector;
+import org.apache.arrow.vector.complex.StructVector;
+import org.apache.arrow.vector.complex.impl.UnionFixedSizeListWriter;
+import org.apache.arrow.vector.complex.impl.UnionLargeListWriter;
+import org.apache.arrow.vector.complex.impl.UnionListWriter;
+import org.apache.arrow.vector.ipc.ArrowStreamReader;
+import org.apache.arrow.vector.ipc.ArrowStreamWriter;
+import org.apache.arrow.vector.types.DateUnit;
+import org.apache.arrow.vector.types.FloatingPointPrecision;
+import org.apache.arrow.vector.types.TimeUnit;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.arrow.vector.util.ByteArrayReadableSeekableByteChannel;
+import org.apache.arrow.vector.util.Text;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class TestAllTypes extends TestDataset {
+
+  @ClassRule
+  public static final TemporaryFolder TMP = new TemporaryFolder();
+
+  private VectorSchemaRoot generateAllTypesVector(BufferAllocator allocator) {
+    // Notes:
+    // - Float16 is not supported by Java.
+    // - IntervalMonthDayNano is not supported by Parquet.
+    // - Map (GH-38250) and SparseUnion are resulting in serialization errors when writing with the Dataset API.
+    // "Unhandled type for Arrow to Parquet schema conversion" errors: IntervalDay, IntervalYear, DenseUnion
+    List<Field> childFields = new ArrayList<>();
+    childFields.add(new Field("int-child",
+        new FieldType(false, new ArrowType.Int(32, true), null, null), null));
+    Field structField = new Field("struct",
+        new FieldType(true, ArrowType.Struct.INSTANCE, null, null), childFields);
+    List<Field> fields = List.of(
+        Field.nullablePrimitive("null", ArrowType.Null.INSTANCE),
+        Field.nullablePrimitive("bool", ArrowType.Bool.INSTANCE),
+        Field.nullablePrimitive("int8", new ArrowType.Int(8, true)),
+        Field.nullablePrimitive("int16", new ArrowType.Int(16, true)),
+        Field.nullablePrimitive("int32", new ArrowType.Int(32, true)),
+        Field.nullablePrimitive("int64", new ArrowType.Int(64, true)),
+        Field.nullablePrimitive("uint8", new ArrowType.Int(8, false)),
+        Field.nullablePrimitive("uint16", new ArrowType.Int(16, false)),
+        Field.nullablePrimitive("uint32", new ArrowType.Int(32, false)),
+        Field.nullablePrimitive("uint64", new ArrowType.Int(64, false)),
+        Field.nullablePrimitive("float32", new ArrowType.FloatingPoint(FloatingPointPrecision.SINGLE)),
+        Field.nullablePrimitive("float64", new ArrowType.FloatingPoint(FloatingPointPrecision.DOUBLE)),
+        Field.nullablePrimitive("utf8", ArrowType.Utf8.INSTANCE),
+        Field.nullablePrimitive("binary", ArrowType.Binary.INSTANCE),
+        Field.nullablePrimitive("largeutf8", ArrowType.LargeUtf8.INSTANCE),
+        Field.nullablePrimitive("largebinary", ArrowType.LargeBinary.INSTANCE),
+        Field.nullablePrimitive("fixed_size_binary", new ArrowType.FixedSizeBinary(1)),
+        Field.nullablePrimitive("date_ms", new ArrowType.Date(DateUnit.MILLISECOND)),
+        Field.nullablePrimitive("time_ms", new ArrowType.Time(TimeUnit.MILLISECOND, 32)),
+        Field.nullablePrimitive("timestamp_ms", new ArrowType.Timestamp(TimeUnit.MILLISECOND, null)),
+        Field.nullablePrimitive("timestamptz_ms", new ArrowType.Timestamp(TimeUnit.MILLISECOND, "UTC")),
+        Field.nullablePrimitive("time_ns", new ArrowType.Time(TimeUnit.NANOSECOND, 64)),
+        Field.nullablePrimitive("timestamp_ns", new ArrowType.Timestamp(TimeUnit.NANOSECOND, null)),
+        Field.nullablePrimitive("timestamptz_ns", new ArrowType.Timestamp(TimeUnit.NANOSECOND, "UTC")),
+        Field.nullablePrimitive("duration", new ArrowType.Duration(TimeUnit.MILLISECOND)),
+        Field.nullablePrimitive("decimal128", new ArrowType.Decimal(10, 2, 128)),
+        Field.nullablePrimitive("decimal256", new ArrowType.Decimal(10, 2, 256)),
+        new Field("list", FieldType.nullable(ArrowType.List.INSTANCE),
+            Collections.singletonList(Field.nullable("items", new ArrowType.Int(32, true)))),
+        new Field("largelist", FieldType.nullable(ArrowType.LargeList.INSTANCE),
+            Collections.singletonList(Field.nullable("items", new ArrowType.Int(32, true)))),
+        new Field("fixedsizelist", FieldType.nullable(new ArrowType.FixedSizeList(2)),
+            Collections.singletonList(Field.nullable("items", new ArrowType.Int(32, true)))),
+        structField
+    );
+    VectorSchemaRoot root = VectorSchemaRoot.create(new Schema(fields), allocator);
+    root.allocateNew();
+    root.setRowCount(2);
+
+    root.getVector("null").setNull(0);
+    root.getVector("bool").setNull(0);
+    root.getVector("int8").setNull(0);
+    root.getVector("int16").setNull(0);
+    root.getVector("int32").setNull(0);
+    root.getVector("int64").setNull(0);
+    root.getVector("uint8").setNull(0);
+    root.getVector("uint16").setNull(0);
+    root.getVector("uint32").setNull(0);
+    root.getVector("uint64").setNull(0);
+    root.getVector("float32").setNull(0);
+    root.getVector("float64").setNull(0);
+    root.getVector("utf8").setNull(0);
+    root.getVector("binary").setNull(0);
+    root.getVector("largeutf8").setNull(0);
+    root.getVector("largebinary").setNull(0);
+    root.getVector("fixed_size_binary").setNull(0);
+    root.getVector("date_ms").setNull(0);
+    root.getVector("time_ms").setNull(0);
+    root.getVector("time_ns").setNull(0);
+    root.getVector("timestamp_ms").setNull(0);
+    root.getVector("timestamp_ns").setNull(0);
+    root.getVector("timestamptz_ms").setNull(0);
+    root.getVector("timestamptz_ns").setNull(0);
+    root.getVector("duration").setNull(0);
+    root.getVector("decimal128").setNull(0);
+    root.getVector("decimal256").setNull(0);
+    root.getVector("fixedsizelist").setNull(0);
+    root.getVector("list").setNull(0);
+    root.getVector("largelist").setNull(0);
+    root.getVector("struct").setNull(0);
+
+    root.getVector("null").setNull(1);
+    ((BitVector) root.getVector("bool")).set(1, 1);
+    ((TinyIntVector) root.getVector("int8")).set(1, 1);
+    ((SmallIntVector) root.getVector("int16")).set(1, 1);
+    ((IntVector) root.getVector("int32")).set(1, 1);
+    ((BigIntVector) root.getVector("int64")).set(1, 1);
+    ((UInt1Vector) root.getVector("uint8")).set(1, 1);
+    ((UInt2Vector) root.getVector("uint16")).set(1, 1);
+    ((UInt4Vector) root.getVector("uint32")).set(1, 1);
+    ((UInt8Vector) root.getVector("uint64")).set(1, 1);
+    ((Float4Vector) root.getVector("float32")).set(1, 1.0f);
+    ((Float8Vector) root.getVector("float64")).set(1, 1.0);
+    ((VarCharVector) root.getVector("utf8")).set(1, new Text("a"));
+    ((VarBinaryVector) root.getVector("binary")).set(1, new byte[] {0x01});
+    ((LargeVarCharVector) root.getVector("largeutf8")).set(1, new Text("a"));
+    ((LargeVarBinaryVector) root.getVector("largebinary")).set(1, new byte[] {0x01});
+    ((FixedSizeBinaryVector) root.getVector("fixed_size_binary")).set(1, new byte[] {0x01});
+    ((DateMilliVector) root.getVector("date_ms")).set(1, 0);
+    ((TimeMilliVector) root.getVector("time_ms")).set(1, 0);
+    ((TimeNanoVector) root.getVector("time_ns")).set(1, 0);
+    ((TimeStampMilliVector) root.getVector("timestamp_ms")).set(1, 0);
+    ((TimeStampNanoVector) root.getVector("timestamp_ns")).set(1, 0);
+    ((TimeStampMilliTZVector) root.getVector("timestamptz_ms")).set(1, 0);
+    ((TimeStampNanoTZVector) root.getVector("timestamptz_ns")).set(1, 0);
+    ((DurationVector) root.getVector("duration")).set(1, 0);
+    ((DecimalVector) root.getVector("decimal128")).set(1, 0);
+    ((Decimal256Vector) root.getVector("decimal256")).set(1, 0);
+    UnionFixedSizeListWriter fixedListWriter = ((FixedSizeListVector) root.getVector("fixedsizelist")).getWriter();
+    fixedListWriter.allocate();
+    fixedListWriter.setPosition(1);
+    fixedListWriter.startList();
+    fixedListWriter.integer().writeInt(1);
+    fixedListWriter.endList();
+
+    UnionListWriter listWriter = ((ListVector) root.getVector("list")).getWriter();
+    listWriter.allocate();
+    listWriter.setPosition(1);
+    listWriter.startList();
+    listWriter.integer().writeInt(1);
+    listWriter.endList();
+
+    UnionLargeListWriter largeListWriter = ((LargeListVector) root.getVector("largelist")).getWriter();
+    largeListWriter.allocate();
+    largeListWriter.setPosition(1);
+    largeListWriter.startList();
+    largeListWriter.integer().writeInt(1);
+    largeListWriter.endList();
+
+    ((StructVector) root.getVector("struct")).getChild("int-child", IntVector.class).set(1, 1);
+    return root;
+  }
+
+  private byte[] serializeFile(VectorSchemaRoot root) {
+    try (
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        WritableByteChannel channel = Channels.newChannel(out);
+        ArrowStreamWriter writer = new ArrowStreamWriter(root, null, channel)
+    ) {
+      writer.start();
+      writer.writeBatch();
+      writer.end();
+      return out.toByteArray();
+    } catch (IOException e) {
+      throw new IllegalArgumentException("Failed to serialize arrow file", e);
+    }
+  }
+
+  @Test
+  public void testAllTypesParquet() throws Exception {
+    try (VectorSchemaRoot root = generateAllTypesVector(rootAllocator())) {
+      byte[] featherData = serializeFile(root);
+      try (SeekableByteChannel channel = new ByteArrayReadableSeekableByteChannel(featherData)) {
+        try (ArrowStreamReader reader = new ArrowStreamReader(channel, rootAllocator())) {
+          TMP.create();
+          final File writtenFolder = TMP.newFolder();
+          final String writtenParquet = writtenFolder.toURI().toString();
+          DatasetFileWriter.write(rootAllocator(), reader, FileFormat.PARQUET,
+              writtenParquet);
+
+          // Load the reference file from the test resources and write to a temporary file on the OS.
+          String referenceFile = ArrowTestDataUtil.getTestDataRoot()
+              .resolve("parquet")
+              .resolve("alltypes-java.parquet")
+              .toUri().toString();
+          assertParquetFileEquals(referenceFile,
+              Objects.requireNonNull(writtenFolder.listFiles())[0].toURI().toString());
+        }
+      }
+    }
+  }
+}
diff --git a/java/dataset/src/test/java/org/apache/arrow/dataset/TestDataset.java b/java/dataset/src/test/java/org/apache/arrow/dataset/TestDataset.java
index af2abeee2145f..cafa63b7880ce 100644
--- a/java/dataset/src/test/java/org/apache/arrow/dataset/TestDataset.java
+++ b/java/dataset/src/test/java/org/apache/arrow/dataset/TestDataset.java
@@ -27,6 +27,9 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+import org.apache.arrow.dataset.file.FileFormat;
+import org.apache.arrow.dataset.file.FileSystemDatasetFactory;
+import org.apache.arrow.dataset.jni.NativeMemoryPool;
 import org.apache.arrow.dataset.scanner.ScanOptions;
 import org.apache.arrow.dataset.scanner.Scanner;
 import org.apache.arrow.dataset.source.Dataset;
@@ -34,12 +37,16 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.util.AutoCloseables;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.VectorLoader;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.VectorUnloader;
+import org.apache.arrow.vector.compare.VectorEqualsVisitor;
 import org.apache.arrow.vector.ipc.ArrowReader;
 import org.apache.arrow.vector.ipc.message.ArrowRecordBatch;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 
 
@@ -100,6 +107,40 @@ protected Schema inferResultSchemaFromFactory(DatasetFactory factory, ScanOption
     return schema;
   }
 
+  protected void assertParquetFileEquals(String expectedURI, String actualURI) throws Exception {
+    final FileSystemDatasetFactory expectedFactory = new FileSystemDatasetFactory(
+        rootAllocator(), NativeMemoryPool.getDefault(), FileFormat.PARQUET, expectedURI);
+    final FileSystemDatasetFactory actualFactory = new FileSystemDatasetFactory(
+        rootAllocator(), NativeMemoryPool.getDefault(), FileFormat.PARQUET, actualURI);
+    List<ArrowRecordBatch> expectedBatches = collectResultFromFactory(expectedFactory,
+        new ScanOptions(new String[0], 100));
+    List<ArrowRecordBatch> actualBatches = collectResultFromFactory(actualFactory,
+        new ScanOptions(new String[0], 100));
+    try (
+        VectorSchemaRoot expectVsr = VectorSchemaRoot.create(expectedFactory.inspect(), rootAllocator());
+        VectorSchemaRoot actualVsr = VectorSchemaRoot.create(actualFactory.inspect(), rootAllocator())) {
+
+      // fast-fail by comparing metadata
+      Assert.assertEquals(expectedBatches.toString(), actualBatches.toString());
+      // compare ArrowRecordBatches
+      Assert.assertEquals(expectedBatches.size(), actualBatches.size());
+      VectorLoader expectLoader = new VectorLoader(expectVsr);
+      VectorLoader actualLoader = new VectorLoader(actualVsr);
+      for (int i = 0; i < expectedBatches.size(); i++) {
+        expectLoader.load(expectedBatches.get(i));
+        actualLoader.load(actualBatches.get(i));
+        for (int j = 0; j < expectVsr.getFieldVectors().size(); j++) {
+          FieldVector vector = expectVsr.getFieldVectors().get(i);
+          FieldVector otherVector = actualVsr.getFieldVectors().get(i);
+          // TODO: ARROW-18140 Use VectorSchemaRoot#equals() method to compare
+          Assert.assertTrue(VectorEqualsVisitor.vectorEquals(vector, otherVector));
+        }
+      }
+    } finally {
+      AutoCloseables.close(expectedBatches, actualBatches);
+    }
+  }
+
   protected <T> Stream<T> stream(Iterable<T> iterable) {
     return StreamSupport.stream(iterable.spliterator(), false);
   }
diff --git a/java/dataset/src/test/java/org/apache/arrow/dataset/file/TestDatasetFileWriter.java b/java/dataset/src/test/java/org/apache/arrow/dataset/file/TestDatasetFileWriter.java
index 10c06be2cca3b..86797c165b2b1 100644
--- a/java/dataset/src/test/java/org/apache/arrow/dataset/file/TestDatasetFileWriter.java
+++ b/java/dataset/src/test/java/org/apache/arrow/dataset/file/TestDatasetFileWriter.java
@@ -20,7 +20,6 @@
 import java.io.File;
 import java.util.Arrays;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -32,12 +31,6 @@
 import org.apache.arrow.dataset.scanner.ScanOptions;
 import org.apache.arrow.dataset.scanner.Scanner;
 import org.apache.arrow.dataset.source.Dataset;
-import org.apache.arrow.util.AutoCloseables;
-import org.apache.arrow.vector.FieldVector;
-import org.apache.arrow.vector.VectorLoader;
-import org.apache.arrow.vector.VectorSchemaRoot;
-import org.apache.arrow.vector.compare.VectorEqualsVisitor;
-import org.apache.arrow.vector.ipc.message.ArrowRecordBatch;
 import org.apache.commons.io.FileUtils;
 import org.junit.Assert;
 import org.junit.ClassRule;
@@ -99,39 +92,5 @@ public void testParquetWriteWithPartitions() throws Exception {
       Assert.assertEquals(expectedOutputFiles, outputFiles);
     }
   }
-
-  private void assertParquetFileEquals(String expectedURI, String actualURI) throws Exception {
-    final FileSystemDatasetFactory expectedFactory = new FileSystemDatasetFactory(
-        rootAllocator(), NativeMemoryPool.getDefault(), FileFormat.PARQUET, expectedURI);
-    final FileSystemDatasetFactory actualFactory = new FileSystemDatasetFactory(
-        rootAllocator(), NativeMemoryPool.getDefault(), FileFormat.PARQUET, actualURI);
-    List<ArrowRecordBatch> expectedBatches = collectResultFromFactory(expectedFactory,
-        new ScanOptions(new String[0], 100));
-    List<ArrowRecordBatch> actualBatches = collectResultFromFactory(actualFactory,
-        new ScanOptions(new String[0], 100));
-    try (
-        VectorSchemaRoot expectVsr = VectorSchemaRoot.create(expectedFactory.inspect(), rootAllocator());
-        VectorSchemaRoot actualVsr = VectorSchemaRoot.create(actualFactory.inspect(), rootAllocator())) {
-
-      // fast-fail by comparing metadata
-      Assert.assertEquals(expectedBatches.toString(), actualBatches.toString());
-      // compare ArrowRecordBatches
-      Assert.assertEquals(expectedBatches.size(), actualBatches.size());
-      VectorLoader expectLoader = new VectorLoader(expectVsr);
-      VectorLoader actualLoader = new VectorLoader(actualVsr);
-      for (int i = 0; i < expectedBatches.size(); i++) {
-        expectLoader.load(expectedBatches.get(i));
-        actualLoader.load(actualBatches.get(i));
-        for (int j = 0; j < expectVsr.getFieldVectors().size(); j++) {
-          FieldVector vector = expectVsr.getFieldVectors().get(i);
-          FieldVector otherVector = actualVsr.getFieldVectors().get(i);
-          // TODO: ARROW-18140 Use VectorSchemaRoot#equals() method to compare
-          Assert.assertTrue(VectorEqualsVisitor.vectorEquals(vector, otherVector));
-        }
-      }
-    } finally {
-      AutoCloseables.close(expectedBatches, actualBatches);
-    }
-  }
 }
 
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/FlightTestUtil.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/FlightTestUtil.java
index cbb714a967bdd..25d59d99ad7cd 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/FlightTestUtil.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/FlightTestUtil.java
@@ -20,12 +20,11 @@
 import java.io.File;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Objects;
 import java.util.Random;
 
+import org.apache.arrow.util.ArrowTestDataUtil;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.function.Executable;
 
@@ -37,21 +36,9 @@ public class FlightTestUtil {
   private static final Random RANDOM = new Random();
 
   public static final String LOCALHOST = "localhost";
-  public static final String TEST_DATA_ENV_VAR = "ARROW_TEST_DATA";
-  public static final String TEST_DATA_PROPERTY = "arrow.test.dataRoot";
-
-  static Path getTestDataRoot() {
-    String path = System.getenv(TEST_DATA_ENV_VAR);
-    if (path == null) {
-      path = System.getProperty(TEST_DATA_PROPERTY);
-    }
-    return Paths.get(Objects.requireNonNull(path,
-        String.format("Could not find test data path. Set the environment variable %s or the JVM property %s.",
-            TEST_DATA_ENV_VAR, TEST_DATA_PROPERTY)));
-  }
 
   static Path getFlightTestDataRoot() {
-    return getTestDataRoot().resolve("flight");
+    return ArrowTestDataUtil.getTestDataRoot().resolve("flight");
   }
 
   static Path exampleTlsRootCert() {
diff --git a/java/vector/src/test/java/org/apache/arrow/util/ArrowTestDataUtil.java b/java/vector/src/test/java/org/apache/arrow/util/ArrowTestDataUtil.java
new file mode 100644
index 0000000000000..120c0adc884ed
--- /dev/null
+++ b/java/vector/src/test/java/org/apache/arrow/util/ArrowTestDataUtil.java
@@ -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.
+ */
+
+package org.apache.arrow.util;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Objects;
+
+/**
+ * Utility methods and constants for working with the arrow-testing repo.
+ */
+public final class ArrowTestDataUtil {
+  public static final String TEST_DATA_ENV_VAR = "ARROW_TEST_DATA";
+  public static final String TEST_DATA_PROPERTY = "arrow.test.dataRoot";
+
+  public static Path getTestDataRoot() {
+    String path = System.getenv(TEST_DATA_ENV_VAR);
+    if (path == null) {
+      path = System.getProperty(TEST_DATA_PROPERTY);
+    }
+    return Paths.get(Objects.requireNonNull(path,
+        String.format("Could not find test data path. Set the environment variable %s or the JVM property %s.",
+            TEST_DATA_ENV_VAR, TEST_DATA_PROPERTY)));
+  }
+
+  private ArrowTestDataUtil() {
+  }
+}
diff --git a/testing b/testing
index 47f7b56b25683..ad82a736c170e 160000
--- a/testing
+++ b/testing
@@ -1 +1 @@
-Subproject commit 47f7b56b25683202c1fd957668e13f2abafc0f12
+Subproject commit ad82a736c170e97b7c8c035ebd8a801c17eec170

From a376e3c21f60540ed8952b066f9367be99ba145f Mon Sep 17 00:00:00 2001
From: Ivan Chesnov <ivan.chesnov@dremio.com>
Date: Fri, 20 Oct 2023 22:49:58 +0300
Subject: [PATCH 597/749] GH-38246: [JAVA] added new getTransferPair() function
 that takes in a Field type for Complex Type Vectors (#38261)

### Rationale for this change

Additionally, a new function **getTransferPair(Field, Allocator)** is introduced so that a new Field method is not constructed each time getTransferPair is called on the Vector.
Added Field.setChildren() method and made **children** not final - for updating **field** object inside complex vector(it possible that Field will be without children on creation) - optimisation for keeping using already existing Field object.

### What changes are included in this PR?

- `getTransferPair` method for ComplexType Vectors and for BaseVariableWidthVector's

- added `Field.setChildren()` method and made **children** not final - for updating **field** object inside complex vector(it possible that Field will be without children on creation) - optimisation for keeping using already existing Field object.

### Are these changes tested?

Yes, some tests have been added to verify these changes.
### Are there any user-facing changes?

Yes.

**This PR includes breaking changes to public APIs.**

* Closes: #38246

Lead-authored-by: Ivan Chesnov <ivan.chesnov@dremio.com>
Co-authored-by: Ivan Chesnov <xxxlaykxxx@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../codegen/templates/DenseUnionVector.java   | 22 +++++-
 .../main/codegen/templates/UnionVector.java   | 19 ++++-
 .../arrow/vector/BaseFixedWidthVector.java    | 12 +++
 .../vector/BaseLargeVariableWidthVector.java  | 21 ++++++
 .../arrow/vector/BaseVariableWidthVector.java | 20 +++++
 .../arrow/vector/ExtensionTypeVector.java     | 10 +++
 .../arrow/vector/LargeVarBinaryVector.java    |  9 +++
 .../arrow/vector/LargeVarCharVector.java      |  9 +++
 .../org/apache/arrow/vector/NullVector.java   | 12 ++-
 .../org/apache/arrow/vector/ValueVector.java  | 38 ++++++++++
 .../apache/arrow/vector/VarBinaryVector.java  |  9 +++
 .../apache/arrow/vector/VarCharVector.java    |  9 +++
 .../vector/complex/FixedSizeListVector.java   | 51 ++++++++++---
 .../arrow/vector/complex/LargeListVector.java | 43 +++++++++--
 .../arrow/vector/complex/ListVector.java      | 41 +++++++++--
 .../arrow/vector/complex/MapVector.java       | 17 ++++-
 .../complex/NonNullableStructVector.java      | 73 +++++++++++++++----
 .../arrow/vector/complex/StructVector.java    | 54 +++++++++++++-
 .../arrow/vector/TestLargeListVector.java     | 23 ++++++
 .../vector/TestLargeVarBinaryVector.java      | 18 +++++
 .../arrow/vector/TestLargeVarCharVector.java  | 17 +++++
 .../apache/arrow/vector/TestListVector.java   | 21 ++++++
 .../apache/arrow/vector/TestMapVector.java    | 22 ++++++
 .../apache/arrow/vector/TestStructVector.java | 44 +++++++++++
 .../arrow/vector/TestVectorSchemaRoot.java    |  1 +
 25 files changed, 564 insertions(+), 51 deletions(-)

diff --git a/java/vector/src/main/codegen/templates/DenseUnionVector.java b/java/vector/src/main/codegen/templates/DenseUnionVector.java
index fba9302f34221..12fc52af3c18e 100644
--- a/java/vector/src/main/codegen/templates/DenseUnionVector.java
+++ b/java/vector/src/main/codegen/templates/DenseUnionVector.java
@@ -234,8 +234,8 @@ public synchronized byte registerNewTypeId(Field field) {
               typeFields.length + " relative types. Please use union of union instead");
     }
     byte typeId = nextTypeId;
-    if (fieldType != null) {
-      int[] typeIds = ((ArrowType.Union) fieldType.getType()).getTypeIds();
+    if (this.fieldType != null) {
+      int[] typeIds = ((ArrowType.Union) this.fieldType.getType()).getTypeIds();
       if (typeIds != null) {
         int thisTypeId = typeIds[nextTypeId];
         if (thisTypeId > Byte.MAX_VALUE) {
@@ -533,7 +533,7 @@ public Field getField() {
     } else {
       final UnionMode mode = UnionMode.Dense;
       fieldType = new FieldType(this.fieldType.isNullable(), new ArrowType.Union(mode, typeIds),
-              this.fieldType.getDictionary(), this.fieldType.getMetadata());
+          this.fieldType.getDictionary(), this.fieldType.getMetadata());
     }
 
     return new Field(name, fieldType, childFields);
@@ -554,6 +554,16 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return new org.apache.arrow.vector.complex.DenseUnionVector.TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return getTransferPair(field, allocator, null);
+  }
+
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new org.apache.arrow.vector.complex.DenseUnionVector.TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((DenseUnionVector) target);
@@ -598,6 +608,12 @@ public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
       createTransferPairs();
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      to = new DenseUnionVector(field.getName(), allocator, null, callBack);
+      internalStruct.makeTransferPair(to.internalStruct);
+      createTransferPairs();
+    }
+
     public TransferImpl(DenseUnionVector to) {
       this.to = to;
       internalStruct.makeTransferPair(to.internalStruct);
diff --git a/java/vector/src/main/codegen/templates/UnionVector.java b/java/vector/src/main/codegen/templates/UnionVector.java
index 0446faab7a95c..ea79c5c2fba76 100644
--- a/java/vector/src/main/codegen/templates/UnionVector.java
+++ b/java/vector/src/main/codegen/templates/UnionVector.java
@@ -144,8 +144,8 @@ public void initializeChildrenFromFields(List<Field> children) {
     int count = 0;
     for (Field child: children) {
       int typeId = Types.getMinorTypeForArrowType(child.getType()).ordinal();
-      if (fieldType != null) {
-        int[] typeIds = ((ArrowType.Union)fieldType.getType()).getTypeIds();
+      if (this.fieldType != null) {
+        int[] typeIds = ((ArrowType.Union)this.fieldType.getType()).getTypeIds();
         if (typeIds != null) {
           typeId = typeIds[count++];
         }
@@ -495,6 +495,16 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return new org.apache.arrow.vector.complex.UnionVector.TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return getTransferPair(field, allocator, null);
+  }
+
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new org.apache.arrow.vector.complex.UnionVector.TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((UnionVector) target);
@@ -547,6 +557,11 @@ public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
       internalStructVectorTransferPair = internalStruct.makeTransferPair(to.internalStruct);
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      to = new UnionVector(field.getName(), allocator, null, callBack);
+      internalStructVectorTransferPair = internalStruct.makeTransferPair(to.internalStruct);
+    }
+
     public TransferImpl(UnionVector to) {
       this.to = to;
       internalStructVectorTransferPair = internalStruct.makeTransferPair(to.internalStruct);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
index 04a038a0b5dfd..d09664e6d313e 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseFixedWidthVector.java
@@ -569,6 +569,18 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return getTransferPair(ref, allocator);
   }
 
+  /**
+   * Construct a transfer pair of this vector and another vector of same type.
+   * @param field The field materialized by this vector.
+   * @param allocator allocator for the target vector
+   * @param callBack not used
+   * @return TransferPair
+   */
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return getTransferPair(field, allocator);
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param allocator allocator for the target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
index 4d5a8a5119c53..db922d6a70854 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
@@ -662,6 +662,18 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return getTransferPair(ref, allocator);
   }
 
+  /**
+   * Construct a transfer pair of this vector and another vector of same type.
+   * @param field The field materialized by this vector
+   * @param allocator allocator for the target vector
+   * @param callBack not used
+   * @return TransferPair
+   */
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return getTransferPair(field, allocator);
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param allocator allocator for the target vector
@@ -672,6 +684,7 @@ public TransferPair getTransferPair(BufferAllocator allocator) {
     return getTransferPair(getName(), allocator);
   }
 
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param ref name of the target vector
@@ -680,6 +693,14 @@ public TransferPair getTransferPair(BufferAllocator allocator) {
    */
   public abstract TransferPair getTransferPair(String ref, BufferAllocator allocator);
 
+  /**
+   * Construct a transfer pair of this vector and another vector of same type.
+   * @param field The field materialized by this vector
+   * @param allocator allocator for the target vector
+   * @return TransferPair
+   */
+  public abstract TransferPair getTransferPair(Field field, BufferAllocator allocator);
+
   /**
    * Transfer this vector'data to another vector. The memory associated
    * with this vector is transferred to the allocator of target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
index d7f5ff05a935d..b57dd9343824a 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
@@ -692,6 +692,18 @@ public void validateScalars() {
     // No validation by default.
   }
 
+  /**
+   * Construct a transfer pair of this vector and another vector of same type.
+   * @param field The field materialized by this vector.
+   * @param allocator allocator for the target vector
+   * @param callBack not used
+   * @return TransferPair
+   */
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return getTransferPair(field, allocator);
+  }
+
   /**
    * Construct a transfer pair of this vector and another vector of same type.
    * @param ref name of the target vector
@@ -722,6 +734,14 @@ public TransferPair getTransferPair(BufferAllocator allocator) {
    */
   public abstract TransferPair getTransferPair(String ref, BufferAllocator allocator);
 
+  /**
+   * Construct a transfer pair of this vector and another vector of same type.
+   * @param field The field materialized by this vector.
+   * @param allocator allocator for the target vector
+   * @return TransferPair
+   */
+  public abstract TransferPair getTransferPair(Field field, BufferAllocator allocator);
+
   /**
    * Transfer this vector'data to another vector. The memory associated
    * with this vector is transferred to the allocator of target vector
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java b/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java
index 9433719c5b8b2..a70efe61bcdfe 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java
@@ -125,6 +125,16 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return underlyingVector.getTransferPair(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return underlyingVector.getTransferPair(field, allocator);
+  }
+
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return underlyingVector.getTransferPair(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return underlyingVector.makeTransferPair(target);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
index 0063a61da570a..6806b958dad93 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
@@ -253,6 +253,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new TransferImpl(ref, allocator);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new TransferImpl(field, allocator);
+  }
+
   /**
    * Construct a TransferPair with a desired target vector of the same type.
    *
@@ -271,6 +276,10 @@ public TransferImpl(String ref, BufferAllocator allocator) {
       to = new LargeVarBinaryVector(ref, field.getFieldType(), allocator);
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator) {
+      to = new LargeVarBinaryVector(field, allocator);
+    }
+
     public TransferImpl(LargeVarBinaryVector to) {
       this.to = to;
     }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
index e9472c9f2c71e..874079a0ef83f 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
@@ -292,6 +292,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new LargeVarCharVector.TransferImpl(ref, allocator);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new LargeVarCharVector.TransferImpl(field, allocator);
+  }
+
   /**
    * Construct a TransferPair with a desired target vector of the same type.
    *
@@ -310,6 +315,10 @@ public TransferImpl(String ref, BufferAllocator allocator) {
       to = new LargeVarCharVector(ref, field.getFieldType(), allocator);
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator) {
+      to = new LargeVarCharVector(field, allocator);
+    }
+
     public TransferImpl(LargeVarCharVector to) {
       this.to = to;
     }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java b/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
index 1badf4b4ca808..de5eb80c0dfb9 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/NullVector.java
@@ -106,7 +106,7 @@ public Types.MinorType getMinorType() {
 
   @Override
   public TransferPair getTransferPair(BufferAllocator allocator) {
-    return getTransferPair(null, allocator);
+    return getTransferPair((String) null, allocator);
   }
 
   @Override
@@ -162,11 +162,21 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new TransferImpl();
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new TransferImpl();
+  }
+
   @Override
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return getTransferPair(ref, allocator);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return getTransferPair(field, allocator);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((NullVector) target);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java b/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
index 462b512c65436..e5f743c9c7f25 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java
@@ -132,10 +132,48 @@ public interface ValueVector extends Closeable, Iterable<ValueVector> {
    */
   TransferPair getTransferPair(BufferAllocator allocator);
 
+  /**
+   * To transfer quota responsibility.
+   *
+   * @param ref the name of the vector
+   * @param allocator the target allocator
+   * @return a {@link org.apache.arrow.vector.util.TransferPair transfer pair}, creating a new target vector of
+   *         the same type.
+   */
   TransferPair getTransferPair(String ref, BufferAllocator allocator);
 
+  /**
+   * To transfer quota responsibility.
+   *
+   * @param field the Field object used by the target vector
+   * @param allocator the target allocator
+   * @return a {@link org.apache.arrow.vector.util.TransferPair transfer pair}, creating a new target vector of
+   *         the same type.
+   */
+  TransferPair getTransferPair(Field field, BufferAllocator allocator);
+
+  /**
+   * To transfer quota responsibility.
+   *
+   * @param ref the name of the vector
+   * @param allocator the target allocator
+   * @param callBack A schema change callback.
+   * @return a {@link org.apache.arrow.vector.util.TransferPair transfer pair}, creating a new target vector of
+   *         the same type.
+   */
   TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack);
 
+  /**
+   * To transfer quota responsibility.
+   *
+   * @param field the Field object used by the target vector
+   * @param allocator the target allocator
+   * @param callBack A schema change callback.
+   * @return a {@link org.apache.arrow.vector.util.TransferPair transfer pair}, creating a new target vector of
+   *         the same type.
+   */
+  TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack);
+
   /**
    * Makes a new transfer pair used to transfer underlying buffers.
    *
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
index 34e072aaa8324..b43cd33d05391 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
@@ -254,6 +254,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new TransferImpl(ref, allocator);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new TransferImpl(field, allocator);
+  }
+
   /**
    * Construct a TransferPair with a desired target vector of the same type.
    *
@@ -272,6 +277,10 @@ public TransferImpl(String ref, BufferAllocator allocator) {
       to = new VarBinaryVector(ref, field.getFieldType(), allocator);
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator) {
+      to = new VarBinaryVector(field, allocator);
+    }
+
     public TransferImpl(VarBinaryVector to) {
       this.to = to;
     }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
index 2c83893819a1e..9ac275f75a771 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
@@ -292,6 +292,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new TransferImpl(ref, allocator);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new TransferImpl(field, allocator);
+  }
+
   /**
    * Construct a TransferPair with a desired target vector of the same type.
    *
@@ -310,6 +315,10 @@ public TransferImpl(String ref, BufferAllocator allocator) {
       to = new VarCharVector(ref, field.getFieldType(), allocator);
     }
 
+    public TransferImpl(Field field, BufferAllocator allocator) {
+      to = new VarCharVector(field, allocator);
+    }
+
     public TransferImpl(VarCharVector to) {
       this.to = to;
     }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/FixedSizeListVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/FixedSizeListVector.java
index 0f78829181142..367335436aecd 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/FixedSizeListVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/FixedSizeListVector.java
@@ -71,8 +71,7 @@ public static FixedSizeListVector empty(String name, int size, BufferAllocator a
   private FieldVector vector;
   private ArrowBuf validityBuffer;
   private final int listSize;
-  private final FieldType fieldType;
-  private final String name;
+  private Field field;
 
   private UnionFixedSizeListReader reader;
   private int valueCount;
@@ -90,13 +89,25 @@ public FixedSizeListVector(String name,
                              BufferAllocator allocator,
                              FieldType fieldType,
                              CallBack unusedSchemaChangeCallback) {
+    this(new Field(name, fieldType, null), allocator, unusedSchemaChangeCallback);
+  }
+
+  /**
+   * Creates a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use for creating/reallocating buffers for the vector.
+   * @param unusedSchemaChangeCallback Currently unused.
+   */
+  public FixedSizeListVector(Field field,
+                             BufferAllocator allocator,
+                             CallBack unusedSchemaChangeCallback) {
     super(allocator);
 
-    this.name = name;
+    this.field = field;
     this.validityBuffer = allocator.getEmpty();
     this.vector = ZeroVector.INSTANCE;
-    this.fieldType = fieldType;
-    this.listSize = ((ArrowType.FixedSizeList) fieldType.getType()).getListSize();
+    this.listSize = ((ArrowType.FixedSizeList) field.getFieldType().getType()).getListSize();
     Preconditions.checkArgument(listSize >= 0, "list size must be non-negative");
     this.valueCount = 0;
     this.validityAllocationSizeInBytes = getValidityBufferSizeFromCount(INITIAL_VALUE_ALLOCATION);
@@ -104,8 +115,11 @@ public FixedSizeListVector(String name,
 
   @Override
   public Field getField() {
-    List<Field> children = Collections.singletonList(getDataVector().getField());
-    return new Field(name, fieldType, children);
+    if (field.getChildren().contains(getDataVector().getField())) {
+      return field;
+    }
+    field = new Field(field.getName(), field.getFieldType(), Collections.singletonList(getDataVector().getField()));
+    return field;
   }
 
   @Override
@@ -115,7 +129,7 @@ public MinorType getMinorType() {
 
   @Override
   public String getName() {
-    return name;
+    return field.getName();
   }
 
   /** Get the fixed size for each list. */
@@ -133,6 +147,7 @@ public void initializeChildrenFromFields(List<Field> children) {
     checkArgument(addOrGetVector.isCreated(), "Child vector already existed: %s", addOrGetVector.getVector());
 
     addOrGetVector.getVector().initializeChildrenFromFields(field.getChildren());
+    this.field = new Field(this.field.getName(), this.field.getFieldType(), children);
   }
 
   @Override
@@ -172,8 +187,6 @@ private void setReaderAndWriterIndex() {
   /**
    * Get the inner vectors.
    *
-   * @deprecated This API will be removed as the current implementations no longer support inner vectors.
-   *
    * @return the inner vectors for this field as defined by the TypeLayout
    */
   @Deprecated
@@ -403,7 +416,7 @@ public void copyFrom(int fromIndex, int thisIndex, ValueVector from) {
 
   @Override
   public UnionVector promoteToUnion() {
-    UnionVector vector = new UnionVector(name, allocator, /* field type */ null, /* call-back */ null);
+    UnionVector vector = new UnionVector(getName(), allocator, /* field type */ null, /* call-back */ null);
     this.vector.clear();
     this.vector = vector;
     invalidateReader();
@@ -519,11 +532,21 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return getTransferPair(ref, allocator, null);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return getTransferPair(field, allocator, null);
+  }
+
   @Override
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((FixedSizeListVector) target);
@@ -567,7 +590,11 @@ private class TransferImpl implements TransferPair {
     TransferPair dataPair;
 
     public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
-      this(new FixedSizeListVector(name, allocator, fieldType, callBack));
+      this(new FixedSizeListVector(name, allocator, field.getFieldType(), callBack));
+    }
+
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      this(new FixedSizeListVector(field, allocator, callBack));
     }
 
     public TransferImpl(FixedSizeListVector to) {
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
index acb058cda3cb8..312bed6ab3349 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/LargeListVector.java
@@ -21,7 +21,6 @@
 import static org.apache.arrow.memory.util.LargeMemoryUtil.capAtMaxInt;
 import static org.apache.arrow.memory.util.LargeMemoryUtil.checkedCastToInt;
 import static org.apache.arrow.util.Preconditions.checkArgument;
-import static org.apache.arrow.util.Preconditions.checkNotNull;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -98,12 +97,11 @@ public static LargeListVector empty(String name, BufferAllocator allocator) {
   protected final CallBack callBack;
   protected int valueCount;
   protected long offsetAllocationSizeInBytes = INITIAL_VALUE_ALLOCATION * OFFSET_WIDTH;
-  private final String name;
 
   protected String defaultDataVectorName = DATA_VECTOR_NAME;
   protected ArrowBuf validityBuffer;
   protected UnionLargeListReader reader;
-  private final FieldType fieldType;
+  private Field field;
   private int validityAllocationSizeInBytes;
 
   /**
@@ -120,10 +118,20 @@ public static LargeListVector empty(String name, BufferAllocator allocator) {
    * @param callBack A schema change callback.
    */
   public LargeListVector(String name, BufferAllocator allocator, FieldType fieldType, CallBack callBack) {
+    this(new Field(name, fieldType, null), allocator, callBack);
+  }
+
+  /**
+   * Creates a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use for creating/reallocating buffers for the vector.
+   * @param callBack A schema change callback.
+   */
+  public LargeListVector(Field field, BufferAllocator allocator, CallBack callBack) {
     super(allocator);
-    this.name = name;
+    this.field = field;
     this.validityBuffer = allocator.getEmpty();
-    this.fieldType = checkNotNull(fieldType);
     this.callBack = callBack;
     this.validityAllocationSizeInBytes = getValidityBufferSizeFromCount(INITIAL_VALUE_ALLOCATION);
     this.lastSet = -1;
@@ -142,6 +150,7 @@ public void initializeChildrenFromFields(List<Field> children) {
     checkArgument(addOrGetVector.isCreated(), "Child vector already existed: %s", addOrGetVector.getVector());
 
     addOrGetVector.getVector().initializeChildrenFromFields(field.getChildren());
+    this.field = new Field(this.field.getName(), this.field.getFieldType(), children);
   }
 
   @Override
@@ -495,11 +504,21 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return getTransferPair(ref, allocator, null);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return getTransferPair(field, allocator, null);
+  }
+
   @Override
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((LargeListVector) target);
@@ -590,7 +609,11 @@ private class TransferImpl implements TransferPair {
     TransferPair dataTransferPair;
 
     public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
-      this(new LargeListVector(name, allocator, fieldType, callBack));
+      this(new LargeListVector(name, allocator, field.getFieldType(), callBack));
+    }
+
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      this(new LargeListVector(field, allocator, callBack));
     }
 
     public TransferImpl(LargeListVector to) {
@@ -784,7 +807,11 @@ public int getBufferSizeFor(int valueCount) {
 
   @Override
   public Field getField() {
-    return new Field(getName(), fieldType, Collections.singletonList(getDataVector().getField()));
+    if (field.getChildren().contains(getDataVector().getField())) {
+      return field;
+    }
+    field = new Field(field.getName(), field.getFieldType(), Collections.singletonList(getDataVector().getField()));
+    return field;
   }
 
   @Override
@@ -794,7 +821,7 @@ public MinorType getMinorType() {
 
   @Override
   public String getName() {
-    return name;
+    return field.getName();
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
index 0d6ff11f8ccf3..e5a83921b3135 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/ListVector.java
@@ -21,7 +21,6 @@
 import static org.apache.arrow.memory.util.LargeMemoryUtil.capAtMaxInt;
 import static org.apache.arrow.memory.util.LargeMemoryUtil.checkedCastToInt;
 import static org.apache.arrow.util.Preconditions.checkArgument;
-import static org.apache.arrow.util.Preconditions.checkNotNull;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -76,7 +75,7 @@ public static ListVector empty(String name, BufferAllocator allocator) {
   protected ArrowBuf validityBuffer;
   protected UnionListReader reader;
   private CallBack callBack;
-  protected final FieldType fieldType;
+  protected Field field;
   protected int validityAllocationSizeInBytes;
 
   /**
@@ -93,9 +92,20 @@ public static ListVector empty(String name, BufferAllocator allocator) {
    * @param callBack A schema change callback.
    */
   public ListVector(String name, BufferAllocator allocator, FieldType fieldType, CallBack callBack) {
-    super(name, allocator, callBack);
+    this(new Field(name, fieldType, null), allocator, callBack);
+  }
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use for allocating/reallocating buffers.
+   * @param callBack A schema change callback.
+   */
+  public ListVector(Field field, BufferAllocator allocator, CallBack callBack) {
+    super(field.getName(), allocator, callBack);
     this.validityBuffer = allocator.getEmpty();
-    this.fieldType = checkNotNull(fieldType);
+    this.field = field;
     this.callBack = callBack;
     this.validityAllocationSizeInBytes = getValidityBufferSizeFromCount(INITIAL_VALUE_ALLOCATION);
     this.lastSet = -1;
@@ -111,6 +121,7 @@ public void initializeChildrenFromFields(List<Field> children) {
     checkArgument(addOrGetVector.isCreated(), "Child vector already existed: %s", addOrGetVector.getVector());
 
     addOrGetVector.getVector().initializeChildrenFromFields(field.getChildren());
+    this.field = new Field(this.field.getName(), this.field.getFieldType(), children);
   }
 
   @Override
@@ -392,11 +403,21 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return getTransferPair(ref, allocator, null);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return getTransferPair(field, allocator, null);
+  }
+
   @Override
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new TransferImpl((ListVector) target);
@@ -462,7 +483,11 @@ private class TransferImpl implements TransferPair {
     TransferPair dataTransferPair;
 
     public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
-      this(new ListVector(name, allocator, fieldType, callBack));
+      this(new ListVector(name, allocator, field.getFieldType(), callBack));
+    }
+
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      this(new ListVector(field, allocator, callBack));
     }
 
     public TransferImpl(ListVector to) {
@@ -633,7 +658,11 @@ public int getBufferSizeFor(int valueCount) {
 
   @Override
   public Field getField() {
-    return new Field(getName(), fieldType, Collections.singletonList(getDataVector().getField()));
+    if (field.getChildren().contains(getDataVector().getField())) {
+      return field;
+    }
+    field = new Field(field.getName(), field.getFieldType(), Collections.singletonList(getDataVector().getField()));
+    return field;
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
index b8f3f32a73a29..c1913574bab19 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
@@ -76,6 +76,11 @@ public MapVector(String name, BufferAllocator allocator, FieldType fieldType, Ca
     defaultDataVectorName = DATA_VECTOR_NAME;
   }
 
+  public MapVector(Field field, BufferAllocator allocator, CallBack callBack) {
+    super(field, allocator, callBack);
+    defaultDataVectorName = DATA_VECTOR_NAME;
+  }
+
   /**
    * Initialize child vectors of the map from the given list of fields.
    *
@@ -99,6 +104,7 @@ public void initializeChildrenFromFields(List<Field> children) {
     checkArgument(addOrGetVector.isCreated(), "Child vector already existed: %s", addOrGetVector.getVector());
 
     addOrGetVector.getVector().initializeChildrenFromFields(structField.getChildren());
+    this.field = new Field(this.field.getName(), this.field.getFieldType(), children);
   }
 
   /**
@@ -130,6 +136,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return getTransferPair(ref, allocator, null);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new TransferImpl(field, allocator, null);
+  }
+
   @Override
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new TransferImpl(ref, allocator, callBack);
@@ -146,7 +157,11 @@ private class TransferImpl implements TransferPair {
     TransferPair dataTransferPair;
 
     public TransferImpl(String name, BufferAllocator allocator, CallBack callBack) {
-      this(new MapVector(name, allocator, fieldType, callBack));
+      this(new MapVector(name, allocator, field.getFieldType(), callBack));
+    }
+
+    public TransferImpl(Field field, BufferAllocator allocator, CallBack callBack) {
+      this(new MapVector(field, allocator, callBack));
     }
 
     public TransferImpl(MapVector to) {
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
index 7d724656cdab7..e642c547a1612 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java
@@ -17,8 +17,6 @@
 
 package org.apache.arrow.vector.complex;
 
-import static org.apache.arrow.util.Preconditions.checkNotNull;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
@@ -62,7 +60,7 @@ public static NonNullableStructVector emptyWithDuplicates(String name, BufferAll
   }
 
   private final SingleStructReaderImpl reader = new SingleStructReaderImpl(this);
-  protected final FieldType fieldType;
+  protected Field field;
   public int valueCount;
 
   /**
@@ -76,13 +74,20 @@ public NonNullableStructVector(String name,
                                  BufferAllocator allocator,
                                  FieldType fieldType,
                                  CallBack callBack) {
-    super(name,
-        allocator,
-        callBack,
-        null,
-        true);
-    this.fieldType = checkNotNull(fieldType);
-    this.valueCount = 0;
+    this(new Field(name, fieldType, null), allocator, callBack);
+  }
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use to allocating/reallocating buffers.
+   * @param callBack A schema change callback.
+   */
+  public NonNullableStructVector(Field field,
+                                 BufferAllocator allocator,
+                                 CallBack callBack) {
+    this(field, allocator, callBack, null, true);
   }
 
   /**
@@ -100,8 +105,24 @@ public NonNullableStructVector(String name,
                                  CallBack callBack,
                                  ConflictPolicy conflictPolicy,
                                  boolean allowConflictPolicyChanges) {
-    super(name, allocator, callBack, conflictPolicy, allowConflictPolicyChanges);
-    this.fieldType = checkNotNull(fieldType);
+    this(new Field(name, fieldType, null), allocator, callBack, conflictPolicy, allowConflictPolicyChanges);
+  }
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use to allocating/reallocating buffers.
+   * @param callBack A schema change callback.
+   * @param conflictPolicy How to handle duplicate field names in the struct.
+   */
+  public NonNullableStructVector(Field field,
+                                 BufferAllocator allocator,
+                                 CallBack callBack,
+                                 ConflictPolicy conflictPolicy,
+                                 boolean allowConflictPolicyChanges) {
+    super(field.getName(), allocator, callBack, conflictPolicy, allowConflictPolicyChanges);
+    this.field = field;
     this.valueCount = 0;
   }
 
@@ -208,7 +229,7 @@ public TransferPair getTransferPair(BufferAllocator allocator) {
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new StructTransferPair(this, new NonNullableStructVector(name,
         allocator,
-        fieldType,
+        field.getFieldType(),
         callBack,
         getConflictPolicy(),
         allowConflictPolicyChanges), false);
@@ -223,7 +244,25 @@ public TransferPair makeTransferPair(ValueVector to) {
   public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new StructTransferPair(this, new NonNullableStructVector(ref,
         allocator,
-        fieldType,
+        field.getFieldType(),
+        callBack,
+        getConflictPolicy(),
+        allowConflictPolicyChanges), false);
+  }
+
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new StructTransferPair(this, new NonNullableStructVector(field,
+        allocator,
+        callBack,
+        getConflictPolicy(),
+        allowConflictPolicyChanges), false);
+  }
+
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new StructTransferPair(this, new NonNullableStructVector(field,
+        allocator,
         callBack,
         getConflictPolicy(),
         allowConflictPolicyChanges), false);
@@ -416,7 +455,11 @@ public Field getField() {
     for (ValueVector child : getChildren()) {
       children.add(child.getField());
     }
-    return new Field(name, fieldType, children);
+    if (children.isEmpty() || field.getChildren().equals(children)) {
+      return field;
+    }
+    field = new Field(field.getName(), field.getFieldType(), children);
+    return field;
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
index 2dabc6e014969..d947249fd3cdd 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
@@ -42,6 +42,7 @@
 import org.apache.arrow.vector.ipc.message.ArrowFieldNode;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.ArrowType.Struct;
+import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.util.CallBack;
 import org.apache.arrow.vector.util.OversizedAllocationException;
@@ -113,6 +114,44 @@ public StructVector(String name,
       BitVectorHelper.getValidityBufferSize(BaseValueVector.INITIAL_VALUE_ALLOCATION);
   }
 
+  /**
+   * Constructs a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use to allocating/reallocating buffers.
+   * @param callBack A schema change callback.
+   */
+  public StructVector(Field field,
+                      BufferAllocator allocator,
+                      CallBack callBack) {
+    super(field,
+        checkNotNull(allocator),
+        callBack);
+    this.validityBuffer = allocator.getEmpty();
+    this.validityAllocationSizeInBytes =
+        BitVectorHelper.getValidityBufferSize(BaseValueVector.INITIAL_VALUE_ALLOCATION);
+  }
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param field The field materialized by this vector.
+   * @param allocator The allocator to use to allocating/reallocating buffers.
+   * @param callBack A schema change callback.
+   * @param conflictPolicy policy to determine how duplicate names are handled.
+   * @param allowConflictPolicyChanges wether duplicate names are allowed at all.
+   */
+  public StructVector(Field field,
+                      BufferAllocator allocator,
+                      CallBack callBack,
+                      ConflictPolicy conflictPolicy,
+                      boolean allowConflictPolicyChanges) {
+    super(field, checkNotNull(allocator), callBack, conflictPolicy, allowConflictPolicyChanges);
+    this.validityBuffer = allocator.getEmpty();
+    this.validityAllocationSizeInBytes =
+        BitVectorHelper.getValidityBufferSize(BaseValueVector.INITIAL_VALUE_ALLOCATION);
+  }
+
   @Override
   public void loadFieldBuffers(ArrowFieldNode fieldNode, List<ArrowBuf> ownBuffers) {
     if (ownBuffers.size() != 1) {
@@ -167,7 +206,7 @@ public NullableStructWriter getWriter() {
   public TransferPair getTransferPair(BufferAllocator allocator) {
     return new NullableStructTransferPair(this, new StructVector(name,
         allocator,
-        fieldType,
+        field.getFieldType(),
         null,
         getConflictPolicy(),
         allowConflictPolicyChanges), false);
@@ -182,7 +221,7 @@ public TransferPair makeTransferPair(ValueVector to) {
   public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
     return new NullableStructTransferPair(this, new StructVector(ref,
         allocator,
-        fieldType,
+        field.getFieldType(),
         null,
         getConflictPolicy(),
         allowConflictPolicyChanges), false);
@@ -192,12 +231,21 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator) {
   public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallBack callBack) {
     return new NullableStructTransferPair(this, new StructVector(ref,
         allocator,
-        fieldType,
+        field.getFieldType(),
         callBack,
         getConflictPolicy(),
         allowConflictPolicyChanges), false);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
+    return new NullableStructTransferPair(this, new StructVector(field,
+        allocator,
+        null,
+        getConflictPolicy(),
+        allowConflictPolicyChanges), false);
+  }
+
   /**
    * {@link TransferPair} for this (nullable) {@link StructVector}.
    */
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
index adf86183c0ada..993ce0b089769 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeListVector.java
@@ -20,6 +20,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
@@ -992,6 +993,28 @@ public void testTotalCapacity() {
     }
   }
 
+  @Test
+  public void testGetTransferPairWithField() throws Exception {
+    try (final LargeListVector fromVector = LargeListVector.empty("list", allocator)) {
+
+      UnionLargeListWriter writer = fromVector.getWriter();
+      writer.allocate();
+
+      //set some values
+      writer.startList();
+      writer.integer().writeInt(1);
+      writer.integer().writeInt(2);
+      writer.endList();
+      fromVector.setValueCount(2);
+
+      final TransferPair transferPair = fromVector.getTransferPair(fromVector.getField(),
+          allocator);
+      final LargeListVector toVector = (LargeListVector) transferPair.getTo();
+      // Field inside a new vector created by reusing a field should be the same in memory as the original field.
+      assertSame(toVector.getField(), fromVector.getField());
+    }
+  }
+
   private void writeIntValues(UnionLargeListWriter writer, int[] values) {
     writer.startList();
     for (int v: values) {
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
index 644827ce995e8..ce7bb15bb1482 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
@@ -18,12 +18,14 @@
 package org.apache.arrow.vector;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.vector.holders.NullableLargeVarBinaryHolder;
+import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -101,4 +103,20 @@ public void testSetNullableLargeVarBinaryHolderSafe() {
       buf.close();
     }
   }
+
+  @Test
+  public void testGetTransferPairWithField() {
+    try (BufferAllocator childAllocator1 = allocator.newChildAllocator("child1", 1000000, 1000000);
+        LargeVarBinaryVector v1 = new LargeVarBinaryVector("v1", childAllocator1)) {
+      v1.allocateNew();
+      v1.setSafe(4094, "hello world".getBytes(), 0, 11);
+      v1.setValueCount(4001);
+
+      TransferPair tp = v1.getTransferPair(v1.getField(), allocator);
+      tp.transfer();
+      LargeVarBinaryVector v2 = (LargeVarBinaryVector) tp.getTo();
+      assertSame(v1.getField(), v2.getField());
+      v2.clear();
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
index 1b81c6b209fbb..5f7863c6f6177 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
@@ -21,6 +21,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import java.nio.charset.StandardCharsets;
@@ -794,6 +795,22 @@ public void testNullableType() {
     }
   }
 
+  @Test
+  public void testGetTransferPairWithField() {
+    try (BufferAllocator childAllocator1 = allocator.newChildAllocator("child1", 1000000, 1000000);
+        LargeVarCharVector v1 = new LargeVarCharVector("v1", childAllocator1)) {
+      v1.allocateNew();
+      v1.setSafe(4094, "hello world".getBytes(), 0, 11);
+      v1.setValueCount(4001);
+
+      TransferPair tp = v1.getTransferPair(v1.getField(), allocator);
+      tp.transfer();
+      LargeVarCharVector v2 = (LargeVarCharVector) tp.getTo();
+      assertSame(v1.getField(), v2.getField());
+      v2.clear();
+    }
+  }
+
   private void populateLargeVarcharVector(final LargeVarCharVector vector, int valueCount, String[] values) {
     for (int i = 0; i < valueCount; i += 3) {
       final String s = String.format("%010d", i);
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
index 2a1228c2a38c2..278f497b47991 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestListVector.java
@@ -20,6 +20,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -1135,6 +1136,26 @@ public void testTotalCapacity() {
     }
   }
 
+  @Test
+  public void testGetTransferPairWithField() {
+    try (ListVector fromVector = ListVector.empty("input", allocator)) {
+      UnionListWriter writer = fromVector.getWriter();
+      writer.allocate();
+      writer.setPosition(0); // optional
+      writer.startList();
+      writer.bigInt().writeBigInt(1);
+      writer.bigInt().writeBigInt(2);
+      writer.bigInt().writeBigInt(3);
+      writer.endList();
+      writer.setValueCount(1);
+      final TransferPair transferPair = fromVector.getTransferPair(fromVector.getField(),
+          allocator);
+      final ListVector toVector = (ListVector) transferPair.getTo();
+      // Field inside a new vector created by reusing a field should be the same in memory as the original field.
+      assertSame(toVector.getField(), fromVector.getField());
+    }
+  }
+
   private void writeIntValues(UnionListWriter writer, int[] values) {
     writer.startList();
     for (int v: values) {
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
index d60d5611a5f7b..5c8fd55ec98dc 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
@@ -1133,4 +1133,26 @@ public void testGetTransferPair() {
       vector.clear();
     }
   }
+
+  @Test
+  public void testGetTransferPairWithField() {
+    try (MapVector mapVector = MapVector.empty("mapVector", allocator, false)) {
+
+      FieldType type = new FieldType(false, ArrowType.Struct.INSTANCE, null, null);
+      AddOrGetResult<StructVector> addResult = mapVector.addOrGetVector(type);
+      FieldType keyType = new FieldType(false, MinorType.BIGINT.getType(), null, null);
+      FieldType valueType = FieldType.nullable(MinorType.FLOAT8.getType());
+      addResult.getVector().addOrGet(MapVector.KEY_NAME, keyType, BigIntVector.class);
+      addResult.getVector().addOrGet(MapVector.VALUE_NAME, valueType, Float8Vector.class);
+      mapVector.allocateNew();
+      mapVector.setValueCount(0);
+
+      assertEquals(-1, mapVector.getLastSet());
+      TransferPair tp = mapVector.getTransferPair(mapVector.getField(), allocator);
+      tp.transfer();
+      MapVector toVector = (MapVector) tp.getTo();
+      assertSame(toVector.getField(), mapVector.getField());
+      toVector.clear();
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
index 552d5752f236f..ee34f203b6320 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
@@ -29,11 +29,16 @@
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.complex.StructVector;
 import org.apache.arrow.vector.complex.UnionVector;
+import org.apache.arrow.vector.complex.impl.NullableStructWriter;
+import org.apache.arrow.vector.complex.writer.Float8Writer;
+import org.apache.arrow.vector.complex.writer.IntWriter;
 import org.apache.arrow.vector.holders.ComplexHolder;
+import org.apache.arrow.vector.types.Types;
 import org.apache.arrow.vector.types.Types.MinorType;
 import org.apache.arrow.vector.types.pojo.ArrowType.Struct;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Before;
@@ -290,4 +295,43 @@ public void testTypedGetters() {
       assertEquals(IntVector.class, s1.getVectorById(0, IntVector.class).getClass());
     }
   }
+
+  @Test
+  public void testGetTransferPair() {
+    try (final StructVector fromVector = simpleStructVector("s1", allocator)) {
+      TransferPair tp = fromVector.getTransferPair(fromVector.getField(), allocator);
+      final StructVector toVector = (StructVector) tp.getTo();
+      // Field inside a new vector created by reusing a field should be the same in memory as the original field.
+      assertSame(toVector.getField(), fromVector.getField());
+      toVector.clear();
+    }
+  }
+
+  private StructVector simpleStructVector(String name, BufferAllocator allocator) {
+    final String INT_COL = "struct_int_child";
+    final String FLT_COL = "struct_flt_child";
+    StructVector structVector = StructVector.empty(name, allocator);
+    final int size = 6; // number of structs
+
+    NullableStructWriter structWriter = structVector.getWriter();
+    structVector.addOrGet(
+        INT_COL, FieldType.nullable(Types.MinorType.INT.getType()), IntVector.class);
+    structVector.addOrGet(
+        FLT_COL, FieldType.nullable(Types.MinorType.INT.getType()), IntVector.class);
+    structVector.allocateNew();
+    IntWriter intWriter = structWriter.integer(INT_COL);
+    Float8Writer float8Writer = structWriter.float8(FLT_COL);
+
+    for (int i = 0; i < size; i++) {
+      structWriter.setPosition(i);
+      structWriter.start();
+      intWriter.writeInt(i);
+      float8Writer.writeFloat8(i * .1);
+      structWriter.end();
+    }
+
+    structWriter.setValueCount(size);
+
+    return structVector;
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestVectorSchemaRoot.java b/java/vector/src/test/java/org/apache/arrow/vector/TestVectorSchemaRoot.java
index 7a445750a63de..ce3fb2cdf0ea1 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestVectorSchemaRoot.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestVectorSchemaRoot.java
@@ -40,6 +40,7 @@
 import org.junit.Test;
 
 public class TestVectorSchemaRoot {
+
   private BufferAllocator allocator;
 
   @Before

From 4bbd48db8f3937c3e2f54f4c1131fd6af5a6b85c Mon Sep 17 00:00:00 2001
From: Chris Larsen <clarsen@euphoriaaudio.com>
Date: Fri, 20 Oct 2023 13:30:14 -0700
Subject: [PATCH 598/749] GH-38366: [Java] Fix Murmur hash on buffers less than
 4 bytes (#38368)

### Rationale for this change

Using the `MurmurHash` implementation would cause collisions on small input values.

### What changes are included in this PR?

Fix the iteration for small and tail values that are not 4 bytes in length.

### Are these changes tested?

Yes

### Are there any user-facing changes?
Unlikely unless someone was using the `MurmurHash` functions to persist a hash value.

* Closes: #38366

Authored-by: Chris Larsen <clarsen@netflix.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/memory/util/hash/MurmurHasher.java  |  2 +-
 .../memory/util/hash/TestArrowBufHasher.java  | 22 +++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/java/memory/memory-core/src/main/java/org/apache/arrow/memory/util/hash/MurmurHasher.java b/java/memory/memory-core/src/main/java/org/apache/arrow/memory/util/hash/MurmurHasher.java
index ea565dfca67e4..75fc3f0c45831 100644
--- a/java/memory/memory-core/src/main/java/org/apache/arrow/memory/util/hash/MurmurHasher.java
+++ b/java/memory/memory-core/src/main/java/org/apache/arrow/memory/util/hash/MurmurHasher.java
@@ -96,7 +96,7 @@ public static int hashCode(long address, long length, int seed) {
     if (index < length) {
       // process remaining data as a integer in little endian
       int intValue = 0;
-      for (int i = index - 1; i >= index; i--) {
+      for (long i = length - 1; i >= index; i--) {
         intValue <<= 8;
         intValue |= (MemoryUtil.UNSAFE.getByte(address + i) & 0x000000ff);
         index += 1;
diff --git a/java/memory/memory-core/src/test/java/org/apache/arrow/memory/util/hash/TestArrowBufHasher.java b/java/memory/memory-core/src/test/java/org/apache/arrow/memory/util/hash/TestArrowBufHasher.java
index a8707e6ca93d7..3da0602bdfd9c 100644
--- a/java/memory/memory-core/src/test/java/org/apache/arrow/memory/util/hash/TestArrowBufHasher.java
+++ b/java/memory/memory-core/src/test/java/org/apache/arrow/memory/util/hash/TestArrowBufHasher.java
@@ -18,8 +18,10 @@
 package org.apache.arrow.memory.util.hash;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collection;
 
@@ -110,6 +112,26 @@ public void testHasherNegative() {
     }
   }
 
+  @Test
+  public void testHasherLessThanInt() {
+    try (ArrowBuf buf1 = allocator.buffer(4);
+         ArrowBuf buf2 = allocator.buffer(4)) {
+      buf1.writeBytes("foo1".getBytes(StandardCharsets.UTF_8));
+      buf2.writeBytes("bar2".getBytes(StandardCharsets.UTF_8));
+
+      for (int i = 1; i <= 4; i ++) {
+        verifyHashCodeNotEqual(buf1, 0, i, buf2, 0, i);
+      }
+    }
+  }
+
+  private void verifyHashCodeNotEqual(ArrowBuf buf1, int offset1, int length1,
+                                      ArrowBuf buf2, int offset2, int length2) {
+    int hashCode1 = hasher.hashCode(buf1, 0, length1);
+    int hashCode2 = hasher.hashCode(buf2, 0, length2);
+    assertNotEquals(hashCode1, hashCode2);
+  }
+
   @Parameterized.Parameters(name = "hasher = {0}")
   public static Collection<Object[]> getHasher() {
     return Arrays.asList(

From cb7996f8d62f7a4e306066f993146893100a8a9a Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Sun, 22 Oct 2023 08:18:51 -0700
Subject: [PATCH 599/749] GH-38387: [Java] Fix JDK8 compilation issue with
 TestAllTypes (#38388)

### Rationale for this change
There is a build error due to use of a JDK9 API

### What changes are included in this PR?
Change construction of a list of to use JDK8 functions instead of a JDK9 function.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.

**This PR contains a "Critical Fix".**

* Closes: #38387

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../test/java/org/apache/arrow/dataset/TestAllTypes.java   | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java b/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
index d0163bec3674c..7be49079e7450 100644
--- a/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
+++ b/java/dataset/src/test/java/org/apache/arrow/dataset/TestAllTypes.java
@@ -24,6 +24,7 @@
 import java.nio.channels.SeekableByteChannel;
 import java.nio.channels.WritableByteChannel;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -97,7 +98,7 @@ private VectorSchemaRoot generateAllTypesVector(BufferAllocator allocator) {
         new FieldType(false, new ArrowType.Int(32, true), null, null), null));
     Field structField = new Field("struct",
         new FieldType(true, ArrowType.Struct.INSTANCE, null, null), childFields);
-    List<Field> fields = List.of(
+    Field[] fields = new Field[] {
         Field.nullablePrimitive("null", ArrowType.Null.INSTANCE),
         Field.nullablePrimitive("bool", ArrowType.Bool.INSTANCE),
         Field.nullablePrimitive("int8", new ArrowType.Int(8, true)),
@@ -132,8 +133,8 @@ private VectorSchemaRoot generateAllTypesVector(BufferAllocator allocator) {
         new Field("fixedsizelist", FieldType.nullable(new ArrowType.FixedSizeList(2)),
             Collections.singletonList(Field.nullable("items", new ArrowType.Int(32, true)))),
         structField
-    );
-    VectorSchemaRoot root = VectorSchemaRoot.create(new Schema(fields), allocator);
+    };
+    VectorSchemaRoot root = VectorSchemaRoot.create(new Schema(Arrays.asList(fields)), allocator);
     root.allocateNew();
     root.setRowCount(2);
 

From f489996e707dd136e41f1eb8ed963f707eed18ad Mon Sep 17 00:00:00 2001
From: Jonathan Keane <jkeane@gmail.com>
Date: Sun, 22 Oct 2023 12:18:33 -0500
Subject: [PATCH 600/749] GH-38376 [R]: Add `dimnames` method to `Dataset`
 class  (#38377)

### Rationale for this change

Add `dimnames` method so that things like `colnames(ds)` work out of the box on datasets. Inspired by dbplyr's lazy tbl implementation

### What changes are included in this PR?

An additional `dimnames` method for Dataset objects

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes
* Closes: #38376

Authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/NAMESPACE                     | 1 +
 r/R/dataset.R                   | 3 +++
 r/tests/testthat/test-dataset.R | 6 ++++++
 3 files changed, 10 insertions(+)

diff --git a/r/NAMESPACE b/r/NAMESPACE
index dac2cbda9cb5e..412d70ed22c99 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -101,6 +101,7 @@ S3method(dim,RecordBatchReader)
 S3method(dim,StructArray)
 S3method(dim,arrow_dplyr_query)
 S3method(dimnames,ArrowTabular)
+S3method(dimnames,Dataset)
 S3method(head,ArrowDatum)
 S3method(head,ArrowTabular)
 S3method(head,Dataset)
diff --git a/r/R/dataset.R b/r/R/dataset.R
index 2400d0839351b..682f6c1481b4f 100644
--- a/r/R/dataset.R
+++ b/r/R/dataset.R
@@ -527,6 +527,9 @@ names.Dataset <- function(x) names(x$schema)
 #' @export
 dim.Dataset <- function(x) c(x$num_rows, x$num_cols)
 
+#' @export
+dimnames.Dataset <- function(x) list(NULL, names(x))
+
 #' @export
 c.Dataset <- function(...) Dataset$create(list(...))
 
diff --git a/r/tests/testthat/test-dataset.R b/r/tests/testthat/test-dataset.R
index b7632084e4622..7ea47db449269 100644
--- a/r/tests/testthat/test-dataset.R
+++ b/r/tests/testthat/test-dataset.R
@@ -334,6 +334,12 @@ test_that("dim method returns the correct number of rows and columns", {
   expect_identical(dim(ds), c(20L, 7L))
 })
 
+test_that("dimnames, colnames on Dataset objects", {
+  ds <- open_dataset(dataset_dir, partitioning = schema(part = uint8()))
+  col_names <- c("int", "dbl", "lgl", "chr", "fct", "ts", "part")
+  expect_identical(dimnames(ds), list(NULL, col_names))
+  expect_identical(colnames(ds), col_names)
+})
 
 test_that("dim() correctly determine numbers of rows and columns on arrow_dplyr_query object", {
   ds <- open_dataset(dataset_dir, partitioning = schema(part = uint8()))

From 6ce6ec278e306788358cc1212f07f85b99b6b59d Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 23 Oct 2023 17:56:14 +0900
Subject: [PATCH 601/749] GH-38300: [Dev][Docs] Update dev/README.md for the
 current merge_arrow_pr.py (#38301)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

dev/README.md is outdated.

### What changes are included in this PR?

* Don't require `arrow` remote
* Remove ARROW Jira related documents

### Are these changes tested?

No.

### Are there any user-facing changes?

No.
* Closes: #38300

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/README.md | 73 +++++++++++++--------------------------------------
 1 file changed, 18 insertions(+), 55 deletions(-)

diff --git a/dev/README.md b/dev/README.md
index 151f33b384a19..24600a67db8c3 100644
--- a/dev/README.md
+++ b/dev/README.md
@@ -31,27 +31,22 @@ NOTE: It may take some time (a few hours) between when you complete
 the setup at GitBox, and when your GitHub account will be added as a
 committer.
 
-## How to merge a Pull request
+## How to Merge a Pull Request
 
-Please don't merge PRs using the Github Web interface.  Instead, set up
-your git clone such as to have a remote named ``apache`` pointing to the
-official Arrow repository:
-```
-git remote add apache git@github.com:apache/arrow.git
-```
+Please don't merge PRs using the GitHub Web interface. Instead, run
+the following command:
 
-and then run the following command:
-```
-./dev/merge_arrow_pr.sh
+```bash
+dev/merge_arrow_pr.sh
 ```
 
 This creates a new Python virtual environment under `dev/.venv[PY_VERSION]`
 and installs all the necessary dependencies to run the Arrow merge script.
 After installed, it runs the merge script.
 
-(we don't provide a wrapper script for Windows yet, so under Windows you'll
-have to install Python dependencies yourself and then run `dev/merge_arrow_pr.py`
-directly)
+(We don't provide a wrapper script for Windows yet, so under Windows
+you'll have to install Python dependencies yourself and then run
+`dev/merge_arrow_pr.py` directly.)
 
 The merge script uses the GitHub REST API. You must set a
 `ARROW_GITHUB_API_TOKEN` environment variable to use a 
@@ -64,30 +59,16 @@ of your JIRA account in the
 `APACHE_JIRA_TOKEN` environment variable.
 If the variable is not set, the script will ask you for it.
 
-Note that the directory name of your Arrow git clone must be called `arrow`.
+Example output:
 
-example output:
-```
+```text
 Which pull request would you like to merge? (e.g. 34):
 ```
-Type the pull request number (from https://github.com/apache/arrow/pulls) and hit enter.
-```
-=== Pull Request #X ===
-title	Blah Blah Blah
-source	repo/branch
-target	master
-url	https://api.github.com/apache/arrow/pulls/X
-=== JIRA ARROW-#Y ===
-Summary		Blah Blah Blah
-Assignee	Name
-Components	C++
-Status		In Progress
-URL		https://issues.apache.org/jira/browse/ARROW-#Y
 
-Proceed with merging pull request #X? (y/n):
-```
+Type the pull request number (from
+https://github.com/apache/arrow/pulls) and hit enter:
 
-```
+```text
 === Pull Request #X ===
 title	GH-#Y: [Component] Title
 source	repo/branch
@@ -103,17 +84,9 @@ URL		https://github.com/apache/arrow/issues/Y
 Proceed with merging pull request #X? (y/n): y
 ```
 
-If this looks good, type y and hit enter.
-```
-Author 1: Name
-Pull request #X merged!
-Merge hash: #hash
+If this looks good, type `y` and hit enter:
 
-Would you like to update the associated JIRA? (y/n): y
-Enter comma-separated fix version(s) [11.0.0]:
-```
-
-```
+```text
 Author 1: Name
 Pull request #X merged!
 Merge hash: #hash
@@ -122,27 +95,17 @@ Would you like to update the associated issue? (y/n): y
 Enter fix version [11.0.0]:
 ```
 
-You can just hit enter and the associated JIRA or GitHub issue
+You can just hit enter and the associated GitHub issue
 will be resolved with the current fix version.
 
-```
-Successfully resolved ARROW-#Y!
-=== JIRA ARROW-#Y ===
-Summary		Blah Blah Blah
-Assignee	Name
-Components	C++
-Status		Resolved
-URL		https://issues.apache.org/jira/browse/ARROW-#Y
-```
-
-```
+```text
 Successfully resolved #Y!
 === GITHUB #Y ===
 Summary		[Component] Title
 Assignee	Name
 Components	Python
 Status		closed
-URL		https://github.com/apache/arrow/issues/Y```
+URL		https://github.com/apache/arrow/issues/Y
 ```
 
 ## Verifying Release Candidates

From 37935604bf168a3b2d52f3cc5b0edf83b5783309 Mon Sep 17 00:00:00 2001
From: Dan Stone <wotbrew@gmail.com>
Date: Mon, 23 Oct 2023 12:30:27 +0100
Subject: [PATCH 602/749] GH-38242: [Java] Fix incorrect internal struct
 accounting for DenseUnionVector#getBufferSizeFor (#38305)

### What changes are included in this PR?

Fix incorrect implementation of `DenseUnionVector.getBufferSizeFor`.
Sum the type id counts before calling `getBufferSizeFor` on the union's child vectors.

### Are these changes tested?

Yes. A test verifies the OOB read (requires bounds check), and an example count is correct, fails as expected before fix.

**This PR contains a "Critical Fix".**

For users of DenseUnionVector the size can calculated incorrectly, as well as cause of out-of-bounds buffer reads which may return garbage (or potentially segfaulting) if bounds checking is off.

* Closes: #38242

Authored-by: Dan Stone <wotbrew@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../codegen/templates/DenseUnionVector.java   | 20 ++++-
 .../complex/TestDenseUnionBufferSize.java     | 81 +++++++++++++++++++
 2 files changed, 99 insertions(+), 2 deletions(-)
 create mode 100644 java/vector/src/test/java/org/apache/arrow/vector/complex/TestDenseUnionBufferSize.java

diff --git a/java/vector/src/main/codegen/templates/DenseUnionVector.java b/java/vector/src/main/codegen/templates/DenseUnionVector.java
index 12fc52af3c18e..de0cf84fd82ad 100644
--- a/java/vector/src/main/codegen/templates/DenseUnionVector.java
+++ b/java/vector/src/main/codegen/templates/DenseUnionVector.java
@@ -730,8 +730,24 @@ public int getBufferSizeFor(final int count) {
     if (count == 0) {
       return 0;
     }
-    return (int) (count * TYPE_WIDTH + (long) count * OFFSET_WIDTH
-        + DataSizeRoundingUtil.divideBy8Ceil(count) + internalStruct.getBufferSizeFor(count));
+
+    int[] counts = new int[Byte.MAX_VALUE + 1];
+    for (int i = 0; i < count; i++) {
+      byte typeId = getTypeId(i);
+      if (typeId != -1) {
+        counts[typeId] += 1;
+      }
+    }
+
+    long childBytes = 0;
+    for (int typeId = 0; typeId < childVectors.length; typeId++) {
+      ValueVector childVector = childVectors[typeId];
+      if (childVector != null) {
+        childBytes += childVector.getBufferSizeFor(counts[typeId]);
+      }
+    }
+
+    return (int) (count * TYPE_WIDTH + (long) count * OFFSET_WIDTH + childBytes);
   }
 
   @Override
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/TestDenseUnionBufferSize.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/TestDenseUnionBufferSize.java
new file mode 100644
index 0000000000000..82ef7a479d05c
--- /dev/null
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/TestDenseUnionBufferSize.java
@@ -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.
+ */
+
+package org.apache.arrow.vector.complex;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.BaseValueVector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.holders.NullableIntHolder;
+import org.apache.arrow.vector.holders.NullableVarBinaryHolder;
+import org.apache.arrow.vector.types.UnionMode;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.FieldType;
+import org.junit.jupiter.api.Test;
+
+public class TestDenseUnionBufferSize {
+  @Test
+  public void testBufferSize() {
+    try (BufferAllocator allocator = new RootAllocator();
+         DenseUnionVector duv = new DenseUnionVector("duv", allocator,
+                 FieldType.nullable(new ArrowType.Union(UnionMode.Dense, null)), null)) {
+
+      byte aTypeId = 42;
+      byte bTypeId = 7;
+
+      duv.addVector(aTypeId, new IntVector("a", FieldType.notNullable(new ArrowType.Int(32, true)), allocator));
+      duv.addVector(bTypeId, new VarBinaryVector("b", FieldType.notNullable(new ArrowType.Binary()), allocator));
+
+      NullableIntHolder intHolder = new NullableIntHolder();
+      NullableVarBinaryHolder varBinaryHolder = new NullableVarBinaryHolder();
+
+      int aCount = BaseValueVector.INITIAL_VALUE_ALLOCATION + 1;
+      for (int i = 0; i < aCount; i++) {
+        duv.setTypeId(i, aTypeId);
+        duv.setSafe(i, intHolder);
+      }
+
+      int bCount = 2;
+      for (int i = 0; i < bCount; i++) {
+        duv.setTypeId(i + aCount, bTypeId);
+        duv.setSafe(i + aCount, varBinaryHolder);
+      }
+
+      int count = aCount + bCount;
+      duv.setValueCount(count);
+
+      // will not necessarily see an error unless bounds checking is on.
+      assertDoesNotThrow(duv::getBufferSize);
+
+      IntVector intVector = duv.getIntVector(aTypeId);
+      VarBinaryVector varBinaryVector = duv.getVarBinaryVector(bTypeId);
+
+      long overhead = DenseUnionVector.TYPE_WIDTH + DenseUnionVector.OFFSET_WIDTH;
+
+      assertEquals(overhead * count + intVector.getBufferSize() + varBinaryVector.getBufferSize(),
+              duv.getBufferSize());
+
+      assertEquals(overhead * (aCount + 1) + intVector.getBufferSizeFor(aCount) + varBinaryVector.getBufferSizeFor(1),
+              duv.getBufferSizeFor(aCount + 1));
+
+    }
+  }
+}

From 1d11df318a7043ec2eaa5984a5daf4ff0890651f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Mon, 23 Oct 2023 16:19:00 +0200
Subject: [PATCH 603/749] MINOR: [Dev] Remove maplefu as collaborator (#38397)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

@ mapleFU is committer now :tada:

### What changes are included in this PR?

Remove from list of collaborators.

### Are these changes tested?

No

### Are there any user-facing changes?

No

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: mwish <maplewish117@gmail.com>
---
 .asf.yaml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.asf.yaml b/.asf.yaml
index 1e7fcf1e07ece..4693631be38b3 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -25,7 +25,6 @@ github:
     - davisusanibar
     - felipecrv
     - js8544
-    - mapleFU
 
 notifications:
   commits:      commits@arrow.apache.org

From 3beb93af36b3388a6871846365502c36ae4cfaa4 Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Mon, 23 Oct 2023 11:37:33 -0400
Subject: [PATCH 604/749] GH-37815: [MATLAB] Add `arrow.array.ListArray` MATLAB
 class (#38357)

### Rationale for this change

Now that many of the commonly-used "primitive" array types have been added to the MATLAB interface, we can implement an `arrow.array.ListArray` class.

This pull request adds a new `arrow.array.ListArray` class which can be converted to a MATLAB `cell` array by calling the static `toMATLAB` method.

### What changes are included in this PR?

1. Added a new `arrow.array.ListArray` MATLAB class.

*Methods*

`cellArray = arrow.array.ListArray.toMATLAB()`
`listArray = arrow.array.ListArray.fromArrays(offsets, values)`

*Properties*

`Offsets` - `Int32Array` list offsets (uses zero-based indexing)
`Values` - Array of values in the list (supports nesting)

2. Added a new `arrow.type.traits.ListTraits` MATLAB class.

**Example**
```matlab
>> offsets = arrow.array(int32([0, 2, 3, 7]))

offsets =

[
  0,
  2,
  3,
  7
]

>> values = arrow.array(["A", "B", "C", "D", "E", "F", "G"])

values =

[
  "A",
  "B",
  "C",
  "D",
  "E",
  "F",
  "G"
]

>> arrowArray = arrow.array.ListArray.fromArrays(offsets, values)

arrowArray =

[
  [
    "A",
    "B"
  ],
  [
    "C"
  ],
  [
    "D",
    "E",
    "F",
    "G"
  ]
]

>> matlabArray = arrowArray.toMATLAB()

matlabArray =

  3x1 cell array

    {2x1 string}
    {["C"     ]}
    {4x1 string}

>> matlabArray{:}

ans =

  2x1 string array

    "A"
    "B"

ans =

    "C"

ans =

  4x1 string array

    "D"
    "E"
    "F"
    "G"

```

### Are these changes tested?

Yes.

1. Added a new `tListArray.m` test class.
2. Added a new `tListTraits.m` test class.
3. Updated `arrow.internal.test.tabular.createAllSupportedArrayTypes` to include `ListArray`.

### Are there any user-facing changes?

Yes.

1. Users can now create an `arrow.array.ListArray` from an `offsets` and `values` array by calling the static `arrow.array.ListArray.fromArrays(offsets, values)` method. `ListArray`s can be converted into MATLAB `cell` arrays by calling the static `arrow.array.ListArray.toMATLAB` method.

### Notes

1. We chose to use the "missing-class" `missing` value as the `NullSubstitutionValue` for the time being for `ListArray`. However, we eventually want to add `arrow.array.NullArray`, and will most likely want to use the "missing-class" `missing` value to represent `NullArray` values in MATLAB. So, this could cause some ambiguity in the future. We have been thinking about whether we should consider introducing some sort of special "sentinel value" to represent null values when converting to MATLAB `cell` arrays. Perhaps, something like `arrow.Null`, or something to that effect, in order to avoid this ambiguity. If we think it makes sense to do that, we may want to retroactively change the `NullSubstitutionValue` to be `arrow.Null` and break compatibility. Since we are still in pre-`0.1`, we don't think the impact of such a behavior change would be very large.
2. Implementing `ListArray` is fairly involved. So, in the spirit of incremental delivery, we chose not to include an implementation of `arrow.array.ListArray.fromMATLAB` in this initial pull request. We plan on following up with some more changes to `arrow.array.ListArray`. See #38353, #38354, and #38361.
3. Thank you @ sgilmore10 for your help with this pull request!

### Future Directions

1. #38353
2. #38354
3. #38361
4. Consider adding a null sentinel value like `arrow.Null` for conversion to MATLAB `cell` arrays.
* Closes: #37815

Lead-authored-by: Kevin Gurney <kgurney@mathworks.com>
Co-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/array/proxy/list_array.cc    | 103 +++++++++++
 .../cpp/arrow/matlab/array/proxy/list_array.h |  38 ++++
 .../src/cpp/arrow/matlab/array/proxy/wrap.cc  |   3 +
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 matlab/src/cpp/arrow/matlab/proxy/factory.cc  |   2 +
 matlab/src/matlab/+arrow/+array/ListArray.m   | 111 ++++++++++++
 .../+tabular/createAllSupportedArrayTypes.m   |   7 +
 .../matlab/+arrow/+type/+traits/ListTraits.m  |  10 +-
 matlab/src/matlab/+arrow/array.m              |   2 +-
 matlab/test/arrow/array/tListArray.m          | 165 ++++++++++++++++++
 matlab/test/arrow/type/traits/tListTraits.m   |  10 +-
 .../cmake/BuildMatlabArrowInterface.cmake     |   1 +
 12 files changed, 444 insertions(+), 9 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
 create mode 100644 matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
 create mode 100644 matlab/src/matlab/+arrow/+array/ListArray.m
 create mode 100644 matlab/test/arrow/array/tListArray.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
new file mode 100644
index 0000000000000..fc75e55dd6012
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
@@ -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.
+
+#include "arrow/matlab/array/proxy/list_array.h"
+#include "arrow/matlab/array/proxy/numeric_array.h"
+#include "arrow/matlab/array/proxy/wrap.h"
+#include "arrow/matlab/error/error.h"
+#include "libmexclass/proxy/ProxyManager.h"
+
+namespace arrow::matlab::array::proxy {
+
+    ListArray::ListArray(std::shared_ptr<arrow::ListArray> list_array) : proxy::Array{std::move(list_array)} {
+        REGISTER_METHOD(ListArray, getValues);
+        REGISTER_METHOD(ListArray, getOffsets);
+    }
+
+    libmexclass::proxy::MakeResult ListArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
+        namespace mda = ::matlab::data;
+        using libmexclass::proxy::ProxyManager;
+        using Int32ArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::Int32Type>;
+        using ListArrayProxy = arrow::matlab::array::proxy::ListArray;
+        using ArrayProxy = arrow::matlab::array::proxy::Array;
+
+        mda::StructArray opts = constructor_arguments[0];
+        const mda::TypedArray<uint64_t> offsets_proxy_id_mda = opts[0]["OffsetsProxyID"];
+        const mda::TypedArray<uint64_t> values_proxy_id_mda = opts[0]["ValuesProxyID"];
+        const mda::TypedArray<bool> validity_bitmap_mda = opts[0]["Valid"];
+
+        const auto offsets_proxy_id = offsets_proxy_id_mda[0];
+        const auto values_proxy_id = values_proxy_id_mda[0];
+
+        const auto offsets_proxy = std::static_pointer_cast<Int32ArrayProxy>(ProxyManager::getProxy(offsets_proxy_id));
+        const auto values_proxy = std::static_pointer_cast<ArrayProxy>(ProxyManager::getProxy(values_proxy_id));
+
+        const auto offsets = offsets_proxy->unwrap();
+        const auto values = values_proxy->unwrap();
+
+        // Pack the validity bitmap values.
+        MATLAB_ASSIGN_OR_ERROR(auto validity_bitmap_buffer,
+                               bit::packValid(validity_bitmap_mda),
+                               error::BITPACK_VALIDITY_BITMAP_ERROR_ID);
+
+        // Create a ListArray from values and offsets.
+        MATLAB_ASSIGN_OR_ERROR(auto array,
+                               arrow::ListArray::FromArrays(*offsets, *values, arrow::default_memory_pool(), validity_bitmap_buffer),
+                               error::LIST_ARRAY_FROM_ARRAYS_FAILED);
+
+        // Return a ListArray Proxy.
+        auto list_array = std::static_pointer_cast<arrow::ListArray>(array);
+        return std::make_shared<ListArrayProxy>(std::move(list_array));
+    }
+
+    void ListArray::getValues(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using libmexclass::proxy::ProxyManager;
+
+        auto list_array = std::static_pointer_cast<arrow::ListArray>(array);
+        auto value_array = list_array->values();
+
+        // Wrap the array within a proxy object if possible.
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto value_array_proxy,
+                                            proxy::wrap(value_array),
+                                            context, error::UNKNOWN_PROXY_FOR_ARRAY_TYPE);
+        const auto value_array_proxy_id = ProxyManager::manageProxy(value_array_proxy);
+        const auto type_id = value_array->type_id();
+
+        // Return a struct with two fields: ProxyID and TypeID. The MATLAB
+        // layer will use these values to construct the appropriate MATLAB
+        // arrow.array.Array subclass.
+        mda::ArrayFactory factory;
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(value_array_proxy_id);
+        output[0]["TypeID"] = factory.createScalar(static_cast<int32_t>(type_id));
+        context.outputs[0] = output;
+    }
+
+    void ListArray::getOffsets(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using libmexclass::proxy::ProxyManager;
+        using Int32ArrayProxy = arrow::matlab::array::proxy::NumericArray<arrow::Int32Type>;
+        auto list_array = std::static_pointer_cast<arrow::ListArray>(array);
+        auto offsets_array = list_array->offsets();
+        auto offsets_int32_array = std::static_pointer_cast<arrow::Int32Array>(offsets_array);
+        auto offsets_int32_array_proxy = std::make_shared<Int32ArrayProxy>(offsets_int32_array);
+        const auto offsets_int32_array_proxy_id = ProxyManager::manageProxy(offsets_int32_array_proxy);
+        mda::ArrayFactory factory;
+        context.outputs[0] = factory.createScalar(offsets_int32_array_proxy_id);
+    }
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
new file mode 100644
index 0000000000000..8db6b6bf1d632
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/matlab/array/proxy/array.h"
+
+namespace arrow::matlab::array::proxy {
+
+class ListArray : public arrow::matlab::array::proxy::Array {
+
+    public:
+        ListArray(std::shared_ptr<arrow::ListArray> list_array);
+        ~ListArray() {}
+
+        static libmexclass::proxy::MakeResult make(const libmexclass::proxy::FunctionArguments& constructor_arguments);
+
+    protected:
+        void getValues(libmexclass::proxy::method::Context& context);
+        void getOffsets(libmexclass::proxy::method::Context& context);
+
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
index b14f4b18711cb..8e300c959717a 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/wrap.cc
@@ -21,6 +21,7 @@
 #include "arrow/matlab/array/proxy/boolean_array.h"
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/string_array.h"
+#include "arrow/matlab/array/proxy/list_array.h"
 #include "arrow/matlab/array/proxy/struct_array.h"
 
 namespace arrow::matlab::array::proxy {
@@ -62,6 +63,8 @@ namespace arrow::matlab::array::proxy {
                 return std::make_shared<proxy::NumericArray<arrow::Date64Type>>(std::static_pointer_cast<arrow::Date64Array>(array));
             case ID::STRING:
                 return std::make_shared<proxy::StringArray>(std::static_pointer_cast<arrow::StringArray>(array));
+            case ID::LIST:
+                return std::make_shared<proxy::ListArray>(std::static_pointer_cast<arrow::ListArray>(array));
             case ID::STRUCT:
                 return std::make_shared<proxy::StructArray>(std::static_pointer_cast<arrow::StructArray>(array));
             default:
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 7dcecfa433567..a512fdcc89fa9 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -197,6 +197,7 @@ namespace arrow::matlab::error {
     static const char* CHUNKED_ARRAY_NUMERIC_INDEX_WITH_EMPTY_CHUNKED_ARRAY = "arrow:chunkedarray:NumericIndexWithEmptyChunkedArray";
     static const char* CHUNKED_ARRAY_INVALID_NUMERIC_CHUNK_INDEX = "arrow:chunkedarray:InvalidNumericChunkIndex";
     static const char* STRUCT_ARRAY_MAKE_FAILED = "arrow:array:StructArrayMakeFailed";
+    static const char* LIST_ARRAY_FROM_ARRAYS_FAILED = "arrow:array:ListArrayFromArraysFailed";
     static const char* INDEX_EMPTY_CONTAINER = "arrow:index:EmptyContainer";
     static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
     static const char* BUFFER_VIEW_OR_COPY_FAILED = "arrow:buffer:ViewOrCopyFailed";
diff --git a/matlab/src/cpp/arrow/matlab/proxy/factory.cc b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
index 5caf8d9fc8f2d..c3b05bec32fda 100644
--- a/matlab/src/cpp/arrow/matlab/proxy/factory.cc
+++ b/matlab/src/cpp/arrow/matlab/proxy/factory.cc
@@ -22,6 +22,7 @@
 #include "arrow/matlab/array/proxy/time32_array.h"
 #include "arrow/matlab/array/proxy/time64_array.h"
 #include "arrow/matlab/array/proxy/struct_array.h"
+#include "arrow/matlab/array/proxy/list_array.h"
 #include "arrow/matlab/array/proxy/chunked_array.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/table.h"
@@ -61,6 +62,7 @@ libmexclass::proxy::MakeResult Factory::make_proxy(const ClassName& class_name,
     REGISTER_PROXY(arrow.array.proxy.BooleanArray  , arrow::matlab::array::proxy::BooleanArray);
     REGISTER_PROXY(arrow.array.proxy.StringArray   , arrow::matlab::array::proxy::StringArray);
     REGISTER_PROXY(arrow.array.proxy.StructArray   , arrow::matlab::array::proxy::StructArray);
+    REGISTER_PROXY(arrow.array.proxy.ListArray     , arrow::matlab::array::proxy::ListArray);
     REGISTER_PROXY(arrow.array.proxy.TimestampArray, arrow::matlab::array::proxy::NumericArray<arrow::TimestampType>);
     REGISTER_PROXY(arrow.array.proxy.Time32Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time32Type>);
     REGISTER_PROXY(arrow.array.proxy.Time64Array   , arrow::matlab::array::proxy::NumericArray<arrow::Time64Type>);
diff --git a/matlab/src/matlab/+arrow/+array/ListArray.m b/matlab/src/matlab/+arrow/+array/ListArray.m
new file mode 100644
index 0000000000000..f8fd934b7c448
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/ListArray.m
@@ -0,0 +1,111 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef ListArray < arrow.array.Array
+
+    properties (Hidden, GetAccess=public, SetAccess=private)
+        NullSubstitutionValue = missing;
+    end
+
+    properties (Dependent, GetAccess=public, SetAccess=private)
+        Values
+        Offsets
+    end
+
+    methods
+        
+        function obj = ListArray(proxy)
+            arguments
+                proxy(1, 1) libmexclass.proxy.Proxy {validate(proxy, "arrow.array.proxy.ListArray")}
+            end
+            import arrow.internal.proxy.validate
+            obj@arrow.array.Array(proxy);
+        end
+
+        function values = get.Values(obj)
+            valueStruct = obj.Proxy.getValues();
+            traits = arrow.type.traits.traits(arrow.type.ID(valueStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=valueStruct.ProxyID);
+            values = traits.ArrayConstructor(proxy);
+        end
+
+        function offsets = get.Offsets(obj)
+            proxyID = obj.Proxy.getOffsets();
+            proxy = libmexclass.proxy.Proxy(Name="arrow.array.proxy.Int32Array", ID=proxyID);
+            offsets = arrow.array.Int32Array(proxy);
+        end
+
+        function matlabArray = toMATLAB(obj)
+            numElements = obj.NumElements;
+            matlabArray = cell(numElements, 1);
+
+            values = toMATLAB(obj.Values);
+            % Add one to Offsets array because MATLAB
+            % uses 1-based indexing.
+            offsets = toMATLAB(obj.Offsets) + 1;
+
+            startIndex = offsets(1);
+            for ii = 1:numElements
+                % Subtract 1 because ending offset value is exclusive.
+                endIndex = offsets(ii + 1) - 1;
+                matlabArray{ii} = values(startIndex:endIndex, :);
+                startIndex = endIndex + 1;
+            end
+
+            hasInvalid = ~all(obj.Valid);
+            if hasInvalid
+                matlabArray(~obj.Valid) = {obj.NullSubstitutionValue};
+            end
+        end
+
+    end
+
+    methods (Static)
+
+        function array = fromArrays(offsets, values, opts)
+            arguments
+                offsets (1, 1) arrow.array.Int32Array
+                values (1, 1) arrow.array.Array
+                opts.Valid
+            end
+            
+            import arrow.internal.validate.parseValid
+
+            if nargin < 2
+                error("arrow:array:list:FromArraysValuesAndOffsets", ...
+                    "Must supply both an offsets and values array to construct a ListArray.")
+            end
+
+            % Offsets should contain one more element than the number of elements in the output ListArray.
+            numElements = offsets.NumElements - 1;
+
+            validElements = parseValid(opts, numElements);
+            offsetsProxyID = offsets.Proxy.ID;
+            valuesProxyID = values.Proxy.ID;
+
+            args = struct(...
+                OffsetsProxyID=offsetsProxyID, ...
+                ValuesProxyID=valuesProxyID, ...
+                Valid=validElements ...
+            );
+            
+            proxyName = "arrow.array.proxy.ListArray";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            array = arrow.array.ListArray(proxy);
+        end
+
+    end
+
+end
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index d3a751ca46731..ad2f026d64e20 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -70,6 +70,13 @@
             stringArray = arrow.array(strings);
             arrowArrays{ii} = StructArray.fromArrays(timestampArray, stringArray);
             matlabData{ii} = table(dates, strings, VariableNames=["Field1", "Field2"]);
+        elseif name == "arrow.array.ListArray"
+            offsets = arrow.array(int32(0:opts.NumRows));
+            numbers = randomNumbers("double", opts.NumRows);
+            matlabData{ii} = num2cell(numbers);
+            values = arrow.array(numbers);
+            listArray = ListArray.fromArrays(offsets, values);
+            arrowArrays{ii} = listArray;
         else
             error("arrow:test:SupportedArrayCase", ...
                 "Missing if-branch for array class " + name); 
diff --git a/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
index c1c87790342ea..26a0c6d340603 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
@@ -16,15 +16,17 @@
 classdef ListTraits < arrow.type.traits.TypeTraits
 
     properties (Constant)
-        ArrayConstructor = missing
-        ArrayClassName = missing
-        ArrayProxyClassName = missing
+        ArrayConstructor = @arrow.array.ListArray
+        ArrayClassName = "arrow.array.ListArray"
+        ArrayProxyClassName = "arrow.array.proxy.ListArray"
         ArrayStaticConstructor = missing
         TypeConstructor = @arrow.type.ListType
         TypeClassName = "arrow.type.ListType"
         TypeProxyClassName = "arrow.type.proxy.ListType"
+        % The cell function works differently than other
+        % "type construction functions" in MATLAB.
         MatlabConstructor = missing
-        MatlabClassName = missing
+        MatlabClassName = "cell"
     end
 
 end
diff --git a/matlab/src/matlab/+arrow/array.m b/matlab/src/matlab/+arrow/array.m
index e34eb8b3fcc6c..50221b4b955df 100644
--- a/matlab/src/matlab/+arrow/array.m
+++ b/matlab/src/matlab/+arrow/array.m
@@ -62,4 +62,4 @@
     if ~ischar(data)
         data = convertCharsToStrings(data);
     end
-end
\ No newline at end of file
+end
diff --git a/matlab/test/arrow/array/tListArray.m b/matlab/test/arrow/array/tListArray.m
new file mode 100644
index 0000000000000..1ebf66e2f0999
--- /dev/null
+++ b/matlab/test/arrow/array/tListArray.m
@@ -0,0 +1,165 @@
+%TLISTARRAY Tests for arrow.array.ListArray
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tListArray < matlab.unittest.TestCase
+
+    properties (Constant)
+        Traits = arrow.type.traits.traits(arrow.type.ID.List)
+    end
+
+    properties (TestParameter)
+        TestArrowArray
+    end
+
+    methods (TestParameterDefinition, Static)
+
+        function TestArrowArray = initializeTestArrowArray()
+            %% Empty (zero-element) list (List<Float64>)
+            Type = arrow.list(arrow.float64());
+            NumElements = int64(0);
+            Valid = logical.empty(0, 1);
+            Offsets = arrow.array(int32(0));
+            Values = arrow.array([]);
+            ArrowArray = arrow.array.ListArray.fromArrays(Offsets, Values, Valid=Valid);
+            MatlabArray = {cell.empty(0, 1)};
+
+            TestArrowArray.EmptyList = struct( ...
+                ArrowArray=ArrowArray, ...
+                MatlabArray=MatlabArray, ...
+                Properties=struct(...
+                    Type=Type, ...
+                    NumElements=NumElements, ...
+                    Valid=Valid, ...
+                    Offsets=Offsets, ...
+                    Values=Values ...
+                ) ...
+            );
+
+            %% List with NULLs (List<String>)
+            Type = arrow.list(arrow.string());
+            NumElements = int64(4);
+            Valid = [true, false, true, false];
+            Offsets = arrow.array(int32([0, 1, 4, 6, 7]));
+            Values = arrow.array(["A", missing, "C", "D", "E", missing, "G"]);
+            ArrowArray = arrow.array.ListArray.fromArrays(Offsets, Values, Valid=Valid);
+            MatlabArray = {{"A"; missing; ["E"; missing]; missing}};
+
+            TestArrowArray.NullList = struct( ...
+                ArrowArray=ArrowArray, ...
+                MatlabArray=MatlabArray, ...
+                Properties=struct(...
+                    Type=Type, ...
+                    NumElements=NumElements, ...
+                    Valid=Valid, ...
+                    Offsets=Offsets, ...
+                    Values=Values ...
+                ) ...
+            );
+
+            %% Single-level list (List<Float64>)
+            Type = arrow.list(arrow.float64());
+            NumElements = int64(3);
+            Valid = true(1, NumElements);
+            Offsets = arrow.array(int32([0, 2, 5, 9]));
+            Values = arrow.array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+            ArrowArray = arrow.array.ListArray.fromArrays(Offsets, Values, Valid=Valid);
+            MatlabArray = {{[1; 2]; [3; 4; 5]; [6; 7; 8; 9]}};
+
+            TestArrowArray.SingleLevelList = struct( ...
+                ArrowArray=ArrowArray, ...
+                MatlabArray=MatlabArray, ...
+                Properties=struct(...
+                    Type=Type, ...
+                    NumElements=NumElements, ...
+                    Valid=Valid, ...
+                    Offsets=Offsets, ...
+                    Values=Values ...
+                ) ...
+            );
+
+            %% Multi-level list (List<List<Float64>>)
+            Type = arrow.list(arrow.list(arrow.float64()));
+            NumElements = int64(2);
+            Valid = true(1, NumElements);
+            Offsets = arrow.array(int32([0, 1, 3]));
+            Values = TestArrowArray.SingleLevelList.ArrowArray;
+            ArrowArray = arrow.array.ListArray.fromArrays(Offsets, Values, Valid=Valid);
+            MatlabArray = {{{[1; 2]}; {[3; 4; 5]; [6; 7; 8; 9]}}};
+
+            TestArrowArray.MultiLevelList = struct( ...
+                ArrowArray=ArrowArray, ...
+                MatlabArray=MatlabArray, ...
+                Properties=struct(...
+                    Type=Type, ...
+                    NumElements=NumElements, ...
+                    Valid=Valid, ...
+                    Offsets=Offsets, ...
+                    Values=Values ...
+                ) ...
+            );
+        end
+
+    end
+
+    methods (Test)
+
+        function TestClass(testCase, TestArrowArray)
+            % Verify that the arrow.array.Array has the expected class.
+            testCase.verifyInstanceOf(TestArrowArray.ArrowArray, testCase.Traits.ArrayClassName);
+        end
+
+        function TestProperties(testCase, TestArrowArray)
+            % Verify that all properties of the arrow.array.Array:
+            %
+            % 1. Return the expected value
+            % 2. Cannot be modified (i.e. are read-only).
+            %
+            properties = string(fieldnames(TestArrowArray.Properties));
+            for ii = numel(properties)
+                property = properties(ii);
+                expected = TestArrowArray.Properties.(property);
+                actual = getfield(TestArrowArray.ArrowArray, property);
+                % Verify that the property returns the expected value.
+                testCase.verifyEqual(actual, expected);
+                fcn = @() setfield(TestArrowArray.ArrowArray, property, "NewValue");
+                % Verify that the property cannot be modified (i.e. that it
+                % is read-only).
+                testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+            end
+        end
+
+        function TestToMatlab(testCase, TestArrowArray)
+            % Verify that the toMATLAB method returns the
+            % expected MATLAB array.
+            actual = TestArrowArray.ArrowArray.toMATLAB();
+            expected = TestArrowArray.MatlabArray;
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function TestErrorIfEmptyOffsets(testCase)
+            % Verify that an arrow:array:ListArrayFromArraysFailed error
+            % is thrown if an empty Offsets array is provided to the
+            % arrow.array.ListArray.fromArrays.
+            offsets = arrow.array(int32.empty(0, 0));
+            values = arrow.array([1, 2, 3]);
+            fcn = @() arrow.array.ListArray.fromArrays(offsets, values);
+            testCase.verifyError(fcn, "arrow:array:ListArrayFromArraysFailed");
+        end
+
+    end
+
+end
diff --git a/matlab/test/arrow/type/traits/tListTraits.m b/matlab/test/arrow/type/traits/tListTraits.m
index 93a8d8a0d10c5..444c977503123 100644
--- a/matlab/test/arrow/type/traits/tListTraits.m
+++ b/matlab/test/arrow/type/traits/tListTraits.m
@@ -17,15 +17,17 @@
 
     properties
         TraitsConstructor = @arrow.type.traits.ListTraits
-        ArrayConstructor = missing
-        ArrayClassName = missing
-        ArrayProxyClassName = missing
+        ArrayConstructor = @arrow.array.ListArray
+        ArrayClassName = "arrow.array.ListArray"
+        ArrayProxyClassName = "arrow.array.proxy.ListArray"
         ArrayStaticConstructor = missing
         TypeConstructor = @arrow.type.ListType
         TypeClassName = "arrow.type.ListType"
         TypeProxyClassName = "arrow.type.proxy.ListType"
+        % The cell function works differently than other
+        % "type construction functions" in MATLAB.
         MatlabConstructor = missing
-        MatlabClassName = missing
+        MatlabClassName = "cell"
     end
 
 end
\ No newline at end of file
diff --git a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
index c3940933679a5..cb746e08b1f8e 100644
--- a/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
+++ b/matlab/tools/cmake/BuildMatlabArrowInterface.cmake
@@ -48,6 +48,7 @@ set(MATLAB_ARROW_LIBMEXCLASS_CLIENT_PROXY_SOURCES "${CMAKE_SOURCE_DIR}/src/cpp/a
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time32_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/time64_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/struct_array.cc"
+                                                  "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/list_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/chunked_array.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/array/proxy/wrap.cc"
                                                   "${CMAKE_SOURCE_DIR}/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc"

From 6f8f34bd344c5cdf158aacb0215c3409d2996c5e Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 23 Oct 2023 09:45:26 -0700
Subject: [PATCH 605/749] GH-38254: [Java] Add reusable buffer getters to
 char/binary vectors (#38266)

### Rationale for this change
Provide a way for a user to reuse a buffer when iterating over byte-array-based ValueVectors to avoid excessive
reallocations.

### What changes are included in this PR?
Add a reusable buffer interface that can be populated by character and binary vectors to avoid allocations when consuming vector content.

Optimize getObject() on VarCharVector/LargeVarCharVector to avoid an extra allocation of a byte array (copy from ArrowBuf directly to the resulting Text).

### Are these changes tested?

### Are there any user-facing changes?

Yes.

**This PR includes breaking changes to public APIs.**

* Closes: #38254

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../ArrowFlightJdbcVarCharVectorAccessor.java |   2 +-
 .../apache/arrow/memory/ReusableBuffer.java   |  47 +++++++
 .../vector/BaseLargeVariableWidthVector.java  |  33 +++--
 .../arrow/vector/BaseVariableWidthVector.java |  27 ++--
 .../arrow/vector/FixedSizeBinaryVector.java   |  13 ++
 .../arrow/vector/LargeVarBinaryVector.java    |  23 +++-
 .../arrow/vector/LargeVarCharVector.java      |  39 ++++--
 .../apache/arrow/vector/VarBinaryVector.java  |  19 ++-
 .../apache/arrow/vector/VarCharVector.java    |  33 +++--
 .../arrow/vector/util/ReusableByteArray.java  | 129 ++++++++++++++++++
 .../org/apache/arrow/vector/util/Text.java    |  78 +----------
 .../vector/TestFixedSizeBinaryVector.java     |  16 +++
 .../vector/TestLargeVarBinaryVector.java      |  74 ++++++----
 .../arrow/vector/TestLargeVarCharVector.java  |  21 +++
 .../apache/arrow/vector/TestValueVector.java  |  44 ++++++
 .../vector/util/TestReusableByteArray.java    |  97 +++++++++++++
 16 files changed, 540 insertions(+), 155 deletions(-)
 create mode 100644 java/memory/memory-core/src/main/java/org/apache/arrow/memory/ReusableBuffer.java
 create mode 100644 java/vector/src/main/java/org/apache/arrow/vector/util/ReusableByteArray.java
 create mode 100644 java/vector/src/test/java/org/apache/arrow/vector/util/TestReusableByteArray.java

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/text/ArrowFlightJdbcVarCharVectorAccessor.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/text/ArrowFlightJdbcVarCharVectorAccessor.java
index aad8d9094c9c9..d4075bbb75ee0 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/text/ArrowFlightJdbcVarCharVectorAccessor.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/text/ArrowFlightJdbcVarCharVectorAccessor.java
@@ -200,7 +200,7 @@ public InputStream getUnicodeStream() {
 
     // Already in UTF-8
     final Text textValue = new Text(value);
-    return new ByteArrayInputStream(textValue.getBytes(), 0, textValue.getLength());
+    return new ByteArrayInputStream(textValue.getBytes(), 0, (int) textValue.getLength());
   }
 
   @Override
diff --git a/java/memory/memory-core/src/main/java/org/apache/arrow/memory/ReusableBuffer.java b/java/memory/memory-core/src/main/java/org/apache/arrow/memory/ReusableBuffer.java
new file mode 100644
index 0000000000000..3530b819aadff
--- /dev/null
+++ b/java/memory/memory-core/src/main/java/org/apache/arrow/memory/ReusableBuffer.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.memory;
+
+/**
+ * A lightweight, automatically expanding container for holding byte data.
+ * @param <T> The type of the underlying buffer.
+ */
+public interface ReusableBuffer<T> {
+  /**
+   * Get the number of valid bytes in the data.
+   *
+   * @return the number of valid bytes in the data
+   */
+  long getLength();
+
+  /**
+   * Get the buffer backing this ReusableBuffer.
+   */
+  T getBuffer();
+
+  /**
+   * Set the buffer to the contents of the given ArrowBuf.
+   * The internal buffer must resize if it cannot fit the contents
+   * of the data.
+   *
+   * @param srcBytes  the data to copy from
+   * @param start     the first position of the new data
+   * @param len       the number of bytes of the new data
+   */
+  void set(ArrowBuf srcBytes, long start, long len);
+}
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
index db922d6a70854..fcac28bd08470 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseLargeVariableWidthVector.java
@@ -180,8 +180,8 @@ public double getDensity() {
     if (valueCount == 0) {
       return 0.0D;
     }
-    final long startOffset = offsetBuffer.getLong(0);
-    final long endOffset = offsetBuffer.getLong((long) valueCount * OFFSET_WIDTH);
+    final long startOffset = getStartOffset(0);
+    final long endOffset = getStartOffset(valueCount);
     final double totalListSize = endOffset - startOffset;
     return totalListSize / valueCount;
   }
@@ -570,7 +570,7 @@ public int sizeOfValueBuffer() {
     if (valueCount == 0) {
       return 0;
     }
-    return capAtMaxInt(offsetBuffer.getLong((long) valueCount * OFFSET_WIDTH));
+    return capAtMaxInt(getStartOffset(valueCount));
   }
 
   /**
@@ -598,7 +598,7 @@ public int getBufferSizeFor(final int valueCount) {
     final long validityBufferSize = getValidityBufferSizeFromCount(valueCount);
     final long offsetBufferSize = (long) (valueCount + 1) * OFFSET_WIDTH;
     /* get the end offset for this valueCount */
-    final long dataBufferSize = offsetBuffer.getLong((long) valueCount * OFFSET_WIDTH);
+    final long dataBufferSize = getStartOffset(valueCount);
     return capAtMaxInt(validityBufferSize + offsetBufferSize + dataBufferSize);
   }
 
@@ -702,7 +702,7 @@ public TransferPair getTransferPair(BufferAllocator allocator) {
   public abstract TransferPair getTransferPair(Field field, BufferAllocator allocator);
 
   /**
-   * Transfer this vector'data to another vector. The memory associated
+   * Transfer this vector's data to another vector. The memory associated
    * with this vector is transferred to the allocator of target vector
    * for accounting and management purposes.
    * @param target destination vector for transfer
@@ -752,12 +752,12 @@ public void splitAndTransferTo(int startIndex, int length,
    * in the target vector.
    */
   private void splitAndTransferOffsetBuffer(int startIndex, int length, BaseLargeVariableWidthVector target) {
-    final long start = offsetBuffer.getLong((long) startIndex * OFFSET_WIDTH);
-    final long end = offsetBuffer.getLong((long) (startIndex + length) * OFFSET_WIDTH);
+    final long start = getStartOffset(startIndex);
+    final long end = getStartOffset(startIndex + length);
     final long dataLength = end - start;
     target.allocateOffsetBuffer((long) (length + 1) * OFFSET_WIDTH);
     for (int i = 0; i < length + 1; i++) {
-      final long relativeSourceOffset = offsetBuffer.getLong((long) (startIndex + i) * OFFSET_WIDTH) - start;
+      final long relativeSourceOffset = getStartOffset(startIndex + i) - start;
       target.offsetBuffer.setLong((long) i * OFFSET_WIDTH, relativeSourceOffset);
     }
     final ArrowBuf slicedBuffer = valueBuffer.slice(start, dataLength);
@@ -973,8 +973,7 @@ public int getValueLength(int index) {
       return 0;
     }
     final long startOffset = getStartOffset(index);
-    final int dataLength =
-        (int) (offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH) - startOffset);
+    final int dataLength = (int) (getEndOffset(index) - startOffset);
     return dataLength;
   }
 
@@ -1320,7 +1319,7 @@ public void copyFrom(int fromIndex, int thisIndex, ValueVector from) {
       final long length = end - start;
       fillHoles(thisIndex);
       BitVectorHelper.setBit(this.validityBuffer, thisIndex);
-      final long copyStart = offsetBuffer.getLong((long) thisIndex * OFFSET_WIDTH);
+      final long copyStart = getStartOffset(thisIndex);
       from.getDataBuffer().getBytes(start, this.valueBuffer, copyStart, (int) length);
       offsetBuffer.setLong((long) (thisIndex + 1) * OFFSET_WIDTH, copyStart + length);
     }
@@ -1352,7 +1351,7 @@ public void copyFromSafe(int fromIndex, int thisIndex, ValueVector from) {
       handleSafe(thisIndex, length);
       fillHoles(thisIndex);
       BitVectorHelper.setBit(this.validityBuffer, thisIndex);
-      final long copyStart = offsetBuffer.getLong((long) thisIndex * OFFSET_WIDTH);
+      final long copyStart = getStartOffset(thisIndex);
       from.getDataBuffer().getBytes(start, this.valueBuffer, copyStart, length);
       offsetBuffer.setLong((long) (thisIndex + 1) * OFFSET_WIDTH, copyStart + length);
     }
@@ -1369,8 +1368,8 @@ public ArrowBufPointer getDataPointer(int index, ArrowBufPointer reuse) {
     if (isNull(index)) {
       reuse.set(null, 0, 0);
     } else {
-      long offset = offsetBuffer.getLong((long) index * OFFSET_WIDTH);
-      int length = (int) (offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH) - offset);
+      long offset = getStartOffset(index);
+      int length = (int) (getEndOffset(index) - offset);
       reuse.set(valueBuffer, offset, length);
     }
     return reuse;
@@ -1387,7 +1386,7 @@ public int hashCode(int index, ArrowBufHasher hasher) {
       return ArrowBufPointer.NULL_HASH_CODE;
     }
     final long start = getStartOffset(index);
-    final long end = getStartOffset(index + 1);
+    final long end = getEndOffset(index);
     return ByteFunctionHelpers.hash(hasher, this.getDataBuffer(), start, end);
   }
 
@@ -1395,4 +1394,8 @@ public int hashCode(int index, ArrowBufHasher hasher) {
   public <OUT, IN> OUT accept(VectorVisitor<OUT, IN> visitor, IN value) {
     return visitor.visit(this, value);
   }
+
+  protected final long getEndOffset(int index) {
+    return offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH);
+  }
 }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
index b57dd9343824a..a0a5e085a5a8a 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/BaseVariableWidthVector.java
@@ -199,8 +199,8 @@ public double getDensity() {
     if (valueCount == 0) {
       return 0.0D;
     }
-    final int startOffset = offsetBuffer.getInt(0);
-    final int endOffset = offsetBuffer.getInt((long) valueCount * OFFSET_WIDTH);
+    final int startOffset = getStartOffset(0);
+    final int endOffset = getStartOffset(valueCount);
     final double totalListSize = endOffset - startOffset;
     return totalListSize / valueCount;
   }
@@ -791,8 +791,8 @@ public void splitAndTransferTo(int startIndex, int length,
    * in the target vector.
    */
   private void splitAndTransferOffsetBuffer(int startIndex, int length, BaseVariableWidthVector target) {
-    final int start = offsetBuffer.getInt((long) startIndex * OFFSET_WIDTH);
-    final int end = offsetBuffer.getInt((long) (startIndex + length) * OFFSET_WIDTH);
+    final int start = getStartOffset(startIndex);
+    final int end = getStartOffset(startIndex + length);
     final int dataLength = end - start;
 
     if (start == 0) {
@@ -801,7 +801,7 @@ private void splitAndTransferOffsetBuffer(int startIndex, int length, BaseVariab
     } else {
       target.allocateOffsetBuffer((long) (length + 1) * OFFSET_WIDTH);
       for (int i = 0; i < length + 1; i++) {
-        final int relativeSourceOffset = offsetBuffer.getInt((long) (startIndex + i) * OFFSET_WIDTH) - start;
+        final int relativeSourceOffset = getStartOffset(startIndex + i) - start;
         target.offsetBuffer.setInt((long) i * OFFSET_WIDTH, relativeSourceOffset);
       }
     }
@@ -1032,8 +1032,7 @@ public int getValueLength(int index) {
       return 0;
     }
     final int startOffset = getStartOffset(index);
-    final int dataLength =
-            offsetBuffer.getInt((index + 1) * OFFSET_WIDTH) - startOffset;
+    final int dataLength = getEndOffset(index) - startOffset;
     return dataLength;
   }
 
@@ -1238,7 +1237,7 @@ public void setSafe(int index, int start, int length, ArrowBuf buffer) {
     handleSafe(index, length);
     fillHoles(index);
     BitVectorHelper.setBit(validityBuffer, index);
-    final int startOffset = offsetBuffer.getInt((long) index * OFFSET_WIDTH);
+    final int startOffset = getStartOffset(index);
     offsetBuffer.setInt((long) (index + 1) * OFFSET_WIDTH, startOffset + length);
     final ArrowBuf bb = buffer.slice(start, length);
     valueBuffer.setBytes(startOffset, bb);
@@ -1375,7 +1374,7 @@ public void copyFrom(int fromIndex, int thisIndex, ValueVector from) {
       final int length = end - start;
       fillHoles(thisIndex);
       BitVectorHelper.setBit(this.validityBuffer, thisIndex);
-      final int copyStart = offsetBuffer.getInt((long) thisIndex * OFFSET_WIDTH);
+      final int copyStart = getStartOffset(thisIndex);
       from.getDataBuffer().getBytes(start, this.valueBuffer, copyStart, length);
       offsetBuffer.setInt((long) (thisIndex + 1) * OFFSET_WIDTH, copyStart + length);
     }
@@ -1398,7 +1397,7 @@ public void copyFromSafe(int fromIndex, int thisIndex, ValueVector from) {
       handleSafe(thisIndex, 0);
       fillHoles(thisIndex);
       BitVectorHelper.unsetBit(this.validityBuffer, thisIndex);
-      final int copyStart = offsetBuffer.getInt(thisIndex * OFFSET_WIDTH);
+      final int copyStart = getStartOffset(thisIndex);
       offsetBuffer.setInt((long) (thisIndex + 1) * OFFSET_WIDTH, copyStart);
     } else {
       final int start = from.getOffsetBuffer().getInt((long) fromIndex * OFFSET_WIDTH);
@@ -1407,7 +1406,7 @@ public void copyFromSafe(int fromIndex, int thisIndex, ValueVector from) {
       handleSafe(thisIndex, length);
       fillHoles(thisIndex);
       BitVectorHelper.setBit(this.validityBuffer, thisIndex);
-      final int copyStart = offsetBuffer.getInt((long) thisIndex * OFFSET_WIDTH);
+      final int copyStart = getStartOffset(thisIndex);
       from.getDataBuffer().getBytes(start, this.valueBuffer, copyStart, length);
       offsetBuffer.setInt((long) (thisIndex + 1) * OFFSET_WIDTH, copyStart + length);
     }
@@ -1424,8 +1423,8 @@ public ArrowBufPointer getDataPointer(int index, ArrowBufPointer reuse) {
     if (isNull(index)) {
       reuse.set(null, 0, 0);
     } else {
-      int offset = offsetBuffer.getInt((long) index * OFFSET_WIDTH);
-      int length = offsetBuffer.getInt((long) (index + 1) * OFFSET_WIDTH) - offset;
+      int offset = getStartOffset(index);
+      int length = getEndOffset(index) - offset;
       reuse.set(valueBuffer, offset, length);
     }
     return reuse;
@@ -1442,7 +1441,7 @@ public int hashCode(int index, ArrowBufHasher hasher) {
       return ArrowBufPointer.NULL_HASH_CODE;
     }
     final int start = getStartOffset(index);
-    final int end = getStartOffset(index + 1);
+    final int end = getEndOffset(index);
     return ByteFunctionHelpers.hash(hasher, this.getDataBuffer(), start, end);
   }
 
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
index 967d560d78dea..52c57e223476d 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/FixedSizeBinaryVector.java
@@ -21,6 +21,7 @@
 
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.ReusableBuffer;
 import org.apache.arrow.util.Preconditions;
 import org.apache.arrow.vector.complex.impl.FixedSizeBinaryReaderImpl;
 import org.apache.arrow.vector.complex.reader.FieldReader;
@@ -116,6 +117,18 @@ public byte[] get(int index) {
     return dst;
   }
 
+  /**
+   * Read the value at the given position to the given output buffer.
+   * The caller is responsible for checking for nullity first.
+   *
+   * @param index position of element.
+   * @param buffer the buffer to write into.
+   */
+  public void read(int index, ReusableBuffer<?> buffer) {
+    final int startOffset = index * byteWidth;
+    buffer.set(valueBuffer, startOffset, byteWidth);
+  }
+
   /**
    * Get the element at the given index from the vector and
    * sets the state in holder. If element at given index
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
index 6806b958dad93..0750f68f4f716 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarBinaryVector.java
@@ -18,6 +18,7 @@
 package org.apache.arrow.vector;
 
 import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.ReusableBuffer;
 import org.apache.arrow.vector.complex.impl.LargeVarBinaryReaderImpl;
 import org.apache.arrow.vector.complex.reader.FieldReader;
 import org.apache.arrow.vector.holders.LargeVarBinaryHolder;
@@ -105,13 +106,25 @@ public byte[] get(int index) {
       return null;
     }
     final long startOffset = getStartOffset(index);
-    final int dataLength =
-        (int) (offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH) - startOffset);
-    final byte[] result = new byte[dataLength];
-    valueBuffer.getBytes(startOffset, result, 0, dataLength);
+    final long dataLength = getEndOffset(index) - startOffset;
+    final byte[] result = new byte[(int) dataLength];
+    valueBuffer.getBytes(startOffset, result, 0, (int) dataLength);
     return result;
   }
 
+  /**
+   * Read the value at the given position to the given output buffer.
+   * The caller is responsible for checking for nullity first.
+   *
+   * @param index position of element.
+   * @param buffer the buffer to write into.
+   */
+  public void read(int index, ReusableBuffer<?> buffer) {
+    final long startOffset = getStartOffset(index);
+    final long dataLength = getEndOffset(index) - startOffset;
+    buffer.set(valueBuffer, startOffset, dataLength);
+  }
+
   /**
    * Get the variable length element at specified index as Text.
    *
@@ -137,7 +150,7 @@ public void get(int index, NullableLargeVarBinaryHolder holder) {
     }
     holder.isSet = 1;
     holder.start = getStartOffset(index);
-    holder.end = offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH);
+    holder.end = getEndOffset(index);
     holder.buffer = valueBuffer;
   }
 
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
index 874079a0ef83f..6f08fcb81fee1 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/LargeVarCharVector.java
@@ -17,7 +17,10 @@
 
 package org.apache.arrow.vector;
 
+import static org.apache.arrow.vector.NullCheckingForGet.NULL_CHECKING_ENABLED;
+
 import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.ReusableBuffer;
 import org.apache.arrow.vector.complex.impl.LargeVarCharReaderImpl;
 import org.apache.arrow.vector.complex.reader.FieldReader;
 import org.apache.arrow.vector.holders.LargeVarCharHolder;
@@ -106,10 +109,9 @@ public byte[] get(int index) {
       return null;
     }
     final long startOffset = getStartOffset(index);
-    final int dataLength =
-        (int) (offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH) - startOffset);
-    final byte[] result = new byte[dataLength];
-    valueBuffer.getBytes(startOffset, result, 0, dataLength);
+    final long dataLength = getEndOffset(index) - startOffset;
+    final byte[] result = new byte[(int) dataLength];
+    valueBuffer.getBytes(startOffset, result, 0, (int) dataLength);
     return result;
   }
 
@@ -120,12 +122,27 @@ public byte[] get(int index) {
    * @return Text object for non-null element, null otherwise
    */
   public Text getObject(int index) {
-    byte[] b = get(index);
-    if (b == null) {
+    assert index >= 0;
+    if (NULL_CHECKING_ENABLED && isSet(index) == 0) {
       return null;
-    } else {
-      return new Text(b);
     }
+
+    final Text result = new Text();
+    read(index, result);
+    return result;
+  }
+
+  /**
+   * Read the value at the given position to the given output buffer.
+   * The caller is responsible for checking for nullity first.
+   *
+   * @param index position of element.
+   * @param buffer the buffer to write into.
+   */
+  public void read(int index, ReusableBuffer<?> buffer) {
+    final long startOffset = getStartOffset(index);
+    final long dataLength = getEndOffset(index) - startOffset;
+    buffer.set(valueBuffer, startOffset, dataLength);
   }
 
   /**
@@ -143,7 +160,7 @@ public void get(int index, NullableLargeVarCharHolder holder) {
     }
     holder.isSet = 1;
     holder.start = getStartOffset(index);
-    holder.end = offsetBuffer.getLong((long) (index + 1) * OFFSET_WIDTH);
+    holder.end = getEndOffset(index);
     holder.buffer = valueBuffer;
   }
 
@@ -247,7 +264,7 @@ public void setSafe(int index, NullableLargeVarCharHolder holder) {
    * @param text    Text object with data
    */
   public void set(int index, Text text) {
-    set(index, text.getBytes(), 0, text.getLength());
+    set(index, text.getBytes(), 0, (int) text.getLength());
   }
 
   /**
@@ -259,7 +276,7 @@ public void set(int index, Text text) {
    * @param text    Text object with data
    */
   public void setSafe(int index, Text text) {
-    setSafe(index, text.getBytes(), 0, text.getLength());
+    setSafe(index, text.getBytes(), 0, (int) text.getLength());
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java b/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
index b43cd33d05391..87790c1168bd0 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/VarBinaryVector.java
@@ -20,6 +20,7 @@
 import static org.apache.arrow.vector.NullCheckingForGet.NULL_CHECKING_ENABLED;
 
 import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.ReusableBuffer;
 import org.apache.arrow.vector.complex.impl.VarBinaryReaderImpl;
 import org.apache.arrow.vector.complex.reader.FieldReader;
 import org.apache.arrow.vector.holders.NullableVarBinaryHolder;
@@ -106,13 +107,25 @@ public byte[] get(int index) {
       return null;
     }
     final int startOffset = getStartOffset(index);
-    final int dataLength =
-            offsetBuffer.getInt((long) (index + 1) * OFFSET_WIDTH) - startOffset;
+    final int dataLength = getEndOffset(index) - startOffset;
     final byte[] result = new byte[dataLength];
     valueBuffer.getBytes(startOffset, result, 0, dataLength);
     return result;
   }
 
+  /**
+   * Read the value at the given position to the given output buffer.
+   * The caller is responsible for checking for nullity first.
+   *
+   * @param index position of element.
+   * @param buffer the buffer to write into.
+   */
+  public void read(int index, ReusableBuffer<?> buffer) {
+    final int startOffset = getStartOffset(index);
+    final int dataLength = getEndOffset(index) - startOffset;
+    buffer.set(valueBuffer, startOffset, dataLength);
+  }
+
   /**
    * Get the variable length element at specified index as Text.
    *
@@ -138,7 +151,7 @@ public void get(int index, NullableVarBinaryHolder holder) {
     }
     holder.isSet = 1;
     holder.start = getStartOffset(index);
-    holder.end = offsetBuffer.getInt((index + 1) * OFFSET_WIDTH);
+    holder.end = getEndOffset(index);
     holder.buffer = valueBuffer;
   }
 
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
index 9ac275f75a771..7350dc99bbda8 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/VarCharVector.java
@@ -20,6 +20,7 @@
 import static org.apache.arrow.vector.NullCheckingForGet.NULL_CHECKING_ENABLED;
 
 import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.ReusableBuffer;
 import org.apache.arrow.vector.complex.impl.VarCharReaderImpl;
 import org.apache.arrow.vector.complex.reader.FieldReader;
 import org.apache.arrow.vector.holders.NullableVarCharHolder;
@@ -105,8 +106,7 @@ public byte[] get(int index) {
       return null;
     }
     final int startOffset = getStartOffset(index);
-    final int dataLength =
-            offsetBuffer.getInt((long) (index + 1) * OFFSET_WIDTH) - startOffset;
+    final int dataLength = getEndOffset(index) - startOffset;
     final byte[] result = new byte[dataLength];
     valueBuffer.getBytes(startOffset, result, 0, dataLength);
     return result;
@@ -119,12 +119,27 @@ public byte[] get(int index) {
    * @return Text object for non-null element, null otherwise
    */
   public Text getObject(int index) {
-    byte[] b = get(index);
-    if (b == null) {
+    assert index >= 0;
+    if (NULL_CHECKING_ENABLED && isSet(index) == 0) {
       return null;
-    } else {
-      return new Text(b);
     }
+
+    final Text result = new Text();
+    read(index, result);
+    return result;
+  }
+
+  /**
+   * Read the value at the given position to the given output buffer.
+   * The caller is responsible for checking for nullity first.
+   *
+   * @param index position of element.
+   * @param buffer the buffer to write into.
+   */
+  public void read(int index, ReusableBuffer<?> buffer) {
+    final int startOffset = getStartOffset(index);
+    final int dataLength = getEndOffset(index) - startOffset;
+    buffer.set(valueBuffer, startOffset, dataLength);
   }
 
   /**
@@ -142,7 +157,7 @@ public void get(int index, NullableVarCharHolder holder) {
     }
     holder.isSet = 1;
     holder.start = getStartOffset(index);
-    holder.end = offsetBuffer.getInt((index + 1) * OFFSET_WIDTH);
+    holder.end = getEndOffset(index);
     holder.buffer = valueBuffer;
   }
 
@@ -247,7 +262,7 @@ public void setSafe(int index, NullableVarCharHolder holder) {
    * @param text    Text object with data
    */
   public void set(int index, Text text) {
-    set(index, text.getBytes(), 0, text.getLength());
+    set(index, text.getBytes(), 0, (int) text.getLength());
   }
 
   /**
@@ -259,7 +274,7 @@ public void set(int index, Text text) {
    * @param text    Text object with data
    */
   public void setSafe(int index, Text text) {
-    setSafe(index, text.getBytes(), 0, text.getLength());
+    setSafe(index, text.getBytes(), 0, (int) text.getLength());
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/ReusableByteArray.java b/java/vector/src/main/java/org/apache/arrow/vector/util/ReusableByteArray.java
new file mode 100644
index 0000000000000..d938cd833a41a
--- /dev/null
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/ReusableByteArray.java
@@ -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.
+ */
+
+package org.apache.arrow.vector.util;
+
+import java.util.Arrays;
+import java.util.Base64;
+
+import org.apache.arrow.memory.ArrowBuf;
+import org.apache.arrow.memory.ReusableBuffer;
+
+/**
+ * A wrapper around byte arrays for repeated writing.
+ */
+public class ReusableByteArray implements ReusableBuffer<byte[]> {
+
+  protected static final byte[] EMPTY_BYTES = new byte[0];
+
+  protected byte[] bytes;
+  protected int length;
+
+  public ReusableByteArray() {
+    bytes = EMPTY_BYTES;
+  }
+
+  public ReusableByteArray(byte[] data) {
+    bytes = Arrays.copyOfRange(data, 0, data.length);
+    length = data.length;
+  }
+
+  /**
+   * Get the number of bytes in the byte array.
+   *
+   * @return the number of bytes in the byte array
+   */
+  @Override
+  public long getLength() {
+    return length;
+  }
+
+  @Override
+  public byte[] getBuffer() {
+    return bytes;
+  }
+
+  @Override
+  public void set(ArrowBuf srcBytes, long start, long len) {
+    setCapacity((int) len, false);
+    srcBytes.getBytes(start, bytes, 0, (int) len);
+    length = (int) len;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (o == this) {
+      return true;
+    } else if (o == null) {
+      return false;
+    }
+    if (!(o instanceof ReusableByteArray)) {
+      return false;
+    }
+
+    final ReusableByteArray that = (ReusableByteArray) o;
+    if (this.getLength() != that.getLength()) {
+      return false;
+    }
+
+    for (int i = 0; i < length; i++) {
+      if (bytes[i] != that.bytes[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    if (bytes == null) {
+      return 0;
+    }
+
+    int result = 1;
+    for (int i = 0; i < length; i++) {
+      result = 31 * result + bytes[i];
+    }
+
+    return result;
+  }
+
+  @Override
+  public String toString() {
+    return Base64.getEncoder().encodeToString(Arrays.copyOfRange(bytes, 0, length));
+  }
+
+  /**
+   * Sets the capacity of this object to <em>at least</em> <code>len</code> bytes. If the
+   * current buffer is longer, then the capacity and existing content of the buffer are unchanged.
+   * If <code>len</code> is larger than the current capacity, the Text object's capacity is
+   * increased to match.
+   *
+   * @param len      the number of bytes we need
+   * @param keepData should the old data be kept
+   */
+  protected void setCapacity(int len, boolean keepData) {
+    if (bytes == null || bytes.length < len) {
+      if (bytes != null && keepData) {
+        bytes = Arrays.copyOf(bytes, Math.max(len, length << 1));
+      } else {
+        bytes = new byte[len];
+      }
+    }
+  }
+}
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java b/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
index 778af0ca956df..5f5f5d3bd6d22 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/Text.java
@@ -29,7 +29,6 @@
 import java.nio.charset.MalformedInputException;
 import java.text.CharacterIterator;
 import java.text.StringCharacterIterator;
-import java.util.Arrays;
 import java.util.Optional;
 
 import com.fasterxml.jackson.core.JsonGenerationException;
@@ -43,7 +42,7 @@
  * Lifted from Hadoop 2.7.1
  */
 @JsonSerialize(using = Text.TextSerializer.class)
-public class Text {
+public class Text extends ReusableByteArray {
 
   private static ThreadLocal<CharsetEncoder> ENCODER_FACTORY =
       new ThreadLocal<CharsetEncoder>() {
@@ -65,13 +64,9 @@ protected CharsetDecoder initialValue() {
         }
       };
 
-  private static final byte[] EMPTY_BYTES = new byte[0];
-
-  private byte[] bytes;
-  private int length;
 
   public Text() {
-    bytes = EMPTY_BYTES;
+    super();
   }
 
   /**
@@ -123,15 +118,6 @@ public byte[] getBytes() {
     return bytes;
   }
 
-  /**
-   * Get the number of bytes in the byte array.
-   *
-   * @return the number of bytes in the byte array
-   */
-  public int getLength() {
-    return length;
-  }
-
   /**
    * Returns the Unicode Scalar Value (32-bit integer value) for the character at
    * <code>position</code>. Note that this method avoids using the converter or doing String
@@ -238,7 +224,7 @@ public void set(byte[] utf8) {
    * @param other the text to initialize from
    */
   public void set(Text other) {
-    set(other.getBytes(), 0, other.getLength());
+    set(other.getBytes(), 0, (int) other.getLength());
   }
 
   /**
@@ -278,25 +264,6 @@ public void clear() {
     length = 0;
   }
 
-  /**
-   * Sets the capacity of this Text object to <em>at least</em> <code>len</code> bytes. If the
-   * current buffer is longer, then the capacity and existing content of the buffer are unchanged.
-   * If <code>len</code> is larger than the current capacity, the Text object's capacity is
-   * increased to match.
-   *
-   * @param len      the number of bytes we need
-   * @param keepData should the old data be kept
-   */
-  private void setCapacity(int len, boolean keepData) {
-    if (bytes == null || bytes.length < len) {
-      if (bytes != null && keepData) {
-        bytes = Arrays.copyOf(bytes, Math.max(len, length << 1));
-      } else {
-        bytes = new byte[len];
-      }
-    }
-  }
-
   @Override
   public String toString() {
     try {
@@ -322,47 +289,10 @@ public void readWithKnownLength(DataInput in, int len) throws IOException {
 
   @Override
   public boolean equals(Object o) {
-    if (o == this) {
-      return true;
-    } else if (o == null) {
-      return false;
-    }
     if (!(o instanceof Text)) {
       return false;
     }
-
-    final Text that = (Text) o;
-    if (this.getLength() != that.getLength()) {
-      return false;
-    }
-
-    // copied from Arrays.equals so we don'thave to copy the byte arrays
-    for (int i = 0; i < length; i++) {
-      if (bytes[i] != that.bytes[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Copied from Arrays.hashCode so we don't have to copy the byte array.
-   *
-   * @return hashCode
-   */
-  @Override
-  public int hashCode() {
-    if (bytes == null) {
-      return 0;
-    }
-
-    int result = 1;
-    for (int i = 0; i < length; i++) {
-      result = 31 * result + bytes[i];
-    }
-
-    return result;
+    return super.equals(o);
   }
 
   // / STATIC UTILITIES FROM HERE DOWN
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeBinaryVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeBinaryVector.java
index c413f4e23ebc3..b9cd89e4ad731 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeBinaryVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeBinaryVector.java
@@ -24,6 +24,7 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.vector.holders.FixedSizeBinaryHolder;
 import org.apache.arrow.vector.holders.NullableFixedSizeBinaryHolder;
+import org.apache.arrow.vector.util.ReusableByteArray;
 import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Before;
@@ -286,4 +287,19 @@ public void testGetTransferPairWithField() {
     // Field inside a new vector created by reusing a field should be the same in memory as the original field.
     assertSame(fromVector.getField(), toVector.getField());
   }
+
+  @Test
+  public void testGetBytesRepeatedly() {
+    for (int i = 0; i < numValues; i++) {
+      vector.set(i, values[i]);
+    }
+    vector.setValueCount(numValues);
+
+    ReusableByteArray reusableByteArray = new ReusableByteArray();
+    for (int i = 0; i < numValues; i++) {
+      // verify results
+      vector.read(i, reusableByteArray);
+      assertArrayEquals(values[i], reusableByteArray.getBuffer());
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
index ce7bb15bb1482..ecababde8de3a 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarBinaryVector.java
@@ -17,14 +17,18 @@
 
 package org.apache.arrow.vector;
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
+import java.util.Arrays;
+
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.vector.holders.NullableLargeVarBinaryHolder;
+import org.apache.arrow.vector.util.ReusableByteArray;
 import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Before;
@@ -56,21 +60,20 @@ public void testSetNullableLargeVarBinaryHolder() {
       binHolder.isSet = 1;
 
       String str = "hello";
-      ArrowBuf buf = allocator.buffer(16);
-      buf.setBytes(0, str.getBytes());
-
-      binHolder.start = 0;
-      binHolder.end = str.length();
-      binHolder.buffer = buf;
+      try (ArrowBuf buf = allocator.buffer(16)) {
+        buf.setBytes(0, str.getBytes());
 
-      vector.set(0, nullHolder);
-      vector.set(1, binHolder);
+        binHolder.start = 0;
+        binHolder.end = str.length();
+        binHolder.buffer = buf;
 
-      // verify results
-      assertTrue(vector.isNull(0));
-      assertEquals(str, new String(vector.get(1)));
+        vector.set(0, nullHolder);
+        vector.set(1, binHolder);
 
-      buf.close();
+        // verify results
+        assertTrue(vector.isNull(0));
+        assertEquals(str, new String(vector.get(1)));
+      }
     }
   }
 
@@ -86,21 +89,46 @@ public void testSetNullableLargeVarBinaryHolderSafe() {
       binHolder.isSet = 1;
 
       String str = "hello world";
-      ArrowBuf buf = allocator.buffer(16);
-      buf.setBytes(0, str.getBytes());
+      try (ArrowBuf buf = allocator.buffer(16)) {
+        buf.setBytes(0, str.getBytes());
 
-      binHolder.start = 0;
-      binHolder.end = str.length();
-      binHolder.buffer = buf;
+        binHolder.start = 0;
+        binHolder.end = str.length();
+        binHolder.buffer = buf;
 
-      vector.setSafe(0, binHolder);
-      vector.setSafe(1, nullHolder);
+        vector.setSafe(0, binHolder);
+        vector.setSafe(1, nullHolder);
 
-      // verify results
-      assertEquals(str, new String(vector.get(0)));
-      assertTrue(vector.isNull(1));
+        // verify results
+        assertEquals(str, new String(vector.get(0)));
+        assertTrue(vector.isNull(1));
+      }
+    }
+  }
 
-      buf.close();
+  @Test
+  public void testGetBytesRepeatedly() {
+    try (LargeVarBinaryVector vector = new LargeVarBinaryVector("", allocator)) {
+      vector.allocateNew(5, 1);
+
+      final String str = "hello world";
+      final String str2 = "foo";
+      vector.setSafe(0, str.getBytes());
+      vector.setSafe(1, str2.getBytes());
+
+      // verify results
+      ReusableByteArray reusableByteArray = new ReusableByteArray();
+      vector.read(0, reusableByteArray);
+      byte[] oldBuffer = reusableByteArray.getBuffer();
+      assertArrayEquals(str.getBytes(), Arrays.copyOfRange(reusableByteArray.getBuffer(),
+          0, (int) reusableByteArray.getLength()));
+
+      vector.read(1, reusableByteArray);
+      assertArrayEquals(str2.getBytes(), Arrays.copyOfRange(reusableByteArray.getBuffer(),
+          0, (int) reusableByteArray.getLength()));
+
+      // There should not have been any reallocation since the newer value is smaller in length.
+      assertSame(oldBuffer, reusableByteArray.getBuffer());
     }
   }
 
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
index 5f7863c6f6177..7d074c393648f 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestLargeVarCharVector.java
@@ -38,6 +38,7 @@
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.arrow.vector.util.OversizedAllocationException;
+import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Assert;
@@ -795,6 +796,26 @@ public void testNullableType() {
     }
   }
 
+  @Test
+  public void testGetTextRepeatedly() {
+    try (final LargeVarCharVector vector = new LargeVarCharVector("myvector", allocator)) {
+
+      ValueVectorDataPopulator.setVector(vector, STR1, STR2);
+      vector.setValueCount(2);
+
+      /* check the vector output */
+      Text text = new Text();
+      vector.read(0, text);
+      byte[] result = new byte[(int) text.getLength()];
+      System.arraycopy(text.getBytes(), 0, result, 0, (int) text.getLength());
+      assertArrayEquals(STR1, result);
+      vector.read(1, text);
+      result = new byte[(int) text.getLength()];
+      System.arraycopy(text.getBytes(), 0, result, 0, (int) text.getLength());
+      assertArrayEquals(STR2, text.getBytes());
+    }
+  }
+
   @Test
   public void testGetTransferPairWithField() {
     try (BufferAllocator childAllocator1 = allocator.newChildAllocator("child1", 1000000, 1000000);
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java
index 0928d3eb03082..fb96870804441 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java
@@ -25,6 +25,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import java.nio.ByteBuffer;
@@ -56,6 +57,7 @@
 import org.apache.arrow.vector.holders.NullableVarBinaryHolder;
 import org.apache.arrow.vector.holders.NullableVarCharHolder;
 import org.apache.arrow.vector.ipc.message.ArrowRecordBatch;
+import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
 import org.apache.arrow.vector.types.Types;
 import org.apache.arrow.vector.types.Types.MinorType;
 import org.apache.arrow.vector.types.pojo.ArrowType;
@@ -63,6 +65,7 @@
 import org.apache.arrow.vector.types.pojo.FieldType;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.arrow.vector.util.OversizedAllocationException;
+import org.apache.arrow.vector.util.ReusableByteArray;
 import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
@@ -1107,6 +1110,22 @@ public void testNullableVarType1() {
     }
   }
 
+  @Test
+  public void testGetTextRepeatedly() {
+    try (final VarCharVector vector = new VarCharVector("myvector", allocator)) {
+
+      ValueVectorDataPopulator.setVector(vector, STR1, STR2);
+      vector.setValueCount(2);
+
+      /* check the vector output */
+      Text text = new Text();
+      vector.read(0, text);
+      assertArrayEquals(STR1, text.getBytes());
+      vector.read(1, text);
+      assertArrayEquals(STR2, text.getBytes());
+    }
+  }
+
   @Test /* VarBinaryVector */
   public void testNullableVarType2() {
 
@@ -1156,6 +1175,31 @@ public void testReallocateCheckSuccess() {
     }
   }
 
+  @Test
+  public void testGetBytesRepeatedly() {
+    try (VarBinaryVector vector = new VarBinaryVector("", allocator)) {
+      vector.allocateNew(5, 1);
+
+      final String str = "hello world";
+      final String str2 = "foo";
+      vector.setSafe(0, str.getBytes());
+      vector.setSafe(1, str2.getBytes());
+
+      // verify results
+      ReusableByteArray reusableByteArray = new ReusableByteArray();
+      vector.read(0, reusableByteArray);
+      assertArrayEquals(str.getBytes(), Arrays.copyOfRange(reusableByteArray.getBuffer(),
+          0, (int) reusableByteArray.getLength()));
+      byte[] oldBuffer = reusableByteArray.getBuffer();
+
+      vector.read(1, reusableByteArray);
+      assertArrayEquals(str2.getBytes(), Arrays.copyOfRange(reusableByteArray.getBuffer(),
+          0, (int) reusableByteArray.getLength()));
+
+      // There should not have been any reallocation since the newer value is smaller in length.
+      assertSame(oldBuffer, reusableByteArray.getBuffer());
+    }
+  }
 
   /*
    * generic tests
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/util/TestReusableByteArray.java b/java/vector/src/test/java/org/apache/arrow/vector/util/TestReusableByteArray.java
new file mode 100644
index 0000000000000..b11aa5638d651
--- /dev/null
+++ b/java/vector/src/test/java/org/apache/arrow/vector/util/TestReusableByteArray.java
@@ -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.
+ */
+
+package org.apache.arrow.vector.util;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Base64;
+
+import org.apache.arrow.memory.ArrowBuf;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.BaseValueVector;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class TestReusableByteArray {
+
+  private BufferAllocator allocator;
+
+  @Before
+  public void prepare() {
+    // Permit allocating 4 vectors of max size.
+    allocator = new RootAllocator(4 * BaseValueVector.MAX_ALLOCATION_SIZE);
+  }
+
+  @After
+  public void shutdown() {
+    allocator.close();
+  }
+
+  @Test
+  public void testSetByteArrayRepeatedly() {
+    ReusableByteArray byteArray = new ReusableByteArray();
+    try (ArrowBuf workingBuf = allocator.buffer(100)) {
+      final String str = "test";
+      workingBuf.setBytes(0, str.getBytes());
+      byteArray.set(workingBuf, 0, str.getBytes().length);
+      assertEquals(str.getBytes().length, byteArray.getLength());
+      assertArrayEquals(str.getBytes(), Arrays.copyOfRange(byteArray.getBuffer(), 0, (int) byteArray.getLength()));
+      assertEquals(Base64.getEncoder().encodeToString(str.getBytes()), byteArray.toString());
+      assertEquals(new ReusableByteArray(str.getBytes()), byteArray);
+      assertEquals(new ReusableByteArray(str.getBytes()).hashCode(), byteArray.hashCode());
+
+      // Test a longer string. Should require reallocation.
+      final String str2 = "test_longer";
+      byte[] oldBuffer = byteArray.getBuffer();
+      workingBuf.clear();
+      workingBuf.setBytes(0, str2.getBytes());
+      byteArray.set(workingBuf, 0, str2.getBytes().length);
+      assertEquals(str2.getBytes().length, byteArray.getLength());
+      assertArrayEquals(str2.getBytes(), Arrays.copyOfRange(byteArray.getBuffer(), 0, (int) byteArray.getLength()));
+      assertEquals(Base64.getEncoder().encodeToString(str2.getBytes()), byteArray.toString());
+      assertEquals(new ReusableByteArray(str2.getBytes()), byteArray);
+      assertEquals(new ReusableByteArray(str2.getBytes()).hashCode(), byteArray.hashCode());
+
+      // Verify reallocation needed.
+      assertNotSame(oldBuffer, byteArray.getBuffer());
+      assertTrue(byteArray.getBuffer().length > oldBuffer.length);
+
+      // Test writing a shorter string. Should not require reallocation.
+      final String str3 = "short";
+      oldBuffer = byteArray.getBuffer();
+      workingBuf.clear();
+      workingBuf.setBytes(0, str3.getBytes());
+      byteArray.set(workingBuf, 0, str3.getBytes().length);
+      assertEquals(str3.getBytes().length, byteArray.getLength());
+      assertArrayEquals(str3.getBytes(), Arrays.copyOfRange(byteArray.getBuffer(), 0, (int) byteArray.getLength()));
+      assertEquals(Base64.getEncoder().encodeToString(str3.getBytes()), byteArray.toString());
+      assertEquals(new ReusableByteArray(str3.getBytes()), byteArray);
+      assertEquals(new ReusableByteArray(str3.getBytes()).hashCode(), byteArray.hashCode());
+
+      // Verify reallocation was not needed.
+      assertSame(oldBuffer, byteArray.getBuffer());
+    }
+  }
+}

From e1f11ba629384ec6e42cd76267e02f84a4dbeab9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:55:20 +0900
Subject: [PATCH 606/749] MINOR: [CI] Bump actions/setup-node from 3 to 4
 (#38406)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [actions/setup-node](https://github.com/actions/setup-node) from 3 to 4.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/actions/setup-node/releases">actions/setup-node's releases</a>.</em></p>
<blockquote>
<h2>v4.0.0</h2>
<h2>What's Changed</h2>
<p>In scope of this release we changed version of node runtime for action from node16 to node20 and updated dependencies in <a href="https://redirect.github.com/actions/setup-node/pull/866">actions/setup-node#866</a></p>
<p>Besides, release contains such changes as:</p>
<ul>
<li>Upgrade actions/checkout to v4 by <a href="https://github.com/gmembre-zenika"><code>@​gmembre-zenika</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/868">actions/setup-node#868</a></li>
<li>Update actions/checkout for documentation and yaml by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/876">actions/setup-node#876</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/gmembre-zenika"><code>@​gmembre-zenika</code></a> made their first contribution in <a href="https://redirect.github.com/actions/setup-node/pull/868">actions/setup-node#868</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/setup-node/compare/v3...v4.0.0">https://github.com/actions/setup-node/compare/v3...v4.0.0</a></p>
<h2>v3.8.2</h2>
<h2>What's Changed</h2>
<ul>
<li>Update semver by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/861">actions/setup-node#861</a></li>
<li>Update temp directory creation by <a href="https://github.com/nikolai-laevskii"><code>@​nikolai-laevskii</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/859">actions/setup-node#859</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.15.4 to 7.23.2 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/870">actions/setup-node#870</a></li>
<li>Add notice about binaries not being updated yet by <a href="https://github.com/nikolai-laevskii"><code>@​nikolai-laevskii</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/872">actions/setup-node#872</a></li>
<li>Update toolkit cache and core by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> and <a href="https://github.com/seongwon-privatenote"><code>@​seongwon-privatenote</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/875">actions/setup-node#875</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/setup-node/compare/v3...v3.8.2">https://github.com/actions/setup-node/compare/v3...v3.8.2</a></p>
<h2>v3.8.1</h2>
<h2>What's Changed</h2>
<p>In scope of this release, the filter was removed within the cache-save step by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/831">actions/setup-node#831</a>. It is filtered and checked in the toolkit/cache library.</p>
<p><strong>Full Changelog</strong>: <a href="https://github.com/actions/setup-node/compare/v3...v3.8.1">https://github.com/actions/setup-node/compare/v3...v3.8.1</a></p>
<h2>v3.8.0</h2>
<h2>What's Changed</h2>
<h3>Bug fixes:</h3>
<ul>
<li>Add check for existing paths by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/803">actions/setup-node#803</a></li>
<li>Resolve SymbolicLink by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/809">actions/setup-node#809</a></li>
<li>Change passing logic for cache input by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/816">actions/setup-node#816</a></li>
<li>Fix armv7 cache issue by <a href="https://github.com/louislam"><code>@​louislam</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/794">actions/setup-node#794</a></li>
<li>Update check-dist workflow name by <a href="https://github.com/sinchang"><code>@​sinchang</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/710">actions/setup-node#710</a></li>
</ul>
<h3>Feature implementations:</h3>
<ul>
<li>feat: handling the case where &quot;node&quot; is used for tool-versions file. by <a href="https://github.com/xytis"><code>@​xytis</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/812">actions/setup-node#812</a></li>
</ul>
<h3>Documentation changes:</h3>
<ul>
<li>Refer to semver package name in README.md by <a href="https://github.com/olleolleolle"><code>@​olleolleolle</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/808">actions/setup-node#808</a></li>
</ul>
<h3>Update dependencies:</h3>
<ul>
<li>Update toolkit cache to fix zstd by <a href="https://github.com/dmitry-shibanov"><code>@​dmitry-shibanov</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/804">actions/setup-node#804</a></li>
<li>Bump tough-cookie and <code>@​azure/ms-rest-js</code> by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/802">actions/setup-node#802</a></li>
<li>Bump semver from 6.1.2 to 6.3.1 by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/actions/setup-node/pull/807">actions/setup-node#807</a></li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/actions/setup-node/commit/8f152de45cc393bb48ce5d89d36b731f54556e65"><code>8f152de</code></a> Update actions/checkout for documentation and yaml (<a href="https://redirect.github.com/actions/setup-node/issues/876">#876</a>)</li>
<li><a href="https://github.com/actions/setup-node/commit/23755b521f87533c8ed7f8fb13674f9021579e34"><code>23755b5</code></a> upgrade actions/checkout to v4 (<a href="https://redirect.github.com/actions/setup-node/issues/868">#868</a>)</li>
<li><a href="https://github.com/actions/setup-node/commit/54534a2a9ba7308e8a8995af3104899e6a95b681"><code>54534a2</code></a> Change node version for action to node20 (<a href="https://redirect.github.com/actions/setup-node/issues/866">#866</a>)</li>
<li>See full diff in <a href="https://github.com/actions/setup-node/compare/v3...v4">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=actions/setup-node&package-manager=github_actions&previous-version=3&new-version=4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .github/workflows/js.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/js.yml b/.github/workflows/js.yml
index 9be11596d845f..781b2023e2f42 100644
--- a/.github/workflows/js.yml
+++ b/.github/workflows/js.yml
@@ -97,7 +97,7 @@ jobs:
           key: js-jest-cache-${{ runner.os }}-${{ hashFiles('js/src/**/*.ts', 'js/test/**/*.ts', 'js/yarn.lock') }}
           restore-keys: js-jest-cache-${{ runner.os }}-
       - name: Install NodeJS
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
       - name: Build
@@ -127,7 +127,7 @@ jobs:
           key: js-jest-cache-${{ runner.os }}-${{ hashFiles('js/src/**/*.ts', 'js/test/**/*.ts', 'js/yarn.lock') }}
           restore-keys: js-jest-cache-${{ runner.os }}-
       - name: Install NodeJS
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node }}
       - name: Build

From 22d8e08f6961997d8846e2ba660cf6f36a723eaf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:55:53 +0900
Subject: [PATCH 607/749] MINOR: [C#] Bump Grpc.AspNetCore from 2.57.0 to
 2.58.0 in /csharp (#38407)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore](https://github.com/grpc/grpc-dotnet) from 2.57.0 to 2.58.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore's releases</a>.</em></p>
<blockquote>
<h2>Release v2.58.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.58 development cycle. by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2267">grpc/grpc-dotnet#2267</a></li>
<li>Update ServiceBinderBase.AddMethod annotations to allow null handler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2270">grpc/grpc-dotnet#2270</a></li>
<li>Add request and channel to call debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2271">grpc/grpc-dotnet#2271</a></li>
<li>Support disabling load balancing with SocketsHttpHandler.Properties by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2274">grpc/grpc-dotnet#2274</a></li>
<li>Remove netstandard1.5 from some projects by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2279">grpc/grpc-dotnet#2279</a></li>
<li>Add debugger display to Status by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2281">grpc/grpc-dotnet#2281</a></li>
<li>Fix detecting inherited WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2288">grpc/grpc-dotnet#2288</a></li>
<li>Dispose socket after connection failure by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2287">grpc/grpc-dotnet#2287</a></li>
<li>Bump GrpcToolsPackageVersion to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2290">grpc/grpc-dotnet#2290</a></li>
<li>Bump version to pre1 on 2.58 branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2291">grpc/grpc-dotnet#2291</a></li>
<li>Update v2.58.x branch to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2299">grpc/grpc-dotnet#2299</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/002368bbca9bb1411aab277acf84b1d73d1a44b0"><code>002368b</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2299">#2299</a> from apolcyn/update_it</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c2f0c5822471168c0b58ee06fae0ee3ae877424d"><code>c2f0c58</code></a> update 2.58.x branch to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/38ab095ea1462fc646590d5ec168fe00334aaac9"><code>38ab095</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2291">#2291</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a90b3de004bc76553afaa40dacbf150a28ef4840"><code>a90b3de</code></a> bump to pre1 on 2.58 branch</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/683fbdfa5ce725a4bb0574a71dbf1a3c08ddcc38"><code>683fbdf</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2290">#2290</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bad41ff5709d515274c5e408cd3823103c03fc44"><code>bad41ff</code></a> bump GrpcToolsPackageVersion to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/207e8066f3ed2f6c656e565c07c746e282f54ff4"><code>207e806</code></a> Dispose socket after connection failure (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2287">#2287</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/97f6fbd3fe749b9cdff109659d91f30987b8ec54"><code>97f6fbd</code></a> Fix detecting inherited WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2288">#2288</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7e62218646dfe16ef0a98802886bb6a7f5507a80"><code>7e62218</code></a> Add debugger display to Status (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2281">#2281</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/46480fca2fccddb3391cf267004f281afe87571d"><code>46480fc</code></a> Remove netstandard1.5 from some projects (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2279">#2279</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore&package-manager=nuget&previous-version=2.57.0&new-version=2.58.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.TestWeb.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
index ce46466bd6ca5..81468deea6c09 100644
--- a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
+++ b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.57.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.58.0" />
   </ItemGroup>
 
   <ItemGroup>

From ce6c2c16db1c6bf002c5f8533367567f4326b781 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:56:36 +0900
Subject: [PATCH 608/749] MINOR: [C#] Bump Grpc.AspNetCore.Server from 2.57.0
 to 2.58.0 in /csharp (#38408)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore.Server](https://github.com/grpc/grpc-dotnet) from 2.57.0 to 2.58.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore.Server's releases</a>.</em></p>
<blockquote>
<h2>Release v2.58.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.58 development cycle. by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2267">grpc/grpc-dotnet#2267</a></li>
<li>Update ServiceBinderBase.AddMethod annotations to allow null handler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2270">grpc/grpc-dotnet#2270</a></li>
<li>Add request and channel to call debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2271">grpc/grpc-dotnet#2271</a></li>
<li>Support disabling load balancing with SocketsHttpHandler.Properties by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2274">grpc/grpc-dotnet#2274</a></li>
<li>Remove netstandard1.5 from some projects by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2279">grpc/grpc-dotnet#2279</a></li>
<li>Add debugger display to Status by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2281">grpc/grpc-dotnet#2281</a></li>
<li>Fix detecting inherited WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2288">grpc/grpc-dotnet#2288</a></li>
<li>Dispose socket after connection failure by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2287">grpc/grpc-dotnet#2287</a></li>
<li>Bump GrpcToolsPackageVersion to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2290">grpc/grpc-dotnet#2290</a></li>
<li>Bump version to pre1 on 2.58 branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2291">grpc/grpc-dotnet#2291</a></li>
<li>Update v2.58.x branch to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2299">grpc/grpc-dotnet#2299</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/002368bbca9bb1411aab277acf84b1d73d1a44b0"><code>002368b</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2299">#2299</a> from apolcyn/update_it</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c2f0c5822471168c0b58ee06fae0ee3ae877424d"><code>c2f0c58</code></a> update 2.58.x branch to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/38ab095ea1462fc646590d5ec168fe00334aaac9"><code>38ab095</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2291">#2291</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a90b3de004bc76553afaa40dacbf150a28ef4840"><code>a90b3de</code></a> bump to pre1 on 2.58 branch</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/683fbdfa5ce725a4bb0574a71dbf1a3c08ddcc38"><code>683fbdf</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2290">#2290</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bad41ff5709d515274c5e408cd3823103c03fc44"><code>bad41ff</code></a> bump GrpcToolsPackageVersion to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/207e8066f3ed2f6c656e565c07c746e282f54ff4"><code>207e806</code></a> Dispose socket after connection failure (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2287">#2287</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/97f6fbd3fe749b9cdff109659d91f30987b8ec54"><code>97f6fbd</code></a> Fix detecting inherited WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2288">#2288</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7e62218646dfe16ef0a98802886bb6a7f5507a80"><code>7e62218</code></a> Add debugger display to Status (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2281">#2281</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/46480fca2fccddb3391cf267004f281afe87571d"><code>46480fc</code></a> Remove netstandard1.5 from some projects (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2279">#2279</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore.Server&package-manager=nuget&previous-version=2.57.0&new-version=2.58.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.AspNetCore.csproj                       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
index 845f2667970e4..47d7e9746dea1 100644
--- a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
+++ b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.57.0" />
+    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.58.0" />
   </ItemGroup>
 
   <ItemGroup>

From 6e321a79b1ee797a6b6c8724838ab7d1dcb5e787 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:56:59 +0900
Subject: [PATCH 609/749] MINOR: [C#] Bump Grpc.Tools from 2.58.0 to 2.59.0 in
 /csharp (#38409)

Bumps [Grpc.Tools](https://github.com/grpc/grpc) from 2.58.0 to 2.59.0.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/grpc/grpc/commits">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Tools&package-manager=nuget&previous-version=2.58.0&new-version=2.59.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj  | 2 +-
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
index 4f785971b2849..f04acf3a4c7e2 100644
--- a/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
+++ b/csharp/src/Apache.Arrow.Flight.Sql/Apache.Arrow.Flight.Sql.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.59.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 633e61f90aecc..12b0bfdada89d 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -7,7 +7,7 @@
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.4" />
     <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
-    <PackageReference Include="Grpc.Tools" Version="2.58.0" PrivateAssets="All" />
+    <PackageReference Include="Grpc.Tools" Version="2.59.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">

From 7661c399c3eaba189638fbd380d2d513261d6357 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:57:21 +0900
Subject: [PATCH 610/749] MINOR: [C#] Bump xunit from 2.5.2 to 2.5.3 in /csharp
 (#38410)

Bumps [xunit](https://github.com/xunit/xunit) from 2.5.2 to 2.5.3.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/161ce40d656a92fe3dda826a98c742310c7c55a1"><code>161ce40</code></a> v2.5.3</li>
<li><a href="https://github.com/xunit/xunit/commit/b8bfb82f89ea697d7b5c7961100b61bc0bd82ff6"><code>b8bfb82</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2795">#2795</a>: Collection equality regression with custom comparer on sequence type (...</li>
<li><a href="https://github.com/xunit/xunit/commit/644d65e557a398317d54b6228abf2b79b887c12d"><code>644d65e</code></a> Use <code>is null</code> and <code>is not null</code> in assertion tests</li>
<li><a href="https://github.com/xunit/xunit/commit/2457cf147e0dca6e34a15a43ada9298201005b93"><code>2457cf1</code></a> Bump up to v2.5.3-pre</li>
<li>See full diff in <a href="https://github.com/xunit/xunit/compare/2.5.2...2.5.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.5.2&new-version=2.5.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 44c6ef4e98238..e63c27d022c24 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.2" />
+    <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 2839911a61d18..ed67fafbf8c72 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -7,7 +7,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-      <PackageReference Include="xunit" Version="2.5.2" />
+      <PackageReference Include="xunit" Version="2.5.3" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index 5029e3696f14f..e4e3c053f943d 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.2" />
+    <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 2d705323425fd..2835c60da414f 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.2" />
+    <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

From 7f9df29fed08c2a5b6593d2bfc62ffb812bc60ea Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 04:57:45 +0900
Subject: [PATCH 611/749] MINOR: [C#] Bump ZstdSharp.Port from 0.7.2 to 0.7.3
 in /csharp (#38412)

Bumps [ZstdSharp.Port](https://github.com/oleg-st/ZstdSharp) from 0.7.2 to 0.7.3.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/oleg-st/ZstdSharp/releases">ZstdSharp.Port's releases</a>.</em></p>
<blockquote>
<h2>0.7.3</h2>
<p>Improved compatibility with Mono and .NET Native</p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/26c25793cad1bdd82223437f4ceb3ea31708465d"><code>26c2579</code></a> 0.7.3</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/3b271630d5bfc48ff034592bbe501da5c9aa08c7"><code>3b27163</code></a> Converted some object initializations to constructors (.NET Native workaround)</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/3767e20b3c73f3dec048eec42cf6f569c9fb15ea"><code>3767e20</code></a> Hide function pointers (.NET Native / Mono / .NET Framework workarounds)</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/dcd8af0d88486bbefd05b6eaaab6823979089069"><code>dcd8af0</code></a> Array initialization optimization for .NET 7/8</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/cd7c9a9c64ecc5790284e063297a93d95cfb10d1"><code>cd7c9a9</code></a> memcmp simplified</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/be37b8f95dd5f0edd93a604e2dff671d70789983"><code>be37b8f</code></a> Bounded macro simplified</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/b1f90a760d63c29c3fad64d5c657cc0949fb01dd"><code>b1f90a7</code></a> Private/readonly fields</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/43f985313c1be1087249f6552c58fe5bd04f4e22"><code>43f9853</code></a> Reworked access to artificial fixed buffer fields</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/4ea7b5a6de2c168b9bb842f6677f86d7fd71391d"><code>4ea7b5a</code></a> Hide symbols that zstd does not export</li>
<li><a href="https://github.com/oleg-st/ZstdSharp/commit/cd0c35bd774a55beb8aa10dd4aa68980967cade4"><code>cd0c35b</code></a> Added TrainFromBufferFastCover method</li>
<li>See full diff in <a href="https://github.com/oleg-st/ZstdSharp/compare/0.7.2...0.7.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=ZstdSharp.Port&package-manager=nuget&previous-version=0.7.2&new-version=0.7.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression/Apache.Arrow.Compression.csproj    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
index 47c99436ba604..fded62911262c 100644
--- a/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
+++ b/csharp/src/Apache.Arrow.Compression/Apache.Arrow.Compression.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.6" />
-    <PackageReference Include="ZstdSharp.Port" Version="0.7.2" />
+    <PackageReference Include="ZstdSharp.Port" Version="0.7.3" />
   </ItemGroup>
 
   <ItemGroup>

From be175de53dee488681d9b9eb8612ab2afae8414d Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Mon, 23 Oct 2023 18:17:24 -0300
Subject: [PATCH 612/749] GH-38401: [C++] Re-generate flatbuffers C++ for
 Skyhook (#38405)

### Rationale for this change

Vendored flatbuffer headers have been upgraded so the checked-in flatc-generated files need to be upgraded.

### What changes are included in this PR?

 - Changes to the shell script that re-generates flatbuffers
 - Check-in of the newly generated `ScanRequest_generated.h`

### Are these changes tested?

By integration tests.
* Closes: #38401

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/build-support/update-flatbuffers.sh       | 11 +--
 .../skyhook/protocol/ScanRequest_generated.h  | 85 ++++++++++---------
 2 files changed, 53 insertions(+), 43 deletions(-)

diff --git a/cpp/build-support/update-flatbuffers.sh b/cpp/build-support/update-flatbuffers.sh
index 8d952751ba7f8..a27d947a4b07a 100755
--- a/cpp/build-support/update-flatbuffers.sh
+++ b/cpp/build-support/update-flatbuffers.sh
@@ -27,13 +27,14 @@ SOURCE_DIR="$CWD/../src"
 PYTHON_SOURCE_DIR="$CWD/../../python"
 FORMAT_DIR="$CWD/../../format"
 TOP="$FORMAT_DIR/.."
-FLATC="flatc"
+FLATC="flatc --cpp --cpp-std c++11 --scoped-enums"
 
 OUT_DIR="$SOURCE_DIR/generated"
 FILES=($(find $FORMAT_DIR -name '*.fbs'))
 FILES+=("$SOURCE_DIR/arrow/ipc/feather.fbs")
 
-$FLATC --cpp --cpp-std c++11 \
-  --scoped-enums \
-  -o "$OUT_DIR" \
-  "${FILES[@]}"
+$FLATC -o "$OUT_DIR" "${FILES[@]}"
+
+# Skyhook flatbuffers
+$FLATC -o "$SOURCE_DIR/skyhook/protocol" \
+  "$SOURCE_DIR/skyhook/protocol/ScanRequest.fbs"
diff --git a/cpp/src/skyhook/protocol/ScanRequest_generated.h b/cpp/src/skyhook/protocol/ScanRequest_generated.h
index 884857a1b4df7..ecf6ff72e1540 100644
--- a/cpp/src/skyhook/protocol/ScanRequest_generated.h
+++ b/cpp/src/skyhook/protocol/ScanRequest_generated.h
@@ -6,14 +6,23 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
 namespace org {
 namespace apache {
 namespace arrow {
 namespace flatbuf {
 
 struct ScanRequest;
+struct ScanRequestBuilder;
 
-struct ScanRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+struct ScanRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef ScanRequestBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_FILE_SIZE = 4,
     VT_FILE_FORMAT = 6,
@@ -28,22 +37,22 @@ struct ScanRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   int16_t file_format() const {
     return GetField<int16_t>(VT_FILE_FORMAT, 0);
   }
-  const flatbuffers::Vector<uint8_t> *filter() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_FILTER);
+  const ::flatbuffers::Vector<uint8_t> *filter() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_FILTER);
   }
-  const flatbuffers::Vector<uint8_t> *partition() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PARTITION);
+  const ::flatbuffers::Vector<uint8_t> *partition() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PARTITION);
   }
-  const flatbuffers::Vector<uint8_t> *dataset_schema() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATASET_SCHEMA);
+  const ::flatbuffers::Vector<uint8_t> *dataset_schema() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATASET_SCHEMA);
   }
-  const flatbuffers::Vector<uint8_t> *projection_schema() const {
-    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PROJECTION_SCHEMA);
+  const ::flatbuffers::Vector<uint8_t> *projection_schema() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PROJECTION_SCHEMA);
   }
-  bool Verify(flatbuffers::Verifier &verifier) const {
+  bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int64_t>(verifier, VT_FILE_SIZE) &&
-           VerifyField<int16_t>(verifier, VT_FILE_FORMAT) &&
+           VerifyField<int64_t>(verifier, VT_FILE_SIZE, 8) &&
+           VerifyField<int16_t>(verifier, VT_FILE_FORMAT, 2) &&
            VerifyOffset(verifier, VT_FILTER) &&
            verifier.VerifyVector(filter()) &&
            VerifyOffset(verifier, VT_PARTITION) &&
@@ -57,46 +66,46 @@ struct ScanRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
 };
 
 struct ScanRequestBuilder {
-  flatbuffers::FlatBufferBuilder &fbb_;
-  flatbuffers::uoffset_t start_;
+  typedef ScanRequest Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
   void add_file_size(int64_t file_size) {
     fbb_.AddElement<int64_t>(ScanRequest::VT_FILE_SIZE, file_size, 0);
   }
   void add_file_format(int16_t file_format) {
     fbb_.AddElement<int16_t>(ScanRequest::VT_FILE_FORMAT, file_format, 0);
   }
-  void add_filter(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> filter) {
+  void add_filter(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> filter) {
     fbb_.AddOffset(ScanRequest::VT_FILTER, filter);
   }
-  void add_partition(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> partition) {
+  void add_partition(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> partition) {
     fbb_.AddOffset(ScanRequest::VT_PARTITION, partition);
   }
-  void add_dataset_schema(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> dataset_schema) {
+  void add_dataset_schema(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dataset_schema) {
     fbb_.AddOffset(ScanRequest::VT_DATASET_SCHEMA, dataset_schema);
   }
-  void add_projection_schema(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> projection_schema) {
+  void add_projection_schema(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> projection_schema) {
     fbb_.AddOffset(ScanRequest::VT_PROJECTION_SCHEMA, projection_schema);
   }
-  explicit ScanRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit ScanRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ScanRequestBuilder &operator=(const ScanRequestBuilder &);
-  flatbuffers::Offset<ScanRequest> Finish() {
+  ::flatbuffers::Offset<ScanRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
-    auto o = flatbuffers::Offset<ScanRequest>(end);
+    auto o = ::flatbuffers::Offset<ScanRequest>(end);
     return o;
   }
 };
 
-inline flatbuffers::Offset<ScanRequest> CreateScanRequest(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ScanRequest> CreateScanRequest(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t file_size = 0,
     int16_t file_format = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> filter = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> partition = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> dataset_schema = 0,
-    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> projection_schema = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> filter = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> partition = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> dataset_schema = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> projection_schema = 0) {
   ScanRequestBuilder builder_(_fbb);
   builder_.add_file_size(file_size);
   builder_.add_projection_schema(projection_schema);
@@ -107,8 +116,8 @@ inline flatbuffers::Offset<ScanRequest> CreateScanRequest(
   return builder_.Finish();
 }
 
-inline flatbuffers::Offset<ScanRequest> CreateScanRequestDirect(
-    flatbuffers::FlatBufferBuilder &_fbb,
+inline ::flatbuffers::Offset<ScanRequest> CreateScanRequestDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
     int64_t file_size = 0,
     int16_t file_format = 0,
     const std::vector<uint8_t> *filter = nullptr,
@@ -130,32 +139,32 @@ inline flatbuffers::Offset<ScanRequest> CreateScanRequestDirect(
 }
 
 inline const org::apache::arrow::flatbuf::ScanRequest *GetScanRequest(const void *buf) {
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::ScanRequest>(buf);
+  return ::flatbuffers::GetRoot<org::apache::arrow::flatbuf::ScanRequest>(buf);
 }
 
 inline const org::apache::arrow::flatbuf::ScanRequest *GetSizePrefixedScanRequest(const void *buf) {
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::ScanRequest>(buf);
+  return ::flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::ScanRequest>(buf);
 }
 
 inline bool VerifyScanRequestBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifyBuffer<org::apache::arrow::flatbuf::ScanRequest>(nullptr);
 }
 
 inline bool VerifySizePrefixedScanRequestBuffer(
-    flatbuffers::Verifier &verifier) {
+    ::flatbuffers::Verifier &verifier) {
   return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::ScanRequest>(nullptr);
 }
 
 inline void FinishScanRequestBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::ScanRequest> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::ScanRequest> root) {
   fbb.Finish(root);
 }
 
 inline void FinishSizePrefixedScanRequestBuffer(
-    flatbuffers::FlatBufferBuilder &fbb,
-    flatbuffers::Offset<org::apache::arrow::flatbuf::ScanRequest> root) {
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<org::apache::arrow::flatbuf::ScanRequest> root) {
   fbb.FinishSizePrefixed(root);
 }
 

From 6bb51b4f9c2285dc92b9a3a10cc0def82c299c47 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 24 Oct 2023 09:16:19 +0900
Subject: [PATCH 613/749] MINOR: [C#] Bump Grpc.Net.Client from 2.57.0 to
 2.58.0 in /csharp (#38411)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.Net.Client](https://github.com/grpc/grpc-dotnet) from 2.57.0 to 2.58.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.Net.Client's releases</a>.</em></p>
<blockquote>
<h2>Release v2.58.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Start 2.58 development cycle. by <a href="https://github.com/jtattermusch"><code>@​jtattermusch</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2267">grpc/grpc-dotnet#2267</a></li>
<li>Update ServiceBinderBase.AddMethod annotations to allow null handler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2270">grpc/grpc-dotnet#2270</a></li>
<li>Add request and channel to call debugging by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2271">grpc/grpc-dotnet#2271</a></li>
<li>Support disabling load balancing with SocketsHttpHandler.Properties by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2274">grpc/grpc-dotnet#2274</a></li>
<li>Remove netstandard1.5 from some projects by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2279">grpc/grpc-dotnet#2279</a></li>
<li>Add debugger display to Status by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2281">grpc/grpc-dotnet#2281</a></li>
<li>Fix detecting inherited WinHttpHandler by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2288">grpc/grpc-dotnet#2288</a></li>
<li>Dispose socket after connection failure by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2287">grpc/grpc-dotnet#2287</a></li>
<li>Bump GrpcToolsPackageVersion to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2290">grpc/grpc-dotnet#2290</a></li>
<li>Bump version to pre1 on 2.58 branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2291">grpc/grpc-dotnet#2291</a></li>
<li>Update v2.58.x branch to 2.58.0 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2299">grpc/grpc-dotnet#2299</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/002368bbca9bb1411aab277acf84b1d73d1a44b0"><code>002368b</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2299">#2299</a> from apolcyn/update_it</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/c2f0c5822471168c0b58ee06fae0ee3ae877424d"><code>c2f0c58</code></a> update 2.58.x branch to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/38ab095ea1462fc646590d5ec168fe00334aaac9"><code>38ab095</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2291">#2291</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/a90b3de004bc76553afaa40dacbf150a28ef4840"><code>a90b3de</code></a> bump to pre1 on 2.58 branch</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/683fbdfa5ce725a4bb0574a71dbf1a3c08ddcc38"><code>683fbdf</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2290">#2290</a> from apolcyn/bump_deps</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/bad41ff5709d515274c5e408cd3823103c03fc44"><code>bad41ff</code></a> bump GrpcToolsPackageVersion to 2.58.0</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/207e8066f3ed2f6c656e565c07c746e282f54ff4"><code>207e806</code></a> Dispose socket after connection failure (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2287">#2287</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/97f6fbd3fe749b9cdff109659d91f30987b8ec54"><code>97f6fbd</code></a> Fix detecting inherited WinHttpHandler (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2288">#2288</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/7e62218646dfe16ef0a98802886bb6a7f5507a80"><code>7e62218</code></a> Add debugger display to Status (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2281">#2281</a>)</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/46480fca2fccddb3391cf267004f281afe87571d"><code>46480fc</code></a> Remove netstandard1.5 from some projects (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2279">#2279</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.57.0...v2.58.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Net.Client&package-manager=nuget&previous-version=2.57.0&new-version=2.58.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 12b0bfdada89d..d771aebd96796 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -6,7 +6,7 @@
   
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.24.4" />
-    <PackageReference Include="Grpc.Net.Client" Version="2.57.0" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.58.0" />
     <PackageReference Include="Grpc.Tools" Version="2.59.0" PrivateAssets="All" />
   </ItemGroup>
 

From c8c74851313a322ac668dda4d51b274d6a40dbd1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Tue, 24 Oct 2023 04:51:22 +0200
Subject: [PATCH 614/749] GH-38307: [CI] Remove gemfury_clean.rb (#38308)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

wheel-clean nightly job is currently failing. As seen on ADBC: https://github.com/apache/arrow-adbc/issues/1085 gemfury seems to have stopped supporting removing via API.

### What changes are included in this PR?

Do not remove old wheels on gemfury anymore. If we reach quota related issues we can re-create the package on pyarrow as suggested on the comments: https://github.com/apache/arrow/pull/38308#issuecomment-1769767770

### Are these changes tested?

No, we are deleting the CI job that fails.

### Are there any user-facing changes?

No
* Closes: #38307

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/gemfury_clean.rb              | 42 ------------------------
 dev/tasks/python-wheels/github.clean.yml | 35 --------------------
 dev/tasks/tasks.yml                      |  4 ---
 3 files changed, 81 deletions(-)
 delete mode 100644 ci/scripts/gemfury_clean.rb
 delete mode 100644 dev/tasks/python-wheels/github.clean.yml

diff --git a/ci/scripts/gemfury_clean.rb b/ci/scripts/gemfury_clean.rb
deleted file mode 100644
index d14891e66e5a7..0000000000000
--- a/ci/scripts/gemfury_clean.rb
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# Clean old releases from Gemfury.
-
-require "gemfury"
-
-client = Gemfury::Client.new(user_api_key: ENV["GEMFURY_API_TOKEN"])
-
-client.list.each do |artifact|
-  puts artifact["name"]
-  versions = client.versions(artifact["name"])
-  versions.sort_by! { |v| v["created_at"] }
-
-  # Keep all versions uploaded within 90 days of the last uploaded version
-  cutoff = DateTime.parse(versions.last['created_at']) - 90.0
-
-  versions.each do |version|
-    time = DateTime.parse(version['created_at'])
-    if time < cutoff
-      client.yank_version(artifact["name"], version["version"])
-      puts "Yanked #{artifact['name']} #{version['version']} (created #{version['created_at']})"
-    else
-      puts "Kept #{artifact['name']} #{version['version']} (created #{version['created_at']})"
-    end
-  end
-end
diff --git a/dev/tasks/python-wheels/github.clean.yml b/dev/tasks/python-wheels/github.clean.yml
deleted file mode 100644
index eae9510ec08ac..0000000000000
--- a/dev/tasks/python-wheels/github.clean.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-{% import 'macros.jinja' as macros with context %}
-
-{{ macros.github_header() }}
-
-jobs:
-  build:
-    name: "Clean old wheels"
-    runs-on: ubuntu-latest
-    steps:
-      {{ macros.github_checkout_arrow()|indent }}
-
-      - name: Clean old wheels
-        env:
-          GEMFURY_API_TOKEN: {{ '${{ secrets.CROSSBOW_GEMFURY_API_TOKEN }}' }}
-        shell: bash
-        run: |
-          gem install --user-install gemfury
-          ruby arrow/ci/scripts/gemfury_clean.rb
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 326c94558a9c2..33050c1de5da8 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -460,10 +460,6 @@ tasks:
       - pyarrow-{no_rc_version}-py310(h[a-z0-9]+)_0_cuda.conda
       - pyarrow-{no_rc_version}-py311(h[a-z0-9]+)_0_cuda.conda
 
-  wheel-clean:
-    ci: github
-    template: python-wheels/github.clean.yml
-
 {% for python_version, python_tag, abi_tag in [("3.8", "cp38", "cp38"),
                                                ("3.9", "cp39", "cp39"),
                                                ("3.10", "cp310", "cp310"),

From 5b9f4b976118052824c5aeaa2220886839b6f4be Mon Sep 17 00:00:00 2001
From: Judah Rand <17158624+judahrand@users.noreply.github.com>
Date: Tue, 24 Oct 2023 07:31:42 +0100
Subject: [PATCH 615/749] MINOR: [Python] Add docs for missing type checking
 functions (#38119)

### Rationale for this change

These appear to be missing and I only found them by accident!

### What changes are included in this PR?

### Are these changes tested?

### Are there any user-facing changes?

Authored-by: Judah Rand <17158624+judahrand@users.noreply.github.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 docs/source/python/api/datatypes.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/source/python/api/datatypes.rst b/docs/source/python/api/datatypes.rst
index 0b3f5e2d5609e..4066ef314234d 100644
--- a/docs/source/python/api/datatypes.rst
+++ b/docs/source/python/api/datatypes.rst
@@ -142,8 +142,11 @@ represents a given data type (such as ``int32``) or general category
    is_float32
    is_float64
    is_decimal
+   is_decimal128
+   is_decimal256
    is_list
    is_large_list
+   is_fixed_size_list
    is_struct
    is_union
    is_nested
@@ -156,6 +159,8 @@ represents a given data type (such as ``int32``) or general category
    is_time
    is_time32
    is_time64
+   is_duration
+   is_interval
    is_null
    is_binary
    is_unicode
@@ -166,3 +171,4 @@ represents a given data type (such as ``int32``) or general category
    is_fixed_size_binary
    is_map
    is_dictionary
+   is_primitive

From e3d6b9beac6924fd6914940eb74b248a5167f05b Mon Sep 17 00:00:00 2001
From: Jeremy Aguilon <jeraguilon@gmail.com>
Date: Tue, 24 Oct 2023 09:22:01 -0400
Subject: [PATCH 616/749] GH-37796: [C++][Acero] Fix race condition caused by
 straggling input in the as-of-join node (#37839)

### Rationale for this change

### What changes are included in this PR?

While asofjoining some large parquet datasets with many row groups, I ran into a deadlock that I described here: https://github.com/apache/arrow/issues/37796. Copy pasting below for convenience:

1. The left hand side of the asofjoin completes and is matched with the right hand tables, so `InputFinished` proceeds as [expected](https://github.com/apache/arrow/blob/2455bc07e09cd5341d1fabdb293afbd07682f0b2/cpp/src/arrow/acero/asof_join_node.cc#L1323). So far so good
2. The right hand table(s) of the join are a huge dataset scan. They're still streaming and can legally still call `AsofJoinNode::InputReceived` all they want ([doc ref](https://arrow.apache.org/docs/cpp/api/acero.html#_CPPv4N5arrow5acero8ExecNode13InputReceivedEP8ExecNode9ExecBatch))
3. Each input batch is blindly pushed to the `InputState`s, which in turn defer to `BackpressureHandler`s to decide whether to pause inputs. ([code pointer](https://github.com/apache/arrow/blob/2455bc07e09cd5341d1fabdb293afbd07682f0b2/cpp/src/arrow/acero/asof_join_node.cc#L1689))
4. If enough batches come in right after `EndFromProcessThread` is called, then we might exceed the [high_threshold](https://github.com/apache/arrow/blob/2455bc07e09cd5341d1fabdb293afbd07682f0b2/cpp/src/arrow/acero/asof_join_node.cc#L575) and tell the input node to pause via the [BackpressureController](https://github.com/apache/arrow/blob/2455bc07e09cd5341d1fabdb293afbd07682f0b2/cpp/src/arrow/acero/asof_join_node.cc#L540)
5. At this point, the process thread has stopped for the asofjoiner, so the right hand table(s) won't be dequeue'd, meaning `BackpressureController::Resume()` will never be called. This causes a [deadlock](https://arrow.apache.org/docs/cpp/api/acero.html#_CPPv4N5arrow5acero19BackpressureControl5PauseEv)

TLDR this is caused by a straggling input node being paused due to backpressure _after_ the process thread has ended. And since every `PauseInput` needs a corresponding `ResumeInput` to exit gracefully, we deadlock.

Turns out this is fairly easy to reproduce with small tables, if you make a slow input node composed of 1-row record batches with a synthetic delay.

My solution is to:

1. Create a `ForceShutdown` hook that puts the input nodes in a resumed state, and for good measure we call `StopProducing`
2. Also for good measure, if nodes come after the process thread exits, we short circuit and return OK. This is because `InputReceived` can be called an arbitrary number of times after `StopProducing`, so it makes sense to not enqueue useless batches.

### Are these changes tested?

Yes, I added a delay to the batches of one of the already-existing asofjoin backpressure tests. Checkout out `main`, we get a timeout failure. With my changes, it passes.

I considered a more deterministic test, but I struggled to create callbacks in a way that wasn't invasive to the Asof implementation. The idea of using delays was inspired by things I saw in `source_node_test.cc`

<!--
We typically require tests for all PRs in order to:
1. Prevent the code from being accidentally broken by subsequent changes
3. Serve as another way to document the expected behavior of the code

### Are there any user-facing changes?

No

* Closes: #37796

Lead-authored-by: Jeremy Aguilon <jeraguilon@gmail.com>
Co-authored-by: Jeremy Aguilon <jaguilon@hudson-trading.com>
Co-authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/acero/asof_join_node.cc      | 45 ++++++++++++++---
 cpp/src/arrow/acero/asof_join_node_test.cc | 56 ++++++++++++++--------
 2 files changed, 74 insertions(+), 27 deletions(-)

diff --git a/cpp/src/arrow/acero/asof_join_node.cc b/cpp/src/arrow/acero/asof_join_node.cc
index 23c07b8acb95f..d19d2db299cba 100644
--- a/cpp/src/arrow/acero/asof_join_node.cc
+++ b/cpp/src/arrow/acero/asof_join_node.cc
@@ -549,15 +549,16 @@ class BackpressureController : public BackpressureControl {
 
 class BackpressureHandler {
  private:
-  BackpressureHandler(size_t low_threshold, size_t high_threshold,
+  BackpressureHandler(ExecNode* input, size_t low_threshold, size_t high_threshold,
                       std::unique_ptr<BackpressureControl> backpressure_control)
-      : low_threshold_(low_threshold),
+      : input_(input),
+        low_threshold_(low_threshold),
         high_threshold_(high_threshold),
         backpressure_control_(std::move(backpressure_control)) {}
 
  public:
   static Result<BackpressureHandler> Make(
-      size_t low_threshold, size_t high_threshold,
+      ExecNode* input, size_t low_threshold, size_t high_threshold,
       std::unique_ptr<BackpressureControl> backpressure_control) {
     if (low_threshold >= high_threshold) {
       return Status::Invalid("low threshold (", low_threshold,
@@ -566,7 +567,7 @@ class BackpressureHandler {
     if (backpressure_control == NULLPTR) {
       return Status::Invalid("null backpressure control parameter");
     }
-    BackpressureHandler backpressure_handler(low_threshold, high_threshold,
+    BackpressureHandler backpressure_handler(input, low_threshold, high_threshold,
                                              std::move(backpressure_control));
     return std::move(backpressure_handler);
   }
@@ -579,7 +580,16 @@ class BackpressureHandler {
     }
   }
 
+  Status ForceShutdown() {
+    // It may be unintuitive to call Resume() here, but this is to avoid a deadlock.
+    // Since acero's executor won't terminate if any one node is paused, we need to
+    // force resume the node before stopping production.
+    backpressure_control_->Resume();
+    return input_->StopProducing();
+  }
+
  private:
+  ExecNode* input_;
   size_t low_threshold_;
   size_t high_threshold_;
   std::unique_ptr<BackpressureControl> backpressure_control_;
@@ -629,6 +639,8 @@ class BackpressureConcurrentQueue : public ConcurrentQueue<T> {
     return ConcurrentQueue<T>::TryPopUnlocked();
   }
 
+  Status ForceShutdown() { return handler_.ForceShutdown(); }
+
  private:
   BackpressureHandler handler_;
 };
@@ -672,9 +684,9 @@ class InputState {
     std::unique_ptr<BackpressureControl> backpressure_control =
         std::make_unique<BackpressureController>(
             /*node=*/asof_input, /*output=*/asof_node, backpressure_counter);
-    ARROW_ASSIGN_OR_RAISE(auto handler,
-                          BackpressureHandler::Make(low_threshold, high_threshold,
-                                                    std::move(backpressure_control)));
+    ARROW_ASSIGN_OR_RAISE(
+        auto handler, BackpressureHandler::Make(asof_input, low_threshold, high_threshold,
+                                                std::move(backpressure_control)));
     return std::make_unique<InputState>(index, tolerance, must_hash, may_rehash,
                                         key_hasher, asof_node, std::move(handler), schema,
                                         time_col_index, key_col_index);
@@ -930,6 +942,12 @@ class InputState {
     total_batches_ = n;
   }
 
+  Status ForceShutdown() {
+    // Force the upstream input node to unpause. Necessary to avoid deadlock when we
+    // terminate the process thread
+    return queue_.ForceShutdown();
+  }
+
  private:
   // Pending record batches. The latest is the front. Batches cannot be empty.
   BackpressureConcurrentQueue<std::shared_ptr<RecordBatch>> queue_;
@@ -1323,6 +1341,9 @@ class AsofJoinNode : public ExecNode {
           if (st.ok()) {
             st = output_->InputFinished(this, batches_produced_);
           }
+          for (const auto& s : state_) {
+            st &= s->ForceShutdown();
+          }
         }));
   }
 
@@ -1679,6 +1700,15 @@ class AsofJoinNode : public ExecNode {
   const Ordering& ordering() const override { return ordering_; }
 
   Status InputReceived(ExecNode* input, ExecBatch batch) override {
+    // InputReceived may be called after execution was finished. Pushing it to the
+    // InputState is unnecessary since we're done (and anyway may cause the
+    // BackPressureController to pause the input, causing a deadlock), so drop it.
+    if (process_task_.is_finished()) {
+      DEBUG_SYNC(this, "Input received while done. Short circuiting.",
+                 DEBUG_MANIP(std::endl));
+      return Status::OK();
+    }
+
     // Get the input
     ARROW_DCHECK(std_has(inputs_, input));
     size_t k = std_find(inputs_, input) - inputs_.begin();
@@ -1687,6 +1717,7 @@ class AsofJoinNode : public ExecNode {
     auto rb = *batch.ToRecordBatch(input->output_schema());
     DEBUG_SYNC(this, "received batch from input ", k, ":", DEBUG_MANIP(std::endl),
                rb->ToString(), DEBUG_MANIP(std::endl));
+
     ARROW_RETURN_NOT_OK(state_.at(k)->Push(rb));
     process_.Push(true);
     return Status::OK();
diff --git a/cpp/src/arrow/acero/asof_join_node_test.cc b/cpp/src/arrow/acero/asof_join_node_test.cc
index 96c00e6a4bd59..df3172b2a09bc 100644
--- a/cpp/src/arrow/acero/asof_join_node_test.cc
+++ b/cpp/src/arrow/acero/asof_join_node_test.cc
@@ -1424,7 +1424,8 @@ AsyncGenerator<std::optional<ExecBatch>> GetGen(BatchesWithSchema bws) {
 }
 
 template <typename BatchesMaker>
-void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
+void TestBackpressure(BatchesMaker maker, int batch_size, int num_l_batches,
+                      int num_r0_batches, int num_r1_batches, bool slow_r0) {
   auto l_schema =
       schema({field("time", int32()), field("key", int32()), field("l_value", int32())});
   auto r0_schema =
@@ -1432,16 +1433,17 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
   auto r1_schema =
       schema({field("time", int32()), field("key", int32()), field("r1_value", int32())});
 
-  auto make_shift = [&maker, num_batches, batch_size](
-                        const std::shared_ptr<Schema>& schema, int shift) {
+  auto make_shift = [&maker, batch_size](int num_batches,
+                                         const std::shared_ptr<Schema>& schema,
+                                         int shift) {
     return maker({[](int row) -> int64_t { return row; },
                   [num_batches](int row) -> int64_t { return row / num_batches; },
                   [shift](int row) -> int64_t { return row * 10 + shift; }},
                  schema, num_batches, batch_size);
   };
-  ASSERT_OK_AND_ASSIGN(auto l_batches, make_shift(l_schema, 0));
-  ASSERT_OK_AND_ASSIGN(auto r0_batches, make_shift(r0_schema, 1));
-  ASSERT_OK_AND_ASSIGN(auto r1_batches, make_shift(r1_schema, 2));
+  ASSERT_OK_AND_ASSIGN(auto l_batches, make_shift(num_l_batches, l_schema, 0));
+  ASSERT_OK_AND_ASSIGN(auto r0_batches, make_shift(num_r0_batches, r0_schema, 1));
+  ASSERT_OK_AND_ASSIGN(auto r1_batches, make_shift(num_r1_batches, r1_schema, 2));
 
   BackpressureCountingNode::Register();
   RegisterTestNodes();  // for GatedNode
@@ -1449,6 +1451,7 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
   struct BackpressureSourceConfig {
     std::string name_prefix;
     bool is_gated;
+    bool is_delayed;
     std::shared_ptr<Schema> schema;
     decltype(l_batches) batches;
 
@@ -1463,9 +1466,9 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
 
   // Two ungated and one gated
   std::vector<BackpressureSourceConfig> source_configs = {
-      {"0", false, l_schema, l_batches},
-      {"1", true, r0_schema, r0_batches},
-      {"2", false, r1_schema, r1_batches},
+      {"0", false, false, l_schema, l_batches},
+      {"1", true, slow_r0, r0_schema, r0_batches},
+      {"2", false, false, r1_schema, r1_batches},
   };
 
   std::vector<BackpressureCounters> bp_counters(source_configs.size());
@@ -1474,9 +1477,16 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
   std::vector<Declaration::Input> bp_decls;
   for (size_t i = 0; i < source_configs.size(); i++) {
     const auto& config = source_configs[i];
-
-    src_decls.emplace_back("source",
-                           SourceNodeOptions(config.schema, GetGen(config.batches)));
+    if (config.is_delayed) {
+      src_decls.emplace_back(
+          "source",
+          SourceNodeOptions(config.schema, MakeDelayedGen(config.batches, "slow_source",
+                                                          /*delay_sec=*/0.5,
+                                                          /*noisy=*/false)));
+    } else {
+      src_decls.emplace_back("source",
+                             SourceNodeOptions(config.schema, GetGen(config.batches)));
+    }
     bp_options.push_back(
         std::make_shared<BackpressureCountingNodeOptions>(&bp_counters[i]));
     std::shared_ptr<ExecNodeOptions> options = bp_options.back();
@@ -1486,11 +1496,12 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
     if (config.is_gated) {
       bp_decl = {std::string{GatedNodeOptions::kName}, {bp_decl}, gate_options};
     }
-    bp_decls.push_back(bp_decl);
+    bp_decls.emplace_back(bp_decl);
   }
 
-  Declaration asofjoin = {"asofjoin", bp_decls,
-                          GetRepeatedOptions(source_configs.size(), "time", {"key"}, 0)};
+  auto opts = GetRepeatedOptions(source_configs.size(), "time", {"key"}, 0);
+
+  Declaration asofjoin = {"asofjoin", bp_decls, opts};
 
   ASSERT_OK_AND_ASSIGN(std::shared_ptr<internal::ThreadPool> tpool,
                        internal::ThreadPool::Make(1));
@@ -1512,14 +1523,14 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
     return true;
   };
 
-  BusyWait(10.0, has_bp_been_applied);
+  BusyWait(60.0, has_bp_been_applied);
   ASSERT_TRUE(has_bp_been_applied());
 
   gate.ReleaseAllBatches();
   ASSERT_FINISHES_OK_AND_ASSIGN(BatchesWithCommonSchema batches, batches_fut);
 
-  // One of the inputs is gated.  The other two will eventually be resumed by the asof
-  // join node
+  // One of the inputs is gated and was released. The other two will eventually be resumed
+  // by the asof join node
   for (size_t i = 0; i < source_configs.size(); i++) {
     const auto& counters = bp_counters[i];
     if (!source_configs[i].is_gated) {
@@ -1529,7 +1540,9 @@ void TestBackpressure(BatchesMaker maker, int num_batches, int batch_size) {
 }
 
 TEST(AsofJoinTest, BackpressureWithBatches) {
-  return TestBackpressure(MakeIntegerBatches, /*num_batches=*/20, /*batch_size=*/1);
+  // Give the first right hand table a delay to stress test race conditions
+  return TestBackpressure(MakeIntegerBatches, /*batch_size=*/1, /*num_l_batches=*/20,
+                          /*num_r0_batches=*/50, /*num_r1_batches=*/20, /*slow_r0=*/true);
 }
 
 template <typename BatchesMaker>
@@ -1595,7 +1608,10 @@ TEST(AsofJoinTest, BackpressureWithBatchesGen) {
   GTEST_SKIP() << "Skipping - see GH-36331";
   int num_batches = GetEnvValue("ARROW_BACKPRESSURE_DEMO_NUM_BATCHES", 20);
   int batch_size = GetEnvValue("ARROW_BACKPRESSURE_DEMO_BATCH_SIZE", 1);
-  return TestBackpressure(MakeIntegerBatchGenForTest, num_batches, batch_size);
+  return TestBackpressure(MakeIntegerBatchGenForTest, /*batch_size=*/batch_size,
+                          /*num_l_batches=*/num_batches,
+                          /*num_r0_batches=*/num_batches, /*num_r1_batches=*/num_batches,
+                          /*slow_r0=*/false);
 }
 
 }  // namespace acero

From 7751444be23a433d73d0722d34d5107ca35a714f Mon Sep 17 00:00:00 2001
From: Peter Andreas Entschev <peter@entschev.com>
Date: Tue, 24 Oct 2023 17:42:06 +0200
Subject: [PATCH 617/749] GH-38364: [Python] Initialize S3 on first use
 (#38375)

### Rationale for this change

In accordance to https://github.com/apache/arrow/issues/38364, we believe that for various reasons (shortening import time, preventing unnecessary resource consumption and potential bugs with S3 library) it is appropriate to avoid initialization of S3 resources at import time and move that step to occur at first-use.

### What changes are included in this PR?

- Remove calls to `ensure_s3_initialized()` that were up until now executed during `import pyarrow.fs`;
- Move `ensure_s3_intialized()` calls to `python/pyarrow/_s3fs.pyx` module;
- Add global flag to mark whether S3 has been previously initialized and `atexit` handlers registered.

### Are these changes tested?

Yes, existing S3 tests check whether it has been initialized, otherwise failing with a C++ exception.

### Are there any user-facing changes?

No, the behavior is now slightly different with S3 initialization not happening immediately after `pyarrow.fs` is imported, but no changes are expected from a user perspective relying on the public API alone.

**This PR contains a "Critical Fix".**
A bug in aws-sdk-cpp reported in https://github.com/aws/aws-sdk-cpp/issues/2681 causes segmentation faults under specific circumstances when Python processes shutdown, specifically observed with Dask+GPUs (so far we were unable to pinpoint the exact correlation of Dask+GPUs+S3). While this definitely doesn't seem to affect all users and is not directly sourced in Arrow, it may affect use cases that are completely independent of S3 to operate, which is particularly problematic in CI where all tests pass successfully but the process crashes at shutdown.
* Closes: #38364

Lead-authored-by: Peter Andreas Entschev <peter@entschev.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 python/pyarrow/_s3fs.pyx                | 11 +++++++++++
 python/pyarrow/fs.py                    |  9 ++++++---
 python/pyarrow/includes/libarrow_fs.pxd |  1 +
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/python/pyarrow/_s3fs.pyx b/python/pyarrow/_s3fs.pyx
index ab45171369953..f7f2a5f80887c 100644
--- a/python/pyarrow/_s3fs.pyx
+++ b/python/pyarrow/_s3fs.pyx
@@ -70,6 +70,13 @@ def finalize_s3():
     check_status(CFinalizeS3())
 
 
+def ensure_s3_finalized():
+    """
+    Finalize S3 if already initialized
+    """
+    check_status(CEnsureS3Finalized())
+
+
 def resolve_s3_region(bucket):
     """
     Resolve the S3 region of a bucket.
@@ -93,6 +100,8 @@ def resolve_s3_region(bucket):
         c_string c_bucket
         c_string c_region
 
+    ensure_s3_initialized()
+
     c_bucket = tobytes(bucket)
     with nogil:
         c_region = GetResultValue(ResolveS3BucketRegion(c_bucket))
@@ -260,6 +269,8 @@ cdef class S3FileSystem(FileSystem):
                  load_frequency=900, proxy_options=None,
                  allow_bucket_creation=False, allow_bucket_deletion=False,
                  retry_strategy: S3RetryStrategy = AwsStandardS3RetryStrategy(max_attempts=3)):
+        ensure_s3_initialized()
+
         cdef:
             optional[CS3Options] options
             shared_ptr[CS3FileSystem] wrapped
diff --git a/python/pyarrow/fs.py b/python/pyarrow/fs.py
index 36655c7d12863..ead750ca44ef8 100644
--- a/python/pyarrow/fs.py
+++ b/python/pyarrow/fs.py
@@ -54,13 +54,16 @@
     from pyarrow._s3fs import (  # noqa
         AwsDefaultS3RetryStrategy, AwsStandardS3RetryStrategy,
         S3FileSystem, S3LogLevel, S3RetryStrategy, ensure_s3_initialized,
-        finalize_s3, initialize_s3, resolve_s3_region)
+        finalize_s3, ensure_s3_finalized, initialize_s3, resolve_s3_region)
 except ImportError:
     _not_imported.append("S3FileSystem")
 else:
-    ensure_s3_initialized()
+    # GH-38364: we don't initialize S3 eagerly as that could lead
+    # to crashes at shutdown even when S3 isn't used.
+    # Instead, S3 is initialized lazily using `ensure_s3_initialized`
+    # in assorted places.
     import atexit
-    atexit.register(finalize_s3)
+    atexit.register(ensure_s3_finalized)
 
 
 def __getattr__(name):
diff --git a/python/pyarrow/includes/libarrow_fs.pxd b/python/pyarrow/includes/libarrow_fs.pxd
index 2727fc201198f..cb30f4e750eff 100644
--- a/python/pyarrow/includes/libarrow_fs.pxd
+++ b/python/pyarrow/includes/libarrow_fs.pxd
@@ -211,6 +211,7 @@ cdef extern from "arrow/filesystem/api.h" namespace "arrow::fs" nogil:
         const CS3GlobalOptions& options)
     cdef CStatus CEnsureS3Initialized "arrow::fs::EnsureS3Initialized"()
     cdef CStatus CFinalizeS3 "arrow::fs::FinalizeS3"()
+    cdef CStatus CEnsureS3Finalized "arrow::fs::EnsureS3Finalized"()
 
     cdef CResult[c_string] ResolveS3BucketRegion(const c_string& bucket)
 

From 7b1281a432f2ea8dcc6bec5c7824a97d608486ca Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 25 Oct 2023 00:10:58 +0800
Subject: [PATCH 618/749] GH-38399: [Go][Parquet] DeltaBitPack decoder reset
 usedFirst after SetData (#38413)

### Rationale for this change

As https://github.com/apache/arrow/issues/38399 says. DeltaBitPack will corrupt when we meet a column chunk
with more than one page. During first page decoding, it works well. But when the second page comes, the
`d.usedFirst` haven't been reset, which cause the bug.

### What changes are included in this PR?

1. Some style enhancement
2. Bug fix

### Are these changes tested?

Currently not

### Are there any user-facing changes?

bugfix

* Closes: #38399

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 .../internal/encoding/delta_bit_packing.go    | 44 +++++++++++--------
 go/parquet/internal/encoding/encoding_test.go | 44 +++++++++++++++++++
 2 files changed, 70 insertions(+), 18 deletions(-)

diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index 5b246f4591657..1fb91634e977b 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -18,6 +18,7 @@ package encoding
 
 import (
 	"bytes"
+	"errors"
 	"math"
 	"math/bits"
 	"reflect"
@@ -27,7 +28,6 @@ import (
 	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/apache/arrow/go/v14/parquet"
 	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"golang.org/x/xerrors"
 )
 
 // see the deltaBitPack encoder for a description of the encoding format that is
@@ -41,7 +41,7 @@ type deltaBitPackDecoder struct {
 	bitdecoder           *utils.BitReader
 	blockSize            uint64
 	currentBlockVals     uint32
-	miniBlocks           uint64
+	miniBlocksPerBlock   uint64
 	valsPerMini          uint32
 	currentMiniBlockVals uint32
 	minDelta             int64
@@ -79,24 +79,26 @@ func (d *deltaBitPackDecoder) SetData(nvalues int, data []byte) error {
 	var ok bool
 	d.blockSize, ok = d.bitdecoder.GetVlqInt()
 	if !ok {
-		return xerrors.New("parquet: eof exception")
+		return errors.New("parquet: eof exception")
 	}
 
-	if d.miniBlocks, ok = d.bitdecoder.GetVlqInt(); !ok {
-		return xerrors.New("parquet: eof exception")
+	if d.miniBlocksPerBlock, ok = d.bitdecoder.GetVlqInt(); !ok {
+		return errors.New("parquet: eof exception")
+	}
+	if d.miniBlocksPerBlock == 0 {
+		return errors.New("parquet: cannot have zero miniblock per block")
 	}
 
 	if d.totalValues, ok = d.bitdecoder.GetVlqInt(); !ok {
-		return xerrors.New("parquet: eof exception")
+		return errors.New("parquet: eof exception")
 	}
 
 	if d.lastVal, ok = d.bitdecoder.GetZigZagVlqInt(); !ok {
-		return xerrors.New("parquet: eof exception")
+		return errors.New("parquet: eof exception")
 	}
 
-	if d.miniBlocks != 0 {
-		d.valsPerMini = uint32(d.blockSize / d.miniBlocks)
-	}
+	d.valsPerMini = uint32(d.blockSize / d.miniBlocksPerBlock)
+	d.usedFirst = false
 	return nil
 }
 
@@ -105,14 +107,14 @@ func (d *deltaBitPackDecoder) initBlock() error {
 	// first we grab the min delta value that we'll start from
 	var ok bool
 	if d.minDelta, ok = d.bitdecoder.GetZigZagVlqInt(); !ok {
-		return xerrors.New("parquet: eof exception")
+		return errors.New("parquet: eof exception")
 	}
 
 	// ensure we have enough space for our miniblocks to decode the widths
-	d.deltaBitWidths.Resize(int(d.miniBlocks))
+	d.deltaBitWidths.Resize(int(d.miniBlocksPerBlock))
 
 	var err error
-	for i := uint64(0); i < d.miniBlocks; i++ {
+	for i := uint64(0); i < d.miniBlocksPerBlock; i++ {
 		if d.deltaBitWidths.Bytes()[i], err = d.bitdecoder.ReadByte(); err != nil {
 			return err
 		}
@@ -143,7 +145,7 @@ func (d *DeltaBitPackInt32Decoder) unpackNextMini() error {
 	for j := 0; j < int(d.valsPerMini); j++ {
 		delta, ok := d.bitdecoder.GetValue(int(d.deltaBitWidth))
 		if !ok {
-			return xerrors.New("parquet: eof exception")
+			return errors.New("parquet: eof exception")
 		}
 
 		d.lastVal += int64(delta) + int64(d.minDelta)
@@ -172,6 +174,9 @@ func (d *DeltaBitPackInt32Decoder) Decode(out []int32) (int, error) {
 	for len(out) > 0 { // unpack mini blocks until we get all the values we need
 		if d.currentBlockVals == 0 {
 			err = d.initBlock()
+			if err != nil {
+				return 0, err
+			}
 		}
 		if d.currentMiniBlockVals == 0 {
 			err = d.unpackNextMini()
@@ -200,7 +205,7 @@ func (d *DeltaBitPackInt32Decoder) DecodeSpaced(out []int32, nullCount int, vali
 		return values, err
 	}
 	if values != toread {
-		return values, xerrors.New("parquet: number of values / definition levels read did not match")
+		return values, errors.New("parquet: number of values / definition levels read did not match")
 	}
 
 	return spacedExpand(out, nullCount, validBits, validBitsOffset), nil
@@ -231,10 +236,10 @@ func (d *DeltaBitPackInt64Decoder) unpackNextMini() error {
 	for j := 0; j < int(d.valsPerMini); j++ {
 		delta, ok := d.bitdecoder.GetValue(int(d.deltaBitWidth))
 		if !ok {
-			return xerrors.New("parquet: eof exception")
+			return errors.New("parquet: eof exception")
 		}
 
-		d.lastVal += int64(delta) + int64(d.minDelta)
+		d.lastVal += int64(delta) + d.minDelta
 		d.miniBlockValues = append(d.miniBlockValues, d.lastVal)
 	}
 	d.miniBlockIdx++
@@ -260,6 +265,9 @@ func (d *DeltaBitPackInt64Decoder) Decode(out []int64) (int, error) {
 	for len(out) > 0 {
 		if d.currentBlockVals == 0 {
 			err = d.initBlock()
+			if err != nil {
+				return 0, err
+			}
 		}
 		if d.currentMiniBlockVals == 0 {
 			err = d.unpackNextMini()
@@ -293,7 +301,7 @@ func (d DeltaBitPackInt64Decoder) DecodeSpaced(out []int64, nullCount int, valid
 		return values, err
 	}
 	if values != toread {
-		return values, xerrors.New("parquet: number of values / definition levels read did not match")
+		return values, errors.New("parquet: number of values / definition levels read did not match")
 	}
 
 	return spacedExpand(out, nullCount, validBits, validBitsOffset), nil
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index 65b085d0ea167..50e72de004e19 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -594,6 +594,28 @@ func TestWriteDeltaBitPackedInt32(t *testing.T) {
 			assert.Equalf(t, values[i:j], valueBuf, "indexes %d:%d", i, j)
 		}
 	})
+
+	t.Run("test decoding multiple pages", func(t *testing.T) {
+		values := make([]int32, 1000)
+		testutils.FillRandomInt32(0, values)
+
+		enc := encoding.NewEncoder(parquet.Types.Int32, parquet.Encodings.DeltaBinaryPacked, false, column, memory.DefaultAllocator)
+		enc.(encoding.Int32Encoder).Put(values)
+		buf, _ := enc.FlushValues()
+		defer buf.Release()
+
+		// Using same Decoder to decode the data.
+		dec := encoding.NewDecoder(parquet.Types.Int32, parquet.Encodings.DeltaBinaryPacked, column, memory.DefaultAllocator)
+		for i := 0; i < 5; i += 1 {
+			dec.(encoding.Int32Decoder).SetData(len(values), buf.Bytes())
+
+			valueBuf := make([]int32, 100)
+			for i, j := 0, len(valueBuf); j <= len(values); i, j = i+len(valueBuf), j+len(valueBuf) {
+				dec.(encoding.Int32Decoder).Decode(valueBuf)
+				assert.Equalf(t, values[i:j], valueBuf, "indexes %d:%d", i, j)
+			}
+		}
+	})
 }
 
 func TestWriteDeltaBitPackedInt64(t *testing.T) {
@@ -670,6 +692,28 @@ func TestWriteDeltaBitPackedInt64(t *testing.T) {
 		assert.Equal(t, len(valueBuf), decoded)
 		assert.Equal(t, values, valueBuf)
 	})
+
+	t.Run("test decoding multiple pages", func(t *testing.T) {
+		values := make([]int64, 1000)
+		testutils.FillRandomInt64(0, values)
+
+		enc := encoding.NewEncoder(parquet.Types.Int64, parquet.Encodings.DeltaBinaryPacked, false, column, memory.DefaultAllocator)
+		enc.(encoding.Int64Encoder).Put(values)
+		buf, _ := enc.FlushValues()
+		defer buf.Release()
+
+		// Using same Decoder to decode the data.
+		dec := encoding.NewDecoder(parquet.Types.Int64, parquet.Encodings.DeltaBinaryPacked, column, memory.DefaultAllocator)
+		for i := 0; i < 5; i += 1 {
+			dec.(encoding.Int64Decoder).SetData(len(values), buf.Bytes())
+
+			valueBuf := make([]int64, 100)
+			for i, j := 0, len(valueBuf); j <= len(values); i, j = i+len(valueBuf), j+len(valueBuf) {
+				dec.(encoding.Int64Decoder).Decode(valueBuf)
+				assert.Equalf(t, values[i:j], valueBuf, "indexes %d:%d", i, j)
+			}
+		}
+	})
 }
 
 func TestDeltaLengthByteArrayEncoding(t *testing.T) {

From 006f387dc4eafb4db655c7ffce619daf2ca326a6 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Tue, 24 Oct 2023 09:54:15 -0700
Subject: [PATCH 619/749] GH-38264: [Java][Packaging] Add BOM file (#38336)

### Rationale for this change
Provide an easy way for users to import Arrow maven packages.

### What changes are included in this PR?
Add a BOM module and utilize this module internally for importing Arrow dependencies.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
Users can import the BOM dependency now.

* Closes: #38264

Authored-by: James Duong <duong.james@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 dev/release/utils-prepare.sh                 |   2 +-
 dev/tasks/tasks.yml                          |   1 +
 java/adapter/avro/pom.xml                    |   3 -
 java/adapter/jdbc/pom.xml                    |   3 -
 java/adapter/orc/pom.xml                     |   3 -
 java/algorithm/pom.xml                       |   3 -
 java/bom/pom.xml                             | 148 +++++++++++++++++++
 java/c/pom.xml                               |   3 -
 java/compression/pom.xml                     |  11 +-
 java/dataset/pom.xml                         |   4 -
 java/flight/flight-core/pom.xml              |   4 -
 java/flight/flight-grpc/pom.xml              |   3 -
 java/flight/flight-integration-tests/pom.xml |   4 -
 java/flight/flight-sql-jdbc-core/pom.xml     |   4 -
 java/flight/flight-sql-jdbc-driver/pom.xml   |   5 -
 java/flight/flight-sql/pom.xml               |   4 -
 java/gandiva/pom.xml                         |   3 -
 java/memory/memory-netty/pom.xml             |   1 -
 java/memory/memory-unsafe/pom.xml            |   1 -
 java/performance/pom.xml                     |   6 -
 java/pom.xml                                 |   9 ++
 java/tools/pom.xml                           |   4 -
 java/vector/pom.xml                          |   4 -
 23 files changed, 163 insertions(+), 70 deletions(-)
 create mode 100644 java/bom/pom.xml

diff --git a/dev/release/utils-prepare.sh b/dev/release/utils-prepare.sh
index 23c89ad54eb01..8e4c8a84ae8fd 100644
--- a/dev/release/utils-prepare.sh
+++ b/dev/release/utils-prepare.sh
@@ -65,7 +65,7 @@ update_versions() {
   popd
 
   pushd "${ARROW_DIR}/java"
-  mvn versions:set -DnewVersion=${version}
+  mvn versions:set -DnewVersion=${version} -DprocessAllModules
   find . -type f -name pom.xml.versionsBackup -delete
   git add "pom.xml"
   git add "**/pom.xml"
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 33050c1de5da8..17123ed2b8339 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -789,6 +789,7 @@ tasks:
       - arrow-avro-{no_rc_snapshot_version}-tests.jar
       - arrow-avro-{no_rc_snapshot_version}.jar
       - arrow-avro-{no_rc_snapshot_version}.pom
+      - arrow-bom-{no_rc_snapshot_version}.pom
       - arrow-c-data-{no_rc_snapshot_version}-cyclonedx.json
       - arrow-c-data-{no_rc_snapshot_version}-cyclonedx.xml
       - arrow-c-data-{no_rc_snapshot_version}-javadoc.jar
diff --git a/java/adapter/avro/pom.xml b/java/adapter/avro/pom.xml
index 7f55fdc19fc27..6735094d11bb4 100644
--- a/java/adapter/avro/pom.xml
+++ b/java/adapter/avro/pom.xml
@@ -31,14 +31,12 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
 
     <!-- https://mvnrepository.com/artifact/org.apache.arrow/arrow-memory-netty -->
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-netty</artifactId>
-      <version>${project.version}</version>
       <scope>runtime</scope>
     </dependency>
 
@@ -46,7 +44,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-vector</artifactId>
-      <version>${project.version}</version>
     </dependency>
 
     <dependency>
diff --git a/java/adapter/jdbc/pom.xml b/java/adapter/jdbc/pom.xml
index 1a160fcc983d1..127202c5215ec 100644
--- a/java/adapter/jdbc/pom.xml
+++ b/java/adapter/jdbc/pom.xml
@@ -31,14 +31,12 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/org.apache.arrow/arrow-memory-netty -->
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
 
@@ -46,7 +44,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
 
diff --git a/java/adapter/orc/pom.xml b/java/adapter/orc/pom.xml
index 90e14679c172e..ec85bf8fe720c 100644
--- a/java/adapter/orc/pom.xml
+++ b/java/adapter/orc/pom.xml
@@ -18,19 +18,16 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
diff --git a/java/algorithm/pom.xml b/java/algorithm/pom.xml
index 7041e92788e64..235c9440f9196 100644
--- a/java/algorithm/pom.xml
+++ b/java/algorithm/pom.xml
@@ -24,7 +24,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-vector</artifactId>
-      <version>${project.version}</version>
       <classifier>${arrow.vector.classifier}</classifier>
     </dependency>
     <dependency>
@@ -36,12 +35,10 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-netty</artifactId>
-      <version>${project.version}</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
diff --git a/java/bom/pom.xml b/java/bom/pom.xml
new file mode 100644
index 0000000000000..7ea0b9bf514be
--- /dev/null
+++ b/java/bom/pom.xml
@@ -0,0 +1,148 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor
+  license agreements. See the NOTICE file distributed with this work for additional
+  information regarding copyright ownership. The ASF licenses this file to
+  You under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of
+  the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required
+  by applicable law or agreed to in writing, software distributed under the
+  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+  OF ANY KIND, either express or implied. See the License for the specific
+  language governing permissions and limitations under the License. -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>org.apache</groupId>
+    <artifactId>apache</artifactId>
+    <version>18</version>
+  </parent>
+
+  <groupId>org.apache.arrow</groupId>
+  <artifactId>arrow-bom</artifactId>
+  <version>14.0.0-SNAPSHOT</version>
+  <packaging>pom</packaging>
+  <name>Arrow Bill of Materials</name>
+  <description>Arrow Bill of Materials</description>
+
+  <properties>
+    <arrow.vector.classifier/>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-vector</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-vector</artifactId>
+        <version>${project.version}</version>
+        <classifier>${arrow.vector.classifier}</classifier>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-avro</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-jdbc</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-orc</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-algorithm</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-c-data</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-compression</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-dataset</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-core</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-grpc</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-integration-tests</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-sql</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-sql-jdbc-core</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>flight-sql-jdbc-driver</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-format</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-gandiva</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-memory-core</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-memory-netty</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-memory-unsafe</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-performance</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-tools</artifactId>
+        <version>${project.version}</version>
+      </dependency>
+    </dependencies>
+
+  </dependencyManagement>
+</project>
diff --git a/java/c/pom.xml b/java/c/pom.xml
index d347175fefa53..a40a7f9e7f5f6 100644
--- a/java/c/pom.xml
+++ b/java/c/pom.xml
@@ -29,7 +29,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
@@ -43,7 +42,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
@@ -53,7 +51,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-unsafe</artifactId>
-            <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
diff --git a/java/compression/pom.xml b/java/compression/pom.xml
index a914d0208433f..ff2835acbe8a4 100644
--- a/java/compression/pom.xml
+++ b/java/compression/pom.xml
@@ -24,18 +24,15 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-vector</artifactId>
-      <version>${project.version}</version>
       <classifier>${arrow.vector.classifier}</classifier>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-unsafe</artifactId>
-      <version>${project.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
@@ -44,9 +41,9 @@
       <version>1.21</version>
     </dependency>
     <dependency>
-    <groupId>com.github.luben</groupId>
-    <artifactId>zstd-jni</artifactId>
-    <version>1.4.9-1</version>
-</dependency>
+      <groupId>com.github.luben</groupId>
+      <artifactId>zstd-jni</artifactId>
+      <version>1.4.9-1</version>
+    </dependency>
   </dependencies>
 </project>
diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index e971a918e4a9d..ad88c02c16fe3 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -34,26 +34,22 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-c-data</artifactId>
-            <version>${project.version}</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
diff --git a/java/flight/flight-core/pom.xml b/java/flight/flight-core/pom.xml
index 9ce777ec1ee5f..c9fa75615032b 100644
--- a/java/flight/flight-core/pom.xml
+++ b/java/flight/flight-core/pom.xml
@@ -31,23 +31,19 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-format</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-vector</artifactId>
-      <version>${project.version}</version>
       <classifier>${arrow.vector.classifier}</classifier>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-netty</artifactId>
-      <version>${project.version}</version>
       <scope>runtime</scope>
     </dependency>
     <dependency>
diff --git a/java/flight/flight-grpc/pom.xml b/java/flight/flight-grpc/pom.xml
index 5e77461841c1f..c857500d560b0 100644
--- a/java/flight/flight-grpc/pom.xml
+++ b/java/flight/flight-grpc/pom.xml
@@ -31,7 +31,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>flight-core</artifactId>
-      <version>${project.version}</version>
       <exclusions>
         <exclusion>
           <groupId>io.netty</groupId>
@@ -58,13 +57,11 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
       <scope>compile</scope>
     </dependency>
     <dependency>
        <groupId>org.apache.arrow</groupId>
        <artifactId>arrow-memory-netty</artifactId>
-       <version>${project.version}</version>
        <scope>runtime</scope>
      </dependency>
      <dependency>
diff --git a/java/flight/flight-integration-tests/pom.xml b/java/flight/flight-integration-tests/pom.xml
index b6a754dea7b18..20e31e0ceec04 100644
--- a/java/flight/flight-integration-tests/pom.xml
+++ b/java/flight/flight-integration-tests/pom.xml
@@ -28,22 +28,18 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-sql</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>com.google.protobuf</groupId>
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index 34d7c26818775..b99f887a6c9f4 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -38,7 +38,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-core</artifactId>
-            <version>${project.version}</version>
             <exclusions>
                 <exclusion>
                     <groupId>io.netty</groupId>
@@ -55,14 +54,12 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/org.apache.arrow/arrow-memory-netty -->
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
 
@@ -70,7 +67,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
 
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 03fb22db9601c..853f1e12274b9 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -39,7 +39,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-sql-jdbc-core</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
 
@@ -54,14 +53,12 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
 
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-sql</artifactId>
-            <version>${project.version}</version>
             <scope>runtime</scope>
         </dependency>
 
@@ -82,7 +79,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>flight-core</artifactId>
-            <version>${project.version}</version>
             <exclusions>
                 <exclusion>
                     <groupId>io.netty</groupId>
@@ -131,7 +127,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
             <scope>runtime</scope>
         </dependency>
diff --git a/java/flight/flight-sql/pom.xml b/java/flight/flight-sql/pom.xml
index 565c170587040..573eb676fd834 100644
--- a/java/flight/flight-sql/pom.xml
+++ b/java/flight/flight-sql/pom.xml
@@ -31,7 +31,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>flight-core</artifactId>
-      <version>${project.version}</version>
       <exclusions>
         <exclusion>
           <groupId>io.netty</groupId>
@@ -50,12 +49,10 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-jdbc</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>com.google.guava</groupId>
@@ -68,7 +65,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-vector</artifactId>
-      <version>${project.version}</version>
       <classifier>${arrow.vector.classifier}</classifier>
     </dependency>
     <dependency>
diff --git a/java/gandiva/pom.xml b/java/gandiva/pom.xml
index d9f20cfd9be43..c9ca3ef615d0e 100644
--- a/java/gandiva/pom.xml
+++ b/java/gandiva/pom.xml
@@ -33,18 +33,15 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
         <dependency>
diff --git a/java/memory/memory-netty/pom.xml b/java/memory/memory-netty/pom.xml
index be3abed76d2c4..626452dba8777 100644
--- a/java/memory/memory-netty/pom.xml
+++ b/java/memory/memory-netty/pom.xml
@@ -25,7 +25,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
diff --git a/java/memory/memory-unsafe/pom.xml b/java/memory/memory-unsafe/pom.xml
index cf4ac4fcc594d..33e2058d5f2da 100644
--- a/java/memory/memory-unsafe/pom.xml
+++ b/java/memory/memory-unsafe/pom.xml
@@ -26,7 +26,6 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
   </dependencies>
 
diff --git a/java/performance/pom.xml b/java/performance/pom.xml
index 8653afca2191e..c6dc572935cb1 100644
--- a/java/performance/pom.xml
+++ b/java/performance/pom.xml
@@ -36,18 +36,15 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-netty</artifactId>
-            <version>${project.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -58,7 +55,6 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-avro</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>com.h2database</groupId>
@@ -69,12 +65,10 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-jdbc</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-algorithm</artifactId>
-            <version>14.0.0-SNAPSHOT</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
diff --git a/java/pom.xml b/java/pom.xml
index b5ec6a61a7e70..417bdd5da375a 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -541,6 +541,14 @@
 
   <dependencyManagement>
     <dependencies>
+      <!-- Utilize the bill of materials in sub-modules -->
+      <dependency>
+        <groupId>org.apache.arrow</groupId>
+        <artifactId>arrow-bom</artifactId>
+        <version>${project.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
       <dependency>
         <groupId>com.google.flatbuffers</groupId>
         <artifactId>flatbuffers-java</artifactId>
@@ -716,6 +724,7 @@
   </reporting>
 
   <modules>
+    <module>bom</module>
     <module>format</module>
     <module>memory</module>
     <module>vector</module>
diff --git a/java/tools/pom.xml b/java/tools/pom.xml
index ba9343228319e..b139b3876e4ae 100644
--- a/java/tools/pom.xml
+++ b/java/tools/pom.xml
@@ -24,18 +24,15 @@
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-memory-core</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-vector</artifactId>
-            <version>${project.version}</version>
             <classifier>${arrow.vector.classifier}</classifier>
         </dependency>
         <dependency>
             <groupId>org.apache.arrow</groupId>
             <artifactId>arrow-compression</artifactId>
-            <version>${project.version}</version>
         </dependency>
         <dependency>
           <groupId>com.google.guava</groupId>
@@ -67,7 +64,6 @@
         <dependency>
           <groupId>org.apache.arrow</groupId>
           <artifactId>arrow-memory-netty</artifactId>
-          <version>${project.version}</version>
           <scope>runtime</scope>
         </dependency>
         <dependency>
diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index e6dcef0e1b3e6..015d089e9d028 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -25,12 +25,10 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-format</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-core</artifactId>
-      <version>${project.version}</version>
     </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
@@ -56,13 +54,11 @@
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-netty</artifactId>
-      <version>${project.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-memory-unsafe</artifactId>
-      <version>${project.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From e14f60b7efd2d41c6ede8569ac1a8b07da3cbf73 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 24 Oct 2023 13:42:41 -0400
Subject: [PATCH 620/749] GH-38398: [MATLAB] Improve array display (#38400)

### Rationale for this change

Currently, the display for `arrow.array.Array`s is not very MATLAB-like:

```matlab

>> a = arrow.array([1 2 3 4])

a =

[
  1,
  2,
  3,
]
```

At the very least, the display should include the class header and indent each line by 4 spaces. Here's one display option:

```matlab

>> a = arrow.array([1 2 3 4])

a =

  Float64Array with 4 elements and 0 null values:

    1 | 2 | 3 | 4

```

### What changes are included in this PR?

1. Array display now includes a class header, which states the array type and the number of elements/nulls in the array.
2. Changed the [`window`](https://github.com/apache/arrow/blob/37935604bf168a3b2d52f3cc5b0edf83b5783309/cpp/src/arrow/pretty_print.h#L79C1-L80C1) size to 3 from 10.
3. Primitive and string arrays are displayed horizontally, i.e. set [`skip_new_lines`](https://github.com/apache/arrow/blob/37935604bf168a3b2d52f3cc5b0edf83b5783309/cpp/src/arrow/pretty_print.h#L90) to `false`. Uses ` | ` as the delimiter between elements with no opening/closing brackets.
4. All other array types (`struct`, `list`, etc) are displayed vertically with an `indent` of 4.

**Example String Array Display:**

```matlab
>> a = arrow.array(["Hello", missing, "Bye"])

a =

  StringArray with 3 elements and 1 null value:

    "Hello" | null | "Bye"
```

**Example Struct Array Display:**

```matlab

>>  a1 = arrow.array(["Hello", missing, "Bye"]);
>> a2 = arrow.array([1 2 3]);
>> structArray = arrow.array.StructArray.fromArrays(a1, a2)

structArray =

  StructArray with 3 elements and 0 null values:

        -- is_valid: all not null
    -- child 0 type: string
        [
            "Hello",
            null,
            "Bye"
        ]
    -- child 1 type: double
        [
            1,
            2,
            3
        ]
```

### Are these changes tested?

Yes. Added a new test class called `tArrayDisplay.m` with unit tests for array display.

### Are there any user-facing changes?

Yes. Users will see a different display for arrays now.

### Future Directions

1. #38166
* Closes: #38398

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc |  30 +-
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 .../+array/+internal/+display/getHeader.m     |  38 ++
 .../+display/pluralizeStringIfNeeded.m        |  23 ++
 matlab/src/matlab/+arrow/+array/Array.m       |  16 +-
 matlab/test/arrow/array/tArrayDisplay.m       | 334 ++++++++++++++++++
 6 files changed, 439 insertions(+), 3 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m
 create mode 100644 matlab/test/arrow/array/tArrayDisplay.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index bd8e9dc842513..4e52c990d3eae 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -21,10 +21,13 @@
 #include "arrow/matlab/bit/unpack.h"
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/type/proxy/wrap.h"
+#include "arrow/pretty_print.h"
 #include "arrow/type_traits.h"
 
 #include "libmexclass/proxy/ProxyManager.h"
 
+#include <sstream>
+
 namespace arrow::matlab::array::proxy {
 
     Array::Array(std::shared_ptr<arrow::Array> array) : array{std::move(array)} {
@@ -44,7 +47,32 @@ namespace arrow::matlab::array::proxy {
 
     void Array::toString(libmexclass::proxy::method::Context& context) {
         ::matlab::data::ArrayFactory factory;
-        const auto str_utf8 = array->ToString();
+        
+        auto opts = arrow::PrettyPrintOptions::Defaults();
+        opts.window = 3;
+        opts.indent = 4;
+        opts.indent_size = 4;
+
+        const auto type_id = array->type()->id();
+        if (arrow::is_primitive(type_id) || arrow::is_string(type_id)) {
+            /* 
+             * Display primitive and string types horizontally without 
+             * opening and closing delimiters. Use " | " as the delimiter
+             * between elments. Below is an example Int32Array display:
+             *
+             *    1 | 2 | 3 | ... | 6 | 7 | 8
+             */
+            opts.skip_new_lines = true;
+            opts.array_delimiters.open = "";
+            opts.array_delimiters.close = "";
+            opts.array_delimiters.element = " | ";
+        }
+
+        std::stringstream ss;
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(arrow::PrettyPrint(*array, opts, &ss), context, error::ARRAY_PRETTY_PRINT_FAILED);
+        
+        const auto str_utf8 = opts.skip_new_lines ? "    " + ss.str() : ss.str();
+
         MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(const auto str_utf16, arrow::util::UTF8StringToUTF16(str_utf8), context, error::UNICODE_CONVERSION_ERROR_ID);
         auto str_mda = factory.createScalar(str_utf16);
         context.outputs[0] = str_mda;
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index a512fdcc89fa9..2d8f5c432c96e 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -201,4 +201,5 @@ namespace arrow::matlab::error {
     static const char* INDEX_EMPTY_CONTAINER = "arrow:index:EmptyContainer";
     static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
     static const char* BUFFER_VIEW_OR_COPY_FAILED = "arrow:buffer:ViewOrCopyFailed";
+    static const char* ARRAY_PRETTY_PRINT_FAILED = "arrow:array:PrettyPrintFailed";
 }
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m b/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
new file mode 100644
index 0000000000000..5c8704d5bf2a4
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
@@ -0,0 +1,38 @@
+%GETHEADER Generates the display header for arrow.array.Array classes
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function header = getHeader(className, numElements, numNulls)
+    import arrow.array.internal.display.pluralizeStringIfNeeded
+    elementString = pluralizeStringIfNeeded(numElements, "element");
+
+    nullString = pluralizeStringIfNeeded(numNulls, "null value");
+    
+    numString = "%d";
+    if usejava("desktop")
+        % Bold the number of elements and nulls if the desktop is enabled
+        numString = compose("<strong>%s</strong>", numString);
+    end
+
+    formatSpec = "  %s with " + numString + " %s and " + numString + " %s";
+    if numElements > 0
+        formatSpec = formatSpec + ":";
+    end
+    formatSpec = formatSpec + newline;
+    
+    header = compose(formatSpec, className, numElements, elementString, numNulls, nullString);
+    header = char(header);
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m b/matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m
new file mode 100644
index 0000000000000..ae9eafba92dd8
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m
@@ -0,0 +1,23 @@
+%PLURALIZESTRINGIFNEEDED Pluralizes str if num is not equal to 1.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function str = pluralizeStringIfNeeded(num, str)
+    if num ~= 1
+        str = str + "s";
+    end
+end
+
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 381e7349831d8..293ad87ad4316 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -62,8 +62,21 @@
     end
 
     methods (Access=protected)
+        function header = getHeader(obj)
+            name = matlab.mixin.CustomDisplay.getClassNameForHeader(obj);
+            numElements = obj.NumElements;
+            % TODO: Add NumValid and NumNull as properties to Array to
+            % avoid materializing the Valid property. This will improve
+            % performance for large arrays.
+            numNulls = nnz(~obj.Valid);
+            header = arrow.array.internal.display.getHeader(name, numElements, numNulls);
+        end
+
         function displayScalarObject(obj)
-            disp(obj.toString());
+            disp(getHeader(obj));
+            if obj.NumElements > 0
+                disp(toString(obj) + newline);
+            end
         end
     end
 
@@ -86,4 +99,3 @@ function displayScalarObject(obj)
         end
     end
 end
-
diff --git a/matlab/test/arrow/array/tArrayDisplay.m b/matlab/test/arrow/array/tArrayDisplay.m
new file mode 100644
index 0000000000000..578f5fe82aaa4
--- /dev/null
+++ b/matlab/test/arrow/array/tArrayDisplay.m
@@ -0,0 +1,334 @@
+%TARRAYDISPLAY Unit tests for array display.
+
+classdef tArrayDisplay < matlab.unittest.TestCase
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+    properties (TestParameter)
+        EmptyArray
+        ArrayWithOneElement
+        ArrayWithMultipleElements
+        ArrayWithOneNull
+        ArrayWithMultipleNulls
+    end
+
+    methods(TestParameterDefinition, Static)
+        function EmptyArray = initializeEmptyArray()
+            EmptyArray.Boolean = arrow.array(logical.empty(0, 0));
+            EmptyArray.UInt8 = arrow.array(uint8.empty(0, 0));
+            EmptyArray.Int64 = arrow.array(int64.empty(0, 0));
+            EmptyArray.Time64 = arrow.array(duration.empty(0, 0));
+            EmptyArray.Timestamp = arrow.array(datetime.empty(0, 0));
+            EmptyArray.String = arrow.array(string.empty(0, 0));
+        end
+
+        function ArrayWithOneElement = initializeArrayWithOneElement()
+            boolStruct = struct(Array=arrow.array(true), String="true");
+            ArrayWithOneElement.Boolean = boolStruct;
+            
+            uint8Struct = struct(Array=arrow.array(uint8(1)), String="1");
+            ArrayWithOneElement.UInt8 = uint8Struct; 
+
+            int64Struct = struct(Array=arrow.array(int64(2)), String="2");
+            ArrayWithOneElement.Int64 = int64Struct;
+
+            time64Struct = struct(Array=arrow.array(seconds(1)), String="00:00:01.000000");
+            ArrayWithOneElement.Time64 = time64Struct; 
+
+            timestampStruct = struct(Array=arrow.array(datetime(2023, 10, 20), TimeUnit="Second"), String="2023-10-20 00:00:00");
+            ArrayWithOneElement.Timestamp = timestampStruct;
+
+            stringStruct = struct(Array=arrow.array("A"), String="""A""");
+            ArrayWithOneElement.String = stringStruct;
+        end
+
+        function ArrayWithMultipleElements = initializeArrayWithMultipleElements()
+            boolStruct = struct(Array=arrow.array([true false true]), ...
+                String="true | false | true");
+            ArrayWithMultipleElements.Boolean = boolStruct;
+            
+            uint8Struct = struct(Array=arrow.array(uint8([1 10 100])), ...
+                String="1 | 10 | 100");
+            ArrayWithMultipleElements.UInt8 = uint8Struct; 
+
+            int64Struct = struct(Array=arrow.array(int64([2 1 20])), ...
+                String="2 | 1 | 20");
+            ArrayWithMultipleElements.Int64 = int64Struct;
+
+            time64Struct = struct(Array=arrow.array(seconds([1 2 3])), ...
+                String="00:00:01.000000 | 00:00:02.000000 | 00:00:03.000000");
+            ArrayWithMultipleElements.Time64 = time64Struct; 
+
+            timestampStruct = struct(Array=arrow.array(datetime(2023, 10, 20) + days(0:2) , TimeUnit="Second"), ...
+                String="2023-10-20 00:00:00 | 2023-10-21 00:00:00 | 2023-10-22 00:00:00");
+            ArrayWithMultipleElements.Timestamp = timestampStruct;
+
+            stringStruct = struct(Array=arrow.array(["A" "ABC" "ABCDE"]), ...
+                String="""A"" | ""ABC"" | ""ABCDE""");
+            ArrayWithMultipleElements.String = stringStruct;
+        end
+
+        function ArrayWithOneNull = initializeArrayWithOneNull()
+            boolStruct = struct(Array=arrow.array([true false true], Valid=[1 3]), ...
+                String="true | null | true");
+            ArrayWithOneNull.Boolean = boolStruct;
+            
+            uint8Struct = struct(Array=arrow.array(uint8([1 10 100]), Valid=[2 3]), ...
+                String="null | 10 | 100");
+            ArrayWithOneNull.UInt8 = uint8Struct; 
+
+            int64Struct = struct(Array=arrow.array(int64([2 1 20]), Valid=[1 2]), ...
+                String="2 | 1 | null");
+            ArrayWithOneNull.Int64 = int64Struct;
+
+            time64Struct = struct(Array=arrow.array(seconds([1 NaN 3])), ...
+                String="00:00:01.000000 | null | 00:00:03.000000");
+            ArrayWithOneNull.Time64 = time64Struct; 
+
+            timestampStruct = struct(Array=arrow.array([datetime(2023, 10, 20) + days(0:1) NaT] , TimeUnit="Second"), ...
+                String="2023-10-20 00:00:00 | 2023-10-21 00:00:00 | null");
+            ArrayWithOneNull.Timestamp = timestampStruct;
+
+            stringStruct = struct(Array=arrow.array([missing "ABC" "ABCDE"]), ...
+                String="null | ""ABC"" | ""ABCDE""");
+            ArrayWithOneNull.String = stringStruct;
+        end
+
+        function ArrayWithMultipleNulls = initializeArrayWithMultipleNulls()
+            boolStruct = struct(Array=arrow.array([true false true], Valid=1), ...
+                String="true | null | null");
+            ArrayWithMultipleNulls.Boolean = boolStruct;
+            
+            uint8Struct = struct(Array=arrow.array(uint8([1 10 100]), Valid=2), ...
+                String="null | 10 | null");
+            ArrayWithMultipleNulls.UInt8 = uint8Struct; 
+
+            int64Struct = struct(Array=arrow.array(int64([2 1 20]), Valid=3), ...
+                String="null | null | 20");
+            ArrayWithMultipleNulls.Int64 = int64Struct;
+
+            time64Struct = struct(Array=arrow.array(seconds([1 NaN NaN])), ...
+                String="00:00:01.000000 | null | null");
+            ArrayWithMultipleNulls.Time64 = time64Struct; 
+
+            timestampStruct = struct(Array=arrow.array([datetime(2023, 10, 20) NaT NaT] , TimeUnit="Second"), ...
+                String="2023-10-20 00:00:00 | null | null");
+            ArrayWithMultipleNulls.Timestamp = timestampStruct;
+
+            stringStruct = struct(Array=arrow.array([missing "ABC" missing]), ...
+                String="null | ""ABC"" | null");
+            ArrayWithMultipleNulls.String = stringStruct;
+        end
+    end
+
+    methods (Test)
+
+        function DisplayEmptyArray(testCase, EmptyArray)
+            import arrow.internal.test.display.makeLinkString
+
+            fullClassName = string(class(EmptyArray)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+            zeroString = getNumString(0);
+            header = compose("  %s with %s elements and %s null values" + newline, ...
+                classNameLink, zeroString, zeroString);
+
+            expectedDisplay = char(header + newline);
+            actualDisplay = evalc('disp(EmptyArray)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayArrayWithOneElement(testCase, ArrayWithOneElement)
+            import arrow.internal.test.display.makeLinkString
+
+            array = ArrayWithOneElement.Array;
+            fullClassName = string(class(array)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(1);
+            numNullString = getNumString(0);
+            header = compose("  %s with %s element and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body = "    " + ArrayWithOneElement.String + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(array)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayArrayWithMultipleElements(testCase, ArrayWithMultipleElements)
+            import arrow.internal.test.display.makeLinkString
+
+            array = ArrayWithMultipleElements.Array;
+            fullClassName = string(class(array)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(3);
+            numNullString = getNumString(0);
+            header = compose("  %s with %s elements and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body = "    " + ArrayWithMultipleElements.String + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(array)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayArrayWithOneNull(testCase, ArrayWithOneNull)
+            import arrow.internal.test.display.makeLinkString
+
+            array = ArrayWithOneNull.Array;
+            fullClassName = string(class(array)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(3);
+            numNullString = getNumString(1);
+            header = compose("  %s with %s elements and %s null value:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body = "    " + ArrayWithOneNull.String + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(array)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayArrayWithMultipleNulls(testCase, ArrayWithMultipleNulls)
+            import arrow.internal.test.display.makeLinkString
+
+            array = ArrayWithMultipleNulls.Array;
+            fullClassName = string(class(array)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(3);
+            numNullString = getNumString(2);
+            header = compose("  %s with %s elements and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+
+            body = "    " + ArrayWithMultipleNulls.String + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(array)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayWindowSizeThree(testCase)
+            import arrow.internal.test.display.makeLinkString
+            array = arrow.array(1:8);
+            fullClassName = string(class(array)); 
+            displayName = extractAfter(fullClassName, "arrow.array.");
+            classNameLink = makeLinkString(FullClassName=fullClassName, ...
+                                           ClassName=displayName, ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(8);
+            numNullString = getNumString(0);
+            header = compose("  %s with %s elements and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body = "    1 | 2 | 3 | ... | 6 | 7 | 8" + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(array)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+
+        end
+
+        function DisplayStructArray(testCase)
+            import arrow.internal.test.display.makeLinkString
+
+            t = table((1:2)', ["A"; "B"], VariableNames=["Number", "Text"]);
+            structArray = arrow.array(t); %#ok<NASGU>
+
+            classNameLink = makeLinkString(FullClassName="arrow.array.StructArray", ...
+                                           ClassName="StructArray", ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(2);
+            numNullString = getNumString(0);
+            header = compose("  %s with %s elements and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body =  "    -- is_valid: all not null" + newline + ...
+                    "    -- child 0 type: double" + newline + ...
+                    "        [" + newline + ...
+                    "            1," + newline + ...
+                    "            2" + newline + ...
+                    "        ]" + newline + ...
+                    "    -- child 1 type: string" + newline + ...
+                    "        [" + newline + ...
+                    "            ""A""," + newline + ...
+                    "            ""B""" + newline + ...
+                    "        ]" + newline + newline;
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(structArray)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayListArray(testCase)
+            import arrow.internal.test.display.makeLinkString
+
+            Offsets = arrow.array(int32([0, 2, 3]));
+            Values = arrow.array([1, 2, 3]);
+
+            listArray = arrow.array.ListArray.fromArrays(Offsets, Values); %#ok<NASGU>
+
+            classNameLink = makeLinkString(FullClassName="arrow.array.ListArray", ...
+                                           ClassName="ListArray", ...
+                                           BoldFont=true);
+
+            numElementString = getNumString(2);
+            numNullString = getNumString(0);
+            header = compose("  %s with %s elements and %s null values:" + newline, ...
+                classNameLink, numElementString, numNullString);
+
+            body =  "    [" + newline + ... 
+                    "        [" + newline + ...
+                    "            1," + newline + ...
+                    "            2" + newline + ...
+                    "        ]," + newline + ...
+                    "        [" + newline + ...
+                    "            3" + newline + ...
+                    "        ]" + newline + ...
+                    "    ]" + newline + newline;
+            
+            expectedDisplay = char(strjoin([header body], newline));
+            actualDisplay = evalc('disp(listArray)');
+            testCase.verifyEqual(actualDisplay, expectedDisplay); 
+        end
+
+    end
+
+end
+
+function numString = getNumString(num)
+    if usejava("desktop")
+        numString = compose("<strong>%d</strong>", num);
+    else
+        numString = compose("%d", num);
+    end
+ end
\ No newline at end of file

From 9e2d4aa2e8743f9302da8823f3c519ab038fc767 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 24 Oct 2023 17:12:44 -0400
Subject: [PATCH 621/749] GH-38395: [Go] fix rounding errors in decimal256
 string functions (#38426)

### Rationale for this change
Slight modifications to the `ToString` and `FromString` methods of decimal 256 to ensure proper accurate and proper conversion given precision and scale.

### Are these changes tested?
Yes

* Closes: #38395

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/decimal128/decimal128.go      | 46 +++++++++++++++++---------
 go/arrow/decimal128/decimal128_test.go | 17 ++++++++++
 go/arrow/decimal256/decimal256.go      | 45 ++++++++++++++++---------
 go/arrow/decimal256/decimal256_test.go | 46 ++++++++++++++++++++++++++
 4 files changed, 124 insertions(+), 30 deletions(-)

diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index 898d7b427ec84..ff9c088b9d638 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -266,23 +266,35 @@ func FromString(v string, prec, scale int32) (n Num, err error) {
 		return
 	}
 
-	// Since we're going to truncate this to get an integer, we need to round
-	// the value instead because of edge cases so that we match how other implementations
-	// (e.g. C++) handles Decimal values. So if we're negative we'll subtract 0.5 and if
-	// we're positive we'll add 0.5.
-	out.Mul(out, big.NewFloat(math.Pow10(int(scale)))).SetPrec(precInBits)
-	if out.Signbit() {
-		out.Sub(out, pt5)
+	if scale < 0 {
+		var tmp big.Int
+		val, _ := out.Int(&tmp)
+		if val.BitLen() > 127 {
+			return Num{}, errors.New("bitlen too large for decimal128")
+		}
+		n = FromBigInt(val)
+		n, _ = n.Div(scaleMultipliers[-scale])
 	} else {
-		out.Add(out, pt5)
-	}
+		// Since we're going to truncate this to get an integer, we need to round
+		// the value instead because of edge cases so that we match how other implementations
+		// (e.g. C++) handles Decimal values. So if we're negative we'll subtract 0.5 and if
+		// we're positive we'll add 0.5.
+		p := (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt())
+		out.Mul(out, p).SetPrec(precInBits)
+		if out.Signbit() {
+			out.Sub(out, pt5)
+		} else {
+			out.Add(out, pt5)
+		}
 
-	var tmp big.Int
-	val, _ := out.Int(&tmp)
-	if val.BitLen() > 127 {
-		return Num{}, errors.New("bitlen too large for decimal128")
+		var tmp big.Int
+		val, _ := out.Int(&tmp)
+		if val.BitLen() > 127 {
+			return Num{}, errors.New("bitlen too large for decimal128")
+		}
+		n = FromBigInt(val)
 	}
-	n = FromBigInt(val)
+
 	if !n.FitsInPrecision(prec) {
 		err = fmt.Errorf("val %v doesn't fit in precision %d", n, prec)
 	}
@@ -505,7 +517,11 @@ func (n Num) FitsInPrecision(prec int32) bool {
 
 func (n Num) ToString(scale int32) string {
 	f := (&big.Float{}).SetInt(n.BigInt())
-	f.Quo(f, (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt()))
+	if scale < 0 {
+		f.SetPrec(128).Mul(f, (&big.Float{}).SetInt(scaleMultipliers[-scale].BigInt()))
+	} else {
+		f.SetPrec(128).Quo(f, (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt()))
+	}
 	return f.Text('f', int(scale))
 }
 
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index 6fa54091019e7..102eede6d3b28 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -659,6 +659,7 @@ func TestFromString(t *testing.T) {
 		{"1e-37", 1, 37},
 		{"2112.33", 211233, 2},
 		{"-2112.33", -211233, 2},
+		{"12E2", 12, -2},
 	}
 
 	for _, tt := range tests {
@@ -681,3 +682,19 @@ func TestInvalidNonNegScaleFromString(t *testing.T) {
 		})
 	}
 }
+
+func TestBitLen(t *testing.T) {
+	n := decimal128.GetScaleMultiplier(38)
+	b := n.BigInt()
+	b.Mul(b, big.NewInt(25))
+	assert.Greater(t, b.BitLen(), 128)
+
+	assert.Panics(t, func() {
+		decimal128.FromBigInt(b)
+	})
+
+	_, err := decimal128.FromString(b.String(), decimal128.MaxPrecision, 0)
+	assert.ErrorContains(t, err, "bitlen too large for decimal128")
+	_, err = decimal128.FromString(b.String(), decimal128.MaxPrecision, -1)
+	assert.ErrorContains(t, err, "bitlen too large for decimal128")
+}
diff --git a/go/arrow/decimal256/decimal256.go b/go/arrow/decimal256/decimal256.go
index 4bfcd4e0419f2..cf2157fdd48ed 100644
--- a/go/arrow/decimal256/decimal256.go
+++ b/go/arrow/decimal256/decimal256.go
@@ -154,23 +154,34 @@ func FromString(v string, prec, scale int32) (n Num, err error) {
 		return
 	}
 
-	out.Mul(out, big.NewFloat(math.Pow10(int(scale)))).SetPrec(precInBits)
-	// Since we're going to truncate this to get an integer, we need to round
-	// the value instead because of edge cases so that we match how other implementations
-	// (e.g. C++) handles Decimal values. So if we're negative we'll subtract 0.5 and if
-	// we're positive we'll add 0.5.
-	if out.Signbit() {
-		out.Sub(out, pt5)
+	if scale < 0 {
+		var tmp big.Int
+		val, _ := out.Int(&tmp)
+		if val.BitLen() > 255 {
+			return Num{}, errors.New("bitlen too large for decimal256")
+		}
+		n = FromBigInt(val)
+
+		n, _ = n.Div(scaleMultipliers[-scale])
 	} else {
-		out.Add(out, pt5)
-	}
+		out.Mul(out, (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt())).SetPrec(precInBits)
+		// Since we're going to truncate this to get an integer, we need to round
+		// the value instead because of edge cases so that we match how other implementations
+		// (e.g. C++) handles Decimal values. So if we're negative we'll subtract 0.5 and if
+		// we're positive we'll add 0.5.
+		if out.Signbit() {
+			out.Sub(out, pt5)
+		} else {
+			out.Add(out, pt5)
+		}
 
-	var tmp big.Int
-	val, _ := out.Int(&tmp)
-	if val.BitLen() > 255 {
-		return Num{}, errors.New("bitlen too large for decimal256")
+		var tmp big.Int
+		val, _ := out.Int(&tmp)
+		if val.BitLen() > 255 {
+			return Num{}, errors.New("bitlen too large for decimal256")
+		}
+		n = FromBigInt(val)
 	}
-	n = FromBigInt(val)
 	if !n.FitsInPrecision(prec) {
 		err = fmt.Errorf("value %v doesn't fit in precision %d", n, prec)
 	}
@@ -506,7 +517,11 @@ func (n Num) FitsInPrecision(prec int32) bool {
 
 func (n Num) ToString(scale int32) string {
 	f := (&big.Float{}).SetInt(n.BigInt())
-	f.Quo(f, (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt()))
+	if scale < 0 {
+		f.SetPrec(256).Mul(f, (&big.Float{}).SetInt(scaleMultipliers[-scale].BigInt()))
+	} else {
+		f.SetPrec(256).Quo(f, (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt()))
+	}
 	return f.Text('f', int(scale))
 }
 
diff --git a/go/arrow/decimal256/decimal256_test.go b/go/arrow/decimal256/decimal256_test.go
index b944d0b1305df..9c734e23aa0d6 100644
--- a/go/arrow/decimal256/decimal256_test.go
+++ b/go/arrow/decimal256/decimal256_test.go
@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"math"
 	"math/big"
+	"strings"
 	"testing"
 
 	"github.com/apache/arrow/go/v14/arrow/decimal256"
@@ -563,6 +564,7 @@ func TestFromString(t *testing.T) {
 		{"1e-37", 1, 37},
 		{"2112.33", 211233, 2},
 		{"-2112.33", -211233, 2},
+		{"12E2", 12, -2},
 	}
 
 	for _, tt := range tests {
@@ -575,3 +577,47 @@ func TestFromString(t *testing.T) {
 		})
 	}
 }
+
+// Test issues from GH-38395
+func TestToString(t *testing.T) {
+	const decStr = "3379334159166193114608287418738414931564221155305735605033949613740461239999"
+
+	integer, _ := (&big.Int{}).SetString(decStr, 10)
+	dec := decimal256.FromBigInt(integer)
+
+	expected := "0." + decStr
+	assert.Equal(t, expected, dec.ToString(int32(len(decStr))))
+	assert.Equal(t, decStr+"0000", dec.ToString(-4))
+}
+
+// Test issues from GH-38395
+func TestHexFromString(t *testing.T) {
+	const decStr = "11111111111111111111111111111111111111.00000000000000000000000000000000000000"
+
+	num, err := decimal256.FromString(decStr, 76, 38)
+	if err != nil {
+		t.Error(err)
+	} else if decStr != num.ToString(38) {
+		t.Errorf("expected: %s, actual: %s\n", decStr, num.ToString(38))
+
+		actualCoeff := num.BigInt()
+		expectedCoeff, _ := (&big.Int{}).SetString(strings.Replace(decStr, ".", "", -1), 10)
+		t.Errorf("expected(hex): %X, actual(hex): %X\n", expectedCoeff.Bytes(), actualCoeff.Bytes())
+	}
+}
+
+func TestBitLen(t *testing.T) {
+	n := decimal256.GetScaleMultiplier(76)
+	b := n.BigInt()
+	b.Mul(b, big.NewInt(25))
+	assert.Greater(t, b.BitLen(), 255)
+
+	assert.Panics(t, func() {
+		decimal256.FromBigInt(b)
+	})
+
+	_, err := decimal256.FromString(b.String(), decimal256.MaxPrecision, 0)
+	assert.ErrorContains(t, err, "bitlen too large for decimal256")
+	_, err = decimal256.FromString(b.String(), decimal256.MaxPrecision, -1)
+	assert.ErrorContains(t, err, "bitlen too large for decimal256")
+}

From a449072745e0b188b4f164958b9a6d751c3a2ae0 Mon Sep 17 00:00:00 2001
From: abandy <abandy@live.com>
Date: Tue, 24 Oct 2023 22:10:07 -0400
Subject: [PATCH 622/749] GH-38131: [Swift][CI] Add linting and fix linting
 errors (#38133)

Description:

- Added swiftlint to swift CI job: swift_test.sh.
- Fixed swiftlint errors in swift files.
* Closes: #38131

Lead-authored-by: Alva Bandy <abandy@live.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/docker/ubuntu-swift.dockerfile             |  16 +-
 ci/scripts/swift_test.sh                      |   8 +-
 swift/.swiftlint.yml                          |  33 ++++
 swift/Arrow/Sources/Arrow/ArrowArray.swift    | 165 ++++++++---------
 .../Sources/Arrow/ArrowArrayBuilder.swift     |  58 +++---
 swift/Arrow/Sources/Arrow/ArrowBuffer.swift   |  20 +-
 .../Sources/Arrow/ArrowBufferBuilder.swift    | 119 ++++++------
 swift/Arrow/Sources/Arrow/ArrowData.swift     |  16 +-
 swift/Arrow/Sources/Arrow/ArrowReader.swift   |  17 +-
 .../Sources/Arrow/ArrowReaderHelper.swift     |  49 +++--
 swift/Arrow/Sources/Arrow/ArrowSchema.swift   |  14 +-
 swift/Arrow/Sources/Arrow/ArrowTable.swift    |  54 +++---
 swift/Arrow/Sources/Arrow/ArrowType.swift     | 162 ++++++++---------
 swift/Arrow/Sources/Arrow/ArrowWriter.swift   | 106 ++++++-----
 .../Sources/Arrow/ArrowWriterHelper.swift     |  46 +++--
 swift/Arrow/Sources/Arrow/BitUtility.swift    |   1 -
 swift/Arrow/Sources/Arrow/ChunkedArray.swift  |  50 ++---
 .../Arrow/Sources/Arrow/MemoryAllocator.swift |   4 +-
 swift/Arrow/Tests/ArrowTests/ArrayTests.swift |  94 +++++-----
 swift/Arrow/Tests/ArrowTests/IPCTests.swift   | 171 ++++++++++--------
 .../Tests/ArrowTests/RecordBatchTests.swift   |  10 +-
 swift/Arrow/Tests/ArrowTests/TableTests.swift |  52 +++---
 .../Sources/ArrowFlight/FlightAction.swift    |  16 +-
 .../ArrowFlight/FlightActionType.swift        |   4 +-
 .../Sources/ArrowFlight/FlightClient.swift    |  33 ++--
 .../Sources/ArrowFlight/FlightCriteria.swift  |   6 +-
 .../Sources/ArrowFlight/FlightData.swift      |  24 +--
 .../ArrowFlight/FlightDescriptor.swift        |  12 +-
 .../Sources/ArrowFlight/FlightEndpoint.swift  |   8 +-
 .../Sources/ArrowFlight/FlightInfo.swift      |  26 +--
 .../Sources/ArrowFlight/FlightLocation.swift  |   8 +-
 .../Sources/ArrowFlight/FlightPutResult.swift |   4 +-
 .../Sources/ArrowFlight/FlightResult.swift    |   4 +-
 .../ArrowFlight/FlightSchemaResult.swift      |   6 +-
 .../Sources/ArrowFlight/FlightServer.swift    | 112 +++++++-----
 .../Sources/ArrowFlight/FlightTicket.swift    |   4 +-
 .../ArrowFlight/RecordBatchStreamReader.swift |  25 +--
 .../ArrowFlight/RecordBatchStreamWriter.swift |  12 +-
 .../Tests/ArrowFlightTests/FlightTest.swift   | 135 +++++++-------
 39 files changed, 906 insertions(+), 798 deletions(-)
 create mode 100644 swift/.swiftlint.yml

diff --git a/ci/docker/ubuntu-swift.dockerfile b/ci/docker/ubuntu-swift.dockerfile
index 5ef6bc433df38..4789c9188c226 100644
--- a/ci/docker/ubuntu-swift.dockerfile
+++ b/ci/docker/ubuntu-swift.dockerfile
@@ -17,8 +17,18 @@
 
 FROM swift:5.7.3
 
-# Install golang
+# Go is needed for generating test data
 RUN apt-get update -y -q && \
     apt-get install -y -q --no-install-recommends \
-        golang-go && \
-    apt-get clean
\ No newline at end of file
+        golang-go \
+        unzip \
+        wget && \
+    apt-get clean
+
+ARG swift_lint=0.53.0
+RUN wget https://github.com/realm/SwiftLint/releases/download/${swift_lint}/swiftlint_linux.zip && \
+    unzip swiftlint_linux.zip && \
+    mv swiftlint /usr/local/bin/ && \
+    mkdir -p /usr/local/share/doc/swiftlint/ && \
+    mv LICENSE /usr/local/share/doc/swiftlint/ && \
+    rm -rf swiftlint_linux.zip
diff --git a/ci/scripts/swift_test.sh b/ci/scripts/swift_test.sh
index b7ab37fd489c9..b523e3891d93c 100755
--- a/ci/scripts/swift_test.sh
+++ b/ci/scripts/swift_test.sh
@@ -20,12 +20,18 @@
 set -ex
 
 data_gen_dir=${1}/swift/data-generator/swift-datagen
+export GOPATH=/
 pushd ${data_gen_dir}
 go get -d ./...
-go run main.go
+go run .
 cp *.arrow ../../Arrow
 popd
 
+source_dir=${1}/swift
+pushd ${source_dir}
+swiftlint --strict
+popd
+
 source_dir=${1}/swift/Arrow
 pushd ${source_dir}
 swift test
diff --git a/swift/.swiftlint.yml b/swift/.swiftlint.yml
new file mode 100644
index 0000000000000..9ce377285973f
--- /dev/null
+++ b/swift/.swiftlint.yml
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+included:
+  - Arrow/Sources
+  - Arrow/Tests
+  - ArrowFlight/Sources
+  - ArrowFlight/Tests
+excluded:
+  - Arrow/Sources/Arrow/File_generated.swift
+  - Arrow/Sources/Arrow/Message_generated.swift
+  - Arrow/Sources/Arrow/Schema_generated.swift
+  - Arrow/Sources/Arrow/SparseTensor_generated.swift
+  - Arrow/Sources/Arrow/Tensor_generated.swift
+  - ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
+  - ArrowFlight/Sources/ArrowFlight/Flight.pb.swift
+identifier_name:
+  min_length: 2 # only warning
+allow_zero_lintable_files: false
diff --git a/swift/Arrow/Sources/Arrow/ArrowArray.swift b/swift/Arrow/Sources/Arrow/ArrowArray.swift
index 1d41cc7e37feb..88b43e63a92b7 100644
--- a/swift/Arrow/Sources/Arrow/ArrowArray.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowArray.swift
@@ -37,9 +37,9 @@ public class ArrowArrayHolder {
                 buffer.append(to: &bufferData[bufferData.count - 1])
             }
 
-            return bufferData;
+            return bufferData
         }
-        
+
         self.getBufferDataSizes = {() -> [Int] in
             var bufferDataSizes = [Int]()
             for buffer in arrowArray.arrowData.buffers {
@@ -48,7 +48,7 @@ public class ArrowArrayHolder {
 
             return bufferDataSizes
         }
-        
+
         self.getArrowColumn = {(field: ArrowField, arrayHolders: [ArrowArrayHolder]) throws -> ArrowColumn in
             var arrays = [ArrowArray<T>]()
             for arrayHolder in arrayHolders {
@@ -56,12 +56,14 @@ public class ArrowArrayHolder {
                     arrays.append(array)
                 }
             }
-            
+
             return ArrowColumn(field, chunked: ChunkedArrayHolder(try ChunkedArray<T>(arrays)))
         }
     }
-    
-    public static func makeArrowColumn(_ field: ArrowField, holders: [ArrowArrayHolder]) -> Result<ArrowColumn, ArrowError> {
+
+    public static func makeArrowColumn(_ field: ArrowField,
+                                       holders: [ArrowArrayHolder]
+    ) -> Result<ArrowColumn, ArrowError> {
         do {
             return .success(try holders[0].getArrowColumn(field, holders))
         } catch {
@@ -73,9 +75,9 @@ public class ArrowArrayHolder {
 public class ArrowArray<T>: AsString {
     public typealias ItemType = T
     public let arrowData: ArrowData
-    public var nullCount : UInt {get{return self.arrowData.nullCount}}
-    public var length: UInt {get{return self.arrowData.length}}
-    
+    public var nullCount: UInt {return self.arrowData.nullCount}
+    public var length: UInt {return self.arrowData.length}
+
     public required init(_ arrowData: ArrowData) {
         self.arrowData = arrowData
     }
@@ -84,102 +86,92 @@ public class ArrowArray<T>: AsString {
         if at >= self.length {
             throw ArrowError.outOfBounds(index: Int64(at))
         }
-        
+
         return self.arrowData.isNull(at)
     }
 
     public subscript(_ index: UInt) -> T? {
-        get {
-            fatalError("subscript() has not been implemented")
-        }
+        fatalError("subscript() has not been implemented")
     }
-    
+
     public func asString(_ index: UInt) -> String {
         if self[index] == nil {
             return ""
         }
-        
+
         return "\(self[index]!)"
     }
 }
 
 public class FixedArray<T>: ArrowArray<T> {
     public override subscript(_ index: UInt) -> T? {
-        get {
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-            
-            let byteOffset = self.arrowData.stride * Int(index);
-            return self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: T.self)
+        if self.arrowData.isNull(index) {
+            return nil
         }
+
+        let byteOffset = self.arrowData.stride * Int(index)
+        return self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: T.self)
     }
 }
 
 public class StringArray: ArrowArray<String> {
     public override subscript(_ index: UInt) -> String? {
-        get {
-            let offsetIndex = MemoryLayout<Int32>.stride * Int(index)
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-            
-            let offsets = self.arrowData.buffers[1]
-            let values = self.arrowData.buffers[2]
+        let offsetIndex = MemoryLayout<Int32>.stride * Int(index)
+        if self.arrowData.isNull(index) {
+            return nil
+        }
 
-            var startIndex: Int32 = 0
-            if index > 0 {
-                startIndex = offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)    
-            }
+        let offsets = self.arrowData.buffers[1]
+        let values = self.arrowData.buffers[2]
 
-            let endIndex = offsets.rawPointer.advanced(by: offsetIndex + MemoryLayout<Int32>.stride ).load(as: Int32.self)
-            let arrayLength = Int(endIndex - startIndex);
-            let rawPointer =  values.rawPointer.advanced(by: Int(startIndex)).bindMemory(to: UInt8.self, capacity: arrayLength)
-            let buffer = UnsafeBufferPointer<UInt8>(start: rawPointer, count: arrayLength);
-            let byteArray = Array(buffer)
-            return String(data: Data(byteArray), encoding: .utf8)
+        var startIndex: Int32 = 0
+        if index > 0 {
+            startIndex = offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)
         }
+
+        let endIndex = offsets.rawPointer.advanced(by: offsetIndex + MemoryLayout<Int32>.stride )
+            .load(as: Int32.self)
+        let arrayLength = Int(endIndex - startIndex)
+        let rawPointer =  values.rawPointer.advanced(by: Int(startIndex))
+            .bindMemory(to: UInt8.self, capacity: arrayLength)
+        let buffer = UnsafeBufferPointer<UInt8>(start: rawPointer, count: arrayLength)
+        let byteArray = Array(buffer)
+        return String(data: Data(byteArray), encoding: .utf8)
     }
 }
 
 public class BoolArray: ArrowArray<Bool> {
     public override subscript(_ index: UInt) -> Bool? {
-        get {
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-
-            let valueBuffer = self.arrowData.buffers[1];
-            return BitUtility.isSet(index, buffer: valueBuffer)
+        if self.arrowData.isNull(index) {
+            return nil
         }
+
+        let valueBuffer = self.arrowData.buffers[1]
+        return BitUtility.isSet(index, buffer: valueBuffer)
     }
 }
 
 public class Date32Array: ArrowArray<Date> {
     public override subscript(_ index: UInt) -> Date? {
-        get {
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-
-            let byteOffset = self.arrowData.stride * Int(index);
-            let milliseconds = self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: UInt32.self)
-            return Date(timeIntervalSince1970: TimeInterval(milliseconds * 86400))
+        if self.arrowData.isNull(index) {
+            return nil
         }
+
+        let byteOffset = self.arrowData.stride * Int(index)
+        let milliseconds = self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: UInt32.self)
+        return Date(timeIntervalSince1970: TimeInterval(milliseconds * 86400))
     }
 }
 
 public class Date64Array: ArrowArray<Date> {
     public override subscript(_ index: UInt) -> Date? {
-        get {
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-
-            let byteOffset = self.arrowData.stride * Int(index);
-            let milliseconds = self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: UInt64.self)
-            return Date(timeIntervalSince1970: TimeInterval(milliseconds / 1000))
+        if self.arrowData.isNull(index) {
+            return nil
         }
+
+        let byteOffset = self.arrowData.stride * Int(index)
+        let milliseconds = self.arrowData.buffers[1].rawPointer.advanced(by: byteOffset).load(as: UInt64.self)
+        return Date(timeIntervalSince1970: TimeInterval(milliseconds / 1000))
     }
 }
 
@@ -189,40 +181,39 @@ public class Time64Array: FixedArray<Time64> {}
 public class BinaryArray: ArrowArray<Data> {
     public struct Options {
         public var printAsHex = false
-        public var printEncoding: String.Encoding = .utf8;
+        public var printEncoding: String.Encoding = .utf8
     }
-    
+
     public var options = Options()
-    
-    public override subscript(_ index: UInt) -> Data? {
-        get {
-            let offsetIndex = MemoryLayout<Int32>.stride * Int(index)
-            if self.arrowData.isNull(index) {
-                return nil
-            }
-            
-            let offsets = self.arrowData.buffers[1]
-            let values = self.arrowData.buffers[2]
 
-            var startIndex: Int32 = 0
-            if index > 0 {
-                startIndex = offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)
-            }
+    public override subscript(_ index: UInt) -> Data? {
+        let offsetIndex = MemoryLayout<Int32>.stride * Int(index)
+        if self.arrowData.isNull(index) {
+            return nil
+        }
 
-            let endIndex = offsets.rawPointer.advanced(by: offsetIndex + MemoryLayout<Int32>.stride ).load(as: Int32.self)
-            let arrayLength = Int(endIndex - startIndex);
-            let rawPointer =  values.rawPointer.advanced(by: Int(startIndex)).bindMemory(to: UInt8.self, capacity: arrayLength)
-            let buffer = UnsafeBufferPointer<UInt8>(start: rawPointer, count: arrayLength);
-            let byteArray = Array(buffer)
-            return Data(byteArray)
+        let offsets = self.arrowData.buffers[1]
+        let values = self.arrowData.buffers[2]
+        var startIndex: Int32 = 0
+        if index > 0 {
+            startIndex = offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)
         }
+
+        let endIndex = offsets.rawPointer.advanced(by: offsetIndex + MemoryLayout<Int32>.stride )
+            .load(as: Int32.self)
+        let arrayLength = Int(endIndex - startIndex)
+        let rawPointer =  values.rawPointer.advanced(by: Int(startIndex))
+            .bindMemory(to: UInt8.self, capacity: arrayLength)
+        let buffer = UnsafeBufferPointer<UInt8>(start: rawPointer, count: arrayLength)
+        let byteArray = Array(buffer)
+        return Data(byteArray)
     }
-    
+
     public override func asString(_ index: UInt) -> String {
         if self[index] == nil {
             return ""
         }
-        
+
         let data = self[index]!
         if options.printAsHex {
             return data.hexEncodedString()
diff --git a/swift/Arrow/Sources/Arrow/ArrowArrayBuilder.swift b/swift/Arrow/Sources/Arrow/ArrowArrayBuilder.swift
index 049b58bc33425..32728dc7eeaa4 100644
--- a/swift/Arrow/Sources/Arrow/ArrowArrayBuilder.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowArrayBuilder.swift
@@ -20,13 +20,13 @@ import Foundation
 public class ArrowArrayBuilder<T: ArrowBufferBuilder, U: ArrowArray<T.ItemType>> {
     let type: ArrowType
     let bufferBuilder: T
-    public var length: UInt {get{return self.bufferBuilder.length}}
-    public var capacity: UInt {get{return self.bufferBuilder.capacity}}
-    public var nullCount : UInt {get{return self.bufferBuilder.nullCount}}
-    public var offset: UInt {get{return self.bufferBuilder.offset}}
-    
+    public var length: UInt {return self.bufferBuilder.length}
+    public var capacity: UInt {return self.bufferBuilder.capacity}
+    public var nullCount: UInt {return self.bufferBuilder.nullCount}
+    public var offset: UInt {return self.bufferBuilder.offset}
+
     fileprivate init(_ type: ArrowType) throws {
-        self.type = type;
+        self.type = type
         self.bufferBuilder = try T()
     }
 
@@ -35,51 +35,51 @@ public class ArrowArrayBuilder<T: ArrowBufferBuilder, U: ArrowArray<T.ItemType>>
     }
 
     public func finish() throws -> ArrowArray<T.ItemType> {
-        let buffers = self.bufferBuilder.finish();
+        let buffers = self.bufferBuilder.finish()
         let arrowData = try ArrowData(self.type, buffers: buffers, nullCount: self.nullCount, stride: self.getStride())
         return U(arrowData)
     }
-    
+
     public func getStride() -> Int {
         MemoryLayout<T.ItemType>.stride
     }
 }
 
-public class NumberArrayBuilder<T> : ArrowArrayBuilder<FixedBufferBuilder<T>, FixedArray<T>> {
+public class NumberArrayBuilder<T>: ArrowArrayBuilder<FixedBufferBuilder<T>, FixedArray<T>> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.infoForNumericType(T.self)))
     }
 }
 
-public class StringArrayBuilder : ArrowArrayBuilder<VariableBufferBuilder<String>, StringArray> {
+public class StringArrayBuilder: ArrowArrayBuilder<VariableBufferBuilder<String>, StringArray> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.ArrowString))
     }
 }
 
-public class BinaryArrayBuilder : ArrowArrayBuilder<VariableBufferBuilder<Data>, BinaryArray> {
+public class BinaryArrayBuilder: ArrowArrayBuilder<VariableBufferBuilder<Data>, BinaryArray> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.ArrowBinary))
     }
 }
 
-public class BoolArrayBuilder : ArrowArrayBuilder<BoolBufferBuilder, BoolArray> {
+public class BoolArrayBuilder: ArrowArrayBuilder<BoolBufferBuilder, BoolArray> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.ArrowBool))
     }
 }
 
-public class Date32ArrayBuilder : ArrowArrayBuilder<Date32BufferBuilder, Date32Array> {
+public class Date32ArrayBuilder: ArrowArrayBuilder<Date32BufferBuilder, Date32Array> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.ArrowDate32))
     }
-    
+
     public override func getStride() -> Int {
         MemoryLayout<Int32>.stride
     }
 }
 
-public class Date64ArrayBuilder : ArrowArrayBuilder<Date64BufferBuilder, Date64Array> {
+public class Date64ArrayBuilder: ArrowArrayBuilder<Date64BufferBuilder, Date64Array> {
     fileprivate convenience init() throws {
         try self.init(ArrowType(ArrowType.ArrowDate64))
     }
@@ -89,13 +89,13 @@ public class Date64ArrayBuilder : ArrowArrayBuilder<Date64BufferBuilder, Date64A
     }
 }
 
-public class Time32ArrayBuilder : ArrowArrayBuilder<FixedBufferBuilder<Time32>, Time32Array> {
+public class Time32ArrayBuilder: ArrowArrayBuilder<FixedBufferBuilder<Time32>, Time32Array> {
     fileprivate convenience init(_ unit: ArrowTime32Unit) throws {
         try self.init(ArrowTypeTime32(unit))
     }
 }
 
-public class Time64ArrayBuilder : ArrowArrayBuilder<FixedBufferBuilder<Time64>, Time64Array> {
+public class Time64ArrayBuilder: ArrowArrayBuilder<FixedBufferBuilder<Time64>, Time64Array> {
     fileprivate convenience init(_ unit: ArrowTime64Unit) throws {
         try self.init(ArrowTypeTime64(unit))
     }
@@ -103,26 +103,26 @@ public class Time64ArrayBuilder : ArrowArrayBuilder<FixedBufferBuilder<Time64>,
 
 public class ArrowArrayBuilders {
     public static func loadNumberArrayBuilder<T>() throws -> NumberArrayBuilder<T> {
-        let t = T.self
-        if t == Int8.self {
+        let type = T.self
+        if type == Int8.self {
             return try NumberArrayBuilder<T>()
-        } else if t == Int16.self  {
+        } else if type == Int16.self {
             return try NumberArrayBuilder<T>()
-        } else if t == Int32.self  {
+        } else if type == Int32.self {
             return try NumberArrayBuilder<T>()
-        } else if t == Int64.self  {
+        } else if type == Int64.self {
             return try NumberArrayBuilder<T>()
-        } else if t == UInt8.self  {
+        } else if type == UInt8.self {
             return try NumberArrayBuilder<T>()
-        } else if t == UInt16.self {
+        } else if type == UInt16.self {
             return try NumberArrayBuilder<T>()
-        } else if t == UInt32.self  {
+        } else if type == UInt32.self {
             return try NumberArrayBuilder<T>()
-        } else if t == UInt64.self {
+        } else if type == UInt64.self {
             return try NumberArrayBuilder<T>()
-        } else if t == Float.self  {
+        } else if type == Float.self {
             return try NumberArrayBuilder<T>()
-        } else if t == Double.self {
+        } else if type == Double.self {
             return try NumberArrayBuilder<T>()
         } else {
             throw ArrowError.unknownType("Type is invalid for NumberArrayBuilder")
@@ -144,7 +144,7 @@ public class ArrowArrayBuilders {
     public static func loadDate64ArrayBuilder() throws -> Date64ArrayBuilder {
         return try Date64ArrayBuilder()
     }
-    
+
     public static func loadBinaryArrayBuilder() throws -> BinaryArrayBuilder {
         return try BinaryArrayBuilder()
     }
diff --git a/swift/Arrow/Sources/Arrow/ArrowBuffer.swift b/swift/Arrow/Sources/Arrow/ArrowBuffer.swift
index d56279bcf8657..4ac4eb93c91db 100644
--- a/swift/Arrow/Sources/Arrow/ArrowBuffer.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowBuffer.swift
@@ -18,8 +18,8 @@
 import Foundation
 
 public class ArrowBuffer {
-    static let min_length: UInt = 1 << 5
-    static let max_length = UInt.max    
+    static let minLength: UInt = 1 << 5
+    static let maxLength = UInt.max
     fileprivate(set) var length: UInt
     let capacity: UInt
     let rawPointer: UnsafeMutableRawPointer
@@ -36,7 +36,7 @@ public class ArrowBuffer {
 
     func append(to data: inout Data) {
         let ptr  = UnsafePointer(rawPointer.assumingMemoryBound(to: UInt8.self))
-        data.append(ptr, count: Int(capacity));
+        data.append(ptr, count: Int(capacity))
     }
 
     static func createBuffer(_ data: [UInt8], length: UInt) -> ArrowBuffer {
@@ -49,13 +49,13 @@ public class ArrowBuffer {
     }
 
     static func createBuffer(_ length: UInt, size: UInt, doAlign: Bool = true) -> ArrowBuffer {
-        let actualLen = max(length, ArrowBuffer.min_length)
+        let actualLen = max(length, ArrowBuffer.minLength)
         let byteCount = size * actualLen
         var capacity = byteCount
         if doAlign {
             capacity = alignTo64(byteCount)
         }
-        
+
         let memory = MemoryAllocator(64)
         let rawPointer = memory.allocateArray(Int(capacity))
         rawPointer.initializeMemory(as: UInt8.self, repeating: 0, count: Int(capacity))
@@ -64,14 +64,14 @@ public class ArrowBuffer {
 
     static func copyCurrent(_ from: ArrowBuffer, to: inout ArrowBuffer, len: UInt) {
         to.rawPointer.copyMemory(from: from.rawPointer, byteCount: Int(len))
-    }    
+    }
 
     private static func alignTo64(_ length: UInt) -> UInt {
-        let buf_alignment = length % 64;
-        if buf_alignment != 0 {
-            return length + (64 - buf_alignment) + 8;
+        let bufAlignment = length % 64
+        if bufAlignment != 0 {
+            return length + (64 - bufAlignment) + 8
         }
 
-        return length + 8;
+        return length + 8
     }
 }
diff --git a/swift/Arrow/Sources/Arrow/ArrowBufferBuilder.swift b/swift/Arrow/Sources/Arrow/ArrowBufferBuilder.swift
index 39b0434c3cdc7..e4c8036c327d1 100644
--- a/swift/Arrow/Sources/Arrow/ArrowBufferBuilder.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowBufferBuilder.swift
@@ -21,7 +21,7 @@ public protocol ArrowBufferBuilder {
     associatedtype ItemType
     var capacity: UInt {get}
     var length: UInt {get}
-    var nullCount : UInt {get}
+    var nullCount: UInt {get}
     var offset: UInt {get}
     init() throws
     func append(_ newValue: ItemType?)
@@ -33,11 +33,11 @@ public protocol ArrowBufferBuilder {
 public class BaseBufferBuilder<T> {
     var values: ArrowBuffer
     var nulls: ArrowBuffer
-    var stride: Int;
+    var stride: Int
     public var offset: UInt = 0
-    public var capacity: UInt {get{return self.values.capacity}}
+    public var capacity: UInt {return self.values.capacity}
     public var length: UInt = 0
-    public var nullCount : UInt  = 0
+    public var nullCount: UInt  = 0
 
     init(values: ArrowBuffer, nulls: ArrowBuffer, stride: Int = MemoryLayout<T>.stride) {
         self.stride = stride
@@ -51,13 +51,13 @@ public class BaseBufferBuilder<T> {
 
     func resizeLength(_ data: ArrowBuffer, len: UInt = 0) -> UInt {
         if len == 0 || len < data.length * 2 {
-            if data.length == 0 || data.length * 2 < ArrowBuffer.min_length {
-                return ArrowBuffer.min_length
+            if data.length == 0 || data.length * 2 < ArrowBuffer.minLength {
+                return ArrowBuffer.minLength
             }
-            return UInt(data.length * 2);
+            return UInt(data.length * 2)
         }
-        
-        return UInt(len * 2);
+
+        return UInt(len * 2)
     }
 }
 
@@ -91,13 +91,13 @@ public class FixedBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder {
 
     public func resize(_ length: UInt) {
         if length > self.values.length {
-            let resizeLength = resizeLength(self.values);
+            let resizeLength = resizeLength(self.values)
             var values = ArrowBuffer.createBuffer(resizeLength, size: UInt(MemoryLayout<T>.size))
             var nulls = ArrowBuffer.createBuffer(resizeLength/8 + 1, size: UInt(MemoryLayout<UInt8>.size))
             ArrowBuffer.copyCurrent(self.values, to: &values, len: self.values.capacity)
             ArrowBuffer.copyCurrent(self.nulls, to: &nulls, len: self.nulls.capacity)
-            self.values = values;  
-            self.nulls = nulls;
+            self.values = values
+            self.nulls = nulls
         }
     }
 
@@ -109,31 +109,31 @@ public class FixedBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder {
         ArrowBuffer.copyCurrent(self.nulls, to: &nulls, len: nulls.capacity)
         return [nulls, values]
     }
-    
+
     fileprivate static func defaultValueForType() throws -> T {
-        let t = T.self
-        if t == Int8.self {
-            return Int8(0) as! T
-        }else if t == Int16.self {
-            return Int16(0) as! T
-        }else if t == Int32.self {
-            return Int32(0) as! T
-        }else if t == Int64.self {
-            return Int64(0) as! T
-        }else if t == UInt8.self {
-            return UInt8(0) as! T
-        }else if t == UInt16.self {
-            return UInt16(0) as! T
-        }else if t == UInt32.self {
-            return UInt32(0) as! T
-        }else if t == UInt64.self {
-            return UInt64(0) as! T
-        }else if t == Float.self {
-            return Float(0) as! T
-        }else if t == Double.self {
-            return Double(0) as! T
+        let type = T.self
+        if type == Int8.self {
+            return Int8(0) as! T // swiftlint:disable:this force_cast
+        } else if type == Int16.self {
+            return Int16(0) as! T // swiftlint:disable:this force_cast
+        } else if type == Int32.self {
+            return Int32(0) as! T // swiftlint:disable:this force_cast
+        } else if type == Int64.self {
+            return Int64(0) as! T // swiftlint:disable:this force_cast
+        } else if type == UInt8.self {
+            return UInt8(0) as! T // swiftlint:disable:this force_cast
+        } else if type == UInt16.self {
+            return UInt16(0) as! T // swiftlint:disable:this force_cast
+        } else if type == UInt32.self {
+            return UInt32(0) as! T // swiftlint:disable:this force_cast
+        } else if type == UInt64.self {
+            return UInt64(0) as! T // swiftlint:disable:this force_cast
+        } else if type == Float.self {
+            return Float(0) as! T // swiftlint:disable:this force_cast
+        } else if type == Double.self {
+            return Double(0) as! T // swiftlint:disable:this force_cast
         }
-        
+
         throw ArrowError.unknownType("Unable to determine default value")
     }
 }
@@ -160,7 +160,7 @@ public class BoolBufferBuilder: BaseBufferBuilder<Bool>, ArrowBufferBuilder {
             } else {
                 BitUtility.clearBit(index + self.offset, buffer: self.values)
             }
-            
+
         } else {
             self.nullCount += 1
             BitUtility.clearBit(index + self.offset, buffer: self.nulls)
@@ -175,8 +175,8 @@ public class BoolBufferBuilder: BaseBufferBuilder<Bool>, ArrowBufferBuilder {
             var nulls = ArrowBuffer.createBuffer(resizeLength, size: UInt(MemoryLayout<UInt8>.size))
             ArrowBuffer.copyCurrent(self.values, to: &values, len: self.values.capacity)
             ArrowBuffer.copyCurrent(self.nulls, to: &nulls, len: self.nulls.capacity)
-            self.values = values;
-            self.nulls = nulls;
+            self.values = values
+            self.nulls = nulls
         }
     }
 
@@ -191,7 +191,7 @@ public class BoolBufferBuilder: BaseBufferBuilder<Bool>, ArrowBufferBuilder {
 }
 
 public class VariableBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder {
-    public typealias ItemType = T    
+    public typealias ItemType = T
     var offsets: ArrowBuffer
     let binaryStride = MemoryLayout<UInt8>.stride
     public required init() throws {
@@ -212,14 +212,14 @@ public class VariableBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder
         var isNull = false
         if let val = newValue {
             binData = getBytesFor(val)!
-        }else {
+        } else {
             var nullVal = 0
             isNull = true
             binData = Data(bytes: &nullVal, count: MemoryLayout<UInt32>.size)
         }
 
-        var currentIndex: Int32 = 0;
-        var currentOffset: Int32 = Int32(binData.count);
+        var currentIndex: Int32 = 0
+        var currentOffset: Int32 = Int32(binData.count)
         if index > 0 {
             currentIndex = self.offsets.rawPointer.advanced(by: offsetIndex).load(as: Int32.self)
             currentOffset += currentIndex
@@ -237,30 +237,32 @@ public class VariableBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder
 
         binData.withUnsafeBytes { bufferPointer in
             let rawPointer = bufferPointer.baseAddress!
-             self.values.rawPointer.advanced(by: Int(currentIndex)).copyMemory(from: rawPointer, byteCount: binData.count)
+             self.values.rawPointer.advanced(by: Int(currentIndex))
+                .copyMemory(from: rawPointer, byteCount: binData.count)
         }
 
-        self.offsets.rawPointer.advanced(by: (offsetIndex + MemoryLayout<Int32>.stride)).storeBytes(of: currentOffset, as: Int32.self)
+        self.offsets.rawPointer.advanced(by: (offsetIndex + MemoryLayout<Int32>.stride))
+            .storeBytes(of: currentOffset, as: Int32.self)
     }
 
     public func value_resize(_ length: UInt) {
         if length > self.values.length {
-            let resizeLength = resizeLength(self.values, len: length);
+            let resizeLength = resizeLength(self.values, len: length)
             var values = ArrowBuffer.createBuffer(resizeLength, size: UInt(MemoryLayout<UInt8>.size))
             ArrowBuffer.copyCurrent(self.values, to: &values, len: self.values.capacity)
-            self.values = values;
+            self.values = values
         }
     }
-    
+
     public func resize(_ length: UInt) {
         if length > self.offsets.length {
-            let resizeLength = resizeLength(self.offsets, len: length);
+            let resizeLength = resizeLength(self.offsets, len: length)
             var nulls = ArrowBuffer.createBuffer(resizeLength/8 + 1, size: UInt(MemoryLayout<UInt8>.size))
             var offsets = ArrowBuffer.createBuffer(resizeLength, size: UInt(MemoryLayout<Int32>.size))
             ArrowBuffer.copyCurrent(self.nulls, to: &nulls, len: self.nulls.capacity)
             ArrowBuffer.copyCurrent(self.offsets, to: &offsets, len: self.offsets.capacity)
-            self.nulls = nulls;
-            self.offsets = offsets;
+            self.nulls = nulls
+            self.offsets = offsets
         }
     }
 
@@ -278,10 +280,10 @@ public class VariableBufferBuilder<T>: BaseBufferBuilder<T>, ArrowBufferBuilder
 
 public class AbstractWrapperBufferBuilder<T, U>: ArrowBufferBuilder {
     public typealias ItemType = T
-    public var capacity: UInt {get{return self.bufferBuilder.capacity}}
-    public var length: UInt {get{return self.bufferBuilder.length}}
-    public var nullCount : UInt {get{return self.bufferBuilder.nullCount}}
-    public var offset: UInt {get{return self.bufferBuilder.offset}}
+    public var capacity: UInt {return self.bufferBuilder.capacity}
+    public var length: UInt {return self.bufferBuilder.length}
+    public var nullCount: UInt {return self.bufferBuilder.nullCount}
+    public var offset: UInt {return self.bufferBuilder.offset}
     let bufferBuilder: FixedBufferBuilder<U>
     public required init() throws {
         self.bufferBuilder = try FixedBufferBuilder()
@@ -294,18 +296,17 @@ public class AbstractWrapperBufferBuilder<T, U>: ArrowBufferBuilder {
     public func isNull(_ index: UInt) -> Bool {
         return self.bufferBuilder.isNull(index)
     }
-    
+
     public func resize(_ length: UInt) {
         self.bufferBuilder.resize(length)
     }
-    
+
     public func finish() -> [ArrowBuffer] {
         return self.bufferBuilder.finish()
     }
 }
 
-
-public class Date32BufferBuilder: AbstractWrapperBufferBuilder<Date,Int32> {
+public class Date32BufferBuilder: AbstractWrapperBufferBuilder<Date, Int32> {
     public override func append(_ newValue: ItemType?) {
         if let val = newValue {
             let daysSinceEpoch = Int32(val.timeIntervalSince1970 / 86400)
@@ -316,7 +317,7 @@ public class Date32BufferBuilder: AbstractWrapperBufferBuilder<Date,Int32> {
     }
 }
 
-public class Date64BufferBuilder: AbstractWrapperBufferBuilder<Date,Int64> {
+public class Date64BufferBuilder: AbstractWrapperBufferBuilder<Date, Int64> {
     public override func append(_ newValue: ItemType?) {
         if let val = newValue {
             let daysSinceEpoch = Int64(val.timeIntervalSince1970 * 1000)
diff --git a/swift/Arrow/Sources/Arrow/ArrowData.swift b/swift/Arrow/Sources/Arrow/ArrowData.swift
index 4d50ef75c3ce7..60281a8d24133 100644
--- a/swift/Arrow/Sources/Arrow/ArrowData.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowData.swift
@@ -26,17 +26,17 @@ public class ArrowData {
 
     init(_ arrowType: ArrowType, buffers: [ArrowBuffer], nullCount: UInt, stride: Int) throws {
         let infoType = arrowType.info
-        switch(infoType) {
-        case let .PrimitiveInfo(typeId):
-            if typeId == ArrowTypeId.Unknown {
+        switch infoType {
+        case let .primitiveInfo(typeId):
+            if typeId == ArrowTypeId.unknown {
                 throw ArrowError.unknownType("Unknown primitive type for data")
             }
-        case let .VariableInfo(typeId):
-            if typeId == ArrowTypeId.Unknown {
+        case let .variableInfo(typeId):
+            if typeId == ArrowTypeId.unknown {
                 throw ArrowError.unknownType("Unknown variable type for data")
             }
-        case let .TimeInfo(typeId):
-            if typeId == ArrowTypeId.Unknown {
+        case let .timeInfo(typeId):
+            if typeId == ArrowTypeId.unknown {
                 throw ArrowError.unknownType("Unknown time type for data")
             }
         }
@@ -49,7 +49,7 @@ public class ArrowData {
     }
 
     public func isNull(_ at: UInt) -> Bool {
-        let nullBuffer = buffers[0];
+        let nullBuffer = buffers[0]
         return nullBuffer.length > 0 && !BitUtility.isSet(at, buffer: nullBuffer)
     }
 }
diff --git a/swift/Arrow/Sources/Arrow/ArrowReader.swift b/swift/Arrow/Sources/Arrow/ArrowReader.swift
index b4c8c7227659a..68096133451ba 100644
--- a/swift/Arrow/Sources/Arrow/ArrowReader.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowReader.swift
@@ -35,9 +35,9 @@ public class ArrowReader {
         public var schema: ArrowSchema?
         public var batches = [RecordBatch]()
     }
-    
+
     public init() {}
-    
+
     private func loadSchema(_ schema: org_apache_arrow_flatbuf_Schema) -> Result<ArrowSchema, ArrowError> {
         let builder = ArrowSchema.Builder()
         for index in 0 ..< schema.fieldsCount {
@@ -95,8 +95,12 @@ public class ArrowReader {
         }
     }
 
-    private func loadRecordBatch(_ message: org_apache_arrow_flatbuf_Message, schema: org_apache_arrow_flatbuf_Schema,
-                                 arrowSchema: ArrowSchema, data: Data, messageEndOffset: Int64) -> Result<RecordBatch, ArrowError> {
+    private func loadRecordBatch(_ message: org_apache_arrow_flatbuf_Message,
+                                 schema: org_apache_arrow_flatbuf_Schema,
+                                 arrowSchema: ArrowSchema,
+                                 data: Data,
+                                 messageEndOffset: Int64
+    ) -> Result<RecordBatch, ArrowError> {
         let recordBatch = message.header(type: org_apache_arrow_flatbuf_RecordBatch.self)
         let nodesCount = recordBatch?.nodesCount ?? 0
         var bufferIndex: Int32 = 0
@@ -114,16 +118,15 @@ public class ArrowReader {
                 result = loadVariableData(loadInfo)
                 bufferIndex += 3
             }
-            
+
             switch result {
             case .success(let holder):
                 columns.append(holder)
             case .failure(let error):
                 return .failure(error)
             }
-            
         }
-        
+
         return .success(RecordBatch(arrowSchema, columns: columns))
     }
 
diff --git a/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift b/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
index ca635723bca8b..2e5a12c6c08f3 100644
--- a/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
@@ -18,7 +18,7 @@
 import FlatBuffers
 import Foundation
 
-fileprivate func makeBinaryHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeBinaryHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
     do {
         let arrowData = try ArrowData(ArrowType(ArrowType.ArrowBinary), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<Int8>.stride)
@@ -30,7 +30,7 @@ fileprivate func makeBinaryHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArray
     }
 }
 
-fileprivate func makeStringHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeStringHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
     do {
         let arrowData = try ArrowData(ArrowType(ArrowType.ArrowString), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<Int8>.stride)
@@ -42,7 +42,9 @@ fileprivate func makeStringHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArray
     }
 }
 
-fileprivate func makeFloatHolder(_ floatType: org_apache_arrow_flatbuf_FloatingPoint, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeFloatHolder(_ floatType: org_apache_arrow_flatbuf_FloatingPoint,
+                             buffers: [ArrowBuffer]
+) -> Result<ArrowArrayHolder, ArrowError> {
     switch floatType.precision {
     case .single:
         return makeFixedHolder(Float.self, buffers: buffers)
@@ -53,14 +55,16 @@ fileprivate func makeFloatHolder(_ floatType: org_apache_arrow_flatbuf_FloatingP
     }
 }
 
-fileprivate func makeDateHolder(_ dateType: org_apache_arrow_flatbuf_Date, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
-    do  {
+private func makeDateHolder(_ dateType: org_apache_arrow_flatbuf_Date,
+                            buffers: [ArrowBuffer]
+) -> Result<ArrowArrayHolder, ArrowError> {
+    do {
         if dateType.unit == .day {
             let arrowData = try ArrowData(ArrowType(ArrowType.ArrowString), buffers: buffers,
                                           nullCount: buffers[0].length, stride: MemoryLayout<Date>.stride)
             return .success(ArrowArrayHolder(Date32Array(arrowData)))
         }
-        
+
         let arrowData = try ArrowData(ArrowType(ArrowType.ArrowString), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<Date>.stride)
         return .success(ArrowArrayHolder(Date64Array(arrowData)))
@@ -71,17 +75,18 @@ fileprivate func makeDateHolder(_ dateType: org_apache_arrow_flatbuf_Date, buffe
     }
 }
 
-fileprivate func makeTimeHolder(_ timeType: org_apache_arrow_flatbuf_Time, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
-    do  {
+private func makeTimeHolder(_ timeType: org_apache_arrow_flatbuf_Time,
+                            buffers: [ArrowBuffer]
+) -> Result<ArrowArrayHolder, ArrowError> {
+    do {
         if timeType.unit == .second || timeType.unit == .millisecond {
-            let arrowUnit: ArrowTime32Unit = timeType.unit == .second ? .Seconds : .Milliseconds
+            let arrowUnit: ArrowTime32Unit = timeType.unit == .second ? .seconds : .milliseconds
             let arrowData = try ArrowData(ArrowTypeTime32(arrowUnit), buffers: buffers,
                                           nullCount: buffers[0].length, stride: MemoryLayout<Time32>.stride)
-            
             return .success(ArrowArrayHolder(FixedArray<Time32>(arrowData)))
         }
-        
-        let arrowUnit: ArrowTime64Unit = timeType.unit == .microsecond ? .Microseconds : .Nanoseconds
+
+        let arrowUnit: ArrowTime64Unit = timeType.unit == .microsecond ? .microseconds : .nanoseconds
         let arrowData = try ArrowData(ArrowTypeTime64(arrowUnit), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<Time64>.stride)
         return .success(ArrowArrayHolder(FixedArray<Time64>(arrowData)))
@@ -92,7 +97,7 @@ fileprivate func makeTimeHolder(_ timeType: org_apache_arrow_flatbuf_Time, buffe
     }
 }
 
-fileprivate func makeBoolHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeBoolHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
     do {
         let arrowData = try ArrowData(ArrowType(ArrowType.ArrowInt32), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<UInt8>.stride)
@@ -104,7 +109,7 @@ fileprivate func makeBoolHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHo
     }
 }
 
-fileprivate func makeFixedHolder<T>(_: T.Type, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeFixedHolder<T>(_: T.Type, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
     do {
         let arrowData = try ArrowData(ArrowType(ArrowType.ArrowInt32), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<T>.stride)
@@ -116,7 +121,10 @@ fileprivate func makeFixedHolder<T>(_: T.Type, buffers: [ArrowBuffer]) -> Result
     }
 }
 
-func makeArrayHolder(_ field: org_apache_arrow_flatbuf_Field, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+func makeArrayHolder( // swiftlint:disable:this cyclomatic_complexity
+    _ field: org_apache_arrow_flatbuf_Field,
+    buffers: [ArrowBuffer]
+) -> Result<ArrowArrayHolder, ArrowError> {
     let type = field.typeType
     switch type {
     case .int:
@@ -185,7 +193,8 @@ func isFixedPrimitive(_ type: org_apache_arrow_flatbuf_Type_) -> Bool {
     }
 }
 
-func findArrowType(_ field: org_apache_arrow_flatbuf_Field) -> ArrowType {
+func findArrowType( // swiftlint:disable:this cyclomatic_complexity
+    _ field: org_apache_arrow_flatbuf_Field) -> ArrowType {
     let type = field.typeType
     switch type {
     case .int:
@@ -217,15 +226,15 @@ func findArrowType(_ field: org_apache_arrow_flatbuf_Field) -> ArrowType {
         if dateType.unit == .day {
             return ArrowType(ArrowType.ArrowDate32)
         }
-        
+
         return ArrowType(ArrowType.ArrowDate64)
     case .time:
         let timeType = field.type(type: org_apache_arrow_flatbuf_Time.self)!
         if timeType.unit == .second || timeType.unit == .millisecond {
-            return ArrowTypeTime32(timeType.unit == .second ? .Seconds : .Milliseconds)
+            return ArrowTypeTime32(timeType.unit == .second ? .seconds : .milliseconds)
         }
-        
-        return ArrowTypeTime64(timeType.unit == .microsecond ? .Microseconds : .Nanoseconds)
+
+        return ArrowTypeTime64(timeType.unit == .microsecond ? .microseconds : .nanoseconds)
     default:
         return ArrowType(ArrowType.ArrowUnknown)
     }
diff --git a/swift/Arrow/Sources/Arrow/ArrowSchema.swift b/swift/Arrow/Sources/Arrow/ArrowSchema.swift
index 882e66a24777e..45f13a1551c3d 100644
--- a/swift/Arrow/Sources/Arrow/ArrowSchema.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowSchema.swift
@@ -20,7 +20,7 @@ public class ArrowField {
     let type: ArrowType
     let name: String
     let isNullable: Bool
-    
+
     init(_ name: String, type: ArrowType, isNullable: Bool) {
         self.name = name
         self.type = type
@@ -34,13 +34,13 @@ public class ArrowSchema {
     init(_ fields: [ArrowField]) {
         var fieldLookup = [String: Int]()
         for (index, field) in fields.enumerated() {
-            fieldLookup[field.name] = index;
+            fieldLookup[field.name] = index
         }
-        
+
         self.fields = fields
         self.fieldLookup = fieldLookup
     }
-    
+
     public func field(_ index: Int) -> ArrowField {
         return self.fields[index]
     }
@@ -51,9 +51,9 @@ public class ArrowSchema {
 
     public class Builder {
         private var fields: [ArrowField] = []
-        
+
         public init() {}
-        
+
         @discardableResult
         public func addField(_ field: ArrowField) -> Builder {
             fields.append(field)
@@ -65,7 +65,7 @@ public class ArrowSchema {
             fields.append(ArrowField(name, type: type, isNullable: isNullable))
             return self
         }
-        
+
         public func finish() -> ArrowSchema {
             return ArrowSchema(fields)
         }
diff --git a/swift/Arrow/Sources/Arrow/ArrowTable.swift b/swift/Arrow/Sources/Arrow/ArrowTable.swift
index a288286a824fb..7677fb4f33a19 100644
--- a/swift/Arrow/Sources/Arrow/ArrowTable.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowTable.swift
@@ -20,15 +20,15 @@ import Foundation
 public class ArrowColumn {
     public let field: ArrowField
     fileprivate let dataHolder: ChunkedArrayHolder
-    public var type: ArrowType {get{return self.dataHolder.type}}
-    public var length: UInt {get{return self.dataHolder.length}}
-    public var nullCount: UInt {get{return self.dataHolder.nullCount}}
+    public var type: ArrowType {return self.dataHolder.type}
+    public var length: UInt {return self.dataHolder.length}
+    public var nullCount: UInt {return self.dataHolder.nullCount}
 
     public func data<T>() -> ChunkedArray<T> {
-        return (self.dataHolder.holder as! ChunkedArray<T>)
+        return (self.dataHolder.holder as! ChunkedArray<T>) // swiftlint:disable:this force_cast
     }
 
-    public var name: String {get{return field.name}}
+    public var name: String {return field.name}
     public init(_ field: ArrowField, chunked: ChunkedArrayHolder) {
         self.field = field
         self.dataHolder = chunked
@@ -37,7 +37,7 @@ public class ArrowColumn {
 
 public class ArrowTable {
     public let schema: ArrowSchema
-    public var columnCount: UInt {get{return UInt(self.columns.count)}}
+    public var columnCount: UInt {return UInt(self.columns.count)}
     public let rowCount: UInt
     public let columns: [ArrowColumn]
     init(_ schema: ArrowSchema, columns: [ArrowColumn]) {
@@ -45,14 +45,14 @@ public class ArrowTable {
         self.columns = columns
         self.rowCount = columns[0].length
     }
-    
+
     public static func from(recordBatches: [RecordBatch]) -> Result<ArrowTable, ArrowError> {
-        if(recordBatches.isEmpty) {
+        if recordBatches.isEmpty {
             return .failure(.arrayHasNoElements)
         }
-        
+
         var holders = [[ArrowArrayHolder]]()
-        let schema = recordBatches[0].schema;
+        let schema = recordBatches[0].schema
         for recordBatch in recordBatches {
             for index in 0..<schema.fields.count {
                 if holders.count <= index {
@@ -61,7 +61,7 @@ public class ArrowTable {
                 holders[index].append(recordBatch.columns[index])
             }
         }
-        
+
         let builder = ArrowTable.Builder()
         for index in 0..<schema.fields.count {
             switch ArrowArrayHolder.makeArrowColumn(schema.fields[index], holders: holders[index]) {
@@ -71,16 +71,16 @@ public class ArrowTable {
                 return .failure(error)
             }
         }
-        
+
         return .success(builder.finish())
     }
-    
+
     public class Builder {
         let schemaBuilder = ArrowSchema.Builder()
         var columns = [ArrowColumn]()
-        
+
         public init() {}
-        
+
         @discardableResult
         public func addColumn<T>(_ fieldName: String, arrowArray: ArrowArray<T>) throws -> Builder {
             return self.addColumn(fieldName, chunked: try ChunkedArray([arrowArray]))
@@ -115,7 +115,7 @@ public class ArrowTable {
             self.columns.append(column)
             return self
         }
-        
+
         public func finish() -> ArrowTable {
             return ArrowTable(self.schemaBuilder.finish(), columns: self.columns)
         }
@@ -124,7 +124,7 @@ public class ArrowTable {
 
 public class RecordBatch {
     public let schema: ArrowSchema
-    public var columnCount: UInt {get{return UInt(self.columns.count)}}
+    public var columnCount: UInt {return UInt(self.columns.count)}
     public let columns: [ArrowArrayHolder]
     public let length: UInt
     public init(_ schema: ArrowSchema, columns: [ArrowArrayHolder]) {
@@ -132,13 +132,13 @@ public class RecordBatch {
         self.columns = columns
         self.length = columns[0].length
     }
-    
+
     public class Builder {
         let schemaBuilder = ArrowSchema.Builder()
         var columns = [ArrowArrayHolder]()
-        
+
         public init() {}
-        
+
         @discardableResult
         public func addColumn(_ fieldName: String, arrowArray: ArrowArrayHolder) -> Builder {
             let field = ArrowField(fieldName, type: arrowArray.type, isNullable: arrowArray.nullCount != 0)
@@ -158,7 +158,7 @@ public class RecordBatch {
             if columns.count > 0 {
                 let columnLength = columns[0].length
                 for column in columns {
-                    if column.length != columnLength {
+                    if column.length != columnLength { // swiftlint:disable:this for_where
                         return .failure(.runtimeError("Columns have different sizes"))
                     }
                 }
@@ -166,12 +166,12 @@ public class RecordBatch {
             return .success(RecordBatch(self.schemaBuilder.finish(), columns: self.columns))
         }
     }
-    
+
     public func data<T>(for columnIndex: Int) -> ArrowArray<T> {
         let arrayHolder = column(columnIndex)
-        return (arrayHolder.array as! ArrowArray<T>)
+        return (arrayHolder.array as! ArrowArray<T>) // swiftlint:disable:this force_cast
     }
-    
+
     public func column(_ index: Int) -> ArrowArrayHolder {
         return self.columns[index]
     }
@@ -180,9 +180,7 @@ public class RecordBatch {
         if let index = self.schema.fieldIndex(name) {
             return self.columns[index]
         }
-        
-        return nil;
-    }
-
 
+        return nil
+    }
 }
diff --git a/swift/Arrow/Sources/Arrow/ArrowType.swift b/swift/Arrow/Sources/Arrow/ArrowType.swift
index cf9d7f4dba399..e1c1ef271cc0f 100644
--- a/swift/Arrow/Sources/Arrow/ArrowType.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowType.swift
@@ -20,9 +20,9 @@ import Foundation
 public typealias Time32 = Int32
 public typealias Time64 = Int64
 
-func FlatBuffersVersion_23_1_4() {
+func FlatBuffersVersion_23_1_4() { // swiftlint:disable:this identifier_name
 }
-                                                                                  
+
 public enum ArrowError: Error {
     case none
     case unknownType(String)
@@ -36,50 +36,50 @@ public enum ArrowError: Error {
 }
 
 public enum ArrowTypeId {
-    case Binary
-    case Boolean
-    case Date32
-    case Date64
-    case DateType
-    case Decimal128
-    case Decimal256
-    case Dictionary
-    case Double
-    case FixedSizeBinary
-    case FixedWidthType
-    case Float
-    //case HalfFloatType
-    case Int16
-    case Int32
-    case Int64
-    case Int8
-    case Integer
-    case IntervalUnit
-    case List
-    case Nested
-    case Null
-    case Number
-    case String
-    case Struct
-    case Time32
-    case Time64
-    case Time
-    case UInt16
-    case UInt32
-    case UInt64
-    case UInt8
-    case Union
-    case Unknown
+    case binary
+    case boolean
+    case date32
+    case date64
+    case dateType
+    case decimal128
+    case decimal256
+    case dictionary
+    case double
+    case fixedSizeBinary
+    case fixedWidthType
+    case float
+    // case HalfFloatType
+    case int16
+    case int32
+    case int64
+    case int8
+    case integer
+    case intervalUnit
+    case list
+    case nested
+    case null
+    case number
+    case string
+    case strct
+    case time32
+    case time64
+    case time
+    case uint16
+    case uint32
+    case uint64
+    case uint8
+    case union
+    case unknown
 }
 
 public enum ArrowTime32Unit {
-    case Seconds
-    case Milliseconds
+    case seconds
+    case milliseconds
 }
 
 public enum ArrowTime64Unit {
-    case Microseconds
-    case Nanoseconds
+    case microseconds
+    case nanoseconds
 }
 
 public class ArrowTypeTime32: ArrowType {
@@ -100,70 +100,70 @@ public class ArrowTypeTime64: ArrowType {
 
 public class ArrowType {
     public private(set) var info: ArrowType.Info
-    public static let ArrowInt8 = Info.PrimitiveInfo(ArrowTypeId.Int8)
-    public static let ArrowInt16 = Info.PrimitiveInfo(ArrowTypeId.Int16)
-    public static let ArrowInt32 = Info.PrimitiveInfo(ArrowTypeId.Int32)
-    public static let ArrowInt64 = Info.PrimitiveInfo(ArrowTypeId.Int64)
-    public static let ArrowUInt8 = Info.PrimitiveInfo(ArrowTypeId.UInt8)
-    public static let ArrowUInt16 = Info.PrimitiveInfo(ArrowTypeId.UInt16)
-    public static let ArrowUInt32 = Info.PrimitiveInfo(ArrowTypeId.UInt32)
-    public static let ArrowUInt64 = Info.PrimitiveInfo(ArrowTypeId.UInt64)
-    public static let ArrowFloat = Info.PrimitiveInfo(ArrowTypeId.Float)
-    public static let ArrowDouble = Info.PrimitiveInfo(ArrowTypeId.Double)
-    public static let ArrowUnknown = Info.PrimitiveInfo(ArrowTypeId.Unknown)
-    public static let ArrowString = Info.VariableInfo(ArrowTypeId.String)
-    public static let ArrowBool = Info.PrimitiveInfo(ArrowTypeId.Boolean)
-    public static let ArrowDate32 = Info.PrimitiveInfo(ArrowTypeId.Date32)
-    public static let ArrowDate64 = Info.PrimitiveInfo(ArrowTypeId.Date64)
-    public static let ArrowBinary = Info.VariableInfo(ArrowTypeId.Binary)
-    public static let ArrowTime32 = Info.TimeInfo(ArrowTypeId.Time32)
-    public static let ArrowTime64 = Info.TimeInfo(ArrowTypeId.Time64)
+    public static let ArrowInt8 = Info.primitiveInfo(ArrowTypeId.int8)
+    public static let ArrowInt16 = Info.primitiveInfo(ArrowTypeId.int16)
+    public static let ArrowInt32 = Info.primitiveInfo(ArrowTypeId.int32)
+    public static let ArrowInt64 = Info.primitiveInfo(ArrowTypeId.int64)
+    public static let ArrowUInt8 = Info.primitiveInfo(ArrowTypeId.uint8)
+    public static let ArrowUInt16 = Info.primitiveInfo(ArrowTypeId.uint16)
+    public static let ArrowUInt32 = Info.primitiveInfo(ArrowTypeId.uint32)
+    public static let ArrowUInt64 = Info.primitiveInfo(ArrowTypeId.uint64)
+    public static let ArrowFloat = Info.primitiveInfo(ArrowTypeId.float)
+    public static let ArrowDouble = Info.primitiveInfo(ArrowTypeId.double)
+    public static let ArrowUnknown = Info.primitiveInfo(ArrowTypeId.unknown)
+    public static let ArrowString = Info.variableInfo(ArrowTypeId.string)
+    public static let ArrowBool = Info.primitiveInfo(ArrowTypeId.boolean)
+    public static let ArrowDate32 = Info.primitiveInfo(ArrowTypeId.date32)
+    public static let ArrowDate64 = Info.primitiveInfo(ArrowTypeId.date64)
+    public static let ArrowBinary = Info.variableInfo(ArrowTypeId.binary)
+    public static let ArrowTime32 = Info.timeInfo(ArrowTypeId.time32)
+    public static let ArrowTime64 = Info.timeInfo(ArrowTypeId.time64)
 
     public init(_ info: ArrowType.Info) {
         self.info = info
     }
-    
+
     public enum Info {
-        case PrimitiveInfo(ArrowTypeId)
-        case VariableInfo(ArrowTypeId)
-        case TimeInfo(ArrowTypeId)
+        case primitiveInfo(ArrowTypeId)
+        case variableInfo(ArrowTypeId)
+        case timeInfo(ArrowTypeId)
     }
 
-    public static func infoForNumericType<T>(_ t: T.Type) -> ArrowType.Info {
-        if t == Int8.self {
+    public static func infoForNumericType<T>(_ type: T.Type) -> ArrowType.Info {
+        if type == Int8.self {
             return ArrowType.ArrowInt8
-        }else if t == Int16.self {
+        } else if type == Int16.self {
             return ArrowType.ArrowInt16
-        }else if t == Int32.self {
+        } else if type == Int32.self {
             return ArrowType.ArrowInt32
-        }else if t == Int64.self {
+        } else if type == Int64.self {
             return ArrowType.ArrowInt64
-        }else if t == UInt8.self {
+        } else if type == UInt8.self {
             return ArrowType.ArrowUInt8
-        }else if t == UInt16.self {
+        } else if type == UInt16.self {
             return ArrowType.ArrowUInt16
-        }else if t == UInt32.self {
+        } else if type == UInt32.self {
             return ArrowType.ArrowUInt32
-        }else if t == UInt64.self {
+        } else if type == UInt64.self {
             return ArrowType.ArrowUInt64
-        }else if t == Float.self {
+        } else if type == Float.self {
             return ArrowType.ArrowFloat
-        }else if t == Double.self {
+        } else if type == Double.self {
             return ArrowType.ArrowDouble
-        }else {
+        } else {
             return ArrowType.ArrowUnknown
         }
     }
 }
 
 extension ArrowType.Info: Equatable {
-    public static func==(lhs: ArrowType.Info, rhs: ArrowType.Info) -> Bool {
+    public static func == (lhs: ArrowType.Info, rhs: ArrowType.Info) -> Bool {
         switch(lhs, rhs) {
-        case (.PrimitiveInfo(let lhsId), .PrimitiveInfo(let rhsId)):
+        case (.primitiveInfo(let lhsId), .primitiveInfo(let rhsId)):
             return lhsId == rhsId
-        case (.VariableInfo(let lhsId), .VariableInfo(let rhsId)):
+        case (.variableInfo(let lhsId), .variableInfo(let rhsId)):
             return lhsId == rhsId
-        case (.TimeInfo(let lhsId), .TimeInfo(let rhsId)):
+        case (.timeInfo(let lhsId), .timeInfo(let rhsId)):
             return lhsId == rhsId
         default:
             return false
@@ -172,11 +172,9 @@ extension ArrowType.Info: Equatable {
 }
 
 func getBytesFor<T>(_ data: T) -> Data? {
-    let t = T.self
-    if t == String.self {
-        let temp = data as! String
+    if let temp = data as? String {
         return temp.data(using: .utf8)
-    } else if t == Data.self {
+    } else if T.self == Data.self {
         return data as? Data
     } else {
         return nil
diff --git a/swift/Arrow/Sources/Arrow/ArrowWriter.swift b/swift/Arrow/Sources/Arrow/ArrowWriter.swift
index 9f3d9bd0c853c..efd0b9d3000dc 100644
--- a/swift/Arrow/Sources/Arrow/ArrowWriter.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowWriter.swift
@@ -24,8 +24,8 @@ public protocol DataWriter {
 }
 
 public class ArrowWriter {
-    public class InMemDataWriter : DataWriter {
-        public private(set) var data: Data;
+    public class InMemDataWriter: DataWriter {
+        public private(set) var data: Data
         public var count: Int { return data.count }
         public init(_ data: Data) {
             self.data = data
@@ -33,23 +33,23 @@ public class ArrowWriter {
         convenience init() {
             self.init(Data())
         }
-        
+
         public func append(_ data: Data) {
             self.data.append(data)
         }
     }
 
-    public class FileDataWriter : DataWriter {
+    public class FileDataWriter: DataWriter {
         private var handle: FileHandle
-        private var current_size: Int = 0
-        public var count: Int { return current_size }
+        private var currentSize: Int = 0
+        public var count: Int { return currentSize }
         public init(_ handle: FileHandle) {
             self.handle = handle
         }
-        
+
         public func append(_ data: Data) {
             self.handle.write(data)
-            self.current_size += data.count
+            self.currentSize += data.count
         }
     }
 
@@ -67,9 +67,9 @@ public class ArrowWriter {
             self.init(type, schema: schema, batches: [RecordBatch]())
         }
     }
-    
+
     public init() {}
-    
+
     private func writeField(_ fbb: inout FlatBufferBuilder, field: ArrowField) -> Result<Offset, ArrowError> {
         let nameOffset = fbb.create(string: field.name)
         let fieldTypeOffsetResult = toFBType(&fbb, arrowType: field.type)
@@ -82,7 +82,7 @@ public class ArrowWriter {
         case .failure(let error):
             return .failure(error)
         }
-        
+
         switch fieldTypeOffsetResult {
         case .success(let offset):
             org_apache_arrow_flatbuf_Field.add(type: offset, &fbb)
@@ -101,18 +101,21 @@ public class ArrowWriter {
             case .failure(let error):
                 return .failure(error)
             }
-            
+
         }
 
         let fieldsOffset: Offset = fbb.createVector(ofOffsets: fieldOffsets)
-        let schemaOffset = org_apache_arrow_flatbuf_Schema.createSchema(&fbb, endianness: .little, fieldsVectorOffset: fieldsOffset)
+        let schemaOffset =
+            org_apache_arrow_flatbuf_Schema.createSchema(&fbb,
+                                                         endianness: .little,
+                                                         fieldsVectorOffset: fieldsOffset)
         return .success(schemaOffset)
-
     }
-    
-    private func writeRecordBatches(_ writer: inout DataWriter, batches: [RecordBatch]) -> Result<[org_apache_arrow_flatbuf_Block], ArrowError> {
-        var rbBlocks = [org_apache_arrow_flatbuf_Block]()
 
+    private func writeRecordBatches(_ writer: inout DataWriter,
+                                    batches: [RecordBatch]
+    ) -> Result<[org_apache_arrow_flatbuf_Block], ArrowError> {
+        var rbBlocks = [org_apache_arrow_flatbuf_Block]()
         for batch in batches {
             let startIndex = writer.count
             switch writeRecordBatch(batch: batch) {
@@ -120,8 +123,11 @@ public class ArrowWriter {
                 withUnsafeBytes(of: rbResult.1.o.littleEndian) {writer.append(Data($0))}
                 writer.append(rbResult.0)
                 switch writeRecordBatchData(&writer, batch: batch) {
-                case .success(_):
-                    rbBlocks.append(org_apache_arrow_flatbuf_Block(offset: Int64(startIndex), metaDataLength: Int32(0), bodyLength: Int64(rbResult.1.o)))
+                case .success:
+                    rbBlocks.append(
+                        org_apache_arrow_flatbuf_Block(offset: Int64(startIndex),
+                                                       metaDataLength: Int32(0),
+                                                       bodyLength: Int64(rbResult.1.o)))
                 case .failure(let error):
                     return .failure(error)
                 }
@@ -129,10 +135,10 @@ public class ArrowWriter {
                 return .failure(error)
             }
         }
-                
+
         return .success(rbBlocks)
     }
-        
+
     private func writeRecordBatch(batch: RecordBatch) -> Result<(Data, Offset), ArrowError> {
         let schema = batch.schema
         var output = Data()
@@ -143,12 +149,13 @@ public class ArrowWriter {
         fbb.startVector(schema.fields.count, elementSize: MemoryLayout<org_apache_arrow_flatbuf_FieldNode>.size)
         for index in (0 ..< schema.fields.count).reversed() {
             let column = batch.column(index)
-            let fieldNode = org_apache_arrow_flatbuf_FieldNode(length: Int64(column.length), nullCount: Int64(column.nullCount))
+            let fieldNode =
+                org_apache_arrow_flatbuf_FieldNode(length: Int64(column.length),
+                                                   nullCount: Int64(column.nullCount))
             fieldNodeOffsets.append(fbb.create(struct: fieldNode))
         }
-        
-        let nodeOffset = fbb.endVector(len: schema.fields.count)
 
+        let nodeOffset = fbb.endVector(len: schema.fields.count)
         // write out buffers
         var buffers = [org_apache_arrow_flatbuf_Buffer]()
         var bufferOffset = Int(0)
@@ -162,19 +169,18 @@ public class ArrowWriter {
                 bufferOffset += bufferDataSize
             }
         }
-        
+
         org_apache_arrow_flatbuf_RecordBatch.startVectorOfBuffers(batch.schema.fields.count, in: &fbb)
-        for buffer in buffers.reversed()  {
+        for buffer in buffers.reversed() {
             fbb.create(struct: buffer)
         }
 
         let batchBuffersOffset = fbb.endVector(len: buffers.count)
-        let startRb = org_apache_arrow_flatbuf_RecordBatch.startRecordBatch(&fbb);
-        org_apache_arrow_flatbuf_RecordBatch.addVectorOf(nodes:nodeOffset, &fbb)
-        org_apache_arrow_flatbuf_RecordBatch.addVectorOf(buffers:batchBuffersOffset, &fbb)
+        let startRb = org_apache_arrow_flatbuf_RecordBatch.startRecordBatch(&fbb)
+        org_apache_arrow_flatbuf_RecordBatch.addVectorOf(nodes: nodeOffset, &fbb)
+        org_apache_arrow_flatbuf_RecordBatch.addVectorOf(buffers: batchBuffersOffset, &fbb)
         let recordBatchOffset = org_apache_arrow_flatbuf_RecordBatch.endRecordBatch(&fbb, start: startRb)
-        
-        let bodySize = Int64(bufferOffset);
+        let bodySize = Int64(bufferOffset)
         let startMessage = org_apache_arrow_flatbuf_Message.startMessage(&fbb)
         org_apache_arrow_flatbuf_Message.add(bodyLength: Int64(bodySize), &fbb)
         org_apache_arrow_flatbuf_Message.add(headerType: .recordbatch, &fbb)
@@ -184,11 +190,11 @@ public class ArrowWriter {
         output.append(fbb.data)
         return .success((output, Offset(offset: UInt32(output.count))))
     }
-    
+
     private func writeRecordBatchData(_ writer: inout DataWriter, batch: RecordBatch) -> Result<Bool, ArrowError> {
         for index in 0 ..< batch.schema.fields.count {
             let column = batch.column(index)
-            let colBufferData = column.getBufferData();
+            let colBufferData = column.getBufferData()
             for var bufferData in colBufferData {
                 addPadForAlignment(&bufferData)
                 writer.append(bufferData)
@@ -197,8 +203,10 @@ public class ArrowWriter {
 
         return .success(true)
     }
-    
-    private func writeFooter(schema: ArrowSchema, rbBlocks: [org_apache_arrow_flatbuf_Block])  -> Result<Data, ArrowError> {
+
+    private func writeFooter(schema: ArrowSchema,
+                             rbBlocks: [org_apache_arrow_flatbuf_Block]
+    ) -> Result<Data, ArrowError> {
         var fbb: FlatBufferBuilder = FlatBufferBuilder()
         switch writeSchema(&fbb, schema: schema) {
         case .success(let schemaOffset):
@@ -206,10 +214,8 @@ public class ArrowWriter {
             for blkInfo in rbBlocks.reversed() {
                 fbb.create(struct: blkInfo)
             }
-            
+
             let rbBlkEnd = fbb.endVector(len: rbBlocks.count)
-            
-            
             let footerStartOffset = org_apache_arrow_flatbuf_Footer.startFooter(&fbb)
             org_apache_arrow_flatbuf_Footer.add(schema: schemaOffset, &fbb)
             org_apache_arrow_flatbuf_Footer.addVectorOf(recordBatches: rbBlkEnd, &fbb)
@@ -231,7 +237,7 @@ public class ArrowWriter {
         case .failure(let error):
             return .failure(error)
         }
-        
+
         switch writeRecordBatches(&writer, batches: info.batches) {
         case .success(let rbBlocks):
             switch writeFooter(schema: info.schema, rbBlocks: rbBlocks) {
@@ -240,9 +246,9 @@ public class ArrowWriter {
                 let footerOffset = writer.count
                 writer.append(footerData)
                 addPadForAlignment(&writer)
-                
+
                 withUnsafeBytes(of: Int32(0).littleEndian) { writer.append(Data($0)) }
-                let footerDiff = (UInt32(writer.count) - UInt32(footerOffset));
+                let footerDiff = (UInt32(writer.count) - UInt32(footerOffset))
                 withUnsafeBytes(of: footerDiff.littleEndian) { writer.append(Data($0)) }
             case .failure(let error):
                 return .failure(error)
@@ -257,8 +263,12 @@ public class ArrowWriter {
     public func toStream(_ info: ArrowWriter.Info) -> Result<Data, ArrowError> {
         var writer: any DataWriter = InMemDataWriter()
         switch writeStream(&writer, info: info) {
-        case .success(_):
-            return .success((writer as! InMemDataWriter).data)
+        case .success:
+            if let memWriter = writer as? InMemDataWriter {
+                return .success(memWriter.data)
+            } else {
+                return .failure(.invalid("Unable to cast writer"))
+            }
         case .failure(let error):
             return .failure(error)
         }
@@ -270,22 +280,22 @@ public class ArrowWriter {
         } catch {
             return .failure(.ioError("\(error)"))
         }
-        
+
         let fileHandle = FileHandle(forUpdatingAtPath: fileName.path)!
         defer { fileHandle.closeFile() }
-        
-        var markerData = FILEMARKER.data(using: .utf8)!;
+
+        var markerData = FILEMARKER.data(using: .utf8)!
         addPadForAlignment(&markerData)
 
         var writer: any DataWriter = FileDataWriter(fileHandle)
         writer.append(FILEMARKER.data(using: .utf8)!)
         switch writeStream(&writer, info: info) {
-        case .success(_):
+        case .success:
             writer.append(FILEMARKER.data(using: .utf8)!)
         case .failure(let error):
             return .failure(error)
         }
-        
+
         return .success(true)
     }
 }
diff --git a/swift/Arrow/Sources/Arrow/ArrowWriterHelper.swift b/swift/Arrow/Sources/Arrow/ArrowWriterHelper.swift
index 612df55830860..fdc72ef6e7f11 100644
--- a/swift/Arrow/Sources/Arrow/ArrowWriterHelper.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowWriterHelper.swift
@@ -47,26 +47,36 @@ func toFBTypeEnum(_ arrowType: ArrowType) -> Result<org_apache_arrow_flatbuf_Typ
     return .failure(.unknownType("Unable to find flatbuf type for Arrow type: \(infoType)"))
 }
 
-func toFBType(_ fbb: inout FlatBufferBuilder, arrowType: ArrowType) -> Result<Offset, ArrowError> {
+func toFBType( // swiftlint:disable:this cyclomatic_complexity
+    _ fbb: inout FlatBufferBuilder,
+    arrowType: ArrowType
+) -> Result<Offset, ArrowError> {
     let infoType = arrowType.info
     if infoType == ArrowType.ArrowInt8 || infoType == ArrowType.ArrowUInt8 {
-        return .success(org_apache_arrow_flatbuf_Int.createInt(&fbb, bitWidth: 8, isSigned: infoType == ArrowType.ArrowInt8))
+        return .success(org_apache_arrow_flatbuf_Int.createInt(
+            &fbb, bitWidth: 8, isSigned: infoType == ArrowType.ArrowInt8))
     } else if infoType == ArrowType.ArrowInt16 || infoType == ArrowType.ArrowUInt16 {
-        return .success(org_apache_arrow_flatbuf_Int.createInt(&fbb, bitWidth: 16, isSigned: infoType == ArrowType.ArrowInt16))
+        return .success(org_apache_arrow_flatbuf_Int.createInt(
+            &fbb, bitWidth: 16, isSigned: infoType == ArrowType.ArrowInt16))
     } else if infoType == ArrowType.ArrowInt32 || infoType == ArrowType.ArrowUInt32 {
-        return .success(org_apache_arrow_flatbuf_Int.createInt(&fbb, bitWidth: 32, isSigned: infoType == ArrowType.ArrowInt32))
+        return .success(org_apache_arrow_flatbuf_Int.createInt(
+            &fbb, bitWidth: 32, isSigned: infoType == ArrowType.ArrowInt32))
     } else if infoType == ArrowType.ArrowInt64 || infoType == ArrowType.ArrowUInt64 {
-        return .success(org_apache_arrow_flatbuf_Int.createInt(&fbb, bitWidth: 64, isSigned: infoType == ArrowType.ArrowInt64))
+        return .success(org_apache_arrow_flatbuf_Int.createInt(
+            &fbb, bitWidth: 64, isSigned: infoType == ArrowType.ArrowInt64))
     } else if infoType == ArrowType.ArrowFloat {
         return .success(org_apache_arrow_flatbuf_FloatingPoint.createFloatingPoint(&fbb, precision: .single))
     } else if infoType == ArrowType.ArrowDouble {
         return .success(org_apache_arrow_flatbuf_FloatingPoint.createFloatingPoint(&fbb, precision: .double))
     } else if infoType == ArrowType.ArrowString {
-        return .success(org_apache_arrow_flatbuf_Utf8.endUtf8(&fbb, start: org_apache_arrow_flatbuf_Utf8.startUtf8(&fbb)))
+        return .success(org_apache_arrow_flatbuf_Utf8.endUtf8(
+            &fbb, start: org_apache_arrow_flatbuf_Utf8.startUtf8(&fbb)))
     } else if infoType == ArrowType.ArrowBinary {
-        return .success(org_apache_arrow_flatbuf_Binary.endBinary(&fbb, start: org_apache_arrow_flatbuf_Binary.startBinary(&fbb)))
+        return .success(org_apache_arrow_flatbuf_Binary.endBinary(
+            &fbb, start: org_apache_arrow_flatbuf_Binary.startBinary(&fbb)))
     } else if infoType == ArrowType.ArrowBool {
-        return .success(org_apache_arrow_flatbuf_Bool.endBool(&fbb, start: org_apache_arrow_flatbuf_Bool.startBool(&fbb)))
+        return .success(org_apache_arrow_flatbuf_Bool.endBool(
+            &fbb, start: org_apache_arrow_flatbuf_Bool.startBool(&fbb)))
     } else if infoType == ArrowType.ArrowDate32 {
         let startOffset = org_apache_arrow_flatbuf_Date.startDate(&fbb)
         org_apache_arrow_flatbuf_Date.add(unit: .day, &fbb)
@@ -77,14 +87,20 @@ func toFBType(_ fbb: inout FlatBufferBuilder, arrowType: ArrowType) -> Result<Of
         return .success(org_apache_arrow_flatbuf_Date.endDate(&fbb, start: startOffset))
     } else if infoType == ArrowType.ArrowTime32 {
         let startOffset = org_apache_arrow_flatbuf_Time.startTime(&fbb)
-        let timeType = arrowType as! ArrowTypeTime32
-        org_apache_arrow_flatbuf_Time.add(unit: timeType.unit == .Seconds ? .second : .millisecond, &fbb)
-        return .success(org_apache_arrow_flatbuf_Time.endTime(&fbb, start: startOffset))
+        if let timeType = arrowType as? ArrowTypeTime32 {
+            org_apache_arrow_flatbuf_Time.add(unit: timeType.unit == .seconds ? .second : .millisecond, &fbb)
+            return .success(org_apache_arrow_flatbuf_Time.endTime(&fbb, start: startOffset))
+        }
+
+        return .failure(.invalid("Unable to case to Time32"))
     } else if infoType == ArrowType.ArrowTime64 {
         let startOffset = org_apache_arrow_flatbuf_Time.startTime(&fbb)
-        let timeType = arrowType as! ArrowTypeTime64
-        org_apache_arrow_flatbuf_Time.add(unit: timeType.unit == .Microseconds ? .microsecond : .nanosecond, &fbb)
-        return .success(org_apache_arrow_flatbuf_Time.endTime(&fbb, start: startOffset))
+        if let timeType = arrowType as? ArrowTypeTime64 {
+            org_apache_arrow_flatbuf_Time.add(unit: timeType.unit == .microseconds ? .microsecond : .nanosecond, &fbb)
+            return .success(org_apache_arrow_flatbuf_Time.endTime(&fbb, start: startOffset))
+        }
+
+        return .failure(.invalid("Unable to case to Time64"))
     }
 
     return .failure(.unknownType("Unable to add flatbuf type for Arrow type: \(infoType)"))
@@ -109,6 +125,6 @@ func getPadForAlignment(_ count: Int, alignment: Int = 8) -> Int {
     if padding > 0 {
         return count + (alignment - padding)
     }
-    
+
     return count
 }
diff --git a/swift/Arrow/Sources/Arrow/BitUtility.swift b/swift/Arrow/Sources/Arrow/BitUtility.swift
index 4c5da298033b0..84edf9889b62c 100644
--- a/swift/Arrow/Sources/Arrow/BitUtility.swift
+++ b/swift/Arrow/Sources/Arrow/BitUtility.swift
@@ -38,4 +38,3 @@ class BitUtility {
         buffer.rawPointer.storeBytes(of: theByte, toByteOffset: Int(byteIndex), as: UInt8.self)
     }
 }
-
diff --git a/swift/Arrow/Sources/Arrow/ChunkedArray.swift b/swift/Arrow/Sources/Arrow/ChunkedArray.swift
index edd4d494b14c4..3a06aa46550df 100644
--- a/swift/Arrow/Sources/Arrow/ChunkedArray.swift
+++ b/swift/Arrow/Sources/Arrow/ChunkedArray.swift
@@ -26,16 +26,17 @@ public class ChunkedArrayHolder {
     public let length: UInt
     public let nullCount: UInt
     public let holder: Any
+
     public let getBufferData: () -> Result<[Data], ArrowError>
     public let getBufferDataSizes: () -> Result<[Int], ArrowError>
-    public init<T>(_ chunked: ChunkedArray<T>) {
+    public init<T>(_ chunked: ChunkedArray<T>) { // swiftlint:disable:this cyclomatic_complexity
         self.holder = chunked
         self.length = chunked.length
         self.type = chunked.type
         self.nullCount = chunked.nullCount
         self.getBufferData = {() -> Result<[Data], ArrowError> in
             var bufferData = [Data]()
-            var numBuffers = 2;
+            var numBuffers = 2
             switch toFBTypeEnum(chunked.type) {
             case .success(let fbType):
                 if !isFixedPrimitive(fbType) {
@@ -49,19 +50,19 @@ public class ChunkedArrayHolder {
                 bufferData.append(Data())
             }
 
-            for arrow_data in chunked.arrays {
+            for arrowData in chunked.arrays {
                 for index in 0 ..< numBuffers {
-                    arrow_data.arrowData.buffers[index].append(to: &bufferData[index])
+                    arrowData.arrowData.buffers[index].append(to: &bufferData[index])
                 }
             }
 
-            return .success(bufferData);
+            return .success(bufferData)
         }
-        
+
         self.getBufferDataSizes = {() -> Result<[Int], ArrowError> in
             var bufferDataSizes = [Int]()
-            var numBuffers = 2;
-            
+            var numBuffers = 2
+
             switch toFBTypeEnum(chunked.type) {
             case .success(let fbType):
                 if !isFixedPrimitive(fbType) {
@@ -70,35 +71,34 @@ public class ChunkedArrayHolder {
             case .failure(let error):
                 return .failure(error)
             }
-            
+
             for _ in 0 ..< numBuffers {
                 bufferDataSizes.append(Int(0))
             }
-            
-            for arrow_data in chunked.arrays {
+
+            for arrowData in chunked.arrays {
                 for index in 0 ..< numBuffers {
-                    bufferDataSizes[index] += Int(arrow_data.arrowData.buffers[index].capacity)
+                    bufferDataSizes[index] += Int(arrowData.arrowData.buffers[index].capacity)
                 }
             }
 
             return .success(bufferDataSizes)
         }
-
     }
 }
 
-public class ChunkedArray<T> : AsString {
+public class ChunkedArray<T>: AsString {
     public let arrays: [ArrowArray<T>]
     public let type: ArrowType
     public let nullCount: UInt
     public let length: UInt
-    public var arrayCount: UInt {get{return UInt(self.arrays.count)}}
-    
+    public var arrayCount: UInt {return UInt(self.arrays.count)}
+
     public init(_ arrays: [ArrowArray<T>]) throws {
         if arrays.count == 0 {
             throw ArrowError.arrayHasNoElements
         }
-        
+
         self.type = arrays[0].arrowData.type
         var len: UInt = 0
         var nullCount: UInt = 0
@@ -106,38 +106,38 @@ public class ChunkedArray<T> : AsString {
             len += array.length
             nullCount += array.nullCount
         }
-        
+
         self.arrays = arrays
         self.length = len
         self.nullCount = nullCount
     }
-    
+
     public subscript(_ index: UInt) -> T? {
         if arrays.count == 0 {
             return nil
         }
-        
+
         var localIndex = index
-        var arrayIndex = 0;
+        var arrayIndex = 0
         var len: UInt = arrays[arrayIndex].length
         while localIndex > (len - 1) {
             arrayIndex += 1
             if arrayIndex > arrays.count {
                 return nil
             }
-            
+
             localIndex -= len
             len = arrays[arrayIndex].length
         }
-        
+
         return arrays[arrayIndex][localIndex]
     }
-    
+
     public func asString(_ index: UInt) -> String {
         if self[index] == nil {
             return ""
         }
-        
+
         return "\(self[index]!)"
     }
 }
diff --git a/swift/Arrow/Sources/Arrow/MemoryAllocator.swift b/swift/Arrow/Sources/Arrow/MemoryAllocator.swift
index b4a7bd8e2b890..0f6e54ec0426d 100644
--- a/swift/Arrow/Sources/Arrow/MemoryAllocator.swift
+++ b/swift/Arrow/Sources/Arrow/MemoryAllocator.swift
@@ -22,10 +22,10 @@ public class MemoryAllocator {
     init(_ alignment: Int) {
         self.alignment = alignment
     }
-    
+
     func allocateArray(_ byteCount: Int) -> UnsafeMutableRawPointer {
         return UnsafeMutableRawPointer.allocate(
             byteCount: byteCount,
-            alignment: self.alignment);
+            alignment: self.alignment)
     }
 }
diff --git a/swift/Arrow/Tests/ArrowTests/ArrayTests.swift b/swift/Arrow/Tests/ArrowTests/ArrayTests.swift
index d36073e1618c7..069dbfc88f3ac 100644
--- a/swift/Arrow/Tests/ArrowTests/ArrayTests.swift
+++ b/swift/Arrow/Tests/ArrowTests/ArrayTests.swift
@@ -23,11 +23,11 @@ final class ArrayTests: XCTestCase {
         // This is an example of a functional test case.
         // Use XCTAssert and related functions to verify your tests produce the correct
         // results.
-        let arrayBuilder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
-        for i in 0..<100 {
-            arrayBuilder.append(UInt8(i))
+        let arrayBuilder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
+        for index in 0..<100 {
+            arrayBuilder.append(UInt8(index))
         }
-        
+
         XCTAssertEqual(arrayBuilder.nullCount, 0)
         arrayBuilder.append(nil)
         XCTAssertEqual(arrayBuilder.length, 101)
@@ -38,8 +38,8 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(array[1]!, 1)
         XCTAssertEqual(array[10]!, 10)
         XCTAssertEqual(try array.isNull(100), true)
-        
-        let doubleBuilder: NumberArrayBuilder<Double> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+
+        let doubleBuilder: NumberArrayBuilder<Double> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         doubleBuilder.append(14)
         doubleBuilder.append(40.4)
         XCTAssertEqual(doubleBuilder.nullCount, 0)
@@ -50,33 +50,34 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(doubleArray[0]!, 14)
         XCTAssertEqual(doubleArray[1]!, 40.4)
     }
-    
+
     func testStringArray() throws {
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
-        for i in 0..<100 {
-            if i % 10 == 9 {
+        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
+        for index in 0..<100 {
+            if index % 10 == 9 {
                 stringBuilder.append(nil)
             } else {
-                stringBuilder.append("test" + String(i))
+                stringBuilder.append("test" + String(index))
             }
         }
+
         XCTAssertEqual(stringBuilder.nullCount, 10)
         XCTAssertEqual(stringBuilder.length, 100)
         XCTAssertEqual(stringBuilder.capacity, 648)
         let stringArray = try stringBuilder.finish()
         XCTAssertEqual(stringArray.length, 100)
-        for i in 0..<stringArray.length {
-            if i % 10 == 9 {
-                XCTAssertEqual(try stringArray.isNull(i), true)
+        for index in 0..<stringArray.length {
+            if index % 10 == 9 {
+                XCTAssertEqual(try stringArray.isNull(index), true)
             } else {
-                XCTAssertEqual(stringArray[i]!, "test" + String(i))
+                XCTAssertEqual(stringArray[index]!, "test" + String(index))
             }
         }
-        
+
         XCTAssertEqual(stringArray[1]!, "test1")
         XCTAssertEqual(stringArray[0]!, "test0")
     }
-    
+
     func testBoolArray() throws {
         let boolBuilder = try ArrowArrayBuilders.loadBoolArrayBuilder()
         boolBuilder.append(true)
@@ -91,11 +92,10 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(boolArray[1], nil)
         XCTAssertEqual(boolArray[0]!, true)
         XCTAssertEqual(boolArray[2]!, false)
-        
     }
-    
+
     func testDate32Array() throws {
-        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder();
+        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder()
         let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
         let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
         date32Builder.append(date1)
@@ -110,9 +110,9 @@ final class ArrayTests: XCTestCase {
         let adjustedDate1 = Date(timeIntervalSince1970: date1.timeIntervalSince1970 - 352)
         XCTAssertEqual(date32Array[0]!, adjustedDate1)
     }
-    
+
     func testDate64Array() throws {
-        let date64Builder: Date64ArrayBuilder = try ArrowArrayBuilders.loadDate64ArrayBuilder();
+        let date64Builder: Date64ArrayBuilder = try ArrowArrayBuilders.loadDate64ArrayBuilder()
         let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
         let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
         date64Builder.append(date1)
@@ -126,34 +126,34 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(date64Array[1], date2)
         XCTAssertEqual(date64Array[0]!, date1)
     }
-    
+
     func testBinaryArray() throws {
-        let binaryBuilder = try ArrowArrayBuilders.loadBinaryArrayBuilder();
-        for i in 0..<100 {
-            if i % 10 == 9 {
+        let binaryBuilder = try ArrowArrayBuilders.loadBinaryArrayBuilder()
+        for index in 0..<100 {
+            if index % 10 == 9 {
                 binaryBuilder.append(nil)
             } else {
-                binaryBuilder.append(("test" + String(i)).data(using:.utf8))
+                binaryBuilder.append(("test" + String(index)).data(using: .utf8))
             }
         }
-        
+
         XCTAssertEqual(binaryBuilder.nullCount, 10)
         XCTAssertEqual(binaryBuilder.length, 100)
         XCTAssertEqual(binaryBuilder.capacity, 648)
         let binaryArray = try binaryBuilder.finish()
         XCTAssertEqual(binaryArray.length, 100)
-        for i in 0..<binaryArray.length {
-            if i % 10 == 9 {
-                XCTAssertEqual(try binaryArray.isNull(i), true)
+        for index in 0..<binaryArray.length {
+            if index % 10 == 9 {
+                XCTAssertEqual(try binaryArray.isNull(index), true)
             } else {
-                let stringData = String(bytes: binaryArray[i]!, encoding: .utf8)
-                XCTAssertEqual(stringData, "test" + String(i))
+                let stringData = String(bytes: binaryArray[index]!, encoding: .utf8)
+                XCTAssertEqual(stringData, "test" + String(index))
             }
         }
     }
-    
+
     func testTime32Array() throws {
-        let milliBuilder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.Milliseconds);
+        let milliBuilder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.milliseconds)
         milliBuilder.append(100)
         milliBuilder.append(1000000)
         milliBuilder.append(nil)
@@ -161,13 +161,13 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(milliBuilder.length, 3)
         XCTAssertEqual(milliBuilder.capacity, 136)
         let milliArray = try milliBuilder.finish()
-        let milliType = milliArray.arrowData.type as! ArrowTypeTime32
-        XCTAssertEqual(milliType.unit, .Milliseconds)
+        let milliType = milliArray.arrowData.type as! ArrowTypeTime32 // swiftlint:disable:this force_cast
+        XCTAssertEqual(milliType.unit, .milliseconds)
         XCTAssertEqual(milliArray.length, 3)
         XCTAssertEqual(milliArray[1], 1000000)
         XCTAssertEqual(milliArray[2], nil)
 
-        let secBuilder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.Seconds);
+        let secBuilder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.seconds)
         secBuilder.append(200)
         secBuilder.append(nil)
         secBuilder.append(2000011)
@@ -175,15 +175,15 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(secBuilder.length, 3)
         XCTAssertEqual(secBuilder.capacity, 136)
         let secArray = try secBuilder.finish()
-        let secType = secArray.arrowData.type as! ArrowTypeTime32
-        XCTAssertEqual(secType.unit, .Seconds)
+        let secType = secArray.arrowData.type as! ArrowTypeTime32 // swiftlint:disable:this force_cast
+        XCTAssertEqual(secType.unit, .seconds)
         XCTAssertEqual(secArray.length, 3)
         XCTAssertEqual(secArray[1], nil)
         XCTAssertEqual(secArray[2], 2000011)
     }
-    
+
     func testTime64Array() throws {
-        let nanoBuilder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.Nanoseconds);
+        let nanoBuilder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.nanoseconds)
         nanoBuilder.append(10000)
         nanoBuilder.append(nil)
         nanoBuilder.append(123456789)
@@ -191,13 +191,13 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(nanoBuilder.length, 3)
         XCTAssertEqual(nanoBuilder.capacity, 264)
         let nanoArray = try nanoBuilder.finish()
-        let nanoType = nanoArray.arrowData.type as! ArrowTypeTime64
-        XCTAssertEqual(nanoType.unit, .Nanoseconds)
+        let nanoType = nanoArray.arrowData.type as! ArrowTypeTime64 // swiftlint:disable:this force_cast
+        XCTAssertEqual(nanoType.unit, .nanoseconds)
         XCTAssertEqual(nanoArray.length, 3)
         XCTAssertEqual(nanoArray[1], nil)
         XCTAssertEqual(nanoArray[2], 123456789)
 
-        let microBuilder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.Microseconds);
+        let microBuilder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.microseconds)
         microBuilder.append(nil)
         microBuilder.append(20000)
         microBuilder.append(987654321)
@@ -205,8 +205,8 @@ final class ArrayTests: XCTestCase {
         XCTAssertEqual(microBuilder.length, 3)
         XCTAssertEqual(microBuilder.capacity, 264)
         let microArray = try microBuilder.finish()
-        let microType = microArray.arrowData.type as! ArrowTypeTime64
-        XCTAssertEqual(microType.unit, .Microseconds)
+        let microType = microArray.arrowData.type as! ArrowTypeTime64 // swiftlint:disable:this force_cast
+        XCTAssertEqual(microType.unit, .microseconds)
         XCTAssertEqual(microArray.length, 3)
         XCTAssertEqual(microArray[1], 20000)
         XCTAssertEqual(microArray[2], 987654321)
diff --git a/swift/Arrow/Tests/ArrowTests/IPCTests.swift b/swift/Arrow/Tests/ArrowTests/IPCTests.swift
index 5a7721360d549..4ea252b78d8f6 100644
--- a/swift/Arrow/Tests/ArrowTests/IPCTests.swift
+++ b/swift/Arrow/Tests/ArrowTests/IPCTests.swift
@@ -28,7 +28,7 @@ func checkBoolRecordBatch(_ result: Result<ArrowReader.ArrowReaderResult, ArrowE
     case .failure(let error):
         throw error
     }
-    
+
     XCTAssertEqual(recordBatches.count, 1)
     for recordBatch in recordBatches {
         XCTAssertEqual(recordBatch.length, 5)
@@ -40,7 +40,7 @@ func checkBoolRecordBatch(_ result: Result<ArrowReader.ArrowReaderResult, ArrowE
         XCTAssertEqual(recordBatch.schema.fields[1].type.info, ArrowType.ArrowString)
         for index in 0..<recordBatch.length {
             let column = recordBatch.columns[0]
-            let str = column.array as! AsString
+            let str = column.array as! AsString // swiftlint:disable:this force_cast
             let val = "\(str.asString(index))"
             if index == 0 || index == 4 {
                 XCTAssertEqual(val, "true")
@@ -51,7 +51,7 @@ func checkBoolRecordBatch(_ result: Result<ArrowReader.ArrowReaderResult, ArrowE
             }
         }
     }
-    
+
     return recordBatches
 }
 
@@ -59,6 +59,48 @@ func currentDirectory(path: String = #file) -> URL {
     return URL(fileURLWithPath: path).deletingLastPathComponent()
 }
 
+func makeSchema() -> ArrowSchema {
+    let schemaBuilder = ArrowSchema.Builder()
+    return schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowUInt8), isNullable: true)
+        .addField("col2", type: ArrowType(ArrowType.ArrowString), isNullable: false)
+        .addField("col3", type: ArrowType(ArrowType.ArrowDate32), isNullable: false)
+        .finish()
+}
+
+func makeRecordBatch() throws -> RecordBatch {
+    let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
+    uint8Builder.append(10)
+    uint8Builder.append(22)
+    uint8Builder.append(33)
+    uint8Builder.append(44)
+    let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
+    stringBuilder.append("test10")
+    stringBuilder.append("test22")
+    stringBuilder.append("test33")
+    stringBuilder.append("test44")
+    let date32Builder = try ArrowArrayBuilders.loadDate32ArrayBuilder()
+    let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
+    let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
+    date32Builder.append(date1)
+    date32Builder.append(date2)
+    date32Builder.append(date1)
+    date32Builder.append(date2)
+    let intHolder = ArrowArrayHolder(try uint8Builder.finish())
+    let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
+    let date32Holder = ArrowArrayHolder(try date32Builder.finish())
+    let result = RecordBatch.Builder()
+        .addColumn("col1", arrowArray: intHolder)
+        .addColumn("col2", arrowArray: stringHolder)
+        .addColumn("col3", arrowArray: date32Holder)
+        .finish()
+    switch result {
+    case .success(let recordBatch):
+        return recordBatch
+    case .failure(let error):
+        throw error
+    }
+}
+
 final class IPCFileReaderTests: XCTestCase {
     func testFileReader_double() throws {
         let fileURL = currentDirectory().appendingPathComponent("../../testdata_double.arrow")
@@ -71,6 +113,7 @@ final class IPCFileReaderTests: XCTestCase {
         case .failure(let error):
             throw error
         }
+
         XCTAssertEqual(recordBatches.count, 1)
         for recordBatch in recordBatches {
             XCTAssertEqual(recordBatch.length, 5)
@@ -82,7 +125,7 @@ final class IPCFileReaderTests: XCTestCase {
             XCTAssertEqual(recordBatch.schema.fields[1].type.info, ArrowType.ArrowString)
             for index in 0..<recordBatch.length {
                 let column = recordBatch.columns[1]
-                let str = column.array as! AsString
+                let str = column.array as! AsString // swiftlint:disable:this force_cast
                 let val = "\(str.asString(index))"
                 if index != 1 {
                     XCTAssertNotEqual(val, "")
@@ -92,7 +135,7 @@ final class IPCFileReaderTests: XCTestCase {
             }
         }
     }
-    
+
     func testFileReader_bool() throws {
         let fileURL = currentDirectory().appendingPathComponent("../../testdata_bool.arrow")
         let arrowReader = ArrowReader()
@@ -100,72 +143,32 @@ final class IPCFileReaderTests: XCTestCase {
     }
 
     func testFileWriter_bool() throws {
-        //read existing file
+        // read existing file
         let fileURL = currentDirectory().appendingPathComponent("../../testdata_bool.arrow")
         let arrowReader = ArrowReader()
         let fileRBs = try checkBoolRecordBatch(arrowReader.fromFile(fileURL))
         let arrowWriter = ArrowWriter()
-        //write data from file to a stream
+        // write data from file to a stream
         let writerInfo = ArrowWriter.Info(.recordbatch, schema: fileRBs[0].schema, batches: fileRBs)
         switch arrowWriter.toStream(writerInfo) {
         case .success(let writeData):
-            //read stream back into recordbatches
+            // read stream back into recordbatches
             try checkBoolRecordBatch(arrowReader.fromStream(writeData))
         case .failure(let error):
             throw error
         }
-        //write file record batches to another file
+        // write file record batches to another file
         let outputUrl = currentDirectory().appendingPathComponent("../../testfilewriter_bool.arrow")
         switch arrowWriter.toFile(outputUrl, info: writerInfo) {
-        case .success(_):
+        case .success:
             try checkBoolRecordBatch(arrowReader.fromFile(outputUrl))
         case .failure(let error):
             throw error
         }
     }
-    func makeSchema() -> ArrowSchema {
-        let schemaBuilder = ArrowSchema.Builder();
-        return schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowUInt8), isNullable: true)
-            .addField("col2", type: ArrowType(ArrowType.ArrowString), isNullable: false)
-            .addField("col3", type: ArrowType(ArrowType.ArrowDate32), isNullable: false)
-            .finish()
-    }
-    func makeRecordBatch() throws -> RecordBatch {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
-        uint8Builder.append(10)
-        uint8Builder.append(22)
-        uint8Builder.append(33)
-        uint8Builder.append(44)
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
-        stringBuilder.append("test10")
-        stringBuilder.append("test22")
-        stringBuilder.append("test33")
-        stringBuilder.append("test44")
-        let date32Builder = try ArrowArrayBuilders.loadDate32ArrayBuilder();
-        let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
-        let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
-        date32Builder.append(date1)
-        date32Builder.append(date2)
-        date32Builder.append(date1)
-        date32Builder.append(date2)
-        let intHolder = ArrowArrayHolder(try uint8Builder.finish())
-        let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
-        let date32Holder = ArrowArrayHolder(try date32Builder.finish())
-        let result = RecordBatch.Builder()
-            .addColumn("col1", arrowArray: intHolder)
-            .addColumn("col2", arrowArray: stringHolder)
-            .addColumn("col3", arrowArray: date32Holder)
-            .finish()
-        switch result {
-        case .success(let recordBatch):
-            return recordBatch
-        case .failure(let error):
-            throw error
-        }
-    }
-    
+
     func testRBInMemoryToFromStream() throws {
-        //read existing file
+        // read existing file
         let schema = makeSchema()
         let recordBatch = try makeRecordBatch()
         let arrowWriter = ArrowWriter()
@@ -187,15 +190,21 @@ final class IPCFileReaderTests: XCTestCase {
                     XCTAssertEqual(recordBatch.schema.fields[1].type.info, ArrowType.ArrowString)
                     XCTAssertEqual(recordBatch.schema.fields[2].name, "col3")
                     XCTAssertEqual(recordBatch.schema.fields[2].type.info, ArrowType.ArrowDate32)
-                    let dateVal = "\((recordBatch.columns[2].array as! AsString).asString(0))"
+                    let columns = recordBatch.columns
+                    let dateVal =
+                        "\((columns[2].array as! AsString).asString(0))" // swiftlint:disable:this force_cast
                     XCTAssertEqual(dateVal, "2014-09-10 00:00:00 +0000")
-                    let stringVal = "\((recordBatch.columns[1].array as! AsString).asString(1))"
+                    let stringVal =
+                        "\((columns[1].array as! AsString).asString(1))" // swiftlint:disable:this force_cast
                     XCTAssertEqual(stringVal, "test22")
-                    let uintVal = "\((recordBatch.columns[0].array as! AsString).asString(0))"
+                    let uintVal =
+                        "\((columns[0].array as! AsString).asString(0))" // swiftlint:disable:this force_cast
                     XCTAssertEqual(uintVal, "10")
-                    let stringVal2 = "\((recordBatch.columns[1].array as! AsString).asString(3))"
+                    let stringVal2 =
+                        "\((columns[1].array as! AsString).asString(3))" // swiftlint:disable:this force_cast
                     XCTAssertEqual(stringVal2, "test44")
-                    let uintVal2 = "\((recordBatch.columns[0].array as! AsString).asString(3))"
+                    let uintVal2 =
+                        "\((columns[0].array as! AsString).asString(3))" // swiftlint:disable:this force_cast
                     XCTAssertEqual(uintVal2, "44")
                 }
             case.failure(let error):
@@ -205,9 +214,9 @@ final class IPCFileReaderTests: XCTestCase {
             throw error
         }
     }
-    
+
     func testSchemaInMemoryToFromStream() throws {
-        //read existing file
+        // read existing file
         let schema = makeSchema()
         let arrowWriter = ArrowWriter()
         let writerInfo = ArrowWriter.Info(.schema, schema: schema)
@@ -232,18 +241,18 @@ final class IPCFileReaderTests: XCTestCase {
             throw error
         }
     }
-    
+
     func makeBinaryDataset() throws -> (ArrowSchema, RecordBatch) {
-        let schemaBuilder = ArrowSchema.Builder();
+        let schemaBuilder = ArrowSchema.Builder()
         let schema = schemaBuilder.addField("binary", type: ArrowType(ArrowType.ArrowBinary), isNullable: false)
             .finish()
-        
-        let binaryBuilder = try ArrowArrayBuilders.loadBinaryArrayBuilder();
+
+        let binaryBuilder = try ArrowArrayBuilders.loadBinaryArrayBuilder()
         binaryBuilder.append("test10".data(using: .utf8))
         binaryBuilder.append("test22".data(using: .utf8))
         binaryBuilder.append("test33".data(using: .utf8))
         binaryBuilder.append("test44".data(using: .utf8))
-        
+
         let binaryHolder = ArrowArrayHolder(try binaryBuilder.finish())
         let result = RecordBatch.Builder()
             .addColumn("binary", arrowArray: binaryHolder)
@@ -255,24 +264,23 @@ final class IPCFileReaderTests: XCTestCase {
             throw error
         }
     }
-    
+
     func makeTimeDataset() throws -> (ArrowSchema, RecordBatch) {
-        let schemaBuilder = ArrowSchema.Builder();
-        let schema = schemaBuilder.addField("time64", type: ArrowTypeTime64(.Microseconds), isNullable: false)
-            .addField("time32", type: ArrowTypeTime32(.Milliseconds), isNullable: false)
+        let schemaBuilder = ArrowSchema.Builder()
+        let schema = schemaBuilder.addField("time64", type: ArrowTypeTime64(.microseconds), isNullable: false)
+            .addField("time32", type: ArrowTypeTime32(.milliseconds), isNullable: false)
             .finish()
-        
-        let time64Builder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.Nanoseconds);
+
+        let time64Builder = try ArrowArrayBuilders.loadTime64ArrayBuilder(.nanoseconds)
         time64Builder.append(12345678)
         time64Builder.append(1)
         time64Builder.append(nil)
         time64Builder.append(98765432)
-        let time32Builder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.Milliseconds);
+        let time32Builder = try ArrowArrayBuilders.loadTime32ArrayBuilder(.milliseconds)
         time32Builder.append(1)
         time32Builder.append(2)
         time32Builder.append(nil)
         time32Builder.append(3)
-        
         let time64Holder = ArrowArrayHolder(try time64Builder.finish())
         let time32Holder = ArrowArrayHolder(try time32Builder.finish())
         let result = RecordBatch.Builder()
@@ -286,9 +294,9 @@ final class IPCFileReaderTests: XCTestCase {
             throw error
         }
     }
-    
+
     func testBinaryInMemroyToFromStream() throws {
-        let dataset = try makeBinaryDataset();
+        let dataset = try makeBinaryDataset()
         let writerInfo = ArrowWriter.Info(.recordbatch, schema: dataset.0, batches: [dataset.1])
         let arrowWriter = ArrowWriter()
         switch arrowWriter.toStream(writerInfo) {
@@ -304,7 +312,9 @@ final class IPCFileReaderTests: XCTestCase {
                 XCTAssertEqual(result.batches.count, 1)
                 let recordBatch = result.batches[0]
                 XCTAssertEqual(recordBatch.length, 4)
-                let stringVal = "\((recordBatch.columns[0].array as! AsString).asString(1))"
+                let columns = recordBatch.columns
+                let stringVal =
+                    "\((columns[0].array as! AsString).asString(1))" // swiftlint:disable:this force_cast
                 XCTAssertEqual(stringVal, "test22")
             case.failure(let error):
                 throw error
@@ -313,9 +323,9 @@ final class IPCFileReaderTests: XCTestCase {
             throw error
         }
     }
-    
+
     func testTimeInMemroyToFromStream() throws {
-        let dataset = try makeTimeDataset();
+        let dataset = try makeTimeDataset()
         let writerInfo = ArrowWriter.Info(.recordbatch, schema: dataset.0, batches: [dataset.1])
         let arrowWriter = ArrowWriter()
         switch arrowWriter.toStream(writerInfo) {
@@ -333,9 +343,12 @@ final class IPCFileReaderTests: XCTestCase {
                 XCTAssertEqual(result.batches.count, 1)
                 let recordBatch = result.batches[0]
                 XCTAssertEqual(recordBatch.length, 4)
-                let stringVal = "\((recordBatch.columns[0].array as! AsString).asString(0))"
+                let columns = recordBatch.columns
+                let stringVal =
+                    "\((columns[0].array as! AsString).asString(0))" // swiftlint:disable:this force_cast
                 XCTAssertEqual(stringVal, "12345678")
-                let stringVal2 = "\((recordBatch.columns[1].array as! AsString).asString(3))"
+                let stringVal2 =
+                    "\((columns[1].array as! AsString).asString(3))" // swiftlint:disable:this force_cast
                 XCTAssertEqual(stringVal2, "3")
             case.failure(let error):
                 throw error
diff --git a/swift/Arrow/Tests/ArrowTests/RecordBatchTests.swift b/swift/Arrow/Tests/ArrowTests/RecordBatchTests.swift
index 9a469bfbd861b..ab6cad1b5e409 100644
--- a/swift/Arrow/Tests/ArrowTests/RecordBatchTests.swift
+++ b/swift/Arrow/Tests/ArrowTests/RecordBatchTests.swift
@@ -20,13 +20,13 @@ import XCTest
 
 final class RecordBatchTests: XCTestCase {
     func testRecordBatch() throws {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder.append(10)
         uint8Builder.append(22)
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
+        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test10")
         stringBuilder.append("test22")
-        
+
         let intHolder = ArrowArrayHolder(try uint8Builder.finish())
         let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
         let result = RecordBatch.Builder()
@@ -44,8 +44,8 @@ final class RecordBatchTests: XCTestCase {
             XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
             XCTAssertEqual(schema.fields[1].isNullable, false)
             XCTAssertEqual(recordBatch.columns.count, 2)
-            let col1: ArrowArray<UInt8> = recordBatch.data(for: 0);
-            let col2: ArrowArray<String> = recordBatch.data(for: 1);
+            let col1: ArrowArray<UInt8> = recordBatch.data(for: 0)
+            let col2: ArrowArray<String> = recordBatch.data(for: 1)
             XCTAssertEqual(col1.length, 2)
             XCTAssertEqual(col2.length, 2)
         case .failure(let error):
diff --git a/swift/Arrow/Tests/ArrowTests/TableTests.swift b/swift/Arrow/Tests/ArrowTests/TableTests.swift
index 73ca3d3726d94..1c6b2d9c0a05c 100644
--- a/swift/Arrow/Tests/ArrowTests/TableTests.swift
+++ b/swift/Arrow/Tests/ArrowTests/TableTests.swift
@@ -20,7 +20,7 @@ import XCTest
 
 final class TableTests: XCTestCase {
     func testSchema() throws {
-        let schemaBuilder = ArrowSchema.Builder();
+        let schemaBuilder = ArrowSchema.Builder()
         let schema = schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowInt8), isNullable: true)
             .addField("col2", type: ArrowType(ArrowType.ArrowBool), isNullable: false)
             .finish()
@@ -32,26 +32,24 @@ final class TableTests: XCTestCase {
         XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowBool)
         XCTAssertEqual(schema.fields[1].isNullable, false)
     }
-    
+
     func testTable() throws {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder.append(10)
         uint8Builder.append(22)
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
+        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test10")
         stringBuilder.append("test22")
-        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder();
+        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder()
         let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
         let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
         date32Builder.append(date1)
         date32Builder.append(date2)
-
         let table = try ArrowTable.Builder()
             .addColumn("col1", arrowArray: uint8Builder.finish())
             .addColumn("col2", arrowArray: stringBuilder.finish())
             .addColumn("col3", arrowArray: date32Builder.finish())
-            .finish();
-        
+            .finish()
         let schema = table.schema
         XCTAssertEqual(schema.fields.count, 3)
         XCTAssertEqual(schema.fields[0].name, "col1")
@@ -64,37 +62,35 @@ final class TableTests: XCTestCase {
         XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
         XCTAssertEqual(schema.fields[1].isNullable, false)
         XCTAssertEqual(table.columns.count, 3)
-        let col1: ChunkedArray<UInt8> = table.columns[0].data();
-        let col2: ChunkedArray<String> = table.columns[1].data();
-        let col3: ChunkedArray<Date> = table.columns[2].data();
+        let col1: ChunkedArray<UInt8> = table.columns[0].data()
+        let col2: ChunkedArray<String> = table.columns[1].data()
+        let col3: ChunkedArray<Date> = table.columns[2].data()
         XCTAssertEqual(col1.length, 2)
         XCTAssertEqual(col2.length, 2)
         XCTAssertEqual(col3.length, 2)
     }
 
     func testTableWithChunkedData() throws {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder.append(10)
         uint8Builder.append(22)
-        let uint8Builder2: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder2: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder2.append(33)
-        let uint8Builder3: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder3: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder3.append(44)
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
+        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test10")
         stringBuilder.append("test22")
-        let stringBuilder2 = try ArrowArrayBuilders.loadStringArrayBuilder();
+        let stringBuilder2 = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test33")
         stringBuilder.append("test44")
-        
-        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder();
+        let date32Builder: Date32ArrayBuilder = try ArrowArrayBuilders.loadDate32ArrayBuilder()
         let date2 = Date(timeIntervalSinceReferenceDate: 86400 * 1)
         let date1 = Date(timeIntervalSinceReferenceDate: 86400 * 5000 + 352)
         date32Builder.append(date1)
         date32Builder.append(date2)
         date32Builder.append(date1)
         date32Builder.append(date2)
-
         let intArray = try ChunkedArray([uint8Builder.finish(), uint8Builder2.finish(), uint8Builder3.finish()])
         let stringArray = try ChunkedArray([stringBuilder.finish(), stringBuilder2.finish()])
         let dateArray = try ChunkedArray([date32Builder.finish()])
@@ -102,8 +98,7 @@ final class TableTests: XCTestCase {
             .addColumn("col1", chunked: intArray)
             .addColumn("col2", chunked: stringArray)
             .addColumn("col3", chunked: dateArray)
-            .finish();
-        
+            .finish()
         let schema = table.schema
         XCTAssertEqual(schema.fields.count, 3)
         XCTAssertEqual(schema.fields[0].name, "col1")
@@ -116,9 +111,9 @@ final class TableTests: XCTestCase {
         XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
         XCTAssertEqual(schema.fields[1].isNullable, false)
         XCTAssertEqual(table.columns.count, 3)
-        let col1: ChunkedArray<UInt8> = table.columns[0].data();
-        let col2: ChunkedArray<String> = table.columns[1].data();
-        let col3: ChunkedArray<Date> = table.columns[2].data();
+        let col1: ChunkedArray<UInt8> = table.columns[0].data()
+        let col2: ChunkedArray<String> = table.columns[1].data()
+        let col3: ChunkedArray<Date> = table.columns[2].data()
         XCTAssertEqual(col1.length, 4)
         XCTAssertEqual(col2.length, 4)
         XCTAssertEqual(col3.length, 4)
@@ -129,13 +124,12 @@ final class TableTests: XCTestCase {
     }
 
     func testTableToRecordBatch() throws {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder();
+        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
         uint8Builder.append(10)
         uint8Builder.append(22)
-        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder();
+        let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test10")
         stringBuilder.append("test22")
-        
         let intHolder = ArrowArrayHolder(try uint8Builder.finish())
         let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
         let result = RecordBatch.Builder()
@@ -155,8 +149,8 @@ final class TableTests: XCTestCase {
             XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
             XCTAssertEqual(schema.fields[1].isNullable, false)
             XCTAssertEqual(table.columns.count, 2)
-            let col1: ChunkedArray<UInt8> = table.columns[0].data();
-            let col2: ChunkedArray<String> = table.columns[1].data();
+            let col1: ChunkedArray<UInt8> = table.columns[0].data()
+            let col2: ChunkedArray<String> = table.columns[1].data()
             XCTAssertEqual(col1.length, 2)
             XCTAssertEqual(col2.length, 2)
         case .failure(let error):
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
index 04e917d474cff..8db12aaa99ffc 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightAction.swift
@@ -24,16 +24,16 @@ public class FlightAction {
         self.type = action.type
         self.body = action.body
     }
-    
+
     public init(_ type: String, body: Data = Data()) {
-        self.type = type;
-        self.body = body;
+        self.type = type
+        self.body = body
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_Action {
-        var flight_action = Arrow_Flight_Protocol_Action()
-        flight_action.type = self.type
-        flight_action.body = self.body
-        return flight_action
+        var flightAction = Arrow_Flight_Protocol_Action()
+        flightAction.type = self.type
+        flightAction.body = self.body
+        return flightAction
     }
 }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
index b3b06793feade..0b4778c6864d3 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightActionType.swift
@@ -22,13 +22,13 @@ public class FlightActionType {
     init(_ actionType: Arrow_Flight_Protocol_ActionType) {
         self.type = actionType.type
         self.description = actionType.description_p
-        
+
     }
     public init(_ type: String, description: String) {
         self.type = type
         self.description = description
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_ActionType {
         var actionType = Arrow_Flight_Protocol_ActionType()
         actionType.type  = self.type
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
index f7b8564af31d7..c9d30f9caf480 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
@@ -27,35 +27,36 @@ public class FlightClient {
     public init(channel: GRPCChannel) {
         client = Arrow_Flight_Protocol_FlightServiceAsyncClient(channel: channel)
     }
-    
+
     public func listActions(_ closure: (FlightActionType) -> Void) async throws {
         let listActions = client.makeListActionsCall(Arrow_Flight_Protocol_Empty())
         for try await data in listActions.responseStream {
             closure(FlightActionType(data))
         }
     }
-    
-    public func listFlights(_ criteria :FlightCriteria, closure: (FlightInfo) throws -> Void) async throws {
+
+    public func listFlights(_ criteria: FlightCriteria, closure: (FlightInfo) throws -> Void) async throws {
         let listFlights = client.makeListFlightsCall(criteria.toProtocol())
         for try await data in listFlights.responseStream {
-            try closure(FlightInfo(data));
+            try closure(FlightInfo(data))
         }
     }
-    
-    
+
     public func doAction(_ action: FlightAction, closure: (FlightResult) throws -> Void) async throws {
         let actionResponse = client.makeDoActionCall(action.toProtocol())
         for try await data in actionResponse.responseStream {
-            try closure(FlightResult(data));
+            try closure(FlightResult(data))
         }
     }
-    
+
     public func getSchema(_ descriptor: FlightDescriptor) async throws -> FlightSchemaResult {
         let schemaResultResponse = client.makeGetSchemaCall(descriptor.toProtocol())
         return FlightSchemaResult(try await schemaResultResponse.response)
     }
-    
-    public func doGet(_ ticket: FlightTicket, readerResultClosure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
+
+    public func doGet(
+        _ ticket: FlightTicket,
+        readerResultClosure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
         let getResult = client.makeDoGetCall(ticket.toProtocol())
         let reader = ArrowReader()
         for try await data in getResult.responseStream {
@@ -77,9 +78,9 @@ public class FlightClient {
 
     public func doPut(_ recordBatchs: [RecordBatch], closure: (FlightPutResult) throws -> Void) async throws {
         if recordBatchs.isEmpty {
-            throw ArrowFlightError.EmptyCollection
+            throw ArrowFlightError.emptyCollection
         }
-        
+
         let putCall = client.makeDoPutCall()
         let writer = ArrowWriter()
         let writerInfo = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
@@ -104,11 +105,13 @@ public class FlightClient {
         }
     }
 
-    public func doExchange(_ recordBatchs: [RecordBatch], closure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
+    public func doExchange(
+        _ recordBatchs: [RecordBatch],
+        closure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
         if recordBatchs.isEmpty {
-            throw ArrowFlightError.EmptyCollection
+            throw ArrowFlightError.emptyCollection
         }
-        
+
         let exchangeCall = client.makeDoExchangeCall()
         let writer = ArrowWriter()
         let info = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
index a887a22ad1737..2d02959998c1e 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightCriteria.swift
@@ -19,18 +19,18 @@ import Foundation
 
 public class FlightCriteria {
     let criteria: Arrow_Flight_Protocol_Criteria
-    
+
     public var expression: Data { criteria.expression }
     public init(_ expression: Data = Data()) {
         criteria = Arrow_Flight_Protocol_Criteria.with {
             $0.expression = expression
         }
     }
-    
+
     init(_ criteria: Arrow_Flight_Protocol_Criteria) {
         self.criteria = criteria
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_Criteria {
         return criteria
     }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
index 004fb785f0c11..fa853baab3b92 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
@@ -18,29 +18,29 @@
 import Foundation
 
 public class FlightData {
-    let flight_data: Arrow_Flight_Protocol_FlightData
+    let flightData: Arrow_Flight_Protocol_FlightData
     public var flightDescriptor: FlightDescriptor? {
-        get { return flight_data.hasFlightDescriptor ? FlightDescriptor(flight_data.flightDescriptor) : nil }
+        return flightData.hasFlightDescriptor ? FlightDescriptor(flightData.flightDescriptor) : nil
     }
-    
-    public var dataBody: Data { flight_data.dataBody }
-    
-    init(_ flight_data: Arrow_Flight_Protocol_FlightData) {
-        self.flight_data = flight_data
+
+    public var dataBody: Data { flightData.dataBody }
+
+    init(_ flightData: Arrow_Flight_Protocol_FlightData) {
+        self.flightData = flightData
     }
-    
+
     public init(_ dataBody: Data, flightDescriptor: FlightDescriptor? = nil) {
         if flightDescriptor != nil {
-            self.flight_data = Arrow_Flight_Protocol_FlightData.with {
+            self.flightData = Arrow_Flight_Protocol_FlightData.with {
                 $0.dataBody = dataBody
                 $0.flightDescriptor = flightDescriptor!.toProtocol()
             }
         } else {
-            self.flight_data = Arrow_Flight_Protocol_FlightData.with {
+            self.flightData = Arrow_Flight_Protocol_FlightData.with {
                 $0.dataBody = dataBody
             }
         }
     }
-    
-    func toProtocol() -> Arrow_Flight_Protocol_FlightData { self.flight_data }
+
+    func toProtocol() -> Arrow_Flight_Protocol_FlightData { self.flightData }
 }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
index 68bc91a3deda1..02712aaa099c7 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightDescriptor.swift
@@ -18,22 +18,22 @@
 import Foundation
 
 public class FlightDescriptor {
-    public enum type {
+    public enum DescriptorType {
         case unknown
         case path
         case cmd
     }
-    
-    public let type: FlightDescriptor.type
+
+    public let type: FlightDescriptor.DescriptorType
     public let cmd: Data
     public let paths: [String]
-    
+
     init(_ descriptor: Arrow_Flight_Protocol_FlightDescriptor) {
         self.type = descriptor.type == .cmd ? .cmd : .path
         self.cmd = descriptor.cmd
         self.paths = descriptor.path
     }
-    
+
     public init(cmd: Data) {
         self.type = .cmd
         self.cmd = cmd
@@ -45,7 +45,7 @@ public class FlightDescriptor {
         self.cmd = Data()
         self.paths = paths
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_FlightDescriptor {
         var descriptor = Arrow_Flight_Protocol_FlightDescriptor()
         descriptor.type = self.type == .cmd ? .cmd : .path
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
index 7c40a2a157ae8..0493772781a13 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightEndpoint.swift
@@ -17,18 +17,18 @@
 
 import Foundation
 public class FlightEndpoint {
-    let ticket: FlightTicket;
+    let ticket: FlightTicket
     let locations: [FlightLocation]
     init(_ endpoint: Arrow_Flight_Protocol_FlightEndpoint) {
         self.ticket = FlightTicket(endpoint.ticket.ticket)
         self.locations = endpoint.location.map {return FlightLocation($0)}
     }
-    
+
     public init(_ ticket: FlightTicket, locations: [FlightLocation]) {
         self.ticket = ticket
-        self.locations = locations;
+        self.locations = locations
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_FlightEndpoint {
         var endpoint = Arrow_Flight_Protocol_FlightEndpoint()
         endpoint.ticket = self.ticket.toProtocol()
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
index b370c00db3d42..e59c0bcc6d997 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
@@ -19,37 +19,37 @@ import Foundation
 import Arrow
 
 public class FlightInfo {
-    let flight_info: Arrow_Flight_Protocol_FlightInfo
+    let flightInfo: Arrow_Flight_Protocol_FlightInfo
     public var flightDescriptor: FlightDescriptor? {
-        get { return flight_info.hasFlightDescriptor ? FlightDescriptor(flight_info.flightDescriptor) : nil }
+        return flightInfo.hasFlightDescriptor ? FlightDescriptor(flightInfo.flightDescriptor) : nil
     }
-    
+
     public var endpoints: [FlightEndpoint] {
-        return self.flight_info.endpoint.map { FlightEndpoint($0) }
+        return self.flightInfo.endpoint.map { FlightEndpoint($0) }
     }
-    public var schema: Data { flight_info.schema }
-    
+    public var schema: Data { flightInfo.schema }
+
     var endpoint: [Arrow_Flight_Protocol_FlightEndpoint] = []
-    init(_ flight_info: Arrow_Flight_Protocol_FlightInfo) {
-        self.flight_info = flight_info
+    init(_ flightInfo: Arrow_Flight_Protocol_FlightInfo) {
+        self.flightInfo = flightInfo
     }
-    
+
     public init(_ schema: Data, endpoints: [FlightEndpoint] = [FlightEndpoint](), descriptor: FlightDescriptor? = nil) {
         if let localDescriptor = descriptor {
-            self.flight_info = Arrow_Flight_Protocol_FlightInfo.with {
+            self.flightInfo = Arrow_Flight_Protocol_FlightInfo.with {
                 $0.schema = schema
                 $0.flightDescriptor = localDescriptor.toProtocol()
                 $0.endpoint = endpoints.map { $0.toProtocol() }
             }
         } else {
-            self.flight_info = Arrow_Flight_Protocol_FlightInfo.with {
+            self.flightInfo = Arrow_Flight_Protocol_FlightInfo.with {
                 $0.schema = schema
                 $0.endpoint = endpoints.map { $0.toProtocol() }
             }
         }
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_FlightInfo {
-        return self.flight_info
+        return self.flightInfo
     }
 }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
index b87671c903d44..9c89d100336f1 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightLocation.swift
@@ -19,15 +19,15 @@ import Foundation
 
 public class FlightLocation {
     public let uri: String
-    
+
     init(_ location: Arrow_Flight_Protocol_Location) {
         self.uri = location.uri
     }
-    
+
     public init(_ uri: String) {
-        self.uri = uri;
+        self.uri = uri
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_Location {
         var location = Arrow_Flight_Protocol_Location()
         location.uri = uri
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
index bf73c716e39c0..3b22f8f0baf11 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightPutResult.swift
@@ -22,11 +22,11 @@ public class FlightPutResult {
     public init(_ appMetadata: Data = Data()) {
         self.appMetadata = appMetadata
     }
-    
+
     init(_ putResult: Arrow_Flight_Protocol_PutResult) {
         self.appMetadata = putResult.appMetadata
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_PutResult {
         var putResult = Arrow_Flight_Protocol_PutResult()
         putResult.appMetadata = self.appMetadata
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
index ba55bede7c70c..d7cf828b96367 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightResult.swift
@@ -22,11 +22,11 @@ public class FlightResult {
     init(_ result: Arrow_Flight_Protocol_Result) {
         self.body = result.body
     }
-    
+
     public init(_ body: Data) {
         self.body = body
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_Result {
         var result = Arrow_Flight_Protocol_Result()
         result.body = self.body
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
index 8d5323b731ea8..fcb4b50c1aa91 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
@@ -19,18 +19,18 @@ import Foundation
 
 public class FlightSchemaResult {
     let schemaResult: Arrow_Flight_Protocol_SchemaResult
-    
+
     public var schema: Data { schemaResult.schema }
     public init(_ schema: Data) {
         self.schemaResult = Arrow_Flight_Protocol_SchemaResult.with {
             $0.schema = schema
         }
     }
-    
+
     init(_ schemaResult: Arrow_Flight_Protocol_SchemaResult) {
         self.schemaResult = schemaResult
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_SchemaResult {
         return schemaResult
     }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
index f67f612b0bcb4..58280a0049f4b 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
@@ -23,10 +23,10 @@ import SwiftProtobuf
 import Arrow
 
 public enum ArrowFlightError: Error {
-    case Unknown(String?)
-    case NotImplemented(String? = nil)
-    case EmptyCollection
-    case IOError(String? = nil)
+    case unknown(String?)
+    case notImplemented(String? = nil)
+    case emptyCollection
+    case ioError(String? = nil)
 }
 
 public func schemaToArrowStream(_ schema: ArrowSchema) throws -> Data {
@@ -46,117 +46,133 @@ public func streamToArrowSchema(_ schema: Data) throws -> ArrowSchema {
         if let retSchema = result.schema {
             return retSchema
         }
-        
-        throw ArrowFlightError.IOError("Schema not found")
+
+        throw ArrowFlightError.ioError("Schema not found")
     case .failure(let error):
         throw error
     }
 }
 
-public protocol ArrowFlightServer : Sendable {
+public protocol ArrowFlightServer: Sendable {
     func listFlights(_ criteria: FlightCriteria, writer: FlightInfoStreamWriter) async throws
     func getFlightInfo(_ request: FlightDescriptor) async throws -> FlightInfo
     func getSchema(_ request: FlightDescriptor) async throws -> ArrowFlight.FlightSchemaResult
     func listActions(_ writer: ActionTypeStreamWriter) async throws
     func doAction(_ action: FlightAction, writer: ResultStreamWriter) async throws
-    func doGet(_ ticket: FlightTicket, writer: RecordBatchStreamWriter) async throws;
+    func doGet(_ ticket: FlightTicket, writer: RecordBatchStreamWriter) async throws
     func doPut(_ reader: RecordBatchStreamReader, writer: PutResultDataStreamWriter) async throws
     func doExchange(_ reader: RecordBatchStreamReader, writer: RecordBatchStreamWriter) async throws
 }
 
-public func MakeFlightServer(_ handler: ArrowFlightServer) -> CallHandlerProvider {
+public func makeFlightServer(_ handler: ArrowFlightServer) -> CallHandlerProvider {
   return InternalFlightServer(handler)
 }
 
-internal final class InternalFlightServer : Arrow_Flight_Protocol_FlightServiceAsyncProvider {
+internal final class InternalFlightServer: Arrow_Flight_Protocol_FlightServiceAsyncProvider {
     let arrowFlightServer: ArrowFlightServer?
-    
+
     init(_ arrowFlightServer: ArrowFlightServer?) {
         self.arrowFlightServer = arrowFlightServer
     }
-    
-    func handshake(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_HandshakeRequest>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_HandshakeResponse>, context: GRPC.GRPCAsyncServerCallContext) async throws {
-        throw ArrowFlightError.NotImplemented()
+
+    func handshake(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_HandshakeRequest>,
+                   responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_HandshakeResponse>,
+                   context: GRPC.GRPCAsyncServerCallContext) async throws {
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func listFlights(request: Arrow_Flight_Protocol_Criteria, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func listFlights(request: Arrow_Flight_Protocol_Criteria,
+                     responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>,
+                     context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             let writer = FlightInfoStreamWriter(responseStream)
             try await server.listFlights(FlightCriteria(request), writer: writer)
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func getFlightInfo(request: Arrow_Flight_Protocol_FlightDescriptor, context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_FlightInfo {
+
+    func getFlightInfo(request: Arrow_Flight_Protocol_FlightDescriptor,
+                       context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_FlightInfo {
         if let server = arrowFlightServer {
             return try await server.getFlightInfo(FlightDescriptor(request)).toProtocol()
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func getSchema(request: Arrow_Flight_Protocol_FlightDescriptor, context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_SchemaResult {
+
+    func getSchema(request: Arrow_Flight_Protocol_FlightDescriptor,
+                   context: GRPC.GRPCAsyncServerCallContext) async throws -> Arrow_Flight_Protocol_SchemaResult {
         if let server = arrowFlightServer {
             return try await server.getSchema(FlightDescriptor(request)).toProtocol()
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func doGet(request: Arrow_Flight_Protocol_Ticket, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func doGet(request: Arrow_Flight_Protocol_Ticket,
+               responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>,
+               context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             let writer = RecordBatchStreamWriter(responseStream)
             let ticket = FlightTicket(request)
             try await server.doGet(ticket, writer: writer)
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()        
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func doPut(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func doPut(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>,
+               responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>,
+               context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             let reader = RecordBatchStreamReader(requestStream)
             let writer = PutResultDataStreamWriter(responseStream)
             try await server.doPut(reader, writer: writer)
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func doExchange(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func doExchange(requestStream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>,
+                    responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>,
+                    context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             let reader = RecordBatchStreamReader(requestStream)
             let writer = RecordBatchStreamWriter(responseStream)
             try await server.doExchange(reader, writer: writer)
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func doAction(request: Arrow_Flight_Protocol_Action, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func doAction(request: Arrow_Flight_Protocol_Action,
+                  responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>,
+                  context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             try await server.doAction(FlightAction(request), writer: ResultStreamWriter(responseStream))
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-    func listActions(request: Arrow_Flight_Protocol_Empty, responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>, context: GRPC.GRPCAsyncServerCallContext) async throws {
+
+    func listActions(request: Arrow_Flight_Protocol_Empty,
+                     responseStream: GRPC.GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>,
+                     context: GRPC.GRPCAsyncServerCallContext) async throws {
         if let server = arrowFlightServer {
             let writer = ActionTypeStreamWriter(responseStream)
             try await server.listActions(writer)
             return
         }
-        
-        throw ArrowFlightError.NotImplemented()
+
+        throw ArrowFlightError.notImplemented()
     }
-    
-  internal var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? { get { return nil } }
+
+  internal var interceptors: Arrow_Flight_Protocol_FlightServiceServerInterceptorFactoryProtocol? { return nil }
 
 }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
index f77fc3545af5c..ab3cb321c6229 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightTicket.swift
@@ -22,11 +22,11 @@ public class FlightTicket {
     init(_ ticket: Arrow_Flight_Protocol_Ticket) {
         self.data = ticket.ticket
     }
-    
+
     public init(_ data: Data) {
         self.data = data
     }
-    
+
     func toProtocol() -> Arrow_Flight_Protocol_Ticket {
         var ticket = Arrow_Flight_Protocol_Ticket()
         ticket.ticket = self.data
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
index a6b9ce93a9acd..f0054a2577e3f 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
@@ -31,7 +31,7 @@ public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
         self.stream = stream
         self.streamIterator = self.stream.makeAsyncIterator()
     }
-    
+
     public func next() async throws -> Arrow.RecordBatch? {
         guard !Task.isCancelled else {
             return nil
@@ -42,21 +42,24 @@ public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
             batchIndex += 1
             return batch
         }
-         
+
         while true {
             let flightData = try await self.streamIterator.next()
             if flightData == nil {
                 return nil
             }
-            
-            let data = (flightData as! Arrow_Flight_Protocol_FlightData).dataBody
-            switch reader.fromStream(data) {
-            case .success(let rbResult):
-                batches = rbResult.batches
-                batchIndex = 1
-                return batches[0]
-            case .failure(let error):
-                throw error
+
+            if let data = (flightData as? Arrow_Flight_Protocol_FlightData)?.dataBody {
+                switch reader.fromStream(data) {
+                case .success(let rbResult):
+                    batches = rbResult.batches
+                    batchIndex = 1
+                    return batches[0]
+                case .failure(let error):
+                    throw error
+                }
+            } else {
+                throw ArrowError.invalid("Flight data is incorrect type.")
             }
         }
     }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
index 1efeba5310369..94fc0e91dff07 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
@@ -24,7 +24,7 @@ public class ActionTypeStreamWriter {
     init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_ActionType>) {
         self.stream = stream
     }
-    
+
     public func write(_ actionType: FlightActionType) async throws {
         try await self.stream.send(actionType.toProtocol())
     }
@@ -35,7 +35,7 @@ public class ResultStreamWriter {
     init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_Result>) {
         self.stream = stream
     }
-    
+
     public func write(_ result: FlightResult) async throws {
         try await self.stream.send(result.toProtocol())
     }
@@ -46,7 +46,7 @@ public class FlightInfoStreamWriter {
     init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightInfo>) {
         self.stream = stream
     }
-    
+
     public func write(_ result: FlightInfo) async throws {
         try await self.stream.send(result.toProtocol())
     }
@@ -57,7 +57,7 @@ public class PutResultDataStreamWriter {
     init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_PutResult>) {
         self.stream = stream
     }
-    
+
     public func write(_ result: FlightPutResult) async throws {
         try await self.stream.send(result.toProtocol())
     }
@@ -69,7 +69,7 @@ public class RecordBatchStreamWriter {
     init(_ stream: GRPCAsyncResponseStreamWriter<Arrow_Flight_Protocol_FlightData>) {
         self.stream = stream
     }
-    
+
     public func write(_ rb: RecordBatch) async throws {
         let info = ArrowWriter.Info(.recordbatch,
                                     schema: rb.schema,
@@ -82,7 +82,7 @@ public class RecordBatchStreamWriter {
             let data = Arrow_Flight_Protocol_FlightData.with {
                 $0.dataBody = rbResult
             }
-            
+
             try await self.stream.send(data)
         case .failure(let error):
             throw error
diff --git a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
index 3fd52af08b82f..31dbcc1829a6a 100644
--- a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
+++ b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
@@ -67,54 +67,58 @@ func makeRecordBatch() throws -> RecordBatch {
     }
 }
 
-final class MyFlightServer : ArrowFlightServer {
-    func doExchange(_ reader: ArrowFlight.RecordBatchStreamReader, writer: ArrowFlight.RecordBatchStreamWriter) async throws {
+final class MyFlightServer: ArrowFlightServer {
+    func doExchange(
+        _ reader: ArrowFlight.RecordBatchStreamReader,
+        writer: ArrowFlight.RecordBatchStreamWriter) async throws {
         do {
             for try await rb in reader {
                 XCTAssertEqual(rb.schema.fields.count, 3)
                 XCTAssertEqual(rb.length, 4)
             }
-            
+
             let rb = try makeRecordBatch()
             try await writer.write(rb)
         } catch {
             print("Unknown error: \(error)")
         }
     }
-    
-    func doPut(_ reader: ArrowFlight.RecordBatchStreamReader, writer: ArrowFlight.PutResultDataStreamWriter) async throws {
+
+    func doPut(
+        _ reader: ArrowFlight.RecordBatchStreamReader,
+        writer: ArrowFlight.PutResultDataStreamWriter) async throws {
         for try await rb in reader {
             XCTAssertEqual(rb.schema.fields.count, 3)
             XCTAssertEqual(rb.length, 4)
             try await writer.write(FlightPutResult())
         }
     }
-    
+
     func doGet(_ ticket: ArrowFlight.FlightTicket, writer: ArrowFlight.RecordBatchStreamWriter) async throws {
         try await writer.write(try makeRecordBatch())
     }
-    
+
     func getSchema(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightSchemaResult {
         XCTAssertEqual(String(bytes: request.cmd, encoding: .utf8)!, "schema info")
         XCTAssertEqual(request.type, .cmd)
         return try ArrowFlight.FlightSchemaResult(schemaToArrowStream(makeSchema()))
     }
-    
+
     func getFlightInfo(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightInfo {
         return ArrowFlight.FlightInfo(Data())
     }
-    
+
     func listFlights(_ criteria: ArrowFlight.FlightCriteria, writer: ArrowFlight.FlightInfoStreamWriter) async throws {
         XCTAssertEqual(String(bytes: criteria.expression, encoding: .utf8), "flight criteria expression")
-        let flight_info = try ArrowFlight.FlightInfo(schemaToArrowStream(makeSchema()))
-        try await writer.write(flight_info)
+        let flightInfo = try ArrowFlight.FlightInfo(schemaToArrowStream(makeSchema()))
+        try await writer.write(flightInfo)
     }
-    
+
     func listActions(_ writer: ArrowFlight.ActionTypeStreamWriter) async throws {
         try await writer.write(FlightActionType("type1", description: "desc1"))
         try await writer.write(FlightActionType("type2", description: "desc2"))
     }
-    
+
     func doAction(_ action: FlightAction, writer: ResultStreamWriter) async throws {
         XCTAssertEqual(action.type, "test_action")
         XCTAssertEqual(String(bytes: action.body, encoding: .utf8)!, "test_action body")
@@ -131,16 +135,15 @@ struct FlightServerImpl {
             // Create an event loop group for the server to run on.
             let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
             // Create a provider using the features we read.
-            let provider = ArrowFlight.MakeFlightServer(MyFlightServer())
-            
+            let provider = ArrowFlight.makeFlightServer(MyFlightServer())
+
             // Start the server and print its address once it has started.
             FlightServerImpl.server = try await Server.insecure(group: group)
                 .withServiceProviders([provider])
                 .bind(host: "localhost", port: 8088)
                 .get()
-            
-            print("server started on port \(server!.channel.localAddress!.port!)")
 
+            print("server started on port \(server!.channel.localAddress!.port!)")
             // Wait on the server's `onClose` future to stop the program from exiting.
         } catch {
             print("Unknown server error: \(error)")
@@ -152,7 +155,7 @@ public class FlightClientTester {
     var client: FlightClient?
     var group: MultiThreadedEventLoopGroup?
     var channel: GRPCChannel?
-    
+
     init() async throws {
         // Load the features.
         let group = PlatformSupport.makeEventLoopGroup(loopCount: 1)
@@ -164,132 +167,135 @@ public class FlightClientTester {
 
         client = FlightClient(channel: channel)
     }
-    
+
     deinit {
         try? group?.syncShutdownGracefully()
         try? channel?.close().wait()
     }
-    
+
     func listActionTest() async throws {
         var actionTypes = [FlightActionType]()
-        try await client?.listActions( { action in
+        try await client?.listActions({ action in
             actionTypes.append(action)
         })
-        
+
         XCTAssertEqual(actionTypes.count, 2)
         XCTAssertEqual(actionTypes[0].type, "type1")
         XCTAssertEqual(actionTypes[0].description, "desc1")
         XCTAssertEqual(actionTypes[1].type, "type2")
         XCTAssertEqual(actionTypes[1].description, "desc2")
     }
-    
+
     func listFlightsTest() async throws {
         let flightCriteria = FlightCriteria("flight criteria expression".data(using: .utf8)!)
-        var num_calls = 0
+        var numCalls = 0
         try await client?.listFlights(flightCriteria, closure: { data in
-            num_calls += 1
+            numCalls += 1
             let schema = try streamToArrowSchema(data.schema)
             XCTAssertEqual(schema.fields.count, 3)
         })
-        
-        XCTAssertEqual(num_calls, 1)
+
+        XCTAssertEqual(numCalls, 1)
     }
-    
+
     func doActionTest() async throws {
         let action = FlightAction("test_action", body: "test_action body".data(using: .utf8)!)
         var actionResults = [FlightResult]()
         try await client?.doAction(action, closure: { result in
             actionResults.append(result)
         })
-        
+
         XCTAssertEqual(actionResults.count, 1)
-        XCTAssertEqual(String(bytes:actionResults[0].body, encoding: .utf8), "test_action result")
+        XCTAssertEqual(String(bytes: actionResults[0].body, encoding: .utf8), "test_action result")
     }
-    
+
     func getSchemaTest() async throws {
         let descriptor = FlightDescriptor(cmd: "schema info".data(using: .utf8)!)
         let schemaResult = try await client?.getSchema(descriptor)
         let schema = try streamToArrowSchema(schemaResult!.schema)
         XCTAssertEqual(schema.fields.count, 3)
     }
-    
+
     func doGetTest() async throws {
         let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
-        var num_call = 0
+        var numCall = 0
         try await client?.doGet(ticket, readerResultClosure: { rb in
-            num_call += 1
+            numCall += 1
             XCTAssertEqual(rb.schema!.fields.count, 3)
             XCTAssertEqual(rb.batches[0].length, 4)
         })
-        
-        XCTAssertEqual(num_call, 1)
+
+        XCTAssertEqual(numCall, 1)
     }
-    
+
     func doGetTestFlightData() async throws {
         let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
-        var num_call = 0
+        var numCall = 0
         try await client?.doGet(ticket, flightDataClosure: { flightData in
-            let reader = ArrowReader();
+            let reader = ArrowReader()
             let result = reader.fromStream(flightData.dataBody)
             switch result {
             case .success(let rb):
                 XCTAssertEqual(rb.schema?.fields.count, 3)
                 XCTAssertEqual(rb.batches[0].length, 4)
-                num_call += 1
+                numCall += 1
             case .failure(let error):
                 throw error
             }
         })
-        
-        XCTAssertEqual(num_call, 1)
+
+        XCTAssertEqual(numCall, 1)
     }
-    
+
     func doPutTest() async throws {
         let rb = try makeRecordBatch()
-        var num_call = 0
-        try await client?.doPut([rb], closure: { result in
-            num_call += 1
+        var numCall = 0
+        try await client?.doPut([rb], closure: { _ in
+            numCall += 1
         })
-        
-        XCTAssertEqual(num_call, 1)
+
+        XCTAssertEqual(numCall, 1)
     }
 
     func doExchangeTest() async throws {
         let rb = try makeRecordBatch()
-        var num_call = 0
+        var numCall = 0
         try await client?.doExchange([rb], closure: { result in
-            num_call += 1
+            numCall += 1
             XCTAssertEqual(result.schema?.fields.count, 3)
             XCTAssertEqual(result.batches[0].length, 4)
         })
-        
-        XCTAssertEqual(num_call, 1)
+
+        XCTAssertEqual(numCall, 1)
     }
 }
 
 actor FlightServerData {
     public var serverup = false
-    func SetServerUp(_ serverUp: Bool) {
+    func setServerUp(_ serverUp: Bool) {
         self.serverup = serverUp
     }
-    
-    func IsServerUp() -> Bool {
+
+    func isServerUp() -> Bool {
         return serverup
     }
 }
 
 final class FlightTest: XCTestCase {
     let serverData = FlightServerData()
-    
+
     func testFlightServer() async throws {
         let basicTask = Task {
             try await FlightServerImpl.run()
             defer {
                 print("server shutting down")
-                try! FlightServerImpl.group?.syncShutdownGracefully()
+                do {
+                    try FlightServerImpl.group?.syncShutdownGracefully()
+                } catch {
+                }
             }
-            
-            await serverData.SetServerUp(true)
+
+            await serverData.setServerUp(true)
             try await FlightServerImpl.server?.onClose.get()
             return "done"
         }
@@ -298,11 +304,11 @@ final class FlightTest: XCTestCase {
             defer {
                 _ = FlightServerImpl.server?.close()
             }
-            
-            while await !serverData.IsServerUp() {
+
+            while await !serverData.isServerUp() {
                 try await Task.sleep(nanoseconds: 1_000_000)
             }
-            
+
             let clientImpl = try await FlightClientTester()
             try await clientImpl.listActionTest()
             try await clientImpl.listFlightsTest()
@@ -312,11 +318,10 @@ final class FlightTest: XCTestCase {
             try await clientImpl.doGetTestFlightData()
             try await clientImpl.doPutTest()
             try await clientImpl.doExchangeTest()
-            
             return "done"
         }
-                
-        let _ = try await [basicTask.value, secondTask.value]
+
+        _ = try await [basicTask.value, secondTask.value]
         print("done running")
     }
 }

From 3be5e603dab1fbb48b5fae11df8e1d6d1cef9e03 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 25 Oct 2023 10:13:17 +0800
Subject: [PATCH 623/749] GH-38042: [C++][Benchmark] Add non-stream Codec
 Compression/Decompression (#38067)

### Rationale for this change

Currently, we will enable compression benchmark with ARROW_WITH_BENCHMARKS_REFERENCE

Note that it only has benchmark for compressor ( make by Codec::MakeCompressor() ) and decompressor ( make by Codec::MakeDecompressor ). However, Parquet uses Codec to encode and decode. So, I'd like to add benchmarks that use Codec directly.

### What changes are included in this PR?

Add benchmark for direct compression and decompression

### Are these changes tested?

no need

### Are there any user-facing changes?

no

* Closes: #38042

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/compression_benchmark.cc | 67 +++++++++++++++++++--
 1 file changed, 63 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/util/compression_benchmark.cc b/cpp/src/arrow/util/compression_benchmark.cc
index c76be275f426c..9ed8a00c521c7 100644
--- a/cpp/src/arrow/util/compression_benchmark.cc
+++ b/cpp/src/arrow/util/compression_benchmark.cc
@@ -30,8 +30,7 @@
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
 
-namespace arrow {
-namespace util {
+namespace arrow::util {
 
 #ifdef ARROW_WITH_BENCHMARKS_REFERENCE
 
@@ -133,6 +132,37 @@ static void ReferenceStreamingCompression(
   StreamingCompression(COMPRESSION, data, state);
 }
 
+int64_t Compress(Codec* codec, const std::vector<uint8_t>& data,
+                 std::vector<uint8_t>* compressed_data) {
+  const uint8_t* input = data.data();
+  int64_t input_len = data.size();
+  int64_t compressed_size = 0;
+  int64_t max_compressed_len = codec->MaxCompressedLen(input_len, input);
+  compressed_data->resize(max_compressed_len);
+
+  if (input_len > 0) {
+    compressed_size = *codec->Compress(input_len, input, compressed_data->size(),
+                                       compressed_data->data());
+    compressed_data->resize(compressed_size);
+  }
+  return compressed_size;
+}
+
+template <Compression::type COMPRESSION>
+static void ReferenceCompression(benchmark::State& state) {  // NOLINT non-const reference
+  auto data = MakeCompressibleData(8 * 1024 * 1024);         // 8 MB
+
+  auto codec = *Codec::Create(COMPRESSION);
+
+  while (state.KeepRunning()) {
+    std::vector<uint8_t> compressed_data;
+    auto compressed_size = Compress(codec.get(), data, &compressed_data);
+    state.counters["ratio"] =
+        static_cast<double>(data.size()) / static_cast<double>(compressed_size);
+  }
+  state.SetBytesProcessed(state.iterations() * data.size());
+}
+
 static void StreamingDecompression(
     Compression::type compression, const std::vector<uint8_t>& data,
     benchmark::State& state) {  // NOLINT non-const reference
@@ -175,27 +205,56 @@ static void ReferenceStreamingDecompression(
   StreamingDecompression(COMPRESSION, data, state);
 }
 
+template <Compression::type COMPRESSION>
+static void ReferenceDecompression(
+    benchmark::State& state) {                        // NOLINT non-const reference
+  auto data = MakeCompressibleData(8 * 1024 * 1024);  // 8 MB
+
+  auto codec = *Codec::Create(COMPRESSION);
+
+  std::vector<uint8_t> compressed_data;
+  ARROW_UNUSED(Compress(codec.get(), data, &compressed_data));
+  state.counters["ratio"] =
+      static_cast<double>(data.size()) / static_cast<double>(compressed_data.size());
+
+  std::vector<uint8_t> decompressed_data(data);
+  while (state.KeepRunning()) {
+    auto result = codec->Decompress(compressed_data.size(), compressed_data.data(),
+                                    decompressed_data.size(), decompressed_data.data());
+    ARROW_CHECK(result.ok());
+    ARROW_CHECK(*result == static_cast<int64_t>(decompressed_data.size()));
+  }
+  state.SetBytesProcessed(state.iterations() * data.size());
+}
+
 #ifdef ARROW_WITH_ZLIB
 BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::GZIP);
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::GZIP);
 BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::GZIP);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::GZIP);
 #endif
 
 #ifdef ARROW_WITH_BROTLI
 BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::BROTLI);
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::BROTLI);
 BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::BROTLI);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::BROTLI);
 #endif
 
 #ifdef ARROW_WITH_ZSTD
 BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::ZSTD);
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::ZSTD);
 BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::ZSTD);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::ZSTD);
 #endif
 
 #ifdef ARROW_WITH_LZ4
 BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::LZ4_FRAME);
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::LZ4_FRAME);
 BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::LZ4_FRAME);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::LZ4_FRAME);
 #endif
 
 #endif
 
-}  // namespace util
-}  // namespace arrow
+}  // namespace arrow::util

From 99f893f41fa21da2a9d13240ec5f8301e0881dae Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 25 Oct 2023 04:16:54 +0200
Subject: [PATCH 624/749] GH-38402: [CI][Integration] Provide wrapper scripts
 for integration testing (#38403)

### Rationale for this change

It is currently cumbersome to run integration tests from an other repository, as each tested implementation must be built explicitly.

See explanatory comment at https://github.com/apache/arrow-rs/pull/4957#issuecomment-1771707301

### What changes are included in this PR?

Provide a wrapper script to automate building the implementations being tested.

Allow usage of environment variables such as `ARROW_INTEGRATION_CPP`, etc. to selectively disable implementations.

### Are these changes tested?

Yes, by construction.

### Are there any user-facing changes?

No.
* Closes: #38402

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/go_build.sh                |  4 +-
 ci/scripts/integration_arrow.sh       | 26 ++++++++++---
 ci/scripts/integration_arrow_build.sh | 55 +++++++++++++++++++++++++++
 docker-compose.yml                    | 13 +------
 4 files changed, 79 insertions(+), 19 deletions(-)
 create mode 100755 ci/scripts/integration_arrow_build.sh

diff --git a/ci/scripts/go_build.sh b/ci/scripts/go_build.sh
index 7c5ca3230c96e..94f75e501ea0b 100755
--- a/ci/scripts/go_build.sh
+++ b/ci/scripts/go_build.sh
@@ -42,7 +42,9 @@ go install -v ./...
 
 popd
 
-if [[ -n "${ARROW_GO_INTEGRATION}" ]]; then
+: ${ARROW_INTEGRATION_GO:=ON}
+
+if [ "${ARROW_INTEGRATION_GO}" == "ON" ]; then
     pushd ${source_dir}/arrow/internal/cdata_integration
 
     case "$(uname)" in
diff --git a/ci/scripts/integration_arrow.sh b/ci/scripts/integration_arrow.sh
index 2861b1c09d479..b5a38f01412d4 100755
--- a/ci/scripts/integration_arrow.sh
+++ b/ci/scripts/integration_arrow.sh
@@ -20,11 +20,25 @@
 set -ex
 
 arrow_dir=${1}
+build_dir=${2}
+
 gold_dir=$arrow_dir/testing/data/arrow-ipc-stream/integration
 
+: ${ARROW_INTEGRATION_CPP:=ON}
+: ${ARROW_INTEGRATION_CSHARP:=ON}
+: ${ARROW_INTEGRATION_GO:=ON}
+: ${ARROW_INTEGRATION_JAVA:=ON}
+: ${ARROW_INTEGRATION_JS:=ON}
+
 pip install -e $arrow_dir/dev/archery[integration]
+
 # For C Data Interface testing
-pip install jpype1 pythonnet
+if [ "${ARROW_INTEGRATION_CSHARP}" == "ON" ]; then
+    pip install pythonnet
+fi
+if [ "${ARROW_INTEGRATION_JAVA}" == "ON" ]; then
+    pip install jpype1
+fi
 
 # Get more detailed context on crashes
 export PYTHONFAULTHANDLER=1
@@ -34,11 +48,11 @@ time archery integration \
     --run-c-data \
     --run-ipc \
     --run-flight \
-    --with-cpp=1 \
-    --with-csharp=1 \
-    --with-java=1 \
-    --with-js=1 \
-    --with-go=1 \
+    --with-cpp=$([ "$ARROW_INTEGRATION_CPP" == "ON" ] && echo "1" || echo "0") \
+    --with-csharp=$([ "$ARROW_INTEGRATION_CSHARP" == "ON" ] && echo "1" || echo "0") \
+    --with-go=$([ "$ARROW_INTEGRATION_GO" == "ON" ] && echo "1" || echo "0") \
+    --with-java=$([ "$ARROW_INTEGRATION_JAVA" == "ON" ] && echo "1" || echo "0") \
+    --with-js=$([ "$ARROW_INTEGRATION_JS" == "ON" ] && echo "1" || echo "0") \
     --gold-dirs=$gold_dir/0.14.1 \
     --gold-dirs=$gold_dir/0.17.1 \
     --gold-dirs=$gold_dir/1.0.0-bigendian \
diff --git a/ci/scripts/integration_arrow_build.sh b/ci/scripts/integration_arrow_build.sh
new file mode 100755
index 0000000000000..02f593bf77b23
--- /dev/null
+++ b/ci/scripts/integration_arrow_build.sh
@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+set -ex
+
+arrow_dir=${1}
+build_dir=${2}
+
+: ${ARROW_INTEGRATION_CPP:=ON}
+: ${ARROW_INTEGRATION_CSHARP:=ON}
+: ${ARROW_INTEGRATION_GO:=ON}
+: ${ARROW_INTEGRATION_JAVA:=ON}
+: ${ARROW_INTEGRATION_JS:=ON}
+
+${arrow_dir}/ci/scripts/rust_build.sh ${arrow_dir} ${build_dir}
+
+if [ "${ARROW_INTEGRATION_CPP}" == "ON" ]; then
+    ${arrow_dir}/ci/scripts/cpp_build.sh ${arrow_dir} ${build_dir}
+fi
+
+if [ "${ARROW_INTEGRATION_CSHARP}" == "ON" ]; then
+    ${arrow_dir}/ci/scripts/csharp_build.sh ${arrow_dir} ${build_dir}
+fi
+
+if [ "${ARROW_INTEGRATION_GO}" == "ON" ]; then
+    ${arrow_dir}/ci/scripts/go_build.sh ${arrow_dir} ${build_dir}
+fi
+
+if [ "${ARROW_INTEGRATION_JAVA}" == "ON" ]; then
+    export ARROW_JAVA_CDATA="ON"
+    export JAVA_JNI_CMAKE_ARGS="-DARROW_JAVA_JNI_ENABLE_DEFAULT=OFF -DARROW_JAVA_JNI_ENABLE_C=ON"
+
+    ${arrow_dir}/ci/scripts/java_jni_build.sh ${arrow_dir} ${ARROW_HOME} ${build_dir} /tmp/dist/java/$(arch)
+    ${arrow_dir}/ci/scripts/java_build.sh ${arrow_dir} ${build_dir} /tmp/dist/java
+fi
+
+if [ "${ARROW_INTEGRATION_JS}" == "ON" ]; then
+    ${arrow_dir}/ci/scripts/js_build.sh ${arrow_dir} ${build_dir}
+fi
diff --git a/docker-compose.yml b/docker-compose.yml
index e54c609e54138..c23d3ff08e487 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1733,19 +1733,8 @@ services:
       ARCHERY_INTEGRATION_WITH_RUST: 0
       # Tell Archery where the arrow C++ binaries are located
       ARROW_CPP_EXE_PATH: /build/cpp/debug
-      ARROW_GO_INTEGRATION: 1
-      ARROW_JAVA_CDATA: "ON"
-      JAVA_JNI_CMAKE_ARGS: >-
-        -DARROW_JAVA_JNI_ENABLE_DEFAULT=OFF
-        -DARROW_JAVA_JNI_ENABLE_C=ON
     command:
-      ["/arrow/ci/scripts/rust_build.sh /arrow /build &&
-        /arrow/ci/scripts/cpp_build.sh /arrow /build &&
-        /arrow/ci/scripts/csharp_build.sh /arrow /build &&
-        /arrow/ci/scripts/go_build.sh /arrow &&
-        /arrow/ci/scripts/java_jni_build.sh /arrow $${ARROW_HOME} /build /tmp/dist/java/$$(arch) &&
-        /arrow/ci/scripts/java_build.sh /arrow /build /tmp/dist/java &&
-        /arrow/ci/scripts/js_build.sh /arrow /build &&
+      ["/arrow/ci/scripts/integration_arrow_build.sh /arrow /build &&
         /arrow/ci/scripts/integration_arrow.sh /arrow /build"]
 
   ################################ Docs #######################################

From 2a4e0db7dd23d0aef6136e361472cba2bff8af21 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Wed, 25 Oct 2023 05:11:22 +0200
Subject: [PATCH 625/749] GH-27839: [R] Fetch latest nightly binary for arrow R
 dev versions. (#38236)

### Rationale for this change

We currently need to manually download the latest nightly build as the ".9000' dev version never matches any nightly builds.

### What changes are included in this PR?

Check the nightly  repo html listing for the latest version matching the local major version.
Refactor  nixlibs.R and integrate the functionality of winlibs.R  into it to simplify maintenance and prepare for the future of in-line windows libarrow builds.

These changes are build on #38195 so once that is merged I will rebase this.

### Are these changes tested?

Crossbow
* Closes: #27839

Lead-authored-by: Jacob Wujciak-Jens <jacob@wujciak.de>
Co-authored-by: Dewey Dunnington <dewey@dunnington.ca>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 r/configure                                |  20 +-
 r/configure.win                            |   3 +-
 r/tools/nixlibs.R                          | 261 +++++++++++++--------
 r/tools/winlibs.R                          | 100 --------
 r/vignettes/developers/install_details.Rmd |  59 +++--
 5 files changed, 215 insertions(+), 228 deletions(-)
 delete mode 100644 r/tools/winlibs.R

diff --git a/r/configure b/r/configure
index c957c9946fba0..5a7f0c81a947b 100755
--- a/r/configure
+++ b/r/configure
@@ -203,9 +203,27 @@ find_arrow () {
 do_bundled_build () {
   ${R_HOME}/bin/Rscript tools/nixlibs.R $VERSION
 
+  if [ $? -ne 0 ]; then
+    # If the nixlibs.R script failed, we can't continue
+    echo "------------------------- NOTE ---------------------------"
+    echo "There was an issue building the Arrow C++ libraries."
+    echo "See https://arrow.apache.org/docs/r/articles/install.html"
+    echo "---------------------------------------------------------"
+    exit 1
+  fi
+
+  if [ -d "libarrow/arrow-$VERSION" ]; then
+    _LIBARROW_FOUND="`pwd`/libarrow/arrow-${VERSION}"
+  else
+    # It's possible that the version of the libarrow binary is not identical to the
+    # R version, e.g. if the R build is a patch release, so find what the dir is
+    # actually called. If there is more than one version present, use the one
+    # with the highest version:
+    _LIBARROW_FOUND="`pwd`/libarrow/$(ls libarrow/ | grep ^arrow- | tail -n 1)"
+  fi
+
   # Handle a few special cases, using what we know about the bundled build
   # and our ability to make edits to it since we "own" it.
-  _LIBARROW_FOUND="`pwd`/libarrow/arrow-${VERSION}"
   LIB_DIR="${_LIBARROW_FOUND}/lib"
   if [ -d "$LIB_DIR" ]; then
     if [ "${PKG_CONFIG_AVAILABLE}" = "true" ]; then
diff --git a/r/configure.win b/r/configure.win
index eed0c632dea13..2d9e5cdf54e44 100755
--- a/r/configure.win
+++ b/r/configure.win
@@ -38,8 +38,7 @@ GCS_LIBS="-lcurl -lnormaliz -lssh2 -lgdi32 -lssl -lcrypto -lcrypt32 -lwldap32 \
 function configure_release() {
   VERSION=$(grep ^Version DESCRIPTION | sed s/Version:\ //)
   # Try to find/download a C++ Arrow binary,
-  # including possibly a local .zip file if RWINLIB_LOCAL is set
-  "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" "tools/winlibs.R" $VERSION $RWINLIB_LOCAL
+  "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" "tools/nixlibs.R" $VERSION 
   # If binary not found, script exits nonzero
   if [ $? -ne 0 ]; then
     echo "Arrow C++ library was not found"
diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 3d651ec6ac9ea..96f2b858cf180 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -15,35 +15,55 @@
 # specific language governing permissions and limitations
 # under the License.
 
-args <- commandArgs(TRUE)
-VERSION <- args[1]
-dst_dir <- paste0("libarrow/arrow-", VERSION)
-
-# TESTING is set in test-nixlibs.R; it won't be set when called from configure
-test_mode <- exists("TESTING")
+#### Fuctions #### check end of file for main logic
+env_is <- function(var, value) identical(tolower(Sys.getenv(var)), value)
 
-# Prevent error with binary selection during testing.
-if (test_mode && is.na(VERSION)) {
-  VERSION <- "8.0.0.9000"
+# Log messages in the style of the configure script
+lg <- function(..., .indent = "***") {
+  cat(.indent, " ", sprintf(...), "\n", sep = "")
 }
 
-dev_version <- package_version(VERSION)[1, 4]
-is_release <- is.na(dev_version) || dev_version < "100"
-on_macos <- tolower(Sys.info()[["sysname"]]) == "darwin"
-checksum_path <- Sys.getenv("ARROW_R_CHECKSUM_PATH", "tools/checksums")
+cleanup <- function(path) {
+  options(.arrow.cleanup = c(getOption(".arrow.cleanup"), path))
+}
 
-# Small dev versions are added for R-only changes during CRAN submission.
-if (is_release) {
-  VERSION <- package_version(VERSION)[1, 1:3]
-  arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
-} else {
-  arrow_repo <- paste0(getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"), "/libarrow/")
+# Exit the script after logging with .status=1 instead of throwing an error
+exit <- function(..., .status = 1) {
+  lg(...)
+  q(save = "no", status = .status)
 }
 
-options(.arrow.cleanup = character()) # To collect dirs to rm on exit
-on.exit(unlink(getOption(".arrow.cleanup")))
 
-env_is <- function(var, value) identical(tolower(Sys.getenv(var)), value)
+# checks the nightly repo for the latest nightly version X.Y.Z.100<dev>
+find_latest_nightly <- function(description_version) {
+  if (!startsWith(arrow_repo, "https://nightlies.apache.org/arrow/r")) {
+    lg("Detected non standard dev repo: %s, not checking latest nightly version.", arrow_repo)
+    return(description_version)
+  }
+
+  res <- try(
+    {
+      # Binaries are only uploaded if all jobs pass so can just look at the source versions.
+      urls <- readLines("https://nightlies.apache.org/arrow/r/src/contrib")
+      versions <- grep("arrow_.*\\.tar\\.gz", urls, value = TRUE)
+      versions <- sub(".*arrow_(.*)\\.tar\\.gz.*", "\\1", x = versions)
+      versions <- sapply(versions, package_version)
+      versions <- data.frame(do.call(rbind, versions))
+      matching_major <- versions[versions$X1 == description_version[1, 1], ]
+      latest <- matching_major[which.max(matching_major$X4), ]
+      package_version(paste0(latest, collapse = "."))
+    },
+    silent = quietly
+  )
+  if (inherits(res, "try-error")) {
+    lg("Failed to find latest nightly for %s", description_version)
+    latest <- description_version
+  } else {
+    lg("Found latest nightly for %s: %s", description_version, res)
+    latest <- res
+  }
+  latest
+}
 
 try_download <- function(from_url, to_file, hush = quietly) {
   status <- try(
@@ -56,52 +76,19 @@ try_download <- function(from_url, to_file, hush = quietly) {
   !inherits(status, "try-error") && status == 0
 }
 
-not_cran <- env_is("NOT_CRAN", "true")
-# enable full featured builds and binaries for macOS (or if the NOT_CRAN variable has been set)
-if (not_cran || on_macos) {
-  # Set more eager defaults
-  if (env_is("LIBARROW_BINARY", "")) {
-    Sys.setenv(LIBARROW_BINARY = "true")
-  }
-  if (env_is("LIBARROW_MINIMAL", "")) {
-    Sys.setenv(LIBARROW_MINIMAL = "false")
-  }
-}
-
-# For local debugging, set ARROW_R_DEV=TRUE to make this script print more
-quietly <- !env_is("ARROW_R_DEV", "true")
-
-# The default will build from source as a fallback if a binary is not found or shouldn't be used
-# Set LIBARROW_BUILD=FALSE to ensure that we use a previously built libarrow
-# and don't fall back to a full source build
-build_ok <- !env_is("LIBARROW_BUILD", "false")
-
-# Check if we're authorized to download (not asked an offline build).
-# (Note that cmake will still be downloaded if necessary
-#  https://arrow.apache.org/docs/developers/cpp/building.html#offline-builds)
-download_ok <- !test_mode && !env_is("TEST_OFFLINE_BUILD", "true")
-
-# This "tools/thirdparty_dependencies" path, within the tar file, might exist if
-# create_package_with_all_dependencies() was run, or if someone has created it
-# manually before running make build.
-# If you change this path, you also need to edit
-# `create_package_with_all_dependencies()` in install-arrow.R
-thirdparty_dependency_dir <- Sys.getenv("ARROW_THIRDPARTY_DEPENDENCY_DIR", "tools/thirdparty_dependencies")
-
-
 download_binary <- function(lib) {
   libfile <- paste0("arrow-", VERSION, ".zip")
   binary_url <- paste0(arrow_repo, "bin/", lib, "/arrow-", VERSION, ".zip")
   if (try_download(binary_url, libfile)) {
     if (!quietly) {
-      cat(sprintf("*** Successfully retrieved C++ binaries (%s)\n", lib))
+      lg("Successfully retrieved C++ binaries (%s)", lib)
     }
   } else {
     if (!quietly) {
-      cat(sprintf(
-        "*** Downloading libarrow binary failed for version %s (%s)\n    at %s\n",
+      lg(
+        "Downloading libarrow binary failed for version %s (%s)\n    at %s",
         VERSION, lib, binary_url
-      ))
+      )
     }
     libfile <- NULL
   }
@@ -109,6 +96,7 @@ download_binary <- function(lib) {
   # e.g. in case the included checksums are stale.
   skip_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "false")
   enforce_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "true")
+  checksum_path <- Sys.getenv("ARROW_R_CHECKSUM_PATH", "tools/checksums")
   # validate binary checksum for CRAN release only
   if (!skip_checksum && dir.exists(checksum_path) && is_release ||
     enforce_checksum) {
@@ -163,6 +151,10 @@ download_binary <- function(lib) {
 #   These string values, along with `NULL`, are the potential return values of
 #   this function.
 identify_binary <- function(lib = Sys.getenv("LIBARROW_BINARY"), info = distro()) {
+  if (on_windows) {
+    return("windows")
+  }
+
   lib <- tolower(lib)
   if (identical(lib, "")) {
     # Not specified. Check the allowlist.
@@ -171,16 +163,16 @@ identify_binary <- function(lib = Sys.getenv("LIBARROW_BINARY"), info = distro()
 
   if (identical(lib, "false")) {
     # Do not download a binary
-    NULL
+    lib <- NULL
   } else if (!identical(lib, "true")) {
     # Env var provided an os-version to use, to override our logic.
     # We don't validate that this exists. If it doesn't, the download will fail
     # and the build will fall back to building from source
-    lib
   } else {
     # See if we can find a suitable binary
-    select_binary()
+    lib <- select_binary()
   }
+  lib
 }
 
 check_allowlist <- function(os, allowed = "https://raw.githubusercontent.com/apache/arrow/main/r/tools/nixlibs-allowlist.txt") {
@@ -209,13 +201,13 @@ select_binary <- function(os = tolower(Sys.info()[["sysname"]]),
         ifelse(is.null(openssl_version), NULL, paste0(os, arch, openssl_version))
       },
       error = function(e) {
-        cat("*** Unable to find libcurl and openssl\n")
+        lg("Unable to find libcurl and openssl")
         NULL
       }
     )
   } else {
     # No binary available for arch
-    cat(sprintf("*** Building on %s %s\n", os, arch))
+    lg("Building on %s %s", os, arch)
     binary <- NULL
   }
   return(binary)
@@ -284,32 +276,32 @@ determine_binary_from_stderr <- function(errs) {
   if (is.null(attr(errs, "status"))) {
     # There was no error in compiling: so we found libcurl and OpenSSL >= 1.1,
     # openssl is < 3.0
-    cat("*** Found libcurl and OpenSSL >= 1.1\n")
+    lg("Found libcurl and OpenSSL >= 1.1")
     return("openssl-1.1")
     # Else, check for dealbreakers:
   } else if (!on_macos && any(grepl("Using libc++", errs, fixed = TRUE))) {
     # Our linux binaries are all built with GNU stdlib so they fail with libc++
-    cat("*** Linux binaries incompatible with libc++\n")
+    lg("Linux binaries incompatible with libc++")
     return(NULL)
   } else if (header_not_found("curl/curl", errs)) {
-    cat("*** libcurl not found\n")
+    lg("libcurl not found")
     return(NULL)
   } else if (header_not_found("openssl/opensslv", errs)) {
-    cat("*** OpenSSL not found\n")
+    lg("OpenSSL not found")
     return(NULL)
   } else if (any(grepl("OpenSSL version too old", errs))) {
-    cat("*** OpenSSL found but version >= 1.0.2 is required for some features\n")
+    lg("OpenSSL found but version >= 1.0.2 is required for some features")
     return(NULL)
     # Else, determine which other binary will work
   } else if (any(grepl("Using OpenSSL version 1.0", errs))) {
     if (on_macos) {
-      cat("*** OpenSSL 1.0 is not supported on macOS\n")
+      lg("OpenSSL 1.0 is not supported on macOS")
       return(NULL)
     }
-    cat("*** Found libcurl and OpenSSL < 1.1\n")
+    lg("Found libcurl and OpenSSL < 1.1")
     return("openssl-1.0")
   } else if (any(grepl("Using OpenSSL version 3", errs))) {
-    cat("*** Found libcurl and OpenSSL >= 3.0.0\n")
+    lg("Found libcurl and OpenSSL >= 3.0.0")
     return("openssl-3.0")
   }
   NULL
@@ -438,7 +430,7 @@ find_local_source <- function() {
   )
   for (cpp_dir in cpp_dir_options) {
     if (file.exists(file.path(cpp_dir, "src/arrow/api.h"))) {
-      cat(paste0("*** Found local C++ source: '", cpp_dir, "'\n"))
+      lg("Found local C++ source: '%s'", cpp_dir)
       return(cpp_dir)
     }
   }
@@ -459,7 +451,7 @@ env_vars_as_string <- function(env_var_list) {
   if (nchar(env_var_string) > 30000) {
     # This could happen if the full paths in *_SOURCE_URL were *very* long.
     # A more formal check would look at getconf ARG_MAX, but this shouldn't matter
-    cat("*** Warning: Environment variables are very long. This could cause issues on some shells.\n")
+    lg("Warning: Environment variables are very long. This could cause issues on some shells.")
   }
   env_var_string
 }
@@ -484,7 +476,7 @@ build_libarrow <- function(src_dir, dst_dir) {
     Sys.setenv(MAKEFLAGS = makeflags)
   }
   if (!quietly) {
-    cat("*** Building with MAKEFLAGS=", makeflags, "\n")
+    lg("Building with MAKEFLAGS=", makeflags)
   }
   # Check for libarrow build dependencies:
   # * cmake
@@ -498,7 +490,7 @@ build_libarrow <- function(src_dir, dst_dir) {
     # But normally we'll just build in a tmp dir
     build_dir <- tempfile()
   }
-  options(.arrow.cleanup = c(getOption(".arrow.cleanup"), build_dir))
+  cleanup(build_dir)
 
   env_var_list <- c(
     SOURCE_DIR = src_dir,
@@ -523,7 +515,7 @@ build_libarrow <- function(src_dir, dst_dir) {
 
   dep_source <- Sys.getenv("ARROW_DEPENDENCY_SOURCE")
   if (dep_source %in% c("", "AUTO") && !nzchar(Sys.which("pkg-config"))) {
-    cat("**** pkg-config not installed, setting ARROW_DEPENDENCY_SOURCE=BUNDLED\n")
+    lg("pkg-config not installed, setting ARROW_DEPENDENCY_SOURCE=BUNDLED", .indent = "****")
     env_var_list <- c(env_var_list, ARROW_DEPENDENCY_SOURCE = "BUNDLED")
   }
 
@@ -552,7 +544,7 @@ build_libarrow <- function(src_dir, dst_dir) {
   }
   env_vars <- env_vars_as_string(env_var_list)
 
-  cat("**** arrow", ifelse(quietly, "", paste("with", env_vars)), "\n")
+  lg("arrow %s", ifelse(quietly, "", paste("with", env_vars)), .indent = "****")
 
   build_log_path <- tempfile(fileext = ".log")
   status <- suppressWarnings(system2(
@@ -565,7 +557,7 @@ build_libarrow <- function(src_dir, dst_dir) {
 
   if (status != 0) {
     # It failed :(
-    cat("**** Error building Arrow C++.", "\n")
+    lg("Error building Arrow C++.", .indent = "****")
     if (quietly) {
       cat(
         "**** Printing contents of build log because the build failed",
@@ -583,7 +575,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
 
   if (is.null(cmake)) {
     # If not found, download it
-    cat("**** cmake\n")
+    lg("cmake", .indent = "****")
     CMAKE_VERSION <- Sys.getenv("CMAKE_VERSION", "3.26.4")
     if (on_macos) {
       postfix <- "-macos-universal.tar.gz"
@@ -592,10 +584,10 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
     } else if (tolower(Sys.info()[["machine"]]) == "x86_64") {
       postfix <- "-linux-x86_64.tar.gz"
     } else {
-      stop(paste0(
+      exit(paste0(
         "*** cmake was not found locally.\n",
         "    Please make sure cmake >= ", cmake_minimum_required,
-        " is installed and available on your PATH.\n"
+        " is installed and available on your PATH."
       ))
     }
     cmake_binary_url <- paste0(
@@ -606,7 +598,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
     cmake_dir <- tempfile()
     download_successful <- try_download(cmake_binary_url, cmake_tar)
     if (!download_successful) {
-      cat(paste0(
+      exit(paste0(
         "*** cmake was not found locally and download failed.\n",
         "    Make sure cmake >= ", cmake_minimum_required,
         " is installed and available on your PATH,\n",
@@ -616,7 +608,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
     }
     untar(cmake_tar, exdir = cmake_dir)
     unlink(cmake_tar)
-    options(.arrow.cleanup = c(getOption(".arrow.cleanup"), cmake_dir))
+    cleanup(cmake_dir)
     cmake <- paste0(
       cmake_dir,
       "/cmake-", CMAKE_VERSION, sub(".tar.gz", "", postfix, fixed = TRUE),
@@ -625,7 +617,7 @@ ensure_cmake <- function(cmake_minimum_required = "3.16") {
   } else {
     # Show which one we found
     # Full source builds will always show "cmake" in the logs
-    cat(sprintf("**** cmake: %s\n", cmake))
+    lg("cmake: %s", cmake, .indent = "****")
   }
   cmake
 }
@@ -796,7 +788,7 @@ with_cloud_support <- function(env_var_list) {
 cmake_find_package <- function(pkg, version = NULL, env_var_list) {
   td <- tempfile()
   dir.create(td)
-  options(.arrow.cleanup = c(getOption(".arrow.cleanup"), td))
+  cleanup(td)
   find_package <- paste0("find_package(", pkg, " ", version, " REQUIRED)")
   writeLines(find_package, file.path(td, "CMakeLists.txt"))
   env_vars <- env_vars_as_string(env_var_list)
@@ -811,22 +803,101 @@ cmake_find_package <- function(pkg, version = NULL, env_var_list) {
   system(cmake_cmd, ignore.stdout = TRUE, ignore.stderr = TRUE) == 0
 }
 
-#####
+############### Main logic #############
+args <- commandArgs(TRUE)
+VERSION <- args[1]
+
+# TESTING is set in test-nixlibs.R; it won't be set when called from configure
+test_mode <- exists("TESTING")
+
+# Prevent error with binary selection during testing.
+if (test_mode && is.na(VERSION)) {
+  VERSION <- "8.0.0.9000"
+}
+
+VERSION <- package_version(VERSION)
+dev_version <- VERSION[1, 4]
+# Small dev versions are added for R-only changes during CRAN submission
+is_release <- is.na(dev_version) || dev_version < "100"
+
+on_macos <- tolower(Sys.info()[["sysname"]]) == "darwin"
+on_windows <- tolower(Sys.info()[["sysname"]]) == "windows"
+
+# For local debugging, set ARROW_R_DEV=TRUE to make this script print more
+quietly <- !env_is("ARROW_R_DEV", "true")
+
+not_cran <- env_is("NOT_CRAN", "true")
+
+if (is_release) {
+  VERSION <- VERSION[1, 1:3]
+  arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
+} else {
+  not_cran <- TRUE
+  arrow_repo <- paste0(getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"), "/libarrow/")
+  VERSION <- find_latest_nightly(VERSION)
+}
+
+# To collect dirs to rm on exit, use del() to add dirs
+# we reset it to avoid errors on reruns in the same session.
+options(.arrow.cleanup = character())
+on.exit(unlink(getOption(".arrow.cleanup"), recursive = TRUE), add = TRUE)
+
+# enable full featured builds for macOS in case of CRAN source builds.
+if (not_cran || on_macos) {
+  # Set more eager defaults
+  if (env_is("LIBARROW_BINARY", "")) {
+    Sys.setenv(LIBARROW_BINARY = "true")
+  }
+  if (env_is("LIBARROW_MINIMAL", "")) {
+    Sys.setenv(LIBARROW_MINIMAL = "false")
+  }
+}
+
+# The default will build from source as a fallback if a binary is not found or shouldn't be used
+# Set LIBARROW_BUILD=FALSE to ensure that we use a previously built libarrow
+# and don't fall back to a full source build
+build_ok <- !env_is("LIBARROW_BUILD", "false")
+
+# Check if we're authorized to download (not asked an offline build).
+# (Note that cmake will still be downloaded if necessary
+#  https://arrow.apache.org/docs/developers/cpp/building.html#offline-builds)
+download_ok <- !test_mode && !env_is("TEST_OFFLINE_BUILD", "true")
+
+# This "tools/thirdparty_dependencies" path, within the tar file, might exist if
+# create_package_with_all_dependencies() was run, or if someone has created it
+# manually before running make build.
+# If you change this path, you also need to edit
+# `create_package_with_all_dependencies()` in install-arrow.R
+thirdparty_dependency_dir <- Sys.getenv("ARROW_THIRDPARTY_DEPENDENCY_DIR", "tools/thirdparty_dependencies")
+
+arrow_versioned <- paste0("arrow-", VERSION)
+# configure.win uses a different libarrow dir and and the zip is already nested
+if (on_windows) {
+  lib_dir <- "windows"
+  dst_dir <- lib_dir
+} else {
+  lib_dir <- "libarrow"
+  dst_dir <- file.path(lib_dir, arrow_versioned)
+}
+
+api_h <- file.path(lib_dir, arrow_versioned, "include/arrow/api.h")
 
-if (!test_mode && !file.exists(paste0(dst_dir, "/include/arrow/api.h"))) {
+if (!test_mode && !file.exists(api_h)) {
   # If we're working in a local checkout and have already built the libs, we
   # don't need to do anything. Otherwise,
   # (1) Look for a prebuilt binary for this version
   bin_file <- src_dir <- NULL
 
-  if (!identical(Sys.getenv("ARROW_DOWNLOADED_BINARIES"), "")) {
-    bin_zip <- Sys.getenv("ARROW_DOWNLOADED_BINARIES")
-    cat(sprintf("*** Using pre-downloaded zip for libarrow binaries: %s\n", bin_zip))
+  # Keep backwards compatibility with winlibs.R
+  bin_zip <- Sys.getenv("ARROW_DOWNLOADED_BINARIES", Sys.getenv("RWINLIB_LOCAL", NA))
+
+  if (!is.na(bin_zip)) {
+    lg("Using pre-downloaded zip for libarrow binaries: %s", bin_zip)
     if (file.exists(bin_zip)) {
       bin_file <- tempfile()
       file.copy(bin_zip, bin_file)
     } else {
-      cat(sprintf("*** File not found: %s ($ARROW_DOWNLOADED_BINARIES)\n", bin_zip))
+      lg("File not found: %s ($ARROW_DOWNLOADED_BINARIES)", bin_zip)
       bin_file <- NULL
     }
   } else if (download_ok) {
@@ -842,7 +913,7 @@ if (!test_mode && !file.exists(paste0(dst_dir, "/include/arrow/api.h"))) {
     dir.create(dst_dir, showWarnings = !quietly, recursive = TRUE)
     unzip(bin_file, exdir = dst_dir)
     unlink(bin_file)
-  } else if (build_ok) {
+  } else if (build_ok && !on_windows) {
     # (2) Find source and build it
     src_dir <- find_local_source()
     if (!is.null(src_dir)) {
@@ -853,9 +924,9 @@ if (!test_mode && !file.exists(paste0(dst_dir, "/include/arrow/api.h"))) {
       ))
       build_libarrow(src_dir, dst_dir)
     } else {
-      cat("*** Proceeding without libarrow (no local source)\n")
+      exit("Proceeding without libarrow (no local source)")
     }
   } else {
-    cat("*** Proceeding without libarrow (build not authorized)\n")
+    exit("Proceeding without libarrow (build not authorized)")
   }
 }
diff --git a/r/tools/winlibs.R b/r/tools/winlibs.R
deleted file mode 100644
index 314062044dcf2..0000000000000
--- a/r/tools/winlibs.R
+++ /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.
-
-args <- commandArgs(TRUE)
-VERSION <- args[1]
-dev_version <- package_version(VERSION)[1, 4]
-# Small dev versions are added for R-only changes during CRAN submission
-is_release <- is.na(dev_version) || dev_version < "100"
-env_is <- function(var, value) identical(tolower(Sys.getenv(var)), value)
-# We want to log the message in the style of the configure script
-# not as an R error. Use `return` to exit the script after logging.
-lg <- function(...) {
-  cat("*** ", sprintf(...), "\n")
-}
-
-if (is_release) {
-  # This is a release version, so we need to use the major.minor.patch version without
-  # the CRAN suffix/dev_version
-  VERSION <- package_version(VERSION)[1, 1:3]
-  # %1$s uses the first variable for both substitutions
-  url_template <- paste0(
-    getOption("arrow.repo", "https://apache.jfrog.io/artifactory/arrow/r/%1$s"),
-    "/libarrow/bin/windows/arrow-%1$s.zip"
-  )
-} else {
-  url_template <- paste0(
-    getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"),
-    "/libarrow/bin/windows/arrow-%s.zip"
-  )
-}
-
-if (file.exists(sprintf("windows/arrow-%s/include/arrow/api.h", VERSION))) {
-  lg("Found local Arrow %s!", VERSION)
-  return()
-}
-
-zip_file <- sprintf("arrow-%s.zip", VERSION)
-
-if (length(args) > 1) {
-  # Arg 2 would be the path/to/lib.zip
-  localfile <- args[2]
-  if (!file.exists(localfile)) {
-    lg("RWINLIB_LOCAL '%s' does not exist. Build will fail.", localfile)
-    return()
-  } else {
-    lg("Using RWINLIB_LOCAL %s", localfile)
-  }
-  file.copy(localfile, zip_file)
-} else {
-  quietly <- !identical(tolower(Sys.getenv("ARROW_R_DEV")), "true")
-  binary_url <- sprintf(url_template, VERSION)
-  try(
-    suppressWarnings(
-      download.file(binary_url, zip_file, quiet = quietly)
-    ),
-    silent = quietly
-  )
-
-  if (!file.exists(zip_file) || file.size(zip_file) == 0) {
-    lg("Failed to download libarrow binary from %s. Build will fail.", binary_url)
-    return()
-  }
-
-  checksum_path <- Sys.getenv("ARROW_R_CHECKSUM_PATH", "tools/checksums")
-  # Explicitly setting the env var to "false" will skip checksum validation
-  # e.g. in case the included checksums are stale.
-  skip_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "false")
-  enforce_checksum <- env_is("ARROW_R_ENFORCE_CHECKSUM", "true")
-  # validate binary checksum for CRAN release only
-  if (!skip_checksum && dir.exists(checksum_path) && is_release ||
-    enforce_checksum) {
-    checksum_file <- sprintf("%s/windows/arrow-%s.zip.sha512", checksum_path, VERSION)
-    # rtools does not have shasum with default config
-    checksum_ok <- system2("sha512sum", args = c("--status", "-c", checksum_file))
-
-    if (checksum_ok != 0) {
-      lg("Checksum validation failed for libarrow binary: %s", zip_file)
-      return()
-    }
-    lg("Checksum validated successfully for libarrow binary: %s", zip_file)
-  }
-}
-
-dir.create("windows", showWarnings = FALSE)
-unzip(zip_file, exdir = "windows")
-unlink(zip_file)
diff --git a/r/vignettes/developers/install_details.Rmd b/r/vignettes/developers/install_details.Rmd
index 2f2f126b61b38..83700b196a642 100644
--- a/r/vignettes/developers/install_details.Rmd
+++ b/r/vignettes/developers/install_details.Rmd
@@ -5,12 +5,12 @@ description: >
 output: rmarkdown::html_vignette
 ---
 
-This document is intended specifically for arrow _developers_ who wish to know 
-more about these scripts.  If you are an arrow _user_ looking for help with 
+This document is intended specifically for arrow _developers_ who wish to know
+more about these scripts.  If you are an arrow _user_ looking for help with
 installing arrow, please see [the installation guide](../install.html)
 
-The arrow R package requires that Arrow C++ library (also known as libarrow) to 
-be installed in order to work properly.  There are a number of different ways 
+The arrow R package requires that Arrow C++ library (also known as libarrow) to
+be installed in order to work properly.  There are a number of different ways
 in which libarrow could be installed:
 
 * as part of the R package installation process
@@ -21,9 +21,9 @@ Below, we discuss each of these setups in turn.
 
 # Installing libarrow during R package installation
 
-There are a number of scripts that are triggered 
-when `R CMD INSTALL .` is run and for Arrow users, these should all just work 
-without configuration and pull in the most complete pieces (e.g. official 
+There are a number of scripts that are triggered
+when `R CMD INSTALL .` is run and for Arrow users, these should all just work
+without configuration and pull in the most complete pieces (e.g. official
 binaries that we host).  One of the jobs of these scripts is to work out
 if libarrow is installed, and if not, install it.
 
@@ -35,23 +35,22 @@ handle finding the libarrow, setting up the build variables necessary, and
 writing the package Makevars file that is used to compile the C++ code in the R
 package.
 
-* `tools/nixlibs.R` - this script is called by `configure` on Linux
+* `tools/nixlibs.R` - this script is called by `configure` on Linux and macOS
 (or on any non-windows OS with the environment variable
-`FORCE_BUNDLED_BUILD=true`) if an existing libarrow installation cannot be found.
-This sets up the build process for our bundled builds (which is the default on 
-linux) and checks for binaries or downloads libarrow from source depending on 
-dependency availability and build configuration.
-
-* `tools/winlibs.R` - this script is called by `configure.win` on Windows
-when environment variable `ARROW_HOME` is not set.  It looks for an existing libarrow
-installation, and if it can't find one downloads an appropriate libarrow binary.
-
-* `inst/build_arrow_static.sh` - called by `tools/nixlibs.R` when libarrow  
+`FORCE_BUNDLED_BUILD=true`). On windows this script is called by
+`configure.win` when environment variable `ARROW_HOME` is not set.
+It looks for an existing libarrow installation, and if it can't find one 
+downloads an appropriate libarrow binary.
+On non-windows if no binary could be found, the script sets up the build
+process for our bundled builds (which is the default on linux) and checks
+for dependencies.
+
+* `inst/build_arrow_static.sh` - called by `tools/nixlibs.R` when libarrow
 needs to be built.  It builds libarrow for a bundled, static build, and
 mirrors the steps described in the [Arrow R developer guide](./setup.html)
 This build script is also what is used to generate our prebuilt binaries.
 
-The actions taken by these scripts to resolve dependencies and install the 
+The actions taken by these scripts to resolve dependencies and install the
 correct components are described below.
 
 ## How the R package finds libarrow
@@ -80,7 +79,7 @@ On Linux and macOS, the core logic is:
 2. Find libarrow on the system. If it is present, make sure that its version
    is compatible with the R package.
 3. If no suitable libarrow is found, download it (where allowed) or build it from source.
-4. Determine what features this libarrow has and what other flags it requires, 
+4. Determine what features this libarrow has and what other flags it requires,
    and set them in `src/Makevars` for use when compiling the bindings.
 
 #### Finding libarrow on the system
@@ -93,7 +92,7 @@ The `configure` script will look for libarrow in three places:
 
 If a libarrow build is found, it will then check that the version of that C++ library
 matches that of the R package. If the versions do not match, like when you've installed
-a system package for a release version but you have a development version of the 
+a system package for a release version but you have a development version of the
 R package, that libarrow will not be used. If both the C++ library and R package are
 on development versions, you will see a warning message advising you that if you do have
 trouble, you should ensure that the C++ library was built from the same commit as the R
@@ -101,10 +100,10 @@ package, as development version numbers do not change with every commit.
 
 #### Prebuilt binaries
 
-If libarrow is not found on the system, the R package installation 
+If libarrow is not found on the system, the R package installation
 script will next attempt to download prebuilt libarrow binaries
-that match your both your local operating system, required 
-dependencies (e.g. openssl version) and arrow R package version. 
+that match your both your local operating system, required
+dependencies (e.g. openssl version) and arrow R package version.
 
 These are used automatically on many Linux distributions (x86_64 architecture only),
 according to the [allowlist](https://github.com/apache/arrow/blob/main/r/tools/nixlibs-allowlist.txt).
@@ -115,18 +114,18 @@ downloaded and bundled when your R package compiles.
 #### Building from source
 
 If no suitable libarrow binary is found, it will attempt to build it locally.
-First, it will also look to see if you are in a checkout of the `apache/arrow` 
+First, it will also look to see if you are in a checkout of the `apache/arrow`
 git repository and thus have the libarrow source files there.
 Otherwise, it builds from the source files included in the package.
-Depending on your system, building libarrow from source may be slow. If 
+Depending on your system, building libarrow from source may be slow. If
 libarrow is built from source, `inst/build_arrow_static.sh` is executed.
 
 # Using the R package with libarrow installed as a system package
 
 If you are authorized to install system packages and you're installing a CRAN release,
-you may want to use the official Apache Arrow release packages corresponding to 
-the R package version via software distribution tools such as `apt` or `yum` 
-(though there are some drawbacks: see the 
+you may want to use the official Apache Arrow release packages corresponding to
+the R package version via software distribution tools such as `apt` or `yum`
+(though there are some drawbacks: see the
 ["Troubleshooting" section in the main installation docs](../install.html#troubleshooting)).
 See the [Arrow project installation page](https://arrow.apache.org/install/)
 to find pre-compiled binary packages for some common Linux distributions,
@@ -138,5 +137,5 @@ be useful because the versions will not match.
 # Using the R package with an existing libarrow build
 
 This setup is much more common for arrow developers, who may be needing to make
-changes to both the R package and libarrow source code.  See 
+changes to both the R package and libarrow source code.  See
 the [developer setup docs](./setup.html) for more information.

From 91b642a0bdbecd3969861f14ed3f914d65a4aa14 Mon Sep 17 00:00:00 2001
From: Diogo Teles Sant'Anna <diogoteles@google.com>
Date: Wed, 25 Oct 2023 00:32:53 -0300
Subject: [PATCH 626/749] GH-36898: [CI] Hashpin Sensitive GitHub Actions
 (#37676)

### Rationale for this change

Explained on issue #36898

### What changes are included in this PR?

For security reasons, it hashpins the calls for github actions that are called with sensitive permission (usually `pull-requests: write`) or with secrets used on the same context. I'm not hashpinning every action call because the tag-pinning flexibility can be useful if used with caution, e.g. in testing environment.

### Are these changes tested?

Not tested, but the changes on this PR shouldn't change any comportment of the CI, as we'd still be using the exact same version, but pinned differently.

### Are there any user-facing changes?

No
* Closes: #36898

Authored-by: Diogo Teles Sant'Anna <diogoteles@google.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 .github/workflows/comment_bot.yml  | 20 ++++++++++----------
 .github/workflows/cpp.yml          |  4 ++--
 .github/workflows/dev.yml          | 12 ++++++------
 .github/workflows/dev_pr.yml       | 10 +++++-----
 .github/workflows/docs.yml         |  6 +++---
 .github/workflows/docs_light.yml   |  6 +++---
 .github/workflows/go.yml           | 22 +++++++++++-----------
 .github/workflows/integration.yml  |  8 ++++----
 .github/workflows/issue_bot.yml    |  2 +-
 .github/workflows/java.yml         |  6 +++---
 .github/workflows/java_jni.yml     | 12 ++++++------
 .github/workflows/java_nightly.yml |  6 +++---
 .github/workflows/js.yml           |  4 ++--
 .github/workflows/pr_bot.yml       |  6 +++---
 .github/workflows/python.yml       |  6 +++---
 .github/workflows/r.yml            | 14 +++++++-------
 .github/workflows/r_nightly.yml    |  8 ++++----
 .github/workflows/ruby.yml         |  6 +++---
 .github/workflows/swift.yml        |  2 +-
 19 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/.github/workflows/comment_bot.yml b/.github/workflows/comment_bot.yml
index cc9e02d955afd..f27d95c4e8cd7 100644
--- a/.github/workflows/comment_bot.yml
+++ b/.github/workflows/comment_bot.yml
@@ -35,13 +35,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           path: arrow
           # fetch the tags for version number generation
           fetch-depth: 0
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Install Archery and Crossbow dependencies
@@ -60,8 +60,8 @@ jobs:
     if: startsWith(github.event.comment.body, '@github-actions autotune')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: r-lib/actions/pr-fetch@v2
+      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
+      - uses: r-lib/actions/pr-fetch@11a22a908006c25fe054c4ef0ac0436b1de3edbe # v2.6.4
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: See what is different
@@ -121,7 +121,7 @@ jobs:
               --clang_format_binary=clang-format-${CLANG_TOOLS} \
               --exclude_glob=cpp/build-support/lint_exclusions.txt \
               --source_dir=r/src --quiet --fix
-      - uses: r-lib/actions/setup-r@v2
+      - uses: r-lib/actions/setup-r@11a22a908006c25fe054c4ef0ac0436b1de3edbe # v2.6.4
         if: env.R_DOCS == 'true' || env.R_CODE == 'true' || endsWith(github.event.comment.body, 'everything')
       - name: Update R docs
         if: env.R_DOCS == 'true' || endsWith(github.event.comment.body, 'everything')
@@ -149,7 +149,7 @@ jobs:
           git config user.name "$(git log -1 --pretty=format:%an)"
           git config user.email "$(git log -1 --pretty=format:%ae)"
           git commit -a -m 'Autoformat/render all the things [automated commit]' || echo "No changes to commit"
-      - uses: r-lib/actions/pr-push@v2
+      - uses: r-lib/actions/pr-push@11a22a908006c25fe054c4ef0ac0436b1de3edbe # v2.6.4
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
 
@@ -158,8 +158,8 @@ jobs:
     if: startsWith(github.event.comment.body, '@github-actions rebase')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: r-lib/actions/pr-fetch@v2
+      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
+      - uses: r-lib/actions/pr-fetch@11a22a908006c25fe054c4ef0ac0436b1de3edbe # v2.6.4
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
       - name: Rebase on ${{ github.repository }} default branch
@@ -170,7 +170,7 @@ jobs:
           git remote add upstream https://github.com/${{ github.repository }}
           git fetch --unshallow upstream ${{ github.event.repository.default_branch }}
           git rebase upstream/${{ github.event.repository.default_branch }}
-      - uses: r-lib/actions/pr-push@v2
+      - uses: r-lib/actions/pr-push@11a22a908006c25fe054c4ef0ac0436b1de3edbe # v2.6.4
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           args: "--force"
@@ -182,7 +182,7 @@ jobs:
     if: github.event.comment.body == 'take'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
diff --git a/.github/workflows/cpp.yml b/.github/workflows/cpp.yml
index a9361f9f51378..e6ae6c60b0f4c 100644
--- a/.github/workflows/cpp.yml
+++ b/.github/workflows/cpp.yml
@@ -96,12 +96,12 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: ${{ matrix.image }}-${{ hashFiles('cpp/**') }}
diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index cfa9ffb49d7ad..df2b20a9e3c77 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -37,11 +37,11 @@ jobs:
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -84,19 +84,19 @@ jobs:
       GIT_COMMITTER_EMAIL: "github-actions[bot]@users.noreply.github.com"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: '3.8'
       - name: Install Ruby
-        uses: ruby/setup-ruby@v1
+        uses: ruby/setup-ruby@250fcd6a742febb1123a77a841497ccaa8b9e939 # v1.152.0
         with:
           ruby-version: '2.7'
       - name: Install .NET
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@3447fd6a9f9e57506b15f895c5b76d3b197dc7c2 # v3.2.0
         with:
           dotnet-version: '7.0.x'
       - name: Install Dependencies
diff --git a/.github/workflows/dev_pr.yml b/.github/workflows/dev_pr.yml
index e5d2a77c5a8a2..78b01b561f3cb 100644
--- a/.github/workflows/dev_pr.yml
+++ b/.github/workflows/dev_pr.yml
@@ -43,7 +43,7 @@ jobs:
     name: Process
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           repository: apache/arrow
           ref: main
@@ -53,7 +53,7 @@ jobs:
         if: |
           (github.event.action == 'opened' ||
            github.event.action == 'edited')
-        uses: actions/github-script@v6
+        uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
@@ -64,7 +64,7 @@ jobs:
         if: |
           (github.event.action == 'opened' ||
            github.event.action == 'edited')
-        uses: actions/github-script@v6
+        uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
@@ -75,7 +75,7 @@ jobs:
         if: |
           (github.event.action == 'opened' ||
            github.event.action == 'edited')
-        uses: actions/github-script@v6
+        uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           debug: true
           github-token: ${{ secrets.GITHUB_TOKEN }}
@@ -87,7 +87,7 @@ jobs:
         if: |
           (github.event.action == 'opened' ||
            github.event.action == 'synchronize')
-        uses: actions/labeler@v4
+        uses: actions/labeler@ac9175f8a1f3625fd0d4fb234536d26811351594 # v4.3.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           configuration-path: .github/workflows/dev_pr/labeler.yml
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index a1ac4c3067dae..b30e1eb8809db 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -38,20 +38,20 @@ jobs:
       UBUNTU: "22.04"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Free up disk space
         run: |
           ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: ubuntu-docs-${{ hashFiles('cpp/**') }}
           restore-keys: ubuntu-docs-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/docs_light.yml b/.github/workflows/docs_light.yml
index 74e6eabe24795..e96ccecdff598 100644
--- a/.github/workflows/docs_light.yml
+++ b/.github/workflows/docs_light.yml
@@ -47,17 +47,17 @@ jobs:
       PYTHON: "3.9"
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: conda-docs-${{ hashFiles('cpp/**') }}
           restore-keys: conda-docs-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index a0dfb9fea1673..11668aaf1b301 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -73,7 +73,7 @@ jobs:
       GO: ${{ matrix.go }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
@@ -106,7 +106,7 @@ jobs:
           github.event_name == 'push' &&
           github.repository == 'apache/arrow' &&
           github.ref_name == 'main'
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4.1.0
         with:
           go-version: ${{ matrix.go }}
           cache: true
@@ -162,12 +162,12 @@ jobs:
       GO: ${{ matrix.go }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -203,11 +203,11 @@ jobs:
       GO: ${{ matrix.go }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -240,12 +240,12 @@ jobs:
         go: [1.19, '1.20']
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Install go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4.1.0
         with:
           go-version: ${{ matrix.go }}
           cache: true
@@ -273,12 +273,12 @@ jobs:
         go: [1.19, '1.20']
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Install go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4.1.0
         with:
           go-version: ${{ matrix.go }}
           cache: true
@@ -299,7 +299,7 @@ jobs:
           github.event_name == 'push' &&
           github.repository == 'apache/arrow' &&
           github.ref_name == 'main'
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: '3.10'
       - name: Run Benchmarks
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 430b0bb2822e7..bd99b62a2fe02 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -62,12 +62,12 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Checkout Arrow Rust
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           repository: apache/arrow-rs
           path: rust
@@ -75,13 +75,13 @@ jobs:
         run: |
           ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: conda-${{ hashFiles('cpp/**') }}
           restore-keys: conda-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/issue_bot.yml b/.github/workflows/issue_bot.yml
index ae344a4c1eba9..86d1858c8c596 100644
--- a/.github/workflows/issue_bot.yml
+++ b/.github/workflows/issue_bot.yml
@@ -33,7 +33,7 @@ jobs:
     if: github.event.issue.pull_request == null
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/github-script@v6
+      - uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           script: |
             let split_body = context.payload.issue.body.split('### Component(s)');
diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 76bc57a6c712c..444bec2c73b61 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -80,18 +80,18 @@ jobs:
       MAVEN: ${{ matrix.maven }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: maven-${{ hashFiles('java/**') }}
           restore-keys: maven-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/java_jni.yml b/.github/workflows/java_jni.yml
index 467e8a88af5d3..76b10b828ee49 100644
--- a/.github/workflows/java_jni.yml
+++ b/.github/workflows/java_jni.yml
@@ -56,7 +56,7 @@ jobs:
     timeout-minutes: 500
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
@@ -64,13 +64,13 @@ jobs:
         run: |
           ci/scripts/util_free_space.sh
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: java-jni-manylinux-2014-${{ hashFiles('cpp/**', 'java/**') }}
           restore-keys: java-jni-manylinux-2014-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -99,18 +99,18 @@ jobs:
     timeout-minutes: 90
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: maven-${{ hashFiles('java/**') }}
           restore-keys: maven-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/java_nightly.yml b/.github/workflows/java_nightly.yml
index 41843d663051a..11aa4e59beefd 100644
--- a/.github/workflows/java_nightly.yml
+++ b/.github/workflows/java_nightly.yml
@@ -43,7 +43,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 1
           path: arrow
@@ -51,14 +51,14 @@ jobs:
           ref: main
           submodules: recursive
       - name: Checkout Crossbow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           path: crossbow
           repository: ursacomputing/crossbow
           ref: main
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           cache: 'pip'
           python-version: 3.8
diff --git a/.github/workflows/js.yml b/.github/workflows/js.yml
index 781b2023e2f42..b2040a76dec48 100644
--- a/.github/workflows/js.yml
+++ b/.github/workflows/js.yml
@@ -47,11 +47,11 @@ jobs:
     timeout-minutes: 60
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/pr_bot.yml b/.github/workflows/pr_bot.yml
index 617f3f2e017a3..596d3511a543d 100644
--- a/.github/workflows/pr_bot.yml
+++ b/.github/workflows/pr_bot.yml
@@ -40,7 +40,7 @@ jobs:
       - name: 'Download PR review payload'
         id: 'download'
         if: github.event_name == 'workflow_run'
-        uses: actions/github-script@v6
+        uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           script: |
             const run_id = "${{ github.event.workflow_run.id }}";
@@ -73,7 +73,7 @@ jobs:
           curl -sL -o committers.yml $url
           echo "committers_path=$(pwd)/committers.yml" >> $GITHUB_OUTPUT
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           path: arrow
           repository: apache/arrow
@@ -82,7 +82,7 @@ jobs:
           # fetch the tags for version number generation
           fetch-depth: 0
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Install Archery and Crossbow dependencies
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 7a8fd8d10c235..d201f90101de8 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -89,18 +89,18 @@ jobs:
       NUMPY: ${{ matrix.numpy || 'latest' }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: ${{ matrix.cache }}-${{ hashFiles('cpp/**') }}
           restore-keys: ${{ matrix.cache }}-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/r.yml b/.github/workflows/r.yml
index a8680aea56d48..db10e6f28ce1c 100644
--- a/.github/workflows/r.yml
+++ b/.github/workflows/r.yml
@@ -68,12 +68,12 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           # As this key is identical on both matrix builds only one will be able to successfully cache,
@@ -83,7 +83,7 @@ jobs:
             ubuntu-${{ matrix.ubuntu }}-r-${{ matrix.r }}-${{ hashFiles('cpp/src/**/*.cc','cpp/src/**/*.h)') }}-
             ubuntu-${{ matrix.ubuntu }}-r-${{ matrix.r }}-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -106,7 +106,7 @@ jobs:
         if: always()
       - name: Save the test output
         if: always()
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@0b7f8abb1508181956e8e162db84b466c27e18ce # v3.1.2
         with:
           name: test-output
           path: r/check/arrow.Rcheck/tests/testthat.Rout*
@@ -139,12 +139,12 @@ jobs:
       DEVTOOLSET_VERSION: ${{ matrix.config.devtoolset }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
@@ -168,7 +168,7 @@ jobs:
         if: always()
       - name: Save the test output
         if: always()
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@0b7f8abb1508181956e8e162db84b466c27e18ce # v3.1.2
         with:
           name: test-output
           path: r/check/arrow.Rcheck/tests/testthat.Rout*
diff --git a/.github/workflows/r_nightly.yml b/.github/workflows/r_nightly.yml
index 7f21d4658e007..5a34239721392 100644
--- a/.github/workflows/r_nightly.yml
+++ b/.github/workflows/r_nightly.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 1
           path: arrow
@@ -53,14 +53,14 @@ jobs:
           ref: main
           submodules: recursive
       - name: Checkout Crossbow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           path: crossbow
           repository: ursacomputing/crossbow
           ref: main
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           cache: 'pip'
           python-version: 3.8
@@ -86,7 +86,7 @@ jobs:
             exit 1
           fi
       - name: Cache Repo
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: repo
           key: r-nightly-${{ github.run_id }}
diff --git a/.github/workflows/ruby.yml b/.github/workflows/ruby.yml
index 2e4b98c2428e9..b9a4ac03b6108 100644
--- a/.github/workflows/ruby.yml
+++ b/.github/workflows/ruby.yml
@@ -71,18 +71,18 @@ jobs:
       UBUNTU: ${{ matrix.ubuntu }}
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive
       - name: Cache Docker Volumes
-        uses: actions/cache@v3
+        uses: actions/cache@88522ab9f39a2ea568f7027eddc7d8d8bc9d59c8 # v3.3.1
         with:
           path: .docker
           key: ubuntu-${{ matrix.ubuntu }}-ruby-${{ hashFiles('cpp/**') }}
           restore-keys: ubuntu-${{ matrix.ubuntu }}-ruby-
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@61a6322f88396a6271a6ee3565807d608ecaddd1 # v4.7.0
         with:
           python-version: 3.8
       - name: Setup Archery
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
index 825921ac6fa24..f55e9e77503c0 100644
--- a/.github/workflows/swift.yml
+++ b/.github/workflows/swift.yml
@@ -51,7 +51,7 @@ jobs:
     timeout-minutes: 15
     steps:
       - name: Checkout Arrow
-        uses: actions/checkout@v4
+        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
         with:
           fetch-depth: 0
           submodules: recursive

From c655c33fdf72d86e24cc4a1c1f977c48ea868039 Mon Sep 17 00:00:00 2001
From: Jin Shang <shangjin1997@gmail.com>
Date: Wed, 25 Oct 2023 13:55:19 +0800
Subject: [PATCH 627/749] MINOR: [C++] Fix a maybe-uninitialized warning
 (#38433)

Some compilers generate a maybe-uninitialized warning when compiling scalar_round.cc
```
/home/jinshang/arrow/cpp/src/arrow/util/logging.h: In function 'void arrow::compute::internal::RegisterScalarRoundArithmetic(arrow::compute::FunctionRegistry*)':
/home/jinshang/arrow/cpp/src/arrow/util/logging.h:59:34: warning: 'exec' may be used uninitialized [-Wmaybe-uninitialized]
   59 | #define ARROW_IGNORE_EXPR(expr) ((void)(expr))
      |                                  ^
/home/jinshang/arrow/cpp/src/arrow/compute/kernels/scalar_round.cc:1262:23: note: 'exec' was declared here
 1262 |       ArrayKernelExec exec;
      |                       ^~~~
/home/jinshang/arrow/cpp/src/arrow/util/logging.h:59:34: warning: 'exec' may be used uninitialized [-Wmaybe-uninitialized]
   59 | #define ARROW_IGNORE_EXPR(expr) ((void)(expr))
      |                                  ^
/home/jinshang/arrow/cpp/src/arrow/compute/kernels/scalar_round.cc:1283:23: note: 'exec' was declared here
 1283 |       ArrayKernelExec exec;
      |                       ^~~~
```

Authored-by: Jin Shang <shangjin1997@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/compute/kernels/scalar_round.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/arrow/compute/kernels/scalar_round.cc b/cpp/src/arrow/compute/kernels/scalar_round.cc
index 5dc628f8d95c5..36e59c8c1deac 100644
--- a/cpp/src/arrow/compute/kernels/scalar_round.cc
+++ b/cpp/src/arrow/compute/kernels/scalar_round.cc
@@ -1259,7 +1259,7 @@ std::shared_ptr<ScalarFunction> MakeUnaryRoundFunction(std::string name,
   RoundKernelGenerator<Op, RoundKernel, OptionsType> kernel_generator;
   for (const auto& tys : {NumericTypes(), {decimal128(1, 0), decimal256(1, 0)}}) {
     for (const auto& ty : tys) {
-      ArrayKernelExec exec;
+      ArrayKernelExec exec = nullptr;
       KernelInit init;
       DCHECK_OK(VisitTypeInline(*ty, &kernel_generator, &exec, &init));
       DCHECK_OK(func->AddKernel(
@@ -1280,7 +1280,7 @@ std::shared_ptr<ScalarFunction> MakeBinaryRoundFunction(const std::string& name,
   RoundKernelGenerator<Op, RoundBinaryKernel, OptionsType> kernel_generator;
   for (const auto& tys : {NumericTypes(), {decimal128(1, 0), decimal256(1, 0)}}) {
     for (const auto& ty : tys) {
-      ArrayKernelExec exec;
+      ArrayKernelExec exec = nullptr;
       KernelInit init;
       DCHECK_OK(VisitTypeInline(*ty, &kernel_generator, &exec, &init));
       DCHECK_OK(func->AddKernel(

From 25e5d19b98511310e617c8b6e3c6ce6af39dfcde Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Wed, 25 Oct 2023 18:03:09 +0900
Subject: [PATCH 628/749] GH-38449: [Release][Go][macOS] Use local test data if
 possible (#38450)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

On macOS, "cp -a source/ destination/" copies "source/*" to "destination/" (such as "source/a" is copied to "destination/a") not "source/" to "destination/" (such as "source/a" is copied to "destination/source/a").

### What changes are included in this PR?

We need to remove the trailing "/" from "source/" to copy "source/" itself to "destination/source/".

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38449

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/release/verify-release-candidate.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 287c557fb5ef4..49997fbf4ea91 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -962,7 +962,7 @@ ensure_source_directory() {
   # Ensure that the testing repositories are prepared
   if [ ! -d ${ARROW_SOURCE_DIR}/testing/data ]; then
     if [ -d ${SOURCE_DIR}/../../testing/data ]; then
-      cp -a ${SOURCE_DIR}/../../testing/ ${ARROW_SOURCE_DIR}/
+      cp -a ${SOURCE_DIR}/../../testing ${ARROW_SOURCE_DIR}/
     else
       git clone \
         https://github.com/apache/arrow-testing.git \
@@ -972,7 +972,7 @@ ensure_source_directory() {
   if [ ! -d ${ARROW_SOURCE_DIR}/cpp/submodules/parquet-testing/data ]; then
     if [ -d ${SOURCE_DIR}/../../cpp/submodules/parquet-testing/data ]; then
       cp -a \
-         ${SOURCE_DIR}/../../cpp/submodules/parquet-testing/ \
+         ${SOURCE_DIR}/../../cpp/submodules/parquet-testing \
          ${ARROW_SOURCE_DIR}/cpp/submodules/
     else
       git clone \

From 73589ddd60e4cbcd860102871692541989ea38c6 Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 25 Oct 2023 20:35:17 +0800
Subject: [PATCH 629/749] GH-38452: [C++][Benchmark] Adding benchmark for
 LZ4/Snappy Compression (#38453)

### Rationale for this change

This patch add LZ4 (LZ4_RAW in Parquet standard) and Snappy compression/decompression benchmark.

### What changes are included in this PR?

Add groups of benchmarks.

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #38452

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/util/compression_benchmark.cc | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/cpp/src/arrow/util/compression_benchmark.cc b/cpp/src/arrow/util/compression_benchmark.cc
index 9ed8a00c521c7..cc04eb4634851 100644
--- a/cpp/src/arrow/util/compression_benchmark.cc
+++ b/cpp/src/arrow/util/compression_benchmark.cc
@@ -253,6 +253,14 @@ BENCHMARK_TEMPLATE(ReferenceStreamingCompression, Compression::LZ4_FRAME);
 BENCHMARK_TEMPLATE(ReferenceCompression, Compression::LZ4_FRAME);
 BENCHMARK_TEMPLATE(ReferenceStreamingDecompression, Compression::LZ4_FRAME);
 BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::LZ4_FRAME);
+
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::LZ4);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::LZ4);
+#endif
+
+#ifdef ARROW_WITH_SNAPPY
+BENCHMARK_TEMPLATE(ReferenceCompression, Compression::SNAPPY);
+BENCHMARK_TEMPLATE(ReferenceDecompression, Compression::SNAPPY);
 #endif
 
 #endif

From e8360615adf6c5a9bb76b81267d08388c7cfc3a9 Mon Sep 17 00:00:00 2001
From: Gang Wu <ustcwg@gmail.com>
Date: Thu, 26 Oct 2023 03:50:29 +0800
Subject: [PATCH 630/749] GH-38346: [C++][Parquet] Use new encrypted files for
 page index encryption test (#38347)

### Rationale for this change

Encrypted parquet files have been updated to apache/parquet-testing repo. We can use the new files to verify encrypted page index.

### What changes are included in this PR?

Minor refactor read_configurations_test.cc to check page index from all parquet files.

### Are these changes tested?

This is indeed a unit test enhancement.

### Are there any user-facing changes?

NO.
* Closes: #38346

Authored-by: Gang Wu <ustcwg@gmail.com>
Signed-off-by: mwish <maplewish117@gmail.com>
---
 .../encryption/read_configurations_test.cc    | 24 +++++++------------
 cpp/submodules/parquet-testing                |  2 +-
 2 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/cpp/src/parquet/encryption/read_configurations_test.cc b/cpp/src/parquet/encryption/read_configurations_test.cc
index 695696db293fb..94fb6362269e2 100644
--- a/cpp/src/parquet/encryption/read_configurations_test.cc
+++ b/cpp/src/parquet/encryption/read_configurations_test.cc
@@ -203,17 +203,15 @@ class TestDecryptionConfiguration
 
   // Check that the decryption result is as expected.
   void CheckResults(const std::string& file_name, unsigned decryption_config_num,
-                    unsigned encryption_config_num, bool file_has_page_index) {
+                    unsigned encryption_config_num) {
     // Encryption_configuration number five contains aad_prefix and
     // disable_aad_prefix_storage.
     // An exception is expected to be thrown if the file is not decrypted with aad_prefix.
     if (encryption_config_num == 5) {
       if (decryption_config_num == 1 || decryption_config_num == 3) {
         EXPECT_THROW(DecryptFile(file_name, decryption_config_num - 1), ParquetException);
-        if (file_has_page_index) {
-          EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
-                       ParquetException);
-        }
+        EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
+                     ParquetException);
         return;
       }
     }
@@ -222,10 +220,8 @@ class TestDecryptionConfiguration
     if (decryption_config_num == 2) {
       if (encryption_config_num != 5 && encryption_config_num != 4) {
         EXPECT_THROW(DecryptFile(file_name, decryption_config_num - 1), ParquetException);
-        if (file_has_page_index) {
-          EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
-                       ParquetException);
-        }
+        EXPECT_THROW(DecryptPageIndex(file_name, decryption_config_num - 1),
+                     ParquetException);
         return;
       }
     }
@@ -235,9 +231,7 @@ class TestDecryptionConfiguration
       return;
     }
     EXPECT_NO_THROW(DecryptFile(file_name, decryption_config_num - 1));
-    if (file_has_page_index) {
-      EXPECT_NO_THROW(DecryptPageIndex(file_name, decryption_config_num - 1));
-    }
+    EXPECT_NO_THROW(DecryptPageIndex(file_name, decryption_config_num - 1));
   }
 
   // Returns true if file exists. Otherwise returns false.
@@ -269,8 +263,7 @@ TEST_P(TestDecryptionConfiguration, TestDecryption) {
   // parquet file.
   for (unsigned index = 0; index < vector_of_decryption_configurations_.size(); ++index) {
     unsigned decryption_config_num = index + 1;
-    CheckResults(file_name, decryption_config_num, encryption_config_num,
-                 /*file_has_page_index=*/true);
+    CheckResults(file_name, decryption_config_num, encryption_config_num);
   }
   // Delete temporary test file.
   ASSERT_EQ(std::remove(file_name.c_str()), 0);
@@ -288,8 +281,7 @@ TEST_P(TestDecryptionConfiguration, TestDecryption) {
   // parquet file.
   for (unsigned index = 0; index < vector_of_decryption_configurations_.size(); ++index) {
     unsigned decryption_config_num = index + 1;
-    CheckResults(file_name, decryption_config_num, encryption_config_num,
-                 /*file_has_page_index=*/false);
+    CheckResults(file_name, decryption_config_num, encryption_config_num);
   }
 }
 
diff --git a/cpp/submodules/parquet-testing b/cpp/submodules/parquet-testing
index b2e7cc7551591..e45cd23f784aa 160000
--- a/cpp/submodules/parquet-testing
+++ b/cpp/submodules/parquet-testing
@@ -1 +1 @@
-Subproject commit b2e7cc755159196e3a068c8594f7acbaecfdaaac
+Subproject commit e45cd23f784aab3d6bf0701f8f4e621469ed3be7

From 7970e1f2aafdd21094ac80e15c8793613fdeecbd Mon Sep 17 00:00:00 2001
From: anjakefala <anja@voltrondata.com>
Date: Wed, 25 Oct 2023 14:38:41 -0700
Subject: [PATCH 631/749] style: run linter

---
 python/pyarrow/tests/test_csv.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/python/pyarrow/tests/test_csv.py b/python/pyarrow/tests/test_csv.py
index e27a35c83fa7e..3c49ee9eddb63 100644
--- a/python/pyarrow/tests/test_csv.py
+++ b/python/pyarrow/tests/test_csv.py
@@ -1936,7 +1936,7 @@ def test_write_quoting_style():
             except Exception as e:
                 # This will trigger when we try to write a comma (,)
                 # without quotes, which is invalid
-                assert type(e) == res
+                assert type(e) is res
                 break
         assert buf.getvalue() == res
         buf.seek(0)
@@ -1986,7 +1986,6 @@ def test_large_binary_write_to_csv(tmpdir, data_size):
 
     write_options = WriteOptions(include_header=True, batch_size=2048,
                                  delimiter='|')
-
     write_csv(fixed_table, file_name, write_options=write_options)
 
     assert os.path.exists(file_name)

From 0f39e8c31edb9a9da72724598b4e1c38fe2fd49e Mon Sep 17 00:00:00 2001
From: anjakefala <anja@voltrondata.com>
Date: Wed, 25 Oct 2023 14:39:16 -0700
Subject: [PATCH 632/749] fix: compare table contents in test

---
 python/pyarrow/tests/test_csv.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/python/pyarrow/tests/test_csv.py b/python/pyarrow/tests/test_csv.py
index 3c49ee9eddb63..9ea4218cce7b6 100644
--- a/python/pyarrow/tests/test_csv.py
+++ b/python/pyarrow/tests/test_csv.py
@@ -1993,6 +1993,10 @@ def test_large_binary_write_to_csv(tmpdir, data_size):
     parse_options = ParseOptions(delimiter="|")
     convert_options = ConvertOptions(column_types={"fixedsize": pa.binary(4)})
     read_options = ReadOptions(block_size=2048)
-    res_table = read_csv(file_name, parse_options=parse_options, convert_options=convert_options, read_options=read_options)
+
+    res_table = read_csv(file_name, parse_options=parse_options,
+                         convert_options=convert_options,
+                         read_options=read_options)
     res_table = res_table.combine_chunks()
-    res_c = res_table.column(0).chunks[0]
+
+    assert res_table.column(0).chunks[0] == fixed_table.column(0).chunks[0]

From ff7b3bba3262c38ba94041aaf0143c0217e41457 Mon Sep 17 00:00:00 2001
From: Peter Andreas Entschev <peter@entschev.com>
Date: Thu, 26 Oct 2023 01:21:18 +0200
Subject: [PATCH 633/749] MINOR: [Python] Deduplicate `ensure_s3_initialized()`
 call (#38451)

### Rationale for this change

https://github.com/apache/arrow/pull/38375 introduced duplicate calls to `ensure_s3_initialized()`.

### What changes are included in this PR?

Deduplicates call to `ensure_s3_initialized()`.

### Are these changes tested?

Yes, covered by existing S3 tests.

### Are there any user-facing changes?

No.

Authored-by: Peter Andreas Entschev <peter@entschev.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 python/pyarrow/_s3fs.pyx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/python/pyarrow/_s3fs.pyx b/python/pyarrow/_s3fs.pyx
index f7f2a5f80887c..13b8c748cb8ca 100644
--- a/python/pyarrow/_s3fs.pyx
+++ b/python/pyarrow/_s3fs.pyx
@@ -269,8 +269,6 @@ cdef class S3FileSystem(FileSystem):
                  load_frequency=900, proxy_options=None,
                  allow_bucket_creation=False, allow_bucket_deletion=False,
                  retry_strategy: S3RetryStrategy = AwsStandardS3RetryStrategy(max_attempts=3)):
-        ensure_s3_initialized()
-
         cdef:
             optional[CS3Options] options
             shared_ptr[CS3FileSystem] wrapped

From 3f4aeab22ab7e37ae86525951d0abd74fc5bc684 Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Thu, 26 Oct 2023 06:13:28 +0200
Subject: [PATCH 634/749] GH-38431: [Python][CI] Update fs.type_name checks for
 s3fs tests (#38455)

### Rationale for this change

Appveyor CI is failing https://ci.appveyor.com/project/ApacheSoftwareFoundation/arrow/builds/48347810. It seems the reason for the test failures is a change in the `type_name` (from `"py::fsspec+s3"` to `"py::fsspec+('s3', 's3a')"`) and due to it tests are not being skipped.

### What changes are included in this PR?

Update the check for `type_name` in case of `PyFileSystem(FSSpecHandler(s3fs.S3FileSystem()))`.
* Closes: #38431

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/conda_env_python.txt         |  2 +-
 python/pyarrow/tests/test_fs.py | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/ci/conda_env_python.txt b/ci/conda_env_python.txt
index da52b5ea689be..97203442129c4 100644
--- a/ci/conda_env_python.txt
+++ b/ci/conda_env_python.txt
@@ -26,6 +26,6 @@ numpy>=1.16.6
 pytest
 pytest-faulthandler
 pytest-lazy-fixture
-s3fs>=2021.8.0
+s3fs>=2023.10.0
 setuptools
 setuptools_scm<8.0.0
diff --git a/python/pyarrow/tests/test_fs.py b/python/pyarrow/tests/test_fs.py
index 72545bf0c6d92..c540bf96818d4 100644
--- a/python/pyarrow/tests/test_fs.py
+++ b/python/pyarrow/tests/test_fs.py
@@ -463,7 +463,7 @@ def check_mtime_or_absent(file_info):
 
 
 def skip_fsspec_s3fs(fs):
-    if fs.type_name == "py::fsspec+s3":
+    if fs.type_name == "py::fsspec+('s3', 's3a')":
         pytest.xfail(reason="Not working with fsspec's s3fs")
 
 
@@ -631,7 +631,7 @@ def test_get_file_info(fs, pathfn):
     assert aaa_info.path == aaa
     assert 'aaa' in repr(aaa_info)
     assert aaa_info.extension == ''
-    if fs.type_name == "py::fsspec+s3":
+    if fs.type_name == "py::fsspec+('s3', 's3a')":
         # s3fs doesn't create empty directories
         assert aaa_info.type == FileType.NotFound
     else:
@@ -646,7 +646,7 @@ def test_get_file_info(fs, pathfn):
     assert bb_info.type == FileType.File
     assert 'FileType.File' in repr(bb_info)
     assert bb_info.size == 0
-    if fs.type_name not in ["py::fsspec+memory", "py::fsspec+s3"]:
+    if fs.type_name not in ["py::fsspec+memory", "py::fsspec+('s3', 's3a')"]:
         check_mtime(bb_info)
 
     assert c_info.path == str(c)
@@ -655,7 +655,7 @@ def test_get_file_info(fs, pathfn):
     assert c_info.type == FileType.File
     assert 'FileType.File' in repr(c_info)
     assert c_info.size == 4
-    if fs.type_name not in ["py::fsspec+memory", "py::fsspec+s3"]:
+    if fs.type_name not in ["py::fsspec+memory", "py::fsspec+('s3', 's3a')"]:
         check_mtime(c_info)
 
     assert zzz_info.path == str(zzz)
@@ -698,7 +698,7 @@ def test_get_file_info_with_selector(fs, pathfn):
         assert selector.base_dir == base_dir
 
         infos = fs.get_file_info(selector)
-        if fs.type_name == "py::fsspec+s3":
+        if fs.type_name == "py::fsspec+('s3', 's3a')":
             # s3fs only lists directories if they are not empty
             len(infos) == 4
         else:
@@ -719,7 +719,7 @@ def test_get_file_info_with_selector(fs, pathfn):
         selector = FileSelector(base_dir, recursive=False)
 
         infos = fs.get_file_info(selector)
-        if fs.type_name == "py::fsspec+s3":
+        if fs.type_name == "py::fsspec+('s3', 's3a')":
             # s3fs only lists directories if they are not empty
             assert len(infos) == 3
         else:

From f2995b0eb9e6792a2cca8ce9e8d9b933d4a9bbfd Mon Sep 17 00:00:00 2001
From: abandy <abandy@live.com>
Date: Thu, 26 Oct 2023 00:30:04 -0400
Subject: [PATCH 635/749] GH-37726: [Swift][FlightSQL] Update behavior to be
 similar to existing impls (#37764)

Swift Flight implementation behavior didn't match existing flight implementations.  The updates in this PR have been tested against python/examples/flight/server.py except for getSchemaTest and doExchangeTest which are not implemented in server.py.  I will follow up this PR with a cleanup refactoring PR.

This difference in behavior was found due to issue #37726.
* Closes: #37726

Authored-by: Alva Bandy <abandy@live.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 swift/.swiftlint.yml                          |    1 +
 swift/Arrow/Sources/Arrow/ArrowReader.swift   |   72 +-
 .../Sources/Arrow/ArrowReaderHelper.swift     |   29 +-
 swift/Arrow/Sources/Arrow/ArrowType.swift     |   11 +
 swift/Arrow/Sources/Arrow/ArrowWriter.swift   |   57 +-
 swift/Arrow/Tests/ArrowTests/TableTests.swift |   14 +-
 .../Sources/ArrowFlight/FlightClient.swift    |  125 +-
 .../Sources/ArrowFlight/FlightData.swift      |    5 +-
 .../Sources/ArrowFlight/FlightInfo.swift      |    4 +-
 .../ArrowFlight/FlightSchemaResult.swift      |    6 +-
 .../Sources/ArrowFlight/FlightServer.swift    |   35 +-
 .../Sources/ArrowFlight/FlightSql.pb.swift    | 5145 +++++++++++++++++
 .../ArrowFlight/RecordBatchStreamReader.swift |   32 +-
 .../ArrowFlight/RecordBatchStreamWriter.swift |   27 +-
 .../Tests/ArrowFlightTests/FlightTest.swift   |  130 +-
 15 files changed, 5520 insertions(+), 173 deletions(-)
 create mode 100644 swift/ArrowFlight/Sources/ArrowFlight/FlightSql.pb.swift

diff --git a/swift/.swiftlint.yml b/swift/.swiftlint.yml
index 9ce377285973f..d447bf9d5d97c 100644
--- a/swift/.swiftlint.yml
+++ b/swift/.swiftlint.yml
@@ -28,6 +28,7 @@ excluded:
   - Arrow/Sources/Arrow/Tensor_generated.swift
   - ArrowFlight/Sources/ArrowFlight/Flight.grpc.swift
   - ArrowFlight/Sources/ArrowFlight/Flight.pb.swift
+  - ArrowFlight/Sources/ArrowFlight/FlightSql.pb.swift
 identifier_name:
   min_length: 2 # only warning
 allow_zero_lintable_files: false
diff --git a/swift/Arrow/Sources/Arrow/ArrowReader.swift b/swift/Arrow/Sources/Arrow/ArrowReader.swift
index 68096133451ba..ef995b18052a8 100644
--- a/swift/Arrow/Sources/Arrow/ArrowReader.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowReader.swift
@@ -32,6 +32,7 @@ public class ArrowReader {
     }
 
     public class ArrowReaderResult {
+        fileprivate var messageSchema: org_apache_arrow_flatbuf_Schema?
         public var schema: ArrowSchema?
         public var batches = [RecordBatch]()
     }
@@ -95,19 +96,19 @@ public class ArrowReader {
         }
     }
 
-    private func loadRecordBatch(_ message: org_apache_arrow_flatbuf_Message,
-                                 schema: org_apache_arrow_flatbuf_Schema,
-                                 arrowSchema: ArrowSchema,
-                                 data: Data,
-                                 messageEndOffset: Int64
+    private func loadRecordBatch(
+        _ recordBatch: org_apache_arrow_flatbuf_RecordBatch,
+        schema: org_apache_arrow_flatbuf_Schema,
+        arrowSchema: ArrowSchema,
+        data: Data,
+        messageEndOffset: Int64
     ) -> Result<RecordBatch, ArrowError> {
-        let recordBatch = message.header(type: org_apache_arrow_flatbuf_RecordBatch.self)
-        let nodesCount = recordBatch?.nodesCount ?? 0
+        let nodesCount = recordBatch.nodesCount
         var bufferIndex: Int32 = 0
         var columns: [ArrowArrayHolder] = []
         for nodeIndex in 0 ..< nodesCount {
             let field = schema.fields(at: nodeIndex)!
-            let loadInfo = DataLoadInfo(recordBatch: recordBatch!, field: field,
+            let loadInfo = DataLoadInfo(recordBatch: recordBatch, field: field,
                                         nodeIndex: nodeIndex, bufferIndex: bufferIndex,
                                         fileData: data, messageOffset: messageEndOffset)
             var result: Result<ArrowArrayHolder, ArrowError>
@@ -130,7 +131,9 @@ public class ArrowReader {
         return .success(RecordBatch(arrowSchema, columns: columns))
     }
 
-    public func fromStream(_ fileData: Data) -> Result<ArrowReaderResult, ArrowError> {
+    public func fromStream( // swiftlint:disable:this function_body_length
+        _ fileData: Data
+    ) -> Result<ArrowReaderResult, ArrowError> {
         let footerLength = fileData.withUnsafeBytes { rawBuffer in
             rawBuffer.loadUnaligned(fromByteOffset: fileData.count - 4, as: Int32.self)
         }
@@ -172,8 +175,13 @@ public class ArrowReader {
             switch message.headerType {
             case .recordbatch:
                 do {
-                    let recordBatch = try loadRecordBatch(message, schema: footer.schema!, arrowSchema: result.schema!,
-                                                          data: fileData, messageEndOffset: messageEndOffset).get()
+                    let rbMessage = message.header(type: org_apache_arrow_flatbuf_RecordBatch.self)!
+                    let recordBatch = try loadRecordBatch(
+                        rbMessage,
+                        schema: footer.schema!,
+                        arrowSchema: result.schema!,
+                        data: fileData,
+                        messageEndOffset: messageEndOffset).get()
                     result.batches.append(recordBatch)
                 } catch let error as ArrowError {
                     return .failure(error)
@@ -203,4 +211,46 @@ public class ArrowReader {
             return .failure(.unknownError("Error loading file: \(error)"))
         }
     }
+
+    static public func makeArrowReaderResult() -> ArrowReaderResult {
+        return ArrowReaderResult()
+    }
+
+    public func fromMessage(
+        _ dataHeader: Data,
+        dataBody: Data,
+        result: ArrowReaderResult
+    ) -> Result<Void, ArrowError> {
+        let mbb = ByteBuffer(data: dataHeader)
+        let message = org_apache_arrow_flatbuf_Message.getRootAsMessage(bb: mbb)
+        switch message.headerType {
+        case .schema:
+            let sMessage = message.header(type: org_apache_arrow_flatbuf_Schema.self)!
+            switch loadSchema(sMessage) {
+            case .success(let schema):
+                result.schema = schema
+                result.messageSchema = sMessage
+                return .success(())
+            case .failure(let error):
+                return .failure(error)
+            }
+        case .recordbatch:
+            let rbMessage = message.header(type: org_apache_arrow_flatbuf_RecordBatch.self)!
+            do {
+                let recordBatch = try loadRecordBatch(
+                    rbMessage, schema: result.messageSchema!, arrowSchema: result.schema!,
+                    data: dataBody, messageEndOffset: 0).get()
+                result.batches.append(recordBatch)
+                return .success(())
+            } catch let error as ArrowError {
+                return .failure(error)
+            } catch {
+                return .failure(.unknownError("Unexpected error: \(error)"))
+            }
+
+        default:
+            return .failure(.unknownError("Unhandled header type: \(message.headerType)"))
+        }
+    }
+
 }
diff --git a/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift b/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
index 2e5a12c6c08f3..fa52160478f24 100644
--- a/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowReaderHelper.swift
@@ -47,9 +47,9 @@ private func makeFloatHolder(_ floatType: org_apache_arrow_flatbuf_FloatingPoint
 ) -> Result<ArrowArrayHolder, ArrowError> {
     switch floatType.precision {
     case .single:
-        return makeFixedHolder(Float.self, buffers: buffers)
+        return makeFixedHolder(Float.self, buffers: buffers, arrowType: ArrowType.ArrowFloat)
     case .double:
-        return makeFixedHolder(Double.self, buffers: buffers)
+        return makeFixedHolder(Double.self, buffers: buffers, arrowType: ArrowType.ArrowDouble)
     default:
         return .failure(.unknownType("Float precision \(floatType.precision) currently not supported"))
     }
@@ -99,7 +99,7 @@ private func makeTimeHolder(_ timeType: org_apache_arrow_flatbuf_Time,
 
 private func makeBoolHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
     do {
-        let arrowData = try ArrowData(ArrowType(ArrowType.ArrowInt32), buffers: buffers,
+        let arrowData = try ArrowData(ArrowType(ArrowType.ArrowBool), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<UInt8>.stride)
         return .success(ArrowArrayHolder(BoolArray(arrowData)))
     } catch let error as ArrowError {
@@ -109,9 +109,12 @@ private func makeBoolHolder(_ buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder
     }
 }
 
-private func makeFixedHolder<T>(_: T.Type, buffers: [ArrowBuffer]) -> Result<ArrowArrayHolder, ArrowError> {
+private func makeFixedHolder<T>(
+    _: T.Type, buffers: [ArrowBuffer],
+    arrowType: ArrowType.Info
+) -> Result<ArrowArrayHolder, ArrowError> {
     do {
-        let arrowData = try ArrowData(ArrowType(ArrowType.ArrowInt32), buffers: buffers,
+        let arrowData = try ArrowData(ArrowType(arrowType), buffers: buffers,
                                       nullCount: buffers[0].length, stride: MemoryLayout<T>.stride)
         return .success(ArrowArrayHolder(FixedArray<T>(arrowData)))
     } catch let error as ArrowError {
@@ -132,27 +135,27 @@ func makeArrayHolder( // swiftlint:disable:this cyclomatic_complexity
         let bitWidth = intType.bitWidth
         if bitWidth == 8 {
             if intType.isSigned {
-                return makeFixedHolder(Int8.self, buffers: buffers)
+                return makeFixedHolder(Int8.self, buffers: buffers, arrowType: ArrowType.ArrowInt8)
             } else {
-                return makeFixedHolder(UInt8.self, buffers: buffers)
+                return makeFixedHolder(UInt8.self, buffers: buffers, arrowType: ArrowType.ArrowUInt8)
             }
         } else if bitWidth == 16 {
             if intType.isSigned {
-                return makeFixedHolder(Int16.self, buffers: buffers)
+                return makeFixedHolder(Int16.self, buffers: buffers, arrowType: ArrowType.ArrowInt16)
             } else {
-                return makeFixedHolder(UInt16.self, buffers: buffers)
+                return makeFixedHolder(UInt16.self, buffers: buffers, arrowType: ArrowType.ArrowUInt16)
             }
         } else if bitWidth == 32 {
             if intType.isSigned {
-                return makeFixedHolder(Int32.self, buffers: buffers)
+                return makeFixedHolder(Int32.self, buffers: buffers, arrowType: ArrowType.ArrowInt32)
             } else {
-                return makeFixedHolder(UInt32.self, buffers: buffers)
+                return makeFixedHolder(UInt32.self, buffers: buffers, arrowType: ArrowType.ArrowUInt32)
             }
         } else if bitWidth == 64 {
             if intType.isSigned {
-                return makeFixedHolder(Int64.self, buffers: buffers)
+                return makeFixedHolder(Int64.self, buffers: buffers, arrowType: ArrowType.ArrowInt64)
             } else {
-                return makeFixedHolder(UInt64.self, buffers: buffers)
+                return makeFixedHolder(UInt64.self, buffers: buffers, arrowType: ArrowType.ArrowUInt64)
             }
         }
         return .failure(.unknownType("Int width \(bitWidth) currently not supported"))
diff --git a/swift/Arrow/Sources/Arrow/ArrowType.swift b/swift/Arrow/Sources/Arrow/ArrowType.swift
index e1c1ef271cc0f..e63647d0797ee 100644
--- a/swift/Arrow/Sources/Arrow/ArrowType.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowType.swift
@@ -123,6 +123,17 @@ public class ArrowType {
         self.info = info
     }
 
+    public var id: ArrowTypeId {
+        switch self.info {
+        case .primitiveInfo(let id):
+            return id
+        case .timeInfo(let id):
+            return id
+        case .variableInfo(let id):
+            return id
+        }
+    }
+
     public enum Info {
         case primitiveInfo(ArrowTypeId)
         case variableInfo(ArrowTypeId)
diff --git a/swift/Arrow/Sources/Arrow/ArrowWriter.swift b/swift/Arrow/Sources/Arrow/ArrowWriter.swift
index efd0b9d3000dc..eec4c85827628 100644
--- a/swift/Arrow/Sources/Arrow/ArrowWriter.swift
+++ b/swift/Arrow/Sources/Arrow/ArrowWriter.swift
@@ -23,7 +23,7 @@ public protocol DataWriter {
     func append(_ data: Data)
 }
 
-public class ArrowWriter {
+public class ArrowWriter { // swiftlint:disable:this type_body_length
     public class InMemDataWriter: DataWriter {
         public private(set) var data: Data
         public var count: Int { return data.count }
@@ -110,12 +110,15 @@ public class ArrowWriter {
                                                          endianness: .little,
                                                          fieldsVectorOffset: fieldsOffset)
         return .success(schemaOffset)
+
     }
 
-    private func writeRecordBatches(_ writer: inout DataWriter,
-                                    batches: [RecordBatch]
+    private func writeRecordBatches(
+        _ writer: inout DataWriter,
+        batches: [RecordBatch]
     ) -> Result<[org_apache_arrow_flatbuf_Block], ArrowError> {
         var rbBlocks = [org_apache_arrow_flatbuf_Block]()
+
         for batch in batches {
             let startIndex = writer.count
             switch writeRecordBatch(batch: batch) {
@@ -141,7 +144,6 @@ public class ArrowWriter {
 
     private func writeRecordBatch(batch: RecordBatch) -> Result<(Data, Offset), ArrowError> {
         let schema = batch.schema
-        var output = Data()
         var fbb = FlatBufferBuilder()
 
         // write out field nodes
@@ -156,6 +158,7 @@ public class ArrowWriter {
         }
 
         let nodeOffset = fbb.endVector(len: schema.fields.count)
+
         // write out buffers
         var buffers = [org_apache_arrow_flatbuf_Buffer]()
         var bufferOffset = Int(0)
@@ -179,16 +182,17 @@ public class ArrowWriter {
         let startRb = org_apache_arrow_flatbuf_RecordBatch.startRecordBatch(&fbb)
         org_apache_arrow_flatbuf_RecordBatch.addVectorOf(nodes: nodeOffset, &fbb)
         org_apache_arrow_flatbuf_RecordBatch.addVectorOf(buffers: batchBuffersOffset, &fbb)
+        org_apache_arrow_flatbuf_RecordBatch.add(length: Int64(batch.length), &fbb)
         let recordBatchOffset = org_apache_arrow_flatbuf_RecordBatch.endRecordBatch(&fbb, start: startRb)
         let bodySize = Int64(bufferOffset)
         let startMessage = org_apache_arrow_flatbuf_Message.startMessage(&fbb)
+        org_apache_arrow_flatbuf_Message.add(version: .max, &fbb)
         org_apache_arrow_flatbuf_Message.add(bodyLength: Int64(bodySize), &fbb)
         org_apache_arrow_flatbuf_Message.add(headerType: .recordbatch, &fbb)
         org_apache_arrow_flatbuf_Message.add(header: recordBatchOffset, &fbb)
         let messageOffset = org_apache_arrow_flatbuf_Message.endMessage(&fbb, start: startMessage)
         fbb.finish(offset: messageOffset)
-        output.append(fbb.data)
-        return .success((output, Offset(offset: UInt32(output.count))))
+        return .success((fbb.data, Offset(offset: UInt32(fbb.data.count))))
     }
 
     private func writeRecordBatchData(_ writer: inout DataWriter, batch: RecordBatch) -> Result<Bool, ArrowError> {
@@ -298,4 +302,45 @@ public class ArrowWriter {
 
         return .success(true)
     }
+
+    public func toMessage(_ batch: RecordBatch) -> Result<[Data], ArrowError> {
+        var writer: any DataWriter = InMemDataWriter()
+        switch writeRecordBatch(batch: batch) {
+        case .success(let message):
+            writer.append(message.0)
+            addPadForAlignment(&writer)
+            var dataWriter: any DataWriter = InMemDataWriter()
+            switch writeRecordBatchData(&dataWriter, batch: batch) {
+            case .success:
+                return .success([
+                    (writer as! InMemDataWriter).data, // swiftlint:disable:this force_cast
+                    (dataWriter as! InMemDataWriter).data // swiftlint:disable:this force_cast
+                ])
+            case .failure(let error):
+                return .failure(error)
+            }
+        case .failure(let error):
+            return .failure(error)
+        }
+    }
+
+    public func toMessage(_ schema: ArrowSchema) -> Result<Data, ArrowError> {
+        var schemaSize: Int32 = 0
+        var fbb = FlatBufferBuilder()
+        switch writeSchema(&fbb, schema: schema) {
+        case .success(let schemaOffset):
+            schemaSize = Int32(schemaOffset.o)
+        case .failure(let error):
+            return .failure(error)
+        }
+
+        let startMessage = org_apache_arrow_flatbuf_Message.startMessage(&fbb)
+        org_apache_arrow_flatbuf_Message.add(bodyLength: Int64(0), &fbb)
+        org_apache_arrow_flatbuf_Message.add(headerType: .schema, &fbb)
+        org_apache_arrow_flatbuf_Message.add(header: Offset(offset: UOffset(schemaSize)), &fbb)
+        org_apache_arrow_flatbuf_Message.add(version: .max, &fbb)
+        let messageOffset = org_apache_arrow_flatbuf_Message.endMessage(&fbb, start: startMessage)
+        fbb.finish(offset: messageOffset)
+        return .success(fbb.data)
+    }
 }
diff --git a/swift/Arrow/Tests/ArrowTests/TableTests.swift b/swift/Arrow/Tests/ArrowTests/TableTests.swift
index 1c6b2d9c0a05c..a82a07979345c 100644
--- a/swift/Arrow/Tests/ArrowTests/TableTests.swift
+++ b/swift/Arrow/Tests/ArrowTests/TableTests.swift
@@ -34,9 +34,9 @@ final class TableTests: XCTestCase {
     }
 
     func testTable() throws {
-        let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
-        uint8Builder.append(10)
-        uint8Builder.append(22)
+        let doubleBuilder: NumberArrayBuilder<Double> = try ArrowArrayBuilders.loadNumberArrayBuilder()
+        doubleBuilder.append(11.11)
+        doubleBuilder.append(22.22)
         let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
         stringBuilder.append("test10")
         stringBuilder.append("test22")
@@ -46,14 +46,14 @@ final class TableTests: XCTestCase {
         date32Builder.append(date1)
         date32Builder.append(date2)
         let table = try ArrowTable.Builder()
-            .addColumn("col1", arrowArray: uint8Builder.finish())
+            .addColumn("col1", arrowArray: doubleBuilder.finish())
             .addColumn("col2", arrowArray: stringBuilder.finish())
             .addColumn("col3", arrowArray: date32Builder.finish())
             .finish()
         let schema = table.schema
         XCTAssertEqual(schema.fields.count, 3)
         XCTAssertEqual(schema.fields[0].name, "col1")
-        XCTAssertEqual(schema.fields[0].type.info, ArrowType.ArrowUInt8)
+        XCTAssertEqual(schema.fields[0].type.info, ArrowType.ArrowDouble)
         XCTAssertEqual(schema.fields[0].isNullable, false)
         XCTAssertEqual(schema.fields[1].name, "col2")
         XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
@@ -62,12 +62,14 @@ final class TableTests: XCTestCase {
         XCTAssertEqual(schema.fields[1].type.info, ArrowType.ArrowString)
         XCTAssertEqual(schema.fields[1].isNullable, false)
         XCTAssertEqual(table.columns.count, 3)
-        let col1: ChunkedArray<UInt8> = table.columns[0].data()
+        let col1: ChunkedArray<Double> = table.columns[0].data()
         let col2: ChunkedArray<String> = table.columns[1].data()
         let col3: ChunkedArray<Date> = table.columns[2].data()
         XCTAssertEqual(col1.length, 2)
         XCTAssertEqual(col2.length, 2)
         XCTAssertEqual(col3.length, 2)
+        XCTAssertEqual(col1[0], 11.11)
+        XCTAssertEqual(col2[1], "test22")
     }
 
     func testTableWithChunkedData() throws {
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
index c9d30f9caf480..ca505869ec774 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightClient.swift
@@ -28,6 +28,54 @@ public class FlightClient {
         client = Arrow_Flight_Protocol_FlightServiceAsyncClient(channel: channel)
     }
 
+    private func readMessages(
+        _ responseStream: GRPCAsyncResponseStream<Arrow_Flight_Protocol_FlightData>
+    ) async throws -> ArrowReader.ArrowReaderResult {
+        let reader = ArrowReader()
+        let arrowResult = ArrowReader.makeArrowReaderResult()
+        for try await data in responseStream {
+            switch reader.fromMessage(data.dataHeader, dataBody: data.dataBody, result: arrowResult) {
+            case .success:
+                continue
+            case .failure(let error):
+                throw error
+            }
+        }
+
+        return arrowResult
+    }
+
+    private func writeBatches(
+        _ requestStream: GRPCAsyncRequestStreamWriter<Arrow_Flight_Protocol_FlightData>,
+        descriptor: FlightDescriptor,
+        recordBatchs: [RecordBatch]
+    ) async throws {
+        let writer = ArrowWriter()
+        switch writer.toMessage(recordBatchs[0].schema) {
+        case .success(let schemaData):
+            try await requestStream.send(
+                FlightData(
+                    schemaData,
+                    dataBody: Data(),
+                    flightDescriptor: descriptor).toProtocol())
+            for recordBatch in recordBatchs {
+                switch writer.toMessage(recordBatch) {
+                case .success(let data):
+                    try await requestStream.send(
+                        FlightData(
+                            data[0],
+                            dataBody: data[1],
+                            flightDescriptor: descriptor).toProtocol())
+                case .failure(let error):
+                    throw error
+                }
+            }
+            requestStream.finish()
+        case .failure(let error):
+            throw error
+        }
+    }
+
     public func listActions(_ closure: (FlightActionType) -> Void) async throws {
         let listActions = client.makeListActionsCall(Arrow_Flight_Protocol_Empty())
         for try await data in listActions.responseStream {
@@ -35,7 +83,9 @@ public class FlightClient {
         }
     }
 
-    public func listFlights(_ criteria: FlightCriteria, closure: (FlightInfo) throws -> Void) async throws {
+    public func listFlights(
+        _ criteria: FlightCriteria,
+        closure: (FlightInfo) throws -> Void) async throws {
         let listFlights = client.makeListFlightsCall(criteria.toProtocol())
         for try await data in listFlights.responseStream {
             try closure(FlightInfo(data))
@@ -58,82 +108,65 @@ public class FlightClient {
         _ ticket: FlightTicket,
         readerResultClosure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
         let getResult = client.makeDoGetCall(ticket.toProtocol())
-        let reader = ArrowReader()
-        for try await data in getResult.responseStream {
-            switch reader.fromStream(data.dataBody) {
-            case .success(let rb):
-                try readerResultClosure(rb)
-            case .failure(let error):
-                throw error
-            }
-        }
+        try readerResultClosure(try await readMessages(getResult.responseStream))
     }
 
-    public func doGet(_ ticket: FlightTicket, flightDataClosure: (FlightData) throws -> Void) async throws {
+    public func doGet(
+        _ ticket: FlightTicket,
+        flightDataClosure: (FlightData) throws -> Void) async throws {
         let getResult = client.makeDoGetCall(ticket.toProtocol())
         for try await data in getResult.responseStream {
             try flightDataClosure(FlightData(data))
         }
     }
 
-    public func doPut(_ recordBatchs: [RecordBatch], closure: (FlightPutResult) throws -> Void) async throws {
+    public func doPut(
+        _ descriptor: FlightDescriptor,
+        recordBatchs: [RecordBatch],
+        closure: (FlightPutResult) throws -> Void) async throws {
         if recordBatchs.isEmpty {
             throw ArrowFlightError.emptyCollection
         }
 
         let putCall = client.makeDoPutCall()
-        let writer = ArrowWriter()
-        let writerInfo = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
-        switch writer.toStream(writerInfo) {
-        case .success(let data):
-            try await putCall.requestStream.send(FlightData(data).toProtocol())
-            putCall.requestStream.finish()
-            for try await response in putCall.responseStream {
-                try closure(FlightPutResult(response))
-            }
-        case .failure(let error):
-            throw error
+        try await writeBatches(putCall.requestStream, descriptor: descriptor, recordBatchs: recordBatchs)
+        var closureCalled = false
+        for try await response in putCall.responseStream {
+            try closure(FlightPutResult(response))
+            closureCalled = true
+        }
+
+        if !closureCalled {
+            try closure(FlightPutResult())
         }
     }
 
-    public func doPut(flightData: FlightData, closure: (FlightPutResult) throws -> Void) async throws {
+    public func doPut(_ flightData: FlightData, closure: (FlightPutResult) throws -> Void) async throws {
         let putCall = client.makeDoPutCall()
         try await putCall.requestStream.send(flightData.toProtocol())
         putCall.requestStream.finish()
+        var closureCalled = false
         for try await response in putCall.responseStream {
             try closure(FlightPutResult(response))
+            closureCalled = true
+        }
+
+        if !closureCalled {
+            try closure(FlightPutResult())
         }
     }
 
     public func doExchange(
-        _ recordBatchs: [RecordBatch],
+        _ descriptor: FlightDescriptor,
+        recordBatchs: [RecordBatch],
         closure: (ArrowReader.ArrowReaderResult) throws -> Void) async throws {
         if recordBatchs.isEmpty {
             throw ArrowFlightError.emptyCollection
         }
 
         let exchangeCall = client.makeDoExchangeCall()
-        let writer = ArrowWriter()
-        let info = ArrowWriter.Info(.recordbatch, schema: recordBatchs[0].schema, batches: recordBatchs)
-        switch writer.toStream(info) {
-        case .success(let data):
-            let request = Arrow_Flight_Protocol_FlightData.with {
-                $0.dataBody = data
-            }
-            try await exchangeCall.requestStream.send(request)
-            exchangeCall.requestStream.finish()
-            let reader = ArrowReader()
-            for try await response in exchangeCall.responseStream {
-                switch reader.fromStream(response.dataBody) {
-                case .success(let rbResult):
-                    try closure(rbResult)
-                case .failure(let error):
-                    throw error
-                }
-            }
-        case .failure(let error):
-            throw error
-        }
+        try await writeBatches(exchangeCall.requestStream, descriptor: descriptor, recordBatchs: recordBatchs)
+        try closure(try await readMessages(exchangeCall.responseStream))
     }
 
     public func doExchange(fligthData: FlightData, closure: (FlightData) throws -> Void) async throws {
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
index fa853baab3b92..84db8c571833e 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightData.swift
@@ -23,15 +23,18 @@ public class FlightData {
         return flightData.hasFlightDescriptor ? FlightDescriptor(flightData.flightDescriptor) : nil
     }
 
+    public var dataHeader: Data { flightData.dataHeader }
+
     public var dataBody: Data { flightData.dataBody }
 
     init(_ flightData: Arrow_Flight_Protocol_FlightData) {
         self.flightData = flightData
     }
 
-    public init(_ dataBody: Data, flightDescriptor: FlightDescriptor? = nil) {
+    public init(_ dataHeader: Data, dataBody: Data, flightDescriptor: FlightDescriptor? = nil) {
         if flightDescriptor != nil {
             self.flightData = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataHeader = dataHeader
                 $0.dataBody = dataBody
                 $0.flightDescriptor = flightDescriptor!.toProtocol()
             }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
index e59c0bcc6d997..eb43aa34caf1b 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightInfo.swift
@@ -27,7 +27,9 @@ public class FlightInfo {
     public var endpoints: [FlightEndpoint] {
         return self.flightInfo.endpoint.map { FlightEndpoint($0) }
     }
-    public var schema: Data { flightInfo.schema }
+    public var schema: ArrowSchema? {
+        return schemaFromMessage(self.flightInfo.schema)
+    }
 
     var endpoint: [Arrow_Flight_Protocol_FlightEndpoint] = []
     init(_ flightInfo: Arrow_Flight_Protocol_FlightInfo) {
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
index fcb4b50c1aa91..7dea98a998858 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightSchemaResult.swift
@@ -16,11 +16,15 @@
 // under the License.
 
 import Foundation
+import Arrow
 
 public class FlightSchemaResult {
     let schemaResult: Arrow_Flight_Protocol_SchemaResult
 
-    public var schema: Data { schemaResult.schema }
+    public var schema: ArrowSchema? {
+        return schemaFromMessage(self.schemaResult.schema)
+    }
+
     public init(_ schema: Data) {
         self.schemaResult = Arrow_Flight_Protocol_SchemaResult.with {
             $0.schema = schema
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
index 58280a0049f4b..a34bf5c0acee9 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightServer.swift
@@ -29,27 +29,36 @@ public enum ArrowFlightError: Error {
     case ioError(String? = nil)
 }
 
-public func schemaToArrowStream(_ schema: ArrowSchema) throws -> Data {
+public func schemaToMessage(_ schema: ArrowSchema) throws -> Data {
     let arrowWriter = ArrowWriter()
-    switch arrowWriter.toStream(ArrowWriter.Info(.schema, schema: schema)) {
+    switch arrowWriter.toMessage(schema) {
     case .success(let result):
-        return result
+        var outputResult = Data()
+        withUnsafeBytes(of: Int32(0).littleEndian) {outputResult.append(Data($0))}
+        withUnsafeBytes(of: Int32(result.count).littleEndian) {outputResult.append(Data($0))}
+        outputResult.append(result)
+        return outputResult
     case .failure(let error):
         throw error
     }
 }
 
-public func streamToArrowSchema(_ schema: Data) throws -> ArrowSchema {
-    let schemaResult = ArrowReader().fromStream(schema)
-    switch schemaResult {
-    case .success(let result):
-        if let retSchema = result.schema {
-            return retSchema
-        }
+public func schemaFromMessage(_ schemaData: Data) -> ArrowSchema? {
+    let messageLength = schemaData.withUnsafeBytes { rawBuffer in
+        rawBuffer.loadUnaligned(fromByteOffset: 4, as: Int32.self)
+    }
 
-        throw ArrowFlightError.ioError("Schema not found")
-    case .failure(let error):
-        throw error
+    let startIndex = schemaData.count - Int(messageLength)
+    let schema = schemaData[startIndex...]
+
+    let reader = ArrowReader()
+    let result = ArrowReader.makeArrowReaderResult()
+    switch reader.fromMessage(schema, dataBody: Data(), result: result) {
+    case .success:
+        return result.schema!
+    case .failure:
+        // TODO: add handling of error swiftlint:disable:this todo
+        return nil
     }
 }
 
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/FlightSql.pb.swift b/swift/ArrowFlight/Sources/ArrowFlight/FlightSql.pb.swift
new file mode 100644
index 0000000000000..238092266904b
--- /dev/null
+++ b/swift/ArrowFlight/Sources/ArrowFlight/FlightSql.pb.swift
@@ -0,0 +1,5145 @@
+// DO NOT EDIT.
+// swift-format-ignore-file
+//
+// Generated by the Swift generator plugin for the protocol buffer compiler.
+// Source: FlightSql.proto
+//
+// For information on using the generated types, please see the documentation:
+//   https://github.com/apple/swift-protobuf/
+
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// <p>
+// http://www.apache.org/licenses/LICENSE-2.0
+// <p>
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT 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 Foundation
+import SwiftProtobuf
+
+// If the compiler emits an error on this type, it is because this file
+// was generated by a version of the `protoc` Swift plug-in that is
+// incompatible with the version of SwiftProtobuf to which you are linking.
+// Please ensure that you are building against the same version of the API
+// that was used to generate this file.
+fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
+  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
+  typealias Version = _2
+}
+
+/// Options for CommandGetSqlInfo.
+enum Arrow_Flight_Protocol_Sql_SqlInfo: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+
+  /// Retrieves a UTF-8 string with the name of the Flight SQL Server.
+  case flightSqlServerName // = 0
+
+  /// Retrieves a UTF-8 string with the native version of the Flight SQL Server.
+  case flightSqlServerVersion // = 1
+
+  /// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
+  case flightSqlServerArrowVersion // = 2
+
+  ///
+  /// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
+  ///
+  /// Returns:
+  /// - false: if read-write
+  /// - true: if read only
+  case flightSqlServerReadOnly // = 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.
+  case flightSqlServerSql // = 4
+
+  ///
+  /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+  /// Substrait plans.
+  case flightSqlServerSubstrait // = 5
+
+  ///
+  /// Retrieves a string value indicating the minimum supported Substrait version, or null
+  /// if Substrait is not supported.
+  case flightSqlServerSubstraitMinVersion // = 6
+
+  ///
+  /// Retrieves a string value indicating the maximum supported Substrait version, or null
+  /// if Substrait is not supported.
+  case 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`.
+  case flightSqlServerTransaction // = 8
+
+  ///
+  /// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
+  /// query cancellation (the CancelQuery action).
+  case 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.
+  case flightSqlServerStatementTimeout // = 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.
+  case 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.
+  case sqlDdlCatalog // = 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.
+  case sqlDdlSchema // = 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.
+  case sqlDdlTable // = 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`.
+  case sqlIdentifierCase // = 503
+
+  /// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
+  case sqlIdentifierQuoteChar // = 504
+
+  ///
+  /// Retrieves a int32 describing the case sensitivity of quoted identifiers.
+  ///
+  /// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+  case sqlQuotedIdentifierCase // = 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.
+  case sqlAllTablesAreSelectable // = 506
+
+  ///
+  /// Retrieves the null ordering.
+  ///
+  /// Returns a int32 ordinal for the null ordering being used, as described in
+  /// `arrow.flight.protocol.sql.SqlNullOrdering`.
+  case sqlNullOrdering // = 507
+
+  /// Retrieves a UTF-8 string list with values of the supported keywords.
+  case sqlKeywords // = 508
+
+  /// Retrieves a UTF-8 string list with values of the supported numeric functions.
+  case sqlNumericFunctions // = 509
+
+  /// Retrieves a UTF-8 string list with values of the supported string functions.
+  case sqlStringFunctions // = 510
+
+  /// Retrieves a UTF-8 string list with values of the supported system functions.
+  case sqlSystemFunctions // = 511
+
+  /// Retrieves a UTF-8 string list with values of the supported datetime functions.
+  case 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.
+  case 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 _).
+  case 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.
+  ///
+  /// Returns:
+  /// - false: if column aliasing is unsupported;
+  /// - true: if column aliasing is supported.
+  case sqlSupportsColumnAliasing // = 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.
+  case 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>>
+  case 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.
+  ///
+  /// Returns:
+  /// - false: if table correlation names are unsupported;
+  /// - true: if table correlation names are supported.
+  case 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.
+  ///
+  /// Returns:
+  /// - false: if different table correlation names are unsupported;
+  /// - true: if different table correlation names are supported
+  case sqlSupportsDifferentTableCorrelationNames // = 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;
+  case 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.
+  ///
+  /// 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.
+  case sqlSupportsOrderByUnrelated // = 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`.
+  case sqlSupportedGroupBy // = 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.
+  case sqlSupportsLikeEscapeClause // = 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.
+  case 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`.
+  case 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`.
+  case sqlAnsi92SupportedLevel // = 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.
+  case sqlSupportsIntegrityEnhancementFacility // = 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`.
+  case sqlOuterJoinsSupportLevel // = 528
+
+  /// Retrieves a UTF-8 string with the preferred term for "schema".
+  case sqlSchemaTerm // = 529
+
+  /// Retrieves a UTF-8 string with the preferred term for "procedure".
+  case sqlProcedureTerm // = 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.
+  case sqlCatalogTerm // = 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.
+  case 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`.
+  case 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`.
+  case sqlCatalogsSupportedActions // = 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`.
+  case sqlSupportedPositionedCommands // = 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.
+  case sqlSelectForUpdateSupported // = 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.
+  case 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`.
+  case sqlSupportedSubqueries // = 538
+
+  ///
+  /// Retrieves a boolean value indicating whether correlated subqueries are supported.
+  ///
+  /// Returns:
+  /// - false: if correlated subqueries are unsupported;
+  /// - true: if correlated subqueries are supported.
+  case sqlCorrelatedSubqueriesSupported // = 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`.
+  case sqlSupportedUnions // = 540
+
+  /// Retrieves a int64 value representing the maximum number of hex characters allowed in an inline binary literal.
+  case sqlMaxBinaryLiteralLength // = 541
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed for a character literal.
+  case sqlMaxCharLiteralLength // = 542
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed for a column name.
+  case sqlMaxColumnNameLength // = 543
+
+  /// Retrieves a int64 value representing the the maximum number of columns allowed in a GROUP BY clause.
+  case sqlMaxColumnsInGroupBy // = 544
+
+  /// Retrieves a int64 value representing the maximum number of columns allowed in an index.
+  case sqlMaxColumnsInIndex // = 545
+
+  /// Retrieves a int64 value representing the maximum number of columns allowed in an ORDER BY clause.
+  case sqlMaxColumnsInOrderBy // = 546
+
+  /// Retrieves a int64 value representing the maximum number of columns allowed in a SELECT list.
+  case sqlMaxColumnsInSelect // = 547
+
+  /// Retrieves a int64 value representing the maximum number of columns allowed in a table.
+  case sqlMaxColumnsInTable // = 548
+
+  /// Retrieves a int64 value representing the maximum number of concurrent connections possible.
+  case sqlMaxConnections // = 549
+
+  /// Retrieves a int64 value the maximum number of characters allowed in a cursor name.
+  case sqlMaxCursorNameLength // = 550
+
+  ///
+  /// Retrieves a int64 value representing the maximum number of bytes allowed for an index,
+  /// including all of the parts of the index.
+  case sqlMaxIndexLength // = 551
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed in a schema name.
+  case sqlDbSchemaNameLength // = 552
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed in a procedure name.
+  case sqlMaxProcedureNameLength // = 553
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed in a catalog name.
+  case sqlMaxCatalogNameLength // = 554
+
+  /// Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
+  case sqlMaxRowSize // = 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.
+  case sqlMaxRowSizeIncludesBlobs // = 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.
+  case sqlMaxStatementLength // = 557
+
+  /// Retrieves a int64 value representing the maximum number of active statements that can be open at the same time.
+  case sqlMaxStatements // = 558
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed in a table name.
+  case sqlMaxTableNameLength // = 559
+
+  /// Retrieves a int64 value representing the maximum number of tables allowed in a SELECT statement.
+  case sqlMaxTablesInSelect // = 560
+
+  /// Retrieves a int64 value representing the maximum number of characters allowed in a user name.
+  case sqlMaxUsernameLength // = 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.
+  case 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`.
+  ///
+  /// Returns:
+  /// - false: if transactions are unsupported;
+  /// - true: if transactions are supported.
+  case 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`.
+  case sqlSupportedTransactionsIsolationLevels // = 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.
+  case sqlDataDefinitionCausesTransactionCommit // = 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.
+  case 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`.
+  case 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`.
+  case 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`.
+  case 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`.
+  case 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`.
+  case sqlSupportedConcurrenciesForResultSetScrollInsensitive // = 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.
+  case sqlBatchUpdatesSupported // = 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.
+  case sqlSavepointsSupported // = 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.
+  case sqlNamedParametersSupported // = 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.
+  case sqlLocatorsUpdateCopy // = 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.
+  case sqlStoredFunctionsUsingCallSyntaxSupported // = 576
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .flightSqlServerName
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .flightSqlServerName
+    case 1: self = .flightSqlServerVersion
+    case 2: self = .flightSqlServerArrowVersion
+    case 3: self = .flightSqlServerReadOnly
+    case 4: self = .flightSqlServerSql
+    case 5: self = .flightSqlServerSubstrait
+    case 6: self = .flightSqlServerSubstraitMinVersion
+    case 7: self = .flightSqlServerSubstraitMaxVersion
+    case 8: self = .flightSqlServerTransaction
+    case 9: self = .flightSqlServerCancel
+    case 100: self = .flightSqlServerStatementTimeout
+    case 101: self = .flightSqlServerTransactionTimeout
+    case 500: self = .sqlDdlCatalog
+    case 501: self = .sqlDdlSchema
+    case 502: self = .sqlDdlTable
+    case 503: self = .sqlIdentifierCase
+    case 504: self = .sqlIdentifierQuoteChar
+    case 505: self = .sqlQuotedIdentifierCase
+    case 506: self = .sqlAllTablesAreSelectable
+    case 507: self = .sqlNullOrdering
+    case 508: self = .sqlKeywords
+    case 509: self = .sqlNumericFunctions
+    case 510: self = .sqlStringFunctions
+    case 511: self = .sqlSystemFunctions
+    case 512: self = .sqlDatetimeFunctions
+    case 513: self = .sqlSearchStringEscape
+    case 514: self = .sqlExtraNameCharacters
+    case 515: self = .sqlSupportsColumnAliasing
+    case 516: self = .sqlNullPlusNullIsNull
+    case 517: self = .sqlSupportsConvert
+    case 518: self = .sqlSupportsTableCorrelationNames
+    case 519: self = .sqlSupportsDifferentTableCorrelationNames
+    case 520: self = .sqlSupportsExpressionsInOrderBy
+    case 521: self = .sqlSupportsOrderByUnrelated
+    case 522: self = .sqlSupportedGroupBy
+    case 523: self = .sqlSupportsLikeEscapeClause
+    case 524: self = .sqlSupportsNonNullableColumns
+    case 525: self = .sqlSupportedGrammar
+    case 526: self = .sqlAnsi92SupportedLevel
+    case 527: self = .sqlSupportsIntegrityEnhancementFacility
+    case 528: self = .sqlOuterJoinsSupportLevel
+    case 529: self = .sqlSchemaTerm
+    case 530: self = .sqlProcedureTerm
+    case 531: self = .sqlCatalogTerm
+    case 532: self = .sqlCatalogAtStart
+    case 533: self = .sqlSchemasSupportedActions
+    case 534: self = .sqlCatalogsSupportedActions
+    case 535: self = .sqlSupportedPositionedCommands
+    case 536: self = .sqlSelectForUpdateSupported
+    case 537: self = .sqlStoredProceduresSupported
+    case 538: self = .sqlSupportedSubqueries
+    case 539: self = .sqlCorrelatedSubqueriesSupported
+    case 540: self = .sqlSupportedUnions
+    case 541: self = .sqlMaxBinaryLiteralLength
+    case 542: self = .sqlMaxCharLiteralLength
+    case 543: self = .sqlMaxColumnNameLength
+    case 544: self = .sqlMaxColumnsInGroupBy
+    case 545: self = .sqlMaxColumnsInIndex
+    case 546: self = .sqlMaxColumnsInOrderBy
+    case 547: self = .sqlMaxColumnsInSelect
+    case 548: self = .sqlMaxColumnsInTable
+    case 549: self = .sqlMaxConnections
+    case 550: self = .sqlMaxCursorNameLength
+    case 551: self = .sqlMaxIndexLength
+    case 552: self = .sqlDbSchemaNameLength
+    case 553: self = .sqlMaxProcedureNameLength
+    case 554: self = .sqlMaxCatalogNameLength
+    case 555: self = .sqlMaxRowSize
+    case 556: self = .sqlMaxRowSizeIncludesBlobs
+    case 557: self = .sqlMaxStatementLength
+    case 558: self = .sqlMaxStatements
+    case 559: self = .sqlMaxTableNameLength
+    case 560: self = .sqlMaxTablesInSelect
+    case 561: self = .sqlMaxUsernameLength
+    case 562: self = .sqlDefaultTransactionIsolation
+    case 563: self = .sqlTransactionsSupported
+    case 564: self = .sqlSupportedTransactionsIsolationLevels
+    case 565: self = .sqlDataDefinitionCausesTransactionCommit
+    case 566: self = .sqlDataDefinitionsInTransactionsIgnored
+    case 567: self = .sqlSupportedResultSetTypes
+    case 568: self = .sqlSupportedConcurrenciesForResultSetUnspecified
+    case 569: self = .sqlSupportedConcurrenciesForResultSetForwardOnly
+    case 570: self = .sqlSupportedConcurrenciesForResultSetScrollSensitive
+    case 571: self = .sqlSupportedConcurrenciesForResultSetScrollInsensitive
+    case 572: self = .sqlBatchUpdatesSupported
+    case 573: self = .sqlSavepointsSupported
+    case 574: self = .sqlNamedParametersSupported
+    case 575: self = .sqlLocatorsUpdateCopy
+    case 576: self = .sqlStoredFunctionsUsingCallSyntaxSupported
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .flightSqlServerName: return 0
+    case .flightSqlServerVersion: return 1
+    case .flightSqlServerArrowVersion: return 2
+    case .flightSqlServerReadOnly: return 3
+    case .flightSqlServerSql: return 4
+    case .flightSqlServerSubstrait: return 5
+    case .flightSqlServerSubstraitMinVersion: return 6
+    case .flightSqlServerSubstraitMaxVersion: return 7
+    case .flightSqlServerTransaction: return 8
+    case .flightSqlServerCancel: return 9
+    case .flightSqlServerStatementTimeout: return 100
+    case .flightSqlServerTransactionTimeout: return 101
+    case .sqlDdlCatalog: return 500
+    case .sqlDdlSchema: return 501
+    case .sqlDdlTable: return 502
+    case .sqlIdentifierCase: return 503
+    case .sqlIdentifierQuoteChar: return 504
+    case .sqlQuotedIdentifierCase: return 505
+    case .sqlAllTablesAreSelectable: return 506
+    case .sqlNullOrdering: return 507
+    case .sqlKeywords: return 508
+    case .sqlNumericFunctions: return 509
+    case .sqlStringFunctions: return 510
+    case .sqlSystemFunctions: return 511
+    case .sqlDatetimeFunctions: return 512
+    case .sqlSearchStringEscape: return 513
+    case .sqlExtraNameCharacters: return 514
+    case .sqlSupportsColumnAliasing: return 515
+    case .sqlNullPlusNullIsNull: return 516
+    case .sqlSupportsConvert: return 517
+    case .sqlSupportsTableCorrelationNames: return 518
+    case .sqlSupportsDifferentTableCorrelationNames: return 519
+    case .sqlSupportsExpressionsInOrderBy: return 520
+    case .sqlSupportsOrderByUnrelated: return 521
+    case .sqlSupportedGroupBy: return 522
+    case .sqlSupportsLikeEscapeClause: return 523
+    case .sqlSupportsNonNullableColumns: return 524
+    case .sqlSupportedGrammar: return 525
+    case .sqlAnsi92SupportedLevel: return 526
+    case .sqlSupportsIntegrityEnhancementFacility: return 527
+    case .sqlOuterJoinsSupportLevel: return 528
+    case .sqlSchemaTerm: return 529
+    case .sqlProcedureTerm: return 530
+    case .sqlCatalogTerm: return 531
+    case .sqlCatalogAtStart: return 532
+    case .sqlSchemasSupportedActions: return 533
+    case .sqlCatalogsSupportedActions: return 534
+    case .sqlSupportedPositionedCommands: return 535
+    case .sqlSelectForUpdateSupported: return 536
+    case .sqlStoredProceduresSupported: return 537
+    case .sqlSupportedSubqueries: return 538
+    case .sqlCorrelatedSubqueriesSupported: return 539
+    case .sqlSupportedUnions: return 540
+    case .sqlMaxBinaryLiteralLength: return 541
+    case .sqlMaxCharLiteralLength: return 542
+    case .sqlMaxColumnNameLength: return 543
+    case .sqlMaxColumnsInGroupBy: return 544
+    case .sqlMaxColumnsInIndex: return 545
+    case .sqlMaxColumnsInOrderBy: return 546
+    case .sqlMaxColumnsInSelect: return 547
+    case .sqlMaxColumnsInTable: return 548
+    case .sqlMaxConnections: return 549
+    case .sqlMaxCursorNameLength: return 550
+    case .sqlMaxIndexLength: return 551
+    case .sqlDbSchemaNameLength: return 552
+    case .sqlMaxProcedureNameLength: return 553
+    case .sqlMaxCatalogNameLength: return 554
+    case .sqlMaxRowSize: return 555
+    case .sqlMaxRowSizeIncludesBlobs: return 556
+    case .sqlMaxStatementLength: return 557
+    case .sqlMaxStatements: return 558
+    case .sqlMaxTableNameLength: return 559
+    case .sqlMaxTablesInSelect: return 560
+    case .sqlMaxUsernameLength: return 561
+    case .sqlDefaultTransactionIsolation: return 562
+    case .sqlTransactionsSupported: return 563
+    case .sqlSupportedTransactionsIsolationLevels: return 564
+    case .sqlDataDefinitionCausesTransactionCommit: return 565
+    case .sqlDataDefinitionsInTransactionsIgnored: return 566
+    case .sqlSupportedResultSetTypes: return 567
+    case .sqlSupportedConcurrenciesForResultSetUnspecified: return 568
+    case .sqlSupportedConcurrenciesForResultSetForwardOnly: return 569
+    case .sqlSupportedConcurrenciesForResultSetScrollSensitive: return 570
+    case .sqlSupportedConcurrenciesForResultSetScrollInsensitive: return 571
+    case .sqlBatchUpdatesSupported: return 572
+    case .sqlSavepointsSupported: return 573
+    case .sqlNamedParametersSupported: return 574
+    case .sqlLocatorsUpdateCopy: return 575
+    case .sqlStoredFunctionsUsingCallSyntaxSupported: return 576
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlInfo: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlInfo] = [
+    .flightSqlServerName,
+    .flightSqlServerVersion,
+    .flightSqlServerArrowVersion,
+    .flightSqlServerReadOnly,
+    .flightSqlServerSql,
+    .flightSqlServerSubstrait,
+    .flightSqlServerSubstraitMinVersion,
+    .flightSqlServerSubstraitMaxVersion,
+    .flightSqlServerTransaction,
+    .flightSqlServerCancel,
+    .flightSqlServerStatementTimeout,
+    .flightSqlServerTransactionTimeout,
+    .sqlDdlCatalog,
+    .sqlDdlSchema,
+    .sqlDdlTable,
+    .sqlIdentifierCase,
+    .sqlIdentifierQuoteChar,
+    .sqlQuotedIdentifierCase,
+    .sqlAllTablesAreSelectable,
+    .sqlNullOrdering,
+    .sqlKeywords,
+    .sqlNumericFunctions,
+    .sqlStringFunctions,
+    .sqlSystemFunctions,
+    .sqlDatetimeFunctions,
+    .sqlSearchStringEscape,
+    .sqlExtraNameCharacters,
+    .sqlSupportsColumnAliasing,
+    .sqlNullPlusNullIsNull,
+    .sqlSupportsConvert,
+    .sqlSupportsTableCorrelationNames,
+    .sqlSupportsDifferentTableCorrelationNames,
+    .sqlSupportsExpressionsInOrderBy,
+    .sqlSupportsOrderByUnrelated,
+    .sqlSupportedGroupBy,
+    .sqlSupportsLikeEscapeClause,
+    .sqlSupportsNonNullableColumns,
+    .sqlSupportedGrammar,
+    .sqlAnsi92SupportedLevel,
+    .sqlSupportsIntegrityEnhancementFacility,
+    .sqlOuterJoinsSupportLevel,
+    .sqlSchemaTerm,
+    .sqlProcedureTerm,
+    .sqlCatalogTerm,
+    .sqlCatalogAtStart,
+    .sqlSchemasSupportedActions,
+    .sqlCatalogsSupportedActions,
+    .sqlSupportedPositionedCommands,
+    .sqlSelectForUpdateSupported,
+    .sqlStoredProceduresSupported,
+    .sqlSupportedSubqueries,
+    .sqlCorrelatedSubqueriesSupported,
+    .sqlSupportedUnions,
+    .sqlMaxBinaryLiteralLength,
+    .sqlMaxCharLiteralLength,
+    .sqlMaxColumnNameLength,
+    .sqlMaxColumnsInGroupBy,
+    .sqlMaxColumnsInIndex,
+    .sqlMaxColumnsInOrderBy,
+    .sqlMaxColumnsInSelect,
+    .sqlMaxColumnsInTable,
+    .sqlMaxConnections,
+    .sqlMaxCursorNameLength,
+    .sqlMaxIndexLength,
+    .sqlDbSchemaNameLength,
+    .sqlMaxProcedureNameLength,
+    .sqlMaxCatalogNameLength,
+    .sqlMaxRowSize,
+    .sqlMaxRowSizeIncludesBlobs,
+    .sqlMaxStatementLength,
+    .sqlMaxStatements,
+    .sqlMaxTableNameLength,
+    .sqlMaxTablesInSelect,
+    .sqlMaxUsernameLength,
+    .sqlDefaultTransactionIsolation,
+    .sqlTransactionsSupported,
+    .sqlSupportedTransactionsIsolationLevels,
+    .sqlDataDefinitionCausesTransactionCommit,
+    .sqlDataDefinitionsInTransactionsIgnored,
+    .sqlSupportedResultSetTypes,
+    .sqlSupportedConcurrenciesForResultSetUnspecified,
+    .sqlSupportedConcurrenciesForResultSetForwardOnly,
+    .sqlSupportedConcurrenciesForResultSetScrollSensitive,
+    .sqlSupportedConcurrenciesForResultSetScrollInsensitive,
+    .sqlBatchUpdatesSupported,
+    .sqlSavepointsSupported,
+    .sqlNamedParametersSupported,
+    .sqlLocatorsUpdateCopy,
+    .sqlStoredFunctionsUsingCallSyntaxSupported,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+/// The level of support for Flight SQL transaction RPCs.
+enum Arrow_Flight_Protocol_Sql_SqlSupportedTransaction: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+
+  /// Unknown/not indicated/no support
+  case 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.
+  case transaction // = 1
+
+  /// Transactions and savepoints
+  case savepoint // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .none
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .none
+    case 1: self = .transaction
+    case 2: self = .savepoint
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .none: return 0
+    case .transaction: return 1
+    case .savepoint: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransaction: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedTransaction] = [
+    .none,
+    .transaction,
+    .savepoint,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedCaseSensitivity: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlCaseSensitivityUnknown // = 0
+  case sqlCaseSensitivityCaseInsensitive // = 1
+  case sqlCaseSensitivityUppercase // = 2
+  case sqlCaseSensitivityLowercase // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlCaseSensitivityUnknown
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlCaseSensitivityUnknown
+    case 1: self = .sqlCaseSensitivityCaseInsensitive
+    case 2: self = .sqlCaseSensitivityUppercase
+    case 3: self = .sqlCaseSensitivityLowercase
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlCaseSensitivityUnknown: return 0
+    case .sqlCaseSensitivityCaseInsensitive: return 1
+    case .sqlCaseSensitivityUppercase: return 2
+    case .sqlCaseSensitivityLowercase: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedCaseSensitivity: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedCaseSensitivity] = [
+    .sqlCaseSensitivityUnknown,
+    .sqlCaseSensitivityCaseInsensitive,
+    .sqlCaseSensitivityUppercase,
+    .sqlCaseSensitivityLowercase,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlNullOrdering: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlNullsSortedHigh // = 0
+  case sqlNullsSortedLow // = 1
+  case sqlNullsSortedAtStart // = 2
+  case sqlNullsSortedAtEnd // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlNullsSortedHigh
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlNullsSortedHigh
+    case 1: self = .sqlNullsSortedLow
+    case 2: self = .sqlNullsSortedAtStart
+    case 3: self = .sqlNullsSortedAtEnd
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlNullsSortedHigh: return 0
+    case .sqlNullsSortedLow: return 1
+    case .sqlNullsSortedAtStart: return 2
+    case .sqlNullsSortedAtEnd: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlNullOrdering: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlNullOrdering] = [
+    .sqlNullsSortedHigh,
+    .sqlNullsSortedLow,
+    .sqlNullsSortedAtStart,
+    .sqlNullsSortedAtEnd,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SupportedSqlGrammar: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlMinimumGrammar // = 0
+  case sqlCoreGrammar // = 1
+  case sqlExtendedGrammar // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlMinimumGrammar
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlMinimumGrammar
+    case 1: self = .sqlCoreGrammar
+    case 2: self = .sqlExtendedGrammar
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlMinimumGrammar: return 0
+    case .sqlCoreGrammar: return 1
+    case .sqlExtendedGrammar: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SupportedSqlGrammar: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SupportedSqlGrammar] = [
+    .sqlMinimumGrammar,
+    .sqlCoreGrammar,
+    .sqlExtendedGrammar,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SupportedAnsi92SqlGrammarLevel: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case ansi92EntrySql // = 0
+  case ansi92IntermediateSql // = 1
+  case ansi92FullSql // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .ansi92EntrySql
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .ansi92EntrySql
+    case 1: self = .ansi92IntermediateSql
+    case 2: self = .ansi92FullSql
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .ansi92EntrySql: return 0
+    case .ansi92IntermediateSql: return 1
+    case .ansi92FullSql: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SupportedAnsi92SqlGrammarLevel: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SupportedAnsi92SqlGrammarLevel] = [
+    .ansi92EntrySql,
+    .ansi92IntermediateSql,
+    .ansi92FullSql,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlOuterJoinsSupportLevel: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlJoinsUnsupported // = 0
+  case sqlLimitedOuterJoins // = 1
+  case sqlFullOuterJoins // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlJoinsUnsupported
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlJoinsUnsupported
+    case 1: self = .sqlLimitedOuterJoins
+    case 2: self = .sqlFullOuterJoins
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlJoinsUnsupported: return 0
+    case .sqlLimitedOuterJoins: return 1
+    case .sqlFullOuterJoins: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlOuterJoinsSupportLevel: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlOuterJoinsSupportLevel] = [
+    .sqlJoinsUnsupported,
+    .sqlLimitedOuterJoins,
+    .sqlFullOuterJoins,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedGroupBy: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlGroupByUnrelated // = 0
+  case sqlGroupByBeyondSelect // = 1
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlGroupByUnrelated
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlGroupByUnrelated
+    case 1: self = .sqlGroupByBeyondSelect
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlGroupByUnrelated: return 0
+    case .sqlGroupByBeyondSelect: return 1
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedGroupBy: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedGroupBy] = [
+    .sqlGroupByUnrelated,
+    .sqlGroupByBeyondSelect,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedElementActions: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlElementInProcedureCalls // = 0
+  case sqlElementInIndexDefinitions // = 1
+  case sqlElementInPrivilegeDefinitions // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlElementInProcedureCalls
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlElementInProcedureCalls
+    case 1: self = .sqlElementInIndexDefinitions
+    case 2: self = .sqlElementInPrivilegeDefinitions
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlElementInProcedureCalls: return 0
+    case .sqlElementInIndexDefinitions: return 1
+    case .sqlElementInPrivilegeDefinitions: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedElementActions: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedElementActions] = [
+    .sqlElementInProcedureCalls,
+    .sqlElementInIndexDefinitions,
+    .sqlElementInPrivilegeDefinitions,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedPositionedCommands: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlPositionedDelete // = 0
+  case sqlPositionedUpdate // = 1
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlPositionedDelete
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlPositionedDelete
+    case 1: self = .sqlPositionedUpdate
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlPositionedDelete: return 0
+    case .sqlPositionedUpdate: return 1
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedPositionedCommands: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedPositionedCommands] = [
+    .sqlPositionedDelete,
+    .sqlPositionedUpdate,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedSubqueries: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlSubqueriesInComparisons // = 0
+  case sqlSubqueriesInExists // = 1
+  case sqlSubqueriesInIns // = 2
+  case sqlSubqueriesInQuantifieds // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlSubqueriesInComparisons
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlSubqueriesInComparisons
+    case 1: self = .sqlSubqueriesInExists
+    case 2: self = .sqlSubqueriesInIns
+    case 3: self = .sqlSubqueriesInQuantifieds
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlSubqueriesInComparisons: return 0
+    case .sqlSubqueriesInExists: return 1
+    case .sqlSubqueriesInIns: return 2
+    case .sqlSubqueriesInQuantifieds: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedSubqueries: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedSubqueries] = [
+    .sqlSubqueriesInComparisons,
+    .sqlSubqueriesInExists,
+    .sqlSubqueriesInIns,
+    .sqlSubqueriesInQuantifieds,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedUnions: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlUnion // = 0
+  case sqlUnionAll // = 1
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlUnion
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlUnion
+    case 1: self = .sqlUnionAll
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlUnion: return 0
+    case .sqlUnionAll: return 1
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedUnions: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedUnions] = [
+    .sqlUnion,
+    .sqlUnionAll,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlTransactionIsolationLevel: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlTransactionNone // = 0
+  case sqlTransactionReadUncommitted // = 1
+  case sqlTransactionReadCommitted // = 2
+  case sqlTransactionRepeatableRead // = 3
+  case sqlTransactionSerializable // = 4
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlTransactionNone
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlTransactionNone
+    case 1: self = .sqlTransactionReadUncommitted
+    case 2: self = .sqlTransactionReadCommitted
+    case 3: self = .sqlTransactionRepeatableRead
+    case 4: self = .sqlTransactionSerializable
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlTransactionNone: return 0
+    case .sqlTransactionReadUncommitted: return 1
+    case .sqlTransactionReadCommitted: return 2
+    case .sqlTransactionRepeatableRead: return 3
+    case .sqlTransactionSerializable: return 4
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlTransactionIsolationLevel: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlTransactionIsolationLevel] = [
+    .sqlTransactionNone,
+    .sqlTransactionReadUncommitted,
+    .sqlTransactionReadCommitted,
+    .sqlTransactionRepeatableRead,
+    .sqlTransactionSerializable,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedTransactions: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlTransactionUnspecified // = 0
+  case sqlDataDefinitionTransactions // = 1
+  case sqlDataManipulationTransactions // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlTransactionUnspecified
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlTransactionUnspecified
+    case 1: self = .sqlDataDefinitionTransactions
+    case 2: self = .sqlDataManipulationTransactions
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlTransactionUnspecified: return 0
+    case .sqlDataDefinitionTransactions: return 1
+    case .sqlDataManipulationTransactions: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransactions: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedTransactions] = [
+    .sqlTransactionUnspecified,
+    .sqlDataDefinitionTransactions,
+    .sqlDataManipulationTransactions,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedResultSetType: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlResultSetTypeUnspecified // = 0
+  case sqlResultSetTypeForwardOnly // = 1
+  case sqlResultSetTypeScrollInsensitive // = 2
+  case sqlResultSetTypeScrollSensitive // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlResultSetTypeUnspecified
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlResultSetTypeUnspecified
+    case 1: self = .sqlResultSetTypeForwardOnly
+    case 2: self = .sqlResultSetTypeScrollInsensitive
+    case 3: self = .sqlResultSetTypeScrollSensitive
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlResultSetTypeUnspecified: return 0
+    case .sqlResultSetTypeForwardOnly: return 1
+    case .sqlResultSetTypeScrollInsensitive: return 2
+    case .sqlResultSetTypeScrollSensitive: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetType: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedResultSetType] = [
+    .sqlResultSetTypeUnspecified,
+    .sqlResultSetTypeForwardOnly,
+    .sqlResultSetTypeScrollInsensitive,
+    .sqlResultSetTypeScrollSensitive,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportedResultSetConcurrency: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlResultSetConcurrencyUnspecified // = 0
+  case sqlResultSetConcurrencyReadOnly // = 1
+  case sqlResultSetConcurrencyUpdatable // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlResultSetConcurrencyUnspecified
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlResultSetConcurrencyUnspecified
+    case 1: self = .sqlResultSetConcurrencyReadOnly
+    case 2: self = .sqlResultSetConcurrencyUpdatable
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlResultSetConcurrencyUnspecified: return 0
+    case .sqlResultSetConcurrencyReadOnly: return 1
+    case .sqlResultSetConcurrencyUpdatable: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetConcurrency: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportedResultSetConcurrency] = [
+    .sqlResultSetConcurrencyUnspecified,
+    .sqlResultSetConcurrencyReadOnly,
+    .sqlResultSetConcurrencyUpdatable,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_SqlSupportsConvert: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case sqlConvertBigint // = 0
+  case sqlConvertBinary // = 1
+  case sqlConvertBit // = 2
+  case sqlConvertChar // = 3
+  case sqlConvertDate // = 4
+  case sqlConvertDecimal // = 5
+  case sqlConvertFloat // = 6
+  case sqlConvertInteger // = 7
+  case sqlConvertIntervalDayTime // = 8
+  case sqlConvertIntervalYearMonth // = 9
+  case sqlConvertLongvarbinary // = 10
+  case sqlConvertLongvarchar // = 11
+  case sqlConvertNumeric // = 12
+  case sqlConvertReal // = 13
+  case sqlConvertSmallint // = 14
+  case sqlConvertTime // = 15
+  case sqlConvertTimestamp // = 16
+  case sqlConvertTinyint // = 17
+  case sqlConvertVarbinary // = 18
+  case sqlConvertVarchar // = 19
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .sqlConvertBigint
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .sqlConvertBigint
+    case 1: self = .sqlConvertBinary
+    case 2: self = .sqlConvertBit
+    case 3: self = .sqlConvertChar
+    case 4: self = .sqlConvertDate
+    case 5: self = .sqlConvertDecimal
+    case 6: self = .sqlConvertFloat
+    case 7: self = .sqlConvertInteger
+    case 8: self = .sqlConvertIntervalDayTime
+    case 9: self = .sqlConvertIntervalYearMonth
+    case 10: self = .sqlConvertLongvarbinary
+    case 11: self = .sqlConvertLongvarchar
+    case 12: self = .sqlConvertNumeric
+    case 13: self = .sqlConvertReal
+    case 14: self = .sqlConvertSmallint
+    case 15: self = .sqlConvertTime
+    case 16: self = .sqlConvertTimestamp
+    case 17: self = .sqlConvertTinyint
+    case 18: self = .sqlConvertVarbinary
+    case 19: self = .sqlConvertVarchar
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .sqlConvertBigint: return 0
+    case .sqlConvertBinary: return 1
+    case .sqlConvertBit: return 2
+    case .sqlConvertChar: return 3
+    case .sqlConvertDate: return 4
+    case .sqlConvertDecimal: return 5
+    case .sqlConvertFloat: return 6
+    case .sqlConvertInteger: return 7
+    case .sqlConvertIntervalDayTime: return 8
+    case .sqlConvertIntervalYearMonth: return 9
+    case .sqlConvertLongvarbinary: return 10
+    case .sqlConvertLongvarchar: return 11
+    case .sqlConvertNumeric: return 12
+    case .sqlConvertReal: return 13
+    case .sqlConvertSmallint: return 14
+    case .sqlConvertTime: return 15
+    case .sqlConvertTimestamp: return 16
+    case .sqlConvertTinyint: return 17
+    case .sqlConvertVarbinary: return 18
+    case .sqlConvertVarchar: return 19
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportsConvert: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_SqlSupportsConvert] = [
+    .sqlConvertBigint,
+    .sqlConvertBinary,
+    .sqlConvertBit,
+    .sqlConvertChar,
+    .sqlConvertDate,
+    .sqlConvertDecimal,
+    .sqlConvertFloat,
+    .sqlConvertInteger,
+    .sqlConvertIntervalDayTime,
+    .sqlConvertIntervalYearMonth,
+    .sqlConvertLongvarbinary,
+    .sqlConvertLongvarchar,
+    .sqlConvertNumeric,
+    .sqlConvertReal,
+    .sqlConvertSmallint,
+    .sqlConvertTime,
+    .sqlConvertTimestamp,
+    .sqlConvertTinyint,
+    .sqlConvertVarbinary,
+    .sqlConvertVarchar,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///*
+/// The JDBC/ODBC-defined type of any object.
+/// All the values here are the sames as in the JDBC and ODBC specs.
+enum Arrow_Flight_Protocol_Sql_XdbcDataType: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case xdbcUnknownType // = 0
+  case xdbcChar // = 1
+  case xdbcNumeric // = 2
+  case xdbcDecimal // = 3
+  case xdbcInteger // = 4
+  case xdbcSmallint // = 5
+  case xdbcFloat // = 6
+  case xdbcReal // = 7
+  case xdbcDouble // = 8
+  case xdbcDatetime // = 9
+  case xdbcInterval // = 10
+  case xdbcVarchar // = 12
+  case xdbcDate // = 91
+  case xdbcTime // = 92
+  case xdbcTimestamp // = 93
+  case xdbcLongvarchar // = -1
+  case xdbcBinary // = -2
+  case xdbcVarbinary // = -3
+  case xdbcLongvarbinary // = -4
+  case xdbcBigint // = -5
+  case xdbcTinyint // = -6
+  case xdbcBit // = -7
+  case xdbcWchar // = -8
+  case xdbcWvarchar // = -9
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .xdbcUnknownType
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case -9: self = .xdbcWvarchar
+    case -8: self = .xdbcWchar
+    case -7: self = .xdbcBit
+    case -6: self = .xdbcTinyint
+    case -5: self = .xdbcBigint
+    case -4: self = .xdbcLongvarbinary
+    case -3: self = .xdbcVarbinary
+    case -2: self = .xdbcBinary
+    case -1: self = .xdbcLongvarchar
+    case 0: self = .xdbcUnknownType
+    case 1: self = .xdbcChar
+    case 2: self = .xdbcNumeric
+    case 3: self = .xdbcDecimal
+    case 4: self = .xdbcInteger
+    case 5: self = .xdbcSmallint
+    case 6: self = .xdbcFloat
+    case 7: self = .xdbcReal
+    case 8: self = .xdbcDouble
+    case 9: self = .xdbcDatetime
+    case 10: self = .xdbcInterval
+    case 12: self = .xdbcVarchar
+    case 91: self = .xdbcDate
+    case 92: self = .xdbcTime
+    case 93: self = .xdbcTimestamp
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .xdbcWvarchar: return -9
+    case .xdbcWchar: return -8
+    case .xdbcBit: return -7
+    case .xdbcTinyint: return -6
+    case .xdbcBigint: return -5
+    case .xdbcLongvarbinary: return -4
+    case .xdbcVarbinary: return -3
+    case .xdbcBinary: return -2
+    case .xdbcLongvarchar: return -1
+    case .xdbcUnknownType: return 0
+    case .xdbcChar: return 1
+    case .xdbcNumeric: return 2
+    case .xdbcDecimal: return 3
+    case .xdbcInteger: return 4
+    case .xdbcSmallint: return 5
+    case .xdbcFloat: return 6
+    case .xdbcReal: return 7
+    case .xdbcDouble: return 8
+    case .xdbcDatetime: return 9
+    case .xdbcInterval: return 10
+    case .xdbcVarchar: return 12
+    case .xdbcDate: return 91
+    case .xdbcTime: return 92
+    case .xdbcTimestamp: return 93
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_XdbcDataType: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_XdbcDataType] = [
+    .xdbcUnknownType,
+    .xdbcChar,
+    .xdbcNumeric,
+    .xdbcDecimal,
+    .xdbcInteger,
+    .xdbcSmallint,
+    .xdbcFloat,
+    .xdbcReal,
+    .xdbcDouble,
+    .xdbcDatetime,
+    .xdbcInterval,
+    .xdbcVarchar,
+    .xdbcDate,
+    .xdbcTime,
+    .xdbcTimestamp,
+    .xdbcLongvarchar,
+    .xdbcBinary,
+    .xdbcVarbinary,
+    .xdbcLongvarbinary,
+    .xdbcBigint,
+    .xdbcTinyint,
+    .xdbcBit,
+    .xdbcWchar,
+    .xdbcWvarchar,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///*
+/// Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
+enum Arrow_Flight_Protocol_Sql_XdbcDatetimeSubcode: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case xdbcSubcodeUnknown // = 0
+  case xdbcSubcodeYear // = 1
+  static let xdbcSubcodeDate = xdbcSubcodeYear
+  case xdbcSubcodeTime // = 2
+  static let xdbcSubcodeMonth = xdbcSubcodeTime
+  case xdbcSubcodeTimestamp // = 3
+  static let xdbcSubcodeDay = xdbcSubcodeTimestamp
+  case xdbcSubcodeTimeWithTimezone // = 4
+  static let xdbcSubcodeHour = xdbcSubcodeTimeWithTimezone
+  case xdbcSubcodeTimestampWithTimezone // = 5
+  static let xdbcSubcodeMinute = xdbcSubcodeTimestampWithTimezone
+  case xdbcSubcodeSecond // = 6
+  case xdbcSubcodeYearToMonth // = 7
+  case xdbcSubcodeDayToHour // = 8
+  case xdbcSubcodeDayToMinute // = 9
+  case xdbcSubcodeDayToSecond // = 10
+  case xdbcSubcodeHourToMinute // = 11
+  case xdbcSubcodeHourToSecond // = 12
+  case xdbcSubcodeMinuteToSecond // = 13
+  case xdbcSubcodeIntervalYear // = 101
+  case xdbcSubcodeIntervalMonth // = 102
+  case xdbcSubcodeIntervalDay // = 103
+  case xdbcSubcodeIntervalHour // = 104
+  case xdbcSubcodeIntervalMinute // = 105
+  case xdbcSubcodeIntervalSecond // = 106
+  case xdbcSubcodeIntervalYearToMonth // = 107
+  case xdbcSubcodeIntervalDayToHour // = 108
+  case xdbcSubcodeIntervalDayToMinute // = 109
+  case xdbcSubcodeIntervalDayToSecond // = 110
+  case xdbcSubcodeIntervalHourToMinute // = 111
+  case xdbcSubcodeIntervalHourToSecond // = 112
+  case xdbcSubcodeIntervalMinuteToSecond // = 113
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .xdbcSubcodeUnknown
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .xdbcSubcodeUnknown
+    case 1: self = .xdbcSubcodeYear
+    case 2: self = .xdbcSubcodeTime
+    case 3: self = .xdbcSubcodeTimestamp
+    case 4: self = .xdbcSubcodeTimeWithTimezone
+    case 5: self = .xdbcSubcodeTimestampWithTimezone
+    case 6: self = .xdbcSubcodeSecond
+    case 7: self = .xdbcSubcodeYearToMonth
+    case 8: self = .xdbcSubcodeDayToHour
+    case 9: self = .xdbcSubcodeDayToMinute
+    case 10: self = .xdbcSubcodeDayToSecond
+    case 11: self = .xdbcSubcodeHourToMinute
+    case 12: self = .xdbcSubcodeHourToSecond
+    case 13: self = .xdbcSubcodeMinuteToSecond
+    case 101: self = .xdbcSubcodeIntervalYear
+    case 102: self = .xdbcSubcodeIntervalMonth
+    case 103: self = .xdbcSubcodeIntervalDay
+    case 104: self = .xdbcSubcodeIntervalHour
+    case 105: self = .xdbcSubcodeIntervalMinute
+    case 106: self = .xdbcSubcodeIntervalSecond
+    case 107: self = .xdbcSubcodeIntervalYearToMonth
+    case 108: self = .xdbcSubcodeIntervalDayToHour
+    case 109: self = .xdbcSubcodeIntervalDayToMinute
+    case 110: self = .xdbcSubcodeIntervalDayToSecond
+    case 111: self = .xdbcSubcodeIntervalHourToMinute
+    case 112: self = .xdbcSubcodeIntervalHourToSecond
+    case 113: self = .xdbcSubcodeIntervalMinuteToSecond
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .xdbcSubcodeUnknown: return 0
+    case .xdbcSubcodeYear: return 1
+    case .xdbcSubcodeTime: return 2
+    case .xdbcSubcodeTimestamp: return 3
+    case .xdbcSubcodeTimeWithTimezone: return 4
+    case .xdbcSubcodeTimestampWithTimezone: return 5
+    case .xdbcSubcodeSecond: return 6
+    case .xdbcSubcodeYearToMonth: return 7
+    case .xdbcSubcodeDayToHour: return 8
+    case .xdbcSubcodeDayToMinute: return 9
+    case .xdbcSubcodeDayToSecond: return 10
+    case .xdbcSubcodeHourToMinute: return 11
+    case .xdbcSubcodeHourToSecond: return 12
+    case .xdbcSubcodeMinuteToSecond: return 13
+    case .xdbcSubcodeIntervalYear: return 101
+    case .xdbcSubcodeIntervalMonth: return 102
+    case .xdbcSubcodeIntervalDay: return 103
+    case .xdbcSubcodeIntervalHour: return 104
+    case .xdbcSubcodeIntervalMinute: return 105
+    case .xdbcSubcodeIntervalSecond: return 106
+    case .xdbcSubcodeIntervalYearToMonth: return 107
+    case .xdbcSubcodeIntervalDayToHour: return 108
+    case .xdbcSubcodeIntervalDayToMinute: return 109
+    case .xdbcSubcodeIntervalDayToSecond: return 110
+    case .xdbcSubcodeIntervalHourToMinute: return 111
+    case .xdbcSubcodeIntervalHourToSecond: return 112
+    case .xdbcSubcodeIntervalMinuteToSecond: return 113
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_XdbcDatetimeSubcode: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_XdbcDatetimeSubcode] = [
+    .xdbcSubcodeUnknown,
+    .xdbcSubcodeYear,
+    .xdbcSubcodeTime,
+    .xdbcSubcodeTimestamp,
+    .xdbcSubcodeTimeWithTimezone,
+    .xdbcSubcodeTimestampWithTimezone,
+    .xdbcSubcodeSecond,
+    .xdbcSubcodeYearToMonth,
+    .xdbcSubcodeDayToHour,
+    .xdbcSubcodeDayToMinute,
+    .xdbcSubcodeDayToSecond,
+    .xdbcSubcodeHourToMinute,
+    .xdbcSubcodeHourToSecond,
+    .xdbcSubcodeMinuteToSecond,
+    .xdbcSubcodeIntervalYear,
+    .xdbcSubcodeIntervalMonth,
+    .xdbcSubcodeIntervalDay,
+    .xdbcSubcodeIntervalHour,
+    .xdbcSubcodeIntervalMinute,
+    .xdbcSubcodeIntervalSecond,
+    .xdbcSubcodeIntervalYearToMonth,
+    .xdbcSubcodeIntervalDayToHour,
+    .xdbcSubcodeIntervalDayToMinute,
+    .xdbcSubcodeIntervalDayToSecond,
+    .xdbcSubcodeIntervalHourToMinute,
+    .xdbcSubcodeIntervalHourToSecond,
+    .xdbcSubcodeIntervalMinuteToSecond,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_Nullable: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+
+  ///*
+  /// Indicates that the fields does not allow the use of null values.
+  case nullabilityNoNulls // = 0
+
+  ///*
+  /// Indicates that the fields allow the use of null values.
+  case nullabilityNullable // = 1
+
+  ///*
+  /// Indicates that nullability of the fields can not be determined.
+  case nullabilityUnknown // = 2
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .nullabilityNoNulls
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .nullabilityNoNulls
+    case 1: self = .nullabilityNullable
+    case 2: self = .nullabilityUnknown
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .nullabilityNoNulls: return 0
+    case .nullabilityNullable: return 1
+    case .nullabilityUnknown: return 2
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_Nullable: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_Nullable] = [
+    .nullabilityNoNulls,
+    .nullabilityNullable,
+    .nullabilityUnknown,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_Searchable: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+
+  ///*
+  /// Indicates that column can not be used in a WHERE clause.
+  case none // = 0
+
+  ///*
+  /// Indicates that the column can be used in a WHERE clause if it is using a
+  /// LIKE operator.
+  case 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.
+  case basic // = 2
+
+  ///*
+  /// Indicates that the column can be used in a WHERE clause using any operator.
+  case full // = 3
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .none
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .none
+    case 1: self = .char
+    case 2: self = .basic
+    case 3: self = .full
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .none: return 0
+    case .char: return 1
+    case .basic: return 2
+    case .full: return 3
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_Searchable: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_Searchable] = [
+    .none,
+    .char,
+    .basic,
+    .full,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+enum Arrow_Flight_Protocol_Sql_UpdateDeleteRules: SwiftProtobuf.Enum {
+  typealias RawValue = Int
+  case cascade // = 0
+  case restrict // = 1
+  case setNull // = 2
+  case noAction // = 3
+  case setDefault // = 4
+  case UNRECOGNIZED(Int)
+
+  init() {
+    self = .cascade
+  }
+
+  init?(rawValue: Int) {
+    switch rawValue {
+    case 0: self = .cascade
+    case 1: self = .restrict
+    case 2: self = .setNull
+    case 3: self = .noAction
+    case 4: self = .setDefault
+    default: self = .UNRECOGNIZED(rawValue)
+    }
+  }
+
+  var rawValue: Int {
+    switch self {
+    case .cascade: return 0
+    case .restrict: return 1
+    case .setNull: return 2
+    case .noAction: return 3
+    case .setDefault: return 4
+    case .UNRECOGNIZED(let i): return i
+    }
+  }
+
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_UpdateDeleteRules: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_UpdateDeleteRules] = [
+    .cascade,
+    .restrict,
+    .setNull,
+    .noAction,
+    .setDefault,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetSqlInfo {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var info: [UInt32] = []
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetXdbcTypeInfo {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// Specifies the data type to search for the info.
+  var dataType: Int32 {
+    get {return _dataType ?? 0}
+    set {_dataType = newValue}
+  }
+  /// Returns true if `dataType` has been explicitly set.
+  var hasDataType: Bool {return self._dataType != nil}
+  /// Clears the value of `dataType`. Subsequent reads from it will return its default value.
+  mutating func clearDataType() {self._dataType = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _dataType: Int32? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetCatalogs {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetDbSchemas {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var catalog: String {
+    get {return _catalog ?? String()}
+    set {_catalog = newValue}
+  }
+  /// Returns true if `catalog` has been explicitly set.
+  var hasCatalog: Bool {return self._catalog != nil}
+  /// Clears the value of `catalog`. Subsequent reads from it will return its default value.
+  mutating func clearCatalog() {self._catalog = nil}
+
+  ///
+  /// 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.
+  var dbSchemaFilterPattern: String {
+    get {return _dbSchemaFilterPattern ?? String()}
+    set {_dbSchemaFilterPattern = newValue}
+  }
+  /// Returns true if `dbSchemaFilterPattern` has been explicitly set.
+  var hasDbSchemaFilterPattern: Bool {return self._dbSchemaFilterPattern != nil}
+  /// Clears the value of `dbSchemaFilterPattern`. Subsequent reads from it will return its default value.
+  mutating func clearDbSchemaFilterPattern() {self._dbSchemaFilterPattern = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _catalog: String? = nil
+  fileprivate var _dbSchemaFilterPattern: String? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetTables {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var catalog: String {
+    get {return _catalog ?? String()}
+    set {_catalog = newValue}
+  }
+  /// Returns true if `catalog` has been explicitly set.
+  var hasCatalog: Bool {return self._catalog != nil}
+  /// Clears the value of `catalog`. Subsequent reads from it will return its default value.
+  mutating func clearCatalog() {self._catalog = nil}
+
+  ///
+  /// 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.
+  var dbSchemaFilterPattern: String {
+    get {return _dbSchemaFilterPattern ?? String()}
+    set {_dbSchemaFilterPattern = newValue}
+  }
+  /// Returns true if `dbSchemaFilterPattern` has been explicitly set.
+  var hasDbSchemaFilterPattern: Bool {return self._dbSchemaFilterPattern != nil}
+  /// Clears the value of `dbSchemaFilterPattern`. Subsequent reads from it will return its default value.
+  mutating func clearDbSchemaFilterPattern() {self._dbSchemaFilterPattern = nil}
+
+  ///
+  /// 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.
+  var tableNameFilterPattern: String {
+    get {return _tableNameFilterPattern ?? String()}
+    set {_tableNameFilterPattern = newValue}
+  }
+  /// Returns true if `tableNameFilterPattern` has been explicitly set.
+  var hasTableNameFilterPattern: Bool {return self._tableNameFilterPattern != nil}
+  /// Clears the value of `tableNameFilterPattern`. Subsequent reads from it will return its default value.
+  mutating func clearTableNameFilterPattern() {self._tableNameFilterPattern = nil}
+
+  ///
+  /// 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.
+  var tableTypes: [String] = []
+
+  /// Specifies if the Arrow schema should be returned for found tables.
+  var includeSchema: Bool = false
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _catalog: String? = nil
+  fileprivate var _dbSchemaFilterPattern: String? = nil
+  fileprivate var _tableNameFilterPattern: String? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetTableTypes {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetPrimaryKeys {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var catalog: String {
+    get {return _catalog ?? String()}
+    set {_catalog = newValue}
+  }
+  /// Returns true if `catalog` has been explicitly set.
+  var hasCatalog: Bool {return self._catalog != nil}
+  /// Clears the value of `catalog`. Subsequent reads from it will return its default value.
+  mutating func clearCatalog() {self._catalog = nil}
+
+  ///
+  /// 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.
+  var dbSchema: String {
+    get {return _dbSchema ?? String()}
+    set {_dbSchema = newValue}
+  }
+  /// Returns true if `dbSchema` has been explicitly set.
+  var hasDbSchema: Bool {return self._dbSchema != nil}
+  /// Clears the value of `dbSchema`. Subsequent reads from it will return its default value.
+  mutating func clearDbSchema() {self._dbSchema = nil}
+
+  /// Specifies the table to get the primary keys for.
+  var table: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _catalog: String? = nil
+  fileprivate var _dbSchema: String? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandGetExportedKeys {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var catalog: String {
+    get {return _catalog ?? String()}
+    set {_catalog = newValue}
+  }
+  /// Returns true if `catalog` has been explicitly set.
+  var hasCatalog: Bool {return self._catalog != nil}
+  /// Clears the value of `catalog`. Subsequent reads from it will return its default value.
+  mutating func clearCatalog() {self._catalog = nil}
+
+  ///
+  /// 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.
+  var dbSchema: String {
+    get {return _dbSchema ?? String()}
+    set {_dbSchema = newValue}
+  }
+  /// Returns true if `dbSchema` has been explicitly set.
+  var hasDbSchema: Bool {return self._dbSchema != nil}
+  /// Clears the value of `dbSchema`. Subsequent reads from it will return its default value.
+  mutating func clearDbSchema() {self._dbSchema = nil}
+
+  /// Specifies the foreign key table to get the foreign keys for.
+  var table: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _catalog: String? = nil
+  fileprivate var _dbSchema: String? = nil
+}
+
+///
+/// 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
+struct Arrow_Flight_Protocol_Sql_CommandGetImportedKeys {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///
+  /// 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.
+  var catalog: String {
+    get {return _catalog ?? String()}
+    set {_catalog = newValue}
+  }
+  /// Returns true if `catalog` has been explicitly set.
+  var hasCatalog: Bool {return self._catalog != nil}
+  /// Clears the value of `catalog`. Subsequent reads from it will return its default value.
+  mutating func clearCatalog() {self._catalog = nil}
+
+  ///
+  /// 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.
+  var dbSchema: String {
+    get {return _dbSchema ?? String()}
+    set {_dbSchema = newValue}
+  }
+  /// Returns true if `dbSchema` has been explicitly set.
+  var hasDbSchema: Bool {return self._dbSchema != nil}
+  /// Clears the value of `dbSchema`. Subsequent reads from it will return its default value.
+  mutating func clearDbSchema() {self._dbSchema = nil}
+
+  /// Specifies the primary key table to get the foreign keys for.
+  var table: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _catalog: String? = nil
+  fileprivate var _dbSchema: String? = nil
+}
+
+///
+/// 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
+struct Arrow_Flight_Protocol_Sql_CommandGetCrossReference {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  ///*
+  /// 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.
+  var pkCatalog: String {
+    get {return _pkCatalog ?? String()}
+    set {_pkCatalog = newValue}
+  }
+  /// Returns true if `pkCatalog` has been explicitly set.
+  var hasPkCatalog: Bool {return self._pkCatalog != nil}
+  /// Clears the value of `pkCatalog`. Subsequent reads from it will return its default value.
+  mutating func clearPkCatalog() {self._pkCatalog = nil}
+
+  ///*
+  /// 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.
+  var pkDbSchema: String {
+    get {return _pkDbSchema ?? String()}
+    set {_pkDbSchema = newValue}
+  }
+  /// Returns true if `pkDbSchema` has been explicitly set.
+  var hasPkDbSchema: Bool {return self._pkDbSchema != nil}
+  /// Clears the value of `pkDbSchema`. Subsequent reads from it will return its default value.
+  mutating func clearPkDbSchema() {self._pkDbSchema = nil}
+
+  ///*
+  /// The parent table name. It cannot be null.
+  var pkTable: 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.
+  var fkCatalog: String {
+    get {return _fkCatalog ?? String()}
+    set {_fkCatalog = newValue}
+  }
+  /// Returns true if `fkCatalog` has been explicitly set.
+  var hasFkCatalog: Bool {return self._fkCatalog != nil}
+  /// Clears the value of `fkCatalog`. Subsequent reads from it will return its default value.
+  mutating func clearFkCatalog() {self._fkCatalog = nil}
+
+  ///*
+  /// 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.
+  var fkDbSchema: String {
+    get {return _fkDbSchema ?? String()}
+    set {_fkDbSchema = newValue}
+  }
+  /// Returns true if `fkDbSchema` has been explicitly set.
+  var hasFkDbSchema: Bool {return self._fkDbSchema != nil}
+  /// Clears the value of `fkDbSchema`. Subsequent reads from it will return its default value.
+  mutating func clearFkDbSchema() {self._fkDbSchema = nil}
+
+  ///*
+  /// The foreign table name. It cannot be null.
+  var fkTable: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _pkCatalog: String? = nil
+  fileprivate var _pkDbSchema: String? = nil
+  fileprivate var _fkCatalog: String? = nil
+  fileprivate var _fkDbSchema: String? = nil
+}
+
+///
+/// Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
+struct Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The valid SQL string to create a prepared statement for.
+  var query: String = String()
+
+  /// Create/execute the prepared statement as part of this transaction (if
+  /// unset, executions of the prepared statement will be auto-committed).
+  var transactionID: Data {
+    get {return _transactionID ?? Data()}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  mutating func clearTransactionID() {self._transactionID = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _transactionID: Data? = nil
+}
+
+///
+/// An embedded message describing a Substrait plan to execute.
+struct Arrow_Flight_Protocol_Sql_SubstraitPlan {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// 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.
+  var plan: Data = Data()
+
+  /// 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.
+  var version: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
+struct Arrow_Flight_Protocol_Sql_ActionCreatePreparedSubstraitPlanRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The serialized substrait.Plan to create a prepared statement for.
+  var plan: Arrow_Flight_Protocol_Sql_SubstraitPlan {
+    get {return _plan ?? Arrow_Flight_Protocol_Sql_SubstraitPlan()}
+    set {_plan = newValue}
+  }
+  /// Returns true if `plan` has been explicitly set.
+  var hasPlan: Bool {return self._plan != nil}
+  /// Clears the value of `plan`. Subsequent reads from it will return its default value.
+  mutating func clearPlan() {self._plan = nil}
+
+  /// Create/execute the prepared statement as part of this transaction (if
+  /// unset, executions of the prepared statement will be auto-committed).
+  var transactionID: Data {
+    get {return _transactionID ?? Data()}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  mutating func clearTransactionID() {self._transactionID = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _plan: Arrow_Flight_Protocol_Sql_SubstraitPlan? = nil
+  fileprivate var _transactionID: Data? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the prepared statement on the server.
+  var preparedStatementHandle: Data = Data()
+
+  /// 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.
+  var datasetSchema: Data = Data()
+
+  /// 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.
+  var parameterSchema: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
+/// Closes server resources associated with the prepared statement handle.
+struct Arrow_Flight_Protocol_Sql_ActionClosePreparedStatementRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the prepared statement on the server.
+  var preparedStatementHandle: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Request message for the "BeginTransaction" action.
+/// Begins a transaction.
+struct Arrow_Flight_Protocol_Sql_ActionBeginTransactionRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Request message for the "BeginSavepoint" action.
+/// Creates a savepoint within a transaction.
+///
+/// Only supported if FLIGHT_SQL_TRANSACTION is
+/// FLIGHT_SQL_TRANSACTION_SUPPORT_SAVEPOINT.
+struct Arrow_Flight_Protocol_Sql_ActionBeginSavepointRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The transaction to which a savepoint belongs.
+  var transactionID: Data = Data()
+
+  /// Name for the savepoint.
+  var name: String = String()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionBeginTransactionResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the transaction on the server.
+  var transactionID: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionBeginSavepointResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the savepoint on the server.
+  var savepointID: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the transaction on the server.
+  var transactionID: Data = Data()
+
+  /// Whether to commit/rollback the given transaction.
+  var action: Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest.EndTransaction = .unspecified
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  enum EndTransaction: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case unspecified // = 0
+
+    /// Commit the transaction.
+    case commit // = 1
+
+    /// Roll back the transaction.
+    case rollback // = 2
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unspecified
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unspecified
+      case 1: self = .commit
+      case 2: self = .rollback
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unspecified: return 0
+      case .commit: return 1
+      case .rollback: return 2
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest.EndTransaction: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest.EndTransaction] = [
+    .unspecified,
+    .commit,
+    .rollback,
+  ]
+}
+
+#endif  // swift(>=4.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.
+struct Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the savepoint on the server.
+  var savepointID: Data = Data()
+
+  /// Whether to rollback/release the given savepoint.
+  var action: Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest.EndSavepoint = .unspecified
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  enum EndSavepoint: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+    case unspecified // = 0
+
+    /// Release the savepoint.
+    case release // = 1
+
+    /// Roll back to a savepoint.
+    case rollback // = 2
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unspecified
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unspecified
+      case 1: self = .release
+      case 2: self = .rollback
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unspecified: return 0
+      case .release: return 1
+      case .rollback: return 2
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest.EndSavepoint: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest.EndSavepoint] = [
+    .unspecified,
+    .release,
+    .rollback,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandStatementQuery {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The SQL syntax.
+  var query: String = String()
+
+  /// Include the query as part of this transaction (if unset, the query is auto-committed).
+  var transactionID: Data {
+    get {return _transactionID ?? Data()}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  mutating func clearTransactionID() {self._transactionID = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _transactionID: Data? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandStatementSubstraitPlan {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// A serialized substrait.Plan
+  var plan: Arrow_Flight_Protocol_Sql_SubstraitPlan {
+    get {return _plan ?? Arrow_Flight_Protocol_Sql_SubstraitPlan()}
+    set {_plan = newValue}
+  }
+  /// Returns true if `plan` has been explicitly set.
+  var hasPlan: Bool {return self._plan != nil}
+  /// Clears the value of `plan`. Subsequent reads from it will return its default value.
+  mutating func clearPlan() {self._plan = nil}
+
+  /// Include the query as part of this transaction (if unset, the query is auto-committed).
+  var transactionID: Data {
+    get {return _transactionID ?? Data()}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  mutating func clearTransactionID() {self._transactionID = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _plan: Arrow_Flight_Protocol_Sql_SubstraitPlan? = nil
+  fileprivate var _transactionID: Data? = nil
+}
+
+///*
+/// 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.
+struct Arrow_Flight_Protocol_Sql_TicketStatementQuery {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Unique identifier for the instance of the statement to execute.
+  var statementHandle: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+///  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+///  - GetFlightInfo: execute the prepared statement instance.
+struct Arrow_Flight_Protocol_Sql_CommandPreparedStatementQuery {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the prepared statement on the server.
+  var preparedStatementHandle: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandStatementUpdate {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The SQL syntax.
+  var query: String = String()
+
+  /// Include the query as part of this transaction (if unset, the query is auto-committed).
+  var transactionID: Data {
+    get {return _transactionID ?? Data()}
+    set {_transactionID = newValue}
+  }
+  /// Returns true if `transactionID` has been explicitly set.
+  var hasTransactionID: Bool {return self._transactionID != nil}
+  /// Clears the value of `transactionID`. Subsequent reads from it will return its default value.
+  mutating func clearTransactionID() {self._transactionID = nil}
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+
+  fileprivate var _transactionID: Data? = nil
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_CommandPreparedStatementUpdate {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// Opaque handle for the prepared statement on the server.
+  var preparedStatementHandle: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// Returned from the RPC call DoPut when a CommandStatementUpdate
+/// CommandPreparedStatementUpdate was in the request, containing
+/// results from the update.
+struct Arrow_Flight_Protocol_Sql_DoPutUpdateResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// The number of records updated. A return value of -1 represents
+  /// an unknown updated record count.
+  var recordCount: Int64 = 0
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionCancelQueryRequest {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  /// 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.
+  var info: Data = Data()
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  init() {}
+}
+
+///
+/// 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.
+struct Arrow_Flight_Protocol_Sql_ActionCancelQueryResult {
+  // SwiftProtobuf.Message conformance is added in an extension below. See the
+  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
+  // methods supported on all messages.
+
+  var result: Arrow_Flight_Protocol_Sql_ActionCancelQueryResult.CancelResult = .unspecified
+
+  var unknownFields = SwiftProtobuf.UnknownStorage()
+
+  enum CancelResult: SwiftProtobuf.Enum {
+    typealias RawValue = Int
+
+    /// 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.
+    case unspecified // = 0
+
+    /// The cancellation request is complete. Subsequent requests with
+    /// the same payload may return CANCELLED or a NOT_FOUND error.
+    case cancelled // = 1
+
+    /// The cancellation request is in progress. The client may retry
+    /// the cancellation request.
+    case cancelling // = 2
+
+    /// The query is not cancellable. The client should not retry the
+    /// cancellation request.
+    case notCancellable // = 3
+    case UNRECOGNIZED(Int)
+
+    init() {
+      self = .unspecified
+    }
+
+    init?(rawValue: Int) {
+      switch rawValue {
+      case 0: self = .unspecified
+      case 1: self = .cancelled
+      case 2: self = .cancelling
+      case 3: self = .notCancellable
+      default: self = .UNRECOGNIZED(rawValue)
+      }
+    }
+
+    var rawValue: Int {
+      switch self {
+      case .unspecified: return 0
+      case .cancelled: return 1
+      case .cancelling: return 2
+      case .notCancellable: return 3
+      case .UNRECOGNIZED(let i): return i
+      }
+    }
+
+  }
+
+  init() {}
+}
+
+#if swift(>=4.2)
+
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryResult.CancelResult: CaseIterable {
+  // The compiler won't synthesize support with the UNRECOGNIZED case.
+  static var allCases: [Arrow_Flight_Protocol_Sql_ActionCancelQueryResult.CancelResult] = [
+    .unspecified,
+    .cancelled,
+    .cancelling,
+    .notCancellable,
+  ]
+}
+
+#endif  // swift(>=4.2)
+
+#if swift(>=5.5) && canImport(_Concurrency)
+extension Arrow_Flight_Protocol_Sql_SqlInfo: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransaction: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedCaseSensitivity: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlNullOrdering: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SupportedSqlGrammar: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SupportedAnsi92SqlGrammarLevel: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlOuterJoinsSupportLevel: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedGroupBy: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedElementActions: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedPositionedCommands: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedSubqueries: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedUnions: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlTransactionIsolationLevel: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransactions: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetType: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetConcurrency: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SqlSupportsConvert: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_XdbcDataType: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_XdbcDatetimeSubcode: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_Nullable: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_Searchable: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_UpdateDeleteRules: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetSqlInfo: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetXdbcTypeInfo: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetCatalogs: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetDbSchemas: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetTables: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetTableTypes: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetPrimaryKeys: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetExportedKeys: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetImportedKeys: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandGetCrossReference: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_SubstraitPlan: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedSubstraitPlanRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionClosePreparedStatementRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionBeginTransactionRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionBeginSavepointRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionBeginTransactionResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionBeginSavepointResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest.EndTransaction: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest.EndSavepoint: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandStatementQuery: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandStatementSubstraitPlan: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_TicketStatementQuery: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandPreparedStatementQuery: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandStatementUpdate: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_CommandPreparedStatementUpdate: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_DoPutUpdateResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryRequest: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryResult: @unchecked Sendable {}
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryResult.CancelResult: @unchecked Sendable {}
+#endif  // swift(>=5.5) && canImport(_Concurrency)
+
+// MARK: - Extension support defined in FlightSql.proto.
+
+// MARK: - Extension Properties
+
+// Swift Extensions on the exteneded Messages to add easy access to the declared
+// extension fields. The names are based on the extension field name from the proto
+// declaration. To avoid naming collisions, the names are prefixed with the name of
+// the scope where the extend directive occurs.
+
+extension SwiftProtobuf.Google_Protobuf_MessageOptions {
+
+  var Arrow_Flight_Protocol_Sql_experimental: Bool {
+    get {return getExtensionValue(ext: Arrow_Flight_Protocol_Sql_Extensions_experimental) ?? false}
+    set {setExtensionValue(ext: Arrow_Flight_Protocol_Sql_Extensions_experimental, value: newValue)}
+  }
+  /// Returns true if extension `Arrow_Flight_Protocol_Sql_Extensions_experimental`
+  /// has been explicitly set.
+  var hasArrow_Flight_Protocol_Sql_experimental: Bool {
+    return hasExtensionValue(ext: Arrow_Flight_Protocol_Sql_Extensions_experimental)
+  }
+  /// Clears the value of extension `Arrow_Flight_Protocol_Sql_Extensions_experimental`.
+  /// Subsequent reads from it will return its default value.
+  mutating func clearArrow_Flight_Protocol_Sql_experimental() {
+    clearExtensionValue(ext: Arrow_Flight_Protocol_Sql_Extensions_experimental)
+  }
+
+}
+
+// MARK: - File's ExtensionMap: Arrow_Flight_Protocol_Sql_FlightSql_Extensions
+
+/// A `SwiftProtobuf.SimpleExtensionMap` that includes all of the extensions defined by
+/// this .proto file. It can be used any place an `SwiftProtobuf.ExtensionMap` is needed
+/// in parsing, or it can be combined with other `SwiftProtobuf.SimpleExtensionMap`s to create
+/// a larger `SwiftProtobuf.SimpleExtensionMap`.
+let Arrow_Flight_Protocol_Sql_FlightSql_Extensions: SwiftProtobuf.SimpleExtensionMap = [
+  Arrow_Flight_Protocol_Sql_Extensions_experimental
+]
+
+// Extension Objects - The only reason these might be needed is when manually
+// constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_
+// accessors for the extension fields on the messages directly.
+
+let Arrow_Flight_Protocol_Sql_Extensions_experimental = SwiftProtobuf.MessageExtension<SwiftProtobuf.OptionalExtensionField<SwiftProtobuf.ProtobufBool>, SwiftProtobuf.Google_Protobuf_MessageOptions>(
+  _protobuf_fieldNumber: 1000,
+  fieldName: "arrow.flight.protocol.sql.experimental"
+)
+
+// MARK: - Code below here is support for the SwiftProtobuf runtime.
+
+fileprivate let _protobuf_package = "arrow.flight.protocol.sql"
+
+extension Arrow_Flight_Protocol_Sql_SqlInfo: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "FLIGHT_SQL_SERVER_NAME"),
+    1: .same(proto: "FLIGHT_SQL_SERVER_VERSION"),
+    2: .same(proto: "FLIGHT_SQL_SERVER_ARROW_VERSION"),
+    3: .same(proto: "FLIGHT_SQL_SERVER_READ_ONLY"),
+    4: .same(proto: "FLIGHT_SQL_SERVER_SQL"),
+    5: .same(proto: "FLIGHT_SQL_SERVER_SUBSTRAIT"),
+    6: .same(proto: "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION"),
+    7: .same(proto: "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION"),
+    8: .same(proto: "FLIGHT_SQL_SERVER_TRANSACTION"),
+    9: .same(proto: "FLIGHT_SQL_SERVER_CANCEL"),
+    100: .same(proto: "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT"),
+    101: .same(proto: "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT"),
+    500: .same(proto: "SQL_DDL_CATALOG"),
+    501: .same(proto: "SQL_DDL_SCHEMA"),
+    502: .same(proto: "SQL_DDL_TABLE"),
+    503: .same(proto: "SQL_IDENTIFIER_CASE"),
+    504: .same(proto: "SQL_IDENTIFIER_QUOTE_CHAR"),
+    505: .same(proto: "SQL_QUOTED_IDENTIFIER_CASE"),
+    506: .same(proto: "SQL_ALL_TABLES_ARE_SELECTABLE"),
+    507: .same(proto: "SQL_NULL_ORDERING"),
+    508: .same(proto: "SQL_KEYWORDS"),
+    509: .same(proto: "SQL_NUMERIC_FUNCTIONS"),
+    510: .same(proto: "SQL_STRING_FUNCTIONS"),
+    511: .same(proto: "SQL_SYSTEM_FUNCTIONS"),
+    512: .same(proto: "SQL_DATETIME_FUNCTIONS"),
+    513: .same(proto: "SQL_SEARCH_STRING_ESCAPE"),
+    514: .same(proto: "SQL_EXTRA_NAME_CHARACTERS"),
+    515: .same(proto: "SQL_SUPPORTS_COLUMN_ALIASING"),
+    516: .same(proto: "SQL_NULL_PLUS_NULL_IS_NULL"),
+    517: .same(proto: "SQL_SUPPORTS_CONVERT"),
+    518: .same(proto: "SQL_SUPPORTS_TABLE_CORRELATION_NAMES"),
+    519: .same(proto: "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES"),
+    520: .same(proto: "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY"),
+    521: .same(proto: "SQL_SUPPORTS_ORDER_BY_UNRELATED"),
+    522: .same(proto: "SQL_SUPPORTED_GROUP_BY"),
+    523: .same(proto: "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE"),
+    524: .same(proto: "SQL_SUPPORTS_NON_NULLABLE_COLUMNS"),
+    525: .same(proto: "SQL_SUPPORTED_GRAMMAR"),
+    526: .same(proto: "SQL_ANSI92_SUPPORTED_LEVEL"),
+    527: .same(proto: "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY"),
+    528: .same(proto: "SQL_OUTER_JOINS_SUPPORT_LEVEL"),
+    529: .same(proto: "SQL_SCHEMA_TERM"),
+    530: .same(proto: "SQL_PROCEDURE_TERM"),
+    531: .same(proto: "SQL_CATALOG_TERM"),
+    532: .same(proto: "SQL_CATALOG_AT_START"),
+    533: .same(proto: "SQL_SCHEMAS_SUPPORTED_ACTIONS"),
+    534: .same(proto: "SQL_CATALOGS_SUPPORTED_ACTIONS"),
+    535: .same(proto: "SQL_SUPPORTED_POSITIONED_COMMANDS"),
+    536: .same(proto: "SQL_SELECT_FOR_UPDATE_SUPPORTED"),
+    537: .same(proto: "SQL_STORED_PROCEDURES_SUPPORTED"),
+    538: .same(proto: "SQL_SUPPORTED_SUBQUERIES"),
+    539: .same(proto: "SQL_CORRELATED_SUBQUERIES_SUPPORTED"),
+    540: .same(proto: "SQL_SUPPORTED_UNIONS"),
+    541: .same(proto: "SQL_MAX_BINARY_LITERAL_LENGTH"),
+    542: .same(proto: "SQL_MAX_CHAR_LITERAL_LENGTH"),
+    543: .same(proto: "SQL_MAX_COLUMN_NAME_LENGTH"),
+    544: .same(proto: "SQL_MAX_COLUMNS_IN_GROUP_BY"),
+    545: .same(proto: "SQL_MAX_COLUMNS_IN_INDEX"),
+    546: .same(proto: "SQL_MAX_COLUMNS_IN_ORDER_BY"),
+    547: .same(proto: "SQL_MAX_COLUMNS_IN_SELECT"),
+    548: .same(proto: "SQL_MAX_COLUMNS_IN_TABLE"),
+    549: .same(proto: "SQL_MAX_CONNECTIONS"),
+    550: .same(proto: "SQL_MAX_CURSOR_NAME_LENGTH"),
+    551: .same(proto: "SQL_MAX_INDEX_LENGTH"),
+    552: .same(proto: "SQL_DB_SCHEMA_NAME_LENGTH"),
+    553: .same(proto: "SQL_MAX_PROCEDURE_NAME_LENGTH"),
+    554: .same(proto: "SQL_MAX_CATALOG_NAME_LENGTH"),
+    555: .same(proto: "SQL_MAX_ROW_SIZE"),
+    556: .same(proto: "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS"),
+    557: .same(proto: "SQL_MAX_STATEMENT_LENGTH"),
+    558: .same(proto: "SQL_MAX_STATEMENTS"),
+    559: .same(proto: "SQL_MAX_TABLE_NAME_LENGTH"),
+    560: .same(proto: "SQL_MAX_TABLES_IN_SELECT"),
+    561: .same(proto: "SQL_MAX_USERNAME_LENGTH"),
+    562: .same(proto: "SQL_DEFAULT_TRANSACTION_ISOLATION"),
+    563: .same(proto: "SQL_TRANSACTIONS_SUPPORTED"),
+    564: .same(proto: "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS"),
+    565: .same(proto: "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT"),
+    566: .same(proto: "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED"),
+    567: .same(proto: "SQL_SUPPORTED_RESULT_SET_TYPES"),
+    568: .same(proto: "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED"),
+    569: .same(proto: "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY"),
+    570: .same(proto: "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE"),
+    571: .same(proto: "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE"),
+    572: .same(proto: "SQL_BATCH_UPDATES_SUPPORTED"),
+    573: .same(proto: "SQL_SAVEPOINTS_SUPPORTED"),
+    574: .same(proto: "SQL_NAMED_PARAMETERS_SUPPORTED"),
+    575: .same(proto: "SQL_LOCATORS_UPDATE_COPY"),
+    576: .same(proto: "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransaction: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_SUPPORTED_TRANSACTION_NONE"),
+    1: .same(proto: "SQL_SUPPORTED_TRANSACTION_TRANSACTION"),
+    2: .same(proto: "SQL_SUPPORTED_TRANSACTION_SAVEPOINT"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedCaseSensitivity: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_CASE_SENSITIVITY_UNKNOWN"),
+    1: .same(proto: "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE"),
+    2: .same(proto: "SQL_CASE_SENSITIVITY_UPPERCASE"),
+    3: .same(proto: "SQL_CASE_SENSITIVITY_LOWERCASE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlNullOrdering: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_NULLS_SORTED_HIGH"),
+    1: .same(proto: "SQL_NULLS_SORTED_LOW"),
+    2: .same(proto: "SQL_NULLS_SORTED_AT_START"),
+    3: .same(proto: "SQL_NULLS_SORTED_AT_END"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SupportedSqlGrammar: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_MINIMUM_GRAMMAR"),
+    1: .same(proto: "SQL_CORE_GRAMMAR"),
+    2: .same(proto: "SQL_EXTENDED_GRAMMAR"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SupportedAnsi92SqlGrammarLevel: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "ANSI92_ENTRY_SQL"),
+    1: .same(proto: "ANSI92_INTERMEDIATE_SQL"),
+    2: .same(proto: "ANSI92_FULL_SQL"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlOuterJoinsSupportLevel: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_JOINS_UNSUPPORTED"),
+    1: .same(proto: "SQL_LIMITED_OUTER_JOINS"),
+    2: .same(proto: "SQL_FULL_OUTER_JOINS"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedGroupBy: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_GROUP_BY_UNRELATED"),
+    1: .same(proto: "SQL_GROUP_BY_BEYOND_SELECT"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedElementActions: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_ELEMENT_IN_PROCEDURE_CALLS"),
+    1: .same(proto: "SQL_ELEMENT_IN_INDEX_DEFINITIONS"),
+    2: .same(proto: "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedPositionedCommands: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_POSITIONED_DELETE"),
+    1: .same(proto: "SQL_POSITIONED_UPDATE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedSubqueries: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_SUBQUERIES_IN_COMPARISONS"),
+    1: .same(proto: "SQL_SUBQUERIES_IN_EXISTS"),
+    2: .same(proto: "SQL_SUBQUERIES_IN_INS"),
+    3: .same(proto: "SQL_SUBQUERIES_IN_QUANTIFIEDS"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedUnions: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_UNION"),
+    1: .same(proto: "SQL_UNION_ALL"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlTransactionIsolationLevel: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_TRANSACTION_NONE"),
+    1: .same(proto: "SQL_TRANSACTION_READ_UNCOMMITTED"),
+    2: .same(proto: "SQL_TRANSACTION_READ_COMMITTED"),
+    3: .same(proto: "SQL_TRANSACTION_REPEATABLE_READ"),
+    4: .same(proto: "SQL_TRANSACTION_SERIALIZABLE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedTransactions: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_TRANSACTION_UNSPECIFIED"),
+    1: .same(proto: "SQL_DATA_DEFINITION_TRANSACTIONS"),
+    2: .same(proto: "SQL_DATA_MANIPULATION_TRANSACTIONS"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetType: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_RESULT_SET_TYPE_UNSPECIFIED"),
+    1: .same(proto: "SQL_RESULT_SET_TYPE_FORWARD_ONLY"),
+    2: .same(proto: "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE"),
+    3: .same(proto: "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportedResultSetConcurrency: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED"),
+    1: .same(proto: "SQL_RESULT_SET_CONCURRENCY_READ_ONLY"),
+    2: .same(proto: "SQL_RESULT_SET_CONCURRENCY_UPDATABLE"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_SqlSupportsConvert: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SQL_CONVERT_BIGINT"),
+    1: .same(proto: "SQL_CONVERT_BINARY"),
+    2: .same(proto: "SQL_CONVERT_BIT"),
+    3: .same(proto: "SQL_CONVERT_CHAR"),
+    4: .same(proto: "SQL_CONVERT_DATE"),
+    5: .same(proto: "SQL_CONVERT_DECIMAL"),
+    6: .same(proto: "SQL_CONVERT_FLOAT"),
+    7: .same(proto: "SQL_CONVERT_INTEGER"),
+    8: .same(proto: "SQL_CONVERT_INTERVAL_DAY_TIME"),
+    9: .same(proto: "SQL_CONVERT_INTERVAL_YEAR_MONTH"),
+    10: .same(proto: "SQL_CONVERT_LONGVARBINARY"),
+    11: .same(proto: "SQL_CONVERT_LONGVARCHAR"),
+    12: .same(proto: "SQL_CONVERT_NUMERIC"),
+    13: .same(proto: "SQL_CONVERT_REAL"),
+    14: .same(proto: "SQL_CONVERT_SMALLINT"),
+    15: .same(proto: "SQL_CONVERT_TIME"),
+    16: .same(proto: "SQL_CONVERT_TIMESTAMP"),
+    17: .same(proto: "SQL_CONVERT_TINYINT"),
+    18: .same(proto: "SQL_CONVERT_VARBINARY"),
+    19: .same(proto: "SQL_CONVERT_VARCHAR"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_XdbcDataType: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    -9: .same(proto: "XDBC_WVARCHAR"),
+    -8: .same(proto: "XDBC_WCHAR"),
+    -7: .same(proto: "XDBC_BIT"),
+    -6: .same(proto: "XDBC_TINYINT"),
+    -5: .same(proto: "XDBC_BIGINT"),
+    -4: .same(proto: "XDBC_LONGVARBINARY"),
+    -3: .same(proto: "XDBC_VARBINARY"),
+    -2: .same(proto: "XDBC_BINARY"),
+    -1: .same(proto: "XDBC_LONGVARCHAR"),
+    0: .same(proto: "XDBC_UNKNOWN_TYPE"),
+    1: .same(proto: "XDBC_CHAR"),
+    2: .same(proto: "XDBC_NUMERIC"),
+    3: .same(proto: "XDBC_DECIMAL"),
+    4: .same(proto: "XDBC_INTEGER"),
+    5: .same(proto: "XDBC_SMALLINT"),
+    6: .same(proto: "XDBC_FLOAT"),
+    7: .same(proto: "XDBC_REAL"),
+    8: .same(proto: "XDBC_DOUBLE"),
+    9: .same(proto: "XDBC_DATETIME"),
+    10: .same(proto: "XDBC_INTERVAL"),
+    12: .same(proto: "XDBC_VARCHAR"),
+    91: .same(proto: "XDBC_DATE"),
+    92: .same(proto: "XDBC_TIME"),
+    93: .same(proto: "XDBC_TIMESTAMP"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_XdbcDatetimeSubcode: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "XDBC_SUBCODE_UNKNOWN"),
+    1: .aliased(proto: "XDBC_SUBCODE_YEAR", aliases: ["XDBC_SUBCODE_DATE"]),
+    2: .aliased(proto: "XDBC_SUBCODE_TIME", aliases: ["XDBC_SUBCODE_MONTH"]),
+    3: .aliased(proto: "XDBC_SUBCODE_TIMESTAMP", aliases: ["XDBC_SUBCODE_DAY"]),
+    4: .aliased(proto: "XDBC_SUBCODE_TIME_WITH_TIMEZONE", aliases: ["XDBC_SUBCODE_HOUR"]),
+    5: .aliased(proto: "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE", aliases: ["XDBC_SUBCODE_MINUTE"]),
+    6: .same(proto: "XDBC_SUBCODE_SECOND"),
+    7: .same(proto: "XDBC_SUBCODE_YEAR_TO_MONTH"),
+    8: .same(proto: "XDBC_SUBCODE_DAY_TO_HOUR"),
+    9: .same(proto: "XDBC_SUBCODE_DAY_TO_MINUTE"),
+    10: .same(proto: "XDBC_SUBCODE_DAY_TO_SECOND"),
+    11: .same(proto: "XDBC_SUBCODE_HOUR_TO_MINUTE"),
+    12: .same(proto: "XDBC_SUBCODE_HOUR_TO_SECOND"),
+    13: .same(proto: "XDBC_SUBCODE_MINUTE_TO_SECOND"),
+    101: .same(proto: "XDBC_SUBCODE_INTERVAL_YEAR"),
+    102: .same(proto: "XDBC_SUBCODE_INTERVAL_MONTH"),
+    103: .same(proto: "XDBC_SUBCODE_INTERVAL_DAY"),
+    104: .same(proto: "XDBC_SUBCODE_INTERVAL_HOUR"),
+    105: .same(proto: "XDBC_SUBCODE_INTERVAL_MINUTE"),
+    106: .same(proto: "XDBC_SUBCODE_INTERVAL_SECOND"),
+    107: .same(proto: "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH"),
+    108: .same(proto: "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR"),
+    109: .same(proto: "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE"),
+    110: .same(proto: "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND"),
+    111: .same(proto: "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE"),
+    112: .same(proto: "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND"),
+    113: .same(proto: "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_Nullable: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "NULLABILITY_NO_NULLS"),
+    1: .same(proto: "NULLABILITY_NULLABLE"),
+    2: .same(proto: "NULLABILITY_UNKNOWN"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_Searchable: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "SEARCHABLE_NONE"),
+    1: .same(proto: "SEARCHABLE_CHAR"),
+    2: .same(proto: "SEARCHABLE_BASIC"),
+    3: .same(proto: "SEARCHABLE_FULL"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_UpdateDeleteRules: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "CASCADE"),
+    1: .same(proto: "RESTRICT"),
+    2: .same(proto: "SET_NULL"),
+    3: .same(proto: "NO_ACTION"),
+    4: .same(proto: "SET_DEFAULT"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetSqlInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetSqlInfo"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "info"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeRepeatedUInt32Field(value: &self.info) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.info.isEmpty {
+      try visitor.visitPackedUInt32Field(value: self.info, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetSqlInfo, rhs: Arrow_Flight_Protocol_Sql_CommandGetSqlInfo) -> Bool {
+    if lhs.info != rhs.info {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetXdbcTypeInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetXdbcTypeInfo"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "data_type"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt32Field(value: &self._dataType) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._dataType {
+      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetXdbcTypeInfo, rhs: Arrow_Flight_Protocol_Sql_CommandGetXdbcTypeInfo) -> Bool {
+    if lhs._dataType != rhs._dataType {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetCatalogs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetCatalogs"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetCatalogs, rhs: Arrow_Flight_Protocol_Sql_CommandGetCatalogs) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetDbSchemas: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetDbSchemas"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "catalog"),
+    2: .standard(proto: "db_schema_filter_pattern"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._catalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._dbSchemaFilterPattern) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._catalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._dbSchemaFilterPattern {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetDbSchemas, rhs: Arrow_Flight_Protocol_Sql_CommandGetDbSchemas) -> Bool {
+    if lhs._catalog != rhs._catalog {return false}
+    if lhs._dbSchemaFilterPattern != rhs._dbSchemaFilterPattern {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetTables: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetTables"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "catalog"),
+    2: .standard(proto: "db_schema_filter_pattern"),
+    3: .standard(proto: "table_name_filter_pattern"),
+    4: .standard(proto: "table_types"),
+    5: .standard(proto: "include_schema"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._catalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._dbSchemaFilterPattern) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self._tableNameFilterPattern) }()
+      case 4: try { try decoder.decodeRepeatedStringField(value: &self.tableTypes) }()
+      case 5: try { try decoder.decodeSingularBoolField(value: &self.includeSchema) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._catalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._dbSchemaFilterPattern {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    try { if let v = self._tableNameFilterPattern {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 3)
+    } }()
+    if !self.tableTypes.isEmpty {
+      try visitor.visitRepeatedStringField(value: self.tableTypes, fieldNumber: 4)
+    }
+    if self.includeSchema != false {
+      try visitor.visitSingularBoolField(value: self.includeSchema, fieldNumber: 5)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetTables, rhs: Arrow_Flight_Protocol_Sql_CommandGetTables) -> Bool {
+    if lhs._catalog != rhs._catalog {return false}
+    if lhs._dbSchemaFilterPattern != rhs._dbSchemaFilterPattern {return false}
+    if lhs._tableNameFilterPattern != rhs._tableNameFilterPattern {return false}
+    if lhs.tableTypes != rhs.tableTypes {return false}
+    if lhs.includeSchema != rhs.includeSchema {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetTableTypes: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetTableTypes"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetTableTypes, rhs: Arrow_Flight_Protocol_Sql_CommandGetTableTypes) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetPrimaryKeys: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetPrimaryKeys"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "catalog"),
+    2: .standard(proto: "db_schema"),
+    3: .same(proto: "table"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._catalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._dbSchema) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.table) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._catalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._dbSchema {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    if !self.table.isEmpty {
+      try visitor.visitSingularStringField(value: self.table, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetPrimaryKeys, rhs: Arrow_Flight_Protocol_Sql_CommandGetPrimaryKeys) -> Bool {
+    if lhs._catalog != rhs._catalog {return false}
+    if lhs._dbSchema != rhs._dbSchema {return false}
+    if lhs.table != rhs.table {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetExportedKeys: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetExportedKeys"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "catalog"),
+    2: .standard(proto: "db_schema"),
+    3: .same(proto: "table"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._catalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._dbSchema) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.table) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._catalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._dbSchema {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    if !self.table.isEmpty {
+      try visitor.visitSingularStringField(value: self.table, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetExportedKeys, rhs: Arrow_Flight_Protocol_Sql_CommandGetExportedKeys) -> Bool {
+    if lhs._catalog != rhs._catalog {return false}
+    if lhs._dbSchema != rhs._dbSchema {return false}
+    if lhs.table != rhs.table {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetImportedKeys: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetImportedKeys"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "catalog"),
+    2: .standard(proto: "db_schema"),
+    3: .same(proto: "table"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._catalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._dbSchema) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.table) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._catalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._dbSchema {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    if !self.table.isEmpty {
+      try visitor.visitSingularStringField(value: self.table, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetImportedKeys, rhs: Arrow_Flight_Protocol_Sql_CommandGetImportedKeys) -> Bool {
+    if lhs._catalog != rhs._catalog {return false}
+    if lhs._dbSchema != rhs._dbSchema {return false}
+    if lhs.table != rhs.table {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandGetCrossReference: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandGetCrossReference"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "pk_catalog"),
+    2: .standard(proto: "pk_db_schema"),
+    3: .standard(proto: "pk_table"),
+    4: .standard(proto: "fk_catalog"),
+    5: .standard(proto: "fk_db_schema"),
+    6: .standard(proto: "fk_table"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self._pkCatalog) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self._pkDbSchema) }()
+      case 3: try { try decoder.decodeSingularStringField(value: &self.pkTable) }()
+      case 4: try { try decoder.decodeSingularStringField(value: &self._fkCatalog) }()
+      case 5: try { try decoder.decodeSingularStringField(value: &self._fkDbSchema) }()
+      case 6: try { try decoder.decodeSingularStringField(value: &self.fkTable) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._pkCatalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._pkDbSchema {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 2)
+    } }()
+    if !self.pkTable.isEmpty {
+      try visitor.visitSingularStringField(value: self.pkTable, fieldNumber: 3)
+    }
+    try { if let v = self._fkCatalog {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 4)
+    } }()
+    try { if let v = self._fkDbSchema {
+      try visitor.visitSingularStringField(value: v, fieldNumber: 5)
+    } }()
+    if !self.fkTable.isEmpty {
+      try visitor.visitSingularStringField(value: self.fkTable, fieldNumber: 6)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandGetCrossReference, rhs: Arrow_Flight_Protocol_Sql_CommandGetCrossReference) -> Bool {
+    if lhs._pkCatalog != rhs._pkCatalog {return false}
+    if lhs._pkDbSchema != rhs._pkDbSchema {return false}
+    if lhs.pkTable != rhs.pkTable {return false}
+    if lhs._fkCatalog != rhs._fkCatalog {return false}
+    if lhs._fkDbSchema != rhs._fkDbSchema {return false}
+    if lhs.fkTable != rhs.fkTable {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionCreatePreparedStatementRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "query"),
+    2: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.query) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    if !self.query.isEmpty {
+      try visitor.visitSingularStringField(value: self.query, fieldNumber: 1)
+    }
+    try { if let v = self._transactionID {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementRequest, rhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementRequest) -> Bool {
+    if lhs.query != rhs.query {return false}
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_SubstraitPlan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".SubstraitPlan"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "plan"),
+    2: .same(proto: "version"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.plan) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.version) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.plan.isEmpty {
+      try visitor.visitSingularBytesField(value: self.plan, fieldNumber: 1)
+    }
+    if !self.version.isEmpty {
+      try visitor.visitSingularStringField(value: self.version, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_SubstraitPlan, rhs: Arrow_Flight_Protocol_Sql_SubstraitPlan) -> Bool {
+    if lhs.plan != rhs.plan {return false}
+    if lhs.version != rhs.version {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedSubstraitPlanRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionCreatePreparedSubstraitPlanRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "plan"),
+    2: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._plan) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._plan {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._transactionID {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedSubstraitPlanRequest, rhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedSubstraitPlanRequest) -> Bool {
+    if lhs._plan != rhs._plan {return false}
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionCreatePreparedStatementResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "prepared_statement_handle"),
+    2: .standard(proto: "dataset_schema"),
+    3: .standard(proto: "parameter_schema"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.preparedStatementHandle) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self.datasetSchema) }()
+      case 3: try { try decoder.decodeSingularBytesField(value: &self.parameterSchema) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.preparedStatementHandle.isEmpty {
+      try visitor.visitSingularBytesField(value: self.preparedStatementHandle, fieldNumber: 1)
+    }
+    if !self.datasetSchema.isEmpty {
+      try visitor.visitSingularBytesField(value: self.datasetSchema, fieldNumber: 2)
+    }
+    if !self.parameterSchema.isEmpty {
+      try visitor.visitSingularBytesField(value: self.parameterSchema, fieldNumber: 3)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementResult, rhs: Arrow_Flight_Protocol_Sql_ActionCreatePreparedStatementResult) -> Bool {
+    if lhs.preparedStatementHandle != rhs.preparedStatementHandle {return false}
+    if lhs.datasetSchema != rhs.datasetSchema {return false}
+    if lhs.parameterSchema != rhs.parameterSchema {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionClosePreparedStatementRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionClosePreparedStatementRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "prepared_statement_handle"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.preparedStatementHandle) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.preparedStatementHandle.isEmpty {
+      try visitor.visitSingularBytesField(value: self.preparedStatementHandle, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionClosePreparedStatementRequest, rhs: Arrow_Flight_Protocol_Sql_ActionClosePreparedStatementRequest) -> Bool {
+    if lhs.preparedStatementHandle != rhs.preparedStatementHandle {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionBeginTransactionRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionBeginTransactionRequest"
+  static let _protobuf_nameMap = SwiftProtobuf._NameMap()
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let _ = try decoder.nextFieldNumber() {
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionBeginTransactionRequest, rhs: Arrow_Flight_Protocol_Sql_ActionBeginTransactionRequest) -> Bool {
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionBeginSavepointRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionBeginSavepointRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "transaction_id"),
+    2: .same(proto: "name"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.transactionID) }()
+      case 2: try { try decoder.decodeSingularStringField(value: &self.name) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.transactionID.isEmpty {
+      try visitor.visitSingularBytesField(value: self.transactionID, fieldNumber: 1)
+    }
+    if !self.name.isEmpty {
+      try visitor.visitSingularStringField(value: self.name, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionBeginSavepointRequest, rhs: Arrow_Flight_Protocol_Sql_ActionBeginSavepointRequest) -> Bool {
+    if lhs.transactionID != rhs.transactionID {return false}
+    if lhs.name != rhs.name {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionBeginTransactionResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionBeginTransactionResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.transactionID.isEmpty {
+      try visitor.visitSingularBytesField(value: self.transactionID, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionBeginTransactionResult, rhs: Arrow_Flight_Protocol_Sql_ActionBeginTransactionResult) -> Bool {
+    if lhs.transactionID != rhs.transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionBeginSavepointResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionBeginSavepointResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "savepoint_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.savepointID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.savepointID.isEmpty {
+      try visitor.visitSingularBytesField(value: self.savepointID, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionBeginSavepointResult, rhs: Arrow_Flight_Protocol_Sql_ActionBeginSavepointResult) -> Bool {
+    if lhs.savepointID != rhs.savepointID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionEndTransactionRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "transaction_id"),
+    2: .same(proto: "action"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.transactionID) }()
+      case 2: try { try decoder.decodeSingularEnumField(value: &self.action) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.transactionID.isEmpty {
+      try visitor.visitSingularBytesField(value: self.transactionID, fieldNumber: 1)
+    }
+    if self.action != .unspecified {
+      try visitor.visitSingularEnumField(value: self.action, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest, rhs: Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest) -> Bool {
+    if lhs.transactionID != rhs.transactionID {return false}
+    if lhs.action != rhs.action {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionEndTransactionRequest.EndTransaction: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "END_TRANSACTION_UNSPECIFIED"),
+    1: .same(proto: "END_TRANSACTION_COMMIT"),
+    2: .same(proto: "END_TRANSACTION_ROLLBACK"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionEndSavepointRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "savepoint_id"),
+    2: .same(proto: "action"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.savepointID) }()
+      case 2: try { try decoder.decodeSingularEnumField(value: &self.action) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.savepointID.isEmpty {
+      try visitor.visitSingularBytesField(value: self.savepointID, fieldNumber: 1)
+    }
+    if self.action != .unspecified {
+      try visitor.visitSingularEnumField(value: self.action, fieldNumber: 2)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest, rhs: Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest) -> Bool {
+    if lhs.savepointID != rhs.savepointID {return false}
+    if lhs.action != rhs.action {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionEndSavepointRequest.EndSavepoint: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "END_SAVEPOINT_UNSPECIFIED"),
+    1: .same(proto: "END_SAVEPOINT_RELEASE"),
+    2: .same(proto: "END_SAVEPOINT_ROLLBACK"),
+  ]
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandStatementQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandStatementQuery"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "query"),
+    2: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.query) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    if !self.query.isEmpty {
+      try visitor.visitSingularStringField(value: self.query, fieldNumber: 1)
+    }
+    try { if let v = self._transactionID {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandStatementQuery, rhs: Arrow_Flight_Protocol_Sql_CommandStatementQuery) -> Bool {
+    if lhs.query != rhs.query {return false}
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandStatementSubstraitPlan: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandStatementSubstraitPlan"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "plan"),
+    2: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularMessageField(value: &self._plan) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    try { if let v = self._plan {
+      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
+    } }()
+    try { if let v = self._transactionID {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandStatementSubstraitPlan, rhs: Arrow_Flight_Protocol_Sql_CommandStatementSubstraitPlan) -> Bool {
+    if lhs._plan != rhs._plan {return false}
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_TicketStatementQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".TicketStatementQuery"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "statement_handle"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.statementHandle) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.statementHandle.isEmpty {
+      try visitor.visitSingularBytesField(value: self.statementHandle, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_TicketStatementQuery, rhs: Arrow_Flight_Protocol_Sql_TicketStatementQuery) -> Bool {
+    if lhs.statementHandle != rhs.statementHandle {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandPreparedStatementQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandPreparedStatementQuery"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "prepared_statement_handle"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.preparedStatementHandle) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.preparedStatementHandle.isEmpty {
+      try visitor.visitSingularBytesField(value: self.preparedStatementHandle, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandPreparedStatementQuery, rhs: Arrow_Flight_Protocol_Sql_CommandPreparedStatementQuery) -> Bool {
+    if lhs.preparedStatementHandle != rhs.preparedStatementHandle {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandStatementUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandStatementUpdate"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "query"),
+    2: .standard(proto: "transaction_id"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularStringField(value: &self.query) }()
+      case 2: try { try decoder.decodeSingularBytesField(value: &self._transactionID) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    // The use of inline closures is to circumvent an issue where the compiler
+    // allocates stack space for every if/case branch local when no optimizations
+    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
+    // https://github.com/apple/swift-protobuf/issues/1182
+    if !self.query.isEmpty {
+      try visitor.visitSingularStringField(value: self.query, fieldNumber: 1)
+    }
+    try { if let v = self._transactionID {
+      try visitor.visitSingularBytesField(value: v, fieldNumber: 2)
+    } }()
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandStatementUpdate, rhs: Arrow_Flight_Protocol_Sql_CommandStatementUpdate) -> Bool {
+    if lhs.query != rhs.query {return false}
+    if lhs._transactionID != rhs._transactionID {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_CommandPreparedStatementUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".CommandPreparedStatementUpdate"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "prepared_statement_handle"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.preparedStatementHandle) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.preparedStatementHandle.isEmpty {
+      try visitor.visitSingularBytesField(value: self.preparedStatementHandle, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_CommandPreparedStatementUpdate, rhs: Arrow_Flight_Protocol_Sql_CommandPreparedStatementUpdate) -> Bool {
+    if lhs.preparedStatementHandle != rhs.preparedStatementHandle {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_DoPutUpdateResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".DoPutUpdateResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .standard(proto: "record_count"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularInt64Field(value: &self.recordCount) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.recordCount != 0 {
+      try visitor.visitSingularInt64Field(value: self.recordCount, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_DoPutUpdateResult, rhs: Arrow_Flight_Protocol_Sql_DoPutUpdateResult) -> Bool {
+    if lhs.recordCount != rhs.recordCount {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryRequest: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionCancelQueryRequest"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "info"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularBytesField(value: &self.info) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if !self.info.isEmpty {
+      try visitor.visitSingularBytesField(value: self.info, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionCancelQueryRequest, rhs: Arrow_Flight_Protocol_Sql_ActionCancelQueryRequest) -> Bool {
+    if lhs.info != rhs.info {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
+  static let protoMessageName: String = _protobuf_package + ".ActionCancelQueryResult"
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    1: .same(proto: "result"),
+  ]
+
+  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
+    while let fieldNumber = try decoder.nextFieldNumber() {
+      // The use of inline closures is to circumvent an issue where the compiler
+      // allocates stack space for every case branch when no optimizations are
+      // enabled. https://github.com/apple/swift-protobuf/issues/1034
+      switch fieldNumber {
+      case 1: try { try decoder.decodeSingularEnumField(value: &self.result) }()
+      default: break
+      }
+    }
+  }
+
+  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
+    if self.result != .unspecified {
+      try visitor.visitSingularEnumField(value: self.result, fieldNumber: 1)
+    }
+    try unknownFields.traverse(visitor: &visitor)
+  }
+
+  static func ==(lhs: Arrow_Flight_Protocol_Sql_ActionCancelQueryResult, rhs: Arrow_Flight_Protocol_Sql_ActionCancelQueryResult) -> Bool {
+    if lhs.result != rhs.result {return false}
+    if lhs.unknownFields != rhs.unknownFields {return false}
+    return true
+  }
+}
+
+extension Arrow_Flight_Protocol_Sql_ActionCancelQueryResult.CancelResult: SwiftProtobuf._ProtoNameProviding {
+  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
+    0: .same(proto: "CANCEL_RESULT_UNSPECIFIED"),
+    1: .same(proto: "CANCEL_RESULT_CANCELLED"),
+    2: .same(proto: "CANCEL_RESULT_CANCELLING"),
+    3: .same(proto: "CANCEL_RESULT_NOT_CANCELLABLE"),
+  ]
+}
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
index f0054a2577e3f..972d19435ddfc 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamReader.swift
@@ -21,9 +21,10 @@ import GRPC
 
 public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
     public typealias AsyncIterator = RecordBatchStreamReader
-    public typealias Element = RecordBatch
+    public typealias Element = (Arrow.RecordBatch?, FlightDescriptor?)
     let reader = ArrowReader()
     var batches = [RecordBatch]()
+    var descriptor: FlightDescriptor?
     var batchIndex = 0
     var streamIterator: any AsyncIteratorProtocol
     let stream: GRPC.GRPCAsyncRequestStream<Arrow_Flight_Protocol_FlightData>
@@ -32,7 +33,7 @@ public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
         self.streamIterator = self.stream.makeAsyncIterator()
     }
 
-    public func next() async throws -> Arrow.RecordBatch? {
+    public func next() async throws -> (Arrow.RecordBatch?, FlightDescriptor?)? {
         guard !Task.isCancelled else {
             return nil
         }
@@ -40,26 +41,29 @@ public class RecordBatchStreamReader: AsyncSequence, AsyncIteratorProtocol {
         if batchIndex < batches.count {
             let batch = batches[batchIndex]
             batchIndex += 1
-            return batch
+            return (batch, descriptor)
         }
 
+        let result = ArrowReader.makeArrowReaderResult()
         while true {
-            let flightData = try await self.streamIterator.next()
-            if flightData == nil {
+            let streamData = try await self.streamIterator.next()
+            if streamData == nil {
                 return nil
             }
 
-            if let data = (flightData as? Arrow_Flight_Protocol_FlightData)?.dataBody {
-                switch reader.fromStream(data) {
-                case .success(let rbResult):
-                    batches = rbResult.batches
+            let flightData = (streamData as? Arrow_Flight_Protocol_FlightData)!
+            let dataBody = flightData.dataBody
+            let dataHeader = flightData.dataHeader
+            descriptor = FlightDescriptor(flightData.flightDescriptor)
+            switch reader.fromMessage(dataHeader, dataBody: dataBody, result: result) {
+            case .success(()):
+                if result.batches.count > 0 {
+                    batches = result.batches
                     batchIndex = 1
-                    return batches[0]
-                case .failure(let error):
-                    throw error
+                    return (batches[0], descriptor)
                 }
-            } else {
-                throw ArrowError.invalid("Flight data is incorrect type.")
+            case .failure(let error):
+                throw error
             }
         }
     }
diff --git a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
index 94fc0e91dff07..d3e03fe17ceb0 100644
--- a/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
+++ b/swift/ArrowFlight/Sources/ArrowFlight/RecordBatchStreamWriter.swift
@@ -71,19 +71,24 @@ public class RecordBatchStreamWriter {
     }
 
     public func write(_ rb: RecordBatch) async throws {
-        let info = ArrowWriter.Info(.recordbatch,
-                                    schema: rb.schema,
-                                    batches: [rb]
-        )
-
-        let result = writer.toStream(info)
-        switch result {
-        case .success(let rbResult):
-            let data = Arrow_Flight_Protocol_FlightData.with {
-                $0.dataBody = rbResult
+        switch writer.toMessage(rb.schema) {
+        case .success(let schemaData):
+            let schemaFlightData = Arrow_Flight_Protocol_FlightData.with {
+                $0.dataHeader = schemaData
             }
 
-            try await self.stream.send(data)
+            try await self.stream.send(schemaFlightData)
+            switch writer.toMessage(rb) {
+            case .success(let recordMessages):
+                let rbMessage = Arrow_Flight_Protocol_FlightData.with {
+                    $0.dataHeader = recordMessages[0]
+                    $0.dataBody = recordMessages[1]
+                }
+
+                try await self.stream.send(rbMessage)
+            case .failure(let error):
+                throw error
+            }
         case .failure(let error):
             throw error
         }
diff --git a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
index 31dbcc1829a6a..db33dfc38734a 100644
--- a/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
+++ b/swift/ArrowFlight/Tests/ArrowFlightTests/FlightTest.swift
@@ -27,18 +27,18 @@ import Arrow
 
 func makeSchema() -> ArrowSchema {
     let schemaBuilder = ArrowSchema.Builder()
-    return schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowUInt8), isNullable: true)
+    return schemaBuilder.addField("col1", type: ArrowType(ArrowType.ArrowDouble), isNullable: true)
         .addField("col2", type: ArrowType(ArrowType.ArrowString), isNullable: false)
         .addField("col3", type: ArrowType(ArrowType.ArrowDate32), isNullable: false)
         .finish()
 }
 
 func makeRecordBatch() throws -> RecordBatch {
-    let uint8Builder: NumberArrayBuilder<UInt8> = try ArrowArrayBuilders.loadNumberArrayBuilder()
-    uint8Builder.append(10)
-    uint8Builder.append(22)
-    uint8Builder.append(33)
-    uint8Builder.append(44)
+    let doubleBuilder: NumberArrayBuilder<Double> = try ArrowArrayBuilders.loadNumberArrayBuilder()
+    doubleBuilder.append(11.11)
+    doubleBuilder.append(22.22)
+    doubleBuilder.append(33.33)
+    doubleBuilder.append(44.44)
     let stringBuilder = try ArrowArrayBuilders.loadStringArrayBuilder()
     stringBuilder.append("test10")
     stringBuilder.append("test22")
@@ -51,11 +51,11 @@ func makeRecordBatch() throws -> RecordBatch {
     date32Builder.append(date2)
     date32Builder.append(date1)
     date32Builder.append(date2)
-    let intHolder = ArrowArrayHolder(try uint8Builder.finish())
+    let doubleHolder = ArrowArrayHolder(try doubleBuilder.finish())
     let stringHolder = ArrowArrayHolder(try stringBuilder.finish())
     let date32Holder = ArrowArrayHolder(try date32Builder.finish())
     let result = RecordBatch.Builder()
-        .addColumn("col1", arrowArray: intHolder)
+        .addColumn("col1", arrowArray: doubleHolder)
         .addColumn("col2", arrowArray: stringHolder)
         .addColumn("col3", arrowArray: date32Holder)
         .finish()
@@ -67,12 +67,14 @@ func makeRecordBatch() throws -> RecordBatch {
     }
 }
 
+var flights = [String: FlightInfo]()
 final class MyFlightServer: ArrowFlightServer {
     func doExchange(
         _ reader: ArrowFlight.RecordBatchStreamReader,
         writer: ArrowFlight.RecordBatchStreamWriter) async throws {
         do {
-            for try await rb in reader {
+            for try await rbData in reader {
+                let rb = rbData.0!
                 XCTAssertEqual(rb.schema.fields.count, 3)
                 XCTAssertEqual(rb.length, 4)
             }
@@ -87,7 +89,10 @@ final class MyFlightServer: ArrowFlightServer {
     func doPut(
         _ reader: ArrowFlight.RecordBatchStreamReader,
         writer: ArrowFlight.PutResultDataStreamWriter) async throws {
-        for try await rb in reader {
+        for try await rbData in reader {
+            let rb = rbData.0!
+            let key = String(decoding: rbData.1!.cmd, as: UTF8.self)
+            flights[key] = try FlightInfo(schemaToMessage(rb.schema), endpoints: [], descriptor: rbData.1)
             XCTAssertEqual(rb.schema.fields.count, 3)
             XCTAssertEqual(rb.length, 4)
             try await writer.write(FlightPutResult())
@@ -101,27 +106,33 @@ final class MyFlightServer: ArrowFlightServer {
     func getSchema(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightSchemaResult {
         XCTAssertEqual(String(bytes: request.cmd, encoding: .utf8)!, "schema info")
         XCTAssertEqual(request.type, .cmd)
-        return try ArrowFlight.FlightSchemaResult(schemaToArrowStream(makeSchema()))
+        return try ArrowFlight.FlightSchemaResult(schemaToMessage(makeSchema()))
     }
 
     func getFlightInfo(_ request: ArrowFlight.FlightDescriptor) async throws -> ArrowFlight.FlightInfo {
-        return ArrowFlight.FlightInfo(Data())
+        let key = String(decoding: request.cmd, as: UTF8.self)
+        if flights[key] != nil {
+            return ArrowFlight.FlightInfo(flights[key]!.toProtocol())
+        }
+
+        throw ArrowFlightError.ioError("Flight not found")
     }
 
     func listFlights(_ criteria: ArrowFlight.FlightCriteria, writer: ArrowFlight.FlightInfoStreamWriter) async throws {
         XCTAssertEqual(String(bytes: criteria.expression, encoding: .utf8), "flight criteria expression")
-        let flightInfo = try ArrowFlight.FlightInfo(schemaToArrowStream(makeSchema()))
-        try await writer.write(flightInfo)
+        for flightData in flights {
+            try await writer.write(flightData.value)
+        }
     }
 
     func listActions(_ writer: ArrowFlight.ActionTypeStreamWriter) async throws {
-        try await writer.write(FlightActionType("type1", description: "desc1"))
-        try await writer.write(FlightActionType("type2", description: "desc2"))
+        try await writer.write(FlightActionType("clear", description: "Clear the stored flights."))
+        try await writer.write(FlightActionType("shutdown", description: "Shut down this server."))
     }
 
     func doAction(_ action: FlightAction, writer: ResultStreamWriter) async throws {
-        XCTAssertEqual(action.type, "test_action")
-        XCTAssertEqual(String(bytes: action.body, encoding: .utf8)!, "test_action body")
+        XCTAssertEqual(action.type, "healthcheck")
+        XCTAssertEqual(String(bytes: action.body, encoding: .utf8)!, "healthcheck body")
         try await writer.write(FlightResult("test_action result".data(using: .utf8)!))
     }
 }
@@ -180,26 +191,28 @@ public class FlightClientTester {
         })
 
         XCTAssertEqual(actionTypes.count, 2)
-        XCTAssertEqual(actionTypes[0].type, "type1")
-        XCTAssertEqual(actionTypes[0].description, "desc1")
-        XCTAssertEqual(actionTypes[1].type, "type2")
-        XCTAssertEqual(actionTypes[1].description, "desc2")
+
+        XCTAssertEqual(actionTypes[0].type, "clear")
+        XCTAssertEqual(actionTypes[0].description, "Clear the stored flights.")
+        XCTAssertEqual(actionTypes[1].type, "shutdown")
+        XCTAssertEqual(actionTypes[1].description, "Shut down this server.")
     }
 
     func listFlightsTest() async throws {
         let flightCriteria = FlightCriteria("flight criteria expression".data(using: .utf8)!)
         var numCalls = 0
         try await client?.listFlights(flightCriteria, closure: { data in
-            numCalls += 1
-            let schema = try streamToArrowSchema(data.schema)
-            XCTAssertEqual(schema.fields.count, 3)
+            if let schema = data.schema {
+                XCTAssertGreaterThanOrEqual(schema.fields.count, 0)
+                numCalls += 1
+            }
         })
 
-        XCTAssertEqual(numCalls, 1)
+        XCTAssertEqual(numCalls, 2)
     }
 
-    func doActionTest() async throws {
-        let action = FlightAction("test_action", body: "test_action body".data(using: .utf8)!)
+    func doActionTest(_ type: String, actionBody: Data) async throws {
+        let action = FlightAction(type, body: actionBody)
         var actionResults = [FlightResult]()
         try await client?.doAction(action, closure: { result in
             actionResults.append(result)
@@ -209,48 +222,63 @@ public class FlightClientTester {
         XCTAssertEqual(String(bytes: actionResults[0].body, encoding: .utf8), "test_action result")
     }
 
-    func getSchemaTest() async throws {
-        let descriptor = FlightDescriptor(cmd: "schema info".data(using: .utf8)!)
+    func getSchemaTest(_ cmd: Data) async throws {
+        let descriptor = FlightDescriptor(cmd: cmd)
         let schemaResult = try await client?.getSchema(descriptor)
-        let schema = try streamToArrowSchema(schemaResult!.schema)
+        let schema = schemaResult!.schema!
         XCTAssertEqual(schema.fields.count, 3)
     }
 
-    func doGetTest() async throws {
-        let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
+    func doGetTest(_ flightData: Data) async throws {
+        let ticket = FlightTicket(flightData)
         var numCall = 0
         try await client?.doGet(ticket, readerResultClosure: { rb in
             numCall += 1
             XCTAssertEqual(rb.schema!.fields.count, 3)
             XCTAssertEqual(rb.batches[0].length, 4)
+            switch ArrowTable.from(recordBatches: rb.batches) {
+            case .success(let table):
+                    for column in table.columns {
+                    switch column.type.id {
+                    case .double:
+                        let doubleArray = column.data() as? ChunkedArray<Double>
+                        XCTAssertNotNil(doubleArray)
+                        XCTAssertEqual(doubleArray?[0], 11.11)
+                        XCTAssertEqual(doubleArray?.asString(0), "11.11")
+                    default:
+                        continue
+                    }
+                }
+            case .failure(let error):
+                throw error
+            }
         })
 
         XCTAssertEqual(numCall, 1)
     }
 
-    func doGetTestFlightData() async throws {
-        let ticket = FlightTicket("flight_ticket test".data(using: .utf8)!)
+    func doGetTestFlightData(_ flightData: Data) async throws {
+        let ticket = FlightTicket(flightData)
         var numCall = 0
+        let reader = ArrowReader()
+        let arrowResult = ArrowReader.makeArrowReaderResult()
         try await client?.doGet(ticket, flightDataClosure: { flightData in
-            let reader = ArrowReader()
-            let result = reader.fromStream(flightData.dataBody)
-            switch result {
-            case .success(let rb):
-                XCTAssertEqual(rb.schema?.fields.count, 3)
-                XCTAssertEqual(rb.batches[0].length, 4)
+            switch reader.fromMessage(flightData.dataHeader, dataBody: flightData.dataBody, result: arrowResult) {
+            case .success:
                 numCall += 1
             case .failure(let error):
                 throw error
             }
         })
 
-        XCTAssertEqual(numCall, 1)
+        XCTAssertEqual(numCall, 2)
     }
 
-    func doPutTest() async throws {
+    func doPutTest(_ cmd: String) async throws {
+        let descriptor = FlightDescriptor(cmd: cmd.data(using: .utf8)!)
         let rb = try makeRecordBatch()
         var numCall = 0
-        try await client?.doPut([rb], closure: { _ in
+        try await client?.doPut(descriptor, recordBatchs: [rb], closure: { _ in
             numCall += 1
         })
 
@@ -258,9 +286,10 @@ public class FlightClientTester {
     }
 
     func doExchangeTest() async throws {
+        let descriptor = FlightDescriptor(cmd: "flight_ticket".data(using: .utf8)!)
         let rb = try makeRecordBatch()
         var numCall = 0
-        try await client?.doExchange([rb], closure: { result in
+        try await client?.doExchange(descriptor, recordBatchs: [rb], closure: { result in
             numCall += 1
             XCTAssertEqual(result.schema?.fields.count, 3)
             XCTAssertEqual(result.batches[0].length, 4)
@@ -311,12 +340,13 @@ final class FlightTest: XCTestCase {
 
             let clientImpl = try await FlightClientTester()
             try await clientImpl.listActionTest()
+            try await clientImpl.doPutTest("flight_ticket")
+            try await clientImpl.doPutTest("flight_another")
             try await clientImpl.listFlightsTest()
-            try await clientImpl.doActionTest()
-            try await clientImpl.getSchemaTest()
-            try await clientImpl.doGetTest()
-            try await clientImpl.doGetTestFlightData()
-            try await clientImpl.doPutTest()
+            try await clientImpl.doActionTest("healthcheck", actionBody: Data("healthcheck body".utf8))
+            try await clientImpl.getSchemaTest(Data("schema info".utf8))
+            try await clientImpl.doGetTest(Data("'flight_ticket'".utf8))
+            try await clientImpl.doGetTestFlightData(Data("'flight_another'".utf8))
             try await clientImpl.doExchangeTest()
             return "done"
         }

From c46fd24ededd0a0cd758e1a0dfb3a3e4fd4fbad4 Mon Sep 17 00:00:00 2001
From: Jiaxing Liang <58449896+sfc-gh-jliang@users.noreply.github.com>
Date: Thu, 26 Oct 2023 02:40:59 -0700
Subject: [PATCH 636/749] MINOR: [Python][Docs] Fix default for
 use_compliant_nested_type in parquet write_table docstring (#38471)

### Rationale for this change

the default value of use_compliant_nested_type is True

### What changes are included in this PR?

Change the comment from False to True

### Are these changes tested?
No, it just changed the comment

### Are there any user-facing changes?
No

Authored-by: Jiaxing Liang <58449896+sfc-gh-jliang@users.noreply.github.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/parquet/core.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pyarrow/parquet/core.py b/python/pyarrow/parquet/core.py
index 51ad955d19f78..072ab7fa11745 100644
--- a/python/pyarrow/parquet/core.py
+++ b/python/pyarrow/parquet/core.py
@@ -838,7 +838,7 @@ def _sanitize_table(table, new_schema, flavor):
 use_compliant_nested_type : bool, default True
     Whether to write compliant Parquet nested type (lists) as defined
     `here <https://github.com/apache/parquet-format/blob/master/
-    LogicalTypes.md#nested-types>`_, defaults to ``False``.
+    LogicalTypes.md#nested-types>`_, defaults to ``True``.
     For ``use_compliant_nested_type=True``, this will write into a list
     with 3-level structure where the middle level, named ``list``,
     is a repeated group with a single field named ``element``::

From 57f643c2cecca729109daae18c7a64f3a37e76e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Thu, 26 Oct 2023 08:34:21 -0600
Subject: [PATCH 637/749] GH-38022: [Java][FlightRPC] Expose app_metadata on
 FlightInfo and FlightEndpoint (#38331)

Making necessary changes in Java to expose the newly added app_metadata.
* Closes: #38022

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 dev/archery/archery/integration/runner.py     |   2 +-
 .../apache/arrow/flight/FlightEndpoint.java   |  81 +++++++++++-
 .../org/apache/arrow/flight/FlightInfo.java   | 123 +++++++++++++++++-
 .../arrow/flight/TestBasicOperation.java      |   9 +-
 .../arrow/flight/TestFlightService.java       |   5 +-
 ...AppMetadataFlightInfoEndpointScenario.java |  76 +++++++++++
 .../flight/integration/tests/Scenarios.java   |   1 +
 .../integration/tests/IntegrationTest.java    |   5 +
 8 files changed, 292 insertions(+), 10 deletions(-)
 create mode 100644 java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/AppMetadataFlightInfoEndpointScenario.java

diff --git a/dev/archery/archery/integration/runner.py b/dev/archery/archery/integration/runner.py
index 841633f94cdba..bab00e6d70d4a 100644
--- a/dev/archery/archery/integration/runner.py
+++ b/dev/archery/archery/integration/runner.py
@@ -615,7 +615,7 @@ def run_all_tests(with_cpp=True, with_java=True, with_js=True,
         Scenario(
             "app_metadata_flight_info_endpoint",
             description="Ensure support FlightInfo and Endpoint app_metadata",
-            skip_testers={"JS", "C#", "Rust", "Java"}
+            skip_testers={"JS", "C#", "Rust"}
         ),
         Scenario(
             "flight_sql",
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightEndpoint.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightEndpoint.java
index ad78cfbd210d4..1967fe1d91c34 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightEndpoint.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightEndpoint.java
@@ -23,6 +23,7 @@
 import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -30,6 +31,7 @@
 
 import org.apache.arrow.flight.impl.Flight;
 
+import com.google.protobuf.ByteString;
 import com.google.protobuf.Timestamp;
 
 /**
@@ -39,6 +41,7 @@ public class FlightEndpoint {
   private final List<Location> locations;
   private final Ticket ticket;
   private final Instant expirationTime;
+  private final byte[] appMetadata;
 
   /**
    * Constructs a new endpoint with no expiration time.
@@ -54,13 +57,22 @@ public FlightEndpoint(Ticket ticket, Location... locations) {
    * Constructs a new endpoint with an expiration time.
    *
    * @param ticket A ticket that describe the key of a data stream.
+   * @param expirationTime (optional) When this endpoint expires.
    * @param locations  The possible locations the stream can be retrieved from.
    */
   public FlightEndpoint(Ticket ticket, Instant expirationTime, Location... locations) {
+    this(ticket, expirationTime, null, Collections.unmodifiableList(new ArrayList<>(Arrays.asList(locations))));
+  }
+
+  /**
+   * Private constructor with all parameters. Should only be called by Builder.
+   */
+  private FlightEndpoint(Ticket ticket, Instant expirationTime, byte[] appMetadata, List<Location> locations) {
     Objects.requireNonNull(ticket);
-    this.locations = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(locations)));
+    this.locations = locations;
     this.expirationTime = expirationTime;
     this.ticket = ticket;
+    this.appMetadata = appMetadata;
   }
 
   /**
@@ -77,6 +89,7 @@ public FlightEndpoint(Ticket ticket, Instant expirationTime, Location... locatio
     } else {
       this.expirationTime = null;
     }
+    this.appMetadata = (flt.getAppMetadata().size() == 0 ? null : flt.getAppMetadata().toByteArray());
     this.ticket = new Ticket(flt.getTicket());
   }
 
@@ -92,6 +105,10 @@ public Optional<Instant> getExpirationTime() {
     return Optional.ofNullable(expirationTime);
   }
 
+  public byte[] getAppMetadata() {
+    return appMetadata;
+  }
+
   /**
    * Converts to the protocol buffer representation.
    */
@@ -111,6 +128,10 @@ Flight.FlightEndpoint toProtocol() {
               .build());
     }
 
+    if (appMetadata != null) {
+      b.setAppMetadata(ByteString.copyFrom(appMetadata));
+    }
+
     return b.build();
   }
 
@@ -148,12 +169,13 @@ public boolean equals(Object o) {
     FlightEndpoint that = (FlightEndpoint) o;
     return locations.equals(that.locations) &&
         ticket.equals(that.ticket) &&
-        Objects.equals(expirationTime, that.expirationTime);
+        Objects.equals(expirationTime, that.expirationTime) &&
+        Arrays.equals(appMetadata, that.appMetadata);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(locations, ticket, expirationTime);
+    return Objects.hash(locations, ticket, expirationTime, Arrays.hashCode(appMetadata));
   }
 
   @Override
@@ -162,6 +184,59 @@ public String toString() {
         "locations=" + locations +
         ", ticket=" + ticket +
         ", expirationTime=" + (expirationTime == null ? "(none)" : expirationTime.toString()) +
+        ", appMetadata=" + (appMetadata == null ? "(none)" : Base64.getEncoder().encodeToString(appMetadata)) +
         '}';
   }
+
+  /**
+   * Create a builder for FlightEndpoint.
+   *
+   * @param ticket A ticket that describe the key of a data stream.
+   * @param locations  The possible locations the stream can be retrieved from.
+   */
+  public static Builder builder(Ticket ticket, Location... locations) {
+    return new Builder(ticket, locations);
+  }
+
+  /**
+   * Builder for FlightEndpoint.
+   */
+  public static final class Builder {
+    private final Ticket ticket;
+    private final List<Location> locations;
+    private Instant expirationTime = null;
+    private byte[] appMetadata = null;
+
+    private Builder(Ticket ticket, Location... locations) {
+      this.ticket = ticket;
+      this.locations = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(locations)));
+    }
+
+    /**
+     * Set expiration time for the endpoint. Default is null, which means don't expire.
+     *
+     * @param expirationTime (optional) When this endpoint expires.
+     */
+    public Builder setExpirationTime(Instant expirationTime) {
+      this.expirationTime = expirationTime;
+      return this;
+    }
+
+    /**
+     * Set the app metadata to send along with the flight. Default is null;
+     *
+     * @param appMetadata Metadata to send along with the flight
+     */
+    public Builder setAppMetadata(byte[] appMetadata) {
+      this.appMetadata = appMetadata;
+      return this;
+    }
+
+    /**
+     * Build FlightEndpoint object.
+     */
+    public FlightEndpoint build() {
+      return new FlightEndpoint(ticket, expirationTime, appMetadata, locations);
+    }
+  }
 }
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
index d871f89465c83..b5279a304c865 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightInfo.java
@@ -23,6 +23,8 @@
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -51,6 +53,7 @@ public class FlightInfo {
   private final long records;
   private final boolean ordered;
   private final IpcOption option;
+  private final byte[] appMetadata;
 
   /**
    * Constructs a new instance.
@@ -94,6 +97,23 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
    */
   public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoint> endpoints, long bytes,
                     long records, boolean ordered, IpcOption option) {
+    this(schema, descriptor, endpoints, bytes, records, ordered, option, null);
+  }
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param schema The schema of the Flight
+   * @param descriptor An identifier for the Flight.
+   * @param endpoints A list of endpoints that have the flight available.
+   * @param bytes The number of bytes in the flight
+   * @param records The number of records in the flight.
+   * @param ordered Whether the endpoints in this flight are ordered.
+   * @param option IPC write options.
+   * @param appMetadata Metadata to send along with the flight
+   */
+  public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoint> endpoints, long bytes,
+                    long records, boolean ordered, IpcOption option, byte[] appMetadata) {
     Objects.requireNonNull(descriptor);
     Objects.requireNonNull(endpoints);
     if (schema != null) {
@@ -106,6 +126,7 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
     this.records = records;
     this.ordered = ordered;
     this.option = option;
+    this.appMetadata = appMetadata;
   }
 
   /**
@@ -131,6 +152,7 @@ public FlightInfo(Schema schema, FlightDescriptor descriptor, List<FlightEndpoin
     bytes = pbFlightInfo.getTotalBytes();
     records = pbFlightInfo.getTotalRecords();
     ordered = pbFlightInfo.getOrdered();
+    appMetadata = (pbFlightInfo.getAppMetadata().size() == 0 ? null : pbFlightInfo.getAppMetadata().toByteArray());
     option = IpcOption.DEFAULT;
   }
 
@@ -167,6 +189,10 @@ public boolean getOrdered() {
     return ordered;
   }
 
+  public byte[] getAppMetadata() {
+    return appMetadata;
+  }
+
   /**
    * Converts to the protocol buffer representation.
    */
@@ -189,6 +215,9 @@ Flight.FlightInfo toProtocol() {
         throw new RuntimeException(e);
       }
     }
+    if (appMetadata != null) {
+      builder.setAppMetadata(ByteString.copyFrom(appMetadata));
+    }
     return builder.build();
   }
 
@@ -229,12 +258,13 @@ public boolean equals(Object o) {
         schema.equals(that.schema) &&
         descriptor.equals(that.descriptor) &&
         endpoints.equals(that.endpoints) &&
-        ordered == that.ordered;
+        ordered == that.ordered &&
+        Arrays.equals(appMetadata, that.appMetadata);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(schema, descriptor, endpoints, bytes, records, ordered);
+    return Objects.hash(schema, descriptor, endpoints, bytes, records, ordered, Arrays.hashCode(appMetadata));
   }
 
   @Override
@@ -246,6 +276,95 @@ public String toString() {
         ", bytes=" + bytes +
         ", records=" + records +
         ", ordered=" + ordered +
+        ", appMetadata=" + (appMetadata == null ? "(none)" : Base64.getEncoder().encodeToString(appMetadata)) +
         '}';
   }
+
+  /**
+   * Create a builder for FlightInfo.
+   *
+   * @param schema     The schema of the Flight
+   * @param descriptor An identifier for the Flight.
+   * @param endpoints  A list of endpoints that have the flight available.
+   */
+  public static Builder builder(Schema schema, FlightDescriptor descriptor, List<FlightEndpoint> endpoints) {
+    return new Builder(schema, descriptor, endpoints);
+  }
+
+  /**
+   * Builder for FlightInfo.
+   */
+  public static final class Builder {
+    private final Schema schema;
+    private final FlightDescriptor descriptor;
+    private final List<FlightEndpoint> endpoints;
+    private long bytes = -1;
+    private long records = -1;
+    private boolean ordered = false;
+    private IpcOption option = IpcOption.DEFAULT;
+    private byte[] appMetadata = null;
+
+    private Builder(Schema schema, FlightDescriptor descriptor, List<FlightEndpoint> endpoints) {
+      this.schema = schema;
+      this.descriptor = descriptor;
+      this.endpoints = endpoints;
+    }
+
+    /**
+     * Set the number of bytes for the flight. Default to -1 for unknown.
+     *
+     * @param bytes The number of bytes in the flight
+     */
+    public Builder setBytes(long bytes) {
+      this.bytes = bytes;
+      return this;
+    }
+
+    /**
+     * Set the number of records for the flight. Default to -1 for unknown.
+     *
+     * @param records The number of records in the flight.
+     */
+    public Builder setRecords(long records) {
+      this.records = records;
+      return this;
+    }
+
+    /**
+     * Set whether the flight endpoints are ordered. Default is false.
+     *
+     * @param ordered Whether the endpoints in this flight are ordered.
+     */
+    public Builder setOrdered(boolean ordered) {
+      this.ordered = ordered;
+      return this;
+    }
+
+    /**
+     * Set IPC write options. Default is IpcOption.DEFAULT
+     *
+     * @param option IPC write options.
+     */
+    public Builder setOption(IpcOption option) {
+      this.option = option;
+      return this;
+    }
+
+    /**
+     * Set the app metadata to send along with the flight. Default is null.
+     *
+     * @param appMetadata Metadata to send along with the flight
+     */
+    public Builder setAppMetadata(byte[] appMetadata) {
+      this.appMetadata = appMetadata;
+      return this;
+    }
+
+    /**
+     * Build FlightInfo object.
+     */
+    public FlightInfo build() {
+      return new FlightInfo(schema, descriptor, endpoints, bytes, records, ordered, option, appMetadata);
+    }
+  }
 }
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
index 238221f051a7e..41b3a4693e579 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestBasicOperation.java
@@ -113,10 +113,13 @@ public void roundTripInfo() throws Exception {
         Field.nullable("a", new ArrowType.Int(32, true)),
         Field.nullable("b", new ArrowType.FixedSizeBinary(32))
     ), metadata);
-    final FlightInfo info1 = new FlightInfo(schema, FlightDescriptor.path(), Collections.emptyList(), -1, -1);
+    final FlightInfo info1 = FlightInfo.builder(schema, FlightDescriptor.path(), Collections.emptyList())
+            .setAppMetadata("foo".getBytes()).build();
     final FlightInfo info2 = new FlightInfo(schema, FlightDescriptor.command(new byte[2]),
-        Collections.singletonList(new FlightEndpoint(
-            new Ticket(new byte[10]), Location.forGrpcDomainSocket("/tmp/test.sock"))), 200, 500);
+        Collections.singletonList(
+                FlightEndpoint.builder(new Ticket(new byte[10]), Location.forGrpcDomainSocket("/tmp/test.sock"))
+                        .setAppMetadata("bar".getBytes()).build()
+        ), 200, 500);
     final FlightInfo info3 = new FlightInfo(schema, FlightDescriptor.path("a", "b"),
         Arrays.asList(new FlightEndpoint(
                 new Ticket(new byte[10]), Location.forGrpcDomainSocket("/tmp/test.sock")),
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
index 691048fb03ed3..0e4669f29ce43 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/TestFlightService.java
@@ -28,6 +28,7 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.util.AutoCloseables;
+import org.apache.arrow.vector.ipc.message.IpcOption;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
@@ -137,7 +138,8 @@ public void supportsNullSchemas() throws Exception
       @Override
       public FlightInfo getFlightInfo(CallContext context,
               FlightDescriptor descriptor) {
-        return new FlightInfo(null, descriptor, Collections.emptyList(), 0, 0);
+        return new FlightInfo(null, descriptor, Collections.emptyList(),
+                0, 0, false, IpcOption.DEFAULT, "foo".getBytes());
       }
     };
 
@@ -147,6 +149,7 @@ public FlightInfo getFlightInfo(CallContext context,
       FlightInfo flightInfo = client.getInfo(FlightDescriptor.path("test"));
       Assertions.assertEquals(Optional.empty(), flightInfo.getSchemaOptional());
       Assertions.assertEquals(new Schema(Collections.emptyList()), flightInfo.getSchema());
+      Assertions.assertArrayEquals(flightInfo.getAppMetadata(), "foo".getBytes());
 
       Exception e = Assertions.assertThrows(
           FlightRuntimeException.class,
diff --git a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/AppMetadataFlightInfoEndpointScenario.java b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/AppMetadataFlightInfoEndpointScenario.java
new file mode 100644
index 0000000000000..3220bb5a2d20f
--- /dev/null
+++ b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/AppMetadataFlightInfoEndpointScenario.java
@@ -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.
+ */
+
+package org.apache.arrow.flight.integration.tests;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.arrow.flight.FlightClient;
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightEndpoint;
+import org.apache.arrow.flight.FlightInfo;
+import org.apache.arrow.flight.FlightProducer;
+import org.apache.arrow.flight.FlightServer;
+import org.apache.arrow.flight.Location;
+import org.apache.arrow.flight.NoOpFlightProducer;
+import org.apache.arrow.flight.Ticket;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.vector.types.Types;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+
+/** Test app_metadata in FlightInfo and FlightEndpoint. */
+final class AppMetadataFlightInfoEndpointScenario implements Scenario {
+  @Override
+  public FlightProducer producer(BufferAllocator allocator, Location location) throws Exception {
+    return new AppMetadataFlightInfoEndpointProducer();
+  }
+
+  @Override
+  public void buildServer(FlightServer.Builder builder) throws Exception {
+  }
+
+  @Override
+  public void client(BufferAllocator allocator, Location location, FlightClient client) throws Exception {
+    byte[] cmd = "foobar".getBytes(StandardCharsets.UTF_8);
+    FlightInfo info = client.getInfo(FlightDescriptor.command(cmd));
+    IntegrationAssertions.assertEquals(info.getAppMetadata(), cmd);
+    IntegrationAssertions.assertEquals(info.getEndpoints().size(), 1);
+    IntegrationAssertions.assertEquals(info.getEndpoints().get(0).getAppMetadata(), cmd);
+  }
+
+  /** producer for app_metadata test. */
+  static class AppMetadataFlightInfoEndpointProducer extends NoOpFlightProducer {
+    @Override
+    public FlightInfo getFlightInfo(CallContext context, FlightDescriptor descriptor) {
+      byte[] cmd = descriptor.getCommand();
+      
+      Schema schema = new Schema(
+              Collections.singletonList(Field.notNullable("number", Types.MinorType.UINT4.getType())));
+
+      List<FlightEndpoint> endpoints = Collections.singletonList(
+              FlightEndpoint.builder(
+                      new Ticket("".getBytes(StandardCharsets.UTF_8))).setAppMetadata(cmd).build());
+
+      return FlightInfo.builder(schema, descriptor, endpoints).setAppMetadata(cmd).build();
+    }
+  }
+}
+
+
diff --git a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
index 26629c650e30f..c61fd94a4d228 100644
--- a/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
+++ b/java/flight/flight-integration-tests/src/main/java/org/apache/arrow/flight/integration/tests/Scenarios.java
@@ -49,6 +49,7 @@ private Scenarios() {
     scenarios.put("poll_flight_info", PollFlightInfoScenario::new);
     scenarios.put("flight_sql", FlightSqlScenario::new);
     scenarios.put("flight_sql:extension", FlightSqlExtensionScenario::new);
+    scenarios.put("app_metadata_flight_info_endpoint", AppMetadataFlightInfoEndpointScenario::new);
   }
 
   private static Scenarios getInstance() {
diff --git a/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java b/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
index cf65e16fac06f..477a56055cbbc 100644
--- a/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
+++ b/java/flight/flight-integration-tests/src/test/java/org/apache/arrow/flight/integration/tests/IntegrationTest.java
@@ -78,6 +78,11 @@ void flightSqlExtension() throws Exception {
     testScenario("flight_sql:extension");
   }
 
+  @Test
+  void appMetadataFlightInfoEndpoint() throws Exception {
+    testScenario("app_metadata_flight_info_endpoint");
+  }
+
   void testScenario(String scenarioName) throws Exception {
     try (final BufferAllocator allocator = new RootAllocator()) {
       final FlightServer.Builder builder = FlightServer.builder()

From 818f71d085b6f820903afc6b1f1e577d8e45ff47 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 26 Oct 2023 15:57:48 -0400
Subject: [PATCH 638/749] GH-38418: [MATLAB]  Add method for extracting one row
 of an `arrow.tabular.Table` as a string (#38463)

### Rationale for this change

We would like to modify the display of the `arrow.tabular.Table` and `arrow.tabular.RecordBatch` classes to be more "MATLAB-like". In order to do this, we need to add a method to their respective C++ Proxy classes that  returns a single row of the Table/RecordBatch as a MATLAB `string` array.

### What changes are included in this PR?

Added  new function template:
```cpp
template <typename TabularLike>
arrow::matlab::tabular::print_row(const std::shared_ptr<TabularLike>& tabularObject, const int64_t row_index)
```
This function template returns a string representation of the specified row in `tabbularObject`.

Added a new proxy method called `getRowString` to both the `Table` and `RecordBatch` C++ proxy classes. These methods invoke `print_row` to return a string representation of one row in the `Table`/`RecordBatch`.  Neither MATLAB class `arrow.tabular.Table` nor `arrow.tabular.RecordBatch` expose these methods directly because they will only be used internally for display.

Below is an example Output of `getRowString()`:

```matlab
>> matlabTable = table([1; 2; 3], ["ABC"; "DE"; "FGH"], datetime(2023, 10, 25) + days(0:2)');
>> arrowTable = arrow.table(matlabTable);
>> rowOneAsString = arrowTable.Proxy.getRowString(struct(Index=int64(1)))

rowOneAsString =

    "1 | "ABC" | 2023-10-25 00:00:00.000000"
```

### Are these changes tested?

Yes, added a new test class called `tTabularInternal.m`. Because `getRowString()` is not a method on the MATLAB classes `arrow.tabular.Table` and `arrow.tabular.RecordBatch`, this test class calls `getRowString()` on their `Proxy` properties, which are public but hidden.

### Are there any user-facing changes?

No.

* Closes: #38418

Lead-authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Co-authored-by: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Co-authored-by: Kevin Gurney <kevin.p.gurney@gmail.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/error/error.h     |   1 +
 .../arrow/matlab/tabular/get_row_as_string.h  |  77 ++++++++++++
 .../matlab/tabular/proxy/record_batch.cc      |  18 +++
 .../arrow/matlab/tabular/proxy/record_batch.h |   1 +
 .../cpp/arrow/matlab/tabular/proxy/table.cc   |  19 +++
 .../cpp/arrow/matlab/tabular/proxy/table.h    |   1 +
 .../+tabular/createAllSupportedArrayTypes.m   |   5 +-
 matlab/test/arrow/tabular/tTabularInternal.m  | 110 ++++++++++++++++++
 8 files changed, 230 insertions(+), 2 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/tabular/get_row_as_string.h
 create mode 100644 matlab/test/arrow/tabular/tTabularInternal.m

diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 2d8f5c432c96e..33e80bca8cc5a 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -202,4 +202,5 @@ namespace arrow::matlab::error {
     static const char* INDEX_OUT_OF_RANGE = "arrow:index:OutOfRange";
     static const char* BUFFER_VIEW_OR_COPY_FAILED = "arrow:buffer:ViewOrCopyFailed";
     static const char* ARRAY_PRETTY_PRINT_FAILED = "arrow:array:PrettyPrintFailed";
+    static const char* TABULAR_GET_ROW_AS_STRING_FAILED = "arrow:tabular:GetRowAsStringFailed";
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/get_row_as_string.h b/matlab/src/cpp/arrow/matlab/tabular/get_row_as_string.h
new file mode 100644
index 0000000000000..824b6c19a7109
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/tabular/get_row_as_string.h
@@ -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.
+
+#pragma once
+
+#include "arrow/pretty_print.h"
+
+#include <sstream>
+
+namespace arrow::matlab::tabular {
+
+    namespace {
+        arrow::PrettyPrintOptions make_pretty_print_options() {
+            auto opts = arrow::PrettyPrintOptions::Defaults();
+            opts.skip_new_lines = true;
+            opts.array_delimiters.open = "";
+            opts.array_delimiters.close = "";
+            opts.chunked_array_delimiters.open = "";
+            opts.chunked_array_delimiters.close = "";
+            return opts;
+        }
+    }
+
+    template <typename TabularType>
+    arrow::Result<std::string> get_row_as_string(const std::shared_ptr<TabularType>& tabular_object, const int64_t matlab_row_index) {
+        std::stringstream ss;
+        const int64_t row_index = matlab_row_index - 1;
+        if (row_index >= tabular_object->num_rows() || row_index < 0) {
+            ss << "Invalid Row Index: " << matlab_row_index;
+            return arrow::Status::Invalid(ss.str());
+        }
+
+        const auto opts = make_pretty_print_options();
+        const auto num_columns = tabular_object->num_columns();
+        const auto& columns = tabular_object->columns();
+
+        for (int32_t i = 0; i < num_columns; ++i) {
+            const auto& column = columns[i];
+            const auto type_id = column->type()->id();
+            if (arrow::is_primitive(type_id) || arrow::is_string(type_id)) {
+                auto slice = column->Slice(row_index, 1);
+                ARROW_RETURN_NOT_OK(arrow::PrettyPrint(*slice, opts, &ss));
+            } else if (type_id == arrow::Type::type::STRUCT) {
+                // Use <Struct> as a placeholder since we don't have a good
+                // way to display StructArray elements horiztonally on screen.
+                ss << "<Struct>";
+            } else if (type_id == arrow::Type::type::LIST) {
+                // Use <List> as a placeholder since we don't have a good
+                // way to display ListArray elements horiztonally on screen.
+                ss << "<List>";
+            } else {
+                return arrow::Status::NotImplemented("Datatype " + column->type()->ToString() + "is not currently supported for display.");
+            }
+
+            if (i + 1 < num_columns) {
+                // Only add the delimiter if there is at least 
+                // one more element to print. 
+                ss << " | ";
+            }
+        }
+        return ss.str();
+    }
+}
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
index 679c7382f6532..7d24ad01d7e73 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.cc
@@ -23,6 +23,7 @@
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/tabular/proxy/record_batch.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
+#include "arrow/matlab/tabular/get_row_as_string.h"
 #include "arrow/type.h"
 #include "arrow/util/utf8.h"
 
@@ -58,6 +59,7 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(RecordBatch, getColumnByIndex);
         REGISTER_METHOD(RecordBatch, getColumnByName);
         REGISTER_METHOD(RecordBatch, getSchema);
+        REGISTER_METHOD(RecordBatch, getRowAsString);
     }
 
     std::shared_ptr<arrow::RecordBatch> RecordBatch::unwrap() {
@@ -218,4 +220,20 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = schema_proxy_id_mda;
     }
 
+    void RecordBatch::getRowAsString(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int64_t> index_mda = args[0]["Index"];
+        const auto matlab_row_index = int64_t(index_mda[0]);
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto row_str_utf8, arrow::matlab::tabular::get_row_as_string(record_batch, matlab_row_index), 
+                                            context, error::TABULAR_GET_ROW_AS_STRING_FAILED);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto row_str_utf16, arrow::util::UTF8StringToUTF16(row_str_utf8),
+                                            context, error::UNICODE_CONVERSION_ERROR_ID);
+        context.outputs[0] = factory.createScalar(row_str_utf16);
+    }
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
index b136ad1ea5db1..c417d8198f9ad 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/record_batch.h
@@ -41,6 +41,7 @@ namespace arrow::matlab::tabular::proxy {
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
             void getColumnByName(libmexclass::proxy::method::Context& context);
             void getSchema(libmexclass::proxy::method::Context& context);
+            void getRowAsString(libmexclass::proxy::method::Context& context);
 
             std::shared_ptr<arrow::RecordBatch> record_batch;
     };
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
index 228e28dad9e9c..cf628407b1742 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc
@@ -24,6 +24,8 @@
 #include "arrow/matlab/error/error.h"
 #include "arrow/matlab/tabular/proxy/table.h"
 #include "arrow/matlab/tabular/proxy/schema.h"
+#include "arrow/matlab/tabular/get_row_as_string.h"
+
 #include "arrow/type.h"
 #include "arrow/util/utf8.h"
 
@@ -57,6 +59,7 @@ namespace arrow::matlab::tabular::proxy {
         REGISTER_METHOD(Table, getSchema);
         REGISTER_METHOD(Table, getColumnByIndex);
         REGISTER_METHOD(Table, getColumnByName);
+        REGISTER_METHOD(Table, getRowAsString);
     }
 
     std::shared_ptr<arrow::Table> Table::unwrap() {
@@ -212,4 +215,20 @@ namespace arrow::matlab::tabular::proxy {
         context.outputs[0] = chunked_array_proxy_id_mda;
     }
 
+    void Table::getRowAsString(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        using namespace libmexclass::proxy;
+        mda::ArrayFactory factory;
+
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<int64_t> index_mda = args[0]["Index"];
+        const auto matlab_row_index = int64_t(index_mda[0]);
+
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto row_str_utf8, arrow::matlab::tabular::get_row_as_string(table, matlab_row_index), 
+                                            context, error::TABULAR_GET_ROW_AS_STRING_FAILED);
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto row_str_utf16, arrow::util::UTF8StringToUTF16(row_str_utf8),
+                                            context, error::UNICODE_CONVERSION_ERROR_ID);
+        context.outputs[0] = factory.createScalar(row_str_utf16);
+    }
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
index dae86a180b7a6..bfcea15bbd1c3 100644
--- a/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
+++ b/matlab/src/cpp/arrow/matlab/tabular/proxy/table.h
@@ -41,6 +41,7 @@ namespace arrow::matlab::tabular::proxy {
             void getSchema(libmexclass::proxy::method::Context& context);
             void getColumnByIndex(libmexclass::proxy::method::Context& context);
             void getColumnByName(libmexclass::proxy::method::Context& context);
+            void getRowAsString(libmexclass::proxy::method::Context& context);
 
             std::shared_ptr<arrow::Table> table;
     };
diff --git a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
index ad2f026d64e20..a9682d317354b 100644
--- a/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
+++ b/matlab/src/matlab/+arrow/+internal/+test/+tabular/createAllSupportedArrayTypes.m
@@ -24,8 +24,8 @@
     end
 
     % Seed the random number generator to ensure
-    % reproducible results in tests.
-    rng(1);
+    % reproducible results in tests across MATLAB sessions.
+    rng(1, "twister");
 
     import arrow.type.ID
     import arrow.array.*
@@ -101,6 +101,7 @@
 
     % Return the class names as a string array
     classes = string({metaClass.Name});
+    classes = sort(classes);
 end
 
 function dict = getNumericArrayToMatlabDictionary()
diff --git a/matlab/test/arrow/tabular/tTabularInternal.m b/matlab/test/arrow/tabular/tTabularInternal.m
new file mode 100644
index 0000000000000..28075d7763dea
--- /dev/null
+++ b/matlab/test/arrow/tabular/tTabularInternal.m
@@ -0,0 +1,110 @@
+%TTABULARINTERNAL Unit tests for internal functionality of tabular types.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTabularInternal < matlab.unittest.TestCase
+
+    properties(TestParameter)
+        TabularObjectWithAllTypes
+
+        TabularObjectWithOneColumn
+
+        TabularObjectWithThreeRows
+    end
+
+    methods (TestParameterDefinition, Static)
+        function TabularObjectWithAllTypes = initializeTabularObjectWithAllTypes()
+            arrays = arrow.internal.test.tabular.createAllSupportedArrayTypes(NumRows=1);
+            arrowTable = arrow.tabular.Table.fromArrays(arrays{:});
+            arrowRecordBatch = arrow.tabular.Table.fromArrays(arrays{:});
+            TabularObjectWithAllTypes = struct(Table=arrowTable, ...
+                RecordBatch=arrowRecordBatch);
+        end
+
+        function TabularObjectWithOneColumn = initializeTabularObjectWithOneColumn()
+            t = table((1:3)');
+            arrowTable = arrow.table(t);
+            arrowRecordBatch = arrow.recordBatch(t);
+            TabularObjectWithOneColumn = struct(Table=arrowTable, ...
+                RecordBatch=arrowRecordBatch);
+        end
+
+        function TabularObjectWithThreeRows = initializeTabularObjectWithThreeRows()
+            t = table((1:3)', ["A"; "B"; "C"]);
+            arrowTable = arrow.table(t);
+            arrowRecordBatch = arrow.recordBatch(t);
+            TabularObjectWithThreeRows = struct(Table=arrowTable, ...
+                RecordBatch=arrowRecordBatch);
+        end
+    end
+
+    methods (Test)
+        function RowWithAllTypes(testCase, TabularObjectWithAllTypes)
+            % Verify getRowAsString successfully returns the expected string
+            % when called on a Table/RecordBatch that contains all
+            % supported array types.
+            proxy = TabularObjectWithAllTypes.Proxy;
+            columnStrs = ["false", "2024-02-23", "2023-08-24", "78", "38", ...
+                          "24", "48", "89", "102", "<List>", """107""", "<Struct>", ...
+                          "00:03:44", "00:00:07.000000", "2024-02-10 00:00:00.000000", ...
+                          "107", "143", "36", "51"];
+            expectedString = strjoin(columnStrs, " | ");
+            actualString = proxy.getRowAsString(struct(Index=int64(1)));
+            testCase.verifyEqual(actualString, expectedString);
+        end
+
+        function RowWithOneColumn(testCase, TabularObjectWithOneColumn)
+            % Verify getRowAsString successfully returns the expected string
+            % when called on a Table/RecordBatch with one column.
+            proxy = TabularObjectWithOneColumn.Proxy;
+            expectedString = "1";
+            actualString = proxy.getRowAsString(struct(Index=int64(1)));
+            testCase.verifyEqual(actualString, expectedString);
+        end
+
+        function RowIndex(testCase, TabularObjectWithThreeRows)
+            % Verify getRowAsString returns the expected string for 
+            % the provided row index.
+            proxy = TabularObjectWithThreeRows.Proxy;
+
+            actualString = proxy.getRowAsString(struct(Index=int64(1)));
+            expectedString = "1 | ""A""";
+            testCase.verifyEqual(actualString, expectedString);
+
+            actualString = proxy.getRowAsString(struct(Index=int64(2)));
+            expectedString = "2 | ""B""";
+            testCase.verifyEqual(actualString, expectedString);
+
+            actualString = proxy.getRowAsString(struct(Index=int64(3)));
+            expectedString = "3 | ""C""";
+            testCase.verifyEqual(actualString, expectedString);
+        end
+
+        function GetRowAsStringFailed(testCase, TabularObjectWithThreeRows)
+            % Verify getRowAsString throws an error with the ID
+            % arrow:tabular:GetRowAsStringFailed if provided invalid index
+            % values.
+            proxy = TabularObjectWithThreeRows.Proxy;
+            fcn = @() proxy.getRowAsString(struct(Index=int64(0)));
+            testCase.verifyError(fcn, "arrow:tabular:GetRowAsStringFailed");
+
+            fcn = @() proxy.getRowAsString(struct(Index=int64(4)));
+            testCase.verifyError(fcn, "arrow:tabular:GetRowAsStringFailed");
+        end
+
+    end
+
+end
\ No newline at end of file

From f62213921b003cc716d6fe50d8604560cea4a3d4 Mon Sep 17 00:00:00 2001
From: Benjamin Kietzman <bengilgit@gmail.com>
Date: Thu, 26 Oct 2023 17:28:48 -0400
Subject: [PATCH 639/749] GH-37710: [C++][Integration] Add C++ Utf8View
 implementation  (#37792)

### Rationale for this change

After the PR changing the spec and schema ( https://github.com/apache/arrow/pull/37526 ) is accepted, this PR will be undrafted. It adds the minimal addition of a C++ implementation and was extracted from the original C++ Utf8View pr ( https://github.com/apache/arrow/pull/35628 ) for ease of review.

### What changes are included in this PR?

- The new types are available with new subclasses of DataType, Array, ArrayBuilder, ...
- The values of string view arrays can be visited as `std::string_view` as with StringArray
- String view arrays can be round tripped through IPC and integration JSON

* Closes: #37710

Relevant mailing list discussions:
* https://lists.apache.org/thread/l8t1vj5x1wdf75mdw3wfjvnxrfy5xomy
* https://lists.apache.org/thread/3qhkomvvc69v3gkotbwldyko7yk9cs9k

Authored-by: Benjamin Kietzman <bengilgit@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/array/array_base.cc             |   2 +
 cpp/src/arrow/array/array_binary.cc           |  28 ++
 cpp/src/arrow/array/array_binary.h            |  60 ++++
 cpp/src/arrow/array/array_binary_test.cc      | 138 +++++++--
 cpp/src/arrow/array/array_test.cc             |   8 +-
 cpp/src/arrow/array/array_view_test.cc        |  32 +++
 cpp/src/arrow/array/builder_base.cc           |  16 +-
 cpp/src/arrow/array/builder_binary.cc         |  69 ++++-
 cpp/src/arrow/array/builder_binary.h          | 261 +++++++++++++++++-
 cpp/src/arrow/array/builder_dict.cc           |   6 +
 cpp/src/arrow/array/builder_dict.h            |   7 +
 cpp/src/arrow/array/concatenate.cc            |  40 +++
 cpp/src/arrow/array/concatenate_test.cc       |  14 +
 cpp/src/arrow/array/data.cc                   |  63 ++++-
 cpp/src/arrow/array/data.h                    |  17 +-
 cpp/src/arrow/array/dict_internal.h           |  26 ++
 cpp/src/arrow/array/diff.cc                   |  31 ++-
 cpp/src/arrow/array/diff_test.cc              |  13 +
 cpp/src/arrow/array/util.cc                   |  54 +++-
 cpp/src/arrow/array/validate.cc               | 162 ++++++++---
 cpp/src/arrow/buffer_builder.h                |   7 +-
 cpp/src/arrow/builder.cc                      |   4 +-
 cpp/src/arrow/compare.cc                      |  28 +-
 cpp/src/arrow/compute/kernels/vector_hash.cc  |  95 ++-----
 .../engine/substrait/expression_internal.cc   |   2 +
 .../arrow/engine/substrait/type_internal.cc   |   2 +
 cpp/src/arrow/integration/json_internal.cc    | 211 ++++++++++++--
 cpp/src/arrow/ipc/feather.cc                  |   4 +-
 cpp/src/arrow/ipc/feather_test.cc             |   6 +-
 cpp/src/arrow/ipc/json_simple.cc              |   4 +
 cpp/src/arrow/ipc/json_simple_test.cc         |  10 +-
 cpp/src/arrow/ipc/metadata_internal.cc        |  41 ++-
 cpp/src/arrow/ipc/metadata_internal.h         |   6 +-
 cpp/src/arrow/ipc/read_write_test.cc          |  91 +++---
 cpp/src/arrow/ipc/reader.cc                   |  35 ++-
 cpp/src/arrow/ipc/test_common.cc              |  53 ++--
 cpp/src/arrow/ipc/test_common.h               |   2 +-
 cpp/src/arrow/ipc/writer.cc                   |  24 +-
 cpp/src/arrow/ipc/writer.h                    |   1 +
 cpp/src/arrow/json/converter.cc               |   2 +
 cpp/src/arrow/json/converter_test.cc          |   4 +-
 cpp/src/arrow/json/parser.cc                  |   1 +
 cpp/src/arrow/json/test_common.h              |  10 +-
 cpp/src/arrow/pretty_print.cc                 |  18 +-
 cpp/src/arrow/scalar.cc                       |  19 +-
 cpp/src/arrow/scalar.h                        |  43 ++-
 cpp/src/arrow/testing/gtest_util.h            |   7 +
 cpp/src/arrow/testing/random.cc               |  54 +++-
 cpp/src/arrow/testing/random.h                |  26 +-
 cpp/src/arrow/testing/random_test.cc          |   1 +
 cpp/src/arrow/type.cc                         |  28 +-
 cpp/src/arrow/type.h                          | 124 ++++++++-
 cpp/src/arrow/type_fwd.h                      |  21 ++
 cpp/src/arrow/type_test.cc                    |  12 +
 cpp/src/arrow/type_traits.cc                  |   2 +
 cpp/src/arrow/type_traits.h                   |  45 +++
 cpp/src/arrow/util/binary_view_util.h         |  95 +++++++
 cpp/src/arrow/util/string.cc                  |  42 ++-
 cpp/src/arrow/util/string.h                   |   4 +-
 cpp/src/arrow/visit_data_inline.h             |  47 +++-
 cpp/src/arrow/visitor.cc                      |   8 +-
 cpp/src/arrow/visitor.h                       |   6 +
 cpp/src/arrow/visitor_generate.h              |   2 +
 .../parquet/arrow/arrow_reader_writer_test.cc |   3 +-
 cpp/src/parquet/column_writer.cc              |   2 +
 dev/archery/archery/integration/datagen.py    |   5 +-
 .../src/arrow/python/arrow_to_pandas.cc       |   3 +-
 .../src/arrow/python/python_to_arrow.cc       |  12 +-
 r/src/r_to_arrow.cpp                          |   7 +-
 69 files changed, 1951 insertions(+), 375 deletions(-)
 create mode 100644 cpp/src/arrow/util/binary_view_util.h

diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc
index f7b8d7954e1cf..eab71de27b11a 100644
--- a/cpp/src/arrow/array/array_base.cc
+++ b/cpp/src/arrow/array/array_base.cc
@@ -87,6 +87,8 @@ struct ScalarFromArraySlotImpl {
     return Finish(a.GetString(index_));
   }
 
+  Status Visit(const BinaryViewArray& a) { return Finish(a.GetString(index_)); }
+
   Status Visit(const FixedSizeBinaryArray& a) { return Finish(a.GetString(index_)); }
 
   Status Visit(const DayTimeIntervalArray& a) { return Finish(a.Value(index_)); }
diff --git a/cpp/src/arrow/array/array_binary.cc b/cpp/src/arrow/array/array_binary.cc
index 9466b5a48f9d7..d83ba0ca8936d 100644
--- a/cpp/src/arrow/array/array_binary.cc
+++ b/cpp/src/arrow/array/array_binary.cc
@@ -24,6 +24,7 @@
 #include "arrow/array/validate.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging.h"
 
@@ -89,6 +90,33 @@ LargeStringArray::LargeStringArray(int64_t length,
 
 Status LargeStringArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
 
+BinaryViewArray::BinaryViewArray(std::shared_ptr<ArrayData> data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::BINARY_VIEW);
+  SetData(std::move(data));
+}
+
+BinaryViewArray::BinaryViewArray(std::shared_ptr<DataType> type, int64_t length,
+                                 std::shared_ptr<Buffer> views, BufferVector buffers,
+                                 std::shared_ptr<Buffer> null_bitmap, int64_t null_count,
+                                 int64_t offset) {
+  buffers.insert(buffers.begin(), std::move(views));
+  buffers.insert(buffers.begin(), std::move(null_bitmap));
+  SetData(
+      ArrayData::Make(std::move(type), length, std::move(buffers), null_count, offset));
+}
+
+std::string_view BinaryViewArray::GetView(int64_t i) const {
+  const std::shared_ptr<Buffer>* data_buffers = data_->buffers.data() + 2;
+  return util::FromBinaryView(raw_values_[i], data_buffers);
+}
+
+StringViewArray::StringViewArray(std::shared_ptr<ArrayData> data) {
+  ARROW_CHECK_EQ(data->type->id(), Type::STRING_VIEW);
+  SetData(std::move(data));
+}
+
+Status StringViewArray::ValidateUTF8() const { return internal::ValidateUTF8(*data_); }
+
 FixedSizeBinaryArray::FixedSizeBinaryArray(const std::shared_ptr<ArrayData>& data) {
   SetData(data);
 }
diff --git a/cpp/src/arrow/array/array_binary.h b/cpp/src/arrow/array/array_binary.h
index 7e58a96ff841a..fd68a379ddbfb 100644
--- a/cpp/src/arrow/array/array_binary.h
+++ b/cpp/src/arrow/array/array_binary.h
@@ -22,6 +22,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -217,6 +218,65 @@ class ARROW_EXPORT LargeStringArray : public LargeBinaryArray {
   Status ValidateUTF8() const;
 };
 
+// ----------------------------------------------------------------------
+// BinaryView and StringView
+
+/// Concrete Array class for variable-size binary view data using the
+/// BinaryViewType::c_type struct to reference in-line or out-of-line string values
+class ARROW_EXPORT BinaryViewArray : public FlatArray {
+ public:
+  using TypeClass = BinaryViewType;
+  using IteratorType = stl::ArrayIterator<BinaryViewArray>;
+  using c_type = BinaryViewType::c_type;
+
+  explicit BinaryViewArray(std::shared_ptr<ArrayData> data);
+
+  BinaryViewArray(std::shared_ptr<DataType> type, int64_t length,
+                  std::shared_ptr<Buffer> views, BufferVector data_buffers,
+                  std::shared_ptr<Buffer> null_bitmap = NULLPTR,
+                  int64_t null_count = kUnknownNullCount, int64_t offset = 0);
+
+  // For API compatibility with BinaryArray etc.
+  std::string_view GetView(int64_t i) const;
+  std::string GetString(int64_t i) const { return std::string{GetView(i)}; }
+
+  const auto& values() const { return data_->buffers[1]; }
+  const c_type* raw_values() const { return raw_values_; }
+
+  std::optional<std::string_view> operator[](int64_t i) const {
+    return *IteratorType(*this, i);
+  }
+
+  IteratorType begin() const { return IteratorType(*this); }
+  IteratorType end() const { return IteratorType(*this, length()); }
+
+ protected:
+  using FlatArray::FlatArray;
+
+  void SetData(std::shared_ptr<ArrayData> data) {
+    FlatArray::SetData(std::move(data));
+    raw_values_ = data_->GetValuesSafe<c_type>(1);
+  }
+
+  const c_type* raw_values_;
+};
+
+/// Concrete Array class for variable-size string view (utf-8) data using
+/// BinaryViewType::c_type to reference in-line or out-of-line string values
+class ARROW_EXPORT StringViewArray : public BinaryViewArray {
+ public:
+  using TypeClass = StringViewType;
+
+  explicit StringViewArray(std::shared_ptr<ArrayData> data);
+
+  using BinaryViewArray::BinaryViewArray;
+
+  /// \brief Validate that this array contains only valid UTF8 entries
+  ///
+  /// This check is also implied by ValidateFull()
+  Status ValidateUTF8() const;
+};
+
 // ----------------------------------------------------------------------
 // Fixed width binary
 
diff --git a/cpp/src/arrow/array/array_binary_test.cc b/cpp/src/arrow/array/array_binary_test.cc
index 3bc9bb91a022a..04391be0ac789 100644
--- a/cpp/src/arrow/array/array_binary_test.cc
+++ b/cpp/src/arrow/array/array_binary_test.cc
@@ -27,17 +27,21 @@
 
 #include "arrow/array.h"
 #include "arrow/array/builder_binary.h"
+#include "arrow/array/validate.h"
 #include "arrow/buffer.h"
 #include "arrow/memory_pool.h"
 #include "arrow/status.h"
 #include "arrow/testing/builder.h"
 #include "arrow/testing/gtest_util.h"
+#include "arrow/testing/matchers.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_builders.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/key_value_metadata.h"
+#include "arrow/util/logging.h"
 #include "arrow/visit_data_inline.h"
 
 namespace arrow {
@@ -365,38 +369,134 @@ TYPED_TEST(TestStringArray, TestValidateOffsets) { this->TestValidateOffsets();
 
 TYPED_TEST(TestStringArray, TestValidateData) { this->TestValidateData(); }
 
+// Produce an Array of index/offset views from a std::vector of index/offset
+// BinaryViewType::c_type
+Result<std::shared_ptr<StringViewArray>> MakeBinaryViewArray(
+    BufferVector data_buffers, const std::vector<BinaryViewType::c_type>& views,
+    bool validate = true) {
+  auto length = static_cast<int64_t>(views.size());
+  auto arr = std::make_shared<StringViewArray>(
+      utf8_view(), length, Buffer::FromVector(views), std::move(data_buffers));
+  if (validate) {
+    RETURN_NOT_OK(arr->ValidateFull());
+  }
+  return arr;
+}
+
+TEST(StringViewArray, Validate) {
+  // Since this is a test of validation, we need to be able to construct invalid arrays.
+  auto buffer_s = Buffer::FromString("supercalifragilistic(sp?)");
+  auto buffer_y = Buffer::FromString("yyyyyyyyyyyyyyyyyyyyyyyyy");
+
+  // empty array is valid
+  EXPECT_THAT(MakeBinaryViewArray({}, {}), Ok());
+
+  // empty array with some data buffers is valid
+  EXPECT_THAT(MakeBinaryViewArray({buffer_s, buffer_y}, {}), Ok());
+
+  // inline views need not have a corresponding buffer
+  EXPECT_THAT(MakeBinaryViewArray({},
+                                  {
+                                      util::ToInlineBinaryView("hello"),
+                                      util::ToInlineBinaryView("world"),
+                                      util::ToInlineBinaryView("inline me"),
+                                  }),
+              Ok());
+
+  // non-inline views are expected to reference only buffers managed by the array
+  EXPECT_THAT(
+      MakeBinaryViewArray(
+          {buffer_s, buffer_y},
+          {util::ToBinaryView("supe", static_cast<int32_t>(buffer_s->size()), 0, 0),
+           util::ToBinaryView("yyyy", static_cast<int32_t>(buffer_y->size()), 1, 0)}),
+      Ok());
+
+  // views may not reference data buffers not present in the array
+  EXPECT_THAT(
+      MakeBinaryViewArray(
+          {}, {util::ToBinaryView("supe", static_cast<int32_t>(buffer_s->size()), 0, 0)}),
+      Raises(StatusCode::IndexError));
+  // ... or ranges which overflow the referenced data buffer
+  EXPECT_THAT(
+      MakeBinaryViewArray(
+          {buffer_s}, {util::ToBinaryView(
+                          "supe", static_cast<int32_t>(buffer_s->size() + 50), 0, 0)}),
+      Raises(StatusCode::IndexError));
+
+  // Additionally, the prefixes of non-inline views must match the data buffer
+  EXPECT_THAT(
+      MakeBinaryViewArray(
+          {buffer_s, buffer_y},
+          {util::ToBinaryView("SUPE", static_cast<int32_t>(buffer_s->size()), 0, 0),
+           util::ToBinaryView("yyyy", static_cast<int32_t>(buffer_y->size()), 1, 0)}),
+      Raises(StatusCode::Invalid));
+
+  // Invalid string views which are masked by a null bit do not cause validation to fail
+  auto invalid_but_masked =
+      MakeBinaryViewArray(
+          {buffer_s},
+          {util::ToBinaryView("SUPE", static_cast<int32_t>(buffer_s->size()), 0, 0),
+           util::ToBinaryView("yyyy", 50, 40, 30)},
+          /*validate=*/false)
+          .ValueOrDie()
+          ->data();
+  invalid_but_masked->null_count = 2;
+  invalid_but_masked->buffers[0] = *AllocateEmptyBitmap(2);
+  EXPECT_THAT(internal::ValidateArrayFull(*invalid_but_masked), Ok());
+
+  // overlapping views are allowed
+  EXPECT_THAT(
+      MakeBinaryViewArray(
+          {buffer_s},
+          {
+              util::ToBinaryView("supe", static_cast<int32_t>(buffer_s->size()), 0, 0),
+              util::ToBinaryView("uper", static_cast<int32_t>(buffer_s->size() - 1), 0,
+                                 1),
+              util::ToBinaryView("perc", static_cast<int32_t>(buffer_s->size() - 2), 0,
+                                 2),
+              util::ToBinaryView("erca", static_cast<int32_t>(buffer_s->size() - 3), 0,
+                                 3),
+          }),
+      Ok());
+}
+
 template <typename T>
 class TestUTF8Array : public ::testing::Test {
  public:
   using TypeClass = T;
-  using offset_type = typename TypeClass::offset_type;
   using ArrayType = typename TypeTraits<TypeClass>::ArrayType;
 
-  Status ValidateUTF8(int64_t length, std::vector<offset_type> offsets,
-                      std::string_view data, int64_t offset = 0) {
-    ArrayType arr(length, Buffer::Wrap(offsets), std::make_shared<Buffer>(data),
-                  /*null_bitmap=*/nullptr, /*null_count=*/0, offset);
-    return arr.ValidateUTF8();
+  std::shared_ptr<DataType> type() const {
+    if constexpr (is_binary_view_like_type<TypeClass>::value) {
+      return TypeClass::is_utf8 ? utf8_view() : binary_view();
+    } else {
+      return TypeTraits<TypeClass>::type_singleton();
+    }
   }
 
-  Status ValidateUTF8(const std::string& json) {
-    auto ty = TypeTraits<T>::type_singleton();
-    auto arr = ArrayFromJSON(ty, json);
-    return checked_cast<const ArrayType&>(*arr).ValidateUTF8();
+  Status ValidateUTF8(const Array& arr) {
+    return checked_cast<const ArrayType&>(arr).ValidateUTF8();
+  }
+
+  Status ValidateUTF8(std::vector<std::string> values) {
+    std::shared_ptr<Array> arr;
+    ArrayFromVector<T, std::string>(type(), values, &arr);
+    return ValidateUTF8(*arr);
   }
 
   void TestValidateUTF8() {
-    ASSERT_OK(ValidateUTF8(R"(["Voix", "ambiguë", "d’un", "cœur"])"));
-    ASSERT_OK(ValidateUTF8(1, {0, 4}, "\xf4\x8f\xbf\xbf"));  // \U0010ffff
+    ASSERT_OK(
+        ValidateUTF8(*ArrayFromJSON(type(), R"(["Voix", "ambiguë", "d’un", "cœur"])")));
+    ASSERT_OK(ValidateUTF8({"\xf4\x8f\xbf\xbf"}));  // \U0010ffff
 
-    ASSERT_RAISES(Invalid, ValidateUTF8(1, {0, 1}, "\xf4"));
+    ASSERT_RAISES(Invalid, ValidateUTF8({"\xf4"}));
 
     // More tests in TestValidateData() above
     // (ValidateFull() calls ValidateUTF8() internally)
   }
 };
 
-TYPED_TEST_SUITE(TestUTF8Array, StringArrowTypes);
+TYPED_TEST_SUITE(TestUTF8Array, StringOrStringViewArrowTypes);
 
 TYPED_TEST(TestUTF8Array, TestValidateUTF8) { this->TestValidateUTF8(); }
 
@@ -883,11 +983,15 @@ class TestBaseBinaryDataVisitor : public ::testing::Test {
   void SetUp() override { type_ = TypeTraits<TypeClass>::type_singleton(); }
 
   void TestBasics() {
-    auto array = ArrayFromJSON(type_, R"(["foo", null, "bar"])");
+    auto array = ArrayFromJSON(
+        type_,
+        R"(["foo", null, "bar", "inline_me", "allocate_me_aaaaa", "allocate_me_bbbb"])");
     BinaryAppender appender;
     ArraySpanVisitor<TypeClass> visitor;
     ASSERT_OK(visitor.Visit(*array->data(), &appender));
-    ASSERT_THAT(appender.data, ::testing::ElementsAreArray({"foo", "(null)", "bar"}));
+    ASSERT_THAT(appender.data,
+                ::testing::ElementsAreArray({"foo", "(null)", "bar", "inline_me",
+                                             "allocate_me_aaaaa", "allocate_me_bbbb"}));
     ARROW_UNUSED(visitor);  // Workaround weird MSVC warning
   }
 
@@ -904,7 +1008,7 @@ class TestBaseBinaryDataVisitor : public ::testing::Test {
   std::shared_ptr<DataType> type_;
 };
 
-TYPED_TEST_SUITE(TestBaseBinaryDataVisitor, BaseBinaryArrowTypes);
+TYPED_TEST_SUITE(TestBaseBinaryDataVisitor, BaseBinaryOrBinaryViewLikeArrowTypes);
 
 TYPED_TEST(TestBaseBinaryDataVisitor, Basics) { this->TestBasics(); }
 
diff --git a/cpp/src/arrow/array/array_test.cc b/cpp/src/arrow/array/array_test.cc
index 2bef9d725d37f..46908439ef5f0 100644
--- a/cpp/src/arrow/array/array_test.cc
+++ b/cpp/src/arrow/array/array_test.cc
@@ -382,10 +382,12 @@ static std::vector<std::shared_ptr<DataType>> TestArrayUtilitiesAgainstTheseType
       float64(),
       binary(),
       large_binary(),
+      binary_view(),
       fixed_size_binary(3),
       decimal(16, 4),
       utf8(),
       large_utf8(),
+      utf8_view(),
       list(utf8()),
       list(int64()),  // NOTE: Regression case for ARROW-9071/MakeArrayOfNull
       list(large_utf8()),
@@ -601,12 +603,15 @@ static ScalarVector GetScalars() {
       std::make_shared<DurationScalar>(60, duration(TimeUnit::SECOND)),
       std::make_shared<BinaryScalar>(hello),
       std::make_shared<LargeBinaryScalar>(hello),
+      std::make_shared<BinaryViewScalar>(hello),
       std::make_shared<FixedSizeBinaryScalar>(
           hello, fixed_size_binary(static_cast<int32_t>(hello->size()))),
       std::make_shared<Decimal128Scalar>(Decimal128(10), decimal(16, 4)),
       std::make_shared<Decimal256Scalar>(Decimal256(10), decimal(76, 38)),
       std::make_shared<StringScalar>(hello),
       std::make_shared<LargeStringScalar>(hello),
+      std::make_shared<StringViewScalar>(hello),
+      std::make_shared<StringViewScalar>(Buffer::FromString("long string; not inlined")),
       std::make_shared<ListScalar>(ArrayFromJSON(int8(), "[1, 2, 3]")),
       ScalarFromJSON(map(int8(), utf8()), R"([[1, "foo"], [2, "bar"]])"),
       std::make_shared<LargeListScalar>(ArrayFromJSON(int8(), "[1, 1, 2, 2, 3, 3]")),
@@ -647,13 +652,14 @@ TEST_F(TestArray, TestMakeArrayFromScalar) {
 
   for (int64_t length : {16}) {
     for (auto scalar : scalars) {
+      ARROW_SCOPED_TRACE("scalar type: ", scalar->type->ToString());
       ASSERT_OK_AND_ASSIGN(auto array, MakeArrayFromScalar(*scalar, length));
       ASSERT_OK(array->ValidateFull());
       ASSERT_EQ(array->length(), length);
       ASSERT_EQ(array->null_count(), 0);
 
       // test case for ARROW-13321
-      for (int64_t i : std::vector<int64_t>{0, length / 2, length - 1}) {
+      for (int64_t i : {int64_t{0}, length / 2, length - 1}) {
         ASSERT_OK_AND_ASSIGN(auto s, array->GetScalar(i));
         AssertScalarsEqual(*s, *scalar, /*verbose=*/true);
       }
diff --git a/cpp/src/arrow/array/array_view_test.cc b/cpp/src/arrow/array/array_view_test.cc
index 07dc3014e4029..97110ea97f3fc 100644
--- a/cpp/src/arrow/array/array_view_test.cc
+++ b/cpp/src/arrow/array/array_view_test.cc
@@ -126,6 +126,38 @@ TEST(TestArrayView, StringAsBinary) {
   CheckView(expected, arr);
 }
 
+TEST(TestArrayView, StringViewAsBinaryView) {
+  for (auto json : {
+           R"(["foox", "barz", null])",
+           R"(["foox", "barz_not_inlined", null])",
+       }) {
+    auto arr = ArrayFromJSON(utf8_view(), json);
+    auto expected = ArrayFromJSON(binary_view(), json);
+    CheckView(arr, expected);
+    CheckView(expected, arr);
+  }
+}
+
+TEST(TestArrayView, StringViewAsBinaryViewInStruct) {
+  auto padl = ArrayFromJSON(list(int16()), "[[0, -1], [], [42]]");
+  auto padr = ArrayFromJSON(utf8(), R"(["foox", "barz", null])");
+
+  for (auto json : {
+           R"(["foox", "barz", null])",
+           R"(["foox", "barz_not_inlined", null])",
+       }) {
+    auto arr =
+        StructArray::Make({padl, ArrayFromJSON(utf8_view(), json), padr}, {"", "", ""})
+            .ValueOrDie();
+    auto expected =
+        StructArray::Make({padl, ArrayFromJSON(binary_view(), json), padr}, {"", "", ""})
+            .ValueOrDie();
+
+    CheckView(arr, expected);
+    CheckView(expected, arr);
+  }
+}
+
 TEST(TestArrayView, PrimitiveWrongSize) {
   auto arr = ArrayFromJSON(int16(), "[0, -1, 42]");
   CheckViewFails(arr, int8());
diff --git a/cpp/src/arrow/array/builder_base.cc b/cpp/src/arrow/array/builder_base.cc
index 3000aea3e189a..d3502a0ab645a 100644
--- a/cpp/src/arrow/array/builder_base.cc
+++ b/cpp/src/arrow/array/builder_base.cc
@@ -96,10 +96,7 @@ namespace {
 template <typename ConstIterator>
 struct AppendScalarImpl {
   template <typename T>
-  enable_if_t<has_c_type<T>::value || is_decimal_type<T>::value ||
-                  is_fixed_size_binary_type<T>::value,
-              Status>
-  Visit(const T&) {
+  Status HandleFixedWidth(const T&) {
     auto builder = checked_cast<typename TypeTraits<T>::BuilderType*>(builder_);
     RETURN_NOT_OK(builder->Reserve(n_repeats_ * (scalars_end_ - scalars_begin_)));
 
@@ -117,7 +114,16 @@ struct AppendScalarImpl {
   }
 
   template <typename T>
-  enable_if_base_binary<T, Status> Visit(const T&) {
+  enable_if_t<has_c_type<T>::value, Status> Visit(const T& t) {
+    return HandleFixedWidth(t);
+  }
+
+  Status Visit(const FixedSizeBinaryType& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal128Type& t) { return HandleFixedWidth(t); }
+  Status Visit(const Decimal256Type& t) { return HandleFixedWidth(t); }
+
+  template <typename T>
+  enable_if_has_string_view<T, Status> Visit(const T&) {
     int64_t data_size = 0;
     for (auto it = scalars_begin_; it != scalars_end_; ++it) {
       const auto& scalar = checked_cast<const typename TypeTraits<T>::ScalarType&>(*it);
diff --git a/cpp/src/arrow/array/builder_binary.cc b/cpp/src/arrow/array/builder_binary.cc
index 571f450aab9c1..3ff22d4a3feeb 100644
--- a/cpp/src/arrow/array/builder_binary.cc
+++ b/cpp/src/arrow/array/builder_binary.cc
@@ -35,11 +35,70 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/decimal.h"
 #include "arrow/util/logging.h"
+#include "arrow/visit_data_inline.h"
 
 namespace arrow {
 
 using internal::checked_cast;
 
+// ----------------------------------------------------------------------
+// Binary/StringView
+BinaryViewBuilder::BinaryViewBuilder(const std::shared_ptr<DataType>& type,
+                                     MemoryPool* pool)
+    : BinaryViewBuilder(pool) {}
+
+Status BinaryViewBuilder::AppendArraySlice(const ArraySpan& array, int64_t offset,
+                                           int64_t length) {
+  auto bitmap = array.GetValues<uint8_t>(0, 0);
+  auto values = array.GetValues<BinaryViewType::c_type>(1) + offset;
+
+  int64_t out_of_line_total = 0, i = 0;
+  VisitNullBitmapInline(
+      array.buffers[0].data, array.offset, array.length, array.null_count,
+      [&] {
+        if (!values[i].is_inline()) {
+          out_of_line_total += static_cast<int64_t>(values[i].size());
+        }
+        ++i;
+      },
+      [&] { ++i; });
+
+  RETURN_NOT_OK(Reserve(length));
+  RETURN_NOT_OK(ReserveData(out_of_line_total));
+
+  for (int64_t i = 0; i < length; i++) {
+    if (bitmap && !bit_util::GetBit(bitmap, array.offset + offset + i)) {
+      UnsafeAppendNull();
+      continue;
+    }
+
+    UnsafeAppend(util::FromBinaryView(values[i], array.GetVariadicBuffers().data()));
+  }
+  return Status::OK();
+}
+
+Status BinaryViewBuilder::FinishInternal(std::shared_ptr<ArrayData>* out) {
+  ARROW_ASSIGN_OR_RAISE(auto null_bitmap, null_bitmap_builder_.FinishWithLength(length_));
+  ARROW_ASSIGN_OR_RAISE(auto data, data_builder_.FinishWithLength(length_));
+  BufferVector buffers = {null_bitmap, data};
+  for (auto&& buffer : data_heap_builder_.Finish()) {
+    buffers.push_back(std::move(buffer));
+  }
+  *out = ArrayData::Make(type(), length_, std::move(buffers), null_count_);
+  Reset();
+  return Status::OK();
+}
+
+Status BinaryViewBuilder::ReserveData(int64_t length) {
+  return data_heap_builder_.Reserve(length);
+}
+
+void BinaryViewBuilder::Reset() {
+  ArrayBuilder::Reset();
+  data_builder_.Reset();
+  data_heap_builder_.Reset();
+}
+
 // ----------------------------------------------------------------------
 // Fixed width binary
 
@@ -125,8 +184,8 @@ const uint8_t* FixedSizeBinaryBuilder::GetValue(int64_t i) const {
 
 std::string_view FixedSizeBinaryBuilder::GetView(int64_t i) const {
   const uint8_t* data_ptr = byte_builder_.data();
-  return std::string_view(reinterpret_cast<const char*>(data_ptr + i * byte_width_),
-                          byte_width_);
+  return {reinterpret_cast<const char*>(data_ptr + i * byte_width_),
+          static_cast<size_t>(byte_width_)};
 }
 
 // ----------------------------------------------------------------------
@@ -173,10 +232,10 @@ Status ChunkedStringBuilder::Finish(ArrayVector* out) {
   RETURN_NOT_OK(ChunkedBinaryBuilder::Finish(out));
 
   // Change data type to string/utf8
-  for (size_t i = 0; i < out->size(); ++i) {
-    std::shared_ptr<ArrayData> data = (*out)[i]->data();
+  for (auto& chunk : *out) {
+    std::shared_ptr<ArrayData> data = chunk->data()->Copy();
     data->type = ::arrow::utf8();
-    (*out)[i] = std::make_shared<StringArray>(data);
+    chunk = std::make_shared<StringArray>(std::move(data));
   }
   return Status::OK();
 }
diff --git a/cpp/src/arrow/array/builder_binary.h b/cpp/src/arrow/array/builder_binary.h
index b0c4fe2fc81fd..3e87cf2403610 100644
--- a/cpp/src/arrow/array/builder_binary.h
+++ b/cpp/src/arrow/array/builder_binary.h
@@ -36,6 +36,7 @@
 #include "arrow/buffer_builder.h"
 #include "arrow/status.h"
 #include "arrow/type.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/macros.h"
 #include "arrow/util/visibility.h"
 
@@ -204,10 +205,10 @@ class BaseBinaryBuilder
         }
       }
     } else {
-      for (std::size_t i = 0; i < values.size(); ++i) {
+      for (const auto& value : values) {
         UnsafeAppendNextOffset();
-        value_data_builder_.UnsafeAppend(
-            reinterpret_cast<const uint8_t*>(values[i].data()), values[i].size());
+        value_data_builder_.UnsafeAppend(reinterpret_cast<const uint8_t*>(value.data()),
+                                         value.size());
       }
     }
 
@@ -463,6 +464,256 @@ class ARROW_EXPORT LargeStringBuilder : public LargeBinaryBuilder {
   std::shared_ptr<DataType> type() const override { return large_utf8(); }
 };
 
+// ----------------------------------------------------------------------
+// BinaryViewBuilder, StringViewBuilder
+//
+// These builders do not support building raw pointer view arrays.
+
+namespace internal {
+
+// We allocate medium-sized memory chunks and accumulate data in those, which
+// may result in some waste if there are many large-ish strings. If a string
+// comes along that does not fit into a block, we allocate a new block and
+// write into that.
+//
+// Later we can implement optimizations to continuing filling underfull blocks
+// after encountering a large string that required allocating a new block.
+class ARROW_EXPORT StringHeapBuilder {
+ public:
+  static constexpr int64_t kDefaultBlocksize = 32 << 10;  // 32KB
+
+  StringHeapBuilder(MemoryPool* pool, int64_t alignment)
+      : pool_(pool), alignment_(alignment) {}
+
+  void SetBlockSize(int64_t blocksize) { blocksize_ = blocksize; }
+
+  using c_type = BinaryViewType::c_type;
+
+  template <bool Safe>
+  std::conditional_t<Safe, Result<c_type>, c_type> Append(const uint8_t* value,
+                                                          int64_t length) {
+    if (length <= BinaryViewType::kInlineSize) {
+      return util::ToInlineBinaryView(value, static_cast<int32_t>(length));
+    }
+
+    if constexpr (Safe) {
+      ARROW_RETURN_NOT_OK(Reserve(length));
+    }
+
+    auto v =
+        util::ToBinaryView(value, static_cast<int32_t>(length),
+                           static_cast<int32_t>(blocks_.size() - 1), current_offset_);
+
+    memcpy(current_out_buffer_, value, static_cast<size_t>(length));
+    current_out_buffer_ += length;
+    current_remaining_bytes_ -= length;
+    current_offset_ += static_cast<int32_t>(length);
+    return v;
+  }
+
+  static constexpr int64_t ValueSizeLimit() {
+    return std::numeric_limits<int32_t>::max();
+  }
+
+  /// \brief Ensure that the indicated number of bytes can be appended via
+  /// UnsafeAppend operations without the need to allocate more memory
+  Status Reserve(int64_t num_bytes) {
+    if (ARROW_PREDICT_FALSE(num_bytes > ValueSizeLimit())) {
+      return Status::CapacityError(
+          "BinaryView or StringView elements cannot reference "
+          "strings larger than 2GB");
+    }
+    if (num_bytes > current_remaining_bytes_) {
+      // Ensure the buffer is fully overwritten to avoid leaking uninitialized
+      // bytes from the allocator
+      if (current_remaining_bytes_ > 0) {
+        std::memset(current_out_buffer_, 0, current_remaining_bytes_);
+        blocks_.back() = SliceBuffer(blocks_.back(), 0,
+                                     blocks_.back()->size() - current_remaining_bytes_);
+      }
+      current_remaining_bytes_ = num_bytes > blocksize_ ? num_bytes : blocksize_;
+      ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Buffer> new_block,
+                            AllocateBuffer(current_remaining_bytes_, alignment_, pool_));
+      current_offset_ = 0;
+      current_out_buffer_ = new_block->mutable_data();
+      blocks_.emplace_back(std::move(new_block));
+    }
+    return Status::OK();
+  }
+
+  void Reset() {
+    current_offset_ = 0;
+    current_out_buffer_ = NULLPTR;
+    current_remaining_bytes_ = 0;
+    blocks_.clear();
+  }
+
+  int64_t current_remaining_bytes() const { return current_remaining_bytes_; }
+
+  std::vector<std::shared_ptr<Buffer>> Finish() {
+    current_offset_ = 0;
+    current_out_buffer_ = NULLPTR;
+    current_remaining_bytes_ = 0;
+    return std::move(blocks_);
+  }
+
+ private:
+  MemoryPool* pool_;
+  int64_t alignment_;
+  int64_t blocksize_ = kDefaultBlocksize;
+  std::vector<std::shared_ptr<Buffer>> blocks_;
+
+  int32_t current_offset_ = 0;
+  uint8_t* current_out_buffer_ = NULLPTR;
+  int64_t current_remaining_bytes_ = 0;
+};
+
+}  // namespace internal
+
+class ARROW_EXPORT BinaryViewBuilder : public ArrayBuilder {
+ public:
+  using TypeClass = BinaryViewType;
+
+  // this constructor provided for MakeBuilder compatibility
+  BinaryViewBuilder(const std::shared_ptr<DataType>&, MemoryPool* pool);
+
+  explicit BinaryViewBuilder(MemoryPool* pool = default_memory_pool(),
+                             int64_t alignment = kDefaultBufferAlignment)
+      : ArrayBuilder(pool, alignment),
+        data_builder_(pool, alignment),
+        data_heap_builder_(pool, alignment) {}
+
+  /// Set the size for future preallocated data buffers.
+  ///
+  /// The default size is 32KB, so after each 32KB of string data appended to the builder
+  /// a new data buffer will be allocated. Adjust this to a larger value to decrease the
+  /// frequency of allocation, or to a smaller value to lower the overhead of each
+  /// allocation.
+  void SetBlockSize(int64_t blocksize) { data_heap_builder_.SetBlockSize(blocksize); }
+
+  /// The number of bytes which can be appended to this builder without allocating another
+  /// data buffer.
+  int64_t current_block_bytes_remaining() const {
+    return data_heap_builder_.current_remaining_bytes();
+  }
+
+  Status Append(const uint8_t* value, int64_t length) {
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    UnsafeAppendToBitmap(true);
+    ARROW_ASSIGN_OR_RAISE(auto v,
+                          data_heap_builder_.Append</*Safe=*/true>(value, length));
+    data_builder_.UnsafeAppend(v);
+    return Status::OK();
+  }
+
+  Status Append(const char* value, int64_t length) {
+    return Append(reinterpret_cast<const uint8_t*>(value), length);
+  }
+
+  Status Append(std::string_view value) {
+    return Append(value.data(), static_cast<int64_t>(value.size()));
+  }
+
+  /// \brief Append without checking capacity
+  ///
+  /// Builder should have been presized using Reserve() and ReserveData(),
+  /// respectively, and the value must not be larger than 2GB
+  void UnsafeAppend(const uint8_t* value, int64_t length) {
+    UnsafeAppendToBitmap(true);
+    auto v = data_heap_builder_.Append</*Safe=*/false>(value, length);
+    data_builder_.UnsafeAppend(v);
+  }
+
+  void UnsafeAppend(const char* value, int64_t length) {
+    UnsafeAppend(reinterpret_cast<const uint8_t*>(value), length);
+  }
+
+  void UnsafeAppend(const std::string& value) {
+    UnsafeAppend(value.c_str(), static_cast<int64_t>(value.size()));
+  }
+
+  void UnsafeAppend(std::string_view value) {
+    UnsafeAppend(value.data(), static_cast<int64_t>(value.size()));
+  }
+
+  /// \brief Ensures there is enough allocated available capacity in the
+  /// out-of-line data heap to append the indicated number of bytes without
+  /// additional allocations
+  Status ReserveData(int64_t length);
+
+  Status AppendNulls(int64_t length) final {
+    ARROW_RETURN_NOT_OK(Reserve(length));
+    data_builder_.UnsafeAppend(length, BinaryViewType::c_type{});
+    UnsafeSetNull(length);
+    return Status::OK();
+  }
+
+  /// \brief Append a single null element
+  Status AppendNull() final {
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    data_builder_.UnsafeAppend(BinaryViewType::c_type{});
+    UnsafeAppendToBitmap(false);
+    return Status::OK();
+  }
+
+  /// \brief Append a empty element (length-0 inline string)
+  Status AppendEmptyValue() final {
+    ARROW_RETURN_NOT_OK(Reserve(1));
+    data_builder_.UnsafeAppend(BinaryViewType::c_type{});
+    UnsafeAppendToBitmap(true);
+    return Status::OK();
+  }
+
+  /// \brief Append several empty elements
+  Status AppendEmptyValues(int64_t length) final {
+    ARROW_RETURN_NOT_OK(Reserve(length));
+    data_builder_.UnsafeAppend(length, BinaryViewType::c_type{});
+    UnsafeSetNotNull(length);
+    return Status::OK();
+  }
+
+  void UnsafeAppendNull() {
+    data_builder_.UnsafeAppend(BinaryViewType::c_type{});
+    UnsafeAppendToBitmap(false);
+  }
+
+  void UnsafeAppendEmptyValue() {
+    data_builder_.UnsafeAppend(BinaryViewType::c_type{});
+    UnsafeAppendToBitmap(true);
+  }
+
+  /// \brief Append a slice of a BinaryViewArray passed as an ArraySpan. Copies
+  /// the underlying out-of-line string memory to avoid memory lifetime issues
+  Status AppendArraySlice(const ArraySpan& array, int64_t offset,
+                          int64_t length) override;
+
+  void Reset() override;
+
+  Status Resize(int64_t capacity) override {
+    ARROW_RETURN_NOT_OK(CheckCapacity(capacity));
+    capacity = std::max(capacity, kMinBuilderCapacity);
+    ARROW_RETURN_NOT_OK(data_builder_.Resize(capacity));
+    return ArrayBuilder::Resize(capacity);
+  }
+
+  Status FinishInternal(std::shared_ptr<ArrayData>* out) override;
+
+  std::shared_ptr<DataType> type() const override { return binary_view(); }
+
+ protected:
+  TypedBufferBuilder<BinaryViewType::c_type> data_builder_;
+
+  // Accumulates out-of-line data in fixed-size chunks which are then attached
+  // to the resulting ArrayData
+  internal::StringHeapBuilder data_heap_builder_;
+};
+
+class ARROW_EXPORT StringViewBuilder : public BinaryViewBuilder {
+ public:
+  using BinaryViewBuilder::BinaryViewBuilder;
+  std::shared_ptr<DataType> type() const override { return utf8_view(); }
+};
+
 // ----------------------------------------------------------------------
 // FixedSizeBinaryBuilder
 
@@ -498,7 +749,7 @@ class ARROW_EXPORT FixedSizeBinaryBuilder : public ArrayBuilder {
 
   Status Append(const Buffer& s) {
     ARROW_RETURN_NOT_OK(Reserve(1));
-    UnsafeAppend(std::string_view(s));
+    UnsafeAppend(s);
     return Status::OK();
   }
 
@@ -549,7 +800,7 @@ class ARROW_EXPORT FixedSizeBinaryBuilder : public ArrayBuilder {
     UnsafeAppend(reinterpret_cast<const uint8_t*>(value.data()));
   }
 
-  void UnsafeAppend(const Buffer& s) { UnsafeAppend(std::string_view(s)); }
+  void UnsafeAppend(const Buffer& s) { UnsafeAppend(std::string_view{s}); }
 
   void UnsafeAppend(const std::shared_ptr<Buffer>& s) { UnsafeAppend(*s); }
 
diff --git a/cpp/src/arrow/array/builder_dict.cc b/cpp/src/arrow/array/builder_dict.cc
index 525b0afbc908a..7a96463ec3c43 100644
--- a/cpp/src/arrow/array/builder_dict.cc
+++ b/cpp/src/arrow/array/builder_dict.cc
@@ -194,6 +194,12 @@ Status DictionaryMemoTable::GetOrInsert(const BinaryType*, std::string_view valu
   return impl_->GetOrInsert<BinaryType>(value, out);
 }
 
+Status DictionaryMemoTable::GetOrInsert(const BinaryViewType*, std::string_view value,
+                                        int32_t* out) {
+  // Create BinaryArray dictionary for now
+  return impl_->GetOrInsert<BinaryType>(value, out);
+}
+
 Status DictionaryMemoTable::GetOrInsert(const LargeBinaryType*, std::string_view value,
                                         int32_t* out) {
   return impl_->GetOrInsert<LargeBinaryType>(value, out);
diff --git a/cpp/src/arrow/array/builder_dict.h b/cpp/src/arrow/array/builder_dict.h
index cb0aaf309915b..3f0d711dc5bb5 100644
--- a/cpp/src/arrow/array/builder_dict.h
+++ b/cpp/src/arrow/array/builder_dict.h
@@ -60,6 +60,12 @@ struct DictionaryValue<T, enable_if_base_binary<T>> {
                                 BinaryType, LargeBinaryType>::type;
 };
 
+template <typename T>
+struct DictionaryValue<T, enable_if_binary_view_like<T>> {
+  using type = std::string_view;
+  using PhysicalType = BinaryViewType;
+};
+
 template <typename T>
 struct DictionaryValue<T, enable_if_fixed_size_binary<T>> {
   using type = std::string_view;
@@ -114,6 +120,7 @@ class ARROW_EXPORT DictionaryMemoTable {
 
   Status GetOrInsert(const BinaryType*, std::string_view value, int32_t* out);
   Status GetOrInsert(const LargeBinaryType*, std::string_view value, int32_t* out);
+  Status GetOrInsert(const BinaryViewType*, std::string_view value, int32_t* out);
 
   class DictionaryMemoTableImpl;
   std::unique_ptr<DictionaryMemoTableImpl> impl_;
diff --git a/cpp/src/arrow/array/concatenate.cc b/cpp/src/arrow/array/concatenate.cc
index f7549fa9d1d1a..37c7271b5b95c 100644
--- a/cpp/src/arrow/array/concatenate.cc
+++ b/cpp/src/arrow/array/concatenate.cc
@@ -43,6 +43,7 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ree_util.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -230,6 +231,45 @@ class ConcatenateImpl {
     return ConcatenateBuffers(value_buffers, pool_).Value(&out_->buffers[2]);
   }
 
+  Status Visit(const BinaryViewType& type) {
+    out_->buffers.resize(2);
+
+    for (const auto& in_data : in_) {
+      for (const auto& buf : util::span(in_data->buffers).subspan(2)) {
+        out_->buffers.push_back(buf);
+      }
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto view_buffers, Buffers(1, BinaryViewType::kSize));
+    ARROW_ASSIGN_OR_RAISE(auto view_buffer, ConcatenateBuffers(view_buffers, pool_));
+
+    auto* views = view_buffer->mutable_data_as<BinaryViewType::c_type>();
+    size_t preceding_buffer_count = 0;
+
+    int64_t i = in_[0]->length;
+    for (size_t in_index = 1; in_index < in_.size(); ++in_index) {
+      preceding_buffer_count += in_[in_index - 1]->buffers.size() - 2;
+
+      for (int64_t end_i = i + in_[in_index]->length; i < end_i; ++i) {
+        if (views[i].is_inline()) continue;
+        views[i].ref.buffer_index = SafeSignedAdd(
+            views[i].ref.buffer_index, static_cast<int32_t>(preceding_buffer_count));
+      }
+    }
+
+    if (out_->buffers[0] != nullptr) {
+      i = in_[0]->length;
+      VisitNullBitmapInline(
+          out_->buffers[0]->data(), i, out_->length - i, out_->null_count, [&] { ++i; },
+          [&] {
+            views[i++] = {};  // overwrite views under null bits with an empty view
+          });
+    }
+
+    out_->buffers[1] = std::move(view_buffer);
+    return Status::OK();
+  }
+
   Status Visit(const ListType&) {
     std::vector<Range> value_ranges;
     ARROW_ASSIGN_OR_RAISE(auto index_buffers, Buffers(1, sizeof(int32_t)));
diff --git a/cpp/src/arrow/array/concatenate_test.cc b/cpp/src/arrow/array/concatenate_test.cc
index 4c03fab731ffe..0ef1136ea78f8 100644
--- a/cpp/src/arrow/array/concatenate_test.cc
+++ b/cpp/src/arrow/array/concatenate_test.cc
@@ -92,9 +92,15 @@ class ConcatenateTest : public ::testing::Test {
       for (auto null_probability : this->null_probabilities_) {
         std::shared_ptr<Array> array;
         factory(size, null_probability, &array);
+        ASSERT_OK(array->ValidateFull());
         auto expected = array->Slice(offsets.front(), offsets.back() - offsets.front());
+        ASSERT_OK(expected->ValidateFull());
         auto slices = this->Slices(array, offsets);
+        for (auto slice : slices) {
+          ASSERT_OK(slice->ValidateFull());
+        }
         ASSERT_OK_AND_ASSIGN(auto actual, Concatenate(slices));
+        ASSERT_OK(actual->ValidateFull());
         AssertArraysEqual(*expected, *actual);
         if (actual->data()->buffers[0]) {
           CheckTrailingBitsAreZeroed(actual->data()->buffers[0], actual->length());
@@ -155,6 +161,14 @@ TEST_F(ConcatenateTest, StringType) {
   });
 }
 
+TEST_F(ConcatenateTest, StringViewType) {
+  Check([this](int32_t size, double null_probability, std::shared_ptr<Array>* out) {
+    *out = rng_.StringView(size, /*min_length =*/0, /*max_length =*/40, null_probability,
+                           /*max_buffer_length=*/200);
+    ASSERT_OK((**out).ValidateFull());
+  });
+}
+
 TEST_F(ConcatenateTest, LargeStringType) {
   Check([this](int32_t size, double null_probability, std::shared_ptr<Array>* out) {
     *out =
diff --git a/cpp/src/arrow/array/data.cc b/cpp/src/arrow/array/data.cc
index 79595ab7c7c31..678513fd4d151 100644
--- a/cpp/src/arrow/array/data.cc
+++ b/cpp/src/arrow/array/data.cc
@@ -31,6 +31,7 @@
 #include "arrow/status.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/macros.h"
@@ -92,6 +93,11 @@ bool RunEndEncodedMayHaveLogicalNulls(const ArrayData& data) {
   return ArraySpan(data).MayHaveLogicalNulls();
 }
 
+BufferSpan PackVariadicBuffers(util::span<const std::shared_ptr<Buffer>> buffers) {
+  return {const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(buffers.data())),
+          static_cast<int64_t>(buffers.size() * sizeof(std::shared_ptr<Buffer>))};
+}
+
 }  // namespace internal
 
 std::shared_ptr<ArrayData> ArrayData::Make(std::shared_ptr<DataType> type, int64_t length,
@@ -187,7 +193,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
   }
   this->offset = data.offset;
 
-  for (int i = 0; i < static_cast<int>(data.buffers.size()); ++i) {
+  for (int i = 0; i < std::min(static_cast<int>(data.buffers.size()), 3); ++i) {
     const std::shared_ptr<Buffer>& buffer = data.buffers[i];
     // It is the invoker-of-kernels's responsibility to ensure that
     // const buffers are not written to accidentally.
@@ -200,7 +206,7 @@ void ArraySpan::SetMembers(const ArrayData& data) {
 
   Type::type type_id = this->type->id();
   if (type_id == Type::EXTENSION) {
-    const ExtensionType* ext_type = checked_cast<const ExtensionType*>(this->type);
+    auto* ext_type = checked_cast<const ExtensionType*>(this->type);
     type_id = ext_type->storage_type()->id();
   }
 
@@ -215,6 +221,11 @@ void ArraySpan::SetMembers(const ArrayData& data) {
     this->buffers[i] = {};
   }
 
+  if (type_id == Type::STRING_VIEW || type_id == Type::BINARY_VIEW) {
+    // store the span of data buffers in the third buffer
+    this->buffers[2] = internal::PackVariadicBuffers(util::span(data.buffers).subspan(2));
+  }
+
   if (type_id == Type::DICTIONARY) {
     this->child_data.resize(1);
     this->child_data[0].SetMembers(*data.dictionary);
@@ -247,6 +258,8 @@ int GetNumBuffers(const DataType& type) {
     case Type::LARGE_BINARY:
     case Type::STRING:
     case Type::LARGE_STRING:
+    case Type::STRING_VIEW:
+    case Type::BINARY_VIEW:
     case Type::DENSE_UNION:
       return 3;
     case Type::EXTENSION:
@@ -351,6 +364,19 @@ void ArraySpan::FillFromScalar(const Scalar& value) {
     }
     this->buffers[2].data = const_cast<uint8_t*>(data_buffer);
     this->buffers[2].size = data_size;
+  } else if (type_id == Type::BINARY_VIEW || type_id == Type::STRING_VIEW) {
+    const auto& scalar = checked_cast<const BaseBinaryScalar&>(value);
+
+    this->buffers[1].size = BinaryViewType::kSize;
+    this->buffers[1].data = scalar.scratch_space_;
+    static_assert(sizeof(BinaryViewType::c_type) <= sizeof(scalar.scratch_space_));
+    auto* view = new (&scalar.scratch_space_) BinaryViewType::c_type;
+    if (scalar.is_valid) {
+      *view = util::ToBinaryView(std::string_view{*scalar.value}, 0, 0);
+      this->buffers[2] = internal::PackVariadicBuffers({&scalar.value, 1});
+    } else {
+      *view = {};
+    }
   } else if (type_id == Type::FIXED_SIZE_BINARY) {
     const auto& scalar = checked_cast<const BaseBinaryScalar&>(value);
     this->buffers[1].data = const_cast<uint8_t*>(scalar.value->data());
@@ -513,6 +539,14 @@ std::shared_ptr<ArrayData> ArraySpan::ToArrayData() const {
     type_id = ext_type->storage_type()->id();
   }
 
+  if (HasVariadicBuffers()) {
+    DCHECK_EQ(result->buffers.size(), 3);
+    result->buffers.pop_back();
+    for (const auto& data_buffer : GetVariadicBuffers()) {
+      result->buffers.push_back(data_buffer);
+    }
+  }
+
   if (type_id == Type::NA) {
     result->null_count = this->length;
   } else if (this->buffers[0].data == nullptr) {
@@ -531,6 +565,16 @@ std::shared_ptr<ArrayData> ArraySpan::ToArrayData() const {
   return result;
 }
 
+util::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
+  DCHECK(HasVariadicBuffers());
+  return {buffers[2].data_as<std::shared_ptr<Buffer>>(),
+          buffers[2].size / sizeof(std::shared_ptr<Buffer>)};
+}
+
+bool ArraySpan::HasVariadicBuffers() const {
+  return type->id() == Type::BINARY_VIEW || type->id() == Type::STRING_VIEW;
+}
+
 std::shared_ptr<Array> ArraySpan::ToArray() const {
   return MakeArray(this->ToArrayData());
 }
@@ -722,7 +766,8 @@ struct ViewDataImpl {
       }
 
       RETURN_NOT_OK(CheckInputAvailable());
-      const auto& in_spec = in_layouts[in_layout_idx].buffers[in_buffer_idx];
+      const auto& in_layout = in_layouts[in_layout_idx];
+      const auto& in_spec = in_layout.buffers[in_buffer_idx];
       if (out_spec != in_spec) {
         return InvalidView("incompatible layouts");
       }
@@ -733,6 +778,18 @@ struct ViewDataImpl {
       DCHECK_GT(in_data_item->buffers.size(), in_buffer_idx);
       out_buffers.push_back(in_data_item->buffers[in_buffer_idx]);
       ++in_buffer_idx;
+
+      if (in_buffer_idx == in_layout.buffers.size()) {
+        if (out_layout.variadic_spec != in_layout.variadic_spec) {
+          return InvalidView("incompatible layouts");
+        }
+
+        if (in_layout.variadic_spec) {
+          for (; in_buffer_idx < in_data_item->buffers.size(); ++in_buffer_idx) {
+            out_buffers.push_back(in_data_item->buffers[in_buffer_idx]);
+          }
+        }
+      }
       AdjustInputPointer();
     }
 
diff --git a/cpp/src/arrow/array/data.h b/cpp/src/arrow/array/data.h
index 8c6b250b71adf..40a77640cd1e5 100644
--- a/cpp/src/arrow/array/data.h
+++ b/cpp/src/arrow/array/data.h
@@ -28,6 +28,7 @@
 #include "arrow/type.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/macros.h"
+#include "arrow/util/span.h"
 #include "arrow/util/visibility.h"
 
 namespace arrow {
@@ -472,10 +473,12 @@ struct ARROW_EXPORT ArraySpan {
   void SetSlice(int64_t offset, int64_t length) {
     this->offset = offset;
     this->length = length;
-    if (this->type->id() != Type::NA) {
+    if (this->type->id() == Type::NA) {
+      this->null_count = this->length;
+    } else if (this->MayHaveNulls()) {
       this->null_count = kUnknownNullCount;
     } else {
-      this->null_count = this->length;
+      this->null_count = 0;
     }
   }
 
@@ -530,6 +533,16 @@ struct ARROW_EXPORT ArraySpan {
   /// \see GetNullCount
   int64_t ComputeLogicalNullCount() const;
 
+  /// Some DataTypes (StringView, BinaryView) may have an arbitrary number of variadic
+  /// buffers. Since ArraySpan only has 3 buffers, we pack the variadic buffers into
+  /// buffers[2]; IE buffers[2].data points to the first shared_ptr<Buffer> of the
+  /// variadic set and buffers[2].size is the number of variadic buffers times
+  /// sizeof(shared_ptr<Buffer>).
+  ///
+  /// \see HasVariadicBuffers
+  util::span<const std::shared_ptr<Buffer>> GetVariadicBuffers() const;
+  bool HasVariadicBuffers() const;
+
  private:
   ARROW_FRIEND_EXPORT friend bool internal::IsNullRunEndEncoded(const ArrayData& span,
                                                                 int64_t i);
diff --git a/cpp/src/arrow/array/dict_internal.h b/cpp/src/arrow/array/dict_internal.h
index 3c1c8c453d1e7..63d8583b17324 100644
--- a/cpp/src/arrow/array/dict_internal.h
+++ b/cpp/src/arrow/array/dict_internal.h
@@ -150,6 +150,32 @@ struct DictionaryTraits<T, enable_if_base_binary<T>> {
   }
 };
 
+template <typename T>
+struct DictionaryTraits<T, enable_if_binary_view_like<T>> {
+  using MemoTableType = typename HashTraits<T>::MemoTableType;
+
+  static_assert(std::is_same_v<MemoTableType, BinaryMemoTable<BinaryBuilder>>);
+
+  // Instead of defining a custom memo table for StringView we reuse BinaryType's,
+  // then convert to views when we copy data out of the memo table.
+  static Result<std::shared_ptr<ArrayData>> GetDictionaryArrayData(
+      MemoryPool* pool, const std::shared_ptr<DataType>& type,
+      const MemoTableType& memo_table, int64_t start_offset) {
+    DCHECK(type->id() == Type::STRING_VIEW || type->id() == Type::BINARY_VIEW);
+
+    BinaryViewBuilder builder(pool);
+    RETURN_NOT_OK(builder.Resize(memo_table.size() - start_offset));
+    RETURN_NOT_OK(builder.ReserveData(memo_table.values_size()));
+    memo_table.VisitValues(static_cast<int32_t>(start_offset),
+                           [&](std::string_view s) { builder.UnsafeAppend(s); });
+
+    std::shared_ptr<ArrayData> out;
+    RETURN_NOT_OK(builder.FinishInternal(&out));
+    out->type = type;
+    return out;
+  }
+};
+
 template <typename T>
 struct DictionaryTraits<T, enable_if_fixed_size_binary<T>> {
   using MemoTableType = typename HashTraits<T>::MemoTableType;
diff --git a/cpp/src/arrow/array/diff.cc b/cpp/src/arrow/array/diff.cc
index 800f19b752726..f267c52c0d696 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -476,30 +476,31 @@ class MakeFormatterImpl {
     return Status::OK();
   }
 
-  // format Binary, LargeBinary and FixedSizeBinary in hexadecimal
   template <typename T>
-  enable_if_binary_like<T, Status> Visit(const T&) {
+  enable_if_has_string_view<T, Status> Visit(const T&) {
     using ArrayType = typename TypeTraits<T>::ArrayType;
     impl_ = [](const Array& array, int64_t index, std::ostream* os) {
-      *os << HexEncode(checked_cast<const ArrayType&>(array).GetView(index));
+      std::string_view view = checked_cast<const ArrayType&>(array).GetView(index);
+      if constexpr (T::is_utf8) {
+        // format String and StringView with \"\n\r\t\\ escaped
+        *os << '"' << Escape(view) << '"';
+      } else {
+        // format Binary, LargeBinary, BinaryView, and FixedSizeBinary in hexadecimal
+        *os << HexEncode(view);
+      }
     };
     return Status::OK();
   }
 
-  // format Strings with \"\n\r\t\\ escaped
+  // format Decimals with Decimal___Array::FormatValue
   template <typename T>
-  enable_if_string_like<T, Status> Visit(const T&) {
-    using ArrayType = typename TypeTraits<T>::ArrayType;
-    impl_ = [](const Array& array, int64_t index, std::ostream* os) {
-      *os << "\"" << Escape(checked_cast<const ArrayType&>(array).GetView(index)) << "\"";
-    };
-    return Status::OK();
-  }
-
-  // format Decimals with Decimal128Array::FormatValue
-  Status Visit(const Decimal128Type&) {
+  enable_if_decimal<T, Status> Visit(const T&) {
     impl_ = [](const Array& array, int64_t index, std::ostream* os) {
-      *os << checked_cast<const Decimal128Array&>(array).FormatValue(index);
+      if constexpr (T::type_id == Type::DECIMAL128) {
+        *os << checked_cast<const Decimal128Array&>(array).FormatValue(index);
+      } else {
+        *os << checked_cast<const Decimal256Array&>(array).FormatValue(index);
+      }
     };
     return Status::OK();
   }
diff --git a/cpp/src/arrow/array/diff_test.cc b/cpp/src/arrow/array/diff_test.cc
index e322006732f9a..4c2f39eddf863 100644
--- a/cpp/src/arrow/array/diff_test.cc
+++ b/cpp/src/arrow/array/diff_test.cc
@@ -596,6 +596,19 @@ TEST_F(DiffTest, UnifiedDiffFormatter) {
 @@ -5, +8 @@
 +79
 +11
+)");
+  }
+
+  for (const auto& type : {
+           decimal128(10, 4),
+           decimal256(10, 4),
+       }) {
+    base_ = ArrayFromJSON(type, R"(["123.4567", "-78.9000"])");
+    target_ = ArrayFromJSON(type, R"(["123.4567", "-123.4567"])");
+    AssertDiffAndFormat(R"(
+@@ -1, +1 @@
+--78.9000
++-123.4567
 )");
   }
 }
diff --git a/cpp/src/arrow/array/util.cc b/cpp/src/arrow/array/util.cc
index 98e9d51b5fc75..9ea2fc2b6f0a1 100644
--- a/cpp/src/arrow/array/util.cc
+++ b/cpp/src/arrow/array/util.cc
@@ -43,6 +43,9 @@
 #include "arrow/util/decimal.h"
 #include "arrow/util/endian.h"
 #include "arrow/util/logging.h"
+#include "arrow/util/sort.h"
+#include "arrow/util/span.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -271,6 +274,13 @@ class ArrayDataEndianSwapper {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType& type) {
+    // TODO(GH-37879): This requires knowledge of whether the array is being swapped to
+    // native endian or from it so that we know what size to trust when deciding whether
+    // something is an inline view.
+    return Status::NotImplemented("Swapping endianness of ", type);
+  }
+
   Status Visit(const ListType& type) {
     RETURN_NOT_OK(SwapOffsets<int32_t>(1));
     return Status::OK();
@@ -379,6 +389,10 @@ class NullArrayFactory {
       return MaxOf(sizeof(typename T::offset_type) * (length_ + 1));
     }
 
+    Status Visit(const BinaryViewType& type) {
+      return MaxOf(sizeof(BinaryViewType::c_type) * length_);
+    }
+
     Status Visit(const FixedSizeListType& type) {
       return MaxOf(GetBufferLength(type.value_type(), type.list_size() * length_));
     }
@@ -498,6 +512,11 @@ class NullArrayFactory {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType&) {
+    out_->buffers.resize(2, buffer_);
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_var_size_list<T, Status> Visit(const T& type) {
     out_->buffers.resize(2, buffer_);
@@ -600,6 +619,11 @@ class RepeatedArrayFactory {
   RepeatedArrayFactory(MemoryPool* pool, const Scalar& scalar, int64_t length)
       : pool_(pool), scalar_(scalar), length_(length) {}
 
+  template <typename T>
+  const auto& scalar() const {
+    return checked_cast<const typename TypeTraits<T>::ScalarType&>(scalar_);
+  }
+
   Result<std::shared_ptr<Array>> Create() {
     RETURN_NOT_OK(VisitTypeInline(*scalar_.type, this));
     return out_;
@@ -621,7 +645,7 @@ class RepeatedArrayFactory {
   template <typename T>
   enable_if_t<is_number_type<T>::value || is_temporal_type<T>::value, Status> Visit(
       const T&) {
-    auto value = checked_cast<const typename TypeTraits<T>::ScalarType&>(scalar_).value;
+    auto value = scalar<T>().value;
     return FinishFixedWidth(&value, sizeof(value));
   }
 
@@ -632,8 +656,7 @@ class RepeatedArrayFactory {
 
   template <typename T>
   enable_if_decimal<T, Status> Visit(const T&) {
-    using ScalarType = typename TypeTraits<T>::ScalarType;
-    auto value = checked_cast<const ScalarType&>(scalar_).value.ToBytes();
+    auto value = scalar<T>().value.ToBytes();
     return FinishFixedWidth(value.data(), value.size());
   }
 
@@ -644,29 +667,36 @@ class RepeatedArrayFactory {
 
   template <typename T>
   enable_if_base_binary<T, Status> Visit(const T&) {
-    std::shared_ptr<Buffer> value =
-        checked_cast<const typename TypeTraits<T>::ScalarType&>(scalar_).value;
+    const std::shared_ptr<Buffer>& value = scalar<T>().value;
     std::shared_ptr<Buffer> values_buffer, offsets_buffer;
     RETURN_NOT_OK(CreateBufferOf(value->data(), value->size(), &values_buffer));
     auto size = static_cast<typename T::offset_type>(value->size());
     RETURN_NOT_OK(CreateOffsetsBuffer(size, &offsets_buffer));
-    out_ = std::make_shared<typename TypeTraits<T>::ArrayType>(length_, offsets_buffer,
-                                                               values_buffer);
+    out_ = std::make_shared<typename TypeTraits<T>::ArrayType>(
+        length_, std::move(offsets_buffer), std::move(values_buffer));
+    return Status::OK();
+  }
+
+  template <typename T>
+  enable_if_binary_view_like<T, Status> Visit(const T& type) {
+    std::string_view value{*scalar<T>().value};
+    auto s = util::ToBinaryView(value, 0, 0);
+    RETURN_NOT_OK(FinishFixedWidth(&s, sizeof(s)));
+    if (!s.is_inline()) {
+      out_->data()->buffers.push_back(scalar<T>().value);
+    }
     return Status::OK();
   }
 
   template <typename T>
   enable_if_var_size_list<T, Status> Visit(const T& type) {
-    using ScalarType = typename TypeTraits<T>::ScalarType;
     using ArrayType = typename TypeTraits<T>::ArrayType;
 
-    auto value = checked_cast<const ScalarType&>(scalar_).value;
-
-    ArrayVector values(length_, value);
+    ArrayVector values(length_, scalar<T>().value);
     ARROW_ASSIGN_OR_RAISE(auto value_array, Concatenate(values, pool_));
 
     std::shared_ptr<Buffer> offsets_buffer;
-    auto size = static_cast<typename T::offset_type>(value->length());
+    auto size = static_cast<typename T::offset_type>(scalar<T>().value->length());
     RETURN_NOT_OK(CreateOffsetsBuffer(size, &offsets_buffer));
 
     out_ =
diff --git a/cpp/src/arrow/array/validate.cc b/cpp/src/arrow/array/validate.cc
index 19ff8e28b536c..3dde41b1450e8 100644
--- a/cpp/src/arrow/array/validate.cc
+++ b/cpp/src/arrow/array/validate.cc
@@ -31,41 +31,43 @@
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ree_util.h"
+#include "arrow/util/sort.h"
+#include "arrow/util/string.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/util/utf8.h"
 #include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
-namespace arrow {
-namespace internal {
+namespace arrow::internal {
 
 namespace {
 
 struct UTF8DataValidator {
   const ArrayData& data;
 
-  Status Visit(const DataType&) {
-    // Default, should be unreachable
-    return Status::NotImplemented("");
-  }
+  template <typename T>
+  Status Visit(const T&) {
+    if constexpr (std::is_same_v<T, StringType> || std::is_same_v<T, LargeStringType> ||
+                  std::is_same_v<T, StringViewType>) {
+      util::InitializeUTF8();
 
-  template <typename StringType>
-  enable_if_string<StringType, Status> Visit(const StringType&) {
-    util::InitializeUTF8();
-
-    int64_t i = 0;
-    return VisitArraySpanInline<StringType>(
-        data,
-        [&](std::string_view v) {
-          if (ARROW_PREDICT_FALSE(!util::ValidateUTF8(v))) {
-            return Status::Invalid("Invalid UTF8 sequence at string index ", i);
-          }
-          ++i;
-          return Status::OK();
-        },
-        [&]() {
-          ++i;
-          return Status::OK();
-        });
+      int64_t i = 0;
+      return VisitArraySpanInline<T>(
+          data,
+          [&](std::string_view v) {
+            if (ARROW_PREDICT_FALSE(!util::ValidateUTF8(v))) {
+              return Status::Invalid("Invalid UTF8 sequence at string index ", i);
+            }
+            ++i;
+            return Status::OK();
+          },
+          [&]() {
+            ++i;
+            return Status::OK();
+          });
+    } else {
+      Unreachable("utf-8 validation of non string type");
+    }
   }
 };
 
@@ -169,6 +171,14 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
+  Status Visit(const StringViewType& type) {
+    RETURN_NOT_OK(ValidateBinaryView(type));
+    if (full_validation) {
+      RETURN_NOT_OK(ValidateUTF8(data));
+    }
+    return Status::OK();
+  }
+
   Status Visit(const Date64Type& type) {
     RETURN_NOT_OK(ValidateFixedWidthBuffers());
 
@@ -248,6 +258,8 @@ struct ValidateArrayImpl {
 
   Status Visit(const LargeBinaryType& type) { return ValidateBinaryLike(type); }
 
+  Status Visit(const BinaryViewType& type) { return ValidateBinaryView(type); }
+
   Status Visit(const ListType& type) { return ValidateListLike(type); }
 
   Status Visit(const LargeListType& type) { return ValidateListLike(type); }
@@ -453,11 +465,16 @@ struct ValidateArrayImpl {
       return Status::Invalid("Array length is negative");
     }
 
-    if (data.buffers.size() != layout.buffers.size()) {
+    if (layout.variadic_spec) {
+      if (data.buffers.size() < layout.buffers.size()) {
+        return Status::Invalid("Expected at least ", layout.buffers.size(),
+                               " buffers in array of type ", type.ToString(), ", got ",
+                               data.buffers.size());
+      }
+    } else if (data.buffers.size() != layout.buffers.size()) {
       return Status::Invalid("Expected ", layout.buffers.size(),
-                             " buffers in array "
-                             "of type ",
-                             type.ToString(), ", got ", data.buffers.size());
+                             " buffers in array of type ", type.ToString(), ", got ",
+                             data.buffers.size());
     }
 
     // This check is required to avoid addition overflow below
@@ -469,7 +486,9 @@ struct ValidateArrayImpl {
 
     for (int i = 0; i < static_cast<int>(data.buffers.size()); ++i) {
       const auto& buffer = data.buffers[i];
-      const auto& spec = layout.buffers[i];
+      const auto& spec = i < static_cast<int>(layout.buffers.size())
+                             ? layout.buffers[i]
+                             : *layout.variadic_spec;
 
       if (buffer == nullptr) {
         continue;
@@ -595,6 +614,85 @@ struct ValidateArrayImpl {
     return Status::OK();
   }
 
+  Status ValidateBinaryView(const BinaryViewType& type) {
+    int64_t views_byte_size = data.buffers[1]->size();
+    int64_t required_view_count = data.length + data.offset;
+    if (static_cast<int64_t>(views_byte_size / BinaryViewType::kSize) <
+        required_view_count) {
+      return Status::Invalid("View buffer size (bytes): ", views_byte_size,
+                             " isn't large enough for length: ", data.length,
+                             " and offset: ", data.offset);
+    }
+
+    if (!full_validation) return Status::OK();
+
+    auto CheckPrefix = [&](size_t i,
+                           std::array<uint8_t, BinaryViewType::kPrefixSize> prefix,
+                           const uint8_t* data) {
+      if (std::memcmp(data, prefix.data(), BinaryViewType::kPrefixSize) == 0) {
+        return Status::OK();
+      }
+      return Status::Invalid("View at slot ", i, " has inlined prefix 0x",
+                             HexEncode(prefix.data(), BinaryViewType::kPrefixSize),
+                             " but the out-of-line data begins with 0x",
+                             HexEncode(data, BinaryViewType::kPrefixSize));
+    };
+
+    util::span views(data.GetValues<BinaryViewType::c_type>(1),
+                     static_cast<size_t>(data.length));
+    util::span data_buffers(data.buffers.data() + 2, data.buffers.size() - 2);
+
+    for (size_t i = 0; i < static_cast<size_t>(data.length); ++i) {
+      if (data.IsNull(i)) continue;
+
+      if (views[i].size() < 0) {
+        return Status::Invalid("View at slot ", i, " has negative size ",
+                               views[i].size());
+      }
+
+      if (views[i].is_inline()) {
+        auto padding_bytes = util::span(views[i].inlined.data).subspan(views[i].size());
+        for (auto padding_byte : padding_bytes) {
+          if (padding_byte != 0) {
+            return Status::Invalid("View at slot ", i, " was inline with size ",
+                                   views[i].size(),
+                                   " but its padding bytes were not all zero: ",
+                                   HexEncode(padding_bytes.data(), padding_bytes.size()));
+          }
+        }
+        continue;
+      }
+
+      auto [size, prefix, buffer_index, offset] = views[i].ref;
+
+      if (buffer_index < 0) {
+        return Status::Invalid("View at slot ", i, " has negative buffer index ",
+                               buffer_index);
+      }
+
+      if (offset < 0) {
+        return Status::Invalid("View at slot ", i, " has negative offset ", offset);
+      }
+
+      if (static_cast<size_t>(buffer_index) >= data_buffers.size()) {
+        return Status::IndexError("View at slot ", i, " references buffer ", buffer_index,
+                                  " but there are only ", data_buffers.size(),
+                                  " data buffers");
+      }
+      const auto& buffer = data_buffers[buffer_index];
+
+      if (int64_t end = offset + static_cast<int64_t>(size); end > buffer->size()) {
+        return Status::IndexError(
+            "View at slot ", i, " references range ", offset, "-", end, " of buffer ",
+            buffer_index, " but that buffer is only ", buffer->size(), " bytes long");
+      }
+
+      RETURN_NOT_OK(CheckPrefix(i, prefix, buffer->data() + offset));
+    }
+
+    return Status::OK();
+  }
+
   template <typename ListType>
   Status ValidateListLike(const ListType& type) {
     const ArrayData& values = *data.child_data[0];
@@ -798,7 +896,8 @@ Status ValidateArrayFull(const Array& array) { return ValidateArrayFull(*array.d
 
 ARROW_EXPORT
 Status ValidateUTF8(const ArrayData& data) {
-  DCHECK(data.type->id() == Type::STRING || data.type->id() == Type::LARGE_STRING);
+  DCHECK(data.type->id() == Type::STRING || data.type->id() == Type::STRING_VIEW ||
+         data.type->id() == Type::LARGE_STRING);
   UTF8DataValidator validator{data};
   return VisitTypeInline(*data.type, &validator);
 }
@@ -806,5 +905,4 @@ Status ValidateUTF8(const ArrayData& data) {
 ARROW_EXPORT
 Status ValidateUTF8(const Array& array) { return ValidateUTF8(*array.data()); }
 
-}  // namespace internal
-}  // namespace arrow
+}  // namespace arrow::internal
diff --git a/cpp/src/arrow/buffer_builder.h b/cpp/src/arrow/buffer_builder.h
index e7eea64043ba8..a84c98b6b2491 100644
--- a/cpp/src/arrow/buffer_builder.h
+++ b/cpp/src/arrow/buffer_builder.h
@@ -143,7 +143,10 @@ class ARROW_EXPORT BufferBuilder {
     memcpy(data_ + size_, data, static_cast<size_t>(length));
     size_ += length;
   }
-  void UnsafeAppend(std::string_view v) { UnsafeAppend(v.data(), v.size()); }
+
+  void UnsafeAppend(std::string_view v) {
+    UnsafeAppend(v.data(), static_cast<int64_t>(v.size()));
+  }
 
   void UnsafeAppend(const int64_t num_copies, uint8_t value) {
     memset(data_ + size_, value, static_cast<size_t>(num_copies));
@@ -268,7 +271,7 @@ class TypedBufferBuilder<
 
   template <typename Iter>
   void UnsafeAppend(Iter values_begin, Iter values_end) {
-    int64_t num_elements = static_cast<int64_t>(std::distance(values_begin, values_end));
+    auto num_elements = static_cast<int64_t>(std::distance(values_begin, values_end));
     auto data = mutable_data() + length();
     bytes_builder_.UnsafeAdvance(num_elements * sizeof(T));
     std::copy(values_begin, values_end, data);
diff --git a/cpp/src/arrow/builder.cc b/cpp/src/arrow/builder.cc
index caddbf9db5578..c7e6207bfefa4 100644
--- a/cpp/src/arrow/builder.cc
+++ b/cpp/src/arrow/builder.cc
@@ -148,6 +148,8 @@ struct DictionaryBuilderCase {
   Status Visit(const StringType&) { return CreateFor<StringType>(); }
   Status Visit(const LargeBinaryType&) { return CreateFor<LargeBinaryType>(); }
   Status Visit(const LargeStringType&) { return CreateFor<LargeStringType>(); }
+  Status Visit(const BinaryViewType&) { return CreateFor<BinaryViewType>(); }
+  Status Visit(const StringViewType&) { return CreateFor<StringViewType>(); }
   Status Visit(const FixedSizeBinaryType&) { return CreateFor<FixedSizeBinaryType>(); }
   Status Visit(const Decimal128Type&) { return CreateFor<Decimal128Type>(); }
   Status Visit(const Decimal256Type&) { return CreateFor<Decimal256Type>(); }
@@ -190,7 +192,7 @@ struct DictionaryBuilderCase {
 
 struct MakeBuilderImpl {
   template <typename T>
-  enable_if_not_nested<T, Status> Visit(const T&) {
+  enable_if_not_nested<T, Status> Visit(const T& t) {
     out.reset(new typename TypeTraits<T>::BuilderType(type, pool));
     return Status::OK();
   }
diff --git a/cpp/src/arrow/compare.cc b/cpp/src/arrow/compare.cc
index df41cd22c9e06..50cfdd05a14bb 100644
--- a/cpp/src/arrow/compare.cc
+++ b/cpp/src/arrow/compare.cc
@@ -38,6 +38,7 @@
 #include "arrow/tensor.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/bit_run_reader.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
@@ -261,6 +262,25 @@ class RangeDataEqualsImpl {
   // Also matches StringType
   Status Visit(const BinaryType& type) { return CompareBinary(type); }
 
+  // Also matches StringViewType
+  Status Visit(const BinaryViewType& type) {
+    auto* left_values = left_.GetValues<BinaryViewType::c_type>(1) + left_start_idx_;
+    auto* right_values = right_.GetValues<BinaryViewType::c_type>(1) + right_start_idx_;
+
+    auto* left_buffers = left_.buffers.data() + 2;
+    auto* right_buffers = right_.buffers.data() + 2;
+    VisitValidRuns([&](int64_t i, int64_t length) {
+      for (auto end_i = i + length; i < end_i; ++i) {
+        if (!util::EqualBinaryView(left_values[i], right_values[i], left_buffers,
+                                   right_buffers)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    return Status::OK();
+  }
+
   // Also matches LargeStringType
   Status Visit(const LargeBinaryType& type) { return CompareBinary(type); }
 
@@ -632,6 +652,11 @@ class TypeEqualsVisitor {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType&) {
+    result_ = true;
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_interval<T, Status> Visit(const T& left) {
     const auto& right = checked_cast<const IntervalType&>(right_);
@@ -802,8 +827,7 @@ class ScalarEqualsVisitor {
   Status Visit(const DoubleScalar& left) { return CompareFloating(left); }
 
   template <typename T>
-  typename std::enable_if<std::is_base_of<BaseBinaryScalar, T>::value, Status>::type
-  Visit(const T& left) {
+  enable_if_t<std::is_base_of<BaseBinaryScalar, T>::value, Status> Visit(const T& left) {
     const auto& right = checked_cast<const BaseBinaryScalar&>(right_);
     result_ = internal::SharedPtrEquals(left.value, right.value);
     return Status::OK();
diff --git a/cpp/src/arrow/compute/kernels/vector_hash.cc b/cpp/src/arrow/compute/kernels/vector_hash.cc
index d9143b760f32b..5426dc405429c 100644
--- a/cpp/src/arrow/compute/kernels/vector_hash.cc
+++ b/cpp/src/arrow/compute/kernels/vector_hash.cc
@@ -31,6 +31,7 @@
 #include "arrow/compute/kernels/common_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/hashing.h"
+#include "arrow/util/unreachable.h"
 
 namespace arrow {
 
@@ -262,7 +263,7 @@ class HashKernel : public KernelState {
 // Base class for all "regular" hash kernel implementations
 // (NullType has a separate implementation)
 
-template <typename Type, typename Scalar, typename Action,
+template <typename Type, typename Action, typename Scalar = typename Type::c_type,
           bool with_error_status = Action::with_error_status>
 class RegularHashKernel : public HashKernel {
  public:
@@ -503,39 +504,13 @@ class DictionaryHashKernel : public HashKernel {
 };
 
 // ----------------------------------------------------------------------
-
-template <typename Type, typename Action, typename Enable = void>
-struct HashKernelTraits {};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_null<Type>> {
-  using HashKernel = NullHashKernel<Action>;
-};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_has_c_type<Type>> {
-  using HashKernel = RegularHashKernel<Type, typename Type::c_type, Action>;
-};
-
-template <typename Type, typename Action>
-struct HashKernelTraits<Type, Action, enable_if_has_string_view<Type>> {
-  using HashKernel = RegularHashKernel<Type, std::string_view, Action>;
-};
-
-template <typename Type, typename Action>
-Result<std::unique_ptr<HashKernel>> HashInitImpl(KernelContext* ctx,
-                                                 const KernelInitArgs& args) {
-  using HashKernelType = typename HashKernelTraits<Type, Action>::HashKernel;
-  auto result = std::make_unique<HashKernelType>(args.inputs[0].GetSharedPtr(),
-                                                 args.options, ctx->memory_pool());
-  RETURN_NOT_OK(result->Reset());
-  return std::move(result);
-}
-
-template <typename Type, typename Action>
+template <typename HashKernel>
 Result<std::unique_ptr<KernelState>> HashInit(KernelContext* ctx,
                                               const KernelInitArgs& args) {
-  return HashInitImpl<Type, Action>(ctx, args);
+  auto result = std::make_unique<HashKernel>(args.inputs[0].GetSharedPtr(), args.options,
+                                             ctx->memory_pool());
+  RETURN_NOT_OK(result->Reset());
+  return std::move(result);
 }
 
 template <typename Action>
@@ -544,22 +519,22 @@ KernelInit GetHashInit(Type::type type_id) {
   // representation
   switch (type_id) {
     case Type::NA:
-      return HashInit<NullType, Action>;
+      return HashInit<NullHashKernel<Action>>;
     case Type::BOOL:
-      return HashInit<BooleanType, Action>;
+      return HashInit<RegularHashKernel<BooleanType, Action>>;
     case Type::INT8:
     case Type::UINT8:
-      return HashInit<UInt8Type, Action>;
+      return HashInit<RegularHashKernel<UInt8Type, Action>>;
     case Type::INT16:
     case Type::UINT16:
-      return HashInit<UInt16Type, Action>;
+      return HashInit<RegularHashKernel<UInt16Type, Action>>;
     case Type::INT32:
     case Type::UINT32:
     case Type::FLOAT:
     case Type::DATE32:
     case Type::TIME32:
     case Type::INTERVAL_MONTHS:
-      return HashInit<UInt32Type, Action>;
+      return HashInit<RegularHashKernel<UInt32Type, Action>>;
     case Type::INT64:
     case Type::UINT64:
     case Type::DOUBLE:
@@ -568,22 +543,24 @@ KernelInit GetHashInit(Type::type type_id) {
     case Type::TIMESTAMP:
     case Type::DURATION:
     case Type::INTERVAL_DAY_TIME:
-      return HashInit<UInt64Type, Action>;
+      return HashInit<RegularHashKernel<UInt64Type, Action>>;
     case Type::BINARY:
     case Type::STRING:
-      return HashInit<BinaryType, Action>;
+      return HashInit<RegularHashKernel<BinaryType, Action, std::string_view>>;
     case Type::LARGE_BINARY:
     case Type::LARGE_STRING:
-      return HashInit<LargeBinaryType, Action>;
+      return HashInit<RegularHashKernel<LargeBinaryType, Action, std::string_view>>;
+    case Type::BINARY_VIEW:
+    case Type::STRING_VIEW:
+      return HashInit<RegularHashKernel<BinaryViewType, Action, std::string_view>>;
     case Type::FIXED_SIZE_BINARY:
     case Type::DECIMAL128:
     case Type::DECIMAL256:
-      return HashInit<FixedSizeBinaryType, Action>;
+      return HashInit<RegularHashKernel<FixedSizeBinaryType, Action, std::string_view>>;
     case Type::INTERVAL_MONTH_DAY_NANO:
-      return HashInit<MonthDayNanoIntervalType, Action>;
+      return HashInit<RegularHashKernel<MonthDayNanoIntervalType, Action>>;
     default:
-      DCHECK(false);
-      return nullptr;
+      Unreachable("non hashable type");
   }
 }
 
@@ -593,31 +570,11 @@ template <typename Action>
 Result<std::unique_ptr<KernelState>> DictionaryHashInit(KernelContext* ctx,
                                                         const KernelInitArgs& args) {
   const auto& dict_type = checked_cast<const DictionaryType&>(*args.inputs[0].type);
-  Result<std::unique_ptr<HashKernel>> indices_hasher;
-  switch (dict_type.index_type()->id()) {
-    case Type::INT8:
-    case Type::UINT8:
-      indices_hasher = HashInitImpl<UInt8Type, Action>(ctx, args);
-      break;
-    case Type::INT16:
-    case Type::UINT16:
-      indices_hasher = HashInitImpl<UInt16Type, Action>(ctx, args);
-      break;
-    case Type::INT32:
-    case Type::UINT32:
-      indices_hasher = HashInitImpl<UInt32Type, Action>(ctx, args);
-      break;
-    case Type::INT64:
-    case Type::UINT64:
-      indices_hasher = HashInitImpl<UInt64Type, Action>(ctx, args);
-      break;
-    default:
-      DCHECK(false) << "Unsupported dictionary index type";
-      break;
-  }
-  RETURN_NOT_OK(indices_hasher);
-  return std::make_unique<DictionaryHashKernel>(std::move(indices_hasher.ValueOrDie()),
-                                                dict_type.value_type());
+  ARROW_ASSIGN_OR_RAISE(auto indices_hasher,
+                        GetHashInit<Action>(dict_type.index_type()->id())(ctx, args));
+  return std::make_unique<DictionaryHashKernel>(
+      checked_pointer_cast<HashKernel>(std::move(indices_hasher)),
+      dict_type.value_type());
 }
 
 Status HashExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc
index 0df8425609ff1..d395261597696 100644
--- a/cpp/src/arrow/engine/substrait/expression_internal.cc
+++ b/cpp/src/arrow/engine/substrait/expression_internal.cc
@@ -727,6 +727,8 @@ struct ScalarToProtoImpl {
                       s);
   }
 
+  Status Visit(const BinaryViewScalar& s) { return NotImplemented(s); }
+
   Status Visit(const FixedSizeBinaryScalar& s) {
     return FromBuffer(
         [](Lit* lit, std::string&& s) { lit->set_fixed_binary(std::move(s)); }, s);
diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc
index 1f9141f36ba6b..d3fb058137e6a 100644
--- a/cpp/src/arrow/engine/substrait/type_internal.cc
+++ b/cpp/src/arrow/engine/substrait/type_internal.cc
@@ -263,6 +263,8 @@ struct DataTypeToProtoImpl {
     return SetWith(&substrait::Type::set_allocated_binary);
   }
 
+  Status Visit(const BinaryViewType& t) { return NotImplemented(t); }
+
   Status Visit(const FixedSizeBinaryType& t) {
     SetWithThen(&substrait::Type::set_allocated_fixed_binary)->set_length(t.byte_width());
     return Status::OK();
diff --git a/cpp/src/arrow/integration/json_internal.cc b/cpp/src/arrow/integration/json_internal.cc
index ed7be4b502985..59749c36a958e 100644
--- a/cpp/src/arrow/integration/json_internal.cc
+++ b/cpp/src/arrow/integration/json_internal.cc
@@ -48,6 +48,7 @@
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/range.h"
+#include "arrow/util/span.h"
 #include "arrow/util/string.h"
 #include "arrow/util/value_parsing.h"
 #include "arrow/visit_array_inline.h"
@@ -106,6 +107,13 @@ std::string GetTimeUnitName(TimeUnit::type unit) {
   return "UNKNOWN";
 }
 
+Result<std::string_view> GetStringView(const rj::Value& str) {
+  if (!str.IsString()) {
+    return Status::Invalid("field was not a string");
+  }
+  return std::string_view{str.GetString(), str.GetStringLength()};
+}
+
 class SchemaWriter {
  public:
   explicit SchemaWriter(const Schema& schema, const DictionaryFieldMapper& mapper,
@@ -226,8 +234,9 @@ class SchemaWriter {
 
   template <typename T>
   enable_if_t<is_null_type<T>::value || is_primitive_ctype<T>::value ||
-              is_base_binary_type<T>::value || is_var_length_list_type<T>::value ||
-              is_struct_type<T>::value || is_run_end_encoded_type<T>::value>
+              is_base_binary_type<T>::value || is_binary_view_like_type<T>::value ||
+              is_var_length_list_type<T>::value || is_struct_type<T>::value ||
+              is_run_end_encoded_type<T>::value>
   WriteTypeMetadata(const T& type) {}
 
   void WriteTypeMetadata(const MapType& type) {
@@ -382,6 +391,8 @@ class SchemaWriter {
   Status Visit(const TimeType& type) { return WritePrimitive("time", type); }
   Status Visit(const StringType& type) { return WriteVarBytes("utf8", type); }
   Status Visit(const BinaryType& type) { return WriteVarBytes("binary", type); }
+  Status Visit(const StringViewType& type) { return WritePrimitive("utf8view", type); }
+  Status Visit(const BinaryViewType& type) { return WritePrimitive("binaryview", type); }
   Status Visit(const LargeStringType& type) { return WriteVarBytes("largeutf8", type); }
   Status Visit(const LargeBinaryType& type) { return WriteVarBytes("largebinary", type); }
   Status Visit(const FixedSizeBinaryType& type) {
@@ -528,22 +539,19 @@ class ArrayWriter {
     }
   }
 
-  // Binary, encode to hexadecimal.
-  template <typename ArrayType>
-  enable_if_binary_like<typename ArrayType::TypeClass> WriteDataValues(
-      const ArrayType& arr) {
-    for (int64_t i = 0; i < arr.length(); ++i) {
-      writer_->String(HexEncode(arr.GetView(i)));
-    }
-  }
-
-  // UTF8 string, write as is
-  template <typename ArrayType>
-  enable_if_string_like<typename ArrayType::TypeClass> WriteDataValues(
-      const ArrayType& arr) {
+  template <typename ArrayType, typename Type = typename ArrayType::TypeClass>
+  std::enable_if_t<is_base_binary_type<Type>::value ||
+                   is_fixed_size_binary_type<Type>::value>
+  WriteDataValues(const ArrayType& arr) {
     for (int64_t i = 0; i < arr.length(); ++i) {
-      auto view = arr.GetView(i);
-      writer_->String(view.data(), static_cast<rj::SizeType>(view.size()));
+      if constexpr (Type::is_utf8) {
+        // UTF8 string, write as is
+        auto view = arr.GetView(i);
+        writer_->String(view.data(), static_cast<rj::SizeType>(view.size()));
+      } else {
+        // Binary, encode to hexadecimal.
+        writer_->String(HexEncode(arr.GetView(i)));
+      }
     }
   }
 
@@ -642,6 +650,50 @@ class ArrayWriter {
     writer_->EndArray();
   }
 
+  template <typename ArrayType>
+  void WriteBinaryViewField(const ArrayType& array) {
+    writer_->Key("VIEWS");
+    writer_->StartArray();
+    for (int64_t i = 0; i < array.length(); ++i) {
+      auto s = array.raw_values()[i];
+      writer_->StartObject();
+      writer_->Key("SIZE");
+      writer_->Int64(s.size());
+      if (s.is_inline()) {
+        writer_->Key("INLINED");
+        if constexpr (ArrayType::TypeClass::is_utf8) {
+          writer_->String(reinterpret_cast<const char*>(s.inline_data()), s.size());
+        } else {
+          writer_->String(HexEncode(s.inline_data(), s.size()));
+        }
+      } else {
+        // Prefix is always 4 bytes so it may not be utf-8 even if the whole
+        // string view is
+        writer_->Key("PREFIX_HEX");
+        writer_->String(HexEncode(s.inline_data(), BinaryViewType::kPrefixSize));
+        writer_->Key("BUFFER_INDEX");
+        writer_->Int64(s.ref.buffer_index);
+        writer_->Key("OFFSET");
+        writer_->Int64(s.ref.offset);
+      }
+      writer_->EndObject();
+    }
+    writer_->EndArray();
+  }
+
+  void WriteVariadicBuffersField(const BinaryViewArray& arr) {
+    writer_->Key("VARIADIC_DATA_BUFFERS");
+    writer_->StartArray();
+    const auto& buffers = arr.data()->buffers;
+    for (size_t i = 2; i < buffers.size(); ++i) {
+      // Encode the data buffers into hexadecimal strings.
+      // Even for arrays which contain utf-8, portions of the buffer not
+      // referenced by any view may be invalid.
+      writer_->String(buffers[i]->ToHexString());
+    }
+    writer_->EndArray();
+  }
+
   void WriteValidityField(const Array& arr) {
     writer_->Key("VALIDITY");
     writer_->StartArray();
@@ -682,8 +734,10 @@ class ArrayWriter {
   }
 
   template <typename ArrayType>
-  enable_if_t<std::is_base_of<PrimitiveArray, ArrayType>::value, Status> Visit(
-      const ArrayType& array) {
+  enable_if_t<std::is_base_of<PrimitiveArray, ArrayType>::value &&
+                  !is_binary_view_like_type<typename ArrayType::TypeClass>::value,
+              Status>
+  Visit(const ArrayType& array) {
     WriteValidityField(array);
     WriteDataField(array);
     SetNoChildren();
@@ -700,6 +754,17 @@ class ArrayWriter {
     return Status::OK();
   }
 
+  template <typename ArrayType>
+  enable_if_binary_view_like<typename ArrayType::TypeClass, Status> Visit(
+      const ArrayType& array) {
+    WriteValidityField(array);
+    WriteBinaryViewField(array);
+    WriteVariadicBuffersField(array);
+
+    SetNoChildren();
+    return Status::OK();
+  }
+
   Status Visit(const DictionaryArray& array) {
     return VisitArrayValues(*array.indices());
   }
@@ -1033,6 +1098,10 @@ Result<std::shared_ptr<DataType>> GetType(const RjObject& json_type,
     return utf8();
   } else if (type_name == "binary") {
     return binary();
+  } else if (type_name == "utf8view") {
+    return utf8_view();
+  } else if (type_name == "binaryview") {
+    return binary_view();
   } else if (type_name == "largeutf8") {
     return large_utf8();
   } else if (type_name == "largebinary") {
@@ -1246,10 +1315,12 @@ class ArrayReader {
     return Status::OK();
   }
 
-  Result<const RjArray> GetDataArray(const RjObject& obj) {
-    ARROW_ASSIGN_OR_RAISE(const auto json_data_arr, GetMemberArray(obj, kData));
+  Result<const RjArray> GetDataArray(const RjObject& obj,
+                                     const std::string& key = kData) {
+    ARROW_ASSIGN_OR_RAISE(const auto json_data_arr, GetMemberArray(obj, key));
     if (static_cast<int32_t>(json_data_arr.Size()) != length_) {
-      return Status::Invalid("JSON DATA array size differs from advertised array length");
+      return Status::Invalid("JSON ", key, " array size ", json_data_arr.Size(),
+                             " differs from advertised array length ", length_);
     }
     return json_data_arr;
   }
@@ -1293,10 +1364,7 @@ class ArrayReader {
         RETURN_NOT_OK(builder.AppendNull());
         continue;
       }
-
-      DCHECK(json_val.IsString());
-      std::string_view val{
-          json_val.GetString()};  // XXX can we use json_val.GetStringLength()?
+      ARROW_ASSIGN_OR_RAISE(auto val, GetStringView(json_val));
 
       int64_t offset_start = ParseOffset(json_offsets[i]);
       int64_t offset_end = ParseOffset(json_offsets[i + 1]);
@@ -1332,6 +1400,97 @@ class ArrayReader {
     return FinishBuilder(&builder);
   }
 
+  template <typename ViewType>
+  enable_if_binary_view_like<ViewType, Status> Visit(const ViewType& type) {
+    ARROW_ASSIGN_OR_RAISE(const auto json_views, GetDataArray(obj_, "VIEWS"));
+    ARROW_ASSIGN_OR_RAISE(const auto json_variadic_bufs,
+                          GetMemberArray(obj_, "VARIADIC_DATA_BUFFERS"));
+
+    using internal::Zip;
+    using util::span;
+
+    BufferVector buffers;
+    buffers.resize(json_variadic_bufs.Size() + 2);
+    for (auto [json_buf, buf] : Zip(json_variadic_bufs, span{buffers}.subspan(2))) {
+      ARROW_ASSIGN_OR_RAISE(auto hex_string, GetStringView(json_buf));
+      ARROW_ASSIGN_OR_RAISE(
+          buf, AllocateBuffer(static_cast<int64_t>(hex_string.size()) / 2, pool_));
+      RETURN_NOT_OK(ParseHexValues(hex_string, buf->mutable_data()));
+    }
+
+    TypedBufferBuilder<bool> validity_builder{pool_};
+    RETURN_NOT_OK(validity_builder.Resize(length_));
+    for (bool is_valid : is_valid_) {
+      validity_builder.UnsafeAppend(is_valid);
+    }
+    ARROW_ASSIGN_OR_RAISE(buffers[0], validity_builder.Finish());
+
+    ARROW_ASSIGN_OR_RAISE(
+        buffers[1], AllocateBuffer(length_ * sizeof(BinaryViewType::c_type), pool_));
+
+    span views{buffers[1]->mutable_data_as<BinaryViewType::c_type>(),
+               static_cast<size_t>(length_)};
+
+    int64_t null_count = 0;
+    for (auto [json_view, out_view, is_valid] : Zip(json_views, views, is_valid_)) {
+      if (!is_valid) {
+        out_view = {};
+        ++null_count;
+        continue;
+      }
+
+      DCHECK(json_view.IsObject());
+      const auto& json_view_obj = json_view.GetObject();
+
+      auto json_size = json_view_obj.FindMember("SIZE");
+      RETURN_NOT_INT("SIZE", json_size, json_view_obj);
+      DCHECK_GE(json_size->value.GetInt64(), 0);
+      auto size = static_cast<int32_t>(json_size->value.GetInt64());
+
+      if (size <= BinaryViewType::kInlineSize) {
+        auto json_inlined = json_view_obj.FindMember("INLINED");
+        RETURN_NOT_STRING("INLINED", json_inlined, json_view_obj);
+        out_view.inlined = {size, {}};
+
+        if constexpr (ViewType::is_utf8) {
+          DCHECK_LE(json_inlined->value.GetStringLength(), BinaryViewType::kInlineSize);
+          memcpy(&out_view.inlined.data, json_inlined->value.GetString(), size);
+        } else {
+          DCHECK_LE(json_inlined->value.GetStringLength(),
+                    BinaryViewType::kInlineSize * 2);
+          ARROW_ASSIGN_OR_RAISE(auto inlined, GetStringView(json_inlined->value));
+          RETURN_NOT_OK(ParseHexValues(inlined, out_view.inlined.data.data()));
+        }
+        continue;
+      }
+
+      auto json_prefix = json_view_obj.FindMember("PREFIX_HEX");
+      auto json_buffer_index = json_view_obj.FindMember("BUFFER_INDEX");
+      auto json_offset = json_view_obj.FindMember("OFFSET");
+      RETURN_NOT_STRING("PREFIX_HEX", json_prefix, json_view_obj);
+      RETURN_NOT_INT("BUFFER_INDEX", json_buffer_index, json_view_obj);
+      RETURN_NOT_INT("OFFSET", json_offset, json_view_obj);
+
+      out_view.ref = {
+          size,
+          {},
+          static_cast<int32_t>(json_buffer_index->value.GetInt64()),
+          static_cast<int32_t>(json_offset->value.GetInt64()),
+      };
+
+      DCHECK_EQ(json_prefix->value.GetStringLength(), BinaryViewType::kPrefixSize * 2);
+      ARROW_ASSIGN_OR_RAISE(auto prefix, GetStringView(json_prefix->value));
+      RETURN_NOT_OK(ParseHexValues(prefix, out_view.ref.prefix.data()));
+
+      DCHECK_LE(static_cast<size_t>(out_view.ref.buffer_index), buffers.size() - 2);
+      DCHECK_LE(static_cast<int64_t>(out_view.ref.offset) + out_view.size(),
+                buffers[out_view.ref.buffer_index + 2]->size());
+    }
+
+    data_ = ArrayData::Make(type_, length_, std::move(buffers), null_count);
+    return Status::OK();
+  }
+
   Status Visit(const DayTimeIntervalType& type) {
     DayTimeIntervalBuilder builder(pool_);
 
diff --git a/cpp/src/arrow/ipc/feather.cc b/cpp/src/arrow/ipc/feather.cc
index b6d3a3d7d8cbb..1ef076fac40e2 100644
--- a/cpp/src/arrow/ipc/feather.cc
+++ b/cpp/src/arrow/ipc/feather.cc
@@ -536,8 +536,8 @@ struct ArrayWriterV1 {
       is_nested_type<T>::value || is_null_type<T>::value || is_decimal_type<T>::value ||
           std::is_same<DictionaryType, T>::value || is_duration_type<T>::value ||
           is_interval_type<T>::value || is_fixed_size_binary_type<T>::value ||
-          std::is_same<Date64Type, T>::value || std::is_same<Time64Type, T>::value ||
-          std::is_same<ExtensionType, T>::value,
+          is_binary_view_like_type<T>::value || std::is_same<Date64Type, T>::value ||
+          std::is_same<Time64Type, T>::value || std::is_same<ExtensionType, T>::value,
       Status>::type
   Visit(const T& type) {
     return Status::NotImplemented(type.ToString());
diff --git a/cpp/src/arrow/ipc/feather_test.cc b/cpp/src/arrow/ipc/feather_test.cc
index e1d4282cb2635..0b6ae4f620647 100644
--- a/cpp/src/arrow/ipc/feather_test.cc
+++ b/cpp/src/arrow/ipc/feather_test.cc
@@ -264,7 +264,8 @@ TEST_P(TestFeather, TimeTypes) {
 
 TEST_P(TestFeather, VLenPrimitiveRoundTrip) {
   std::shared_ptr<RecordBatch> batch;
-  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch));
+  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true,
+                                                  /*with_view_types=*/false));
   CheckRoundtrip(batch);
 }
 
@@ -306,7 +307,8 @@ TEST_P(TestFeather, SliceFloatRoundTrip) {
 
 TEST_P(TestFeather, SliceStringsRoundTrip) {
   std::shared_ptr<RecordBatch> batch;
-  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true));
+  ASSERT_OK(ipc::test::MakeStringTypesRecordBatch(&batch, /*with_nulls=*/true,
+                                                  /*with_view_types=*/false));
   CheckSlices(batch);
 }
 
diff --git a/cpp/src/arrow/ipc/json_simple.cc b/cpp/src/arrow/ipc/json_simple.cc
index eea0c9730283e..4d2d803f3f65e 100644
--- a/cpp/src/arrow/ipc/json_simple.cc
+++ b/cpp/src/arrow/ipc/json_simple.cc
@@ -847,6 +847,8 @@ Status GetDictConverter(const std::shared_ptr<DataType>& type,
     PARAM_CONVERTER_CASE(Type::BINARY, StringConverter, BinaryType)
     PARAM_CONVERTER_CASE(Type::LARGE_STRING, StringConverter, LargeStringType)
     PARAM_CONVERTER_CASE(Type::LARGE_BINARY, StringConverter, LargeBinaryType)
+    PARAM_CONVERTER_CASE(Type::STRING_VIEW, StringConverter, StringViewType)
+    PARAM_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter, BinaryViewType)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter,
                           FixedSizeBinaryType)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter, Decimal128Type)
@@ -905,6 +907,8 @@ Status GetConverter(const std::shared_ptr<DataType>& type,
     SIMPLE_CONVERTER_CASE(Type::BINARY, StringConverter<BinaryType>)
     SIMPLE_CONVERTER_CASE(Type::LARGE_STRING, StringConverter<LargeStringType>)
     SIMPLE_CONVERTER_CASE(Type::LARGE_BINARY, StringConverter<LargeBinaryType>)
+    SIMPLE_CONVERTER_CASE(Type::STRING_VIEW, StringConverter<StringViewType>)
+    SIMPLE_CONVERTER_CASE(Type::BINARY_VIEW, StringConverter<BinaryViewType>)
     SIMPLE_CONVERTER_CASE(Type::FIXED_SIZE_BINARY, FixedSizeBinaryConverter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL128, Decimal128Converter<>)
     SIMPLE_CONVERTER_CASE(Type::DECIMAL256, Decimal256Converter<>)
diff --git a/cpp/src/arrow/ipc/json_simple_test.cc b/cpp/src/arrow/ipc/json_simple_test.cc
index 6eee5955242aa..b67c26999945b 100644
--- a/cpp/src/arrow/ipc/json_simple_test.cc
+++ b/cpp/src/arrow/ipc/json_simple_test.cc
@@ -271,7 +271,13 @@ INSTANTIATE_TYPED_TEST_SUITE_P(TestHalfFloat, TestIntegers, HalfFloatType);
 template <typename T>
 class TestStrings : public ::testing::Test {
  public:
-  std::shared_ptr<DataType> type() { return TypeTraits<T>::type_singleton(); }
+  std::shared_ptr<DataType> type() const {
+    if constexpr (is_binary_view_like_type<T>::value) {
+      return T::is_utf8 ? utf8_view() : binary_view();
+    } else {
+      return TypeTraits<T>::type_singleton();
+    }
+  }
 };
 
 TYPED_TEST_SUITE_P(TestStrings);
@@ -327,6 +333,8 @@ INSTANTIATE_TYPED_TEST_SUITE_P(TestString, TestStrings, StringType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestBinary, TestStrings, BinaryType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestLargeString, TestStrings, LargeStringType);
 INSTANTIATE_TYPED_TEST_SUITE_P(TestLargeBinary, TestStrings, LargeBinaryType);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestStringView, TestStrings, StringViewType);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestBinaryView, TestStrings, BinaryViewType);
 
 TEST(TestNull, Basics) {
   std::shared_ptr<DataType> type = null();
diff --git a/cpp/src/arrow/ipc/metadata_internal.cc b/cpp/src/arrow/ipc/metadata_internal.cc
index 1394516ecd5ce..ab1a58dd1df8b 100644
--- a/cpp/src/arrow/ipc/metadata_internal.cc
+++ b/cpp/src/arrow/ipc/metadata_internal.cc
@@ -258,6 +258,9 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
     case flatbuf::Type::LargeBinary:
       *out = large_binary();
       return Status::OK();
+    case flatbuf::Type::BinaryView:
+      *out = binary_view();
+      return Status::OK();
     case flatbuf::Type::FixedSizeBinary: {
       auto fw_binary = static_cast<const flatbuf::FixedSizeBinary*>(type_data);
       return FixedSizeBinaryType::Make(fw_binary->byteWidth()).Value(out);
@@ -268,6 +271,9 @@ Status ConcreteTypeFromFlatbuffer(flatbuf::Type type, const void* type_data,
     case flatbuf::Type::LargeUtf8:
       *out = large_utf8();
       return Status::OK();
+    case flatbuf::Type::Utf8View:
+      *out = utf8_view();
+      return Status::OK();
     case flatbuf::Type::Bool:
       *out = boolean();
       return Status::OK();
@@ -534,6 +540,18 @@ class FieldToFlatbufferVisitor {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewType& type) {
+    fb_type_ = flatbuf::Type::BinaryView;
+    type_offset_ = flatbuf::CreateBinaryView(fbb_).Union();
+    return Status::OK();
+  }
+
+  Status Visit(const StringViewType& type) {
+    fb_type_ = flatbuf::Type::Utf8View;
+    type_offset_ = flatbuf::CreateUtf8View(fbb_).Union();
+    return Status::OK();
+  }
+
   Status Visit(const LargeBinaryType& type) {
     fb_type_ = flatbuf::Type::LargeBinary;
     type_offset_ = flatbuf::CreateLargeBinary(fbb_).Union();
@@ -967,6 +985,7 @@ static Status GetBodyCompression(FBB& fbb, const IpcWriteOptions& options,
 static Status MakeRecordBatch(FBB& fbb, int64_t length, int64_t body_length,
                               const std::vector<FieldMetadata>& nodes,
                               const std::vector<BufferMetadata>& buffers,
+                              const std::vector<int64_t>& variadic_buffer_counts,
                               const IpcWriteOptions& options, RecordBatchOffset* offset) {
   FieldNodeVector fb_nodes;
   RETURN_NOT_OK(WriteFieldNodes(fbb, nodes, &fb_nodes));
@@ -977,7 +996,13 @@ static Status MakeRecordBatch(FBB& fbb, int64_t length, int64_t body_length,
   BodyCompressionOffset fb_compression;
   RETURN_NOT_OK(GetBodyCompression(fbb, options, &fb_compression));
 
-  *offset = flatbuf::CreateRecordBatch(fbb, length, fb_nodes, fb_buffers, fb_compression);
+  flatbuffers::Offset<flatbuffers::Vector<int64_t>> fb_variadic_buffer_counts{};
+  if (!variadic_buffer_counts.empty()) {
+    fb_variadic_buffer_counts = fbb.CreateVector(variadic_buffer_counts);
+  }
+
+  *offset = flatbuf::CreateRecordBatch(fbb, length, fb_nodes, fb_buffers, fb_compression,
+                                       fb_variadic_buffer_counts);
   return Status::OK();
 }
 
@@ -1224,11 +1249,12 @@ Status WriteRecordBatchMessage(
     int64_t length, int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out) {
+    const std::vector<int64_t>& variadic_buffer_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out) {
   FBB fbb;
   RecordBatchOffset record_batch;
-  RETURN_NOT_OK(
-      MakeRecordBatch(fbb, length, body_length, nodes, buffers, options, &record_batch));
+  RETURN_NOT_OK(MakeRecordBatch(fbb, length, body_length, nodes, buffers,
+                                variadic_buffer_counts, options, &record_batch));
   return WriteFBMessage(fbb, flatbuf::MessageHeader::RecordBatch, record_batch.Union(),
                         body_length, options.metadata_version, custom_metadata,
                         options.memory_pool)
@@ -1285,11 +1311,12 @@ Status WriteDictionaryMessage(
     int64_t id, bool is_delta, int64_t length, int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out) {
+    const std::vector<int64_t>& variadic_buffer_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out) {
   FBB fbb;
   RecordBatchOffset record_batch;
-  RETURN_NOT_OK(
-      MakeRecordBatch(fbb, length, body_length, nodes, buffers, options, &record_batch));
+  RETURN_NOT_OK(MakeRecordBatch(fbb, length, body_length, nodes, buffers,
+                                variadic_buffer_counts, options, &record_batch));
   auto dictionary_batch =
       flatbuf::CreateDictionaryBatch(fbb, id, record_batch, is_delta).Union();
   return WriteFBMessage(fbb, flatbuf::MessageHeader::DictionaryBatch, dictionary_batch,
diff --git a/cpp/src/arrow/ipc/metadata_internal.h b/cpp/src/arrow/ipc/metadata_internal.h
index abbed5b2dace0..631a336f75a9a 100644
--- a/cpp/src/arrow/ipc/metadata_internal.h
+++ b/cpp/src/arrow/ipc/metadata_internal.h
@@ -201,7 +201,8 @@ Status WriteRecordBatchMessage(
     const int64_t length, const int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out);
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out);
 
 ARROW_EXPORT
 Result<std::shared_ptr<Buffer>> WriteTensorMessage(const Tensor& tensor,
@@ -225,7 +226,8 @@ Status WriteDictionaryMessage(
     const int64_t body_length,
     const std::shared_ptr<const KeyValueMetadata>& custom_metadata,
     const std::vector<FieldMetadata>& nodes, const std::vector<BufferMetadata>& buffers,
-    const IpcWriteOptions& options, std::shared_ptr<Buffer>* out);
+    const std::vector<int64_t>& variadic_counts, const IpcWriteOptions& options,
+    std::shared_ptr<Buffer>* out);
 
 static inline Result<std::shared_ptr<Buffer>> WriteFlatbufferBuilder(
     flatbuffers::FlatBufferBuilder& fbb,  // NOLINT non-const reference
diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 3ae007c20efe7..05a48aec2c7f3 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -159,7 +159,7 @@ TEST_P(TestMessage, SerializeCustomMetadata) {
     ASSERT_OK(internal::WriteRecordBatchMessage(
         /*length=*/0, /*body_length=*/0, metadata,
         /*nodes=*/{},
-        /*buffers=*/{}, options_, &serialized));
+        /*buffers=*/{}, /*variadic_counts=*/{}, options_, &serialized));
     ASSERT_OK_AND_ASSIGN(std::unique_ptr<Message> message,
                          Message::Open(serialized, /*body=*/nullptr));
 
@@ -240,23 +240,33 @@ class TestSchemaMetadata : public ::testing::Test {
   }
 };
 
-const std::shared_ptr<DataType> INT32 = std::make_shared<Int32Type>();
-
 TEST_F(TestSchemaMetadata, PrimitiveFields) {
-  auto f0 = field("f0", std::make_shared<Int8Type>());
-  auto f1 = field("f1", std::make_shared<Int16Type>(), false);
-  auto f2 = field("f2", std::make_shared<Int32Type>());
-  auto f3 = field("f3", std::make_shared<Int64Type>());
-  auto f4 = field("f4", std::make_shared<UInt8Type>());
-  auto f5 = field("f5", std::make_shared<UInt16Type>());
-  auto f6 = field("f6", std::make_shared<UInt32Type>());
-  auto f7 = field("f7", std::make_shared<UInt64Type>());
-  auto f8 = field("f8", std::make_shared<FloatType>());
-  auto f9 = field("f9", std::make_shared<DoubleType>(), false);
-  auto f10 = field("f10", std::make_shared<BooleanType>());
-
-  Schema schema({f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10});
-  CheckSchemaRoundtrip(schema);
+  CheckSchemaRoundtrip(Schema({
+      field("f0", int8()),
+      field("f1", int16(), false),
+      field("f2", int32()),
+      field("f3", int64()),
+      field("f4", uint8()),
+      field("f5", uint16()),
+      field("f6", uint32()),
+      field("f7", uint64()),
+      field("f8", float32()),
+      field("f9", float64(), false),
+      field("f10", boolean()),
+  }));
+}
+
+TEST_F(TestSchemaMetadata, BinaryFields) {
+  CheckSchemaRoundtrip(Schema({
+      field("f0", utf8()),
+      field("f1", binary()),
+      field("f2", large_utf8()),
+      field("f3", large_binary()),
+      field("f4", utf8_view()),
+      field("f5", binary_view()),
+      field("f6", fixed_size_binary(3)),
+      field("f7", fixed_size_binary(33)),
+  }));
 }
 
 TEST_F(TestSchemaMetadata, PrimitiveFieldsWithKeyValueMetadata) {
@@ -269,15 +279,14 @@ TEST_F(TestSchemaMetadata, PrimitiveFieldsWithKeyValueMetadata) {
 }
 
 TEST_F(TestSchemaMetadata, NestedFields) {
-  auto type = list(int32());
-  auto f0 = field("f0", type);
-
-  std::shared_ptr<StructType> type2(
-      new StructType({field("k1", INT32), field("k2", INT32), field("k3", INT32)}));
-  auto f1 = field("f1", type2);
-
-  Schema schema({f0, f1});
-  CheckSchemaRoundtrip(schema);
+  CheckSchemaRoundtrip(Schema({
+      field("f0", list(int32())),
+      field("f1", struct_({
+                      field("k1", int32()),
+                      field("k2", int32()),
+                      field("k3", int32()),
+                  })),
+  }));
 }
 
 // Verify that nullable=false is well-preserved for child fields of map type.
@@ -305,19 +314,15 @@ TEST_F(TestSchemaMetadata, NestedFieldsWithKeyValueMetadata) {
 
 TEST_F(TestSchemaMetadata, DictionaryFields) {
   {
-    auto dict_type = dictionary(int8(), int32(), true /* ordered */);
-    auto f0 = field("f0", dict_type);
-    auto f1 = field("f1", list(dict_type));
-
-    Schema schema({f0, f1});
-    CheckSchemaRoundtrip(schema);
+    auto dict_type = dictionary(int8(), int32(), /*ordered=*/true);
+    CheckSchemaRoundtrip(Schema({
+        field("f0", dict_type),
+        field("f1", list(dict_type)),
+    }));
   }
   {
     auto dict_type = dictionary(int8(), list(int32()));
-    auto f0 = field("f0", dict_type);
-
-    Schema schema({f0});
-    CheckSchemaRoundtrip(schema);
+    CheckSchemaRoundtrip(Schema({field("f0", dict_type)}));
   }
 }
 
@@ -325,9 +330,7 @@ TEST_F(TestSchemaMetadata, NestedDictionaryFields) {
   {
     auto inner_dict_type = dictionary(int8(), int32(), /*ordered=*/true);
     auto dict_type = dictionary(int16(), list(inner_dict_type));
-
-    Schema schema({field("f0", dict_type)});
-    CheckSchemaRoundtrip(schema);
+    CheckSchemaRoundtrip(Schema({field("f0", dict_type)}));
   }
   {
     auto dict_type1 = dictionary(int8(), utf8(), /*ordered=*/true);
@@ -2910,21 +2913,21 @@ void GetReadRecordBatchReadRanges(
   // 1) read magic and footer length IO
   // 2) read footer IO
   // 3) read record batch metadata IO
-  ASSERT_EQ(read_ranges.size(), 3 + expected_body_read_lengths.size());
+  EXPECT_EQ(read_ranges.size(), 3 + expected_body_read_lengths.size());
   const int32_t magic_size = static_cast<int>(strlen(ipc::internal::kArrowMagicBytes));
   // read magic and footer length IO
   auto file_end_size = magic_size + sizeof(int32_t);
   auto footer_length_offset = buffer->size() - file_end_size;
   auto footer_length = bit_util::FromLittleEndian(
       util::SafeLoadAs<int32_t>(buffer->data() + footer_length_offset));
-  ASSERT_EQ(read_ranges[0].length, file_end_size);
+  EXPECT_EQ(read_ranges[0].length, file_end_size);
   // read footer IO
-  ASSERT_EQ(read_ranges[1].length, footer_length);
+  EXPECT_EQ(read_ranges[1].length, footer_length);
   // read record batch metadata.  The exact size is tricky to determine but it doesn't
   // matter for this test and it should be smaller than the footer.
-  ASSERT_LT(read_ranges[2].length, footer_length);
+  EXPECT_LE(read_ranges[2].length, footer_length);
   for (uint32_t i = 0; i < expected_body_read_lengths.size(); i++) {
-    ASSERT_EQ(read_ranges[3 + i].length, expected_body_read_lengths[i]);
+    EXPECT_EQ(read_ranges[3 + i].length, expected_body_read_lengths[i]);
   }
 }
 
diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index 6e801e1f8adb7..d603062d81d4a 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -248,6 +248,15 @@ class ArrayLoader {
     }
   }
 
+  Result<size_t> GetVariadicCount(int i) {
+    auto* variadic_counts = metadata_->variadicBufferCounts();
+    CHECK_FLATBUFFERS_NOT_NULL(variadic_counts, "RecordBatch.variadicBufferCounts");
+    if (i >= static_cast<int>(variadic_counts->size())) {
+      return Status::IOError("variadic_count_index out of range.");
+    }
+    return static_cast<size_t>(variadic_counts->Get(i));
+  }
+
   Status GetFieldMetadata(int field_index, ArrayData* out) {
     auto nodes = metadata_->nodes();
     CHECK_FLATBUFFERS_NOT_NULL(nodes, "Table.nodes");
@@ -296,7 +305,6 @@ class ArrayLoader {
     return Status::OK();
   }
 
-  template <typename TYPE>
   Status LoadBinary(Type::type type_id) {
     DCHECK_NE(out_, nullptr);
     out_->buffers.resize(3);
@@ -355,7 +363,22 @@ class ArrayLoader {
 
   template <typename T>
   enable_if_base_binary<T, Status> Visit(const T& type) {
-    return LoadBinary<T>(type.id());
+    return LoadBinary(type.id());
+  }
+
+  Status Visit(const BinaryViewType& type) {
+    out_->buffers.resize(2);
+
+    RETURN_NOT_OK(LoadCommon(type.id()));
+    RETURN_NOT_OK(GetBuffer(buffer_index_++, &out_->buffers[1]));
+
+    ARROW_ASSIGN_OR_RAISE(auto character_buffer_count,
+                          GetVariadicCount(variadic_count_index_++));
+    out_->buffers.resize(character_buffer_count + 2);
+    for (size_t i = 0; i < character_buffer_count; ++i) {
+      RETURN_NOT_OK(GetBuffer(buffer_index_++, &out_->buffers[i + 2]));
+    }
+    return Status::OK();
   }
 
   Status Visit(const FixedSizeBinaryType& type) {
@@ -450,6 +473,7 @@ class ArrayLoader {
   int buffer_index_ = 0;
   int field_index_ = 0;
   bool skip_io_ = false;
+  int variadic_count_index_ = 0;
 
   BatchDataReadRequest read_request_;
   const Field* field_ = nullptr;
@@ -580,10 +604,9 @@ Result<std::shared_ptr<RecordBatch>> LoadRecordBatchSubset(
 
   // swap endian in a set of ArrayData if necessary (swap_endian == true)
   if (context.swap_endian) {
-    for (int i = 0; i < static_cast<int>(filtered_columns.size()); ++i) {
-      ARROW_ASSIGN_OR_RAISE(filtered_columns[i],
-                            arrow::internal::SwapEndianArrayData(
-                                filtered_columns[i], context.options.memory_pool));
+    for (auto& filtered_column : filtered_columns) {
+      ARROW_ASSIGN_OR_RAISE(filtered_column,
+                            arrow::internal::SwapEndianArrayData(filtered_column));
     }
   }
   return RecordBatch::Make(std::move(filtered_schema), metadata->length(),
diff --git a/cpp/src/arrow/ipc/test_common.cc b/cpp/src/arrow/ipc/test_common.cc
index 53721c0b20fbc..6faaf96b332d4 100644
--- a/cpp/src/arrow/ipc/test_common.cc
+++ b/cpp/src/arrow/ipc/test_common.cc
@@ -351,39 +351,32 @@ static Status MakeBinaryArrayWithUniqueValues(int64_t length, bool include_nulls
   return builder.Finish(out);
 }
 
-Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out, bool with_nulls) {
+Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out, bool with_nulls,
+                                  bool with_view_types) {
   const int64_t length = 500;
-  auto f0 = field("strings", utf8());
-  auto f1 = field("binaries", binary());
-  auto f2 = field("large_strings", large_utf8());
-  auto f3 = field("large_binaries", large_binary());
-  auto schema = ::arrow::schema({f0, f1, f2, f3});
-
-  std::shared_ptr<Array> a0, a1, a2, a3;
-  MemoryPool* pool = default_memory_pool();
 
-  // Quirk with RETURN_NOT_OK macro and templated functions
-  {
-    auto s =
-        MakeBinaryArrayWithUniqueValues<StringBuilder>(length, with_nulls, pool, &a0);
-    RETURN_NOT_OK(s);
+  ArrayVector arrays;
+  FieldVector fields;
+
+  auto AppendColumn = [&](auto& MakeArray) {
+    arrays.emplace_back();
+    RETURN_NOT_OK(MakeArray(length, with_nulls, default_memory_pool(), &arrays.back()));
+
+    const auto& type = arrays.back()->type();
+    fields.push_back(field(type->ToString(), type));
+    return Status::OK();
+  };
+
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<StringBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<BinaryBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<LargeStringBuilder>));
+  RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<LargeBinaryBuilder>));
+  if (with_view_types) {
+    RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<StringViewBuilder>));
+    RETURN_NOT_OK(AppendColumn(MakeBinaryArrayWithUniqueValues<BinaryViewBuilder>));
   }
-  {
-    auto s =
-        MakeBinaryArrayWithUniqueValues<BinaryBuilder>(length, with_nulls, pool, &a1);
-    RETURN_NOT_OK(s);
-  }
-  {
-    auto s = MakeBinaryArrayWithUniqueValues<LargeStringBuilder>(length, with_nulls, pool,
-                                                                 &a2);
-    RETURN_NOT_OK(s);
-  }
-  {
-    auto s = MakeBinaryArrayWithUniqueValues<LargeBinaryBuilder>(length, with_nulls, pool,
-                                                                 &a3);
-    RETURN_NOT_OK(s);
-  }
-  *out = RecordBatch::Make(schema, length, {a0, a1, a2, a3});
+
+  *out = RecordBatch::Make(schema(std::move(fields)), length, std::move(arrays));
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/ipc/test_common.h b/cpp/src/arrow/ipc/test_common.h
index 5e0c65556c630..fc0c8ddbea319 100644
--- a/cpp/src/arrow/ipc/test_common.h
+++ b/cpp/src/arrow/ipc/test_common.h
@@ -96,7 +96,7 @@ Status MakeRandomStringArray(int64_t length, bool include_nulls, MemoryPool* poo
 
 ARROW_TESTING_EXPORT
 Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out,
-                                  bool with_nulls = true);
+                                  bool with_nulls = true, bool with_view_types = true);
 
 ARROW_TESTING_EXPORT
 Status MakeStringTypesRecordBatchWithNulls(std::shared_ptr<RecordBatch>* out);
diff --git a/cpp/src/arrow/ipc/writer.cc b/cpp/src/arrow/ipc/writer.cc
index e4b49ed56464e..9668f459d0d31 100644
--- a/cpp/src/arrow/ipc/writer.cc
+++ b/cpp/src/arrow/ipc/writer.cc
@@ -52,10 +52,12 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/compression.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/int_util_overflow.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/parallel.h"
 #include "arrow/visit_array_inline.h"
+#include "arrow/visit_data_inline.h"
 #include "arrow/visit_type_inline.h"
 
 namespace arrow {
@@ -174,7 +176,8 @@ class RecordBatchSerializer {
   // Override this for writing dictionary metadata
   virtual Status SerializeMetadata(int64_t num_rows) {
     return WriteRecordBatchMessage(num_rows, out_->body_length, custom_metadata_,
-                                   field_nodes_, buffer_meta_, options_, &out_->metadata);
+                                   field_nodes_, buffer_meta_, variadic_counts_, options_,
+                                   &out_->metadata);
   }
 
   bool ShouldCompress(int64_t uncompressed_size, int64_t compressed_size) const {
@@ -296,6 +299,8 @@ class RecordBatchSerializer {
       offset += size + padding;
     }
 
+    variadic_counts_ = out_->variadic_buffer_counts;
+
     out_->body_length = offset - buffer_start_offset_;
     DCHECK(bit_util::IsMultipleOf8(out_->body_length));
 
@@ -403,6 +408,18 @@ class RecordBatchSerializer {
     return Status::OK();
   }
 
+  Status Visit(const BinaryViewArray& array) {
+    auto views = SliceBuffer(array.values(), array.offset() * BinaryViewType::kSize,
+                             array.length() * BinaryViewType::kSize);
+    out_->body_buffers.emplace_back(std::move(views));
+
+    out_->variadic_buffer_counts.emplace_back(array.data()->buffers.size() - 2);
+    for (size_t i = 2; i < array.data()->buffers.size(); ++i) {
+      out_->body_buffers.emplace_back(array.data()->buffers[i]);
+    }
+    return Status::OK();
+  }
+
   template <typename T>
   enable_if_var_size_list<typename T::TypeClass, Status> Visit(const T& array) {
     using offset_type = typename T::offset_type;
@@ -590,6 +607,7 @@ class RecordBatchSerializer {
 
   std::vector<internal::FieldMetadata> field_nodes_;
   std::vector<internal::BufferMetadata> buffer_meta_;
+  std::vector<int64_t> variadic_counts_;
 
   const IpcWriteOptions& options_;
   int64_t max_recursion_depth_;
@@ -606,8 +624,8 @@ class DictionarySerializer : public RecordBatchSerializer {
 
   Status SerializeMetadata(int64_t num_rows) override {
     return WriteDictionaryMessage(dictionary_id_, is_delta_, num_rows, out_->body_length,
-                                  custom_metadata_, field_nodes_, buffer_meta_, options_,
-                                  &out_->metadata);
+                                  custom_metadata_, field_nodes_, buffer_meta_,
+                                  variadic_counts_, options_, &out_->metadata);
   }
 
   Status Assemble(const std::shared_ptr<Array>& dictionary) {
diff --git a/cpp/src/arrow/ipc/writer.h b/cpp/src/arrow/ipc/writer.h
index 9e18a213ba3f2..4e0ee3dfc8b44 100644
--- a/cpp/src/arrow/ipc/writer.h
+++ b/cpp/src/arrow/ipc/writer.h
@@ -57,6 +57,7 @@ struct IpcPayload {
   MessageType type = MessageType::NONE;
   std::shared_ptr<Buffer> metadata;
   std::vector<std::shared_ptr<Buffer>> body_buffers;
+  std::vector<int64_t> variadic_buffer_counts;
   int64_t body_length = 0;      // serialized body length (padded, maybe compressed)
   int64_t raw_body_length = 0;  // initial uncompressed body length
 };
diff --git a/cpp/src/arrow/json/converter.cc b/cpp/src/arrow/json/converter.cc
index 04ebe4714ceec..c393b77acf334 100644
--- a/cpp/src/arrow/json/converter.cc
+++ b/cpp/src/arrow/json/converter.cc
@@ -304,6 +304,8 @@ Status MakeConverter(const std::shared_ptr<DataType>& out_type, MemoryPool* pool
     CONVERTER_CASE(Type::STRING, BinaryConverter<StringType>);
     CONVERTER_CASE(Type::LARGE_BINARY, BinaryConverter<LargeBinaryType>);
     CONVERTER_CASE(Type::LARGE_STRING, BinaryConverter<LargeStringType>);
+    CONVERTER_CASE(Type::BINARY_VIEW, BinaryConverter<BinaryViewType>);
+    CONVERTER_CASE(Type::STRING_VIEW, BinaryConverter<StringViewType>);
     CONVERTER_CASE(Type::DECIMAL128, DecimalConverter<Decimal128Type>);
     CONVERTER_CASE(Type::DECIMAL256, DecimalConverter<Decimal256Type>);
     default:
diff --git a/cpp/src/arrow/json/converter_test.cc b/cpp/src/arrow/json/converter_test.cc
index 378a4491c0e62..cfc44c99976d5 100644
--- a/cpp/src/arrow/json/converter_test.cc
+++ b/cpp/src/arrow/json/converter_test.cc
@@ -131,8 +131,8 @@ TEST(ConverterTest, Floats) {
   }
 }
 
-TEST(ConverterTest, StringAndLargeString) {
-  for (auto string_type : {utf8(), large_utf8()}) {
+TEST(ConverterTest, StringAndLargeStringAndStringView) {
+  for (auto string_type : {utf8(), large_utf8(), utf8_view()}) {
     ParseOptions options;
     options.explicit_schema = schema({field("", string_type)});
 
diff --git a/cpp/src/arrow/json/parser.cc b/cpp/src/arrow/json/parser.cc
index e2941a29ab9bd..185dcde355f0a 100644
--- a/cpp/src/arrow/json/parser.cc
+++ b/cpp/src/arrow/json/parser.cc
@@ -104,6 +104,7 @@ Status Kind::ForType(const DataType& type, Kind::type* kind) {
     Status Visit(const DateType&) { return SetKind(Kind::kNumber); }
     Status Visit(const BinaryType&) { return SetKind(Kind::kString); }
     Status Visit(const LargeBinaryType&) { return SetKind(Kind::kString); }
+    Status Visit(const BinaryViewType&) { return SetKind(Kind::kString); }
     Status Visit(const TimestampType&) { return SetKind(Kind::kString); }
     Status Visit(const DecimalType&) { return SetKind(Kind::kNumberOrString); }
     Status Visit(const DictionaryType& dict_type) {
diff --git a/cpp/src/arrow/json/test_common.h b/cpp/src/arrow/json/test_common.h
index 0f7b3466fdbc9..f7ab6fd10275f 100644
--- a/cpp/src/arrow/json/test_common.h
+++ b/cpp/src/arrow/json/test_common.h
@@ -110,8 +110,7 @@ struct GenerateImpl {
     return OK(writer.Double(val));
   }
 
-  template <typename T>
-  enable_if_base_binary<T, Status> Visit(const T&) {
+  Status GenerateAscii(const DataType&) {
     auto size = std::poisson_distribution<>{4}(e);
     std::uniform_int_distribution<uint16_t> gen_char(32, 126);  // FIXME generate UTF8
     std::string s(size, '\0');
@@ -119,6 +118,13 @@ struct GenerateImpl {
     return OK(writer.String(s.c_str()));
   }
 
+  template <typename T>
+  enable_if_base_binary<T, Status> Visit(const T& t) {
+    return GenerateAscii(t);
+  }
+
+  Status Visit(const BinaryViewType& t) { return GenerateAscii(t); }
+
   template <typename T>
   enable_if_list_like<T, Status> Visit(const T& t) {
     auto size = std::poisson_distribution<>{4}(e);
diff --git a/cpp/src/arrow/pretty_print.cc b/cpp/src/arrow/pretty_print.cc
index a5410df7e9ae2..b392e027a6b89 100644
--- a/cpp/src/arrow/pretty_print.cc
+++ b/cpp/src/arrow/pretty_print.cc
@@ -229,18 +229,13 @@ class ArrayPrinter : public PrettyPrinter {
   }
 
   template <typename ArrayType, typename T = typename ArrayType::TypeClass>
-  enable_if_string_like<T, Status> WriteDataValues(const ArrayType& array) {
+  enable_if_has_string_view<T, Status> WriteDataValues(const ArrayType& array) {
     return WriteValues(array, [&](int64_t i) {
-      (*sink_) << "\"" << array.GetView(i) << "\"";
-      return Status::OK();
-    });
-  }
-
-  template <typename ArrayType, typename T = typename ArrayType::TypeClass>
-  enable_if_t<is_binary_like_type<T>::value && !is_decimal_type<T>::value, Status>
-  WriteDataValues(const ArrayType& array) {
-    return WriteValues(array, [&](int64_t i) {
-      (*sink_) << HexEncode(array.GetView(i));
+      if constexpr (T::is_utf8) {
+        (*sink_) << "\"" << array.GetView(i) << "\"";
+      } else {
+        (*sink_) << HexEncode(array.GetView(i));
+      }
       return Status::OK();
     });
   }
@@ -302,6 +297,7 @@ class ArrayPrinter : public PrettyPrinter {
                   std::is_base_of<FixedSizeBinaryArray, T>::value ||
                   std::is_base_of<BinaryArray, T>::value ||
                   std::is_base_of<LargeBinaryArray, T>::value ||
+                  std::is_base_of<BinaryViewArray, T>::value ||
                   std::is_base_of<ListArray, T>::value ||
                   std::is_base_of<LargeListArray, T>::value ||
                   std::is_base_of<MapArray, T>::value ||
diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc
index b2ad1ad519bb2..167e272705268 100644
--- a/cpp/src/arrow/scalar.cc
+++ b/cpp/src/arrow/scalar.cc
@@ -263,6 +263,12 @@ struct ScalarValidateImpl {
 
   Status Visit(const StringScalar& s) { return ValidateStringScalar(s); }
 
+  Status Visit(const BinaryViewScalar& s) { return ValidateBinaryScalar(s); }
+
+  Status Visit(const StringViewScalar& s) { return ValidateStringScalar(s); }
+
+  Status Visit(const LargeBinaryScalar& s) { return ValidateBinaryScalar(s); }
+
   Status Visit(const LargeStringScalar& s) { return ValidateStringScalar(s); }
 
   template <typename ScalarType>
@@ -548,17 +554,8 @@ Status Scalar::ValidateFull() const {
   return ScalarValidateImpl(/*full_validation=*/true).Validate(*this);
 }
 
-BinaryScalar::BinaryScalar(std::string s)
-    : BinaryScalar(Buffer::FromString(std::move(s))) {}
-
-StringScalar::StringScalar(std::string s)
-    : StringScalar(Buffer::FromString(std::move(s))) {}
-
-LargeBinaryScalar::LargeBinaryScalar(std::string s)
-    : LargeBinaryScalar(Buffer::FromString(std::move(s))) {}
-
-LargeStringScalar::LargeStringScalar(std::string s)
-    : LargeStringScalar(Buffer::FromString(std::move(s))) {}
+BaseBinaryScalar::BaseBinaryScalar(std::string s, std::shared_ptr<DataType> type)
+    : BaseBinaryScalar(Buffer::FromString(std::move(s)), std::move(type)) {}
 
 FixedSizeBinaryScalar::FixedSizeBinaryScalar(std::shared_ptr<Buffer> value,
                                              std::shared_ptr<DataType> type,
diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h
index 1d1ce4aa72948..5175b0128524c 100644
--- a/cpp/src/arrow/scalar.h
+++ b/cpp/src/arrow/scalar.h
@@ -263,24 +263,21 @@ struct ARROW_EXPORT BaseBinaryScalar
     return value ? std::string_view(*value) : std::string_view();
   }
 
- protected:
   BaseBinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)
       : internal::PrimitiveScalarBase{std::move(type), true}, value(std::move(value)) {}
 
   friend ArraySpan;
+  BaseBinaryScalar(std::string s, std::shared_ptr<DataType> type);
 };
 
 struct ARROW_EXPORT BinaryScalar : public BaseBinaryScalar {
   using BaseBinaryScalar::BaseBinaryScalar;
   using TypeClass = BinaryType;
 
-  BinaryScalar(std::shared_ptr<Buffer> value, std::shared_ptr<DataType> type)
-      : BaseBinaryScalar(std::move(value), std::move(type)) {}
-
   explicit BinaryScalar(std::shared_ptr<Buffer> value)
       : BinaryScalar(std::move(value), binary()) {}
 
-  explicit BinaryScalar(std::string s);
+  explicit BinaryScalar(std::string s) : BaseBinaryScalar(std::move(s), binary()) {}
 
   BinaryScalar() : BinaryScalar(binary()) {}
 };
@@ -292,11 +289,39 @@ struct ARROW_EXPORT StringScalar : public BinaryScalar {
   explicit StringScalar(std::shared_ptr<Buffer> value)
       : StringScalar(std::move(value), utf8()) {}
 
-  explicit StringScalar(std::string s);
+  explicit StringScalar(std::string s) : BinaryScalar(std::move(s), utf8()) {}
 
   StringScalar() : StringScalar(utf8()) {}
 };
 
+struct ARROW_EXPORT BinaryViewScalar : public BaseBinaryScalar {
+  using BaseBinaryScalar::BaseBinaryScalar;
+  using TypeClass = BinaryViewType;
+
+  explicit BinaryViewScalar(std::shared_ptr<Buffer> value)
+      : BinaryViewScalar(std::move(value), binary_view()) {}
+
+  explicit BinaryViewScalar(std::string s)
+      : BaseBinaryScalar(std::move(s), binary_view()) {}
+
+  BinaryViewScalar() : BinaryViewScalar(binary_view()) {}
+
+  std::string_view view() const override { return std::string_view(*this->value); }
+};
+
+struct ARROW_EXPORT StringViewScalar : public BinaryViewScalar {
+  using BinaryViewScalar::BinaryViewScalar;
+  using TypeClass = StringViewType;
+
+  explicit StringViewScalar(std::shared_ptr<Buffer> value)
+      : StringViewScalar(std::move(value), utf8_view()) {}
+
+  explicit StringViewScalar(std::string s)
+      : BinaryViewScalar(std::move(s), utf8_view()) {}
+
+  StringViewScalar() : StringViewScalar(utf8_view()) {}
+};
+
 struct ARROW_EXPORT LargeBinaryScalar : public BaseBinaryScalar {
   using BaseBinaryScalar::BaseBinaryScalar;
   using TypeClass = LargeBinaryType;
@@ -307,7 +332,8 @@ struct ARROW_EXPORT LargeBinaryScalar : public BaseBinaryScalar {
   explicit LargeBinaryScalar(std::shared_ptr<Buffer> value)
       : LargeBinaryScalar(std::move(value), large_binary()) {}
 
-  explicit LargeBinaryScalar(std::string s);
+  explicit LargeBinaryScalar(std::string s)
+      : BaseBinaryScalar(std::move(s), large_binary()) {}
 
   LargeBinaryScalar() : LargeBinaryScalar(large_binary()) {}
 };
@@ -319,7 +345,8 @@ struct ARROW_EXPORT LargeStringScalar : public LargeBinaryScalar {
   explicit LargeStringScalar(std::shared_ptr<Buffer> value)
       : LargeStringScalar(std::move(value), large_utf8()) {}
 
-  explicit LargeStringScalar(std::string s);
+  explicit LargeStringScalar(std::string s)
+      : LargeBinaryScalar(std::move(s), large_utf8()) {}
 
   LargeStringScalar() : LargeStringScalar(large_utf8()) {}
 };
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index bb462af86a5f2..641aae5a5e2e4 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -176,10 +176,17 @@ using DecimalArrowTypes = ::testing::Types<Decimal128Type, Decimal256Type>;
 using BaseBinaryArrowTypes =
     ::testing::Types<BinaryType, LargeBinaryType, StringType, LargeStringType>;
 
+using BaseBinaryOrBinaryViewLikeArrowTypes =
+    ::testing::Types<BinaryType, LargeBinaryType, BinaryViewType, StringType,
+                     LargeStringType, StringViewType>;
+
 using BinaryArrowTypes = ::testing::Types<BinaryType, LargeBinaryType>;
 
 using StringArrowTypes = ::testing::Types<StringType, LargeStringType>;
 
+using StringOrStringViewArrowTypes =
+    ::testing::Types<StringType, LargeStringType, StringViewType>;
+
 using ListArrowTypes = ::testing::Types<ListType, LargeListType>;
 
 using UnionArrowTypes = ::testing::Types<SparseUnionType, DenseUnionType>;
diff --git a/cpp/src/arrow/testing/random.cc b/cpp/src/arrow/testing/random.cc
index b74c41f75e452..1386075397e20 100644
--- a/cpp/src/arrow/testing/random.cc
+++ b/cpp/src/arrow/testing/random.cc
@@ -363,13 +363,11 @@ std::shared_ptr<Array> RandomArrayGenerator::Decimal256(std::shared_ptr<DataType
   return gen.MakeRandomArray(size, null_probability, alignment, memory_pool);
 }
 
-template <typename TypeClass>
-static std::shared_ptr<Array> GenerateBinaryArray(RandomArrayGenerator* gen, int64_t size,
-                                                  int32_t min_length, int32_t max_length,
-                                                  double null_probability,
-                                                  int64_t alignment,
-                                                  MemoryPool* memory_pool) {
-  using offset_type = typename TypeClass::offset_type;
+template <typename TypeClass, typename offset_type = typename TypeClass::offset_type>
+static std::shared_ptr<Array> GenerateBinaryArray(
+    RandomArrayGenerator* gen, int64_t size, int32_t min_length, int32_t max_length,
+    double null_probability, std::optional<int64_t> max_data_buffer_length,
+    int64_t alignment, MemoryPool* memory_pool) {
   using BuilderType = typename TypeTraits<TypeClass>::BuilderType;
   using OffsetArrowType = typename CTypeTraits<offset_type>::ArrowType;
   using OffsetArrayType = typename TypeTraits<OffsetArrowType>::ArrayType;
@@ -387,7 +385,12 @@ static std::shared_ptr<Array> GenerateBinaryArray(RandomArrayGenerator* gen, int
                  /*null_probability=*/0);
 
   std::vector<uint8_t> str_buffer(max_length);
-  BuilderType builder(memory_pool, alignment);
+  BuilderType builder{memory_pool, alignment};
+  if constexpr (std::is_base_of_v<BinaryViewType, TypeClass>) {
+    if (max_data_buffer_length) {
+      builder.SetBlockSize(*max_data_buffer_length);
+    }
+  }
 
   for (int64_t i = 0; i < size; ++i) {
     if (lengths->IsValid(i)) {
@@ -409,7 +412,8 @@ std::shared_ptr<Array> RandomArrayGenerator::String(int64_t size, int32_t min_le
                                                     int64_t alignment,
                                                     MemoryPool* memory_pool) {
   return GenerateBinaryArray<StringType>(this, size, min_length, max_length,
-                                         null_probability, alignment, memory_pool);
+                                         null_probability, /*max_data_buffer_length=*/{},
+                                         alignment, memory_pool);
 }
 
 std::shared_ptr<Array> RandomArrayGenerator::LargeString(int64_t size, int32_t min_length,
@@ -417,8 +421,9 @@ std::shared_ptr<Array> RandomArrayGenerator::LargeString(int64_t size, int32_t m
                                                          double null_probability,
                                                          int64_t alignment,
                                                          MemoryPool* memory_pool) {
-  return GenerateBinaryArray<LargeStringType>(this, size, min_length, max_length,
-                                              null_probability, alignment, memory_pool);
+  return GenerateBinaryArray<LargeStringType>(
+      this, size, min_length, max_length, null_probability, /*max_data_buffer_length=*/{},
+      alignment, memory_pool);
 }
 
 std::shared_ptr<Array> RandomArrayGenerator::BinaryWithRepeats(
@@ -430,6 +435,15 @@ std::shared_ptr<Array> RandomArrayGenerator::BinaryWithRepeats(
   return *strings->View(binary());
 }
 
+std::shared_ptr<Array> RandomArrayGenerator::StringView(
+    int64_t size, int32_t min_length, int32_t max_length, double null_probability,
+    std::optional<int64_t> max_data_buffer_length, int64_t alignment,
+    MemoryPool* memory_pool) {
+  return GenerateBinaryArray<StringViewType, int32_t>(
+      this, size, min_length, max_length, null_probability, max_data_buffer_length,
+      alignment, memory_pool);
+}
+
 std::shared_ptr<Array> RandomArrayGenerator::StringWithRepeats(
     int64_t size, int64_t unique, int32_t min_length, int32_t max_length,
     double null_probability, int64_t alignment, MemoryPool* memory_pool) {
@@ -843,6 +857,24 @@ std::shared_ptr<Array> RandomArrayGenerator::ArrayOf(const Field& field, int64_t
                   ->View(field.type());
     }
 
+    case Type::type::STRING_VIEW:
+    case Type::type::BINARY_VIEW: {
+      const auto min_length =
+          GetMetadata<int32_t>(field.metadata().get(), "min_length", 0);
+      const auto max_length =
+          GetMetadata<int32_t>(field.metadata().get(), "max_length", 20);
+      std::optional<int64_t> max_data_buffer_length =
+          GetMetadata<int64_t>(field.metadata().get(), "max_data_buffer_length", 0);
+      if (*max_data_buffer_length == 0) {
+        *max_data_buffer_length = {};
+      }
+
+      return StringView(length, min_length, max_length, null_probability,
+                        max_data_buffer_length, alignment)
+          ->View(field.type())
+          .ValueOrDie();
+    }
+
     case Type::type::DECIMAL128:
       return Decimal128(field.type(), length, null_probability, alignment, memory_pool);
 
diff --git a/cpp/src/arrow/testing/random.h b/cpp/src/arrow/testing/random.h
index de9ea6d05648d..cbdac3baa0109 100644
--- a/cpp/src/arrow/testing/random.h
+++ b/cpp/src/arrow/testing/random.h
@@ -367,6 +367,26 @@ class ARROW_TESTING_EXPORT RandomArrayGenerator {
                                 int64_t alignment = kDefaultBufferAlignment,
                                 MemoryPool* memory_pool = default_memory_pool());
 
+  /// \brief Generate a random StringViewArray
+  ///
+  /// \param[in] size the size of the array to generate
+  /// \param[in] min_length the lower bound of the string length
+  ///            determined by the uniform distribution
+  /// \param[in] max_length the upper bound of the string length
+  ///            determined by the uniform distribution
+  /// \param[in] null_probability the probability of a value being null
+  /// \param[in] max_data_buffer_length the data buffer size at which
+  ///            a new chunk will be generated
+  /// \param[in] alignment alignment for memory allocations (in bytes)
+  /// \param[in] memory_pool memory pool to allocate memory from
+  ///
+  /// \return a generated Array
+  std::shared_ptr<Array> StringView(int64_t size, int32_t min_length, int32_t max_length,
+                                    double null_probability = 0,
+                                    std::optional<int64_t> max_data_buffer_length = {},
+                                    int64_t alignment = kDefaultBufferAlignment,
+                                    MemoryPool* memory_pool = default_memory_pool());
+
   /// \brief Generate a random LargeStringArray
   ///
   /// \param[in] size the size of the array to generate
@@ -556,10 +576,14 @@ class ARROW_TESTING_EXPORT RandomArrayGenerator {
   /// - max_length (T::offset_type): the minimum length of the child to generate,
   ///   default 1024
   ///
-  /// For string and binary types T (not including their large variants):
+  /// For string and binary types T (not including their large or view variants):
   /// - unique (int32_t): if positive, this many distinct values will be generated
   ///   and all array values will be one of these values, default -1
   ///
+  /// For string and binary view types T:
+  /// - max_data_buffer_length (int64_t): the data buffer size at which a new chunk
+  ///   will be generated, default 32KB
+  ///
   /// For MapType:
   /// - values (int32_t): the number of key-value pairs to generate, which will be
   ///   partitioned among the array values.
diff --git a/cpp/src/arrow/testing/random_test.cc b/cpp/src/arrow/testing/random_test.cc
index f269818e83a3d..951b654e56f73 100644
--- a/cpp/src/arrow/testing/random_test.cc
+++ b/cpp/src/arrow/testing/random_test.cc
@@ -160,6 +160,7 @@ auto values = ::testing::Values(
     field("uint32", uint32()), field("int32", int32()), field("uint64", uint64()),
     field("int64", int64()), field("float16", float16()), field("float32", float32()),
     field("float64", float64()), field("string", utf8()), field("binary", binary()),
+    field("string_view", utf8_view()), field("binary_view", binary_view()),
     field("fixed_size_binary", fixed_size_binary(8)),
     field("decimal128", decimal128(8, 3)), field("decimal128", decimal128(29, -5)),
     field("decimal256", decimal256(16, 4)), field("decimal256", decimal256(57, -6)),
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index a4f43256827da..f378bd974047d 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -64,10 +64,14 @@ constexpr Type::type FixedSizeListType::type_id;
 
 constexpr Type::type BinaryType::type_id;
 
+constexpr Type::type BinaryViewType::type_id;
+
 constexpr Type::type LargeBinaryType::type_id;
 
 constexpr Type::type StringType::type_id;
 
+constexpr Type::type StringViewType::type_id;
+
 constexpr Type::type LargeStringType::type_id;
 
 constexpr Type::type FixedSizeBinaryType::type_id;
@@ -130,6 +134,8 @@ std::vector<Type::type> AllTypeIds() {
           Type::BINARY,
           Type::LARGE_STRING,
           Type::LARGE_BINARY,
+          Type::STRING_VIEW,
+          Type::BINARY_VIEW,
           Type::FIXED_SIZE_BINARY,
           Type::STRUCT,
           Type::LIST,
@@ -194,7 +200,9 @@ std::string ToString(Type::type id) {
     TO_STRING_CASE(INTERVAL_MONTHS)
     TO_STRING_CASE(DURATION)
     TO_STRING_CASE(STRING)
+    TO_STRING_CASE(STRING_VIEW)
     TO_STRING_CASE(BINARY)
+    TO_STRING_CASE(BINARY_VIEW)
     TO_STRING_CASE(LARGE_STRING)
     TO_STRING_CASE(LARGE_BINARY)
     TO_STRING_CASE(FIXED_SIZE_BINARY)
@@ -247,7 +255,7 @@ struct PhysicalTypeVisitor {
   }
 
   template <typename Type, typename PhysicalType = typename Type::PhysicalType>
-  Status Visit(const Type&) {
+  Status Visit(const Type& type) {
     result = TypeTraits<PhysicalType>::type_singleton();
     return Status::OK();
   }
@@ -1058,10 +1066,14 @@ std::string FixedSizeListType::ToString() const {
 
 std::string BinaryType::ToString() const { return "binary"; }
 
+std::string BinaryViewType::ToString() const { return "binary_view"; }
+
 std::string LargeBinaryType::ToString() const { return "large_binary"; }
 
 std::string StringType::ToString() const { return "string"; }
 
+std::string StringViewType::ToString() const { return "string_view"; }
+
 std::string LargeStringType::ToString() const { return "large_string"; }
 
 int FixedSizeBinaryType::bit_width() const { return CHAR_BIT * byte_width(); }
@@ -2821,8 +2833,10 @@ PARAMETER_LESS_FINGERPRINT(HalfFloat)
 PARAMETER_LESS_FINGERPRINT(Float)
 PARAMETER_LESS_FINGERPRINT(Double)
 PARAMETER_LESS_FINGERPRINT(Binary)
+PARAMETER_LESS_FINGERPRINT(BinaryView)
 PARAMETER_LESS_FINGERPRINT(LargeBinary)
 PARAMETER_LESS_FINGERPRINT(String)
+PARAMETER_LESS_FINGERPRINT(StringView)
 PARAMETER_LESS_FINGERPRINT(LargeString)
 PARAMETER_LESS_FINGERPRINT(Date32)
 PARAMETER_LESS_FINGERPRINT(Date64)
@@ -3034,6 +3048,16 @@ TYPE_FACTORY(large_binary, LargeBinaryType)
 TYPE_FACTORY(date64, Date64Type)
 TYPE_FACTORY(date32, Date32Type)
 
+const std::shared_ptr<DataType>& utf8_view() {
+  static std::shared_ptr<DataType> type = std::make_shared<StringViewType>();
+  return type;
+}
+
+const std::shared_ptr<DataType>& binary_view() {
+  static std::shared_ptr<DataType> type = std::make_shared<BinaryViewType>();
+  return type;
+}
+
 std::shared_ptr<DataType> fixed_size_binary(int32_t byte_width) {
   return std::make_shared<FixedSizeBinaryType>(byte_width);
 }
@@ -3294,7 +3318,7 @@ void InitStaticData() {
   // * Time32
   // * Time64
   // * Timestamp
-  g_primitive_types = {null(), boolean(), date32(), date64()};
+  g_primitive_types = {null(), boolean(), date32(), date64(), binary_view(), utf8_view()};
   Extend(g_numeric_types, &g_primitive_types);
   Extend(g_base_binary_types, &g_primitive_types);
 }
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index 3f4dd5c9b21fa..a905192e4a54e 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -23,6 +23,7 @@
 #include <iosfwd>
 #include <limits>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <variant>
@@ -113,8 +114,14 @@ struct ARROW_EXPORT DataTypeLayout {
   std::vector<BufferSpec> buffers;
   /// Whether this type expects an associated dictionary array.
   bool has_dictionary = false;
+  /// If this is provided, the number of buffers expected is only lower-bounded by
+  /// buffers.size(). Buffers beyond this lower bound are expected to conform to
+  /// variadic_spec.
+  std::optional<BufferSpec> variadic_spec;
 
-  explicit DataTypeLayout(std::vector<BufferSpec> v) : buffers(std::move(v)) {}
+  explicit DataTypeLayout(std::vector<BufferSpec> buffers,
+                          std::optional<BufferSpec> variadic_spec = {})
+      : buffers(std::move(buffers)), variadic_spec(variadic_spec) {}
 };
 
 /// \brief Base class for all data types
@@ -772,6 +779,103 @@ class ARROW_EXPORT BinaryType : public BaseBinaryType {
   explicit BinaryType(Type::type logical_type) : BaseBinaryType(logical_type) {}
 };
 
+/// \brief Concrete type class for variable-size binary view data
+class ARROW_EXPORT BinaryViewType : public DataType {
+ public:
+  static constexpr Type::type type_id = Type::BINARY_VIEW;
+  static constexpr bool is_utf8 = false;
+  using PhysicalType = BinaryViewType;
+
+  static constexpr int kSize = 16;
+  static constexpr int kInlineSize = 12;
+  static constexpr int kPrefixSize = 4;
+
+  /// Variable length string or binary with inline optimization for small values (12 bytes
+  /// or fewer). This is similar to std::string_view except limited in size to INT32_MAX
+  /// and at least the first four bytes of the string are copied inline (accessible
+  /// without pointer dereference). This inline prefix allows failing comparisons early.
+  /// Furthermore when dealing with short strings the CPU cache working set is reduced
+  /// since many can be inline.
+  ///
+  /// This union supports two states:
+  ///
+  /// - Entirely inlined string data
+  ///                |----|--------------|
+  ///                 ^    ^
+  ///                 |    |
+  ///              size    in-line string data, zero padded
+  ///
+  /// - Reference into a buffer
+  ///                |----|----|----|----|
+  ///                 ^    ^    ^    ^
+  ///                 |    |    |    |
+  ///              size    |    |    `------.
+  ///                  prefix   |           |
+  ///                        buffer index   |
+  ///                                  offset in buffer
+  ///
+  /// Adapted from TU Munich's UmbraDB [1], Velox, DuckDB.
+  ///
+  /// [1]: https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf
+  ///
+  /// Alignment to 64 bits enables an aligned load of the size and prefix into
+  /// a single 64 bit integer, which is useful to the comparison fast path.
+  union alignas(int64_t) c_type {
+    struct {
+      int32_t size;
+      std::array<uint8_t, kInlineSize> data;
+    } inlined;
+
+    struct {
+      int32_t size;
+      std::array<uint8_t, kPrefixSize> prefix;
+      int32_t buffer_index;
+      int32_t offset;
+    } ref;
+
+    /// The number of bytes viewed.
+    int32_t size() const {
+      // Size is in the common initial subsequence of each member of the union,
+      // so accessing `inlined.size` is legal even if another member is active.
+      return inlined.size;
+    }
+
+    /// True if the view's data is entirely stored inline.
+    bool is_inline() const { return size() <= kInlineSize; }
+
+    /// Return a pointer to the inline data of a view.
+    ///
+    /// For inline views, this points to the entire data of the view.
+    /// For other views, this points to the 4 byte prefix.
+    const uint8_t* inline_data() const& {
+      // Since `ref.prefix` has the same address as `inlined.data`,
+      // the branch will be trivially optimized out.
+      return is_inline() ? inlined.data.data() : ref.prefix.data();
+    }
+    const uint8_t* inline_data() && = delete;
+  };
+  static_assert(sizeof(c_type) == kSize);
+  static_assert(std::is_trivial_v<c_type>);
+
+  static constexpr const char* type_name() { return "binary_view"; }
+
+  BinaryViewType() : BinaryViewType(Type::BINARY_VIEW) {}
+
+  DataTypeLayout layout() const override {
+    return DataTypeLayout({DataTypeLayout::Bitmap(), DataTypeLayout::FixedWidth(kSize)},
+                          DataTypeLayout::VariableWidth());
+  }
+
+  std::string ToString() const override;
+  std::string name() const override { return "binary_view"; }
+
+ protected:
+  std::string ComputeFingerprint() const override;
+
+  // Allow subclasses like StringType to change the logical type.
+  explicit BinaryViewType(Type::type logical_type) : DataType(logical_type) {}
+};
+
 /// \brief Concrete type class for large variable-size binary data
 class ARROW_EXPORT LargeBinaryType : public BaseBinaryType {
  public:
@@ -818,6 +922,24 @@ class ARROW_EXPORT StringType : public BinaryType {
   std::string ComputeFingerprint() const override;
 };
 
+/// \brief Concrete type class for variable-size string data, utf8-encoded
+class ARROW_EXPORT StringViewType : public BinaryViewType {
+ public:
+  static constexpr Type::type type_id = Type::STRING_VIEW;
+  static constexpr bool is_utf8 = true;
+  using PhysicalType = BinaryViewType;
+
+  static constexpr const char* type_name() { return "utf8_view"; }
+
+  StringViewType() : BinaryViewType(Type::STRING_VIEW) {}
+
+  std::string ToString() const override;
+  std::string name() const override { return "utf8_view"; }
+
+ protected:
+  std::string ComputeFingerprint() const override;
+};
+
 /// \brief Concrete type class for large variable-size string data, utf8-encoded
 class ARROW_EXPORT LargeStringType : public LargeBinaryType {
  public:
diff --git a/cpp/src/arrow/type_fwd.h b/cpp/src/arrow/type_fwd.h
index 499684719feab..ca263b710317b 100644
--- a/cpp/src/arrow/type_fwd.h
+++ b/cpp/src/arrow/type_fwd.h
@@ -110,6 +110,11 @@ class BinaryArray;
 class BinaryBuilder;
 struct BinaryScalar;
 
+class BinaryViewType;
+class BinaryViewArray;
+class BinaryViewBuilder;
+struct BinaryViewScalar;
+
 class LargeBinaryType;
 class LargeBinaryArray;
 class LargeBinaryBuilder;
@@ -125,6 +130,11 @@ class StringArray;
 class StringBuilder;
 struct StringScalar;
 
+class StringViewType;
+class StringViewArray;
+class StringViewBuilder;
+struct StringViewScalar;
+
 class LargeStringType;
 class LargeStringArray;
 class LargeStringBuilder;
@@ -415,6 +425,13 @@ struct Type {
     /// Run-end encoded data.
     RUN_END_ENCODED = 38,
 
+    /// String (UTF8) view type with 4-byte prefix and inline small string
+    /// optimization
+    STRING_VIEW = 39,
+
+    /// Bytes view type with 4-byte prefix and inline small string optimization
+    BINARY_VIEW = 40,
+
     // Leave this at the end
     MAX_ID
   };
@@ -456,10 +473,14 @@ ARROW_EXPORT const std::shared_ptr<DataType>& float32();
 ARROW_EXPORT const std::shared_ptr<DataType>& float64();
 /// \brief Return a StringType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& utf8();
+/// \brief Return a StringViewType instance
+ARROW_EXPORT const std::shared_ptr<DataType>& utf8_view();
 /// \brief Return a LargeStringType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& large_utf8();
 /// \brief Return a BinaryType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& binary();
+/// \brief Return a BinaryViewType instance
+ARROW_EXPORT const std::shared_ptr<DataType>& binary_view();
 /// \brief Return a LargeBinaryType instance
 ARROW_EXPORT const std::shared_ptr<DataType>& large_binary();
 /// \brief Return a Date32Type instance
diff --git a/cpp/src/arrow/type_test.cc b/cpp/src/arrow/type_test.cc
index 9ba8cf98dea4f..273f8933fa577 100644
--- a/cpp/src/arrow/type_test.cc
+++ b/cpp/src/arrow/type_test.cc
@@ -1469,9 +1469,21 @@ TEST(TestBinaryType, ToString) {
 TEST(TestStringType, ToString) {
   StringType str;
   ASSERT_EQ(str.id(), Type::STRING);
+  ASSERT_EQ(str.name(), std::string("utf8"));
+  ASSERT_EQ(str.type_name(), std::string("utf8"));
   ASSERT_EQ(str.ToString(), std::string("string"));
 }
 
+TEST(TestBinaryViewType, ToString) {
+  BinaryViewType t1;
+  BinaryViewType e1;
+  StringViewType t2;
+  AssertTypeEqual(t1, e1);
+  AssertTypeNotEqual(t1, t2);
+  ASSERT_EQ(t1.id(), Type::BINARY_VIEW);
+  ASSERT_EQ(t1.ToString(), std::string("binary_view"));
+}
+
 TEST(TestLargeBinaryTypes, ToString) {
   BinaryType bt1;
   LargeBinaryType t1;
diff --git a/cpp/src/arrow/type_traits.cc b/cpp/src/arrow/type_traits.cc
index ac16afe4b8cd8..de328f322ad5f 100644
--- a/cpp/src/arrow/type_traits.cc
+++ b/cpp/src/arrow/type_traits.cc
@@ -88,6 +88,8 @@ int RequiredValueAlignmentForBuffer(Type::type type_id, int buffer_index) {
     case Type::DURATION:
     case Type::INTERVAL_MONTH_DAY_NANO:  // Stored as two 32-bit integers and a 64-bit
                                          // integer
+    case Type::STRING_VIEW:
+    case Type::BINARY_VIEW:
       return 8;
     case Type::DICTIONARY:
     case Type::EXTENSION:
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index bcbde23ae4a4b..9d8cafacf397b 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -341,6 +341,16 @@ struct TypeTraits<BinaryType> {
   static inline std::shared_ptr<DataType> type_singleton() { return binary(); }
 };
 
+template <>
+struct TypeTraits<BinaryViewType> {
+  using ArrayType = BinaryViewArray;
+  using BuilderType = BinaryViewBuilder;
+  using ScalarType = BinaryViewScalar;
+  using CType = BinaryViewType::c_type;
+  constexpr static bool is_parameter_free = true;
+  static inline std::shared_ptr<DataType> type_singleton() { return binary_view(); }
+};
+
 template <>
 struct TypeTraits<LargeBinaryType> {
   using ArrayType = LargeBinaryArray;
@@ -371,6 +381,16 @@ struct TypeTraits<StringType> {
   static inline std::shared_ptr<DataType> type_singleton() { return utf8(); }
 };
 
+template <>
+struct TypeTraits<StringViewType> {
+  using ArrayType = StringViewArray;
+  using BuilderType = StringViewBuilder;
+  using ScalarType = StringViewScalar;
+  using CType = BinaryViewType::c_type;
+  constexpr static bool is_parameter_free = true;
+  static inline std::shared_ptr<DataType> type_singleton() { return utf8_view(); }
+};
+
 template <>
 struct TypeTraits<LargeStringType> {
   using ArrayType = LargeStringArray;
@@ -399,6 +419,11 @@ struct CTypeTraits<std::string> : public TypeTraits<StringType> {
   using ArrowType = StringType;
 };
 
+template <>
+struct CTypeTraits<BinaryViewType::c_type> : public TypeTraits<BinaryViewType> {
+  using ArrowType = BinaryViewType;
+};
+
 template <>
 struct CTypeTraits<const char*> : public CTypeTraits<std::string> {};
 
@@ -614,6 +639,24 @@ using is_string_type =
 template <typename T, typename R = void>
 using enable_if_string = enable_if_t<is_string_type<T>::value, R>;
 
+template <typename T>
+using is_binary_view_like_type = std::is_base_of<BinaryViewType, T>;
+
+template <typename T>
+using is_binary_view_type = std::is_same<BinaryViewType, T>;
+
+template <typename T>
+using is_string_view_type = std::is_same<StringViewType, T>;
+
+template <typename T, typename R = void>
+using enable_if_binary_view_like = enable_if_t<is_binary_view_like_type<T>::value, R>;
+
+template <typename T, typename R = void>
+using enable_if_binary_view = enable_if_t<is_binary_view_type<T>::value, R>;
+
+template <typename T, typename R = void>
+using enable_if_string_view = enable_if_t<is_string_view_type<T>::value, R>;
+
 template <typename T>
 using is_string_like_type =
     std::integral_constant<bool, is_base_binary_type<T>::value && T::is_utf8>;
@@ -801,8 +844,10 @@ using enable_if_has_c_type = enable_if_t<has_c_type<T>::value, R>;
 template <typename T>
 using has_string_view =
     std::integral_constant<bool, std::is_same<BinaryType, T>::value ||
+                                     std::is_same<BinaryViewType, T>::value ||
                                      std::is_same<LargeBinaryType, T>::value ||
                                      std::is_same<StringType, T>::value ||
+                                     std::is_same<StringViewType, T>::value ||
                                      std::is_same<LargeStringType, T>::value ||
                                      std::is_same<FixedSizeBinaryType, T>::value>;
 
diff --git a/cpp/src/arrow/util/binary_view_util.h b/cpp/src/arrow/util/binary_view_util.h
new file mode 100644
index 0000000000000..94f7a5bdfa667
--- /dev/null
+++ b/cpp/src/arrow/util/binary_view_util.h
@@ -0,0 +1,95 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <string_view>
+#include <utility>
+
+#include "arrow/type.h"
+#include "arrow/util/span.h"
+
+namespace arrow::util {
+
+inline BinaryViewType::c_type ToInlineBinaryView(const void* data, int32_t size) {
+  // Small string: inlined. Bytes beyond size are zeroed
+  BinaryViewType::c_type out;
+  out.inlined = {size, {}};
+  memcpy(&out.inlined.data, data, size);
+  return out;
+}
+
+inline BinaryViewType::c_type ToInlineBinaryView(std::string_view v) {
+  return ToInlineBinaryView(v.data(), static_cast<int32_t>(v.size()));
+}
+
+inline BinaryViewType::c_type ToBinaryView(const void* data, int32_t size,
+                                           int32_t buffer_index, int32_t offset) {
+  if (size <= BinaryViewType::kInlineSize) {
+    return ToInlineBinaryView(data, size);
+  }
+
+  // Large string: store index/offset.
+  BinaryViewType::c_type out;
+  out.ref = {size, {}, buffer_index, offset};
+  memcpy(&out.ref.prefix, data, sizeof(out.ref.prefix));
+  return out;
+}
+
+inline BinaryViewType::c_type ToBinaryView(std::string_view v, int32_t buffer_index,
+                                           int32_t offset) {
+  return ToBinaryView(v.data(), static_cast<int32_t>(v.size()), buffer_index, offset);
+}
+
+template <typename BufferPtr>
+std::string_view FromBinaryView(const BinaryViewType::c_type& v,
+                                const BufferPtr* data_buffers) {
+  auto* data = v.is_inline() ? v.inlined.data.data()
+                             : data_buffers[v.ref.buffer_index]->data() + v.ref.offset;
+  return {reinterpret_cast<const char*>(data), static_cast<size_t>(v.size())};
+}
+template <typename BufferPtr>
+std::string_view FromBinaryView(BinaryViewType::c_type&&, const BufferPtr*) = delete;
+
+template <typename BufferPtr>
+bool EqualBinaryView(BinaryViewType::c_type l, BinaryViewType::c_type r,
+                     const BufferPtr* l_buffers, const BufferPtr* r_buffers) {
+  int64_t l_size_and_prefix, r_size_and_prefix;
+  memcpy(&l_size_and_prefix, &l, sizeof(l_size_and_prefix));
+  memcpy(&r_size_and_prefix, &r, sizeof(r_size_and_prefix));
+
+  if (l_size_and_prefix != r_size_and_prefix) return false;
+
+  if (l.is_inline()) {
+    // The columnar spec mandates that the inlined part be zero-padded, so we can compare
+    // a word at a time regardless of the exact size.
+    int64_t l_inlined, r_inlined;
+    memcpy(&l_inlined, l.inline_data() + BinaryViewType::kPrefixSize, sizeof(l_inlined));
+    memcpy(&r_inlined, r.inline_data() + BinaryViewType::kPrefixSize, sizeof(r_inlined));
+    return l_inlined == r_inlined;
+  }
+
+  // Sizes are equal and this is not inline, therefore both are out
+  // of line and have kPrefixSize first in common.
+  const uint8_t* l_data = l_buffers[l.ref.buffer_index]->data() + l.ref.offset;
+  const uint8_t* r_data = r_buffers[r.ref.buffer_index]->data() + r.ref.offset;
+  return memcmp(l_data + BinaryViewType::kPrefixSize,
+                r_data + BinaryViewType::kPrefixSize,
+                l.size() - BinaryViewType::kPrefixSize) == 0;
+}
+
+}  // namespace arrow::util
diff --git a/cpp/src/arrow/util/string.cc b/cpp/src/arrow/util/string.cc
index 2055b4f47ea22..192173fa16ce9 100644
--- a/cpp/src/arrow/util/string.cc
+++ b/cpp/src/arrow/util/string.cc
@@ -25,15 +25,13 @@
 
 namespace arrow {
 
-static const char* kAsciiTable = "0123456789ABCDEF";
-
 std::string HexEncode(const uint8_t* data, size_t length) {
-  std::string hex_string;
-  hex_string.reserve(length * 2);
-  for (size_t j = 0; j < length; ++j) {
+  std::string hex_string(length * 2, '\0');
+  for (size_t j = 0, i = 0; j < length; ++j) {
     // Convert to 2 base16 digits
-    hex_string.push_back(kAsciiTable[data[j] >> 4]);
-    hex_string.push_back(kAsciiTable[data[j] & 15]);
+    constexpr auto kHexDigitTable = "0123456789ABCDEF";
+    hex_string[i++] = kHexDigitTable[data[j] >> 4];
+    hex_string[i++] = kHexDigitTable[data[j] & 0b1111];
   }
   return hex_string;
 }
@@ -73,20 +71,34 @@ std::string HexEncode(std::string_view str) { return HexEncode(str.data(), str.s
 
 std::string Escape(std::string_view str) { return Escape(str.data(), str.size()); }
 
-Status ParseHexValue(const char* data, uint8_t* out) {
-  char c1 = data[0];
-  char c2 = data[1];
+constexpr uint8_t kInvalidHexDigit = -1;
 
-  const char* kAsciiTableEnd = kAsciiTable + 16;
-  const char* pos1 = std::lower_bound(kAsciiTable, kAsciiTableEnd, c1);
-  const char* pos2 = std::lower_bound(kAsciiTable, kAsciiTableEnd, c2);
+constexpr uint8_t ParseHexDigit(char c) {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return kInvalidHexDigit;
+}
+
+Status ParseHexValue(const char* data, uint8_t* out) {
+  uint8_t high = ParseHexDigit(data[0]);
+  uint8_t low = ParseHexDigit(data[1]);
 
   // Error checking
-  if (pos1 == kAsciiTableEnd || pos2 == kAsciiTableEnd || *pos1 != c1 || *pos2 != c2) {
+  if (high == kInvalidHexDigit || low == kInvalidHexDigit) {
     return Status::Invalid("Encountered non-hex digit");
   }
 
-  *out = static_cast<uint8_t>((pos1 - kAsciiTable) << 4 | (pos2 - kAsciiTable));
+  *out = static_cast<uint8_t>(high << 4 | low);
+  return Status::OK();
+}
+
+Status ParseHexValues(std::string_view hex_string, uint8_t* out) {
+  if (hex_string.size() % 2 != 0) {
+    return Status::Invalid("Expected base16 hex string");
+  }
+  for (size_t j = 0; j < hex_string.size() / 2; ++j) {
+    RETURN_NOT_OK(ParseHexValue(hex_string.data() + j * 2, out + j));
+  }
   return Status::OK();
 }
 
diff --git a/cpp/src/arrow/util/string.h b/cpp/src/arrow/util/string.h
index d9777efc56a8c..d7e377773f62f 100644
--- a/cpp/src/arrow/util/string.h
+++ b/cpp/src/arrow/util/string.h
@@ -46,7 +46,9 @@ ARROW_EXPORT std::string HexEncode(std::string_view str);
 
 ARROW_EXPORT std::string Escape(std::string_view str);
 
-ARROW_EXPORT Status ParseHexValue(const char* data, uint8_t* out);
+ARROW_EXPORT Status ParseHexValue(const char* hex_pair, uint8_t* out);
+
+ARROW_EXPORT Status ParseHexValues(std::string_view hex_string, uint8_t* out);
 
 namespace internal {
 
diff --git a/cpp/src/arrow/visit_data_inline.h b/cpp/src/arrow/visit_data_inline.h
index 6a9b32d73a635..a2ba9cfc65071 100644
--- a/cpp/src/arrow/visit_data_inline.h
+++ b/cpp/src/arrow/visit_data_inline.h
@@ -23,6 +23,7 @@
 #include "arrow/status.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/binary_view_util.h"
 #include "arrow/util/bit_block_counter.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/checked_cast.h"
@@ -144,6 +145,42 @@ struct ArraySpanInlineVisitor<T, enable_if_base_binary<T>> {
   }
 };
 
+// BinaryView, StringView...
+template <typename T>
+struct ArraySpanInlineVisitor<T, enable_if_binary_view_like<T>> {
+  using c_type = std::string_view;
+
+  template <typename ValidFunc, typename NullFunc>
+  static Status VisitStatus(const ArraySpan& arr, ValidFunc&& valid_func,
+                            NullFunc&& null_func) {
+    if (arr.length == 0) {
+      return Status::OK();
+    }
+    auto* s = arr.GetValues<BinaryViewType::c_type>(1);
+    auto* data_buffers = arr.GetVariadicBuffers().data();
+    return VisitBitBlocks(
+        arr.buffers[0].data, arr.offset, arr.length,
+        [&](int64_t index) {
+          return valid_func(util::FromBinaryView(s[index], data_buffers));
+        },
+        [&]() { return null_func(); });
+  }
+
+  template <typename ValidFunc, typename NullFunc>
+  static void VisitVoid(const ArraySpan& arr, ValidFunc&& valid_func,
+                        NullFunc&& null_func) {
+    if (arr.length == 0) {
+      return;
+    }
+    auto* s = arr.GetValues<BinaryViewType::c_type>(1);
+    auto* data_buffers = arr.GetVariadicBuffers().data();
+    VisitBitBlocksVoid(
+        arr.buffers[0].data, arr.offset, arr.length,
+        [&](int64_t index) { valid_func(util::FromBinaryView(s[index], data_buffers)); },
+        std::forward<NullFunc>(null_func));
+  }
+};
+
 // FixedSizeBinary, Decimal128
 template <typename T>
 struct ArraySpanInlineVisitor<T, enable_if_fixed_size_binary<T>> {
@@ -240,9 +277,8 @@ typename internal::call_traits::enable_if_return<ValidFunc, Status>::type
 VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
                       int64_t num_values, int64_t null_count, ValidFunc&& valid_func,
                       NullFunc&& null_func) {
-  ARROW_UNUSED(null_count);
-  internal::OptionalBitBlockCounter bit_counter(valid_bits, valid_bits_offset,
-                                                num_values);
+  internal::OptionalBitBlockCounter bit_counter(null_count == 0 ? NULLPTR : valid_bits,
+                                                valid_bits_offset, num_values);
   int64_t position = 0;
   int64_t offset_position = valid_bits_offset;
   while (position < num_values) {
@@ -273,9 +309,8 @@ typename internal::call_traits::enable_if_return<ValidFunc, void>::type
 VisitNullBitmapInline(const uint8_t* valid_bits, int64_t valid_bits_offset,
                       int64_t num_values, int64_t null_count, ValidFunc&& valid_func,
                       NullFunc&& null_func) {
-  ARROW_UNUSED(null_count);
-  internal::OptionalBitBlockCounter bit_counter(valid_bits, valid_bits_offset,
-                                                num_values);
+  internal::OptionalBitBlockCounter bit_counter(null_count == 0 ? NULLPTR : valid_bits,
+                                                valid_bits_offset, num_values);
   int64_t position = 0;
   int64_t offset_position = valid_bits_offset;
   while (position < num_values) {
diff --git a/cpp/src/arrow/visitor.cc b/cpp/src/arrow/visitor.cc
index ed3d5bc2c68d7..e057f6b12fb1b 100644
--- a/cpp/src/arrow/visitor.cc
+++ b/cpp/src/arrow/visitor.cc
@@ -45,8 +45,10 @@ ARRAY_VISITOR_DEFAULT(UInt64Array)
 ARRAY_VISITOR_DEFAULT(HalfFloatArray)
 ARRAY_VISITOR_DEFAULT(FloatArray)
 ARRAY_VISITOR_DEFAULT(DoubleArray)
-ARRAY_VISITOR_DEFAULT(BinaryArray)
 ARRAY_VISITOR_DEFAULT(StringArray)
+ARRAY_VISITOR_DEFAULT(StringViewArray)
+ARRAY_VISITOR_DEFAULT(BinaryArray)
+ARRAY_VISITOR_DEFAULT(BinaryViewArray)
 ARRAY_VISITOR_DEFAULT(LargeBinaryArray)
 ARRAY_VISITOR_DEFAULT(LargeStringArray)
 ARRAY_VISITOR_DEFAULT(FixedSizeBinaryArray)
@@ -96,7 +98,9 @@ TYPE_VISITOR_DEFAULT(HalfFloatType)
 TYPE_VISITOR_DEFAULT(FloatType)
 TYPE_VISITOR_DEFAULT(DoubleType)
 TYPE_VISITOR_DEFAULT(StringType)
+TYPE_VISITOR_DEFAULT(StringViewType)
 TYPE_VISITOR_DEFAULT(BinaryType)
+TYPE_VISITOR_DEFAULT(BinaryViewType)
 TYPE_VISITOR_DEFAULT(LargeStringType)
 TYPE_VISITOR_DEFAULT(LargeBinaryType)
 TYPE_VISITOR_DEFAULT(FixedSizeBinaryType)
@@ -147,7 +151,9 @@ SCALAR_VISITOR_DEFAULT(HalfFloatScalar)
 SCALAR_VISITOR_DEFAULT(FloatScalar)
 SCALAR_VISITOR_DEFAULT(DoubleScalar)
 SCALAR_VISITOR_DEFAULT(StringScalar)
+SCALAR_VISITOR_DEFAULT(StringViewScalar)
 SCALAR_VISITOR_DEFAULT(BinaryScalar)
+SCALAR_VISITOR_DEFAULT(BinaryViewScalar)
 SCALAR_VISITOR_DEFAULT(LargeStringScalar)
 SCALAR_VISITOR_DEFAULT(LargeBinaryScalar)
 SCALAR_VISITOR_DEFAULT(FixedSizeBinaryScalar)
diff --git a/cpp/src/arrow/visitor.h b/cpp/src/arrow/visitor.h
index b22d4d3c567e1..650b0e7ee0a30 100644
--- a/cpp/src/arrow/visitor.h
+++ b/cpp/src/arrow/visitor.h
@@ -45,7 +45,9 @@ class ARROW_EXPORT ArrayVisitor {
   virtual Status Visit(const FloatArray& array);
   virtual Status Visit(const DoubleArray& array);
   virtual Status Visit(const StringArray& array);
+  virtual Status Visit(const StringViewArray& array);
   virtual Status Visit(const BinaryArray& array);
+  virtual Status Visit(const BinaryViewArray& array);
   virtual Status Visit(const LargeStringArray& array);
   virtual Status Visit(const LargeBinaryArray& array);
   virtual Status Visit(const FixedSizeBinaryArray& array);
@@ -94,7 +96,9 @@ class ARROW_EXPORT TypeVisitor {
   virtual Status Visit(const FloatType& type);
   virtual Status Visit(const DoubleType& type);
   virtual Status Visit(const StringType& type);
+  virtual Status Visit(const StringViewType& type);
   virtual Status Visit(const BinaryType& type);
+  virtual Status Visit(const BinaryViewType& type);
   virtual Status Visit(const LargeStringType& type);
   virtual Status Visit(const LargeBinaryType& type);
   virtual Status Visit(const FixedSizeBinaryType& type);
@@ -143,7 +147,9 @@ class ARROW_EXPORT ScalarVisitor {
   virtual Status Visit(const FloatScalar& scalar);
   virtual Status Visit(const DoubleScalar& scalar);
   virtual Status Visit(const StringScalar& scalar);
+  virtual Status Visit(const StringViewScalar& scalar);
   virtual Status Visit(const BinaryScalar& scalar);
+  virtual Status Visit(const BinaryViewScalar& scalar);
   virtual Status Visit(const LargeStringScalar& scalar);
   virtual Status Visit(const LargeBinaryScalar& scalar);
   virtual Status Visit(const FixedSizeBinaryScalar& scalar);
diff --git a/cpp/src/arrow/visitor_generate.h b/cpp/src/arrow/visitor_generate.h
index 8f6b176ba8fea..4b57abe53ff14 100644
--- a/cpp/src/arrow/visitor_generate.h
+++ b/cpp/src/arrow/visitor_generate.h
@@ -40,7 +40,9 @@ namespace arrow {
   ACTION(Boolean);                              \
   ARROW_GENERATE_FOR_ALL_NUMERIC_TYPES(ACTION); \
   ACTION(String);                               \
+  ACTION(StringView);                           \
   ACTION(Binary);                               \
+  ACTION(BinaryView);                           \
   ACTION(LargeString);                          \
   ACTION(LargeBinary);                          \
   ACTION(FixedSizeBinary);                      \
diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 315405ef1e569..4e23d0fab5c69 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -3374,6 +3374,8 @@ TEST(ArrowReadWrite, NestedRequiredOuterOptional) {
 
   for (const auto& inner_type : types) {
     if (inner_type->id() == ::arrow::Type::NA) continue;
+    if (inner_type->id() == ::arrow::Type::BINARY_VIEW) continue;
+    if (inner_type->id() == ::arrow::Type::STRING_VIEW) continue;
 
     auto writer_props = WriterProperties::Builder();
     auto arrow_writer_props = ArrowWriterProperties::Builder();
@@ -3389,7 +3391,6 @@ TEST(ArrowReadWrite, NestedRequiredOuterOptional) {
         arrow_writer_props.coerce_timestamps(unit);
       }
     }
-
     ASSERT_NO_FATAL_FAILURE(DoNestedRequiredRoundtrip(inner_type, writer_props.build(),
                                                       arrow_writer_props.build()));
 
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 72e984d7736fa..5dff533c1cce2 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -134,6 +134,8 @@ struct ValueBufferSlicer {
   NOT_IMPLEMENTED_VISIT(Dictionary);
   NOT_IMPLEMENTED_VISIT(RunEndEncoded);
   NOT_IMPLEMENTED_VISIT(Extension);
+  NOT_IMPLEMENTED_VISIT(BinaryView);
+  NOT_IMPLEMENTED_VISIT(StringView);
 
 #undef NOT_IMPLEMENTED_VISIT
 
diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 7635cfd98feda..1ce2775c160b8 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1856,12 +1856,13 @@ def _temp_path():
         .skip_tester('Rust'),
 
         generate_binary_view_case()
-        .skip_tester('C++')
         .skip_tester('C#')
         .skip_tester('Go')
         .skip_tester('Java')
         .skip_tester('JS')
-        .skip_tester('Rust'),
+        .skip_tester('Rust')
+        .skip_format(SKIP_C_SCHEMA, 'C++')
+        .skip_format(SKIP_C_ARRAY, 'C++'),
 
         generate_extension_case()
         .skip_tester('C#')
diff --git a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
index 91c7b8a45718e..8ed5d4e216e8e 100644
--- a/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
+++ b/python/pyarrow/src/arrow/python/arrow_to_pandas.cc
@@ -1353,7 +1353,8 @@ struct ObjectWriterVisitor {
                   std::is_same<ExtensionType, Type>::value ||
                   (std::is_base_of<IntervalType, Type>::value &&
                    !std::is_same<MonthDayNanoIntervalType, Type>::value) ||
-                  std::is_base_of<UnionType, Type>::value,
+                  std::is_base_of<UnionType, Type>::value ||
+                  std::is_base_of<BinaryViewType, Type>::value,
               Status>
   Visit(const Type& type) {
     return Status::NotImplemented("No implemented conversion to object dtype: ",
diff --git a/python/pyarrow/src/arrow/python/python_to_arrow.cc b/python/pyarrow/src/arrow/python/python_to_arrow.cc
index 2143129356fd5..e47492499867a 100644
--- a/python/pyarrow/src/arrow/python/python_to_arrow.cc
+++ b/python/pyarrow/src/arrow/python/python_to_arrow.cc
@@ -572,12 +572,18 @@ struct PyConverterTrait;
 
 template <typename T>
 struct PyConverterTrait<
-    T, enable_if_t<(!is_nested_type<T>::value && !is_interval_type<T>::value &&
-                    !is_extension_type<T>::value) ||
-                   std::is_same<T, MonthDayNanoIntervalType>::value>> {
+    T,
+    enable_if_t<(!is_nested_type<T>::value && !is_interval_type<T>::value &&
+                 !is_extension_type<T>::value && !is_binary_view_like_type<T>::value) ||
+                std::is_same<T, MonthDayNanoIntervalType>::value>> {
   using type = PyPrimitiveConverter<T>;
 };
 
+template <typename T>
+struct PyConverterTrait<T, enable_if_binary_view_like<T>> {
+  // not implemented
+};
+
 template <typename T>
 struct PyConverterTrait<T, enable_if_list_like<T>> {
   using type = PyListConverter<T>;
diff --git a/r/src/r_to_arrow.cpp b/r/src/r_to_arrow.cpp
index 19c23973a62fe..d9bf848e24292 100644
--- a/r/src/r_to_arrow.cpp
+++ b/r/src/r_to_arrow.cpp
@@ -1051,10 +1051,15 @@ struct RConverterTrait;
 template <typename T>
 struct RConverterTrait<
     T, enable_if_t<!is_nested_type<T>::value && !is_interval_type<T>::value &&
-                   !is_extension_type<T>::value>> {
+                   !is_extension_type<T>::value && !is_binary_view_like_type<T>::value>> {
   using type = RPrimitiveConverter<T>;
 };
 
+template <typename T>
+struct RConverterTrait<T, enable_if_binary_view_like<T>> {
+  // not implemented
+};
+
 template <typename T>
 struct RConverterTrait<T, enable_if_list_like<T>> {
   using type = RListConverter<T>;

From fcbcb7dab71b14ff3436af7b21bd23132877e2fa Mon Sep 17 00:00:00 2001
From: Felipe Oliveira Carvalho <felipekde@gmail.com>
Date: Thu, 26 Oct 2023 18:35:05 -0300
Subject: [PATCH 640/749] GH-34569: [C++] Diffing of Run-End Encoded arrays
 (#35003)

### What changes are included in this PR?

Ability to diff run-end encoded arrays without expanding them first. This is useful for debugging and understanding of unit test failures.

Many successive random accesses to REE arrays by logical indices incur many successive binary searches on the run-ends array to find the physical index of the values array, so this PR implements a few interesting optimizations -- the most complicated one is encapsulated in a new utility available via `ree_util.h` as there are many potential uses for it other than diffing.

    +-------------+---------------------------+----------------------------------------------------+
    |             |                                  Optimizations                                 |
    +-------------+---------------------------+-----------------------+----------------------------+
    | # bsearches | Null checks on Comparator | RunLengthOfEqualsFrom | Cached FindPhysicalIndex() |
    +-------------+---------------------------+----------------------+-----------------------------+
    |    3798     |                           |                      |                             |
    +-------------+---------------------------+----------------------+-----------------------------+
    |    1914     |           X               |                      |                             |
    +-------------+---------------------------+----------------------+-----------------------------+
    |     180     |           X               |        X             |                             |
    +-------------+---------------------------+----------------------+-----------------------------+
    |     153     |           X               |                      |           X                 |
    +-------------+---------------------------+----------------------+-----------------------------+
    |      75     |           X               |        X             |           X                 |
    +-------------+---------------------------+----------------------+-----------------------------+

### Are these changes tested?

Yes. By existing and newly added REE-specific tests.

### Are there any user-facing changes?

No.

* Closes: #34569

Authored-by: Felipe Oliveira Carvalho <felipekde@gmail.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/array/diff.cc      | 319 +++++++++++++++++++++++++------
 cpp/src/arrow/array/diff_test.cc | 107 +++++++++++
 cpp/src/arrow/util/ree_util.cc   |  56 ++++++
 cpp/src/arrow/util/ree_util.h    |  68 +++++++
 4 files changed, 491 insertions(+), 59 deletions(-)

diff --git a/cpp/src/arrow/array/diff.cc b/cpp/src/arrow/array/diff.cc
index f267c52c0d696..be9597e59b378 100644
--- a/cpp/src/arrow/array/diff.cc
+++ b/cpp/src/arrow/array/diff.cc
@@ -21,6 +21,7 @@
 #include <chrono>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <sstream>
 #include <string>
 #include <string_view>
@@ -32,6 +33,7 @@
 #include "arrow/array/array_decimal.h"
 #include "arrow/array/array_nested.h"
 #include "arrow/array/array_primitive.h"
+#include "arrow/array/array_run_end.h"
 #include "arrow/buffer.h"
 #include "arrow/buffer_builder.h"
 #include "arrow/extension_type.h"
@@ -43,7 +45,9 @@
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/range.h"
+#include "arrow/util/ree_util.h"
 #include "arrow/util/string.h"
+#include "arrow/util/unreachable.h"
 #include "arrow/vendored/datetime.h"
 #include "arrow/visit_type_inline.h"
 
@@ -96,45 +100,247 @@ static UnitSlice GetView(const UnionArray& array, int64_t index) {
   return UnitSlice{&array, index};
 }
 
-using ValueComparator = std::function<bool(const Array&, int64_t, const Array&, int64_t)>;
+/// \brief A simple virtual comparator interface for two arrays.
+///
+/// The base and target array ara bound at construction time. Then
+/// Equals(base_index, target_index) should return true if the values
+/// at the given indices are equal.
+struct ValueComparator {
+  virtual ~ValueComparator() = default;
+
+  /// \brief Compare the validity and values at the given indices in the base and target
+  /// arrays.
+  ///
+  /// \param base_index The index in the base array.
+  /// \param target_index The index in the target array.
+  /// \return true if the values at the given indices are equal, false otherwise.
+  /// \pre base_index and target_index are valid indices in their respective arrays.
+  virtual bool Equals(int64_t base_index, int64_t target_index) = 0;
+
+  /// \brief Return the run length of equal values starting at the given indices in the
+  /// base and target arrays.
+  ///
+  /// \param base_index The starting index in the base array.
+  /// \param base_length The length of the base array.
+  /// \param target_index The starting index in the target array.
+  /// \param target_length The length of the target array.
+  /// \return The run length of equal values starting at the given indices in the base
+  /// and target arrays.
+  virtual int64_t RunLengthOfEqualsFrom(int64_t base_index, int64_t base_length,
+                                        int64_t target_index, int64_t target_length) {
+    int64_t run_length_of_equals = 0;
+    while (base_index < base_length && target_index < target_length) {
+      if (!Equals(base_index, target_index)) {
+        break;
+      }
+      base_index += 1;
+      target_index += 1;
+      run_length_of_equals += 1;
+    }
+    return run_length_of_equals;
+  }
+};
+
+template <typename ArrayType>
+struct DefaultValueComparator : public ValueComparator {
+  const ArrayType& base;
+  const ArrayType& target;
+
+  DefaultValueComparator(const ArrayType& base, const ArrayType& target)
+      : base(base), target(target) {}
+
+  ~DefaultValueComparator() override = default;
+
+  bool Equals(int64_t base_index, int64_t target_index) override {
+    const bool base_valid = base.IsValid(base_index);
+    const bool target_valid = target.IsValid(target_index);
+    if (base_valid && target_valid) {
+      return GetView(base, base_index) == GetView(target, target_index);
+    }
+    return base_valid == target_valid;
+  }
+};
+
+template <typename RunEndCType>
+class REEValueComparator : public ValueComparator {
+ private:
+  const RunEndEncodedArray& base_;
+  const RunEndEncodedArray& target_;
+  std::unique_ptr<ValueComparator> inner_value_comparator_;
+  ree_util::PhysicalIndexFinder<RunEndCType> base_physical_index_finder_;
+  ree_util::PhysicalIndexFinder<RunEndCType> target_physical_index_finder_;
+
+ public:
+  REEValueComparator(const RunEndEncodedArray& base, const RunEndEncodedArray& target,
+                     std::unique_ptr<ValueComparator>&& inner_value_comparator)
+      : base_(base),
+        target_(target),
+        inner_value_comparator_(std::move(inner_value_comparator)),
+        base_physical_index_finder_(*base_.data()),
+        target_physical_index_finder_(*target_.data()) {
+    DCHECK_EQ(*base_.type(), *target_.type());
+  }
+
+  ~REEValueComparator() override = default;
+
+ private:
+  /// \pre 0 <= i < base_.length()
+  inline int64_t FindPhysicalIndexOnBase(int64_t i) {
+    return base_physical_index_finder_.FindPhysicalIndex(i);
+  }
+
+  /// \pre 0 <= i < target_.length()
+  inline int64_t FindPhysicalIndexOnTarget(int64_t i) {
+    return target_physical_index_finder_.FindPhysicalIndex(i);
+  }
+
+  const RunEndCType* base_run_ends() { return base_physical_index_finder_.run_ends; }
+
+  const RunEndCType* target_run_ends() { return target_physical_index_finder_.run_ends; }
+
+ public:
+  int64_t RunLengthOfEqualsFrom(int64_t base_index, int64_t base_length,
+                                int64_t target_index, int64_t target_length) override {
+    // Ensure the first search for physical index on the values arrays is safe.
+    if (base_index >= base_length || target_index >= target_length) {
+      // Without values on either side, there is no run of equal values.
+      return 0;
+    }
+
+    // Translate the two logical indices into physical indices.
+    int64_t physical_base_index = FindPhysicalIndexOnBase(base_index);
+    int64_t physical_target_index = FindPhysicalIndexOnTarget(target_index);
+
+    int64_t run_length_of_equals = 0;
+    // The loop invariant (base_index < base_length && target_index < target_length)
+    // is valid when the loop starts because of the check above.
+    for (;;) {
+      const auto base_run_end =
+          static_cast<int64_t>(base_run_ends()[physical_base_index]) - base_.offset();
+      const auto target_run_end =
+          static_cast<int64_t>(target_run_ends()[physical_target_index]) -
+          target_.offset();
+      // The end of the runs containing the logical indices, by definition, ends
+      // after the logical indices.
+      DCHECK_LT(base_index, base_run_end);
+      DCHECK_LT(target_index, target_run_end);
+
+      // Compare the physical values that make up the runs containing base_index
+      // and target_index.
+      if (!inner_value_comparator_->Equals(physical_base_index, physical_target_index)) {
+        // First difference found, stop because the run of equal values cannot
+        // be extended further.
+        break;
+      }
+
+      const int64_t base_run = std::min(base_run_end, base_length) - base_index;
+      const int64_t target_run = std::min(target_run_end, target_length) - target_index;
+      // Due to the loop-invariant (base_index < base_length && target_index <
+      // target_length) and properties of the run-ends asserted above, both base_run and
+      // target_run are strictly greater than zero.
+      DCHECK_GT(base_run, 0);
+      DCHECK_GT(target_run, 0);
+
+      // Skip the smallest run (or both runs if they are equal)
+      const int64_t increment = std::min(base_run, target_run);
+      physical_base_index += increment == base_run;
+      physical_target_index += increment == target_run;
+
+      // Since both base_run and target_run are greater than zero,
+      // increment is also greater than zero...
+      DCHECK_GT(increment, 0);
+      // ...which implies that the loop will make progress and eventually terminate
+      // because base_index or target_index will equal base_length or target_length,
+      // respectively.
+      base_index += increment;
+      target_index += increment;
+      // The value representing the two runs are equal, so we can assume that at
+      // least `increment` (size of smallest run) values are equal.
+      run_length_of_equals += increment;
+
+      if (base_index >= base_length || target_index >= target_length) {
+        break;
+      }
+    }
+
+    return run_length_of_equals;
+  }
 
-struct ValueComparatorVisitor {
+  bool Equals(int64_t base_index, int64_t target_index) override {
+    const int64_t physical_base_index = FindPhysicalIndexOnBase(base_index);
+    const int64_t physical_target_index = FindPhysicalIndexOnTarget(target_index);
+    return inner_value_comparator_->Equals(physical_base_index, physical_target_index);
+  }
+};
+
+class ValueComparatorFactory {
+ private:
+  std::unique_ptr<ValueComparator> comparator_;
+
+ public:
   template <typename T>
-  Status Visit(const T&) {
+  Status Visit(const T&, const Array& base, const Array& target) {
     using ArrayType = typename TypeTraits<T>::ArrayType;
-    out = [](const Array& base, int64_t base_index, const Array& target,
-             int64_t target_index) {
-      return (GetView(checked_cast<const ArrayType&>(base), base_index) ==
-              GetView(checked_cast<const ArrayType&>(target), target_index));
-    };
+    comparator_ = std::make_unique<DefaultValueComparator<ArrayType>>(
+        checked_cast<const ArrayType&>(base), checked_cast<const ArrayType&>(target));
     return Status::OK();
   }
 
-  Status Visit(const NullType&) { return Status::NotImplemented("null type"); }
+  Status Visit(const NullType&, const Array&, const Array&) {
+    return Status::NotImplemented("null type");
+  }
 
-  Status Visit(const ExtensionType&) { return Status::NotImplemented("extension type"); }
+  Status Visit(const ExtensionType&, const Array&, const Array&) {
+    return Status::NotImplemented("extension type");
+  }
 
-  Status Visit(const DictionaryType&) {
+  Status Visit(const DictionaryType&, const Array& base, const Array& target) {
     return Status::NotImplemented("dictionary type");
   }
 
-  Status Visit(const RunEndEncodedType&) {
-    return Status::NotImplemented("run-end encoded type");
+  Status Visit(const RunEndEncodedType& ree_type, const Array& base,
+               const Array& target) {
+    const auto& base_ree = checked_cast<const RunEndEncodedArray&>(base);
+    const auto& target_ree = checked_cast<const RunEndEncodedArray&>(target);
+
+    ARROW_ASSIGN_OR_RAISE(
+        auto inner_values_comparator,
+        Create(*ree_type.value_type(), *base_ree.values(), *target_ree.values()));
+
+    // Instantiate the specialized comparator types with operator new instead of
+    // make_unique<T>() to avoid binary bloat. unique_ptr<T>'s constructor is templated
+    // on the type of the deleter and we're fine with destructor calls being virtually
+    // dispatched via ValueComparator.
+    ValueComparator* ree_value_comparator = nullptr;
+    switch (ree_type.run_end_type()->id()) {
+      case Type::INT16:
+        ree_value_comparator = new REEValueComparator<int16_t>(
+            base_ree, target_ree, std::move(inner_values_comparator));
+        break;
+      case Type::INT32:
+        ree_value_comparator = new REEValueComparator<int32_t>(
+            base_ree, target_ree, std::move(inner_values_comparator));
+        break;
+      case Type::INT64:
+        ree_value_comparator = new REEValueComparator<int64_t>(
+            base_ree, target_ree, std::move(inner_values_comparator));
+        break;
+      default:
+        Unreachable();
+    }
+    comparator_.reset(ree_value_comparator);
+    return Status::OK();
   }
 
-  ValueComparator Create(const DataType& type) {
-    DCHECK_OK(VisitTypeInline(type, this));
-    return out;
+  static Result<std::unique_ptr<ValueComparator>> Create(const DataType& type,
+                                                         const Array& base,
+                                                         const Array& target) {
+    ValueComparatorFactory self;
+    RETURN_NOT_OK(VisitTypeInline(type, &self, base, target));
+    return std::move(self.comparator_);
   }
-
-  ValueComparator out;
 };
 
-ValueComparator GetValueComparator(const DataType& type) {
-  ValueComparatorVisitor type_visitor;
-  return type_visitor.Create(type);
-}
-
 // represents an intermediate state in the comparison of two arrays
 struct EditPoint {
   int64_t base, target;
@@ -161,33 +367,9 @@ struct EditPoint {
 class QuadraticSpaceMyersDiff {
  public:
   QuadraticSpaceMyersDiff(const Array& base, const Array& target, MemoryPool* pool)
-      : base_(base),
-        target_(target),
-        pool_(pool),
-        value_comparator_(GetValueComparator(*base.type())),
-        base_begin_(0),
-        base_end_(base.length()),
-        target_begin_(0),
-        target_end_(target.length()),
-        endpoint_base_({ExtendFrom({base_begin_, target_begin_}).base}),
-        insert_({true}) {
-    if ((base_end_ - base_begin_ == target_end_ - target_begin_) &&
-        endpoint_base_[0] == base_end_) {
-      // trivial case: base == target
-      finish_index_ = 0;
-    }
-  }
-
-  bool ValuesEqual(int64_t base_index, int64_t target_index) const {
-    bool base_null = base_.IsNull(base_index);
-    bool target_null = target_.IsNull(target_index);
-    if (base_null || target_null) {
-      // If only one is null, then this is false, otherwise true
-      return base_null && target_null;
-    }
-    return value_comparator_(base_, base_index, target_, target_index);
-  }
+      : base_(base), target_(target), pool_(pool) {}
 
+ private:
   // increment the position within base (the element pointed to was deleted)
   // then extend maximally
   EditPoint DeleteOne(EditPoint p) const {
@@ -209,11 +391,10 @@ class QuadraticSpaceMyersDiff {
   // increment the position within base and target (the elements skipped in this way were
   // present in both sequences)
   EditPoint ExtendFrom(EditPoint p) const {
-    for (; p.base != base_end_ && p.target != target_end_; ++p.base, ++p.target) {
-      if (!ValuesEqual(p.base, p.target)) {
-        break;
-      }
-    }
+    const int64_t run_length_of_equals =
+        _comparator->RunLengthOfEqualsFrom(p.base, base_end_, p.target, target_end_);
+    p.base += run_length_of_equals;
+    p.target += run_length_of_equals;
     return p;
   }
 
@@ -321,7 +502,24 @@ class QuadraticSpaceMyersDiff {
         {field("insert", boolean()), field("run_length", int64())});
   }
 
+ public:
   Result<std::shared_ptr<StructArray>> Diff() {
+    base_begin_ = 0;
+    base_end_ = base_.length();
+    target_begin_ = 0;
+    target_end_ = target_.length();
+    ARROW_ASSIGN_OR_RAISE(_comparator,
+                          ValueComparatorFactory::Create(*base_.type(), base_, target_));
+
+    finish_index_ = -1;
+    edit_count_ = 0;
+    endpoint_base_ = {ExtendFrom({base_begin_, target_begin_}).base};
+    insert_ = {true};
+    if ((base_end_ - base_begin_ == target_end_ - target_begin_) &&
+        endpoint_base_[0] == base_end_) {
+      // trivial case: base == target
+      finish_index_ = 0;
+    }
     while (!Done()) {
       Next();
     }
@@ -329,14 +527,19 @@ class QuadraticSpaceMyersDiff {
   }
 
  private:
+  // Constructor-injected references
   const Array& base_;
   const Array& target_;
   MemoryPool* pool_;
-  ValueComparator value_comparator_;
+
+  // Initialized on Diff() and immutable thereafter
+  int64_t base_begin_ = 0, base_end_ = -1;
+  int64_t target_begin_ = 0, target_end_ = -1;
+  std::unique_ptr<ValueComparator> _comparator;
+
+  // Initialized on Next() and mutated throughout the diffing process
   int64_t finish_index_ = -1;
   int64_t edit_count_ = 0;
-  int64_t base_begin_, base_end_;
-  int64_t target_begin_, target_end_;
   // each element of endpoint_base_ is the furthest position in base reachable given an
   // edit_count and (# insertions) - (# deletions). Each bit of insert_ records whether
   // the corresponding furthest position was reached via an insertion or a deletion
@@ -386,8 +589,6 @@ Result<std::shared_ptr<StructArray>> Diff(const Array& base, const Array& target
     return Diff(*base_storage, *target_storage, pool);
   } else if (base.type()->id() == Type::DICTIONARY) {
     return Status::NotImplemented("diffing arrays of type ", *base.type());
-  } else if (base.type()->id() == Type::RUN_END_ENCODED) {
-    return Status::NotImplemented("diffing arrays of type ", *base.type());
   } else {
     return QuadraticSpaceMyersDiff(base, target, pool).Diff();
   }
diff --git a/cpp/src/arrow/array/diff_test.cc b/cpp/src/arrow/array/diff_test.cc
index 4c2f39eddf863..145978a91ad54 100644
--- a/cpp/src/arrow/array/diff_test.cc
+++ b/cpp/src/arrow/array/diff_test.cc
@@ -163,6 +163,107 @@ class DiffTest : public ::testing::Test {
     AssertRunLengthIs("[2, 0, 0]");
   }
 
+  std::shared_ptr<RunEndEncodedArray> RunEndEncodedArrayFromJSON(
+      int64_t logical_length, const std::shared_ptr<DataType>& ree_type,
+      std::string_view run_ends_json, std::string_view values_json,
+      int64_t logical_offset = 0) {
+    auto& ree_type_ref = checked_cast<const RunEndEncodedType&>(*ree_type);
+    auto run_ends = ArrayFromJSON(ree_type_ref.run_end_type(), run_ends_json);
+    auto values = ArrayFromJSON(ree_type_ref.value_type(), values_json);
+    return RunEndEncodedArray::Make(logical_length, std::move(run_ends),
+                                    std::move(values), logical_offset)
+        .ValueOrDie();
+  }
+
+  template <typename RunEndType>
+  void TestBasicsWithREEs() {
+    auto run_end_type = std::make_shared<RunEndType>();
+    auto value_type = utf8();
+    auto ree_type = run_end_encoded(run_end_type, value_type);
+
+    // empty REEs
+    base_ = RunEndEncodedArrayFromJSON(0, ree_type, "[]", "[]");
+    target_ = RunEndEncodedArrayFromJSON(0, ree_type, "[]", "[]");
+    DoDiff();
+    AssertInsertIs("[false]");
+    AssertRunLengthIs("[0]");
+
+    // null REE arrays of different lengths
+    base_ = RunEndEncodedArrayFromJSON(2, ree_type, "[2]", "[null]");
+    target_ = RunEndEncodedArrayFromJSON(4, ree_type, "[4]", "[null]");
+    DoDiff();
+    AssertInsertIs("[false, true, true]");
+    AssertRunLengthIs("[2, 0, 0]");
+
+    // identical REE arrays w/ offsets
+    base_ =
+        RunEndEncodedArrayFromJSON(110, ree_type, R"([20, 120])", R"(["a", "b"])", 10);
+    target_ =
+        RunEndEncodedArrayFromJSON(110, ree_type, R"([20, 120])", R"(["a", "b"])", 10);
+    DoDiff();
+    AssertInsertIs("[false]");
+    AssertRunLengthIs("[110]");
+
+    // equivalent REE arrays
+    base_ = RunEndEncodedArrayFromJSON(120, ree_type, R"([10, 20, 120])",
+                                       R"(["a", "a", "b"])");
+    target_ = RunEndEncodedArrayFromJSON(120, ree_type, R"([20, 30, 120])",
+                                         R"(["a", "b", "b"])");
+    DoDiff();
+    AssertInsertIs("[false]");
+    AssertRunLengthIs("[120]");
+
+    // slice so last run-end goes beyond length
+    base_ = base_->Slice(5, 105);
+    target_ = target_->Slice(5, 105);
+    DoDiff();
+    AssertInsertIs("[false]");
+    AssertRunLengthIs("[105]");
+
+    // insert one
+    base_ = RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 12])", R"(["a", "b"])");
+    target_ = RunEndEncodedArrayFromJSON(13, ree_type, R"([3, 13])", R"(["a", "b"])");
+    DoDiff();
+    AssertInsertIs("[false, true]");
+    AssertRunLengthIs("[2, 10]");
+
+    // delete one
+    base_ =
+        RunEndEncodedArrayFromJSON(13, ree_type, R"([2, 5, 13])", R"(["a", "b", "c"])");
+    target_ =
+        RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 4, 12])", R"(["a", "b", "c"])");
+    DoDiff();
+    AssertInsertIs("[false, false]");
+    AssertRunLengthIs("[4, 8]");
+
+    // null out one
+    base_ =
+        RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 5, 12])", R"(["a", "b", "c"])");
+    target_ = RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 4, 5, 12])",
+                                         R"(["a", "b", null, "c"])");
+    DoDiff();
+    AssertInsertIs("[false, false, true]");
+    AssertRunLengthIs("[4, 0, 7]");
+
+    // append some
+    base_ = RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 4, 8, 12])",
+                                       R"(["a", "b", "c", "d"])");
+    target_ = RunEndEncodedArrayFromJSON(15, ree_type, R"([2, 4, 8, 13, 15])",
+                                         R"(["a", "b", "c", "d", "e"])");
+    DoDiff();
+    AssertInsertIs("[false, true, true, true]");
+    AssertRunLengthIs("[12, 0, 0, 0]");
+
+    // prepend some
+    base_ = RunEndEncodedArrayFromJSON(12, ree_type, R"([2, 4, 8, 12])",
+                                       R"(["c", "d", "e", "f"])");
+    target_ = RunEndEncodedArrayFromJSON(15, ree_type, R"([1, 3, 5, 7, 11, 15])",
+                                         R"(["a", "b", "c", "d", "e", "f"])");
+    DoDiff();
+    AssertInsertIs("[false, true, true, true]");
+    AssertRunLengthIs("[0, 0, 0, 12]");
+  }
+
   random::RandomArrayGenerator rng_;
   std::shared_ptr<StructArray> edits_;
   std::shared_ptr<Array> base_, target_;
@@ -415,6 +516,12 @@ TEST_F(DiffTest, BasicsWithSparseUnions) { TestBasicsWithUnions(UnionMode::SPARS
 
 TEST_F(DiffTest, BasicsWithDenseUnions) { TestBasicsWithUnions(UnionMode::DENSE); }
 
+TEST_F(DiffTest, BasicsWithREEs) {
+  TestBasicsWithREEs<Int16Type>();
+  TestBasicsWithREEs<Int32Type>();
+  TestBasicsWithREEs<Int64Type>();
+}
+
 TEST_F(DiffTest, UnifiedDiffFormatter) {
   // no changes
   base_ = ArrayFromJSON(utf8(), R"(["give", "me", "a", "break"])");
diff --git a/cpp/src/arrow/util/ree_util.cc b/cpp/src/arrow/util/ree_util.cc
index fcd6c204e06b2..819de5eb60c63 100644
--- a/cpp/src/arrow/util/ree_util.cc
+++ b/cpp/src/arrow/util/ree_util.cc
@@ -61,6 +61,62 @@ int64_t LogicalNullCount(const ArraySpan& span) {
   return LogicalNullCount<int64_t>(span);
 }
 
+namespace internal {
+
+/// \pre 0 <= i < array_span.length()
+template <typename RunEndCType>
+int64_t FindPhysicalIndexImpl(PhysicalIndexFinder<RunEndCType>& self, int64_t i) {
+  DCHECK_LT(i, self.array_span.length);
+  const int64_t run_ends_size = ree_util::RunEndsArray(self.array_span).length;
+  DCHECK_LT(self.last_physical_index, run_ends_size);
+  // This access to self.run_ends[last_physical_index] is alwas safe because:
+  // 1. 0 <= i < array_span.length() implies there is at least one run and the initial
+  //    value 0 will be safe to index with.
+  // 2. last_physical_index > 0 is always the result of a valid call to
+  //    internal::FindPhysicalIndex.
+  if (ARROW_PREDICT_TRUE(self.array_span.offset + i <
+                         self.run_ends[self.last_physical_index])) {
+    // The cached value is an upper-bound, but is it the least upper-bound?
+    if (self.last_physical_index == 0 ||
+        self.array_span.offset + i >= self.run_ends[self.last_physical_index - 1]) {
+      return self.last_physical_index;
+    }
+    // last_physical_index - 1 is a candidate for the least upper-bound,
+    // so search for the least upper-bound in the range that includes it.
+    const int64_t j = ree_util::internal::FindPhysicalIndex<RunEndCType>(
+        self.run_ends, /*run_ends_size=*/self.last_physical_index, i,
+        self.array_span.offset);
+    DCHECK_LT(j, self.last_physical_index);
+    return self.last_physical_index = j;
+  }
+
+  // last_physical_index is not an upper-bound, and the logical index i MUST be
+  // in the runs that follow it. Since i is a valid logical index, we know that at least
+  // one extra run is present.
+  DCHECK_LT(self.last_physical_index + 1, run_ends_size);
+  const int64_t min_physical_index = self.last_physical_index + 1;
+
+  const int64_t j = ree_util::internal::FindPhysicalIndex<RunEndCType>(
+      /*run_ends=*/self.run_ends + min_physical_index,
+      /*run_ends_size=*/run_ends_size - min_physical_index, i, self.array_span.offset);
+  DCHECK_LT(min_physical_index + j, run_ends_size);
+  return self.last_physical_index = min_physical_index + j;
+}
+
+int64_t FindPhysicalIndexImpl16(PhysicalIndexFinder<int16_t>& self, int64_t i) {
+  return FindPhysicalIndexImpl(self, i);
+}
+
+int64_t FindPhysicalIndexImpl32(PhysicalIndexFinder<int32_t>& self, int64_t i) {
+  return FindPhysicalIndexImpl(self, i);
+}
+
+int64_t FindPhysicalIndexImpl64(PhysicalIndexFinder<int64_t>& self, int64_t i) {
+  return FindPhysicalIndexImpl(self, i);
+}
+
+}  // namespace internal
+
 int64_t FindPhysicalIndex(const ArraySpan& span, int64_t i, int64_t absolute_offset) {
   const auto type_id = RunEndsArray(span).type->id();
   if (type_id == Type::INT16) {
diff --git a/cpp/src/arrow/util/ree_util.h b/cpp/src/arrow/util/ree_util.h
index a3d3d16c0da95..2b7940154a50b 100644
--- a/cpp/src/arrow/util/ree_util.h
+++ b/cpp/src/arrow/util/ree_util.h
@@ -23,6 +23,7 @@
 
 #include "arrow/array/data.h"
 #include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
 #include "arrow/util/macros.h"
 
 namespace arrow {
@@ -139,6 +140,69 @@ int64_t FindPhysicalLength(const ArraySpan& span) {
       /*offset=*/span.offset);
 }
 
+template <typename RunEndCType>
+struct PhysicalIndexFinder;
+
+// non-inline implementations for each run-end type
+ARROW_EXPORT int64_t FindPhysicalIndexImpl16(PhysicalIndexFinder<int16_t>& self,
+                                             int64_t i);
+ARROW_EXPORT int64_t FindPhysicalIndexImpl32(PhysicalIndexFinder<int32_t>& self,
+                                             int64_t i);
+ARROW_EXPORT int64_t FindPhysicalIndexImpl64(PhysicalIndexFinder<int64_t>& self,
+                                             int64_t i);
+
+/// \brief Stateful version of FindPhysicalIndex() that caches the result of
+/// the previous search and uses it to optimize the next search.
+///
+/// When new queries for the physical index of a logical index come in,
+/// binary search is performed again but the first candidate checked is the
+/// result of the previous search (cached physical index) instead of the
+/// midpoint of the run-ends array.
+///
+/// If that test fails, internal::FindPhysicalIndex() is called with one of the
+/// partitions defined by the cached index. If the queried logical indices
+/// follow an increasing or decreasing pattern, this first test is much more
+/// effective in (1) finding the answer right away (close logical indices belong
+/// to the same runs) or (2) discarding many more candidates than probing
+/// the midpoint would.
+///
+/// The most adversarial case (i.e. alternating between 0 and length-1 queries)
+/// only adds one extra binary search probe when compared to always starting
+/// binary search from the midpoint without any of these optimizations.
+///
+/// \tparam RunEndCType The numeric type of the run-ends array.
+template <typename RunEndCType>
+struct PhysicalIndexFinder {
+  const ArraySpan array_span;
+  const RunEndCType* run_ends;
+  int64_t last_physical_index = 0;
+
+  explicit PhysicalIndexFinder(const ArrayData& data)
+      : array_span(data),
+        run_ends(RunEndsArray(array_span).template GetValues<RunEndCType>(1)) {
+    assert(CTypeTraits<RunEndCType>::ArrowType::type_id ==
+           ::arrow::internal::checked_cast<const RunEndEncodedType&>(*data.type)
+               .run_end_type()
+               ->id());
+  }
+
+  /// \brief Find the physical index into the values array of the REE array.
+  ///
+  /// \pre 0 <= i < array_span.length()
+  /// \param i the logical index into the REE array
+  /// \return the physical index into the values array
+  int64_t FindPhysicalIndex(int64_t i) {
+    if constexpr (std::is_same_v<RunEndCType, int16_t>) {
+      return FindPhysicalIndexImpl16(*this, i);
+    } else if constexpr (std::is_same_v<RunEndCType, int32_t>) {
+      return FindPhysicalIndexImpl32(*this, i);
+    } else {
+      static_assert(std::is_same_v<RunEndCType, int64_t>, "Unsupported RunEndCType.");
+      return FindPhysicalIndexImpl64(*this, i);
+    }
+  }
+};
+
 }  // namespace internal
 
 /// \brief Find the physical index into the values array of the REE ArraySpan
@@ -166,6 +230,10 @@ ARROW_EXPORT std::pair<int64_t, int64_t> FindPhysicalRange(const ArraySpan& span
                                                            int64_t offset,
                                                            int64_t length);
 
+// Publish PhysicalIndexFinder outside of the internal namespace.
+template <typename RunEndCType>
+using PhysicalIndexFinder = internal::PhysicalIndexFinder<RunEndCType>;
+
 template <typename RunEndCType>
 class RunEndEncodedArraySpan {
  private:

From 471334dbf4a1282de3afd52faa16eefbca941adb Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 27 Oct 2023 09:51:00 +0900
Subject: [PATCH 641/749] GH-38424: [CI][C++] Use Fedora 38 instead of 35
 (#38425)

### Rationale for this change

Because Fedora 35 reached EOL.

### What changes are included in this PR?

Use Fedora 38.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38424

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .env                                          |  2 +-
 ...pp.dockerfile => fedora-38-cpp.dockerfile} |  9 ++---
 cpp/CMakeLists.txt                            |  6 +--
 .../{FindORC.cmake => FindorcAlt.cmake}       | 37 +++++++++++--------
 cpp/cmake_modules/ThirdpartyToolchain.cmake   | 34 ++++++++++-------
 cpp/src/arrow/adapters/orc/CMakeLists.txt     |  2 +-
 dev/tasks/tasks.yml                           |  8 ++--
 docker-compose.yml                            |  6 +--
 8 files changed, 57 insertions(+), 47 deletions(-)
 rename ci/docker/{fedora-35-cpp.dockerfile => fedora-38-cpp.dockerfile} (95%)
 rename cpp/cmake_modules/{FindORC.cmake => FindorcAlt.cmake} (68%)

diff --git a/.env b/.env
index a551e2120a6fb..6746892fd4ed8 100644
--- a/.env
+++ b/.env
@@ -49,7 +49,7 @@ ULIMIT_CORE=-1
 ALMALINUX=8
 ALPINE_LINUX=3.16
 DEBIAN=11
-FEDORA=35
+FEDORA=38
 UBUNTU=20.04
 
 # Default versions for various dependencies
diff --git a/ci/docker/fedora-35-cpp.dockerfile b/ci/docker/fedora-38-cpp.dockerfile
similarity index 95%
rename from ci/docker/fedora-35-cpp.dockerfile
rename to ci/docker/fedora-38-cpp.dockerfile
index aefa25663ba14..2dcc094ee20c5 100644
--- a/ci/docker/fedora-35-cpp.dockerfile
+++ b/ci/docker/fedora-38-cpp.dockerfile
@@ -16,7 +16,7 @@
 # under the License.
 
 ARG arch
-FROM ${arch}/fedora:35
+FROM ${arch}/fedora:38
 ARG arch
 
 # install dependencies
@@ -46,9 +46,9 @@ RUN dnf update -y && \
         java-latest-openjdk-devel \
         java-latest-openjdk-headless \
         json-devel \
+        liborc-devel \
         libzstd-devel \
         llvm-devel \
-        llvm-static \
         lz4-devel \
         make \
         ninja-build \
@@ -64,6 +64,7 @@ RUN dnf update -y && \
         utf8proc-devel \
         wget \
         which \
+        xsimd-devel \
         zlib-devel
 
 COPY ci/scripts/install_minio.sh /arrow/ci/scripts/
@@ -100,8 +101,6 @@ ENV absl_SOURCE=BUNDLED \
     CC=gcc \
     CXX=g++ \
     google_cloud_cpp_storage_SOURCE=BUNDLED \
-    ORC_SOURCE=BUNDLED \
     PARQUET_BUILD_EXAMPLES=ON \
     PARQUET_BUILD_EXECUTABLES=ON \
-    PATH=/usr/lib/ccache/:$PATH \
-    xsimd_SOURCE=BUNDLED
+    PATH=/usr/lib/ccache/:$PATH
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 8566508406bd4..7138139b13ec0 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -770,10 +770,10 @@ if(ARROW_WITH_ZSTD)
 endif()
 
 if(ARROW_ORC)
-  list(APPEND ARROW_SHARED_LINK_LIBS orc::liborc ${ARROW_PROTOBUF_LIBPROTOBUF})
-  list(APPEND ARROW_STATIC_LINK_LIBS orc::liborc ${ARROW_PROTOBUF_LIBPROTOBUF})
+  list(APPEND ARROW_SHARED_LINK_LIBS orc::orc ${ARROW_PROTOBUF_LIBPROTOBUF})
+  list(APPEND ARROW_STATIC_LINK_LIBS orc::orc ${ARROW_PROTOBUF_LIBPROTOBUF})
   if(ORC_SOURCE STREQUAL "SYSTEM")
-    list(APPEND ARROW_STATIC_INSTALL_INTERFACE_LIBS orc::liborc
+    list(APPEND ARROW_STATIC_INSTALL_INTERFACE_LIBS orc::orc
          ${ARROW_PROTOBUF_LIBPROTOBUF})
   endif()
 endif()
diff --git a/cpp/cmake_modules/FindORC.cmake b/cpp/cmake_modules/FindorcAlt.cmake
similarity index 68%
rename from cpp/cmake_modules/FindORC.cmake
rename to cpp/cmake_modules/FindorcAlt.cmake
index aca915acc13d0..dc3b978cf4037 100644
--- a/cpp/cmake_modules/FindORC.cmake
+++ b/cpp/cmake_modules/FindorcAlt.cmake
@@ -15,13 +15,20 @@
 # specific language governing permissions and limitations
 # under the License.
 
-# - Find Apache ORC C++ (orc/orc-config.h, liborc.a)
-# This module defines
-#  ORC_INCLUDE_DIR, directory containing headers
-#  ORC_STATIC_LIB, path to liborc.a
-#  ORC_FOUND, whether orc has been found
+if(orcAlt_FOUND)
+  return()
+endif()
 
-if(ORC_FOUND)
+set(find_package_args)
+if(orcAlt_FIND_VERSION)
+  list(APPEND find_package_args ${orcAlt_FIND_VERSION})
+endif()
+if(orcAlt_FIND_QUIETLY)
+  list(APPEND find_package_args QUIET)
+endif()
+find_package(orc ${find_package_args})
+if(orc_FOUND)
+  set(orcAlt_FOUND TRUE)
   return()
 endif()
 
@@ -45,15 +52,13 @@ else()
             PATH_SUFFIXES ${ARROW_INCLUDE_PATH_SUFFIXES})
 endif()
 
-if(ORC_STATIC_LIB AND ORC_INCLUDE_DIR)
-  set(ORC_FOUND TRUE)
-  add_library(orc::liborc STATIC IMPORTED)
-  set_target_properties(orc::liborc
-                        PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}"
-                                   INTERFACE_INCLUDE_DIRECTORIES "${ORC_INCLUDE_DIR}")
-else()
-  if(ORC_FIND_REQUIRED)
-    message(FATAL_ERROR "ORC library was required in toolchain and unable to locate")
+find_package_handle_standard_args(orcAlt REQUIRED_VARS ORC_STATIC_LIB ORC_INCLUDE_DIR)
+
+if(orcAlt_FOUND)
+  if(NOT TARGET orc::orc)
+    add_library(orc::orc STATIC IMPORTED)
+    set_target_properties(orc::orc
+                          PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}"
+                                     INTERFACE_INCLUDE_DIRECTORIES "${ORC_INCLUDE_DIR}")
   endif()
-  set(ORC_FOUND FALSE)
 endif()
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 559ddf14f6a91..5de8ff9b1cb11 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -65,7 +65,7 @@ set(ARROW_THIRDPARTY_DEPENDENCIES
     lz4
     nlohmann_json
     opentelemetry-cpp
-    ORC
+    orc
     re2
     Protobuf
     RapidJSON
@@ -94,6 +94,14 @@ if("${re2_SOURCE}" STREQUAL "" AND NOT "${RE2_SOURCE}" STREQUAL "")
   set(re2_SOURCE ${RE2_SOURCE})
 endif()
 
+# For backward compatibility. We use "ORC_SOURCE" if "orc_SOURCE"
+# isn't specified and "ORC_SOURCE" is specified.
+# We renamed "ORC" dependency name to "orc" in 15.0.0 because
+# upstream uses "orc" not "ORC" as package name.
+if("${orc_SOURCE}" STREQUAL "" AND NOT "${ORC_SOURCE}" STREQUAL "")
+  set(orc_SOURCE ${ORC_SOURCE})
+endif()
+
 # For backward compatibility. We use "RE2_ROOT" if "re2_ROOT"
 # isn't specified and "RE2_ROOT" is specified.
 if("${re2_ROOT}" STREQUAL "" AND NOT "${RE2_ROOT}" STREQUAL "")
@@ -193,7 +201,7 @@ macro(build_dependency DEPENDENCY_NAME)
     build_nlohmann_json()
   elseif("${DEPENDENCY_NAME}" STREQUAL "opentelemetry-cpp")
     build_opentelemetry()
-  elseif("${DEPENDENCY_NAME}" STREQUAL "ORC")
+  elseif("${DEPENDENCY_NAME}" STREQUAL "orc")
     build_orc()
   elseif("${DEPENDENCY_NAME}" STREQUAL "Protobuf")
     build_protobuf()
@@ -4423,31 +4431,31 @@ macro(build_orc)
 
   set(ORC_VENDORED 1)
 
-  add_library(orc::liborc STATIC IMPORTED)
-  set_target_properties(orc::liborc PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}")
-  target_include_directories(orc::liborc BEFORE INTERFACE "${ORC_INCLUDE_DIR}")
-  set(ORC_LINK_LIBRARIES LZ4::lz4 ZLIB::ZLIB ${ARROW_ZSTD_LIBZSTD} ${Snappy_TARGET})
+  add_library(orc::orc STATIC IMPORTED)
+  set_target_properties(orc::orc PROPERTIES IMPORTED_LOCATION "${ORC_STATIC_LIB}")
+  target_include_directories(orc::orc BEFORE INTERFACE "${ORC_INCLUDE_DIR}")
+  target_link_libraries(orc::orc INTERFACE LZ4::lz4 ZLIB::ZLIB ${ARROW_ZSTD_LIBZSTD}
+                                           ${Snappy_TARGET})
   # Protobuf generated files may use ABSL_DCHECK*() and
   # absl::log_internal_check_op is needed for them.
   if(TARGET absl::log_internal_check_op)
-    list(APPEND ORC_LINK_LIBRARIES absl::log_internal_check_op)
+    target_link_libraries(orc::orc INTERFACE absl::log_internal_check_op)
   endif()
   if(NOT MSVC)
     if(NOT APPLE AND ARROW_ENABLE_THREADING)
-      list(APPEND ORC_LINK_LIBRARIES Threads::Threads)
+      target_link_libraries(orc::orc INTERFACE Threads::Threads)
     endif()
-    list(APPEND ORC_LINK_LIBRARIES ${CMAKE_DL_LIBS})
+    target_link_libraries(orc::orc INTERFACE ${CMAKE_DL_LIBS})
   endif()
-  target_link_libraries(orc::liborc INTERFACE ${ORC_LINK_LIBRARIES})
 
   add_dependencies(toolchain orc_ep)
-  add_dependencies(orc::liborc orc_ep)
+  add_dependencies(orc::orc orc_ep)
 
-  list(APPEND ARROW_BUNDLED_STATIC_LIBS orc::liborc)
+  list(APPEND ARROW_BUNDLED_STATIC_LIBS orc::orc)
 endmacro()
 
 if(ARROW_ORC)
-  resolve_dependency(ORC)
+  resolve_dependency(orc HAVE_ALT TRUE)
   message(STATUS "Found ORC static library: ${ORC_STATIC_LIB}")
   message(STATUS "Found ORC headers: ${ORC_INCLUDE_DIR}")
 endif()
diff --git a/cpp/src/arrow/adapters/orc/CMakeLists.txt b/cpp/src/arrow/adapters/orc/CMakeLists.txt
index e8ff69c191fb1..44719379994d9 100644
--- a/cpp/src/arrow/adapters/orc/CMakeLists.txt
+++ b/cpp/src/arrow/adapters/orc/CMakeLists.txt
@@ -32,7 +32,7 @@ else()
   set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
 endif()
 
-set(ORC_STATIC_TEST_LINK_LIBS orc::liborc ${ARROW_LIBRARIES_FOR_STATIC_TESTS}
+set(ORC_STATIC_TEST_LINK_LIBS orc::orc ${ARROW_LIBRARIES_FOR_STATIC_TESTS}
                               ${ARROW_GTEST_GTEST_MAIN} ${ARROW_GTEST_GTEST})
 
 add_arrow_test(adapter_test
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 17123ed2b8339..b620c9b8c8b0c 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -1182,12 +1182,12 @@ tasks:
       image: debian-cpp
 {% endfor %}
 
-  test-fedora-35-cpp:
+  test-fedora-38-cpp:
     ci: github
     template: docker-tests/github.linux.yml
     params:
       env:
-        FEDORA: 35
+        FEDORA: 38
       image: fedora-cpp
 
 {% for cpp_standard in [20] %}
@@ -1295,12 +1295,12 @@ tasks:
         UBUNTU: 22.04
       image: ubuntu-python
 
-  test-fedora-35-python-3:
+  test-fedora-38-python-3:
     ci: azure
     template: docker-tests/azure.linux.yml
     params:
       env:
-        FEDORA: 35
+        FEDORA: 38
       image: fedora-python
 
   test-r-linux-valgrind:
diff --git a/docker-compose.yml b/docker-compose.yml
index c23d3ff08e487..bbe4e65c10c43 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -655,7 +655,7 @@ services:
     #   docker-compose run --rm fedora-cpp
     # Parameters:
     #   ARCH: amd64, arm64v8, ...
-    #   FEDORA: 33
+    #   FEDORA: 38
     image: ${REPO}:${ARCH}-fedora-${FEDORA}-cpp
     build:
       context: .
@@ -671,7 +671,6 @@ services:
       <<: [*common, *ccache, *sccache, *cpp]
       ARROW_ENABLE_TIMING_TESTS:  # inherit
       ARROW_MIMALLOC: "ON"
-      Protobuf_SOURCE: "BUNDLED"  # Need Protobuf >= 3.15
     volumes: &fedora-volumes
       - .:/arrow:delegated
       - ${DOCKER_VOLUME_PREFIX}fedora-ccache:/ccache:delegated
@@ -957,7 +956,7 @@ services:
     #   docker-compose run --rm fedora-python
     # Parameters:
     #   ARCH: amd64, arm64v8, ...
-    #   FEDORA: 33
+    #   FEDORA: 38
     image: ${REPO}:${ARCH}-fedora-${FEDORA}-python-3
     build:
       context: .
@@ -969,7 +968,6 @@ services:
     shm_size: *shm-size
     environment:
       <<: [*common, *ccache]
-      Protobuf_SOURCE: "BUNDLED"  # Need Protobuf >= 3.15
     volumes: *fedora-volumes
     command: *python-command
 

From 6e6fd0a30aebee6738bb4bb703344f0c866debea Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 27 Oct 2023 09:52:07 +0900
Subject: [PATCH 642/749] GH-38378: [C++][Parquet] Don't initialize OpenSSL
 explicitly with OpenSSL 1.1 (#38379)

### Rationale for this change

This explicit initialization is for Valgrind and OpenSSL 1.1 will be unsupported eventually. So we can disable this explicit initialization for OpenSSL 1.1.

### What changes are included in this PR?

Disable the explicit initialization with OpenSSL 1.1.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38378

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/parquet/encryption/openssl_internal.cc | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cpp/src/parquet/encryption/openssl_internal.cc b/cpp/src/parquet/encryption/openssl_internal.cc
index 05f2773532353..61ec81b490802 100644
--- a/cpp/src/parquet/encryption/openssl_internal.cc
+++ b/cpp/src/parquet/encryption/openssl_internal.cc
@@ -24,11 +24,14 @@
 namespace parquet::encryption::openssl {
 
 void EnsureInitialized() {
+// OpenSSL 1.1 doesn't provide OPENSSL_INIT_ENGINE_ALL_BUILTIN.
+#ifdef OPENSSL_INIT_ENGINE_ALL_BUILTIN
   // Initialize ciphers and random engines
   if (!OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN | OPENSSL_INIT_ADD_ALL_CIPHERS,
                            NULL)) {
     throw ParquetException("OpenSSL initialization failed");
   }
+#endif
 }
 
 }  // namespace parquet::encryption::openssl

From 547b2406d71bf9ad14e2bcc7064c6923165dd737 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Fri, 27 Oct 2023 11:01:19 -0400
Subject: [PATCH 643/749] GH-38166: [MATLAB] Improve tabular object display
 (#38482)

### Rationale for this change

Currently, the display for `arrow.tabular.RecordBatch` and `arrow.tabular.Table` are not very MATLAB-like.

### What changes are included in this PR?

1. Updated the display of both `arrow.tabular.Table` and `arrow.tabular.RecordBatch`.
2. Added a new utility function `arrow.internal.display.boldFontIfPossible`
3. Renamed  `arrow.array.internal.display.pluralizeStringIfNeeded` to `arrow.internal.display.pluralizeStringIfNeeded`
4. Renamed `arrow.tabular.internal.displaySchema` to `arrow.tabular.internal.display.getSchemaString`.

**Example RecordBatch Display**

```matlab
>> t = table(1, false, datetime(2023, 1, 1), VariableNames=["Number", "Logical", "Date"]);
>> rb = arrow.recordBatch(t)

rb =

  Arrow RecordBatch with 1 row and 3 columns:

    Schema:

        Number: Float64 | Logical: Boolean | Date: Timestamp

    First Row:

        1 | false | 2023-01-01 00:00:00.000000
```

**Example Table Display**

```matlab
>> t = table(1, false, datetime(2023, 1, 1), VariableNames=["Number", "Logical", "Date"]);
>> arrowTable = arrow.table(t)

arrowTable =

  Arrow Table with 1 row and 3 columns:

    Schema:

        Number: Float64 | Logical: Boolean | Date: Timestamp

    First Row:

        1 | false | 2023-01-01 00:00:00.000000
```

### Are these changes tested?

Yes, I added a new test class in `matlab/test/arrow/tabular` called `tTabularDisplay.m`.

### Are there any user-facing changes?

Yes. Users will now see the new `Table`/`RecordBatch` display

* Closes: #38166

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+array/+internal/+display/getHeader.m     |   2 +-
 .../+internal/+display/boldFontIfPossible.m   |  26 +++
 .../+display/pluralizeStringIfNeeded.m        |   0
 .../getSchemaString.m}                        |   7 +-
 .../+internal/+display/getTabularDisplay.m    |  44 ++++++
 .../+internal/+display/getTabularHeader.m     |  32 ++++
 .../src/matlab/+arrow/+tabular/RecordBatch.m  |   4 +-
 matlab/src/matlab/+arrow/+tabular/Schema.m    |   2 +-
 matlab/src/matlab/+arrow/+tabular/Table.m     |   5 +-
 matlab/test/arrow/tabular/tTabularDisplay.m   | 148 ++++++++++++++++++
 10 files changed, 262 insertions(+), 8 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+internal/+display/boldFontIfPossible.m
 rename matlab/src/matlab/+arrow/{+array => }/+internal/+display/pluralizeStringIfNeeded.m (100%)
 rename matlab/src/matlab/+arrow/+tabular/+internal/{displaySchema.m => +display/getSchemaString.m} (92%)
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularDisplay.m
 create mode 100644 matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularHeader.m
 create mode 100644 matlab/test/arrow/tabular/tTabularDisplay.m

diff --git a/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m b/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
index 5c8704d5bf2a4..85301ddefaada 100644
--- a/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
+++ b/matlab/src/matlab/+arrow/+array/+internal/+display/getHeader.m
@@ -16,7 +16,7 @@
 % permissions and limitations under the License.
 
 function header = getHeader(className, numElements, numNulls)
-    import arrow.array.internal.display.pluralizeStringIfNeeded
+    import arrow.internal.display.pluralizeStringIfNeeded
     elementString = pluralizeStringIfNeeded(numElements, "element");
 
     nullString = pluralizeStringIfNeeded(numNulls, "null value");
diff --git a/matlab/src/matlab/+arrow/+internal/+display/boldFontIfPossible.m b/matlab/src/matlab/+arrow/+internal/+display/boldFontIfPossible.m
new file mode 100644
index 0000000000000..cb980cbff99e8
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+internal/+display/boldFontIfPossible.m
@@ -0,0 +1,26 @@
+%BOLDFONTIFPOSSIBLE Bolds the input string if possible
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function str = boldFontIfPossible(str)
+
+    arguments
+        str(1, 1) string {mustBeNonzeroLengthText}
+    end
+    if usejava("desktop")
+        str = compose("<strong>%s</strong>", str);
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m b/matlab/src/matlab/+arrow/+internal/+display/pluralizeStringIfNeeded.m
similarity index 100%
rename from matlab/src/matlab/+arrow/+array/+internal/+display/pluralizeStringIfNeeded.m
rename to matlab/src/matlab/+arrow/+internal/+display/pluralizeStringIfNeeded.m
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getSchemaString.m
similarity index 92%
rename from matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m
rename to matlab/src/matlab/+arrow/+tabular/+internal/+display/getSchemaString.m
index 8d6740b195abc..7da945ca993ef 100644
--- a/matlab/src/matlab/+arrow/+tabular/+internal/displaySchema.m
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getSchemaString.m
@@ -1,4 +1,5 @@
-%DISPLAYSCHEMA Generates arrow.tabular.Schema display text.
+%GETSCHEMASTRING Generates a string representation of an 
+% arrow.tabular.Schema object.
 
 % Licensed to the Apache Software Foundation (ASF) under one or more
 % contributor license agreements.  See the NOTICE file distributed with
@@ -15,7 +16,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-function text = displaySchema(schema)
+function text = getSchemaString(schema)
     fields = schema.Fields;
     names = [fields.Name];
     types = [fields.Type];
@@ -46,5 +47,5 @@
     end
 
     text = names + ": " + typeIDs;
-    text = "    " + strjoin(text, " | ");
+    text = strjoin(text, " | ");
 end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularDisplay.m b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularDisplay.m
new file mode 100644
index 0000000000000..054922fa03c75
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularDisplay.m
@@ -0,0 +1,44 @@
+%GETTABULARDISPLAY Generates the display for arrow.tabular.Table and
+% arrow.tabular.RecordBatch.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function tabularDisplay = getTabularDisplay(tabularObj, className)
+    import arrow.tabular.internal.display.getSchemaString
+    import arrow.tabular.internal.display.getTabularHeader
+
+    numRows = tabularObj.NumRows;
+    numColumns = tabularObj.NumColumns;
+    tabularDisplay = getTabularHeader(className, numRows, numColumns);
+
+    if numColumns > 0
+        twoNewLines = string([newline newline]);
+        fourSpaces = string(repmat(' ', 1, 4));
+        eightSpaces = string(repmat(' ', 1, 8));
+
+        schemaHeader = fourSpaces + "Schema:";
+        schemaBody =   eightSpaces + getSchemaString(tabularObj.Schema);
+        schemaDisplay = schemaHeader + twoNewLines + schemaBody;
+        tabularDisplay = tabularDisplay + twoNewLines + schemaDisplay;
+    
+        if numRows > 0
+            rowHeader = fourSpaces + "First Row:";
+            rowBody = eightSpaces + tabularObj.Proxy.getRowAsString(struct(Index=int64(1)));
+            rowDisplay = rowHeader + twoNewLines + rowBody;
+            tabularDisplay = tabularDisplay + twoNewLines + rowDisplay;
+        end
+    end
+end
diff --git a/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularHeader.m b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularHeader.m
new file mode 100644
index 0000000000000..4c647986ce055
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+tabular/+internal/+display/getTabularHeader.m
@@ -0,0 +1,32 @@
+%GETTABULARHEADER Generates the display header for arrow.tabular.Table and
+% arrow.tabular.RecordBatch.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function header = getTabularHeader(className, numRows, numColumns)
+    import arrow.internal.display.boldFontIfPossible
+    import arrow.internal.display.pluralizeStringIfNeeded
+
+    numRowsString = boldFontIfPossible(numRows);
+    numColsString = boldFontIfPossible(numColumns);
+    rowWordString = pluralizeStringIfNeeded(numRows, "row");
+    colWordString = pluralizeStringIfNeeded(numColumns, "column");
+    formatSpec = "  Arrow %s with %s %s and %s %s";
+    if numColumns > 0
+        formatSpec = formatSpec + ":";
+    end
+    header = compose(formatSpec,className, numRowsString, rowWordString, numColsString, colWordString);
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
index fdedaecb5eb3a..0225f3d771181 100644
--- a/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
+++ b/matlab/src/matlab/+arrow/+tabular/RecordBatch.m
@@ -112,7 +112,9 @@
 
     methods (Access=protected)
         function displayScalarObject(obj)
-            disp(obj.toString());
+            className = matlab.mixin.CustomDisplay.getClassNameForHeader(obj);
+            tabularDisplay = arrow.tabular.internal.display.getTabularDisplay(obj, className);
+            disp(tabularDisplay + newline);
         end
     end
 
diff --git a/matlab/src/matlab/+arrow/+tabular/Schema.m b/matlab/src/matlab/+arrow/+tabular/Schema.m
index 3ee40f0e14293..a50522c6b5283 100644
--- a/matlab/src/matlab/+arrow/+tabular/Schema.m
+++ b/matlab/src/matlab/+arrow/+tabular/Schema.m
@@ -116,7 +116,7 @@ function displayScalarObject(obj)
             numFields = obj.NumFields;
 
             if numFields > 0
-                text = arrow.tabular.internal.displaySchema(obj);
+                text = "    " + arrow.tabular.internal.display.getSchemaString(obj);
                 disp(text + newline);
             end
 
diff --git a/matlab/src/matlab/+arrow/+tabular/Table.m b/matlab/src/matlab/+arrow/+tabular/Table.m
index c2f73450408ef..1ed205d639747 100644
--- a/matlab/src/matlab/+arrow/+tabular/Table.m
+++ b/matlab/src/matlab/+arrow/+tabular/Table.m
@@ -112,9 +112,10 @@
     end
 
     methods (Access=protected)
-
         function displayScalarObject(obj)
-            disp(obj.toString());
+            className = matlab.mixin.CustomDisplay.getClassNameForHeader(obj);
+            tabularDisplay = arrow.tabular.internal.display.getTabularDisplay(obj, className);
+            disp(tabularDisplay + newline);
         end
 
     end
diff --git a/matlab/test/arrow/tabular/tTabularDisplay.m b/matlab/test/arrow/tabular/tTabularDisplay.m
new file mode 100644
index 0000000000000..f99b25ab3452f
--- /dev/null
+++ b/matlab/test/arrow/tabular/tTabularDisplay.m
@@ -0,0 +1,148 @@
+%TTABULARDISPLAY Unit tests verifying the display of arrow.tabular.Table
+%and arrow.tabular.RecordBatch objects.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTabularDisplay < matlab.unittest.TestCase
+
+    properties (TestParameter)
+        TabularType
+    end
+
+    methods (TestParameterDefinition, Static)
+        function TabularType = initializeTabularType()
+
+            tableStruct = struct(FullClassName="arrow.tabular.Table", ...
+                ClassName="Table", FromTableFcn = @arrow.table);
+            
+            recordBatchStruct = struct(FullClassName="arrow.tabular.RecordBatch", ...
+                ClassName="RecordBatch", FromTableFcn=@arrow.recordBatch);
+
+            TabularType = struct(Table=tableStruct, RecordBatch=recordBatchStruct);
+        end
+
+    end
+
+    methods (Test)
+
+        function ZeroRowsZeroColumns(testCase, TabularType)
+            % Verify tabular object display when the object has zero rows
+            % and zero columns.
+            import arrow.internal.test.display.makeLinkString
+            
+            tabularObj = TabularType.FromTableFcn(table); %#ok<NASGU>
+            
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            zeroString = getNumString(0);
+            header = compose("  Arrow %s with %s rows and %s columns", classNameString, zeroString, zeroString);
+            expectedDisplay = char(header + newline + newline);
+            actualDisplay = evalc('disp(tabularObj)');
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function ZeroRowsOneColumn(testCase, TabularType)
+            % Verify tabular object display when the object has zero rows
+            % and one column.
+            import arrow.internal.test.display.makeLinkString
+            
+            t = table(1, VariableNames="Number");
+            tabularObj = TabularType.FromTableFcn(t(1:0, :)); %#ok<NASGU>
+            
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s column:", classNameString, getNumString(0), getNumString(1));
+            
+            fieldString = makeFieldString("Number", "Float64", "arrow.type.Float64Type");
+            schema = join(["    Schema:" "        " + fieldString], [newline newline]);
+            
+            expectedDisplay = char(join([header schema + newline + newline], [newline newline]));
+            actualDisplay = evalc('disp(tabularObj)');
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function OneRowOneColumn(testCase, TabularType)
+            % Verify tabular object display when the object has one row
+            % and column.
+            import arrow.internal.test.display.makeLinkString
+            
+            t = table(1, VariableNames="Number");
+            tabularObj = TabularType.FromTableFcn(t); %#ok<NASGU>
+            
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s row and %s column:", classNameString, getNumString(1), getNumString(1));
+            
+            fieldString = makeFieldString("Number", "Float64", "arrow.type.Float64Type");
+            schema = join(["    Schema:" "        " + fieldString], [newline newline]);
+            row = join(["    First Row:"  "        1"], [newline newline]);
+
+            
+            expectedDisplay = char(join([header schema row + newline + newline], [newline newline]));
+            actualDisplay = evalc('disp(tabularObj)');
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function ManyRowsAndColumns(testCase, TabularType)
+            % Verify tabular object display when the object has many rows
+            % and columns.
+            import arrow.internal.test.display.makeLinkString
+            
+            t = table((1:2)', ["A"; "B"], true(2, 1), VariableNames=["Number", "Letter", "Logical"]);
+            tabularObj = TabularType.FromTableFcn(t); %#ok<NASGU>
+            
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(2), getNumString(3));
+            
+            fieldOneString = makeFieldString("Number", "Float64", "arrow.type.Float64Type");
+            fieldTwoString = makeFieldString("Letter", "String", "arrow.type.StringType");
+            fieldThreeString = makeFieldString("Logical", "Boolean", "arrow.type.BooleanType");
+
+            fields = join([fieldOneString fieldTwoString fieldThreeString], " | ");
+            schema = join(["    Schema:" "        " + fields], [newline newline]);
+            row = join(["    First Row:"  "        1 | ""A"" | true"], [newline newline]);
+            
+            expectedDisplay = char(join([header schema row + newline + newline], [newline newline]));
+            actualDisplay = evalc('disp(tabularObj)');
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+    end
+end
+
+function numString = getNumString(num)
+    if usejava("desktop")
+        numString = compose("<strong>%d</strong>", num);
+    else
+        numString = compose("%d", num);
+    end
+end
+
+function str = makeFieldString(fieldName, classType, fullClassType)
+    import arrow.internal.test.display.makeLinkString
+
+    if usejava("desktop")
+        name = compose("<strong>%s</strong>:", fieldName);
+        typeStr = makeLinkString(FullClassName=fullClassType, ClassName=classType, BoldFont=true);
+        str = name + " " + typeStr;
+    else
+        str = fieldName + ": " + classType;
+    end
+end
\ No newline at end of file

From 848725f31b2633a35a0389e4ffb96e1c14bc8e26 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 27 Oct 2023 16:29:30 -0400
Subject: [PATCH 644/749] MINOR: [Go] Bump google.golang.org/grpc from 1.58.2
 to 1.58.3 in /go (#38468)

Bumps [google.golang.org/grpc](https://github.com/grpc/grpc-go) from 1.58.2 to 1.58.3.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-go/releases">google.golang.org/grpc's releases</a>.</em></p>
<blockquote>
<h2>Release 1.58.3</h2>
<h1>Security</h1>
<ul>
<li>
<p>server: prohibit more than MaxConcurrentStreams handlers from running at once (CVE-2023-44487)</p>
<p>In addition to this change, applications should ensure they do not leave running tasks behind related to the RPC before returning from method handlers, or should enforce appropriate limits on any such work.</p>
</li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-go/commit/bf05b9558c16677e362d231120f8213eb276d406"><code>bf05b95</code></a> Change version.go to v1.58.3 (<a href="https://redirect.github.com/grpc/grpc-go/issues/6707">#6707</a>)</li>
<li><a href="https://github.com/grpc/grpc-go/commit/c40c9ba315aaaa58eb4dc74ba9d8bbc5058f1dfa"><code>c40c9ba</code></a> server: prohibit more than MaxConcurrentStreams handlers from running at once...</li>
<li><a href="https://github.com/grpc/grpc-go/commit/dd9270d663c346b82341f7f51c4cded2bba5a653"><code>dd9270d</code></a> update version to 1.58.3-dev (<a href="https://redirect.github.com/grpc/grpc-go/issues/6656">#6656</a>)</li>
<li>See full diff in <a href="https://github.com/grpc/grpc-go/compare/v1.58.2...v1.58.3">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=google.golang.org/grpc&package-manager=go_modules&previous-version=1.58.2&new-version=1.58.3)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
You can disable automated security fix PRs for this repo from the [Security Alerts page](https://github.com/apache/arrow/network/alerts).

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/go.mod | 2 +-
 go/go.sum | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/go/go.mod b/go/go.mod
index bf685eef910ed..de73c210d159d 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -40,7 +40,7 @@ require (
 	golang.org/x/tools v0.14.0
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
 	gonum.org/v1/gonum v0.12.0
-	google.golang.org/grpc v1.58.2
+	google.golang.org/grpc v1.58.3
 	google.golang.org/protobuf v1.31.0
 	modernc.org/sqlite v1.21.2
 )
diff --git a/go/go.sum b/go/go.sum
index d1e8884e7a2f6..bdd499c3f5190 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -107,8 +107,8 @@ gonum.org/v1/gonum v0.12.0 h1:xKuo6hzt+gMav00meVPUlXwSdoEJP46BR+wdxQEFK2o=
 gonum.org/v1/gonum v0.12.0/go.mod h1:73TDxJfAAHeA8Mk9mf8NlIppyhQNo5GLTcYeqgo2lvY=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 h1:6GQBEOdGkX6MMTLT9V+TjtIRZCw9VPD5Z+yHY9wMgS0=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY=
-google.golang.org/grpc v1.58.2 h1:SXUpjxeVF3FKrTYQI4f4KvbGD5u2xccdYdurwowix5I=
-google.golang.org/grpc v1.58.2/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
+google.golang.org/grpc v1.58.3 h1:BjnpXut1btbtgN/6sp+brB2Kbm2LjNXnidYujAVbSoQ=
+google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=

From b587a3d14f229945f243ed22bdd2d11ef2825ea9 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 27 Oct 2023 14:18:57 -0700
Subject: [PATCH 645/749] MINOR: [Java] Update installation documentation for
 BOM file (#38475)

Update the installation documentation to describe how to use the bill of materials module.

### Rationale for this change
Add information to get users to use the bill of materials file.

### What changes are included in this PR?
Provide an example of including the bill of materials dependency.

### Are these changes tested?
N/A

### Are there any user-facing changes?
Documentation

Lead-authored-by: James Duong <duong.james@gmail.com>
Co-authored-by: James Duong <james.duong@improving.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/install.rst | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/docs/source/java/install.rst b/docs/source/java/install.rst
index 47e91fb39ec7b..32c121573a692 100644
--- a/docs/source/java/install.rst
+++ b/docs/source/java/install.rst
@@ -83,6 +83,40 @@ arrow-vector, and arrow-memory-netty.
         </dependencies>
     </project>
 
+A bill of materials (BOM) module has been provided to simplify adding
+Arrow modules. This eliminates the need to specify the version for
+every module. An alternative to the above would be:
+
+.. code-block:: xml
+
+    <?xml version="1.0" encoding="UTF-8"?>
+    <project xmlns="http://maven.apache.org/POM/4.0.0"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+        <modelVersion>4.0.0</modelVersion>
+        <groupId>org.example</groupId>
+        <artifactId>demo</artifactId>
+        <version>1.0-SNAPSHOT</version>
+        <properties>
+            <arrow.version>15.0.0</arrow.version>
+        </properties>
+        <dependencies>
+            <dependency>
+                <groupId>org.apache.arrow</groupId>
+                <artifactId>arrow-bom</artifactId>
+                <version>${arrow.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.arrow</groupId>
+                <artifactId>arrow-vector</artifactId>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.arrow</groupId>
+                <artifactId>arrow-memory-netty</artifactId>
+            </dependency>
+        </dependencies>
+    </project>
+
 To use the Arrow Flight dependencies, also add the ``os-maven-plugin``
 plugin. This plugin generates useful platform-dependent properties
 such as ``os.detected.name`` and ``os.detected.arch`` needed to resolve

From 09d6ca747cb9f247a15268cfd04fa6aeb89c3f12 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Fri, 27 Oct 2023 14:36:45 -0700
Subject: [PATCH 646/749] GH-14936: [Java] Remove netty dependency from
 arrow-vector (#38493)

### Rationale for this change
This removes Netty from core Arrow modules that do not have net code (aside from tests).

### What changes are included in this PR?
* Change use of IntObjectHashMap to come from Eclipse instead of Netty-common to remove the dependency on Netty from arrow-vector.
* Add test cases for MapWithOrdinal.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.

* Closes: #14936

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/vector/pom.xml                           |  9 +-
 .../arrow/vector/util/MapWithOrdinalImpl.java | 10 +-
 .../vector/util/MultiMapWithOrdinal.java      |  2 +-
 .../arrow/vector/util/TestMapWithOrdinal.java | 97 +++++++++++++++++++
 4 files changed, 105 insertions(+), 13 deletions(-)
 create mode 100644 java/vector/src/test/java/org/apache/arrow/vector/util/TestMapWithOrdinal.java

diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index 015d089e9d028..98d7e02126a98 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -61,10 +61,6 @@
       <artifactId>arrow-memory-unsafe</artifactId>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-common</artifactId>
-    </dependency>
     <dependency>
       <groupId>com.google.flatbuffers</groupId>
       <artifactId>flatbuffers-java</artifactId>
@@ -74,6 +70,11 @@
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.eclipse.collections</groupId>
+      <artifactId>eclipse-collections</artifactId>
+      <version>11.1.0</version>
+    </dependency>
   </dependencies>
 
   <pluginRepositories>
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/MapWithOrdinalImpl.java b/java/vector/src/main/java/org/apache/arrow/vector/util/MapWithOrdinalImpl.java
index 3612d677ed5a9..7c9c0e9408860 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/MapWithOrdinalImpl.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/MapWithOrdinalImpl.java
@@ -25,15 +25,11 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
-import java.util.stream.StreamSupport;
 
-import org.apache.arrow.util.Preconditions;
+import org.eclipse.collections.impl.map.mutable.primitive.IntObjectHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import io.netty.util.collection.IntObjectHashMap;
-import io.netty.util.collection.IntObjectMap;
-
 /**
  * An implementation of map that supports constant time look-up by a generic key or an ordinal.
  *
@@ -133,9 +129,7 @@ public Set<K> keySet() {
 
     @Override
     public Collection<V> values() {
-      return StreamSupport.stream(secondary.entries().spliterator(), false)
-          .map((IntObjectMap.PrimitiveEntry<V> t) -> Preconditions.checkNotNull(t).value())
-          .collect(Collectors.toList());
+      return secondary.values();
     }
 
     @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/util/MultiMapWithOrdinal.java b/java/vector/src/main/java/org/apache/arrow/vector/util/MultiMapWithOrdinal.java
index 5fbb45a7ac6ac..f722a8a86772c 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/util/MultiMapWithOrdinal.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/util/MultiMapWithOrdinal.java
@@ -25,7 +25,7 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 
-import io.netty.util.collection.IntObjectHashMap;
+import org.eclipse.collections.impl.map.mutable.primitive.IntObjectHashMap;
 
 /**
  * An implementation of a multimap that supports constant time look-up by a generic key or an ordinal.
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/util/TestMapWithOrdinal.java b/java/vector/src/test/java/org/apache/arrow/vector/util/TestMapWithOrdinal.java
new file mode 100644
index 0000000000000..edd5221faf268
--- /dev/null
+++ b/java/vector/src/test/java/org/apache/arrow/vector/util/TestMapWithOrdinal.java
@@ -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.
+ */
+
+package org.apache.arrow.vector.util;
+
+import static junit.framework.TestCase.assertNull;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class TestMapWithOrdinal {
+
+  private MapWithOrdinal<String, String> map;
+
+  @Before
+  public void setUp() {
+    map = new MapWithOrdinalImpl<>();
+  }
+
+  @Test
+  public void testGetByOrdinal() {
+    map.put("key0", "val0", true);
+    assertEquals("val0", map.getByOrdinal(0));
+
+    map.put("key1", "val1", true);
+    assertEquals("val1", map.getByOrdinal(1));
+    assertEquals("val0", map.getByOrdinal(0));
+  }
+
+  @Test
+  public void testGetByKey() {
+    map.put("key0", "val0", true);
+    assertEquals("val0", map.get("key0"));
+
+    map.put("key1", "val1", true);
+    assertEquals("val1", map.get("key1"));
+    assertEquals("val0", map.get("key0"));
+  }
+
+  @Test
+  public void testInvalidOrdinal() {
+    map.put("key0", "val0", true);
+    assertNull(map.getByOrdinal(1));
+
+    map.removeAll("key0");
+    assertNull(map.getByOrdinal(0));
+  }
+
+  @Test
+  public void testInvalidKey() {
+    MapWithOrdinalImpl<String, String> map = new MapWithOrdinalImpl<>();
+    map.put("key0", "val0", true);
+    assertNull(map.get("fake_key"));
+
+    map.removeAll("key0");
+    assertNull(map.get("key0"));
+  }
+
+  @Test
+  public void testValues() {
+    map.put("key0", "val0", true);
+    map.put("key1", "val1", true);
+
+    Collection<String> values = map.values();
+    assertTrue(values.contains("val0"));
+    assertTrue(values.contains("val1"));
+
+    map.put("key1", "new_val1", true);
+    values = map.values();
+    assertTrue(values.contains("val0"));
+    assertTrue(values.contains("new_val1"));
+    assertFalse(values.contains("val1"));
+
+    map.removeAll("key0");
+    assertTrue(values.contains("new_val1"));
+    assertFalse(values.contains("val0"));
+  }
+}

From 1633f8d0284bfefa2e50bbd1378c46acfbc5ceab Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Fri, 27 Oct 2023 15:13:33 -0700
Subject: [PATCH 647/749] GH-38351: [C#] Add SqlDecimal support to
 Decimal128Array (#38481)

### What changes are included in this PR?

Adds support for reading and writing System.Data.SqlTypes.SqlDecimal against Decimal128Array.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Adds functions to the API.
* Closes: #38351

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Curt Hagenlocher <curt@hagenlocher.org>
---
 .../Apache.Arrow/Arrays/Decimal128Array.cs    |  40 +++++
 csharp/src/Apache.Arrow/DecimalUtility.cs     |  49 ++++++
 .../Decimal128ArrayTests.cs                   | 139 +++++++++++++++++-
 .../Apache.Arrow.Tests/DecimalUtilityTests.cs |  61 +++++++-
 4 files changed, 278 insertions(+), 11 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs b/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
index 128e9e5f0818e..7b147f5124c1d 100644
--- a/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
@@ -15,6 +15,9 @@
 
 using System;
 using System.Collections.Generic;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+#endif
 using System.Diagnostics;
 using System.Numerics;
 using Apache.Arrow.Arrays;
@@ -61,6 +64,31 @@ public Builder AppendRange(IEnumerable<decimal> values)
                 return Instance;
             }
 
+#if !NETSTANDARD1_3
+            public Builder Append(SqlDecimal value)
+            {
+                Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
+                DecimalUtility.GetBytes(value, DataType.Precision, DataType.Scale, bytes);
+
+                return Append(bytes);
+            }
+
+            public Builder AppendRange(IEnumerable<SqlDecimal> values)
+            {
+                if (values == null)
+                {
+                    throw new ArgumentNullException(nameof(values));
+                }
+
+                foreach (SqlDecimal d in values)
+                {
+                    Append(d);
+                }
+
+                return Instance;
+            }
+#endif
+
             public Builder Set(int index, decimal value)
             {
                 Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
@@ -91,5 +119,17 @@ public Decimal128Array(ArrayData data)
             }
             return DecimalUtility.GetDecimal(ValueBuffer, index, Scale, ByteWidth);
         }
+
+#if !NETSTANDARD1_3
+        public SqlDecimal? GetSqlDecimal(int index)
+        {
+            if (IsNull(index))
+            {
+                return null;
+            }
+
+            return DecimalUtility.GetSqlDecimal128(ValueBuffer, index, Precision, Scale);
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/DecimalUtility.cs b/csharp/src/Apache.Arrow/DecimalUtility.cs
index 4a29d068c6eff..35e56ff65e2ed 100644
--- a/csharp/src/Apache.Arrow/DecimalUtility.cs
+++ b/csharp/src/Apache.Arrow/DecimalUtility.cs
@@ -14,6 +14,9 @@
 // limitations under the License.
 
 using System;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+#endif
 using System.Numerics;
 
 namespace Apache.Arrow
@@ -73,6 +76,32 @@ internal static decimal GetDecimal(in ArrowBuffer valueBuffer, int index, int sc
             }
         }
 
+#if !NETSTANDARD1_3
+        internal static SqlDecimal GetSqlDecimal128(in ArrowBuffer valueBuffer, int index, int precision, int scale)
+        {
+            const int byteWidth = 16;
+            const int intWidth = byteWidth / 4;
+            const int longWidth = byteWidth / 8;
+
+            byte mostSignificantByte = valueBuffer.Span[(index + 1) * byteWidth - 1];
+            bool isPositive = (mostSignificantByte & 0x80) == 0;
+
+            if (isPositive)
+            {
+                ReadOnlySpan<int> value = valueBuffer.Span.CastTo<int>().Slice(index * intWidth, intWidth);
+                return new SqlDecimal((byte)precision, (byte)scale, true, value[0], value[1], value[2], value[3]);
+            }
+            else
+            {
+                ReadOnlySpan<long> value = valueBuffer.Span.CastTo<long>().Slice(index * longWidth, longWidth);
+                long data1 = -value[0];
+                long data2 = (data1 == 0) ? -value[1] : ~value[1];
+
+                return new SqlDecimal((byte)precision, (byte)scale, false, (int)(data1 & 0xffffffff), (int)(data1 >> 32), (int)(data2 & 0xffffffff), (int)(data2 >> 32));
+            }
+        }
+#endif
+
         private static decimal DivideByScale(BigInteger integerValue, int scale)
         {
             decimal result = (decimal)integerValue; // this cast is safe here
@@ -169,5 +198,25 @@ internal static void GetBytes(decimal value, int precision, int scale, int byteW
                 }
             }
         }
+
+#if !NETSTANDARD1_3
+        internal static void GetBytes(SqlDecimal value, int precision, int scale, Span<byte> bytes)
+        {
+            if (value.Precision != precision || value.Scale != scale)
+            {
+                value = SqlDecimal.ConvertToPrecScale(value, precision, scale);
+            }
+
+            // TODO: Consider groveling in the internals to avoid the probable allocation
+            Span<int> span = bytes.CastTo<int>();
+            value.Data.AsSpan().CopyTo(span);
+            if (!value.IsPositive)
+            {
+                Span<long> longSpan = bytes.CastTo<long>();
+                longSpan[0] = -longSpan[0];
+                longSpan[1] = (longSpan[0] == 0) ? -longSpan[1] : ~longSpan[1];
+            }
+        }
+#endif
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs b/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
index 4c4e6537269a4..8d7adfef42b54 100644
--- a/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
@@ -14,7 +14,9 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+#endif
 using Apache.Arrow.Types;
 using Xunit;
 
@@ -22,6 +24,18 @@ namespace Apache.Arrow.Tests
 {
     public class Decimal128ArrayTests
     {
+#if !NETSTANDARD1_3
+        static SqlDecimal? Convert(decimal? value)
+        {
+            return value == null ? null : new SqlDecimal(value.Value);
+        }
+
+        static decimal? Convert(SqlDecimal? value)
+        {
+            return value == null ? null : value.Value.Value;
+        }
+#endif
+
         public class Builder
         {
             public class AppendNull
@@ -30,7 +44,7 @@ public class AppendNull
                 public void AppendThenGetGivesNull()
                 {
                     // Arrange
-                    var builder = new Decimal128Array.Builder(new Decimal128Type(8,2));
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(8, 2));
 
                     // Act
 
@@ -45,6 +59,12 @@ public void AppendThenGetGivesNull()
                     Assert.Null(array.GetValue(0));
                     Assert.Null(array.GetValue(1));
                     Assert.Null(array.GetValue(2));
+
+#if !NETSTANDARD1_3
+                    Assert.Null(array.GetSqlDecimal(0));
+                    Assert.Null(array.GetSqlDecimal(1));
+                    Assert.Null(array.GetSqlDecimal(2));
+#endif
                 }
             }
 
@@ -67,7 +87,7 @@ public void AppendDecimal(int count)
                             testData[i] = null;
                             continue;
                         }
-                        decimal rnd = i * (decimal)Math.Round(new Random().NextDouble(),10);
+                        decimal rnd = i * (decimal)Math.Round(new Random().NextDouble(), 10);
                         testData[i] = rnd;
                         builder.Append(rnd);
                     }
@@ -78,6 +98,9 @@ public void AppendDecimal(int count)
                     for (int i = 0; i < count; i++)
                     {
                         Assert.Equal(testData[i], array.GetValue(i));
+#if !NETSTANDARD1_3
+                        Assert.Equal(Convert(testData[i]), array.GetSqlDecimal(i));
+#endif
                     }
                 }
 
@@ -95,6 +118,11 @@ public void AppendLargeDecimal()
                     var array = builder.Build();
                     Assert.Equal(large, array.GetValue(0));
                     Assert.Equal(-large, array.GetValue(1));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(large), array.GetSqlDecimal(0));
+                    Assert.Equal(Convert(-large), array.GetSqlDecimal(1));
+#endif
                 }
 
                 [Fact]
@@ -115,6 +143,13 @@ public void AppendMaxAndMinDecimal()
                     Assert.Equal(Decimal.MinValue, array.GetValue(1));
                     Assert.Equal(Decimal.MaxValue - 10, array.GetValue(2));
                     Assert.Equal(Decimal.MinValue + 10, array.GetValue(3));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(Decimal.MaxValue), array.GetSqlDecimal(0));
+                    Assert.Equal(Convert(Decimal.MinValue), array.GetSqlDecimal(1));
+                    Assert.Equal(Convert(Decimal.MaxValue) - 10, array.GetSqlDecimal(2));
+                    Assert.Equal(Convert(Decimal.MinValue) + 10, array.GetSqlDecimal(3));
+#endif
                 }
 
                 [Fact]
@@ -131,6 +166,11 @@ public void AppendFractionalDecimal()
                     var array = builder.Build();
                     Assert.Equal(fraction, array.GetValue(0));
                     Assert.Equal(-fraction, array.GetValue(1));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(fraction), array.GetSqlDecimal(0));
+                    Assert.Equal(Convert(-fraction), array.GetSqlDecimal(1));
+#endif
                 }
 
                 [Fact]
@@ -138,7 +178,7 @@ public void AppendRangeDecimal()
                 {
                     // Arrange
                     var builder = new Decimal128Array.Builder(new Decimal128Type(24, 8));
-                    var range = new decimal[] {2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M};
+                    var range = new decimal[] { 2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M };
 
                     // Act
                     builder.AppendRange(range);
@@ -146,12 +186,15 @@ public void AppendRangeDecimal()
 
                     // Assert
                     var array = builder.Build();
-                    for(int i = 0; i < range.Length; i ++)
+                    for (int i = 0; i < range.Length; i++)
                     {
                         Assert.Equal(range[i], array.GetValue(i));
+#if !NETSTANDARD1_3
+                        Assert.Equal(Convert(range[i]), array.GetSqlDecimal(i));
+#endif
                     }
-                    
-                    Assert.Null( array.GetValue(range.Length));
+
+                    Assert.Null(array.GetValue(range.Length));
                 }
 
                 [Fact]
@@ -159,7 +202,7 @@ public void AppendClearAppendDecimal()
                 {
                     // Arrange
                     var builder = new Decimal128Array.Builder(new Decimal128Type(24, 8));
-                    
+
                     // Act
                     builder.Append(1);
                     builder.Clear();
@@ -256,6 +299,86 @@ public void SwapNull()
                     Assert.Equal(123.456M, array.GetValue(1));
                 }
             }
+
+#if !NETSTANDARD1_3
+            public class SqlDecimals
+            {
+                [Theory]
+                [InlineData(200)]
+                public void AppendSqlDecimal(int count)
+                {
+                    // Arrange
+                    const int precision = 10;
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(14, precision));
+
+                    // Act
+                    SqlDecimal?[] testData = new SqlDecimal?[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (i == count - 2)
+                        {
+                            builder.AppendNull();
+                            testData[i] = null;
+                            continue;
+                        }
+                        SqlDecimal rnd = i * (SqlDecimal)Math.Round(new Random().NextDouble(), 10);
+                        builder.Append(rnd);
+                        testData[i] = SqlDecimal.Round(rnd, precision);
+                    }
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(count, array.Length);
+                    for (int i = 0; i < count; i++)
+                    {
+                        Assert.Equal(testData[i], array.GetSqlDecimal(i));
+                        Assert.Equal(Convert(testData[i]), array.GetValue(i));
+                    }
+                }
+
+                [Fact]
+                public void AppendMaxAndMinSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(38, 0));
+
+                    // Act
+                    builder.Append(SqlDecimal.MaxValue);
+                    builder.Append(SqlDecimal.MinValue);
+                    builder.Append(SqlDecimal.MaxValue - 10);
+                    builder.Append(SqlDecimal.MinValue + 10);
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(SqlDecimal.MaxValue, array.GetSqlDecimal(0));
+                    Assert.Equal(SqlDecimal.MinValue, array.GetSqlDecimal(1));
+                    Assert.Equal(SqlDecimal.MaxValue - 10, array.GetSqlDecimal(2));
+                    Assert.Equal(SqlDecimal.MinValue + 10, array.GetSqlDecimal(3));
+                }
+
+                [Fact]
+                public void AppendRangeSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(24, 8));
+                    var range = new SqlDecimal[] { 2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M };
+
+                    // Act
+                    builder.AppendRange(range);
+                    builder.AppendNull();
+
+                    // Assert
+                    var array = builder.Build();
+                    for (int i = 0; i < range.Length; i++)
+                    {
+                        Assert.Equal(range[i], array.GetSqlDecimal(i));
+                        Assert.Equal(Convert(range[i]), array.GetValue(i));
+                    }
+
+                    Assert.Null(array.GetValue(range.Length));
+                }
+            }
+#endif
         }
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
index 9c7e5b587cb9d..dd5f7b9d3f67f 100644
--- a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
@@ -14,6 +14,9 @@
 // limitations under the License.
 
 using System;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+#endif
 using Apache.Arrow.Types;
 using Xunit;
 
@@ -31,13 +34,13 @@ public class Overflow
             [InlineData(100.123, 5, 2, true)]
             [InlineData(100.123, 5, 3, true)]
             [InlineData(100.123, 6, 3, false)]
-            public void HasExpectedResultOrThrows(decimal d, int precision , int scale, bool shouldThrow)
+            public void HasExpectedResultOrThrows(decimal d, int precision, int scale, bool shouldThrow)
             {
                 var builder = new Decimal128Array.Builder(new Decimal128Type(precision, scale));
 
                 if (shouldThrow)
                 {
-                   Assert.Throws<OverflowException>(() => builder.Append(d));
+                    Assert.Throws<OverflowException>(() => builder.Append(d));
                 }
                 else
                 {
@@ -55,7 +58,7 @@ public void Decimal256HasExpectedResultOrThrows(decimal d, int precision, int sc
                 var builder = new Decimal256Array.Builder(new Decimal256Type(precision, scale));
                 builder.Append(d);
                 Decimal256Array result = builder.Build(new TestMemoryAllocator()); ;
-                
+
                 if (shouldThrow)
                 {
                     Assert.Throws<OverflowException>(() => result.GetValue(0));
@@ -66,5 +69,57 @@ public void Decimal256HasExpectedResultOrThrows(decimal d, int precision, int sc
                 }
             }
         }
+
+        public class SqlDecimals
+        {
+
+#if !NETSTANDARD1_3
+            [Fact]
+            public void NegativeSqlDecimal()
+            {
+                const int precision = 38;
+                const int scale = 0;
+                const int bitWidth = 16;
+
+                var negative = new SqlDecimal(precision, scale, false, 0, 0, 1, 0);
+                var bytes = new byte[16];
+                DecimalUtility.GetBytes(negative.Value, precision, scale, bitWidth, bytes);
+                var sqlNegative = DecimalUtility.GetSqlDecimal128(new ArrowBuffer(bytes), 0, precision, scale);
+                Assert.Equal(negative, sqlNegative);
+
+                DecimalUtility.GetBytes(sqlNegative, precision, scale, bytes);
+                var decimalNegative = DecimalUtility.GetDecimal(new ArrowBuffer(bytes), 0, scale, bitWidth);
+                Assert.Equal(negative.Value, decimalNegative);
+            }
+
+            [Fact]
+            public void LargeScale()
+            {
+                string digits = "1.2345678901234567890123456789012345678";
+
+                var positive = SqlDecimal.Parse(digits);
+                Assert.Equal(38, positive.Precision);
+                Assert.Equal(37, positive.Scale);
+
+                var bytes = new byte[16];
+                DecimalUtility.GetBytes(positive, positive.Precision, positive.Scale, bytes);
+                var sqlPositive = DecimalUtility.GetSqlDecimal128(new ArrowBuffer(bytes), 0, positive.Precision, positive.Scale);
+
+                Assert.Equal(positive, sqlPositive);
+                Assert.Equal(digits, sqlPositive.ToString());
+
+                digits = "-" + digits;
+                var negative = SqlDecimal.Parse(digits);
+                Assert.Equal(38, positive.Precision);
+                Assert.Equal(37, positive.Scale);
+
+                DecimalUtility.GetBytes(negative, negative.Precision, negative.Scale, bytes);
+                var sqlNegative = DecimalUtility.GetSqlDecimal128(new ArrowBuffer(bytes), 0, negative.Precision, negative.Scale);
+
+                Assert.Equal(negative, sqlNegative);
+                Assert.Equal(digits, sqlNegative.ToString());
+            }
+#endif
+        }
     }
 }

From 7ef517e31ec3d146679cde98bb259e6e2b7aa9b8 Mon Sep 17 00:00:00 2001
From: Tsutomu Katsube <tsuto.katsube@gmail.com>
Date: Sat, 28 Oct 2023 15:04:02 +0900
Subject: [PATCH 648/749] MINOR: [GLib][Docs] Specify downloaded archive name
 explicitly (#38497)

### Rationale for this change

Unable to extract on the [arrow/c_glib/README.md](https://github.com/apache/arrow/blob/848725f31b2633a35a0389e4ffb96e1c14bc8e26/c_glib/README.md?plain=1#L70-L71) because the downloaded file name is `closer.lua?action=download&filename=arrow%2Farrow-12.0.0%2Fapache-arrow-12.0.0.tar.gz` not `apache-arrow-12.0.0.tar.gz`.

### What changes are included in this PR?

Specify the downloaded file name explicitly.

Authored-by: Tsutomu Katsube <tsuto.katsube@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/c_glib/README.md b/c_glib/README.md
index 23e3bd91b8a2a..5ff38d3a4d6e6 100644
--- a/c_glib/README.md
+++ b/c_glib/README.md
@@ -67,7 +67,8 @@ GLib (replace the version number in the following commands with the
 one you use):
 
 ```console
-$ wget 'https://www.apache.org/dyn/closer.lua?action=download&filename=arrow/arrow-12.0.0/apache-arrow-12.0.0.tar.gz'
+$ wget 'https://www.apache.org/dyn/closer.lua?action=download&filename=arrow/arrow-12.0.0/apache-arrow-12.0.0.tar.gz' \
+    --output-document apache-arrow-12.0.0.tar.gz
 $ tar xf apache-arrow-12.0.0.tar.gz
 $ cd apache-arrow-12.0.0
 ```

From 2628d495ca99a892dca50019f4e72f087dc5aac7 Mon Sep 17 00:00:00 2001
From: Curt Hagenlocher <curt@hagenlocher.org>
Date: Mon, 30 Oct 2023 07:00:52 -0700
Subject: [PATCH 649/749] GH-38483: [C#] Add support for more decimal
 conversions (#38508)

### What changes are included in this PR?

Adds support for decimal128 <-> string and decimal256 <-> string.
Adds support for decimal256 <-> SqlDecimal.

### Are these changes tested?

Yes

### Are there any user-facing changes?

APIs have been added to support these conversions.
* Closes: #38483

Authored-by: Curt Hagenlocher <curt@hagenlocher.org>
Signed-off-by: Curt Hagenlocher <curt@hagenlocher.org>
---
 .../Apache.Arrow/Arrays/Decimal128Array.cs    |  40 +++
 .../Apache.Arrow/Arrays/Decimal256Array.cs    |  98 +++++++-
 csharp/src/Apache.Arrow/DecimalUtility.cs     | 229 ++++++++++++++++++
 .../Decimal128ArrayTests.cs                   |  89 +++++++
 .../Decimal256ArrayTests.cs                   | 223 ++++++++++++++++-
 .../Apache.Arrow.Tests/DecimalUtilityTests.cs |  85 +++++++
 6 files changed, 761 insertions(+), 3 deletions(-)

diff --git a/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs b/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
index 7b147f5124c1d..01724e2acda3e 100644
--- a/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Decimal128Array.cs
@@ -64,6 +64,37 @@ public Builder AppendRange(IEnumerable<decimal> values)
                 return Instance;
             }
 
+            public Builder Append(string value)
+            {
+                if (value == null)
+                {
+                    AppendNull();
+                }
+                else
+                {
+                    Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
+                    DecimalUtility.GetBytes(value, DataType.Precision, DataType.Scale, ByteWidth, bytes);
+                    Append(bytes);
+                }
+
+                return Instance;
+            }
+
+            public Builder AppendRange(IEnumerable<string> values)
+            {
+                if (values == null)
+                {
+                    throw new ArgumentNullException(nameof(values));
+                }
+
+                foreach (string s in values)
+                {
+                    Append(s);
+                }
+
+                return Instance;
+            }
+
 #if !NETSTANDARD1_3
             public Builder Append(SqlDecimal value)
             {
@@ -120,6 +151,15 @@ public Decimal128Array(ArrayData data)
             return DecimalUtility.GetDecimal(ValueBuffer, index, Scale, ByteWidth);
         }
 
+        public string GetString(int index)
+        {
+            if (IsNull(index))
+            {
+                return null;
+            }
+            return DecimalUtility.GetString(ValueBuffer, index, Precision, Scale, ByteWidth);
+        }
+
 #if !NETSTANDARD1_3
         public SqlDecimal? GetSqlDecimal(int index)
         {
diff --git a/csharp/src/Apache.Arrow/Arrays/Decimal256Array.cs b/csharp/src/Apache.Arrow/Arrays/Decimal256Array.cs
index fb4cd6be396e3..f314c2d6ebc9e 100644
--- a/csharp/src/Apache.Arrow/Arrays/Decimal256Array.cs
+++ b/csharp/src/Apache.Arrow/Arrays/Decimal256Array.cs
@@ -15,8 +15,10 @@
 
 using System;
 using System.Collections.Generic;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+#endif
 using System.Diagnostics;
-using System.Numerics;
 using Apache.Arrow.Arrays;
 using Apache.Arrow.Types;
 
@@ -61,6 +63,68 @@ public Builder AppendRange(IEnumerable<decimal> values)
                 return Instance;
             }
 
+            public Builder Append(string value)
+            {
+                if (value == null)
+                {
+                    AppendNull();
+                }
+                else
+                {
+                    Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
+                    DecimalUtility.GetBytes(value, DataType.Precision, DataType.Scale, ByteWidth, bytes);
+                    Append(bytes);
+                }
+
+                return Instance;
+            }
+
+            public Builder AppendRange(IEnumerable<string> values)
+            {
+                if (values == null)
+                {
+                    throw new ArgumentNullException(nameof(values));
+                }
+
+                foreach (string s in values)
+                {
+                    Append(s);
+                }
+
+                return Instance;
+            }
+
+#if !NETSTANDARD1_3
+            public Builder Append(SqlDecimal value)
+            {
+                Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
+                DecimalUtility.GetBytes(value, DataType.Precision, DataType.Scale, bytes);
+                if (!value.IsPositive)
+                {
+                    var span = bytes.CastTo<long>();
+                    span[2] = -1;
+                    span[3] = -1;
+                }
+
+                return Append(bytes);
+            }
+
+            public Builder AppendRange(IEnumerable<SqlDecimal> values)
+            {
+                if (values == null)
+                {
+                    throw new ArgumentNullException(nameof(values));
+                }
+
+                foreach (SqlDecimal d in values)
+                {
+                    Append(d);
+                }
+
+                return Instance;
+            }
+#endif
+
             public Builder Set(int index, decimal value)
             {
                 Span<byte> bytes = stackalloc byte[DataType.ByteWidth];
@@ -92,5 +156,37 @@ public Decimal256Array(ArrayData data)
 
             return DecimalUtility.GetDecimal(ValueBuffer, index, Scale, ByteWidth);
         }
+
+        public string GetString(int index)
+        {
+            if (IsNull(index))
+            {
+                return null;
+            }
+            return DecimalUtility.GetString(ValueBuffer, index, Precision, Scale, ByteWidth);
+        }
+
+#if !NETSTANDARD1_3
+        public bool TryGetSqlDecimal(int index, out SqlDecimal? value)
+        {
+            if (IsNull(index))
+            {
+                value = null;
+                return true;
+            }
+
+            const int longWidth = 4;
+            var span = ValueBuffer.Span.CastTo<long>().Slice(index * longWidth);
+            if ((span[2] == 0 && span[3] == 0) ||
+                (span[2] == -1 && span[3] == -1))
+            {
+                value = DecimalUtility.GetSqlDecimal128(ValueBuffer, 2 * index, Precision, Scale);
+                return true;
+            }
+
+            value = null;
+            return false;
+        }
+#endif
     }
 }
diff --git a/csharp/src/Apache.Arrow/DecimalUtility.cs b/csharp/src/Apache.Arrow/DecimalUtility.cs
index 35e56ff65e2ed..bb3f0834fcec3 100644
--- a/csharp/src/Apache.Arrow/DecimalUtility.cs
+++ b/csharp/src/Apache.Arrow/DecimalUtility.cs
@@ -76,6 +76,113 @@ internal static decimal GetDecimal(in ArrowBuffer valueBuffer, int index, int sc
             }
         }
 
+#if NETCOREAPP
+        internal unsafe static string GetString(in ArrowBuffer valueBuffer, int index, int precision, int scale, int byteWidth)
+        {
+            int startIndex = index * byteWidth;
+            ReadOnlySpan<byte> value = valueBuffer.Span.Slice(startIndex, byteWidth);
+            BigInteger integerValue = new BigInteger(value);
+            if (scale == 0)
+            {
+                return integerValue.ToString();
+            }
+
+            bool negative = integerValue.Sign < 0;
+            if (negative)
+            {
+                integerValue = -integerValue;
+            }
+
+            int start = scale + 3;
+            Span<char> result = stackalloc char[start + precision];
+            if (!integerValue.TryFormat(result.Slice(start), out int charsWritten) || charsWritten > precision)
+            {
+                throw new OverflowException($"Value: {integerValue} cannot be formatted");
+            }
+
+            if (scale >= charsWritten)
+            {
+                int length = charsWritten;
+                result[++length] = '0';
+                result[++length] = '.';
+                while (scale > length - 2)
+                {
+                    result[++length] = '0';
+                }
+                start = charsWritten + 1;
+                charsWritten = length;
+            }
+            else
+            {
+                result.Slice(start, charsWritten - scale).CopyTo(result.Slice(--start));
+                charsWritten++;
+                result[charsWritten + 1] = '.';
+            }
+
+            if (negative)
+            {
+                result[--start] = '-';
+                charsWritten++;
+            }
+
+            return new string(result.Slice(start, charsWritten));
+        }
+#else
+        internal unsafe static string GetString(in ArrowBuffer valueBuffer, int index, int precision, int scale, int byteWidth)
+        {
+            int startIndex = index * byteWidth;
+            ReadOnlySpan<byte> value = valueBuffer.Span.Slice(startIndex, byteWidth);
+            BigInteger integerValue = new BigInteger(value.ToArray());
+            if (scale == 0)
+            {
+                return integerValue.ToString();
+            }
+
+            bool negative = integerValue.Sign < 0;
+            if (negative)
+            {
+                integerValue = -integerValue;
+            }
+
+            string toString = integerValue.ToString();
+            int charsWritten = toString.Length;
+            if (charsWritten > precision)
+            {
+                throw new OverflowException($"Value: {integerValue} cannot be formatted");
+            }
+
+            char[] result = new char[precision + 2];
+            int pos = 0;
+            if (negative)
+            {
+                result[pos++] = '-';
+            }
+            if (scale >= charsWritten)
+            {
+                result[pos++] = '0';
+                result[pos++] = '.';
+                int length = 0;
+                while (scale > charsWritten + length)
+                {
+                    result[pos++] = '0';
+                    length++;
+                }
+                toString.CopyTo(0, result, pos, charsWritten);
+                pos += charsWritten;
+            }
+            else
+            {
+                int wholePartLength = charsWritten - scale;
+                toString.CopyTo(0, result, pos, wholePartLength);
+                pos += wholePartLength;
+                result[pos++] = '.';
+                toString.CopyTo(wholePartLength, result, pos, scale);
+                pos += scale;
+            }
+            return new string(result, 0, pos);
+        }
+#endif
+
 #if !NETSTANDARD1_3
         internal static SqlDecimal GetSqlDecimal128(in ArrowBuffer valueBuffer, int index, int precision, int scale)
         {
@@ -199,6 +306,128 @@ internal static void GetBytes(decimal value, int precision, int scale, int byteW
             }
         }
 
+        internal static void GetBytes(string value, int precision, int scale, int byteWidth, Span<byte> bytes)
+        {
+            if (value == null || value.Length == 0)
+            {
+                throw new ArgumentException("numeric value may not be null or blank", nameof(value));
+            }
+
+            int start = 0;
+            if (value[0] == '-' || value[0] == '+')
+            {
+                start++;
+            }
+            while (value[start] == '0' && start < value.Length - 1)
+            {
+                start++;
+            }
+
+            int pos = value.IndexOf('.');
+            int neededPrecision = value.Length - start;
+            int neededScale;
+            if (pos == -1)
+            {
+                neededScale = 0;
+            }
+            else
+            {
+                neededPrecision--;
+                neededScale = value.Length - pos - 1;
+            }
+
+            if (neededScale > scale)
+            {
+                throw new OverflowException($"Decimal scale cannot be greater than that in the Arrow vector: {value} has scale > {scale}");
+            }
+            if (neededPrecision > precision)
+            {
+                throw new OverflowException($"Decimal precision cannot be greater than that in the Arrow vector: {value} has precision > {precision}");
+            }
+
+#if NETCOREAPP
+            ReadOnlySpan<char> src = value.AsSpan();
+            Span<char> buffer = stackalloc char[precision + start + 1];
+
+            int end;
+            if (pos == -1)
+            {
+                src.CopyTo(buffer);
+                end = src.Length;
+            }
+            else
+            {
+                src.Slice(0, pos).CopyTo(buffer);
+                src.Slice(pos + 1).CopyTo(buffer.Slice(pos));
+                end = src.Length - 1;
+            }
+
+            while (neededScale < scale)
+            {
+                buffer[end++] = '0';
+                neededScale++;
+            }
+
+            if (!BigInteger.TryParse(buffer.Slice(0, end), out BigInteger bigInt))
+            {
+                throw new ArgumentException($"Unable to parse {value} as decimal");
+            }
+
+            if (!bigInt.TryWriteBytes(bytes, out int bytesWritten, false, !BitConverter.IsLittleEndian))
+            {
+                throw new OverflowException("Could not extract bytes from integer value " + bigInt);
+            }
+#else
+            char[] buffer = new char[precision + start + 1];
+
+            int end;
+            if (pos == -1)
+            {
+                value.CopyTo(0, buffer, 0, value.Length);
+                end = value.Length;
+            }
+            else
+            {
+                value.CopyTo(0, buffer, 0, pos);
+                value.CopyTo(pos + 1, buffer, pos, neededScale);
+                end = value.Length - 1;
+            }
+
+            while (neededScale < scale)
+            {
+                buffer[end++] = '0';
+                neededScale++;
+            }
+
+            if (!BigInteger.TryParse(new string(buffer, 0, end), out BigInteger bigInt))
+            {
+                throw new ArgumentException($"Unable to parse {value} as decimal");
+            }
+
+            byte[] tempBytes = bigInt.ToByteArray();
+            try
+            {
+                tempBytes.CopyTo(bytes);
+            }
+            catch (ArgumentException)
+            {
+                throw new OverflowException("Could not extract bytes from integer value " + bigInt);
+            }
+            int bytesWritten = tempBytes.Length;
+#endif
+
+            if (bytes.Length > byteWidth)
+            {
+                throw new OverflowException($"Decimal size greater than {byteWidth} bytes: {bytes.Length}");
+            }
+
+            byte fill = bigInt.Sign == -1 ? (byte)255 : (byte)0;
+            for (int i = bytesWritten; i < byteWidth; i++)
+            {
+                bytes[i] = fill;
+            }
+        }
+
 #if !NETSTANDARD1_3
         internal static void GetBytes(SqlDecimal value, int precision, int scale, Span<byte> bytes)
         {
diff --git a/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs b/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
index 8d7adfef42b54..497c9d2f6c6af 100644
--- a/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/Decimal128ArrayTests.cs
@@ -16,6 +16,7 @@
 using System;
 #if !NETSTANDARD1_3
 using System.Data.SqlTypes;
+using System.Linq;
 #endif
 using Apache.Arrow.Types;
 using Xunit;
@@ -378,6 +379,94 @@ public void AppendRangeSqlDecimal()
                     Assert.Null(array.GetValue(range.Length));
                 }
             }
+
+            public class Strings
+            {
+                [Theory]
+                [InlineData(200)]
+                public void AppendString(int count)
+                {
+                    // Arrange
+                    const int precision = 10;
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(14, precision));
+
+                    // Act
+                    string[] testData = new string[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (i == count - 2)
+                        {
+                            builder.AppendNull();
+                            testData[i] = null;
+                            continue;
+                        }
+                        SqlDecimal rnd = i * (SqlDecimal)Math.Round(new Random().NextDouble(), 10);
+                        builder.Append(rnd);
+                        testData[i] = SqlDecimal.Round(rnd, precision).ToString();
+                    }
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(count, array.Length);
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (testData[i] == null)
+                        {
+                            Assert.Null(array.GetString(i));
+                            Assert.Null(array.GetSqlDecimal(i));
+                        }
+                        else
+                        {
+                            Assert.Equal(testData[i].TrimEnd('0'), array.GetString(i).TrimEnd('0'));
+                            Assert.Equal(SqlDecimal.Parse(testData[i]), array.GetSqlDecimal(i));
+                        }
+                    }
+                }
+
+                [Fact]
+                public void AppendMaxAndMinSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(38, 0));
+
+                    // Act
+                    builder.Append(SqlDecimal.MaxValue.ToString());
+                    builder.Append(SqlDecimal.MinValue.ToString());
+                    string maxMinusTen = (SqlDecimal.MaxValue - 10).ToString();
+                    string minPlusTen = (SqlDecimal.MinValue + 10).ToString();
+                    builder.Append(maxMinusTen);
+                    builder.Append(minPlusTen);
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(SqlDecimal.MaxValue.ToString(), array.GetString(0));
+                    Assert.Equal(SqlDecimal.MinValue.ToString(), array.GetString(1));
+                    Assert.Equal(maxMinusTen, array.GetString(2));
+                    Assert.Equal(minPlusTen, array.GetString(3));
+                }
+
+                [Fact]
+                public void AppendRangeSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal128Array.Builder(new Decimal128Type(24, 8));
+                    var range = new SqlDecimal[] { 2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M };
+
+                    // Act
+                    builder.AppendRange(range.Select(d => d.ToString()));
+                    builder.AppendNull();
+
+                    // Assert
+                    var array = builder.Build();
+                    for (int i = 0; i < range.Length; i++)
+                    {
+                        Assert.Equal(range[i], array.GetSqlDecimal(i));
+                        Assert.Equal(range[i].ToString(), array.GetString(i).TrimEnd('0'));
+                    }
+
+                    Assert.Null(array.GetValue(range.Length));
+                }
+            }
 #endif
         }
     }
diff --git a/csharp/test/Apache.Arrow.Tests/Decimal256ArrayTests.cs b/csharp/test/Apache.Arrow.Tests/Decimal256ArrayTests.cs
index e63c39d24eea8..3924c73a4e2f7 100644
--- a/csharp/test/Apache.Arrow.Tests/Decimal256ArrayTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/Decimal256ArrayTests.cs
@@ -14,7 +14,10 @@
 // limitations under the License.
 
 using System;
-using System.Collections.Generic;
+#if !NETSTANDARD1_3
+using System.Data.SqlTypes;
+using System.Linq;
+#endif
 using Apache.Arrow.Types;
 using Xunit;
 
@@ -22,6 +25,25 @@ namespace Apache.Arrow.Tests
 {
     public class Decimal256ArrayTests
     {
+#if !NETSTANDARD1_3
+        static SqlDecimal? GetSqlDecimal(Decimal256Array array, int index)
+        {
+            SqlDecimal? result;
+            Assert.True(array.TryGetSqlDecimal(index, out result));
+            return result;
+        }
+
+        static SqlDecimal? Convert(decimal? value)
+        {
+            return value == null ? null : new SqlDecimal(value.Value);
+        }
+
+        static decimal? Convert(SqlDecimal? value)
+        {
+            return value == null ? null : value.Value.Value;
+        }
+#endif
+
         public class Builder
         {
             public class AppendNull
@@ -45,6 +67,12 @@ public void AppendThenGetGivesNull()
                     Assert.Null(array.GetValue(0));
                     Assert.Null(array.GetValue(1));
                     Assert.Null(array.GetValue(2));
+
+#if !NETSTANDARD1_3
+                    Assert.Null(GetSqlDecimal(array, 0));
+                    Assert.Null(GetSqlDecimal(array, 1));
+                    Assert.Null(GetSqlDecimal(array, 2));
+#endif
                 }
             }
 
@@ -78,6 +106,9 @@ public void AppendDecimal(int count)
                     for (int i = 0; i < count; i++)
                     {
                         Assert.Equal(testData[i], array.GetValue(i));
+#if !NETSTANDARD1_3
+                        Assert.Equal(Convert(testData[i]), GetSqlDecimal(array, i));
+#endif
                     }
                 }
 
@@ -95,6 +126,11 @@ public void AppendLargeDecimal()
                     var array = builder.Build();
                     Assert.Equal(large, array.GetValue(0));
                     Assert.Equal(-large, array.GetValue(1));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(large), GetSqlDecimal(array, 0));
+                    Assert.Equal(Convert(-large), GetSqlDecimal(array, 1));
+#endif
                 }
 
                 [Fact]
@@ -115,6 +151,13 @@ public void AppendMaxAndMinDecimal()
                     Assert.Equal(Decimal.MinValue, array.GetValue(1));
                     Assert.Equal(Decimal.MaxValue - 10, array.GetValue(2));
                     Assert.Equal(Decimal.MinValue + 10, array.GetValue(3));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(Decimal.MaxValue), GetSqlDecimal(array, 0));
+                    Assert.Equal(Convert(Decimal.MinValue), GetSqlDecimal(array, 1));
+                    Assert.Equal(Convert(Decimal.MaxValue) - 10, GetSqlDecimal(array, 2));
+                    Assert.Equal(Convert(Decimal.MinValue) + 10, GetSqlDecimal(array, 3));
+#endif
                 }
 
                 [Fact]
@@ -131,6 +174,11 @@ public void AppendFractionalDecimal()
                     var array = builder.Build();
                     Assert.Equal(fraction, array.GetValue(0));
                     Assert.Equal(-fraction, array.GetValue(1));
+
+#if !NETSTANDARD1_3
+                    Assert.Equal(Convert(fraction), GetSqlDecimal(array, 0));
+                    Assert.Equal(Convert(-fraction), GetSqlDecimal(array, 1));
+#endif
                 }
 
                 [Fact]
@@ -149,8 +197,11 @@ public void AppendRangeDecimal()
                     for(int i = 0; i < range.Length; i ++)
                     {
                         Assert.Equal(range[i], array.GetValue(i));
+#if !NETSTANDARD1_3
+                        Assert.Equal(Convert(range[i]), GetSqlDecimal(array, i));
+#endif
                     }
-                    
+
                     Assert.Null( array.GetValue(range.Length));
                 }
 
@@ -256,6 +307,174 @@ public void SwapNull()
                     Assert.Equal(123.456M, array.GetValue(1));
                 }
             }
+
+#if !NETSTANDARD1_3
+            public class SqlDecimals
+            {
+                [Theory]
+                [InlineData(200)]
+                public void AppendSqlDecimal(int count)
+                {
+                    // Arrange
+                    const int precision = 10;
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(14, precision));
+
+                    // Act
+                    SqlDecimal?[] testData = new SqlDecimal?[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (i == count - 2)
+                        {
+                            builder.AppendNull();
+                            testData[i] = null;
+                            continue;
+                        }
+                        SqlDecimal rnd = i * (SqlDecimal)Math.Round(new Random().NextDouble(), 10);
+                        builder.Append(rnd);
+                        testData[i] = SqlDecimal.Round(rnd, precision);
+                    }
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(count, array.Length);
+                    for (int i = 0; i < count; i++)
+                    {
+                        Assert.Equal(testData[i], GetSqlDecimal(array, i));
+                        Assert.Equal(Convert(testData[i]), array.GetValue(i));
+                    }
+                }
+
+                [Fact]
+                public void AppendMaxAndMinSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(38, 0));
+
+                    // Act
+                    builder.Append(SqlDecimal.MaxValue);
+                    builder.Append(SqlDecimal.MinValue);
+                    builder.Append(SqlDecimal.MaxValue - 10);
+                    builder.Append(SqlDecimal.MinValue + 10);
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(SqlDecimal.MaxValue, GetSqlDecimal(array, 0));
+                    Assert.Equal(SqlDecimal.MinValue, GetSqlDecimal(array, 1));
+                    Assert.Equal(SqlDecimal.MaxValue - 10, GetSqlDecimal(array, 2));
+                    Assert.Equal(SqlDecimal.MinValue + 10, GetSqlDecimal(array, 3));
+                }
+
+                [Fact]
+                public void AppendRangeSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(24, 8));
+                    var range = new SqlDecimal[] { 2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M };
+
+                    // Act
+                    builder.AppendRange(range);
+                    builder.AppendNull();
+
+                    // Assert
+                    var array = builder.Build();
+                    for (int i = 0; i < range.Length; i++)
+                    {
+                        Assert.Equal(range[i], GetSqlDecimal(array, i));
+                        Assert.Equal(Convert(range[i]), array.GetValue(i));
+                    }
+
+                    Assert.Null(array.GetValue(range.Length));
+                }
+            }
+
+            public class Strings
+            {
+                [Theory]
+                [InlineData(200)]
+                public void AppendString(int count)
+                {
+                    // Arrange
+                    const int precision = 10;
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(14, precision));
+
+                    // Act
+                    string[] testData = new string[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (i == count - 2)
+                        {
+                            builder.AppendNull();
+                            testData[i] = null;
+                            continue;
+                        }
+                        SqlDecimal rnd = i * (SqlDecimal)Math.Round(new Random().NextDouble(), 10);
+                        builder.Append(rnd);
+                        testData[i] = SqlDecimal.Round(rnd, precision).ToString();
+                    }
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(count, array.Length);
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (testData[i] == null)
+                        {
+                            Assert.Null(array.GetString(i));
+                            Assert.Null(GetSqlDecimal(array, i));
+                        }
+                        else
+                        {
+                            Assert.Equal(testData[i].TrimEnd('0'), array.GetString(i).TrimEnd('0'));
+                            Assert.Equal(SqlDecimal.Parse(testData[i]), GetSqlDecimal(array, i));
+                        }
+                    }
+                }
+
+                [Fact]
+                public void AppendMaxAndMinSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(38, 0));
+
+                    // Act
+                    builder.Append(SqlDecimal.MaxValue.ToString());
+                    builder.Append(SqlDecimal.MinValue.ToString());
+                    string maxMinusTen = (SqlDecimal.MaxValue - 10).ToString();
+                    string minPlusTen = (SqlDecimal.MinValue + 10).ToString();
+                    builder.Append(maxMinusTen);
+                    builder.Append(minPlusTen);
+
+                    // Assert
+                    var array = builder.Build();
+                    Assert.Equal(SqlDecimal.MaxValue.ToString(), array.GetString(0));
+                    Assert.Equal(SqlDecimal.MinValue.ToString(), array.GetString(1));
+                    Assert.Equal(maxMinusTen, array.GetString(2));
+                    Assert.Equal(minPlusTen, array.GetString(3));
+                }
+
+                [Fact]
+                public void AppendRangeSqlDecimal()
+                {
+                    // Arrange
+                    var builder = new Decimal256Array.Builder(new Decimal256Type(24, 8));
+                    var range = new SqlDecimal[] { 2.123M, 1.5984M, -0.0000001M, 9878987987987987.1235407M };
+
+                    // Act
+                    builder.AppendRange(range.Select(d => d.ToString()));
+                    builder.AppendNull();
+
+                    // Assert
+                    var array = builder.Build();
+                    for (int i = 0; i < range.Length; i++)
+                    {
+                        Assert.Equal(range[i], GetSqlDecimal(array, i));
+                        Assert.Equal(range[i].ToString().TrimEnd('0'), array.GetString(i).TrimEnd('0'));
+                    }
+
+                    Assert.Null(array.GetValue(range.Length));
+                }
+            }
+#endif
         }
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
index dd5f7b9d3f67f..677e9b6cadfcf 100644
--- a/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs
@@ -121,5 +121,90 @@ public void LargeScale()
             }
 #endif
         }
+
+        public class Strings
+        {
+            [Theory]
+            [InlineData(100.12, 10, 2, "100.12")]
+            [InlineData(100.12, 8, 3, "100.120")]
+            [InlineData(100.12, 7, 4, "100.1200")]
+            [InlineData(.12, 6, 3, "0.120")]
+            [InlineData(.0012, 5, 4, "0.0012")]
+            [InlineData(-100.12, 10, 2, "-100.12")]
+            [InlineData(-100.12, 8, 3, "-100.120")]
+            [InlineData(-100.12, 7, 4, "-100.1200")]
+            [InlineData(-.12, 6, 3, "-0.120")]
+            [InlineData(-.0012, 5, 4, "-0.0012")]
+            [InlineData(7.89, 76, 38, "7.89000000000000000000000000000000000000")]
+            public void FromDecimal(decimal d, int precision, int scale, string result)
+            {
+                if (precision <= 38)
+                {
+                    TestFromDecimal(d, precision, scale, 16, result);
+                }
+                TestFromDecimal(d, precision, scale, 32, result);
+            }
+
+            private void TestFromDecimal(decimal d, int precision, int scale, int byteWidth, string result)
+            {
+                var bytes = new byte[byteWidth];
+                DecimalUtility.GetBytes(d, precision, scale, byteWidth, bytes);
+                Assert.Equal(result, DecimalUtility.GetString(new ArrowBuffer(bytes), 0, precision, scale, byteWidth));
+            }
+
+            [Theory]
+            [InlineData("100.12", 10, 2, "100.12")]
+            [InlineData("100.12", 8, 3, "100.120")]
+            [InlineData("100.12", 7, 4, "100.1200")]
+            [InlineData(".12", 6, 3, "0.120")]
+            [InlineData(".0012", 5, 4, "0.0012")]
+            [InlineData("-100.12", 10, 2, "-100.12")]
+            [InlineData("-100.12", 8, 3, "-100.120")]
+            [InlineData("-100.12", 7, 4, "-100.1200")]
+            [InlineData("-.12", 6, 3, "-0.120")]
+            [InlineData("-.0012", 5, 4, "-0.0012")]
+            [InlineData("+.0012", 5, 4, "0.0012")]
+            [InlineData("99999999999999999999999999999999999999", 38, 0, "99999999999999999999999999999999999999")]
+            [InlineData("-99999999999999999999999999999999999999", 38, 0, "-99999999999999999999999999999999999999")]
+            public void FromString(string s, int precision, int scale, string result)
+            {
+                TestFromString(s, precision, scale, 16, result);
+                TestFromString(s, precision, scale, 32, result);
+            }
+
+            [Fact]
+            public void ThroughDecimal256()
+            {
+                var seventysix = new string('9', 76);
+                TestFromString(seventysix, 76, 0, 32, seventysix);
+                TestFromString("0000" + seventysix, 76, 0, 32, seventysix);
+
+                seventysix = "-" + seventysix;
+                TestFromString(seventysix, 76, 0, 32, seventysix);
+
+                var seventyseven = new string('9', 77);
+                Assert.Throws<OverflowException>(() => TestFromString(seventyseven, 76, 0, 32, seventyseven));
+            }
+
+            private void TestFromString(string s, int precision, int scale, int byteWidth, string result)
+            {
+                var bytes = new byte[byteWidth];
+                DecimalUtility.GetBytes(s, precision, scale, byteWidth, bytes);
+                Assert.Equal(result, DecimalUtility.GetString(new ArrowBuffer(bytes), 0, precision, scale, byteWidth));
+            }
+
+            [Theory]
+            [InlineData("", 10, 2, 16, typeof(ArgumentException))]
+            [InlineData("", 10, 2, 32, typeof(ArgumentException))]
+            [InlineData(null, 10, 2, 32, typeof(ArgumentException))]
+            [InlineData("1.23", 10, 1, 16, typeof(OverflowException))]
+            [InlineData("12345678901234567890", 24, 1, 8, typeof(OverflowException))]
+            [InlineData("abc", 24, 1, 8, typeof(ArgumentException))]
+            public void ParseErrors(string s, int precision, int scale, int byteWidth, Type exceptionType)
+            {
+                byte[] bytes = new byte[byteWidth];
+                Assert.Throws(exceptionType, () => DecimalUtility.GetBytes(s, precision, scale, byteWidth, bytes));
+            }
+        }
     }
 }

From b42d44e32fe64c2f9e04d701300f170c9f47f3b3 Mon Sep 17 00:00:00 2001
From: James Duong <duong.james@gmail.com>
Date: Mon, 30 Oct 2023 08:02:57 -0700
Subject: [PATCH 650/749] GH-37889: [Java][Doc] Improve JDBC driver
 documentation (#38469)

### Rationale for this change
Correct inaccuracies and better document how to connect with the Flight SQL JDBC Driver.

### What changes are included in this PR?
- Correct the user property.
- Correct the default for useEncryption.
- Elaborate on using the Properties object when connecting and describe the order of precedence.

### Are these changes tested?
N/A

### Are there any user-facing changes?
Yes
* Closes: #37889

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/flight_sql_jdbc_driver.rst | 25 ++++++++++++++++-----
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/docs/source/java/flight_sql_jdbc_driver.rst b/docs/source/java/flight_sql_jdbc_driver.rst
index 3b45cdd8b84cd..8268242302488 100644
--- a/docs/source/java/flight_sql_jdbc_driver.rst
+++ b/docs/source/java/flight_sql_jdbc_driver.rst
@@ -80,8 +80,8 @@ The components of the URI are as follows.
 * **HOSTNAME** is the hostname of the Flight SQL service.
 * **PORT** is the port of the Flight SQL service.
 
-Additional options can be passed as query parameters.  The supported
-parameters are:
+Additional options can be passed as query parameters. Parameter names are
+case-sensitive. The supported parameters are:
 
 .. list-table::
    :header-rows: 1
@@ -115,11 +115,10 @@ parameters are:
      - When TLS is enabled, the password for the certificate store
 
    * - useEncryption
-     - false
-     - Whether to use TLS (the default is an insecure, plaintext
-       connection)
+     - true
+     - Whether to use TLS (the default is an encrypted connection)
 
-   * - username
+   * - user
      - null
      - The username for user/password authentication
 
@@ -127,6 +126,9 @@ parameters are:
      - true
      - When TLS is enabled, whether to use the system certificate store
 
+Note that URI values must be URI-encoded if they contain characters such
+as !, @, $, etc.
+
 Any URI parameters that are not handled by the driver are passed to
 the Flight SQL service as gRPC headers. For example, the following URI ::
 
@@ -135,3 +137,14 @@ the Flight SQL service as gRPC headers. For example, the following URI ::
 This will connect without authentication or encryption, to a Flight
 SQL service running on ``localhost`` on port 12345. Each request will
 also include a `database=mydb` gRPC header.
+
+Connection parameters may also be supplied using the Properties object
+when using the JDBC Driver Manager to connect. When supplying using
+the Properties object, values should *not* be URI-encoded.
+
+Parameters specified by the URI supercede parameters supplied by the
+Properties object. When calling the `user/password overload of 
+DriverManager#getConnection() 
+<https://docs.oracle.com/javase/8/docs/api/java/sql/DriverManager.html#getConnection-java.lang.String-java.lang.String-java.lang.String->`_,
+the username and password supplied on the URI supercede the username and
+password arguments to the function call.

From 23b62a441ee73ef1643a28e992335b9029f0ebe4 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Mon, 30 Oct 2023 11:11:41 -0400
Subject: [PATCH 651/749] GH-38462: [Go][Parquet] Handle Boolean RLE
 encoding/decoding (#38367)

### Rationale for this change
Looks like the parquet-testing repo files have been updated and now include boolean columns which use the RLE encoding type. This causes the Go parquet lib to fail verification tests when it pulls the most recent commits for the parquet-testing repository. So a solution for this is to actually implement the RleBoolean encoder and decoder.

### What changes are included in this PR?
Adding `RleBooleanEncoder` and `RleBooleanDecoder` and updating the `parquet-testing` repo.

### Are these changes tested?
Unit tests are added, and this is also tested via the `parquet-testing` golden files.

* Closes: #38345
* Closes: #38462

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/file/column_reader.go              |  8 +-
 go/parquet/file/file_reader_test.go           | 61 ++++++++++++++
 .../internal/encoding/boolean_decoder.go      | 82 ++++++++++++++++++-
 .../internal/encoding/boolean_encoder.go      | 55 +++++++++++++
 go/parquet/internal/encoding/encoder.go       |  2 +-
 go/parquet/internal/encoding/encoding_test.go | 12 +++
 go/parquet/internal/encoding/levels.go        |  2 +-
 .../internal/encoding/typed_encoder.gen.go    |  4 +
 .../encoding/typed_encoder.gen.go.tmpl        |  8 ++
 go/parquet/internal/testutils/random.go       | 13 +--
 go/parquet/internal/utils/bit_reader_test.go  |  2 +-
 go/parquet/internal/utils/rle.go              |  4 +-
 12 files changed, 239 insertions(+), 14 deletions(-)

diff --git a/go/parquet/file/column_reader.go b/go/parquet/file/column_reader.go
index 1ebceaca234c1..b623bd5074d02 100644
--- a/go/parquet/file/column_reader.go
+++ b/go/parquet/file/column_reader.go
@@ -17,6 +17,7 @@
 package file
 
 import (
+	"errors"
 	"fmt"
 	"sync"
 
@@ -345,6 +346,11 @@ func (c *columnChunkReader) initDataDecoder(page Page, lvlByteLen int64) error {
 		c.curDecoder = decoder
 	} else {
 		switch encoding {
+		case format.Encoding_RLE:
+			if c.descr.PhysicalType() != parquet.Types.Boolean {
+				return fmt.Errorf("parquet: only boolean supports RLE encoding, got %s", c.descr.PhysicalType())
+			}
+			fallthrough
 		case format.Encoding_PLAIN,
 			format.Encoding_DELTA_BYTE_ARRAY,
 			format.Encoding_DELTA_LENGTH_BYTE_ARRAY,
@@ -352,7 +358,7 @@ func (c *columnChunkReader) initDataDecoder(page Page, lvlByteLen int64) error {
 			c.curDecoder = c.decoderTraits.Decoder(parquet.Encoding(encoding), c.descr, false, c.mem)
 			c.decoders[encoding] = c.curDecoder
 		case format.Encoding_RLE_DICTIONARY:
-			return xerrors.New("parquet: dictionary page must be before data page")
+			return errors.New("parquet: dictionary page must be before data page")
 		case format.Encoding_BYTE_STREAM_SPLIT:
 			return fmt.Errorf("parquet: unsupported data encoding %s", encoding)
 		default:
diff --git a/go/parquet/file/file_reader_test.go b/go/parquet/file/file_reader_test.go
index eccb572b30040..2a9b097139062 100644
--- a/go/parquet/file/file_reader_test.go
+++ b/go/parquet/file/file_reader_test.go
@@ -21,6 +21,8 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 	"io"
+	"os"
+	"path"
 	"testing"
 
 	"github.com/apache/arrow/go/v14/arrow/memory"
@@ -385,3 +387,62 @@ func TestDeltaLengthByteArrayPackingWithNulls(t *testing.T) {
 		assert.NotNil(t, readData[0])
 	}
 }
+
+func TestRleBooleanEncodingFileRead(t *testing.T) {
+	dir := os.Getenv("PARQUET_TEST_DATA")
+	if dir == "" {
+		t.Skip("no path supplied with PARQUET_TEST_DATA")
+	}
+	assert.DirExists(t, dir)
+
+	props := parquet.NewReaderProperties(memory.DefaultAllocator)
+	fileReader, err := file.OpenParquetFile(path.Join(dir, "rle_boolean_encoding.parquet"),
+		false, file.WithReadProps(props))
+	require.NoError(t, err)
+	defer fileReader.Close()
+
+	assert.Equal(t, 1, fileReader.NumRowGroups())
+	rgr := fileReader.RowGroup(0)
+	assert.EqualValues(t, 68, rgr.NumRows())
+
+	rdr, err := rgr.Column(0)
+	require.NoError(t, err)
+	brdr := rdr.(*file.BooleanColumnChunkReader)
+
+	values := make([]bool, 68)
+	defLvls, repLvls := make([]int16, 68), make([]int16, 68)
+	total, read, err := brdr.ReadBatch(68, values, defLvls, repLvls)
+	require.NoError(t, err)
+
+	assert.EqualValues(t, 68, total)
+	md, err := rgr.MetaData().ColumnChunk(0)
+	require.NoError(t, err)
+	stats, err := md.Statistics()
+	require.NoError(t, err)
+	assert.EqualValues(t, total-stats.NullCount(), read)
+
+	expected := []bool{
+		true, false, true, true, false, false,
+		true, true, true, false, false, true, true,
+		false, true, true, false, false, true, true,
+		false, true, true, false, false, true, true,
+		true, false, false, false, false, true, true,
+		false, true, true, false, false, true, true,
+		true, false, false, true, true, false, false,
+		true, true, true, false, true, true, false,
+		true, true, false, false, true, true, true,
+	}
+	expectedNulls := []int{2, 15, 23, 38, 48, 60}
+
+	expectedNullIdx := 0
+	for i, v := range defLvls {
+		if expectedNullIdx < len(expectedNulls) && i == expectedNulls[expectedNullIdx] {
+			assert.Zero(t, v)
+			expectedNullIdx++
+		} else {
+			assert.EqualValues(t, 1, v)
+		}
+	}
+
+	assert.Equal(t, expected, values[:len(expected)])
+}
diff --git a/go/parquet/internal/encoding/boolean_decoder.go b/go/parquet/internal/encoding/boolean_decoder.go
index dd213395d6324..337a6db967a2e 100644
--- a/go/parquet/internal/encoding/boolean_decoder.go
+++ b/go/parquet/internal/encoding/boolean_decoder.go
@@ -17,11 +17,16 @@
 package encoding
 
 import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
 	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/apache/arrow/go/v14/parquet"
 	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"golang.org/x/xerrors"
 )
 
 // PlainBooleanDecoder is for the Plain Encoding type, there is no
@@ -103,7 +108,80 @@ func (dec *PlainBooleanDecoder) DecodeSpaced(out []bool, nullCount int, validBit
 			return 0, err
 		}
 		if valuesRead != toRead {
-			return valuesRead, xerrors.New("parquet: boolean decoder: number of values / definition levels read did not match")
+			return valuesRead, errors.New("parquet: boolean decoder: number of values / definition levels read did not match")
+		}
+		return spacedExpand(out, nullCount, validBits, validBitsOffset), nil
+	}
+	return dec.Decode(out)
+}
+
+type RleBooleanDecoder struct {
+	decoder
+
+	rleDec *utils.RleDecoder
+}
+
+func (RleBooleanDecoder) Type() parquet.Type {
+	return parquet.Types.Boolean
+}
+
+func (dec *RleBooleanDecoder) SetData(nvals int, data []byte) error {
+	dec.nvals = nvals
+
+	if len(data) < 4 {
+		return fmt.Errorf("invalid length - %d (corrupt data page?)", len(data))
+	}
+
+	// load the first 4 bytes in little-endian which indicates the length
+	nbytes := binary.LittleEndian.Uint32(data[:4])
+	if nbytes > uint32(len(data)-4) {
+		return fmt.Errorf("received invalid number of bytes - %d (corrupt data page?)", nbytes)
+	}
+
+	dec.data = data[4:]
+	if dec.rleDec == nil {
+		dec.rleDec = utils.NewRleDecoder(bytes.NewReader(dec.data), 1)
+	} else {
+		dec.rleDec.Reset(bytes.NewReader(dec.data), 1)
+	}
+	return nil
+}
+
+func (dec *RleBooleanDecoder) Decode(out []bool) (int, error) {
+	max := shared_utils.MinInt(len(out), dec.nvals)
+
+	var (
+		buf [1024]uint64
+		n   = max
+	)
+
+	for n > 0 {
+		batch := shared_utils.MinInt(len(buf), n)
+		decoded := dec.rleDec.GetBatch(buf[:batch])
+		if decoded != batch {
+			return max - n, io.ErrUnexpectedEOF
+		}
+
+		for i := 0; i < batch; i++ {
+			out[i] = buf[i] != 0
+		}
+		n -= batch
+		out = out[batch:]
+	}
+
+	dec.nvals -= max
+	return max, nil
+}
+
+func (dec *RleBooleanDecoder) DecodeSpaced(out []bool, nullCount int, validBits []byte, validBitsOffset int64) (int, error) {
+	if nullCount > 0 {
+		toRead := len(out) - nullCount
+		valuesRead, err := dec.Decode(out[:toRead])
+		if err != nil {
+			return 0, err
+		}
+		if valuesRead != toRead {
+			return valuesRead, errors.New("parquet: rle boolean decoder: number of values / definition levels read did not match")
 		}
 		return spacedExpand(out, nullCount, validBits, validBitsOffset), nil
 	}
diff --git a/go/parquet/internal/encoding/boolean_encoder.go b/go/parquet/internal/encoding/boolean_encoder.go
index 65ba2658b0637..3970e05fca289 100644
--- a/go/parquet/internal/encoding/boolean_encoder.go
+++ b/go/parquet/internal/encoding/boolean_encoder.go
@@ -17,8 +17,11 @@
 package encoding
 
 import (
+	"encoding/binary"
+
 	"github.com/apache/arrow/go/v14/arrow/bitutil"
 	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 )
 
@@ -87,3 +90,55 @@ func (enc *PlainBooleanEncoder) FlushValues() (Buffer, error) {
 
 	return enc.sink.Finish(), nil
 }
+
+const rleLengthInBytes = 4
+
+type RleBooleanEncoder struct {
+	encoder
+
+	bufferedValues []bool
+}
+
+func (RleBooleanEncoder) Type() parquet.Type {
+	return parquet.Types.Boolean
+}
+
+func (enc *RleBooleanEncoder) Put(in []bool) {
+	enc.bufferedValues = append(enc.bufferedValues, in...)
+}
+
+func (enc *RleBooleanEncoder) PutSpaced(in []bool, validBits []byte, validBitsOffset int64) {
+	bufferOut := make([]bool, len(in))
+	nvalid := spacedCompress(in, bufferOut, validBits, validBitsOffset)
+	enc.Put(bufferOut[:nvalid])
+}
+
+func (enc *RleBooleanEncoder) EstimatedDataEncodedSize() int64 {
+	return rleLengthInBytes + int64(enc.maxRleBufferSize())
+}
+
+func (enc *RleBooleanEncoder) maxRleBufferSize() int {
+	return utils.MaxRLEBufferSize(1, len(enc.bufferedValues)) +
+		utils.MinRLEBufferSize(1)
+}
+
+func (enc *RleBooleanEncoder) FlushValues() (Buffer, error) {
+	rleBufferSizeMax := enc.maxRleBufferSize()
+	enc.sink.SetOffset(rleLengthInBytes)
+	enc.sink.Reserve(rleBufferSizeMax)
+
+	rleEncoder := utils.NewRleEncoder(enc.sink, 1)
+	for _, v := range enc.bufferedValues {
+		if v {
+			rleEncoder.Put(1)
+		} else {
+			rleEncoder.Put(0)
+		}
+	}
+	n := rleEncoder.Flush()
+	debug.Assert(n <= rleBufferSizeMax, "num encoded bytes larger than expected max")
+	buf := enc.sink.Finish()
+	binary.LittleEndian.PutUint32(buf.Bytes(), uint32(n))
+
+	return buf, nil
+}
diff --git a/go/parquet/internal/encoding/encoder.go b/go/parquet/internal/encoding/encoder.go
index 9626e4e9ff97f..f6b57fe63c433 100644
--- a/go/parquet/internal/encoding/encoder.go
+++ b/go/parquet/internal/encoding/encoder.go
@@ -244,7 +244,7 @@ func (d *dictEncoder) FlushValues() (Buffer, error) {
 // EstimatedDataEncodedSize returns the maximum number of bytes needed to store the RLE encoded indexes, not including the
 // dictionary index in the computation.
 func (d *dictEncoder) EstimatedDataEncodedSize() int64 {
-	return 1 + int64(utils.MaxBufferSize(d.BitWidth(), len(d.idxValues))+utils.MinBufferSize(d.BitWidth()))
+	return 1 + int64(utils.MaxRLEBufferSize(d.BitWidth(), len(d.idxValues))+utils.MinRLEBufferSize(d.BitWidth()))
 }
 
 // NumEntries returns the number of entires in the dictionary index for this encoder.
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index 50e72de004e19..b0d86321e09f1 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -363,6 +363,16 @@ func (b *BaseEncodingTestSuite) TestBasicRoundTrip() {
 	b.checkRoundTrip(parquet.Encodings.Plain)
 }
 
+func (b *BaseEncodingTestSuite) TestRleBooleanEncodingRoundTrip() {
+	switch b.typ {
+	case reflect.TypeOf(true):
+		b.initData(2000, 200)
+		b.checkRoundTrip(parquet.Encodings.RLE)
+	default:
+		b.T().SkipNow()
+	}
+}
+
 func (b *BaseEncodingTestSuite) TestDeltaEncodingRoundTrip() {
 	b.initData(10000, 1)
 
@@ -408,6 +418,8 @@ func (b *BaseEncodingTestSuite) TestSpacedRoundTrip() {
 			if validBits != nil {
 				b.checkRoundTripSpaced(parquet.Encodings.Plain, validBits, validBitsOffset)
 				switch b.typ {
+				case reflect.TypeOf(false):
+					b.checkRoundTripSpaced(parquet.Encodings.RLE, validBits, validBitsOffset)
 				case reflect.TypeOf(int32(0)), reflect.TypeOf(int64(0)):
 					b.checkRoundTripSpaced(parquet.Encodings.DeltaBinaryPacked, validBits, validBitsOffset)
 				case reflect.TypeOf(parquet.ByteArray{}):
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index c5622519b0ce4..e04ec19d5473d 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -48,7 +48,7 @@ func LevelEncodingMaxBufferSize(encoding parquet.Encoding, maxLvl int16, nbuffer
 	nbytes := 0
 	switch encoding {
 	case parquet.Encodings.RLE:
-		nbytes = utils.MaxBufferSize(bitWidth, nbuffered) + utils.MinBufferSize(bitWidth)
+		nbytes = utils.MaxRLEBufferSize(bitWidth, nbuffered) + utils.MinRLEBufferSize(bitWidth)
 	case parquet.Encodings.BitPacked:
 		nbytes = int(bitutil.BytesForBits(int64(nbuffered * bitWidth)))
 	default:
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go b/go/parquet/internal/encoding/typed_encoder.gen.go
index 7c1f954632f06..411e87c17e7d5 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go
@@ -1225,6 +1225,8 @@ func (boolEncoderTraits) Encoder(e format.Encoding, useDict bool, descr *schema.
 	switch e {
 	case format.Encoding_PLAIN:
 		return &PlainBooleanEncoder{encoder: newEncoderBase(e, descr, mem)}
+	case format.Encoding_RLE:
+		return &RleBooleanEncoder{encoder: newEncoderBase(e, descr, mem)}
 	default:
 		panic("unimplemented encoding type")
 	}
@@ -1248,6 +1250,8 @@ func (boolDecoderTraits) Decoder(e parquet.Encoding, descr *schema.Column, useDi
 	switch e {
 	case parquet.Encodings.Plain:
 		return &PlainBooleanDecoder{decoder: newDecoderBase(format.Encoding(e), descr)}
+	case parquet.Encodings.RLE:
+		return &RleBooleanDecoder{decoder: newDecoderBase(format.Encoding(e), descr)}
 	default:
 		panic("unimplemented encoding type")
 	}
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
index f0d4fb50ae2fc..69415ccca4a26 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
@@ -73,6 +73,10 @@ func ({{.lower}}EncoderTraits) Encoder(e format.Encoding, useDict bool, descr *s
   switch e {
   case format.Encoding_PLAIN:
     return &Plain{{.Name}}Encoder{encoder: newEncoderBase(e, descr, mem)}
+{{- if eq .Name "Boolean" }}
+  case format.Encoding_RLE:
+    return &RleBooleanEncoder{encoder: newEncoderBase(e, descr, mem)}
+{{- end}}
 {{- if or (eq .Name "Int32") (eq .Name "Int64")}}
   case format.Encoding_DELTA_BINARY_PACKED:
     return DeltaBitPack{{.Name}}Encoder{&deltaBitPackEncoder{
@@ -117,6 +121,10 @@ func ({{.lower}}DecoderTraits) Decoder(e parquet.Encoding, descr *schema.Column,
   switch e {
   case parquet.Encodings.Plain:
     return &Plain{{.Name}}Decoder{decoder: newDecoderBase(format.Encoding(e), descr)}
+{{- if eq .Name "Boolean" }}
+  case parquet.Encodings.RLE:
+    return &RleBooleanDecoder{decoder: newDecoderBase(format.Encoding(e), descr)}
+{{- end}}
 {{- if or (eq .Name "Int32") (eq .Name "Int64")}}
   case parquet.Encodings.DeltaBinaryPacked:
     if mem == nil {
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index 2c8a2809dc784..d9a06da43ba4e 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -438,15 +438,16 @@ func fillRandomIsValid(seed uint64, pctNull float64, out []bool) {
 // If the type is parquet.ByteArray or parquet.FixedLenByteArray, heap must not be null.
 //
 // The default values are:
-//  []bool uses the current time as the seed with only values of 1 being false, for use
-//   of creating validity boolean slices.
-//  all other types use 0 as the seed
-//  a []parquet.ByteArray is populated with lengths between 2 and 12
-//  a []parquet.FixedLenByteArray is populated with fixed size random byte arrays of length 12.
+//
+//	[]bool uses the current time as the seed with only values of 1 being false, for use
+//	 of creating validity boolean slices.
+//	all other types use 0 as the seed
+//	a []parquet.ByteArray is populated with lengths between 2 and 12
+//	a []parquet.FixedLenByteArray is populated with fixed size random byte arrays of length 12.
 func InitValues(values interface{}, heap *memory.Buffer) {
 	switch arr := values.(type) {
 	case []bool:
-		fillRandomIsValid(uint64(time.Now().Unix()), 1.0, arr)
+		fillRandomIsValid(uint64(time.Now().Unix()), 0.5, arr)
 	case []int32:
 		FillRandomInt32(0, arr)
 	case []int64:
diff --git a/go/parquet/internal/utils/bit_reader_test.go b/go/parquet/internal/utils/bit_reader_test.go
index 317cc4960afe2..c285f5165cc0a 100644
--- a/go/parquet/internal/utils/bit_reader_test.go
+++ b/go/parquet/internal/utils/bit_reader_test.go
@@ -494,7 +494,7 @@ func (r *RLERandomSuite) checkRoundTrip(vals []uint64, width int) bool {
 
 func (r *RLERandomSuite) checkRoundTripSpaced(vals arrow.Array, width int) {
 	nvalues := vals.Len()
-	bufsize := utils.MaxBufferSize(width, nvalues)
+	bufsize := utils.MaxRLEBufferSize(width, nvalues)
 
 	buffer := make([]byte, bufsize)
 	encoder := utils.NewRleEncoder(utils.NewWriterAtBuffer(buffer), width)
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index 866d7c61b4099..fef322c6fd560 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -37,13 +37,13 @@ const (
 	MaxValuesPerLiteralRun = (1 << 6) * 8
 )
 
-func MinBufferSize(bitWidth int) int {
+func MinRLEBufferSize(bitWidth int) int {
 	maxLiteralRunSize := 1 + bitutil.BytesForBits(int64(MaxValuesPerLiteralRun*bitWidth))
 	maxRepeatedRunSize := binary.MaxVarintLen32 + bitutil.BytesForBits(int64(bitWidth))
 	return int(utils.Max(maxLiteralRunSize, maxRepeatedRunSize))
 }
 
-func MaxBufferSize(width, numValues int) int {
+func MaxRLEBufferSize(width, numValues int) int {
 	bytesPerRun := width
 	numRuns := int(bitutil.BytesForBits(int64(numValues)))
 	literalMaxSize := numRuns + (numRuns * bytesPerRun)

From 0026c0cda71c44b73a8b635bd5245b49b9cabb80 Mon Sep 17 00:00:00 2001
From: Gavin Murrison <2135106+voidstar69@users.noreply.github.com>
Date: Mon, 30 Oct 2023 16:17:15 +0000
Subject: [PATCH 652/749] GH-30717: [C#] Add ToString() methods to Arrow
 classes (#36566)

### What changes are included in this PR?

Implemented the ToString() method on classes ChunkedArray, Field, RecordBatch, Schema and Table.
I could not find the class DataType mentioned in the issue, perhaps it meant DateType?

Closes #30717.
* Closes: #30717

Lead-authored-by: Gavin Murrison <2135106+voidstar69@users.noreply.github.com>
Co-authored-by: voidstar69 <voidstar69@gmail.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Curt Hagenlocher <curt@hagenlocher.org>
---
 csharp/src/Apache.Arrow/ChunkedArray.cs                  | 2 ++
 csharp/src/Apache.Arrow/Field.cs                         | 2 ++
 csharp/src/Apache.Arrow/RecordBatch.cs                   | 2 ++
 csharp/src/Apache.Arrow/Schema.cs                        | 2 ++
 csharp/src/Apache.Arrow/Table.cs                         | 2 ++
 csharp/test/Apache.Arrow.Tests/ArrowStreamWriterTests.cs | 4 ++++
 csharp/test/Apache.Arrow.Tests/TableTests.cs             | 6 ++++++
 7 files changed, 20 insertions(+)

diff --git a/csharp/src/Apache.Arrow/ChunkedArray.cs b/csharp/src/Apache.Arrow/ChunkedArray.cs
index f5909f5adfe48..85b3560c229f2 100644
--- a/csharp/src/Apache.Arrow/ChunkedArray.cs
+++ b/csharp/src/Apache.Arrow/ChunkedArray.cs
@@ -92,6 +92,8 @@ public ChunkedArray Slice(long offset)
             return Slice(offset, Length - offset);
         }
 
+        public override string ToString() => $"{nameof(ChunkedArray)}: Length={Length}, DataType={DataType.Name}";
+      
         private static IArrowArray[] Cast(IList<Array> arrays)
         {
             IArrowArray[] arrowArrays = new IArrowArray[arrays.Count];
diff --git a/csharp/src/Apache.Arrow/Field.cs b/csharp/src/Apache.Arrow/Field.cs
index 562b9587bddb9..4fddd1bc4e2de 100644
--- a/csharp/src/Apache.Arrow/Field.cs
+++ b/csharp/src/Apache.Arrow/Field.cs
@@ -61,5 +61,7 @@ private Field(string name, IArrowType dataType, bool nullable, bool allowBlankNa
             DataType = dataType ?? NullType.Default;
             IsNullable = nullable;
         }
+
+        public override string ToString() => $"{nameof(Field)}: Name={Name}, DataType={DataType.Name}, IsNullable={IsNullable}, Metadata count={Metadata?.Count ?? 0}";
     }
 }
diff --git a/csharp/src/Apache.Arrow/RecordBatch.cs b/csharp/src/Apache.Arrow/RecordBatch.cs
index f87081d2987ac..566c77830265e 100644
--- a/csharp/src/Apache.Arrow/RecordBatch.cs
+++ b/csharp/src/Apache.Arrow/RecordBatch.cs
@@ -93,5 +93,7 @@ public RecordBatch Clone(MemoryAllocator allocator = default)
             IEnumerable<IArrowArray> arrays = _arrays.Select(array => ArrowArrayFactory.BuildArray(array.Data.Clone(allocator)));
             return new RecordBatch(Schema, arrays, Length);
         }
+
+        public override string ToString() => $"{nameof(RecordBatch)}: {ColumnCount} columns by {Length} rows";
     }
 }
diff --git a/csharp/src/Apache.Arrow/Schema.cs b/csharp/src/Apache.Arrow/Schema.cs
index 5d6b2b7bbdc4c..608b967630079 100644
--- a/csharp/src/Apache.Arrow/Schema.cs
+++ b/csharp/src/Apache.Arrow/Schema.cs
@@ -114,5 +114,7 @@ public Schema SetField(int fieldIndex, Field newField)
 
             return new Schema(fields, Metadata);
         }
+
+        public override string ToString() => $"{nameof(Schema)}: Num fields={_fieldsList.Count}, Num metadata={Metadata?.Count ?? 0}";
     }
 }
diff --git a/csharp/src/Apache.Arrow/Table.cs b/csharp/src/Apache.Arrow/Table.cs
index 939ec23f54ff2..dd21cf1d0b39c 100644
--- a/csharp/src/Apache.Arrow/Table.cs
+++ b/csharp/src/Apache.Arrow/Table.cs
@@ -107,6 +107,8 @@ public Table SetColumn(int columnIndex, Column column)
             return new Table(newSchema, newColumns);
         }
 
+        public override string ToString() => $"{nameof(Table)}: {ColumnCount} columns by {RowCount} rows";
+
         // TODO: Flatten for Tables with Lists/Structs?
     }
 }
diff --git a/csharp/test/Apache.Arrow.Tests/ArrowStreamWriterTests.cs b/csharp/test/Apache.Arrow.Tests/ArrowStreamWriterTests.cs
index 89595f99dc0e4..c4c0b6ec9ff21 100644
--- a/csharp/test/Apache.Arrow.Tests/ArrowStreamWriterTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/ArrowStreamWriterTests.cs
@@ -541,6 +541,10 @@ public async Task WriteMultipleDictionaryArraysAsync()
         public void WriteMultipleDictionaryArrays()
         {
             List<RecordBatch> originalRecordBatches = CreateMultipleDictionaryArraysTestData();
+            Assert.Equal("RecordBatch: 10 columns by 3 rows", originalRecordBatches[0].ToString());
+            Assert.Equal("Schema: Num fields=10, Num metadata=0", originalRecordBatches[0].Schema.ToString());
+            Assert.Equal("Field: Name=dictionaryField_int8, DataType=dictionary, IsNullable=False, Metadata count=0",
+                originalRecordBatches[0].Schema.FieldsLookup["dictionaryField_int8"].Single().ToString());
             TestRoundTripRecordBatches(originalRecordBatches);
         }
 
diff --git a/csharp/test/Apache.Arrow.Tests/TableTests.cs b/csharp/test/Apache.Arrow.Tests/TableTests.cs
index 234dd63a79cd2..9e23fa99a769c 100644
--- a/csharp/test/Apache.Arrow.Tests/TableTests.cs
+++ b/csharp/test/Apache.Arrow.Tests/TableTests.cs
@@ -49,6 +49,8 @@ public void TestTableBasics()
             Table table = MakeTableWithOneColumnOfTwoIntArrays(10);
             Assert.Equal(20, table.RowCount);
             Assert.Equal(1, table.ColumnCount);
+            Assert.Equal("Table: 1 columns by 20 rows", table.ToString());
+            Assert.Equal("ChunkedArray: Length=20, DataType=int32", table.Column(0).Data.ToString());
         }
 
         [Fact]
@@ -61,6 +63,7 @@ public void TestTableFromRecordBatches()
             Table table1 = Table.TableFromRecordBatches(recordBatch1.Schema, recordBatches);
             Assert.Equal(20, table1.RowCount);
             Assert.Equal(27, table1.ColumnCount);
+            Assert.Equal("ChunkedArray: Length=20, DataType=list", table1.Column(0).Data.ToString());
 
             FixedSizeBinaryType type = new FixedSizeBinaryType(17);
             Field newField1 = new Field(type.Name, type, false);
@@ -83,6 +86,9 @@ public void TestTableFromRecordBatches()
         public void TestTableAddRemoveAndSetColumn()
         {
             Table table = MakeTableWithOneColumnOfTwoIntArrays(10);
+            Assert.Equal("Table: 1 columns by 20 rows", table.ToString());
+            Assert.Equal("Field: Name=f0, DataType=int32, IsNullable=True, Metadata count=0", table.Column(0).Field.ToString());
+            Assert.Equal("ChunkedArray: Length=20, DataType=int32", table.Column(0).Data.ToString());
 
             Array nonEqualLengthIntArray = ColumnTests.MakeIntArray(10);
             Field field1 = new Field.Builder().Name("f1").DataType(Int32Type.Default).Build();

From cb11e44d878f3c7b28d70f1b82f5e04f4fb584df Mon Sep 17 00:00:00 2001
From: Lei Hou <leihou@mathworks.com>
Date: Mon, 30 Oct 2023 16:50:31 -0400
Subject: [PATCH 653/749] GH-38310: [MATLAB] Create the testing guideline
 document for testing MATLAB interface (#38459)

### Rationale for this change

This document is aimed at coaching people on how to write and run tests for the MATLAB interface. This document is helpful to reproduce and address test failures in GitHub Actions CI, and is also helpful to maintain the good quality of MATLAB interface.

### What changes are included in this PR?

Created a markdown page under arrow/matlab/doc.

### Are these changes tested?

No test needed.

### Are there any user-facing changes?

No software change.
* Closes: #38310

Authored-by: Lei Hou <leihou@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 ...or_the_matlab_interface_to_apache_arrow.md | 144 ++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 matlab/doc/testing_guidelines_for_the_matlab_interface_to_apache_arrow.md

diff --git a/matlab/doc/testing_guidelines_for_the_matlab_interface_to_apache_arrow.md b/matlab/doc/testing_guidelines_for_the_matlab_interface_to_apache_arrow.md
new file mode 100644
index 0000000000000..ee4343155deba
--- /dev/null
+++ b/matlab/doc/testing_guidelines_for_the_matlab_interface_to_apache_arrow.md
@@ -0,0 +1,144 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Testing Guidelines for the MATLAB Interface to Apache Arrow  
+
+## Overview  
+
+The goal of this document is to provide helpful guidelines for testing functionality within the [`matlab` directory](https://github.com/apache/arrow/tree/main/matlab) of the [`apache/arrow`](https://github.com/apache/arrow) repository.  
+
+## Prerequisites  
+
+Adding tests to the MATLAB interface helps to ensure quality and verify that the software works as intended. To run the MATLAB interface tests, the following software must be installed locally:  
+
+1. [MATLAB](https://www.mathworks.com/products/get-matlab.html)
+2. [MATLAB Interface to Apache Arrow](https://github.com/mathworks/arrow/tree/main/matlab)  
+
+## Running Tests Locally  
+
+To run the MATLAB interface tests on a local machine, start MATLAB and then `cd` to the directory under `matlab/test` where the test files of interest reside. After changing to the test directory, call the `runtests` command to run your tests:  
+
+```matlab
+% To run a single test file
+>> runtests(testFileName) % For example: runtests("tArray.m")
+
+% To run all tests recursively under a test directory
+>> runtests(testFolderName, IncludeSubfolders = true) % For example: runtests('matlab\test', IncludeSubfolders = true)
+```
+
+To learn more about `runtests`, please check [the documentation](https://www.mathworks.com/help/matlab/ref/runtests.html).  
+
+## Writing Tests  
+
+All tests for the MATLAB interface should use the [MATLAB Class-Based Unit Testing Framework](https://www.mathworks.com/help/matlab/class-based-unit-tests.html) (i.e. they should use [`matlab.unittest.TestCase`](https://www.mathworks.com/help/matlab/ref/matlab.unittest.testcase-class.html)).  
+
+Included below is a simple example of a MATLAB test:  
+
+```matlab
+classdef tStringArray < matlab.unittest.TestCase
+    methods(Test)
+        function TestBasicStringArray(testCase)
+            % Verify that an `arrow.array.StringArray` can be created from
+            % a basic MATLAB `string` array using the `arrow.array` gateway
+            % construction function.
+
+            % Create a basic MATLAB `string` array.
+            matlabArray = ["A" ,"B", "C"];
+            % Create an `arrow.array.StringArray` from the MATLAB `string`
+            % array by using the `arrow.array` gateway construction function.
+            arrowArray = arrow.array(matlabArray);
+            % Verify the class of `arrowArray` is `arrow.array.StringArray`.
+            testCase.verifyEqual(string(class(arrowArray)), "arrow.array.StringArray");
+            % Verify `arrowArray` can be converted back into a MATLAB `string` array.
+            testCase.verifyEqual(arrowArray.toMATLAB, ["A"; "B"; "C"]);
+        end
+    end
+end
+```
+
+More test examples can be found in the `matlab/test` directory.  
+
+### Testing Best Practices  
+
+- Use descriptive names for your test cases.
+- Focus on testing one software "behavior" in each test case.
+- Test with both "expected" and "unexpected" inputs.
+- Add a comment at the beginning of each test case which describes what the test case is verifying.
+- Treat test code like any other code (i.e. use clear variable names, write helper functions, make use of abstraction, etc.)
+- Follow existing patterns when adding new test cases to an existing test class.
+
+## Test Case Design Guidelines  
+
+When adding new tests, it is recommended to, at a minimum, ensure that real-world workflows work as expected.  
+
+If a change cannot be easily tested at the MATLAB interface level (e.g. you would like to test the behavior of a C++ `Proxy` method), consider creating a `Proxy` instance manually from a MATLAB test case and calling relevant methods on the `Proxy`.  
+
+An example of this approach to test C++ `Proxy` code can be found in [`matlab/test/arrow/tabular/tTabularInternal.m`](https://github.com/apache/arrow/blob/main/matlab/test/arrow/tabular/tTabularInternal.m).  
+
+## Test Organization  
+
+All tests for the MATLAB interface are located under the `matlab/test` directory.  
+
+To make it easy to find the test files which correspond to specific source files, the MATLAB interface tests are organized using the following rules:  
+
+- Source and test directories follow an (approximately) "parallel" structure. For example, the test directory [`test/arrow/array`](https://github.com/apache/arrow/tree/main/matlab/test/arrow/array) contains tests for the source directory [`src/matlab/+arrow/+array`](https://github.com/apache/arrow/tree/main/matlab/src/matlab/%2Barrow/%2Barray).  
+- One test file maps to one source file. For example, [`test/arrow/array/tArray.m`](https://github.com/apache/arrow/blob/main/matlab/test/arrow/array/tArray.m) is the test file for [`src/matlab/+arrow/+array/Array.m`](https://github.com/apache/arrow/blob/main/matlab/src/matlab/%2Barrow/%2Barray/Array.m).  
+- **Note**: In certain scenarios, it can make sense to diverge from these rules. For example, if a particular class is very complex and contains a lot of divergent functionality (which we generally try to avoid), we might choose to split the testing into several "focused" test files (e.g. one for testing the class display, one for testing the properties, and one for testing the methods).  
+
+## Continuous Integration (CI) Workflows  
+
+The Apache Arrow project uses [GitHub Actions](https://github.com/features/actions) as its primary [Continuous Integration (CI)](https://en.wikipedia.org/wiki/Continuous_integration) platform.  
+
+Creating a pull request that changes code in the MATLAB interface will automatically trigger [MATLAB CI Workflows](https://github.com/apache/arrow/actions/workflows/matlab.yml) to be run. These CI workflows will run all tests located under the `matlab/test` directory.  
+
+Reviewers will generally expect the MATLAB CI Workflows to be passing successfully before they will consider merging a pull request.  
+
+If you are having trouble understanding CI failures, you can always ask a reviewer or another community member for help.  
+
+## Code Coverage Goals  
+
+When making changes to the MATLAB interface, please do your best to add tests to cover all changed lines, conditions, and decisions.  
+
+Before making a pull request, please check the code coverage for any changed code. If possible, it can be helpful to explicitly comment on the code coverage in your pull request description.  
+
+Although we strive for high code coverage, it is understood that some code cannot be reasonably tested (e.g. an "un-reachable" branch in a `switch` condition on an enumeration value).
+
+### How to Check Code Coverage  
+
+***Requirement:** MATLAB R2023b or later.*  
+
+To generate a MATLAB code coverage report, the [`ReportCoverageFor`](https://www.mathworks.com/help/matlab/ref/runtests.html#mw_764c9db7-6823-439f-a77d-7fd25a03d20e) name-value pair argument can be supplied to the [`runtests`](https://www.mathworks.com/help/matlab/ref/runtests.html) command. Before generating the code coverage report, remember to add your source file directory to the [MATLAB Search Path](https://www.mathworks.com/help/matlab/matlab_env/what-is-the-matlab-search-path.html).  
+
+```matlab  
+>> addpath( genpath(<your local arrow/matlab>) ) % `genpath` is needed to include all subdirectories and add them to MATLAB search path.
+>> runtests(testFilePath/testFolderPath, 'ReportCoverageFor', sourceFilePath/sourceFolderPath, 'IncludeSubfolders', true/false);  
+```
+
+Below is an example of running all tests under `matlab/test` and getting the MATLAB code coverage report for all files under `matlab/src/matlab`.
+
+```matlab  
+>> addpath(genpath("C:\TryCodeCoverage\arrow\matlab"))
+>> runtests('C:\TryCodeCoverage\arrow\matlab\test', 'ReportCoverageFor', 'C:\TryCodeCoverage\arrow\matlab\src\matlab\', 'IncludeSubfolders', true);
+```
+
+## Tips  
+
+### Debugging Code Coverage Results  
+
+If the `runtests` command with `RepoCoverageFor` reports confusing or incorrect code coverage results, this could be due to caching or other issues. As a workaround, you can try setting a breakpoint in your source file, and then re-run the tests. This step can be used to verify that your source file is being executed by the tests.  

From efd945d437a8df12b200c1da20573216f2a17feb Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Mon, 30 Oct 2023 21:22:05 -0700
Subject: [PATCH 654/749] MINOR: [Docs][Python] Add more text around PyArrow
 build types (#38522)

### Rationale for this change

It's not very clear that PyArrow will get built in release mode even if the linked Arrow C++ is built in debug mode. I added some text to the docs to make it more clear. An example of a user running into this is https://github.com/apache/arrow/issues/38519.

### Are these changes tested?

No as they're just minor docs changes.

### Are there any user-facing changes?

This adds text to the Python docs.

Authored-by: Bryce Mecum <petridish@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/developers/python.rst | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/docs/source/developers/python.rst b/docs/source/developers/python.rst
index e4699a65e211e..be9fac067cb52 100644
--- a/docs/source/developers/python.rst
+++ b/docs/source/developers/python.rst
@@ -405,6 +405,12 @@ set the ``PYARROW_PARALLEL`` environment variable.
 If you wish to delete stale PyArrow build artifacts before rebuilding, navigate
 to the ``arrow/python`` folder and run ``git clean -Xfd .``.
 
+By default, PyArrow will be built in release mode even if Arrow C++ has been
+built in debug mode. To create a debug build of PyArrow, run
+``export PYARROW_BUILD_TYPE=debug`` prior to running  ``python setup.py
+build_ext --inplace`` above. A ``relwithdebinfo`` build can be created
+similarly.
+
 Now you are ready to install test dependencies and run `Unit Testing`_, as
 described above.
 
@@ -434,6 +440,9 @@ Debugging
 
 Since pyarrow depends on the Arrow C++ libraries, debugging can
 frequently involve crossing between Python and C++ shared libraries.
+For the best experience, make sure you've built both Arrow C++
+(``-DCMAKE_BUILD_TYPE=Debug``) and PyArrow (``export PYARROW_BUILD_TYPE=debug``)
+in debug mode.
 
 Using gdb on Linux
 ~~~~~~~~~~~~~~~~~~

From 66844e9f16e9cf26bd5d260de9150973f94f4d5a Mon Sep 17 00:00:00 2001
From: Kevin Gurney <kgurney@mathworks.com>
Date: Tue, 31 Oct 2023 14:16:07 -0400
Subject: [PATCH 655/749] GH-38361: Add validation logic for `offsets` and
 `values` to `arrow.array.ListArray.fromArrays` (#38531)

### Rationale for this change

This pull request adds a new `ValidationMode` name-value pair to the `arrow.array.ListArray.fromArrays` function. This allows client code to validate whether provided `offsets` and `values` are valid.

### What changes are included in this PR?

1. Added a new name-value pair `ValidationMode = "None" | "Minimal" (default) | "Full".` to the `arrow.array.ListArrays.fromArrays` function. If `ValidationMode` is set to `"Minimal"` or `"Full"` and the provided `offsets` and `values` arrays are invalid, then an error will be thrown when calling the `arrow.array.ListArrays.fromArrays` function.
2. Set the default `ValidationMode` for `arrow.array.ListArray.fromArrays` to `"Minimal"` to balance usability and performance when creating `ListArray`s. Hopefully, this should help more MATLAB users navigate the complexities of creating `ListArray`s "from scratch" using `offsets` and `values` arrays.
3. Added a new `arrow.array.ValidationMode` enumeration class. This is used as the type of the `ValidationMode` name-value pair on the `arrow.array.ListArray.fromArrays` function.

Supported values for `arrow.array.ValidationMode` include:
* `arrow.array.ValidationMode.None` - Do no validation checks on the given `Array`.
* `arrow.array.ValidationMode.Minimal` - Do relatively inexpensive validation checks on the given `Array`. Delegates to the C++ [`Array::Validate`](https://github.com/apache/arrow/blob/efd945d437a8df12b200c1da20573216f2a17feb/cpp/src/arrow/array/array_base.h#L200) method under the hood.
* `arrow.array.ValidationMode.Full` - Do expensive / robust validation checks on the given `Array`. Delegates to the C++ [`Array::ValidateFull`](https://github.com/apache/arrow/blob/efd945d437a8df12b200c1da20573216f2a17feb/cpp/src/arrow/array/array_base.h#L209) method under the hood.

**Example**
```matlab
>> offsets = arrow.array(int32([0, 1, 2, 3, 4, 5]))

offsets =

  Int32Array with 6 elements and 0 null values:

    0 | 1 | 2 | 3 | 4 | 5

>> values = arrow.array([1, 2, 3])

values =

  Float64Array with 3 elements and 0 null values:

    1 | 2 | 3

>> array = arrow.array.ListArray.fromArrays(offsets, values, ValidationMode="full")
Error using  .
Offset invariant failure: offset for slot 4 out of bounds: 4 > 3

Error in arrow.array.ListArray.fromArrays (line 108)
            proxy.validate(struct(ValidationMode=uint8(opts.ValidationMode)));

>> array = arrow.array.ListArray.fromArrays(offsets, values, ValidationMode="minimal")
Error using  .
Length spanned by list offsets (5) larger than values array (length 3)

Error in arrow.array.ListArray.fromArrays (line 108)
            proxy.validate(struct(ValidationMode=uint8(opts.ValidationMode)));

>> array = arrow.array.ListArray.fromArrays(offsets, values, ValidationMode="none")

array =

  ListArray with 5 elements and 0 null values:

<Invalid array: Length spanned by list offsets (5) larger than values array (length 3)>
```

### Are these changes tested?

Yes.

1. Added new test cases for verifying `ValidationMode` behavior to `tListArray.m`.

### Are there any user-facing changes?

Yes.

1. Client code can now control validation behavior when calling `arrow.array.ListArray.fromArrays` by using the new `ValidationMode` name-value pair.
2. By default, an error will now be thrown by `arrow.array.ListArray.fromArrays` for certain invalid combinations of `offsets` and `values`. In other words, `arrow.array.ListArray.fromArrays` will call the C++ method `Array::Validate` by default, which corresponds to `arrow.array.ValidationMode.Minimal`.
3. Client code can now create `arrow.array.ValidationMode` enumeration values.

**This PR includes breaking changes to public APIs.**

Previously, all `offsets` and `values` would be accepted by the `arrow.array.ListArray.fromArrays` function. However, this pull request changes the default behavior to call the C++ [`Array::Validate`](https://github.com/apache/arrow/blob/efd945d437a8df12b200c1da20573216f2a17feb/cpp/src/arrow/array/array_base.h#L200) method under the hood, which means that some previously accepted `offsets` and `values` will now result in a validation error. This can be worked around by setting `ValidationMode` to `"None"` when calling `arrow.array.ListArray.fromArrays`.

### Future Directions

1. Currently `ValidationMode` has only been added to the `arrow.array.ListArray.fromArrays` method. However, in the future, it may make sense to generalize validation behavior and provide `ValidationMode` on other `fromMATLAB` and `fromArrays` methods for other `Array` types. We may also want to add a stand-alone `validate` method on all `arrow.array.Array` classes (#38532). We decided to start with `ListArray` as an incremental first step since we suspect creating valid `ListArray`s from `offsets` and `values` will generally be more error prone than creating simpler `Array` types like `Float64Array` or `StringArray`.

### Notes

1. We chose to set the default `ValidationMode` value to `arrow.array.ValidationMode.Minimal` to balance usability and performance. If this ends up causing major performance issues in common workflows, then we could consider changing this to `arrow.array.ValidationMode.None` in the future.
2. Thank you @ sgilmore10 for your help with this pull request!
* Closes: #38361

Authored-by: Kevin Gurney <kgurney@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../arrow/matlab/array/proxy/list_array.cc    |  36 ++++++
 .../cpp/arrow/matlab/array/proxy/list_array.h |   1 +
 .../cpp/arrow/matlab/array/validation_mode.h  |  30 +++++
 matlab/src/cpp/arrow/matlab/error/error.h     |   3 +
 matlab/src/matlab/+arrow/+array/ListArray.m   |   7 +-
 .../src/matlab/+arrow/+array/ValidationMode.m |  24 ++++
 matlab/test/arrow/array/tListArray.m          | 105 ++++++++++++++++++
 7 files changed, 204 insertions(+), 2 deletions(-)
 create mode 100644 matlab/src/cpp/arrow/matlab/array/validation_mode.h
 create mode 100644 matlab/src/matlab/+arrow/+array/ValidationMode.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
index fc75e55dd6012..941e658c25127 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.cc
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include "arrow/matlab/array/validation_mode.h"
 #include "arrow/matlab/array/proxy/list_array.h"
 #include "arrow/matlab/array/proxy/numeric_array.h"
 #include "arrow/matlab/array/proxy/wrap.h"
@@ -26,6 +27,7 @@ namespace arrow::matlab::array::proxy {
     ListArray::ListArray(std::shared_ptr<arrow::ListArray> list_array) : proxy::Array{std::move(list_array)} {
         REGISTER_METHOD(ListArray, getValues);
         REGISTER_METHOD(ListArray, getOffsets);
+        REGISTER_METHOD(ListArray, validate);
     }
 
     libmexclass::proxy::MakeResult ListArray::make(const libmexclass::proxy::FunctionArguments& constructor_arguments) {
@@ -100,4 +102,38 @@ namespace arrow::matlab::array::proxy {
         mda::ArrayFactory factory;
         context.outputs[0] = factory.createScalar(offsets_int32_array_proxy_id);
     }
+
+    void ListArray::validate(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+        mda::StructArray args = context.inputs[0];
+        const mda::TypedArray<std::uint8_t> validation_mode_mda = args[0]["ValidationMode"];
+        const auto validation_mode_integer = uint8_t(validation_mode_mda[0]);
+        // Convert integer representation to ValidationMode enum.
+        const auto validation_mode = static_cast<ValidationMode>(validation_mode_integer);
+        switch (validation_mode) {
+            case ValidationMode::None: {
+                // Do nothing.
+                break;
+            }
+            case ValidationMode::Minimal: {
+                MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(array->Validate(),
+                        context,
+                        error::ARRAY_VALIDATE_MINIMAL_FAILED);
+                break;
+            }
+            case ValidationMode::Full: {
+                MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(array->ValidateFull(),
+                        context,
+                        error::ARRAY_VALIDATE_FULL_FAILED);
+                break;
+            }
+            default: {
+                // Throw an error if an unsupported enumeration value is provided.
+                const auto msg = "Unsupported ValidationMode enumeration value: " + std::to_string(validation_mode_integer);
+                context.error = libmexclass::error::Error{error::ARRAY_VALIDATE_UNSUPPORTED_ENUM, msg};
+                return;
+            }
+        }
+    }
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
index 8db6b6bf1d632..1f34b11406594 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/list_array.h
@@ -32,6 +32,7 @@ class ListArray : public arrow::matlab::array::proxy::Array {
     protected:
         void getValues(libmexclass::proxy::method::Context& context);
         void getOffsets(libmexclass::proxy::method::Context& context);
+        void validate(libmexclass::proxy::method::Context& context);
 
     };
 
diff --git a/matlab/src/cpp/arrow/matlab/array/validation_mode.h b/matlab/src/cpp/arrow/matlab/array/validation_mode.h
new file mode 100644
index 0000000000000..92e10f47aa4e7
--- /dev/null
+++ b/matlab/src/cpp/arrow/matlab/array/validation_mode.h
@@ -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.
+
+#pragma once
+
+#include <cstdint>
+
+namespace arrow::matlab::array {
+
+    enum class ValidationMode : uint8_t {
+        None    = 0,
+        Minimal = 1,
+        Full    = 2
+    };
+
+}
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 33e80bca8cc5a..5aa8f05c8c315 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -203,4 +203,7 @@ namespace arrow::matlab::error {
     static const char* BUFFER_VIEW_OR_COPY_FAILED = "arrow:buffer:ViewOrCopyFailed";
     static const char* ARRAY_PRETTY_PRINT_FAILED = "arrow:array:PrettyPrintFailed";
     static const char* TABULAR_GET_ROW_AS_STRING_FAILED = "arrow:tabular:GetRowAsStringFailed";
+    static const char* ARRAY_VALIDATE_MINIMAL_FAILED = "arrow:array:ValidateMinimalFailed";
+    static const char* ARRAY_VALIDATE_FULL_FAILED = "arrow:array:ValidateFullFailed";
+    static const char* ARRAY_VALIDATE_UNSUPPORTED_ENUM = "arrow:array:ValidateUnsupportedEnum";
 }
diff --git a/matlab/src/matlab/+arrow/+array/ListArray.m b/matlab/src/matlab/+arrow/+array/ListArray.m
index f8fd934b7c448..9a93c39ec6193 100644
--- a/matlab/src/matlab/+arrow/+array/ListArray.m
+++ b/matlab/src/matlab/+arrow/+array/ListArray.m
@@ -79,8 +79,9 @@
                 offsets (1, 1) arrow.array.Int32Array
                 values (1, 1) arrow.array.Array
                 opts.Valid
+                opts.ValidationMode (1, 1) arrow.array.ValidationMode = arrow.array.ValidationMode.Minimal
             end
-            
+
             import arrow.internal.validate.parseValid
 
             if nargin < 2
@@ -100,9 +101,11 @@
                 ValuesProxyID=valuesProxyID, ...
                 Valid=validElements ...
             );
-            
+
             proxyName = "arrow.array.proxy.ListArray";
             proxy = arrow.internal.proxy.create(proxyName, args);
+            % Validate the provided offsets and values.
+            proxy.validate(struct(ValidationMode=uint8(opts.ValidationMode)));
             array = arrow.array.ListArray(proxy);
         end
 
diff --git a/matlab/src/matlab/+arrow/+array/ValidationMode.m b/matlab/src/matlab/+arrow/+array/ValidationMode.m
new file mode 100644
index 0000000000000..3442bcccf725b
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/ValidationMode.m
@@ -0,0 +1,24 @@
+% Mode to use for Array validation.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef ValidationMode < uint8
+    enumeration
+        None    (0)
+        Minimal (1)
+        Full    (2)
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/tListArray.m b/matlab/test/arrow/array/tListArray.m
index 1ebf66e2f0999..07304eb384299 100644
--- a/matlab/test/arrow/array/tListArray.m
+++ b/matlab/test/arrow/array/tListArray.m
@@ -23,6 +23,7 @@
 
     properties (TestParameter)
         TestArrowArray
+        TestValidationModeArray
     end
 
     methods (TestParameterDefinition, Static)
@@ -113,6 +114,29 @@
             );
         end
 
+        function TestValidationModeArray = initializeTestValidationModeArray()
+            %% Valid ListArray
+            Offsets = arrow.array(int32([0, 1, 2, 3]));
+            Values = arrow.array([1, 2, 3]);
+
+            TestValidationModeArray.ValidList = struct( ...
+                Offsets=Offsets, ...
+                Values=Values, ...
+                Valid=true ...
+            );
+
+            %% Invalid ListArray
+            % Incorrect number of offsets (length should be 1 more than the number of Values).
+            Offsets = arrow.array(int32([0, 1, 2, 3, 4, 5]));
+            Values = arrow.array([1, 2, 3]);
+
+            TestValidationModeArray.InvalidList = struct( ...
+                Offsets=Offsets, ...
+                Values=Values, ...
+                Valid=false ...
+            );
+        end
+
     end
 
     methods (Test)
@@ -160,6 +184,87 @@ function TestErrorIfEmptyOffsets(testCase)
             testCase.verifyError(fcn, "arrow:array:ListArrayFromArraysFailed");
         end
 
+        function TestValidationModeDefault(testCase, TestValidationModeArray)
+            % Verify that the default ValidationMode value for the
+            % arrow.array.ListArray.fromArrays method is
+            % arrow.array.ValidationMode.Minimal.
+            offsets = TestValidationModeArray.Offsets;
+            values = TestValidationModeArray.Values;
+            valid = TestValidationModeArray.Valid;
+            fcn = @() arrow.array.ListArray.fromArrays(offsets, values);
+            if valid
+                testCase.verifyWarningFree(fcn);
+            else
+                testCase.verifyError(fcn, "arrow:array:ValidateMinimalFailed");
+            end
+        end
+
+        function TestValidationModeNone(testCase, TestValidationModeArray)
+            % Verify that no error is thrown when supplying the
+            % ValidatationMode name-value pair, with a value of
+            % arrow.array.ValidationMode.None, to the
+            % arrow.array.ListArray.fromArrays method.
+            offsets = TestValidationModeArray.Offsets;
+            values = TestValidationModeArray.Values;
+            validationMode = arrow.array.ValidationMode.None;
+            fcn = @() arrow.array.ListArray.fromArrays(offsets, values, ValidationMode=validationMode);
+            testCase.verifyWarningFree(fcn);
+        end
+
+        function TestValidationModeMinimal(testCase, TestValidationModeArray)
+            % Verify that an error of type arrow:array:ValidateMinimalFailed
+            % is thrown when supplying the ValidatationMode name-value pair,
+            % with a value of arrow.array.ValidationMode.Minimal, to the
+            % arrow.array.ListArray.fromArrays method, if the provided offsets
+            % and values arrays are invalid.
+            offsets = TestValidationModeArray.Offsets;
+            values = TestValidationModeArray.Values;
+            valid = TestValidationModeArray.Valid;
+            validationMode = arrow.array.ValidationMode.Minimal;
+            fcn = @() arrow.array.ListArray.fromArrays(offsets, values, ValidationMode=validationMode);
+            if valid
+                testCase.verifyWarningFree(fcn);
+            else
+                testCase.verifyError(fcn, "arrow:array:ValidateMinimalFailed");
+            end
+        end
+
+        function TestValidationModeFull(testCase, TestValidationModeArray)
+            % Verify that an error of type arrow:array:ValidateFullFailed
+            % is thrown when supplying the ValidatationMode name-value pair,
+            % with a value of arrow.array.ValidationMode.Full, to the
+            % arrow.array.ListArray.fromArrays method, if the provided offsets
+            % and values arrays are invalid.
+            offsets = TestValidationModeArray.Offsets;
+            values = TestValidationModeArray.Values;
+            validationMode = arrow.array.ValidationMode.Full;
+            valid = TestValidationModeArray.Valid;
+            fcn = @() arrow.array.ListArray.fromArrays(offsets, values, ValidationMode=validationMode);
+            if valid
+                testCase.verifyWarningFree(fcn);
+            else
+                testCase.verifyError(fcn, "arrow:array:ValidateFullFailed");
+            end
+        end
+
+        function TestValidationModeUnsupportedEnum(testCase)
+            % Verify that an error of type arrow:array:ValidateUnsupportedEnum
+            % is thrown when an unsupported integer enumeration value is
+            % supplied for the ValidatationMode parameter to the internal
+            % C++ ListArray Proxy validate method.
+            offsets = arrow.array.Int32Array.fromMATLAB(int32([0, 1, 2]));
+            values = arrow.array.Float64Array.fromMATLAB([1, 2, 3]);
+            array = arrow.array.ListArray.fromArrays(offsets, values);
+            % Get the underlying Proxy instance from the ListArray.
+            proxy = array.Proxy;
+            % Call the internal Proxy method "validate" with an unsupported
+            % integer ValidationMode value.
+            validationMode = uint8(3);
+            args = struct(ValidationMode=validationMode);
+            fcn = @() proxy.validate(args);
+            testCase.verifyError(fcn, "arrow:array:ValidateUnsupportedEnum");
+        end
+
     end
 
 end

From aaf01e82a9ae64d6f473302d5f1df24d8a9d895b Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 31 Oct 2023 14:41:16 -0400
Subject: [PATCH 656/749] GH-38419: [MATLAB] Implement a `ClassTypeValidator`
 class that validates a MATLAB `cell` array contains only values of the same
 class type.   (#38530)

### Rationale for this change

Adding this `ClassTypeValidator` class is a step towards implementing the `arrow.array.ListArray.fromMATLAB()` method for creating `ListArray`s whose `ValueType`s is either a numeric, boolean, string, time32, or time64 array from a MATLAB `cell` array.

### What changes are included in this PR?

Added an abstract class `arrow.array.internal.list.ListTypeValidator` that defines three abstract methods:
1. `validateElement(obj, element)`
2. `length = getElementLength(obj, element)`
3. `C = reshapeCellElements(obj, C)`

These abstract methods will be used in `ListArray.fromMATLAB` to create `ListArray`s from MATLAB `cell` arrays.  Below is a  "pared-down" version of how the `fromMATLAB` algorithm will work:

```matlab
function listArray = fromMATLAB(C)

    % Create the appropriate ListTypeValidator from the
    % first element in the cell array C
    validator = createListTypeValidator(C{1});

    % Pre-allocate a uint32 vector for the offsets
    numRows = numel(C);
    offsets = zeros([numRows 1], "int32");

    for ii = 1:numRows
         cellElement = C{ii};

        % Validate cellElement can be used to create
        % one row in the ListArray, i.e. For example,
        % if the first element in C was a double, verify
        % cellElement is also a double.
        validator.validateElement(cellElement);

        % Determine how much to increment the
        % last offset value by to set the offset at index ii + 1.
        length = validator.getElementLEngth(cellElement);
        offsets[ii + 1] = length + offsets[i];
    end

    % Reshape the elements in cell array C so that they
    % can be vertically concatenated.
    C = validator.reshapeCellElements(C);

    % Extract the cell array elements and vertically concatenate
    % them into one array. Then pass this array to arrow.array().
    values = vertcat(C{:});
    valueArray = arrow.array(values);

    % Create an Int32Array from offsets
    offsetArray = arrow.array(offsets);

    listArray = arrow.array.ListArray(Values=valueArray, Offsets=offsetArray)
end
```
The concrete type of the `validator` object is created based on the first element in the `cell` array `C`.  We use the first element to determine what kind of `ListArray` to construct from the input `cell` array.

--

Added a concrete class called `arrow.array.internal.list.ClassTypeValidator`, which inherits from `arrow.array.internal.list.ListTypeValidator`:

1. `validateElement(obj, element)` - Throws an error if the element's class type does not match the expected value.
2.  `length = getElementLength(obj, element)` - Returns the number of elements in the input array.
3.  `C = reshapeCellElements(obj, C)` - Reshapes all elements in the `cell` array `C` to be column vectors.

`ClassTypeValidator` will be used when creating `ListArray`s from MATLAB `cell` arrays containing "primitive types", such as numerics, strings, and durations.

### Are these changes tested?

Yes. I added a new class called `tClassTypeValidator.m`.

### Are there any user-facing changes?

No.

### Future Directions

1. #38420
2. #38417
3. #38354
* Closes: #38419

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/+list/ClassTypeValidator.m      | 47 +++++++++
 .../+arrow/+array/+internal/+list/Validator.m | 28 ++++++
 .../arrow/array/list/tClassTypeValidator.m    | 99 +++++++++++++++++++
 3 files changed, 174 insertions(+)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/ClassTypeValidator.m
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
 create mode 100644 matlab/test/arrow/array/list/tClassTypeValidator.m

diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/ClassTypeValidator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/ClassTypeValidator.m
new file mode 100644
index 0000000000000..419560b8d566b
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/ClassTypeValidator.m
@@ -0,0 +1,47 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef ClassTypeValidator < arrow.array.internal.list.Validator
+    
+    properties (GetAccess=public, SetAccess=private)
+        ClassName(1, 1) string
+    end
+    
+    methods
+        function obj = ClassTypeValidator(data)
+            obj.ClassName = class(data);
+        end
+        
+        function validateElement(obj, element)
+           if ~isa(element, obj.ClassName)
+               id = "arrow:array:list:ClassTypeMismatch";
+               fmt = "Expected all cell array elements to have class type " + ...
+                   """%s"", but encountered an element whose class type is" + ...
+                   " ""%s"".";
+               msg = compose(fmt, obj.ClassName, class(element));
+              error(id, msg);
+           end
+        end
+
+        function length = getElementLength(~, element)
+            length = numel(element);
+        end
+
+        function C = reshapeCellElements(~, C)
+            C = cellfun(@(elem) reshape(elem, [], 1), C, UniformOutput=false);
+        end
+    end
+end
+
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
new file mode 100644
index 0000000000000..0178632bb6dd2
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
@@ -0,0 +1,28 @@
+%VALIDATOR Defines interface used to validate MATLAB cell arrays
+%can be converted into Arrow List arrays.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef Validator
+
+    methods (Abstract)
+        tf = validateElement(obj, element)
+
+        length = getElementLength(obj, element)
+
+        C = reshapeCellElements(obj, element)
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/list/tClassTypeValidator.m b/matlab/test/arrow/array/list/tClassTypeValidator.m
new file mode 100644
index 0000000000000..ae6fe7c855754
--- /dev/null
+++ b/matlab/test/arrow/array/list/tClassTypeValidator.m
@@ -0,0 +1,99 @@
+%TCLASSTYPEVALIDATOR Unit tests for arrow.array.internal.list.ClassTypeValidator
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tClassTypeValidator < matlab.unittest.TestCase
+
+    methods (Test)
+        function Smoke(testCase)
+            import arrow.array.internal.list.ClassTypeValidator
+            validator = ClassTypeValidator("Sample Data");
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+        end
+
+        function ClassNameGetter(testCase)
+            % Verify the ClassName getter returns the expected scalar
+            % string.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = ClassTypeValidator("Sample Data");
+            testCase.verifyEqual(validator.ClassName, "string");
+        end
+
+        function ClassNameNoSetter(testCase)
+            % Verify ClassName property is not settable.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = ClassTypeValidator(1);
+            fcn = @() setfield(validator, "ClassName", "duration");
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ValidateElementNoThrow(testCase) %#ok<MANU>
+            % Verify validateElement does not throw an exception
+            % if class type of the input element matches the ClassName
+            % property value.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = ClassTypeValidator(1);
+            validator.validateElement(2);
+            validator.validateElement([1 2 3]);
+            validator.validateElement([1; 2; 3; 3]);
+            validator.validateElement([5 6; 7 8]);
+            validator.validateElement(double.empty(0, 1));
+        end
+
+        function ValidateElementClassTypeMismatchError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:ClassTypeMismatch" if the input
+            % element's class type does not match the ClassName property
+            % value.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            % validator will expect all elements to be of type double, since "1" is a double.
+            validator = ClassTypeValidator(1);
+            errorID = "arrow:array:list:ClassTypeMismatch";
+            testCase.verifyError(@() validator.validateElement("A"), errorID);
+            testCase.verifyError(@() validator.validateElement(uint8([1 2])), errorID);
+            testCase.verifyError(@() validator.validateElement(datetime(2023, 1, 1)), errorID);
+        end
+
+        function GetElementLength(testCase)
+            % Verify getElementLength returns the expected length values
+            % for the given input arrays.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = ClassTypeValidator(1);
+            testCase.verifyEqual(validator.getElementLength(2), 1);
+            testCase.verifyEqual(validator.getElementLength([1 2; 3 4]), 4);
+            testCase.verifyEqual(validator.getElementLength(double.empty(1, 0)), 0);
+        end
+
+        function ReshapeCellElements(testCase)
+            % Verify reshapeCellElements reshapes all elements in the input
+            % cell array into column vectors.
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = ClassTypeValidator(1);
+            C = {[1 2 3], [4; 5], [6 7; 8 9], double.empty(1, 0), 10};
+            act = validator.reshapeCellElements(C);
+            exp = {[1; 2; 3], [4; 5], [6; 8; 7; 9], double.empty(0, 1), 10};
+            testCase.verifyEqual(act, exp);
+        end
+
+    end
+
+end
\ No newline at end of file

From c49e24273160ac1ce195f02dbd14acd7d0f6945e Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Tue, 31 Oct 2023 16:03:23 -0400
Subject: [PATCH 657/749] GH-38420: [MATLAB] Implement a `DatetimeValidator`
 class that validates a MATLAB `cell` array contains only values of zoned or
 unzoned `datetime`s (#38533)

### Rationale for this change

This is a followup to #38419.

Adding this `DatetimeTypeValidator` class is a step towards implementing the `arrow.array.ListArray.fromMATLAB()` method for creating `ListArray`s whose `ValueType`s is a timestamp array from a MATLAB `cell` array.

This validator will ensure the cell array contain only `datetime`s or unzoned `datetime`s. This is a requirement when creating a `List` of `Timestamp`s because two MATLAB `datetime`s can only be concatenated together if they are either both zoned or both unzoned:

```matlab
>> d1 = datetime(2023, 10, 31, TimeZone="America/New_York");
>> d2 =datetime(2023, 11, 1);
>> [d1; d2]
Error using datetime/vertcat
Unable to concatenate a datetime array that has a time zone with one that does not have a time
zone.
```

### What changes are included in this PR?

Added a new MATLAB class called `arrow.array.internal.list.DatetimeValidator`, which inherits from `arrow.array.internal.list.ClassTypeValidator`.

 This new class defines one property called `HasTimeZone`, which is a scalar `logical` indicating if the validator expects all `datetime`s to be zoned or not.

Additionally, `DatetimeValidator` overrides the `validateElement` method. It first call's `ClassTypeValidator`'s implementation of `validateElement` to verify the input element is a `datetime`. If so, it then confirms that the input `datetime`'s TimeZone property is empty or nonempty, based on the validator's `HasTimeZone`  property value.

### Are these changes tested?

Yes, I added a new test class called `tDatetimeValidator.m`.

### Are there any user-facing changes?

No.

### Future Directions

1. #38417
2. #38354
* Closes: #38420

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+internal/+list/DatetimeValidator.m       |  49 +++++
 .../arrow/array/list/tDatetimeValidator.m     | 181 ++++++++++++++++++
 2 files changed, 230 insertions(+)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/DatetimeValidator.m
 create mode 100644 matlab/test/arrow/array/list/tDatetimeValidator.m

diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/DatetimeValidator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/DatetimeValidator.m
new file mode 100644
index 0000000000000..f8665d822795e
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/DatetimeValidator.m
@@ -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.
+
+classdef DatetimeValidator < arrow.array.internal.list.ClassTypeValidator
+
+    properties (GetAccess=public, SetAccess=private)
+        Zoned (1, 1) logical = false
+    end
+
+    methods
+        function obj = DatetimeValidator(date)
+            arguments
+                date(:, :) datetime
+            end
+            obj@arrow.array.internal.list.ClassTypeValidator(date);
+            obj.Zoned = ~isempty(date.TimeZone);
+        end
+
+        function validateElement(obj, element)
+            validateElement@arrow.array.internal.list.ClassTypeValidator(obj, element);
+            % zoned and obj.Zoned must be equal because zoned
+            % and unzoned datetimes cannot be concatenated together.
+            zoned = ~isempty(element.TimeZone);
+            if obj.Zoned && ~zoned
+                errorID = "arrow:array:list:ExpectedZonedDatetime";
+                msg = "Expected all datetime elements in the cell array to " + ...
+                    "have a time zone but encountered a datetime array without a time zone";
+                error(errorID, msg);
+            elseif ~obj.Zoned && zoned
+                errorID = "arrow:array:list:ExpectedUnzonedDatetime";
+                msg = "Expected all datetime elements in the cell array to " + ...
+                    "not have a time zone but encountered a datetime array with a time zone";
+                error(errorID, msg);
+            end
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/list/tDatetimeValidator.m b/matlab/test/arrow/array/list/tDatetimeValidator.m
new file mode 100644
index 0000000000000..06d18bd92f747
--- /dev/null
+++ b/matlab/test/arrow/array/list/tDatetimeValidator.m
@@ -0,0 +1,181 @@
+%TDATETIMEVALIDATOR Unit tests for
+%arrow.array.internal.list.DatetimeValidator
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tDatetimeValidator < matlab.unittest.TestCase
+
+    methods (Test)
+        function Smoke(testCase)
+            import arrow.array.internal.list.DatetimeValidator
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.DatetimeValidator");
+        end
+
+        function ClassNameGetter(testCase)
+            % Verify the ClassName getter returns the expected scalar
+            % string.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            testCase.verifyEqual(validator.ClassName, "datetime");
+        end
+
+        function ClassNameNoSetter(testCase)
+            % Verify ClassName property is not settable.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            fcn = @() setfield(validator, "ClassName", "duration");
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ZonedGetter(testCase)
+            % Verify the Zoned getter returns the expected scalar
+            % logical.
+
+            import arrow.array.internal.list.DatetimeValidator
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            testCase.verifyEqual(validator.Zoned, false);
+
+            validator = DatetimeValidator(datetime(2023, 10, 31, TimeZone="UTC"));
+            testCase.verifyEqual(validator.Zoned, true);
+        end
+
+        function ZonedNoSetter(testCase)
+            % Verify Zoned property is not settable.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            fcn = @() setfield(validator, "Zoned", true);
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+
+             validator = DatetimeValidator(datetime(2023, 10, 31, TimeZone="UTC"));
+            fcn = @() setfield(validator, "Zoned", false);
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ValidateElementNoThrow(testCase) %#ok<MANU>
+            % Verify validateElement does not throw an exception if:
+            %  1. the input element is a datetime
+            %  2. its TimeZone property is '' and Zoned = false
+            %  3. its TimeZone property is not empty and Zoned = true
+
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            validator.validateElement(datetime(2023, 11, 1));
+            validator.validateElement(datetime(2023, 11, 1) + days(0:2));
+            validator.validateElement(datetime(2023, 11, 1) + days(0:2)');
+            validator.validateElement(datetime.empty(0, 1));
+
+            validator = DatetimeValidator(datetime(2023, 10, 31, TimeZone="UTC"));
+            validator.validateElement(datetime(2023, 11, 1,  TimeZone="UTC"));
+            validator.validateElement(datetime(2023, 11, 1,  TimeZone="America/New_York") + days(0:2));
+            validator.validateElement(datetime(2023, 11, 1,  TimeZone="Pacific/Fiji") + days(0:2)');
+            emptyDatetime = datetime.empty(0, 1);
+            emptyDatetime.TimeZone = "Asia/Dubai";
+            validator.validateElement(emptyDatetime);
+        end
+
+        function ValidateElementExpectedZonedDatetimeError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:ExpectedZonedDatetime" if the input
+            % datetime is unzoned, but the validator expected all 
+            % datetimes to zoned.
+            import arrow.array.internal.list.DatetimeValidator
+
+            % validator will expect all elements to be zoned datetimes
+            % because the input datetime is zoned.
+            validator = DatetimeValidator(datetime(2023, 10, 31, TimeZone="UTC"));
+            errorID = "arrow:array:list:ExpectedZonedDatetime";
+            fcn = @() validator.validateElement(datetime(2023, 11, 1));
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function ValidateElementExpectedUnzonedDatetimeError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:ExpectedUnzonedDatetime" if the input
+            % datetime has a time zone, but the validator expected all 
+            % datetimes to be unzoned.
+            import arrow.array.internal.list.DatetimeValidator
+
+            % validator will expect all elements to be unzoned datetimes
+            % because the input datetime is not zoned.
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            errorID = "arrow:array:list:ExpectedUnzonedDatetime";
+            fcn = @() validator.validateElement(datetime(2023, 11, 1, TimeZone="America/New_York"));
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function ValidateElementClassTypeMismatchError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:ClassTypeMismatch" if the input
+            % element is not a datetime.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            errorID = "arrow:array:list:ClassTypeMismatch";
+            fcn = @() validator.validateElement(1);
+            testCase.verifyError(fcn, errorID);
+            fcn = @() validator.validateElement("A");
+            testCase.verifyError(fcn, errorID);
+            fcn = @() validator.validateElement(seconds(1));
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function GetElementLength(testCase)
+            % Verify getElementLength returns the expected length values
+            % for the given input arrays.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            length = validator.getElementLength(datetime.empty(0, 1));
+            testCase.verifyEqual(length, 0);
+            length = validator.getElementLength(datetime(2023, 11, 1));
+            testCase.verifyEqual(length, 1);
+            length = validator.getElementLength(datetime(2023, 11, 1) + days(0:2));
+            testCase.verifyEqual(length, 3);
+            length = validator.getElementLength(datetime(2023, 11, 1) + days([0 1; 2 3]));
+            testCase.verifyEqual(length, 4);
+        end
+
+        function ReshapeCellElements(testCase)
+            % Verify reshapeCellElements reshapes all elements in the input
+            % cell array into column vectors.
+            import arrow.array.internal.list.DatetimeValidator
+
+            validator = DatetimeValidator(datetime(2023, 10, 31));
+            date = datetime(2023, 10, 31);
+            
+            C = {date + days(0:2), ...
+                 date + days(3:4)', ...
+                 date + days([5 6; 7 8]), ...
+                 datetime.empty(1, 0)};
+
+            act = validator.reshapeCellElements(C);
+
+            exp = {date + days(0:2)', ...
+                   date + days(3:4)', ...
+                   date + days([5; 7; 6; 8]), ...
+                   datetime.empty(0, 1)};
+
+            testCase.verifyEqual(act, exp);
+        end
+
+    end
+
+end
\ No newline at end of file

From 57c028f3d1ef7841966225b3886205c2e92b4869 Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Wed, 1 Nov 2023 10:08:18 -0400
Subject: [PATCH 658/749] GH-38382: [R] Explicitly clean up
 `arrow_duck_connection()` on exit (#38495)

### Rationale for this change

We get lots of warning messages about unclosed connections when running tests + users get them on exit when they weren't expecting them.

### What changes are included in this PR?

A finalizer was added on exit to close the global arrow_duck_con that we cache in the global options.

### Are these changes tested?

Yes, the finalizer will run in every test that runs `to_duckb()` with the default connection.

### Are there any user-facing changes?

No.
* Closes: #38382

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Nic Crane <thisisnic@gmail.com>
---
 r/R/duckdb.R                   | 19 +++++++++++++++++++
 r/tests/testthat/test-duckdb.R | 10 ++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/r/R/duckdb.R b/r/R/duckdb.R
index eee777ba835d0..bf3a57daf2f1e 100644
--- a/r/R/duckdb.R
+++ b/r/R/duckdb.R
@@ -76,12 +76,31 @@ to_duckdb <- function(.data,
   tbl
 }
 
+arrow_duck_finalizer <- new.env(parent = emptyenv())
+
 arrow_duck_connection <- function() {
   con <- getOption("arrow_duck_con")
   if (is.null(con) || !DBI::dbIsValid(con)) {
     con <- DBI::dbConnect(duckdb::duckdb())
     # Use the same CPU count that the arrow library is set to
     DBI::dbExecute(con, paste0("PRAGMA threads=", cpu_count()))
+
+    # This connection will get cleaned up at exit using the garbage collector,
+    # but if we don't explicitly run dbDisconnect() the user gets a warning
+    # that they may not expect (since they did not open a duckdb connection).
+    # This bit of code will run when the package namespace is cleaned up (i.e.,
+    # at exit). This is more reliable than .onUnload() or .onDetatch(), which
+    # don't necessarily run on exit.
+    reg.finalizer(arrow_duck_finalizer, function(...) {
+      con <- getOption("arrow_duck_con")
+      if (is.null(con)) {
+        return()
+      }
+
+      options(arrow_duck_con = NULL)
+      DBI::dbDisconnect(con, shutdown = TRUE)
+    }, onexit = TRUE)
+
     options(arrow_duck_con = con)
   }
   con
diff --git a/r/tests/testthat/test-duckdb.R b/r/tests/testthat/test-duckdb.R
index 13cffa1423767..6894a7a270b70 100644
--- a/r/tests/testthat/test-duckdb.R
+++ b/r/tests/testthat/test-duckdb.R
@@ -277,8 +277,14 @@ test_that("to_duckdb passing a connection", {
   table_four <- ds %>%
     select(int, lgl, dbl) %>%
     to_duckdb(con = con_separate, auto_disconnect = FALSE)
-  # dbplyr 2.2.0 renames this internal attribute to lazy_query
-  table_four_name <- table_four$ops$x %||% table_four$lazy_query$x
+
+  # dbplyr 2.3.0 renamed this internal attribute to lazy_query;
+  # and 2.4.0 reserved $... for internal use + changed the identifier class
+  if (packageVersion("dbplyr") < "2.4.0") {
+    table_four_name <- unclass(table_four)$lazy_query$x
+  } else {
+    table_four_name <- unclass(unclass(table_four)$lazy_query$x)$table
+  }
 
   result <- DBI::dbGetQuery(
     con_separate,

From 641fee6bdbc6177f7eb3be70799a22f80b444bde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 1 Nov 2023 16:41:50 +0100
Subject: [PATCH 659/749] MINOR: [Release] Update versions for 15.0.0-SNAPSHOT

---
 c_glib/meson.build                            |  2 +-
 ci/scripts/PKGBUILD                           |  2 +-
 cpp/CMakeLists.txt                            |  2 +-
 cpp/vcpkg.json                                |  2 +-
 csharp/Directory.Build.props                  |  2 +-
 .../homebrew-formulae/apache-arrow-glib.rb    |  2 +-
 dev/tasks/homebrew-formulae/apache-arrow.rb   |  2 +-
 docs/source/_static/versions.json             |  9 ++++--
 go/README.md                                  |  2 +-
 go/arrow/_examples/helloworld/main.go         |  8 ++---
 go/arrow/_tools/tmpl/main.go                  |  2 +-
 go/arrow/array.go                             |  4 +--
 go/arrow/array/array.go                       |  6 ++--
 go/arrow/array/array_test.go                  | 10 +++---
 go/arrow/array/binary.go                      |  4 +--
 go/arrow/array/binary_test.go                 |  6 ++--
 go/arrow/array/binarybuilder.go               |  8 ++---
 go/arrow/array/binarybuilder_test.go          |  6 ++--
 go/arrow/array/boolean.go                     |  8 ++---
 go/arrow/array/boolean_test.go                |  4 +--
 go/arrow/array/booleanbuilder.go              | 10 +++---
 go/arrow/array/booleanbuilder_test.go         |  6 ++--
 go/arrow/array/bufferbuilder.go               |  6 ++--
 go/arrow/array/bufferbuilder_byte.go          |  2 +-
 go/arrow/array/bufferbuilder_numeric.gen.go   |  6 ++--
 .../array/bufferbuilder_numeric.gen.go.tmpl   |  6 ++--
 go/arrow/array/bufferbuilder_numeric_test.go  |  4 +--
 go/arrow/array/builder.go                     |  8 ++---
 go/arrow/array/builder_test.go                |  4 +--
 go/arrow/array/compare.go                     |  6 ++--
 go/arrow/array/compare_test.go                | 10 +++---
 go/arrow/array/concat.go                      | 14 ++++----
 go/arrow/array/concat_test.go                 | 10 +++---
 go/arrow/array/data.go                        |  6 ++--
 go/arrow/array/data_test.go                   |  4 +--
 go/arrow/array/decimal128.go                  | 12 +++----
 go/arrow/array/decimal128_test.go             |  8 ++---
 go/arrow/array/decimal256.go                  | 12 +++----
 go/arrow/array/decimal256_test.go             |  8 ++---
 go/arrow/array/decimal_test.go                | 12 +++----
 go/arrow/array/dictionary.go                  | 20 ++++++------
 go/arrow/array/dictionary_test.go             | 14 ++++----
 go/arrow/array/diff.go                        |  2 +-
 go/arrow/array/diff_test.go                   | 10 +++---
 go/arrow/array/encoded.go                     | 12 +++----
 go/arrow/array/encoded_test.go                |  8 ++---
 go/arrow/array/extension.go                   |  6 ++--
 go/arrow/array/extension_test.go              |  8 ++---
 go/arrow/array/fixed_size_list.go             | 10 +++---
 go/arrow/array/fixed_size_list_test.go        |  6 ++--
 go/arrow/array/fixedsize_binary.go            |  4 +--
 go/arrow/array/fixedsize_binary_test.go       |  6 ++--
 go/arrow/array/fixedsize_binarybuilder.go     |  8 ++---
 .../array/fixedsize_binarybuilder_test.go     |  4 +--
 go/arrow/array/float16.go                     |  6 ++--
 go/arrow/array/float16_builder.go             | 12 +++----
 go/arrow/array/float16_builder_test.go        |  6 ++--
 go/arrow/array/interval.go                    | 10 +++---
 go/arrow/array/interval_test.go               |  6 ++--
 go/arrow/array/json_reader.go                 |  8 ++---
 go/arrow/array/json_reader_test.go            |  6 ++--
 go/arrow/array/list.go                        | 10 +++---
 go/arrow/array/list_test.go                   |  6 ++--
 go/arrow/array/map.go                         |  6 ++--
 go/arrow/array/map_test.go                    |  6 ++--
 go/arrow/array/null.go                        |  8 ++---
 go/arrow/array/null_test.go                   |  6 ++--
 go/arrow/array/numeric.gen.go                 |  4 +--
 go/arrow/array/numeric.gen.go.tmpl            |  4 +--
 go/arrow/array/numeric_test.go                |  8 ++---
 go/arrow/array/numericbuilder.gen.go          | 10 +++---
 go/arrow/array/numericbuilder.gen.go.tmpl     | 10 +++---
 go/arrow/array/numericbuilder.gen_test.go     |  6 ++--
 .../array/numericbuilder.gen_test.go.tmpl     |  6 ++--
 go/arrow/array/record.go                      |  8 ++---
 go/arrow/array/record_test.go                 |  6 ++--
 go/arrow/array/string.go                      |  6 ++--
 go/arrow/array/string_test.go                 |  8 ++---
 go/arrow/array/struct.go                      | 10 +++---
 go/arrow/array/struct_test.go                 |  6 ++--
 go/arrow/array/table.go                       |  4 +--
 go/arrow/array/table_test.go                  |  6 ++--
 go/arrow/array/timestamp.go                   | 10 +++---
 go/arrow/array/timestamp_test.go              |  6 ++--
 go/arrow/array/union.go                       | 12 +++----
 go/arrow/array/union_test.go                  |  6 ++--
 go/arrow/array/util.go                        | 10 +++---
 go/arrow/array/util_test.go                   | 14 ++++----
 go/arrow/arrio/arrio.go                       |  2 +-
 go/arrow/arrio/arrio_test.go                  | 10 +++---
 go/arrow/bitutil/bitmaps.go                   |  6 ++--
 go/arrow/bitutil/bitmaps_test.go              |  4 +--
 go/arrow/bitutil/bitutil.go                   |  2 +-
 go/arrow/bitutil/bitutil_test.go              |  4 +--
 go/arrow/cdata/cdata.go                       |  8 ++---
 go/arrow/cdata/cdata_exports.go               | 10 +++---
 go/arrow/cdata/cdata_test.go                  | 12 +++----
 go/arrow/cdata/cdata_test_framework.go        |  8 ++---
 go/arrow/cdata/exports.go                     |  4 +--
 go/arrow/cdata/import_allocator.go            |  2 +-
 go/arrow/cdata/interface.go                   |  8 ++---
 go/arrow/cdata/test/test_cimport.go           |  8 ++---
 go/arrow/compute/arithmetic.go                | 12 +++----
 go/arrow/compute/arithmetic_test.go           | 20 ++++++------
 go/arrow/compute/cast.go                      | 10 +++---
 go/arrow/compute/cast_test.go                 | 20 ++++++------
 go/arrow/compute/datum.go                     |  6 ++--
 go/arrow/compute/example_test.go              | 10 +++---
 go/arrow/compute/exec.go                      |  6 ++--
 go/arrow/compute/exec/kernel.go               |  8 ++---
 go/arrow/compute/exec/kernel_test.go          | 12 +++----
 go/arrow/compute/exec/span.go                 | 10 +++---
 go/arrow/compute/exec/span_test.go            | 16 +++++-----
 go/arrow/compute/exec/utils.go                | 14 ++++----
 go/arrow/compute/exec/utils_test.go           |  8 ++---
 go/arrow/compute/exec_internals_test.go       | 14 ++++----
 go/arrow/compute/exec_test.go                 | 12 +++----
 go/arrow/compute/executor.go                  | 16 +++++-----
 go/arrow/compute/expression.go                | 16 +++++-----
 go/arrow/compute/expression_test.go           | 10 +++---
 go/arrow/compute/exprs/builders.go            |  4 +--
 go/arrow/compute/exprs/builders_test.go       |  4 +--
 go/arrow/compute/exprs/exec.go                | 18 +++++------
 go/arrow/compute/exprs/exec_internal_test.go  |  8 ++---
 go/arrow/compute/exprs/exec_test.go           | 12 +++----
 go/arrow/compute/exprs/extension_types.go     |  4 +--
 go/arrow/compute/exprs/field_refs.go          | 10 +++---
 go/arrow/compute/exprs/types.go               |  4 +--
 go/arrow/compute/fieldref.go                  |  4 +--
 go/arrow/compute/fieldref_test.go             |  8 ++---
 go/arrow/compute/functions.go                 |  4 +--
 go/arrow/compute/functions_test.go            |  4 +--
 .../internal/kernels/base_arithmetic.go       | 10 +++---
 .../internal/kernels/base_arithmetic_amd64.go |  4 +--
 .../kernels/base_arithmetic_avx2_amd64.go     |  2 +-
 .../kernels/base_arithmetic_sse4_amd64.go     |  2 +-
 .../kernels/basic_arithmetic_noasm.go         |  2 +-
 .../compute/internal/kernels/boolean_cast.go  |  6 ++--
 go/arrow/compute/internal/kernels/cast.go     |  6 ++--
 .../compute/internal/kernels/cast_numeric.go  |  2 +-
 .../kernels/cast_numeric_avx2_amd64.go        |  2 +-
 .../kernels/cast_numeric_neon_arm64.go        |  2 +-
 .../kernels/cast_numeric_sse4_amd64.go        |  2 +-
 .../compute/internal/kernels/cast_temporal.go |  8 ++---
 go/arrow/compute/internal/kernels/helpers.go  | 14 ++++----
 .../compute/internal/kernels/numeric_cast.go  | 14 ++++----
 go/arrow/compute/internal/kernels/rounding.go | 10 +++---
 .../internal/kernels/scalar_arithmetic.go     | 14 ++++----
 .../internal/kernels/scalar_boolean.go        |  6 ++--
 .../kernels/scalar_comparison_amd64.go        |  4 +--
 .../kernels/scalar_comparison_avx2_amd64.go   |  2 +-
 .../kernels/scalar_comparison_noasm.go        |  2 +-
 .../kernels/scalar_comparison_sse4_amd64.go   |  2 +-
 .../internal/kernels/scalar_comparisons.go    | 16 +++++-----
 .../compute/internal/kernels/string_casts.go  | 12 +++----
 go/arrow/compute/internal/kernels/types.go    |  8 ++---
 .../compute/internal/kernels/vector_hash.go   | 14 ++++----
 .../internal/kernels/vector_run_end_encode.go | 16 +++++-----
 .../internal/kernels/vector_selection.go      | 14 ++++----
 go/arrow/compute/registry.go                  |  2 +-
 go/arrow/compute/registry_test.go             |  6 ++--
 go/arrow/compute/scalar_bool.go               |  6 ++--
 go/arrow/compute/scalar_bool_test.go          | 10 +++---
 go/arrow/compute/scalar_compare.go            |  6 ++--
 go/arrow/compute/scalar_compare_test.go       | 18 +++++------
 go/arrow/compute/selection.go                 |  8 ++---
 go/arrow/compute/utils.go                     | 12 +++----
 go/arrow/compute/vector_hash.go               |  4 +--
 go/arrow/compute/vector_hash_test.go          | 14 ++++----
 go/arrow/compute/vector_run_end_test.go       | 14 ++++----
 go/arrow/compute/vector_run_ends.go           |  4 +--
 go/arrow/compute/vector_selection_test.go     | 18 +++++------
 go/arrow/csv/common.go                        |  4 +--
 go/arrow/csv/reader.go                        | 14 ++++----
 go/arrow/csv/reader_test.go                   | 14 ++++----
 go/arrow/csv/transformer.go                   |  4 +--
 go/arrow/csv/writer.go                        |  2 +-
 go/arrow/csv/writer_test.go                   | 16 +++++-----
 go/arrow/datatype.go                          |  2 +-
 go/arrow/datatype_binary_test.go              |  2 +-
 go/arrow/datatype_extension_test.go           |  4 +--
 go/arrow/datatype_fixedwidth.go               |  2 +-
 go/arrow/datatype_fixedwidth_test.go          |  2 +-
 go/arrow/datatype_nested.go                   |  2 +-
 go/arrow/datatype_null_test.go                |  2 +-
 go/arrow/decimal128/decimal128.go             |  2 +-
 go/arrow/decimal128/decimal128_test.go        |  2 +-
 go/arrow/decimal256/decimal256.go             |  4 +--
 go/arrow/decimal256/decimal256_test.go        |  2 +-
 go/arrow/doc.go                               |  2 +-
 go/arrow/encoded/ree_utils.go                 |  2 +-
 go/arrow/encoded/ree_utils_test.go            |  8 ++---
 go/arrow/endian/endian.go                     |  4 +--
 go/arrow/example_test.go                      |  8 ++---
 go/arrow/flight/basic_auth_flight_test.go     |  2 +-
 go/arrow/flight/client.go                     |  2 +-
 go/arrow/flight/cookie_middleware_test.go     |  2 +-
 go/arrow/flight/example_flight_server_test.go |  2 +-
 go/arrow/flight/flight_middleware_test.go     |  4 +--
 go/arrow/flight/flight_test.go                | 10 +++---
 go/arrow/flight/flightsql/client.go           | 12 +++----
 go/arrow/flight/flightsql/client_test.go      | 12 +++----
 go/arrow/flight/flightsql/column_metadata.go  |  2 +-
 go/arrow/flight/flightsql/driver/README.md    |  6 ++--
 .../flight/flightsql/driver/config_test.go    |  2 +-
 go/arrow/flight/flightsql/driver/driver.go    | 10 +++---
 .../flight/flightsql/driver/driver_test.go    | 14 ++++----
 go/arrow/flight/flightsql/driver/utils.go     |  4 +--
 .../flight/flightsql/driver/utils_test.go     | 12 +++----
 .../cmd/sqlite_flightsql_server/main.go       |  6 ++--
 .../flightsql/example/sql_batch_reader.go     | 10 +++---
 .../flight/flightsql/example/sqlite_info.go   |  4 +--
 .../flight/flightsql/example/sqlite_server.go | 14 ++++----
 .../sqlite_tables_schema_batch_reader.go      | 12 +++----
 .../flight/flightsql/example/type_info.go     |  8 ++---
 .../flightsql/schema_ref/reference_schemas.go |  2 +-
 go/arrow/flight/flightsql/server.go           | 16 +++++-----
 go/arrow/flight/flightsql/server_test.go      | 12 +++----
 go/arrow/flight/flightsql/sql_info.go         |  4 +--
 .../flight/flightsql/sqlite_server_test.go    | 16 +++++-----
 go/arrow/flight/flightsql/types.go            |  2 +-
 go/arrow/flight/record_batch_reader.go        | 12 +++----
 go/arrow/flight/record_batch_writer.go        |  6 ++--
 go/arrow/flight/server.go                     |  2 +-
 go/arrow/flight/server_example_test.go        |  2 +-
 go/arrow/internal/arrdata/arrdata.go          | 16 +++++-----
 go/arrow/internal/arrdata/ioutil.go           | 10 +++---
 go/arrow/internal/arrjson/arrjson.go          | 20 ++++++------
 go/arrow/internal/arrjson/arrjson_test.go     |  6 ++--
 go/arrow/internal/arrjson/option.go           |  4 +--
 go/arrow/internal/arrjson/reader.go           | 10 +++---
 go/arrow/internal/arrjson/writer.go           | 10 +++---
 .../internal/cdata_integration/entrypoints.go |  8 ++---
 go/arrow/internal/dictutils/dict.go           |  6 ++--
 go/arrow/internal/dictutils/dict_test.go      |  8 ++---
 .../arrow-flight-integration-client/main.go   |  2 +-
 .../arrow-flight-integration-server/main.go   |  2 +-
 .../internal/flight_integration/scenario.go   | 18 +++++------
 .../internal/testing/gen/random_array_gen.go  | 10 +++---
 go/arrow/internal/testing/tools/bits_test.go  |  2 +-
 go/arrow/internal/testing/tools/data_types.go |  4 +--
 go/arrow/internal/utils.go                    |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main.go            |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main_test.go       |  8 ++---
 go/arrow/ipc/cmd/arrow-file-to-stream/main.go |  6 ++--
 .../ipc/cmd/arrow-file-to-stream/main_test.go |  4 +--
 .../cmd/arrow-json-integration-test/main.go   | 12 +++----
 .../arrow-json-integration-test/main_test.go  |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main.go             |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main_test.go        |  8 ++---
 go/arrow/ipc/cmd/arrow-stream-to-file/main.go |  6 ++--
 .../ipc/cmd/arrow-stream-to-file/main_test.go |  4 +--
 go/arrow/ipc/compression.go                   |  6 ++--
 go/arrow/ipc/endian_swap.go                   |  6 ++--
 go/arrow/ipc/endian_swap_test.go              | 10 +++---
 go/arrow/ipc/file_reader.go                   | 16 +++++-----
 go/arrow/ipc/file_test.go                     |  6 ++--
 go/arrow/ipc/file_writer.go                   | 10 +++---
 go/arrow/ipc/ipc.go                           |  8 ++---
 go/arrow/ipc/ipc_test.go                      |  8 ++---
 go/arrow/ipc/message.go                       |  6 ++--
 go/arrow/ipc/message_test.go                  |  6 ++--
 go/arrow/ipc/metadata.go                      | 10 +++---
 go/arrow/ipc/metadata_test.go                 | 12 +++----
 go/arrow/ipc/reader.go                        | 14 ++++----
 go/arrow/ipc/reader_test.go                   |  6 ++--
 go/arrow/ipc/stream_test.go                   |  6 ++--
 go/arrow/ipc/writer.go                        | 16 +++++-----
 go/arrow/ipc/writer_test.go                   | 10 +++---
 go/arrow/math/float64.go                      |  2 +-
 go/arrow/math/float64_avx2_amd64.go           |  2 +-
 go/arrow/math/float64_neon_arm64.go           |  2 +-
 go/arrow/math/float64_sse4_amd64.go           |  2 +-
 go/arrow/math/float64_test.go                 |  6 ++--
 go/arrow/math/int64.go                        |  2 +-
 go/arrow/math/int64_avx2_amd64.go             |  2 +-
 go/arrow/math/int64_neon_arm64.go             |  2 +-
 go/arrow/math/int64_sse4_amd64.go             |  2 +-
 go/arrow/math/int64_test.go                   |  6 ++--
 go/arrow/math/type.go.tmpl                    |  2 +-
 go/arrow/math/type_simd_amd64.go.tmpl         |  2 +-
 go/arrow/math/type_simd_arm64.go.tmpl         |  2 +-
 go/arrow/math/type_test.go.tmpl               |  6 ++--
 go/arrow/math/uint64.go                       |  2 +-
 go/arrow/math/uint64_avx2_amd64.go            |  2 +-
 go/arrow/math/uint64_neon_arm64.go            |  2 +-
 go/arrow/math/uint64_sse4_amd64.go            |  2 +-
 go/arrow/math/uint64_test.go                  |  6 ++--
 go/arrow/memory/buffer.go                     |  2 +-
 go/arrow/memory/buffer_test.go                |  2 +-
 go/arrow/memory/cgo_allocator.go              |  2 +-
 go/arrow/memory/default_mallocator.go         |  2 +-
 go/arrow/memory/default_mallocator_test.go    |  4 +--
 go/arrow/memory/mallocator/mallocator_test.go |  2 +-
 go/arrow/memory/memory_test.go                |  2 +-
 go/arrow/record.go                            |  2 +-
 go/arrow/scalar/append.go                     | 10 +++---
 go/arrow/scalar/append_test.go                | 10 +++---
 go/arrow/scalar/binary.go                     |  4 +--
 go/arrow/scalar/compare.go                    |  2 +-
 go/arrow/scalar/nested.go                     |  8 ++---
 go/arrow/scalar/numeric.gen.go                |  6 ++--
 go/arrow/scalar/numeric.gen_test.go           |  4 +--
 go/arrow/scalar/numeric.gen_test.go.tmpl      |  4 +--
 go/arrow/scalar/parse.go                      | 12 +++----
 go/arrow/scalar/scalar.go                     | 20 ++++++------
 go/arrow/scalar/scalar_test.go                | 12 +++----
 go/arrow/scalar/temporal.go                   |  2 +-
 go/arrow/schema.go                            |  2 +-
 go/arrow/schema_test.go                       |  2 +-
 go/arrow/table.go                             |  2 +-
 go/arrow/tensor/numeric.gen.go                |  2 +-
 go/arrow/tensor/numeric.gen.go.tmpl           |  4 +--
 go/arrow/tensor/numeric.gen_test.go           |  8 ++---
 go/arrow/tensor/numeric.gen_test.go.tmpl      |  8 ++---
 go/arrow/tensor/tensor.go                     |  4 +--
 go/arrow/tensor/tensor_test.go                |  8 ++---
 go/arrow/type_traits_boolean.go               |  2 +-
 go/arrow/type_traits_decimal128.go            |  4 +--
 go/arrow/type_traits_decimal256.go            |  4 +--
 go/arrow/type_traits_float16.go               |  4 +--
 go/arrow/type_traits_interval.go              |  4 +--
 go/arrow/type_traits_numeric.gen.go           |  2 +-
 go/arrow/type_traits_numeric.gen.go.tmpl      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go.tmpl |  2 +-
 go/arrow/type_traits_test.go                  |  8 ++---
 go/arrow/type_traits_timestamp.go             |  2 +-
 go/arrow/util/byte_size.go                    |  6 ++--
 go/arrow/util/byte_size_test.go               |  8 ++---
 go/go.mod                                     |  2 +-
 go/internal/bitutils/bit_block_counter.go     |  4 +--
 .../bitutils/bit_block_counter_test.go        |  6 ++--
 go/internal/bitutils/bit_run_reader.go        |  6 ++--
 go/internal/bitutils/bit_run_reader_test.go   |  6 ++--
 go/internal/bitutils/bit_set_run_reader.go    |  4 +--
 .../bitutils/bit_set_run_reader_test.go       |  6 ++--
 go/internal/bitutils/bitmap_generate.go       |  2 +-
 go/internal/bitutils/bitmap_generate_test.go  |  2 +-
 go/internal/hashing/xxh3_memo_table.gen.go    |  6 ++--
 .../hashing/xxh3_memo_table.gen.go.tmpl       |  4 +--
 go/internal/types/extension_types.go          |  6 ++--
 go/internal/types/extension_types_test.go     | 10 +++---
 go/internal/utils/transpose_ints_def.go       |  2 +-
 go/internal/utils/transpose_ints_test.go      |  2 +-
 go/parquet/cmd/parquet_reader/dumper.go       |  6 ++--
 go/parquet/cmd/parquet_reader/main.go         | 10 +++---
 go/parquet/cmd/parquet_schema/main.go         |  4 +--
 go/parquet/compress/brotli.go                 |  2 +-
 go/parquet/compress/compress.go               |  2 +-
 go/parquet/compress/compress_test.go          |  2 +-
 go/parquet/compress/zstd.go                   |  2 +-
 go/parquet/doc.go                             |  6 ++--
 go/parquet/encryption_properties.go           |  2 +-
 go/parquet/encryption_properties_test.go      |  4 +--
 go/parquet/encryption_read_config_test.go     |  8 ++---
 go/parquet/encryption_write_config_test.go    |  8 ++---
 go/parquet/file/column_reader.go              | 14 ++++----
 go/parquet/file/column_reader_test.go         | 12 +++----
 go/parquet/file/column_reader_types.gen.go    |  6 ++--
 .../file/column_reader_types.gen.go.tmpl      |  4 +--
 go/parquet/file/column_writer.go              | 16 +++++-----
 go/parquet/file/column_writer_test.go         | 26 +++++++--------
 go/parquet/file/column_writer_types.gen.go    | 12 +++----
 .../file/column_writer_types.gen.go.tmpl      |  8 ++---
 go/parquet/file/file_reader.go                |  8 ++---
 go/parquet/file/file_reader_mmap.go           |  2 +-
 go/parquet/file/file_reader_mmap_windows.go   |  2 +-
 go/parquet/file/file_reader_test.go           | 20 ++++++------
 go/parquet/file/file_writer.go                | 10 +++---
 go/parquet/file/file_writer_test.go           | 14 ++++----
 go/parquet/file/level_conversion.go           | 10 +++---
 go/parquet/file/level_conversion_test.go      |  6 ++--
 go/parquet/file/page_reader.go                | 14 ++++----
 go/parquet/file/page_writer.go                | 18 +++++------
 go/parquet/file/record_reader.go              | 16 +++++-----
 go/parquet/file/row_group_reader.go           |  8 ++---
 go/parquet/file/row_group_writer.go           |  8 ++---
 go/parquet/file/row_group_writer_test.go      |  8 ++---
 go/parquet/internal/bmi/bmi_test.go           |  2 +-
 .../internal/encoding/boolean_decoder.go      |  8 ++---
 .../internal/encoding/boolean_encoder.go      |  8 ++---
 .../internal/encoding/byte_array_decoder.go   | 12 +++----
 .../internal/encoding/byte_array_encoder.go   | 10 +++---
 go/parquet/internal/encoding/decoder.go       | 20 ++++++------
 .../internal/encoding/delta_bit_packing.go    | 10 +++---
 .../internal/encoding/delta_byte_array.go     |  6 ++--
 .../encoding/delta_byte_array_test.go         |  4 +--
 .../encoding/delta_length_byte_array.go       |  6 ++--
 go/parquet/internal/encoding/encoder.go       | 16 +++++-----
 .../encoding/encoding_benchmarks_test.go      | 16 +++++-----
 go/parquet/internal/encoding/encoding_test.go | 14 ++++----
 .../encoding/fixed_len_byte_array_decoder.go  |  4 +--
 .../encoding/fixed_len_byte_array_encoder.go  |  6 ++--
 go/parquet/internal/encoding/levels.go        | 10 +++---
 go/parquet/internal/encoding/levels_test.go   | 10 +++---
 go/parquet/internal/encoding/memo_table.go    | 10 +++---
 .../internal/encoding/memo_table_test.go      | 10 +++---
 .../internal/encoding/memo_table_types.gen.go |  4 +--
 .../encoding/memo_table_types.gen.go.tmpl     |  2 +-
 .../encoding/plain_encoder_types.gen.go       | 10 +++---
 .../encoding/plain_encoder_types.gen.go.tmpl  |  8 ++---
 .../internal/encoding/typed_encoder.gen.go    | 18 +++++------
 .../encoding/typed_encoder.gen.go.tmpl        | 14 ++++----
 go/parquet/internal/encoding/types.go         | 10 +++---
 go/parquet/internal/encryption/aes.go         |  2 +-
 go/parquet/internal/encryption/decryptor.go   |  4 +--
 go/parquet/internal/encryption/encryptor.go   |  4 +--
 go/parquet/internal/testutils/pagebuilder.go  | 14 ++++----
 .../internal/testutils/primitive_typed.go     | 10 +++---
 go/parquet/internal/testutils/random.go       | 14 ++++----
 go/parquet/internal/testutils/random_arrow.go |  6 ++--
 go/parquet/internal/testutils/utils.go        |  2 +-
 go/parquet/internal/thrift/helpers.go         |  2 +-
 .../internal/utils/bit_benchmark_test.go      |  6 ++--
 .../internal/utils/bit_packing_arm64.go       |  2 +-
 go/parquet/internal/utils/bit_reader.go       |  8 ++---
 go/parquet/internal/utils/bit_reader_test.go  | 10 +++---
 go/parquet/internal/utils/bit_writer.go       |  2 +-
 go/parquet/internal/utils/bitmap_writer.go    |  2 +-
 .../internal/utils/bitmap_writer_test.go      |  4 +--
 go/parquet/internal/utils/rle.go              |  8 ++---
 .../internal/utils/typed_rle_dict.gen.go      |  6 ++--
 .../internal/utils/typed_rle_dict.gen.go.tmpl |  6 ++--
 go/parquet/metadata/app_version.go            |  4 +--
 go/parquet/metadata/column_chunk.go           | 14 ++++----
 go/parquet/metadata/file.go                   | 12 +++----
 go/parquet/metadata/metadata_test.go          |  6 ++--
 go/parquet/metadata/row_group.go              |  8 ++---
 go/parquet/metadata/stat_compare_test.go      |  4 +--
 go/parquet/metadata/statistics.go             | 16 +++++-----
 go/parquet/metadata/statistics_test.go        | 10 +++---
 go/parquet/metadata/statistics_types.gen.go   | 16 +++++-----
 .../metadata/statistics_types.gen.go.tmpl     | 14 ++++----
 go/parquet/pqarrow/column_readers.go          | 20 ++++++------
 go/parquet/pqarrow/encode_arrow.go            | 20 ++++++------
 go/parquet/pqarrow/encode_arrow_test.go       | 32 +++++++++----------
 go/parquet/pqarrow/encode_dict_compute.go     | 16 +++++-----
 go/parquet/pqarrow/encode_dict_nocompute.go   |  4 +--
 go/parquet/pqarrow/encode_dictionary_test.go  | 16 +++++-----
 go/parquet/pqarrow/file_reader.go             | 14 ++++----
 go/parquet/pqarrow/file_reader_test.go        | 14 ++++----
 go/parquet/pqarrow/file_writer.go             | 12 +++----
 go/parquet/pqarrow/helpers.go                 |  2 +-
 go/parquet/pqarrow/path_builder.go            | 10 +++---
 go/parquet/pqarrow/path_builder_test.go       |  8 ++---
 go/parquet/pqarrow/properties.go              |  6 ++--
 go/parquet/pqarrow/reader_writer_test.go      | 12 +++----
 go/parquet/pqarrow/schema.go                  | 18 +++++------
 go/parquet/pqarrow/schema_test.go             | 18 +++++------
 go/parquet/reader_properties.go               |  4 +--
 go/parquet/reader_writer_properties_test.go   |  6 ++--
 go/parquet/schema/column.go                   |  4 +--
 go/parquet/schema/converted_types.go          |  2 +-
 go/parquet/schema/converted_types_test.go     |  2 +-
 go/parquet/schema/helpers.go                  |  2 +-
 go/parquet/schema/helpers_test.go             |  4 +--
 go/parquet/schema/logical_types.go            |  8 ++---
 go/parquet/schema/logical_types_test.go       |  6 ++--
 go/parquet/schema/node.go                     |  4 +--
 go/parquet/schema/reflection.go               |  4 +--
 go/parquet/schema/reflection_test.go          |  4 +--
 go/parquet/schema/schema.go                   |  4 +--
 go/parquet/schema/schema_element_test.go      |  4 +--
 go/parquet/schema/schema_flatten_test.go      |  4 +--
 go/parquet/schema/schema_test.go              |  6 ++--
 go/parquet/types.go                           |  4 +--
 go/parquet/writer_properties.go               |  6 ++--
 java/adapter/avro/pom.xml                     |  2 +-
 java/adapter/jdbc/pom.xml                     |  2 +-
 java/adapter/orc/pom.xml                      |  2 +-
 java/algorithm/pom.xml                        |  2 +-
 java/bom/pom.xml                              |  2 +-
 java/c/pom.xml                                |  2 +-
 java/compression/pom.xml                      |  2 +-
 java/dataset/pom.xml                          |  2 +-
 java/flight/flight-core/pom.xml               |  2 +-
 java/flight/flight-grpc/pom.xml               |  2 +-
 java/flight/flight-integration-tests/pom.xml  |  2 +-
 java/flight/flight-sql-jdbc-core/pom.xml      |  2 +-
 java/flight/flight-sql-jdbc-driver/pom.xml    |  2 +-
 java/flight/flight-sql/pom.xml                |  2 +-
 java/flight/pom.xml                           |  2 +-
 java/format/pom.xml                           |  2 +-
 java/gandiva/pom.xml                          |  2 +-
 java/memory/memory-core/pom.xml               |  2 +-
 java/memory/memory-netty/pom.xml              |  2 +-
 java/memory/memory-unsafe/pom.xml             |  2 +-
 java/memory/pom.xml                           |  2 +-
 java/performance/pom.xml                      |  2 +-
 java/pom.xml                                  |  2 +-
 java/tools/pom.xml                            |  2 +-
 java/vector/pom.xml                           |  2 +-
 js/package.json                               |  2 +-
 matlab/CMakeLists.txt                         |  2 +-
 python/CMakeLists.txt                         |  2 +-
 python/setup.py                               |  2 +-
 r/DESCRIPTION                                 |  2 +-
 r/NEWS.md                                     |  4 ++-
 r/pkgdown/assets/versions.json                |  8 +++--
 ruby/red-arrow-cuda/lib/arrow-cuda/version.rb |  2 +-
 .../lib/arrow-dataset/version.rb              |  2 +-
 .../lib/arrow-flight-sql/version.rb           |  2 +-
 .../lib/arrow-flight/version.rb               |  2 +-
 ruby/red-arrow/lib/arrow/version.rb           |  2 +-
 ruby/red-gandiva/lib/gandiva/version.rb       |  2 +-
 ruby/red-parquet/lib/parquet/version.rb       |  2 +-
 507 files changed, 1748 insertions(+), 1737 deletions(-)

diff --git a/c_glib/meson.build b/c_glib/meson.build
index d9de6fcbf7e24..7c495d2567d72 100644
--- a/c_glib/meson.build
+++ b/c_glib/meson.build
@@ -24,7 +24,7 @@ project('arrow-glib', 'c', 'cpp',
           'cpp_std=c++17',
         ])
 
-version = '14.0.0-SNAPSHOT'
+version = '15.0.0-SNAPSHOT'
 if version.endswith('-SNAPSHOT')
   version_numbers = version.split('-')[0].split('.')
   version_tag = version.split('-')[1]
diff --git a/ci/scripts/PKGBUILD b/ci/scripts/PKGBUILD
index dcd313087e966..95029d98f7a01 100644
--- a/ci/scripts/PKGBUILD
+++ b/ci/scripts/PKGBUILD
@@ -18,7 +18,7 @@
 _realname=arrow
 pkgbase=mingw-w64-${_realname}
 pkgname="${MINGW_PACKAGE_PREFIX}-${_realname}"
-pkgver=13.0.0.9000
+pkgver=14.0.0.9000
 pkgrel=8000
 pkgdesc="Apache Arrow is a cross-language development platform for in-memory data (mingw-w64)"
 arch=("any")
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 7138139b13ec0..524a9bebf7fa2 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -71,7 +71,7 @@ if(POLICY CMP0135)
   cmake_policy(SET CMP0135 NEW)
 endif()
 
-set(ARROW_VERSION "14.0.0-SNAPSHOT")
+set(ARROW_VERSION "15.0.0-SNAPSHOT")
 
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_BASE_VERSION "${ARROW_VERSION}")
 
diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json
index 71855dafdea35..c0bf5dce50e32 100644
--- a/cpp/vcpkg.json
+++ b/cpp/vcpkg.json
@@ -1,6 +1,6 @@
 {
   "name": "arrow",
-  "version-string": "14.0.0-SNAPSHOT",
+  "version-string": "15.0.0-SNAPSHOT",
   "dependencies": [
     "abseil",
     {
diff --git a/csharp/Directory.Build.props b/csharp/Directory.Build.props
index b6c7c75c237e5..ae6edda0e2f0e 100644
--- a/csharp/Directory.Build.props
+++ b/csharp/Directory.Build.props
@@ -29,7 +29,7 @@
     <Product>Apache Arrow library</Product>
     <Copyright>Copyright 2016-2019 The Apache Software Foundation</Copyright>
     <Company>The Apache Software Foundation</Company>
-    <Version>14.0.0-SNAPSHOT</Version>
+    <Version>15.0.0-SNAPSHOT</Version>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
index c31ef267d73c5..e29354def4c1c 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
@@ -29,7 +29,7 @@
 class ApacheArrowGlib < Formula
   desc "GLib bindings for Apache Arrow"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.0-SNAPSHOT/apache-arrow-14.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index edf2d7b73b8f5..14d229b477dc8 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -29,7 +29,7 @@
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.0-SNAPSHOT/apache-arrow-14.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/docs/source/_static/versions.json b/docs/source/_static/versions.json
index 8d9c5878c8213..10e179420b803 100644
--- a/docs/source/_static/versions.json
+++ b/docs/source/_static/versions.json
@@ -1,15 +1,20 @@
 [
     {
-        "name": "14.0 (dev)",
+        "name": "15.0 (dev)",
         "version": "dev/",
         "url": "https://arrow.apache.org/docs/dev/"
     },
     {
-        "name": "13.0 (stable)",
+        "name": "14.0 (stable)",
         "version": "",
         "url": "https://arrow.apache.org/docs/",
         "preferred": true
     },
+    {
+        "name": "13.0",
+        "version": "13.0/",
+        "url": "https://arrow.apache.org/docs/13.0/"
+    },
     {
         "name": "12.0",
         "version": "12.0/",
diff --git a/go/README.md b/go/README.md
index 660549cb1b366..c45bcd756f81c 100644
--- a/go/README.md
+++ b/go/README.md
@@ -20,7 +20,7 @@
 Apache Arrow for Go
 ===================
 
-[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v14.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v14)
+[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v15.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v15)
 
 [Apache Arrow][arrow] is a cross-language development platform for in-memory
 data. It specifies a standardized language-independent columnar memory format
diff --git a/go/arrow/_examples/helloworld/main.go b/go/arrow/_examples/helloworld/main.go
index 02601be694400..156a52b86da1c 100644
--- a/go/arrow/_examples/helloworld/main.go
+++ b/go/arrow/_examples/helloworld/main.go
@@ -19,10 +19,10 @@ package main
 import (
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/_tools/tmpl/main.go b/go/arrow/_tools/tmpl/main.go
index 87c4b6ed02c12..c591c3b96803c 100644
--- a/go/arrow/_tools/tmpl/main.go
+++ b/go/arrow/_tools/tmpl/main.go
@@ -28,7 +28,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const Ext = ".tmpl"
diff --git a/go/arrow/array.go b/go/arrow/array.go
index 7622e7503e0b6..e07fa478aae57 100644
--- a/go/arrow/array.go
+++ b/go/arrow/array.go
@@ -19,8 +19,8 @@ package arrow
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // ArrayData is the underlying memory and metadata of an Arrow array, corresponding
diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index 1ee04c7aa2bcc..bbe301ee661f3 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/array/array_test.go b/go/arrow/array/array_test.go
index 6139548ddec7d..bbfbee83585da 100644
--- a/go/arrow/array/array_test.go
+++ b/go/arrow/array/array_test.go
@@ -19,11 +19,11 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binary.go b/go/arrow/array/binary.go
index e9e6e66e7e813..bf27139fddbaa 100644
--- a/go/arrow/array/binary.go
+++ b/go/arrow/array/binary.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type BinaryLike interface {
diff --git a/go/arrow/array/binary_test.go b/go/arrow/array/binary_test.go
index 5febb55691d7d..9c1770950a8b5 100644
--- a/go/arrow/array/binary_test.go
+++ b/go/arrow/array/binary_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binarybuilder.go b/go/arrow/array/binarybuilder.go
index 3cb709b45b7a1..a51bc799e4965 100644
--- a/go/arrow/array/binarybuilder.go
+++ b/go/arrow/array/binarybuilder.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A BinaryBuilder is used to build a Binary array using the Append methods.
diff --git a/go/arrow/array/binarybuilder_test.go b/go/arrow/array/binarybuilder_test.go
index c63307433bcca..96be73da6516d 100644
--- a/go/arrow/array/binarybuilder_test.go
+++ b/go/arrow/array/binarybuilder_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/boolean.go b/go/arrow/array/boolean.go
index 464cef48bdf32..43bac64a4c990 100644
--- a/go/arrow/array/boolean.go
+++ b/go/arrow/array/boolean.go
@@ -21,10 +21,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of boolean values.
diff --git a/go/arrow/array/boolean_test.go b/go/arrow/array/boolean_test.go
index c49ec08624cc6..bcd17ee5967d6 100644
--- a/go/arrow/array/boolean_test.go
+++ b/go/arrow/array/boolean_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/booleanbuilder.go b/go/arrow/array/booleanbuilder.go
index 10b7405aa5b2a..cd0cffd5e43e2 100644
--- a/go/arrow/array/booleanbuilder.go
+++ b/go/arrow/array/booleanbuilder.go
@@ -23,11 +23,11 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type BooleanBuilder struct {
diff --git a/go/arrow/array/booleanbuilder_test.go b/go/arrow/array/booleanbuilder_test.go
index e270636a87b1c..f6f6c80dab37f 100644
--- a/go/arrow/array/booleanbuilder_test.go
+++ b/go/arrow/array/booleanbuilder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/bufferbuilder.go b/go/arrow/array/bufferbuilder.go
index e023b0d907421..cb381e25b32a2 100644
--- a/go/arrow/array/bufferbuilder.go
+++ b/go/arrow/array/bufferbuilder.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type bufBuilder interface {
diff --git a/go/arrow/array/bufferbuilder_byte.go b/go/arrow/array/bufferbuilder_byte.go
index 00a0d1c21b3ef..9b2b559ba9f68 100644
--- a/go/arrow/array/bufferbuilder_byte.go
+++ b/go/arrow/array/bufferbuilder_byte.go
@@ -16,7 +16,7 @@
 
 package array
 
-import "github.com/apache/arrow/go/v14/arrow/memory"
+import "github.com/apache/arrow/go/v15/arrow/memory"
 
 type byteBufferBuilder struct {
 	bufferBuilder
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go b/go/arrow/array/bufferbuilder_numeric.gen.go
index 879bc9f571152..a7961166c0edd 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go
@@ -19,9 +19,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type int64BufferBuilder struct {
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
index e859b5bff02a1..845d7ef01c89a 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
@@ -17,9 +17,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/bufferbuilder_numeric_test.go b/go/arrow/array/bufferbuilder_numeric_test.go
index ba0a60e5b703b..b51e9ae9207ea 100644
--- a/go/arrow/array/bufferbuilder_numeric_test.go
+++ b/go/arrow/array/bufferbuilder_numeric_test.go
@@ -20,8 +20,8 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index 2f15ac965e07c..bb15298e03ccf 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const (
diff --git a/go/arrow/array/builder_test.go b/go/arrow/array/builder_test.go
index 3cacb54f725e7..7bec86d86cc8b 100644
--- a/go/arrow/array/builder_test.go
+++ b/go/arrow/array/builder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index e70716bee91a7..778de41e32c67 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 // RecordEqual reports whether the two provided records are equal.
diff --git a/go/arrow/array/compare_test.go b/go/arrow/array/compare_test.go
index 51421aa04fe9a..4fc9cf50e8643 100644
--- a/go/arrow/array/compare_test.go
+++ b/go/arrow/array/compare_test.go
@@ -22,11 +22,11 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 9d815023c4b76..53c5be06895b9 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -23,13 +23,13 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // Concatenate creates a new arrow.Array which is the concatenation of the
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index c80844f05bacd..1cc484ad1a923 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/data.go b/go/arrow/array/data.go
index 49df06fb1174a..8cce49182b879 100644
--- a/go/arrow/array/data.go
+++ b/go/arrow/array/data.go
@@ -22,9 +22,9 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Data represents the memory and metadata of an Arrow array.
diff --git a/go/arrow/array/data_test.go b/go/arrow/array/data_test.go
index 2773096995fb6..b7b0f396470d7 100644
--- a/go/arrow/array/data_test.go
+++ b/go/arrow/array/data_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal128.go b/go/arrow/array/decimal128.go
index 3317531687ca4..16a492db09c67 100644
--- a/go/arrow/array/decimal128.go
+++ b/go/arrow/array/decimal128.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of 128-bit decimal values.
diff --git a/go/arrow/array/decimal128_test.go b/go/arrow/array/decimal128_test.go
index 8ef09b68c176a..8c26d00cdc18e 100644
--- a/go/arrow/array/decimal128_test.go
+++ b/go/arrow/array/decimal128_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal256.go b/go/arrow/array/decimal256.go
index d63544f784a09..8f72e414d1959 100644
--- a/go/arrow/array/decimal256.go
+++ b/go/arrow/array/decimal256.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Decimal256 is a type that represents an immutable sequence of 256-bit decimal values.
diff --git a/go/arrow/array/decimal256_test.go b/go/arrow/array/decimal256_test.go
index a02098e79103f..6085d6b5a6a59 100644
--- a/go/arrow/array/decimal256_test.go
+++ b/go/arrow/array/decimal256_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal_test.go b/go/arrow/array/decimal_test.go
index 2203b2702c09a..67900447be1cf 100644
--- a/go/arrow/array/decimal_test.go
+++ b/go/arrow/array/decimal_test.go
@@ -21,12 +21,12 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index d0a1c4dc97e1d..856f91605ff53 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -25,16 +25,16 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // Dictionary represents the type for dictionary-encoded data with a data
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index d0878fa3b0329..5a3e0e10c23f3 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -24,13 +24,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/diff.go b/go/arrow/array/diff.go
index 026a27b983f59..6bf6372531fd7 100644
--- a/go/arrow/array/diff.go
+++ b/go/arrow/array/diff.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Edit represents one entry in the edit script to compare two arrays.
diff --git a/go/arrow/array/diff_test.go b/go/arrow/array/diff_test.go
index 0eff8dc4f0577..17539c38d282f 100644
--- a/go/arrow/array/diff_test.go
+++ b/go/arrow/array/diff_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 type diffTestCase struct {
diff --git a/go/arrow/array/encoded.go b/go/arrow/array/encoded.go
index bf4a942cf1c35..fa5fa7addf34c 100644
--- a/go/arrow/array/encoded.go
+++ b/go/arrow/array/encoded.go
@@ -23,12 +23,12 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // RunEndEncoded represents an array containing two children:
diff --git a/go/arrow/array/encoded_test.go b/go/arrow/array/encoded_test.go
index 57c01cf22d2d6..5bfac7a1a96e6 100644
--- a/go/arrow/array/encoded_test.go
+++ b/go/arrow/array/encoded_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/array/extension.go b/go/arrow/array/extension.go
index 03e8c1734b9d6..021b8e7bc451b 100644
--- a/go/arrow/array/extension.go
+++ b/go/arrow/array/extension.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // ExtensionArray is the interface that needs to be implemented to handle
diff --git a/go/arrow/array/extension_test.go b/go/arrow/array/extension_test.go
index 5b473fed428ef..a8e2b0dfd59bb 100644
--- a/go/arrow/array/extension_test.go
+++ b/go/arrow/array/extension_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/fixed_size_list.go b/go/arrow/array/fixed_size_list.go
index 62c3213861a7d..5923d68590b15 100644
--- a/go/arrow/array/fixed_size_list.go
+++ b/go/arrow/array/fixed_size_list.go
@@ -22,11 +22,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // FixedSizeList represents an immutable sequence of N array values.
diff --git a/go/arrow/array/fixed_size_list_test.go b/go/arrow/array/fixed_size_list_test.go
index 83dff923fe120..5c01199ddf987 100644
--- a/go/arrow/array/fixed_size_list_test.go
+++ b/go/arrow/array/fixed_size_list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/fixedsize_binary.go b/go/arrow/array/fixedsize_binary.go
index 5466156d5a256..6cdaeace939fd 100644
--- a/go/arrow/array/fixedsize_binary.go
+++ b/go/arrow/array/fixedsize_binary.go
@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of fixed-length binary strings.
diff --git a/go/arrow/array/fixedsize_binary_test.go b/go/arrow/array/fixedsize_binary_test.go
index b65c7051a9b3e..785725537cbdd 100644
--- a/go/arrow/array/fixedsize_binary_test.go
+++ b/go/arrow/array/fixedsize_binary_test.go
@@ -21,9 +21,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFixedSizeBinary(t *testing.T) {
diff --git a/go/arrow/array/fixedsize_binarybuilder.go b/go/arrow/array/fixedsize_binarybuilder.go
index ba4b474a89fd0..230a65fd2d352 100644
--- a/go/arrow/array/fixedsize_binarybuilder.go
+++ b/go/arrow/array/fixedsize_binarybuilder.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A FixedSizeBinaryBuilder is used to build a FixedSizeBinary array using the Append methods.
diff --git a/go/arrow/array/fixedsize_binarybuilder_test.go b/go/arrow/array/fixedsize_binarybuilder_test.go
index e3962ad3b9372..8e4a0ac1e46a7 100644
--- a/go/arrow/array/fixedsize_binarybuilder_test.go
+++ b/go/arrow/array/fixedsize_binarybuilder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/float16.go b/go/arrow/array/float16.go
index de499e26706cc..4260f8e3774b4 100644
--- a/go/arrow/array/float16.go
+++ b/go/arrow/array/float16.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of Float16 values.
diff --git a/go/arrow/array/float16_builder.go b/go/arrow/array/float16_builder.go
index f96ab6037e002..033b9fa2d8028 100644
--- a/go/arrow/array/float16_builder.go
+++ b/go/arrow/array/float16_builder.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Float16Builder struct {
diff --git a/go/arrow/array/float16_builder_test.go b/go/arrow/array/float16_builder_test.go
index 6ee028d978fb0..f8c5890179869 100644
--- a/go/arrow/array/float16_builder_test.go
+++ b/go/arrow/array/float16_builder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/interval.go b/go/arrow/array/interval.go
index ff059c92c8583..2a5529f1c30f7 100644
--- a/go/arrow/array/interval.go
+++ b/go/arrow/array/interval.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 func NewIntervalData(data arrow.ArrayData) arrow.Array {
diff --git a/go/arrow/array/interval_test.go b/go/arrow/array/interval_test.go
index 50a96e4779f03..f83fc52dfa34e 100644
--- a/go/arrow/array/interval_test.go
+++ b/go/arrow/array/interval_test.go
@@ -20,9 +20,9 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/json_reader.go b/go/arrow/array/json_reader.go
index e09717c4199b7..2f05d4b70dd76 100644
--- a/go/arrow/array/json_reader.go
+++ b/go/arrow/array/json_reader.go
@@ -22,10 +22,10 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Option func(config)
diff --git a/go/arrow/array/json_reader_test.go b/go/arrow/array/json_reader_test.go
index 3a095a0d33189..7f12bf211dd04 100644
--- a/go/arrow/array/json_reader_test.go
+++ b/go/arrow/array/json_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/list.go b/go/arrow/array/list.go
index d8d8b8c76165a..f10e2072c43a2 100644
--- a/go/arrow/array/list.go
+++ b/go/arrow/array/list.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type ListLike interface {
diff --git a/go/arrow/array/list_test.go b/go/arrow/array/list_test.go
index bf3555b3f6603..11404b2d8bb95 100644
--- a/go/arrow/array/list_test.go
+++ b/go/arrow/array/list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index 9945a90ce495e..fe07a68785067 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Map represents an immutable sequence of Key/Value structs. It is a
diff --git a/go/arrow/array/map_test.go b/go/arrow/array/map_test.go
index 3fe78549ec803..a7ecc032682bc 100644
--- a/go/arrow/array/map_test.go
+++ b/go/arrow/array/map_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/null.go b/go/arrow/array/null.go
index 150a1030eb49d..2735a88a92cb3 100644
--- a/go/arrow/array/null.go
+++ b/go/arrow/array/null.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Null represents an immutable, degenerate array with no physical storage.
diff --git a/go/arrow/array/null_test.go b/go/arrow/array/null_test.go
index e1bf1e0345b84..5d230ec5cec71 100644
--- a/go/arrow/array/null_test.go
+++ b/go/arrow/array/null_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numeric.gen.go b/go/arrow/array/numeric.gen.go
index a3e1101516aa6..59c9a979768d5 100644
--- a/go/arrow/array/numeric.gen.go
+++ b/go/arrow/array/numeric.gen.go
@@ -23,8 +23,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of int64 values.
diff --git a/go/arrow/array/numeric.gen.go.tmpl b/go/arrow/array/numeric.gen.go.tmpl
index 34d17fbfc8854..027456009daad 100644
--- a/go/arrow/array/numeric.gen.go.tmpl
+++ b/go/arrow/array/numeric.gen.go.tmpl
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numeric_test.go b/go/arrow/array/numeric_test.go
index 34f59c238cbef..91dd724c8da50 100644
--- a/go/arrow/array/numeric_test.go
+++ b/go/arrow/array/numeric_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen.go b/go/arrow/array/numericbuilder.gen.go
index 7f01180f55957..52b189d6ed453 100644
--- a/go/arrow/array/numericbuilder.gen.go
+++ b/go/arrow/array/numericbuilder.gen.go
@@ -27,11 +27,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Int64Builder struct {
diff --git a/go/arrow/array/numericbuilder.gen.go.tmpl b/go/arrow/array/numericbuilder.gen.go.tmpl
index cf663c031f616..82ac35465d424 100644
--- a/go/arrow/array/numericbuilder.gen.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen.go.tmpl
@@ -17,11 +17,11 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numericbuilder.gen_test.go b/go/arrow/array/numericbuilder.gen_test.go
index b5986775cd995..e1f72773403d8 100644
--- a/go/arrow/array/numericbuilder.gen_test.go
+++ b/go/arrow/array/numericbuilder.gen_test.go
@@ -21,9 +21,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen_test.go.tmpl b/go/arrow/array/numericbuilder.gen_test.go.tmpl
index bc8c993374671..eddd884e2eddf 100644
--- a/go/arrow/array/numericbuilder.gen_test.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen_test.go.tmpl
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/record.go b/go/arrow/array/record.go
index 0b0fe4c3847fc..d080f726e472d 100644
--- a/go/arrow/array/record.go
+++ b/go/arrow/array/record.go
@@ -22,10 +22,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // RecordReader reads a stream of records.
diff --git a/go/arrow/array/record_test.go b/go/arrow/array/record_test.go
index da50a30b646f1..7d438d1f1f81e 100644
--- a/go/arrow/array/record_test.go
+++ b/go/arrow/array/record_test.go
@@ -21,9 +21,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 86e27c970cbe9..9ab7c938ef5d8 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -23,9 +23,9 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // String represents an immutable sequence of variable-length UTF-8 strings.
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index fbc106b098332..d743a3ec7f37f 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/struct.go b/go/arrow/array/struct.go
index 248a25bf6044d..94052953852c2 100644
--- a/go/arrow/array/struct.go
+++ b/go/arrow/array/struct.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Struct represents an ordered sequence of relative types.
diff --git a/go/arrow/array/struct_test.go b/go/arrow/array/struct_test.go
index 86a5b311fcc21..1b0dc5a3e4b19 100644
--- a/go/arrow/array/struct_test.go
+++ b/go/arrow/array/struct_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/table.go b/go/arrow/array/table.go
index 6456992e34973..a987dd057f82c 100644
--- a/go/arrow/array/table.go
+++ b/go/arrow/array/table.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // NewColumnSlice returns a new zero-copy slice of the column with the indicated
diff --git a/go/arrow/array/table_test.go b/go/arrow/array/table_test.go
index 8e22d53963ba4..9535ae6b089bb 100644
--- a/go/arrow/array/table_test.go
+++ b/go/arrow/array/table_test.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestChunked(t *testing.T) {
diff --git a/go/arrow/array/timestamp.go b/go/arrow/array/timestamp.go
index 2928b1fc77ff6..6ffb43e067af0 100644
--- a/go/arrow/array/timestamp.go
+++ b/go/arrow/array/timestamp.go
@@ -24,11 +24,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Timestamp represents an immutable sequence of arrow.Timestamp values.
diff --git a/go/arrow/array/timestamp_test.go b/go/arrow/array/timestamp_test.go
index 1e55364e8da0d..acbad8b586dd4 100644
--- a/go/arrow/array/timestamp_test.go
+++ b/go/arrow/array/timestamp_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/union.go b/go/arrow/array/union.go
index 869355ac7108a..c0a5050560634 100644
--- a/go/arrow/array/union.go
+++ b/go/arrow/array/union.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Union is a convenience interface to encompass both Sparse and Dense
diff --git a/go/arrow/array/union_test.go b/go/arrow/array/union_test.go
index 2f2bf3b84e9f7..e876f5def26d3 100644
--- a/go/arrow/array/union_test.go
+++ b/go/arrow/array/union_test.go
@@ -21,9 +21,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/array/util.go b/go/arrow/array/util.go
index 54d15a8095c80..a1b3cc7d4e5f7 100644
--- a/go/arrow/array/util.go
+++ b/go/arrow/array/util.go
@@ -22,11 +22,11 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 func min(a, b int) int {
diff --git a/go/arrow/array/util_test.go b/go/arrow/array/util_test.go
index d3d2b37365513..84a6debdf3946 100644
--- a/go/arrow/array/util_test.go
+++ b/go/arrow/array/util_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/arrio/arrio.go b/go/arrow/arrio/arrio.go
index 466a93a68400a..51cf6dc46d44a 100644
--- a/go/arrow/arrio/arrio.go
+++ b/go/arrow/arrio/arrio.go
@@ -22,7 +22,7 @@ import (
 	"errors"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Reader is the interface that wraps the Read method.
diff --git a/go/arrow/arrio/arrio_test.go b/go/arrow/arrio/arrio_test.go
index 7e9aac8fbe520..c80d5d2569d67 100644
--- a/go/arrow/arrio/arrio_test.go
+++ b/go/arrow/arrio/arrio_test.go
@@ -22,11 +22,11 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type copyKind int
diff --git a/go/arrow/bitutil/bitmaps.go b/go/arrow/bitutil/bitmaps.go
index 2e9c0601c3c45..d7516771def7f 100644
--- a/go/arrow/bitutil/bitmaps.go
+++ b/go/arrow/bitutil/bitmaps.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // BitmapReader is a simple bitmap reader for a byte slice.
diff --git a/go/arrow/bitutil/bitmaps_test.go b/go/arrow/bitutil/bitmaps_test.go
index 60022a179d1da..c926bff39e09a 100644
--- a/go/arrow/bitutil/bitmaps_test.go
+++ b/go/arrow/bitutil/bitmaps_test.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/bitutil/bitutil.go b/go/arrow/bitutil/bitutil.go
index a4a1519b8f940..dc510a8b374c4 100644
--- a/go/arrow/bitutil/bitutil.go
+++ b/go/arrow/bitutil/bitutil.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/bitutil/bitutil_test.go b/go/arrow/bitutil/bitutil_test.go
index 9e29e9d04d1db..189c8541f4925 100644
--- a/go/arrow/bitutil/bitutil_test.go
+++ b/go/arrow/bitutil/bitutil_test.go
@@ -21,8 +21,8 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index 1d454c57f722e..f9693851d7483 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -46,10 +46,10 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index 187c2deb9755f..91f1b352e0327 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -45,11 +45,11 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
 )
 
 func encodeCMetadata(keys, values []string) []byte {
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index f09fa3ff2f6fa..607cfe53217a6 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -35,12 +35,12 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index 2df52dcb3cd40..1251b20201e41 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -69,10 +69,10 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 )
 
 const (
diff --git a/go/arrow/cdata/exports.go b/go/arrow/cdata/exports.go
index 9d2576818e31c..7353df62d113a 100644
--- a/go/arrow/cdata/exports.go
+++ b/go/arrow/cdata/exports.go
@@ -20,8 +20,8 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 // #include <stdlib.h>
diff --git a/go/arrow/cdata/import_allocator.go b/go/arrow/cdata/import_allocator.go
index eff8c7517caef..cf1c6a961ff37 100644
--- a/go/arrow/cdata/import_allocator.go
+++ b/go/arrow/cdata/import_allocator.go
@@ -20,7 +20,7 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // #include "arrow/c/helpers.h"
diff --git a/go/arrow/cdata/interface.go b/go/arrow/cdata/interface.go
index bf5c5270bae2f..8ce06280a0bf5 100644
--- a/go/arrow/cdata/interface.go
+++ b/go/arrow/cdata/interface.go
@@ -22,10 +22,10 @@ package cdata
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/test/test_cimport.go b/go/arrow/cdata/test/test_cimport.go
index a7c5dc034496a..147c3691f0c71 100644
--- a/go/arrow/cdata/test/test_cimport.go
+++ b/go/arrow/cdata/test/test_cimport.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/cdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/cdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/compute/arithmetic.go b/go/arrow/compute/arithmetic.go
index 2fb95f06ff84a..1ee1959b2ddc8 100644
--- a/go/arrow/compute/arithmetic.go
+++ b/go/arrow/compute/arithmetic.go
@@ -22,12 +22,12 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 type (
diff --git a/go/arrow/compute/arithmetic_test.go b/go/arrow/compute/arithmetic_test.go
index a99b2074eb69f..821ffd9e068d4 100644
--- a/go/arrow/compute/arithmetic_test.go
+++ b/go/arrow/compute/arithmetic_test.go
@@ -26,16 +26,16 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/klauspost/cpuid/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/compute/cast.go b/go/arrow/compute/cast.go
index 8b720a2bad5d8..133a983038ce1 100644
--- a/go/arrow/compute/cast.go
+++ b/go/arrow/compute/cast.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/cast_test.go b/go/arrow/compute/cast_test.go
index cc301cc35e6e5..10957a45167aa 100644
--- a/go/arrow/compute/cast_test.go
+++ b/go/arrow/compute/cast_test.go
@@ -26,16 +26,16 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/datum.go b/go/arrow/compute/datum.go
index 1d3c1b4dab700..98bd1f1a0a326 100644
--- a/go/arrow/compute/datum.go
+++ b/go/arrow/compute/datum.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 //go:generate go run golang.org/x/tools/cmd/stringer -type=DatumKind -linecomment
diff --git a/go/arrow/compute/example_test.go b/go/arrow/compute/example_test.go
index f0db9f377868e..e2b07b7e191ae 100644
--- a/go/arrow/compute/example_test.go
+++ b/go/arrow/compute/example_test.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // This example demonstrates how to register a custom scalar function.
diff --git a/go/arrow/compute/exec.go b/go/arrow/compute/exec.go
index 84e3310cc2df8..eba47e64bd509 100644
--- a/go/arrow/compute/exec.go
+++ b/go/arrow/compute/exec.go
@@ -22,9 +22,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 func haveChunkedArray(values []Datum) bool {
diff --git a/go/arrow/compute/exec/kernel.go b/go/arrow/compute/exec/kernel.go
index 327426da68eb9..766857f63e565 100644
--- a/go/arrow/compute/exec/kernel.go
+++ b/go/arrow/compute/exec/kernel.go
@@ -24,10 +24,10 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/slices"
 )
 
diff --git a/go/arrow/compute/exec/kernel_test.go b/go/arrow/compute/exec/kernel_test.go
index 16a29ea2deda6..4df6b42ff9408 100644
--- a/go/arrow/compute/exec/kernel_test.go
+++ b/go/arrow/compute/exec/kernel_test.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/span.go b/go/arrow/compute/exec/span.go
index b6d240fa4a0be..0b5f6208227f5 100644
--- a/go/arrow/compute/exec/span.go
+++ b/go/arrow/compute/exec/span.go
@@ -23,11 +23,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // BufferSpan is a lightweight Buffer holder for ArraySpans that does not
diff --git a/go/arrow/compute/exec/span_test.go b/go/arrow/compute/exec/span_test.go
index c642be1c30c23..474c005b44642 100644
--- a/go/arrow/compute/exec/span_test.go
+++ b/go/arrow/compute/exec/span_test.go
@@ -24,14 +24,14 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/utils.go b/go/arrow/compute/exec/utils.go
index 6d83b75da1313..17bc30ef2adb0 100644
--- a/go/arrow/compute/exec/utils.go
+++ b/go/arrow/compute/exec/utils.go
@@ -25,13 +25,13 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/exec/utils_test.go b/go/arrow/compute/exec/utils_test.go
index e9bb07177f2ac..b26e4ff41e79f 100644
--- a/go/arrow/compute/exec/utils_test.go
+++ b/go/arrow/compute/exec/utils_test.go
@@ -21,10 +21,10 @@ package exec_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec_internals_test.go b/go/arrow/compute/exec_internals_test.go
index eb9273d23389f..bae32268862ff 100644
--- a/go/arrow/compute/exec_internals_test.go
+++ b/go/arrow/compute/exec_internals_test.go
@@ -24,13 +24,13 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/exec_test.go b/go/arrow/compute/exec_test.go
index 30bfbc0246a1c..a37f67c03e8ce 100644
--- a/go/arrow/compute/exec_test.go
+++ b/go/arrow/compute/exec_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index 6da7ed1293065..1cba0b1e19f69 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -25,14 +25,14 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // ExecCtx holds simple contextual information for execution
diff --git a/go/arrow/compute/expression.go b/go/arrow/compute/expression.go
index 9f20c9704dca7..fbb6c502d98ab 100644
--- a/go/arrow/compute/expression.go
+++ b/go/arrow/compute/expression.go
@@ -28,14 +28,14 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 var hashSeed = maphash.MakeSeed()
diff --git a/go/arrow/compute/expression_test.go b/go/arrow/compute/expression_test.go
index 71b1b64c4b0c1..b3b44ae1faa61 100644
--- a/go/arrow/compute/expression_test.go
+++ b/go/arrow/compute/expression_test.go
@@ -22,11 +22,11 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exprs/builders.go b/go/arrow/compute/exprs/builders.go
index 39606c27e714a..0b694525d1b47 100644
--- a/go/arrow/compute/exprs/builders.go
+++ b/go/arrow/compute/exprs/builders.go
@@ -25,8 +25,8 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/builders_test.go b/go/arrow/compute/exprs/builders_test.go
index e42d7569a8f03..69501622359d5 100644
--- a/go/arrow/compute/exprs/builders_test.go
+++ b/go/arrow/compute/exprs/builders_test.go
@@ -21,8 +21,8 @@ package exprs_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/exec.go b/go/arrow/compute/exprs/exec.go
index d63752696082b..800ffe62f2559 100644
--- a/go/arrow/compute/exprs/exec.go
+++ b/go/arrow/compute/exprs/exec.go
@@ -23,15 +23,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/exec_internal_test.go b/go/arrow/compute/exprs/exec_internal_test.go
index 9475a9a8cbca9..680bf36f11958 100644
--- a/go/arrow/compute/exprs/exec_internal_test.go
+++ b/go/arrow/compute/exprs/exec_internal_test.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/exprs/exec_test.go b/go/arrow/compute/exprs/exec_test.go
index e30d2afdb73f8..65cafc8e62ddb 100644
--- a/go/arrow/compute/exprs/exec_test.go
+++ b/go/arrow/compute/exprs/exec_test.go
@@ -23,12 +23,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/extension_types.go b/go/arrow/compute/exprs/extension_types.go
index ce375492d67f1..db7992b8f089f 100644
--- a/go/arrow/compute/exprs/extension_types.go
+++ b/go/arrow/compute/exprs/extension_types.go
@@ -24,8 +24,8 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type simpleExtensionTypeFactory[P comparable] struct {
diff --git a/go/arrow/compute/exprs/field_refs.go b/go/arrow/compute/exprs/field_refs.go
index fd4313818195e..e95e3c8c9abb9 100644
--- a/go/arrow/compute/exprs/field_refs.go
+++ b/go/arrow/compute/exprs/field_refs.go
@@ -21,11 +21,11 @@ package exprs
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 )
 
diff --git a/go/arrow/compute/exprs/types.go b/go/arrow/compute/exprs/types.go
index 9f807e1e1ecbc..6a5b81d11b3eb 100644
--- a/go/arrow/compute/exprs/types.go
+++ b/go/arrow/compute/exprs/types.go
@@ -24,8 +24,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/fieldref.go b/go/arrow/compute/fieldref.go
index ee6f39948ebf1..565ae3bfadbd0 100644
--- a/go/arrow/compute/fieldref.go
+++ b/go/arrow/compute/fieldref.go
@@ -27,8 +27,8 @@ import (
 	"unicode"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 var (
diff --git a/go/arrow/compute/fieldref_test.go b/go/arrow/compute/fieldref_test.go
index c38ad8ac1fe30..c4fa72182835f 100644
--- a/go/arrow/compute/fieldref_test.go
+++ b/go/arrow/compute/fieldref_test.go
@@ -19,10 +19,10 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/functions.go b/go/arrow/compute/functions.go
index a1905f91850f0..b85062721d9b8 100644
--- a/go/arrow/compute/functions.go
+++ b/go/arrow/compute/functions.go
@@ -23,8 +23,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 type Function interface {
diff --git a/go/arrow/compute/functions_test.go b/go/arrow/compute/functions_test.go
index b37da285badd0..1e6bbd598e0c9 100644
--- a/go/arrow/compute/functions_test.go
+++ b/go/arrow/compute/functions_test.go
@@ -21,8 +21,8 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic.go b/go/arrow/compute/internal/kernels/base_arithmetic.go
index 67e80af74f511..c7950877264df 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic.go
@@ -24,11 +24,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
index 0e78e6c9183ff..942b8e4ff5600 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/sys/cpu"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
index 29cce7830e0f4..6814e834b4bf3 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
index e9b03551f81b1..633ec5f4f18e5 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
index 4f160a1411091..8e46ca030c8b7 100644
--- a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
+++ b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
@@ -19,7 +19,7 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/boolean_cast.go b/go/arrow/compute/internal/kernels/boolean_cast.go
index 18d04c845c41d..923c5b3f54512 100644
--- a/go/arrow/compute/internal/kernels/boolean_cast.go
+++ b/go/arrow/compute/internal/kernels/boolean_cast.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 func isNonZero[T exec.FixedWidthTypes](ctx *exec.KernelCtx, in []T, out []byte) error {
diff --git a/go/arrow/compute/internal/kernels/cast.go b/go/arrow/compute/internal/kernels/cast.go
index 5a71206b2476c..bc4ee3abd128c 100644
--- a/go/arrow/compute/internal/kernels/cast.go
+++ b/go/arrow/compute/internal/kernels/cast.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 type CastOptions struct {
diff --git a/go/arrow/compute/internal/kernels/cast_numeric.go b/go/arrow/compute/internal/kernels/cast_numeric.go
index 4e5c5c1d9ea77..2e893c7205f6a 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 var castNumericUnsafe func(itype, otype arrow.Type, in, out []byte, len int) = castNumericGo
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
index 6b28441ec083e..eafa4b41001ae 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
index d53a4486f6983..75ad79fd0e7f3 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
index 1cbea033dec27..d04f393c4c099 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_temporal.go b/go/arrow/compute/internal/kernels/cast_temporal.go
index 82fce1e33c959..542a8a4590b28 100644
--- a/go/arrow/compute/internal/kernels/cast_temporal.go
+++ b/go/arrow/compute/internal/kernels/cast_temporal.go
@@ -24,10 +24,10 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const millisecondsInDay = 86400000
diff --git a/go/arrow/compute/internal/kernels/helpers.go b/go/arrow/compute/internal/kernels/helpers.go
index ed25071c9d87f..686c4b3e0c29a 100644
--- a/go/arrow/compute/internal/kernels/helpers.go
+++ b/go/arrow/compute/internal/kernels/helpers.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/numeric_cast.go b/go/arrow/compute/internal/kernels/numeric_cast.go
index 8e5350754723d..c055552bf7ff5 100644
--- a/go/arrow/compute/internal/kernels/numeric_cast.go
+++ b/go/arrow/compute/internal/kernels/numeric_cast.go
@@ -23,13 +23,13 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/rounding.go b/go/arrow/compute/internal/kernels/rounding.go
index 2f58a9faea8a2..8a1bec1180ac8 100644
--- a/go/arrow/compute/internal/kernels/rounding.go
+++ b/go/arrow/compute/internal/kernels/rounding.go
@@ -22,11 +22,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_arithmetic.go b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
index 9cb32ae64a4a9..cf17e9fd9548b 100644
--- a/go/arrow/compute/internal/kernels/scalar_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // scalar kernel that ignores (assumed all-null inputs) and returns null
diff --git a/go/arrow/compute/internal/kernels/scalar_boolean.go b/go/arrow/compute/internal/kernels/scalar_boolean.go
index 812f4ad1bd363..0707c92e6a198 100644
--- a/go/arrow/compute/internal/kernels/scalar_boolean.go
+++ b/go/arrow/compute/internal/kernels/scalar_boolean.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 type computeWordFN func(leftTrue, leftFalse, rightTrue, rightFalse uint64) (outValid, outData uint64)
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
index 585d1bff01ab6..8e5ce1ab7c1ad 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
index 868179057ccf4..cf9fc1eeedbb8 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
index 56abad42b1ffc..c0aef5a04e9b8 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
@@ -18,7 +18,7 @@
 
 package kernels
 
-import "github.com/apache/arrow/go/v14/arrow/compute/exec"
+import "github.com/apache/arrow/go/v15/arrow/compute/exec"
 
 func genCompareKernel[T exec.NumericTypes](op CompareOperator) *CompareData {
 	return genGoCompareKernel(getCmpOp[T](op))
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
index 7cf96a4171d6c..f8b36a1e4be76 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparisons.go b/go/arrow/compute/internal/kernels/scalar_comparisons.go
index 8a957eafd85da..9a7640a8d8a39 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparisons.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparisons.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 type binaryKernel func(left, right, out []byte, offset int)
diff --git a/go/arrow/compute/internal/kernels/string_casts.go b/go/arrow/compute/internal/kernels/string_casts.go
index 3070514665d7d..76da901e33f8d 100644
--- a/go/arrow/compute/internal/kernels/string_casts.go
+++ b/go/arrow/compute/internal/kernels/string_casts.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 func validateUtf8Fsb(input *exec.ArraySpan) error {
diff --git a/go/arrow/compute/internal/kernels/types.go b/go/arrow/compute/internal/kernels/types.go
index 2788fb7054c53..481eab36059f8 100644
--- a/go/arrow/compute/internal/kernels/types.go
+++ b/go/arrow/compute/internal/kernels/types.go
@@ -21,10 +21,10 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 var (
diff --git a/go/arrow/compute/internal/kernels/vector_hash.go b/go/arrow/compute/internal/kernels/vector_hash.go
index e0ede826e876e..9401e31cc5b09 100644
--- a/go/arrow/compute/internal/kernels/vector_hash.go
+++ b/go/arrow/compute/internal/kernels/vector_hash.go
@@ -21,13 +21,13 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/hashing"
 )
 
 type HashState interface {
diff --git a/go/arrow/compute/internal/kernels/vector_run_end_encode.go b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
index e073ff1ff5308..a147bf7d50170 100644
--- a/go/arrow/compute/internal/kernels/vector_run_end_encode.go
+++ b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
@@ -24,14 +24,14 @@ import (
 	"sort"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type RunEndEncodeState struct {
diff --git a/go/arrow/compute/internal/kernels/vector_selection.go b/go/arrow/compute/internal/kernels/vector_selection.go
index c7a902bd008d0..714e452325bfd 100644
--- a/go/arrow/compute/internal/kernels/vector_selection.go
+++ b/go/arrow/compute/internal/kernels/vector_selection.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 type NullSelectionBehavior int8
diff --git a/go/arrow/compute/registry.go b/go/arrow/compute/registry.go
index 4f1c435fb680a..379e0ccbe86a9 100644
--- a/go/arrow/compute/registry.go
+++ b/go/arrow/compute/registry.go
@@ -21,7 +21,7 @@ package compute
 import (
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/registry_test.go b/go/arrow/compute/registry_test.go
index 428f7cf1d8fda..4e4f44f1d39b6 100644
--- a/go/arrow/compute/registry_test.go
+++ b/go/arrow/compute/registry_test.go
@@ -23,9 +23,9 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/scalar_bool.go b/go/arrow/compute/scalar_bool.go
index 49c745688284e..1f28a6e2bfcb2 100644
--- a/go/arrow/compute/scalar_bool.go
+++ b/go/arrow/compute/scalar_bool.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/scalar_bool_test.go b/go/arrow/compute/scalar_bool_test.go
index 6eadc973d6965..bd4f3c5c0df2b 100644
--- a/go/arrow/compute/scalar_bool_test.go
+++ b/go/arrow/compute/scalar_bool_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/compute/scalar_compare.go b/go/arrow/compute/scalar_compare.go
index 476f37711e289..24a4191a10999 100644
--- a/go/arrow/compute/scalar_compare.go
+++ b/go/arrow/compute/scalar_compare.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 type compareFunction struct {
diff --git a/go/arrow/compute/scalar_compare_test.go b/go/arrow/compute/scalar_compare_test.go
index 13fdd24fdd6b3..d209f72c800b0 100644
--- a/go/arrow/compute/scalar_compare_test.go
+++ b/go/arrow/compute/scalar_compare_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/selection.go b/go/arrow/compute/selection.go
index ed6d80418d3f6..90bc5280ef2a7 100644
--- a/go/arrow/compute/selection.go
+++ b/go/arrow/compute/selection.go
@@ -22,10 +22,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/arrow/compute/utils.go b/go/arrow/compute/utils.go
index cc4d6edc48ec8..9de6523fd0b5f 100644
--- a/go/arrow/compute/utils.go
+++ b/go/arrow/compute/utils.go
@@ -24,12 +24,12 @@ import (
 	"math"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/compute/vector_hash.go b/go/arrow/compute/vector_hash.go
index 5f9aec55c55bc..144c123380fe2 100644
--- a/go/arrow/compute/vector_hash.go
+++ b/go/arrow/compute/vector_hash.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_hash_test.go b/go/arrow/compute/vector_hash_test.go
index 50c96ddc04f6c..9410720de7941 100644
--- a/go/arrow/compute/vector_hash_test.go
+++ b/go/arrow/compute/vector_hash_test.go
@@ -23,13 +23,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/vector_run_end_test.go b/go/arrow/compute/vector_run_end_test.go
index 8d894d96b8f0a..51c0f834ceb6a 100644
--- a/go/arrow/compute/vector_run_end_test.go
+++ b/go/arrow/compute/vector_run_end_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/vector_run_ends.go b/go/arrow/compute/vector_run_ends.go
index 48f3dcba8c481..3e47c67de3c35 100644
--- a/go/arrow/compute/vector_run_ends.go
+++ b/go/arrow/compute/vector_run_ends.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_selection_test.go b/go/arrow/compute/vector_selection_test.go
index 10788d60e10d2..f44840ba72034 100644
--- a/go/arrow/compute/vector_selection_test.go
+++ b/go/arrow/compute/vector_selection_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/csv/common.go b/go/arrow/csv/common.go
index 91f42897a24a6..2a1f7300a986f 100644
--- a/go/arrow/csv/common.go
+++ b/go/arrow/csv/common.go
@@ -22,8 +22,8 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/csv/reader.go b/go/arrow/csv/reader.go
index 80af520a12b7f..e58b426d837fb 100644
--- a/go/arrow/csv/reader.go
+++ b/go/arrow/csv/reader.go
@@ -29,13 +29,13 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Reader wraps encoding/csv.Reader and creates array.Records from a schema.
diff --git a/go/arrow/csv/reader_test.go b/go/arrow/csv/reader_test.go
index f481cd2e961d3..dfcb6625bd7cc 100644
--- a/go/arrow/csv/reader_test.go
+++ b/go/arrow/csv/reader_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/csv"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/csv"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/csv/transformer.go b/go/arrow/csv/transformer.go
index 7c8eafcee1a59..0f0181520b847 100644
--- a/go/arrow/csv/transformer.go
+++ b/go/arrow/csv/transformer.go
@@ -25,8 +25,8 @@ import (
 	"math/big"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 func (w *Writer) transformColToStringArr(typ arrow.DataType, col arrow.Array) []string {
diff --git a/go/arrow/csv/writer.go b/go/arrow/csv/writer.go
index e558364ecf16d..a672008b58a07 100644
--- a/go/arrow/csv/writer.go
+++ b/go/arrow/csv/writer.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Writer wraps encoding/csv.Writer and writes arrow.Record based on a schema.
diff --git a/go/arrow/csv/writer_test.go b/go/arrow/csv/writer_test.go
index f945023790426..1918e2e492dff 100644
--- a/go/arrow/csv/writer_test.go
+++ b/go/arrow/csv/writer_test.go
@@ -25,14 +25,14 @@ import (
 	"log"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/csv"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/csv"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 )
 
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index f0fb24ec873c5..24113b55899dc 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -21,7 +21,7 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Type is a logical type. They can be expressed as
diff --git a/go/arrow/datatype_binary_test.go b/go/arrow/datatype_binary_test.go
index c47df3da1db9c..25ba6e8db4ba4 100644
--- a/go/arrow/datatype_binary_test.go
+++ b/go/arrow/datatype_binary_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestBinaryType(t *testing.T) {
diff --git a/go/arrow/datatype_extension_test.go b/go/arrow/datatype_extension_test.go
index c542b22b769e6..9811800400506 100644
--- a/go/arrow/datatype_extension_test.go
+++ b/go/arrow/datatype_extension_test.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index fc0b3aea56e70..bcbc8ef6aec87 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/internal/json"
 
 	"golang.org/x/xerrors"
 )
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index 1d3a07de09c1d..918572d40b8f4 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/datatype_nested.go b/go/arrow/datatype_nested.go
index 4ae4880334620..e381cd7047e45 100644
--- a/go/arrow/datatype_nested.go
+++ b/go/arrow/datatype_nested.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 type (
diff --git a/go/arrow/datatype_null_test.go b/go/arrow/datatype_null_test.go
index 286a72fb7fea3..57cddfadb8ef8 100644
--- a/go/arrow/datatype_null_test.go
+++ b/go/arrow/datatype_null_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestNullType(t *testing.T) {
diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index ff9c088b9d638..7bde39d327417 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -23,7 +23,7 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index 102eede6d3b28..879f2849028f8 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -22,7 +22,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/decimal256/decimal256.go b/go/arrow/decimal256/decimal256.go
index cf2157fdd48ed..5f2ad5f32165c 100644
--- a/go/arrow/decimal256/decimal256.go
+++ b/go/arrow/decimal256/decimal256.go
@@ -23,8 +23,8 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal256/decimal256_test.go b/go/arrow/decimal256/decimal256_test.go
index 9c734e23aa0d6..3be6a1944406f 100644
--- a/go/arrow/decimal256/decimal256_test.go
+++ b/go/arrow/decimal256/decimal256_test.go
@@ -23,7 +23,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/doc.go b/go/arrow/doc.go
index 4a5f5a3c9ef72..c8da330e4f8a1 100644
--- a/go/arrow/doc.go
+++ b/go/arrow/doc.go
@@ -36,7 +36,7 @@ To build with tinygo include the noasm build tag.
 */
 package arrow
 
-const PkgVersion = "14.0.0-SNAPSHOT"
+const PkgVersion = "15.0.0-SNAPSHOT"
 
 //go:generate go run _tools/tmpl/main.go -i -data=numeric.tmpldata type_traits_numeric.gen.go.tmpl type_traits_numeric.gen_test.go.tmpl array/numeric.gen.go.tmpl array/numericbuilder.gen.go.tmpl array/bufferbuilder_numeric.gen.go.tmpl
 //go:generate go run _tools/tmpl/main.go -i -data=datatype_numeric.gen.go.tmpldata datatype_numeric.gen.go.tmpl tensor/numeric.gen.go.tmpl tensor/numeric.gen_test.go.tmpl
diff --git a/go/arrow/encoded/ree_utils.go b/go/arrow/encoded/ree_utils.go
index 1f71e7b5210cf..2ff4e7cadd38b 100644
--- a/go/arrow/encoded/ree_utils.go
+++ b/go/arrow/encoded/ree_utils.go
@@ -20,7 +20,7 @@ import (
 	"math"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // FindPhysicalIndex performs a binary search on the run-ends to return
diff --git a/go/arrow/encoded/ree_utils_test.go b/go/arrow/encoded/ree_utils_test.go
index 785a3b105a47d..9470331002b80 100644
--- a/go/arrow/encoded/ree_utils_test.go
+++ b/go/arrow/encoded/ree_utils_test.go
@@ -21,10 +21,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/endian/endian.go b/go/arrow/endian/endian.go
index 3ecda7b3600b7..d4865025b1fb0 100644
--- a/go/arrow/endian/endian.go
+++ b/go/arrow/endian/endian.go
@@ -17,8 +17,8 @@
 package endian
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
 )
 
 type Endianness flatbuf.Endianness
diff --git a/go/arrow/example_test.go b/go/arrow/example_test.go
index 10b3633f65536..b28cc9093739f 100644
--- a/go/arrow/example_test.go
+++ b/go/arrow/example_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 // This example demonstrates how to build an array of int64 values using a builder and Append.
diff --git a/go/arrow/flight/basic_auth_flight_test.go b/go/arrow/flight/basic_auth_flight_test.go
index 0f63a400353d2..4097bf02edeff 100755
--- a/go/arrow/flight/basic_auth_flight_test.go
+++ b/go/arrow/flight/basic_auth_flight_test.go
@@ -22,7 +22,7 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index c9a1417accab4..8c400eb66b64d 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/cookie_middleware_test.go b/go/arrow/flight/cookie_middleware_test.go
index 2bde37fc0bb85..bdfe4fb32c1a5 100644
--- a/go/arrow/flight/cookie_middleware_test.go
+++ b/go/arrow/flight/cookie_middleware_test.go
@@ -28,7 +28,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/example_flight_server_test.go b/go/arrow/flight/example_flight_server_test.go
index 09f01361d13a0..d3a71b3b67ade 100755
--- a/go/arrow/flight/example_flight_server_test.go
+++ b/go/arrow/flight/example_flight_server_test.go
@@ -23,7 +23,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flight_middleware_test.go b/go/arrow/flight/flight_middleware_test.go
index f2b240d1f2e45..e6faa1b7df1d2 100755
--- a/go/arrow/flight/flight_middleware_test.go
+++ b/go/arrow/flight/flight_middleware_test.go
@@ -23,8 +23,8 @@ import (
 	sync "sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flight_test.go b/go/arrow/flight/flight_test.go
index 7cd724b76b8ce..cd37658603d5b 100755
--- a/go/arrow/flight/flight_test.go
+++ b/go/arrow/flight/flight_test.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flightsql/client.go b/go/arrow/flight/flightsql/client.go
index 13d046661e96d..c0c7e2cf20a28 100644
--- a/go/arrow/flight/flightsql/client.go
+++ b/go/arrow/flight/flightsql/client.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index bb4ae29477997..3efe4ba4049b8 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/column_metadata.go b/go/arrow/flight/flightsql/column_metadata.go
index d9785892888b2..8e0a69b99d055 100644
--- a/go/arrow/flight/flightsql/column_metadata.go
+++ b/go/arrow/flight/flightsql/column_metadata.go
@@ -19,7 +19,7 @@ package flightsql
 import (
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/driver/README.md b/go/arrow/flight/flightsql/driver/README.md
index b8850527c19c1..f1447a7d24256 100644
--- a/go/arrow/flight/flightsql/driver/README.md
+++ b/go/arrow/flight/flightsql/driver/README.md
@@ -36,7 +36,7 @@ connection pooling, transactions combined with ease of use (see (#usage)).
 ## Prerequisites
 
 * Go 1.17+
-* Installation via `go get -u github.com/apache/arrow/go/v14/arrow/flight/flightsql`
+* Installation via `go get -u github.com/apache/arrow/go/v15/arrow/flight/flightsql`
 * Backend speaking FlightSQL
 
 ---------------------------------------
@@ -55,7 +55,7 @@ import (
     "database/sql"
     "time"
 
-    _ "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+    _ "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 // Open the connection to an SQLite backend
@@ -141,7 +141,7 @@ import (
     "log"
     "time"
 
-    "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+    "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/driver/config_test.go b/go/arrow/flight/flightsql/driver/config_test.go
index abcececeaf214..6b24b535585d9 100644
--- a/go/arrow/flight/flightsql/driver/config_test.go
+++ b/go/arrow/flight/flightsql/driver/config_test.go
@@ -22,7 +22,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
 )
 
 func TestConfigTLSRegistry(t *testing.T) {
diff --git a/go/arrow/flight/flightsql/driver/driver.go b/go/arrow/flight/flightsql/driver/driver.go
index b4cb0d2dbda2e..e325489236c6d 100644
--- a/go/arrow/flight/flightsql/driver/driver.go
+++ b/go/arrow/flight/flightsql/driver/driver.go
@@ -25,11 +25,11 @@ import (
 	"sort"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go
index 4449b390974a7..a388bf155ec99 100644
--- a/go/arrow/flight/flightsql/driver/driver_test.go
+++ b/go/arrow/flight/flightsql/driver/driver_test.go
@@ -33,13 +33,13 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 const defaultTableName = "drivertest"
diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go
index 99352e7251c53..022e9da4925f9 100644
--- a/go/arrow/flight/flightsql/driver/utils.go
+++ b/go/arrow/flight/flightsql/driver/utils.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 // *** GRPC helpers ***
diff --git a/go/arrow/flight/flightsql/driver/utils_test.go b/go/arrow/flight/flightsql/driver/utils_test.go
index 355c888f56cc4..8f5ea031adf28 100644
--- a/go/arrow/flight/flightsql/driver/utils_test.go
+++ b/go/arrow/flight/flightsql/driver/utils_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
index 6508833876fa5..1a50422f826f3 100644
--- a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
+++ b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
@@ -27,9 +27,9 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/example/sql_batch_reader.go b/go/arrow/flight/flightsql/example/sql_batch_reader.go
index 7101b8f830a6f..36a0d7b424544 100644
--- a/go/arrow/flight/flightsql/example/sql_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sql_batch_reader.go
@@ -26,11 +26,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/wrapperspb"
diff --git a/go/arrow/flight/flightsql/example/sqlite_info.go b/go/arrow/flight/flightsql/example/sqlite_info.go
index bf29265853c65..c993af97f7449 100644
--- a/go/arrow/flight/flightsql/example/sqlite_info.go
+++ b/go/arrow/flight/flightsql/example/sqlite_info.go
@@ -20,8 +20,8 @@
 package example
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 func SqlInfoResultMap() flightsql.SqlInfoResultMap {
diff --git a/go/arrow/flight/flightsql/example/sqlite_server.go b/go/arrow/flight/flightsql/example/sqlite_server.go
index 63b41ee5e0a4a..f06dd0210655f 100644
--- a/go/arrow/flight/flightsql/example/sqlite_server.go
+++ b/go/arrow/flight/flightsql/example/sqlite_server.go
@@ -45,13 +45,13 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
index 507abf622d890..e07a98fffdbf7 100644
--- a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	sqlite3 "modernc.org/sqlite/lib"
 )
 
diff --git a/go/arrow/flight/flightsql/example/type_info.go b/go/arrow/flight/flightsql/example/type_info.go
index 6d6ceb339e4b0..0180fc1f23af5 100644
--- a/go/arrow/flight/flightsql/example/type_info.go
+++ b/go/arrow/flight/flightsql/example/type_info.go
@@ -22,10 +22,10 @@ package example
 import (
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func GetTypeInfoResult(mem memory.Allocator) arrow.Record {
diff --git a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
index 98d61f8110d45..b65688306473b 100644
--- a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
+++ b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
@@ -18,7 +18,7 @@
 // by FlightSQL servers and clients.
 package schema_ref
 
-import "github.com/apache/arrow/go/v14/arrow"
+import "github.com/apache/arrow/go/v15/arrow"
 
 var (
 	Catalogs = arrow.NewSchema(
diff --git a/go/arrow/flight/flightsql/server.go b/go/arrow/flight/flightsql/server.go
index e9cbc177da2c4..a086610433eae 100644
--- a/go/arrow/flight/flightsql/server.go
+++ b/go/arrow/flight/flightsql/server.go
@@ -20,14 +20,14 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
diff --git a/go/arrow/flight/flightsql/server_test.go b/go/arrow/flight/flightsql/server_test.go
index 33e9b8236a261..e444da4aaf4a2 100644
--- a/go/arrow/flight/flightsql/server_test.go
+++ b/go/arrow/flight/flightsql/server_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/sql_info.go b/go/arrow/flight/flightsql/sql_info.go
index a12c4fbdaeda9..5f78e1facd581 100644
--- a/go/arrow/flight/flightsql/sql_info.go
+++ b/go/arrow/flight/flightsql/sql_info.go
@@ -17,8 +17,8 @@
 package flightsql
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/sqlite_server_test.go b/go/arrow/flight/flightsql/sqlite_server_test.go
index 03ae3d7a8313a..e6fa798c55cf1 100644
--- a/go/arrow/flight/flightsql/sqlite_server_test.go
+++ b/go/arrow/flight/flightsql/sqlite_server_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/types.go b/go/arrow/flight/flightsql/types.go
index 98086a61fe067..2b7419482e3e3 100644
--- a/go/arrow/flight/flightsql/types.go
+++ b/go/arrow/flight/flightsql/types.go
@@ -17,7 +17,7 @@
 package flightsql
 
 import (
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
diff --git a/go/arrow/flight/record_batch_reader.go b/go/arrow/flight/record_batch_reader.go
index b726180627e6f..f137c75172368 100644
--- a/go/arrow/flight/record_batch_reader.go
+++ b/go/arrow/flight/record_batch_reader.go
@@ -21,12 +21,12 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // DataStreamReader is an interface for receiving flight data messages on a stream
diff --git a/go/arrow/flight/record_batch_writer.go b/go/arrow/flight/record_batch_writer.go
index 3ae17bcf48042..426dca6c3e907 100644
--- a/go/arrow/flight/record_batch_writer.go
+++ b/go/arrow/flight/record_batch_writer.go
@@ -19,9 +19,9 @@ package flight
 import (
 	"bytes"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // DataStreamWriter is an interface that represents an Arrow Flight stream
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index cf471f9b3a2b6..8676b15644e47 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -22,7 +22,7 @@ import (
 	"os"
 	"os/signal"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 )
 
diff --git a/go/arrow/flight/server_example_test.go b/go/arrow/flight/server_example_test.go
index b82e2cb7f7164..4e2e4f4c6b587 100644
--- a/go/arrow/flight/server_example_test.go
+++ b/go/arrow/flight/server_example_test.go
@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/health"
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 0851bff0fe0da..6631e4245c19d 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -21,14 +21,14 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 var (
diff --git a/go/arrow/internal/arrdata/ioutil.go b/go/arrow/internal/arrdata/ioutil.go
index 1a2ce0e5b5eca..a6becc2151ef3 100644
--- a/go/arrow/internal/arrdata/ioutil.go
+++ b/go/arrow/internal/arrdata/ioutil.go
@@ -23,11 +23,11 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // CheckArrowFile checks whether a given ARROW file contains the expected list of records.
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index ad87b73fc4ddb..87bdc1f44d875 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Schema struct {
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index ee85d431805ab..7beadee370edb 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -22,9 +22,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/arrjson/option.go b/go/arrow/internal/arrjson/option.go
index 7ae2058d471a7..47d40f857c54e 100644
--- a/go/arrow/internal/arrjson/option.go
+++ b/go/arrow/internal/arrjson/option.go
@@ -17,8 +17,8 @@
 package arrjson
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type config struct {
diff --git a/go/arrow/internal/arrjson/reader.go b/go/arrow/internal/arrjson/reader.go
index c8056ef1dc744..226fa1b1919f9 100644
--- a/go/arrow/internal/arrjson/reader.go
+++ b/go/arrow/internal/arrjson/reader.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Reader struct {
diff --git a/go/arrow/internal/arrjson/writer.go b/go/arrow/internal/arrjson/writer.go
index ddac32609b604..af7032d581f4d 100644
--- a/go/arrow/internal/arrjson/writer.go
+++ b/go/arrow/internal/arrjson/writer.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const (
diff --git a/go/arrow/internal/cdata_integration/entrypoints.go b/go/arrow/internal/cdata_integration/entrypoints.go
index 629b8a762a689..a40db8316f848 100644
--- a/go/arrow/internal/cdata_integration/entrypoints.go
+++ b/go/arrow/internal/cdata_integration/entrypoints.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/cdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/cdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/internal/dictutils/dict.go b/go/arrow/internal/dictutils/dict.go
index e09a2f4a0ecd1..d31369f7d25b3 100644
--- a/go/arrow/internal/dictutils/dict.go
+++ b/go/arrow/internal/dictutils/dict.go
@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"hash/maphash"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type Kind int8
diff --git a/go/arrow/internal/dictutils/dict_test.go b/go/arrow/internal/dictutils/dict_test.go
index 6cafacbd1df00..9d2f7ae4782c7 100644
--- a/go/arrow/internal/dictutils/dict_test.go
+++ b/go/arrow/internal/dictutils/dict_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestDictMemo(t *testing.T) {
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
index 8da39858fabab..1afb53c5294f4 100755
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
index 9cebb2c695ece..d382ff9e88670 100644
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
@@ -23,7 +23,7 @@ import (
 	"os"
 	"syscall"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
 )
 
 var (
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 4f47d7fd506ee..3ec905e2d659c 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -31,15 +31,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"golang.org/x/xerrors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index 41f2578209a7f..b42273ff93fac 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -19,11 +19,11 @@ package gen
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/arrow/internal/testing/tools/bits_test.go b/go/arrow/internal/testing/tools/bits_test.go
index 7d0fccb5f999e..6ad8ac5b12b68 100644
--- a/go/arrow/internal/testing/tools/bits_test.go
+++ b/go/arrow/internal/testing/tools/bits_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/testing/tools/data_types.go b/go/arrow/internal/testing/tools/data_types.go
index 654780bc3e853..161cfa431491d 100644
--- a/go/arrow/internal/testing/tools/data_types.go
+++ b/go/arrow/internal/testing/tools/data_types.go
@@ -21,8 +21,8 @@ package tools
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/internal/utils.go b/go/arrow/internal/utils.go
index 265f030dfd19a..619eebd97dc78 100644
--- a/go/arrow/internal/utils.go
+++ b/go/arrow/internal/utils.go
@@ -17,8 +17,8 @@
 package internal
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
 )
 
 const CurMetadataVersion = flatbuf.MetadataVersionV5
diff --git a/go/arrow/ipc/cmd/arrow-cat/main.go b/go/arrow/ipc/cmd/arrow-cat/main.go
index af53c9b4e5f44..0251b08c09bff 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main.go
@@ -63,8 +63,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-cat/main_test.go b/go/arrow/ipc/cmd/arrow-cat/main_test.go
index 22e4f6ffe0778..b6528b85b416d 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestCatStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
index 7e86263d6d5b8..6187b94465211 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
index 30db24715386f..2f66a8b48c59d 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFileToStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
index 91ba6a4ad9b61..7db2fa1d1c5db 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
@@ -22,12 +22,12 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
index 140f9f62478c0..eb702f0aa2bc5 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
@@ -20,8 +20,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestIntegration(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main.go b/go/arrow/ipc/cmd/arrow-ls/main.go
index f739c9ae7da8e..4230ae2449985 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main.go
@@ -61,8 +61,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main_test.go b/go/arrow/ipc/cmd/arrow-ls/main_test.go
index 2c038dae97b52..bda1c2dc4d3dc 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestLsStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
index 758231ea21cf5..7ed3f6a281d9f 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
index 4354b46e8964b..73196551054ac 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestStreamToFile(t *testing.T) {
diff --git a/go/arrow/ipc/compression.go b/go/arrow/ipc/compression.go
index 73fb916500804..8856b732f9c5d 100644
--- a/go/arrow/ipc/compression.go
+++ b/go/arrow/ipc/compression.go
@@ -19,9 +19,9 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/klauspost/compress/zstd"
 	"github.com/pierrec/lz4/v4"
 )
diff --git a/go/arrow/ipc/endian_swap.go b/go/arrow/ipc/endian_swap.go
index d98fec1089f04..d2e0948434abc 100644
--- a/go/arrow/ipc/endian_swap.go
+++ b/go/arrow/ipc/endian_swap.go
@@ -20,9 +20,9 @@ import (
 	"errors"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // swap the endianness of the array's buffers as needed in-place to save
diff --git a/go/arrow/ipc/endian_swap_test.go b/go/arrow/ipc/endian_swap_test.go
index 4f02bb53d61a4..1c724103f4441 100644
--- a/go/arrow/ipc/endian_swap_test.go
+++ b/go/arrow/ipc/endian_swap_test.go
@@ -20,11 +20,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index 10cb2cae764e6..330355d3a60c3 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // FileReader is an Arrow file reader.
diff --git a/go/arrow/ipc/file_test.go b/go/arrow/ipc/file_test.go
index 1b22719dc8097..5f4dac1f899bb 100644
--- a/go/arrow/ipc/file_test.go
+++ b/go/arrow/ipc/file_test.go
@@ -21,9 +21,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFile(t *testing.T) {
diff --git a/go/arrow/ipc/file_writer.go b/go/arrow/ipc/file_writer.go
index 12384225b70a1..55e4d7c2dc22c 100644
--- a/go/arrow/ipc/file_writer.go
+++ b/go/arrow/ipc/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // PayloadWriter is an interface for injecting a different payloadwriter
diff --git a/go/arrow/ipc/ipc.go b/go/arrow/ipc/ipc.go
index 6c04b6f5ad2d6..8cf56e8331fcb 100644
--- a/go/arrow/ipc/ipc.go
+++ b/go/arrow/ipc/ipc.go
@@ -19,10 +19,10 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 const (
diff --git a/go/arrow/ipc/ipc_test.go b/go/arrow/ipc/ipc_test.go
index 551d325dc1212..d02d8734b56d4 100644
--- a/go/arrow/ipc/ipc_test.go
+++ b/go/arrow/ipc/ipc_test.go
@@ -29,10 +29,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestArrow12072(t *testing.T) {
diff --git a/go/arrow/ipc/message.go b/go/arrow/ipc/message.go
index c5d0ec68d19c4..709aa5aa2dba4 100644
--- a/go/arrow/ipc/message.go
+++ b/go/arrow/ipc/message.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // MetadataVersion represents the Arrow metadata version.
diff --git a/go/arrow/ipc/message_test.go b/go/arrow/ipc/message_test.go
index cc41fdd3fe13d..912d112229f0c 100644
--- a/go/arrow/ipc/message_test.go
+++ b/go/arrow/ipc/message_test.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestMessageReaderBodyInAllocator(t *testing.T) {
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index 9bab47d6fa0cd..bd437834c3d06 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
diff --git a/go/arrow/ipc/metadata_test.go b/go/arrow/ipc/metadata_test.go
index 3038abdf5f791..a35068813ba56 100644
--- a/go/arrow/ipc/metadata_test.go
+++ b/go/arrow/ipc/metadata_test.go
@@ -21,12 +21,12 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	flatbuffers "github.com/google/flatbuffers/go"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/arrow/ipc/reader.go b/go/arrow/ipc/reader.go
index 1f684c1f6c034..826062fafdb46 100644
--- a/go/arrow/ipc/reader.go
+++ b/go/arrow/ipc/reader.go
@@ -23,13 +23,13 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Reader reads records from an io.Reader.
diff --git a/go/arrow/ipc/reader_test.go b/go/arrow/ipc/reader_test.go
index 229374e94ec74..f00f3bb3da476 100644
--- a/go/arrow/ipc/reader_test.go
+++ b/go/arrow/ipc/reader_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/stream_test.go b/go/arrow/ipc/stream_test.go
index d8bbd8f04b14d..201bfb82a5677 100644
--- a/go/arrow/ipc/stream_test.go
+++ b/go/arrow/ipc/stream_test.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestStream(t *testing.T) {
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index a97f47ef4aa43..58c56d2d16ccf 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -26,14 +26,14 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type swriter struct {
diff --git a/go/arrow/ipc/writer_test.go b/go/arrow/ipc/writer_test.go
index da461c3d52272..ea7592554c888 100644
--- a/go/arrow/ipc/writer_test.go
+++ b/go/arrow/ipc/writer_test.go
@@ -24,11 +24,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/math/float64.go b/go/arrow/math/float64.go
index 81de594df6ce6..8d72ecf1b2668 100644
--- a/go/arrow/math/float64.go
+++ b/go/arrow/math/float64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Float64Funcs struct {
diff --git a/go/arrow/math/float64_avx2_amd64.go b/go/arrow/math/float64_avx2_amd64.go
index 8a131a2bc8fc5..e78d4affe9f6f 100644
--- a/go/arrow/math/float64_avx2_amd64.go
+++ b/go/arrow/math/float64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_neon_arm64.go b/go/arrow/math/float64_neon_arm64.go
index ad9b6435b26fc..a5013960d9ec7 100755
--- a/go/arrow/math/float64_neon_arm64.go
+++ b/go/arrow/math/float64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_sse4_amd64.go b/go/arrow/math/float64_sse4_amd64.go
index a2be5de43f5bb..cdd88f91c2c2b 100644
--- a/go/arrow/math/float64_sse4_amd64.go
+++ b/go/arrow/math/float64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_test.go b/go/arrow/math/float64_test.go
index b10214f6d892f..3a7c247c5df8c 100644
--- a/go/arrow/math/float64_test.go
+++ b/go/arrow/math/float64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/int64.go b/go/arrow/math/int64.go
index 2adff970c2233..b8236dfbb6552 100644
--- a/go/arrow/math/int64.go
+++ b/go/arrow/math/int64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Int64Funcs struct {
diff --git a/go/arrow/math/int64_avx2_amd64.go b/go/arrow/math/int64_avx2_amd64.go
index ac0b2e1ff662a..5c16e790c1e55 100644
--- a/go/arrow/math/int64_avx2_amd64.go
+++ b/go/arrow/math/int64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_neon_arm64.go b/go/arrow/math/int64_neon_arm64.go
index 4ab5fb771a526..00ec48b6e4735 100755
--- a/go/arrow/math/int64_neon_arm64.go
+++ b/go/arrow/math/int64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_sse4_amd64.go b/go/arrow/math/int64_sse4_amd64.go
index 85304210eb448..a894bad2ef6a3 100644
--- a/go/arrow/math/int64_sse4_amd64.go
+++ b/go/arrow/math/int64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_test.go b/go/arrow/math/int64_test.go
index 06b42ffe9351b..3781fd3570785 100644
--- a/go/arrow/math/int64_test.go
+++ b/go/arrow/math/int64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/type.go.tmpl b/go/arrow/math/type.go.tmpl
index 7ae142c46f12b..f1a4dfa1362f8 100644
--- a/go/arrow/math/type.go.tmpl
+++ b/go/arrow/math/type.go.tmpl
@@ -17,7 +17,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$def := .D}}
diff --git a/go/arrow/math/type_simd_amd64.go.tmpl b/go/arrow/math/type_simd_amd64.go.tmpl
index 72d40ea386a8f..77dee758b05cd 100644
--- a/go/arrow/math/type_simd_amd64.go.tmpl
+++ b/go/arrow/math/type_simd_amd64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_simd_arm64.go.tmpl b/go/arrow/math/type_simd_arm64.go.tmpl
index 72d40ea386a8f..77dee758b05cd 100755
--- a/go/arrow/math/type_simd_arm64.go.tmpl
+++ b/go/arrow/math/type_simd_arm64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_test.go.tmpl b/go/arrow/math/type_test.go.tmpl
index 160fc34e4d4d4..969377e454e52 100644
--- a/go/arrow/math/type_test.go.tmpl
+++ b/go/arrow/math/type_test.go.tmpl
@@ -19,9 +19,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/uint64.go b/go/arrow/math/uint64.go
index 64ac63a3d1853..b9a70360224ea 100644
--- a/go/arrow/math/uint64.go
+++ b/go/arrow/math/uint64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Uint64Funcs struct {
diff --git a/go/arrow/math/uint64_avx2_amd64.go b/go/arrow/math/uint64_avx2_amd64.go
index 2a35bebc980b3..c1f48efefd8eb 100644
--- a/go/arrow/math/uint64_avx2_amd64.go
+++ b/go/arrow/math/uint64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_neon_arm64.go b/go/arrow/math/uint64_neon_arm64.go
index f6588694bb1fd..37ca4ecad04e7 100755
--- a/go/arrow/math/uint64_neon_arm64.go
+++ b/go/arrow/math/uint64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_sse4_amd64.go b/go/arrow/math/uint64_sse4_amd64.go
index 8c6621464f118..7163c1de171de 100644
--- a/go/arrow/math/uint64_sse4_amd64.go
+++ b/go/arrow/math/uint64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_test.go b/go/arrow/math/uint64_test.go
index aac768e599cf8..e8ba42b59aa10 100644
--- a/go/arrow/math/uint64_test.go
+++ b/go/arrow/math/uint64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/buffer.go b/go/arrow/memory/buffer.go
index 5a2b4297031f0..ffdb41e3dbe9e 100644
--- a/go/arrow/memory/buffer.go
+++ b/go/arrow/memory/buffer.go
@@ -19,7 +19,7 @@ package memory
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Buffer is a wrapper type for a buffer of bytes.
diff --git a/go/arrow/memory/buffer_test.go b/go/arrow/memory/buffer_test.go
index 25a0b39848519..92bb071d0abde 100644
--- a/go/arrow/memory/buffer_test.go
+++ b/go/arrow/memory/buffer_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/cgo_allocator.go b/go/arrow/memory/cgo_allocator.go
index 85ee445216f6a..af25d1899a6fe 100644
--- a/go/arrow/memory/cgo_allocator.go
+++ b/go/arrow/memory/cgo_allocator.go
@@ -22,7 +22,7 @@ package memory
 import (
 	"runtime"
 
-	cga "github.com/apache/arrow/go/v14/arrow/memory/internal/cgoalloc"
+	cga "github.com/apache/arrow/go/v15/arrow/memory/internal/cgoalloc"
 )
 
 // CgoArrowAllocator is an allocator which exposes the C++ memory pool class
diff --git a/go/arrow/memory/default_mallocator.go b/go/arrow/memory/default_mallocator.go
index 12ad0846677b1..4a9ef942fd08d 100644
--- a/go/arrow/memory/default_mallocator.go
+++ b/go/arrow/memory/default_mallocator.go
@@ -19,7 +19,7 @@
 package memory
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 )
 
 // DefaultAllocator is a default implementation of Allocator and can be used anywhere
diff --git a/go/arrow/memory/default_mallocator_test.go b/go/arrow/memory/default_mallocator_test.go
index b209ced68a067..5a38e8b4e843c 100644
--- a/go/arrow/memory/default_mallocator_test.go
+++ b/go/arrow/memory/default_mallocator_test.go
@@ -21,8 +21,8 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/mallocator/mallocator_test.go b/go/arrow/memory/mallocator/mallocator_test.go
index 5b09355033f70..91b74383ed494 100644
--- a/go/arrow/memory/mallocator/mallocator_test.go
+++ b/go/arrow/memory/mallocator/mallocator_test.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/memory_test.go b/go/arrow/memory/memory_test.go
index dff2e0bfd0712..adaa8359369be 100644
--- a/go/arrow/memory/memory_test.go
+++ b/go/arrow/memory/memory_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/record.go b/go/arrow/record.go
index d98c7732ef798..885af38034938 100644
--- a/go/arrow/record.go
+++ b/go/arrow/record.go
@@ -16,7 +16,7 @@
 
 package arrow
 
-import "github.com/apache/arrow/go/v14/internal/json"
+import "github.com/apache/arrow/go/v15/internal/json"
 
 // Record is a collection of equal-length arrays matching a particular Schema.
 // Also known as a RecordBatch in the spec and in some implementations.
diff --git a/go/arrow/scalar/append.go b/go/arrow/scalar/append.go
index 9bcfe3e22dc63..fe8dd32e9eae5 100644
--- a/go/arrow/scalar/append.go
+++ b/go/arrow/scalar/append.go
@@ -21,11 +21,11 @@ package scalar
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/scalar/append_test.go b/go/arrow/scalar/append_test.go
index 497a6a2d02933..e509bca1fb7b0 100644
--- a/go/arrow/scalar/append_test.go
+++ b/go/arrow/scalar/append_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/binary.go b/go/arrow/scalar/binary.go
index 3c041210fde9c..b6abe9cba7b1c 100644
--- a/go/arrow/scalar/binary.go
+++ b/go/arrow/scalar/binary.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type BinaryScalar interface {
diff --git a/go/arrow/scalar/compare.go b/go/arrow/scalar/compare.go
index be7fa4d01cc19..b4a3fe08d26fe 100644
--- a/go/arrow/scalar/compare.go
+++ b/go/arrow/scalar/compare.go
@@ -16,7 +16,7 @@
 
 package scalar
 
-import "github.com/apache/arrow/go/v14/arrow"
+import "github.com/apache/arrow/go/v15/arrow"
 
 // Equals returns true if two scalars are equal, which means they have the same
 // datatype, validity and value.
diff --git a/go/arrow/scalar/nested.go b/go/arrow/scalar/nested.go
index 87e84210f58a1..8250beb5ed90d 100644
--- a/go/arrow/scalar/nested.go
+++ b/go/arrow/scalar/nested.go
@@ -21,10 +21,10 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/numeric.gen.go b/go/arrow/scalar/numeric.gen.go
index 90ae2a7004ce3..da088162f4017 100644
--- a/go/arrow/scalar/numeric.gen.go
+++ b/go/arrow/scalar/numeric.gen.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
 )
 
 type Int8 struct {
diff --git a/go/arrow/scalar/numeric.gen_test.go b/go/arrow/scalar/numeric.gen_test.go
index 987cd66c75f3c..807857c1c98c2 100644
--- a/go/arrow/scalar/numeric.gen_test.go
+++ b/go/arrow/scalar/numeric.gen_test.go
@@ -21,8 +21,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/numeric.gen_test.go.tmpl b/go/arrow/scalar/numeric.gen_test.go.tmpl
index c975cc9db6e1c..7f45898a20d29 100644
--- a/go/arrow/scalar/numeric.gen_test.go.tmpl
+++ b/go/arrow/scalar/numeric.gen_test.go.tmpl
@@ -19,8 +19,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/parse.go b/go/arrow/scalar/parse.go
index fcffe1ea6adf8..5002f98a65c42 100644
--- a/go/arrow/scalar/parse.go
+++ b/go/arrow/scalar/parse.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type TypeToScalar interface {
diff --git a/go/arrow/scalar/scalar.go b/go/arrow/scalar/scalar.go
index 395771fa89c94..8b0d3ace2ad78 100644
--- a/go/arrow/scalar/scalar.go
+++ b/go/arrow/scalar/scalar.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/scalar_test.go b/go/arrow/scalar/scalar_test.go
index 405571a14880d..ce8170301b0a2 100644
--- a/go/arrow/scalar/scalar_test.go
+++ b/go/arrow/scalar/scalar_test.go
@@ -25,12 +25,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/temporal.go b/go/arrow/scalar/temporal.go
index 880416f7dd5a3..ee13c84429e8e 100644
--- a/go/arrow/scalar/temporal.go
+++ b/go/arrow/scalar/temporal.go
@@ -22,7 +22,7 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func temporalToString(s TemporalScalar) string {
diff --git a/go/arrow/schema.go b/go/arrow/schema.go
index a7fa434131925..e84f350a53637 100644
--- a/go/arrow/schema.go
+++ b/go/arrow/schema.go
@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 type Metadata struct {
diff --git a/go/arrow/schema_test.go b/go/arrow/schema_test.go
index 5e79723f90352..fddf1d7f131ec 100644
--- a/go/arrow/schema_test.go
+++ b/go/arrow/schema_test.go
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/table.go b/go/arrow/table.go
index 5a68085f8df93..82dc283706b65 100644
--- a/go/arrow/table.go
+++ b/go/arrow/table.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Table represents a logical sequence of chunked arrays of equal length. It is
diff --git a/go/arrow/tensor/numeric.gen.go b/go/arrow/tensor/numeric.gen.go
index 5b7bbde150fe2..d207f0bfa2c9c 100644
--- a/go/arrow/tensor/numeric.gen.go
+++ b/go/arrow/tensor/numeric.gen.go
@@ -19,7 +19,7 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Int8 is an n-dim array of int8s.
diff --git a/go/arrow/tensor/numeric.gen.go.tmpl b/go/arrow/tensor/numeric.gen.go.tmpl
index c693082192247..e03f986da3f8f 100644
--- a/go/arrow/tensor/numeric.gen.go.tmpl
+++ b/go/arrow/tensor/numeric.gen.go.tmpl
@@ -17,8 +17,8 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/numeric.gen_test.go b/go/arrow/tensor/numeric.gen_test.go
index 00922a84b6b03..3a7c3570c216b 100644
--- a/go/arrow/tensor/numeric.gen_test.go
+++ b/go/arrow/tensor/numeric.gen_test.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 func TestTensorInt8(t *testing.T) {
diff --git a/go/arrow/tensor/numeric.gen_test.go.tmpl b/go/arrow/tensor/numeric.gen_test.go.tmpl
index 665bb8dc68da9..34f01b40d8084 100644
--- a/go/arrow/tensor/numeric.gen_test.go.tmpl
+++ b/go/arrow/tensor/numeric.gen_test.go.tmpl
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/tensor.go b/go/arrow/tensor/tensor.go
index 27c380345a498..1f2ed7e82141b 100644
--- a/go/arrow/tensor/tensor.go
+++ b/go/arrow/tensor/tensor.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Interface represents an n-dimensional array of numerical data.
diff --git a/go/arrow/tensor/tensor_test.go b/go/arrow/tensor/tensor_test.go
index 4cfe69f780421..552c4c1c223e0 100644
--- a/go/arrow/tensor/tensor_test.go
+++ b/go/arrow/tensor/tensor_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 func TestTensor(t *testing.T) {
diff --git a/go/arrow/type_traits_boolean.go b/go/arrow/type_traits_boolean.go
index 6a46bdec702ff..c164d45954fc0 100644
--- a/go/arrow/type_traits_boolean.go
+++ b/go/arrow/type_traits_boolean.go
@@ -17,7 +17,7 @@
 package arrow
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 type booleanTraits struct{}
diff --git a/go/arrow/type_traits_decimal128.go b/go/arrow/type_traits_decimal128.go
index d2d3aae371663..f573ad3c65a4c 100644
--- a/go/arrow/type_traits_decimal128.go
+++ b/go/arrow/type_traits_decimal128.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 // Decimal128 traits
diff --git a/go/arrow/type_traits_decimal256.go b/go/arrow/type_traits_decimal256.go
index 256ed68fffc8d..adf3cc3e0bc31 100644
--- a/go/arrow/type_traits_decimal256.go
+++ b/go/arrow/type_traits_decimal256.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 // Decimal256 traits
diff --git a/go/arrow/type_traits_float16.go b/go/arrow/type_traits_float16.go
index c40363d3785da..e59efd4c248d8 100644
--- a/go/arrow/type_traits_float16.go
+++ b/go/arrow/type_traits_float16.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 )
 
 // Float16 traits
diff --git a/go/arrow/type_traits_interval.go b/go/arrow/type_traits_interval.go
index 35e6057090f10..5fbd7a5248918 100644
--- a/go/arrow/type_traits_interval.go
+++ b/go/arrow/type_traits_interval.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go b/go/arrow/type_traits_numeric.gen.go
index 6edd75291155c..57606c0fce6df 100644
--- a/go/arrow/type_traits_numeric.gen.go
+++ b/go/arrow/type_traits_numeric.gen.go
@@ -23,7 +23,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go.tmpl b/go/arrow/type_traits_numeric.gen.go.tmpl
index ffae975c1aa15..c491047b51429 100644
--- a/go/arrow/type_traits_numeric.gen.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen.go.tmpl
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen_test.go b/go/arrow/type_traits_numeric.gen_test.go
index 74395485736ff..ac2d0726ed6fa 100644
--- a/go/arrow/type_traits_numeric.gen_test.go
+++ b/go/arrow/type_traits_numeric.gen_test.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestInt64Traits(t *testing.T) {
diff --git a/go/arrow/type_traits_numeric.gen_test.go.tmpl b/go/arrow/type_traits_numeric.gen_test.go.tmpl
index 96685f31327bd..4948f42cf542e 100644
--- a/go/arrow/type_traits_numeric.gen_test.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen_test.go.tmpl
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 {{- range .In}}
diff --git a/go/arrow/type_traits_test.go b/go/arrow/type_traits_test.go
index 85ad4da9d041d..0ae88b4bd82b6 100644
--- a/go/arrow/type_traits_test.go
+++ b/go/arrow/type_traits_test.go
@@ -22,10 +22,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 )
 
 func TestBooleanTraits(t *testing.T) {
diff --git a/go/arrow/type_traits_timestamp.go b/go/arrow/type_traits_timestamp.go
index 7c393b3559f82..c1a9aba3db386 100644
--- a/go/arrow/type_traits_timestamp.go
+++ b/go/arrow/type_traits_timestamp.go
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var TimestampTraits timestampTraits
diff --git a/go/arrow/util/byte_size.go b/go/arrow/util/byte_size.go
index 141b78c459119..6d6fc021f8005 100644
--- a/go/arrow/util/byte_size.go
+++ b/go/arrow/util/byte_size.go
@@ -17,9 +17,9 @@
 package util
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func isArrayDataNil(arrayData arrow.ArrayData) bool {
diff --git a/go/arrow/util/byte_size_test.go b/go/arrow/util/byte_size_test.go
index 052bf3adee158..a218c69558fe9 100644
--- a/go/arrow/util/byte_size_test.go
+++ b/go/arrow/util/byte_size_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/util"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/util"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/go.mod b/go/go.mod
index de73c210d159d..a6c2af7025d32 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -14,7 +14,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-module github.com/apache/arrow/go/v14
+module github.com/apache/arrow/go/v15
 
 go 1.20
 
diff --git a/go/internal/bitutils/bit_block_counter.go b/go/internal/bitutils/bit_block_counter.go
index 86818bfd45ab7..99eece34cd068 100644
--- a/go/internal/bitutils/bit_block_counter.go
+++ b/go/internal/bitutils/bit_block_counter.go
@@ -21,8 +21,8 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 func loadWord(byt []byte) uint64 {
diff --git a/go/internal/bitutils/bit_block_counter_test.go b/go/internal/bitutils/bit_block_counter_test.go
index ad5e989d1fa65..790105c290182 100644
--- a/go/internal/bitutils/bit_block_counter_test.go
+++ b/go/internal/bitutils/bit_block_counter_test.go
@@ -19,9 +19,9 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/rand"
 )
diff --git a/go/internal/bitutils/bit_run_reader.go b/go/internal/bitutils/bit_run_reader.go
index a1686a4909b8b..f09149d7ec5df 100644
--- a/go/internal/bitutils/bit_run_reader.go
+++ b/go/internal/bitutils/bit_run_reader.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // BitRun represents a run of bits with the same value of length Len
diff --git a/go/internal/bitutils/bit_run_reader_test.go b/go/internal/bitutils/bit_run_reader_test.go
index 0e1500bff811a..7db76768a9476 100644
--- a/go/internal/bitutils/bit_run_reader_test.go
+++ b/go/internal/bitutils/bit_run_reader_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/internal/bitutils/bit_set_run_reader.go b/go/internal/bitutils/bit_set_run_reader.go
index a2269ffecb870..6764ca7912679 100644
--- a/go/internal/bitutils/bit_set_run_reader.go
+++ b/go/internal/bitutils/bit_set_run_reader.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // IsMultipleOf64 returns whether v is a multiple of 64.
diff --git a/go/internal/bitutils/bit_set_run_reader_test.go b/go/internal/bitutils/bit_set_run_reader_test.go
index 205954b3800a8..832993671ef6d 100644
--- a/go/internal/bitutils/bit_set_run_reader_test.go
+++ b/go/internal/bitutils/bit_set_run_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/internal/bitutils/bitmap_generate.go b/go/internal/bitutils/bitmap_generate.go
index 78219d8120bcc..08b5fceab57d3 100644
--- a/go/internal/bitutils/bitmap_generate.go
+++ b/go/internal/bitutils/bitmap_generate.go
@@ -16,7 +16,7 @@
 
 package bitutils
 
-import "github.com/apache/arrow/go/v14/arrow/bitutil"
+import "github.com/apache/arrow/go/v15/arrow/bitutil"
 
 // GenerateBits writes sequential bits to a bitmap. Bits preceding the
 // initial start offset are preserved, bits following the bitmap may
diff --git a/go/internal/bitutils/bitmap_generate_test.go b/go/internal/bitutils/bitmap_generate_test.go
index 788b2198c3a78..c9a6203864a20 100644
--- a/go/internal/bitutils/bitmap_generate_test.go
+++ b/go/internal/bitutils/bitmap_generate_test.go
@@ -19,7 +19,7 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go b/go/internal/hashing/xxh3_memo_table.gen.go
index cc996552b49e5..39b82cdeff9a2 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go
+++ b/go/internal/hashing/xxh3_memo_table.gen.go
@@ -21,9 +21,9 @@ package hashing
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 type payloadInt8 struct {
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
index 25164341d227e..527008ad63c3c 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
+++ b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
@@ -17,8 +17,8 @@
 package hashing
 
 import (
-  "github.com/apache/arrow/go/v14/arrow/bitutil"  
-  "github.com/apache/arrow/go/v14/internal/utils"  
+  "github.com/apache/arrow/go/v15/arrow/bitutil"  
+  "github.com/apache/arrow/go/v15/internal/utils"  
 )
 
 {{range .In}}
diff --git a/go/internal/types/extension_types.go b/go/internal/types/extension_types.go
index 1a31014874bbe..e24c89efc7b8b 100644
--- a/go/internal/types/extension_types.go
+++ b/go/internal/types/extension_types.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/google/uuid"
 	"golang.org/x/xerrors"
 )
diff --git a/go/internal/types/extension_types_test.go b/go/internal/types/extension_types_test.go
index 16273890b4c9c..f93f1000c9e4a 100644
--- a/go/internal/types/extension_types_test.go
+++ b/go/internal/types/extension_types_test.go
@@ -20,11 +20,11 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/internal/utils/transpose_ints_def.go b/go/internal/utils/transpose_ints_def.go
index cc3b0abb59363..c52598d7148ea 100644
--- a/go/internal/utils/transpose_ints_def.go
+++ b/go/internal/utils/transpose_ints_def.go
@@ -19,7 +19,7 @@ package utils
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl -i -data=transpose_ints.tmpldata -d arch=avx2 transpose_ints_simd.go.tmpl=transpose_ints_avx2_amd64.go
diff --git a/go/internal/utils/transpose_ints_test.go b/go/internal/utils/transpose_ints_test.go
index e41b61156abdc..73b2bbce3fc14 100644
--- a/go/internal/utils/transpose_ints_test.go
+++ b/go/internal/utils/transpose_ints_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 var (
diff --git a/go/parquet/cmd/parquet_reader/dumper.go b/go/parquet/cmd/parquet_reader/dumper.go
index a04dcf23b2d8d..4cb2ea4a96fee 100644
--- a/go/parquet/cmd/parquet_reader/dumper.go
+++ b/go/parquet/cmd/parquet_reader/dumper.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 const defaultBatchSize = 128
diff --git a/go/parquet/cmd/parquet_reader/main.go b/go/parquet/cmd/parquet_reader/main.go
index e7d1cd7fc5a7d..0d651d8c294c5 100644
--- a/go/parquet/cmd/parquet_reader/main.go
+++ b/go/parquet/cmd/parquet_reader/main.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 
 	"github.com/docopt/docopt-go"
 )
diff --git a/go/parquet/cmd/parquet_schema/main.go b/go/parquet/cmd/parquet_schema/main.go
index 28d1288b54aeb..01d541e8ac925 100644
--- a/go/parquet/cmd/parquet_schema/main.go
+++ b/go/parquet/cmd/parquet_schema/main.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/docopt/docopt-go"
 )
 
diff --git a/go/parquet/compress/brotli.go b/go/parquet/compress/brotli.go
index 1c1ae1dffaca5..a1199d9711435 100644
--- a/go/parquet/compress/brotli.go
+++ b/go/parquet/compress/brotli.go
@@ -21,7 +21,7 @@ import (
 	"io"
 
 	"github.com/andybalholm/brotli"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 )
 
 type brotliCodec struct{}
diff --git a/go/parquet/compress/compress.go b/go/parquet/compress/compress.go
index 4c4c792c2f614..f61147eb1ea10 100644
--- a/go/parquet/compress/compress.go
+++ b/go/parquet/compress/compress.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Compression is an alias to the thrift compression codec enum type for easy use
diff --git a/go/parquet/compress/compress_test.go b/go/parquet/compress/compress_test.go
index e8041a64c0996..d1c55b15bc3cc 100644
--- a/go/parquet/compress/compress_test.go
+++ b/go/parquet/compress/compress_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/compress/zstd.go b/go/parquet/compress/zstd.go
index 129af62807175..fd8ec81953359 100644
--- a/go/parquet/compress/zstd.go
+++ b/go/parquet/compress/zstd.go
@@ -20,7 +20,7 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 	"github.com/klauspost/compress/zstd"
 )
 
diff --git a/go/parquet/doc.go b/go/parquet/doc.go
index 99a605a284fae..afeee00587ef5 100644
--- a/go/parquet/doc.go
+++ b/go/parquet/doc.go
@@ -29,9 +29,9 @@
 // Install
 //
 // You can download the library and cli utilities via:
-//   go get -u github.com/apache/arrow/go/v14/parquet
-//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_reader@latest
-//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_schema@latest
+//   go get -u github.com/apache/arrow/go/v15/parquet
+//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_reader@latest
+//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_schema@latest
 //
 // Modules
 //
diff --git a/go/parquet/encryption_properties.go b/go/parquet/encryption_properties.go
index dd85a856820fe..6eb6cf1fe5680 100644
--- a/go/parquet/encryption_properties.go
+++ b/go/parquet/encryption_properties.go
@@ -20,7 +20,7 @@ import (
 	"crypto/rand"
 	"unicode/utf8"
 
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Constants that will be used as the default values with encryption/decryption
diff --git a/go/parquet/encryption_properties_test.go b/go/parquet/encryption_properties_test.go
index 0b1118a5cfa66..ab028927c5ecb 100644
--- a/go/parquet/encryption_properties_test.go
+++ b/go/parquet/encryption_properties_test.go
@@ -19,8 +19,8 @@ package parquet_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/encryption_read_config_test.go b/go/parquet/encryption_read_config_test.go
index 8a84c19900dd0..53b7ba3c621c0 100644
--- a/go/parquet/encryption_read_config_test.go
+++ b/go/parquet/encryption_read_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/encryption_write_config_test.go b/go/parquet/encryption_write_config_test.go
index 6b2d049e1390c..558b89208c706 100644
--- a/go/parquet/encryption_write_config_test.go
+++ b/go/parquet/encryption_write_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/file/column_reader.go b/go/parquet/file/column_reader.go
index b623bd5074d02..766638d88f26c 100644
--- a/go/parquet/file/column_reader.go
+++ b/go/parquet/file/column_reader.go
@@ -21,13 +21,13 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_reader_test.go b/go/parquet/file/column_reader_test.go
index 3ce05c6cfe47e..21ea52e2b7bbc 100755
--- a/go/parquet/file/column_reader_test.go
+++ b/go/parquet/file/column_reader_test.go
@@ -24,12 +24,12 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/file/column_reader_types.gen.go b/go/parquet/file/column_reader_types.gen.go
index 31dccc157642f..3fb113780f811 100644
--- a/go/parquet/file/column_reader_types.gen.go
+++ b/go/parquet/file/column_reader_types.gen.go
@@ -21,9 +21,9 @@ package file
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 // Int32ColumnChunkReader is the Typed Column chunk reader instance for reading
diff --git a/go/parquet/file/column_reader_types.gen.go.tmpl b/go/parquet/file/column_reader_types.gen.go.tmpl
index 6557963e69f50..261b5f0bfacab 100644
--- a/go/parquet/file/column_reader_types.gen.go.tmpl
+++ b/go/parquet/file/column_reader_types.gen.go.tmpl
@@ -17,8 +17,8 @@
 package file
 
 import (
-    "github.com/apache/arrow/go/v14/parquet"
-    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+    "github.com/apache/arrow/go/v15/parquet"
+    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/column_writer.go b/go/parquet/file/column_writer.go
index 9d9111042df28..0b0d1145d604e 100755
--- a/go/parquet/file/column_writer.go
+++ b/go/parquet/file/column_writer.go
@@ -21,14 +21,14 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata column_writer_types.gen.go.tmpl
diff --git a/go/parquet/file/column_writer_test.go b/go/parquet/file/column_writer_test.go
index e2ae6b0f4a71e..134c290fa6894 100755
--- a/go/parquet/file/column_writer_test.go
+++ b/go/parquet/file/column_writer_test.go
@@ -24,19 +24,19 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	arrutils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	arrutils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/column_writer_types.gen.go b/go/parquet/file/column_writer_types.gen.go
index 5594f63249fb8..8b3be25f3ea29 100644
--- a/go/parquet/file/column_writer_types.gen.go
+++ b/go/parquet/file/column_writer_types.gen.go
@@ -22,12 +22,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_writer_types.gen.go.tmpl b/go/parquet/file/column_writer_types.gen.go.tmpl
index c00e1dabb5fe6..7df69b4a219c6 100644
--- a/go/parquet/file/column_writer_types.gen.go.tmpl
+++ b/go/parquet/file/column_writer_types.gen.go.tmpl
@@ -19,10 +19,10 @@ package file
 import (
     "fmt"
     
-    "github.com/apache/arrow/go/v14/parquet"
-    "github.com/apache/arrow/go/v14/parquet/metadata"
-    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
-    format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+    "github.com/apache/arrow/go/v15/parquet"
+    "github.com/apache/arrow/go/v15/parquet/metadata"
+    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
+    format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/file_reader.go b/go/parquet/file/file_reader.go
index 5481d5c7738b0..afff579ded5b7 100644
--- a/go/parquet/file/file_reader.go
+++ b/go/parquet/file/file_reader.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/file_reader_mmap.go b/go/parquet/file/file_reader_mmap.go
index 89c5a84cee2e1..03e12adf08c8c 100644
--- a/go/parquet/file/file_reader_mmap.go
+++ b/go/parquet/file/file_reader_mmap.go
@@ -22,7 +22,7 @@ package file
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/exp/mmap"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/file_reader_mmap_windows.go b/go/parquet/file/file_reader_mmap_windows.go
index 6b08422163fd1..06a9e97160fe0 100644
--- a/go/parquet/file/file_reader_mmap_windows.go
+++ b/go/parquet/file/file_reader_mmap_windows.go
@@ -22,7 +22,7 @@ package file
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 func mmapOpen(filename string) (parquet.ReaderAtSeeker, error) {
diff --git a/go/parquet/file/file_reader_test.go b/go/parquet/file/file_reader_test.go
index 2a9b097139062..f3248925cf5b9 100644
--- a/go/parquet/file/file_reader_test.go
+++ b/go/parquet/file/file_reader_test.go
@@ -25,16 +25,16 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index c6289434bbe6e..48eb8f44d167b 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 // Writer is the primary interface for writing a parquet file
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index af083ebe60e4f..beceff9732584 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -22,13 +22,13 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/level_conversion.go b/go/parquet/file/level_conversion.go
index ac53dcd18abae..c23bdda445963 100755
--- a/go/parquet/file/level_conversion.go
+++ b/go/parquet/file/level_conversion.go
@@ -22,11 +22,11 @@ import (
 	"math/bits"
 	"unsafe"
 
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/level_conversion_test.go b/go/parquet/file/level_conversion_test.go
index 343edb687980d..5d5bdde90dc7e 100644
--- a/go/parquet/file/level_conversion_test.go
+++ b/go/parquet/file/level_conversion_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/file/page_reader.go b/go/parquet/file/page_reader.go
index ab8679b127f1b..01f253aff8864 100644
--- a/go/parquet/file/page_reader.go
+++ b/go/parquet/file/page_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/page_writer.go b/go/parquet/file/page_writer.go
index b2b6d5061b0fc..c16476fbb232c 100644
--- a/go/parquet/file/page_writer.go
+++ b/go/parquet/file/page_writer.go
@@ -20,15 +20,15 @@ import (
 	"bytes"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/record_reader.go b/go/parquet/file/record_reader.go
index 3311a6d77da39..ad836d29ef483 100755
--- a/go/parquet/file/record_reader.go
+++ b/go/parquet/file/record_reader.go
@@ -23,14 +23,14 @@ import (
 	"unsafe"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_reader.go b/go/parquet/file/row_group_reader.go
index f1aebf1085a23..3c1c1edb0b484 100644
--- a/go/parquet/file/row_group_reader.go
+++ b/go/parquet/file/row_group_reader.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer.go b/go/parquet/file/row_group_writer.go
index 75f0dede5246f..935c13d13a67f 100644
--- a/go/parquet/file/row_group_writer.go
+++ b/go/parquet/file/row_group_writer.go
@@ -17,10 +17,10 @@
 package file
 
 import (
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer_test.go b/go/parquet/file/row_group_writer_test.go
index bc95e99d91582..2ea317cb91001 100644
--- a/go/parquet/file/row_group_writer_test.go
+++ b/go/parquet/file/row_group_writer_test.go
@@ -20,10 +20,10 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/parquet/internal/bmi/bmi_test.go b/go/parquet/internal/bmi/bmi_test.go
index 460c6ec4e24c6..a5278dfef2211 100644
--- a/go/parquet/internal/bmi/bmi_test.go
+++ b/go/parquet/internal/bmi/bmi_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/boolean_decoder.go b/go/parquet/internal/encoding/boolean_decoder.go
index 337a6db967a2e..3782dc85ea814 100644
--- a/go/parquet/internal/encoding/boolean_decoder.go
+++ b/go/parquet/internal/encoding/boolean_decoder.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 // PlainBooleanDecoder is for the Plain Encoding type, there is no
diff --git a/go/parquet/internal/encoding/boolean_encoder.go b/go/parquet/internal/encoding/boolean_encoder.go
index 3970e05fca289..3e01bde369d8b 100644
--- a/go/parquet/internal/encoding/boolean_encoder.go
+++ b/go/parquet/internal/encoding/boolean_encoder.go
@@ -19,10 +19,10 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/byte_array_decoder.go b/go/parquet/internal/encoding/byte_array_decoder.go
index c3ca1de5888f7..82ce9f84265c5 100644
--- a/go/parquet/internal/encoding/byte_array_decoder.go
+++ b/go/parquet/internal/encoding/byte_array_decoder.go
@@ -19,12 +19,12 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	pqutils "github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	pqutils "github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/byte_array_encoder.go b/go/parquet/internal/encoding/byte_array_encoder.go
index cb49178435a6f..9270b5531768c 100644
--- a/go/parquet/internal/encoding/byte_array_encoder.go
+++ b/go/parquet/internal/encoding/byte_array_encoder.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // PlainByteArrayEncoder encodes byte arrays according to the spec for Plain encoding
diff --git a/go/parquet/internal/encoding/decoder.go b/go/parquet/internal/encoding/decoder.go
index b441868e1df85..cee624730e993 100644
--- a/go/parquet/internal/encoding/decoder.go
+++ b/go/parquet/internal/encoding/decoder.go
@@ -20,16 +20,16 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index 1fb91634e977b..a00f3457cac7a 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 // see the deltaBitPack encoder for a description of the encoding format that is
diff --git a/go/parquet/internal/encoding/delta_byte_array.go b/go/parquet/internal/encoding/delta_byte_array.go
index 60a20a3ff0d72..b35d022fd5deb 100644
--- a/go/parquet/internal/encoding/delta_byte_array.go
+++ b/go/parquet/internal/encoding/delta_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_byte_array_test.go b/go/parquet/internal/encoding/delta_byte_array_test.go
index 69c632bf69971..0a206796f742a 100644
--- a/go/parquet/internal/encoding/delta_byte_array_test.go
+++ b/go/parquet/internal/encoding/delta_byte_array_test.go
@@ -18,8 +18,8 @@ package encoding
 
 import (
 	"fmt"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
diff --git a/go/parquet/internal/encoding/delta_length_byte_array.go b/go/parquet/internal/encoding/delta_length_byte_array.go
index 981a067b07e08..d5a99c187d11e 100644
--- a/go/parquet/internal/encoding/delta_length_byte_array.go
+++ b/go/parquet/internal/encoding/delta_length_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/encoder.go b/go/parquet/internal/encoding/encoder.go
index f6b57fe63c433..7023309397a3b 100644
--- a/go/parquet/internal/encoding/encoder.go
+++ b/go/parquet/internal/encoding/encoder.go
@@ -21,14 +21,14 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata plain_encoder_types.gen.go.tmpl typed_encoder.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/encoding_benchmarks_test.go b/go/parquet/internal/encoding/encoding_benchmarks_test.go
index 0bb4e895f316d..e0645e9de54e4 100644
--- a/go/parquet/internal/encoding/encoding_benchmarks_test.go
+++ b/go/parquet/internal/encoding/encoding_benchmarks_test.go
@@ -21,14 +21,14 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index b0d86321e09f1..48e2316b0f897 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -26,13 +26,13 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
index e4516bf4a1ac1..1e589fc2e7be1 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
@@ -19,8 +19,8 @@ package encoding
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
index b5aee337d5bf0..39202c8e25d9f 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
@@ -19,9 +19,9 @@ package encoding
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // PlainFixedLenByteArrayEncoder writes the raw bytes of the byte array
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index e04ec19d5473d..caf832059334b 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/levels_test.go b/go/parquet/internal/encoding/levels_test.go
index ae3a3a8c497fc..304ce32b3106d 100644
--- a/go/parquet/internal/encoding/levels_test.go
+++ b/go/parquet/internal/encoding/levels_test.go
@@ -21,11 +21,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table.go b/go/parquet/internal/encoding/memo_table.go
index 170eab47d6160..810e8633b886e 100644
--- a/go/parquet/internal/encoding/memo_table.go
+++ b/go/parquet/internal/encoding/memo_table.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata memo_table_types.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/memo_table_test.go b/go/parquet/internal/encoding/memo_table_test.go
index 1eb61cb2559a3..1b9337010f855 100644
--- a/go/parquet/internal/encoding/memo_table_test.go
+++ b/go/parquet/internal/encoding/memo_table_test.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go b/go/parquet/internal/encoding/memo_table_types.gen.go
index c9af6178bbb98..4da2721437814 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go
@@ -19,8 +19,8 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
index 7e88238d67b71..75335f25ff1f7 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
@@ -17,7 +17,7 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v15/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go b/go/parquet/internal/encoding/plain_encoder_types.gen.go
index 23db13b7a4121..09403d74cb06f 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go
@@ -24,11 +24,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
index e45419050302d..2838c63a41857 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
@@ -20,10 +20,10 @@ import (
   "encoding/binary"
   "fmt"
 
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 var (
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go b/go/parquet/internal/encoding/typed_encoder.gen.go
index 411e87c17e7d5..25fa309e0a38f 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go
@@ -22,15 +22,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
index 69415ccca4a26..66c2649d599c6 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
@@ -17,13 +17,13 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/parquet/schema"
-  format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/parquet/schema"
+  format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 // fully typed encoder interfaces to enable writing against encoder/decoders
diff --git a/go/parquet/internal/encoding/types.go b/go/parquet/internal/encoding/types.go
index 2d13a9c8f877a..4ab3ab1a1c954 100644
--- a/go/parquet/internal/encoding/types.go
+++ b/go/parquet/internal/encoding/types.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encryption/aes.go b/go/parquet/internal/encryption/aes.go
index cc0cea0112fee..b6e9130ef81cd 100644
--- a/go/parquet/internal/encryption/aes.go
+++ b/go/parquet/internal/encryption/aes.go
@@ -29,7 +29,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // important constants for handling the aes encryption
diff --git a/go/parquet/internal/encryption/decryptor.go b/go/parquet/internal/encryption/decryptor.go
index 62a4f2ee9e56e..658559e6082c4 100644
--- a/go/parquet/internal/encryption/decryptor.go
+++ b/go/parquet/internal/encryption/decryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // FileDecryptor is an interface used by the filereader for decrypting an
diff --git a/go/parquet/internal/encryption/encryptor.go b/go/parquet/internal/encryption/encryptor.go
index 2ef09e558a23f..bdbae4740a44f 100644
--- a/go/parquet/internal/encryption/encryptor.go
+++ b/go/parquet/internal/encryption/encryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // FileEncryptor is the interface for constructing encryptors for the different
diff --git a/go/parquet/internal/testutils/pagebuilder.go b/go/parquet/internal/testutils/pagebuilder.go
index 9c1fd72a1bdf0..48ac331640087 100644
--- a/go/parquet/internal/testutils/pagebuilder.go
+++ b/go/parquet/internal/testutils/pagebuilder.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/mock"
 )
 
diff --git a/go/parquet/internal/testutils/primitive_typed.go b/go/parquet/internal/testutils/primitive_typed.go
index 2bd0a29dd2970..daab0d427ba10 100644
--- a/go/parquet/internal/testutils/primitive_typed.go
+++ b/go/parquet/internal/testutils/primitive_typed.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 type PrimitiveTypedTest struct {
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index d9a06da43ba4e..bb101ebf9a92d 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -24,13 +24,13 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
diff --git a/go/parquet/internal/testutils/random_arrow.go b/go/parquet/internal/testutils/random_arrow.go
index 360b8e7476430..d886db0360b84 100644
--- a/go/parquet/internal/testutils/random_arrow.go
+++ b/go/parquet/internal/testutils/random_arrow.go
@@ -17,9 +17,9 @@
 package testutils
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/parquet/internal/testutils/utils.go b/go/parquet/internal/testutils/utils.go
index 1122f4286f386..3da76c17ddc32 100644
--- a/go/parquet/internal/testutils/utils.go
+++ b/go/parquet/internal/testutils/utils.go
@@ -19,7 +19,7 @@ package testutils
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 var typeToParquetTypeMap = map[reflect.Type]parquet.Type{
diff --git a/go/parquet/internal/thrift/helpers.go b/go/parquet/internal/thrift/helpers.go
index 357d9020989d3..3835830ac6c2d 100644
--- a/go/parquet/internal/thrift/helpers.go
+++ b/go/parquet/internal/thrift/helpers.go
@@ -23,7 +23,7 @@ import (
 	"context"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/apache/thrift/lib/go/thrift"
 )
 
diff --git a/go/parquet/internal/utils/bit_benchmark_test.go b/go/parquet/internal/utils/bit_benchmark_test.go
index 2518e48a4baa8..14353380a5694 100644
--- a/go/parquet/internal/utils/bit_benchmark_test.go
+++ b/go/parquet/internal/utils/bit_benchmark_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
 )
 
 type linearBitRunReader struct {
diff --git a/go/parquet/internal/utils/bit_packing_arm64.go b/go/parquet/internal/utils/bit_packing_arm64.go
index 92fe0f97b77c3..e9fb2ef1d810b 100644
--- a/go/parquet/internal/utils/bit_packing_arm64.go
+++ b/go/parquet/internal/utils/bit_packing_arm64.go
@@ -23,7 +23,7 @@ import (
 	"github.com/klauspost/cpuid/v2"
 	// import for side effect of initializing feature flags
 	// based on ARM_ENABLE_EXT env var
-	_ "github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	_ "github.com/apache/arrow/go/v15/parquet/internal/bmi"
 )
 
 func init() {
diff --git a/go/parquet/internal/utils/bit_reader.go b/go/parquet/internal/utils/bit_reader.go
index cf61395c0b16c..bf9741c79878b 100644
--- a/go/parquet/internal/utils/bit_reader.go
+++ b/go/parquet/internal/utils/bit_reader.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // masks for grabbing the trailing bits based on the number of trailing bits desired
diff --git a/go/parquet/internal/utils/bit_reader_test.go b/go/parquet/internal/utils/bit_reader_test.go
index c285f5165cc0a..5ce1b799b463b 100644
--- a/go/parquet/internal/utils/bit_reader_test.go
+++ b/go/parquet/internal/utils/bit_reader_test.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"golang.org/x/exp/rand"
diff --git a/go/parquet/internal/utils/bit_writer.go b/go/parquet/internal/utils/bit_writer.go
index 99a1db065590d..6cb255f5b0473 100644
--- a/go/parquet/internal/utils/bit_writer.go
+++ b/go/parquet/internal/utils/bit_writer.go
@@ -21,7 +21,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 // WriterAtBuffer is a convenience struct for providing a WriteAt function
diff --git a/go/parquet/internal/utils/bitmap_writer.go b/go/parquet/internal/utils/bitmap_writer.go
index 447222139b773..3ef99291e3748 100644
--- a/go/parquet/internal/utils/bitmap_writer.go
+++ b/go/parquet/internal/utils/bitmap_writer.go
@@ -20,7 +20,7 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 // BitmapWriter is an interface for bitmap writers so that we can use multiple
diff --git a/go/parquet/internal/utils/bitmap_writer_test.go b/go/parquet/internal/utils/bitmap_writer_test.go
index 9f38f1ef291ea..3dddc7567903e 100644
--- a/go/parquet/internal/utils/bitmap_writer_test.go
+++ b/go/parquet/internal/utils/bitmap_writer_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index fef322c6fd560..21ac2ce6b5db5 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -24,10 +24,10 @@ import (
 	"encoding/binary"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go b/go/parquet/internal/utils/typed_rle_dict.gen.go
index dff22711b120f..886d24564db4b 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go
@@ -19,9 +19,9 @@
 package utils
 
 import (
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
index 090275745ff59..abcb419055a92 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
@@ -17,9 +17,9 @@
 package utils
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
-  "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
+  "github.com/apache/arrow/go/v15/internal/utils"
 )
 
 {{range .In}}
diff --git a/go/parquet/metadata/app_version.go b/go/parquet/metadata/app_version.go
index 85ace57365bd3..9966827026106 100644
--- a/go/parquet/metadata/app_version.go
+++ b/go/parquet/metadata/app_version.go
@@ -21,8 +21,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 var (
diff --git a/go/parquet/metadata/column_chunk.go b/go/parquet/metadata/column_chunk.go
index e6ea6ff1ea183..729f741e1b4f9 100644
--- a/go/parquet/metadata/column_chunk.go
+++ b/go/parquet/metadata/column_chunk.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/file.go b/go/parquet/metadata/file.go
index dddd95c5df670..3335140c2e1c8 100644
--- a/go/parquet/metadata/file.go
+++ b/go/parquet/metadata/file.go
@@ -24,12 +24,12 @@ import (
 	"reflect"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/metadata_test.go b/go/parquet/metadata/metadata_test.go
index b685dd2223274..8caa319f83e63 100644
--- a/go/parquet/metadata/metadata_test.go
+++ b/go/parquet/metadata/metadata_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/row_group.go b/go/parquet/metadata/row_group.go
index 16af67241e959..2923720371abe 100644
--- a/go/parquet/metadata/row_group.go
+++ b/go/parquet/metadata/row_group.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 // RowGroupMetaData is a proxy around the thrift RowGroup meta data object
diff --git a/go/parquet/metadata/stat_compare_test.go b/go/parquet/metadata/stat_compare_test.go
index d02123cbef039..041696d84d17a 100644
--- a/go/parquet/metadata/stat_compare_test.go
+++ b/go/parquet/metadata/stat_compare_test.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/statistics.go b/go/parquet/metadata/statistics.go
index 245b06a7348c4..606e76ffd0454 100644
--- a/go/parquet/metadata/statistics.go
+++ b/go/parquet/metadata/statistics.go
@@ -22,14 +22,14 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata statistics_types.gen.go.tmpl
diff --git a/go/parquet/metadata/statistics_test.go b/go/parquet/metadata/statistics_test.go
index 35d8b7821c51a..47798d3c4dd3c 100644
--- a/go/parquet/metadata/statistics_test.go
+++ b/go/parquet/metadata/statistics_test.go
@@ -21,11 +21,11 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go b/go/parquet/metadata/statistics_types.gen.go
index e6aa7f1801a0f..e8fb9877c8444 100644
--- a/go/parquet/metadata/statistics_types.gen.go
+++ b/go/parquet/metadata/statistics_types.gen.go
@@ -22,14 +22,14 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go.tmpl b/go/parquet/metadata/statistics_types.gen.go.tmpl
index 35470f06046bf..4b6253a8574ea 100644
--- a/go/parquet/metadata/statistics_types.gen.go.tmpl
+++ b/go/parquet/metadata/statistics_types.gen.go.tmpl
@@ -19,13 +19,13 @@ package metadata
 import (
   "fmt"
 
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/parquet/schema"
-  "github.com/apache/arrow/go/v14/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/parquet/internal/encoding"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/parquet/schema"
+  "github.com/apache/arrow/go/v15/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/parquet/internal/encoding"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 {{range .In}}
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 759a3d8675927..02f94c941c3d9 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -26,16 +26,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index c3a0a50c43f45..81b4527b105cb 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -25,16 +25,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 )
 
 // get the count of the number of leaf arrays for the type
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 3c20cf2d4757b..281ca0d526476 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -25,22 +25,22 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/encode_dict_compute.go b/go/parquet/pqarrow/encode_dict_compute.go
index 59e25cec19132..b43b4002ed0af 100644
--- a/go/parquet/pqarrow/encode_dict_compute.go
+++ b/go/parquet/pqarrow/encode_dict_compute.go
@@ -21,14 +21,14 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 func isDictEncoding(enc parquet.Encoding) bool {
diff --git a/go/parquet/pqarrow/encode_dict_nocompute.go b/go/parquet/pqarrow/encode_dict_nocompute.go
index 31d0f1bc1ce27..73ec5cfc46682 100644
--- a/go/parquet/pqarrow/encode_dict_nocompute.go
+++ b/go/parquet/pqarrow/encode_dict_nocompute.go
@@ -21,8 +21,8 @@ package pqarrow
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/parquet/file"
 )
 
 func writeDictionaryArrow(*arrowWriteContext, file.ColumnChunkWriter, arrow.Array, []int16, []int16, bool) (err error) {
diff --git a/go/parquet/pqarrow/encode_dictionary_test.go b/go/parquet/pqarrow/encode_dictionary_test.go
index 995f3fb329534..28ebee53e1b83 100644
--- a/go/parquet/pqarrow/encode_dictionary_test.go
+++ b/go/parquet/pqarrow/encode_dictionary_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/pqarrow/file_reader.go b/go/parquet/pqarrow/file_reader.go
index d91010c62c19d..3534cc87b78b5 100755
--- a/go/parquet/pqarrow/file_reader.go
+++ b/go/parquet/pqarrow/file_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/pqarrow/file_reader_test.go b/go/parquet/pqarrow/file_reader_test.go
index d1f3ae1c984a2..9c1b4252f5fc6 100644
--- a/go/parquet/pqarrow/file_reader_test.go
+++ b/go/parquet/pqarrow/file_reader_test.go
@@ -26,13 +26,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index aa0bae7b1fdfb..21f16c0b67938 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/helpers.go b/go/parquet/pqarrow/helpers.go
index e8b740d12ba62..39d17cf80ae68 100644
--- a/go/parquet/pqarrow/helpers.go
+++ b/go/parquet/pqarrow/helpers.go
@@ -17,7 +17,7 @@
 package pqarrow
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func releaseArrays(arrays []arrow.Array) {
diff --git a/go/parquet/pqarrow/path_builder.go b/go/parquet/pqarrow/path_builder.go
index c4915d58dd59f..0f1158bd1e9f0 100644
--- a/go/parquet/pqarrow/path_builder.go
+++ b/go/parquet/pqarrow/path_builder.go
@@ -21,11 +21,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/path_builder_test.go b/go/parquet/pqarrow/path_builder_test.go
index 16b994582df02..e0a60262d3f4a 100644
--- a/go/parquet/pqarrow/path_builder_test.go
+++ b/go/parquet/pqarrow/path_builder_test.go
@@ -20,10 +20,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/properties.go b/go/parquet/pqarrow/properties.go
index 98427bbf9398c..cc100fa80d87b 100755
--- a/go/parquet/pqarrow/properties.go
+++ b/go/parquet/pqarrow/properties.go
@@ -19,9 +19,9 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 // ArrowWriterProperties are used to determine how to manipulate the arrow data
diff --git a/go/parquet/pqarrow/reader_writer_test.go b/go/parquet/pqarrow/reader_writer_test.go
index e3f66834c2cee..9d09bcec15da6 100644
--- a/go/parquet/pqarrow/reader_writer_test.go
+++ b/go/parquet/pqarrow/reader_writer_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index 9ba8554898986..b23c37ea39102 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -22,15 +22,15 @@ import (
 	"math"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/schema_test.go b/go/parquet/pqarrow/schema_test.go
index e195358af6c98..b5e7dc8fad34a 100644
--- a/go/parquet/pqarrow/schema_test.go
+++ b/go/parquet/pqarrow/schema_test.go
@@ -20,15 +20,15 @@ import (
 	"encoding/base64"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/reader_properties.go b/go/parquet/reader_properties.go
index dd2032958a51c..be2377527d782 100644
--- a/go/parquet/reader_properties.go
+++ b/go/parquet/reader_properties.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // ReaderProperties are used to define how the file reader will handle buffering and allocating buffers
diff --git a/go/parquet/reader_writer_properties_test.go b/go/parquet/reader_writer_properties_test.go
index 6bd93a02550e4..698129471adda 100644
--- a/go/parquet/reader_writer_properties_test.go
+++ b/go/parquet/reader_writer_properties_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/column.go b/go/parquet/schema/column.go
index 1575037d59d23..02d0d83e8465e 100644
--- a/go/parquet/schema/column.go
+++ b/go/parquet/schema/column.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Column encapsulates the information necessary to interpret primitive
diff --git a/go/parquet/schema/converted_types.go b/go/parquet/schema/converted_types.go
index 6a4702b819259..58051dba7f19b 100644
--- a/go/parquet/schema/converted_types.go
+++ b/go/parquet/schema/converted_types.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // ConvertedType corresponds to the ConvertedType in the parquet.Thrift,
diff --git a/go/parquet/schema/converted_types_test.go b/go/parquet/schema/converted_types_test.go
index a4f9ea0018196..8b8e061466474 100644
--- a/go/parquet/schema/converted_types_test.go
+++ b/go/parquet/schema/converted_types_test.go
@@ -19,7 +19,7 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/helpers.go b/go/parquet/schema/helpers.go
index 23a5a0b667f26..13075a065f073 100644
--- a/go/parquet/schema/helpers.go
+++ b/go/parquet/schema/helpers.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/helpers_test.go b/go/parquet/schema/helpers_test.go
index 6d136e4ecd155..98f3cab36d433 100644
--- a/go/parquet/schema/helpers_test.go
+++ b/go/parquet/schema/helpers_test.go
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index a0607a1a2f62d..1ea44fc56c615 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // DecimalMetadata is a struct for managing scale and precision information between
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 8531a061abb77..49edf1748c52c 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -19,9 +19,9 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/node.go b/go/parquet/schema/node.go
index 28259c8d61f58..ff23624afa35d 100644
--- a/go/parquet/schema/node.go
+++ b/go/parquet/schema/node.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index bc863f1390030..d79edb92408f8 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index e18feada7a796..06ad7191a5749 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -22,8 +22,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/schema.go b/go/parquet/schema/schema.go
index 1b3363f58d11f..ace2775763a06 100644
--- a/go/parquet/schema/schema.go
+++ b/go/parquet/schema/schema.go
@@ -35,8 +35,8 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/schema_element_test.go b/go/parquet/schema/schema_element_test.go
index e9a2ef5eb31f6..dd1d293e5cfd7 100644
--- a/go/parquet/schema/schema_element_test.go
+++ b/go/parquet/schema/schema_element_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_flatten_test.go b/go/parquet/schema/schema_flatten_test.go
index 90741ae9b43bb..34f4ac8d3c450 100644
--- a/go/parquet/schema/schema_flatten_test.go
+++ b/go/parquet/schema/schema_flatten_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_test.go b/go/parquet/schema/schema_test.go
index e69a13e07986e..b60c7dfaafcd1 100644
--- a/go/parquet/schema/schema_test.go
+++ b/go/parquet/schema/schema_test.go
@@ -20,9 +20,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/types.go b/go/parquet/types.go
index 7b6df2ea9d16c..5b6f8fb0251d9 100644
--- a/go/parquet/types.go
+++ b/go/parquet/types.go
@@ -24,8 +24,8 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 const (
diff --git a/go/parquet/writer_properties.go b/go/parquet/writer_properties.go
index e4199f451f5f9..9e33bddf7faa7 100644
--- a/go/parquet/writer_properties.go
+++ b/go/parquet/writer_properties.go
@@ -17,8 +17,8 @@
 package parquet
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 )
 
 // Constants for default property values used for the default reader, writer and column props.
@@ -46,7 +46,7 @@ const (
 	DefaultStatsEnabled = true
 	// If the stats are larger than 4K the writer will skip writing them out anyways.
 	DefaultMaxStatsSize int64 = 4096
-	DefaultCreatedBy          = "parquet-go version 14.0.0-SNAPSHOT"
+	DefaultCreatedBy          = "parquet-go version 15.0.0-SNAPSHOT"
 	DefaultRootName           = "schema"
 )
 
diff --git a/java/adapter/avro/pom.xml b/java/adapter/avro/pom.xml
index 6735094d11bb4..c0410ea4c2314 100644
--- a/java/adapter/avro/pom.xml
+++ b/java/adapter/avro/pom.xml
@@ -16,7 +16,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../../pom.xml</relativePath>
   </parent>
 
diff --git a/java/adapter/jdbc/pom.xml b/java/adapter/jdbc/pom.xml
index 127202c5215ec..2490f708e6f24 100644
--- a/java/adapter/jdbc/pom.xml
+++ b/java/adapter/jdbc/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/adapter/orc/pom.xml b/java/adapter/orc/pom.xml
index ec85bf8fe720c..72ba13ea81738 100644
--- a/java/adapter/orc/pom.xml
+++ b/java/adapter/orc/pom.xml
@@ -111,7 +111,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/algorithm/pom.xml b/java/algorithm/pom.xml
index 235c9440f9196..8c6a9fb0151ef 100644
--- a/java/algorithm/pom.xml
+++ b/java/algorithm/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-algorithm</artifactId>
   <name>Arrow Algorithms</name>
diff --git a/java/bom/pom.xml b/java/bom/pom.xml
index 7ea0b9bf514be..1f6f854f60013 100644
--- a/java/bom/pom.xml
+++ b/java/bom/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-bom</artifactId>
-  <version>14.0.0-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Arrow Bill of Materials</name>
   <description>Arrow Bill of Materials</description>
diff --git a/java/c/pom.xml b/java/c/pom.xml
index a40a7f9e7f5f6..d66379d356624 100644
--- a/java/c/pom.xml
+++ b/java/c/pom.xml
@@ -13,7 +13,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/compression/pom.xml b/java/compression/pom.xml
index ff2835acbe8a4..129268b9e6a07 100644
--- a/java/compression/pom.xml
+++ b/java/compression/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-compression</artifactId>
   <name>Arrow Compression</name>
diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index ad88c02c16fe3..b533a1733521b 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/flight/flight-core/pom.xml b/java/flight/flight-core/pom.xml
index c9fa75615032b..7b69179053d7f 100644
--- a/java/flight/flight-core/pom.xml
+++ b/java/flight/flight-core/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/flight-grpc/pom.xml b/java/flight/flight-grpc/pom.xml
index c857500d560b0..e7bb9508d2403 100644
--- a/java/flight/flight-grpc/pom.xml
+++ b/java/flight/flight-grpc/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
   <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-integration-tests/pom.xml b/java/flight/flight-integration-tests/pom.xml
index 20e31e0ceec04..778cb7df11f61 100644
--- a/java/flight/flight-integration-tests/pom.xml
+++ b/java/flight/flight-integration-tests/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index b99f887a6c9f4..8a0e62bde8471 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 853f1e12274b9..263538ba48b37 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql/pom.xml b/java/flight/flight-sql/pom.xml
index 573eb676fd834..09100d9731ad5 100644
--- a/java/flight/flight-sql/pom.xml
+++ b/java/flight/flight-sql/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/pom.xml b/java/flight/pom.xml
index b6b84278c1960..7ddda94f77b49 100644
--- a/java/flight/pom.xml
+++ b/java/flight/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/format/pom.xml b/java/format/pom.xml
index c8e83336c0ff3..3f581311e20ea 100644
--- a/java/format/pom.xml
+++ b/java/format/pom.xml
@@ -15,7 +15,7 @@
 <parent>
   <artifactId>arrow-java-root</artifactId>
   <groupId>org.apache.arrow</groupId>
-  <version>14.0.0-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
 </parent>
 
 <artifactId>arrow-format</artifactId>
diff --git a/java/gandiva/pom.xml b/java/gandiva/pom.xml
index c9ca3ef615d0e..cfda0b0c527a9 100644
--- a/java/gandiva/pom.xml
+++ b/java/gandiva/pom.xml
@@ -14,7 +14,7 @@
     <parent>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-java-root</artifactId>
-      <version>14.0.0-SNAPSHOT</version>
+      <version>15.0.0-SNAPSHOT</version>
     </parent>
 
     <groupId>org.apache.arrow.gandiva</groupId>
diff --git a/java/memory/memory-core/pom.xml b/java/memory/memory-core/pom.xml
index 62d74bd0925c9..8f28699045383 100644
--- a/java/memory/memory-core/pom.xml
+++ b/java/memory/memory-core/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-netty/pom.xml b/java/memory/memory-netty/pom.xml
index 626452dba8777..307f6ad81a0f1 100644
--- a/java/memory/memory-netty/pom.xml
+++ b/java/memory/memory-netty/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-unsafe/pom.xml b/java/memory/memory-unsafe/pom.xml
index 33e2058d5f2da..9f8137308195d 100644
--- a/java/memory/memory-unsafe/pom.xml
+++ b/java/memory/memory-unsafe/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/pom.xml b/java/memory/pom.xml
index 0ddbf63ef38b9..c10263b97f1bf 100644
--- a/java/memory/pom.xml
+++ b/java/memory/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-memory</artifactId>
   <name>Arrow Memory</name>
diff --git a/java/performance/pom.xml b/java/performance/pom.xml
index c6dc572935cb1..102832491ec05 100644
--- a/java/performance/pom.xml
+++ b/java/performance/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-performance</artifactId>
     <packaging>jar</packaging>
diff --git a/java/pom.xml b/java/pom.xml
index 417bdd5da375a..6d1ef51380b7a 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-java-root</artifactId>
-  <version>14.0.0-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>Apache Arrow Java Root POM</name>
diff --git a/java/tools/pom.xml b/java/tools/pom.xml
index b139b3876e4ae..128825c224369 100644
--- a/java/tools/pom.xml
+++ b/java/tools/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.0-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-tools</artifactId>
     <name>Arrow Tools</name>
diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index 98d7e02126a98..4c8bf1e594aa4 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.0-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-vector</artifactId>
   <name>Arrow Vectors</name>
diff --git a/js/package.json b/js/package.json
index 14f26c74d29f3..fd4408e5bcaab 100644
--- a/js/package.json
+++ b/js/package.json
@@ -121,5 +121,5 @@
   "engines": {
     "node": ">=12.0"
   },
-  "version": "14.0.0-SNAPSHOT"
+  "version": "15.0.0-SNAPSHOT"
 }
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index b7af37a278536..47d2acd613f8b 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -94,7 +94,7 @@ endfunction()
 
 set(CMAKE_CXX_STANDARD 17)
 
-set(MLARROW_VERSION "14.0.0-SNAPSHOT")
+set(MLARROW_VERSION "15.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" MLARROW_BASE_VERSION "${MLARROW_VERSION}")
 
 project(mlarrow VERSION "${MLARROW_BASE_VERSION}")
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 2a430055a5a86..86285c3dc381b 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -21,7 +21,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(pyarrow)
 
-set(PYARROW_VERSION "14.0.0-SNAPSHOT")
+set(PYARROW_VERSION "15.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" PYARROW_BASE_VERSION "${PYARROW_VERSION}")
 
 # Running from a Python sdist tarball
diff --git a/python/setup.py b/python/setup.py
index 3686dc4573cf7..b1c825d84d5a9 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -407,7 +407,7 @@ def get_outputs(self):
 
 # If the event of not running from a git clone (e.g. from a git archive
 # or a Python sdist), see if we can set the version number ourselves
-default_version = '14.0.0-SNAPSHOT'
+default_version = '15.0.0-SNAPSHOT'
 if (not os.path.exists('../.git') and
         not os.environ.get('SETUPTOOLS_SCM_PRETEND_VERSION')):
     os.environ['SETUPTOOLS_SCM_PRETEND_VERSION'] = \
diff --git a/r/DESCRIPTION b/r/DESCRIPTION
index 72e1c4334ce8f..3a36a808ab1d0 100644
--- a/r/DESCRIPTION
+++ b/r/DESCRIPTION
@@ -1,6 +1,6 @@
 Package: arrow
 Title: Integration to 'Apache' 'Arrow'
-Version: 13.0.0.9000
+Version: 14.0.0.9000
 Authors@R: c(
     person("Neal", "Richardson", email = "neal.p.richardson@gmail.com", role = c("aut")),
     person("Ian", "Cook", email = "ianmcook@gmail.com", role = c("aut")),
diff --git a/r/NEWS.md b/r/NEWS.md
index 34875cce55ab8..e00c6b51b597d 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -17,7 +17,9 @@
   under the License.
 -->
 
-# arrow 13.0.0.9000
+# arrow 14.0.0.9000
+
+# arrow 14.0.0
 
 ## New features
 
diff --git a/r/pkgdown/assets/versions.json b/r/pkgdown/assets/versions.json
index b7c6984e3c660..615a84511fca9 100644
--- a/r/pkgdown/assets/versions.json
+++ b/r/pkgdown/assets/versions.json
@@ -1,12 +1,16 @@
 [
     {
-        "name": "13.0.0.9000 (dev)",
+        "name": "14.0.0.9000 (dev)",
         "version": "dev/"
     },
     {
-        "name": "13.0.0.1 (release)",
+        "name": "14.0.0 (release)",
         "version": ""
     },
+    {
+        "name": "13.0.0.1",
+        "version": "13.0/"
+    },
     {
         "name": "12.0.1.1",
         "version": "12.0/"
diff --git a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
index f1619503fe63a..8551b647cb86f 100644
--- a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
+++ b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowCUDA
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
index ae903d6a1b9d7..acfdd675687be 100644
--- a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
+++ b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowDataset
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
index 2a800c7f3f2bf..3354678e30032 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlightSQL
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/version.rb b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
index ab06445180191..f2141a68432e5 100644
--- a/ruby/red-arrow-flight/lib/arrow-flight/version.rb
+++ b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlight
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow/lib/arrow/version.rb b/ruby/red-arrow/lib/arrow/version.rb
index 23d0239549e48..235a7df75d672 100644
--- a/ruby/red-arrow/lib/arrow/version.rb
+++ b/ruby/red-arrow/lib/arrow/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-gandiva/lib/gandiva/version.rb b/ruby/red-gandiva/lib/gandiva/version.rb
index 190abcf134a9a..6a1835f0e50e8 100644
--- a/ruby/red-gandiva/lib/gandiva/version.rb
+++ b/ruby/red-gandiva/lib/gandiva/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Gandiva
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-parquet/lib/parquet/version.rb b/ruby/red-parquet/lib/parquet/version.rb
index 747c68f9af7f8..c5a945c4e4297 100644
--- a/ruby/red-parquet/lib/parquet/version.rb
+++ b/ruby/red-parquet/lib/parquet/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Parquet
-  VERSION = "14.0.0-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")

From 62985c56930f6d7f151508a0e510d40e7bd41ced Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 1 Nov 2023 16:41:50 +0100
Subject: [PATCH 660/749] MINOR: [Release] Update .deb package names for 15.0.0

---
 .../apache-arrow/debian/control.in            | 104 +++++++++---------
 ...400.install => libarrow-acero1500.install} |   0
 ...install => libarrow-cuda-glib1500.install} |   0
 ...1400.install => libarrow-cuda1500.install} |   0
 ...tall => libarrow-dataset-glib1500.install} |   0
 ...0.install => libarrow-dataset1500.install} |   0
 ...stall => libarrow-flight-glib1500.install} |   0
 ...l => libarrow-flight-sql-glib1500.install} |   0
 ...nstall => libarrow-flight-sql1500.install} |   0
 ...00.install => libarrow-flight1500.install} |   0
 ...1400.install => libarrow-glib1500.install} |   0
 ...arrow1400.install => libarrow1500.install} |   0
 ...00.install => libgandiva-glib1500.install} |   0
 ...iva1400.install => libgandiva1500.install} |   0
 ...00.install => libparquet-glib1500.install} |   0
 ...uet1400.install => libparquet1500.install} |   0
 dev/tasks/tasks.yml                           |  60 +++++-----
 17 files changed, 82 insertions(+), 82 deletions(-)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-acero1400.install => libarrow-acero1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-cuda-glib1400.install => libarrow-cuda-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-cuda1400.install => libarrow-cuda1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-dataset-glib1400.install => libarrow-dataset-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-dataset1400.install => libarrow-dataset1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-glib1400.install => libarrow-flight-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-sql-glib1400.install => libarrow-flight-sql-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight-sql1400.install => libarrow-flight-sql1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-flight1400.install => libarrow-flight1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow-glib1400.install => libarrow-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libarrow1400.install => libarrow1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libgandiva-glib1400.install => libgandiva-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libgandiva1400.install => libgandiva1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libparquet-glib1400.install => libparquet-glib1500.install} (100%)
 rename dev/tasks/linux-packages/apache-arrow/debian/{libparquet1400.install => libparquet1500.install} (100%)

diff --git a/dev/tasks/linux-packages/apache-arrow/debian/control.in b/dev/tasks/linux-packages/apache-arrow/debian/control.in
index f08fc05bfc3ad..6ea7e56e88365 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/control.in
+++ b/dev/tasks/linux-packages/apache-arrow/debian/control.in
@@ -41,7 +41,7 @@ Build-Depends-Indep: libglib2.0-doc
 Standards-Version: 3.9.8
 Homepage: https://arrow.apache.org/
 
-Package: libarrow1400
+Package: libarrow1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -61,12 +61,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides tools.
 
-Package: libarrow-cuda1400
+Package: libarrow-cuda1500
 Section: libs
 Architecture: @CUDA_ARCHITECTURE@
 Multi-Arch: same
@@ -74,12 +74,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for CUDA support.
 
-Package: libarrow-acero1400
+Package: libarrow-acero1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -87,12 +87,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Acero module.
 
-Package: libarrow-dataset1400
+Package: libarrow-dataset1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -100,13 +100,13 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-acero1400 (= ${binary:Version}),
-  libparquet1400 (= ${binary:Version})
+  libarrow-acero1500 (= ${binary:Version}),
+  libparquet1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Dataset module.
 
-Package: libarrow-flight1400
+Package: libarrow-flight1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -114,12 +114,12 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Flight RPC system.
 
-Package: libarrow-flight-sql1400
+Package: libarrow-flight-sql1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -127,7 +127,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-flight1400 (= ${binary:Version})
+  libarrow-flight1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ library files for Flight SQL system.
@@ -138,7 +138,7 @@ Architecture: any
 Multi-Arch: same
 Depends:
   ${misc:Depends},
-  libarrow1400 (= ${binary:Version}),
+  libarrow1500 (= ${binary:Version}),
   libbrotli-dev,
   libbz2-dev,
   libcurl4-openssl-dev,
@@ -163,7 +163,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libarrow-cuda1400 (= ${binary:Version})
+  libarrow-cuda1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for CUDA support.
@@ -174,7 +174,7 @@ Architecture: any
 Multi-Arch: same
 Depends:
   ${misc:Depends},
-  libarrow-acero1400 (= ${binary:Version}),
+  libarrow-acero1500 (= ${binary:Version}),
   libparquet-dev (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -187,7 +187,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-acero-dev (= ${binary:Version}),
-  libarrow-dataset1400 (= ${binary:Version}),
+  libarrow-dataset1500 (= ${binary:Version}),
   libparquet-dev (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -200,7 +200,7 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libarrow-flight1400 (= ${binary:Version}),
+  libarrow-flight1500 (= ${binary:Version}),
   libc-ares-dev,
 @USE_SYSTEM_GRPC@  libgrpc++-dev,
 @USE_SYSTEM_PROTOBUF@  libprotobuf-dev,
@@ -216,12 +216,12 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-flight-dev (= ${binary:Version}),
-  libarrow-flight-sql1400 (= ${binary:Version})
+  libarrow-flight-sql1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides C++ header files for Flight SQL system.
 
-Package: libgandiva1400
+Package: libgandiva1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -229,7 +229,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
@@ -242,13 +242,13 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libgandiva1400 (= ${binary:Version})
+  libgandiva1500 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
  This package provides C++ header files.
 
-Package: libparquet1400
+Package: libparquet1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -268,7 +268,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libparquet1400 (= ${binary:Version})
+  libparquet1500 (= ${binary:Version})
 Description: Apache Parquet is a columnar storage format
  .
  This package provides tools.
@@ -280,13 +280,13 @@ Multi-Arch: same
 Depends:
   ${misc:Depends},
   libarrow-dev (= ${binary:Version}),
-  libparquet1400 (= ${binary:Version}),
+  libparquet1500 (= ${binary:Version}),
   libthrift-dev
 Description: Apache Parquet is a columnar storage format
  .
  This package provides C++ header files.
 
-Package: libarrow-glib1400
+Package: libarrow-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -294,7 +294,7 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow1400 (= ${binary:Version})
+  libarrow1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files.
@@ -318,7 +318,7 @@ Depends:
   ${misc:Depends},
   libglib2.0-dev,
   libarrow-acero-dev (= ${binary:Version}),
-  libarrow-glib1400 (= ${binary:Version}),
+  libarrow-glib1500 (= ${binary:Version}),
   gir1.2-arrow-1.0 (= ${binary:Version})
 Suggests: libarrow-glib-doc
 Description: Apache Arrow is a data processing library for analysis
@@ -336,7 +336,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations.
 
-Package: libarrow-cuda-glib1400
+Package: libarrow-cuda-glib1500
 Section: libs
 Architecture: @CUDA_ARCHITECTURE@
 Multi-Arch: same
@@ -344,8 +344,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1400 (= ${binary:Version}),
-  libarrow-cuda1400 (= ${binary:Version})
+  libarrow-glib1500 (= ${binary:Version}),
+  libarrow-cuda1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for CUDA support.
@@ -370,13 +370,13 @@ Depends:
   ${misc:Depends},
   libarrow-cuda-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-cuda-glib1400 (= ${binary:Version}),
+  libarrow-cuda-glib1500 (= ${binary:Version}),
   gir1.2-arrow-cuda-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based header files for CUDA support.
 
-Package: libarrow-dataset-glib1400
+Package: libarrow-dataset-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -384,8 +384,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1400 (= ${binary:Version}),
-  libarrow-dataset1400 (= ${binary:Version})
+  libarrow-glib1500 (= ${binary:Version}),
+  libarrow-dataset1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for dataset module.
@@ -410,7 +410,7 @@ Depends:
   ${misc:Depends},
   libarrow-dataset-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-dataset-glib1400 (= ${binary:Version}),
+  libarrow-dataset-glib1500 (= ${binary:Version}),
   gir1.2-arrow-dataset-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -427,7 +427,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for dataset module.
 
-Package: libarrow-flight-glib1400
+Package: libarrow-flight-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -435,8 +435,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1400 (= ${binary:Version}),
-  libarrow-flight1400 (= ${binary:Version})
+  libarrow-glib1500 (= ${binary:Version}),
+  libarrow-flight1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for Apache Arrow Flight.
@@ -462,7 +462,7 @@ Depends:
   ${misc:Depends},
   libarrow-flight-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libarrow-flight-glib1400 (= ${binary:Version}),
+  libarrow-flight-glib1500 (= ${binary:Version}),
   gir1.2-arrow-flight-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -479,7 +479,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for Apache Arrow Flight.
 
-Package: libarrow-flight-sql-glib1400
+Package: libarrow-flight-sql-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -487,8 +487,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-flight-glib1400 (= ${binary:Version}),
-  libarrow-flight-sql1400 (= ${binary:Version})
+  libarrow-flight-glib1500 (= ${binary:Version}),
+  libarrow-flight-sql1500 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
  This package provides GLib based library files for Apache Arrow Flight SQL.
@@ -514,7 +514,7 @@ Depends:
   ${misc:Depends},
   libarrow-flight-sql-dev (= ${binary:Version}),
   libarrow-flight-glib-dev (= ${binary:Version}),
-  libarrow-flight-sql-glib1400 (= ${binary:Version}),
+  libarrow-flight-sql-glib1500 (= ${binary:Version}),
   gir1.2-arrow-flight-sql-1.0 (= ${binary:Version})
 Description: Apache Arrow is a data processing library for analysis
  .
@@ -531,7 +531,7 @@ Description: Apache Arrow is a data processing library for analysis
  .
  This package provides documentations for Apache Arrow Flight SQL.
 
-Package: libgandiva-glib1400
+Package: libgandiva-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -539,8 +539,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1400 (= ${binary:Version}),
-  libgandiva1400 (= ${binary:Version})
+  libarrow-glib1500 (= ${binary:Version}),
+  libgandiva1500 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
  .
@@ -567,7 +567,7 @@ Depends:
   ${misc:Depends},
   libgandiva-dev (= ${binary:Version}),
   libarrow-glib-dev (= ${binary:Version}),
-  libgandiva-glib1400 (= ${binary:Version}),
+  libgandiva-glib1500 (= ${binary:Version}),
   gir1.2-gandiva-1.0 (= ${binary:Version})
 Description: Gandiva is a toolset for compiling and evaluating expressions
  on Arrow Data.
@@ -586,7 +586,7 @@ Description: Gandiva is a toolset for compiling and evaluating expressions
  .
  This package provides documentations.
 
-Package: libparquet-glib1400
+Package: libparquet-glib1500
 Section: libs
 Architecture: any
 Multi-Arch: same
@@ -594,8 +594,8 @@ Pre-Depends: ${misc:Pre-Depends}
 Depends:
   ${misc:Depends},
   ${shlibs:Depends},
-  libarrow-glib1400 (= ${binary:Version}),
-  libparquet1400 (= ${binary:Version})
+  libarrow-glib1500 (= ${binary:Version}),
+  libparquet1500 (= ${binary:Version})
 Description: Apache Parquet is a columnar storage format
  .
  This package provides GLib based library files.
@@ -620,7 +620,7 @@ Depends:
   ${misc:Depends},
   libarrow-glib-dev (= ${binary:Version}),
   libparquet-dev (= ${binary:Version}),
-  libparquet-glib1400 (= ${binary:Version}),
+  libparquet-glib1500 (= ${binary:Version}),
   gir1.2-parquet-1.0 (= ${binary:Version})
 Suggests: libparquet-glib-doc
 Description: Apache Parquet is a columnar storage format
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-acero1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-cuda1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-dataset1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight-sql1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-flight1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libarrow1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libarrow1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libarrow1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libarrow1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libgandiva-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libgandiva1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libgandiva1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libgandiva1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libgandiva1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libparquet-glib1500.install
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/libparquet1400.install b/dev/tasks/linux-packages/apache-arrow/debian/libparquet1500.install
similarity index 100%
rename from dev/tasks/linux-packages/apache-arrow/debian/libparquet1400.install
rename to dev/tasks/linux-packages/apache-arrow/debian/libparquet1500.install
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index b620c9b8c8b0c..0c62200e9b1ab 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -594,59 +594,59 @@ tasks:
       - gir1.2-gandiva-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - gir1.2-parquet-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-acero-dev_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-acero1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-acero1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-acero1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-acero1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dataset-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-dataset-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-dataset-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-dataset1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-dataset1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-dataset-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-dataset-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-dataset1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-dataset1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-flight-sql-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-sql-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-sql-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight-sql1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight-sql1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-flight1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-flight1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-sql-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-sql-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight-sql1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight-sql1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-flight1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-flight1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libgandiva-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libgandiva-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libgandiva-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libgandiva1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libgandiva1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libgandiva-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libgandiva-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libgandiva1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libgandiva1500_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libparquet-glib-doc_{no_rc_version}-1_[a-z0-9]+.deb
-      - libparquet-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libparquet-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libparquet1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libparquet1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libparquet-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libparquet-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libparquet1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libparquet1500_{no_rc_version}-1_[a-z0-9]+.deb
       - parquet-tools_{no_rc_version}-1_[a-z0-9]+.deb
     {% if architecture == "amd64" %}
       - gir1.2-arrow-cuda-1.0_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-cuda-dev_{no_rc_version}-1_[a-z0-9]+.deb
       - libarrow-cuda-glib-dev_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-cuda-glib1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-cuda-glib1400_{no_rc_version}-1_[a-z0-9]+.deb
-      - libarrow-cuda1400-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
-      - libarrow-cuda1400_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-cuda-glib1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-cuda-glib1500_{no_rc_version}-1_[a-z0-9]+.deb
+      - libarrow-cuda1500-dbgsym_{no_rc_version}-1_[a-z0-9]+.d?deb
+      - libarrow-cuda1500_{no_rc_version}-1_[a-z0-9]+.deb
     {% endif %}
   {% endfor %}
 {% endfor %}

From 5d6192c7db5e13d72d79bc9ca470c544344ec52b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Wed, 1 Nov 2023 16:41:50 +0100
Subject: [PATCH 661/749] MINOR: [Release] Update .deb/.rpm changelogs for
 14.0.0

---
 .../linux-packages/apache-arrow-apt-source/debian/changelog | 6 ++++++
 .../apache-arrow-release/yum/apache-arrow-release.spec.in   | 3 +++
 dev/tasks/linux-packages/apache-arrow/debian/changelog      | 6 ++++++
 dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in     | 3 +++
 4 files changed, 18 insertions(+)

diff --git a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
index 597a2d4d3b43a..221fb0caa8952 100644
--- a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
@@ -1,3 +1,9 @@
+apache-arrow-apt-source (14.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
+
 apache-arrow-apt-source (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
index 79cb46006d074..273bf32a2a8e4 100644
--- a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
@@ -102,6 +102,9 @@ else
 fi
 
 %changelog
+* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
+- New upstream release.
+
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/changelog b/dev/tasks/linux-packages/apache-arrow/debian/changelog
index 525ae9cae02a0..5e01d962c44d4 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow/debian/changelog
@@ -1,3 +1,9 @@
+apache-arrow (14.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
+
 apache-arrow (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 4691f9e5439da..f61d47db2edd7 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -864,6 +864,9 @@ Documentation for Apache Parquet GLib.
 %{_datadir}/gtk-doc/html/parquet-glib/
 
 %changelog
+* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
+- New upstream release.
+
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 

From 87a1852d3578ecdf23e776e65bf30f0ee1f2362f Mon Sep 17 00:00:00 2001
From: Ivan Chesnov <ivan.chesnov@dremio.com>
Date: Wed, 1 Nov 2023 20:24:48 +0200
Subject: [PATCH 662/749] GH-38511: [Java] Add getTransferPair(Field,
 BufferAllocator, CallBack) for StructVector and MapVector (#38512)

### Rationale for this change
Missed impl of getTransferPair(Field, BufferAllocator, CallBack) for StructVector and MapVector

### What changes are included in this PR?

### Are these changes tested?
yes, added unit test.

### Are there any user-facing changes?

* Closes: #38511

Authored-by: Ivan Chesnov <ivan.chesnov@dremio.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/vector/complex/MapVector.java       |  5 ++++
 .../arrow/vector/complex/StructVector.java    |  9 ++++++++
 .../apache/arrow/vector/TestMapVector.java    | 23 +++++++++++++++++++
 .../apache/arrow/vector/TestStructVector.java | 12 ++++++++++
 4 files changed, 49 insertions(+)

diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
index c1913574bab19..e082b2f43be64 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/MapVector.java
@@ -146,6 +146,11 @@ public TransferPair getTransferPair(String ref, BufferAllocator allocator, CallB
     return new TransferImpl(ref, allocator, callBack);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new TransferImpl(field, allocator, callBack);
+  }
+
   @Override
   public TransferPair makeTransferPair(ValueVector target) {
     return new MapVector.TransferImpl((MapVector) target);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
index d947249fd3cdd..d0304a6fd2504 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java
@@ -246,6 +246,15 @@ public TransferPair getTransferPair(Field field, BufferAllocator allocator) {
         allowConflictPolicyChanges), false);
   }
 
+  @Override
+  public TransferPair getTransferPair(Field field, BufferAllocator allocator, CallBack callBack) {
+    return new NullableStructTransferPair(this, new StructVector(field,
+        allocator,
+        callBack,
+        getConflictPolicy(),
+        allowConflictPolicyChanges), false);
+  }
+
   /**
    * {@link TransferPair} for this (nullable) {@link StructVector}.
    */
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
index 5c8fd55ec98dc..1db55198e4bb3 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestMapVector.java
@@ -1155,4 +1155,27 @@ public void testGetTransferPairWithField() {
       toVector.clear();
     }
   }
+
+  @Test
+  public void testGetTransferPairWithFieldAndCallBack() {
+    SchemaChangeCallBack callBack = new SchemaChangeCallBack();
+    try (MapVector mapVector = MapVector.empty("mapVector", allocator, false)) {
+
+      FieldType type = new FieldType(false, ArrowType.Struct.INSTANCE, null, null);
+      AddOrGetResult<StructVector> addResult = mapVector.addOrGetVector(type);
+      FieldType keyType = new FieldType(false, MinorType.BIGINT.getType(), null, null);
+      FieldType valueType = FieldType.nullable(MinorType.FLOAT8.getType());
+      addResult.getVector().addOrGet(MapVector.KEY_NAME, keyType, BigIntVector.class);
+      addResult.getVector().addOrGet(MapVector.VALUE_NAME, valueType, Float8Vector.class);
+      mapVector.allocateNew();
+      mapVector.setValueCount(0);
+
+      assertEquals(-1, mapVector.getLastSet());
+      TransferPair tp = mapVector.getTransferPair(mapVector.getField(), allocator, callBack);
+      tp.transfer();
+      MapVector toVector = (MapVector) tp.getTo();
+      assertSame(toVector.getField(), mapVector.getField());
+      toVector.clear();
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
index ee34f203b6320..68f5e14dabb9b 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestStructVector.java
@@ -307,6 +307,18 @@ public void testGetTransferPair() {
     }
   }
 
+  @Test
+  public void testGetTransferPairWithFieldAndCallBack() {
+    SchemaChangeCallBack callBack = new SchemaChangeCallBack();
+    try (final StructVector fromVector = simpleStructVector("s1", allocator)) {
+      TransferPair tp = fromVector.getTransferPair(fromVector.getField(), allocator, callBack);
+      final StructVector toVector = (StructVector) tp.getTo();
+      // Field inside a new vector created by reusing a field should be the same in memory as the original field.
+      assertSame(toVector.getField(), fromVector.getField());
+      toVector.clear();
+    }
+  }
+
   private StructVector simpleStructVector(String name, BufferAllocator allocator) {
     final String INT_COL = "struct_int_child";
     final String FLT_COL = "struct_flt_child";

From c6e62f1fb54aecc1f240e7c8c3d2036279dab822 Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Thu, 2 Nov 2023 09:19:32 +0900
Subject: [PATCH 663/749] MINOR: [C++][FlightRPC] Add missing app_metadata
 arguments (#38548)

### Rationale for this change

This issue was discovered in the #38210 issue. It is reproduced on Mac with ARM Architecture CPU (**M1**). If the argument for `app_metadata` is not explicitly added, the build fails.

### What changes are included in this PR?

* Added the argument for `app_metadata` explicitly

### Are these changes tested?

Yes (Build)

### Are there any user-facing changes?

No

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 cpp/src/arrow/flight/perf_server.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/flight/perf_server.cc b/cpp/src/arrow/flight/perf_server.cc
index 40f6cbcbf0d82..87676da11213d 100644
--- a/cpp/src/arrow/flight/perf_server.cc
+++ b/cpp/src/arrow/flight/perf_server.cc
@@ -189,7 +189,7 @@ class FlightPerfServer : public FlightServerBase {
       (void)token.SerializeToString(&tmp_ticket.ticket);
 
       // All endpoints same location for now
-      endpoints.push_back(FlightEndpoint{tmp_ticket, {location_}, std::nullopt});
+      endpoints.push_back(FlightEndpoint{tmp_ticket, {location_}, std::nullopt, ""});
     }
 
     uint64_t total_records =

From fe9030272c4b7ecdc832ab720c137f75e88ade0f Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Wed, 1 Nov 2023 23:02:34 -0400
Subject: [PATCH 664/749] MINOR: [Docs][Python] Fix typo on pycapsule and ipc
 docs (#38550)

### Rationale for this change

`_export_from_c` was a typo and it should be `_export_to_c`.

### Are these changes tested?

No.

### Are there any user-facing changes?

Docs changes.

Authored-by: Bryce Mecum <petridish@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/format/CDataInterface/PyCapsuleInterface.rst | 2 +-
 python/pyarrow/ipc.pxi                                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/source/format/CDataInterface/PyCapsuleInterface.rst b/docs/source/format/CDataInterface/PyCapsuleInterface.rst
index 263c428c1ef0e..0c1a01d7c6778 100644
--- a/docs/source/format/CDataInterface/PyCapsuleInterface.rst
+++ b/docs/source/format/CDataInterface/PyCapsuleInterface.rst
@@ -30,7 +30,7 @@ The :ref:`C data interface <c-data-interface>` and
 different implementations of Arrow. However, these interfaces don't specify how
 Python libraries should expose these structs to other libraries. Prior to this,
 many libraries simply provided export to PyArrow data structures, using the
-``_import_from_c`` and ``_export_from_c`` methods. However, this always required
+``_import_from_c`` and ``_export_to_c`` methods. However, this always required
 PyArrow to be installed. In addition, those APIs could cause memory leaks if
 handled improperly.
 
diff --git a/python/pyarrow/ipc.pxi b/python/pyarrow/ipc.pxi
index deb3bb728aea9..fcb9eb729ef04 100644
--- a/python/pyarrow/ipc.pxi
+++ b/python/pyarrow/ipc.pxi
@@ -632,7 +632,7 @@ cdef class RecordBatchReader(_Weakrefable):
     Notes
     -----
     To import and export using the Arrow C stream interface, use the
-    ``_import_from_c`` and ``_export_from_c`` methods. However, keep in mind this
+    ``_import_from_c`` and ``_export_to_c`` methods. However, keep in mind this
     interface is intended for expert users.
 
     Examples

From ff762a5878603a0cca3d1498d5f8895078ffbb0a Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 2 Nov 2023 15:34:26 +0900
Subject: [PATCH 665/749] GH-38339: [C++][CMake] Use transitive dependency for
 system GoogleTest (#38340)

### Rationale for this change

Our bundled GoogleTest has transitive dependency. So we can omit explicit `GTest::gtest` linking because `GTest::gtest_main`/`GTest::gmock` has transitive dependency.

But GoogleTest related targets found by CMake's `FindGTest.cmake` don't have transitive dependency. So our code base needs to link `GTest::gtest` explicitly.

We can remove needless links by setting transitive dependency to GoogleTest related targets found by CMake's `FindGTest.cmake`.

### What changes are included in this PR?

* Set transitive dependencies to `GTest::gtest_main` and `GTest::gmock`
* Remove needless links

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38339

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/cpp_test.sh                        |  2 +-
 cpp/CMakeLists.txt                            |  6 +--
 cpp/cmake_modules/FindGTestAlt.cmake          |  3 ++
 cpp/src/arrow/acero/CMakeLists.txt            |  3 +-
 cpp/src/arrow/adapters/orc/CMakeLists.txt     | 10 ++---
 cpp/src/arrow/compute/CMakeLists.txt          |  4 +-
 cpp/src/arrow/compute/kernels/CMakeLists.txt  |  3 +-
 cpp/src/arrow/dataset/CMakeLists.txt          |  3 +-
 cpp/src/arrow/filesystem/CMakeLists.txt       |  2 +-
 cpp/src/arrow/flight/CMakeLists.txt           |  1 -
 .../flight/integration_tests/CMakeLists.txt   |  7 +---
 cpp/src/arrow/gpu/CMakeLists.txt              |  9 +++--
 cpp/src/parquet/CMakeLists.txt                | 37 ++++++++-----------
 13 files changed, 38 insertions(+), 52 deletions(-)

diff --git a/ci/scripts/cpp_test.sh b/ci/scripts/cpp_test.sh
index 3acf56bae0fe4..0c6e1c6ef7057 100755
--- a/ci/scripts/cpp_test.sh
+++ b/ci/scripts/cpp_test.sh
@@ -86,7 +86,7 @@ ctest \
     --parallel ${n_jobs} \
     --timeout ${ARROW_CTEST_TIMEOUT:-300} \
     "${ctest_options[@]}" \
-    $@
+    "$@"
 
 if [ "${ARROW_BUILD_EXAMPLES}" == "ON" ]; then
     examples=$(find ${binary_output_dir} -executable -name "*example")
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index 524a9bebf7fa2..bcb298407bd8b 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -889,8 +889,8 @@ if(NOT MSVC_TOOLCHAIN)
   list(APPEND ARROW_SHARED_LINK_LIBS ${CMAKE_DL_LIBS})
 endif()
 
-set(ARROW_TEST_LINK_TOOLCHAIN arrow::flatbuffers ${ARROW_GTEST_GTEST_MAIN}
-                              ${ARROW_GTEST_GTEST} ${ARROW_GTEST_GMOCK})
+set(ARROW_TEST_LINK_TOOLCHAIN arrow::flatbuffers ${ARROW_GTEST_GMOCK}
+                              ${ARROW_GTEST_GTEST_MAIN})
 
 if(ARROW_BUILD_TESTS)
   add_dependencies(arrow_test_dependencies ${ARROW_TEST_LINK_TOOLCHAIN})
@@ -909,7 +909,7 @@ set(ARROW_TEST_SHARED_LINK_LIBS arrow_testing_shared arrow_shared
                                 ${ARROW_SHARED_LINK_LIBS} ${ARROW_TEST_LINK_TOOLCHAIN})
 
 if(NOT MSVC)
-  set(ARROW_TEST_SHARED_LINK_LIBS ${ARROW_TEST_SHARED_LINK_LIBS} ${CMAKE_DL_LIBS})
+  list(APPEND ARROW_TEST_SHARED_LINK_LIBS ${CMAKE_DL_LIBS})
 endif()
 
 if("${ARROW_TEST_LINKAGE}" STREQUAL "shared")
diff --git a/cpp/cmake_modules/FindGTestAlt.cmake b/cpp/cmake_modules/FindGTestAlt.cmake
index 77d4f39d9e0bf..d1873d138e6c7 100644
--- a/cpp/cmake_modules/FindGTestAlt.cmake
+++ b/cpp/cmake_modules/FindGTestAlt.cmake
@@ -63,4 +63,7 @@ TEST(CXX_STANDARD, MatcherStringView) {
     find_package_handle_standard_args(GTestAlt
                                       REQUIRED_VARS GTestAlt_CXX_STANDARD_AVAILABLE)
   endif()
+
+  target_link_libraries(GTest::gmock INTERFACE GTest::gtest)
+  target_link_libraries(GTest::gtest_main INTERFACE GTest::gtest)
 endif()
diff --git a/cpp/src/arrow/acero/CMakeLists.txt b/cpp/src/arrow/acero/CMakeLists.txt
index 44fbb26f0814d..153413b33cab5 100644
--- a/cpp/src/arrow/acero/CMakeLists.txt
+++ b/cpp/src/arrow/acero/CMakeLists.txt
@@ -123,8 +123,7 @@ if(ARROW_TESTING)
   add_library(arrow_acero_testing OBJECT test_util_internal.cc)
   # Even though this is still just an object library we still need to "link" our
   # dependencies so that include paths are configured correctly
-  target_link_libraries(arrow_acero_testing ${ARROW_ACERO_TEST_LINK_LIBS})
-  target_link_libraries(arrow_acero_testing ${ARROW_GTEST_GTEST})
+  target_link_libraries(arrow_acero_testing PRIVATE ${ARROW_ACERO_TEST_LINK_LIBS})
   list(APPEND ARROW_ACERO_TEST_LINK_LIBS arrow_acero_testing)
 endif()
 
diff --git a/cpp/src/arrow/adapters/orc/CMakeLists.txt b/cpp/src/arrow/adapters/orc/CMakeLists.txt
index 44719379994d9..4d66151cd38c9 100644
--- a/cpp/src/arrow/adapters/orc/CMakeLists.txt
+++ b/cpp/src/arrow/adapters/orc/CMakeLists.txt
@@ -27,19 +27,15 @@ install(FILES adapter.h options.h
 arrow_add_pkg_config("arrow-orc")
 
 if(ARROW_BUILD_STATIC)
-  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_static arrow_static)
+  set(ARROW_ORC_STATIC_LINK_LIBS ${ARROW_TEST_STATIC_LINK_LIBS})
 else()
-  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
+  set(ARROW_ORC_STATIC_LINK_LIBS ${ARROW_TEST_SHARED_LINK_LIBS})
 endif()
-
-set(ORC_STATIC_TEST_LINK_LIBS orc::orc ${ARROW_LIBRARIES_FOR_STATIC_TESTS}
-                              ${ARROW_GTEST_GTEST_MAIN} ${ARROW_GTEST_GTEST})
-
 add_arrow_test(adapter_test
                PREFIX
                "arrow-orc"
                STATIC_LINK_LIBS
-               ${ORC_STATIC_TEST_LINK_LIBS})
+               ${ARROW_ORC_STATIC_LINK_LIBS})
 
 set_source_files_properties(adapter_test.cc PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                                        SKIP_UNITY_BUILD_INCLUSION ON)
diff --git a/cpp/src/arrow/compute/CMakeLists.txt b/cpp/src/arrow/compute/CMakeLists.txt
index 001424dd42072..1134e0a98ae45 100644
--- a/cpp/src/arrow/compute/CMakeLists.txt
+++ b/cpp/src/arrow/compute/CMakeLists.txt
@@ -89,9 +89,7 @@ add_arrow_test(internals_test
                kernel_test.cc
                light_array_test.cc
                registry_test.cc
-               key_hash_test.cc
-               EXTRA_LINK_LIBS
-               ${ARROW_GTEST_GMOCK})
+               key_hash_test.cc)
 
 add_arrow_compute_test(expression_test SOURCES expression_test.cc)
 
diff --git a/cpp/src/arrow/compute/kernels/CMakeLists.txt b/cpp/src/arrow/compute/kernels/CMakeLists.txt
index 78743050625a4..4350cd57ff026 100644
--- a/cpp/src/arrow/compute/kernels/CMakeLists.txt
+++ b/cpp/src/arrow/compute/kernels/CMakeLists.txt
@@ -23,8 +23,7 @@ if(ARROW_TESTING)
   add_library(arrow_compute_kernels_testing OBJECT test_util.cc)
   # Even though this is still just an object library we still need to "link" our
   # dependencies so that include paths are configured correctly
-  target_link_libraries(arrow_compute_kernels_testing ${ARROW_GTEST_GTEST}
-                        ${ARROW_GTEST_GMOCK})
+  target_link_libraries(arrow_compute_kernels_testing PRIVATE ${ARROW_GTEST_GMOCK})
 endif()
 
 add_arrow_test(scalar_cast_test
diff --git a/cpp/src/arrow/dataset/CMakeLists.txt b/cpp/src/arrow/dataset/CMakeLists.txt
index eb8fb54803aa9..1afef3e3b0463 100644
--- a/cpp/src/arrow/dataset/CMakeLists.txt
+++ b/cpp/src/arrow/dataset/CMakeLists.txt
@@ -113,8 +113,7 @@ if(ARROW_TESTING)
   add_library(arrow_dataset_testing OBJECT test_util_internal.cc)
   # Even though this is still just an object library we still need to "link" our
   # dependencies so that include paths are configured correctly
-  target_link_libraries(arrow_dataset_testing ${ARROW_DATASET_TEST_LINK_LIBS})
-  target_link_libraries(arrow_dataset_testing ${ARROW_GTEST_GTEST})
+  target_link_libraries(arrow_dataset_testing PRIVATE ${ARROW_DATASET_TEST_LINK_LIBS})
   list(APPEND ARROW_DATASET_TEST_LINK_LIBS arrow_dataset_testing)
 endif()
 
diff --git a/cpp/src/arrow/filesystem/CMakeLists.txt b/cpp/src/arrow/filesystem/CMakeLists.txt
index b997ca0a387a6..a42a8d0f8c1b6 100644
--- a/cpp/src/arrow/filesystem/CMakeLists.txt
+++ b/cpp/src/arrow/filesystem/CMakeLists.txt
@@ -90,7 +90,7 @@ if(ARROW_S3)
   if(ARROW_BUILD_TESTS)
     add_executable(arrow-s3fs-narrative-test s3fs_narrative_test.cc)
     target_link_libraries(arrow-s3fs-narrative-test ${ARROW_TEST_LINK_LIBS}
-                          ${GFLAGS_LIBRARIES} ${ARROW_GTEST_GTEST})
+                          ${GFLAGS_LIBRARIES})
     add_dependencies(arrow-tests arrow-s3fs-narrative-test)
   endif()
 
diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt
index c37d2c56700e0..91e0fbf9136d3 100644
--- a/cpp/src/arrow/flight/CMakeLists.txt
+++ b/cpp/src/arrow/flight/CMakeLists.txt
@@ -67,7 +67,6 @@ list(APPEND
      Boost::headers
      Boost::filesystem
      Boost::system
-     ${ARROW_GTEST_GTEST}
      ${ARROW_GTEST_GMOCK})
 list(APPEND ARROW_FLIGHT_TEST_LINK_LIBS gRPC::grpc++)
 
diff --git a/cpp/src/arrow/flight/integration_tests/CMakeLists.txt b/cpp/src/arrow/flight/integration_tests/CMakeLists.txt
index 98a7a2a7af386..7ac314531ff4d 100644
--- a/cpp/src/arrow/flight/integration_tests/CMakeLists.txt
+++ b/cpp/src/arrow/flight/integration_tests/CMakeLists.txt
@@ -22,11 +22,8 @@ if(ARROW_FLIGHT_TEST_LINKAGE STREQUAL "static" AND ARROW_BUILD_STATIC)
 else()
   set(ARROW_FLIGHT_INTEGRATION_TEST_LINK_LIBS arrow_flight_sql_shared)
 endif()
-list(APPEND
-     ARROW_FLIGHT_INTEGRATION_TEST_LINK_LIBS
-     ${ARROW_FLIGHT_TEST_LINK_LIBS}
-     ${GFLAGS_LIBRARIES}
-     ${ARROW_GTEST_GTEST})
+list(APPEND ARROW_FLIGHT_INTEGRATION_TEST_LINK_LIBS ${ARROW_FLIGHT_TEST_LINK_LIBS}
+     ${GFLAGS_LIBRARIES})
 
 add_executable(flight-test-integration-server test_integration_server.cc
                                               test_integration.cc)
diff --git a/cpp/src/arrow/gpu/CMakeLists.txt b/cpp/src/arrow/gpu/CMakeLists.txt
index a5b176793e495..7238a0e0b7c9b 100644
--- a/cpp/src/arrow/gpu/CMakeLists.txt
+++ b/cpp/src/arrow/gpu/CMakeLists.txt
@@ -100,9 +100,10 @@ if(ARROW_BUILD_TESTS)
 endif()
 
 if(ARROW_BUILD_BENCHMARKS)
-  add_arrow_benchmark(cuda_benchmark PREFIX "arrow-gpu")
-  target_link_libraries(arrow-gpu-cuda-benchmark
-                        PUBLIC ${ARROW_CUDA_LIBRARY} ${ARROW_GTEST_GTEST}
-                               ${ARROW_BENCHMARK_LINK_LIBS})
+  add_arrow_benchmark(cuda_benchmark
+                      PREFIX
+                      "arrow-gpu"
+                      EXTRA_LINK_LIBS
+                      ${ARROW_CUDA_LIBRARY})
   add_dependencies(arrow_cuda-benchmarks arrow-gpu-cuda-benchmark)
 endif()
diff --git a/cpp/src/parquet/CMakeLists.txt b/cpp/src/parquet/CMakeLists.txt
index 0d04ec3e306e5..04028431ba157 100644
--- a/cpp/src/parquet/CMakeLists.txt
+++ b/cpp/src/parquet/CMakeLists.txt
@@ -46,13 +46,15 @@ function(ADD_PARQUET_TEST REL_TEST_NAME)
   if(ARROW_TEST_LINKAGE STREQUAL "static")
     add_test_case(${REL_TEST_NAME}
                   STATIC_LINK_LIBS
-                  ${PARQUET_STATIC_TEST_LINK_LIBS}
+                  parquet_static
+                  ${PARQUET_TEST_LINK_LIBS}
                   ${TEST_ARGUMENTS}
                   ${ARG_UNPARSED_ARGUMENTS})
   else()
     add_test_case(${REL_TEST_NAME}
                   STATIC_LINK_LIBS
-                  ${PARQUET_SHARED_TEST_LINK_LIBS}
+                  parquet_shared
+                  ${PARQUET_TEST_LINK_LIBS}
                   ${TEST_ARGUMENTS}
                   ${ARG_UNPARSED_ARGUMENTS})
   endif()
@@ -118,28 +120,20 @@ endfunction()
 if(ARROW_BUILD_STATIC)
   set(PARQUET_STATIC_LINK_LIBS arrow_static ${ARROW_STATIC_LINK_LIBS})
   set(PARQUET_STATIC_INSTALL_INTERFACE_LIBS Arrow::arrow_static)
-  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_static arrow_static
-                                       ${ARROW_STATIC_LINK_LIBS})
 else()
   set(PARQUET_STATIC_INSTALL_INTERFACE_LIBS)
-  set(ARROW_LIBRARIES_FOR_STATIC_TESTS arrow_testing_shared arrow_shared)
 endif()
 
-set(PARQUET_MIN_TEST_LIBS ${ARROW_GTEST_GMOCK} ${ARROW_GTEST_GTEST}
-                          ${ARROW_GTEST_GTEST_MAIN} Boost::headers)
-
+set(PARQUET_TEST_LINK_LIBS ${ARROW_TEST_LINK_LIBS} thrift::thrift Boost::headers)
 if(APPLE)
-  list(APPEND PARQUET_MIN_TEST_LIBS ${CMAKE_DL_LIBS})
+  list(APPEND PARQUET_TEST_LINK_LIBS ${CMAKE_DL_LIBS})
 elseif(NOT MSVC)
-  list(APPEND PARQUET_MIN_TEST_LIBS pthread ${CMAKE_DL_LIBS})
+  if(ARROW_ENABLE_THREADING)
+    list(APPEND PARQUET_TEST_LINK_LIBS Threads::Threads)
+  endif()
+  list(APPEND PARQUET_TEST_LINK_LIBS ${CMAKE_DL_LIBS})
 endif()
 
-set(PARQUET_SHARED_TEST_LINK_LIBS arrow_testing_shared ${PARQUET_MIN_TEST_LIBS}
-                                  parquet_shared thrift::thrift)
-
-set(PARQUET_STATIC_TEST_LINK_LIBS ${PARQUET_MIN_TEST_LIBS} parquet_static thrift::thrift
-                                  ${ARROW_LIBRARIES_FOR_STATIC_TESTS})
-
 #
 # Generated Thrift sources
 set(PARQUET_THRIFT_SOURCE_DIR "${ARROW_SOURCE_DIR}/src/generated/")
@@ -302,15 +296,16 @@ if(WIN32 AND NOT (ARROW_TEST_LINKAGE STREQUAL "static"))
               "${PARQUET_THRIFT_SOURCE_DIR}/parquet_constants.cpp"
               "${PARQUET_THRIFT_SOURCE_DIR}/parquet_types.cpp")
   target_link_libraries(parquet_test_support thrift::thrift)
-  set(PARQUET_SHARED_TEST_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS} parquet_test_support)
-  set(PARQUET_LIBRARIES ${PARQUET_LIBRARIES} parquet_test_support)
+  list(PREPEND PARQUET_TEST_LINK_LIBS parquet_test_support)
+  list(APPEND PARQUET_LIBRARIES parquet_test_support)
 endif()
 
 if(NOT ARROW_BUILD_SHARED)
-  set(PARQUET_BENCHMARK_LINK_OPTION STATIC_LINK_LIBS benchmark::benchmark_main
-                                    ${PARQUET_STATIC_TEST_LINK_LIBS})
+  set(PARQUET_BENCHMARK_LINK_OPTION STATIC_LINK_LIBS parquet_static
+                                    ${PARQUET_TEST_LINK_LIBS} benchmark::benchmark_main)
 else()
-  set(PARQUET_BENCHMARK_LINK_OPTION EXTRA_LINK_LIBS ${PARQUET_SHARED_TEST_LINK_LIBS})
+  set(PARQUET_BENCHMARK_LINK_OPTION EXTRA_LINK_LIBS parquet_shared
+                                    ${PARQUET_TEST_LINK_LIBS})
 endif()
 
 if(ARROW_BUILD_STATIC AND WIN32)

From cead3dd3f024a16f5b23dd6a82069a3190967ec4 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Thu, 2 Nov 2023 15:35:24 +0900
Subject: [PATCH 666/749] GH-37429: [C++] Add
 arrow::ipc::StreamDecoder::Reset() (#37970)

### Rationale for this change

We can reuse the same StreamDecoder to read multiple streams with this.

### What changes are included in this PR?

Add StreamDecoder::Reset().

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #37429

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/ipc/read_write_test.cc | 37 +++++++++++++
 cpp/src/arrow/ipc/reader.cc          | 79 ++++++++++++++++++++++++++--
 cpp/src/arrow/ipc/reader.h           |  8 +++
 3 files changed, 120 insertions(+), 4 deletions(-)

diff --git a/cpp/src/arrow/ipc/read_write_test.cc b/cpp/src/arrow/ipc/read_write_test.cc
index 05a48aec2c7f3..313346b5deced 100644
--- a/cpp/src/arrow/ipc/read_write_test.cc
+++ b/cpp/src/arrow/ipc/read_write_test.cc
@@ -2164,6 +2164,43 @@ TEST(TestRecordBatchStreamReader, MalformedInput) {
   ASSERT_RAISES(Invalid, RecordBatchStreamReader::Open(&garbage_reader));
 }
 
+namespace {
+class EndlessCollectListener : public CollectListener {
+ public:
+  EndlessCollectListener() : CollectListener(), decoder_(nullptr) {}
+
+  void SetDecoder(StreamDecoder* decoder) { decoder_ = decoder; }
+
+  arrow::Status OnEOS() override { return decoder_->Reset(); }
+
+ private:
+  StreamDecoder* decoder_;
+};
+};  // namespace
+
+TEST(TestStreamDecoder, Reset) {
+  auto listener = std::make_shared<EndlessCollectListener>();
+  StreamDecoder decoder(listener);
+  listener->SetDecoder(&decoder);
+
+  std::shared_ptr<RecordBatch> batch;
+  ASSERT_OK(MakeIntRecordBatch(&batch));
+  StreamWriterHelper writer_helper;
+  ASSERT_OK(writer_helper.Init(batch->schema(), IpcWriteOptions::Defaults()));
+  ASSERT_OK(writer_helper.WriteBatch(batch));
+  ASSERT_OK(writer_helper.Finish());
+
+  ASSERT_OK_AND_ASSIGN(auto all_buffer, ConcatenateBuffers({writer_helper.buffer_,
+                                                            writer_helper.buffer_}));
+  // Consume by Buffer
+  ASSERT_OK(decoder.Consume(all_buffer));
+  ASSERT_EQ(2, listener->num_record_batches());
+
+  // Consume by raw data
+  ASSERT_OK(decoder.Consume(all_buffer->data(), all_buffer->size()));
+  ASSERT_EQ(4, listener->num_record_batches());
+}
+
 TEST(TestStreamDecoder, NextRequiredSize) {
   auto listener = std::make_shared<CollectListener>();
   StreamDecoder decoder(listener);
diff --git a/cpp/src/arrow/ipc/reader.cc b/cpp/src/arrow/ipc/reader.cc
index d603062d81d4a..5dd01f2015dd7 100644
--- a/cpp/src/arrow/ipc/reader.cc
+++ b/cpp/src/arrow/ipc/reader.cc
@@ -932,14 +932,18 @@ class StreamDecoderInternal : public MessageDecoderListener {
     return listener_->OnEOS();
   }
 
+  std::shared_ptr<Listener> listener() const { return listener_; }
+
   Listener* raw_listener() const { return listener_.get(); }
 
+  IpcReadOptions options() const { return options_; }
+
+  State state() const { return state_; }
+
   std::shared_ptr<Schema> schema() const { return filtered_schema_; }
 
   ReadStats stats() const { return stats_; }
 
-  State state() const { return state_; }
-
   int num_required_initial_dictionaries() const {
     return num_required_initial_dictionaries_;
   }
@@ -2039,6 +2043,8 @@ class StreamDecoder::StreamDecoderImpl : public StreamDecoderInternal {
 
   int64_t next_required_size() const { return message_decoder_.next_required_size(); }
 
+  const MessageDecoder* message_decoder() const { return &message_decoder_; }
+
  private:
   MessageDecoder message_decoder_;
 };
@@ -2050,10 +2056,75 @@ StreamDecoder::StreamDecoder(std::shared_ptr<Listener> listener, IpcReadOptions
 StreamDecoder::~StreamDecoder() {}
 
 Status StreamDecoder::Consume(const uint8_t* data, int64_t size) {
-  return impl_->Consume(data, size);
+  while (size > 0) {
+    const auto next_required_size = impl_->next_required_size();
+    if (next_required_size == 0) {
+      break;
+    }
+    if (size < next_required_size) {
+      break;
+    }
+    ARROW_RETURN_NOT_OK(impl_->Consume(data, next_required_size));
+    data += next_required_size;
+    size -= next_required_size;
+  }
+  if (size > 0) {
+    return impl_->Consume(data, size);
+  } else {
+    return arrow::Status::OK();
+  }
 }
+
 Status StreamDecoder::Consume(std::shared_ptr<Buffer> buffer) {
-  return impl_->Consume(std::move(buffer));
+  if (buffer->size() == 0) {
+    return arrow::Status::OK();
+  }
+  if (impl_->next_required_size() == 0 || buffer->size() <= impl_->next_required_size()) {
+    return impl_->Consume(std::move(buffer));
+  } else {
+    int64_t offset = 0;
+    while (true) {
+      const auto next_required_size = impl_->next_required_size();
+      if (next_required_size == 0) {
+        break;
+      }
+      if (buffer->size() - offset <= next_required_size) {
+        break;
+      }
+      if (buffer->is_cpu()) {
+        switch (impl_->message_decoder()->state()) {
+          case MessageDecoder::State::INITIAL:
+          case MessageDecoder::State::METADATA_LENGTH:
+            // We don't need to pass a sliced buffer because
+            // MessageDecoder doesn't keep reference of the given
+            // buffer on these states.
+            ARROW_RETURN_NOT_OK(
+                impl_->Consume(buffer->data() + offset, next_required_size));
+            break;
+          default:
+            ARROW_RETURN_NOT_OK(
+                impl_->Consume(SliceBuffer(buffer, offset, next_required_size)));
+            break;
+        }
+      } else {
+        ARROW_RETURN_NOT_OK(
+            impl_->Consume(SliceBuffer(buffer, offset, next_required_size)));
+      }
+      offset += next_required_size;
+    }
+    if (buffer->size() - offset == 0) {
+      return arrow::Status::OK();
+    } else if (offset == 0) {
+      return impl_->Consume(std::move(buffer));
+    } else {
+      return impl_->Consume(SliceBuffer(std::move(buffer), offset));
+    }
+  }
+}
+
+Status StreamDecoder::Reset() {
+  impl_ = std::make_unique<StreamDecoderImpl>(impl_->listener(), impl_->options());
+  return Status::OK();
 }
 
 std::shared_ptr<Schema> StreamDecoder::schema() const { return impl_->schema(); }
diff --git a/cpp/src/arrow/ipc/reader.h b/cpp/src/arrow/ipc/reader.h
index 0d7ae22264052..de4606094049c 100644
--- a/cpp/src/arrow/ipc/reader.h
+++ b/cpp/src/arrow/ipc/reader.h
@@ -425,6 +425,14 @@ class ARROW_EXPORT StreamDecoder {
   /// \return Status
   Status Consume(std::shared_ptr<Buffer> buffer);
 
+  /// \brief Reset the internal status.
+  ///
+  /// You can reuse this decoder for new stream after calling
+  /// this.
+  ///
+  /// \return Status
+  Status Reset();
+
   /// \return the shared schema of the record batches in the stream
   std::shared_ptr<Schema> schema() const;
 

From 728185119b1d21860d0803752f92d17a6b92b443 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 2 Nov 2023 10:07:06 +0100
Subject: [PATCH 667/749] GH-38542: [C++][Parquet] Faster scalar
 BYTE_STREAM_SPLIT (#38529)

### Rationale for this change

BYTE_STREAM_SPLIT encoding and decoding benefit from SIMD accelerations on x86, but scalar implementations are used otherwise.

### What changes are included in this PR?

Improve the speed of scalar implementations of BYTE_STREAM_SPLIT by using a blocked algorithm.

Benchmark numbers on the author's machine (AMD Ryzen 9 3900X):

* before:
```
-------------------------------------------------------------------------------------------------------
Benchmark                                             Time             CPU   Iterations UserCounters...
-------------------------------------------------------------------------------------------------------
BM_ByteStreamSplitDecode_Float_Scalar/1024         1374 ns         1374 ns       510396 bytes_per_second=2.77574G/s
BM_ByteStreamSplitDecode_Float_Scalar/4096         5483 ns         5483 ns       127498 bytes_per_second=2.78303G/s
BM_ByteStreamSplitDecode_Float_Scalar/32768       44042 ns        44035 ns        15905 bytes_per_second=2.77212G/s
BM_ByteStreamSplitDecode_Float_Scalar/65536       87966 ns        87952 ns         7962 bytes_per_second=2.77583G/s

BM_ByteStreamSplitDecode_Double_Scalar/1024        2583 ns         2583 ns       271436 bytes_per_second=2.95408G/s
BM_ByteStreamSplitDecode_Double_Scalar/4096       10533 ns        10532 ns        65695 bytes_per_second=2.89761G/s
BM_ByteStreamSplitDecode_Double_Scalar/32768      84067 ns        84053 ns         8275 bytes_per_second=2.90459G/s
BM_ByteStreamSplitDecode_Double_Scalar/65536     168332 ns       168309 ns         4155 bytes_per_second=2.9011G/s

BM_ByteStreamSplitEncode_Float_Scalar/1024         1435 ns         1435 ns       484278 bytes_per_second=2.65802G/s
BM_ByteStreamSplitEncode_Float_Scalar/4096         5725 ns         5725 ns       121877 bytes_per_second=2.66545G/s
BM_ByteStreamSplitEncode_Float_Scalar/32768       46291 ns        46283 ns        15134 bytes_per_second=2.63745G/s
BM_ByteStreamSplitEncode_Float_Scalar/65536       91139 ns        91128 ns         7707 bytes_per_second=2.6791G/s

BM_ByteStreamSplitEncode_Double_Scalar/1024        3093 ns         3093 ns       226198 bytes_per_second=2.46663G/s
BM_ByteStreamSplitEncode_Double_Scalar/4096       12724 ns        12722 ns        54522 bytes_per_second=2.39873G/s
BM_ByteStreamSplitEncode_Double_Scalar/32768     100488 ns       100475 ns         6957 bytes_per_second=2.42987G/s
BM_ByteStreamSplitEncode_Double_Scalar/65536     200885 ns       200852 ns         3486 bytes_per_second=2.43105G/s
```
* after:
```
-------------------------------------------------------------------------------------------------------
Benchmark                                             Time             CPU   Iterations UserCounters...
-------------------------------------------------------------------------------------------------------
BM_ByteStreamSplitDecode_Float_Scalar/1024          932 ns          932 ns       753352 bytes_per_second=4.09273G/s
BM_ByteStreamSplitDecode_Float_Scalar/4096         3715 ns         3715 ns       188394 bytes_per_second=4.10783G/s
BM_ByteStreamSplitDecode_Float_Scalar/32768       30167 ns        30162 ns        23441 bytes_per_second=4.04716G/s
BM_ByteStreamSplitDecode_Float_Scalar/65536       59483 ns        59475 ns        11744 bytes_per_second=4.10496G/s

BM_ByteStreamSplitDecode_Double_Scalar/1024        1862 ns         1862 ns       374715 bytes_per_second=4.09823G/s
BM_ByteStreamSplitDecode_Double_Scalar/4096        7554 ns         7553 ns        91975 bytes_per_second=4.04038G/s
BM_ByteStreamSplitDecode_Double_Scalar/32768      60429 ns        60421 ns        11499 bytes_per_second=4.04067G/s
BM_ByteStreamSplitDecode_Double_Scalar/65536     120992 ns       120972 ns         5756 bytes_per_second=4.03631G/s

BM_ByteStreamSplitEncode_Float_Scalar/1024          737 ns          737 ns       947423 bytes_per_second=5.17843G/s
BM_ByteStreamSplitEncode_Float_Scalar/4096         2934 ns         2933 ns       239459 bytes_per_second=5.20175G/s
BM_ByteStreamSplitEncode_Float_Scalar/32768       23730 ns        23727 ns        29243 bytes_per_second=5.14485G/s
BM_ByteStreamSplitEncode_Float_Scalar/65536       47671 ns        47664 ns        14682 bytes_per_second=5.12209G/s

BM_ByteStreamSplitEncode_Double_Scalar/1024        1517 ns         1517 ns       458928 bytes_per_second=5.02827G/s
BM_ByteStreamSplitEncode_Double_Scalar/4096        6224 ns         6223 ns       111361 bytes_per_second=4.90407G/s
BM_ByteStreamSplitEncode_Double_Scalar/32768      49719 ns        49713 ns        14059 bytes_per_second=4.91099G/s
BM_ByteStreamSplitEncode_Double_Scalar/65536      99445 ns        99432 ns         7027 bytes_per_second=4.91072G/s
```

### Are these changes tested?

Yes, though the scalar implementations are unfortunately only exercised on non-x86 by default (see added comment in the PR).

### Are there any user-facing changes?

No.

* Closes: #38542

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/util/CMakeLists.txt             |   1 +
 ...m_split.h => byte_stream_split_internal.h} | 148 ++++++++++++---
 cpp/src/arrow/util/byte_stream_split_test.cc  | 172 ++++++++++++++++++
 cpp/src/parquet/encoding.cc                   |   6 +-
 cpp/src/parquet/encoding_benchmark.cc         |   2 +-
 5 files changed, 298 insertions(+), 31 deletions(-)
 rename cpp/src/arrow/util/{byte_stream_split.h => byte_stream_split_internal.h} (84%)
 create mode 100644 cpp/src/arrow/util/byte_stream_split_test.cc

diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 3cecab3a633cc..3dc8eac1abf64 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -43,6 +43,7 @@ add_arrow_test(utility-test
                align_util_test.cc
                atfork_test.cc
                byte_size_test.cc
+               byte_stream_split_test.cc
                cache_test.cc
                checked_cast_test.cc
                compression_test.cc
diff --git a/cpp/src/arrow/util/byte_stream_split.h b/cpp/src/arrow/util/byte_stream_split_internal.h
similarity index 84%
rename from cpp/src/arrow/util/byte_stream_split.h
rename to cpp/src/arrow/util/byte_stream_split_internal.h
index d428df0659b28..ae85e2cfa81a3 100644
--- a/cpp/src/arrow/util/byte_stream_split.h
+++ b/cpp/src/arrow/util/byte_stream_split_internal.h
@@ -17,20 +17,24 @@
 
 #pragma once
 
+#include "arrow/util/endian.h"
 #include "arrow/util/simd.h"
 #include "arrow/util/ubsan.h"
 
-#include <stdint.h>
 #include <algorithm>
+#include <cassert>
+#include <cstdint>
 
 #ifdef ARROW_HAVE_SSE4_2
 // Enable the SIMD for ByteStreamSplit Encoder/Decoder
 #define ARROW_HAVE_SIMD_SPLIT
 #endif  // ARROW_HAVE_SSE4_2
 
-namespace arrow {
-namespace util {
-namespace internal {
+namespace arrow::util::internal {
+
+//
+// SIMD implementations
+//
 
 #if defined(ARROW_HAVE_SSE4_2)
 template <typename T>
@@ -565,48 +569,140 @@ void inline ByteStreamSplitDecodeSimd(const uint8_t* data, int64_t num_values,
 }
 
 template <typename T>
-void inline ByteStreamSplitEncodeSimd(const uint8_t* raw_values, const size_t num_values,
+void inline ByteStreamSplitEncodeSimd(const uint8_t* raw_values, const int64_t num_values,
                                       uint8_t* output_buffer_raw) {
 #if defined(ARROW_HAVE_AVX512)
-  return ByteStreamSplitEncodeAvx512<T>(raw_values, num_values, output_buffer_raw);
+  return ByteStreamSplitEncodeAvx512<T>(raw_values, static_cast<size_t>(num_values),
+                                        output_buffer_raw);
 #elif defined(ARROW_HAVE_AVX2)
-  return ByteStreamSplitEncodeAvx2<T>(raw_values, num_values, output_buffer_raw);
+  return ByteStreamSplitEncodeAvx2<T>(raw_values, static_cast<size_t>(num_values),
+                                      output_buffer_raw);
 #elif defined(ARROW_HAVE_SSE4_2)
-  return ByteStreamSplitEncodeSse2<T>(raw_values, num_values, output_buffer_raw);
+  return ByteStreamSplitEncodeSse2<T>(raw_values, static_cast<size_t>(num_values),
+                                      output_buffer_raw);
 #else
 #error "ByteStreamSplitEncodeSimd not implemented"
 #endif
 }
 #endif
 
+//
+// Scalar implementations
+//
+
+inline void DoSplitStreams(const uint8_t* src, int width, int64_t nvalues,
+                           uint8_t** dest_streams) {
+  // Value empirically chosen to provide the best performance on the author's machine
+  constexpr int kBlockSize = 32;
+
+  while (nvalues >= kBlockSize) {
+    for (int stream = 0; stream < width; ++stream) {
+      uint8_t* dest = dest_streams[stream];
+      for (int i = 0; i < kBlockSize; i += 8) {
+        uint64_t a = src[stream + i * width];
+        uint64_t b = src[stream + (i + 1) * width];
+        uint64_t c = src[stream + (i + 2) * width];
+        uint64_t d = src[stream + (i + 3) * width];
+        uint64_t e = src[stream + (i + 4) * width];
+        uint64_t f = src[stream + (i + 5) * width];
+        uint64_t g = src[stream + (i + 6) * width];
+        uint64_t h = src[stream + (i + 7) * width];
+#if ARROW_LITTLE_ENDIAN
+        uint64_t r = a | (b << 8) | (c << 16) | (d << 24) | (e << 32) | (f << 40) |
+                     (g << 48) | (h << 56);
+#else
+        uint64_t r = (a << 56) | (b << 48) | (c << 40) | (d << 32) | (e << 24) |
+                     (f << 16) | (g << 8) | h;
+#endif
+        arrow::util::SafeStore(&dest[i], r);
+      }
+      dest_streams[stream] += kBlockSize;
+    }
+    src += width * kBlockSize;
+    nvalues -= kBlockSize;
+  }
+
+  // Epilog
+  for (int stream = 0; stream < width; ++stream) {
+    uint8_t* dest = dest_streams[stream];
+    for (int64_t i = 0; i < nvalues; ++i) {
+      dest[i] = src[stream + i * width];
+    }
+  }
+}
+
+inline void DoMergeStreams(const uint8_t** src_streams, int width, int64_t nvalues,
+                           uint8_t* dest) {
+  // Value empirically chosen to provide the best performance on the author's machine
+  constexpr int kBlockSize = 128;
+
+  while (nvalues >= kBlockSize) {
+    for (int stream = 0; stream < width; ++stream) {
+      // Take kBlockSize bytes from the given stream and spread them
+      // to their logical places in destination.
+      const uint8_t* src = src_streams[stream];
+      for (int i = 0; i < kBlockSize; i += 8) {
+        uint64_t v = arrow::util::SafeLoadAs<uint64_t>(&src[i]);
+#if ARROW_LITTLE_ENDIAN
+        dest[stream + i * width] = static_cast<uint8_t>(v);
+        dest[stream + (i + 1) * width] = static_cast<uint8_t>(v >> 8);
+        dest[stream + (i + 2) * width] = static_cast<uint8_t>(v >> 16);
+        dest[stream + (i + 3) * width] = static_cast<uint8_t>(v >> 24);
+        dest[stream + (i + 4) * width] = static_cast<uint8_t>(v >> 32);
+        dest[stream + (i + 5) * width] = static_cast<uint8_t>(v >> 40);
+        dest[stream + (i + 6) * width] = static_cast<uint8_t>(v >> 48);
+        dest[stream + (i + 7) * width] = static_cast<uint8_t>(v >> 56);
+#else
+        dest[stream + i * width] = static_cast<uint8_t>(v >> 56);
+        dest[stream + (i + 1) * width] = static_cast<uint8_t>(v >> 48);
+        dest[stream + (i + 2) * width] = static_cast<uint8_t>(v >> 40);
+        dest[stream + (i + 3) * width] = static_cast<uint8_t>(v >> 32);
+        dest[stream + (i + 4) * width] = static_cast<uint8_t>(v >> 24);
+        dest[stream + (i + 5) * width] = static_cast<uint8_t>(v >> 16);
+        dest[stream + (i + 6) * width] = static_cast<uint8_t>(v >> 8);
+        dest[stream + (i + 7) * width] = static_cast<uint8_t>(v);
+#endif
+      }
+      src_streams[stream] += kBlockSize;
+    }
+    dest += width * kBlockSize;
+    nvalues -= kBlockSize;
+  }
+
+  // Epilog
+  for (int stream = 0; stream < width; ++stream) {
+    const uint8_t* src = src_streams[stream];
+    for (int64_t i = 0; i < nvalues; ++i) {
+      dest[stream + i * width] = src[i];
+    }
+  }
+}
+
 template <typename T>
-void ByteStreamSplitEncodeScalar(const uint8_t* raw_values, const size_t num_values,
+void ByteStreamSplitEncodeScalar(const uint8_t* raw_values, const int64_t num_values,
                                  uint8_t* output_buffer_raw) {
-  constexpr size_t kNumStreams = sizeof(T);
-  for (size_t i = 0U; i < num_values; ++i) {
-    for (size_t j = 0U; j < kNumStreams; ++j) {
-      const uint8_t byte_in_value = raw_values[i * kNumStreams + j];
-      output_buffer_raw[j * num_values + i] = byte_in_value;
-    }
+  constexpr int kNumStreams = static_cast<int>(sizeof(T));
+  std::array<uint8_t*, kNumStreams> dest_streams;
+  for (int stream = 0; stream < kNumStreams; ++stream) {
+    dest_streams[stream] = &output_buffer_raw[stream * num_values];
   }
+  DoSplitStreams(raw_values, kNumStreams, num_values, dest_streams.data());
 }
 
 template <typename T>
 void ByteStreamSplitDecodeScalar(const uint8_t* data, int64_t num_values, int64_t stride,
                                  T* out) {
-  constexpr size_t kNumStreams = sizeof(T);
-  auto output_buffer_raw = reinterpret_cast<uint8_t*>(out);
-
-  for (int64_t i = 0; i < num_values; ++i) {
-    for (size_t b = 0; b < kNumStreams; ++b) {
-      const size_t byte_index = b * stride + i;
-      output_buffer_raw[i * kNumStreams + b] = data[byte_index];
-    }
+  constexpr int kNumStreams = static_cast<int>(sizeof(T));
+  std::array<const uint8_t*, kNumStreams> src_streams;
+  for (int stream = 0; stream < kNumStreams; ++stream) {
+    src_streams[stream] = &data[stream * stride];
   }
+  DoMergeStreams(src_streams.data(), kNumStreams, num_values,
+                 reinterpret_cast<uint8_t*>(out));
 }
 
 template <typename T>
-void inline ByteStreamSplitEncode(const uint8_t* raw_values, const size_t num_values,
+void inline ByteStreamSplitEncode(const uint8_t* raw_values, const int64_t num_values,
                                   uint8_t* output_buffer_raw) {
 #if defined(ARROW_HAVE_SIMD_SPLIT)
   return ByteStreamSplitEncodeSimd<T>(raw_values, num_values, output_buffer_raw);
@@ -625,6 +721,4 @@ void inline ByteStreamSplitDecode(const uint8_t* data, int64_t num_values, int64
 #endif
 }
 
-}  // namespace internal
-}  // namespace util
-}  // namespace arrow
+}  // namespace arrow::util::internal
diff --git a/cpp/src/arrow/util/byte_stream_split_test.cc b/cpp/src/arrow/util/byte_stream_split_test.cc
new file mode 100644
index 0000000000000..3ea27f57da881
--- /dev/null
+++ b/cpp/src/arrow/util/byte_stream_split_test.cc
@@ -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.
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <random>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/util.h"
+#include "arrow/util/byte_stream_split_internal.h"
+
+namespace arrow::util::internal {
+
+using ByteStreamSplitTypes = ::testing::Types<float, double>;
+
+template <typename Func>
+struct NamedFunc {
+  std::string name;
+  Func func;
+
+  friend std::ostream& operator<<(std::ostream& os, const NamedFunc& func) {
+    os << func.name;
+    return os;
+  }
+};
+
+// A simplistic reference implementation for validation
+void RefererenceByteStreamSplitEncode(const uint8_t* src, int width,
+                                      const int64_t num_values, uint8_t* dest) {
+  for (int64_t i = 0; i < num_values; ++i) {
+    for (int stream = 0; stream < width; ++stream) {
+      dest[stream * num_values + i] = *src++;
+    }
+  }
+}
+
+template <typename T>
+class TestByteStreamSplitSpecialized : public ::testing::Test {
+ public:
+  using EncodeFunc = NamedFunc<std::function<decltype(ByteStreamSplitEncode<T>)>>;
+  using DecodeFunc = NamedFunc<std::function<decltype(ByteStreamSplitDecode<T>)>>;
+
+  static constexpr int kWidth = static_cast<int>(sizeof(T));
+
+  void SetUp() override {
+    encode_funcs_.push_back({"reference", &ReferenceEncode});
+    encode_funcs_.push_back({"scalar", &ByteStreamSplitEncodeScalar<T>});
+    decode_funcs_.push_back({"scalar", &ByteStreamSplitDecodeScalar<T>});
+#if defined(ARROW_HAVE_SIMD_SPLIT)
+    encode_funcs_.push_back({"simd", &ByteStreamSplitEncodeSimd<T>});
+    decode_funcs_.push_back({"simd", &ByteStreamSplitDecodeSimd<T>});
+#endif
+  }
+
+  void TestRoundtrip(int64_t num_values) {
+    // Test one-shot roundtrip among all encode/decode function combinations
+    ARROW_SCOPED_TRACE("num_values = ", num_values);
+    const auto input = MakeRandomInput(num_values);
+    std::vector<uint8_t> encoded(num_values * kWidth);
+    std::vector<T> decoded(num_values);
+
+    for (const auto& encode_func : encode_funcs_) {
+      ARROW_SCOPED_TRACE("encode_func = ", encode_func);
+      encoded.assign(encoded.size(), 0);
+      encode_func.func(reinterpret_cast<const uint8_t*>(input.data()), num_values,
+                       encoded.data());
+      for (const auto& decode_func : decode_funcs_) {
+        ARROW_SCOPED_TRACE("decode_func = ", decode_func);
+        decoded.assign(decoded.size(), T{});
+        decode_func.func(encoded.data(), num_values, /*stride=*/num_values,
+                         decoded.data());
+        ASSERT_EQ(decoded, input);
+      }
+    }
+  }
+
+  void TestPiecewiseDecode(int64_t num_values) {
+    // Test chunked decoding against the reference encode function
+    ARROW_SCOPED_TRACE("num_values = ", num_values);
+    const auto input = MakeRandomInput(num_values);
+    std::vector<uint8_t> encoded(num_values * kWidth);
+    ReferenceEncode(reinterpret_cast<const uint8_t*>(input.data()), num_values,
+                    encoded.data());
+    std::vector<T> decoded(num_values);
+
+    std::default_random_engine gen(seed_++);
+    std::uniform_int_distribution<int64_t> chunk_size_dist(1, 123);
+
+    for (const auto& decode_func : decode_funcs_) {
+      ARROW_SCOPED_TRACE("decode_func = ", decode_func);
+      decoded.assign(decoded.size(), T{});
+
+      int64_t offset = 0;
+      while (offset < num_values) {
+        auto chunk_size = std::min<int64_t>(num_values - offset, chunk_size_dist(gen));
+        decode_func.func(encoded.data() + offset, chunk_size, /*stride=*/num_values,
+                         decoded.data() + offset);
+        offset += chunk_size;
+      }
+      ASSERT_EQ(offset, num_values);
+      ASSERT_EQ(decoded, input);
+    }
+  }
+
+ protected:
+  static void ReferenceEncode(const uint8_t* raw_values, const int64_t num_values,
+                              uint8_t* output_buffer_raw) {
+    RefererenceByteStreamSplitEncode(raw_values, kWidth, num_values, output_buffer_raw);
+  }
+
+  static std::vector<T> MakeRandomInput(int64_t num_values) {
+    std::vector<T> input(num_values);
+    random_bytes(kWidth * num_values, seed_++, reinterpret_cast<uint8_t*>(input.data()));
+    // Avoid NaNs to ease comparison
+    for (auto& value : input) {
+      if (std::isnan(value)) {
+        value = nan_replacement_++;
+      }
+    }
+    return input;
+  }
+
+  std::vector<EncodeFunc> encode_funcs_;
+  std::vector<DecodeFunc> decode_funcs_;
+
+  static inline uint32_t seed_ = 42;
+  static inline T nan_replacement_ = 0;
+};
+
+TYPED_TEST_SUITE(TestByteStreamSplitSpecialized, ByteStreamSplitTypes);
+
+TYPED_TEST(TestByteStreamSplitSpecialized, RoundtripSmall) {
+  for (int64_t num_values : {1, 5, 7, 12, 19, 31, 32}) {
+    this->TestRoundtrip(num_values);
+  }
+}
+
+TYPED_TEST(TestByteStreamSplitSpecialized, RoundtripMidsized) {
+  for (int64_t num_values : {126, 127, 128, 129, 133, 200}) {
+    this->TestRoundtrip(num_values);
+  }
+}
+
+TYPED_TEST(TestByteStreamSplitSpecialized, PiecewiseDecode) {
+  this->TestPiecewiseDecode(/*num_values=*/500);
+}
+
+}  // namespace arrow::util::internal
diff --git a/cpp/src/parquet/encoding.cc b/cpp/src/parquet/encoding.cc
index 5221f2588c0d3..1bb487c20d3e2 100644
--- a/cpp/src/parquet/encoding.cc
+++ b/cpp/src/parquet/encoding.cc
@@ -37,7 +37,7 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_writer.h"
-#include "arrow/util/byte_stream_split.h"
+#include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/hashing.h"
 #include "arrow/util/int_util_overflow.h"
@@ -850,8 +850,8 @@ std::shared_ptr<Buffer> ByteStreamSplitEncoder<DType>::FlushValues() {
       AllocateBuffer(this->memory_pool(), EstimatedDataEncodedSize());
   uint8_t* output_buffer_raw = output_buffer->mutable_data();
   const uint8_t* raw_values = sink_.data();
-  ::arrow::util::internal::ByteStreamSplitEncode<T>(
-      raw_values, static_cast<size_t>(num_values_in_buffer_), output_buffer_raw);
+  ::arrow::util::internal::ByteStreamSplitEncode<T>(raw_values, num_values_in_buffer_,
+                                                    output_buffer_raw);
   sink_.Reset();
   num_values_in_buffer_ = 0;
   return std::move(output_buffer);
diff --git a/cpp/src/parquet/encoding_benchmark.cc b/cpp/src/parquet/encoding_benchmark.cc
index 717c716330563..b5b6cc8d93e03 100644
--- a/cpp/src/parquet/encoding_benchmark.cc
+++ b/cpp/src/parquet/encoding_benchmark.cc
@@ -24,7 +24,7 @@
 #include "arrow/testing/random.h"
 #include "arrow/testing/util.h"
 #include "arrow/type.h"
-#include "arrow/util/byte_stream_split.h"
+#include "arrow/util/byte_stream_split_internal.h"
 #include "arrow/visit_data_inline.h"
 
 #include "parquet/encoding.h"

From d8aeb42709f9a0dca8409849572c8e150713fe80 Mon Sep 17 00:00:00 2001
From: Jacob Wujciak-Jens <jacob@wujciak.de>
Date: Thu, 2 Nov 2023 15:18:17 +0100
Subject: [PATCH 668/749] GH-37657: [JS] Run bin scripts with ts-node (#38500)

(rebased version of #37668, yarn.lock conflicts resolved in favor of main)
* update bin scripts to use ts-node in transpile-only mode
* remove ts-node config from top level tsconfig.json
* fix tsc errors in bin scripts
* Closes: #37657

Authored-by: ptaylor <paul.e.taylor@me.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 dev/archery/archery/integration/tester.py     |    5 +-
 dev/archery/archery/integration/tester_js.py  |   26 +-
 dev/archery/archery/integration/util.py       |    5 +-
 js/.vscode/launch.json                        |   57 +-
 js/bin/{arrow2csv.js => arrow2csv.cjs}        |    0
 .../{file-to-stream.js => file-to-stream.ts}  |   17 +-
 js/bin/{integration.js => integration.ts}     |   79 +-
 js/bin/{json-to-arrow.js => json-to-arrow.ts} |   26 +-
 js/bin/package.json                           |    3 -
 ...alignment.js => print-buffer-alignment.ts} |   26 +-
 .../{stream-to-file.js => stream-to-file.ts}  |   13 +-
 js/gulp/closure-task.js                       |    3 +-
 js/index.mjs                                  |    2 +-
 js/index.ts                                   |    2 +-
 js/package.json                               |   25 +-
 js/perf/index.ts                              |   15 +-
 js/src/io/adapters.ts                         |    8 +-
 js/src/recordbatch.ts                         |    2 +-
 js/tsconfig.json                              |   15 +-
 js/tsconfig/tsconfig.es2015.cls.json          |    2 -
 js/tsconfig/tsconfig.es5.cls.json             |    2 -
 js/tsconfig/tsconfig.esnext.cls.json          |    2 -
 js/yarn.lock                                  | 3173 +++++++++--------
 23 files changed, 1830 insertions(+), 1678 deletions(-)
 rename js/bin/{arrow2csv.js => arrow2csv.cjs} (100%)
 rename js/bin/{file-to-stream.js => file-to-stream.ts} (73%)
 rename js/bin/{integration.js => integration.ts} (76%)
 rename js/bin/{json-to-arrow.js => json-to-arrow.ts} (82%)
 delete mode 100644 js/bin/package.json
 rename js/bin/{print-buffer-alignment.js => print-buffer-alignment.ts} (86%)
 rename js/bin/{stream-to-file.js => stream-to-file.ts} (80%)
 mode change 100644 => 100755 js/perf/index.ts

diff --git a/dev/archery/archery/integration/tester.py b/dev/archery/archery/integration/tester.py
index eadb953a61b50..7de8f73c1398c 100644
--- a/dev/archery/archery/integration/tester.py
+++ b/dev/archery/archery/integration/tester.py
@@ -225,11 +225,12 @@ def __init__(self, debug=False, **args):
         self.args = args
         self.debug = debug
 
-    def run_shell_command(self, cmd):
+    def run_shell_command(self, cmd, **kwargs):
         cmd = ' '.join(cmd)
         if self.debug:
             log(cmd)
-        subprocess.check_call(cmd, shell=True)
+        kwargs.update(shell=True)
+        subprocess.check_call(cmd, **kwargs)
 
     def json_to_file(self, json_path, arrow_path):
         """
diff --git a/dev/archery/archery/integration/tester_js.py b/dev/archery/archery/integration/tester_js.py
index 6544a1fc6cc3c..c7f363ba54687 100644
--- a/dev/archery/archery/integration/tester_js.py
+++ b/dev/archery/archery/integration/tester_js.py
@@ -22,11 +22,12 @@
 from ..utils.source import ARROW_ROOT_DEFAULT
 
 
-_EXE_PATH = os.path.join(ARROW_ROOT_DEFAULT, 'js/bin')
-_VALIDATE = os.path.join(_EXE_PATH, 'integration.js')
-_JSON_TO_ARROW = os.path.join(_EXE_PATH, 'json-to-arrow.js')
-_STREAM_TO_FILE = os.path.join(_EXE_PATH, 'stream-to-file.js')
-_FILE_TO_STREAM = os.path.join(_EXE_PATH, 'file-to-stream.js')
+ARROW_JS_ROOT = os.path.join(ARROW_ROOT_DEFAULT, 'js')
+_EXE_PATH = os.path.join(ARROW_JS_ROOT, 'bin')
+_VALIDATE = os.path.join(_EXE_PATH, 'integration.ts')
+_JSON_TO_ARROW = os.path.join(_EXE_PATH, 'json-to-arrow.ts')
+_STREAM_TO_FILE = os.path.join(_EXE_PATH, 'stream-to-file.ts')
+_FILE_TO_STREAM = os.path.join(_EXE_PATH, 'file-to-stream.ts')
 
 
 class JSTester(Tester):
@@ -50,26 +51,25 @@ def _run(self, exe_cmd, arrow_path=None, json_path=None,
         if self.debug:
             log(' '.join(cmd))
 
-        run_cmd(cmd)
+        run_cmd(cmd, cwd=ARROW_JS_ROOT)
 
     def validate(self, json_path, arrow_path, quirks=None):
         return self._run(_VALIDATE, arrow_path, json_path, 'VALIDATE')
 
     def json_to_file(self, json_path, arrow_path):
-        cmd = ['node',
-               '--no-warnings', _JSON_TO_ARROW,
+        cmd = [_JSON_TO_ARROW,
                '-a', arrow_path,
                '-j', json_path]
-        self.run_shell_command(cmd)
+        self.run_shell_command(cmd, cwd=ARROW_JS_ROOT)
 
     def stream_to_file(self, stream_path, file_path):
-        cmd = ['node', '--no-warnings', _STREAM_TO_FILE,
+        cmd = [_STREAM_TO_FILE,
                '<', stream_path,
                '>', file_path]
-        self.run_shell_command(cmd)
+        self.run_shell_command(cmd, cwd=ARROW_JS_ROOT)
 
     def file_to_stream(self, file_path, stream_path):
-        cmd = ['node', '--no-warnings', _FILE_TO_STREAM,
+        cmd = [_FILE_TO_STREAM,
                '<', file_path,
                '>', stream_path]
-        self.run_shell_command(cmd)
+        self.run_shell_command(cmd, cwd=ARROW_JS_ROOT)
diff --git a/dev/archery/archery/integration/util.py b/dev/archery/archery/integration/util.py
index afef7d5eb13b9..1b1eb95a1d296 100644
--- a/dev/archery/archery/integration/util.py
+++ b/dev/archery/archery/integration/util.py
@@ -127,12 +127,13 @@ def frombytes(o):
     return o
 
 
-def run_cmd(cmd):
+def run_cmd(cmd, **kwargs):
     if isinstance(cmd, str):
         cmd = cmd.split(' ')
 
     try:
-        output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        kwargs.update(stderr=subprocess.STDOUT)
+        output = subprocess.check_output(cmd, **kwargs)
     except subprocess.CalledProcessError as e:
         # this avoids hiding the stdout / stderr of failed processes
         sio = io.StringIO()
diff --git a/js/.vscode/launch.json b/js/.vscode/launch.json
index 7d169ccb26274..21255b61c39a5 100644
--- a/js/.vscode/launch.json
+++ b/js/.vscode/launch.json
@@ -31,7 +31,7 @@
       "args": {
         "cwd": "${workspaceFolder}",
         "description": "Select a file to debug",
-        "command": "./node_modules/.bin/jest --listTests | sed -r \"s@$PWD/test/@@g\"",
+        "command": "node_modules/.bin/jest --listTests | sed -r \"s@$PWD/test/@@g\"",
       }
     },
     {
@@ -98,25 +98,23 @@
       "request": "launch",
       "name": "Debug Integration Tests",
       "cwd": "${workspaceFolder}",
-      "program": "${workspaceFolder}/bin/integration.js",
+      "program": "${workspaceFolder}/bin/integration.ts",
       "skipFiles": [
         "<node_internals>/**/*.js",
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "env": {
         "NODE_NO_WARNINGS": "1",
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "args": [
         "--mode",
         "VALIDATE",
         "-j", "test/data/json/unions.json",
-        "-a", "./test/data/cpp/stream/struct_example.arrow"
+        "-a", "test/data/cpp/stream/unions.arrow"
       ]
     },
     {
@@ -140,8 +138,7 @@
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "runtimeArgs": [
-        "--loader",
-        "ts-node/esm/transpile-only"
+        "--loader", "ts-node/esm/transpile-only"
       ]
     },
     {
@@ -150,12 +147,10 @@
       "name": "Debug bin/arrow2csv",
       "cwd": "${workspaceFolder}",
       "env": {
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "console": "integratedTerminal",
       "skipFiles": [
@@ -165,7 +160,7 @@
       "args": [
         "${workspaceFolder}/src/bin/arrow2csv.ts",
         "-f",
-        "./test/data/cpp/stream/simple.arrow"
+        "test/data/cpp/stream/simple.arrow"
       ]
     },
     {
@@ -174,21 +169,19 @@
       "name": "Debug bin/file-to-stream",
       "cwd": "${workspaceFolder}",
       "env": {
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "skipFiles": [
         "<node_internals>/**/*.js",
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "args": [
-        "${workspaceFolder}/bin/file-to-stream.js",
-        "./test/data/cpp/file/struct_example.arrow",
-        "./struct_example-stream-out.arrow",
+        "${workspaceFolder}/bin/file-to-stream.ts",
+        "test/data/cpp/file/struct_example.arrow",
+        "struct_example-stream-out.arrow",
       ]
     },
     {
@@ -197,21 +190,19 @@
       "name": "Debug bin/stream-to-file",
       "cwd": "${workspaceFolder}",
       "env": {
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "skipFiles": [
         "<node_internals>/**/*.js",
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "args": [
-        "${workspaceFolder}/bin/stream-to-file.js",
-        "./test/data/cpp/stream/struct_example.arrow",
-        "./struct_example-file-out.arrow",
+        "${workspaceFolder}/bin/stream-to-file.ts",
+        "test/data/cpp/stream/struct_example.arrow",
+        "struct_example-file-out.arrow",
       ]
     },
     {
@@ -220,23 +211,21 @@
       "name": "Debug bin/json-to-arrow",
       "cwd": "${workspaceFolder}",
       "env": {
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "skipFiles": [
         "<node_internals>/**/*.js",
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "args": [
-        "${workspaceFolder}/bin/json-to-arrow.js",
+        "${workspaceFolder}/bin/json-to-arrow.ts",
         "-j",
-        "./test/data/json/struct_example.json",
+        "test/data/json/struct_example.json",
         "-a",
-        "./struct_example-stream-out.arrow",
+        "struct_example-stream-out.arrow",
         "-f",
         "stream"
       ]
@@ -247,20 +236,18 @@
       "name": "Debug bin/print-buffer-alignment",
       "cwd": "${workspaceFolder}",
       "env": {
-        "ARROW_JS_DEBUG": "src",
         "TS_NODE_CACHE": "false"
       },
       "runtimeArgs": [
-        "-r",
-        "ts-node/register"
+        "--loader", "ts-node/esm/transpile-only"
       ],
       "skipFiles": [
         "<node_internals>/**/*.js",
         "${workspaceFolder}/node_modules/**/*.js"
       ],
       "args": [
-        "${workspaceFolder}/bin/print-buffer-alignment.js",
-        "./test/data/cpp/stream/struct_example.arrow"
+        "${workspaceFolder}/bin/print-buffer-alignment.ts",
+        "test/data/cpp/stream/struct_example.arrow"
       ]
     },
     {
diff --git a/js/bin/arrow2csv.js b/js/bin/arrow2csv.cjs
similarity index 100%
rename from js/bin/arrow2csv.js
rename to js/bin/arrow2csv.cjs
diff --git a/js/bin/file-to-stream.js b/js/bin/file-to-stream.ts
similarity index 73%
rename from js/bin/file-to-stream.js
rename to js/bin/file-to-stream.ts
index 7fab54e2cb09f..9dad4951f96e1 100755
--- a/js/bin/file-to-stream.js
+++ b/js/bin/file-to-stream.ts
@@ -1,4 +1,4 @@
-#! /usr/bin/env node
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
 
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -17,18 +17,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// @ts-check
-
-const fs = require('fs');
-const path = require('path');
-const eos = require('util').promisify(require('stream').finished);
-const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const { RecordBatchReader, RecordBatchStreamWriter } = require(`../index${extension}`);
+import * as fs from 'fs';
+import * as Path from 'path';
+import { finished as eos } from 'stream/promises';
+import { RecordBatchReader, RecordBatchStreamWriter } from '../index.ts';
 
 (async () => {
 
-    const readable = process.argv.length < 3 ? process.stdin : fs.createReadStream(path.resolve(process.argv[2]));
-    const writable = process.argv.length < 4 ? process.stdout : fs.createWriteStream(path.resolve(process.argv[3]));
+    const readable = process.argv.length < 3 ? process.stdin : fs.createReadStream(Path.resolve(process.argv[2]));
+    const writable = process.argv.length < 4 ? process.stdout : fs.createWriteStream(Path.resolve(process.argv[3]));
 
     const fileToStream = readable
         .pipe(RecordBatchReader.throughNode())
diff --git a/js/bin/integration.js b/js/bin/integration.ts
similarity index 76%
rename from js/bin/integration.js
rename to js/bin/integration.ts
index 583b7a2161d7d..f9aad3422ae72 100755
--- a/js/bin/integration.js
+++ b/js/bin/integration.ts
@@ -1,4 +1,4 @@
-#! /usr/bin/env node
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
 
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -17,23 +17,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// @ts-nocheck
+import * as fs from 'fs';
+import * as Path from 'path';
+import { glob } from 'glob';
+import { zip } from 'ix/iterable/zip.js';
+import commandLineArgs from 'command-line-args';
+// @ts-ignore
+import { parse as bignumJSONParse } from 'json-bignum';
 
-const fs = require('fs');
-const Path = require('path');
-const { glob } = require('glob');
-const { zip } = require('ix/iterable/zip');
-const { parse: bignumJSONParse } = require('json-bignum');
-const argv = require(`command-line-args`)(cliOpts(), { partial: true });
-const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const {
+import {
     Table,
+    Vector,
+    RecordBatch,
+    ArrowJSONLike,
     RecordBatchReader,
     RecordBatchStreamWriter,
-    util: { createElementComparator }
-} = require(`../index${extension}`);
+    util,
+} from '../index.ts';
 
-const exists = async (p) => {
+const { createElementComparator } = util;
+const argv = commandLineArgs(cliOpts(), { partial: true });
+
+const exists = async (p: string) => {
     try {
         return !!(await fs.promises.stat(p));
     } catch (e) { return false; }
@@ -60,7 +65,7 @@ const exists = async (p) => {
             for (let [jsonPath, arrowPath] of zip(jsonPaths, arrowPaths)) {
                 try {
                     await validate(jsonPath, arrowPath);
-                } catch (e) {
+                } catch (e: any) {
                     threw = true;
                     e && process.stderr.write(`${e?.stack || e}\n`);
                 }
@@ -108,7 +113,7 @@ function print_usage() {
         {
             header: 'Synopsis',
             content: [
-                '$ integration.js -j file.json -a file.arrow --mode validate'
+                '$ integration.ts -j file.json -a file.arrow --mode validate'
             ]
         },
         {
@@ -125,7 +130,7 @@ function print_usage() {
     return 1;
 }
 
-async function validate(jsonPath, arrowPath) {
+async function validate(jsonPath: string, arrowPath: string) {
 
     const files = await Promise.all([
         fs.promises.readFile(arrowPath),
@@ -147,7 +152,7 @@ async function validate(jsonPath, arrowPath) {
     validateTableToBuffersIntegration('binary', 'file')(jsonData, arrowData);
 }
 
-function validateReaderIntegration(jsonData, arrowBuffer) {
+function validateReaderIntegration(jsonData: ArrowJSONLike, arrowBuffer: Uint8Array) {
     const msg = `json and arrow record batches report the same values`;
     try {
         const jsonReader = RecordBatchReader.from(jsonData);
@@ -155,57 +160,57 @@ function validateReaderIntegration(jsonData, arrowBuffer) {
         for (const [jsonRecordBatch, binaryRecordBatch] of zip(jsonReader, binaryReader)) {
             compareTableIsh(jsonRecordBatch, binaryRecordBatch);
         }
-    } catch (e) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
+    } catch (e: any) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
     process.stdout.write(`${msg}: pass\n`);
 }
 
-function validateTableFromBuffersIntegration(jsonData, arrowBuffer) {
+function validateTableFromBuffersIntegration(jsonData: ArrowJSONLike, arrowBuffer: Uint8Array) {
     const msg = `json and arrow tables report the same values`;
     try {
         const jsonTable = new Table(RecordBatchReader.from(jsonData));
         const binaryTable = new Table(RecordBatchReader.from(arrowBuffer));
         compareTableIsh(jsonTable, binaryTable);
-    } catch (e) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
+    } catch (e: any) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
     process.stdout.write(`${msg}: pass\n`);
 }
 
-function validateTableToBuffersIntegration(srcFormat, arrowFormat) {
+function validateTableToBuffersIntegration(srcFormat: 'json' | 'binary', arrowFormat: 'file' | 'stream') {
     const refFormat = srcFormat === `json` ? `binary` : `json`;
-    return function testTableToBuffersIntegration(jsonData, arrowBuffer) {
+    return function testTableToBuffersIntegration(jsonData: ArrowJSONLike, arrowBuffer: Uint8Array) {
         const msg = `serialized ${srcFormat} ${arrowFormat} reports the same values as the ${refFormat} ${arrowFormat}`;
         try {
-            const refTable = new Table(RecordBatchReader.from(refFormat === `json` ? jsonData : arrowBuffer));
-            const srcTable = new Table(RecordBatchReader.from(srcFormat === `json` ? jsonData : arrowBuffer));
+            const refTable = new Table(refFormat === `json` ? RecordBatchReader.from(jsonData) : RecordBatchReader.from(arrowBuffer));
+            const srcTable = new Table(srcFormat === `json` ? RecordBatchReader.from(jsonData) : RecordBatchReader.from(arrowBuffer));
             const dstTable = new Table(RecordBatchReader.from(RecordBatchStreamWriter.writeAll(srcTable).toUint8Array(true)));
             compareTableIsh(dstTable, refTable);
-        } catch (e) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
+        } catch (e: any) { throw new Error(`${msg}: fail \n ${e?.stack || e}`); }
         process.stdout.write(`${msg}: pass\n`);
     };
 }
 
-function compareTableIsh(actual, expected) {
-    if (actual.length !== expected.length) {
-        throw new Error(`length: ${actual.length} !== ${expected.length}`);
+function compareTableIsh(actual: Table | RecordBatch, expected: Table | RecordBatch) {
+    if (actual.numRows !== expected.numRows) {
+        throw new Error(`numRows: ${actual.numRows} !== ${expected.numRows}`);
     }
     if (actual.numCols !== expected.numCols) {
         throw new Error(`numCols: ${actual.numCols} !== ${expected.numCols}`);
     }
     (() => {
         for (let i = -1, n = actual.numCols; ++i < n;) {
-            const v1 = actual.getChildAt(i);
-            const v2 = expected.getChildAt(i);
+            const v1 = actual.getChildAt(i)!;
+            const v2 = expected.getChildAt(i)!;
             compareVectors(v1, v2);
         }
     })();
 }
 
-function compareVectors(actual, expected) {
+function compareVectors(actual: Vector, expected: Vector) {
 
     if ((actual == null && expected != null) || (expected == null && actual != null)) {
         throw new Error(`${actual == null ? `actual` : `expected`} is null, was expecting ${actual ?? expected} to be that also`);
     }
 
-    const props = ['type', 'length', 'nullCount'];
+    const props = ['type', 'length', 'nullCount'] as (keyof Vector & string)[];
 
     (() => {
         for (let i = -1, n = props.length; ++i < n;) {
@@ -236,7 +241,7 @@ function compareVectors(actual, expected) {
     })();
 }
 
-async function loadLocalJSONAndArrowPathsForDebugging(jsonPaths, arrowPaths) {
+async function loadLocalJSONAndArrowPathsForDebugging(jsonPaths: string[], arrowPaths: string[]) {
 
     const sourceJSONPaths = await glob(Path.resolve(__dirname, `../test/data/json/`, `*.json`));
 
@@ -254,7 +259,13 @@ async function loadLocalJSONAndArrowPathsForDebugging(jsonPaths, arrowPaths) {
 
     return [jsonPaths, arrowPaths];
 
-    async function loadJSONAndArrowPaths(sourceJSONPaths, jsonPaths, arrowPaths, source, format) {
+    async function loadJSONAndArrowPaths(
+        sourceJSONPaths: string[],
+        jsonPaths: string[],
+        arrowPaths: string[],
+        source: 'cpp' | 'java',
+        format: 'file' | 'stream'
+    ) {
         for (const jsonPath of sourceJSONPaths) {
             const { name } = Path.parse(jsonPath);
             const arrowPath = Path.resolve(__dirname, `../test/data/${source}/${format}/${name}.arrow`);
diff --git a/js/bin/json-to-arrow.js b/js/bin/json-to-arrow.ts
similarity index 82%
rename from js/bin/json-to-arrow.js
rename to js/bin/json-to-arrow.ts
index 20442ac062358..49726706a1be6 100755
--- a/js/bin/json-to-arrow.js
+++ b/js/bin/json-to-arrow.ts
@@ -1,4 +1,4 @@
-#! /usr/bin/env node
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
 
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -17,16 +17,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// @ts-check
-
-const fs = require('fs');
-const Path = require('path');
-const { parse } = require('json-bignum');
-const eos = require('util').promisify(require('stream').finished);
-const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const argv = require(`command-line-args`)(cliOpts(), { partial: true });
-const { RecordBatchReader, RecordBatchFileWriter, RecordBatchStreamWriter } = require(`../index${extension}`);
+import * as fs from 'fs';
+import * as Path from 'path';
+import commandLineArgs from 'command-line-args';
+import { finished as eos } from 'stream/promises';
+// @ts-ignore
+import { parse as bignumJSONParse } from 'json-bignum';
+import { RecordBatchReader, RecordBatchFileWriter, RecordBatchStreamWriter } from '../index.ts';
 
+const argv = commandLineArgs(cliOpts(), { partial: true });
 const jsonPaths = [...(argv.json || [])];
 const arrowPaths = [...(argv.arrow || [])];
 
@@ -42,7 +41,7 @@ const arrowPaths = [...(argv.arrow || [])];
             ? RecordBatchFileWriter
             : RecordBatchStreamWriter;
 
-        const reader = RecordBatchReader.from(parse(
+        const reader = RecordBatchReader.from(bignumJSONParse(
             await fs.promises.readFile(Path.resolve(path), 'utf8')));
 
         const jsonToArrow = reader
@@ -50,8 +49,9 @@ const arrowPaths = [...(argv.arrow || [])];
             .pipe(fs.createWriteStream(arrowPaths[i]));
 
         await eos(jsonToArrow);
-
     }));
+
+    return undefined;
 })()
     .then((x) => x ?? 0, (e) => {
         e && process.stderr.write(`${e}`);
@@ -90,7 +90,7 @@ function print_usage() {
         {
             header: 'Synopsis',
             content: [
-                '$ json-to-arrow.js -j in.json -a out.arrow -f stream'
+                '$ json-to-arrow.ts -j in.json -a out.arrow -f stream'
             ]
         },
         {
diff --git a/js/bin/package.json b/js/bin/package.json
deleted file mode 100644
index 6a0d2ef2aa8b2..0000000000000
--- a/js/bin/package.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-    "type": "commonjs"
-}
\ No newline at end of file
diff --git a/js/bin/print-buffer-alignment.js b/js/bin/print-buffer-alignment.ts
similarity index 86%
rename from js/bin/print-buffer-alignment.js
rename to js/bin/print-buffer-alignment.ts
index 0dd46c2da1c5d..07563af5a87e8 100755
--- a/js/bin/print-buffer-alignment.js
+++ b/js/bin/print-buffer-alignment.ts
@@ -1,4 +1,4 @@
-#! /usr/bin/env node
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
 
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -17,19 +17,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// @ts-check
-
-const fs = require('fs');
-const path = require('path');
-const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const { VectorLoader } = process.env.ARROW_JS_DEBUG
-    ? require(`../src/visitor/vectorloader${extension}`)
-    : require(`../targets/apache-arrow/visitor/vectorloader`);
-const { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } = require(`../index${extension}`);
+import * as fs from 'fs';
+import * as Path from 'path';
+import { VectorLoader } from '../src/visitor/vectorloader.ts';
+import { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } from '../index.ts';
 
 (async () => {
 
-    const readable = process.argv.length < 3 ? process.stdin : fs.createReadStream(path.resolve(process.argv[2]));
+    const readable = process.argv.length < 3 ? process.stdin : fs.createReadStream(Path.resolve(process.argv[2]));
     const reader = new AsyncMessageReader(readable);
 
     let schema, metadataLength, message;
@@ -38,10 +33,13 @@ const { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } = req
     let dictionaryBatchCount = 0;
 
     while (1) {
+        // @ts-ignore
         if ((metadataLength = (await reader.readMetadataLength())).done) { break; }
         if (metadataLength.value === -1) {
+            // @ts-ignore
             if ((metadataLength = (await reader.readMetadataLength())).done) { break; }
         }
+        // @ts-ignore
         if ((message = (await reader.readMetadata(metadataLength.value))).done) { break; }
 
         if (message.value.isSchema()) {
@@ -74,7 +72,7 @@ const { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } = req
         } else if (message.value.isDictionaryBatch()) {
             const header = message.value.header();
             const bufferRegions = header.data.buffers;
-            const type = schema.dictionaries.get(header.id);
+            const type = schema!.dictionaries.get(header.id);
             const body = await reader.readMessageBody(message.value.bodyLength);
             const recordBatch = loadDictionaryBatch(header.data, body, type);
             console.log(
@@ -98,7 +96,7 @@ const { RecordBatch, AsyncMessageReader, makeData, Struct, Schema, Field } = req
 
 })().catch((e) => { console.error(e); process.exit(1); });
 
-function loadRecordBatch(schema, header, body) {
+function loadRecordBatch(schema: any, header: any, body: any) {
     const children = new VectorLoader(body, header.nodes, header.buffers, new Map()).visitMany(schema.fields);
     return new RecordBatch(
         schema,
@@ -110,7 +108,7 @@ function loadRecordBatch(schema, header, body) {
     );
 }
 
-function loadDictionaryBatch(header, body, dictionaryType) {
+function loadDictionaryBatch(header: any, body: any, dictionaryType: any) {
     const schema = new Schema([new Field('', dictionaryType)]);
     const children = new VectorLoader(body, header.nodes, header.buffers, new Map()).visitMany([dictionaryType]);
     return new RecordBatch(
diff --git a/js/bin/stream-to-file.js b/js/bin/stream-to-file.ts
similarity index 80%
rename from js/bin/stream-to-file.js
rename to js/bin/stream-to-file.ts
index 5cd9e76f8085f..6e09ead2fde19 100755
--- a/js/bin/stream-to-file.js
+++ b/js/bin/stream-to-file.ts
@@ -1,4 +1,4 @@
-#! /usr/bin/env node
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
 
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
@@ -17,13 +17,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// @ts-check
-
-const fs = require('fs');
-const path = require('path');
-const eos = require('util').promisify(require('stream').finished);
-const extension = process.env.ARROW_JS_DEBUG === 'src' ? '.ts' : '.cjs';
-const { RecordBatchReader, RecordBatchFileWriter } = require(`../index${extension}`);
+import * as fs from 'fs';
+import * as path from 'path';
+import { finished as eos } from 'stream/promises';
+import { RecordBatchReader, RecordBatchFileWriter } from '../index.ts';
 
 (async () => {
 
diff --git a/js/gulp/closure-task.js b/js/gulp/closure-task.js
index e7e13c3046b37..7c0ae1c1b6cd5 100644
--- a/js/gulp/closure-task.js
+++ b/js/gulp/closure-task.js
@@ -56,7 +56,8 @@ export const closureTask = ((cache) => memoizeTask(cache, async function closure
 
     return await Promise.all([
         runClosureCompileAsObservable().toPromise(),
-        compileBinFiles(target, format).toPromise()
+        compileBinFiles(target, format).toPromise(),
+        observableFromStreams(gulp.src(`${src}/**/*.d.ts`), gulp.dest(out)), // copy .d.ts files
     ]);
 
     function runClosureCompileAsObservable() {
diff --git a/js/index.mjs b/js/index.mjs
index 163f250e61641..f834ef19a0397 100644
--- a/js/index.mjs
+++ b/js/index.mjs
@@ -15,4 +15,4 @@
 // specific language governing permissions and limitations
 // under the License.
 
-export * from './targets/apache-arrow/Arrow.mjs';
+export * from './targets/apache-arrow/Arrow.node.mjs';
diff --git a/js/index.ts b/js/index.ts
index cfd64bbbe9730..dab2977678aac 100644
--- a/js/index.ts
+++ b/js/index.ts
@@ -15,4 +15,4 @@
 // specific language governing permissions and limitations
 // under the License.
 
-export * from './src/Arrow.node';
\ No newline at end of file
+export * from './src/Arrow.node.ts';
diff --git a/js/package.json b/js/package.json
index fd4408e5bcaab..5c3f0ed5aba8a 100644
--- a/js/package.json
+++ b/js/package.json
@@ -2,7 +2,7 @@
   "name": "apache-arrow",
   "description": "Apache Arrow columnar in-memory format",
   "bin": {
-    "arrow2csv": "bin/arrow2csv.js"
+    "arrow2csv": "bin/arrow2csv.cjs"
   },
   "type": "module",
   "scripts": {
@@ -11,8 +11,8 @@
     "build": "cross-env NODE_NO_WARNINGS=1 gulp build",
     "clean": "cross-env NODE_NO_WARNINGS=1 gulp clean",
     "debug": "cross-env NODE_NO_WARNINGS=1 gulp debug",
-    "perf": "node --loader ts-node/esm/transpile-only ./perf/index.ts",
-    "test:integration": "node ./bin/integration.js --mode validate",
+    "perf": "perf/index.ts",
+    "test:integration": "bin/integration.ts --mode validate",
     "release": "./npm-release.sh",
     "clean:all": "yarn clean && yarn clean:testdata",
     "clean:testdata": "gulp clean:testdata",
@@ -52,22 +52,24 @@
     "jest.config.js"
   ],
   "dependencies": {
-    "@types/command-line-args": "5.2.0",
-    "@types/command-line-usage": "5.0.2",
-    "@types/node": "20.3.0",
-    "@types/pad-left": "2.1.1",
-    "command-line-args": "5.2.1",
-    "command-line-usage": "7.0.1",
-    "flatbuffers": "23.5.26",
+    "@swc/helpers": "^0.5.2",
+    "@types/command-line-args": "^5.2.1",
+    "@types/command-line-usage": "^5.0.2",
+    "@types/node": "^20.6.0",
+    "@types/pad-left": "^2.1.1",
+    "command-line-args": "^5.2.1",
+    "command-line-usage": "^7.0.1",
+    "flatbuffers": "^23.5.26",
     "json-bignum": "^0.0.3",
     "pad-left": "^2.1.0",
-    "tslib": "^2.5.3"
+    "tslib": "^2.6.2"
   },
   "devDependencies": {
     "@openpgp/web-stream-tools": "0.0.13",
     "@rollup/plugin-alias": "5.0.0",
     "@rollup/plugin-node-resolve": "15.1.0",
     "@rollup/stream": "3.0.0",
+    "@swc/core": "1.3.82",
     "@types/benchmark": "2.1.2",
     "@types/glob": "8.1.0",
     "@types/jest": "29.5.3",
@@ -103,6 +105,7 @@
     "mkdirp": "3.0.1",
     "multistream": "4.1.0",
     "randomatic": "3.1.1",
+    "regenerator-runtime": "0.14.0",
     "rollup": "3.25.0",
     "rxjs": "7.8.1",
     "ts-jest": "29.1.1",
diff --git a/js/perf/index.ts b/js/perf/index.ts
old mode 100644
new mode 100755
index 40225a6d8ae8c..2869470b4697f
--- a/js/perf/index.ts
+++ b/js/perf/index.ts
@@ -1,3 +1,5 @@
+#! /usr/bin/env -S node --no-warnings --loader ts-node/esm/transpile-only
+
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
@@ -15,24 +17,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// Alternatively, use bundles for performance tests
-// import * as Arrow from '../targets/es5/umd/Arrow.js';
+export { Arrow };
+
+import * as Arrow from '../src/Arrow.ts';
+// import Arrow from '../targets/es5/umd/Arrow.js';
 // import * as Arrow from '../targets/es5/esm/Arrow.js';
 // import * as Arrow from '../targets/es5/cjs/Arrow.js';
-// import * as Arrow from '../targets/es2015/umd/Arrow.js';
+// import Arrow from '../targets/es2015/umd/Arrow.js';
 // import * as Arrow from '../targets/es2015/esm/Arrow.js';
 // import * as Arrow from '../targets/es2015/cjs/Arrow.js';
-// import * as Arrow from '../targets/esnext/umd/Arrow.js';
+// import Arrow from '../targets/esnext/umd/Arrow.js';
 // import * as Arrow from '../targets/esnext/esm/Arrow.js';
 // import * as Arrow from '../targets/esnext/cjs/Arrow.js';
 
-import * as Arrow from '../src/Arrow.js';
-
 import config, { arrays, typedArrays, vectors } from './config.js';
 import b from 'benny';
 import { CaseResult, Summary } from 'benny/lib/internal/common-types';
 import kleur from 'kleur';
-export { Arrow };
 
 const { RecordBatchReader, RecordBatchStreamWriter } = Arrow;
 
diff --git a/js/src/io/adapters.ts b/js/src/io/adapters.ts
index d0c8f7a5a99f0..05020314aa6b9 100644
--- a/js/src/io/adapters.ts
+++ b/js/src/io/adapters.ts
@@ -71,7 +71,7 @@ function* fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T):
     }
 
     // Yield so the caller can inject the read command before creating the source Iterator
-    ({ cmd, size } = yield <any>null);
+    ({ cmd, size } = (yield (() => <any>null)()) || {cmd: 'read', size: 0});
 
     // initialize the iterator
     const it = toUint8ArrayIterator(source)[Symbol.iterator]();
@@ -117,7 +117,7 @@ async function* fromAsyncIterable<T extends ArrayBufferViewInput>(source: AsyncI
     }
 
     // Yield so the caller can inject the read command before creating the source AsyncIterator
-    ({ cmd, size } = (yield <any>null)!);
+    ({ cmd, size } = (yield (() => <any>null)()) || {cmd: 'read', size: 0});
 
     // initialize the iterator
     const it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();
@@ -167,7 +167,7 @@ async function* fromDOMStream<T extends ArrayBufferViewInput>(source: ReadableSt
     }
 
     // Yield so the caller can inject the read command before we establish the ReadableStream lock
-    ({ cmd, size } = yield <any>null);
+    ({ cmd, size } = (yield (() => <any>null)()) || {cmd: 'read', size: 0});
 
     // initialize the reader and lock the stream
     const it = new AdaptiveByteReader(source);
@@ -273,7 +273,7 @@ async function* fromNodeStream(stream: NodeJS.ReadableStream): AsyncUint8ArrayGe
 
     // Yield so the caller can inject the read command before we
     // add the listener for the source stream's 'readable' event.
-    ({ cmd, size } = yield <any>null);
+    ({ cmd, size } = (yield (() => <any>null)()) || {cmd: 'read', size: 0});
 
     // ignore stdin if it's a TTY
     if ((stream as any)['isTTY']) {
diff --git a/js/src/recordbatch.ts b/js/src/recordbatch.ts
index 59505a70a3c81..1ea7c52ccf310 100644
--- a/js/src/recordbatch.ts
+++ b/js/src/recordbatch.ts
@@ -203,7 +203,7 @@ export class RecordBatch<T extends TypeMap = any> {
      * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
      * @param index The index of the child to retrieve.
      */
-    public getChildAt<R extends DataType = any>(index: number): Vector<R> | null {
+    public getChildAt<R extends T[keyof T] = any>(index: number): Vector<R> | null {
         if (index > -1 && index < this.schema.fields.length) {
             return new Vector([this.data.children[index]]) as Vector<R>;
         }
diff --git a/js/tsconfig.json b/js/tsconfig.json
index fa352302eaadc..abdd1815a0d98 100644
--- a/js/tsconfig.json
+++ b/js/tsconfig.json
@@ -15,18 +15,11 @@
     "paths": {
       "apache-arrow": ["src/Arrow.node"],
       "apache-arrow/*": ["src/*"]
-    }
+    },
+    "allowImportingTsExtensions": true,
   },
-  "include": ["src/**/*.ts", "test/**/*.ts", "perf/**/*.ts"],
+  "include": ["bin/**/*.ts", "src/**/*.ts", "test/**/*.ts", "perf/**/*.ts"],
   "ts-node": {
-    "transpileOnly": true,
-    "experimentalResolver": true,
-    "compilerOptions": {
-      "module": "CommonJS"
-    },
-    "moduleTypes": {
-      "index.ts": "cjs",
-      "src/**/*": "cjs",
-    }
+    "swc": true
   }
 }
diff --git a/js/tsconfig/tsconfig.es2015.cls.json b/js/tsconfig/tsconfig.es2015.cls.json
index 7db6858c767d3..edac1038ee301 100644
--- a/js/tsconfig/tsconfig.es2015.cls.json
+++ b/js/tsconfig/tsconfig.es2015.cls.json
@@ -4,8 +4,6 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ES2015",
-    "declaration": false,
-    "declarationMap": false,
     "noEmitHelpers": true,
     "importHelpers": false
   }
diff --git a/js/tsconfig/tsconfig.es5.cls.json b/js/tsconfig/tsconfig.es5.cls.json
index 0751eb0c96d7f..a6a4e80b2745b 100644
--- a/js/tsconfig/tsconfig.es5.cls.json
+++ b/js/tsconfig/tsconfig.es5.cls.json
@@ -4,8 +4,6 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ES2015",
-    "declaration": false,
-    "declarationMap": false,
     "noEmitHelpers": true,
     "importHelpers": false
   }
diff --git a/js/tsconfig/tsconfig.esnext.cls.json b/js/tsconfig/tsconfig.esnext.cls.json
index f9a456693d9db..335e759904159 100644
--- a/js/tsconfig/tsconfig.esnext.cls.json
+++ b/js/tsconfig/tsconfig.esnext.cls.json
@@ -4,8 +4,6 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ES2015",
-    "declaration": false,
-    "declarationMap": false,
     "noEmitHelpers": true,
     "importHelpers": false
   }
diff --git a/js/yarn.lock b/js/yarn.lock
index 6677772086ad5..00a4c7ae0ec34 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -4,15 +4,20 @@
 
 "@75lb/deep-merge@^1.1.1":
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/@75lb/deep-merge/-/deep-merge-1.1.1.tgz#3b06155b90d34f5f8cc2107d796f1853ba02fd6d"
+  resolved "https://registry.npmjs.org/@75lb/deep-merge/-/deep-merge-1.1.1.tgz#3b06155b90d34f5f8cc2107d796f1853ba02fd6d"
   integrity sha512-xvgv6pkMGBA6GwdyJbNAnDmfAIR/DfWhrj9jgWh3TY7gRm3KO46x/GPjRg6wJ0nOepwqrNxFfojebh0Df4h4Tw==
   dependencies:
     lodash.assignwith "^4.2.0"
     typical "^7.1.1"
 
+"@aashutoshrathi/word-wrap@^1.2.3":
+  version "1.2.6"
+  resolved "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz#bd9154aec9983f77b3a034ecaa015c2e4201f6cf"
+  integrity sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==
+
 "@ampproject/remapping@^2.2.0":
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.1.tgz#99e8e11851128b8702cd57c33684f1d0f260b630"
+  resolved "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.2.1.tgz#99e8e11851128b8702cd57c33684f1d0f260b630"
   integrity sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==
   dependencies:
     "@jridgewell/gen-mapping" "^0.3.0"
@@ -20,31 +25,31 @@
 
 "@arrows/array@^1.4.1":
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/@arrows/array/-/array-1.4.1.tgz#a6580a08cee219755ca9a8eb14e956d3c29a5508"
+  resolved "https://registry.npmjs.org/@arrows/array/-/array-1.4.1.tgz#a6580a08cee219755ca9a8eb14e956d3c29a5508"
   integrity sha512-MGYS8xi3c4tTy1ivhrVntFvufoNzje0PchjEz6G/SsWRgUKxL4tKwS6iPdO8vsaJYldagAeWMd5KRD0aX3Q39g==
   dependencies:
     "@arrows/composition" "^1.2.2"
 
 "@arrows/composition@^1.0.0", "@arrows/composition@^1.2.2":
   version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@arrows/composition/-/composition-1.2.2.tgz#d0a213cac8f8c36c1c75856a1e6ed940c27e9169"
+  resolved "https://registry.npmjs.org/@arrows/composition/-/composition-1.2.2.tgz#d0a213cac8f8c36c1c75856a1e6ed940c27e9169"
   integrity sha512-9fh1yHwrx32lundiB3SlZ/VwuStPB4QakPsSLrGJFH6rCXvdrd060ivAZ7/2vlqPnEjBkPRRXOcG1YOu19p2GQ==
 
 "@arrows/dispatch@^1.0.2":
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/@arrows/dispatch/-/dispatch-1.0.3.tgz#c4c06260f89e9dd4ce280df3712980aa2f3de976"
+  resolved "https://registry.npmjs.org/@arrows/dispatch/-/dispatch-1.0.3.tgz#c4c06260f89e9dd4ce280df3712980aa2f3de976"
   integrity sha512-v/HwvrFonitYZM2PmBlAlCqVqxrkIIoiEuy5bQgn0BdfvlL0ooSBzcPzTMrtzY8eYktPyYcHg8fLbSgyybXEqw==
   dependencies:
     "@arrows/composition" "^1.2.2"
 
 "@arrows/error@^1.0.2":
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@arrows/error/-/error-1.0.2.tgz#4e68036f901118ba6f1de88656ef6be49e650414"
+  resolved "https://registry.npmjs.org/@arrows/error/-/error-1.0.2.tgz#4e68036f901118ba6f1de88656ef6be49e650414"
   integrity sha512-yvkiv1ay4Z3+Z6oQsUkedsQm5aFdyPpkBUQs8vejazU/RmANABx6bMMcBPPHI4aW43VPQmXFfBzr/4FExwWTEA==
 
 "@arrows/multimethod@^1.1.6":
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/@arrows/multimethod/-/multimethod-1.4.1.tgz#319d0b6f84d22522dd2f4b24f04137b6219f0300"
+  resolved "https://registry.npmjs.org/@arrows/multimethod/-/multimethod-1.4.1.tgz#319d0b6f84d22522dd2f4b24f04137b6219f0300"
   integrity sha512-AZnAay0dgPnCJxn3We5uKiB88VL+1ZIF2SjZohLj6vqY2UyvB/sKdDnFP+LZNVsTC5lcnGPmLlRRkAh4sXkXsQ==
   dependencies:
     "@arrows/array" "^1.4.1"
@@ -52,12 +57,13 @@
     "@arrows/error" "^1.0.2"
     fast-deep-equal "^3.1.3"
 
-"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.22.5.tgz#234d98e1551960604f1246e6475891a570ad5658"
-  integrity sha512-Xmwn266vad+6DAqEB2A6V/CcZVp62BbwVmcOJc2RPuwih1kw02TjQvWVWlcKGbBPd+8/0V5DEkOcizRGYsspYQ==
+"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.12.13", "@babel/code-frame@^7.22.13":
+  version "7.22.13"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz#e3c1c099402598483b7a8c46a721d1038803755e"
+  integrity sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==
   dependencies:
-    "@babel/highlight" "^7.22.5"
+    "@babel/highlight" "^7.22.13"
+    chalk "^2.4.2"
 
 "@babel/code-frame@^7.22.13":
   version "7.22.13"
@@ -73,32 +79,32 @@
   integrity sha512-4Jc/YuIaYqKnDDz892kPIledykKg12Aw1PYX5i/TY28anJtacvM1Rrr8wbieB9GfEJwlzqT0hUEao0CxEebiDA==
 
 "@babel/core@^7.11.6", "@babel/core@^7.12.3":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.22.5.tgz#d67d9747ecf26ee7ecd3ebae1ee22225fe902a89"
-  integrity sha512-SBuTAjg91A3eKOvD+bPEz3LlhHZRNu1nFOVts9lzDJTXshHTjII0BAtDS3Y2DAkdZdDKWVZGVwkDfc4Clxn1dg==
+  version "7.22.19"
+  resolved "https://registry.npmjs.org/@babel/core/-/core-7.22.19.tgz#b38162460a6f3baf2a424bda720b24a8aafea241"
+  integrity sha512-Q8Yj5X4LHVYTbLCKVz0//2D2aDmHF4xzCdEttYvKOnWvErGsa6geHXD6w46x64n5tP69VfeH+IfSrdyH3MLhwA==
   dependencies:
     "@ampproject/remapping" "^2.2.0"
-    "@babel/code-frame" "^7.22.5"
-    "@babel/generator" "^7.22.5"
-    "@babel/helper-compilation-targets" "^7.22.5"
-    "@babel/helper-module-transforms" "^7.22.5"
-    "@babel/helpers" "^7.22.5"
-    "@babel/parser" "^7.22.5"
-    "@babel/template" "^7.22.5"
-    "@babel/traverse" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/code-frame" "^7.22.13"
+    "@babel/generator" "^7.22.15"
+    "@babel/helper-compilation-targets" "^7.22.15"
+    "@babel/helper-module-transforms" "^7.22.19"
+    "@babel/helpers" "^7.22.15"
+    "@babel/parser" "^7.22.16"
+    "@babel/template" "^7.22.15"
+    "@babel/traverse" "^7.22.19"
+    "@babel/types" "^7.22.19"
     convert-source-map "^1.7.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
-    json5 "^2.2.2"
-    semver "^6.3.0"
+    json5 "^2.2.3"
+    semver "^6.3.1"
 
-"@babel/generator@^7.22.5", "@babel/generator@^7.7.2":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.22.5.tgz#1e7bf768688acfb05cf30b2369ef855e82d984f7"
-  integrity sha512-+lcUbnTRhd0jOewtFSedLyiPsD5tswKkbgcezOqqWFUVNEwoUTlpPOBmvhG7OXWLR4jMdv0czPGH5XbflnD1EA==
+"@babel/generator@^7.22.15", "@babel/generator@^7.7.2":
+  version "7.22.15"
+  resolved "https://registry.npmjs.org/@babel/generator/-/generator-7.22.15.tgz#1564189c7ec94cb8f77b5e8a90c4d200d21b2339"
+  integrity sha512-Zu9oWARBqeVOW0dZOjXc3JObrzuqothQ3y/n1kUtrjCoCPLkXUwMvOo/F/TCfoHMbWIFlWwpZtkZVb9ga4U2pA==
   dependencies:
-    "@babel/types" "^7.22.5"
+    "@babel/types" "^7.22.15"
     "@jridgewell/gen-mapping" "^0.3.2"
     "@jridgewell/trace-mapping" "^0.3.17"
     jsesc "^2.5.1"
@@ -118,11 +124,11 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.5.tgz#fc7319fc54c5e2fa14b2909cf3c5fd3046813e02"
   integrity sha512-Ji+ywpHeuqxB8WDxraCiqR0xfhYjiDE/e6k7FuIaANnoOFxAHskHChz4vA1mJC9Lbm01s1PVAGhQY4FUKSkGZw==
   dependencies:
-    "@babel/compat-data" "^7.22.5"
-    "@babel/helper-validator-option" "^7.22.5"
-    browserslist "^4.21.3"
+    "@babel/compat-data" "^7.22.9"
+    "@babel/helper-validator-option" "^7.22.15"
+    browserslist "^4.21.9"
     lru-cache "^5.1.1"
-    semver "^6.3.0"
+    semver "^6.3.1"
 
 "@babel/helper-environment-visitor@^7.22.20":
   version "7.22.20"
@@ -131,7 +137,7 @@
 
 "@babel/helper-environment-visitor@^7.22.5":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz#f06dd41b7c1f44e1f8da6c4055b41ab3a09a7e98"
+  resolved "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.22.5.tgz#f06dd41b7c1f44e1f8da6c4055b41ab3a09a7e98"
   integrity sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==
 
 "@babel/helper-function-name@^7.23.0":
@@ -144,48 +150,45 @@
 
 "@babel/helper-hoist-variables@^7.22.5":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz#c01a007dac05c085914e8fb652b339db50d823bb"
+  resolved "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.22.5.tgz#c01a007dac05c085914e8fb652b339db50d823bb"
   integrity sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==
   dependencies:
     "@babel/types" "^7.22.5"
 
-"@babel/helper-module-imports@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.22.5.tgz#1a8f4c9f4027d23f520bd76b364d44434a72660c"
-  integrity sha512-8Dl6+HD/cKifutF5qGd/8ZJi84QeAKh+CEe1sBzz8UayBBGg1dAIJrdHOcOM5b2MpzWL2yuotJTtGjETq0qjXg==
+"@babel/helper-module-imports@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.22.15.tgz#16146307acdc40cc00c3b2c647713076464bdbf0"
+  integrity sha512-0pYVBnDKZO2fnSPCrgM/6WMc7eS20Fbok+0r88fp+YtWVLZrp4CkafFGIp+W0VKw4a22sgebPT99y+FDNMdP4w==
   dependencies:
-    "@babel/types" "^7.22.5"
+    "@babel/types" "^7.22.15"
 
-"@babel/helper-module-transforms@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.22.5.tgz#0f65daa0716961b6e96b164034e737f60a80d2ef"
-  integrity sha512-+hGKDt/Ze8GFExiVHno/2dvG5IdstpzCq0y4Qc9OJ25D4q3pKfiIP/4Vp3/JvhDkLKsDK2api3q3fpIgiIF5bw==
+"@babel/helper-module-transforms@^7.22.19":
+  version "7.22.19"
+  resolved "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.22.19.tgz#94b1f281caa6518f02ec0f5ea2b5348e298ce266"
+  integrity sha512-m6h1cJvn+OJ+R3jOHp30faq5xKJ7VbjwDj5RGgHuRlU9hrMeKsGC+JpihkR5w1g7IfseCPPtZ0r7/hB4UKaYlA==
   dependencies:
     "@babel/helper-environment-visitor" "^7.22.5"
-    "@babel/helper-module-imports" "^7.22.5"
+    "@babel/helper-module-imports" "^7.22.15"
     "@babel/helper-simple-access" "^7.22.5"
-    "@babel/helper-split-export-declaration" "^7.22.5"
-    "@babel/helper-validator-identifier" "^7.22.5"
-    "@babel/template" "^7.22.5"
-    "@babel/traverse" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/helper-split-export-declaration" "^7.22.6"
+    "@babel/helper-validator-identifier" "^7.22.19"
 
 "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.22.5", "@babel/helper-plugin-utils@^7.8.0":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz#dd7ee3735e8a313b9f7b05a773d892e88e6d7295"
+  resolved "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.22.5.tgz#dd7ee3735e8a313b9f7b05a773d892e88e6d7295"
   integrity sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==
 
 "@babel/helper-simple-access@^7.22.5":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz#4938357dc7d782b80ed6dbb03a0fba3d22b1d5de"
+  resolved "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.22.5.tgz#4938357dc7d782b80ed6dbb03a0fba3d22b1d5de"
   integrity sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==
   dependencies:
     "@babel/types" "^7.22.5"
 
-"@babel/helper-split-export-declaration@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.5.tgz#88cf11050edb95ed08d596f7a044462189127a08"
-  integrity sha512-thqK5QFghPKWLhAV321lxF95yCg2K3Ob5yw+M3VHWfdia0IkPXUtoLH8x/6Fh486QUvzhb8YOWHChTVen2/PoQ==
+"@babel/helper-split-export-declaration@^7.22.6":
+  version "7.22.6"
+  resolved "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c"
+  integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==
   dependencies:
     "@babel/types" "^7.22.5"
 
@@ -198,13 +201,13 @@
 
 "@babel/helper-string-parser@^7.22.5":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f"
+  resolved "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f"
   integrity sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==
 
-"@babel/helper-validator-identifier@^7.19.1", "@babel/helper-validator-identifier@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.5.tgz#9544ef6a33999343c8740fa51350f30eeaaaf193"
-  integrity sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==
+"@babel/helper-validator-identifier@^7.19.1", "@babel/helper-validator-identifier@^7.22.19", "@babel/helper-validator-identifier@^7.22.5":
+  version "7.22.19"
+  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.19.tgz#2f34ab1e445f5b95e2e6edfe50ea2449e610583a"
+  integrity sha512-Tinq7ybnEPFFXhlYOYFiSjespWQk0dq2dRNAiMdRTOYQzEGqnnNyrTxPYHP5r6wGjlF1rFgABdDV0g8EwD6Qbg==
 
 "@babel/helper-validator-identifier@^7.22.20":
   version "7.22.20"
@@ -216,14 +219,14 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz#de52000a15a177413c8234fa3a8af4ee8102d0ac"
   integrity sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw==
 
-"@babel/helpers@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.22.5.tgz#74bb4373eb390d1ceed74a15ef97767e63120820"
-  integrity sha512-pSXRmfE1vzcUIDFQcSGA5Mr+GxBV9oiRKDuDxXvWQQBCh8HoIjs/2DlDB7H8smac1IVrB9/xdXj2N3Wol9Cr+Q==
+"@babel/helpers@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.npmjs.org/@babel/helpers/-/helpers-7.22.15.tgz#f09c3df31e86e3ea0b7ff7556d85cdebd47ea6f1"
+  integrity sha512-7pAjK0aSdxOwR+CcYAqgWOGy5dcfvzsTIfFTb2odQqW47MDfv14UaJDY6eng8ylM2EaeKXdxaSWESbkmaQHTmw==
   dependencies:
-    "@babel/template" "^7.22.5"
-    "@babel/traverse" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/template" "^7.22.15"
+    "@babel/traverse" "^7.22.15"
+    "@babel/types" "^7.22.15"
 
 "@babel/highlight@^7.22.13":
   version "7.22.20"
@@ -240,13 +243,13 @@
   integrity sha512-BSKlD1hgnedS5XRnGOljZawtag7H1yPfQp0tdNJCHoH6AZ+Pcm9VvkrK59/Yy593Ypg0zMxH2BxD1VPYUQ7UIw==
   dependencies:
     "@babel/helper-validator-identifier" "^7.22.5"
-    chalk "^2.0.0"
+    chalk "^2.4.2"
     js-tokens "^4.0.0"
 
-"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.22.5.tgz#721fd042f3ce1896238cf1b341c77eb7dee7dbea"
-  integrity sha512-DFZMC9LJUG9PLOclRC32G63UXwzqS2koQC8dkx+PLdmt1xSePYpbT/NbsrJy8Q/muXz7o/h/d4A7Fuyixm559Q==
+"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.15", "@babel/parser@^7.22.16":
+  version "7.22.16"
+  resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.22.16.tgz#180aead7f247305cce6551bea2720934e2fa2c95"
+  integrity sha512-+gPfKv8UWeKKeJTUxe59+OobVcrYHETCsORl61EmSkmgymguYk/X5bp7GuUIXaFsc6y++v8ZxPsLSSuujqDphA==
 
 "@babel/parser@^7.22.15", "@babel/parser@^7.23.0":
   version "7.23.0"
@@ -255,98 +258,98 @@
 
 "@babel/plugin-syntax-async-generators@^7.8.4":
   version "7.8.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
   integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-bigint@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz#4c9a6f669f5d0cdf1b90a1671e9a146be5300cea"
   integrity sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-class-properties@^7.8.3":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
   integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-syntax-import-meta@^7.8.3":
   version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz#ee601348c370fa334d2207be158777496521fd51"
   integrity sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==
   dependencies:
     "@babel/helper-plugin-utils" "^7.10.4"
 
 "@babel/plugin-syntax-json-strings@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
   integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-jsx@^7.7.2":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.22.5.tgz#a6b68e84fb76e759fc3b93e901876ffabbe1d918"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.22.5.tgz#a6b68e84fb76e759fc3b93e901876ffabbe1d918"
   integrity sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
 
 "@babel/plugin-syntax-logical-assignment-operators@^7.8.3":
   version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
   integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
   dependencies:
     "@babel/helper-plugin-utils" "^7.10.4"
 
 "@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
   integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-numeric-separator@^7.8.3":
   version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
   integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
   dependencies:
     "@babel/helper-plugin-utils" "^7.10.4"
 
 "@babel/plugin-syntax-object-rest-spread@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
   integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-optional-catch-binding@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
   integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-optional-chaining@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
   integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-top-level-await@^7.8.3":
   version "7.14.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c"
   integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.14.5"
 
 "@babel/plugin-syntax-typescript@^7.7.2":
   version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.22.5.tgz#aac8d383b062c5072c647a31ef990c1d0af90272"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.22.5.tgz#aac8d383b062c5072c647a31ef990c1d0af90272"
   integrity sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.22.5"
@@ -365,9 +368,9 @@
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.22.5.tgz#0c8c4d944509875849bd0344ff0050756eefc6ec"
   integrity sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw==
   dependencies:
-    "@babel/code-frame" "^7.22.5"
-    "@babel/parser" "^7.22.5"
-    "@babel/types" "^7.22.5"
+    "@babel/code-frame" "^7.22.13"
+    "@babel/parser" "^7.22.15"
+    "@babel/types" "^7.22.15"
 
 "@babel/traverse@^7.22.5":
   version "7.23.2"
@@ -385,13 +388,13 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.22.5", "@babel/types@^7.3.3":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.22.5.tgz#cd93eeaab025880a3a47ec881f4b096a5b786fbe"
-  integrity sha512-zo3MIHGOkPOfoRXitsgHLjEXmlDaD/5KU1Uzuc9GNiZPhSqVxVRtxuPaSBZDsYZ9qV88AjtMtWW7ww98loJ9KA==
+"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.22.15", "@babel/types@^7.22.19", "@babel/types@^7.22.5", "@babel/types@^7.3.3":
+  version "7.22.19"
+  resolved "https://registry.npmjs.org/@babel/types/-/types-7.22.19.tgz#7425343253556916e440e662bb221a93ddb75684"
+  integrity sha512-P7LAw/LbojPzkgp5oznjE6tQEIWbp4PkkfrZDINTro9zgBRtI324/EYsiSI7lhPbpIQ+DCeR2NNmMWANGGfZsg==
   dependencies:
     "@babel/helper-string-parser" "^7.22.5"
-    "@babel/helper-validator-identifier" "^7.22.5"
+    "@babel/helper-validator-identifier" "^7.22.19"
     to-fast-properties "^2.0.0"
 
 "@babel/types@^7.22.15", "@babel/types@^7.23.0":
@@ -405,261 +408,261 @@
 
 "@bcoe/v8-coverage@^0.2.3":
   version "0.2.3"
-  resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
+  resolved "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
   integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==
 
 "@cspotcode/source-map-support@^0.8.0":
   version "0.8.1"
-  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1"
+  resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1"
   integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
   dependencies:
     "@jridgewell/trace-mapping" "0.3.9"
 
 "@discoveryjs/json-ext@0.5.7":
   version "0.5.7"
-  resolved "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70"
+  resolved "https://registry.npmjs.org/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70"
   integrity sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==
 
 "@esbuild/android-arm64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz#bafb75234a5d3d1b690e7c2956a599345e84a2fd"
+  resolved "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz#bafb75234a5d3d1b690e7c2956a599345e84a2fd"
   integrity sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==
 
 "@esbuild/android-arm64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.19.2.tgz#bc35990f412a749e948b792825eef7df0ce0e073"
+  resolved "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.2.tgz#bc35990f412a749e948b792825eef7df0ce0e073"
   integrity sha512-lsB65vAbe90I/Qe10OjkmrdxSX4UJDjosDgb8sZUKcg3oefEuW2OT2Vozz8ef7wrJbMcmhvCC+hciF8jY/uAkw==
 
 "@esbuild/android-arm@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.17.19.tgz#5898f7832c2298bc7d0ab53701c57beb74d78b4d"
+  resolved "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.17.19.tgz#5898f7832c2298bc7d0ab53701c57beb74d78b4d"
   integrity sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==
 
 "@esbuild/android-arm@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.19.2.tgz#edd1c8f23ba353c197f5b0337123c58ff2a56999"
+  resolved "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.2.tgz#edd1c8f23ba353c197f5b0337123c58ff2a56999"
   integrity sha512-tM8yLeYVe7pRyAu9VMi/Q7aunpLwD139EY1S99xbQkT4/q2qa6eA4ige/WJQYdJ8GBL1K33pPFhPfPdJ/WzT8Q==
 
 "@esbuild/android-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.17.19.tgz#658368ef92067866d95fb268719f98f363d13ae1"
+  resolved "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.17.19.tgz#658368ef92067866d95fb268719f98f363d13ae1"
   integrity sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==
 
 "@esbuild/android-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.19.2.tgz#2dcdd6e6f1f2d82ea1b746abd8da5b284960f35a"
+  resolved "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.2.tgz#2dcdd6e6f1f2d82ea1b746abd8da5b284960f35a"
   integrity sha512-qK/TpmHt2M/Hg82WXHRc/W/2SGo/l1thtDHZWqFq7oi24AjZ4O/CpPSu6ZuYKFkEgmZlFoa7CooAyYmuvnaG8w==
 
 "@esbuild/darwin-arm64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz#584c34c5991b95d4d48d333300b1a4e2ff7be276"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz#584c34c5991b95d4d48d333300b1a4e2ff7be276"
   integrity sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==
 
 "@esbuild/darwin-arm64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.19.2.tgz#55b36bc06d76f5c243987c1f93a11a80d8fc3b26"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.2.tgz#55b36bc06d76f5c243987c1f93a11a80d8fc3b26"
   integrity sha512-Ora8JokrvrzEPEpZO18ZYXkH4asCdc1DLdcVy8TGf5eWtPO1Ie4WroEJzwI52ZGtpODy3+m0a2yEX9l+KUn0tA==
 
 "@esbuild/darwin-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz#7751d236dfe6ce136cce343dce69f52d76b7f6cb"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz#7751d236dfe6ce136cce343dce69f52d76b7f6cb"
   integrity sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==
 
 "@esbuild/darwin-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.19.2.tgz#982524af33a6424a3b5cb44bbd52559623ad719c"
+  resolved "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.2.tgz#982524af33a6424a3b5cb44bbd52559623ad719c"
   integrity sha512-tP+B5UuIbbFMj2hQaUr6EALlHOIOmlLM2FK7jeFBobPy2ERdohI4Ka6ZFjZ1ZYsrHE/hZimGuU90jusRE0pwDw==
 
 "@esbuild/freebsd-arm64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz#cacd171665dd1d500f45c167d50c6b7e539d5fd2"
+  resolved "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz#cacd171665dd1d500f45c167d50c6b7e539d5fd2"
   integrity sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==
 
 "@esbuild/freebsd-arm64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.2.tgz#8e478a0856645265fe79eac4b31b52193011ee06"
+  resolved "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.2.tgz#8e478a0856645265fe79eac4b31b52193011ee06"
   integrity sha512-YbPY2kc0acfzL1VPVK6EnAlig4f+l8xmq36OZkU0jzBVHcOTyQDhnKQaLzZudNJQyymd9OqQezeaBgkTGdTGeQ==
 
 "@esbuild/freebsd-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz#0769456eee2a08b8d925d7c00b79e861cb3162e4"
+  resolved "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz#0769456eee2a08b8d925d7c00b79e861cb3162e4"
   integrity sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==
 
 "@esbuild/freebsd-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.19.2.tgz#01b96604f2540db023c73809bb8ae6cd1692d6f3"
+  resolved "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.2.tgz#01b96604f2540db023c73809bb8ae6cd1692d6f3"
   integrity sha512-nSO5uZT2clM6hosjWHAsS15hLrwCvIWx+b2e3lZ3MwbYSaXwvfO528OF+dLjas1g3bZonciivI8qKR/Hm7IWGw==
 
 "@esbuild/linux-arm64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz#38e162ecb723862c6be1c27d6389f48960b68edb"
+  resolved "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz#38e162ecb723862c6be1c27d6389f48960b68edb"
   integrity sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==
 
 "@esbuild/linux-arm64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.19.2.tgz#7e5d2c7864c5c83ec789b59c77cd9c20d2594916"
+  resolved "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.2.tgz#7e5d2c7864c5c83ec789b59c77cd9c20d2594916"
   integrity sha512-ig2P7GeG//zWlU0AggA3pV1h5gdix0MA3wgB+NsnBXViwiGgY77fuN9Wr5uoCrs2YzaYfogXgsWZbm+HGr09xg==
 
 "@esbuild/linux-arm@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz#1a2cd399c50040184a805174a6d89097d9d1559a"
+  resolved "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz#1a2cd399c50040184a805174a6d89097d9d1559a"
   integrity sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==
 
 "@esbuild/linux-arm@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.19.2.tgz#c32ae97bc0246664a1cfbdb4a98e7b006d7db8ae"
+  resolved "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.2.tgz#c32ae97bc0246664a1cfbdb4a98e7b006d7db8ae"
   integrity sha512-Odalh8hICg7SOD7XCj0YLpYCEc+6mkoq63UnExDCiRA2wXEmGlK5JVrW50vZR9Qz4qkvqnHcpH+OFEggO3PgTg==
 
 "@esbuild/linux-ia32@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz#e28c25266b036ce1cabca3c30155222841dc035a"
+  resolved "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz#e28c25266b036ce1cabca3c30155222841dc035a"
   integrity sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==
 
 "@esbuild/linux-ia32@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.19.2.tgz#3fc4f0fa026057fe885e4a180b3956e704f1ceaa"
+  resolved "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.2.tgz#3fc4f0fa026057fe885e4a180b3956e704f1ceaa"
   integrity sha512-mLfp0ziRPOLSTek0Gd9T5B8AtzKAkoZE70fneiiyPlSnUKKI4lp+mGEnQXcQEHLJAcIYDPSyBvsUbKUG2ri/XQ==
 
 "@esbuild/linux-loong64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz#0f887b8bb3f90658d1a0117283e55dbd4c9dcf72"
+  resolved "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz#0f887b8bb3f90658d1a0117283e55dbd4c9dcf72"
   integrity sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==
 
 "@esbuild/linux-loong64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.19.2.tgz#633bcaea443f3505fb0ed109ab840c99ad3451a4"
+  resolved "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.2.tgz#633bcaea443f3505fb0ed109ab840c99ad3451a4"
   integrity sha512-hn28+JNDTxxCpnYjdDYVMNTR3SKavyLlCHHkufHV91fkewpIyQchS1d8wSbmXhs1fiYDpNww8KTFlJ1dHsxeSw==
 
 "@esbuild/linux-mips64el@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz#f5d2a0b8047ea9a5d9f592a178ea054053a70289"
+  resolved "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz#f5d2a0b8047ea9a5d9f592a178ea054053a70289"
   integrity sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==
 
 "@esbuild/linux-mips64el@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.19.2.tgz#e0bff2898c46f52be7d4dbbcca8b887890805823"
+  resolved "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.2.tgz#e0bff2898c46f52be7d4dbbcca8b887890805823"
   integrity sha512-KbXaC0Sejt7vD2fEgPoIKb6nxkfYW9OmFUK9XQE4//PvGIxNIfPk1NmlHmMg6f25x57rpmEFrn1OotASYIAaTg==
 
 "@esbuild/linux-ppc64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz#876590e3acbd9fa7f57a2c7d86f83717dbbac8c7"
+  resolved "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz#876590e3acbd9fa7f57a2c7d86f83717dbbac8c7"
   integrity sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==
 
 "@esbuild/linux-ppc64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.19.2.tgz#d75798da391f54a9674f8c143b9a52d1dbfbfdde"
+  resolved "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.2.tgz#d75798da391f54a9674f8c143b9a52d1dbfbfdde"
   integrity sha512-dJ0kE8KTqbiHtA3Fc/zn7lCd7pqVr4JcT0JqOnbj4LLzYnp+7h8Qi4yjfq42ZlHfhOCM42rBh0EwHYLL6LEzcw==
 
 "@esbuild/linux-riscv64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz#7f49373df463cd9f41dc34f9b2262d771688bf09"
+  resolved "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz#7f49373df463cd9f41dc34f9b2262d771688bf09"
   integrity sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==
 
 "@esbuild/linux-riscv64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.19.2.tgz#012409bd489ed1bb9b775541d4a46c5ded8e6dd8"
+  resolved "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.2.tgz#012409bd489ed1bb9b775541d4a46c5ded8e6dd8"
   integrity sha512-7Z/jKNFufZ/bbu4INqqCN6DDlrmOTmdw6D0gH+6Y7auok2r02Ur661qPuXidPOJ+FSgbEeQnnAGgsVynfLuOEw==
 
 "@esbuild/linux-s390x@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz#e2afd1afcaf63afe2c7d9ceacd28ec57c77f8829"
+  resolved "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz#e2afd1afcaf63afe2c7d9ceacd28ec57c77f8829"
   integrity sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==
 
 "@esbuild/linux-s390x@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.19.2.tgz#ece3ed75c5a150de8a5c110f02e97d315761626b"
+  resolved "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.2.tgz#ece3ed75c5a150de8a5c110f02e97d315761626b"
   integrity sha512-U+RinR6aXXABFCcAY4gSlv4CL1oOVvSSCdseQmGO66H+XyuQGZIUdhG56SZaDJQcLmrSfRmx5XZOWyCJPRqS7g==
 
 "@esbuild/linux-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz#8a0e9738b1635f0c53389e515ae83826dec22aa4"
+  resolved "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz#8a0e9738b1635f0c53389e515ae83826dec22aa4"
   integrity sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==
 
 "@esbuild/linux-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.19.2.tgz#dea187019741602d57aaf189a80abba261fbd2aa"
+  resolved "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.2.tgz#dea187019741602d57aaf189a80abba261fbd2aa"
   integrity sha512-oxzHTEv6VPm3XXNaHPyUTTte+3wGv7qVQtqaZCrgstI16gCuhNOtBXLEBkBREP57YTd68P0VgDgG73jSD8bwXQ==
 
 "@esbuild/netbsd-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz#c29fb2453c6b7ddef9a35e2c18b37bda1ae5c462"
+  resolved "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz#c29fb2453c6b7ddef9a35e2c18b37bda1ae5c462"
   integrity sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==
 
 "@esbuild/netbsd-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.19.2.tgz#bbfd7cf9ab236a23ee3a41b26f0628c57623d92a"
+  resolved "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.2.tgz#bbfd7cf9ab236a23ee3a41b26f0628c57623d92a"
   integrity sha512-WNa5zZk1XpTTwMDompZmvQLHszDDDN7lYjEHCUmAGB83Bgs20EMs7ICD+oKeT6xt4phV4NDdSi/8OfjPbSbZfQ==
 
 "@esbuild/openbsd-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz#95e75a391403cb10297280d524d66ce04c920691"
+  resolved "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz#95e75a391403cb10297280d524d66ce04c920691"
   integrity sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==
 
 "@esbuild/openbsd-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.19.2.tgz#fa5c4c6ee52a360618f00053652e2902e1d7b4a7"
+  resolved "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.2.tgz#fa5c4c6ee52a360618f00053652e2902e1d7b4a7"
   integrity sha512-S6kI1aT3S++Dedb7vxIuUOb3oAxqxk2Rh5rOXOTYnzN8JzW1VzBd+IqPiSpgitu45042SYD3HCoEyhLKQcDFDw==
 
 "@esbuild/sunos-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz#722eaf057b83c2575937d3ffe5aeb16540da7273"
+  resolved "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz#722eaf057b83c2575937d3ffe5aeb16540da7273"
   integrity sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==
 
 "@esbuild/sunos-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.19.2.tgz#52a2ac8ac6284c02d25df22bb4cfde26fbddd68d"
+  resolved "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.2.tgz#52a2ac8ac6284c02d25df22bb4cfde26fbddd68d"
   integrity sha512-VXSSMsmb+Z8LbsQGcBMiM+fYObDNRm8p7tkUDMPG/g4fhFX5DEFmjxIEa3N8Zr96SjsJ1woAhF0DUnS3MF3ARw==
 
 "@esbuild/win32-arm64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz#9aa9dc074399288bdcdd283443e9aeb6b9552b6f"
+  resolved "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz#9aa9dc074399288bdcdd283443e9aeb6b9552b6f"
   integrity sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==
 
 "@esbuild/win32-arm64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.19.2.tgz#719ed5870855de8537aef8149694a97d03486804"
+  resolved "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.2.tgz#719ed5870855de8537aef8149694a97d03486804"
   integrity sha512-5NayUlSAyb5PQYFAU9x3bHdsqB88RC3aM9lKDAz4X1mo/EchMIT1Q+pSeBXNgkfNmRecLXA0O8xP+x8V+g/LKg==
 
 "@esbuild/win32-ia32@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz#95ad43c62ad62485e210f6299c7b2571e48d2b03"
+  resolved "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz#95ad43c62ad62485e210f6299c7b2571e48d2b03"
   integrity sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==
 
 "@esbuild/win32-ia32@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.19.2.tgz#24832223880b0f581962c8660f8fb8797a1e046a"
+  resolved "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.2.tgz#24832223880b0f581962c8660f8fb8797a1e046a"
   integrity sha512-47gL/ek1v36iN0wL9L4Q2MFdujR0poLZMJwhO2/N3gA89jgHp4MR8DKCmwYtGNksbfJb9JoTtbkoe6sDhg2QTA==
 
 "@esbuild/win32-x64@0.17.19":
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz#8cfaf2ff603e9aabb910e9c0558c26cf32744061"
+  resolved "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz#8cfaf2ff603e9aabb910e9c0558c26cf32744061"
   integrity sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==
 
 "@esbuild/win32-x64@0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.19.2.tgz#1205014625790c7ff0e471644a878a65d1e34ab0"
+  resolved "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.2.tgz#1205014625790c7ff0e471644a878a65d1e34ab0"
   integrity sha512-tcuhV7ncXBqbt/Ybf0IyrMcwVOAPDckMK9rXNHtF17UTK18OKLpg08glminN06pt2WCoALhXdLfSPbVvK/6fxw==
 
 "@eslint-community/eslint-utils@^4.2.0", "@eslint-community/eslint-utils@^4.4.0":
   version "4.4.0"
-  resolved "https://registry.yarnpkg.com/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59"
+  resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz#a23514e8fb9af1269d5f7788aa556798d61c6b59"
   integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==
   dependencies:
     eslint-visitor-keys "^3.3.0"
 
 "@eslint-community/regexpp@^4.4.0":
-  version "4.5.1"
-  resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.5.1.tgz#cdd35dce4fa1a89a4fd42b1599eb35b3af408884"
-  integrity sha512-Z5ba73P98O1KUYCCJTUeVpja9RcGoMdncZ6T49FCUl2lN38JtCJ+3WgIDBv0AuY4WChU5PmtJmOCTlN6FZTFKQ==
+  version "4.8.1"
+  resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.8.1.tgz#8c4bb756cc2aa7eaf13cfa5e69c83afb3260c20c"
+  integrity sha512-PWiOzLIUAjN/w5K17PoF4n6sKBw0gqLHPhywmYHP4t1VFQQVYeb1yWsJwnMVEMl3tUHME7X/SJPZLmtG7XBDxQ==
 
 "@eslint/eslintrc@^2.0.3":
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.0.3.tgz#4910db5505f4d503f27774bf356e3704818a0331"
-  integrity sha512-+5gy6OQfk+xx3q0d6jGZZC3f3KzAkXc/IanVxd1is/VIIziRqqt3ongQz0FiTUXqTk0c7aDB3OaFuKnuSoJicQ==
+  version "2.1.2"
+  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.2.tgz#c6936b4b328c64496692f76944e755738be62396"
+  integrity sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==
   dependencies:
     ajv "^6.12.4"
     debug "^4.3.2"
-    espree "^9.5.2"
+    espree "^9.6.0"
     globals "^13.19.0"
     ignore "^5.2.0"
     import-fresh "^3.2.1"
@@ -669,12 +672,12 @@
 
 "@eslint/js@8.42.0":
   version "8.42.0"
-  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.42.0.tgz#484a1d638de2911e6f5a30c12f49c7e4a3270fb6"
+  resolved "https://registry.npmjs.org/@eslint/js/-/js-8.42.0.tgz#484a1d638de2911e6f5a30c12f49c7e4a3270fb6"
   integrity sha512-6SWlXpWU5AvId8Ac7zjzmIOqMOba/JWY8XZ4A7q7Gn1Vlfg/SFFIlrtHXt9nPn4op9ZPAkl91Jao+QQv3r/ukw==
 
 "@gulp-sourcemaps/identity-map@^2.0.1":
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@gulp-sourcemaps/identity-map/-/identity-map-2.0.1.tgz#a6e8b1abec8f790ec6be2b8c500e6e68037c0019"
+  resolved "https://registry.npmjs.org/@gulp-sourcemaps/identity-map/-/identity-map-2.0.1.tgz#a6e8b1abec8f790ec6be2b8c500e6e68037c0019"
   integrity sha512-Tb+nSISZku+eQ4X1lAkevcQa+jknn/OVUgZ3XCxEKIsLsqYuPoJwJOPQeaOk75X3WPftb29GWY1eqE7GLsXb1Q==
   dependencies:
     acorn "^6.4.1"
@@ -685,16 +688,16 @@
 
 "@gulp-sourcemaps/map-sources@^1.0.0":
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@gulp-sourcemaps/map-sources/-/map-sources-1.0.0.tgz#890ae7c5d8c877f6d384860215ace9d7ec945bda"
+  resolved "https://registry.npmjs.org/@gulp-sourcemaps/map-sources/-/map-sources-1.0.0.tgz#890ae7c5d8c877f6d384860215ace9d7ec945bda"
   integrity sha512-o/EatdaGt8+x2qpb0vFLC/2Gug/xYPRXb6a+ET1wGYKozKN3krDWC/zZFZAtrzxJHuDL12mwdfEFKcKMNvc55A==
   dependencies:
     normalize-path "^2.0.1"
     through2 "^2.0.3"
 
 "@humanwhocodes/config-array@^0.11.10":
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.10.tgz#5a3ffe32cc9306365fb3fd572596cd602d5e12d2"
-  integrity sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==
+  version "0.11.11"
+  resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.11.tgz#88a04c570dbbc7dd943e4712429c3df09bc32844"
+  integrity sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==
   dependencies:
     "@humanwhocodes/object-schema" "^1.2.1"
     debug "^4.1.1"
@@ -702,17 +705,17 @@
 
 "@humanwhocodes/module-importer@^1.0.1":
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
+  resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
   integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
 
 "@humanwhocodes/object-schema@^1.2.1":
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
+  resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
   integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
 
 "@isaacs/cliui@^8.0.2":
   version "8.0.2"
-  resolved "https://registry.yarnpkg.com/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550"
+  resolved "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz#b37667b7bc181c168782259bab42474fbf52b550"
   integrity sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==
   dependencies:
     string-width "^5.1.2"
@@ -724,7 +727,7 @@
 
 "@istanbuljs/load-nyc-config@^1.0.0":
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced"
+  resolved "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced"
   integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==
   dependencies:
     camelcase "^5.3.1"
@@ -735,112 +738,112 @@
 
 "@istanbuljs/schema@^0.1.2":
   version "0.1.3"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
+  resolved "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
   integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==
 
-"@jest/console@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/console/-/console-29.6.2.tgz#bf1d4101347c23e07c029a1b1ae07d550f5cc541"
-  integrity sha512-0N0yZof5hi44HAR2pPS+ikJ3nzKNoZdVu8FffRf3wy47I7Dm7etk/3KetMdRUqzVd16V4O2m2ISpNTbnIuqy1w==
+"@jest/console@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/console/-/console-29.7.0.tgz#cd4822dbdb84529265c5a2bdb529a3c9cc950ffc"
+  integrity sha512-5Ni4CU7XHQi32IJ398EEP4RrB8eV09sXP2ROqD4bksHrnTree52PsxvX8tpL8LvTZ3pFzXyPbNQReSN41CAhOg==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     chalk "^4.0.0"
-    jest-message-util "^29.6.2"
-    jest-util "^29.6.2"
+    jest-message-util "^29.7.0"
+    jest-util "^29.7.0"
     slash "^3.0.0"
 
-"@jest/core@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/core/-/core-29.6.2.tgz#6f2d1dbe8aa0265fcd4fb8082ae1952f148209c8"
-  integrity sha512-Oj+5B+sDMiMWLhPFF+4/DvHOf+U10rgvCLGPHP8Xlsy/7QxS51aU/eBngudHlJXnaWD5EohAgJ4js+T6pa+zOg==
+"@jest/core@^29.6.2", "@jest/core@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/core/-/core-29.7.0.tgz#b6cccc239f30ff36609658c5a5e2291757ce448f"
+  integrity sha512-n7aeXWKMnGtDA48y8TLWJPJmLmmZ642Ceo78cYWEpiD7FzDgmNDV/GCVRorPABdXLJZ/9wzzgZAlHjXjxDHGsg==
   dependencies:
-    "@jest/console" "^29.6.2"
-    "@jest/reporters" "^29.6.2"
-    "@jest/test-result" "^29.6.2"
-    "@jest/transform" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/console" "^29.7.0"
+    "@jest/reporters" "^29.7.0"
+    "@jest/test-result" "^29.7.0"
+    "@jest/transform" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     ansi-escapes "^4.2.1"
     chalk "^4.0.0"
     ci-info "^3.2.0"
     exit "^0.1.2"
     graceful-fs "^4.2.9"
-    jest-changed-files "^29.5.0"
-    jest-config "^29.6.2"
-    jest-haste-map "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-regex-util "^29.4.3"
-    jest-resolve "^29.6.2"
-    jest-resolve-dependencies "^29.6.2"
-    jest-runner "^29.6.2"
-    jest-runtime "^29.6.2"
-    jest-snapshot "^29.6.2"
-    jest-util "^29.6.2"
-    jest-validate "^29.6.2"
-    jest-watcher "^29.6.2"
+    jest-changed-files "^29.7.0"
+    jest-config "^29.7.0"
+    jest-haste-map "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-regex-util "^29.6.3"
+    jest-resolve "^29.7.0"
+    jest-resolve-dependencies "^29.7.0"
+    jest-runner "^29.7.0"
+    jest-runtime "^29.7.0"
+    jest-snapshot "^29.7.0"
+    jest-util "^29.7.0"
+    jest-validate "^29.7.0"
+    jest-watcher "^29.7.0"
     micromatch "^4.0.4"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
     slash "^3.0.0"
     strip-ansi "^6.0.0"
 
-"@jest/environment@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-29.6.2.tgz#794c0f769d85e7553439d107d3f43186dc6874a9"
-  integrity sha512-AEcW43C7huGd/vogTddNNTDRpO6vQ2zaQNrttvWV18ArBx9Z56h7BIsXkNFJVOO4/kblWEQz30ckw0+L3izc+Q==
+"@jest/environment@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/environment/-/environment-29.7.0.tgz#24d61f54ff1f786f3cd4073b4b94416383baf2a7"
+  integrity sha512-aQIfHDq33ExsN4jP1NWGXhxgQ/wixs60gDiKO+XVMd8Mn0NWPWgc34ZQDTb2jKaUWQ7MuwoitXAsN2XVXNMpAw==
   dependencies:
-    "@jest/fake-timers" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/fake-timers" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
-    jest-mock "^29.6.2"
+    jest-mock "^29.7.0"
 
-"@jest/expect-utils@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/expect-utils/-/expect-utils-29.6.2.tgz#1b97f290d0185d264dd9fdec7567a14a38a90534"
-  integrity sha512-6zIhM8go3RV2IG4aIZaZbxwpOzz3ZiM23oxAlkquOIole+G6TrbeXnykxWYlqF7kz2HlBjdKtca20x9atkEQYg==
+"@jest/expect-utils@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.7.0.tgz#023efe5d26a8a70f21677d0a1afc0f0a44e3a1c6"
+  integrity sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==
   dependencies:
-    jest-get-type "^29.4.3"
+    jest-get-type "^29.6.3"
 
-"@jest/expect@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/expect/-/expect-29.6.2.tgz#5a2ad58bb345165d9ce0a1845bbf873c480a4b28"
-  integrity sha512-m6DrEJxVKjkELTVAztTLyS/7C92Y2b0VYqmDROYKLLALHn8T/04yPs70NADUYPrV3ruI+H3J0iUIuhkjp7vkfg==
+"@jest/expect@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/expect/-/expect-29.7.0.tgz#76a3edb0cb753b70dfbfe23283510d3d45432bf2"
+  integrity sha512-8uMeAMycttpva3P1lBHB8VciS9V0XAr3GymPpipdyQXbBcuhkLQOSe8E/p92RyAdToS6ZD1tFkX+CkhoECE0dQ==
   dependencies:
-    expect "^29.6.2"
-    jest-snapshot "^29.6.2"
+    expect "^29.7.0"
+    jest-snapshot "^29.7.0"
 
-"@jest/fake-timers@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/fake-timers/-/fake-timers-29.6.2.tgz#fe9d43c5e4b1b901168fe6f46f861b3e652a2df4"
-  integrity sha512-euZDmIlWjm1Z0lJ1D0f7a0/y5Kh/koLFMUBE5SUYWrmy8oNhJpbTBDAP6CxKnadcMLDoDf4waRYCe35cH6G6PA==
+"@jest/fake-timers@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-29.7.0.tgz#fd91bf1fffb16d7d0d24a426ab1a47a49881a565"
+  integrity sha512-q4DH1Ha4TTFPdxLsqDXK1d3+ioSL7yL5oCMJZgDYm6i+6CygW5E5xVr/D1HdsGxjt1ZWSfUAs9OxSB/BNelWrQ==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@sinonjs/fake-timers" "^10.0.2"
     "@types/node" "*"
-    jest-message-util "^29.6.2"
-    jest-mock "^29.6.2"
-    jest-util "^29.6.2"
+    jest-message-util "^29.7.0"
+    jest-mock "^29.7.0"
+    jest-util "^29.7.0"
 
-"@jest/globals@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-29.6.2.tgz#74af81b9249122cc46f1eb25793617eec69bf21a"
-  integrity sha512-cjuJmNDjs6aMijCmSa1g2TNG4Lby/AeU7/02VtpW+SLcZXzOLK2GpN2nLqcFjmhy3B3AoPeQVx7BnyOf681bAw==
+"@jest/globals@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/globals/-/globals-29.7.0.tgz#8d9290f9ec47ff772607fa864ca1d5a2efae1d4d"
+  integrity sha512-mpiz3dutLbkW2MNFubUGUEVLkTGiqW6yLVTA+JbP6fI6J5iL9Y0Nlg8k95pcF8ctKwCS7WVxteBs29hhfAotzQ==
   dependencies:
-    "@jest/environment" "^29.6.2"
-    "@jest/expect" "^29.6.2"
-    "@jest/types" "^29.6.1"
-    jest-mock "^29.6.2"
+    "@jest/environment" "^29.7.0"
+    "@jest/expect" "^29.7.0"
+    "@jest/types" "^29.6.3"
+    jest-mock "^29.7.0"
 
-"@jest/reporters@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/reporters/-/reporters-29.6.2.tgz#524afe1d76da33d31309c2c4a2c8062d0c48780a"
-  integrity sha512-sWtijrvIav8LgfJZlrGCdN0nP2EWbakglJY49J1Y5QihcQLfy7ovyxxjJBRXMNltgt4uPtEcFmIMbVshEDfFWw==
+"@jest/reporters@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/reporters/-/reporters-29.7.0.tgz#04b262ecb3b8faa83b0b3d321623972393e8f4c7"
+  integrity sha512-DApq0KJbJOEzAFYjHADNNxAE3KbhxQB1y5Kplb5Waqw6zVbuWatSnMjE5gs8FUgEPmNsnZA3NCWl9NG0ia04Pg==
   dependencies:
     "@bcoe/v8-coverage" "^0.2.3"
-    "@jest/console" "^29.6.2"
-    "@jest/test-result" "^29.6.2"
-    "@jest/transform" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/console" "^29.7.0"
+    "@jest/test-result" "^29.7.0"
+    "@jest/transform" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@jridgewell/trace-mapping" "^0.3.18"
     "@types/node" "*"
     chalk "^4.0.0"
@@ -849,70 +852,70 @@
     glob "^7.1.3"
     graceful-fs "^4.2.9"
     istanbul-lib-coverage "^3.0.0"
-    istanbul-lib-instrument "^5.1.0"
+    istanbul-lib-instrument "^6.0.0"
     istanbul-lib-report "^3.0.0"
     istanbul-lib-source-maps "^4.0.0"
     istanbul-reports "^3.1.3"
-    jest-message-util "^29.6.2"
-    jest-util "^29.6.2"
-    jest-worker "^29.6.2"
+    jest-message-util "^29.7.0"
+    jest-util "^29.7.0"
+    jest-worker "^29.7.0"
     slash "^3.0.0"
     string-length "^4.0.1"
     strip-ansi "^6.0.0"
     v8-to-istanbul "^9.0.1"
 
-"@jest/schemas@^29.6.0":
-  version "29.6.0"
-  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.0.tgz#0f4cb2c8e3dca80c135507ba5635a4fd755b0040"
-  integrity sha512-rxLjXyJBTL4LQeJW3aKo0M/+GkCOXsO+8i9Iu7eDb6KwtP65ayoDsitrdPBtujxQ88k4wI2FNYfa6TOGwSn6cQ==
+"@jest/schemas@^29.6.3":
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz#430b5ce8a4e0044a7e3819663305a7b3091c8e03"
+  integrity sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==
   dependencies:
     "@sinclair/typebox" "^0.27.8"
 
-"@jest/source-map@^29.6.0":
-  version "29.6.0"
-  resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-29.6.0.tgz#bd34a05b5737cb1a99d43e1957020ac8e5b9ddb1"
-  integrity sha512-oA+I2SHHQGxDCZpbrsCQSoMLb3Bz547JnM+jUr9qEbuw0vQlWZfpPS7CO9J7XiwKicEz9OFn/IYoLkkiUD7bzA==
+"@jest/source-map@^29.6.3":
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/@jest/source-map/-/source-map-29.6.3.tgz#d90ba772095cf37a34a5eb9413f1b562a08554c4"
+  integrity sha512-MHjT95QuipcPrpLM+8JMSzFx6eHp5Bm+4XeFDJlwsvVBjmKNiIAvasGK2fxz2WbGRlnvqehFbh07MMa7n3YJnw==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.18"
     callsites "^3.0.0"
     graceful-fs "^4.2.9"
 
-"@jest/test-result@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/test-result/-/test-result-29.6.2.tgz#fdd11583cd1608e4db3114e8f0cce277bf7a32ed"
-  integrity sha512-3VKFXzcV42EYhMCsJQURptSqnyjqCGbtLuX5Xxb6Pm6gUf1wIRIl+mandIRGJyWKgNKYF9cnstti6Ls5ekduqw==
+"@jest/test-result@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/test-result/-/test-result-29.7.0.tgz#8db9a80aa1a097bb2262572686734baed9b1657c"
+  integrity sha512-Fdx+tv6x1zlkJPcWXmMDAG2HBnaR9XPSd5aDWQVsfrZmLVT3lU1cwyxLgRmXR9yrq4NBoEm9BMsfgFzTQAbJYA==
   dependencies:
-    "@jest/console" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/console" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/istanbul-lib-coverage" "^2.0.0"
     collect-v8-coverage "^1.0.0"
 
-"@jest/test-sequencer@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/test-sequencer/-/test-sequencer-29.6.2.tgz#585eff07a68dd75225a7eacf319780cb9f6b9bf4"
-  integrity sha512-GVYi6PfPwVejO7slw6IDO0qKVum5jtrJ3KoLGbgBWyr2qr4GaxFV6su+ZAjdTX75Sr1DkMFRk09r2ZVa+wtCGw==
+"@jest/test-sequencer@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-29.7.0.tgz#6cef977ce1d39834a3aea887a1726628a6f072ce"
+  integrity sha512-GQwJ5WZVrKnOJuiYiAF52UNUJXgTZx1NHjFSEB0qEMmSZKAkdMoIzw/Cj6x6NF4AvV23AUqDpFzQkN/eYCYTxw==
   dependencies:
-    "@jest/test-result" "^29.6.2"
+    "@jest/test-result" "^29.7.0"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.6.2"
+    jest-haste-map "^29.7.0"
     slash "^3.0.0"
 
-"@jest/transform@^29.6.2":
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/transform/-/transform-29.6.2.tgz#522901ebbb211af08835bc3bcdf765ab778094e3"
-  integrity sha512-ZqCqEISr58Ce3U+buNFJYUktLJZOggfyvR+bZMaiV1e8B1SIvJbwZMrYz3gx/KAPn9EXmOmN+uB08yLCjWkQQg==
+"@jest/transform@^29.7.0":
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/@jest/transform/-/transform-29.7.0.tgz#df2dd9c346c7d7768b8a06639994640c642e284c"
+  integrity sha512-ok/BTPFzFKVMwO5eOHRrvnBVHdRy9IrsrW1GpMaQ9MCnilNLXQKmAX8s1YXDFaai9xJpac2ySzV0YeRRECr2Vw==
   dependencies:
     "@babel/core" "^7.11.6"
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@jridgewell/trace-mapping" "^0.3.18"
     babel-plugin-istanbul "^6.1.1"
     chalk "^4.0.0"
     convert-source-map "^2.0.0"
     fast-json-stable-stringify "^2.1.0"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.6.2"
-    jest-regex-util "^29.4.3"
-    jest-util "^29.6.2"
+    jest-haste-map "^29.7.0"
+    jest-regex-util "^29.6.3"
+    jest-util "^29.7.0"
     micromatch "^4.0.4"
     pirates "^4.0.4"
     slash "^3.0.0"
@@ -920,7 +923,7 @@
 
 "@jest/types@^26.6.2":
   version "26.6.2"
-  resolved "https://registry.yarnpkg.com/@jest/types/-/types-26.6.2.tgz#bef5a532030e1d88a2f5a6d933f84e97226ed48e"
+  resolved "https://registry.npmjs.org/@jest/types/-/types-26.6.2.tgz#bef5a532030e1d88a2f5a6d933f84e97226ed48e"
   integrity sha512-fC6QCp7Sc5sX6g8Tvbmj4XUTbyrik0akgRy03yjXbQaBWWNWGE7SGtJk98m0N8nzegD/7SggrUlivxo5ax4KWQ==
   dependencies:
     "@types/istanbul-lib-coverage" "^2.0.0"
@@ -929,12 +932,12 @@
     "@types/yargs" "^15.0.0"
     chalk "^4.0.0"
 
-"@jest/types@^29.6.1":
-  version "29.6.1"
-  resolved "https://registry.yarnpkg.com/@jest/types/-/types-29.6.1.tgz#ae79080278acff0a6af5eb49d063385aaa897bf2"
-  integrity sha512-tPKQNMPuXgvdOn2/Lg9HNfUvjYVGolt04Hp03f5hAk878uwOLikN+JzeLY0HcVgKgFl9Hs3EIqpu3WX27XNhnw==
+"@jest/types@^29.6.1", "@jest/types@^29.6.3":
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz#1131f8cf634e7e84c5e77bab12f052af585fba59"
+  integrity sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==
   dependencies:
-    "@jest/schemas" "^29.6.0"
+    "@jest/schemas" "^29.6.3"
     "@types/istanbul-lib-coverage" "^2.0.0"
     "@types/istanbul-reports" "^3.0.0"
     "@types/node" "*"
@@ -943,65 +946,47 @@
 
 "@jridgewell/gen-mapping@^0.3.0", "@jridgewell/gen-mapping@^0.3.2":
   version "0.3.3"
-  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098"
+  resolved "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098"
   integrity sha512-HLhSWOLRi875zjjMG/r+Nv0oCW8umGb0BgEhyX3dDX3egwZtB8PqLnjz3yedt8R5StBrzcg4aBpnh8UA9D1BoQ==
   dependencies:
     "@jridgewell/set-array" "^1.0.1"
     "@jridgewell/sourcemap-codec" "^1.4.10"
     "@jridgewell/trace-mapping" "^0.3.9"
 
-"@jridgewell/resolve-uri@3.1.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78"
-  integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==
-
 "@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0":
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721"
+  resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721"
   integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==
 
 "@jridgewell/set-array@^1.0.1":
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72"
+  resolved "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72"
   integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==
 
 "@jridgewell/source-map@^0.3.3":
-  version "0.3.3"
-  resolved "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.3.tgz#8108265659d4c33e72ffe14e33d6cc5eb59f2fda"
-  integrity sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==
+  version "0.3.5"
+  resolved "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.5.tgz#a3bb4d5c6825aab0d281268f47f6ad5853431e91"
+  integrity sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==
   dependencies:
     "@jridgewell/gen-mapping" "^0.3.0"
     "@jridgewell/trace-mapping" "^0.3.9"
 
-"@jridgewell/sourcemap-codec@1.4.14":
-  version "1.4.14"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24"
-  integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==
-
 "@jridgewell/sourcemap-codec@^1.4.10", "@jridgewell/sourcemap-codec@^1.4.14":
   version "1.4.15"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
+  resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
   integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
 
 "@jridgewell/trace-mapping@0.3.9":
   version "0.3.9"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
+  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
   integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
   dependencies:
     "@jridgewell/resolve-uri" "^3.0.3"
     "@jridgewell/sourcemap-codec" "^1.4.10"
 
-"@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.9":
-  version "0.3.18"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.18.tgz#25783b2086daf6ff1dcb53c9249ae480e4dd4cd6"
-  integrity sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==
-  dependencies:
-    "@jridgewell/resolve-uri" "3.1.0"
-    "@jridgewell/sourcemap-codec" "1.4.14"
-
-"@jridgewell/trace-mapping@^0.3.18":
+"@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.18", "@jridgewell/trace-mapping@^0.3.9":
   version "0.3.19"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.19.tgz#f8a3249862f91be48d3127c3cfe992f79b4b8811"
+  resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.19.tgz#f8a3249862f91be48d3127c3cfe992f79b4b8811"
   integrity sha512-kf37QtfW+Hwx/buWGMPcR60iF9ziHa6r/CZJIHbmcm4+0qrXiVdxegAH0F6yddEVQ7zdkjcGCgCzUu+BcbhQxw==
   dependencies:
     "@jridgewell/resolve-uri" "^3.1.0"
@@ -1009,7 +994,7 @@
 
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
+  resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
   integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
   dependencies:
     "@nodelib/fs.stat" "2.0.5"
@@ -1017,12 +1002,12 @@
 
 "@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
+  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
   integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
 
 "@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8":
   version "1.2.8"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
+  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
   integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
   dependencies:
     "@nodelib/fs.scandir" "2.1.5"
@@ -1030,29 +1015,29 @@
 
 "@openpgp/web-stream-tools@0.0.13":
   version "0.0.13"
-  resolved "https://registry.yarnpkg.com/@openpgp/web-stream-tools/-/web-stream-tools-0.0.13.tgz#f0be50120c152efb11b65df29ab482dc192dbbd7"
+  resolved "https://registry.npmjs.org/@openpgp/web-stream-tools/-/web-stream-tools-0.0.13.tgz#f0be50120c152efb11b65df29ab482dc192dbbd7"
   integrity sha512-VQ0O0lUcD9ilLcMLQMJMgPhp8fDgMd4copd+UhSBGjud0vbI1ONQ3ffAhixEMml/AApLJtqCpd7PJcccPliFSA==
 
 "@pkgjs/parseargs@^0.11.0":
   version "0.11.0"
-  resolved "https://registry.yarnpkg.com/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
+  resolved "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz#a77ea742fab25775145434eb1d2328cf5013ac33"
   integrity sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==
 
 "@polka/url@^1.0.0-next.20":
-  version "1.0.0-next.21"
-  resolved "https://registry.yarnpkg.com/@polka/url/-/url-1.0.0-next.21.tgz#5de5a2385a35309427f6011992b544514d559aa1"
-  integrity sha512-a5Sab1C4/icpTZVzZc5Ghpz88yQtGOyNqYXcZgOssB2uuAr+wF/MvN6bgtW32q7HHrvBki+BsZ0OuNv6EV3K9g==
+  version "1.0.0-next.23"
+  resolved "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.23.tgz#498e41218ab3b6a1419c735e5c6ae2c5ed609b6c"
+  integrity sha512-C16M+IYz0rgRhWZdCmK+h58JMv8vijAA61gmz2rspCSwKwzBebpdcsiUmwrtJRdphuY30i6BSLEOP8ppbNLyLg==
 
 "@rollup/plugin-alias@5.0.0":
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-5.0.0.tgz#70f3d504bd17d8922e35c6b61c08b40a6ec25af2"
+  resolved "https://registry.npmjs.org/@rollup/plugin-alias/-/plugin-alias-5.0.0.tgz#70f3d504bd17d8922e35c6b61c08b40a6ec25af2"
   integrity sha512-l9hY5chSCjuFRPsnRm16twWBiSApl2uYFLsepQYwtBuAxNMQ/1dJqADld40P0Jkqm65GRTLy/AC6hnpVebtLsA==
   dependencies:
     slash "^4.0.0"
 
 "@rollup/plugin-node-resolve@15.1.0":
   version "15.1.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.1.0.tgz#9ffcd8e8c457080dba89bb9fcb583a6778dc757e"
+  resolved "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.1.0.tgz#9ffcd8e8c457080dba89bb9fcb583a6778dc757e"
   integrity sha512-xeZHCgsiZ9pzYVgAo9580eCGqwh/XCEUM9q6iQfGNocjgkufHAqC3exA+45URvhiYV8sBF9RlBai650eNs7AsA==
   dependencies:
     "@rollup/pluginutils" "^5.0.1"
@@ -1063,9 +1048,9 @@
     resolve "^1.22.1"
 
 "@rollup/pluginutils@^5.0.1":
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-5.0.2.tgz#012b8f53c71e4f6f9cb317e311df1404f56e7a33"
-  integrity sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==
+  version "5.0.4"
+  resolved "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.0.4.tgz#74f808f9053d33bafec0cc98e7b835c9667d32ba"
+  integrity sha512-0KJnIoRI8A+a1dqOYLxH8vBf8bphDmty5QvIm2hqm7oFCFYKCAZWWd2hXgMibaPsNDhI0AtpYfQZJG47pt/k4g==
   dependencies:
     "@types/estree" "^1.0.0"
     estree-walker "^2.0.2"
@@ -1073,51 +1058,131 @@
 
 "@rollup/stream@3.0.0":
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/stream/-/stream-3.0.0.tgz#8578177aa992e1e7d932d7b8b9ac302ce272663e"
+  resolved "https://registry.npmjs.org/@rollup/stream/-/stream-3.0.0.tgz#8578177aa992e1e7d932d7b8b9ac302ce272663e"
   integrity sha512-rCctaa32QWDmbO/NyZPE3fKbpi4RHmR3N/mPvCYaig7ieSsDg4uSudKkIsaDHuLuYpvNII8kPwgXs1k077lAPg==
 
 "@sinclair/typebox@^0.27.8":
   version "0.27.8"
-  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
+  resolved "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
   integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==
 
 "@sinonjs/commons@^3.0.0":
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@sinonjs/commons/-/commons-3.0.0.tgz#beb434fe875d965265e04722ccfc21df7f755d72"
+  resolved "https://registry.npmjs.org/@sinonjs/commons/-/commons-3.0.0.tgz#beb434fe875d965265e04722ccfc21df7f755d72"
   integrity sha512-jXBtWAF4vmdNmZgD5FoKsVLv3rPgDnLgPbU84LIJ3otV44vJlDRokVng5v8NFJdCf/da9legHcKaRuZs4L7faA==
   dependencies:
     type-detect "4.0.8"
 
 "@sinonjs/fake-timers@^10.0.2":
-  version "10.2.0"
-  resolved "https://registry.yarnpkg.com/@sinonjs/fake-timers/-/fake-timers-10.2.0.tgz#b3e322a34c5f26e3184e7f6115695f299c1b1194"
-  integrity sha512-OPwQlEdg40HAj5KNF8WW6q2KG4Z+cBCZb3m4ninfTZKaBmbIJodviQsDBoYMPHkOyJJMHnOJo5j2+LKDOhOACg==
+  version "10.3.0"
+  resolved "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-10.3.0.tgz#55fdff1ecab9f354019129daf4df0dd4d923ea66"
+  integrity sha512-V4BG07kuYSUkTCSBHG8G8TNhM+F19jXFWnQtzj+we8DrkpSBCee9Z3Ms8yiGer/dlmhe35/Xdgyo3/0rQKg7YA==
   dependencies:
     "@sinonjs/commons" "^3.0.0"
 
+"@swc/core-darwin-arm64@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-darwin-arm64/-/core-darwin-arm64-1.3.82.tgz#bbf9874747b51053d8a59ea26c3e235c326f24a3"
+  integrity sha512-JfsyDW34gVKD3uE0OUpUqYvAD3yseEaicnFP6pB292THtLJb0IKBBnK50vV/RzEJtc1bR3g1kNfxo2PeurZTrA==
+
+"@swc/core-darwin-x64@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-darwin-x64/-/core-darwin-x64-1.3.82.tgz#145cdde16678e0d793620035783e5b413a16ac43"
+  integrity sha512-ogQWgNMq7qTpITjcP3dnzkFNj7bh6SwMr859GvtOTrE75H7L7jDWxESfH4f8foB/LGxBKiDNmxKhitCuAsZK4A==
+
+"@swc/core-linux-arm-gnueabihf@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-linux-arm-gnueabihf/-/core-linux-arm-gnueabihf-1.3.82.tgz#0c2f32c5793f2ac8e8ccf416aec84d016c30ef7b"
+  integrity sha512-7TMXG1lXlNhD0kUiEqs+YlGV4irAdBa2quuy+XI3oJf2fBK6dQfEq4xBy65B3khrorzQS3O0oDGQ+cmdpHExHA==
+
+"@swc/core-linux-arm64-gnu@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-linux-arm64-gnu/-/core-linux-arm64-gnu-1.3.82.tgz#2313d4901fa0ebdd2a0f189909073e1e8a07f1d6"
+  integrity sha512-26JkOujbzcItPAmIbD5vHJxQVy5ihcSu3YHTKwope1h28sApZdtE7S3e2G3gsZRTIdsCQkXUtAQeqHxGWWR3pw==
+
+"@swc/core-linux-arm64-musl@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-linux-arm64-musl/-/core-linux-arm64-musl-1.3.82.tgz#6e96cf6e52e647fecf27511d766bea90e96f8a2f"
+  integrity sha512-8Izj9tuuMpoc3cqiPBRtwqpO1BZ/+sfZVsEhLxrbOFlcSb8LnKyMle1g3JMMUwI4EU75RGVIzZMn8A6GOKdJbA==
+
+"@swc/core-linux-x64-gnu@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-linux-x64-gnu/-/core-linux-x64-gnu-1.3.82.tgz#6275c10d7c8c0768550bc7934c9dd8cde4881d92"
+  integrity sha512-0GSrIBScQwTaPv46T2qB7XnDYxndRCpwH4HMjh6FN+I+lfPUhTSJKW8AonqrqT1TbpFIgvzQs7EnTsD7AnSCow==
+
+"@swc/core-linux-x64-musl@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-linux-x64-musl/-/core-linux-x64-musl-1.3.82.tgz#edb98c30bd0de42bf1a63469937630d942c71988"
+  integrity sha512-KJUnaaepDKNzrEbwz4jv0iC3/t9x0NSoe06fnkAlhh2+NFKWKKJhVCOBTrpds8n7eylBDIXUlK34XQafjVMUdg==
+
+"@swc/core-win32-arm64-msvc@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-win32-arm64-msvc/-/core-win32-arm64-msvc-1.3.82.tgz#0a8e9b361aac37d01f684c8a3d3e94e5f8c3b14f"
+  integrity sha512-TR3MHKhDYIyGyFcyl2d/p1ftceXcubAhX5wRSOdtOyr5+K/v3jbyCCqN7bbqO5o43wQVCwwR/drHleYyDZvg8Q==
+
+"@swc/core-win32-ia32-msvc@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-win32-ia32-msvc/-/core-win32-ia32-msvc-1.3.82.tgz#096854ff764282766271f1354ee1214358a8bf01"
+  integrity sha512-ZX4HzVVt6hs84YUg70UvyBJnBOIspmQQM0iXSzBvOikk3zRoN7BnDwQH4GScvevCEBuou60+i4I6d5kHLOfh8Q==
+
+"@swc/core-win32-x64-msvc@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core-win32-x64-msvc/-/core-win32-x64-msvc-1.3.82.tgz#1181070bff4a13a7fcc7f1020eef1571f8c1257a"
+  integrity sha512-4mJMnex21kbQoaHeAmHnVwQN9/XAfPszJ6n9HI7SVH+aAHnbBIR0M59/b50/CJMjTj5niUGk7EwQ3nhVNOG32g==
+
+"@swc/core@1.3.82":
+  version "1.3.82"
+  resolved "https://registry.npmjs.org/@swc/core/-/core-1.3.82.tgz#8f6c53db3c23a1769b6c5085fbcb3b1df9548a40"
+  integrity sha512-jpC1a18HMH67018Ij2jh+hT7JBFu7ZKcQVfrZ8K6JuEY+kjXmbea07P9MbQUZbAe0FB+xi3CqEVCP73MebodJQ==
+  dependencies:
+    "@swc/types" "^0.1.4"
+  optionalDependencies:
+    "@swc/core-darwin-arm64" "1.3.82"
+    "@swc/core-darwin-x64" "1.3.82"
+    "@swc/core-linux-arm-gnueabihf" "1.3.82"
+    "@swc/core-linux-arm64-gnu" "1.3.82"
+    "@swc/core-linux-arm64-musl" "1.3.82"
+    "@swc/core-linux-x64-gnu" "1.3.82"
+    "@swc/core-linux-x64-musl" "1.3.82"
+    "@swc/core-win32-arm64-msvc" "1.3.82"
+    "@swc/core-win32-ia32-msvc" "1.3.82"
+    "@swc/core-win32-x64-msvc" "1.3.82"
+
+"@swc/helpers@^0.5.2":
+  version "0.5.2"
+  resolved "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.2.tgz#85ea0c76450b61ad7d10a37050289eded783c27d"
+  integrity sha512-E4KcWTpoLHqwPHLxidpOqQbcrZVgi0rsmmZXUle1jXmJfuIf/UWpczUJ7MZZ5tlxytgJXyp0w4PGkkeLiuIdZw==
+  dependencies:
+    tslib "^2.4.0"
+
+"@swc/types@^0.1.4":
+  version "0.1.4"
+  resolved "https://registry.npmjs.org/@swc/types/-/types-0.1.4.tgz#8d647e111dc97a8e2881bf71c2ee2d011698ff10"
+  integrity sha512-z/G02d+59gyyUb7KYhKi9jOhicek6QD2oMaotUyG+lUkybpXoV49dY9bj7Ah5Q+y7knK2jU67UTX9FyfGzaxQg==
+
 "@tsconfig/node10@^1.0.7":
   version "1.0.9"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"
+  resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"
   integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==
 
 "@tsconfig/node12@^1.0.7":
   version "1.0.11"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d"
+  resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d"
   integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
 
 "@tsconfig/node14@^1.0.0":
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1"
+  resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1"
   integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
 
 "@tsconfig/node16@^1.0.2":
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
+  resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
   integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
 
 "@types/babel__core@^7.1.14":
   version "7.20.1"
-  resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.20.1.tgz#916ecea274b0c776fec721e333e55762d3a9614b"
+  resolved "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.1.tgz#916ecea274b0c776fec721e333e55762d3a9614b"
   integrity sha512-aACu/U/omhdk15O4Nfb+fHgH/z3QsfQzpnvRZhYhThms83ZnAOZz7zZAWO7mn2yyNQaA4xTO8GLK3uqFU4bYYw==
   dependencies:
     "@babel/parser" "^7.20.7"
@@ -1128,14 +1193,14 @@
 
 "@types/babel__generator@*":
   version "7.6.4"
-  resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.4.tgz#1f20ce4c5b1990b37900b63f050182d28c2439b7"
+  resolved "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.6.4.tgz#1f20ce4c5b1990b37900b63f050182d28c2439b7"
   integrity sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg==
   dependencies:
     "@babel/types" "^7.0.0"
 
 "@types/babel__template@*":
   version "7.4.1"
-  resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.1.tgz#3d1a48fd9d6c0edfd56f2ff578daed48f36c8969"
+  resolved "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.1.tgz#3d1a48fd9d6c0edfd56f2ff578daed48f36c8969"
   integrity sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==
   dependencies:
     "@babel/parser" "^7.1.0"
@@ -1143,55 +1208,55 @@
 
 "@types/babel__traverse@*", "@types/babel__traverse@^7.0.6":
   version "7.20.1"
-  resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.20.1.tgz#dd6f1d2411ae677dcb2db008c962598be31d6acf"
+  resolved "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.1.tgz#dd6f1d2411ae677dcb2db008c962598be31d6acf"
   integrity sha512-MitHFXnhtgwsGZWtT68URpOvLN4EREih1u3QtQiN4VdAxWKRVvGCSvw/Qth0M0Qq3pJpnGOu5JaM/ydK7OGbqg==
   dependencies:
     "@babel/types" "^7.20.7"
 
 "@types/benchmark@2.1.2":
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/@types/benchmark/-/benchmark-2.1.2.tgz#b7838408c93dc08ceb4e6e13147dbfbe6a151f82"
+  resolved "https://registry.npmjs.org/@types/benchmark/-/benchmark-2.1.2.tgz#b7838408c93dc08ceb4e6e13147dbfbe6a151f82"
   integrity sha512-EDKtLYNMKrig22jEvhXq8TBFyFgVNSPmDF2b9UzJ7+eylPqdZVo17PCUMkn1jP6/1A/0u78VqYC6VrX6b8pDWA==
 
-"@types/command-line-args@5.2.0":
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/@types/command-line-args/-/command-line-args-5.2.0.tgz#adbb77980a1cc376bb208e3f4142e907410430f6"
-  integrity sha512-UuKzKpJJ/Ief6ufIaIzr3A/0XnluX7RvFgwkV89Yzvm77wCh1kFaFmqN8XEnGcN62EuHdedQjEMb8mYxFLGPyA==
+"@types/command-line-args@^5.2.1":
+  version "5.2.1"
+  resolved "https://registry.npmjs.org/@types/command-line-args/-/command-line-args-5.2.1.tgz#233bd1ba687e84ecbec0388e09f9ec9ebf63c55b"
+  integrity sha512-U2OcmS2tj36Yceu+mRuPyUV0ILfau/h5onStcSCzqTENsq0sBiAp2TmaXu1k8fY4McLcPKSYl9FRzn2hx5bI+w==
 
-"@types/command-line-usage@5.0.2":
+"@types/command-line-usage@^5.0.2":
   version "5.0.2"
-  resolved "https://registry.yarnpkg.com/@types/command-line-usage/-/command-line-usage-5.0.2.tgz#ba5e3f6ae5a2009d466679cc431b50635bf1a064"
+  resolved "https://registry.npmjs.org/@types/command-line-usage/-/command-line-usage-5.0.2.tgz#ba5e3f6ae5a2009d466679cc431b50635bf1a064"
   integrity sha512-n7RlEEJ+4x4TS7ZQddTmNSxP+zziEG0TNsMfiRIxcIVXt71ENJ9ojeXmGO3wPoTdn7pJcU2xc3CJYMktNT6DPg==
 
 "@types/eslint-scope@^3.7.3":
   version "3.7.4"
-  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.4.tgz#37fc1223f0786c39627068a12e94d6e6fc61de16"
+  resolved "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.4.tgz#37fc1223f0786c39627068a12e94d6e6fc61de16"
   integrity sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==
   dependencies:
     "@types/eslint" "*"
     "@types/estree" "*"
 
 "@types/eslint@*":
-  version "8.40.1"
-  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.40.1.tgz#92edc592c3575b52a8e790cd5ec04efe28f3d24c"
-  integrity sha512-vRb792M4mF1FBT+eoLecmkpLXwxsBHvWWRGJjzbYANBM6DtiJc6yETyv4rqDA6QNjF1pkj1U7LMA6dGb3VYlHw==
+  version "8.44.2"
+  resolved "https://registry.npmjs.org/@types/eslint/-/eslint-8.44.2.tgz#0d21c505f98a89b8dd4d37fa162b09da6089199a"
+  integrity sha512-sdPRb9K6iL5XZOmBubg8yiFp5yS/JdUDQsq5e6h95km91MCYMuvp7mh1fjPEYUhvHepKpZOjnEaMBR4PxjWDzg==
   dependencies:
     "@types/estree" "*"
     "@types/json-schema" "*"
 
 "@types/estree@*", "@types/estree@^1.0.0":
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.1.tgz#aa22750962f3bf0e79d753d3cc067f010c95f194"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-1.0.1.tgz#aa22750962f3bf0e79d753d3cc067f010c95f194"
   integrity sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA==
 
 "@types/expect@^1.20.4":
   version "1.20.4"
-  resolved "https://registry.yarnpkg.com/@types/expect/-/expect-1.20.4.tgz#8288e51737bf7e3ab5d7c77bfa695883745264e5"
+  resolved "https://registry.npmjs.org/@types/expect/-/expect-1.20.4.tgz#8288e51737bf7e3ab5d7c77bfa695883745264e5"
   integrity sha512-Q5Vn3yjTDyCMV50TB6VRIbQNxSE4OmZR86VSbGaNpfUolm0iePBB4KdEEHmxoY5sT2+2DIvXW0rvMDP2nHZ4Mg==
 
 "@types/glob@8.1.0":
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/@types/glob/-/glob-8.1.0.tgz#b63e70155391b0584dce44e7ea25190bbc38f2fc"
+  resolved "https://registry.npmjs.org/@types/glob/-/glob-8.1.0.tgz#b63e70155391b0584dce44e7ea25190bbc38f2fc"
   integrity sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w==
   dependencies:
     "@types/minimatch" "^5.1.2"
@@ -1199,33 +1264,33 @@
 
 "@types/graceful-fs@^4.1.3":
   version "4.1.6"
-  resolved "https://registry.yarnpkg.com/@types/graceful-fs/-/graceful-fs-4.1.6.tgz#e14b2576a1c25026b7f02ede1de3b84c3a1efeae"
+  resolved "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.6.tgz#e14b2576a1c25026b7f02ede1de3b84c3a1efeae"
   integrity sha512-Sig0SNORX9fdW+bQuTEovKj3uHcUL6LQKbCrrqb1X7J6/ReAbhCXRAhc+SMejhLELFj2QcyuxmUooZ4bt5ReSw==
   dependencies:
     "@types/node" "*"
 
 "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0", "@types/istanbul-lib-coverage@^2.0.1":
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44"
+  resolved "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44"
   integrity sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g==
 
 "@types/istanbul-lib-report@*":
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#c14c24f18ea8190c118ee7562b7ff99a36552686"
+  resolved "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#c14c24f18ea8190c118ee7562b7ff99a36552686"
   integrity sha512-plGgXAPfVKFoYfa9NpYDAkseG+g6Jr294RqeqcqDixSbU34MZVJRi/P+7Y8GDpzkEwLaGZZOpKIEmeVZNtKsrg==
   dependencies:
     "@types/istanbul-lib-coverage" "*"
 
 "@types/istanbul-reports@^3.0.0":
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz#9153fe98bba2bd565a63add9436d6f0d7f8468ff"
+  resolved "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.1.tgz#9153fe98bba2bd565a63add9436d6f0d7f8468ff"
   integrity sha512-c3mAZEuK0lvBp8tmuL74XRKn1+y2dcwOUpH7x4WrF6gk1GIgiluDRgMYQtw2OFcBvAJWlt6ASU3tSqxp0Uu0Aw==
   dependencies:
     "@types/istanbul-lib-report" "*"
 
 "@types/jest@29.5.3":
   version "29.5.3"
-  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-29.5.3.tgz#7a35dc0044ffb8b56325c6802a4781a626b05777"
+  resolved "https://registry.npmjs.org/@types/jest/-/jest-29.5.3.tgz#7a35dc0044ffb8b56325c6802a4781a626b05777"
   integrity sha512-1Nq7YrO/vJE/FYnqYyw0FS8LdrjExSgIiHyKg7xPpn+yi8Q4huZryKnkJatN1ZRH89Kw2v33/8ZMB7DuZeSLlA==
   dependencies:
     expect "^29.0.0"
@@ -1233,62 +1298,62 @@
 
 "@types/json-schema@*", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
   version "7.0.12"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.12.tgz#d70faba7039d5fca54c83c7dbab41051d2b6f6cb"
+  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.12.tgz#d70faba7039d5fca54c83c7dbab41051d2b6f6cb"
   integrity sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==
 
 "@types/minimatch@^5.1.2":
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-5.1.2.tgz#07508b45797cb81ec3f273011b054cd0755eddca"
+  resolved "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz#07508b45797cb81ec3f273011b054cd0755eddca"
   integrity sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==
 
 "@types/minimist@^1.2.2":
   version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
+  resolved "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
   integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
 
-"@types/node@*", "@types/node@20.3.0":
-  version "20.3.0"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.3.0.tgz#719498898d5defab83c3560f45d8498f58d11938"
-  integrity sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ==
+"@types/node@*", "@types/node@^20.6.0":
+  version "20.6.0"
+  resolved "https://registry.npmjs.org/@types/node/-/node-20.6.0.tgz#9d7daa855d33d4efec8aea88cd66db1c2f0ebe16"
+  integrity sha512-najjVq5KN2vsH2U/xyh2opaSEz6cZMR2SetLIlxlj08nOcmPOemJmUK2o4kUzfLqfrWE0PIrNeE16XhYDd3nqg==
 
 "@types/node@^13.7.4":
   version "13.13.52"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-13.13.52.tgz#03c13be70b9031baaed79481c0c0cfb0045e53f7"
+  resolved "https://registry.npmjs.org/@types/node/-/node-13.13.52.tgz#03c13be70b9031baaed79481c0c0cfb0045e53f7"
   integrity sha512-s3nugnZumCC//n4moGGe6tkNMyYEdaDBitVjwPxXmR5lnMG5dHePinH2EdxkG3Rh1ghFHHixAG4NJhpJW1rthQ==
 
 "@types/normalize-package-data@^2.4.0":
   version "2.4.1"
-  resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301"
+  resolved "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301"
   integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==
 
-"@types/pad-left@2.1.1":
+"@types/pad-left@^2.1.1":
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/@types/pad-left/-/pad-left-2.1.1.tgz#17d906fc75804e1cc722da73623f1d978f16a137"
+  resolved "https://registry.npmjs.org/@types/pad-left/-/pad-left-2.1.1.tgz#17d906fc75804e1cc722da73623f1d978f16a137"
   integrity sha512-Xd22WCRBydkGSApl5Bw0PhAOHKSVjNL3E3AwzKaps96IMraPqy5BvZIsBVK6JLwdybUzjHnuWVwpDd0JjTfHXA==
 
 "@types/randomatic@3.1.3":
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/@types/randomatic/-/randomatic-3.1.3.tgz#5475c29e82cb8dab6c94e55e77306c8eedab2d1f"
+  resolved "https://registry.npmjs.org/@types/randomatic/-/randomatic-3.1.3.tgz#5475c29e82cb8dab6c94e55e77306c8eedab2d1f"
   integrity sha512-UlYMg/XxN+YMh6vAiB879yh2bhaTOU0DB1g4NGIhzlaiSf22rAVKIGTvH8HjCXu+wfFvjAWHuPG5waN4btEubw==
 
 "@types/resolve@1.20.2":
   version "1.20.2"
-  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.20.2.tgz#97d26e00cd4a0423b4af620abecf3e6f442b7975"
+  resolved "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz#97d26e00cd4a0423b4af620abecf3e6f442b7975"
   integrity sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==
 
 "@types/semver@^7.3.12":
-  version "7.5.0"
-  resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.5.0.tgz#591c1ce3a702c45ee15f47a42ade72c2fd78978a"
-  integrity sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==
+  version "7.5.2"
+  resolved "https://registry.npmjs.org/@types/semver/-/semver-7.5.2.tgz#31f6eec1ed7ec23f4f05608d3a2d381df041f564"
+  integrity sha512-7aqorHYgdNO4DM36stTiGO3DvKoex9TQRwsJU6vMaFGyqpBA1MNZkz+PG3gaNUPpTAOYhT1WR7M1JyA3fbS9Cw==
 
 "@types/stack-utils@^2.0.0":
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c"
+  resolved "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.1.tgz#20f18294f797f2209b5f65c8e3b5c8e8261d127c"
   integrity sha512-Hl219/BT5fLAaz6NDkSuhzasy49dwQS/DSdu4MdggFB8zcXv7vflBI3xp7FEmkmdDkBUI2bPUNeMttp2knYdxw==
 
 "@types/vinyl@^2.0.4":
   version "2.0.7"
-  resolved "https://registry.yarnpkg.com/@types/vinyl/-/vinyl-2.0.7.tgz#9739a9a2afaf9af32761c54a0e82c735279f726c"
+  resolved "https://registry.npmjs.org/@types/vinyl/-/vinyl-2.0.7.tgz#9739a9a2afaf9af32761c54a0e82c735279f726c"
   integrity sha512-4UqPv+2567NhMQuMLdKAyK4yzrfCqwaTt6bLhHEs8PFcxbHILsrxaY63n4wgE/BRLDWDQeI+WcTmkXKExh9hQg==
   dependencies:
     "@types/expect" "^1.20.4"
@@ -1296,26 +1361,26 @@
 
 "@types/yargs-parser@*":
   version "21.0.0"
-  resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b"
+  resolved "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b"
   integrity sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA==
 
 "@types/yargs@^15.0.0":
   version "15.0.15"
-  resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-15.0.15.tgz#e609a2b1ef9e05d90489c2f5f45bbfb2be092158"
+  resolved "https://registry.npmjs.org/@types/yargs/-/yargs-15.0.15.tgz#e609a2b1ef9e05d90489c2f5f45bbfb2be092158"
   integrity sha512-IziEYMU9XoVj8hWg7k+UJrXALkGFjWJhn5QFEv9q4p+v40oZhSuC135M38st8XPjICL7Ey4TV64ferBGUoJhBg==
   dependencies:
     "@types/yargs-parser" "*"
 
 "@types/yargs@^17.0.8":
   version "17.0.24"
-  resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-17.0.24.tgz#b3ef8d50ad4aa6aecf6ddc97c580a00f5aa11902"
+  resolved "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.24.tgz#b3ef8d50ad4aa6aecf6ddc97c580a00f5aa11902"
   integrity sha512-6i0aC7jV6QzQB8ne1joVZ0eSFIstHsCrobmOtghM11yGlH0j43FKL2UhWdELkyps0zuf7qVTUVCCR+tgSlyLLw==
   dependencies:
     "@types/yargs-parser" "*"
 
 "@typescript-eslint/eslint-plugin@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.59.9.tgz#2604cfaf2b306e120044f901e20c8ed926debf15"
+  resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.59.9.tgz#2604cfaf2b306e120044f901e20c8ed926debf15"
   integrity sha512-4uQIBq1ffXd2YvF7MAvehWKW3zVv/w+mSfRAu+8cKbfj3nwzyqJLNcZJpQ/WZ1HLbJDiowwmQ6NO+63nCA+fqA==
   dependencies:
     "@eslint-community/regexpp" "^4.4.0"
@@ -1331,7 +1396,7 @@
 
 "@typescript-eslint/parser@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.59.9.tgz#a85c47ccdd7e285697463da15200f9a8561dd5fa"
+  resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.59.9.tgz#a85c47ccdd7e285697463da15200f9a8561dd5fa"
   integrity sha512-FsPkRvBtcLQ/eVK1ivDiNYBjn3TGJdXy2fhXX+rc7czWl4ARwnpArwbihSOHI2Peg9WbtGHrbThfBUkZZGTtvQ==
   dependencies:
     "@typescript-eslint/scope-manager" "5.59.9"
@@ -1341,15 +1406,23 @@
 
 "@typescript-eslint/scope-manager@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.59.9.tgz#eadce1f2733389cdb58c49770192c0f95470d2f4"
+  resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.59.9.tgz#eadce1f2733389cdb58c49770192c0f95470d2f4"
   integrity sha512-8RA+E+w78z1+2dzvK/tGZ2cpGigBZ58VMEHDZtpE1v+LLjzrYGc8mMaTONSxKyEkz3IuXFM0IqYiGHlCsmlZxQ==
   dependencies:
     "@typescript-eslint/types" "5.59.9"
     "@typescript-eslint/visitor-keys" "5.59.9"
 
+"@typescript-eslint/scope-manager@5.62.0":
+  version "5.62.0"
+  resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz#d9457ccc6a0b8d6b37d0eb252a23022478c5460c"
+  integrity sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==
+  dependencies:
+    "@typescript-eslint/types" "5.62.0"
+    "@typescript-eslint/visitor-keys" "5.62.0"
+
 "@typescript-eslint/type-utils@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.59.9.tgz#53bfaae2e901e6ac637ab0536d1754dfef4dafc2"
+  resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.59.9.tgz#53bfaae2e901e6ac637ab0536d1754dfef4dafc2"
   integrity sha512-ksEsT0/mEHg9e3qZu98AlSrONAQtrSTljL3ow9CGej8eRo7pe+yaC/mvTjptp23Xo/xIf2mLZKC6KPv4Sji26Q==
   dependencies:
     "@typescript-eslint/typescript-estree" "5.59.9"
@@ -1359,12 +1432,17 @@
 
 "@typescript-eslint/types@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.59.9.tgz#3b4e7ae63718ce1b966e0ae620adc4099a6dcc52"
+  resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.59.9.tgz#3b4e7ae63718ce1b966e0ae620adc4099a6dcc52"
   integrity sha512-uW8H5NRgTVneSVTfiCVffBb8AbwWSKg7qcA4Ot3JI3MPCJGsB4Db4BhvAODIIYE5mNj7Q+VJkK7JxmRhk2Lyjw==
 
+"@typescript-eslint/types@5.62.0":
+  version "5.62.0"
+  resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz#258607e60effa309f067608931c3df6fed41fd2f"
+  integrity sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==
+
 "@typescript-eslint/typescript-estree@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.59.9.tgz#6bfea844e468427b5e72034d33c9fffc9557392b"
+  resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.59.9.tgz#6bfea844e468427b5e72034d33c9fffc9557392b"
   integrity sha512-pmM0/VQ7kUhd1QyIxgS+aRvMgw+ZljB3eDb+jYyp6d2bC0mQWLzUDF+DLwCTkQ3tlNyVsvZRXjFyV0LkU/aXjA==
   dependencies:
     "@typescript-eslint/types" "5.59.9"
@@ -1375,9 +1453,22 @@
     semver "^7.3.7"
     tsutils "^3.21.0"
 
-"@typescript-eslint/utils@5.59.9", "@typescript-eslint/utils@^5.10.0":
+"@typescript-eslint/typescript-estree@5.62.0":
+  version "5.62.0"
+  resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz#7d17794b77fabcac615d6a48fb143330d962eb9b"
+  integrity sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==
+  dependencies:
+    "@typescript-eslint/types" "5.62.0"
+    "@typescript-eslint/visitor-keys" "5.62.0"
+    debug "^4.3.4"
+    globby "^11.1.0"
+    is-glob "^4.0.3"
+    semver "^7.3.7"
+    tsutils "^3.21.0"
+
+"@typescript-eslint/utils@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.59.9.tgz#adee890107b5ffe02cd46fdaa6c2125fb3c6c7c4"
+  resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.59.9.tgz#adee890107b5ffe02cd46fdaa6c2125fb3c6c7c4"
   integrity sha512-1PuMYsju/38I5Ggblaeb98TOoUvjhRvLpLa1DoTOFaLWqaXl/1iQ1eGurTXgBY58NUdtfTXKP5xBq7q9NDaLKg==
   dependencies:
     "@eslint-community/eslint-utils" "^4.2.0"
@@ -1389,17 +1480,39 @@
     eslint-scope "^5.1.1"
     semver "^7.3.7"
 
+"@typescript-eslint/utils@^5.10.0":
+  version "5.62.0"
+  resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz#141e809c71636e4a75daa39faed2fb5f4b10df86"
+  integrity sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==
+  dependencies:
+    "@eslint-community/eslint-utils" "^4.2.0"
+    "@types/json-schema" "^7.0.9"
+    "@types/semver" "^7.3.12"
+    "@typescript-eslint/scope-manager" "5.62.0"
+    "@typescript-eslint/types" "5.62.0"
+    "@typescript-eslint/typescript-estree" "5.62.0"
+    eslint-scope "^5.1.1"
+    semver "^7.3.7"
+
 "@typescript-eslint/visitor-keys@5.59.9":
   version "5.59.9"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.59.9.tgz#9f86ef8e95aca30fb5a705bb7430f95fc58b146d"
+  resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.59.9.tgz#9f86ef8e95aca30fb5a705bb7430f95fc58b146d"
   integrity sha512-bT7s0td97KMaLwpEBckbzj/YohnvXtqbe2XgqNvTl6RJVakY5mvENOTPvw5u66nljfZxthESpDozs86U+oLY8Q==
   dependencies:
     "@typescript-eslint/types" "5.59.9"
     eslint-visitor-keys "^3.3.0"
 
+"@typescript-eslint/visitor-keys@5.62.0":
+  version "5.62.0"
+  resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz#2174011917ce582875954ffe2f6912d5931e353e"
+  integrity sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==
+  dependencies:
+    "@typescript-eslint/types" "5.62.0"
+    eslint-visitor-keys "^3.3.0"
+
 "@webassemblyjs/ast@1.11.6", "@webassemblyjs/ast@^1.11.5":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24"
+  resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24"
   integrity sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==
   dependencies:
     "@webassemblyjs/helper-numbers" "1.11.6"
@@ -1407,22 +1520,22 @@
 
 "@webassemblyjs/floating-point-hex-parser@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz#dacbcb95aff135c8260f77fa3b4c5fea600a6431"
+  resolved "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz#dacbcb95aff135c8260f77fa3b4c5fea600a6431"
   integrity sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==
 
 "@webassemblyjs/helper-api-error@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz#6132f68c4acd59dcd141c44b18cbebbd9f2fa768"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz#6132f68c4acd59dcd141c44b18cbebbd9f2fa768"
   integrity sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==
 
 "@webassemblyjs/helper-buffer@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz#b66d73c43e296fd5e88006f18524feb0f2c7c093"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz#b66d73c43e296fd5e88006f18524feb0f2c7c093"
   integrity sha512-z3nFzdcp1mb8nEOFFk8DrYLpHvhKC3grJD2ardfKOzmbmJvEf/tPIqCY+sNcwZIY8ZD7IkB2l7/pqhUhqm7hLA==
 
 "@webassemblyjs/helper-numbers@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz#cbce5e7e0c1bd32cf4905ae444ef64cea919f1b5"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz#cbce5e7e0c1bd32cf4905ae444ef64cea919f1b5"
   integrity sha512-vUIhZ8LZoIWHBohiEObxVm6hwP034jwmc9kuq5GdHZH0wiLVLIPcMCdpJzG4C11cHoQ25TFIQj9kaVADVX7N3g==
   dependencies:
     "@webassemblyjs/floating-point-hex-parser" "1.11.6"
@@ -1431,12 +1544,12 @@
 
 "@webassemblyjs/helper-wasm-bytecode@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz#bb2ebdb3b83aa26d9baad4c46d4315283acd51e9"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz#bb2ebdb3b83aa26d9baad4c46d4315283acd51e9"
   integrity sha512-sFFHKwcmBprO9e7Icf0+gddyWYDViL8bpPjJJl0WHxCdETktXdmtWLGVzoHbqUcY4Be1LkNfwTmXOJUFZYSJdA==
 
 "@webassemblyjs/helper-wasm-section@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz#ff97f3863c55ee7f580fd5c41a381e9def4aa577"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz#ff97f3863c55ee7f580fd5c41a381e9def4aa577"
   integrity sha512-LPpZbSOwTpEC2cgn4hTydySy1Ke+XEu+ETXuoyvuyezHO3Kjdu90KK95Sh9xTbmjrCsUwvWwCOQQNta37VrS9g==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1446,26 +1559,26 @@
 
 "@webassemblyjs/ieee754@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz#bb665c91d0b14fffceb0e38298c329af043c6e3a"
+  resolved "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz#bb665c91d0b14fffceb0e38298c329af043c6e3a"
   integrity sha512-LM4p2csPNvbij6U1f19v6WR56QZ8JcHg3QIJTlSwzFcmx6WSORicYj6I63f9yU1kEUtrpG+kjkiIAkevHpDXrg==
   dependencies:
     "@xtuc/ieee754" "^1.2.0"
 
 "@webassemblyjs/leb128@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.6.tgz#70e60e5e82f9ac81118bc25381a0b283893240d7"
+  resolved "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.11.6.tgz#70e60e5e82f9ac81118bc25381a0b283893240d7"
   integrity sha512-m7a0FhE67DQXgouf1tbN5XQcdWoNgaAuoULHIfGFIEVKA6tu/edls6XnIlkmS6FrXAquJRPni3ZZKjw6FSPjPQ==
   dependencies:
     "@xtuc/long" "4.2.2"
 
 "@webassemblyjs/utf8@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.6.tgz#90f8bc34c561595fe156603be7253cdbcd0fab5a"
+  resolved "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.11.6.tgz#90f8bc34c561595fe156603be7253cdbcd0fab5a"
   integrity sha512-vtXf2wTQ3+up9Zsg8sa2yWiQpzSsMyXj0qViVP6xKGCUT8p8YJ6HqI7l5eCnWx1T/FYdsv07HQs2wTFbbof/RA==
 
 "@webassemblyjs/wasm-edit@^1.11.5":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz#c72fa8220524c9b416249f3d94c2958dfe70ceab"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz#c72fa8220524c9b416249f3d94c2958dfe70ceab"
   integrity sha512-Ybn2I6fnfIGuCR+Faaz7YcvtBKxvoLV3Lebn1tM4o/IAJzmi9AWYIPWpyBfU8cC+JxAO57bk4+zdsTjJR+VTOw==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1479,7 +1592,7 @@
 
 "@webassemblyjs/wasm-gen@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz#fb5283e0e8b4551cc4e9c3c0d7184a65faf7c268"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz#fb5283e0e8b4551cc4e9c3c0d7184a65faf7c268"
   integrity sha512-3XOqkZP/y6B4F0PBAXvI1/bky7GryoogUtfwExeP/v7Nzwo1QLcq5oQmpKlftZLbT+ERUOAZVQjuNVak6UXjPA==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1490,7 +1603,7 @@
 
 "@webassemblyjs/wasm-opt@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz#d9a22d651248422ca498b09aa3232a81041487c2"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz#d9a22d651248422ca498b09aa3232a81041487c2"
   integrity sha512-cOrKuLRE7PCe6AsOVl7WasYf3wbSo4CeOk6PkrjS7g57MFfVUF9u6ysQBBODX0LdgSvQqRiGz3CXvIDKcPNy4g==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1500,7 +1613,7 @@
 
 "@webassemblyjs/wasm-parser@1.11.6", "@webassemblyjs/wasm-parser@^1.11.5":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz#bb85378c527df824004812bbdb784eea539174a1"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz#bb85378c527df824004812bbdb784eea539174a1"
   integrity sha512-6ZwPeGzMJM3Dqp3hCsLgESxBGtT/OeCvCZ4TA1JUPYgmhAx38tTPR9JaKy0S5H3evQpO/h2uWs2j6Yc/fjkpTQ==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1512,7 +1625,7 @@
 
 "@webassemblyjs/wast-printer@1.11.6":
   version "1.11.6"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz#a7bf8dd7e362aeb1668ff43f35cb849f188eff20"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz#a7bf8dd7e362aeb1668ff43f35cb849f188eff20"
   integrity sha512-JM7AhRcE+yW2GWYaKeHL5vt4xqee5N2WcezptmgyhNS+ScggqcT1OtXykhAb13Sn5Yas0j2uv9tHgrjwvzAP4A==
   dependencies:
     "@webassemblyjs/ast" "1.11.6"
@@ -1520,42 +1633,42 @@
 
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
+  resolved "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
   integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
 
 "@xtuc/long@4.2.2":
   version "4.2.2"
-  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
+  resolved "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
   integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
 
 acorn-import-assertions@^1.9.0:
   version "1.9.0"
-  resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz#507276249d684797c84e0734ef84860334cfb1ac"
+  resolved "https://registry.npmjs.org/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz#507276249d684797c84e0734ef84860334cfb1ac"
   integrity sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==
 
 acorn-jsx@^5.3.2:
   version "5.3.2"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
+  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
 acorn-walk@^8.0.0, acorn-walk@^8.1.1:
   version "8.2.0"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
+  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
   integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
 
 acorn@^6.4.1:
   version "6.4.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
-acorn@^8.0.4, acorn@^8.4.1, acorn@^8.7.1, acorn@^8.8.0, acorn@^8.8.2:
-  version "8.8.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.8.2.tgz#1b2f25db02af965399b9776b0c2c391276d37c4a"
-  integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==
+acorn@^8.0.4, acorn@^8.4.1, acorn@^8.7.1, acorn@^8.8.2, acorn@^8.9.0:
+  version "8.10.0"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-8.10.0.tgz#8be5b3907a67221a81ab23c7889c4c5526b62ec5"
+  integrity sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==
 
 aggregate-error@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-4.0.1.tgz#25091fe1573b9e0be892aeda15c7c66a545f758e"
+  resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-4.0.1.tgz#25091fe1573b9e0be892aeda15c7c66a545f758e"
   integrity sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w==
   dependencies:
     clean-stack "^4.0.0"
@@ -1563,12 +1676,12 @@ aggregate-error@^4.0.0:
 
 ajv-keywords@^3.5.2:
   version "3.5.2"
-  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
+  resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
 ajv@^6.10.0, ajv@^6.12.4, ajv@^6.12.5:
   version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
   dependencies:
     fast-deep-equal "^3.1.1"
@@ -1578,82 +1691,82 @@ ajv@^6.10.0, ajv@^6.12.4, ajv@^6.12.5:
 
 ansi-colors@^1.0.1:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-1.1.0.tgz#6374b4dd5d4718ff3ce27a671a3b1cad077132a9"
+  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-1.1.0.tgz#6374b4dd5d4718ff3ce27a671a3b1cad077132a9"
   integrity sha512-SFKX67auSNoVR38N3L+nvsPjOE0bybKTYbkf5tRvushrAPQ9V75huw0ZxBkKVeRU9kqH3d6HA4xTckbwZ4ixmA==
   dependencies:
     ansi-wrap "^0.1.0"
 
 ansi-colors@^3.0.5:
   version "3.2.4"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.4.tgz#e3a3da4bfbae6c86a9c285625de124a234026fbf"
+  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.4.tgz#e3a3da4bfbae6c86a9c285625de124a234026fbf"
   integrity sha512-hHUXGagefjN2iRrID63xckIvotOXOojhQKWIPUZ4mNUZ9nLZW+7FMNoE1lOkEhNWYsx/7ysGIuJYCiMAA9FnrA==
 
 ansi-escapes@^4.2.1, ansi-escapes@^4.3.0:
   version "4.3.2"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
+  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
   integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
   dependencies:
     type-fest "^0.21.3"
 
 ansi-gray@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-gray/-/ansi-gray-0.1.1.tgz#2962cf54ec9792c48510a3deb524436861ef7251"
+  resolved "https://registry.npmjs.org/ansi-gray/-/ansi-gray-0.1.1.tgz#2962cf54ec9792c48510a3deb524436861ef7251"
   integrity sha512-HrgGIZUl8h2EHuZaU9hTR/cU5nhKxpVE1V6kdGsQ8e4zirElJ5fvtfc8N7Q1oq1aatO275i8pUFUCpNWCAnVWw==
   dependencies:
     ansi-wrap "0.1.0"
 
 ansi-regex@^2.0.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
   integrity sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==
 
 ansi-regex@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
   integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
 
 ansi-regex@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
   integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
 
 ansi-sequence-parser@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-sequence-parser/-/ansi-sequence-parser-1.1.0.tgz#4d790f31236ac20366b23b3916b789e1bde39aed"
-  integrity sha512-lEm8mt52to2fT8GhciPCGeCXACSz2UwIN4X2e2LJSnZ5uAbn2/dsYdOmUXq0AtWS5cpAupysIneExOgH0Vd2TQ==
+  version "1.1.1"
+  resolved "https://registry.npmjs.org/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz#e0aa1cdcbc8f8bb0b5bca625aac41f5f056973cf"
+  integrity sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==
 
 ansi-styles@^3.2.1:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
   integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
   dependencies:
     color-convert "^1.9.0"
 
 ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
   dependencies:
     color-convert "^2.0.1"
 
 ansi-styles@^5.0.0:
   version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
   integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
 
 ansi-styles@^6.1.0:
   version "6.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz#0e62320cf99c21afff3b3012192546aacbfb05c5"
   integrity sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==
 
 ansi-wrap@0.1.0, ansi-wrap@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-wrap/-/ansi-wrap-0.1.0.tgz#a82250ddb0015e9a27ca82e82ea603bbfa45efaf"
+  resolved "https://registry.npmjs.org/ansi-wrap/-/ansi-wrap-0.1.0.tgz#a82250ddb0015e9a27ca82e82ea603bbfa45efaf"
   integrity sha512-ZyznvL8k/FZeQHr2T6LzcJ/+vBApDnMNZvfVFy3At0knswWd6rJ3/0Hhmpu8oqa6C92npmozs890sX9Dl6q+Qw==
 
 anymatch@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
   integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==
   dependencies:
     micromatch "^3.1.4"
@@ -1661,7 +1774,7 @@ anymatch@^2.0.0:
 
 anymatch@^3.0.3:
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e"
   integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==
   dependencies:
     normalize-path "^3.0.0"
@@ -1669,85 +1782,85 @@ anymatch@^3.0.3:
 
 append-buffer@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/append-buffer/-/append-buffer-1.0.2.tgz#d8220cf466081525efea50614f3de6514dfa58f1"
+  resolved "https://registry.npmjs.org/append-buffer/-/append-buffer-1.0.2.tgz#d8220cf466081525efea50614f3de6514dfa58f1"
   integrity sha512-WLbYiXzD3y/ATLZFufV/rZvWdZOs+Z/+5v1rBZ463Jn398pa6kcde27cvozYnBoxXblGZTFfoPpsaEw0orU5BA==
   dependencies:
     buffer-equal "^1.0.0"
 
 archy@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40"
+  resolved "https://registry.npmjs.org/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40"
   integrity sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==
 
 arg@^4.1.0:
   version "4.1.3"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+  resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
   integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
 
 arg@^5.0.2:
   version "5.0.2"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
+  resolved "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
   integrity sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==
 
 argparse@^1.0.7:
   version "1.0.10"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
+  resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
   dependencies:
     sprintf-js "~1.0.2"
 
 argparse@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
+  resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
   integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
 
 arr-diff@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
+  resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
   integrity sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==
 
 arr-filter@^1.1.1:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/arr-filter/-/arr-filter-1.1.2.tgz#43fdddd091e8ef11aa4c45d9cdc18e2dff1711ee"
+  resolved "https://registry.npmjs.org/arr-filter/-/arr-filter-1.1.2.tgz#43fdddd091e8ef11aa4c45d9cdc18e2dff1711ee"
   integrity sha512-A2BETWCqhsecSvCkWAeVBFLH6sXEUGASuzkpjL3GR1SlL/PWL6M3J8EAAld2Uubmh39tvkJTqC9LeLHCUKmFXA==
   dependencies:
     make-iterator "^1.0.0"
 
 arr-flatten@^1.0.1, arr-flatten@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
+  resolved "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
   integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
 
 arr-map@^2.0.0, arr-map@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/arr-map/-/arr-map-2.0.2.tgz#3a77345ffc1cf35e2a91825601f9e58f2e24cac4"
+  resolved "https://registry.npmjs.org/arr-map/-/arr-map-2.0.2.tgz#3a77345ffc1cf35e2a91825601f9e58f2e24cac4"
   integrity sha512-tVqVTHt+Q5Xb09qRkbu+DidW1yYzz5izWS2Xm2yFm7qJnmUfz4HPzNxbHkdRJbz2lrqI7S+z17xNYdFcBBO8Hw==
   dependencies:
     make-iterator "^1.0.0"
 
 arr-union@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
+  resolved "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
   integrity sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q==
 
 array-back@^3.0.1, array-back@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/array-back/-/array-back-3.1.0.tgz#b8859d7a508871c9a7b2cf42f99428f65e96bfb0"
+  resolved "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz#b8859d7a508871c9a7b2cf42f99428f65e96bfb0"
   integrity sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==
 
 array-back@^6.2.2:
   version "6.2.2"
-  resolved "https://registry.yarnpkg.com/array-back/-/array-back-6.2.2.tgz#f567d99e9af88a6d3d2f9dfcc21db6f9ba9fd157"
+  resolved "https://registry.npmjs.org/array-back/-/array-back-6.2.2.tgz#f567d99e9af88a6d3d2f9dfcc21db6f9ba9fd157"
   integrity sha512-gUAZ7HPyb4SJczXAMUXMGAvI976JoK3qEx9v1FTmeYuJj0IBiaKttG1ydtGKdkfqWkIkouke7nG8ufGy77+Cvw==
 
 array-each@^1.0.0, array-each@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/array-each/-/array-each-1.0.1.tgz#a794af0c05ab1752846ee753a1f211a05ba0c44f"
+  resolved "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz#a794af0c05ab1752846ee753a1f211a05ba0c44f"
   integrity sha512-zHjL5SZa68hkKHBFBK6DJCTtr9sfTCPCaph/L7tMSLcTFgy+zX7E+6q5UArbtOtMBCtxdICpfTCspRse+ywyXA==
 
 array-initial@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/array-initial/-/array-initial-1.1.0.tgz#2fa74b26739371c3947bd7a7adc73be334b3d795"
+  resolved "https://registry.npmjs.org/array-initial/-/array-initial-1.1.0.tgz#2fa74b26739371c3947bd7a7adc73be334b3d795"
   integrity sha512-BC4Yl89vneCYfpLrs5JU2aAu9/a+xWbeKhvISg9PT7eWFB9UlRvI+rKEtk6mgxWr3dSkk9gQ8hCrdqt06NXPdw==
   dependencies:
     array-slice "^1.0.0"
@@ -1755,19 +1868,19 @@ array-initial@^1.0.0:
 
 array-last@^1.1.1:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/array-last/-/array-last-1.3.0.tgz#7aa77073fec565ddab2493f5f88185f404a9d336"
+  resolved "https://registry.npmjs.org/array-last/-/array-last-1.3.0.tgz#7aa77073fec565ddab2493f5f88185f404a9d336"
   integrity sha512-eOCut5rXlI6aCOS7Z7kCplKRKyiFQ6dHFBem4PwlwKeNFk2/XxTrhRh5T9PyaEWGy/NHTZWbY+nsZlNFJu9rYg==
   dependencies:
     is-number "^4.0.0"
 
 array-slice@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-1.1.0.tgz#e368ea15f89bc7069f7ffb89aec3a6c7d4ac22d4"
+  resolved "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz#e368ea15f89bc7069f7ffb89aec3a6c7d4ac22d4"
   integrity sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==
 
 array-sort@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-sort/-/array-sort-1.0.0.tgz#e4c05356453f56f53512a7d1d6123f2c54c0a88a"
+  resolved "https://registry.npmjs.org/array-sort/-/array-sort-1.0.0.tgz#e4c05356453f56f53512a7d1d6123f2c54c0a88a"
   integrity sha512-ihLeJkonmdiAsD7vpgN3CRcx2J2S0TiYW+IS/5zHBI7mKUq3ySvBdzzBfD236ubDBQFiiyG3SWCPc+msQ9KoYg==
   dependencies:
     default-compare "^1.0.0"
@@ -1776,37 +1889,37 @@ array-sort@^1.0.0:
 
 array-union@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
+  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
   integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
 
 array-unique@^0.3.2:
   version "0.3.2"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
+  resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
   integrity sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ==
 
 arrify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
+  resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==
 
 asap@~2.0.6:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
+  resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz#e50347611d7e690943208bbdafebcbc2fb866d46"
   integrity sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==
 
 assign-symbols@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
+  resolved "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
   integrity sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==
 
 astral-regex@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
+  resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
   integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
 
 async-done@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/async-done/-/async-done-2.0.0.tgz#f1ec5df738c6383a52b0a30d0902fd897329c15a"
+  resolved "https://registry.npmjs.org/async-done/-/async-done-2.0.0.tgz#f1ec5df738c6383a52b0a30d0902fd897329c15a"
   integrity sha512-j0s3bzYq9yKIVLKGE/tWlCpa3PfFLcrDZLTSVdnnCTGagXuXBJO4SsY9Xdk/fQBirCkH4evW5xOeJXqlAQFdsw==
   dependencies:
     end-of-stream "^1.4.4"
@@ -1815,7 +1928,7 @@ async-done@2.0.0:
 
 async-done@^1.2.0, async-done@^1.2.2:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/async-done/-/async-done-1.3.2.tgz#5e15aa729962a4b07414f528a88cdf18e0b290a2"
+  resolved "https://registry.npmjs.org/async-done/-/async-done-1.3.2.tgz#5e15aa729962a4b07414f528a88cdf18e0b290a2"
   integrity sha512-uYkTP8dw2og1tu1nmza1n1CMW0qb8gWWlwqMmLb7MhBVs4BXrFziT6HXUd+/RlRA/i4H9AkofYloUbs1fwMqlw==
   dependencies:
     end-of-stream "^1.1.0"
@@ -1825,37 +1938,37 @@ async-done@^1.2.0, async-done@^1.2.2:
 
 async-each@^1.0.1:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.6.tgz#52f1d9403818c179b7561e11a5d1b77eb2160e77"
+  resolved "https://registry.npmjs.org/async-each/-/async-each-1.0.6.tgz#52f1d9403818c179b7561e11a5d1b77eb2160e77"
   integrity sha512-c646jH1avxr+aVpndVMeAfYw7wAa6idufrlN3LPA4PmKS0QEGp6PIC9nwz0WQkkvBGAMEki3pFdtxaF39J9vvg==
 
 async-settle@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/async-settle/-/async-settle-1.0.0.tgz#1d0a914bb02575bec8a8f3a74e5080f72b2c0c6b"
+  resolved "https://registry.npmjs.org/async-settle/-/async-settle-1.0.0.tgz#1d0a914bb02575bec8a8f3a74e5080f72b2c0c6b"
   integrity sha512-VPXfB4Vk49z1LHHodrEQ6Xf7W4gg1w0dAPROHngx7qgDjqmIQ+fXmwgGXTW/ITLai0YLSvWepJOP9EVpMnEAcw==
   dependencies:
     async-done "^1.2.2"
 
 atob@^2.1.2:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
+  resolved "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
-babel-jest@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/babel-jest/-/babel-jest-29.6.2.tgz#cada0a59e07f5acaeb11cbae7e3ba92aec9c1126"
-  integrity sha512-BYCzImLos6J3BH/+HvUCHG1dTf2MzmAB4jaVxHV+29RZLjR29XuYTmsf2sdDwkrb+FczkGo3kOhE7ga6sI0P4A==
+babel-jest@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/babel-jest/-/babel-jest-29.7.0.tgz#f4369919225b684c56085998ac63dbd05be020d5"
+  integrity sha512-BrvGY3xZSwEcCzKvKsCi2GgHqDqsYkOP4/by5xCgIwGXQxIEh+8ew3gmrE1y7XRR6LHZIj6yLYnUi/mm2KXKBg==
   dependencies:
-    "@jest/transform" "^29.6.2"
+    "@jest/transform" "^29.7.0"
     "@types/babel__core" "^7.1.14"
     babel-plugin-istanbul "^6.1.1"
-    babel-preset-jest "^29.5.0"
+    babel-preset-jest "^29.6.3"
     chalk "^4.0.0"
     graceful-fs "^4.2.9"
     slash "^3.0.0"
 
 babel-plugin-istanbul@^6.1.1:
   version "6.1.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73"
+  resolved "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73"
   integrity sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
@@ -1864,10 +1977,10 @@ babel-plugin-istanbul@^6.1.1:
     istanbul-lib-instrument "^5.0.4"
     test-exclude "^6.0.0"
 
-babel-plugin-jest-hoist@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.5.0.tgz#a97db437936f441ec196990c9738d4b88538618a"
-  integrity sha512-zSuuuAlTMT4mzLj2nPnUm6fsE6270vdOfnpbJ+RmruU75UhLFvL0N2NgI7xpeS7NaB6hGqmd5pVpGTDYvi4Q3w==
+babel-plugin-jest-hoist@^29.6.3:
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-29.6.3.tgz#aadbe943464182a8922c3c927c3067ff40d24626"
+  integrity sha512-ESAc/RJvGTFEzRwOTT4+lNDk/GNHMkKbNzsvT0qKRfDyyYTskxB5rnU2njIDYVxXCBHHEI1c0YwHob3WaYujOg==
   dependencies:
     "@babel/template" "^7.3.3"
     "@babel/types" "^7.3.3"
@@ -1876,7 +1989,7 @@ babel-plugin-jest-hoist@^29.5.0:
 
 babel-preset-current-node-syntax@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz#b4399239b89b2a011f9ddbe3e4f401fc40cff73b"
+  resolved "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.0.1.tgz#b4399239b89b2a011f9ddbe3e4f401fc40cff73b"
   integrity sha512-M7LQ0bxarkxQoN+vz5aJPsLBn77n8QgTFmo8WK0/44auK2xlCXrYcUxHFxgU7qW5Yzw/CjmLRK2uJzaCd7LvqQ==
   dependencies:
     "@babel/plugin-syntax-async-generators" "^7.8.4"
@@ -1892,17 +2005,17 @@ babel-preset-current-node-syntax@^1.0.0:
     "@babel/plugin-syntax-optional-chaining" "^7.8.3"
     "@babel/plugin-syntax-top-level-await" "^7.8.3"
 
-babel-preset-jest@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/babel-preset-jest/-/babel-preset-jest-29.5.0.tgz#57bc8cc88097af7ff6a5ab59d1cd29d52a5916e2"
-  integrity sha512-JOMloxOqdiBSxMAzjRaH023/vvcaSaec49zvg+2LmNsktC7ei39LTJGw02J+9uUtTZUq6xbLyJ4dxe9sSmIuAg==
+babel-preset-jest@^29.6.3:
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-29.6.3.tgz#fa05fa510e7d493896d7b0dd2033601c840f171c"
+  integrity sha512-0B3bhxR6snWXJZtR/RliHTDPRgn1sNHOR0yVtq/IiQFyuOVjFS+wuio/R4gSNkyYmKmJB4wGZv2NZanmKmTnNA==
   dependencies:
-    babel-plugin-jest-hoist "^29.5.0"
+    babel-plugin-jest-hoist "^29.6.3"
     babel-preset-current-node-syntax "^1.0.0"
 
 bach@^1.0.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/bach/-/bach-1.2.0.tgz#4b3ce96bf27134f79a1b414a51c14e34c3bd9880"
+  resolved "https://registry.npmjs.org/bach/-/bach-1.2.0.tgz#4b3ce96bf27134f79a1b414a51c14e34c3bd9880"
   integrity sha512-bZOOfCb3gXBXbTFXq3OZtGR88LwGeJvzu6szttaIzymOTS4ZttBNOWSv7aLZja2EMycKtRYV0Oa8SNKH/zkxvg==
   dependencies:
     arr-filter "^1.1.1"
@@ -1917,12 +2030,12 @@ bach@^1.0.0:
 
 balanced-match@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
+  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
   integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
 
 base@^0.11.1:
   version "0.11.2"
-  resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
+  resolved "https://registry.npmjs.org/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
   integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
   dependencies:
     cache-base "^1.0.1"
@@ -1935,7 +2048,7 @@ base@^0.11.1:
 
 benchmark@^2.1.4:
   version "2.1.4"
-  resolved "https://registry.yarnpkg.com/benchmark/-/benchmark-2.1.4.tgz#09f3de31c916425d498cc2ee565a0ebf3c2a5629"
+  resolved "https://registry.npmjs.org/benchmark/-/benchmark-2.1.4.tgz#09f3de31c916425d498cc2ee565a0ebf3c2a5629"
   integrity sha512-l9MlfN4M1K/H2fbhfMy3B7vJd6AGKJVQn2h6Sg/Yx+KckoUA7ewS5Vv6TjSq18ooE1kS9hhAlQRH3AkXIh/aOQ==
   dependencies:
     lodash "^4.17.4"
@@ -1943,7 +2056,7 @@ benchmark@^2.1.4:
 
 benny@3.7.1:
   version "3.7.1"
-  resolved "https://registry.yarnpkg.com/benny/-/benny-3.7.1.tgz#964aaaf877e3ab658f79705422277b8471868e37"
+  resolved "https://registry.npmjs.org/benny/-/benny-3.7.1.tgz#964aaaf877e3ab658f79705422277b8471868e37"
   integrity sha512-USzYxODdVfOS7JuQq/L0naxB788dWCiUgUTxvN+WLPt/JfcDURNNj8kN/N+uK6PDvuR67/9/55cVKGPleFQINA==
   dependencies:
     "@arrows/composition" "^1.0.0"
@@ -1958,24 +2071,24 @@ benny@3.7.1:
 
 binary-extensions@^1.0.0:
   version "1.13.1"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.13.1.tgz#598afe54755b2868a5330d2aff9d4ebb53209b65"
+  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz#598afe54755b2868a5330d2aff9d4ebb53209b65"
   integrity sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==
 
 binaryextensions@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/binaryextensions/-/binaryextensions-2.3.0.tgz#1d269cbf7e6243ea886aa41453c3651ccbe13c22"
+  resolved "https://registry.npmjs.org/binaryextensions/-/binaryextensions-2.3.0.tgz#1d269cbf7e6243ea886aa41453c3651ccbe13c22"
   integrity sha512-nAihlQsYGyc5Bwq6+EsubvANYGExeJKHDO3RjnvwU042fawQTQfM3Kxn7IHUXQOz4bzfwsGYYHGSvXyW4zOGLg==
 
 bindings@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
+  resolved "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
   integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
   dependencies:
     file-uri-to-path "1.0.0"
 
 bl@^1.2.1:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
+  resolved "https://registry.npmjs.org/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
   integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
   dependencies:
     readable-stream "^2.3.5"
@@ -1983,7 +2096,7 @@ bl@^1.2.1:
 
 brace-expansion@^1.1.7:
   version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
   dependencies:
     balanced-match "^1.0.0"
@@ -1991,14 +2104,14 @@ brace-expansion@^1.1.7:
 
 brace-expansion@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae"
   integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==
   dependencies:
     balanced-match "^1.0.0"
 
 braces@^2.3.1, braces@^2.3.2:
   version "2.3.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
+  resolved "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
   integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
   dependencies:
     arr-flatten "^1.1.0"
@@ -2014,53 +2127,53 @@ braces@^2.3.1, braces@^2.3.2:
 
 braces@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
   integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
   dependencies:
     fill-range "^7.0.1"
 
-browserslist@^4.14.5, browserslist@^4.21.3:
-  version "4.21.7"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.7.tgz#e2b420947e5fb0a58e8f4668ae6e23488127e551"
-  integrity sha512-BauCXrQ7I2ftSqd2mvKHGo85XR0u7Ru3C/Hxsy/0TkfCtjrmAbPdzLGasmoiBxplpDXlPvdjX9u7srIMfgasNA==
+browserslist@^4.14.5, browserslist@^4.21.9:
+  version "4.21.10"
+  resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.21.10.tgz#dbbac576628c13d3b2231332cb2ec5a46e015bb0"
+  integrity sha512-bipEBdZfVH5/pwrvqc+Ub0kUPVfGUhlKxbvfD+z1BDnPEO/X98ruXGA1WP5ASpAFKan7Qr6j736IacbZQuAlKQ==
   dependencies:
-    caniuse-lite "^1.0.30001489"
-    electron-to-chromium "^1.4.411"
-    node-releases "^2.0.12"
+    caniuse-lite "^1.0.30001517"
+    electron-to-chromium "^1.4.477"
+    node-releases "^2.0.13"
     update-browserslist-db "^1.0.11"
 
 bs-logger@0.x:
   version "0.2.6"
-  resolved "https://registry.yarnpkg.com/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8"
+  resolved "https://registry.npmjs.org/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8"
   integrity sha512-pd8DCoxmbgc7hyPKOvxtqNcjYoOsABPQdcCUjGp3d42VR2CX1ORhk2A87oqqu5R1kk+76nsxZupkmyd+MVtCog==
   dependencies:
     fast-json-stable-stringify "2.x"
 
 bser@2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05"
+  resolved "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz#e6787da20ece9d07998533cfd9de6f5c38f4bc05"
   integrity sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==
   dependencies:
     node-int64 "^0.4.0"
 
 buffer-equal@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/buffer-equal/-/buffer-equal-1.0.1.tgz#2f7651be5b1b3f057fcd6e7ee16cf34767077d90"
+  resolved "https://registry.npmjs.org/buffer-equal/-/buffer-equal-1.0.1.tgz#2f7651be5b1b3f057fcd6e7ee16cf34767077d90"
   integrity sha512-QoV3ptgEaQpvVwbXdSO39iqPQTCxSF7A5U99AxbHYqUdCizL/lH2Z0A2y6nbZucxMEOtNyZfG2s6gsVugGpKkg==
 
 buffer-from@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
+  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
 builtin-modules@^3.3.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.3.0.tgz#cae62812b89801e9656336e46223e030386be7b6"
+  resolved "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.3.0.tgz#cae62812b89801e9656336e46223e030386be7b6"
   integrity sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==
 
 cache-base@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
+  resolved "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
   integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
   dependencies:
     collection-visit "^1.0.0"
@@ -2075,7 +2188,7 @@ cache-base@^1.0.1:
 
 call-bind@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
+  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
   integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
   dependencies:
     function-bind "^1.1.1"
@@ -2083,12 +2196,12 @@ call-bind@^1.0.2:
 
 callsites@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
+  resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
   integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
 
 camelcase-keys@^7.0.0:
   version "7.0.2"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-7.0.2.tgz#d048d8c69448745bb0de6fc4c1c52a30dfbe7252"
+  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-7.0.2.tgz#d048d8c69448745bb0de6fc4c1c52a30dfbe7252"
   integrity sha512-Rjs1H+A9R+Ig+4E/9oyB66UC5Mj9Xq3N//vcLf2WzgdTi/3gUu3Z9KoqmlrEG4VuuLK8wJHofxzdQXz/knhiYg==
   dependencies:
     camelcase "^6.3.0"
@@ -2098,34 +2211,34 @@ camelcase-keys@^7.0.0:
 
 camelcase@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz#32fc4b9fcdaf845fcdf7e73bb97cac2261f0ab0a"
   integrity sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==
 
 camelcase@^5.3.1:
   version "5.3.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
   integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
 
 camelcase@^6.2.0, camelcase@^6.3.0:
   version "6.3.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
   integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
-caniuse-lite@^1.0.30001489:
-  version "1.0.30001499"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001499.tgz#0235c127d9795c82aaf0a7f43e24018549dac659"
-  integrity sha512-IhoQqRrW6WiecFcfZgoJS1YLEN1/HR1vHP5WNgjCARRW7KUNToHHTX3FrwCM+y4zkRa48D9rE90WFYc2IWhDWQ==
+caniuse-lite@^1.0.30001517:
+  version "1.0.30001534"
+  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001534.tgz#f24a9b2a6d39630bac5c132b5dff89b39a12e7dd"
+  integrity sha512-vlPVrhsCS7XaSh2VvWluIQEzVhefrUQcEsQWSS5A5V+dM07uv1qHeQzAOTGIMy9i3e9bH15+muvI/UHojVgS/Q==
 
 chalk-template@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/chalk-template/-/chalk-template-0.4.0.tgz#692c034d0ed62436b9062c1707fadcd0f753204b"
+  resolved "https://registry.npmjs.org/chalk-template/-/chalk-template-0.4.0.tgz#692c034d0ed62436b9062c1707fadcd0f753204b"
   integrity sha512-/ghrgmhfY8RaSdeo43hNXxpoHAtxdbskUHjPpfqUWGttFgycUhYPGx3YZBCnUCvOa7Doivn1IZec3DEGFoMgLg==
   dependencies:
     chalk "^4.1.2"
 
 chalk@4.x, chalk@^4.0.0, chalk@^4.1.2:
   version "4.1.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
   dependencies:
     ansi-styles "^4.1.0"
@@ -2133,7 +2246,7 @@ chalk@4.x, chalk@^4.0.0, chalk@^4.1.2:
 
 chalk@^2.0.0, chalk@^2.4.2:
   version "2.4.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
   dependencies:
     ansi-styles "^3.2.1"
@@ -2142,12 +2255,12 @@ chalk@^2.0.0, chalk@^2.4.2:
 
 char-regex@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
+  resolved "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz#d744358226217f981ed58f479b1d6bcc29545dcf"
   integrity sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==
 
 chokidar@^2.0.0:
   version "2.1.8"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.1.8.tgz#804b3a7b6a99358c3c5c61e71d8728f041cff917"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz#804b3a7b6a99358c3c5c61e71d8728f041cff917"
   integrity sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==
   dependencies:
     anymatch "^2.0.0"
@@ -2166,27 +2279,27 @@ chokidar@^2.0.0:
 
 chrome-trace-event@^1.0.2:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
+  resolved "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
   integrity sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==
 
 ci-info@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
+  resolved "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
   integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==
 
 ci-info@^3.2.0, ci-info@^3.8.0:
   version "3.8.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.8.0.tgz#81408265a5380c929f0bc665d62256628ce9ef91"
+  resolved "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz#81408265a5380c929f0bc665d62256628ce9ef91"
   integrity sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==
 
 cjs-module-lexer@^1.0.0:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/cjs-module-lexer/-/cjs-module-lexer-1.2.3.tgz#6c370ab19f8a3394e318fe682686ec0ac684d107"
+  resolved "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.2.3.tgz#6c370ab19f8a3394e318fe682686ec0ac684d107"
   integrity sha512-0TNiGstbQmCFwt4akjjBg5pLRTSyj/PkWQ1ZoO2zntmg9yLqSRxwEa4iCfQLGjqhiqBfOJa7W/E8wfGrTDmlZQ==
 
 class-utils@^0.3.5:
   version "0.3.6"
-  resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
+  resolved "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
   integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
   dependencies:
     arr-union "^3.1.0"
@@ -2196,28 +2309,28 @@ class-utils@^0.3.5:
 
 clean-regexp@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/clean-regexp/-/clean-regexp-1.0.0.tgz#8df7c7aae51fd36874e8f8d05b9180bc11a3fed7"
+  resolved "https://registry.npmjs.org/clean-regexp/-/clean-regexp-1.0.0.tgz#8df7c7aae51fd36874e8f8d05b9180bc11a3fed7"
   integrity sha512-GfisEZEJvzKrmGWkvfhgzcz/BllN1USeqD2V6tg14OAOgaCD2Z/PUEuxnAZ/nPvmaHRG7a8y77p1T/IRQ4D1Hw==
   dependencies:
     escape-string-regexp "^1.0.5"
 
 clean-stack@^4.0.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-4.2.0.tgz#c464e4cde4ac789f4e0735c5d75beb49d7b30b31"
+  resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-4.2.0.tgz#c464e4cde4ac789f4e0735c5d75beb49d7b30b31"
   integrity sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg==
   dependencies:
     escape-string-regexp "5.0.0"
 
 cli-cursor@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
+  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
   integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
   dependencies:
     restore-cursor "^3.1.0"
 
 cliui@^3.2.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
+  resolved "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz#120601537a916d29940f934da3b48d585a39213d"
   integrity sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==
   dependencies:
     string-width "^1.0.1"
@@ -2226,7 +2339,7 @@ cliui@^3.2.0:
 
 cliui@^8.0.1:
   version "8.0.1"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa"
+  resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz#0c04b075db02cbfe60dc8e6cf2f5486b1a3608aa"
   integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==
   dependencies:
     string-width "^4.2.0"
@@ -2235,22 +2348,22 @@ cliui@^8.0.1:
 
 clone-buffer@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"
+  resolved "https://registry.npmjs.org/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"
   integrity sha512-KLLTJWrvwIP+OPfMn0x2PheDEP20RPUcGXj/ERegTgdmPEZylALQldygiqrPPu8P45uNuPs7ckmReLY6v/iA5g==
 
 clone-stats@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-1.0.0.tgz#b3782dff8bb5474e18b9b6bf0fdfe782f8777680"
+  resolved "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz#b3782dff8bb5474e18b9b6bf0fdfe782f8777680"
   integrity sha512-au6ydSpg6nsrigcZ4m8Bc9hxjeW+GJ8xh5G3BJCMt4WXe1H10UNaVOamqQTmrx1kjVuxAHIQSNU6hY4Nsn9/ag==
 
 clone@^2.1.1, clone@^2.1.2:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
+  resolved "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
   integrity sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w==
 
 cloneable-readable@^1.0.0:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/cloneable-readable/-/cloneable-readable-1.1.3.tgz#120a00cb053bfb63a222e709f9683ea2e11d8cec"
+  resolved "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.3.tgz#120a00cb053bfb63a222e709f9683ea2e11d8cec"
   integrity sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==
   dependencies:
     inherits "^2.0.1"
@@ -2259,22 +2372,22 @@ cloneable-readable@^1.0.0:
 
 co@^4.6.0:
   version "4.6.0"
-  resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
+  resolved "https://registry.npmjs.org/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184"
   integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==
 
 code-point-at@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
+  resolved "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
   integrity sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==
 
 collect-v8-coverage@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/collect-v8-coverage/-/collect-v8-coverage-1.0.1.tgz#cc2c8e94fc18bbdffe64d6534570c8a673b27f59"
-  integrity sha512-iBPtljfCNcTKNAto0KEtDfZ3qzjJvqE3aTGZsbhjSBlorqpXJlaWWtPO35D+ZImoC3KWejX64o+yPGxhWSTzfg==
+  version "1.0.2"
+  resolved "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.2.tgz#c0b29bcd33bcd0779a1344c2136051e6afd3d9e9"
+  integrity sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==
 
 collection-map@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/collection-map/-/collection-map-1.0.0.tgz#aea0f06f8d26c780c2b75494385544b2255af18c"
+  resolved "https://registry.npmjs.org/collection-map/-/collection-map-1.0.0.tgz#aea0f06f8d26c780c2b75494385544b2255af18c"
   integrity sha512-5D2XXSpkOnleOI21TG7p3T0bGAsZ/XknZpKBmGYyluO8pw4zA3K8ZlrBIbC4FXg3m6z/RNFiUFfT2sQK01+UHA==
   dependencies:
     arr-map "^2.0.2"
@@ -2283,7 +2396,7 @@ collection-map@^1.0.0:
 
 collection-visit@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
+  resolved "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
   integrity sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw==
   dependencies:
     map-visit "^1.0.0"
@@ -2291,36 +2404,36 @@ collection-visit@^1.0.0:
 
 color-convert@^1.9.0:
   version "1.9.3"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
   integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
   dependencies:
     color-name "1.1.3"
 
 color-convert@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
   integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
   dependencies:
     color-name "~1.1.4"
 
 color-name@1.1.3:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
   integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==
 
 color-name@~1.1.4:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
 color-support@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-support/-/color-support-1.1.3.tgz#93834379a1cc9a0c61f82f52f0d04322251bd5a2"
+  resolved "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz#93834379a1cc9a0c61f82f52f0d04322251bd5a2"
   integrity sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==
 
-command-line-args@5.2.1, command-line-args@^5.2.1:
+command-line-args@^5.2.1:
   version "5.2.1"
-  resolved "https://registry.yarnpkg.com/command-line-args/-/command-line-args-5.2.1.tgz#c44c32e437a57d7c51157696893c5909e9cec42e"
+  resolved "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz#c44c32e437a57d7c51157696893c5909e9cec42e"
   integrity sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==
   dependencies:
     array-back "^3.1.0"
@@ -2328,9 +2441,9 @@ command-line-args@5.2.1, command-line-args@^5.2.1:
     lodash.camelcase "^4.3.0"
     typical "^4.0.0"
 
-command-line-usage@7.0.1, command-line-usage@^7.0.0:
+command-line-usage@^7.0.0, command-line-usage@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.yarnpkg.com/command-line-usage/-/command-line-usage-7.0.1.tgz#e540afef4a4f3bc501b124ffde33956309100655"
+  resolved "https://registry.npmjs.org/command-line-usage/-/command-line-usage-7.0.1.tgz#e540afef4a4f3bc501b124ffde33956309100655"
   integrity sha512-NCyznE//MuTjwi3y84QVUGEOT+P5oto1e1Pk/jFPVdPPfsG03qpTIl3yw6etR+v73d0lXsoojRpvbru2sqePxQ==
   dependencies:
     array-back "^6.2.2"
@@ -2340,37 +2453,37 @@ command-line-usage@7.0.1, command-line-usage@^7.0.0:
 
 commander@^2.20.0:
   version "2.20.3"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
 commander@^6.1.0:
   version "6.2.1"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c"
+  resolved "https://registry.npmjs.org/commander/-/commander-6.2.1.tgz#0792eb682dfbc325999bb2b84fddddba110ac73c"
   integrity sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==
 
 commander@^7.2.0:
   version "7.2.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7"
+  resolved "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz#a36cb57d0b501ce108e4d20559a150a391d97ab7"
   integrity sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==
 
 common-tags@^1.8.0:
   version "1.8.2"
-  resolved "https://registry.yarnpkg.com/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6"
+  resolved "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz#94ebb3c076d26032745fd54face7f688ef5ac9c6"
   integrity sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==
 
 component-emitter@^1.2.1:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
+  resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
   integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
 
 concat-map@0.0.1:
   version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==
 
 concat-stream@^1.6.0:
   version "1.6.2"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
+  resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
   dependencies:
     buffer-from "^1.0.0"
@@ -2380,22 +2493,22 @@ concat-stream@^1.6.0:
 
 convert-source-map@^1.0.0, convert-source-map@^1.5.0, convert-source-map@^1.6.0, convert-source-map@^1.7.0:
   version "1.9.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
+  resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
   integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==
 
 convert-source-map@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a"
+  resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz#4b560f649fc4e918dd0ab75cf4961e8bc882d82a"
   integrity sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==
 
 copy-descriptor@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
+  resolved "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
   integrity sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw==
 
 copy-props@^2.0.1:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/copy-props/-/copy-props-2.0.5.tgz#03cf9ae328d4ebb36f8f1d804448a6af9ee3f2d2"
+  resolved "https://registry.npmjs.org/copy-props/-/copy-props-2.0.5.tgz#03cf9ae328d4ebb36f8f1d804448a6af9ee3f2d2"
   integrity sha512-XBlx8HSqrT0ObQwmSzM7WE5k8FxTV75h1DX1Z3n6NhQ/UYYAvInWYmG06vFt7hQZArE2fuO62aihiWIVQwh1sw==
   dependencies:
     each-props "^1.3.2"
@@ -2403,24 +2516,37 @@ copy-props@^2.0.1:
 
 core-util-is@~1.0.0:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
+  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
   integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
 
+create-jest@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/create-jest/-/create-jest-29.7.0.tgz#a355c5b3cb1e1af02ba177fe7afd7feee49a5320"
+  integrity sha512-Adz2bdH0Vq3F53KEMJOoftQFutWCukm6J24wbPWRO4k1kMY7gS7ds/uoJkNuV8wDCtWWnuwGcJwpWcih+zEW1Q==
+  dependencies:
+    "@jest/types" "^29.6.3"
+    chalk "^4.0.0"
+    exit "^0.1.2"
+    graceful-fs "^4.2.9"
+    jest-config "^29.7.0"
+    jest-util "^29.7.0"
+    prompts "^2.0.1"
+
 create-require@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
+  resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
   integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
 
 cross-env@7.0.3:
   version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-env/-/cross-env-7.0.3.tgz#865264b29677dc015ba8418918965dd232fc54cf"
+  resolved "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz#865264b29677dc015ba8418918965dd232fc54cf"
   integrity sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==
   dependencies:
     cross-spawn "^7.0.1"
 
 cross-spawn@^7.0.0, cross-spawn@^7.0.1, cross-spawn@^7.0.2, cross-spawn@^7.0.3:
   version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
   integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
   dependencies:
     path-key "^3.1.0"
@@ -2429,7 +2555,7 @@ cross-spawn@^7.0.0, cross-spawn@^7.0.1, cross-spawn@^7.0.2, cross-spawn@^7.0.3:
 
 css@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/css/-/css-3.0.0.tgz#4447a4d58fdd03367c516ca9f64ae365cee4aa5d"
+  resolved "https://registry.npmjs.org/css/-/css-3.0.0.tgz#4447a4d58fdd03367c516ca9f64ae365cee4aa5d"
   integrity sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==
   dependencies:
     inherits "^2.0.4"
@@ -2438,7 +2564,7 @@ css@^3.0.0:
 
 d@1, d@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a"
+  resolved "https://registry.npmjs.org/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a"
   integrity sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==
   dependencies:
     es5-ext "^0.10.50"
@@ -2446,7 +2572,7 @@ d@1, d@^1.0.1:
 
 debug-fabulous@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/debug-fabulous/-/debug-fabulous-1.1.0.tgz#af8a08632465224ef4174a9f06308c3c2a1ebc8e"
+  resolved "https://registry.npmjs.org/debug-fabulous/-/debug-fabulous-1.1.0.tgz#af8a08632465224ef4174a9f06308c3c2a1ebc8e"
   integrity sha512-GZqvGIgKNlUnHUPQhepnUZFIMoi3dgZKQBzKDeL2g7oJF9SNAji/AAu36dusFUas0O+pae74lNeoIPHqXWDkLg==
   dependencies:
     debug "3.X"
@@ -2455,28 +2581,28 @@ debug-fabulous@^1.0.0:
 
 debug@3.X:
   version "3.2.7"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
+  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
   integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
   dependencies:
     ms "^2.1.1"
 
 debug@^2.2.0, debug@^2.3.3:
   version "2.6.9"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
 debug@^4.1.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.4:
   version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
   integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
   dependencies:
     ms "2.1.2"
 
 decamelize-keys@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8"
+  resolved "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8"
   integrity sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==
   dependencies:
     decamelize "^1.1.0"
@@ -2484,71 +2610,81 @@ decamelize-keys@^1.1.0:
 
 decamelize@^1.1.0, decamelize@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
+  resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
 
 decamelize@^5.0.0:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-5.0.1.tgz#db11a92e58c741ef339fb0a2868d8a06a9a7b1e9"
+  resolved "https://registry.npmjs.org/decamelize/-/decamelize-5.0.1.tgz#db11a92e58c741ef339fb0a2868d8a06a9a7b1e9"
   integrity sha512-VfxadyCECXgQlkoEAjeghAr5gY3Hf+IKjKb+X8tGVDtveCjN+USwprd2q3QXBR9T1+x2DG0XZF5/w+7HAtSaXA==
 
 decode-uri-component@^0.2.0:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.2.tgz#e69dbe25d37941171dd540e024c444cd5188e1e9"
+  resolved "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz#e69dbe25d37941171dd540e024c444cd5188e1e9"
   integrity sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==
 
 dedent@^1.0.0:
   version "1.5.1"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-1.5.1.tgz#4f3fc94c8b711e9bb2800d185cd6ad20f2a90aff"
+  resolved "https://registry.npmjs.org/dedent/-/dedent-1.5.1.tgz#4f3fc94c8b711e9bb2800d185cd6ad20f2a90aff"
   integrity sha512-+LxW+KLWxu3HW3M2w2ympwtqPrqYRzU8fqi6Fhd18fBALe15blJPI/I4+UHveMVG6lJqB4JNd4UG0S5cnVHwIg==
 
 deep-is@^0.1.3:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
+  resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
   integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
 
 deepmerge@^4.2.2:
   version "4.3.1"
-  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
+  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz#44b5f2147cd3b00d4b56137685966f26fd25dd4a"
   integrity sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==
 
 default-compare@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/default-compare/-/default-compare-1.0.0.tgz#cb61131844ad84d84788fb68fd01681ca7781a2f"
+  resolved "https://registry.npmjs.org/default-compare/-/default-compare-1.0.0.tgz#cb61131844ad84d84788fb68fd01681ca7781a2f"
   integrity sha512-QWfXlM0EkAbqOCbD/6HjdwT19j7WCkMyiRhWilc4H9/5h/RzTF9gv5LYh1+CmDV5d1rki6KAWLtQale0xt20eQ==
   dependencies:
     kind-of "^5.0.2"
 
 default-resolution@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/default-resolution/-/default-resolution-2.0.0.tgz#bcb82baa72ad79b426a76732f1a81ad6df26d684"
+  resolved "https://registry.npmjs.org/default-resolution/-/default-resolution-2.0.0.tgz#bcb82baa72ad79b426a76732f1a81ad6df26d684"
   integrity sha512-2xaP6GiwVwOEbXCGoJ4ufgC76m8cj805jrghScewJC2ZDsb9U0b4BIrba+xt/Uytyd0HvQ6+WymSRTfnYj59GQ==
 
+define-data-property@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.0.tgz#0db13540704e1d8d479a0656cf781267531b9451"
+  integrity sha512-UzGwzcjyv3OtAvolTj1GoyNYzfFR+iqbGjcnBEENZVCpM4/Ng1yhGNvS3lR/xDS74Tb2wGG9WzNSNIOS9UVb2g==
+  dependencies:
+    get-intrinsic "^1.2.1"
+    gopd "^1.0.1"
+    has-property-descriptors "^1.0.0"
+
 define-properties@^1.1.4:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.0.tgz#52988570670c9eacedd8064f4a990f2405849bd5"
-  integrity sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==
+  version "1.2.1"
+  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c"
+  integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==
   dependencies:
+    define-data-property "^1.0.1"
     has-property-descriptors "^1.0.0"
     object-keys "^1.1.1"
 
 define-property@^0.2.5:
   version "0.2.5"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
   integrity sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA==
   dependencies:
     is-descriptor "^0.1.0"
 
 define-property@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
   integrity sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==
   dependencies:
     is-descriptor "^1.0.0"
 
 define-property@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
   integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
   dependencies:
     is-descriptor "^1.0.2"
@@ -2556,7 +2692,7 @@ define-property@^2.0.2:
 
 del-cli@5.1.0:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/del-cli/-/del-cli-5.1.0.tgz#740eca1c7a9eb13043e68d8a361cf0ff9a18d5c8"
+  resolved "https://registry.npmjs.org/del-cli/-/del-cli-5.1.0.tgz#740eca1c7a9eb13043e68d8a361cf0ff9a18d5c8"
   integrity sha512-xwMeh2acluWeccsfzE7VLsG3yTr7nWikbfw+xhMnpRrF15pGSkw+3/vJZWlGoE4I86UiLRNHicmKt4tkIX9Jtg==
   dependencies:
     del "^7.1.0"
@@ -2564,7 +2700,7 @@ del-cli@5.1.0:
 
 del@7.1.0, del@^7.1.0:
   version "7.1.0"
-  resolved "https://registry.yarnpkg.com/del/-/del-7.1.0.tgz#0de0044d556b649ff05387f1fa7c885e155fd1b6"
+  resolved "https://registry.npmjs.org/del/-/del-7.1.0.tgz#0de0044d556b649ff05387f1fa7c885e155fd1b6"
   integrity sha512-v2KyNk7efxhlyHpjEvfyxaAihKKK0nWCuf6ZtqZcFFpQRG0bJ12Qsr0RpvsICMjAAZ8DOVCxrlqpxISlMHC4Kg==
   dependencies:
     globby "^13.1.2"
@@ -2578,51 +2714,51 @@ del@7.1.0, del@^7.1.0:
 
 detect-file@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
+  resolved "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
   integrity sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==
 
 detect-newline@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2"
+  resolved "https://registry.npmjs.org/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2"
   integrity sha512-CwffZFvlJffUg9zZA0uqrjQayUTC8ob94pnr5sFwaVv3IOmkfUHcWH+jXaQK3askE51Cqe8/9Ql/0uXNwqZ8Zg==
 
 detect-newline@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651"
+  resolved "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651"
   integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==
 
-diff-sequences@^29.4.3:
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.4.3.tgz#9314bc1fabe09267ffeca9cbafc457d8499a13f2"
-  integrity sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==
+diff-sequences@^29.6.3:
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz#4deaf894d11407c51efc8418012f9e70b84ea921"
+  integrity sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==
 
 diff@^4.0.1:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+  resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
 dir-glob@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
+  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
   integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
   dependencies:
     path-type "^4.0.0"
 
 doctrine@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
+  resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
   integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
   dependencies:
     esutils "^2.0.2"
 
 duplexer@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
+  resolved "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
   integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==
 
 duplexify@^3.6.0:
   version "3.7.1"
-  resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
+  resolved "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz#2a4df5317f6ccfd91f86d6fd25d8d8a103b88309"
   integrity sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==
   dependencies:
     end-of-stream "^1.0.0"
@@ -2632,7 +2768,7 @@ duplexify@^3.6.0:
 
 each-props@^1.3.2:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/each-props/-/each-props-1.3.2.tgz#ea45a414d16dd5cfa419b1a81720d5ca06892333"
+  resolved "https://registry.npmjs.org/each-props/-/each-props-1.3.2.tgz#ea45a414d16dd5cfa419b1a81720d5ca06892333"
   integrity sha512-vV0Hem3zAGkJAyU7JSjixeU66rwdynTAa1vofCrSA5fEln+m67Az9CcnkVD776/fsN/UjIWmBDoNRS6t6G9RfA==
   dependencies:
     is-plain-object "^2.0.1"
@@ -2640,66 +2776,66 @@ each-props@^1.3.2:
 
 eastasianwidth@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
+  resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
   integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
-electron-to-chromium@^1.4.411:
-  version "1.4.427"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.427.tgz#67e8069f7a864fc092fe2e09f196e68af5cb88a1"
-  integrity sha512-HK3r9l+Jm8dYAm1ctXEWIC+hV60zfcjS9UA5BDlYvnI5S7PU/yytjpvSrTNrSSRRkuu3tDyZhdkwIczh+0DWaw==
+electron-to-chromium@^1.4.477:
+  version "1.4.520"
+  resolved "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.520.tgz#c19c25a10d87bd88a9aae2b76cae9235a50c2994"
+  integrity sha512-Frfus2VpYADsrh1lB3v/ft/WVFlVzOIm+Q0p7U7VqHI6qr7NWHYKe+Wif3W50n7JAFoBsWVsoU0+qDks6WQ60g==
 
 emittery@^0.13.1:
   version "0.13.1"
-  resolved "https://registry.yarnpkg.com/emittery/-/emittery-0.13.1.tgz#c04b8c3457490e0847ae51fced3af52d338e3dad"
+  resolved "https://registry.npmjs.org/emittery/-/emittery-0.13.1.tgz#c04b8c3457490e0847ae51fced3af52d338e3dad"
   integrity sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==
 
 emoji-regex@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
 emoji-regex@^9.2.2:
   version "9.2.2"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
 end-of-stream@^1.0.0, end-of-stream@^1.1.0, end-of-stream@^1.4.4:
   version "1.4.4"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
+  resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
   integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
   dependencies:
     once "^1.4.0"
 
 enhanced-resolve@^5.14.1:
-  version "5.14.1"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.14.1.tgz#de684b6803724477a4af5d74ccae5de52c25f6b3"
-  integrity sha512-Vklwq2vDKtl0y/vtwjSesgJ5MYS7Etuk5txS8VdKL4AOS1aUlD96zqIfsOSLQsdv3xgMRbtkWM8eG9XDfKUPow==
+  version "5.15.0"
+  resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.15.0.tgz#1af946c7d93603eb88e9896cee4904dc012e9c35"
+  integrity sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==
   dependencies:
     graceful-fs "^4.2.4"
     tapable "^2.2.0"
 
 errno@^0.1.3:
   version "0.1.8"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
+  resolved "https://registry.npmjs.org/errno/-/errno-0.1.8.tgz#8bb3e9c7d463be4976ff888f76b4809ebc2e811f"
   integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==
   dependencies:
     prr "~1.0.1"
 
 error-ex@^1.2.0, error-ex@^1.3.1:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
+  resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
   integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
   dependencies:
     is-arrayish "^0.2.1"
 
 es-module-lexer@^1.2.1:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.3.0.tgz#6be9c9e0b4543a60cd166ff6f8b4e9dae0b0c16f"
-  integrity sha512-vZK7T0N2CBmBOixhmjdqx2gWVbFZ4DXZ/NyRMZVlJXPa7CyFS+/a4QQsDGDQy9ZfEzxFuNEsMLeQJnKP2p5/JA==
+  version "1.3.1"
+  resolved "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.3.1.tgz#c1b0dd5ada807a3b3155315911f364dc4e909db1"
+  integrity sha512-JUFAyicQV9mXc3YRxPnDlrfBKpqt6hUYzz9/boprUJHs4e4KVr3XwOF70doO6gwXUor6EWZJAyWAfKki84t20Q==
 
 es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@^0.10.53, es5-ext@~0.10.14, es5-ext@~0.10.2, es5-ext@~0.10.46:
   version "0.10.62"
-  resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.62.tgz#5e6adc19a6da524bf3d1e02bbc8960e5eb49a9a5"
+  resolved "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.62.tgz#5e6adc19a6da524bf3d1e02bbc8960e5eb49a9a5"
   integrity sha512-BHLqn0klhEpnOKSrzn/Xsz2UIW8j+cGmo9JLzr8BiUapV8hPL9+FliFqjwr9ngW7jWdnxv6eO+/LqyhJVqgrjA==
   dependencies:
     es6-iterator "^2.0.3"
@@ -2708,7 +2844,7 @@ es5-ext@^0.10.35, es5-ext@^0.10.46, es5-ext@^0.10.50, es5-ext@^0.10.53, es5-ext@
 
 es6-iterator@^2.0.1, es6-iterator@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
+  resolved "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
   integrity sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==
   dependencies:
     d "1"
@@ -2717,7 +2853,7 @@ es6-iterator@^2.0.1, es6-iterator@^2.0.3:
 
 es6-symbol@^3.1.1, es6-symbol@^3.1.3:
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
+  resolved "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
   integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==
   dependencies:
     d "^1.0.1"
@@ -2725,7 +2861,7 @@ es6-symbol@^3.1.1, es6-symbol@^3.1.3:
 
 es6-weak-map@^2.0.1, es6-weak-map@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/es6-weak-map/-/es6-weak-map-2.0.3.tgz#b6da1f16cc2cc0d9be43e6bdbfc5e7dfcdf31d53"
+  resolved "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.3.tgz#b6da1f16cc2cc0d9be43e6bdbfc5e7dfcdf31d53"
   integrity sha512-p5um32HOTO1kP+w7PRnB+5lQ43Z6muuMuIMffvDN8ZB4GcnjLBV6zGStpbASIMk4DCAvEaamhe2zhyCb/QXXsA==
   dependencies:
     d "1"
@@ -2735,12 +2871,12 @@ es6-weak-map@^2.0.1, es6-weak-map@^2.0.3:
 
 esbuild-plugin-alias@0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/esbuild-plugin-alias/-/esbuild-plugin-alias-0.2.1.tgz#45a86cb941e20e7c2bc68a2bea53562172494fcb"
+  resolved "https://registry.npmjs.org/esbuild-plugin-alias/-/esbuild-plugin-alias-0.2.1.tgz#45a86cb941e20e7c2bc68a2bea53562172494fcb"
   integrity sha512-jyfL/pwPqaFXyKnj8lP8iLk6Z0m099uXR45aSN8Av1XD4vhvQutxxPzgA2bTcAwQpa1zCXDcWOlhFgyP3GKqhQ==
 
 esbuild@0.19.2:
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.19.2.tgz#b1541828a89dfb6f840d38538767c6130dca2aac"
+  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.19.2.tgz#b1541828a89dfb6f840d38538767c6130dca2aac"
   integrity sha512-G6hPax8UbFakEj3hWO0Vs52LQ8k3lnBhxZWomUJDxfz3rZTLqF5k/FCzuNdLx2RbpBiQQF9H9onlDDH1lZsnjg==
   optionalDependencies:
     "@esbuild/android-arm" "0.19.2"
@@ -2768,7 +2904,7 @@ esbuild@0.19.2:
 
 esbuild@^0.17.11:
   version "0.17.19"
-  resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.17.19.tgz#087a727e98299f0462a3d0bcdd9cd7ff100bd955"
+  resolved "https://registry.npmjs.org/esbuild/-/esbuild-0.17.19.tgz#087a727e98299f0462a3d0bcdd9cd7ff100bd955"
   integrity sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==
   optionalDependencies:
     "@esbuild/android-arm" "0.17.19"
@@ -2796,27 +2932,27 @@ esbuild@^0.17.11:
 
 escalade@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
+  resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
   integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
 
 escape-string-regexp@5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz#4683126b500b61762f2dbebace1806e8be31b1c8"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz#4683126b500b61762f2dbebace1806e8be31b1c8"
   integrity sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==
 
 escape-string-regexp@^1.0.3, escape-string-regexp@^1.0.5:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
   integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==
 
 escape-string-regexp@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344"
   integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==
 
 escape-string-regexp@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
   integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
 
 eslint-plugin-jest@27.4.2:
@@ -2828,7 +2964,7 @@ eslint-plugin-jest@27.4.2:
 
 eslint-plugin-unicorn@47.0.0:
   version "47.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-unicorn/-/eslint-plugin-unicorn-47.0.0.tgz#960e9d3789f656ba3e21982420793b069a911011"
+  resolved "https://registry.npmjs.org/eslint-plugin-unicorn/-/eslint-plugin-unicorn-47.0.0.tgz#960e9d3789f656ba3e21982420793b069a911011"
   integrity sha512-ivB3bKk7fDIeWOUmmMm9o3Ax9zbMz1Bsza/R2qm46ufw4T6VBFBaJIR1uN3pCKSmSXm8/9Nri8V+iUut1NhQGA==
   dependencies:
     "@babel/helper-validator-identifier" "^7.19.1"
@@ -2850,28 +2986,28 @@ eslint-plugin-unicorn@47.0.0:
 
 eslint-scope@5.1.1, eslint-scope@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
   integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^4.1.1"
 
 eslint-scope@^7.2.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.2.0.tgz#f21ebdafda02352f103634b96dd47d9f81ca117b"
-  integrity sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw==
+  version "7.2.2"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f"
+  integrity sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^5.2.0"
 
 eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1:
-  version "3.4.1"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.1.tgz#c22c48f48942d08ca824cc526211ae400478a994"
-  integrity sha512-pZnmmLwYzf+kWaM/Qgrvpen51upAktaaiI01nsJD/Yr3lMOdNtq0cxkrrg16w64VtisN6okbs7Q8AfGqj4c9fA==
+  version "3.4.3"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800"
+  integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==
 
 eslint@8.42.0:
   version "8.42.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.42.0.tgz#7bebdc3a55f9ed7167251fe7259f75219cade291"
+  resolved "https://registry.npmjs.org/eslint/-/eslint-8.42.0.tgz#7bebdc3a55f9ed7167251fe7259f75219cade291"
   integrity sha512-ulg9Ms6E1WPf67PHaEY4/6E2tEn5/f7FXGzr3t9cBMugOmf1INYvuUwwh1aXQN4MfJ6a5K2iNwP3w4AColvI9A==
   dependencies:
     "@eslint-community/eslint-utils" "^4.2.0"
@@ -2918,57 +3054,57 @@ eslint@8.42.0:
   version "3.2.25"
   resolved "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz#c463cfa4e14aceea6b7cd7e669ef90de072ea60a"
 
-espree@^9.5.2:
-  version "9.5.2"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-9.5.2.tgz#e994e7dc33a082a7a82dceaf12883a829353215b"
-  integrity sha512-7OASN1Wma5fum5SrNhFMAMJxOUAbhyfQ8dQ//PJaJbNw0URTPWqIghHWt1MmAANKhHZIYOHruW4Kw4ruUWOdGw==
+espree@^9.5.2, espree@^9.6.0:
+  version "9.6.1"
+  resolved "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f"
+  integrity sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==
   dependencies:
-    acorn "^8.8.0"
+    acorn "^8.9.0"
     acorn-jsx "^5.3.2"
     eslint-visitor-keys "^3.4.1"
 
 esprima@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
+  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
 esquery@^1.4.2, esquery@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b"
+  resolved "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz#6ce17738de8577694edd7361c57182ac8cb0db0b"
   integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==
   dependencies:
     estraverse "^5.1.0"
 
 esrecurse@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
+  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
   integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
   dependencies:
     estraverse "^5.2.0"
 
 estraverse@^4.1.1:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
   integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
 
 estraverse@^5.1.0, estraverse@^5.2.0:
   version "5.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
   integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
 
 estree-walker@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
   integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
 
 esutils@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
+  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 event-emitter@^0.3.5:
   version "0.3.5"
-  resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39"
+  resolved "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz#df8c69eef1647923c7157b9ce83840610b02cc39"
   integrity sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==
   dependencies:
     d "1"
@@ -2976,12 +3112,12 @@ event-emitter@^0.3.5:
 
 events@^3.2.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
+  resolved "https://registry.npmjs.org/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
 execa@^5.0.0:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
+  resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
   integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
   dependencies:
     cross-spawn "^7.0.3"
@@ -2996,12 +3132,12 @@ execa@^5.0.0:
 
 exit@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
+  resolved "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
   integrity sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==
 
 expand-brackets@^2.1.4:
   version "2.1.4"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
+  resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
   integrity sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA==
   dependencies:
     debug "^2.3.3"
@@ -3014,40 +3150,39 @@ expand-brackets@^2.1.4:
 
 expand-tilde@^2.0.0, expand-tilde@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
+  resolved "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
   integrity sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==
   dependencies:
     homedir-polyfill "^1.0.1"
 
-expect@^29.0.0, expect@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/expect/-/expect-29.6.2.tgz#7b08e83eba18ddc4a2cf62b5f2d1918f5cd84521"
-  integrity sha512-iAErsLxJ8C+S02QbLAwgSGSezLQK+XXRDt8IuFXFpwCNw2ECmzZSmjKcCaFVp5VRMk+WAvz6h6jokzEzBFZEuA==
+expect@^29.0.0, expect@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/expect/-/expect-29.7.0.tgz#578874590dcb3214514084c08115d8aee61e11bc"
+  integrity sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==
   dependencies:
-    "@jest/expect-utils" "^29.6.2"
-    "@types/node" "*"
-    jest-get-type "^29.4.3"
-    jest-matcher-utils "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-util "^29.6.2"
+    "@jest/expect-utils" "^29.7.0"
+    jest-get-type "^29.6.3"
+    jest-matcher-utils "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-util "^29.7.0"
 
 ext@^1.1.2:
   version "1.7.0"
-  resolved "https://registry.yarnpkg.com/ext/-/ext-1.7.0.tgz#0ea4383c0103d60e70be99e9a7f11027a33c4f5f"
+  resolved "https://registry.npmjs.org/ext/-/ext-1.7.0.tgz#0ea4383c0103d60e70be99e9a7f11027a33c4f5f"
   integrity sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==
   dependencies:
     type "^2.7.2"
 
 extend-shallow@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
+  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
   integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==
   dependencies:
     is-extendable "^0.1.0"
 
 extend-shallow@^3.0.0, extend-shallow@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
+  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
   integrity sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==
   dependencies:
     assign-symbols "^1.0.0"
@@ -3055,12 +3190,12 @@ extend-shallow@^3.0.0, extend-shallow@^3.0.2:
 
 extend@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
+  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
 extglob@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
+  resolved "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
   integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
   dependencies:
     array-unique "^0.3.2"
@@ -3074,7 +3209,7 @@ extglob@^2.0.4:
 
 fancy-log@^1.3.2, fancy-log@^1.3.3:
   version "1.3.3"
-  resolved "https://registry.yarnpkg.com/fancy-log/-/fancy-log-1.3.3.tgz#dbc19154f558690150a23953a0adbd035be45fc7"
+  resolved "https://registry.npmjs.org/fancy-log/-/fancy-log-1.3.3.tgz#dbc19154f558690150a23953a0adbd035be45fc7"
   integrity sha512-k9oEhlyc0FrVh25qYuSELjr8oxsCoc4/LEZfg2iJJrfEk/tZL9bCoJE47gqAvI2m/AUjluCS4+3I0eTx8n3AEw==
   dependencies:
     ansi-gray "^0.1.1"
@@ -3084,25 +3219,25 @@ fancy-log@^1.3.2, fancy-log@^1.3.3:
 
 fancy-log@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/fancy-log/-/fancy-log-2.0.0.tgz#cad207b8396d69ae4796d74d17dff5f68b2f7343"
+  resolved "https://registry.npmjs.org/fancy-log/-/fancy-log-2.0.0.tgz#cad207b8396d69ae4796d74d17dff5f68b2f7343"
   integrity sha512-9CzxZbACXMUXW13tS0tI8XsGGmxWzO2DmYrGuBJOJ8k8q2K7hwfJA5qHjuPPe8wtsco33YR9wc+Rlr5wYFvhSA==
   dependencies:
     color-support "^1.1.3"
 
 fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
+  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
 fast-fifo@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/fast-fifo/-/fast-fifo-1.2.0.tgz#2ee038da2468e8623066dee96958b0c1763aa55a"
-  integrity sha512-NcvQXt7Cky1cNau15FWy64IjuO8X0JijhTBBrJj1YlxlDfRkJXNaK9RFUjwpfDPzMdv7wB38jr53l9tkNLxnWg==
+  version "1.3.2"
+  resolved "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz#286e31de96eb96d38a97899815740ba2a4f3640c"
+  integrity sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==
 
-fast-glob@^3.2.11, fast-glob@^3.2.9:
-  version "3.2.12"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.12.tgz#7f39ec99c2e6ab030337142da9e0c18f37afae80"
-  integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==
+fast-glob@^3.2.9, fast-glob@^3.3.0:
+  version "3.3.1"
+  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.1.tgz#784b4e897340f3dbbef17413b3f11acf03c874c4"
+  integrity sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==
   dependencies:
     "@nodelib/fs.stat" "^2.0.2"
     "@nodelib/fs.walk" "^1.2.3"
@@ -3112,53 +3247,53 @@ fast-glob@^3.2.11, fast-glob@^3.2.9:
 
 fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.0.0, fast-json-stable-stringify@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
+  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
   integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
 
 fast-levenshtein@^1.0.0:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz#e6a754cc8f15e58987aa9cbd27af66fd6f4e5af9"
+  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-1.1.4.tgz#e6a754cc8f15e58987aa9cbd27af66fd6f4e5af9"
   integrity sha512-Ia0sQNrMPXXkqVFt6w6M1n1oKo3NfKs+mvaV811Jwir7vAk9a6PVV9VPYf6X3BU97QiLEmuW3uXH9u87zDFfdw==
 
 fast-levenshtein@^2.0.6:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
+  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
   integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==
 
 fastq@^1.6.0:
   version "1.15.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.15.0.tgz#d04d07c6a2a68fe4599fea8d2e103a937fae6b3a"
+  resolved "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz#d04d07c6a2a68fe4599fea8d2e103a937fae6b3a"
   integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==
   dependencies:
     reusify "^1.0.4"
 
 fb-watchman@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c"
+  resolved "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c"
   integrity sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==
   dependencies:
     bser "2.1.1"
 
 file-entry-cache@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
+  resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
   integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
   dependencies:
     flat-cache "^3.0.4"
 
 file-uri-to-path@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
+  resolved "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
   integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
 
 filesize@^9.0.11:
   version "9.0.11"
-  resolved "https://registry.yarnpkg.com/filesize/-/filesize-9.0.11.tgz#4ac3a42c084232dd9b2a1da0107f32d42fcfa5e4"
+  resolved "https://registry.npmjs.org/filesize/-/filesize-9.0.11.tgz#4ac3a42c084232dd9b2a1da0107f32d42fcfa5e4"
   integrity sha512-gTAiTtI0STpKa5xesyTA9hA3LX4ga8sm2nWRcffEa1L/5vQwb4mj2MdzMkoHoGv4QzfDshQZuYscQSf8c4TKOA==
 
 fill-range@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
   integrity sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ==
   dependencies:
     extend-shallow "^2.0.1"
@@ -3168,21 +3303,21 @@ fill-range@^4.0.0:
 
 fill-range@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
   integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
   dependencies:
     to-regex-range "^5.0.1"
 
 find-replace@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/find-replace/-/find-replace-3.0.0.tgz#3e7e23d3b05167a76f770c9fbd5258b0def68c38"
+  resolved "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz#3e7e23d3b05167a76f770c9fbd5258b0def68c38"
   integrity sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==
   dependencies:
     array-back "^3.0.1"
 
 find-up@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
   integrity sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==
   dependencies:
     path-exists "^2.0.0"
@@ -3190,7 +3325,7 @@ find-up@^1.0.0:
 
 find-up@^4.0.0, find-up@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
   integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
   dependencies:
     locate-path "^5.0.0"
@@ -3198,7 +3333,7 @@ find-up@^4.0.0, find-up@^4.1.0:
 
 find-up@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
   integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
   dependencies:
     locate-path "^6.0.0"
@@ -3206,7 +3341,7 @@ find-up@^5.0.0:
 
 findup-sync@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-2.0.0.tgz#9326b1488c22d1a6088650a86901b2d9a90a2cbc"
+  resolved "https://registry.npmjs.org/findup-sync/-/findup-sync-2.0.0.tgz#9326b1488c22d1a6088650a86901b2d9a90a2cbc"
   integrity sha512-vs+3unmJT45eczmcAZ6zMJtxN3l/QXeccaXQx5cu/MeJMhewVfoWZqibRkOxPnmoR59+Zy5hjabfQc6JLSah4g==
   dependencies:
     detect-file "^1.0.0"
@@ -3216,7 +3351,7 @@ findup-sync@^2.0.0:
 
 findup-sync@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-3.0.0.tgz#17b108f9ee512dfb7a5c7f3c8b27ea9e1a9c08d1"
+  resolved "https://registry.npmjs.org/findup-sync/-/findup-sync-3.0.0.tgz#17b108f9ee512dfb7a5c7f3c8b27ea9e1a9c08d1"
   integrity sha512-YbffarhcicEhOrm4CtrwdKBdCuz576RLdhJDsIfvNtxUuhdRet1qZcsMjqbePtAseKdAnDyM/IyXbu7PRPRLYg==
   dependencies:
     detect-file "^1.0.0"
@@ -3226,7 +3361,7 @@ findup-sync@^3.0.0:
 
 fined@^1.0.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/fined/-/fined-1.2.0.tgz#d00beccf1aa2b475d16d423b0238b713a2c4a37b"
+  resolved "https://registry.npmjs.org/fined/-/fined-1.2.0.tgz#d00beccf1aa2b475d16d423b0238b713a2c4a37b"
   integrity sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==
   dependencies:
     expand-tilde "^2.0.2"
@@ -3237,30 +3372,31 @@ fined@^1.0.1:
 
 flagged-respawn@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/flagged-respawn/-/flagged-respawn-1.0.1.tgz#e7de6f1279ddd9ca9aac8a5971d618606b3aab41"
+  resolved "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.1.tgz#e7de6f1279ddd9ca9aac8a5971d618606b3aab41"
   integrity sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==
 
 flat-cache@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
-  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.1.0.tgz#0e54ab4a1a60fe87e2946b6b00657f1c99e1af3f"
+  integrity sha512-OHx4Qwrrt0E4jEIcI5/Xb+f+QmJYNj2rrK8wiIdQOIrB9WrrJL8cjZvXdXuBTkkEwEqLycb5BeZDV1o2i9bTew==
   dependencies:
-    flatted "^3.1.0"
+    flatted "^3.2.7"
+    keyv "^4.5.3"
     rimraf "^3.0.2"
 
-flatbuffers@23.5.26:
+flatbuffers@^23.5.26:
   version "23.5.26"
-  resolved "https://registry.yarnpkg.com/flatbuffers/-/flatbuffers-23.5.26.tgz#01358e272a61239f0faf3bfbe4e014f3ace9d746"
+  resolved "https://registry.npmjs.org/flatbuffers/-/flatbuffers-23.5.26.tgz#01358e272a61239f0faf3bfbe4e014f3ace9d746"
   integrity sha512-vE+SI9vrJDwi1oETtTIFldC/o9GsVKRM+s6EL0nQgxXlYV1Vc4Tk30hj4xGICftInKQKj1F3up2n8UbIVobISQ==
 
-flatted@^3.1.0:
+flatted@^3.2.7:
   version "3.2.7"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787"
+  resolved "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787"
   integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==
 
 flush-write-stream@^1.0.2:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.1.1.tgz#8dd7d873a1babc207d94ead0c2e0e44276ebf2e8"
+  resolved "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.1.1.tgz#8dd7d873a1babc207d94ead0c2e0e44276ebf2e8"
   integrity sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==
   dependencies:
     inherits "^2.0.3"
@@ -3268,19 +3404,19 @@ flush-write-stream@^1.0.2:
 
 for-in@^1.0.1, for-in@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
+  resolved "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
   integrity sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==
 
 for-own@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/for-own/-/for-own-1.0.0.tgz#c63332f415cedc4b04dbfe70cf836494c53cb44b"
+  resolved "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz#c63332f415cedc4b04dbfe70cf836494c53cb44b"
   integrity sha512-0OABksIGrxKK8K4kynWkQ7y1zounQxP+CWnyclVwj81KW3vlLlGUx57DKGcP/LH216GzqnstnPocF16Nxs0Ycg==
   dependencies:
     for-in "^1.0.1"
 
 foreground-child@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/foreground-child/-/foreground-child-3.1.1.tgz#1d173e776d75d2772fed08efe4a0de1ea1b12d0d"
+  resolved "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz#1d173e776d75d2772fed08efe4a0de1ea1b12d0d"
   integrity sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==
   dependencies:
     cross-spawn "^7.0.0"
@@ -3288,14 +3424,14 @@ foreground-child@^3.1.0:
 
 fragment-cache@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
+  resolved "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
   integrity sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA==
   dependencies:
     map-cache "^0.2.2"
 
 fs-extra@^10.0.0:
   version "10.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
+  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
   integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==
   dependencies:
     graceful-fs "^4.2.0"
@@ -3304,7 +3440,7 @@ fs-extra@^10.0.0:
 
 fs-mkdirp-stream@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz#0b7815fc3201c6a69e14db98ce098c16935259eb"
+  resolved "https://registry.npmjs.org/fs-mkdirp-stream/-/fs-mkdirp-stream-1.0.0.tgz#0b7815fc3201c6a69e14db98ce098c16935259eb"
   integrity sha512-+vSd9frUnapVC2RZYfL3FCB2p3g4TBhaUmrsWlSudsGdnxIuUvBB2QM1VZeBtc49QFwrp+wQLrDs3+xxDgI5gQ==
   dependencies:
     graceful-fs "^4.1.11"
@@ -3312,45 +3448,45 @@ fs-mkdirp-stream@^1.0.0:
 
 fs.realpath@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
   integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==
 
 fsevents@^1.2.7:
   version "1.2.13"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.13.tgz#f325cb0455592428bcf11b383370ef70e3bfcc38"
+  resolved "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz#f325cb0455592428bcf11b383370ef70e3bfcc38"
   integrity sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==
   dependencies:
     bindings "^1.5.0"
     nan "^2.12.1"
 
 fsevents@^2.3.2, fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
+  version "2.3.3"
+  resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6"
+  integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==
 
 function-bind@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
-  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
+  resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
 get-caller-file@^1.0.1:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"
+  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.3.tgz#f978fa4c90d1dfe7ff2d6beda2a515e713bdcf4a"
   integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==
 
 get-caller-file@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
+  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
-get-intrinsic@^1.0.2, get-intrinsic@^1.1.1:
+get-intrinsic@^1.0.2, get-intrinsic@^1.1.1, get-intrinsic@^1.1.3, get-intrinsic@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.1.tgz#d295644fed4505fc9cde952c37ee12b477a83d82"
+  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.1.tgz#d295644fed4505fc9cde952c37ee12b477a83d82"
   integrity sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==
   dependencies:
     function-bind "^1.1.1"
@@ -3360,22 +3496,22 @@ get-intrinsic@^1.0.2, get-intrinsic@^1.1.1:
 
 get-package-type@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
+  resolved "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
   integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
 
 get-stream@^6.0.0:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
+  resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
   integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
 get-value@^2.0.3, get-value@^2.0.6:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
+  resolved "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
   integrity sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==
 
 glob-parent@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
   integrity sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==
   dependencies:
     is-glob "^3.1.0"
@@ -3383,21 +3519,21 @@ glob-parent@^3.1.0:
 
 glob-parent@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
 glob-parent@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
   integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
   dependencies:
     is-glob "^4.0.3"
 
 glob-stream@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.yarnpkg.com/glob-stream/-/glob-stream-6.1.0.tgz#7045c99413b3eb94888d83ab46d0b404cc7bdde4"
+  resolved "https://registry.npmjs.org/glob-stream/-/glob-stream-6.1.0.tgz#7045c99413b3eb94888d83ab46d0b404cc7bdde4"
   integrity sha512-uMbLGAP3S2aDOHUDfdoYcdIePUCfysbAd0IAoWVZbeGU/oNQ8asHVSshLDJUPWxfzj8zsCG7/XeHPHTtow0nsw==
   dependencies:
     extend "^3.0.0"
@@ -3413,12 +3549,12 @@ glob-stream@^6.1.0:
 
 glob-to-regexp@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
+  resolved "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
   integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
 
 glob-watcher@^5.0.3:
   version "5.0.5"
-  resolved "https://registry.yarnpkg.com/glob-watcher/-/glob-watcher-5.0.5.tgz#aa6bce648332924d9a8489be41e3e5c52d4186dc"
+  resolved "https://registry.npmjs.org/glob-watcher/-/glob-watcher-5.0.5.tgz#aa6bce648332924d9a8489be41e3e5c52d4186dc"
   integrity sha512-zOZgGGEHPklZNjZQaZ9f41i7F2YwE+tS5ZHrDhbBCk3stwahn5vQxnFmBJZHoYdusR6R1bLSXeGUy/BhctwKzw==
   dependencies:
     anymatch "^2.0.0"
@@ -3431,7 +3567,7 @@ glob-watcher@^5.0.3:
 
 glob@10.2.7:
   version "10.2.7"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-10.2.7.tgz#9dd2828cd5bc7bd861e7738d91e7113dda41d7d8"
+  resolved "https://registry.npmjs.org/glob/-/glob-10.2.7.tgz#9dd2828cd5bc7bd861e7738d91e7113dda41d7d8"
   integrity sha512-jTKehsravOJo8IJxUGfZILnkvVJM/MOfHRs8QcXolVef2zNI9Tqyy5+SeuOAZd3upViEZQLyFpQhYiHLrMUNmA==
   dependencies:
     foreground-child "^3.1.0"
@@ -3442,7 +3578,7 @@ glob@10.2.7:
 
 glob@^7.1.1, glob@^7.1.3, glob@^7.1.4:
   version "7.2.3"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b"
   integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==
   dependencies:
     fs.realpath "^1.0.0"
@@ -3454,7 +3590,7 @@ glob@^7.1.1, glob@^7.1.3, glob@^7.1.4:
 
 global-modules@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
+  resolved "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
   integrity sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==
   dependencies:
     global-prefix "^1.0.1"
@@ -3463,7 +3599,7 @@ global-modules@^1.0.0:
 
 global-prefix@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
+  resolved "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
   integrity sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==
   dependencies:
     expand-tilde "^2.0.2"
@@ -3474,19 +3610,19 @@ global-prefix@^1.0.1:
 
 globals@^11.1.0:
   version "11.12.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
+  resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
   integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
 globals@^13.19.0:
-  version "13.20.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-13.20.0.tgz#ea276a1e508ffd4f1612888f9d1bad1e2717bf82"
-  integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==
+  version "13.21.0"
+  resolved "https://registry.npmjs.org/globals/-/globals-13.21.0.tgz#163aae12f34ef502f5153cfbdd3600f36c63c571"
+  integrity sha512-ybyme3s4yy/t/3s35bewwXKOf7cvzfreG2lH0lZl0JB7I4GxRP2ghxOK/Nb9EkRXdbBXZLfq/p/0W2JUONB/Gg==
   dependencies:
     type-fest "^0.20.2"
 
 globby@^11.1.0:
   version "11.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
+  resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
   integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
   dependencies:
     array-union "^2.1.0"
@@ -3497,19 +3633,19 @@ globby@^11.1.0:
     slash "^3.0.0"
 
 globby@^13.1.2:
-  version "13.1.4"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-13.1.4.tgz#2f91c116066bcec152465ba36e5caa4a13c01317"
-  integrity sha512-iui/IiiW+QrJ1X1hKH5qwlMQyv34wJAYwH1vrf8b9kBA4sNiif3gKsMHa+BrdnOpEudWjpotfa7LrTzB1ERS/g==
+  version "13.2.2"
+  resolved "https://registry.npmjs.org/globby/-/globby-13.2.2.tgz#63b90b1bf68619c2135475cbd4e71e66aa090592"
+  integrity sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==
   dependencies:
     dir-glob "^3.0.1"
-    fast-glob "^3.2.11"
-    ignore "^5.2.0"
+    fast-glob "^3.3.0"
+    ignore "^5.2.4"
     merge2 "^1.4.1"
     slash "^4.0.0"
 
 glogg@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/glogg/-/glogg-1.0.2.tgz#2d7dd702beda22eb3bffadf880696da6d846313f"
+  resolved "https://registry.npmjs.org/glogg/-/glogg-1.0.2.tgz#2d7dd702beda22eb3bffadf880696da6d846313f"
   integrity sha512-5mwUoSuBk44Y4EshyiqcH95ZntbDdTQqA3QYSrxmzj28Ai0vXBGMH1ApSANH14j2sIRtqCEyg6PfsuP7ElOEDA==
   dependencies:
     sparkles "^1.0.0"
@@ -3549,24 +3685,31 @@ google-closure-compiler@20230802.0.0:
     google-closure-compiler-osx "^20230802.0.0"
     google-closure-compiler-windows "^20230802.0.0"
 
+gopd@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz#29ff76de69dac7489b7c0918a5788e56477c332c"
+  integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==
+  dependencies:
+    get-intrinsic "^1.1.3"
+
 graceful-fs@^4.0.0, graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4, graceful-fs@^4.2.9:
   version "4.2.11"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3"
   integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==
 
 grapheme-splitter@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e"
+  resolved "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e"
   integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
 
 graphemer@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6"
+  resolved "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz#fb2f1d55e0e3a1849aeffc90c4fa0dd53a0e66c6"
   integrity sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==
 
 gulp-cli@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/gulp-cli/-/gulp-cli-2.3.0.tgz#ec0d380e29e52aa45e47977f0d32e18fd161122f"
+  resolved "https://registry.npmjs.org/gulp-cli/-/gulp-cli-2.3.0.tgz#ec0d380e29e52aa45e47977f0d32e18fd161122f"
   integrity sha512-zzGBl5fHo0EKSXsHzjspp3y5CONegCm8ErO5Qh0UzFzk2y4tMvzLWhoDokADbarfZRL2pGpRp7yt6gfJX4ph7A==
   dependencies:
     ansi-colors "^1.0.1"
@@ -3590,7 +3733,7 @@ gulp-cli@^2.2.0:
 
 gulp-esbuild@0.11.1:
   version "0.11.1"
-  resolved "https://registry.yarnpkg.com/gulp-esbuild/-/gulp-esbuild-0.11.1.tgz#85d0ebbacae844dbbae02bb6f9d4216e9b45cee7"
+  resolved "https://registry.npmjs.org/gulp-esbuild/-/gulp-esbuild-0.11.1.tgz#85d0ebbacae844dbbae02bb6f9d4216e9b45cee7"
   integrity sha512-+Lbc4NXBcSXtvvz9wIZNrxGfgF70NgBfSNhHi3o4jKD36KQxFVKRECU72ZsSqyy08qXojK6Cur5/S0Ds+2xpSg==
   dependencies:
     esbuild "^0.17.11"
@@ -3599,7 +3742,7 @@ gulp-esbuild@0.11.1:
 
 gulp-json-transform@0.4.8:
   version "0.4.8"
-  resolved "https://registry.yarnpkg.com/gulp-json-transform/-/gulp-json-transform-0.4.8.tgz#fdbd19fd5327661ccdfc5977621f739ea86d557d"
+  resolved "https://registry.npmjs.org/gulp-json-transform/-/gulp-json-transform-0.4.8.tgz#fdbd19fd5327661ccdfc5977621f739ea86d557d"
   integrity sha512-FBVn1HqNf0hqsgrspA7Xz2i/HxRZPKnccMapKPfIE+PANuCmtmgMD2OfRLbqRGBb0Xwl1pE76sSct5gyF1zsfw==
   dependencies:
     ansi-colors "^1.0.1"
@@ -3611,12 +3754,12 @@ gulp-json-transform@0.4.8:
 
 gulp-rename@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/gulp-rename/-/gulp-rename-2.0.0.tgz#9bbc3962b0c0f52fc67cd5eaff6c223ec5b9cf6c"
+  resolved "https://registry.npmjs.org/gulp-rename/-/gulp-rename-2.0.0.tgz#9bbc3962b0c0f52fc67cd5eaff6c223ec5b9cf6c"
   integrity sha512-97Vba4KBzbYmR5VBs9mWmK+HwIf5mj+/zioxfZhOKeXtx5ZjBk57KFlePf5nxq9QsTtFl0ejnHE3zTC9MHXqyQ==
 
 gulp-replace@1.1.4:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/gulp-replace/-/gulp-replace-1.1.4.tgz#06a0e9ee36f30e343c1e0a2dd760ec32c8a3d3b2"
+  resolved "https://registry.npmjs.org/gulp-replace/-/gulp-replace-1.1.4.tgz#06a0e9ee36f30e343c1e0a2dd760ec32c8a3d3b2"
   integrity sha512-SVSF7ikuWKhpAW4l4wapAqPPSToJoiNKsbDoUnRrSgwZHH7lH8pbPeQj1aOVYQrbZKhfSVBxVW+Py7vtulRktw==
   dependencies:
     "@types/node" "*"
@@ -3627,7 +3770,7 @@ gulp-replace@1.1.4:
 
 gulp-sourcemaps@3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/gulp-sourcemaps/-/gulp-sourcemaps-3.0.0.tgz#2e154e1a2efed033c0e48013969e6f30337b2743"
+  resolved "https://registry.npmjs.org/gulp-sourcemaps/-/gulp-sourcemaps-3.0.0.tgz#2e154e1a2efed033c0e48013969e6f30337b2743"
   integrity sha512-RqvUckJkuYqy4VaIH60RMal4ZtG0IbQ6PXMNkNsshEGJ9cldUPRb/YCgboYae+CLAs1HQNb4ADTKCx65HInquQ==
   dependencies:
     "@gulp-sourcemaps/identity-map" "^2.0.1"
@@ -3644,7 +3787,7 @@ gulp-sourcemaps@3.0.0:
 
 gulp-terser@2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/gulp-terser/-/gulp-terser-2.1.0.tgz#149b693a1adbde922807b60b844bb7351dafbde1"
+  resolved "https://registry.npmjs.org/gulp-terser/-/gulp-terser-2.1.0.tgz#149b693a1adbde922807b60b844bb7351dafbde1"
   integrity sha512-lQ3+JUdHDVISAlUIUSZ/G9Dz/rBQHxOiYDQ70IVWFQeh4b33TC1MCIU+K18w07PS3rq/CVc34aQO4SUbdaNMPQ==
   dependencies:
     plugin-error "^1.0.1"
@@ -3654,7 +3797,7 @@ gulp-terser@2.1.0:
 
 gulp-typescript@5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/gulp-typescript/-/gulp-typescript-5.0.1.tgz#96c6565a6eb31e08c2aae1c857b1a079e6226d94"
+  resolved "https://registry.npmjs.org/gulp-typescript/-/gulp-typescript-5.0.1.tgz#96c6565a6eb31e08c2aae1c857b1a079e6226d94"
   integrity sha512-YuMMlylyJtUSHG1/wuSVTrZp60k1dMEFKYOvDf7OvbAJWrDtxxD4oZon4ancdWwzjj30ztiidhe4VXJniF0pIQ==
   dependencies:
     ansi-colors "^3.0.5"
@@ -3666,7 +3809,7 @@ gulp-typescript@5.0.1:
 
 gulp-vinyl-size@1.1.4:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/gulp-vinyl-size/-/gulp-vinyl-size-1.1.4.tgz#06b98a8aa9f91f420ea3068798800aa21f8ccdc1"
+  resolved "https://registry.npmjs.org/gulp-vinyl-size/-/gulp-vinyl-size-1.1.4.tgz#06b98a8aa9f91f420ea3068798800aa21f8ccdc1"
   integrity sha512-k8QTnUD69CnQnbpbXExFRtMDtQ9jIc5nZXYyVNB5Z+7xrZIO3hVS0zotoWwZawgtBLNLvAnm6JZ3zL+O1ysQ3A==
   dependencies:
     fancy-log "^2.0.0"
@@ -3675,7 +3818,7 @@ gulp-vinyl-size@1.1.4:
 
 gulp@4.0.2:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/gulp/-/gulp-4.0.2.tgz#543651070fd0f6ab0a0650c6a3e6ff5a7cb09caa"
+  resolved "https://registry.npmjs.org/gulp/-/gulp-4.0.2.tgz#543651070fd0f6ab0a0650c6a3e6ff5a7cb09caa"
   integrity sha512-dvEs27SCZt2ibF29xYgmnwwCYZxdxhQ/+LFWlbAW8y7jt68L/65402Lz3+CKy0Ov4rOs+NERmDq7YlZaDqUIfA==
   dependencies:
     glob-watcher "^5.0.3"
@@ -3685,53 +3828,53 @@ gulp@4.0.2:
 
 gulplog@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/gulplog/-/gulplog-1.0.0.tgz#e28c4d45d05ecbbed818363ce8f9c5926229ffe5"
+  resolved "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz#e28c4d45d05ecbbed818363ce8f9c5926229ffe5"
   integrity sha512-hm6N8nrm3Y08jXie48jsC55eCZz9mnb4OirAStEk2deqeyhXU3C1otDVh+ccttMuc1sBi6RX6ZJ720hs9RCvgw==
   dependencies:
     glogg "^1.0.0"
 
 gzip-size@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/gzip-size/-/gzip-size-6.0.0.tgz#065367fd50c239c0671cbcbad5be3e2eeb10e462"
+  resolved "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz#065367fd50c239c0671cbcbad5be3e2eeb10e462"
   integrity sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==
   dependencies:
     duplexer "^0.1.2"
 
 hard-rejection@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
+  resolved "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
   integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
 
 has-flag@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
   integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==
 
 has-flag@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
 has-property-descriptors@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861"
+  resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861"
   integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==
   dependencies:
     get-intrinsic "^1.1.1"
 
 has-proto@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.0.1.tgz#1885c1305538958aff469fef37937c22795408e0"
+  resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz#1885c1305538958aff469fef37937c22795408e0"
   integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==
 
 has-symbols@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
+  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
   integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
 
 has-value@^0.3.1:
   version "0.3.1"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
+  resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
   integrity sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q==
   dependencies:
     get-value "^2.0.3"
@@ -3740,7 +3883,7 @@ has-value@^0.3.1:
 
 has-value@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
+  resolved "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
   integrity sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw==
   dependencies:
     get-value "^2.0.6"
@@ -3749,12 +3892,12 @@ has-value@^1.0.0:
 
 has-values@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
+  resolved "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
   integrity sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ==
 
 has-values@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
+  resolved "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
   integrity sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ==
   dependencies:
     is-number "^3.0.0"
@@ -3762,53 +3905,53 @@ has-values@^1.0.0:
 
 has@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
   dependencies:
     function-bind "^1.1.1"
 
 homedir-polyfill@^1.0.1:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
+  resolved "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
   integrity sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==
   dependencies:
     parse-passwd "^1.0.0"
 
 hosted-git-info@^2.1.4:
   version "2.8.9"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
+  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
   integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==
 
 hosted-git-info@^4.0.1:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
+  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
   integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
   dependencies:
     lru-cache "^6.0.0"
 
 html-escaper@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
+  resolved "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
 human-signals@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
+  resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
   integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
 
 hyperdyperid@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/hyperdyperid/-/hyperdyperid-1.2.0.tgz#59668d323ada92228d2a869d3e474d5a33b69e6b"
+  resolved "https://registry.npmjs.org/hyperdyperid/-/hyperdyperid-1.2.0.tgz#59668d323ada92228d2a869d3e474d5a33b69e6b"
   integrity sha512-Y93lCzHYgGWdrJ66yIktxiaGULYc6oGiABxhcO5AufBeOyoIdZF7bIfLaOrbM0iGIOXQQgxxRrFEnb+Y6w1n4A==
 
-ignore@^5.2.0:
+ignore@^5.2.0, ignore@^5.2.4:
   version "5.2.4"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
+  resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
   integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
 
 import-fresh@^3.0.0, import-fresh@^3.2.1:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
+  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
   integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
   dependencies:
     parent-module "^1.0.0"
@@ -3816,7 +3959,7 @@ import-fresh@^3.0.0, import-fresh@^3.2.1:
 
 import-local@^3.0.2:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/import-local/-/import-local-3.1.0.tgz#b4479df8a5fd44f6cdce24070675676063c95cb4"
+  resolved "https://registry.npmjs.org/import-local/-/import-local-3.1.0.tgz#b4479df8a5fd44f6cdce24070675676063c95cb4"
   integrity sha512-ASB07uLtnDs1o6EHjKpX34BKYDSqnFerfTOJL2HvMqF70LnxpjkzDB8J44oT9pu4AMPkQwf8jl6szgvNd2tRIg==
   dependencies:
     pkg-dir "^4.2.0"
@@ -3824,22 +3967,22 @@ import-local@^3.0.2:
 
 imurmurhash@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
+  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
   integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==
 
 indent-string@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
+  resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
   integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
 
 indent-string@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-5.0.0.tgz#4fd2980fccaf8622d14c64d694f4cf33c81951a5"
+  resolved "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz#4fd2980fccaf8622d14c64d694f4cf33c81951a5"
   integrity sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==
 
 inflight@^1.0.4:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
   integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==
   dependencies:
     once "^1.3.0"
@@ -3847,27 +3990,27 @@ inflight@^1.0.4:
 
 inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
 ini@^1.3.4:
   version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
+  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
 interpret@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
+  resolved "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
   integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
 
 invert-kv@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
+  resolved "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz#104a8e4aaca6d3d8cd157a8ef8bfab2d7a3ffdb6"
   integrity sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==
 
 is-absolute@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-absolute/-/is-absolute-1.0.0.tgz#395e1ae84b11f26ad1795e73c17378e48a301576"
+  resolved "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz#395e1ae84b11f26ad1795e73c17378e48a301576"
   integrity sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==
   dependencies:
     is-relative "^1.0.0"
@@ -3875,73 +4018,73 @@ is-absolute@^1.0.0:
 
 is-accessor-descriptor@^0.1.6:
   version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
+  resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
   integrity sha512-e1BM1qnDbMRG3ll2U9dSK0UMHuWOs3pY3AtcFsmvwPtKL3MML/Q86i+GilLfvqEs4GW+ExB91tQ3Ig9noDIZ+A==
   dependencies:
     kind-of "^3.0.2"
 
 is-accessor-descriptor@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
+  resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
   integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
   dependencies:
     kind-of "^6.0.0"
 
 is-arrayish@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
+  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==
 
 is-binary-path@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
+  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
   integrity sha512-9fRVlXc0uCxEDj1nQzaWONSpbTfx0FmJfzHF7pwlI8DkWGoHBBea4Pg5Ky0ojwwxQmnSifgbKkI06Qv0Ljgj+Q==
   dependencies:
     binary-extensions "^1.0.0"
 
 is-buffer@^1.1.5:
   version "1.1.6"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
+  resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 
 is-builtin-module@^3.2.1:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.2.1.tgz#f03271717d8654cfcaf07ab0463faa3571581169"
+  resolved "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-3.2.1.tgz#f03271717d8654cfcaf07ab0463faa3571581169"
   integrity sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==
   dependencies:
     builtin-modules "^3.3.0"
 
 is-ci@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c"
+  resolved "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz#6bc6334181810e04b5c22b3d589fdca55026404c"
   integrity sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w==
   dependencies:
     ci-info "^2.0.0"
 
-is-core-module@^2.11.0, is-core-module@^2.5.0:
-  version "2.12.1"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.1.tgz#0c0b6885b6f80011c71541ce15c8d66cf5a4f9fd"
-  integrity sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg==
+is-core-module@^2.13.0, is-core-module@^2.5.0:
+  version "2.13.0"
+  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.13.0.tgz#bb52aa6e2cbd49a30c2ba68c42bf3435ba6072db"
+  integrity sha512-Z7dk6Qo8pOCp3l4tsX2C5ZVas4V+UxwQodwZhLopL91TX8UyyHEXafPcyoeeWuLrwzHcr3igO78wNLwHJHsMCQ==
   dependencies:
     has "^1.0.3"
 
 is-data-descriptor@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
+  resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
   integrity sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg==
   dependencies:
     kind-of "^3.0.2"
 
 is-data-descriptor@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
+  resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
   integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
   dependencies:
     kind-of "^6.0.0"
 
 is-descriptor@^0.1.0:
   version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
+  resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
   integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
   dependencies:
     is-accessor-descriptor "^0.1.6"
@@ -3950,7 +4093,7 @@ is-descriptor@^0.1.0:
 
 is-descriptor@^1.0.0, is-descriptor@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
+  resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
   integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
   dependencies:
     is-accessor-descriptor "^1.0.0"
@@ -3959,180 +4102,180 @@ is-descriptor@^1.0.0, is-descriptor@^1.0.2:
 
 is-extendable@^0.1.0, is-extendable@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
+  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
   integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==
 
 is-extendable@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
+  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
   integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
   dependencies:
     is-plain-object "^2.0.4"
 
 is-extglob@^2.1.0, is-extglob@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
+  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
   integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==
 
 is-fullwidth-code-point@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
   integrity sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==
   dependencies:
     number-is-nan "^1.0.0"
 
 is-fullwidth-code-point@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
 is-generator-fn@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118"
+  resolved "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz#7d140adc389aaf3011a8f2a2a4cfa6faadffb118"
   integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==
 
 is-glob@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
   integrity sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==
   dependencies:
     is-extglob "^2.1.0"
 
 is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3:
   version "4.0.3"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
   integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
   dependencies:
     is-extglob "^2.1.1"
 
 is-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
+  resolved "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
   integrity sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==
 
 is-negated-glob@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-negated-glob/-/is-negated-glob-1.0.0.tgz#6910bca5da8c95e784b5751b976cf5a10fee36d2"
+  resolved "https://registry.npmjs.org/is-negated-glob/-/is-negated-glob-1.0.0.tgz#6910bca5da8c95e784b5751b976cf5a10fee36d2"
   integrity sha512-czXVVn/QEmgvej1f50BZ648vUI+em0xqMq2Sn+QncCLN4zj1UAxlT+kw/6ggQTOaZPd1HqKQGEqbpQVtJucWug==
 
 is-number@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
   integrity sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg==
   dependencies:
     kind-of "^3.0.2"
 
 is-number@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
   integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
 
 is-number@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
 is-path-cwd@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-3.0.0.tgz#889b41e55c8588b1eb2a96a61d05740a674521c7"
+  resolved "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-3.0.0.tgz#889b41e55c8588b1eb2a96a61d05740a674521c7"
   integrity sha512-kyiNFFLU0Ampr6SDZitD/DwUo4Zs1nSdnygUBqsu3LooL00Qvb5j+UnvApUn/TTj1J3OuE6BTdQ5rudKmU2ZaA==
 
 is-path-inside@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
+  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
   integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
 
 is-path-inside@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-4.0.0.tgz#805aeb62c47c1b12fc3fd13bfb3ed1e7430071db"
+  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz#805aeb62c47c1b12fc3fd13bfb3ed1e7430071db"
   integrity sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA==
 
 is-plain-obj@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
+  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
   integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==
 
 is-plain-object@^2.0.1, is-plain-object@^2.0.3, is-plain-object@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
   dependencies:
     isobject "^3.0.1"
 
 is-plain-object@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344"
+  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz#4427f50ab3429e9025ea7d52e9043a9ef4159344"
   integrity sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==
 
 is-promise@^2.2.2:
   version "2.2.2"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.2.2.tgz#39ab959ccbf9a774cf079f7b40c7a26f763135f1"
+  resolved "https://registry.npmjs.org/is-promise/-/is-promise-2.2.2.tgz#39ab959ccbf9a774cf079f7b40c7a26f763135f1"
   integrity sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==
 
 is-relative@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-relative/-/is-relative-1.0.0.tgz#a1bb6935ce8c5dba1e8b9754b9b2dcc020e2260d"
+  resolved "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz#a1bb6935ce8c5dba1e8b9754b9b2dcc020e2260d"
   integrity sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==
   dependencies:
     is-unc-path "^1.0.0"
 
 is-stream@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
+  resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
 is-unc-path@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-unc-path/-/is-unc-path-1.0.0.tgz#d731e8898ed090a12c352ad2eaed5095ad322c9d"
+  resolved "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz#d731e8898ed090a12c352ad2eaed5095ad322c9d"
   integrity sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==
   dependencies:
     unc-path-regex "^0.1.2"
 
 is-utf8@^0.2.0, is-utf8@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
+  resolved "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
   integrity sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==
 
 is-valid-glob@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-valid-glob/-/is-valid-glob-1.0.0.tgz#29bf3eff701be2d4d315dbacc39bc39fe8f601aa"
+  resolved "https://registry.npmjs.org/is-valid-glob/-/is-valid-glob-1.0.0.tgz#29bf3eff701be2d4d315dbacc39bc39fe8f601aa"
   integrity sha512-AhiROmoEFDSsjx8hW+5sGwgKVIORcXnrlAx/R0ZSeaPw70Vw0CqkGBBhHGL58Uox2eXnU1AnvXJl1XlyedO5bA==
 
 is-windows@^1.0.1, is-windows@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
+  resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 
 isarray@1.0.0, isarray@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
   integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==
 
 isexe@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
+  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
   integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==
 
 isobject@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
+  resolved "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
   integrity sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA==
   dependencies:
     isarray "1.0.0"
 
 isobject@^3.0.0, isobject@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+  resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
   integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==
 
 istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
+  resolved "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
   integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
 
-istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
+istanbul-lib-instrument@^5.0.4:
   version "5.2.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz#d10c8885c2125574e1c231cacadf955675e1ce3d"
+  resolved "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz#d10c8885c2125574e1c231cacadf955675e1ce3d"
   integrity sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==
   dependencies:
     "@babel/core" "^7.12.3"
@@ -4141,18 +4284,29 @@ istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
     istanbul-lib-coverage "^3.2.0"
     semver "^6.3.0"
 
+istanbul-lib-instrument@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-6.0.0.tgz#7a8af094cbfff1d5bb280f62ce043695ae8dd5b8"
+  integrity sha512-x58orMzEVfzPUKqlbLd1hXCnySCxKdDKa6Rjg97CwuLLRI4g3FHTdnExu1OqffVFay6zeMW+T6/DowFLndWnIw==
+  dependencies:
+    "@babel/core" "^7.12.3"
+    "@babel/parser" "^7.14.7"
+    "@istanbuljs/schema" "^0.1.2"
+    istanbul-lib-coverage "^3.2.0"
+    semver "^7.5.4"
+
 istanbul-lib-report@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6"
-  integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz#908305bac9a5bd175ac6a74489eafd0fc2445a7d"
+  integrity sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==
   dependencies:
     istanbul-lib-coverage "^3.0.0"
-    make-dir "^3.0.0"
+    make-dir "^4.0.0"
     supports-color "^7.1.0"
 
 istanbul-lib-source-maps@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
+  resolved "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
   integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
   dependencies:
     debug "^4.1.1"
@@ -4160,16 +4314,16 @@ istanbul-lib-source-maps@^4.0.0:
     source-map "^0.6.1"
 
 istanbul-reports@^3.1.3:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.5.tgz#cc9a6ab25cb25659810e4785ed9d9fb742578bae"
-  integrity sha512-nUsEMa9pBt/NOHqbcbeJEgqIlY/K7rVWUX6Lql2orY5e9roQOthbR3vtY4zzf2orPELg80fnxxk9zUyPlgwD1w==
+  version "3.1.6"
+  resolved "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.6.tgz#2544bcab4768154281a2f0870471902704ccaa1a"
+  integrity sha512-TLgnMkKg3iTDsQ9PbPTdpfAK2DzjF9mqUG7RMgcQl8oFjad8ob4laGxv5XV5U9MAfx8D6tSJiUyuAwzLicaxlg==
   dependencies:
     html-escaper "^2.0.0"
     istanbul-lib-report "^3.0.0"
 
 istextorbinary@^3.0.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/istextorbinary/-/istextorbinary-3.3.0.tgz#06b1c57d948da11461bd237c00ce09e9902964f2"
+  resolved "https://registry.npmjs.org/istextorbinary/-/istextorbinary-3.3.0.tgz#06b1c57d948da11461bd237c00ce09e9902964f2"
   integrity sha512-Tvq1W6NAcZeJ8op+Hq7tdZ434rqnMx4CCZ7H0ff83uEloDvVbqAwaMTZcafKGJT0VHkYzuXUiCY4hlXQg6WfoQ==
   dependencies:
     binaryextensions "^2.2.0"
@@ -4177,332 +4331,332 @@ istextorbinary@^3.0.0:
 
 ix@5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/ix/-/ix-5.0.0.tgz#b9e292f79b1876bbf696809fe86e42930bdbfcd4"
+  resolved "https://registry.npmjs.org/ix/-/ix-5.0.0.tgz#b9e292f79b1876bbf696809fe86e42930bdbfcd4"
   integrity sha512-6LyyrHnvNrSy5pKtW/KA+KKusHrB223aBJCJlIGPN7QBfDkEEtNrAkAz9lLLShIcdJntq6BiPCHuKaCM/9wwXw==
   dependencies:
     "@types/node" "^13.7.4"
     tslib "^2.3.0"
 
 jackspeak@^2.0.3:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/jackspeak/-/jackspeak-2.2.1.tgz#655e8cf025d872c9c03d3eb63e8f0c024fef16a6"
-  integrity sha512-MXbxovZ/Pm42f6cDIDkl3xpwv1AGwObKwfmjs2nQePiy85tP3fatofl3FC1aBsOtP/6fq5SbtgHwWcMsLP+bDw==
+  version "2.3.3"
+  resolved "https://registry.npmjs.org/jackspeak/-/jackspeak-2.3.3.tgz#95e4cbcc03b3eb357bf6bcce14a903fb3d1151e1"
+  integrity sha512-R2bUw+kVZFS/h1AZqBKrSgDmdmjApzgY0AlCPumopFiAlbUxE2gf+SCuBzQ0cP5hHmUmFYF5yw55T97Th5Kstg==
   dependencies:
     "@isaacs/cliui" "^8.0.2"
   optionalDependencies:
     "@pkgjs/parseargs" "^0.11.0"
 
-jest-changed-files@^29.5.0:
-  version "29.5.0"
-  resolved "https://registry.yarnpkg.com/jest-changed-files/-/jest-changed-files-29.5.0.tgz#e88786dca8bf2aa899ec4af7644e16d9dcf9b23e"
-  integrity sha512-IFG34IUMUaNBIxjQXF/iu7g6EcdMrGRRxaUSw92I/2g2YC6vCdTltl4nHvt7Ci5nSJwXIkCu8Ka1DKF+X7Z1Ag==
+jest-changed-files@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-29.7.0.tgz#1c06d07e77c78e1585d020424dedc10d6e17ac3a"
+  integrity sha512-fEArFiwf1BpQ+4bXSprcDc3/x4HSzL4al2tozwVpDFpsxALjLYdyiIK4e5Vz66GQJIbXJ82+35PtysofptNX2w==
   dependencies:
     execa "^5.0.0"
+    jest-util "^29.7.0"
     p-limit "^3.1.0"
 
-jest-circus@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-circus/-/jest-circus-29.6.2.tgz#1e6ffca60151ac66cad63fce34f443f6b5bb4258"
-  integrity sha512-G9mN+KOYIUe2sB9kpJkO9Bk18J4dTDArNFPwoZ7WKHKel55eKIS/u2bLthxgojwlf9NLCVQfgzM/WsOVvoC6Fw==
+jest-circus@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-circus/-/jest-circus-29.7.0.tgz#b6817a45fcc835d8b16d5962d0c026473ee3668a"
+  integrity sha512-3E1nCMgipcTkCocFwM90XXQab9bS+GMsjdpmPrlelaxwD93Ad8iVEjX/vvHPdLPnFf+L40u+5+iutRdA1N9myw==
   dependencies:
-    "@jest/environment" "^29.6.2"
-    "@jest/expect" "^29.6.2"
-    "@jest/test-result" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/environment" "^29.7.0"
+    "@jest/expect" "^29.7.0"
+    "@jest/test-result" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     chalk "^4.0.0"
     co "^4.6.0"
     dedent "^1.0.0"
     is-generator-fn "^2.0.0"
-    jest-each "^29.6.2"
-    jest-matcher-utils "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-runtime "^29.6.2"
-    jest-snapshot "^29.6.2"
-    jest-util "^29.6.2"
+    jest-each "^29.7.0"
+    jest-matcher-utils "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-runtime "^29.7.0"
+    jest-snapshot "^29.7.0"
+    jest-util "^29.7.0"
     p-limit "^3.1.0"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
     pure-rand "^6.0.0"
     slash "^3.0.0"
     stack-utils "^2.0.3"
 
 jest-cli@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-cli/-/jest-cli-29.6.2.tgz#edb381763398d1a292cd1b636a98bfa5644b8fda"
-  integrity sha512-TT6O247v6dCEX2UGHGyflMpxhnrL0DNqP2fRTKYm3nJJpCTfXX3GCMQPGFjXDoj0i5/Blp3jriKXFgdfmbYB6Q==
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-cli/-/jest-cli-29.7.0.tgz#5592c940798e0cae677eec169264f2d839a37995"
+  integrity sha512-OVVobw2IubN/GSYsxETi+gOe7Ka59EFMR/twOU3Jb2GnKKeMGJB5SGUUrEz3SFVmJASUdZUzy83sLNNQ2gZslg==
   dependencies:
-    "@jest/core" "^29.6.2"
-    "@jest/test-result" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/core" "^29.7.0"
+    "@jest/test-result" "^29.7.0"
+    "@jest/types" "^29.6.3"
     chalk "^4.0.0"
+    create-jest "^29.7.0"
     exit "^0.1.2"
-    graceful-fs "^4.2.9"
     import-local "^3.0.2"
-    jest-config "^29.6.2"
-    jest-util "^29.6.2"
-    jest-validate "^29.6.2"
-    prompts "^2.0.1"
+    jest-config "^29.7.0"
+    jest-util "^29.7.0"
+    jest-validate "^29.7.0"
     yargs "^17.3.1"
 
-jest-config@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-config/-/jest-config-29.6.2.tgz#c68723f06b31ca5e63030686e604727d406cd7c3"
-  integrity sha512-VxwFOC8gkiJbuodG9CPtMRjBUNZEHxwfQXmIudSTzFWxaci3Qub1ddTRbFNQlD/zUeaifLndh/eDccFX4wCMQw==
+jest-config@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-config/-/jest-config-29.7.0.tgz#bcbda8806dbcc01b1e316a46bb74085a84b0245f"
+  integrity sha512-uXbpfeQ7R6TZBqI3/TxCU4q4ttk3u0PJeC+E0zbfSoSjq6bJ7buBPxzQPL0ifrkY4DNu4JUdk0ImlBUYi840eQ==
   dependencies:
     "@babel/core" "^7.11.6"
-    "@jest/test-sequencer" "^29.6.2"
-    "@jest/types" "^29.6.1"
-    babel-jest "^29.6.2"
+    "@jest/test-sequencer" "^29.7.0"
+    "@jest/types" "^29.6.3"
+    babel-jest "^29.7.0"
     chalk "^4.0.0"
     ci-info "^3.2.0"
     deepmerge "^4.2.2"
     glob "^7.1.3"
     graceful-fs "^4.2.9"
-    jest-circus "^29.6.2"
-    jest-environment-node "^29.6.2"
-    jest-get-type "^29.4.3"
-    jest-regex-util "^29.4.3"
-    jest-resolve "^29.6.2"
-    jest-runner "^29.6.2"
-    jest-util "^29.6.2"
-    jest-validate "^29.6.2"
+    jest-circus "^29.7.0"
+    jest-environment-node "^29.7.0"
+    jest-get-type "^29.6.3"
+    jest-regex-util "^29.6.3"
+    jest-resolve "^29.7.0"
+    jest-runner "^29.7.0"
+    jest-util "^29.7.0"
+    jest-validate "^29.7.0"
     micromatch "^4.0.4"
     parse-json "^5.2.0"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
     slash "^3.0.0"
     strip-json-comments "^3.1.1"
 
-jest-diff@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.6.2.tgz#c36001e5543e82a0805051d3ceac32e6825c1c46"
-  integrity sha512-t+ST7CB9GX5F2xKwhwCf0TAR17uNDiaPTZnVymP9lw0lssa9vG+AFyDZoeIHStU3WowFFwT+ky+er0WVl2yGhA==
+jest-diff@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-diff/-/jest-diff-29.7.0.tgz#017934a66ebb7ecf6f205e84699be10afd70458a"
+  integrity sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==
   dependencies:
     chalk "^4.0.0"
-    diff-sequences "^29.4.3"
-    jest-get-type "^29.4.3"
-    pretty-format "^29.6.2"
+    diff-sequences "^29.6.3"
+    jest-get-type "^29.6.3"
+    pretty-format "^29.7.0"
 
-jest-docblock@^29.4.3:
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-29.4.3.tgz#90505aa89514a1c7dceeac1123df79e414636ea8"
-  integrity sha512-fzdTftThczeSD9nZ3fzA/4KkHtnmllawWrXO69vtI+L9WjEIuXWs4AmyME7lN5hU7dB0sHhuPfcKofRsUb/2Fg==
+jest-docblock@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-docblock/-/jest-docblock-29.7.0.tgz#8fddb6adc3cdc955c93e2a87f61cfd350d5d119a"
+  integrity sha512-q617Auw3A612guyaFgsbFeYpNP5t2aoUNLwBUbc/0kD1R4t9ixDbyFTHd1nok4epoVFpr7PmeWHrhvuV3XaJ4g==
   dependencies:
     detect-newline "^3.0.0"
 
-jest-each@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-each/-/jest-each-29.6.2.tgz#c9e4b340bcbe838c73adf46b76817b15712d02ce"
-  integrity sha512-MsrsqA0Ia99cIpABBc3izS1ZYoYfhIy0NNWqPSE0YXbQjwchyt6B1HD2khzyPe1WiJA7hbxXy77ZoUQxn8UlSw==
+jest-each@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-each/-/jest-each-29.7.0.tgz#162a9b3f2328bdd991beaabffbb74745e56577d1"
+  integrity sha512-gns+Er14+ZrEoC5fhOfYCY1LOHHr0TI+rQUHZS8Ttw2l7gl+80eHc/gFf2Ktkw0+SIACDTeWvpFcv3B04VembQ==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     chalk "^4.0.0"
-    jest-get-type "^29.4.3"
-    jest-util "^29.6.2"
-    pretty-format "^29.6.2"
-
-jest-environment-node@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-environment-node/-/jest-environment-node-29.6.2.tgz#a9ea2cabff39b08eca14ccb32c8ceb924c8bb1ad"
-  integrity sha512-YGdFeZ3T9a+/612c5mTQIllvWkddPbYcN2v95ZH24oWMbGA4GGS2XdIF92QMhUhvrjjuQWYgUGW2zawOyH63MQ==
-  dependencies:
-    "@jest/environment" "^29.6.2"
-    "@jest/fake-timers" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    jest-get-type "^29.6.3"
+    jest-util "^29.7.0"
+    pretty-format "^29.7.0"
+
+jest-environment-node@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-29.7.0.tgz#0b93e111dda8ec120bc8300e6d1fb9576e164376"
+  integrity sha512-DOSwCRqXirTOyheM+4d5YZOrWcdu0LNZ87ewUoywbcb2XR4wKgqiG8vNeYwhjFMbEkfju7wx2GYH0P2gevGvFw==
+  dependencies:
+    "@jest/environment" "^29.7.0"
+    "@jest/fake-timers" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
-    jest-mock "^29.6.2"
-    jest-util "^29.6.2"
+    jest-mock "^29.7.0"
+    jest-util "^29.7.0"
 
-jest-get-type@^29.4.3:
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-29.4.3.tgz#1ab7a5207c995161100b5187159ca82dd48b3dd5"
-  integrity sha512-J5Xez4nRRMjk8emnTpWrlkyb9pfRQQanDrvWHhsR1+VUfbwxi30eVcZFlcdGInRibU4G5LwHXpI7IRHU0CY+gg==
+jest-get-type@^29.6.3:
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz#36f499fdcea197c1045a127319c0481723908fd1"
+  integrity sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==
 
-jest-haste-map@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-29.6.2.tgz#298c25ea5255cfad8b723179d4295cf3a50a70d1"
-  integrity sha512-+51XleTDAAysvU8rT6AnS1ZJ+WHVNqhj1k6nTvN2PYP+HjU3kqlaKQ1Lnw3NYW3bm2r8vq82X0Z1nDDHZMzHVA==
+jest-haste-map@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-29.7.0.tgz#3c2396524482f5a0506376e6c858c3bbcc17b104"
+  integrity sha512-fP8u2pyfqx0K1rGn1R9pyE0/KTn+G7PxktWidOBTqFPLYX0b9ksaMFkhK5vrS3DVun09pckLdlx90QthlW7AmA==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@types/graceful-fs" "^4.1.3"
     "@types/node" "*"
     anymatch "^3.0.3"
     fb-watchman "^2.0.0"
     graceful-fs "^4.2.9"
-    jest-regex-util "^29.4.3"
-    jest-util "^29.6.2"
-    jest-worker "^29.6.2"
+    jest-regex-util "^29.6.3"
+    jest-util "^29.7.0"
+    jest-worker "^29.7.0"
     micromatch "^4.0.4"
     walker "^1.0.8"
   optionalDependencies:
     fsevents "^2.3.2"
 
-jest-leak-detector@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-leak-detector/-/jest-leak-detector-29.6.2.tgz#e2b307fee78cab091c37858a98c7e1d73cdf5b38"
-  integrity sha512-aNqYhfp5uYEO3tdWMb2bfWv6f0b4I0LOxVRpnRLAeque2uqOVVMLh6khnTcE2qJ5wAKop0HcreM1btoysD6bPQ==
+jest-leak-detector@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-29.7.0.tgz#5b7ec0dadfdfec0ca383dc9aa016d36b5ea4c728"
+  integrity sha512-kYA8IJcSYtST2BY9I+SMC32nDpBT3J2NvWJx8+JCuCdl/CR1I4EKUJROiP8XtCcxqgTTBGJNdbB1A8XRKbTetw==
   dependencies:
-    jest-get-type "^29.4.3"
-    pretty-format "^29.6.2"
+    jest-get-type "^29.6.3"
+    pretty-format "^29.7.0"
 
-jest-matcher-utils@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-29.6.2.tgz#39de0be2baca7a64eacb27291f0bd834fea3a535"
-  integrity sha512-4LiAk3hSSobtomeIAzFTe+N8kL6z0JtF3n6I4fg29iIW7tt99R7ZcIFW34QkX+DuVrf+CUe6wuVOpm7ZKFJzZQ==
+jest-matcher-utils@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz#ae8fec79ff249fd592ce80e3ee474e83a6c44f12"
+  integrity sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==
   dependencies:
     chalk "^4.0.0"
-    jest-diff "^29.6.2"
-    jest-get-type "^29.4.3"
-    pretty-format "^29.6.2"
+    jest-diff "^29.7.0"
+    jest-get-type "^29.6.3"
+    pretty-format "^29.7.0"
 
-jest-message-util@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-29.6.2.tgz#af7adc2209c552f3f5ae31e77cf0a261f23dc2bb"
-  integrity sha512-vnIGYEjoPSuRqV8W9t+Wow95SDp6KPX2Uf7EoeG9G99J2OVh7OSwpS4B6J0NfpEIpfkBNHlBZpA2rblEuEFhZQ==
+jest-message-util@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.7.0.tgz#8bc392e204e95dfe7564abbe72a404e28e51f7f3"
+  integrity sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==
   dependencies:
     "@babel/code-frame" "^7.12.13"
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@types/stack-utils" "^2.0.0"
     chalk "^4.0.0"
     graceful-fs "^4.2.9"
     micromatch "^4.0.4"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
     slash "^3.0.0"
     stack-utils "^2.0.3"
 
-jest-mock@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-mock/-/jest-mock-29.6.2.tgz#ef9c9b4d38c34a2ad61010a021866dad41ce5e00"
-  integrity sha512-hoSv3lb3byzdKfwqCuT6uTscan471GUECqgNYykg6ob0yiAw3zYc7OrPnI9Qv8Wwoa4lC7AZ9hyS4AiIx5U2zg==
+jest-mock@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-mock/-/jest-mock-29.7.0.tgz#4e836cf60e99c6fcfabe9f99d017f3fdd50a6347"
+  integrity sha512-ITOMZn+UkYS4ZFh83xYAOzWStloNzJFO2s8DWrE4lhtGD+AorgnbkiKERe4wQVBydIGPx059g6riW5Btp6Llnw==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
-    jest-util "^29.6.2"
+    jest-util "^29.7.0"
 
 jest-pnp-resolver@^1.2.2:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e"
+  resolved "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e"
   integrity sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==
 
-jest-regex-util@^29.4.3:
-  version "29.4.3"
-  resolved "https://registry.yarnpkg.com/jest-regex-util/-/jest-regex-util-29.4.3.tgz#a42616141e0cae052cfa32c169945d00c0aa0bb8"
-  integrity sha512-O4FglZaMmWXbGHSQInfXewIsd1LMn9p3ZXB/6r4FOkyhX2/iP/soMG98jGvk/A3HAN78+5VWcBGO0BJAPRh4kg==
+jest-regex-util@^29.6.3:
+  version "29.6.3"
+  resolved "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-29.6.3.tgz#4a556d9c776af68e1c5f48194f4d0327d24e8a52"
+  integrity sha512-KJJBsRCyyLNWCNBOvZyRDnAIfUiRJ8v+hOBQYGn8gDyF3UegwiP4gwRR3/SDa42g1YbVycTidUF3rKjyLFDWbg==
 
-jest-resolve-dependencies@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-resolve-dependencies/-/jest-resolve-dependencies-29.6.2.tgz#36435269b6672c256bcc85fb384872c134cc4cf2"
-  integrity sha512-LGqjDWxg2fuQQm7ypDxduLu/m4+4Lb4gczc13v51VMZbVP5tSBILqVx8qfWcsdP8f0G7aIqByIALDB0R93yL+w==
+jest-resolve-dependencies@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-29.7.0.tgz#1b04f2c095f37fc776ff40803dc92921b1e88428"
+  integrity sha512-un0zD/6qxJ+S0et7WxeI3H5XSe9lTBBR7bOHCHXkKR6luG5mwDDlIzVQ0V5cZCuoTgEdcdwzTghYkTWfubi+nA==
   dependencies:
-    jest-regex-util "^29.4.3"
-    jest-snapshot "^29.6.2"
+    jest-regex-util "^29.6.3"
+    jest-snapshot "^29.7.0"
 
-jest-resolve@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-resolve/-/jest-resolve-29.6.2.tgz#f18405fe4b50159b7b6d85e81f6a524d22afb838"
-  integrity sha512-G/iQUvZWI5e3SMFssc4ug4dH0aZiZpsDq9o1PtXTV1210Ztyb2+w+ZgQkB3iOiC5SmAEzJBOHWz6Hvrd+QnNPw==
+jest-resolve@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-resolve/-/jest-resolve-29.7.0.tgz#64d6a8992dd26f635ab0c01e5eef4399c6bcbc30"
+  integrity sha512-IOVhZSrg+UvVAshDSDtHyFCCBUl/Q3AAJv8iZ6ZjnZ74xzvwuzLXid9IIIPgTnY62SJjfuupMKZsZQRsCvxEgA==
   dependencies:
     chalk "^4.0.0"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.6.2"
+    jest-haste-map "^29.7.0"
     jest-pnp-resolver "^1.2.2"
-    jest-util "^29.6.2"
-    jest-validate "^29.6.2"
+    jest-util "^29.7.0"
+    jest-validate "^29.7.0"
     resolve "^1.20.0"
     resolve.exports "^2.0.0"
     slash "^3.0.0"
 
-jest-runner@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-runner/-/jest-runner-29.6.2.tgz#89e8e32a8fef24781a7c4c49cd1cb6358ac7fc01"
-  integrity sha512-wXOT/a0EspYgfMiYHxwGLPCZfC0c38MivAlb2lMEAlwHINKemrttu1uSbcGbfDV31sFaPWnWJPmb2qXM8pqZ4w==
+jest-runner@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-runner/-/jest-runner-29.7.0.tgz#809af072d408a53dcfd2e849a4c976d3132f718e"
+  integrity sha512-fsc4N6cPCAahybGBfTRcq5wFR6fpLznMg47sY5aDpsoejOcVYFb07AHuSnR0liMcPTgBsA3ZJL6kFOjPdoNipQ==
   dependencies:
-    "@jest/console" "^29.6.2"
-    "@jest/environment" "^29.6.2"
-    "@jest/test-result" "^29.6.2"
-    "@jest/transform" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/console" "^29.7.0"
+    "@jest/environment" "^29.7.0"
+    "@jest/test-result" "^29.7.0"
+    "@jest/transform" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     chalk "^4.0.0"
     emittery "^0.13.1"
     graceful-fs "^4.2.9"
-    jest-docblock "^29.4.3"
-    jest-environment-node "^29.6.2"
-    jest-haste-map "^29.6.2"
-    jest-leak-detector "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-resolve "^29.6.2"
-    jest-runtime "^29.6.2"
-    jest-util "^29.6.2"
-    jest-watcher "^29.6.2"
-    jest-worker "^29.6.2"
+    jest-docblock "^29.7.0"
+    jest-environment-node "^29.7.0"
+    jest-haste-map "^29.7.0"
+    jest-leak-detector "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-resolve "^29.7.0"
+    jest-runtime "^29.7.0"
+    jest-util "^29.7.0"
+    jest-watcher "^29.7.0"
+    jest-worker "^29.7.0"
     p-limit "^3.1.0"
     source-map-support "0.5.13"
 
-jest-runtime@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-runtime/-/jest-runtime-29.6.2.tgz#692f25e387f982e89ab83270e684a9786248e545"
-  integrity sha512-2X9dqK768KufGJyIeLmIzToDmsN0m7Iek8QNxRSI/2+iPFYHF0jTwlO3ftn7gdKd98G/VQw9XJCk77rbTGZnJg==
-  dependencies:
-    "@jest/environment" "^29.6.2"
-    "@jest/fake-timers" "^29.6.2"
-    "@jest/globals" "^29.6.2"
-    "@jest/source-map" "^29.6.0"
-    "@jest/test-result" "^29.6.2"
-    "@jest/transform" "^29.6.2"
-    "@jest/types" "^29.6.1"
+jest-runtime@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-runtime/-/jest-runtime-29.7.0.tgz#efecb3141cf7d3767a3a0cc8f7c9990587d3d817"
+  integrity sha512-gUnLjgwdGqW7B4LvOIkbKs9WGbn+QLqRQQ9juC6HndeDiezIwhDP+mhMwHWCEcfQ5RUXa6OPnFF8BJh5xegwwQ==
+  dependencies:
+    "@jest/environment" "^29.7.0"
+    "@jest/fake-timers" "^29.7.0"
+    "@jest/globals" "^29.7.0"
+    "@jest/source-map" "^29.6.3"
+    "@jest/test-result" "^29.7.0"
+    "@jest/transform" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     chalk "^4.0.0"
     cjs-module-lexer "^1.0.0"
     collect-v8-coverage "^1.0.0"
     glob "^7.1.3"
     graceful-fs "^4.2.9"
-    jest-haste-map "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-mock "^29.6.2"
-    jest-regex-util "^29.4.3"
-    jest-resolve "^29.6.2"
-    jest-snapshot "^29.6.2"
-    jest-util "^29.6.2"
+    jest-haste-map "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-mock "^29.7.0"
+    jest-regex-util "^29.6.3"
+    jest-resolve "^29.7.0"
+    jest-snapshot "^29.7.0"
+    jest-util "^29.7.0"
     slash "^3.0.0"
     strip-bom "^4.0.0"
 
 jest-silent-reporter@0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/jest-silent-reporter/-/jest-silent-reporter-0.5.0.tgz#5fd8ccd61665227e3bf19d908b7350719d06ff38"
+  resolved "https://registry.npmjs.org/jest-silent-reporter/-/jest-silent-reporter-0.5.0.tgz#5fd8ccd61665227e3bf19d908b7350719d06ff38"
   integrity sha512-epdLt8Oj0a1AyRiR6F8zx/1SVT1Mi7VU3y4wB2uOBHs/ohIquC7v2eeja7UN54uRPyHInIKWdL+RdG228n5pJQ==
   dependencies:
     chalk "^4.0.0"
     jest-util "^26.0.0"
 
-jest-snapshot@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-snapshot/-/jest-snapshot-29.6.2.tgz#9b431b561a83f2bdfe041e1cab8a6becdb01af9c"
-  integrity sha512-1OdjqvqmRdGNvWXr/YZHuyhh5DeaLp1p/F8Tht/MrMw4Kr1Uu/j4lRG+iKl1DAqUJDWxtQBMk41Lnf/JETYBRA==
+jest-snapshot@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-29.7.0.tgz#c2c574c3f51865da1bb329036778a69bf88a6be5"
+  integrity sha512-Rm0BMWtxBcioHr1/OX5YCP8Uov4riHvKPknOGs804Zg9JGZgmIBkbtlxJC/7Z4msKYVbIJtfU+tKb8xlYNfdkw==
   dependencies:
     "@babel/core" "^7.11.6"
     "@babel/generator" "^7.7.2"
     "@babel/plugin-syntax-jsx" "^7.7.2"
     "@babel/plugin-syntax-typescript" "^7.7.2"
     "@babel/types" "^7.3.3"
-    "@jest/expect-utils" "^29.6.2"
-    "@jest/transform" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/expect-utils" "^29.7.0"
+    "@jest/transform" "^29.7.0"
+    "@jest/types" "^29.6.3"
     babel-preset-current-node-syntax "^1.0.0"
     chalk "^4.0.0"
-    expect "^29.6.2"
+    expect "^29.7.0"
     graceful-fs "^4.2.9"
-    jest-diff "^29.6.2"
-    jest-get-type "^29.4.3"
-    jest-matcher-utils "^29.6.2"
-    jest-message-util "^29.6.2"
-    jest-util "^29.6.2"
+    jest-diff "^29.7.0"
+    jest-get-type "^29.6.3"
+    jest-matcher-utils "^29.7.0"
+    jest-message-util "^29.7.0"
+    jest-util "^29.7.0"
     natural-compare "^1.4.0"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
     semver "^7.5.3"
 
 jest-util@^26.0.0:
   version "26.6.2"
-  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-26.6.2.tgz#907535dbe4d5a6cb4c47ac9b926f6af29576cbc1"
+  resolved "https://registry.npmjs.org/jest-util/-/jest-util-26.6.2.tgz#907535dbe4d5a6cb4c47ac9b926f6af29576cbc1"
   integrity sha512-MDW0fKfsn0OI7MS7Euz6h8HNDXVQ0gaM9uW6RjfDmd1DAFcaxX9OqIakHIqhbnmF08Cf2DLDG+ulq8YQQ0Lp0Q==
   dependencies:
     "@jest/types" "^26.6.2"
@@ -4512,66 +4666,66 @@ jest-util@^26.0.0:
     is-ci "^2.0.0"
     micromatch "^4.0.2"
 
-jest-util@^29.0.0, jest-util@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-util/-/jest-util-29.6.2.tgz#8a052df8fff2eebe446769fd88814521a517664d"
-  integrity sha512-3eX1qb6L88lJNCFlEADKOkjpXJQyZRiavX1INZ4tRnrBVr2COd3RgcTLyUiEXMNBlDU/cgYq6taUS0fExrWW4w==
+jest-util@^29.0.0, jest-util@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz#23c2b62bfb22be82b44de98055802ff3710fc0bc"
+  integrity sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     chalk "^4.0.0"
     ci-info "^3.2.0"
     graceful-fs "^4.2.9"
     picomatch "^2.2.3"
 
-jest-validate@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-29.6.2.tgz#25d972af35b2415b83b1373baf1a47bb266c1082"
-  integrity sha512-vGz0yMN5fUFRRbpJDPwxMpgSXW1LDKROHfBopAvDcmD6s+B/s8WJrwi+4bfH4SdInBA5C3P3BI19dBtKzx1Arg==
+jest-validate@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-validate/-/jest-validate-29.7.0.tgz#7bf705511c64da591d46b15fce41400d52147d9c"
+  integrity sha512-ZB7wHqaRGVw/9hST/OuFUReG7M8vKeq0/J2egIGLdvjHCmYqGARhzXmtgi+gVeZ5uXFF219aOc3Ls2yLg27tkw==
   dependencies:
-    "@jest/types" "^29.6.1"
+    "@jest/types" "^29.6.3"
     camelcase "^6.2.0"
     chalk "^4.0.0"
-    jest-get-type "^29.4.3"
+    jest-get-type "^29.6.3"
     leven "^3.1.0"
-    pretty-format "^29.6.2"
+    pretty-format "^29.7.0"
 
-jest-watcher@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-watcher/-/jest-watcher-29.6.2.tgz#77c224674f0620d9f6643c4cfca186d8893ca088"
-  integrity sha512-GZitlqkMkhkefjfN/p3SJjrDaxPflqxEAv3/ik10OirZqJGYH5rPiIsgVcfof0Tdqg3shQGdEIxDBx+B4tuLzA==
+jest-watcher@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-watcher/-/jest-watcher-29.7.0.tgz#7810d30d619c3a62093223ce6bb359ca1b28a2f2"
+  integrity sha512-49Fg7WXkU3Vl2h6LbLtMQ/HyB6rXSIX7SqvBLQmssRBGN9I0PNvPmAmCWSOY6SOvrjhI/F7/bGAv9RtnsPA03g==
   dependencies:
-    "@jest/test-result" "^29.6.2"
-    "@jest/types" "^29.6.1"
+    "@jest/test-result" "^29.7.0"
+    "@jest/types" "^29.6.3"
     "@types/node" "*"
     ansi-escapes "^4.2.1"
     chalk "^4.0.0"
     emittery "^0.13.1"
-    jest-util "^29.6.2"
+    jest-util "^29.7.0"
     string-length "^4.0.1"
 
 jest-worker@^27.4.5:
   version "27.5.1"
-  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
+  resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
   integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==
   dependencies:
     "@types/node" "*"
     merge-stream "^2.0.0"
     supports-color "^8.0.0"
 
-jest-worker@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-29.6.2.tgz#682fbc4b6856ad0aa122a5403c6d048b83f3fb44"
-  integrity sha512-l3ccBOabTdkng8I/ORCkADz4eSMKejTYv1vB/Z83UiubqhC1oQ5Li6dWCyqOIvSifGjUBxuvxvlm6KGK2DtuAQ==
+jest-worker@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/jest-worker/-/jest-worker-29.7.0.tgz#acad073acbbaeb7262bd5389e1bcf43e10058d4a"
+  integrity sha512-eIz2msL/EzL9UFTFFx7jBTkeZfku0yUAyZZZmJ93H2TYEiroIx2PQjEXcwYtYl8zXCxb+PAmA2hLIt/6ZEkPHw==
   dependencies:
     "@types/node" "*"
-    jest-util "^29.6.2"
+    jest-util "^29.7.0"
     merge-stream "^2.0.0"
     supports-color "^8.0.0"
 
 jest@29.6.2:
   version "29.6.2"
-  resolved "https://registry.yarnpkg.com/jest/-/jest-29.6.2.tgz#3bd55b9fd46a161b2edbdf5f1d1bd0d1eab76c42"
+  resolved "https://registry.npmjs.org/jest/-/jest-29.6.2.tgz#3bd55b9fd46a161b2edbdf5f1d1bd0d1eab76c42"
   integrity sha512-8eQg2mqFbaP7CwfsTpCxQ+sHzw1WuNWL5UUvjnWP4hx2riGz9fPSzYOaU5q8/GqWn1TfgZIVTqYJygbGbWAANg==
   dependencies:
     "@jest/core" "^29.6.2"
@@ -4581,12 +4735,12 @@ jest@29.6.2:
 
 js-tokens@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
+  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
 js-yaml@^3.13.1:
   version "3.14.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
   dependencies:
     argparse "^1.0.7"
@@ -4594,76 +4748,81 @@ js-yaml@^3.13.1:
 
 js-yaml@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
   integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
   dependencies:
     argparse "^2.0.1"
 
 jsesc@^2.5.1:
   version "2.5.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
+  resolved "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
   integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
 
 jsesc@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e"
+  resolved "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz#bb8b09a6597ba426425f2e4a07245c3d00b9343e"
   integrity sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==
 
 jsesc@~0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
+  resolved "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
   integrity sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==
 
 json-bignum@^0.0.3:
   version "0.0.3"
-  resolved "https://registry.yarnpkg.com/json-bignum/-/json-bignum-0.0.3.tgz#41163b50436c773d82424dbc20ed70db7604b8d7"
+  resolved "https://registry.npmjs.org/json-bignum/-/json-bignum-0.0.3.tgz#41163b50436c773d82424dbc20ed70db7604b8d7"
   integrity sha512-2WHyXj3OfHSgNyuzDbSxI1w2jgw5gkWSWhS7Qg4bWXx1nLk3jnbwfUeS0PSba3IzpTUWdHxBieELUzXRjQB2zg==
 
+json-buffer@3.0.1:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13"
+  integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
+
 json-joy@^9.2.0:
-  version "9.5.1"
-  resolved "https://registry.yarnpkg.com/json-joy/-/json-joy-9.5.1.tgz#056683b4db4b0e279451a563a756b70b9fd97fa3"
-  integrity sha512-XMSpdxaiWUZlc+CAUbPS3G2MZbGxm6clFatqjta/DLrq5V4Y5JU4cx7Qvy7l+XTVPvmRWaYuzzAuCf9uUc40IA==
+  version "9.6.0"
+  resolved "https://registry.npmjs.org/json-joy/-/json-joy-9.6.0.tgz#b691310024205b2d082737ca3c7e72cac0e364ac"
+  integrity sha512-vJtJD89T0OOZFMaENe95xKCOdibMev/lELkclTdhZxLplwbBPxneWNuctUPizk2nLqtGfBxwCXVO42G9LBoFBA==
   dependencies:
     arg "^5.0.2"
     hyperdyperid "^1.2.0"
 
 json-parse-even-better-errors@^2.3.0, json-parse-even-better-errors@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
+  resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
   integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
 
 json-schema-traverse@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
+  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
 json-stable-stringify-without-jsonify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
+  resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
   integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==
 
 json2csv@^5.0.6:
   version "5.0.7"
-  resolved "https://registry.yarnpkg.com/json2csv/-/json2csv-5.0.7.tgz#f3a583c25abd9804be873e495d1e65ad8d1b54ae"
+  resolved "https://registry.npmjs.org/json2csv/-/json2csv-5.0.7.tgz#f3a583c25abd9804be873e495d1e65ad8d1b54ae"
   integrity sha512-YRZbUnyaJZLZUJSRi2G/MqahCyRv9n/ds+4oIetjDF3jWQA7AG7iSeKTiZiCNqtMZM7HDyt0e/W6lEnoGEmMGA==
   dependencies:
     commander "^6.1.0"
     jsonparse "^1.3.1"
     lodash.get "^4.4.2"
 
-json5@^2.2.2, json5@^2.2.3:
+json5@^2.2.3:
   version "2.2.3"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
+  resolved "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz#78cd6f1a19bdc12b73db5ad0c61efd66c1e29283"
   integrity sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==
 
 jsonc-parser@^3.2.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-3.2.0.tgz#31ff3f4c2b9793f89c67212627c51c6394f88e76"
+  resolved "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz#31ff3f4c2b9793f89c67212627c51c6394f88e76"
   integrity sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==
 
 jsonfile@^6.0.1:
   version "6.1.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
+  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
   integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
   dependencies:
     universalify "^2.0.0"
@@ -4672,51 +4831,58 @@ jsonfile@^6.0.1:
 
 jsonparse@^1.3.1:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
+  resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
   integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==
 
 just-debounce@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/just-debounce/-/just-debounce-1.1.0.tgz#2f81a3ad4121a76bc7cb45dbf704c0d76a8e5ddf"
+  resolved "https://registry.npmjs.org/just-debounce/-/just-debounce-1.1.0.tgz#2f81a3ad4121a76bc7cb45dbf704c0d76a8e5ddf"
   integrity sha512-qpcRocdkUmf+UTNBYx5w6dexX5J31AKK1OmPwH630a83DdVVUIngk55RSAiIGpQyoH0dlr872VHfPjnQnK1qDQ==
 
+keyv@^4.5.3:
+  version "4.5.3"
+  resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.3.tgz#00873d2b046df737963157bd04f294ca818c9c25"
+  integrity sha512-QCiSav9WaX1PgETJ+SpNnx2PRRapJ/oRSXM4VO5OGYGSjrxbKPVFVhB3l2OCbLCk329N8qyAtsJjSjvVBWzEug==
+  dependencies:
+    json-buffer "3.0.1"
+
 kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
   version "3.2.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
   integrity sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==
   dependencies:
     is-buffer "^1.1.5"
 
 kind-of@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
   integrity sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw==
   dependencies:
     is-buffer "^1.1.5"
 
 kind-of@^5.0.0, kind-of@^5.0.2:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
   integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
 
 kind-of@^6.0.0, kind-of@^6.0.2, kind-of@^6.0.3:
   version "6.0.3"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
   integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
 
 kleur@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e"
+  resolved "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz#a79c9ecc86ee1ce3fa6206d1216c501f147fc07e"
   integrity sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==
 
 kleur@^4.1.4:
   version "4.1.5"
-  resolved "https://registry.yarnpkg.com/kleur/-/kleur-4.1.5.tgz#95106101795f7050c6c650f350c683febddb1780"
+  resolved "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz#95106101795f7050c6c650f350c683febddb1780"
   integrity sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==
 
 last-run@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/last-run/-/last-run-1.1.1.tgz#45b96942c17b1c79c772198259ba943bebf8ca5b"
+  resolved "https://registry.npmjs.org/last-run/-/last-run-1.1.1.tgz#45b96942c17b1c79c772198259ba943bebf8ca5b"
   integrity sha512-U/VxvpX4N/rFvPzr3qG5EtLKEnNI0emvIQB3/ecEwv+8GHaUKbIB8vxv1Oai5FAF0d0r7LXHhLLe5K/yChm5GQ==
   dependencies:
     default-resolution "^2.0.0"
@@ -4724,33 +4890,33 @@ last-run@^1.1.0:
 
 lazystream@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/lazystream/-/lazystream-1.0.1.tgz#494c831062f1f9408251ec44db1cba29242a2638"
+  resolved "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz#494c831062f1f9408251ec44db1cba29242a2638"
   integrity sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==
   dependencies:
     readable-stream "^2.0.5"
 
 lcid@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835"
+  resolved "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz#308accafa0bc483a3867b4b6f2b9506251d1b835"
   integrity sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==
   dependencies:
     invert-kv "^1.0.0"
 
 lead@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lead/-/lead-1.0.0.tgz#6f14f99a37be3a9dd784f5495690e5903466ee42"
+  resolved "https://registry.npmjs.org/lead/-/lead-1.0.0.tgz#6f14f99a37be3a9dd784f5495690e5903466ee42"
   integrity sha512-IpSVCk9AYvLHo5ctcIXxOBpMWUe+4TKN3VPWAKUbJikkmsGp0VrSM8IttVc32D6J4WUsiPE6aEFRNmIoF/gdow==
   dependencies:
     flush-write-stream "^1.0.2"
 
 leven@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2"
+  resolved "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz#77891de834064cccba82ae7842bb6b14a13ed7f2"
   integrity sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==
 
 levn@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
+  resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
   integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
   dependencies:
     prelude-ls "^1.2.1"
@@ -4758,7 +4924,7 @@ levn@^0.4.1:
 
 liftoff@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/liftoff/-/liftoff-3.1.0.tgz#c9ba6081f908670607ee79062d700df062c52ed3"
+  resolved "https://registry.npmjs.org/liftoff/-/liftoff-3.1.0.tgz#c9ba6081f908670607ee79062d700df062c52ed3"
   integrity sha512-DlIPlJUkCV0Ips2zf2pJP0unEoT1kwYhiiPUGF3s/jtxTCjziNLoiVVh+jqWOWeFi6mmwQ5fNxvAUyPad4Dfog==
   dependencies:
     extend "^3.0.0"
@@ -4772,12 +4938,12 @@ liftoff@^3.1.0:
 
 lines-and-columns@^1.1.6:
   version "1.2.4"
-  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
+  resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
   integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
 
 load-json-file@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
+  resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
   integrity sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==
   dependencies:
     graceful-fs "^4.1.2"
@@ -4788,96 +4954,96 @@ load-json-file@^1.0.0:
 
 loader-runner@^4.2.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
+  resolved "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
   integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
 
 locate-path@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
   integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
   dependencies:
     p-locate "^4.1.0"
 
 locate-path@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
   integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
   dependencies:
     p-locate "^5.0.0"
 
 lodash.assignwith@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.assignwith/-/lodash.assignwith-4.2.0.tgz#127a97f02adc41751a954d24b0de17e100e038eb"
+  resolved "https://registry.npmjs.org/lodash.assignwith/-/lodash.assignwith-4.2.0.tgz#127a97f02adc41751a954d24b0de17e100e038eb"
   integrity sha512-ZznplvbvtjK2gMvnQ1BR/zqPFZmS6jbK4p+6Up4xcRYA7yMIwxHCfbTcrYxXKzzqLsQ05eJPVznEW3tuwV7k1g==
 
 lodash.camelcase@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
+  resolved "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz#b28aa6288a2b9fc651035c7711f65ab6190331a6"
   integrity sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==
 
 lodash.clone@^4.3.2:
   version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-4.5.0.tgz#195870450f5a13192478df4bc3d23d2dea1907b6"
+  resolved "https://registry.npmjs.org/lodash.clone/-/lodash.clone-4.5.0.tgz#195870450f5a13192478df4bc3d23d2dea1907b6"
   integrity sha512-GhrVeweiTD6uTmmn5hV/lzgCQhccwReIVRLHp7LT4SopOjqEZ5BbX8b5WWEtAKasjmy8hR7ZPwsYlxRCku5odg==
 
 lodash.debounce@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
+  resolved "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
   integrity sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==
 
 lodash.escape@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/lodash.escape/-/lodash.escape-4.0.1.tgz#c9044690c21e04294beaa517712fded1fa88de98"
+  resolved "https://registry.npmjs.org/lodash.escape/-/lodash.escape-4.0.1.tgz#c9044690c21e04294beaa517712fded1fa88de98"
   integrity sha512-nXEOnb/jK9g0DYMr1/Xvq6l5xMD7GDG55+GSYIYmS0G4tBk/hURD4JR9WCavs04t33WmJx9kCyp9vJ+mr4BOUw==
 
 lodash.flatten@^4.4.0:
   version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
+  resolved "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
   integrity sha512-C5N2Z3DgnnKr0LOpv/hKCgKdb7ZZwafIrsesve6lmzvZIRZRGaZ/l6Q8+2W7NaT+ZwO3fFlSCzCzrDCFdJfZ4g==
 
 lodash.get@^4.4.2:
   version "4.4.2"
-  resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
+  resolved "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99"
   integrity sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==
 
 lodash.invokemap@^4.6.0:
   version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.invokemap/-/lodash.invokemap-4.6.0.tgz#1748cda5d8b0ef8369c4eb3ec54c21feba1f2d62"
+  resolved "https://registry.npmjs.org/lodash.invokemap/-/lodash.invokemap-4.6.0.tgz#1748cda5d8b0ef8369c4eb3ec54c21feba1f2d62"
   integrity sha512-CfkycNtMqgUlfjfdh2BhKO/ZXrP8ePOX5lEU/g0R3ItJcnuxWDwokMGKx1hWcfOikmyOVx6X9IwWnDGlgKl61w==
 
 lodash.memoize@4.x:
   version "4.1.2"
-  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
+  resolved "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
   integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==
 
 lodash.merge@^4.6.2:
   version "4.6.2"
-  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
+  resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
   integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
 
 lodash.pullall@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.pullall/-/lodash.pullall-4.2.0.tgz#9d98b8518b7c965b0fae4099bd9fb7df8bbf38ba"
+  resolved "https://registry.npmjs.org/lodash.pullall/-/lodash.pullall-4.2.0.tgz#9d98b8518b7c965b0fae4099bd9fb7df8bbf38ba"
   integrity sha512-VhqxBKH0ZxPpLhiu68YD1KnHmbhQJQctcipvmFnqIBDYzcIHzf3Zpu0tpeOKtR4x76p9yohc506eGdOjTmyIBg==
 
 lodash.some@^4.2.2:
   version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.some/-/lodash.some-4.6.0.tgz#1bb9f314ef6b8baded13b549169b2a945eb68e4d"
+  resolved "https://registry.npmjs.org/lodash.some/-/lodash.some-4.6.0.tgz#1bb9f314ef6b8baded13b549169b2a945eb68e4d"
   integrity sha512-j7MJE+TuT51q9ggt4fSgVqro163BEFjAt3u97IqU+JA2DkWl80nFTrowzLpZ/BnpN7rrl0JA/593NAdd8p/scQ==
 
 lodash.uniqby@^4.7.0:
   version "4.7.0"
-  resolved "https://registry.yarnpkg.com/lodash.uniqby/-/lodash.uniqby-4.7.0.tgz#d99c07a669e9e6d24e1362dfe266c67616af1302"
+  resolved "https://registry.npmjs.org/lodash.uniqby/-/lodash.uniqby-4.7.0.tgz#d99c07a669e9e6d24e1362dfe266c67616af1302"
   integrity sha512-e/zcLx6CSbmaEgFHCA7BnoQKyCtKMxnuWrJygbwPs/AIn+IMKl66L8/s+wBUn5LRw2pZx3bUHibiV1b6aTWIww==
 
 lodash@^4.17.21, lodash@^4.17.4:
   version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 
 log-update@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
+  resolved "https://registry.npmjs.org/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
   integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==
   dependencies:
     ansi-escapes "^4.3.0"
@@ -4887,91 +5053,91 @@ log-update@^4.0.0:
 
 lru-cache@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
   integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
   dependencies:
     yallist "^3.0.2"
 
 lru-cache@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
   integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
   dependencies:
     yallist "^4.0.0"
 
-lru-cache@^9.1.1:
-  version "9.1.2"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-9.1.2.tgz#255fdbc14b75589d6d0e73644ca167a8db506835"
-  integrity sha512-ERJq3FOzJTxBbFjZ7iDs+NiK4VI9Wz+RdrrAB8dio1oV+YvdPzUEE4QNiT2VD51DkIbCYRUUzCRkssXCHqSnKQ==
+"lru-cache@^9.1.1 || ^10.0.0":
+  version "10.0.1"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-10.0.1.tgz#0a3be479df549cca0e5d693ac402ff19537a6b7a"
+  integrity sha512-IJ4uwUTi2qCccrioU6g9g/5rvvVl13bsdczUUcqbciD9iLr095yj8DQKdObriEvuNSx325N1rV1O0sJFszx75g==
 
 lru-queue@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/lru-queue/-/lru-queue-0.1.0.tgz#2738bd9f0d3cf4f84490c5736c48699ac632cda3"
+  resolved "https://registry.npmjs.org/lru-queue/-/lru-queue-0.1.0.tgz#2738bd9f0d3cf4f84490c5736c48699ac632cda3"
   integrity sha512-BpdYkt9EvGl8OfWHDQPISVpcl5xZthb+XPsbELj5AQXxIC8IriDZIQYjBJPEm5rS420sjZ0TLEzRcq5KdBhYrQ==
   dependencies:
     es5-ext "~0.10.2"
 
 lunr@^2.3.9:
   version "2.3.9"
-  resolved "https://registry.yarnpkg.com/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1"
+  resolved "https://registry.npmjs.org/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1"
   integrity sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==
 
-make-dir@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
-  integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
+make-dir@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz#c3c2307a771277cd9638305f915c29ae741b614e"
+  integrity sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==
   dependencies:
-    semver "^6.0.0"
+    semver "^7.5.3"
 
 make-error@1.x, make-error@^1.1.1:
   version "1.3.6"
-  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
+  resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
 
 make-iterator@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/make-iterator/-/make-iterator-1.0.1.tgz#29b33f312aa8f547c4a5e490f56afcec99133ad6"
+  resolved "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz#29b33f312aa8f547c4a5e490f56afcec99133ad6"
   integrity sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==
   dependencies:
     kind-of "^6.0.2"
 
 makeerror@1.0.12:
   version "1.0.12"
-  resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a"
+  resolved "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a"
   integrity sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==
   dependencies:
     tmpl "1.0.5"
 
 map-cache@^0.2.0, map-cache@^0.2.2:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
+  resolved "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
   integrity sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==
 
 map-obj@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
+  resolved "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
   integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==
 
 map-obj@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
+  resolved "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
   integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
 
 map-visit@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
+  resolved "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
   integrity sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w==
   dependencies:
     object-visit "^1.0.0"
 
 marked@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/marked/-/marked-4.3.0.tgz#796362821b019f734054582038b116481b456cf3"
+  resolved "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz#796362821b019f734054582038b116481b456cf3"
   integrity sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==
 
 matchdep@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/matchdep/-/matchdep-2.0.0.tgz#c6f34834a0d8dbc3b37c27ee8bbcb27c7775582e"
+  resolved "https://registry.npmjs.org/matchdep/-/matchdep-2.0.0.tgz#c6f34834a0d8dbc3b37c27ee8bbcb27c7775582e"
   integrity sha512-LFgVbaHIHMqCRuCZyfCtUOq9/Lnzhi7Z0KFUE2fhD54+JN2jLh3hC02RLkqauJ3U4soU6H1J3tfj/Byk7GoEjA==
   dependencies:
     findup-sync "^2.0.0"
@@ -4981,7 +5147,7 @@ matchdep@^2.0.0:
 
 math-random@^1.0.1:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
+  resolved "https://registry.npmjs.org/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
   integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==
 
 memfs@4.5.0:
@@ -4994,7 +5160,7 @@ memfs@4.5.0:
 
 memoizee@0.4.X:
   version "0.4.15"
-  resolved "https://registry.yarnpkg.com/memoizee/-/memoizee-0.4.15.tgz#e6f3d2da863f318d02225391829a6c5956555b72"
+  resolved "https://registry.npmjs.org/memoizee/-/memoizee-0.4.15.tgz#e6f3d2da863f318d02225391829a6c5956555b72"
   integrity sha512-UBWmJpLZd5STPm7PMUlOw/TSy972M+z8gcyQ5veOnSDRREz/0bmpyTfKt3/51DhEBqCZQn1udM/5flcSPYhkdQ==
   dependencies:
     d "^1.0.1"
@@ -5008,7 +5174,7 @@ memoizee@0.4.X:
 
 memory-fs@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
+  resolved "https://registry.npmjs.org/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
   integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
   dependencies:
     errno "^0.1.3"
@@ -5016,7 +5182,7 @@ memory-fs@^0.5.0:
 
 meow@^10.1.3:
   version "10.1.5"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-10.1.5.tgz#be52a1d87b5f5698602b0f32875ee5940904aa7f"
+  resolved "https://registry.npmjs.org/meow/-/meow-10.1.5.tgz#be52a1d87b5f5698602b0f32875ee5940904aa7f"
   integrity sha512-/d+PQ4GKmGvM9Bee/DPa8z3mXs/pkvJE2KEThngVNOqtmljC6K7NMPxtc2JeZYTmpWb9k/TmxjeL18ez3h7vCw==
   dependencies:
     "@types/minimist" "^1.2.2"
@@ -5034,17 +5200,17 @@ meow@^10.1.3:
 
 merge-stream@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
+  resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
   integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
 
 merge2@^1.3.0, merge2@^1.4.1:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
+  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
 micromatch@^3.0.4, micromatch@^3.1.10, micromatch@^3.1.4:
   version "3.1.10"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
+  resolved "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
   integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
   dependencies:
     arr-diff "^4.0.0"
@@ -5063,7 +5229,7 @@ micromatch@^3.0.4, micromatch@^3.1.10, micromatch@^3.1.4:
 
 micromatch@^4.0.2, micromatch@^4.0.4:
   version "4.0.5"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
+  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
   integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
   dependencies:
     braces "^3.0.2"
@@ -5071,43 +5237,43 @@ micromatch@^4.0.2, micromatch@^4.0.4:
 
 mime-db@1.52.0:
   version "1.52.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
+  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
   integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
 mime-types@^2.1.27:
   version "2.1.35"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
+  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
   integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
   dependencies:
     mime-db "1.52.0"
 
 mimic-fn@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
   integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
 
 min-indent@^1.0.0, min-indent@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
+  resolved "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
   integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
 
 minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2:
   version "3.1.2"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
   integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
   dependencies:
     brace-expansion "^1.1.7"
 
 minimatch@^9.0.0, minimatch@^9.0.1:
-  version "9.0.1"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.1.tgz#8a555f541cf976c622daf078bb28f29fb927c253"
-  integrity sha512-0jWhJpD/MdhPXwPuiRkCbfYfSKp2qnn2eOc279qI7f+osl/l+prKSrvhg157zSYvx/1nmgn2NqdT6k2Z7zSH9w==
+  version "9.0.3"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-9.0.3.tgz#a6e00c3de44c3a542bfaae70abfc22420a6da825"
+  integrity sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==
   dependencies:
     brace-expansion "^2.0.1"
 
 minimist-options@4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
+  resolved "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
   integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==
   dependencies:
     arrify "^1.0.1"
@@ -5116,17 +5282,22 @@ minimist-options@4.1.0:
 
 minimist@1.x:
   version "1.2.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
 
 "minipass@^5.0.0 || ^6.0.2":
   version "6.0.2"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-6.0.2.tgz#542844b6c4ce95b202c0995b0a471f1229de4c81"
+  resolved "https://registry.npmjs.org/minipass/-/minipass-6.0.2.tgz#542844b6c4ce95b202c0995b0a471f1229de4c81"
   integrity sha512-MzWSV5nYVT7mVyWCwn2o7JH13w2TBRmmSqSRCKzTw+lmft9X4z+3wjvs06Tzijo5z4W/kahUCDpRXTF+ZrmF/w==
 
+"minipass@^5.0.0 || ^6.0.2 || ^7.0.0":
+  version "7.0.3"
+  resolved "https://registry.npmjs.org/minipass/-/minipass-7.0.3.tgz#05ea638da44e475037ed94d1c7efcc76a25e1974"
+  integrity sha512-LhbbwCfz3vsb12j/WkWQPZfKTsgqIe1Nf/ti1pKjYESGLHIVjWU96G9/ljLH4F9mWNVhlQOm0VySdAWzf05dpg==
+
 mixin-deep@^1.2.0:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
+  resolved "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
   integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
   dependencies:
     for-in "^1.0.2"
@@ -5134,32 +5305,32 @@ mixin-deep@^1.2.0:
 
 mkdirp@3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-3.0.1.tgz#e44e4c5607fb279c168241713cc6e0fea9adcb50"
+  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-3.0.1.tgz#e44e4c5607fb279c168241713cc6e0fea9adcb50"
   integrity sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==
 
 mrmime@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/mrmime/-/mrmime-1.0.1.tgz#5f90c825fad4bdd41dc914eff5d1a8cfdaf24f27"
+  resolved "https://registry.npmjs.org/mrmime/-/mrmime-1.0.1.tgz#5f90c825fad4bdd41dc914eff5d1a8cfdaf24f27"
   integrity sha512-hzzEagAgDyoU1Q6yg5uI+AorQgdvMCur3FcKf7NhMKWsaYg+RnbTyHRa/9IlLF9rf455MOCtcqqrQQ83pPP7Uw==
 
 ms@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
   integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==
 
 ms@2.1.2:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
 ms@^2.1.1:
   version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
 multistream@4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/multistream/-/multistream-4.1.0.tgz#7bf00dfd119556fbc153cff3de4c6d477909f5a8"
+  resolved "https://registry.npmjs.org/multistream/-/multistream-4.1.0.tgz#7bf00dfd119556fbc153cff3de4c6d477909f5a8"
   integrity sha512-J1XDiAmmNpRCBfIWJv+n0ymC4ABcf/Pl+5YvC5B/D2f/2+8PtHvCNxMPKiQcZyi922Hq69J2YOpb1pTywfifyw==
   dependencies:
     once "^1.4.0"
@@ -5167,17 +5338,17 @@ multistream@4.1.0:
 
 mute-stdout@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/mute-stdout/-/mute-stdout-1.0.1.tgz#acb0300eb4de23a7ddeec014e3e96044b3472331"
+  resolved "https://registry.npmjs.org/mute-stdout/-/mute-stdout-1.0.1.tgz#acb0300eb4de23a7ddeec014e3e96044b3472331"
   integrity sha512-kDcwXR4PS7caBpuRYYBUz9iVixUk3anO3f5OYFiIPwK/20vCzKCHyKoulbiDY1S53zD2bxUpxN/IJ+TnXjfvxg==
 
 nan@^2.12.1:
-  version "2.17.0"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.17.0.tgz#c0150a2368a182f033e9aa5195ec76ea41a199cb"
-  integrity sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==
+  version "2.18.0"
+  resolved "https://registry.npmjs.org/nan/-/nan-2.18.0.tgz#26a6faae7ffbeb293a39660e88a76b82e30b7554"
+  integrity sha512-W7tfG7vMOGtD30sHoZSSc/JVYiyDPEyQVso/Zz+/uQd0B0L46gtC+pHha5FFMRpil6fm/AoEcRWyOVi4+E/f8w==
 
 nanomatch@^1.2.9:
   version "1.2.13"
-  resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
+  resolved "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
   integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
   dependencies:
     arr-diff "^4.0.0"
@@ -5194,37 +5365,37 @@ nanomatch@^1.2.9:
 
 natural-compare-lite@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz#17b09581988979fddafe0201e931ba933c96cbb4"
+  resolved "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz#17b09581988979fddafe0201e931ba933c96cbb4"
   integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==
 
 natural-compare@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
+  resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==
 
 neo-async@^2.6.2:
   version "2.6.2"
-  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
+  resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
 next-tick@1, next-tick@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb"
+  resolved "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz#1836ee30ad56d67ef281b22bd199f709449b35eb"
   integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==
 
 node-int64@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b"
+  resolved "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b"
   integrity sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==
 
-node-releases@^2.0.12:
-  version "2.0.12"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.12.tgz#35627cc224a23bfb06fb3380f2b3afaaa7eb1039"
-  integrity sha512-QzsYKWhXTWx8h1kIvqfnC++o0pEmpRQA/aenALsL2F4pqNVr7YzcdMlDij5WBnwftRbJCNJL/O7zdKaxKPHqgQ==
+node-releases@^2.0.13:
+  version "2.0.13"
+  resolved "https://registry.npmjs.org/node-releases/-/node-releases-2.0.13.tgz#d5ed1627c23e3461e819b02e57b75e4899b1c81d"
+  integrity sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ==
 
 normalize-package-data@^2.3.2, normalize-package-data@^2.5.0:
   version "2.5.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
+  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
   integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
   dependencies:
     hosted-git-info "^2.1.4"
@@ -5234,7 +5405,7 @@ normalize-package-data@^2.3.2, normalize-package-data@^2.5.0:
 
 normalize-package-data@^3.0.2:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
+  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
   integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
   dependencies:
     hosted-git-info "^4.0.1"
@@ -5244,43 +5415,43 @@ normalize-package-data@^3.0.2:
 
 normalize-path@^2.0.1, normalize-path@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
   integrity sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w==
   dependencies:
     remove-trailing-separator "^1.0.1"
 
 normalize-path@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
   integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
 now-and-later@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/now-and-later/-/now-and-later-2.0.1.tgz#8e579c8685764a7cc02cb680380e94f43ccb1f7c"
+  resolved "https://registry.npmjs.org/now-and-later/-/now-and-later-2.0.1.tgz#8e579c8685764a7cc02cb680380e94f43ccb1f7c"
   integrity sha512-KGvQ0cB70AQfg107Xvs/Fbu+dGmZoTRJp2TaPwcwQm3/7PteUyN2BCgk8KBMPGBUXZdVwyWS8fDCGFygBm19UQ==
   dependencies:
     once "^1.3.2"
 
 npm-run-path@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
+  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
   integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
   dependencies:
     path-key "^3.0.0"
 
 number-is-nan@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
+  resolved "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
   integrity sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==
 
 object-assign@4.X, object-assign@^4.0.1:
   version "4.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
 
 object-copy@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
+  resolved "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
   integrity sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ==
   dependencies:
     copy-descriptor "^0.1.0"
@@ -5289,19 +5460,19 @@ object-copy@^0.1.0:
 
 object-keys@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
+  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
 object-visit@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
+  resolved "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
   integrity sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA==
   dependencies:
     isobject "^3.0.0"
 
 object.assign@^4.0.4, object.assign@^4.1.0:
   version "4.1.4"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.4.tgz#9673c7c7c351ab8c4d0b516f4343ebf4dfb7799f"
+  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz#9673c7c7c351ab8c4d0b516f4343ebf4dfb7799f"
   integrity sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==
   dependencies:
     call-bind "^1.0.2"
@@ -5311,7 +5482,7 @@ object.assign@^4.0.4, object.assign@^4.1.0:
 
 object.defaults@^1.0.0, object.defaults@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/object.defaults/-/object.defaults-1.1.0.tgz#3a7f868334b407dea06da16d88d5cd29e435fecf"
+  resolved "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz#3a7f868334b407dea06da16d88d5cd29e435fecf"
   integrity sha512-c/K0mw/F11k4dEUBMW8naXUuBuhxRCfG7W+yFy8EcijU/rSmazOUd1XAEEe6bC0OuXY4HUKjTJv7xbxIMqdxrA==
   dependencies:
     array-each "^1.0.1"
@@ -5321,7 +5492,7 @@ object.defaults@^1.0.0, object.defaults@^1.1.0:
 
 object.map@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object.map/-/object.map-1.0.1.tgz#cf83e59dc8fcc0ad5f4250e1f78b3b81bd801d37"
+  resolved "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz#cf83e59dc8fcc0ad5f4250e1f78b3b81bd801d37"
   integrity sha512-3+mAJu2PLfnSVGHwIWubpOFLscJANBKuB/6A4CxBstc4aqwQY0FWcsppuy4jU5GSB95yES5JHSI+33AWuS4k6w==
   dependencies:
     for-own "^1.0.0"
@@ -5329,14 +5500,14 @@ object.map@^1.0.0:
 
 object.pick@^1.2.0, object.pick@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
+  resolved "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
   integrity sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==
   dependencies:
     isobject "^3.0.1"
 
 object.reduce@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object.reduce/-/object.reduce-1.0.1.tgz#6fe348f2ac7fa0f95ca621226599096825bb03ad"
+  resolved "https://registry.npmjs.org/object.reduce/-/object.reduce-1.0.1.tgz#6fe348f2ac7fa0f95ca621226599096825bb03ad"
   integrity sha512-naLhxxpUESbNkRqc35oQ2scZSJueHGQNUfMW/0U37IgN6tE2dgDWg3whf+NEliy3F/QysrO48XKUz/nGPe+AQw==
   dependencies:
     for-own "^1.0.0"
@@ -5344,106 +5515,106 @@ object.reduce@^1.0.0:
 
 once@^1.3.0, once@^1.3.1, once@^1.3.2, once@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
   integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==
   dependencies:
     wrappy "1"
 
 onetime@^5.1.0, onetime@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
+  resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
   integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
   dependencies:
     mimic-fn "^2.1.0"
 
 opener@^1.5.2:
   version "1.5.2"
-  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
+  resolved "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
 optionator@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
-  integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
+  version "0.9.3"
+  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz#007397d44ed1872fdc6ed31360190f81814e2c64"
+  integrity sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==
   dependencies:
+    "@aashutoshrathi/word-wrap" "^1.2.3"
     deep-is "^0.1.3"
     fast-levenshtein "^2.0.6"
     levn "^0.4.1"
     prelude-ls "^1.2.1"
     type-check "^0.4.0"
-    word-wrap "^1.2.3"
 
 ordered-read-streams@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz#77c0cb37c41525d64166d990ffad7ec6a0e1363e"
+  resolved "https://registry.npmjs.org/ordered-read-streams/-/ordered-read-streams-1.0.1.tgz#77c0cb37c41525d64166d990ffad7ec6a0e1363e"
   integrity sha512-Z87aSjx3r5c0ZB7bcJqIgIRX5bxR7A4aSzvIbaxd0oTkWBCOoKfuGHiKj60CHVUgg1Phm5yMZzBdt8XqRs73Mw==
   dependencies:
     readable-stream "^2.0.1"
 
 os-locale@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/os-locale/-/os-locale-1.4.0.tgz#20f9f17ae29ed345e8bde583b13d2009803c14d9"
+  resolved "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz#20f9f17ae29ed345e8bde583b13d2009803c14d9"
   integrity sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==
   dependencies:
     lcid "^1.0.0"
 
 p-limit@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
   integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
   dependencies:
     p-try "^2.0.0"
 
 p-limit@^3.0.2, p-limit@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
   integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
   dependencies:
     yocto-queue "^0.1.0"
 
 p-locate@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
   integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
   dependencies:
     p-limit "^2.2.0"
 
 p-locate@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
   integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
   dependencies:
     p-limit "^3.0.2"
 
 p-map@^5.5.0:
   version "5.5.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-5.5.0.tgz#054ca8ca778dfa4cf3f8db6638ccb5b937266715"
+  resolved "https://registry.npmjs.org/p-map/-/p-map-5.5.0.tgz#054ca8ca778dfa4cf3f8db6638ccb5b937266715"
   integrity sha512-VFqfGDHlx87K66yZrNdI4YGtD70IRyd+zSvgks6mzHPRNkoKy+9EKP4SFC77/vTTQYmRmti7dvqC+m5jBrBAcg==
   dependencies:
     aggregate-error "^4.0.0"
 
 p-try@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
+  resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
 
 pad-left@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/pad-left/-/pad-left-2.1.0.tgz#16e6a3b2d44a8e138cb0838cc7cb403a4fc9e994"
+  resolved "https://registry.npmjs.org/pad-left/-/pad-left-2.1.0.tgz#16e6a3b2d44a8e138cb0838cc7cb403a4fc9e994"
   integrity sha512-HJxs9K9AztdIQIAIa/OIazRAUW/L6B9hbQDxO4X07roW3eo9XqZc2ur9bn1StH9CnbbI9EgvejHQX7CBpCF1QA==
   dependencies:
     repeat-string "^1.5.4"
 
 parent-module@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
+  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
   integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
   dependencies:
     callsites "^3.0.0"
 
 parse-filepath@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/parse-filepath/-/parse-filepath-1.0.2.tgz#a632127f53aaf3d15876f5872f3ffac763d6c891"
+  resolved "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz#a632127f53aaf3d15876f5872f3ffac763d6c891"
   integrity sha512-FwdRXKCohSVeXqwtYonZTXtbGJKrn+HNyWDYVcp5yuJlesTwNH4rsmRZ+GrKAPJ5bLpRxESMeS+Rl0VCHRvB2Q==
   dependencies:
     is-absolute "^1.0.0"
@@ -5452,14 +5623,14 @@ parse-filepath@^1.0.1:
 
 parse-json@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
+  resolved "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
   integrity sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==
   dependencies:
     error-ex "^1.2.0"
 
 parse-json@^5.0.0, parse-json@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
+  resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
   integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -5469,74 +5640,74 @@ parse-json@^5.0.0, parse-json@^5.2.0:
 
 parse-node-version@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parse-node-version/-/parse-node-version-1.0.1.tgz#e2b5dbede00e7fa9bc363607f53327e8b073189b"
+  resolved "https://registry.npmjs.org/parse-node-version/-/parse-node-version-1.0.1.tgz#e2b5dbede00e7fa9bc363607f53327e8b073189b"
   integrity sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==
 
 parse-passwd@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
+  resolved "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
   integrity sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==
 
 pascalcase@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
+  resolved "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
   integrity sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw==
 
 path-dirname@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
+  resolved "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
   integrity sha512-ALzNPpyNq9AqXMBjeymIjFDAkAFH06mHJH/cSBHAgU0s4vfpBn6b2nf8tiRLvagKD8RbTpq2FKTBg7cl9l3c7Q==
 
 path-exists@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
   integrity sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==
   dependencies:
     pinkie-promise "^2.0.0"
 
 path-exists@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
   integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
 
 path-is-absolute@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
   integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==
 
 path-key@^3.0.0, path-key@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
 path-parse@^1.0.7:
   version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
+  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
 
 path-root-regex@^0.1.0:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/path-root-regex/-/path-root-regex-0.1.2.tgz#bfccdc8df5b12dc52c8b43ec38d18d72c04ba96d"
+  resolved "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz#bfccdc8df5b12dc52c8b43ec38d18d72c04ba96d"
   integrity sha512-4GlJ6rZDhQZFE0DPVKh0e9jmZ5egZfxTkp7bcRDuPlJXbAwhxcl2dINPUAsjLdejqaLsCeg8axcLjIbvBjN4pQ==
 
 path-root@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/path-root/-/path-root-0.1.1.tgz#9a4a6814cac1c0cd73360a95f32083c8ea4745b7"
+  resolved "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz#9a4a6814cac1c0cd73360a95f32083c8ea4745b7"
   integrity sha512-QLcPegTHF11axjfojBIoDygmS2E3Lf+8+jI6wOVmNVenrKSo3mFdSGiIgdSHenczw3wPtlVMQaFVwGmM7BJdtg==
   dependencies:
     path-root-regex "^0.1.0"
 
 path-scurry@^1.7.0:
-  version "1.9.2"
-  resolved "https://registry.yarnpkg.com/path-scurry/-/path-scurry-1.9.2.tgz#90f9d296ac5e37e608028e28a447b11d385b3f63"
-  integrity sha512-qSDLy2aGFPm8i4rsbHd4MNyTcrzHFsLQykrtbuGRknZZCBBVXSv2tSCDN2Cg6Rt/GFRw8GoW9y9Ecw5rIPG1sg==
+  version "1.10.1"
+  resolved "https://registry.npmjs.org/path-scurry/-/path-scurry-1.10.1.tgz#9ba6bf5aa8500fe9fd67df4f0d9483b2b0bfc698"
+  integrity sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==
   dependencies:
-    lru-cache "^9.1.1"
-    minipass "^5.0.0 || ^6.0.2"
+    lru-cache "^9.1.1 || ^10.0.0"
+    minipass "^5.0.0 || ^6.0.2 || ^7.0.0"
 
 path-type@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
+  resolved "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
   integrity sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==
   dependencies:
     graceful-fs "^4.1.2"
@@ -5545,61 +5716,61 @@ path-type@^1.0.0:
 
 path-type@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
+  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
 picocolors@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-0.2.1.tgz#570670f793646851d1ba135996962abad587859f"
+  resolved "https://registry.npmjs.org/picocolors/-/picocolors-0.2.1.tgz#570670f793646851d1ba135996962abad587859f"
   integrity sha512-cMlDqaLEqfSaW8Z7N5Jw+lyIW869EzT73/F5lhtY9cLGoVxSXznfgfXMO0Z5K0o0Q2TkTXq+0KFsdnSe3jDViA==
 
 picocolors@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
+  resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
   integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
 
 picomatch@^2.0.4, picomatch@^2.2.3, picomatch@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
 pify@^2.0.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
+  resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
   integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==
 
 pinkie-promise@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  resolved "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
   integrity sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==
   dependencies:
     pinkie "^2.0.0"
 
 pinkie@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+  resolved "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
   integrity sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==
 
 pirates@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b"
-  integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==
+  version "4.0.6"
+  resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.6.tgz#3018ae32ecfcff6c29ba2267cbf21166ac1f36b9"
+  integrity sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==
 
 pkg-dir@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
+  resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
   integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
   dependencies:
     find-up "^4.0.0"
 
 platform@^1.3.3:
   version "1.3.6"
-  resolved "https://registry.yarnpkg.com/platform/-/platform-1.3.6.tgz#48b4ce983164b209c2d45a107adb31f473a6e7a7"
+  resolved "https://registry.npmjs.org/platform/-/platform-1.3.6.tgz#48b4ce983164b209c2d45a107adb31f473a6e7a7"
   integrity sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==
 
 plugin-error@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/plugin-error/-/plugin-error-1.0.1.tgz#77016bd8919d0ac377fdcdd0322328953ca5781c"
+  resolved "https://registry.npmjs.org/plugin-error/-/plugin-error-1.0.1.tgz#77016bd8919d0ac377fdcdd0322328953ca5781c"
   integrity sha512-L1zP0dk7vGweZME2i+EeakvUNqSrdiI3F91TwEoYiGrAfUXmVv6fJIq4g82PAXxNsWOp0J7ZqQy/3Szz0ajTxA==
   dependencies:
     ansi-colors "^1.0.1"
@@ -5609,24 +5780,24 @@ plugin-error@^1.0.1:
 
 plugin-error@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/plugin-error/-/plugin-error-2.0.1.tgz#f2ac92bac8c85e3e23492d76d0c3ca12f30eb00b"
+  resolved "https://registry.npmjs.org/plugin-error/-/plugin-error-2.0.1.tgz#f2ac92bac8c85e3e23492d76d0c3ca12f30eb00b"
   integrity sha512-zMakqvIDyY40xHOvzXka0kUvf40nYIuwRE8dWhti2WtjQZ31xAgBZBhxsK7vK3QbRXS1Xms/LO7B5cuAsfB2Gg==
   dependencies:
     ansi-colors "^1.0.1"
 
 pluralize@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-8.0.0.tgz#1a6fa16a38d12a1901e0320fa017051c539ce3b1"
+  resolved "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz#1a6fa16a38d12a1901e0320fa017051c539ce3b1"
   integrity sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==
 
 posix-character-classes@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
+  resolved "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
   integrity sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg==
 
 postcss@^7.0.16:
   version "7.0.39"
-  resolved "https://registry.yarnpkg.com/postcss/-/postcss-7.0.39.tgz#9624375d965630e2e1f2c02a935c82a59cb48309"
+  resolved "https://registry.npmjs.org/postcss/-/postcss-7.0.39.tgz#9624375d965630e2e1f2c02a935c82a59cb48309"
   integrity sha512-yioayjNbHn6z1/Bywyb2Y4s3yvDAeXGOyxqD+LnVOinq6Mdmd++SW2wUNVzavyyHxd6+DxzWGIuosg6P1Rj8uA==
   dependencies:
     picocolors "^0.2.1"
@@ -5634,38 +5805,38 @@ postcss@^7.0.16:
 
 prelude-ls@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
+  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
-pretty-format@^29.0.0, pretty-format@^29.6.2:
-  version "29.6.2"
-  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.6.2.tgz#3d5829261a8a4d89d8b9769064b29c50ed486a47"
-  integrity sha512-1q0oC8eRveTg5nnBEWMXAU2qpv65Gnuf2eCQzSjxpWFkPaPARwqZZDGuNE0zPAZfTCHzIk3A8dIjwlQKKLphyg==
+pretty-format@^29.0.0, pretty-format@^29.7.0:
+  version "29.7.0"
+  resolved "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz#ca42c758310f365bfa71a0bda0a807160b776812"
+  integrity sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==
   dependencies:
-    "@jest/schemas" "^29.6.0"
+    "@jest/schemas" "^29.6.3"
     ansi-styles "^5.0.0"
     react-is "^18.0.0"
 
 pretty-hrtime@^1.0.0:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz#b7e3ea42435a4c9b2759d99e0f201eb195802ee1"
+  resolved "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz#b7e3ea42435a4c9b2759d99e0f201eb195802ee1"
   integrity sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==
 
 process-nextick-args@^2.0.0, process-nextick-args@~2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
+  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
 promise@^8.0.1:
   version "8.3.0"
-  resolved "https://registry.yarnpkg.com/promise/-/promise-8.3.0.tgz#8cb333d1edeb61ef23869fbb8a4ea0279ab60e0a"
+  resolved "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz#8cb333d1edeb61ef23869fbb8a4ea0279ab60e0a"
   integrity sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==
   dependencies:
     asap "~2.0.6"
 
 prompts@^2.0.1:
   version "2.4.2"
-  resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069"
+  resolved "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069"
   integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==
   dependencies:
     kleur "^3.0.3"
@@ -5673,12 +5844,12 @@ prompts@^2.0.1:
 
 prr@~1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
+  resolved "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
   integrity sha512-yPw4Sng1gWghHQWj0B3ZggWUm4qVbPwPFcRG8KyxiU7J2OHFSoEHKS+EZ3fv5l1t9CyCiop6l/ZYeWbrgoQejw==
 
 pump@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
+  resolved "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
   integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
   dependencies:
     end-of-stream "^1.1.0"
@@ -5686,7 +5857,7 @@ pump@^2.0.0:
 
 pumpify@^1.3.5:
   version "1.5.1"
-  resolved "https://registry.yarnpkg.com/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
+  resolved "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
   integrity sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==
   dependencies:
     duplexify "^3.6.0"
@@ -5695,32 +5866,32 @@ pumpify@^1.3.5:
 
 punycode@^2.1.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz#f67fa67c94da8f4d0cfff981aee4118064199b8f"
   integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==
 
 pure-rand@^6.0.0:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/pure-rand/-/pure-rand-6.0.2.tgz#a9c2ddcae9b68d736a8163036f088a2781c8b306"
-  integrity sha512-6Yg0ekpKICSjPswYOuC5sku/TSWaRYlA0qsXqJgM/d/4pLPHPuTxK7Nbf7jFKzAeedUhR8C7K9Uv63FBsSo8xQ==
+  version "6.0.3"
+  resolved "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.3.tgz#3c9e6b53c09e52ac3cedffc85ab7c1c7094b38cb"
+  integrity sha512-KddyFewCsO0j3+np81IQ+SweXLDnDQTs5s67BOnrYmYe/yNmUhttQyGsYzy8yUnoljGAQ9sl38YB4vH8ur7Y+w==
 
 queue-microtask@^1.2.2:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
+  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
 queue-tick@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/queue-tick/-/queue-tick-1.0.1.tgz#f6f07ac82c1fd60f82e098b417a80e52f1f4c142"
+  resolved "https://registry.npmjs.org/queue-tick/-/queue-tick-1.0.1.tgz#f6f07ac82c1fd60f82e098b417a80e52f1f4c142"
   integrity sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==
 
 quick-lru@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
+  resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
   integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
 randomatic@3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
+  resolved "https://registry.npmjs.org/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
   integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==
   dependencies:
     is-number "^4.0.0"
@@ -5729,19 +5900,19 @@ randomatic@3.1.1:
 
 randombytes@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
+  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
   integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
   dependencies:
     safe-buffer "^5.1.0"
 
 react-is@^18.0.0:
   version "18.2.0"
-  resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.2.0.tgz#199431eeaaa2e09f86427efbb4f1473edb47609b"
+  resolved "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz#199431eeaaa2e09f86427efbb4f1473edb47609b"
   integrity sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==
 
 read-pkg-up@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
   integrity sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==
   dependencies:
     find-up "^1.0.0"
@@ -5749,7 +5920,7 @@ read-pkg-up@^1.0.1:
 
 read-pkg-up@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
   integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
   dependencies:
     find-up "^4.1.0"
@@ -5758,7 +5929,7 @@ read-pkg-up@^7.0.1:
 
 read-pkg-up@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-8.0.0.tgz#72f595b65e66110f43b052dd9af4de6b10534670"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-8.0.0.tgz#72f595b65e66110f43b052dd9af4de6b10534670"
   integrity sha512-snVCqPczksT0HS2EC+SxUndvSzn6LRCwpfSvLrIfR5BKDQQZMaI6jPRC9dYvYFDRAuFEAnkwww8kBBNE/3VvzQ==
   dependencies:
     find-up "^5.0.0"
@@ -5767,7 +5938,7 @@ read-pkg-up@^8.0.0:
 
 read-pkg@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
   integrity sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==
   dependencies:
     load-json-file "^1.0.0"
@@ -5776,7 +5947,7 @@ read-pkg@^1.0.0:
 
 read-pkg@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
   integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==
   dependencies:
     "@types/normalize-package-data" "^2.4.0"
@@ -5786,7 +5957,7 @@ read-pkg@^5.2.0:
 
 read-pkg@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-6.0.0.tgz#a67a7d6a1c2b0c3cd6aa2ea521f40c458a4a504c"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-6.0.0.tgz#a67a7d6a1c2b0c3cd6aa2ea521f40c458a4a504c"
   integrity sha512-X1Fu3dPuk/8ZLsMhEj5f4wFAF0DWoK7qhGJvgaijocXxBmSToKfbFtqbxMO7bVjNA1dmE5huAzjXj/ey86iw9Q==
   dependencies:
     "@types/normalize-package-data" "^2.4.0"
@@ -5796,7 +5967,7 @@ read-pkg@^6.0.0:
 
 "readable-stream@2 || 3", readable-stream@3, readable-stream@^3.6.0:
   version "3.6.2"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967"
   integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==
   dependencies:
     inherits "^2.0.3"
@@ -5805,7 +5976,7 @@ read-pkg@^6.0.0:
 
 readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.5, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.3, readable-stream@^2.3.5, readable-stream@^2.3.6, readable-stream@~2.3.6:
   version "2.3.8"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.8.tgz#91125e8042bba1b9887f49345f6277027ce8be9b"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz#91125e8042bba1b9887f49345f6277027ce8be9b"
   integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==
   dependencies:
     core-util-is "~1.0.0"
@@ -5818,7 +5989,7 @@ readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable
 
 readdirp@^2.2.1:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525"
   integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==
   dependencies:
     graceful-fs "^4.1.11"
@@ -5827,22 +5998,27 @@ readdirp@^2.2.1:
 
 rechoir@^0.6.2:
   version "0.6.2"
-  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
+  resolved "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
   integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==
   dependencies:
     resolve "^1.1.6"
 
 redent@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-4.0.0.tgz#0c0ba7caabb24257ab3bb7a4fd95dd1d5c5681f9"
+  resolved "https://registry.npmjs.org/redent/-/redent-4.0.0.tgz#0c0ba7caabb24257ab3bb7a4fd95dd1d5c5681f9"
   integrity sha512-tYkDkVVtYkSVhuQ4zBgfvciymHaeuel+zFKXShfDnFP5SyVEP7qo70Rf1jTOTCx3vGNAbnEi/xFkcfQVMIBWag==
   dependencies:
     indent-string "^5.0.0"
     strip-indent "^4.0.0"
 
+regenerator-runtime@0.14.0:
+  version "0.14.0"
+  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.0.tgz#5e19d68eb12d486f797e15a3c6a918f7cec5eb45"
+  integrity sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==
+
 regex-not@^1.0.0, regex-not@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
+  resolved "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
   integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
   dependencies:
     extend-shallow "^3.0.2"
@@ -5850,19 +6026,19 @@ regex-not@^1.0.0, regex-not@^1.0.2:
 
 regexp-tree@^0.1.24, regexp-tree@~0.1.1:
   version "0.1.27"
-  resolved "https://registry.yarnpkg.com/regexp-tree/-/regexp-tree-0.1.27.tgz#2198f0ef54518ffa743fe74d983b56ffd631b6cd"
+  resolved "https://registry.npmjs.org/regexp-tree/-/regexp-tree-0.1.27.tgz#2198f0ef54518ffa743fe74d983b56ffd631b6cd"
   integrity sha512-iETxpjK6YoRWJG5o6hXLwvjYAoW+FEZn9os0PD/b6AP6xQwsa/Y7lCVgIixBbUPMfhu+i2LtdeAqVTgGlQarfA==
 
 regjsparser@^0.10.0:
   version "0.10.0"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.10.0.tgz#b1ed26051736b436f22fdec1c8f72635f9f44892"
+  resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.10.0.tgz#b1ed26051736b436f22fdec1c8f72635f9f44892"
   integrity sha512-qx+xQGZVsy55CH0a1hiVwHmqjLryfh7wQyF5HO07XJ9f7dQMY/gPQHhlyDkIzJKC+x2fUCpCcUODUUUFrm7SHA==
   dependencies:
     jsesc "~0.5.0"
 
 remove-bom-buffer@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz#c2bf1e377520d324f623892e33c10cac2c252b53"
+  resolved "https://registry.npmjs.org/remove-bom-buffer/-/remove-bom-buffer-3.0.0.tgz#c2bf1e377520d324f623892e33c10cac2c252b53"
   integrity sha512-8v2rWhaakv18qcvNeli2mZ/TMTL2nEyAKRvzo1WtnZBl15SHyEhrCu2/xKlJyUFKHiHgfXIyuY6g2dObJJycXQ==
   dependencies:
     is-buffer "^1.1.5"
@@ -5870,7 +6046,7 @@ remove-bom-buffer@^3.0.0:
 
 remove-bom-stream@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz#05f1a593f16e42e1fb90ebf59de8e569525f9523"
+  resolved "https://registry.npmjs.org/remove-bom-stream/-/remove-bom-stream-1.2.0.tgz#05f1a593f16e42e1fb90ebf59de8e569525f9523"
   integrity sha512-wigO8/O08XHb8YPzpDDT+QmRANfW6vLqxfaXm1YXhnFf3AkSLyjfG3GEFg4McZkmgL7KvCj5u2KczkvSP6NfHA==
   dependencies:
     remove-bom-buffer "^3.0.0"
@@ -5879,32 +6055,32 @@ remove-bom-stream@^1.2.0:
 
 remove-trailing-separator@^1.0.1, remove-trailing-separator@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
+  resolved "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
   integrity sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw==
 
 repeat-element@^1.1.2:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9"
+  resolved "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9"
   integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==
 
 repeat-string@^1.5.4, repeat-string@^1.6.1:
   version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
+  resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
   integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==
 
 replace-ext@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-1.0.1.tgz#2d6d996d04a15855d967443631dd5f77825b016a"
+  resolved "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.1.tgz#2d6d996d04a15855d967443631dd5f77825b016a"
   integrity sha512-yD5BHCe7quCgBph4rMQ+0KkIRKwWCrHDOX1p1Gp6HwjPM5kVoCdKGNhN7ydqqsX6lJEnQDKZ/tFMiEdQ1dvPEw==
 
 replace-ext@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-2.0.0.tgz#9471c213d22e1bcc26717cd6e50881d88f812b06"
+  resolved "https://registry.npmjs.org/replace-ext/-/replace-ext-2.0.0.tgz#9471c213d22e1bcc26717cd6e50881d88f812b06"
   integrity sha512-UszKE5KVK6JvyD92nzMn9cDapSk6w/CaFZ96CnmDMUqH9oowfxF/ZjRITD25H4DnOQClLA4/j7jLGXXLVKxAug==
 
 replace-homedir@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/replace-homedir/-/replace-homedir-1.0.0.tgz#e87f6d513b928dde808260c12be7fec6ff6e798c"
+  resolved "https://registry.npmjs.org/replace-homedir/-/replace-homedir-1.0.0.tgz#e87f6d513b928dde808260c12be7fec6ff6e798c"
   integrity sha512-CHPV/GAglbIB1tnQgaiysb8H2yCy8WQ7lcEwQ/eT+kLj0QHV8LnJW0zpqpE7RSkrMSRoa+EBoag86clf7WAgSg==
   dependencies:
     homedir-polyfill "^1.0.1"
@@ -5913,7 +6089,7 @@ replace-homedir@^1.0.0:
 
 replacestream@^4.0.3:
   version "4.0.3"
-  resolved "https://registry.yarnpkg.com/replacestream/-/replacestream-4.0.3.tgz#3ee5798092be364b1cdb1484308492cb3dff2f36"
+  resolved "https://registry.npmjs.org/replacestream/-/replacestream-4.0.3.tgz#3ee5798092be364b1cdb1484308492cb3dff2f36"
   integrity sha512-AC0FiLS352pBBiZhd4VXB1Ab/lh0lEgpP+GGvZqbQh8a5cmXVoTe5EX/YeTFArnp4SRGTHh1qCHu9lGs1qG8sA==
   dependencies:
     escape-string-regexp "^1.0.3"
@@ -5922,24 +6098,24 @@ replacestream@^4.0.3:
 
 require-directory@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
+  resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
 
 require-main-filename@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
+  resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
   integrity sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==
 
 resolve-cwd@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d"
+  resolved "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d"
   integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==
   dependencies:
     resolve-from "^5.0.0"
 
 resolve-dir@^1.0.0, resolve-dir@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
+  resolved "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
   integrity sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==
   dependencies:
     expand-tilde "^2.0.0"
@@ -5947,43 +6123,43 @@ resolve-dir@^1.0.0, resolve-dir@^1.0.1:
 
 resolve-from@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
+  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
 resolve-from@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
+  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
   integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
 
 resolve-options@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/resolve-options/-/resolve-options-1.1.0.tgz#32bb9e39c06d67338dc9378c0d6d6074566ad131"
+  resolved "https://registry.npmjs.org/resolve-options/-/resolve-options-1.1.0.tgz#32bb9e39c06d67338dc9378c0d6d6074566ad131"
   integrity sha512-NYDgziiroVeDC29xq7bp/CacZERYsA9bXYd1ZmcJlF3BcrZv5pTb4NG7SjdyKDnXZ84aC4vo2u6sNKIA1LCu/A==
   dependencies:
     value-or-function "^3.0.0"
 
 resolve-url@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
+  resolved "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
   integrity sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==
 
 resolve.exports@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/resolve.exports/-/resolve.exports-2.0.2.tgz#f8c934b8e6a13f539e38b7098e2e36134f01e800"
+  resolved "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.2.tgz#f8c934b8e6a13f539e38b7098e2e36134f01e800"
   integrity sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==
 
 resolve@^1.1.6, resolve@^1.1.7, resolve@^1.10.0, resolve@^1.20.0, resolve@^1.22.1, resolve@^1.4.0:
-  version "1.22.2"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.2.tgz#0ed0943d4e301867955766c9f3e1ae6d01c6845f"
-  integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==
+  version "1.22.4"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.4.tgz#1dc40df46554cdaf8948a486a10f6ba1e2026c34"
+  integrity sha512-PXNdCiPqDqeUou+w1C2eTQbNfxKSuMxqTCuvlmmMsk1NWHL5fRrhY6Pl0qEYYc6+QqGClco1Qj8XnjPego4wfg==
   dependencies:
-    is-core-module "^2.11.0"
+    is-core-module "^2.13.0"
     path-parse "^1.0.7"
     supports-preserve-symlinks-flag "^1.0.0"
 
 restore-cursor@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
+  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
   integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
   dependencies:
     onetime "^5.1.0"
@@ -5991,75 +6167,75 @@ restore-cursor@^3.1.0:
 
 ret@~0.1.10:
   version "0.1.15"
-  resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
+  resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
 
 reusify@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
+  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
   integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
 
 rimraf@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
+  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
   dependencies:
     glob "^7.1.3"
 
 rollup@3.25.0:
   version "3.25.0"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.25.0.tgz#71327d396a9decbf23c87b55916ae7204211738a"
+  resolved "https://registry.npmjs.org/rollup/-/rollup-3.25.0.tgz#71327d396a9decbf23c87b55916ae7204211738a"
   integrity sha512-FnJkNRst2jEZGw7f+v4hFo6UTzpDKrAKcHZWcEfm5/GJQ5CK7wgb4moNLNAe7npKUev7yQn1AY/YbZRIxOv6Qg==
   optionalDependencies:
     fsevents "~2.3.2"
 
 run-parallel@^1.1.9:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
+  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
   integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
   dependencies:
     queue-microtask "^1.2.2"
 
 rxjs@7.8.1:
   version "7.8.1"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543"
+  resolved "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543"
   integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==
   dependencies:
     tslib "^2.1.0"
 
 safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@~5.2.0:
   version "5.2.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
 safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
 safe-regex@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
+  resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
   integrity sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg==
   dependencies:
     ret "~0.1.10"
 
 safe-regex@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-2.1.1.tgz#f7128f00d056e2fe5c11e81a1324dd974aadced2"
+  resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-2.1.1.tgz#f7128f00d056e2fe5c11e81a1324dd974aadced2"
   integrity sha512-rx+x8AMzKb5Q5lQ95Zoi6ZbJqwCLkqi3XuJXp5P3rT8OEc6sZCJG5AE5dU3lsgRr/F4Bs31jSlVN+j5KrsGu9A==
   dependencies:
     regexp-tree "~0.1.1"
 
 sax@>=0.6.0:
   version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
+  resolved "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
   integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
 
 schema-utils@^3.1.1, schema-utils@^3.1.2:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.2.0.tgz#7dff4881064a4f22c09f0c6a1457feb820fd0636"
-  integrity sha512-0zTyLGyDJYd/MBxG1AhJkKa6fpEBds4OQO2ut0w7OYG+ZGhGea09lijvzsqegYSik88zc7cUtIlnnO+/BvD6gQ==
+  version "3.3.0"
+  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz#f50a88877c3c01652a15b622ae9e9795df7a60fe"
+  integrity sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==
   dependencies:
     "@types/json-schema" "^7.0.8"
     ajv "^6.12.5"
@@ -6067,43 +6243,43 @@ schema-utils@^3.1.1, schema-utils@^3.1.2:
 
 semver-greatest-satisfied-range@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz#13e8c2658ab9691cb0cd71093240280d36f77a5b"
+  resolved "https://registry.npmjs.org/semver-greatest-satisfied-range/-/semver-greatest-satisfied-range-1.1.0.tgz#13e8c2658ab9691cb0cd71093240280d36f77a5b"
   integrity sha512-Ny/iyOzSSa8M5ML46IAx3iXc6tfOsYU2R4AXi2UpHk60Zrgyq6eqPj/xiOfS0rRl/iiQ/rdJkVjw/5cdUyCntQ==
   dependencies:
     sver-compat "^1.5.0"
 
 "semver@2 || 3 || 4 || 5":
   version "5.7.2"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
+  resolved "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz#48d55db737c3287cd4835e17fa13feace1c41ef8"
   integrity sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==
 
-semver@^6.0.0, semver@^6.3.0:
+semver@^6.3.0, semver@^6.3.1:
   version "6.3.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
+  resolved "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz#556d2ef8689146e46dcea4bfdd095f3434dffcb4"
   integrity sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==
 
-semver@^7.3.4, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3:
+semver@^7.3.4, semver@^7.3.7, semver@^7.3.8, semver@^7.5.3, semver@^7.5.4:
   version "7.5.4"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
   dependencies:
     lru-cache "^6.0.0"
 
 serialize-javascript@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.1.tgz#b206efb27c3da0b0ab6b52f48d170b7996458e5c"
+  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.1.tgz#b206efb27c3da0b0ab6b52f48d170b7996458e5c"
   integrity sha512-owoXEFjWRllis8/M1Q+Cw5k8ZH40e3zhp/ovX+Xr/vi1qj6QesbyXXViFbpNvWvPNAD62SutwEXavefrLJWj7w==
   dependencies:
     randombytes "^2.1.0"
 
 set-blocking@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
+  resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
   integrity sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==
 
 set-value@^2.0.0, set-value@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
+  resolved "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz#a18d40530e6f07de4228c7defe4227af8cad005b"
   integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==
   dependencies:
     extend-shallow "^2.0.1"
@@ -6113,20 +6289,20 @@ set-value@^2.0.0, set-value@^2.0.1:
 
 shebang-command@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
   integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
   dependencies:
     shebang-regex "^3.0.0"
 
 shebang-regex@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
 shiki@^0.14.1:
-  version "0.14.2"
-  resolved "https://registry.yarnpkg.com/shiki/-/shiki-0.14.2.tgz#d51440800b701392b31ce2336036058e338247a1"
-  integrity sha512-ltSZlSLOuSY0M0Y75KA+ieRaZ0Trf5Wl3gutE7jzLuIcWxLp5i/uEnLoQWNvgKXQ5OMpGkJnVMRLAuzjc0LJ2A==
+  version "0.14.4"
+  resolved "https://registry.npmjs.org/shiki/-/shiki-0.14.4.tgz#2454969b466a5f75067d0f2fa0d7426d32881b20"
+  integrity sha512-IXCRip2IQzKwxArNNq1S+On4KPML3Yyn8Zzs/xRgcgOWIr8ntIK3IKzjFPfjy/7kt9ZMjc+FItfqHRBg8b6tNQ==
   dependencies:
     ansi-sequence-parser "^1.1.0"
     jsonc-parser "^3.2.0"
@@ -6135,17 +6311,17 @@ shiki@^0.14.1:
 
 signal-exit@^3.0.2, signal-exit@^3.0.3, signal-exit@^3.0.7:
   version "3.0.7"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
+  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
   integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
 
 signal-exit@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-4.0.2.tgz#ff55bb1d9ff2114c13b400688fa544ac63c36967"
-  integrity sha512-MY2/qGx4enyjprQnFaZsHib3Yadh3IXyV2C321GY0pjGfVBu4un0uDJkwgdxqO+Rdx8JMT8IfJIRwbYVz3Ob3Q==
+  version "4.1.0"
+  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz#952188c1cbd546070e2dd20d0f41c0ae0530cb04"
+  integrity sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==
 
 sirv@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.3.tgz#ca5868b87205a74bef62a469ed0296abceccd446"
+  resolved "https://registry.npmjs.org/sirv/-/sirv-2.0.3.tgz#ca5868b87205a74bef62a469ed0296abceccd446"
   integrity sha512-O9jm9BsID1P+0HOi81VpXPoDxYP374pkOLzACAoyUQ/3OUVndNpsz6wMnY2z+yOxzbllCKZrM+9QrWsv4THnyA==
   dependencies:
     "@polka/url" "^1.0.0-next.20"
@@ -6154,22 +6330,22 @@ sirv@^2.0.3:
 
 sisteransi@^1.0.5:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
+  resolved "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed"
   integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==
 
 slash@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
+  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
 slash@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-4.0.0.tgz#2422372176c4c6c5addb5e2ada885af984b396a7"
+  resolved "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz#2422372176c4c6c5addb5e2ada885af984b396a7"
   integrity sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==
 
 slice-ansi@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
+  resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
   integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
   dependencies:
     ansi-styles "^4.0.0"
@@ -6178,7 +6354,7 @@ slice-ansi@^4.0.0:
 
 snapdragon-node@^2.0.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
+  resolved "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
   integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
   dependencies:
     define-property "^1.0.0"
@@ -6187,14 +6363,14 @@ snapdragon-node@^2.0.1:
 
 snapdragon-util@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
+  resolved "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
   integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
   dependencies:
     kind-of "^3.2.0"
 
 snapdragon@^0.8.1:
   version "0.8.2"
-  resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
+  resolved "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
   integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
   dependencies:
     base "^0.11.1"
@@ -6208,7 +6384,7 @@ snapdragon@^0.8.1:
 
 source-map-resolve@^0.5.0:
   version "0.5.3"
-  resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
+  resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
   integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==
   dependencies:
     atob "^2.1.2"
@@ -6219,7 +6395,7 @@ source-map-resolve@^0.5.0:
 
 source-map-resolve@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.6.0.tgz#3d9df87e236b53f16d01e58150fc7711138e5ed2"
+  resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.6.0.tgz#3d9df87e236b53f16d01e58150fc7711138e5ed2"
   integrity sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==
   dependencies:
     atob "^2.1.2"
@@ -6227,7 +6403,7 @@ source-map-resolve@^0.6.0:
 
 source-map-support@0.5.13:
   version "0.5.13"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932"
+  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932"
   integrity sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==
   dependencies:
     buffer-from "^1.0.0"
@@ -6235,7 +6411,7 @@ source-map-support@0.5.13:
 
 source-map-support@~0.5.20:
   version "0.5.21"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
+  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
   integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
   dependencies:
     buffer-from "^1.0.0"
@@ -6243,32 +6419,32 @@ source-map-support@~0.5.20:
 
 source-map-url@^0.4.0:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56"
+  resolved "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56"
   integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==
 
 source-map@^0.5.1, source-map@^0.5.6:
   version "0.5.7"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==
 
 source-map@^0.6.0, source-map@^0.6.1:
   version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
 source-map@^0.7.3:
   version "0.7.4"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.4.tgz#a9bbe705c9d8846f4e08ff6765acf0f1b0898656"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz#a9bbe705c9d8846f4e08ff6765acf0f1b0898656"
   integrity sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==
 
 sparkles@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/sparkles/-/sparkles-1.0.1.tgz#008db65edce6c50eec0c5e228e1945061dd0437c"
+  resolved "https://registry.npmjs.org/sparkles/-/sparkles-1.0.1.tgz#008db65edce6c50eec0c5e228e1945061dd0437c"
   integrity sha512-dSO0DDYUahUt/0/pD/Is3VIm5TGJjludZ0HVymmhYF6eNA53PVLhnUk0znSYbH8IYBuJdCE+1luR22jNLMaQdw==
 
 spdx-correct@^3.0.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.2.0.tgz#4f5ab0668f0059e34f9c00dce331784a12de4e9c"
+  resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz#4f5ab0668f0059e34f9c00dce331784a12de4e9c"
   integrity sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==
   dependencies:
     spdx-expression-parse "^3.0.0"
@@ -6276,12 +6452,12 @@ spdx-correct@^3.0.0:
 
 spdx-exceptions@^2.1.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
+  resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
   integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==
 
 spdx-expression-parse@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
+  resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
   integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
   dependencies:
     spdx-exceptions "^2.1.0"
@@ -6289,36 +6465,36 @@ spdx-expression-parse@^3.0.0:
 
 spdx-license-ids@^3.0.0:
   version "3.0.13"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.13.tgz#7189a474c46f8d47c7b0da4b987bb45e908bd2d5"
+  resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.13.tgz#7189a474c46f8d47c7b0da4b987bb45e908bd2d5"
   integrity sha512-XkD+zwiqXHikFZm4AX/7JSCXA98U5Db4AFd5XUg/+9UNtnH75+Z9KxtpYiJZx36mUDVOwH83pl7yvCer6ewM3w==
 
 split-string@^3.0.1, split-string@^3.0.2:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
+  resolved "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
   integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
   dependencies:
     extend-shallow "^3.0.0"
 
 sprintf-js@~1.0.2:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
+  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
   integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==
 
 stack-trace@0.0.10:
   version "0.0.10"
-  resolved "https://registry.yarnpkg.com/stack-trace/-/stack-trace-0.0.10.tgz#547c70b347e8d32b4e108ea1a2a159e5fdde19c0"
+  resolved "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz#547c70b347e8d32b4e108ea1a2a159e5fdde19c0"
   integrity sha512-KGzahc7puUKkzyMt+IqAep+TVNbKP+k2Lmwhub39m1AsTSkaDutx56aDCo+HLDzf/D26BIHTJWNiTG1KAJiQCg==
 
 stack-utils@^2.0.3:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-2.0.6.tgz#aaf0748169c02fc33c8232abccf933f54a1cc34f"
+  resolved "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz#aaf0748169c02fc33c8232abccf933f54a1cc34f"
   integrity sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==
   dependencies:
     escape-string-regexp "^2.0.0"
 
 static-extend@^0.1.1:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
+  resolved "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
   integrity sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g==
   dependencies:
     define-property "^0.2.5"
@@ -6326,30 +6502,30 @@ static-extend@^0.1.1:
 
 stream-exhaust@^1.0.1, stream-exhaust@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/stream-exhaust/-/stream-exhaust-1.0.2.tgz#acdac8da59ef2bc1e17a2c0ccf6c320d120e555d"
+  resolved "https://registry.npmjs.org/stream-exhaust/-/stream-exhaust-1.0.2.tgz#acdac8da59ef2bc1e17a2c0ccf6c320d120e555d"
   integrity sha512-b/qaq/GlBK5xaq1yrK9/zFcyRSTNxmcZwFLGSTG0mXgZl/4Z6GgiyYOXOvY7N3eEvFRAG1bkDRz5EPGSvPYQlw==
 
 stream-read-all@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/stream-read-all/-/stream-read-all-3.0.1.tgz#60762ae45e61d93ba0978cda7f3913790052ad96"
+  resolved "https://registry.npmjs.org/stream-read-all/-/stream-read-all-3.0.1.tgz#60762ae45e61d93ba0978cda7f3913790052ad96"
   integrity sha512-EWZT9XOceBPlVJRrYcykW8jyRSZYbkb/0ZK36uLEmoWVO5gxBOnntNTseNzfREsqxqdfEGQrD8SXQ3QWbBmq8A==
 
 stream-shift@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/stream-shift/-/stream-shift-1.0.1.tgz#d7088281559ab2778424279b0877da3c392d5a3d"
+  resolved "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz#d7088281559ab2778424279b0877da3c392d5a3d"
   integrity sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==
 
 streamx@^2.12.5:
-  version "2.14.1"
-  resolved "https://registry.yarnpkg.com/streamx/-/streamx-2.14.1.tgz#783ebfb0ca494fd4655de11cbdb1ae20c4587147"
-  integrity sha512-Zt63KGejYaQIbZOlJeILKJxmzKJDQA6gLn1W0Fuiz7O4kTorbIQ3jhf57euOzuNAS0Y1BBP1HzGdI8bcf6bTNg==
+  version "2.15.1"
+  resolved "https://registry.npmjs.org/streamx/-/streamx-2.15.1.tgz#396ad286d8bc3eeef8f5cea3f029e81237c024c6"
+  integrity sha512-fQMzy2O/Q47rgwErk/eGeLu/roaFWV0jVsogDmrszM9uIw8L5OA+t+V93MgYlufNptfjmYR1tOMWhei/Eh7TQA==
   dependencies:
     fast-fifo "^1.1.0"
     queue-tick "^1.0.1"
 
 string-length@^4.0.1:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/string-length/-/string-length-4.0.2.tgz#a8a8dc7bd5c1a82b9b3c8b87e125f66871b6e57a"
+  resolved "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz#a8a8dc7bd5c1a82b9b3c8b87e125f66871b6e57a"
   integrity sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==
   dependencies:
     char-regex "^1.0.2"
@@ -6357,7 +6533,7 @@ string-length@^4.0.1:
 
 "string-width-cjs@npm:string-width@^4.2.0", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3:
   version "4.2.3"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
   dependencies:
     emoji-regex "^8.0.0"
@@ -6366,7 +6542,7 @@ string-length@^4.0.1:
 
 string-width@^1.0.1, string-width@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
   integrity sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==
   dependencies:
     code-point-at "^1.0.0"
@@ -6375,7 +6551,7 @@ string-width@^1.0.1, string-width@^1.0.2:
 
 string-width@^5.0.1, string-width@^5.1.2:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
   integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
   dependencies:
     eastasianwidth "^0.2.0"
@@ -6384,109 +6560,109 @@ string-width@^5.0.1, string-width@^5.1.2:
 
 string_decoder@^1.1.1:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
   dependencies:
     safe-buffer "~5.2.0"
 
 string_decoder@~1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
   integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
   dependencies:
     safe-buffer "~5.1.0"
 
 "strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
   dependencies:
     ansi-regex "^5.0.1"
 
 strip-ansi@^3.0.0, strip-ansi@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
   integrity sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==
   dependencies:
     ansi-regex "^2.0.0"
 
 strip-ansi@^7.0.1:
   version "7.1.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
   integrity sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==
   dependencies:
     ansi-regex "^6.0.1"
 
 strip-bom-string@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom-string/-/strip-bom-string-1.0.0.tgz#e5211e9224369fbb81d633a2f00044dc8cedad92"
+  resolved "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz#e5211e9224369fbb81d633a2f00044dc8cedad92"
   integrity sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g==
 
 strip-bom@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
+  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
   integrity sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==
   dependencies:
     is-utf8 "^0.2.0"
 
 strip-bom@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
+  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
   integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==
 
 strip-final-newline@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
+  resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
   integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
 
 strip-indent@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
+  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
   integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
   dependencies:
     min-indent "^1.0.0"
 
 strip-indent@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-4.0.0.tgz#b41379433dd06f5eae805e21d631e07ee670d853"
+  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-4.0.0.tgz#b41379433dd06f5eae805e21d631e07ee670d853"
   integrity sha512-mnVSV2l+Zv6BLpSD/8V87CW/y9EmmbYzGCIavsnsI6/nwn26DwffM/yztm30Z/I2DY9wdS3vXVCMnHDgZaVNoA==
   dependencies:
     min-indent "^1.0.1"
 
 strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
+  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
 supports-color@^5.3.0:
   version "5.5.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
   integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
   dependencies:
     has-flag "^3.0.0"
 
 supports-color@^7.1.0:
   version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
   integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
   dependencies:
     has-flag "^4.0.0"
 
 supports-color@^8.0.0, supports-color@^8.1.1:
   version "8.1.1"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
   integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
   dependencies:
     has-flag "^4.0.0"
 
 supports-preserve-symlinks-flag@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
+  resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
   integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
 
 sver-compat@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.yarnpkg.com/sver-compat/-/sver-compat-1.5.0.tgz#3cf87dfeb4d07b4a3f14827bc186b3fd0c645cd8"
+  resolved "https://registry.npmjs.org/sver-compat/-/sver-compat-1.5.0.tgz#3cf87dfeb4d07b4a3f14827bc186b3fd0c645cd8"
   integrity sha512-aFTHfmjwizMNlNE6dsGmoAM4lHjL0CyiobWaFiXWSlD7cIxshW422Nb8KbXCmR6z+0ZEPY+daXJrDyh/vuwTyg==
   dependencies:
     es6-iterator "^2.0.1"
@@ -6494,7 +6670,7 @@ sver-compat@^1.5.0:
 
 table-layout@^3.0.0:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/table-layout/-/table-layout-3.0.2.tgz#69c2be44388a5139b48c59cf21e73b488021769a"
+  resolved "https://registry.npmjs.org/table-layout/-/table-layout-3.0.2.tgz#69c2be44388a5139b48c59cf21e73b488021769a"
   integrity sha512-rpyNZYRw+/C+dYkcQ3Pr+rLxW4CfHpXjPDnG7lYhdRoUcZTUt+KEsX+94RGp/aVp/MQU35JCITv2T/beY4m+hw==
   dependencies:
     "@75lb/deep-merge" "^1.1.1"
@@ -6507,19 +6683,19 @@ table-layout@^3.0.0:
 
 tapable@^2.1.1, tapable@^2.2.0:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
+  resolved "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
   integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
 
 teex@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/teex/-/teex-1.0.1.tgz#b8fa7245ef8e8effa8078281946c85ab780a0b12"
+  resolved "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz#b8fa7245ef8e8effa8078281946c85ab780a0b12"
   integrity sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==
   dependencies:
     streamx "^2.12.5"
 
 terser-webpack-plugin@^5.3.7:
   version "5.3.9"
-  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz#832536999c51b46d468067f9e37662a3b96adfe1"
+  resolved "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz#832536999c51b46d468067f9e37662a3b96adfe1"
   integrity sha512-ZuXsqE07EcggTWQjXUj+Aot/OMcD0bMKGgF63f7UxYcu5/AJF53aIpK1YoP5xR9l6s/Hy2b+t1AM0bLNPRuhwA==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.17"
@@ -6529,9 +6705,9 @@ terser-webpack-plugin@^5.3.7:
     terser "^5.16.8"
 
 terser@^5.16.8, terser@^5.9.0:
-  version "5.17.7"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.17.7.tgz#2a8b134826fe179b711969fd9d9a0c2479b2a8c3"
-  integrity sha512-/bi0Zm2C6VAexlGgLlVxA0P2lru/sdLyfCVaRMfKVo9nWxbmz7f/sD8VPybPeSUJaJcwmCJis9pBIhcVcG1QcQ==
+  version "5.19.4"
+  resolved "https://registry.npmjs.org/terser/-/terser-5.19.4.tgz#941426fa482bf9b40a0308ab2b3cd0cf7c775ebd"
+  integrity sha512-6p1DjHeuluwxDXcuT9VR8p64klWJKo1ILiy19s6C9+0Bh2+NWTX6nD9EPppiER4ICkHDVB1RkVpin/YW2nQn/g==
   dependencies:
     "@jridgewell/source-map" "^0.3.3"
     acorn "^8.8.2"
@@ -6540,7 +6716,7 @@ terser@^5.16.8, terser@^5.9.0:
 
 test-exclude@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e"
+  resolved "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e"
   integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==
   dependencies:
     "@istanbuljs/schema" "^0.1.2"
@@ -6549,22 +6725,22 @@ test-exclude@^6.0.0:
 
 text-table@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
+  resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
   integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==
 
 textextensions@^3.2.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/textextensions/-/textextensions-3.3.0.tgz#03530d5287b86773c08b77458589148870cc71d3"
+  resolved "https://registry.npmjs.org/textextensions/-/textextensions-3.3.0.tgz#03530d5287b86773c08b77458589148870cc71d3"
   integrity sha512-mk82dS8eRABNbeVJrEiN5/UMSCliINAuz8mkUwH4SwslkNP//gbEzlWNS5au0z5Dpx40SQxzqZevZkn+WYJ9Dw==
 
 thingies@^1.11.1:
   version "1.12.0"
-  resolved "https://registry.yarnpkg.com/thingies/-/thingies-1.12.0.tgz#a815c224482d607aa70f563d3cbb351a338e4710"
+  resolved "https://registry.npmjs.org/thingies/-/thingies-1.12.0.tgz#a815c224482d607aa70f563d3cbb351a338e4710"
   integrity sha512-AiGqfYC1jLmJagbzQGuoZRM48JPsr9yB734a7K6wzr34NMhjUPrWSQrkF7ZBybf3yCerCL2Gcr02kMv4NmaZfA==
 
 through2-filter@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/through2-filter/-/through2-filter-3.0.0.tgz#700e786df2367c2c88cd8aa5be4cf9c1e7831254"
+  resolved "https://registry.npmjs.org/through2-filter/-/through2-filter-3.0.0.tgz#700e786df2367c2c88cd8aa5be4cf9c1e7831254"
   integrity sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==
   dependencies:
     through2 "~2.0.0"
@@ -6572,7 +6748,7 @@ through2-filter@^3.0.0:
 
 through2@^2.0.0, through2@^2.0.3, through2@~2.0.0:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
+  resolved "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
   integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
   dependencies:
     readable-stream "~2.3.6"
@@ -6580,7 +6756,7 @@ through2@^2.0.0, through2@^2.0.3, through2@~2.0.0:
 
 through2@^3.0.0, through2@^3.0.1:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-3.0.2.tgz#99f88931cfc761ec7678b41d5d7336b5b6a07bf4"
+  resolved "https://registry.npmjs.org/through2/-/through2-3.0.2.tgz#99f88931cfc761ec7678b41d5d7336b5b6a07bf4"
   integrity sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==
   dependencies:
     inherits "^2.0.4"
@@ -6588,24 +6764,24 @@ through2@^3.0.0, through2@^3.0.1:
 
 through2@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764"
+  resolved "https://registry.npmjs.org/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764"
   integrity sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==
   dependencies:
     readable-stream "3"
 
 through@^2.3.6, through@^2.3.8:
   version "2.3.8"
-  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
+  resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==
 
 time-stamp@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/time-stamp/-/time-stamp-1.1.0.tgz#764a5a11af50561921b133f3b44e618687e0f5c3"
+  resolved "https://registry.npmjs.org/time-stamp/-/time-stamp-1.1.0.tgz#764a5a11af50561921b133f3b44e618687e0f5c3"
   integrity sha512-gLCeArryy2yNTRzTGKbZbloctj64jkZ57hj5zdraXue6aFgd6PmvVtEyiUU+hvU0v7q08oVv8r8ev0tRo6bvgw==
 
 timers-ext@^0.1.7:
   version "0.1.7"
-  resolved "https://registry.yarnpkg.com/timers-ext/-/timers-ext-0.1.7.tgz#6f57ad8578e07a3fb9f91d9387d65647555e25c6"
+  resolved "https://registry.npmjs.org/timers-ext/-/timers-ext-0.1.7.tgz#6f57ad8578e07a3fb9f91d9387d65647555e25c6"
   integrity sha512-b85NUNzTSdodShTIbky6ZF02e8STtVVfD+fu4aXXShEELpozH+bCpJLYMPZbsABN2wDH7fJpqIoXxJpzbf0NqQ==
   dependencies:
     es5-ext "~0.10.46"
@@ -6613,12 +6789,12 @@ timers-ext@^0.1.7:
 
 tmpl@1.0.5:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc"
+  resolved "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc"
   integrity sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==
 
 to-absolute-glob@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz#1865f43d9e74b0822db9f145b78cff7d0f7c849b"
+  resolved "https://registry.npmjs.org/to-absolute-glob/-/to-absolute-glob-2.0.2.tgz#1865f43d9e74b0822db9f145b78cff7d0f7c849b"
   integrity sha512-rtwLUQEwT8ZeKQbyFJyomBRYXyE16U5VKuy0ftxLMK/PZb2fkOsg5r9kHdauuVDbsNdIBoC/HCthpidamQFXYA==
   dependencies:
     is-absolute "^1.0.0"
@@ -6626,19 +6802,19 @@ to-absolute-glob@^2.0.0:
 
 to-fast-properties@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
+  resolved "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
   integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==
 
 to-object-path@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
+  resolved "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
   integrity sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg==
   dependencies:
     kind-of "^3.0.2"
 
 to-regex-range@^2.1.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
   integrity sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg==
   dependencies:
     is-number "^3.0.0"
@@ -6646,14 +6822,14 @@ to-regex-range@^2.1.0:
 
 to-regex-range@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
   integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
   dependencies:
     is-number "^7.0.0"
 
 to-regex@^3.0.1, to-regex@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
+  resolved "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
   integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
   dependencies:
     define-property "^2.0.2"
@@ -6663,24 +6839,24 @@ to-regex@^3.0.1, to-regex@^3.0.2:
 
 to-through@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-through/-/to-through-2.0.0.tgz#fc92adaba072647bc0b67d6b03664aa195093af6"
+  resolved "https://registry.npmjs.org/to-through/-/to-through-2.0.0.tgz#fc92adaba072647bc0b67d6b03664aa195093af6"
   integrity sha512-+QIz37Ly7acM4EMdw2PRN389OneM5+d844tirkGp4dPKzI5OE72V9OsbFp+CIYJDahZ41ZV05hNtcPAQUAm9/Q==
   dependencies:
     through2 "^2.0.3"
 
 totalist@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/totalist/-/totalist-3.0.1.tgz#ba3a3d600c915b1a97872348f79c127475f6acf8"
+  resolved "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz#ba3a3d600c915b1a97872348f79c127475f6acf8"
   integrity sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==
 
 trim-newlines@^4.0.2:
   version "4.1.1"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-4.1.1.tgz#28c88deb50ed10c7ba6dc2474421904a00139125"
+  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-4.1.1.tgz#28c88deb50ed10c7ba6dc2474421904a00139125"
   integrity sha512-jRKj0n0jXWo6kh62nA5TEh3+4igKDXLvzBJcPpiizP7oOolUrYIxmVBG9TOtHYFHoddUk6YvAkGeGoSVTXfQXQ==
 
 ts-jest@29.1.1:
   version "29.1.1"
-  resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-29.1.1.tgz#f58fe62c63caf7bfcc5cc6472082f79180f0815b"
+  resolved "https://registry.npmjs.org/ts-jest/-/ts-jest-29.1.1.tgz#f58fe62c63caf7bfcc5cc6472082f79180f0815b"
   integrity sha512-D6xjnnbP17cC85nliwGiL+tpoKN0StpgE0TeOjXQTU6MVCfsB4v7aW05CgQ/1OywGb0x/oy9hHFnN+sczTiRaA==
   dependencies:
     bs-logger "0.x"
@@ -6694,7 +6870,7 @@ ts-jest@29.1.1:
 
 ts-node@10.9.1:
   version "10.9.1"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.1.tgz#e73de9102958af9e1f0b168a6ff320e25adcff4b"
+  resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz#e73de9102958af9e1f0b168a6ff320e25adcff4b"
   integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==
   dependencies:
     "@cspotcode/source-map-support" "^0.8.0"
@@ -6713,76 +6889,76 @@ ts-node@10.9.1:
 
 tslib@^1.8.1:
   version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
   integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
 
-tslib@^2.1.0, tslib@^2.3.0, tslib@^2.5.3:
-  version "2.5.3"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.3.tgz#24944ba2d990940e6e982c4bea147aba80209913"
-  integrity sha512-mSxlJJwl3BMEQCUNnxXBU9jP4JBktcEGhURcPR6VQVlnP0FdDEsIaz0C35dXNGLyRfrATNofF0F5p2KPxQgB+w==
+tslib@^2.1.0, tslib@^2.3.0, tslib@^2.4.0, tslib@^2.6.2:
+  version "2.6.2"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz#703ac29425e7b37cd6fd456e92404d46d1f3e4ae"
+  integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==
 
 tsutils@^3.21.0:
   version "3.21.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
+  resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
   integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
   dependencies:
     tslib "^1.8.1"
 
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
+  resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
   integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
   dependencies:
     prelude-ls "^1.2.1"
 
 type-detect@4.0.8:
   version "4.0.8"
-  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
+  resolved "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
   integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==
 
 type-fest@^0.20.2:
   version "0.20.2"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
   integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
 
 type-fest@^0.21.3:
   version "0.21.3"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
   integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
 
 type-fest@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
   integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==
 
 type-fest@^0.8.1:
   version "0.8.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
   integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
 
 type-fest@^1.0.1, type-fest@^1.2.1, type-fest@^1.2.2:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-1.4.0.tgz#e9fb813fe3bf1744ec359d55d1affefa76f14be1"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz#e9fb813fe3bf1744ec359d55d1affefa76f14be1"
   integrity sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==
 
 type@^1.0.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/type/-/type-1.2.0.tgz#848dd7698dafa3e54a6c479e759c4bc3f18847a0"
+  resolved "https://registry.npmjs.org/type/-/type-1.2.0.tgz#848dd7698dafa3e54a6c479e759c4bc3f18847a0"
   integrity sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==
 
 type@^2.7.2:
   version "2.7.2"
-  resolved "https://registry.yarnpkg.com/type/-/type-2.7.2.tgz#2376a15a3a28b1efa0f5350dcf72d24df6ef98d0"
+  resolved "https://registry.npmjs.org/type/-/type-2.7.2.tgz#2376a15a3a28b1efa0f5350dcf72d24df6ef98d0"
   integrity sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==
 
 typedarray@^0.0.6:
   version "0.0.6"
-  resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
+  resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==
 
 typedoc@0.24.8:
   version "0.24.8"
-  resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.24.8.tgz#cce9f47ba6a8d52389f5e583716a2b3b4335b63e"
+  resolved "https://registry.npmjs.org/typedoc/-/typedoc-0.24.8.tgz#cce9f47ba6a8d52389f5e583716a2b3b4335b63e"
   integrity sha512-ahJ6Cpcvxwaxfu4KtjA8qZNqS43wYt6JL27wYiIgl1vd38WW/KWX11YuAeZhuz9v+ttrutSsgK+XO1CjL1kA3w==
   dependencies:
     lunr "^2.3.9"
@@ -6792,32 +6968,32 @@ typedoc@0.24.8:
 
 typescript@5.1.3:
   version "5.1.3"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.1.3.tgz#8d84219244a6b40b6fb2b33cc1c062f715b9e826"
+  resolved "https://registry.npmjs.org/typescript/-/typescript-5.1.3.tgz#8d84219244a6b40b6fb2b33cc1c062f715b9e826"
   integrity sha512-XH627E9vkeqhlZFQuL+UsyAXEnibT0kWR2FWONlr4sTjvxyJYnyefgrkyECLzM5NenmKzRAy2rR/OlYLA1HkZw==
 
 typical@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/typical/-/typical-4.0.0.tgz#cbeaff3b9d7ae1e2bbfaf5a4e6f11eccfde94fc4"
+  resolved "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz#cbeaff3b9d7ae1e2bbfaf5a4e6f11eccfde94fc4"
   integrity sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==
 
 typical@^7.1.1:
   version "7.1.1"
-  resolved "https://registry.yarnpkg.com/typical/-/typical-7.1.1.tgz#ba177ab7ab103b78534463ffa4c0c9754523ac1f"
+  resolved "https://registry.npmjs.org/typical/-/typical-7.1.1.tgz#ba177ab7ab103b78534463ffa4c0c9754523ac1f"
   integrity sha512-T+tKVNs6Wu7IWiAce5BgMd7OZfNYUndHwc5MknN+UHOudi7sGZzuHdCadllRuqJ3fPtgFtIH9+lt9qRv6lmpfA==
 
 unc-path-regex@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/unc-path-regex/-/unc-path-regex-0.1.2.tgz#e73dd3d7b0d7c5ed86fbac6b0ae7d8c6a69d50fa"
+  resolved "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz#e73dd3d7b0d7c5ed86fbac6b0ae7d8c6a69d50fa"
   integrity sha512-eXL4nmJT7oCpkZsHZUOJo8hcX3GbsiDOa0Qu9F646fi8dT3XuSVopVqAcEiVzSKKH7UoDti23wNX3qGFxcW5Qg==
 
 undertaker-registry@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/undertaker-registry/-/undertaker-registry-1.0.1.tgz#5e4bda308e4a8a2ae584f9b9a4359a499825cc50"
+  resolved "https://registry.npmjs.org/undertaker-registry/-/undertaker-registry-1.0.1.tgz#5e4bda308e4a8a2ae584f9b9a4359a499825cc50"
   integrity sha512-UR1khWeAjugW3548EfQmL9Z7pGMlBgXteQpr1IZeZBtnkCJQJIJ1Scj0mb9wQaPvUZ9Q17XqW6TIaPchJkyfqw==
 
 undertaker@^1.2.1:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/undertaker/-/undertaker-1.3.0.tgz#363a6e541f27954d5791d6fa3c1d321666f86d18"
+  resolved "https://registry.npmjs.org/undertaker/-/undertaker-1.3.0.tgz#363a6e541f27954d5791d6fa3c1d321666f86d18"
   integrity sha512-/RXwi5m/Mu3H6IHQGww3GNt1PNXlbeCuclF2QYR14L/2CHPz3DFZkvB5hZ0N/QUkiXWCACML2jXViIQEQc2MLg==
   dependencies:
     arr-flatten "^1.0.1"
@@ -6833,7 +7009,7 @@ undertaker@^1.2.1:
 
 union-value@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
+  resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"
   integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==
   dependencies:
     arr-union "^3.1.0"
@@ -6843,7 +7019,7 @@ union-value@^1.0.0:
 
 unique-stream@^2.0.2:
   version "2.3.1"
-  resolved "https://registry.yarnpkg.com/unique-stream/-/unique-stream-2.3.1.tgz#c65d110e9a4adf9a6c5948b28053d9a8d04cbeac"
+  resolved "https://registry.npmjs.org/unique-stream/-/unique-stream-2.3.1.tgz#c65d110e9a4adf9a6c5948b28053d9a8d04cbeac"
   integrity sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==
   dependencies:
     json-stable-stringify-without-jsonify "^1.0.1"
@@ -6851,12 +7027,12 @@ unique-stream@^2.0.2:
 
 universalify@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
+  resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
   integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
 
 unset-value@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
+  resolved "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
   integrity sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ==
   dependencies:
     has-value "^0.3.1"
@@ -6864,12 +7040,12 @@ unset-value@^1.0.0:
 
 upath@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894"
+  resolved "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz#8f66dbcd55a883acdae4408af8b035a5044c1894"
   integrity sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==
 
 update-browserslist-db@^1.0.11:
   version "1.0.11"
-  resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz#9a2a641ad2907ae7b3616506f4b977851db5b940"
+  resolved "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.0.11.tgz#9a2a641ad2907ae7b3616506f4b977851db5b940"
   integrity sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA==
   dependencies:
     escalade "^3.1.1"
@@ -6877,34 +7053,34 @@ update-browserslist-db@^1.0.11:
 
 uri-js@^4.2.2:
   version "4.4.1"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
+  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
   integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
   dependencies:
     punycode "^2.1.0"
 
 urix@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
+  resolved "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
   integrity sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg==
 
 use@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
+  resolved "https://registry.npmjs.org/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
   integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
 
 util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==
 
 v8-compile-cache-lib@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
+  resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
   integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
 
 v8-to-istanbul@^9.0.1:
   version "9.1.0"
-  resolved "https://registry.yarnpkg.com/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz#1b83ed4e397f58c85c266a570fc2558b5feb9265"
+  resolved "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-9.1.0.tgz#1b83ed4e397f58c85c266a570fc2558b5feb9265"
   integrity sha512-6z3GW9x8G1gd+JIIgQQQxXuiJtCXeAjp6RaPEPLv62mH3iPHPxV6W3robxtCzNErRo6ZwTmzWhsbNvjyEBKzKA==
   dependencies:
     "@jridgewell/trace-mapping" "^0.3.12"
@@ -6913,14 +7089,14 @@ v8-to-istanbul@^9.0.1:
 
 v8flags@^3.2.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/v8flags/-/v8flags-3.2.0.tgz#b243e3b4dfd731fa774e7492128109a0fe66d656"
+  resolved "https://registry.npmjs.org/v8flags/-/v8flags-3.2.0.tgz#b243e3b4dfd731fa774e7492128109a0fe66d656"
   integrity sha512-mH8etigqMfiGWdeXpaaqGfs6BndypxusHHcv2qSHyZkGEznCd/qAXCWWRzeowtL54147cktFOC4P5y+kl8d8Jg==
   dependencies:
     homedir-polyfill "^1.0.1"
 
 validate-npm-package-license@^3.0.1:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
+  resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
   dependencies:
     spdx-correct "^3.0.0"
@@ -6928,12 +7104,12 @@ validate-npm-package-license@^3.0.1:
 
 value-or-function@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/value-or-function/-/value-or-function-3.0.0.tgz#1c243a50b595c1be54a754bfece8563b9ff8d813"
+  resolved "https://registry.npmjs.org/value-or-function/-/value-or-function-3.0.0.tgz#1c243a50b595c1be54a754bfece8563b9ff8d813"
   integrity sha512-jdBB2FrWvQC/pnPtIqcLsMaQgjhdb6B7tk1MMyTKapox+tQZbdRP4uLxu/JY0t7fbfDCUMnuelzEYv5GsxHhdg==
 
 vinyl-buffer@1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/vinyl-buffer/-/vinyl-buffer-1.0.1.tgz#96c1a3479b8c5392542c612029013b5b27f88bbf"
+  resolved "https://registry.npmjs.org/vinyl-buffer/-/vinyl-buffer-1.0.1.tgz#96c1a3479b8c5392542c612029013b5b27f88bbf"
   integrity sha512-LRBE2/g3C1hSHL2k/FynSZcVTRhEw8sb08oKGt/0hukZXwrh2m8nfy+r5yLhGEk7eFFuclhyIuPct/Bxlxk6rg==
   dependencies:
     bl "^1.2.1"
@@ -6941,7 +7117,7 @@ vinyl-buffer@1.0.1:
 
 vinyl-fs@^3.0.0, vinyl-fs@^3.0.3:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/vinyl-fs/-/vinyl-fs-3.0.3.tgz#c85849405f67428feabbbd5c5dbdd64f47d31bc7"
+  resolved "https://registry.npmjs.org/vinyl-fs/-/vinyl-fs-3.0.3.tgz#c85849405f67428feabbbd5c5dbdd64f47d31bc7"
   integrity sha512-vIu34EkyNyJxmP0jscNzWBSygh7VWhqun6RmqVfXePrOwi9lhvRs//dOaGOTRUQr4tx7/zd26Tk5WeSVZitgng==
   dependencies:
     fs-mkdirp-stream "^1.0.0"
@@ -6964,14 +7140,14 @@ vinyl-fs@^3.0.0, vinyl-fs@^3.0.3:
 
 vinyl-named@1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/vinyl-named/-/vinyl-named-1.1.0.tgz#94e4fe741e38db0ec303e5b3d868b297a2deab66"
+  resolved "https://registry.npmjs.org/vinyl-named/-/vinyl-named-1.1.0.tgz#94e4fe741e38db0ec303e5b3d868b297a2deab66"
   integrity sha512-ElYBnsSw8Y1Hz11WPw0DFmi+TBNTEBhZ9zXaHluDSIZZnkFIGCjGRBpsW5QmbMMLwv+lRpUD3VbKdJCbNpct7Q==
   dependencies:
     through "^2.3.6"
 
 vinyl-source-stream@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/vinyl-source-stream/-/vinyl-source-stream-2.0.0.tgz#f38a5afb9dd1e93b65d550469ac6182ac4f54b8e"
+  resolved "https://registry.npmjs.org/vinyl-source-stream/-/vinyl-source-stream-2.0.0.tgz#f38a5afb9dd1e93b65d550469ac6182ac4f54b8e"
   integrity sha512-Y5f1wRGajOfYukhv8biIGA7iZiY8UOIc3zJ6zcUNIbRG1BVuXzBsfSfe7MUJTttVkuy64k/pGQtJdd/aIt+hbw==
   dependencies:
     through2 "^2.0.3"
@@ -6979,7 +7155,7 @@ vinyl-source-stream@2.0.0:
 
 vinyl-sourcemap@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz#92a800593a38703a8cdb11d8b300ad4be63b3e16"
+  resolved "https://registry.npmjs.org/vinyl-sourcemap/-/vinyl-sourcemap-1.1.0.tgz#92a800593a38703a8cdb11d8b300ad4be63b3e16"
   integrity sha512-NiibMgt6VJGJmyw7vtzhctDcfKch4e4n9TBeoWlirb7FMg9/1Ov9k+A5ZRAtywBpRPiyECvQRQllYM8dECegVA==
   dependencies:
     append-buffer "^1.0.2"
@@ -6992,14 +7168,14 @@ vinyl-sourcemap@^1.1.0:
 
 vinyl-sourcemaps-apply@^0.2.0, vinyl-sourcemaps-apply@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz#ab6549d61d172c2b1b87be5c508d239c8ef87705"
+  resolved "https://registry.npmjs.org/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz#ab6549d61d172c2b1b87be5c508d239c8ef87705"
   integrity sha512-+oDh3KYZBoZC8hfocrbrxbLUeaYtQK7J5WU5Br9VqWqmCll3tFJqKp97GC9GmMsVIL0qnx2DgEDVxdo5EZ5sSw==
   dependencies:
     source-map "^0.5.1"
 
 vinyl@2.x, vinyl@^2.0.0, vinyl@^2.1.0, vinyl@^2.2.1:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-2.2.1.tgz#23cfb8bbab5ece3803aa2c0a1eb28af7cbba1974"
+  resolved "https://registry.npmjs.org/vinyl/-/vinyl-2.2.1.tgz#23cfb8bbab5ece3803aa2c0a1eb28af7cbba1974"
   integrity sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==
   dependencies:
     clone "^2.1.1"
@@ -7011,7 +7187,7 @@ vinyl@2.x, vinyl@^2.0.0, vinyl@^2.1.0, vinyl@^2.2.1:
 
 vinyl@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-3.0.0.tgz#11e14732bf56e2faa98ffde5157fe6c13259ff30"
+  resolved "https://registry.npmjs.org/vinyl/-/vinyl-3.0.0.tgz#11e14732bf56e2faa98ffde5157fe6c13259ff30"
   integrity sha512-rC2VRfAVVCGEgjnxHUnpIVh3AGuk62rP3tqVrn+yab0YH7UULisC085+NYH+mnqf3Wx4SpSi1RQMwudL89N03g==
   dependencies:
     clone "^2.1.2"
@@ -7022,24 +7198,24 @@ vinyl@^3.0.0:
 
 vscode-oniguruma@^1.7.0:
   version "1.7.0"
-  resolved "https://registry.yarnpkg.com/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz#439bfad8fe71abd7798338d1cd3dc53a8beea94b"
+  resolved "https://registry.npmjs.org/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz#439bfad8fe71abd7798338d1cd3dc53a8beea94b"
   integrity sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==
 
 vscode-textmate@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-8.0.0.tgz#2c7a3b1163ef0441097e0b5d6389cd5504b59e5d"
+  resolved "https://registry.npmjs.org/vscode-textmate/-/vscode-textmate-8.0.0.tgz#2c7a3b1163ef0441097e0b5d6389cd5504b59e5d"
   integrity sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==
 
 walker@^1.0.8:
   version "1.0.8"
-  resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f"
+  resolved "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f"
   integrity sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==
   dependencies:
     makeerror "1.0.12"
 
 watchpack@^2.4.0:
   version "2.4.0"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.4.0.tgz#fa33032374962c78113f93c7f2fb4c54c9862a5d"
+  resolved "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz#fa33032374962c78113f93c7f2fb4c54c9862a5d"
   integrity sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==
   dependencies:
     glob-to-regexp "^0.4.1"
@@ -7047,12 +7223,12 @@ watchpack@^2.4.0:
 
 web-streams-polyfill@3.2.1:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz#71c2718c52b45fd49dbeee88634b3a60ceab42a6"
+  resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz#71c2718c52b45fd49dbeee88634b3a60ceab42a6"
   integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==
 
 webpack-bundle-analyzer@4.9.1:
   version "4.9.1"
-  resolved "https://registry.yarnpkg.com/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.9.1.tgz#d00bbf3f17500c10985084f22f1a2bf45cb2f09d"
+  resolved "https://registry.npmjs.org/webpack-bundle-analyzer/-/webpack-bundle-analyzer-4.9.1.tgz#d00bbf3f17500c10985084f22f1a2bf45cb2f09d"
   integrity sha512-jnd6EoYrf9yMxCyYDPj8eutJvtjQNp8PHmni/e/ulydHBWhT5J3menXt3HEkScsu9YqMAcG4CfFjs3rj5pVU1w==
   dependencies:
     "@discoveryjs/json-ext" "0.5.7"
@@ -7075,12 +7251,12 @@ webpack-bundle-analyzer@4.9.1:
 
 webpack-sources@^3.2.3:
   version "3.2.3"
-  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde"
+  resolved "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde"
   integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
 
 webpack-stream@7.0.0:
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/webpack-stream/-/webpack-stream-7.0.0.tgz#e6a1edb9568198499af872678e95031752d72f00"
+  resolved "https://registry.npmjs.org/webpack-stream/-/webpack-stream-7.0.0.tgz#e6a1edb9568198499af872678e95031752d72f00"
   integrity sha512-XoAQTHyCaYMo6TS7Atv1HYhtmBgKiVLONJbzLBl2V3eibXQ2IT/MCRM841RW/r3vToKD5ivrTJFWgd/ghoxoRg==
   dependencies:
     fancy-log "^1.3.3"
@@ -7094,7 +7270,7 @@ webpack-stream@7.0.0:
 
 webpack@5.86.0:
   version "5.86.0"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.86.0.tgz#b0eb81794b62aee0b7e7eb8c5073495217d9fc6d"
+  resolved "https://registry.npmjs.org/webpack/-/webpack-5.86.0.tgz#b0eb81794b62aee0b7e7eb8c5073495217d9fc6d"
   integrity sha512-3BOvworZ8SO/D4GVP+GoRC3fVeg5MO4vzmq8TJJEkdmopxyazGDxN8ClqN12uzrZW9Tv8EED8v5VSb6Sqyi0pg==
   dependencies:
     "@types/eslint-scope" "^3.7.3"
@@ -7124,37 +7300,32 @@ webpack@5.86.0:
 
 which-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/which-module/-/which-module-1.0.0.tgz#bba63ca861948994ff307736089e3b96026c2a4f"
+  resolved "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz#bba63ca861948994ff307736089e3b96026c2a4f"
   integrity sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==
 
 which@^1.2.14:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
+  resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
   dependencies:
     isexe "^2.0.0"
 
 which@^2.0.1:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
+  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
   dependencies:
     isexe "^2.0.0"
 
-word-wrap@^1.2.3:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.4.tgz#cb4b50ec9aca570abd1f52f33cd45b6c61739a9f"
-  integrity sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==
-
 wordwrapjs@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/wordwrapjs/-/wordwrapjs-5.1.0.tgz#4c4d20446dcc670b14fa115ef4f8fd9947af2b3a"
+  resolved "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-5.1.0.tgz#4c4d20446dcc670b14fa115ef4f8fd9947af2b3a"
   integrity sha512-JNjcULU2e4KJwUNv6CHgI46UvDGitb6dGryHajXTDiLgg1/RiGoPSDw4kZfYnwGtEXf2ZMeIewDQgFGzkCB2Sg==
 
 "wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
   name wrap-ansi-cjs
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
   dependencies:
     ansi-styles "^4.0.0"
@@ -7163,7 +7334,7 @@ wordwrapjs@^5.1.0:
 
 wrap-ansi@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz#d8fc3d284dd05794fe84973caecdd1cf824fdd85"
   integrity sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==
   dependencies:
     string-width "^1.0.1"
@@ -7171,7 +7342,7 @@ wrap-ansi@^2.0.0:
 
 wrap-ansi@^6.2.0:
   version "6.2.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
   integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
   dependencies:
     ansi-styles "^4.0.0"
@@ -7180,7 +7351,7 @@ wrap-ansi@^6.2.0:
 
 wrap-ansi@^8.1.0:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"
   integrity sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==
   dependencies:
     ansi-styles "^6.1.0"
@@ -7189,12 +7360,12 @@ wrap-ansi@^8.1.0:
 
 wrappy@1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==
 
 write-file-atomic@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/write-file-atomic/-/write-file-atomic-4.0.2.tgz#a9df01ae5b77858a027fd2e80768ee433555fcfd"
+  resolved "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-4.0.2.tgz#a9df01ae5b77858a027fd2e80768ee433555fcfd"
   integrity sha512-7KxauUdBmSdWnmpaGFg+ppNjKF8uNLry8LyzjauQDOVONfFLNKrKvQOxZ/VuTIcS/gge/YNahf5RIIQWTSarlg==
   dependencies:
     imurmurhash "^0.1.4"
@@ -7202,12 +7373,12 @@ write-file-atomic@^4.0.2:
 
 ws@^7.3.1:
   version "7.5.9"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
+  resolved "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
   integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
 
 xml2js@0.6.2:
   version "0.6.2"
-  resolved "https://registry.yarnpkg.com/xml2js/-/xml2js-0.6.2.tgz#dd0b630083aa09c161e25a4d0901e2b2a929b499"
+  resolved "https://registry.npmjs.org/xml2js/-/xml2js-0.6.2.tgz#dd0b630083aa09c161e25a4d0901e2b2a929b499"
   integrity sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==
   dependencies:
     sax ">=0.6.0"
@@ -7215,47 +7386,47 @@ xml2js@0.6.2:
 
 xmlbuilder@~11.0.0:
   version "11.0.1"
-  resolved "https://registry.yarnpkg.com/xmlbuilder/-/xmlbuilder-11.0.1.tgz#be9bae1c8a046e76b31127726347d0ad7002beb3"
+  resolved "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz#be9bae1c8a046e76b31127726347d0ad7002beb3"
   integrity sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==
 
 xtend@~4.0.0, xtend@~4.0.1:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
+  resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
   integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
 
 y18n@^3.2.1:
   version "3.2.2"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-3.2.2.tgz#85c901bd6470ce71fc4bb723ad209b70f7f28696"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-3.2.2.tgz#85c901bd6470ce71fc4bb723ad209b70f7f28696"
   integrity sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==
 
 y18n@^5.0.5:
   version "5.0.8"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
   integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
 
 yallist@^3.0.2:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
+  resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz#dbb7daf9bfd8bac9ab45ebf602b8cbad0d5d08fd"
   integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==
 
 yallist@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
+  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
 yargs-parser@>=5.0.0-security.0, yargs-parser@^21.0.1, yargs-parser@^21.1.1:
   version "21.1.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
   integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
 
 yargs-parser@^20.2.9:
   version "20.2.9"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
   integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
 
 yargs-parser@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-5.0.1.tgz#7ede329c1d8cdbbe209bd25cdb990e9b1ebbb394"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.1.tgz#7ede329c1d8cdbbe209bd25cdb990e9b1ebbb394"
   integrity sha512-wpav5XYiddjXxirPoCTUPbqM0PXvJ9hiBMvuJgInvo4/lAOTZzUprArw17q2O1P2+GHhbBr18/iQwjL5Z9BqfA==
   dependencies:
     camelcase "^3.0.0"
@@ -7263,7 +7434,7 @@ yargs-parser@^5.0.1:
 
 yargs@^17.3.1:
   version "17.7.2"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269"
   integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==
   dependencies:
     cliui "^8.0.1"
@@ -7276,7 +7447,7 @@ yargs@^17.3.1:
 
 yargs@^7.1.0:
   version "7.1.2"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-7.1.2.tgz#63a0a5d42143879fdbb30370741374e0641d55db"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-7.1.2.tgz#63a0a5d42143879fdbb30370741374e0641d55db"
   integrity sha512-ZEjj/dQYQy0Zx0lgLMLR8QuaqTihnxirir7EwUHp1Axq4e3+k8jXU5K0VLbNvedv1f4EWtBonDIZm0NUr+jCcA==
   dependencies:
     camelcase "^3.0.0"
@@ -7295,10 +7466,10 @@ yargs@^7.1.0:
 
 yn@3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
   integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
 
 yocto-queue@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
+  resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==

From 0c329cd56e3c6a46b8d463da3fd5d3135ebc299a Mon Sep 17 00:00:00 2001
From: Ivan Chesnov <ivan.chesnov@dremio.com>
Date: Thu, 2 Nov 2023 19:26:26 +0200
Subject: [PATCH 669/749] GH-38537: [Java] upgrade to netty 4.1.100.Final
 (#38538)

### Rationale for this change
<img width="938" alt="Screenshot 2023-11-01 at 14 58 19" src="https://github.com/apache/arrow/assets/30110721/7bc749de-ddfc-48d5-a291-522506ceddf3">
<img width="911" alt="Screenshot 2023-11-01 at 14 58 36" src="https://github.com/apache/arrow/assets/30110721/74973933-0caa-4ab3-926b-993adce57403">

### What changes are included in this PR?

new version of netty.

### Are these changes tested?

### Are there any user-facing changes?
no

* Closes: #38537

Authored-by: Ivan Chesnov <ivan.chesnov@dremio.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java/pom.xml b/java/pom.xml
index 6d1ef51380b7a..2a9997b7012b7 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -33,7 +33,7 @@
     <dep.junit.jupiter.version>5.9.0</dep.junit.jupiter.version>
     <dep.slf4j.version>1.7.25</dep.slf4j.version>
     <dep.guava-bom.version>31.1-jre</dep.guava-bom.version>
-    <dep.netty-bom.version>4.1.96.Final</dep.netty-bom.version>
+    <dep.netty-bom.version>4.1.100.Final</dep.netty-bom.version>
     <dep.grpc-bom.version>1.56.0</dep.grpc-bom.version>
     <dep.protobuf-bom.version>3.23.1</dep.protobuf-bom.version>
     <dep.jackson-bom.version>2.15.1</dep.jackson-bom.version>

From 4fa7f03859b9c5a22fd1434e4516043476d3b6e2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Fri, 3 Nov 2023 03:19:59 +0900
Subject: [PATCH 670/749] GH-38554: [Release][Website] post-03-website.sh
 doesn't quote current.date (#38555)

### Rationale for this change

We should not quote the value to process the value as a date value.

### What changes are included in this PR?

Remove needless quotation.

### Are these changes tested?

No.

### Are there any user-facing changes?

No.
* Closes: #38554

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 dev/release/post-03-website.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev/release/post-03-website.sh b/dev/release/post-03-website.sh
index cb605aee83523..83dc157b346e5 100755
--- a/dev/release/post-03-website.sh
+++ b/dev/release/post-03-website.sh
@@ -258,7 +258,7 @@ current:
   number: '${version}'
   pinned_number: '${pinned_version}'
   major_number: '${major_version}'
-  date: '${release_date_iso8601}'
+  date: ${release_date_iso8601}
   git-tag: '${git_tag_hash}'
   github-tag-link: 'https://github.com/apache/arrow/releases/tag/${git_tag}'
   release-notes: 'https://arrow.apache.org/release/${version}.html'

From 56edb2d0f6b4a4a1689f5dbac9df1bb9a5274f2e Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 2 Nov 2023 15:23:33 -0400
Subject: [PATCH 671/749] GH-38417: [MATLAB] Implement a `TableTypeValidator`
 class that validates a MATLAB `cell` array contains only `table`s that share
 the same schema (#38551)

### Rationale for this change

This is a followup to #38533.

Adding this `TableValidator` class is a step towards implementing the `arrow.array.ListArray.fromMATLAB` method for creating `ListArray`s whose `ValueType` is a `StructArray`.

This validator will ensure all `table`s in a `cell` array have the same schema when attempting to make a `ListArray` of `Struct`s. This is a requirement to ensure the `table`s in the `cell` array are vertcat'ble. For example, two `table`s with different `VariableNames` cannot be concatenated together:

```matlab
>> t1 = table(1, 2, VariableNames=["A", "B"]);
>> t2 = table(3, 4, VariableNames=["C", "D"]);
>> vertcat(t1, t2)
Error using tabular/vertcat
All tables being vertically concatenated must have the same variable names.
```

### What changes are included in this PR?

Modified `arrow.array.internal.list.Validator` to inherit from `matlab.mixin.Heterogeneous`. Doing so enables creating an array whose elements are different subclasses of `arrow.array.internal.list.Validator`.

Added a new MATLAB class `arrow.array.internal.list.TableValidator`, which inherits from `arrow.array.internal.list.Validator`. This class has two properties: `VariableNames` and `VariableValidators`.

`VariableNames` is a `string` array containing the expected variable names of all `table`s.

`VariableValidators` is an array of `arrow.array.internal.list.Validator`, in which each element represents one variable in a `table`. This array is used to validate `table` variables have the expected type and configuration.

`TableValidator`'s `validateElement` method uses both its `VariableNames` and `VariableValidator` properties to validate the input argument provided is a `table` with the expected schema. If not, it throws an error.

Lastly, I  added a gateway function called `arrow.array.internal.list.createValidator`, which creates the appropriate `Validator` subclass based on the input. If no such `Validator` exists, an error is thrown.

### Are these changes tested?

Yes. Added two new test classes: `tTableValidator.m` and `tCreateValidator.m`.

### Are there any user-facing changes?

No.

### Future Directions:

1. #38354
* Closes: #38417

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+array/+internal/+list/TableValidator.m   |  90 ++++++
 .../+arrow/+array/+internal/+list/Validator.m |   2 +-
 .../+array/+internal/+list/createValidator.m  |  42 +++
 .../test/arrow/array/list/tCreateValidator.m  | 131 ++++++++
 .../test/arrow/array/list/tTableValidator.m   | 286 ++++++++++++++++++
 5 files changed, 550 insertions(+), 1 deletion(-)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/TableValidator.m
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/createValidator.m
 create mode 100644 matlab/test/arrow/array/list/tCreateValidator.m
 create mode 100644 matlab/test/arrow/array/list/tTableValidator.m

diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/TableValidator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/TableValidator.m
new file mode 100644
index 0000000000000..d62be5fb31fdb
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/TableValidator.m
@@ -0,0 +1,90 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef TableValidator < arrow.array.internal.list.ClassTypeValidator
+
+    properties (GetAccess=public, SetAccess=private)
+        VariableNames string = string.empty(1, 0)
+        VariableValidators arrow.array.internal.list.Validator = arrow.array.internal.list.Validator.empty(1, 0) 
+    end
+
+    methods
+        function obj = TableValidator(T)
+            arguments
+                T table
+            end
+            
+            numVars = width(T);
+
+            if (numVars == 0)
+                error("arrow:array:list:TableWithZeroVariables", ...
+                    "Expected table to have at least one variable.");
+            end
+
+            obj@arrow.array.internal.list.ClassTypeValidator(table);
+            obj.VariableNames = string(T.Properties.VariableNames);
+            validators = cell([1 numVars]);
+            for ii = 1:numVars
+                validators{ii} = arrow.array.internal.list.createValidator(T.(ii));
+            end
+
+            obj.VariableValidators = [validators{:}];
+        end
+
+        function validateElement(obj, element)
+            % Verify element is a table
+            validateElement@arrow.array.internal.list.ClassTypeValidator(obj, element);
+            
+            % Validate element has the expected number of variables
+            numVars = numel(obj.VariableNames);
+            if width(element) ~= numVars
+                id = "arrow:array:list:NumVariablesMismatch";
+                msg = "Expected all tables in the cell array to have " + ...
+                    string(numVars) + " variables.";
+                error(id, msg);
+            end
+
+            % Validate element has the expected variable names
+            if ~all(obj.VariableNames == string(element.Properties.VariableNames))
+                id = "arrow:array:list:VariableNamesMismatch";
+                msg = "Expected all tables in the cell array to have the " + ...
+                    "same variable names.";
+                error(id, msg);
+            end
+
+            for ii=1:numVars
+                var = element.(ii);
+
+                % In order to concatenate tables together later, require
+                % all non-tabular variables to be columnar or empty.
+                if ~istable(var) && (~iscolumn(var) && ~isempty(var))
+                    id = "arrow:array:list:NonTabularVariablesMustBeColumnar";
+                    msg = "Expected all variables except for nested tables to be columnar.";
+                    error(id, msg);
+                end
+
+                obj.VariableValidators(ii).validateElement(var);
+            end
+        end
+
+        function length = getElementLength(~, element)
+            length = height(element);
+        end
+
+        function C = reshapeCellElements(~, C)
+            % NO-OP for cell array of tables
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
index 0178632bb6dd2..a8217f0afae67 100644
--- a/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/Validator.m
@@ -16,7 +16,7 @@
 % implied.  See the License for the specific language governing
 % permissions and limitations under the License.
 
-classdef Validator
+classdef Validator < matlab.mixin.Heterogeneous
 
     methods (Abstract)
         tf = validateElement(obj, element)
diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/createValidator.m b/matlab/src/matlab/+arrow/+array/+internal/+list/createValidator.m
new file mode 100644
index 0000000000000..856143f8e574f
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/createValidator.m
@@ -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.
+
+function validator = createValidator(data)
+    import arrow.array.internal.list.ClassTypeValidator
+    import arrow.array.internal.list.DatetimeValidator
+    import arrow.array.internal.list.TableValidator
+
+    if isnumeric(data)
+        validator = ClassTypeValidator(data);
+    elseif islogical(data)
+        validator = ClassTypeValidator(data);
+    elseif isduration(data)
+        validator = ClassTypeValidator(data);
+    elseif isstring(data)
+        validator = ClassTypeValidator(data);
+    elseif iscell(data)
+        validator = ClassTypeValidator(data);
+    elseif isdatetime(data)
+        validator = DatetimeValidator(data);
+    elseif istable(data)
+        validator = TableValidator(data);
+    else
+        errorID = "arrow:array:list:UnsupportedDataType";
+        msg = "Unable to create a ListArray from a cell array containing " + class(data) + " values.";
+        error(errorID, msg);
+    end
+
+end
+
diff --git a/matlab/test/arrow/array/list/tCreateValidator.m b/matlab/test/arrow/array/list/tCreateValidator.m
new file mode 100644
index 0000000000000..d95af334ae76a
--- /dev/null
+++ b/matlab/test/arrow/array/list/tCreateValidator.m
@@ -0,0 +1,131 @@
+%TCREATEVALIDATOR Unit tests for arrow.array.internal.list.createValidator.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tCreateValidator < matlab.unittest.TestCase
+
+    properties (TestParameter)
+        NumericTypes
+    end
+
+    methods (TestParameterDefinition, Static)
+        function NumericTypes = initializeNumericTypes()
+            NumericTypes = {"uint8", ...
+                            "uint16", ...
+                            "uint32", ...
+                            "uint64", ...
+                            "int8", ...
+                            "int16", ...
+                            "int32", ...
+                            "int64", ...
+                            "single", ...
+                            "double"};
+        end
+    end
+
+    methods (Test)
+        function TestNumericTypes(testCase, NumericTypes)
+            % Verify createValidator returns a ClassTypeValidator with the
+            % expected ClassName value when given a numeric array as input.
+            import arrow.array.internal.list.createValidator
+            data = cast(1, NumericTypes);
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.ClassName, NumericTypes);
+        end
+
+        function TestLogical(testCase)
+            % Verify createValidator returns a ClassTypeValidator whose
+            % ClassName property is set to "logical" when given a logical
+            % array as input.
+            import arrow.array.internal.list.createValidator
+            data = true;
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.ClassName, "logical");
+        end
+
+        function TestDuration(testCase)
+            % Verify createValidator returns a ClassTypeValidator whose
+            % ClassName property is set to "duration" when given a duration
+            % array as input.
+            import arrow.array.internal.list.createValidator
+            data = seconds(1);
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.ClassName, "duration");
+        end
+
+        function TestString(testCase)
+            % Verify createValidator returns a ClassTypeValidator whose
+            % ClassName property is set to "string" when given a string
+            % array as input.
+            import arrow.array.internal.list.createValidator
+            data = "Hello World";
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.ClassName, "string");
+        end
+
+        function TestCell(testCase)
+            % Verify createValidator returns a ClassTypeValidator whose
+            % ClassName property is set to "cell" when given a cell
+            % array as input.
+            import arrow.array.internal.list.createValidator
+            data = {"Hello World"};
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.ClassName, "cell");
+        end
+
+        function TestDatetime(testCase)
+            % Verify createValidator returns a DatetimeValidator when given
+            % a datetime array as input.
+            import arrow.array.internal.list.createValidator
+            data = datetime(2023, 10, 31);
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.DatetimeValidator");
+            testCase.verifyEqual(validator.ClassName, "datetime");
+            testCase.verifyEqual(validator.Zoned, false);
+        end
+
+        function TestTable(testCase)
+            % Verify createValidator returns a TableValidator when given
+            % a table as input.
+            import arrow.array.internal.list.createValidator
+            data = table(1, "A", VariableNames=["Number", "Letter"]);
+            validator = createValidator(data);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.TableValidator");
+            testCase.verifyEqual(validator.VariableNames, ["Number", "Letter"]);
+            testCase.verifyEqual(numel(validator.VariableValidators), 2);
+            testCase.verifyInstanceOf(validator.VariableValidators(1), "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.VariableValidators(1).ClassName, "double");
+            testCase.verifyInstanceOf(validator.VariableValidators(2), "arrow.array.internal.list.ClassTypeValidator");
+            testCase.verifyEqual(validator.VariableValidators(2).ClassName, "string");
+
+        end
+    
+        function UnsupportedDataTypeError(testCase)
+            % Verify createValidator throws an exception whose identifier
+            % is "arrow:array:list:UnsupportedDataType" when given an
+            % unsupported datatype as input.
+            import arrow.array.internal.list.createValidator
+            data = calyears(1);
+            fcn = @() createValidator(data);
+            testCase.verifyError(fcn, "arrow:array:list:UnsupportedDataType");
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/list/tTableValidator.m b/matlab/test/arrow/array/list/tTableValidator.m
new file mode 100644
index 0000000000000..b3aeac9b6728c
--- /dev/null
+++ b/matlab/test/arrow/array/list/tTableValidator.m
@@ -0,0 +1,286 @@
+%TTABLEVALIDATOR Unit tests for arrow.array.internal.list.TableValidator
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tTableValidator < matlab.unittest.TestCase
+    
+    properties (Constant)
+        BaseTable = table(1, "A", datetime(2023, 11, 1, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+    end
+
+    methods(Test)
+        function Smoke(testCase)
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            testCase.verifyInstanceOf(validator, "arrow.array.internal.list.TableValidator");
+        end
+
+        function TableWithZeroVariablesError(testCase)
+            % Verify the TableValidator constructor throws an exception
+            % whose identifier is "arrow:array:list:TableWithZeroVariables"
+            % if provided a table with zero variables.
+            import arrow.array.internal.list.TableValidator
+            
+            fcn = @() TableValidator(table);
+            testCase.verifyError(fcn, "arrow:array:list:TableWithZeroVariables");
+        end
+
+        function VariableNamesGetter(testCase)
+            % Verify the VariableNames property getter returns the
+            % expected string array.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            testCase.verifyEqual(validator.VariableNames, ["Number", "Letter", "Date"]);
+        end
+
+        function VariableNamesNoSetter(testCase)
+            % Verify the VariableNames property is not settable.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            fcn = @() setfield(validator, "VariableNames", ["A", "B", "C"]);
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function VariableValidatorsGetter(testCase)
+            % Verify the VariableValidators getter returns the expected
+            % arrow.array.internal.list.Validator array.
+
+            import arrow.array.internal.list.TableValidator
+            import arrow.array.internal.list.DatetimeValidator
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = TableValidator(testCase.BaseTable);
+
+            numberVariableValidator = ClassTypeValidator(1);
+            letterVariableValidator = ClassTypeValidator("A");
+            datetimeVariableValidator = DatetimeValidator(datetime(2023, 10, 31, TimeZone="UTC"));
+            expectedValidators = [numberVariableValidator letterVariableValidator datetimeVariableValidator];
+            testCase.verifyEqual(validator.VariableValidators, expectedValidators);
+        end
+
+        function VariableValidatorsNoSetter(testCase)
+            % Verify the VariableValidators property is not settable.
+            import arrow.array.internal.list.TableValidator
+            import arrow.array.internal.list.ClassTypeValidator
+
+            validator = TableValidator(testCase.BaseTable);
+            numberVariableValidator = ClassTypeValidator(1);
+            fcn = @() setfield(validator, "VariableValidators", numberVariableValidator);
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ClassNameGetter(testCase)
+            % Verify the ClassName getter returns the expected scalar
+            % string.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            testCase.verifyEqual(validator.ClassName, "table");
+        end
+
+        function ClassNameNoSetter(testCase)
+            % Verify the ClassName property is not settable.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            fcn = @() setfield(validator, "ClassName", "string");
+            testCase.verifyError(fcn, "MATLAB:class:SetProhibited");
+        end
+
+        function ValidateElementClassTypeMismatchError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:ClassTypeMismatch" if the input is
+            % not a table.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            errorID = "arrow:array:list:ClassTypeMismatch";
+            fcn = @() validator.validateElement(1);
+            testCase.verifyError(fcn, errorID);
+            fcn = @() validator.validateElement(seconds(1));
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function ValidateElementNumVariablesMismatchError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:NumVariablesMismatch" if the input table
+            % does not have the expected number of variables.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            errorID = "arrow:array:list:NumVariablesMismatch";
+
+            inputTable = table(1, "A", VariableNames=["Number", "Letter"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, errorID);
+
+            inputTable = table(1, "A", datetime(2023, 10, 30, TimeZone="UTC"), seconds(1), ...
+                VariableNames=["Number", "Letter", "Date", "Time"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function ValidateElementVariableNamesMismatchError(testCase)
+            % Verify validateElement throws an exception whose identifier
+            % is "arrow:array:list:NumVariablesMismatch" if the input table
+            % does not have the expected variable names of variables.
+            import arrow.array.internal.list.TableValidator
+
+            validator = TableValidator(testCase.BaseTable);
+            errorID = "arrow:array:list:VariableNamesMismatch";
+
+            inputTable = table(1, "A", datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["A", "B", "C"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, errorID);
+        end
+
+        function ValidateElementErrorFromFirstVariable(testCase)
+            % Verify validateElement throws an exception if there is an
+            % issue with the first variable in the input table.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+
+            % validator expects the second variable to be a double
+            inputTable = table(true, "A", datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:ClassTypeMismatch");
+
+            % validator expects all table variables that are not tables
+            % themselves to be columnar or empty
+            nonColumnar = [1 2 3 4];
+            inputTable = table(nonColumnar, "B", datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:NonTabularVariablesMustBeColumnar");
+        end
+
+        function ValidateElementErrorFromSecondVariable(testCase)
+            % Verify validateElement throws an exception if there is an
+            % issue with the second variable in the input table.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+
+            % validator expects the second variable to be a string
+            inputTable = table(2, seconds(1), datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:ClassTypeMismatch");
+
+            % validator expects all table variables that are not tables
+            % themselves to be columnar or empty
+            nonColumnar = ["A" "B"];
+            inputTable = table(2, nonColumnar, datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:NonTabularVariablesMustBeColumnar");
+        end
+
+        function ValidateElementErrorFromThirdVariable(testCase)
+            % Verify validateElement throws an exception if there is an
+            % issue with the third variable in the input table.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+
+            % validator expects the third variable to be a zoned datetime
+            inputTable = table(2, "B", datetime(2023, 10, 31), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:ExpectedZonedDatetime");
+
+            % validator expects the third variable to be datetime
+            inputTable = table(2, "B", uint8(1), ...
+                VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:ClassTypeMismatch");
+
+            % validator expects all table variables that are not tables
+            % themselves to be columnar or empty
+            nonColumnar = datetime(2023, 10, 31, TimeZone="UTC") + days(0:4);
+            inputTable = table(2, "B", nonColumnar, VariableNames=["Number", "Letter", "Date"]);
+            fcn = @() validator.validateElement(inputTable);
+            testCase.verifyError(fcn, "arrow:array:list:NonTabularVariablesMustBeColumnar");
+        end
+
+        function validateElementNoThrow(testCase)
+            % Verify validateElement does not throw an exception if the
+            % input provided matches the expected schema.
+
+            import arrow.array.internal.list.TableValidator
+            validator = TableValidator(testCase.BaseTable);
+            
+            inputTable = table(2, "B", datetime(2023, 10, 31, TimeZone="UTC"), ...
+                VariableNames=["Number", "Letter", "Date"]);
+             validator.validateElement(inputTable);
+
+            inputTable = repmat(inputTable, [10 1]);
+            validator.validateElement(inputTable);
+
+            % Create a 0x3 table
+            inputTable = inputTable(1:0, :);
+            validator.validateElement(inputTable);
+        end
+
+        function validateElementNestedTableVariable(testCase) %#ok<MANU>
+            % Verify table variables that are tables themselves do not have
+            % to be columnar, i.e. can have more than one variable.
+            import arrow.array.internal.list.TableValidator
+            
+            baseTable = table(1, seconds(1), table("A", false));
+            validator = TableValidator(baseTable);
+
+            inputTable = table([1; 2], seconds([3;4]), table(["C"; "D"], [false; false]));
+            validator.validateElement(inputTable);
+        end
+
+        function GetElementLength(testCase)
+            % Verify GetElementLength returns the the number of rows as the
+            % length of the element.
+            import arrow.array.internal.list.TableValidator
+            
+            validator = TableValidator(testCase.BaseTable);
+            
+            length = validator.getElementLength(testCase.BaseTable);
+            testCase.verifyEqual(length, 1);
+
+            length = validator.getElementLength(repmat(testCase.BaseTable, [12 1]));
+            testCase.verifyEqual(length, 12);
+
+            length = validator.getElementLength(testCase.BaseTable(1:0, :));
+            testCase.verifyEqual(length, 0);
+        end
+
+        function ReshapeCellElements(testCase)
+            % Verify reshapeCellElements is a no-op. It should return the
+            % original cell array unchanged.
+            import arrow.array.internal.list.TableValidator
+
+            validator = TableValidator(testCase.BaseTable);
+            
+            COriginal = {testCase.BaseTable, repmat(testCase.BaseTable, [10 1]), testCase.BaseTable(1:0, :)};
+            CActual = validator.reshapeCellElements(COriginal);
+            testCase.verifyEqual(COriginal, CActual);
+        end
+    end
+end
\ No newline at end of file

From 1749e00ff4fc39816f4226f9b328198838049da5 Mon Sep 17 00:00:00 2001
From: Lei Hou <leihou@mathworks.com>
Date: Thu, 2 Nov 2023 16:24:16 -0400
Subject: [PATCH 672/749] GH-38541: [MATLAB] Add remaining tests for arrow
 tabular object display (#38564)

### Rationale for this change

The current tests for arrow tabular display only covers basic use cases. To guarantee its quality, we need to add tests to cover more use cases.

### Added Test Cases
- display of 0-by-N tabular
- display of a very wide tabular to verify that the display is not truncated.
- display of hyperlink contained in the tabular data
- display class name when the datatype of a tabular variable is not array.
- display of null
- display of Unicode.

### Are these changes tested?

Yes.

See "Added test Cases" above.

### Are there any user-facing changes?

No
* Closes: #38541

Authored-by: Lei Hou <leihou@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/test/arrow/tabular/tTabularDisplay.m | 200 +++++++++++++++++++-
 1 file changed, 197 insertions(+), 3 deletions(-)

diff --git a/matlab/test/arrow/tabular/tTabularDisplay.m b/matlab/test/arrow/tabular/tTabularDisplay.m
index f99b25ab3452f..027517edeb2d6 100644
--- a/matlab/test/arrow/tabular/tTabularDisplay.m
+++ b/matlab/test/arrow/tabular/tTabularDisplay.m
@@ -76,6 +76,35 @@ function ZeroRowsOneColumn(testCase, TabularType)
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
 
+        function ZeroRowsMultipleColumns(testCase, TabularType)
+            % Verify that the display of a 0xN arrow tabular object displays
+            % the schema but no rows because there are zero rows.
+            import arrow.internal.test.display.makeLinkString
+            t = table(Size=[0,6], ...
+                      VariableTypes=["double" "single" "int8" "logical" "uint64" "string"], ...
+                      VariableNames=["ratio = a / b" "number" "ID" "A very looooooooooooooong name" "Result" "侯磊"]);
+            tabularObj = TabularType.FromTableFcn(t);
+            actualDisplay = evalc('disp(tabularObj)');
+
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(0), getNumString(6));
+            var1Field = char(makeFieldString(                 "ratio = a / b", "Float64", "arrow.type.Float64Type"));
+            var2Field = char(makeFieldString(                        "number", "Float32", "arrow.type.Float32Type"));
+            var3Field = char(makeFieldString(                            "ID", "Int8"   , "arrow.type.Int8Type"));
+            var4Field = char(makeFieldString("A very looooooooooooooong name", "Boolean", "arrow.type.BooleanType"));
+            var5Field = char(makeFieldString(                        "Result", "UInt64" , "arrow.type.UInt64Type"));
+            var6Field = char(makeFieldString(                          "侯磊", "String" , "arrow.type.StringType"));
+            expectedDisplay = [char(header), newline, ...
+                               newline, ...
+                               '    Schema:', newline, ...
+                               newline ...
+                               '        ', var1Field, ' | ', var2Field, ' | ', var3Field, ' | ', var4Field, ' | ', var5Field, ' | ', var6Field, newline, ...
+                               newline];
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
         function OneRowOneColumn(testCase, TabularType)
             % Verify tabular object display when the object has one row
             % and column.
@@ -99,9 +128,10 @@ function OneRowOneColumn(testCase, TabularType)
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
 
-        function ManyRowsAndColumns(testCase, TabularType)
-            % Verify tabular object display when the object has many rows
-            % and columns.
+        function MultipleRowsAndColumns(testCase, TabularType)
+            % Verify tabular object display when the object has mulitple rows
+            % and columns. Only the first row is displayed. All columns are
+            % displayed.
             import arrow.internal.test.display.makeLinkString
             
             t = table((1:2)', ["A"; "B"], true(2, 1), VariableNames=["Number", "Letter", "Logical"]);
@@ -124,6 +154,170 @@ function ManyRowsAndColumns(testCase, TabularType)
 
             testCase.verifyEqual(actualDisplay, expectedDisplay);
         end
+
+        function VeryWideTabular(testCase, TabularType)
+            % Verify that all variables are displayed without any trucation 
+            % even when the tabular object is wider than the MATLAB Command
+            % Window.
+            import arrow.internal.test.display.makeLinkString
+
+            t = array2table([1:100;101:200],VariableNames="x"+(1:100));
+            arrowTabularObj = TabularType.FromTableFcn(t);
+            actualDisplay = evalc('disp(arrowTabularObj)');
+
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(2), getNumString(100));
+            schemaDisplay = ['    Schema:', newline, newline, '        '];
+            dataDisplay   = ['    First Row:', newline, newline, '        '];
+            for i = 1:width(t)
+                if i < width(t)
+                    schemaDisplay = [schemaDisplay, char(makeFieldString("x"+i, "Float64", "arrow.type.Float64Type")), ' | '];
+                    dataDisplay = [dataDisplay, num2str(i), ' | '];
+                else
+                    schemaDisplay = [schemaDisplay, char(makeFieldString("x"+i, "Float64", "arrow.type.Float64Type"))];
+                    dataDisplay = [dataDisplay, num2str(i)];
+                end
+            end
+            expectedDisplay = [char(header), newline, ...
+                               newline, ...
+                               schemaDisplay, newline, ...
+                               newline ...
+                               dataDisplay, newline, ...
+                               newline];
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DataContainsHyperlink(testCase, TabularType)
+            % Verify that the data text containing hyperlink is always
+            % displayed as expected no matter whether hotlinks is turned on
+            % or off.
+            import arrow.internal.test.display.makeLinkString
+
+            hLink1 = string('<a href="http://www.foo.com">foo</a>');
+            hLink2 = string('<a href="http://www.foo.com">another foo</a>');
+            t = table(["a";"bcd";missing;""],[hLink1;hLink2;hLink1;hLink2],[NaN;1;2;3],'VariableNames',["Description", "Link_to_doc", "Result"]);
+            arrowTabularObj = TabularType.FromTableFcn(t);
+
+            % The display of schema and actual tabular data always contains 
+            % hyperlinks no matter whether hotlinks is turned on or off
+            var1Field = char(makeFieldString("Description", "String" , "arrow.type.StringType"));
+            var2Field = char(makeFieldString("Link_to_doc", "String" , "arrow.type.StringType"));
+            var3Field = char(makeFieldString(     "Result", "Float64", "arrow.type.Float64Type"));
+            schemaDisplay = ['    Schema:', newline, newline, ...
+                             '        ', var1Field, ' | ', var2Field, ' | ', var3Field];
+            dataDisplay   = ['    First Row:', newline, newline, ...
+                             '        ', '"a"', ' | ', '"', '<a href="http://www.foo.com">foo</a>', '"', ' | ', 'null'];
+            expectedDisplayOfData = [newline, ...
+                                     '    Schema:', newline, ...
+                                     newline ...
+                                     '        ', var1Field, ' | ', var2Field, ' | ', var3Field, newline, ...
+                                     newline, ...
+                                     '    First Row:', newline, ...
+                                     newline, ...
+                                     '        ', '"a"', ' | ', '"', '<a href="http://www.foo.com">foo</a>', '"', ' | ', 'null', newline, ...
+                                     newline];
+
+            % hotlinks is turned off
+            actualDisplay = evalc('feature(''hotlinks'',''off'');disp(arrowTabularObj)');
+            testCase.verifySubstring(actualDisplay, expectedDisplayOfData);
+
+            % hotlinks is turned on
+            actualDisplay = evalc('feature(''hotlinks'',''on'');disp(arrowTabularObj)');
+            testCase.verifySubstring(actualDisplay, expectedDisplayOfData);
+        end
+
+        function DisplayClassNameWhenDataIsNotArray(testCase, TabularType)
+            % Verify that the class name instead of the actual data will be
+            % displayed when the datatype of a tabular variable is a nested
+            % array type (e.g. StructArray or ListArray).
+            import arrow.internal.test.display.makeLinkString
+
+            t = table(datetime(2023,1,[1;2;3]),table([1;2;3],[4;5;6]),seconds([1;2;3]));
+            arrowTabularObj = TabularType.FromTableFcn(t);
+            actualDisplay = evalc('disp(arrowTabularObj)');
+
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(3), getNumString(3));
+            var1Field = char(makeFieldString("Var1", "Timestamp" , "arrow.type.TimestampType"));
+            var2Field = char(makeFieldString("Var2", "Struct" , "arrow.type.StructType"));
+            var3Field = char(makeFieldString("Var3", "Time64", "arrow.type.Time64Type"));
+            expectedDisplay = [char(header), newline, ...
+                               newline, ...
+                               '    Schema:', newline, ...
+                               newline, ...
+                               '        ', var1Field, ' | ', var2Field, ' | ', var3Field, newline, ...
+                               newline, ...
+                               '    First Row:', newline, ...
+                               newline, ...
+                               '        ', '2023-01-01 00:00:00.000000 | <Struct> | 00:00:01.000000', newline,...
+                               newline];
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function DisplayInvalidData(testCase, TabularType)
+            % Verify that "null" is displayed for invalid value.
+            import arrow.internal.test.display.makeLinkString
+
+            t = table(seconds([NaN;1]), string([missing;"a"]), string(["";"b"]),  [NaN;1], datetime(2023,1,[NaN;2]),...
+                VariableNames=["durationVar", "stringVar1", "stringVar2", "doubleVar", "datetimeVar"]);
+            arrowTabularObj = TabularType.FromTableFcn(t);
+            actualDisplay = evalc('disp(arrowTabularObj)');
+
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(2), getNumString(5));
+            var1Field = char(makeFieldString("durationVar", "Time64" , "arrow.type.Time64Type"));
+            var2Field = char(makeFieldString("stringVar1", "String" , "arrow.type.StringType"));
+            var3Field = char(makeFieldString("stringVar2", "String", "arrow.type.StringType"));
+            var4Field = char(makeFieldString("doubleVar", "Float64", "arrow.type.Float64Type"));
+            var5Field = char(makeFieldString("datetimeVar", "Timestamp", "arrow.type.TimestampType"));
+            expectedDisplay = [char(header), newline, ...
+                               newline, ...
+                               '    Schema:', newline, ...
+                               newline, ...
+                               '        ', var1Field, ' | ', var2Field, ' | ', var3Field, ' | ', var4Field, ' | ', var5Field, newline, ...
+                               newline, ...
+                               '    First Row:', newline, ...
+                               newline, ...
+                               '        ', 'null | null | "" | null | null', newline,...
+                               newline];
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
+
+        function Unicode(testCase, TabularType)
+            % Verify that unicode characters are displayed well. The 
+            % current display doesn't align multiple rows vertically. 
+            % Therefore, there is no alignment concern.
+            import arrow.internal.test.display.makeLinkString
+
+            t = table([0.1;0.2],string(char([26228 22825; 22810 20113])), ["Kevin"; "Lei"],...
+                      VariableNames=["Number" "Weather" string(char([21517 23383]))]);
+            arrowTabularObj = TabularType.FromTableFcn(t);
+            actualDisplay = evalc('disp(arrowTabularObj)');
+
+            classNameString = makeLinkString(FullClassName=TabularType.FullClassName, ...
+                ClassName=TabularType.ClassName, BoldFont=true);
+            header = compose("  Arrow %s with %s rows and %s columns:", classNameString, getNumString(2), getNumString(3));
+            var1Field = char(makeFieldString(t.Properties.VariableNames{1}, "Float64" , "arrow.type.Float64Type"));
+            var2Field = char(makeFieldString(t.Properties.VariableNames{2}, "String" , "arrow.type.StringType"));
+            var3Field = char(makeFieldString(t.Properties.VariableNames{3}, "String", "arrow.type.StringType"));
+            expectedDisplay = [char(header), newline, ...
+                               newline, ...
+                               '    Schema:', newline, ...
+                               newline, ...
+                               '        ', var1Field, ' | ', var2Field, ' | ', var3Field, newline, ...
+                               newline, ...
+                               '    First Row:', newline, ...
+                               newline, ...
+                               '        ', '0.1 | "', char([26228 22825]), '" | "Kevin"', newline,...
+                               newline];
+
+            testCase.verifyEqual(actualDisplay, expectedDisplay);
+        end
     end
 end
 

From cd6e63570f81e96375a4c51ef5d925b5f32f5a57 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 2 Nov 2023 16:25:42 -0400
Subject: [PATCH 673/749] GH-38354: [MATLAB] Implement `fromMATLAB` method for
 `arrow.array.ListArray` (#38561)

### Rationale for this change

We should implement a static `fromMATLAB` method for `arrow.array.ListArray` that takes in a MATLAB `cell` array and returns an instance of `arrow.array.ListArray`. Adding this method enables users to create an `arrow.array.ListArray` by passing a MATLAB `cell` array to the `arrow.array` gateway function:

```matlab
>> C = {[1 2 3], [4 5], 6};
>> array = arrow.array(C)

array =

  ListArray with 3 elements and 0 null values:

    [
        [
            1,
            2,
            3
        ],
        [
            4,
            5
        ],
        [
            6
        ]
    ]
```
Internally, the `arrow.array` gateway function will call `arrow.array.ListArray.fromMATLAB` to construct a `ListArray` from the given `cell` array.

### What changes are included in this PR?

1. Implemented `fromMATLAB` method on `arrow.array.ListArray`. This method accepts a MATLAB `cell` array and returns an instance of `arrow.array.ListArray`.
2. Set the `ArrayStaticConstructor` property of `arrow.type.traits.ListTraits` to `@ arrow.array.ListArray.fromMATLAB`.
3. Added a switch case for `"cell"` to the `arrow.array` gateway function that invokes `arrow.array.ListArray.fromMATLAB` with the input `cell` array.

### Are these changes tested?

Yes. I added a new test class to the `test/arrow/array/list` folder named `tFromMATLAB.m`.

### Are there any user-facing changes?

Yes. Users can now create instances of `arrow.array.ListArray` by passing `cell` arrays to `arrow.array`:

```matlab
>> C = {["A" "B"], ["C" "D" "E"], missing, ["F" "G"], string.empty(0, 1)};
>> array = arrow.array(C)

array =

  ListArray with 5 elements and 1 null value:

    [
        [
            "A",
            "B"
        ],
        [
            "C",
            "D",
            "E"
        ],
        null,
        [
            "F",
            "G"
        ],
        []
    ]

```

* Closes: #38354

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../+list/findFirstNonMissingElement.m        |  24 ++
 matlab/src/matlab/+arrow/+array/ListArray.m   |  54 +++++
 .../matlab/+arrow/+type/+traits/ListTraits.m  |   2 +-
 matlab/src/matlab/+arrow/array.m              |   2 +
 matlab/test/arrow/array/list/tFromMATLAB.m    | 206 ++++++++++++++++++
 matlab/test/arrow/array/tArray.m              |   5 +-
 matlab/test/arrow/type/traits/tListTraits.m   |   2 +-
 7 files changed, 291 insertions(+), 4 deletions(-)
 create mode 100644 matlab/src/matlab/+arrow/+array/+internal/+list/findFirstNonMissingElement.m
 create mode 100644 matlab/test/arrow/array/list/tFromMATLAB.m

diff --git a/matlab/src/matlab/+arrow/+array/+internal/+list/findFirstNonMissingElement.m b/matlab/src/matlab/+arrow/+array/+internal/+list/findFirstNonMissingElement.m
new file mode 100644
index 0000000000000..5b29443568e6e
--- /dev/null
+++ b/matlab/src/matlab/+arrow/+array/+internal/+list/findFirstNonMissingElement.m
@@ -0,0 +1,24 @@
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+function idx = findFirstNonMissingElement(C)
+    idx = -1;
+    for ii=1:numel(C)
+        if ~isa(C{ii}, "missing")
+            idx = ii;
+            return;
+        end
+    end
+end
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/ListArray.m b/matlab/src/matlab/+arrow/+array/ListArray.m
index 9a93c39ec6193..0febdd3831c07 100644
--- a/matlab/src/matlab/+arrow/+array/ListArray.m
+++ b/matlab/src/matlab/+arrow/+array/ListArray.m
@@ -109,6 +109,60 @@
             array = arrow.array.ListArray(proxy);
         end
 
+        function array = fromMATLAB(C)
+            arguments
+                C(:, 1) cell {mustBeNonempty}
+            end
+            import arrow.array.internal.list.findFirstNonMissingElement
+            import arrow.array.internal.list.createValidator
+
+            idx = findFirstNonMissingElement(C);
+
+            if idx == -1
+                id = "arrow:array:list:CellArrayAllMissing";
+                msg = "The input cell array must contain at least one non-missing" + ...
+                    " value to be converted to an Arrow array.";
+                error(id, msg);
+            end
+
+            validator = createValidator(C{idx});
+
+            numElements = numel(C);
+            valid = true([numElements 1]);
+            % All elements before the first non-missing value should be 
+            % treated as null values.
+            valid(1:idx-1) = false;
+            offsets = zeros([numElements + 1, 1], "int32");
+
+            for ii = idx:numElements
+                element = C{ii};
+                if isa(element, "missing")
+                    % Treat missing values as null values.
+                    valid(ii) = false;
+                    offsets(ii + 1) = offsets(ii);
+                else
+                    validator.validateElement(element);
+                    length = validator.getElementLength(element);
+                    offsets(ii + 1) = offsets(ii) + length;
+                end
+            end
+
+            offsetArray = arrow.array(offsets);
+
+            validValueCellArray = validator.reshapeCellElements(C(valid));
+            values = vertcat(validValueCellArray{:});
+            valueArray = arrow.array(values);
+
+            args = struct(...
+                OffsetsProxyID=offsetArray.Proxy.ID, ...
+                ValuesProxyID=valueArray.Proxy.ID, ...
+                Valid=valid ...
+            );
+            
+            proxyName = "arrow.array.proxy.ListArray";
+            proxy = arrow.internal.proxy.create(proxyName, args);
+            array = arrow.array.ListArray(proxy);
+        end
     end
 
 end
diff --git a/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
index 26a0c6d340603..5404e0716c84a 100644
--- a/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
+++ b/matlab/src/matlab/+arrow/+type/+traits/ListTraits.m
@@ -19,7 +19,7 @@
         ArrayConstructor = @arrow.array.ListArray
         ArrayClassName = "arrow.array.ListArray"
         ArrayProxyClassName = "arrow.array.proxy.ListArray"
-        ArrayStaticConstructor = missing
+        ArrayStaticConstructor = @arrow.array.ListArray.fromMATLAB
         TypeConstructor = @arrow.type.ListType
         TypeClassName = "arrow.type.ListType"
         TypeProxyClassName = "arrow.type.proxy.ListType"
diff --git a/matlab/src/matlab/+arrow/array.m b/matlab/src/matlab/+arrow/array.m
index 50221b4b955df..073715ece7713 100644
--- a/matlab/src/matlab/+arrow/array.m
+++ b/matlab/src/matlab/+arrow/array.m
@@ -49,6 +49,8 @@
             arrowArray = arrow.array.Time64Array.fromMATLAB(data, varargin{:});
         case "table"
             arrowArray = arrow.array.StructArray.fromMATLAB(data, varargin{:});
+        case "cell"
+            arrowArray = arrow.array.ListArray.fromMATLAB(data, varargin{:});
         otherwise
             errid = "arrow:array:UnsupportedMATLABType";
             msg = join(["Unable to convert MATLAB type" classname "to arrow array."]);
diff --git a/matlab/test/arrow/array/list/tFromMATLAB.m b/matlab/test/arrow/array/list/tFromMATLAB.m
new file mode 100644
index 0000000000000..ebc79ec0fd98b
--- /dev/null
+++ b/matlab/test/arrow/array/list/tFromMATLAB.m
@@ -0,0 +1,206 @@
+%TFROMMATLAB Unit tests for arrow.array.ListArray's froMATLAB method.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tFromMATLAB < matlab.unittest.TestCase
+
+    methods (Test)
+        function EmptyCellArrayError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is 
+            % "MATLAB:validators:mustBeNonempty" if given an empty cell
+            % array as input.
+            import arrow.array.ListArray
+
+            fcn = @() ListArray.fromMATLAB({});
+            testCase.verifyError(fcn, "MATLAB:validators:mustBeNonempty");
+        end
+
+        function MustBeCellArrayError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "MATLAB:validation:UnableToConvert" if the input provided is
+            % not a cell array.
+            import arrow.array.ListArray
+
+            fcn = @() ListArray.fromMATLAB('a');
+            testCase.verifyError(fcn, "MATLAB:validation:UnableToConvert");
+        end
+
+        function AllMissingCellArrayError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "arrow:array:list:CellArrayAllMissing" if given a cell array
+            % containing only missing values.
+            import arrow.array.ListArray
+
+            C = {missing missing missing};
+            fcn = @() ListArray.fromMATLAB(C);
+            testCase.verifyError(fcn, "arrow:array:list:CellArrayAllMissing");
+        end
+
+        function ListOfFloat64(testCase)
+            % Verify fromMATLAB creates the expected ListArray whose
+            % Values property is a Float64Array.
+            import arrow.array.ListArray
+
+            C = {[1 2 3], [4 5], missing, [6 7 8], [], [9 10]};
+            actual = ListArray.fromMATLAB(C);
+
+            values = arrow.array(1:10);
+            offsets = arrow.array(int32([0 3 5 5 8 8 10]));
+            expected = ListArray.fromArrays(offsets, values, Valid=[1 2 4 5 6]);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ListOfStruct(testCase)
+            % Verify fromMATLAB creates the expected ListArray whose
+            % Values property is a StructArray.
+            import arrow.array.ListArray
+
+            Number = (1:10)';
+            Text = compose("Test%d", (1:10)');
+            Date = datetime(2023, 11, 2) + days(0:9)';
+            T = table(Number, Text, Date);
+            C = {missing, T(1:3, :), T(4, :), T(1:0, :), T(5:10, :), missing};
+            actual = ListArray.fromMATLAB(C);
+
+            values = arrow.array(T);
+            offsets = arrow.array(int32([0 0 3 4 4 10 10]));
+            expected = ListArray.fromArrays(offsets, values, Valid=[2 3 4 5]);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ListOfListOfString(testCase)
+            % Verify fromMATLAB creates the expected ListArray whose
+            % Values property is a ListArray.
+            import arrow.array.ListArray
+
+            rowOne = {["A" "B"], ["C" "D" "E"] missing};
+            rowTwo = missing;
+            rowThree = {"F" ["G" "H" "I"]};
+            C = {rowOne, rowTwo rowThree};
+            actual = ListArray.fromMATLAB(C);
+
+            stringValues = arrow.array(["A" "B" "C" "D" "E" "F" "G" "H" "I"]);
+            innerOffsets = arrow.array(int32([0 2 5 5 6 9]));
+            valuesList = ListArray.fromArrays(innerOffsets, stringValues, Valid=[1 2 4 5]);
+
+            outerOffsets = arrow.array(int32([0 3 3 5]));
+            expected = ListArray.fromArrays(outerOffsets, valuesList, Valid=[1 3]);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function OnlyEmptyElement(testCase)
+            % Create a ListArray containing only empty elements.
+            import arrow.array.ListArray
+
+            emptyDuration = duration.empty(0, 0);
+
+            C = {emptyDuration, emptyDuration, emptyDuration, emptyDuration};
+            actual = ListArray.fromMATLAB(C);
+
+            values = arrow.array(duration.empty);
+            offsets = arrow.array(int32([0 0 0 0 0]));
+            expected = ListArray.fromArrays(offsets, values);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function CellOfEmptyCell(testCase)
+            % Verify fromMATLAB creates a ListArray whose Values property
+            % is a StringArray when given a cell array containing just an
+            % empty cell array.
+            import arrow.array.ListArray
+
+            C = {{}};
+            actual = ListArray.fromMATLAB(C);
+
+            values = arrow.array(string.empty);
+            offsets = arrow.array(int32([0 0]));
+            expected = ListArray.fromArrays(offsets, values);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function CellOfMatrices(testCase)
+            % Verify fromMATLAB can handle cell arrays that contain
+            % matrices instead of just vectors - i.e. the matrices are
+            % reshaped as column vectors before they are concatenated
+            % together.
+            import arrow.array.ListArray
+
+            C = {[1 2 3; 4 5 6], [7 8; 9 10], 11};
+            actual = ListArray.fromMATLAB(C);
+
+            values = arrow.array([1 4 2 5 3 6 7 9 8 10 11]);
+            offsets = arrow.array(int32([0 6 10 11]));
+            expected = ListArray.fromArrays(offsets, values);
+
+            testCase.verifyEqual(actual, expected);
+        end
+
+        function ClassTypeMismatchError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "arrow:array:list:ClassTypeMismatch" if given a cell array
+            % containing arrays with different class types.
+            import arrow.array.ListArray
+
+            C = {1, [2 3 4], "A", 5};
+            fcn = @() ListArray.fromMATLAB(C);
+            testCase.verifyError(fcn, "arrow:array:list:ClassTypeMismatch");
+        end
+
+        function VariableNamesMismatchError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "arrow:array:list:VariableNamesMismatch" if given a cell 
+            % array containing tables whose variable names don't match.
+            import arrow.array.ListArray
+
+            C = {table(1, "A"), table(2, "B", VariableNames=["X", "Y"])};
+            fcn = @() ListArray.fromMATLAB(C);
+            testCase.verifyError(fcn, "arrow:array:list:VariableNamesMismatch");
+        end
+
+        function ExpectedZonedDatetimeError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "arrow:array:list:ExpectedZonedDatetime" if given a cell 
+            % array containing zoned and unzoned datetimes - in that order.
+
+            import arrow.array.ListArray
+
+            C = {datetime(2023, 11, 1, TimeZone="UTC"), datetime(2023, 11, 2)}; 
+            fcn = @() ListArray.fromMATLAB(C);
+            testCase.verifyError(fcn, "arrow:array:list:ExpectedZonedDatetime");
+        end
+
+        function ExpectedUnzonedDatetimeError(testCase)
+            % Verify fromMATLAB throws an error whose identifier is
+            % "arrow:array:list:ExpectedUnzonedDatetime" if given a cell 
+            % array containing unzoned and zoned datetimes - in that order.
+
+            import arrow.array.ListArray
+
+            C = {datetime(2023, 11, 1), datetime(2023, 11, 2, TimeZone="UTC")}; 
+            fcn = @() ListArray.fromMATLAB(C);
+            testCase.verifyError(fcn, "arrow:array:list:ExpectedUnzonedDatetime");
+        end
+
+
+
+    end
+
+end
\ No newline at end of file
diff --git a/matlab/test/arrow/array/tArray.m b/matlab/test/arrow/array/tArray.m
index 545d382ddf7f4..0012ad900ecb2 100644
--- a/matlab/test/arrow/array/tArray.m
+++ b/matlab/test/arrow/array/tArray.m
@@ -33,7 +33,8 @@
             {datetime(2022, 1, 1), "arrow.array.TimestampArray"}, ...
             {seconds([1 2]),       "arrow.array.Time64Array"}, ...
             {["A" "B"],            "arrow.array.StringArray"}, ...
-            {table(["A" "B"]'),    "arrow.array.StructArray"}};
+            {table(["A" "B"]'),    "arrow.array.StructArray"}, ...
+            {{[1, 2, 3], [4, 5]},  "arrow.array.ListArray"}};
     end
 
     methods(Test)        
@@ -51,7 +52,7 @@ function UnsupportedMATLABTypeError(testCase)
         % Verify arrow.array throws an error with the identifier
         % "arrow:array:UnsupportedMATLABType" if the input array is not one
         % we support converting into an Arrow array.
-            matlabArray = {table};
+            matlabArray = calmonths(12);
             fcn = @() arrow.array(matlabArray);
             errID = "arrow:array:UnsupportedMATLABType";
             testCase.verifyError(fcn, errID);
diff --git a/matlab/test/arrow/type/traits/tListTraits.m b/matlab/test/arrow/type/traits/tListTraits.m
index 444c977503123..2559d256d47f8 100644
--- a/matlab/test/arrow/type/traits/tListTraits.m
+++ b/matlab/test/arrow/type/traits/tListTraits.m
@@ -20,7 +20,7 @@
         ArrayConstructor = @arrow.array.ListArray
         ArrayClassName = "arrow.array.ListArray"
         ArrayProxyClassName = "arrow.array.proxy.ListArray"
-        ArrayStaticConstructor = missing
+        ArrayStaticConstructor = @arrow.array.ListArray.fromMATLAB
         TypeConstructor = @arrow.type.ListType
         TypeClassName = "arrow.type.ListType"
         TypeProxyClassName = "arrow.type.proxy.ListType"

From 2fb7fd94f26ba733587e2ed21f6b3625c48bf736 Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Fri, 3 Nov 2023 10:57:29 -0700
Subject: [PATCH 674/749] GH-34532: [Java][FlightSQL] Change JDBC to handle
 multi-endpoints (#38521)

### Rationale for this change
The Flight SQL JDBC Driver currently doesn't fetch at multiple endpoints correctly when the data is not at the same location as the original connection.

### What changes are included in this PR?
- Create new clients to connect to new locations in endpoints.
- If no location is reported using the current connection.
- Make ArrowFlightSqlClientHandler's builder's build() function to be idempodent.
- Add functionality to clone ArrowFlightSqClientHandler's builder so that it can be used for temporary connections to locations returned by getFlightInfo().
- Add utility classes in unit tests for constructing a distributed Flight SQL Server

### Are these changes tested?
Yes.

### Are there any user-facing changes?
The behavior for when there are reported endpoints from getFlightInfo is now fixed. However if users relied on the previous behavior of just getting streams from the same node, and their server only ever reported the original node, they may observe more Flight client connections opening and closing than before (since new connections get spawned for each partition that has at least one Location now).

* Closes: #34532

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../ArrowFlightJdbcFlightStreamResultSet.java |  82 +++++++------
 ...owFlightJdbcVectorSchemaRootResultSet.java |   6 +-
 .../client/ArrowFlightSqlClientHandler.java   | 113 ++++++++++++++---
 .../client/CloseableEndpointStreamPair.java   |  46 +++++++
 ...ueue.java => FlightEndpointDataQueue.java} |  68 ++++++-----
 .../arrow/driver/jdbc/ResultSetTest.java      | 104 ++++++++++++++--
 ....java => FlightEndpointDataQueueTest.java} |  14 +--
 .../utils/PartitionedFlightSqlProducer.java   | 115 ++++++++++++++++++
 8 files changed, 439 insertions(+), 109 deletions(-)
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/CloseableEndpointStreamPair.java
 rename java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/{FlightStreamQueue.java => FlightEndpointDataQueue.java} (73%)
 rename java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/{FlightStreamQueueTest.java => FlightEndpointDataQueueTest.java} (85%)
 create mode 100644 java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/PartitionedFlightSqlProducer.java

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
index 9a53f9fcafdd2..2e42cf0166b06 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
@@ -17,7 +17,7 @@
 
 package org.apache.arrow.driver.jdbc;
 
-import static org.apache.arrow.driver.jdbc.utils.FlightStreamQueue.createNewQueue;
+import static org.apache.arrow.driver.jdbc.utils.FlightEndpointDataQueue.createNewQueue;
 
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
@@ -26,7 +26,8 @@
 import java.util.TimeZone;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.arrow.driver.jdbc.utils.FlightStreamQueue;
+import org.apache.arrow.driver.jdbc.client.CloseableEndpointStreamPair;
+import org.apache.arrow.driver.jdbc.utils.FlightEndpointDataQueue;
 import org.apache.arrow.driver.jdbc.utils.VectorSchemaRootTransformer;
 import org.apache.arrow.flight.FlightInfo;
 import org.apache.arrow.flight.FlightStream;
@@ -47,8 +48,8 @@ public final class ArrowFlightJdbcFlightStreamResultSet
     extends ArrowFlightJdbcVectorSchemaRootResultSet {
 
   private final ArrowFlightConnection connection;
-  private FlightStream currentFlightStream;
-  private FlightStreamQueue flightStreamQueue;
+  private CloseableEndpointStreamPair currentEndpointData;
+  private FlightEndpointDataQueue flightEndpointDataQueue;
 
   private VectorSchemaRootTransformer transformer;
   private VectorSchemaRoot currentVectorSchemaRoot;
@@ -102,20 +103,20 @@ static ArrowFlightJdbcFlightStreamResultSet fromFlightInfo(
 
     resultSet.transformer = transformer;
 
-    resultSet.execute(flightInfo);
+    resultSet.populateData(flightInfo);
     return resultSet;
   }
 
   private void loadNewQueue() {
-    Optional.ofNullable(flightStreamQueue).ifPresent(AutoCloseables::closeNoChecked);
-    flightStreamQueue = createNewQueue(connection.getExecutorService());
+    Optional.ofNullable(flightEndpointDataQueue).ifPresent(AutoCloseables::closeNoChecked);
+    flightEndpointDataQueue = createNewQueue(connection.getExecutorService());
   }
 
   private void loadNewFlightStream() throws SQLException {
-    if (currentFlightStream != null) {
-      AutoCloseables.closeNoChecked(currentFlightStream);
+    if (currentEndpointData != null) {
+      AutoCloseables.closeNoChecked(currentEndpointData);
     }
-    this.currentFlightStream = getNextFlightStream(true);
+    this.currentEndpointData = getNextEndpointStream(true);
   }
 
   @Override
@@ -124,24 +125,24 @@ protected AvaticaResultSet execute() throws SQLException {
 
     if (flightInfo != null) {
       schema = flightInfo.getSchemaOptional().orElse(null);
-      execute(flightInfo);
+      populateData(flightInfo);
     }
     return this;
   }
 
-  private void execute(final FlightInfo flightInfo) throws SQLException {
+  private void populateData(final FlightInfo flightInfo) throws SQLException {
     loadNewQueue();
-    flightStreamQueue.enqueue(connection.getClientHandler().getStreams(flightInfo));
+    flightEndpointDataQueue.enqueue(connection.getClientHandler().getStreams(flightInfo));
     loadNewFlightStream();
 
     // Ownership of the root will be passed onto the cursor.
-    if (currentFlightStream != null) {
-      executeForCurrentFlightStream();
+    if (currentEndpointData != null) {
+      populateDataForCurrentFlightStream();
     }
   }
 
-  private void executeForCurrentFlightStream() throws SQLException {
-    final VectorSchemaRoot originalRoot = currentFlightStream.getRoot();
+  private void populateDataForCurrentFlightStream() throws SQLException {
+    final VectorSchemaRoot originalRoot = currentEndpointData.getStream().getRoot();
 
     if (transformer != null) {
       try {
@@ -154,9 +155,9 @@ private void executeForCurrentFlightStream() throws SQLException {
     }
 
     if (schema != null) {
-      execute(currentVectorSchemaRoot, schema);
+      populateData(currentVectorSchemaRoot, schema);
     } else {
-      execute(currentVectorSchemaRoot);
+      populateData(currentVectorSchemaRoot);
     }
   }
 
@@ -179,20 +180,20 @@ public boolean next() throws SQLException {
         return true;
       }
 
-      if (currentFlightStream != null) {
-        currentFlightStream.getRoot().clear();
-        if (currentFlightStream.next()) {
-          executeForCurrentFlightStream();
+      if (currentEndpointData != null) {
+        currentEndpointData.getStream().getRoot().clear();
+        if (currentEndpointData.getStream().next()) {
+          populateDataForCurrentFlightStream();
           continue;
         }
 
-        flightStreamQueue.enqueue(currentFlightStream);
+        flightEndpointDataQueue.enqueue(currentEndpointData);
       }
 
-      currentFlightStream = getNextFlightStream(false);
+      currentEndpointData = getNextEndpointStream(false);
 
-      if (currentFlightStream != null) {
-        executeForCurrentFlightStream();
+      if (currentEndpointData != null) {
+        populateDataForCurrentFlightStream();
         continue;
       }
 
@@ -207,14 +208,14 @@ public boolean next() throws SQLException {
   @Override
   protected void cancel() {
     super.cancel();
-    final FlightStream currentFlightStream = this.currentFlightStream;
-    if (currentFlightStream != null) {
-      currentFlightStream.cancel("Cancel", null);
+    final CloseableEndpointStreamPair currentEndpoint = this.currentEndpointData;
+    if (currentEndpoint != null) {
+      currentEndpoint.getStream().cancel("Cancel", null);
     }
 
-    if (flightStreamQueue != null) {
+    if (flightEndpointDataQueue != null) {
       try {
-        flightStreamQueue.close();
+        flightEndpointDataQueue.close();
       } catch (final Exception e) {
         throw new RuntimeException(e);
       }
@@ -224,13 +225,14 @@ protected void cancel() {
   @Override
   public synchronized void close() {
     try {
-      if (flightStreamQueue != null) {
+      if (flightEndpointDataQueue != null) {
         // flightStreamQueue should close currentFlightStream internally
-        flightStreamQueue.close();
-      } else if (currentFlightStream != null) {
+        flightEndpointDataQueue.close();
+      } else if (currentEndpointData != null) {
         // close is only called for currentFlightStream if there's no queue
-        currentFlightStream.close();
+        currentEndpointData.close();
       }
+
     } catch (final Exception e) {
       throw new RuntimeException(e);
     } finally {
@@ -238,13 +240,13 @@ public synchronized void close() {
     }
   }
 
-  private FlightStream getNextFlightStream(final boolean isExecution) throws SQLException {
-    if (isExecution) {
+  private CloseableEndpointStreamPair getNextEndpointStream(final boolean canTimeout) throws SQLException {
+    if (canTimeout) {
       final int statementTimeout = statement != null ? statement.getQueryTimeout() : 0;
       return statementTimeout != 0 ?
-          flightStreamQueue.next(statementTimeout, TimeUnit.SECONDS) : flightStreamQueue.next();
+          flightEndpointDataQueue.next(statementTimeout, TimeUnit.SECONDS) : flightEndpointDataQueue.next();
     } else {
-      return flightStreamQueue.next();
+      return flightEndpointDataQueue.next();
     }
   }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
index 9e377e51decc9..20a2af6a84aa4 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
@@ -83,7 +83,7 @@ public static ArrowFlightJdbcVectorSchemaRootResultSet fromVectorSchemaRoot(
         new ArrowFlightJdbcVectorSchemaRootResultSet(null, state, signature, resultSetMetaData,
             timeZone, null);
 
-    resultSet.execute(vectorSchemaRoot);
+    resultSet.populateData(vectorSchemaRoot);
     return resultSet;
   }
 
@@ -92,7 +92,7 @@ protected AvaticaResultSet execute() throws SQLException {
     throw new RuntimeException("Can only execute with execute(VectorSchemaRoot)");
   }
 
-  void execute(final VectorSchemaRoot vectorSchemaRoot) {
+  void populateData(final VectorSchemaRoot vectorSchemaRoot) {
     final List<Field> fields = vectorSchemaRoot.getSchema().getFields();
     final List<ColumnMetaData> columns = ConvertUtils.convertArrowFieldsToColumnMetaDataList(fields);
     signature.columns.clear();
@@ -102,7 +102,7 @@ void execute(final VectorSchemaRoot vectorSchemaRoot) {
     execute2(new ArrowFlightJdbcCursor(vectorSchemaRoot), this.signature.columns);
   }
 
-  void execute(final VectorSchemaRoot vectorSchemaRoot, final Schema schema) {
+  void populateData(final VectorSchemaRoot vectorSchemaRoot, final Schema schema) {
     final List<ColumnMetaData> columns = ConvertUtils.convertArrowFieldsToColumnMetaDataList(schema.getFields());
     signature.columns.clear();
     signature.columns.addAll(columns);
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
index bb1d524aca008..38e5a9bb362d2 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
@@ -18,14 +18,15 @@
 package org.apache.arrow.driver.jdbc.client;
 
 import java.io.IOException;
+import java.net.URI;
 import java.security.GeneralSecurityException;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.stream.Collectors;
 
 import org.apache.arrow.driver.jdbc.client.utils.ClientAuthenticationUtils;
 import org.apache.arrow.flight.CallOption;
@@ -35,8 +36,8 @@
 import org.apache.arrow.flight.FlightInfo;
 import org.apache.arrow.flight.FlightRuntimeException;
 import org.apache.arrow.flight.FlightStatusCode;
-import org.apache.arrow.flight.FlightStream;
 import org.apache.arrow.flight.Location;
+import org.apache.arrow.flight.LocationSchemes;
 import org.apache.arrow.flight.auth2.BearerCredentialWriter;
 import org.apache.arrow.flight.auth2.ClientBearerHeaderHandler;
 import org.apache.arrow.flight.auth2.ClientIncomingAuthHeaderMiddleware;
@@ -58,13 +59,18 @@
  */
 public final class ArrowFlightSqlClientHandler implements AutoCloseable {
   private static final Logger LOGGER = LoggerFactory.getLogger(ArrowFlightSqlClientHandler.class);
+
   private final FlightSqlClient sqlClient;
   private final Set<CallOption> options = new HashSet<>();
+  private final Builder builder;
 
   ArrowFlightSqlClientHandler(final FlightSqlClient sqlClient,
-                              final Collection<CallOption> options) {
-    this.options.addAll(options);
+                              final Builder builder,
+                              final Collection<CallOption> credentialOptions) {
+    this.options.addAll(builder.options);
+    this.options.addAll(credentialOptions);
     this.sqlClient = Preconditions.checkNotNull(sqlClient);
+    this.builder = builder;
   }
 
   /**
@@ -75,8 +81,9 @@ public final class ArrowFlightSqlClientHandler implements AutoCloseable {
    * @return a new {@link ArrowFlightSqlClientHandler}.
    */
   public static ArrowFlightSqlClientHandler createNewHandler(final FlightClient client,
+                                                             final Builder builder,
                                                              final Collection<CallOption> options) {
-    return new ArrowFlightSqlClientHandler(new FlightSqlClient(client), options);
+    return new ArrowFlightSqlClientHandler(new FlightSqlClient(client), builder, options);
   }
 
   /**
@@ -95,11 +102,55 @@ private CallOption[] getOptions() {
    * @param flightInfo The {@link FlightInfo} instance from which to fetch results.
    * @return a {@code FlightStream} of results.
    */
-  public List<FlightStream> getStreams(final FlightInfo flightInfo) {
-    return flightInfo.getEndpoints().stream()
-        .map(FlightEndpoint::getTicket)
-        .map(ticket -> sqlClient.getStream(ticket, getOptions()))
-        .collect(Collectors.toList());
+  public List<CloseableEndpointStreamPair> getStreams(final FlightInfo flightInfo) throws SQLException {
+    final ArrayList<CloseableEndpointStreamPair> endpoints =
+        new ArrayList<>(flightInfo.getEndpoints().size());
+
+    try {
+      for (FlightEndpoint endpoint : flightInfo.getEndpoints()) {
+        if (endpoint.getLocations().isEmpty()) {
+          // Create a stream using the current client only and do not close the client at the end.
+          endpoints.add(new CloseableEndpointStreamPair(
+              sqlClient.getStream(endpoint.getTicket(), getOptions()), null));
+        } else {
+          // Clone the builder and then set the new endpoint on it.
+          // GH-38573: This code currently only tries the first Location and treats a failure as fatal.
+          // This should be changed to try other Locations that are available.
+          
+          // GH-38574: Currently a new FlightClient will be made for each partition that returns a non-empty Location
+          // then disposed of. It may be better to cache clients because a server may report the same Locations.
+          // It would also be good to identify when the reported location is the same as the original connection's
+          // Location and skip creating a FlightClient in that scenario.
+          final URI endpointUri = endpoint.getLocations().get(0).getUri();
+          final Builder builderForEndpoint = new Builder(ArrowFlightSqlClientHandler.this.builder)
+              .withHost(endpointUri.getHost())
+              .withPort(endpointUri.getPort())
+              .withEncryption(endpointUri.getScheme().equals(LocationSchemes.GRPC_TLS));
+
+          final ArrowFlightSqlClientHandler endpointHandler = builderForEndpoint.build();
+          try {
+            endpoints.add(new CloseableEndpointStreamPair(
+                endpointHandler.sqlClient.getStream(endpoint.getTicket(),
+                    endpointHandler.getOptions()), endpointHandler.sqlClient));
+          } catch (Exception ex) {
+            AutoCloseables.close(endpointHandler);
+            throw ex;
+          }
+        }
+      }
+    } catch (Exception outerException) {
+      try {
+        AutoCloseables.close(endpoints);
+      } catch (Exception innerEx) {
+        outerException.addSuppressed(innerEx);
+      }
+
+      if (outerException instanceof SQLException) {
+        throw (SQLException) outerException;
+      }
+      throw new SQLException(outerException);
+    }
+    return endpoints;
   }
 
   /**
@@ -364,6 +415,31 @@ public static final class Builder {
     private boolean useSystemTrustStore;
     private BufferAllocator allocator;
 
+    public Builder() {
+
+    }
+
+    /**
+     * Copies the builder.
+     *
+     * @param original The builder to base this copy off of.
+     */
+    private Builder(Builder original) {
+      this.middlewareFactories.addAll(original.middlewareFactories);
+      this.options.addAll(original.options);
+      this.host = original.host;
+      this.port = original.port;
+      this.username = original.username;
+      this.password = original.password;
+      this.trustStorePath = original.trustStorePath;
+      this.trustStorePassword = original.trustStorePassword;
+      this.token = original.token;
+      this.useEncryption = original.useEncryption;
+      this.disableCertificateVerification = original.disableCertificateVerification;
+      this.useSystemTrustStore = original.useSystemTrustStore;
+      this.allocator = original.allocator;
+    }
+
     /**
      * Sets the host for this handler.
      *
@@ -535,18 +611,22 @@ public Builder withCallOptions(final Collection<CallOption> options) {
      * @throws SQLException on error.
      */
     public ArrowFlightSqlClientHandler build() throws SQLException {
+      // Copy middlewares so that the build method doesn't change the state of the builder fields itself.
+      Set<FlightClientMiddleware.Factory> buildTimeMiddlewareFactories = new HashSet<>(this.middlewareFactories);
       FlightClient client = null;
+
       try {
         ClientIncomingAuthHeaderMiddleware.Factory authFactory = null;
         // Token should take priority since some apps pass in a username/password even when a token is provided
         if (username != null && token == null) {
           authFactory =
               new ClientIncomingAuthHeaderMiddleware.Factory(new ClientBearerHeaderHandler());
-          withMiddlewareFactories(authFactory);
+          buildTimeMiddlewareFactories.add(authFactory);
         }
         final FlightClient.Builder clientBuilder = FlightClient.builder().allocator(allocator);
-        withMiddlewareFactories(new ClientCookieMiddleware.Factory());
-        middlewareFactories.forEach(clientBuilder::intercept);
+
+        buildTimeMiddlewareFactories.add(new ClientCookieMiddleware.Factory());
+        buildTimeMiddlewareFactories.forEach(clientBuilder::intercept);
         Location location;
         if (useEncryption) {
           location = Location.forGrpcTls(host, port);
@@ -571,17 +651,18 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
         }
 
         client = clientBuilder.build();
+        final ArrayList<CallOption> credentialOptions = new ArrayList<>();
         if (authFactory != null) {
-          options.add(
+          credentialOptions.add(
               ClientAuthenticationUtils.getAuthenticate(
                       client, username, password, authFactory, options.toArray(new CallOption[0])));
         } else if (token != null) {
-          options.add(
+          credentialOptions.add(
               ClientAuthenticationUtils.getAuthenticate(
                   client, new CredentialCallOption(new BearerCredentialWriter(token)), options.toArray(
                           new CallOption[0])));
         }
-        return ArrowFlightSqlClientHandler.createNewHandler(client, options);
+        return ArrowFlightSqlClientHandler.createNewHandler(client, this, credentialOptions);
 
       } catch (final IllegalArgumentException | GeneralSecurityException | IOException | FlightRuntimeException e) {
         final SQLException originalException = new SQLException(e);
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/CloseableEndpointStreamPair.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/CloseableEndpointStreamPair.java
new file mode 100644
index 0000000000000..6c37a5b0c626c
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/CloseableEndpointStreamPair.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc.client;
+
+import org.apache.arrow.flight.FlightStream;
+import org.apache.arrow.flight.sql.FlightSqlClient;
+import org.apache.arrow.util.AutoCloseables;
+import org.apache.arrow.util.Preconditions;
+
+/**
+ * Represents a connection to a {@link org.apache.arrow.flight.FlightEndpoint}.
+ */
+public class CloseableEndpointStreamPair implements AutoCloseable {
+
+  private final FlightStream stream;
+  private final FlightSqlClient client;
+
+  public CloseableEndpointStreamPair(FlightStream stream, FlightSqlClient client) {
+    this.stream = Preconditions.checkNotNull(stream);
+    this.client = client;
+  }
+
+  public FlightStream getStream() {
+    return stream;
+  }
+
+  @Override
+  public void close() throws Exception {
+    AutoCloseables.close(stream, client);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueue.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
similarity index 73%
rename from java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueue.java
rename to java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
index e1d770800e40c..71cafd2ec3075 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueue.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
@@ -36,6 +36,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import org.apache.arrow.driver.jdbc.client.CloseableEndpointStreamPair;
 import org.apache.arrow.flight.CallStatus;
 import org.apache.arrow.flight.FlightRuntimeException;
 import org.apache.arrow.flight.FlightStream;
@@ -55,28 +56,28 @@
  *   <li>Repeat from (3) until <code>next()</code> returns null.</li>
  * </ol>
  */
-public class FlightStreamQueue implements AutoCloseable {
-  private static final Logger LOGGER = LoggerFactory.getLogger(FlightStreamQueue.class);
-  private final CompletionService<FlightStream> completionService;
-  private final Set<Future<FlightStream>> futures = synchronizedSet(new HashSet<>());
-  private final Set<FlightStream> allStreams = synchronizedSet(new HashSet<>());
+public class FlightEndpointDataQueue implements AutoCloseable {
+  private static final Logger LOGGER = LoggerFactory.getLogger(FlightEndpointDataQueue.class);
+  private final CompletionService<CloseableEndpointStreamPair> completionService;
+  private final Set<Future<CloseableEndpointStreamPair>> futures = synchronizedSet(new HashSet<>());
+  private final Set<CloseableEndpointStreamPair> endpointsToClose = synchronizedSet(new HashSet<>());
   private final AtomicBoolean closed = new AtomicBoolean();
 
   /**
    * Instantiate a new FlightStreamQueue.
    */
-  protected FlightStreamQueue(final CompletionService<FlightStream> executorService) {
+  protected FlightEndpointDataQueue(final CompletionService<CloseableEndpointStreamPair> executorService) {
     completionService = checkNotNull(executorService);
   }
 
   /**
-   * Creates a new {@link FlightStreamQueue} from the provided {@link ExecutorService}.
+   * Creates a new {@link FlightEndpointDataQueue} from the provided {@link ExecutorService}.
    *
    * @param service the service from which to create a new queue.
    * @return a new queue.
    */
-  public static FlightStreamQueue createNewQueue(final ExecutorService service) {
-    return new FlightStreamQueue(new ExecutorCompletionService<>(service));
+  public static FlightEndpointDataQueue createNewQueue(final ExecutorService service) {
+    return new FlightEndpointDataQueue(new ExecutorCompletionService<>(service));
   }
 
   /**
@@ -92,19 +93,21 @@ public boolean isClosed() {
    * Auxiliary functional interface for getting ready-to-consume FlightStreams.
    */
   @FunctionalInterface
-  interface FlightStreamSupplier {
-    Future<FlightStream> get() throws SQLException;
+  interface EndpointStreamSupplier {
+    Future<CloseableEndpointStreamPair> get() throws SQLException;
   }
 
-  private FlightStream next(final FlightStreamSupplier flightStreamSupplier) throws SQLException {
+  private CloseableEndpointStreamPair next(final EndpointStreamSupplier endpointStreamSupplier) throws SQLException {
     checkOpen();
     while (!futures.isEmpty()) {
-      final Future<FlightStream> future = flightStreamSupplier.get();
+      final Future<CloseableEndpointStreamPair> future = endpointStreamSupplier.get();
       futures.remove(future);
       try {
-        final FlightStream stream = future.get();
-        if (stream.getRoot().getRowCount() > 0) {
-          return stream;
+        final CloseableEndpointStreamPair endpoint = future.get();
+        // Get the next FlightStream with content.
+        // The stream is non-empty.
+        if (endpoint.getStream().getRoot().getRowCount() > 0) {
+          return endpoint;
         }
       } catch (final ExecutionException | InterruptedException | CancellationException e) {
         throw AvaticaConnection.HELPER.wrap(e.getMessage(), e);
@@ -120,11 +123,11 @@ private FlightStream next(final FlightStreamSupplier flightStreamSupplier) throw
    * @param timeoutUnit  the timeoutValue time unit
    * @return a FlightStream that is ready to consume or null if all FlightStreams are ended.
    */
-  public FlightStream next(final long timeoutValue, final TimeUnit timeoutUnit)
+  public CloseableEndpointStreamPair next(final long timeoutValue, final TimeUnit timeoutUnit)
       throws SQLException {
     return next(() -> {
       try {
-        final Future<FlightStream> future = completionService.poll(timeoutValue, timeoutUnit);
+        final Future<CloseableEndpointStreamPair> future = completionService.poll(timeoutValue, timeoutUnit);
         if (future != null) {
           return future;
         }
@@ -142,7 +145,7 @@ public FlightStream next(final long timeoutValue, final TimeUnit timeoutUnit)
    *
    * @return a FlightStream that is ready to consume or null if all FlightStreams are ended.
    */
-  public FlightStream next() throws SQLException {
+  public CloseableEndpointStreamPair next() throws SQLException {
     return next(() -> {
       try {
         return completionService.take();
@@ -162,21 +165,21 @@ public synchronized void checkOpen() {
   /**
    * Readily adds given {@link FlightStream}s to the queue.
    */
-  public void enqueue(final Collection<FlightStream> flightStreams) {
-    flightStreams.forEach(this::enqueue);
+  public void enqueue(final Collection<CloseableEndpointStreamPair> endpointRequests) {
+    endpointRequests.forEach(this::enqueue);
   }
 
   /**
    * Adds given {@link FlightStream} to the queue.
    */
-  public synchronized void enqueue(final FlightStream flightStream) {
-    checkNotNull(flightStream);
+  public synchronized void enqueue(final CloseableEndpointStreamPair endpointRequest) {
+    checkNotNull(endpointRequest);
     checkOpen();
-    allStreams.add(flightStream);
+    endpointsToClose.add(endpointRequest);
     futures.add(completionService.submit(() -> {
       // `FlightStream#next` will block until new data can be read or stream is over.
-      flightStream.next();
-      return flightStream;
+      endpointRequest.getStream().next();
+      return endpointRequest;
     }));
   }
 
@@ -187,14 +190,15 @@ private static boolean isCallStatusCancelled(final Exception e) {
 
   @Override
   public synchronized void close() throws SQLException {
-    final Set<SQLException> exceptions = new HashSet<>();
     if (isClosed()) {
       return;
     }
+
+    final Set<SQLException> exceptions = new HashSet<>();
     try {
-      for (final FlightStream flightStream : allStreams) {
+      for (final CloseableEndpointStreamPair endpointToClose : endpointsToClose) {
         try {
-          flightStream.cancel("Cancelling this FlightStream.", null);
+          endpointToClose.getStream().cancel("Cancelling this FlightStream.", null);
         } catch (final Exception e) {
           final String errorMsg = "Failed to cancel a FlightStream.";
           LOGGER.error(errorMsg, e);
@@ -214,9 +218,9 @@ public synchronized void close() throws SQLException {
           }
         }
       });
-      for (final FlightStream flightStream : allStreams) {
+      for (final CloseableEndpointStreamPair endpointToClose : endpointsToClose) {
         try {
-          flightStream.close();
+          endpointToClose.close();
         } catch (final Exception e) {
           final String errorMsg = "Failed to close a FlightStream.";
           LOGGER.error(errorMsg, e);
@@ -224,7 +228,7 @@ public synchronized void close() throws SQLException {
         }
       }
     } finally {
-      allStreams.clear();
+      endpointsToClose.clear();
       futures.clear();
       closed.set(true);
     }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
index b3002ec58416e..e2ac100b8dc36 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
@@ -19,6 +19,7 @@
 
 import static java.lang.String.format;
 import static java.util.Collections.synchronizedSet;
+import static org.apache.arrow.flight.Location.forGrpcInsecure;
 import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.anyOf;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -29,16 +30,32 @@
 import static org.junit.Assert.fail;
 
 import java.sql.Connection;
+import java.sql.DriverManager;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.SQLTimeoutException;
 import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Random;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 
 import org.apache.arrow.driver.jdbc.utils.CoreMockedSqlProducers;
+import org.apache.arrow.driver.jdbc.utils.PartitionedFlightSqlProducer;
+import org.apache.arrow.flight.FlightEndpoint;
+import org.apache.arrow.flight.FlightProducer;
+import org.apache.arrow.flight.FlightServer;
+import org.apache.arrow.flight.Ticket;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
@@ -144,9 +161,10 @@ public void testShouldRunSelectQuerySettingMaxRowLimit() throws Exception {
   @Test(expected = SQLException.class)
   public void testShouldThrowExceptionUponAttemptingToExecuteAnInvalidSelectQuery()
       throws Exception {
-    Statement statement = connection.createStatement();
-    statement.executeQuery("SELECT * FROM SHOULD-FAIL");
-    fail();
+    try (Statement statement = connection.createStatement();
+         ResultSet result = statement.executeQuery("SELECT * FROM SHOULD-FAIL")) {
+      fail();
+    }
   }
 
   /**
@@ -200,14 +218,15 @@ public void testColumnCountShouldRemainConsistentForResultSetThroughoutEntireDur
    */
   @Test
   public void testShouldCloseStatementWhenIsCloseOnCompletion() throws Exception {
-    Statement statement = connection.createStatement();
-    ResultSet resultSet = statement.executeQuery(CoreMockedSqlProducers.LEGACY_REGULAR_SQL_CMD);
+    try (Statement statement = connection.createStatement();
+        ResultSet resultSet = statement.executeQuery(CoreMockedSqlProducers.LEGACY_REGULAR_SQL_CMD)) {
 
-    statement.closeOnCompletion();
+      statement.closeOnCompletion();
 
-    resultSetNextUntilDone(resultSet);
+      resultSetNextUntilDone(resultSet);
 
-    collector.checkThat(statement.isClosed(), is(true));
+      collector.checkThat(statement.isClosed(), is(true));
+    }
   }
 
   /**
@@ -368,9 +387,72 @@ public void testFlightStreamsQueryShouldNotTimeout() throws SQLException {
     final int timeoutValue = 5;
     try (Statement statement = connection.createStatement()) {
       statement.setQueryTimeout(timeoutValue);
-      ResultSet resultSet = statement.executeQuery(query);
-      CoreMockedSqlProducers.assertLegacyRegularSqlResultSet(resultSet, collector);
-      resultSet.close();
+      try (ResultSet resultSet = statement.executeQuery(query)) {
+        CoreMockedSqlProducers.assertLegacyRegularSqlResultSet(resultSet, collector);
+      }
+    }
+  }
+
+  @Test
+  public void testPartitionedFlightServer() throws Exception {
+    // Arrange
+    final Schema schema = new Schema(
+        Arrays.asList(Field.nullablePrimitive("int_column", new ArrowType.Int(32, true))));
+    try (BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE);
+        VectorSchemaRoot firstPartition = VectorSchemaRoot.create(schema, allocator);
+        VectorSchemaRoot secondPartition = VectorSchemaRoot.create(schema, allocator)) {
+      firstPartition.setRowCount(1);
+      ((IntVector) firstPartition.getVector(0)).set(0, 1);
+      secondPartition.setRowCount(1);
+      ((IntVector) secondPartition.getVector(0)).set(0, 2);
+
+      // Construct the data-only nodes first.
+      FlightProducer firstProducer = new PartitionedFlightSqlProducer.DataOnlyFlightSqlProducer(
+          new Ticket("first".getBytes()), firstPartition);
+      FlightProducer secondProducer = new PartitionedFlightSqlProducer.DataOnlyFlightSqlProducer(
+          new Ticket("second".getBytes()), secondPartition);
+
+      final FlightServer.Builder firstBuilder = FlightServer.builder(
+          allocator, forGrpcInsecure("localhost", 0), firstProducer);
+
+      final FlightServer.Builder secondBuilder = FlightServer.builder(
+          allocator, forGrpcInsecure("localhost", 0), secondProducer);
+
+      // Run the data-only nodes so that we can get the Locations they are running at.
+      try (FlightServer firstServer = firstBuilder.build();
+           FlightServer secondServer = secondBuilder.build()) {
+        firstServer.start();
+        secondServer.start();
+        final FlightEndpoint firstEndpoint =
+            new FlightEndpoint(new Ticket("first".getBytes()), firstServer.getLocation());
+
+        final FlightEndpoint secondEndpoint =
+            new FlightEndpoint(new Ticket("second".getBytes()), secondServer.getLocation());
+
+        // Finally start the root node.
+        try (final PartitionedFlightSqlProducer rootProducer = new PartitionedFlightSqlProducer(
+            schema, firstEndpoint, secondEndpoint);
+             FlightServer rootServer = FlightServer.builder(
+                 allocator, forGrpcInsecure("localhost", 0), rootProducer)
+                 .build()
+                 .start();
+             Connection newConnection = DriverManager.getConnection(String.format(
+                 "jdbc:arrow-flight-sql://%s:%d/?useEncryption=false",
+                 rootServer.getLocation().getUri().getHost(), rootServer.getPort()));
+             Statement newStatement = newConnection.createStatement();
+             // Act
+             ResultSet result = newStatement.executeQuery("Select partitioned_data")) {
+          List<Integer> resultData = new ArrayList<>();
+          while (result.next()) {
+            resultData.add(result.getInt(1));
+          }
+
+          // Assert
+          assertEquals(firstPartition.getRowCount() + secondPartition.getRowCount(), resultData.size());
+          assertTrue(resultData.contains(((IntVector) firstPartition.getVector(0)).get(0)));
+          assertTrue(resultData.contains(((IntVector) secondPartition.getVector(0)).get(0)));
+        }
+      }
     }
   }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueueTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueueTest.java
similarity index 85%
rename from java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueueTest.java
rename to java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueueTest.java
index b474da55a7f1f..05325faa18ef3 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightStreamQueueTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueueTest.java
@@ -23,7 +23,7 @@
 
 import java.util.concurrent.CompletionService;
 
-import org.apache.arrow.flight.FlightStream;
+import org.apache.arrow.driver.jdbc.client.CloseableEndpointStreamPair;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -33,20 +33,20 @@
 import org.mockito.junit.MockitoJUnitRunner;
 
 /**
- * Tests for {@link FlightStreamQueue}.
+ * Tests for {@link FlightEndpointDataQueue}.
  */
 @RunWith(MockitoJUnitRunner.class)
-public class FlightStreamQueueTest {
+public class FlightEndpointDataQueueTest {
 
   @Rule
   public final ErrorCollector collector = new ErrorCollector();
   @Mock
-  private CompletionService<FlightStream> mockedService;
-  private FlightStreamQueue queue;
+  private CompletionService<CloseableEndpointStreamPair> mockedService;
+  private FlightEndpointDataQueue queue;
 
   @Before
   public void setUp() {
-    queue = new FlightStreamQueue(mockedService);
+    queue = new FlightEndpointDataQueue(mockedService);
   }
 
   @Test
@@ -64,7 +64,7 @@ public void testNextShouldThrowExceptionUponClose() throws Exception {
   public void testEnqueueShouldThrowExceptionUponClose() throws Exception {
     queue.close();
     ThrowableAssertionUtils.simpleAssertThrowableClass(IllegalStateException.class,
-        () -> queue.enqueue(mock(FlightStream.class)));
+        () -> queue.enqueue(mock(CloseableEndpointStreamPair.class)));
   }
 
   @Test
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/PartitionedFlightSqlProducer.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/PartitionedFlightSqlProducer.java
new file mode 100644
index 0000000000000..3230ce626fac6
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/PartitionedFlightSqlProducer.java
@@ -0,0 +1,115 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc.utils;
+
+import static com.google.protobuf.Any.pack;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.arrow.flight.CallStatus;
+import org.apache.arrow.flight.FlightDescriptor;
+import org.apache.arrow.flight.FlightEndpoint;
+import org.apache.arrow.flight.FlightInfo;
+import org.apache.arrow.flight.NoOpFlightProducer;
+import org.apache.arrow.flight.Result;
+import org.apache.arrow.flight.Ticket;
+import org.apache.arrow.flight.sql.BasicFlightSqlProducer;
+import org.apache.arrow.flight.sql.impl.FlightSql;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.types.pojo.Schema;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Message;
+
+public class PartitionedFlightSqlProducer extends BasicFlightSqlProducer {
+
+  /**
+   * A minimal FlightProducer intended to just serve data when given the correct Ticket.
+   */
+  public static class DataOnlyFlightSqlProducer extends NoOpFlightProducer {
+    private final Ticket ticket;
+    private final VectorSchemaRoot data;
+
+    public DataOnlyFlightSqlProducer(Ticket ticket, VectorSchemaRoot data) {
+      this.ticket = ticket;
+      this.data = data;
+    }
+
+    @Override
+    public void getStream(CallContext context, Ticket ticket, ServerStreamListener listener) {
+      if (!Arrays.equals(ticket.getBytes(), this.ticket.getBytes())) {
+        listener.error(CallStatus.INVALID_ARGUMENT.withDescription("Illegal ticket.").toRuntimeException());
+        return;
+      }
+
+      listener.start(data);
+      listener.putNext();
+      listener.completed();
+    }
+  }
+
+  private final List<FlightEndpoint> endpoints;
+
+  private final Schema schema;
+
+  public PartitionedFlightSqlProducer(Schema schema, FlightEndpoint... endpoints) {
+    this.schema = schema;
+    this.endpoints = Arrays.asList(endpoints);
+  }
+
+  @Override
+  protected <T extends Message> List<FlightEndpoint> determineEndpoints(
+      T request, FlightDescriptor flightDescriptor, Schema schema) {
+    return endpoints;
+  }
+
+  @Override
+  public void createPreparedStatement(FlightSql.ActionCreatePreparedStatementRequest request,
+                                      CallContext context, StreamListener<Result> listener) {
+    final FlightSql.ActionCreatePreparedStatementResult.Builder resultBuilder =
+        FlightSql.ActionCreatePreparedStatementResult.newBuilder()
+            .setPreparedStatementHandle(ByteString.EMPTY);
+
+    final ByteString datasetSchemaBytes = ByteString.copyFrom(schema.serializeAsMessage());
+
+    resultBuilder.setDatasetSchema(datasetSchemaBytes);
+    listener.onNext(new Result(pack(resultBuilder.build()).toByteArray()));
+    listener.onCompleted();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoStatement(
+      FlightSql.CommandStatementQuery command, CallContext context, FlightDescriptor descriptor) {
+    return FlightInfo.builder(schema, descriptor, endpoints).build();
+  }
+
+  @Override
+  public FlightInfo getFlightInfoPreparedStatement(FlightSql.CommandPreparedStatementQuery command,
+                                                   CallContext context, FlightDescriptor descriptor) {
+    return FlightInfo.builder(schema, descriptor, endpoints).build();
+  }
+
+  @Override
+  public void closePreparedStatement(FlightSql.ActionClosePreparedStatementRequest request,
+                                     CallContext context, StreamListener<Result> listener) {
+    listener.onCompleted();
+  }
+
+  // Note -- getStream() is intentionally not implemented.
+}

From d4deb36a13711bc4069750658bb8822cc9f68f86 Mon Sep 17 00:00:00 2001
From: Pierre Moulon <pmoulon@gmail.com>
Date: Fri, 3 Nov 2023 14:12:19 -0700
Subject: [PATCH 675/749] MINOR: [Docs][C++] Fix a typo (#38568)

### Rationale for this change

Noticed a typo on the web doc and proposing here a fix

### Are these changes tested?

No. But the PR is changing only text.

### Are there any user-facing changes?

Yes. But only documentation typo

Authored-by: Pierre Moulon <pmoulon@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/cpp/examples/compute_and_write_example.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/examples/compute_and_write_example.rst b/docs/source/cpp/examples/compute_and_write_example.rst
index 096b97b837e05..c4480a5f5cdf1 100644
--- a/docs/source/cpp/examples/compute_and_write_example.rst
+++ b/docs/source/cpp/examples/compute_and_write_example.rst
@@ -23,6 +23,6 @@ Compute and Write CSV Example
 
 The file ``cpp/examples/arrow/compute_and_write_csv_example.cc`` located inside 
 the source tree contains an example of creating a table of two numerical columns 
-and then compariong the magnitudes of the entries in the columns and wrting out to 
+and then comparing the magnitudes of the entries in the columns and wrting out to 
 a CSV file with the column entries and their comparisons.  The code in the example
 is documented.

From fc8c6b7dc8287c672b62c62f3a2bd724b3835063 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Sat, 4 Nov 2023 11:01:41 -0600
Subject: [PATCH 676/749] GH-33475: [Java] Add parameter binding for Prepared
 Statements in JDBC driver (#38404)

This PR is a combination of #33961 and #14627. The goal is to support parametrized queries through the Arrow Flight SQL JDBC driver.

An Arrow Flight SQL server returns a Schema for the `PreparedStatement` parameters. The driver then converts the `Field` list associated with the Schema into a list of `AvaticaParameter`. When the user sets values for the parameters, Avatica generates a list of `TypedValue`, which we then bind to each parameter vector. This conversion between Arrow and Avatica is handled by implementations of a `AvaticaParameterConverter` interface for each Arrow type. This interface which provides 2 methods:
- createParameter: Create an `AvaticaParameter` from the given Arrow `Field`.
- bindParameter: Cast the given `TypedValue` and bind it to the `FieldVector` at the specified index.

This PR purposely leaves out a few features:
- We currently naively cast the `TypedValue` values assuming users set the type correctly. If this cast fails, we raise an exception letting the user know that the cast is not supported. This could be improved in subsequent PRs to do smarter conversions from other types.
- We currently don't provide conversions for complex types such as List, Map, Struct, Union, Interval, and Duration. The stubs are there so they can be implemented as needed.
- Tests for specific types have not been implemented. I'm not very familiar with a lot of these JDBC types so it's hard to implement rigorous tets.

* Closes: #33475
* Closes: #35536

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../driver/jdbc/ArrowFlightJdbcFactory.java   |   9 -
 .../ArrowFlightJdbcFlightStreamResultSet.java |   8 +-
 ...owFlightJdbcVectorSchemaRootResultSet.java |  19 +-
 .../driver/jdbc/ArrowFlightMetaImpl.java      |  90 ++++---
 .../jdbc/ArrowFlightPreparedStatement.java    |  33 ---
 .../client/ArrowFlightSqlClientHandler.java   |  20 ++
 .../converter/AvaticaParameterConverter.java  |  42 ++++
 .../impl/BaseAvaticaParameterConverter.java   |  42 ++++
 .../impl/BinaryAvaticaParameterConverter.java |  49 ++++
 .../impl/BoolAvaticaParameterConverter.java   |  49 ++++
 .../impl/DateAvaticaParameterConverter.java   |  53 ++++
 .../DecimalAvaticaParameterConverter.java     |  51 ++++
 .../DurationAvaticaParameterConverter.java    |  43 ++++
 ...edSizeBinaryAvaticaParameterConverter.java |  49 ++++
 ...ixedSizeListAvaticaParameterConverter.java |  43 ++++
 ...loatingPointAvaticaParameterConverter.java |  53 ++++
 .../impl/IntAvaticaParameterConverter.java    |  79 ++++++
 .../IntervalAvaticaParameterConverter.java    |  49 ++++
 .../LargeBinaryAvaticaParameterConverter.java |  49 ++++
 .../LargeListAvaticaParameterConverter.java   |  43 ++++
 .../LargeUtf8AvaticaParameterConverter.java   |  50 ++++
 .../impl/ListAvaticaParameterConverter.java   |  43 ++++
 .../impl/MapAvaticaParameterConverter.java    |  43 ++++
 .../impl/NullAvaticaParameterConverter.java   |  49 ++++
 .../impl/StructAvaticaParameterConverter.java |  43 ++++
 .../impl/TimeAvaticaParameterConverter.java   |  61 +++++
 .../TimestampAvaticaParameterConverter.java   |  78 ++++++
 .../impl/UnionAvaticaParameterConverter.java  |  43 ++++
 .../impl/Utf8AvaticaParameterConverter.java   |  50 ++++
 .../jdbc/utils/AvaticaParameterBinder.java    | 233 ++++++++++++++++++
 .../arrow/driver/jdbc/utils/ConvertUtils.java | 154 +++++++++++-
 .../ArrowFlightPreparedStatementTest.java     |  80 ++++++
 .../jdbc/utils/MockFlightSqlProducer.java     |  81 +++++-
 .../arrow/flight/sql/FlightSqlClient.java     |  42 ++--
 34 files changed, 1809 insertions(+), 114 deletions(-)
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BaseAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BinaryAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BoolAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DateAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DecimalAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DurationAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeBinaryAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeListAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FloatingPointAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntervalAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeBinaryAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeListAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeUtf8AvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/ListAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/MapAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/NullAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/StructAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimeAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/UnionAvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/Utf8AvaticaParameterConverter.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFactory.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFactory.java
index 216e4cd002bc3..16bdede02d039 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFactory.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFactory.java
@@ -17,8 +17,6 @@
 
 package org.apache.arrow.driver.jdbc;
 
-import static org.apache.arrow.driver.jdbc.utils.ConvertUtils.convertArrowFieldsToColumnMetaDataList;
-
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.util.Properties;
@@ -26,7 +24,6 @@
 
 import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler;
 import org.apache.arrow.memory.RootAllocator;
-import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.AvaticaConnection;
 import org.apache.calcite.avatica.AvaticaFactory;
 import org.apache.calcite.avatica.AvaticaResultSetMetaData;
@@ -89,12 +86,6 @@ public ArrowFlightPreparedStatement newPreparedStatement(
     ArrowFlightSqlClientHandler.PreparedStatement preparedStatement =
         flightConnection.getMeta().getPreparedStatement(statementHandle);
 
-    if (preparedStatement == null) {
-      preparedStatement = flightConnection.getClientHandler().prepare(signature.sql);
-    }
-    final Schema resultSetSchema = preparedStatement.getDataSetSchema();
-    signature.columns.addAll(convertArrowFieldsToColumnMetaDataList(resultSetSchema.getFields()));
-
     return ArrowFlightPreparedStatement.newPreparedStatement(
         flightConnection, preparedStatement, statementHandle,
         signature, resultType, resultSetConcurrency, resultSetHoldability);
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
index 2e42cf0166b06..e23267ebe9ebf 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcFlightStreamResultSet.java
@@ -93,7 +93,7 @@ static ArrowFlightJdbcFlightStreamResultSet fromFlightInfo(
     final TimeZone timeZone = TimeZone.getDefault();
     final QueryState state = new QueryState();
 
-    final Meta.Signature signature = ArrowFlightMetaImpl.newSignature(null);
+    final Meta.Signature signature = ArrowFlightMetaImpl.newSignature(null, null, null);
 
     final AvaticaResultSetMetaData resultSetMetaData =
         new AvaticaResultSetMetaData(null, null, signature);
@@ -154,11 +154,7 @@ private void populateDataForCurrentFlightStream() throws SQLException {
       currentVectorSchemaRoot = originalRoot;
     }
 
-    if (schema != null) {
-      populateData(currentVectorSchemaRoot, schema);
-    } else {
-      populateData(currentVectorSchemaRoot);
-    }
+    populateData(currentVectorSchemaRoot, schema);
   }
 
   @Override
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
index 20a2af6a84aa4..626ae95bc5bbe 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightJdbcVectorSchemaRootResultSet.java
@@ -17,20 +17,18 @@
 
 package org.apache.arrow.driver.jdbc;
 
-import static java.util.Objects.isNull;
-
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.TimeZone;
 
 import org.apache.arrow.driver.jdbc.utils.ConvertUtils;
 import org.apache.arrow.util.AutoCloseables;
 import org.apache.arrow.vector.VectorSchemaRoot;
-import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.AvaticaResultSet;
 import org.apache.calcite.avatica.AvaticaResultSetMetaData;
@@ -74,7 +72,7 @@ public static ArrowFlightJdbcVectorSchemaRootResultSet fromVectorSchemaRoot(
     final TimeZone timeZone = TimeZone.getDefault();
     final QueryState state = new QueryState();
 
-    final Meta.Signature signature = ArrowFlightMetaImpl.newSignature(null);
+    final Meta.Signature signature = ArrowFlightMetaImpl.newSignature(null, null, null);
 
     final AvaticaResultSetMetaData resultSetMetaData =
         new AvaticaResultSetMetaData(null, null, signature);
@@ -93,17 +91,12 @@ protected AvaticaResultSet execute() throws SQLException {
   }
 
   void populateData(final VectorSchemaRoot vectorSchemaRoot) {
-    final List<Field> fields = vectorSchemaRoot.getSchema().getFields();
-    final List<ColumnMetaData> columns = ConvertUtils.convertArrowFieldsToColumnMetaDataList(fields);
-    signature.columns.clear();
-    signature.columns.addAll(columns);
-
-    this.vectorSchemaRoot = vectorSchemaRoot;
-    execute2(new ArrowFlightJdbcCursor(vectorSchemaRoot), this.signature.columns);
+    populateData(vectorSchemaRoot, null);
   }
 
   void populateData(final VectorSchemaRoot vectorSchemaRoot, final Schema schema) {
-    final List<ColumnMetaData> columns = ConvertUtils.convertArrowFieldsToColumnMetaDataList(schema.getFields());
+    Schema currentSchema = schema == null ? vectorSchemaRoot.getSchema() : schema;
+    final List<ColumnMetaData> columns = ConvertUtils.convertArrowFieldsToColumnMetaDataList(currentSchema.getFields());
     signature.columns.clear();
     signature.columns.addAll(columns);
 
@@ -137,7 +130,7 @@ public void close() {
     } catch (final Exception e) {
       exceptions.add(e);
     }
-    if (!isNull(statement)) {
+    if (!Objects.isNull(statement)) {
       try {
         super.close();
       } catch (final Exception e) {
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightMetaImpl.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightMetaImpl.java
index f825e7d13cef5..382750914992f 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightMetaImpl.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightMetaImpl.java
@@ -17,8 +17,6 @@
 
 package org.apache.arrow.driver.jdbc;
 
-import static java.lang.String.format;
-
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.sql.SQLTimeoutException;
@@ -29,7 +27,10 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler.PreparedStatement;
+import org.apache.arrow.driver.jdbc.utils.AvaticaParameterBinder;
+import org.apache.arrow.driver.jdbc.utils.ConvertUtils;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.AvaticaConnection;
 import org.apache.calcite.avatica.AvaticaParameter;
 import org.apache.calcite.avatica.ColumnMetaData;
@@ -54,12 +55,20 @@ public ArrowFlightMetaImpl(final AvaticaConnection connection) {
     setDefaultConnectionProperties();
   }
 
-  static Signature newSignature(final String sql) {
+  /**
+   * Construct a signature.
+   */
+  static Signature newSignature(final String sql, Schema resultSetSchema, Schema parameterSchema) {
+    List<ColumnMetaData> columnMetaData = resultSetSchema == null ?
+            new ArrayList<>() : ConvertUtils.convertArrowFieldsToColumnMetaDataList(resultSetSchema.getFields());
+    List<AvaticaParameter> parameters = parameterSchema == null ?
+            new ArrayList<>() : ConvertUtils.convertArrowFieldsToAvaticaParameters(parameterSchema.getFields());
+
     return new Signature(
-        new ArrayList<ColumnMetaData>(),
+        columnMetaData,
         sql,
-        Collections.<AvaticaParameter>emptyList(),
-        Collections.<String, Object>emptyMap(),
+        parameters,
+        Collections.emptyMap(),
         null, // unnecessary, as SQL requests use ArrowFlightJdbcCursor
         StatementType.SELECT
     );
@@ -84,23 +93,28 @@ public void commit(final ConnectionHandle connectionHandle) {
   public ExecuteResult execute(final StatementHandle statementHandle,
                                final List<TypedValue> typedValues, final long maxRowCount) {
     Preconditions.checkArgument(connection.id.equals(statementHandle.connectionId),
-        "Connection IDs are not consistent");
+            "Connection IDs are not consistent");
+    PreparedStatement preparedStatement = getPreparedStatement(statementHandle);
+
+    if (preparedStatement == null) {
+      throw new IllegalStateException("Prepared statement not found: " + statementHandle);
+    }
+
+
+    new AvaticaParameterBinder(preparedStatement, ((ArrowFlightConnection) connection).getBufferAllocator())
+            .bind(typedValues);
+
     if (statementHandle.signature == null) {
       // Update query
-      final StatementHandleKey key = new StatementHandleKey(statementHandle);
-      PreparedStatement preparedStatement = statementHandlePreparedStatementMap.get(key);
-      if (preparedStatement == null) {
-        throw new IllegalStateException("Prepared statement not found: " + statementHandle);
-      }
       long updatedCount = preparedStatement.executeUpdate();
       return new ExecuteResult(Collections.singletonList(MetaResultSet.count(statementHandle.connectionId,
-          statementHandle.id, updatedCount)));
+              statementHandle.id, updatedCount)));
     } else {
       // TODO Why is maxRowCount ignored?
       return new ExecuteResult(
-          Collections.singletonList(MetaResultSet.create(
-              statementHandle.connectionId, statementHandle.id,
-              true, statementHandle.signature, null)));
+              Collections.singletonList(MetaResultSet.create(
+                      statementHandle.connectionId, statementHandle.id,
+                      true, statementHandle.signature, null)));
     }
   }
 
@@ -114,7 +128,23 @@ public ExecuteResult execute(final StatementHandle statementHandle,
   public ExecuteBatchResult executeBatch(final StatementHandle statementHandle,
                                          final List<List<TypedValue>> parameterValuesList)
       throws IllegalStateException {
-    throw new IllegalStateException("executeBatch not implemented.");
+    Preconditions.checkArgument(connection.id.equals(statementHandle.connectionId),
+            "Connection IDs are not consistent");
+    PreparedStatement preparedStatement = getPreparedStatement(statementHandle);
+
+    if (preparedStatement == null) {
+      throw new IllegalStateException("Prepared statement not found: " + statementHandle);
+    }
+
+    final AvaticaParameterBinder binder = new AvaticaParameterBinder(preparedStatement,
+            ((ArrowFlightConnection) connection).getBufferAllocator());
+    for (int i = 0; i < parameterValuesList.size(); i++) {
+      binder.bind(parameterValuesList.get(i), i);
+    }
+
+    // Update query
+    long[] updatedCounts = {preparedStatement.executeUpdate()};
+    return new ExecuteBatchResult(updatedCounts);
   }
 
   @Override
@@ -126,18 +156,24 @@ public Frame fetch(final StatementHandle statementHandle, final long offset,
      * the results.
      */
     throw AvaticaConnection.HELPER.wrap(
-        format("%s does not use frames.", this),
+        String.format("%s does not use frames.", this),
         AvaticaConnection.HELPER.unsupported());
   }
 
+  private PreparedStatement prepareForHandle(final String query, StatementHandle handle) {
+    final PreparedStatement preparedStatement =
+        ((ArrowFlightConnection) connection).getClientHandler().prepare(query);
+    handle.signature = newSignature(query, preparedStatement.getDataSetSchema(),
+            preparedStatement.getParameterSchema());
+    statementHandlePreparedStatementMap.put(new StatementHandleKey(handle), preparedStatement);
+    return preparedStatement;
+  }
+
   @Override
   public StatementHandle prepare(final ConnectionHandle connectionHandle,
                                  final String query, final long maxRowCount) {
     final StatementHandle handle = super.createStatement(connectionHandle);
-    handle.signature = newSignature(query);
-    final PreparedStatement preparedStatement =
-        ((ArrowFlightConnection) connection).getClientHandler().prepare(query);
-    statementHandlePreparedStatementMap.put(new StatementHandleKey(handle), preparedStatement);
+    prepareForHandle(query, handle);
     return handle;
   }
 
@@ -157,20 +193,18 @@ public ExecuteResult prepareAndExecute(final StatementHandle handle,
                                          final PrepareCallback callback)
       throws NoSuchStatementException {
     try {
-      final PreparedStatement preparedStatement =
-          ((ArrowFlightConnection) connection).getClientHandler().prepare(query);
+      PreparedStatement preparedStatement = prepareForHandle(query, handle);
       final StatementType statementType = preparedStatement.getType();
-      statementHandlePreparedStatementMap.put(new StatementHandleKey(handle), preparedStatement);
-      final Signature signature = newSignature(query);
+
       final long updateCount =
           statementType.equals(StatementType.UPDATE) ? preparedStatement.executeUpdate() : -1;
       synchronized (callback.getMonitor()) {
         callback.clear();
-        callback.assign(signature, null, updateCount);
+        callback.assign(handle.signature, null, updateCount);
       }
       callback.execute();
       final MetaResultSet metaResultSet = MetaResultSet.create(handle.connectionId, handle.id,
-          false, signature, null);
+          false, handle.signature, null);
       return new ExecuteResult(Collections.singletonList(metaResultSet));
     } catch (SQLTimeoutException e) {
       // So far AvaticaStatement(executeInternal) only handles NoSuchStatement and Runtime Exceptions.
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatement.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatement.java
index 8784e39840b6a..7203f02daa9a1 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatement.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatement.java
@@ -17,15 +17,12 @@
 
 package org.apache.arrow.driver.jdbc;
 
-import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 
 import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler;
-import org.apache.arrow.driver.jdbc.utils.ConvertUtils;
 import org.apache.arrow.flight.FlightInfo;
 import org.apache.arrow.util.Preconditions;
-import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.AvaticaPreparedStatement;
 import org.apache.calcite.avatica.Meta.Signature;
 import org.apache.calcite.avatica.Meta.StatementHandle;
@@ -50,36 +47,6 @@ private ArrowFlightPreparedStatement(final ArrowFlightConnection connection,
     this.preparedStatement = Preconditions.checkNotNull(preparedStatement);
   }
 
-  /**
-   * Creates a new {@link ArrowFlightPreparedStatement} from the provided information.
-   *
-   * @param connection           the {@link Connection} to use.
-   * @param statementHandle      the {@link StatementHandle} to use.
-   * @param signature            the {@link Signature} to use.
-   * @param resultSetType        the ResultSet type.
-   * @param resultSetConcurrency the ResultSet concurrency.
-   * @param resultSetHoldability the ResultSet holdability.
-   * @return a new {@link PreparedStatement}.
-   * @throws SQLException on error.
-   */
-  static ArrowFlightPreparedStatement createNewPreparedStatement(
-      final ArrowFlightConnection connection,
-      final StatementHandle statementHandle,
-      final Signature signature,
-      final int resultSetType,
-      final int resultSetConcurrency,
-      final int resultSetHoldability) throws SQLException {
-
-    final ArrowFlightSqlClientHandler.PreparedStatement prepare = connection.getClientHandler().prepare(signature.sql);
-    final Schema resultSetSchema = prepare.getDataSetSchema();
-
-    signature.columns.addAll(ConvertUtils.convertArrowFieldsToColumnMetaDataList(resultSetSchema.getFields()));
-
-    return new ArrowFlightPreparedStatement(
-        connection, prepare, statementHandle,
-        signature, resultSetType, resultSetConcurrency, resultSetHoldability);
-  }
-
   static ArrowFlightPreparedStatement newPreparedStatement(final ArrowFlightConnection connection,
       final ArrowFlightSqlClientHandler.PreparedStatement preparedStmt,
       final StatementHandle statementHandle,
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
index 38e5a9bb362d2..66372092b8e99 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
@@ -49,6 +49,7 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.util.AutoCloseables;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.Meta.StatementType;
 import org.slf4j.Logger;
@@ -206,6 +207,15 @@ public interface PreparedStatement extends AutoCloseable {
      */
     Schema getDataSetSchema();
 
+    /**
+     * Gets the {@link Schema} of the parameters for this {@link PreparedStatement}.
+     *
+     * @return {@link Schema}.
+     */
+    Schema getParameterSchema();
+
+    void setParameters(VectorSchemaRoot parameters);
+
     @Override
     void close();
   }
@@ -241,6 +251,16 @@ public Schema getDataSetSchema() {
         return preparedStatement.getResultSetSchema();
       }
 
+      @Override
+      public Schema getParameterSchema() {
+        return preparedStatement.getParameterSchema();
+      }
+
+      @Override
+      public void setParameters(VectorSchemaRoot parameters) {
+        preparedStatement.setParameters(parameters);
+      }
+
       @Override
       public void close() {
         try {
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
new file mode 100644
index 0000000000000..c01e688f37396
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * Interface for a class in charge of converting between AvaticaParameters and TypedValues and
+ * Arrow.
+ */
+public interface AvaticaParameterConverter {
+
+  /**
+   * Bind a TypedValue to a FieldVector at the given index.
+   *
+   * @param vector FieldVector that the parameter should be bound to.
+   * @param typedValue TypedValue to bind as a parameter.
+   * @param index Vector index that the TypedValue should be bound to.
+   * @return Whether the value was set successfully.
+   */
+  boolean bindParameter(FieldVector vector, TypedValue typedValue, int index);
+
+  AvaticaParameter createParameter(Field field);
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BaseAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BaseAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..f5cf8358b7a14
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BaseAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.driver.jdbc.converter.AvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.utils.SqlTypes;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.SqlType;
+
+/**
+ * Base AvaticaParameterConverter with a generic createParameter method that can be used by most
+ * Arrow types.
+ */
+abstract class BaseAvaticaParameterConverter implements AvaticaParameterConverter {
+  protected AvaticaParameter createParameter(Field field, boolean signed) {
+    final String name = field.getName();
+    final ArrowType arrowType = field.getType();
+    final String typeName = arrowType.toString();
+    final int precision = 0; // Would have to know about the actual number
+    final int scale = 0; // According to https://www.postgresql.org/docs/current/datatype-numeric.html
+    final int jdbcType = SqlTypes.getSqlTypeIdFromArrowType(arrowType);
+    final String className = SqlType.valueOf(jdbcType).clazz.getCanonicalName();
+    return new AvaticaParameter(signed, precision, scale, jdbcType, typeName, className, name);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BinaryAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BinaryAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..d244848955e52
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BinaryAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Binary Arrow types.
+ */
+public class BinaryAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public BinaryAvaticaParameterConverter(ArrowType.Binary type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    byte[] value = (byte[]) typedValue.toJdbc(null);
+    if (vector instanceof VarBinaryVector) {
+      ((VarBinaryVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BoolAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BoolAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..6725154d03c25
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/BoolAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.BitVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Bool Arrow types.
+ */
+public class BoolAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public BoolAvaticaParameterConverter(ArrowType.Bool type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    boolean value = (boolean) typedValue.toLocal();
+    if (vector instanceof BitVector) {
+      ((BitVector) vector).setSafe(index, value ? 1 : 0);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DateAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DateAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..0da1dabe43721
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DateAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.DateDayVector;
+import org.apache.arrow.vector.DateMilliVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Date Arrow types.
+ */
+public class DateAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public DateAvaticaParameterConverter(ArrowType.Date type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    int value = (int) typedValue.toLocal();
+    if (vector instanceof DateMilliVector) {
+      ((DateMilliVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof DateDayVector) {
+      ((DateDayVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DecimalAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DecimalAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..fad43e2e06a76
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DecimalAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import java.math.BigDecimal;
+
+import org.apache.arrow.vector.DecimalVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Decimal Arrow types.
+ */
+public class DecimalAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public DecimalAvaticaParameterConverter(ArrowType.Decimal type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    BigDecimal value = (BigDecimal) typedValue.toLocal();
+    if (vector instanceof DecimalVector) {
+      ((DecimalVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, true);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DurationAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DurationAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..89f2fc1d5c12f
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/DurationAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Duration Arrow types.
+ */
+public class DurationAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public DurationAvaticaParameterConverter(ArrowType.Duration type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeBinaryAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeBinaryAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..a90434f695ac3
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeBinaryAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.FixedSizeBinaryVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for FixedSizeBinary Arrow types.
+ */
+public class FixedSizeBinaryAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public FixedSizeBinaryAvaticaParameterConverter(ArrowType.FixedSizeBinary type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    byte[] value = (byte[]) typedValue.toJdbc(null);
+    if (vector instanceof FixedSizeBinaryVector) {
+      ((FixedSizeBinaryVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeListAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeListAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..60231a2460286
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FixedSizeListAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for FixedSizeList Arrow types.
+ */
+public class FixedSizeListAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public FixedSizeListAvaticaParameterConverter(ArrowType.FixedSizeList type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FloatingPointAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FloatingPointAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..9f305a2b6f20d
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/FloatingPointAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.Float4Vector;
+import org.apache.arrow.vector.Float8Vector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for FloatingPoint Arrow types.
+ */
+public class FloatingPointAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public FloatingPointAvaticaParameterConverter(ArrowType.FloatingPoint type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    Number value = (Number) typedValue.value;
+    if (vector instanceof Float4Vector) {
+      ((Float4Vector) vector).setSafe(index, value.floatValue());
+      return true;
+    } else if (vector instanceof Float8Vector) {
+      ((Float8Vector) vector).setSafe(index, value.doubleValue());
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, true);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..6684e8d32c9a9
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntAvaticaParameterConverter.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.BigIntVector;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.SmallIntVector;
+import org.apache.arrow.vector.TinyIntVector;
+import org.apache.arrow.vector.UInt1Vector;
+import org.apache.arrow.vector.UInt2Vector;
+import org.apache.arrow.vector.UInt4Vector;
+import org.apache.arrow.vector.UInt8Vector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Int Arrow types.
+ */
+public class IntAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+  private final ArrowType.Int type;
+
+  public IntAvaticaParameterConverter(ArrowType.Int type) {
+    this.type = type;
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    Number value = (Number) typedValue.value;
+    if (vector instanceof TinyIntVector) {
+      ((TinyIntVector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof SmallIntVector) {
+      ((SmallIntVector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof IntVector) {
+      ((IntVector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof BigIntVector) {
+      ((BigIntVector) vector).setSafe(index, value.longValue());
+      return true;
+    } else if (vector instanceof UInt1Vector) {
+      ((UInt1Vector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof UInt2Vector) {
+      ((UInt2Vector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof UInt4Vector) {
+      ((UInt4Vector) vector).setSafe(index, value.intValue());
+      return true;
+    } else if (vector instanceof UInt8Vector) {
+      ((UInt8Vector) vector).setSafe(index, value.longValue());
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, type.getIsSigned());
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntervalAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntervalAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..724275d51091e
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/IntervalAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Interval Arrow types.
+ */
+public class IntervalAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public IntervalAvaticaParameterConverter(ArrowType.Interval type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    //    Object value = typedValue.toLocal();
+    //    if (vector instanceof IntervalDayVector) {
+    //      ((IntervalDayVector) vector).setSafe(index, () value);
+    //    } else if (vector instanceof IntervalYearVector) {
+    //      ((IntervalYearVector) vector).setSafe(index, () value);
+    //    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeBinaryAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeBinaryAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..133ec2072d583
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeBinaryAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for LargeBinary Arrow types.
+ */
+public class LargeBinaryAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public LargeBinaryAvaticaParameterConverter(ArrowType.LargeBinary type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    byte[] value = (byte[]) typedValue.toJdbc(null);
+    if (vector instanceof LargeVarBinaryVector) {
+      ((LargeVarBinaryVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeListAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeListAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..6ef6920474860
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeListAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for LargeList Arrow types.
+ */
+public class LargeListAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public LargeListAvaticaParameterConverter(ArrowType.LargeList type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeUtf8AvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeUtf8AvaticaParameterConverter.java
new file mode 100644
index 0000000000000..d412ab007ac67
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/LargeUtf8AvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.LargeVarCharVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.util.Text;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for LargeUtf8 Arrow types.
+ */
+public class LargeUtf8AvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public LargeUtf8AvaticaParameterConverter(ArrowType.LargeUtf8 type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    String value = (String) typedValue.toLocal();
+    if (vector instanceof LargeVarCharVector) {
+      ((LargeVarCharVector) vector).setSafe(index, new Text(value));
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/ListAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/ListAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..aec59cb4d428e
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/ListAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for List Arrow types.
+ */
+public class ListAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public ListAvaticaParameterConverter(ArrowType.List type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/MapAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/MapAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..feac3794d222b
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/MapAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Map Arrow types.
+ */
+public class MapAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public MapAvaticaParameterConverter(ArrowType.Map type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/NullAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/NullAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..e2c184fb11a09
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/NullAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.NullVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Null Arrow types.
+ */
+public class NullAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public NullAvaticaParameterConverter(ArrowType.Null type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    Object value = typedValue.toLocal();
+    if (vector instanceof NullVector) {
+      if (value != null) { throw new RuntimeException("Can't set non-null value on NullVector"); }
+      vector.setNull(index);
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/StructAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/StructAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..5dfe923cb516e
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/StructAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Struct Arrow types.
+ */
+public class StructAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public StructAvaticaParameterConverter(ArrowType.Struct type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimeAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimeAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..c6b79537fd435
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimeAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.TimeMicroVector;
+import org.apache.arrow.vector.TimeMilliVector;
+import org.apache.arrow.vector.TimeNanoVector;
+import org.apache.arrow.vector.TimeSecVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Time Arrow types.
+ */
+public class TimeAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public TimeAvaticaParameterConverter(ArrowType.Time type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    int value = (int) typedValue.toLocal();
+    if (vector instanceof TimeMicroVector) {
+      ((TimeMicroVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeMilliVector) {
+      ((TimeMilliVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeNanoVector) {
+      ((TimeNanoVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeSecVector) {
+      ((TimeSecVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..3c1940b75cfa7
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
@@ -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 org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.TimeStampMicroTZVector;
+import org.apache.arrow.vector.TimeStampMicroVector;
+import org.apache.arrow.vector.TimeStampMilliTZVector;
+import org.apache.arrow.vector.TimeStampMilliVector;
+import org.apache.arrow.vector.TimeStampNanoTZVector;
+import org.apache.arrow.vector.TimeStampNanoVector;
+import org.apache.arrow.vector.TimeStampSecTZVector;
+import org.apache.arrow.vector.TimeStampSecVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Timestamp Arrow types.
+ */
+public class TimestampAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public TimestampAvaticaParameterConverter(ArrowType.Timestamp type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    // FIXME: how should we handle TZ? Do we need to convert the value to the TZ on the vector?
+    long value = (long) typedValue.toLocal();
+    if (vector instanceof TimeStampSecVector) {
+      ((TimeStampSecVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampMicroVector) {
+      ((TimeStampMicroVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampMilliVector) {
+      ((TimeStampMilliVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampNanoVector) {
+      ((TimeStampNanoVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampSecTZVector) {
+      ((TimeStampSecTZVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampMicroTZVector) {
+      ((TimeStampMicroTZVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampMilliTZVector) {
+      ((TimeStampMilliTZVector) vector).setSafe(index, value);
+      return true;
+    } else if (vector instanceof TimeStampNanoTZVector) {
+      ((TimeStampNanoTZVector) vector).setSafe(index, value);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/UnionAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/UnionAvaticaParameterConverter.java
new file mode 100644
index 0000000000000..6b171e685579a
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/UnionAvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Union Arrow types.
+ */
+public class UnionAvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public UnionAvaticaParameterConverter(ArrowType.Union type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/Utf8AvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/Utf8AvaticaParameterConverter.java
new file mode 100644
index 0000000000000..9223e5361d2d5
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/Utf8AvaticaParameterConverter.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.converter.impl;
+
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.util.Text;
+import org.apache.calcite.avatica.AvaticaParameter;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * AvaticaParameterConverter for Utf8 Arrow types.
+ */
+public class Utf8AvaticaParameterConverter extends BaseAvaticaParameterConverter {
+
+  public Utf8AvaticaParameterConverter(ArrowType.Utf8 type) {
+  }
+
+  @Override
+  public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
+    String value = (String) typedValue.toLocal();
+    if (vector instanceof VarCharVector) {
+      ((VarCharVector) vector).setSafe(index, new Text(value));
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public AvaticaParameter createParameter(Field field) {
+    return createParameter(field, false);
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java
new file mode 100644
index 0000000000000..c5be4697db7c5
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc.utils;
+
+import java.util.List;
+
+import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler.PreparedStatement;
+import org.apache.arrow.driver.jdbc.converter.impl.BinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.BoolAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DateAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DecimalAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DurationAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FixedSizeBinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FixedSizeListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FloatingPointAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.IntAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.IntervalAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeBinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeUtf8AvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.ListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.MapAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.NullAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.StructAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.TimeAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.TimestampAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.UnionAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.Utf8AvaticaParameterConverter;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.vector.FieldVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.calcite.avatica.remote.TypedValue;
+
+/**
+ * Convert Avatica PreparedStatement parameters from a list of TypedValue to Arrow and bind them to the
+ * VectorSchemaRoot representing the PreparedStatement parameters.
+ * <p>
+ * NOTE: Make sure to close the parameters VectorSchemaRoot once we're done with them.
+ */
+public class AvaticaParameterBinder {
+  private final PreparedStatement preparedStatement;
+  private final VectorSchemaRoot parameters;
+
+  public AvaticaParameterBinder(PreparedStatement preparedStatement, BufferAllocator bufferAllocator) {
+    this.parameters = VectorSchemaRoot.create(preparedStatement.getParameterSchema(), bufferAllocator);
+    this.preparedStatement = preparedStatement;
+  }
+
+  /**
+   * Bind the given Avatica values to the prepared statement.
+   * @param typedValues The parameter values.
+   */
+  public void bind(List<TypedValue> typedValues) {
+    bind(typedValues, 0);
+  }
+
+  /**
+   * Bind the given Avatica values to the prepared statement at the given index.
+   * @param typedValues The parameter values.
+   * @param index index for parameter.
+   */
+  public void bind(List<TypedValue> typedValues, int index) {
+    if (preparedStatement.getParameterSchema().getFields().size() != typedValues.size()) {
+      throw new IllegalStateException(
+          String.format("Prepared statement has %s parameters, but only received %s",
+              preparedStatement.getParameterSchema().getFields().size(),
+              typedValues.size()));
+    }
+
+    for (int i = 0; i < typedValues.size(); i++) {
+      bind(parameters.getVector(i), typedValues.get(i), index);
+    }
+
+    if (!typedValues.isEmpty()) {
+      parameters.setRowCount(index + 1);
+      preparedStatement.setParameters(parameters);
+    }
+  }
+
+  /**
+   * Bind a TypedValue to the given index on the FieldVctor.
+   *
+   * @param vector     FieldVector to bind to.
+   * @param typedValue TypedValue to bind to the vector.
+   * @param index      Vector index to bind the value at.
+   */
+  private void bind(FieldVector vector, TypedValue typedValue, int index) {
+    try {
+      if (!vector.getField().getType().accept(new BinderVisitor(vector, typedValue, index))) {
+        throw new RuntimeException(
+                String.format("Binding to vector type %s is not yet supported", vector.getClass()));
+      }
+    } catch (ClassCastException e) {
+      throw new RuntimeException(
+              String.format("Binding value of type %s is not yet supported for expected Arrow type %s",
+                      typedValue.type, vector.getField().getType()));
+    }
+  }
+
+  private static class BinderVisitor implements ArrowType.ArrowTypeVisitor<Boolean> {
+    private final FieldVector vector;
+    private final TypedValue typedValue;
+    private final int index;
+
+    private BinderVisitor(FieldVector vector, TypedValue value, int index) {
+      this.vector = vector;
+      this.typedValue = value;
+      this.index = index;
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Null type) {
+      return new NullAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Struct type) {
+      return new StructAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.List type) {
+      return new ListAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.LargeList type) {
+      return new LargeListAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.FixedSizeList type) {
+      return new FixedSizeListAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Union type) {
+      return new UnionAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Map type) {
+      return new MapAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Int type) {
+      return new IntAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.FloatingPoint type) {
+      return new FloatingPointAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Utf8 type) {
+      return new Utf8AvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.LargeUtf8 type) {
+      return new LargeUtf8AvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Binary type) {
+      return new BinaryAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.LargeBinary type) {
+      return new LargeBinaryAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.FixedSizeBinary type) {
+      return new FixedSizeBinaryAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Bool type) {
+      return new BoolAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Decimal type) {
+      return new DecimalAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Date type) {
+      return new DateAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Time type) {
+      return new TimeAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Timestamp type) {
+      return new TimestampAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Interval type) {
+      return new IntervalAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+
+    @Override
+    public Boolean visit(ArrowType.Duration type) {
+      return new DurationAvaticaParameterConverter(type).bindParameter(vector, typedValue, index);
+    }
+  }
+
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ConvertUtils.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ConvertUtils.java
index 324f991ef09e9..b21b03340e9f9 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ConvertUtils.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ConvertUtils.java
@@ -22,15 +22,37 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.apache.arrow.driver.jdbc.converter.impl.BinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.BoolAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DateAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DecimalAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.DurationAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FixedSizeBinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FixedSizeListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.FloatingPointAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.IntAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.IntervalAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeBinaryAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.LargeUtf8AvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.ListAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.MapAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.NullAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.StructAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.TimeAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.TimestampAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.UnionAvaticaParameterConverter;
+import org.apache.arrow.driver.jdbc.converter.impl.Utf8AvaticaParameterConverter;
 import org.apache.arrow.flight.sql.FlightSqlColumnMetadata;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.calcite.avatica.AvaticaParameter;
 import org.apache.calcite.avatica.ColumnMetaData;
 import org.apache.calcite.avatica.proto.Common;
 import org.apache.calcite.avatica.proto.Common.ColumnMetaData.Builder;
 
 /**
- * Convert Fields To Column MetaData List functions.
+ * Convert objects between Arrow and Avatica.
  */
 public final class ConvertUtils {
 
@@ -113,4 +135,134 @@ public static void setOnColumnMetaDataBuilder(final Builder builder,
       builder.setSearchable(searchable);
     }
   }
+
+  /**
+   * Convert Fields To Avatica Parameters.
+   *
+   * @param fields list of {@link Field}.
+   * @return list of {@link AvaticaParameter}.
+   */
+  public static List<AvaticaParameter> convertArrowFieldsToAvaticaParameters(final List<Field> fields) {
+    return fields.stream()
+            .map(field -> field.getType().accept(new ConverterVisitor(field)))
+            .collect(Collectors.toList());
+  }
+
+  private static class ConverterVisitor implements ArrowType.ArrowTypeVisitor<AvaticaParameter> {
+    private final Field field;
+
+    private ConverterVisitor(Field field) {
+      this.field = field;
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Null type) {
+      return new NullAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Struct type) {
+      return new StructAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.List type) {
+      return new ListAvaticaParameterConverter(type).createParameter(field);
+
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.LargeList type) {
+      return new LargeListAvaticaParameterConverter(type).createParameter(field);
+
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.FixedSizeList type) {
+      return new FixedSizeListAvaticaParameterConverter(type).createParameter(field);
+
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Union type) {
+      return new UnionAvaticaParameterConverter(type).createParameter(field);
+
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Map type) {
+      return new MapAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Int type) {
+      return new IntAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.FloatingPoint type) {
+      return new FloatingPointAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Utf8 type) {
+      return new Utf8AvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.LargeUtf8 type) {
+      return new LargeUtf8AvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Binary type) {
+      return new BinaryAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.LargeBinary type) {
+      return new LargeBinaryAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.FixedSizeBinary type) {
+      return new FixedSizeBinaryAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Bool type) {
+      return new BoolAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Decimal type) {
+      return new DecimalAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Date type) {
+      return new DateAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Time type) {
+      return new TimeAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Timestamp type) {
+      return new TimestampAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Interval type) {
+      return new IntervalAvaticaParameterConverter(type).createParameter(field);
+    }
+
+    @Override
+    public AvaticaParameter visit(ArrowType.Duration type) {
+      return new DurationAvaticaParameterConverter(type).createParameter(field);
+    }
+  }
+
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatementTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatementTest.java
index df2577e955881..b19f049544ada 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatementTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ArrowFlightPreparedStatementTest.java
@@ -20,14 +20,26 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.nio.charset.StandardCharsets;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collections;
 
 import org.apache.arrow.driver.jdbc.utils.CoreMockedSqlProducers;
 import org.apache.arrow.driver.jdbc.utils.MockFlightSqlProducer;
 import org.apache.arrow.flight.sql.FlightSqlUtils;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.VectorSchemaRoot;
+import org.apache.arrow.vector.types.Types;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.arrow.vector.util.Text;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -73,6 +85,39 @@ public void testSimpleQueryNoParameterBinding() throws SQLException {
     }
   }
 
+  @Test
+  public void testQueryWithParameterBinding() throws SQLException {
+    final String query = "Fake query with parameters";
+    final Schema schema = new Schema(Collections.singletonList(Field.nullable("", Types.MinorType.INT.getType())));
+    PRODUCER.addSelectQuery(query, schema,
+            Collections.singletonList(listener -> {
+              try (final BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE);
+                   final VectorSchemaRoot root = VectorSchemaRoot.create(schema,
+                           allocator)) {
+                ((IntVector) root.getVector(0)).setSafe(0, 10);
+                root.setRowCount(1);
+                listener.start(root);
+                listener.putNext();
+              } catch (final Throwable throwable) {
+                listener.error(throwable);
+              } finally {
+                listener.completed();
+              }
+            }));
+
+    PRODUCER.addExpectedParameters(query,
+            new Schema(Collections.singletonList(Field.nullable("", ArrowType.Utf8.INSTANCE))),
+            Collections.singletonList(Collections.singletonList(new Text("foo".getBytes(StandardCharsets.UTF_8)))));
+    try (final PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+      preparedStatement.setString(1, "foo");
+      try (final ResultSet resultSet = preparedStatement.executeQuery()) {
+        resultSet.next();
+        assert true;
+      }
+    }
+  }
+
+
   @Test
   @Ignore("https://github.com/apache/arrow/issues/34741: flaky test")
   public void testPreparedStatementExecutionOnce() throws SQLException {
@@ -107,4 +152,39 @@ public void testUpdateQuery() throws SQLException {
       assertEquals(42, updated);
     }
   }
+
+  @Test
+  public void testUpdateQueryWithParameters() throws SQLException {
+    String query = "Fake update with parameters";
+    PRODUCER.addUpdateQuery(query, /*updatedRows*/42);
+    PRODUCER.addExpectedParameters(query,
+        new Schema(Collections.singletonList(Field.nullable("", ArrowType.Utf8.INSTANCE))),
+        Collections.singletonList(Collections.singletonList(new Text("foo".getBytes(StandardCharsets.UTF_8)))));
+    try (final PreparedStatement stmt = connection.prepareStatement(query)) {
+      // TODO: make sure this is validated on the server too
+      stmt.setString(1, "foo");
+      int updated = stmt.executeUpdate();
+      assertEquals(42, updated);
+    }
+  }
+
+  @Test
+  public void testUpdateQueryWithBatchedParameters() throws SQLException {
+    String query = "Fake update with batched parameters";
+    PRODUCER.addUpdateQuery(query, /*updatedRows*/42);
+    PRODUCER.addExpectedParameters(query,
+            new Schema(Collections.singletonList(Field.nullable("", ArrowType.Utf8.INSTANCE))),
+            Arrays.asList(
+                    Collections.singletonList(new Text("foo".getBytes(StandardCharsets.UTF_8))),
+                    Collections.singletonList(new Text("bar".getBytes(StandardCharsets.UTF_8)))));
+    try (final PreparedStatement stmt = connection.prepareStatement(query)) {
+      // TODO: make sure this is validated on the server too
+      stmt.setString(1, "foo");
+      stmt.addBatch();
+      stmt.setString(1, "bar");
+      stmt.addBatch();
+      int[] updated = stmt.executeBatch();
+      assertEquals(42, updated[0]);
+    }
+  }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
index 0299eeb46d93b..75a7396931c8e 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
@@ -34,6 +34,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
@@ -75,6 +76,7 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.memory.RootAllocator;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.ipc.WriteChannel;
 import org.apache.arrow.vector.ipc.message.MessageSerializer;
 import org.apache.arrow.vector.types.pojo.Schema;
@@ -97,7 +99,9 @@ public final class MockFlightSqlProducer implements FlightSqlProducer {
   private final Map<String, BiConsumer<FlightStream, StreamListener<PutResult>>>
       updateResultProviders =
       new HashMap<>();
-  private SqlInfoBuilder sqlInfoBuilder = new SqlInfoBuilder();
+  private final SqlInfoBuilder sqlInfoBuilder = new SqlInfoBuilder();
+  private final Map<String, Schema> parameterSchemas = new HashMap<>();
+  private final Map<String, List<List<Object>>> expectedParameterValues = new HashMap<>();
 
   private final Map<String, Integer> actionTypeCounter = new HashMap<>();
 
@@ -192,6 +196,12 @@ void addUpdateQuery(final String sqlCommand,
         format("Attempted to overwrite pre-existing query: <%s>.", sqlCommand));
   }
 
+  /** Registers parameters expected to be provided with a prepared statement. */
+  public void addExpectedParameters(String query, Schema parameterSchema, List<List<Object>> expectedValues) {
+    parameterSchemas.put(query, parameterSchema);
+    expectedParameterValues.put(query, expectedValues);
+  }
+
   @Override
   public void createPreparedStatement(final ActionCreatePreparedStatementRequest request,
                                       final CallContext callContext,
@@ -223,6 +233,13 @@ public void createPreparedStatement(final ActionCreatePreparedStatementRequest r
         return;
       }
 
+      final Schema parameterSchema = parameterSchemas.get(query);
+      if (parameterSchema != null) {
+        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        MessageSerializer.serialize(new WriteChannel(Channels.newChannel(outputStream)), parameterSchema);
+        resultBuilder.setParameterSchema(ByteString.copyFrom(outputStream.toByteArray()));
+      }
+
       listener.onNext(new Result(pack(resultBuilder.build()).toByteArray()));
     } catch (final Throwable t) {
       listener.onError(t);
@@ -330,6 +347,51 @@ public Runnable acceptPutStatement(final CommandStatementUpdate commandStatement
     };
   }
 
+  private boolean validateParameters(String query,
+                                     FlightStream flightStream,
+                                     StreamListener<PutResult> streamListener) {
+    final List<List<Object>> expectedValues = expectedParameterValues.get(query);
+    if (expectedValues != null) {
+      int index = 0;
+      while (flightStream.next()) {
+        final VectorSchemaRoot root = flightStream.getRoot();
+        for (int i = 0; i < root.getRowCount(); i++) {
+          if (index >= expectedValues.size()) {
+            streamListener.onError(CallStatus.INVALID_ARGUMENT
+                .withDescription("More parameter rows provided than expected")
+                .toRuntimeException());
+            return true;
+          }
+          List<Object> expectedRow = expectedValues.get(index++);
+          if (root.getFieldVectors().size() != expectedRow.size()) {
+            streamListener.onError(CallStatus.INVALID_ARGUMENT
+                .withDescription("Parameter count mismatch")
+                .toRuntimeException());
+            return true;
+          }
+
+          for (int paramIndex = 0; paramIndex < expectedRow.size(); paramIndex++) {
+            Object expected = expectedRow.get(paramIndex);
+            Object actual = root.getVector(paramIndex).getObject(i);
+            if (!Objects.equals(expected, actual)) {
+              streamListener.onError(CallStatus.INVALID_ARGUMENT
+                  .withDescription(String.format("Parameter mismatch. Expected: %s Actual: %s", expected, actual))
+                  .toRuntimeException());
+              return true;
+            }
+          }
+        }
+      }
+      if (index < expectedValues.size()) {
+        streamListener.onError(CallStatus.INVALID_ARGUMENT
+            .withDescription("Fewer parameter rows provided than expected")
+            .toRuntimeException());
+        return true;
+      }
+    }
+    return false;
+  }
+
   @Override
   public Runnable acceptPutPreparedStatementUpdate(
       final CommandPreparedStatementUpdate commandPreparedStatementUpdate,
@@ -339,6 +401,11 @@ public Runnable acceptPutPreparedStatementUpdate(
     final String query = Preconditions.checkNotNull(
         preparedStatements.get(handle),
         format("No query registered under handle: <%s>.", handle));
+
+    if (validateParameters(query, flightStream, streamListener)) {
+      return () -> { };
+    }
+
     return acceptPutStatement(
         CommandStatementUpdate.newBuilder().setQuery(query).build(), callContext, flightStream,
         streamListener);
@@ -349,8 +416,16 @@ public Runnable acceptPutPreparedStatementQuery(
       final CommandPreparedStatementQuery commandPreparedStatementQuery,
       final CallContext callContext, final FlightStream flightStream,
       final StreamListener<PutResult> streamListener) {
-    // TODO Implement this method.
-    throw CallStatus.UNIMPLEMENTED.toRuntimeException();
+    final ByteString handle = commandPreparedStatementQuery.getPreparedStatementHandle();
+    final String query = Preconditions.checkNotNull(
+        preparedStatements.get(handle),
+        format("No query registered under handle: <%s>.", handle));
+
+    if (validateParameters(query, flightStream, streamListener)) {
+      return () -> { };
+    }
+
+    return streamListener::onCompleted;
   }
 
   @Override
diff --git a/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlClient.java b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlClient.java
index e72354513013e..93d933f00f38f 100644
--- a/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlClient.java
+++ b/java/flight/flight-sql/src/main/java/org/apache/arrow/flight/sql/FlightSqlClient.java
@@ -951,12 +951,11 @@ public static class PreparedStatement implements AutoCloseable {
      *                             {@code PreparedStatement} setters.
      */
     public void setParameters(final VectorSchemaRoot parameterBindingRoot) {
-      if (this.parameterBindingRoot != null) {
-        if (this.parameterBindingRoot.equals(parameterBindingRoot)) {
-          return;
-        }
-        this.parameterBindingRoot.close();
+      if (parameterBindingRoot == this.parameterBindingRoot) {
+        // Nothing to do if we're attempting to set the same parameters again.
+        return;
       }
+      clearParameters();
       this.parameterBindingRoot = parameterBindingRoot;
     }
 
@@ -1038,19 +1037,25 @@ public FlightInfo execute(final CallOption... options) {
               .toByteArray());
 
       if (parameterBindingRoot != null && parameterBindingRoot.getRowCount() > 0) {
-        final SyncPutListener putListener = new SyncPutListener();
-
-        FlightClient.ClientStreamListener listener =
-            client.startPut(descriptor, parameterBindingRoot, putListener, options);
-
-        listener.putNext();
-        listener.completed();
-        listener.getResult();
+        putParameters(descriptor, options);
       }
 
       return client.getInfo(descriptor, options);
     }
 
+    private SyncPutListener putParameters(FlightDescriptor descriptor, CallOption... options) {
+      final SyncPutListener putListener = new SyncPutListener();
+
+      FlightClient.ClientStreamListener listener =
+              client.startPut(descriptor, parameterBindingRoot, putListener, options);
+
+      listener.putNext();
+      listener.completed();
+      listener.getResult();
+
+      return putListener;
+    }
+
     /**
      * Checks whether this client is open.
      *
@@ -1074,11 +1079,8 @@ public long executeUpdate(final CallOption... options) {
                   .build())
               .toByteArray());
       setParameters(parameterBindingRoot == null ? VectorSchemaRoot.of() : parameterBindingRoot);
-      final SyncPutListener putListener = new SyncPutListener();
-      final FlightClient.ClientStreamListener listener =
-          client.startPut(descriptor, parameterBindingRoot, putListener, options);
-      listener.putNext();
-      listener.completed();
+      SyncPutListener putListener = putParameters(descriptor, options);
+
       try {
         final PutResult read = putListener.read();
         try (final ArrowBuf metadata = read.getApplicationMetadata()) {
@@ -1112,9 +1114,7 @@ public void close(final CallOption... options) {
       final Iterator<Result> closePreparedStatementResults = client.doAction(action, options);
       closePreparedStatementResults.forEachRemaining(result -> {
       });
-      if (parameterBindingRoot != null) {
-        parameterBindingRoot.close();
-      }
+      clearParameters();
     }
 
     @Override

From 029849284709574777eaa7edf96ab9b35fd7ee8f Mon Sep 17 00:00:00 2001
From: Tsutomu Katsube <tsuto.katsube@gmail.com>
Date: Mon, 6 Nov 2023 09:08:03 +0900
Subject: [PATCH 677/749] MINOR: [GLib][Docs] Specify Brewfile location
 explicitly (#38592)

### Rationale for this change

Unable to find Brewfile on the [arrow/c_glib/README.md](https://github.com/apache/arrow/blob/fc8c6b7dc8287c672b62c62f3a2bd724b3835063/c_glib/README.md?plain=1#L85) because the found Brewfile location is `./Brewfile`, not `c_glib/Brewfile`.

### What changes are included in this PR?

Specify Brewfile location explicitly.

### Are these changes tested?

Yes. `brew bundle --file=c_glib/Brewfile` was successfully bundled.

### Are there any user-facing changes?

Yes.

Authored-by: Tsutomu Katsube <tsuto.katsube@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/c_glib/README.md b/c_glib/README.md
index 5ff38d3a4d6e6..d571053c3dce8 100644
--- a/c_glib/README.md
+++ b/c_glib/README.md
@@ -82,7 +82,7 @@ required packages.
 macOS:
 
 ```console
-$ brew bundle
+$ brew bundle --file=c_glib/Brewfile
 $ meson setup c_glib.build c_glib --buildtype=release
 $ meson compile -C c_glib.build
 $ sudo meson install -C c_glib.build
@@ -128,7 +128,7 @@ $ sudo pip3 install meson
 On macOS with [Homebrew](https://brew.sh/):
 
 ```console
-$ brew bundle
+$ brew bundle --file=c_glib/Brewfile
 ```
 
 You can build and install Arrow GLib by the followings:

From 987975c9e072e6d7a9c2aac3473451c65197bf5d Mon Sep 17 00:00:00 2001
From: William Ayd <william.ayd@icloud.com>
Date: Sun, 5 Nov 2023 20:52:57 -0500
Subject: [PATCH 678/749] MINOR: [C++] Fix typo in Decimal256::FromBigEndian
 error (#38587)

Looks like a copy/paste error from the Decimal128 variant

Authored-by: Will Ayd <william.ayd@icloud.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/util/decimal.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index 704b6bb9d491d..13709aa2f0cde 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -868,7 +868,7 @@ Result<Decimal256> Decimal256::FromBigEndian(const uint8_t* bytes, int32_t lengt
   std::array<uint64_t, 4> little_endian_array;
 
   if (ARROW_PREDICT_FALSE(length < kMinDecimalBytes || length > kMaxDecimalBytes)) {
-    return Status::Invalid("Length of byte array passed to Decimal128::FromBigEndian ",
+    return Status::Invalid("Length of byte array passed to Decimal256::FromBigEndian ",
                            "was ", length, ", but must be between ", kMinDecimalBytes,
                            " and ", kMaxDecimalBytes);
   }

From b00f141231e9f63a5097198d300743ec0163b8d2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 11:51:47 +0900
Subject: [PATCH 679/749] MINOR: [JS] Bump @types/benchmark from 2.1.2 to 2.1.4
 in /js (#38544)

Bumps [@ types/benchmark](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/benchmark) from 2.1.2 to 2.1.4.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/benchmark">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=@ types/benchmark&package-manager=npm_and_yarn&previous-version=2.1.2&new-version=2.1.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 68 ++++++++++++++++---------------------------------
 2 files changed, 23 insertions(+), 47 deletions(-)

diff --git a/js/package.json b/js/package.json
index 5c3f0ed5aba8a..65010010252fa 100644
--- a/js/package.json
+++ b/js/package.json
@@ -70,7 +70,7 @@
     "@rollup/plugin-node-resolve": "15.1.0",
     "@rollup/stream": "3.0.0",
     "@swc/core": "1.3.82",
-    "@types/benchmark": "2.1.2",
+    "@types/benchmark": "2.1.4",
     "@types/glob": "8.1.0",
     "@types/jest": "29.5.3",
     "@types/randomatic": "3.1.3",
diff --git a/js/yarn.lock b/js/yarn.lock
index 00a4c7ae0ec34..84c5ba6a240e5 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -65,18 +65,10 @@
     "@babel/highlight" "^7.22.13"
     chalk "^2.4.2"
 
-"@babel/code-frame@^7.22.13":
-  version "7.22.13"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.22.13.tgz#e3c1c099402598483b7a8c46a721d1038803755e"
-  integrity sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==
-  dependencies:
-    "@babel/highlight" "^7.22.13"
-    chalk "^2.4.2"
-
-"@babel/compat-data@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.22.5.tgz#b1f6c86a02d85d2dd3368a2b67c09add8cd0c255"
-  integrity sha512-4Jc/YuIaYqKnDDz892kPIledykKg12Aw1PYX5i/TY28anJtacvM1Rrr8wbieB9GfEJwlzqT0hUEao0CxEebiDA==
+"@babel/compat-data@^7.22.9":
+  version "7.23.2"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.23.2.tgz#6a12ced93455827037bfb5ed8492820d60fc32cc"
+  integrity sha512-0S9TQMmDHlqAZ2ITT95irXKfxN9bncq8ZCoJhun3nHL/lLUxd2NKBJYoNGWH7S0hz6fRQwWlAWn/ILM0C70KZQ==
 
 "@babel/core@^7.11.6", "@babel/core@^7.12.3":
   version "7.22.19"
@@ -119,10 +111,10 @@
     "@jridgewell/trace-mapping" "^0.3.17"
     jsesc "^2.5.1"
 
-"@babel/helper-compilation-targets@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.5.tgz#fc7319fc54c5e2fa14b2909cf3c5fd3046813e02"
-  integrity sha512-Ji+ywpHeuqxB8WDxraCiqR0xfhYjiDE/e6k7FuIaANnoOFxAHskHChz4vA1mJC9Lbm01s1PVAGhQY4FUKSkGZw==
+"@babel/helper-compilation-targets@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.22.15.tgz#0698fc44551a26cf29f18d4662d5bf545a6cfc52"
+  integrity sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==
   dependencies:
     "@babel/compat-data" "^7.22.9"
     "@babel/helper-validator-option" "^7.22.15"
@@ -185,13 +177,6 @@
   dependencies:
     "@babel/types" "^7.22.5"
 
-"@babel/helper-split-export-declaration@^7.22.6":
-  version "7.22.6"
-  resolved "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c"
-  integrity sha512-AsUnxuLhRYsisFiaJwvp1QF+I3KjD5FOxut14q/GzovUe6orHLesW2C7d754kRm53h5gqrz6sFl6sxc4BVtE/g==
-  dependencies:
-    "@babel/types" "^7.22.5"
-
 "@babel/helper-split-export-declaration@^7.22.6":
   version "7.22.6"
   resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.22.6.tgz#322c61b7310c0997fe4c323955667f18fcefb91c"
@@ -204,7 +189,7 @@
   resolved "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.22.5.tgz#533f36457a25814cf1df6488523ad547d784a99f"
   integrity sha512-mM4COjgZox8U+JcXQwPijIZLElkgEpO5rsERVDJTc2qfCDfERyob6k5WegS14SX18IIjv+XD+GrqNumY5JRCDw==
 
-"@babel/helper-validator-identifier@^7.19.1", "@babel/helper-validator-identifier@^7.22.19", "@babel/helper-validator-identifier@^7.22.5":
+"@babel/helper-validator-identifier@^7.19.1", "@babel/helper-validator-identifier@^7.22.19":
   version "7.22.19"
   resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.19.tgz#2f34ab1e445f5b95e2e6edfe50ea2449e610583a"
   integrity sha512-Tinq7ybnEPFFXhlYOYFiSjespWQk0dq2dRNAiMdRTOYQzEGqnnNyrTxPYHP5r6wGjlF1rFgABdDV0g8EwD6Qbg==
@@ -214,10 +199,10 @@
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz#c4ae002c61d2879e724581d96665583dbc1dc0e0"
   integrity sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==
 
-"@babel/helper-validator-option@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.5.tgz#de52000a15a177413c8234fa3a8af4ee8102d0ac"
-  integrity sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw==
+"@babel/helper-validator-option@^7.22.15":
+  version "7.22.15"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.22.15.tgz#694c30dfa1d09a6534cdfcafbe56789d36aba040"
+  integrity sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==
 
 "@babel/helpers@^7.22.15":
   version "7.22.15"
@@ -237,16 +222,7 @@
     chalk "^2.4.2"
     js-tokens "^4.0.0"
 
-"@babel/highlight@^7.22.5":
-  version "7.22.5"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.22.5.tgz#aa6c05c5407a67ebce408162b7ede789b4d22031"
-  integrity sha512-BSKlD1hgnedS5XRnGOljZawtag7H1yPfQp0tdNJCHoH6AZ+Pcm9VvkrK59/Yy593Ypg0zMxH2BxD1VPYUQ7UIw==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.22.5"
-    chalk "^2.4.2"
-    js-tokens "^4.0.0"
-
-"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.15", "@babel/parser@^7.22.16":
+"@babel/parser@^7.1.0", "@babel/parser@^7.14.7", "@babel/parser@^7.20.7", "@babel/parser@^7.22.16":
   version "7.22.16"
   resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.22.16.tgz#180aead7f247305cce6551bea2720934e2fa2c95"
   integrity sha512-+gPfKv8UWeKKeJTUxe59+OobVcrYHETCsORl61EmSkmgymguYk/X5bp7GuUIXaFsc6y++v8ZxPsLSSuujqDphA==
@@ -363,7 +339,7 @@
     "@babel/parser" "^7.22.15"
     "@babel/types" "^7.22.15"
 
-"@babel/template@^7.22.5", "@babel/template@^7.3.3":
+"@babel/template@^7.3.3":
   version "7.22.5"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.22.5.tgz#0c8c4d944509875849bd0344ff0050756eefc6ec"
   integrity sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw==
@@ -372,7 +348,7 @@
     "@babel/parser" "^7.22.15"
     "@babel/types" "^7.22.15"
 
-"@babel/traverse@^7.22.5":
+"@babel/traverse@^7.22.15", "@babel/traverse@^7.22.19":
   version "7.23.2"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.23.2.tgz#329c7a06735e144a506bdb2cad0268b7f46f4ad8"
   integrity sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==
@@ -388,7 +364,7 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.22.15", "@babel/types@^7.22.19", "@babel/types@^7.22.5", "@babel/types@^7.3.3":
+"@babel/types@^7.0.0", "@babel/types@^7.20.7", "@babel/types@^7.22.19", "@babel/types@^7.22.5", "@babel/types@^7.3.3":
   version "7.22.19"
   resolved "https://registry.npmjs.org/@babel/types/-/types-7.22.19.tgz#7425343253556916e440e662bb221a93ddb75684"
   integrity sha512-P7LAw/LbojPzkgp5oznjE6tQEIWbp4PkkfrZDINTro9zgBRtI324/EYsiSI7lhPbpIQ+DCeR2NNmMWANGGfZsg==
@@ -1213,10 +1189,10 @@
   dependencies:
     "@babel/types" "^7.20.7"
 
-"@types/benchmark@2.1.2":
-  version "2.1.2"
-  resolved "https://registry.npmjs.org/@types/benchmark/-/benchmark-2.1.2.tgz#b7838408c93dc08ceb4e6e13147dbfbe6a151f82"
-  integrity sha512-EDKtLYNMKrig22jEvhXq8TBFyFgVNSPmDF2b9UzJ7+eylPqdZVo17PCUMkn1jP6/1A/0u78VqYC6VrX6b8pDWA==
+"@types/benchmark@2.1.4":
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/@types/benchmark/-/benchmark-2.1.4.tgz#74f331a07ca5a07a14409ccae7e8072775974361"
+  integrity sha512-rVCCileCU5NhP9Ix1e03sIn4gd0mpjh7VNULVQAxzF+9vddk6A5QAHzp2h5kXH8pkv1Ow45fUf3QP3wOEiISvA==
 
 "@types/command-line-args@^5.2.1":
   version "5.2.1"
@@ -2244,7 +2220,7 @@ chalk@4.x, chalk@^4.0.0, chalk@^4.1.2:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^2.0.0, chalk@^2.4.2:
+chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==

From 70b552ab1cd1d3f211f1d73f006ed718ad4840e4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 11:52:12 +0900
Subject: [PATCH 680/749] MINOR: [JS] Bump rollup from 3.25.0 to 3.29.4 in /js
 (#38543)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

[//]: # (dependabot-start)
⚠️  **Dependabot is rebasing this PR** ⚠️

Rebasing might not happen immediately, so don't worry if this takes some time.

Note: if you make any changes to this PR yourself, they will take precedence over the rebase.

---

[//]: # (dependabot-end)

Bumps [rollup](https://github.com/rollup/rollup) from 3.25.0 to 3.29.4.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/rollup/rollup/releases">rollup's releases</a>.</em></p>
<blockquote>
<h2>v3.29.4</h2>
<h2>3.29.4</h2>
<p><em>2023-09-28</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix static analysis when an exported function uses callbacks (<a href="https://redirect.github.com/rollup/rollup/issues/5158">#5158</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5158">#5158</a>: Deoptimize all parameters when losing track of a function (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>v3.29.3</h2>
<h2>3.29.3</h2>
<p><em>2023-09-24</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix a bug where code was wrongly tree-shaken after mutating function parameters (<a href="https://redirect.github.com/rollup/rollup/issues/5153">#5153</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5145">#5145</a>: docs: improve the docs repl appearance in the light mode (<a href="https://github.com/TrickyPi"><code>@​TrickyPi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5148">#5148</a>: chore(deps): update dependency <code>@​vue/eslint-config-typescript</code> to v12 (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5149">#5149</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5153">#5153</a>: Fully deoptimize first level path when deoptimizing nested parameter paths (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>v3.29.2</h2>
<h2>3.29.2</h2>
<p><em>2023-09-15</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Export <code>TreeshakingPreset</code> type (<a href="https://redirect.github.com/rollup/rollup/issues/5131">#5131</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5131">#5131</a>: fix: exports <code>TreeshakingPreset</code> (<a href="https://github.com/moltar"><code>@​moltar</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5134">#5134</a>: docs: steps to enable symlinks on windows (<a href="https://github.com/thebanjomatic"><code>@​thebanjomatic</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5137">#5137</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
</ul>
<h2>v3.29.1</h2>
<h2>3.29.1</h2>
<p><em>2023-09-10</em></p>
<h3>Bug Fixes</h3>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/rollup/rollup/blob/master/CHANGELOG.md">rollup's changelog</a>.</em></p>
<blockquote>
<h2>3.29.4</h2>
<p><em>2023-09-28</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix static analysis when an exported function uses callbacks (<a href="https://redirect.github.com/rollup/rollup/issues/5158">#5158</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5158">#5158</a>: Deoptimize all parameters when losing track of a function (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>3.29.3</h2>
<p><em>2023-09-24</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix a bug where code was wrongly tree-shaken after mutating function parameters (<a href="https://redirect.github.com/rollup/rollup/issues/5153">#5153</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5145">#5145</a>: docs: improve the docs repl appearance in the light mode (<a href="https://github.com/TrickyPi"><code>@​TrickyPi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5148">#5148</a>: chore(deps): update dependency <code>@​vue/eslint-config-typescript</code> to v12 (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5149">#5149</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5153">#5153</a>: Fully deoptimize first level path when deoptimizing nested parameter paths (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>3.29.2</h2>
<p><em>2023-09-15</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Export <code>TreeshakingPreset</code> type (<a href="https://redirect.github.com/rollup/rollup/issues/5131">#5131</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5131">#5131</a>: fix: exports <code>TreeshakingPreset</code> (<a href="https://github.com/moltar"><code>@​moltar</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5134">#5134</a>: docs: steps to enable symlinks on windows (<a href="https://github.com/thebanjomatic"><code>@​thebanjomatic</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5137">#5137</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
</ul>
<h2>3.29.1</h2>
<p><em>2023-09-10</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix time measurement of plugin hooks in watch mode (<a href="https://redirect.github.com/rollup/rollup/issues/5114">#5114</a>)</li>
<li>Ensure accessing document.currentScript in import.meta.url returns correct results (<a href="https://redirect.github.com/rollup/rollup/issues/5118">#5118</a>)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/rollup/rollup/commit/a6448b99f725d457e35821b73a865b5c4d4c6a61"><code>a6448b9</code></a> 3.29.4</li>
<li><a href="https://github.com/rollup/rollup/commit/4e92d60fa90cead39481e3703d26e5d812f43bd1"><code>4e92d60</code></a> Deoptimize all parameters when losing track of a function (<a href="https://redirect.github.com/rollup/rollup/issues/5158">#5158</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/801ffd1a9bebe550b6a0ce665bdca1ead06313de"><code>801ffd1</code></a> 3.29.3</li>
<li><a href="https://github.com/rollup/rollup/commit/353e4628284b1ef4d8a8b47d895881e5ce6546f4"><code>353e462</code></a> Fully deoptimize first level path when deoptimizing nested parameter paths (#...</li>
<li><a href="https://github.com/rollup/rollup/commit/a1a89e77fbe06a23229486194970f0813593e9df"><code>a1a89e7</code></a> chore(deps): update dependency <code>@​vue/eslint-config-typescript</code> to v12 (<a href="https://redirect.github.com/rollup/rollup/issues/5148">#5148</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/cc14f7070af8c02ac2d477bda043f3203955291d"><code>cc14f70</code></a> chore(deps): lock file maintenance minor/patch updates (<a href="https://redirect.github.com/rollup/rollup/issues/5149">#5149</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/1e8355b2b68811da24e1d96dea32176b403dc377"><code>1e8355b</code></a> docs: improve the docs repl appearance in the light mode (<a href="https://redirect.github.com/rollup/rollup/issues/5145">#5145</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/5950fc8a6bf6c9f8ef1c7ae05bb8c43d5c313212"><code>5950fc8</code></a> Adapt branches in REPL workflow</li>
<li><a href="https://github.com/rollup/rollup/commit/e1a78ff8e61295edc88890f834e8763176692be6"><code>e1a78ff</code></a> 3.29.2</li>
<li><a href="https://github.com/rollup/rollup/commit/be3b25c68382b227548cdbcab057d29805e34e02"><code>be3b25c</code></a> chore(deps): lock file maintenance minor/patch updates (<a href="https://redirect.github.com/rollup/rollup/issues/5137">#5137</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/rollup/rollup/compare/v3.25.0...v3.29.4">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=rollup&package-manager=npm_and_yarn&previous-version=3.25.0&new-version=3.29.4)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json | 2 +-
 js/yarn.lock    | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/js/package.json b/js/package.json
index 65010010252fa..e7ef0f895aa1d 100644
--- a/js/package.json
+++ b/js/package.json
@@ -106,7 +106,7 @@
     "multistream": "4.1.0",
     "randomatic": "3.1.1",
     "regenerator-runtime": "0.14.0",
-    "rollup": "3.25.0",
+    "rollup": "3.29.4",
     "rxjs": "7.8.1",
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index 84c5ba6a240e5..0b37e4cbcc68a 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -6158,10 +6158,10 @@ rimraf@^3.0.2:
   dependencies:
     glob "^7.1.3"
 
-rollup@3.25.0:
-  version "3.25.0"
-  resolved "https://registry.npmjs.org/rollup/-/rollup-3.25.0.tgz#71327d396a9decbf23c87b55916ae7204211738a"
-  integrity sha512-FnJkNRst2jEZGw7f+v4hFo6UTzpDKrAKcHZWcEfm5/GJQ5CK7wgb4moNLNAe7npKUev7yQn1AY/YbZRIxOv6Qg==
+rollup@3.29.4:
+  version "3.29.4"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.29.4.tgz#4d70c0f9834146df8705bfb69a9a19c9e1109981"
+  integrity sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==
   optionalDependencies:
     fsevents "~2.3.2"
 

From d18054ece1d1ff54c1bb7b17a4ad22cfeedf7060 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 11:53:47 +0900
Subject: [PATCH 681/749] MINOR: [JS] Bump @types/node from 20.3.0 to 20.8.10
 in /js (#38547)

Bumps [@ types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node) from 20.3.0 to 20.8.10.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=@ types/node&package-manager=npm_and_yarn&previous-version=20.3.0&new-version=20.8.10)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/yarn.lock | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/js/yarn.lock b/js/yarn.lock
index 0b37e4cbcc68a..40d5ef5f16141 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -1288,9 +1288,11 @@
   integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
 
 "@types/node@*", "@types/node@^20.6.0":
-  version "20.6.0"
-  resolved "https://registry.npmjs.org/@types/node/-/node-20.6.0.tgz#9d7daa855d33d4efec8aea88cd66db1c2f0ebe16"
-  integrity sha512-najjVq5KN2vsH2U/xyh2opaSEz6cZMR2SetLIlxlj08nOcmPOemJmUK2o4kUzfLqfrWE0PIrNeE16XhYDd3nqg==
+  version "20.8.10"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.8.10.tgz#a5448b895c753ae929c26ce85cab557c6d4a365e"
+  integrity sha512-TlgT8JntpcbmKUFzjhsyhGfP2fsiz1Mv56im6enJ905xG1DAYesxJaeSbGqQmAw8OWPdhyJGhGSQGKRNJ45u9w==
+  dependencies:
+    undici-types "~5.26.4"
 
 "@types/node@^13.7.4":
   version "13.13.52"
@@ -6983,6 +6985,11 @@ undertaker@^1.2.1:
     object.reduce "^1.0.0"
     undertaker-registry "^1.0.0"
 
+undici-types@~5.26.4:
+  version "5.26.5"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
+  integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
+
 union-value@^1.0.0:
   version "1.0.1"
   resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz#0b6fe7b835aecda61c6ea4d4f02c14221e109847"

From 9a364b8ea955097f6cd5721fd9a42606b7d83b08 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Mon, 6 Nov 2023 17:31:01 +0900
Subject: [PATCH 682/749] GH-38556: [C++] Add missing explicit size_t cast for
 i386 (#38557)

### Rationale for this change

We need explicit cast for `int64_t` to `size_t` conversion for i386 environment.

This was introduced by GH-37792.

### What changes are included in this PR?

Add explicit cast.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38556

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/array/data.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/arrow/array/data.cc b/cpp/src/arrow/array/data.cc
index 678513fd4d151..186682be3009e 100644
--- a/cpp/src/arrow/array/data.cc
+++ b/cpp/src/arrow/array/data.cc
@@ -568,7 +568,7 @@ std::shared_ptr<ArrayData> ArraySpan::ToArrayData() const {
 util::span<const std::shared_ptr<Buffer>> ArraySpan::GetVariadicBuffers() const {
   DCHECK(HasVariadicBuffers());
   return {buffers[2].data_as<std::shared_ptr<Buffer>>(),
-          buffers[2].size / sizeof(std::shared_ptr<Buffer>)};
+          static_cast<size_t>(buffers[2].size) / sizeof(std::shared_ptr<Buffer>)};
 }
 
 bool ArraySpan::HasVariadicBuffers() const {

From 305f4383ba0cc0eff92ac5f97031a7a926c61f58 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 7 Nov 2023 02:08:39 +0900
Subject: [PATCH 683/749] GH-38562: [Packaging] Add support for Ubuntu 23.10
 (#38563)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Ubuntu 23.10 released on 2023-10.

### What changes are included in this PR?

Build packages for Ubuntu 23.10.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38562

Authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 dev/release/binary-task.rb                    |  1 +
 dev/release/verify-release-candidate.sh       |  4 +-
 .../apt/ubuntu-mantic/Dockerfile              | 41 +++++++++
 .../apache-arrow/apt/ubuntu-mantic-arm64/from | 18 ++++
 .../apache-arrow/apt/ubuntu-mantic/Dockerfile | 85 +++++++++++++++++++
 dev/tasks/linux-packages/package-task.rb      |  4 +
 dev/tasks/tasks.yml                           |  3 +-
 7 files changed, 154 insertions(+), 2 deletions(-)
 create mode 100644 dev/tasks/linux-packages/apache-arrow-apt-source/apt/ubuntu-mantic/Dockerfile
 create mode 100644 dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic-arm64/from
 create mode 100644 dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic/Dockerfile

diff --git a/dev/release/binary-task.rb b/dev/release/binary-task.rb
index e7b618ba3348d..519c8339a4dba 100644
--- a/dev/release/binary-task.rb
+++ b/dev/release/binary-task.rb
@@ -1089,6 +1089,7 @@ def available_apt_targets
       ["ubuntu", "focal", "main"],
       ["ubuntu", "jammy", "main"],
       ["ubuntu", "lunar", "main"],
+      ["ubuntu", "mantic", "main"],
     ]
   end
 
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index 49997fbf4ea91..05a7498a85180 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -196,7 +196,9 @@ test_apt() {
                 "ubuntu:jammy" \
                 "arm64v8/ubuntu:jammy" \
                 "ubuntu:lunar" \
-                "arm64v8/ubuntu:lunar"; do \
+                "arm64v8/ubuntu:lunar" \
+                "ubuntu:mantic" \
+                "arm64v8/ubuntu:mantic"; do \
     case "${target}" in
       arm64v8/*)
         if [ "$(arch)" = "aarch64" -o -e /usr/bin/qemu-aarch64-static ]; then
diff --git a/dev/tasks/linux-packages/apache-arrow-apt-source/apt/ubuntu-mantic/Dockerfile b/dev/tasks/linux-packages/apache-arrow-apt-source/apt/ubuntu-mantic/Dockerfile
new file mode 100644
index 0000000000000..b5a61282b30fc
--- /dev/null
+++ b/dev/tasks/linux-packages/apache-arrow-apt-source/apt/ubuntu-mantic/Dockerfile
@@ -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.
+
+FROM ubuntu:mantic
+
+RUN \
+  echo "debconf debconf/frontend select Noninteractive" | \
+    debconf-set-selections
+
+RUN \
+  echo 'APT::Install-Recommends "false";' > \
+    /etc/apt/apt.conf.d/disable-install-recommends
+
+ARG DEBUG
+
+RUN \
+  quiet=$([ "${DEBUG}" = "yes" ] || echo "-qq") && \
+  apt update ${quiet} && \
+  apt install -y -V ${quiet} \
+    build-essential \
+    debhelper \
+    devscripts \
+    fakeroot \
+    gnupg \
+    lsb-release && \
+  apt clean && \
+  rm -rf /var/lib/apt/lists/*
diff --git a/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic-arm64/from b/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic-arm64/from
new file mode 100644
index 0000000000000..247faef234794
--- /dev/null
+++ b/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic-arm64/from
@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+arm64v8/ubuntu:mantic
diff --git a/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic/Dockerfile b/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic/Dockerfile
new file mode 100644
index 0000000000000..9e90e08d26513
--- /dev/null
+++ b/dev/tasks/linux-packages/apache-arrow/apt/ubuntu-mantic/Dockerfile
@@ -0,0 +1,85 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+ARG FROM=ubuntu:mantic
+FROM ${FROM}
+
+RUN \
+  echo "debconf debconf/frontend select Noninteractive" | \
+    debconf-set-selections
+
+RUN \
+  echo 'APT::Install-Recommends "false";' > \
+    /etc/apt/apt.conf.d/disable-install-recommends
+
+ARG DEBUG
+RUN \
+  quiet=$([ "${DEBUG}" = "yes" ] || echo "-qq") && \
+  apt update ${quiet} && \
+  apt install -y -V ${quiet} \
+    build-essential \
+    clang \
+    clang-tools \
+    cmake \
+    debhelper \
+    devscripts \
+    git \
+    gtk-doc-tools \
+    libboost-filesystem-dev \
+    libboost-system-dev \
+    libbrotli-dev \
+    libbz2-dev \
+    libc-ares-dev \
+    libcurl4-openssl-dev \
+    libgirepository1.0-dev \
+    libglib2.0-doc \
+    libgmock-dev \
+    libgoogle-glog-dev \
+    libgrpc++-dev \
+    libgtest-dev \
+    liblz4-dev \
+    libmlir-15-dev \
+    libprotobuf-dev \
+    libprotoc-dev \
+    libre2-dev \
+    libsnappy-dev \
+    libssl-dev \
+    libthrift-dev \
+    libutf8proc-dev \
+    libzstd-dev \
+    llvm-dev \
+    lsb-release \
+    meson \
+    mlir-15-tools \
+    ninja-build \
+    nlohmann-json3-dev \
+    pkg-config \
+    protobuf-compiler-grpc \
+    python3-dev \
+    python3-pip \
+    python3-setuptools \
+    rapidjson-dev \
+    tzdata \
+    valac \
+    zlib1g-dev && \
+  if apt list | grep -q '^libcuda1'; then \
+    apt install -y -V ${quiet} nvidia-cuda-toolkit; \
+  else \
+    :; \
+  fi && \
+  apt clean && \
+  rm -rf /var/lib/apt/lists/*
diff --git a/dev/tasks/linux-packages/package-task.rb b/dev/tasks/linux-packages/package-task.rb
index bb5d70b64f2b0..da281d0ee2cf9 100644
--- a/dev/tasks/linux-packages/package-task.rb
+++ b/dev/tasks/linux-packages/package-task.rb
@@ -271,12 +271,16 @@ def apt_targets_default
       # "debian-bullseye-arm64",
       "debian-bookworm",
       # "debian-bookworm-arm64",
+      "debian-trixie",
+      # "debian-trixie-arm64",
       "ubuntu-focal",
       # "ubuntu-focal-arm64",
       "ubuntu-jammy",
       # "ubuntu-jammy-arm64",
       "ubuntu-lunar",
       # "ubuntu-lunar-arm64",
+      "ubuntu-mantic",
+      # "ubuntu-mantic-arm64",
     ]
   end
 
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index 0c62200e9b1ab..b8d2f6c0a0086 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -557,7 +557,8 @@ tasks:
                   "debian-trixie",
                   "ubuntu-focal",
                   "ubuntu-jammy",
-                  "ubuntu-lunar"] %}
+                  "ubuntu-lunar",
+                  "ubuntu-mantic"] %}
   {% for architecture in ["amd64", "arm64"] %}
   {{ target }}-{{ architecture }}:
     ci: github

From b55d8d5664480f63c2be75f0e18eeb006b640427 Mon Sep 17 00:00:00 2001
From: Jeremy Aguilon <jeraguilon@gmail.com>
Date: Mon, 6 Nov 2023 12:48:35 -0500
Subject: [PATCH 684/749] GH-38381: [C++][Acero] Create a  sorted merge node
 (#38380)

### Rationale for this change

This is an implementation of a node that can merge N sorted inputs (only in ascending order for a first pass).

Where possible I have shared components with `asof_join_node.cc`.

Full description/use case is described in https://github.com/apache/arrow/issues/38381

### What changes are included in this PR?

* Take out relevant guts of asofjoin to stream data top to bottom/consume in a non blocking manner
* Implement a sorted merger

### Are these changes tested?

Basic test added. Locally I have tested this on 100+ gigabytes of parquet, sharded across 50+ files. Happy to add a benchmark test on top of the basic test, but submitting now for code feedback.

### Are there any user-facing changes?

Yes, `sorted_merge` is now an exposed declaration

Lead-authored-by: Jeremy Aguilon <jeraguilon@gmail.com>
Co-authored-by: jeremy <jeraguilon@gmail.com>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Weston Pace <weston.pace@gmail.com>
---
 cpp/src/arrow/acero/CMakeLists.txt            |   6 +-
 cpp/src/arrow/acero/asof_join_node.cc         | 432 ++-----------
 cpp/src/arrow/acero/backpressure_handler.h    |  74 +++
 .../arrow/acero/concurrent_queue_internal.h   | 161 +++++
 cpp/src/arrow/acero/exec_plan.cc              |   2 +
 cpp/src/arrow/acero/sorted_merge_node.cc      | 609 ++++++++++++++++++
 cpp/src/arrow/acero/sorted_merge_node_test.cc |  87 +++
 cpp/src/arrow/acero/time_series_util.cc       |  63 ++
 cpp/src/arrow/acero/time_series_util.h        |  31 +
 cpp/src/arrow/acero/unmaterialized_table.h    | 271 ++++++++
 10 files changed, 1357 insertions(+), 379 deletions(-)
 create mode 100644 cpp/src/arrow/acero/backpressure_handler.h
 create mode 100644 cpp/src/arrow/acero/concurrent_queue_internal.h
 create mode 100644 cpp/src/arrow/acero/sorted_merge_node.cc
 create mode 100644 cpp/src/arrow/acero/sorted_merge_node_test.cc
 create mode 100644 cpp/src/arrow/acero/time_series_util.cc
 create mode 100644 cpp/src/arrow/acero/time_series_util.h
 create mode 100644 cpp/src/arrow/acero/unmaterialized_table.h

diff --git a/cpp/src/arrow/acero/CMakeLists.txt b/cpp/src/arrow/acero/CMakeLists.txt
index 153413b33cab5..b77d52a23eedb 100644
--- a/cpp/src/arrow/acero/CMakeLists.txt
+++ b/cpp/src/arrow/acero/CMakeLists.txt
@@ -49,9 +49,11 @@ set(ARROW_ACERO_SRCS
     project_node.cc
     query_context.cc
     sink_node.cc
+    sorted_merge_node.cc
     source_node.cc
     swiss_join.cc
     task_util.cc
+    time_series_util.cc
     tpch_node.cc
     union_node.cc
     util.cc)
@@ -173,11 +175,13 @@ add_arrow_acero_test(hash_join_node_test SOURCES hash_join_node_test.cc
 add_arrow_acero_test(pivot_longer_node_test SOURCES pivot_longer_node_test.cc
                      test_nodes.cc)
 
-# asof_join_node uses std::thread internally
+# asof_join_node and sorted_merge_node use std::thread internally
 # and doesn't use ThreadPool so it will
 # be broken if threading is turned off
 if(ARROW_ENABLE_THREADING)
   add_arrow_acero_test(asof_join_node_test SOURCES asof_join_node_test.cc test_nodes.cc)
+  add_arrow_acero_test(sorted_merge_node_test SOURCES sorted_merge_node_test.cc
+                       test_nodes.cc)
 endif()
 
 add_arrow_acero_test(tpch_node_test SOURCES tpch_node_test.cc)
diff --git a/cpp/src/arrow/acero/asof_join_node.cc b/cpp/src/arrow/acero/asof_join_node.cc
index d19d2db299cba..4a3b6b199c4c0 100644
--- a/cpp/src/arrow/acero/asof_join_node.cc
+++ b/cpp/src/arrow/acero/asof_join_node.cc
@@ -16,6 +16,8 @@
 // under the License.
 
 #include "arrow/acero/asof_join_node.h"
+#include "arrow/acero/backpressure_handler.h"
+#include "arrow/acero/concurrent_queue_internal.h"
 
 #include <atomic>
 #include <condition_variable>
@@ -30,6 +32,7 @@
 
 #include "arrow/acero/exec_plan.h"
 #include "arrow/acero/options.h"
+#include "arrow/acero/unmaterialized_table.h"
 #ifndef NDEBUG
 #include "arrow/acero/options_internal.h"
 #endif
@@ -41,6 +44,7 @@
 #ifndef NDEBUG
 #include "arrow/compute/function_internal.h"
 #endif
+#include "arrow/acero/time_series_util.h"
 #include "arrow/compute/key_hash.h"
 #include "arrow/compute/light_array.h"
 #include "arrow/record_batch.h"
@@ -122,92 +126,12 @@ struct TolType {
 typedef uint64_t row_index_t;
 typedef int col_index_t;
 
-// normalize the value to 64-bits while preserving ordering of values
-template <typename T, enable_if_t<std::is_integral<T>::value, bool> = true>
-static inline uint64_t time_value(T t) {
-  uint64_t bias = std::is_signed<T>::value ? (uint64_t)1 << (8 * sizeof(T) - 1) : 0;
-  return t < 0 ? static_cast<uint64_t>(t + bias) : static_cast<uint64_t>(t);
-}
-
 // indicates normalization of a key value
 template <typename T, enable_if_t<std::is_integral<T>::value, bool> = true>
 static inline uint64_t key_value(T t) {
   return static_cast<uint64_t>(t);
 }
 
-/**
- * Simple implementation for an unbound concurrent queue
- */
-template <class T>
-class ConcurrentQueue {
- public:
-  T Pop() {
-    std::unique_lock<std::mutex> lock(mutex_);
-    cond_.wait(lock, [&] { return !queue_.empty(); });
-    return PopUnlocked();
-  }
-
-  T PopUnlocked() {
-    auto item = queue_.front();
-    queue_.pop();
-    return item;
-  }
-
-  void Push(const T& item) {
-    std::unique_lock<std::mutex> lock(mutex_);
-    return PushUnlocked(item);
-  }
-
-  void PushUnlocked(const T& item) {
-    queue_.push(item);
-    cond_.notify_one();
-  }
-
-  void Clear() {
-    std::unique_lock<std::mutex> lock(mutex_);
-    ClearUnlocked();
-  }
-
-  void ClearUnlocked() { queue_ = std::queue<T>(); }
-
-  std::optional<T> TryPop() {
-    std::unique_lock<std::mutex> lock(mutex_);
-    return TryPopUnlocked();
-  }
-
-  std::optional<T> TryPopUnlocked() {
-    // Try to pop the oldest value from the queue (or return nullopt if none)
-    if (queue_.empty()) {
-      return std::nullopt;
-    } else {
-      auto item = queue_.front();
-      queue_.pop();
-      return item;
-    }
-  }
-
-  bool Empty() const {
-    std::unique_lock<std::mutex> lock(mutex_);
-    return queue_.empty();
-  }
-
-  // Un-synchronized access to front
-  // For this to be "safe":
-  // 1) the caller logically guarantees that queue is not empty
-  // 2) pop/try_pop cannot be called concurrently with this
-  const T& UnsyncFront() const { return queue_.front(); }
-
-  size_t UnsyncSize() const { return queue_.size(); }
-
- protected:
-  std::mutex& GetMutex() { return mutex_; }
-
- private:
-  std::queue<T> queue_;
-  mutable std::mutex mutex_;
-  std::condition_variable cond_;
-};
-
 class AsofJoinNode;
 
 #ifndef NDEBUG
@@ -547,104 +471,6 @@ class BackpressureController : public BackpressureControl {
   std::atomic<int32_t>& backpressure_counter_;
 };
 
-class BackpressureHandler {
- private:
-  BackpressureHandler(ExecNode* input, size_t low_threshold, size_t high_threshold,
-                      std::unique_ptr<BackpressureControl> backpressure_control)
-      : input_(input),
-        low_threshold_(low_threshold),
-        high_threshold_(high_threshold),
-        backpressure_control_(std::move(backpressure_control)) {}
-
- public:
-  static Result<BackpressureHandler> Make(
-      ExecNode* input, size_t low_threshold, size_t high_threshold,
-      std::unique_ptr<BackpressureControl> backpressure_control) {
-    if (low_threshold >= high_threshold) {
-      return Status::Invalid("low threshold (", low_threshold,
-                             ") must be less than high threshold (", high_threshold, ")");
-    }
-    if (backpressure_control == NULLPTR) {
-      return Status::Invalid("null backpressure control parameter");
-    }
-    BackpressureHandler backpressure_handler(input, low_threshold, high_threshold,
-                                             std::move(backpressure_control));
-    return std::move(backpressure_handler);
-  }
-
-  void Handle(size_t start_level, size_t end_level) {
-    if (start_level < high_threshold_ && end_level >= high_threshold_) {
-      backpressure_control_->Pause();
-    } else if (start_level > low_threshold_ && end_level <= low_threshold_) {
-      backpressure_control_->Resume();
-    }
-  }
-
-  Status ForceShutdown() {
-    // It may be unintuitive to call Resume() here, but this is to avoid a deadlock.
-    // Since acero's executor won't terminate if any one node is paused, we need to
-    // force resume the node before stopping production.
-    backpressure_control_->Resume();
-    return input_->StopProducing();
-  }
-
- private:
-  ExecNode* input_;
-  size_t low_threshold_;
-  size_t high_threshold_;
-  std::unique_ptr<BackpressureControl> backpressure_control_;
-};
-
-template <typename T>
-class BackpressureConcurrentQueue : public ConcurrentQueue<T> {
- private:
-  struct DoHandle {
-    explicit DoHandle(BackpressureConcurrentQueue& queue)
-        : queue_(queue), start_size_(queue_.UnsyncSize()) {}
-
-    ~DoHandle() {
-      size_t end_size = queue_.UnsyncSize();
-      queue_.handler_.Handle(start_size_, end_size);
-    }
-
-    BackpressureConcurrentQueue& queue_;
-    size_t start_size_;
-  };
-
- public:
-  explicit BackpressureConcurrentQueue(BackpressureHandler handler)
-      : handler_(std::move(handler)) {}
-
-  T Pop() {
-    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
-    DoHandle do_handle(*this);
-    return ConcurrentQueue<T>::PopUnlocked();
-  }
-
-  void Push(const T& item) {
-    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
-    DoHandle do_handle(*this);
-    ConcurrentQueue<T>::PushUnlocked(item);
-  }
-
-  void Clear() {
-    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
-    DoHandle do_handle(*this);
-    ConcurrentQueue<T>::ClearUnlocked();
-  }
-
-  std::optional<T> TryPop() {
-    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
-    DoHandle do_handle(*this);
-    return ConcurrentQueue<T>::TryPopUnlocked();
-  }
-
-  Status ForceShutdown() { return handler_.ForceShutdown(); }
-
- private:
-  BackpressureHandler handler_;
-};
-
 class InputState {
   // InputState correponds to an input
   // Input record batches are queued up in InputState until processed and
@@ -783,29 +609,8 @@ class InputState {
   }
 
   inline OnType GetLatestTime() const {
-    return GetTime(GetLatestBatch().get(), latest_ref_row_);
-  }
-
-  inline ByType GetTime(const RecordBatch* batch, row_index_t row) const {
-    auto data = batch->column_data(time_col_index_);
-    switch (time_type_id_) {
-      LATEST_VAL_CASE(INT8, time_value)
-      LATEST_VAL_CASE(INT16, time_value)
-      LATEST_VAL_CASE(INT32, time_value)
-      LATEST_VAL_CASE(INT64, time_value)
-      LATEST_VAL_CASE(UINT8, time_value)
-      LATEST_VAL_CASE(UINT16, time_value)
-      LATEST_VAL_CASE(UINT32, time_value)
-      LATEST_VAL_CASE(UINT64, time_value)
-      LATEST_VAL_CASE(DATE32, time_value)
-      LATEST_VAL_CASE(DATE64, time_value)
-      LATEST_VAL_CASE(TIME32, time_value)
-      LATEST_VAL_CASE(TIME64, time_value)
-      LATEST_VAL_CASE(TIMESTAMP, time_value)
-      default:
-        DCHECK(false);
-        return 0;  // cannot happen
-    }
+    return GetTime(GetLatestBatch().get(), time_type_id_, time_col_index_,
+                   latest_ref_row_);
   }
 
 #undef LATEST_VAL_CASE
@@ -832,7 +637,9 @@ class InputState {
         have_active_batch &= !queue_.TryPop();
         if (have_active_batch) {
           DCHECK_GT(queue_.UnsyncFront()->num_rows(), 0);  // empty batches disallowed
-          memo_.UpdateTime(GetTime(queue_.UnsyncFront().get(), 0));  // time changed
+          memo_.UpdateTime(GetTime(queue_.UnsyncFront().get(), time_type_id_,
+                                   time_col_index_,
+                                   0));  // time changed
         }
       }
     }
@@ -988,35 +795,25 @@ class InputState {
   std::vector<std::optional<col_index_t>> src_to_dst_;
 };
 
+/// Wrapper around UnmaterializedCompositeTable that knows how to emplace
+/// the join row-by-row
 template <size_t MAX_TABLES>
-struct CompositeReferenceRow {
-  struct Entry {
-    arrow::RecordBatch* batch;  // can be NULL if there's no value
-    row_index_t row;
-  };
-  Entry refs[MAX_TABLES];
-};
+class CompositeTableBuilder {
+  using SliceBuilder = UnmaterializedSliceBuilder<MAX_TABLES>;
+  using CompositeTable = UnmaterializedCompositeTable<MAX_TABLES>;
 
-// A table of composite reference rows.  Rows maintain pointers to the
-// constituent record batches, but the overall table retains shared_ptr
-// references to ensure memory remains resident while the table is live.
-//
-// The main reason for this is that, especially for wide tables, joins
-// are effectively row-oriented, rather than column-oriented.  Separating
-// the join part from the columnar materialization part simplifies the
-// logic around data types and increases efficiency.
-//
-// We don't put the shared_ptr's into the rows for efficiency reasons.
-template <size_t MAX_TABLES>
-class CompositeReferenceTable {
  public:
-  NDEBUG_EXPLICIT CompositeReferenceTable(DEBUG_ADD(size_t n_tables, AsofJoinNode* node))
-      : DEBUG_ADD(n_tables_(n_tables), node_(node)) {
+  NDEBUG_EXPLICIT CompositeTableBuilder(
+      const std::vector<std::unique_ptr<InputState>>& inputs,
+      const std::shared_ptr<Schema>& schema, arrow::MemoryPool* pool,
+      DEBUG_ADD(size_t n_tables, AsofJoinNode* node))
+      : unmaterialized_table(InitUnmaterializedTable(schema, inputs, pool)),
+        DEBUG_ADD(n_tables_(n_tables), node_(node)) {
     DCHECK_GE(n_tables_, 1);
     DCHECK_LE(n_tables_, MAX_TABLES);
   }
 
-  size_t n_rows() const { return rows_.size(); }
+  size_t n_rows() const { return unmaterialized_table.Size(); }
 
   // Adds the latest row from the input state as a new composite reference row
   // - LHS must have a valid key,timestep,and latest rows
@@ -1037,14 +834,16 @@ class CompositeReferenceTable {
       // On the first row of the batch, we resize the destination.
       // The destination size is dictated by the size of the LHS batch.
       row_index_t new_batch_size = lhs_latest_batch->num_rows();
-      row_index_t new_capacity = rows_.size() + new_batch_size;
-      if (rows_.capacity() < new_capacity) rows_.reserve(new_capacity);
+      row_index_t new_capacity = unmaterialized_table.Size() + new_batch_size;
+      if (unmaterialized_table.capacity() < new_capacity) {
+        unmaterialized_table.reserve(new_capacity);
+      }
     }
-    rows_.resize(rows_.size() + 1);
-    auto& row = rows_.back();
-    row.refs[0].batch = lhs_latest_batch.get();
-    row.refs[0].row = lhs_latest_row;
-    AddRecordBatchRef(lhs_latest_batch);
+
+    SliceBuilder new_row{&unmaterialized_table};
+
+    // Each item represents a portion of the columns of the output table
+    new_row.AddEntry(lhs_latest_batch, lhs_latest_row, lhs_latest_row + 1);
 
     DEBUG_SYNC(node_, "Emplace: key=", key, " lhs_latest_row=", lhs_latest_row,
                " lhs_latest_time=", lhs_latest_time, DEBUG_MANIP(std::endl));
@@ -1068,100 +867,25 @@ class CompositeReferenceTable {
         if (tolerance.Accepts(lhs_latest_time, (*opt_entry)->time)) {
           // Have a valid entry
           const MemoStore::Entry* entry = *opt_entry;
-          row.refs[i].batch = entry->batch.get();
-          row.refs[i].row = entry->row;
-          AddRecordBatchRef(entry->batch);
+          new_row.AddEntry(entry->batch, entry->row, entry->row + 1);
           continue;
         }
       }
-      row.refs[i].batch = NULL;
-      row.refs[i].row = 0;
+      new_row.AddEntry(nullptr, 0, 1);
     }
+    new_row.Finalize();
   }
 
   // Materializes the current reference table into a target record batch
-  Result<std::shared_ptr<RecordBatch>> Materialize(
-      MemoryPool* memory_pool, const std::shared_ptr<arrow::Schema>& output_schema,
-      const std::vector<std::unique_ptr<InputState>>& state) {
-    DCHECK_EQ(state.size(), n_tables_);
-
-    // Don't build empty batches
-    size_t n_rows = rows_.size();
-    if (!n_rows) return NULLPTR;
-
-    // Build the arrays column-by-column from the rows
-    std::vector<std::shared_ptr<arrow::Array>> arrays(output_schema->num_fields());
-    for (size_t i_table = 0; i_table < n_tables_; ++i_table) {
-      int n_src_cols = state.at(i_table)->get_schema()->num_fields();
-      {
-        for (col_index_t i_src_col = 0; i_src_col < n_src_cols; ++i_src_col) {
-          std::optional<col_index_t> i_dst_col_opt =
-              state[i_table]->MapSrcToDst(i_src_col);
-          if (!i_dst_col_opt) continue;
-          col_index_t i_dst_col = *i_dst_col_opt;
-          const auto& src_field = state[i_table]->get_schema()->field(i_src_col);
-          const auto& dst_field = output_schema->field(i_dst_col);
-          DCHECK(src_field->type()->Equals(dst_field->type()));
-          DCHECK_EQ(src_field->name(), dst_field->name());
-          const auto& field_type = src_field->type();
-
-#define ASOFJOIN_MATERIALIZE_CASE(id)                                       \
-  case Type::id: {                                                          \
-    using T = typename TypeIdTraits<Type::id>::Type;                        \
-    ARROW_ASSIGN_OR_RAISE(                                                  \
-        arrays.at(i_dst_col),                                               \
-        MaterializeColumn<T>(memory_pool, field_type, i_table, i_src_col)); \
-    break;                                                                  \
-  }
-
-          switch (field_type->id()) {
-            ASOFJOIN_MATERIALIZE_CASE(BOOL)
-            ASOFJOIN_MATERIALIZE_CASE(INT8)
-            ASOFJOIN_MATERIALIZE_CASE(INT16)
-            ASOFJOIN_MATERIALIZE_CASE(INT32)
-            ASOFJOIN_MATERIALIZE_CASE(INT64)
-            ASOFJOIN_MATERIALIZE_CASE(UINT8)
-            ASOFJOIN_MATERIALIZE_CASE(UINT16)
-            ASOFJOIN_MATERIALIZE_CASE(UINT32)
-            ASOFJOIN_MATERIALIZE_CASE(UINT64)
-            ASOFJOIN_MATERIALIZE_CASE(FLOAT)
-            ASOFJOIN_MATERIALIZE_CASE(DOUBLE)
-            ASOFJOIN_MATERIALIZE_CASE(DATE32)
-            ASOFJOIN_MATERIALIZE_CASE(DATE64)
-            ASOFJOIN_MATERIALIZE_CASE(TIME32)
-            ASOFJOIN_MATERIALIZE_CASE(TIME64)
-            ASOFJOIN_MATERIALIZE_CASE(TIMESTAMP)
-            ASOFJOIN_MATERIALIZE_CASE(STRING)
-            ASOFJOIN_MATERIALIZE_CASE(LARGE_STRING)
-            ASOFJOIN_MATERIALIZE_CASE(BINARY)
-            ASOFJOIN_MATERIALIZE_CASE(LARGE_BINARY)
-            default:
-              return Status::Invalid("Unsupported data type ",
-                                     src_field->type()->ToString(), " for field ",
-                                     src_field->name());
-          }
-
-#undef ASOFJOIN_MATERIALIZE_CASE
-        }
-      }
-    }
-
-    // Build the result
-    DCHECK_LE(n_rows, (uint64_t)std::numeric_limits<int64_t>::max());
-    std::shared_ptr<arrow::RecordBatch> r =
-        arrow::RecordBatch::Make(output_schema, (int64_t)n_rows, arrays);
-    return r;
+  Result<std::optional<std::shared_ptr<RecordBatch>>> Materialize() {
+    return unmaterialized_table.Materialize();
   }
 
   // Returns true if there are no rows
-  bool empty() const { return rows_.empty(); }
+  bool empty() const { return unmaterialized_table.Empty(); }
 
  private:
-  // Contains shared_ptr refs for all RecordBatches referred to by the contents of rows_
-  std::unordered_map<uintptr_t, std::shared_ptr<RecordBatch>> _ptr2ref;
-
-  // Row table references
-  std::vector<CompositeReferenceRow<MAX_TABLES>> rows_;
+  CompositeTable unmaterialized_table;
 
   // Total number of tables in the composite table
   size_t n_tables_;
@@ -1171,70 +895,20 @@ class CompositeReferenceTable {
   AsofJoinNode* node_;
 #endif
 
-  // Adds a RecordBatch ref to the mapping, if needed
-  void AddRecordBatchRef(const std::shared_ptr<RecordBatch>& ref) {
-    if (!_ptr2ref.count((uintptr_t)ref.get())) _ptr2ref[(uintptr_t)ref.get()] = ref;
-  }
-
-  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
-  enable_if_boolean<Type, Status> static BuilderAppend(
-      Builder& builder, const std::shared_ptr<ArrayData>& source, row_index_t row) {
-    if (source->IsNull(row)) {
-      builder.UnsafeAppendNull();
-      return Status::OK();
-    }
-    builder.UnsafeAppend(bit_util::GetBit(source->template GetValues<uint8_t>(1), row));
-    return Status::OK();
-  }
-
-  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
-  enable_if_t<is_fixed_width_type<Type>::value && !is_boolean_type<Type>::value,
-              Status> static BuilderAppend(Builder& builder,
-                                           const std::shared_ptr<ArrayData>& source,
-                                           row_index_t row) {
-    if (source->IsNull(row)) {
-      builder.UnsafeAppendNull();
-      return Status::OK();
-    }
-    using CType = typename TypeTraits<Type>::CType;
-    builder.UnsafeAppend(source->template GetValues<CType>(1)[row]);
-    return Status::OK();
-  }
-
-  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
-  enable_if_base_binary<Type, Status> static BuilderAppend(
-      Builder& builder, const std::shared_ptr<ArrayData>& source, row_index_t row) {
-    if (source->IsNull(row)) {
-      return builder.AppendNull();
-    }
-    using offset_type = typename Type::offset_type;
-    const uint8_t* data = source->buffers[2]->data();
-    const offset_type* offsets = source->GetValues<offset_type>(1);
-    const offset_type offset0 = offsets[row];
-    const offset_type offset1 = offsets[row + 1];
-    return builder.Append(data + offset0, offset1 - offset0);
-  }
-
-  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
-  Result<std::shared_ptr<Array>> MaterializeColumn(MemoryPool* memory_pool,
-                                                   const std::shared_ptr<DataType>& type,
-                                                   size_t i_table, col_index_t i_col) {
-    ARROW_ASSIGN_OR_RAISE(auto a_builder, MakeBuilder(type, memory_pool));
-    Builder& builder = *checked_cast<Builder*>(a_builder.get());
-    ARROW_RETURN_NOT_OK(builder.Reserve(rows_.size()));
-    for (row_index_t i_row = 0; i_row < rows_.size(); ++i_row) {
-      const auto& ref = rows_[i_row].refs[i_table];
-      if (ref.batch) {
-        Status st =
-            BuilderAppend<Type, Builder>(builder, ref.batch->column_data(i_col), ref.row);
-        ARROW_RETURN_NOT_OK(st);
-      } else {
-        builder.UnsafeAppendNull();
+  static CompositeTable InitUnmaterializedTable(
+      const std::shared_ptr<Schema>& schema,
+      const std::vector<std::unique_ptr<InputState>>& inputs, arrow::MemoryPool* pool) {
+    std::unordered_map<int, std::pair<int, int>> dst_to_src;
+    for (size_t i = 0; i < inputs.size(); i++) {
+      auto& input = inputs[i];
+      for (int src = 0; src < input->get_schema()->num_fields(); src++) {
+        auto dst = input->MapSrcToDst(src);
+        if (dst.has_value()) {
+          dst_to_src[dst.value()] = std::make_pair(static_cast<int>(i), src);
+        }
       }
     }
-    std::shared_ptr<Array> result;
-    ARROW_RETURN_NOT_OK(builder.Finish(&result));
-    return result;
+    return CompositeTable{schema, inputs.size(), dst_to_src, pool};
   }
 };
 
@@ -1279,7 +953,9 @@ class AsofJoinNode : public ExecNode {
     auto& lhs = *state_.at(0);
 
     // Construct new target table if needed
-    CompositeReferenceTable<MAX_JOIN_TABLES> dst(DEBUG_ADD(state_.size(), this));
+    CompositeTableBuilder<MAX_JOIN_TABLES> dst(state_, output_schema_,
+                                               plan()->query_context()->memory_pool(),
+                                               DEBUG_ADD(state_.size(), this));
 
     // Generate rows into the dst table until we either run out of data or hit the row
     // limit, or run out of input
@@ -1318,8 +994,8 @@ class AsofJoinNode : public ExecNode {
     if (dst.empty()) {
       return NULLPTR;
     } else {
-      return dst.Materialize(plan()->query_context()->memory_pool(), output_schema(),
-                             state_);
+      ARROW_ASSIGN_OR_RAISE(auto out, dst.Materialize());
+      return out.has_value() ? out.value() : NULLPTR;
     }
   }
 
diff --git a/cpp/src/arrow/acero/backpressure_handler.h b/cpp/src/arrow/acero/backpressure_handler.h
new file mode 100644
index 0000000000000..178272315d7fb
--- /dev/null
+++ b/cpp/src/arrow/acero/backpressure_handler.h
@@ -0,0 +1,74 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+#include "arrow/acero/exec_plan.h"
+#include "arrow/acero/options.h"
+
+#include <memory>
+
+namespace arrow::acero {
+
+class BackpressureHandler {
+ private:
+  BackpressureHandler(ExecNode* input, size_t low_threshold, size_t high_threshold,
+                      std::unique_ptr<BackpressureControl> backpressure_control)
+      : input_(input),
+        low_threshold_(low_threshold),
+        high_threshold_(high_threshold),
+        backpressure_control_(std::move(backpressure_control)) {}
+
+ public:
+  static Result<BackpressureHandler> Make(
+      ExecNode* input, size_t low_threshold, size_t high_threshold,
+      std::unique_ptr<BackpressureControl> backpressure_control) {
+    if (low_threshold >= high_threshold) {
+      return Status::Invalid("low threshold (", low_threshold,
+                             ") must be less than high threshold (", high_threshold, ")");
+    }
+    if (backpressure_control == NULLPTR) {
+      return Status::Invalid("null backpressure control parameter");
+    }
+    BackpressureHandler backpressure_handler(input, low_threshold, high_threshold,
+                                             std::move(backpressure_control));
+    return std::move(backpressure_handler);
+  }
+
+  void Handle(size_t start_level, size_t end_level) {
+    if (start_level < high_threshold_ && end_level >= high_threshold_) {
+      backpressure_control_->Pause();
+    } else if (start_level > low_threshold_ && end_level <= low_threshold_) {
+      backpressure_control_->Resume();
+    }
+  }
+
+  Status ForceShutdown() {
+    // It may be unintuitive to call Resume() here, but this is to avoid a deadlock.
+    // Since acero's executor won't terminate if any one node is paused, we need to
+    // force resume the node before stopping production.
+    backpressure_control_->Resume();
+    return input_->StopProducing();
+  }
+
+ private:
+  ExecNode* input_;
+  size_t low_threshold_;
+  size_t high_threshold_;
+  std::unique_ptr<BackpressureControl> backpressure_control_;
+};
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/concurrent_queue_internal.h b/cpp/src/arrow/acero/concurrent_queue_internal.h
new file mode 100644
index 0000000000000..f530394187299
--- /dev/null
+++ b/cpp/src/arrow/acero/concurrent_queue_internal.h
@@ -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.
+
+#pragma once
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include "arrow/acero/backpressure_handler.h"
+
+namespace arrow::acero {
+
+/**
+ * Simple implementation for a thread safe blocking unbound multi-consumer /
+ * multi-producer concurrent queue
+ */
+template <class T>
+class ConcurrentQueue {
+ public:
+  // Pops the last item from the queue. Must be called on a non-empty queue
+  //
+  T Pop() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cond_.wait(lock, [&] { return !queue_.empty(); });
+    return PopUnlocked();
+  }
+
+  // Pops the last item from the queue, or returns a nullopt if empty
+  //
+  std::optional<T> TryPop() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    return TryPopUnlocked();
+  }
+
+  // Pushes an item to the queue
+  //
+  void Push(const T& item) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    return PushUnlocked(item);
+  }
+
+  // Clears the queue
+  //
+  void Clear() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    ClearUnlocked();
+  }
+
+  bool Empty() const {
+    std::unique_lock<std::mutex> lock(mutex_);
+    return queue_.empty();
+  }
+
+  // Un-synchronized access to front
+  // For this to be "safe":
+  // 1) the caller logically guarantees that queue is not empty
+  // 2) pop/try_pop cannot be called concurrently with this
+  const T& UnsyncFront() const { return queue_.front(); }
+
+  size_t UnsyncSize() const { return queue_.size(); }
+
+ protected:
+  std::mutex& GetMutex() { return mutex_; }
+
+  T PopUnlocked() {
+    auto item = queue_.front();
+    queue_.pop();
+    return item;
+  }
+
+  void PushUnlocked(const T& item) {
+    queue_.push(item);
+    cond_.notify_one();
+  }
+
+  void ClearUnlocked() { queue_ = std::queue<T>(); }
+
+  std::optional<T> TryPopUnlocked() {
+    // Try to pop the oldest value from the queue (or return nullopt if none)
+    if (queue_.empty()) {
+      return std::nullopt;
+    } else {
+      auto item = queue_.front();
+      queue_.pop();
+      return item;
+    }
+  }
+  std::queue<T> queue_;
+
+ private:
+  mutable std::mutex mutex_;
+  std::condition_variable cond_;
+};
+
+template <typename T>
+class BackpressureConcurrentQueue : public ConcurrentQueue<T> {
+ private:
+  struct DoHandle {
+    explicit DoHandle(BackpressureConcurrentQueue& queue)
+        : queue_(queue), start_size_(queue_.UnsyncSize()) {}
+
+    ~DoHandle() {
+      // unsynced access is safe since DoHandle is internally only used when the
+      // lock is held
+      size_t end_size = queue_.UnsyncSize();
+      queue_.handler_.Handle(start_size_, end_size);
+    }
+
+    BackpressureConcurrentQueue& queue_;
+    size_t start_size_;
+  };
+
+ public:
+  explicit BackpressureConcurrentQueue(BackpressureHandler handler)
+      : handler_(std::move(handler)) {}
+
+  T Pop() {
+    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
+    DoHandle do_handle(*this);
+    return ConcurrentQueue<T>::PopUnlocked();
+  }
+
+  void Push(const T& item) {
+    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
+    DoHandle do_handle(*this);
+    ConcurrentQueue<T>::PushUnlocked(item);
+  }
+
+  void Clear() {
+    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
+    DoHandle do_handle(*this);
+    ConcurrentQueue<T>::ClearUnlocked();
+  }
+
+  std::optional<T> TryPop() {
+    std::unique_lock<std::mutex> lock(ConcurrentQueue<T>::GetMutex());
+    DoHandle do_handle(*this);
+    return ConcurrentQueue<T>::TryPopUnlocked();
+  }
+
+  Status ForceShutdown() { return handler_.ForceShutdown(); }
+
+ private:
+  BackpressureHandler handler_;
+};
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/exec_plan.cc b/cpp/src/arrow/acero/exec_plan.cc
index 541e5fed6206b..97119726d4b17 100644
--- a/cpp/src/arrow/acero/exec_plan.cc
+++ b/cpp/src/arrow/acero/exec_plan.cc
@@ -1114,6 +1114,7 @@ void RegisterAggregateNode(ExecFactoryRegistry*);
 void RegisterSinkNode(ExecFactoryRegistry*);
 void RegisterHashJoinNode(ExecFactoryRegistry*);
 void RegisterAsofJoinNode(ExecFactoryRegistry*);
+void RegisterSortedMergeNode(ExecFactoryRegistry*);
 
 }  // namespace internal
 
@@ -1132,6 +1133,7 @@ ExecFactoryRegistry* default_exec_factory_registry() {
       internal::RegisterSinkNode(this);
       internal::RegisterHashJoinNode(this);
       internal::RegisterAsofJoinNode(this);
+      internal::RegisterSortedMergeNode(this);
     }
 
     Result<Factory> GetFactory(const std::string& factory_name) override {
diff --git a/cpp/src/arrow/acero/sorted_merge_node.cc b/cpp/src/arrow/acero/sorted_merge_node.cc
new file mode 100644
index 0000000000000..f3b934eda186b
--- /dev/null
+++ b/cpp/src/arrow/acero/sorted_merge_node.cc
@@ -0,0 +1,609 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <any>
+#include <atomic>
+#include <mutex>
+#include <sstream>
+#include <thread>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+#include "arrow/acero/concurrent_queue_internal.h"
+#include "arrow/acero/exec_plan.h"
+#include "arrow/acero/options.h"
+#include "arrow/acero/query_context.h"
+#include "arrow/acero/time_series_util.h"
+#include "arrow/acero/unmaterialized_table.h"
+#include "arrow/acero/util.h"
+#include "arrow/array/builder_base.h"
+#include "arrow/result.h"
+#include "arrow/type_fwd.h"
+#include "arrow/util/logging.h"
+
+namespace {
+template <typename Callable>
+struct Defer {
+  Callable callable;
+  explicit Defer(Callable callable_) : callable(std::move(callable_)) {}
+  ~Defer() noexcept { callable(); }
+};
+
+std::vector<std::string> GetInputLabels(
+    const arrow::acero::ExecNode::NodeVector& inputs) {
+  std::vector<std::string> labels(inputs.size());
+  for (size_t i = 0; i < inputs.size(); i++) {
+    labels[i] = "input_" + std::to_string(i) + "_label";
+  }
+  return labels;
+}
+
+template <typename T, typename V = typename T::value_type>
+inline typename T::const_iterator std_find(const T& container, const V& val) {
+  return std::find(container.begin(), container.end(), val);
+}
+
+template <typename T, typename V = typename T::value_type>
+inline bool std_has(const T& container, const V& val) {
+  return container.end() != std_find(container, val);
+}
+
+}  // namespace
+
+namespace arrow::acero {
+
+namespace {
+
+// Each slice is associated with a single input source, so we only need 1 record
+// batch per slice
+using SingleRecordBatchSliceBuilder = arrow::acero::UnmaterializedSliceBuilder<1>;
+using SingleRecordBatchCompositeTable = arrow::acero::UnmaterializedCompositeTable<1>;
+
+using row_index_t = uint64_t;
+using time_unit_t = uint64_t;
+using col_index_t = int;
+
+constexpr bool kNewTask = true;
+constexpr bool kPoisonPill = false;
+
+class BackpressureController : public BackpressureControl {
+ public:
+  BackpressureController(ExecNode* node, ExecNode* output,
+                         std::atomic<int32_t>& backpressure_counter)
+      : node_(node), output_(output), backpressure_counter_(backpressure_counter) {}
+
+  void Pause() override { node_->PauseProducing(output_, ++backpressure_counter_); }
+  void Resume() override { node_->ResumeProducing(output_, ++backpressure_counter_); }
+
+ private:
+  ExecNode* node_;
+  ExecNode* output_;
+  std::atomic<int32_t>& backpressure_counter_;
+};
+
+/// InputState correponds to an input. Input record batches are queued up in InputState
+/// until processed and turned into output record batches.
+class InputState {
+ public:
+  InputState(size_t index, BackpressureHandler handler,
+             const std::shared_ptr<arrow::Schema>& schema, const int time_col_index)
+      : index_(index),
+        queue_(std::move(handler)),
+        schema_(schema),
+        time_col_index_(time_col_index),
+        time_type_id_(schema_->fields()[time_col_index_]->type()->id()) {}
+
+  template <typename PtrType>
+  static arrow::Result<PtrType> Make(size_t index, arrow::acero::ExecNode* input,
+                                     arrow::acero::ExecNode* output,
+                                     std::atomic<int32_t>& backpressure_counter,
+                                     const std::shared_ptr<arrow::Schema>& schema,
+                                     const col_index_t time_col_index) {
+    constexpr size_t low_threshold = 4, high_threshold = 8;
+    std::unique_ptr<arrow::acero::BackpressureControl> backpressure_control =
+        std::make_unique<BackpressureController>(input, output, backpressure_counter);
+    ARROW_ASSIGN_OR_RAISE(auto handler,
+                          BackpressureHandler::Make(input, low_threshold, high_threshold,
+                                                    std::move(backpressure_control)));
+    return PtrType(new InputState(index, std::move(handler), schema, time_col_index));
+  }
+
+  bool IsTimeColumn(col_index_t i) const {
+    DCHECK_LT(i, schema_->num_fields());
+    return (i == time_col_index_);
+  }
+
+  // Gets the latest row index, assuming the queue isn't empty
+  row_index_t GetLatestRow() const { return latest_ref_row_; }
+
+  bool Empty() const {
+    // cannot be empty if ref row is >0 -- can avoid slow queue lock
+    // below
+    if (latest_ref_row_ > 0) {
+      return false;
+    }
+    return queue_.Empty();
+  }
+
+  size_t index() const { return index_; }
+
+  int total_batches() const { return total_batches_; }
+
+  // Gets latest batch (precondition: must not be empty)
+  const std::shared_ptr<arrow::RecordBatch>& GetLatestBatch() const {
+    return queue_.UnsyncFront();
+  }
+
+#define LATEST_VAL_CASE(id, val)                                   \
+  case arrow::Type::id: {                                          \
+    using T = typename arrow::TypeIdTraits<arrow::Type::id>::Type; \
+    using CType = typename arrow::TypeTraits<T>::CType;            \
+    return val(data->GetValues<CType>(1)[row]);                    \
+  }
+
+  inline time_unit_t GetLatestTime() const {
+    return GetTime(GetLatestBatch().get(), time_type_id_, time_col_index_,
+                   latest_ref_row_);
+  }
+
+#undef LATEST_VAL_CASE
+
+  bool Finished() const { return batches_processed_ == total_batches_; }
+
+  void Advance(SingleRecordBatchSliceBuilder& builder) {
+    // Advance the row until a new time is encountered or the record batch
+    // ends. This will return a range of {-1, -1} and a nullptr if there is
+    // no input
+    bool active =
+        (latest_ref_row_ > 0 /*short circuit the lock on the queue*/) || !queue_.Empty();
+
+    if (!active) {
+      return;
+    }
+
+    row_index_t start = latest_ref_row_;
+    row_index_t end = latest_ref_row_;
+    time_unit_t startTime = GetLatestTime();
+    std::shared_ptr<arrow::RecordBatch> batch = queue_.UnsyncFront();
+    auto rows_in_batch = (row_index_t)batch->num_rows();
+
+    while (GetLatestTime() == startTime) {
+      end = ++latest_ref_row_;
+      if (latest_ref_row_ >= rows_in_batch) {
+        // hit the end of the batch, need to get the next batch if
+        // possible.
+        ++batches_processed_;
+        latest_ref_row_ = 0;
+        active &= !queue_.TryPop();
+        if (active) {
+          DCHECK_GT(queue_.UnsyncFront()->num_rows(),
+                    0);  // empty batches disallowed, sanity check
+        }
+        break;
+      }
+    }
+    builder.AddEntry(batch, start, end);
+  }
+
+  arrow::Status Push(const std::shared_ptr<arrow::RecordBatch>& rb) {
+    if (rb->num_rows() > 0) {
+      queue_.Push(rb);
+    } else {
+      ++batches_processed_;  // don't enqueue empty batches, just record
+                             // as processed
+    }
+    return arrow::Status::OK();
+  }
+
+  const std::shared_ptr<arrow::Schema>& get_schema() const { return schema_; }
+
+  void set_total_batches(int n) { total_batches_ = n; }
+
+ private:
+  size_t index_;
+  // Pending record batches. The latest is the front. Batches cannot be empty.
+  BackpressureConcurrentQueue<std::shared_ptr<arrow::RecordBatch>> queue_;
+  // Schema associated with the input
+  std::shared_ptr<arrow::Schema> schema_;
+  // Total number of batches (only int because InputFinished uses int)
+  std::atomic<int> total_batches_{-1};
+  // Number of batches processed so far (only int because InputFinished uses
+  // int)
+  std::atomic<int> batches_processed_{0};
+  // Index of the time col
+  col_index_t time_col_index_;
+  // Type id of the time column
+  arrow::Type::type time_type_id_;
+  // Index of the latest row reference within; if >0 then queue_ cannot be
+  // empty Must be < queue_.front()->num_rows() if queue_ is non-empty
+  row_index_t latest_ref_row_ = 0;
+  // Time of latest row
+  time_unit_t latest_time_ = std::numeric_limits<time_unit_t>::lowest();
+};
+
+struct InputStateComparator {
+  bool operator()(const std::shared_ptr<InputState>& lhs,
+                  const std::shared_ptr<InputState>& rhs) const {
+    // True if lhs is ahead of time of rhs
+    if (lhs->Finished()) {
+      return false;
+    }
+    if (rhs->Finished()) {
+      return false;
+    }
+    time_unit_t lFirst = lhs->GetLatestTime();
+    time_unit_t rFirst = rhs->GetLatestTime();
+    return lFirst > rFirst;
+  }
+};
+
+class SortedMergeNode : public ExecNode {
+  static constexpr int64_t kTargetOutputBatchSize = 1024 * 1024;
+
+ public:
+  SortedMergeNode(arrow::acero::ExecPlan* plan,
+                  std::vector<arrow::acero::ExecNode*> inputs,
+                  std::shared_ptr<arrow::Schema> output_schema,
+                  arrow::Ordering new_ordering)
+      : ExecNode(plan, inputs, GetInputLabels(inputs), std::move(output_schema)),
+        ordering_(std::move(new_ordering)),
+        input_counter(inputs_.size()),
+        output_counter(inputs_.size()),
+        process_thread() {
+    SetLabel("sorted_merge");
+  }
+
+  ~SortedMergeNode() override {
+    process_queue.Push(
+        kPoisonPill);  // poison pill
+                       // We might create a temporary (such as to inspect the output
+                       // schema), in which case there isn't anything  to join
+    if (process_thread.joinable()) {
+      process_thread.join();
+    }
+  }
+
+  static arrow::Result<arrow::acero::ExecNode*> Make(
+      arrow::acero::ExecPlan* plan, std::vector<arrow::acero::ExecNode*> inputs,
+      const arrow::acero::ExecNodeOptions& options) {
+    RETURN_NOT_OK(ValidateExecNodeInputs(plan, inputs, static_cast<int>(inputs.size()),
+                                         "SortedMergeNode"));
+
+    if (inputs.size() < 1) {
+      return Status::Invalid("Constructing a `SortedMergeNode` with < 1 inputs");
+    }
+
+    const auto schema = inputs.at(0)->output_schema();
+    for (const auto& input : inputs) {
+      if (!input->output_schema()->Equals(schema)) {
+        return Status::Invalid(
+            "SortedMergeNode input schemas must all "
+            "match, first schema "
+            "was: ",
+            schema->ToString(), " got schema: ", input->output_schema()->ToString());
+      }
+    }
+
+    const auto& order_options =
+        arrow::internal::checked_cast<const OrderByNodeOptions&>(options);
+
+    if (order_options.ordering.is_implicit() || order_options.ordering.is_unordered()) {
+      return Status::Invalid("`ordering` must be an explicit non-empty ordering");
+    }
+
+    std::shared_ptr<Schema> output_schema = inputs[0]->output_schema();
+    return plan->EmplaceNode<SortedMergeNode>(
+        plan, std::move(inputs), std::move(output_schema), order_options.ordering);
+  }
+
+  const char* kind_name() const override { return "SortedMergeNode"; }
+
+  const arrow::Ordering& ordering() const override { return ordering_; }
+
+  arrow::Status Init() override {
+    ARROW_CHECK(ordering_.sort_keys().size() == 1) << "Only one sort key supported";
+
+    auto inputs = this->inputs();
+    for (size_t i = 0; i < inputs.size(); i++) {
+      ExecNode* input = inputs[i];
+      const auto& schema = input->output_schema();
+
+      const auto& sort_key = ordering_.sort_keys()[0];
+      if (sort_key.order != arrow::compute::SortOrder::Ascending) {
+        return Status::NotImplemented("Only ascending sort order is supported");
+      }
+
+      const FieldRef& ref = sort_key.target;
+      auto match_res = ref.FindOne(*schema);
+      if (!match_res.ok()) {
+        return Status::Invalid("Bad sort key : ", match_res.status().message());
+      }
+      ARROW_ASSIGN_OR_RAISE(auto match, match_res);
+      ARROW_DCHECK(match.indices().size() == 1);
+
+      ARROW_ASSIGN_OR_RAISE(auto input_state,
+                            InputState::Make<std::shared_ptr<InputState>>(
+                                i, input, this, backpressure_counter, schema,
+                                std::move(match.indices()[0])));
+      state.push_back(std::move(input_state));
+    }
+    return Status::OK();
+  }
+
+  arrow::Status InputReceived(arrow::acero::ExecNode* input,
+                              arrow::ExecBatch batch) override {
+    ARROW_DCHECK(std_has(inputs_, input));
+    const size_t index = std_find(inputs_, input) - inputs_.begin();
+    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<RecordBatch> rb,
+                          batch.ToRecordBatch(output_schema_));
+
+    // Push into the queue. Note that we don't need to lock since
+    // InputState's ConcurrentQueue manages locking
+    input_counter[index] += rb->num_rows();
+    ARROW_RETURN_NOT_OK(state[index]->Push(rb));
+    process_queue.Push(kNewTask);
+    return Status::OK();
+  }
+
+  arrow::Status InputFinished(arrow::acero::ExecNode* input, int total_batches) override {
+    ARROW_DCHECK(std_has(inputs_, input));
+    {
+      std::lock_guard<std::mutex> guard(gate);
+      ARROW_DCHECK(std_has(inputs_, input));
+      size_t k = std_find(inputs_, input) - inputs_.begin();
+      state.at(k)->set_total_batches(total_batches);
+    }
+    // Trigger a final process call for stragglers
+    process_queue.Push(kNewTask);
+    return Status::OK();
+  }
+
+  arrow::Status StartProducing() override {
+    ARROW_ASSIGN_OR_RAISE(process_task, plan_->query_context()->BeginExternalTask(
+                                            "SortedMergeNode::ProcessThread"));
+    if (!process_task.is_valid()) {
+      // Plan has already aborted.  Do not start process thread
+      return Status::OK();
+    }
+    process_thread = std::thread(&SortedMergeNode::StartPoller, this);
+    return Status::OK();
+  }
+
+  arrow::Status StopProducingImpl() override {
+    process_queue.Clear();
+    process_queue.Push(kPoisonPill);
+    return Status::OK();
+  }
+
+  // handled by the backpressure controller
+  void PauseProducing(arrow::acero::ExecNode* output, int32_t counter) override {}
+  void ResumeProducing(arrow::acero::ExecNode* output, int32_t counter) override {}
+
+ protected:
+  std::string ToStringExtra(int indent) const override {
+    std::stringstream ss;
+    ss << "ordering=" << ordering_.ToString();
+    return ss.str();
+  }
+
+ private:
+  void EndFromProcessThread(arrow::Status st = arrow::Status::OK()) {
+    ARROW_CHECK(!cleanup_started);
+    for (size_t i = 0; i < input_counter.size(); ++i) {
+      ARROW_CHECK(input_counter[i] == output_counter[i])
+          << input_counter[i] << " != " << output_counter[i];
+    }
+
+    ARROW_UNUSED(
+        plan_->query_context()->executor()->Spawn([this, st = std::move(st)]() mutable {
+          Defer cleanup([this, &st]() { process_task.MarkFinished(st); });
+          if (st.ok()) {
+            st = output_->InputFinished(this, batches_produced);
+          }
+        }));
+  }
+
+  bool CheckEnded() {
+    bool all_finished = true;
+    for (const auto& s : state) {
+      all_finished &= s->Finished();
+    }
+    if (all_finished) {
+      EndFromProcessThread();
+      return false;
+    }
+    return true;
+  }
+
+  /// Streams the input states in sorted order until we run out of input
+  arrow::Result<std::shared_ptr<arrow::RecordBatch>> getNextBatch() {
+    DCHECK(!state.empty());
+    for (const auto& s : state) {
+      if (s->Empty() && !s->Finished()) {
+        return nullptr;  // not enough data, wait
+      }
+    }
+
+    std::vector<std::shared_ptr<InputState>> heap = state;
+    // filter out finished states
+    heap.erase(std::remove_if(
+                   heap.begin(), heap.end(),
+                   [](const std::shared_ptr<InputState>& s) { return s->Finished(); }),
+               heap.end());
+
+    // If any are Empty(), then return early since we don't have enough data
+    if (std::any_of(heap.begin(), heap.end(),
+                    [](const std::shared_ptr<InputState>& s) { return s->Empty(); })) {
+      return nullptr;
+    }
+
+    // Currently we only support one sort key
+    const auto sort_col = *ordering_.sort_keys().at(0).target.name();
+    const auto comp = InputStateComparator();
+    std::make_heap(heap.begin(), heap.end(), comp);
+
+    // Each slice only has one record batch with the same schema as the output
+    std::unordered_map<int, std::pair<int, int>> output_col_to_src;
+    for (int i = 0; i < output_schema_->num_fields(); i++) {
+      output_col_to_src[i] = std::make_pair(0, i);
+    }
+    SingleRecordBatchCompositeTable output(output_schema(), 1,
+                                           std::move(output_col_to_src),
+                                           plan()->query_context()->memory_pool());
+
+    // Generate rows until we run out of data or we exceed the target output
+    // size
+    bool waiting_for_more_data = false;
+    while (!waiting_for_more_data && !heap.empty() &&
+           output.Size() < kTargetOutputBatchSize) {
+      std::pop_heap(heap.begin(), heap.end(), comp);
+
+      auto& next_item = heap.back();
+      time_unit_t latest_time = std::numeric_limits<time_unit_t>::min();
+      time_unit_t new_time = next_item->GetLatestTime();
+      ARROW_CHECK(new_time >= latest_time)
+          << "Input state " << next_item->index()
+          << " has out of order data. newTime=" << new_time
+          << " latestTime=" << latest_time;
+
+      latest_time = new_time;
+      SingleRecordBatchSliceBuilder builder{&output};
+      next_item->Advance(builder);
+
+      if (builder.Size() > 0) {
+        output_counter[next_item->index()] += builder.Size();
+        builder.Finalize();
+      }
+      if (next_item->Finished()) {
+        heap.pop_back();
+      } else if (next_item->Empty()) {
+        // We've run out of data on one of the inputs
+        waiting_for_more_data = true;
+        continue;  // skip the unnecessary make_heap
+      }
+      std::make_heap(heap.begin(), heap.end(), comp);
+    }
+
+    // Emit the batch
+    if (output.Size() == 0) {
+      return nullptr;
+    }
+
+    ARROW_ASSIGN_OR_RAISE(auto maybe_rb, output.Materialize());
+    return maybe_rb.value_or(nullptr);
+  }
+  /// Gets a batch. Returns true if there is more data to process, false if we
+  /// are done or an error occurred
+  bool PollOnce() {
+    std::lock_guard<std::mutex> guard(gate);
+    if (!CheckEnded()) {
+      return false;
+    }
+
+    // Process batches while we have data
+    for (;;) {
+      Result<std::shared_ptr<RecordBatch>> result = getNextBatch();
+
+      if (result.ok()) {
+        auto out_rb = *result;
+        if (!out_rb) {
+          break;
+        }
+        ExecBatch out_b(*out_rb);
+        out_b.index = batches_produced++;
+        Status st = output_->InputReceived(this, std::move(out_b));
+        if (!st.ok()) {
+          ARROW_LOG(FATAL) << "Error in output_::InputReceived: " << st.ToString();
+          EndFromProcessThread(std::move(st));
+        }
+      } else {
+        EndFromProcessThread(result.status());
+        return false;
+      }
+    }
+
+    // Report to the output the total batch count, if we've already
+    // finished everything (there are two places where this can happen:
+    // here and InputFinished)
+    //
+    // It may happen here in cases where InputFinished was called before
+    // we were finished producing results (so we didn't know the output
+    // size at that time)
+    if (!CheckEnded()) {
+      return false;
+    }
+
+    // There is no more we can do now but there is still work remaining
+    // for later when more data arrives.
+    return true;
+  }
+
+  void EmitBatches() {
+    while (true) {
+      // Implementation note: If the queue is empty, we will block here
+      if (process_queue.Pop() == kPoisonPill) {
+        EndFromProcessThread();
+      }
+      // Either we're out of data or something went wrong
+      if (!PollOnce()) {
+        return;
+      }
+    }
+  }
+
+  /// The entry point for processThread
+  static void StartPoller(SortedMergeNode* node) { node->EmitBatches(); }
+
+  arrow::Ordering ordering_;
+
+  // Each input state corresponds to an input (e.g. a parquet data file)
+  std::vector<std::shared_ptr<InputState>> state;
+  std::vector<std::atomic_int64_t> input_counter;
+  std::vector<std::atomic_int64_t> output_counter;
+  std::mutex gate;
+
+  std::atomic<bool> cleanup_started{false};
+
+  // Backpressure counter common to all input states
+  std::atomic<int32_t> backpressure_counter;
+
+  std::atomic<int32_t> batches_produced{0};
+
+  // Queue to trigger processing of a given input. False acts as a poison pill
+  ConcurrentQueue<bool> process_queue;
+  // Once StartProducing is called, we initialize this thread to poll the
+  // input states and emit batches
+  std::thread process_thread;
+  arrow::Future<> process_task;
+
+  // Map arg index --> completion counter
+  std::vector<arrow::acero::AtomicCounter> counter_;
+  // Map arg index --> data
+  std::vector<InputState> accumulation_queue_;
+  std::mutex mutex_;
+  std::atomic<int> total_batches_{0};
+};
+
+}  // namespace
+
+namespace internal {
+void RegisterSortedMergeNode(ExecFactoryRegistry* registry) {
+  DCHECK_OK(registry->AddFactory("sorted_merge", SortedMergeNode::Make));
+}
+}  // namespace internal
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/sorted_merge_node_test.cc b/cpp/src/arrow/acero/sorted_merge_node_test.cc
new file mode 100644
index 0000000000000..55446d631d90c
--- /dev/null
+++ b/cpp/src/arrow/acero/sorted_merge_node_test.cc
@@ -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.
+
+#include <gtest/gtest.h>
+
+#include "arrow/acero/exec_plan.h"
+#include "arrow/acero/map_node.h"
+#include "arrow/acero/options.h"
+#include "arrow/acero/test_nodes.h"
+#include "arrow/array/builder_base.h"
+#include "arrow/array/concatenate.h"
+#include "arrow/compute/ordering.h"
+#include "arrow/result.h"
+#include "arrow/scalar.h"
+#include "arrow/table.h"
+#include "arrow/testing/generator.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/type.h"
+#include "arrow/type_fwd.h"
+
+namespace arrow::acero {
+
+std::shared_ptr<Table> TestTable(int start, int step, int rows_per_batch,
+                                 int num_batches) {
+  return gen::Gen({{"timestamp", gen::Step(start, step, /*signed_int=*/true)},
+                   {"str", gen::Random(utf8())}})
+      ->FailOnError()
+      ->Table(rows_per_batch, num_batches);
+}
+
+TEST(SortedMergeNode, Basic) {
+  auto table1 = TestTable(
+      /*start=*/0,
+      /*step=*/2,
+      /*rows_per_batch=*/2,
+      /*num_batches=*/3);
+  auto table2 = TestTable(
+      /*start=*/1,
+      /*step=*/2,
+      /*rows_per_batch=*/3,
+      /*num_batches=*/2);
+  auto table3 = TestTable(
+      /*start=*/3,
+      /*step=*/3,
+      /*rows_per_batch=*/6,
+      /*num_batches=*/1);
+  std::vector<Declaration::Input> src_decls;
+  src_decls.emplace_back(Declaration("table_source", TableSourceNodeOptions(table1)));
+  src_decls.emplace_back(Declaration("table_source", TableSourceNodeOptions(table2)));
+  src_decls.emplace_back(Declaration("table_source", TableSourceNodeOptions(table3)));
+
+  auto ops = OrderByNodeOptions(compute::Ordering({compute::SortKey("timestamp")}));
+
+  Declaration sorted_merge{"sorted_merge", src_decls, ops};
+  // We can't use threads for sorted merging since it relies on
+  // ascending deterministic order of timestamps
+  ASSERT_OK_AND_ASSIGN(auto output,
+                       DeclarationToTable(sorted_merge, /*use_threads=*/false));
+  ASSERT_EQ(output->num_rows(), 18);
+
+  ASSERT_OK_AND_ASSIGN(auto expected_ts_builder,
+                       MakeBuilder(int32(), default_memory_pool()));
+  for (auto i : {0, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 11, 12, 15, 18}) {
+    ASSERT_OK(expected_ts_builder->AppendScalar(*MakeScalar(i)));
+  }
+  ASSERT_OK_AND_ASSIGN(auto expected_ts, expected_ts_builder->Finish());
+  auto output_col = output->column(0);
+  ASSERT_OK_AND_ASSIGN(auto output_ts, Concatenate(output_col->chunks()));
+
+  AssertArraysEqual(*expected_ts, *output_ts);
+}
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/time_series_util.cc b/cpp/src/arrow/acero/time_series_util.cc
new file mode 100644
index 0000000000000..71133fef47306
--- /dev/null
+++ b/cpp/src/arrow/acero/time_series_util.cc
@@ -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.
+
+#include "arrow/array/data.h"
+
+#include "arrow/acero/time_series_util.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::acero {
+
+template <typename T, enable_if_t<std::is_integral<T>::value, bool>>
+inline uint64_t NormalizeTime(T t) {
+  uint64_t bias =
+      std::is_signed<T>::value ? static_cast<uint64_t>(1) << (8 * sizeof(T) - 1) : 0;
+  return t < 0 ? static_cast<uint64_t>(t + bias) : static_cast<uint64_t>(t);
+}
+
+uint64_t GetTime(const RecordBatch* batch, Type::type time_type, int col, uint64_t row) {
+#define LATEST_VAL_CASE(id, val)                     \
+  case Type::id: {                                   \
+    using T = typename TypeIdTraits<Type::id>::Type; \
+    using CType = typename TypeTraits<T>::CType;     \
+    return val(data->GetValues<CType>(1)[row]);      \
+  }
+
+  auto data = batch->column_data(col);
+  switch (time_type) {
+    LATEST_VAL_CASE(INT8, NormalizeTime)
+    LATEST_VAL_CASE(INT16, NormalizeTime)
+    LATEST_VAL_CASE(INT32, NormalizeTime)
+    LATEST_VAL_CASE(INT64, NormalizeTime)
+    LATEST_VAL_CASE(UINT8, NormalizeTime)
+    LATEST_VAL_CASE(UINT16, NormalizeTime)
+    LATEST_VAL_CASE(UINT32, NormalizeTime)
+    LATEST_VAL_CASE(UINT64, NormalizeTime)
+    LATEST_VAL_CASE(DATE32, NormalizeTime)
+    LATEST_VAL_CASE(DATE64, NormalizeTime)
+    LATEST_VAL_CASE(TIME32, NormalizeTime)
+    LATEST_VAL_CASE(TIME64, NormalizeTime)
+    LATEST_VAL_CASE(TIMESTAMP, NormalizeTime)
+    default:
+      DCHECK(false);
+      return 0;  // cannot happen
+  }
+
+#undef LATEST_VAL_CASE
+}
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/time_series_util.h b/cpp/src/arrow/acero/time_series_util.h
new file mode 100644
index 0000000000000..97707f43bf20b
--- /dev/null
+++ b/cpp/src/arrow/acero/time_series_util.h
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "arrow/record_batch.h"
+#include "arrow/type_traits.h"
+
+namespace arrow::acero {
+
+// normalize the value to unsigned 64-bits while preserving ordering of values
+template <typename T, enable_if_t<std::is_integral<T>::value, bool> = true>
+uint64_t NormalizeTime(T t);
+
+uint64_t GetTime(const RecordBatch* batch, Type::type time_type, int col, uint64_t row);
+
+}  // namespace arrow::acero
diff --git a/cpp/src/arrow/acero/unmaterialized_table.h b/cpp/src/arrow/acero/unmaterialized_table.h
new file mode 100644
index 0000000000000..05d6c866936e0
--- /dev/null
+++ b/cpp/src/arrow/acero/unmaterialized_table.h
@@ -0,0 +1,271 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <optional>
+#include <vector>
+#include "arrow/array/builder_base.h"
+#include "arrow/array/builder_binary.h"
+#include "arrow/array/builder_primitive.h"
+#include "arrow/memory_pool.h"
+#include "arrow/record_batch.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/logging.h"
+
+namespace arrow::acero {
+
+/// Lightweight representation of a cell of an unmaterialized table.
+///
+struct CompositeEntry {
+  RecordBatch* batch;
+  uint64_t start;
+  uint64_t end;
+};
+
+// Forward declare the builder
+template <size_t MAX_COMPOSITE_TABLES>
+class UnmaterializedSliceBuilder;
+
+/// A table of composite reference rows.  Rows maintain pointers to the
+/// constituent record batches, but the overall table retains shared_ptr
+/// references to ensure memory remains resident while the table is live.
+///
+/// The main reason for this is that, especially for wide tables, some operations
+/// such as sorted_merge or asof_join are effectively row-oriented, rather than
+/// column-oriented.  Separating the join part from the columnar materialization
+/// part simplifies the logic around data types and increases efficiency.
+///
+/// We don't put the shared_ptr's into the rows for efficiency reasons. Use
+/// UnmaterializedSliceBuilder to add ranges of record batches to this table
+template <size_t MAX_COMPOSITE_TABLES>
+class UnmaterializedCompositeTable {
+ public:
+  UnmaterializedCompositeTable(
+      const std::shared_ptr<arrow::Schema>& output_schema, size_t num_composite_tables,
+      std::unordered_map<int, std::pair<int, int>> output_col_to_src_,
+      arrow::MemoryPool* pool_ = arrow::default_memory_pool())
+      : schema(output_schema),
+        num_composite_tables(num_composite_tables),
+        output_col_to_src(std::move(output_col_to_src_)),
+        pool{pool_} {}
+
+  // Shallow wrappers around std::vector for performance
+  inline size_t capacity() { return slices.capacity(); }
+  inline void reserve(size_t num_slices) { slices.reserve(num_slices); }
+
+  inline size_t Size() const { return num_rows; }
+  inline size_t Empty() const { return num_rows == 0; }
+
+  Result<std::optional<std::shared_ptr<RecordBatch>>> Materialize() {
+    // Don't build empty batches
+    if (Empty()) {
+      return std::nullopt;
+    }
+    DCHECK_LE(Size(), (uint64_t)std::numeric_limits<int64_t>::max());
+    std::vector<std::shared_ptr<arrow::Array>> arrays(schema->num_fields());
+
+#define MATERIALIZE_CASE(id)                                                          \
+  case arrow::Type::id: {                                                             \
+    using T = typename arrow::TypeIdTraits<arrow::Type::id>::Type;                    \
+    ARROW_ASSIGN_OR_RAISE(arrays.at(i_col), materializeColumn<T>(field_type, i_col)); \
+    break;                                                                            \
+  }
+
+    // Build the arrays column-by-column from the rows
+    for (int i_col = 0; i_col < schema->num_fields(); ++i_col) {
+      const std::shared_ptr<arrow::Field>& field = schema->field(i_col);
+      const auto& field_type = field->type();
+
+      switch (field_type->id()) {
+        MATERIALIZE_CASE(BOOL)
+        MATERIALIZE_CASE(INT8)
+        MATERIALIZE_CASE(INT16)
+        MATERIALIZE_CASE(INT32)
+        MATERIALIZE_CASE(INT64)
+        MATERIALIZE_CASE(UINT8)
+        MATERIALIZE_CASE(UINT16)
+        MATERIALIZE_CASE(UINT32)
+        MATERIALIZE_CASE(UINT64)
+        MATERIALIZE_CASE(FLOAT)
+        MATERIALIZE_CASE(DOUBLE)
+        MATERIALIZE_CASE(DATE32)
+        MATERIALIZE_CASE(DATE64)
+        MATERIALIZE_CASE(TIME32)
+        MATERIALIZE_CASE(TIME64)
+        MATERIALIZE_CASE(TIMESTAMP)
+        MATERIALIZE_CASE(STRING)
+        MATERIALIZE_CASE(LARGE_STRING)
+        MATERIALIZE_CASE(BINARY)
+        MATERIALIZE_CASE(LARGE_BINARY)
+        default:
+          return arrow::Status::Invalid("Unsupported data type ",
+                                        field->type()->ToString(), " for field ",
+                                        field->name());
+      }
+    }
+
+#undef MATERIALIZE_CASE
+
+    std::shared_ptr<arrow::RecordBatch> r =
+        arrow::RecordBatch::Make(schema, (int64_t)num_rows, arrays);
+    return r;
+  }
+
+ private:
+  struct UnmaterializedSlice {
+    CompositeEntry components[MAX_COMPOSITE_TABLES];
+    size_t num_components;
+
+    inline int64_t Size() const {
+      if (num_components == 0) {
+        return 0;
+      }
+      return components[0].end - components[0].start;
+    }
+  };
+
+  // Mapping from an output column ID to a source table ID and column ID
+  std::shared_ptr<arrow::Schema> schema;
+  size_t num_composite_tables;
+  std::unordered_map<int, std::pair<int, int>> output_col_to_src;
+
+  arrow::MemoryPool* pool;
+
+  /// A map from address of a record batch to the record batch. Used to
+  /// maintain the lifetime of the record batch in case it goes out of scope
+  /// by the main exec node thread
+  std::unordered_map<uintptr_t, std::shared_ptr<arrow::RecordBatch>> ptr2Ref = {};
+  std::vector<UnmaterializedSlice> slices;
+
+  size_t num_rows = 0;
+
+  // for AddRecordBatchRef/AddSlice and access to UnmaterializedSlice
+  friend class UnmaterializedSliceBuilder<MAX_COMPOSITE_TABLES>;
+
+  void AddRecordBatchRef(const std::shared_ptr<arrow::RecordBatch>& ref) {
+    ptr2Ref[(uintptr_t)ref.get()] = ref;
+  }
+  void AddSlice(const UnmaterializedSlice& slice) {
+    slices.push_back(slice);
+    num_rows += slice.Size();
+  }
+
+  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
+  enable_if_boolean<Type, Status> static BuilderAppend(
+      Builder& builder, const std::shared_ptr<ArrayData>& source, uint64_t row) {
+    if (source->IsNull(row)) {
+      builder.UnsafeAppendNull();
+      return Status::OK();
+    }
+    builder.UnsafeAppend(bit_util::GetBit(source->template GetValues<uint8_t>(1), row));
+    return Status::OK();
+  }
+
+  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
+  enable_if_t<is_fixed_width_type<Type>::value && !is_boolean_type<Type>::value,
+              Status> static BuilderAppend(Builder& builder,
+                                           const std::shared_ptr<ArrayData>& source,
+                                           uint64_t row) {
+    if (source->IsNull(row)) {
+      builder.UnsafeAppendNull();
+      return Status::OK();
+    }
+    using CType = typename TypeTraits<Type>::CType;
+    builder.UnsafeAppend(source->template GetValues<CType>(1)[row]);
+    return Status::OK();
+  }
+
+  template <class Type, class Builder = typename TypeTraits<Type>::BuilderType>
+  enable_if_base_binary<Type, Status> static BuilderAppend(
+      Builder& builder, const std::shared_ptr<ArrayData>& source, uint64_t row) {
+    if (source->IsNull(row)) {
+      return builder.AppendNull();
+    }
+    using offset_type = typename Type::offset_type;
+    const uint8_t* data = source->buffers[2]->data();
+    const offset_type* offsets = source->GetValues<offset_type>(1);
+    const offset_type offset0 = offsets[row];
+    const offset_type offset1 = offsets[row + 1];
+    return builder.Append(data + offset0, offset1 - offset0);
+  }
+
+  template <class Type, class Builder = typename arrow::TypeTraits<Type>::BuilderType>
+  arrow::Result<std::shared_ptr<arrow::Array>> materializeColumn(
+      const std::shared_ptr<arrow::DataType>& type, int i_col) {
+    ARROW_ASSIGN_OR_RAISE(auto builderPtr, arrow::MakeBuilder(type, pool));
+    Builder& builder = *arrow::internal::checked_cast<Builder*>(builderPtr.get());
+    ARROW_RETURN_NOT_OK(builder.Reserve(num_rows));
+
+    const auto& [table_index, column_index] = output_col_to_src[i_col];
+
+    for (const auto& unmaterialized_slice : slices) {
+      const auto& [batch, start, end] = unmaterialized_slice.components[table_index];
+      if (batch) {
+        for (uint64_t rowNum = start; rowNum < end; ++rowNum) {
+          arrow::Status st = BuilderAppend<Type, Builder>(
+              builder, batch->column_data(column_index), rowNum);
+          ARROW_RETURN_NOT_OK(st);
+        }
+      } else {
+        for (uint64_t rowNum = start; rowNum < end; ++rowNum) {
+          ARROW_RETURN_NOT_OK(builder.AppendNull());
+        }
+      }
+    }
+    std::shared_ptr<arrow::Array> result;
+    ARROW_RETURN_NOT_OK(builder.Finish(&result));
+    return Result{std::move(result)};
+  }
+};
+
+/// A builder class that can append blocks of data to a row. A "slice"
+/// is built by horizontally concatenating record batches.
+template <size_t MAX_COMPOSITE_TABLES>
+class UnmaterializedSliceBuilder {
+ public:
+  explicit UnmaterializedSliceBuilder(
+      UnmaterializedCompositeTable<MAX_COMPOSITE_TABLES>* table_)
+      : table(table_) {}
+
+  void AddEntry(std::shared_ptr<RecordBatch> rb, uint64_t start, uint64_t end) {
+    if (rb) {
+      table->AddRecordBatchRef(rb);
+    }
+    if (slice.num_components) {
+      size_t last_index = slice.num_components - 1;
+      DCHECK_EQ(slice.components[last_index].end - slice.components[last_index].start,
+                end - start)
+          << "Slices should be the same length. ";
+    }
+    slice.components[slice.num_components++] = CompositeEntry{rb.get(), start, end};
+  }
+
+  void Finalize() { table->AddSlice(slice); }
+  int64_t Size() { return slice.Size(); }
+
+ private:
+  using TUnmaterializedCompositeTable =
+      UnmaterializedCompositeTable<MAX_COMPOSITE_TABLES>;
+  using TUnmaterializedSlice =
+      typename TUnmaterializedCompositeTable::UnmaterializedSlice;
+
+  TUnmaterializedCompositeTable* table;
+  TUnmaterializedSlice slice{};
+};
+
+}  // namespace arrow::acero

From 02d8bd26ef5a8a6f840d4cc98f669ea81c534487 Mon Sep 17 00:00:00 2001
From: Laurent Goujon <laurentgo@users.noreply.github.com>
Date: Mon, 6 Nov 2023 11:34:40 -0800
Subject: [PATCH 685/749] GH-38578: [Java][FlightSQL] Remove joda usage from
 flight-sql library (#38579)

### Rationale for this change

[joda](https://www.joda.org/joda-time/) is a very popular date/time manipulation library for java but the introduction of `java.time` package makes it obsolete and author actually recommends using `java.time` over `joda`

> Note that from Java SE 8 onwards, users are asked to migrate to java.time (JSR-310) - a core part of the JDK which replaces this project.

### What changes are included in this PR?

Change include the use of `java.time` classes over `joda` classes and the removal of `joda` library as a dependency

### Are these changes tested?

As there is no behavior change, it is covered by the existing tests
* Closes: #38578

Authored-by: Laurent Goujon <laurent@apache.org>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 java/flight/flight-sql-jdbc-core/pom.xml      |  6 --
 ...ArrowFlightJdbcIntervalVectorAccessor.java |  7 +-
 .../jdbc/utils/IntervalStringUtils.java       | 15 ++--
 ...wFlightJdbcIntervalVectorAccessorTest.java | 74 ++++++++++---------
 4 files changed, 49 insertions(+), 53 deletions(-)

diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index 8a0e62bde8471..cbeaa88f1e2f7 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -136,12 +136,6 @@
             <artifactId>bcpkix-jdk15on</artifactId>
             <version>1.61</version>
         </dependency>
-
-        <dependency>
-            <groupId>joda-time</groupId>
-            <artifactId>joda-time</artifactId>
-            <version>2.10.14</version>
-        </dependency>
     </dependencies>
 
     <build>
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessor.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessor.java
index 283dc9160a9e9..21d1c15712cdb 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessor.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessor.java
@@ -22,6 +22,8 @@
 import static org.apache.arrow.vector.util.DateUtility.yearsToMonths;
 
 import java.sql.SQLException;
+import java.time.Duration;
+import java.time.Period;
 import java.util.function.IntSupplier;
 
 import org.apache.arrow.driver.jdbc.accessor.ArrowFlightJdbcAccessor;
@@ -31,7 +33,6 @@
 import org.apache.arrow.vector.IntervalYearVector;
 import org.apache.arrow.vector.holders.NullableIntervalDayHolder;
 import org.apache.arrow.vector.holders.NullableIntervalYearHolder;
-import org.joda.time.Period;
 
 /**
  * Accessor for the Arrow type {@link IntervalDayVector}.
@@ -62,7 +63,7 @@ public ArrowFlightJdbcIntervalVectorAccessor(IntervalDayVector vector,
       } else {
         final int days = holder.days;
         final int millis = holder.milliseconds;
-        return formatIntervalDay(new Period().plusDays(days).plusMillis(millis));
+        return formatIntervalDay(Duration.ofDays(days).plusMillis(millis));
       }
     };
     objectClass = java.time.Duration.class;
@@ -89,7 +90,7 @@ public ArrowFlightJdbcIntervalVectorAccessor(IntervalYearVector vector,
         final int interval = holder.value;
         final int years = (interval / yearsToMonths);
         final int months = (interval % yearsToMonths);
-        return formatIntervalYear(new Period().plusYears(years).plusMonths(months));
+        return formatIntervalYear(Period.ofYears(years).plusMonths(months));
       }
     };
     objectClass = java.time.Period.class;
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/IntervalStringUtils.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/IntervalStringUtils.java
index 05643274ac348..fdf6c508d93b0 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/IntervalStringUtils.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/IntervalStringUtils.java
@@ -17,8 +17,10 @@
 
 package org.apache.arrow.driver.jdbc.utils;
 
+import java.time.Duration;
+import java.time.Period;
+
 import org.apache.arrow.vector.util.DateUtility;
-import org.joda.time.Period;
 
 /**
  * Utility class to format periods similar to Oracle's representation
@@ -36,7 +38,7 @@ private IntervalStringUtils( ) {}
    * For example, the string "+21-02" defines an interval of 21 years and 2 months.
    */
   public static String formatIntervalYear(final Period p) {
-    long months = p.getYears() * (long) DateUtility.yearsToMonths + p.getMonths();
+    long months = p.toTotalMonths();
     boolean neg = false;
     if (months < 0) {
       months = -months;
@@ -53,8 +55,8 @@ public static String formatIntervalYear(final Period p) {
    * For example, the string "-001 18:25:16.766" defines an interval of
    * - 1 day 18 hours 25 minutes 16 seconds and 766 milliseconds.
    */
-  public static String formatIntervalDay(final Period p) {
-    long millis = p.getDays() * (long) DateUtility.daysToStandardMillis + millisFromPeriod(p);
+  public static String formatIntervalDay(final Duration d) {
+    long millis = d.toMillis();
 
     boolean neg = false;
     if (millis < 0) {
@@ -76,9 +78,4 @@ public static String formatIntervalDay(final Period p) {
 
     return String.format("%c%03d %02d:%02d:%02d.%03d", neg ? '-' : '+', days, hours, minutes, seconds, millis);
   }
-
-  public static int millisFromPeriod(Period period) {
-    return period.getHours() * DateUtility.hoursToMillis + period.getMinutes() * DateUtility.minutesToMillis +
-        period.getSeconds() * DateUtility.secondsToMillis + period.getMillis();
-  }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessorTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessorTest.java
index ea228692202a7..322b7d40bd6e1 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessorTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/accessor/impl/calendar/ArrowFlightJdbcIntervalVectorAccessorTest.java
@@ -21,7 +21,6 @@
 import static org.apache.arrow.driver.jdbc.utils.IntervalStringUtils.formatIntervalYear;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
-import static org.joda.time.Period.parse;
 
 import java.time.Duration;
 import java.time.Period;
@@ -142,57 +141,62 @@ private String getStringOnVector(ValueVector vector, int index) {
     if (object == null) {
       return null;
     } else if (vector instanceof IntervalDayVector) {
-      return formatIntervalDay(parse(object));
+      return formatIntervalDay(Duration.parse(object));
     } else if (vector instanceof IntervalYearVector) {
-      return formatIntervalYear(parse(object));
+      return formatIntervalYear(Period.parse(object));
     }
     return null;
   }
 
   @Test
   public void testShouldGetIntervalYear( ) {
-    Assert.assertEquals("-002-00", formatIntervalYear(parse("P-2Y")));
-    Assert.assertEquals("-001-01", formatIntervalYear(parse("P-1Y-1M")));
-    Assert.assertEquals("-001-02", formatIntervalYear(parse("P-1Y-2M")));
-    Assert.assertEquals("-002-03", formatIntervalYear(parse("P-2Y-3M")));
-    Assert.assertEquals("-002-04", formatIntervalYear(parse("P-2Y-4M")));
-    Assert.assertEquals("-011-01", formatIntervalYear(parse("P-11Y-1M")));
-    Assert.assertEquals("+002-00", formatIntervalYear(parse("P+2Y")));
-    Assert.assertEquals("+001-01", formatIntervalYear(parse("P+1Y1M")));
-    Assert.assertEquals("+001-02", formatIntervalYear(parse("P+1Y2M")));
-    Assert.assertEquals("+002-03", formatIntervalYear(parse("P+2Y3M")));
-    Assert.assertEquals("+002-04", formatIntervalYear(parse("P+2Y4M")));
-    Assert.assertEquals("+011-01", formatIntervalYear(parse("P+11Y1M")));
+    Assert.assertEquals("-002-00", formatIntervalYear(Period.parse("P-2Y")));
+    Assert.assertEquals("-001-01", formatIntervalYear(Period.parse("P-1Y-1M")));
+    Assert.assertEquals("-001-02", formatIntervalYear(Period.parse("P-1Y-2M")));
+    Assert.assertEquals("-002-03", formatIntervalYear(Period.parse("P-2Y-3M")));
+    Assert.assertEquals("-002-04", formatIntervalYear(Period.parse("P-2Y-4M")));
+    Assert.assertEquals("-011-01", formatIntervalYear(Period.parse("P-11Y-1M")));
+    Assert.assertEquals("+002-00", formatIntervalYear(Period.parse("P+2Y")));
+    Assert.assertEquals("+001-01", formatIntervalYear(Period.parse("P+1Y1M")));
+    Assert.assertEquals("+001-02", formatIntervalYear(Period.parse("P+1Y2M")));
+    Assert.assertEquals("+002-03", formatIntervalYear(Period.parse("P+2Y3M")));
+    Assert.assertEquals("+002-04", formatIntervalYear(Period.parse("P+2Y4M")));
+    Assert.assertEquals("+011-01", formatIntervalYear(Period.parse("P+11Y1M")));
   }
 
   @Test
   public void testShouldGetIntervalDay( ) {
-    Assert.assertEquals("-001 00:00:00.000", formatIntervalDay(parse("PT-24H")));
-    Assert.assertEquals("+001 00:00:00.000", formatIntervalDay(parse("PT+24H")));
-    Assert.assertEquals("-000 01:00:00.000", formatIntervalDay(parse("PT-1H")));
-    Assert.assertEquals("-000 01:00:00.001", formatIntervalDay(parse("PT-1H-0M-00.001S")));
-    Assert.assertEquals("-000 01:01:01.000", formatIntervalDay(parse("PT-1H-1M-1S")));
-    Assert.assertEquals("-000 02:02:02.002", formatIntervalDay(parse("PT-2H-2M-02.002S")));
-    Assert.assertEquals("-000 23:59:59.999", formatIntervalDay(parse("PT-23H-59M-59.999S")));
-    Assert.assertEquals("-000 11:59:00.100", formatIntervalDay(parse("PT-11H-59M-00.100S")));
-    Assert.assertEquals("-000 05:02:03.000", formatIntervalDay(parse("PT-5H-2M-3S")));
-    Assert.assertEquals("-000 22:22:22.222", formatIntervalDay(parse("PT-22H-22M-22.222S")));
-    Assert.assertEquals("+000 01:00:00.000", formatIntervalDay(parse("PT+1H")));
-    Assert.assertEquals("+000 01:00:00.001", formatIntervalDay(parse("PT+1H0M00.001S")));
-    Assert.assertEquals("+000 01:01:01.000", formatIntervalDay(parse("PT+1H1M1S")));
-    Assert.assertEquals("+000 02:02:02.002", formatIntervalDay(parse("PT+2H2M02.002S")));
-    Assert.assertEquals("+000 23:59:59.999", formatIntervalDay(parse("PT+23H59M59.999S")));
-    Assert.assertEquals("+000 11:59:00.100", formatIntervalDay(parse("PT+11H59M00.100S")));
-    Assert.assertEquals("+000 05:02:03.000", formatIntervalDay(parse("PT+5H2M3S")));
-    Assert.assertEquals("+000 22:22:22.222", formatIntervalDay(parse("PT+22H22M22.222S")));
+    Assert.assertEquals("-001 00:00:00.000", formatIntervalDay(Duration.parse("PT-24H")));
+    Assert.assertEquals("+001 00:00:00.000", formatIntervalDay(Duration.parse("PT+24H")));
+    Assert.assertEquals("-000 01:00:00.000", formatIntervalDay(Duration.parse("PT-1H")));
+    // "JDK-8054978: java.time.Duration.parse() fails for negative duration with 0 seconds and nanos" not fixed on JDK8
+    //Assert.assertEquals("-000 01:00:00.001", formatIntervalDay(Duration.parse("PT-1H-0M-00.001S")));
+    Assert.assertEquals("-000 01:00:00.001", formatIntervalDay(Duration.ofHours(-1).minusMillis(1)));
+    Assert.assertEquals("-000 01:01:01.000", formatIntervalDay(Duration.parse("PT-1H-1M-1S")));
+    Assert.assertEquals("-000 02:02:02.002", formatIntervalDay(Duration.parse("PT-2H-2M-02.002S")));
+    Assert.assertEquals("-000 23:59:59.999", formatIntervalDay(Duration.parse("PT-23H-59M-59.999S")));
+    // "JDK-8054978: java.time.Duration.parse() fails for negative duration with 0 seconds and nanos" not fixed on JDK8
+    //Assert.assertEquals("-000 11:59:00.100", formatIntervalDay(Duration.parse("PT-11H-59M-00.100S")));
+    Assert.assertEquals("-000 11:59:00.100", 
+        formatIntervalDay(Duration.ofHours(-11).minusMinutes(59).minusMillis(100)));
+    Assert.assertEquals("-000 05:02:03.000", formatIntervalDay(Duration.parse("PT-5H-2M-3S")));
+    Assert.assertEquals("-000 22:22:22.222", formatIntervalDay(Duration.parse("PT-22H-22M-22.222S")));
+    Assert.assertEquals("+000 01:00:00.000", formatIntervalDay(Duration.parse("PT+1H")));
+    Assert.assertEquals("+000 01:00:00.001", formatIntervalDay(Duration.parse("PT+1H0M00.001S")));
+    Assert.assertEquals("+000 01:01:01.000", formatIntervalDay(Duration.parse("PT+1H1M1S")));
+    Assert.assertEquals("+000 02:02:02.002", formatIntervalDay(Duration.parse("PT+2H2M02.002S")));
+    Assert.assertEquals("+000 23:59:59.999", formatIntervalDay(Duration.parse("PT+23H59M59.999S")));
+    Assert.assertEquals("+000 11:59:00.100", formatIntervalDay(Duration.parse("PT+11H59M00.100S")));
+    Assert.assertEquals("+000 05:02:03.000", formatIntervalDay(Duration.parse("PT+5H2M3S")));
+    Assert.assertEquals("+000 22:22:22.222", formatIntervalDay(Duration.parse("PT+22H22M22.222S")));
   }
 
   @Test
   public void testIntervalDayWithJodaPeriodObject() {
     Assert.assertEquals("+1567 00:00:00.000",
-        formatIntervalDay(new org.joda.time.Period().plusDays(1567)));
+        formatIntervalDay(Duration.ofDays(1567)));
     Assert.assertEquals("-1567 00:00:00.000",
-        formatIntervalDay(new org.joda.time.Period().minusDays(1567)));
+        formatIntervalDay(Duration.ofDays(-1567)));
   }
 
   @Test

From 4ff1a29aae561cad6851a13666e4375a7645c6ef Mon Sep 17 00:00:00 2001
From: prmoore77 <prmoore77@hotmail.com>
Date: Mon, 6 Nov 2023 14:55:28 -0500
Subject: [PATCH 686/749] GH-38460: [Java][FlightRPC] Add mTLS support for
 Flight SQL JDBC driver (#38461)

### Rationale for this change

I wanted to add additional security capabilities to the Arrow Flight SQL JDBC driver so that it catches up to ADBC.  ADBC already supports mTLS - and it is a great security feature.  I wanted to bring this to the JDBC driver as well.

### What changes are included in this PR?

This PR adds support for mTLS (client certificate verification/authentication) to the Arrow Flight SQL JDBC driver.

### Are these changes tested?

Yes, I've added tests of the new mTLS functionality - and have ensured that the change is backward compatible by verifying all existing tests pass.

### Are there any user-facing changes?

Yes - but the end-user documentation for the Arrow Flight SQL JDBC driver has been updated in the PR itself.

* Closes: #38460

Lead-authored-by: prmoore77 <prmoore77@hotmail.com>
Co-authored-by: David Li <li.davidm96@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/flight_sql_jdbc_driver.rst   |  15 +
 .../org/apache/arrow/flight/FlightServer.java | 100 +++-
 .../driver/jdbc/ArrowFlightConnection.java    |   3 +
 .../client/ArrowFlightSqlClientHandler.java   |  54 ++-
 .../utils/ClientAuthenticationUtils.java      |  56 ++-
 .../ArrowFlightConnectionConfigImpl.java      |  15 +
 .../driver/jdbc/ConnectionMutualTlsTest.java  | 427 ++++++++++++++++++
 .../jdbc/ConnectionTlsRootCertsTest.java      | 352 +++++++++++++++
 .../driver/jdbc/FlightServerTestRule.java     |  22 +-
 .../jdbc/utils/FlightSqlTestCertificates.java |  10 +
 10 files changed, 1045 insertions(+), 9 deletions(-)
 create mode 100644 java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
 create mode 100644 java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java

diff --git a/docs/source/java/flight_sql_jdbc_driver.rst b/docs/source/java/flight_sql_jdbc_driver.rst
index 8268242302488..34ccfea47f9e3 100644
--- a/docs/source/java/flight_sql_jdbc_driver.rst
+++ b/docs/source/java/flight_sql_jdbc_driver.rst
@@ -114,6 +114,21 @@ case-sensitive. The supported parameters are:
      - null
      - When TLS is enabled, the password for the certificate store
 
+   * - tlsRootCerts
+     - null
+     - Path to PEM-encoded root certificates for TLS - use this as
+       an alternative to ``trustStore``
+
+   * - clientCertificate
+     - null
+     - Path to PEM-encoded client mTLS certificate when the Flight
+       SQL server requires client verification.
+
+   * - clientKey
+     - null
+     - Path to PEM-encoded client mTLS key when the Flight
+       SQL server requires client verification.
+
    * - useEncryption
      - true
      - Whether to use TLS (the default is an encrypted connection)
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightServer.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightServer.java
index 7f15798f6a326..234c9bdcaacc1 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightServer.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/FlightServer.java
@@ -34,6 +34,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 
+import javax.net.ssl.SSLException;
+
 import org.apache.arrow.flight.auth.ServerAuthHandler;
 import org.apache.arrow.flight.auth.ServerAuthInterceptor;
 import org.apache.arrow.flight.auth2.Auth2Constants;
@@ -49,9 +51,14 @@
 
 import io.grpc.Server;
 import io.grpc.ServerInterceptors;
+import io.grpc.netty.GrpcSslContexts;
 import io.grpc.netty.NettyServerBuilder;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.ServerChannel;
+import io.netty.handler.ssl.ClientAuth;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+
 
 /**
  * Generic server of flight data that is customized via construction with delegate classes for the
@@ -172,6 +179,8 @@ public static final class Builder {
     private int maxInboundMessageSize = MAX_GRPC_MESSAGE_SIZE;
     private InputStream certChain;
     private InputStream key;
+    private InputStream mTlsCACert;
+    private SslContext sslContext;
     private final List<KeyFactory<?>> interceptors;
     // Keep track of inserted interceptors
     private final Set<String> interceptorKeys;
@@ -245,7 +254,25 @@ public FlightServer build() {
       }
 
       if (certChain != null) {
-        builder.useTransportSecurity(certChain, key);
+        SslContextBuilder sslContextBuilder = GrpcSslContexts
+                .forServer(certChain, key);
+
+        if (mTlsCACert != null) {
+          sslContextBuilder
+                  .clientAuth(ClientAuth.REQUIRE)
+                  .trustManager(mTlsCACert);
+        }
+        try {
+          sslContext = sslContextBuilder.build();
+        } catch (SSLException e) {
+          throw new RuntimeException(e);
+        } finally {
+          closeMTlsCACert();
+          closeCertChain();
+          closeKey();
+        }
+
+        builder.sslContext(sslContext);
       }
 
       // Share one executor between the gRPC service, DoPut, and Handshake
@@ -306,14 +333,69 @@ public Builder maxInboundMessageSize(int maxMessageSize) {
       return this;
     }
 
+    /**
+     * A small utility function to ensure that InputStream attributes.
+     * are closed if they are not null
+     * @param stream The InputStream to close (if it is not null).
+     */
+    private void closeInputStreamIfNotNull(InputStream stream) {
+      if (stream != null) {
+        try {
+          stream.close();
+        } catch (IOException ignored) {
+        }
+      }
+    }
+
+    /**
+     * A small utility function to ensure that the certChain attribute
+     * is closed if it is not null.  It then sets the attribute to null.
+     */
+    private void closeCertChain() {
+      closeInputStreamIfNotNull(certChain);
+      certChain = null;
+    }
+
+    /**
+     * A small utility function to ensure that the key attribute
+     * is closed if it is not null.  It then sets the attribute to null.
+     */
+    private void closeKey() {
+      closeInputStreamIfNotNull(key);
+      key = null;
+    }
+
+    /**
+     * A small utility function to ensure that the mTlsCACert attribute
+     * is closed if it is not null.  It then sets the attribute to null.
+     */
+    private void closeMTlsCACert() {
+      closeInputStreamIfNotNull(mTlsCACert);
+      mTlsCACert = null;
+    }
+
     /**
      * Enable TLS on the server.
      * @param certChain The certificate chain to use.
      * @param key The private key to use.
      */
     public Builder useTls(final File certChain, final File key) throws IOException {
+      closeCertChain();
       this.certChain = new FileInputStream(certChain);
+
+      closeKey();
       this.key = new FileInputStream(key);
+
+      return this;
+    }
+
+    /**
+     * Enable Client Verification via mTLS on the server.
+     * @param mTlsCACert The CA certificate to use for verifying clients.
+     */
+    public Builder useMTlsClientVerification(final File mTlsCACert) throws IOException {
+      closeMTlsCACert();
+      this.mTlsCACert = new FileInputStream(mTlsCACert);
       return this;
     }
 
@@ -322,9 +404,23 @@ public Builder useTls(final File certChain, final File key) throws IOException {
      * @param certChain The certificate chain to use.
      * @param key The private key to use.
      */
-    public Builder useTls(final InputStream certChain, final InputStream key) {
+    public Builder useTls(final InputStream certChain, final InputStream key) throws IOException {
+      closeCertChain();
       this.certChain = certChain;
+
+      closeKey();
       this.key = key;
+
+      return this;
+    }
+
+    /**
+     * Enable mTLS on the server.
+     * @param mTlsCACert The CA certificate to use for verifying clients.
+     */
+    public Builder useMTlsClientVerification(final InputStream mTlsCACert) throws IOException {
+      closeMTlsCACert();
+      this.mTlsCACert = mTlsCACert;
       return this;
     }
 
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
index 79bc04d27fe01..fdbb9381c0a55 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
@@ -101,6 +101,9 @@ private static ArrowFlightSqlClientHandler createNewClientHandler(
           .withTrustStorePath(config.getTrustStorePath())
           .withTrustStorePassword(config.getTrustStorePassword())
           .withSystemTrustStore(config.useSystemTrustStore())
+          .withTlsRootCertificates(config.getTlsRootCertificatesPath())
+          .withClientCertificate(config.getClientCertificatePath())
+          .withClientKey(config.getClientKeyPath())
           .withBufferAllocator(allocator)
           .withEncryption(config.useEncryption())
           .withDisableCertificateVerification(config.getDisableCertificateVerification())
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
index 66372092b8e99..75e80d45dc669 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
@@ -433,6 +433,9 @@ public static final class Builder {
     private boolean useEncryption;
     private boolean disableCertificateVerification;
     private boolean useSystemTrustStore;
+    private String tlsRootCertificatesPath;
+    private String clientCertificatePath;
+    private String clientKeyPath;
     private BufferAllocator allocator;
 
     public Builder() {
@@ -457,6 +460,9 @@ private Builder(Builder original) {
       this.useEncryption = original.useEncryption;
       this.disableCertificateVerification = original.disableCertificateVerification;
       this.useSystemTrustStore = original.useSystemTrustStore;
+      this.tlsRootCertificatesPath = original.tlsRootCertificatesPath;
+      this.clientCertificatePath = original.clientCertificatePath;
+      this.clientKeyPath = original.clientKeyPath;
       this.allocator = original.allocator;
     }
 
@@ -560,7 +566,42 @@ public Builder withSystemTrustStore(final boolean useSystemTrustStore) {
     }
 
     /**
-     * Sets the token used in the token authetication.
+     * Sets the TLS root certificate path as an alternative to using the System
+     * or other Trust Store.  The path must contain a valid PEM file.
+     *
+     * @param tlsRootCertificatesPath the TLS root certificate path (if TLS is required).
+     * @return this instance.
+     */
+    public Builder withTlsRootCertificates(final String tlsRootCertificatesPath) {
+      this.tlsRootCertificatesPath = tlsRootCertificatesPath;
+      return this;
+    }
+
+    /**
+     * Sets the mTLS client certificate path (if mTLS is required).
+     *
+     * @param clientCertificatePath the mTLS client certificate path (if mTLS is required).
+     * @return this instance.
+     */
+    public Builder withClientCertificate(final String clientCertificatePath) {
+      this.clientCertificatePath = clientCertificatePath;
+      return this;
+    }
+
+    /**
+     * Sets the mTLS client certificate private key path (if mTLS is required).
+     *
+     * @param clientKeyPath the mTLS client certificate private key path (if mTLS is required).
+     * @return this instance.
+     */
+    public Builder withClientKey(final String clientKeyPath) {
+      this.clientKeyPath = clientKeyPath;
+      return this;
+    }
+    
+    /**
+     * Sets the token used in the token authentication.
+     *
      * @param token the token value.
      * @return      this builder instance.
      */
@@ -660,7 +701,10 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
           if (disableCertificateVerification) {
             clientBuilder.verifyServer(false);
           } else {
-            if (useSystemTrustStore) {
+            if (tlsRootCertificatesPath != null) {
+              clientBuilder.trustedCertificates(
+                      ClientAuthenticationUtils.getTlsRootCertificatesStream(tlsRootCertificatesPath));
+            } else if (useSystemTrustStore) {
               clientBuilder.trustedCertificates(
                   ClientAuthenticationUtils.getCertificateInputStreamFromSystem(trustStorePassword));
             } else if (trustStorePath != null) {
@@ -668,6 +712,12 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
                   ClientAuthenticationUtils.getCertificateStream(trustStorePath, trustStorePassword));
             }
           }
+
+          if (clientCertificatePath != null && clientKeyPath != null) {
+            clientBuilder.clientCertificate(
+                ClientAuthenticationUtils.getClientCertificateStream(clientCertificatePath),
+                ClientAuthenticationUtils.getClientKeyStream(clientKeyPath));
+          }
         }
 
         client = clientBuilder.build();
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtils.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtils.java
index 6d9880bd27048..d50dc385a62e1 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtils.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/utils/ClientAuthenticationUtils.java
@@ -227,14 +227,64 @@ public static InputStream getCertificateStream(final String keyStorePath,
     final KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
 
     try (final InputStream keyStoreStream = Files
-        .newInputStream(Paths.get(Preconditions.checkNotNull(keyStorePath)))) {
-      keyStore.load(keyStoreStream,
-          Preconditions.checkNotNull(keyStorePass).toCharArray());
+        .newInputStream(Paths.get(keyStorePath))) {
+      keyStore.load(keyStoreStream, keyStorePass.toCharArray());
     }
 
     return getSingleCertificateInputStream(keyStore);
   }
 
+  /**
+   * Generates an {@link InputStream} that contains certificates for path-based
+   * TLS Root Certificates.
+   *
+   * @param tlsRootsCertificatesPath The path of the TLS Root Certificates.
+   * @return a new {code InputStream} containing the certificates.
+   * @throws GeneralSecurityException on error.
+   * @throws IOException              on error.
+   */
+  public static InputStream getTlsRootCertificatesStream(final String tlsRootsCertificatesPath)
+          throws GeneralSecurityException, IOException {
+    Preconditions.checkNotNull(tlsRootsCertificatesPath, "TLS Root certificates path cannot be null!");
+
+    return Files
+      .newInputStream(Paths.get(tlsRootsCertificatesPath));
+  }
+
+  /**
+   * Generates an {@link InputStream} that contains certificates for a path-based
+   * mTLS Client Certificate.
+   *
+   * @param clientCertificatePath The path of the mTLS Client Certificate.
+   * @return a new {code InputStream} containing the certificates.
+   * @throws GeneralSecurityException on error.
+   * @throws IOException              on error.
+   */
+  public static InputStream getClientCertificateStream(final String clientCertificatePath)
+      throws GeneralSecurityException, IOException {
+    Preconditions.checkNotNull(clientCertificatePath, "Client certificate path cannot be null!");
+
+    return Files
+      .newInputStream(Paths.get(clientCertificatePath));
+  }
+
+  /**
+   * Generates an {@link InputStream} that contains certificates for a path-based
+   * mTLS Client Key.
+   *
+   * @param clientKeyPath The path of the mTLS Client Key.
+   * @return a new {code InputStream} containing the certificates.
+   * @throws GeneralSecurityException on error.
+   * @throws IOException              on error.
+   */
+  public static InputStream getClientKeyStream(final String clientKeyPath)
+          throws GeneralSecurityException, IOException {
+    Preconditions.checkNotNull(clientKeyPath, "Client key path cannot be null!");
+
+    return Files
+      .newInputStream(Paths.get(clientKeyPath));
+  }
+
   private static InputStream getSingleCertificateInputStream(KeyStore keyStore)
       throws KeyStoreException, IOException, CertificateException {
     final Enumeration<String> aliases = keyStore.aliases();
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
index ac338a85d6292..59118e1d6f788 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
@@ -109,6 +109,18 @@ public boolean useSystemTrustStore() {
     return ArrowFlightConnectionProperty.USE_SYSTEM_TRUST_STORE.getBoolean(properties);
   }
 
+  public String getTlsRootCertificatesPath() {
+    return ArrowFlightConnectionProperty.TLS_ROOT_CERTS.getString(properties);
+  }
+
+  public String getClientCertificatePath() {
+    return ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.getString(properties);
+  }
+
+  public String getClientKeyPath() {
+    return ArrowFlightConnectionProperty.CLIENT_KEY.getString(properties);
+  }
+
   /**
    * Whether to use TLS encryption.
    *
@@ -175,6 +187,9 @@ public enum ArrowFlightConnectionProperty implements ConnectionProperty {
     TRUST_STORE("trustStore", null, Type.STRING, false),
     TRUST_STORE_PASSWORD("trustStorePassword", null, Type.STRING, false),
     USE_SYSTEM_TRUST_STORE("useSystemTrustStore", true, Type.BOOLEAN, false),
+    TLS_ROOT_CERTS("tlsRootCerts", null, Type.STRING, false),
+    CLIENT_CERTIFICATE("clientCertificate", null, Type.STRING, false),
+    CLIENT_KEY("clientKey", null, Type.STRING, false),
     THREAD_POOL_SIZE("threadPoolSize", 1, Type.NUMBER, false),
     TOKEN("token", null, Type.STRING, false);
 
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
new file mode 100644
index 0000000000000..783e0c41e9269
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
@@ -0,0 +1,427 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+
+import java.io.File;
+import java.net.URLEncoder;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import org.apache.arrow.driver.jdbc.authentication.UserPasswordAuthentication;
+import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler;
+import org.apache.arrow.driver.jdbc.utils.ArrowFlightConnectionConfigImpl.ArrowFlightConnectionProperty;
+import org.apache.arrow.driver.jdbc.utils.FlightSqlTestCertificates;
+import org.apache.arrow.driver.jdbc.utils.MockFlightSqlProducer;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.util.AutoCloseables;
+import org.apache.calcite.avatica.org.apache.http.auth.UsernamePasswordCredentials;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+/**
+ * Tests encrypted connections.
+ */
+public class ConnectionMutualTlsTest {
+
+  @ClassRule
+  public static final FlightServerTestRule FLIGHT_SERVER_TEST_RULE;
+  private static final String tlsRootCertsPath;
+
+  private static final String serverMTlsCACertPath;
+  private static final String clientMTlsCertPath;
+  private static final String badClientMTlsCertPath;
+  private static final String clientMTlsKeyPath;
+  private static final String badClientMTlsKeyPath;
+  private static final MockFlightSqlProducer PRODUCER = new MockFlightSqlProducer();
+  private static final String userTest = "user1";
+  private static final String passTest = "pass1";
+
+  static {
+    final FlightSqlTestCertificates.CertKeyPair
+        certKey = FlightSqlTestCertificates.exampleTlsCerts().get(0);
+
+    tlsRootCertsPath = certKey.cert.getPath();
+
+    final File serverMTlsCACert = FlightSqlTestCertificates.exampleCACert();
+
+    serverMTlsCACertPath = serverMTlsCACert.getPath();
+
+    final FlightSqlTestCertificates.CertKeyPair
+        clientMTlsCertKey = FlightSqlTestCertificates.exampleTlsCerts().get(1);
+
+    clientMTlsCertPath = clientMTlsCertKey.cert.getPath();
+    clientMTlsKeyPath = clientMTlsCertKey.key.getPath();
+
+    badClientMTlsCertPath = clientMTlsCertPath + ".bad";
+    badClientMTlsKeyPath = clientMTlsKeyPath + ".bad";
+
+    UserPasswordAuthentication authentication = new UserPasswordAuthentication.Builder()
+            .user(userTest, passTest)
+            .build();
+
+    FLIGHT_SERVER_TEST_RULE = new FlightServerTestRule.Builder()
+        .authentication(authentication)
+        .useEncryption(certKey.cert, certKey.key)
+        .useMTlsClientVerification(serverMTlsCACert)
+        .producer(PRODUCER)
+        .build();
+  }
+
+  private BufferAllocator allocator;
+
+  @Before
+  public void setUp() throws Exception {
+    allocator = new RootAllocator(Long.MAX_VALUE);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    allocator.getChildAllocators().forEach(BufferAllocator::close);
+    AutoCloseables.close(allocator);
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetEncryptedClientAuthenticated() throws Exception {
+    final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
+        userTest, passTest);
+
+    try (ArrowFlightSqlClientHandler client =
+             new ArrowFlightSqlClientHandler.Builder()
+                 .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+                 .withUsername(credentials.getUserName())
+                 .withPassword(credentials.getPassword())
+                 .withTlsRootCertificates(tlsRootCertsPath)
+                 .withClientCertificate(clientMTlsCertPath)
+                 .withClientKey(clientMTlsKeyPath)
+                 .withBufferAllocator(allocator)
+                 .withEncryption(true)
+                 .build()) {
+      assertNotNull(client);
+    }
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient providing a bad mTLS Cert Path. It's expected to
+   * receive the SQLException.
+   */
+  @Test
+  public void testGetEncryptedClientWithBadMTlsCertPath() {
+    final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
+            userTest, passTest);
+
+    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
+            .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+            .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+            .withUsername(credentials.getUserName())
+            .withPassword(credentials.getPassword())
+            .withTlsRootCertificates(tlsRootCertsPath)
+            .withClientCertificate(badClientMTlsCertPath)
+            .withClientKey(clientMTlsKeyPath)
+            .withBufferAllocator(allocator)
+            .withEncryption(true)
+            .build());
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient providing a bad mTLS Key Path. It's expected to
+   * receive the SQLException.
+   */
+  @Test
+  public void testGetEncryptedClientWithBadMTlsKeyPath() {
+    final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
+            userTest, passTest);
+
+    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
+                         .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                         .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+                         .withUsername(credentials.getUserName())
+                         .withPassword(credentials.getPassword())
+                         .withTlsRootCertificates(tlsRootCertsPath)
+                         .withClientCertificate(clientMTlsCertPath)
+                         .withClientKey(badClientMTlsKeyPath)
+                         .withBufferAllocator(allocator)
+                         .withEncryption(true)
+                         .build());
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient without credentials.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetNonAuthenticatedEncryptedClientNoAuth() throws Exception {
+    try (ArrowFlightSqlClientHandler client =
+             new ArrowFlightSqlClientHandler.Builder()
+                 .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withTlsRootCertificates(tlsRootCertsPath)
+                 .withClientCertificate(clientMTlsCertPath)
+                 .withClientKey(clientMTlsKeyPath)
+                 .withBufferAllocator(allocator)
+                 .withEncryption(true)
+                 .build()) {
+      assertNotNull(client);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when the
+   * provided valid credentials and a valid TLS Root Certs path.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetEncryptedConnectionWithValidCredentialsAndTlsRootsPath() throws Exception {
+    final Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.HOST.camelName(), "localhost");
+    properties.put(ArrowFlightConnectionProperty.PORT.camelName(),
+        FLIGHT_SERVER_TEST_RULE.getPort());
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(),
+        userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(),
+        passTest);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+        tlsRootCertsPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(),
+        clientMTlsCertPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(),
+        clientMTlsKeyPath);
+
+    final ArrowFlightJdbcDataSource dataSource =
+        ArrowFlightJdbcDataSource.createNewDataSource(properties);
+    try (final Connection connection = dataSource.getConnection()) {
+      assert connection.isValid(300);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when not
+   * providing authentication.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetNonAuthenticatedEncryptedConnection() throws Exception {
+    final Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.HOST.camelName(), FLIGHT_SERVER_TEST_RULE.getHost());
+    properties.put(ArrowFlightConnectionProperty.PORT.camelName(), FLIGHT_SERVER_TEST_RULE.getPort());
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), true);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(), clientMTlsCertPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(), clientMTlsKeyPath);
+
+    final ArrowFlightJdbcDataSource dataSource = ArrowFlightJdbcDataSource.createNewDataSource(properties);
+    try (final Connection connection = dataSource.getConnection()) {
+      assert connection.isValid(300);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through
+   * the DriverManager using just a connection url.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    final String jdbcUrl = String.format(
+            "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
+                    "&useEncryption=true&%s=%s&%s=%s&%s=%s",
+            FLIGHT_SERVER_TEST_RULE.getPort(),
+            userTest,
+            passTest,
+            ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8"),
+            ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(),
+            URLEncoder.encode(clientMTlsCertPath, "UTF-8"),
+            ArrowFlightConnectionProperty.CLIENT_KEY.camelName(),
+            URLEncoder.encode(clientMTlsKeyPath, "UTF-8"));
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with String K-V pairs.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingSetPropertyWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.setProperty(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.setProperty(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "true");
+    properties.setProperty(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(), clientMTlsCertPath);
+    properties.setProperty(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(), clientMTlsKeyPath);
+
+    final String jdbcUrl = String.format(
+            "jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort());
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl, properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with Object K-V pairs.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingPutWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), true);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(), clientMTlsCertPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(), clientMTlsKeyPath);
+
+    final String jdbcUrl = String.format(
+            "jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort());
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl, properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * just a connection url and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    final String jdbcUrl = String.format(
+            "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
+                    "&useEncryption=1&useSystemTrustStore=0&%s=%s&%s=%s&%s=%s",
+            FLIGHT_SERVER_TEST_RULE.getPort(),
+            userTest,
+            passTest,
+            ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8"),
+            ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(),
+            URLEncoder.encode(clientMTlsCertPath, "UTF-8"),
+            ArrowFlightConnectionProperty.CLIENT_KEY.camelName(),
+            URLEncoder.encode(clientMTlsKeyPath, "UTF-8"));
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with String K-V pairs and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsingSetPropertyWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.setProperty(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.setProperty(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "1");
+    properties.setProperty(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(), clientMTlsCertPath);
+    properties.setProperty(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(), clientMTlsKeyPath);
+
+    final String jdbcUrl = String.format("jdbc:arrow-flight-sql://localhost:%s", FLIGHT_SERVER_TEST_RULE.getPort());
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl, properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with Object K-V pairs and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsingPutWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), 1);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_CERTIFICATE.camelName(), clientMTlsCertPath);
+    properties.put(ArrowFlightConnectionProperty.CLIENT_KEY.camelName(), clientMTlsKeyPath);
+
+    final String jdbcUrl = String.format("jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort());
+
+    try (Connection connection = DriverManager.getConnection(jdbcUrl, properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java
new file mode 100644
index 0000000000000..333c474824e52
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java
@@ -0,0 +1,352 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.driver.jdbc;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+
+import java.net.URLEncoder;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+import org.apache.arrow.driver.jdbc.authentication.UserPasswordAuthentication;
+import org.apache.arrow.driver.jdbc.client.ArrowFlightSqlClientHandler;
+import org.apache.arrow.driver.jdbc.utils.ArrowFlightConnectionConfigImpl.ArrowFlightConnectionProperty;
+import org.apache.arrow.driver.jdbc.utils.FlightSqlTestCertificates;
+import org.apache.arrow.driver.jdbc.utils.MockFlightSqlProducer;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.apache.arrow.util.AutoCloseables;
+import org.apache.calcite.avatica.org.apache.http.auth.UsernamePasswordCredentials;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+
+/**
+ * Tests encrypted connections.
+ */
+public class ConnectionTlsRootCertsTest {
+
+  @ClassRule
+  public static final FlightServerTestRule FLIGHT_SERVER_TEST_RULE;
+  private static final String tlsRootCertsPath;
+  private static final String badTlsRootCertsPath;
+  private static final MockFlightSqlProducer PRODUCER = new MockFlightSqlProducer();
+  private static final String userTest = "user1";
+  private static final String passTest = "pass1";
+
+  static {
+    final FlightSqlTestCertificates.CertKeyPair
+        certKey = FlightSqlTestCertificates.exampleTlsCerts().get(0);
+
+    tlsRootCertsPath = certKey.cert.getPath();
+
+    badTlsRootCertsPath = certKey.cert.getPath() + ".bad";
+
+    UserPasswordAuthentication authentication = new UserPasswordAuthentication.Builder()
+            .user(userTest, passTest)
+            .build();
+
+    FLIGHT_SERVER_TEST_RULE = new FlightServerTestRule.Builder()
+        .authentication(authentication)
+        .useEncryption(certKey.cert, certKey.key)
+        .producer(PRODUCER)
+        .build();
+  }
+
+  private BufferAllocator allocator;
+
+  @Before
+  public void setUp() throws Exception {
+    allocator = new RootAllocator(Long.MAX_VALUE);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    allocator.getChildAllocators().forEach(BufferAllocator::close);
+    AutoCloseables.close(allocator);
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetEncryptedClientAuthenticated() throws Exception {
+    final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
+        userTest, passTest);
+
+    try (ArrowFlightSqlClientHandler client =
+             new ArrowFlightSqlClientHandler.Builder()
+                 .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+                 .withUsername(credentials.getUserName())
+                 .withPassword(credentials.getPassword())
+                 .withTlsRootCertificates(tlsRootCertsPath)
+                 .withBufferAllocator(allocator)
+                 .withEncryption(true)
+                 .build()) {
+      assertNotNull(client);
+    }
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient providing a bad TLS Root Certs Path. It's expected to
+   * receive the SQLException.
+   */
+  @Test
+  public void testGetEncryptedClientWithNoCertificateOnKeyStore() {
+    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
+            .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+            .withTlsRootCertificates(badTlsRootCertsPath)
+            .withBufferAllocator(allocator)
+            .withEncryption(true)
+            .build());
+  }
+
+  /**
+   * Try to instantiate an encrypted FlightClient without credentials.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetNonAuthenticatedEncryptedClientNoAuth() throws Exception {
+    try (ArrowFlightSqlClientHandler client =
+             new ArrowFlightSqlClientHandler.Builder()
+                 .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withTlsRootCertificates(tlsRootCertsPath)
+                 .withBufferAllocator(allocator)
+                 .withEncryption(true)
+                 .build()) {
+      assertNotNull(client);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when the
+   * provided valid credentials and a valid TLS Root Certs path.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetEncryptedConnectionWithValidCredentialsAndTlsRootsPath() throws Exception {
+    final Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.HOST.camelName(), "localhost");
+    properties.put(ArrowFlightConnectionProperty.PORT.camelName(),
+        FLIGHT_SERVER_TEST_RULE.getPort());
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(),
+        userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(),
+        passTest);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+        tlsRootCertsPath);
+
+    final ArrowFlightJdbcDataSource dataSource =
+        ArrowFlightJdbcDataSource.createNewDataSource(properties);
+    try (final Connection connection = dataSource.getConnection()) {
+      assert connection.isValid(300);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when not
+   * providing authentication.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testGetNonAuthenticatedEncryptedConnection() throws Exception {
+    final Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.HOST.camelName(), FLIGHT_SERVER_TEST_RULE.getHost());
+    properties.put(ArrowFlightConnectionProperty.PORT.camelName(), FLIGHT_SERVER_TEST_RULE.getPort());
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), true);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+
+    final ArrowFlightJdbcDataSource dataSource = ArrowFlightJdbcDataSource.createNewDataSource(properties);
+    try (final Connection connection = dataSource.getConnection()) {
+      assert connection.isValid(300);
+    }
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through
+   * the DriverManager using just a connection url.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    final Connection connection = DriverManager.getConnection(
+        String.format(
+            "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
+                "&useEncryption=true&%s=%s",
+            FLIGHT_SERVER_TEST_RULE.getPort(),
+            userTest,
+            passTest,
+            ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8")));
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with String K-V pairs.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingSetPropertyWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.setProperty(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.setProperty(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "true");
+
+    final Connection connection = DriverManager.getConnection(
+        String.format(
+            "jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort()),
+        properties);
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with Object K-V pairs.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingPutWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), true);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+
+    final Connection connection = DriverManager.getConnection(
+        String.format(
+            "jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort()),
+        properties);
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * just a connection url and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    final Connection connection = DriverManager.getConnection(
+        String.format(
+            "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
+                "&useEncryption=1&useSystemTrustStore=0&%s=%s",
+            FLIGHT_SERVER_TEST_RULE.getPort(),
+            userTest,
+            passTest,
+            ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8")));
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with String K-V pairs and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsingSetPropertyWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.setProperty(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.setProperty(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+    properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "1");
+
+    final Connection connection = DriverManager.getConnection(
+        String.format("jdbc:arrow-flight-sql://localhost:%s", FLIGHT_SERVER_TEST_RULE.getPort()),
+        properties);
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+
+  /**
+   * Check if an encrypted connection can be established successfully when connecting through the DriverManager using
+   * a connection url and properties with Object K-V pairs and using 0 and 1 as ssl values.
+   *
+   * @throws Exception on error.
+   */
+  @Test
+  public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsingPutWithDriverManager()
+      throws Exception {
+    final Driver driver = new ArrowFlightJdbcDriver();
+    DriverManager.registerDriver(driver);
+
+    Properties properties = new Properties();
+
+    properties.put(ArrowFlightConnectionProperty.USER.camelName(), userTest);
+    properties.put(ArrowFlightConnectionProperty.PASSWORD.camelName(), passTest);
+    properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), 1);
+    properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
+
+    final Connection connection = DriverManager.getConnection(
+        String.format("jdbc:arrow-flight-sql://localhost:%s",
+            FLIGHT_SERVER_TEST_RULE.getPort()),
+        properties);
+    Assert.assertTrue(connection.isValid(0));
+    connection.close();
+  }
+}
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
index 733145892ec3e..df7cbea56ee2f 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
@@ -63,6 +63,7 @@ public class FlightServerTestRule implements TestRule, AutoCloseable {
   private final FlightSqlProducer producer;
   private final Authentication authentication;
   private final CertKeyPair certKeyPair;
+  private final File mTlsCACert;
 
   private final MiddlewareCookie.Factory middlewareCookieFactory = new MiddlewareCookie.Factory();
 
@@ -71,13 +72,15 @@ private FlightServerTestRule(final Properties properties,
                                final BufferAllocator allocator,
                                final FlightSqlProducer producer,
                                final Authentication authentication,
-                               final CertKeyPair certKeyPair) {
+                               final CertKeyPair certKeyPair,
+                               final File mTlsCACert) {
     this.properties = Preconditions.checkNotNull(properties);
     this.config = Preconditions.checkNotNull(config);
     this.allocator = Preconditions.checkNotNull(allocator);
     this.producer = Preconditions.checkNotNull(producer);
     this.authentication = authentication;
     this.certKeyPair = certKeyPair;
+    this.mTlsCACert = mTlsCACert;
   }
 
   /**
@@ -142,6 +145,9 @@ private FlightServer initiateServer(Location location) throws IOException {
     if (certKeyPair != null) {
       builder.useTls(certKeyPair.cert, certKeyPair.key);
     }
+    if (mTlsCACert != null) {
+      builder.useMTlsClientVerification(mTlsCACert);
+    }
     return builder.build();
   }
 
@@ -212,6 +218,7 @@ public static final class Builder {
     private FlightSqlProducer producer;
     private Authentication authentication;
     private CertKeyPair certKeyPair;
+    private File mTlsCACert;
 
     public Builder() {
       this.properties = new Properties();
@@ -254,6 +261,17 @@ public Builder useEncryption(final File certChain, final File key) {
       return this;
     }
 
+    /**
+     * Enable Client Verification via mTLS on the server.
+     *
+     * @param mTlsCACert The CA certificate to use for client verification.
+     * @return the Builder.
+     */
+    public Builder useMTlsClientVerification(final File mTlsCACert) {
+      this.mTlsCACert = mTlsCACert;
+      return this;
+    }
+
     /**
      * Builds the {@link FlightServerTestRule} using the provided values.
      *
@@ -262,7 +280,7 @@ public Builder useEncryption(final File certChain, final File key) {
     public FlightServerTestRule build() {
       authentication.populateProperties(properties);
       return new FlightServerTestRule(properties, new ArrowFlightConnectionConfigImpl(properties),
-          new RootAllocator(Long.MAX_VALUE), producer, authentication, certKeyPair);
+          new RootAllocator(Long.MAX_VALUE), producer, authentication, certKeyPair, mTlsCACert);
     }
   }
 
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightSqlTestCertificates.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightSqlTestCertificates.java
index a2b1864c02657..89e27be9f53da 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightSqlTestCertificates.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/FlightSqlTestCertificates.java
@@ -51,6 +51,16 @@ static Path getFlightTestDataRoot() {
     return getTestDataRoot().resolve("flight");
   }
 
+  /**
+   * Create File object with the CA certificate.
+   *
+   * @return A File containing the Root CA certificate.
+   */
+  public static File exampleCACert() {
+    final Path root = getFlightTestDataRoot();
+    return root.resolve("root-ca.pem").toFile();
+  }
+
   /**
    * Create CertKeyPair object with the certificates and keys.
    *

From 09e5e6a0020300a73c8e95ec279eea39a52a9ef8 Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Mon, 6 Nov 2023 13:15:14 -0800
Subject: [PATCH 687/749] GH-36912: [Java] JDBC driver stops consuming roots if
 it sees an empty root (#38590)

### Rationale for this change
The JDBC driver for Flight SQL incorrectly stops iterating on a FlightStream if it encounters an empty root.

### What changes are included in this PR?
The driver now waits until FlightStream#next() returns false to determine if a FlightStream is fully-consumed instead of an empty root.

### Are these changes tested?
Yes, new tests have been written.

### Are there any user-facing changes?
No
* Closes: #36912

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../jdbc/utils/FlightEndpointDataQueue.java   | 13 ++++---
 .../arrow/driver/jdbc/ResultSetTest.java      | 13 +++++++
 .../jdbc/utils/CoreMockedSqlProducers.java    | 36 +++++++++++++++++++
 3 files changed, 57 insertions(+), 5 deletions(-)

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
index 71cafd2ec3075..1198d89c40aef 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/FlightEndpointDataQueue.java
@@ -104,9 +104,8 @@ private CloseableEndpointStreamPair next(final EndpointStreamSupplier endpointSt
       futures.remove(future);
       try {
         final CloseableEndpointStreamPair endpoint = future.get();
-        // Get the next FlightStream with content.
-        // The stream is non-empty.
-        if (endpoint.getStream().getRoot().getRowCount() > 0) {
+        // Get the next FlightStream that has a root with content.
+        if (endpoint != null) {
           return endpoint;
         }
       } catch (final ExecutionException | InterruptedException | CancellationException e) {
@@ -178,8 +177,12 @@ public synchronized void enqueue(final CloseableEndpointStreamPair endpointReque
     endpointsToClose.add(endpointRequest);
     futures.add(completionService.submit(() -> {
       // `FlightStream#next` will block until new data can be read or stream is over.
-      endpointRequest.getStream().next();
-      return endpointRequest;
+      while (endpointRequest.getStream().next()) {
+        if (endpointRequest.getStream().getRoot().getRowCount() > 0) {
+          return endpointRequest;
+        }
+      }
+      return null;
     }));
   }
 
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
index e2ac100b8dc36..5b9e269fb3cc8 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
@@ -455,4 +455,17 @@ allocator, forGrpcInsecure("localhost", 0), rootProducer)
       }
     }
   }
+
+  @Test
+  public void testShouldRunSelectQueryWithEmptyVectorsEmbedded() throws Exception {
+    try (Statement statement = connection.createStatement();
+         ResultSet resultSet = statement.executeQuery(
+             CoreMockedSqlProducers.LEGACY_REGULAR_WITH_EMPTY_SQL_CMD)) {
+      long rowCount = 0;
+      while (resultSet.next()) {
+        ++rowCount;
+      }
+      assertEquals(2, rowCount);
+    }
+  }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/CoreMockedSqlProducers.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/CoreMockedSqlProducers.java
index cf359849a7105..a8e2e7f2e4ce5 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/CoreMockedSqlProducers.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/CoreMockedSqlProducers.java
@@ -64,6 +64,7 @@ public final class CoreMockedSqlProducers {
   public static final String LEGACY_REGULAR_SQL_CMD = "SELECT * FROM TEST";
   public static final String LEGACY_METADATA_SQL_CMD = "SELECT * FROM METADATA";
   public static final String LEGACY_CANCELLATION_SQL_CMD = "SELECT * FROM TAKES_FOREVER";
+  public static final String LEGACY_REGULAR_WITH_EMPTY_SQL_CMD = "SELECT * FROM TEST_EMPTIES";
 
   private CoreMockedSqlProducers() {
     // Prevent instantiation.
@@ -80,9 +81,44 @@ public static MockFlightSqlProducer getLegacyProducer() {
     addLegacyRegularSqlCmdSupport(producer);
     addLegacyMetadataSqlCmdSupport(producer);
     addLegacyCancellationSqlCmdSupport(producer);
+    addQueryWithEmbeddedEmptyRoot(producer);
     return producer;
   }
 
+  private static void addQueryWithEmbeddedEmptyRoot(final MockFlightSqlProducer producer) {
+    final Schema querySchema = new Schema(ImmutableList.of(
+        new Field(
+            "ID",
+            new FieldType(true, new ArrowType.Int(64, true),
+                null),
+            null)
+    ));
+
+    final List<Consumer<ServerStreamListener>> resultProducers = new ArrayList<>();
+    Consumer<ServerStreamListener> dataRoot = listener -> {
+      try (final BufferAllocator allocator = new RootAllocator(Long.MAX_VALUE);
+           final VectorSchemaRoot root = VectorSchemaRoot.create(querySchema, allocator)) {
+        root.allocateNew();
+        root.setRowCount(0);
+        listener.start(root);
+        listener.putNext(); // empty root
+        ((BigIntVector) root.getVector("ID")).setSafe(0, 100L);
+        root.setRowCount(1);
+        listener.putNext(); // data root
+        root.clear();
+        root.setRowCount(0);
+        listener.putNext(); // empty root
+        ((BigIntVector) root.getVector("ID")).setSafe(0, 100L);
+        root.setRowCount(1);
+        listener.putNext(); // data root
+      } finally {
+        listener.completed();
+      }
+    };
+    resultProducers.add(dataRoot);
+    producer.addSelectQuery(LEGACY_REGULAR_WITH_EMPTY_SQL_CMD, querySchema, resultProducers);
+  }
+
   private static void addLegacyRegularSqlCmdSupport(final MockFlightSqlProducer producer) {
     final Schema querySchema = new Schema(ImmutableList.of(
         new Field(

From c131feae965b510a1c1b045c1b670fbf5a7da9d4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 07:09:05 +0900
Subject: [PATCH 688/749] MINOR: [JS] Bump rollup and @rollup/stream in /js
 (#38595)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [rollup](https://github.com/rollup/rollup) and [@ rollup/stream](https://github.com/rollup/stream). These dependencies needed to be updated together.
Updates `rollup` from 3.29.4 to 4.3.0
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/rollup/rollup/releases">rollup's releases</a>.</em></p>
<blockquote>
<h2>v4.3.0</h2>
<h2>4.3.0</h2>
<p><em>2023-11-03</em></p>
<h3>Features</h3>
<ul>
<li>Add <code>forceExit</code> CLI flag for situations where the CLI does not exit gracefully (<a href="https://redirect.github.com/rollup/rollup/issues/5195">#5195</a>)</li>
</ul>
<h3>Bug Fixes</h3>
<ul>
<li>Properly catch errors when removing a temporary config file fails (<a href="https://redirect.github.com/rollup/rollup/issues/5198">#5198</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5195">#5195</a>: Add <code>forceExit</code> CLI flag (<a href="https://github.com/raphael-theriault-swi"><code>@​raphael-theriault-swi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5198">#5198</a>: fix: prevent <code>ENOENT</code> error on temp config removal (<a href="https://github.com/jzempel"><code>@​jzempel</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5237">#5237</a>: chore: remove unused files and deps (<a href="https://github.com/TrickyPi"><code>@​TrickyPi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5238">#5238</a>: chore(deps): update dependency eslint-plugin-unicorn to v49 (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5239">#5239</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
</ul>
<h2>v4.2.0</h2>
<h2>4.2.0</h2>
<p><em>2023-10-31</em></p>
<h3>Features</h3>
<ul>
<li>Run parsing in multiple threads and introduce <code>parseAstAsync</code> helper function (<a href="https://redirect.github.com/rollup/rollup/issues/5202">#5202</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5202">#5202</a>: perf: introduce <code>parseAstAsync</code> and parallelize parsing AST (<a href="https://github.com/sapphi-red"><code>@​sapphi-red</code></a>)</li>
</ul>
<h2>v4.1.6</h2>
<h2>4.1.6</h2>
<p><em>2023-10-31</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix a bug where emtpy block comments in certain positions could freeze Rollup (<a href="https://redirect.github.com/rollup/rollup/issues/5231">#5231</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5228">#5228</a>: build: ensure rust toolchain components for linting are installed (<a href="https://github.com/jerome-benoit"><code>@​jerome-benoit</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5231">#5231</a>: Render emtpy block comments after tree-shaken statements (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5232">#5232</a>: Revert specifying rustfmt and clippy in toolchain file as it breaks REPL build (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>v4.1.5</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/rollup/rollup/blob/master/CHANGELOG.md">rollup's changelog</a>.</em></p>
<blockquote>
<h2>4.3.0</h2>
<p><em>2023-11-03</em></p>
<h3>Features</h3>
<ul>
<li>Add <code>forceExit</code> CLI flag for situations where the CLI does not exit gracefully (<a href="https://redirect.github.com/rollup/rollup/issues/5195">#5195</a>)</li>
</ul>
<h3>Bug Fixes</h3>
<ul>
<li>Properly catch errors when removing a temporary config file fails (<a href="https://redirect.github.com/rollup/rollup/issues/5198">#5198</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5195">#5195</a>: Add <code>forceExit</code> CLI flag (<a href="https://github.com/raphael-theriault-swi"><code>@​raphael-theriault-swi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5198">#5198</a>: fix: prevent <code>ENOENT</code> error on temp config removal (<a href="https://github.com/jzempel"><code>@​jzempel</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5237">#5237</a>: chore: remove unused files and deps (<a href="https://github.com/TrickyPi"><code>@​TrickyPi</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5238">#5238</a>: chore(deps): update dependency eslint-plugin-unicorn to v49 (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5239">#5239</a>: chore(deps): lock file maintenance minor/patch updates (<a href="https://github.com/renovate"><code>@​renovate</code></a>[bot])</li>
</ul>
<h2>4.2.0</h2>
<p><em>2023-10-31</em></p>
<h3>Features</h3>
<ul>
<li>Run parsing in multiple threads and introduce <code>parseAstAsync</code> helper function (<a href="https://redirect.github.com/rollup/rollup/issues/5202">#5202</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5202">#5202</a>: perf: introduce <code>parseAstAsync</code> and parallelize parsing AST (<a href="https://github.com/sapphi-red"><code>@​sapphi-red</code></a>)</li>
</ul>
<h2>4.1.6</h2>
<p><em>2023-10-31</em></p>
<h3>Bug Fixes</h3>
<ul>
<li>Fix a bug where emtpy block comments in certain positions could freeze Rollup (<a href="https://redirect.github.com/rollup/rollup/issues/5231">#5231</a>)</li>
</ul>
<h3>Pull Requests</h3>
<ul>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5228">#5228</a>: build: ensure rust toolchain components for linting are installed (<a href="https://github.com/jerome-benoit"><code>@​jerome-benoit</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5231">#5231</a>: Render emtpy block comments after tree-shaken statements (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
<li><a href="https://redirect.github.com/rollup/rollup/pull/5232">#5232</a>: Revert specifying rustfmt and clippy in toolchain file as it breaks REPL build (<a href="https://github.com/lukastaegert"><code>@​lukastaegert</code></a>)</li>
</ul>
<h2>4.1.5</h2>
<p><em>2023-10-28</em></p>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/rollup/rollup/commit/937d9911376574c42f893e1cd14b55418c4f7b68"><code>937d991</code></a> 4.3.0</li>
<li><a href="https://github.com/rollup/rollup/commit/75c67e9e3f739fe65f4a9c4a0a9d12d375a9f902"><code>75c67e9</code></a> fix: prevent <code>ENOENT</code> error on temp config removal (<a href="https://redirect.github.com/rollup/rollup/issues/5198">#5198</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/ba2a961416affaadbe253c93655e91908b722e08"><code>ba2a961</code></a> chore(deps): lock file maintenance minor/patch updates (<a href="https://redirect.github.com/rollup/rollup/issues/5239">#5239</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/20a64a11d0804c27f9dff38af9a65e896c99beb1"><code>20a64a1</code></a> Add <code>forceExit</code> CLI flag (<a href="https://redirect.github.com/rollup/rollup/issues/5195">#5195</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/d255414d2c0d234b2d5ab368d6e31daa60f77989"><code>d255414</code></a> chore: remove unused files and deps (<a href="https://redirect.github.com/rollup/rollup/issues/5237">#5237</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/876f305b06d41486d77725ba7ffbd0419fc0821a"><code>876f305</code></a> chore(deps): update dependency eslint-plugin-unicorn to v49 (<a href="https://redirect.github.com/rollup/rollup/issues/5238">#5238</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/fbf806aceffd822d43e4603b664c54165c72cf36"><code>fbf806a</code></a> 4.2.0</li>
<li><a href="https://github.com/rollup/rollup/commit/49b57c2b30d55178a7316f23cc9ccc457e1a2ee7"><code>49b57c2</code></a> perf: introduce <code>parseAstAsync</code> and parallelize parsing AST (<a href="https://redirect.github.com/rollup/rollup/issues/5202">#5202</a>)</li>
<li><a href="https://github.com/rollup/rollup/commit/5865fbd33e13c4be2018494de196f6e815e2bc8a"><code>5865fbd</code></a> Revert specifying components in workflow files</li>
<li><a href="https://github.com/rollup/rollup/commit/5901e545697b36326110d89ed02964fdaffd9f6f"><code>5901e54</code></a> 4.1.6</li>
<li>Additional commits viewable in <a href="https://github.com/rollup/rollup/compare/v3.29.4...v4.3.0">compare view</a></li>
</ul>
</details>
<br />

Updates `@ rollup/stream` from 3.0.0 to 3.0.1
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/rollup/stream/commits/v3.0.1">compare view</a></li>
</ul>
</details>
<br />

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  4 +--
 js/yarn.lock    | 88 ++++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 82 insertions(+), 10 deletions(-)

diff --git a/js/package.json b/js/package.json
index e7ef0f895aa1d..cca333ad3d006 100644
--- a/js/package.json
+++ b/js/package.json
@@ -68,7 +68,7 @@
     "@openpgp/web-stream-tools": "0.0.13",
     "@rollup/plugin-alias": "5.0.0",
     "@rollup/plugin-node-resolve": "15.1.0",
-    "@rollup/stream": "3.0.0",
+    "@rollup/stream": "3.0.1",
     "@swc/core": "1.3.82",
     "@types/benchmark": "2.1.4",
     "@types/glob": "8.1.0",
@@ -106,7 +106,7 @@
     "multistream": "4.1.0",
     "randomatic": "3.1.1",
     "regenerator-runtime": "0.14.0",
-    "rollup": "3.29.4",
+    "rollup": "4.3.0",
     "rxjs": "7.8.1",
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
diff --git a/js/yarn.lock b/js/yarn.lock
index 40d5ef5f16141..b2ed3ed20600b 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -1032,10 +1032,70 @@
     estree-walker "^2.0.2"
     picomatch "^2.3.1"
 
-"@rollup/stream@3.0.0":
-  version "3.0.0"
-  resolved "https://registry.npmjs.org/@rollup/stream/-/stream-3.0.0.tgz#8578177aa992e1e7d932d7b8b9ac302ce272663e"
-  integrity sha512-rCctaa32QWDmbO/NyZPE3fKbpi4RHmR3N/mPvCYaig7ieSsDg4uSudKkIsaDHuLuYpvNII8kPwgXs1k077lAPg==
+"@rollup/rollup-android-arm-eabi@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.3.0.tgz#8ad8a660b18f1a24ad4a272738a65ac4788a8811"
+  integrity sha512-/4pns6BYi8MXdwnXM44yoGAcFYVHL/BYlB2q1HXZ6AzH++LaiEVWFpBWQ/glXhbMbv3E3o09igrHFbP/snhAvA==
+
+"@rollup/rollup-android-arm64@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.3.0.tgz#17b0f412034d14668c8acc8b7cbd8b1c76279599"
+  integrity sha512-nLO/JsL9idr416vzi3lHm3Xm+QZh4qHij8k3Er13kZr5YhL7/+kBAx84kDmPc7HMexLmwisjDCeDIKNFp8mDlQ==
+
+"@rollup/rollup-darwin-arm64@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.3.0.tgz#80c4a4dd7b120906d4e655808fb9005784a8bf35"
+  integrity sha512-dGhVBlllt4iHwTGy21IEoMOTN5wZoid19zEIxsdY29xcEiOEHqzDa7Sqrkh5OE7LKCowL61eFJXxYe/+pYa7ZQ==
+
+"@rollup/rollup-darwin-x64@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.3.0.tgz#52ad0db40d9b5ae047dfc08e54e4b3f42feaef82"
+  integrity sha512-h8wRfHeLEbU3NzaP1Oku7BYXCJQiTRr+8U0lklyOQXxXiEpHLL8tk1hFl+tezoRKLcPJD7joKaK74ASsqt3Ekg==
+
+"@rollup/rollup-linux-arm-gnueabihf@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.3.0.tgz#2ad3d190af01d7fc8704e8e782c4a24006a9f21a"
+  integrity sha512-wP4VgR/gfV18sylTuym3sxRTkAgUR2vh6YLeX/GEznk5jCYcYSlx585XlcUcl0c8UffIZlRJ09raWSX3JDb4GA==
+
+"@rollup/rollup-linux-arm64-gnu@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.3.0.tgz#4f7ba42f779f06e93876755b7393c61676e2958a"
+  integrity sha512-v/14JCYVkqRSJeQbxFx4oUkwVQQw6lFMN7bd4vuARBc3X2lmomkxBsc+BFiIDL/BK+CTx5AOh/k9XmqDnKWRVg==
+
+"@rollup/rollup-linux-arm64-musl@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.3.0.tgz#64795a09dac02b4d779819509a793b93ba7e4c0d"
+  integrity sha512-tNhfYqFH5OxtRzfkTOKdgFYlPSZnlDLNW4+leNEvQZhwTJxoTwsZAAhR97l3qVry/kkLyJPBK+Q8EAJLPinDIg==
+
+"@rollup/rollup-linux-x64-gnu@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.3.0.tgz#00c1ff131ba16881eb1a0ad46b0aa10dcacb010e"
+  integrity sha512-pw77m8QywdsoFdFOgmc8roF1inBI0rciqzO8ffRUgLoq7+ee9o5eFqtEcS6hHOOplgifAUUisP8cAnwl9nUYPw==
+
+"@rollup/rollup-linux-x64-musl@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.3.0.tgz#89479dce5e5bf6850fbca92fa7f1637ddd70c9ef"
+  integrity sha512-tJs7v2MnV2F8w6X1UpPHl/43OfxjUy9SuJ2ZPoxn79v9vYteChVYO/ueLHCpRMmyTUIVML3N9z4azl9ENH8Xxg==
+
+"@rollup/rollup-win32-arm64-msvc@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.3.0.tgz#1a36aba17c7efe6d61e98b8049e70b40e33b1f45"
+  integrity sha512-OKGxp6kATQdTyI2DF+e9s+hB3/QZB45b6e+dzcfW1SUqiF6CviWyevhmT4USsMEdP3mlpC9zxLz3Oh+WaTMOSw==
+
+"@rollup/rollup-win32-ia32-msvc@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.3.0.tgz#a0b1f79afde51e390a7725b7c15ab4e0df780aea"
+  integrity sha512-DDZ5AH68JJ2ClQFEA1aNnfA7Ybqyeh0644rGbrLOdNehTmzfICHiWSn0OprzYi9HAshTPQvlwrM+bi2kuaIOjQ==
+
+"@rollup/rollup-win32-x64-msvc@4.3.0":
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.3.0.tgz#0b9bcc159b93c911efb5a2c39ec5d70dd0a589dc"
+  integrity sha512-dMvGV8p92GQ8jhNlGIKpyhVZPzJlT258pPrM5q2F8lKcc9Iv9BbfdnhX1OfinYWnb9ms5zLw6MlaMnqLfUkKnQ==
+
+"@rollup/stream@3.0.1":
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/@rollup/stream/-/stream-3.0.1.tgz#485452d6f1016ac1b0513060f90ff02aaca3e1c0"
+  integrity sha512-wdzoakLc9UiPOFa1k17ukfEtvQ0p7JuNFvOZT1DhO5Z5CrTf71An01U9+v+aebYcaLCwy3tLwpCSUF7K7xVN0A==
 
 "@sinclair/typebox@^0.27.8":
   version "0.27.8"
@@ -6160,11 +6220,23 @@ rimraf@^3.0.2:
   dependencies:
     glob "^7.1.3"
 
-rollup@3.29.4:
-  version "3.29.4"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-3.29.4.tgz#4d70c0f9834146df8705bfb69a9a19c9e1109981"
-  integrity sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==
+rollup@4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.3.0.tgz#198e6ae4355899db630d75bc0e17b53f5d0fc20e"
+  integrity sha512-scIi1NrKLDIYSPK66jjECtII7vIgdAMFmFo8h6qm++I6nN9qDSV35Ku6erzGVqYjx+lj+j5wkusRMr++8SyDZg==
   optionalDependencies:
+    "@rollup/rollup-android-arm-eabi" "4.3.0"
+    "@rollup/rollup-android-arm64" "4.3.0"
+    "@rollup/rollup-darwin-arm64" "4.3.0"
+    "@rollup/rollup-darwin-x64" "4.3.0"
+    "@rollup/rollup-linux-arm-gnueabihf" "4.3.0"
+    "@rollup/rollup-linux-arm64-gnu" "4.3.0"
+    "@rollup/rollup-linux-arm64-musl" "4.3.0"
+    "@rollup/rollup-linux-x64-gnu" "4.3.0"
+    "@rollup/rollup-linux-x64-musl" "4.3.0"
+    "@rollup/rollup-win32-arm64-msvc" "4.3.0"
+    "@rollup/rollup-win32-ia32-msvc" "4.3.0"
+    "@rollup/rollup-win32-x64-msvc" "4.3.0"
     fsevents "~2.3.2"
 
 run-parallel@^1.1.9:

From e90c4cfdfceae662ba451c4f6ef7895a437a7aef Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 07:11:18 +0900
Subject: [PATCH 689/749] MINOR: [C#] Bump Google.Protobuf from 3.24.4 to
 3.25.0 in /csharp (#38603)

Bumps [Google.Protobuf](https://github.com/protocolbuffers/protobuf) from 3.24.4 to 3.25.0.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/6b5d8db01fe47478e8d400f550e797e6230d464e"><code>6b5d8db</code></a> Updating version.json and repo version numbers to: 25.0</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/59a66af1465c8abbc78c7506153ae7f711b991f2"><code>59a66af</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14583">#14583</a> from haberman/cherry-pick-python-memory-leak</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/1711ebd4559313555e89d0f56294842779c7e900"><code>1711ebd</code></a> Fixed Python memory leak in map lookup.</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/8defef58f4367d3a968b44000698e308a035ab9e"><code>8defef5</code></a> Include .inc files directly instead of through a filegroup (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14575">#14575</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/0a5d6d4a45880a3076681cbd7d88e0985b4ccdb7"><code>0a5d6d4</code></a> Check that ffi-compiler loads before using it to define tasks. (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14538">#14538</a>) (<a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14560">#14560</a>)</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/a4964a44f7ae6d00584658422d19d337959ee79d"><code>a4964a4</code></a> Merge pull request <a href="https://redirect.github.com/protocolbuffers/protobuf/issues/14460">#14460</a> from protocolbuffers/25.x-202310181825</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/08b6c404af3cba3e054bec05221faa296584dba9"><code>08b6c40</code></a> Updating version.json to: 25.0-dev</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/ba1aab2baf19e83cc8c5532f98e5f90bd6d21fd5"><code>ba1aab2</code></a> Updating version.json and repo version numbers to: 25.0-rc2</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/3f05c099c3ad62b4af33cf4e78bc4674c32cc680"><code>3f05c09</code></a> update test runners</li>
<li><a href="https://github.com/protocolbuffers/protobuf/commit/b4abcef8a954383d860a9367465fb398e5992d82"><code>b4abcef</code></a> Bump minimum PHP to 8.0</li>
<li>Additional commits viewable in <a href="https://github.com/protocolbuffers/protobuf/compare/v3.24.4...v3.25.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Google.Protobuf&package-manager=nuget&previous-version=3.24.4&new-version=3.25.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index d771aebd96796..975bf44db888f 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
   
   <ItemGroup>
-    <PackageReference Include="Google.Protobuf" Version="3.24.4" />
+    <PackageReference Include="Google.Protobuf" Version="3.25.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.58.0" />
     <PackageReference Include="Grpc.Tools" Version="2.59.0" PrivateAssets="All" />
   </ItemGroup>

From 5164acbf8c102bbfe2ec7011d8fe638b031aac7a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 07:11:45 +0900
Subject: [PATCH 690/749] MINOR: [C#] Bump xunit from 2.5.3 to 2.6.1 in /csharp
 (#38604)

Bumps [xunit](https://github.com/xunit/xunit) from 2.5.3 to 2.6.1.
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/xunit/xunit/commit/9f1684f5f74196d952f0085d7bde21aa20df6229"><code>9f1684f</code></a> v2.6.1</li>
<li><a href="https://github.com/xunit/xunit/commit/5d9ef4b8ef82e3e3a8581a259f8a02fb01fd7391"><code>5d9ef4b</code></a> Remove unnecessary XUNIT_VALUETASK definition</li>
<li><a href="https://github.com/xunit/xunit/commit/0266bac5ed8b31ada11b6034c9fe013142090033"><code>0266bac</code></a> Latest assertions</li>
<li><a href="https://github.com/xunit/xunit/commit/fb3c3cf30445dc5a7aa7fdca6fe8118dc407b960"><code>fb3c3cf</code></a> Remove all ValueTask support from assertions</li>
<li><a href="https://github.com/xunit/xunit/commit/801790c5accbaa51b06fde9397b92a47d4ae8f41"><code>801790c</code></a> Reconcile AcceptanceTestAssembly and friends with v3</li>
<li><a href="https://github.com/xunit/xunit/commit/f244cc89bf086ce8a3b3f628f70da14e2420a4a4"><code>f244cc8</code></a> More shared assertion tests that shouldn't return ValueTask</li>
<li><a href="https://github.com/xunit/xunit/commit/262dd72145a7a62143926892beab0af1f9832e9e"><code>262dd72</code></a> Shared assertion tests cannot return ValueTask</li>
<li><a href="https://github.com/xunit/xunit/commit/36bbf773ea60b1fa1622063c160cfb4b0707dcd8"><code>36bbf77</code></a> Bump up to v2.6.1-pre</li>
<li><a href="https://github.com/xunit/xunit/commit/6a07b9530d643f938287db600feb46082e894188"><code>6a07b95</code></a> v2.6.0</li>
<li><a href="https://github.com/xunit/xunit/commit/5a7297e8dcbc7998dc85708af8fb3756888ccd14"><code>5a7297e</code></a> <a href="https://redirect.github.com/xunit/xunit/issues/2806">#2806</a>: Performance improvements in Assert.Equal (v2)</li>
<li>Additional commits viewable in <a href="https://github.com/xunit/xunit/compare/2.5.3...2.6.1">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=xunit&package-manager=nuget&previous-version=2.5.3&new-version=2.6.1)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index e63c27d022c24..835d95fc0c521 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
 
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index ed67fafbf8c72..10582500d443c 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -7,7 +7,7 @@
 
     <ItemGroup>
       <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-      <PackageReference Include="xunit" Version="2.5.3" />
+      <PackageReference Include="xunit" Version="2.6.1" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
     </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index e4e3c053f943d..b371de9b1eb99 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 2835c60da414f..0df097156da34 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -15,7 +15,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>

From 0bc75b7486e51d8939df966b29ee54ebc1083598 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 07:12:24 +0900
Subject: [PATCH 691/749] MINOR: [C#] Bump BenchmarkDotNet from 0.13.9 to
 0.13.10 in /csharp (#38606)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet) from 0.13.9 to 0.13.10.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet's releases</a>.</em></p>
<blockquote>
<h2>0.13.10</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.10.html">https://benchmarkdotnet.org/changelog/v0.13.10.html</a></p>
<h2>Highlights</h2>
<p>Initial support of .NET 9 and minor bug fixes.</p>
<h2>Details</h2>
<p>In the <a href="https://github.com/dotnet/BenchmarkDotNet/issues?q=milestone:v0.13.10">v0.13.10</a> scope,
2 issues were resolved and 3 pull requests were merged.
This release includes 10 commits by 4 contributors.</p>
<h2>Resolved issues (2)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> BenchmarkDotNet Access Denied Error on WSL2 when Writing to '/mnt/c/DumpStack.log.tmp' (assignee: <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2455">#2455</a> .NET 9 support (assignee: <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
</ul>
<h2>Merged pull requests (3)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2447">#2447</a> Add support for wasm/net9.0 (by <a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2453">#2453</a> feat: set RuntimeHostConfigurationOption on generated project (by <a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2456">#2456</a> implement full .NET 9 support (by <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
</ul>
<h2>Commits (10)</h2>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c27152b9d7b6391501abcf7e8edcb2804999622f">c27152</a> Set next BenchmarkDotNet version: 0.13.10 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2e96d29453a804cfc1b92fffeea94c866522167a">2e96d2</a> Don't show AssemblyInformationalVersion metadata in BDN BrandVersion (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d17c6ad0bd8ac15d83ced0a7522de7dd51526ad4">d17c6a</a> Support Windows 11 23H2 (10.0.22631) in OsBrandStringHelper (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af9c5c6013b4e661cda0ff8fed40a50ae62d5a74">af9c5c</a> Exception handling in DotNetCliGenerator.GetRootDirectory, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e11136897bdf26c004076bcbe812bb4ae60f8859">e11136</a> [build] Bump Docfx.App: 2.71.0-&gt;2.71.1 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7b342f5cfb63c73708f3e69dde33d7430a3c0401">7b342f</a> Add support for wasm/net9.0 (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2447">#2447</a>) (by <a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e170684208103ca5ba4212ad8dc7c2aad5cf02d4">e17068</a> Adjust 'Failed to set up high priority' message (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/0a734a94a13733c2950d7edbac08499c6f2c108a">0a734a</a> feat: set RuntimeHostConfigurationOption on generated project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2453">#2453</a>) (by <a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ae49148a92c358676190772803fe0ed532814ce3">ae4914</a> implement full .NET 9 support (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2456">#2456</a>) (by <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/40c4142734ce68bdfcbccf7086ed2b724e9428bc">40c414</a> Prepare v0.13.10 changelog (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>
<h2>Contributors (4)</h2>
<ul>
<li>Adam Sitnik (<a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
<li>Andrey Akinshin (<a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li>Ankit Jain (<a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li>workgroupengineering (<a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
</ul>
<p>Thank you very much!</p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/40c4142734ce68bdfcbccf7086ed2b724e9428bc"><code>40c4142</code></a> Prepare v0.13.10 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ae49148a92c358676190772803fe0ed532814ce3"><code>ae49148</code></a> implement full .NET 9 support (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2456">#2456</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/0a734a94a13733c2950d7edbac08499c6f2c108a"><code>0a734a9</code></a> feat: set RuntimeHostConfigurationOption on generated project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2453">#2453</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e170684208103ca5ba4212ad8dc7c2aad5cf02d4"><code>e170684</code></a> Adjust 'Failed to set up high priority' message</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7b342f5cfb63c73708f3e69dde33d7430a3c0401"><code>7b342f5</code></a> Add support for wasm/net9.0 (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2447">#2447</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e11136897bdf26c004076bcbe812bb4ae60f8859"><code>e111368</code></a> [build] Bump Docfx.App: 2.71.0-&gt;2.71.1</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af9c5c6013b4e661cda0ff8fed40a50ae62d5a74"><code>af9c5c6</code></a> Exception handling in DotNetCliGenerator.GetRootDirectory, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a></li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d17c6ad0bd8ac15d83ced0a7522de7dd51526ad4"><code>d17c6ad</code></a> Support Windows 11 23H2 (10.0.22631) in OsBrandStringHelper</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2e96d29453a804cfc1b92fffeea94c866522167a"><code>2e96d29</code></a> Don't show AssemblyInformationalVersion metadata in BDN BrandVersion</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c27152b9d7b6391501abcf7e8edcb2804999622f"><code>c27152b</code></a> Set next BenchmarkDotNet version: 0.13.10</li>
<li>See full diff in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.9...v0.13.10">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet&package-manager=nuget&previous-version=0.13.9&new-version=0.13.10)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index 5c2c1823fec99..4cbab77e1fe24 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.9" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.10" />
     <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.9" />
   </ItemGroup>
 

From c73cb13b9f89493f9fb91da854f95aa38bd86cc7 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Mon, 6 Nov 2023 23:20:05 +0100
Subject: [PATCH 692/749] GH-38607: [Python] Disable PyExtensionType autoload
 (#38608)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

PyExtensionType autoload is really a misfeature. It creates PyArrow-specific extension types, though using ExtensionType is almost the same complexity while allowing deserialization from non-PyArrow software.

### What changes are included in this PR?

* Disable PyExtensionType autoloading and deprecate PyExtensionType instantiation.
* Update the docs to emphasize ExtensionType.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.

* Closes: #38607

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>
---
 docs/source/python/extending_types.rst      | 149 ++++------
 python/pyarrow/tests/test_cffi.py           |  48 ++-
 python/pyarrow/tests/test_extension_type.py | 313 ++++++++++++++------
 python/pyarrow/tests/test_pandas.py         |  24 +-
 python/pyarrow/types.pxi                    |  88 +++---
 5 files changed, 377 insertions(+), 245 deletions(-)

diff --git a/docs/source/python/extending_types.rst b/docs/source/python/extending_types.rst
index b9e875ceebc74..ee92cebcb549c 100644
--- a/docs/source/python/extending_types.rst
+++ b/docs/source/python/extending_types.rst
@@ -68,34 +68,43 @@ message).
 See the :ref:`format_metadata_extension_types` section of the metadata
 specification for more details.
 
-Pyarrow allows you to define such extension types from Python.
-
-There are currently two ways:
-
-* Subclassing :class:`PyExtensionType`: the (de)serialization is based on pickle.
-  This is a good option for an extension type that is only used from Python.
-* Subclassing :class:`ExtensionType`: this allows to give a custom
-  Python-independent name and serialized metadata, that can potentially be
-  recognized by other (non-Python) Arrow implementations such as PySpark.
+Pyarrow allows you to define such extension types from Python by subclassing
+:class:`ExtensionType` and giving the derived class its own extension name
+and serialization mechanism. The extension name and serialized metadata
+can potentially be recognized by other (non-Python) Arrow implementations
+such as PySpark.
 
 For example, we could define a custom UUID type for 128-bit numbers which can
-be represented as ``FixedSizeBinary`` type with 16 bytes.
-Using the first approach, we create a ``UuidType`` subclass, and implement the
-``__reduce__`` method to ensure the class can be properly pickled::
+be represented as ``FixedSizeBinary`` type with 16 bytes::
 
-    class UuidType(pa.PyExtensionType):
+    class UuidType(pa.ExtensionType):
 
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.binary(16))
+            super().__init__(pa.binary(16), "my_package.uuid")
+
+        def __arrow_ext_serialize__(self):
+            # Since we don't have a parameterized type, we don't need extra
+            # metadata to be deserialized
+            return b''
 
-        def __reduce__(self):
-            return UuidType, ()
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            # Sanity checks, not required but illustrate the method signature.
+            assert storage_type == pa.binary(16)
+            assert serialized == b''
+            # Return an instance of this subclass given the serialized
+            # metadata.
+            return UuidType()
+
+The special methods ``__arrow_ext_serialize__`` and ``__arrow_ext_deserialize__``
+define the serialization of an extension type instance. For non-parametric
+types such as the above, the serialization payload can be left empty.
 
 This can now be used to create arrays and tables holding the extension type::
 
     >>> uuid_type = UuidType()
     >>> uuid_type.extension_name
-    'arrow.py_extension_type'
+    'my_package.uuid'
     >>> uuid_type.storage_type
     FixedSizeBinaryType(fixed_size_binary[16])
 
@@ -112,8 +121,11 @@ This can now be used to create arrays and tables holding the extension type::
     ]
 
 This array can be included in RecordBatches, sent over IPC and received in
-another Python process. The custom UUID type will be preserved there, as long
-as the definition of the class is available (the type can be unpickled).
+another Python process. The receiving process must explicitly register the
+extension type for deserialization, otherwise it will fall back to the
+storage type::
+
+    >>> pa.register_extension_type(UuidType())
 
 For example, creating a RecordBatch and writing it to a stream using the
 IPC protocol::
@@ -129,43 +141,12 @@ and then reading it back yields the proper type::
     >>> with pa.ipc.open_stream(buf) as reader:
     ...    result = reader.read_all()
     >>> result.column('ext').type
-    UuidType(extension<arrow.py_extension_type>)
-
-We can define the same type using the other option::
-
-    class UuidType(pa.ExtensionType):
-
-        def __init__(self):
-            pa.ExtensionType.__init__(self, pa.binary(16), "my_package.uuid")
-
-        def __arrow_ext_serialize__(self):
-            # since we don't have a parameterized type, we don't need extra
-            # metadata to be deserialized
-            return b''
-
-        @classmethod
-        def __arrow_ext_deserialize__(self, storage_type, serialized):
-            # return an instance of this subclass given the serialized
-            # metadata.
-            return UuidType()
-
-This is a slightly longer implementation (you need to implement the special
-methods ``__arrow_ext_serialize__`` and ``__arrow_ext_deserialize__``), and the
-extension type needs to be registered to be received through IPC (using
-:func:`register_extension_type`), but it has
-now a unique name::
-
-    >>> uuid_type = UuidType()
-    >>> uuid_type.extension_name
-    'my_package.uuid'
-
-    >>> pa.register_extension_type(uuid_type)
+    UuidType(FixedSizeBinaryType(fixed_size_binary[16]))
 
 The receiving application doesn't need to be Python but can still recognize
-the extension type as a "uuid" type, if it has implemented its own extension
-type to receive it.
-If the type is not registered in the receiving application, it will fall back
-to the storage type.
+the extension type as a "my_package.uuid" type, if it has implemented its own
+extension type to receive it. If the type is not registered in the receiving
+application, it will fall back to the storage type.
 
 Parameterized extension type
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -187,7 +168,7 @@ of the given frequency since 1970.
             # attributes need to be set first before calling
             # super init (as that calls serialize)
             self._freq = freq
-            pa.ExtensionType.__init__(self, pa.int64(), 'my_package.period')
+            super().__init__(pa.int64(), 'my_package.period')
 
         @property
         def freq(self):
@@ -198,7 +179,7 @@ of the given frequency since 1970.
 
         @classmethod
         def __arrow_ext_deserialize__(cls, storage_type, serialized):
-            # return an instance of this subclass given the serialized
+            # Return an instance of this subclass given the serialized
             # metadata.
             serialized = serialized.decode()
             assert serialized.startswith("freq=")
@@ -209,31 +190,10 @@ Here, we ensure to store all information in the serialized metadata that is
 needed to reconstruct the instance (in the ``__arrow_ext_deserialize__`` class
 method), in this case the frequency string.
 
-Note that, once created, the data type instance is considered immutable. If,
-in the example above, the ``freq`` parameter would change after instantiation,
-the reconstruction of the type instance after IPC will be incorrect.
+Note that, once created, the data type instance is considered immutable.
 In the example above, the ``freq`` parameter is therefore stored in a private
 attribute with a public read-only property to access it.
 
-Parameterized extension types are also possible using the pickle-based type
-subclassing :class:`PyExtensionType`. The equivalent example for the period
-data type from above would look like::
-
-    class PeriodType(pa.PyExtensionType):
-
-        def __init__(self, freq):
-            self._freq = freq
-            pa.PyExtensionType.__init__(self, pa.int64())
-
-        @property
-        def freq(self):
-            return self._freq
-
-        def __reduce__(self):
-            return PeriodType, (self.freq,)
-
-Also the storage type does not need to be fixed but can be parameterized.
-
 Custom extension array class
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -252,12 +212,16 @@ the data as a 2-D Numpy array ``(N, 3)`` without any copy::
             return self.storage.flatten().to_numpy().reshape((-1, 3))
 
 
-    class Point3DType(pa.PyExtensionType):
+    class Point3DType(pa.ExtensionType):
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.list_(pa.float32(), 3))
+            super().__init__(pa.list_(pa.float32(), 3), "my_package.Point3DType")
 
-        def __reduce__(self):
-            return Point3DType, ()
+        def __arrow_ext_serialize__(self):
+            return b''
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            return Point3DType()
 
         def __arrow_ext_class__(self):
             return Point3DArray
@@ -289,11 +253,8 @@ The additional methods in the extension class are then available to the user::
 
 
 This array can be sent over IPC, received in another Python process, and the custom
-extension array class will be preserved (as long as the definitions of the classes above
-are available).
-
-The same ``__arrow_ext_class__`` specialization can be used with custom types defined
-by subclassing :class:`ExtensionType`.
+extension array class will be preserved (as long as the receiving process registers
+the extension type using :func:`register_extension_type` before reading the IPC data).
 
 Custom scalar conversion
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -304,18 +265,24 @@ If you want scalars of your custom extension type to convert to a custom type wh
 For example, if we wanted the above example 3D point type to return a custom
 3D point class instead of a list, we would implement::
 
+    from collections import namedtuple
+
     Point3D = namedtuple("Point3D", ["x", "y", "z"])
 
     class Point3DScalar(pa.ExtensionScalar):
         def as_py(self) -> Point3D:
             return Point3D(*self.value.as_py())
 
-    class Point3DType(pa.PyExtensionType):
+    class Point3DType(pa.ExtensionType):
         def __init__(self):
-            pa.PyExtensionType.__init__(self, pa.list_(pa.float32(), 3))
+            super().__init__(pa.list_(pa.float32(), 3), "my_package.Point3DType")
 
-        def __reduce__(self):
-            return Point3DType, ()
+        def __arrow_ext_serialize__(self):
+            return b''
+
+        @classmethod
+        def __arrow_ext_deserialize__(cls, storage_type, serialized):
+            return Point3DType()
 
         def __arrow_ext_scalar_class__(self):
             return Point3DScalar
diff --git a/python/pyarrow/tests/test_cffi.py b/python/pyarrow/tests/test_cffi.py
index 55bab4359bffc..a9c17cc100cb4 100644
--- a/python/pyarrow/tests/test_cffi.py
+++ b/python/pyarrow/tests/test_cffi.py
@@ -16,6 +16,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import contextlib
 import ctypes
 import gc
 
@@ -51,18 +52,33 @@ def PyCapsule_IsValid(capsule, name):
     return ctypes.pythonapi.PyCapsule_IsValid(ctypes.py_object(capsule), name) == 1
 
 
-class ParamExtType(pa.PyExtensionType):
+@contextlib.contextmanager
+def registered_extension_type(ext_type):
+    pa.register_extension_type(ext_type)
+    try:
+        yield
+    finally:
+        pa.unregister_extension_type(ext_type.extension_name)
+
+
+class ParamExtType(pa.ExtensionType):
 
     def __init__(self, width):
         self._width = width
-        pa.PyExtensionType.__init__(self, pa.binary(width))
+        super().__init__(pa.binary(width),
+                         "pyarrow.tests.test_cffi.ParamExtType")
 
     @property
     def width(self):
         return self._width
 
-    def __reduce__(self):
-        return ParamExtType, (self.width,)
+    def __arrow_ext_serialize__(self):
+        return str(self.width).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        width = int(serialized.decode())
+        return cls(width)
 
 
 def make_schema():
@@ -75,6 +91,12 @@ def make_extension_schema():
                      metadata={b'key1': b'value1'})
 
 
+def make_extension_storage_schema():
+    # Should be kept in sync with make_extension_schema
+    return pa.schema([('ext', ParamExtType(3).storage_type)],
+                     metadata={b'key1': b'value1'})
+
+
 def make_batch():
     return pa.record_batch([[[1], [2, 42]]], make_schema())
 
@@ -204,7 +226,10 @@ def test_export_import_array():
         pa.Array._import_from_c(ptr_array, ptr_schema)
 
 
-def check_export_import_schema(schema_factory):
+def check_export_import_schema(schema_factory, expected_schema_factory=None):
+    if expected_schema_factory is None:
+        expected_schema_factory = schema_factory
+
     c_schema = ffi.new("struct ArrowSchema*")
     ptr_schema = int(ffi.cast("uintptr_t", c_schema))
 
@@ -215,7 +240,7 @@ def check_export_import_schema(schema_factory):
     assert pa.total_allocated_bytes() > old_allocated
     # Delete and recreate C++ object from exported pointer
     schema_new = pa.Schema._import_from_c(ptr_schema)
-    assert schema_new == schema_factory()
+    assert schema_new == expected_schema_factory()
     assert pa.total_allocated_bytes() == old_allocated
     del schema_new
     assert pa.total_allocated_bytes() == old_allocated
@@ -240,7 +265,13 @@ def test_export_import_schema():
 
 @needs_cffi
 def test_export_import_schema_with_extension():
-    check_export_import_schema(make_extension_schema)
+    # Extension type is unregistered => the storage type is imported
+    check_export_import_schema(make_extension_schema,
+                               make_extension_storage_schema)
+
+    # Extension type is registered => the extension type is imported
+    with registered_extension_type(ParamExtType(1)):
+        check_export_import_schema(make_extension_schema)
 
 
 @needs_cffi
@@ -319,7 +350,8 @@ def test_export_import_batch():
 
 @needs_cffi
 def test_export_import_batch_with_extension():
-    check_export_import_batch(make_extension_batch)
+    with registered_extension_type(ParamExtType(1)):
+        check_export_import_batch(make_extension_batch)
 
 
 def _export_import_batch_reader(ptr_stream, reader_factory):
diff --git a/python/pyarrow/tests/test_extension_type.py b/python/pyarrow/tests/test_extension_type.py
index ce575d984e41c..a88e20eefe098 100644
--- a/python/pyarrow/tests/test_extension_type.py
+++ b/python/pyarrow/tests/test_extension_type.py
@@ -15,6 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import contextlib
 import os
 import shutil
 import subprocess
@@ -29,31 +30,69 @@
 import pytest
 
 
-class TinyIntType(pa.PyExtensionType):
+@contextlib.contextmanager
+def registered_extension_type(ext_type):
+    pa.register_extension_type(ext_type)
+    try:
+        yield
+    finally:
+        pa.unregister_extension_type(ext_type.extension_name)
+
+
+@contextlib.contextmanager
+def enabled_auto_load():
+    pa.PyExtensionType.set_auto_load(True)
+    try:
+        yield
+    finally:
+        pa.PyExtensionType.set_auto_load(False)
+
+
+class TinyIntType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int8())
+        super().__init__(pa.int8(), 'pyarrow.tests.TinyIntType')
 
-    def __reduce__(self):
-        return TinyIntType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int8()
+        return cls()
 
 
-class IntegerType(pa.PyExtensionType):
+class IntegerType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(), 'pyarrow.tests.IntegerType')
 
-    def __reduce__(self):
-        return IntegerType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int64()
+        return cls()
 
 
-class IntegerEmbeddedType(pa.PyExtensionType):
+class IntegerEmbeddedType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, IntegerType())
+        super().__init__(IntegerType(), 'pyarrow.tests.IntegerType')
 
-    def __reduce__(self):
-        return IntegerEmbeddedType, ()
+    def __arrow_ext_serialize__(self):
+        # XXX pa.BaseExtensionType should expose C++ serialization method
+        return self.storage_type.__arrow_ext_serialize__()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        deserialized_storage_type = storage_type.__arrow_ext_deserialize__(
+            serialized)
+        assert deserialized_storage_type == storage_type
+        return cls()
 
 
 class UuidScalarType(pa.ExtensionScalar):
@@ -61,81 +100,125 @@ def as_py(self):
         return None if self.value is None else UUID(bytes=self.value.as_py())
 
 
-class UuidType(pa.PyExtensionType):
+class UuidType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.binary(16))
-
-    def __reduce__(self):
-        return UuidType, ()
+        super().__init__(pa.binary(16), 'pyarrow.tests.UuidType')
 
     def __arrow_ext_scalar_class__(self):
         return UuidScalarType
 
+    def __arrow_ext_serialize__(self):
+        return b''
 
-class UuidType2(pa.PyExtensionType):
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
+
+
+class UuidType2(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.binary(16))
+        super().__init__(pa.binary(16), 'pyarrow.tests.UuidType2')
 
-    def __reduce__(self):
-        return UuidType2, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
 
 
-class LabelType(pa.PyExtensionType):
+class LabelType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.string())
+        super().__init__(pa.string(), 'pyarrow.tests.LabelType')
 
-    def __reduce__(self):
-        return LabelType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        return cls()
 
 
-class ParamExtType(pa.PyExtensionType):
+class ParamExtType(pa.ExtensionType):
 
     def __init__(self, width):
         self._width = width
-        pa.PyExtensionType.__init__(self, pa.binary(width))
+        super().__init__(pa.binary(width), 'pyarrow.tests.ParamExtType')
 
     @property
     def width(self):
         return self._width
 
-    def __reduce__(self):
-        return ParamExtType, (self.width,)
+    def __arrow_ext_serialize__(self):
+        return str(self._width).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        width = int(serialized.decode())
+        assert storage_type == pa.binary(width)
+        return cls(width)
 
 
-class MyStructType(pa.PyExtensionType):
+class MyStructType(pa.ExtensionType):
     storage_type = pa.struct([('left', pa.int64()),
                               ('right', pa.int64())])
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, self.storage_type)
+        super().__init__(self.storage_type, 'pyarrow.tests.MyStructType')
 
-    def __reduce__(self):
-        return MyStructType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
 
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == cls.storage_type
+        return cls()
 
-class MyListType(pa.PyExtensionType):
+
+class MyListType(pa.ExtensionType):
 
     def __init__(self, storage_type):
-        pa.PyExtensionType.__init__(self, storage_type)
+        assert isinstance(storage_type, pa.ListType)
+        super().__init__(storage_type, 'pyarrow.tests.MyListType')
 
-    def __reduce__(self):
-        return MyListType, (self.storage_type,)
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        return cls(storage_type)
 
 
-class AnnotatedType(pa.PyExtensionType):
+class AnnotatedType(pa.ExtensionType):
     """
     Generic extension type that can store any storage type.
     """
 
     def __init__(self, storage_type, annotation):
         self.annotation = annotation
-        super().__init__(storage_type)
+        super().__init__(storage_type, 'pyarrow.tests.AnnotatedType')
+
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        return cls(storage_type)
+
+
+class LegacyIntType(pa.PyExtensionType):
+
+    def __init__(self):
+        pa.PyExtensionType.__init__(self, pa.int8())
 
     def __reduce__(self):
-        return AnnotatedType, (self.storage_type, self.annotation)
+        return LegacyIntType, ()
 
 
 def ipc_write_batch(batch):
@@ -153,12 +236,12 @@ def ipc_read_batch(buf):
 
 def test_ext_type_basics():
     ty = UuidType()
-    assert ty.extension_name == "arrow.py_extension_type"
+    assert ty.extension_name == "pyarrow.tests.UuidType"
 
 
 def test_ext_type_str():
     ty = IntegerType()
-    expected = "extension<arrow.py_extension_type<IntegerType>>"
+    expected = "extension<pyarrow.tests.IntegerType<IntegerType>>"
     assert str(ty) == expected
     assert pa.DataType.__str__(ty) == expected
 
@@ -223,7 +306,7 @@ def test_uuid_type_pickle(pickle_module):
         del ty
         ty = pickle_module.loads(ser)
         wr = weakref.ref(ty)
-        assert ty.extension_name == "arrow.py_extension_type"
+        assert ty.extension_name == "pyarrow.tests.UuidType"
         del ty
         assert wr() is None
 
@@ -571,9 +654,9 @@ def test_cast_between_extension_types():
     assert tiny_int_arr.type == TinyIntType()
 
     # Casting between extension types w/ different storage types not okay.
-    msg = ("Casting from 'extension<arrow.py_extension_type<TinyIntType>>' "
+    msg = ("Casting from 'extension<.*?<TinyIntType>>' "
            "to different extension type "
-           "'extension<arrow.py_extension_type<IntegerType>>' not permitted. "
+           "'extension<.*?<IntegerType>>' not permitted. "
            "One can first cast to the storage type, "
            "then to the extension type."
            )
@@ -660,53 +743,38 @@ def example_batch():
     return pa.RecordBatch.from_arrays([arr], ["exts"])
 
 
-def check_example_batch(batch):
+def check_example_batch(batch, *, expect_extension):
     arr = batch.column(0)
-    assert isinstance(arr, pa.ExtensionArray)
-    assert arr.type.storage_type == pa.binary(3)
-    assert arr.storage.to_pylist() == [b"foo", b"bar"]
+    if expect_extension:
+        assert isinstance(arr, pa.ExtensionArray)
+        assert arr.type.storage_type == pa.binary(3)
+        assert arr.storage.to_pylist() == [b"foo", b"bar"]
+    else:
+        assert arr.type == pa.binary(3)
+        assert arr.to_pylist() == [b"foo", b"bar"]
     return arr
 
 
-def test_ipc():
+def test_ipc_unregistered():
     batch = example_batch()
     buf = ipc_write_batch(batch)
     del batch
 
     batch = ipc_read_batch(buf)
-    arr = check_example_batch(batch)
-    assert arr.type == ParamExtType(3)
+    batch.validate(full=True)
+    check_example_batch(batch, expect_extension=False)
 
 
-def test_ipc_unknown_type():
-    batch = example_batch()
-    buf = ipc_write_batch(batch)
-    del batch
-
-    orig_type = ParamExtType
-    try:
-        # Simulate the original Python type being unavailable.
-        # Deserialization should not fail but return a placeholder type.
-        del globals()['ParamExtType']
+def test_ipc_registered():
+    with registered_extension_type(ParamExtType(1)):
+        batch = example_batch()
+        buf = ipc_write_batch(batch)
+        del batch
 
         batch = ipc_read_batch(buf)
-        arr = check_example_batch(batch)
-        assert isinstance(arr.type, pa.UnknownExtensionType)
-
-        # Can be serialized again
-        buf2 = ipc_write_batch(batch)
-        del batch, arr
-
-        batch = ipc_read_batch(buf2)
-        arr = check_example_batch(batch)
-        assert isinstance(arr.type, pa.UnknownExtensionType)
-    finally:
-        globals()['ParamExtType'] = orig_type
-
-    # Deserialize again with the type restored
-    batch = ipc_read_batch(buf2)
-    arr = check_example_batch(batch)
-    assert arr.type == ParamExtType(3)
+        batch.validate(full=True)
+        arr = check_example_batch(batch, expect_extension=True)
+        assert arr.type == ParamExtType(3)
 
 
 class PeriodArray(pa.ExtensionArray):
@@ -930,6 +998,7 @@ def test_parquet_period(tmpdir, registered_period_type):
 
     # When reading in, properly create extension type if it is registered
     result = pq.read_table(filename)
+    result.validate(full=True)
     assert result.schema.field("ext").type == period_type
     assert result.schema.field("ext").metadata == {}
     # Get the exact array class defined by the registered type.
@@ -939,6 +1008,7 @@ def test_parquet_period(tmpdir, registered_period_type):
     # When the type is not registered, read in as storage type
     pa.unregister_extension_type(period_type.extension_name)
     result = pq.read_table(filename)
+    result.validate(full=True)
     assert result.schema.field("ext").type == pa.int64()
     # The extension metadata is present for roundtripping.
     assert result.schema.field("ext").metadata == {
@@ -967,13 +1037,28 @@ def test_parquet_extension_with_nested_storage(tmpdir):
     filename = tmpdir / 'nested_extension_storage.parquet'
     pq.write_table(orig_table, filename)
 
+    # Unregistered
     table = pq.read_table(filename)
-    assert table.column('structs').type == mystruct_array.type
-    assert table.column('lists').type == mylist_array.type
-    assert table == orig_table
-
-    with pytest.raises(pa.ArrowInvalid, match='without all of its fields'):
-        pq.ParquetFile(filename).read(columns=['structs.left'])
+    table.validate(full=True)
+    assert table.column('structs').type == struct_array.type
+    assert table.column('structs').combine_chunks() == struct_array
+    assert table.column('lists').type == list_array.type
+    assert table.column('lists').combine_chunks() == list_array
+
+    # Registered
+    with registered_extension_type(mystruct_array.type):
+        with registered_extension_type(mylist_array.type):
+            table = pq.read_table(filename)
+            table.validate(full=True)
+            assert table.column('structs').type == mystruct_array.type
+            assert table.column('lists').type == mylist_array.type
+            assert table == orig_table
+
+            # Cannot select a subfield of an extension type with
+            # a struct storage type.
+            with pytest.raises(pa.ArrowInvalid,
+                               match='without all of its fields'):
+                pq.ParquetFile(filename).read(columns=['structs.left'])
 
 
 @pytest.mark.parquet
@@ -995,8 +1080,14 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == struct_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.struct({'ints': pa.int64(),
+                                              'exts': pa.int64()})
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == struct_array.type
+        assert table == orig_table
 
     # List of extensions
     list_array = pa.ListArray.from_arrays([0, 1, None, 3], ext_array)
@@ -1006,8 +1097,13 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == list_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.list_(pa.int64())
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == list_array.type
+        assert table == orig_table
 
     # Large list of extensions
     list_array = pa.LargeListArray.from_arrays([0, 1, None, 3], ext_array)
@@ -1017,8 +1113,13 @@ def test_parquet_nested_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == list_array.type
-    assert table == orig_table
+    table.validate(full=True)
+    assert table.column(0).type == pa.large_list(pa.int64())
+    with registered_extension_type(ext_type):
+        table = pq.read_table(filename)
+        table.validate(full=True)
+        assert table.column(0).type == list_array.type
+        assert table == orig_table
 
 
 @pytest.mark.parquet
@@ -1040,8 +1141,12 @@ def test_parquet_extension_nested_in_extension(tmpdir):
     pq.write_table(orig_table, filename)
 
     table = pq.read_table(filename)
-    assert table.column(0).type == mylist_array.type
-    assert table == orig_table
+    assert table.column(0).type == pa.list_(pa.int64())
+    with registered_extension_type(mylist_array.type):
+        with registered_extension_type(inner_ext_array.type):
+            table = pq.read_table(filename)
+            assert table.column(0).type == mylist_array.type
+            assert table == orig_table
 
 
 def test_to_numpy():
@@ -1370,3 +1475,25 @@ def test_tensor_type_is_picklable(pickle_module):
 def test_tensor_type_str(tensor_type, text):
     tensor_type_str = tensor_type.__str__()
     assert text in tensor_type_str
+
+
+def test_legacy_int_type():
+    with pytest.warns(FutureWarning, match="PyExtensionType is deprecated"):
+        ext_ty = LegacyIntType()
+    arr = pa.array([1, 2, 3], type=ext_ty.storage_type)
+    ext_arr = pa.ExtensionArray.from_storage(ext_ty, arr)
+    batch = pa.RecordBatch.from_arrays([ext_arr], names=['ext'])
+    buf = ipc_write_batch(batch)
+
+    with pytest.warns(
+            RuntimeWarning,
+            match="pickle-based deserialization of pyarrow.PyExtensionType "
+                  "subclasses is disabled by default"):
+        batch = ipc_read_batch(buf)
+        assert isinstance(batch.column(0).type, pa.UnknownExtensionType)
+
+    with enabled_auto_load():
+        with pytest.warns(FutureWarning, match="PyExtensionType is deprecated"):
+            batch = ipc_read_batch(buf)
+            assert isinstance(batch.column(0).type, LegacyIntType)
+            assert batch.column(0) == ext_arr
diff --git a/python/pyarrow/tests/test_pandas.py b/python/pyarrow/tests/test_pandas.py
index 62a9443953a3d..10eb931592093 100644
--- a/python/pyarrow/tests/test_pandas.py
+++ b/python/pyarrow/tests/test_pandas.py
@@ -4096,13 +4096,20 @@ def test_array_protocol():
     assert result.equals(expected2)
 
 
-class DummyExtensionType(pa.PyExtensionType):
+class DummyExtensionType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(),
+                         'pyarrow.tests.test_pandas.DummyExtensionType')
 
-    def __reduce__(self):
-        return DummyExtensionType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        assert serialized == b''
+        assert storage_type == pa.int64()
+        return cls()
 
 
 def PandasArray__arrow_array__(self, type=None):
@@ -4198,13 +4205,14 @@ def test_convert_to_extension_array(monkeypatch):
     assert not isinstance(_get_mgr(result).blocks[0], _int.ExtensionBlock)
 
 
-class MyCustomIntegerType(pa.PyExtensionType):
+class MyCustomIntegerType(pa.ExtensionType):
 
     def __init__(self):
-        pa.PyExtensionType.__init__(self, pa.int64())
+        super().__init__(pa.int64(),
+                         'pyarrow.tests.test_pandas.MyCustomIntegerType')
 
-    def __reduce__(self):
-        return MyCustomIntegerType, ()
+    def __arrow_ext_serialize__(self):
+        return b''
 
     def to_pandas_dtype(self):
         return pd.Int64Dtype()
diff --git a/python/pyarrow/types.pxi b/python/pyarrow/types.pxi
index d394b803e7fc2..a0ddf09d69423 100644
--- a/python/pyarrow/types.pxi
+++ b/python/pyarrow/types.pxi
@@ -1437,7 +1437,10 @@ cdef class ExtensionType(BaseExtensionType):
     Parameters
     ----------
     storage_type : DataType
+        The underlying storage type for the extension type.
     extension_name : str
+        A unique name distinguishing this extension type. The name will be
+        used when deserializing IPC data.
 
     Examples
     --------
@@ -1671,60 +1674,22 @@ cdef class FixedShapeTensorType(BaseExtensionType):
                                     self.dim_names, self.permutation)
 
 
+_py_extension_type_auto_load = False
+
+
 cdef class PyExtensionType(ExtensionType):
     """
     Concrete base class for Python-defined extension types based on pickle
     for (de)serialization.
 
+    .. warning::
+       This class is deprecated and its deserialization is disabled by default.
+       :class:`ExtensionType` is recommended instead.
+
     Parameters
     ----------
     storage_type : DataType
         The storage type for which the extension is built.
-
-    Examples
-    --------
-    Define a UuidType extension type subclassing PyExtensionType:
-
-    >>> import pyarrow as pa
-    >>> class UuidType(pa.PyExtensionType):
-    ...     def __init__(self):
-    ...         pa.PyExtensionType.__init__(self, pa.binary(16))
-    ...     def __reduce__(self):
-    ...         return UuidType, ()
-    ...
-
-    Create an instance of UuidType extension type:
-
-    >>> uuid_type = UuidType() # doctest: +SKIP
-    >>> uuid_type # doctest: +SKIP
-    UuidType(FixedSizeBinaryType(fixed_size_binary[16]))
-
-    Inspect the extension type:
-
-    >>> uuid_type.extension_name # doctest: +SKIP
-    'arrow.py_extension_type'
-    >>> uuid_type.storage_type # doctest: +SKIP
-    FixedSizeBinaryType(fixed_size_binary[16])
-
-    Wrap an array as an extension array:
-
-    >>> import uuid
-    >>> storage_array = pa.array([uuid.uuid4().bytes for _ in range(4)],
-    ...                          pa.binary(16)) # doctest: +SKIP
-    >>> uuid_type.wrap_array(storage_array) # doctest: +SKIP
-    <pyarrow.lib.ExtensionArray object at ...>
-    [
-      ...
-    ]
-
-    Or do the same with creating an ExtensionArray:
-
-    >>> pa.ExtensionArray.from_storage(uuid_type,
-    ...                                storage_array) # doctest: +SKIP
-    <pyarrow.lib.ExtensionArray object at ...>
-    [
-      ...
-    ]
     """
 
     def __cinit__(self):
@@ -1733,6 +1698,12 @@ cdef class PyExtensionType(ExtensionType):
                             "PyExtensionType")
 
     def __init__(self, DataType storage_type):
+        warnings.warn(
+            "pyarrow.PyExtensionType is deprecated "
+            "and will refuse deserialization by default. "
+            "Instead, please derive from pyarrow.ExtensionType and implement "
+            "your own serialization mechanism.",
+            FutureWarning)
         ExtensionType.__init__(self, storage_type, "arrow.py_extension_type")
 
     def __reduce__(self):
@@ -1744,6 +1715,17 @@ cdef class PyExtensionType(ExtensionType):
 
     @classmethod
     def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        if not _py_extension_type_auto_load:
+            warnings.warn(
+                "pickle-based deserialization of pyarrow.PyExtensionType subclasses "
+                "is disabled by default; if you only ingest "
+                "trusted data files, you may re-enable this using "
+                "`pyarrow.PyExtensionType.set_auto_load(True)`.\n"
+                "In the future, Python-defined extension subclasses should "
+                "derive from pyarrow.ExtensionType (not pyarrow.PyExtensionType) "
+                "and implement their own serialization mechanism.\n",
+                RuntimeWarning)
+            return UnknownExtensionType(storage_type, serialized)
         try:
             ty = pickle.loads(serialized)
         except Exception:
@@ -1759,6 +1741,22 @@ cdef class PyExtensionType(ExtensionType):
                             .format(ty.storage_type, storage_type))
         return ty
 
+    # XXX Cython marks extension types as immutable, so cannot expose this
+    # as a writable class attribute.
+    @classmethod
+    def set_auto_load(cls, value):
+        """
+        Enable or disable auto-loading of serialized PyExtensionType instances.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to enable auto-loading.
+        """
+        global _py_extension_type_auto_load
+        assert isinstance(value, bool)
+        _py_extension_type_auto_load = value
+
 
 cdef class UnknownExtensionType(PyExtensionType):
     """

From 6dcba930bed468268288dc6f66c1580cbf5f80e0 Mon Sep 17 00:00:00 2001
From: Maximilian Muecke <muecke.maximilian@gmail.com>
Date: Tue, 7 Nov 2023 00:47:50 +0100
Subject: [PATCH 693/749] GH-38602: [R] Add missing `prod` for summarize
 (#38601)

### Rationale for this change

`prod` is currently missing for use in summarize.

### What changes are included in this PR?

Added `prod` for summarize aggregation.

### Are these changes tested?

Yes, included the same tests used for the other aggregation functions for summarize.

### Are there any user-facing changes?

Yes, added `prod` function.

* Closes: #38602

Authored-by: Maximilian Muecke <muecke.maximilian@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/R/dplyr-funcs-doc.R                   |  1 +
 r/R/dplyr-summarize.R                   |  7 +++++++
 r/man/acero.Rd                          |  1 +
 r/src/compute.cpp                       |  3 ++-
 r/tests/testthat/test-dplyr-summarize.R | 23 +++++++++++++++++++++++
 5 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/r/R/dplyr-funcs-doc.R b/r/R/dplyr-funcs-doc.R
index 5099e903da670..492729df8c12a 100644
--- a/r/R/dplyr-funcs-doc.R
+++ b/r/R/dplyr-funcs-doc.R
@@ -167,6 +167,7 @@
 #' * [`paste0()`][base::paste0()]: the `collapse` argument is not yet supported
 #' * [`pmax()`][base::pmax()]
 #' * [`pmin()`][base::pmin()]
+#' * [`prod()`][base::prod()]
 #' * [`round()`][base::round()]
 #' * [`sign()`][base::sign()]
 #' * [`sin()`][base::sin()]
diff --git a/r/R/dplyr-summarize.R b/r/R/dplyr-summarize.R
index 1e9d42969d080..e2c70f9e89e42 100644
--- a/r/R/dplyr-summarize.R
+++ b/r/R/dplyr-summarize.R
@@ -42,6 +42,13 @@ register_bindings_aggregate <- function() {
       options = list(skip_nulls = na.rm, min_count = 0L)
     )
   })
+  register_binding_agg("base::prod", function(..., na.rm = FALSE) {
+    list(
+      fun = "product",
+      data = ensure_one_arg(list2(...), "prod"),
+      options = list(skip_nulls = na.rm, min_count = 0L)
+    )
+  })
   register_binding_agg("base::any", function(..., na.rm = FALSE) {
     list(
       fun = "any",
diff --git a/r/man/acero.Rd b/r/man/acero.Rd
index c9fb4d37a1d95..12afdc23138ac 100644
--- a/r/man/acero.Rd
+++ b/r/man/acero.Rd
@@ -156,6 +156,7 @@ Consider using the lubridate specialised parsing functions \code{ymd()}, \code{y
 \item \code{\link[base:paste]{paste0()}}: the \code{collapse} argument is not yet supported
 \item \code{\link[base:Extremes]{pmax()}}
 \item \code{\link[base:Extremes]{pmin()}}
+\item \code{\link[base:prod]{prod()}}
 \item \code{\link[base:Round]{round()}}
 \item \code{\link[base:sign]{sign()}}
 \item \code{\link[base:Trig]{sin()}}
diff --git a/r/src/compute.cpp b/r/src/compute.cpp
index 578ce74d05d12..87d1326ed3419 100644
--- a/r/src/compute.cpp
+++ b/r/src/compute.cpp
@@ -176,7 +176,8 @@ std::shared_ptr<arrow::compute::FunctionOptions> make_compute_options(
       func_name == "hash_approximate_median" || func_name == "mean" ||
       func_name == "hash_mean" || func_name == "min_max" || func_name == "hash_min_max" ||
       func_name == "min" || func_name == "hash_min" || func_name == "max" ||
-      func_name == "hash_max" || func_name == "sum" || func_name == "hash_sum") {
+      func_name == "hash_max" || func_name == "sum" || func_name == "hash_sum" ||
+      func_name == "product" || func_name == "hash_product") {
     using Options = arrow::compute::ScalarAggregateOptions;
     auto out = std::make_shared<Options>(Options::Defaults());
     if (!Rf_isNull(options["min_count"])) {
diff --git a/r/tests/testthat/test-dplyr-summarize.R b/r/tests/testthat/test-dplyr-summarize.R
index e2fb9841e72ad..29993711921e2 100644
--- a/r/tests/testthat/test-dplyr-summarize.R
+++ b/r/tests/testthat/test-dplyr-summarize.R
@@ -91,6 +91,27 @@ test_that("Group by sum on dataset", {
   )
 })
 
+test_that("Group by prod on dataset", {
+  compare_dplyr_binding(
+    .input %>%
+      group_by(some_grouping) %>%
+      summarize(prod = prod(int, na.rm = TRUE)) %>%
+      collect(),
+    tbl
+  )
+
+  compare_dplyr_binding(
+    .input %>%
+      group_by(some_grouping) %>%
+      summarize(
+        prod = prod(int, na.rm = FALSE),
+        prod2 = base::prod(int, na.rm = TRUE)
+      ) %>%
+      collect(),
+    tbl
+  )
+})
+
 test_that("Group by mean on dataset", {
   compare_dplyr_binding(
     .input %>%
@@ -319,6 +340,7 @@ test_that("Functions that take ... but we only accept a single arg", {
   # the agg_funcs directly
   expect_error(call_binding_agg("n_distinct"), "n_distinct() with 0 arguments", fixed = TRUE)
   expect_error(call_binding_agg("sum"), "sum() with 0 arguments", fixed = TRUE)
+  expect_error(call_binding_agg("prod"), "prod() with 0 arguments", fixed = TRUE)
   expect_error(call_binding_agg("any"), "any() with 0 arguments", fixed = TRUE)
   expect_error(call_binding_agg("all"), "all() with 0 arguments", fixed = TRUE)
   expect_error(call_binding_agg("min"), "min() with 0 arguments", fixed = TRUE)
@@ -642,6 +664,7 @@ test_that("summarise() with !!sym()", {
       group_by(false) %>%
       summarise(
         sum = sum(!!sym(test_dbl_col)),
+        prod = prod(!!sym(test_dbl_col)),
         any = any(!!sym(test_lgl_col)),
         all = all(!!sym(test_lgl_col)),
         mean = mean(!!sym(test_dbl_col)),

From 2e01f0ce4d05726b3d6203e216211201e4c50d00 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 09:48:01 +0900
Subject: [PATCH 694/749] MINOR: [JS] Bump @types/command-line-args from 5.2.0
 to 5.2.2 in /js (#38546)

Bumps [@ types/command-line-args](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/command-line-args) from 5.2.0 to 5.2.2.
<details>
<summary>Commits</summary>
<ul>
<li>See full diff in <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/command-line-args">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=@ types/command-line-args&package-manager=npm_and_yarn&previous-version=5.2.0&new-version=5.2.2)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/yarn.lock | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/js/yarn.lock b/js/yarn.lock
index b2ed3ed20600b..26a459a73a206 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -1255,9 +1255,9 @@
   integrity sha512-rVCCileCU5NhP9Ix1e03sIn4gd0mpjh7VNULVQAxzF+9vddk6A5QAHzp2h5kXH8pkv1Ow45fUf3QP3wOEiISvA==
 
 "@types/command-line-args@^5.2.1":
-  version "5.2.1"
-  resolved "https://registry.npmjs.org/@types/command-line-args/-/command-line-args-5.2.1.tgz#233bd1ba687e84ecbec0388e09f9ec9ebf63c55b"
-  integrity sha512-U2OcmS2tj36Yceu+mRuPyUV0ILfau/h5onStcSCzqTENsq0sBiAp2TmaXu1k8fY4McLcPKSYl9FRzn2hx5bI+w==
+  version "5.2.2"
+  resolved "https://registry.yarnpkg.com/@types/command-line-args/-/command-line-args-5.2.2.tgz#ca93ae7045305a2b7c60936bfcb1ebc897b42270"
+  integrity sha512-9aZ7KzLDOBYyqH5J2bvB9edvsMXusX+H/aS8idAJOpWNmscZG5RqO1CVJPFa4Q0/1xKgvxcweXunFVx2l/dYFA==
 
 "@types/command-line-usage@^5.0.2":
   version "5.0.2"

From 7622ded456497911785f997a9e0240033e57042d Mon Sep 17 00:00:00 2001
From: Jonathan Keane <jkeane@gmail.com>
Date: Mon, 6 Nov 2023 19:08:13 -0600
Subject: [PATCH 695/749] GH-38570: [R] Ensure that test-nix-libs is warning
 free (#38571)

### Rationale for this change

Although we stop / fail the CI job for warnings elsewhere, we don't seem to be doing that for our buildsystem tests. Let's change that so warnings + other output doesn't creep in.

- [x] Prevent `*** Failed to find latest nightly for 8.0.0.9000` from showing up when the file is sourced under test
- [x] fix `Warning ('test-nixlibs.R:140:3'): select_binary() with test program 'x' is NULL so the result will be NULL`
- [x] update version strings to be characters to avoid r-devel warnings

### What changes are included in this PR?

Added `stop_on_warning` to the test call, and fixes to make that pass

### Are these changes tested?

Yes, they are all part of the test suite

### Are there any user-facing changes?

No.
* Closes: #38570

Authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 ci/scripts/r_test.sh     |  2 +-
 r/tools/check-versions.R |  4 ++--
 r/tools/nixlibs.R        | 14 +++++++++-----
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/ci/scripts/r_test.sh b/ci/scripts/r_test.sh
index e0c2ce9efedd8..22ec551edb9fa 100755
--- a/ci/scripts/r_test.sh
+++ b/ci/scripts/r_test.sh
@@ -27,7 +27,7 @@ pushd ${source_dir}
 printenv
 
 # Run the nixlibs.R test suite, which is not included in the installed package
-${R_BIN} -e 'setwd("tools"); testthat::test_dir(".")'
+${R_BIN} -e 'setwd("tools"); testthat::test_dir(".", stop_on_warning = TRUE)'
 
 # Before release, we always copy the relevant parts of the cpp source into the
 # package. In some CI checks, we will use this version of the source:
diff --git a/r/tools/check-versions.R b/r/tools/check-versions.R
index 45fbd0b61a40a..3d8cbf02a14c9 100644
--- a/r/tools/check-versions.R
+++ b/r/tools/check-versions.R
@@ -23,8 +23,8 @@ test_mode <- exists("TESTING")
 check_versions <- function(r_version, cpp_version) {
   r_parsed <- package_version(r_version)
   r_dev_version <- r_parsed[1, 4]
-  r_is_dev <- !is.na(r_dev_version) && r_dev_version > 100
-  r_is_patch <- !is.na(r_dev_version) && r_dev_version <= 100
+  r_is_dev <- !is.na(r_dev_version) && r_dev_version > "100"
+  r_is_patch <- !is.na(r_dev_version) && r_dev_version <= "100"
   cpp_is_dev <- grepl("SNAPSHOT$", cpp_version)
   cpp_parsed <- package_version(sub("-SNAPSHOT$", "", cpp_version))
 
diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 96f2b858cf180..63c185ce54563 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -198,7 +198,11 @@ select_binary <- function(os = tolower(Sys.info()[["sysname"]]),
         errs <- compile_test_program(test_program)
         openssl_version <- determine_binary_from_stderr(errs)
         arch <- ifelse(identical(os, "darwin"), paste0("-", arch, "-"), "-")
-        ifelse(is.null(openssl_version), NULL, paste0(os, arch, openssl_version))
+        if (is.null(openssl_version)) {
+          NULL
+        } else {
+          paste0(os, arch, openssl_version)
+        }
       },
       error = function(e) {
         lg("Unable to find libcurl and openssl")
@@ -210,7 +214,7 @@ select_binary <- function(os = tolower(Sys.info()[["sysname"]]),
     lg("Building on %s %s", os, arch)
     binary <- NULL
   }
-  return(binary)
+  binary
 }
 
 # This tests that curl and OpenSSL are present (bc we can include their headers)
@@ -268,7 +272,7 @@ get_macos_openssl_dir <- function() {
       openssl_root_dir <- "/usr/local"
     }
   }
-  return(openssl_root_dir)
+  openssl_root_dir
 }
 
 # (built with newer devtoolset but older glibc (2.17) for broader compatibility,# like manylinux2014)
@@ -828,10 +832,10 @@ quietly <- !env_is("ARROW_R_DEV", "true")
 
 not_cran <- env_is("NOT_CRAN", "true")
 
-if (is_release) {
+if (is_release & !test_mode) {
   VERSION <- VERSION[1, 1:3]
   arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
-} else {
+} else if(!test_mode) {
   not_cran <- TRUE
   arrow_repo <- paste0(getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"), "/libarrow/")
   VERSION <- find_latest_nightly(VERSION)

From f1820cb3d79a31945a9e0992fbedbc5d3b932ec2 Mon Sep 17 00:00:00 2001
From: Sutou Kouhei <kou@clear-code.com>
Date: Tue, 7 Nov 2023 10:34:18 +0900
Subject: [PATCH 696/749] GH-38330: [C++][Azure] Use properties for input
 stream metadata (#38524)

### Rationale for this change

We use user defined metadata for input stream metadata for now. But we should use properties returned from Azure like other remove filesystem implementations such as S3 and GCS.

### What changes are included in this PR?

Convert `Azure::Storage::Blobs::Models::BlobProperties` to `KeyValueMetadata`. The following values aren't supported yet:

* `BlobProperties::ObjectReplicationSourceProperties`
* `BlobProperties::Metadata`

If they need, we will add support for them as a follow-up task.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

Yes.
* Closes: #38330

Lead-authored-by: Sutou Kouhei <kou@clear-code.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/filesystem/azurefs.cc      | 150 +++++++++++++++++++++--
 cpp/src/arrow/filesystem/azurefs_test.cc |  67 ++++++++--
 2 files changed, 201 insertions(+), 16 deletions(-)

diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc
index 179be069b2acf..a04338d999d11 100644
--- a/cpp/src/arrow/filesystem/azurefs.cc
+++ b/cpp/src/arrow/filesystem/azurefs.cc
@@ -24,6 +24,7 @@
 #include "arrow/filesystem/util_internal.h"
 #include "arrow/result.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/formatting.h"
 #include "arrow/util/future.h"
 #include "arrow/util/key_value_metadata.h"
 #include "arrow/util/logging.h"
@@ -150,13 +151,148 @@ Status ErrorToStatus(const std::string& prefix,
   return Status::IOError(prefix, " Azure Error: ", exception.what());
 }
 
-template <typename ObjectResult>
-std::shared_ptr<const KeyValueMetadata> GetObjectMetadata(const ObjectResult& result) {
-  auto md = std::make_shared<KeyValueMetadata>();
-  for (auto prop : result) {
-    md->Append(prop.first, prop.second);
+template <typename ArrowType>
+std::string FormatValue(typename TypeTraits<ArrowType>::CType value) {
+  struct StringAppender {
+    std::string string;
+    Status operator()(std::string_view view) {
+      string.append(view.data(), view.size());
+      return Status::OK();
+    }
+  } appender;
+  arrow::internal::StringFormatter<ArrowType> formatter;
+  ARROW_UNUSED(formatter(value, appender));
+  return appender.string;
+}
+
+std::shared_ptr<const KeyValueMetadata> PropertiesToMetadata(
+    const Azure::Storage::Blobs::Models::BlobProperties& properties) {
+  auto metadata = std::make_shared<KeyValueMetadata>();
+  // Not supported yet:
+  // * properties.ObjectReplicationSourceProperties
+  // * properties.Metadata
+  //
+  // They may have the same key defined in the following
+  // metadata->Append() list. If we have duplicated key in metadata,
+  // the first value may be only used by users because
+  // KeyValueMetadata::Get() returns the first found value. Note that
+  // users can use all values by using KeyValueMetadata::keys() and
+  // KeyValueMetadata::values().
+  if (properties.ImmutabilityPolicy.HasValue()) {
+    metadata->Append("Immutability-Policy-Expires-On",
+                     properties.ImmutabilityPolicy.Value().ExpiresOn.ToString());
+    metadata->Append("Immutability-Policy-Mode",
+                     properties.ImmutabilityPolicy.Value().PolicyMode.ToString());
+  }
+  metadata->Append("Content-Type", properties.HttpHeaders.ContentType);
+  metadata->Append("Content-Encoding", properties.HttpHeaders.ContentEncoding);
+  metadata->Append("Content-Language", properties.HttpHeaders.ContentLanguage);
+  const auto& content_hash = properties.HttpHeaders.ContentHash.Value;
+  metadata->Append("Content-Hash", HexEncode(content_hash.data(), content_hash.size()));
+  metadata->Append("Content-Disposition", properties.HttpHeaders.ContentDisposition);
+  metadata->Append("Cache-Control", properties.HttpHeaders.CacheControl);
+  metadata->Append("Last-Modified", properties.LastModified.ToString());
+  metadata->Append("Created-On", properties.CreatedOn.ToString());
+  if (properties.ObjectReplicationDestinationPolicyId.HasValue()) {
+    metadata->Append("Object-Replication-Destination-Policy-Id",
+                     properties.ObjectReplicationDestinationPolicyId.Value());
+  }
+  metadata->Append("Blob-Type", properties.BlobType.ToString());
+  if (properties.CopyCompletedOn.HasValue()) {
+    metadata->Append("Copy-Completed-On", properties.CopyCompletedOn.Value().ToString());
+  }
+  if (properties.CopyStatusDescription.HasValue()) {
+    metadata->Append("Copy-Status-Description", properties.CopyStatusDescription.Value());
+  }
+  if (properties.CopyId.HasValue()) {
+    metadata->Append("Copy-Id", properties.CopyId.Value());
+  }
+  if (properties.CopyProgress.HasValue()) {
+    metadata->Append("Copy-Progress", properties.CopyProgress.Value());
+  }
+  if (properties.CopySource.HasValue()) {
+    metadata->Append("Copy-Source", properties.CopySource.Value());
+  }
+  if (properties.CopyStatus.HasValue()) {
+    metadata->Append("Copy-Status", properties.CopyStatus.Value().ToString());
+  }
+  if (properties.IsIncrementalCopy.HasValue()) {
+    metadata->Append("Is-Incremental-Copy",
+                     FormatValue<BooleanType>(properties.IsIncrementalCopy.Value()));
+  }
+  if (properties.IncrementalCopyDestinationSnapshot.HasValue()) {
+    metadata->Append("Incremental-Copy-Destination-Snapshot",
+                     properties.IncrementalCopyDestinationSnapshot.Value());
+  }
+  if (properties.LeaseDuration.HasValue()) {
+    metadata->Append("Lease-Duration", properties.LeaseDuration.Value().ToString());
+  }
+  if (properties.LeaseState.HasValue()) {
+    metadata->Append("Lease-State", properties.LeaseState.Value().ToString());
+  }
+  if (properties.LeaseStatus.HasValue()) {
+    metadata->Append("Lease-Status", properties.LeaseStatus.Value().ToString());
+  }
+  metadata->Append("Content-Length", FormatValue<Int64Type>(properties.BlobSize));
+  if (properties.ETag.HasValue()) {
+    metadata->Append("ETag", properties.ETag.ToString());
+  }
+  if (properties.SequenceNumber.HasValue()) {
+    metadata->Append("Sequence-Number",
+                     FormatValue<Int64Type>(properties.SequenceNumber.Value()));
+  }
+  if (properties.CommittedBlockCount.HasValue()) {
+    metadata->Append("Committed-Block-Count",
+                     FormatValue<Int32Type>(properties.CommittedBlockCount.Value()));
+  }
+  metadata->Append("IsServerEncrypted",
+                   FormatValue<BooleanType>(properties.IsServerEncrypted));
+  if (properties.EncryptionKeySha256.HasValue()) {
+    const auto& sha256 = properties.EncryptionKeySha256.Value();
+    metadata->Append("Encryption-Key-Sha-256", HexEncode(sha256.data(), sha256.size()));
+  }
+  if (properties.EncryptionScope.HasValue()) {
+    metadata->Append("Encryption-Scope", properties.EncryptionScope.Value());
+  }
+  if (properties.AccessTier.HasValue()) {
+    metadata->Append("Access-Tier", properties.AccessTier.Value().ToString());
+  }
+  if (properties.IsAccessTierInferred.HasValue()) {
+    metadata->Append("Is-Access-Tier-Inferred",
+                     FormatValue<BooleanType>(properties.IsAccessTierInferred.Value()));
+  }
+  if (properties.ArchiveStatus.HasValue()) {
+    metadata->Append("Archive-Status", properties.ArchiveStatus.Value().ToString());
+  }
+  if (properties.AccessTierChangedOn.HasValue()) {
+    metadata->Append("Access-Tier-Changed-On",
+                     properties.AccessTierChangedOn.Value().ToString());
+  }
+  if (properties.VersionId.HasValue()) {
+    metadata->Append("Version-Id", properties.VersionId.Value());
+  }
+  if (properties.IsCurrentVersion.HasValue()) {
+    metadata->Append("Is-Current-Version",
+                     FormatValue<BooleanType>(properties.IsCurrentVersion.Value()));
+  }
+  if (properties.TagCount.HasValue()) {
+    metadata->Append("Tag-Count", FormatValue<Int32Type>(properties.TagCount.Value()));
+  }
+  if (properties.ExpiresOn.HasValue()) {
+    metadata->Append("Expires-On", properties.ExpiresOn.Value().ToString());
+  }
+  if (properties.IsSealed.HasValue()) {
+    metadata->Append("Is-Sealed", FormatValue<BooleanType>(properties.IsSealed.Value()));
+  }
+  if (properties.RehydratePriority.HasValue()) {
+    metadata->Append("Rehydrate-Priority",
+                     properties.RehydratePriority.Value().ToString());
+  }
+  if (properties.LastAccessedOn.HasValue()) {
+    metadata->Append("Last-Accessed-On", properties.LastAccessedOn.Value().ToString());
   }
-  return md;
+  metadata->Append("Has-Legal-Hold", FormatValue<BooleanType>(properties.HasLegalHold));
+  return metadata;
 }
 
 class ObjectInputFile final : public io::RandomAccessFile {
@@ -176,7 +312,7 @@ class ObjectInputFile final : public io::RandomAccessFile {
     try {
       auto properties = blob_client_->GetProperties();
       content_length_ = properties.Value.BlobSize;
-      metadata_ = GetObjectMetadata(properties.Value.Metadata);
+      metadata_ = PropertiesToMetadata(properties.Value);
       return Status::OK();
     } catch (const Azure::Storage::StorageException& exception) {
       if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index 5d454bdc33f47..f57fc4d8140a0 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -51,6 +51,8 @@
 #include "arrow/testing/util.h"
 #include "arrow/util/io_util.h"
 #include "arrow/util/key_value_metadata.h"
+#include "arrow/util/string.h"
+#include "arrow/util/value_parsing.h"
 
 namespace arrow {
 using internal::TemporaryDir;
@@ -296,21 +298,68 @@ TEST_F(TestAzureFileSystem, OpenInputStreamTrailingSlash) {
   ASSERT_RAISES(IOError, fs_->OpenInputStream(PreexistingObjectPath() + '/'));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamReadMetadata) {
-  const std::string object_name = "OpenInputStreamMetadataTest/simple.txt";
-
-  service_client_->GetBlobContainerClient(PreexistingContainerName())
-      .GetBlobClient(PreexistingObjectName())
-      .SetMetadata(Azure::Storage::Metadata{{"key0", "value0"}});
+namespace {
+std::shared_ptr<const KeyValueMetadata> NormalizerKeyValueMetadata(
+    std::shared_ptr<const KeyValueMetadata> metadata) {
+  auto normalized = std::make_shared<KeyValueMetadata>();
+  for (int64_t i = 0; i < metadata->size(); ++i) {
+    auto key = metadata->key(i);
+    auto value = metadata->value(i);
+    if (key == "Content-Hash") {
+      std::vector<uint8_t> output;
+      output.reserve(value.size() / 2);
+      if (ParseHexValues(value, output.data()).ok()) {
+        // Valid value
+        value = std::string(value.size(), 'F');
+      }
+    } else if (key == "Last-Modified" || key == "Created-On" ||
+               key == "Access-Tier-Changed-On") {
+      auto parser = TimestampParser::MakeISO8601();
+      int64_t output;
+      if ((*parser)(value.data(), value.size(), TimeUnit::NANO, &output)) {
+        // Valid value
+        value = "2023-10-31T08:15:20Z";
+      }
+    } else if (key == "ETag") {
+      if (internal::StartsWith(value, "\"") && internal::EndsWith(value, "\"")) {
+        // Valid value
+        value = "\"ETagValue\"";
+      }
+    }
+    normalized->Append(key, value);
+  }
+  return normalized;
+}
+};  // namespace
 
+TEST_F(TestAzureFileSystem, OpenInputStreamReadMetadata) {
   std::shared_ptr<io::InputStream> stream;
   ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
 
   std::shared_ptr<const KeyValueMetadata> actual;
   ASSERT_OK_AND_ASSIGN(actual, stream->ReadMetadata());
-  // TODO(GH-38330): This is asserting that the user defined metadata is returned but this
-  // is probably not the correct behaviour.
-  ASSERT_OK_AND_EQ("value0", actual->Get("key0"));
+  ASSERT_EQ(
+      "\n"
+      "-- metadata --\n"
+      "Content-Type: application/octet-stream\n"
+      "Content-Encoding: \n"
+      "Content-Language: \n"
+      "Content-Hash: FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\n"
+      "Content-Disposition: \n"
+      "Cache-Control: \n"
+      "Last-Modified: 2023-10-31T08:15:20Z\n"
+      "Created-On: 2023-10-31T08:15:20Z\n"
+      "Blob-Type: BlockBlob\n"
+      "Lease-State: available\n"
+      "Lease-Status: unlocked\n"
+      "Content-Length: 447\n"
+      "ETag: \"ETagValue\"\n"
+      "IsServerEncrypted: true\n"
+      "Access-Tier: Hot\n"
+      "Is-Access-Tier-Inferred: true\n"
+      "Access-Tier-Changed-On: 2023-10-31T08:15:20Z\n"
+      "Has-Legal-Hold: false",
+      NormalizerKeyValueMetadata(actual)->ToString());
 }
 
 TEST_F(TestAzureFileSystem, OpenInputStreamClosed) {

From dbed49914eb0dab00250566b993a7b30123b963c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 11:00:23 +0900
Subject: [PATCH 697/749] MINOR: [C#] Bump BenchmarkDotNet.Diagnostics.Windows
 from 0.13.9 to 0.13.10 in /csharp (#38605)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [BenchmarkDotNet.Diagnostics.Windows](https://github.com/dotnet/BenchmarkDotNet) from 0.13.9 to 0.13.10.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/dotnet/BenchmarkDotNet/releases">BenchmarkDotNet.Diagnostics.Windows's releases</a>.</em></p>
<blockquote>
<h2>0.13.10</h2>
<p>Full changelog: <a href="https://benchmarkdotnet.org/changelog/v0.13.10.html">https://benchmarkdotnet.org/changelog/v0.13.10.html</a></p>
<h2>Highlights</h2>
<p>Initial support of .NET 9 and minor bug fixes.</p>
<h2>Details</h2>
<p>In the <a href="https://github.com/dotnet/BenchmarkDotNet/issues?q=milestone:v0.13.10">v0.13.10</a> scope,
2 issues were resolved and 3 pull requests were merged.
This release includes 10 commits by 4 contributors.</p>
<h2>Resolved issues (2)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> BenchmarkDotNet Access Denied Error on WSL2 when Writing to '/mnt/c/DumpStack.log.tmp' (assignee: <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2455">#2455</a> .NET 9 support (assignee: <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
</ul>
<h2>Merged pull requests (3)</h2>
<ul>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2447">#2447</a> Add support for wasm/net9.0 (by <a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2453">#2453</a> feat: set RuntimeHostConfigurationOption on generated project (by <a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
<li><a href="https://redirect.github.com/dotnet/BenchmarkDotNet/pull/2456">#2456</a> implement full .NET 9 support (by <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
</ul>
<h2>Commits (10)</h2>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c27152b9d7b6391501abcf7e8edcb2804999622f">c27152</a> Set next BenchmarkDotNet version: 0.13.10 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2e96d29453a804cfc1b92fffeea94c866522167a">2e96d2</a> Don't show AssemblyInformationalVersion metadata in BDN BrandVersion (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d17c6ad0bd8ac15d83ced0a7522de7dd51526ad4">d17c6a</a> Support Windows 11 23H2 (10.0.22631) in OsBrandStringHelper (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af9c5c6013b4e661cda0ff8fed40a50ae62d5a74">af9c5c</a> Exception handling in DotNetCliGenerator.GetRootDirectory, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a> (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e11136897bdf26c004076bcbe812bb4ae60f8859">e11136</a> [build] Bump Docfx.App: 2.71.0-&gt;2.71.1 (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7b342f5cfb63c73708f3e69dde33d7430a3c0401">7b342f</a> Add support for wasm/net9.0 (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2447">#2447</a>) (by <a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e170684208103ca5ba4212ad8dc7c2aad5cf02d4">e17068</a> Adjust 'Failed to set up high priority' message (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/0a734a94a13733c2950d7edbac08499c6f2c108a">0a734a</a> feat: set RuntimeHostConfigurationOption on generated project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2453">#2453</a>) (by <a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ae49148a92c358676190772803fe0ed532814ce3">ae4914</a> implement full .NET 9 support (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2456">#2456</a>) (by <a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/40c4142734ce68bdfcbccf7086ed2b724e9428bc">40c414</a> Prepare v0.13.10 changelog (by <a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
</ul>
<h2>Contributors (4)</h2>
<ul>
<li>Adam Sitnik (<a href="https://github.com/adamsitnik"><code>@​adamsitnik</code></a>)</li>
<li>Andrey Akinshin (<a href="https://github.com/AndreyAkinshin"><code>@​AndreyAkinshin</code></a>)</li>
<li>Ankit Jain (<a href="https://github.com/radical"><code>@​radical</code></a>)</li>
<li>workgroupengineering (<a href="https://github.com/workgroupengineering"><code>@​workgroupengineering</code></a>)</li>
</ul>
<p>Thank you very much!</p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/40c4142734ce68bdfcbccf7086ed2b724e9428bc"><code>40c4142</code></a> Prepare v0.13.10 changelog</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/ae49148a92c358676190772803fe0ed532814ce3"><code>ae49148</code></a> implement full .NET 9 support (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2456">#2456</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/0a734a94a13733c2950d7edbac08499c6f2c108a"><code>0a734a9</code></a> feat: set RuntimeHostConfigurationOption on generated project (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2453">#2453</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e170684208103ca5ba4212ad8dc7c2aad5cf02d4"><code>e170684</code></a> Adjust 'Failed to set up high priority' message</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/7b342f5cfb63c73708f3e69dde33d7430a3c0401"><code>7b342f5</code></a> Add support for wasm/net9.0 (<a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2447">#2447</a>)</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/e11136897bdf26c004076bcbe812bb4ae60f8859"><code>e111368</code></a> [build] Bump Docfx.App: 2.71.0-&gt;2.71.1</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/af9c5c6013b4e661cda0ff8fed40a50ae62d5a74"><code>af9c5c6</code></a> Exception handling in DotNetCliGenerator.GetRootDirectory, fix <a href="https://redirect.github.com/dotnet/BenchmarkDotNet/issues/2436">#2436</a></li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/d17c6ad0bd8ac15d83ced0a7522de7dd51526ad4"><code>d17c6ad</code></a> Support Windows 11 23H2 (10.0.22631) in OsBrandStringHelper</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/2e96d29453a804cfc1b92fffeea94c866522167a"><code>2e96d29</code></a> Don't show AssemblyInformationalVersion metadata in BDN BrandVersion</li>
<li><a href="https://github.com/dotnet/BenchmarkDotNet/commit/c27152b9d7b6391501abcf7e8edcb2804999622f"><code>c27152b</code></a> Set next BenchmarkDotNet version: 0.13.10</li>
<li>See full diff in <a href="https://github.com/dotnet/BenchmarkDotNet/compare/v0.13.9...v0.13.10">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=BenchmarkDotNet.Diagnostics.Windows&package-manager=nuget&previous-version=0.13.9&new-version=0.13.10)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
index 4cbab77e1fe24..df76fd4a7b45f 100644
--- a/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
+++ b/csharp/test/Apache.Arrow.Benchmarks/Apache.Arrow.Benchmarks.csproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.13.10" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.9" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.10" />
   </ItemGroup>
 
   <ItemGroup>

From 25c18d8cd6a299f3bb6b72966f2dca357db26399 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 7 Nov 2023 11:00:57 +0900
Subject: [PATCH 698/749] MINOR: [JS] Bump eslint from 8.42.0 to 8.52.0 in /js
 (#38545)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [eslint](https://github.com/eslint/eslint) from 8.42.0 to 8.52.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/eslint/eslint/releases">eslint's releases</a>.</em></p>
<blockquote>
<h2>v8.52.0</h2>
<h2>Features</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/70648ee49c07f7b533d09f6bf8a5291e5a5a8601"><code>70648ee</code></a> feat: report-unused-disable-directive to report unused eslint-enable (<a href="https://redirect.github.com/eslint/eslint/issues/17611">#17611</a>) (Yosuke Ota)</li>
</ul>
<h2>Bug Fixes</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/5de9637fc925729a83d5a5e9e868a41792a184e3"><code>5de9637</code></a> fix: Ensure shared references in rule configs are separated (<a href="https://redirect.github.com/eslint/eslint/issues/17666">#17666</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/dcfe5739c374c9d7ed21f14027870ec0fd453661"><code>dcfe573</code></a> fix: add preceding semicolon in suggestions of <code>no-object-constructor</code> (<a href="https://redirect.github.com/eslint/eslint/issues/17649">#17649</a>) (Francesco Trotta)</li>
</ul>
<h2>Documentation</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/476d58a584d5d2db003c4c22ffee90e63566164d"><code>476d58a</code></a> docs: Add note about invalid CLI flags when using flat config. (<a href="https://redirect.github.com/eslint/eslint/issues/17664">#17664</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/660ed3afd128ad529234a855345629982caf1bc7"><code>660ed3a</code></a> docs: Plugin flat config migration guide (<a href="https://redirect.github.com/eslint/eslint/issues/17640">#17640</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/a58aa200fccedae7e2e9b6129246f2cedab14f8d"><code>a58aa20</code></a> docs: fix examples for several rules (<a href="https://redirect.github.com/eslint/eslint/issues/17645">#17645</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/179929bd46892f18f2aef0c159d5cc361cb69987"><code>179929b</code></a> docs: Remove trailing newline from the code of Playground links (<a href="https://redirect.github.com/eslint/eslint/issues/17641">#17641</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/f8e5c30636450d4a8baf51f0e227685e6d77ac64"><code>f8e5c30</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/b7ef2f34fe12b68a366e1b4bf5f64d7332c6e72e"><code>b7ef2f3</code></a> docs: Enable pretty code formatter output (<a href="https://redirect.github.com/eslint/eslint/issues/17635">#17635</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/0bcb9a8db608a3d0bd2645f99e0707b9a9bbaaf0"><code>0bcb9a8</code></a> docs: Fix syntax errors in rule examples (<a href="https://redirect.github.com/eslint/eslint/issues/17633">#17633</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/61b90839633ef300ac7707a651f65f532e65f42d"><code>61b9083</code></a> docs: Make no-continue example code work (<a href="https://redirect.github.com/eslint/eslint/issues/17643">#17643</a>) (Zhongyuan Zhou)</li>
<li><a href="https://github.com/eslint/eslint/commit/9fafe450c31ed9b6bdd9dcd6c115255943b8c1c2"><code>9fafe45</code></a> docs: upgrade to 11ty 2.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17632">#17632</a>) (Percy Ma)</li>
<li><a href="https://github.com/eslint/eslint/commit/ff8e4bf327b5c92b0623b0fc5f8f101954f785db"><code>ff8e4bf</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/fab249ae6addac2ee18cd81cee80916010bb469e"><code>fab249a</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/392305bf4797e3ebc696dfca48bd874741fca845"><code>392305b</code></a> docs: Update <code>no-irregular-whitespace</code> and fix examples (<a href="https://redirect.github.com/eslint/eslint/issues/17626">#17626</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/6b8acfb770589f3941df41c3910d3b8ffc3e1e45"><code>6b8acfb</code></a> docs: Add real whitespace to <code>no-trailing-spaces</code> examples (<a href="https://redirect.github.com/eslint/eslint/issues/17630">#17630</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/1000187e00949332babcee4d37d46c96a6a554a8"><code>1000187</code></a> docs: Fix examples in <code>unicode-bom</code> (<a href="https://redirect.github.com/eslint/eslint/issues/17631">#17631</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/000290c4c923cc1473e21b4bdbdc0c42765ef7dd"><code>000290c</code></a> docs: Update README (GitHub Actions Bot)</li>
</ul>
<h2>Chores</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/6d1f0c2da0309c06c21149b8d71a8f439a70d7e8"><code>6d1f0c2</code></a> chore: upgrade <code>@​eslint/js</code><a href="https://github.com/8"><code>@​8</code></a>.52.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17671">#17671</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/d63d4fe0942e6747ab60e758aa36076f43041a30"><code>d63d4fe</code></a> chore: package.json update for <code>@​eslint/js</code> release (ESLint Jenkins)</li>
<li><a href="https://github.com/eslint/eslint/commit/f30cefee6bda2789ede18e1664b84c2638ea1bb5"><code>f30cefe</code></a> test: fix FlatESLint tests for caching (<a href="https://redirect.github.com/eslint/eslint/issues/17658">#17658</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/ef650cb612510bcfa1379c1f0af56dd563b3a705"><code>ef650cb</code></a> test: update tests for no-promise-executor-return (<a href="https://redirect.github.com/eslint/eslint/issues/17661">#17661</a>) (Milos Djermanovic)</li>
</ul>
<h2>v8.51.0</h2>
<h2>Features</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/0a9c43339a4adef24ef83034d0b078dd279cc977"><code>0a9c433</code></a> feat: Add <code>--no-warn-ignored</code> CLI option for flat config (<a href="https://redirect.github.com/eslint/eslint/issues/17569">#17569</a>) (Domantas Petrauskas)</li>
<li><a href="https://github.com/eslint/eslint/commit/977e67ec274a05cb7391665b5e3453e7f72f72b2"><code>977e67e</code></a> feat: logical-assignment-operators to report expressions with 3 operands (<a href="https://redirect.github.com/eslint/eslint/issues/17600">#17600</a>) (Yosuke Ota)</li>
</ul>
<h2>Bug Fixes</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/f976b2f7bfe7cc78bb649f8b37e90fd519ff3bcc"><code>f976b2f</code></a> fix: make rule severity case-sensitive in flat config (<a href="https://redirect.github.com/eslint/eslint/issues/17619">#17619</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/0edfe369aa5bd80a98053022bb4c6b1ea0155f44"><code>0edfe36</code></a> fix: Ensure crash error messages are not duplicated (<a href="https://redirect.github.com/eslint/eslint/issues/17584">#17584</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/dd79abc0c1857b1d765acc312c0d6518e40d31c9"><code>dd79abc</code></a> fix: <code>eslint-disable</code> to be able to parse quoted rule names (<a href="https://redirect.github.com/eslint/eslint/issues/17612">#17612</a>) (Yosuke Ota)</li>
<li><a href="https://github.com/eslint/eslint/commit/d2f68019b8882278877801c5ef2f74d55e2a10c1"><code>d2f6801</code></a> fix: Ensure correct code path for &amp;&amp; followed by ?? (<a href="https://redirect.github.com/eslint/eslint/issues/17618">#17618</a>) (Nicholas C. Zakas)</li>
</ul>
<h2>Documentation</h2>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/ee5be81fa3c4fe801c2f653854f098ed6a84dcef"><code>ee5be81</code></a> docs: default to <code>sourceType: &quot;module&quot;</code> in rule examples (<a href="https://redirect.github.com/eslint/eslint/issues/17615">#17615</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/1aa26df9fbcfdf5b895743c6d2d3a216479544b1"><code>1aa26df</code></a> docs: Add more examples for multiline-ternary (<a href="https://redirect.github.com/eslint/eslint/issues/17610">#17610</a>) (George Ashiotis)</li>
<li><a href="https://github.com/eslint/eslint/commit/47d0b446964f44d70b9457ecc368e721e1dc7c11"><code>47d0b44</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/dbf831e31f8eea0bc94df96cd33255579324b66e"><code>dbf831e</code></a> docs: use generated og image (<a href="https://redirect.github.com/eslint/eslint/issues/17601">#17601</a>) (Percy Ma)</li>
<li><a href="https://github.com/eslint/eslint/commit/1866da5e1d931787256ecb825a803cac5835b71c"><code>1866da5</code></a> docs: Update README (GitHub Actions Bot)</li>
</ul>
<h2>Chores</h2>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/eslint/eslint/blob/main/CHANGELOG.md">eslint's changelog</a>.</em></p>
<blockquote>
<p>v8.52.0 - October 20, 2023</p>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/6d1f0c2da0309c06c21149b8d71a8f439a70d7e8"><code>6d1f0c2</code></a> chore: upgrade <code>@​eslint/js</code><a href="https://github.com/8"><code>@​8</code></a>.52.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17671">#17671</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/d63d4fe0942e6747ab60e758aa36076f43041a30"><code>d63d4fe</code></a> chore: package.json update for <code>@​eslint/js</code> release (ESLint Jenkins)</li>
<li><a href="https://github.com/eslint/eslint/commit/476d58a584d5d2db003c4c22ffee90e63566164d"><code>476d58a</code></a> docs: Add note about invalid CLI flags when using flat config. (<a href="https://redirect.github.com/eslint/eslint/issues/17664">#17664</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/5de9637fc925729a83d5a5e9e868a41792a184e3"><code>5de9637</code></a> fix: Ensure shared references in rule configs are separated (<a href="https://redirect.github.com/eslint/eslint/issues/17666">#17666</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/f30cefee6bda2789ede18e1664b84c2638ea1bb5"><code>f30cefe</code></a> test: fix FlatESLint tests for caching (<a href="https://redirect.github.com/eslint/eslint/issues/17658">#17658</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/ef650cb612510bcfa1379c1f0af56dd563b3a705"><code>ef650cb</code></a> test: update tests for no-promise-executor-return (<a href="https://redirect.github.com/eslint/eslint/issues/17661">#17661</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/70648ee49c07f7b533d09f6bf8a5291e5a5a8601"><code>70648ee</code></a> feat: report-unused-disable-directive to report unused eslint-enable (<a href="https://redirect.github.com/eslint/eslint/issues/17611">#17611</a>) (Yosuke Ota)</li>
<li><a href="https://github.com/eslint/eslint/commit/dcfe5739c374c9d7ed21f14027870ec0fd453661"><code>dcfe573</code></a> fix: add preceding semicolon in suggestions of <code>no-object-constructor</code> (<a href="https://redirect.github.com/eslint/eslint/issues/17649">#17649</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/660ed3afd128ad529234a855345629982caf1bc7"><code>660ed3a</code></a> docs: Plugin flat config migration guide (<a href="https://redirect.github.com/eslint/eslint/issues/17640">#17640</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/a58aa200fccedae7e2e9b6129246f2cedab14f8d"><code>a58aa20</code></a> docs: fix examples for several rules (<a href="https://redirect.github.com/eslint/eslint/issues/17645">#17645</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/179929bd46892f18f2aef0c159d5cc361cb69987"><code>179929b</code></a> docs: Remove trailing newline from the code of Playground links (<a href="https://redirect.github.com/eslint/eslint/issues/17641">#17641</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/f8e5c30636450d4a8baf51f0e227685e6d77ac64"><code>f8e5c30</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/b7ef2f34fe12b68a366e1b4bf5f64d7332c6e72e"><code>b7ef2f3</code></a> docs: Enable pretty code formatter output (<a href="https://redirect.github.com/eslint/eslint/issues/17635">#17635</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/0bcb9a8db608a3d0bd2645f99e0707b9a9bbaaf0"><code>0bcb9a8</code></a> docs: Fix syntax errors in rule examples (<a href="https://redirect.github.com/eslint/eslint/issues/17633">#17633</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/61b90839633ef300ac7707a651f65f532e65f42d"><code>61b9083</code></a> docs: Make no-continue example code work (<a href="https://redirect.github.com/eslint/eslint/issues/17643">#17643</a>) (Zhongyuan Zhou)</li>
<li><a href="https://github.com/eslint/eslint/commit/9fafe450c31ed9b6bdd9dcd6c115255943b8c1c2"><code>9fafe45</code></a> docs: upgrade to 11ty 2.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17632">#17632</a>) (Percy Ma)</li>
<li><a href="https://github.com/eslint/eslint/commit/ff8e4bf327b5c92b0623b0fc5f8f101954f785db"><code>ff8e4bf</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/fab249ae6addac2ee18cd81cee80916010bb469e"><code>fab249a</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/392305bf4797e3ebc696dfca48bd874741fca845"><code>392305b</code></a> docs: Update <code>no-irregular-whitespace</code> and fix examples (<a href="https://redirect.github.com/eslint/eslint/issues/17626">#17626</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/6b8acfb770589f3941df41c3910d3b8ffc3e1e45"><code>6b8acfb</code></a> docs: Add real whitespace to <code>no-trailing-spaces</code> examples (<a href="https://redirect.github.com/eslint/eslint/issues/17630">#17630</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/1000187e00949332babcee4d37d46c96a6a554a8"><code>1000187</code></a> docs: Fix examples in <code>unicode-bom</code> (<a href="https://redirect.github.com/eslint/eslint/issues/17631">#17631</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/000290c4c923cc1473e21b4bdbdc0c42765ef7dd"><code>000290c</code></a> docs: Update README (GitHub Actions Bot)</li>
</ul>
<p>v8.51.0 - October 6, 2023</p>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/1ef39ea5b884453be717ebc929155d7eb584dcbf"><code>1ef39ea</code></a> chore: upgrade <code>@​eslint/js</code><a href="https://github.com/8"><code>@​8</code></a>.51.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17624">#17624</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/f8c7403255c11e99c402860aef3c0179f2b16628"><code>f8c7403</code></a> chore: package.json update for <code>@​eslint/js</code> release (ESLint Jenkins)</li>
<li><a href="https://github.com/eslint/eslint/commit/f976b2f7bfe7cc78bb649f8b37e90fd519ff3bcc"><code>f976b2f</code></a> fix: make rule severity case-sensitive in flat config (<a href="https://redirect.github.com/eslint/eslint/issues/17619">#17619</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/0edfe369aa5bd80a98053022bb4c6b1ea0155f44"><code>0edfe36</code></a> fix: Ensure crash error messages are not duplicated (<a href="https://redirect.github.com/eslint/eslint/issues/17584">#17584</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/ee5be81fa3c4fe801c2f653854f098ed6a84dcef"><code>ee5be81</code></a> docs: default to <code>sourceType: &quot;module&quot;</code> in rule examples (<a href="https://redirect.github.com/eslint/eslint/issues/17615">#17615</a>) (Francesco Trotta)</li>
<li><a href="https://github.com/eslint/eslint/commit/dd79abc0c1857b1d765acc312c0d6518e40d31c9"><code>dd79abc</code></a> fix: <code>eslint-disable</code> to be able to parse quoted rule names (<a href="https://redirect.github.com/eslint/eslint/issues/17612">#17612</a>) (Yosuke Ota)</li>
<li><a href="https://github.com/eslint/eslint/commit/d2f68019b8882278877801c5ef2f74d55e2a10c1"><code>d2f6801</code></a> fix: Ensure correct code path for &amp;&amp; followed by ?? (<a href="https://redirect.github.com/eslint/eslint/issues/17618">#17618</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/2665552ba0057e8603f9fbece0fd236f189f5cf3"><code>2665552</code></a> test: fix flat config linter tests to use Linter in flat config mode (<a href="https://redirect.github.com/eslint/eslint/issues/17616">#17616</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/1aa26df9fbcfdf5b895743c6d2d3a216479544b1"><code>1aa26df</code></a> docs: Add more examples for multiline-ternary (<a href="https://redirect.github.com/eslint/eslint/issues/17610">#17610</a>) (George Ashiotis)</li>
<li><a href="https://github.com/eslint/eslint/commit/47d0b446964f44d70b9457ecc368e721e1dc7c11"><code>47d0b44</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/dbf831e31f8eea0bc94df96cd33255579324b66e"><code>dbf831e</code></a> docs: use generated og image (<a href="https://redirect.github.com/eslint/eslint/issues/17601">#17601</a>) (Percy Ma)</li>
<li><a href="https://github.com/eslint/eslint/commit/0a9c43339a4adef24ef83034d0b078dd279cc977"><code>0a9c433</code></a> feat: Add <code>--no-warn-ignored</code> CLI option for flat config (<a href="https://redirect.github.com/eslint/eslint/issues/17569">#17569</a>) (Domantas Petrauskas)</li>
<li><a href="https://github.com/eslint/eslint/commit/1866da5e1d931787256ecb825a803cac5835b71c"><code>1866da5</code></a> docs: Update README (GitHub Actions Bot)</li>
<li><a href="https://github.com/eslint/eslint/commit/7b77bccbb51bd36b2d20fea61bc782545c4029b3"><code>7b77bcc</code></a> chore: Refactor CodePathState (<a href="https://redirect.github.com/eslint/eslint/issues/17510">#17510</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/977e67ec274a05cb7391665b5e3453e7f72f72b2"><code>977e67e</code></a> feat: logical-assignment-operators to report expressions with 3 operands (<a href="https://redirect.github.com/eslint/eslint/issues/17600">#17600</a>) (Yosuke Ota)</li>
<li><a href="https://github.com/eslint/eslint/commit/bc77c9af12539f350ef19e30611a153a5b869c6b"><code>bc77c9a</code></a> chore: Document and refactor ForkContext (<a href="https://redirect.github.com/eslint/eslint/issues/17566">#17566</a>) (Nicholas C. Zakas)</li>
<li><a href="https://github.com/eslint/eslint/commit/24e1f140ec68659e55c1ace0d7500addb135a2b4"><code>24e1f14</code></a> chore: Refactor and document CodePath (<a href="https://redirect.github.com/eslint/eslint/issues/17558">#17558</a>) (Nicholas C. Zakas)</li>
</ul>
<p>v8.50.0 - September 22, 2023</p>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/f8a8a2d6b45c82f94a574623759b6e3d2af193f3"><code>f8a8a2d</code></a> chore: upgrade <code>@​eslint/js</code><a href="https://github.com/8"><code>@​8</code></a>.50.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17599">#17599</a>) (Milos Djermanovic)</li>
<li><a href="https://github.com/eslint/eslint/commit/38ada6df8f4a0313b7d0739b28f0af6b4897b8ce"><code>38ada6d</code></a> chore: package.json update for <code>@​eslint/js</code> release (ESLint Jenkins)</li>
<li><a href="https://github.com/eslint/eslint/commit/27d5a9e57ad347982a68fcd0e75eafee42d344f0"><code>27d5a9e</code></a> feat: add suggestions to array-callback-return (<a href="https://redirect.github.com/eslint/eslint/issues/17590">#17590</a>) (Tanuj Kanti)</li>
</ul>

</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/eslint/eslint/commit/331cf62024b6c7ad4067c14c593f116576c3c861"><code>331cf62</code></a> 8.52.0</li>
<li><a href="https://github.com/eslint/eslint/commit/7dc28ed1615169c68c08808fa445172cc0cf37e0"><code>7dc28ed</code></a> Build: changelog update for 8.52.0</li>
<li><a href="https://github.com/eslint/eslint/commit/6d1f0c2da0309c06c21149b8d71a8f439a70d7e8"><code>6d1f0c2</code></a> chore: upgrade <code>@​eslint/js</code><a href="https://github.com/8"><code>@​8</code></a>.52.0 (<a href="https://redirect.github.com/eslint/eslint/issues/17671">#17671</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/d63d4fe0942e6747ab60e758aa36076f43041a30"><code>d63d4fe</code></a> chore: package.json update for <code>@​eslint/js</code> release</li>
<li><a href="https://github.com/eslint/eslint/commit/476d58a584d5d2db003c4c22ffee90e63566164d"><code>476d58a</code></a> docs: Add note about invalid CLI flags when using flat config. (<a href="https://redirect.github.com/eslint/eslint/issues/17664">#17664</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/5de9637fc925729a83d5a5e9e868a41792a184e3"><code>5de9637</code></a> fix: Ensure shared references in rule configs are separated (<a href="https://redirect.github.com/eslint/eslint/issues/17666">#17666</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/f30cefee6bda2789ede18e1664b84c2638ea1bb5"><code>f30cefe</code></a> test: fix FlatESLint tests for caching (<a href="https://redirect.github.com/eslint/eslint/issues/17658">#17658</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/ef650cb612510bcfa1379c1f0af56dd563b3a705"><code>ef650cb</code></a> test: update tests for no-promise-executor-return (<a href="https://redirect.github.com/eslint/eslint/issues/17661">#17661</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/70648ee49c07f7b533d09f6bf8a5291e5a5a8601"><code>70648ee</code></a> feat: report-unused-disable-directive to report unused eslint-enable (<a href="https://redirect.github.com/eslint/eslint/issues/17611">#17611</a>)</li>
<li><a href="https://github.com/eslint/eslint/commit/dcfe5739c374c9d7ed21f14027870ec0fd453661"><code>dcfe573</code></a> fix: add preceding semicolon in suggestions of <code>no-object-constructor</code> (<a href="https://redirect.github.com/eslint/eslint/issues/17649">#17649</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/eslint/eslint/compare/v8.42.0...v8.52.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=eslint&package-manager=npm_and_yarn&previous-version=8.42.0&new-version=8.52.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/package.json |  2 +-
 js/yarn.lock    | 92 ++++++++++++++++++++++++++-----------------------
 2 files changed, 49 insertions(+), 45 deletions(-)

diff --git a/js/package.json b/js/package.json
index cca333ad3d006..33bc4849903ef 100644
--- a/js/package.json
+++ b/js/package.json
@@ -83,7 +83,7 @@
     "del-cli": "5.1.0",
     "esbuild": "0.19.2",
     "esbuild-plugin-alias": "0.2.1",
-    "eslint": "8.42.0",
+    "eslint": "8.52.0",
     "eslint-plugin-jest": "27.4.2",
     "eslint-plugin-unicorn": "47.0.0",
     "esm": "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz",
diff --git a/js/yarn.lock b/js/yarn.lock
index 26a459a73a206..eddf380d1ffad 100644
--- a/js/yarn.lock
+++ b/js/yarn.lock
@@ -626,14 +626,14 @@
   dependencies:
     eslint-visitor-keys "^3.3.0"
 
-"@eslint-community/regexpp@^4.4.0":
-  version "4.8.1"
-  resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.8.1.tgz#8c4bb756cc2aa7eaf13cfa5e69c83afb3260c20c"
-  integrity sha512-PWiOzLIUAjN/w5K17PoF4n6sKBw0gqLHPhywmYHP4t1VFQQVYeb1yWsJwnMVEMl3tUHME7X/SJPZLmtG7XBDxQ==
+"@eslint-community/regexpp@^4.4.0", "@eslint-community/regexpp@^4.6.1":
+  version "4.10.0"
+  resolved "https://registry.yarnpkg.com/@eslint-community/regexpp/-/regexpp-4.10.0.tgz#548f6de556857c8bb73bbee70c35dc82a2e74d63"
+  integrity sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==
 
-"@eslint/eslintrc@^2.0.3":
+"@eslint/eslintrc@^2.1.2":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.2.tgz#c6936b4b328c64496692f76944e755738be62396"
+  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-2.1.2.tgz#c6936b4b328c64496692f76944e755738be62396"
   integrity sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==
   dependencies:
     ajv "^6.12.4"
@@ -646,10 +646,10 @@
     minimatch "^3.1.2"
     strip-json-comments "^3.1.1"
 
-"@eslint/js@8.42.0":
-  version "8.42.0"
-  resolved "https://registry.npmjs.org/@eslint/js/-/js-8.42.0.tgz#484a1d638de2911e6f5a30c12f49c7e4a3270fb6"
-  integrity sha512-6SWlXpWU5AvId8Ac7zjzmIOqMOba/JWY8XZ4A7q7Gn1Vlfg/SFFIlrtHXt9nPn4op9ZPAkl91Jao+QQv3r/ukw==
+"@eslint/js@8.52.0":
+  version "8.52.0"
+  resolved "https://registry.yarnpkg.com/@eslint/js/-/js-8.52.0.tgz#78fe5f117840f69dc4a353adf9b9cd926353378c"
+  integrity sha512-mjZVbpaeMZludF2fsWLD0Z9gCref1Tk4i9+wddjRvpUNqqcndPkBD09N/Mapey0b3jaXbLm2kICwFv2E64QinA==
 
 "@gulp-sourcemaps/identity-map@^2.0.1":
   version "2.0.1"
@@ -670,12 +670,12 @@
     normalize-path "^2.0.1"
     through2 "^2.0.3"
 
-"@humanwhocodes/config-array@^0.11.10":
-  version "0.11.11"
-  resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.11.tgz#88a04c570dbbc7dd943e4712429c3df09bc32844"
-  integrity sha512-N2brEuAadi0CcdeMXUkhbZB84eskAc8MEX1By6qEchoVywSgXPIjou4rYsl0V3Hj0ZnuGycGCjdNgockbzeWNA==
+"@humanwhocodes/config-array@^0.11.13":
+  version "0.11.13"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.11.13.tgz#075dc9684f40a531d9b26b0822153c1e832ee297"
+  integrity sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==
   dependencies:
-    "@humanwhocodes/object-schema" "^1.2.1"
+    "@humanwhocodes/object-schema" "^2.0.1"
     debug "^4.1.1"
     minimatch "^3.0.5"
 
@@ -684,10 +684,10 @@
   resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz#af5b2691a22b44be847b0ca81641c5fb6ad0172c"
   integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==
 
-"@humanwhocodes/object-schema@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
-  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
+"@humanwhocodes/object-schema@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-2.0.1.tgz#e5211452df060fa8522b55c7b3c0c4d1981cb044"
+  integrity sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==
 
 "@isaacs/cliui@^8.0.2":
   version "8.0.2"
@@ -1548,6 +1548,11 @@
     "@typescript-eslint/types" "5.62.0"
     eslint-visitor-keys "^3.3.0"
 
+"@ungap/structured-clone@^1.2.0":
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/@ungap/structured-clone/-/structured-clone-1.2.0.tgz#756641adb587851b5ccb3e095daf27ae581c8406"
+  integrity sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==
+
 "@webassemblyjs/ast@1.11.6", "@webassemblyjs/ast@^1.11.5":
   version "1.11.6"
   resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24"
@@ -1717,7 +1722,7 @@ ajv-keywords@^3.5.2:
   resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
   integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
-ajv@^6.10.0, ajv@^6.12.4, ajv@^6.12.5:
+ajv@^6.12.4, ajv@^6.12.5:
   version "6.12.6"
   resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -3030,40 +3035,41 @@ eslint-scope@5.1.1, eslint-scope@^5.1.1:
     esrecurse "^4.3.0"
     estraverse "^4.1.1"
 
-eslint-scope@^7.2.0:
+eslint-scope@^7.2.2:
   version "7.2.2"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.2.2.tgz#deb4f92563390f32006894af62a22dba1c46423f"
   integrity sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^5.2.0"
 
-eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1:
+eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.1, eslint-visitor-keys@^3.4.3:
   version "3.4.3"
   resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz#0cd72fe8550e3c2eae156a96a4dddcd1c8ac5800"
   integrity sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==
 
-eslint@8.42.0:
-  version "8.42.0"
-  resolved "https://registry.npmjs.org/eslint/-/eslint-8.42.0.tgz#7bebdc3a55f9ed7167251fe7259f75219cade291"
-  integrity sha512-ulg9Ms6E1WPf67PHaEY4/6E2tEn5/f7FXGzr3t9cBMugOmf1INYvuUwwh1aXQN4MfJ6a5K2iNwP3w4AColvI9A==
+eslint@8.52.0:
+  version "8.52.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.52.0.tgz#d0cd4a1fac06427a61ef9242b9353f36ea7062fc"
+  integrity sha512-zh/JHnaixqHZsolRB/w9/02akBk9EPrOs9JwcTP2ek7yL5bVvXuRariiaAjjoJ5DvuwQ1WAE/HsMz+w17YgBCg==
   dependencies:
     "@eslint-community/eslint-utils" "^4.2.0"
-    "@eslint-community/regexpp" "^4.4.0"
-    "@eslint/eslintrc" "^2.0.3"
-    "@eslint/js" "8.42.0"
-    "@humanwhocodes/config-array" "^0.11.10"
+    "@eslint-community/regexpp" "^4.6.1"
+    "@eslint/eslintrc" "^2.1.2"
+    "@eslint/js" "8.52.0"
+    "@humanwhocodes/config-array" "^0.11.13"
     "@humanwhocodes/module-importer" "^1.0.1"
     "@nodelib/fs.walk" "^1.2.8"
-    ajv "^6.10.0"
+    "@ungap/structured-clone" "^1.2.0"
+    ajv "^6.12.4"
     chalk "^4.0.0"
     cross-spawn "^7.0.2"
     debug "^4.3.2"
     doctrine "^3.0.0"
     escape-string-regexp "^4.0.0"
-    eslint-scope "^7.2.0"
-    eslint-visitor-keys "^3.4.1"
-    espree "^9.5.2"
+    eslint-scope "^7.2.2"
+    eslint-visitor-keys "^3.4.3"
+    espree "^9.6.1"
     esquery "^1.4.2"
     esutils "^2.0.2"
     fast-deep-equal "^3.1.3"
@@ -3073,7 +3079,6 @@ eslint@8.42.0:
     globals "^13.19.0"
     graphemer "^1.4.0"
     ignore "^5.2.0"
-    import-fresh "^3.0.0"
     imurmurhash "^0.1.4"
     is-glob "^4.0.0"
     is-path-inside "^3.0.3"
@@ -3083,18 +3088,17 @@ eslint@8.42.0:
     lodash.merge "^4.6.2"
     minimatch "^3.1.2"
     natural-compare "^1.4.0"
-    optionator "^0.9.1"
+    optionator "^0.9.3"
     strip-ansi "^6.0.1"
-    strip-json-comments "^3.1.0"
     text-table "^0.2.0"
 
 "esm@https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz":
   version "3.2.25"
   resolved "https://github.com/jsg2021/esm/releases/download/v3.x.x-pr883/esm-3.x.x-pr883.tgz#c463cfa4e14aceea6b7cd7e669ef90de072ea60a"
 
-espree@^9.5.2, espree@^9.6.0:
+espree@^9.6.0, espree@^9.6.1:
   version "9.6.1"
-  resolved "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-9.6.1.tgz#a2a17b8e434690a5432f2f8018ce71d331a48c6f"
   integrity sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==
   dependencies:
     acorn "^8.9.0"
@@ -3987,7 +3991,7 @@ ignore@^5.2.0, ignore@^5.2.4:
   resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz#a291c0c6178ff1b960befe47fcdec301674a6324"
   integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==
 
-import-fresh@^3.0.0, import-fresh@^3.2.1:
+import-fresh@^3.2.1:
   version "3.3.0"
   resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
   integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
@@ -5570,9 +5574,9 @@ opener@^1.5.2:
   resolved "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
-optionator@^0.9.1:
+optionator@^0.9.3:
   version "0.9.3"
-  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz#007397d44ed1872fdc6ed31360190f81814e2c64"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.3.tgz#007397d44ed1872fdc6ed31360190f81814e2c64"
   integrity sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==
   dependencies:
     "@aashutoshrathi/word-wrap" "^1.2.3"
@@ -6679,7 +6683,7 @@ strip-indent@^4.0.0:
   dependencies:
     min-indent "^1.0.1"
 
-strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
+strip-json-comments@^3.1.1:
   version "3.1.1"
   resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==

From fafd48c3196b4e6af0c09f633c6a3440419bf1f0 Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Tue, 7 Nov 2023 08:40:38 -0800
Subject: [PATCH 699/749] GH-38576: [Java] Change JDBC driver to optionally
 preserve cookies and auth tokens when getting streams (#38580)

### Rationale for this change
This change restores the original behavior of transmitting existing cookies and auth tokens when getting separate
streams returned by getFlightInfo after adding support for multiple endpoints.

These properties are now optional though.

### What changes are included in this PR?
- Change the JDBC driver to add new properties "retainCookies" and "retainAuth"
- These properties allow internally spawned connections for getting streams to use the cookies and bearer tokens from the original connection.
- Add tests for validating defaults from ArrowFlightSqlClient.Builder

### Are these changes tested?
Unit tests have been added.

### Are there any user-facing changes?
Yes. There are now properties and they are documented.
* Closes: #38576

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 docs/source/java/flight_sql_jdbc_driver.rst   |  11 ++
 .../ClientIncomingAuthHeaderMiddleware.java   |   2 +-
 .../driver/jdbc/ArrowFlightConnection.java    |   2 +
 .../client/ArrowFlightSqlClientHandler.java   | 117 +++++++++++---
 .../ArrowFlightConnectionConfigImpl.java      |  20 ++-
 .../driver/jdbc/ConnectionMutualTlsTest.java  |  56 ++++---
 .../arrow/driver/jdbc/ConnectionTest.java     | 123 ++++++++-------
 .../jdbc/ConnectionTlsRootCertsTest.java      |  68 +++++----
 .../arrow/driver/jdbc/ConnectionTlsTest.java  |  56 +++----
 .../driver/jdbc/FlightServerTestRule.java     |   5 +-
 .../arrow/driver/jdbc/ResultSetTest.java      |  15 +-
 ...rrowFlightSqlClientHandlerBuilderTest.java | 143 ++++++++++++++++++
 12 files changed, 448 insertions(+), 170 deletions(-)
 create mode 100644 java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandlerBuilderTest.java

diff --git a/docs/source/java/flight_sql_jdbc_driver.rst b/docs/source/java/flight_sql_jdbc_driver.rst
index 34ccfea47f9e3..0ace2185983a9 100644
--- a/docs/source/java/flight_sql_jdbc_driver.rst
+++ b/docs/source/java/flight_sql_jdbc_driver.rst
@@ -141,6 +141,17 @@ case-sensitive. The supported parameters are:
      - true
      - When TLS is enabled, whether to use the system certificate store
 
+   * - retainCookies
+     - true
+     - Whether to use cookies from the initial connection in subsequent
+       internal connections when retrieving streams from separate endpoints.
+
+   * - retainAuth
+     - true
+     - Whether to use bearer tokens obtained from the initial connection
+       in subsequent internal connections used for retrieving streams
+       from separate endpoints.
+
 Note that URI values must be URI-encoded if they contain characters such
 as !, @, $, etc.
 
diff --git a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth2/ClientIncomingAuthHeaderMiddleware.java b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth2/ClientIncomingAuthHeaderMiddleware.java
index be5f3f54d326c..7bb55d145d104 100644
--- a/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth2/ClientIncomingAuthHeaderMiddleware.java
+++ b/java/flight/flight-core/src/main/java/org/apache/arrow/flight/auth2/ClientIncomingAuthHeaderMiddleware.java
@@ -34,7 +34,7 @@ public class ClientIncomingAuthHeaderMiddleware implements FlightClientMiddlewar
    */
   public static class Factory implements FlightClientMiddleware.Factory {
     private final ClientHeaderHandler headerHandler;
-    private CredentialCallOption credentialCallOption;
+    private CredentialCallOption credentialCallOption = null;
 
     /**
      * Construct a factory with the given header handler.
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
index fdbb9381c0a55..ad19c616ff29a 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowFlightConnection.java
@@ -109,6 +109,8 @@ private static ArrowFlightSqlClientHandler createNewClientHandler(
           .withDisableCertificateVerification(config.getDisableCertificateVerification())
           .withToken(config.getToken())
           .withCallOptions(config.toCallOption())
+          .withRetainCookies(config.retainCookies())
+          .withRetainAuth(config.retainAuth())
           .build();
     } catch (final SQLException e) {
       try {
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
index 75e80d45dc669..54fd17853c00b 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandler.java
@@ -49,6 +49,7 @@
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.util.AutoCloseables;
 import org.apache.arrow.util.Preconditions;
+import org.apache.arrow.util.VisibleForTesting;
 import org.apache.arrow.vector.VectorSchemaRoot;
 import org.apache.arrow.vector.types.pojo.Schema;
 import org.apache.calcite.avatica.Meta.StatementType;
@@ -425,21 +426,59 @@ public static final class Builder {
     private final Set<CallOption> options = new HashSet<>();
     private String host;
     private int port;
-    private String username;
-    private String password;
-    private String trustStorePath;
-    private String trustStorePassword;
-    private String token;
-    private boolean useEncryption;
-    private boolean disableCertificateVerification;
-    private boolean useSystemTrustStore;
-    private String tlsRootCertificatesPath;
-    private String clientCertificatePath;
-    private String clientKeyPath;
+
+    @VisibleForTesting
+    String username;
+
+    @VisibleForTesting
+    String password;
+
+    @VisibleForTesting
+    String trustStorePath;
+
+    @VisibleForTesting
+    String trustStorePassword;
+
+    @VisibleForTesting
+    String token;
+
+    @VisibleForTesting
+    boolean useEncryption = true;
+
+    @VisibleForTesting
+    boolean disableCertificateVerification;
+
+    @VisibleForTesting
+    boolean useSystemTrustStore = true;
+
+    @VisibleForTesting
+    String tlsRootCertificatesPath;
+
+    @VisibleForTesting
+    String clientCertificatePath;
+
+    @VisibleForTesting
+    String clientKeyPath;
+
+    @VisibleForTesting
     private BufferAllocator allocator;
 
-    public Builder() {
+    @VisibleForTesting
+    boolean retainCookies = true;
+
+    @VisibleForTesting
+    boolean retainAuth = true;
+
+    // These two middlewares are for internal use within build() and should not be exposed by builder APIs.
+    // Note that these middlewares may not necessarily be registered.
+    @VisibleForTesting
+    ClientIncomingAuthHeaderMiddleware.Factory authFactory
+        = new ClientIncomingAuthHeaderMiddleware.Factory(new ClientBearerHeaderHandler());
 
+    @VisibleForTesting
+    ClientCookieMiddleware.Factory cookieFactory = new ClientCookieMiddleware.Factory();
+
+    public Builder() {
     }
 
     /**
@@ -447,7 +486,8 @@ public Builder() {
      *
      * @param original The builder to base this copy off of.
      */
-    private Builder(Builder original) {
+    @VisibleForTesting
+    Builder(Builder original) {
       this.middlewareFactories.addAll(original.middlewareFactories);
       this.options.addAll(original.options);
       this.host = original.host;
@@ -464,6 +504,14 @@ private Builder(Builder original) {
       this.clientCertificatePath = original.clientCertificatePath;
       this.clientKeyPath = original.clientKeyPath;
       this.allocator = original.allocator;
+
+      if (original.retainCookies) {
+        this.cookieFactory = original.cookieFactory;
+      }
+
+      if (original.retainAuth) {
+        this.authFactory = original.authFactory;
+      }
     }
 
     /**
@@ -622,6 +670,28 @@ public Builder withBufferAllocator(final BufferAllocator allocator) {
       return this;
     }
 
+    /**
+     * Indicates if cookies should be re-used by connections spawned for getStreams() calls.
+     * @param retainCookies The flag indicating if cookies should be re-used.
+     * @return      this builder instance.
+     */
+    public Builder withRetainCookies(boolean retainCookies) {
+      this.retainCookies = retainCookies;
+      return this;
+    }
+
+    /**
+     * Indicates if bearer tokens negotiated should be re-used by connections
+     * spawned for getStreams() calls.
+     *
+     * @param retainAuth The flag indicating if auth tokens should be re-used.
+     * @return      this builder instance.
+     */
+    public Builder withRetainAuth(boolean retainAuth) {
+      this.retainAuth = retainAuth;
+      return this;
+    }
+
     /**
      * Adds the provided {@code factories} to the list of {@link #middlewareFactories} of this handler.
      *
@@ -675,13 +745,11 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
       // Copy middlewares so that the build method doesn't change the state of the builder fields itself.
       Set<FlightClientMiddleware.Factory> buildTimeMiddlewareFactories = new HashSet<>(this.middlewareFactories);
       FlightClient client = null;
+      boolean isUsingUserPasswordAuth = username != null && token == null;
 
       try {
-        ClientIncomingAuthHeaderMiddleware.Factory authFactory = null;
         // Token should take priority since some apps pass in a username/password even when a token is provided
-        if (username != null && token == null) {
-          authFactory =
-              new ClientIncomingAuthHeaderMiddleware.Factory(new ClientBearerHeaderHandler());
+        if (isUsingUserPasswordAuth) {
           buildTimeMiddlewareFactories.add(authFactory);
         }
         final FlightClient.Builder clientBuilder = FlightClient.builder().allocator(allocator);
@@ -722,10 +790,17 @@ public ArrowFlightSqlClientHandler build() throws SQLException {
 
         client = clientBuilder.build();
         final ArrayList<CallOption> credentialOptions = new ArrayList<>();
-        if (authFactory != null) {
-          credentialOptions.add(
-              ClientAuthenticationUtils.getAuthenticate(
-                      client, username, password, authFactory, options.toArray(new CallOption[0])));
+        if (isUsingUserPasswordAuth) {
+          // If the authFactory has already been used for a handshake, use the existing token.
+          // This can occur if the authFactory is being re-used for a new connection spawned for getStream().
+          if (authFactory.getCredentialCallOption() != null) {
+            credentialOptions.add(authFactory.getCredentialCallOption());
+          } else {
+            // Otherwise do the handshake and get the token if possible.
+            credentialOptions.add(
+                ClientAuthenticationUtils.getAuthenticate(
+                    client, username, password, authFactory, options.toArray(new CallOption[0])));
+          }
         } else if (token != null) {
           credentialOptions.add(
               ClientAuthenticationUtils.getAuthenticate(
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
index 59118e1d6f788..6237a8b58d68a 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/ArrowFlightConnectionConfigImpl.java
@@ -143,6 +143,22 @@ public int threadPoolSize() {
     return ArrowFlightConnectionProperty.THREAD_POOL_SIZE.getInteger(properties);
   }
 
+  /**
+   * Indicates if sub-connections created for stream retrieval
+   * should reuse cookies from the main connection.
+   */
+  public boolean retainCookies() {
+    return ArrowFlightConnectionProperty.RETAIN_COOKIES.getBoolean(properties);
+  }
+
+  /**
+   * Indicates if sub-connections created for stream retrieval
+   * should reuse bearer tokens created from the main connection.
+   */
+  public boolean retainAuth() {
+    return ArrowFlightConnectionProperty.RETAIN_AUTH.getBoolean(properties);
+  }
+
   /**
    * Gets the {@link CallOption}s from this {@link ConnectionConfig}.
    *
@@ -191,7 +207,9 @@ public enum ArrowFlightConnectionProperty implements ConnectionProperty {
     CLIENT_CERTIFICATE("clientCertificate", null, Type.STRING, false),
     CLIENT_KEY("clientKey", null, Type.STRING, false),
     THREAD_POOL_SIZE("threadPoolSize", 1, Type.NUMBER, false),
-    TOKEN("token", null, Type.STRING, false);
+    TOKEN("token", null, Type.STRING, false),
+    RETAIN_COOKIES("retainCookies", true, Type.BOOLEAN, false),
+    RETAIN_AUTH("retainAuth", true, Type.BOOLEAN, false);
 
     private final String camelName;
     private final Object defaultValue;
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
index 783e0c41e9269..927b3e426c6ba 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionMutualTlsTest.java
@@ -140,17 +140,21 @@ public void testGetEncryptedClientWithBadMTlsCertPath() {
     final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
             userTest, passTest);
 
-    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
-            .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
-            .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
-            .withUsername(credentials.getUserName())
-            .withPassword(credentials.getPassword())
-            .withTlsRootCertificates(tlsRootCertsPath)
-            .withClientCertificate(badClientMTlsCertPath)
-            .withClientKey(clientMTlsKeyPath)
-            .withBufferAllocator(allocator)
-            .withEncryption(true)
-            .build());
+    assertThrows(SQLException.class, () -> {
+      try (ArrowFlightSqlClientHandler handler = new ArrowFlightSqlClientHandler.Builder()
+          .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+          .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+          .withUsername(credentials.getUserName())
+          .withPassword(credentials.getPassword())
+          .withTlsRootCertificates(tlsRootCertsPath)
+          .withClientCertificate(badClientMTlsCertPath)
+          .withClientKey(clientMTlsKeyPath)
+          .withBufferAllocator(allocator)
+          .withEncryption(true)
+          .build()) {
+        Assert.fail();
+      }
+    });
   }
 
   /**
@@ -162,17 +166,21 @@ public void testGetEncryptedClientWithBadMTlsKeyPath() {
     final UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
             userTest, passTest);
 
-    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
-                         .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
-                         .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
-                         .withUsername(credentials.getUserName())
-                         .withPassword(credentials.getPassword())
-                         .withTlsRootCertificates(tlsRootCertsPath)
-                         .withClientCertificate(clientMTlsCertPath)
-                         .withClientKey(badClientMTlsKeyPath)
-                         .withBufferAllocator(allocator)
-                         .withEncryption(true)
-                         .build());
+    assertThrows(SQLException.class, () -> {
+      try (ArrowFlightSqlClientHandler handler = new ArrowFlightSqlClientHandler.Builder()
+          .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+          .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+          .withUsername(credentials.getUserName())
+          .withPassword(credentials.getPassword())
+          .withTlsRootCertificates(tlsRootCertsPath)
+          .withClientCertificate(clientMTlsCertPath)
+          .withClientKey(badClientMTlsKeyPath)
+          .withBufferAllocator(allocator)
+          .withEncryption(true)
+          .build()) {
+        Assert.fail();
+      }
+    });
   }
 
   /**
@@ -222,7 +230,7 @@ public void testGetEncryptedConnectionWithValidCredentialsAndTlsRootsPath() thro
     final ArrowFlightJdbcDataSource dataSource =
         ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -245,7 +253,7 @@ public void testGetNonAuthenticatedEncryptedConnection() throws Exception {
 
     final ArrowFlightJdbcDataSource dataSource = ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
index bec0ff1e59752..357506b3d177c 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTest.java
@@ -20,6 +20,7 @@
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 import java.net.URISyntaxException;
 import java.sql.Connection;
@@ -100,7 +101,7 @@ public void testUnencryptedConnectionShouldOpenSuccessfullyWhenProvidedValidCred
     try (Connection connection = DriverManager.getConnection(
         "jdbc:arrow-flight-sql://" + FLIGHT_SERVER_TEST_RULE.getHost() + ":" +
             FLIGHT_SERVER_TEST_RULE.getPort(), properties)) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -122,11 +123,13 @@ public void testTokenOverridesUsernameAndPasswordAuth() {
     properties.put(ArrowFlightConnectionProperty.TOKEN.camelName(), "token");
     properties.put("useEncryption", false);
 
-    SQLException e = assertThrows(SQLException.class, () ->
-            DriverManager.getConnection(
-                    "jdbc:arrow-flight-sql://" + FLIGHT_SERVER_TEST_RULE.getHost() + ":" +
-                            FLIGHT_SERVER_TEST_RULE.getPort(),
-                    properties));
+    SQLException e = assertThrows(SQLException.class, () -> {
+      try (Connection conn = DriverManager.getConnection(
+          "jdbc:arrow-flight-sql://" + FLIGHT_SERVER_TEST_RULE.getHost() + ":" + FLIGHT_SERVER_TEST_RULE.getPort(),
+          properties)) {
+        Assert.fail();
+      }
+    });
     assertTrue(e.getMessage().contains("UNAUTHENTICATED"));
   }
 
@@ -145,7 +148,9 @@ public void testUnencryptedConnectionWithEmptyHost()
     properties.put("password", passTest);
     final String invalidUrl = "jdbc:arrow-flight-sql://";
 
-    DriverManager.getConnection(invalidUrl, properties);
+    try (Connection conn = DriverManager.getConnection(invalidUrl, properties)) {
+      Assert.fail("Expected SQLException.");
+    }
   }
 
   /**
@@ -161,6 +166,7 @@ public void testGetBasicClientAuthenticatedShouldOpenConnection()
              new ArrowFlightSqlClientHandler.Builder()
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
                  .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+                 .withEncryption(false)
                  .withUsername(userTest)
                  .withPassword(passTest)
                  .withBufferAllocator(allocator)
@@ -191,7 +197,9 @@ public void testUnencryptedConnectionProvidingInvalidPort()
     final String invalidUrl = "jdbc:arrow-flight-sql://" + FLIGHT_SERVER_TEST_RULE.getHost() +
         ":" + 65537;
 
-    DriverManager.getConnection(invalidUrl, properties);
+    try (Connection conn = DriverManager.getConnection(invalidUrl, properties)) {
+      fail("Expected SQLException");
+    }
   }
 
   /**
@@ -206,6 +214,7 @@ public void testGetBasicClientNoAuthShouldOpenConnection() throws Exception {
              new ArrowFlightSqlClientHandler.Builder()
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
                  .withBufferAllocator(allocator)
+                 .withEncryption(false)
                  .build()) {
       assertNotNull(client);
     }
@@ -228,7 +237,7 @@ public void testUnencryptedConnectionShouldOpenSuccessfullyWithoutAuthentication
         false);
     try (Connection connection = DriverManager
         .getConnection("jdbc:arrow-flight-sql://localhost:32010", properties)) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -271,14 +280,14 @@ public void testTLSConnectionPropertyFalseCorrectCastUrlWithDriverManager() thro
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s&useEncryption=false",
             FLIGHT_SERVER_TEST_RULE.getPort(),
             userTest,
-            passTest));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            passTest))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -301,13 +310,13 @@ public void testTLSConnectionPropertyFalseCorrectCastUrlAndPropertiesUsingSetPro
         passTest);
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "false");
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -329,13 +338,13 @@ public void testTLSConnectionPropertyFalseCorrectCastUrlAndPropertiesUsingPutWit
         passTest);
     properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), false);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -350,14 +359,14 @@ public void testTLSConnectionPropertyFalseIntegerCorrectCastUrlWithDriverManager
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s&useEncryption=0",
             FLIGHT_SERVER_TEST_RULE.getPort(),
             userTest,
-            passTest));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            passTest))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -380,13 +389,13 @@ public void testTLSConnectionPropertyFalseIntegerCorrectCastUrlAndPropertiesUsin
         passTest);
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "0");
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -409,13 +418,13 @@ public void testTLSConnectionPropertyFalseIntegerCorrectCastUrlAndPropertiesUsin
         passTest);
     properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), 0);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -430,15 +439,15 @@ public void testThreadPoolSizeConnectionPropertyCorrectCastUrlWithDriverManager(
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s&threadPoolSize=1&useEncryption=%s",
             FLIGHT_SERVER_TEST_RULE.getPort(),
             userTest,
             passTest,
-            false));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            false))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -462,13 +471,13 @@ public void testThreadPoolSizeConnectionPropertyCorrectCastUrlAndPropertiesUsing
     properties.setProperty(ArrowFlightConnectionProperty.THREAD_POOL_SIZE.camelName(), "1");
     properties.put("useEncryption", false);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -492,13 +501,13 @@ public void testThreadPoolSizeConnectionPropertyCorrectCastUrlAndPropertiesUsing
     properties.put(ArrowFlightConnectionProperty.THREAD_POOL_SIZE.camelName(), 1);
     properties.put("useEncryption", false);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -513,15 +522,15 @@ public void testPasswordConnectionPropertyIntegerCorrectCastUrlWithDriverManager
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s&useEncryption=%s",
             FLIGHT_SERVER_TEST_RULE.getPort(),
             userTest,
             passTest,
-            false));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            false))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -544,13 +553,13 @@ public void testPasswordConnectionPropertyIntegerCorrectCastUrlAndPropertiesUsin
         passTest);
     properties.put("useEncryption", false);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -573,12 +582,12 @@ public void testPasswordConnectionPropertyIntegerCorrectCastUrlAndPropertiesUsin
         passTest);
     properties.put("useEncryption", false);
 
-    Connection connection = DriverManager.getConnection(
+    try (Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java
index 333c474824e52..5579cf0cf5f54 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsRootCertsTest.java
@@ -118,12 +118,16 @@ public void testGetEncryptedClientAuthenticated() throws Exception {
    */
   @Test
   public void testGetEncryptedClientWithNoCertificateOnKeyStore() {
-    assertThrows(SQLException.class, () -> new ArrowFlightSqlClientHandler.Builder()
-            .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
-            .withTlsRootCertificates(badTlsRootCertsPath)
-            .withBufferAllocator(allocator)
-            .withEncryption(true)
-            .build());
+    assertThrows(SQLException.class, () -> {
+      try (ArrowFlightSqlClientHandler handler = new ArrowFlightSqlClientHandler.Builder()
+          .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+          .withTlsRootCertificates(badTlsRootCertsPath)
+          .withBufferAllocator(allocator)
+          .withEncryption(true)
+          .build()) {
+        Assert.fail();
+      }
+    });
   }
 
   /**
@@ -167,7 +171,7 @@ public void testGetEncryptedConnectionWithValidCredentialsAndTlsRootsPath() thro
     final ArrowFlightJdbcDataSource dataSource =
         ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -188,7 +192,7 @@ public void testGetNonAuthenticatedEncryptedConnection() throws Exception {
 
     final ArrowFlightJdbcDataSource dataSource = ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -203,7 +207,7 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throw
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
                 "&useEncryption=true&%s=%s",
@@ -211,9 +215,9 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throw
             userTest,
             passTest,
             ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
-            URLEncoder.encode(tlsRootCertsPath, "UTF-8")));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8")))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -235,13 +239,13 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingSetProp
     properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "true");
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -263,13 +267,13 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingPutWith
     properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), true);
     properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -284,7 +288,7 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager(
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
                 "&useEncryption=1&useSystemTrustStore=0&%s=%s",
@@ -292,9 +296,9 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager(
             userTest,
             passTest,
             ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(),
-            URLEncoder.encode(tlsRootCertsPath, "UTF-8")));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            URLEncoder.encode(tlsRootCertsPath, "UTF-8")))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -316,11 +320,11 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsing
     properties.setProperty(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "1");
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format("jdbc:arrow-flight-sql://localhost:%s", FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -342,11 +346,11 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsing
     properties.put(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), 1);
     properties.put(ArrowFlightConnectionProperty.TLS_ROOT_CERTS.camelName(), tlsRootCertsPath);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format("jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsTest.java
index 95d591766a836..7e160f3f0c385 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ConnectionTlsTest.java
@@ -127,6 +127,7 @@ public void testGetEncryptedClientAuthenticated() throws Exception {
              new ArrowFlightSqlClientHandler.Builder()
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
                  .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+                 .withSystemTrustStore(false)
                  .withUsername(credentials.getUserName())
                  .withPassword(credentials.getPassword())
                  .withTrustStorePath(trustStorePath)
@@ -153,6 +154,7 @@ public void testGetEncryptedClientWithNoCertificateOnKeyStore() throws Exception
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
                  .withTrustStorePath(noCertificateKeyStorePath)
                  .withTrustStorePassword(noCertificateKeyStorePassword)
+                 .withSystemTrustStore(false)
                  .withBufferAllocator(allocator)
                  .withEncryption(true)
                  .build()) {
@@ -170,6 +172,7 @@ public void testGetNonAuthenticatedEncryptedClientNoAuth() throws Exception {
     try (ArrowFlightSqlClientHandler client =
              new ArrowFlightSqlClientHandler.Builder()
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withSystemTrustStore(false)
                  .withTrustStorePath(trustStorePath)
                  .withTrustStorePassword(trustStorePass)
                  .withBufferAllocator(allocator)
@@ -192,6 +195,7 @@ public void testGetEncryptedClientWithKeyStoreBadPasswordAndNoAuth() throws Exce
     try (ArrowFlightSqlClientHandler ignored =
              new ArrowFlightSqlClientHandler.Builder()
                  .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+                 .withSystemTrustStore(false)
                  .withTrustStorePath(trustStorePath)
                  .withTrustStorePassword(keyStoreBadPassword)
                  .withBufferAllocator(allocator)
@@ -225,7 +229,7 @@ public void testGetEncryptedConnectionWithValidCredentialsAndKeyStore() throws E
     final ArrowFlightJdbcDataSource dataSource =
         ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -276,7 +280,7 @@ public void testGetNonAuthenticatedEncryptedConnection() throws Exception {
 
     final ArrowFlightJdbcDataSource dataSource = ArrowFlightJdbcDataSource.createNewDataSource(properties);
     try (final Connection connection = dataSource.getConnection()) {
-      assert connection.isValid(300);
+      Assert.assertTrue(connection.isValid(300));
     }
   }
 
@@ -291,7 +295,7 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throw
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
                 "&useEncryption=true&useSystemTrustStore=false&%s=%s&%s=%s",
@@ -301,9 +305,9 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlWithDriverManager() throw
             ArrowFlightConnectionProperty.TRUST_STORE.camelName(),
             URLEncoder.encode(trustStorePath, "UTF-8"),
             ArrowFlightConnectionProperty.TRUST_STORE_PASSWORD.camelName(),
-            URLEncoder.encode(trustStorePass, "UTF-8")));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            URLEncoder.encode(trustStorePass, "UTF-8")))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -327,13 +331,13 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingSetProp
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "true");
     properties.setProperty(ArrowFlightConnectionProperty.USE_SYSTEM_TRUST_STORE.camelName(), "false");
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -357,13 +361,13 @@ public void testTLSConnectionPropertyTrueCorrectCastUrlAndPropertiesUsingPutWith
     properties.put(ArrowFlightConnectionProperty.TRUST_STORE.camelName(), trustStorePath);
     properties.put(ArrowFlightConnectionProperty.TRUST_STORE_PASSWORD.camelName(), trustStorePass);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -378,7 +382,7 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager(
     final Driver driver = new ArrowFlightJdbcDriver();
     DriverManager.registerDriver(driver);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format(
             "jdbc:arrow-flight-sql://localhost:%s?user=%s&password=%s" +
                 "&useEncryption=1&useSystemTrustStore=0&%s=%s&%s=%s",
@@ -388,9 +392,9 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlWithDriverManager(
             ArrowFlightConnectionProperty.TRUST_STORE.camelName(),
             URLEncoder.encode(trustStorePath, "UTF-8"),
             ArrowFlightConnectionProperty.TRUST_STORE_PASSWORD.camelName(),
-            URLEncoder.encode(trustStorePass, "UTF-8")));
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+            URLEncoder.encode(trustStorePass, "UTF-8")))) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -414,11 +418,11 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsing
     properties.setProperty(ArrowFlightConnectionProperty.USE_ENCRYPTION.camelName(), "1");
     properties.setProperty(ArrowFlightConnectionProperty.USE_SYSTEM_TRUST_STORE.camelName(), "0");
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format("jdbc:arrow-flight-sql://localhost:%s", FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 
   /**
@@ -442,11 +446,11 @@ public void testTLSConnectionPropertyTrueIntegerCorrectCastUrlAndPropertiesUsing
     properties.put(ArrowFlightConnectionProperty.TRUST_STORE.camelName(), trustStorePath);
     properties.put(ArrowFlightConnectionProperty.TRUST_STORE_PASSWORD.camelName(), trustStorePass);
 
-    final Connection connection = DriverManager.getConnection(
+    try (final Connection connection = DriverManager.getConnection(
         String.format("jdbc:arrow-flight-sql://localhost:%s",
             FLIGHT_SERVER_TEST_RULE.getPort()),
-        properties);
-    Assert.assertTrue(connection.isValid(0));
-    connection.close();
+        properties)) {
+      Assert.assertTrue(connection.isValid(0));
+    }
   }
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
index df7cbea56ee2f..39eb0a29866f1 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/FlightServerTestRule.java
@@ -55,6 +55,9 @@
  * and interact with it.
  */
 public class FlightServerTestRule implements TestRule, AutoCloseable {
+  public static final String DEFAULT_USER = "flight-test-user";
+  public static final String DEFAULT_PASSWORD = "flight-test-password";
+
   private static final Logger LOGGER = LoggerFactory.getLogger(FlightServerTestRule.class);
 
   private final Properties properties;
@@ -92,7 +95,7 @@ private FlightServerTestRule(final Properties properties,
   public static FlightServerTestRule createStandardTestRule(final FlightSqlProducer producer) {
     UserPasswordAuthentication authentication =
         new UserPasswordAuthentication.Builder()
-            .user("flight-test-user", "flight-test-password")
+            .user(DEFAULT_USER, DEFAULT_PASSWORD)
             .build();
 
     return new Builder()
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
index 5b9e269fb3cc8..52910812fb4fb 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/ResultSetTest.java
@@ -237,16 +237,17 @@ public void testShouldCloseStatementWhenIsCloseOnCompletion() throws Exception {
    */
   @Test
   public void testShouldCloseStatementWhenIsCloseOnCompletionWithMaxRowsLimit() throws Exception {
-    Statement statement = connection.createStatement();
-    ResultSet resultSet = statement.executeQuery(CoreMockedSqlProducers.LEGACY_REGULAR_SQL_CMD);
+    try (Statement statement = connection.createStatement();
+         ResultSet resultSet = statement.executeQuery(CoreMockedSqlProducers.LEGACY_REGULAR_SQL_CMD)) {
 
-    final long maxRowsLimit = 3;
-    statement.setLargeMaxRows(maxRowsLimit);
-    statement.closeOnCompletion();
+      final long maxRowsLimit = 3;
+      statement.setLargeMaxRows(maxRowsLimit);
+      statement.closeOnCompletion();
 
-    resultSetNextUntilDone(resultSet);
+      resultSetNextUntilDone(resultSet);
 
-    collector.checkThat(statement.isClosed(), is(true));
+      collector.checkThat(statement.isClosed(), is(true));
+    }
   }
 
   /**
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandlerBuilderTest.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandlerBuilderTest.java
new file mode 100644
index 0000000000000..6565a85ddf99f
--- /dev/null
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/client/ArrowFlightSqlClientHandlerBuilderTest.java
@@ -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.
+ */
+
+package org.apache.arrow.driver.jdbc.client;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.arrow.driver.jdbc.FlightServerTestRule;
+import org.apache.arrow.driver.jdbc.utils.CoreMockedSqlProducers;
+import org.apache.arrow.memory.BufferAllocator;
+import org.apache.arrow.memory.RootAllocator;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.ClassRule;
+import org.junit.Test;
+
+/**
+ * Test the behavior of ArrowFlightSqlClientHandler.Builder
+ */
+public class ArrowFlightSqlClientHandlerBuilderTest {
+  @ClassRule
+  public static final FlightServerTestRule FLIGHT_SERVER_TEST_RULE = FlightServerTestRule
+      .createStandardTestRule(CoreMockedSqlProducers.getLegacyProducer());
+
+  private static BufferAllocator allocator;
+
+  @BeforeClass
+  public static void setup() {
+    allocator = new RootAllocator(Long.MAX_VALUE);
+  }
+
+  @AfterClass
+  public static void tearDown() {
+    allocator.close();
+  }
+
+  @Test
+  public void testRetainCookiesOnAuthOff() throws Exception {
+    // Arrange
+    final ArrowFlightSqlClientHandler.Builder rootBuilder = new ArrowFlightSqlClientHandler.Builder()
+        .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+        .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+        .withBufferAllocator(allocator)
+        .withUsername(FlightServerTestRule.DEFAULT_USER)
+        .withPassword(FlightServerTestRule.DEFAULT_PASSWORD)
+        .withEncryption(false)
+        .withRetainCookies(true)
+        .withRetainAuth(false);
+
+    try (ArrowFlightSqlClientHandler rootHandler = rootBuilder.build()) {
+      // Act
+      final ArrowFlightSqlClientHandler.Builder testBuilder = new ArrowFlightSqlClientHandler.Builder(rootBuilder);
+
+      // Assert
+      assertSame(rootBuilder.cookieFactory, testBuilder.cookieFactory);
+      assertNotSame(rootBuilder.authFactory, testBuilder.authFactory);
+    }
+  }
+
+  @Test
+  public void testRetainCookiesOffAuthOff() throws Exception {
+    // Arrange
+    final ArrowFlightSqlClientHandler.Builder rootBuilder = new ArrowFlightSqlClientHandler.Builder()
+        .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+        .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+        .withBufferAllocator(allocator)
+        .withUsername(FlightServerTestRule.DEFAULT_USER)
+        .withPassword(FlightServerTestRule.DEFAULT_PASSWORD)
+        .withEncryption(false)
+        .withRetainCookies(false)
+        .withRetainAuth(false);
+
+    try (ArrowFlightSqlClientHandler rootHandler = rootBuilder.build()) {
+      // Act
+      final ArrowFlightSqlClientHandler.Builder testBuilder = new ArrowFlightSqlClientHandler.Builder(rootBuilder);
+
+      // Assert
+      assertNotSame(rootBuilder.cookieFactory, testBuilder.cookieFactory);
+      assertNotSame(rootBuilder.authFactory, testBuilder.authFactory);
+    }
+  }
+
+  @Test
+  public void testRetainCookiesOnAuthOn() throws Exception {
+    // Arrange
+    final ArrowFlightSqlClientHandler.Builder rootBuilder = new ArrowFlightSqlClientHandler.Builder()
+        .withHost(FLIGHT_SERVER_TEST_RULE.getHost())
+        .withPort(FLIGHT_SERVER_TEST_RULE.getPort())
+        .withBufferAllocator(allocator)
+        .withUsername(FlightServerTestRule.DEFAULT_USER)
+        .withPassword(FlightServerTestRule.DEFAULT_PASSWORD)
+        .withEncryption(false)
+        .withRetainCookies(true)
+        .withRetainAuth(true);
+
+    try (ArrowFlightSqlClientHandler rootHandler = rootBuilder.build()) {
+      // Act
+      final ArrowFlightSqlClientHandler.Builder testBuilder = new ArrowFlightSqlClientHandler.Builder(rootBuilder);
+
+      // Assert
+      assertSame(rootBuilder.cookieFactory, testBuilder.cookieFactory);
+      assertSame(rootBuilder.authFactory, testBuilder.authFactory);
+    }
+  }
+
+  @Test
+  public void testDefaults() {
+    final ArrowFlightSqlClientHandler.Builder builder = new ArrowFlightSqlClientHandler.Builder();
+
+    // Validate all non-mandatory fields against defaults in ArrowFlightConnectionProperty.
+    assertNull(builder.username);
+    assertNull(builder.password);
+    assertTrue(builder.useEncryption);
+    assertFalse(builder.disableCertificateVerification);
+    assertNull(builder.trustStorePath);
+    assertNull(builder.trustStorePassword);
+    assertTrue(builder.useSystemTrustStore);
+    assertNull(builder.token);
+    assertTrue(builder.retainAuth);
+    assertTrue(builder.retainCookies);
+    assertNull(builder.tlsRootCertificatesPath);
+    assertNull(builder.clientCertificatePath);
+    assertNull(builder.clientKeyPath);
+  }
+}

From c4db009f8e3fa8698c58d31a7d3db9d6344da7d5 Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Wed, 8 Nov 2023 04:59:04 +0900
Subject: [PATCH 700/749] MINOR: [Docs][C++] Fix a typo (#38625)

### Rationale for this change

Noticed a typo on the web doc and proposing a fix

### Are these changes tested?

No. But the PR is changing only text.

### Are there any user-facing changes?

Yes. But only documentation typo

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 docs/source/cpp/datatypes.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/datatypes.rst b/docs/source/cpp/datatypes.rst
index 1d2133cbdf3d6..922fef1498b9c 100644
--- a/docs/source/cpp/datatypes.rst
+++ b/docs/source/cpp/datatypes.rst
@@ -157,7 +157,7 @@ Visitor Pattern
 ---------------
 
 In order to process :class:`arrow::DataType`, :class:`arrow::Scalar`, or
-:class:`arrow::Array`, you may need to write write logic that specializes based 
+:class:`arrow::Array`, you may need to write logic that specializes based
 on the particular Arrow type. In these cases, use the
 `visitor pattern <https://en.wikipedia.org/wiki/Visitor_pattern>`_. Arrow provides
 the template functions:

From bbb610e61a00bd80aff5cc7b2d10842bed34e0a4 Mon Sep 17 00:00:00 2001
From: Yue <niyue.com@gmail.com>
Date: Wed, 8 Nov 2023 08:56:03 +0800
Subject: [PATCH 701/749] GH-37753: [C++][Gandiva] Add external function
 registry support (#38116)

# Rationale for this change

This PR tries to enhance Gandiva by supporting external function registry, so that developers can author third party functions without modifying Gandiva's core codebase. See https://github.com/apache/arrow/issues/37753 for more details. In this PR, the external function needs to be compiled into LLVM IR for integration.

# What changes are included in this PR?
Two new APIs are added to `FunctionRegistry`:
```C++
/// \brief register a set of functions into the function registry from a given bitcode
  /// file
arrow::Status Register(const std::vector<NativeFunction>& funcs,
                         const std::string& bitcode_path);

  /// \brief register a set of functions into the function registry from a given bitcode
  /// buffer
  arrow::Status Register(const std::vector<NativeFunction>& funcs,
                         std::shared_ptr<arrow::Buffer> bitcode_buffer);
```
Developers can use these two APIs to register external functions. Typically, developers will register a set of function metadatas (`funcs`) for all functions in a LLVM bitcode file, by giving either the path to the LLVM bitcode file or an `arrow::Buffer` containing the LLVM bitcode buffer.

The overall flow looks like this:
![image](https://github.com/apache/arrow/assets/27754/b2b346fe-931f-4253-b198-4c388c57a56b)

# Are these changes tested?

Some unit tests are added to verify this enhancement

# Are there any user-facing changes?

Some new ways to interfacing the library are added in this PR:
* The `Configuration` class now supports accepting a customized function registry, which developers can register their own external functions and uses it as the function registry
* The `FunctionRegistry` class has two new APIs mentioned above
* The `FunctionRegistry` class, after instantiation, now it doesn't have any built-in function registered in it. And we switch to use a new function `GANDIVA_EXPORT std::shared_ptr<FunctionRegistry> default_function_registry();` to retrieve the default function registry, which contains all the Gandiva built-in functions.
    * Some library depending on Gandiva C++ library, such as Gandiva's Ruby binding's `Gandiva::FunctionRegistry` class behavior is changed accordingly

# Notes
* Performance
    * the code generation time grows with the number of externally added function bitcodes (the more functions are added, the slower the codegen will be), even if the externally function is not used in the given expression at all. But this is not a new issue, and it applies to built-in functions as well (the more built-in functions are there, the slower the codegen will be). In my limited testing, this is because `llvm::Linker::linkModule` takes non trivial of time, which happens to every IR loaded, and the `RemoveUnusedFunctions` happens after that, which doesn't help to reduce the time of `linkModule`. We may have to selectively load only necessary IR (primarily selectively doing `linkModule` for these IR), but more metadata may be needed to tell which functions can be found in which IR. This could be a separated PR for improving it, please advice if any one has any idea on improving it. Thanks.
* Integration with other programming languages via LLVM IR/bitcode
    * So far I only added an external C++ function in the codebase for unit testing purpose. Rust based function is possible but I gave it a try and found another issue (Rust has std lib which needs to be processed in different approach), I will do some exploration for other languages such as zig later.
    * Non pre-compiled functions, may require some different approach to get the function pointer, and we may discuss and work on it in a separated PR later. Another issue https://github.com/apache/arrow/issues/38589 was logged for this.
* The discussion thread in dev mail list, https://lists.apache.org/thread/lm4sbw61w9cl7fsmo7tz3gvkq0ox6rod
     * I submitted another PR previously (https://github.com/apache/arrow/pull/37787) which introduced JSON based function registry, and after discussion, I will close that PR and use this PR instead
* Closes: #37753

Lead-authored-by: Yue Ni <niyue.com@gmail.com>
Co-authored-by: Sutou Kouhei <kou@clear-code.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 c_glib/arrow-glib/version.h.in                |  23 ++++
 c_glib/doc/gandiva-glib/gandiva-glib-docs.xml |   4 +
 c_glib/gandiva-glib/function-registry.cpp     | 118 +++++++++++++++---
 c_glib/gandiva-glib/function-registry.h       |   2 +
 c_glib/gandiva-glib/function-registry.hpp     |  30 +++++
 c_glib/test/gandiva/test-function-registry.rb |   2 +-
 c_glib/test/gandiva/test-native-function.rb   |   2 +-
 cpp/cmake_modules/GandivaAddBitcode.cmake     |  75 +++++++++++
 cpp/cmake_modules/ThirdpartyToolchain.cmake   |  21 ++--
 cpp/src/gandiva/CMakeLists.txt                |   6 +-
 cpp/src/gandiva/GandivaConfig.cmake.in        |   1 +
 cpp/src/gandiva/configuration.cc              |   5 +-
 cpp/src/gandiva/configuration.h               |  26 +++-
 cpp/src/gandiva/engine.cc                     |  69 +++++++---
 cpp/src/gandiva/engine.h                      |   4 +
 cpp/src/gandiva/expr_decomposer_test.cc       |  17 ++-
 cpp/src/gandiva/expr_validator.cc             |   2 +-
 cpp/src/gandiva/expr_validator.h              |   9 +-
 cpp/src/gandiva/expression_registry.cc        |   6 +-
 cpp/src/gandiva/expression_registry.h         |   6 +-
 cpp/src/gandiva/expression_registry_test.cc   |   4 +-
 cpp/src/gandiva/filter.cc                     |   3 +-
 cpp/src/gandiva/function_registry.cc          | 111 +++++++++++-----
 cpp/src/gandiva/function_registry.h           |  34 ++++-
 cpp/src/gandiva/function_registry_test.cc     |  47 +++++--
 cpp/src/gandiva/llvm_generator.cc             |  13 +-
 cpp/src/gandiva/llvm_generator.h              |   8 +-
 cpp/src/gandiva/llvm_generator_test.cc        |  19 ++-
 cpp/src/gandiva/native_function.h             |  12 +-
 cpp/src/gandiva/precompiled/CMakeLists.txt    |  67 ++--------
 cpp/src/gandiva/projector.cc                  |   3 +-
 cpp/src/gandiva/tests/CMakeLists.txt          |  47 ++++---
 cpp/src/gandiva/tests/date_time_test.cc       |  26 ++--
 .../tests/external_functions/CMakeLists.txt   |  50 ++++++++
 .../external_functions/multiply_by_two.cc     |  20 +++
 .../external_functions/multiply_by_two.h      |  24 ++++
 cpp/src/gandiva/tests/filter_test.cc          |   6 +-
 cpp/src/gandiva/tests/huge_table_test.cc      |   5 +-
 .../tests/projector_build_validation_test.cc  |  24 ++--
 cpp/src/gandiva/tests/projector_test.cc       |  26 ++++
 cpp/src/gandiva/tests/test_util.cc            |  52 ++++++++
 cpp/src/gandiva/tests/test_util.h             |  11 +-
 cpp/src/gandiva/tree_expr_test.cc             |  16 +--
 43 files changed, 809 insertions(+), 247 deletions(-)
 create mode 100644 c_glib/gandiva-glib/function-registry.hpp
 create mode 100644 cpp/cmake_modules/GandivaAddBitcode.cmake
 create mode 100644 cpp/src/gandiva/tests/external_functions/CMakeLists.txt
 create mode 100644 cpp/src/gandiva/tests/external_functions/multiply_by_two.cc
 create mode 100644 cpp/src/gandiva/tests/external_functions/multiply_by_two.h
 create mode 100644 cpp/src/gandiva/tests/test_util.cc

diff --git a/c_glib/arrow-glib/version.h.in b/c_glib/arrow-glib/version.h.in
index 60c02936193bc..abb8ba08708de 100644
--- a/c_glib/arrow-glib/version.h.in
+++ b/c_glib/arrow-glib/version.h.in
@@ -110,6 +110,15 @@
 #  define GARROW_UNAVAILABLE(major, minor) G_UNAVAILABLE(major, minor)
 #endif
 
+/**
+ * GARROW_VERSION_15_0:
+ *
+ * You can use this macro value for compile time API version check.
+ *
+ * Since: 15.0.0
+ */
+#define GARROW_VERSION_15_0 G_ENCODE_VERSION(15, 0)
+
 /**
  * GARROW_VERSION_14_0:
  *
@@ -346,6 +355,20 @@
 
 #define GARROW_AVAILABLE_IN_ALL
 
+#if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_15_0
+#  define GARROW_DEPRECATED_IN_15_0                GARROW_DEPRECATED
+#  define GARROW_DEPRECATED_IN_15_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
+#else
+#  define GARROW_DEPRECATED_IN_15_0
+#  define GARROW_DEPRECATED_IN_15_0_FOR(function)
+#endif
+
+#if GARROW_VERSION_MAX_ALLOWED < GARROW_VERSION_15_0
+#  define GARROW_AVAILABLE_IN_15_0 GARROW_UNAVAILABLE(15, 0)
+#else
+#  define GARROW_AVAILABLE_IN_15_0
+#endif
+
 #if GARROW_VERSION_MIN_REQUIRED >= GARROW_VERSION_14_0
 #  define GARROW_DEPRECATED_IN_14_0                GARROW_DEPRECATED
 #  define GARROW_DEPRECATED_IN_14_0_FOR(function)  GARROW_DEPRECATED_FOR(function)
diff --git a/c_glib/doc/gandiva-glib/gandiva-glib-docs.xml b/c_glib/doc/gandiva-glib/gandiva-glib-docs.xml
index 182bbfb527eb2..a5c32f11337e8 100644
--- a/c_glib/doc/gandiva-glib/gandiva-glib-docs.xml
+++ b/c_glib/doc/gandiva-glib/gandiva-glib-docs.xml
@@ -100,6 +100,10 @@
     <title>Index of deprecated API</title>
     <xi:include href="xml/api-index-deprecated.xml"><xi:fallback /></xi:include>
   </index>
+  <index id="api-index-15-0-0" role="15.0.0">
+    <title>Index of new symbols in 15.0.0</title>
+    <xi:include href="xml/api-index-15.0.0.xml"><xi:fallback /></xi:include>
+  </index>
   <index id="api-index-4-0-0" role="4.0.0">
     <title>Index of new symbols in 4.0.0</title>
     <xi:include href="xml/api-index-4.0.0.xml"><xi:fallback /></xi:include>
diff --git a/c_glib/gandiva-glib/function-registry.cpp b/c_glib/gandiva-glib/function-registry.cpp
index a95019bd62c2b..f47262986db82 100644
--- a/c_glib/gandiva-glib/function-registry.cpp
+++ b/c_glib/gandiva-glib/function-registry.cpp
@@ -18,8 +18,8 @@
  */
 
 #include <gandiva/function_registry.h>
-#include <gandiva-glib/function-registry.h>
 
+#include <gandiva-glib/function-registry.hpp>
 #include <gandiva-glib/function-signature.hpp>
 #include <gandiva-glib/native-function.hpp>
 
@@ -34,18 +34,86 @@ G_BEGIN_DECLS
  * Since: 0.14.0
  */
 
-G_DEFINE_TYPE(GGandivaFunctionRegistry,
-              ggandiva_function_registry,
-              G_TYPE_OBJECT)
+struct GGandivaFunctionRegistryPrivate {
+  std::shared_ptr<gandiva::FunctionRegistry> function_registry;
+};
+
+enum {
+  PROP_FUNCTION_REGISTRY = 1,
+};
+
+G_DEFINE_TYPE_WITH_PRIVATE(GGandivaFunctionRegistry,
+                           ggandiva_function_registry,
+                           G_TYPE_OBJECT)
+
+#define GGANDIVA_FUNCTION_REGISTRY_GET_PRIVATE(object)     \
+  static_cast<GGandivaFunctionRegistryPrivate *>(          \
+    ggandiva_function_registry_get_instance_private(       \
+      GGANDIVA_FUNCTION_REGISTRY(object)))
+
+static void
+ggandiva_function_registry_finalize(GObject *object)
+{
+  auto priv = GGANDIVA_FUNCTION_REGISTRY_GET_PRIVATE(object);
+  priv->function_registry.~shared_ptr();
+  G_OBJECT_CLASS(ggandiva_function_registry_parent_class)->finalize(object);
+}
+
+static void
+ggandiva_function_registry_set_property(GObject *object,
+                                        guint prop_id,
+                                        const GValue *value,
+                                        GParamSpec *pspec)
+{
+  auto priv = GGANDIVA_FUNCTION_REGISTRY_GET_PRIVATE(object);
+
+  switch (prop_id) {
+  case PROP_FUNCTION_REGISTRY:
+    priv->function_registry =
+      *static_cast<std::shared_ptr<gandiva::FunctionRegistry> *>(
+        g_value_get_pointer(value));
+    break;
+  default:
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+    break;
+  }
+}
 
 static void
 ggandiva_function_registry_init(GGandivaFunctionRegistry *object)
 {
+  auto priv = GGANDIVA_FUNCTION_REGISTRY_GET_PRIVATE(object);
+  new(&priv->function_registry) std::shared_ptr<gandiva::FunctionRegistry>;
 }
 
 static void
 ggandiva_function_registry_class_init(GGandivaFunctionRegistryClass *klass)
 {
+  auto gobject_class = G_OBJECT_CLASS(klass);
+  gobject_class->finalize = ggandiva_function_registry_finalize;
+  gobject_class->set_property = ggandiva_function_registry_set_property;
+
+  GParamSpec *spec;
+  spec = g_param_spec_pointer("function-registry",
+                              "Function registry",
+                              "The raw std::shared_ptr<gandiva::FunctionRegistry> *",
+                              static_cast<GParamFlags>(G_PARAM_WRITABLE |
+                                                       G_PARAM_CONSTRUCT_ONLY));
+  g_object_class_install_property(gobject_class, PROP_FUNCTION_REGISTRY, spec);
+}
+
+/**
+ * ggandiva_function_registry_default:
+ *
+ * Returns: (transfer full): The process-wide default function registry.
+ *
+ * Since: 15.0.0
+ */
+GGandivaFunctionRegistry *
+ggandiva_function_registry_default(void)
+{
+  auto gandiva_function_registry = gandiva::default_function_registry();
+  return ggandiva_function_registry_new_raw(&gandiva_function_registry);
 }
 
 /**
@@ -58,7 +126,8 @@ ggandiva_function_registry_class_init(GGandivaFunctionRegistryClass *klass)
 GGandivaFunctionRegistry *
 ggandiva_function_registry_new(void)
 {
-  return GGANDIVA_FUNCTION_REGISTRY(g_object_new(GGANDIVA_TYPE_FUNCTION_REGISTRY, NULL));
+  auto gandiva_function_registry = std::make_shared<gandiva::FunctionRegistry>();
+  return ggandiva_function_registry_new_raw(&gandiva_function_registry);
 }
 
 /**
@@ -75,15 +144,16 @@ GGandivaNativeFunction *
 ggandiva_function_registry_lookup(GGandivaFunctionRegistry *function_registry,
                                   GGandivaFunctionSignature *function_signature)
 {
-  gandiva::FunctionRegistry gandiva_function_registry;
+  auto gandiva_function_registry =
+    ggandiva_function_registry_get_raw(function_registry);
   auto gandiva_function_signature =
     ggandiva_function_signature_get_raw(function_signature);
   auto gandiva_native_function =
-    gandiva_function_registry.LookupSignature(*gandiva_function_signature);
+    gandiva_function_registry->LookupSignature(*gandiva_function_signature);
   if (gandiva_native_function) {
     return ggandiva_native_function_new_raw(gandiva_native_function);
   } else {
-    return NULL;
+    return nullptr;
   }
 }
 
@@ -99,18 +169,32 @@ ggandiva_function_registry_lookup(GGandivaFunctionRegistry *function_registry,
 GList *
 ggandiva_function_registry_get_native_functions(GGandivaFunctionRegistry *function_registry)
 {
-  gandiva::FunctionRegistry gandiva_function_registry;
-
+  auto gandiva_function_registry =
+    ggandiva_function_registry_get_raw(function_registry);
   GList *native_functions = nullptr;
-  for (auto gandiva_native_function = gandiva_function_registry.begin();
-       gandiva_native_function != gandiva_function_registry.end();
-       ++gandiva_native_function) {
-    auto native_function = ggandiva_native_function_new_raw(gandiva_native_function);
+  for (const auto &gandiva_native_function : *gandiva_function_registry) {
+    auto native_function = ggandiva_native_function_new_raw(&gandiva_native_function);
     native_functions = g_list_prepend(native_functions, native_function);
   }
-  native_functions = g_list_reverse(native_functions);
-
-  return native_functions;
+  return g_list_reverse(native_functions);
 }
 
 G_END_DECLS
+
+GGandivaFunctionRegistry *
+ggandiva_function_registry_new_raw(
+    std::shared_ptr<gandiva::FunctionRegistry> *gandiva_function_registry)
+{
+  return GGANDIVA_FUNCTION_REGISTRY(
+    g_object_new(GGANDIVA_TYPE_FUNCTION_REGISTRY,
+                 "function-registry", gandiva_function_registry,
+                 nullptr));
+}
+
+std::shared_ptr<gandiva::FunctionRegistry>
+ggandiva_function_registry_get_raw(GGandivaFunctionRegistry *function_registry)
+{
+  auto priv = GGANDIVA_FUNCTION_REGISTRY_GET_PRIVATE(function_registry);
+  return priv->function_registry;
+}
+
diff --git a/c_glib/gandiva-glib/function-registry.h b/c_glib/gandiva-glib/function-registry.h
index 1a0d767d45354..8ff6027cf1734 100644
--- a/c_glib/gandiva-glib/function-registry.h
+++ b/c_glib/gandiva-glib/function-registry.h
@@ -35,6 +35,8 @@ struct _GGandivaFunctionRegistryClass
   GObjectClass parent_class;
 };
 
+GARROW_AVAILABLE_IN_15_0
+GGandivaFunctionRegistry *ggandiva_function_registry_default(void);
 GGandivaFunctionRegistry *ggandiva_function_registry_new(void);
 GGandivaNativeFunction *
 ggandiva_function_registry_lookup(GGandivaFunctionRegistry *function_registry,
diff --git a/c_glib/gandiva-glib/function-registry.hpp b/c_glib/gandiva-glib/function-registry.hpp
new file mode 100644
index 0000000000000..0430fc57dead2
--- /dev/null
+++ b/c_glib/gandiva-glib/function-registry.hpp
@@ -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.
+ */
+
+#pragma once
+
+#include <gandiva/function_registry.h>
+
+#include <gandiva-glib/function-registry.h>
+
+GGandivaFunctionRegistry *
+ggandiva_function_registry_new_raw(
+  std::shared_ptr<gandiva::FunctionRegistry> *gandiva_function_registry);
+std::shared_ptr<gandiva::FunctionRegistry>
+ggandiva_function_registry_get_raw(GGandivaFunctionRegistry *function_registry);
diff --git a/c_glib/test/gandiva/test-function-registry.rb b/c_glib/test/gandiva/test-function-registry.rb
index 25bac6673105e..d0f959a1c5f5f 100644
--- a/c_glib/test/gandiva/test-function-registry.rb
+++ b/c_glib/test/gandiva/test-function-registry.rb
@@ -20,7 +20,7 @@ class TestGandivaFunctionRegistry < Test::Unit::TestCase
 
   def setup
     omit("Gandiva is required") unless defined?(::Gandiva)
-    @registry = Gandiva::FunctionRegistry.new
+    @registry = Gandiva::FunctionRegistry.default
   end
 
   sub_test_case("lookup") do
diff --git a/c_glib/test/gandiva/test-native-function.rb b/c_glib/test/gandiva/test-native-function.rb
index 7888f96b678b7..630a1f7c32d2a 100644
--- a/c_glib/test/gandiva/test-native-function.rb
+++ b/c_glib/test/gandiva/test-native-function.rb
@@ -20,7 +20,7 @@ class TestGandivaNativeFunction < Test::Unit::TestCase
 
   def setup
     omit("Gandiva is required") unless defined?(::Gandiva)
-    @registry = Gandiva::FunctionRegistry.new
+    @registry = Gandiva::FunctionRegistry.default
     @not = lookup("not", [boolean_data_type], boolean_data_type)
     @isnull = lookup("isnull", [int8_data_type], boolean_data_type)
   end
diff --git a/cpp/cmake_modules/GandivaAddBitcode.cmake b/cpp/cmake_modules/GandivaAddBitcode.cmake
new file mode 100644
index 0000000000000..98847f8a186fe
--- /dev/null
+++ b/cpp/cmake_modules/GandivaAddBitcode.cmake
@@ -0,0 +1,75 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Create bitcode for the given source file.
+function(gandiva_add_bitcode SOURCE)
+  set(CLANG_OPTIONS -std=c++17)
+  if(MSVC)
+    # "19.20" means that it's compatible with Visual Studio 16 2019.
+    # We can update this to "19.30" when we dropped support for Visual
+    # Studio 16 2019.
+    #
+    # See https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
+    # for MSVC_VERSION and Visual Studio version.
+    set(FMS_COMPATIBILITY 19.20)
+    list(APPEND CLANG_OPTIONS -fms-compatibility
+         -fms-compatibility-version=${FMS_COMPATIBILITY})
+  endif()
+
+  get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
+  get_filename_component(ABSOLUTE_SOURCE ${SOURCE} ABSOLUTE)
+  set(BC_FILE ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
+  set(PRECOMPILE_COMMAND)
+  if(CMAKE_OSX_SYSROOT)
+    list(APPEND
+         PRECOMPILE_COMMAND
+         ${CMAKE_COMMAND}
+         -E
+         env
+         SDKROOT=${CMAKE_OSX_SYSROOT})
+  endif()
+  list(APPEND
+       PRECOMPILE_COMMAND
+       ${CLANG_EXECUTABLE}
+       ${CLANG_OPTIONS}
+       -DGANDIVA_IR
+       -DNDEBUG # DCHECK macros not implemented in precompiled code
+       -DARROW_STATIC # Do not set __declspec(dllimport) on MSVC on Arrow symbols
+       -DGANDIVA_STATIC # Do not set __declspec(dllimport) on MSVC on Gandiva symbols
+       -fno-use-cxa-atexit # Workaround for unresolved __dso_handle
+       -emit-llvm
+       -O3
+       -c
+       ${ABSOLUTE_SOURCE}
+       -o
+       ${BC_FILE}
+       ${ARROW_GANDIVA_PC_CXX_FLAGS})
+  if(ARROW_BINARY_DIR)
+    list(APPEND PRECOMPILE_COMMAND -I${ARROW_BINARY_DIR}/src)
+  endif()
+  if(ARROW_SOURCE_DIR)
+    list(APPEND PRECOMPILE_COMMAND -I${ARROW_SOURCE_DIR}/src)
+  endif()
+  if(NOT ARROW_USE_NATIVE_INT128)
+    foreach(boost_include_dir ${Boost_INCLUDE_DIRS})
+      list(APPEND PRECOMPILE_COMMAND -I${boost_include_dir})
+    endforeach()
+  endif()
+  add_custom_command(OUTPUT ${BC_FILE}
+                     COMMAND ${PRECOMPILE_COMMAND}
+                     DEPENDS ${SOURCE_FILE})
+endfunction()
diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake
index 5de8ff9b1cb11..52632d554aafb 100644
--- a/cpp/cmake_modules/ThirdpartyToolchain.cmake
+++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake
@@ -230,18 +230,21 @@ macro(build_dependency DEPENDENCY_NAME)
   endif()
 endmacro()
 
-# Find modules are needed by the consumer in case of a static build, or if the
-# linkage is PUBLIC or INTERFACE.
-macro(provide_find_module PACKAGE_NAME ARROW_CMAKE_PACKAGE_NAME)
-  set(module_ "${CMAKE_SOURCE_DIR}/cmake_modules/Find${PACKAGE_NAME}.cmake")
-  if(EXISTS "${module_}")
-    message(STATUS "Providing CMake module for ${PACKAGE_NAME} as part of ${ARROW_CMAKE_PACKAGE_NAME} CMake package"
+function(provide_cmake_module MODULE_NAME ARROW_CMAKE_PACKAGE_NAME)
+  set(module "${CMAKE_SOURCE_DIR}/cmake_modules/${MODULE_NAME}.cmake")
+  if(EXISTS "${module}")
+    message(STATUS "Providing CMake module for ${MODULE_NAME} as part of ${ARROW_CMAKE_PACKAGE_NAME} CMake package"
     )
-    install(FILES "${module_}"
+    install(FILES "${module}"
             DESTINATION "${ARROW_CMAKE_DIR}/${ARROW_CMAKE_PACKAGE_NAME}")
   endif()
-  unset(module_)
-endmacro()
+endfunction()
+
+# Find modules are needed by the consumer in case of a static build, or if the
+# linkage is PUBLIC or INTERFACE.
+function(provide_find_module PACKAGE_NAME ARROW_CMAKE_PACKAGE_NAME)
+  provide_cmake_module("Find${PACKAGE_NAME}" ${ARROW_CMAKE_PACKAGE_NAME})
+endfunction()
 
 macro(resolve_dependency DEPENDENCY_NAME)
   set(options)
diff --git a/cpp/src/gandiva/CMakeLists.txt b/cpp/src/gandiva/CMakeLists.txt
index 6b6743bc8e52f..3448d516768bb 100644
--- a/cpp/src/gandiva/CMakeLists.txt
+++ b/cpp/src/gandiva/CMakeLists.txt
@@ -25,11 +25,14 @@ add_custom_target(gandiva-benchmarks)
 
 add_dependencies(gandiva-all gandiva gandiva-tests gandiva-benchmarks)
 
+include(GandivaAddBitcode)
+
 find_package(LLVMAlt REQUIRED)
 provide_find_module(LLVMAlt "Gandiva")
 if(ARROW_WITH_ZSTD AND "${zstd_SOURCE}" STREQUAL "SYSTEM")
   provide_find_module(zstdAlt "Gandiva")
 endif()
+provide_cmake_module(GandivaAddBitcode "Gandiva")
 
 # Set the path where the bitcode file generated, see precompiled/CMakeLists.txt
 set(GANDIVA_PRECOMPILED_BC_PATH "${CMAKE_CURRENT_BINARY_DIR}/irhelpers.bc")
@@ -249,7 +252,8 @@ add_gandiva_test(internals-test
                  random_generator_holder_test.cc
                  hash_utils_test.cc
                  gdv_function_stubs_test.cc
-                 interval_holder_test.cc)
+                 interval_holder_test.cc
+                 tests/test_util.cc)
 
 add_subdirectory(precompiled)
 add_subdirectory(tests)
diff --git a/cpp/src/gandiva/GandivaConfig.cmake.in b/cpp/src/gandiva/GandivaConfig.cmake.in
index f02e29f25bb3a..68579debd183b 100644
--- a/cpp/src/gandiva/GandivaConfig.cmake.in
+++ b/cpp/src/gandiva/GandivaConfig.cmake.in
@@ -49,6 +49,7 @@ else()
 endif()
 
 include("${CMAKE_CURRENT_LIST_DIR}/GandivaTargets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/GandivaAddBitcode.cmake")
 
 arrow_keep_backward_compatibility(Gandiva gandiva)
 
diff --git a/cpp/src/gandiva/configuration.cc b/cpp/src/gandiva/configuration.cc
index 1e26c5c70d4ec..b79f4118e07f2 100644
--- a/cpp/src/gandiva/configuration.cc
+++ b/cpp/src/gandiva/configuration.cc
@@ -29,11 +29,14 @@ std::size_t Configuration::Hash() const {
   size_t result = kHashSeed;
   arrow::internal::hash_combine(result, static_cast<size_t>(optimize_));
   arrow::internal::hash_combine(result, static_cast<size_t>(target_host_cpu_));
+  arrow::internal::hash_combine(
+      result, reinterpret_cast<std::uintptr_t>(function_registry_.get()));
   return result;
 }
 
 bool Configuration::operator==(const Configuration& other) const {
-  return optimize_ == other.optimize_ && target_host_cpu_ == other.target_host_cpu_;
+  return optimize_ == other.optimize_ && target_host_cpu_ == other.target_host_cpu_ &&
+         function_registry_ == other.function_registry_;
 }
 
 bool Configuration::operator!=(const Configuration& other) const {
diff --git a/cpp/src/gandiva/configuration.h b/cpp/src/gandiva/configuration.h
index 9cd301524d03d..f43a2b190731f 100644
--- a/cpp/src/gandiva/configuration.h
+++ b/cpp/src/gandiva/configuration.h
@@ -21,6 +21,7 @@
 #include <string>
 
 #include "arrow/status.h"
+#include "gandiva/function_registry.h"
 #include "gandiva/visibility.h"
 
 namespace gandiva {
@@ -34,8 +35,14 @@ class GANDIVA_EXPORT Configuration {
  public:
   friend class ConfigurationBuilder;
 
-  Configuration() : optimize_(true), target_host_cpu_(true) {}
-  explicit Configuration(bool optimize) : optimize_(optimize), target_host_cpu_(true) {}
+  explicit Configuration(bool optimize,
+                         std::shared_ptr<FunctionRegistry> function_registry =
+                             gandiva::default_function_registry())
+      : optimize_(optimize),
+        target_host_cpu_(true),
+        function_registry_(function_registry) {}
+
+  Configuration() : Configuration(true) {}
 
   std::size_t Hash() const;
   bool operator==(const Configuration& other) const;
@@ -43,13 +50,21 @@ class GANDIVA_EXPORT Configuration {
 
   bool optimize() const { return optimize_; }
   bool target_host_cpu() const { return target_host_cpu_; }
+  std::shared_ptr<FunctionRegistry> function_registry() const {
+    return function_registry_;
+  }
 
   void set_optimize(bool optimize) { optimize_ = optimize; }
   void target_host_cpu(bool target_host_cpu) { target_host_cpu_ = target_host_cpu; }
+  void set_function_registry(std::shared_ptr<FunctionRegistry> function_registry) {
+    function_registry_ = std::move(function_registry);
+  }
 
  private:
   bool optimize_;        /* optimise the generated llvm IR */
   bool target_host_cpu_; /* set the mcpu flag to host cpu while compiling llvm ir */
+  std::shared_ptr<FunctionRegistry>
+      function_registry_; /* function registry that may contain external functions */
 };
 
 /// \brief configuration builder for gandiva
@@ -68,6 +83,13 @@ class GANDIVA_EXPORT ConfigurationBuilder {
     return configuration;
   }
 
+  std::shared_ptr<Configuration> build(
+      std::shared_ptr<FunctionRegistry> function_registry) {
+    std::shared_ptr<Configuration> configuration(
+        new Configuration(true, std::move(function_registry)));
+    return configuration;
+  }
+
   static std::shared_ptr<Configuration> DefaultConfiguration() {
     return default_configuration_;
   }
diff --git a/cpp/src/gandiva/engine.cc b/cpp/src/gandiva/engine.cc
index 8ebe927437567..5ae1d76876148 100644
--- a/cpp/src/gandiva/engine.cc
+++ b/cpp/src/gandiva/engine.cc
@@ -141,7 +141,8 @@ Engine::Engine(const std::shared_ptr<Configuration>& conf,
       module_(module),
       types_(*context_),
       optimize_(conf->optimize()),
-      cached_(cached) {}
+      cached_(cached),
+      function_registry_(conf->function_registry()) {}
 
 Status Engine::Init() {
   std::call_once(register_exported_funcs_flag, gandiva::RegisterExportedFuncs);
@@ -155,6 +156,7 @@ Status Engine::LoadFunctionIRs() {
   if (!functions_loaded_) {
     ARROW_RETURN_NOT_OK(LoadPreCompiledIR());
     ARROW_RETURN_NOT_OK(DecimalIR::AddFunctions(this));
+    ARROW_RETURN_NOT_OK(LoadExternalPreCompiledIR());
     functions_loaded_ = true;
   }
   return Status::OK();
@@ -236,7 +238,38 @@ static void SetDataLayout(llvm::Module* module) {
 
   module->setDataLayout(machine->createDataLayout());
 }
-// end of the mofified method from MLIR
+// end of the modified method from MLIR
+
+template <typename T>
+static arrow::Result<T> AsArrowResult(llvm::Expected<T>& expected) {
+  if (!expected) {
+    std::string str;
+    llvm::raw_string_ostream stream(str);
+    stream << expected.takeError();
+    return Status::CodeGenError(stream.str());
+  }
+  return std::move(expected.get());
+}
+
+static arrow::Status VerifyAndLinkModule(
+    llvm::Module* dest_module,
+    llvm::Expected<std::unique_ptr<llvm::Module>> src_module_or_error) {
+  ARROW_ASSIGN_OR_RAISE(auto src_ir_module, AsArrowResult(src_module_or_error));
+
+  // set dataLayout
+  SetDataLayout(src_ir_module.get());
+
+  std::string error_info;
+  llvm::raw_string_ostream error_stream(error_info);
+  ARROW_RETURN_IF(
+      llvm::verifyModule(*src_ir_module, &error_stream),
+      Status::CodeGenError("verify of IR Module failed: " + error_stream.str()));
+
+  ARROW_RETURN_IF(llvm::Linker::linkModules(*dest_module, std::move(src_ir_module)),
+                  Status::CodeGenError("failed to link IR Modules"));
+
+  return Status::OK();
+}
 
 // Handling for pre-compiled IR libraries.
 Status Engine::LoadPreCompiledIR() {
@@ -256,23 +289,25 @@ Status Engine::LoadPreCompiledIR() {
   /// Parse the IR module.
   llvm::Expected<std::unique_ptr<llvm::Module>> module_or_error =
       llvm::getOwningLazyBitcodeModule(std::move(buffer), *context());
-  if (!module_or_error) {
-    // NOTE: llvm::handleAllErrors() fails linking with RTTI-disabled LLVM builds
-    // (ARROW-5148)
-    std::string str;
-    llvm::raw_string_ostream stream(str);
-    stream << module_or_error.takeError();
-    return Status::CodeGenError(stream.str());
-  }
-  std::unique_ptr<llvm::Module> ir_module = std::move(module_or_error.get());
+  // NOTE: llvm::handleAllErrors() fails linking with RTTI-disabled LLVM builds
+  // (ARROW-5148)
+  ARROW_RETURN_NOT_OK(VerifyAndLinkModule(module_, std::move(module_or_error)));
+  return Status::OK();
+}
 
-  // set dataLayout
-  SetDataLayout(ir_module.get());
+static llvm::MemoryBufferRef AsLLVMMemoryBuffer(const arrow::Buffer& arrow_buffer) {
+  auto data = reinterpret_cast<const char*>(arrow_buffer.data());
+  auto size = arrow_buffer.size();
+  return llvm::MemoryBufferRef(llvm::StringRef(data, size), "external_bitcode");
+}
 
-  ARROW_RETURN_IF(llvm::verifyModule(*ir_module, &llvm::errs()),
-                  Status::CodeGenError("verify of IR Module failed"));
-  ARROW_RETURN_IF(llvm::Linker::linkModules(*module_, std::move(ir_module)),
-                  Status::CodeGenError("failed to link IR Modules"));
+Status Engine::LoadExternalPreCompiledIR() {
+  auto const& buffers = function_registry_->GetBitcodeBuffers();
+  for (auto const& buffer : buffers) {
+    auto llvm_memory_buffer_ref = AsLLVMMemoryBuffer(*buffer);
+    auto module_or_error = llvm::parseBitcodeFile(llvm_memory_buffer_ref, *context());
+    ARROW_RETURN_NOT_OK(VerifyAndLinkModule(module_, std::move(module_or_error)));
+  }
 
   return Status::OK();
 }
diff --git a/cpp/src/gandiva/engine.h b/cpp/src/gandiva/engine.h
index a4d6a5fd1a758..566977dc4adad 100644
--- a/cpp/src/gandiva/engine.h
+++ b/cpp/src/gandiva/engine.h
@@ -93,6 +93,9 @@ class GANDIVA_EXPORT Engine {
   /// the main module.
   Status LoadPreCompiledIR();
 
+  // load external pre-compiled bitcodes into module
+  Status LoadExternalPreCompiledIR();
+
   // Create and add mappings for cpp functions that can be accessed from LLVM.
   void AddGlobalMappings();
 
@@ -111,6 +114,7 @@ class GANDIVA_EXPORT Engine {
   bool module_finalized_ = false;
   bool cached_;
   bool functions_loaded_ = false;
+  std::shared_ptr<FunctionRegistry> function_registry_;
 };
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/expr_decomposer_test.cc b/cpp/src/gandiva/expr_decomposer_test.cc
index 638ceebcb19fd..7681d9e646297 100644
--- a/cpp/src/gandiva/expr_decomposer_test.cc
+++ b/cpp/src/gandiva/expr_decomposer_test.cc
@@ -24,7 +24,6 @@
 #include "gandiva/function_registry.h"
 #include "gandiva/gandiva_aliases.h"
 #include "gandiva/node.h"
-#include "gandiva/tree_expr_builder.h"
 
 namespace gandiva {
 
@@ -32,12 +31,12 @@ using arrow::int32;
 
 class TestExprDecomposer : public ::testing::Test {
  protected:
-  FunctionRegistry registry_;
+  std::shared_ptr<FunctionRegistry> registry_ = default_function_registry();
 };
 
 TEST_F(TestExprDecomposer, TestStackSimple) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (a) _
   // else _
@@ -58,7 +57,7 @@ TEST_F(TestExprDecomposer, TestStackSimple) {
 
 TEST_F(TestExprDecomposer, TestNested) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (a) _
   // else _
@@ -97,7 +96,7 @@ TEST_F(TestExprDecomposer, TestNested) {
 
 TEST_F(TestExprDecomposer, TestInternalIf) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (a) _
   //   if (b) _
@@ -136,7 +135,7 @@ TEST_F(TestExprDecomposer, TestInternalIf) {
 
 TEST_F(TestExprDecomposer, TestParallelIf) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (a) _
   // else _
@@ -174,7 +173,7 @@ TEST_F(TestExprDecomposer, TestParallelIf) {
 
 TEST_F(TestExprDecomposer, TestIfInCondition) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (if _ else _)   : a
   //   -
@@ -245,7 +244,7 @@ TEST_F(TestExprDecomposer, TestIfInCondition) {
 
 TEST_F(TestExprDecomposer, TestFunctionBetweenNestedIf) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (a) _
   // else
@@ -286,7 +285,7 @@ TEST_F(TestExprDecomposer, TestFunctionBetweenNestedIf) {
 
 TEST_F(TestExprDecomposer, TestComplexIfCondition) {
   Annotator annotator;
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
 
   // if (if _
   //     else
diff --git a/cpp/src/gandiva/expr_validator.cc b/cpp/src/gandiva/expr_validator.cc
index 35a13494523d0..8a6f86e6f0419 100644
--- a/cpp/src/gandiva/expr_validator.cc
+++ b/cpp/src/gandiva/expr_validator.cc
@@ -93,7 +93,7 @@ Status ExprValidator::Visit(const FunctionNode& node) {
   const auto& desc = node.descriptor();
   FunctionSignature signature(desc->name(), desc->params(), desc->return_type());
 
-  const NativeFunction* native_function = registry_.LookupSignature(signature);
+  const NativeFunction* native_function = registry_->LookupSignature(signature);
   ARROW_RETURN_IF(native_function == nullptr,
                   Status::ExpressionValidationError("Function ", signature.ToString(),
                                                     " not supported yet. "));
diff --git a/cpp/src/gandiva/expr_validator.h b/cpp/src/gandiva/expr_validator.h
index 7f6d7fd131fbe..8a423fc93b02b 100644
--- a/cpp/src/gandiva/expr_validator.h
+++ b/cpp/src/gandiva/expr_validator.h
@@ -37,8 +37,9 @@ class FunctionRegistry;
 /// data types, signatures and return types
 class ExprValidator : public NodeVisitor {
  public:
-  explicit ExprValidator(LLVMTypes* types, SchemaPtr schema)
-      : types_(types), schema_(schema) {
+  explicit ExprValidator(LLVMTypes* types, SchemaPtr schema,
+                         std::shared_ptr<FunctionRegistry> registry)
+      : types_(types), schema_(schema), registry_(std::move(registry)) {
     for (auto& field : schema_->fields()) {
       field_map_[field->name()] = field;
     }
@@ -65,12 +66,12 @@ class ExprValidator : public NodeVisitor {
   Status Visit(const InExpressionNode<gandiva::DecimalScalar128>& node) override;
   Status Visit(const InExpressionNode<std::string>& node) override;
 
-  FunctionRegistry registry_;
-
   LLVMTypes* types_;
 
   SchemaPtr schema_;
 
+  std::shared_ptr<FunctionRegistry> registry_;
+
   using FieldMap = std::unordered_map<std::string, FieldPtr>;
   FieldMap field_map_;
 };
diff --git a/cpp/src/gandiva/expression_registry.cc b/cpp/src/gandiva/expression_registry.cc
index 9bff97f5ad269..dd964a7cb8a7a 100644
--- a/cpp/src/gandiva/expression_registry.cc
+++ b/cpp/src/gandiva/expression_registry.cc
@@ -22,9 +22,9 @@
 
 namespace gandiva {
 
-ExpressionRegistry::ExpressionRegistry() {
-  function_registry_.reset(new FunctionRegistry());
-}
+ExpressionRegistry::ExpressionRegistry(
+    std::shared_ptr<FunctionRegistry> function_registry)
+    : function_registry_{function_registry} {}
 
 ExpressionRegistry::~ExpressionRegistry() {}
 
diff --git a/cpp/src/gandiva/expression_registry.h b/cpp/src/gandiva/expression_registry.h
index 609a2dbbe21f9..156a6392564f9 100644
--- a/cpp/src/gandiva/expression_registry.h
+++ b/cpp/src/gandiva/expression_registry.h
@@ -21,6 +21,7 @@
 #include <vector>
 
 #include "gandiva/arrow.h"
+#include "gandiva/function_registry.h"
 #include "gandiva/function_signature.h"
 #include "gandiva/gandiva_aliases.h"
 #include "gandiva/visibility.h"
@@ -37,7 +38,8 @@ class GANDIVA_EXPORT ExpressionRegistry {
  public:
   using native_func_iterator_type = const NativeFunction*;
   using func_sig_iterator_type = const FunctionSignature*;
-  ExpressionRegistry();
+  explicit ExpressionRegistry(std::shared_ptr<FunctionRegistry> function_registry =
+                                  gandiva::default_function_registry());
   ~ExpressionRegistry();
   static DataTypeVector supported_types() { return supported_types_; }
   class GANDIVA_EXPORT FunctionSignatureIterator {
@@ -62,7 +64,7 @@ class GANDIVA_EXPORT ExpressionRegistry {
 
  private:
   static DataTypeVector supported_types_;
-  std::unique_ptr<FunctionRegistry> function_registry_;
+  std::shared_ptr<FunctionRegistry> function_registry_;
 };
 
 /// \brief Get the list of all function signatures.
diff --git a/cpp/src/gandiva/expression_registry_test.cc b/cpp/src/gandiva/expression_registry_test.cc
index c254ff4f3aa5e..cd784192c194e 100644
--- a/cpp/src/gandiva/expression_registry_test.cc
+++ b/cpp/src/gandiva/expression_registry_test.cc
@@ -31,7 +31,7 @@ typedef int64_t (*add_vector_func_t)(int64_t* elements, int nelements);
 
 class TestExpressionRegistry : public ::testing::Test {
  protected:
-  FunctionRegistry registry_;
+  std::shared_ptr<FunctionRegistry> registry_ = default_function_registry();
 };
 
 // Verify all functions in registry are exported.
@@ -42,7 +42,7 @@ TEST_F(TestExpressionRegistry, VerifySupportedFunctions) {
        iter != expr_registry.function_signature_end(); iter++) {
     functions.push_back((*iter));
   }
-  for (auto& iter : registry_) {
+  for (auto& iter : *registry_) {
     for (auto& func_iter : iter.signatures()) {
       auto element = std::find(functions.begin(), functions.end(), func_iter);
       EXPECT_NE(element, functions.end()) << "function signature " << func_iter.ToString()
diff --git a/cpp/src/gandiva/filter.cc b/cpp/src/gandiva/filter.cc
index 78917467a0f56..416d97b5dbd1d 100644
--- a/cpp/src/gandiva/filter.cc
+++ b/cpp/src/gandiva/filter.cc
@@ -71,7 +71,8 @@ Status Filter::Make(SchemaPtr schema, ConditionPtr condition,
   if (!is_cached) {
     // Run the validation on the expression.
     // Return if the expression is invalid since we will not be able to process further.
-    ExprValidator expr_validator(llvm_gen->types(), schema);
+    ExprValidator expr_validator(llvm_gen->types(), schema,
+                                 configuration->function_registry());
     ARROW_RETURN_NOT_OK(expr_validator.Validate(condition));
   }
 
diff --git a/cpp/src/gandiva/function_registry.cc b/cpp/src/gandiva/function_registry.cc
index 67b7b404b325c..5d676dfa8df74 100644
--- a/cpp/src/gandiva/function_registry.cc
+++ b/cpp/src/gandiva/function_registry.cc
@@ -16,6 +16,13 @@
 // under the License.
 
 #include "gandiva/function_registry.h"
+
+#include <utility>
+#include <vector>
+
+#include <llvm/Support/MemoryBuffer.h>
+
+#include "arrow/util/logging.h"
 #include "gandiva/function_registry_arithmetic.h"
 #include "gandiva/function_registry_datetime.h"
 #include "gandiva/function_registry_hash.h"
@@ -23,12 +30,26 @@
 #include "gandiva/function_registry_string.h"
 #include "gandiva/function_registry_timestamp_arithmetic.h"
 
-#include <iterator>
-#include <utility>
-#include <vector>
-
 namespace gandiva {
 
+static constexpr uint32_t kMaxFunctionSignatures = 2048;
+
+// encapsulates an llvm memory buffer in an arrow buffer
+// this is needed because we don't expose the llvm memory buffer to the outside world in
+// the header file
+class LLVMMemoryArrowBuffer : public arrow::Buffer {
+ public:
+  explicit LLVMMemoryArrowBuffer(std::unique_ptr<llvm::MemoryBuffer> llvm_buffer)
+      : arrow::Buffer(reinterpret_cast<const uint8_t*>(llvm_buffer->getBufferStart()),
+                      static_cast<int64_t>(llvm_buffer->getBufferSize())),
+        llvm_buffer_(std::move(llvm_buffer)) {}
+
+ private:
+  std::unique_ptr<llvm::MemoryBuffer> llvm_buffer_;
+};
+
+FunctionRegistry::FunctionRegistry() { pc_registry_.reserve(kMaxFunctionSignatures); }
+
 FunctionRegistry::iterator FunctionRegistry::begin() const {
   return &(*pc_registry_.begin());
 }
@@ -41,42 +62,74 @@ FunctionRegistry::iterator FunctionRegistry::back() const {
   return &(pc_registry_.back());
 }
 
-std::vector<NativeFunction> FunctionRegistry::pc_registry_;
+const NativeFunction* FunctionRegistry::LookupSignature(
+    const FunctionSignature& signature) const {
+  auto got = pc_registry_map_.find(&signature);
+  return got == pc_registry_map_.end() ? nullptr : got->second;
+}
 
-SignatureMap FunctionRegistry::pc_registry_map_ = InitPCMap();
+Status FunctionRegistry::Add(NativeFunction func) {
+  if (pc_registry_.size() == kMaxFunctionSignatures) {
+    return Status::CapacityError("Exceeded max function signatures limit of ",
+                                 kMaxFunctionSignatures);
+  }
+  pc_registry_.emplace_back(std::move(func));
+  auto const& last_func = pc_registry_.back();
+  for (auto const& func_signature : last_func.signatures()) {
+    pc_registry_map_.emplace(&func_signature, &last_func);
+  }
+  return arrow::Status::OK();
+}
 
-SignatureMap FunctionRegistry::InitPCMap() {
-  SignatureMap map;
+arrow::Result<std::unique_ptr<llvm::MemoryBuffer>> GetBufferFromFile(
+    const std::string& bitcode_file_path) {
+  auto buffer_or_error = llvm::MemoryBuffer::getFile(bitcode_file_path);
 
-  auto v1 = GetArithmeticFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v1.begin(), v1.end());
-  auto v2 = GetDateTimeFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v2.begin(), v2.end());
+  ARROW_RETURN_IF(!buffer_or_error,
+                  Status::IOError("Could not load module from bitcode file: ",
+                                  bitcode_file_path +
+                                      " Error: " + buffer_or_error.getError().message()));
 
-  auto v3 = GetHashFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v3.begin(), v3.end());
+  return std::move(buffer_or_error.get());
+}
 
-  auto v4 = GetMathOpsFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v4.begin(), v4.end());
+Status FunctionRegistry::Register(const std::vector<NativeFunction>& funcs,
+                                  const std::string& bitcode_path) {
+  ARROW_ASSIGN_OR_RAISE(auto llvm_buffer, GetBufferFromFile(bitcode_path));
+  auto buffer = std::make_shared<LLVMMemoryArrowBuffer>(std::move(llvm_buffer));
+  return Register(funcs, std::move(buffer));
+}
 
-  auto v5 = GetStringFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v5.begin(), v5.end());
+arrow::Status FunctionRegistry::Register(const std::vector<NativeFunction>& funcs,
+                                         std::shared_ptr<arrow::Buffer> bitcode_buffer) {
+  bitcode_memory_buffers_.emplace_back(std::move(bitcode_buffer));
+  for (const auto& func : funcs) {
+    ARROW_RETURN_NOT_OK(FunctionRegistry::Add(func));
+  }
+  return Status::OK();
+}
 
-  auto v6 = GetDateTimeArithmeticFunctionRegistry();
-  pc_registry_.insert(std::end(pc_registry_), v6.begin(), v6.end());
-  for (auto& elem : pc_registry_) {
-    for (auto& func_signature : elem.signatures()) {
-      map.insert(std::make_pair(&(func_signature), &elem));
+const std::vector<std::shared_ptr<arrow::Buffer>>& FunctionRegistry::GetBitcodeBuffers()
+    const {
+  return bitcode_memory_buffers_;
+}
+
+arrow::Result<std::shared_ptr<FunctionRegistry>> MakeDefaultFunctionRegistry() {
+  auto registry = std::make_shared<FunctionRegistry>();
+  for (auto const& funcs :
+       {GetArithmeticFunctionRegistry(), GetDateTimeFunctionRegistry(),
+        GetHashFunctionRegistry(), GetMathOpsFunctionRegistry(),
+        GetStringFunctionRegistry(), GetDateTimeArithmeticFunctionRegistry()}) {
+    for (auto const& func_signature : funcs) {
+      ARROW_RETURN_NOT_OK(registry->Add(func_signature));
     }
   }
-
-  return map;
+  return std::move(registry);
 }
 
-const NativeFunction* FunctionRegistry::LookupSignature(
-    const FunctionSignature& signature) const {
-  auto got = pc_registry_map_.find(&signature);
-  return got == pc_registry_map_.end() ? nullptr : got->second;
+std::shared_ptr<FunctionRegistry> default_function_registry() {
+  static auto default_registry = *MakeDefaultFunctionRegistry();
+  return default_registry;
 }
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/function_registry.h b/cpp/src/gandiva/function_registry.h
index d9256326019c6..01984961dc90f 100644
--- a/cpp/src/gandiva/function_registry.h
+++ b/cpp/src/gandiva/function_registry.h
@@ -17,7 +17,12 @@
 
 #pragma once
 
+#include <memory>
+#include <string>
 #include <vector>
+
+#include "arrow/buffer.h"
+#include "arrow/status.h"
 #include "gandiva/function_registry_common.h"
 #include "gandiva/gandiva_aliases.h"
 #include "gandiva/native_function.h"
@@ -30,18 +35,41 @@ class GANDIVA_EXPORT FunctionRegistry {
  public:
   using iterator = const NativeFunction*;
 
+  FunctionRegistry();
+  FunctionRegistry(const FunctionRegistry&) = delete;
+  FunctionRegistry& operator=(const FunctionRegistry&) = delete;
+
   /// Lookup a pre-compiled function by its signature.
   const NativeFunction* LookupSignature(const FunctionSignature& signature) const;
 
+  /// \brief register a set of functions into the function registry from a given bitcode
+  /// file
+  arrow::Status Register(const std::vector<NativeFunction>& funcs,
+                         const std::string& bitcode_path);
+
+  /// \brief register a set of functions into the function registry from a given bitcode
+  /// buffer
+  arrow::Status Register(const std::vector<NativeFunction>& funcs,
+                         std::shared_ptr<arrow::Buffer> bitcode_buffer);
+
+  /// \brief get a list of bitcode memory buffers saved in the registry
+  const std::vector<std::shared_ptr<arrow::Buffer>>& GetBitcodeBuffers() const;
+
   iterator begin() const;
   iterator end() const;
   iterator back() const;
 
+  friend arrow::Result<std::shared_ptr<FunctionRegistry>> MakeDefaultFunctionRegistry();
+
  private:
-  static SignatureMap InitPCMap();
+  std::vector<NativeFunction> pc_registry_;
+  SignatureMap pc_registry_map_;
+  std::vector<std::shared_ptr<arrow::Buffer>> bitcode_memory_buffers_;
 
-  static std::vector<NativeFunction> pc_registry_;
-  static SignatureMap pc_registry_map_;
+  Status Add(NativeFunction func);
 };
 
+/// \brief get the default function registry
+GANDIVA_EXPORT std::shared_ptr<FunctionRegistry> default_function_registry();
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/function_registry_test.cc b/cpp/src/gandiva/function_registry_test.cc
index e3c1e85f79cba..bbe72c0ee970c 100644
--- a/cpp/src/gandiva/function_registry_test.cc
+++ b/cpp/src/gandiva/function_registry_test.cc
@@ -23,17 +23,26 @@
 #include <string>
 #include <unordered_set>
 
+#include "gandiva/tests/test_util.h"
+
 namespace gandiva {
 
 class TestFunctionRegistry : public ::testing::Test {
  protected:
-  FunctionRegistry registry_;
+  std::shared_ptr<FunctionRegistry> registry_ = gandiva::default_function_registry();
+
+  static std::unique_ptr<FunctionRegistry> MakeFunctionRegistryWithExternalFunction() {
+    auto registry = std::make_unique<FunctionRegistry>();
+    ARROW_EXPECT_OK(
+        registry->Register({GetTestExternalFunction()}, GetTestFunctionLLVMIRPath()));
+    return registry;
+  }
 };
 
 TEST_F(TestFunctionRegistry, TestFound) {
   FunctionSignature add_i32_i32("add", {arrow::int32(), arrow::int32()}, arrow::int32());
 
-  const NativeFunction* function = registry_.LookupSignature(add_i32_i32);
+  const NativeFunction* function = registry_->LookupSignature(add_i32_i32);
   EXPECT_NE(function, nullptr);
   EXPECT_THAT(function->signatures(), testing::Contains(add_i32_i32));
   EXPECT_EQ(function->pc_name(), "add_int32_int32");
@@ -42,11 +51,32 @@ TEST_F(TestFunctionRegistry, TestFound) {
 TEST_F(TestFunctionRegistry, TestNotFound) {
   FunctionSignature addX_i32_i32("addX", {arrow::int32(), arrow::int32()},
                                  arrow::int32());
-  EXPECT_EQ(registry_.LookupSignature(addX_i32_i32), nullptr);
+  EXPECT_EQ(registry_->LookupSignature(addX_i32_i32), nullptr);
 
   FunctionSignature add_i32_i32_ret64("add", {arrow::int32(), arrow::int32()},
                                       arrow::int64());
-  EXPECT_EQ(registry_.LookupSignature(add_i32_i32_ret64), nullptr);
+  EXPECT_EQ(registry_->LookupSignature(add_i32_i32_ret64), nullptr);
+}
+
+TEST_F(TestFunctionRegistry, TestCustomFunctionRegistry) {
+  auto registry = MakeFunctionRegistryWithExternalFunction();
+
+  auto multiply_by_two_func = GetTestExternalFunction();
+  auto multiply_by_two_int32_ret64 = multiply_by_two_func.signatures().front();
+  EXPECT_NE(registry->LookupSignature(multiply_by_two_int32_ret64), nullptr);
+
+  FunctionSignature add_i32_i32_ret64("add", {arrow::int32(), arrow::int32()},
+                                      arrow::int64());
+  EXPECT_EQ(registry->LookupSignature(add_i32_i32_ret64), nullptr);
+}
+
+TEST_F(TestFunctionRegistry, TestGetBitcodeMemoryBuffersDefaultFunctionRegistry) {
+  EXPECT_EQ(registry_->GetBitcodeBuffers().size(), 0);
+}
+
+TEST_F(TestFunctionRegistry, TestGetBitcodeMemoryBuffersCustomFunctionRegistry) {
+  auto registry = MakeFunctionRegistryWithExternalFunction();
+  EXPECT_EQ(registry->GetBitcodeBuffers().size(), 1);
 }
 
 // one nativefunction object per precompiled function
@@ -55,10 +85,9 @@ TEST_F(TestFunctionRegistry, TestNoDuplicates) {
   std::unordered_set<std::string> native_func_duplicates;
   std::unordered_set<std::string> func_sigs;
   std::unordered_set<std::string> func_sig_duplicates;
-  for (auto native_func_it = registry_.begin(); native_func_it != registry_.end();
-       ++native_func_it) {
-    auto& first_sig = native_func_it->signatures().front();
-    auto pc_func_sig = FunctionSignature(native_func_it->pc_name(),
+  for (const auto& native_func_it : *registry_) {
+    auto& first_sig = native_func_it.signatures().front();
+    auto pc_func_sig = FunctionSignature(native_func_it.pc_name(),
                                          first_sig.param_types(), first_sig.ret_type())
                            .ToString();
     if (pc_func_sigs.count(pc_func_sig) == 0) {
@@ -67,7 +96,7 @@ TEST_F(TestFunctionRegistry, TestNoDuplicates) {
       native_func_duplicates.insert(pc_func_sig);
     }
 
-    for (auto& sig : native_func_it->signatures()) {
+    for (auto& sig : native_func_it.signatures()) {
       auto sig_str = sig.ToString();
       if (func_sigs.count(sig_str) == 0) {
         func_sigs.insert(sig_str);
diff --git a/cpp/src/gandiva/llvm_generator.cc b/cpp/src/gandiva/llvm_generator.cc
index fa1d97be301a8..41cbe0ffe3a3a 100644
--- a/cpp/src/gandiva/llvm_generator.cc
+++ b/cpp/src/gandiva/llvm_generator.cc
@@ -36,11 +36,16 @@ namespace gandiva {
     AddTrace(__VA_ARGS__); \
   }
 
-LLVMGenerator::LLVMGenerator(bool cached) : cached_(cached), enable_ir_traces_(false) {}
+LLVMGenerator::LLVMGenerator(bool cached,
+                             std::shared_ptr<FunctionRegistry> function_registry)
+    : cached_(cached),
+      function_registry_(std::move(function_registry)),
+      enable_ir_traces_(false) {}
 
-Status LLVMGenerator::Make(std::shared_ptr<Configuration> config, bool cached,
+Status LLVMGenerator::Make(const std::shared_ptr<Configuration>& config, bool cached,
                            std::unique_ptr<LLVMGenerator>* llvm_generator) {
-  std::unique_ptr<LLVMGenerator> llvmgen_obj(new LLVMGenerator(cached));
+  std::unique_ptr<LLVMGenerator> llvmgen_obj(
+      new LLVMGenerator(cached, config->function_registry()));
 
   ARROW_RETURN_NOT_OK(Engine::Make(config, cached, &(llvmgen_obj->engine_)));
   *llvm_generator = std::move(llvmgen_obj);
@@ -64,7 +69,7 @@ void LLVMGenerator::SetLLVMObjectCache(GandivaObjectCache& object_cache) {
 Status LLVMGenerator::Add(const ExpressionPtr expr, const FieldDescriptorPtr output) {
   int idx = static_cast<int>(compiled_exprs_.size());
   // decompose the expression to separate out value and validities.
-  ExprDecomposer decomposer(function_registry_, annotator_);
+  ExprDecomposer decomposer(*function_registry_, annotator_);
   ValueValidityPairPtr value_validity;
   ARROW_RETURN_NOT_OK(decomposer.Decompose(*expr->root(), &value_validity));
   // Generate the IR function for the decomposed expression.
diff --git a/cpp/src/gandiva/llvm_generator.h b/cpp/src/gandiva/llvm_generator.h
index 04f9b854b1d29..1921e2565338b 100644
--- a/cpp/src/gandiva/llvm_generator.h
+++ b/cpp/src/gandiva/llvm_generator.h
@@ -47,7 +47,7 @@ class FunctionHolder;
 class GANDIVA_EXPORT LLVMGenerator {
  public:
   /// \brief Factory method to initialize the generator.
-  static Status Make(std::shared_ptr<Configuration> config, bool cached,
+  static Status Make(const std::shared_ptr<Configuration>& config, bool cached,
                      std::unique_ptr<LLVMGenerator>* llvm_generator);
 
   /// \brief Get the cache to be used for LLVM ObjectCache.
@@ -82,11 +82,13 @@ class GANDIVA_EXPORT LLVMGenerator {
   std::string DumpIR() { return engine_->DumpIR(); }
 
  private:
-  explicit LLVMGenerator(bool cached);
+  explicit LLVMGenerator(bool cached,
+                         std::shared_ptr<FunctionRegistry> function_registry);
 
   FRIEND_TEST(TestLLVMGenerator, VerifyPCFunctions);
   FRIEND_TEST(TestLLVMGenerator, TestAdd);
   FRIEND_TEST(TestLLVMGenerator, TestNullInternal);
+  FRIEND_TEST(TestLLVMGenerator, VerifyExtendedPCFunctions);
 
   llvm::LLVMContext* context() { return engine_->context(); }
   llvm::IRBuilder<>* ir_builder() { return engine_->ir_builder(); }
@@ -250,7 +252,7 @@ class GANDIVA_EXPORT LLVMGenerator {
   std::unique_ptr<Engine> engine_;
   std::vector<std::unique_ptr<CompiledExpr>> compiled_exprs_;
   bool cached_;
-  FunctionRegistry function_registry_;
+  std::shared_ptr<FunctionRegistry> function_registry_;
   Annotator annotator_;
   SelectionVector::Mode selection_vector_mode_;
 
diff --git a/cpp/src/gandiva/llvm_generator_test.cc b/cpp/src/gandiva/llvm_generator_test.cc
index 028893b0b4594..671ce91e870f6 100644
--- a/cpp/src/gandiva/llvm_generator_test.cc
+++ b/cpp/src/gandiva/llvm_generator_test.cc
@@ -35,7 +35,7 @@ typedef int64_t (*add_vector_func_t)(int64_t* elements, int nelements);
 
 class TestLLVMGenerator : public ::testing::Test {
  protected:
-  FunctionRegistry registry_;
+  std::shared_ptr<FunctionRegistry> registry_ = default_function_registry();
 };
 
 // Verify that a valid pc function exists for every function in the registry.
@@ -45,7 +45,7 @@ TEST_F(TestLLVMGenerator, VerifyPCFunctions) {
 
   llvm::Module* module = generator->module();
   ASSERT_OK(generator->engine_->LoadFunctionIRs());
-  for (auto& iter : registry_) {
+  for (auto& iter : *registry_) {
     EXPECT_NE(module->getFunction(iter.pc_name()), nullptr);
   }
 }
@@ -73,7 +73,7 @@ TEST_F(TestLLVMGenerator, TestAdd) {
   FunctionSignature signature(func_desc->name(), func_desc->params(),
                               func_desc->return_type());
   const NativeFunction* native_func =
-      generator->function_registry_.LookupSignature(signature);
+      generator->function_registry_->LookupSignature(signature);
 
   std::vector<ValueValidityPairPtr> pairs{pair0, pair1};
   auto func_dex = std::make_shared<NonNullableFuncDex>(
@@ -115,4 +115,17 @@ TEST_F(TestLLVMGenerator, TestAdd) {
   EXPECT_EQ(out_bitmap, 0ULL);
 }
 
+TEST_F(TestLLVMGenerator, VerifyExtendedPCFunctions) {
+  auto external_registry = std::make_shared<FunctionRegistry>();
+  auto config_with_func_registry =
+      TestConfigurationWithFunctionRegistry(std::move(external_registry));
+
+  std::unique_ptr<LLVMGenerator> generator;
+  ASSERT_OK(LLVMGenerator::Make(config_with_func_registry, false, &generator));
+
+  auto module = generator->module();
+  ASSERT_OK(generator->engine_->LoadFunctionIRs());
+  EXPECT_NE(module->getFunction("multiply_by_two_int32"), nullptr);
+}
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/native_function.h b/cpp/src/gandiva/native_function.h
index 1268a25674a9d..c20de3dbdd54d 100644
--- a/cpp/src/gandiva/native_function.h
+++ b/cpp/src/gandiva/native_function.h
@@ -54,16 +54,16 @@ class GANDIVA_EXPORT NativeFunction {
   bool CanReturnErrors() const { return (flags_ & kCanReturnErrors) != 0; }
 
   NativeFunction(const std::string& base_name, const std::vector<std::string>& aliases,
-                 const DataTypeVector& param_types, DataTypePtr ret_type,
-                 const ResultNullableType& result_nullable_type,
-                 const std::string& pc_name, int32_t flags = 0)
+                 const DataTypeVector& param_types, const DataTypePtr& ret_type,
+                 const ResultNullableType& result_nullable_type, std::string pc_name,
+                 int32_t flags = 0)
       : signatures_(),
         flags_(flags),
         result_nullable_type_(result_nullable_type),
-        pc_name_(pc_name) {
-    signatures_.push_back(FunctionSignature(base_name, param_types, ret_type));
+        pc_name_(std::move(pc_name)) {
+    signatures_.emplace_back(base_name, param_types, ret_type);
     for (auto& func_name : aliases) {
-      signatures_.push_back(FunctionSignature(func_name, param_types, ret_type));
+      signatures_.emplace_back(func_name, param_types, ret_type);
     }
   }
 
diff --git a/cpp/src/gandiva/precompiled/CMakeLists.txt b/cpp/src/gandiva/precompiled/CMakeLists.txt
index 3e41640861123..e62a8e3d4a375 100644
--- a/cpp/src/gandiva/precompiled/CMakeLists.txt
+++ b/cpp/src/gandiva/precompiled/CMakeLists.txt
@@ -15,8 +15,6 @@
 # specific language governing permissions and limitations
 # under the License.
 
-project(gandiva)
-
 set(PRECOMPILED_SRCS
     arithmetic_ops.cc
     bitmap.cc
@@ -29,69 +27,18 @@ set(PRECOMPILED_SRCS
     time.cc
     timestamp_arithmetic.cc
     ../../arrow/util/basic_decimal.cc)
-
-set(PLATFORM_CLANG_OPTIONS -std=c++17)
-if(MSVC)
-  # "19.20" means that it's compatible with Visual Studio 16 2019.
-  # We can update this to "19.30" when we dropped support for Visual
-  # Studio 16 2019.
-  #
-  # See https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
-  # for MSVC_VERSION and Visual Studio version.
-  set(FMS_COMPATIBILITY 19.20)
-  list(APPEND PLATFORM_CLANG_OPTIONS -fms-compatibility
-       -fms-compatibility-version=${FMS_COMPATIBILITY})
-endif()
-
-# Create bitcode for each of the source files.
-foreach(SRC_FILE ${PRECOMPILED_SRCS})
-  get_filename_component(SRC_BASE ${SRC_FILE} NAME_WE)
-  get_filename_component(ABSOLUTE_SRC ${SRC_FILE} ABSOLUTE)
-  set(BC_FILE ${CMAKE_CURRENT_BINARY_DIR}/${SRC_BASE}.bc)
-  set(PRECOMPILE_COMMAND)
-  if(CMAKE_OSX_SYSROOT)
-    list(APPEND
-         PRECOMPILE_COMMAND
-         ${CMAKE_COMMAND}
-         -E
-         env
-         SDKROOT=${CMAKE_OSX_SYSROOT})
-  endif()
-  list(APPEND
-       PRECOMPILE_COMMAND
-       ${CLANG_EXECUTABLE}
-       ${PLATFORM_CLANG_OPTIONS}
-       -DGANDIVA_IR
-       -DNDEBUG # DCHECK macros not implemented in precompiled code
-       -DARROW_STATIC # Do not set __declspec(dllimport) on MSVC on Arrow symbols
-       -DGANDIVA_STATIC # Do not set __declspec(dllimport) on MSVC on Gandiva symbols
-       -fno-use-cxa-atexit # Workaround for unresolved __dso_handle
-       -emit-llvm
-       -O3
-       -c
-       ${ABSOLUTE_SRC}
-       -o
-       ${BC_FILE}
-       ${ARROW_GANDIVA_PC_CXX_FLAGS}
-       -I${CMAKE_SOURCE_DIR}/src
-       -I${ARROW_BINARY_DIR}/src)
-
-  if(NOT ARROW_USE_NATIVE_INT128)
-    foreach(boost_include_dir ${Boost_INCLUDE_DIRS})
-      list(APPEND PRECOMPILE_COMMAND -I${boost_include_dir})
-    endforeach()
-  endif()
-  add_custom_command(OUTPUT ${BC_FILE}
-                     COMMAND ${PRECOMPILE_COMMAND}
-                     DEPENDS ${SRC_FILE})
-  list(APPEND BC_FILES ${BC_FILE})
+set(GANDIVA_PRECOMPILED_BC_FILES)
+foreach(SOURCE ${PRECOMPILED_SRCS})
+  gandiva_add_bitcode(${SOURCE})
+  get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
+  list(APPEND GANDIVA_PRECOMPILED_BC_FILES ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
 endforeach()
 
 # link all of the bitcode files into a single bitcode file.
 add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_BC_PATH}
                    COMMAND ${LLVM_LINK_EXECUTABLE} -o ${GANDIVA_PRECOMPILED_BC_PATH}
-                           ${BC_FILES}
-                   DEPENDS ${BC_FILES})
+                           ${GANDIVA_PRECOMPILED_BC_FILES}
+                   DEPENDS ${GANDIVA_PRECOMPILED_BC_FILES})
 
 # turn the bitcode file into a C++ static data variable.
 add_custom_command(OUTPUT ${GANDIVA_PRECOMPILED_CC_PATH}
diff --git a/cpp/src/gandiva/projector.cc b/cpp/src/gandiva/projector.cc
index 7024a3bc208af..e717e825dfc71 100644
--- a/cpp/src/gandiva/projector.cc
+++ b/cpp/src/gandiva/projector.cc
@@ -87,7 +87,8 @@ Status Projector::Make(SchemaPtr schema, const ExpressionVector& exprs,
   // Return if any of the expression is invalid since
   // we will not be able to process further.
   if (!is_cached) {
-    ExprValidator expr_validator(llvm_gen->types(), schema);
+    ExprValidator expr_validator(llvm_gen->types(), schema,
+                                 configuration->function_registry());
     for (auto& expr : exprs) {
       ARROW_RETURN_NOT_OK(expr_validator.Validate(expr));
     }
diff --git a/cpp/src/gandiva/tests/CMakeLists.txt b/cpp/src/gandiva/tests/CMakeLists.txt
index 5fa2da16c632f..68138f50d813d 100644
--- a/cpp/src/gandiva/tests/CMakeLists.txt
+++ b/cpp/src/gandiva/tests/CMakeLists.txt
@@ -15,28 +15,41 @@
 # specific language governing permissions and limitations
 # under the License.
 
-add_gandiva_test(filter_test)
-add_gandiva_test(projector_test)
-add_gandiva_test(projector_build_validation_test)
-add_gandiva_test(if_expr_test)
-add_gandiva_test(literal_test)
-add_gandiva_test(boolean_expr_test)
-add_gandiva_test(binary_test)
-add_gandiva_test(date_time_test)
-add_gandiva_test(to_string_test)
-add_gandiva_test(utf8_test)
-add_gandiva_test(hash_test)
-add_gandiva_test(in_expr_test)
-add_gandiva_test(null_validity_test)
-add_gandiva_test(decimal_test)
-add_gandiva_test(decimal_single_test)
-add_gandiva_test(filter_project_test)
+add_gandiva_test(projector-test
+                 SOURCES
+                 binary_test.cc
+                 boolean_expr_test.cc
+                 date_time_test.cc
+                 decimal_single_test.cc
+                 decimal_test.cc
+                 filter_project_test.cc
+                 filter_test.cc
+                 hash_test.cc
+                 huge_table_test.cc
+                 if_expr_test.cc
+                 in_expr_test.cc
+                 literal_test.cc
+                 null_validity_test.cc
+                 projector_build_validation_test.cc
+                 projector_test.cc
+                 test_util.cc
+                 to_string_test.cc
+                 utf8_test.cc)
 
 if(ARROW_BUILD_STATIC)
-  add_gandiva_test(projector_test_static SOURCES projector_test.cc USE_STATIC_LINKING)
+  add_gandiva_test(projector_test_static
+                   SOURCES
+                   projector_test.cc
+                   test_util.cc
+                   USE_STATIC_LINKING)
   add_arrow_benchmark(micro_benchmarks
+                      SOURCES
+                      micro_benchmarks.cc
+                      test_util.cc
                       PREFIX
                       "gandiva"
                       EXTRA_LINK_LIBS
                       gandiva_static)
 endif()
+
+add_subdirectory(external_functions)
diff --git a/cpp/src/gandiva/tests/date_time_test.cc b/cpp/src/gandiva/tests/date_time_test.cc
index ce1c3d05f6638..6208f1ecba9b5 100644
--- a/cpp/src/gandiva/tests/date_time_test.cc
+++ b/cpp/src/gandiva/tests/date_time_test.cc
@@ -36,7 +36,7 @@ using arrow::int32;
 using arrow::int64;
 using arrow::timestamp;
 
-class TestProjector : public ::testing::Test {
+class DateTimeTestProjector : public ::testing::Test {
  public:
   void SetUp() { pool_ = arrow::default_memory_pool(); }
 
@@ -111,7 +111,7 @@ int32_t DaysSince(time_t base_line, int32_t yy, int32_t mm, int32_t dd, int32_t
   return static_cast<int32_t>(((ts - base_line) * 1000 + millis) / MILLIS_IN_DAY);
 }
 
-TEST_F(TestProjector, TestIsNull) {
+TEST_F(DateTimeTestProjector, TestIsNull) {
   auto d0 = field("d0", date64());
   auto t0 = field("t0", time32(arrow::TimeUnit::MILLI));
   auto schema = arrow::schema({d0, t0});
@@ -155,7 +155,7 @@ TEST_F(TestProjector, TestIsNull) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_isnotnull, outputs.at(1));
 }
 
-TEST_F(TestProjector, TestDate32IsNull) {
+TEST_F(DateTimeTestProjector, TestDate32IsNull) {
   auto d0 = field("d0", date32());
   auto schema = arrow::schema({d0});
 
@@ -191,7 +191,7 @@ TEST_F(TestProjector, TestDate32IsNull) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_isnull, outputs.at(0));
 }
 
-TEST_F(TestProjector, TestDateTime) {
+TEST_F(DateTimeTestProjector, TestDateTime) {
   auto field0 = field("f0", date64());
   auto field1 = field("f1", date32());
   auto field2 = field("f2", timestamp(arrow::TimeUnit::MILLI));
@@ -292,7 +292,7 @@ TEST_F(TestProjector, TestDateTime) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_dd_from_ts, outputs.at(5));
 }
 
-TEST_F(TestProjector, TestTime) {
+TEST_F(DateTimeTestProjector, TestTime) {
   auto field0 = field("f0", time32(arrow::TimeUnit::MILLI));
   auto schema = arrow::schema({field0});
 
@@ -339,7 +339,7 @@ TEST_F(TestProjector, TestTime) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_hour, outputs.at(1));
 }
 
-TEST_F(TestProjector, TestTimestampDiff) {
+TEST_F(DateTimeTestProjector, TestTimestampDiff) {
   auto f0 = field("f0", timestamp(arrow::TimeUnit::MILLI));
   auto f1 = field("f1", timestamp(arrow::TimeUnit::MILLI));
   auto schema = arrow::schema({f0, f1});
@@ -439,7 +439,7 @@ TEST_F(TestProjector, TestTimestampDiff) {
   }
 }
 
-TEST_F(TestProjector, TestTimestampDiffMonth) {
+TEST_F(DateTimeTestProjector, TestTimestampDiffMonth) {
   auto f0 = field("f0", timestamp(arrow::TimeUnit::MILLI));
   auto f1 = field("f1", timestamp(arrow::TimeUnit::MILLI));
   auto schema = arrow::schema({f0, f1});
@@ -497,7 +497,7 @@ TEST_F(TestProjector, TestTimestampDiffMonth) {
   }
 }
 
-TEST_F(TestProjector, TestMonthsBetween) {
+TEST_F(DateTimeTestProjector, TestMonthsBetween) {
   auto f0 = field("f0", arrow::date64());
   auto f1 = field("f1", arrow::date64());
   auto schema = arrow::schema({f0, f1});
@@ -550,7 +550,7 @@ TEST_F(TestProjector, TestMonthsBetween) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_output, outputs.at(0));
 }
 
-TEST_F(TestProjector, TestCastTimestampFromInt64) {
+TEST_F(DateTimeTestProjector, TestCastTimestampFromInt64) {
   auto f0 = field("f0", arrow::int64());
   auto schema = arrow::schema({f0});
 
@@ -600,7 +600,7 @@ TEST_F(TestProjector, TestCastTimestampFromInt64) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_output, outputs.at(0));
 }
 
-TEST_F(TestProjector, TestLastDay) {
+TEST_F(DateTimeTestProjector, TestLastDay) {
   auto f0 = field("f0", arrow::date64());
   auto schema = arrow::schema({f0});
 
@@ -650,7 +650,7 @@ TEST_F(TestProjector, TestLastDay) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_output, outputs.at(0));
 }
 
-TEST_F(TestProjector, TestToTimestampFromInt) {
+TEST_F(DateTimeTestProjector, TestToTimestampFromInt) {
   auto f0 = field("f0", arrow::int32());
   auto f1 = field("f1", arrow::int64());
   auto f2 = field("f2", arrow::float32());
@@ -721,7 +721,7 @@ TEST_F(TestProjector, TestToTimestampFromInt) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_output1, outputs.at(3));
 }
 
-TEST_F(TestProjector, TestToUtcTimestamp) {
+TEST_F(DateTimeTestProjector, TestToUtcTimestamp) {
   auto f0 = field("f0", timestamp(arrow::TimeUnit::MILLI));
   auto f1 = field("f1", arrow::utf8());
 
@@ -775,7 +775,7 @@ TEST_F(TestProjector, TestToUtcTimestamp) {
   EXPECT_ARROW_ARRAY_EQUALS(exp_output, outputs.at(0));
 }
 
-TEST_F(TestProjector, TestFromUtcTimestamp) {
+TEST_F(DateTimeTestProjector, TestFromUtcTimestamp) {
   auto f0 = field("f0", timestamp(arrow::TimeUnit::MILLI));
   auto f1 = field("f1", arrow::utf8());
 
diff --git a/cpp/src/gandiva/tests/external_functions/CMakeLists.txt b/cpp/src/gandiva/tests/external_functions/CMakeLists.txt
new file mode 100644
index 0000000000000..c309549e874e3
--- /dev/null
+++ b/cpp/src/gandiva/tests/external_functions/CMakeLists.txt
@@ -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.
+
+if(NO_TESTS)
+  return()
+endif()
+#
+## copy the testing data into the build directory
+add_custom_target(extension-tests-data
+                  COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}
+                          ${CMAKE_CURRENT_BINARY_DIR})
+
+set(TEST_PRECOMPILED_SOURCES multiply_by_two.cc)
+set(TEST_PRECOMPILED_BC_FILES)
+foreach(SOURCE ${TEST_PRECOMPILED_SOURCES})
+  gandiva_add_bitcode(${SOURCE})
+  get_filename_component(SOURCE_BASE ${SOURCE} NAME_WE)
+  list(APPEND TEST_PRECOMPILED_BC_FILES ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_BASE}.bc)
+endforeach()
+add_custom_target(extension-tests ALL DEPENDS extension-tests-data
+                                              ${TEST_PRECOMPILED_BC_FILES})
+#
+## set the GANDIVA_EXTENSION_TEST_DIR macro so that the tests can pass regardless where they are run from
+## corresponding extension test data files and bitcode will be copied/generated
+set(TARGETS_DEPENDING_ON_TEST_BITCODE_FILES gandiva-internals-test gandiva-projector-test
+                                            gandiva-projector-test-static)
+foreach(TARGET ${TARGETS_DEPENDING_ON_TEST_BITCODE_FILES})
+  if(TARGET ${TARGET})
+    add_dependencies(${TARGET} extension-tests)
+    target_compile_definitions(${TARGET}
+                               PRIVATE -DGANDIVA_EXTENSION_TEST_DIR="${CMAKE_CURRENT_BINARY_DIR}"
+    )
+  endif()
+endforeach()
+
+add_dependencies(gandiva-tests extension-tests)
diff --git a/cpp/src/gandiva/tests/external_functions/multiply_by_two.cc b/cpp/src/gandiva/tests/external_functions/multiply_by_two.cc
new file mode 100644
index 0000000000000..cc7e2b0f8267f
--- /dev/null
+++ b/cpp/src/gandiva/tests/external_functions/multiply_by_two.cc
@@ -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.
+
+#include "multiply_by_two.h"  // NOLINT
+
+int64_t multiply_by_two_int32(int32_t value) { return value * 2; }
diff --git a/cpp/src/gandiva/tests/external_functions/multiply_by_two.h b/cpp/src/gandiva/tests/external_functions/multiply_by_two.h
new file mode 100644
index 0000000000000..b8aec5185457b
--- /dev/null
+++ b/cpp/src/gandiva/tests/external_functions/multiply_by_two.h
@@ -0,0 +1,24 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <cstdint>
+
+extern "C" {
+int64_t multiply_by_two_int32(int32_t value);
+}
diff --git a/cpp/src/gandiva/tests/filter_test.cc b/cpp/src/gandiva/tests/filter_test.cc
index effd31cc27aa0..749000aa0cf27 100644
--- a/cpp/src/gandiva/tests/filter_test.cc
+++ b/cpp/src/gandiva/tests/filter_test.cc
@@ -42,8 +42,8 @@ class TestFilter : public ::testing::Test {
 
 TEST_F(TestFilter, TestFilterCache) {
   // schema for input fields
-  auto field0 = field("f0", int32());
-  auto field1 = field("f1", int32());
+  auto field0 = field("f0_filter_cache", int32());
+  auto field1 = field("f1_filter_cache", int32());
   auto schema = arrow::schema({field0, field1});
 
   // Build condition f0 + f1 < 10
@@ -69,7 +69,7 @@ TEST_F(TestFilter, TestFilterCache) {
   EXPECT_TRUE(cached_filter->GetBuiltFromCache());
 
   // schema is different should return a new filter.
-  auto field2 = field("f2", int32());
+  auto field2 = field("f2_filter_cache", int32());
   auto different_schema = arrow::schema({field0, field1, field2});
   std::shared_ptr<Filter> should_be_new_filter;
   status =
diff --git a/cpp/src/gandiva/tests/huge_table_test.cc b/cpp/src/gandiva/tests/huge_table_test.cc
index 46f814b472d84..34c8512f1b0a9 100644
--- a/cpp/src/gandiva/tests/huge_table_test.cc
+++ b/cpp/src/gandiva/tests/huge_table_test.cc
@@ -139,8 +139,11 @@ TEST_F(LARGE_MEMORY_TEST(TestHugeFilter), TestSimpleHugeFilter) {
   auto status = Filter::Make(schema, condition, TestConfiguration(), &filter);
   EXPECT_TRUE(status.ok());
 
+  auto array1 = MakeArrowArray<arrow::Int32Type, int32_t>(arr1, validity);
+  auto array2 = MakeArrowArray<arrow::Int32Type, int32_t>(arr2, validity);
+
   // prepare input record batch
-  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {arr1, arr2});
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array1, array2});
 
   std::shared_ptr<SelectionVector> selection_vector;
   status = SelectionVector::MakeInt64(num_records, pool_, &selection_vector);
diff --git a/cpp/src/gandiva/tests/projector_build_validation_test.cc b/cpp/src/gandiva/tests/projector_build_validation_test.cc
index 5b86844f940bf..1ed4c77a074ab 100644
--- a/cpp/src/gandiva/tests/projector_build_validation_test.cc
+++ b/cpp/src/gandiva/tests/projector_build_validation_test.cc
@@ -27,7 +27,7 @@ using arrow::boolean;
 using arrow::float32;
 using arrow::int32;
 
-class TestProjector : public ::testing::Test {
+class ValidationTestProjector : public ::testing::Test {
  public:
   void SetUp() { pool_ = arrow::default_memory_pool(); }
 
@@ -35,7 +35,7 @@ class TestProjector : public ::testing::Test {
   arrow::MemoryPool* pool_;
 };
 
-TEST_F(TestProjector, TestNonexistentFunction) {
+TEST_F(ValidationTestProjector, TestNonexistentFunction) {
   // schema for input fields
   auto field0 = field("f0", float32());
   auto field1 = field("f2", float32());
@@ -57,7 +57,7 @@ TEST_F(TestProjector, TestNonexistentFunction) {
   EXPECT_TRUE(status.message().find(expected_error) != std::string::npos);
 }
 
-TEST_F(TestProjector, TestNotMatchingDataType) {
+TEST_F(ValidationTestProjector, TestNotMatchingDataType) {
   // schema for input fields
   auto field0 = field("f0", float32());
   auto schema = arrow::schema({field0});
@@ -78,7 +78,7 @@ TEST_F(TestProjector, TestNotMatchingDataType) {
   EXPECT_TRUE(status.message().find(expected_error) != std::string::npos);
 }
 
-TEST_F(TestProjector, TestNotSupportedDataType) {
+TEST_F(ValidationTestProjector, TestNotSupportedDataType) {
   // schema for input fields
   auto field0 = field("f0", list(int32()));
   auto schema = arrow::schema({field0});
@@ -98,7 +98,7 @@ TEST_F(TestProjector, TestNotSupportedDataType) {
   EXPECT_TRUE(status.message().find(expected_error) != std::string::npos);
 }
 
-TEST_F(TestProjector, TestIncorrectSchemaMissingField) {
+TEST_F(ValidationTestProjector, TestIncorrectSchemaMissingField) {
   // schema for input fields
   auto field0 = field("f0", float32());
   auto field1 = field("f2", float32());
@@ -119,7 +119,7 @@ TEST_F(TestProjector, TestIncorrectSchemaMissingField) {
   EXPECT_TRUE(status.message().find(expected_error) != std::string::npos);
 }
 
-TEST_F(TestProjector, TestIncorrectSchemaTypeNotMatching) {
+TEST_F(ValidationTestProjector, TestIncorrectSchemaTypeNotMatching) {
   // schema for input fields
   auto field0 = field("f0", float32());
   auto field1 = field("f2", float32());
@@ -142,7 +142,7 @@ TEST_F(TestProjector, TestIncorrectSchemaTypeNotMatching) {
   EXPECT_TRUE(status.message().find(expected_error) != std::string::npos);
 }
 
-TEST_F(TestProjector, TestIfNotSupportedFunction) {
+TEST_F(ValidationTestProjector, TestIfNotSupportedFunction) {
   // schema for input fields
   auto fielda = field("a", int32());
   auto fieldb = field("b", int32());
@@ -170,7 +170,7 @@ TEST_F(TestProjector, TestIfNotSupportedFunction) {
   EXPECT_TRUE(status.IsExpressionValidationError());
 }
 
-TEST_F(TestProjector, TestIfNotMatchingReturnType) {
+TEST_F(ValidationTestProjector, TestIfNotMatchingReturnType) {
   // schema for input fields
   auto fielda = field("a", int32());
   auto fieldb = field("b", int32());
@@ -193,7 +193,7 @@ TEST_F(TestProjector, TestIfNotMatchingReturnType) {
   EXPECT_TRUE(status.IsExpressionValidationError());
 }
 
-TEST_F(TestProjector, TestElseNotMatchingReturnType) {
+TEST_F(ValidationTestProjector, TestElseNotMatchingReturnType) {
   // schema for input fields
   auto fielda = field("a", int32());
   auto fieldb = field("b", int32());
@@ -218,7 +218,7 @@ TEST_F(TestProjector, TestElseNotMatchingReturnType) {
   EXPECT_TRUE(status.IsExpressionValidationError());
 }
 
-TEST_F(TestProjector, TestElseNotSupportedType) {
+TEST_F(ValidationTestProjector, TestElseNotSupportedType) {
   // schema for input fields
   auto fielda = field("a", int32());
   auto fieldb = field("b", int32());
@@ -244,7 +244,7 @@ TEST_F(TestProjector, TestElseNotSupportedType) {
   EXPECT_EQ(status.code(), StatusCode::ExpressionValidationError);
 }
 
-TEST_F(TestProjector, TestAndMinChildren) {
+TEST_F(ValidationTestProjector, TestAndMinChildren) {
   // schema for input fields
   auto fielda = field("a", boolean());
   auto schema = arrow::schema({fielda});
@@ -263,7 +263,7 @@ TEST_F(TestProjector, TestAndMinChildren) {
   EXPECT_TRUE(status.IsExpressionValidationError());
 }
 
-TEST_F(TestProjector, TestAndBooleanArgType) {
+TEST_F(ValidationTestProjector, TestAndBooleanArgType) {
   // schema for input fields
   auto fielda = field("a", boolean());
   auto fieldb = field("b", int32());
diff --git a/cpp/src/gandiva/tests/projector_test.cc b/cpp/src/gandiva/tests/projector_test.cc
index 462fae64393fd..38566fb408ab5 100644
--- a/cpp/src/gandiva/tests/projector_test.cc
+++ b/cpp/src/gandiva/tests/projector_test.cc
@@ -26,6 +26,7 @@
 #include <cmath>
 
 #include "arrow/memory_pool.h"
+#include "gandiva/function_registry.h"
 #include "gandiva/literal_holder.h"
 #include "gandiva/node.h"
 #include "gandiva/tests/test_util.h"
@@ -3582,4 +3583,29 @@ TEST_F(TestProjector, TestSqrtFloat64) {
   EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
 }
 
+TEST_F(TestProjector, TestExtendedFunctions) {
+  auto in_field = field("in", arrow::int32());
+  auto schema = arrow::schema({in_field});
+  auto out_field = field("out", arrow::int64());
+  // the multiply_by_two function is only available in the external function's IR bitcode
+  auto multiply =
+      TreeExprBuilder::MakeExpression("multiply_by_two", {in_field}, out_field);
+
+  std::shared_ptr<Projector> projector;
+  auto external_registry = std::make_shared<FunctionRegistry>();
+  auto config_with_func_registry =
+      TestConfigurationWithFunctionRegistry(std::move(external_registry));
+  ARROW_EXPECT_OK(
+      Projector::Make(schema, {multiply}, config_with_func_registry, &projector));
+
+  int num_records = 4;
+  auto array = MakeArrowArrayInt32({1, 2, 3, 4}, {true, true, true, true});
+  auto in_batch = arrow::RecordBatch::Make(schema, num_records, {array});
+  auto out = MakeArrowArrayInt64({2, 4, 6, 8}, {true, true, true, true});
+
+  arrow::ArrayVector outs;
+  ARROW_EXPECT_OK(projector->Evaluate(*in_batch, pool_, &outs));
+  EXPECT_ARROW_ARRAY_EQUALS(out, outs.at(0));
+}
+
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/tests/test_util.cc b/cpp/src/gandiva/tests/test_util.cc
new file mode 100644
index 0000000000000..42f67d3824a21
--- /dev/null
+++ b/cpp/src/gandiva/tests/test_util.cc
@@ -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.
+
+#include "gandiva/tests/test_util.h"
+
+#include <filesystem>
+
+namespace gandiva {
+std::shared_ptr<Configuration> TestConfiguration() {
+  auto builder = ConfigurationBuilder();
+  return builder.DefaultConfiguration();
+}
+
+#ifndef GANDIVA_EXTENSION_TEST_DIR
+#define GANDIVA_EXTENSION_TEST_DIR "."
+#endif
+
+std::string GetTestFunctionLLVMIRPath() {
+  std::filesystem::path base(GANDIVA_EXTENSION_TEST_DIR);
+  std::filesystem::path ir_file = base / "multiply_by_two.bc";
+  return ir_file.string();
+}
+
+NativeFunction GetTestExternalFunction() {
+  NativeFunction multiply_by_two_func(
+      "multiply_by_two", {}, {arrow::int32()}, arrow::int64(),
+      ResultNullableType::kResultNullIfNull, "multiply_by_two_int32");
+  return multiply_by_two_func;
+}
+
+std::shared_ptr<Configuration> TestConfigurationWithFunctionRegistry(
+    std::shared_ptr<FunctionRegistry> registry) {
+  ARROW_EXPECT_OK(
+      registry->Register({GetTestExternalFunction()}, GetTestFunctionLLVMIRPath()));
+  auto external_func_config = ConfigurationBuilder().build(std::move(registry));
+  return external_func_config;
+}
+}  // namespace gandiva
diff --git a/cpp/src/gandiva/tests/test_util.h b/cpp/src/gandiva/tests/test_util.h
index 99df90769e0ad..e431e53096c2c 100644
--- a/cpp/src/gandiva/tests/test_util.h
+++ b/cpp/src/gandiva/tests/test_util.h
@@ -96,9 +96,12 @@ static inline ArrayPtr MakeArrowTypeArray(const std::shared_ptr<arrow::DataType>
   EXPECT_TRUE((a)->Equals(b)) << "expected type: " << (a)->ToString() \
                               << " actual type: " << (b)->ToString()
 
-static inline std::shared_ptr<Configuration> TestConfiguration() {
-  auto builder = ConfigurationBuilder();
-  return builder.DefaultConfiguration();
-}
+std::shared_ptr<Configuration> TestConfiguration();
+
+std::shared_ptr<Configuration> TestConfigurationWithFunctionRegistry(
+    std::shared_ptr<FunctionRegistry> registry);
+
+std::string GetTestFunctionLLVMIRPath();
+NativeFunction GetTestExternalFunction();
 
 }  // namespace gandiva
diff --git a/cpp/src/gandiva/tree_expr_test.cc b/cpp/src/gandiva/tree_expr_test.cc
index e70cf12898124..86a826f29367f 100644
--- a/cpp/src/gandiva/tree_expr_test.cc
+++ b/cpp/src/gandiva/tree_expr_test.cc
@@ -45,7 +45,7 @@ class TestExprTree : public ::testing::Test {
   FieldPtr i1_;  // int32
 
   FieldPtr b0_;  // bool
-  FunctionRegistry registry_;
+  std::shared_ptr<FunctionRegistry> registry_ = gandiva::default_function_registry();
 };
 
 TEST_F(TestExprTree, TestField) {
@@ -57,7 +57,7 @@ TEST_F(TestExprTree, TestField) {
   auto n1 = TreeExprBuilder::MakeField(b0_);
   EXPECT_EQ(n1->return_type(), boolean());
 
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
   ValueValidityPairPtr pair;
   auto status = decomposer.Decompose(*n1, &pair);
   DCHECK_EQ(status.ok(), true) << status.message();
@@ -88,7 +88,7 @@ TEST_F(TestExprTree, TestBinary) {
   EXPECT_EQ(add->return_type(), int32());
   EXPECT_TRUE(sign == FunctionSignature("add", {int32(), int32()}, int32()));
 
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
   ValueValidityPairPtr pair;
   auto status = decomposer.Decompose(*n, &pair);
   DCHECK_EQ(status.ok(), true) << status.message();
@@ -97,7 +97,7 @@ TEST_F(TestExprTree, TestBinary) {
   auto null_if_null = std::dynamic_pointer_cast<NonNullableFuncDex>(value);
 
   FunctionSignature signature("add", {int32(), int32()}, int32());
-  const NativeFunction* fn = registry_.LookupSignature(signature);
+  const NativeFunction* fn = registry_->LookupSignature(signature);
   EXPECT_EQ(null_if_null->native_function(), fn);
 }
 
@@ -114,7 +114,7 @@ TEST_F(TestExprTree, TestUnary) {
   EXPECT_EQ(unaryFn->return_type(), boolean());
   EXPECT_TRUE(sign == FunctionSignature("isnumeric", {int32()}, boolean()));
 
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
   ValueValidityPairPtr pair;
   auto status = decomposer.Decompose(*n, &pair);
   DCHECK_EQ(status.ok(), true) << status.message();
@@ -123,7 +123,7 @@ TEST_F(TestExprTree, TestUnary) {
   auto never_null = std::dynamic_pointer_cast<NullableNeverFuncDex>(value);
 
   FunctionSignature signature("isnumeric", {int32()}, boolean());
-  const NativeFunction* fn = registry_.LookupSignature(signature);
+  const NativeFunction* fn = registry_->LookupSignature(signature);
   EXPECT_EQ(never_null->native_function(), fn);
 }
 
@@ -143,7 +143,7 @@ TEST_F(TestExprTree, TestExpression) {
                          func_desc->return_type());
   EXPECT_TRUE(sign == FunctionSignature("add", {int32(), int32()}, int32()));
 
-  ExprDecomposer decomposer(registry_, annotator);
+  ExprDecomposer decomposer(*registry_, annotator);
   ValueValidityPairPtr pair;
   auto status = decomposer.Decompose(*root_node, &pair);
   DCHECK_EQ(status.ok(), true) << status.message();
@@ -152,7 +152,7 @@ TEST_F(TestExprTree, TestExpression) {
   auto null_if_null = std::dynamic_pointer_cast<NonNullableFuncDex>(value);
 
   FunctionSignature signature("add", {int32(), int32()}, int32());
-  const NativeFunction* fn = registry_.LookupSignature(signature);
+  const NativeFunction* fn = registry_->LookupSignature(signature);
   EXPECT_EQ(null_if_null->native_function(), fn);
 }
 

From e62ec62e40b04b0bfce76d58369845d3aa96a419 Mon Sep 17 00:00:00 2001
From: Eero Lihavainen <eero.lihavainen@nitor.com>
Date: Wed, 8 Nov 2023 08:32:32 +0200
Subject: [PATCH 702/749] GH-38591: [Parquet][C++] Remove redundant open calls
 in `ParquetFileFormat::GetReaderAsync`  (#38621)

### Rationale for this change
There were duplicate method calls causing extra I/O operations, apparently unintentional from https://github.com/apache/arrow/commit/0793432ad0ef5cb598b7b1e61071cd4991bd1b8b.

### What changes are included in this PR?
Remove the extra method calls.

### Are these changes tested?

### Are there any user-facing changes?

* Closes: #38591

Authored-by: Eero Lihavainen <eero.lihavainen@nitor.com>
Signed-off-by: mwish <maplewish117@gmail.com>
---
 cpp/src/arrow/dataset/file_parquet.cc | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/cpp/src/arrow/dataset/file_parquet.cc b/cpp/src/arrow/dataset/file_parquet.cc
index d486f194f38a3..65ad70181f28a 100644
--- a/cpp/src/arrow/dataset/file_parquet.cc
+++ b/cpp/src/arrow/dataset/file_parquet.cc
@@ -504,11 +504,6 @@ Future<std::shared_ptr<parquet::arrow::FileReader>> ParquetFileFormat::GetReader
                                                          default_fragment_scan_options));
   auto properties = MakeReaderProperties(*this, parquet_scan_options.get(), source.path(),
                                          source.filesystem(), options->pool);
-  ARROW_ASSIGN_OR_RAISE(auto input, source.Open());
-  // TODO(ARROW-12259): workaround since we have Future<(move-only type)>
-  auto reader_fut = parquet::ParquetFileReader::OpenAsync(
-      std::move(input), std::move(properties), metadata);
-  auto path = source.path();
   auto self = checked_pointer_cast<const ParquetFileFormat>(shared_from_this());
 
   return source.OpenAsync().Then(

From 3d96bab9916e24e18255a2c2cde306a023108c5c Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@voltrondata.com>
Date: Wed, 8 Nov 2023 12:52:18 -0400
Subject: [PATCH 703/749] MINOR: [R] Fix .lintr config file for updated lintr
 dependency (#38639)

### Rationale for this change

The lint CI job is failing because an update to a dependency of lintr now does more strict DCF checking on the .lintr file

### What changes are included in this PR?

The 'license' field was wrapped in quotes so that .lintr passes validation

### Are these changes tested?

Yes, by existing CI job

### Are there any user-facing changes?

No

Authored-by: Dewey Dunnington <dewey@voltrondata.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 r/.lintr | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/r/.lintr b/r/.lintr
index 085ff45123411..d920f77e9bbd3 100644
--- a/r/.lintr
+++ b/r/.lintr
@@ -1,4 +1,4 @@
-license:  #  Licensed to the Apache Software Foundation (ASF) under one
+license:  '#  Licensed to the Apache Software Foundation (ASF) under one
   #  or more contributor license agreements.  See the NOTICE file
   #  distributed with this work for additional information
   #  regarding copyright ownership.  The ASF licenses this file
@@ -13,7 +13,7 @@ license:  #  Licensed to the Apache Software Foundation (ASF) under one
   #  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   #  KIND, either express or implied.  See the License for the
   #  specific language governing permissions and limitations
-  #  under the License.
+  #  under the License.'
 linters: linters_with_defaults(
   indentation_linter = NULL,
   line_length_linter = line_length_linter(120),

From db19a358cdf2b550b741fc7574dea38a6e32261b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Diego=20Fern=C3=A1ndez=20Giraldo?=
 <aiguo.fernandez@gmail.com>
Date: Wed, 8 Nov 2023 13:40:57 -0700
Subject: [PATCH 704/749] GH-38627: [Java][FlightRPC] Handle null parameter
 values (#38628)

### Rationale for this change

We want to make sure we correctly handle binding `null` values to JDBC parameters.
We also want better exceptions when handling parameter binding.

### What changes are included in this PR?

- Handle adding null values to parameters if it's a nullable vector, else throw `UnsupportedOperationException`
- For unsupported parameter types or casts, throw `UnsupportedOperationException` instead of `RuntimeException`
* Closes: #38627

Authored-by: Diego Fernandez <aiguo.fernandez@gmail.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../jdbc/converter/AvaticaParameterConverter.java    |  7 ++++++-
 .../impl/TimestampAvaticaParameterConverter.java     |  1 -
 .../driver/jdbc/utils/AvaticaParameterBinder.java    | 12 +++++++++---
 3 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
index c01e688f37396..db34a8c9e1582 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/AvaticaParameterConverter.java
@@ -33,10 +33,15 @@ public interface AvaticaParameterConverter {
    *
    * @param vector FieldVector that the parameter should be bound to.
    * @param typedValue TypedValue to bind as a parameter.
-   * @param index Vector index that the TypedValue should be bound to.
+   * @param index Vector index (0-indexed) that the TypedValue should be bound to.
    * @return Whether the value was set successfully.
    */
   boolean bindParameter(FieldVector vector, TypedValue typedValue, int index);
 
+  /**
+   * Create an AvaticaParameter from the given Field.
+   *
+   * @param field Arrow Field to generate an AvaticaParameter from.
+   */
   AvaticaParameter createParameter(Field field);
 }
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
index 3c1940b75cfa7..eb3316a1bdbed 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/converter/impl/TimestampAvaticaParameterConverter.java
@@ -41,7 +41,6 @@ public TimestampAvaticaParameterConverter(ArrowType.Timestamp type) {
 
   @Override
   public boolean bindParameter(FieldVector vector, TypedValue typedValue, int index) {
-    // FIXME: how should we handle TZ? Do we need to convert the value to the TZ on the vector?
     long value = (long) typedValue.toLocal();
     if (vector instanceof TimeStampSecVector) {
       ((TimeStampSecVector) vector).setSafe(index, value);
diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java
index c5be4697db7c5..9e805fc79bcf8 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/utils/AvaticaParameterBinder.java
@@ -102,12 +102,18 @@ public void bind(List<TypedValue> typedValues, int index) {
    */
   private void bind(FieldVector vector, TypedValue typedValue, int index) {
     try {
-      if (!vector.getField().getType().accept(new BinderVisitor(vector, typedValue, index))) {
-        throw new RuntimeException(
+      if (typedValue.value == null) {
+        if (vector.getField().isNullable()) {
+          vector.setNull(index);
+        } else {
+          throw new UnsupportedOperationException("Can't set null on non-nullable parameter");
+        }
+      } else if (!vector.getField().getType().accept(new BinderVisitor(vector, typedValue, index))) {
+        throw new UnsupportedOperationException(
                 String.format("Binding to vector type %s is not yet supported", vector.getClass()));
       }
     } catch (ClassCastException e) {
-      throw new RuntimeException(
+      throw new UnsupportedOperationException(
               String.format("Binding value of type %s is not yet supported for expected Arrow type %s",
                       typedValue.type, vector.getField().getType()));
     }

From 75a04030996261333e843a93f4981156372fa7f8 Mon Sep 17 00:00:00 2001
From: Thomas Newton <thomas.w.newton@gmail.com>
Date: Thu, 9 Nov 2023 04:11:22 +0000
Subject: [PATCH 705/749] GH-38335: [C++] Implement `GetFileInfo` for a single
 file in Azure filesystem (#38505)

### Rationale for this change

`GetFileInfo` is an important part of an Arrow filesystem implementation.

### What changes are included in this PR?
- Start `azurefs_internal` similar to GCS and S3 filesystems.
- Implement `HierarchicalNamespaceDetector`.
  - This does not use the obvious and simple implementation. It uses a more complicated option inspired by `hadoop-azure` that avoids requiring the significantly elevated permissions needed for `blob_service_client->GetAccountInfo()`.
  - This can't be detected an initialisation time of the filesystem because it requires a `container_name`.  Its packed into its only class so that the result can be cached.
- Implement `GetFileInfo` for single paths.
  - Supports hierarchical or flat namespace accounts and takes advantage of hierarchical namespace where possible to avoid unnecessary extra calls to blob storage. The performance difference is actually noticeable just from running the `GetFileInfoObjectWithNestedStructure` test against real flat and hierarchical accounts.  Its about 3 seconds with hierarchical namespace or 5 seconds with a flat namespace.
- Update tests with TODO(GH-38335) to now use this implementation of `GetFileInfo` to replace the temporary direct Azure SDK usage.
- Rename the main test fixture and introduce new ones for connecting to real blob storage. If details of real blob storage is not provided then the real blob storage tests will be skipped.

### Are these changes tested?

Yes. There are new Azurite based tests for everything that can be tested with Azurite.

There are also some tests that are designed to test against a real blob storage account. This is because [Azurite cannot emulate a hierarchical namespace account](https://github.com/Azure/Azurite/issues/553). Additionally some of the behaviour used to detect a hierarchical namespace account is different on Azurite compared to a real flat namespace account. These tests will be automatically skipped unless environment variables are provided with details for connecting to the relevant real storage accounts.

Initially I based the tests on the GCS filesystem but I added a few extras where I thought it was appropriate.

### Are there any user-facing changes?
Yes. `GetFileInfo` is now supported on the Azure filesystem.

* Closes: #38335

Lead-authored-by: Thomas Newton <thomas.w.newton@gmail.com>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 cpp/src/arrow/CMakeLists.txt                 |   4 +-
 cpp/src/arrow/filesystem/azurefs.cc          | 158 ++++++++--
 cpp/src/arrow/filesystem/azurefs_internal.cc |  88 ++++++
 cpp/src/arrow/filesystem/azurefs_internal.h  |  42 +++
 cpp/src/arrow/filesystem/azurefs_test.cc     | 288 ++++++++++++++-----
 cpp/src/arrow/filesystem/path_util.cc        |  11 +-
 cpp/src/arrow/filesystem/path_util.h         |   3 +
 7 files changed, 497 insertions(+), 97 deletions(-)
 create mode 100644 cpp/src/arrow/filesystem/azurefs_internal.cc
 create mode 100644 cpp/src/arrow/filesystem/azurefs_internal.h

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 9a6117011535e..101b089ba837f 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -502,8 +502,8 @@ if(ARROW_FILESYSTEM)
        filesystem/util_internal.cc)
 
   if(ARROW_AZURE)
-    list(APPEND ARROW_SRCS filesystem/azurefs.cc)
-    set_source_files_properties(filesystem/azurefs.cc
+    list(APPEND ARROW_SRCS filesystem/azurefs.cc filesystem/azurefs_internal.cc)
+    set_source_files_properties(filesystem/azurefs.cc filesystem/azurefs_internal.cc
                                 PROPERTIES SKIP_PRECOMPILE_HEADERS ON
                                            SKIP_UNITY_BUILD_INCLUSION ON)
   endif()
diff --git a/cpp/src/arrow/filesystem/azurefs.cc b/cpp/src/arrow/filesystem/azurefs.cc
index a04338d999d11..6359183d90bb4 100644
--- a/cpp/src/arrow/filesystem/azurefs.cc
+++ b/cpp/src/arrow/filesystem/azurefs.cc
@@ -16,8 +16,10 @@
 // under the License.
 
 #include "arrow/filesystem/azurefs.h"
+#include "arrow/filesystem/azurefs_internal.h"
 
 #include <azure/storage/blobs.hpp>
+#include <azure/storage/files/datalake.hpp>
 
 #include "arrow/buffer.h"
 #include "arrow/filesystem/path_util.h"
@@ -59,6 +61,7 @@ Status AzureOptions::ConfigureAccountKeyCredentials(const std::string& account_n
   credentials_kind = AzureCredentialsKind::StorageCredentials;
   return Status::OK();
 }
+
 namespace {
 
 // An AzureFileSystem represents a single Azure storage account. AzurePath describes a
@@ -79,18 +82,17 @@ struct AzurePath {
           "Expected an Azure object path of the form 'container/path...', got a URI: '",
           s, "'");
     }
-    const auto src = internal::RemoveTrailingSlash(s);
-    auto first_sep = src.find_first_of(internal::kSep);
+    auto first_sep = s.find_first_of(internal::kSep);
     if (first_sep == 0) {
       return Status::Invalid("Path cannot start with a separator ('", s, "')");
     }
     if (first_sep == std::string::npos) {
-      return AzurePath{std::string(src), std::string(src), "", {}};
+      return AzurePath{std::string(s), std::string(s), "", {}};
     }
     AzurePath path;
-    path.full_path = std::string(src);
-    path.container = std::string(src.substr(0, first_sep));
-    path.path_to_file = std::string(src.substr(first_sep + 1));
+    path.full_path = std::string(s);
+    path.container = std::string(s.substr(0, first_sep));
+    path.path_to_file = std::string(s.substr(first_sep + 1));
     path.path_to_file_parts = internal::SplitAbstractPath(path.path_to_file);
     RETURN_NOT_OK(Validate(path));
     return path;
@@ -146,11 +148,6 @@ Status ValidateFilePath(const AzurePath& path) {
   return Status::OK();
 }
 
-Status ErrorToStatus(const std::string& prefix,
-                     const Azure::Storage::StorageException& exception) {
-  return Status::IOError(prefix, " Azure Error: ", exception.what());
-}
-
 template <typename ArrowType>
 std::string FormatValue(typename TypeTraits<ArrowType>::CType value) {
   struct StringAppender {
@@ -316,11 +313,13 @@ class ObjectInputFile final : public io::RandomAccessFile {
       return Status::OK();
     } catch (const Azure::Storage::StorageException& exception) {
       if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
-        // Could be either container or blob not found.
         return PathNotFound(path_);
       }
-      return ErrorToStatus(
-          "When fetching properties for '" + blob_client_->GetUrl() + "': ", exception);
+      return internal::ExceptionToStatus(
+          "GetProperties failed for '" + blob_client_->GetUrl() +
+              "' with an unexpected Azure error. Can not initialise an ObjectInputFile "
+              "without knowing the file size.",
+          exception);
     }
   }
 
@@ -397,10 +396,12 @@ class ObjectInputFile final : public io::RandomAccessFile {
           ->DownloadTo(reinterpret_cast<uint8_t*>(out), nbytes, download_options)
           .Value.ContentRange.Length.Value();
     } catch (const Azure::Storage::StorageException& exception) {
-      return ErrorToStatus("When reading from '" + blob_client_->GetUrl() +
-                               "' at position " + std::to_string(position) + " for " +
-                               std::to_string(nbytes) + " bytes: ",
-                           exception);
+      return internal::ExceptionToStatus("DownloadTo from '" + blob_client_->GetUrl() +
+                                             "' at position " + std::to_string(position) +
+                                             " for " + std::to_string(nbytes) +
+                                             " bytes failed with an Azure error. ReadAt "
+                                             "failed to read the required byte range.",
+                                         exception);
     }
   }
 
@@ -444,7 +445,6 @@ class ObjectInputFile final : public io::RandomAccessFile {
   int64_t content_length_ = kNoSize;
   std::shared_ptr<const KeyValueMetadata> metadata_;
 };
-
 }  // namespace
 
 // -----------------------------------------------------------------------
@@ -453,27 +453,136 @@ class ObjectInputFile final : public io::RandomAccessFile {
 class AzureFileSystem::Impl {
  public:
   io::IOContext io_context_;
-  std::shared_ptr<Azure::Storage::Blobs::BlobServiceClient> service_client_;
+  std::unique_ptr<Azure::Storage::Files::DataLake::DataLakeServiceClient>
+      datalake_service_client_;
+  std::unique_ptr<Azure::Storage::Blobs::BlobServiceClient> blob_service_client_;
   AzureOptions options_;
+  internal::HierarchicalNamespaceDetector hierarchical_namespace_;
 
   explicit Impl(AzureOptions options, io::IOContext io_context)
       : io_context_(io_context), options_(std::move(options)) {}
 
   Status Init() {
-    service_client_ = std::make_shared<Azure::Storage::Blobs::BlobServiceClient>(
+    blob_service_client_ = std::make_unique<Azure::Storage::Blobs::BlobServiceClient>(
         options_.account_blob_url, options_.storage_credentials_provider);
+    datalake_service_client_ =
+        std::make_unique<Azure::Storage::Files::DataLake::DataLakeServiceClient>(
+            options_.account_dfs_url, options_.storage_credentials_provider);
+    RETURN_NOT_OK(hierarchical_namespace_.Init(datalake_service_client_.get()));
     return Status::OK();
   }
 
   const AzureOptions& options() const { return options_; }
 
+ public:
+  Result<FileInfo> GetFileInfo(const AzurePath& path) {
+    FileInfo info;
+    info.set_path(path.full_path);
+
+    if (path.container.empty()) {
+      DCHECK(path.path_to_file.empty());  // The path is invalid if the container is empty
+                                          // but not path_to_file.
+      // path must refer to the root of the Azure storage account. This is a directory,
+      // and there isn't any extra metadata to fetch.
+      info.set_type(FileType::Directory);
+      return info;
+    }
+    if (path.path_to_file.empty()) {
+      // path refers to a container. This is a directory if it exists.
+      auto container_client =
+          blob_service_client_->GetBlobContainerClient(path.container);
+      try {
+        auto properties = container_client.GetProperties();
+        info.set_type(FileType::Directory);
+        info.set_mtime(
+            std::chrono::system_clock::time_point(properties.Value.LastModified));
+        return info;
+      } catch (const Azure::Storage::StorageException& exception) {
+        if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
+          info.set_type(FileType::NotFound);
+          return info;
+        }
+        return internal::ExceptionToStatus(
+            "GetProperties for '" + container_client.GetUrl() +
+                "' failed with an unexpected Azure error. GetFileInfo is unable to "
+                "determine whether the container exists.",
+            exception);
+      }
+    }
+    auto file_client = datalake_service_client_->GetFileSystemClient(path.container)
+                           .GetFileClient(path.path_to_file);
+    try {
+      auto properties = file_client.GetProperties();
+      if (properties.Value.IsDirectory) {
+        info.set_type(FileType::Directory);
+      } else if (internal::HasTrailingSlash(path.path_to_file)) {
+        // For a path with a trailing slash a hierarchical namespace may return a blob
+        // with that trailing slash removed. For consistency with flat namespace and
+        // other filesystems we chose to return NotFound.
+        info.set_type(FileType::NotFound);
+        return info;
+      } else {
+        info.set_type(FileType::File);
+        info.set_size(properties.Value.FileSize);
+      }
+      info.set_mtime(
+          std::chrono::system_clock::time_point(properties.Value.LastModified));
+      return info;
+    } catch (const Azure::Storage::StorageException& exception) {
+      if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
+        ARROW_ASSIGN_OR_RAISE(auto hierarchical_namespace_enabled,
+                              hierarchical_namespace_.Enabled(path.container));
+        if (hierarchical_namespace_enabled) {
+          // If the hierarchical namespace is enabled, then the storage account will have
+          // explicit directories. Neither a file nor a directory was found.
+          info.set_type(FileType::NotFound);
+          return info;
+        }
+        // On flat namespace accounts there are no real directories. Directories are only
+        // implied by using `/` in the blob name.
+        Azure::Storage::Blobs::ListBlobsOptions list_blob_options;
+
+        // If listing the prefix `path.path_to_file` with trailing slash returns at least
+        // one result then `path` refers to an implied directory.
+        auto prefix = internal::EnsureTrailingSlash(path.path_to_file);
+        list_blob_options.Prefix = prefix;
+        // We only need to know if there is at least one result, so minimise page size
+        // for efficiency.
+        list_blob_options.PageSizeHint = 1;
+
+        try {
+          auto paged_list_result =
+              blob_service_client_->GetBlobContainerClient(path.container)
+                  .ListBlobs(list_blob_options);
+          if (paged_list_result.Blobs.size() > 0) {
+            info.set_type(FileType::Directory);
+          } else {
+            info.set_type(FileType::NotFound);
+          }
+          return info;
+        } catch (const Azure::Storage::StorageException& exception) {
+          return internal::ExceptionToStatus(
+              "ListBlobs for '" + prefix +
+                  "' failed with an unexpected Azure error. GetFileInfo is unable to "
+                  "determine whether the path should be considered an implied directory.",
+              exception);
+        }
+      }
+      return internal::ExceptionToStatus(
+          "GetProperties for '" + file_client.GetUrl() +
+              "' failed with an unexpected "
+              "Azure error. GetFileInfo is unable to determine whether the path exists.",
+          exception);
+    }
+  }
+
   Result<std::shared_ptr<ObjectInputFile>> OpenInputFile(const std::string& s,
                                                          AzureFileSystem* fs) {
     ARROW_RETURN_NOT_OK(internal::AssertNoTrailingSlash(s));
     ARROW_ASSIGN_OR_RAISE(auto path, AzurePath::FromString(s));
     RETURN_NOT_OK(ValidateFilePath(path));
     auto blob_client = std::make_shared<Azure::Storage::Blobs::BlobClient>(
-        service_client_->GetBlobContainerClient(path.container)
+        blob_service_client_->GetBlobContainerClient(path.container)
             .GetBlobClient(path.path_to_file));
 
     auto ptr =
@@ -494,7 +603,7 @@ class AzureFileSystem::Impl {
     ARROW_ASSIGN_OR_RAISE(auto path, AzurePath::FromString(info.path()));
     RETURN_NOT_OK(ValidateFilePath(path));
     auto blob_client = std::make_shared<Azure::Storage::Blobs::BlobClient>(
-        service_client_->GetBlobContainerClient(path.container)
+        blob_service_client_->GetBlobContainerClient(path.container)
             .GetBlobClient(path.path_to_file));
 
     auto ptr = std::make_shared<ObjectInputFile>(blob_client, fs->io_context(),
@@ -518,7 +627,8 @@ bool AzureFileSystem::Equals(const FileSystem& other) const {
 }
 
 Result<FileInfo> AzureFileSystem::GetFileInfo(const std::string& path) {
-  return Status::NotImplemented("The Azure FileSystem is not fully implemented");
+  ARROW_ASSIGN_OR_RAISE(auto p, AzurePath::FromString(path));
+  return impl_->GetFileInfo(p);
 }
 
 Result<FileInfoVector> AzureFileSystem::GetFileInfo(const FileSelector& select) {
diff --git a/cpp/src/arrow/filesystem/azurefs_internal.cc b/cpp/src/arrow/filesystem/azurefs_internal.cc
new file mode 100644
index 0000000000000..3e545d670cb04
--- /dev/null
+++ b/cpp/src/arrow/filesystem/azurefs_internal.cc
@@ -0,0 +1,88 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "arrow/filesystem/azurefs_internal.h"
+
+#include <azure/storage/files/datalake.hpp>
+
+#include "arrow/result.h"
+
+namespace arrow::fs::internal {
+
+Status ExceptionToStatus(const std::string& prefix,
+                         const Azure::Storage::StorageException& exception) {
+  return Status::IOError(prefix, " Azure Error: ", exception.what());
+}
+
+Status HierarchicalNamespaceDetector::Init(
+    Azure::Storage::Files::DataLake::DataLakeServiceClient* datalake_service_client) {
+  datalake_service_client_ = datalake_service_client;
+  return Status::OK();
+}
+
+Result<bool> HierarchicalNamespaceDetector::Enabled(const std::string& container_name) {
+  // Hierarchical namespace can't easily be changed after the storage account is created
+  // and its common across all containers in the storage account. Do nothing until we've
+  // checked for a cached result.
+  if (enabled_.has_value()) {
+    return enabled_.value();
+  }
+
+  // This approach is inspired by hadoop-azure
+  // https://github.com/apache/hadoop/blob/7c6af6a5f626d18d68b656d085cc23e4c1f7a1ef/hadoop-tools/hadoop-azure/src/main/java/org/apache/hadoop/fs/azurebfs/AzureBlobFileSystemStore.java#L356.
+  // Unfortunately `blob_service_client->GetAccountInfo()` requires significantly
+  // elevated permissions.
+  // https://learn.microsoft.com/en-us/rest/api/storageservices/get-blob-service-properties?tabs=azure-ad#authorization
+  auto filesystem_client = datalake_service_client_->GetFileSystemClient(container_name);
+  auto directory_client = filesystem_client.GetDirectoryClient("/");
+  try {
+    directory_client.GetAccessControlList();
+    enabled_ = true;
+  } catch (const Azure::Storage::StorageException& exception) {
+    // GetAccessControlList will fail on storage accounts without hierarchical
+    // namespace enabled.
+
+    if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::BadRequest ||
+        exception.StatusCode == Azure::Core::Http::HttpStatusCode::Conflict) {
+      // Flat namespace storage accounts with soft delete enabled return
+      // Conflict - This endpoint does not support BlobStorageEvents or SoftDelete
+      // otherwise it returns: BadRequest - This operation is only supported on a
+      // hierarchical namespace account.
+      enabled_ = false;
+    } else if (exception.StatusCode == Azure::Core::Http::HttpStatusCode::NotFound) {
+      // Azurite returns NotFound.
+      try {
+        filesystem_client.GetProperties();
+        enabled_ = false;
+      } catch (const Azure::Storage::StorageException& exception) {
+        return ExceptionToStatus("Failed to confirm '" + filesystem_client.GetUrl() +
+                                     "' is an accessible container. Therefore the "
+                                     "hierarchical namespace check was invalid.",
+                                 exception);
+      }
+    } else {
+      return ExceptionToStatus(
+          "GetAccessControlList for '" + directory_client.GetUrl() +
+              "' failed with an unexpected Azure error, while checking "
+              "whether the storage account has hierarchical namespace enabled.",
+          exception);
+    }
+  }
+  return enabled_.value();
+}
+
+}  // namespace arrow::fs::internal
diff --git a/cpp/src/arrow/filesystem/azurefs_internal.h b/cpp/src/arrow/filesystem/azurefs_internal.h
new file mode 100644
index 0000000000000..c3da96239a18f
--- /dev/null
+++ b/cpp/src/arrow/filesystem/azurefs_internal.h
@@ -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.
+
+#pragma once
+
+#include <optional>
+
+#include <azure/storage/files/datalake.hpp>
+
+#include "arrow/result.h"
+
+namespace arrow::fs::internal {
+
+Status ExceptionToStatus(const std::string& prefix,
+                         const Azure::Storage::StorageException& exception);
+
+class HierarchicalNamespaceDetector {
+ public:
+  Status Init(
+      Azure::Storage::Files::DataLake::DataLakeServiceClient* datalake_service_client);
+  Result<bool> Enabled(const std::string& container_name);
+
+ private:
+  Azure::Storage::Files::DataLake::DataLakeServiceClient* datalake_service_client_;
+  std::optional<bool> enabled_;
+};
+
+}  // namespace arrow::fs::internal
diff --git a/cpp/src/arrow/filesystem/azurefs_test.cc b/cpp/src/arrow/filesystem/azurefs_test.cc
index f57fc4d8140a0..c08a4b50b77a8 100644
--- a/cpp/src/arrow/filesystem/azurefs_test.cc
+++ b/cpp/src/arrow/filesystem/azurefs_test.cc
@@ -34,6 +34,7 @@
 #include <boost/process.hpp>
 
 #include "arrow/filesystem/azurefs.h"
+#include "arrow/filesystem/azurefs_internal.h"
 
 #include <random>
 #include <string>
@@ -46,7 +47,10 @@
 #include <azure/identity/managed_identity_credential.hpp>
 #include <azure/storage/blobs.hpp>
 #include <azure/storage/common/storage_credential.hpp>
+#include <azure/storage/files/datalake.hpp>
 
+#include "arrow/filesystem/test_util.h"
+#include "arrow/result.h"
 #include "arrow/testing/gtest_util.h"
 #include "arrow/testing/util.h"
 #include "arrow/util/io_util.h"
@@ -139,34 +143,37 @@ TEST(AzureFileSystem, OptionsCompare) {
   EXPECT_TRUE(options.Equals(options));
 }
 
-class TestAzureFileSystem : public ::testing::Test {
+class AzureFileSystemTest : public ::testing::Test {
  public:
   std::shared_ptr<FileSystem> fs_;
-  std::shared_ptr<Azure::Storage::Blobs::BlobServiceClient> service_client_;
+  std::unique_ptr<Azure::Storage::Blobs::BlobServiceClient> blob_service_client_;
+  std::unique_ptr<Azure::Storage::Files::DataLake::DataLakeServiceClient>
+      datalake_service_client_;
+  AzureOptions options_;
   std::mt19937_64 generator_;
   std::string container_name_;
+  bool suite_skipped_ = false;
 
-  TestAzureFileSystem() : generator_(std::random_device()()) {}
+  AzureFileSystemTest() : generator_(std::random_device()()) {}
 
-  AzureOptions MakeOptions() {
-    const std::string& account_name = GetAzuriteEnv()->account_name();
-    const std::string& account_key = GetAzuriteEnv()->account_key();
-    AzureOptions options;
-    options.backend = AzureBackend::Azurite;
-    ARROW_EXPECT_OK(options.ConfigureAccountKeyCredentials(account_name, account_key));
-    return options;
-  }
+  virtual Result<AzureOptions> MakeOptions() = 0;
 
   void SetUp() override {
-    ASSERT_THAT(GetAzuriteEnv(), NotNull());
-    ASSERT_OK(GetAzuriteEnv()->status());
-
-    container_name_ = RandomChars(32);
     auto options = MakeOptions();
-    service_client_ = std::make_shared<Azure::Storage::Blobs::BlobServiceClient>(
-        options.account_blob_url, options.storage_credentials_provider);
-    ASSERT_OK_AND_ASSIGN(fs_, AzureFileSystem::Make(options));
-    auto container_client = service_client_->GetBlobContainerClient(container_name_);
+    if (options.ok()) {
+      options_ = *options;
+    } else {
+      suite_skipped_ = true;
+      GTEST_SKIP() << options.status().message();
+    }
+    container_name_ = RandomChars(32);
+    blob_service_client_ = std::make_unique<Azure::Storage::Blobs::BlobServiceClient>(
+        options_.account_blob_url, options_.storage_credentials_provider);
+    datalake_service_client_ =
+        std::make_unique<Azure::Storage::Files::DataLake::DataLakeServiceClient>(
+            options_.account_dfs_url, options_.storage_credentials_provider);
+    ASSERT_OK_AND_ASSIGN(fs_, AzureFileSystem::Make(options_));
+    auto container_client = blob_service_client_->GetBlobContainerClient(container_name_);
     container_client.CreateIfNotExists();
 
     auto blob_client = container_client.GetBlockBlobClient(PreexistingObjectName());
@@ -175,10 +182,13 @@ class TestAzureFileSystem : public ::testing::Test {
   }
 
   void TearDown() override {
-    auto containers = service_client_->ListBlobContainers();
-    for (auto container : containers.BlobContainers) {
-      auto container_client = service_client_->GetBlobContainerClient(container.Name);
-      container_client.DeleteIfExists();
+    if (!suite_skipped_) {
+      auto containers = blob_service_client_->ListBlobContainers();
+      for (auto container : containers.BlobContainers) {
+        auto container_client =
+            blob_service_client_->GetBlobContainerClient(container.Name);
+        container_client.DeleteIfExists();
+      }
     }
   }
 
@@ -218,15 +228,175 @@ class TestAzureFileSystem : public ::testing::Test {
   void UploadLines(const std::vector<std::string>& lines, const char* path_to_file,
                    int total_size) {
     // TODO(GH-38333): Switch to using Azure filesystem to write once its implemented.
-    auto blob_client = service_client_->GetBlobContainerClient(PreexistingContainerName())
-                           .GetBlockBlobClient(path_to_file);
+    auto blob_client =
+        blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+            .GetBlockBlobClient(path_to_file);
     std::string all_lines = std::accumulate(lines.begin(), lines.end(), std::string(""));
     blob_client.UploadFrom(reinterpret_cast<const uint8_t*>(all_lines.data()),
                            total_size);
   }
+
+  void RunGetFileInfoObjectWithNestedStructureTest();
+  void RunGetFileInfoObjectTest();
+};
+
+class AzuriteFileSystemTest : public AzureFileSystemTest {
+  Result<AzureOptions> MakeOptions() {
+    EXPECT_THAT(GetAzuriteEnv(), NotNull());
+    ARROW_EXPECT_OK(GetAzuriteEnv()->status());
+    AzureOptions options;
+    options.backend = AzureBackend::Azurite;
+    ARROW_EXPECT_OK(options.ConfigureAccountKeyCredentials(
+        GetAzuriteEnv()->account_name(), GetAzuriteEnv()->account_key()));
+    return options;
+  }
+};
+
+class AzureFlatNamespaceFileSystemTest : public AzureFileSystemTest {
+  Result<AzureOptions> MakeOptions() override {
+    AzureOptions options;
+    const auto account_key = std::getenv("AZURE_FLAT_NAMESPACE_ACCOUNT_KEY");
+    const auto account_name = std::getenv("AZURE_FLAT_NAMESPACE_ACCOUNT_NAME");
+    if (account_key && account_name) {
+      RETURN_NOT_OK(options.ConfigureAccountKeyCredentials(account_name, account_key));
+      return options;
+    }
+    return Status::Cancelled(
+        "Connection details not provided for a real flat namespace "
+        "account.");
+  }
 };
 
-TEST_F(TestAzureFileSystem, OpenInputStreamString) {
+class AzureHierarchicalNamespaceFileSystemTest : public AzureFileSystemTest {
+  Result<AzureOptions> MakeOptions() override {
+    AzureOptions options;
+    const auto account_key = std::getenv("AZURE_HIERARCHICAL_NAMESPACE_ACCOUNT_KEY");
+    const auto account_name = std::getenv("AZURE_HIERARCHICAL_NAMESPACE_ACCOUNT_NAME");
+    if (account_key && account_name) {
+      RETURN_NOT_OK(options.ConfigureAccountKeyCredentials(account_name, account_key));
+      return options;
+    }
+    return Status::Cancelled(
+        "Connection details not provided for a real hierarchical namespace "
+        "account.");
+  }
+};
+
+TEST_F(AzureFlatNamespaceFileSystemTest, DetectHierarchicalNamespace) {
+  auto hierarchical_namespace = internal::HierarchicalNamespaceDetector();
+  ASSERT_OK(hierarchical_namespace.Init(datalake_service_client_.get()));
+  ASSERT_OK_AND_EQ(false, hierarchical_namespace.Enabled(PreexistingContainerName()));
+}
+
+TEST_F(AzureHierarchicalNamespaceFileSystemTest, DetectHierarchicalNamespace) {
+  auto hierarchical_namespace = internal::HierarchicalNamespaceDetector();
+  ASSERT_OK(hierarchical_namespace.Init(datalake_service_client_.get()));
+  ASSERT_OK_AND_EQ(true, hierarchical_namespace.Enabled(PreexistingContainerName()));
+}
+
+TEST_F(AzuriteFileSystemTest, DetectHierarchicalNamespace) {
+  auto hierarchical_namespace = internal::HierarchicalNamespaceDetector();
+  ASSERT_OK(hierarchical_namespace.Init(datalake_service_client_.get()));
+  ASSERT_OK_AND_EQ(false, hierarchical_namespace.Enabled(PreexistingContainerName()));
+}
+
+TEST_F(AzuriteFileSystemTest, DetectHierarchicalNamespaceFailsWithMissingContainer) {
+  auto hierarchical_namespace = internal::HierarchicalNamespaceDetector();
+  ASSERT_OK(hierarchical_namespace.Init(datalake_service_client_.get()));
+  ASSERT_NOT_OK(hierarchical_namespace.Enabled("non-existent-container"));
+}
+
+TEST_F(AzuriteFileSystemTest, GetFileInfoAccount) {
+  AssertFileInfo(fs_.get(), "", FileType::Directory);
+
+  // URI
+  ASSERT_RAISES(Invalid, fs_->GetFileInfo("abfs://"));
+}
+
+TEST_F(AzuriteFileSystemTest, GetFileInfoContainer) {
+  AssertFileInfo(fs_.get(), PreexistingContainerName(), FileType::Directory);
+
+  AssertFileInfo(fs_.get(), "non-existent-container", FileType::NotFound);
+
+  // URI
+  ASSERT_RAISES(Invalid, fs_->GetFileInfo("abfs://" + PreexistingContainerName()));
+}
+
+void AzureFileSystemTest::RunGetFileInfoObjectWithNestedStructureTest() {
+  // Adds detailed tests to handle cases of different edge cases
+  // with directory naming conventions (e.g. with and without slashes).
+  constexpr auto kObjectName = "test-object-dir/some_other_dir/another_dir/foo";
+  // TODO(GH-38333): Switch to using Azure filesystem to write once its implemented.
+  blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+      .GetBlockBlobClient(kObjectName)
+      .UploadFrom(reinterpret_cast<const uint8_t*>(kLoremIpsum), strlen(kLoremIpsum));
+
+  // 0 is immediately after "/" lexicographically, ensure that this doesn't
+  // cause unexpected issues.
+  // TODO(GH-38333): Switch to using Azure filesystem to write once its implemented.
+  blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+      .GetBlockBlobClient("test-object-dir/some_other_dir0")
+      .UploadFrom(reinterpret_cast<const uint8_t*>(kLoremIpsum), strlen(kLoremIpsum));
+
+  blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+      .GetBlockBlobClient(std::string(kObjectName) + "0")
+      .UploadFrom(reinterpret_cast<const uint8_t*>(kLoremIpsum), strlen(kLoremIpsum));
+
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + kObjectName, FileType::File);
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + kObjectName + "/",
+                 FileType::NotFound);
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-object-dir",
+                 FileType::Directory);
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-object-dir/",
+                 FileType::Directory);
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-object-dir/some_other_dir",
+                 FileType::Directory);
+  AssertFileInfo(fs_.get(),
+                 PreexistingContainerPath() + "test-object-dir/some_other_dir/",
+                 FileType::Directory);
+
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-object-di",
+                 FileType::NotFound);
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-object-dir/some_other_di",
+                 FileType::NotFound);
+}
+
+TEST_F(AzuriteFileSystemTest, GetFileInfoObjectWithNestedStructure) {
+  RunGetFileInfoObjectWithNestedStructureTest();
+}
+
+TEST_F(AzureHierarchicalNamespaceFileSystemTest, GetFileInfoObjectWithNestedStructure) {
+  RunGetFileInfoObjectWithNestedStructureTest();
+  datalake_service_client_->GetFileSystemClient(PreexistingContainerName())
+      .GetDirectoryClient("test-empty-object-dir")
+      .Create();
+
+  AssertFileInfo(fs_.get(), PreexistingContainerPath() + "test-empty-object-dir",
+                 FileType::Directory);
+}
+
+void AzureFileSystemTest::RunGetFileInfoObjectTest() {
+  auto object_properties =
+      blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+          .GetBlobClient(PreexistingObjectName())
+          .GetProperties()
+          .Value;
+
+  AssertFileInfo(fs_.get(), PreexistingObjectPath(), FileType::File,
+                 std::chrono::system_clock::time_point(object_properties.LastModified),
+                 static_cast<int64_t>(object_properties.BlobSize));
+
+  // URI
+  ASSERT_RAISES(Invalid, fs_->GetFileInfo("abfs://" + PreexistingObjectName()));
+}
+
+TEST_F(AzuriteFileSystemTest, GetFileInfoObject) { RunGetFileInfoObjectTest(); }
+
+TEST_F(AzureHierarchicalNamespaceFileSystemTest, GetFileInfoObject) {
+  RunGetFileInfoObjectTest();
+}
+
+TEST_F(AzuriteFileSystemTest, OpenInputStreamString) {
   std::shared_ptr<io::InputStream> stream;
   ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
 
@@ -234,7 +404,7 @@ TEST_F(TestAzureFileSystem, OpenInputStreamString) {
   EXPECT_EQ(buffer->ToString(), kLoremIpsum);
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamStringBuffers) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamStringBuffers) {
   std::shared_ptr<io::InputStream> stream;
   ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
 
@@ -248,10 +418,8 @@ TEST_F(TestAzureFileSystem, OpenInputStreamStringBuffers) {
   EXPECT_EQ(contents, kLoremIpsum);
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamInfo) {
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(PreexistingObjectPath()));
-  arrow::fs::FileInfo info(PreexistingObjectPath(), FileType::File);
+TEST_F(AzuriteFileSystemTest, OpenInputStreamInfo) {
+  ASSERT_OK_AND_ASSIGN(auto info, fs_->GetFileInfo(PreexistingObjectPath()));
 
   std::shared_ptr<io::InputStream> stream;
   ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(info));
@@ -260,10 +428,10 @@ TEST_F(TestAzureFileSystem, OpenInputStreamInfo) {
   EXPECT_EQ(buffer->ToString(), kLoremIpsum);
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamEmpty) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamEmpty) {
   const auto path_to_file = "empty-object.txt";
   const auto path = PreexistingContainerPath() + path_to_file;
-  service_client_->GetBlobContainerClient(PreexistingContainerName())
+  blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
       .GetBlockBlobClient(path_to_file)
       .UploadFrom(nullptr, 0);
 
@@ -274,27 +442,23 @@ TEST_F(TestAzureFileSystem, OpenInputStreamEmpty) {
   EXPECT_EQ(size, 0);
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamNotFound) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamNotFound) {
   ASSERT_RAISES(IOError, fs_->OpenInputStream(NotFoundObjectPath()));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamInfoInvalid) {
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(PreexistingBucketPath()));
-  arrow::fs::FileInfo info(PreexistingContainerPath(), FileType::Directory);
+TEST_F(AzuriteFileSystemTest, OpenInputStreamInfoInvalid) {
+  ASSERT_OK_AND_ASSIGN(auto info, fs_->GetFileInfo(PreexistingContainerPath()));
   ASSERT_RAISES(IOError, fs_->OpenInputStream(info));
 
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(NotFoundObjectPath()));
-  arrow::fs::FileInfo info2(PreexistingContainerPath(), FileType::NotFound);
+  ASSERT_OK_AND_ASSIGN(auto info2, fs_->GetFileInfo(NotFoundObjectPath()));
   ASSERT_RAISES(IOError, fs_->OpenInputStream(info2));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamUri) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamUri) {
   ASSERT_RAISES(Invalid, fs_->OpenInputStream("abfss://" + PreexistingObjectPath()));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamTrailingSlash) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamTrailingSlash) {
   ASSERT_RAISES(IOError, fs_->OpenInputStream(PreexistingObjectPath() + '/'));
 }
 
@@ -321,7 +485,8 @@ std::shared_ptr<const KeyValueMetadata> NormalizerKeyValueMetadata(
         value = "2023-10-31T08:15:20Z";
       }
     } else if (key == "ETag") {
-      if (internal::StartsWith(value, "\"") && internal::EndsWith(value, "\"")) {
+      if (arrow::internal::StartsWith(value, "\"") &&
+          arrow::internal::EndsWith(value, "\"")) {
         // Valid value
         value = "\"ETagValue\"";
       }
@@ -332,7 +497,7 @@ std::shared_ptr<const KeyValueMetadata> NormalizerKeyValueMetadata(
 }
 };  // namespace
 
-TEST_F(TestAzureFileSystem, OpenInputStreamReadMetadata) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamReadMetadata) {
   std::shared_ptr<io::InputStream> stream;
   ASSERT_OK_AND_ASSIGN(stream, fs_->OpenInputStream(PreexistingObjectPath()));
 
@@ -362,7 +527,7 @@ TEST_F(TestAzureFileSystem, OpenInputStreamReadMetadata) {
       NormalizerKeyValueMetadata(actual)->ToString());
 }
 
-TEST_F(TestAzureFileSystem, OpenInputStreamClosed) {
+TEST_F(AzuriteFileSystemTest, OpenInputStreamClosed) {
   ASSERT_OK_AND_ASSIGN(auto stream, fs_->OpenInputStream(PreexistingObjectPath()));
   ASSERT_OK(stream->Close());
   std::array<char, 16> buffer{};
@@ -371,7 +536,7 @@ TEST_F(TestAzureFileSystem, OpenInputStreamClosed) {
   ASSERT_RAISES(Invalid, stream->Tell());
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileMixedReadVsReadAt) {
+TEST_F(AzuriteFileSystemTest, OpenInputFileMixedReadVsReadAt) {
   // Create a file large enough to make the random access tests non-trivial.
   auto constexpr kLineWidth = 100;
   auto constexpr kLineCount = 4096;
@@ -417,7 +582,7 @@ TEST_F(TestAzureFileSystem, OpenInputFileMixedReadVsReadAt) {
   }
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileRandomSeek) {
+TEST_F(AzuriteFileSystemTest, OpenInputFileRandomSeek) {
   // Create a file large enough to make the random access tests non-trivial.
   auto constexpr kLineWidth = 100;
   auto constexpr kLineCount = 4096;
@@ -445,14 +610,15 @@ TEST_F(TestAzureFileSystem, OpenInputFileRandomSeek) {
   }
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileIoContext) {
+TEST_F(AzuriteFileSystemTest, OpenInputFileIoContext) {
   // Create a test file.
   const auto path_to_file = "OpenInputFileIoContext/object-name";
   const auto path = PreexistingContainerPath() + path_to_file;
   const std::string contents = "The quick brown fox jumps over the lazy dog";
 
-  auto blob_client = service_client_->GetBlobContainerClient(PreexistingContainerName())
-                         .GetBlockBlobClient(path_to_file);
+  auto blob_client =
+      blob_service_client_->GetBlobContainerClient(PreexistingContainerName())
+          .GetBlockBlobClient(path_to_file);
   blob_client.UploadFrom(reinterpret_cast<const uint8_t*>(contents.data()),
                          contents.length());
 
@@ -461,10 +627,8 @@ TEST_F(TestAzureFileSystem, OpenInputFileIoContext) {
   EXPECT_EQ(fs_->io_context().external_id(), file->io_context().external_id());
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileInfo) {
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(PreexistingObjectPath()));
-  arrow::fs::FileInfo info(PreexistingObjectPath(), FileType::File);
+TEST_F(AzuriteFileSystemTest, OpenInputFileInfo) {
+  ASSERT_OK_AND_ASSIGN(auto info, fs_->GetFileInfo(PreexistingObjectPath()));
 
   std::shared_ptr<io::RandomAccessFile> file;
   ASSERT_OK_AND_ASSIGN(file, fs_->OpenInputFile(info));
@@ -478,23 +642,19 @@ TEST_F(TestAzureFileSystem, OpenInputFileInfo) {
   EXPECT_EQ(std::string(buffer.data(), size), expected);
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileNotFound) {
+TEST_F(AzuriteFileSystemTest, OpenInputFileNotFound) {
   ASSERT_RAISES(IOError, fs_->OpenInputFile(NotFoundObjectPath()));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileInfoInvalid) {
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(PreexistingContainerPath()));
-  arrow::fs::FileInfo info(PreexistingContainerPath(), FileType::File);
+TEST_F(AzuriteFileSystemTest, OpenInputFileInfoInvalid) {
+  ASSERT_OK_AND_ASSIGN(auto info, fs_->GetFileInfo(PreexistingContainerPath()));
   ASSERT_RAISES(IOError, fs_->OpenInputFile(info));
 
-  // TODO(GH-38335): When implemented use ASSERT_OK_AND_ASSIGN(info,
-  // fs->GetFileInfo(NotFoundObjectPath()));
-  arrow::fs::FileInfo info2(NotFoundObjectPath(), FileType::NotFound);
+  ASSERT_OK_AND_ASSIGN(auto info2, fs_->GetFileInfo(NotFoundObjectPath()));
   ASSERT_RAISES(IOError, fs_->OpenInputFile(info2));
 }
 
-TEST_F(TestAzureFileSystem, OpenInputFileClosed) {
+TEST_F(AzuriteFileSystemTest, OpenInputFileClosed) {
   ASSERT_OK_AND_ASSIGN(auto stream, fs_->OpenInputFile(PreexistingObjectPath()));
   ASSERT_OK(stream->Close());
   std::array<char, 16> buffer{};
diff --git a/cpp/src/arrow/filesystem/path_util.cc b/cpp/src/arrow/filesystem/path_util.cc
index 90af3c66ff8d4..46ea436a9f31a 100644
--- a/cpp/src/arrow/filesystem/path_util.cc
+++ b/cpp/src/arrow/filesystem/path_util.cc
@@ -191,18 +191,15 @@ std::string_view RemoveLeadingSlash(std::string_view key) {
 }
 
 Status AssertNoTrailingSlash(std::string_view key) {
-  if (key.back() == '/') {
+  if (HasTrailingSlash(key)) {
     return NotAFile(key);
   }
   return Status::OK();
 }
 
-bool HasLeadingSlash(std::string_view key) {
-  if (key.front() != '/') {
-    return false;
-  }
-  return true;
-}
+bool HasTrailingSlash(std::string_view key) { return key.back() == '/'; }
+
+bool HasLeadingSlash(std::string_view key) { return key.front() == '/'; }
 
 Result<std::string> MakeAbstractPathRelative(const std::string& base,
                                              const std::string& path) {
diff --git a/cpp/src/arrow/filesystem/path_util.h b/cpp/src/arrow/filesystem/path_util.h
index 13a74b7fa12c8..2c8c123e779f4 100644
--- a/cpp/src/arrow/filesystem/path_util.h
+++ b/cpp/src/arrow/filesystem/path_util.h
@@ -94,6 +94,9 @@ std::string_view RemoveTrailingSlash(std::string_view s, bool preserve_root = fa
 ARROW_EXPORT
 Status AssertNoTrailingSlash(std::string_view s);
 
+ARROW_EXPORT
+bool HasTrailingSlash(std::string_view s);
+
 ARROW_EXPORT
 bool HasLeadingSlash(std::string_view s);
 

From 9569be83adb917c8ac9e024e3e5d7bc78829608e Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Wed, 8 Nov 2023 23:39:33 -0500
Subject: [PATCH 706/749] GH-38439: [Java][CI] Use Eclipse Temurin for all Java
 CI linux jobs (#38440)

### Rationale for this change

Use the same JDK vendor for all linux CI jobs and upgrade maven to latest version.

### What changes are included in this PR?

* Eclipse Temurin image for Ubuntu is used for JDK 8 and 11
* maven is upgraded to 3.9.5 for all Ubuntu jobs

### Are these changes tested?

This will be tested in CI.

### Are there any user-facing changes?

No, just a developer change when using docker/archery. The image name is now `java` instead of `eclipse-java` and `debian-java`.
* Closes: #38439

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: Jacob Wujciak-Jens <jacob@wujciak.de>
---
 .github/workflows/java.yml               | 23 ++++----------------
 docker-compose.yml                       | 27 ++++++------------------
 docs/source/developers/java/building.rst |  4 ++--
 3 files changed, 13 insertions(+), 41 deletions(-)

diff --git a/.github/workflows/java.yml b/.github/workflows/java.yml
index 444bec2c73b61..69adc184b7fe7 100644
--- a/.github/workflows/java.yml
+++ b/.github/workflows/java.yml
@@ -49,8 +49,8 @@ env:
 
 jobs:
 
-  debian:
-    name: ${{ matrix.title }}
+  ubuntu:
+    name: AMD64 Ubuntu 22.04 Java JDK ${{ matrix.jdk }} Maven ${{ matrix.maven }}
     runs-on: ubuntu-latest
     if: ${{ !contains(github.event.pull_request.title, 'WIP') }}
     timeout-minutes: 30
@@ -58,23 +58,8 @@ jobs:
       fail-fast: false
       matrix:
         jdk: [8, 11, 17, 21]
-        include:
-        - jdk: 8
-          title: AMD64 Debian 9 Java JDK 8 Maven 3.5.4
-          maven: 3.5.4
-          image: debian-java
-        - jdk: 11
-          title: AMD64 Debian 9 Java JDK 11 Maven 3.6.2
-          maven: 3.6.2
-          image: debian-java
-        - jdk: 17
-          title: AMD64 Ubuntu 22.04 Java JDK 17 Maven 3.9.4
-          maven: 3.9.4
-          image: eclipse-java
-        - jdk: 21
-          title: AMD64 Ubuntu 22.04 Java JDK 21 Maven 3.9.4
-          maven: 3.9.4
-          image: eclipse-java
+        maven: [3.9.5]
+        image: [java]
     env:
       JDK: ${{ matrix.jdk }}
       MAVEN: ${{ matrix.maven }}
diff --git a/docker-compose.yml b/docker-compose.yml
index bbe4e65c10c43..e2c993ee9ea41 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -135,11 +135,10 @@ x-hierarchy:
   - debian-go:
     - debian-go-cgo
     - debian-go-cgo-python
-  - debian-java
   - debian-js
-  - eclipse-java
   - fedora-cpp:
     - fedora-python
+  - java
   - python-sdist
   - ubuntu-cpp:
     - ubuntu-cpp-static
@@ -1674,14 +1673,14 @@ services:
 
   ################################ Java #######################################
 
-  debian-java:
+  java:
     # Usage:
-    #   docker-compose build debian-java
-    #   docker-compose run debian-java
+    #   docker-compose build java
+    #   docker-compose run java
     # Parameters:
-    #   MAVEN: 3.5.4, 3.6.2
-    #   JDK: 8, 11
-    image: ${ARCH}/maven:${MAVEN}-jdk-${JDK}
+    #   MAVEN: 3.9.5
+    #   JDK: 8, 11, 17, 21
+    image: ${ARCH}/maven:${MAVEN}-eclipse-temurin-${JDK}
     shm_size: *shm-size
     volumes: &java-volumes
       - .:/arrow:delegated
@@ -1691,18 +1690,6 @@ services:
         /arrow/ci/scripts/java_build.sh /arrow /build &&
         /arrow/ci/scripts/java_test.sh /arrow /build"
 
-  eclipse-java:
-    # Usage:
-    #   docker-compose build eclipse-java
-    #   docker-compose run eclipse-java
-    # Parameters:
-    #   MAVEN: 3.9.4
-    #   JDK: 17, 21
-    image: ${ARCH}/maven:${MAVEN}-eclipse-temurin-${JDK}
-    shm_size: *shm-size
-    volumes: *java-volumes
-    command: *java-command
-
   ############################## Integration ##################################
 
   conda-integration:
diff --git a/docs/source/developers/java/building.rst b/docs/source/developers/java/building.rst
index 061c616d4b971..8b2a504631fdb 100644
--- a/docs/source/developers/java/building.rst
+++ b/docs/source/developers/java/building.rst
@@ -76,7 +76,7 @@ Docker compose
     $ cd arrow/java
     $ export JAVA_HOME=<absolute path to your java home>
     $ java --version
-    $ docker-compose run debian-java
+    $ docker-compose run java
 
 Archery
 ~~~~~~~
@@ -86,7 +86,7 @@ Archery
     $ cd arrow/java
     $ export JAVA_HOME=<absolute path to your java home>
     $ java --version
-    $ archery docker run debian-java
+    $ archery docker run java
 
 Building JNI Libraries (\*.dylib / \*.so / \*.dll)
 --------------------------------------------------

From 80503a6a1a024bbac32213b597a2b0e46bfcf390 Mon Sep 17 00:00:00 2001
From: Nick Hughes <nick@intervaliq.com>
Date: Thu, 9 Nov 2023 07:39:22 -0800
Subject: [PATCH 707/749] GH-34017: [Python][FlightRPC][Doc] Fix `read_chunk`
 docstring for FlightStreamReader and MetadataRecordBatchReader (#38641)

### Rationale for this change

The docs for `FlightStreamReader` and `MetadataRecordBatchReader` currently list an incorrect return type for the `read_chunk` method - see #34017. NB: this issue was partially addressed by #35583.

### What changes are included in this PR?

Simple docstring update for `read_chunk`.

### Are these changes tested?

No (v minor docstring only change)

### Are there any user-facing changes?

Yes
* Closes: #34017

Authored-by: Nick Hughes <nick@intervaliq.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 python/pyarrow/_flight.pyx | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/python/pyarrow/_flight.pyx b/python/pyarrow/_flight.pyx
index 79aa24e4ce8e3..8fe9465a13d9c 100644
--- a/python/pyarrow/_flight.pyx
+++ b/python/pyarrow/_flight.pyx
@@ -1014,11 +1014,8 @@ cdef class _MetadataRecordBatchReader(_Weakrefable, _ReadPandasMixin):
 
         Returns
         -------
-        data : FlightStreamChunk
+        chunk : FlightStreamChunk
             The next FlightStreamChunk in the stream.
-        app_metadata : Buffer or None
-            Application-specific metadata for the batch as defined by
-            Flight.
 
         Raises
         ------

From 1f71014435fd56c915aebe0a9ac982f6e8de6f94 Mon Sep 17 00:00:00 2001
From: Dane Pitkin <48041712+danepitkin@users.noreply.github.com>
Date: Thu, 9 Nov 2023 10:53:55 -0500
Subject: [PATCH 708/749] GH-38648: [Java] Regenerate Flatbuffers (#38650)

### Rationale for this change

Regenerate the Flatbuffers to include new formats. Flatbuffers are always forwards/backwards compatible as long as the code is generated from the same `flatc` compiler version.

### What changes are included in this PR?

* Flatbuffers regenerated with `flatc` v1.12.0

### Are these changes tested?

Yes, via unit tests.

### Are there any user-facing changes?

Yes, RecordBatch.java was modified.
* Closes: #38648

Authored-by: Dane Pitkin <dane@voltrondata.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../org/apache/arrow/flatbuf/BinaryView.java  |  57 +++++++
 .../apache/arrow/flatbuf/BodyCompression.java |   3 +-
 .../java/org/apache/arrow/flatbuf/Date.java   |   4 +-
 .../apache/arrow/flatbuf/LargeListView.java   |  52 ++++++
 .../org/apache/arrow/flatbuf/ListView.java    |  53 +++++++
 .../org/apache/arrow/flatbuf/RecordBatch.java |  33 +++-
 .../apache/arrow/flatbuf/RunEndEncoded.java   |  55 +++++++
 .../java/org/apache/arrow/flatbuf/Time.java   |  17 +-
 .../org/apache/arrow/flatbuf/Timestamp.java   | 148 +++++++++++++-----
 .../java/org/apache/arrow/flatbuf/Type.java   |   7 +-
 .../org/apache/arrow/flatbuf/Utf8View.java    |  57 +++++++
 11 files changed, 435 insertions(+), 51 deletions(-)
 create mode 100644 java/format/src/main/java/org/apache/arrow/flatbuf/BinaryView.java
 create mode 100644 java/format/src/main/java/org/apache/arrow/flatbuf/LargeListView.java
 create mode 100644 java/format/src/main/java/org/apache/arrow/flatbuf/ListView.java
 create mode 100644 java/format/src/main/java/org/apache/arrow/flatbuf/RunEndEncoded.java
 create mode 100644 java/format/src/main/java/org/apache/arrow/flatbuf/Utf8View.java

diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/BinaryView.java b/java/format/src/main/java/org/apache/arrow/flatbuf/BinaryView.java
new file mode 100644
index 0000000000000..56a8d329532c0
--- /dev/null
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/BinaryView.java
@@ -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.
+// 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package org.apache.arrow.flatbuf;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+/**
+ * Logically the same as Binary, but the internal representation uses a view
+ * struct that contains the string length and either the string's entire data
+ * inline (for small strings) or an inlined prefix, an index of another buffer,
+ * and an offset pointing to a slice in that buffer (for non-small strings).
+ *
+ * Since it uses a variable number of data buffers, each Field with this type
+ * must have a corresponding entry in `variadicBufferCounts`.
+ */
+public final class BinaryView extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static BinaryView getRootAsBinaryView(ByteBuffer _bb) { return getRootAsBinaryView(_bb, new BinaryView()); }
+  public static BinaryView getRootAsBinaryView(ByteBuffer _bb, BinaryView obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public BinaryView __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startBinaryView(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endBinaryView(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public BinaryView get(int j) { return get(new BinaryView(), j); }
+    public BinaryView get(BinaryView obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/BodyCompression.java b/java/format/src/main/java/org/apache/arrow/flatbuf/BodyCompression.java
index 650454eb154b4..ed8ce0939a044 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/BodyCompression.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/BodyCompression.java
@@ -37,7 +37,8 @@ public final class BodyCompression extends Table {
   public BodyCompression __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   /**
-   * Compressor library
+   * Compressor library.
+   * For LZ4_FRAME, each compressed buffer must consist of a single frame.
    */
   public byte codec() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; }
   /**
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/Date.java b/java/format/src/main/java/org/apache/arrow/flatbuf/Date.java
index b2fcc9e39e38d..ac6e389835a43 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/Date.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/Date.java
@@ -25,8 +25,8 @@
 
 @SuppressWarnings("unused")
 /**
- * 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
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/LargeListView.java b/java/format/src/main/java/org/apache/arrow/flatbuf/LargeListView.java
new file mode 100644
index 0000000000000..08c31c23a943f
--- /dev/null
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/LargeListView.java
@@ -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.
+// 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package org.apache.arrow.flatbuf;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+/**
+ * Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+ * extremely large data values.
+ */
+public final class LargeListView extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static LargeListView getRootAsLargeListView(ByteBuffer _bb) { return getRootAsLargeListView(_bb, new LargeListView()); }
+  public static LargeListView getRootAsLargeListView(ByteBuffer _bb, LargeListView obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public LargeListView __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startLargeListView(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endLargeListView(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public LargeListView get(int j) { return get(new LargeListView(), j); }
+    public LargeListView get(LargeListView obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/ListView.java b/java/format/src/main/java/org/apache/arrow/flatbuf/ListView.java
new file mode 100644
index 0000000000000..2c9ad4c13d884
--- /dev/null
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/ListView.java
@@ -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.
+// 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package org.apache.arrow.flatbuf;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+/**
+ * Represents the same logical types that List can, but contains offsets and
+ * sizes allowing for writes in any order and sharing of child values among
+ * list values.
+ */
+public final class ListView extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static ListView getRootAsListView(ByteBuffer _bb) { return getRootAsListView(_bb, new ListView()); }
+  public static ListView getRootAsListView(ByteBuffer _bb, ListView obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public ListView __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startListView(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endListView(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public ListView get(int j) { return get(new ListView(), j); }
+    public ListView get(ListView obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/RecordBatch.java b/java/format/src/main/java/org/apache/arrow/flatbuf/RecordBatch.java
index eb814e07dcceb..ce907ee0fdcda 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/RecordBatch.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/RecordBatch.java
@@ -67,27 +67,54 @@ public final class RecordBatch extends Table {
    */
   public org.apache.arrow.flatbuf.BodyCompression compression() { return compression(new org.apache.arrow.flatbuf.BodyCompression()); }
   public org.apache.arrow.flatbuf.BodyCompression compression(org.apache.arrow.flatbuf.BodyCompression obj) { int o = __offset(10); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+  /**
+   * Some types such as Utf8View are represented using a variable number of buffers.
+   * For each such Field in the pre-ordered flattened logical schema, there will be
+   * an entry in variadicBufferCounts to indicate the number of number of variadic
+   * buffers which belong to that Field in the current RecordBatch.
+   *
+   * For example, the schema
+   *     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+   *     col2: Utf8View
+   * contains two Fields with variadic buffers so variadicBufferCounts will have
+   * two entries, the first counting the variadic buffers of `col1.beta` and the
+   * second counting `col2`'s.
+   *
+   * This field may be omitted if and only if the schema contains no Fields with
+   * a variable number of buffers, such as BinaryView and Utf8View.
+   */
+  public long variadicBufferCounts(int j) { int o = __offset(12); return o != 0 ? bb.getLong(__vector(o) + j * 8) : 0; }
+  public int variadicBufferCountsLength() { int o = __offset(12); return o != 0 ? __vector_len(o) : 0; }
+  public LongVector variadicBufferCountsVector() { return variadicBufferCountsVector(new LongVector()); }
+  public LongVector variadicBufferCountsVector(LongVector obj) { int o = __offset(12); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer variadicBufferCountsAsByteBuffer() { return __vector_as_bytebuffer(12, 8); }
+  public ByteBuffer variadicBufferCountsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 8); }
 
   public static int createRecordBatch(FlatBufferBuilder builder,
       long length,
       int nodesOffset,
       int buffersOffset,
-      int compressionOffset) {
-    builder.startTable(4);
+      int compressionOffset,
+      int variadicBufferCountsOffset) {
+    builder.startTable(5);
     RecordBatch.addLength(builder, length);
+    RecordBatch.addVariadicBufferCounts(builder, variadicBufferCountsOffset);
     RecordBatch.addCompression(builder, compressionOffset);
     RecordBatch.addBuffers(builder, buffersOffset);
     RecordBatch.addNodes(builder, nodesOffset);
     return RecordBatch.endRecordBatch(builder);
   }
 
-  public static void startRecordBatch(FlatBufferBuilder builder) { builder.startTable(4); }
+  public static void startRecordBatch(FlatBufferBuilder builder) { builder.startTable(5); }
   public static void addLength(FlatBufferBuilder builder, long length) { builder.addLong(0, length, 0L); }
   public static void addNodes(FlatBufferBuilder builder, int nodesOffset) { builder.addOffset(1, nodesOffset, 0); }
   public static void startNodesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(16, numElems, 8); }
   public static void addBuffers(FlatBufferBuilder builder, int buffersOffset) { builder.addOffset(2, buffersOffset, 0); }
   public static void startBuffersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(16, numElems, 8); }
   public static void addCompression(FlatBufferBuilder builder, int compressionOffset) { builder.addOffset(3, compressionOffset, 0); }
+  public static void addVariadicBufferCounts(FlatBufferBuilder builder, int variadicBufferCountsOffset) { builder.addOffset(4, variadicBufferCountsOffset, 0); }
+  public static int createVariadicBufferCountsVector(FlatBufferBuilder builder, long[] data) { builder.startVector(8, data.length, 8); for (int i = data.length - 1; i >= 0; i--) builder.addLong(data[i]); return builder.endVector(); }
+  public static void startVariadicBufferCountsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(8, numElems, 8); }
   public static int endRecordBatch(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/RunEndEncoded.java b/java/format/src/main/java/org/apache/arrow/flatbuf/RunEndEncoded.java
new file mode 100644
index 0000000000000..d48733ef0c826
--- /dev/null
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/RunEndEncoded.java
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+// 
+// http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package org.apache.arrow.flatbuf;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+/**
+ * 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.
+ */
+public final class RunEndEncoded extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static RunEndEncoded getRootAsRunEndEncoded(ByteBuffer _bb) { return getRootAsRunEndEncoded(_bb, new RunEndEncoded()); }
+  public static RunEndEncoded getRootAsRunEndEncoded(ByteBuffer _bb, RunEndEncoded obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public RunEndEncoded __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startRunEndEncoded(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endRunEndEncoded(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public RunEndEncoded get(int j) { return get(new RunEndEncoded(), j); }
+    public RunEndEncoded get(RunEndEncoded obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/Time.java b/java/format/src/main/java/org/apache/arrow/flatbuf/Time.java
index 596d403a3eae9..9acc3fc7a5ea1 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/Time.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/Time.java
@@ -25,9 +25,20 @@
 
 @SuppressWarnings("unused")
 /**
- * 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).
  */
 public final class Time extends Table {
   public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/Timestamp.java b/java/format/src/main/java/org/apache/arrow/flatbuf/Timestamp.java
index 041452607c9e1..fe0c6aaea24fa 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/Timestamp.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/Timestamp.java
@@ -25,37 +25,111 @@
 
 @SuppressWarnings("unused")
 /**
- * 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.
+ *
+ * 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
+ * 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 single moment in time that has no meaningful time zone
- * or the time zone is unknown.  A column of instants can also contain values from
- * multiple time zones.  To encode an instant set the timezone string to "UTC".
- *
- * A "zoned date-time" represents a single moment in time that has a meaningful
- * reference time zone.  To encode a zoned date-time as a Timestamp set the timezone
- * string to the name of the timezone.  There is some ambiguity between an instant
- * and a zoned date-time with the UTC time zone.  Both of these are stored the same.
- * 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 single moment in time combined with a meaningful
- * offset from UTC.  To encode an offset date-time as a Timestamp set the timezone string
- * to the numeric time zone offset string (e.g. "+03:00").
- *
- * A "local date-time" does not represent a single moment in time.  It represents a wall
- * clock time combined with a date.  Because of daylight savings time there may multiple
- * instants that correspond to a single local date-time in any given time zone.  A
- * local date-time is often stored as a struct or a Date32/Time64 pair.  However, it can
- * also be encoded into a Timestamp column.  To do so the value should be the the time
- * elapsed from the Unix epoch so that a wall clock in UTC would display the desired time.
- * The timezone string should be set to null or the empty string.
+ * 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.
  */
 public final class Timestamp extends Table {
   public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
@@ -66,24 +140,16 @@ public final class Timestamp extends Table {
 
   public short unit() { int o = __offset(4); return o != 0 ? bb.getShort(o + bb_pos) : 0; }
   /**
-   * 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 an empty string, the data is a local date-time
-   *   and does not represent a single moment in time.  Instead it represents a wall clock
-   *   time and care should be taken to avoid interpreting it semantically as an instant.
-   *
-   * * 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).
    */
   public String timezone() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; }
   public ByteBuffer timezoneAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/Type.java b/java/format/src/main/java/org/apache/arrow/flatbuf/Type.java
index 5f1a550cffff4..29248bb23c303 100644
--- a/java/format/src/main/java/org/apache/arrow/flatbuf/Type.java
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/Type.java
@@ -47,8 +47,13 @@ private Type() { }
   public static final byte LargeBinary = 19;
   public static final byte LargeUtf8 = 20;
   public static final byte LargeList = 21;
+  public static final byte RunEndEncoded = 22;
+  public static final byte BinaryView = 23;
+  public static final byte Utf8View = 24;
+  public static final byte ListView = 25;
+  public static final byte LargeListView = 26;
 
-  public static final String[] names = { "NONE", "Null", "Int", "FloatingPoint", "Binary", "Utf8", "Bool", "Decimal", "Date", "Time", "Timestamp", "Interval", "List", "Struct_", "Union", "FixedSizeBinary", "FixedSizeList", "Map", "Duration", "LargeBinary", "LargeUtf8", "LargeList", };
+  public static final String[] names = { "NONE", "Null", "Int", "FloatingPoint", "Binary", "Utf8", "Bool", "Decimal", "Date", "Time", "Timestamp", "Interval", "List", "Struct_", "Union", "FixedSizeBinary", "FixedSizeList", "Map", "Duration", "LargeBinary", "LargeUtf8", "LargeList", "RunEndEncoded", "BinaryView", "Utf8View", "ListView", "LargeListView", };
 
   public static String name(int e) { return names[e]; }
 }
diff --git a/java/format/src/main/java/org/apache/arrow/flatbuf/Utf8View.java b/java/format/src/main/java/org/apache/arrow/flatbuf/Utf8View.java
new file mode 100644
index 0000000000000..035c977576e43
--- /dev/null
+++ b/java/format/src/main/java/org/apache/arrow/flatbuf/Utf8View.java
@@ -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.
+// 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package org.apache.arrow.flatbuf;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+@SuppressWarnings("unused")
+/**
+ * Logically the same as Utf8, but the internal representation uses a view
+ * struct that contains the string length and either the string's entire data
+ * inline (for small strings) or an inlined prefix, an index of another buffer,
+ * and an offset pointing to a slice in that buffer (for non-small strings).
+ *
+ * Since it uses a variable number of data buffers, each Field with this type
+ * must have a corresponding entry in `variadicBufferCounts`.
+ */
+public final class Utf8View extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static Utf8View getRootAsUtf8View(ByteBuffer _bb) { return getRootAsUtf8View(_bb, new Utf8View()); }
+  public static Utf8View getRootAsUtf8View(ByteBuffer _bb, Utf8View obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Utf8View __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startUtf8View(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endUtf8View(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Utf8View get(int j) { return get(new Utf8View(), j); }
+    public Utf8View get(Utf8View obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+

From 49838858eab984fc4a7e8595d7dd1883b00350ea Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Thu, 9 Nov 2023 11:14:31 -0500
Subject: [PATCH 709/749] GH-38630: [MATLAB] `arrow.array.BooleanArray`'s
 `toMATLAB` method does not take slice offsets into account (#38636)

### Rationale for this change

While working on #38415, I noticed that the `toMATLAB` method of `arrow.array.BooleanArray` does not take the slice offset into account. This will cause the `toMATLAB` method to return the wrong value.

### What changes are included in this PR?

1. Updated `arrow::matlab::bit::unpack` function to accept a `start_offset` as input.
2. Updated clients (`BooleanArray::toMATLAB` and `Array::getValid`) to supply the array `offset` as the `start_offset`.

### Are these changes tested?

The existing tests cover these changes. Additionally, the changes for #38415 will include tests that verify the `toMATLAB` method returns the correct MATLAB array when the underlying Arrow array has been sliced.

### Are there any user-facing changes?

No.

* Closes: #38630

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/src/cpp/arrow/matlab/array/proxy/array.cc         | 2 +-
 matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc | 2 +-
 matlab/src/cpp/arrow/matlab/bit/unpack.cc                | 3 +--
 matlab/src/cpp/arrow/matlab/bit/unpack.h                 | 2 +-
 4 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index 4e52c990d3eae..09d9473df4795 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -100,7 +100,7 @@ namespace arrow::matlab::array::proxy {
         }
 
         auto validity_bitmap = array->null_bitmap();
-        auto valid_elements_mda = bit::unpack(validity_bitmap, array_length);
+        auto valid_elements_mda = bit::unpack(validity_bitmap, array_length, array->offset());
         context.outputs[0] = valid_elements_mda;
     }
 
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
index 6a6e478274823..da3560ce522f3 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/boolean_array.cc
@@ -53,7 +53,7 @@ namespace arrow::matlab::array::proxy {
         void BooleanArray::toMATLAB(libmexclass::proxy::method::Context& context) {
             auto array_length = array->length();
             auto packed_logical_data_buffer = std::static_pointer_cast<arrow::BooleanArray>(array)->values();
-            auto logical_array_mda = bit::unpack(packed_logical_data_buffer, array_length);
+            auto logical_array_mda = bit::unpack(packed_logical_data_buffer, array_length, array->offset());
             context.outputs[0] = logical_array_mda;
         }
 }
diff --git a/matlab/src/cpp/arrow/matlab/bit/unpack.cc b/matlab/src/cpp/arrow/matlab/bit/unpack.cc
index 7135d593cf752..6cc88d48ede43 100644
--- a/matlab/src/cpp/arrow/matlab/bit/unpack.cc
+++ b/matlab/src/cpp/arrow/matlab/bit/unpack.cc
@@ -20,7 +20,7 @@
 #include "arrow/util/bitmap_visit.h"
 
 namespace arrow::matlab::bit {
-    ::matlab::data::TypedArray<bool> unpack(const std::shared_ptr<arrow::Buffer>& packed_buffer, int64_t length) {
+    ::matlab::data::TypedArray<bool> unpack(const std::shared_ptr<arrow::Buffer>& packed_buffer, int64_t length, int64_t start_offset) {
         const auto packed_buffer_ptr = packed_buffer->data();
 
         ::matlab::data::ArrayFactory factory;
@@ -31,7 +31,6 @@ namespace arrow::matlab::bit {
         auto unpacked_buffer_ptr = unpacked_buffer.get();
         auto visitFcn = [&](const bool is_valid) { *unpacked_buffer_ptr++ = is_valid; };
 
-        const int64_t start_offset = 0;
         arrow::internal::VisitBitsUnrolled(packed_buffer_ptr, start_offset, length, visitFcn);
 
         ::matlab::data::TypedArray<bool> unpacked_matlab_logical_Array = factory.createArrayFromBuffer({array_length, 1}, std::move(unpacked_buffer));
diff --git a/matlab/src/cpp/arrow/matlab/bit/unpack.h b/matlab/src/cpp/arrow/matlab/bit/unpack.h
index b6debb85f837b..6cd633e76fa56 100644
--- a/matlab/src/cpp/arrow/matlab/bit/unpack.h
+++ b/matlab/src/cpp/arrow/matlab/bit/unpack.h
@@ -22,6 +22,6 @@
 #include "MatlabDataArray.hpp"
 
 namespace arrow::matlab::bit {
-    ::matlab::data::TypedArray<bool> unpack(const std::shared_ptr<arrow::Buffer>& packed_buffer, int64_t length);
+    ::matlab::data::TypedArray<bool> unpack(const std::shared_ptr<arrow::Buffer>& packed_buffer, int64_t length, int64_t start_offset);
     const uint8_t* extract_ptr(const ::matlab::data::TypedArray<bool>& unpacked_validity_bitmap);
 }

From 79e328b3b7ce23002bc46904c1944654ce4cd0a3 Mon Sep 17 00:00:00 2001
From: Benjamin Schmidt <bmschmidt@gmail.com>
Date: Thu, 9 Nov 2023 15:19:03 -0500
Subject: [PATCH 710/749] MINOR: [JS][Docs] Correct typo in README (#38658)

### Rationale for this change

A demo variable is named 'uft8' but should clearly be 'utf8'.

### What changes are included in this PR?

Two transpostions of two characters

### Are these changes tested?

N/A

### Are there any user-facing changes?

No

Authored-by: Benjamin Schmidt <bmschmidt@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 js/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/README.md b/js/README.md
index f626ef7240fca..f3dd3fef890f2 100644
--- a/js/README.md
+++ b/js/README.md
@@ -151,7 +151,7 @@ Strings can be encoded as UTF-8 or dictionary encoded UTF-8. Dictionary encoding
 ```js
 import { makeVector, vectorFromArray, Dictionary, Uint8, Utf8 } from "apache-arrow";
 
-const uft8Vector = vectorFromArray(['foo', 'bar', 'baz'], new Utf8);
+const utf8Vector = vectorFromArray(['foo', 'bar', 'baz'], new Utf8);
 
 const dictionaryVector1 = vectorFromArray(
     ['foo', 'bar', 'baz', 'foo', 'bar']
@@ -159,7 +159,7 @@ const dictionaryVector1 = vectorFromArray(
 
 const dictionaryVector2 = makeVector({
     data: [0, 1, 2, 0, 1],  // indexes into the dictionary
-    dictionary: uft8Vector,
+    dictionary: utf8Vector,
     type: new Dictionary(new Utf8, new Uint8)
 });
 ```

From 0acf4c8271e65e103c9fbbf753b8759fd9058f45 Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Thu, 9 Nov 2023 13:56:53 -0800
Subject: [PATCH 711/749] GH-38614: [Java] Add VarBinary and VarCharWriter
 helper methods to more writers (#38631)

### Rationale for this change
Add the overrides for new convenience Writer methods added to VarCharWriter and VarBinaryWriter so that classes that
use composition such as UnionWriter and PromotableWriter can invoke them properly.

### What changes are included in this PR?
- Rename from writeTo$type to write$type for consistency with other methods
- Add new helper methods to PromotableWriter
- Add new helper methods to complex writers such as list and union

### Are these changes tested?
Yes. New unit tests added for several Writer classes.

 **This PR includes breaking changes to public APIs.**
The writeTo<Type>() and similar methods in Writers have been renamed to just write<Type>()

* Closes: #38614

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../templates/AbstractFieldWriter.java        |  11 +-
 .../AbstractPromotableFieldWriter.java        |  32 +++
 .../codegen/templates/ComplexWriters.java     |  16 +-
 .../templates/UnionFixedSizeListWriter.java   |  56 +++++
 .../codegen/templates/UnionListWriter.java    |  37 +++
 .../main/codegen/templates/UnionWriter.java   |  36 +++
 .../vector/complex/impl/PromotableWriter.java |  63 +++++-
 .../arrow/vector/TestFixedSizeListVector.java |  92 +++++++-
 .../complex/impl/TestPromotableWriter.java    | 197 ++++++++++++++++
 .../complex/writer/TestComplexWriter.java     | 211 ++++++++++++++++++
 .../complex/writer/TestSimpleWriter.java      |  16 +-
 11 files changed, 741 insertions(+), 26 deletions(-)

diff --git a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
index bb4ee45eaa073..6c2368117f7c2 100644
--- a/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
+++ b/java/vector/src/main/codegen/templates/AbstractFieldWriter.java
@@ -27,6 +27,9 @@
 
 /*
  * This class is generated using freemarker and the ${.template_name} template.
+ * Note that changes to the AbstractFieldWriter template should also get reflected in the
+ * AbstractPromotableFieldWriter, ComplexWriters, UnionFixedSizeListWriter, UnionListWriter
+ * and UnionWriter templates and the PromotableWriter concrete code.
  */
 @SuppressWarnings("unused")
 abstract class AbstractFieldWriter extends AbstractBaseWriter implements FieldWriter {
@@ -125,19 +128,19 @@ public void write(${name}Holder holder) {
   </#if>
 
   <#if minor.class?ends_with("VarBinary")>
-  public void writeTo${minor.class}(byte[] value) {
+  public void write${minor.class}(byte[] value) {
     fail("${name}");
   }
 
-  public void writeTo${minor.class}(byte[] value, int offset, int length) {
+  public void write${minor.class}(byte[] value, int offset, int length) {
     fail("${name}");
   }
 
-  public void writeTo${minor.class}(ByteBuffer value) {
+  public void write${minor.class}(ByteBuffer value) {
     fail("${name}");
   }
 
-  public void writeTo${minor.class}(ByteBuffer value, int offset, int length) {
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
     fail("${name}");
   }
   </#if>
diff --git a/java/vector/src/main/codegen/templates/AbstractPromotableFieldWriter.java b/java/vector/src/main/codegen/templates/AbstractPromotableFieldWriter.java
index 2f963a9df0d05..59f9fb5b8098d 100644
--- a/java/vector/src/main/codegen/templates/AbstractPromotableFieldWriter.java
+++ b/java/vector/src/main/codegen/templates/AbstractPromotableFieldWriter.java
@@ -221,6 +221,38 @@ public void write(${name}Holder holder) {
   }
   </#if>
 
+  <#if minor.class?ends_with("VarBinary")>
+  @Override
+  public void write${minor.class}(byte[] value) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(byte[] value, int offset, int length) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value, offset, length);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value, offset, length);
+  }
+  <#elseif minor.class?ends_with("VarChar")>
+  @Override
+  public void write${minor.class}(Text value) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(String value) {
+    getWriter(MinorType.${name?upper_case}).write${minor.class}(value);
+  }
+  </#if>
+
   </#list></#list>
   public void writeNull() {
   }
diff --git a/java/vector/src/main/codegen/templates/ComplexWriters.java b/java/vector/src/main/codegen/templates/ComplexWriters.java
index 51a52a6e3070d..2e3caae1f0f22 100644
--- a/java/vector/src/main/codegen/templates/ComplexWriters.java
+++ b/java/vector/src/main/codegen/templates/ComplexWriters.java
@@ -194,22 +194,22 @@ public void writeNull() {
   </#if>
 
   <#if minor.class?ends_with("VarBinary")>
-  public void writeTo${minor.class}(byte[] value) {
+  public void write${minor.class}(byte[] value) {
     vector.setSafe(idx(), value);
     vector.setValueCount(idx() + 1);
   }
 
-  public void writeTo${minor.class}(byte[] value, int offset, int length) {
+  public void write${minor.class}(byte[] value, int offset, int length) {
     vector.setSafe(idx(), value, offset, length);
     vector.setValueCount(idx() + 1);
   }
 
-  public void writeTo${minor.class}(ByteBuffer value) {
+  public void write${minor.class}(ByteBuffer value) {
     vector.setSafe(idx(), value, 0, value.remaining());
     vector.setValueCount(idx() + 1);
   }
 
-  public void writeTo${minor.class}(ByteBuffer value, int offset, int length) {
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
     vector.setSafe(idx(), value, offset, length);
     vector.setValueCount(idx() + 1);
   }
@@ -259,13 +259,13 @@ public interface ${eName}Writer extends BaseWriter {
 </#if>
 
 <#if minor.class?ends_with("VarBinary")>
-  public void writeTo${minor.class}(byte[] value);
+  public void write${minor.class}(byte[] value);
 
-  public void writeTo${minor.class}(byte[] value, int offset, int length);
+  public void write${minor.class}(byte[] value, int offset, int length);
 
-  public void writeTo${minor.class}(ByteBuffer value);
+  public void write${minor.class}(ByteBuffer value);
 
-  public void writeTo${minor.class}(ByteBuffer value, int offset, int length);
+  public void write${minor.class}(ByteBuffer value, int offset, int length);
 </#if>
 
 <#if minor.class?ends_with("VarChar")>
diff --git a/java/vector/src/main/codegen/templates/UnionFixedSizeListWriter.java b/java/vector/src/main/codegen/templates/UnionFixedSizeListWriter.java
index 55c661bfc6023..3436e3a967651 100644
--- a/java/vector/src/main/codegen/templates/UnionFixedSizeListWriter.java
+++ b/java/vector/src/main/codegen/templates/UnionFixedSizeListWriter.java
@@ -295,6 +295,62 @@ public void writeBigEndianBytesToDecimal256(byte[] value, ArrowType arrowType) {
       <#assign name = minor.class?cap_first />
       <#assign fields = minor.fields!type.fields />
       <#assign uncappedName = name?uncap_first/>
+      <#if minor.class?ends_with("VarBinary")>
+  @Override
+  public void write${minor.class}(byte[] value) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(byte[] value, int offset, int length) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value, offset, length);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value, offset, length);
+    writer.setPosition(writer.idx() + 1);
+  }
+  <#elseif minor.class?ends_with("VarChar")>
+  @Override
+  public void write${minor.class}(Text value) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(String value) {
+    if (writer.idx() >= (idx() + 1) * listSize) {
+      throw new IllegalStateException(String.format("values at index %s is greater than listSize %s", idx(), listSize));
+    }
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+      </#if>
+
       <#if !minor.typeParams?? >
   @Override
   public void write${name}(<#list fields as field>${field.type} ${field.name}<#if field_has_next>, </#if></#list>) {
diff --git a/java/vector/src/main/codegen/templates/UnionListWriter.java b/java/vector/src/main/codegen/templates/UnionListWriter.java
index fac75a9ce5637..5c0565ee27175 100644
--- a/java/vector/src/main/codegen/templates/UnionListWriter.java
+++ b/java/vector/src/main/codegen/templates/UnionListWriter.java
@@ -274,6 +274,43 @@ public void write(${name}Holder holder) {
     writer.write${name}(<#list fields as field>holder.${field.name}<#if field_has_next>, </#if></#list>);
     writer.setPosition(writer.idx()+1);
   }
+  </#if>
+
+  <#if minor.class?ends_with("VarBinary")>
+  @Override
+  public void write${minor.class}(byte[] value) {
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(byte[] value, int offset, int length) {
+    writer.write${minor.class}(value, offset, length);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value) {
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
+    writer.write${minor.class}(value, offset, length);
+    writer.setPosition(writer.idx() + 1);
+  }
+  <#elseif minor.class?ends_with("VarChar")>
+  @Override
+  public void write${minor.class}(Text value) {
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
+
+  public void write${minor.class}(String value) {
+    writer.write${minor.class}(value);
+    writer.setPosition(writer.idx() + 1);
+  }
   </#if>
 
     </#list>
diff --git a/java/vector/src/main/codegen/templates/UnionWriter.java b/java/vector/src/main/codegen/templates/UnionWriter.java
index 4efd1026cac4a..08dbf24324b17 100644
--- a/java/vector/src/main/codegen/templates/UnionWriter.java
+++ b/java/vector/src/main/codegen/templates/UnionWriter.java
@@ -302,6 +302,42 @@ public void write(${name}Holder holder) {
     get${name}Writer(arrowType).setPosition(idx());
     get${name}Writer(arrowType).writeBigEndianBytesTo${name}(value, arrowType);
   }
+  <#elseif minor.class?ends_with("VarBinary")>
+  @Override
+  public void write${minor.class}(byte[] value) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(byte[] value, int offset, int length) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value, offset, length);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(ByteBuffer value, int offset, int length) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value, offset, length);
+  }
+  <#elseif minor.class?ends_with("VarChar")>
+  @Override
+  public void write${minor.class}(${friendlyType} value) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value);
+  }
+
+  @Override
+  public void write${minor.class}(String value) {
+    get${name}Writer().setPosition(idx());
+    get${name}Writer().write${minor.class}(value);
+  }
   </#if>
       </#if>
     </#list>
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/complex/impl/PromotableWriter.java b/java/vector/src/main/java/org/apache/arrow/vector/complex/impl/PromotableWriter.java
index d99efceae3eca..f7be277f592a6 100644
--- a/java/vector/src/main/java/org/apache/arrow/vector/complex/impl/PromotableWriter.java
+++ b/java/vector/src/main/java/org/apache/arrow/vector/complex/impl/PromotableWriter.java
@@ -18,6 +18,7 @@
 package org.apache.arrow.vector.complex.impl;
 
 import java.math.BigDecimal;
+import java.nio.ByteBuffer;
 
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.vector.FieldVector;
@@ -37,6 +38,7 @@
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
 
 /**
@@ -378,7 +380,66 @@ public void writeBigEndianBytesToDecimal256(byte[] value, ArrowType arrowType) {
           /*bitWidth=*/256)).writeBigEndianBytesToDecimal256(value, arrowType);
   }
 
- 
+  @Override
+  public void writeVarBinary(byte[] value) {
+    getWriter(MinorType.VARBINARY).writeVarBinary(value);
+  }
+
+  @Override
+  public void writeVarBinary(byte[] value, int offset, int length) {
+    getWriter(MinorType.VARBINARY).writeVarBinary(value, offset, length);
+  }
+
+  @Override
+  public void writeVarBinary(ByteBuffer value) {
+    getWriter(MinorType.VARBINARY).writeVarBinary(value);
+  }
+
+  @Override
+  public void writeVarBinary(ByteBuffer value, int offset, int length) {
+    getWriter(MinorType.VARBINARY).writeVarBinary(value, offset, length);
+  }
+
+  @Override
+  public void writeLargeVarBinary(byte[] value) {
+    getWriter(MinorType.LARGEVARBINARY).writeLargeVarBinary(value);
+  }
+
+  @Override
+  public void writeLargeVarBinary(byte[] value, int offset, int length) {
+    getWriter(MinorType.LARGEVARBINARY).writeLargeVarBinary(value, offset, length);
+  }
+
+  @Override
+  public void writeLargeVarBinary(ByteBuffer value) {
+    getWriter(MinorType.LARGEVARBINARY).writeLargeVarBinary(value);
+  }
+
+  @Override
+  public void writeLargeVarBinary(ByteBuffer value, int offset, int length) {
+    getWriter(MinorType.LARGEVARBINARY).writeLargeVarBinary(value, offset, length);
+  }
+
+  @Override
+  public void writeVarChar(Text value) {
+    getWriter(MinorType.VARCHAR).writeVarChar(value);
+  }
+
+  @Override
+  public void writeVarChar(String value) {
+    getWriter(MinorType.VARCHAR).writeVarChar(value);
+  }
+
+  @Override
+  public void writeLargeVarChar(Text value) {
+    getWriter(MinorType.LARGEVARCHAR).writeLargeVarChar(value);
+  }
+
+  @Override
+  public void writeLargeVarChar(String value) {
+    getWriter(MinorType.LARGEVARCHAR).writeLargeVarChar(value);
+  }
+
   @Override
   public void allocate() {
     getWriter().allocate();
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeListVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeListVector.java
index 9d7e413a739ad..0023b1dddb8e7 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeListVector.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/TestFixedSizeListVector.java
@@ -24,6 +24,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.math.BigDecimal;
+import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.List;
 
@@ -37,6 +38,7 @@
 import org.apache.arrow.vector.types.Types.MinorType;
 import org.apache.arrow.vector.types.pojo.ArrowType;
 import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.util.Text;
 import org.apache.arrow.vector.util.TransferPair;
 import org.junit.After;
 import org.junit.Assert;
@@ -457,18 +459,98 @@ public void testVectorWithNulls() {
 
       assertEquals(4, vector1.getValueCount());
 
-      List realValue1 = vector1.getObject(0);
+      List<?> realValue1 = vector1.getObject(0);
       assertEquals(values1, realValue1);
-      List realValue2 = vector1.getObject(1);
+      List<?> realValue2 = vector1.getObject(1);
       assertEquals(values2, realValue2);
-      List realValue3 = vector1.getObject(2);
+      List<?> realValue3 = vector1.getObject(2);
       assertEquals(values3, realValue3);
-      List realValue4 = vector1.getObject(3);
+      List<?> realValue4 = vector1.getObject(3);
       assertEquals(values4, realValue4);
     }
   }
 
-  private int[] convertListToIntArray(List list) {
+  @Test
+  public void testWriteVarCharHelpers() throws Exception {
+    try (final FixedSizeListVector vector = FixedSizeListVector.empty("vector", /*listSize=*/4, allocator)) {
+
+      UnionFixedSizeListWriter writer = vector.getWriter();
+      writer.allocate();
+
+      writer.startList();
+      writer.writeVarChar("row1,1");
+      writer.writeVarChar(new Text("row1,2"));
+      writer.writeNull();
+      writer.writeNull();
+      writer.endList();
+
+      assertEquals("row1,1", vector.getObject(0).get(0).toString());
+      assertEquals("row1,2", vector.getObject(0).get(1).toString());
+    }
+  }
+
+  @Test
+  public void testWriteLargeVarCharHelpers() throws Exception {
+    try (final FixedSizeListVector vector = FixedSizeListVector.empty("vector", /*listSize=*/4, allocator)) {
+
+      UnionFixedSizeListWriter writer = vector.getWriter();
+      writer.allocate();
+
+      writer.startList();
+      writer.writeLargeVarChar("row1,1");
+      writer.writeLargeVarChar(new Text("row1,2"));
+      writer.writeNull();
+      writer.writeNull();
+      writer.endList();
+
+      assertEquals("row1,1", vector.getObject(0).get(0).toString());
+      assertEquals("row1,2", vector.getObject(0).get(1).toString());
+    }
+  }
+
+  @Test
+  public void testWriteVarBinaryHelpers() throws Exception {
+    try (final FixedSizeListVector vector = FixedSizeListVector.empty("vector", /*listSize=*/4, allocator)) {
+
+      UnionFixedSizeListWriter writer = vector.getWriter();
+      writer.allocate();
+
+      writer.startList();
+      writer.writeVarBinary("row1,1".getBytes());
+      writer.writeVarBinary("row1,2".getBytes(), 0, "row1,2".getBytes().length);
+      writer.writeVarBinary(ByteBuffer.wrap("row1,3".getBytes()));
+      writer.writeVarBinary(ByteBuffer.wrap("row1,4".getBytes()), 0, "row1,4".getBytes().length);
+      writer.endList();
+
+      assertEquals("row1,1", new String((byte[]) (vector.getObject(0).get(0))));
+      assertEquals("row1,2", new String((byte[]) (vector.getObject(0).get(1))));
+      assertEquals("row1,3", new String((byte[]) (vector.getObject(0).get(2))));
+      assertEquals("row1,4", new String((byte[]) (vector.getObject(0).get(3))));
+    }
+  }
+
+  @Test
+  public void testWriteLargeVarBinaryHelpers() throws Exception {
+    try (final FixedSizeListVector vector = FixedSizeListVector.empty("vector", /*listSize=*/4, allocator)) {
+
+      UnionFixedSizeListWriter writer = vector.getWriter();
+      writer.allocate();
+
+      writer.startList();
+      writer.writeLargeVarBinary("row1,1".getBytes());
+      writer.writeLargeVarBinary("row1,2".getBytes(), 0, "row1,2".getBytes().length);
+      writer.writeLargeVarBinary(ByteBuffer.wrap("row1,3".getBytes()));
+      writer.writeLargeVarBinary(ByteBuffer.wrap("row1,4".getBytes()), 0, "row1,4".getBytes().length);
+      writer.endList();
+
+      assertEquals("row1,1", new String((byte[]) (vector.getObject(0).get(0))));
+      assertEquals("row1,2", new String((byte[]) (vector.getObject(0).get(1))));
+      assertEquals("row1,3", new String((byte[]) (vector.getObject(0).get(2))));
+      assertEquals("row1,4", new String((byte[]) (vector.getObject(0).get(3))));
+    }
+  }
+
+  private int[] convertListToIntArray(List<?> list) {
     int[] values = new int[list.size()];
     for (int i = 0; i < list.size(); i++) {
       values[i] = (int) list.get(i);
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/impl/TestPromotableWriter.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/impl/TestPromotableWriter.java
index 1068f7c030eb5..4c8c96a0d74d3 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/complex/impl/TestPromotableWriter.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/impl/TestPromotableWriter.java
@@ -28,6 +28,10 @@
 import org.apache.arrow.memory.ArrowBuf;
 import org.apache.arrow.memory.BufferAllocator;
 import org.apache.arrow.vector.DirtyRootAllocator;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.LargeVarCharVector;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.complex.NonNullableStructVector;
 import org.apache.arrow.vector.complex.StructVector;
@@ -43,6 +47,7 @@
 import org.apache.arrow.vector.types.pojo.ArrowType.ArrowTypeID;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.FieldType;
+import org.apache.arrow.vector.util.Text;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -392,4 +397,196 @@ public void testNoPromoteFixedSizeBinaryToUnionWithNull() throws Exception {
       buf.close();
     }
   }
+
+  @Test
+  public void testPromoteLargeVarCharHelpersOnStruct() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.largeVarChar("c").writeLargeVarChar(new Text("foo"));
+      writer.setPosition(1);
+      writer.largeVarChar("c").writeLargeVarChar("foo2");
+      writer.end();
+
+      final LargeVarCharVector uv = v.getChild("c", LargeVarCharVector.class);
+      assertEquals("foo", uv.getObject(0).toString());
+      assertEquals("foo2", uv.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void testPromoteVarCharHelpersOnStruct() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.varChar("c").writeVarChar(new Text("foo"));
+      writer.setPosition(1);
+      writer.varChar("c").writeVarChar("foo2");
+      writer.end();
+
+      final VarCharVector uv = v.getChild("c", VarCharVector.class);
+      assertEquals("foo", uv.getObject(0).toString());
+      assertEquals("foo2", uv.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void testPromoteVarCharHelpersDirect() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.writeVarChar(new Text("foo"));
+      writer.setPosition(1);
+      writer.writeVarChar("foo2");
+      writer.end();
+
+      // The "test" vector in the parent container should have been replaced with a UnionVector.
+      UnionVector promotedVector = container.getChild("test", UnionVector.class);
+      VarCharVector vector = promotedVector.getVarCharVector();
+      assertEquals("foo", vector.getObject(0).toString());
+      assertEquals("foo2", vector.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void testPromoteLargeVarCharHelpersDirect() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.writeLargeVarChar(new Text("foo"));
+      writer.setPosition(1);
+      writer.writeLargeVarChar("foo2");
+      writer.end();
+
+      // The "test" vector in the parent container should have been replaced with a UnionVector.
+      UnionVector promotedVector = container.getChild("test", UnionVector.class);
+      LargeVarCharVector vector = promotedVector.getLargeVarCharVector();
+      assertEquals("foo", vector.getObject(0).toString());
+      assertEquals("foo2", vector.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void testPromoteVarBinaryHelpersOnStruct() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.varBinary("c").writeVarBinary("row1".getBytes());
+      writer.setPosition(1);
+      writer.varBinary("c").writeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      writer.setPosition(2);
+      writer.varBinary("c").writeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      writer.setPosition(3);
+      writer.varBinary("c").writeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      writer.end();
+
+      final VarBinaryVector uv = v.getChild("c", VarBinaryVector.class);
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
+
+  @Test
+  public void testPromoteVarBinaryHelpersDirect() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.writeVarBinary("row1".getBytes());
+      writer.setPosition(1);
+      writer.writeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      writer.setPosition(2);
+      writer.writeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      writer.setPosition(3);
+      writer.writeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      writer.end();
+
+      // The "test" vector in the parent container should have been replaced with a UnionVector.
+      UnionVector promotedVector = container.getChild("test", UnionVector.class);
+      VarBinaryVector uv = promotedVector.getVarBinaryVector();
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
+
+  @Test
+  public void testPromoteLargeVarBinaryHelpersOnStruct() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.largeVarBinary("c").writeLargeVarBinary("row1".getBytes());
+      writer.setPosition(1);
+      writer.largeVarBinary("c").writeLargeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      writer.setPosition(2);
+      writer.largeVarBinary("c").writeLargeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      writer.setPosition(3);
+      writer.largeVarBinary("c").writeLargeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      writer.end();
+
+      final LargeVarBinaryVector uv = v.getChild("c", LargeVarBinaryVector.class);
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
+
+  @Test
+  public void testPromoteLargeVarBinaryHelpersDirect() throws Exception {
+    try (final NonNullableStructVector container = NonNullableStructVector.empty(EMPTY_SCHEMA_PATH, allocator);
+         final StructVector v = container.addOrGetStruct("test");
+         final PromotableWriter writer = new PromotableWriter(v, container)) {
+      container.allocateNew();
+
+      writer.start();
+      writer.setPosition(0);
+      writer.writeLargeVarBinary("row1".getBytes());
+      writer.setPosition(1);
+      writer.writeLargeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      writer.setPosition(2);
+      writer.writeLargeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      writer.setPosition(3);
+      writer.writeLargeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      writer.end();
+
+      // The "test" vector in the parent container should have been replaced with a UnionVector.
+      UnionVector promotedVector = container.getChild("test", UnionVector.class);
+      LargeVarBinaryVector uv = promotedVector.getLargeVarBinaryVector();
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestComplexWriter.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestComplexWriter.java
index 6f7f5abd30ac9..96d39e85f1f4a 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestComplexWriter.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestComplexWriter.java
@@ -20,6 +20,7 @@
 import static org.junit.Assert.*;
 
 import java.math.BigDecimal;
+import java.nio.ByteBuffer;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -35,7 +36,11 @@
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
+import org.apache.arrow.vector.LargeVarBinaryVector;
+import org.apache.arrow.vector.LargeVarCharVector;
 import org.apache.arrow.vector.SchemaChangeCallBack;
+import org.apache.arrow.vector.VarBinaryVector;
+import org.apache.arrow.vector.VarCharVector;
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.complex.MapVector;
 import org.apache.arrow.vector.complex.NonNullableStructVector;
@@ -1667,4 +1672,210 @@ public void testMapWithStructKey() {
       assertEquals(1, mapReader.value().readInteger().intValue());
     }
   }
+
+  @Test
+  public void structWriterVarCharHelpers() {
+    try (NonNullableStructVector parent = NonNullableStructVector.empty("parent", allocator)) {
+      ComplexWriter writer = new ComplexWriterImpl("root", parent, false, true);
+      StructWriter rootWriter = writer.rootAsStruct();
+      rootWriter.start();
+      rootWriter.setPosition(0);
+      rootWriter.varChar("c").writeVarChar(new Text("row1"));
+      rootWriter.setPosition(1);
+      rootWriter.varChar("c").writeVarChar("row2");
+      rootWriter.end();
+
+      VarCharVector vector = parent.getChild("root", StructVector.class).getChild("c", VarCharVector.class);
+
+      assertEquals("row1", vector.getObject(0).toString());
+      assertEquals("row2", vector.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void structWriterLargeVarCharHelpers() {
+    try (NonNullableStructVector parent = NonNullableStructVector.empty("parent", allocator)) {
+      ComplexWriter writer = new ComplexWriterImpl("root", parent, false, true);
+      StructWriter rootWriter = writer.rootAsStruct();
+      rootWriter.start();
+      rootWriter.setPosition(0);
+      rootWriter.largeVarChar("c").writeLargeVarChar(new Text("row1"));
+      rootWriter.setPosition(1);
+      rootWriter.largeVarChar("c").writeLargeVarChar("row2");
+      rootWriter.end();
+
+      LargeVarCharVector vector = parent.getChild("root", StructVector.class).getChild("c",
+          LargeVarCharVector.class);
+
+      assertEquals("row1", vector.getObject(0).toString());
+      assertEquals("row2", vector.getObject(1).toString());
+    }
+  }
+
+  @Test
+  public void structWriterVarBinaryHelpers() {
+    try (NonNullableStructVector parent = NonNullableStructVector.empty("parent", allocator)) {
+      ComplexWriter writer = new ComplexWriterImpl("root", parent, false, true);
+      StructWriter rootWriter = writer.rootAsStruct();
+      rootWriter.start();
+      rootWriter.setPosition(0);
+      rootWriter.varBinary("c").writeVarBinary("row1".getBytes());
+      rootWriter.setPosition(1);
+      rootWriter.varBinary("c").writeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      rootWriter.setPosition(2);
+      rootWriter.varBinary("c").writeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      rootWriter.setPosition(3);
+      rootWriter.varBinary("c").writeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      rootWriter.end();
+
+      VarBinaryVector uv = parent.getChild("root", StructVector.class).getChild("c", VarBinaryVector.class);
+
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
+
+  @Test
+  public void structWriterLargeVarBinaryHelpers() {
+    try (NonNullableStructVector parent = NonNullableStructVector.empty("parent", allocator)) {
+      ComplexWriter writer = new ComplexWriterImpl("root", parent, false, true);
+      StructWriter rootWriter = writer.rootAsStruct();
+      rootWriter.start();
+      rootWriter.setPosition(0);
+      rootWriter.largeVarBinary("c").writeLargeVarBinary("row1".getBytes());
+      rootWriter.setPosition(1);
+      rootWriter.largeVarBinary("c").writeLargeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      rootWriter.setPosition(2);
+      rootWriter.largeVarBinary("c").writeLargeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      rootWriter.setPosition(3);
+      rootWriter.largeVarBinary("c").writeLargeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0,
+          "row4".getBytes().length);
+      rootWriter.end();
+
+      LargeVarBinaryVector uv = parent.getChild("root", StructVector.class).getChild("c",
+          LargeVarBinaryVector.class);
+
+      assertEquals("row1", new String(uv.get(0)));
+      assertEquals("row2", new String(uv.get(1)));
+      assertEquals("row3", new String(uv.get(2)));
+      assertEquals("row4", new String(uv.get(3)));
+    }
+  }
+
+  @Test
+  public void listVarCharHelpers() {
+    try (ListVector listVector = ListVector.empty("list", allocator)) {
+      listVector.allocateNew();
+      UnionListWriter listWriter = new UnionListWriter(listVector);
+      listWriter.startList();
+      listWriter.writeVarChar("row1");
+      listWriter.writeVarChar(new Text("row2"));
+      listWriter.endList();
+      listWriter.setValueCount(1);
+      assertEquals("row1", listVector.getObject(0).get(0).toString());
+      assertEquals("row2", listVector.getObject(0).get(1).toString());
+    }
+  }
+
+  @Test
+  public void listLargeVarCharHelpers() {
+    try (ListVector listVector = ListVector.empty("list", allocator)) {
+      listVector.allocateNew();
+      UnionListWriter listWriter = new UnionListWriter(listVector);
+      listWriter.startList();
+      listWriter.writeLargeVarChar("row1");
+      listWriter.writeLargeVarChar(new Text("row2"));
+      listWriter.endList();
+      listWriter.setValueCount(1);
+      assertEquals("row1", listVector.getObject(0).get(0).toString());
+      assertEquals("row2", listVector.getObject(0).get(1).toString());
+    }
+  }
+
+  @Test
+  public void listVarBinaryHelpers() {
+    try (ListVector listVector = ListVector.empty("list", allocator)) {
+      listVector.allocateNew();
+      UnionListWriter listWriter = new UnionListWriter(listVector);
+      listWriter.startList();
+      listWriter.writeVarBinary("row1".getBytes());
+      listWriter.writeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      listWriter.writeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      listWriter.writeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      listWriter.endList();
+      listWriter.setValueCount(1);
+      assertEquals("row1", new String((byte[]) listVector.getObject(0).get(0)));
+      assertEquals("row2", new String((byte[]) listVector.getObject(0).get(1)));
+      assertEquals("row3", new String((byte[]) listVector.getObject(0).get(2)));
+      assertEquals("row4", new String((byte[]) listVector.getObject(0).get(3)));
+    }
+  }
+
+  @Test
+  public void listLargeVarBinaryHelpers() {
+    try (ListVector listVector = ListVector.empty("list", allocator)) {
+      listVector.allocateNew();
+      UnionListWriter listWriter = new UnionListWriter(listVector);
+      listWriter.startList();
+      listWriter.writeLargeVarBinary("row1".getBytes());
+      listWriter.writeLargeVarBinary("row2".getBytes(), 0, "row2".getBytes().length);
+      listWriter.writeLargeVarBinary(ByteBuffer.wrap("row3".getBytes()));
+      listWriter.writeLargeVarBinary(ByteBuffer.wrap("row4".getBytes()), 0, "row4".getBytes().length);
+      listWriter.endList();
+      listWriter.setValueCount(1);
+      assertEquals("row1", new String((byte[]) listVector.getObject(0).get(0)));
+      assertEquals("row2", new String((byte[]) listVector.getObject(0).get(1)));
+      assertEquals("row3", new String((byte[]) listVector.getObject(0).get(2)));
+      assertEquals("row4", new String((byte[]) listVector.getObject(0).get(3)));
+    }
+  }
+
+  @Test
+  public void unionWithVarCharAndBinaryHelpers() throws Exception {
+    try (UnionVector vector = new UnionVector("union", allocator, /* field type */ null, /* call-back */ null)) {
+      UnionWriter unionWriter = new UnionWriter(vector);
+      unionWriter.allocate();
+      unionWriter.start();
+      unionWriter.setPosition(0);
+      unionWriter.writeVarChar("row1");
+      unionWriter.setPosition(1);
+      unionWriter.writeVarChar(new Text("row2"));
+      unionWriter.setPosition(2);
+      unionWriter.writeLargeVarChar("row3");
+      unionWriter.setPosition(3);
+      unionWriter.writeLargeVarChar(new Text("row4"));
+      unionWriter.setPosition(4);
+      unionWriter.writeVarBinary("row5".getBytes());
+      unionWriter.setPosition(5);
+      unionWriter.writeVarBinary("row6".getBytes(), 0, "row6".getBytes().length);
+      unionWriter.setPosition(6);
+      unionWriter.writeVarBinary(ByteBuffer.wrap("row7".getBytes()));
+      unionWriter.setPosition(7);
+      unionWriter.writeVarBinary(ByteBuffer.wrap("row8".getBytes()), 0, "row8".getBytes().length);
+      unionWriter.setPosition(8);
+      unionWriter.writeLargeVarBinary("row9".getBytes());
+      unionWriter.setPosition(9);
+      unionWriter.writeLargeVarBinary("row10".getBytes(), 0, "row10".getBytes().length);
+      unionWriter.setPosition(10);
+      unionWriter.writeLargeVarBinary(ByteBuffer.wrap("row11".getBytes()));
+      unionWriter.setPosition(11);
+      unionWriter.writeLargeVarBinary(ByteBuffer.wrap("row12".getBytes()), 0, "row12".getBytes().length);
+      unionWriter.end();
+
+      assertEquals("row1", new String(vector.getVarCharVector().get(0)));
+      assertEquals("row2", new String(vector.getVarCharVector().get(1)));
+      assertEquals("row3", new String(vector.getLargeVarCharVector().get(2)));
+      assertEquals("row4", new String(vector.getLargeVarCharVector().get(3)));
+      assertEquals("row5", new String(vector.getVarBinaryVector().get(4)));
+      assertEquals("row6", new String(vector.getVarBinaryVector().get(5)));
+      assertEquals("row7", new String(vector.getVarBinaryVector().get(6)));
+      assertEquals("row8", new String(vector.getVarBinaryVector().get(7)));
+      assertEquals("row9", new String(vector.getLargeVarBinaryVector().get(8)));
+      assertEquals("row10", new String(vector.getLargeVarBinaryVector().get(9)));
+      assertEquals("row11", new String(vector.getLargeVarBinaryVector().get(10)));
+      assertEquals("row12", new String(vector.getLargeVarBinaryVector().get(11)));
+    }
+  }
 }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
index ef918b13fb691..27b8f1796ee31 100644
--- a/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
+++ b/java/vector/src/test/java/org/apache/arrow/vector/complex/writer/TestSimpleWriter.java
@@ -54,7 +54,7 @@ public void testWriteByteArrayToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
          VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
-      writer.writeToVarBinary(input);
+      writer.writeVarBinary(input);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(input, result);
     }
@@ -65,7 +65,7 @@ public void testWriteByteArrayWithOffsetToVarBinary() throws Exception {
     try (VarBinaryVector vector = new VarBinaryVector("test", allocator);
          VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
-      writer.writeToVarBinary(input, 1, 1);
+      writer.writeVarBinary(input, 1, 1);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(new byte[] { 0x02 }, result);
     }
@@ -77,7 +77,7 @@ public void testWriteByteBufferToVarBinary() throws Exception {
          VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
-      writer.writeToVarBinary(buffer);
+      writer.writeVarBinary(buffer);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(input, result);
     }
@@ -89,7 +89,7 @@ public void testWriteByteBufferWithOffsetToVarBinary() throws Exception {
          VarBinaryWriter writer = new VarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
-      writer.writeToVarBinary(buffer, 1, 1);
+      writer.writeVarBinary(buffer, 1, 1);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(new byte[] { 0x02 }, result);
     }
@@ -100,7 +100,7 @@ public void testWriteByteArrayToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
          LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
-      writer.writeToLargeVarBinary(input);
+      writer.writeLargeVarBinary(input);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(input, result);
     }
@@ -111,7 +111,7 @@ public void testWriteByteArrayWithOffsetToLargeVarBinary() throws Exception {
     try (LargeVarBinaryVector vector = new LargeVarBinaryVector("test", allocator);
          LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
-      writer.writeToLargeVarBinary(input, 1, 1);
+      writer.writeLargeVarBinary(input, 1, 1);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(new byte[] { 0x02 }, result);
     }
@@ -123,7 +123,7 @@ public void testWriteByteBufferToLargeVarBinary() throws Exception {
          LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
-      writer.writeToLargeVarBinary(buffer);
+      writer.writeLargeVarBinary(buffer);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(input, result);
     }
@@ -135,7 +135,7 @@ public void testWriteByteBufferWithOffsetToLargeVarBinary() throws Exception {
          LargeVarBinaryWriter writer = new LargeVarBinaryWriterImpl(vector)) {
       byte[] input = new byte[] { 0x01, 0x02 };
       ByteBuffer buffer = ByteBuffer.wrap(input);
-      writer.writeToLargeVarBinary(buffer, 1, 1);
+      writer.writeLargeVarBinary(buffer, 1, 1);
       byte[] result = vector.get(0);
       Assert.assertArrayEquals(new byte[] { 0x02 }, result);
     }

From 8fcaba7c10ed84bea00351133d924407dec1e18a Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Thu, 9 Nov 2023 21:57:54 -0400
Subject: [PATCH 712/749] MINOR: [R] Fix broken link in README.md (#38657)

### Rationale for this change

There is a broken link in README.md that refers to an old URL in the Arrow documentation. This causes the CRAN incoming check to fail.

### What changes are included in this PR?

The link was updated.

### Are these changes tested?

Not needed (docs only)

### Are there any user-facing changes?

No

Lead-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Co-authored-by: Sutou Kouhei <kou@cozmixng.org>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/r/README.md b/r/README.md
index 3c1e3570ffdd4..72c1574417a20 100644
--- a/r/README.md
+++ b/r/README.md
@@ -101,7 +101,7 @@ issue you want to create. Add a meaningful title prefixed with **`[R]`**
 followed by a space, the issue summary and select component **R** from the
 dropdown list. For more information, see the **Report bugs and propose
 features** section of the [Contributing to Apache
-Arrow](https://arrow.apache.org/docs/developers/contributing.html) page
+Arrow](https://arrow.apache.org/docs/developers/#contributing) page
 in the Arrow developer documentation.
 
 We welcome questions, discussion, and contributions from users of the

From c260a24fb17a78cde65aabec724a2dace408e5cc Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Thu, 9 Nov 2023 22:00:37 -0400
Subject: [PATCH 713/749] GH-38430: [R] Add test + fix corner cases after
 nixlibs.R refactor (#38534)

### Rationale for this change

A few rough edges exist after https://github.com/apache/arrow/pull/38236 including:

- When zero or 1 nightly with the matching major version exist, detection of the latest nightly might fail
- At least one CI job is pulling nightlies instead of using the version from the current commit

### What changes are included in this PR?

- Clean up `find_latest_nightly()` + add test
- Ensure all CI jobs are not using `find_latest_nightly()`

### Are these changes tested?

Yes (test added)

### Are there any user-facing changes?

No
* Closes: #38430

Lead-authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Co-authored-by: Jonathan Keane <jkeane@gmail.com>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/tools/nixlibs.R       | 46 ++++++++++++++++++++---------
 r/tools/test-nixlibs.R  | 65 +++++++++++++++++++++++++++++++++++++++++
 r/vignettes/install.Rmd |  1 +
 3 files changed, 98 insertions(+), 14 deletions(-)

diff --git a/r/tools/nixlibs.R b/r/tools/nixlibs.R
index 63c185ce54563..436eefcfcfe3e 100644
--- a/r/tools/nixlibs.R
+++ b/r/tools/nixlibs.R
@@ -35,7 +35,9 @@ exit <- function(..., .status = 1) {
 
 
 # checks the nightly repo for the latest nightly version X.Y.Z.100<dev>
-find_latest_nightly <- function(description_version) {
+find_latest_nightly <- function(description_version,
+                                list_uri = "https://nightlies.apache.org/arrow/r/src/contrib/PACKAGES",
+                                hush = quietly) {
   if (!startsWith(arrow_repo, "https://nightlies.apache.org/arrow/r")) {
     lg("Detected non standard dev repo: %s, not checking latest nightly version.", arrow_repo)
     return(description_version)
@@ -44,17 +46,28 @@ find_latest_nightly <- function(description_version) {
   res <- try(
     {
       # Binaries are only uploaded if all jobs pass so can just look at the source versions.
-      urls <- readLines("https://nightlies.apache.org/arrow/r/src/contrib")
-      versions <- grep("arrow_.*\\.tar\\.gz", urls, value = TRUE)
-      versions <- sub(".*arrow_(.*)\\.tar\\.gz.*", "\\1", x = versions)
-      versions <- sapply(versions, package_version)
-      versions <- data.frame(do.call(rbind, versions))
-      matching_major <- versions[versions$X1 == description_version[1, 1], ]
-      latest <- matching_major[which.max(matching_major$X4), ]
-      package_version(paste0(latest, collapse = "."))
+      urls <- readLines(list_uri)
+      versions <- grep("Version:\\s*.*?", urls, value = TRUE)
+      versions <- sort(package_version(sub("Version:\\s*", "\\1", versions)))
+      major_versions <- versions$major
+
+      description_version_major <- as.integer(description_version[1, 1])
+      matching_major <- major_versions == description_version_major
+      if (!any(matching_major)) {
+        lg(
+          "No nightly binaries were found for version %s: falling back to libarrow build from source",
+          description_version
+        )
+
+        return(description_version)
+      }
+
+      versions <- versions[matching_major]
+      max(versions)
     },
-    silent = quietly
+    silent = hush
   )
+
   if (inherits(res, "try-error")) {
     lg("Failed to find latest nightly for %s", description_version)
     latest <- description_version
@@ -832,16 +845,19 @@ quietly <- !env_is("ARROW_R_DEV", "true")
 
 not_cran <- env_is("NOT_CRAN", "true")
 
-if (is_release & !test_mode) {
+if (is_release) {
   VERSION <- VERSION[1, 1:3]
   arrow_repo <- paste0(getOption("arrow.repo", sprintf("https://apache.jfrog.io/artifactory/arrow/r/%s", VERSION)), "/libarrow/")
-} else if(!test_mode) {
+} else {
   not_cran <- TRUE
   arrow_repo <- paste0(getOption("arrow.dev_repo", "https://nightlies.apache.org/arrow/r"), "/libarrow/")
+}
+
+if (!is_release && !test_mode) {
   VERSION <- find_latest_nightly(VERSION)
 }
 
-# To collect dirs to rm on exit, use del() to add dirs
+# To collect dirs to rm on exit, use cleanup() to add dirs
 # we reset it to avoid errors on reruns in the same session.
 options(.arrow.cleanup = character())
 on.exit(unlink(getOption(".arrow.cleanup"), recursive = TRUE), add = TRUE)
@@ -867,6 +883,8 @@ build_ok <- !env_is("LIBARROW_BUILD", "false")
 #  https://arrow.apache.org/docs/developers/cpp/building.html#offline-builds)
 download_ok <- !test_mode && !env_is("TEST_OFFLINE_BUILD", "true")
 
+download_libarrow_ok <- download_ok && !env_is("LIBARROW_DOWNLOAD", "false")
+
 # This "tools/thirdparty_dependencies" path, within the tar file, might exist if
 # create_package_with_all_dependencies() was run, or if someone has created it
 # manually before running make build.
@@ -904,7 +922,7 @@ if (!test_mode && !file.exists(api_h)) {
       lg("File not found: %s ($ARROW_DOWNLOADED_BINARIES)", bin_zip)
       bin_file <- NULL
     }
-  } else if (download_ok) {
+  } else if (download_libarrow_ok) {
     binary_flavor <- identify_binary()
     if (!is.null(binary_flavor)) {
       # The env vars say we can, and we've determined a lib that should work
diff --git a/r/tools/test-nixlibs.R b/r/tools/test-nixlibs.R
index c9571b58b7bbf..f97a80ccc2917 100644
--- a/r/tools/test-nixlibs.R
+++ b/r/tools/test-nixlibs.R
@@ -155,3 +155,68 @@ test_that("check_allowlist", {
   expect_true(check_allowlist("redhat", tempfile())) # remote allowlist doesn't exist, so we fall back to the default list, which contains redhat
   expect_false(check_allowlist("debian", tempfile()))
 })
+
+test_that("find_latest_nightly()", {
+  tf <- tempfile()
+  tf_uri <- paste0("file://", tf)
+  on.exit(unlink(tf))
+
+  writeLines(
+    c(
+      "Version: 13.0.0.100000333",
+      "Version: 13.0.0.100000334",
+      "Version: 13.0.0.100000335",
+      "Version: 14.0.0.100000001"
+    ),
+    tf
+  )
+
+  expect_output(
+    expect_identical(
+      find_latest_nightly(package_version("13.0.1.9000"), list_uri = tf_uri),
+      package_version("13.0.0.100000335")
+    ),
+    "Found latest nightly"
+  )
+
+  expect_output(
+    expect_identical(
+      find_latest_nightly(package_version("14.0.0.9000"), list_uri = tf_uri),
+      package_version("14.0.0.100000001")
+    ),
+    "Found latest nightly"
+  )
+
+  expect_output(
+    expect_identical(
+      find_latest_nightly(package_version("15.0.0.9000"), list_uri = tf_uri),
+      package_version("15.0.0.9000")
+    ),
+    "No nightly binaries were found for version"
+  )
+
+  # Check empty input
+  writeLines(character(), tf)
+  expect_output(
+    expect_identical(
+      find_latest_nightly(package_version("15.0.0.9000"), list_uri = tf_uri),
+      package_version("15.0.0.9000")
+    ),
+    "No nightly binaries were found for version"
+  )
+
+  # Check input that will throw an error
+  expect_output(
+    expect_identical(
+      suppressWarnings(
+        find_latest_nightly(
+          package_version("15.0.0.9000"),
+          list_uri = "this is not a URI",
+          hush = TRUE
+        )
+      ),
+      package_version("15.0.0.9000")
+    ),
+    "Failed to find latest nightly"
+  )
+})
diff --git a/r/vignettes/install.Rmd b/r/vignettes/install.Rmd
index 20fe4ed8961c6..10155e3a8cd5b 100644
--- a/r/vignettes/install.Rmd
+++ b/r/vignettes/install.Rmd
@@ -283,6 +283,7 @@ the bundled build script.  All boolean variables are case-insensitive.
 | --- | --- | :-: |
 | `LIBARROW_BUILD` | Allow building from source | `true` |
 | `LIBARROW_BINARY` | Try to install `libarrow` binary instead of building from source | (unset) |
+| `LIBARROW_DOWNLOAD` | Set to `false` to explicitly forbid fetching a `libarrow` binary | (unset) |
 | `LIBARROW_MINIMAL` | Build with minimal features enabled | (unset) |
 | `NOT_CRAN` | Set `LIBARROW_BINARY=true` and `LIBARROW_MINIMAL=false` | `false` |
 | `ARROW_R_DEV` | More verbose messaging and regenerates some code | `false` |

From e5b2bba2229836f7b1b37a06d62081cb214d598a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Fri, 10 Nov 2023 16:21:57 +0100
Subject: [PATCH 714/749] MINOR: [Release] Update versions for 14.0.1-SNAPSHOT

---
 c_glib/meson.build                            |  2 +-
 cpp/CMakeLists.txt                            |  2 +-
 cpp/vcpkg.json                                |  2 +-
 csharp/Directory.Build.props                  |  2 +-
 .../homebrew-formulae/apache-arrow-glib.rb    |  2 +-
 dev/tasks/homebrew-formulae/apache-arrow.rb   |  2 +-
 go/README.md                                  |  2 +-
 go/arrow/_examples/helloworld/main.go         |  8 ++---
 go/arrow/_tools/tmpl/main.go                  |  2 +-
 go/arrow/array.go                             |  4 +--
 go/arrow/array/array.go                       |  6 ++--
 go/arrow/array/array_test.go                  | 10 +++---
 go/arrow/array/binary.go                      |  4 +--
 go/arrow/array/binary_test.go                 |  6 ++--
 go/arrow/array/binarybuilder.go               |  8 ++---
 go/arrow/array/binarybuilder_test.go          |  6 ++--
 go/arrow/array/boolean.go                     |  8 ++---
 go/arrow/array/boolean_test.go                |  4 +--
 go/arrow/array/booleanbuilder.go              | 10 +++---
 go/arrow/array/booleanbuilder_test.go         |  6 ++--
 go/arrow/array/bufferbuilder.go               |  6 ++--
 go/arrow/array/bufferbuilder_byte.go          |  2 +-
 go/arrow/array/bufferbuilder_numeric.gen.go   |  6 ++--
 .../array/bufferbuilder_numeric.gen.go.tmpl   |  6 ++--
 go/arrow/array/bufferbuilder_numeric_test.go  |  4 +--
 go/arrow/array/builder.go                     |  8 ++---
 go/arrow/array/builder_test.go                |  4 +--
 go/arrow/array/compare.go                     |  6 ++--
 go/arrow/array/compare_test.go                | 10 +++---
 go/arrow/array/concat.go                      | 14 ++++----
 go/arrow/array/concat_test.go                 | 10 +++---
 go/arrow/array/data.go                        |  6 ++--
 go/arrow/array/data_test.go                   |  4 +--
 go/arrow/array/decimal128.go                  | 12 +++----
 go/arrow/array/decimal128_test.go             |  8 ++---
 go/arrow/array/decimal256.go                  | 12 +++----
 go/arrow/array/decimal256_test.go             |  8 ++---
 go/arrow/array/decimal_test.go                | 12 +++----
 go/arrow/array/dictionary.go                  | 20 ++++++------
 go/arrow/array/dictionary_test.go             | 14 ++++----
 go/arrow/array/diff.go                        |  2 +-
 go/arrow/array/diff_test.go                   | 10 +++---
 go/arrow/array/encoded.go                     | 12 +++----
 go/arrow/array/encoded_test.go                |  8 ++---
 go/arrow/array/extension.go                   |  6 ++--
 go/arrow/array/extension_test.go              |  8 ++---
 go/arrow/array/fixed_size_list.go             | 10 +++---
 go/arrow/array/fixed_size_list_test.go        |  6 ++--
 go/arrow/array/fixedsize_binary.go            |  4 +--
 go/arrow/array/fixedsize_binary_test.go       |  6 ++--
 go/arrow/array/fixedsize_binarybuilder.go     |  8 ++---
 .../array/fixedsize_binarybuilder_test.go     |  4 +--
 go/arrow/array/float16.go                     |  6 ++--
 go/arrow/array/float16_builder.go             | 12 +++----
 go/arrow/array/float16_builder_test.go        |  6 ++--
 go/arrow/array/interval.go                    | 10 +++---
 go/arrow/array/interval_test.go               |  6 ++--
 go/arrow/array/json_reader.go                 |  8 ++---
 go/arrow/array/json_reader_test.go            |  6 ++--
 go/arrow/array/list.go                        | 10 +++---
 go/arrow/array/list_test.go                   |  6 ++--
 go/arrow/array/map.go                         |  6 ++--
 go/arrow/array/map_test.go                    |  6 ++--
 go/arrow/array/null.go                        |  8 ++---
 go/arrow/array/null_test.go                   |  6 ++--
 go/arrow/array/numeric.gen.go                 |  4 +--
 go/arrow/array/numeric.gen.go.tmpl            |  4 +--
 go/arrow/array/numeric_test.go                |  8 ++---
 go/arrow/array/numericbuilder.gen.go          | 10 +++---
 go/arrow/array/numericbuilder.gen.go.tmpl     | 10 +++---
 go/arrow/array/numericbuilder.gen_test.go     |  6 ++--
 .../array/numericbuilder.gen_test.go.tmpl     |  6 ++--
 go/arrow/array/record.go                      |  8 ++---
 go/arrow/array/record_test.go                 |  6 ++--
 go/arrow/array/string.go                      |  6 ++--
 go/arrow/array/string_test.go                 |  8 ++---
 go/arrow/array/struct.go                      | 10 +++---
 go/arrow/array/struct_test.go                 |  6 ++--
 go/arrow/array/table.go                       |  4 +--
 go/arrow/array/table_test.go                  |  6 ++--
 go/arrow/array/timestamp.go                   | 10 +++---
 go/arrow/array/timestamp_test.go              |  6 ++--
 go/arrow/array/union.go                       | 12 +++----
 go/arrow/array/union_test.go                  |  6 ++--
 go/arrow/array/util.go                        | 10 +++---
 go/arrow/array/util_test.go                   | 14 ++++----
 go/arrow/arrio/arrio.go                       |  2 +-
 go/arrow/arrio/arrio_test.go                  | 10 +++---
 go/arrow/bitutil/bitmaps.go                   |  6 ++--
 go/arrow/bitutil/bitmaps_test.go              |  4 +--
 go/arrow/bitutil/bitutil.go                   |  2 +-
 go/arrow/bitutil/bitutil_test.go              |  4 +--
 go/arrow/cdata/cdata.go                       |  8 ++---
 go/arrow/cdata/cdata_exports.go               | 10 +++---
 go/arrow/cdata/cdata_test.go                  | 12 +++----
 go/arrow/cdata/cdata_test_framework.go        |  8 ++---
 go/arrow/cdata/exports.go                     |  4 +--
 go/arrow/cdata/import_allocator.go            |  2 +-
 go/arrow/cdata/interface.go                   |  8 ++---
 go/arrow/cdata/test/test_cimport.go           |  8 ++---
 go/arrow/compute/arithmetic.go                | 12 +++----
 go/arrow/compute/arithmetic_test.go           | 20 ++++++------
 go/arrow/compute/cast.go                      | 10 +++---
 go/arrow/compute/cast_test.go                 | 20 ++++++------
 go/arrow/compute/datum.go                     |  6 ++--
 go/arrow/compute/example_test.go              | 10 +++---
 go/arrow/compute/exec.go                      |  6 ++--
 go/arrow/compute/exec/kernel.go               |  8 ++---
 go/arrow/compute/exec/kernel_test.go          | 12 +++----
 go/arrow/compute/exec/span.go                 | 10 +++---
 go/arrow/compute/exec/span_test.go            | 16 +++++-----
 go/arrow/compute/exec/utils.go                | 14 ++++----
 go/arrow/compute/exec/utils_test.go           |  8 ++---
 go/arrow/compute/exec_internals_test.go       | 14 ++++----
 go/arrow/compute/exec_test.go                 | 12 +++----
 go/arrow/compute/executor.go                  | 16 +++++-----
 go/arrow/compute/expression.go                | 16 +++++-----
 go/arrow/compute/expression_test.go           | 10 +++---
 go/arrow/compute/exprs/builders.go            |  4 +--
 go/arrow/compute/exprs/builders_test.go       |  4 +--
 go/arrow/compute/exprs/exec.go                | 18 +++++------
 go/arrow/compute/exprs/exec_internal_test.go  |  8 ++---
 go/arrow/compute/exprs/exec_test.go           | 12 +++----
 go/arrow/compute/exprs/extension_types.go     |  4 +--
 go/arrow/compute/exprs/field_refs.go          | 10 +++---
 go/arrow/compute/exprs/types.go               |  4 +--
 go/arrow/compute/fieldref.go                  |  4 +--
 go/arrow/compute/fieldref_test.go             |  8 ++---
 go/arrow/compute/functions.go                 |  4 +--
 go/arrow/compute/functions_test.go            |  4 +--
 .../internal/kernels/base_arithmetic.go       | 10 +++---
 .../internal/kernels/base_arithmetic_amd64.go |  4 +--
 .../kernels/base_arithmetic_avx2_amd64.go     |  2 +-
 .../kernels/base_arithmetic_sse4_amd64.go     |  2 +-
 .../kernels/basic_arithmetic_noasm.go         |  2 +-
 .../compute/internal/kernels/boolean_cast.go  |  6 ++--
 go/arrow/compute/internal/kernels/cast.go     |  6 ++--
 .../compute/internal/kernels/cast_numeric.go  |  2 +-
 .../kernels/cast_numeric_avx2_amd64.go        |  2 +-
 .../kernels/cast_numeric_neon_arm64.go        |  2 +-
 .../kernels/cast_numeric_sse4_amd64.go        |  2 +-
 .../compute/internal/kernels/cast_temporal.go |  8 ++---
 go/arrow/compute/internal/kernels/helpers.go  | 14 ++++----
 .../compute/internal/kernels/numeric_cast.go  | 14 ++++----
 go/arrow/compute/internal/kernels/rounding.go | 10 +++---
 .../internal/kernels/scalar_arithmetic.go     | 14 ++++----
 .../internal/kernels/scalar_boolean.go        |  6 ++--
 .../kernels/scalar_comparison_amd64.go        |  4 +--
 .../kernels/scalar_comparison_avx2_amd64.go   |  2 +-
 .../kernels/scalar_comparison_noasm.go        |  2 +-
 .../kernels/scalar_comparison_sse4_amd64.go   |  2 +-
 .../internal/kernels/scalar_comparisons.go    | 16 +++++-----
 .../compute/internal/kernels/string_casts.go  | 12 +++----
 go/arrow/compute/internal/kernels/types.go    |  8 ++---
 .../compute/internal/kernels/vector_hash.go   | 14 ++++----
 .../internal/kernels/vector_run_end_encode.go | 16 +++++-----
 .../internal/kernels/vector_selection.go      | 14 ++++----
 go/arrow/compute/registry.go                  |  2 +-
 go/arrow/compute/registry_test.go             |  6 ++--
 go/arrow/compute/scalar_bool.go               |  6 ++--
 go/arrow/compute/scalar_bool_test.go          | 10 +++---
 go/arrow/compute/scalar_compare.go            |  6 ++--
 go/arrow/compute/scalar_compare_test.go       | 18 +++++------
 go/arrow/compute/selection.go                 |  8 ++---
 go/arrow/compute/utils.go                     | 12 +++----
 go/arrow/compute/vector_hash.go               |  4 +--
 go/arrow/compute/vector_hash_test.go          | 14 ++++----
 go/arrow/compute/vector_run_end_test.go       | 14 ++++----
 go/arrow/compute/vector_run_ends.go           |  4 +--
 go/arrow/compute/vector_selection_test.go     | 18 +++++------
 go/arrow/csv/common.go                        |  4 +--
 go/arrow/csv/reader.go                        | 14 ++++----
 go/arrow/csv/reader_test.go                   | 14 ++++----
 go/arrow/csv/transformer.go                   |  4 +--
 go/arrow/csv/writer.go                        |  2 +-
 go/arrow/csv/writer_test.go                   | 16 +++++-----
 go/arrow/datatype.go                          |  2 +-
 go/arrow/datatype_binary_test.go              |  2 +-
 go/arrow/datatype_extension_test.go           |  4 +--
 go/arrow/datatype_fixedwidth.go               |  2 +-
 go/arrow/datatype_fixedwidth_test.go          |  2 +-
 go/arrow/datatype_nested.go                   |  2 +-
 go/arrow/datatype_null_test.go                |  2 +-
 go/arrow/decimal128/decimal128.go             |  2 +-
 go/arrow/decimal128/decimal128_test.go        |  2 +-
 go/arrow/decimal256/decimal256.go             |  4 +--
 go/arrow/decimal256/decimal256_test.go        |  2 +-
 go/arrow/doc.go                               |  2 +-
 go/arrow/encoded/ree_utils.go                 |  2 +-
 go/arrow/encoded/ree_utils_test.go            |  8 ++---
 go/arrow/endian/endian.go                     |  4 +--
 go/arrow/example_test.go                      |  8 ++---
 go/arrow/flight/basic_auth_flight_test.go     |  2 +-
 go/arrow/flight/client.go                     |  2 +-
 go/arrow/flight/cookie_middleware_test.go     |  2 +-
 go/arrow/flight/example_flight_server_test.go |  2 +-
 go/arrow/flight/flight_middleware_test.go     |  4 +--
 go/arrow/flight/flight_test.go                | 10 +++---
 go/arrow/flight/flightsql/client.go           | 12 +++----
 go/arrow/flight/flightsql/client_test.go      | 12 +++----
 go/arrow/flight/flightsql/column_metadata.go  |  2 +-
 go/arrow/flight/flightsql/driver/README.md    |  6 ++--
 .../flight/flightsql/driver/config_test.go    |  2 +-
 go/arrow/flight/flightsql/driver/driver.go    | 10 +++---
 .../flight/flightsql/driver/driver_test.go    | 14 ++++----
 go/arrow/flight/flightsql/driver/utils.go     |  4 +--
 .../flight/flightsql/driver/utils_test.go     | 12 +++----
 .../cmd/sqlite_flightsql_server/main.go       |  6 ++--
 .../flightsql/example/sql_batch_reader.go     | 10 +++---
 .../flight/flightsql/example/sqlite_info.go   |  4 +--
 .../flight/flightsql/example/sqlite_server.go | 14 ++++----
 .../sqlite_tables_schema_batch_reader.go      | 12 +++----
 .../flight/flightsql/example/type_info.go     |  8 ++---
 .../flightsql/schema_ref/reference_schemas.go |  2 +-
 go/arrow/flight/flightsql/server.go           | 16 +++++-----
 go/arrow/flight/flightsql/server_test.go      | 12 +++----
 go/arrow/flight/flightsql/sql_info.go         |  4 +--
 .../flight/flightsql/sqlite_server_test.go    | 16 +++++-----
 go/arrow/flight/flightsql/types.go            |  2 +-
 go/arrow/flight/record_batch_reader.go        | 12 +++----
 go/arrow/flight/record_batch_writer.go        |  6 ++--
 go/arrow/flight/server.go                     |  2 +-
 go/arrow/flight/server_example_test.go        |  2 +-
 go/arrow/internal/arrdata/arrdata.go          | 16 +++++-----
 go/arrow/internal/arrdata/ioutil.go           | 10 +++---
 go/arrow/internal/arrjson/arrjson.go          | 20 ++++++------
 go/arrow/internal/arrjson/arrjson_test.go     |  6 ++--
 go/arrow/internal/arrjson/option.go           |  4 +--
 go/arrow/internal/arrjson/reader.go           | 10 +++---
 go/arrow/internal/arrjson/writer.go           | 10 +++---
 .../internal/cdata_integration/entrypoints.go |  8 ++---
 go/arrow/internal/dictutils/dict.go           |  6 ++--
 go/arrow/internal/dictutils/dict_test.go      |  8 ++---
 .../arrow-flight-integration-client/main.go   |  2 +-
 .../arrow-flight-integration-server/main.go   |  2 +-
 .../internal/flight_integration/scenario.go   | 18 +++++------
 .../internal/testing/gen/random_array_gen.go  | 10 +++---
 go/arrow/internal/testing/tools/bits_test.go  |  2 +-
 go/arrow/internal/testing/tools/data_types.go |  4 +--
 go/arrow/internal/utils.go                    |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main.go            |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main_test.go       |  8 ++---
 go/arrow/ipc/cmd/arrow-file-to-stream/main.go |  6 ++--
 .../ipc/cmd/arrow-file-to-stream/main_test.go |  4 +--
 .../cmd/arrow-json-integration-test/main.go   | 12 +++----
 .../arrow-json-integration-test/main_test.go  |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main.go             |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main_test.go        |  8 ++---
 go/arrow/ipc/cmd/arrow-stream-to-file/main.go |  6 ++--
 .../ipc/cmd/arrow-stream-to-file/main_test.go |  4 +--
 go/arrow/ipc/compression.go                   |  6 ++--
 go/arrow/ipc/endian_swap.go                   |  6 ++--
 go/arrow/ipc/endian_swap_test.go              | 10 +++---
 go/arrow/ipc/file_reader.go                   | 16 +++++-----
 go/arrow/ipc/file_test.go                     |  6 ++--
 go/arrow/ipc/file_writer.go                   | 10 +++---
 go/arrow/ipc/ipc.go                           |  8 ++---
 go/arrow/ipc/ipc_test.go                      |  8 ++---
 go/arrow/ipc/message.go                       |  6 ++--
 go/arrow/ipc/message_test.go                  |  6 ++--
 go/arrow/ipc/metadata.go                      | 10 +++---
 go/arrow/ipc/metadata_test.go                 | 12 +++----
 go/arrow/ipc/reader.go                        | 14 ++++----
 go/arrow/ipc/reader_test.go                   |  6 ++--
 go/arrow/ipc/stream_test.go                   |  6 ++--
 go/arrow/ipc/writer.go                        | 16 +++++-----
 go/arrow/ipc/writer_test.go                   | 10 +++---
 go/arrow/math/float64.go                      |  2 +-
 go/arrow/math/float64_avx2_amd64.go           |  2 +-
 go/arrow/math/float64_neon_arm64.go           |  2 +-
 go/arrow/math/float64_sse4_amd64.go           |  2 +-
 go/arrow/math/float64_test.go                 |  6 ++--
 go/arrow/math/int64.go                        |  2 +-
 go/arrow/math/int64_avx2_amd64.go             |  2 +-
 go/arrow/math/int64_neon_arm64.go             |  2 +-
 go/arrow/math/int64_sse4_amd64.go             |  2 +-
 go/arrow/math/int64_test.go                   |  6 ++--
 go/arrow/math/type.go.tmpl                    |  2 +-
 go/arrow/math/type_simd_amd64.go.tmpl         |  2 +-
 go/arrow/math/type_simd_arm64.go.tmpl         |  2 +-
 go/arrow/math/type_test.go.tmpl               |  6 ++--
 go/arrow/math/uint64.go                       |  2 +-
 go/arrow/math/uint64_avx2_amd64.go            |  2 +-
 go/arrow/math/uint64_neon_arm64.go            |  2 +-
 go/arrow/math/uint64_sse4_amd64.go            |  2 +-
 go/arrow/math/uint64_test.go                  |  6 ++--
 go/arrow/memory/buffer.go                     |  2 +-
 go/arrow/memory/buffer_test.go                |  2 +-
 go/arrow/memory/cgo_allocator.go              |  2 +-
 go/arrow/memory/default_mallocator.go         |  2 +-
 go/arrow/memory/default_mallocator_test.go    |  4 +--
 go/arrow/memory/mallocator/mallocator_test.go |  2 +-
 go/arrow/memory/memory_test.go                |  2 +-
 go/arrow/record.go                            |  2 +-
 go/arrow/scalar/append.go                     | 10 +++---
 go/arrow/scalar/append_test.go                | 10 +++---
 go/arrow/scalar/binary.go                     |  4 +--
 go/arrow/scalar/compare.go                    |  2 +-
 go/arrow/scalar/nested.go                     |  8 ++---
 go/arrow/scalar/numeric.gen.go                |  6 ++--
 go/arrow/scalar/numeric.gen_test.go           |  4 +--
 go/arrow/scalar/numeric.gen_test.go.tmpl      |  4 +--
 go/arrow/scalar/parse.go                      | 12 +++----
 go/arrow/scalar/scalar.go                     | 20 ++++++------
 go/arrow/scalar/scalar_test.go                | 12 +++----
 go/arrow/scalar/temporal.go                   |  2 +-
 go/arrow/schema.go                            |  2 +-
 go/arrow/schema_test.go                       |  2 +-
 go/arrow/table.go                             |  2 +-
 go/arrow/tensor/numeric.gen.go                |  2 +-
 go/arrow/tensor/numeric.gen.go.tmpl           |  4 +--
 go/arrow/tensor/numeric.gen_test.go           |  8 ++---
 go/arrow/tensor/numeric.gen_test.go.tmpl      |  8 ++---
 go/arrow/tensor/tensor.go                     |  4 +--
 go/arrow/tensor/tensor_test.go                |  8 ++---
 go/arrow/type_traits_boolean.go               |  2 +-
 go/arrow/type_traits_decimal128.go            |  4 +--
 go/arrow/type_traits_decimal256.go            |  4 +--
 go/arrow/type_traits_float16.go               |  4 +--
 go/arrow/type_traits_interval.go              |  4 +--
 go/arrow/type_traits_numeric.gen.go           |  2 +-
 go/arrow/type_traits_numeric.gen.go.tmpl      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go.tmpl |  2 +-
 go/arrow/type_traits_test.go                  |  8 ++---
 go/arrow/type_traits_timestamp.go             |  2 +-
 go/arrow/util/byte_size.go                    |  6 ++--
 go/arrow/util/byte_size_test.go               |  8 ++---
 go/go.mod                                     |  2 +-
 go/internal/bitutils/bit_block_counter.go     |  4 +--
 .../bitutils/bit_block_counter_test.go        |  6 ++--
 go/internal/bitutils/bit_run_reader.go        |  6 ++--
 go/internal/bitutils/bit_run_reader_test.go   |  6 ++--
 go/internal/bitutils/bit_set_run_reader.go    |  4 +--
 .../bitutils/bit_set_run_reader_test.go       |  6 ++--
 go/internal/bitutils/bitmap_generate.go       |  2 +-
 go/internal/bitutils/bitmap_generate_test.go  |  2 +-
 go/internal/hashing/xxh3_memo_table.gen.go    |  6 ++--
 .../hashing/xxh3_memo_table.gen.go.tmpl       |  4 +--
 go/internal/types/extension_types.go          |  6 ++--
 go/internal/types/extension_types_test.go     | 10 +++---
 go/internal/utils/transpose_ints_def.go       |  2 +-
 go/internal/utils/transpose_ints_test.go      |  2 +-
 go/parquet/cmd/parquet_reader/dumper.go       |  6 ++--
 go/parquet/cmd/parquet_reader/main.go         | 10 +++---
 go/parquet/cmd/parquet_schema/main.go         |  4 +--
 go/parquet/compress/brotli.go                 |  2 +-
 go/parquet/compress/compress.go               |  2 +-
 go/parquet/compress/compress_test.go          |  2 +-
 go/parquet/compress/zstd.go                   |  2 +-
 go/parquet/doc.go                             |  6 ++--
 go/parquet/encryption_properties.go           |  2 +-
 go/parquet/encryption_properties_test.go      |  4 +--
 go/parquet/encryption_read_config_test.go     |  8 ++---
 go/parquet/encryption_write_config_test.go    |  8 ++---
 go/parquet/file/column_reader.go              | 14 ++++----
 go/parquet/file/column_reader_test.go         | 12 +++----
 go/parquet/file/column_reader_types.gen.go    |  6 ++--
 .../file/column_reader_types.gen.go.tmpl      |  4 +--
 go/parquet/file/column_writer.go              | 16 +++++-----
 go/parquet/file/column_writer_test.go         | 26 +++++++--------
 go/parquet/file/column_writer_types.gen.go    | 12 +++----
 .../file/column_writer_types.gen.go.tmpl      |  8 ++---
 go/parquet/file/file_reader.go                |  8 ++---
 go/parquet/file/file_reader_mmap.go           |  2 +-
 go/parquet/file/file_reader_mmap_windows.go   |  2 +-
 go/parquet/file/file_reader_test.go           | 20 ++++++------
 go/parquet/file/file_writer.go                | 10 +++---
 go/parquet/file/file_writer_test.go           | 14 ++++----
 go/parquet/file/level_conversion.go           | 10 +++---
 go/parquet/file/level_conversion_test.go      |  6 ++--
 go/parquet/file/page_reader.go                | 14 ++++----
 go/parquet/file/page_writer.go                | 18 +++++------
 go/parquet/file/record_reader.go              | 16 +++++-----
 go/parquet/file/row_group_reader.go           |  8 ++---
 go/parquet/file/row_group_writer.go           |  8 ++---
 go/parquet/file/row_group_writer_test.go      |  8 ++---
 go/parquet/internal/bmi/bmi_test.go           |  2 +-
 .../internal/encoding/boolean_decoder.go      |  8 ++---
 .../internal/encoding/boolean_encoder.go      |  8 ++---
 .../internal/encoding/byte_array_decoder.go   | 12 +++----
 .../internal/encoding/byte_array_encoder.go   | 10 +++---
 go/parquet/internal/encoding/decoder.go       | 20 ++++++------
 .../internal/encoding/delta_bit_packing.go    | 10 +++---
 .../internal/encoding/delta_byte_array.go     |  6 ++--
 .../encoding/delta_byte_array_test.go         |  4 +--
 .../encoding/delta_length_byte_array.go       |  6 ++--
 go/parquet/internal/encoding/encoder.go       | 16 +++++-----
 .../encoding/encoding_benchmarks_test.go      | 16 +++++-----
 go/parquet/internal/encoding/encoding_test.go | 14 ++++----
 .../encoding/fixed_len_byte_array_decoder.go  |  4 +--
 .../encoding/fixed_len_byte_array_encoder.go  |  6 ++--
 go/parquet/internal/encoding/levels.go        | 10 +++---
 go/parquet/internal/encoding/levels_test.go   | 10 +++---
 go/parquet/internal/encoding/memo_table.go    | 10 +++---
 .../internal/encoding/memo_table_test.go      | 10 +++---
 .../internal/encoding/memo_table_types.gen.go |  4 +--
 .../encoding/memo_table_types.gen.go.tmpl     |  2 +-
 .../encoding/plain_encoder_types.gen.go       | 10 +++---
 .../encoding/plain_encoder_types.gen.go.tmpl  |  8 ++---
 .../internal/encoding/typed_encoder.gen.go    | 18 +++++------
 .../encoding/typed_encoder.gen.go.tmpl        | 14 ++++----
 go/parquet/internal/encoding/types.go         | 10 +++---
 go/parquet/internal/encryption/aes.go         |  2 +-
 go/parquet/internal/encryption/decryptor.go   |  4 +--
 go/parquet/internal/encryption/encryptor.go   |  4 +--
 go/parquet/internal/testutils/pagebuilder.go  | 14 ++++----
 .../internal/testutils/primitive_typed.go     | 10 +++---
 go/parquet/internal/testutils/random.go       | 14 ++++----
 go/parquet/internal/testutils/random_arrow.go |  6 ++--
 go/parquet/internal/testutils/utils.go        |  2 +-
 go/parquet/internal/thrift/helpers.go         |  2 +-
 .../internal/utils/bit_benchmark_test.go      |  6 ++--
 .../internal/utils/bit_packing_arm64.go       |  2 +-
 go/parquet/internal/utils/bit_reader.go       |  8 ++---
 go/parquet/internal/utils/bit_reader_test.go  | 10 +++---
 go/parquet/internal/utils/bit_writer.go       |  2 +-
 go/parquet/internal/utils/bitmap_writer.go    |  2 +-
 .../internal/utils/bitmap_writer_test.go      |  4 +--
 go/parquet/internal/utils/rle.go              |  8 ++---
 .../internal/utils/typed_rle_dict.gen.go      |  6 ++--
 .../internal/utils/typed_rle_dict.gen.go.tmpl |  6 ++--
 go/parquet/metadata/app_version.go            |  4 +--
 go/parquet/metadata/column_chunk.go           | 14 ++++----
 go/parquet/metadata/file.go                   | 12 +++----
 go/parquet/metadata/metadata_test.go          |  6 ++--
 go/parquet/metadata/row_group.go              |  8 ++---
 go/parquet/metadata/stat_compare_test.go      |  4 +--
 go/parquet/metadata/statistics.go             | 16 +++++-----
 go/parquet/metadata/statistics_test.go        | 10 +++---
 go/parquet/metadata/statistics_types.gen.go   | 16 +++++-----
 .../metadata/statistics_types.gen.go.tmpl     | 14 ++++----
 go/parquet/pqarrow/column_readers.go          | 20 ++++++------
 go/parquet/pqarrow/encode_arrow.go            | 20 ++++++------
 go/parquet/pqarrow/encode_arrow_test.go       | 32 +++++++++----------
 go/parquet/pqarrow/encode_dict_compute.go     | 16 +++++-----
 go/parquet/pqarrow/encode_dict_nocompute.go   |  4 +--
 go/parquet/pqarrow/encode_dictionary_test.go  | 16 +++++-----
 go/parquet/pqarrow/file_reader.go             | 14 ++++----
 go/parquet/pqarrow/file_reader_test.go        | 14 ++++----
 go/parquet/pqarrow/file_writer.go             | 12 +++----
 go/parquet/pqarrow/helpers.go                 |  2 +-
 go/parquet/pqarrow/path_builder.go            | 10 +++---
 go/parquet/pqarrow/path_builder_test.go       |  8 ++---
 go/parquet/pqarrow/properties.go              |  6 ++--
 go/parquet/pqarrow/reader_writer_test.go      | 12 +++----
 go/parquet/pqarrow/schema.go                  | 18 +++++------
 go/parquet/pqarrow/schema_test.go             | 18 +++++------
 go/parquet/reader_properties.go               |  4 +--
 go/parquet/reader_writer_properties_test.go   |  6 ++--
 go/parquet/schema/column.go                   |  4 +--
 go/parquet/schema/converted_types.go          |  2 +-
 go/parquet/schema/converted_types_test.go     |  2 +-
 go/parquet/schema/helpers.go                  |  2 +-
 go/parquet/schema/helpers_test.go             |  4 +--
 go/parquet/schema/logical_types.go            |  8 ++---
 go/parquet/schema/logical_types_test.go       |  6 ++--
 go/parquet/schema/node.go                     |  4 +--
 go/parquet/schema/reflection.go               |  4 +--
 go/parquet/schema/reflection_test.go          |  4 +--
 go/parquet/schema/schema.go                   |  4 +--
 go/parquet/schema/schema_element_test.go      |  4 +--
 go/parquet/schema/schema_flatten_test.go      |  4 +--
 go/parquet/schema/schema_test.go              |  6 ++--
 go/parquet/types.go                           |  4 +--
 go/parquet/writer_properties.go               |  6 ++--
 java/adapter/avro/pom.xml                     |  2 +-
 java/adapter/jdbc/pom.xml                     |  2 +-
 java/adapter/orc/pom.xml                      |  2 +-
 java/algorithm/pom.xml                        |  2 +-
 java/bom/pom.xml                              |  2 +-
 java/c/pom.xml                                |  2 +-
 java/compression/pom.xml                      |  2 +-
 java/dataset/pom.xml                          |  2 +-
 java/flight/flight-core/pom.xml               |  2 +-
 java/flight/flight-grpc/pom.xml               |  2 +-
 java/flight/flight-integration-tests/pom.xml  |  2 +-
 java/flight/flight-sql-jdbc-core/pom.xml      |  2 +-
 java/flight/flight-sql-jdbc-driver/pom.xml    |  2 +-
 java/flight/flight-sql/pom.xml                |  2 +-
 java/flight/pom.xml                           |  2 +-
 java/format/pom.xml                           |  2 +-
 java/gandiva/pom.xml                          |  2 +-
 java/memory/memory-core/pom.xml               |  2 +-
 java/memory/memory-netty/pom.xml              |  2 +-
 java/memory/memory-unsafe/pom.xml             |  2 +-
 java/memory/pom.xml                           |  2 +-
 java/performance/pom.xml                      |  2 +-
 java/pom.xml                                  |  2 +-
 java/tools/pom.xml                            |  2 +-
 java/vector/pom.xml                           |  2 +-
 js/package.json                               |  2 +-
 matlab/CMakeLists.txt                         |  2 +-
 python/CMakeLists.txt                         |  2 +-
 python/setup.py                               |  2 +-
 r/NEWS.md                                     |  2 ++
 ruby/red-arrow-cuda/lib/arrow-cuda/version.rb |  2 +-
 .../lib/arrow-dataset/version.rb              |  2 +-
 .../lib/arrow-flight-sql/version.rb           |  2 +-
 .../lib/arrow-flight/version.rb               |  2 +-
 ruby/red-arrow/lib/arrow/version.rb           |  2 +-
 ruby/red-gandiva/lib/gandiva/version.rb       |  2 +-
 ruby/red-parquet/lib/parquet/version.rb       |  2 +-
 503 files changed, 1732 insertions(+), 1730 deletions(-)

diff --git a/c_glib/meson.build b/c_glib/meson.build
index 7c495d2567d72..1aba855703828 100644
--- a/c_glib/meson.build
+++ b/c_glib/meson.build
@@ -24,7 +24,7 @@ project('arrow-glib', 'c', 'cpp',
           'cpp_std=c++17',
         ])
 
-version = '15.0.0-SNAPSHOT'
+version = '14.0.1-SNAPSHOT'
 if version.endswith('-SNAPSHOT')
   version_numbers = version.split('-')[0].split('.')
   version_tag = version.split('-')[1]
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index bcb298407bd8b..d57fcebb498dc 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -71,7 +71,7 @@ if(POLICY CMP0135)
   cmake_policy(SET CMP0135 NEW)
 endif()
 
-set(ARROW_VERSION "15.0.0-SNAPSHOT")
+set(ARROW_VERSION "14.0.1-SNAPSHOT")
 
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_BASE_VERSION "${ARROW_VERSION}")
 
diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json
index c0bf5dce50e32..d1508658b8165 100644
--- a/cpp/vcpkg.json
+++ b/cpp/vcpkg.json
@@ -1,6 +1,6 @@
 {
   "name": "arrow",
-  "version-string": "15.0.0-SNAPSHOT",
+  "version-string": "14.0.1-SNAPSHOT",
   "dependencies": [
     "abseil",
     {
diff --git a/csharp/Directory.Build.props b/csharp/Directory.Build.props
index ae6edda0e2f0e..1047272ffd448 100644
--- a/csharp/Directory.Build.props
+++ b/csharp/Directory.Build.props
@@ -29,7 +29,7 @@
     <Product>Apache Arrow library</Product>
     <Copyright>Copyright 2016-2019 The Apache Software Foundation</Copyright>
     <Company>The Apache Software Foundation</Company>
-    <Version>15.0.0-SNAPSHOT</Version>
+    <Version>14.0.1-SNAPSHOT</Version>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
index e29354def4c1c..e9fca5bc74216 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
@@ -29,7 +29,7 @@
 class ApacheArrowGlib < Formula
   desc "GLib bindings for Apache Arrow"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.1-SNAPSHOT/apache-arrow-14.0.1-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index 14d229b477dc8..ff7e54ba64bc0 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -29,7 +29,7 @@
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.1-SNAPSHOT/apache-arrow-14.0.1-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/go/README.md b/go/README.md
index c45bcd756f81c..660549cb1b366 100644
--- a/go/README.md
+++ b/go/README.md
@@ -20,7 +20,7 @@
 Apache Arrow for Go
 ===================
 
-[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v15.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v15)
+[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v14.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v14)
 
 [Apache Arrow][arrow] is a cross-language development platform for in-memory
 data. It specifies a standardized language-independent columnar memory format
diff --git a/go/arrow/_examples/helloworld/main.go b/go/arrow/_examples/helloworld/main.go
index 156a52b86da1c..02601be694400 100644
--- a/go/arrow/_examples/helloworld/main.go
+++ b/go/arrow/_examples/helloworld/main.go
@@ -19,10 +19,10 @@ package main
 import (
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/math"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/_tools/tmpl/main.go b/go/arrow/_tools/tmpl/main.go
index c591c3b96803c..87c4b6ed02c12 100644
--- a/go/arrow/_tools/tmpl/main.go
+++ b/go/arrow/_tools/tmpl/main.go
@@ -28,7 +28,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const Ext = ".tmpl"
diff --git a/go/arrow/array.go b/go/arrow/array.go
index e07fa478aae57..7622e7503e0b6 100644
--- a/go/arrow/array.go
+++ b/go/arrow/array.go
@@ -19,8 +19,8 @@ package arrow
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // ArrayData is the underlying memory and metadata of an Arrow array, corresponding
diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index bbe301ee661f3..1ee04c7aa2bcc 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/array/array_test.go b/go/arrow/array/array_test.go
index bbfbee83585da..6139548ddec7d 100644
--- a/go/arrow/array/array_test.go
+++ b/go/arrow/array/array_test.go
@@ -19,11 +19,11 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binary.go b/go/arrow/array/binary.go
index bf27139fddbaa..e9e6e66e7e813 100644
--- a/go/arrow/array/binary.go
+++ b/go/arrow/array/binary.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type BinaryLike interface {
diff --git a/go/arrow/array/binary_test.go b/go/arrow/array/binary_test.go
index 9c1770950a8b5..5febb55691d7d 100644
--- a/go/arrow/array/binary_test.go
+++ b/go/arrow/array/binary_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binarybuilder.go b/go/arrow/array/binarybuilder.go
index a51bc799e4965..3cb709b45b7a1 100644
--- a/go/arrow/array/binarybuilder.go
+++ b/go/arrow/array/binarybuilder.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A BinaryBuilder is used to build a Binary array using the Append methods.
diff --git a/go/arrow/array/binarybuilder_test.go b/go/arrow/array/binarybuilder_test.go
index 96be73da6516d..c63307433bcca 100644
--- a/go/arrow/array/binarybuilder_test.go
+++ b/go/arrow/array/binarybuilder_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/boolean.go b/go/arrow/array/boolean.go
index 43bac64a4c990..464cef48bdf32 100644
--- a/go/arrow/array/boolean.go
+++ b/go/arrow/array/boolean.go
@@ -21,10 +21,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of boolean values.
diff --git a/go/arrow/array/boolean_test.go b/go/arrow/array/boolean_test.go
index bcd17ee5967d6..c49ec08624cc6 100644
--- a/go/arrow/array/boolean_test.go
+++ b/go/arrow/array/boolean_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/booleanbuilder.go b/go/arrow/array/booleanbuilder.go
index cd0cffd5e43e2..10b7405aa5b2a 100644
--- a/go/arrow/array/booleanbuilder.go
+++ b/go/arrow/array/booleanbuilder.go
@@ -23,11 +23,11 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type BooleanBuilder struct {
diff --git a/go/arrow/array/booleanbuilder_test.go b/go/arrow/array/booleanbuilder_test.go
index f6f6c80dab37f..e270636a87b1c 100644
--- a/go/arrow/array/booleanbuilder_test.go
+++ b/go/arrow/array/booleanbuilder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/bufferbuilder.go b/go/arrow/array/bufferbuilder.go
index cb381e25b32a2..e023b0d907421 100644
--- a/go/arrow/array/bufferbuilder.go
+++ b/go/arrow/array/bufferbuilder.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type bufBuilder interface {
diff --git a/go/arrow/array/bufferbuilder_byte.go b/go/arrow/array/bufferbuilder_byte.go
index 9b2b559ba9f68..00a0d1c21b3ef 100644
--- a/go/arrow/array/bufferbuilder_byte.go
+++ b/go/arrow/array/bufferbuilder_byte.go
@@ -16,7 +16,7 @@
 
 package array
 
-import "github.com/apache/arrow/go/v15/arrow/memory"
+import "github.com/apache/arrow/go/v14/arrow/memory"
 
 type byteBufferBuilder struct {
 	bufferBuilder
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go b/go/arrow/array/bufferbuilder_numeric.gen.go
index a7961166c0edd..879bc9f571152 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go
@@ -19,9 +19,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type int64BufferBuilder struct {
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
index 845d7ef01c89a..e859b5bff02a1 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
@@ -17,9 +17,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/bufferbuilder_numeric_test.go b/go/arrow/array/bufferbuilder_numeric_test.go
index b51e9ae9207ea..ba0a60e5b703b 100644
--- a/go/arrow/array/bufferbuilder_numeric_test.go
+++ b/go/arrow/array/bufferbuilder_numeric_test.go
@@ -20,8 +20,8 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index bb15298e03ccf..2f15ac965e07c 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const (
diff --git a/go/arrow/array/builder_test.go b/go/arrow/array/builder_test.go
index 7bec86d86cc8b..3cacb54f725e7 100644
--- a/go/arrow/array/builder_test.go
+++ b/go/arrow/array/builder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index 778de41e32c67..e70716bee91a7 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 // RecordEqual reports whether the two provided records are equal.
diff --git a/go/arrow/array/compare_test.go b/go/arrow/array/compare_test.go
index 4fc9cf50e8643..51421aa04fe9a 100644
--- a/go/arrow/array/compare_test.go
+++ b/go/arrow/array/compare_test.go
@@ -22,11 +22,11 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 53c5be06895b9..9d815023c4b76 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -23,13 +23,13 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/encoded"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // Concatenate creates a new arrow.Array which is the concatenation of the
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index 1cc484ad1a923..c80844f05bacd 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/data.go b/go/arrow/array/data.go
index 8cce49182b879..49df06fb1174a 100644
--- a/go/arrow/array/data.go
+++ b/go/arrow/array/data.go
@@ -22,9 +22,9 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Data represents the memory and metadata of an Arrow array.
diff --git a/go/arrow/array/data_test.go b/go/arrow/array/data_test.go
index b7b0f396470d7..2773096995fb6 100644
--- a/go/arrow/array/data_test.go
+++ b/go/arrow/array/data_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal128.go b/go/arrow/array/decimal128.go
index 16a492db09c67..3317531687ca4 100644
--- a/go/arrow/array/decimal128.go
+++ b/go/arrow/array/decimal128.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of 128-bit decimal values.
diff --git a/go/arrow/array/decimal128_test.go b/go/arrow/array/decimal128_test.go
index 8c26d00cdc18e..8ef09b68c176a 100644
--- a/go/arrow/array/decimal128_test.go
+++ b/go/arrow/array/decimal128_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal256.go b/go/arrow/array/decimal256.go
index 8f72e414d1959..d63544f784a09 100644
--- a/go/arrow/array/decimal256.go
+++ b/go/arrow/array/decimal256.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Decimal256 is a type that represents an immutable sequence of 256-bit decimal values.
diff --git a/go/arrow/array/decimal256_test.go b/go/arrow/array/decimal256_test.go
index 6085d6b5a6a59..a02098e79103f 100644
--- a/go/arrow/array/decimal256_test.go
+++ b/go/arrow/array/decimal256_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal_test.go b/go/arrow/array/decimal_test.go
index 67900447be1cf..2203b2702c09a 100644
--- a/go/arrow/array/decimal_test.go
+++ b/go/arrow/array/decimal_test.go
@@ -21,12 +21,12 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index 856f91605ff53..d0a1c4dc97e1d 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -25,16 +25,16 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/hashing"
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // Dictionary represents the type for dictionary-encoded data with a data
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index 5a3e0e10c23f3..d0878fa3b0329 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -24,13 +24,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/diff.go b/go/arrow/array/diff.go
index 6bf6372531fd7..026a27b983f59 100644
--- a/go/arrow/array/diff.go
+++ b/go/arrow/array/diff.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Edit represents one entry in the edit script to compare two arrays.
diff --git a/go/arrow/array/diff_test.go b/go/arrow/array/diff_test.go
index 17539c38d282f..0eff8dc4f0577 100644
--- a/go/arrow/array/diff_test.go
+++ b/go/arrow/array/diff_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 type diffTestCase struct {
diff --git a/go/arrow/array/encoded.go b/go/arrow/array/encoded.go
index fa5fa7addf34c..bf4a942cf1c35 100644
--- a/go/arrow/array/encoded.go
+++ b/go/arrow/array/encoded.go
@@ -23,12 +23,12 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/encoded"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // RunEndEncoded represents an array containing two children:
diff --git a/go/arrow/array/encoded_test.go b/go/arrow/array/encoded_test.go
index 5bfac7a1a96e6..57c01cf22d2d6 100644
--- a/go/arrow/array/encoded_test.go
+++ b/go/arrow/array/encoded_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/array/extension.go b/go/arrow/array/extension.go
index 021b8e7bc451b..03e8c1734b9d6 100644
--- a/go/arrow/array/extension.go
+++ b/go/arrow/array/extension.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // ExtensionArray is the interface that needs to be implemented to handle
diff --git a/go/arrow/array/extension_test.go b/go/arrow/array/extension_test.go
index a8e2b0dfd59bb..5b473fed428ef 100644
--- a/go/arrow/array/extension_test.go
+++ b/go/arrow/array/extension_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/fixed_size_list.go b/go/arrow/array/fixed_size_list.go
index 5923d68590b15..62c3213861a7d 100644
--- a/go/arrow/array/fixed_size_list.go
+++ b/go/arrow/array/fixed_size_list.go
@@ -22,11 +22,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // FixedSizeList represents an immutable sequence of N array values.
diff --git a/go/arrow/array/fixed_size_list_test.go b/go/arrow/array/fixed_size_list_test.go
index 5c01199ddf987..83dff923fe120 100644
--- a/go/arrow/array/fixed_size_list_test.go
+++ b/go/arrow/array/fixed_size_list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/fixedsize_binary.go b/go/arrow/array/fixedsize_binary.go
index 6cdaeace939fd..5466156d5a256 100644
--- a/go/arrow/array/fixedsize_binary.go
+++ b/go/arrow/array/fixedsize_binary.go
@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of fixed-length binary strings.
diff --git a/go/arrow/array/fixedsize_binary_test.go b/go/arrow/array/fixedsize_binary_test.go
index 785725537cbdd..b65c7051a9b3e 100644
--- a/go/arrow/array/fixedsize_binary_test.go
+++ b/go/arrow/array/fixedsize_binary_test.go
@@ -21,9 +21,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFixedSizeBinary(t *testing.T) {
diff --git a/go/arrow/array/fixedsize_binarybuilder.go b/go/arrow/array/fixedsize_binarybuilder.go
index 230a65fd2d352..ba4b474a89fd0 100644
--- a/go/arrow/array/fixedsize_binarybuilder.go
+++ b/go/arrow/array/fixedsize_binarybuilder.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A FixedSizeBinaryBuilder is used to build a FixedSizeBinary array using the Append methods.
diff --git a/go/arrow/array/fixedsize_binarybuilder_test.go b/go/arrow/array/fixedsize_binarybuilder_test.go
index 8e4a0ac1e46a7..e3962ad3b9372 100644
--- a/go/arrow/array/fixedsize_binarybuilder_test.go
+++ b/go/arrow/array/fixedsize_binarybuilder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/float16.go b/go/arrow/array/float16.go
index 4260f8e3774b4..de499e26706cc 100644
--- a/go/arrow/array/float16.go
+++ b/go/arrow/array/float16.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of Float16 values.
diff --git a/go/arrow/array/float16_builder.go b/go/arrow/array/float16_builder.go
index 033b9fa2d8028..f96ab6037e002 100644
--- a/go/arrow/array/float16_builder.go
+++ b/go/arrow/array/float16_builder.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Float16Builder struct {
diff --git a/go/arrow/array/float16_builder_test.go b/go/arrow/array/float16_builder_test.go
index f8c5890179869..6ee028d978fb0 100644
--- a/go/arrow/array/float16_builder_test.go
+++ b/go/arrow/array/float16_builder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/interval.go b/go/arrow/array/interval.go
index 2a5529f1c30f7..ff059c92c8583 100644
--- a/go/arrow/array/interval.go
+++ b/go/arrow/array/interval.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 func NewIntervalData(data arrow.ArrayData) arrow.Array {
diff --git a/go/arrow/array/interval_test.go b/go/arrow/array/interval_test.go
index f83fc52dfa34e..50a96e4779f03 100644
--- a/go/arrow/array/interval_test.go
+++ b/go/arrow/array/interval_test.go
@@ -20,9 +20,9 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/json_reader.go b/go/arrow/array/json_reader.go
index 2f05d4b70dd76..e09717c4199b7 100644
--- a/go/arrow/array/json_reader.go
+++ b/go/arrow/array/json_reader.go
@@ -22,10 +22,10 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Option func(config)
diff --git a/go/arrow/array/json_reader_test.go b/go/arrow/array/json_reader_test.go
index 7f12bf211dd04..3a095a0d33189 100644
--- a/go/arrow/array/json_reader_test.go
+++ b/go/arrow/array/json_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/list.go b/go/arrow/array/list.go
index f10e2072c43a2..d8d8b8c76165a 100644
--- a/go/arrow/array/list.go
+++ b/go/arrow/array/list.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type ListLike interface {
diff --git a/go/arrow/array/list_test.go b/go/arrow/array/list_test.go
index 11404b2d8bb95..bf3555b3f6603 100644
--- a/go/arrow/array/list_test.go
+++ b/go/arrow/array/list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index fe07a68785067..9945a90ce495e 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Map represents an immutable sequence of Key/Value structs. It is a
diff --git a/go/arrow/array/map_test.go b/go/arrow/array/map_test.go
index a7ecc032682bc..3fe78549ec803 100644
--- a/go/arrow/array/map_test.go
+++ b/go/arrow/array/map_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/null.go b/go/arrow/array/null.go
index 2735a88a92cb3..150a1030eb49d 100644
--- a/go/arrow/array/null.go
+++ b/go/arrow/array/null.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Null represents an immutable, degenerate array with no physical storage.
diff --git a/go/arrow/array/null_test.go b/go/arrow/array/null_test.go
index 5d230ec5cec71..e1bf1e0345b84 100644
--- a/go/arrow/array/null_test.go
+++ b/go/arrow/array/null_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numeric.gen.go b/go/arrow/array/numeric.gen.go
index 59c9a979768d5..a3e1101516aa6 100644
--- a/go/arrow/array/numeric.gen.go
+++ b/go/arrow/array/numeric.gen.go
@@ -23,8 +23,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // A type which represents an immutable sequence of int64 values.
diff --git a/go/arrow/array/numeric.gen.go.tmpl b/go/arrow/array/numeric.gen.go.tmpl
index 027456009daad..34d17fbfc8854 100644
--- a/go/arrow/array/numeric.gen.go.tmpl
+++ b/go/arrow/array/numeric.gen.go.tmpl
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numeric_test.go b/go/arrow/array/numeric_test.go
index 91dd724c8da50..34f59c238cbef 100644
--- a/go/arrow/array/numeric_test.go
+++ b/go/arrow/array/numeric_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen.go b/go/arrow/array/numericbuilder.gen.go
index 52b189d6ed453..7f01180f55957 100644
--- a/go/arrow/array/numericbuilder.gen.go
+++ b/go/arrow/array/numericbuilder.gen.go
@@ -27,11 +27,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Int64Builder struct {
diff --git a/go/arrow/array/numericbuilder.gen.go.tmpl b/go/arrow/array/numericbuilder.gen.go.tmpl
index 82ac35465d424..cf663c031f616 100644
--- a/go/arrow/array/numericbuilder.gen.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen.go.tmpl
@@ -17,11 +17,11 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numericbuilder.gen_test.go b/go/arrow/array/numericbuilder.gen_test.go
index e1f72773403d8..b5986775cd995 100644
--- a/go/arrow/array/numericbuilder.gen_test.go
+++ b/go/arrow/array/numericbuilder.gen_test.go
@@ -21,9 +21,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen_test.go.tmpl b/go/arrow/array/numericbuilder.gen_test.go.tmpl
index eddd884e2eddf..bc8c993374671 100644
--- a/go/arrow/array/numericbuilder.gen_test.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen_test.go.tmpl
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/record.go b/go/arrow/array/record.go
index d080f726e472d..0b0fe4c3847fc 100644
--- a/go/arrow/array/record.go
+++ b/go/arrow/array/record.go
@@ -22,10 +22,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // RecordReader reads a stream of records.
diff --git a/go/arrow/array/record_test.go b/go/arrow/array/record_test.go
index 7d438d1f1f81e..da50a30b646f1 100644
--- a/go/arrow/array/record_test.go
+++ b/go/arrow/array/record_test.go
@@ -21,9 +21,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 9ab7c938ef5d8..86e27c970cbe9 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -23,9 +23,9 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // String represents an immutable sequence of variable-length UTF-8 strings.
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index d743a3ec7f37f..fbc106b098332 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/struct.go b/go/arrow/array/struct.go
index 94052953852c2..248a25bf6044d 100644
--- a/go/arrow/array/struct.go
+++ b/go/arrow/array/struct.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Struct represents an ordered sequence of relative types.
diff --git a/go/arrow/array/struct_test.go b/go/arrow/array/struct_test.go
index 1b0dc5a3e4b19..86a5b311fcc21 100644
--- a/go/arrow/array/struct_test.go
+++ b/go/arrow/array/struct_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/table.go b/go/arrow/array/table.go
index a987dd057f82c..6456992e34973 100644
--- a/go/arrow/array/table.go
+++ b/go/arrow/array/table.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // NewColumnSlice returns a new zero-copy slice of the column with the indicated
diff --git a/go/arrow/array/table_test.go b/go/arrow/array/table_test.go
index 9535ae6b089bb..8e22d53963ba4 100644
--- a/go/arrow/array/table_test.go
+++ b/go/arrow/array/table_test.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestChunked(t *testing.T) {
diff --git a/go/arrow/array/timestamp.go b/go/arrow/array/timestamp.go
index 6ffb43e067af0..2928b1fc77ff6 100644
--- a/go/arrow/array/timestamp.go
+++ b/go/arrow/array/timestamp.go
@@ -24,11 +24,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Timestamp represents an immutable sequence of arrow.Timestamp values.
diff --git a/go/arrow/array/timestamp_test.go b/go/arrow/array/timestamp_test.go
index acbad8b586dd4..1e55364e8da0d 100644
--- a/go/arrow/array/timestamp_test.go
+++ b/go/arrow/array/timestamp_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/union.go b/go/arrow/array/union.go
index c0a5050560634..869355ac7108a 100644
--- a/go/arrow/array/union.go
+++ b/go/arrow/array/union.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 // Union is a convenience interface to encompass both Sparse and Dense
diff --git a/go/arrow/array/union_test.go b/go/arrow/array/union_test.go
index e876f5def26d3..2f2bf3b84e9f7 100644
--- a/go/arrow/array/union_test.go
+++ b/go/arrow/array/union_test.go
@@ -21,9 +21,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/array/util.go b/go/arrow/array/util.go
index a1b3cc7d4e5f7..54d15a8095c80 100644
--- a/go/arrow/array/util.go
+++ b/go/arrow/array/util.go
@@ -22,11 +22,11 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/hashing"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 func min(a, b int) int {
diff --git a/go/arrow/array/util_test.go b/go/arrow/array/util_test.go
index 84a6debdf3946..d3d2b37365513 100644
--- a/go/arrow/array/util_test.go
+++ b/go/arrow/array/util_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/arrio/arrio.go b/go/arrow/arrio/arrio.go
index 51cf6dc46d44a..466a93a68400a 100644
--- a/go/arrow/arrio/arrio.go
+++ b/go/arrow/arrio/arrio.go
@@ -22,7 +22,7 @@ import (
 	"errors"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Reader is the interface that wraps the Read method.
diff --git a/go/arrow/arrio/arrio_test.go b/go/arrow/arrio/arrio_test.go
index c80d5d2569d67..7e9aac8fbe520 100644
--- a/go/arrow/arrio/arrio_test.go
+++ b/go/arrow/arrio/arrio_test.go
@@ -22,11 +22,11 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type copyKind int
diff --git a/go/arrow/bitutil/bitmaps.go b/go/arrow/bitutil/bitmaps.go
index d7516771def7f..2e9c0601c3c45 100644
--- a/go/arrow/bitutil/bitmaps.go
+++ b/go/arrow/bitutil/bitmaps.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // BitmapReader is a simple bitmap reader for a byte slice.
diff --git a/go/arrow/bitutil/bitmaps_test.go b/go/arrow/bitutil/bitmaps_test.go
index c926bff39e09a..60022a179d1da 100644
--- a/go/arrow/bitutil/bitmaps_test.go
+++ b/go/arrow/bitutil/bitmaps_test.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/bitutil/bitutil.go b/go/arrow/bitutil/bitutil.go
index dc510a8b374c4..a4a1519b8f940 100644
--- a/go/arrow/bitutil/bitutil.go
+++ b/go/arrow/bitutil/bitutil.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/bitutil/bitutil_test.go b/go/arrow/bitutil/bitutil_test.go
index 189c8541f4925..9e29e9d04d1db 100644
--- a/go/arrow/bitutil/bitutil_test.go
+++ b/go/arrow/bitutil/bitutil_test.go
@@ -21,8 +21,8 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index f9693851d7483..1d454c57f722e 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -46,10 +46,10 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index 91f1b352e0327..187c2deb9755f 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -45,11 +45,11 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
 )
 
 func encodeCMetadata(keys, values []string) []byte {
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index 607cfe53217a6..f09fa3ff2f6fa 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -35,12 +35,12 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index 1251b20201e41..2df52dcb3cd40 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -69,10 +69,10 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal"
-	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 )
 
 const (
diff --git a/go/arrow/cdata/exports.go b/go/arrow/cdata/exports.go
index 7353df62d113a..9d2576818e31c 100644
--- a/go/arrow/cdata/exports.go
+++ b/go/arrow/cdata/exports.go
@@ -20,8 +20,8 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 // #include <stdlib.h>
diff --git a/go/arrow/cdata/import_allocator.go b/go/arrow/cdata/import_allocator.go
index cf1c6a961ff37..eff8c7517caef 100644
--- a/go/arrow/cdata/import_allocator.go
+++ b/go/arrow/cdata/import_allocator.go
@@ -20,7 +20,7 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // #include "arrow/c/helpers.h"
diff --git a/go/arrow/cdata/interface.go b/go/arrow/cdata/interface.go
index 8ce06280a0bf5..bf5c5270bae2f 100644
--- a/go/arrow/cdata/interface.go
+++ b/go/arrow/cdata/interface.go
@@ -22,10 +22,10 @@ package cdata
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/test/test_cimport.go b/go/arrow/cdata/test/test_cimport.go
index 147c3691f0c71..a7c5dc034496a 100644
--- a/go/arrow/cdata/test/test_cimport.go
+++ b/go/arrow/cdata/test/test_cimport.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/cdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/cdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/compute/arithmetic.go b/go/arrow/compute/arithmetic.go
index 1ee1959b2ddc8..2fb95f06ff84a 100644
--- a/go/arrow/compute/arithmetic.go
+++ b/go/arrow/compute/arithmetic.go
@@ -22,12 +22,12 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 type (
diff --git a/go/arrow/compute/arithmetic_test.go b/go/arrow/compute/arithmetic_test.go
index 821ffd9e068d4..a99b2074eb69f 100644
--- a/go/arrow/compute/arithmetic_test.go
+++ b/go/arrow/compute/arithmetic_test.go
@@ -26,16 +26,16 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/klauspost/cpuid/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/compute/cast.go b/go/arrow/compute/cast.go
index 133a983038ce1..8b720a2bad5d8 100644
--- a/go/arrow/compute/cast.go
+++ b/go/arrow/compute/cast.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/cast_test.go b/go/arrow/compute/cast_test.go
index 10957a45167aa..cc301cc35e6e5 100644
--- a/go/arrow/compute/cast_test.go
+++ b/go/arrow/compute/cast_test.go
@@ -26,16 +26,16 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/datum.go b/go/arrow/compute/datum.go
index 98bd1f1a0a326..1d3c1b4dab700 100644
--- a/go/arrow/compute/datum.go
+++ b/go/arrow/compute/datum.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 //go:generate go run golang.org/x/tools/cmd/stringer -type=DatumKind -linecomment
diff --git a/go/arrow/compute/example_test.go b/go/arrow/compute/example_test.go
index e2b07b7e191ae..f0db9f377868e 100644
--- a/go/arrow/compute/example_test.go
+++ b/go/arrow/compute/example_test.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // This example demonstrates how to register a custom scalar function.
diff --git a/go/arrow/compute/exec.go b/go/arrow/compute/exec.go
index eba47e64bd509..84e3310cc2df8 100644
--- a/go/arrow/compute/exec.go
+++ b/go/arrow/compute/exec.go
@@ -22,9 +22,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 func haveChunkedArray(values []Datum) bool {
diff --git a/go/arrow/compute/exec/kernel.go b/go/arrow/compute/exec/kernel.go
index 766857f63e565..327426da68eb9 100644
--- a/go/arrow/compute/exec/kernel.go
+++ b/go/arrow/compute/exec/kernel.go
@@ -24,10 +24,10 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/slices"
 )
 
diff --git a/go/arrow/compute/exec/kernel_test.go b/go/arrow/compute/exec/kernel_test.go
index 4df6b42ff9408..16a29ea2deda6 100644
--- a/go/arrow/compute/exec/kernel_test.go
+++ b/go/arrow/compute/exec/kernel_test.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/span.go b/go/arrow/compute/exec/span.go
index 0b5f6208227f5..b6d240fa4a0be 100644
--- a/go/arrow/compute/exec/span.go
+++ b/go/arrow/compute/exec/span.go
@@ -23,11 +23,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // BufferSpan is a lightweight Buffer holder for ArraySpans that does not
diff --git a/go/arrow/compute/exec/span_test.go b/go/arrow/compute/exec/span_test.go
index 474c005b44642..c642be1c30c23 100644
--- a/go/arrow/compute/exec/span_test.go
+++ b/go/arrow/compute/exec/span_test.go
@@ -24,14 +24,14 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/utils.go b/go/arrow/compute/exec/utils.go
index 17bc30ef2adb0..6d83b75da1313 100644
--- a/go/arrow/compute/exec/utils.go
+++ b/go/arrow/compute/exec/utils.go
@@ -25,13 +25,13 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/exec/utils_test.go b/go/arrow/compute/exec/utils_test.go
index b26e4ff41e79f..e9bb07177f2ac 100644
--- a/go/arrow/compute/exec/utils_test.go
+++ b/go/arrow/compute/exec/utils_test.go
@@ -21,10 +21,10 @@ package exec_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec_internals_test.go b/go/arrow/compute/exec_internals_test.go
index bae32268862ff..eb9273d23389f 100644
--- a/go/arrow/compute/exec_internals_test.go
+++ b/go/arrow/compute/exec_internals_test.go
@@ -24,13 +24,13 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/exec_test.go b/go/arrow/compute/exec_test.go
index a37f67c03e8ce..30bfbc0246a1c 100644
--- a/go/arrow/compute/exec_test.go
+++ b/go/arrow/compute/exec_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index 1cba0b1e19f69..6da7ed1293065 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -25,14 +25,14 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // ExecCtx holds simple contextual information for execution
diff --git a/go/arrow/compute/expression.go b/go/arrow/compute/expression.go
index fbb6c502d98ab..9f20c9704dca7 100644
--- a/go/arrow/compute/expression.go
+++ b/go/arrow/compute/expression.go
@@ -28,14 +28,14 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 var hashSeed = maphash.MakeSeed()
diff --git a/go/arrow/compute/expression_test.go b/go/arrow/compute/expression_test.go
index b3b44ae1faa61..71b1b64c4b0c1 100644
--- a/go/arrow/compute/expression_test.go
+++ b/go/arrow/compute/expression_test.go
@@ -22,11 +22,11 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exprs/builders.go b/go/arrow/compute/exprs/builders.go
index 0b694525d1b47..39606c27e714a 100644
--- a/go/arrow/compute/exprs/builders.go
+++ b/go/arrow/compute/exprs/builders.go
@@ -25,8 +25,8 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/builders_test.go b/go/arrow/compute/exprs/builders_test.go
index 69501622359d5..e42d7569a8f03 100644
--- a/go/arrow/compute/exprs/builders_test.go
+++ b/go/arrow/compute/exprs/builders_test.go
@@ -21,8 +21,8 @@ package exprs_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/exec.go b/go/arrow/compute/exprs/exec.go
index 800ffe62f2559..d63752696082b 100644
--- a/go/arrow/compute/exprs/exec.go
+++ b/go/arrow/compute/exprs/exec.go
@@ -23,15 +23,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/exec_internal_test.go b/go/arrow/compute/exprs/exec_internal_test.go
index 680bf36f11958..9475a9a8cbca9 100644
--- a/go/arrow/compute/exprs/exec_internal_test.go
+++ b/go/arrow/compute/exprs/exec_internal_test.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/exprs/exec_test.go b/go/arrow/compute/exprs/exec_test.go
index 65cafc8e62ddb..e30d2afdb73f8 100644
--- a/go/arrow/compute/exprs/exec_test.go
+++ b/go/arrow/compute/exprs/exec_test.go
@@ -23,12 +23,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/extension_types.go b/go/arrow/compute/exprs/extension_types.go
index db7992b8f089f..ce375492d67f1 100644
--- a/go/arrow/compute/exprs/extension_types.go
+++ b/go/arrow/compute/exprs/extension_types.go
@@ -24,8 +24,8 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type simpleExtensionTypeFactory[P comparable] struct {
diff --git a/go/arrow/compute/exprs/field_refs.go b/go/arrow/compute/exprs/field_refs.go
index e95e3c8c9abb9..fd4313818195e 100644
--- a/go/arrow/compute/exprs/field_refs.go
+++ b/go/arrow/compute/exprs/field_refs.go
@@ -21,11 +21,11 @@ package exprs
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 )
 
diff --git a/go/arrow/compute/exprs/types.go b/go/arrow/compute/exprs/types.go
index 6a5b81d11b3eb..9f807e1e1ecbc 100644
--- a/go/arrow/compute/exprs/types.go
+++ b/go/arrow/compute/exprs/types.go
@@ -24,8 +24,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/fieldref.go b/go/arrow/compute/fieldref.go
index 565ae3bfadbd0..ee6f39948ebf1 100644
--- a/go/arrow/compute/fieldref.go
+++ b/go/arrow/compute/fieldref.go
@@ -27,8 +27,8 @@ import (
 	"unicode"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 var (
diff --git a/go/arrow/compute/fieldref_test.go b/go/arrow/compute/fieldref_test.go
index c4fa72182835f..c38ad8ac1fe30 100644
--- a/go/arrow/compute/fieldref_test.go
+++ b/go/arrow/compute/fieldref_test.go
@@ -19,10 +19,10 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/functions.go b/go/arrow/compute/functions.go
index b85062721d9b8..a1905f91850f0 100644
--- a/go/arrow/compute/functions.go
+++ b/go/arrow/compute/functions.go
@@ -23,8 +23,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 type Function interface {
diff --git a/go/arrow/compute/functions_test.go b/go/arrow/compute/functions_test.go
index 1e6bbd598e0c9..b37da285badd0 100644
--- a/go/arrow/compute/functions_test.go
+++ b/go/arrow/compute/functions_test.go
@@ -21,8 +21,8 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic.go b/go/arrow/compute/internal/kernels/base_arithmetic.go
index c7950877264df..67e80af74f511 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic.go
@@ -24,11 +24,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
index 942b8e4ff5600..0e78e6c9183ff 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/sys/cpu"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
index 6814e834b4bf3..29cce7830e0f4 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
index 633ec5f4f18e5..e9b03551f81b1 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
index 8e46ca030c8b7..4f160a1411091 100644
--- a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
+++ b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
@@ -19,7 +19,7 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/boolean_cast.go b/go/arrow/compute/internal/kernels/boolean_cast.go
index 923c5b3f54512..18d04c845c41d 100644
--- a/go/arrow/compute/internal/kernels/boolean_cast.go
+++ b/go/arrow/compute/internal/kernels/boolean_cast.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 func isNonZero[T exec.FixedWidthTypes](ctx *exec.KernelCtx, in []T, out []byte) error {
diff --git a/go/arrow/compute/internal/kernels/cast.go b/go/arrow/compute/internal/kernels/cast.go
index bc4ee3abd128c..5a71206b2476c 100644
--- a/go/arrow/compute/internal/kernels/cast.go
+++ b/go/arrow/compute/internal/kernels/cast.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 )
 
 type CastOptions struct {
diff --git a/go/arrow/compute/internal/kernels/cast_numeric.go b/go/arrow/compute/internal/kernels/cast_numeric.go
index 2e893c7205f6a..4e5c5c1d9ea77 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 var castNumericUnsafe func(itype, otype arrow.Type, in, out []byte, len int) = castNumericGo
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
index eafa4b41001ae..6b28441ec083e 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
index 75ad79fd0e7f3..d53a4486f6983 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
index d04f393c4c099..1cbea033dec27 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_temporal.go b/go/arrow/compute/internal/kernels/cast_temporal.go
index 542a8a4590b28..82fce1e33c959 100644
--- a/go/arrow/compute/internal/kernels/cast_temporal.go
+++ b/go/arrow/compute/internal/kernels/cast_temporal.go
@@ -24,10 +24,10 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const millisecondsInDay = 86400000
diff --git a/go/arrow/compute/internal/kernels/helpers.go b/go/arrow/compute/internal/kernels/helpers.go
index 686c4b3e0c29a..ed25071c9d87f 100644
--- a/go/arrow/compute/internal/kernels/helpers.go
+++ b/go/arrow/compute/internal/kernels/helpers.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/numeric_cast.go b/go/arrow/compute/internal/kernels/numeric_cast.go
index c055552bf7ff5..8e5350754723d 100644
--- a/go/arrow/compute/internal/kernels/numeric_cast.go
+++ b/go/arrow/compute/internal/kernels/numeric_cast.go
@@ -23,13 +23,13 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/rounding.go b/go/arrow/compute/internal/kernels/rounding.go
index 8a1bec1180ac8..2f58a9faea8a2 100644
--- a/go/arrow/compute/internal/kernels/rounding.go
+++ b/go/arrow/compute/internal/kernels/rounding.go
@@ -22,11 +22,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_arithmetic.go b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
index cf17e9fd9548b..9cb32ae64a4a9 100644
--- a/go/arrow/compute/internal/kernels/scalar_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 // scalar kernel that ignores (assumed all-null inputs) and returns null
diff --git a/go/arrow/compute/internal/kernels/scalar_boolean.go b/go/arrow/compute/internal/kernels/scalar_boolean.go
index 0707c92e6a198..812f4ad1bd363 100644
--- a/go/arrow/compute/internal/kernels/scalar_boolean.go
+++ b/go/arrow/compute/internal/kernels/scalar_boolean.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 type computeWordFN func(leftTrue, leftFalse, rightTrue, rightFalse uint64) (outValid, outData uint64)
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
index 8e5ce1ab7c1ad..585d1bff01ab6 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
index cf9fc1eeedbb8..868179057ccf4 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
index c0aef5a04e9b8..56abad42b1ffc 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
@@ -18,7 +18,7 @@
 
 package kernels
 
-import "github.com/apache/arrow/go/v15/arrow/compute/exec"
+import "github.com/apache/arrow/go/v14/arrow/compute/exec"
 
 func genCompareKernel[T exec.NumericTypes](op CompareOperator) *CompareData {
 	return genGoCompareKernel(getCmpOp[T](op))
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
index f8b36a1e4be76..7cf96a4171d6c 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparisons.go b/go/arrow/compute/internal/kernels/scalar_comparisons.go
index 9a7640a8d8a39..8a957eafd85da 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparisons.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparisons.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 type binaryKernel func(left, right, out []byte, offset int)
diff --git a/go/arrow/compute/internal/kernels/string_casts.go b/go/arrow/compute/internal/kernels/string_casts.go
index 76da901e33f8d..3070514665d7d 100644
--- a/go/arrow/compute/internal/kernels/string_casts.go
+++ b/go/arrow/compute/internal/kernels/string_casts.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 func validateUtf8Fsb(input *exec.ArraySpan) error {
diff --git a/go/arrow/compute/internal/kernels/types.go b/go/arrow/compute/internal/kernels/types.go
index 481eab36059f8..2788fb7054c53 100644
--- a/go/arrow/compute/internal/kernels/types.go
+++ b/go/arrow/compute/internal/kernels/types.go
@@ -21,10 +21,10 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 )
 
 var (
diff --git a/go/arrow/compute/internal/kernels/vector_hash.go b/go/arrow/compute/internal/kernels/vector_hash.go
index 9401e31cc5b09..e0ede826e876e 100644
--- a/go/arrow/compute/internal/kernels/vector_hash.go
+++ b/go/arrow/compute/internal/kernels/vector_hash.go
@@ -21,13 +21,13 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/hashing"
 )
 
 type HashState interface {
diff --git a/go/arrow/compute/internal/kernels/vector_run_end_encode.go b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
index a147bf7d50170..e073ff1ff5308 100644
--- a/go/arrow/compute/internal/kernels/vector_run_end_encode.go
+++ b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
@@ -24,14 +24,14 @@ import (
 	"sort"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type RunEndEncodeState struct {
diff --git a/go/arrow/compute/internal/kernels/vector_selection.go b/go/arrow/compute/internal/kernels/vector_selection.go
index 714e452325bfd..c7a902bd008d0 100644
--- a/go/arrow/compute/internal/kernels/vector_selection.go
+++ b/go/arrow/compute/internal/kernels/vector_selection.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 type NullSelectionBehavior int8
diff --git a/go/arrow/compute/registry.go b/go/arrow/compute/registry.go
index 379e0ccbe86a9..4f1c435fb680a 100644
--- a/go/arrow/compute/registry.go
+++ b/go/arrow/compute/registry.go
@@ -21,7 +21,7 @@ package compute
 import (
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/registry_test.go b/go/arrow/compute/registry_test.go
index 4e4f44f1d39b6..428f7cf1d8fda 100644
--- a/go/arrow/compute/registry_test.go
+++ b/go/arrow/compute/registry_test.go
@@ -23,9 +23,9 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/scalar_bool.go b/go/arrow/compute/scalar_bool.go
index 1f28a6e2bfcb2..49c745688284e 100644
--- a/go/arrow/compute/scalar_bool.go
+++ b/go/arrow/compute/scalar_bool.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/scalar_bool_test.go b/go/arrow/compute/scalar_bool_test.go
index bd4f3c5c0df2b..6eadc973d6965 100644
--- a/go/arrow/compute/scalar_bool_test.go
+++ b/go/arrow/compute/scalar_bool_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/compute/scalar_compare.go b/go/arrow/compute/scalar_compare.go
index 24a4191a10999..476f37711e289 100644
--- a/go/arrow/compute/scalar_compare.go
+++ b/go/arrow/compute/scalar_compare.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 type compareFunction struct {
diff --git a/go/arrow/compute/scalar_compare_test.go b/go/arrow/compute/scalar_compare_test.go
index d209f72c800b0..13fdd24fdd6b3 100644
--- a/go/arrow/compute/scalar_compare_test.go
+++ b/go/arrow/compute/scalar_compare_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/selection.go b/go/arrow/compute/selection.go
index 90bc5280ef2a7..ed6d80418d3f6 100644
--- a/go/arrow/compute/selection.go
+++ b/go/arrow/compute/selection.go
@@ -22,10 +22,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/arrow/compute/utils.go b/go/arrow/compute/utils.go
index 9de6523fd0b5f..cc4d6edc48ec8 100644
--- a/go/arrow/compute/utils.go
+++ b/go/arrow/compute/utils.go
@@ -24,12 +24,12 @@ import (
 	"math"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/compute/vector_hash.go b/go/arrow/compute/vector_hash.go
index 144c123380fe2..5f9aec55c55bc 100644
--- a/go/arrow/compute/vector_hash.go
+++ b/go/arrow/compute/vector_hash.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_hash_test.go b/go/arrow/compute/vector_hash_test.go
index 9410720de7941..50c96ddc04f6c 100644
--- a/go/arrow/compute/vector_hash_test.go
+++ b/go/arrow/compute/vector_hash_test.go
@@ -23,13 +23,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/vector_run_end_test.go b/go/arrow/compute/vector_run_end_test.go
index 51c0f834ceb6a..8d894d96b8f0a 100644
--- a/go/arrow/compute/vector_run_end_test.go
+++ b/go/arrow/compute/vector_run_end_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/vector_run_ends.go b/go/arrow/compute/vector_run_ends.go
index 3e47c67de3c35..48f3dcba8c481 100644
--- a/go/arrow/compute/vector_run_ends.go
+++ b/go/arrow/compute/vector_run_ends.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_selection_test.go b/go/arrow/compute/vector_selection_test.go
index f44840ba72034..10788d60e10d2 100644
--- a/go/arrow/compute/vector_selection_test.go
+++ b/go/arrow/compute/vector_selection_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/compute/exec"
-	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/csv/common.go b/go/arrow/csv/common.go
index 2a1f7300a986f..91f42897a24a6 100644
--- a/go/arrow/csv/common.go
+++ b/go/arrow/csv/common.go
@@ -22,8 +22,8 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/csv/reader.go b/go/arrow/csv/reader.go
index e58b426d837fb..80af520a12b7f 100644
--- a/go/arrow/csv/reader.go
+++ b/go/arrow/csv/reader.go
@@ -29,13 +29,13 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Reader wraps encoding/csv.Reader and creates array.Records from a schema.
diff --git a/go/arrow/csv/reader_test.go b/go/arrow/csv/reader_test.go
index dfcb6625bd7cc..f481cd2e961d3 100644
--- a/go/arrow/csv/reader_test.go
+++ b/go/arrow/csv/reader_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/csv"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/csv"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/csv/transformer.go b/go/arrow/csv/transformer.go
index 0f0181520b847..7c8eafcee1a59 100644
--- a/go/arrow/csv/transformer.go
+++ b/go/arrow/csv/transformer.go
@@ -25,8 +25,8 @@ import (
 	"math/big"
 	"strconv"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 func (w *Writer) transformColToStringArr(typ arrow.DataType, col arrow.Array) []string {
diff --git a/go/arrow/csv/writer.go b/go/arrow/csv/writer.go
index a672008b58a07..e558364ecf16d 100644
--- a/go/arrow/csv/writer.go
+++ b/go/arrow/csv/writer.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Writer wraps encoding/csv.Writer and writes arrow.Record based on a schema.
diff --git a/go/arrow/csv/writer_test.go b/go/arrow/csv/writer_test.go
index 1918e2e492dff..f945023790426 100644
--- a/go/arrow/csv/writer_test.go
+++ b/go/arrow/csv/writer_test.go
@@ -25,14 +25,14 @@ import (
 	"log"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/csv"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/csv"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 )
 
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index 24113b55899dc..f0fb24ec873c5 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -21,7 +21,7 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Type is a logical type. They can be expressed as
diff --git a/go/arrow/datatype_binary_test.go b/go/arrow/datatype_binary_test.go
index 25ba6e8db4ba4..c47df3da1db9c 100644
--- a/go/arrow/datatype_binary_test.go
+++ b/go/arrow/datatype_binary_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestBinaryType(t *testing.T) {
diff --git a/go/arrow/datatype_extension_test.go b/go/arrow/datatype_extension_test.go
index 9811800400506..c542b22b769e6 100644
--- a/go/arrow/datatype_extension_test.go
+++ b/go/arrow/datatype_extension_test.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index bcbc8ef6aec87..fc0b3aea56e70 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/internal/json"
 
 	"golang.org/x/xerrors"
 )
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index 918572d40b8f4..1d3a07de09c1d 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/datatype_nested.go b/go/arrow/datatype_nested.go
index e381cd7047e45..4ae4880334620 100644
--- a/go/arrow/datatype_nested.go
+++ b/go/arrow/datatype_nested.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 type (
diff --git a/go/arrow/datatype_null_test.go b/go/arrow/datatype_null_test.go
index 57cddfadb8ef8..286a72fb7fea3 100644
--- a/go/arrow/datatype_null_test.go
+++ b/go/arrow/datatype_null_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestNullType(t *testing.T) {
diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index 7bde39d327417..ff9c088b9d638 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -23,7 +23,7 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index 879f2849028f8..102eede6d3b28 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -22,7 +22,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/decimal256/decimal256.go b/go/arrow/decimal256/decimal256.go
index 5f2ad5f32165c..cf2157fdd48ed 100644
--- a/go/arrow/decimal256/decimal256.go
+++ b/go/arrow/decimal256/decimal256.go
@@ -23,8 +23,8 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal256/decimal256_test.go b/go/arrow/decimal256/decimal256_test.go
index 3be6a1944406f..9c734e23aa0d6 100644
--- a/go/arrow/decimal256/decimal256_test.go
+++ b/go/arrow/decimal256/decimal256_test.go
@@ -23,7 +23,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/doc.go b/go/arrow/doc.go
index c8da330e4f8a1..87aea1d41035c 100644
--- a/go/arrow/doc.go
+++ b/go/arrow/doc.go
@@ -36,7 +36,7 @@ To build with tinygo include the noasm build tag.
 */
 package arrow
 
-const PkgVersion = "15.0.0-SNAPSHOT"
+const PkgVersion = "14.0.1-SNAPSHOT"
 
 //go:generate go run _tools/tmpl/main.go -i -data=numeric.tmpldata type_traits_numeric.gen.go.tmpl type_traits_numeric.gen_test.go.tmpl array/numeric.gen.go.tmpl array/numericbuilder.gen.go.tmpl array/bufferbuilder_numeric.gen.go.tmpl
 //go:generate go run _tools/tmpl/main.go -i -data=datatype_numeric.gen.go.tmpldata datatype_numeric.gen.go.tmpl tensor/numeric.gen.go.tmpl tensor/numeric.gen_test.go.tmpl
diff --git a/go/arrow/encoded/ree_utils.go b/go/arrow/encoded/ree_utils.go
index 2ff4e7cadd38b..1f71e7b5210cf 100644
--- a/go/arrow/encoded/ree_utils.go
+++ b/go/arrow/encoded/ree_utils.go
@@ -20,7 +20,7 @@ import (
 	"math"
 	"sort"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // FindPhysicalIndex performs a binary search on the run-ends to return
diff --git a/go/arrow/encoded/ree_utils_test.go b/go/arrow/encoded/ree_utils_test.go
index 9470331002b80..785a3b105a47d 100644
--- a/go/arrow/encoded/ree_utils_test.go
+++ b/go/arrow/encoded/ree_utils_test.go
@@ -21,10 +21,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/encoded"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/endian/endian.go b/go/arrow/endian/endian.go
index d4865025b1fb0..3ecda7b3600b7 100644
--- a/go/arrow/endian/endian.go
+++ b/go/arrow/endian/endian.go
@@ -17,8 +17,8 @@
 package endian
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
 )
 
 type Endianness flatbuf.Endianness
diff --git a/go/arrow/example_test.go b/go/arrow/example_test.go
index b28cc9093739f..10b3633f65536 100644
--- a/go/arrow/example_test.go
+++ b/go/arrow/example_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 // This example demonstrates how to build an array of int64 values using a builder and Append.
diff --git a/go/arrow/flight/basic_auth_flight_test.go b/go/arrow/flight/basic_auth_flight_test.go
index 4097bf02edeff..0f63a400353d2 100755
--- a/go/arrow/flight/basic_auth_flight_test.go
+++ b/go/arrow/flight/basic_auth_flight_test.go
@@ -22,7 +22,7 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index 8c400eb66b64d..c9a1417accab4 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/cookie_middleware_test.go b/go/arrow/flight/cookie_middleware_test.go
index bdfe4fb32c1a5..2bde37fc0bb85 100644
--- a/go/arrow/flight/cookie_middleware_test.go
+++ b/go/arrow/flight/cookie_middleware_test.go
@@ -28,7 +28,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/example_flight_server_test.go b/go/arrow/flight/example_flight_server_test.go
index d3a71b3b67ade..09f01361d13a0 100755
--- a/go/arrow/flight/example_flight_server_test.go
+++ b/go/arrow/flight/example_flight_server_test.go
@@ -23,7 +23,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flight_middleware_test.go b/go/arrow/flight/flight_middleware_test.go
index e6faa1b7df1d2..f2b240d1f2e45 100755
--- a/go/arrow/flight/flight_middleware_test.go
+++ b/go/arrow/flight/flight_middleware_test.go
@@ -23,8 +23,8 @@ import (
 	sync "sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flight_test.go b/go/arrow/flight/flight_test.go
index cd37658603d5b..7cd724b76b8ce 100755
--- a/go/arrow/flight/flight_test.go
+++ b/go/arrow/flight/flight_test.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flightsql/client.go b/go/arrow/flight/flightsql/client.go
index c0c7e2cf20a28..13d046661e96d 100644
--- a/go/arrow/flight/flightsql/client.go
+++ b/go/arrow/flight/flightsql/client.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index 3efe4ba4049b8..bb4ae29477997 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/column_metadata.go b/go/arrow/flight/flightsql/column_metadata.go
index 8e0a69b99d055..d9785892888b2 100644
--- a/go/arrow/flight/flightsql/column_metadata.go
+++ b/go/arrow/flight/flightsql/column_metadata.go
@@ -19,7 +19,7 @@ package flightsql
 import (
 	"strconv"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/driver/README.md b/go/arrow/flight/flightsql/driver/README.md
index f1447a7d24256..b8850527c19c1 100644
--- a/go/arrow/flight/flightsql/driver/README.md
+++ b/go/arrow/flight/flightsql/driver/README.md
@@ -36,7 +36,7 @@ connection pooling, transactions combined with ease of use (see (#usage)).
 ## Prerequisites
 
 * Go 1.17+
-* Installation via `go get -u github.com/apache/arrow/go/v15/arrow/flight/flightsql`
+* Installation via `go get -u github.com/apache/arrow/go/v14/arrow/flight/flightsql`
 * Backend speaking FlightSQL
 
 ---------------------------------------
@@ -55,7 +55,7 @@ import (
     "database/sql"
     "time"
 
-    _ "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+    _ "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 // Open the connection to an SQLite backend
@@ -141,7 +141,7 @@ import (
     "log"
     "time"
 
-    "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+    "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/driver/config_test.go b/go/arrow/flight/flightsql/driver/config_test.go
index 6b24b535585d9..abcececeaf214 100644
--- a/go/arrow/flight/flightsql/driver/config_test.go
+++ b/go/arrow/flight/flightsql/driver/config_test.go
@@ -22,7 +22,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
 )
 
 func TestConfigTLSRegistry(t *testing.T) {
diff --git a/go/arrow/flight/flightsql/driver/driver.go b/go/arrow/flight/flightsql/driver/driver.go
index e325489236c6d..b4cb0d2dbda2e 100644
--- a/go/arrow/flight/flightsql/driver/driver.go
+++ b/go/arrow/flight/flightsql/driver/driver.go
@@ -25,11 +25,11 @@ import (
 	"sort"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go
index a388bf155ec99..4449b390974a7 100644
--- a/go/arrow/flight/flightsql/driver/driver_test.go
+++ b/go/arrow/flight/flightsql/driver/driver_test.go
@@ -33,13 +33,13 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 const defaultTableName = "drivertest"
diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go
index 022e9da4925f9..99352e7251c53 100644
--- a/go/arrow/flight/flightsql/driver/utils.go
+++ b/go/arrow/flight/flightsql/driver/utils.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 // *** GRPC helpers ***
diff --git a/go/arrow/flight/flightsql/driver/utils_test.go b/go/arrow/flight/flightsql/driver/utils_test.go
index 8f5ea031adf28..355c888f56cc4 100644
--- a/go/arrow/flight/flightsql/driver/utils_test.go
+++ b/go/arrow/flight/flightsql/driver/utils_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
index 1a50422f826f3..6508833876fa5 100644
--- a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
+++ b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
@@ -27,9 +27,9 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/example/sql_batch_reader.go b/go/arrow/flight/flightsql/example/sql_batch_reader.go
index 36a0d7b424544..7101b8f830a6f 100644
--- a/go/arrow/flight/flightsql/example/sql_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sql_batch_reader.go
@@ -26,11 +26,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/wrapperspb"
diff --git a/go/arrow/flight/flightsql/example/sqlite_info.go b/go/arrow/flight/flightsql/example/sqlite_info.go
index c993af97f7449..bf29265853c65 100644
--- a/go/arrow/flight/flightsql/example/sqlite_info.go
+++ b/go/arrow/flight/flightsql/example/sqlite_info.go
@@ -20,8 +20,8 @@
 package example
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
 )
 
 func SqlInfoResultMap() flightsql.SqlInfoResultMap {
diff --git a/go/arrow/flight/flightsql/example/sqlite_server.go b/go/arrow/flight/flightsql/example/sqlite_server.go
index f06dd0210655f..63b41ee5e0a4a 100644
--- a/go/arrow/flight/flightsql/example/sqlite_server.go
+++ b/go/arrow/flight/flightsql/example/sqlite_server.go
@@ -45,13 +45,13 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
index e07a98fffdbf7..507abf622d890 100644
--- a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	sqlite3 "modernc.org/sqlite/lib"
 )
 
diff --git a/go/arrow/flight/flightsql/example/type_info.go b/go/arrow/flight/flightsql/example/type_info.go
index 0180fc1f23af5..6d6ceb339e4b0 100644
--- a/go/arrow/flight/flightsql/example/type_info.go
+++ b/go/arrow/flight/flightsql/example/type_info.go
@@ -22,10 +22,10 @@ package example
 import (
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func GetTypeInfoResult(mem memory.Allocator) arrow.Record {
diff --git a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
index b65688306473b..98d61f8110d45 100644
--- a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
+++ b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
@@ -18,7 +18,7 @@
 // by FlightSQL servers and clients.
 package schema_ref
 
-import "github.com/apache/arrow/go/v15/arrow"
+import "github.com/apache/arrow/go/v14/arrow"
 
 var (
 	Catalogs = arrow.NewSchema(
diff --git a/go/arrow/flight/flightsql/server.go b/go/arrow/flight/flightsql/server.go
index a086610433eae..e9cbc177da2c4 100644
--- a/go/arrow/flight/flightsql/server.go
+++ b/go/arrow/flight/flightsql/server.go
@@ -20,14 +20,14 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
-	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
diff --git a/go/arrow/flight/flightsql/server_test.go b/go/arrow/flight/flightsql/server_test.go
index e444da4aaf4a2..33e9b8236a261 100644
--- a/go/arrow/flight/flightsql/server_test.go
+++ b/go/arrow/flight/flightsql/server_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/sql_info.go b/go/arrow/flight/flightsql/sql_info.go
index 5f78e1facd581..a12c4fbdaeda9 100644
--- a/go/arrow/flight/flightsql/sql_info.go
+++ b/go/arrow/flight/flightsql/sql_info.go
@@ -17,8 +17,8 @@
 package flightsql
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/sqlite_server_test.go b/go/arrow/flight/flightsql/sqlite_server_test.go
index e6fa798c55cf1..03ae3d7a8313a 100644
--- a/go/arrow/flight/flightsql/sqlite_server_test.go
+++ b/go/arrow/flight/flightsql/sqlite_server_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/types.go b/go/arrow/flight/flightsql/types.go
index 2b7419482e3e3..98086a61fe067 100644
--- a/go/arrow/flight/flightsql/types.go
+++ b/go/arrow/flight/flightsql/types.go
@@ -17,7 +17,7 @@
 package flightsql
 
 import (
-	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
diff --git a/go/arrow/flight/record_batch_reader.go b/go/arrow/flight/record_batch_reader.go
index f137c75172368..b726180627e6f 100644
--- a/go/arrow/flight/record_batch_reader.go
+++ b/go/arrow/flight/record_batch_reader.go
@@ -21,12 +21,12 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // DataStreamReader is an interface for receiving flight data messages on a stream
diff --git a/go/arrow/flight/record_batch_writer.go b/go/arrow/flight/record_batch_writer.go
index 426dca6c3e907..3ae17bcf48042 100644
--- a/go/arrow/flight/record_batch_writer.go
+++ b/go/arrow/flight/record_batch_writer.go
@@ -19,9 +19,9 @@ package flight
 import (
 	"bytes"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // DataStreamWriter is an interface that represents an Arrow Flight stream
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index 8676b15644e47..cf471f9b3a2b6 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -22,7 +22,7 @@ import (
 	"os"
 	"os/signal"
 
-	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 )
 
diff --git a/go/arrow/flight/server_example_test.go b/go/arrow/flight/server_example_test.go
index 4e2e4f4c6b587..b82e2cb7f7164 100644
--- a/go/arrow/flight/server_example_test.go
+++ b/go/arrow/flight/server_example_test.go
@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/health"
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 6631e4245c19d..0851bff0fe0da 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -21,14 +21,14 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 var (
diff --git a/go/arrow/internal/arrdata/ioutil.go b/go/arrow/internal/arrdata/ioutil.go
index a6becc2151ef3..1a2ce0e5b5eca 100644
--- a/go/arrow/internal/arrdata/ioutil.go
+++ b/go/arrow/internal/arrdata/ioutil.go
@@ -23,11 +23,11 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // CheckArrowFile checks whether a given ARROW file contains the expected list of records.
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index 87bdc1f44d875..ad87b73fc4ddb 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Schema struct {
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index 7beadee370edb..ee85d431805ab 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -22,9 +22,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/arrjson/option.go b/go/arrow/internal/arrjson/option.go
index 47d40f857c54e..7ae2058d471a7 100644
--- a/go/arrow/internal/arrjson/option.go
+++ b/go/arrow/internal/arrjson/option.go
@@ -17,8 +17,8 @@
 package arrjson
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type config struct {
diff --git a/go/arrow/internal/arrjson/reader.go b/go/arrow/internal/arrjson/reader.go
index 226fa1b1919f9..c8056ef1dc744 100644
--- a/go/arrow/internal/arrjson/reader.go
+++ b/go/arrow/internal/arrjson/reader.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 type Reader struct {
diff --git a/go/arrow/internal/arrjson/writer.go b/go/arrow/internal/arrjson/writer.go
index af7032d581f4d..ddac32609b604 100644
--- a/go/arrow/internal/arrjson/writer.go
+++ b/go/arrow/internal/arrjson/writer.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/internal/json"
 )
 
 const (
diff --git a/go/arrow/internal/cdata_integration/entrypoints.go b/go/arrow/internal/cdata_integration/entrypoints.go
index a40db8316f848..629b8a762a689 100644
--- a/go/arrow/internal/cdata_integration/entrypoints.go
+++ b/go/arrow/internal/cdata_integration/entrypoints.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/cdata"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/cdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/internal/dictutils/dict.go b/go/arrow/internal/dictutils/dict.go
index d31369f7d25b3..e09a2f4a0ecd1 100644
--- a/go/arrow/internal/dictutils/dict.go
+++ b/go/arrow/internal/dictutils/dict.go
@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"hash/maphash"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type Kind int8
diff --git a/go/arrow/internal/dictutils/dict_test.go b/go/arrow/internal/dictutils/dict_test.go
index 9d2f7ae4782c7..6cafacbd1df00 100644
--- a/go/arrow/internal/dictutils/dict_test.go
+++ b/go/arrow/internal/dictutils/dict_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestDictMemo(t *testing.T) {
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
index 1afb53c5294f4..8da39858fabab 100755
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
index d382ff9e88670..9cebb2c695ece 100644
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
@@ -23,7 +23,7 @@ import (
 	"os"
 	"syscall"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
 )
 
 var (
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 3ec905e2d659c..4f47d7fd506ee 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -31,15 +31,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"golang.org/x/xerrors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index b42273ff93fac..41f2578209a7f 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -19,11 +19,11 @@ package gen
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/arrow/internal/testing/tools/bits_test.go b/go/arrow/internal/testing/tools/bits_test.go
index 6ad8ac5b12b68..7d0fccb5f999e 100644
--- a/go/arrow/internal/testing/tools/bits_test.go
+++ b/go/arrow/internal/testing/tools/bits_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/testing/tools/data_types.go b/go/arrow/internal/testing/tools/data_types.go
index 161cfa431491d..654780bc3e853 100644
--- a/go/arrow/internal/testing/tools/data_types.go
+++ b/go/arrow/internal/testing/tools/data_types.go
@@ -21,8 +21,8 @@ package tools
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/internal/utils.go b/go/arrow/internal/utils.go
index 619eebd97dc78..265f030dfd19a 100644
--- a/go/arrow/internal/utils.go
+++ b/go/arrow/internal/utils.go
@@ -17,8 +17,8 @@
 package internal
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
 )
 
 const CurMetadataVersion = flatbuf.MetadataVersionV5
diff --git a/go/arrow/ipc/cmd/arrow-cat/main.go b/go/arrow/ipc/cmd/arrow-cat/main.go
index 0251b08c09bff..af53c9b4e5f44 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main.go
@@ -63,8 +63,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-cat/main_test.go b/go/arrow/ipc/cmd/arrow-cat/main_test.go
index b6528b85b416d..22e4f6ffe0778 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestCatStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
index 6187b94465211..7e86263d6d5b8 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
index 2f66a8b48c59d..30db24715386f 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFileToStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
index 7db2fa1d1c5db..91ba6a4ad9b61 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
@@ -22,12 +22,12 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/internal/types"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
index eb702f0aa2bc5..140f9f62478c0 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
@@ -20,8 +20,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestIntegration(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main.go b/go/arrow/ipc/cmd/arrow-ls/main.go
index 4230ae2449985..f739c9ae7da8e 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main.go
@@ -61,8 +61,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main_test.go b/go/arrow/ipc/cmd/arrow-ls/main_test.go
index bda1c2dc4d3dc..2c038dae97b52 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestLsStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
index 7ed3f6a281d9f..758231ea21cf5 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
index 73196551054ac..4354b46e8964b 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestStreamToFile(t *testing.T) {
diff --git a/go/arrow/ipc/compression.go b/go/arrow/ipc/compression.go
index 8856b732f9c5d..73fb916500804 100644
--- a/go/arrow/ipc/compression.go
+++ b/go/arrow/ipc/compression.go
@@ -19,9 +19,9 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/klauspost/compress/zstd"
 	"github.com/pierrec/lz4/v4"
 )
diff --git a/go/arrow/ipc/endian_swap.go b/go/arrow/ipc/endian_swap.go
index d2e0948434abc..d98fec1089f04 100644
--- a/go/arrow/ipc/endian_swap.go
+++ b/go/arrow/ipc/endian_swap.go
@@ -20,9 +20,9 @@ import (
 	"errors"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // swap the endianness of the array's buffers as needed in-place to save
diff --git a/go/arrow/ipc/endian_swap_test.go b/go/arrow/ipc/endian_swap_test.go
index 1c724103f4441..4f02bb53d61a4 100644
--- a/go/arrow/ipc/endian_swap_test.go
+++ b/go/arrow/ipc/endian_swap_test.go
@@ -20,11 +20,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index 330355d3a60c3..10cb2cae764e6 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // FileReader is an Arrow file reader.
diff --git a/go/arrow/ipc/file_test.go b/go/arrow/ipc/file_test.go
index 5f4dac1f899bb..1b22719dc8097 100644
--- a/go/arrow/ipc/file_test.go
+++ b/go/arrow/ipc/file_test.go
@@ -21,9 +21,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestFile(t *testing.T) {
diff --git a/go/arrow/ipc/file_writer.go b/go/arrow/ipc/file_writer.go
index 55e4d7c2dc22c..12384225b70a1 100644
--- a/go/arrow/ipc/file_writer.go
+++ b/go/arrow/ipc/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // PayloadWriter is an interface for injecting a different payloadwriter
diff --git a/go/arrow/ipc/ipc.go b/go/arrow/ipc/ipc.go
index 8cf56e8331fcb..6c04b6f5ad2d6 100644
--- a/go/arrow/ipc/ipc.go
+++ b/go/arrow/ipc/ipc.go
@@ -19,10 +19,10 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 const (
diff --git a/go/arrow/ipc/ipc_test.go b/go/arrow/ipc/ipc_test.go
index d02d8734b56d4..551d325dc1212 100644
--- a/go/arrow/ipc/ipc_test.go
+++ b/go/arrow/ipc/ipc_test.go
@@ -29,10 +29,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestArrow12072(t *testing.T) {
diff --git a/go/arrow/ipc/message.go b/go/arrow/ipc/message.go
index 709aa5aa2dba4..c5d0ec68d19c4 100644
--- a/go/arrow/ipc/message.go
+++ b/go/arrow/ipc/message.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // MetadataVersion represents the Arrow metadata version.
diff --git a/go/arrow/ipc/message_test.go b/go/arrow/ipc/message_test.go
index 912d112229f0c..cc41fdd3fe13d 100644
--- a/go/arrow/ipc/message_test.go
+++ b/go/arrow/ipc/message_test.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestMessageReaderBodyInAllocator(t *testing.T) {
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index bd437834c3d06..9bab47d6fa0cd 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"sort"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
diff --git a/go/arrow/ipc/metadata_test.go b/go/arrow/ipc/metadata_test.go
index a35068813ba56..3038abdf5f791 100644
--- a/go/arrow/ipc/metadata_test.go
+++ b/go/arrow/ipc/metadata_test.go
@@ -21,12 +21,12 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	flatbuffers "github.com/google/flatbuffers/go"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/arrow/ipc/reader.go b/go/arrow/ipc/reader.go
index 826062fafdb46..1f684c1f6c034 100644
--- a/go/arrow/ipc/reader.go
+++ b/go/arrow/ipc/reader.go
@@ -23,13 +23,13 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 // Reader reads records from an io.Reader.
diff --git a/go/arrow/ipc/reader_test.go b/go/arrow/ipc/reader_test.go
index f00f3bb3da476..229374e94ec74 100644
--- a/go/arrow/ipc/reader_test.go
+++ b/go/arrow/ipc/reader_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/stream_test.go b/go/arrow/ipc/stream_test.go
index 201bfb82a5677..d8bbd8f04b14d 100644
--- a/go/arrow/ipc/stream_test.go
+++ b/go/arrow/ipc/stream_test.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func TestStream(t *testing.T) {
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index 58c56d2d16ccf..a97f47ef4aa43 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -26,14 +26,14 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type swriter struct {
diff --git a/go/arrow/ipc/writer_test.go b/go/arrow/ipc/writer_test.go
index ea7592554c888..da461c3d52272 100644
--- a/go/arrow/ipc/writer_test.go
+++ b/go/arrow/ipc/writer_test.go
@@ -24,11 +24,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/math/float64.go b/go/arrow/math/float64.go
index 8d72ecf1b2668..81de594df6ce6 100644
--- a/go/arrow/math/float64.go
+++ b/go/arrow/math/float64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Float64Funcs struct {
diff --git a/go/arrow/math/float64_avx2_amd64.go b/go/arrow/math/float64_avx2_amd64.go
index e78d4affe9f6f..8a131a2bc8fc5 100644
--- a/go/arrow/math/float64_avx2_amd64.go
+++ b/go/arrow/math/float64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_neon_arm64.go b/go/arrow/math/float64_neon_arm64.go
index a5013960d9ec7..ad9b6435b26fc 100755
--- a/go/arrow/math/float64_neon_arm64.go
+++ b/go/arrow/math/float64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_sse4_amd64.go b/go/arrow/math/float64_sse4_amd64.go
index cdd88f91c2c2b..a2be5de43f5bb 100644
--- a/go/arrow/math/float64_sse4_amd64.go
+++ b/go/arrow/math/float64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_test.go b/go/arrow/math/float64_test.go
index 3a7c247c5df8c..b10214f6d892f 100644
--- a/go/arrow/math/float64_test.go
+++ b/go/arrow/math/float64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/math"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/int64.go b/go/arrow/math/int64.go
index b8236dfbb6552..2adff970c2233 100644
--- a/go/arrow/math/int64.go
+++ b/go/arrow/math/int64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Int64Funcs struct {
diff --git a/go/arrow/math/int64_avx2_amd64.go b/go/arrow/math/int64_avx2_amd64.go
index 5c16e790c1e55..ac0b2e1ff662a 100644
--- a/go/arrow/math/int64_avx2_amd64.go
+++ b/go/arrow/math/int64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_neon_arm64.go b/go/arrow/math/int64_neon_arm64.go
index 00ec48b6e4735..4ab5fb771a526 100755
--- a/go/arrow/math/int64_neon_arm64.go
+++ b/go/arrow/math/int64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_sse4_amd64.go b/go/arrow/math/int64_sse4_amd64.go
index a894bad2ef6a3..85304210eb448 100644
--- a/go/arrow/math/int64_sse4_amd64.go
+++ b/go/arrow/math/int64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_test.go b/go/arrow/math/int64_test.go
index 3781fd3570785..06b42ffe9351b 100644
--- a/go/arrow/math/int64_test.go
+++ b/go/arrow/math/int64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/math"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/type.go.tmpl b/go/arrow/math/type.go.tmpl
index f1a4dfa1362f8..7ae142c46f12b 100644
--- a/go/arrow/math/type.go.tmpl
+++ b/go/arrow/math/type.go.tmpl
@@ -17,7 +17,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$def := .D}}
diff --git a/go/arrow/math/type_simd_amd64.go.tmpl b/go/arrow/math/type_simd_amd64.go.tmpl
index 77dee758b05cd..72d40ea386a8f 100644
--- a/go/arrow/math/type_simd_amd64.go.tmpl
+++ b/go/arrow/math/type_simd_amd64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_simd_arm64.go.tmpl b/go/arrow/math/type_simd_arm64.go.tmpl
index 77dee758b05cd..72d40ea386a8f 100755
--- a/go/arrow/math/type_simd_arm64.go.tmpl
+++ b/go/arrow/math/type_simd_arm64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_test.go.tmpl b/go/arrow/math/type_test.go.tmpl
index 969377e454e52..160fc34e4d4d4 100644
--- a/go/arrow/math/type_test.go.tmpl
+++ b/go/arrow/math/type_test.go.tmpl
@@ -19,9 +19,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/math"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/uint64.go b/go/arrow/math/uint64.go
index b9a70360224ea..64ac63a3d1853 100644
--- a/go/arrow/math/uint64.go
+++ b/go/arrow/math/uint64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 type Uint64Funcs struct {
diff --git a/go/arrow/math/uint64_avx2_amd64.go b/go/arrow/math/uint64_avx2_amd64.go
index c1f48efefd8eb..2a35bebc980b3 100644
--- a/go/arrow/math/uint64_avx2_amd64.go
+++ b/go/arrow/math/uint64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_neon_arm64.go b/go/arrow/math/uint64_neon_arm64.go
index 37ca4ecad04e7..f6588694bb1fd 100755
--- a/go/arrow/math/uint64_neon_arm64.go
+++ b/go/arrow/math/uint64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_sse4_amd64.go b/go/arrow/math/uint64_sse4_amd64.go
index 7163c1de171de..8c6621464f118 100644
--- a/go/arrow/math/uint64_sse4_amd64.go
+++ b/go/arrow/math/uint64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_test.go b/go/arrow/math/uint64_test.go
index e8ba42b59aa10..aac768e599cf8 100644
--- a/go/arrow/math/uint64_test.go
+++ b/go/arrow/math/uint64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/math"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/math"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/buffer.go b/go/arrow/memory/buffer.go
index ffdb41e3dbe9e..5a2b4297031f0 100644
--- a/go/arrow/memory/buffer.go
+++ b/go/arrow/memory/buffer.go
@@ -19,7 +19,7 @@ package memory
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Buffer is a wrapper type for a buffer of bytes.
diff --git a/go/arrow/memory/buffer_test.go b/go/arrow/memory/buffer_test.go
index 92bb071d0abde..25a0b39848519 100644
--- a/go/arrow/memory/buffer_test.go
+++ b/go/arrow/memory/buffer_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/cgo_allocator.go b/go/arrow/memory/cgo_allocator.go
index af25d1899a6fe..85ee445216f6a 100644
--- a/go/arrow/memory/cgo_allocator.go
+++ b/go/arrow/memory/cgo_allocator.go
@@ -22,7 +22,7 @@ package memory
 import (
 	"runtime"
 
-	cga "github.com/apache/arrow/go/v15/arrow/memory/internal/cgoalloc"
+	cga "github.com/apache/arrow/go/v14/arrow/memory/internal/cgoalloc"
 )
 
 // CgoArrowAllocator is an allocator which exposes the C++ memory pool class
diff --git a/go/arrow/memory/default_mallocator.go b/go/arrow/memory/default_mallocator.go
index 4a9ef942fd08d..12ad0846677b1 100644
--- a/go/arrow/memory/default_mallocator.go
+++ b/go/arrow/memory/default_mallocator.go
@@ -19,7 +19,7 @@
 package memory
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 )
 
 // DefaultAllocator is a default implementation of Allocator and can be used anywhere
diff --git a/go/arrow/memory/default_mallocator_test.go b/go/arrow/memory/default_mallocator_test.go
index 5a38e8b4e843c..b209ced68a067 100644
--- a/go/arrow/memory/default_mallocator_test.go
+++ b/go/arrow/memory/default_mallocator_test.go
@@ -21,8 +21,8 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/mallocator/mallocator_test.go b/go/arrow/memory/mallocator/mallocator_test.go
index 91b74383ed494..5b09355033f70 100644
--- a/go/arrow/memory/mallocator/mallocator_test.go
+++ b/go/arrow/memory/mallocator/mallocator_test.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/memory_test.go b/go/arrow/memory/memory_test.go
index adaa8359369be..dff2e0bfd0712 100644
--- a/go/arrow/memory/memory_test.go
+++ b/go/arrow/memory/memory_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/record.go b/go/arrow/record.go
index 885af38034938..d98c7732ef798 100644
--- a/go/arrow/record.go
+++ b/go/arrow/record.go
@@ -16,7 +16,7 @@
 
 package arrow
 
-import "github.com/apache/arrow/go/v15/internal/json"
+import "github.com/apache/arrow/go/v14/internal/json"
 
 // Record is a collection of equal-length arrays matching a particular Schema.
 // Also known as a RecordBatch in the spec and in some implementations.
diff --git a/go/arrow/scalar/append.go b/go/arrow/scalar/append.go
index fe8dd32e9eae5..9bcfe3e22dc63 100644
--- a/go/arrow/scalar/append.go
+++ b/go/arrow/scalar/append.go
@@ -21,11 +21,11 @@ package scalar
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/scalar/append_test.go b/go/arrow/scalar/append_test.go
index e509bca1fb7b0..497a6a2d02933 100644
--- a/go/arrow/scalar/append_test.go
+++ b/go/arrow/scalar/append_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/binary.go b/go/arrow/scalar/binary.go
index b6abe9cba7b1c..3c041210fde9c 100644
--- a/go/arrow/scalar/binary.go
+++ b/go/arrow/scalar/binary.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type BinaryScalar interface {
diff --git a/go/arrow/scalar/compare.go b/go/arrow/scalar/compare.go
index b4a3fe08d26fe..be7fa4d01cc19 100644
--- a/go/arrow/scalar/compare.go
+++ b/go/arrow/scalar/compare.go
@@ -16,7 +16,7 @@
 
 package scalar
 
-import "github.com/apache/arrow/go/v15/arrow"
+import "github.com/apache/arrow/go/v14/arrow"
 
 // Equals returns true if two scalars are equal, which means they have the same
 // datatype, validity and value.
diff --git a/go/arrow/scalar/nested.go b/go/arrow/scalar/nested.go
index 8250beb5ed90d..87e84210f58a1 100644
--- a/go/arrow/scalar/nested.go
+++ b/go/arrow/scalar/nested.go
@@ -21,10 +21,10 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/numeric.gen.go b/go/arrow/scalar/numeric.gen.go
index da088162f4017..90ae2a7004ce3 100644
--- a/go/arrow/scalar/numeric.gen.go
+++ b/go/arrow/scalar/numeric.gen.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
 )
 
 type Int8 struct {
diff --git a/go/arrow/scalar/numeric.gen_test.go b/go/arrow/scalar/numeric.gen_test.go
index 807857c1c98c2..987cd66c75f3c 100644
--- a/go/arrow/scalar/numeric.gen_test.go
+++ b/go/arrow/scalar/numeric.gen_test.go
@@ -21,8 +21,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/numeric.gen_test.go.tmpl b/go/arrow/scalar/numeric.gen_test.go.tmpl
index 7f45898a20d29..c975cc9db6e1c 100644
--- a/go/arrow/scalar/numeric.gen_test.go.tmpl
+++ b/go/arrow/scalar/numeric.gen_test.go.tmpl
@@ -19,8 +19,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/parse.go b/go/arrow/scalar/parse.go
index 5002f98a65c42..fcffe1ea6adf8 100644
--- a/go/arrow/scalar/parse.go
+++ b/go/arrow/scalar/parse.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 type TypeToScalar interface {
diff --git a/go/arrow/scalar/scalar.go b/go/arrow/scalar/scalar.go
index 8b0d3ace2ad78..395771fa89c94 100644
--- a/go/arrow/scalar/scalar.go
+++ b/go/arrow/scalar/scalar.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/encoded"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/float16"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/encoded"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/scalar_test.go b/go/arrow/scalar/scalar_test.go
index ce8170301b0a2..405571a14880d 100644
--- a/go/arrow/scalar/scalar_test.go
+++ b/go/arrow/scalar/scalar_test.go
@@ -25,12 +25,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/temporal.go b/go/arrow/scalar/temporal.go
index ee13c84429e8e..880416f7dd5a3 100644
--- a/go/arrow/scalar/temporal.go
+++ b/go/arrow/scalar/temporal.go
@@ -22,7 +22,7 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func temporalToString(s TemporalScalar) string {
diff --git a/go/arrow/schema.go b/go/arrow/schema.go
index e84f350a53637..a7fa434131925 100644
--- a/go/arrow/schema.go
+++ b/go/arrow/schema.go
@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 type Metadata struct {
diff --git a/go/arrow/schema_test.go b/go/arrow/schema_test.go
index fddf1d7f131ec..5e79723f90352 100644
--- a/go/arrow/schema_test.go
+++ b/go/arrow/schema_test.go
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/table.go b/go/arrow/table.go
index 82dc283706b65..5a68085f8df93 100644
--- a/go/arrow/table.go
+++ b/go/arrow/table.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Table represents a logical sequence of chunked arrays of equal length. It is
diff --git a/go/arrow/tensor/numeric.gen.go b/go/arrow/tensor/numeric.gen.go
index d207f0bfa2c9c..5b7bbde150fe2 100644
--- a/go/arrow/tensor/numeric.gen.go
+++ b/go/arrow/tensor/numeric.gen.go
@@ -19,7 +19,7 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 // Int8 is an n-dim array of int8s.
diff --git a/go/arrow/tensor/numeric.gen.go.tmpl b/go/arrow/tensor/numeric.gen.go.tmpl
index e03f986da3f8f..c693082192247 100644
--- a/go/arrow/tensor/numeric.gen.go.tmpl
+++ b/go/arrow/tensor/numeric.gen.go.tmpl
@@ -17,8 +17,8 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/numeric.gen_test.go b/go/arrow/tensor/numeric.gen_test.go
index 3a7c3570c216b..00922a84b6b03 100644
--- a/go/arrow/tensor/numeric.gen_test.go
+++ b/go/arrow/tensor/numeric.gen_test.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 func TestTensorInt8(t *testing.T) {
diff --git a/go/arrow/tensor/numeric.gen_test.go.tmpl b/go/arrow/tensor/numeric.gen_test.go.tmpl
index 34f01b40d8084..665bb8dc68da9 100644
--- a/go/arrow/tensor/numeric.gen_test.go.tmpl
+++ b/go/arrow/tensor/numeric.gen_test.go.tmpl
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/tensor.go b/go/arrow/tensor/tensor.go
index 1f2ed7e82141b..27c380345a498 100644
--- a/go/arrow/tensor/tensor.go
+++ b/go/arrow/tensor/tensor.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 // Interface represents an n-dimensional array of numerical data.
diff --git a/go/arrow/tensor/tensor_test.go b/go/arrow/tensor/tensor_test.go
index 552c4c1c223e0..4cfe69f780421 100644
--- a/go/arrow/tensor/tensor_test.go
+++ b/go/arrow/tensor/tensor_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/tensor"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/tensor"
 )
 
 func TestTensor(t *testing.T) {
diff --git a/go/arrow/type_traits_boolean.go b/go/arrow/type_traits_boolean.go
index c164d45954fc0..6a46bdec702ff 100644
--- a/go/arrow/type_traits_boolean.go
+++ b/go/arrow/type_traits_boolean.go
@@ -17,7 +17,7 @@
 package arrow
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 type booleanTraits struct{}
diff --git a/go/arrow/type_traits_decimal128.go b/go/arrow/type_traits_decimal128.go
index f573ad3c65a4c..d2d3aae371663 100644
--- a/go/arrow/type_traits_decimal128.go
+++ b/go/arrow/type_traits_decimal128.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 // Decimal128 traits
diff --git a/go/arrow/type_traits_decimal256.go b/go/arrow/type_traits_decimal256.go
index adf3cc3e0bc31..256ed68fffc8d 100644
--- a/go/arrow/type_traits_decimal256.go
+++ b/go/arrow/type_traits_decimal256.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 // Decimal256 traits
diff --git a/go/arrow/type_traits_float16.go b/go/arrow/type_traits_float16.go
index e59efd4c248d8..c40363d3785da 100644
--- a/go/arrow/type_traits_float16.go
+++ b/go/arrow/type_traits_float16.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 )
 
 // Float16 traits
diff --git a/go/arrow/type_traits_interval.go b/go/arrow/type_traits_interval.go
index 5fbd7a5248918..35e6057090f10 100644
--- a/go/arrow/type_traits_interval.go
+++ b/go/arrow/type_traits_interval.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/internal/debug"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go b/go/arrow/type_traits_numeric.gen.go
index 57606c0fce6df..6edd75291155c 100644
--- a/go/arrow/type_traits_numeric.gen.go
+++ b/go/arrow/type_traits_numeric.gen.go
@@ -23,7 +23,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go.tmpl b/go/arrow/type_traits_numeric.gen.go.tmpl
index c491047b51429..ffae975c1aa15 100644
--- a/go/arrow/type_traits_numeric.gen.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen.go.tmpl
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen_test.go b/go/arrow/type_traits_numeric.gen_test.go
index ac2d0726ed6fa..74395485736ff 100644
--- a/go/arrow/type_traits_numeric.gen_test.go
+++ b/go/arrow/type_traits_numeric.gen_test.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func TestInt64Traits(t *testing.T) {
diff --git a/go/arrow/type_traits_numeric.gen_test.go.tmpl b/go/arrow/type_traits_numeric.gen_test.go.tmpl
index 4948f42cf542e..96685f31327bd 100644
--- a/go/arrow/type_traits_numeric.gen_test.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen_test.go.tmpl
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 {{- range .In}}
diff --git a/go/arrow/type_traits_test.go b/go/arrow/type_traits_test.go
index 0ae88b4bd82b6..85ad4da9d041d 100644
--- a/go/arrow/type_traits_test.go
+++ b/go/arrow/type_traits_test.go
@@ -22,10 +22,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/float16"
 )
 
 func TestBooleanTraits(t *testing.T) {
diff --git a/go/arrow/type_traits_timestamp.go b/go/arrow/type_traits_timestamp.go
index c1a9aba3db386..7c393b3559f82 100644
--- a/go/arrow/type_traits_timestamp.go
+++ b/go/arrow/type_traits_timestamp.go
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/endian"
 )
 
 var TimestampTraits timestampTraits
diff --git a/go/arrow/util/byte_size.go b/go/arrow/util/byte_size.go
index 6d6fc021f8005..141b78c459119 100644
--- a/go/arrow/util/byte_size.go
+++ b/go/arrow/util/byte_size.go
@@ -17,9 +17,9 @@
 package util
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 )
 
 func isArrayDataNil(arrayData arrow.ArrayData) bool {
diff --git a/go/arrow/util/byte_size_test.go b/go/arrow/util/byte_size_test.go
index a218c69558fe9..052bf3adee158 100644
--- a/go/arrow/util/byte_size_test.go
+++ b/go/arrow/util/byte_size_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/arrow/util"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow/util"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/go.mod b/go/go.mod
index a6c2af7025d32..de73c210d159d 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -14,7 +14,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-module github.com/apache/arrow/go/v15
+module github.com/apache/arrow/go/v14
 
 go 1.20
 
diff --git a/go/internal/bitutils/bit_block_counter.go b/go/internal/bitutils/bit_block_counter.go
index 99eece34cd068..86818bfd45ab7 100644
--- a/go/internal/bitutils/bit_block_counter.go
+++ b/go/internal/bitutils/bit_block_counter.go
@@ -21,8 +21,8 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 func loadWord(byt []byte) uint64 {
diff --git a/go/internal/bitutils/bit_block_counter_test.go b/go/internal/bitutils/bit_block_counter_test.go
index 790105c290182..ad5e989d1fa65 100644
--- a/go/internal/bitutils/bit_block_counter_test.go
+++ b/go/internal/bitutils/bit_block_counter_test.go
@@ -19,9 +19,9 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/rand"
 )
diff --git a/go/internal/bitutils/bit_run_reader.go b/go/internal/bitutils/bit_run_reader.go
index f09149d7ec5df..a1686a4909b8b 100644
--- a/go/internal/bitutils/bit_run_reader.go
+++ b/go/internal/bitutils/bit_run_reader.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // BitRun represents a run of bits with the same value of length Len
diff --git a/go/internal/bitutils/bit_run_reader_test.go b/go/internal/bitutils/bit_run_reader_test.go
index 7db76768a9476..0e1500bff811a 100644
--- a/go/internal/bitutils/bit_run_reader_test.go
+++ b/go/internal/bitutils/bit_run_reader_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/internal/bitutils/bit_set_run_reader.go b/go/internal/bitutils/bit_set_run_reader.go
index 6764ca7912679..a2269ffecb870 100644
--- a/go/internal/bitutils/bit_set_run_reader.go
+++ b/go/internal/bitutils/bit_set_run_reader.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // IsMultipleOf64 returns whether v is a multiple of 64.
diff --git a/go/internal/bitutils/bit_set_run_reader_test.go b/go/internal/bitutils/bit_set_run_reader_test.go
index 832993671ef6d..205954b3800a8 100644
--- a/go/internal/bitutils/bit_set_run_reader_test.go
+++ b/go/internal/bitutils/bit_set_run_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/internal/bitutils/bitmap_generate.go b/go/internal/bitutils/bitmap_generate.go
index 08b5fceab57d3..78219d8120bcc 100644
--- a/go/internal/bitutils/bitmap_generate.go
+++ b/go/internal/bitutils/bitmap_generate.go
@@ -16,7 +16,7 @@
 
 package bitutils
 
-import "github.com/apache/arrow/go/v15/arrow/bitutil"
+import "github.com/apache/arrow/go/v14/arrow/bitutil"
 
 // GenerateBits writes sequential bits to a bitmap. Bits preceding the
 // initial start offset are preserved, bits following the bitmap may
diff --git a/go/internal/bitutils/bitmap_generate_test.go b/go/internal/bitutils/bitmap_generate_test.go
index c9a6203864a20..788b2198c3a78 100644
--- a/go/internal/bitutils/bitmap_generate_test.go
+++ b/go/internal/bitutils/bitmap_generate_test.go
@@ -19,7 +19,7 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go b/go/internal/hashing/xxh3_memo_table.gen.go
index 39b82cdeff9a2..cc996552b49e5 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go
+++ b/go/internal/hashing/xxh3_memo_table.gen.go
@@ -21,9 +21,9 @@ package hashing
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 type payloadInt8 struct {
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
index 527008ad63c3c..25164341d227e 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
+++ b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
@@ -17,8 +17,8 @@
 package hashing
 
 import (
-  "github.com/apache/arrow/go/v15/arrow/bitutil"  
-  "github.com/apache/arrow/go/v15/internal/utils"  
+  "github.com/apache/arrow/go/v14/arrow/bitutil"  
+  "github.com/apache/arrow/go/v14/internal/utils"  
 )
 
 {{range .In}}
diff --git a/go/internal/types/extension_types.go b/go/internal/types/extension_types.go
index e24c89efc7b8b..1a31014874bbe 100644
--- a/go/internal/types/extension_types.go
+++ b/go/internal/types/extension_types.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/internal/json"
 	"github.com/google/uuid"
 	"golang.org/x/xerrors"
 )
diff --git a/go/internal/types/extension_types_test.go b/go/internal/types/extension_types_test.go
index f93f1000c9e4a..16273890b4c9c 100644
--- a/go/internal/types/extension_types_test.go
+++ b/go/internal/types/extension_types_test.go
@@ -20,11 +20,11 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/internal/utils/transpose_ints_def.go b/go/internal/utils/transpose_ints_def.go
index c52598d7148ea..cc3b0abb59363 100644
--- a/go/internal/utils/transpose_ints_def.go
+++ b/go/internal/utils/transpose_ints_def.go
@@ -19,7 +19,7 @@ package utils
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl -i -data=transpose_ints.tmpldata -d arch=avx2 transpose_ints_simd.go.tmpl=transpose_ints_avx2_amd64.go
diff --git a/go/internal/utils/transpose_ints_test.go b/go/internal/utils/transpose_ints_test.go
index 73b2bbce3fc14..e41b61156abdc 100644
--- a/go/internal/utils/transpose_ints_test.go
+++ b/go/internal/utils/transpose_ints_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 var (
diff --git a/go/parquet/cmd/parquet_reader/dumper.go b/go/parquet/cmd/parquet_reader/dumper.go
index 4cb2ea4a96fee..a04dcf23b2d8d 100644
--- a/go/parquet/cmd/parquet_reader/dumper.go
+++ b/go/parquet/cmd/parquet_reader/dumper.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 const defaultBatchSize = 128
diff --git a/go/parquet/cmd/parquet_reader/main.go b/go/parquet/cmd/parquet_reader/main.go
index 0d651d8c294c5..e7d1cd7fc5a7d 100644
--- a/go/parquet/cmd/parquet_reader/main.go
+++ b/go/parquet/cmd/parquet_reader/main.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 
 	"github.com/docopt/docopt-go"
 )
diff --git a/go/parquet/cmd/parquet_schema/main.go b/go/parquet/cmd/parquet_schema/main.go
index 01d541e8ac925..28d1288b54aeb 100644
--- a/go/parquet/cmd/parquet_schema/main.go
+++ b/go/parquet/cmd/parquet_schema/main.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/docopt/docopt-go"
 )
 
diff --git a/go/parquet/compress/brotli.go b/go/parquet/compress/brotli.go
index a1199d9711435..1c1ae1dffaca5 100644
--- a/go/parquet/compress/brotli.go
+++ b/go/parquet/compress/brotli.go
@@ -21,7 +21,7 @@ import (
 	"io"
 
 	"github.com/andybalholm/brotli"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 )
 
 type brotliCodec struct{}
diff --git a/go/parquet/compress/compress.go b/go/parquet/compress/compress.go
index f61147eb1ea10..4c4c792c2f614 100644
--- a/go/parquet/compress/compress.go
+++ b/go/parquet/compress/compress.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Compression is an alias to the thrift compression codec enum type for easy use
diff --git a/go/parquet/compress/compress_test.go b/go/parquet/compress/compress_test.go
index d1c55b15bc3cc..e8041a64c0996 100644
--- a/go/parquet/compress/compress_test.go
+++ b/go/parquet/compress/compress_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/compress/zstd.go b/go/parquet/compress/zstd.go
index fd8ec81953359..129af62807175 100644
--- a/go/parquet/compress/zstd.go
+++ b/go/parquet/compress/zstd.go
@@ -20,7 +20,7 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 	"github.com/klauspost/compress/zstd"
 )
 
diff --git a/go/parquet/doc.go b/go/parquet/doc.go
index afeee00587ef5..99a605a284fae 100644
--- a/go/parquet/doc.go
+++ b/go/parquet/doc.go
@@ -29,9 +29,9 @@
 // Install
 //
 // You can download the library and cli utilities via:
-//   go get -u github.com/apache/arrow/go/v15/parquet
-//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_reader@latest
-//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_schema@latest
+//   go get -u github.com/apache/arrow/go/v14/parquet
+//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_reader@latest
+//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_schema@latest
 //
 // Modules
 //
diff --git a/go/parquet/encryption_properties.go b/go/parquet/encryption_properties.go
index 6eb6cf1fe5680..dd85a856820fe 100644
--- a/go/parquet/encryption_properties.go
+++ b/go/parquet/encryption_properties.go
@@ -20,7 +20,7 @@ import (
 	"crypto/rand"
 	"unicode/utf8"
 
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Constants that will be used as the default values with encryption/decryption
diff --git a/go/parquet/encryption_properties_test.go b/go/parquet/encryption_properties_test.go
index ab028927c5ecb..0b1118a5cfa66 100644
--- a/go/parquet/encryption_properties_test.go
+++ b/go/parquet/encryption_properties_test.go
@@ -19,8 +19,8 @@ package parquet_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/encryption_read_config_test.go b/go/parquet/encryption_read_config_test.go
index 53b7ba3c621c0..8a84c19900dd0 100644
--- a/go/parquet/encryption_read_config_test.go
+++ b/go/parquet/encryption_read_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/encryption_write_config_test.go b/go/parquet/encryption_write_config_test.go
index 558b89208c706..6b2d049e1390c 100644
--- a/go/parquet/encryption_write_config_test.go
+++ b/go/parquet/encryption_write_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/file/column_reader.go b/go/parquet/file/column_reader.go
index 766638d88f26c..b623bd5074d02 100644
--- a/go/parquet/file/column_reader.go
+++ b/go/parquet/file/column_reader.go
@@ -21,13 +21,13 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_reader_test.go b/go/parquet/file/column_reader_test.go
index 21ea52e2b7bbc..3ce05c6cfe47e 100755
--- a/go/parquet/file/column_reader_test.go
+++ b/go/parquet/file/column_reader_test.go
@@ -24,12 +24,12 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/file/column_reader_types.gen.go b/go/parquet/file/column_reader_types.gen.go
index 3fb113780f811..31dccc157642f 100644
--- a/go/parquet/file/column_reader_types.gen.go
+++ b/go/parquet/file/column_reader_types.gen.go
@@ -21,9 +21,9 @@ package file
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 // Int32ColumnChunkReader is the Typed Column chunk reader instance for reading
diff --git a/go/parquet/file/column_reader_types.gen.go.tmpl b/go/parquet/file/column_reader_types.gen.go.tmpl
index 261b5f0bfacab..6557963e69f50 100644
--- a/go/parquet/file/column_reader_types.gen.go.tmpl
+++ b/go/parquet/file/column_reader_types.gen.go.tmpl
@@ -17,8 +17,8 @@
 package file
 
 import (
-    "github.com/apache/arrow/go/v15/parquet"
-    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
+    "github.com/apache/arrow/go/v14/parquet"
+    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/column_writer.go b/go/parquet/file/column_writer.go
index 0b0d1145d604e..9d9111042df28 100755
--- a/go/parquet/file/column_writer.go
+++ b/go/parquet/file/column_writer.go
@@ -21,14 +21,14 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata column_writer_types.gen.go.tmpl
diff --git a/go/parquet/file/column_writer_test.go b/go/parquet/file/column_writer_test.go
index 134c290fa6894..e2ae6b0f4a71e 100755
--- a/go/parquet/file/column_writer_test.go
+++ b/go/parquet/file/column_writer_test.go
@@ -24,19 +24,19 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	arrutils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	arrutils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/column_writer_types.gen.go b/go/parquet/file/column_writer_types.gen.go
index 8b3be25f3ea29..5594f63249fb8 100644
--- a/go/parquet/file/column_writer_types.gen.go
+++ b/go/parquet/file/column_writer_types.gen.go
@@ -22,12 +22,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_writer_types.gen.go.tmpl b/go/parquet/file/column_writer_types.gen.go.tmpl
index 7df69b4a219c6..c00e1dabb5fe6 100644
--- a/go/parquet/file/column_writer_types.gen.go.tmpl
+++ b/go/parquet/file/column_writer_types.gen.go.tmpl
@@ -19,10 +19,10 @@ package file
 import (
     "fmt"
     
-    "github.com/apache/arrow/go/v15/parquet"
-    "github.com/apache/arrow/go/v15/parquet/metadata"
-    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
-    format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+    "github.com/apache/arrow/go/v14/parquet"
+    "github.com/apache/arrow/go/v14/parquet/metadata"
+    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+    format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/file_reader.go b/go/parquet/file/file_reader.go
index afff579ded5b7..5481d5c7738b0 100644
--- a/go/parquet/file/file_reader.go
+++ b/go/parquet/file/file_reader.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/file_reader_mmap.go b/go/parquet/file/file_reader_mmap.go
index 03e12adf08c8c..89c5a84cee2e1 100644
--- a/go/parquet/file/file_reader_mmap.go
+++ b/go/parquet/file/file_reader_mmap.go
@@ -22,7 +22,7 @@ package file
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/exp/mmap"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/file_reader_mmap_windows.go b/go/parquet/file/file_reader_mmap_windows.go
index 06a9e97160fe0..6b08422163fd1 100644
--- a/go/parquet/file/file_reader_mmap_windows.go
+++ b/go/parquet/file/file_reader_mmap_windows.go
@@ -22,7 +22,7 @@ package file
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 func mmapOpen(filename string) (parquet.ReaderAtSeeker, error) {
diff --git a/go/parquet/file/file_reader_test.go b/go/parquet/file/file_reader_test.go
index f3248925cf5b9..2a9b097139062 100644
--- a/go/parquet/file/file_reader_test.go
+++ b/go/parquet/file/file_reader_test.go
@@ -25,16 +25,16 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index 48eb8f44d167b..c6289434bbe6e 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 // Writer is the primary interface for writing a parquet file
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index beceff9732584..af083ebe60e4f 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -22,13 +22,13 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/level_conversion.go b/go/parquet/file/level_conversion.go
index c23bdda445963..ac53dcd18abae 100755
--- a/go/parquet/file/level_conversion.go
+++ b/go/parquet/file/level_conversion.go
@@ -22,11 +22,11 @@ import (
 	"math/bits"
 	"unsafe"
 
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/level_conversion_test.go b/go/parquet/file/level_conversion_test.go
index 5d5bdde90dc7e..343edb687980d 100644
--- a/go/parquet/file/level_conversion_test.go
+++ b/go/parquet/file/level_conversion_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/file/page_reader.go b/go/parquet/file/page_reader.go
index 01f253aff8864..ab8679b127f1b 100644
--- a/go/parquet/file/page_reader.go
+++ b/go/parquet/file/page_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/page_writer.go b/go/parquet/file/page_writer.go
index c16476fbb232c..b2b6d5061b0fc 100644
--- a/go/parquet/file/page_writer.go
+++ b/go/parquet/file/page_writer.go
@@ -20,15 +20,15 @@ import (
 	"bytes"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/record_reader.go b/go/parquet/file/record_reader.go
index ad836d29ef483..3311a6d77da39 100755
--- a/go/parquet/file/record_reader.go
+++ b/go/parquet/file/record_reader.go
@@ -23,14 +23,14 @@ import (
 	"unsafe"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_reader.go b/go/parquet/file/row_group_reader.go
index 3c1c1edb0b484..f1aebf1085a23 100644
--- a/go/parquet/file/row_group_reader.go
+++ b/go/parquet/file/row_group_reader.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer.go b/go/parquet/file/row_group_writer.go
index 935c13d13a67f..75f0dede5246f 100644
--- a/go/parquet/file/row_group_writer.go
+++ b/go/parquet/file/row_group_writer.go
@@ -17,10 +17,10 @@
 package file
 
 import (
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer_test.go b/go/parquet/file/row_group_writer_test.go
index 2ea317cb91001..bc95e99d91582 100644
--- a/go/parquet/file/row_group_writer_test.go
+++ b/go/parquet/file/row_group_writer_test.go
@@ -20,10 +20,10 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/parquet/internal/bmi/bmi_test.go b/go/parquet/internal/bmi/bmi_test.go
index a5278dfef2211..460c6ec4e24c6 100644
--- a/go/parquet/internal/bmi/bmi_test.go
+++ b/go/parquet/internal/bmi/bmi_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/boolean_decoder.go b/go/parquet/internal/encoding/boolean_decoder.go
index 3782dc85ea814..337a6db967a2e 100644
--- a/go/parquet/internal/encoding/boolean_decoder.go
+++ b/go/parquet/internal/encoding/boolean_decoder.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 )
 
 // PlainBooleanDecoder is for the Plain Encoding type, there is no
diff --git a/go/parquet/internal/encoding/boolean_encoder.go b/go/parquet/internal/encoding/boolean_encoder.go
index 3e01bde369d8b..3970e05fca289 100644
--- a/go/parquet/internal/encoding/boolean_encoder.go
+++ b/go/parquet/internal/encoding/boolean_encoder.go
@@ -19,10 +19,10 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/byte_array_decoder.go b/go/parquet/internal/encoding/byte_array_decoder.go
index 82ce9f84265c5..c3ca1de5888f7 100644
--- a/go/parquet/internal/encoding/byte_array_decoder.go
+++ b/go/parquet/internal/encoding/byte_array_decoder.go
@@ -19,12 +19,12 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	pqutils "github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	pqutils "github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/byte_array_encoder.go b/go/parquet/internal/encoding/byte_array_encoder.go
index 9270b5531768c..cb49178435a6f 100644
--- a/go/parquet/internal/encoding/byte_array_encoder.go
+++ b/go/parquet/internal/encoding/byte_array_encoder.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // PlainByteArrayEncoder encodes byte arrays according to the spec for Plain encoding
diff --git a/go/parquet/internal/encoding/decoder.go b/go/parquet/internal/encoding/decoder.go
index cee624730e993..b441868e1df85 100644
--- a/go/parquet/internal/encoding/decoder.go
+++ b/go/parquet/internal/encoding/decoder.go
@@ -20,16 +20,16 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index a00f3457cac7a..1fb91634e977b 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 )
 
 // see the deltaBitPack encoder for a description of the encoding format that is
diff --git a/go/parquet/internal/encoding/delta_byte_array.go b/go/parquet/internal/encoding/delta_byte_array.go
index b35d022fd5deb..60a20a3ff0d72 100644
--- a/go/parquet/internal/encoding/delta_byte_array.go
+++ b/go/parquet/internal/encoding/delta_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_byte_array_test.go b/go/parquet/internal/encoding/delta_byte_array_test.go
index 0a206796f742a..69c632bf69971 100644
--- a/go/parquet/internal/encoding/delta_byte_array_test.go
+++ b/go/parquet/internal/encoding/delta_byte_array_test.go
@@ -18,8 +18,8 @@ package encoding
 
 import (
 	"fmt"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
diff --git a/go/parquet/internal/encoding/delta_length_byte_array.go b/go/parquet/internal/encoding/delta_length_byte_array.go
index d5a99c187d11e..981a067b07e08 100644
--- a/go/parquet/internal/encoding/delta_length_byte_array.go
+++ b/go/parquet/internal/encoding/delta_length_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/encoder.go b/go/parquet/internal/encoding/encoder.go
index 7023309397a3b..f6b57fe63c433 100644
--- a/go/parquet/internal/encoding/encoder.go
+++ b/go/parquet/internal/encoding/encoder.go
@@ -21,14 +21,14 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata plain_encoder_types.gen.go.tmpl typed_encoder.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/encoding_benchmarks_test.go b/go/parquet/internal/encoding/encoding_benchmarks_test.go
index e0645e9de54e4..0bb4e895f316d 100644
--- a/go/parquet/internal/encoding/encoding_benchmarks_test.go
+++ b/go/parquet/internal/encoding/encoding_benchmarks_test.go
@@ -21,14 +21,14 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/hashing"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index 48e2316b0f897..b0d86321e09f1 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -26,13 +26,13 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
index 1e589fc2e7be1..e4516bf4a1ac1 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
@@ -19,8 +19,8 @@ package encoding
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
index 39202c8e25d9f..b5aee337d5bf0 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
@@ -19,9 +19,9 @@ package encoding
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // PlainFixedLenByteArrayEncoder writes the raw bytes of the byte array
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index caf832059334b..e04ec19d5473d 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/levels_test.go b/go/parquet/internal/encoding/levels_test.go
index 304ce32b3106d..ae3a3a8c497fc 100644
--- a/go/parquet/internal/encoding/levels_test.go
+++ b/go/parquet/internal/encoding/levels_test.go
@@ -21,11 +21,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table.go b/go/parquet/internal/encoding/memo_table.go
index 810e8633b886e..170eab47d6160 100644
--- a/go/parquet/internal/encoding/memo_table.go
+++ b/go/parquet/internal/encoding/memo_table.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/hashing"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata memo_table_types.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/memo_table_test.go b/go/parquet/internal/encoding/memo_table_test.go
index 1b9337010f855..1eb61cb2559a3 100644
--- a/go/parquet/internal/encoding/memo_table_test.go
+++ b/go/parquet/internal/encoding/memo_table_test.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/hashing"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go b/go/parquet/internal/encoding/memo_table_types.gen.go
index 4da2721437814..c9af6178bbb98 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go
@@ -19,8 +19,8 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
index 75335f25ff1f7..7e88238d67b71 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
@@ -17,7 +17,7 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v14/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go b/go/parquet/internal/encoding/plain_encoder_types.gen.go
index 09403d74cb06f..23db13b7a4121 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go
@@ -24,11 +24,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
index 2838c63a41857..e45419050302d 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
@@ -20,10 +20,10 @@ import (
   "encoding/binary"
   "fmt"
 
-  "github.com/apache/arrow/go/v15/arrow"
-  "github.com/apache/arrow/go/v15/parquet"
-  "github.com/apache/arrow/go/v15/internal/utils"
-  "github.com/apache/arrow/go/v15/internal/bitutils"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 var (
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go b/go/parquet/internal/encoding/typed_encoder.gen.go
index 25fa309e0a38f..411e87c17e7d5 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go
@@ -22,15 +22,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
index 66c2649d599c6..69415ccca4a26 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
@@ -17,13 +17,13 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v15/parquet"
-  "github.com/apache/arrow/go/v15/parquet/schema"
-  format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-  "github.com/apache/arrow/go/v15/arrow"
-  "github.com/apache/arrow/go/v15/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-  "github.com/apache/arrow/go/v15/internal/bitutils"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/parquet/schema"
+  format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 // fully typed encoder interfaces to enable writing against encoder/decoders
diff --git a/go/parquet/internal/encoding/types.go b/go/parquet/internal/encoding/types.go
index 4ab3ab1a1c954..2d13a9c8f877a 100644
--- a/go/parquet/internal/encoding/types.go
+++ b/go/parquet/internal/encoding/types.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encryption/aes.go b/go/parquet/internal/encryption/aes.go
index b6e9130ef81cd..cc0cea0112fee 100644
--- a/go/parquet/internal/encryption/aes.go
+++ b/go/parquet/internal/encryption/aes.go
@@ -29,7 +29,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // important constants for handling the aes encryption
diff --git a/go/parquet/internal/encryption/decryptor.go b/go/parquet/internal/encryption/decryptor.go
index 658559e6082c4..62a4f2ee9e56e 100644
--- a/go/parquet/internal/encryption/decryptor.go
+++ b/go/parquet/internal/encryption/decryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // FileDecryptor is an interface used by the filereader for decrypting an
diff --git a/go/parquet/internal/encryption/encryptor.go b/go/parquet/internal/encryption/encryptor.go
index bdbae4740a44f..2ef09e558a23f 100644
--- a/go/parquet/internal/encryption/encryptor.go
+++ b/go/parquet/internal/encryption/encryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 // FileEncryptor is the interface for constructing encryptors for the different
diff --git a/go/parquet/internal/testutils/pagebuilder.go b/go/parquet/internal/testutils/pagebuilder.go
index 48ac331640087..9c1fd72a1bdf0 100644
--- a/go/parquet/internal/testutils/pagebuilder.go
+++ b/go/parquet/internal/testutils/pagebuilder.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/mock"
 )
 
diff --git a/go/parquet/internal/testutils/primitive_typed.go b/go/parquet/internal/testutils/primitive_typed.go
index daab0d427ba10..2bd0a29dd2970 100644
--- a/go/parquet/internal/testutils/primitive_typed.go
+++ b/go/parquet/internal/testutils/primitive_typed.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 type PrimitiveTypedTest struct {
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index bb101ebf9a92d..d9a06da43ba4e 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -24,13 +24,13 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/endian"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
diff --git a/go/parquet/internal/testutils/random_arrow.go b/go/parquet/internal/testutils/random_arrow.go
index d886db0360b84..360b8e7476430 100644
--- a/go/parquet/internal/testutils/random_arrow.go
+++ b/go/parquet/internal/testutils/random_arrow.go
@@ -17,9 +17,9 @@
 package testutils
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/parquet/internal/testutils/utils.go b/go/parquet/internal/testutils/utils.go
index 3da76c17ddc32..1122f4286f386 100644
--- a/go/parquet/internal/testutils/utils.go
+++ b/go/parquet/internal/testutils/utils.go
@@ -19,7 +19,7 @@ package testutils
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 )
 
 var typeToParquetTypeMap = map[reflect.Type]parquet.Type{
diff --git a/go/parquet/internal/thrift/helpers.go b/go/parquet/internal/thrift/helpers.go
index 3835830ac6c2d..357d9020989d3 100644
--- a/go/parquet/internal/thrift/helpers.go
+++ b/go/parquet/internal/thrift/helpers.go
@@ -23,7 +23,7 @@ import (
 	"context"
 	"io"
 
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
 	"github.com/apache/thrift/lib/go/thrift"
 )
 
diff --git a/go/parquet/internal/utils/bit_benchmark_test.go b/go/parquet/internal/utils/bit_benchmark_test.go
index 14353380a5694..2518e48a4baa8 100644
--- a/go/parquet/internal/utils/bit_benchmark_test.go
+++ b/go/parquet/internal/utils/bit_benchmark_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
 )
 
 type linearBitRunReader struct {
diff --git a/go/parquet/internal/utils/bit_packing_arm64.go b/go/parquet/internal/utils/bit_packing_arm64.go
index e9fb2ef1d810b..92fe0f97b77c3 100644
--- a/go/parquet/internal/utils/bit_packing_arm64.go
+++ b/go/parquet/internal/utils/bit_packing_arm64.go
@@ -23,7 +23,7 @@ import (
 	"github.com/klauspost/cpuid/v2"
 	// import for side effect of initializing feature flags
 	// based on ARM_ENABLE_EXT env var
-	_ "github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	_ "github.com/apache/arrow/go/v14/parquet/internal/bmi"
 )
 
 func init() {
diff --git a/go/parquet/internal/utils/bit_reader.go b/go/parquet/internal/utils/bit_reader.go
index bf9741c79878b..cf61395c0b16c 100644
--- a/go/parquet/internal/utils/bit_reader.go
+++ b/go/parquet/internal/utils/bit_reader.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // masks for grabbing the trailing bits based on the number of trailing bits desired
diff --git a/go/parquet/internal/utils/bit_reader_test.go b/go/parquet/internal/utils/bit_reader_test.go
index 5ce1b799b463b..c285f5165cc0a 100644
--- a/go/parquet/internal/utils/bit_reader_test.go
+++ b/go/parquet/internal/utils/bit_reader_test.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"golang.org/x/exp/rand"
diff --git a/go/parquet/internal/utils/bit_writer.go b/go/parquet/internal/utils/bit_writer.go
index 6cb255f5b0473..99a1db065590d 100644
--- a/go/parquet/internal/utils/bit_writer.go
+++ b/go/parquet/internal/utils/bit_writer.go
@@ -21,7 +21,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 // WriterAtBuffer is a convenience struct for providing a WriteAt function
diff --git a/go/parquet/internal/utils/bitmap_writer.go b/go/parquet/internal/utils/bitmap_writer.go
index 3ef99291e3748..447222139b773 100644
--- a/go/parquet/internal/utils/bitmap_writer.go
+++ b/go/parquet/internal/utils/bitmap_writer.go
@@ -20,7 +20,7 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
 )
 
 // BitmapWriter is an interface for bitmap writers so that we can use multiple
diff --git a/go/parquet/internal/utils/bitmap_writer_test.go b/go/parquet/internal/utils/bitmap_writer_test.go
index 3dddc7567903e..9f38f1ef291ea 100644
--- a/go/parquet/internal/utils/bitmap_writer_test.go
+++ b/go/parquet/internal/utils/bitmap_writer_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/parquet/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index 21ac2ce6b5db5..fef322c6fd560 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -24,10 +24,10 @@ import (
 	"encoding/binary"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go b/go/parquet/internal/utils/typed_rle_dict.gen.go
index 886d24564db4b..dff22711b120f 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go
@@ -19,9 +19,9 @@
 package utils
 
 import (
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
index abcb419055a92..090275745ff59 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
@@ -17,9 +17,9 @@
 package utils
 
 import (
-  "github.com/apache/arrow/go/v15/parquet"
-  "github.com/apache/arrow/go/v15/internal/bitutils"
-  "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v14/internal/utils"
 )
 
 {{range .In}}
diff --git a/go/parquet/metadata/app_version.go b/go/parquet/metadata/app_version.go
index 9966827026106..85ace57365bd3 100644
--- a/go/parquet/metadata/app_version.go
+++ b/go/parquet/metadata/app_version.go
@@ -21,8 +21,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 var (
diff --git a/go/parquet/metadata/column_chunk.go b/go/parquet/metadata/column_chunk.go
index 729f741e1b4f9..e6ea6ff1ea183 100644
--- a/go/parquet/metadata/column_chunk.go
+++ b/go/parquet/metadata/column_chunk.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/file.go b/go/parquet/metadata/file.go
index 3335140c2e1c8..dddd95c5df670 100644
--- a/go/parquet/metadata/file.go
+++ b/go/parquet/metadata/file.go
@@ -24,12 +24,12 @@ import (
 	"reflect"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/metadata_test.go b/go/parquet/metadata/metadata_test.go
index 8caa319f83e63..b685dd2223274 100644
--- a/go/parquet/metadata/metadata_test.go
+++ b/go/parquet/metadata/metadata_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/row_group.go b/go/parquet/metadata/row_group.go
index 2923720371abe..16af67241e959 100644
--- a/go/parquet/metadata/row_group.go
+++ b/go/parquet/metadata/row_group.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 // RowGroupMetaData is a proxy around the thrift RowGroup meta data object
diff --git a/go/parquet/metadata/stat_compare_test.go b/go/parquet/metadata/stat_compare_test.go
index 041696d84d17a..d02123cbef039 100644
--- a/go/parquet/metadata/stat_compare_test.go
+++ b/go/parquet/metadata/stat_compare_test.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/statistics.go b/go/parquet/metadata/statistics.go
index 606e76ffd0454..245b06a7348c4 100644
--- a/go/parquet/metadata/statistics.go
+++ b/go/parquet/metadata/statistics.go
@@ -22,14 +22,14 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata statistics_types.gen.go.tmpl
diff --git a/go/parquet/metadata/statistics_test.go b/go/parquet/metadata/statistics_test.go
index 47798d3c4dd3c..35d8b7821c51a 100644
--- a/go/parquet/metadata/statistics_test.go
+++ b/go/parquet/metadata/statistics_test.go
@@ -21,11 +21,11 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go b/go/parquet/metadata/statistics_types.gen.go
index e8fb9877c8444..e6aa7f1801a0f 100644
--- a/go/parquet/metadata/statistics_types.gen.go
+++ b/go/parquet/metadata/statistics_types.gen.go
@@ -22,14 +22,14 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go.tmpl b/go/parquet/metadata/statistics_types.gen.go.tmpl
index 4b6253a8574ea..35470f06046bf 100644
--- a/go/parquet/metadata/statistics_types.gen.go.tmpl
+++ b/go/parquet/metadata/statistics_types.gen.go.tmpl
@@ -19,13 +19,13 @@ package metadata
 import (
   "fmt"
 
-  "github.com/apache/arrow/go/v15/arrow"
-  "github.com/apache/arrow/go/v15/parquet"
-  "github.com/apache/arrow/go/v15/parquet/schema"
-  "github.com/apache/arrow/go/v15/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
-  "github.com/apache/arrow/go/v15/parquet/internal/encoding"
-  "github.com/apache/arrow/go/v15/internal/bitutils"
+  "github.com/apache/arrow/go/v14/arrow"
+  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v14/parquet/schema"
+  "github.com/apache/arrow/go/v14/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+  "github.com/apache/arrow/go/v14/internal/bitutils"
 )
 
 {{range .In}}
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 02f94c941c3d9..759a3d8675927 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -26,16 +26,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index 81b4527b105cb..c3a0a50c43f45 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -25,16 +25,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
 )
 
 // get the count of the number of leaf arrays for the type
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 281ca0d526476..3c20cf2d4757b 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -25,22 +25,22 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/bitutil"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/decimal256"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/encode_dict_compute.go b/go/parquet/pqarrow/encode_dict_compute.go
index b43b4002ed0af..59e25cec19132 100644
--- a/go/parquet/pqarrow/encode_dict_compute.go
+++ b/go/parquet/pqarrow/encode_dict_compute.go
@@ -21,14 +21,14 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 func isDictEncoding(enc parquet.Encoding) bool {
diff --git a/go/parquet/pqarrow/encode_dict_nocompute.go b/go/parquet/pqarrow/encode_dict_nocompute.go
index 73ec5cfc46682..31d0f1bc1ce27 100644
--- a/go/parquet/pqarrow/encode_dict_nocompute.go
+++ b/go/parquet/pqarrow/encode_dict_nocompute.go
@@ -21,8 +21,8 @@ package pqarrow
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/parquet/file"
 )
 
 func writeDictionaryArrow(*arrowWriteContext, file.ColumnChunkWriter, arrow.Array, []int16, []int16, bool) (err error) {
diff --git a/go/parquet/pqarrow/encode_dictionary_test.go b/go/parquet/pqarrow/encode_dictionary_test.go
index 28ebee53e1b83..995f3fb329534 100644
--- a/go/parquet/pqarrow/encode_dictionary_test.go
+++ b/go/parquet/pqarrow/encode_dictionary_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/compute"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/pqarrow/file_reader.go b/go/parquet/pqarrow/file_reader.go
index 3534cc87b78b5..d91010c62c19d 100755
--- a/go/parquet/pqarrow/file_reader.go
+++ b/go/parquet/pqarrow/file_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/arrio"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/arrio"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/pqarrow/file_reader_test.go b/go/parquet/pqarrow/file_reader_test.go
index 9c1b4252f5fc6..d1f3ae1c984a2 100644
--- a/go/parquet/pqarrow/file_reader_test.go
+++ b/go/parquet/pqarrow/file_reader_test.go
@@ -26,13 +26,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index 21f16c0b67938..aa0bae7b1fdfb 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/internal/utils"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/helpers.go b/go/parquet/pqarrow/helpers.go
index 39d17cf80ae68..e8b740d12ba62 100644
--- a/go/parquet/pqarrow/helpers.go
+++ b/go/parquet/pqarrow/helpers.go
@@ -17,7 +17,7 @@
 package pqarrow
 
 import (
-	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v14/arrow"
 )
 
 func releaseArrays(arrays []arrow.Array) {
diff --git a/go/parquet/pqarrow/path_builder.go b/go/parquet/pqarrow/path_builder.go
index 0f1158bd1e9f0..c4915d58dd59f 100644
--- a/go/parquet/pqarrow/path_builder.go
+++ b/go/parquet/pqarrow/path_builder.go
@@ -21,11 +21,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/bitutils"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/path_builder_test.go b/go/parquet/pqarrow/path_builder_test.go
index e0a60262d3f4a..16b994582df02 100644
--- a/go/parquet/pqarrow/path_builder_test.go
+++ b/go/parquet/pqarrow/path_builder_test.go
@@ -20,10 +20,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/properties.go b/go/parquet/pqarrow/properties.go
index cc100fa80d87b..98427bbf9398c 100755
--- a/go/parquet/pqarrow/properties.go
+++ b/go/parquet/pqarrow/properties.go
@@ -19,9 +19,9 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
 )
 
 // ArrowWriterProperties are used to determine how to manipulate the arrow data
diff --git a/go/parquet/pqarrow/reader_writer_test.go b/go/parquet/pqarrow/reader_writer_test.go
index 9d09bcec15da6..e3f66834c2cee 100644
--- a/go/parquet/pqarrow/reader_writer_test.go
+++ b/go/parquet/pqarrow/reader_writer_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/array"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index b23c37ea39102..9ba8554898986 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -22,15 +22,15 @@ import (
 	"math"
 	"strconv"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/decimal128"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/file"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/schema_test.go b/go/parquet/pqarrow/schema_test.go
index b5e7dc8fad34a..e195358af6c98 100644
--- a/go/parquet/pqarrow/schema_test.go
+++ b/go/parquet/pqarrow/schema_test.go
@@ -20,15 +20,15 @@ import (
 	"encoding/base64"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	"github.com/apache/arrow/go/v15/arrow/flight"
-	"github.com/apache/arrow/go/v15/arrow/ipc"
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/types"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/metadata"
-	"github.com/apache/arrow/go/v15/parquet/pqarrow"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/reader_properties.go b/go/parquet/reader_properties.go
index be2377527d782..dd2032958a51c 100644
--- a/go/parquet/reader_properties.go
+++ b/go/parquet/reader_properties.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/internal/utils"
 )
 
 // ReaderProperties are used to define how the file reader will handle buffering and allocating buffers
diff --git a/go/parquet/reader_writer_properties_test.go b/go/parquet/reader_writer_properties_test.go
index 698129471adda..6bd93a02550e4 100644
--- a/go/parquet/reader_writer_properties_test.go
+++ b/go/parquet/reader_writer_properties_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/column.go b/go/parquet/schema/column.go
index 02d0d83e8465e..1575037d59d23 100644
--- a/go/parquet/schema/column.go
+++ b/go/parquet/schema/column.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // Column encapsulates the information necessary to interpret primitive
diff --git a/go/parquet/schema/converted_types.go b/go/parquet/schema/converted_types.go
index 58051dba7f19b..6a4702b819259 100644
--- a/go/parquet/schema/converted_types.go
+++ b/go/parquet/schema/converted_types.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // ConvertedType corresponds to the ConvertedType in the parquet.Thrift,
diff --git a/go/parquet/schema/converted_types_test.go b/go/parquet/schema/converted_types_test.go
index 8b8e061466474..a4f9ea0018196 100644
--- a/go/parquet/schema/converted_types_test.go
+++ b/go/parquet/schema/converted_types_test.go
@@ -19,7 +19,7 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/helpers.go b/go/parquet/schema/helpers.go
index 13075a065f073..23a5a0b667f26 100644
--- a/go/parquet/schema/helpers.go
+++ b/go/parquet/schema/helpers.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/helpers_test.go b/go/parquet/schema/helpers_test.go
index 98f3cab36d433..6d136e4ecd155 100644
--- a/go/parquet/schema/helpers_test.go
+++ b/go/parquet/schema/helpers_test.go
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index 1ea44fc56c615..a0607a1a2f62d 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 // DecimalMetadata is a struct for managing scale and precision information between
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 49edf1748c52c..8531a061abb77 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -19,9 +19,9 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/internal/json"
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/node.go b/go/parquet/schema/node.go
index ff23624afa35d..28259c8d61f58 100644
--- a/go/parquet/schema/node.go
+++ b/go/parquet/schema/node.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index d79edb92408f8..bc863f1390030 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index 06ad7191a5749..e18feada7a796 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -22,8 +22,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/schema.go b/go/parquet/schema/schema.go
index ace2775763a06..1b3363f58d11f 100644
--- a/go/parquet/schema/schema.go
+++ b/go/parquet/schema/schema.go
@@ -35,8 +35,8 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/schema_element_test.go b/go/parquet/schema/schema_element_test.go
index dd1d293e5cfd7..e9a2ef5eb31f6 100644
--- a/go/parquet/schema/schema_element_test.go
+++ b/go/parquet/schema/schema_element_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_flatten_test.go b/go/parquet/schema/schema_flatten_test.go
index 34f4ac8d3c450..90741ae9b43bb 100644
--- a/go/parquet/schema/schema_flatten_test.go
+++ b/go/parquet/schema/schema_flatten_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_test.go b/go/parquet/schema/schema_test.go
index b60c7dfaafcd1..e69a13e07986e 100644
--- a/go/parquet/schema/schema_test.go
+++ b/go/parquet/schema/schema_test.go
@@ -20,9 +20,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v15/parquet"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v15/parquet/schema"
+	"github.com/apache/arrow/go/v14/parquet"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/types.go b/go/parquet/types.go
index 5b6f8fb0251d9..7b6df2ea9d16c 100644
--- a/go/parquet/types.go
+++ b/go/parquet/types.go
@@ -24,8 +24,8 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v15/arrow"
-	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v14/arrow"
+	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
 )
 
 const (
diff --git a/go/parquet/writer_properties.go b/go/parquet/writer_properties.go
index 9e33bddf7faa7..acd43194c1be7 100644
--- a/go/parquet/writer_properties.go
+++ b/go/parquet/writer_properties.go
@@ -17,8 +17,8 @@
 package parquet
 
 import (
-	"github.com/apache/arrow/go/v15/arrow/memory"
-	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v14/parquet/compress"
 )
 
 // Constants for default property values used for the default reader, writer and column props.
@@ -46,7 +46,7 @@ const (
 	DefaultStatsEnabled = true
 	// If the stats are larger than 4K the writer will skip writing them out anyways.
 	DefaultMaxStatsSize int64 = 4096
-	DefaultCreatedBy          = "parquet-go version 15.0.0-SNAPSHOT"
+	DefaultCreatedBy          = "parquet-go version 14.0.1-SNAPSHOT"
 	DefaultRootName           = "schema"
 )
 
diff --git a/java/adapter/avro/pom.xml b/java/adapter/avro/pom.xml
index c0410ea4c2314..20602f3b80771 100644
--- a/java/adapter/avro/pom.xml
+++ b/java/adapter/avro/pom.xml
@@ -16,7 +16,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
     <relativePath>../../pom.xml</relativePath>
   </parent>
 
diff --git a/java/adapter/jdbc/pom.xml b/java/adapter/jdbc/pom.xml
index 2490f708e6f24..f97bcaf74a27c 100644
--- a/java/adapter/jdbc/pom.xml
+++ b/java/adapter/jdbc/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/adapter/orc/pom.xml b/java/adapter/orc/pom.xml
index 72ba13ea81738..2213a2a7d0783 100644
--- a/java/adapter/orc/pom.xml
+++ b/java/adapter/orc/pom.xml
@@ -111,7 +111,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/algorithm/pom.xml b/java/algorithm/pom.xml
index 8c6a9fb0151ef..a248389aeb406 100644
--- a/java/algorithm/pom.xml
+++ b/java/algorithm/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-algorithm</artifactId>
   <name>Arrow Algorithms</name>
diff --git a/java/bom/pom.xml b/java/bom/pom.xml
index 1f6f854f60013..01f5e93dc0438 100644
--- a/java/bom/pom.xml
+++ b/java/bom/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-bom</artifactId>
-  <version>15.0.0-SNAPSHOT</version>
+  <version>14.0.1-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Arrow Bill of Materials</name>
   <description>Arrow Bill of Materials</description>
diff --git a/java/c/pom.xml b/java/c/pom.xml
index d66379d356624..7a4631704fa80 100644
--- a/java/c/pom.xml
+++ b/java/c/pom.xml
@@ -13,7 +13,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/compression/pom.xml b/java/compression/pom.xml
index 129268b9e6a07..283c2af2d7d76 100644
--- a/java/compression/pom.xml
+++ b/java/compression/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-compression</artifactId>
   <name>Arrow Compression</name>
diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index b533a1733521b..cdc1a411798c3 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/flight/flight-core/pom.xml b/java/flight/flight-core/pom.xml
index 7b69179053d7f..172a8583d8c88 100644
--- a/java/flight/flight-core/pom.xml
+++ b/java/flight/flight-core/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/flight-grpc/pom.xml b/java/flight/flight-grpc/pom.xml
index e7bb9508d2403..f113ba50759a9 100644
--- a/java/flight/flight-grpc/pom.xml
+++ b/java/flight/flight-grpc/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
   <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-integration-tests/pom.xml b/java/flight/flight-integration-tests/pom.xml
index 778cb7df11f61..6b7796641b607 100644
--- a/java/flight/flight-integration-tests/pom.xml
+++ b/java/flight/flight-integration-tests/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index cbeaa88f1e2f7..34efb04fa8702 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 263538ba48b37..69e3bfad8d883 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql/pom.xml b/java/flight/flight-sql/pom.xml
index 09100d9731ad5..e49cb8fa4dd5c 100644
--- a/java/flight/flight-sql/pom.xml
+++ b/java/flight/flight-sql/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/pom.xml b/java/flight/pom.xml
index 7ddda94f77b49..fd65c054d971e 100644
--- a/java/flight/pom.xml
+++ b/java/flight/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/format/pom.xml b/java/format/pom.xml
index 3f581311e20ea..58dd21e3288f2 100644
--- a/java/format/pom.xml
+++ b/java/format/pom.xml
@@ -15,7 +15,7 @@
 <parent>
   <artifactId>arrow-java-root</artifactId>
   <groupId>org.apache.arrow</groupId>
-  <version>15.0.0-SNAPSHOT</version>
+  <version>14.0.1-SNAPSHOT</version>
 </parent>
 
 <artifactId>arrow-format</artifactId>
diff --git a/java/gandiva/pom.xml b/java/gandiva/pom.xml
index cfda0b0c527a9..e87ba2bb4eb88 100644
--- a/java/gandiva/pom.xml
+++ b/java/gandiva/pom.xml
@@ -14,7 +14,7 @@
     <parent>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-java-root</artifactId>
-      <version>15.0.0-SNAPSHOT</version>
+      <version>14.0.1-SNAPSHOT</version>
     </parent>
 
     <groupId>org.apache.arrow.gandiva</groupId>
diff --git a/java/memory/memory-core/pom.xml b/java/memory/memory-core/pom.xml
index 8f28699045383..5d1886032b3e8 100644
--- a/java/memory/memory-core/pom.xml
+++ b/java/memory/memory-core/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-netty/pom.xml b/java/memory/memory-netty/pom.xml
index 307f6ad81a0f1..56db6924bf746 100644
--- a/java/memory/memory-netty/pom.xml
+++ b/java/memory/memory-netty/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-unsafe/pom.xml b/java/memory/memory-unsafe/pom.xml
index 9f8137308195d..68bd61e742741 100644
--- a/java/memory/memory-unsafe/pom.xml
+++ b/java/memory/memory-unsafe/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/pom.xml b/java/memory/pom.xml
index c10263b97f1bf..6fc9d11730eaf 100644
--- a/java/memory/pom.xml
+++ b/java/memory/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-memory</artifactId>
   <name>Arrow Memory</name>
diff --git a/java/performance/pom.xml b/java/performance/pom.xml
index 102832491ec05..6aa1599425ad8 100644
--- a/java/performance/pom.xml
+++ b/java/performance/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-performance</artifactId>
     <packaging>jar</packaging>
diff --git a/java/pom.xml b/java/pom.xml
index 2a9997b7012b7..caf470ee2b2b2 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-java-root</artifactId>
-  <version>15.0.0-SNAPSHOT</version>
+  <version>14.0.1-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>Apache Arrow Java Root POM</name>
diff --git a/java/tools/pom.xml b/java/tools/pom.xml
index 128825c224369..ce6243e98dacf 100644
--- a/java/tools/pom.xml
+++ b/java/tools/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>15.0.0-SNAPSHOT</version>
+        <version>14.0.1-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-tools</artifactId>
     <name>Arrow Tools</name>
diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index 4c8bf1e594aa4..0cfa421fbf7d4 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>15.0.0-SNAPSHOT</version>
+    <version>14.0.1-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-vector</artifactId>
   <name>Arrow Vectors</name>
diff --git a/js/package.json b/js/package.json
index 33bc4849903ef..3bad73b6fdf76 100644
--- a/js/package.json
+++ b/js/package.json
@@ -124,5 +124,5 @@
   "engines": {
     "node": ">=12.0"
   },
-  "version": "15.0.0-SNAPSHOT"
+  "version": "14.0.1-SNAPSHOT"
 }
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index 47d2acd613f8b..df20ad9680707 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -94,7 +94,7 @@ endfunction()
 
 set(CMAKE_CXX_STANDARD 17)
 
-set(MLARROW_VERSION "15.0.0-SNAPSHOT")
+set(MLARROW_VERSION "14.0.1-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" MLARROW_BASE_VERSION "${MLARROW_VERSION}")
 
 project(mlarrow VERSION "${MLARROW_BASE_VERSION}")
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 86285c3dc381b..95d23933a88b7 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -21,7 +21,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(pyarrow)
 
-set(PYARROW_VERSION "15.0.0-SNAPSHOT")
+set(PYARROW_VERSION "14.0.1-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" PYARROW_BASE_VERSION "${PYARROW_VERSION}")
 
 # Running from a Python sdist tarball
diff --git a/python/setup.py b/python/setup.py
index b1c825d84d5a9..4e45b8c68fe16 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -407,7 +407,7 @@ def get_outputs(self):
 
 # If the event of not running from a git clone (e.g. from a git archive
 # or a Python sdist), see if we can set the version number ourselves
-default_version = '15.0.0-SNAPSHOT'
+default_version = '14.0.1-SNAPSHOT'
 if (not os.path.exists('../.git') and
         not os.environ.get('SETUPTOOLS_SCM_PRETEND_VERSION')):
     os.environ['SETUPTOOLS_SCM_PRETEND_VERSION'] = \
diff --git a/r/NEWS.md b/r/NEWS.md
index e00c6b51b597d..d2d5f08288cb8 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -21,6 +21,8 @@
 
 # arrow 14.0.0
 
+# arrow 14.0.0
+
 ## New features
 
 * When reading partitioned CSV datasets and supplying a schema to
diff --git a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
index 8551b647cb86f..86d8ffba80c90 100644
--- a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
+++ b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowCUDA
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
index acfdd675687be..b0a29b7f7b365 100644
--- a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
+++ b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowDataset
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
index 3354678e30032..6734ab6ae2536 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlightSQL
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/version.rb b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
index f2141a68432e5..b3b778108199e 100644
--- a/ruby/red-arrow-flight/lib/arrow-flight/version.rb
+++ b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlight
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow/lib/arrow/version.rb b/ruby/red-arrow/lib/arrow/version.rb
index 235a7df75d672..222b72d10bb34 100644
--- a/ruby/red-arrow/lib/arrow/version.rb
+++ b/ruby/red-arrow/lib/arrow/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-gandiva/lib/gandiva/version.rb b/ruby/red-gandiva/lib/gandiva/version.rb
index 6a1835f0e50e8..576ee097743db 100644
--- a/ruby/red-gandiva/lib/gandiva/version.rb
+++ b/ruby/red-gandiva/lib/gandiva/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Gandiva
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-parquet/lib/parquet/version.rb b/ruby/red-parquet/lib/parquet/version.rb
index c5a945c4e4297..17a9157a36047 100644
--- a/ruby/red-parquet/lib/parquet/version.rb
+++ b/ruby/red-parquet/lib/parquet/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Parquet
-  VERSION = "15.0.0-SNAPSHOT"
+  VERSION = "14.0.1-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")

From 452c420244ea45ee1376fc8f5707d0fc52c903c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Fri, 10 Nov 2023 16:21:57 +0100
Subject: [PATCH 715/749] MINOR: [Release] Update .deb/.rpm changelogs for
 14.0.0

---
 .../linux-packages/apache-arrow-apt-source/debian/changelog | 6 ++++++
 .../apache-arrow-release/yum/apache-arrow-release.spec.in   | 3 +++
 dev/tasks/linux-packages/apache-arrow/debian/changelog      | 6 ++++++
 dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in     | 3 +++
 4 files changed, 18 insertions(+)

diff --git a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
index 221fb0caa8952..8e3cfb9d1c38f 100644
--- a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
@@ -4,6 +4,12 @@ apache-arrow-apt-source (14.0.0-1) unstable; urgency=low
 
  -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
 
+apache-arrow-apt-source (14.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
+
 apache-arrow-apt-source (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
index 273bf32a2a8e4..680e7f75fe4b8 100644
--- a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
@@ -105,6 +105,9 @@ fi
 * Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
 - New upstream release.
 
+* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
+- New upstream release.
+
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/changelog b/dev/tasks/linux-packages/apache-arrow/debian/changelog
index 5e01d962c44d4..90a2ce8f21a91 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow/debian/changelog
@@ -4,6 +4,12 @@ apache-arrow (14.0.0-1) unstable; urgency=low
 
  -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
 
+apache-arrow (14.0.0-1) unstable; urgency=low
+
+  * New upstream release.
+
+ -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
+
 apache-arrow (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index f61d47db2edd7..95ea679d205ee 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -867,6 +867,9 @@ Documentation for Apache Parquet GLib.
 * Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
 - New upstream release.
 
+* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
+- New upstream release.
+
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 

From 0b796f8e995e92265325cc453d702f12b46d35ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Fri, 10 Nov 2023 16:26:15 +0100
Subject: [PATCH 716/749] Revert "MINOR: [Release] Update .deb/.rpm changelogs
 for 14.0.0"

This reverts commit 452c420244ea45ee1376fc8f5707d0fc52c903c5.
---
 .../linux-packages/apache-arrow-apt-source/debian/changelog | 6 ------
 .../apache-arrow-release/yum/apache-arrow-release.spec.in   | 3 ---
 dev/tasks/linux-packages/apache-arrow/debian/changelog      | 6 ------
 dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in     | 3 ---
 4 files changed, 18 deletions(-)

diff --git a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
index 8e3cfb9d1c38f..221fb0caa8952 100644
--- a/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow-apt-source/debian/changelog
@@ -4,12 +4,6 @@ apache-arrow-apt-source (14.0.0-1) unstable; urgency=low
 
  -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
 
-apache-arrow-apt-source (14.0.0-1) unstable; urgency=low
-
-  * New upstream release.
-
- -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
-
 apache-arrow-apt-source (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
index 680e7f75fe4b8..273bf32a2a8e4 100644
--- a/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow-release/yum/apache-arrow-release.spec.in
@@ -105,9 +105,6 @@ fi
 * Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
 - New upstream release.
 
-* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
-- New upstream release.
-
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 
diff --git a/dev/tasks/linux-packages/apache-arrow/debian/changelog b/dev/tasks/linux-packages/apache-arrow/debian/changelog
index 90a2ce8f21a91..5e01d962c44d4 100644
--- a/dev/tasks/linux-packages/apache-arrow/debian/changelog
+++ b/dev/tasks/linux-packages/apache-arrow/debian/changelog
@@ -4,12 +4,6 @@ apache-arrow (14.0.0-1) unstable; urgency=low
 
  -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
 
-apache-arrow (14.0.0-1) unstable; urgency=low
-
-  * New upstream release.
-
- -- Raúl Cumplido <raulcumplido@gmail.com>  Thu, 19 Oct 2023 09:12:19 -0000
-
 apache-arrow (13.0.0-1) unstable; urgency=low
 
   * New upstream release.
diff --git a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
index 95ea679d205ee..f61d47db2edd7 100644
--- a/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
+++ b/dev/tasks/linux-packages/apache-arrow/yum/arrow.spec.in
@@ -867,9 +867,6 @@ Documentation for Apache Parquet GLib.
 * Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
 - New upstream release.
 
-* Thu Oct 19 2023 Raúl Cumplido <raulcumplido@gmail.com> - 14.0.0-1
-- New upstream release.
-
 * Thu Aug 17 2023 Raúl Cumplido <raulcumplido@gmail.com> - 13.0.0-1
 - New upstream release.
 

From 3c99fbb470c926e948b3b80d8ae9bac5b5c6eddf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Fri, 10 Nov 2023 16:26:22 +0100
Subject: [PATCH 717/749] Revert "MINOR: [Release] Update versions for
 14.0.1-SNAPSHOT"

This reverts commit e5b2bba2229836f7b1b37a06d62081cb214d598a.
---
 c_glib/meson.build                            |  2 +-
 cpp/CMakeLists.txt                            |  2 +-
 cpp/vcpkg.json                                |  2 +-
 csharp/Directory.Build.props                  |  2 +-
 .../homebrew-formulae/apache-arrow-glib.rb    |  2 +-
 dev/tasks/homebrew-formulae/apache-arrow.rb   |  2 +-
 go/README.md                                  |  2 +-
 go/arrow/_examples/helloworld/main.go         |  8 ++---
 go/arrow/_tools/tmpl/main.go                  |  2 +-
 go/arrow/array.go                             |  4 +--
 go/arrow/array/array.go                       |  6 ++--
 go/arrow/array/array_test.go                  | 10 +++---
 go/arrow/array/binary.go                      |  4 +--
 go/arrow/array/binary_test.go                 |  6 ++--
 go/arrow/array/binarybuilder.go               |  8 ++---
 go/arrow/array/binarybuilder_test.go          |  6 ++--
 go/arrow/array/boolean.go                     |  8 ++---
 go/arrow/array/boolean_test.go                |  4 +--
 go/arrow/array/booleanbuilder.go              | 10 +++---
 go/arrow/array/booleanbuilder_test.go         |  6 ++--
 go/arrow/array/bufferbuilder.go               |  6 ++--
 go/arrow/array/bufferbuilder_byte.go          |  2 +-
 go/arrow/array/bufferbuilder_numeric.gen.go   |  6 ++--
 .../array/bufferbuilder_numeric.gen.go.tmpl   |  6 ++--
 go/arrow/array/bufferbuilder_numeric_test.go  |  4 +--
 go/arrow/array/builder.go                     |  8 ++---
 go/arrow/array/builder_test.go                |  4 +--
 go/arrow/array/compare.go                     |  6 ++--
 go/arrow/array/compare_test.go                | 10 +++---
 go/arrow/array/concat.go                      | 14 ++++----
 go/arrow/array/concat_test.go                 | 10 +++---
 go/arrow/array/data.go                        |  6 ++--
 go/arrow/array/data_test.go                   |  4 +--
 go/arrow/array/decimal128.go                  | 12 +++----
 go/arrow/array/decimal128_test.go             |  8 ++---
 go/arrow/array/decimal256.go                  | 12 +++----
 go/arrow/array/decimal256_test.go             |  8 ++---
 go/arrow/array/decimal_test.go                | 12 +++----
 go/arrow/array/dictionary.go                  | 20 ++++++------
 go/arrow/array/dictionary_test.go             | 14 ++++----
 go/arrow/array/diff.go                        |  2 +-
 go/arrow/array/diff_test.go                   | 10 +++---
 go/arrow/array/encoded.go                     | 12 +++----
 go/arrow/array/encoded_test.go                |  8 ++---
 go/arrow/array/extension.go                   |  6 ++--
 go/arrow/array/extension_test.go              |  8 ++---
 go/arrow/array/fixed_size_list.go             | 10 +++---
 go/arrow/array/fixed_size_list_test.go        |  6 ++--
 go/arrow/array/fixedsize_binary.go            |  4 +--
 go/arrow/array/fixedsize_binary_test.go       |  6 ++--
 go/arrow/array/fixedsize_binarybuilder.go     |  8 ++---
 .../array/fixedsize_binarybuilder_test.go     |  4 +--
 go/arrow/array/float16.go                     |  6 ++--
 go/arrow/array/float16_builder.go             | 12 +++----
 go/arrow/array/float16_builder_test.go        |  6 ++--
 go/arrow/array/interval.go                    | 10 +++---
 go/arrow/array/interval_test.go               |  6 ++--
 go/arrow/array/json_reader.go                 |  8 ++---
 go/arrow/array/json_reader_test.go            |  6 ++--
 go/arrow/array/list.go                        | 10 +++---
 go/arrow/array/list_test.go                   |  6 ++--
 go/arrow/array/map.go                         |  6 ++--
 go/arrow/array/map_test.go                    |  6 ++--
 go/arrow/array/null.go                        |  8 ++---
 go/arrow/array/null_test.go                   |  6 ++--
 go/arrow/array/numeric.gen.go                 |  4 +--
 go/arrow/array/numeric.gen.go.tmpl            |  4 +--
 go/arrow/array/numeric_test.go                |  8 ++---
 go/arrow/array/numericbuilder.gen.go          | 10 +++---
 go/arrow/array/numericbuilder.gen.go.tmpl     | 10 +++---
 go/arrow/array/numericbuilder.gen_test.go     |  6 ++--
 .../array/numericbuilder.gen_test.go.tmpl     |  6 ++--
 go/arrow/array/record.go                      |  8 ++---
 go/arrow/array/record_test.go                 |  6 ++--
 go/arrow/array/string.go                      |  6 ++--
 go/arrow/array/string_test.go                 |  8 ++---
 go/arrow/array/struct.go                      | 10 +++---
 go/arrow/array/struct_test.go                 |  6 ++--
 go/arrow/array/table.go                       |  4 +--
 go/arrow/array/table_test.go                  |  6 ++--
 go/arrow/array/timestamp.go                   | 10 +++---
 go/arrow/array/timestamp_test.go              |  6 ++--
 go/arrow/array/union.go                       | 12 +++----
 go/arrow/array/union_test.go                  |  6 ++--
 go/arrow/array/util.go                        | 10 +++---
 go/arrow/array/util_test.go                   | 14 ++++----
 go/arrow/arrio/arrio.go                       |  2 +-
 go/arrow/arrio/arrio_test.go                  | 10 +++---
 go/arrow/bitutil/bitmaps.go                   |  6 ++--
 go/arrow/bitutil/bitmaps_test.go              |  4 +--
 go/arrow/bitutil/bitutil.go                   |  2 +-
 go/arrow/bitutil/bitutil_test.go              |  4 +--
 go/arrow/cdata/cdata.go                       |  8 ++---
 go/arrow/cdata/cdata_exports.go               | 10 +++---
 go/arrow/cdata/cdata_test.go                  | 12 +++----
 go/arrow/cdata/cdata_test_framework.go        |  8 ++---
 go/arrow/cdata/exports.go                     |  4 +--
 go/arrow/cdata/import_allocator.go            |  2 +-
 go/arrow/cdata/interface.go                   |  8 ++---
 go/arrow/cdata/test/test_cimport.go           |  8 ++---
 go/arrow/compute/arithmetic.go                | 12 +++----
 go/arrow/compute/arithmetic_test.go           | 20 ++++++------
 go/arrow/compute/cast.go                      | 10 +++---
 go/arrow/compute/cast_test.go                 | 20 ++++++------
 go/arrow/compute/datum.go                     |  6 ++--
 go/arrow/compute/example_test.go              | 10 +++---
 go/arrow/compute/exec.go                      |  6 ++--
 go/arrow/compute/exec/kernel.go               |  8 ++---
 go/arrow/compute/exec/kernel_test.go          | 12 +++----
 go/arrow/compute/exec/span.go                 | 10 +++---
 go/arrow/compute/exec/span_test.go            | 16 +++++-----
 go/arrow/compute/exec/utils.go                | 14 ++++----
 go/arrow/compute/exec/utils_test.go           |  8 ++---
 go/arrow/compute/exec_internals_test.go       | 14 ++++----
 go/arrow/compute/exec_test.go                 | 12 +++----
 go/arrow/compute/executor.go                  | 16 +++++-----
 go/arrow/compute/expression.go                | 16 +++++-----
 go/arrow/compute/expression_test.go           | 10 +++---
 go/arrow/compute/exprs/builders.go            |  4 +--
 go/arrow/compute/exprs/builders_test.go       |  4 +--
 go/arrow/compute/exprs/exec.go                | 18 +++++------
 go/arrow/compute/exprs/exec_internal_test.go  |  8 ++---
 go/arrow/compute/exprs/exec_test.go           | 12 +++----
 go/arrow/compute/exprs/extension_types.go     |  4 +--
 go/arrow/compute/exprs/field_refs.go          | 10 +++---
 go/arrow/compute/exprs/types.go               |  4 +--
 go/arrow/compute/fieldref.go                  |  4 +--
 go/arrow/compute/fieldref_test.go             |  8 ++---
 go/arrow/compute/functions.go                 |  4 +--
 go/arrow/compute/functions_test.go            |  4 +--
 .../internal/kernels/base_arithmetic.go       | 10 +++---
 .../internal/kernels/base_arithmetic_amd64.go |  4 +--
 .../kernels/base_arithmetic_avx2_amd64.go     |  2 +-
 .../kernels/base_arithmetic_sse4_amd64.go     |  2 +-
 .../kernels/basic_arithmetic_noasm.go         |  2 +-
 .../compute/internal/kernels/boolean_cast.go  |  6 ++--
 go/arrow/compute/internal/kernels/cast.go     |  6 ++--
 .../compute/internal/kernels/cast_numeric.go  |  2 +-
 .../kernels/cast_numeric_avx2_amd64.go        |  2 +-
 .../kernels/cast_numeric_neon_arm64.go        |  2 +-
 .../kernels/cast_numeric_sse4_amd64.go        |  2 +-
 .../compute/internal/kernels/cast_temporal.go |  8 ++---
 go/arrow/compute/internal/kernels/helpers.go  | 14 ++++----
 .../compute/internal/kernels/numeric_cast.go  | 14 ++++----
 go/arrow/compute/internal/kernels/rounding.go | 10 +++---
 .../internal/kernels/scalar_arithmetic.go     | 14 ++++----
 .../internal/kernels/scalar_boolean.go        |  6 ++--
 .../kernels/scalar_comparison_amd64.go        |  4 +--
 .../kernels/scalar_comparison_avx2_amd64.go   |  2 +-
 .../kernels/scalar_comparison_noasm.go        |  2 +-
 .../kernels/scalar_comparison_sse4_amd64.go   |  2 +-
 .../internal/kernels/scalar_comparisons.go    | 16 +++++-----
 .../compute/internal/kernels/string_casts.go  | 12 +++----
 go/arrow/compute/internal/kernels/types.go    |  8 ++---
 .../compute/internal/kernels/vector_hash.go   | 14 ++++----
 .../internal/kernels/vector_run_end_encode.go | 16 +++++-----
 .../internal/kernels/vector_selection.go      | 14 ++++----
 go/arrow/compute/registry.go                  |  2 +-
 go/arrow/compute/registry_test.go             |  6 ++--
 go/arrow/compute/scalar_bool.go               |  6 ++--
 go/arrow/compute/scalar_bool_test.go          | 10 +++---
 go/arrow/compute/scalar_compare.go            |  6 ++--
 go/arrow/compute/scalar_compare_test.go       | 18 +++++------
 go/arrow/compute/selection.go                 |  8 ++---
 go/arrow/compute/utils.go                     | 12 +++----
 go/arrow/compute/vector_hash.go               |  4 +--
 go/arrow/compute/vector_hash_test.go          | 14 ++++----
 go/arrow/compute/vector_run_end_test.go       | 14 ++++----
 go/arrow/compute/vector_run_ends.go           |  4 +--
 go/arrow/compute/vector_selection_test.go     | 18 +++++------
 go/arrow/csv/common.go                        |  4 +--
 go/arrow/csv/reader.go                        | 14 ++++----
 go/arrow/csv/reader_test.go                   | 14 ++++----
 go/arrow/csv/transformer.go                   |  4 +--
 go/arrow/csv/writer.go                        |  2 +-
 go/arrow/csv/writer_test.go                   | 16 +++++-----
 go/arrow/datatype.go                          |  2 +-
 go/arrow/datatype_binary_test.go              |  2 +-
 go/arrow/datatype_extension_test.go           |  4 +--
 go/arrow/datatype_fixedwidth.go               |  2 +-
 go/arrow/datatype_fixedwidth_test.go          |  2 +-
 go/arrow/datatype_nested.go                   |  2 +-
 go/arrow/datatype_null_test.go                |  2 +-
 go/arrow/decimal128/decimal128.go             |  2 +-
 go/arrow/decimal128/decimal128_test.go        |  2 +-
 go/arrow/decimal256/decimal256.go             |  4 +--
 go/arrow/decimal256/decimal256_test.go        |  2 +-
 go/arrow/doc.go                               |  2 +-
 go/arrow/encoded/ree_utils.go                 |  2 +-
 go/arrow/encoded/ree_utils_test.go            |  8 ++---
 go/arrow/endian/endian.go                     |  4 +--
 go/arrow/example_test.go                      |  8 ++---
 go/arrow/flight/basic_auth_flight_test.go     |  2 +-
 go/arrow/flight/client.go                     |  2 +-
 go/arrow/flight/cookie_middleware_test.go     |  2 +-
 go/arrow/flight/example_flight_server_test.go |  2 +-
 go/arrow/flight/flight_middleware_test.go     |  4 +--
 go/arrow/flight/flight_test.go                | 10 +++---
 go/arrow/flight/flightsql/client.go           | 12 +++----
 go/arrow/flight/flightsql/client_test.go      | 12 +++----
 go/arrow/flight/flightsql/column_metadata.go  |  2 +-
 go/arrow/flight/flightsql/driver/README.md    |  6 ++--
 .../flight/flightsql/driver/config_test.go    |  2 +-
 go/arrow/flight/flightsql/driver/driver.go    | 10 +++---
 .../flight/flightsql/driver/driver_test.go    | 14 ++++----
 go/arrow/flight/flightsql/driver/utils.go     |  4 +--
 .../flight/flightsql/driver/utils_test.go     | 12 +++----
 .../cmd/sqlite_flightsql_server/main.go       |  6 ++--
 .../flightsql/example/sql_batch_reader.go     | 10 +++---
 .../flight/flightsql/example/sqlite_info.go   |  4 +--
 .../flight/flightsql/example/sqlite_server.go | 14 ++++----
 .../sqlite_tables_schema_batch_reader.go      | 12 +++----
 .../flight/flightsql/example/type_info.go     |  8 ++---
 .../flightsql/schema_ref/reference_schemas.go |  2 +-
 go/arrow/flight/flightsql/server.go           | 16 +++++-----
 go/arrow/flight/flightsql/server_test.go      | 12 +++----
 go/arrow/flight/flightsql/sql_info.go         |  4 +--
 .../flight/flightsql/sqlite_server_test.go    | 16 +++++-----
 go/arrow/flight/flightsql/types.go            |  2 +-
 go/arrow/flight/record_batch_reader.go        | 12 +++----
 go/arrow/flight/record_batch_writer.go        |  6 ++--
 go/arrow/flight/server.go                     |  2 +-
 go/arrow/flight/server_example_test.go        |  2 +-
 go/arrow/internal/arrdata/arrdata.go          | 16 +++++-----
 go/arrow/internal/arrdata/ioutil.go           | 10 +++---
 go/arrow/internal/arrjson/arrjson.go          | 20 ++++++------
 go/arrow/internal/arrjson/arrjson_test.go     |  6 ++--
 go/arrow/internal/arrjson/option.go           |  4 +--
 go/arrow/internal/arrjson/reader.go           | 10 +++---
 go/arrow/internal/arrjson/writer.go           | 10 +++---
 .../internal/cdata_integration/entrypoints.go |  8 ++---
 go/arrow/internal/dictutils/dict.go           |  6 ++--
 go/arrow/internal/dictutils/dict_test.go      |  8 ++---
 .../arrow-flight-integration-client/main.go   |  2 +-
 .../arrow-flight-integration-server/main.go   |  2 +-
 .../internal/flight_integration/scenario.go   | 18 +++++------
 .../internal/testing/gen/random_array_gen.go  | 10 +++---
 go/arrow/internal/testing/tools/bits_test.go  |  2 +-
 go/arrow/internal/testing/tools/data_types.go |  4 +--
 go/arrow/internal/utils.go                    |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main.go            |  4 +--
 go/arrow/ipc/cmd/arrow-cat/main_test.go       |  8 ++---
 go/arrow/ipc/cmd/arrow-file-to-stream/main.go |  6 ++--
 .../ipc/cmd/arrow-file-to-stream/main_test.go |  4 +--
 .../cmd/arrow-json-integration-test/main.go   | 12 +++----
 .../arrow-json-integration-test/main_test.go  |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main.go             |  4 +--
 go/arrow/ipc/cmd/arrow-ls/main_test.go        |  8 ++---
 go/arrow/ipc/cmd/arrow-stream-to-file/main.go |  6 ++--
 .../ipc/cmd/arrow-stream-to-file/main_test.go |  4 +--
 go/arrow/ipc/compression.go                   |  6 ++--
 go/arrow/ipc/endian_swap.go                   |  6 ++--
 go/arrow/ipc/endian_swap_test.go              | 10 +++---
 go/arrow/ipc/file_reader.go                   | 16 +++++-----
 go/arrow/ipc/file_test.go                     |  6 ++--
 go/arrow/ipc/file_writer.go                   | 10 +++---
 go/arrow/ipc/ipc.go                           |  8 ++---
 go/arrow/ipc/ipc_test.go                      |  8 ++---
 go/arrow/ipc/message.go                       |  6 ++--
 go/arrow/ipc/message_test.go                  |  6 ++--
 go/arrow/ipc/metadata.go                      | 10 +++---
 go/arrow/ipc/metadata_test.go                 | 12 +++----
 go/arrow/ipc/reader.go                        | 14 ++++----
 go/arrow/ipc/reader_test.go                   |  6 ++--
 go/arrow/ipc/stream_test.go                   |  6 ++--
 go/arrow/ipc/writer.go                        | 16 +++++-----
 go/arrow/ipc/writer_test.go                   | 10 +++---
 go/arrow/math/float64.go                      |  2 +-
 go/arrow/math/float64_avx2_amd64.go           |  2 +-
 go/arrow/math/float64_neon_arm64.go           |  2 +-
 go/arrow/math/float64_sse4_amd64.go           |  2 +-
 go/arrow/math/float64_test.go                 |  6 ++--
 go/arrow/math/int64.go                        |  2 +-
 go/arrow/math/int64_avx2_amd64.go             |  2 +-
 go/arrow/math/int64_neon_arm64.go             |  2 +-
 go/arrow/math/int64_sse4_amd64.go             |  2 +-
 go/arrow/math/int64_test.go                   |  6 ++--
 go/arrow/math/type.go.tmpl                    |  2 +-
 go/arrow/math/type_simd_amd64.go.tmpl         |  2 +-
 go/arrow/math/type_simd_arm64.go.tmpl         |  2 +-
 go/arrow/math/type_test.go.tmpl               |  6 ++--
 go/arrow/math/uint64.go                       |  2 +-
 go/arrow/math/uint64_avx2_amd64.go            |  2 +-
 go/arrow/math/uint64_neon_arm64.go            |  2 +-
 go/arrow/math/uint64_sse4_amd64.go            |  2 +-
 go/arrow/math/uint64_test.go                  |  6 ++--
 go/arrow/memory/buffer.go                     |  2 +-
 go/arrow/memory/buffer_test.go                |  2 +-
 go/arrow/memory/cgo_allocator.go              |  2 +-
 go/arrow/memory/default_mallocator.go         |  2 +-
 go/arrow/memory/default_mallocator_test.go    |  4 +--
 go/arrow/memory/mallocator/mallocator_test.go |  2 +-
 go/arrow/memory/memory_test.go                |  2 +-
 go/arrow/record.go                            |  2 +-
 go/arrow/scalar/append.go                     | 10 +++---
 go/arrow/scalar/append_test.go                | 10 +++---
 go/arrow/scalar/binary.go                     |  4 +--
 go/arrow/scalar/compare.go                    |  2 +-
 go/arrow/scalar/nested.go                     |  8 ++---
 go/arrow/scalar/numeric.gen.go                |  6 ++--
 go/arrow/scalar/numeric.gen_test.go           |  4 +--
 go/arrow/scalar/numeric.gen_test.go.tmpl      |  4 +--
 go/arrow/scalar/parse.go                      | 12 +++----
 go/arrow/scalar/scalar.go                     | 20 ++++++------
 go/arrow/scalar/scalar_test.go                | 12 +++----
 go/arrow/scalar/temporal.go                   |  2 +-
 go/arrow/schema.go                            |  2 +-
 go/arrow/schema_test.go                       |  2 +-
 go/arrow/table.go                             |  2 +-
 go/arrow/tensor/numeric.gen.go                |  2 +-
 go/arrow/tensor/numeric.gen.go.tmpl           |  4 +--
 go/arrow/tensor/numeric.gen_test.go           |  8 ++---
 go/arrow/tensor/numeric.gen_test.go.tmpl      |  8 ++---
 go/arrow/tensor/tensor.go                     |  4 +--
 go/arrow/tensor/tensor_test.go                |  8 ++---
 go/arrow/type_traits_boolean.go               |  2 +-
 go/arrow/type_traits_decimal128.go            |  4 +--
 go/arrow/type_traits_decimal256.go            |  4 +--
 go/arrow/type_traits_float16.go               |  4 +--
 go/arrow/type_traits_interval.go              |  4 +--
 go/arrow/type_traits_numeric.gen.go           |  2 +-
 go/arrow/type_traits_numeric.gen.go.tmpl      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go      |  2 +-
 go/arrow/type_traits_numeric.gen_test.go.tmpl |  2 +-
 go/arrow/type_traits_test.go                  |  8 ++---
 go/arrow/type_traits_timestamp.go             |  2 +-
 go/arrow/util/byte_size.go                    |  6 ++--
 go/arrow/util/byte_size_test.go               |  8 ++---
 go/go.mod                                     |  2 +-
 go/internal/bitutils/bit_block_counter.go     |  4 +--
 .../bitutils/bit_block_counter_test.go        |  6 ++--
 go/internal/bitutils/bit_run_reader.go        |  6 ++--
 go/internal/bitutils/bit_run_reader_test.go   |  6 ++--
 go/internal/bitutils/bit_set_run_reader.go    |  4 +--
 .../bitutils/bit_set_run_reader_test.go       |  6 ++--
 go/internal/bitutils/bitmap_generate.go       |  2 +-
 go/internal/bitutils/bitmap_generate_test.go  |  2 +-
 go/internal/hashing/xxh3_memo_table.gen.go    |  6 ++--
 .../hashing/xxh3_memo_table.gen.go.tmpl       |  4 +--
 go/internal/types/extension_types.go          |  6 ++--
 go/internal/types/extension_types_test.go     | 10 +++---
 go/internal/utils/transpose_ints_def.go       |  2 +-
 go/internal/utils/transpose_ints_test.go      |  2 +-
 go/parquet/cmd/parquet_reader/dumper.go       |  6 ++--
 go/parquet/cmd/parquet_reader/main.go         | 10 +++---
 go/parquet/cmd/parquet_schema/main.go         |  4 +--
 go/parquet/compress/brotli.go                 |  2 +-
 go/parquet/compress/compress.go               |  2 +-
 go/parquet/compress/compress_test.go          |  2 +-
 go/parquet/compress/zstd.go                   |  2 +-
 go/parquet/doc.go                             |  6 ++--
 go/parquet/encryption_properties.go           |  2 +-
 go/parquet/encryption_properties_test.go      |  4 +--
 go/parquet/encryption_read_config_test.go     |  8 ++---
 go/parquet/encryption_write_config_test.go    |  8 ++---
 go/parquet/file/column_reader.go              | 14 ++++----
 go/parquet/file/column_reader_test.go         | 12 +++----
 go/parquet/file/column_reader_types.gen.go    |  6 ++--
 .../file/column_reader_types.gen.go.tmpl      |  4 +--
 go/parquet/file/column_writer.go              | 16 +++++-----
 go/parquet/file/column_writer_test.go         | 26 +++++++--------
 go/parquet/file/column_writer_types.gen.go    | 12 +++----
 .../file/column_writer_types.gen.go.tmpl      |  8 ++---
 go/parquet/file/file_reader.go                |  8 ++---
 go/parquet/file/file_reader_mmap.go           |  2 +-
 go/parquet/file/file_reader_mmap_windows.go   |  2 +-
 go/parquet/file/file_reader_test.go           | 20 ++++++------
 go/parquet/file/file_writer.go                | 10 +++---
 go/parquet/file/file_writer_test.go           | 14 ++++----
 go/parquet/file/level_conversion.go           | 10 +++---
 go/parquet/file/level_conversion_test.go      |  6 ++--
 go/parquet/file/page_reader.go                | 14 ++++----
 go/parquet/file/page_writer.go                | 18 +++++------
 go/parquet/file/record_reader.go              | 16 +++++-----
 go/parquet/file/row_group_reader.go           |  8 ++---
 go/parquet/file/row_group_writer.go           |  8 ++---
 go/parquet/file/row_group_writer_test.go      |  8 ++---
 go/parquet/internal/bmi/bmi_test.go           |  2 +-
 .../internal/encoding/boolean_decoder.go      |  8 ++---
 .../internal/encoding/boolean_encoder.go      |  8 ++---
 .../internal/encoding/byte_array_decoder.go   | 12 +++----
 .../internal/encoding/byte_array_encoder.go   | 10 +++---
 go/parquet/internal/encoding/decoder.go       | 20 ++++++------
 .../internal/encoding/delta_bit_packing.go    | 10 +++---
 .../internal/encoding/delta_byte_array.go     |  6 ++--
 .../encoding/delta_byte_array_test.go         |  4 +--
 .../encoding/delta_length_byte_array.go       |  6 ++--
 go/parquet/internal/encoding/encoder.go       | 16 +++++-----
 .../encoding/encoding_benchmarks_test.go      | 16 +++++-----
 go/parquet/internal/encoding/encoding_test.go | 14 ++++----
 .../encoding/fixed_len_byte_array_decoder.go  |  4 +--
 .../encoding/fixed_len_byte_array_encoder.go  |  6 ++--
 go/parquet/internal/encoding/levels.go        | 10 +++---
 go/parquet/internal/encoding/levels_test.go   | 10 +++---
 go/parquet/internal/encoding/memo_table.go    | 10 +++---
 .../internal/encoding/memo_table_test.go      | 10 +++---
 .../internal/encoding/memo_table_types.gen.go |  4 +--
 .../encoding/memo_table_types.gen.go.tmpl     |  2 +-
 .../encoding/plain_encoder_types.gen.go       | 10 +++---
 .../encoding/plain_encoder_types.gen.go.tmpl  |  8 ++---
 .../internal/encoding/typed_encoder.gen.go    | 18 +++++------
 .../encoding/typed_encoder.gen.go.tmpl        | 14 ++++----
 go/parquet/internal/encoding/types.go         | 10 +++---
 go/parquet/internal/encryption/aes.go         |  2 +-
 go/parquet/internal/encryption/decryptor.go   |  4 +--
 go/parquet/internal/encryption/encryptor.go   |  4 +--
 go/parquet/internal/testutils/pagebuilder.go  | 14 ++++----
 .../internal/testutils/primitive_typed.go     | 10 +++---
 go/parquet/internal/testutils/random.go       | 14 ++++----
 go/parquet/internal/testutils/random_arrow.go |  6 ++--
 go/parquet/internal/testutils/utils.go        |  2 +-
 go/parquet/internal/thrift/helpers.go         |  2 +-
 .../internal/utils/bit_benchmark_test.go      |  6 ++--
 .../internal/utils/bit_packing_arm64.go       |  2 +-
 go/parquet/internal/utils/bit_reader.go       |  8 ++---
 go/parquet/internal/utils/bit_reader_test.go  | 10 +++---
 go/parquet/internal/utils/bit_writer.go       |  2 +-
 go/parquet/internal/utils/bitmap_writer.go    |  2 +-
 .../internal/utils/bitmap_writer_test.go      |  4 +--
 go/parquet/internal/utils/rle.go              |  8 ++---
 .../internal/utils/typed_rle_dict.gen.go      |  6 ++--
 .../internal/utils/typed_rle_dict.gen.go.tmpl |  6 ++--
 go/parquet/metadata/app_version.go            |  4 +--
 go/parquet/metadata/column_chunk.go           | 14 ++++----
 go/parquet/metadata/file.go                   | 12 +++----
 go/parquet/metadata/metadata_test.go          |  6 ++--
 go/parquet/metadata/row_group.go              |  8 ++---
 go/parquet/metadata/stat_compare_test.go      |  4 +--
 go/parquet/metadata/statistics.go             | 16 +++++-----
 go/parquet/metadata/statistics_test.go        | 10 +++---
 go/parquet/metadata/statistics_types.gen.go   | 16 +++++-----
 .../metadata/statistics_types.gen.go.tmpl     | 14 ++++----
 go/parquet/pqarrow/column_readers.go          | 20 ++++++------
 go/parquet/pqarrow/encode_arrow.go            | 20 ++++++------
 go/parquet/pqarrow/encode_arrow_test.go       | 32 +++++++++----------
 go/parquet/pqarrow/encode_dict_compute.go     | 16 +++++-----
 go/parquet/pqarrow/encode_dict_nocompute.go   |  4 +--
 go/parquet/pqarrow/encode_dictionary_test.go  | 16 +++++-----
 go/parquet/pqarrow/file_reader.go             | 14 ++++----
 go/parquet/pqarrow/file_reader_test.go        | 14 ++++----
 go/parquet/pqarrow/file_writer.go             | 12 +++----
 go/parquet/pqarrow/helpers.go                 |  2 +-
 go/parquet/pqarrow/path_builder.go            | 10 +++---
 go/parquet/pqarrow/path_builder_test.go       |  8 ++---
 go/parquet/pqarrow/properties.go              |  6 ++--
 go/parquet/pqarrow/reader_writer_test.go      | 12 +++----
 go/parquet/pqarrow/schema.go                  | 18 +++++------
 go/parquet/pqarrow/schema_test.go             | 18 +++++------
 go/parquet/reader_properties.go               |  4 +--
 go/parquet/reader_writer_properties_test.go   |  6 ++--
 go/parquet/schema/column.go                   |  4 +--
 go/parquet/schema/converted_types.go          |  2 +-
 go/parquet/schema/converted_types_test.go     |  2 +-
 go/parquet/schema/helpers.go                  |  2 +-
 go/parquet/schema/helpers_test.go             |  4 +--
 go/parquet/schema/logical_types.go            |  8 ++---
 go/parquet/schema/logical_types_test.go       |  6 ++--
 go/parquet/schema/node.go                     |  4 +--
 go/parquet/schema/reflection.go               |  4 +--
 go/parquet/schema/reflection_test.go          |  4 +--
 go/parquet/schema/schema.go                   |  4 +--
 go/parquet/schema/schema_element_test.go      |  4 +--
 go/parquet/schema/schema_flatten_test.go      |  4 +--
 go/parquet/schema/schema_test.go              |  6 ++--
 go/parquet/types.go                           |  4 +--
 go/parquet/writer_properties.go               |  6 ++--
 java/adapter/avro/pom.xml                     |  2 +-
 java/adapter/jdbc/pom.xml                     |  2 +-
 java/adapter/orc/pom.xml                      |  2 +-
 java/algorithm/pom.xml                        |  2 +-
 java/bom/pom.xml                              |  2 +-
 java/c/pom.xml                                |  2 +-
 java/compression/pom.xml                      |  2 +-
 java/dataset/pom.xml                          |  2 +-
 java/flight/flight-core/pom.xml               |  2 +-
 java/flight/flight-grpc/pom.xml               |  2 +-
 java/flight/flight-integration-tests/pom.xml  |  2 +-
 java/flight/flight-sql-jdbc-core/pom.xml      |  2 +-
 java/flight/flight-sql-jdbc-driver/pom.xml    |  2 +-
 java/flight/flight-sql/pom.xml                |  2 +-
 java/flight/pom.xml                           |  2 +-
 java/format/pom.xml                           |  2 +-
 java/gandiva/pom.xml                          |  2 +-
 java/memory/memory-core/pom.xml               |  2 +-
 java/memory/memory-netty/pom.xml              |  2 +-
 java/memory/memory-unsafe/pom.xml             |  2 +-
 java/memory/pom.xml                           |  2 +-
 java/performance/pom.xml                      |  2 +-
 java/pom.xml                                  |  2 +-
 java/tools/pom.xml                            |  2 +-
 java/vector/pom.xml                           |  2 +-
 js/package.json                               |  2 +-
 matlab/CMakeLists.txt                         |  2 +-
 python/CMakeLists.txt                         |  2 +-
 python/setup.py                               |  2 +-
 r/NEWS.md                                     |  2 --
 ruby/red-arrow-cuda/lib/arrow-cuda/version.rb |  2 +-
 .../lib/arrow-dataset/version.rb              |  2 +-
 .../lib/arrow-flight-sql/version.rb           |  2 +-
 .../lib/arrow-flight/version.rb               |  2 +-
 ruby/red-arrow/lib/arrow/version.rb           |  2 +-
 ruby/red-gandiva/lib/gandiva/version.rb       |  2 +-
 ruby/red-parquet/lib/parquet/version.rb       |  2 +-
 503 files changed, 1730 insertions(+), 1732 deletions(-)

diff --git a/c_glib/meson.build b/c_glib/meson.build
index 1aba855703828..7c495d2567d72 100644
--- a/c_glib/meson.build
+++ b/c_glib/meson.build
@@ -24,7 +24,7 @@ project('arrow-glib', 'c', 'cpp',
           'cpp_std=c++17',
         ])
 
-version = '14.0.1-SNAPSHOT'
+version = '15.0.0-SNAPSHOT'
 if version.endswith('-SNAPSHOT')
   version_numbers = version.split('-')[0].split('.')
   version_tag = version.split('-')[1]
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index d57fcebb498dc..bcb298407bd8b 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -71,7 +71,7 @@ if(POLICY CMP0135)
   cmake_policy(SET CMP0135 NEW)
 endif()
 
-set(ARROW_VERSION "14.0.1-SNAPSHOT")
+set(ARROW_VERSION "15.0.0-SNAPSHOT")
 
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" ARROW_BASE_VERSION "${ARROW_VERSION}")
 
diff --git a/cpp/vcpkg.json b/cpp/vcpkg.json
index d1508658b8165..c0bf5dce50e32 100644
--- a/cpp/vcpkg.json
+++ b/cpp/vcpkg.json
@@ -1,6 +1,6 @@
 {
   "name": "arrow",
-  "version-string": "14.0.1-SNAPSHOT",
+  "version-string": "15.0.0-SNAPSHOT",
   "dependencies": [
     "abseil",
     {
diff --git a/csharp/Directory.Build.props b/csharp/Directory.Build.props
index 1047272ffd448..ae6edda0e2f0e 100644
--- a/csharp/Directory.Build.props
+++ b/csharp/Directory.Build.props
@@ -29,7 +29,7 @@
     <Product>Apache Arrow library</Product>
     <Copyright>Copyright 2016-2019 The Apache Software Foundation</Copyright>
     <Company>The Apache Software Foundation</Company>
-    <Version>14.0.1-SNAPSHOT</Version>
+    <Version>15.0.0-SNAPSHOT</Version>
   </PropertyGroup>
 
   <PropertyGroup>
diff --git a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
index e9fca5bc74216..e29354def4c1c 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow-glib.rb
@@ -29,7 +29,7 @@
 class ApacheArrowGlib < Formula
   desc "GLib bindings for Apache Arrow"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.1-SNAPSHOT/apache-arrow-14.0.1-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/dev/tasks/homebrew-formulae/apache-arrow.rb b/dev/tasks/homebrew-formulae/apache-arrow.rb
index ff7e54ba64bc0..14d229b477dc8 100644
--- a/dev/tasks/homebrew-formulae/apache-arrow.rb
+++ b/dev/tasks/homebrew-formulae/apache-arrow.rb
@@ -29,7 +29,7 @@
 class ApacheArrow < Formula
   desc "Columnar in-memory analytics layer designed to accelerate big data"
   homepage "https://arrow.apache.org/"
-  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-14.0.1-SNAPSHOT/apache-arrow-14.0.1-SNAPSHOT.tar.gz"
+  url "https://www.apache.org/dyn/closer.lua?path=arrow/arrow-15.0.0-SNAPSHOT/apache-arrow-15.0.0-SNAPSHOT.tar.gz"
   sha256 "9948ddb6d4798b51552d0dca3252dd6e3a7d0f9702714fc6f5a1b59397ce1d28"
   license "Apache-2.0"
   head "https://github.com/apache/arrow.git", branch: "main"
diff --git a/go/README.md b/go/README.md
index 660549cb1b366..c45bcd756f81c 100644
--- a/go/README.md
+++ b/go/README.md
@@ -20,7 +20,7 @@
 Apache Arrow for Go
 ===================
 
-[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v14.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v14)
+[![Go Reference](https://pkg.go.dev/badge/github.com/apache/arrow/go/v15.svg)](https://pkg.go.dev/github.com/apache/arrow/go/v15)
 
 [Apache Arrow][arrow] is a cross-language development platform for in-memory
 data. It specifies a standardized language-independent columnar memory format
diff --git a/go/arrow/_examples/helloworld/main.go b/go/arrow/_examples/helloworld/main.go
index 02601be694400..156a52b86da1c 100644
--- a/go/arrow/_examples/helloworld/main.go
+++ b/go/arrow/_examples/helloworld/main.go
@@ -19,10 +19,10 @@ package main
 import (
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/_tools/tmpl/main.go b/go/arrow/_tools/tmpl/main.go
index 87c4b6ed02c12..c591c3b96803c 100644
--- a/go/arrow/_tools/tmpl/main.go
+++ b/go/arrow/_tools/tmpl/main.go
@@ -28,7 +28,7 @@ import (
 	"strings"
 	"text/template"
 
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const Ext = ".tmpl"
diff --git a/go/arrow/array.go b/go/arrow/array.go
index 7622e7503e0b6..e07fa478aae57 100644
--- a/go/arrow/array.go
+++ b/go/arrow/array.go
@@ -19,8 +19,8 @@ package arrow
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // ArrayData is the underlying memory and metadata of an Arrow array, corresponding
diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index 1ee04c7aa2bcc..bbe301ee661f3 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/array/array_test.go b/go/arrow/array/array_test.go
index 6139548ddec7d..bbfbee83585da 100644
--- a/go/arrow/array/array_test.go
+++ b/go/arrow/array/array_test.go
@@ -19,11 +19,11 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binary.go b/go/arrow/array/binary.go
index e9e6e66e7e813..bf27139fddbaa 100644
--- a/go/arrow/array/binary.go
+++ b/go/arrow/array/binary.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type BinaryLike interface {
diff --git a/go/arrow/array/binary_test.go b/go/arrow/array/binary_test.go
index 5febb55691d7d..9c1770950a8b5 100644
--- a/go/arrow/array/binary_test.go
+++ b/go/arrow/array/binary_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/binarybuilder.go b/go/arrow/array/binarybuilder.go
index 3cb709b45b7a1..a51bc799e4965 100644
--- a/go/arrow/array/binarybuilder.go
+++ b/go/arrow/array/binarybuilder.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A BinaryBuilder is used to build a Binary array using the Append methods.
diff --git a/go/arrow/array/binarybuilder_test.go b/go/arrow/array/binarybuilder_test.go
index c63307433bcca..96be73da6516d 100644
--- a/go/arrow/array/binarybuilder_test.go
+++ b/go/arrow/array/binarybuilder_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/boolean.go b/go/arrow/array/boolean.go
index 464cef48bdf32..43bac64a4c990 100644
--- a/go/arrow/array/boolean.go
+++ b/go/arrow/array/boolean.go
@@ -21,10 +21,10 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of boolean values.
diff --git a/go/arrow/array/boolean_test.go b/go/arrow/array/boolean_test.go
index c49ec08624cc6..bcd17ee5967d6 100644
--- a/go/arrow/array/boolean_test.go
+++ b/go/arrow/array/boolean_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/booleanbuilder.go b/go/arrow/array/booleanbuilder.go
index 10b7405aa5b2a..cd0cffd5e43e2 100644
--- a/go/arrow/array/booleanbuilder.go
+++ b/go/arrow/array/booleanbuilder.go
@@ -23,11 +23,11 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type BooleanBuilder struct {
diff --git a/go/arrow/array/booleanbuilder_test.go b/go/arrow/array/booleanbuilder_test.go
index e270636a87b1c..f6f6c80dab37f 100644
--- a/go/arrow/array/booleanbuilder_test.go
+++ b/go/arrow/array/booleanbuilder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/bufferbuilder.go b/go/arrow/array/bufferbuilder.go
index e023b0d907421..cb381e25b32a2 100644
--- a/go/arrow/array/bufferbuilder.go
+++ b/go/arrow/array/bufferbuilder.go
@@ -19,9 +19,9 @@ package array
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type bufBuilder interface {
diff --git a/go/arrow/array/bufferbuilder_byte.go b/go/arrow/array/bufferbuilder_byte.go
index 00a0d1c21b3ef..9b2b559ba9f68 100644
--- a/go/arrow/array/bufferbuilder_byte.go
+++ b/go/arrow/array/bufferbuilder_byte.go
@@ -16,7 +16,7 @@
 
 package array
 
-import "github.com/apache/arrow/go/v14/arrow/memory"
+import "github.com/apache/arrow/go/v15/arrow/memory"
 
 type byteBufferBuilder struct {
 	bufferBuilder
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go b/go/arrow/array/bufferbuilder_numeric.gen.go
index 879bc9f571152..a7961166c0edd 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go
@@ -19,9 +19,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type int64BufferBuilder struct {
diff --git a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
index e859b5bff02a1..845d7ef01c89a 100644
--- a/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
+++ b/go/arrow/array/bufferbuilder_numeric.gen.go.tmpl
@@ -17,9 +17,9 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/bufferbuilder_numeric_test.go b/go/arrow/array/bufferbuilder_numeric_test.go
index ba0a60e5b703b..b51e9ae9207ea 100644
--- a/go/arrow/array/bufferbuilder_numeric_test.go
+++ b/go/arrow/array/bufferbuilder_numeric_test.go
@@ -20,8 +20,8 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index 2f15ac965e07c..bb15298e03ccf 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const (
diff --git a/go/arrow/array/builder_test.go b/go/arrow/array/builder_test.go
index 3cacb54f725e7..7bec86d86cc8b 100644
--- a/go/arrow/array/builder_test.go
+++ b/go/arrow/array/builder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index e70716bee91a7..778de41e32c67 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 // RecordEqual reports whether the two provided records are equal.
diff --git a/go/arrow/array/compare_test.go b/go/arrow/array/compare_test.go
index 51421aa04fe9a..4fc9cf50e8643 100644
--- a/go/arrow/array/compare_test.go
+++ b/go/arrow/array/compare_test.go
@@ -22,11 +22,11 @@ import (
 	"sort"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 9d815023c4b76..53c5be06895b9 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -23,13 +23,13 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // Concatenate creates a new arrow.Array which is the concatenation of the
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index c80844f05bacd..1cc484ad1a923 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/data.go b/go/arrow/array/data.go
index 49df06fb1174a..8cce49182b879 100644
--- a/go/arrow/array/data.go
+++ b/go/arrow/array/data.go
@@ -22,9 +22,9 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Data represents the memory and metadata of an Arrow array.
diff --git a/go/arrow/array/data_test.go b/go/arrow/array/data_test.go
index 2773096995fb6..b7b0f396470d7 100644
--- a/go/arrow/array/data_test.go
+++ b/go/arrow/array/data_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal128.go b/go/arrow/array/decimal128.go
index 3317531687ca4..16a492db09c67 100644
--- a/go/arrow/array/decimal128.go
+++ b/go/arrow/array/decimal128.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of 128-bit decimal values.
diff --git a/go/arrow/array/decimal128_test.go b/go/arrow/array/decimal128_test.go
index 8ef09b68c176a..8c26d00cdc18e 100644
--- a/go/arrow/array/decimal128_test.go
+++ b/go/arrow/array/decimal128_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal256.go b/go/arrow/array/decimal256.go
index d63544f784a09..8f72e414d1959 100644
--- a/go/arrow/array/decimal256.go
+++ b/go/arrow/array/decimal256.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Decimal256 is a type that represents an immutable sequence of 256-bit decimal values.
diff --git a/go/arrow/array/decimal256_test.go b/go/arrow/array/decimal256_test.go
index a02098e79103f..6085d6b5a6a59 100644
--- a/go/arrow/array/decimal256_test.go
+++ b/go/arrow/array/decimal256_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/decimal_test.go b/go/arrow/array/decimal_test.go
index 2203b2702c09a..67900447be1cf 100644
--- a/go/arrow/array/decimal_test.go
+++ b/go/arrow/array/decimal_test.go
@@ -21,12 +21,12 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/dictionary.go b/go/arrow/array/dictionary.go
index d0a1c4dc97e1d..856f91605ff53 100644
--- a/go/arrow/array/dictionary.go
+++ b/go/arrow/array/dictionary.go
@@ -25,16 +25,16 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // Dictionary represents the type for dictionary-encoded data with a data
diff --git a/go/arrow/array/dictionary_test.go b/go/arrow/array/dictionary_test.go
index d0878fa3b0329..5a3e0e10c23f3 100644
--- a/go/arrow/array/dictionary_test.go
+++ b/go/arrow/array/dictionary_test.go
@@ -24,13 +24,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/array/diff.go b/go/arrow/array/diff.go
index 026a27b983f59..6bf6372531fd7 100644
--- a/go/arrow/array/diff.go
+++ b/go/arrow/array/diff.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Edit represents one entry in the edit script to compare two arrays.
diff --git a/go/arrow/array/diff_test.go b/go/arrow/array/diff_test.go
index 0eff8dc4f0577..17539c38d282f 100644
--- a/go/arrow/array/diff_test.go
+++ b/go/arrow/array/diff_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 type diffTestCase struct {
diff --git a/go/arrow/array/encoded.go b/go/arrow/array/encoded.go
index bf4a942cf1c35..fa5fa7addf34c 100644
--- a/go/arrow/array/encoded.go
+++ b/go/arrow/array/encoded.go
@@ -23,12 +23,12 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // RunEndEncoded represents an array containing two children:
diff --git a/go/arrow/array/encoded_test.go b/go/arrow/array/encoded_test.go
index 57c01cf22d2d6..5bfac7a1a96e6 100644
--- a/go/arrow/array/encoded_test.go
+++ b/go/arrow/array/encoded_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/array/extension.go b/go/arrow/array/extension.go
index 03e8c1734b9d6..021b8e7bc451b 100644
--- a/go/arrow/array/extension.go
+++ b/go/arrow/array/extension.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // ExtensionArray is the interface that needs to be implemented to handle
diff --git a/go/arrow/array/extension_test.go b/go/arrow/array/extension_test.go
index 5b473fed428ef..a8e2b0dfd59bb 100644
--- a/go/arrow/array/extension_test.go
+++ b/go/arrow/array/extension_test.go
@@ -19,10 +19,10 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/array/fixed_size_list.go b/go/arrow/array/fixed_size_list.go
index 62c3213861a7d..5923d68590b15 100644
--- a/go/arrow/array/fixed_size_list.go
+++ b/go/arrow/array/fixed_size_list.go
@@ -22,11 +22,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // FixedSizeList represents an immutable sequence of N array values.
diff --git a/go/arrow/array/fixed_size_list_test.go b/go/arrow/array/fixed_size_list_test.go
index 83dff923fe120..5c01199ddf987 100644
--- a/go/arrow/array/fixed_size_list_test.go
+++ b/go/arrow/array/fixed_size_list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/fixedsize_binary.go b/go/arrow/array/fixedsize_binary.go
index 5466156d5a256..6cdaeace939fd 100644
--- a/go/arrow/array/fixedsize_binary.go
+++ b/go/arrow/array/fixedsize_binary.go
@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of fixed-length binary strings.
diff --git a/go/arrow/array/fixedsize_binary_test.go b/go/arrow/array/fixedsize_binary_test.go
index b65c7051a9b3e..785725537cbdd 100644
--- a/go/arrow/array/fixedsize_binary_test.go
+++ b/go/arrow/array/fixedsize_binary_test.go
@@ -21,9 +21,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFixedSizeBinary(t *testing.T) {
diff --git a/go/arrow/array/fixedsize_binarybuilder.go b/go/arrow/array/fixedsize_binarybuilder.go
index ba4b474a89fd0..230a65fd2d352 100644
--- a/go/arrow/array/fixedsize_binarybuilder.go
+++ b/go/arrow/array/fixedsize_binarybuilder.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A FixedSizeBinaryBuilder is used to build a FixedSizeBinary array using the Append methods.
diff --git a/go/arrow/array/fixedsize_binarybuilder_test.go b/go/arrow/array/fixedsize_binarybuilder_test.go
index e3962ad3b9372..8e4a0ac1e46a7 100644
--- a/go/arrow/array/fixedsize_binarybuilder_test.go
+++ b/go/arrow/array/fixedsize_binarybuilder_test.go
@@ -19,8 +19,8 @@ package array
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/float16.go b/go/arrow/array/float16.go
index de499e26706cc..4260f8e3774b4 100644
--- a/go/arrow/array/float16.go
+++ b/go/arrow/array/float16.go
@@ -20,9 +20,9 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of Float16 values.
diff --git a/go/arrow/array/float16_builder.go b/go/arrow/array/float16_builder.go
index f96ab6037e002..033b9fa2d8028 100644
--- a/go/arrow/array/float16_builder.go
+++ b/go/arrow/array/float16_builder.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Float16Builder struct {
diff --git a/go/arrow/array/float16_builder_test.go b/go/arrow/array/float16_builder_test.go
index 6ee028d978fb0..f8c5890179869 100644
--- a/go/arrow/array/float16_builder_test.go
+++ b/go/arrow/array/float16_builder_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/interval.go b/go/arrow/array/interval.go
index ff059c92c8583..2a5529f1c30f7 100644
--- a/go/arrow/array/interval.go
+++ b/go/arrow/array/interval.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 func NewIntervalData(data arrow.ArrayData) arrow.Array {
diff --git a/go/arrow/array/interval_test.go b/go/arrow/array/interval_test.go
index 50a96e4779f03..f83fc52dfa34e 100644
--- a/go/arrow/array/interval_test.go
+++ b/go/arrow/array/interval_test.go
@@ -20,9 +20,9 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/json_reader.go b/go/arrow/array/json_reader.go
index e09717c4199b7..2f05d4b70dd76 100644
--- a/go/arrow/array/json_reader.go
+++ b/go/arrow/array/json_reader.go
@@ -22,10 +22,10 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Option func(config)
diff --git a/go/arrow/array/json_reader_test.go b/go/arrow/array/json_reader_test.go
index 3a095a0d33189..7f12bf211dd04 100644
--- a/go/arrow/array/json_reader_test.go
+++ b/go/arrow/array/json_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/list.go b/go/arrow/array/list.go
index d8d8b8c76165a..f10e2072c43a2 100644
--- a/go/arrow/array/list.go
+++ b/go/arrow/array/list.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type ListLike interface {
diff --git a/go/arrow/array/list_test.go b/go/arrow/array/list_test.go
index bf3555b3f6603..11404b2d8bb95 100644
--- a/go/arrow/array/list_test.go
+++ b/go/arrow/array/list_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/map.go b/go/arrow/array/map.go
index 9945a90ce495e..fe07a68785067 100644
--- a/go/arrow/array/map.go
+++ b/go/arrow/array/map.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Map represents an immutable sequence of Key/Value structs. It is a
diff --git a/go/arrow/array/map_test.go b/go/arrow/array/map_test.go
index 3fe78549ec803..a7ecc032682bc 100644
--- a/go/arrow/array/map_test.go
+++ b/go/arrow/array/map_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/null.go b/go/arrow/array/null.go
index 150a1030eb49d..2735a88a92cb3 100644
--- a/go/arrow/array/null.go
+++ b/go/arrow/array/null.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Null represents an immutable, degenerate array with no physical storage.
diff --git a/go/arrow/array/null_test.go b/go/arrow/array/null_test.go
index e1bf1e0345b84..5d230ec5cec71 100644
--- a/go/arrow/array/null_test.go
+++ b/go/arrow/array/null_test.go
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numeric.gen.go b/go/arrow/array/numeric.gen.go
index a3e1101516aa6..59c9a979768d5 100644
--- a/go/arrow/array/numeric.gen.go
+++ b/go/arrow/array/numeric.gen.go
@@ -23,8 +23,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // A type which represents an immutable sequence of int64 values.
diff --git a/go/arrow/array/numeric.gen.go.tmpl b/go/arrow/array/numeric.gen.go.tmpl
index 34d17fbfc8854..027456009daad 100644
--- a/go/arrow/array/numeric.gen.go.tmpl
+++ b/go/arrow/array/numeric.gen.go.tmpl
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numeric_test.go b/go/arrow/array/numeric_test.go
index 34f59c238cbef..91dd724c8da50 100644
--- a/go/arrow/array/numeric_test.go
+++ b/go/arrow/array/numeric_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen.go b/go/arrow/array/numericbuilder.gen.go
index 7f01180f55957..52b189d6ed453 100644
--- a/go/arrow/array/numericbuilder.gen.go
+++ b/go/arrow/array/numericbuilder.gen.go
@@ -27,11 +27,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Int64Builder struct {
diff --git a/go/arrow/array/numericbuilder.gen.go.tmpl b/go/arrow/array/numericbuilder.gen.go.tmpl
index cf663c031f616..82ac35465d424 100644
--- a/go/arrow/array/numericbuilder.gen.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen.go.tmpl
@@ -17,11 +17,11 @@
 package array
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 {{range .In}}
diff --git a/go/arrow/array/numericbuilder.gen_test.go b/go/arrow/array/numericbuilder.gen_test.go
index b5986775cd995..e1f72773403d8 100644
--- a/go/arrow/array/numericbuilder.gen_test.go
+++ b/go/arrow/array/numericbuilder.gen_test.go
@@ -21,9 +21,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/numericbuilder.gen_test.go.tmpl b/go/arrow/array/numericbuilder.gen_test.go.tmpl
index bc8c993374671..eddd884e2eddf 100644
--- a/go/arrow/array/numericbuilder.gen_test.go.tmpl
+++ b/go/arrow/array/numericbuilder.gen_test.go.tmpl
@@ -19,9 +19,9 @@ package array_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/record.go b/go/arrow/array/record.go
index 0b0fe4c3847fc..d080f726e472d 100644
--- a/go/arrow/array/record.go
+++ b/go/arrow/array/record.go
@@ -22,10 +22,10 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // RecordReader reads a stream of records.
diff --git a/go/arrow/array/record_test.go b/go/arrow/array/record_test.go
index da50a30b646f1..7d438d1f1f81e 100644
--- a/go/arrow/array/record_test.go
+++ b/go/arrow/array/record_test.go
@@ -21,9 +21,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 86e27c970cbe9..9ab7c938ef5d8 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -23,9 +23,9 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // String represents an immutable sequence of variable-length UTF-8 strings.
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index fbc106b098332..d743a3ec7f37f 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/struct.go b/go/arrow/array/struct.go
index 248a25bf6044d..94052953852c2 100644
--- a/go/arrow/array/struct.go
+++ b/go/arrow/array/struct.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Struct represents an ordered sequence of relative types.
diff --git a/go/arrow/array/struct_test.go b/go/arrow/array/struct_test.go
index 86a5b311fcc21..1b0dc5a3e4b19 100644
--- a/go/arrow/array/struct_test.go
+++ b/go/arrow/array/struct_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/table.go b/go/arrow/array/table.go
index 6456992e34973..a987dd057f82c 100644
--- a/go/arrow/array/table.go
+++ b/go/arrow/array/table.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // NewColumnSlice returns a new zero-copy slice of the column with the indicated
diff --git a/go/arrow/array/table_test.go b/go/arrow/array/table_test.go
index 8e22d53963ba4..9535ae6b089bb 100644
--- a/go/arrow/array/table_test.go
+++ b/go/arrow/array/table_test.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestChunked(t *testing.T) {
diff --git a/go/arrow/array/timestamp.go b/go/arrow/array/timestamp.go
index 2928b1fc77ff6..6ffb43e067af0 100644
--- a/go/arrow/array/timestamp.go
+++ b/go/arrow/array/timestamp.go
@@ -24,11 +24,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Timestamp represents an immutable sequence of arrow.Timestamp values.
diff --git a/go/arrow/array/timestamp_test.go b/go/arrow/array/timestamp_test.go
index 1e55364e8da0d..acbad8b586dd4 100644
--- a/go/arrow/array/timestamp_test.go
+++ b/go/arrow/array/timestamp_test.go
@@ -20,9 +20,9 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/array/union.go b/go/arrow/array/union.go
index 869355ac7108a..c0a5050560634 100644
--- a/go/arrow/array/union.go
+++ b/go/arrow/array/union.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 // Union is a convenience interface to encompass both Sparse and Dense
diff --git a/go/arrow/array/union_test.go b/go/arrow/array/union_test.go
index 2f2bf3b84e9f7..e876f5def26d3 100644
--- a/go/arrow/array/union_test.go
+++ b/go/arrow/array/union_test.go
@@ -21,9 +21,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/array/util.go b/go/arrow/array/util.go
index 54d15a8095c80..a1b3cc7d4e5f7 100644
--- a/go/arrow/array/util.go
+++ b/go/arrow/array/util.go
@@ -22,11 +22,11 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 func min(a, b int) int {
diff --git a/go/arrow/array/util_test.go b/go/arrow/array/util_test.go
index d3d2b37365513..84a6debdf3946 100644
--- a/go/arrow/array/util_test.go
+++ b/go/arrow/array/util_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/arrio/arrio.go b/go/arrow/arrio/arrio.go
index 466a93a68400a..51cf6dc46d44a 100644
--- a/go/arrow/arrio/arrio.go
+++ b/go/arrow/arrio/arrio.go
@@ -22,7 +22,7 @@ import (
 	"errors"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Reader is the interface that wraps the Read method.
diff --git a/go/arrow/arrio/arrio_test.go b/go/arrow/arrio/arrio_test.go
index 7e9aac8fbe520..c80d5d2569d67 100644
--- a/go/arrow/arrio/arrio_test.go
+++ b/go/arrow/arrio/arrio_test.go
@@ -22,11 +22,11 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type copyKind int
diff --git a/go/arrow/bitutil/bitmaps.go b/go/arrow/bitutil/bitmaps.go
index 2e9c0601c3c45..d7516771def7f 100644
--- a/go/arrow/bitutil/bitmaps.go
+++ b/go/arrow/bitutil/bitmaps.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // BitmapReader is a simple bitmap reader for a byte slice.
diff --git a/go/arrow/bitutil/bitmaps_test.go b/go/arrow/bitutil/bitmaps_test.go
index 60022a179d1da..c926bff39e09a 100644
--- a/go/arrow/bitutil/bitmaps_test.go
+++ b/go/arrow/bitutil/bitmaps_test.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/bitutil/bitutil.go b/go/arrow/bitutil/bitutil.go
index a4a1519b8f940..dc510a8b374c4 100644
--- a/go/arrow/bitutil/bitutil.go
+++ b/go/arrow/bitutil/bitutil.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/bitutil/bitutil_test.go b/go/arrow/bitutil/bitutil_test.go
index 9e29e9d04d1db..189c8541f4925 100644
--- a/go/arrow/bitutil/bitutil_test.go
+++ b/go/arrow/bitutil/bitutil_test.go
@@ -21,8 +21,8 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata.go b/go/arrow/cdata/cdata.go
index 1d454c57f722e..f9693851d7483 100644
--- a/go/arrow/cdata/cdata.go
+++ b/go/arrow/cdata/cdata.go
@@ -46,10 +46,10 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/cdata_exports.go b/go/arrow/cdata/cdata_exports.go
index 187c2deb9755f..91f1b352e0327 100644
--- a/go/arrow/cdata/cdata_exports.go
+++ b/go/arrow/cdata/cdata_exports.go
@@ -45,11 +45,11 @@ import (
 	"strings"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
 )
 
 func encodeCMetadata(keys, values []string) []byte {
diff --git a/go/arrow/cdata/cdata_test.go b/go/arrow/cdata/cdata_test.go
index f09fa3ff2f6fa..607cfe53217a6 100644
--- a/go/arrow/cdata/cdata_test.go
+++ b/go/arrow/cdata/cdata_test.go
@@ -35,12 +35,12 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/cdata/cdata_test_framework.go b/go/arrow/cdata/cdata_test_framework.go
index 2df52dcb3cd40..1251b20201e41 100644
--- a/go/arrow/cdata/cdata_test_framework.go
+++ b/go/arrow/cdata/cdata_test_framework.go
@@ -69,10 +69,10 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 )
 
 const (
diff --git a/go/arrow/cdata/exports.go b/go/arrow/cdata/exports.go
index 9d2576818e31c..7353df62d113a 100644
--- a/go/arrow/cdata/exports.go
+++ b/go/arrow/cdata/exports.go
@@ -20,8 +20,8 @@ import (
 	"runtime/cgo"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 // #include <stdlib.h>
diff --git a/go/arrow/cdata/import_allocator.go b/go/arrow/cdata/import_allocator.go
index eff8c7517caef..cf1c6a961ff37 100644
--- a/go/arrow/cdata/import_allocator.go
+++ b/go/arrow/cdata/import_allocator.go
@@ -20,7 +20,7 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // #include "arrow/c/helpers.h"
diff --git a/go/arrow/cdata/interface.go b/go/arrow/cdata/interface.go
index bf5c5270bae2f..8ce06280a0bf5 100644
--- a/go/arrow/cdata/interface.go
+++ b/go/arrow/cdata/interface.go
@@ -22,10 +22,10 @@ package cdata
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/cdata/test/test_cimport.go b/go/arrow/cdata/test/test_cimport.go
index a7c5dc034496a..147c3691f0c71 100644
--- a/go/arrow/cdata/test/test_cimport.go
+++ b/go/arrow/cdata/test/test_cimport.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"runtime"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/cdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/cdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/compute/arithmetic.go b/go/arrow/compute/arithmetic.go
index 2fb95f06ff84a..1ee1959b2ddc8 100644
--- a/go/arrow/compute/arithmetic.go
+++ b/go/arrow/compute/arithmetic.go
@@ -22,12 +22,12 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 type (
diff --git a/go/arrow/compute/arithmetic_test.go b/go/arrow/compute/arithmetic_test.go
index a99b2074eb69f..821ffd9e068d4 100644
--- a/go/arrow/compute/arithmetic_test.go
+++ b/go/arrow/compute/arithmetic_test.go
@@ -26,16 +26,16 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/klauspost/cpuid/v2"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/arrow/compute/cast.go b/go/arrow/compute/cast.go
index 8b720a2bad5d8..133a983038ce1 100644
--- a/go/arrow/compute/cast.go
+++ b/go/arrow/compute/cast.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/cast_test.go b/go/arrow/compute/cast_test.go
index cc301cc35e6e5..10957a45167aa 100644
--- a/go/arrow/compute/cast_test.go
+++ b/go/arrow/compute/cast_test.go
@@ -26,16 +26,16 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/datum.go b/go/arrow/compute/datum.go
index 1d3c1b4dab700..98bd1f1a0a326 100644
--- a/go/arrow/compute/datum.go
+++ b/go/arrow/compute/datum.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 //go:generate go run golang.org/x/tools/cmd/stringer -type=DatumKind -linecomment
diff --git a/go/arrow/compute/example_test.go b/go/arrow/compute/example_test.go
index f0db9f377868e..e2b07b7e191ae 100644
--- a/go/arrow/compute/example_test.go
+++ b/go/arrow/compute/example_test.go
@@ -23,11 +23,11 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // This example demonstrates how to register a custom scalar function.
diff --git a/go/arrow/compute/exec.go b/go/arrow/compute/exec.go
index 84e3310cc2df8..eba47e64bd509 100644
--- a/go/arrow/compute/exec.go
+++ b/go/arrow/compute/exec.go
@@ -22,9 +22,9 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 func haveChunkedArray(values []Datum) bool {
diff --git a/go/arrow/compute/exec/kernel.go b/go/arrow/compute/exec/kernel.go
index 327426da68eb9..766857f63e565 100644
--- a/go/arrow/compute/exec/kernel.go
+++ b/go/arrow/compute/exec/kernel.go
@@ -24,10 +24,10 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/slices"
 )
 
diff --git a/go/arrow/compute/exec/kernel_test.go b/go/arrow/compute/exec/kernel_test.go
index 16a29ea2deda6..4df6b42ff9408 100644
--- a/go/arrow/compute/exec/kernel_test.go
+++ b/go/arrow/compute/exec/kernel_test.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/span.go b/go/arrow/compute/exec/span.go
index b6d240fa4a0be..0b5f6208227f5 100644
--- a/go/arrow/compute/exec/span.go
+++ b/go/arrow/compute/exec/span.go
@@ -23,11 +23,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // BufferSpan is a lightweight Buffer holder for ArraySpans that does not
diff --git a/go/arrow/compute/exec/span_test.go b/go/arrow/compute/exec/span_test.go
index c642be1c30c23..474c005b44642 100644
--- a/go/arrow/compute/exec/span_test.go
+++ b/go/arrow/compute/exec/span_test.go
@@ -24,14 +24,14 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec/utils.go b/go/arrow/compute/exec/utils.go
index 6d83b75da1313..17bc30ef2adb0 100644
--- a/go/arrow/compute/exec/utils.go
+++ b/go/arrow/compute/exec/utils.go
@@ -25,13 +25,13 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/exec/utils_test.go b/go/arrow/compute/exec/utils_test.go
index e9bb07177f2ac..b26e4ff41e79f 100644
--- a/go/arrow/compute/exec/utils_test.go
+++ b/go/arrow/compute/exec/utils_test.go
@@ -21,10 +21,10 @@ package exec_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exec_internals_test.go b/go/arrow/compute/exec_internals_test.go
index eb9273d23389f..bae32268862ff 100644
--- a/go/arrow/compute/exec_internals_test.go
+++ b/go/arrow/compute/exec_internals_test.go
@@ -24,13 +24,13 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/exec_test.go b/go/arrow/compute/exec_test.go
index 30bfbc0246a1c..a37f67c03e8ce 100644
--- a/go/arrow/compute/exec_test.go
+++ b/go/arrow/compute/exec_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index 6da7ed1293065..1cba0b1e19f69 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -25,14 +25,14 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // ExecCtx holds simple contextual information for execution
diff --git a/go/arrow/compute/expression.go b/go/arrow/compute/expression.go
index 9f20c9704dca7..fbb6c502d98ab 100644
--- a/go/arrow/compute/expression.go
+++ b/go/arrow/compute/expression.go
@@ -28,14 +28,14 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 var hashSeed = maphash.MakeSeed()
diff --git a/go/arrow/compute/expression_test.go b/go/arrow/compute/expression_test.go
index 71b1b64c4b0c1..b3b44ae1faa61 100644
--- a/go/arrow/compute/expression_test.go
+++ b/go/arrow/compute/expression_test.go
@@ -22,11 +22,11 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/exprs/builders.go b/go/arrow/compute/exprs/builders.go
index 39606c27e714a..0b694525d1b47 100644
--- a/go/arrow/compute/exprs/builders.go
+++ b/go/arrow/compute/exprs/builders.go
@@ -25,8 +25,8 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/builders_test.go b/go/arrow/compute/exprs/builders_test.go
index e42d7569a8f03..69501622359d5 100644
--- a/go/arrow/compute/exprs/builders_test.go
+++ b/go/arrow/compute/exprs/builders_test.go
@@ -21,8 +21,8 @@ package exprs_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/exec.go b/go/arrow/compute/exprs/exec.go
index d63752696082b..800ffe62f2559 100644
--- a/go/arrow/compute/exprs/exec.go
+++ b/go/arrow/compute/exprs/exec.go
@@ -23,15 +23,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/exprs/exec_internal_test.go b/go/arrow/compute/exprs/exec_internal_test.go
index 9475a9a8cbca9..680bf36f11958 100644
--- a/go/arrow/compute/exprs/exec_internal_test.go
+++ b/go/arrow/compute/exprs/exec_internal_test.go
@@ -23,10 +23,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/exprs/exec_test.go b/go/arrow/compute/exprs/exec_test.go
index e30d2afdb73f8..65cafc8e62ddb 100644
--- a/go/arrow/compute/exprs/exec_test.go
+++ b/go/arrow/compute/exprs/exec_test.go
@@ -23,12 +23,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exprs"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exprs"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/substrait-io/substrait-go/expr"
diff --git a/go/arrow/compute/exprs/extension_types.go b/go/arrow/compute/exprs/extension_types.go
index ce375492d67f1..db7992b8f089f 100644
--- a/go/arrow/compute/exprs/extension_types.go
+++ b/go/arrow/compute/exprs/extension_types.go
@@ -24,8 +24,8 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type simpleExtensionTypeFactory[P comparable] struct {
diff --git a/go/arrow/compute/exprs/field_refs.go b/go/arrow/compute/exprs/field_refs.go
index fd4313818195e..e95e3c8c9abb9 100644
--- a/go/arrow/compute/exprs/field_refs.go
+++ b/go/arrow/compute/exprs/field_refs.go
@@ -21,11 +21,11 @@ package exprs
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/substrait-io/substrait-go/expr"
 )
 
diff --git a/go/arrow/compute/exprs/types.go b/go/arrow/compute/exprs/types.go
index 9f807e1e1ecbc..6a5b81d11b3eb 100644
--- a/go/arrow/compute/exprs/types.go
+++ b/go/arrow/compute/exprs/types.go
@@ -24,8 +24,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/substrait-io/substrait-go/expr"
 	"github.com/substrait-io/substrait-go/extensions"
 	"github.com/substrait-io/substrait-go/types"
diff --git a/go/arrow/compute/fieldref.go b/go/arrow/compute/fieldref.go
index ee6f39948ebf1..565ae3bfadbd0 100644
--- a/go/arrow/compute/fieldref.go
+++ b/go/arrow/compute/fieldref.go
@@ -27,8 +27,8 @@ import (
 	"unicode"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 var (
diff --git a/go/arrow/compute/fieldref_test.go b/go/arrow/compute/fieldref_test.go
index c38ad8ac1fe30..c4fa72182835f 100644
--- a/go/arrow/compute/fieldref_test.go
+++ b/go/arrow/compute/fieldref_test.go
@@ -19,10 +19,10 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/compute/functions.go b/go/arrow/compute/functions.go
index a1905f91850f0..b85062721d9b8 100644
--- a/go/arrow/compute/functions.go
+++ b/go/arrow/compute/functions.go
@@ -23,8 +23,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 type Function interface {
diff --git a/go/arrow/compute/functions_test.go b/go/arrow/compute/functions_test.go
index b37da285badd0..1e6bbd598e0c9 100644
--- a/go/arrow/compute/functions_test.go
+++ b/go/arrow/compute/functions_test.go
@@ -21,8 +21,8 @@ package compute_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic.go b/go/arrow/compute/internal/kernels/base_arithmetic.go
index 67e80af74f511..c7950877264df 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic.go
@@ -24,11 +24,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
index 0e78e6c9183ff..942b8e4ff5600 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/constraints"
 	"golang.org/x/sys/cpu"
 )
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
index 29cce7830e0f4..6814e834b4bf3 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
index e9b03551f81b1..633ec5f4f18e5 100644
--- a/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/base_arithmetic_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
index 4f160a1411091..8e46ca030c8b7 100644
--- a/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
+++ b/go/arrow/compute/internal/kernels/basic_arithmetic_noasm.go
@@ -19,7 +19,7 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/boolean_cast.go b/go/arrow/compute/internal/kernels/boolean_cast.go
index 18d04c845c41d..923c5b3f54512 100644
--- a/go/arrow/compute/internal/kernels/boolean_cast.go
+++ b/go/arrow/compute/internal/kernels/boolean_cast.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 func isNonZero[T exec.FixedWidthTypes](ctx *exec.KernelCtx, in []T, out []byte) error {
diff --git a/go/arrow/compute/internal/kernels/cast.go b/go/arrow/compute/internal/kernels/cast.go
index 5a71206b2476c..bc4ee3abd128c 100644
--- a/go/arrow/compute/internal/kernels/cast.go
+++ b/go/arrow/compute/internal/kernels/cast.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 )
 
 type CastOptions struct {
diff --git a/go/arrow/compute/internal/kernels/cast_numeric.go b/go/arrow/compute/internal/kernels/cast_numeric.go
index 4e5c5c1d9ea77..2e893c7205f6a 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 var castNumericUnsafe func(itype, otype arrow.Type, in, out []byte, len int) = castNumericGo
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
index 6b28441ec083e..eafa4b41001ae 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
index d53a4486f6983..75ad79fd0e7f3 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_neon_arm64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
index 1cbea033dec27..d04f393c4c099 100644
--- a/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/cast_numeric_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/cast_temporal.go b/go/arrow/compute/internal/kernels/cast_temporal.go
index 82fce1e33c959..542a8a4590b28 100644
--- a/go/arrow/compute/internal/kernels/cast_temporal.go
+++ b/go/arrow/compute/internal/kernels/cast_temporal.go
@@ -24,10 +24,10 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const millisecondsInDay = 86400000
diff --git a/go/arrow/compute/internal/kernels/helpers.go b/go/arrow/compute/internal/kernels/helpers.go
index ed25071c9d87f..686c4b3e0c29a 100644
--- a/go/arrow/compute/internal/kernels/helpers.go
+++ b/go/arrow/compute/internal/kernels/helpers.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/numeric_cast.go b/go/arrow/compute/internal/kernels/numeric_cast.go
index 8e5350754723d..c055552bf7ff5 100644
--- a/go/arrow/compute/internal/kernels/numeric_cast.go
+++ b/go/arrow/compute/internal/kernels/numeric_cast.go
@@ -23,13 +23,13 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/rounding.go b/go/arrow/compute/internal/kernels/rounding.go
index 2f58a9faea8a2..8a1bec1180ac8 100644
--- a/go/arrow/compute/internal/kernels/rounding.go
+++ b/go/arrow/compute/internal/kernels/rounding.go
@@ -22,11 +22,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_arithmetic.go b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
index 9cb32ae64a4a9..cf17e9fd9548b 100644
--- a/go/arrow/compute/internal/kernels/scalar_arithmetic.go
+++ b/go/arrow/compute/internal/kernels/scalar_arithmetic.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 // scalar kernel that ignores (assumed all-null inputs) and returns null
diff --git a/go/arrow/compute/internal/kernels/scalar_boolean.go b/go/arrow/compute/internal/kernels/scalar_boolean.go
index 812f4ad1bd363..0707c92e6a198 100644
--- a/go/arrow/compute/internal/kernels/scalar_boolean.go
+++ b/go/arrow/compute/internal/kernels/scalar_boolean.go
@@ -19,9 +19,9 @@
 package kernels
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 type computeWordFN func(leftTrue, leftFalse, rightTrue, rightFalse uint64) (outValid, outData uint64)
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
index 585d1bff01ab6..8e5ce1ab7c1ad 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_amd64.go
@@ -21,8 +21,8 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"golang.org/x/sys/cpu"
 )
 
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
index 868179057ccf4..cf9fc1eeedbb8 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_avx2_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
index 56abad42b1ffc..c0aef5a04e9b8 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_noasm.go
@@ -18,7 +18,7 @@
 
 package kernels
 
-import "github.com/apache/arrow/go/v14/arrow/compute/exec"
+import "github.com/apache/arrow/go/v15/arrow/compute/exec"
 
 func genCompareKernel[T exec.NumericTypes](op CompareOperator) *CompareData {
 	return genGoCompareKernel(getCmpOp[T](op))
diff --git a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
index 7cf96a4171d6c..f8b36a1e4be76 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparison_sse4_amd64.go
@@ -21,7 +21,7 @@ package kernels
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:noescape
diff --git a/go/arrow/compute/internal/kernels/scalar_comparisons.go b/go/arrow/compute/internal/kernels/scalar_comparisons.go
index 8a957eafd85da..9a7640a8d8a39 100644
--- a/go/arrow/compute/internal/kernels/scalar_comparisons.go
+++ b/go/arrow/compute/internal/kernels/scalar_comparisons.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 type binaryKernel func(left, right, out []byte, offset int)
diff --git a/go/arrow/compute/internal/kernels/string_casts.go b/go/arrow/compute/internal/kernels/string_casts.go
index 3070514665d7d..76da901e33f8d 100644
--- a/go/arrow/compute/internal/kernels/string_casts.go
+++ b/go/arrow/compute/internal/kernels/string_casts.go
@@ -23,12 +23,12 @@ import (
 	"strconv"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 func validateUtf8Fsb(input *exec.ArraySpan) error {
diff --git a/go/arrow/compute/internal/kernels/types.go b/go/arrow/compute/internal/kernels/types.go
index 2788fb7054c53..481eab36059f8 100644
--- a/go/arrow/compute/internal/kernels/types.go
+++ b/go/arrow/compute/internal/kernels/types.go
@@ -21,10 +21,10 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 )
 
 var (
diff --git a/go/arrow/compute/internal/kernels/vector_hash.go b/go/arrow/compute/internal/kernels/vector_hash.go
index e0ede826e876e..9401e31cc5b09 100644
--- a/go/arrow/compute/internal/kernels/vector_hash.go
+++ b/go/arrow/compute/internal/kernels/vector_hash.go
@@ -21,13 +21,13 @@ package kernels
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/hashing"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/hashing"
 )
 
 type HashState interface {
diff --git a/go/arrow/compute/internal/kernels/vector_run_end_encode.go b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
index e073ff1ff5308..a147bf7d50170 100644
--- a/go/arrow/compute/internal/kernels/vector_run_end_encode.go
+++ b/go/arrow/compute/internal/kernels/vector_run_end_encode.go
@@ -24,14 +24,14 @@ import (
 	"sort"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type RunEndEncodeState struct {
diff --git a/go/arrow/compute/internal/kernels/vector_selection.go b/go/arrow/compute/internal/kernels/vector_selection.go
index c7a902bd008d0..714e452325bfd 100644
--- a/go/arrow/compute/internal/kernels/vector_selection.go
+++ b/go/arrow/compute/internal/kernels/vector_selection.go
@@ -22,13 +22,13 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 type NullSelectionBehavior int8
diff --git a/go/arrow/compute/registry.go b/go/arrow/compute/registry.go
index 4f1c435fb680a..379e0ccbe86a9 100644
--- a/go/arrow/compute/registry.go
+++ b/go/arrow/compute/registry.go
@@ -21,7 +21,7 @@ package compute
 import (
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"golang.org/x/exp/maps"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/registry_test.go b/go/arrow/compute/registry_test.go
index 428f7cf1d8fda..4e4f44f1d39b6 100644
--- a/go/arrow/compute/registry_test.go
+++ b/go/arrow/compute/registry_test.go
@@ -23,9 +23,9 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/slices"
 )
diff --git a/go/arrow/compute/scalar_bool.go b/go/arrow/compute/scalar_bool.go
index 49c745688284e..1f28a6e2bfcb2 100644
--- a/go/arrow/compute/scalar_bool.go
+++ b/go/arrow/compute/scalar_bool.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/scalar_bool_test.go b/go/arrow/compute/scalar_bool_test.go
index 6eadc973d6965..bd4f3c5c0df2b 100644
--- a/go/arrow/compute/scalar_bool_test.go
+++ b/go/arrow/compute/scalar_bool_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/compute/scalar_compare.go b/go/arrow/compute/scalar_compare.go
index 476f37711e289..24a4191a10999 100644
--- a/go/arrow/compute/scalar_compare.go
+++ b/go/arrow/compute/scalar_compare.go
@@ -21,9 +21,9 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 type compareFunction struct {
diff --git a/go/arrow/compute/scalar_compare_test.go b/go/arrow/compute/scalar_compare_test.go
index 13fdd24fdd6b3..d209f72c800b0 100644
--- a/go/arrow/compute/scalar_compare_test.go
+++ b/go/arrow/compute/scalar_compare_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/selection.go b/go/arrow/compute/selection.go
index ed6d80418d3f6..90bc5280ef2a7 100644
--- a/go/arrow/compute/selection.go
+++ b/go/arrow/compute/selection.go
@@ -22,10 +22,10 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/arrow/compute/utils.go b/go/arrow/compute/utils.go
index cc4d6edc48ec8..9de6523fd0b5f 100644
--- a/go/arrow/compute/utils.go
+++ b/go/arrow/compute/utils.go
@@ -24,12 +24,12 @@ import (
 	"math"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/compute/vector_hash.go b/go/arrow/compute/vector_hash.go
index 5f9aec55c55bc..144c123380fe2 100644
--- a/go/arrow/compute/vector_hash.go
+++ b/go/arrow/compute/vector_hash.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_hash_test.go b/go/arrow/compute/vector_hash_test.go
index 50c96ddc04f6c..9410720de7941 100644
--- a/go/arrow/compute/vector_hash_test.go
+++ b/go/arrow/compute/vector_hash_test.go
@@ -23,13 +23,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/compute/vector_run_end_test.go b/go/arrow/compute/vector_run_end_test.go
index 8d894d96b8f0a..51c0f834ceb6a 100644
--- a/go/arrow/compute/vector_run_end_test.go
+++ b/go/arrow/compute/vector_run_end_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/arrow/compute/vector_run_ends.go b/go/arrow/compute/vector_run_ends.go
index 48f3dcba8c481..3e47c67de3c35 100644
--- a/go/arrow/compute/vector_run_ends.go
+++ b/go/arrow/compute/vector_run_ends.go
@@ -21,8 +21,8 @@ package compute
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
 )
 
 var (
diff --git a/go/arrow/compute/vector_selection_test.go b/go/arrow/compute/vector_selection_test.go
index 10788d60e10d2..f44840ba72034 100644
--- a/go/arrow/compute/vector_selection_test.go
+++ b/go/arrow/compute/vector_selection_test.go
@@ -24,15 +24,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/compute/exec"
-	"github.com/apache/arrow/go/v14/arrow/compute/internal/kernels"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/gen"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/compute/exec"
+	"github.com/apache/arrow/go/v15/arrow/compute/internal/kernels"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/gen"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/csv/common.go b/go/arrow/csv/common.go
index 91f42897a24a6..2a1f7300a986f 100644
--- a/go/arrow/csv/common.go
+++ b/go/arrow/csv/common.go
@@ -22,8 +22,8 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 var (
diff --git a/go/arrow/csv/reader.go b/go/arrow/csv/reader.go
index 80af520a12b7f..e58b426d837fb 100644
--- a/go/arrow/csv/reader.go
+++ b/go/arrow/csv/reader.go
@@ -29,13 +29,13 @@ import (
 	"time"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Reader wraps encoding/csv.Reader and creates array.Records from a schema.
diff --git a/go/arrow/csv/reader_test.go b/go/arrow/csv/reader_test.go
index f481cd2e961d3..dfcb6625bd7cc 100644
--- a/go/arrow/csv/reader_test.go
+++ b/go/arrow/csv/reader_test.go
@@ -25,13 +25,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/csv"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/csv"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/csv/transformer.go b/go/arrow/csv/transformer.go
index 7c8eafcee1a59..0f0181520b847 100644
--- a/go/arrow/csv/transformer.go
+++ b/go/arrow/csv/transformer.go
@@ -25,8 +25,8 @@ import (
 	"math/big"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 func (w *Writer) transformColToStringArr(typ arrow.DataType, col arrow.Array) []string {
diff --git a/go/arrow/csv/writer.go b/go/arrow/csv/writer.go
index e558364ecf16d..a672008b58a07 100644
--- a/go/arrow/csv/writer.go
+++ b/go/arrow/csv/writer.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Writer wraps encoding/csv.Writer and writes arrow.Record based on a schema.
diff --git a/go/arrow/csv/writer_test.go b/go/arrow/csv/writer_test.go
index f945023790426..1918e2e492dff 100644
--- a/go/arrow/csv/writer_test.go
+++ b/go/arrow/csv/writer_test.go
@@ -25,14 +25,14 @@ import (
 	"log"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/csv"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/csv"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 )
 
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index f0fb24ec873c5..24113b55899dc 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -21,7 +21,7 @@ import (
 	"hash/maphash"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Type is a logical type. They can be expressed as
diff --git a/go/arrow/datatype_binary_test.go b/go/arrow/datatype_binary_test.go
index c47df3da1db9c..25ba6e8db4ba4 100644
--- a/go/arrow/datatype_binary_test.go
+++ b/go/arrow/datatype_binary_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestBinaryType(t *testing.T) {
diff --git a/go/arrow/datatype_extension_test.go b/go/arrow/datatype_extension_test.go
index c542b22b769e6..9811800400506 100644
--- a/go/arrow/datatype_extension_test.go
+++ b/go/arrow/datatype_extension_test.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/arrow/datatype_fixedwidth.go b/go/arrow/datatype_fixedwidth.go
index fc0b3aea56e70..bcbc8ef6aec87 100644
--- a/go/arrow/datatype_fixedwidth.go
+++ b/go/arrow/datatype_fixedwidth.go
@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/internal/json"
 
 	"golang.org/x/xerrors"
 )
diff --git a/go/arrow/datatype_fixedwidth_test.go b/go/arrow/datatype_fixedwidth_test.go
index 1d3a07de09c1d..918572d40b8f4 100644
--- a/go/arrow/datatype_fixedwidth_test.go
+++ b/go/arrow/datatype_fixedwidth_test.go
@@ -20,7 +20,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/datatype_nested.go b/go/arrow/datatype_nested.go
index 4ae4880334620..e381cd7047e45 100644
--- a/go/arrow/datatype_nested.go
+++ b/go/arrow/datatype_nested.go
@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 type (
diff --git a/go/arrow/datatype_null_test.go b/go/arrow/datatype_null_test.go
index 286a72fb7fea3..57cddfadb8ef8 100644
--- a/go/arrow/datatype_null_test.go
+++ b/go/arrow/datatype_null_test.go
@@ -19,7 +19,7 @@ package arrow_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestNullType(t *testing.T) {
diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index ff9c088b9d638..7bde39d327417 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -23,7 +23,7 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index 102eede6d3b28..879f2849028f8 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -22,7 +22,7 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/decimal256/decimal256.go b/go/arrow/decimal256/decimal256.go
index cf2157fdd48ed..5f2ad5f32165c 100644
--- a/go/arrow/decimal256/decimal256.go
+++ b/go/arrow/decimal256/decimal256.go
@@ -23,8 +23,8 @@ import (
 	"math/big"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 const (
diff --git a/go/arrow/decimal256/decimal256_test.go b/go/arrow/decimal256/decimal256_test.go
index 9c734e23aa0d6..3be6a1944406f 100644
--- a/go/arrow/decimal256/decimal256_test.go
+++ b/go/arrow/decimal256/decimal256_test.go
@@ -23,7 +23,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/doc.go b/go/arrow/doc.go
index 87aea1d41035c..c8da330e4f8a1 100644
--- a/go/arrow/doc.go
+++ b/go/arrow/doc.go
@@ -36,7 +36,7 @@ To build with tinygo include the noasm build tag.
 */
 package arrow
 
-const PkgVersion = "14.0.1-SNAPSHOT"
+const PkgVersion = "15.0.0-SNAPSHOT"
 
 //go:generate go run _tools/tmpl/main.go -i -data=numeric.tmpldata type_traits_numeric.gen.go.tmpl type_traits_numeric.gen_test.go.tmpl array/numeric.gen.go.tmpl array/numericbuilder.gen.go.tmpl array/bufferbuilder_numeric.gen.go.tmpl
 //go:generate go run _tools/tmpl/main.go -i -data=datatype_numeric.gen.go.tmpldata datatype_numeric.gen.go.tmpl tensor/numeric.gen.go.tmpl tensor/numeric.gen_test.go.tmpl
diff --git a/go/arrow/encoded/ree_utils.go b/go/arrow/encoded/ree_utils.go
index 1f71e7b5210cf..2ff4e7cadd38b 100644
--- a/go/arrow/encoded/ree_utils.go
+++ b/go/arrow/encoded/ree_utils.go
@@ -20,7 +20,7 @@ import (
 	"math"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // FindPhysicalIndex performs a binary search on the run-ends to return
diff --git a/go/arrow/encoded/ree_utils_test.go b/go/arrow/encoded/ree_utils_test.go
index 785a3b105a47d..9470331002b80 100644
--- a/go/arrow/encoded/ree_utils_test.go
+++ b/go/arrow/encoded/ree_utils_test.go
@@ -21,10 +21,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/endian/endian.go b/go/arrow/endian/endian.go
index 3ecda7b3600b7..d4865025b1fb0 100644
--- a/go/arrow/endian/endian.go
+++ b/go/arrow/endian/endian.go
@@ -17,8 +17,8 @@
 package endian
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
 )
 
 type Endianness flatbuf.Endianness
diff --git a/go/arrow/example_test.go b/go/arrow/example_test.go
index 10b3633f65536..b28cc9093739f 100644
--- a/go/arrow/example_test.go
+++ b/go/arrow/example_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 // This example demonstrates how to build an array of int64 values using a builder and Append.
diff --git a/go/arrow/flight/basic_auth_flight_test.go b/go/arrow/flight/basic_auth_flight_test.go
index 0f63a400353d2..4097bf02edeff 100755
--- a/go/arrow/flight/basic_auth_flight_test.go
+++ b/go/arrow/flight/basic_auth_flight_test.go
@@ -22,7 +22,7 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/client.go b/go/arrow/flight/client.go
index c9a1417accab4..8c400eb66b64d 100644
--- a/go/arrow/flight/client.go
+++ b/go/arrow/flight/client.go
@@ -26,7 +26,7 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/cookie_middleware_test.go b/go/arrow/flight/cookie_middleware_test.go
index 2bde37fc0bb85..bdfe4fb32c1a5 100644
--- a/go/arrow/flight/cookie_middleware_test.go
+++ b/go/arrow/flight/cookie_middleware_test.go
@@ -28,7 +28,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/example_flight_server_test.go b/go/arrow/flight/example_flight_server_test.go
index 09f01361d13a0..d3a71b3b67ade 100755
--- a/go/arrow/flight/example_flight_server_test.go
+++ b/go/arrow/flight/example_flight_server_test.go
@@ -23,7 +23,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flight_middleware_test.go b/go/arrow/flight/flight_middleware_test.go
index f2b240d1f2e45..e6faa1b7df1d2 100755
--- a/go/arrow/flight/flight_middleware_test.go
+++ b/go/arrow/flight/flight_middleware_test.go
@@ -23,8 +23,8 @@ import (
 	sync "sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flight_test.go b/go/arrow/flight/flight_test.go
index 7cd724b76b8ce..cd37658603d5b 100755
--- a/go/arrow/flight/flight_test.go
+++ b/go/arrow/flight/flight_test.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials/insecure"
diff --git a/go/arrow/flight/flightsql/client.go b/go/arrow/flight/flightsql/client.go
index 13d046661e96d..c0c7e2cf20a28 100644
--- a/go/arrow/flight/flightsql/client.go
+++ b/go/arrow/flight/flightsql/client.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
diff --git a/go/arrow/flight/flightsql/client_test.go b/go/arrow/flight/flightsql/client_test.go
index bb4ae29477997..3efe4ba4049b8 100644
--- a/go/arrow/flight/flightsql/client_test.go
+++ b/go/arrow/flight/flightsql/client_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
diff --git a/go/arrow/flight/flightsql/column_metadata.go b/go/arrow/flight/flightsql/column_metadata.go
index d9785892888b2..8e0a69b99d055 100644
--- a/go/arrow/flight/flightsql/column_metadata.go
+++ b/go/arrow/flight/flightsql/column_metadata.go
@@ -19,7 +19,7 @@ package flightsql
 import (
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/driver/README.md b/go/arrow/flight/flightsql/driver/README.md
index b8850527c19c1..f1447a7d24256 100644
--- a/go/arrow/flight/flightsql/driver/README.md
+++ b/go/arrow/flight/flightsql/driver/README.md
@@ -36,7 +36,7 @@ connection pooling, transactions combined with ease of use (see (#usage)).
 ## Prerequisites
 
 * Go 1.17+
-* Installation via `go get -u github.com/apache/arrow/go/v14/arrow/flight/flightsql`
+* Installation via `go get -u github.com/apache/arrow/go/v15/arrow/flight/flightsql`
 * Backend speaking FlightSQL
 
 ---------------------------------------
@@ -55,7 +55,7 @@ import (
     "database/sql"
     "time"
 
-    _ "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+    _ "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 // Open the connection to an SQLite backend
@@ -141,7 +141,7 @@ import (
     "log"
     "time"
 
-    "github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+    "github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/driver/config_test.go b/go/arrow/flight/flightsql/driver/config_test.go
index abcececeaf214..6b24b535585d9 100644
--- a/go/arrow/flight/flightsql/driver/config_test.go
+++ b/go/arrow/flight/flightsql/driver/config_test.go
@@ -22,7 +22,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
 )
 
 func TestConfigTLSRegistry(t *testing.T) {
diff --git a/go/arrow/flight/flightsql/driver/driver.go b/go/arrow/flight/flightsql/driver/driver.go
index b4cb0d2dbda2e..e325489236c6d 100644
--- a/go/arrow/flight/flightsql/driver/driver.go
+++ b/go/arrow/flight/flightsql/driver/driver.go
@@ -25,11 +25,11 @@ import (
 	"sort"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
diff --git a/go/arrow/flight/flightsql/driver/driver_test.go b/go/arrow/flight/flightsql/driver/driver_test.go
index 4449b390974a7..a388bf155ec99 100644
--- a/go/arrow/flight/flightsql/driver/driver_test.go
+++ b/go/arrow/flight/flightsql/driver/driver_test.go
@@ -33,13 +33,13 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/driver"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/driver"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 const defaultTableName = "drivertest"
diff --git a/go/arrow/flight/flightsql/driver/utils.go b/go/arrow/flight/flightsql/driver/utils.go
index 99352e7251c53..022e9da4925f9 100644
--- a/go/arrow/flight/flightsql/driver/utils.go
+++ b/go/arrow/flight/flightsql/driver/utils.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 // *** GRPC helpers ***
diff --git a/go/arrow/flight/flightsql/driver/utils_test.go b/go/arrow/flight/flightsql/driver/utils_test.go
index 355c888f56cc4..8f5ea031adf28 100644
--- a/go/arrow/flight/flightsql/driver/utils_test.go
+++ b/go/arrow/flight/flightsql/driver/utils_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/require"
 )
 
diff --git a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
index 6508833876fa5..1a50422f826f3 100644
--- a/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
+++ b/go/arrow/flight/flightsql/example/cmd/sqlite_flightsql_server/main.go
@@ -27,9 +27,9 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
 )
 
 func main() {
diff --git a/go/arrow/flight/flightsql/example/sql_batch_reader.go b/go/arrow/flight/flightsql/example/sql_batch_reader.go
index 7101b8f830a6f..36a0d7b424544 100644
--- a/go/arrow/flight/flightsql/example/sql_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sql_batch_reader.go
@@ -26,11 +26,11 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/wrapperspb"
diff --git a/go/arrow/flight/flightsql/example/sqlite_info.go b/go/arrow/flight/flightsql/example/sqlite_info.go
index bf29265853c65..c993af97f7449 100644
--- a/go/arrow/flight/flightsql/example/sqlite_info.go
+++ b/go/arrow/flight/flightsql/example/sqlite_info.go
@@ -20,8 +20,8 @@
 package example
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
 )
 
 func SqlInfoResultMap() flightsql.SqlInfoResultMap {
diff --git a/go/arrow/flight/flightsql/example/sqlite_server.go b/go/arrow/flight/flightsql/example/sqlite_server.go
index 63b41ee5e0a4a..f06dd0210655f 100644
--- a/go/arrow/flight/flightsql/example/sqlite_server.go
+++ b/go/arrow/flight/flightsql/example/sqlite_server.go
@@ -45,13 +45,13 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
diff --git a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
index 507abf622d890..e07a98fffdbf7 100644
--- a/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
+++ b/go/arrow/flight/flightsql/example/sqlite_tables_schema_batch_reader.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	sqlite3 "modernc.org/sqlite/lib"
 )
 
diff --git a/go/arrow/flight/flightsql/example/type_info.go b/go/arrow/flight/flightsql/example/type_info.go
index 6d6ceb339e4b0..0180fc1f23af5 100644
--- a/go/arrow/flight/flightsql/example/type_info.go
+++ b/go/arrow/flight/flightsql/example/type_info.go
@@ -22,10 +22,10 @@ package example
 import (
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func GetTypeInfoResult(mem memory.Allocator) arrow.Record {
diff --git a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
index 98d61f8110d45..b65688306473b 100644
--- a/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
+++ b/go/arrow/flight/flightsql/schema_ref/reference_schemas.go
@@ -18,7 +18,7 @@
 // by FlightSQL servers and clients.
 package schema_ref
 
-import "github.com/apache/arrow/go/v14/arrow"
+import "github.com/apache/arrow/go/v15/arrow"
 
 var (
 	Catalogs = arrow.NewSchema(
diff --git a/go/arrow/flight/flightsql/server.go b/go/arrow/flight/flightsql/server.go
index e9cbc177da2c4..a086610433eae 100644
--- a/go/arrow/flight/flightsql/server.go
+++ b/go/arrow/flight/flightsql/server.go
@@ -20,14 +20,14 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
diff --git a/go/arrow/flight/flightsql/server_test.go b/go/arrow/flight/flightsql/server_test.go
index 33e9b8236a261..e444da4aaf4a2 100644
--- a/go/arrow/flight/flightsql/server_test.go
+++ b/go/arrow/flight/flightsql/server_test.go
@@ -22,12 +22,12 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/sql_info.go b/go/arrow/flight/flightsql/sql_info.go
index a12c4fbdaeda9..5f78e1facd581 100644
--- a/go/arrow/flight/flightsql/sql_info.go
+++ b/go/arrow/flight/flightsql/sql_info.go
@@ -17,8 +17,8 @@
 package flightsql
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 const (
diff --git a/go/arrow/flight/flightsql/sqlite_server_test.go b/go/arrow/flight/flightsql/sqlite_server_test.go
index 03ae3d7a8313a..e6fa798c55cf1 100644
--- a/go/arrow/flight/flightsql/sqlite_server_test.go
+++ b/go/arrow/flight/flightsql/sqlite_server_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/example"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/example"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/flight/flightsql/types.go b/go/arrow/flight/flightsql/types.go
index 98086a61fe067..2b7419482e3e3 100644
--- a/go/arrow/flight/flightsql/types.go
+++ b/go/arrow/flight/flightsql/types.go
@@ -17,7 +17,7 @@
 package flightsql
 
 import (
-	pb "github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	pb "github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
 )
diff --git a/go/arrow/flight/record_batch_reader.go b/go/arrow/flight/record_batch_reader.go
index b726180627e6f..f137c75172368 100644
--- a/go/arrow/flight/record_batch_reader.go
+++ b/go/arrow/flight/record_batch_reader.go
@@ -21,12 +21,12 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // DataStreamReader is an interface for receiving flight data messages on a stream
diff --git a/go/arrow/flight/record_batch_writer.go b/go/arrow/flight/record_batch_writer.go
index 3ae17bcf48042..426dca6c3e907 100644
--- a/go/arrow/flight/record_batch_writer.go
+++ b/go/arrow/flight/record_batch_writer.go
@@ -19,9 +19,9 @@ package flight
 import (
 	"bytes"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // DataStreamWriter is an interface that represents an Arrow Flight stream
diff --git a/go/arrow/flight/server.go b/go/arrow/flight/server.go
index cf471f9b3a2b6..8676b15644e47 100644
--- a/go/arrow/flight/server.go
+++ b/go/arrow/flight/server.go
@@ -22,7 +22,7 @@ import (
 	"os"
 	"os/signal"
 
-	"github.com/apache/arrow/go/v14/arrow/flight/gen/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/gen/flight"
 	"google.golang.org/grpc"
 )
 
diff --git a/go/arrow/flight/server_example_test.go b/go/arrow/flight/server_example_test.go
index b82e2cb7f7164..4e2e4f4c6b587 100644
--- a/go/arrow/flight/server_example_test.go
+++ b/go/arrow/flight/server_example_test.go
@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/apache/arrow/go/v14/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/health"
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 0851bff0fe0da..6631e4245c19d 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -21,14 +21,14 @@ import (
 	"fmt"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 var (
diff --git a/go/arrow/internal/arrdata/ioutil.go b/go/arrow/internal/arrdata/ioutil.go
index 1a2ce0e5b5eca..a6becc2151ef3 100644
--- a/go/arrow/internal/arrdata/ioutil.go
+++ b/go/arrow/internal/arrdata/ioutil.go
@@ -23,11 +23,11 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // CheckArrowFile checks whether a given ARROW file contains the expected list of records.
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index ad87b73fc4ddb..87bdc1f44d875 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Schema struct {
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index ee85d431805ab..7beadee370edb 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -22,9 +22,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/arrjson/option.go b/go/arrow/internal/arrjson/option.go
index 7ae2058d471a7..47d40f857c54e 100644
--- a/go/arrow/internal/arrjson/option.go
+++ b/go/arrow/internal/arrjson/option.go
@@ -17,8 +17,8 @@
 package arrjson
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type config struct {
diff --git a/go/arrow/internal/arrjson/reader.go b/go/arrow/internal/arrjson/reader.go
index c8056ef1dc744..226fa1b1919f9 100644
--- a/go/arrow/internal/arrjson/reader.go
+++ b/go/arrow/internal/arrjson/reader.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 type Reader struct {
diff --git a/go/arrow/internal/arrjson/writer.go b/go/arrow/internal/arrjson/writer.go
index ddac32609b604..af7032d581f4d 100644
--- a/go/arrow/internal/arrjson/writer.go
+++ b/go/arrow/internal/arrjson/writer.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/internal/json"
 )
 
 const (
diff --git a/go/arrow/internal/cdata_integration/entrypoints.go b/go/arrow/internal/cdata_integration/entrypoints.go
index 629b8a762a689..a40db8316f848 100644
--- a/go/arrow/internal/cdata_integration/entrypoints.go
+++ b/go/arrow/internal/cdata_integration/entrypoints.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/cdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/cdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // #include <stdint.h>
diff --git a/go/arrow/internal/dictutils/dict.go b/go/arrow/internal/dictutils/dict.go
index e09a2f4a0ecd1..d31369f7d25b3 100644
--- a/go/arrow/internal/dictutils/dict.go
+++ b/go/arrow/internal/dictutils/dict.go
@@ -21,9 +21,9 @@ import (
 	"fmt"
 	"hash/maphash"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type Kind int8
diff --git a/go/arrow/internal/dictutils/dict_test.go b/go/arrow/internal/dictutils/dict_test.go
index 6cafacbd1df00..9d2f7ae4782c7 100644
--- a/go/arrow/internal/dictutils/dict_test.go
+++ b/go/arrow/internal/dictutils/dict_test.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestDictMemo(t *testing.T) {
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
index 8da39858fabab..1afb53c5294f4 100755
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-client/main.go
@@ -22,7 +22,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 )
diff --git a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
index 9cebb2c695ece..d382ff9e88670 100644
--- a/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
+++ b/go/arrow/internal/flight_integration/cmd/arrow-flight-integration-server/main.go
@@ -23,7 +23,7 @@ import (
 	"os"
 	"syscall"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/flight_integration"
+	"github.com/apache/arrow/go/v15/arrow/internal/flight_integration"
 )
 
 var (
diff --git a/go/arrow/internal/flight_integration/scenario.go b/go/arrow/internal/flight_integration/scenario.go
index 4f47d7fd506ee..3ec905e2d659c 100644
--- a/go/arrow/internal/flight_integration/scenario.go
+++ b/go/arrow/internal/flight_integration/scenario.go
@@ -31,15 +31,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql"
-	"github.com/apache/arrow/go/v14/arrow/flight/flightsql/schema_ref"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql"
+	"github.com/apache/arrow/go/v15/arrow/flight/flightsql/schema_ref"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"golang.org/x/xerrors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index 41f2578209a7f..b42273ff93fac 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -19,11 +19,11 @@ package gen
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/arrow/internal/testing/tools/bits_test.go b/go/arrow/internal/testing/tools/bits_test.go
index 7d0fccb5f999e..6ad8ac5b12b68 100644
--- a/go/arrow/internal/testing/tools/bits_test.go
+++ b/go/arrow/internal/testing/tools/bits_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/internal/testing/tools/data_types.go b/go/arrow/internal/testing/tools/data_types.go
index 654780bc3e853..161cfa431491d 100644
--- a/go/arrow/internal/testing/tools/data_types.go
+++ b/go/arrow/internal/testing/tools/data_types.go
@@ -21,8 +21,8 @@ package tools
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/internal/utils.go b/go/arrow/internal/utils.go
index 265f030dfd19a..619eebd97dc78 100644
--- a/go/arrow/internal/utils.go
+++ b/go/arrow/internal/utils.go
@@ -17,8 +17,8 @@
 package internal
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
 )
 
 const CurMetadataVersion = flatbuf.MetadataVersionV5
diff --git a/go/arrow/ipc/cmd/arrow-cat/main.go b/go/arrow/ipc/cmd/arrow-cat/main.go
index af53c9b4e5f44..0251b08c09bff 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main.go
@@ -63,8 +63,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-cat/main_test.go b/go/arrow/ipc/cmd/arrow-cat/main_test.go
index 22e4f6ffe0778..b6528b85b416d 100644
--- a/go/arrow/ipc/cmd/arrow-cat/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-cat/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestCatStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
index 7e86263d6d5b8..6187b94465211 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
index 30db24715386f..2f66a8b48c59d 100644
--- a/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-file-to-stream/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFileToStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
index 91ba6a4ad9b61..7db2fa1d1c5db 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main.go
@@ -22,12 +22,12 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrjson"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrjson"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/internal/types"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
index 140f9f62478c0..eb702f0aa2bc5 100644
--- a/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-json-integration-test/main_test.go
@@ -20,8 +20,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestIntegration(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main.go b/go/arrow/ipc/cmd/arrow-ls/main.go
index f739c9ae7da8e..4230ae2449985 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main.go
@@ -61,8 +61,8 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-ls/main_test.go b/go/arrow/ipc/cmd/arrow-ls/main_test.go
index 2c038dae97b52..bda1c2dc4d3dc 100644
--- a/go/arrow/ipc/cmd/arrow-ls/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-ls/main_test.go
@@ -23,10 +23,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestLsStream(t *testing.T) {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
index 758231ea21cf5..7ed3f6a281d9f 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main.go
@@ -24,9 +24,9 @@ import (
 	"log"
 	"os"
 
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func main() {
diff --git a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
index 4354b46e8964b..73196551054ac 100644
--- a/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
+++ b/go/arrow/ipc/cmd/arrow-stream-to-file/main_test.go
@@ -21,8 +21,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestStreamToFile(t *testing.T) {
diff --git a/go/arrow/ipc/compression.go b/go/arrow/ipc/compression.go
index 73fb916500804..8856b732f9c5d 100644
--- a/go/arrow/ipc/compression.go
+++ b/go/arrow/ipc/compression.go
@@ -19,9 +19,9 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/klauspost/compress/zstd"
 	"github.com/pierrec/lz4/v4"
 )
diff --git a/go/arrow/ipc/endian_swap.go b/go/arrow/ipc/endian_swap.go
index d98fec1089f04..d2e0948434abc 100644
--- a/go/arrow/ipc/endian_swap.go
+++ b/go/arrow/ipc/endian_swap.go
@@ -20,9 +20,9 @@ import (
 	"errors"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // swap the endianness of the array's buffers as needed in-place to save
diff --git a/go/arrow/ipc/endian_swap_test.go b/go/arrow/ipc/endian_swap_test.go
index 4f02bb53d61a4..1c724103f4441 100644
--- a/go/arrow/ipc/endian_swap_test.go
+++ b/go/arrow/ipc/endian_swap_test.go
@@ -20,11 +20,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index 10cb2cae764e6..330355d3a60c3 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -23,14 +23,14 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // FileReader is an Arrow file reader.
diff --git a/go/arrow/ipc/file_test.go b/go/arrow/ipc/file_test.go
index 1b22719dc8097..5f4dac1f899bb 100644
--- a/go/arrow/ipc/file_test.go
+++ b/go/arrow/ipc/file_test.go
@@ -21,9 +21,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestFile(t *testing.T) {
diff --git a/go/arrow/ipc/file_writer.go b/go/arrow/ipc/file_writer.go
index 12384225b70a1..55e4d7c2dc22c 100644
--- a/go/arrow/ipc/file_writer.go
+++ b/go/arrow/ipc/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // PayloadWriter is an interface for injecting a different payloadwriter
diff --git a/go/arrow/ipc/ipc.go b/go/arrow/ipc/ipc.go
index 6c04b6f5ad2d6..8cf56e8331fcb 100644
--- a/go/arrow/ipc/ipc.go
+++ b/go/arrow/ipc/ipc.go
@@ -19,10 +19,10 @@ package ipc
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 const (
diff --git a/go/arrow/ipc/ipc_test.go b/go/arrow/ipc/ipc_test.go
index 551d325dc1212..d02d8734b56d4 100644
--- a/go/arrow/ipc/ipc_test.go
+++ b/go/arrow/ipc/ipc_test.go
@@ -29,10 +29,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestArrow12072(t *testing.T) {
diff --git a/go/arrow/ipc/message.go b/go/arrow/ipc/message.go
index c5d0ec68d19c4..709aa5aa2dba4 100644
--- a/go/arrow/ipc/message.go
+++ b/go/arrow/ipc/message.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // MetadataVersion represents the Arrow metadata version.
diff --git a/go/arrow/ipc/message_test.go b/go/arrow/ipc/message_test.go
index cc41fdd3fe13d..912d112229f0c 100644
--- a/go/arrow/ipc/message_test.go
+++ b/go/arrow/ipc/message_test.go
@@ -22,9 +22,9 @@ import (
 	"io"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestMessageReaderBodyInAllocator(t *testing.T) {
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index 9bab47d6fa0cd..bd437834c3d06 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -23,11 +23,11 @@ import (
 	"io"
 	"sort"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	flatbuffers "github.com/google/flatbuffers/go"
 )
 
diff --git a/go/arrow/ipc/metadata_test.go b/go/arrow/ipc/metadata_test.go
index 3038abdf5f791..a35068813ba56 100644
--- a/go/arrow/ipc/metadata_test.go
+++ b/go/arrow/ipc/metadata_test.go
@@ -21,12 +21,12 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	flatbuffers "github.com/google/flatbuffers/go"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/arrow/ipc/reader.go b/go/arrow/ipc/reader.go
index 1f684c1f6c034..826062fafdb46 100644
--- a/go/arrow/ipc/reader.go
+++ b/go/arrow/ipc/reader.go
@@ -23,13 +23,13 @@ import (
 	"io"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 // Reader reads records from an io.Reader.
diff --git a/go/arrow/ipc/reader_test.go b/go/arrow/ipc/reader_test.go
index 229374e94ec74..f00f3bb3da476 100644
--- a/go/arrow/ipc/reader_test.go
+++ b/go/arrow/ipc/reader_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/ipc/stream_test.go b/go/arrow/ipc/stream_test.go
index d8bbd8f04b14d..201bfb82a5677 100644
--- a/go/arrow/ipc/stream_test.go
+++ b/go/arrow/ipc/stream_test.go
@@ -22,9 +22,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/arrdata"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/internal/arrdata"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func TestStream(t *testing.T) {
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index a97f47ef4aa43..58c56d2d16ccf 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -26,14 +26,14 @@ import (
 	"sync"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/internal/dictutils"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/dictutils"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type swriter struct {
diff --git a/go/arrow/ipc/writer_test.go b/go/arrow/ipc/writer_test.go
index da461c3d52272..ea7592554c888 100644
--- a/go/arrow/ipc/writer_test.go
+++ b/go/arrow/ipc/writer_test.go
@@ -24,11 +24,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/internal/flatbuf"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/internal/flatbuf"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/arrow/math/float64.go b/go/arrow/math/float64.go
index 81de594df6ce6..8d72ecf1b2668 100644
--- a/go/arrow/math/float64.go
+++ b/go/arrow/math/float64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Float64Funcs struct {
diff --git a/go/arrow/math/float64_avx2_amd64.go b/go/arrow/math/float64_avx2_amd64.go
index 8a131a2bc8fc5..e78d4affe9f6f 100644
--- a/go/arrow/math/float64_avx2_amd64.go
+++ b/go/arrow/math/float64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_neon_arm64.go b/go/arrow/math/float64_neon_arm64.go
index ad9b6435b26fc..a5013960d9ec7 100755
--- a/go/arrow/math/float64_neon_arm64.go
+++ b/go/arrow/math/float64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_sse4_amd64.go b/go/arrow/math/float64_sse4_amd64.go
index a2be5de43f5bb..cdd88f91c2c2b 100644
--- a/go/arrow/math/float64_sse4_amd64.go
+++ b/go/arrow/math/float64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/float64_test.go b/go/arrow/math/float64_test.go
index b10214f6d892f..3a7c247c5df8c 100644
--- a/go/arrow/math/float64_test.go
+++ b/go/arrow/math/float64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/int64.go b/go/arrow/math/int64.go
index 2adff970c2233..b8236dfbb6552 100644
--- a/go/arrow/math/int64.go
+++ b/go/arrow/math/int64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Int64Funcs struct {
diff --git a/go/arrow/math/int64_avx2_amd64.go b/go/arrow/math/int64_avx2_amd64.go
index ac0b2e1ff662a..5c16e790c1e55 100644
--- a/go/arrow/math/int64_avx2_amd64.go
+++ b/go/arrow/math/int64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_neon_arm64.go b/go/arrow/math/int64_neon_arm64.go
index 4ab5fb771a526..00ec48b6e4735 100755
--- a/go/arrow/math/int64_neon_arm64.go
+++ b/go/arrow/math/int64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_sse4_amd64.go b/go/arrow/math/int64_sse4_amd64.go
index 85304210eb448..a894bad2ef6a3 100644
--- a/go/arrow/math/int64_sse4_amd64.go
+++ b/go/arrow/math/int64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/int64_test.go b/go/arrow/math/int64_test.go
index 06b42ffe9351b..3781fd3570785 100644
--- a/go/arrow/math/int64_test.go
+++ b/go/arrow/math/int64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/type.go.tmpl b/go/arrow/math/type.go.tmpl
index 7ae142c46f12b..f1a4dfa1362f8 100644
--- a/go/arrow/math/type.go.tmpl
+++ b/go/arrow/math/type.go.tmpl
@@ -17,7 +17,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$def := .D}}
diff --git a/go/arrow/math/type_simd_amd64.go.tmpl b/go/arrow/math/type_simd_amd64.go.tmpl
index 72d40ea386a8f..77dee758b05cd 100644
--- a/go/arrow/math/type_simd_amd64.go.tmpl
+++ b/go/arrow/math/type_simd_amd64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_simd_arm64.go.tmpl b/go/arrow/math/type_simd_arm64.go.tmpl
index 72d40ea386a8f..77dee758b05cd 100755
--- a/go/arrow/math/type_simd_arm64.go.tmpl
+++ b/go/arrow/math/type_simd_arm64.go.tmpl
@@ -21,7 +21,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{$name := printf "%s_%s" .In.Type .D.arch}}
diff --git a/go/arrow/math/type_test.go.tmpl b/go/arrow/math/type_test.go.tmpl
index 160fc34e4d4d4..969377e454e52 100644
--- a/go/arrow/math/type_test.go.tmpl
+++ b/go/arrow/math/type_test.go.tmpl
@@ -19,9 +19,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/math/uint64.go b/go/arrow/math/uint64.go
index 64ac63a3d1853..b9a70360224ea 100644
--- a/go/arrow/math/uint64.go
+++ b/go/arrow/math/uint64.go
@@ -19,7 +19,7 @@
 package math
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 type Uint64Funcs struct {
diff --git a/go/arrow/math/uint64_avx2_amd64.go b/go/arrow/math/uint64_avx2_amd64.go
index 2a35bebc980b3..c1f48efefd8eb 100644
--- a/go/arrow/math/uint64_avx2_amd64.go
+++ b/go/arrow/math/uint64_avx2_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_neon_arm64.go b/go/arrow/math/uint64_neon_arm64.go
index f6588694bb1fd..37ca4ecad04e7 100755
--- a/go/arrow/math/uint64_neon_arm64.go
+++ b/go/arrow/math/uint64_neon_arm64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_sse4_amd64.go b/go/arrow/math/uint64_sse4_amd64.go
index 8c6621464f118..7163c1de171de 100644
--- a/go/arrow/math/uint64_sse4_amd64.go
+++ b/go/arrow/math/uint64_sse4_amd64.go
@@ -24,7 +24,7 @@ package math
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 //go:noescape
diff --git a/go/arrow/math/uint64_test.go b/go/arrow/math/uint64_test.go
index aac768e599cf8..e8ba42b59aa10 100644
--- a/go/arrow/math/uint64_test.go
+++ b/go/arrow/math/uint64_test.go
@@ -21,9 +21,9 @@ package math_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/math"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/math"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/buffer.go b/go/arrow/memory/buffer.go
index 5a2b4297031f0..ffdb41e3dbe9e 100644
--- a/go/arrow/memory/buffer.go
+++ b/go/arrow/memory/buffer.go
@@ -19,7 +19,7 @@ package memory
 import (
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Buffer is a wrapper type for a buffer of bytes.
diff --git a/go/arrow/memory/buffer_test.go b/go/arrow/memory/buffer_test.go
index 25a0b39848519..92bb071d0abde 100644
--- a/go/arrow/memory/buffer_test.go
+++ b/go/arrow/memory/buffer_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/cgo_allocator.go b/go/arrow/memory/cgo_allocator.go
index 85ee445216f6a..af25d1899a6fe 100644
--- a/go/arrow/memory/cgo_allocator.go
+++ b/go/arrow/memory/cgo_allocator.go
@@ -22,7 +22,7 @@ package memory
 import (
 	"runtime"
 
-	cga "github.com/apache/arrow/go/v14/arrow/memory/internal/cgoalloc"
+	cga "github.com/apache/arrow/go/v15/arrow/memory/internal/cgoalloc"
 )
 
 // CgoArrowAllocator is an allocator which exposes the C++ memory pool class
diff --git a/go/arrow/memory/default_mallocator.go b/go/arrow/memory/default_mallocator.go
index 12ad0846677b1..4a9ef942fd08d 100644
--- a/go/arrow/memory/default_mallocator.go
+++ b/go/arrow/memory/default_mallocator.go
@@ -19,7 +19,7 @@
 package memory
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 )
 
 // DefaultAllocator is a default implementation of Allocator and can be used anywhere
diff --git a/go/arrow/memory/default_mallocator_test.go b/go/arrow/memory/default_mallocator_test.go
index b209ced68a067..5a38e8b4e843c 100644
--- a/go/arrow/memory/default_mallocator_test.go
+++ b/go/arrow/memory/default_mallocator_test.go
@@ -21,8 +21,8 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/mallocator/mallocator_test.go b/go/arrow/memory/mallocator/mallocator_test.go
index 5b09355033f70..91b74383ed494 100644
--- a/go/arrow/memory/mallocator/mallocator_test.go
+++ b/go/arrow/memory/mallocator/mallocator_test.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory/mallocator"
+	"github.com/apache/arrow/go/v15/arrow/memory/mallocator"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/memory/memory_test.go b/go/arrow/memory/memory_test.go
index dff2e0bfd0712..adaa8359369be 100644
--- a/go/arrow/memory/memory_test.go
+++ b/go/arrow/memory/memory_test.go
@@ -19,7 +19,7 @@ package memory_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/record.go b/go/arrow/record.go
index d98c7732ef798..885af38034938 100644
--- a/go/arrow/record.go
+++ b/go/arrow/record.go
@@ -16,7 +16,7 @@
 
 package arrow
 
-import "github.com/apache/arrow/go/v14/internal/json"
+import "github.com/apache/arrow/go/v15/internal/json"
 
 // Record is a collection of equal-length arrays matching a particular Schema.
 // Also known as a RecordBatch in the spec and in some implementations.
diff --git a/go/arrow/scalar/append.go b/go/arrow/scalar/append.go
index 9bcfe3e22dc63..fe8dd32e9eae5 100644
--- a/go/arrow/scalar/append.go
+++ b/go/arrow/scalar/append.go
@@ -21,11 +21,11 @@ package scalar
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"golang.org/x/exp/constraints"
 )
 
diff --git a/go/arrow/scalar/append_test.go b/go/arrow/scalar/append_test.go
index 497a6a2d02933..e509bca1fb7b0 100644
--- a/go/arrow/scalar/append_test.go
+++ b/go/arrow/scalar/append_test.go
@@ -23,11 +23,11 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/testing/tools"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/testing/tools"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/binary.go b/go/arrow/scalar/binary.go
index 3c041210fde9c..b6abe9cba7b1c 100644
--- a/go/arrow/scalar/binary.go
+++ b/go/arrow/scalar/binary.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type BinaryScalar interface {
diff --git a/go/arrow/scalar/compare.go b/go/arrow/scalar/compare.go
index be7fa4d01cc19..b4a3fe08d26fe 100644
--- a/go/arrow/scalar/compare.go
+++ b/go/arrow/scalar/compare.go
@@ -16,7 +16,7 @@
 
 package scalar
 
-import "github.com/apache/arrow/go/v14/arrow"
+import "github.com/apache/arrow/go/v15/arrow"
 
 // Equals returns true if two scalars are equal, which means they have the same
 // datatype, validity and value.
diff --git a/go/arrow/scalar/nested.go b/go/arrow/scalar/nested.go
index 87e84210f58a1..8250beb5ed90d 100644
--- a/go/arrow/scalar/nested.go
+++ b/go/arrow/scalar/nested.go
@@ -21,10 +21,10 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/numeric.gen.go b/go/arrow/scalar/numeric.gen.go
index 90ae2a7004ce3..da088162f4017 100644
--- a/go/arrow/scalar/numeric.gen.go
+++ b/go/arrow/scalar/numeric.gen.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
 )
 
 type Int8 struct {
diff --git a/go/arrow/scalar/numeric.gen_test.go b/go/arrow/scalar/numeric.gen_test.go
index 987cd66c75f3c..807857c1c98c2 100644
--- a/go/arrow/scalar/numeric.gen_test.go
+++ b/go/arrow/scalar/numeric.gen_test.go
@@ -21,8 +21,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/numeric.gen_test.go.tmpl b/go/arrow/scalar/numeric.gen_test.go.tmpl
index c975cc9db6e1c..7f45898a20d29 100644
--- a/go/arrow/scalar/numeric.gen_test.go.tmpl
+++ b/go/arrow/scalar/numeric.gen_test.go.tmpl
@@ -19,8 +19,8 @@ package scalar_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/scalar/parse.go b/go/arrow/scalar/parse.go
index fcffe1ea6adf8..5002f98a65c42 100644
--- a/go/arrow/scalar/parse.go
+++ b/go/arrow/scalar/parse.go
@@ -25,12 +25,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 type TypeToScalar interface {
diff --git a/go/arrow/scalar/scalar.go b/go/arrow/scalar/scalar.go
index 395771fa89c94..8b0d3ace2ad78 100644
--- a/go/arrow/scalar/scalar.go
+++ b/go/arrow/scalar/scalar.go
@@ -26,16 +26,16 @@ import (
 	"strconv"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/encoded"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/float16"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/encoded"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/arrow/scalar/scalar_test.go b/go/arrow/scalar/scalar_test.go
index 405571a14880d..ce8170301b0a2 100644
--- a/go/arrow/scalar/scalar_test.go
+++ b/go/arrow/scalar/scalar_test.go
@@ -25,12 +25,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/scalar"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/scalar"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/arrow/scalar/temporal.go b/go/arrow/scalar/temporal.go
index 880416f7dd5a3..ee13c84429e8e 100644
--- a/go/arrow/scalar/temporal.go
+++ b/go/arrow/scalar/temporal.go
@@ -22,7 +22,7 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func temporalToString(s TemporalScalar) string {
diff --git a/go/arrow/schema.go b/go/arrow/schema.go
index a7fa434131925..e84f350a53637 100644
--- a/go/arrow/schema.go
+++ b/go/arrow/schema.go
@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 type Metadata struct {
diff --git a/go/arrow/schema_test.go b/go/arrow/schema_test.go
index 5e79723f90352..fddf1d7f131ec 100644
--- a/go/arrow/schema_test.go
+++ b/go/arrow/schema_test.go
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/arrow/table.go b/go/arrow/table.go
index 5a68085f8df93..82dc283706b65 100644
--- a/go/arrow/table.go
+++ b/go/arrow/table.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Table represents a logical sequence of chunked arrays of equal length. It is
diff --git a/go/arrow/tensor/numeric.gen.go b/go/arrow/tensor/numeric.gen.go
index 5b7bbde150fe2..d207f0bfa2c9c 100644
--- a/go/arrow/tensor/numeric.gen.go
+++ b/go/arrow/tensor/numeric.gen.go
@@ -19,7 +19,7 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 // Int8 is an n-dim array of int8s.
diff --git a/go/arrow/tensor/numeric.gen.go.tmpl b/go/arrow/tensor/numeric.gen.go.tmpl
index c693082192247..e03f986da3f8f 100644
--- a/go/arrow/tensor/numeric.gen.go.tmpl
+++ b/go/arrow/tensor/numeric.gen.go.tmpl
@@ -17,8 +17,8 @@
 package tensor
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/numeric.gen_test.go b/go/arrow/tensor/numeric.gen_test.go
index 00922a84b6b03..3a7c3570c216b 100644
--- a/go/arrow/tensor/numeric.gen_test.go
+++ b/go/arrow/tensor/numeric.gen_test.go
@@ -23,10 +23,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 func TestTensorInt8(t *testing.T) {
diff --git a/go/arrow/tensor/numeric.gen_test.go.tmpl b/go/arrow/tensor/numeric.gen_test.go.tmpl
index 665bb8dc68da9..34f01b40d8084 100644
--- a/go/arrow/tensor/numeric.gen_test.go.tmpl
+++ b/go/arrow/tensor/numeric.gen_test.go.tmpl
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 {{range .In}}
diff --git a/go/arrow/tensor/tensor.go b/go/arrow/tensor/tensor.go
index 27c380345a498..1f2ed7e82141b 100644
--- a/go/arrow/tensor/tensor.go
+++ b/go/arrow/tensor/tensor.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 // Interface represents an n-dimensional array of numerical data.
diff --git a/go/arrow/tensor/tensor_test.go b/go/arrow/tensor/tensor_test.go
index 4cfe69f780421..552c4c1c223e0 100644
--- a/go/arrow/tensor/tensor_test.go
+++ b/go/arrow/tensor/tensor_test.go
@@ -21,10 +21,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/tensor"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/tensor"
 )
 
 func TestTensor(t *testing.T) {
diff --git a/go/arrow/type_traits_boolean.go b/go/arrow/type_traits_boolean.go
index 6a46bdec702ff..c164d45954fc0 100644
--- a/go/arrow/type_traits_boolean.go
+++ b/go/arrow/type_traits_boolean.go
@@ -17,7 +17,7 @@
 package arrow
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 type booleanTraits struct{}
diff --git a/go/arrow/type_traits_decimal128.go b/go/arrow/type_traits_decimal128.go
index d2d3aae371663..f573ad3c65a4c 100644
--- a/go/arrow/type_traits_decimal128.go
+++ b/go/arrow/type_traits_decimal128.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 // Decimal128 traits
diff --git a/go/arrow/type_traits_decimal256.go b/go/arrow/type_traits_decimal256.go
index 256ed68fffc8d..adf3cc3e0bc31 100644
--- a/go/arrow/type_traits_decimal256.go
+++ b/go/arrow/type_traits_decimal256.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 // Decimal256 traits
diff --git a/go/arrow/type_traits_float16.go b/go/arrow/type_traits_float16.go
index c40363d3785da..e59efd4c248d8 100644
--- a/go/arrow/type_traits_float16.go
+++ b/go/arrow/type_traits_float16.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 )
 
 // Float16 traits
diff --git a/go/arrow/type_traits_interval.go b/go/arrow/type_traits_interval.go
index 35e6057090f10..5fbd7a5248918 100644
--- a/go/arrow/type_traits_interval.go
+++ b/go/arrow/type_traits_interval.go
@@ -20,8 +20,8 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go b/go/arrow/type_traits_numeric.gen.go
index 6edd75291155c..57606c0fce6df 100644
--- a/go/arrow/type_traits_numeric.gen.go
+++ b/go/arrow/type_traits_numeric.gen.go
@@ -23,7 +23,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen.go.tmpl b/go/arrow/type_traits_numeric.gen.go.tmpl
index ffae975c1aa15..c491047b51429 100644
--- a/go/arrow/type_traits_numeric.gen.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen.go.tmpl
@@ -21,7 +21,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var (
diff --git a/go/arrow/type_traits_numeric.gen_test.go b/go/arrow/type_traits_numeric.gen_test.go
index 74395485736ff..ac2d0726ed6fa 100644
--- a/go/arrow/type_traits_numeric.gen_test.go
+++ b/go/arrow/type_traits_numeric.gen_test.go
@@ -22,7 +22,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func TestInt64Traits(t *testing.T) {
diff --git a/go/arrow/type_traits_numeric.gen_test.go.tmpl b/go/arrow/type_traits_numeric.gen_test.go.tmpl
index 96685f31327bd..4948f42cf542e 100644
--- a/go/arrow/type_traits_numeric.gen_test.go.tmpl
+++ b/go/arrow/type_traits_numeric.gen_test.go.tmpl
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 {{- range .In}}
diff --git a/go/arrow/type_traits_test.go b/go/arrow/type_traits_test.go
index 85ad4da9d041d..0ae88b4bd82b6 100644
--- a/go/arrow/type_traits_test.go
+++ b/go/arrow/type_traits_test.go
@@ -22,10 +22,10 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/float16"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 )
 
 func TestBooleanTraits(t *testing.T) {
diff --git a/go/arrow/type_traits_timestamp.go b/go/arrow/type_traits_timestamp.go
index 7c393b3559f82..c1a9aba3db386 100644
--- a/go/arrow/type_traits_timestamp.go
+++ b/go/arrow/type_traits_timestamp.go
@@ -20,7 +20,7 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/endian"
 )
 
 var TimestampTraits timestampTraits
diff --git a/go/arrow/util/byte_size.go b/go/arrow/util/byte_size.go
index 141b78c459119..6d6fc021f8005 100644
--- a/go/arrow/util/byte_size.go
+++ b/go/arrow/util/byte_size.go
@@ -17,9 +17,9 @@
 package util
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 )
 
 func isArrayDataNil(arrayData arrow.ArrayData) bool {
diff --git a/go/arrow/util/byte_size_test.go b/go/arrow/util/byte_size_test.go
index 052bf3adee158..a218c69558fe9 100644
--- a/go/arrow/util/byte_size_test.go
+++ b/go/arrow/util/byte_size_test.go
@@ -20,10 +20,10 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/arrow/util"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow/util"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/go.mod b/go/go.mod
index de73c210d159d..a6c2af7025d32 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -14,7 +14,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-module github.com/apache/arrow/go/v14
+module github.com/apache/arrow/go/v15
 
 go 1.20
 
diff --git a/go/internal/bitutils/bit_block_counter.go b/go/internal/bitutils/bit_block_counter.go
index 86818bfd45ab7..99eece34cd068 100644
--- a/go/internal/bitutils/bit_block_counter.go
+++ b/go/internal/bitutils/bit_block_counter.go
@@ -21,8 +21,8 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 func loadWord(byt []byte) uint64 {
diff --git a/go/internal/bitutils/bit_block_counter_test.go b/go/internal/bitutils/bit_block_counter_test.go
index ad5e989d1fa65..790105c290182 100644
--- a/go/internal/bitutils/bit_block_counter_test.go
+++ b/go/internal/bitutils/bit_block_counter_test.go
@@ -19,9 +19,9 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/exp/rand"
 )
diff --git a/go/internal/bitutils/bit_run_reader.go b/go/internal/bitutils/bit_run_reader.go
index a1686a4909b8b..f09149d7ec5df 100644
--- a/go/internal/bitutils/bit_run_reader.go
+++ b/go/internal/bitutils/bit_run_reader.go
@@ -22,9 +22,9 @@ import (
 	"math/bits"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // BitRun represents a run of bits with the same value of length Len
diff --git a/go/internal/bitutils/bit_run_reader_test.go b/go/internal/bitutils/bit_run_reader_test.go
index 0e1500bff811a..7db76768a9476 100644
--- a/go/internal/bitutils/bit_run_reader_test.go
+++ b/go/internal/bitutils/bit_run_reader_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/internal/bitutils/bit_set_run_reader.go b/go/internal/bitutils/bit_set_run_reader.go
index a2269ffecb870..6764ca7912679 100644
--- a/go/internal/bitutils/bit_set_run_reader.go
+++ b/go/internal/bitutils/bit_set_run_reader.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // IsMultipleOf64 returns whether v is a multiple of 64.
diff --git a/go/internal/bitutils/bit_set_run_reader_test.go b/go/internal/bitutils/bit_set_run_reader_test.go
index 205954b3800a8..832993671ef6d 100644
--- a/go/internal/bitutils/bit_set_run_reader_test.go
+++ b/go/internal/bitutils/bit_set_run_reader_test.go
@@ -20,9 +20,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/internal/bitutils/bitmap_generate.go b/go/internal/bitutils/bitmap_generate.go
index 78219d8120bcc..08b5fceab57d3 100644
--- a/go/internal/bitutils/bitmap_generate.go
+++ b/go/internal/bitutils/bitmap_generate.go
@@ -16,7 +16,7 @@
 
 package bitutils
 
-import "github.com/apache/arrow/go/v14/arrow/bitutil"
+import "github.com/apache/arrow/go/v15/arrow/bitutil"
 
 // GenerateBits writes sequential bits to a bitmap. Bits preceding the
 // initial start offset are preserved, bits following the bitmap may
diff --git a/go/internal/bitutils/bitmap_generate_test.go b/go/internal/bitutils/bitmap_generate_test.go
index 788b2198c3a78..c9a6203864a20 100644
--- a/go/internal/bitutils/bitmap_generate_test.go
+++ b/go/internal/bitutils/bitmap_generate_test.go
@@ -19,7 +19,7 @@ package bitutils_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go b/go/internal/hashing/xxh3_memo_table.gen.go
index cc996552b49e5..39b82cdeff9a2 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go
+++ b/go/internal/hashing/xxh3_memo_table.gen.go
@@ -21,9 +21,9 @@ package hashing
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 type payloadInt8 struct {
diff --git a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
index 25164341d227e..527008ad63c3c 100644
--- a/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
+++ b/go/internal/hashing/xxh3_memo_table.gen.go.tmpl
@@ -17,8 +17,8 @@
 package hashing
 
 import (
-  "github.com/apache/arrow/go/v14/arrow/bitutil"  
-  "github.com/apache/arrow/go/v14/internal/utils"  
+  "github.com/apache/arrow/go/v15/arrow/bitutil"  
+  "github.com/apache/arrow/go/v15/internal/utils"  
 )
 
 {{range .In}}
diff --git a/go/internal/types/extension_types.go b/go/internal/types/extension_types.go
index 1a31014874bbe..e24c89efc7b8b 100644
--- a/go/internal/types/extension_types.go
+++ b/go/internal/types/extension_types.go
@@ -24,9 +24,9 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/internal/json"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/internal/json"
 	"github.com/google/uuid"
 	"golang.org/x/xerrors"
 )
diff --git a/go/internal/types/extension_types_test.go b/go/internal/types/extension_types_test.go
index 16273890b4c9c..f93f1000c9e4a 100644
--- a/go/internal/types/extension_types_test.go
+++ b/go/internal/types/extension_types_test.go
@@ -20,11 +20,11 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/internal/utils/transpose_ints_def.go b/go/internal/utils/transpose_ints_def.go
index cc3b0abb59363..c52598d7148ea 100644
--- a/go/internal/utils/transpose_ints_def.go
+++ b/go/internal/utils/transpose_ints_def.go
@@ -19,7 +19,7 @@ package utils
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl -i -data=transpose_ints.tmpldata -d arch=avx2 transpose_ints_simd.go.tmpl=transpose_ints_avx2_amd64.go
diff --git a/go/internal/utils/transpose_ints_test.go b/go/internal/utils/transpose_ints_test.go
index e41b61156abdc..73b2bbce3fc14 100644
--- a/go/internal/utils/transpose_ints_test.go
+++ b/go/internal/utils/transpose_ints_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 var (
diff --git a/go/parquet/cmd/parquet_reader/dumper.go b/go/parquet/cmd/parquet_reader/dumper.go
index a04dcf23b2d8d..4cb2ea4a96fee 100644
--- a/go/parquet/cmd/parquet_reader/dumper.go
+++ b/go/parquet/cmd/parquet_reader/dumper.go
@@ -22,9 +22,9 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 const defaultBatchSize = 128
diff --git a/go/parquet/cmd/parquet_reader/main.go b/go/parquet/cmd/parquet_reader/main.go
index e7d1cd7fc5a7d..0d651d8c294c5 100644
--- a/go/parquet/cmd/parquet_reader/main.go
+++ b/go/parquet/cmd/parquet_reader/main.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 
 	"github.com/docopt/docopt-go"
 )
diff --git a/go/parquet/cmd/parquet_schema/main.go b/go/parquet/cmd/parquet_schema/main.go
index 28d1288b54aeb..01d541e8ac925 100644
--- a/go/parquet/cmd/parquet_schema/main.go
+++ b/go/parquet/cmd/parquet_schema/main.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/docopt/docopt-go"
 )
 
diff --git a/go/parquet/compress/brotli.go b/go/parquet/compress/brotli.go
index 1c1ae1dffaca5..a1199d9711435 100644
--- a/go/parquet/compress/brotli.go
+++ b/go/parquet/compress/brotli.go
@@ -21,7 +21,7 @@ import (
 	"io"
 
 	"github.com/andybalholm/brotli"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 )
 
 type brotliCodec struct{}
diff --git a/go/parquet/compress/compress.go b/go/parquet/compress/compress.go
index 4c4c792c2f614..f61147eb1ea10 100644
--- a/go/parquet/compress/compress.go
+++ b/go/parquet/compress/compress.go
@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Compression is an alias to the thrift compression codec enum type for easy use
diff --git a/go/parquet/compress/compress_test.go b/go/parquet/compress/compress_test.go
index e8041a64c0996..d1c55b15bc3cc 100644
--- a/go/parquet/compress/compress_test.go
+++ b/go/parquet/compress/compress_test.go
@@ -22,7 +22,7 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/compress/zstd.go b/go/parquet/compress/zstd.go
index 129af62807175..fd8ec81953359 100644
--- a/go/parquet/compress/zstd.go
+++ b/go/parquet/compress/zstd.go
@@ -20,7 +20,7 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 	"github.com/klauspost/compress/zstd"
 )
 
diff --git a/go/parquet/doc.go b/go/parquet/doc.go
index 99a605a284fae..afeee00587ef5 100644
--- a/go/parquet/doc.go
+++ b/go/parquet/doc.go
@@ -29,9 +29,9 @@
 // Install
 //
 // You can download the library and cli utilities via:
-//   go get -u github.com/apache/arrow/go/v14/parquet
-//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_reader@latest
-//   go install github.com/apache/arrow/go/v14/parquet/cmd/parquet_schema@latest
+//   go get -u github.com/apache/arrow/go/v15/parquet
+//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_reader@latest
+//   go install github.com/apache/arrow/go/v15/parquet/cmd/parquet_schema@latest
 //
 // Modules
 //
diff --git a/go/parquet/encryption_properties.go b/go/parquet/encryption_properties.go
index dd85a856820fe..6eb6cf1fe5680 100644
--- a/go/parquet/encryption_properties.go
+++ b/go/parquet/encryption_properties.go
@@ -20,7 +20,7 @@ import (
 	"crypto/rand"
 	"unicode/utf8"
 
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Constants that will be used as the default values with encryption/decryption
diff --git a/go/parquet/encryption_properties_test.go b/go/parquet/encryption_properties_test.go
index 0b1118a5cfa66..ab028927c5ecb 100644
--- a/go/parquet/encryption_properties_test.go
+++ b/go/parquet/encryption_properties_test.go
@@ -19,8 +19,8 @@ package parquet_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/encryption_read_config_test.go b/go/parquet/encryption_read_config_test.go
index 8a84c19900dd0..53b7ba3c621c0 100644
--- a/go/parquet/encryption_read_config_test.go
+++ b/go/parquet/encryption_read_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/encryption_write_config_test.go b/go/parquet/encryption_write_config_test.go
index 6b2d049e1390c..558b89208c706 100644
--- a/go/parquet/encryption_write_config_test.go
+++ b/go/parquet/encryption_write_config_test.go
@@ -23,10 +23,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/file/column_reader.go b/go/parquet/file/column_reader.go
index b623bd5074d02..766638d88f26c 100644
--- a/go/parquet/file/column_reader.go
+++ b/go/parquet/file/column_reader.go
@@ -21,13 +21,13 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_reader_test.go b/go/parquet/file/column_reader_test.go
index 3ce05c6cfe47e..21ea52e2b7bbc 100755
--- a/go/parquet/file/column_reader_test.go
+++ b/go/parquet/file/column_reader_test.go
@@ -24,12 +24,12 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/file/column_reader_types.gen.go b/go/parquet/file/column_reader_types.gen.go
index 31dccc157642f..3fb113780f811 100644
--- a/go/parquet/file/column_reader_types.gen.go
+++ b/go/parquet/file/column_reader_types.gen.go
@@ -21,9 +21,9 @@ package file
 import (
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 // Int32ColumnChunkReader is the Typed Column chunk reader instance for reading
diff --git a/go/parquet/file/column_reader_types.gen.go.tmpl b/go/parquet/file/column_reader_types.gen.go.tmpl
index 6557963e69f50..261b5f0bfacab 100644
--- a/go/parquet/file/column_reader_types.gen.go.tmpl
+++ b/go/parquet/file/column_reader_types.gen.go.tmpl
@@ -17,8 +17,8 @@
 package file
 
 import (
-    "github.com/apache/arrow/go/v14/parquet"
-    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
+    "github.com/apache/arrow/go/v15/parquet"
+    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/column_writer.go b/go/parquet/file/column_writer.go
index 9d9111042df28..0b0d1145d604e 100755
--- a/go/parquet/file/column_writer.go
+++ b/go/parquet/file/column_writer.go
@@ -21,14 +21,14 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata column_writer_types.gen.go.tmpl
diff --git a/go/parquet/file/column_writer_test.go b/go/parquet/file/column_writer_test.go
index e2ae6b0f4a71e..134c290fa6894 100755
--- a/go/parquet/file/column_writer_test.go
+++ b/go/parquet/file/column_writer_test.go
@@ -24,19 +24,19 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	arrutils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	arrutils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/column_writer_types.gen.go b/go/parquet/file/column_writer_types.gen.go
index 5594f63249fb8..8b3be25f3ea29 100644
--- a/go/parquet/file/column_writer_types.gen.go
+++ b/go/parquet/file/column_writer_types.gen.go
@@ -22,12 +22,12 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/column_writer_types.gen.go.tmpl b/go/parquet/file/column_writer_types.gen.go.tmpl
index c00e1dabb5fe6..7df69b4a219c6 100644
--- a/go/parquet/file/column_writer_types.gen.go.tmpl
+++ b/go/parquet/file/column_writer_types.gen.go.tmpl
@@ -19,10 +19,10 @@ package file
 import (
     "fmt"
     
-    "github.com/apache/arrow/go/v14/parquet"
-    "github.com/apache/arrow/go/v14/parquet/metadata"
-    "github.com/apache/arrow/go/v14/parquet/internal/encoding"
-    format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+    "github.com/apache/arrow/go/v15/parquet"
+    "github.com/apache/arrow/go/v15/parquet/metadata"
+    "github.com/apache/arrow/go/v15/parquet/internal/encoding"
+    format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 {{range .In}}
diff --git a/go/parquet/file/file_reader.go b/go/parquet/file/file_reader.go
index 5481d5c7738b0..afff579ded5b7 100644
--- a/go/parquet/file/file_reader.go
+++ b/go/parquet/file/file_reader.go
@@ -25,10 +25,10 @@ import (
 	"runtime"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/file_reader_mmap.go b/go/parquet/file/file_reader_mmap.go
index 89c5a84cee2e1..03e12adf08c8c 100644
--- a/go/parquet/file/file_reader_mmap.go
+++ b/go/parquet/file/file_reader_mmap.go
@@ -22,7 +22,7 @@ package file
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/exp/mmap"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/file_reader_mmap_windows.go b/go/parquet/file/file_reader_mmap_windows.go
index 6b08422163fd1..06a9e97160fe0 100644
--- a/go/parquet/file/file_reader_mmap_windows.go
+++ b/go/parquet/file/file_reader_mmap_windows.go
@@ -22,7 +22,7 @@ package file
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 func mmapOpen(filename string) (parquet.ReaderAtSeeker, error) {
diff --git a/go/parquet/file/file_reader_test.go b/go/parquet/file/file_reader_test.go
index 2a9b097139062..f3248925cf5b9 100644
--- a/go/parquet/file/file_reader_test.go
+++ b/go/parquet/file/file_reader_test.go
@@ -25,16 +25,16 @@ import (
 	"path"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index c6289434bbe6e..48eb8f44d167b 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 // Writer is the primary interface for writing a parquet file
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index af083ebe60e4f..beceff9732584 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -22,13 +22,13 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/file/level_conversion.go b/go/parquet/file/level_conversion.go
index ac53dcd18abae..c23bdda445963 100755
--- a/go/parquet/file/level_conversion.go
+++ b/go/parquet/file/level_conversion.go
@@ -22,11 +22,11 @@ import (
 	"math/bits"
 	"unsafe"
 
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/level_conversion_test.go b/go/parquet/file/level_conversion_test.go
index 343edb687980d..5d5bdde90dc7e 100644
--- a/go/parquet/file/level_conversion_test.go
+++ b/go/parquet/file/level_conversion_test.go
@@ -20,9 +20,9 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/file/page_reader.go b/go/parquet/file/page_reader.go
index ab8679b127f1b..01f253aff8864 100644
--- a/go/parquet/file/page_reader.go
+++ b/go/parquet/file/page_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/page_writer.go b/go/parquet/file/page_writer.go
index b2b6d5061b0fc..c16476fbb232c 100644
--- a/go/parquet/file/page_writer.go
+++ b/go/parquet/file/page_writer.go
@@ -20,15 +20,15 @@ import (
 	"bytes"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	libthrift "github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/file/record_reader.go b/go/parquet/file/record_reader.go
index 3311a6d77da39..ad836d29ef483 100755
--- a/go/parquet/file/record_reader.go
+++ b/go/parquet/file/record_reader.go
@@ -23,14 +23,14 @@ import (
 	"unsafe"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_reader.go b/go/parquet/file/row_group_reader.go
index f1aebf1085a23..3c1c1edb0b484 100644
--- a/go/parquet/file/row_group_reader.go
+++ b/go/parquet/file/row_group_reader.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer.go b/go/parquet/file/row_group_writer.go
index 75f0dede5246f..935c13d13a67f 100644
--- a/go/parquet/file/row_group_writer.go
+++ b/go/parquet/file/row_group_writer.go
@@ -17,10 +17,10 @@
 package file
 
 import (
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/file/row_group_writer_test.go b/go/parquet/file/row_group_writer_test.go
index bc95e99d91582..2ea317cb91001 100644
--- a/go/parquet/file/row_group_writer_test.go
+++ b/go/parquet/file/row_group_writer_test.go
@@ -20,10 +20,10 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 )
diff --git a/go/parquet/internal/bmi/bmi_test.go b/go/parquet/internal/bmi/bmi_test.go
index 460c6ec4e24c6..a5278dfef2211 100644
--- a/go/parquet/internal/bmi/bmi_test.go
+++ b/go/parquet/internal/bmi/bmi_test.go
@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	"github.com/apache/arrow/go/v15/parquet/internal/bmi"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/boolean_decoder.go b/go/parquet/internal/encoding/boolean_decoder.go
index 337a6db967a2e..3782dc85ea814 100644
--- a/go/parquet/internal/encoding/boolean_decoder.go
+++ b/go/parquet/internal/encoding/boolean_decoder.go
@@ -23,10 +23,10 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 // PlainBooleanDecoder is for the Plain Encoding type, there is no
diff --git a/go/parquet/internal/encoding/boolean_encoder.go b/go/parquet/internal/encoding/boolean_encoder.go
index 3970e05fca289..3e01bde369d8b 100644
--- a/go/parquet/internal/encoding/boolean_encoder.go
+++ b/go/parquet/internal/encoding/boolean_encoder.go
@@ -19,10 +19,10 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/byte_array_decoder.go b/go/parquet/internal/encoding/byte_array_decoder.go
index c3ca1de5888f7..82ce9f84265c5 100644
--- a/go/parquet/internal/encoding/byte_array_decoder.go
+++ b/go/parquet/internal/encoding/byte_array_decoder.go
@@ -19,12 +19,12 @@ package encoding
 import (
 	"encoding/binary"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	pqutils "github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	pqutils "github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/byte_array_encoder.go b/go/parquet/internal/encoding/byte_array_encoder.go
index cb49178435a6f..9270b5531768c 100644
--- a/go/parquet/internal/encoding/byte_array_encoder.go
+++ b/go/parquet/internal/encoding/byte_array_encoder.go
@@ -21,11 +21,11 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // PlainByteArrayEncoder encodes byte arrays according to the spec for Plain encoding
diff --git a/go/parquet/internal/encoding/decoder.go b/go/parquet/internal/encoding/decoder.go
index b441868e1df85..cee624730e993 100644
--- a/go/parquet/internal/encoding/decoder.go
+++ b/go/parquet/internal/encoding/decoder.go
@@ -20,16 +20,16 @@ import (
 	"bytes"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_bit_packing.go b/go/parquet/internal/encoding/delta_bit_packing.go
index 1fb91634e977b..a00f3457cac7a 100644
--- a/go/parquet/internal/encoding/delta_bit_packing.go
+++ b/go/parquet/internal/encoding/delta_bit_packing.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 )
 
 // see the deltaBitPack encoder for a description of the encoding format that is
diff --git a/go/parquet/internal/encoding/delta_byte_array.go b/go/parquet/internal/encoding/delta_byte_array.go
index 60a20a3ff0d72..b35d022fd5deb 100644
--- a/go/parquet/internal/encoding/delta_byte_array.go
+++ b/go/parquet/internal/encoding/delta_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/delta_byte_array_test.go b/go/parquet/internal/encoding/delta_byte_array_test.go
index 69c632bf69971..0a206796f742a 100644
--- a/go/parquet/internal/encoding/delta_byte_array_test.go
+++ b/go/parquet/internal/encoding/delta_byte_array_test.go
@@ -18,8 +18,8 @@ package encoding
 
 import (
 	"fmt"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 	"github.com/stretchr/testify/assert"
 	"testing"
 )
diff --git a/go/parquet/internal/encoding/delta_length_byte_array.go b/go/parquet/internal/encoding/delta_length_byte_array.go
index 981a067b07e08..d5a99c187d11e 100644
--- a/go/parquet/internal/encoding/delta_length_byte_array.go
+++ b/go/parquet/internal/encoding/delta_length_byte_array.go
@@ -17,9 +17,9 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/encoder.go b/go/parquet/internal/encoding/encoder.go
index f6b57fe63c433..7023309397a3b 100644
--- a/go/parquet/internal/encoding/encoder.go
+++ b/go/parquet/internal/encoding/encoder.go
@@ -21,14 +21,14 @@ import (
 	"math/bits"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata plain_encoder_types.gen.go.tmpl typed_encoder.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/encoding_benchmarks_test.go b/go/parquet/internal/encoding/encoding_benchmarks_test.go
index 0bb4e895f316d..e0645e9de54e4 100644
--- a/go/parquet/internal/encoding/encoding_benchmarks_test.go
+++ b/go/parquet/internal/encoding/encoding_benchmarks_test.go
@@ -21,14 +21,14 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 const (
diff --git a/go/parquet/internal/encoding/encoding_test.go b/go/parquet/internal/encoding/encoding_test.go
index b0d86321e09f1..48e2316b0f897 100644
--- a/go/parquet/internal/encoding/encoding_test.go
+++ b/go/parquet/internal/encoding/encoding_test.go
@@ -26,13 +26,13 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
index e4516bf4a1ac1..1e589fc2e7be1 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_decoder.go
@@ -19,8 +19,8 @@ package encoding
 import (
 	"math"
 
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
index b5aee337d5bf0..39202c8e25d9f 100644
--- a/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
+++ b/go/parquet/internal/encoding/fixed_len_byte_array_encoder.go
@@ -19,9 +19,9 @@ package encoding
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // PlainFixedLenByteArrayEncoder writes the raw bytes of the byte array
diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index e04ec19d5473d..caf832059334b 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -23,11 +23,11 @@ import (
 	"math/bits"
 
 	"github.com/JohnCGriffin/overflow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/levels_test.go b/go/parquet/internal/encoding/levels_test.go
index ae3a3a8c497fc..304ce32b3106d 100644
--- a/go/parquet/internal/encoding/levels_test.go
+++ b/go/parquet/internal/encoding/levels_test.go
@@ -21,11 +21,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table.go b/go/parquet/internal/encoding/memo_table.go
index 170eab47d6160..810e8633b886e 100644
--- a/go/parquet/internal/encoding/memo_table.go
+++ b/go/parquet/internal/encoding/memo_table.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 //go:generate go run ../../../arrow/_tools/tmpl/main.go -i -data=physical_types.tmpldata memo_table_types.gen.go.tmpl
diff --git a/go/parquet/internal/encoding/memo_table_test.go b/go/parquet/internal/encoding/memo_table_test.go
index 1eb61cb2559a3..1b9337010f855 100644
--- a/go/parquet/internal/encoding/memo_table_test.go
+++ b/go/parquet/internal/encoding/memo_table_test.go
@@ -20,11 +20,11 @@ import (
 	"math"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/hashing"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/hashing"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go b/go/parquet/internal/encoding/memo_table_types.gen.go
index c9af6178bbb98..4da2721437814 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go
@@ -19,8 +19,8 @@
 package encoding
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
index 7e88238d67b71..75335f25ff1f7 100644
--- a/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/memo_table_types.gen.go.tmpl
@@ -17,7 +17,7 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
+  "github.com/apache/arrow/go/v15/parquet"
 )
 
 // standard map based implementation of memo tables which can be more efficient
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go b/go/parquet/internal/encoding/plain_encoder_types.gen.go
index 23db13b7a4121..09403d74cb06f 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go
@@ -24,11 +24,11 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
index e45419050302d..2838c63a41857 100644
--- a/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
+++ b/go/parquet/internal/encoding/plain_encoder_types.gen.go.tmpl
@@ -20,10 +20,10 @@ import (
   "encoding/binary"
   "fmt"
 
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 var (
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go b/go/parquet/internal/encoding/typed_encoder.gen.go
index 411e87c17e7d5..25fa309e0a38f 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go
@@ -22,15 +22,15 @@ import (
 	"fmt"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
index 69415ccca4a26..66c2649d599c6 100644
--- a/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
+++ b/go/parquet/internal/encoding/typed_encoder.gen.go.tmpl
@@ -17,13 +17,13 @@
 package encoding
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/parquet/schema"
-  format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/parquet/schema"
+  format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 // fully typed encoder interfaces to enable writing against encoder/decoders
diff --git a/go/parquet/internal/encoding/types.go b/go/parquet/internal/encoding/types.go
index 2d13a9c8f877a..4ab3ab1a1c954 100644
--- a/go/parquet/internal/encoding/types.go
+++ b/go/parquet/internal/encoding/types.go
@@ -20,11 +20,11 @@ import (
 	"io"
 	"sync"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/encryption/aes.go b/go/parquet/internal/encryption/aes.go
index cc0cea0112fee..b6e9130ef81cd 100644
--- a/go/parquet/internal/encryption/aes.go
+++ b/go/parquet/internal/encryption/aes.go
@@ -29,7 +29,7 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // important constants for handling the aes encryption
diff --git a/go/parquet/internal/encryption/decryptor.go b/go/parquet/internal/encryption/decryptor.go
index 62a4f2ee9e56e..658559e6082c4 100644
--- a/go/parquet/internal/encryption/decryptor.go
+++ b/go/parquet/internal/encryption/decryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // FileDecryptor is an interface used by the filereader for decrypting an
diff --git a/go/parquet/internal/encryption/encryptor.go b/go/parquet/internal/encryption/encryptor.go
index 2ef09e558a23f..bdbae4740a44f 100644
--- a/go/parquet/internal/encryption/encryptor.go
+++ b/go/parquet/internal/encryption/encryptor.go
@@ -19,8 +19,8 @@ package encryption
 import (
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 // FileEncryptor is the interface for constructing encryptors for the different
diff --git a/go/parquet/internal/testutils/pagebuilder.go b/go/parquet/internal/testutils/pagebuilder.go
index 9c1fd72a1bdf0..48ac331640087 100644
--- a/go/parquet/internal/testutils/pagebuilder.go
+++ b/go/parquet/internal/testutils/pagebuilder.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/mock"
 )
 
diff --git a/go/parquet/internal/testutils/primitive_typed.go b/go/parquet/internal/testutils/primitive_typed.go
index 2bd0a29dd2970..daab0d427ba10 100644
--- a/go/parquet/internal/testutils/primitive_typed.go
+++ b/go/parquet/internal/testutils/primitive_typed.go
@@ -20,11 +20,11 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 type PrimitiveTypedTest struct {
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index d9a06da43ba4e..bb101ebf9a92d 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -24,13 +24,13 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/endian"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
diff --git a/go/parquet/internal/testutils/random_arrow.go b/go/parquet/internal/testutils/random_arrow.go
index 360b8e7476430..d886db0360b84 100644
--- a/go/parquet/internal/testutils/random_arrow.go
+++ b/go/parquet/internal/testutils/random_arrow.go
@@ -17,9 +17,9 @@
 package testutils
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/rand"
 )
 
diff --git a/go/parquet/internal/testutils/utils.go b/go/parquet/internal/testutils/utils.go
index 1122f4286f386..3da76c17ddc32 100644
--- a/go/parquet/internal/testutils/utils.go
+++ b/go/parquet/internal/testutils/utils.go
@@ -19,7 +19,7 @@ package testutils
 import (
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 )
 
 var typeToParquetTypeMap = map[reflect.Type]parquet.Type{
diff --git a/go/parquet/internal/thrift/helpers.go b/go/parquet/internal/thrift/helpers.go
index 357d9020989d3..3835830ac6c2d 100644
--- a/go/parquet/internal/thrift/helpers.go
+++ b/go/parquet/internal/thrift/helpers.go
@@ -23,7 +23,7 @@ import (
 	"context"
 	"io"
 
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
 	"github.com/apache/thrift/lib/go/thrift"
 )
 
diff --git a/go/parquet/internal/utils/bit_benchmark_test.go b/go/parquet/internal/utils/bit_benchmark_test.go
index 2518e48a4baa8..14353380a5694 100644
--- a/go/parquet/internal/utils/bit_benchmark_test.go
+++ b/go/parquet/internal/utils/bit_benchmark_test.go
@@ -20,9 +20,9 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
 )
 
 type linearBitRunReader struct {
diff --git a/go/parquet/internal/utils/bit_packing_arm64.go b/go/parquet/internal/utils/bit_packing_arm64.go
index 92fe0f97b77c3..e9fb2ef1d810b 100644
--- a/go/parquet/internal/utils/bit_packing_arm64.go
+++ b/go/parquet/internal/utils/bit_packing_arm64.go
@@ -23,7 +23,7 @@ import (
 	"github.com/klauspost/cpuid/v2"
 	// import for side effect of initializing feature flags
 	// based on ARM_ENABLE_EXT env var
-	_ "github.com/apache/arrow/go/v14/parquet/internal/bmi"
+	_ "github.com/apache/arrow/go/v15/parquet/internal/bmi"
 )
 
 func init() {
diff --git a/go/parquet/internal/utils/bit_reader.go b/go/parquet/internal/utils/bit_reader.go
index cf61395c0b16c..bf9741c79878b 100644
--- a/go/parquet/internal/utils/bit_reader.go
+++ b/go/parquet/internal/utils/bit_reader.go
@@ -24,10 +24,10 @@ import (
 	"reflect"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // masks for grabbing the trailing bits based on the number of trailing bits desired
diff --git a/go/parquet/internal/utils/bit_reader_test.go b/go/parquet/internal/utils/bit_reader_test.go
index c285f5165cc0a..5ce1b799b463b 100644
--- a/go/parquet/internal/utils/bit_reader_test.go
+++ b/go/parquet/internal/utils/bit_reader_test.go
@@ -25,11 +25,11 @@ import (
 	"strconv"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"golang.org/x/exp/rand"
diff --git a/go/parquet/internal/utils/bit_writer.go b/go/parquet/internal/utils/bit_writer.go
index 99a1db065590d..6cb255f5b0473 100644
--- a/go/parquet/internal/utils/bit_writer.go
+++ b/go/parquet/internal/utils/bit_writer.go
@@ -21,7 +21,7 @@ import (
 	"io"
 	"log"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 // WriterAtBuffer is a convenience struct for providing a WriteAt function
diff --git a/go/parquet/internal/utils/bitmap_writer.go b/go/parquet/internal/utils/bitmap_writer.go
index 447222139b773..3ef99291e3748 100644
--- a/go/parquet/internal/utils/bitmap_writer.go
+++ b/go/parquet/internal/utils/bitmap_writer.go
@@ -20,7 +20,7 @@ import (
 	"encoding/binary"
 	"math/bits"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
 )
 
 // BitmapWriter is an interface for bitmap writers so that we can use multiple
diff --git a/go/parquet/internal/utils/bitmap_writer_test.go b/go/parquet/internal/utils/bitmap_writer_test.go
index 9f38f1ef291ea..3dddc7567903e 100644
--- a/go/parquet/internal/utils/bitmap_writer_test.go
+++ b/go/parquet/internal/utils/bitmap_writer_test.go
@@ -22,8 +22,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/parquet/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/parquet/internal/utils"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/go/parquet/internal/utils/rle.go b/go/parquet/internal/utils/rle.go
index fef322c6fd560..21ac2ce6b5db5 100644
--- a/go/parquet/internal/utils/rle.go
+++ b/go/parquet/internal/utils/rle.go
@@ -24,10 +24,10 @@ import (
 	"encoding/binary"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go b/go/parquet/internal/utils/typed_rle_dict.gen.go
index dff22711b120f..886d24564db4b 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go
@@ -19,9 +19,9 @@
 package utils
 
 import (
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
index 090275745ff59..abcb419055a92 100644
--- a/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
+++ b/go/parquet/internal/utils/typed_rle_dict.gen.go.tmpl
@@ -17,9 +17,9 @@
 package utils
 
 import (
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
-  "github.com/apache/arrow/go/v14/internal/utils"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
+  "github.com/apache/arrow/go/v15/internal/utils"
 )
 
 {{range .In}}
diff --git a/go/parquet/metadata/app_version.go b/go/parquet/metadata/app_version.go
index 85ace57365bd3..9966827026106 100644
--- a/go/parquet/metadata/app_version.go
+++ b/go/parquet/metadata/app_version.go
@@ -21,8 +21,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 var (
diff --git a/go/parquet/metadata/column_chunk.go b/go/parquet/metadata/column_chunk.go
index e6ea6ff1ea183..729f741e1b4f9 100644
--- a/go/parquet/metadata/column_chunk.go
+++ b/go/parquet/metadata/column_chunk.go
@@ -22,13 +22,13 @@ import (
 	"io"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/file.go b/go/parquet/metadata/file.go
index dddd95c5df670..3335140c2e1c8 100644
--- a/go/parquet/metadata/file.go
+++ b/go/parquet/metadata/file.go
@@ -24,12 +24,12 @@ import (
 	"reflect"
 	"unicode/utf8"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/thrift"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/thrift"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/metadata_test.go b/go/parquet/metadata/metadata_test.go
index b685dd2223274..8caa319f83e63 100644
--- a/go/parquet/metadata/metadata_test.go
+++ b/go/parquet/metadata/metadata_test.go
@@ -21,9 +21,9 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/row_group.go b/go/parquet/metadata/row_group.go
index 16af67241e959..2923720371abe 100644
--- a/go/parquet/metadata/row_group.go
+++ b/go/parquet/metadata/row_group.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encryption"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encryption"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 // RowGroupMetaData is a proxy around the thrift RowGroup meta data object
diff --git a/go/parquet/metadata/stat_compare_test.go b/go/parquet/metadata/stat_compare_test.go
index d02123cbef039..041696d84d17a 100644
--- a/go/parquet/metadata/stat_compare_test.go
+++ b/go/parquet/metadata/stat_compare_test.go
@@ -20,8 +20,8 @@ import (
 	"encoding/binary"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/metadata/statistics.go b/go/parquet/metadata/statistics.go
index 245b06a7348c4..606e76ffd0454 100644
--- a/go/parquet/metadata/statistics.go
+++ b/go/parquet/metadata/statistics.go
@@ -22,14 +22,14 @@ import (
 	"math"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
 //go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata statistics_types.gen.go.tmpl
diff --git a/go/parquet/metadata/statistics_test.go b/go/parquet/metadata/statistics_test.go
index 35d8b7821c51a..47798d3c4dd3c 100644
--- a/go/parquet/metadata/statistics_test.go
+++ b/go/parquet/metadata/statistics_test.go
@@ -21,11 +21,11 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go b/go/parquet/metadata/statistics_types.gen.go
index e6aa7f1801a0f..e8fb9877c8444 100644
--- a/go/parquet/metadata/statistics_types.gen.go
+++ b/go/parquet/metadata/statistics_types.gen.go
@@ -22,14 +22,14 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/metadata/statistics_types.gen.go.tmpl b/go/parquet/metadata/statistics_types.gen.go.tmpl
index 35470f06046bf..4b6253a8574ea 100644
--- a/go/parquet/metadata/statistics_types.gen.go.tmpl
+++ b/go/parquet/metadata/statistics_types.gen.go.tmpl
@@ -19,13 +19,13 @@ package metadata
 import (
   "fmt"
 
-  "github.com/apache/arrow/go/v14/arrow"
-  "github.com/apache/arrow/go/v14/parquet"
-  "github.com/apache/arrow/go/v14/parquet/schema"
-  "github.com/apache/arrow/go/v14/parquet/internal/utils"
-  shared_utils "github.com/apache/arrow/go/v14/internal/utils"
-  "github.com/apache/arrow/go/v14/parquet/internal/encoding"
-  "github.com/apache/arrow/go/v14/internal/bitutils"
+  "github.com/apache/arrow/go/v15/arrow"
+  "github.com/apache/arrow/go/v15/parquet"
+  "github.com/apache/arrow/go/v15/parquet/schema"
+  "github.com/apache/arrow/go/v15/parquet/internal/utils"
+  shared_utils "github.com/apache/arrow/go/v15/internal/utils"
+  "github.com/apache/arrow/go/v15/parquet/internal/encoding"
+  "github.com/apache/arrow/go/v15/internal/bitutils"
 )
 
 {{range .In}}
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 759a3d8675927..02f94c941c3d9 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -26,16 +26,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/sync/errgroup"
 )
 
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index c3a0a50c43f45..81b4527b105cb 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -25,16 +25,16 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
 )
 
 // get the count of the number of leaf arrays for the type
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 3c20cf2d4757b..281ca0d526476 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -25,22 +25,22 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/bitutil"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/decimal256"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/decimal256"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/encode_dict_compute.go b/go/parquet/pqarrow/encode_dict_compute.go
index 59e25cec19132..b43b4002ed0af 100644
--- a/go/parquet/pqarrow/encode_dict_compute.go
+++ b/go/parquet/pqarrow/encode_dict_compute.go
@@ -21,14 +21,14 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 func isDictEncoding(enc parquet.Encoding) bool {
diff --git a/go/parquet/pqarrow/encode_dict_nocompute.go b/go/parquet/pqarrow/encode_dict_nocompute.go
index 31d0f1bc1ce27..73ec5cfc46682 100644
--- a/go/parquet/pqarrow/encode_dict_nocompute.go
+++ b/go/parquet/pqarrow/encode_dict_nocompute.go
@@ -21,8 +21,8 @@ package pqarrow
 import (
 	"errors"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/parquet/file"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/parquet/file"
 )
 
 func writeDictionaryArrow(*arrowWriteContext, file.ColumnChunkWriter, arrow.Array, []int16, []int16, bool) (err error) {
diff --git a/go/parquet/pqarrow/encode_dictionary_test.go b/go/parquet/pqarrow/encode_dictionary_test.go
index 995f3fb329534..28ebee53e1b83 100644
--- a/go/parquet/pqarrow/encode_dictionary_test.go
+++ b/go/parquet/pqarrow/encode_dictionary_test.go
@@ -26,14 +26,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/compute"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/internal/testutils"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/compute"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/internal/testutils"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/pqarrow/file_reader.go b/go/parquet/pqarrow/file_reader.go
index d91010c62c19d..3534cc87b78b5 100755
--- a/go/parquet/pqarrow/file_reader.go
+++ b/go/parquet/pqarrow/file_reader.go
@@ -23,13 +23,13 @@ import (
 	"sync"
 	"sync/atomic"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/arrio"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/arrio"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/pqarrow/file_reader_test.go b/go/parquet/pqarrow/file_reader_test.go
index d1f3ae1c984a2..9c1b4252f5fc6 100644
--- a/go/parquet/pqarrow/file_reader_test.go
+++ b/go/parquet/pqarrow/file_reader_test.go
@@ -26,13 +26,13 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index aa0bae7b1fdfb..21f16c0b67938 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -22,12 +22,12 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/internal/utils"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/internal/utils"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/helpers.go b/go/parquet/pqarrow/helpers.go
index e8b740d12ba62..39d17cf80ae68 100644
--- a/go/parquet/pqarrow/helpers.go
+++ b/go/parquet/pqarrow/helpers.go
@@ -17,7 +17,7 @@
 package pqarrow
 
 import (
-	"github.com/apache/arrow/go/v14/arrow"
+	"github.com/apache/arrow/go/v15/arrow"
 )
 
 func releaseArrays(arrays []arrow.Array) {
diff --git a/go/parquet/pqarrow/path_builder.go b/go/parquet/pqarrow/path_builder.go
index c4915d58dd59f..0f1158bd1e9f0 100644
--- a/go/parquet/pqarrow/path_builder.go
+++ b/go/parquet/pqarrow/path_builder.go
@@ -21,11 +21,11 @@ import (
 	"sync/atomic"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/bitutils"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/bitutils"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/path_builder_test.go b/go/parquet/pqarrow/path_builder_test.go
index 16b994582df02..e0a60262d3f4a 100644
--- a/go/parquet/pqarrow/path_builder_test.go
+++ b/go/parquet/pqarrow/path_builder_test.go
@@ -20,10 +20,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
diff --git a/go/parquet/pqarrow/properties.go b/go/parquet/pqarrow/properties.go
index 98427bbf9398c..cc100fa80d87b 100755
--- a/go/parquet/pqarrow/properties.go
+++ b/go/parquet/pqarrow/properties.go
@@ -19,9 +19,9 @@ package pqarrow
 import (
 	"context"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/internal/encoding"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 )
 
 // ArrowWriterProperties are used to determine how to manipulate the arrow data
diff --git a/go/parquet/pqarrow/reader_writer_test.go b/go/parquet/pqarrow/reader_writer_test.go
index e3f66834c2cee..9d09bcec15da6 100644
--- a/go/parquet/pqarrow/reader_writer_test.go
+++ b/go/parquet/pqarrow/reader_writer_test.go
@@ -22,12 +22,12 @@ import (
 	"testing"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/array"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
 	"golang.org/x/exp/rand"
 	"gonum.org/v1/gonum/stat/distuv"
 )
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index 9ba8554898986..b23c37ea39102 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -22,15 +22,15 @@ import (
 	"math"
 	"strconv"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/decimal128"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/file"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/decimal128"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/file"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/pqarrow/schema_test.go b/go/parquet/pqarrow/schema_test.go
index e195358af6c98..b5e7dc8fad34a 100644
--- a/go/parquet/pqarrow/schema_test.go
+++ b/go/parquet/pqarrow/schema_test.go
@@ -20,15 +20,15 @@ import (
 	"encoding/base64"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	"github.com/apache/arrow/go/v14/arrow/flight"
-	"github.com/apache/arrow/go/v14/arrow/ipc"
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/types"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/metadata"
-	"github.com/apache/arrow/go/v14/parquet/pqarrow"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/flight"
+	"github.com/apache/arrow/go/v15/arrow/ipc"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/types"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/pqarrow"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/go/parquet/reader_properties.go b/go/parquet/reader_properties.go
index dd2032958a51c..be2377527d782 100644
--- a/go/parquet/reader_properties.go
+++ b/go/parquet/reader_properties.go
@@ -21,8 +21,8 @@ import (
 	"fmt"
 	"io"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/internal/utils"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/internal/utils"
 )
 
 // ReaderProperties are used to define how the file reader will handle buffering and allocating buffers
diff --git a/go/parquet/reader_writer_properties_test.go b/go/parquet/reader_writer_properties_test.go
index 6bd93a02550e4..698129471adda 100644
--- a/go/parquet/reader_writer_properties_test.go
+++ b/go/parquet/reader_writer_properties_test.go
@@ -20,9 +20,9 @@ import (
 	"bytes"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/column.go b/go/parquet/schema/column.go
index 1575037d59d23..02d0d83e8465e 100644
--- a/go/parquet/schema/column.go
+++ b/go/parquet/schema/column.go
@@ -20,8 +20,8 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // Column encapsulates the information necessary to interpret primitive
diff --git a/go/parquet/schema/converted_types.go b/go/parquet/schema/converted_types.go
index 6a4702b819259..58051dba7f19b 100644
--- a/go/parquet/schema/converted_types.go
+++ b/go/parquet/schema/converted_types.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // ConvertedType corresponds to the ConvertedType in the parquet.Thrift,
diff --git a/go/parquet/schema/converted_types_test.go b/go/parquet/schema/converted_types_test.go
index a4f9ea0018196..8b8e061466474 100644
--- a/go/parquet/schema/converted_types_test.go
+++ b/go/parquet/schema/converted_types_test.go
@@ -19,7 +19,7 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/helpers.go b/go/parquet/schema/helpers.go
index 23a5a0b667f26..13075a065f073 100644
--- a/go/parquet/schema/helpers.go
+++ b/go/parquet/schema/helpers.go
@@ -17,7 +17,7 @@
 package schema
 
 import (
-	"github.com/apache/arrow/go/v14/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/helpers_test.go b/go/parquet/schema/helpers_test.go
index 6d136e4ecd155..98f3cab36d433 100644
--- a/go/parquet/schema/helpers_test.go
+++ b/go/parquet/schema/helpers_test.go
@@ -21,8 +21,8 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index a0607a1a2f62d..1ea44fc56c615 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -20,10 +20,10 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/internal/debug"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/internal/debug"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 // DecimalMetadata is a struct for managing scale and precision information between
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 8531a061abb77..49edf1748c52c 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -19,9 +19,9 @@ package schema_test
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/internal/json"
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/internal/json"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/node.go b/go/parquet/schema/node.go
index 28259c8d61f58..ff23624afa35d 100644
--- a/go/parquet/schema/node.go
+++ b/go/parquet/schema/node.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"fmt"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/apache/thrift/lib/go/thrift"
 	"golang.org/x/xerrors"
 )
diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index bc863f1390030..d79edb92408f8 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -22,8 +22,8 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index e18feada7a796..06ad7191a5749 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -22,8 +22,8 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go/parquet/schema/schema.go b/go/parquet/schema/schema.go
index 1b3363f58d11f..ace2775763a06 100644
--- a/go/parquet/schema/schema.go
+++ b/go/parquet/schema/schema.go
@@ -35,8 +35,8 @@ import (
 	"io"
 	"strings"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
 )
 
diff --git a/go/parquet/schema/schema_element_test.go b/go/parquet/schema/schema_element_test.go
index e9a2ef5eb31f6..dd1d293e5cfd7 100644
--- a/go/parquet/schema/schema_element_test.go
+++ b/go/parquet/schema/schema_element_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_flatten_test.go b/go/parquet/schema/schema_flatten_test.go
index 90741ae9b43bb..34f4ac8d3c450 100644
--- a/go/parquet/schema/schema_flatten_test.go
+++ b/go/parquet/schema/schema_flatten_test.go
@@ -19,8 +19,8 @@ package schema
 import (
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 )
diff --git a/go/parquet/schema/schema_test.go b/go/parquet/schema/schema_test.go
index e69a13e07986e..b60c7dfaafcd1 100644
--- a/go/parquet/schema/schema_test.go
+++ b/go/parquet/schema/schema_test.go
@@ -20,9 +20,9 @@ import (
 	"os"
 	"testing"
 
-	"github.com/apache/arrow/go/v14/parquet"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
-	"github.com/apache/arrow/go/v14/parquet/schema"
+	"github.com/apache/arrow/go/v15/parquet"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/apache/thrift/lib/go/thrift"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
diff --git a/go/parquet/types.go b/go/parquet/types.go
index 7b6df2ea9d16c..5b6f8fb0251d9 100644
--- a/go/parquet/types.go
+++ b/go/parquet/types.go
@@ -24,8 +24,8 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/apache/arrow/go/v14/arrow"
-	format "github.com/apache/arrow/go/v14/parquet/internal/gen-go/parquet"
+	"github.com/apache/arrow/go/v15/arrow"
+	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 )
 
 const (
diff --git a/go/parquet/writer_properties.go b/go/parquet/writer_properties.go
index acd43194c1be7..9e33bddf7faa7 100644
--- a/go/parquet/writer_properties.go
+++ b/go/parquet/writer_properties.go
@@ -17,8 +17,8 @@
 package parquet
 
 import (
-	"github.com/apache/arrow/go/v14/arrow/memory"
-	"github.com/apache/arrow/go/v14/parquet/compress"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+	"github.com/apache/arrow/go/v15/parquet/compress"
 )
 
 // Constants for default property values used for the default reader, writer and column props.
@@ -46,7 +46,7 @@ const (
 	DefaultStatsEnabled = true
 	// If the stats are larger than 4K the writer will skip writing them out anyways.
 	DefaultMaxStatsSize int64 = 4096
-	DefaultCreatedBy          = "parquet-go version 14.0.1-SNAPSHOT"
+	DefaultCreatedBy          = "parquet-go version 15.0.0-SNAPSHOT"
 	DefaultRootName           = "schema"
 )
 
diff --git a/java/adapter/avro/pom.xml b/java/adapter/avro/pom.xml
index 20602f3b80771..c0410ea4c2314 100644
--- a/java/adapter/avro/pom.xml
+++ b/java/adapter/avro/pom.xml
@@ -16,7 +16,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../../pom.xml</relativePath>
   </parent>
 
diff --git a/java/adapter/jdbc/pom.xml b/java/adapter/jdbc/pom.xml
index f97bcaf74a27c..2490f708e6f24 100644
--- a/java/adapter/jdbc/pom.xml
+++ b/java/adapter/jdbc/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/adapter/orc/pom.xml b/java/adapter/orc/pom.xml
index 2213a2a7d0783..72ba13ea81738 100644
--- a/java/adapter/orc/pom.xml
+++ b/java/adapter/orc/pom.xml
@@ -111,7 +111,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/java/algorithm/pom.xml b/java/algorithm/pom.xml
index a248389aeb406..8c6a9fb0151ef 100644
--- a/java/algorithm/pom.xml
+++ b/java/algorithm/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-algorithm</artifactId>
   <name>Arrow Algorithms</name>
diff --git a/java/bom/pom.xml b/java/bom/pom.xml
index 01f5e93dc0438..1f6f854f60013 100644
--- a/java/bom/pom.xml
+++ b/java/bom/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-bom</artifactId>
-  <version>14.0.1-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <name>Arrow Bill of Materials</name>
   <description>Arrow Bill of Materials</description>
diff --git a/java/c/pom.xml b/java/c/pom.xml
index 7a4631704fa80..d66379d356624 100644
--- a/java/c/pom.xml
+++ b/java/c/pom.xml
@@ -13,7 +13,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/compression/pom.xml b/java/compression/pom.xml
index 283c2af2d7d76..129268b9e6a07 100644
--- a/java/compression/pom.xml
+++ b/java/compression/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-compression</artifactId>
   <name>Arrow Compression</name>
diff --git a/java/dataset/pom.xml b/java/dataset/pom.xml
index cdc1a411798c3..b533a1733521b 100644
--- a/java/dataset/pom.xml
+++ b/java/dataset/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/flight/flight-core/pom.xml b/java/flight/flight-core/pom.xml
index 172a8583d8c88..7b69179053d7f 100644
--- a/java/flight/flight-core/pom.xml
+++ b/java/flight/flight-core/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/flight-grpc/pom.xml b/java/flight/flight-grpc/pom.xml
index f113ba50759a9..e7bb9508d2403 100644
--- a/java/flight/flight-grpc/pom.xml
+++ b/java/flight/flight-grpc/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
   <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-integration-tests/pom.xml b/java/flight/flight-integration-tests/pom.xml
index 6b7796641b607..778cb7df11f61 100644
--- a/java/flight/flight-integration-tests/pom.xml
+++ b/java/flight/flight-integration-tests/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
diff --git a/java/flight/flight-sql-jdbc-core/pom.xml b/java/flight/flight-sql-jdbc-core/pom.xml
index 34efb04fa8702..cbeaa88f1e2f7 100644
--- a/java/flight/flight-sql-jdbc-core/pom.xml
+++ b/java/flight/flight-sql-jdbc-core/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql-jdbc-driver/pom.xml b/java/flight/flight-sql-jdbc-driver/pom.xml
index 69e3bfad8d883..263538ba48b37 100644
--- a/java/flight/flight-sql-jdbc-driver/pom.xml
+++ b/java/flight/flight-sql-jdbc-driver/pom.xml
@@ -16,7 +16,7 @@
     <parent>
         <artifactId>arrow-flight</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
     <modelVersion>4.0.0</modelVersion>
diff --git a/java/flight/flight-sql/pom.xml b/java/flight/flight-sql/pom.xml
index e49cb8fa4dd5c..09100d9731ad5 100644
--- a/java/flight/flight-sql/pom.xml
+++ b/java/flight/flight-sql/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <artifactId>arrow-flight</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
     <relativePath>../pom.xml</relativePath>
   </parent>
 
diff --git a/java/flight/pom.xml b/java/flight/pom.xml
index fd65c054d971e..7ddda94f77b49 100644
--- a/java/flight/pom.xml
+++ b/java/flight/pom.xml
@@ -15,7 +15,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/format/pom.xml b/java/format/pom.xml
index 58dd21e3288f2..3f581311e20ea 100644
--- a/java/format/pom.xml
+++ b/java/format/pom.xml
@@ -15,7 +15,7 @@
 <parent>
   <artifactId>arrow-java-root</artifactId>
   <groupId>org.apache.arrow</groupId>
-  <version>14.0.1-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
 </parent>
 
 <artifactId>arrow-format</artifactId>
diff --git a/java/gandiva/pom.xml b/java/gandiva/pom.xml
index e87ba2bb4eb88..cfda0b0c527a9 100644
--- a/java/gandiva/pom.xml
+++ b/java/gandiva/pom.xml
@@ -14,7 +14,7 @@
     <parent>
       <groupId>org.apache.arrow</groupId>
       <artifactId>arrow-java-root</artifactId>
-      <version>14.0.1-SNAPSHOT</version>
+      <version>15.0.0-SNAPSHOT</version>
     </parent>
 
     <groupId>org.apache.arrow.gandiva</groupId>
diff --git a/java/memory/memory-core/pom.xml b/java/memory/memory-core/pom.xml
index 5d1886032b3e8..8f28699045383 100644
--- a/java/memory/memory-core/pom.xml
+++ b/java/memory/memory-core/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-netty/pom.xml b/java/memory/memory-netty/pom.xml
index 56db6924bf746..307f6ad81a0f1 100644
--- a/java/memory/memory-netty/pom.xml
+++ b/java/memory/memory-netty/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/memory-unsafe/pom.xml b/java/memory/memory-unsafe/pom.xml
index 68bd61e742741..9f8137308195d 100644
--- a/java/memory/memory-unsafe/pom.xml
+++ b/java/memory/memory-unsafe/pom.xml
@@ -13,7 +13,7 @@
   <parent>
     <artifactId>arrow-memory</artifactId>
     <groupId>org.apache.arrow</groupId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/java/memory/pom.xml b/java/memory/pom.xml
index 6fc9d11730eaf..c10263b97f1bf 100644
--- a/java/memory/pom.xml
+++ b/java/memory/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-memory</artifactId>
   <name>Arrow Memory</name>
diff --git a/java/performance/pom.xml b/java/performance/pom.xml
index 6aa1599425ad8..102832491ec05 100644
--- a/java/performance/pom.xml
+++ b/java/performance/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <artifactId>arrow-java-root</artifactId>
         <groupId>org.apache.arrow</groupId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-performance</artifactId>
     <packaging>jar</packaging>
diff --git a/java/pom.xml b/java/pom.xml
index caf470ee2b2b2..2a9997b7012b7 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -20,7 +20,7 @@
 
   <groupId>org.apache.arrow</groupId>
   <artifactId>arrow-java-root</artifactId>
-  <version>14.0.1-SNAPSHOT</version>
+  <version>15.0.0-SNAPSHOT</version>
   <packaging>pom</packaging>
 
   <name>Apache Arrow Java Root POM</name>
diff --git a/java/tools/pom.xml b/java/tools/pom.xml
index ce6243e98dacf..128825c224369 100644
--- a/java/tools/pom.xml
+++ b/java/tools/pom.xml
@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.apache.arrow</groupId>
         <artifactId>arrow-java-root</artifactId>
-        <version>14.0.1-SNAPSHOT</version>
+        <version>15.0.0-SNAPSHOT</version>
     </parent>
     <artifactId>arrow-tools</artifactId>
     <name>Arrow Tools</name>
diff --git a/java/vector/pom.xml b/java/vector/pom.xml
index 0cfa421fbf7d4..4c8bf1e594aa4 100644
--- a/java/vector/pom.xml
+++ b/java/vector/pom.xml
@@ -14,7 +14,7 @@
   <parent>
     <groupId>org.apache.arrow</groupId>
     <artifactId>arrow-java-root</artifactId>
-    <version>14.0.1-SNAPSHOT</version>
+    <version>15.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>arrow-vector</artifactId>
   <name>Arrow Vectors</name>
diff --git a/js/package.json b/js/package.json
index 3bad73b6fdf76..33bc4849903ef 100644
--- a/js/package.json
+++ b/js/package.json
@@ -124,5 +124,5 @@
   "engines": {
     "node": ">=12.0"
   },
-  "version": "14.0.1-SNAPSHOT"
+  "version": "15.0.0-SNAPSHOT"
 }
diff --git a/matlab/CMakeLists.txt b/matlab/CMakeLists.txt
index df20ad9680707..47d2acd613f8b 100644
--- a/matlab/CMakeLists.txt
+++ b/matlab/CMakeLists.txt
@@ -94,7 +94,7 @@ endfunction()
 
 set(CMAKE_CXX_STANDARD 17)
 
-set(MLARROW_VERSION "14.0.1-SNAPSHOT")
+set(MLARROW_VERSION "15.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" MLARROW_BASE_VERSION "${MLARROW_VERSION}")
 
 project(mlarrow VERSION "${MLARROW_BASE_VERSION}")
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 95d23933a88b7..86285c3dc381b 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -21,7 +21,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(pyarrow)
 
-set(PYARROW_VERSION "14.0.1-SNAPSHOT")
+set(PYARROW_VERSION "15.0.0-SNAPSHOT")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" PYARROW_BASE_VERSION "${PYARROW_VERSION}")
 
 # Running from a Python sdist tarball
diff --git a/python/setup.py b/python/setup.py
index 4e45b8c68fe16..b1c825d84d5a9 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -407,7 +407,7 @@ def get_outputs(self):
 
 # If the event of not running from a git clone (e.g. from a git archive
 # or a Python sdist), see if we can set the version number ourselves
-default_version = '14.0.1-SNAPSHOT'
+default_version = '15.0.0-SNAPSHOT'
 if (not os.path.exists('../.git') and
         not os.environ.get('SETUPTOOLS_SCM_PRETEND_VERSION')):
     os.environ['SETUPTOOLS_SCM_PRETEND_VERSION'] = \
diff --git a/r/NEWS.md b/r/NEWS.md
index d2d5f08288cb8..e00c6b51b597d 100644
--- a/r/NEWS.md
+++ b/r/NEWS.md
@@ -21,8 +21,6 @@
 
 # arrow 14.0.0
 
-# arrow 14.0.0
-
 ## New features
 
 * When reading partitioned CSV datasets and supplying a schema to
diff --git a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
index 86d8ffba80c90..8551b647cb86f 100644
--- a/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
+++ b/ruby/red-arrow-cuda/lib/arrow-cuda/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowCUDA
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
index b0a29b7f7b365..acfdd675687be 100644
--- a/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
+++ b/ruby/red-arrow-dataset/lib/arrow-dataset/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowDataset
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
index 6734ab6ae2536..3354678e30032 100644
--- a/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
+++ b/ruby/red-arrow-flight-sql/lib/arrow-flight-sql/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlightSQL
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow-flight/lib/arrow-flight/version.rb b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
index b3b778108199e..f2141a68432e5 100644
--- a/ruby/red-arrow-flight/lib/arrow-flight/version.rb
+++ b/ruby/red-arrow-flight/lib/arrow-flight/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module ArrowFlight
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-arrow/lib/arrow/version.rb b/ruby/red-arrow/lib/arrow/version.rb
index 222b72d10bb34..235a7df75d672 100644
--- a/ruby/red-arrow/lib/arrow/version.rb
+++ b/ruby/red-arrow/lib/arrow/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Arrow
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-gandiva/lib/gandiva/version.rb b/ruby/red-gandiva/lib/gandiva/version.rb
index 576ee097743db..6a1835f0e50e8 100644
--- a/ruby/red-gandiva/lib/gandiva/version.rb
+++ b/ruby/red-gandiva/lib/gandiva/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Gandiva
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")
diff --git a/ruby/red-parquet/lib/parquet/version.rb b/ruby/red-parquet/lib/parquet/version.rb
index 17a9157a36047..c5a945c4e4297 100644
--- a/ruby/red-parquet/lib/parquet/version.rb
+++ b/ruby/red-parquet/lib/parquet/version.rb
@@ -16,7 +16,7 @@
 # under the License.
 
 module Parquet
-  VERSION = "14.0.1-SNAPSHOT"
+  VERSION = "15.0.0-SNAPSHOT"
 
   module Version
     numbers, TAG = VERSION.split("-")

From aa9f8ecdaf3cb8eb2fb478abff32fb96eb350305 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ra=C3=BAl=20Cumplido?= <raulcumplido@gmail.com>
Date: Sun, 12 Nov 2023 13:56:02 -0600
Subject: [PATCH 718/749] MINOR: [Dev] Add Bryce Mecum to list of collaborators
 (#38678)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

### Rationale for this change

Disclaimer: is a colleague of mine.

Opening PR as documented on: https://arrow.apache.org/docs/developers/reviewing.html#collaborators
Bryce Mecum (@ amoeba) has been helping with the project for some time and usually helps reviewing breaking changes and critical fixes in order to properly label the issues for the release.
It would be helpful if he can add the corresponding labels and assign issues.

### What changes are included in this PR?
Add to list of collaborators.

### Are these changes tested?

No

### Are there any user-facing changes?

No

Authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .asf.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.asf.yaml b/.asf.yaml
index 4693631be38b3..d2522ecae0b43 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -25,6 +25,7 @@ github:
     - davisusanibar
     - felipecrv
     - js8544
+    - amoeba
 
 notifications:
   commits:      commits@arrow.apache.org

From 79c72a67f90719fb1af315a9b2b8caa25d667775 Mon Sep 17 00:00:00 2001
From: Dan Homola <dan.homola@hotmail.cz>
Date: Mon, 13 Nov 2023 14:45:25 +0100
Subject: [PATCH 719/749] GH-38528: [Python][Compute] Describe strptime format
 semantics (#38665)

### Rationale for this change

To prevent possible confusion with the compute strptime function, we now explicitly mention that the C/C++ semantics are followed.

### What changes are included in this PR?

The documentation of the `format` parameter of the `strptime` function is expanded.

### Are these changes tested?

N/A documentation change only.

### Are there any user-facing changes?

Just the documentation.
* Closes: #38528

Lead-authored-by: Dan Homola <dan.homola@hotmail.cz>
Co-authored-by: Dan Homola <dan.homola@gooddata.com>
Co-authored-by: Rok Mihevc <rok@mihevc.org>
Signed-off-by: Rok Mihevc <rok@mihevc.org>
---
 python/pyarrow/_compute.pyx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/python/pyarrow/_compute.pyx b/python/pyarrow/_compute.pyx
index 25f77d8160ea8..51dfdbf8ebbbe 100644
--- a/python/pyarrow/_compute.pyx
+++ b/python/pyarrow/_compute.pyx
@@ -1682,6 +1682,9 @@ class StrptimeOptions(_StrptimeOptions):
     ----------
     format : str
         Pattern for parsing input strings as timestamps, such as "%Y/%m/%d".
+        Note that the semantics of the format follow the C/C++ strptime, not the Python one.
+        There are differences in behavior, for example how the "%y" placeholder
+        handles years with less than four digits.
     unit : str
         Timestamp unit of the output.
         Accepted values are "s", "ms", "us", "ns".

From e18ace315226525cf624b64f6c1244aa06d67e75 Mon Sep 17 00:00:00 2001
From: sgilmore10 <74676073+sgilmore10@users.noreply.github.com>
Date: Mon, 13 Nov 2023 10:05:44 -0500
Subject: [PATCH 720/749] GH-38415: [MATLAB] Add indexing "slice" method to C++
 Array Proxy class (#38674)

### Rationale for this change

In order to support MATLAB indexing semantics on the `arrow.array.Array` classes, we first need to add a method for "slicing" an Arrow Array to the C++ Array Proxy classes.

### What changes are included in this PR?

1. Added a `slice` method to the C++ Arrow Array Proxy class.
2. Added a `slice` method to `arrow.array.Array`. This method invokes the `slice` method on the proxy class.

**Example**

```matlab

>> a = arrow.array([1 2 NaN 4 5 NaN 7])

a =

  Float64Array with 7 elements and 2 null values:

    1 | 2 | null | 4 | 5 | null | 7

% Note: MATLAB uses 1-based indexing.
>> slice = a.slice(int64(2), int64(4))

slice =

  Float64Array with 4 elements and 1 null value:

    2 | null | 4 | 5

```

### Are these changes tested?

Yes, added a new test file called `tSlice.m`.

### Are there any user-facing changes?

The `slice` method is public, but [hidden](https://www.mathworks.com/help/matlab/matlab_oop/method-attributes.html).

* Closes: #38415

Authored-by: Sarah Gilmore <sgilmore@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 .../src/cpp/arrow/matlab/array/proxy/array.cc |  36 ++++-
 .../src/cpp/arrow/matlab/array/proxy/array.h  |   2 +
 matlab/src/cpp/arrow/matlab/error/error.h     |   4 +
 matlab/src/cpp/arrow/matlab/index/validate.cc |  16 ++
 matlab/src/cpp/arrow/matlab/index/validate.h  |   3 +
 matlab/src/matlab/+arrow/+array/Array.m       |  10 ++
 matlab/test/arrow/array/tSlice.m              | 138 ++++++++++++++++++
 7 files changed, 208 insertions(+), 1 deletion(-)
 create mode 100644 matlab/test/arrow/array/tSlice.m

diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
index 09d9473df4795..bc5ab093b4534 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.cc
@@ -18,8 +18,10 @@
 #include "arrow/util/utf8.h"
 
 #include "arrow/matlab/array/proxy/array.h"
+#include "arrow/matlab/array/proxy/wrap.h"
 #include "arrow/matlab/bit/unpack.h"
 #include "arrow/matlab/error/error.h"
+#include "arrow/matlab/index/validate.h"
 #include "arrow/matlab/type/proxy/wrap.h"
 #include "arrow/pretty_print.h"
 #include "arrow/type_traits.h"
@@ -38,7 +40,7 @@ namespace arrow::matlab::array::proxy {
         REGISTER_METHOD(Array, getValid);
         REGISTER_METHOD(Array, getType);
         REGISTER_METHOD(Array, isEqual);
-
+        REGISTER_METHOD(Array, slice);
     }
 
     std::shared_ptr<arrow::Array> Array::unwrap() {
@@ -144,4 +146,36 @@ namespace arrow::matlab::array::proxy {
         mda::ArrayFactory factory;
         context.outputs[0] = factory.createScalar(is_equal);
     }
+
+    void Array::slice(libmexclass::proxy::method::Context& context) {
+        namespace mda = ::matlab::data;
+
+        mda::StructArray opts = context.inputs[0];
+        const mda::TypedArray<int64_t> offset_mda = opts[0]["Offset"];
+        const mda::TypedArray<int64_t> length_mda = opts[0]["Length"];
+
+        const auto matlab_offset = int64_t(offset_mda[0]);        
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(arrow::matlab::index::validateSliceOffset(matlab_offset),
+                                            context, error::ARRAY_SLICE_NON_POSITIVE_OFFSET);
+
+        // Note: MATLAB uses 1-based indexing, so subtract 1.
+        const int64_t offset = matlab_offset - 1;
+        const int64_t length = int64_t(length_mda[0]);
+        MATLAB_ERROR_IF_NOT_OK_WITH_CONTEXT(arrow::matlab::index::validateSliceLength(length),
+                                            context, error::ARRAY_SLICE_NEGATIVE_LENGTH);
+
+        auto sliced_array = array->Slice(offset, length);
+        const auto type_id = static_cast<int32_t>(sliced_array->type_id());
+        MATLAB_ASSIGN_OR_ERROR_WITH_CONTEXT(auto sliced_array_proxy,
+                                            array::proxy::wrap(sliced_array),
+                                            context, error::ARRAY_SLICE_FAILED_TO_CREATE_ARRAY_PROXY);
+
+        const auto proxy_id = libmexclass::proxy::ProxyManager::manageProxy(sliced_array_proxy);
+
+        mda::ArrayFactory factory;
+        mda::StructArray output = factory.createStructArray({1, 1}, {"ProxyID", "TypeID"});
+        output[0]["ProxyID"] = factory.createScalar(proxy_id);
+        output[0]["TypeID"] = factory.createScalar(type_id);
+        context.outputs[0] = output;
+    }
 }
diff --git a/matlab/src/cpp/arrow/matlab/array/proxy/array.h b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
index 0ab7b279bc92e..1e3164ed01a72 100644
--- a/matlab/src/cpp/arrow/matlab/array/proxy/array.h
+++ b/matlab/src/cpp/arrow/matlab/array/proxy/array.h
@@ -44,6 +44,8 @@ class Array : public libmexclass::proxy::Proxy {
 
         void isEqual(libmexclass::proxy::method::Context& context);
 
+        void slice(libmexclass::proxy::method::Context& context);
+
         std::shared_ptr<arrow::Array> array;
 };
 
diff --git a/matlab/src/cpp/arrow/matlab/error/error.h b/matlab/src/cpp/arrow/matlab/error/error.h
index 5aa8f05c8c315..e6be411b62a05 100644
--- a/matlab/src/cpp/arrow/matlab/error/error.h
+++ b/matlab/src/cpp/arrow/matlab/error/error.h
@@ -206,4 +206,8 @@ namespace arrow::matlab::error {
     static const char* ARRAY_VALIDATE_MINIMAL_FAILED = "arrow:array:ValidateMinimalFailed";
     static const char* ARRAY_VALIDATE_FULL_FAILED = "arrow:array:ValidateFullFailed";
     static const char* ARRAY_VALIDATE_UNSUPPORTED_ENUM = "arrow:array:ValidateUnsupportedEnum";
+    static const char* ARRAY_SLICE_NON_POSITIVE_OFFSET = "arrow:array:slice:NonPositiveOffset";
+    static const char* ARRAY_SLICE_NEGATIVE_LENGTH = "arrow:array:slice:NegativeLength";
+    static const char* ARRAY_SLICE_FAILED_TO_CREATE_ARRAY_PROXY = "arrow:array:slice:FailedToCreateArrayProxy";
+
 }
diff --git a/matlab/src/cpp/arrow/matlab/index/validate.cc b/matlab/src/cpp/arrow/matlab/index/validate.cc
index b24653f1b814c..84e8e424e171f 100644
--- a/matlab/src/cpp/arrow/matlab/index/validate.cc
+++ b/matlab/src/cpp/arrow/matlab/index/validate.cc
@@ -53,4 +53,20 @@ namespace arrow::matlab::index {
         }
         return arrow::Status::OK();
     }
+
+    arrow::Status validateSliceOffset(const int64_t matlab_offset) {
+        if (matlab_offset < 1) {
+            const std::string msg = "Slice offset must be positive";
+            return arrow::Status::Invalid(std::move(msg));
+        }
+        return arrow::Status::OK();
+    }
+
+        arrow::Status validateSliceLength(const int64_t length) {
+        if (length < 0) {
+            const std::string msg = "Slice length must be nonnegative";
+            return arrow::Status::Invalid(std::move(msg));
+        }
+        return arrow::Status::OK();
+    }
 }
\ No newline at end of file
diff --git a/matlab/src/cpp/arrow/matlab/index/validate.h b/matlab/src/cpp/arrow/matlab/index/validate.h
index 40e109c19e9ef..2fa88ef8f1b5a 100644
--- a/matlab/src/cpp/arrow/matlab/index/validate.h
+++ b/matlab/src/cpp/arrow/matlab/index/validate.h
@@ -23,4 +23,7 @@ namespace arrow::matlab::index {
 
     arrow::Status validateNonEmptyContainer(const int32_t num_fields);
     arrow::Status validateInRange(const int32_t matlab_index, const int32_t num_fields);
+    arrow::Status validateSliceOffset(const int64_t matlab_offset);
+    arrow::Status validateSliceLength(const int64_t length);
+
 }
\ No newline at end of file
diff --git a/matlab/src/matlab/+arrow/+array/Array.m b/matlab/src/matlab/+arrow/+array/Array.m
index 293ad87ad4316..4402055932b60 100644
--- a/matlab/src/matlab/+arrow/+array/Array.m
+++ b/matlab/src/matlab/+arrow/+array/Array.m
@@ -98,4 +98,14 @@ function displayScalarObject(obj)
             tf = obj.Proxy.isEqual(proxyIDs);
         end
     end
+
+    methods (Hidden)
+        function array = slice(obj, offset, length)
+            sliceStruct = struct(Offset=offset, Length=length);
+            arrayStruct = obj.Proxy.slice(sliceStruct);
+            traits = arrow.type.traits.traits(arrow.type.ID(arrayStruct.TypeID));
+            proxy = libmexclass.proxy.Proxy(Name=traits.ArrayProxyClassName, ID=arrayStruct.ProxyID);
+            array = traits.ArrayConstructor(proxy);
+        end
+    end
 end
diff --git a/matlab/test/arrow/array/tSlice.m b/matlab/test/arrow/array/tSlice.m
new file mode 100644
index 0000000000000..c99503371a41c
--- /dev/null
+++ b/matlab/test/arrow/array/tSlice.m
@@ -0,0 +1,138 @@
+%TSLICE Unit tests verifying the behavior of arrow.array.Array's slice
+%method.
+
+% Licensed to the Apache Software Foundation (ASF) under one or more
+% contributor license agreements.  See the NOTICE file distributed with
+% this work for additional information regarding copyright ownership.
+% The ASF licenses this file to you under the Apache License, Version
+% 2.0 (the "License"); you may not use this file except in compliance
+% with the License.  You may obtain a copy of the License at
+%
+%   http://www.apache.org/licenses/LICENSE-2.0
+%
+% Unless required by applicable law or agreed to in writing, software
+% distributed under the License is distributed on an "AS IS" BASIS,
+% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+% implied.  See the License for the specific language governing
+% permissions and limitations under the License.
+
+classdef tSlice < matlab.unittest.TestCase
+    
+    methods(Test)
+        function BooleanArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a Boolean Array.
+            boolArray = arrow.array([true true false true true false], Valid=[1 2 3 6]);
+            slice = boolArray.slice(int64(2), int64(4));
+            testCase.verifyEqual(slice.NumElements, int64(4));
+            testCase.verifyEqual(slice.Valid, [true; true; false; false]);
+            testCase.verifyEqual(toMATLAB(slice), [true; false; false; false]);
+        end
+
+        function NumericArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a Numeric Array.
+            float64Array = arrow.array(1:10, Valid=[2 3 4 5 8 10]);
+            slice = float64Array.slice(int64(4), int64(5));
+            testCase.verifyEqual(slice.NumElements, int64(5));
+            testCase.verifyEqual(slice.Valid, [true; true; false; false; true]);
+            testCase.verifyEqual(toMATLAB(slice), [4; 5; NaN; NaN; 8]);
+        end
+
+        function DateArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a Date Array.
+            import arrow.array.Date32Array
+            dates = datetime(2023, 11, 8:16);
+            date32Array = Date32Array.fromMATLAB(dates, Valid=[4 5 6 9]);
+            slice = date32Array.slice(int64(3), int64(4));
+            testCase.verifyEqual(slice.NumElements, int64(4));
+            testCase.verifyEqual(slice.Valid, [false; true; true; true]);
+            expected = [NaT; dates(4:6)'];
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function TimeArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a Time Array.
+            times = seconds(10:20);
+            time64Array = arrow.array(times, Valid=[2 4 6 7 8 10]);
+            slice = time64Array.slice(int64(5), int64(6));
+            testCase.verifyEqual(slice.NumElements, int64(6));
+            testCase.verifyEqual(slice.Valid, [false; true; true; true; false; true]);
+            expected = [NaN; times(6:8)'; NaN; times(10)];
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function TimestampArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a TimestampArray.
+            dates = datetime(2023, 11, 8:16);
+            date32Array = arrow.array(dates, Valid=[1 2 4 5 6 8]);
+            slice = date32Array.slice(int64(5), int64(3));
+            testCase.verifyEqual(slice.NumElements, int64(3));
+            testCase.verifyEqual(slice.Valid, [true; true; false]);
+            expected = [dates(5:6)'; NaT];
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function StringArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a StringArray.
+            stringArray = arrow.array(["a" "b" "c" "d" "e" "f" "g"], Valid=[1 3 4 5 6]);
+            slice = stringArray.slice(int64(2), int64(3));
+            testCase.verifyEqual(slice.NumElements, int64(3));
+            testCase.verifyEqual(slice.Valid, [false; true; true]);
+            expected = [missing; "c"; "d"];
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function ListArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a ListArray.
+            cellArray = {missing, [1, 2, 3], missing, [4, NaN], [6, 7, 8], missing};
+            listArray = arrow.array(cellArray);
+            slice = listArray.slice(int64(2), int64(4));
+            testCase.verifyEqual(slice.NumElements, int64(4));
+            testCase.verifyEqual(slice.Valid, [true; false; true; true]);
+            expected = {[1; 2; 3]; missing; [4; NaN]; [6; 7; 8]};
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function StructArray(testCase)
+            % Verify the slice method returns the expected array when
+            % called on a StructArray.
+            numbers = [NaN; 2; 3; 4; 5; 6; 7; NaN; 9; 10];
+            text = ["a"; missing; "c"; "d"; "e"; missing; "g"; "h"; "i"; "j"];
+            t = table(numbers, text);
+            structArray = arrow.array(t, Valid=[1 2 3 6 7 8 10]);
+            slice = structArray.slice(int64(5), int64(4));
+            testCase.verifyEqual(slice.NumElements, int64(4));
+            testCase.verifyEqual(slice.Valid, [false; true; true; true]);
+            expected = t(5:8, :);
+            expected.numbers(1) = NaN;
+            expected.text(1) = missing;
+            testCase.verifyEqual(toMATLAB(slice), expected);
+        end
+
+        function NonPositiveOffsetError(testCase)
+            % Verify the slice method throws an error whose identifier is
+            % "arrow:array:slice:NonPositiveOffset" if given a non-positive
+            % value as the offset.
+            array = arrow.array(1:10);
+            fcn = @() array.slice(int64(0), int64(2));
+            testCase.verifyError(fcn, "arrow:array:slice:NonPositiveOffset");
+            fcn = @() array.slice(int64(-1), int64(2));
+            testCase.verifyError(fcn, "arrow:array:slice:NonPositiveOffset");
+        end
+
+        function NegativeLengthError(testCase)
+            % Verify the slice method throws an error whose identifier is
+            % "arrow:array:slice:NegativeLength" if given a negative value
+            % as the length.
+            array = arrow.array(1:10);
+            fcn = @() array.slice(int64(1), int64(-1));
+            testCase.verifyError(fcn, "arrow:array:slice:NegativeLength");
+        end
+    end    
+end
\ No newline at end of file

From 1ff43ab5ee13de5c3130acf10c7aa8eb9680baab Mon Sep 17 00:00:00 2001
From: Tim Schaub <tschaub@users.noreply.github.com>
Date: Mon, 13 Nov 2023 10:01:01 -0700
Subject: [PATCH 721/749] GH-38516: [Go][Parquet] Increment the number of rows
 written when appending a new row group (#38517)

### Rationale for this change

This makes it so the `NumRows` method on the `file.Writer` reports the total number of rows written across multiple row groups.

### Are these changes tested?

A regression test is added that asserts that the total number of rows written matches expectations.

* Closes: #38516

Authored-by: Tim Schaub <tim@planet.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/file/file_writer.go      | 1 +
 go/parquet/file/file_writer_test.go | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/go/parquet/file/file_writer.go b/go/parquet/file/file_writer.go
index 48eb8f44d167b..1d7f7840dac50 100644
--- a/go/parquet/file/file_writer.go
+++ b/go/parquet/file/file_writer.go
@@ -121,6 +121,7 @@ func (fw *Writer) AppendRowGroup() SerialRowGroupWriter {
 
 func (fw *Writer) appendRowGroup(buffered bool) *rowGroupWriter {
 	if fw.rowGroupWriter != nil {
+		fw.nrows += fw.rowGroupWriter.nrows
 		fw.rowGroupWriter.Close()
 	}
 	fw.rowGroups++
diff --git a/go/parquet/file/file_writer_test.go b/go/parquet/file/file_writer_test.go
index beceff9732584..f32e403a8d534 100644
--- a/go/parquet/file/file_writer_test.go
+++ b/go/parquet/file/file_writer_test.go
@@ -97,6 +97,8 @@ func (t *SerializeTestSuite) fileSerializeTest(codec compress.Compression, expec
 	writer.Close()
 
 	nrows := t.numRowGroups * t.rowsPerRG
+	t.EqualValues(nrows, writer.NumRows())
+
 	reader, err := file.NewParquetReader(bytes.NewReader(sink.Bytes()))
 	t.NoError(err)
 	t.Equal(t.numCols, reader.MetaData().Schema.NumColumns())

From bff5fb95ac987354ecd7d69466e11b9f33a67d08 Mon Sep 17 00:00:00 2001
From: Ben Harkins <60872452+benibus@users.noreply.github.com>
Date: Mon, 13 Nov 2023 16:02:49 -0500
Subject: [PATCH 722/749] GH-37582: [Go][Parquet] Implement Float16 logical
 type (#37599)

### Rationale for this change

There is an active proposal for a Float16 logical type in Parquet (https://github.com/apache/parquet-format/pull/184) with C++/Python implementations in progress (https://github.com/apache/arrow/pull/36073), so we should add one for Go as well.

### What changes are included in this PR?

- [x] Adds `LogicalType` definitions and methods for `Float16`
- [x] Adds support for `Float16` column statistics and comparators
- [x] Adds support for interchange between Parquet and Arrow's half-precision float

### Are these changes tested?

Yes

### Are there any user-facing changes?

Yes

* Closes: #37582

Authored-by: benibus <bpharks@gmx.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/float16/float16.go                   |  46 ++-
 go/arrow/float16/float16_test.go              |  43 ++
 go/parquet/file/column_writer_types.gen.go    |  13 +-
 .../file/column_writer_types.gen.go.tmpl      |  28 +-
 .../gen-go/parquet/GoUnusedProtection__.go    |   2 +-
 .../internal/gen-go/parquet/parquet-consts.go |   9 +-
 go/parquet/internal/gen-go/parquet/parquet.go | 382 +++++++++++++++---
 go/parquet/internal/testutils/random.go       |  23 ++
 go/parquet/internal/testutils/random_arrow.go |  23 ++
 go/parquet/metadata/statistics.go             |  45 ++-
 go/parquet/metadata/statistics_test.go        |  62 ++-
 go/parquet/metadata/statistics_types.gen.go   | 315 +++++++++++++++
 .../metadata/statistics_types.gen.go.tmpl     |  47 ++-
 go/parquet/metadata/statistics_types.tmpldata |  60 +++
 go/parquet/pqarrow/column_readers.go          |  16 +
 go/parquet/pqarrow/encode_arrow.go            |  25 ++
 go/parquet/pqarrow/encode_arrow_test.go       |   9 +
 go/parquet/pqarrow/schema.go                  |   6 +
 go/parquet/pqarrow/schema_test.go             |  20 +-
 go/parquet/schema/logical_types.go            |  46 +++
 go/parquet/schema/logical_types_test.go       |  12 +
 go/parquet/schema/reflection.go               |   6 +
 go/parquet/schema/reflection_test.go          |   7 +
 go/parquet/schema/schema_element_test.go      |   9 +-
 go/parquet/schema/schema_test.go              |   4 +
 25 files changed, 1183 insertions(+), 75 deletions(-)
 create mode 100644 go/parquet/metadata/statistics_types.tmpldata

diff --git a/go/arrow/float16/float16.go b/go/arrow/float16/float16.go
index 4e03d13df0cae..e0192495eb971 100644
--- a/go/arrow/float16/float16.go
+++ b/go/arrow/float16/float16.go
@@ -17,6 +17,7 @@
 package float16
 
 import (
+	"encoding/binary"
 	"math"
 	"strconv"
 )
@@ -29,6 +30,11 @@ type Num struct {
 	bits uint16
 }
 
+var (
+	MaxNum = Num{bits: 0b0111101111111111}
+	MinNum = MaxNum.Negate()
+)
+
 // New creates a new half-precision floating point value from the provided
 // float32 value.
 func New(f float32) Num {
@@ -86,6 +92,11 @@ func (n Num) Div(rhs Num) Num {
 	return New(n.Float32() / rhs.Float32())
 }
 
+// Equal returns true if the value represented by n is == other
+func (n Num) Equal(other Num) bool {
+	return n.Float32() == other.Float32()
+}
+
 // Greater returns true if the value represented by n is > other
 func (n Num) Greater(other Num) bool {
 	return n.Float32() > other.Float32()
@@ -152,14 +163,39 @@ func (n Num) Abs() Num {
 }
 
 func (n Num) Sign() int {
-	f := n.Float32()
-	if f > 0 {
-		return 1
-	} else if f == 0 {
+	if n.IsZero() {
 		return 0
+	} else if n.Signbit() {
+		return -1
 	}
-	return -1
+	return 1
 }
 
+func (n Num) Signbit() bool { return (n.bits & 0x8000) != 0 }
+
+func (n Num) IsNaN() bool { return (n.bits & 0x7fff) > 0x7c00 }
+
+func (n Num) IsZero() bool { return (n.bits & 0x7fff) == 0 }
+
 func (f Num) Uint16() uint16 { return f.bits }
 func (f Num) String() string { return strconv.FormatFloat(float64(f.Float32()), 'g', -1, 32) }
+
+func Inf() Num { return Num{bits: 0x7c00} }
+
+func NaN() Num { return Num{bits: 0x7fff} }
+
+func FromBits(src uint16) Num { return Num{bits: src} }
+
+func FromLEBytes(src []byte) Num {
+	return Num{bits: binary.LittleEndian.Uint16(src)}
+}
+
+func (f Num) PutLEBytes(dst []byte) {
+	binary.LittleEndian.PutUint16(dst, f.bits)
+}
+
+func (f Num) ToLEBytes() []byte {
+	dst := make([]byte, 2)
+	f.PutLEBytes(dst)
+	return dst
+}
diff --git a/go/arrow/float16/float16_test.go b/go/arrow/float16/float16_test.go
index 55c3ea8b30404..cfde440c5f9e4 100644
--- a/go/arrow/float16/float16_test.go
+++ b/go/arrow/float16/float16_test.go
@@ -238,6 +238,7 @@ func TestSign(t *testing.T) {
 	}{
 		{Num{bits: 0x4580}, 1},  // 5.5
 		{Num{bits: 0x0000}, 0},  // 0
+		{Num{bits: 0x8000}, 0},  // -0
 		{Num{bits: 0xC580}, -1}, // -5.5
 	} {
 		t.Run("sign", func(t *testing.T) {
@@ -248,3 +249,45 @@ func TestSign(t *testing.T) {
 		})
 	}
 }
+
+func TestSignbit(t *testing.T) {
+	for _, tc := range []struct {
+		n    Num
+		want bool
+	}{
+		{Num{bits: 0x4580}, false}, // 5.5
+		{Num{bits: 0x0000}, false}, // 0
+		{Num{bits: 0x8000}, true},  // -0
+		{Num{bits: 0xC580}, true},  // -5.5
+	} {
+		t.Run("signbit", func(t *testing.T) {
+			n := tc.n.Signbit()
+			if got, want := n, tc.want; got != want {
+				t.Fatalf("invalid value. got=%v, want=%v", got, want)
+			}
+		})
+	}
+}
+
+func TestIsNaN(t *testing.T) {
+	for _, tc := range []struct {
+		n    Num
+		want bool
+	}{
+		{NaN(), true},
+		{NaN().Negate(), true},
+		{Inf(), false},
+		{Inf().Negate(), false},
+		{Num{bits: 0x7c01}, true}, // nan
+		{Num{bits: 0xfc01}, true}, // -nan
+		{Num{bits: 0x7e00}, true}, // nan
+		{Num{bits: 0xfe00}, true}, // -nan
+	} {
+		t.Run("isnan", func(t *testing.T) {
+			n := tc.n.IsNaN()
+			if got, want := n, tc.want; got != want {
+				t.Fatalf("invalid value. got=%v, want=%v", got, want)
+			}
+		})
+	}
+}
diff --git a/go/parquet/file/column_writer_types.gen.go b/go/parquet/file/column_writer_types.gen.go
index 8b3be25f3ea29..b4d7954639319 100644
--- a/go/parquet/file/column_writer_types.gen.go
+++ b/go/parquet/file/column_writer_types.gen.go
@@ -28,6 +28,7 @@ import (
 	"github.com/apache/arrow/go/v15/parquet/internal/encoding"
 	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/apache/arrow/go/v15/parquet/metadata"
+	"github.com/apache/arrow/go/v15/parquet/schema"
 	"golang.org/x/xerrors"
 )
 
@@ -1629,7 +1630,11 @@ func (w *FixedLenByteArrayColumnChunkWriter) WriteDictIndices(indices arrow.Arra
 func (w *FixedLenByteArrayColumnChunkWriter) writeValues(values []parquet.FixedLenByteArray, numNulls int64) {
 	w.currentEncoder.(encoding.FixedLenByteArrayEncoder).Put(values)
 	if w.pageStatistics != nil {
-		w.pageStatistics.(*metadata.FixedLenByteArrayStatistics).Update(values, numNulls)
+		if w.Descr().LogicalType().Equals(schema.Float16LogicalType{}) {
+			w.pageStatistics.(*metadata.Float16Statistics).Update(values, numNulls)
+		} else {
+			w.pageStatistics.(*metadata.FixedLenByteArrayStatistics).Update(values, numNulls)
+		}
 	}
 }
 
@@ -1641,7 +1646,11 @@ func (w *FixedLenByteArrayColumnChunkWriter) writeValuesSpaced(spacedValues []pa
 	}
 	if w.pageStatistics != nil {
 		nulls := numValues - numRead
-		w.pageStatistics.(*metadata.FixedLenByteArrayStatistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+		if w.Descr().LogicalType().Equals(schema.Float16LogicalType{}) {
+			w.pageStatistics.(*metadata.Float16Statistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+		} else {
+			w.pageStatistics.(*metadata.FixedLenByteArrayStatistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+		}
 	}
 }
 
diff --git a/go/parquet/file/column_writer_types.gen.go.tmpl b/go/parquet/file/column_writer_types.gen.go.tmpl
index 7df69b4a219c6..70bcfe679eb92 100644
--- a/go/parquet/file/column_writer_types.gen.go.tmpl
+++ b/go/parquet/file/column_writer_types.gen.go.tmpl
@@ -18,7 +18,7 @@ package file
 
 import (
     "fmt"
-    
+
     "github.com/apache/arrow/go/v15/parquet"
     "github.com/apache/arrow/go/v15/parquet/metadata"
     "github.com/apache/arrow/go/v15/parquet/internal/encoding"
@@ -83,7 +83,7 @@ func (w *{{.Name}}ColumnChunkWriter) WriteBatch(values []{{.name}}, defLevels, r
   // writes a large number of values, the DataPage size can be much above the limit.
   // The purpose of this chunking is to bound this. Even if a user writes large number
   // of values, the chunking will ensure the AddDataPage() is called at a reasonable
-  // pagesize limit  
+  // pagesize limit
   var n int64
   switch {
   case defLevels != nil:
@@ -107,7 +107,7 @@ func (w *{{.Name}}ColumnChunkWriter) WriteBatch(values []{{.name}}, defLevels, r
     valueOffset += toWrite
     w.checkDictionarySizeLimit()
   })
-  return 
+  return
 }
 
 // WriteBatchSpaced writes a batch of repetition levels, definition levels, and values to the
@@ -132,7 +132,7 @@ func (w *{{.Name}}ColumnChunkWriter) WriteBatchSpaced(values []{{.name}}, defLev
     length = len(values)
   }
   doBatches(int64(length), w.props.WriteBatchSize(), func(offset, batch int64) {
-    var vals []{{.name}}    
+    var vals []{{.name}}
     info := w.maybeCalculateValidityBits(levelSliceOrNil(defLevels, offset, batch), batch)
 
     w.writeLevelsSpaced(batch, levelSliceOrNil(defLevels, offset, batch), levelSliceOrNil(repLevels, offset, batch))
@@ -165,7 +165,7 @@ func (w *{{.Name}}ColumnChunkWriter) WriteDictIndices(indices arrow.Array, defLe
       }
     }
   }()
-  
+
   valueOffset := int64(0)
   length := len(defLevels)
   if defLevels == nil {
@@ -193,14 +193,22 @@ func (w *{{.Name}}ColumnChunkWriter) WriteDictIndices(indices arrow.Array, defLe
 
     valueOffset += info.numSpaced()
   })
-  
+
   return
 }
 
 func (w *{{.Name}}ColumnChunkWriter) writeValues(values []{{.name}}, numNulls int64) {
   w.currentEncoder.(encoding.{{.Name}}Encoder).Put(values)
   if w.pageStatistics != nil {
+{{- if ne .Name "FixedLenByteArray"}}
     w.pageStatistics.(*metadata.{{.Name}}Statistics).Update(values, numNulls)
+{{- else}}
+    if w.Descr().LogicalType().Equals(schema.Float16LogicalType{}) {
+      w.pageStatistics.(*metadata.Float16Statistics).Update(values, numNulls)
+    } else {
+      w.pageStatistics.(*metadata.{{.Name}}Statistics).Update(values, numNulls)
+    }
+{{- end}}
   }
 }
 
@@ -212,7 +220,15 @@ func (w *{{.Name}}ColumnChunkWriter) writeValuesSpaced(spacedValues []{{.name}},
   }
   if w.pageStatistics != nil {
     nulls := numValues - numRead
+{{- if ne .Name "FixedLenByteArray"}}
     w.pageStatistics.(*metadata.{{.Name}}Statistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+{{- else}}
+    if w.Descr().LogicalType().Equals(schema.Float16LogicalType{}) {
+      w.pageStatistics.(*metadata.Float16Statistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+    } else {
+      w.pageStatistics.(*metadata.{{.Name}}Statistics).UpdateSpaced(spacedValues, validBits, validBitsOffset, nulls)
+    }
+{{- end}}
   }
 }
 
diff --git a/go/parquet/internal/gen-go/parquet/GoUnusedProtection__.go b/go/parquet/internal/gen-go/parquet/GoUnusedProtection__.go
index 1de0c8dee4cbd..01f1eb5aa99e3 100644
--- a/go/parquet/internal/gen-go/parquet/GoUnusedProtection__.go
+++ b/go/parquet/internal/gen-go/parquet/GoUnusedProtection__.go
@@ -1,4 +1,4 @@
-// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.
+// Code generated by Thrift Compiler (0.18.1). DO NOT EDIT.
 
 package parquet
 
diff --git a/go/parquet/internal/gen-go/parquet/parquet-consts.go b/go/parquet/internal/gen-go/parquet/parquet-consts.go
index d4a63b22b890a..ab0a73c596e7d 100644
--- a/go/parquet/internal/gen-go/parquet/parquet-consts.go
+++ b/go/parquet/internal/gen-go/parquet/parquet-consts.go
@@ -1,21 +1,28 @@
-// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.
+// Code generated by Thrift Compiler (0.18.1). DO NOT EDIT.
 
 package parquet
 
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"time"
 	thrift "github.com/apache/thrift/lib/go/thrift"
+	"strings"
+	"regexp"
 )
 
 // (needed to ensure safety because of naive import list construction.)
 var _ = thrift.ZERO
 var _ = fmt.Printf
+var _ = errors.New
 var _ = context.Background
 var _ = time.Now
 var _ = bytes.Equal
+// (needed by validator.)
+var _ = strings.Contains
+var _ = regexp.MatchString
 
 
 func init() {
diff --git a/go/parquet/internal/gen-go/parquet/parquet.go b/go/parquet/internal/gen-go/parquet/parquet.go
index d4508f8e4529f..9dcedae8888d3 100644
--- a/go/parquet/internal/gen-go/parquet/parquet.go
+++ b/go/parquet/internal/gen-go/parquet/parquet.go
@@ -1,4 +1,4 @@
-// Code generated by Thrift Compiler (0.16.0). DO NOT EDIT.
+// Code generated by Thrift Compiler (0.18.1). DO NOT EDIT.
 
 package parquet
 
@@ -10,14 +10,20 @@ import (
 	"fmt"
 	"time"
 	thrift "github.com/apache/thrift/lib/go/thrift"
+	"strings"
+	"regexp"
 )
 
 // (needed to ensure safety because of naive import list construction.)
 var _ = thrift.ZERO
 var _ = fmt.Printf
+var _ = errors.New
 var _ = context.Background
 var _ = time.Now
 var _ = bytes.Equal
+// (needed by validator.)
+var _ = strings.Contains
+var _ = regexp.MatchString
 
 //Types supported by Parquet.  These types are intended to be used in combination
 //with the encodings to control the on disk storage format.
@@ -94,9 +100,10 @@ func (p * Type) Value() (driver.Value, error) {
   }
 return int64(*p), nil
 }
-//Common types used by frameworks(e.g. hive, pig) using parquet.  This helps map
-//between types in those frameworks to the base types in parquet.  This is only
-//metadata and not needed to read or write the data.
+//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.
 type ConvertedType int64
 const (
   ConvertedType_UTF8 ConvertedType = 0
@@ -897,6 +904,9 @@ func (p *Statistics) String() string {
   return fmt.Sprintf("Statistics(%+v)", *p)
 }
 
+func (p *Statistics) Validate() error {
+  return nil
+}
 // Empty structs to use as logical type annotations
 type StringType struct {
 }
@@ -958,6 +968,9 @@ func (p *StringType) String() string {
   return fmt.Sprintf("StringType(%+v)", *p)
 }
 
+func (p *StringType) Validate() error {
+  return nil
+}
 type UUIDType struct {
 }
 
@@ -1018,6 +1031,9 @@ func (p *UUIDType) String() string {
   return fmt.Sprintf("UUIDType(%+v)", *p)
 }
 
+func (p *UUIDType) Validate() error {
+  return nil
+}
 type MapType struct {
 }
 
@@ -1078,6 +1094,9 @@ func (p *MapType) String() string {
   return fmt.Sprintf("MapType(%+v)", *p)
 }
 
+func (p *MapType) Validate() error {
+  return nil
+}
 type ListType struct {
 }
 
@@ -1138,6 +1157,9 @@ func (p *ListType) String() string {
   return fmt.Sprintf("ListType(%+v)", *p)
 }
 
+func (p *ListType) Validate() error {
+  return nil
+}
 type EnumType struct {
 }
 
@@ -1198,6 +1220,9 @@ func (p *EnumType) String() string {
   return fmt.Sprintf("EnumType(%+v)", *p)
 }
 
+func (p *EnumType) Validate() error {
+  return nil
+}
 type DateType struct {
 }
 
@@ -1258,6 +1283,72 @@ func (p *DateType) String() string {
   return fmt.Sprintf("DateType(%+v)", *p)
 }
 
+func (p *DateType) Validate() error {
+  return nil
+}
+type Float16Type struct {
+}
+
+func NewFloat16Type() *Float16Type {
+  return &Float16Type{}
+}
+
+func (p *Float16Type) Read(ctx context.Context, iprot thrift.TProtocol) error {
+  if _, err := iprot.ReadStructBegin(ctx); err != nil {
+    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
+  }
+
+
+  for {
+    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx)
+    if err != nil {
+      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
+    }
+    if fieldTypeId == thrift.STOP { break; }
+    if err := iprot.Skip(ctx, fieldTypeId); err != nil {
+      return err
+    }
+    if err := iprot.ReadFieldEnd(ctx); err != nil {
+      return err
+    }
+  }
+  if err := iprot.ReadStructEnd(ctx); err != nil {
+    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+  }
+  return nil
+}
+
+func (p *Float16Type) Write(ctx context.Context, oprot thrift.TProtocol) error {
+  if err := oprot.WriteStructBegin(ctx, "Float16Type"); err != nil {
+    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
+  if p != nil {
+  }
+  if err := oprot.WriteFieldStop(ctx); err != nil {
+    return thrift.PrependError("write field stop error: ", err) }
+  if err := oprot.WriteStructEnd(ctx); err != nil {
+    return thrift.PrependError("write struct stop error: ", err) }
+  return nil
+}
+
+func (p *Float16Type) Equals(other *Float16Type) bool {
+  if p == other {
+    return true
+  } else if p == nil || other == nil {
+    return false
+  }
+  return true
+}
+
+func (p *Float16Type) String() string {
+  if p == nil {
+    return "<nil>"
+  }
+  return fmt.Sprintf("Float16Type(%+v)", *p)
+}
+
+func (p *Float16Type) Validate() error {
+  return nil
+}
 // Logical type to annotate a column that is always null.
 // 
 // Sometimes when discovering the schema of existing data, values are always
@@ -1323,6 +1414,9 @@ func (p *NullType) String() string {
   return fmt.Sprintf("NullType(%+v)", *p)
 }
 
+func (p *NullType) Validate() error {
+  return nil
+}
 // Decimal logical type annotation
 // 
 // To maintain forward-compatibility in v1, implementations using this logical
@@ -1478,6 +1572,9 @@ func (p *DecimalType) String() string {
   return fmt.Sprintf("DecimalType(%+v)", *p)
 }
 
+func (p *DecimalType) Validate() error {
+  return nil
+}
 // Time units for logical types
 type MilliSeconds struct {
 }
@@ -1539,6 +1636,9 @@ func (p *MilliSeconds) String() string {
   return fmt.Sprintf("MilliSeconds(%+v)", *p)
 }
 
+func (p *MilliSeconds) Validate() error {
+  return nil
+}
 type MicroSeconds struct {
 }
 
@@ -1599,6 +1699,9 @@ func (p *MicroSeconds) String() string {
   return fmt.Sprintf("MicroSeconds(%+v)", *p)
 }
 
+func (p *MicroSeconds) Validate() error {
+  return nil
+}
 type NanoSeconds struct {
 }
 
@@ -1659,6 +1762,9 @@ func (p *NanoSeconds) String() string {
   return fmt.Sprintf("NanoSeconds(%+v)", *p)
 }
 
+func (p *NanoSeconds) Validate() error {
+  return nil
+}
 // Attributes:
 //  - MILLIS
 //  - MICROS
@@ -1879,6 +1985,9 @@ func (p *TimeUnit) String() string {
   return fmt.Sprintf("TimeUnit(%+v)", *p)
 }
 
+func (p *TimeUnit) Validate() error {
+  return nil
+}
 // Timestamp logical type annotation
 // 
 // Allowed for physical types: INT64
@@ -2038,6 +2147,9 @@ func (p *TimestampType) String() string {
   return fmt.Sprintf("TimestampType(%+v)", *p)
 }
 
+func (p *TimestampType) Validate() error {
+  return nil
+}
 // Time logical type annotation
 // 
 // Allowed for physical types: INT32 (millis), INT64 (micros, nanos)
@@ -2197,6 +2309,9 @@ func (p *TimeType) String() string {
   return fmt.Sprintf("TimeType(%+v)", *p)
 }
 
+func (p *TimeType) Validate() error {
+  return nil
+}
 // Integer logical type annotation
 // 
 // bitWidth must be 8, 16, 32, or 64.
@@ -2352,6 +2467,9 @@ func (p *IntType) String() string {
   return fmt.Sprintf("IntType(%+v)", *p)
 }
 
+func (p *IntType) Validate() error {
+  return nil
+}
 // Embedded JSON logical type annotation
 // 
 // Allowed for physical types: BINARY
@@ -2415,6 +2533,9 @@ func (p *JsonType) String() string {
   return fmt.Sprintf("JsonType(%+v)", *p)
 }
 
+func (p *JsonType) Validate() error {
+  return nil
+}
 // Embedded BSON logical type annotation
 // 
 // Allowed for physical types: BINARY
@@ -2478,11 +2599,14 @@ func (p *BsonType) String() string {
   return fmt.Sprintf("BsonType(%+v)", *p)
 }
 
+func (p *BsonType) Validate() error {
+  return nil
+}
 // LogicalType annotations to replace ConvertedType.
 // 
 // To maintain compatibility, implementations using LogicalType for a
-// SchemaElement must also set the corresponding ConvertedType from the
-// following table.
+// SchemaElement must also set the corresponding ConvertedType (if any)
+// from the following table.
 // 
 // Attributes:
 //  - STRING
@@ -2498,6 +2622,7 @@ func (p *BsonType) String() string {
 //  - JSON
 //  - BSON
 //  - UUID
+//  - FLOAT16
 type LogicalType struct {
   STRING *StringType `thrift:"STRING,1" db:"STRING" json:"STRING,omitempty"`
   MAP *MapType `thrift:"MAP,2" db:"MAP" json:"MAP,omitempty"`
@@ -2513,6 +2638,7 @@ type LogicalType struct {
   JSON *JsonType `thrift:"JSON,12" db:"JSON" json:"JSON,omitempty"`
   BSON *BsonType `thrift:"BSON,13" db:"BSON" json:"BSON,omitempty"`
   UUID *UUIDType `thrift:"UUID,14" db:"UUID" json:"UUID,omitempty"`
+  FLOAT16 *Float16Type `thrift:"FLOAT16,15" db:"FLOAT16" json:"FLOAT16,omitempty"`
 }
 
 func NewLogicalType() *LogicalType {
@@ -2610,6 +2736,13 @@ func (p *LogicalType) GetUUID() *UUIDType {
   }
 return p.UUID
 }
+var LogicalType_FLOAT16_DEFAULT *Float16Type
+func (p *LogicalType) GetFLOAT16() *Float16Type {
+  if !p.IsSetFLOAT16() {
+    return LogicalType_FLOAT16_DEFAULT
+  }
+return p.FLOAT16
+}
 func (p *LogicalType) CountSetFieldsLogicalType() int {
   count := 0
   if (p.IsSetSTRING()) {
@@ -2651,6 +2784,9 @@ func (p *LogicalType) CountSetFieldsLogicalType() int {
   if (p.IsSetUUID()) {
     count++
   }
+  if (p.IsSetFLOAT16()) {
+    count++
+  }
   return count
 
 }
@@ -2707,6 +2843,10 @@ func (p *LogicalType) IsSetUUID() bool {
   return p.UUID != nil
 }
 
+func (p *LogicalType) IsSetFLOAT16() bool {
+  return p.FLOAT16 != nil
+}
+
 func (p *LogicalType) Read(ctx context.Context, iprot thrift.TProtocol) error {
   if _, err := iprot.ReadStructBegin(ctx); err != nil {
     return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
@@ -2850,6 +2990,16 @@ func (p *LogicalType) Read(ctx context.Context, iprot thrift.TProtocol) error {
           return err
         }
       }
+    case 15:
+      if fieldTypeId == thrift.STRUCT {
+        if err := p.ReadField15(ctx, iprot); err != nil {
+          return err
+        }
+      } else {
+        if err := iprot.Skip(ctx, fieldTypeId); err != nil {
+          return err
+        }
+      }
     default:
       if err := iprot.Skip(ctx, fieldTypeId); err != nil {
         return err
@@ -2969,6 +3119,14 @@ func (p *LogicalType)  ReadField14(ctx context.Context, iprot thrift.TProtocol)
   return nil
 }
 
+func (p *LogicalType)  ReadField15(ctx context.Context, iprot thrift.TProtocol) error {
+  p.FLOAT16 = &Float16Type{}
+  if err := p.FLOAT16.Read(ctx, iprot); err != nil {
+    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.FLOAT16), err)
+  }
+  return nil
+}
+
 func (p *LogicalType) Write(ctx context.Context, oprot thrift.TProtocol) error {
   if c := p.CountSetFieldsLogicalType(); c != 1 {
     return fmt.Errorf("%T write union: exactly one field must be set (%d set)", p, c)
@@ -2989,6 +3147,7 @@ func (p *LogicalType) Write(ctx context.Context, oprot thrift.TProtocol) error {
     if err := p.writeField12(ctx, oprot); err != nil { return err }
     if err := p.writeField13(ctx, oprot); err != nil { return err }
     if err := p.writeField14(ctx, oprot); err != nil { return err }
+    if err := p.writeField15(ctx, oprot); err != nil { return err }
   }
   if err := oprot.WriteFieldStop(ctx); err != nil {
     return thrift.PrependError("write field stop error: ", err) }
@@ -3166,6 +3325,19 @@ func (p *LogicalType) writeField14(ctx context.Context, oprot thrift.TProtocol)
   return err
 }
 
+func (p *LogicalType) writeField15(ctx context.Context, oprot thrift.TProtocol) (err error) {
+  if p.IsSetFLOAT16() {
+    if err := oprot.WriteFieldBegin(ctx, "FLOAT16", thrift.STRUCT, 15); err != nil {
+      return thrift.PrependError(fmt.Sprintf("%T write field begin error 15:FLOAT16: ", p), err) }
+    if err := p.FLOAT16.Write(ctx, oprot); err != nil {
+      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.FLOAT16), err)
+    }
+    if err := oprot.WriteFieldEnd(ctx); err != nil {
+      return thrift.PrependError(fmt.Sprintf("%T write field end error 15:FLOAT16: ", p), err) }
+  }
+  return err
+}
+
 func (p *LogicalType) Equals(other *LogicalType) bool {
   if p == other {
     return true
@@ -3185,6 +3357,7 @@ func (p *LogicalType) Equals(other *LogicalType) bool {
   if !p.JSON.Equals(other.JSON) { return false }
   if !p.BSON.Equals(other.BSON) { return false }
   if !p.UUID.Equals(other.UUID) { return false }
+  if !p.FLOAT16.Equals(other.FLOAT16) { return false }
   return true
 }
 
@@ -3195,6 +3368,9 @@ func (p *LogicalType) String() string {
   return fmt.Sprintf("LogicalType(%+v)", *p)
 }
 
+func (p *LogicalType) Validate() error {
+  return nil
+}
 // 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
@@ -3202,7 +3378,7 @@ func (p *LogicalType) String() string {
 // 
 // Attributes:
 //  - Type: Data type for this field. Not set if the current element is a non-leaf node
-//  - TypeLength: If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the vales.
+//  - TypeLength: 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.
@@ -3213,10 +3389,14 @@ func (p *LogicalType) String() string {
 // 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
-//  - ConvertedType: When the schema is the result of a conversion from another model
+//  - ConvertedType: DEPRECATED: When the schema is the result of a conversion from another model.
 // Used to record the original type to help with cross conversion.
-//  - Scale: Used when this column contains decimal data.
+// 
+// This is superseded by logicalType.
+//  - Scale: 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.
 //  - Precision
 //  - FieldID: When the original schema supports field ids, this will save the
 // original field id in the parquet schema
@@ -3776,6 +3956,9 @@ func (p *SchemaElement) String() string {
   return fmt.Sprintf("SchemaElement(%+v)", *p)
 }
 
+func (p *SchemaElement) Validate() error {
+  return nil
+}
 // Data page header
 // 
 // Attributes:
@@ -4059,6 +4242,9 @@ func (p *DataPageHeader) String() string {
   return fmt.Sprintf("DataPageHeader(%+v)", *p)
 }
 
+func (p *DataPageHeader) Validate() error {
+  return nil
+}
 type IndexPageHeader struct {
 }
 
@@ -4119,6 +4305,14 @@ func (p *IndexPageHeader) String() string {
   return fmt.Sprintf("IndexPageHeader(%+v)", *p)
 }
 
+func (p *IndexPageHeader) Validate() error {
+  return nil
+}
+// 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.
+// 
+// 
 // Attributes:
 //  - NumValues: Number of values in the dictionary *
 //  - Encoding: Encoding using this dictionary page *
@@ -4319,6 +4513,9 @@ func (p *DictionaryPageHeader) String() string {
   return fmt.Sprintf("DictionaryPageHeader(%+v)", *p)
 }
 
+func (p *DictionaryPageHeader) Validate() error {
+  return nil
+}
 // 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
@@ -4738,6 +4935,9 @@ func (p *DataPageHeaderV2) String() string {
   return fmt.Sprintf("DataPageHeaderV2(%+v)", *p)
 }
 
+func (p *DataPageHeaderV2) Validate() error {
+  return nil
+}
 // Block-based algorithm type annotation. *
 type SplitBlockAlgorithm struct {
 }
@@ -4799,6 +4999,9 @@ func (p *SplitBlockAlgorithm) String() string {
   return fmt.Sprintf("SplitBlockAlgorithm(%+v)", *p)
 }
 
+func (p *SplitBlockAlgorithm) Validate() error {
+  return nil
+}
 // The algorithm used in Bloom filter. *
 // 
 // Attributes:
@@ -4923,6 +5126,9 @@ func (p *BloomFilterAlgorithm) String() string {
   return fmt.Sprintf("BloomFilterAlgorithm(%+v)", *p)
 }
 
+func (p *BloomFilterAlgorithm) Validate() error {
+  return nil
+}
 // Hash strategy type annotation. xxHash is an extremely fast non-cryptographic hash
 // algorithm. It uses 64 bits version of xxHash.
 // 
@@ -4986,6 +5192,9 @@ func (p *XxHash) String() string {
   return fmt.Sprintf("XxHash(%+v)", *p)
 }
 
+func (p *XxHash) Validate() error {
+  return nil
+}
 // The hash function used in Bloom filter. This function takes the hash of a column value
 // using plain encoding.
 // 
@@ -5112,6 +5321,9 @@ func (p *BloomFilterHash) String() string {
   return fmt.Sprintf("BloomFilterHash(%+v)", *p)
 }
 
+func (p *BloomFilterHash) Validate() error {
+  return nil
+}
 // The compression used in the Bloom filter.
 // 
 type Uncompressed struct {
@@ -5174,6 +5386,9 @@ func (p *Uncompressed) String() string {
   return fmt.Sprintf("Uncompressed(%+v)", *p)
 }
 
+func (p *Uncompressed) Validate() error {
+  return nil
+}
 // Attributes:
 //  - UNCOMPRESSED
 type BloomFilterCompression struct {
@@ -5296,6 +5511,9 @@ func (p *BloomFilterCompression) String() string {
   return fmt.Sprintf("BloomFilterCompression(%+v)", *p)
 }
 
+func (p *BloomFilterCompression) Validate() error {
+  return nil
+}
 // Bloom filter header is stored at beginning of Bloom filter data of each column
 // and followed by its bitset.
 // 
@@ -5553,36 +5771,29 @@ func (p *BloomFilterHeader) String() string {
   return fmt.Sprintf("BloomFilterHeader(%+v)", *p)
 }
 
+func (p *BloomFilterHeader) Validate() error {
+  return nil
+}
 // Attributes:
 //  - Type: the type of the page: indicates which of the *_header fields is set *
 //  - UncompressedPageSize: Uncompressed page size in bytes (not including this header) *
 //  - CompressedPageSize: Compressed (and potentially encrypted) page size in bytes, not including this header *
-//  - Crc: The 32bit CRC for the page, to be be calculated as follows:
-// - Using the standard CRC32 algorithm
-// - On the data only, i.e. this header should not be included. 'Data'
-//   hereby refers to the concatenation of the repetition levels, the
-//   definition levels and the column value, in this exact order.
-// - On the encoded versions of the repetition levels, definition levels and
-//   column values
-// - On the compressed versions of the repetition levels, definition levels
-//   and column values where possible;
-//   - For v1 data pages, the repetition levels, definition levels and column
-//     values are always compressed together. If a compression scheme is
-//     specified, the CRC shall be calculated on the compressed version of
-//     this concatenation. If no compression scheme is specified, the CRC
-//     shall be calculated on the uncompressed version of this concatenation.
-//   - For v2 data pages, the repetition levels and definition levels are
-//     handled separately from the data and are never compressed (only
-//     encoded). If a compression scheme is specified, the CRC shall be
-//     calculated on the concatenation of the uncompressed repetition levels,
-//     uncompressed definition levels and the compressed column values.
-//     If no compression scheme is specified, the CRC shall be calculated on
-//     the uncompressed concatenation.
-// - In encrypted columns, CRC is calculated after page encryption; the
-//   encryption itself is performed after page compression (if compressed)
+//  - Crc: 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.
-// 
 //  - DataPageHeader
 //  - IndexPageHeader
 //  - DictionaryPageHeader
@@ -6006,6 +6217,9 @@ func (p *PageHeader) String() string {
   return fmt.Sprintf("PageHeader(%+v)", *p)
 }
 
+func (p *PageHeader) Validate() error {
+  return nil
+}
 // Wrapper struct to store key values
 // 
 // Attributes:
@@ -6165,6 +6379,9 @@ func (p *KeyValue) String() string {
   return fmt.Sprintf("KeyValue(%+v)", *p)
 }
 
+func (p *KeyValue) Validate() error {
+  return nil
+}
 // Wrapper struct to specify sort order
 // 
 // Attributes:
@@ -6358,6 +6575,9 @@ func (p *SortingColumn) String() string {
   return fmt.Sprintf("SortingColumn(%+v)", *p)
 }
 
+func (p *SortingColumn) Validate() error {
+  return nil
+}
 // statistics of a given page type and encoding
 // 
 // Attributes:
@@ -6552,6 +6772,9 @@ func (p *PageEncodingStats) String() string {
   return fmt.Sprintf("PageEncodingStats(%+v)", *p)
 }
 
+func (p *PageEncodingStats) Validate() error {
+  return nil
+}
 // Description for column metadata
 // 
 // Attributes:
@@ -7346,6 +7569,9 @@ func (p *ColumnMetaData) String() string {
   return fmt.Sprintf("ColumnMetaData(%+v)", *p)
 }
 
+func (p *ColumnMetaData) Validate() error {
+  return nil
+}
 type EncryptionWithFooterKey struct {
 }
 
@@ -7406,6 +7632,9 @@ func (p *EncryptionWithFooterKey) String() string {
   return fmt.Sprintf("EncryptionWithFooterKey(%+v)", *p)
 }
 
+func (p *EncryptionWithFooterKey) Validate() error {
+  return nil
+}
 // Attributes:
 //  - PathInSchema: Column path in schema *
 //  - KeyMetadata: Retrieval metadata of column encryption key *
@@ -7581,6 +7810,9 @@ func (p *EncryptionWithColumnKey) String() string {
   return fmt.Sprintf("EncryptionWithColumnKey(%+v)", *p)
 }
 
+func (p *EncryptionWithColumnKey) Validate() error {
+  return nil
+}
 // Attributes:
 //  - ENCRYPTION_WITH_FOOTER_KEY
 //  - ENCRYPTION_WITH_COLUMN_KEY
@@ -7752,6 +7984,9 @@ func (p *ColumnCryptoMetaData) String() string {
   return fmt.Sprintf("ColumnCryptoMetaData(%+v)", *p)
 }
 
+func (p *ColumnCryptoMetaData) Validate() error {
+  return nil
+}
 // Attributes:
 //  - FilePath: File where column data is stored.  If not set, assumed to be same file as
 // metadata.  This path is relative to the current file.
@@ -8254,6 +8489,9 @@ func (p *ColumnChunk) String() string {
   return fmt.Sprintf("ColumnChunk(%+v)", *p)
 }
 
+func (p *ColumnChunk) Validate() error {
+  return nil
+}
 // Attributes:
 //  - Columns: Metadata for each column chunk in this row group.
 // This list must have the same order as the SchemaElement list in FileMetaData.
@@ -8694,6 +8932,9 @@ func (p *RowGroup) String() string {
   return fmt.Sprintf("RowGroup(%+v)", *p)
 }
 
+func (p *RowGroup) Validate() error {
+  return nil
+}
 // Empty struct to signal the order defined by the physical or logical type
 type TypeDefinedOrder struct {
 }
@@ -8755,6 +8996,9 @@ func (p *TypeDefinedOrder) String() string {
   return fmt.Sprintf("TypeDefinedOrder(%+v)", *p)
 }
 
+func (p *TypeDefinedOrder) Validate() error {
+  return nil
+}
 // Union to specify the order used for the min_value and max_value fields for a
 // column. This union takes the role of an enhanced enum that allows rich
 // elements (which will be needed for a collation-based ordering in the future).
@@ -8808,6 +9052,13 @@ func (p *TypeDefinedOrder) String() string {
 //     - If the min is +0, the row group may contain -0 values as well.
 //     - If the max is -0, the row group may contain +0 values as well.
 //     - When looking for NaN values, min and max should be ignored.
+// 
+//     When writing statistics the following rules should be followed:
+//     - NaNs should not be written to min or max statistics fields.
+//     - If the computed max value is zero (whether negative or positive),
+//       `+0.0` should be written into the max statistics field.
+//     - If the computed min value is zero (whether negative or positive),
+//       `-0.0` should be written into the min statistics field.
 type ColumnOrder struct {
   TYPE_ORDER *TypeDefinedOrder `thrift:"TYPE_ORDER,1" db:"TYPE_ORDER" json:"TYPE_ORDER,omitempty"`
 }
@@ -8928,6 +9179,9 @@ func (p *ColumnOrder) String() string {
   return fmt.Sprintf("ColumnOrder(%+v)", *p)
 }
 
+func (p *ColumnOrder) Validate() error {
+  return nil
+}
 // Attributes:
 //  - Offset: Offset of the page in the file *
 //  - CompressedPageSize: Size of the page, including header. Sum of compressed_page_size and header
@@ -9120,6 +9374,9 @@ func (p *PageLocation) String() string {
   return fmt.Sprintf("PageLocation(%+v)", *p)
 }
 
+func (p *PageLocation) Validate() error {
+  return nil
+}
 // Attributes:
 //  - PageLocations: PageLocations, ordered by increasing PageLocation.offset. It is required
 // that page_locations[i].first_row_index < page_locations[i+1].first_row_index.
@@ -9251,6 +9508,9 @@ func (p *OffsetIndex) String() string {
   return fmt.Sprintf("OffsetIndex(%+v)", *p)
 }
 
+func (p *OffsetIndex) Validate() error {
+  return nil
+}
 // Description for ColumnIndex.
 // Each <array-field>[i] refers to the page at OffsetIndex.page_locations[i]
 // 
@@ -9260,15 +9520,16 @@ func (p *OffsetIndex) String() string {
 // 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.
-//  - MinValues: Two lists containing lower and upper bounds for the values of each page.
-// 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.
+//  - MinValues: 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.
 //  - MaxValues
-//  - BoundaryOrder: Stores whether both min_values and max_values are orderd and if so, in
+//  - BoundaryOrder: 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.
@@ -9644,6 +9905,9 @@ func (p *ColumnIndex) String() string {
   return fmt.Sprintf("ColumnIndex(%+v)", *p)
 }
 
+func (p *ColumnIndex) Validate() error {
+  return nil
+}
 // Attributes:
 //  - AadPrefix: AAD prefix *
 //  - AadFileUnique: Unique file identifier part of AAD suffix *
@@ -9848,6 +10112,9 @@ func (p *AesGcmV1) String() string {
   return fmt.Sprintf("AesGcmV1(%+v)", *p)
 }
 
+func (p *AesGcmV1) Validate() error {
+  return nil
+}
 // Attributes:
 //  - AadPrefix: AAD prefix *
 //  - AadFileUnique: Unique file identifier part of AAD suffix *
@@ -10052,6 +10319,9 @@ func (p *AesGcmCtrV1) String() string {
   return fmt.Sprintf("AesGcmCtrV1(%+v)", *p)
 }
 
+func (p *AesGcmCtrV1) Validate() error {
+  return nil
+}
 // Attributes:
 //  - AES_GCM_V1
 //  - AES_GCM_CTR_V1
@@ -10223,6 +10493,9 @@ func (p *EncryptionAlgorithm) String() string {
   return fmt.Sprintf("EncryptionAlgorithm(%+v)", *p)
 }
 
+func (p *EncryptionAlgorithm) Validate() error {
+  return nil
+}
 // Description for file metadata
 // 
 // Attributes:
@@ -10240,17 +10513,20 @@ func (p *EncryptionAlgorithm) String() string {
 // <Application> version <App Version> (build <App Build Hash>).
 // e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55)
 // 
-//  - ColumnOrders: Sort order used for the min_value and max_value fields 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.
+//  - ColumnOrders: 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 is
-// undefined. To ensure well-defined behaviour, if min_value and max_value are
-// written to a Parquet file, column_orders must be written as well.
+// 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 are always sorted by signed comparison
-// regardless of column_orders.
+// The obsolete min and max fields in the Statistics object are always sorted
+// by signed comparison regardless of column_orders.
 //  - EncryptionAlgorithm: Encryption algorithm. This field is set only in encrypted files
 // with plaintext footer. Files with encrypted footer store algorithm id
 // in FileCryptoMetaData structure.
@@ -10803,6 +11079,9 @@ func (p *FileMetaData) String() string {
   return fmt.Sprintf("FileMetaData(%+v)", *p)
 }
 
+func (p *FileMetaData) Validate() error {
+  return nil
+}
 // Crypto metadata for files with encrypted footer *
 // 
 // Attributes:
@@ -10965,3 +11244,6 @@ func (p *FileCryptoMetaData) String() string {
   return fmt.Sprintf("FileCryptoMetaData(%+v)", *p)
 }
 
+func (p *FileCryptoMetaData) Validate() error {
+  return nil
+}
diff --git a/go/parquet/internal/testutils/random.go b/go/parquet/internal/testutils/random.go
index bb101ebf9a92d..bb9ee0cdf2bba 100644
--- a/go/parquet/internal/testutils/random.go
+++ b/go/parquet/internal/testutils/random.go
@@ -28,6 +28,7 @@ import (
 	"github.com/apache/arrow/go/v15/arrow/array"
 	"github.com/apache/arrow/go/v15/arrow/bitutil"
 	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/apache/arrow/go/v15/parquet"
 	"github.com/apache/arrow/go/v15/parquet/pqarrow"
@@ -369,6 +370,17 @@ func randFloat64(r *rand.Rand) float64 {
 	}
 }
 
+// randFloat16 creates a random float value with a normal distribution
+// to better spread the values out and ensure we do not return any NaN or Inf values.
+func randFloat16(r *rand.Rand) float16.Num {
+	for {
+		f := float16.FromBits(uint16(r.Uint64n(math.MaxUint16 + 1)))
+		if !f.IsNaN() {
+			return f
+		}
+	}
+}
+
 // FillRandomFloat32 populates out with random float32 values using seed as the random
 // seed for the generator to allow consistency for testing.
 func FillRandomFloat32(seed uint64, out []float32) {
@@ -387,6 +399,15 @@ func FillRandomFloat64(seed uint64, out []float64) {
 	}
 }
 
+// FillRandomFloat16 populates out with random float64 values using seed as the random
+// seed for the generator to allow consistency for testing.
+func FillRandomFloat16(seed uint64, out []float16.Num) {
+	r := rand.New(rand.NewSource(seed))
+	for idx := range out {
+		out[idx] = randFloat16(r)
+	}
+}
+
 // FillRandomByteArray populates out with random ByteArray values with lengths between 2 and 12
 // using heap as the actual memory storage used for the bytes generated. Each element of
 // out will be some slice of the bytes in heap, and as such heap must outlive the byte array slices.
@@ -456,6 +477,8 @@ func InitValues(values interface{}, heap *memory.Buffer) {
 		FillRandomFloat32(0, arr)
 	case []float64:
 		FillRandomFloat64(0, arr)
+	case []float16.Num:
+		FillRandomFloat16(0, arr)
 	case []parquet.Int96:
 		FillRandomInt96(0, arr)
 	case []parquet.ByteArray:
diff --git a/go/parquet/internal/testutils/random_arrow.go b/go/parquet/internal/testutils/random_arrow.go
index d886db0360b84..7dd2a3e8b77e3 100644
--- a/go/parquet/internal/testutils/random_arrow.go
+++ b/go/parquet/internal/testutils/random_arrow.go
@@ -19,6 +19,7 @@ package testutils
 import (
 	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/arrow/memory"
 	"golang.org/x/exp/rand"
 )
@@ -49,6 +50,13 @@ func RandomNonNull(mem memory.Allocator, dt arrow.DataType, size int) arrow.Arra
 		FillRandomFloat64(0, values)
 		bldr.AppendValues(values, nil)
 		return bldr.NewArray()
+	case arrow.FLOAT16:
+		bldr := array.NewFloat16Builder(mem)
+		defer bldr.Release()
+		values := make([]float16.Num, size)
+		FillRandomFloat16(0, values)
+		bldr.AppendValues(values, nil)
+		return bldr.NewArray()
 	case arrow.INT64:
 		bldr := array.NewInt64Builder(mem)
 		defer bldr.Release()
@@ -212,6 +220,21 @@ func RandomNullable(dt arrow.DataType, size int, numNulls int) arrow.Array {
 		values := make([]float64, size)
 		FillRandomFloat64(0, values)
 
+		valid := make([]bool, size)
+		for idx := range valid {
+			valid[idx] = true
+		}
+		for i := 0; i < numNulls; i++ {
+			valid[i*2] = false
+		}
+		bldr.AppendValues(values, valid)
+		return bldr.NewArray()
+	case arrow.FLOAT16:
+		bldr := array.NewFloat16Builder(memory.DefaultAllocator)
+		defer bldr.Release()
+		values := make([]float16.Num, size)
+		FillRandomFloat16(0, values)
+
 		valid := make([]bool, size)
 		for idx := range valid {
 			valid[idx] = true
diff --git a/go/parquet/metadata/statistics.go b/go/parquet/metadata/statistics.go
index 606e76ffd0454..43294272dec35 100644
--- a/go/parquet/metadata/statistics.go
+++ b/go/parquet/metadata/statistics.go
@@ -23,6 +23,7 @@ import (
 	"unsafe"
 
 	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/apache/arrow/go/v15/internal/utils"
 	"github.com/apache/arrow/go/v15/parquet"
@@ -32,7 +33,7 @@ import (
 	"github.com/apache/arrow/go/v15/parquet/schema"
 )
 
-//go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=../internal/encoding/physical_types.tmpldata statistics_types.gen.go.tmpl
+//go:generate go run ../../arrow/_tools/tmpl/main.go -i -data=statistics_types.tmpldata statistics_types.gen.go.tmpl
 
 type StatProvider interface {
 	GetMin() []byte
@@ -373,6 +374,9 @@ var (
 	defaultMinUInt96 parquet.Int96
 	defaultMaxInt96  parquet.Int96
 	defaultMaxUInt96 parquet.Int96
+
+	defaultMinFloat16 parquet.FixedLenByteArray = float16.MaxNum.ToLEBytes()
+	defaultMaxFloat16 parquet.FixedLenByteArray = float16.MinNum.ToLEBytes()
 )
 
 func init() {
@@ -407,6 +411,14 @@ func (s *Int96Statistics) defaultMax() parquet.Int96 {
 	return defaultMaxInt96
 }
 
+func (Float16Statistics) defaultMin() parquet.FixedLenByteArray {
+	return defaultMinFloat16
+}
+
+func (Float16Statistics) defaultMax() parquet.FixedLenByteArray {
+	return defaultMaxFloat16
+}
+
 func (Float32Statistics) defaultMin() float32                             { return math.MaxFloat32 }
 func (Float32Statistics) defaultMax() float32                             { return -math.MaxFloat32 }
 func (Float64Statistics) defaultMin() float64                             { return math.MaxFloat64 }
@@ -427,6 +439,10 @@ func (FixedLenByteArrayStatistics) equal(a, b parquet.FixedLenByteArray) bool {
 	return bytes.Equal(a, b)
 }
 
+func (Float16Statistics) equal(a, b parquet.FixedLenByteArray) bool {
+	return float16.FromLEBytes(a).Equal(float16.FromLEBytes(b))
+}
+
 func (BooleanStatistics) less(a, b bool) bool {
 	return !a && b
 }
@@ -481,6 +497,10 @@ func (s *FixedLenByteArrayStatistics) less(a, b parquet.FixedLenByteArray) bool
 	return signedByteLess([]byte(a), []byte(b))
 }
 
+func (Float16Statistics) less(a, b parquet.FixedLenByteArray) bool {
+	return float16.FromLEBytes(a).Less(float16.FromLEBytes(b))
+}
+
 func (BooleanStatistics) cleanStat(minMax minmaxPairBoolean) *minmaxPairBoolean { return &minMax }
 func (Int32Statistics) cleanStat(minMax minmaxPairInt32) *minmaxPairInt32       { return &minMax }
 func (Int64Statistics) cleanStat(minMax minmaxPairInt64) *minmaxPairInt64       { return &minMax }
@@ -535,6 +555,29 @@ func (Float64Statistics) cleanStat(minMax minmaxPairFloat64) *minmaxPairFloat64
 	return &minMax
 }
 
+func (Float16Statistics) cleanStat(minMax minmaxPairFloat16) *minmaxPairFloat16 {
+	min := float16.FromLEBytes(minMax[0][:])
+	max := float16.FromLEBytes(minMax[1][:])
+
+	if min.IsNaN() || max.IsNaN() {
+		return nil
+	}
+
+	if min.Equal(float16.MaxNum) && max.Equal(float16.MinNum) {
+		return nil
+	}
+
+	zero := float16.New(0)
+	if min.Equal(zero) && !min.Signbit() {
+		minMax[0] = min.Negate().ToLEBytes()
+	}
+	if max.Equal(zero) && max.Signbit() {
+		minMax[1] = max.Negate().ToLEBytes()
+	}
+
+	return &minMax
+}
+
 func (ByteArrayStatistics) cleanStat(minMax minmaxPairByteArray) *minmaxPairByteArray {
 	if minMax[0] == nil || minMax[1] == nil {
 		return nil
diff --git a/go/parquet/metadata/statistics_test.go b/go/parquet/metadata/statistics_test.go
index 47798d3c4dd3c..19311dc8955d3 100644
--- a/go/parquet/metadata/statistics_test.go
+++ b/go/parquet/metadata/statistics_test.go
@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/apache/arrow/go/v15/arrow/bitutil"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/apache/arrow/go/v15/parquet"
 	"github.com/apache/arrow/go/v15/parquet/metadata"
@@ -32,24 +33,36 @@ import (
 // NOTE(zeroshade): tests will be added and updated after merging the "file" package
 // since the tests that I wrote relied on the file writer/reader for ease of use.
 
+func newFloat16Node(name string, rep parquet.Repetition, fieldID int32) *schema.PrimitiveNode {
+	return schema.MustPrimitive(schema.NewPrimitiveNodeLogical(name, rep, schema.Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2, fieldID))
+}
+
 func TestCheckNaNs(t *testing.T) {
 	const (
 		numvals = 8
 		min     = -4.0
 		max     = 3.0
 	)
-	nan := math.NaN()
+	var (
+		nan                              = math.NaN()
+		f16Min parquet.FixedLenByteArray = float16.New(float32(min)).ToLEBytes()
+		f16Max parquet.FixedLenByteArray = float16.New(float32(max)).ToLEBytes()
+	)
 
 	allNans := []float64{nan, nan, nan, nan, nan, nan, nan, nan}
 	allNansf32 := make([]float32, numvals)
+	allNansf16 := make([]parquet.FixedLenByteArray, numvals)
 	for idx, v := range allNans {
 		allNansf32[idx] = float32(v)
+		allNansf16[idx] = float16.New(float32(v)).ToLEBytes()
 	}
 
 	someNans := []float64{nan, max, -3.0, -1.0, nan, 2.0, min, nan}
 	someNansf32 := make([]float32, numvals)
+	someNansf16 := make([]parquet.FixedLenByteArray, numvals)
 	for idx, v := range someNans {
 		someNansf32[idx] = float32(v)
+		someNansf16[idx] = float16.New(float32(v)).ToLEBytes()
 	}
 
 	validBitmap := []byte{0x7F}       // 0b01111111
@@ -62,6 +75,8 @@ func TestCheckNaNs(t *testing.T) {
 				s.Update(values.([]float32), 0)
 			case *metadata.Float64Statistics:
 				s.Update(values.([]float64), 0)
+			case *metadata.Float16Statistics:
+				s.Update(values.([]parquet.FixedLenByteArray), 0)
 			}
 			assert.False(t, stats.HasMinMax())
 		} else {
@@ -72,6 +87,8 @@ func TestCheckNaNs(t *testing.T) {
 				s.UpdateSpaced(values.([]float32), bitmap, 0, int64(nullCount))
 			case *metadata.Float64Statistics:
 				s.UpdateSpaced(values.([]float64), bitmap, 0, int64(nullCount))
+			case *metadata.Float16Statistics:
+				s.UpdateSpaced(values.([]parquet.FixedLenByteArray), bitmap, 0, int64(nullCount))
 			}
 			assert.False(t, stats.HasMinMax())
 		}
@@ -89,6 +106,11 @@ func TestCheckNaNs(t *testing.T) {
 			assert.True(t, stats.HasMinMax())
 			assert.Equal(t, expectedMin, s.Min())
 			assert.Equal(t, expectedMax, s.Max())
+		case *metadata.Float16Statistics:
+			s.Update(values.([]parquet.FixedLenByteArray), 0)
+			assert.True(t, stats.HasMinMax())
+			assert.Equal(t, expectedMin, s.Min())
+			assert.Equal(t, expectedMax, s.Max())
 		}
 	}
 
@@ -106,34 +128,48 @@ func TestCheckNaNs(t *testing.T) {
 			assert.True(t, s.HasMinMax())
 			assert.Equal(t, expectedMin, s.Min())
 			assert.Equal(t, expectedMax, s.Max())
+		case *metadata.Float16Statistics:
+			s.UpdateSpaced(values.([]parquet.FixedLenByteArray), bitmap, 0, int64(nullCount))
+			assert.True(t, s.HasMinMax())
+			assert.Equal(t, expectedMin, s.Min())
+			assert.Equal(t, expectedMax, s.Max())
 		}
 	}
 
 	f32Col := schema.NewColumn(schema.NewFloat32Node("f", parquet.Repetitions.Optional, -1), 1, 1)
 	f64Col := schema.NewColumn(schema.NewFloat64Node("f", parquet.Repetitions.Optional, -1), 1, 1)
+	f16Col := schema.NewColumn(newFloat16Node("f", parquet.Repetitions.Required, -1), 1, 1)
 	// test values
 	someNanStats := metadata.NewStatistics(f64Col, memory.DefaultAllocator)
 	someNanStatsf32 := metadata.NewStatistics(f32Col, memory.DefaultAllocator)
+	someNanStatsf16 := metadata.NewStatistics(f16Col, memory.DefaultAllocator)
 	// ingesting only nans should not yield a min or max
 	assertUnsetMinMax(someNanStats, allNans, nil)
 	assertUnsetMinMax(someNanStatsf32, allNansf32, nil)
+	assertUnsetMinMax(someNanStatsf16, allNansf16, nil)
 	// ingesting a mix should yield a valid min/max
 	assertMinMaxAre(someNanStats, someNans, min, max)
 	assertMinMaxAre(someNanStatsf32, someNansf32, float32(min), float32(max))
+	assertMinMaxAre(someNanStatsf16, someNansf16, f16Min, f16Max)
 	// ingesting only nans after a valid min/max should have no effect
 	assertMinMaxAre(someNanStats, allNans, min, max)
 	assertMinMaxAre(someNanStatsf32, allNansf32, float32(min), float32(max))
+	assertMinMaxAre(someNanStatsf16, allNansf16, f16Min, f16Max)
 
 	someNanStats = metadata.NewStatistics(f64Col, memory.DefaultAllocator)
 	someNanStatsf32 = metadata.NewStatistics(f32Col, memory.DefaultAllocator)
+	someNanStatsf16 = metadata.NewStatistics(f16Col, memory.DefaultAllocator)
 	assertUnsetMinMax(someNanStats, allNans, validBitmap)
 	assertUnsetMinMax(someNanStatsf32, allNansf32, validBitmap)
+	assertUnsetMinMax(someNanStatsf16, allNansf16, validBitmap)
 	// nans should not pollute min/max when excluded via null bitmap
 	assertMinMaxAreSpaced(someNanStats, someNans, validBitmapNoNaNs, min, max)
 	assertMinMaxAreSpaced(someNanStatsf32, someNansf32, validBitmapNoNaNs, float32(min), float32(max))
+	assertMinMaxAreSpaced(someNanStatsf16, someNansf16, validBitmapNoNaNs, f16Min, f16Max)
 	// ingesting nans with a null bitmap should not change the result
 	assertMinMaxAreSpaced(someNanStats, someNans, validBitmap, min, max)
 	assertMinMaxAreSpaced(someNanStatsf32, someNansf32, validBitmap, float32(min), float32(max))
+	assertMinMaxAreSpaced(someNanStatsf16, someNansf16, validBitmap, f16Min, f16Max)
 }
 
 func TestCheckNegativeZeroStats(t *testing.T) {
@@ -155,37 +191,61 @@ func TestCheckNegativeZeroStats(t *testing.T) {
 			assert.True(t, math.Signbit(s.Min()))
 			assert.Equal(t, zero, s.Max())
 			assert.False(t, math.Signbit(s.Max()))
+		case *metadata.Float16Statistics:
+			s.Update(values.([]parquet.FixedLenByteArray), 0)
+			assert.True(t, s.HasMinMax())
+			var zero float64
+			min := float64(float16.FromLEBytes(s.Min()).Float32())
+			max := float64(float16.FromLEBytes(s.Max()).Float32())
+			assert.Equal(t, zero, min)
+			assert.True(t, math.Signbit(min))
+			assert.Equal(t, zero, max)
+			assert.False(t, math.Signbit(max))
 		}
 	}
 
 	fcol := schema.NewColumn(schema.NewFloat32Node("f", parquet.Repetitions.Optional, -1), 1, 1)
 	dcol := schema.NewColumn(schema.NewFloat64Node("d", parquet.Repetitions.Optional, -1), 1, 1)
+	hcol := schema.NewColumn(newFloat16Node("h", parquet.Repetitions.Optional, -1), 1, 1)
 
 	var f32zero float32
 	var f64zero float64
+	var f16PosZero parquet.FixedLenByteArray = float16.New(+f32zero).ToLEBytes()
+	var f16NegZero parquet.FixedLenByteArray = float16.New(-f32zero).ToLEBytes()
+
+	assert.False(t, float16.FromLEBytes(f16PosZero).Signbit())
+	assert.True(t, float16.FromLEBytes(f16NegZero).Signbit())
 	{
 		fstats := metadata.NewStatistics(fcol, memory.DefaultAllocator)
 		dstats := metadata.NewStatistics(dcol, memory.DefaultAllocator)
+		hstats := metadata.NewStatistics(hcol, memory.DefaultAllocator)
 		assertMinMaxZeroesSign(fstats, []float32{-f32zero, f32zero})
 		assertMinMaxZeroesSign(dstats, []float64{-f64zero, f64zero})
+		assertMinMaxZeroesSign(hstats, []parquet.FixedLenByteArray{f16NegZero, f16PosZero})
 	}
 	{
 		fstats := metadata.NewStatistics(fcol, memory.DefaultAllocator)
 		dstats := metadata.NewStatistics(dcol, memory.DefaultAllocator)
+		hstats := metadata.NewStatistics(hcol, memory.DefaultAllocator)
 		assertMinMaxZeroesSign(fstats, []float32{f32zero, -f32zero})
 		assertMinMaxZeroesSign(dstats, []float64{f64zero, -f64zero})
+		assertMinMaxZeroesSign(hstats, []parquet.FixedLenByteArray{f16PosZero, f16NegZero})
 	}
 	{
 		fstats := metadata.NewStatistics(fcol, memory.DefaultAllocator)
 		dstats := metadata.NewStatistics(dcol, memory.DefaultAllocator)
+		hstats := metadata.NewStatistics(hcol, memory.DefaultAllocator)
 		assertMinMaxZeroesSign(fstats, []float32{-f32zero, -f32zero})
 		assertMinMaxZeroesSign(dstats, []float64{-f64zero, -f64zero})
+		assertMinMaxZeroesSign(hstats, []parquet.FixedLenByteArray{f16NegZero, f16NegZero})
 	}
 	{
 		fstats := metadata.NewStatistics(fcol, memory.DefaultAllocator)
 		dstats := metadata.NewStatistics(dcol, memory.DefaultAllocator)
+		hstats := metadata.NewStatistics(hcol, memory.DefaultAllocator)
 		assertMinMaxZeroesSign(fstats, []float32{f32zero, f32zero})
 		assertMinMaxZeroesSign(dstats, []float64{f64zero, f64zero})
+		assertMinMaxZeroesSign(hstats, []parquet.FixedLenByteArray{f16PosZero, f16PosZero})
 	}
 }
 
diff --git a/go/parquet/metadata/statistics_types.gen.go b/go/parquet/metadata/statistics_types.gen.go
index e8fb9877c8444..baecd185d14fc 100644
--- a/go/parquet/metadata/statistics_types.gen.go
+++ b/go/parquet/metadata/statistics_types.gen.go
@@ -24,6 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/apache/arrow/go/v15/arrow/array"
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/apache/arrow/go/v15/internal/bitutils"
 	shared_utils "github.com/apache/arrow/go/v15/internal/utils"
@@ -2432,6 +2433,314 @@ func (s *FixedLenByteArrayStatistics) Encode() (enc EncodedStatistics, err error
 	return
 }
 
+type minmaxPairFloat16 [2]parquet.FixedLenByteArray
+
+// Float16Statistics is the typed interface for managing stats for a column
+// of Float16 type.
+type Float16Statistics struct {
+	statistics
+	min parquet.FixedLenByteArray
+	max parquet.FixedLenByteArray
+
+	bitSetReader bitutils.SetBitRunReader
+}
+
+// NewFloat16Statistics constructs an appropriate stat object type using the
+// given column descriptor and allocator.
+//
+// Panics if the physical type of descr is not parquet.Type.FixedLenByteArray
+// Panics if the logical type of descr is not schema.Float16LogicalType
+func NewFloat16Statistics(descr *schema.Column, mem memory.Allocator) *Float16Statistics {
+	if descr.PhysicalType() != parquet.Types.FixedLenByteArray {
+		panic(fmt.Errorf("parquet: invalid type %s for constructing a Float16 stat object", descr.PhysicalType()))
+	}
+	if !descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+		panic(fmt.Errorf("parquet: invalid logical type %s for constructing a Float16 stat object", descr.LogicalType().String()))
+	}
+
+	return &Float16Statistics{
+		statistics: statistics{
+			descr:            descr,
+			hasNullCount:     true,
+			hasDistinctCount: true,
+			order:            descr.SortOrder(),
+			encoder:          encoding.NewEncoder(descr.PhysicalType(), parquet.Encodings.Plain, false, descr, mem),
+			mem:              mem,
+		},
+	}
+}
+
+// NewFloat16StatisticsFromEncoded will construct a propertly typed statistics object
+// initializing it with the provided information.
+func NewFloat16StatisticsFromEncoded(descr *schema.Column, mem memory.Allocator, nvalues int64, encoded StatProvider) *Float16Statistics {
+	ret := NewFloat16Statistics(descr, mem)
+	ret.nvalues += nvalues
+	if encoded.IsSetNullCount() {
+		ret.IncNulls(encoded.GetNullCount())
+	}
+	if encoded.IsSetDistinctCount() {
+		ret.IncDistinct(encoded.GetDistinctCount())
+	}
+
+	encodedMin := encoded.GetMin()
+	if encodedMin != nil && len(encodedMin) > 0 {
+		ret.min = ret.plainDecode(encodedMin)
+	}
+	encodedMax := encoded.GetMax()
+	if encodedMax != nil && len(encodedMax) > 0 {
+		ret.max = ret.plainDecode(encodedMax)
+	}
+	ret.hasMinMax = encoded.IsSetMax() || encoded.IsSetMin()
+	return ret
+}
+
+func (s *Float16Statistics) plainEncode(src parquet.FixedLenByteArray) []byte {
+	s.encoder.(encoding.FixedLenByteArrayEncoder).Put([]parquet.FixedLenByteArray{src})
+	buf, err := s.encoder.FlushValues()
+	if err != nil {
+		panic(err) // recovered by Encode
+	}
+	defer buf.Release()
+
+	out := make([]byte, buf.Len())
+	copy(out, buf.Bytes())
+	return out
+}
+
+func (s *Float16Statistics) plainDecode(src []byte) parquet.FixedLenByteArray {
+	var buf [1]parquet.FixedLenByteArray
+
+	decoder := encoding.NewDecoder(s.descr.PhysicalType(), parquet.Encodings.Plain, s.descr, s.mem)
+	decoder.SetData(1, src)
+	decoder.(encoding.FixedLenByteArrayDecoder).Decode(buf[:])
+	return buf[0]
+}
+
+func (s *Float16Statistics) minval(a, b parquet.FixedLenByteArray) parquet.FixedLenByteArray {
+	switch {
+	case a == nil:
+		return b
+	case b == nil:
+		return a
+	case s.less(a, b):
+		return a
+	default:
+		return b
+	}
+}
+
+func (s *Float16Statistics) maxval(a, b parquet.FixedLenByteArray) parquet.FixedLenByteArray {
+	switch {
+	case a == nil:
+		return b
+	case b == nil:
+		return a
+	case s.less(a, b):
+		return b
+	default:
+		return a
+	}
+}
+
+// MinMaxEqual returns true if both stat objects have the same Min and Max values
+func (s *Float16Statistics) MinMaxEqual(rhs *Float16Statistics) bool {
+	return s.equal(s.min, rhs.min) && s.equal(s.max, rhs.max)
+}
+
+// Equals returns true only if both objects are the same type, have the same min and
+// max values, null count, distinct count and number of values.
+func (s *Float16Statistics) Equals(other TypedStatistics) bool {
+	if s.Type() != other.Type() || !s.descr.LogicalType().Equals(other.Descr().LogicalType()) {
+		return false
+	}
+	rhs, ok := other.(*Float16Statistics)
+	if !ok {
+		return false
+	}
+
+	if s.HasMinMax() != rhs.HasMinMax() {
+		return false
+	}
+	return (s.hasMinMax && s.MinMaxEqual(rhs)) &&
+		s.NullCount() == rhs.NullCount() &&
+		s.DistinctCount() == rhs.DistinctCount() &&
+		s.NumValues() == rhs.NumValues()
+}
+
+func (s *Float16Statistics) coalesce(val, fallback parquet.FixedLenByteArray) parquet.FixedLenByteArray {
+	if float16.FromLEBytes(val).IsNaN() {
+		return fallback
+	}
+	return val
+}
+
+func (s *Float16Statistics) getMinMax(values []parquet.FixedLenByteArray) (min, max parquet.FixedLenByteArray) {
+	defMin := s.defaultMin()
+	defMax := s.defaultMax()
+
+	min = defMin
+	max = defMax
+
+	for _, v := range values {
+		min = s.minval(min, s.coalesce(v, defMin))
+		max = s.maxval(max, s.coalesce(v, defMax))
+	}
+	return
+}
+
+func (s *Float16Statistics) getMinMaxSpaced(values []parquet.FixedLenByteArray, validBits []byte, validBitsOffset int64) (min, max parquet.FixedLenByteArray) {
+	min = s.defaultMin()
+	max = s.defaultMax()
+
+	if s.bitSetReader == nil {
+		s.bitSetReader = bitutils.NewSetBitRunReader(validBits, validBitsOffset, int64(len(values)))
+	} else {
+		s.bitSetReader.Reset(validBits, validBitsOffset, int64(len(values)))
+	}
+
+	for {
+		run := s.bitSetReader.NextRun()
+		if run.Length == 0 {
+			break
+		}
+		for _, v := range values[int(run.Pos):int(run.Pos+run.Length)] {
+			min = s.minval(min, coalesce(v, s.defaultMin()).(parquet.FixedLenByteArray))
+			max = s.maxval(max, coalesce(v, s.defaultMax()).(parquet.FixedLenByteArray))
+		}
+	}
+	return
+}
+
+func (s *Float16Statistics) Min() parquet.FixedLenByteArray { return s.min }
+func (s *Float16Statistics) Max() parquet.FixedLenByteArray { return s.max }
+
+// Merge merges the stats from other into this stat object, updating
+// the null count, distinct count, number of values and the min/max if
+// appropriate.
+func (s *Float16Statistics) Merge(other TypedStatistics) {
+	rhs, ok := other.(*Float16Statistics)
+	if !ok {
+		panic("incompatible stat type merge")
+	}
+
+	s.statistics.merge(rhs)
+	if rhs.HasMinMax() {
+		s.SetMinMax(rhs.Min(), rhs.Max())
+	}
+}
+
+// Update is used to add more values to the current stat object, finding the
+// min and max values etc.
+func (s *Float16Statistics) Update(values []parquet.FixedLenByteArray, numNull int64) {
+	s.IncNulls(numNull)
+	s.nvalues += int64(len(values))
+
+	if len(values) == 0 {
+		return
+	}
+
+	s.SetMinMax(s.getMinMax(values))
+}
+
+// UpdateSpaced is just like Update, but for spaced values using validBits to determine
+// and skip null values.
+func (s *Float16Statistics) UpdateSpaced(values []parquet.FixedLenByteArray, validBits []byte, validBitsOffset, numNull int64) {
+	s.IncNulls(numNull)
+	notnull := int64(len(values)) - numNull
+	s.nvalues += notnull
+
+	if notnull == 0 {
+		return
+	}
+
+	s.SetMinMax(s.getMinMaxSpaced(values, validBits, validBitsOffset))
+}
+
+func (s *Float16Statistics) UpdateFromArrow(values arrow.Array, updateCounts bool) error {
+	if updateCounts {
+		s.IncNulls(int64(values.NullN()))
+		s.nvalues += int64(values.Len() - values.NullN())
+	}
+
+	if values.NullN() == values.Len() {
+		return nil
+	}
+
+	return fmt.Errorf("%w: update float16 stats from Arrow", arrow.ErrNotImplemented)
+}
+
+// SetMinMax updates the min and max values only if they are not currently set
+// or if argMin is less than the current min / argMax is greater than the current max
+func (s *Float16Statistics) SetMinMax(argMin, argMax parquet.FixedLenByteArray) {
+	maybeMinMax := s.cleanStat([2]parquet.FixedLenByteArray{argMin, argMax})
+	if maybeMinMax == nil {
+		return
+	}
+
+	min := (*maybeMinMax)[0]
+	max := (*maybeMinMax)[1]
+
+	if !s.hasMinMax {
+		s.hasMinMax = true
+		s.min = min
+		s.max = max
+	} else {
+		if !s.less(s.min, min) {
+			s.min = min
+		}
+		if s.less(s.max, max) {
+			s.max = max
+		}
+	}
+}
+
+// EncodeMin returns the encoded min value with plain encoding.
+//
+// ByteArray stats do not include the length in the encoding.
+func (s *Float16Statistics) EncodeMin() []byte {
+	if s.HasMinMax() {
+		return s.plainEncode(s.min)
+	}
+	return nil
+}
+
+// EncodeMax returns the current encoded max value with plain encoding
+//
+// ByteArray stats do not include the length in the encoding
+func (s *Float16Statistics) EncodeMax() []byte {
+	if s.HasMinMax() {
+		return s.plainEncode(s.max)
+	}
+	return nil
+}
+
+// Encode returns a populated EncodedStatistics object
+func (s *Float16Statistics) Encode() (enc EncodedStatistics, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			switch r := r.(type) {
+			case error:
+				err = r
+			case string:
+				err = xerrors.New(r)
+			default:
+				err = fmt.Errorf("unknown error type thrown from panic: %v", r)
+			}
+		}
+	}()
+	if s.HasMinMax() {
+		enc.SetMax(s.EncodeMax())
+		enc.SetMin(s.EncodeMin())
+	}
+	if s.HasNullCount() {
+		enc.SetNullCount(s.NullCount())
+	}
+	if s.HasDistinctCount() {
+		enc.SetDistinctCount(s.DistinctCount())
+	}
+	return
+}
+
 // NewStatistics uses the type in the column descriptor to construct the appropriate
 // typed stats object. If mem is nil, then memory.DefaultAllocator will be used.
 func NewStatistics(descr *schema.Column, mem memory.Allocator) TypedStatistics {
@@ -2454,6 +2763,9 @@ func NewStatistics(descr *schema.Column, mem memory.Allocator) TypedStatistics {
 	case parquet.Types.ByteArray:
 		return NewByteArrayStatistics(descr, mem)
 	case parquet.Types.FixedLenByteArray:
+		if descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+			return NewFloat16Statistics(descr, mem)
+		}
 		return NewFixedLenByteArrayStatistics(descr, mem)
 	default:
 		panic("not implemented")
@@ -2484,6 +2796,9 @@ func NewStatisticsFromEncoded(descr *schema.Column, mem memory.Allocator, nvalue
 	case parquet.Types.ByteArray:
 		return NewByteArrayStatisticsFromEncoded(descr, mem, nvalues, encoded)
 	case parquet.Types.FixedLenByteArray:
+		if descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+			return NewFloat16StatisticsFromEncoded(descr, mem, nvalues, encoded)
+		}
 		return NewFixedLenByteArrayStatisticsFromEncoded(descr, mem, nvalues, encoded)
 	default:
 		panic("not implemented")
diff --git a/go/parquet/metadata/statistics_types.gen.go.tmpl b/go/parquet/metadata/statistics_types.gen.go.tmpl
index 4b6253a8574ea..93495527c7e54 100644
--- a/go/parquet/metadata/statistics_types.gen.go.tmpl
+++ b/go/parquet/metadata/statistics_types.gen.go.tmpl
@@ -45,10 +45,18 @@ type {{.Name}}Statistics struct {
 // given column descriptor and allocator.
 //
 // Panics if the physical type of descr is not parquet.Type.{{if .physical}}{{.physical}}{{else}}{{.Name}}{{end}}
+{{- if eq .Name "Float16"}}
+// Panics if the logical type of descr is not schema.Float16LogicalType
+{{- end}}
 func New{{.Name}}Statistics(descr *schema.Column, mem memory.Allocator) *{{.Name}}Statistics {
   if descr.PhysicalType() != parquet.Types.{{if .physical}}{{.physical}}{{else}}{{.Name}}{{end}} {
     panic(fmt.Errorf("parquet: invalid type %s for constructing a {{.Name}} stat object", descr.PhysicalType()))
   }
+{{- if eq .Name "Float16"}}
+  if !descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+    panic(fmt.Errorf("parquet: invalid logical type %s for constructing a {{.Name}} stat object", descr.LogicalType().String()))
+  }
+{{- end}}
 
   return &{{.Name}}Statistics{
     statistics: statistics{
@@ -96,7 +104,7 @@ func (s *{{.Name}}Statistics) plainEncode(src {{.name}}) []byte {
   copy(out, src)
   return out
 {{- else}}
-  s.encoder.(encoding.{{.Name}}Encoder).Put([]{{.name}}{src})
+  s.encoder.(encoding.{{if .logical}}{{.physical}}{{else}}{{.Name}}{{end}}Encoder).Put([]{{.name}}{src})
   buf, err := s.encoder.FlushValues()
   if err != nil {
     panic(err) // recovered by Encode
@@ -117,12 +125,12 @@ func (s *{{.Name}}Statistics) plainDecode(src []byte) {{.name}} {
 
   decoder := encoding.NewDecoder(s.descr.PhysicalType(), parquet.Encodings.Plain, s.descr, s.mem)
   decoder.SetData(1, src)
-  decoder.(encoding.{{.Name}}Decoder).Decode(buf[:])
+  decoder.(encoding.{{if .logical}}{{.physical}}{{else}}{{.Name}}{{end}}Decoder).Decode(buf[:])
   return buf[0]
 {{- end}}
 }
 
-{{if and (ne .Name "ByteArray") (ne .Name "FixedLenByteArray")}}
+{{if and (ne .Name "ByteArray") (ne .Name "FixedLenByteArray") (ne .Name "Float16")}}
 func (s *{{.Name}}Statistics) minval(a, b {{.name}}) {{.name}} {
   if s.less(a, b) {
     return a
@@ -172,7 +180,11 @@ func (s *{{.Name}}Statistics) MinMaxEqual(rhs *{{.Name}}Statistics) bool {
 // Equals returns true only if both objects are the same type, have the same min and
 // max values, null count, distinct count and number of values.
 func (s *{{.Name}}Statistics) Equals(other TypedStatistics) bool {
+{{- if .logical}}
+  if s.Type() != other.Type() || !s.descr.LogicalType().Equals(other.Descr().LogicalType()) {
+{{- else}}
   if s.Type() != other.Type() {
+{{- end}}
     return false
   }
   rhs, ok := other.(*{{.Name}}Statistics)
@@ -194,6 +206,13 @@ func (s *{{.Name}}Statistics) coalesce(val, fallback {{.name}}) {{.name}} {
   }
   return val
 }
+{{else if eq .Name "Float16"}}
+func (s *{{.Name}}Statistics) coalesce(val, fallback {{.name}}) {{.name}} {
+  if float16.FromLEBytes(val).IsNaN() {
+    return fallback
+  }
+  return val
+}
 {{end}}
 
 func (s *{{.Name}}Statistics) getMinMax(values []{{.name}}) (min, max {{.name}}) {
@@ -212,7 +231,7 @@ func (s *{{.Name}}Statistics) getMinMax(values []{{.name}}) (min, max {{.name}})
   max = defMax
 
   for _, v := range values {
-{{- if or (eq .name "float32") (eq .name "float64") }}
+{{- if or (eq .name "float32") (eq .name "float64") (eq .Name "Float16") }}
     min = s.minval(min, s.coalesce(v, defMin))
     max = s.maxval(max, s.coalesce(v, defMax))
 {{- else}}
@@ -261,7 +280,7 @@ func (s *{{.Name}}Statistics) getMinMaxSpaced(values []{{.name}}, validBits []by
     }
 {{- else}}
     for _, v := range values[int(run.Pos):int(run.Pos+run.Length)] {
-{{- if or (eq .name "float32") (eq .name "float64") }}
+{{- if or (eq .name "float32") (eq .name "float64") (eq .Name "Float16") }}
       min = s.minval(min, coalesce(v, s.defaultMin()).({{.name}}))
       max = s.maxval(max, coalesce(v, s.defaultMax()).({{.name}}))
 {{- else}}
@@ -381,7 +400,9 @@ func (s *{{.Name}}Statistics) UpdateFromArrow(values arrow.Array, updateCounts b
   s.SetMinMax(min, max)
   return nil
 {{else if eq .Name "Boolean"}}
-  return fmt.Errorf("%w: update boolean stats from Arrow", arrow.ErrNotImplemented)  
+  return fmt.Errorf("%w: update boolean stats from Arrow", arrow.ErrNotImplemented)
+{{else if eq .Name "Float16"}}
+  return fmt.Errorf("%w: update float16 stats from Arrow", arrow.ErrNotImplemented)
 {{else}}
   if values.DataType().(arrow.FixedWidthDataType).Bytes() != arrow.{{.Name}}SizeBytes {
     return fmt.Errorf("%w: cannot update {{.name}} stats with %s arrow array", 
@@ -475,8 +496,15 @@ func NewStatistics(descr *schema.Column, mem memory.Allocator) TypedStatistics {
   }
   switch descr.PhysicalType() {
 {{- range .In}}
+  {{- if not .logical}}
   case parquet.Types.{{if .physical}}{{.physical}}{{else}}{{.Name}}{{end}}:
+    {{- if eq .Name "FixedLenByteArray"}}
+    if descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+      return NewFloat16Statistics(descr, mem)
+    }
+    {{- end}}
     return New{{.Name}}Statistics(descr, mem)
+  {{- end}}
 {{- end}}
   default:
     panic("not implemented")
@@ -493,8 +521,15 @@ func NewStatisticsFromEncoded(descr *schema.Column, mem memory.Allocator, nvalue
   }
   switch descr.PhysicalType() {
 {{- range .In}}
+  {{- if not .logical}}
   case parquet.Types.{{if .physical}}{{.physical}}{{else}}{{.Name}}{{end}}:
+    {{- if eq .Name "FixedLenByteArray"}}
+    if descr.LogicalType().Equals(schema.Float16LogicalType{}) {
+      return NewFloat16StatisticsFromEncoded(descr, mem, nvalues, encoded)
+    }
+    {{- end}}
     return New{{.Name}}StatisticsFromEncoded(descr, mem, nvalues, encoded)
+  {{- end}}
 {{- end}}
   default:
     panic("not implemented")
diff --git a/go/parquet/metadata/statistics_types.tmpldata b/go/parquet/metadata/statistics_types.tmpldata
new file mode 100644
index 0000000000000..400c0a3ca515d
--- /dev/null
+++ b/go/parquet/metadata/statistics_types.tmpldata
@@ -0,0 +1,60 @@
+[
+  {
+    "Name": "Int32",
+    "name": "int32",
+    "lower": "int32",
+    "prefix": "arrow"
+  },
+  {
+    "Name": "Int64",
+    "name": "int64",
+    "lower": "int64",
+    "prefix": "arrow"
+  },
+  {
+    "Name": "Int96",
+    "name": "parquet.Int96",
+    "lower": "int96",
+    "prefix": "parquet"
+  },
+  {
+    "Name": "Float32",
+    "name": "float32",
+    "lower": "float32",
+    "prefix": "arrow",
+    "physical": "Float"
+  },
+  {
+    "Name": "Float64",
+    "name": "float64",
+    "lower": "float64",
+    "prefix": "arrow",
+    "physical": "Double"
+  },
+  {
+    "Name": "Boolean",
+    "name": "bool",
+    "lower": "bool",
+    "prefix": "arrow"
+  },
+  {
+    "Name": "ByteArray",
+    "name": "parquet.ByteArray",
+    "lower": "byteArray",
+    "prefix": "parquet"
+  },
+  {
+    "Name": "FixedLenByteArray",
+    "name": "parquet.FixedLenByteArray",
+    "lower": "fixedLenByteArray",
+    "prefix": "parquet"
+  },
+  {
+    "Name": "Float16",
+    "name": "parquet.FixedLenByteArray",
+    "lower": "float16",
+    "prefix": "parquet",
+    "physical": "FixedLenByteArray",
+    "logical": "Float16LogicalType"
+  }
+]
diff --git a/go/parquet/pqarrow/column_readers.go b/go/parquet/pqarrow/column_readers.go
index 02f94c941c3d9..49f3fac0a3b7c 100644
--- a/go/parquet/pqarrow/column_readers.go
+++ b/go/parquet/pqarrow/column_readers.go
@@ -517,6 +517,14 @@ func transferColumnData(rdr file.RecordReader, valueType arrow.DataType, descr *
 		default:
 			return nil, errors.New("time unit not supported")
 		}
+	case arrow.FLOAT16:
+		if descr.PhysicalType() != parquet.Types.FixedLenByteArray {
+			return nil, errors.New("physical type for float16 must be fixed len byte array")
+		}
+		if len := arrow.Float16SizeBytes; descr.TypeLength() != len {
+			return nil, fmt.Errorf("fixed len byte array length for float16 must be %d", len)
+		}
+		return transferBinary(rdr, valueType), nil
 	default:
 		return nil, fmt.Errorf("no support for reading columns of type: %s", valueType.Name())
 	}
@@ -563,6 +571,14 @@ func transferBinary(rdr file.RecordReader, dt arrow.DataType) *arrow.Chunked {
 			chunks[idx] = array.MakeFromData(chunk.Data())
 			chunk.Release()
 		}
+	case *arrow.Float16Type:
+		for idx, chunk := range chunks {
+			data := chunk.Data()
+			f16_data := array.NewData(dt, data.Len(), data.Buffers(), nil, data.NullN(), data.Offset())
+			defer f16_data.Release()
+			chunks[idx] = array.NewFloat16Data(f16_data)
+			chunk.Release()
+		}
 	}
 	return arrow.NewChunked(dt, chunks)
 }
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index 81b4527b105cb..1855d3625adb7 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -582,6 +582,31 @@ func writeDenseArrow(ctx *arrowWriteContext, cw file.ColumnChunkWriter, leafArr
 				}
 				wr.WriteBatchSpaced(data, defLevels, repLevels, arr.NullBitmapBytes(), int64(arr.Data().Offset()))
 			}
+		case *arrow.Float16Type:
+			typeLen := wr.Descr().TypeLength()
+			if typeLen != arrow.Float16SizeBytes {
+				return fmt.Errorf("%w: invalid FixedLenByteArray length to write from float16 column: %d", arrow.ErrInvalid, typeLen)
+			}
+
+			arr := leafArr.(*array.Float16)
+			rawValues := arrow.Float16Traits.CastToBytes(arr.Values())
+			data := make([]parquet.FixedLenByteArray, arr.Len())
+
+			if arr.NullN() == 0 {
+				for idx := range data {
+					offset := idx * typeLen
+					data[idx] = rawValues[offset : offset+typeLen]
+				}
+				_, err = wr.WriteBatch(data, defLevels, repLevels)
+			} else {
+				for idx := range data {
+					if arr.IsValid(idx) {
+						offset := idx * typeLen
+						data[idx] = rawValues[offset : offset+typeLen]
+					}
+				}
+				wr.WriteBatchSpaced(data, defLevels, repLevels, arr.NullBitmapBytes(), int64(arr.Data().Offset()))
+			}
 		default:
 			return fmt.Errorf("%w: invalid column type to write to FixedLenByteArray: %s", arrow.ErrInvalid, leafArr.DataType().Name())
 		}
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 281ca0d526476..d588aff701f3d 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -495,6 +495,8 @@ func getLogicalType(typ arrow.DataType) schema.LogicalType {
 		return schema.DateLogicalType{}
 	case arrow.DATE64:
 		return schema.DateLogicalType{}
+	case arrow.FLOAT16:
+		return schema.Float16LogicalType{}
 	case arrow.TIMESTAMP:
 		ts := typ.(*arrow.TimestampType)
 		adjustedUTC := len(ts.TimeZone) == 0
@@ -541,6 +543,8 @@ func getPhysicalType(typ arrow.DataType) parquet.Type {
 		return parquet.Types.Float
 	case arrow.FLOAT64:
 		return parquet.Types.Double
+	case arrow.FLOAT16:
+		return parquet.Types.FixedLenByteArray
 	case arrow.BINARY, arrow.LARGE_BINARY, arrow.STRING, arrow.LARGE_STRING:
 		return parquet.Types.ByteArray
 	case arrow.FIXED_SIZE_BINARY, arrow.DECIMAL:
@@ -600,6 +604,8 @@ func (ps *ParquetIOTestSuite) makeSimpleSchema(typ arrow.DataType, rep parquet.R
 		byteWidth = int32(typ.ByteWidth)
 	case arrow.DecimalType:
 		byteWidth = pqarrow.DecimalSize(typ.GetPrecision())
+	case *arrow.Float16Type:
+		byteWidth = int32(typ.Bytes())
 	case *arrow.DictionaryType:
 		valuesType := typ.ValueType
 		switch dt := valuesType.(type) {
@@ -607,6 +613,8 @@ func (ps *ParquetIOTestSuite) makeSimpleSchema(typ arrow.DataType, rep parquet.R
 			byteWidth = int32(dt.ByteWidth)
 		case arrow.DecimalType:
 			byteWidth = pqarrow.DecimalSize(dt.GetPrecision())
+		case *arrow.Float16Type:
+			byteWidth = int32(typ.Bytes())
 		}
 	}
 
@@ -1113,6 +1121,7 @@ var fullTypeList = []arrow.DataType{
 	arrow.FixedWidthTypes.Date32,
 	arrow.PrimitiveTypes.Float32,
 	arrow.PrimitiveTypes.Float64,
+	arrow.FixedWidthTypes.Float16,
 	arrow.BinaryTypes.String,
 	arrow.BinaryTypes.Binary,
 	&arrow.FixedSizeBinaryType{ByteWidth: 10},
diff --git a/go/parquet/pqarrow/schema.go b/go/parquet/pqarrow/schema.go
index b23c37ea39102..95c477c78b87d 100644
--- a/go/parquet/pqarrow/schema.go
+++ b/go/parquet/pqarrow/schema.go
@@ -344,6 +344,10 @@ func fieldToNode(name string, field arrow.Field, props *parquet.WriterProperties
 		} else {
 			logicalType = schema.NewTimeLogicalType(true, schema.TimeUnitMicros)
 		}
+	case arrow.FLOAT16:
+		typ = parquet.Types.FixedLenByteArray
+		length = arrow.Float16SizeBytes
+		logicalType = schema.Float16LogicalType{}
 	case arrow.STRUCT:
 		return structToNode(field.Type.(*arrow.StructType), field.Name, field.Nullable, props, arrprops)
 	case arrow.FIXED_SIZE_LIST, arrow.LIST:
@@ -597,6 +601,8 @@ func arrowFromFLBA(logical schema.LogicalType, length int) (arrow.DataType, erro
 		return arrowDecimal(logtype), nil
 	case schema.NoLogicalType, schema.IntervalLogicalType, schema.UUIDLogicalType:
 		return &arrow.FixedSizeBinaryType{ByteWidth: int(length)}, nil
+	case schema.Float16LogicalType:
+		return &arrow.Float16Type{}, nil
 	default:
 		return nil, xerrors.New("unhandled logical type " + logical.String() + " for fixed-length byte array")
 	}
diff --git a/go/parquet/pqarrow/schema_test.go b/go/parquet/pqarrow/schema_test.go
index b5e7dc8fad34a..ee5aad8913470 100644
--- a/go/parquet/pqarrow/schema_test.go
+++ b/go/parquet/pqarrow/schema_test.go
@@ -280,6 +280,25 @@ func TestConvertArrowDecimals(t *testing.T) {
 	}
 }
 
+func TestConvertArrowFloat16(t *testing.T) {
+	parquetFields := make(schema.FieldList, 0)
+	arrowFields := make([]arrow.Field, 0)
+
+	parquetFields = append(parquetFields, schema.Must(schema.NewPrimitiveNodeLogical("float16", parquet.Repetitions.Required,
+		schema.Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2, -1)))
+	arrowFields = append(arrowFields, arrow.Field{Name: "float16", Type: &arrow.Float16Type{}})
+
+	arrowSchema := arrow.NewSchema(arrowFields, nil)
+	parquetSchema := schema.NewSchema(schema.MustGroup(schema.NewGroupNode("schema", parquet.Repetitions.Repeated, parquetFields, -1)))
+
+	result, err := pqarrow.ToParquet(arrowSchema, nil, pqarrow.NewArrowWriterProperties(pqarrow.WithDeprecatedInt96Timestamps(true)))
+	assert.NoError(t, err)
+	assert.True(t, parquetSchema.Equals(result))
+	for i := 0; i < parquetSchema.NumColumns(); i++ {
+		assert.Truef(t, parquetSchema.Column(i).Equals(result.Column(i)), "Column %d didn't match: %s", i, parquetSchema.Column(i).Name())
+	}
+}
+
 func TestCoerceTImestampV1(t *testing.T) {
 	parquetFields := make(schema.FieldList, 0)
 	arrowFields := make([]arrow.Field, 0)
@@ -418,7 +437,6 @@ func TestUnsupportedTypes(t *testing.T) {
 		typ arrow.DataType
 	}{
 		// Non-exhaustive list of unsupported types
-		{typ: &arrow.Float16Type{}},
 		{typ: &arrow.DurationType{}},
 		{typ: &arrow.DayTimeIntervalType{}},
 		{typ: &arrow.MonthIntervalType{}},
diff --git a/go/parquet/schema/logical_types.go b/go/parquet/schema/logical_types.go
index 1ea44fc56c615..69e69363887cd 100644
--- a/go/parquet/schema/logical_types.go
+++ b/go/parquet/schema/logical_types.go
@@ -68,6 +68,8 @@ func getLogicalType(l *format.LogicalType) LogicalType {
 		return BSONLogicalType{}
 	case l.IsSetUUID():
 		return UUIDLogicalType{}
+	case l.IsSetFLOAT16():
+		return Float16LogicalType{}
 	case l == nil:
 		return NoLogicalType{}
 	default:
@@ -1064,6 +1066,50 @@ func (IntervalLogicalType) Equals(rhs LogicalType) bool {
 	return ok
 }
 
+// Float16LogicalType can only be used with a FixedLength byte array column
+// that is exactly 2 bytes long
+type Float16LogicalType struct{ baseLogicalType }
+
+func (Float16LogicalType) SortOrder() SortOrder {
+	return SortSIGNED
+}
+
+func (Float16LogicalType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(map[string]string{"Type": Float16LogicalType{}.String()})
+}
+
+func (Float16LogicalType) String() string {
+	return "Float16"
+}
+
+func (Float16LogicalType) ToConvertedType() (ConvertedType, DecimalMetadata) {
+	return ConvertedTypes.None, DecimalMetadata{}
+}
+
+func (Float16LogicalType) IsCompatible(c ConvertedType, dec DecimalMetadata) bool {
+	if dec.IsSet {
+		return false
+	}
+	switch c {
+	case ConvertedTypes.None, ConvertedTypes.NA:
+		return true
+	}
+	return false
+}
+
+func (Float16LogicalType) IsApplicable(t parquet.Type, tlen int32) bool {
+	return t == parquet.Types.FixedLenByteArray && tlen == 2
+}
+
+func (Float16LogicalType) toThrift() *format.LogicalType {
+	return &format.LogicalType{FLOAT16: format.NewFloat16Type()}
+}
+
+func (Float16LogicalType) Equals(rhs LogicalType) bool {
+	_, ok := rhs.(Float16LogicalType)
+	return ok
+}
+
 type NullLogicalType struct{ baseLogicalType }
 
 func (NullLogicalType) SortOrder() SortOrder {
diff --git a/go/parquet/schema/logical_types_test.go b/go/parquet/schema/logical_types_test.go
index 49edf1748c52c..c371b47714f41 100644
--- a/go/parquet/schema/logical_types_test.go
+++ b/go/parquet/schema/logical_types_test.go
@@ -158,6 +158,7 @@ func TestNewTypeIncompatibility(t *testing.T) {
 		expected schema.LogicalType
 	}{
 		{"uuid", schema.UUIDLogicalType{}, schema.UUIDLogicalType{}},
+		{"float16", schema.Float16LogicalType{}, schema.Float16LogicalType{}},
 		{"null", schema.NullLogicalType{}, schema.NullLogicalType{}},
 		{"not-utc-time_milli", schema.NewTimeLogicalType(false /* adjutedToUTC */, schema.TimeUnitMillis), &schema.TimeLogicalType{}},
 		{"not-utc-time-micro", schema.NewTimeLogicalType(false /* adjutedToUTC */, schema.TimeUnitMicros), &schema.TimeLogicalType{}},
@@ -224,6 +225,7 @@ func TestLogicalTypeProperties(t *testing.T) {
 		{"json", schema.JSONLogicalType{}, false, true, true},
 		{"bson", schema.BSONLogicalType{}, false, true, true},
 		{"uuid", schema.UUIDLogicalType{}, false, true, true},
+		{"float16", schema.Float16LogicalType{}, false, true, true},
 		{"nological", schema.NoLogicalType{}, false, false, true},
 		{"unknown", schema.UnknownLogicalType{}, false, false, false},
 	}
@@ -358,6 +360,14 @@ func TestLogicalInapplicableTypes(t *testing.T) {
 			assert.False(t, logical.IsApplicable(tt.typ, tt.len))
 		})
 	}
+
+	logical = schema.Float16LogicalType{}
+	assert.True(t, logical.IsApplicable(parquet.Types.FixedLenByteArray, 2))
+	for _, tt := range tests {
+		t.Run("float16 "+tt.name, func(t *testing.T) {
+			assert.False(t, logical.IsApplicable(tt.typ, tt.len))
+		})
+	}
 }
 
 func TestDecimalLogicalTypeApplicability(t *testing.T) {
@@ -445,6 +455,7 @@ func TestLogicalTypeRepresentation(t *testing.T) {
 		{"json", schema.JSONLogicalType{}, "JSON", `{"Type": "JSON"}`},
 		{"bson", schema.BSONLogicalType{}, "BSON", `{"Type": "BSON"}`},
 		{"uuid", schema.UUIDLogicalType{}, "UUID", `{"Type": "UUID"}`},
+		{"float16", schema.Float16LogicalType{}, "Float16", `{"Type": "Float16"}`},
 		{"none", schema.NoLogicalType{}, "None", `{"Type": "None"}`},
 	}
 
@@ -490,6 +501,7 @@ func TestLogicalTypeSortOrder(t *testing.T) {
 		{"json", schema.JSONLogicalType{}, schema.SortUNSIGNED},
 		{"bson", schema.BSONLogicalType{}, schema.SortUNSIGNED},
 		{"uuid", schema.UUIDLogicalType{}, schema.SortUNSIGNED},
+		{"float16", schema.Float16LogicalType{}, schema.SortSIGNED},
 		{"none", schema.NoLogicalType{}, schema.SortUNKNOWN},
 	}
 
diff --git a/go/parquet/schema/reflection.go b/go/parquet/schema/reflection.go
index d79edb92408f8..c0c8e0533efb0 100644
--- a/go/parquet/schema/reflection.go
+++ b/go/parquet/schema/reflection.go
@@ -22,6 +22,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/parquet"
 	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"golang.org/x/xerrors"
@@ -159,6 +160,8 @@ func (t *taggedInfo) UpdateLogicalTypes() {
 			return BSONLogicalType{}
 		case "uuid":
 			return UUIDLogicalType{}
+		case "float16":
+			return Float16LogicalType{}
 		default:
 			panic(fmt.Errorf("invalid logical type specified: %s", t))
 		}
@@ -373,6 +376,9 @@ func typeToNode(name string, typ reflect.Type, repType parquet.Repetition, info
 		}
 		return Must(MapOf(name, key, value, repType, fieldID))
 	case reflect.Struct:
+		if typ == reflect.TypeOf(float16.Num{}) {
+			return MustPrimitive(NewPrimitiveNodeLogical(name, repType, Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2, fieldID))
+		}
 		// structs are Group nodes
 		fields := make(FieldList, 0)
 		for i := 0; i < typ.NumField(); i++ {
diff --git a/go/parquet/schema/reflection_test.go b/go/parquet/schema/reflection_test.go
index 06ad7191a5749..e3a880cacc1e8 100644
--- a/go/parquet/schema/reflection_test.go
+++ b/go/parquet/schema/reflection_test.go
@@ -22,6 +22,7 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/apache/arrow/go/v15/arrow/float16"
 	"github.com/apache/arrow/go/v15/parquet"
 	"github.com/apache/arrow/go/v15/parquet/schema"
 	"github.com/stretchr/testify/assert"
@@ -152,6 +153,9 @@ func ExampleNewSchemaFromStruct_logicaltypes() {
 		JSON                  string   `parquet:"logical=json"`
 		BSON                  []byte   `parquet:"logical=BSON"`
 		UUID                  [16]byte `parquet:"logical=uuid"`
+		Float16               [2]byte  `parquet:"logical=float16"`
+		Float16Optional       *[2]byte `parquet:"logical=float16"`
+		Float16Num            float16.Num
 	}
 
 	sc, err := schema.NewSchemaFromStruct(LogicalTypes{})
@@ -180,6 +184,9 @@ func ExampleNewSchemaFromStruct_logicaltypes() {
 	//   required byte_array field_id=-1 JSON (JSON);
 	//   required byte_array field_id=-1 BSON (BSON);
 	//   required fixed_len_byte_array field_id=-1 UUID (UUID);
+	//   required fixed_len_byte_array field_id=-1 Float16 (Float16);
+	//   optional fixed_len_byte_array field_id=-1 Float16Optional (Float16);
+	//   required fixed_len_byte_array field_id=-1 Float16Num (Float16);
 	// }
 }
 
diff --git a/go/parquet/schema/schema_element_test.go b/go/parquet/schema/schema_element_test.go
index dd1d293e5cfd7..d190ffe5a253a 100644
--- a/go/parquet/schema/schema_element_test.go
+++ b/go/parquet/schema/schema_element_test.go
@@ -159,6 +159,10 @@ func (s *SchemaElementConstructionSuite) TestSimple() {
 			"uuid", UUIDLogicalType{}, parquet.Types.FixedLenByteArray, 16, false, ConvertedTypes.NA, true,
 			func(e *format.SchemaElement) bool { return e.LogicalType.IsSetUUID() },
 		}, nil},
+		{"float16", &schemaElementConstructArgs{
+			"float16", Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2, false, ConvertedTypes.NA, true,
+			func(e *format.SchemaElement) bool { return e.LogicalType.IsSetFLOAT16() },
+		}, nil},
 		{"none", &schemaElementConstructArgs{
 			"none", NoLogicalType{}, parquet.Types.Int64, -1, false, ConvertedTypes.NA, false,
 			checkNone,
@@ -425,7 +429,8 @@ func TestSchemaElementNestedSerialization(t *testing.T) {
 	timestampNode := MustPrimitive(NewPrimitiveNodeLogical("timestamp" /*name */, parquet.Repetitions.Required, NewTimestampLogicalType(false /* adjustedToUTC */, TimeUnitNanos), parquet.Types.Int64, -1 /* type len */, -1 /* fieldID */))
 	intNode := MustPrimitive(NewPrimitiveNodeLogical("int" /*name */, parquet.Repetitions.Required, NewIntLogicalType(64 /* bitWidth */, false /* signed */), parquet.Types.Int64, -1 /* type len */, -1 /* fieldID */))
 	decimalNode := MustPrimitive(NewPrimitiveNodeLogical("decimal" /*name */, parquet.Repetitions.Required, NewDecimalLogicalType(16 /* precision */, 6 /* scale */), parquet.Types.Int64, -1 /* type len */, -1 /* fieldID */))
-	listNode := MustGroup(NewGroupNodeLogical("list" /*name */, parquet.Repetitions.Repeated, []Node{strNode, dateNode, jsonNode, uuidNode, timestampNode, intNode, decimalNode}, NewListLogicalType(), -1 /* fieldID */))
+	float16Node := MustPrimitive(NewPrimitiveNodeLogical("float16" /*name */, parquet.Repetitions.Required, Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2 /* type len */, - /* fieldID */ 1))
+	listNode := MustGroup(NewGroupNodeLogical("list" /*name */, parquet.Repetitions.Repeated, []Node{strNode, dateNode, jsonNode, uuidNode, timestampNode, intNode, decimalNode, float16Node}, NewListLogicalType(), -1 /* fieldID */))
 
 	listElems := ToThrift(listNode)
 	assert.Equal(t, "list", listElems[0].Name)
@@ -440,6 +445,7 @@ func TestSchemaElementNestedSerialization(t *testing.T) {
 	assert.True(t, listElems[5].LogicalType.IsSetTIMESTAMP())
 	assert.True(t, listElems[6].LogicalType.IsSetINTEGER())
 	assert.True(t, listElems[7].LogicalType.IsSetDECIMAL())
+	assert.True(t, listElems[8].LogicalType.IsSetFLOAT16())
 
 	mapNode := MustGroup(NewGroupNodeLogical("map" /* name */, parquet.Repetitions.Required, []Node{}, MapLogicalType{}, -1 /* fieldID */))
 	mapElems := ToThrift(mapNode)
@@ -486,6 +492,7 @@ func TestLogicalTypeSerializationRoundTrip(t *testing.T) {
 		{"json", JSONLogicalType{}, parquet.Types.ByteArray, -1},
 		{"bson", BSONLogicalType{}, parquet.Types.ByteArray, -1},
 		{"uuid", UUIDLogicalType{}, parquet.Types.FixedLenByteArray, 16},
+		{"float16", Float16LogicalType{}, parquet.Types.FixedLenByteArray, 2},
 		{"none", NoLogicalType{}, parquet.Types.Boolean, -1},
 	}
 
diff --git a/go/parquet/schema/schema_test.go b/go/parquet/schema/schema_test.go
index b60c7dfaafcd1..cc43c3856d68e 100644
--- a/go/parquet/schema/schema_test.go
+++ b/go/parquet/schema/schema_test.go
@@ -635,6 +635,10 @@ func TestPanicSchemaNodeCreation(t *testing.T) {
 		schema.MustPrimitive(schema.NewPrimitiveNodeLogical("uuid" /* name */, parquet.Repetitions.Required, schema.UUIDLogicalType{}, parquet.Types.FixedLenByteArray, 64 /* type len */, -1 /* fieldID */))
 	}, "incompatible primitive length")
 
+	assert.Panics(t, func() {
+		schema.MustPrimitive(schema.NewPrimitiveNodeLogical("float16" /* name */, parquet.Repetitions.Required, schema.Float16LogicalType{}, parquet.Types.FixedLenByteArray, 4 /* type len */, -1 /* fieldID */))
+	}, "incompatible primitive length")
+
 	assert.Panics(t, func() {
 		schema.MustPrimitive(schema.NewPrimitiveNodeLogical("negative_len" /* name */, parquet.Repetitions.Required, schema.NoLogicalType{}, parquet.Types.FixedLenByteArray, -16 /* type len */, -1 /* fieldID */))
 	}, "non-positive length for fixed length binary")

From fba8389e6e9c41613cf13e9557311b3aec0f349b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Nov 2023 08:20:33 +0900
Subject: [PATCH 723/749] MINOR: [C#] Bump Grpc.AspNetCore from 2.58.0 to
 2.59.0 in /csharp (#38685)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore](https://github.com/grpc/grpc-dotnet) from 2.58.0 to 2.59.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore's releases</a>.</em></p>
<blockquote>
<h2>Release v2.59.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0</a></p>
<h2>Release v2.59.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
<li>Update to version 2.59.0-pre1 on v2.59.x branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2307">grpc/grpc-dotnet#2307</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/9124a4cb8c210a27bab47cce3da694d0d0b049ea"><code>9124a4c</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2316">#2316</a> from apolcyn/bump_r</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/eb9f932d52597116625fc127e1ae463a0b5faa62"><code>eb9f932</code></a> bump to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/20a6e90ab43f47452446c49bab74c8839047b8d2"><code>20a6e90</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2307">#2307</a> from apolcyn/release_updates</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/2084009f8f375514dcad6b8b1d4571d266e8e6c8"><code>2084009</code></a> bump version to 2.59.0-pre1</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/e52049a94d69bf5105d07193b116800ddd62eae3"><code>e52049a</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2303">#2303</a> from apolcyn/update_59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/51ad5ab7573ce61c1eecf620dc26bd3687d85e07"><code>51ad5ab</code></a> update grpc tools to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3c4abbada1a9794398c40e88b5e9de6c6f4641eb"><code>3c4abba</code></a> Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp...</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/91be3925c19ab297dda52ff0c201ee025eda0d6e"><code>91be392</code></a> Fix HttpContext race by copying values to reader and writer (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2294">#2294</a>)</li>
<li>See full diff in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore&package-manager=nuget&previous-version=2.58.0&new-version=2.59.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.TestWeb.csproj                          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
index 81468deea6c09..3aaebb103f9da 100644
--- a/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
+++ b/csharp/test/Apache.Arrow.Flight.TestWeb/Apache.Arrow.Flight.TestWeb.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore" Version="2.58.0" />
+    <PackageReference Include="Grpc.AspNetCore" Version="2.59.0" />
   </ItemGroup>
 
   <ItemGroup>

From e7d90b2ea1b56b7b23305efc3653679029ce3e4c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Nov 2023 08:20:57 +0900
Subject: [PATCH 724/749] MINOR: [C#] Bump Grpc.Net.Client from 2.58.0 to
 2.59.0 in /csharp (#38686)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.Net.Client](https://github.com/grpc/grpc-dotnet) from 2.58.0 to 2.59.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.Net.Client's releases</a>.</em></p>
<blockquote>
<h2>Release v2.59.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0</a></p>
<h2>Release v2.59.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
<li>Update to version 2.59.0-pre1 on v2.59.x branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2307">grpc/grpc-dotnet#2307</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/9124a4cb8c210a27bab47cce3da694d0d0b049ea"><code>9124a4c</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2316">#2316</a> from apolcyn/bump_r</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/eb9f932d52597116625fc127e1ae463a0b5faa62"><code>eb9f932</code></a> bump to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/20a6e90ab43f47452446c49bab74c8839047b8d2"><code>20a6e90</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2307">#2307</a> from apolcyn/release_updates</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/2084009f8f375514dcad6b8b1d4571d266e8e6c8"><code>2084009</code></a> bump version to 2.59.0-pre1</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/e52049a94d69bf5105d07193b116800ddd62eae3"><code>e52049a</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2303">#2303</a> from apolcyn/update_59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/51ad5ab7573ce61c1eecf620dc26bd3687d85e07"><code>51ad5ab</code></a> update grpc tools to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3c4abbada1a9794398c40e88b5e9de6c6f4641eb"><code>3c4abba</code></a> Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp...</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/91be3925c19ab297dda52ff0c201ee025eda0d6e"><code>91be392</code></a> Fix HttpContext race by copying values to reader and writer (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2294">#2294</a>)</li>
<li>See full diff in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.Net.Client&package-manager=nuget&previous-version=2.58.0&new-version=2.59.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
index 975bf44db888f..67b37e49c7dc5 100644
--- a/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
+++ b/csharp/src/Apache.Arrow.Flight/Apache.Arrow.Flight.csproj
@@ -6,7 +6,7 @@
   
   <ItemGroup>
     <PackageReference Include="Google.Protobuf" Version="3.25.0" />
-    <PackageReference Include="Grpc.Net.Client" Version="2.58.0" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.59.0" />
     <PackageReference Include="Grpc.Tools" Version="2.59.0" PrivateAssets="All" />
   </ItemGroup>
 

From 37db2a03fc2d2c54d207fdcf04f1b88c1c1ae11b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Nov 2023 08:21:38 +0900
Subject: [PATCH 725/749] MINOR: [C#] Bump Microsoft.NET.Test.Sdk from 17.7.2
 to 17.8.0 in /csharp (#38687)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.7.2 to 17.8.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/microsoft/vstest/releases">Microsoft.NET.Test.Sdk's releases</a>.</em></p>
<blockquote>
<h2>v17.8.0</h2>
<h2>What's Changed</h2>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.7.2...v17.8.0">https://github.com/microsoft/vstest/compare/v17.7.2...v17.8.0</a></p>
<h2>v17.8.0-release-23468-02</h2>
<h2>What's Changed</h2>
<ul>
<li>Upgrade Newtonsoft.Json from 13.0.1 to 13.0.3 by <a href="https://github.com/mthalman"><code>@​mthalman</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4681">#4681</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.8.0-preview-23424-02...v17.8.0-release-23468-02">https://github.com/microsoft/vstest/compare/v17.8.0-preview-23424-02...v17.8.0-release-23468-02</a></p>
<h2>v17.8.0-preview-23424-02</h2>
<h2>What's Changed</h2>
<ul>
<li>Add possibility to send telemetry events by data collectors by <a href="https://github.com/jakubch1"><code>@​jakubch1</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4622">microsoft/vstest#4622</a></li>
<li>Fix timing issue in parallel execution by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4629">microsoft/vstest#4629</a></li>
<li>Document default value for diag trace level by <a href="https://github.com/riQQ"><code>@​riQQ</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4640">microsoft/vstest#4640</a></li>
<li>Remove process suspend by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4586">microsoft/vstest#4586</a></li>
<li>Make async VSTestConsoleWrapper apis obsolete by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4648">microsoft/vstest#4648</a></li>
<li>Mitigate the usage of JsonConvert.DefaultSettings in user code by <a href="https://github.com/Applesauce314"><code>@​Applesauce314</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4581">microsoft/vstest#4581</a></li>
<li>Set console encoding to UTF8 by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4649">microsoft/vstest#4649</a></li>
<li>Fix executable bitness for testhost.x86 by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4652">microsoft/vstest#4652</a></li>
<li>Change license packages that use .NET Library license to MIT by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4658">microsoft/vstest#4658</a></li>
<li>Fix cannot find System.Text.Json by <a href="https://github.com/nohwnd"><code>@​nohwnd</code></a> in <a href="https://redirect.github.com/microsoft/vstest/pull/4668">microsoft/vstest#4668</a></li>
</ul>
<h2>New Contributors</h2>
<ul>
<li><a href="https://github.com/riQQ"><code>@​riQQ</code></a> made their first contribution in <a href="https://redirect.github.com/microsoft/vstest/pull/4640">microsoft/vstest#4640</a></li>
<li><a href="https://github.com/Applesauce314"><code>@​Applesauce314</code></a> made their first contribution in <a href="https://redirect.github.com/microsoft/vstest/pull/4581">microsoft/vstest#4581</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.8.0-preview-23371-04...v17.8.0-preview-23424-02">https://github.com/microsoft/vstest/compare/v17.8.0-preview-23371-04...v17.8.0-preview-23424-02</a></p>
<h2>v17.8.0-preview-23371-04</h2>
<h3>Issues Fixed</h3>
<ul>
<li>Take System dlls from testhost folder <a href="https://redirect.github.com/microsoft/vstest/pull/4610">#4610</a></li>
<li>Simplify naming in ExecutionTests</li>
<li>Fix XmlException when writing Html log with certain test names <a href="https://redirect.github.com/microsoft/vstest/pull/4576">#4576</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/microsoft/vstest/compare/v17.8.0-rebrand...v17.8.0-preview-23371-04">here</a></p>
<h3>Drops</h3>
<ul>
<li>Microsoft.TestPlatform.ObjectModel : <a href="https://www.nuget.org/packages/Microsoft.TestPlatform.ObjectModel/17.8.0-preview.23371.4">v17.8.0-preview-23371-04</a></li>
</ul>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/microsoft/vstest/commit/cf7d549fc0197abaabec19d61d2c20d7a7b089f8"><code>cf7d549</code></a> [rel/17.8] Update dependencies from devdiv/DevDiv/vs-code-coverage (<a href="https://redirect.github.com/microsoft/vstest/issues/4692">#4692</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/9fbb6e99222967142be29dabff064e2482cc229d"><code>9fbb6e9</code></a> Merge branch 'main' into rel/17.8</li>
<li><a href="https://github.com/microsoft/vstest/commit/bb99e3ea07aaecd62d5c59568524133317d081b4"><code>bb99e3e</code></a> Upgrade Newtonsoft.Json from 13.0.1 to 13.0.3 (<a href="https://redirect.github.com/microsoft/vstest/issues/4681">#4681</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/e527e41b00c1418bc09abfe4f9550de43f232a27"><code>e527e41</code></a> [main] Update dependencies from dotnet/source-build-reference-packages (<a href="https://redirect.github.com/microsoft/vstest/issues/4677">#4677</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/f49f8c0700491d03c229543fc68980a613c56028"><code>f49f8c0</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/44d3923145828924815d11a836aefaef9856e20d"><code>44d3923</code></a> Release branding 17.8.0</li>
<li><a href="https://github.com/microsoft/vstest/commit/de95035550cad9e1b3ed3c9e31b599a883646205"><code>de95035</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/c2d75c9455e40924d16f2367568df33c6f8d0aec"><code>c2d75c9</code></a> Fix SB ref assembly issue for System.ComponentModel.Composition (<a href="https://redirect.github.com/microsoft/vstest/issues/4675">#4675</a>)</li>
<li><a href="https://github.com/microsoft/vstest/commit/7c7e6806c7bed0cab7d9944502f47e326afec43b"><code>7c7e680</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li><a href="https://github.com/microsoft/vstest/commit/d0f7444a3b4445b0275b368ce233e4d71046b7ed"><code>d0f7444</code></a> Update dependencies from <a href="https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov">https://dev.azure.com/devdiv/DevDiv/_git/vs-code-cov</a>...</li>
<li>Additional commits viewable in <a href="https://github.com/microsoft/vstest/compare/v17.7.2...v17.8.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Microsoft.NET.Test.Sdk&package-manager=nuget&previous-version=17.7.2&new-version=17.8.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Compression.Tests.csproj                       | 2 +-
 .../Apache.Arrow.Flight.Sql.Tests.csproj                        | 2 +-
 .../Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj  | 2 +-
 csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
index 835d95fc0c521..475d7ccc3ef28 100644
--- a/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Compression.Tests/Apache.Arrow.Compression.Tests.csproj
@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
diff --git a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
index 10582500d443c..656ee6a2470e4 100644
--- a/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Sql.Tests/Apache.Arrow.Flight.Sql.Tests.csproj
@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+      <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
       <PackageReference Include="xunit" Version="2.6.1" />
       <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
       <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
index b371de9b1eb99..53fdd6d62dbcb 100644
--- a/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Flight.Tests/Apache.Arrow.Flight.Tests.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
diff --git a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
index 0df097156da34..66becb84c5b66 100644
--- a/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
+++ b/csharp/test/Apache.Arrow.Tests/Apache.Arrow.Tests.csproj
@@ -14,7 +14,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.6.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3">
       <PrivateAssets>all</PrivateAssets>

From 0815a70948b81c1f89252dcdb0c083991fef44a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Nov 2023 08:21:46 +0900
Subject: [PATCH 726/749] MINOR: [C#] Bump Grpc.AspNetCore.Server from 2.58.0
 to 2.59.0 in /csharp (#38688)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Bumps [Grpc.AspNetCore.Server](https://github.com/grpc/grpc-dotnet) from 2.58.0 to 2.59.0.
<details>
<summary>Release notes</summary>
<p><em>Sourced from <a href="https://github.com/grpc/grpc-dotnet/releases">Grpc.AspNetCore.Server's releases</a>.</em></p>
<blockquote>
<h2>Release v2.59.0</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0</a></p>
<h2>Release v2.59.0-pre1</h2>
<h2>What's Changed</h2>
<ul>
<li>Fix HttpContext race condition by copying values to reader and writer by <a href="https://github.com/JamesNK"><code>@​JamesNK</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2294">grpc/grpc-dotnet#2294</a></li>
<li>Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp by <a href="https://github.com/dependabot"><code>@​dependabot</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2298">grpc/grpc-dotnet#2298</a></li>
<li>Update grpc tools to 2.59 by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2303">grpc/grpc-dotnet#2303</a></li>
<li>Update to version 2.59.0-pre1 on v2.59.x branch by <a href="https://github.com/apolcyn"><code>@​apolcyn</code></a> in <a href="https://redirect.github.com/grpc/grpc-dotnet/pull/2307">grpc/grpc-dotnet#2307</a></li>
</ul>
<p><strong>Full Changelog</strong>: <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1">https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0-pre1</a></p>
</blockquote>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/9124a4cb8c210a27bab47cce3da694d0d0b049ea"><code>9124a4c</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2316">#2316</a> from apolcyn/bump_r</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/eb9f932d52597116625fc127e1ae463a0b5faa62"><code>eb9f932</code></a> bump to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/20a6e90ab43f47452446c49bab74c8839047b8d2"><code>20a6e90</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2307">#2307</a> from apolcyn/release_updates</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/2084009f8f375514dcad6b8b1d4571d266e8e6c8"><code>2084009</code></a> bump version to 2.59.0-pre1</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/e52049a94d69bf5105d07193b116800ddd62eae3"><code>e52049a</code></a> Merge pull request <a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2303">#2303</a> from apolcyn/update_59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/51ad5ab7573ce61c1eecf620dc26bd3687d85e07"><code>51ad5ab</code></a> update grpc tools to 2.59</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/3c4abbada1a9794398c40e88b5e9de6c6f4641eb"><code>3c4abba</code></a> Bump <code>@​babel/traverse</code> from 7.17.3 to 7.23.2 in /examples/Spar/Server/ClientApp...</li>
<li><a href="https://github.com/grpc/grpc-dotnet/commit/91be3925c19ab297dda52ff0c201ee025eda0d6e"><code>91be392</code></a> Fix HttpContext race by copying values to reader and writer (<a href="https://redirect.github.com/grpc/grpc-dotnet/issues/2294">#2294</a>)</li>
<li>See full diff in <a href="https://github.com/grpc/grpc-dotnet/compare/v2.58.0...v2.59.0">compare view</a></li>
</ul>
</details>
<br />

[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility_score?dependency-name=Grpc.AspNetCore.Server&package-manager=nuget&previous-version=2.58.0&new-version=2.59.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@ dependabot rebase`.

[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)

---

<details>
<summary>Dependabot commands and options</summary>
<br />

You can trigger Dependabot actions by commenting on this PR:
- `@ dependabot rebase` will rebase this PR
- `@ dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@ dependabot merge` will merge this PR after your CI passes on it
- `@ dependabot squash and merge` will squash and merge this PR after your CI passes on it
- `@ dependabot cancel merge` will cancel a previously requested merge and block automerging
- `@ dependabot reopen` will reopen this PR if it is closed
- `@ dependabot close` will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
- `@ dependabot show <dependency name> ignore conditions` will show all of the ignore conditions of the specified dependency
- `@ dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@ dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

</details>

Authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 .../Apache.Arrow.Flight.AspNetCore.csproj                       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
index 47d7e9746dea1..04cf06b1ec440 100644
--- a/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
+++ b/csharp/src/Apache.Arrow.Flight.AspNetCore/Apache.Arrow.Flight.AspNetCore.csproj
@@ -5,7 +5,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.58.0" />
+    <PackageReference Include="Grpc.AspNetCore.Server" Version="2.59.0" />
   </ItemGroup>
 
   <ItemGroup>

From 9e5c5b5274928c92a642657e73e8cf84f17bd7b7 Mon Sep 17 00:00:00 2001
From: Yue <niyue.com@gmail.com>
Date: Tue, 14 Nov 2023 08:18:10 +0800
Subject: [PATCH 727/749] GH-38653: [Packaging][Java][Python][Ruby] Raise the
 minimum macOS version to 10.15 catalina to allow using new APIs in C++17
 (#38677)

### Rationale for this change
For macOS, some new APIs in C++17, e.g. `std::filesystem::path` is only visible when the compiling target is >= macOS 10.15 (Catalina). But currently the minimum macOS target is set to 10.14 (Mojave).

* macOS 10.14 Mojave was released on 2018-09-24 [1]
* macOS 10.15 Catalina was released on 2019-10-07 [2]
* Both macOS 10.14 and 10.15 are end of life [3]

There is a [similar issue](https://github.com/ClickHouse/ClickHouse/issues/8541) [4] and [its fix](https://github.com/ClickHouse/ClickHouse/pull/8600) [5] for ClickHouse on year 2020, which raised minimum macOS version from 10.14 to 10.15.

### What changes are included in this PR?
Raise the minimum macOS version from 10.14 to 10.15

### Are these changes tested?
This should be tested and verified on CI.

### Are there any user-facing changes?
* Users using macOS <= 10.14 may not able to run these CI jobs locally.
* The new version of python wheels may not be able to be deployed to environments with macOS <= 10.14 (not completely sure how this affects the deployment)
* Closes: #38653

### References
* [1] https://en.wikipedia.org/wiki/MacOS_Mojave
* [2] https://en.wikipedia.org/wiki/MacOS_Catalina
* [3] https://endoflife.date/macos
* [4] https://github.com/ClickHouse/ClickHouse/issues/8541
* [5] https://github.com/ClickHouse/ClickHouse/pull/8600

Authored-by: Yue Ni <niyue.com@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/python_wheel_macos_build.sh       | 2 +-
 ci/vcpkg/universal2-osx-static-debug.cmake   | 2 +-
 ci/vcpkg/universal2-osx-static-release.cmake | 2 +-
 dev/tasks/java-jars/github.yml               | 2 +-
 dev/tasks/tasks.yml                          | 2 +-
 python/CMakeLists.txt                        | 2 +-
 ruby/red-arrow/ext/arrow/extconf.rb          | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/ci/scripts/python_wheel_macos_build.sh b/ci/scripts/python_wheel_macos_build.sh
index 5a3c6fb6d1f6f..fd845c512dcdb 100755
--- a/ci/scripts/python_wheel_macos_build.sh
+++ b/ci/scripts/python_wheel_macos_build.sh
@@ -34,7 +34,7 @@ rm -rf ${source_dir}/python/pyarrow/*.so.*
 
 echo "=== (${PYTHON_VERSION}) Set SDK, C++ and Wheel flags ==="
 export _PYTHON_HOST_PLATFORM="macosx-${MACOSX_DEPLOYMENT_TARGET}-${arch}"
-export MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET:-10.14}
+export MACOSX_DEPLOYMENT_TARGET=${MACOSX_DEPLOYMENT_TARGET:-10.15}
 export SDKROOT=${SDKROOT:-$(xcrun --sdk macosx --show-sdk-path)}
 
 if [ $arch = "arm64" ]; then
diff --git a/ci/vcpkg/universal2-osx-static-debug.cmake b/ci/vcpkg/universal2-osx-static-debug.cmake
index 580b4604d522f..8abc1ebf838f1 100644
--- a/ci/vcpkg/universal2-osx-static-debug.cmake
+++ b/ci/vcpkg/universal2-osx-static-debug.cmake
@@ -21,6 +21,6 @@ set(VCPKG_LIBRARY_LINKAGE static)
 
 set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
 set(VCPKG_OSX_ARCHITECTURES "x86_64;arm64")
-set(VCPKG_OSX_DEPLOYMENT_TARGET "10.14")
+set(VCPKG_OSX_DEPLOYMENT_TARGET "10.15")
 
 set(VCPKG_BUILD_TYPE debug)
diff --git a/ci/vcpkg/universal2-osx-static-release.cmake b/ci/vcpkg/universal2-osx-static-release.cmake
index 7247d0af351c5..2eb36c15175b2 100644
--- a/ci/vcpkg/universal2-osx-static-release.cmake
+++ b/ci/vcpkg/universal2-osx-static-release.cmake
@@ -21,6 +21,6 @@ set(VCPKG_LIBRARY_LINKAGE static)
 
 set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
 set(VCPKG_OSX_ARCHITECTURES "x86_64;arm64")
-set(VCPKG_OSX_DEPLOYMENT_TARGET "10.14")
+set(VCPKG_OSX_DEPLOYMENT_TARGET "10.15")
 
 set(VCPKG_BUILD_TYPE release)
diff --git a/dev/tasks/java-jars/github.yml b/dev/tasks/java-jars/github.yml
index 7dc53a35ef402..fbce12ee427e1 100644
--- a/dev/tasks/java-jars/github.yml
+++ b/dev/tasks/java-jars/github.yml
@@ -81,7 +81,7 @@ jobs:
           - { runs_on: ["macos-latest"], arch: "x86_64"}
           - { runs_on: ["self-hosted", "macOS", "arm64", "devops-managed"], arch: "aarch_64" }
     env:
-      MACOSX_DEPLOYMENT_TARGET: "10.13"
+      MACOSX_DEPLOYMENT_TARGET: "10.15"
     steps:
       {{ macros.github_checkout_arrow()|indent }}
       - name: Set up Python
diff --git a/dev/tasks/tasks.yml b/dev/tasks/tasks.yml
index b8d2f6c0a0086..15fac25d26d65 100644
--- a/dev/tasks/tasks.yml
+++ b/dev/tasks/tasks.yml
@@ -487,7 +487,7 @@ tasks:
 
 {############################## Wheel OSX ####################################}
 
-{% for macos_version, macos_codename in [("10.14", "mojave")] %}
+{% for macos_version, macos_codename in [("10.15", "catalina")] %}
   {% set platform_tag = "macosx_{}_x86_64".format(macos_version.replace('.', '_')) %}
 
   wheel-macos-{{ macos_codename }}-{{ python_tag }}-amd64:
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index 86285c3dc381b..529265235c746 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -84,7 +84,7 @@ set(CMAKE_MACOSX_RPATH 1)
 if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET})
   set(CMAKE_OSX_DEPLOYMENT_TARGET $ENV{MACOSX_DEPLOYMENT_TARGET})
 else()
-  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.14)
+  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15)
 endif()
 
 # Generate a Clang compile_commands.json "compilation database" file for use
diff --git a/ruby/red-arrow/ext/arrow/extconf.rb b/ruby/red-arrow/ext/arrow/extconf.rb
index 8043bb689fc17..7ef3c6c83432a 100644
--- a/ruby/red-arrow/ext/arrow/extconf.rb
+++ b/ruby/red-arrow/ext/arrow/extconf.rb
@@ -84,7 +84,7 @@
   symbols_in_external_bundles.each do |symbol|
     $DLDFLAGS << " -Wl,-U,#{symbol}"
   end
-  mmacosx_version_min = "-mmacosx-version-min=10.14"
+  mmacosx_version_min = "-mmacosx-version-min=10.15"
   $CFLAGS << " #{mmacosx_version_min}"
   $CXXFLAGS << " #{mmacosx_version_min}"
 end

From 160d45c251b5041b9688ff68c3a7c5e091a50989 Mon Sep 17 00:00:00 2001
From: Bryce Mecum <petridish@gmail.com>
Date: Mon, 13 Nov 2023 22:21:12 -0900
Subject: [PATCH 728/749] MINOR: [Docs] Tweak text on docs index page (#38695)

### Rationale for this change

These are just some minor style tweaks which made the text and buttons on these cards read more naturally to me. Feel free to ignore or take only some of the changes here.

### Are these changes tested?

Yes, I confirmed the docs still build as expected locally.

### Are there any user-facing changes?

New language in docs, see above.

Authored-by: Bryce Mecum <petridish@gmail.com>
Signed-off-by: AlenkaF <frim.alenka@gmail.com>
---
 docs/source/index.rst | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/docs/source/index.rst b/docs/source/index.rst
index d01c74f9a482e..8407813bd7abb 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -46,8 +46,8 @@ target environment.**
       :class-card: contrib-card
       :shadow: none
 
-      Read about the Apache Arrow format
-      specifications and Protocols.
+      Read about the Apache Arrow format and its related specifications and
+      protocols.
 
       +++
 
@@ -57,17 +57,15 @@ target environment.**
          :color: primary
          :expand:
 
-         To the Specifications
+         To Specifications
 
    .. grid-item-card:: Development
       :class-card: contrib-card
       :shadow: none
 
-      Find the documentation on the topic of
-      contributions, reviews, building of the libraries
-      from source, building of the documentation, 
-      continuous integration, benchmarks and the
-      release process.
+      Find documentation on building the libraries from source, building the
+      documentation, contributing and code reviews, continuous integration,
+      benchmarking, and the release process.
 
       +++
 
@@ -77,7 +75,7 @@ target environment.**
          :color: primary
          :expand:
 
-         To the Development
+         To Development
 
 .. _toc.columnar:
 

From a4080209a97a5d66accdeb71c5c1ffa982fed51e Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Tue, 14 Nov 2023 05:10:36 -0800
Subject: [PATCH 729/749] GH-38662: [Java] Add comparators (#38669)

### Rationale for this change
Add missing Default VectorValueComparators for some more types.

### What changes are included in this PR?
Add comparators for:
- FixedSizeBinaryVector
- LargeListVector
- FixedSizeListVector
- NullVector

### Are these changes tested?
Yes, unit tests added.

### Are there any user-facing changes?
No
* Closes: #38662

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../sort/DefaultVectorComparators.java        | 140 ++++++++++++++++--
 .../sort/TestDefaultVectorComparator.java     | 132 +++++++++++++++++
 2 files changed, 259 insertions(+), 13 deletions(-)

diff --git a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
index 4f9c8b7d71bab..588876aa99059 100644
--- a/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
+++ b/java/algorithm/src/main/java/org/apache/arrow/algorithm/sort/DefaultVectorComparators.java
@@ -32,11 +32,13 @@
 import org.apache.arrow.vector.Decimal256Vector;
 import org.apache.arrow.vector.DecimalVector;
 import org.apache.arrow.vector.DurationVector;
+import org.apache.arrow.vector.FixedSizeBinaryVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.IntervalDayVector;
 import org.apache.arrow.vector.IntervalMonthDayNanoVector;
+import org.apache.arrow.vector.NullVector;
 import org.apache.arrow.vector.SmallIntVector;
 import org.apache.arrow.vector.TimeMicroVector;
 import org.apache.arrow.vector.TimeMilliVector;
@@ -50,7 +52,9 @@
 import org.apache.arrow.vector.UInt8Vector;
 import org.apache.arrow.vector.ValueVector;
 import org.apache.arrow.vector.VariableWidthVector;
-import org.apache.arrow.vector.complex.BaseRepeatedValueVector;
+import org.apache.arrow.vector.complex.FixedSizeListVector;
+import org.apache.arrow.vector.complex.RepeatedValueVector;
+import org.apache.arrow.vector.holders.NullableFixedSizeBinaryHolder;
 
 /**
  * Default comparator implementations for different types of vectors.
@@ -111,13 +115,21 @@ public static <T extends ValueVector> VectorValueComparator<T> createDefaultComp
         return (VectorValueComparator<T>) new TimeSecComparator();
       } else if (vector instanceof TimeStampVector) {
         return (VectorValueComparator<T>) new TimeStampComparator();
+      } else if (vector instanceof FixedSizeBinaryVector) {
+        return (VectorValueComparator<T>) new FixedSizeBinaryComparator();
       }
     } else if (vector instanceof VariableWidthVector) {
       return (VectorValueComparator<T>) new VariableWidthComparator();
-    } else if (vector instanceof BaseRepeatedValueVector) {
+    } else if (vector instanceof RepeatedValueVector) {
       VectorValueComparator<?> innerComparator =
-              createDefaultComparator(((BaseRepeatedValueVector) vector).getDataVector());
+              createDefaultComparator(((RepeatedValueVector) vector).getDataVector());
       return new RepeatedValueComparator(innerComparator);
+    } else if (vector instanceof FixedSizeListVector) {
+      VectorValueComparator<?> innerComparator =
+          createDefaultComparator(((FixedSizeListVector) vector).getDataVector());
+      return new FixedSizeListComparator(innerComparator);
+    } else if (vector instanceof NullVector) {
+      return (VectorValueComparator<T>) new NullComparator();
     }
 
     throw new IllegalArgumentException("No default comparator for " + vector.getClass().getCanonicalName());
@@ -674,6 +686,61 @@ public VectorValueComparator<TimeStampVector> createNew() {
     }
   }
 
+  /**
+   * Default comparator for {@link org.apache.arrow.vector.FixedSizeBinaryVector}.
+   * The comparison is in lexicographic order, with null comes first.
+   */
+  public static class FixedSizeBinaryComparator extends VectorValueComparator<FixedSizeBinaryVector> {
+
+    @Override
+    public int compare(int index1, int index2) {
+      NullableFixedSizeBinaryHolder holder1 = new NullableFixedSizeBinaryHolder();
+      NullableFixedSizeBinaryHolder holder2 = new NullableFixedSizeBinaryHolder();
+      vector1.get(index1, holder1);
+      vector2.get(index2, holder2);
+
+      return ByteFunctionHelpers.compare(
+          holder1.buffer, 0, holder1.byteWidth, holder2.buffer, 0, holder2.byteWidth);
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      NullableFixedSizeBinaryHolder holder1 = new NullableFixedSizeBinaryHolder();
+      NullableFixedSizeBinaryHolder holder2 = new NullableFixedSizeBinaryHolder();
+      vector1.get(index1, holder1);
+      vector2.get(index2, holder2);
+
+      return ByteFunctionHelpers.compare(
+          holder1.buffer, 0, holder1.byteWidth, holder2.buffer, 0, holder2.byteWidth);
+    }
+
+    @Override
+    public VectorValueComparator<FixedSizeBinaryVector> createNew() {
+      return new FixedSizeBinaryComparator();
+    }
+  }
+
+  /**
+   * Default comparator for {@link org.apache.arrow.vector.NullVector}.
+   */
+  public static class NullComparator extends VectorValueComparator<NullVector> {
+    @Override
+    public int compare(int index1, int index2) {
+      // Values are always equal (and are always null).
+      return 0;
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      throw new AssertionError("Cannot compare non-null values in a NullVector.");
+    }
+
+    @Override
+    public VectorValueComparator<NullVector> createNew() {
+      return new NullComparator();
+    }
+  }
+
   /**
    * Default comparator for {@link org.apache.arrow.vector.VariableWidthVector}.
    * The comparison is in lexicographic order, with null comes first.
@@ -705,14 +772,14 @@ public VectorValueComparator<VariableWidthVector> createNew() {
   }
 
   /**
-   * Default comparator for {@link BaseRepeatedValueVector}.
+   * Default comparator for {@link RepeatedValueVector}.
    * It works by comparing the underlying vector in a lexicographic order.
    * @param <T> inner vector type.
    */
   public static class RepeatedValueComparator<T extends ValueVector>
-          extends VectorValueComparator<BaseRepeatedValueVector> {
+          extends VectorValueComparator<RepeatedValueVector> {
 
-    private VectorValueComparator<T> innerComparator;
+    private final VectorValueComparator<T> innerComparator;
 
     public RepeatedValueComparator(VectorValueComparator<T> innerComparator) {
       this.innerComparator = innerComparator;
@@ -720,16 +787,16 @@ public RepeatedValueComparator(VectorValueComparator<T> innerComparator) {
 
     @Override
     public int compareNotNull(int index1, int index2) {
-      int startIdx1 = vector1.getOffsetBuffer().getInt(index1 * OFFSET_WIDTH);
-      int startIdx2 = vector2.getOffsetBuffer().getInt(index2 * OFFSET_WIDTH);
+      int startIdx1 = vector1.getOffsetBuffer().getInt((long) index1 * OFFSET_WIDTH);
+      int startIdx2 = vector2.getOffsetBuffer().getInt((long) index2 * OFFSET_WIDTH);
 
-      int endIdx1 = vector1.getOffsetBuffer().getInt((index1 + 1) * OFFSET_WIDTH);
-      int endIdx2 = vector2.getOffsetBuffer().getInt((index2 + 1) * OFFSET_WIDTH);
+      int endIdx1 = vector1.getOffsetBuffer().getInt((long) (index1 + 1) * OFFSET_WIDTH);
+      int endIdx2 = vector2.getOffsetBuffer().getInt((long) (index2 + 1) * OFFSET_WIDTH);
 
       int length1 = endIdx1 - startIdx1;
       int length2 = endIdx2 - startIdx2;
 
-      int length = length1 < length2 ? length1 : length2;
+      int length = Math.min(length1, length2);
 
       for (int i = 0; i < length; i++) {
         int result = innerComparator.compare(startIdx1 + i, startIdx2 + i);
@@ -741,13 +808,60 @@ public int compareNotNull(int index1, int index2) {
     }
 
     @Override
-    public VectorValueComparator<BaseRepeatedValueVector> createNew() {
+    public VectorValueComparator<RepeatedValueVector> createNew() {
       VectorValueComparator<T> newInnerComparator = innerComparator.createNew();
       return new RepeatedValueComparator<>(newInnerComparator);
     }
 
     @Override
-    public void attachVectors(BaseRepeatedValueVector vector1, BaseRepeatedValueVector vector2) {
+    public void attachVectors(RepeatedValueVector vector1, RepeatedValueVector vector2) {
+      this.vector1 = vector1;
+      this.vector2 = vector2;
+
+      innerComparator.attachVectors((T) vector1.getDataVector(), (T) vector2.getDataVector());
+    }
+  }
+
+  /**
+   * Default comparator for {@link RepeatedValueVector}.
+   * It works by comparing the underlying vector in a lexicographic order.
+   * @param <T> inner vector type.
+   */
+  public static class FixedSizeListComparator<T extends ValueVector>
+      extends VectorValueComparator<FixedSizeListVector> {
+
+    private final VectorValueComparator<T> innerComparator;
+
+    public FixedSizeListComparator(VectorValueComparator<T> innerComparator) {
+      this.innerComparator = innerComparator;
+    }
+
+    @Override
+    public int compareNotNull(int index1, int index2) {
+      int length1 = vector1.getListSize();
+      int length2 = vector2.getListSize();
+
+      int length = Math.min(length1, length2);
+      int startIdx1 = vector1.getElementStartIndex(index1);
+      int startIdx2 = vector2.getElementStartIndex(index2);
+
+      for (int i = 0; i < length; i++) {
+        int result = innerComparator.compare(startIdx1 + i, startIdx2 + i);
+        if (result != 0) {
+          return result;
+        }
+      }
+      return length1 - length2;
+    }
+
+    @Override
+    public VectorValueComparator<FixedSizeListVector> createNew() {
+      VectorValueComparator<T> newInnerComparator = innerComparator.createNew();
+      return new FixedSizeListComparator<>(newInnerComparator);
+    }
+
+    @Override
+    public void attachVectors(FixedSizeListVector vector1, FixedSizeListVector vector2) {
       this.vector1 = vector1;
       this.vector2 = vector2;
 
diff --git a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
index bdae85110aa62..43c634b7647fb 100644
--- a/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
+++ b/java/algorithm/src/test/java/org/apache/arrow/algorithm/sort/TestDefaultVectorComparator.java
@@ -31,12 +31,14 @@
 import org.apache.arrow.vector.Decimal256Vector;
 import org.apache.arrow.vector.DecimalVector;
 import org.apache.arrow.vector.DurationVector;
+import org.apache.arrow.vector.FixedSizeBinaryVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.IntervalDayVector;
 import org.apache.arrow.vector.LargeVarBinaryVector;
 import org.apache.arrow.vector.LargeVarCharVector;
+import org.apache.arrow.vector.NullVector;
 import org.apache.arrow.vector.SmallIntVector;
 import org.apache.arrow.vector.TimeMicroVector;
 import org.apache.arrow.vector.TimeMilliVector;
@@ -52,6 +54,8 @@
 import org.apache.arrow.vector.ValueVector;
 import org.apache.arrow.vector.VarBinaryVector;
 import org.apache.arrow.vector.VarCharVector;
+import org.apache.arrow.vector.complex.FixedSizeListVector;
+import org.apache.arrow.vector.complex.LargeListVector;
 import org.apache.arrow.vector.complex.ListVector;
 import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
 import org.apache.arrow.vector.types.TimeUnit;
@@ -158,6 +162,61 @@ public void testCopiedComparatorForLists() {
     }
   }
 
+  private FixedSizeListVector createFixedSizeListVector(int count) {
+    FixedSizeListVector listVector = FixedSizeListVector.empty("list vector", count, allocator);
+    Types.MinorType type = Types.MinorType.INT;
+    listVector.addOrGetVector(FieldType.nullable(type.getType()));
+    listVector.allocateNew();
+
+    IntVector dataVector = (IntVector) listVector.getDataVector();
+
+    for (int i = 0; i < count; i++) {
+      dataVector.set(i, i);
+    }
+    dataVector.setValueCount(count);
+
+    listVector.setNotNull(0);
+    listVector.setValueCount(1);
+
+    return listVector;
+  }
+
+  @Test
+  public void testCompareFixedSizeLists() {
+    try (FixedSizeListVector listVector1 = createFixedSizeListVector(10);
+         FixedSizeListVector listVector2 = createFixedSizeListVector(11)) {
+      VectorValueComparator<FixedSizeListVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(listVector1);
+      comparator.attachVectors(listVector1, listVector2);
+
+      // prefix is smaller
+      assertTrue(comparator.compare(0, 0) < 0);
+    }
+
+    try (FixedSizeListVector listVector1 = createFixedSizeListVector(11);
+         FixedSizeListVector listVector2 = createFixedSizeListVector(11)) {
+      ((IntVector) listVector2.getDataVector()).set(10, 110);
+
+      VectorValueComparator<FixedSizeListVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(listVector1);
+      comparator.attachVectors(listVector1, listVector2);
+
+      // breaking tie by the last element
+      assertTrue(comparator.compare(0, 0) < 0);
+    }
+
+    try (FixedSizeListVector listVector1 = createFixedSizeListVector(10);
+         FixedSizeListVector listVector2 = createFixedSizeListVector(10)) {
+
+      VectorValueComparator<FixedSizeListVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(listVector1);
+      comparator.attachVectors(listVector1, listVector2);
+
+      // list vector elements equal
+      assertTrue(comparator.compare(0, 0) == 0);
+    }
+  }
+
   @Test
   public void testCompareUInt1() {
     try (UInt1Vector vec = new UInt1Vector("", allocator)) {
@@ -845,6 +904,65 @@ public void testCompareTimeStamp() {
     }
   }
 
+  @Test
+  public void testCompareFixedSizeBinary() {
+    try (FixedSizeBinaryVector vector1 = new FixedSizeBinaryVector("test1", allocator, 2);
+         FixedSizeBinaryVector vector2 = new FixedSizeBinaryVector("test1", allocator, 3)) {
+      vector1.allocateNew();
+      vector2.allocateNew();
+      vector1.set(0, new byte[] {1, 1});
+      vector2.set(0, new byte[] {1, 1, 0});
+      VectorValueComparator<FixedSizeBinaryVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vector1);
+      comparator.attachVectors(vector1, vector2);
+
+      // prefix is smaller
+      assertTrue(comparator.compare(0, 0) < 0);
+    }
+
+    try (FixedSizeBinaryVector vector1 = new FixedSizeBinaryVector("test1", allocator, 3);
+         FixedSizeBinaryVector vector2 = new FixedSizeBinaryVector("test1", allocator, 3)) {
+      vector1.allocateNew();
+      vector2.allocateNew();
+      vector1.set(0, new byte[] {1, 1, 0});
+      vector2.set(0, new byte[] {1, 1, 1});
+      VectorValueComparator<FixedSizeBinaryVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vector1);
+      comparator.attachVectors(vector1, vector2);
+
+      // breaking tie by the last element
+      assertTrue(comparator.compare(0, 0) < 0);
+    }
+
+    try (FixedSizeBinaryVector vector1 = new FixedSizeBinaryVector("test1", allocator, 3);
+         FixedSizeBinaryVector vector2 = new FixedSizeBinaryVector("test1", allocator, 3)) {
+      vector1.allocateNew();
+      vector2.allocateNew();
+      vector1.set(0, new byte[] {1, 1, 1});
+      vector2.set(0, new byte[] {1, 1, 1});
+      VectorValueComparator<FixedSizeBinaryVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vector1);
+      comparator.attachVectors(vector1, vector2);
+
+      // list vector elements equal
+      assertTrue(comparator.compare(0, 0) == 0);
+    }
+  }
+
+  @Test
+  public void testCompareNull() {
+    try (NullVector vec = new NullVector("test",
+        FieldType.notNullable(new ArrowType.Int(32, false)))) {
+      vec.setValueCount(2);
+
+      VectorValueComparator<NullVector> comparator =
+          DefaultVectorComparators.createDefaultComparator(vec);
+      comparator.attachVector(vec);
+      assertEquals(DefaultVectorComparators.NullComparator.class, comparator.getClass());
+      assertEquals(0, comparator.compare(0, 1));
+    }
+  }
+
   @Test
   public void testCheckNullsOnCompareIsFalseForNonNullableVector() {
     try (IntVector vec = new IntVector("not nullable",
@@ -937,4 +1055,18 @@ private static <V extends ValueVector> void verifyVariableWidthComparatorReturne
     VectorValueComparator<V> comparator = DefaultVectorComparators.createDefaultComparator(vec);
     assertEquals(DefaultVectorComparators.VariableWidthComparator.class, comparator.getClass());
   }
+
+  @Test
+  public void testRepeatedDefaultComparators() {
+    final FieldType type = FieldType.nullable(Types.MinorType.INT.getType());
+    try (final LargeListVector vector = new LargeListVector("list", allocator, type, null)) {
+      vector.addOrGetVector(FieldType.nullable(type.getType()));
+      verifyRepeatedComparatorReturned(vector);
+    }
+  }
+
+  private static <V extends ValueVector> void verifyRepeatedComparatorReturned(V vec) {
+    VectorValueComparator<V> comparator = DefaultVectorComparators.createDefaultComparator(vec);
+    assertEquals(DefaultVectorComparators.RepeatedValueComparator.class, comparator.getClass());
+  }
 }

From f3ec224ab6ace14f630509c79dfbba2ec32d881a Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Tue, 14 Nov 2023 14:25:29 +0100
Subject: [PATCH 730/749] GH-38626: [Python] Fix segfault when PyArrow is
 imported at shutdown (#38637)

### Rationale for this change

Some C++ destructors may be called after the Python interpreter has ceased to exist.
If such a destructor tries to call back in the Python interpreter, for example by calling `Py_DECREF`, we get a crash.

### What changes are included in this PR?

Protect `OwnedRef` and `OwneRefNoGIL` destructors against decref'ing a Python object after Python finalization.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38626

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/src/arrow/python/common.h | 17 ++++++++++-------
 python/pyarrow/tests/test_misc.py        | 13 +++++++++++++
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/python/pyarrow/src/arrow/python/common.h b/python/pyarrow/src/arrow/python/common.h
index e36c0834fd424..bc567ef78e83a 100644
--- a/python/pyarrow/src/arrow/python/common.h
+++ b/python/pyarrow/src/arrow/python/common.h
@@ -188,7 +188,12 @@ class ARROW_PYTHON_EXPORT OwnedRef {
     return *this;
   }
 
-  ~OwnedRef() { reset(); }
+  ~OwnedRef() {
+    // GH-38626: destructor may be called after the Python interpreter is finalized.
+    if (Py_IsInitialized()) {
+      reset();
+    }
+  }
 
   void reset(PyObject* obj) {
     Py_XDECREF(obj_);
@@ -225,13 +230,11 @@ class ARROW_PYTHON_EXPORT OwnedRefNoGIL : public OwnedRef {
   explicit OwnedRefNoGIL(PyObject* obj) : OwnedRef(obj) {}
 
   ~OwnedRefNoGIL() {
-    // This destructor may be called after the Python interpreter is finalized.
-    // At least avoid spurious attempts to take the GIL when not necessary.
-    if (obj() == NULLPTR) {
-      return;
+    // GH-38626: destructor may be called after the Python interpreter is finalized.
+    if (Py_IsInitialized() && obj() != NULLPTR) {
+      PyAcquireGIL lock;
+      reset();
     }
-    PyAcquireGIL lock;
-    reset();
   }
 };
 
diff --git a/python/pyarrow/tests/test_misc.py b/python/pyarrow/tests/test_misc.py
index 9b9dfdd554806..a48ac0c3cd81a 100644
--- a/python/pyarrow/tests/test_misc.py
+++ b/python/pyarrow/tests/test_misc.py
@@ -117,6 +117,19 @@ def test_runtime_info():
         subprocess.check_call([sys.executable, "-c", code], env=env)
 
 
+def test_import_at_shutdown():
+    # GH-38626: importing PyArrow at interpreter shutdown would crash
+    code = """if 1:
+        import atexit
+
+        def import_arrow():
+            import pyarrow
+
+        atexit.register(import_arrow)
+        """
+    subprocess.check_call([sys.executable, "-c", code])
+
+
 @pytest.mark.skipif(sys.platform == "win32",
                     reason="Path to timezone database is not configurable "
                            "on non-Windows platforms")

From bb7ffaf0bd0661baba872c3fe1500369f26241bd Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 14 Nov 2023 10:43:28 -0500
Subject: [PATCH 731/749] GH-38477: [Go] Fixing decimal 128 rounding issue
 (#38478)

### Rationale for this change
Fixing an off-by-one rounding issue with decimal128 by ensuring proper precision handling.

### Are these changes tested?
The test case which reproduced the rounding issue has been added as a unit test.

* Closes: #38477

Authored-by: Matt Topol <zotthewizard@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/arrow/decimal128/decimal128.go      | 4 ++--
 go/arrow/decimal128/decimal128_test.go | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/go/arrow/decimal128/decimal128.go b/go/arrow/decimal128/decimal128.go
index 7bde39d327417..3b88dce1fa809 100644
--- a/go/arrow/decimal128/decimal128.go
+++ b/go/arrow/decimal128/decimal128.go
@@ -261,7 +261,7 @@ func FromString(v string, prec, scale int32) (n Num, err error) {
 	var precInBits = uint(math.Round(float64(prec+scale+1)/math.Log10(2))) + 1
 
 	var out *big.Float
-	out, _, err = big.ParseFloat(v, 10, 127, big.ToNearestEven)
+	out, _, err = big.ParseFloat(v, 10, 128, big.ToNearestEven)
 	if err != nil {
 		return
 	}
@@ -280,7 +280,7 @@ func FromString(v string, prec, scale int32) (n Num, err error) {
 		// (e.g. C++) handles Decimal values. So if we're negative we'll subtract 0.5 and if
 		// we're positive we'll add 0.5.
 		p := (&big.Float{}).SetInt(scaleMultipliers[scale].BigInt())
-		out.Mul(out, p).SetPrec(precInBits)
+		out.SetPrec(precInBits).Mul(out, p)
 		if out.Signbit() {
 			out.Sub(out, pt5)
 		} else {
diff --git a/go/arrow/decimal128/decimal128_test.go b/go/arrow/decimal128/decimal128_test.go
index 879f2849028f8..4cfd7db20db08 100644
--- a/go/arrow/decimal128/decimal128_test.go
+++ b/go/arrow/decimal128/decimal128_test.go
@@ -24,6 +24,7 @@ import (
 
 	"github.com/apache/arrow/go/v15/arrow/decimal128"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFromU64(t *testing.T) {
@@ -698,3 +699,11 @@ func TestBitLen(t *testing.T) {
 	_, err = decimal128.FromString(b.String(), decimal128.MaxPrecision, -1)
 	assert.ErrorContains(t, err, "bitlen too large for decimal128")
 }
+
+func TestFromStringDecimal128b(t *testing.T) {
+	const decStr = "9323406071781562130.6457232358109488923"
+
+	num, err := decimal128.FromString(decStr, 38, 19)
+	require.NoError(t, err)
+	assert.Equal(t, decStr, num.ToString(19))
+}

From cd0d7f53b3ab7dfac7a3477751a87586d4da3782 Mon Sep 17 00:00:00 2001
From: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Date: Tue, 14 Nov 2023 17:31:08 +0100
Subject: [PATCH 732/749] MINOR: [Python] Fix name of new keyword in the
 concat_tables future warning (#38710)

We renamed the new keyword in a final iteration of the PR, but apparently forgot to update the warning message.

Authored-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/table.pxi | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index bbf60416de995..e55a0d1dd54cb 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -5226,7 +5226,8 @@ def concat_tables(tables, MemoryPool memory_pool=None, str promote_options="none
 
     if "promote" in kwargs:
         warnings.warn(
-            "promote has been superseded by mode='default'.", FutureWarning, stacklevel=2)
+            "promote has been superseded by promote_options='default'.",
+            FutureWarning, stacklevel=2)
         if kwargs['promote'] is True:
             promote_options = "default"
 

From 26149d9fab0360e6d4d9a295f934100470c4bc37 Mon Sep 17 00:00:00 2001
From: Matt Topol <zotthewizard@gmail.com>
Date: Tue, 14 Nov 2023 11:44:19 -0500
Subject: [PATCH 733/749] GH-38718: [Go][Format][Integration] Add
 StringView/BinaryView to Go implementation (#35769)

### Rationale for this change
See #35628 for the rationale and description of the StringView/BinaryView array types.

This change is adding Go as a second implementation of it.

### What changes are included in this PR?

Add Array Types for `StringView` and `BinaryView` along with `StringViewType` and `BinaryViewType` and necessary enums and builders. These arrays can be round tripped through JSON and IPC.

### Are these changes tested?
Yes, unit tests have been added and integration tests run

* Closes: [#38718](https://github.com/apache/arrow/issues/38718)
* Closes: #38718

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Alex Shcherbakov <candiduslynx@users.noreply.github.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 .gitattributes                                |   3 +
 docs/source/status.rst                        |   4 +
 format/Schema.fbs                             |   2 +-
 go/arrow/array/array.go                       |   3 +-
 go/arrow/array/binary.go                      | 121 +++++++
 go/arrow/array/binary_test.go                 |  24 ++
 go/arrow/array/binarybuilder.go               | 329 ++++++++++++++++++
 go/arrow/array/bufferbuilder.go               | 108 ++++++
 go/arrow/array/builder.go                     |   4 +
 go/arrow/array/compare.go                     |  12 +
 go/arrow/array/concat.go                      |  30 +-
 go/arrow/array/concat_test.go                 |   3 +
 go/arrow/array/string.go                      | 196 ++++++++++-
 go/arrow/array/string_test.go                 | 173 +++++++++
 go/arrow/compute/executor.go                  |   5 +-
 go/arrow/datatype.go                          |   7 +
 go/arrow/datatype_binary.go                   |  41 +++
 go/arrow/datatype_binary_test.go              |  30 ++
 go/arrow/datatype_viewheader.go               | 141 ++++++++
 go/arrow/datatype_viewheader_inline.go        |  31 ++
 go/arrow/datatype_viewheader_inline_go1.19.go |  35 ++
 go/arrow/datatype_viewheader_inline_tinygo.go |  35 ++
 go/arrow/internal/arrdata/arrdata.go          |  81 +++++
 go/arrow/internal/arrjson/arrjson.go          | 150 ++++++++
 go/arrow/internal/arrjson/arrjson_test.go     | 259 ++++++++++++++
 go/arrow/internal/flatbuf/MetadataVersion.go  |   2 +-
 .../internal/testing/gen/random_array_gen.go  |  34 ++
 go/arrow/ipc/endian_swap.go                   |   4 +
 go/arrow/ipc/file_reader.go                   |  38 +-
 go/arrow/ipc/message.go                       |  10 +-
 go/arrow/ipc/metadata.go                      |  40 ++-
 go/arrow/ipc/writer.go                        |  36 +-
 go/arrow/type_traits_view.go                  |  53 +++
 33 files changed, 2011 insertions(+), 33 deletions(-)
 create mode 100644 go/arrow/datatype_viewheader.go
 create mode 100644 go/arrow/datatype_viewheader_inline.go
 create mode 100644 go/arrow/datatype_viewheader_inline_go1.19.go
 create mode 100644 go/arrow/datatype_viewheader_inline_tinygo.go
 create mode 100644 go/arrow/type_traits_view.go

diff --git a/.gitattributes b/.gitattributes
index 69f4139c4e4f4..70007c26c8b9b 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -3,6 +3,9 @@ cpp/src/generated/*.cpp linguist-generated=true
 cpp/src/generated/*.h linguist-generated=true
 go/**/*.s linguist-generated=true
 go/arrow/unionmode_string.go linguist-generated=true
+go/arrow/internal/flatbuf/*.go linguist-generated=true
+go/**/*.pb.go linguist-generated=true
+go/parquet/internal/gen-go/parquet/*.go linguist-generated=true
 r/R/RcppExports.R linguist-generated=true
 r/R/arrowExports.R linguist-generated=true
 r/src/RcppExports.cpp linguist-generated=true
diff --git a/docs/source/status.rst b/docs/source/status.rst
index c8c0e6dfc1dfe..c059ab3cef971 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -68,6 +68,10 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Large Utf8        | ✓     | ✓     | ✓     |            |       |  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
+| Binary View       | ✓     |       | ✓     |            |       |       |       |       |
++-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
+| String View       | ✓     |       | ✓     |            |       |       |       |       |
++-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Data type         | C++   | Java  | Go    | JavaScript | C#    | Rust  | Julia | Swift |
diff --git a/format/Schema.fbs b/format/Schema.fbs
index 6adbcb115cde3..dbf482e6cc786 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -40,7 +40,7 @@ enum MetadataVersion:short {
   /// >= 0.8.0 (December 2017). Non-backwards compatible with V3.
   V4,
 
-  /// >= 1.0.0 (July 2020. Backwards compatible with V4 (V5 readers can read V4
+  /// >= 1.0.0 (July 2020). Backwards compatible with V4 (V5 readers can read V4
   /// metadata and IPC messages). Implementations are recommended to provide a
   /// V4 compatibility mode with V5 format changes disabled.
   ///
diff --git a/go/arrow/array/array.go b/go/arrow/array/array.go
index bbe301ee661f3..5aacc8f99a4ee 100644
--- a/go/arrow/array/array.go
+++ b/go/arrow/array/array.go
@@ -178,7 +178,8 @@ func init() {
 		arrow.RUN_END_ENCODED:         func(data arrow.ArrayData) arrow.Array { return NewRunEndEncodedData(data) },
 		arrow.LIST_VIEW:               func(data arrow.ArrayData) arrow.Array { return NewListViewData(data) },
 		arrow.LARGE_LIST_VIEW:         func(data arrow.ArrayData) arrow.Array { return NewLargeListViewData(data) },
-
+		arrow.BINARY_VIEW:             func(data arrow.ArrayData) arrow.Array { return NewBinaryViewData(data) },
+		arrow.STRING_VIEW:             func(data arrow.ArrayData) arrow.Array { return NewStringViewData(data) },
 		// invalid data types to fill out array to size 2^6 - 1
 		63: invalidDataType,
 	}
diff --git a/go/arrow/array/binary.go b/go/arrow/array/binary.go
index bf27139fddbaa..c226297da04c6 100644
--- a/go/arrow/array/binary.go
+++ b/go/arrow/array/binary.go
@@ -24,6 +24,7 @@ import (
 	"unsafe"
 
 	"github.com/apache/arrow/go/v15/arrow"
+	"github.com/apache/arrow/go/v15/arrow/memory"
 	"github.com/apache/arrow/go/v15/internal/json"
 )
 
@@ -318,6 +319,126 @@ func arrayEqualLargeBinary(left, right *LargeBinary) bool {
 	return true
 }
 
+type ViewLike interface {
+	arrow.Array
+	ValueHeader(int) *arrow.ViewHeader
+}
+
+type BinaryView struct {
+	array
+	values      []arrow.ViewHeader
+	dataBuffers []*memory.Buffer
+}
+
+func NewBinaryViewData(data arrow.ArrayData) *BinaryView {
+	a := &BinaryView{}
+	a.refCount = 1
+	a.setData(data.(*Data))
+	return a
+}
+
+func (a *BinaryView) setData(data *Data) {
+	if len(data.buffers) < 2 {
+		panic("len(data.buffers) < 2")
+	}
+	a.array.setData(data)
+
+	if valueData := data.buffers[1]; valueData != nil {
+		a.values = arrow.ViewHeaderTraits.CastFromBytes(valueData.Bytes())
+	}
+
+	a.dataBuffers = data.buffers[2:]
+}
+
+func (a *BinaryView) ValueHeader(i int) *arrow.ViewHeader {
+	if i < 0 || i >= a.array.data.length {
+		panic("arrow/array: index out of range")
+	}
+	return &a.values[a.array.data.offset+i]
+}
+
+func (a *BinaryView) Value(i int) []byte {
+	s := a.ValueHeader(i)
+	if s.IsInline() {
+		return s.InlineBytes()
+	}
+	start := s.BufferOffset()
+	buf := a.dataBuffers[s.BufferIndex()]
+	return buf.Bytes()[start : start+int32(s.Len())]
+}
+
+// ValueString returns the value at index i as a string instead of
+// a byte slice, without copying the underlying data.
+func (a *BinaryView) ValueString(i int) string {
+	b := a.Value(i)
+	return *(*string)(unsafe.Pointer(&b))
+}
+
+func (a *BinaryView) String() string {
+	var o strings.Builder
+	o.WriteString("[")
+	for i := 0; i < a.Len(); i++ {
+		if i > 0 {
+			o.WriteString(" ")
+		}
+		switch {
+		case a.IsNull(i):
+			o.WriteString(NullValueStr)
+		default:
+			fmt.Fprintf(&o, "%q", a.ValueString(i))
+		}
+	}
+	o.WriteString("]")
+	return o.String()
+}
+
+// ValueStr is paired with AppendValueFromString in that it returns
+// the value at index i as a string: Semantically this means that for
+// a null value it will return the string "(null)", otherwise it will
+// return the value as a base64 encoded string suitable for CSV/JSON.
+//
+// This is always going to be less performant than just using ValueString
+// and exists to fulfill the Array interface to provide a method which
+// can produce a human readable string for a given index.
+func (a *BinaryView) ValueStr(i int) string {
+	if a.IsNull(i) {
+		return NullValueStr
+	}
+	return base64.StdEncoding.EncodeToString(a.Value(i))
+}
+
+func (a *BinaryView) GetOneForMarshal(i int) interface{} {
+	if a.IsNull(i) {
+		return nil
+	}
+	return a.Value(i)
+}
+
+func (a *BinaryView) MarshalJSON() ([]byte, error) {
+	vals := make([]interface{}, a.Len())
+	for i := 0; i < a.Len(); i++ {
+		vals[i] = a.GetOneForMarshal(i)
+	}
+	// golang marshal standard says that []byte will be marshalled
+	// as a base64-encoded string
+	return json.Marshal(vals)
+}
+
+func arrayEqualBinaryView(left, right *BinaryView) bool {
+	leftBufs, rightBufs := left.dataBuffers, right.dataBuffers
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		if !left.ValueHeader(i).Equals(leftBufs, right.ValueHeader(i), rightBufs) {
+			return false
+		}
+	}
+	return true
+}
+
 var (
 	_ arrow.Array = (*Binary)(nil)
+	_ arrow.Array = (*LargeBinary)(nil)
+	_ arrow.Array = (*BinaryView)(nil)
 )
diff --git a/go/arrow/array/binary_test.go b/go/arrow/array/binary_test.go
index 9c1770950a8b5..c9e165515225b 100644
--- a/go/arrow/array/binary_test.go
+++ b/go/arrow/array/binary_test.go
@@ -700,3 +700,27 @@ func TestBinaryStringRoundTrip(t *testing.T) {
 
 	assert.True(t, Equal(arr, arr1))
 }
+
+func TestBinaryViewStringRoundTrip(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.DefaultAllocator)
+	defer mem.AssertSize(t, 0)
+
+	values := []string{"a", "bc", "", "", "supercalifragilistic", "", "expeallodocious"}
+	valid := []bool{true, true, false, false, true, true, true}
+
+	b := NewBinaryViewBuilder(mem)
+	defer b.Release()
+
+	b.AppendStringValues(values, valid)
+	arr := b.NewArray().(*BinaryView)
+	defer arr.Release()
+
+	for i := 0; i < arr.Len(); i++ {
+		assert.NoError(t, b.AppendValueFromString(arr.ValueStr(i)))
+	}
+
+	arr1 := b.NewArray().(*BinaryView)
+	defer arr1.Release()
+
+	assert.True(t, Equal(arr, arr1))
+}
diff --git a/go/arrow/array/binarybuilder.go b/go/arrow/array/binarybuilder.go
index a51bc799e4965..21ad576508e9e 100644
--- a/go/arrow/array/binarybuilder.go
+++ b/go/arrow/array/binarybuilder.go
@@ -23,6 +23,7 @@ import (
 	"math"
 	"reflect"
 	"sync/atomic"
+	"unsafe"
 
 	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/apache/arrow/go/v15/arrow/internal/debug"
@@ -370,6 +371,334 @@ func (b *BinaryBuilder) UnmarshalJSON(data []byte) error {
 	return b.Unmarshal(dec)
 }
 
+const (
+	dfltBlockSize            = 32 << 10 // 32 KB
+	viewValueSizeLimit int32 = math.MaxInt32
+)
+
+type BinaryViewBuilder struct {
+	builder
+	dtype arrow.BinaryDataType
+
+	data    *memory.Buffer
+	rawData []arrow.ViewHeader
+
+	blockBuilder multiBufferBuilder
+}
+
+func NewBinaryViewBuilder(mem memory.Allocator) *BinaryViewBuilder {
+	return &BinaryViewBuilder{
+		dtype: arrow.BinaryTypes.BinaryView,
+		builder: builder{
+			refCount: 1,
+			mem:      mem,
+		},
+		blockBuilder: multiBufferBuilder{
+			refCount:  1,
+			blockSize: dfltBlockSize,
+			mem:       mem,
+		},
+	}
+}
+
+func (b *BinaryViewBuilder) SetBlockSize(sz uint) {
+	b.blockBuilder.blockSize = int(sz)
+}
+
+func (b *BinaryViewBuilder) Type() arrow.DataType { return b.dtype }
+
+func (b *BinaryViewBuilder) Release() {
+	debug.Assert(atomic.LoadInt64(&b.refCount) > 0, "too many releases")
+
+	if atomic.AddInt64(&b.refCount, -1) != 0 {
+		return
+	}
+
+	if b.nullBitmap != nil {
+		b.nullBitmap.Release()
+		b.nullBitmap = nil
+	}
+	if b.data != nil {
+		b.data.Release()
+		b.data = nil
+		b.rawData = nil
+	}
+}
+
+func (b *BinaryViewBuilder) init(capacity int) {
+	b.builder.init(capacity)
+	b.data = memory.NewResizableBuffer(b.mem)
+	bytesN := arrow.ViewHeaderTraits.BytesRequired(capacity)
+	b.data.Resize(bytesN)
+	b.rawData = arrow.ViewHeaderTraits.CastFromBytes(b.data.Bytes())
+}
+
+func (b *BinaryViewBuilder) Resize(n int) {
+	nbuild := n
+	if n < minBuilderCapacity {
+		n = minBuilderCapacity
+	}
+
+	if b.capacity == 0 {
+		b.init(n)
+		return
+	}
+
+	b.builder.resize(nbuild, b.init)
+	b.data.Resize(arrow.ViewHeaderTraits.BytesRequired(n))
+	b.rawData = arrow.ViewHeaderTraits.CastFromBytes(b.data.Bytes())
+}
+
+func (b *BinaryViewBuilder) ReserveData(length int) {
+	if int32(length) > viewValueSizeLimit {
+		panic(fmt.Errorf("%w: BinaryView or StringView elements cannot reference strings larger than 2GB",
+			arrow.ErrInvalid))
+	}
+	b.blockBuilder.Reserve(int(length))
+}
+
+func (b *BinaryViewBuilder) Reserve(n int) {
+	b.builder.reserve(n, b.Resize)
+}
+
+func (b *BinaryViewBuilder) Append(v []byte) {
+	if int32(len(v)) > viewValueSizeLimit {
+		panic(fmt.Errorf("%w: BinaryView or StringView elements cannot reference strings larger than 2GB", arrow.ErrInvalid))
+	}
+
+	if !arrow.IsViewInline(len(v)) {
+		b.ReserveData(len(v))
+	}
+
+	b.Reserve(1)
+	b.UnsafeAppend(v)
+}
+
+// AppendString is identical to Append, only accepting a string instead
+// of a byte slice, avoiding the extra copy that would occur if you simply
+// did []byte(v).
+//
+// This is different than AppendValueFromString which exists for the
+// Builder interface, in that this expects raw binary data which is
+// appended unmodified. AppendValueFromString expects base64 encoded binary
+// data instead.
+func (b *BinaryViewBuilder) AppendString(v string) {
+	// create a []byte without copying the bytes
+	// in go1.20 this would be unsafe.StringData
+	val := *(*[]byte)(unsafe.Pointer(&struct {
+		string
+		int
+	}{v, len(v)}))
+	b.Append(val)
+}
+
+func (b *BinaryViewBuilder) AppendNull() {
+	b.Reserve(1)
+	b.UnsafeAppendBoolToBitmap(false)
+}
+
+func (b *BinaryViewBuilder) AppendNulls(n int) {
+	b.Reserve(n)
+	for i := 0; i < n; i++ {
+		b.UnsafeAppendBoolToBitmap(false)
+	}
+}
+
+func (b *BinaryViewBuilder) AppendEmptyValue() {
+	b.Reserve(1)
+	b.UnsafeAppendBoolToBitmap(true)
+}
+
+func (b *BinaryViewBuilder) AppendEmptyValues(n int) {
+	b.Reserve(n)
+	b.unsafeAppendBoolsToBitmap(nil, n)
+}
+
+func (b *BinaryViewBuilder) UnsafeAppend(v []byte) {
+	hdr := &b.rawData[b.length]
+	hdr.SetBytes(v)
+	if !hdr.IsInline() {
+		b.blockBuilder.UnsafeAppend(hdr, v)
+	}
+	b.UnsafeAppendBoolToBitmap(true)
+}
+
+func (b *BinaryViewBuilder) AppendValues(v [][]byte, valid []bool) {
+	if len(v) != len(valid) && len(valid) != 0 {
+		panic("len(v) != len(valid) && len(valid) != 0")
+	}
+
+	if len(v) == 0 {
+		return
+	}
+
+	b.Reserve(len(v))
+	outOfLineTotal := 0
+	for i, vv := range v {
+		if len(valid) == 0 || valid[i] {
+			if !arrow.IsViewInline(len(vv)) {
+				outOfLineTotal += len(vv)
+			}
+		}
+	}
+
+	b.ReserveData(outOfLineTotal)
+	for i, vv := range v {
+		if len(valid) == 0 || valid[i] {
+			hdr := &b.rawData[b.length+i]
+			hdr.SetBytes(vv)
+			if !hdr.IsInline() {
+				b.blockBuilder.UnsafeAppend(hdr, vv)
+			}
+		}
+	}
+
+	b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+}
+
+func (b *BinaryViewBuilder) AppendStringValues(v []string, valid []bool) {
+	if len(v) != len(valid) && len(valid) != 0 {
+		panic("len(v) != len(valid) && len(valid) != 0")
+	}
+
+	if len(v) == 0 {
+		return
+	}
+
+	b.Reserve(len(v))
+	outOfLineTotal := 0
+	for i, vv := range v {
+		if len(valid) == 0 || valid[i] {
+			if !arrow.IsViewInline(len(vv)) {
+				outOfLineTotal += len(vv)
+			}
+		}
+	}
+
+	b.ReserveData(outOfLineTotal)
+	for i, vv := range v {
+		if len(valid) == 0 || valid[i] {
+			hdr := &b.rawData[b.length+i]
+			hdr.SetString(vv)
+			if !hdr.IsInline() {
+				b.blockBuilder.UnsafeAppendString(hdr, vv)
+			}
+		}
+	}
+
+	b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+}
+
+// AppendValueFromString is paired with ValueStr for fulfilling the
+// base Builder interface. This is intended to read in a human-readable
+// string such as from CSV or JSON and append it to the array.
+//
+// For Binary values are expected to be base64 encoded (and will be
+// decoded as such before being appended).
+func (b *BinaryViewBuilder) AppendValueFromString(s string) error {
+	if s == NullValueStr {
+		b.AppendNull()
+		return nil
+	}
+
+	if b.dtype.IsUtf8() {
+		b.Append([]byte(s))
+		return nil
+	}
+
+	decodedVal, err := base64.StdEncoding.DecodeString(s)
+	if err != nil {
+		return fmt.Errorf("could not decode base64 string: %w", err)
+	}
+	b.Append(decodedVal)
+	return nil
+}
+
+func (b *BinaryViewBuilder) UnmarshalOne(dec *json.Decoder) error {
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch v := t.(type) {
+	case string:
+		data, err := base64.StdEncoding.DecodeString(v)
+		if err != nil {
+			return err
+		}
+		b.Append(data)
+	case []byte:
+		b.Append(v)
+	case nil:
+		b.AppendNull()
+	default:
+		return &json.UnmarshalTypeError{
+			Value:  fmt.Sprint(t),
+			Type:   reflect.TypeOf([]byte{}),
+			Offset: dec.InputOffset(),
+		}
+	}
+	return nil
+}
+
+func (b *BinaryViewBuilder) Unmarshal(dec *json.Decoder) error {
+	for dec.More() {
+		if err := b.UnmarshalOne(dec); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (b *BinaryViewBuilder) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if delim, ok := t.(json.Delim); !ok || delim != '[' {
+		return fmt.Errorf("binary view builder must unpack from json array, found %s", delim)
+	}
+
+	return b.Unmarshal(dec)
+}
+
+func (b *BinaryViewBuilder) newData() (data *Data) {
+	bytesRequired := arrow.ViewHeaderTraits.BytesRequired(b.length)
+	if bytesRequired > 0 && bytesRequired < b.data.Len() {
+		// trim buffers
+		b.data.Resize(bytesRequired)
+	}
+
+	dataBuffers := b.blockBuilder.Finish()
+	data = NewData(b.dtype, b.length, append([]*memory.Buffer{
+		b.nullBitmap, b.data}, dataBuffers...), nil, b.nulls, 0)
+	b.reset()
+
+	if b.data != nil {
+		b.data.Release()
+		b.data = nil
+		b.rawData = nil
+		for _, buf := range dataBuffers {
+			buf.Release()
+		}
+	}
+	return
+}
+
+func (b *BinaryViewBuilder) NewBinaryViewArray() (a *BinaryView) {
+	data := b.newData()
+	a = NewBinaryViewData(data)
+	data.Release()
+	return
+}
+
+func (b *BinaryViewBuilder) NewArray() arrow.Array {
+	return b.NewBinaryViewArray()
+}
+
 var (
 	_ Builder = (*BinaryBuilder)(nil)
+	_ Builder = (*BinaryViewBuilder)(nil)
 )
diff --git a/go/arrow/array/bufferbuilder.go b/go/arrow/array/bufferbuilder.go
index cb381e25b32a2..13741ba8926ac 100644
--- a/go/arrow/array/bufferbuilder.go
+++ b/go/arrow/array/bufferbuilder.go
@@ -18,7 +18,9 @@ package array
 
 import (
 	"sync/atomic"
+	"unsafe"
 
+	"github.com/apache/arrow/go/v15/arrow"
 	"github.com/apache/arrow/go/v15/arrow/bitutil"
 	"github.com/apache/arrow/go/v15/arrow/internal/debug"
 	"github.com/apache/arrow/go/v15/arrow/memory"
@@ -151,3 +153,109 @@ func (b *bufferBuilder) unsafeAppend(data []byte) {
 	copy(b.bytes[b.length:], data)
 	b.length += len(data)
 }
+
+type multiBufferBuilder struct {
+	refCount  int64
+	blockSize int
+
+	mem              memory.Allocator
+	blocks           []*memory.Buffer
+	currentOutBuffer int
+}
+
+// Retain increases the reference count by 1.
+// Retain may be called simultaneously from multiple goroutines.
+func (b *multiBufferBuilder) Retain() {
+	atomic.AddInt64(&b.refCount, 1)
+}
+
+// Release decreases the reference count by 1.
+// When the reference count goes to zero, the memory is freed.
+// Release may be called simultaneously from multiple goroutines.
+func (b *multiBufferBuilder) Release() {
+	debug.Assert(atomic.LoadInt64(&b.refCount) > 0, "too many releases")
+
+	if atomic.AddInt64(&b.refCount, -1) == 0 {
+		b.Reset()
+	}
+}
+
+func (b *multiBufferBuilder) Reserve(nbytes int) {
+	if len(b.blocks) == 0 {
+		out := memory.NewResizableBuffer(b.mem)
+		if nbytes < b.blockSize {
+			nbytes = b.blockSize
+		}
+		out.Reserve(nbytes)
+		b.currentOutBuffer = 0
+		b.blocks = []*memory.Buffer{out}
+		return
+	}
+
+	curBuf := b.blocks[b.currentOutBuffer]
+	remain := curBuf.Cap() - curBuf.Len()
+	if nbytes <= remain {
+		return
+	}
+
+	// search for underfull block that has enough bytes
+	for i, block := range b.blocks {
+		remaining := block.Cap() - block.Len()
+		if nbytes <= remaining {
+			b.currentOutBuffer = i
+			return
+		}
+	}
+
+	// current buffer doesn't have enough space, no underfull buffers
+	// make new buffer and set that as our current.
+	newBuf := memory.NewResizableBuffer(b.mem)
+	if nbytes < b.blockSize {
+		nbytes = b.blockSize
+	}
+
+	newBuf.Reserve(nbytes)
+	b.currentOutBuffer = len(b.blocks)
+	b.blocks = append(b.blocks, newBuf)
+}
+
+func (b *multiBufferBuilder) RemainingBytes() int {
+	if len(b.blocks) == 0 {
+		return 0
+	}
+
+	buf := b.blocks[b.currentOutBuffer]
+	return buf.Cap() - buf.Len()
+}
+
+func (b *multiBufferBuilder) Reset() {
+	b.currentOutBuffer = 0
+	for _, block := range b.Finish() {
+		block.Release()
+	}
+}
+
+func (b *multiBufferBuilder) UnsafeAppend(hdr *arrow.ViewHeader, val []byte) {
+	buf := b.blocks[b.currentOutBuffer]
+	idx, offset := b.currentOutBuffer, buf.Len()
+	hdr.SetIndexOffset(int32(idx), int32(offset))
+
+	n := copy(buf.Buf()[offset:], val)
+	buf.ResizeNoShrink(offset + n)
+}
+
+func (b *multiBufferBuilder) UnsafeAppendString(hdr *arrow.ViewHeader, val string) {
+	// create a byte slice with zero-copies
+	// in go1.20 this would be equivalent to unsafe.StringData
+	v := *(*[]byte)(unsafe.Pointer(&struct {
+		string
+		int
+	}{val, len(val)}))
+	b.UnsafeAppend(hdr, v)
+}
+
+func (b *multiBufferBuilder) Finish() (out []*memory.Buffer) {
+	b.currentOutBuffer = 0
+	out, b.blocks = b.blocks, nil
+	return
+}
diff --git a/go/arrow/array/builder.go b/go/arrow/array/builder.go
index bb15298e03ccf..279804a1cdb9f 100644
--- a/go/arrow/array/builder.go
+++ b/go/arrow/array/builder.go
@@ -364,6 +364,10 @@ func NewBuilder(mem memory.Allocator, dtype arrow.DataType) Builder {
 	case arrow.RUN_END_ENCODED:
 		typ := dtype.(*arrow.RunEndEncodedType)
 		return NewRunEndEncodedBuilder(mem, typ.RunEnds(), typ.Encoded())
+	case arrow.BINARY_VIEW:
+		return NewBinaryViewBuilder(mem)
+	case arrow.STRING_VIEW:
+		return NewStringViewBuilder(mem)
 	}
 	panic(fmt.Errorf("arrow/array: unsupported builder for %T", dtype))
 }
diff --git a/go/arrow/array/compare.go b/go/arrow/array/compare.go
index 778de41e32c67..372293a61d6cb 100644
--- a/go/arrow/array/compare.go
+++ b/go/arrow/array/compare.go
@@ -232,6 +232,12 @@ func Equal(left, right arrow.Array) bool {
 	case *LargeString:
 		r := right.(*LargeString)
 		return arrayEqualLargeString(l, r)
+	case *BinaryView:
+		r := right.(*BinaryView)
+		return arrayEqualBinaryView(l, r)
+	case *StringView:
+		r := right.(*StringView)
+		return arrayEqualStringView(l, r)
 	case *Int8:
 		r := right.(*Int8)
 		return arrayEqualInt8(l, r)
@@ -482,6 +488,12 @@ func arrayApproxEqual(left, right arrow.Array, opt equalOption) bool {
 	case *LargeString:
 		r := right.(*LargeString)
 		return arrayEqualLargeString(l, r)
+	case *BinaryView:
+		r := right.(*BinaryView)
+		return arrayEqualBinaryView(l, r)
+	case *StringView:
+		r := right.(*StringView)
+		return arrayEqualStringView(l, r)
 	case *Int8:
 		r := right.(*Int8)
 		return arrayEqualInt8(l, r)
diff --git a/go/arrow/array/concat.go b/go/arrow/array/concat.go
index 53c5be06895b9..fa3554c1c0555 100644
--- a/go/arrow/array/concat.go
+++ b/go/arrow/array/concat.go
@@ -600,6 +600,35 @@ func concat(data []arrow.ArrayData, mem memory.Allocator) (arr arrow.ArrayData,
 		}
 	case arrow.FixedWidthDataType:
 		out.buffers[1] = concatBuffers(gatherBuffersFixedWidthType(data, 1, dt), mem)
+	case arrow.BinaryViewDataType:
+		out.buffers = out.buffers[:2]
+		for _, d := range data {
+			for _, buf := range d.Buffers()[2:] {
+				buf.Retain()
+				out.buffers = append(out.buffers, buf)
+			}
+		}
+
+		out.buffers[1] = concatBuffers(gatherFixedBuffers(data, 1, arrow.ViewHeaderSizeBytes), mem)
+
+		var (
+			s                  = arrow.ViewHeaderTraits.CastFromBytes(out.buffers[1].Bytes())
+			i                  = data[0].Len()
+			precedingBufsCount int
+		)
+
+		for idx := 1; idx < len(data); idx++ {
+			precedingBufsCount += len(data[idx-1].Buffers()) - 2
+
+			for end := i + data[idx].Len(); i < end; i++ {
+				if s[i].IsInline() {
+					continue
+				}
+
+				bufIndex := s[i].BufferIndex() + int32(precedingBufsCount)
+				s[i].SetIndexOffset(bufIndex, s[i].BufferOffset())
+			}
+		}
 	case arrow.BinaryDataType:
 		offsetWidth := dt.Layout().Buffers[1].ByteWidth
 		offsetBuffer, valueRanges, err := concatOffsets(gatherFixedBuffers(data, 1, offsetWidth), offsetWidth, mem)
@@ -739,7 +768,6 @@ func concat(data []arrow.ArrayData, mem memory.Allocator) (arr arrow.ArrayData,
 			out.childData[0].Release()
 			return nil, err
 		}
-
 	default:
 		return nil, fmt.Errorf("concatenate not implemented for type %s", dt)
 	}
diff --git a/go/arrow/array/concat_test.go b/go/arrow/array/concat_test.go
index 1cc484ad1a923..7b22d97a41e00 100644
--- a/go/arrow/array/concat_test.go
+++ b/go/arrow/array/concat_test.go
@@ -84,6 +84,7 @@ func TestConcatenate(t *testing.T) {
 		{arrow.StructOf()},
 		{arrow.MapOf(arrow.PrimitiveTypes.Uint16, arrow.PrimitiveTypes.Int8)},
 		{&arrow.DictionaryType{IndexType: arrow.PrimitiveTypes.Int32, ValueType: arrow.PrimitiveTypes.Float64}},
+		{arrow.BinaryTypes.StringView},
 	}
 
 	for _, tt := range tests {
@@ -150,6 +151,8 @@ func (cts *ConcatTestSuite) generateArr(size int64, nullprob float64) arrow.Arra
 		return cts.rng.String(size, 0, 15, nullprob)
 	case arrow.LARGE_STRING:
 		return cts.rng.LargeString(size, 0, 15, nullprob)
+	case arrow.STRING_VIEW:
+		return cts.rng.StringView(size, 0, 20, nullprob)
 	case arrow.LIST:
 		valuesSize := size * 4
 		values := cts.rng.Int8(valuesSize, 0, 127, nullprob).(*array.Int8)
diff --git a/go/arrow/array/string.go b/go/arrow/array/string.go
index 9ab7c938ef5d8..90a4628f0d0fb 100644
--- a/go/arrow/array/string.go
+++ b/go/arrow/array/string.go
@@ -28,6 +28,11 @@ import (
 	"github.com/apache/arrow/go/v15/internal/json"
 )
 
+type StringLike interface {
+	arrow.Array
+	Value(int) string
+}
+
 // String represents an immutable sequence of variable-length UTF-8 strings.
 type String struct {
 	array
@@ -310,6 +315,108 @@ func arrayEqualLargeString(left, right *LargeString) bool {
 	return true
 }
 
+type StringView struct {
+	array
+	values      []arrow.ViewHeader
+	dataBuffers []*memory.Buffer
+}
+
+func NewStringViewData(data arrow.ArrayData) *StringView {
+	a := &StringView{}
+	a.refCount = 1
+	a.setData(data.(*Data))
+	return a
+}
+
+// Reset resets the String with a different set of Data.
+func (a *StringView) Reset(data arrow.ArrayData) {
+	a.setData(data.(*Data))
+}
+
+func (a *StringView) setData(data *Data) {
+	if len(data.buffers) < 2 {
+		panic("len(data.buffers) < 2")
+	}
+	a.array.setData(data)
+
+	if valueData := data.buffers[1]; valueData != nil {
+		a.values = arrow.ViewHeaderTraits.CastFromBytes(valueData.Bytes())
+	}
+
+	a.dataBuffers = data.buffers[2:]
+}
+
+func (a *StringView) ValueHeader(i int) *arrow.ViewHeader {
+	if i < 0 || i >= a.array.data.length {
+		panic("arrow/array: index out of range")
+	}
+	return &a.values[a.array.data.offset+i]
+}
+
+func (a *StringView) Value(i int) string {
+	s := a.ValueHeader(i)
+	if s.IsInline() {
+		return s.InlineString()
+	}
+	start := s.BufferOffset()
+	buf := a.dataBuffers[s.BufferIndex()]
+	value := buf.Bytes()[start : start+int32(s.Len())]
+	return *(*string)(unsafe.Pointer(&value))
+}
+
+func (a *StringView) String() string {
+	var o strings.Builder
+	o.WriteString("[")
+	for i := 0; i < a.Len(); i++ {
+		if i > 0 {
+			o.WriteString(" ")
+		}
+		switch {
+		case a.IsNull(i):
+			o.WriteString(NullValueStr)
+		default:
+			fmt.Fprintf(&o, "%q", a.Value(i))
+		}
+	}
+	o.WriteString("]")
+	return o.String()
+}
+
+func (a *StringView) ValueStr(i int) string {
+	if a.IsNull(i) {
+		return NullValueStr
+	}
+	return a.Value(i)
+}
+
+func (a *StringView) GetOneForMarshal(i int) interface{} {
+	if a.IsNull(i) {
+		return nil
+	}
+	return a.Value(i)
+}
+
+func (a *StringView) MarshalJSON() ([]byte, error) {
+	vals := make([]interface{}, a.Len())
+	for i := 0; i < a.Len(); i++ {
+		vals[i] = a.GetOneForMarshal(i)
+	}
+	return json.Marshal(vals)
+}
+
+func arrayEqualStringView(left, right *StringView) bool {
+	leftBufs, rightBufs := left.dataBuffers, right.dataBuffers
+	for i := 0; i < left.Len(); i++ {
+		if left.IsNull(i) {
+			continue
+		}
+		if !left.ValueHeader(i).Equals(leftBufs, right.ValueHeader(i), rightBufs) {
+			return false
+		}
+	}
+	return true
+}
+
 // A StringBuilder is used to build a String array using the Append methods.
 type StringBuilder struct {
 	*BinaryBuilder
@@ -344,10 +451,6 @@ func (b *StringBuilder) Value(i int) string {
 	return string(b.BinaryBuilder.Value(i))
 }
 
-// func (b *StringBuilder) UnsafeAppend(v string) {
-// 	b.BinaryBuilder.UnsafeAppend([]byte(v))
-// }
-
 // NewArray creates a String array from the memory buffers used by the builder and resets the StringBuilder
 // so it can be used to build a new array.
 func (b *StringBuilder) NewArray() arrow.Array {
@@ -441,10 +544,6 @@ func (b *LargeStringBuilder) Value(i int) string {
 	return string(b.BinaryBuilder.Value(i))
 }
 
-// func (b *LargeStringBuilder) UnsafeAppend(v string) {
-// 	b.BinaryBuilder.UnsafeAppend([]byte(v))
-// }
-
 // NewArray creates a String array from the memory buffers used by the builder and resets the StringBuilder
 // so it can be used to build a new array.
 func (b *LargeStringBuilder) NewArray() arrow.Array {
@@ -504,9 +603,87 @@ func (b *LargeStringBuilder) UnmarshalJSON(data []byte) error {
 	return b.Unmarshal(dec)
 }
 
+type StringViewBuilder struct {
+	*BinaryViewBuilder
+}
+
+func NewStringViewBuilder(mem memory.Allocator) *StringViewBuilder {
+	bldr := &StringViewBuilder{
+		BinaryViewBuilder: NewBinaryViewBuilder(mem),
+	}
+	bldr.dtype = arrow.BinaryTypes.StringView
+	return bldr
+}
+
+func (b *StringViewBuilder) Append(v string) {
+	b.BinaryViewBuilder.AppendString(v)
+}
+
+func (b *StringViewBuilder) AppendValues(v []string, valid []bool) {
+	b.BinaryViewBuilder.AppendStringValues(v, valid)
+}
+
+func (b *StringViewBuilder) UnmarshalOne(dec *json.Decoder) error {
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch v := t.(type) {
+	case string:
+		b.Append(v)
+	case []byte:
+		b.BinaryViewBuilder.Append(v)
+	case nil:
+		b.AppendNull()
+	default:
+		return &json.UnmarshalTypeError{
+			Value:  fmt.Sprint(t),
+			Type:   reflect.TypeOf([]byte{}),
+			Offset: dec.InputOffset(),
+		}
+	}
+	return nil
+}
+
+func (b *StringViewBuilder) Unmarshal(dec *json.Decoder) error {
+	for dec.More() {
+		if err := b.UnmarshalOne(dec); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (b *StringViewBuilder) UnmarshalJSON(data []byte) error {
+	dec := json.NewDecoder(bytes.NewReader(data))
+	t, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if delim, ok := t.(json.Delim); !ok || delim != '[' {
+		return fmt.Errorf("binary view builder must unpack from json array, found %s", delim)
+	}
+
+	return b.Unmarshal(dec)
+}
+
+func (b *StringViewBuilder) NewArray() arrow.Array {
+	return b.NewStringViewArray()
+}
+
+func (b *StringViewBuilder) NewStringViewArray() (a *StringView) {
+	data := b.newData()
+	a = NewStringViewData(data)
+	data.Release()
+	return
+}
+
 type StringLikeBuilder interface {
 	Builder
 	Append(string)
+	AppendValues([]string, []bool)
 	UnsafeAppend([]byte)
 	ReserveData(int)
 }
@@ -514,8 +691,11 @@ type StringLikeBuilder interface {
 var (
 	_ arrow.Array       = (*String)(nil)
 	_ arrow.Array       = (*LargeString)(nil)
+	_ arrow.Array       = (*StringView)(nil)
 	_ Builder           = (*StringBuilder)(nil)
 	_ Builder           = (*LargeStringBuilder)(nil)
+	_ Builder           = (*StringViewBuilder)(nil)
 	_ StringLikeBuilder = (*StringBuilder)(nil)
 	_ StringLikeBuilder = (*LargeStringBuilder)(nil)
+	_ StringLikeBuilder = (*StringViewBuilder)(nil)
 )
diff --git a/go/arrow/array/string_test.go b/go/arrow/array/string_test.go
index d743a3ec7f37f..803fae51347c1 100644
--- a/go/arrow/array/string_test.go
+++ b/go/arrow/array/string_test.go
@@ -619,3 +619,176 @@ func TestStringValueLen(t *testing.T) {
 		assert.Equal(t, len(v), slice.ValueLen(i))
 	}
 }
+func TestStringViewArray(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer mem.AssertSize(t, 0)
+
+	var (
+		// only the last string is long enough to not get inlined
+		want   = []string{"hello", "世界", "", "say goodbye daffy"}
+		valids = []bool{true, true, false, true}
+	)
+
+	sb := array.NewStringViewBuilder(mem)
+	defer sb.Release()
+
+	sb.Retain()
+	sb.Release()
+
+	assert.NoError(t, sb.AppendValueFromString(want[0]))
+	sb.AppendValues(want[1:2], nil)
+
+	sb.AppendNull()
+	sb.Append(want[3])
+
+	if got, want := sb.Len(), len(want); got != want {
+		t.Fatalf("invalid len: got=%d, want=%d", got, want)
+	}
+
+	if got, want := sb.NullN(), 1; got != want {
+		t.Fatalf("invalid nulls: got=%d, want=%d", got, want)
+	}
+
+	arr := sb.NewStringViewArray()
+	defer arr.Release()
+
+	arr.Retain()
+	arr.Release()
+
+	assert.Equal(t, "hello", arr.ValueStr(0))
+
+	if got, want := arr.Len(), len(want); got != want {
+		t.Fatalf("invalid len: got=%d, want=%d", got, want)
+	}
+
+	if got, want := arr.NullN(), 1; got != want {
+		t.Fatalf("invalid nulls: got=%d, want=%d", got, want)
+	}
+
+	for i := range want {
+		if arr.IsNull(i) != !valids[i] {
+			t.Fatalf("arr[%d]-validity: got=%v want=%v", i, !arr.IsNull(i), valids[i])
+		}
+		switch {
+		case arr.IsNull(i):
+		default:
+			got := arr.Value(i)
+			if got != want[i] {
+				t.Fatalf("arr[%d]: got=%q, want=%q", i, got, want[i])
+			}
+		}
+	}
+
+	sub := array.MakeFromData(arr.Data())
+	defer sub.Release()
+
+	if sub.DataType().ID() != arrow.STRING_VIEW {
+		t.Fatalf("invalid type: got=%q, want=string view", sub.DataType().Name())
+	}
+
+	if _, ok := sub.(*array.StringView); !ok {
+		t.Fatalf("could not type-assert to array.String")
+	}
+
+	if got, want := arr.String(), `["hello" "世界" (null) "say goodbye daffy"]`; got != want {
+		t.Fatalf("got=%q, want=%q", got, want)
+	}
+
+	// only the last string gets stuck into a buffer the rest are inlined
+	// in the headers.
+	if !bytes.Equal([]byte(`say goodbye daffy`), arr.Data().Buffers()[2].Bytes()) {
+		t.Fatalf("got=%q, want=%q", string(arr.Data().Buffers()[2].Bytes()), `say goodbye daffy`)
+	}
+
+	// check the prefix for the non-inlined value
+	if [4]byte{'s', 'a', 'y', ' '} != arr.ValueHeader(3).Prefix() {
+		t.Fatalf("got=%q, want=%q", arr.ValueHeader(3).Prefix(), `say `)
+	}
+
+	slice := array.NewSliceData(arr.Data(), 2, 4)
+	defer slice.Release()
+
+	sub1 := array.MakeFromData(slice)
+	defer sub1.Release()
+
+	v, ok := sub1.(*array.StringView)
+	if !ok {
+		t.Fatalf("could not type-assert to array.StringView")
+	}
+
+	if got, want := v.String(), `[(null) "say goodbye daffy"]`; got != want {
+		t.Fatalf("got=%q, want=%q", got, want)
+	}
+
+	if !bytes.Equal([]byte(`say goodbye daffy`), v.Data().Buffers()[2].Bytes()) {
+		t.Fatalf("got=%q, want=%q", string(v.Data().Buffers()[2].Bytes()), `say goodbye daffy`)
+	}
+
+	// check the prefix for the non-inlined value
+	if [4]byte{'s', 'a', 'y', ' '} != v.ValueHeader(1).Prefix() {
+		t.Fatalf("got=%q, want=%q", v.ValueHeader(1).Prefix(), `say `)
+	}
+}
+
+func TestStringViewBuilder_Empty(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	defer mem.AssertSize(t, 0)
+
+	want := []string{"hello", "世界", "", "say goodbye daffy"}
+
+	ab := array.NewStringViewBuilder(mem)
+	defer ab.Release()
+
+	stringValues := func(a *array.StringView) []string {
+		vs := make([]string, a.Len())
+		for i := range vs {
+			vs[i] = a.Value(i)
+		}
+		return vs
+	}
+
+	ab.AppendValues([]string{}, nil)
+	a := ab.NewStringViewArray()
+	assert.Zero(t, a.Len())
+	a.Release()
+
+	ab.AppendValues(nil, nil)
+	a = ab.NewStringViewArray()
+	assert.Zero(t, a.Len())
+	a.Release()
+
+	ab.AppendValues([]string{}, nil)
+	ab.AppendValues(want, nil)
+	a = ab.NewStringViewArray()
+	assert.Equal(t, want, stringValues(a))
+	a.Release()
+
+	ab.AppendValues(want, nil)
+	ab.AppendValues([]string{}, nil)
+	a = ab.NewStringViewArray()
+	assert.Equal(t, want, stringValues(a))
+	a.Release()
+}
+
+// TestStringReset tests the Reset() method on the String type by creating two different Strings and then
+// reseting the contents of string2 with the values from string1.
+func TestStringViewReset(t *testing.T) {
+	mem := memory.NewCheckedAllocator(memory.NewGoAllocator())
+	sb1 := array.NewStringViewBuilder(mem)
+	sb2 := array.NewStringViewBuilder(mem)
+	defer sb1.Release()
+	defer sb2.Release()
+
+	sb1.Append("string1")
+	sb1.AppendNull()
+
+	var (
+		string1 = sb1.NewStringViewArray()
+		string2 = sb2.NewStringViewArray()
+
+		string1Data = string1.Data()
+	)
+	string2.Reset(string1Data)
+
+	assert.Equal(t, "string1", string2.Value(0))
+}
diff --git a/go/arrow/compute/executor.go b/go/arrow/compute/executor.go
index 1cba0b1e19f69..db89b206daf5f 100644
--- a/go/arrow/compute/executor.go
+++ b/go/arrow/compute/executor.go
@@ -171,6 +171,8 @@ func addComputeDataPrealloc(dt arrow.DataType, widths []bufferPrealloc) []buffer
 		return append(widths, bufferPrealloc{bitWidth: 32, addLen: 1})
 	case arrow.LARGE_BINARY, arrow.LARGE_STRING, arrow.LARGE_LIST:
 		return append(widths, bufferPrealloc{bitWidth: 64, addLen: 1})
+	case arrow.STRING_VIEW, arrow.BINARY_VIEW:
+		return append(widths, bufferPrealloc{bitWidth: arrow.ViewHeaderSizeBytes * 8})
 	}
 	return widths
 }
@@ -1007,9 +1009,10 @@ func (v *vectorExecutor) WrapResults(ctx context.Context, out <-chan Datum, hasC
 	case <-ctx.Done():
 		return nil
 	case output = <-out:
-		if output == nil {
+		if output == nil || ctx.Err() != nil {
 			return nil
 		}
+
 		// if the inputs contained at least one chunked array
 		// then we want to return chunked output
 		if hasChunked {
diff --git a/go/arrow/datatype.go b/go/arrow/datatype.go
index 24113b55899dc..1e5d8fb98aa59 100644
--- a/go/arrow/datatype.go
+++ b/go/arrow/datatype.go
@@ -210,6 +210,11 @@ type BinaryDataType interface {
 	binary()
 }
 
+type BinaryViewDataType interface {
+	BinaryDataType
+	view()
+}
+
 type OffsetsDataType interface {
 	DataType
 	OffsetTypeTraits() OffsetTraits
@@ -272,6 +277,8 @@ func (b BufferSpec) Equals(other BufferSpec) bool {
 type DataTypeLayout struct {
 	Buffers []BufferSpec
 	HasDict bool
+	// VariadicSpec is what the buffers beyond len(Buffers) are expected to conform to.
+	VariadicSpec *BufferSpec
 }
 
 func SpecFixedWidth(w int) BufferSpec { return BufferSpec{KindFixedWidth, w} }
diff --git a/go/arrow/datatype_binary.go b/go/arrow/datatype_binary.go
index a3a8568645052..f3e601f08ec79 100644
--- a/go/arrow/datatype_binary.go
+++ b/go/arrow/datatype_binary.go
@@ -83,16 +83,57 @@ func (t *LargeStringType) Layout() DataTypeLayout {
 func (t *LargeStringType) OffsetTypeTraits() OffsetTraits { return Int64Traits }
 func (LargeStringType) IsUtf8() bool                      { return true }
 
+type BinaryViewType struct{}
+
+func (*BinaryViewType) ID() Type              { return BINARY_VIEW }
+func (*BinaryViewType) Name() string          { return "binary_view" }
+func (*BinaryViewType) String() string        { return "binary_view" }
+func (*BinaryViewType) IsUtf8() bool          { return false }
+func (*BinaryViewType) binary()               {}
+func (*BinaryViewType) view()                 {}
+func (t *BinaryViewType) Fingerprint() string { return typeFingerprint(t) }
+func (*BinaryViewType) Layout() DataTypeLayout {
+	variadic := SpecVariableWidth()
+	return DataTypeLayout{
+		Buffers:      []BufferSpec{SpecBitmap(), SpecFixedWidth(ViewHeaderSizeBytes)},
+		VariadicSpec: &variadic,
+	}
+}
+
+type StringViewType struct{}
+
+func (*StringViewType) ID() Type              { return STRING_VIEW }
+func (*StringViewType) Name() string          { return "string_view" }
+func (*StringViewType) String() string        { return "string_view" }
+func (*StringViewType) IsUtf8() bool          { return true }
+func (*StringViewType) binary()               {}
+func (*StringViewType) view()                 {}
+func (t *StringViewType) Fingerprint() string { return typeFingerprint(t) }
+func (*StringViewType) Layout() DataTypeLayout {
+	variadic := SpecVariableWidth()
+	return DataTypeLayout{
+		Buffers:      []BufferSpec{SpecBitmap(), SpecFixedWidth(ViewHeaderSizeBytes)},
+		VariadicSpec: &variadic,
+	}
+}
+
 var (
 	BinaryTypes = struct {
 		Binary      BinaryDataType
 		String      BinaryDataType
 		LargeBinary BinaryDataType
 		LargeString BinaryDataType
+		BinaryView  BinaryDataType
+		StringView  BinaryDataType
 	}{
 		Binary:      &BinaryType{},
 		String:      &StringType{},
 		LargeBinary: &LargeBinaryType{},
 		LargeString: &LargeStringType{},
+		BinaryView:  &BinaryViewType{},
+		StringView:  &StringViewType{},
 	}
+
+	_ BinaryViewDataType = (*StringViewType)(nil)
+	_ BinaryViewDataType = (*BinaryViewType)(nil)
 )
diff --git a/go/arrow/datatype_binary_test.go b/go/arrow/datatype_binary_test.go
index 25ba6e8db4ba4..083d69ee3e5d4 100644
--- a/go/arrow/datatype_binary_test.go
+++ b/go/arrow/datatype_binary_test.go
@@ -81,3 +81,33 @@ func TestLargeStringType(t *testing.T) {
 		t.Fatalf("invalid string type stringer. got=%v, want=%v", got, want)
 	}
 }
+
+func TestBinaryViewType(t *testing.T) {
+	var nt *arrow.BinaryViewType
+	if got, want := nt.ID(), arrow.BINARY_VIEW; got != want {
+		t.Fatalf("invalid string type id. got=%v, want=%v", got, want)
+	}
+
+	if got, want := nt.Name(), "binary_view"; got != want {
+		t.Fatalf("invalid string type name. got=%v, want=%v", got, want)
+	}
+
+	if got, want := nt.String(), "binary_view"; got != want {
+		t.Fatalf("invalid string type stringer. got=%v, want=%v", got, want)
+	}
+}
+
+func TestStringViewType(t *testing.T) {
+	var nt *arrow.StringViewType
+	if got, want := nt.ID(), arrow.STRING_VIEW; got != want {
+		t.Fatalf("invalid string type id. got=%v, want=%v", got, want)
+	}
+
+	if got, want := nt.Name(), "string_view"; got != want {
+		t.Fatalf("invalid string type name. got=%v, want=%v", got, want)
+	}
+
+	if got, want := nt.String(), "string_view"; got != want {
+		t.Fatalf("invalid string type stringer. got=%v, want=%v", got, want)
+	}
+}
diff --git a/go/arrow/datatype_viewheader.go b/go/arrow/datatype_viewheader.go
new file mode 100644
index 0000000000000..54b9256b34604
--- /dev/null
+++ b/go/arrow/datatype_viewheader.go
@@ -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.
+
+package arrow
+
+import (
+	"bytes"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v15/arrow/endian"
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+	"github.com/apache/arrow/go/v15/arrow/memory"
+)
+
+const (
+	ViewPrefixLen  = 4
+	viewInlineSize = 12
+)
+
+func IsViewInline(length int) bool {
+	return length < viewInlineSize
+}
+
+// ViewHeader is a variable length string (utf8) or byte slice with
+// a 4 byte prefix and inline optimization for small values (12 bytes
+// or fewer). This is similar to Go's standard string but limited by
+// a length of Uint32Max and up to the first four bytes of the string
+// are copied into the struct. This prefix allows failing comparisons
+// early and can reduce CPU cache working set when dealing with short
+// strings.
+//
+// There are two situations:
+//
+//		Entirely inlined string data
+//	                |----|------------|
+//		                ^    ^
+//		                |    |
+//		              size  inline string data, zero padded
+//
+//		Reference into buffer
+//	                |----|----|----|----|
+//		                ^    ^     ^     ^
+//		                |    |     |     |
+//		              size prefix buffer index and offset to out-of-line portion
+//
+// Adapted from TU Munich's UmbraDB [1], Velox, DuckDB.
+//
+// [1]: https://db.in.tum.de/~freitag/papers/p29-neumann-cidr20.pdf
+type ViewHeader struct {
+	size int32
+	// the first 4 bytes of this are the prefix for the string
+	// if size <= StringHeaderInlineSize, then the entire string
+	// is in the data array and is zero padded.
+	// if size > StringHeaderInlineSize, the next 8 bytes are 2 uint32
+	// values which are the buffer index and offset in that buffer
+	// containing the full string.
+	data [viewInlineSize]byte
+}
+
+func (sh *ViewHeader) IsInline() bool {
+	return sh.size <= int32(viewInlineSize)
+}
+
+func (sh *ViewHeader) Len() int { return int(sh.size) }
+func (sh *ViewHeader) Prefix() [ViewPrefixLen]byte {
+	return *(*[4]byte)(unsafe.Pointer(&sh.data))
+}
+
+func (sh *ViewHeader) BufferIndex() int32 {
+	return int32(endian.Native.Uint32(sh.data[ViewPrefixLen:]))
+}
+
+func (sh *ViewHeader) BufferOffset() int32 {
+	return int32(endian.Native.Uint32(sh.data[ViewPrefixLen+4:]))
+}
+
+func (sh *ViewHeader) InlineBytes() (data []byte) {
+	debug.Assert(sh.IsInline(), "calling InlineBytes on non-inline ViewHeader")
+	return sh.data[:sh.size]
+}
+
+func (sh *ViewHeader) SetBytes(data []byte) int {
+	sh.size = int32(len(data))
+	if sh.IsInline() {
+		return copy(sh.data[:], data)
+	}
+	return copy(sh.data[:4], data)
+}
+
+func (sh *ViewHeader) SetString(data string) int {
+	sh.size = int32(len(data))
+	if sh.IsInline() {
+		return copy(sh.data[:], data)
+	}
+	return copy(sh.data[:4], data)
+}
+
+func (sh *ViewHeader) SetIndexOffset(bufferIndex, offset int32) {
+	endian.Native.PutUint32(sh.data[ViewPrefixLen:], uint32(bufferIndex))
+	endian.Native.PutUint32(sh.data[ViewPrefixLen+4:], uint32(offset))
+}
+
+func (sh *ViewHeader) Equals(buffers []*memory.Buffer, other *ViewHeader, otherBuffers []*memory.Buffer) bool {
+	if sh.sizeAndPrefixAsInt64() != other.sizeAndPrefixAsInt64() {
+		return false
+	}
+
+	if sh.IsInline() {
+		return sh.inlinedAsInt64() == other.inlinedAsInt64()
+	}
+
+	return bytes.Equal(sh.getBufferBytes(buffers), other.getBufferBytes(otherBuffers))
+}
+
+func (sh *ViewHeader) getBufferBytes(buffers []*memory.Buffer) []byte {
+	offset := sh.BufferOffset()
+	return buffers[sh.BufferIndex()].Bytes()[offset : offset+sh.size]
+}
+
+func (sh *ViewHeader) inlinedAsInt64() int64 {
+	s := unsafe.Slice((*int64)(unsafe.Pointer(sh)), 2)
+	return s[1]
+}
+
+func (sh *ViewHeader) sizeAndPrefixAsInt64() int64 {
+	s := unsafe.Slice((*int64)(unsafe.Pointer(sh)), 2)
+	return s[0]
+}
diff --git a/go/arrow/datatype_viewheader_inline.go b/go/arrow/datatype_viewheader_inline.go
new file mode 100644
index 0000000000000..89ac1d06adcdf
--- /dev/null
+++ b/go/arrow/datatype_viewheader_inline.go
@@ -0,0 +1,31 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build go1.20
+
+package arrow
+
+import (
+	"unsafe"
+
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+)
+
+func (sh *ViewHeader) InlineString() (data string) {
+	debug.Assert(sh.IsInline(), "calling InlineString on non-inline ViewHeader")
+
+	return unsafe.String((*byte)(unsafe.Pointer(&sh.data)), sh.size)
+}
diff --git a/go/arrow/datatype_viewheader_inline_go1.19.go b/go/arrow/datatype_viewheader_inline_go1.19.go
new file mode 100644
index 0000000000000..aec66009d9492
--- /dev/null
+++ b/go/arrow/datatype_viewheader_inline_go1.19.go
@@ -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.
+
+//go:build !go1.20 && !tinygo
+
+package arrow
+
+import (
+	"reflect"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+)
+
+func (sh *ViewHeader) InlineString() (data string) {
+	debug.Assert(sh.IsInline(), "calling InlineString on non-inline ViewHeader")
+
+	h := (*reflect.StringHeader)(unsafe.Pointer(&data))
+	h.Data = uintptr(unsafe.Pointer(&sh.data))
+	h.Len = int(sh.size)
+	return
+}
diff --git a/go/arrow/datatype_viewheader_inline_tinygo.go b/go/arrow/datatype_viewheader_inline_tinygo.go
new file mode 100644
index 0000000000000..bff63a273a722
--- /dev/null
+++ b/go/arrow/datatype_viewheader_inline_tinygo.go
@@ -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.
+
+//go:build !go1.20 && tinygo
+
+package arrow
+
+import (
+	"reflect"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v15/arrow/internal/debug"
+)
+
+func (sh *ViewHeader) InlineString() (data string) {
+	debug.Assert(sh.IsInline(), "calling InlineString on non-inline ViewHeader")
+
+	h := (*reflect.StringHeader)(unsafe.Pointer(&data))
+	h.Data = uintptr(unsafe.Pointer(&sh.data))
+	h.Len = uintptr(sh.size)
+	return
+}
diff --git a/go/arrow/internal/arrdata/arrdata.go b/go/arrow/internal/arrdata/arrdata.go
index 6631e4245c19d..985388094eb51 100644
--- a/go/arrow/internal/arrdata/arrdata.go
+++ b/go/arrow/internal/arrdata/arrdata.go
@@ -54,6 +54,7 @@ func init() {
 	Records["extension"] = makeExtensionRecords()
 	Records["union"] = makeUnionRecords()
 	Records["run_end_encoded"] = makeRunEndEncodedRecords()
+	Records["view_types"] = makeStringViewRecords()
 
 	for k := range Records {
 		RecordNames = append(RecordNames, k)
@@ -1155,6 +1156,65 @@ func makeRunEndEncodedRecords() []arrow.Record {
 	return recs
 }
 
+func makeStringViewRecords() []arrow.Record {
+	mem := memory.NewGoAllocator()
+	schema := arrow.NewSchema([]arrow.Field{
+		{Name: "binary_view", Type: arrow.BinaryTypes.BinaryView, Nullable: true},
+		{Name: "string_view", Type: arrow.BinaryTypes.StringView, Nullable: true},
+	}, nil)
+
+	mask := []bool{true, false, false, true, true}
+	chunks := [][]arrow.Array{
+		{
+			viewTypeArrayOf(mem, [][]byte{[]byte("1é"), []byte("2"), []byte("3"), []byte("4"), []byte("5")}, mask),
+			viewTypeArrayOf(mem, []string{"1é", "2", "3", "4", "5"}, mask),
+		},
+		{
+			viewTypeArrayOf(mem, [][]byte{[]byte("1é"), []byte("22222222222222"), []byte("33333333333333"), []byte("4444"), []byte("5555")}, mask),
+			viewTypeArrayOf(mem, []string{"1é", "22222222222222", "33333333333333", "4444", "5555"}, nil),
+		},
+		{
+			viewTypeArrayOf(mem, [][]byte{[]byte("1é1é"), []byte("22222222222222"), []byte("33333333333333"), []byte("44"), []byte("55")}, nil),
+			viewTypeArrayOf(mem, []string{"1é1é", "22222222222222", "33333333333333", "44", "55"}, mask),
+		},
+	}
+
+	defer func() {
+		for _, chunk := range chunks {
+			for _, col := range chunk {
+				col.Release()
+			}
+		}
+	}()
+
+	recs := make([]arrow.Record, len(chunks))
+	for i, chunk := range chunks {
+		recs[i] = array.NewRecord(schema, chunk, -1)
+	}
+
+	return recs
+}
+
+func viewTypeArrayOf(mem memory.Allocator, a interface{}, valids []bool) arrow.Array {
+	if mem == nil {
+		mem = memory.NewGoAllocator()
+	}
+
+	switch a := a.(type) {
+	case []string:
+		bldr := array.NewStringViewBuilder(mem)
+		defer bldr.Release()
+		bldr.AppendValues(a, valids)
+		return bldr.NewArray()
+	case [][]byte:
+		bldr := array.NewBinaryViewBuilder(mem)
+		defer bldr.Release()
+		bldr.AppendValues(a, valids)
+		return bldr.NewArray()
+	}
+	return nil
+}
+
 func extArray(mem memory.Allocator, dt arrow.ExtensionType, a interface{}, valids []bool) arrow.Array {
 	var storage arrow.Array
 	switch st := dt.StorageType().(type) {
@@ -1750,5 +1810,26 @@ func buildArray(bldr array.Builder, data arrow.Array) {
 				bldr.AppendNull()
 			}
 		}
+
+	case *array.BinaryViewBuilder:
+		data := data.(*array.BinaryView)
+		for i := 0; i < data.Len(); i++ {
+			switch {
+			case data.IsValid(i):
+				bldr.Append(data.Value(i))
+			default:
+				bldr.AppendNull()
+			}
+		}
+	case *array.StringViewBuilder:
+		data := data.(*array.StringView)
+		for i := 0; i < data.Len(); i++ {
+			switch {
+			case data.IsValid(i):
+				bldr.Append(data.Value(i))
+			default:
+				bldr.AppendNull()
+			}
+		}
 	}
 }
diff --git a/go/arrow/internal/arrjson/arrjson.go b/go/arrow/internal/arrjson/arrjson.go
index 87bdc1f44d875..f74b615362642 100644
--- a/go/arrow/internal/arrjson/arrjson.go
+++ b/go/arrow/internal/arrjson/arrjson.go
@@ -158,6 +158,10 @@ func typeToJSON(arrowType arrow.DataType) (json.RawMessage, error) {
 		typ = nameJSON{"utf8"}
 	case *arrow.LargeStringType:
 		typ = nameJSON{"largeutf8"}
+	case *arrow.BinaryViewType:
+		typ = nameJSON{"binaryview"}
+	case *arrow.StringViewType:
+		typ = nameJSON{"utf8view"}
 	case *arrow.Date32Type:
 		typ = unitZoneJSON{Name: "date", Unit: "DAY"}
 	case *arrow.Date64Type:
@@ -342,6 +346,10 @@ func typeFromJSON(typ json.RawMessage, children []FieldWrapper) (arrowType arrow
 		arrowType = arrow.BinaryTypes.String
 	case "largeutf8":
 		arrowType = arrow.BinaryTypes.LargeString
+	case "binaryview":
+		arrowType = arrow.BinaryTypes.BinaryView
+	case "utf8view":
+		arrowType = arrow.BinaryTypes.StringView
 	case "date":
 		t := unitZoneJSON{}
 		if err = json.Unmarshal(typ, &t); err != nil {
@@ -818,6 +826,7 @@ type Array struct {
 	Offset   interface{}           `json:"OFFSET,omitempty"`
 	Size     interface{}           `json:"SIZE,omitempty"`
 	Children []Array               `json:"children,omitempty"`
+	Variadic []string              `json:"VARIADIC_BUFFERS,omitempty"`
 }
 
 func (a *Array) MarshalJSON() ([]byte, error) {
@@ -1078,6 +1087,18 @@ func arrayFromJSON(mem memory.Allocator, dt arrow.DataType, arr Array) arrow.Arr
 		bldr.AppendValues(data, valids)
 		return returnNewArrayData(bldr)
 
+	case arrow.BinaryViewDataType:
+		valids := validsToBitmap(validsFromJSON(arr.Valids), mem)
+		nulls := arr.Count - bitutil.CountSetBits(valids.Bytes(), 0, arr.Count)
+		headers := stringHeadersFromJSON(mem, !dt.IsUtf8(), arr.Data)
+		extraBufs := variadicBuffersFromJSON(arr.Variadic)
+		defer valids.Release()
+		defer headers.Release()
+
+		return array.NewData(dt, arr.Count,
+			append([]*memory.Buffer{valids, headers}, extraBufs...),
+			nil, nulls, 0)
+
 	case *arrow.ListType:
 		valids := validsFromJSON(arr.Valids)
 		elems := arrayFromJSON(mem, dt.Elem(), arr.Children[0])
@@ -1486,6 +1507,24 @@ func arrayToJSON(field arrow.Field, arr arrow.Array) Array {
 			Offset: strOffsets,
 		}
 
+	case *array.StringView:
+		variadic := variadicBuffersToJSON(arr.Data().Buffers()[2:])
+		return Array{
+			Name:     field.Name,
+			Count:    arr.Len(),
+			Valids:   validsToJSON(arr),
+			Data:     stringHeadersToJSON(arr, false),
+			Variadic: variadic,
+		}
+	case *array.BinaryView:
+		variadic := variadicBuffersToJSON(arr.Data().Buffers()[2:])
+		return Array{
+			Name:     field.Name,
+			Count:    arr.Len(),
+			Valids:   validsToJSON(arr),
+			Data:     stringHeadersToJSON(arr, true),
+			Variadic: variadic,
+		}
 	case *array.List:
 		o := Array{
 			Name:   field.Name,
@@ -2309,3 +2348,114 @@ func durationToJSON(arr *array.Duration) []interface{} {
 	}
 	return o
 }
+
+func variadicBuffersFromJSON(bufs []string) []*memory.Buffer {
+	out := make([]*memory.Buffer, len(bufs))
+	for i, data := range bufs {
+		rawData, err := hex.DecodeString(data)
+		if err != nil {
+			panic(err)
+		}
+
+		out[i] = memory.NewBufferBytes(rawData)
+	}
+	return out
+}
+
+func variadicBuffersToJSON(bufs []*memory.Buffer) []string {
+	out := make([]string, len(bufs))
+	for i, data := range bufs {
+		out[i] = strings.ToUpper(hex.EncodeToString(data.Bytes()))
+	}
+	return out
+}
+
+func stringHeadersFromJSON(mem memory.Allocator, isBinary bool, data []interface{}) *memory.Buffer {
+	buf := memory.NewResizableBuffer(mem)
+	buf.Resize(arrow.ViewHeaderTraits.BytesRequired(len(data)))
+
+	values := arrow.ViewHeaderTraits.CastFromBytes(buf.Bytes())
+
+	for i, d := range data {
+		switch v := d.(type) {
+		case nil:
+			continue
+		case map[string]interface{}:
+			if inlined, ok := v["INLINED"]; ok {
+				if isBinary {
+					val, err := hex.DecodeString(inlined.(string))
+					if err != nil {
+						panic(fmt.Errorf("could not decode %v: %v", inlined, err))
+					}
+					values[i].SetBytes(val)
+				} else {
+					values[i].SetString(inlined.(string))
+				}
+				continue
+			}
+
+			idx, offset := v["BUFFER_INDEX"].(json.Number), v["OFFSET"].(json.Number)
+			bufIdx, err := idx.Int64()
+			if err != nil {
+				panic(err)
+			}
+
+			bufOffset, err := offset.Int64()
+			if err != nil {
+				panic(err)
+			}
+
+			values[i].SetIndexOffset(int32(bufIdx), int32(bufOffset))
+			prefix, err := hex.DecodeString(v["PREFIX"].(string))
+			if err != nil {
+				panic(err)
+			}
+			sz, err := v["SIZE"].(json.Number).Int64()
+			if err != nil {
+				panic(err)
+			}
+
+			rawData := make([]byte, sz)
+			copy(rawData, prefix)
+			values[i].SetBytes(rawData)
+		}
+	}
+	return buf
+}
+
+func stringHeadersToJSON(arr array.ViewLike, isBinary bool) []interface{} {
+	type StringHeader struct {
+		Size      int     `json:"SIZE"`
+		Prefix    *string `json:"PREFIX,omitempty"`
+		BufferIdx *int    `json:"BUFFER_INDEX,omitempty"`
+		BufferOff *int    `json:"OFFSET,omitempty"`
+		Inlined   *string `json:"INLINED,omitempty"`
+	}
+
+	o := make([]interface{}, arr.Len())
+	for i := range o {
+		hdr := arr.ValueHeader(i)
+		if hdr.IsInline() {
+			data := hdr.InlineString()
+			if isBinary {
+				data = strings.ToUpper(hex.EncodeToString(hdr.InlineBytes()))
+			}
+			o[i] = StringHeader{
+				Size:    hdr.Len(),
+				Inlined: &data,
+			}
+			continue
+		}
+
+		idx, off := int(hdr.BufferIndex()), int(hdr.BufferOffset())
+		prefix := hdr.Prefix()
+		encodedPrefix := strings.ToUpper(hex.EncodeToString(prefix[:]))
+		o[i] = StringHeader{
+			Size:      hdr.Len(),
+			Prefix:    &encodedPrefix,
+			BufferIdx: &idx,
+			BufferOff: &off,
+		}
+	}
+	return o
+}
diff --git a/go/arrow/internal/arrjson/arrjson_test.go b/go/arrow/internal/arrjson/arrjson_test.go
index 7beadee370edb..31f3cb238ec16 100644
--- a/go/arrow/internal/arrjson/arrjson_test.go
+++ b/go/arrow/internal/arrjson/arrjson_test.go
@@ -48,6 +48,7 @@ func TestReadWrite(t *testing.T) {
 	wantJSONs["dictionary"] = makeDictionaryWantJSONs()
 	wantJSONs["union"] = makeUnionWantJSONs()
 	wantJSONs["run_end_encoded"] = makeRunEndEncodedWantJSONs()
+	wantJSONs["view_types"] = makeViewTypesWantJSONs()
 	tempDir := t.TempDir()
 
 	for name, recs := range arrdata.Records {
@@ -6127,3 +6128,261 @@ func makeRunEndEncodedWantJSONs() string {
   ]
 }`
 }
+
+func makeViewTypesWantJSONs() string {
+	return `{
+  "schema": {
+    "fields": [
+      {
+        "name": "binary_view",
+        "type": {
+          "name": "binaryview"
+        },
+        "nullable": true,
+        "children": []
+      },
+      {
+        "name": "string_view",
+        "type": {
+          "name": "utf8view"
+        },
+        "nullable": true,
+        "children": []
+      }
+    ]
+  },
+  "batches": [
+    {
+      "count": 5,
+      "columns": [
+        {
+          "name": "binary_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            0,
+            0,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 3,
+              "INLINED": "31C3A9"
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 1,
+              "INLINED": "34"
+            },
+            {
+              "SIZE": 1,
+              "INLINED": "35"
+            }
+          ],
+          "VARIADIC_BUFFERS": [""]
+        },
+        {
+          "name": "string_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            0,
+            0,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 3,
+              "INLINED": "1é" 
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 1,
+              "INLINED": "4"
+            },
+            {
+              "SIZE": 1,
+              "INLINED": "5"
+            }
+          ],
+          "VARIADIC_BUFFERS": [""]
+        }
+      ]
+    },
+    {
+      "count": 5,
+      "columns": [
+        {
+          "name": "binary_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            0,
+            0,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 3,
+              "INLINED": "31C3A9"
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 4,
+              "INLINED": "34343434"
+            },
+            {
+              "SIZE": 4,
+              "INLINED": "35353535"
+            }
+          ],
+          "VARIADIC_BUFFERS": [""]
+        },
+        {
+          "name": "string_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            1,
+            1,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 3,
+              "INLINED": "1é"              
+            },
+            {
+              "SIZE": 14,
+              "PREFIX": "32323232",
+              "BUFFER_INDEX": 0,
+              "OFFSET": 0
+            },
+            {
+              "SIZE": 14,
+              "PREFIX": "33333333",
+              "BUFFER_INDEX": 0,
+              "OFFSET": 14
+            },
+            {
+              "SIZE": 4,
+              "INLINED": "4444"
+            },
+            {
+              "SIZE": 4,
+              "INLINED": "5555"
+            }
+          ],
+          "VARIADIC_BUFFERS": [
+            "32323232323232323232323232323333333333333333333333333333"
+          ]
+        }
+      ]
+    },
+    {
+      "count": 5,
+      "columns": [
+        {
+          "name": "binary_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            1,
+            1,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 6,
+              "INLINED": "31C3A931C3A9"
+            },
+            {
+              "SIZE": 14,
+              "PREFIX": "32323232",
+              "BUFFER_INDEX": 0,
+              "OFFSET": 0
+            },
+            {
+              "SIZE": 14,
+              "PREFIX": "33333333",
+              "BUFFER_INDEX": 0,
+              "OFFSET": 14
+            },
+            {
+              "SIZE": 2,
+              "INLINED": "3434"
+            },
+            {
+              "SIZE": 2,
+              "INLINED": "3535"
+            }
+          ],
+          "VARIADIC_BUFFERS": [
+            "32323232323232323232323232323333333333333333333333333333"
+          ]
+        },
+        {
+          "name": "string_view",
+          "count": 5,
+          "VALIDITY": [
+            1,
+            0,
+            0,
+            1,
+            1
+          ],
+          "DATA": [
+            {
+              "SIZE": 6,
+              "INLINED": "1é1é"
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 0,
+              "INLINED": ""
+            },
+            {
+              "SIZE": 2,
+              "INLINED": "44"
+            },
+            {
+              "SIZE": 2,
+              "INLINED": "55"
+            }
+          ],
+          "VARIADIC_BUFFERS": [""]
+        }
+      ]
+    }
+  ]
+}`
+}
diff --git a/go/arrow/internal/flatbuf/MetadataVersion.go b/go/arrow/internal/flatbuf/MetadataVersion.go
index 21b234f9c2b21..bb5e99dd588ad 100644
--- a/go/arrow/internal/flatbuf/MetadataVersion.go
+++ b/go/arrow/internal/flatbuf/MetadataVersion.go
@@ -31,7 +31,7 @@ const (
 	MetadataVersionV3 MetadataVersion = 2
 	/// >= 0.8.0 (December 2017). Non-backwards compatible with V3.
 	MetadataVersionV4 MetadataVersion = 3
-	/// >= 1.0.0 (July 2020. Backwards compatible with V4 (V5 readers can read V4
+	/// >= 1.0.0 (July 2020). Backwards compatible with V4 (V5 readers can read V4
 	/// metadata and IPC messages). Implementations are recommended to provide a
 	/// V4 compatibility mode with V5 format changes disabled.
 	///
diff --git a/go/arrow/internal/testing/gen/random_array_gen.go b/go/arrow/internal/testing/gen/random_array_gen.go
index b42273ff93fac..57b417bd2b878 100644
--- a/go/arrow/internal/testing/gen/random_array_gen.go
+++ b/go/arrow/internal/testing/gen/random_array_gen.go
@@ -351,6 +351,40 @@ func (r *RandomArrayGenerator) LargeString(size int64, minLength, maxLength int6
 	return bldr.NewArray()
 }
 
+func (r *RandomArrayGenerator) StringView(size int64, minLength, maxLength int64, nullProb float64) arrow.Array {
+	return r.generateBinaryView(arrow.BinaryTypes.StringView, size, minLength, maxLength, nullProb)
+}
+
+func (r *RandomArrayGenerator) generateBinaryView(dt arrow.DataType, size int64, minLength, maxLength int64, nullProb float64) arrow.Array {
+	lengths := r.Int32(size, int32(minLength), int32(maxLength), nullProb).(*array.Int32)
+	defer lengths.Release()
+
+	bldr := array.NewBuilder(r.mem, dt).(array.StringLikeBuilder)
+	defer bldr.Release()
+
+	r.extra++
+	dist := rand.New(rand.NewSource(r.seed + r.extra))
+
+	buf := make([]byte, 0, maxLength)
+	gen := func(n int32) string {
+		out := buf[:n]
+		for i := range out {
+			out[i] = uint8(dist.Int31n(int32('z')-int32('A')+1) + int32('A'))
+		}
+		return string(out)
+	}
+
+	for i := 0; i < lengths.Len(); i++ {
+		if lengths.IsNull(i) {
+			bldr.AppendNull()
+			continue
+		}
+		bldr.Append(gen(lengths.Value(i)))
+	}
+
+	return bldr.NewArray()
+}
+
 func (r *RandomArrayGenerator) Numeric(dt arrow.Type, size int64, min, max int64, nullprob float64) arrow.Array {
 	switch dt {
 	case arrow.INT8:
diff --git a/go/arrow/ipc/endian_swap.go b/go/arrow/ipc/endian_swap.go
index d2e0948434abc..35ba0e4e764f9 100644
--- a/go/arrow/ipc/endian_swap.go
+++ b/go/arrow/ipc/endian_swap.go
@@ -18,6 +18,7 @@ package ipc
 
 import (
 	"errors"
+	"fmt"
 	"math/bits"
 
 	"github.com/apache/arrow/go/v15/arrow"
@@ -119,7 +120,10 @@ func swapType(dt arrow.DataType, data *array.Data) (err error) {
 		return swapType(dt.IndexType, data)
 	case arrow.FixedWidthDataType:
 		byteSwapBuffer(dt.BitWidth(), data.Buffers()[1])
+	default:
+		err = fmt.Errorf("%w: swapping endianness of %s", arrow.ErrNotImplemented, dt)
 	}
+
 	return
 }
 
diff --git a/go/arrow/ipc/file_reader.go b/go/arrow/ipc/file_reader.go
index 330355d3a60c3..1c7eb31799cfa 100644
--- a/go/arrow/ipc/file_reader.go
+++ b/go/arrow/ipc/file_reader.go
@@ -430,13 +430,18 @@ func (src *ipcSource) fieldMetadata(i int) *flatbuf.FieldNode {
 	return &node
 }
 
+func (src *ipcSource) variadicCount(i int) int64 {
+	return src.meta.VariadicBufferCounts(i)
+}
+
 type arrayLoaderContext struct {
-	src     ipcSource
-	ifield  int
-	ibuffer int
-	max     int
-	memo    *dictutils.Memo
-	version MetadataVersion
+	src       ipcSource
+	ifield    int
+	ibuffer   int
+	ivariadic int
+	max       int
+	memo      *dictutils.Memo
+	version   MetadataVersion
 }
 
 func (ctx *arrayLoaderContext) field() *flatbuf.FieldNode {
@@ -451,6 +456,12 @@ func (ctx *arrayLoaderContext) buffer() *memory.Buffer {
 	return buf
 }
 
+func (ctx *arrayLoaderContext) variadic() int64 {
+	v := ctx.src.variadicCount(ctx.ivariadic)
+	ctx.ivariadic++
+	return v
+}
+
 func (ctx *arrayLoaderContext) loadArray(dt arrow.DataType) arrow.ArrayData {
 	switch dt := dt.(type) {
 	case *arrow.NullType:
@@ -476,6 +487,9 @@ func (ctx *arrayLoaderContext) loadArray(dt arrow.DataType) arrow.ArrayData {
 	case *arrow.BinaryType, *arrow.StringType, *arrow.LargeStringType, *arrow.LargeBinaryType:
 		return ctx.loadBinary(dt)
 
+	case arrow.BinaryViewDataType:
+		return ctx.loadBinaryView(dt)
+
 	case *arrow.FixedSizeBinaryType:
 		return ctx.loadFixedSizeBinary(dt)
 
@@ -582,6 +596,18 @@ func (ctx *arrayLoaderContext) loadBinary(dt arrow.DataType) arrow.ArrayData {
 	return array.NewData(dt, int(field.Length()), buffers, nil, int(field.NullCount()), 0)
 }
 
+func (ctx *arrayLoaderContext) loadBinaryView(dt arrow.DataType) arrow.ArrayData {
+	nVariadicBufs := ctx.variadic()
+	field, buffers := ctx.loadCommon(dt.ID(), 2+int(nVariadicBufs))
+	buffers = append(buffers, ctx.buffer())
+	for i := 0; i < int(nVariadicBufs); i++ {
+		buffers = append(buffers, ctx.buffer())
+	}
+	defer releaseBuffers(buffers)
+
+	return array.NewData(dt, int(field.Length()), buffers, nil, int(field.NullCount()), 0)
+}
+
 func (ctx *arrayLoaderContext) loadFixedSizeBinary(dt *arrow.FixedSizeBinaryType) arrow.ArrayData {
 	field, buffers := ctx.loadCommon(dt.ID(), 2)
 	buffers = append(buffers, ctx.buffer())
diff --git a/go/arrow/ipc/message.go b/go/arrow/ipc/message.go
index 709aa5aa2dba4..5295c5df30137 100644
--- a/go/arrow/ipc/message.go
+++ b/go/arrow/ipc/message.go
@@ -31,11 +31,11 @@ import (
 type MetadataVersion flatbuf.MetadataVersion
 
 const (
-	MetadataV1 = MetadataVersion(flatbuf.MetadataVersionV1) // version for Arrow-0.1.0
-	MetadataV2 = MetadataVersion(flatbuf.MetadataVersionV2) // version for Arrow-0.2.0
-	MetadataV3 = MetadataVersion(flatbuf.MetadataVersionV3) // version for Arrow-0.3.0 to 0.7.1
-	MetadataV4 = MetadataVersion(flatbuf.MetadataVersionV4) // version for >= Arrow-0.8.0
-	MetadataV5 = MetadataVersion(flatbuf.MetadataVersionV5) // version for >= Arrow-1.0.0, backward compatible with v4
+	MetadataV1 = MetadataVersion(flatbuf.MetadataVersionV1) // version for Arrow Format-0.1.0
+	MetadataV2 = MetadataVersion(flatbuf.MetadataVersionV2) // version for Arrow Format-0.2.0
+	MetadataV3 = MetadataVersion(flatbuf.MetadataVersionV3) // version for Arrow Format-0.3.0 to 0.7.1
+	MetadataV4 = MetadataVersion(flatbuf.MetadataVersionV4) // version for >= Arrow Format-0.8.0
+	MetadataV5 = MetadataVersion(flatbuf.MetadataVersionV5) // version for >= Arrow Format-1.0.0, backward compatible with v4
 )
 
 func (m MetadataVersion) String() string {
diff --git a/go/arrow/ipc/metadata.go b/go/arrow/ipc/metadata.go
index bd437834c3d06..54ef58753a173 100644
--- a/go/arrow/ipc/metadata.go
+++ b/go/arrow/ipc/metadata.go
@@ -323,6 +323,16 @@ func (fv *fieldVisitor) visit(field arrow.Field) {
 		flatbuf.LargeUtf8Start(fv.b)
 		fv.offset = flatbuf.LargeUtf8End(fv.b)
 
+	case *arrow.BinaryViewType:
+		fv.dtype = flatbuf.TypeBinaryView
+		flatbuf.BinaryViewStart(fv.b)
+		fv.offset = flatbuf.BinaryViewEnd(fv.b)
+
+	case *arrow.StringViewType:
+		fv.dtype = flatbuf.TypeUtf8View
+		flatbuf.Utf8ViewStart(fv.b)
+		fv.offset = flatbuf.Utf8ViewEnd(fv.b)
+
 	case *arrow.Date32Type:
 		fv.dtype = flatbuf.TypeDate
 		flatbuf.DateStart(fv.b)
@@ -713,6 +723,12 @@ func concreteTypeFromFB(typ flatbuf.Type, data flatbuffers.Table, children []arr
 	case flatbuf.TypeLargeUtf8:
 		return arrow.BinaryTypes.LargeString, nil
 
+	case flatbuf.TypeUtf8View:
+		return arrow.BinaryTypes.StringView, nil
+
+	case flatbuf.TypeBinaryView:
+		return arrow.BinaryTypes.BinaryView, nil
+
 	case flatbuf.TypeBool:
 		return arrow.FixedWidthTypes.Boolean, nil
 
@@ -1168,15 +1184,15 @@ func writeFileFooter(schema *arrow.Schema, dicts, recs []fileBlock, w io.Writer)
 	return err
 }
 
-func writeRecordMessage(mem memory.Allocator, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType) *memory.Buffer {
+func writeRecordMessage(mem memory.Allocator, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType, variadicCounts []int64) *memory.Buffer {
 	b := flatbuffers.NewBuilder(0)
-	recFB := recordToFB(b, size, bodyLength, fields, meta, codec)
+	recFB := recordToFB(b, size, bodyLength, fields, meta, codec, variadicCounts)
 	return writeMessageFB(b, mem, flatbuf.MessageHeaderRecordBatch, recFB, bodyLength)
 }
 
-func writeDictionaryMessage(mem memory.Allocator, id int64, isDelta bool, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType) *memory.Buffer {
+func writeDictionaryMessage(mem memory.Allocator, id int64, isDelta bool, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType, variadicCounts []int64) *memory.Buffer {
 	b := flatbuffers.NewBuilder(0)
-	recFB := recordToFB(b, size, bodyLength, fields, meta, codec)
+	recFB := recordToFB(b, size, bodyLength, fields, meta, codec, variadicCounts)
 
 	flatbuf.DictionaryBatchStart(b)
 	flatbuf.DictionaryBatchAddId(b, id)
@@ -1186,7 +1202,7 @@ func writeDictionaryMessage(mem memory.Allocator, id int64, isDelta bool, size,
 	return writeMessageFB(b, mem, flatbuf.MessageHeaderDictionaryBatch, dictFB, bodyLength)
 }
 
-func recordToFB(b *flatbuffers.Builder, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType) flatbuffers.UOffsetT {
+func recordToFB(b *flatbuffers.Builder, size, bodyLength int64, fields []fieldMetadata, meta []bufferMetadata, codec flatbuf.CompressionType, variadicCounts []int64) flatbuffers.UOffsetT {
 	fieldsFB := writeFieldNodes(b, fields, flatbuf.RecordBatchStartNodesVector)
 	metaFB := writeBuffers(b, meta, flatbuf.RecordBatchStartBuffersVector)
 	var bodyCompressFB flatbuffers.UOffsetT
@@ -1194,10 +1210,24 @@ func recordToFB(b *flatbuffers.Builder, size, bodyLength int64, fields []fieldMe
 		bodyCompressFB = writeBodyCompression(b, codec)
 	}
 
+	var vcFB *flatbuffers.UOffsetT
+	if len(variadicCounts) > 0 {
+		flatbuf.RecordBatchStartVariadicBufferCountsVector(b, len(variadicCounts))
+		for i := len(variadicCounts) - 1; i >= 0; i-- {
+			b.PrependInt64(variadicCounts[i])
+		}
+		vcFBVal := b.EndVector(len(variadicCounts))
+		vcFB = &vcFBVal
+	}
+
 	flatbuf.RecordBatchStart(b)
 	flatbuf.RecordBatchAddLength(b, size)
 	flatbuf.RecordBatchAddNodes(b, fieldsFB)
 	flatbuf.RecordBatchAddBuffers(b, metaFB)
+	if vcFB != nil {
+		flatbuf.RecordBatchAddVariadicBufferCounts(b, *vcFB)
+	}
+
 	if codec != -1 {
 		flatbuf.RecordBatchAddCompression(b, bodyCompressFB)
 	}
diff --git a/go/arrow/ipc/writer.go b/go/arrow/ipc/writer.go
index 58c56d2d16ccf..e9d59f0e35e00 100644
--- a/go/arrow/ipc/writer.go
+++ b/go/arrow/ipc/writer.go
@@ -277,7 +277,7 @@ type dictEncoder struct {
 }
 
 func (d *dictEncoder) encodeMetadata(p *Payload, isDelta bool, id, nrows int64) error {
-	p.meta = writeDictionaryMessage(d.mem, id, isDelta, nrows, p.size, d.fields, d.meta, d.codec)
+	p.meta = writeDictionaryMessage(d.mem, id, isDelta, nrows, p.size, d.fields, d.meta, d.codec, d.variadicCounts)
 	return nil
 }
 
@@ -300,8 +300,9 @@ func (d *dictEncoder) Encode(p *Payload, id int64, isDelta bool, dict arrow.Arra
 type recordEncoder struct {
 	mem memory.Allocator
 
-	fields []fieldMetadata
-	meta   []bufferMetadata
+	fields         []fieldMetadata
+	meta           []bufferMetadata
+	variadicCounts []int64
 
 	depth           int64
 	start           int64
@@ -602,6 +603,33 @@ func (w *recordEncoder) visit(p *Payload, arr arrow.Array) error {
 		p.body = append(p.body, voffsets)
 		p.body = append(p.body, values)
 
+	case arrow.BinaryViewDataType:
+		data := arr.Data()
+		values := data.Buffers()[1]
+		arrLen := int64(arr.Len())
+		typeWidth := int64(arrow.ViewHeaderSizeBytes)
+		minLength := paddedLength(arrLen*typeWidth, kArrowAlignment)
+
+		switch {
+		case needTruncate(int64(data.Offset()), values, minLength):
+			// non-zero offset: slice the buffer
+			offset := data.Offset() * int(typeWidth)
+			// send padding if available
+			len := int(minI64(bitutil.CeilByte64(arrLen*typeWidth), int64(values.Len()-offset)))
+			values = memory.SliceBuffer(values, offset, len)
+		default:
+			if values != nil {
+				values.Retain()
+			}
+		}
+		p.body = append(p.body, values)
+
+		w.variadicCounts = append(w.variadicCounts, int64(len(data.Buffers())-2))
+		for _, b := range data.Buffers()[2:] {
+			b.Retain()
+			p.body = append(p.body, b)
+		}
+
 	case *arrow.StructType:
 		w.depth--
 		arr := arr.(*array.Struct)
@@ -946,7 +974,7 @@ func (w *recordEncoder) Encode(p *Payload, rec arrow.Record) error {
 }
 
 func (w *recordEncoder) encodeMetadata(p *Payload, nrows int64) error {
-	p.meta = writeRecordMessage(w.mem, nrows, p.size, w.fields, w.meta, w.codec)
+	p.meta = writeRecordMessage(w.mem, nrows, p.size, w.fields, w.meta, w.codec, w.variadicCounts)
 	return nil
 }
 
diff --git a/go/arrow/type_traits_view.go b/go/arrow/type_traits_view.go
new file mode 100644
index 0000000000000..c3846db294681
--- /dev/null
+++ b/go/arrow/type_traits_view.go
@@ -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 arrow
+
+import (
+	"reflect"
+	"unsafe"
+
+	"github.com/apache/arrow/go/v15/arrow/endian"
+)
+
+var ViewHeaderTraits viewHeaderTraits
+
+const (
+	ViewHeaderSizeBytes = int(unsafe.Sizeof(ViewHeader{}))
+)
+
+type viewHeaderTraits struct{}
+
+func (viewHeaderTraits) BytesRequired(n int) int { return ViewHeaderSizeBytes * n }
+
+func (viewHeaderTraits) PutValue(b []byte, v ViewHeader) {
+	endian.Native.PutUint32(b, uint32(v.size))
+	copy(b[4:], v.data[:])
+}
+
+func (viewHeaderTraits) CastFromBytes(b []byte) (res []ViewHeader) {
+	h := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+
+	return unsafe.Slice((*ViewHeader)(unsafe.Pointer(h.Data)), cap(b)/ViewHeaderSizeBytes)[:len(b)/ViewHeaderSizeBytes]
+}
+
+func (viewHeaderTraits) CastToBytes(b []ViewHeader) (res []byte) {
+	h := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+
+	return unsafe.Slice((*byte)(unsafe.Pointer(h.Data)), cap(b)*ViewHeaderSizeBytes)[:len(b)*ViewHeaderSizeBytes]
+}
+
+func (viewHeaderTraits) Copy(dst, src []ViewHeader) { copy(dst, src) }

From a886fdaa2d80a2e7f56cf8a3cf94b367443b6e8e Mon Sep 17 00:00:00 2001
From: Dewey Dunnington <dewey@fishandwhistle.net>
Date: Tue, 14 Nov 2023 22:19:48 -0400
Subject: [PATCH 734/749] GH-38715: [R] Fix possible bashism in configure
 script (#38716)

### Rationale for this change

The CRAN incoming check for 14.0.0 is failing with a NOTE about a possible bashism

### What changes are included in this PR?

One `test -a` usage was replaced with `&&`.

### Are these changes tested?

Yes (via crossbow, below)

### Are there any user-facing changes?

No
* Closes: #38715

Authored-by: Dewey Dunnington <dewey@fishandwhistle.net>
Signed-off-by: Dewey Dunnington <dewey@fishandwhistle.net>
---
 r/configure | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/r/configure b/r/configure
index 5a7f0c81a947b..4f09cfdc4419b 100755
--- a/r/configure
+++ b/r/configure
@@ -126,7 +126,7 @@ fi
 # but doing it now allows us to catch it in
 # nixlibs.R and activate S3 and GCS support for the source build.
 
-# macOS ships with libressl. openssl is installable with brew, but it is 
+# macOS ships with libressl. openssl is installable with brew, but it is
 # generally not linked. We can over-ride this and find
 # openssl by setting OPENSSL_ROOT_DIR (which cmake will pick up later in
 # the installation process).
@@ -135,7 +135,7 @@ if [ "${OPENSSL_ROOT_DIR}" = "" ] && brew --prefix openssl >/dev/null 2>&1; then
   export PKG_CONFIG_PATH="${OPENSSL_ROOT_DIR}/lib/pkgconfig${PKG_CONFIG_PATH:+:${PKG_CONFIG_PATH}}"
 fi
 # Look for openssl with pkg-config for non-brew sources(e.g. CRAN) and Linux
-if [ "${OPENSSL_ROOT_DIR}" = "" -a "${PKG_CONFIG_AVAILABLE}" = "true" ]; then
+if [ "${OPENSSL_ROOT_DIR}" = "" ] && [ "${PKG_CONFIG_AVAILABLE}" = "true" ]; then
   if ${PKG_CONFIG} --exists openssl; then
     export OPENSSL_ROOT_DIR="`${PKG_CONFIG} --variable=prefix openssl`"
   fi
@@ -282,7 +282,7 @@ set_pkg_vars () {
     PKG_CFLAGS="$PKG_CFLAGS $ARROW_R_CXXFLAGS"
   fi
 
-  # We use expr because the product version returns more than just 10.13 and we want to 
+  # We use expr because the product version returns more than just 10.13 and we want to
   # match the substring. However, expr always outputs the number of matched characters
   # to stdout, to avoid noise in the log we redirect the output to /dev/null
   if [ "$UNAME" = "Darwin" ] && expr $(sw_vers -productVersion) : '10\.13' >/dev/null 2>&1; then

From e49d8ae15583ceff03237571569099a6ad62be32 Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Wed, 15 Nov 2023 14:17:42 +0900
Subject: [PATCH 735/749] GH-38711: [CI] Rollback aws-cli for preview
 documentation (#38723)

### Rationale for this change

Restored the Runner image to not delete `aws-cli` for the execution of the `preview-docs` command.

### Are these changes tested?

No

### Are there any user-facing changes?

No

* Closes: #38711

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: Sutou Kouhei <kou@clear-code.com>
---
 ci/scripts/util_free_space.sh | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/ci/scripts/util_free_space.sh b/ci/scripts/util_free_space.sh
index 0518869d06993..dd6ba2c4600a9 100755
--- a/ci/scripts/util_free_space.sh
+++ b/ci/scripts/util_free_space.sh
@@ -25,7 +25,6 @@ du -hsc /usr/local/*
 echo "::endgroup::"
 # ~1GB
 sudo rm -rf \
-  /usr/local/aws-cli \
   /usr/local/aws-sam-cil \
   /usr/local/julia* || :
 echo "::group::/usr/local/bin/*"
@@ -34,8 +33,6 @@ echo "::endgroup::"
 # ~1GB (From 1.2GB to 214MB)
 sudo rm -rf \
   /usr/local/bin/aliyun \
-  /usr/local/bin/aws \
-  /usr/local/bin/aws_completer \
   /usr/local/bin/azcopy \
   /usr/local/bin/bicep \
   /usr/local/bin/cmake-gui \

From 5b17b8402e0444f1a9b9ce1fb4dc2b7b92e9aede Mon Sep 17 00:00:00 2001
From: Alenka Frim <AlenkaF@users.noreply.github.com>
Date: Wed, 15 Nov 2023 09:21:22 +0100
Subject: [PATCH 736/749] GH-38712: [Python] Remove dead code in
 _reconstruct_block (#38714)

### Rationale for this change

It seems the object case in `_reconstruct_block` is a dead code and is not needed anymore so therefore could be removed.

### What changes are included in this PR?

Removal of the object case in `_reconstruct_block` code. Was also looking at the `arrow_to_pandas.cc` code to see if there is any dead code present and I couldn't find any.

### Are these changes tested?

The change in this PR should not make any of the existing tests fail.

### Are there any user-facing changes?

There shouldn't be.
* Closes: #38712

Authored-by: AlenkaF <frim.alenka@gmail.com>
Signed-off-by: Joris Van den Bossche <jorisvandenbossche@gmail.com>
---
 python/pyarrow/pandas_compat.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/python/pyarrow/pandas_compat.py b/python/pyarrow/pandas_compat.py
index e232603ba45ac..be29f68a13d5f 100644
--- a/python/pyarrow/pandas_compat.py
+++ b/python/pyarrow/pandas_compat.py
@@ -26,7 +26,6 @@
 from itertools import zip_longest
 import json
 import operator
-import pickle
 import re
 import warnings
 
@@ -721,9 +720,6 @@ def _reconstruct_block(item, columns=None, extension_columns=None):
         block = _int.make_block(block_arr, placement=placement,
                                 klass=_int.DatetimeTZBlock,
                                 dtype=dtype)
-    elif 'object' in item:
-        block = _int.make_block(pickle.loads(block_arr),
-                                placement=placement)
     elif 'py_array' in item:
         # create ExtensionBlock
         arr = item['py_array']

From cc627ee7e35807a98717603d0a2520685919e17c Mon Sep 17 00:00:00 2001
From: Hyunseok Seo <hsseo0501@gmail.com>
Date: Wed, 15 Nov 2023 19:01:43 +0900
Subject: [PATCH 737/749] GH-38599: [Docs] Update Headers (#38696)

### Rationale for this change

Noticed wrong section headings on the web doc and proposing a fix.

### Are these changes tested?

Yes. Built and verified the documentation locally.

<img width="1049" alt="image" src="https://github.com/apache/arrow/assets/6668548/793d6222-2bc5-4f55-ab67-5abe5283add4">

### Are there any user-facing changes?

No.
* Closes: #38599

Authored-by: Hyunseok Seo <hsseo0501@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 docs/source/format/CDeviceDataInterface.rst | 29 ++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/docs/source/format/CDeviceDataInterface.rst b/docs/source/format/CDeviceDataInterface.rst
index b54e6eabe0b2d..a584852df87eb 100644
--- a/docs/source/format/CDeviceDataInterface.rst
+++ b/docs/source/format/CDeviceDataInterface.rst
@@ -277,7 +277,7 @@ has the following fields:
     to access the memory in the buffers.
 
     If an event is provided, then the producer MUST ensure that the exported
-    data is available on the device before the event is triggered. The 
+    data is available on the device before the event is triggered. The
     consumer SHOULD wait on the event before trying to access the exported
     data.
 
@@ -290,7 +290,7 @@ has the following fields:
     As non-CPU development expands, there may be a need to expand this
     structure. In order to do so without potentially breaking ABI changes,
     we reserve 24 bytes at the end of the object. These bytes MUST be zero'd
-    out after initialization by the producer in order to ensure safe 
+    out after initialization by the producer in order to ensure safe
     evolution of the ABI in the future.
 
 .. _c-device-data-interface-event-types:
@@ -300,7 +300,7 @@ Synchronization event types
 
 The table below lists the expected event types for each device type.
 If no event type is supported ("N/A"), then the ``sync_event`` member
-should always be null. 
+should always be null.
 
 Remember that the event *CAN* be null if synchronization is not needed
 to access the data.
@@ -352,7 +352,7 @@ Memory management
 -----------------
 
 First and foremost: Out of everything in this interface, it is *only* the
-data buffers themselves which reside in device memory (i.e. the ``buffers`` 
+data buffers themselves which reside in device memory (i.e. the ``buffers``
 member of the ``ArrowArray`` struct). Everything else should be in CPU
 memory.
 
@@ -408,7 +408,7 @@ see inconsistent data while the other is mutating it.
 Synchronization
 ---------------
 
-If the ``sync_event`` member is non-NULL, the consumer should not attempt 
+If the ``sync_event`` member is non-NULL, the consumer should not attempt
 to access or read the data until they have synchronized on that event. If
 the ``sync_event`` member is NULL, then it MUST be safe to access the data
 without any synchronization necessary on the part of the consumer.
@@ -501,7 +501,6 @@ could be used for any device:
         arr->array.release(&arr->array);
     }
 
-=======================
 Device Stream Interface
 =======================
 
@@ -510,7 +509,7 @@ interface also specifies a higher-level structure for easing communication
 of streaming data within a single process.
 
 Semantics
-=========
+---------
 
 An Arrow C device stream exposes a streaming source of data chunks, each with
 the same schema. Chunks are obtained by calling a blocking pull-style iteration
@@ -520,7 +519,7 @@ to provide a stream of data on multiple device types, a producer should
 provide a separate stream object for each device type.
 
 Structure definition
-====================
+--------------------
 
 The C device stream interface is defined by a single ``struct`` definition:
 
@@ -554,7 +553,7 @@ The C device stream interface is defined by a single ``struct`` definition:
     kept exactly as-is when these definitions are copied.
 
 The ArrowDeviceArrayStream structure
-------------------------------------
+''''''''''''''''''''''''''''''''''''
 
 The ``ArrowDeviceArrayStream`` provides a device type that can access the
 resulting data along with the required callbacks to interact with a
@@ -627,20 +626,20 @@ streaming source of Arrow arrays. It has the following fields:
     handled by the producer, and especially by the release callback.
 
 Result lifetimes
-----------------
+''''''''''''''''
 
 The data returned by the ``get_schema`` and ``get_next`` callbacks must be
 released independantly. Their lifetimes are not tied to that of
 ``ArrowDeviceArrayStream``.
 
 Stream lifetime
----------------
+'''''''''''''''
 
 Lifetime of the C stream is managed using a release callback with similar
 usage as in :ref:`C data interface <c-data-interface-released>`.
 
 Thread safety
--------------
+'''''''''''''
 
 The stream source is not assumed to be thread-safe. Consumers wanting to
 call ``get_next`` from several threads should ensure those calls are
@@ -652,9 +651,9 @@ Interoperability with other interchange formats
 Other interchange APIs, such as the `CUDA Array Interface`_, include
 members to pass the shape and the data types of the data buffers being
 exported. This information is necessary to interpret the raw bytes in the
-device data buffers that are being shared. Rather than store the 
-shape / types of the data alongside the ``ArrowDeviceArray``, users 
-should utilize the existing ``ArrowSchema`` structure to pass any data 
+device data buffers that are being shared. Rather than store the
+shape / types of the data alongside the ``ArrowDeviceArray``, users
+should utilize the existing ``ArrowSchema`` structure to pass any data
 type and shape information.
 
 Updating this specification

From b55d13c16eb25f3264645e53cc03aa1f7d753b25 Mon Sep 17 00:00:00 2001
From: Ben Harkins <60872452+benibus@users.noreply.github.com>
Date: Wed, 15 Nov 2023 06:05:07 -0500
Subject: [PATCH 738/749] GH-36036: [C++][Python][Parquet] Implement Float16
 logical type (#36073)

### Rationale for this change

There is currently an active proposal to support half-float types in Parquet. For more details/discussion, see the links in this PR's accompanying issue.

### What changes are included in this PR?

This PR implements basic support for a `Float16LogicalType` in accordance with the proposed spec. More specifically, this includes:

- Changes to `parquet.thrift` and regenerated `parqet_types` files
- Basic `LogicalType` class definition, method impls, and enums
- Support for specialized comparisons and column statistics

In the interest of scope, this PR does not currently deal with arrow integration and byte split encoding - although we will want both of these features resolved before the proposal is approved.

### Are these changes tested?

Yes (tests are included)

### Are there any user-facing changes?

Yes

* Closes: #36036

Lead-authored-by: benibus <bpharks@gmx.com>
Co-authored-by: Ben Harkins <60872452+benibus@users.noreply.github.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/arrow/CMakeLists.txt                  |    1 +
 cpp/src/arrow/util/CMakeLists.txt             |    1 +
 cpp/src/arrow/util/float16.cc                 |  226 ++
 cpp/src/arrow/util/float16.h                  |  209 ++
 cpp/src/arrow/util/float16_test.cc            |  367 +++
 cpp/src/generated/parquet_types.cpp           | 2267 +++++++++--------
 cpp/src/generated/parquet_types.h             |   45 +-
 .../parquet/arrow/arrow_reader_writer_test.cc |   33 +-
 cpp/src/parquet/arrow/arrow_schema_test.cc    |    7 +-
 cpp/src/parquet/arrow/reader_internal.cc      |   25 +
 cpp/src/parquet/arrow/schema.cc               |    5 +
 cpp/src/parquet/arrow/schema_internal.cc      |    2 +
 cpp/src/parquet/arrow/test_util.h             |   21 +-
 cpp/src/parquet/column_writer.cc              |   30 +
 cpp/src/parquet/page_index_test.cc            |   22 +
 cpp/src/parquet/parquet.thrift                |    2 +
 cpp/src/parquet/schema_test.cc                |   29 +-
 cpp/src/parquet/statistics.cc                 |  179 +-
 cpp/src/parquet/statistics_test.cc            |  355 ++-
 cpp/src/parquet/test_util.cc                  |   10 +
 cpp/src/parquet/test_util.h                   |    4 +
 cpp/src/parquet/types.cc                      |   26 +
 cpp/src/parquet/types.h                       |   13 +
 docs/source/cpp/parquet.rst                   |    2 +
 24 files changed, 2670 insertions(+), 1211 deletions(-)
 create mode 100644 cpp/src/arrow/util/float16.cc
 create mode 100644 cpp/src/arrow/util/float16.h
 create mode 100644 cpp/src/arrow/util/float16_test.cc

diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt
index 101b089ba837f..24e8eefad1523 100644
--- a/cpp/src/arrow/CMakeLists.txt
+++ b/cpp/src/arrow/CMakeLists.txt
@@ -223,6 +223,7 @@ set(ARROW_SRCS
     util/debug.cc
     util/decimal.cc
     util/delimiting.cc
+    util/float16.cc
     util/formatting.cc
     util/future.cc
     util/hashing.cc
diff --git a/cpp/src/arrow/util/CMakeLists.txt b/cpp/src/arrow/util/CMakeLists.txt
index 3dc8eac1abf64..2e9487dcf50c8 100644
--- a/cpp/src/arrow/util/CMakeLists.txt
+++ b/cpp/src/arrow/util/CMakeLists.txt
@@ -48,6 +48,7 @@ add_arrow_test(utility-test
                checked_cast_test.cc
                compression_test.cc
                decimal_test.cc
+               float16_test.cc
                formatting_util_test.cc
                key_value_metadata_test.cc
                hashing_test.cc
diff --git a/cpp/src/arrow/util/float16.cc b/cpp/src/arrow/util/float16.cc
new file mode 100644
index 0000000000000..5c8b3d10ca0cd
--- /dev/null
+++ b/cpp/src/arrow/util/float16.cc
@@ -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.
+
+#include <ostream>
+#include <type_traits>
+
+#include "arrow/util/float16.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow {
+namespace util {
+
+namespace {
+
+// --------------------------------------------------------
+// Binary conversions
+// --------------------------------------------------------
+// These routines are partially adapted from Numpy's C implementation
+//
+// Some useful metrics for conversions between different precisions:
+// |-----------------------------------------|
+// | precision | half    | single  | double  |
+// |-----------------------------------------|
+// | mantissa  | 10 bits | 23 bits | 52 bits |
+// | exponent  | 5 bits  | 8 bits  | 11 bits |
+// | sign      | 1 bit   | 1 bit   | 1 bit   |
+// | exp bias  | 15      | 127     | 1023    |
+// |-----------------------------------------|
+
+template <typename T>
+struct BinaryConverter {
+  static_assert(std::is_same_v<T, uint32_t> || std::is_same_v<T, uint64_t>);
+
+  static constexpr int kNumBits = sizeof(T) * 8;
+  static constexpr int kMantNumBits = (kNumBits == 32) ? 23 : 52;
+  static constexpr int kExpNumBits = kNumBits - kMantNumBits - 1;
+
+  static constexpr int kExpBias = (1 << (kExpNumBits - 1)) - 1;
+
+  static constexpr T kMantMask = (T(1) << kMantNumBits) - 1;
+  static constexpr T kExpMask = ((T(1) << kExpNumBits) - 1) << kMantNumBits;
+  static constexpr T kSignMask = T(1) << (kNumBits - 1);
+
+  static_assert(kMantNumBits + kExpNumBits + 1 == kNumBits);
+  static_assert(kSignMask + kExpMask + kMantMask == ~T(0));
+
+  static uint16_t ToBinary16(T);
+  static T FromBinary16(uint16_t);
+};
+
+// Converts a IEEE binary32/64 into a binary16. Rounds to nearest with ties to zero
+template <typename T>
+uint16_t BinaryConverter<T>::ToBinary16(T f_bits) {
+  // Sign mask for output binary16
+  const uint16_t h_sign = uint16_t((f_bits >> (kNumBits - 16)) & 0x8000);
+
+  // Exponent mask for input binary
+  const T f_exp = f_bits & kExpMask;
+  // Exponents as signed pre-shifted values for convenience. Here, we need to re-bias the
+  // exponent for a binary16. If, after re-biasing, the binary16 exponent falls outside of
+  // the range [1,30] then we need to handle the under/overflow case specially.
+  const int16_t f_biased_exp = int16_t(f_exp >> kMantNumBits);
+  const int16_t unbiased_exp = f_biased_exp - kExpBias;
+  const int16_t h_biased_exp = unbiased_exp + 15;
+
+  // Mantissa mask for input
+  const T f_mant = f_bits & kMantMask;
+
+  // We define a "rounding bit", which is the most significant bit to be dropped
+  // (e.g. for a binary32, 0x1000).
+  constexpr T rounding_bit = T(1) << (kMantNumBits - (10 + 1));
+
+  // Handle exponent overflow, NaN, and +/-Inf
+  if (h_biased_exp >= 0x1f) {
+    // The input is a NaN representation
+    if (f_exp == kExpMask && f_mant != 0) {
+      uint16_t h_mant = uint16_t(f_mant >> (kMantNumBits - 10));
+      // If the mantissa bit(s) indicating NaN were shifted out, add one back. Otherwise,
+      // the result would be infinity.
+      if (h_mant == 0) {
+        h_mant = 0x1;
+      }
+      return uint16_t(h_sign | 0x7c00u | h_mant);
+    }
+
+    // Clamp to +/-infinity
+    return uint16_t(h_sign | 0x7c00u);
+  }
+
+  // Handle exponent underflow, subnormals, and +/-0
+  if (h_biased_exp <= 0) {
+    // If the underflow exceeds the number of bits in a binary16 mantissa (10) then we
+    // can't round, so just clamp to 0. Note that this also weeds out any input values
+    // that are subnormal - including +/-0;
+    if (h_biased_exp < -10) {
+      return h_sign;
+    }
+
+    // Convert to a rounded subnormal value starting with the mantissa. Since the input
+    // input is known to be normal at this point, we need to prepend its implicit leading
+    // bit - which also necessitates an additional right-shift.
+    T rounded_mant = (T(1) << kMantNumBits) | f_mant;
+    rounded_mant >>= (1 - h_biased_exp);
+
+    // Here, we implement rounding to nearest (with ties to even)
+    //
+    // By now, our new mantissa has two conceptual ranges:
+    //  - The lower 13 bits, which will be shifted out
+    //  - The upper 10 bits, which will become the binary16's mantissa
+    //
+    // "Rounding to nearest" basically just means that we add 1 to the rounding bit. If
+    // it's set, then the bit will cascade upwards into the 10-bit mantissa (and
+    // potentially the exponent). The only time where we may NOT do this is when a "tie"
+    // occurs - i.e. when the rounding bit is set but all of the lower bits are 0. In that
+    // case, we don't add 1 if the retained mantissa is "even" (its least significant bit
+    // is 0).
+    if ((rounded_mant & ((rounding_bit << 2) - 1)) != rounding_bit ||
+        (f_mant & 0x7ffu) != 0) {
+      rounded_mant += rounding_bit;
+    }
+
+    const uint16_t h_mant = uint16_t(rounded_mant >> (kMantNumBits - 10));
+    return h_sign + h_mant;
+  }
+
+  const uint16_t h_exp = uint16_t(h_biased_exp) << 10;
+
+  // See comment on rounding behavior above
+  T rounded_mant = f_mant;
+  if ((rounded_mant & ((rounding_bit << 2) - 1)) != rounding_bit) {
+    rounded_mant += rounding_bit;
+  }
+
+  const uint16_t h_mant = uint16_t(rounded_mant >> (kMantNumBits - 10));
+  // Note that we ADD (rather than OR) the components because we want the carryover bit
+  // from rounding the mantissa to cascade through the exponent (it shouldn't affect the
+  // sign bit though).
+  return h_sign + h_exp + h_mant;
+}
+
+// Converts a IEEE binary16 into a binary32/64
+template <typename T>
+T BinaryConverter<T>::FromBinary16(uint16_t h_bits) {
+  // Sign mask for output
+  const T f_sign = T(h_bits & 0x8000u) << (kNumBits - 16);
+
+  // Exponent mask for input binary16
+  const uint16_t h_exp = h_bits & 0x7c00;
+  // Mantissa mask for input binary16
+  const uint16_t h_mant = h_bits & 0x3ffu;
+
+  switch (h_exp) {
+    // Handle Inf and NaN
+    case 0x7c00u:
+      return f_sign | kExpMask | (T(h_mant) << (kMantNumBits - 10));
+    // Handle zeros and subnormals
+    case 0x0000u: {
+      // Input is +/-0
+      if (h_mant == 0) {
+        return f_sign;
+      }
+      // Subnormal binary16 to normal binary32/64
+      //
+      // Start with an f32/64-biased exponent of 2^-15. We then decrement it until the
+      // most significant set bit is left-shifted out - as it doesn't get explicitly
+      // stored in normalized floating point values. Instead, its existence is implied by
+      // the new exponent.
+      T f_exp = kExpBias - 15;
+      T f_mant = T(h_mant) << 1;
+      while ((f_mant & 0x0400u) == 0) {
+        --f_exp;
+        f_mant <<= 1;
+      }
+      f_exp <<= kMantNumBits;
+      f_mant = (f_mant & 0x03ffu) << (kMantNumBits - 10);
+      return f_sign | f_exp | f_mant;
+    } break;
+    // Handle normals
+    default:
+      // Equivalent to rebiasing the exponent and shifting everything by the remaining
+      // mantissa bits.
+      return f_sign |
+             ((T(h_bits & 0x7fffu) + (T(kExpBias - 15) << 10)) << (kMantNumBits - 10));
+  }
+}
+
+}  // namespace
+
+float Float16::ToFloat() const {
+  const uint32_t f_bits = BinaryConverter<uint32_t>::FromBinary16(bits_);
+  return SafeCopy<float>(f_bits);
+}
+
+Float16 Float16::FromFloat(float f) {
+  const uint32_t f_bits = SafeCopy<uint32_t>(f);
+  return FromBits(BinaryConverter<uint32_t>::ToBinary16(f_bits));
+}
+
+double Float16::ToDouble() const {
+  const uint64_t d_bits = BinaryConverter<uint64_t>::FromBinary16(bits_);
+  return SafeCopy<double>(d_bits);
+}
+
+Float16 Float16::FromDouble(double d) {
+  const uint64_t d_bits = SafeCopy<uint64_t>(d);
+  return FromBits(BinaryConverter<uint64_t>::ToBinary16(d_bits));
+}
+
+std::ostream& operator<<(std::ostream& os, Float16 arg) { return (os << arg.ToFloat()); }
+
+}  // namespace util
+}  // namespace arrow
diff --git a/cpp/src/arrow/util/float16.h b/cpp/src/arrow/util/float16.h
new file mode 100644
index 0000000000000..0a432fee2cd31
--- /dev/null
+++ b/cpp/src/arrow/util/float16.h
@@ -0,0 +1,209 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <limits>
+#include <type_traits>
+
+#include "arrow/util/endian.h"
+#include "arrow/util/macros.h"
+#include "arrow/util/ubsan.h"
+#include "arrow/util/visibility.h"
+
+namespace arrow {
+namespace util {
+
+/// \brief Class representing an IEEE half-precision float, encoded as a `uint16_t`
+///
+/// The exact format is as follows (from LSB to MSB):
+/// - bits 0-10:  mantissa
+/// - bits 10-15: exponent
+/// - bit 15:     sign
+///
+class ARROW_EXPORT Float16 {
+ public:
+  Float16() = default;
+  explicit Float16(float f) : Float16(FromFloat(f)) {}
+  explicit Float16(double d) : Float16(FromDouble(d)) {}
+  template <typename T,
+            typename std::enable_if_t<std::is_convertible_v<T, double>>* = NULLPTR>
+  explicit Float16(T v) : Float16(static_cast<double>(v)) {}
+
+  /// \brief Create a `Float16` from its exact binary representation
+  constexpr static Float16 FromBits(uint16_t bits) { return Float16{bits, bool{}}; }
+  /// \brief Create a `Float16` from a 32-bit float (may lose precision)
+  static Float16 FromFloat(float f);
+  /// \brief Create a `Float16` from a 64-bit float (may lose precision)
+  static Float16 FromDouble(double d);
+
+  /// \brief Read a `Float16` from memory in native-endian byte order
+  static Float16 FromBytes(const uint8_t* src) {
+    return FromBits(SafeLoadAs<uint16_t>(src));
+  }
+
+  /// \brief Read a `Float16` from memory in little-endian byte order
+  static Float16 FromLittleEndian(const uint8_t* src) {
+    return FromBits(::arrow::bit_util::FromLittleEndian(SafeLoadAs<uint16_t>(src)));
+  }
+
+  /// \brief Read a `Float16` from memory in big-endian byte order
+  static Float16 FromBigEndian(const uint8_t* src) {
+    return FromBits(::arrow::bit_util::FromBigEndian(SafeLoadAs<uint16_t>(src)));
+  }
+
+  /// \brief Return the value's binary representation as a `uint16_t`
+  constexpr uint16_t bits() const { return bits_; }
+
+  /// \brief Return true if the value is negative (sign bit is set)
+  constexpr bool signbit() const { return (bits_ & 0x8000) != 0; }
+
+  /// \brief Return true if the value is NaN
+  constexpr bool is_nan() const { return (bits_ & 0x7fff) > 0x7c00; }
+  /// \brief Return true if the value is positive/negative infinity
+  constexpr bool is_infinity() const { return (bits_ & 0x7fff) == 0x7c00; }
+  /// \brief Return true if the value is finite and not NaN
+  constexpr bool is_finite() const { return (bits_ & 0x7c00) != 0x7c00; }
+  /// \brief Return true if the value is positive/negative zero
+  constexpr bool is_zero() const { return (bits_ & 0x7fff) == 0; }
+
+  /// \brief Convert to a 32-bit float
+  float ToFloat() const;
+  /// \brief Convert to a 64-bit float
+  double ToDouble() const;
+
+  explicit operator float() const { return ToFloat(); }
+  explicit operator double() const { return ToDouble(); }
+
+  /// \brief Copy the value's bytes in native-endian byte order
+  void ToBytes(uint8_t* dest) const { std::memcpy(dest, &bits_, sizeof(bits_)); }
+  /// \brief Return the value's bytes in native-endian byte order
+  constexpr std::array<uint8_t, 2> ToBytes() const {
+#if ARROW_LITTLE_ENDIAN
+    return ToLittleEndian();
+#else
+    return ToBigEndian();
+#endif
+  }
+
+  /// \brief Copy the value's bytes in little-endian byte order
+  void ToLittleEndian(uint8_t* dest) const {
+    const auto bytes = ToLittleEndian();
+    std::memcpy(dest, bytes.data(), bytes.size());
+  }
+  /// \brief Return the value's bytes in little-endian byte order
+  constexpr std::array<uint8_t, 2> ToLittleEndian() const {
+#if ARROW_LITTLE_ENDIAN
+    return {uint8_t(bits_ & 0xff), uint8_t(bits_ >> 8)};
+#else
+    return {uint8_t(bits_ >> 8), uint8_t(bits_ & 0xff)};
+#endif
+  }
+
+  /// \brief Copy the value's bytes in big-endian byte order
+  void ToBigEndian(uint8_t* dest) const {
+    const auto bytes = ToBigEndian();
+    std::memcpy(dest, bytes.data(), bytes.size());
+  }
+  /// \brief Return the value's bytes in big-endian byte order
+  constexpr std::array<uint8_t, 2> ToBigEndian() const {
+#if ARROW_LITTLE_ENDIAN
+    return {uint8_t(bits_ >> 8), uint8_t(bits_ & 0xff)};
+#else
+    return {uint8_t(bits_ & 0xff), uint8_t(bits_ >> 8)};
+#endif
+  }
+
+  constexpr Float16 operator-() const { return FromBits(bits_ ^ 0x8000); }
+  constexpr Float16 operator+() const { return FromBits(bits_); }
+
+  friend constexpr bool operator==(Float16 lhs, Float16 rhs) {
+    if (lhs.is_nan() || rhs.is_nan()) return false;
+    return Float16::CompareEq(lhs, rhs);
+  }
+  friend constexpr bool operator!=(Float16 lhs, Float16 rhs) { return !(lhs == rhs); }
+
+  friend constexpr bool operator<(Float16 lhs, Float16 rhs) {
+    if (lhs.is_nan() || rhs.is_nan()) return false;
+    return Float16::CompareLt(lhs, rhs);
+  }
+  friend constexpr bool operator>(Float16 lhs, Float16 rhs) { return rhs < lhs; }
+
+  friend constexpr bool operator<=(Float16 lhs, Float16 rhs) {
+    if (lhs.is_nan() || rhs.is_nan()) return false;
+    return !Float16::CompareLt(rhs, lhs);
+  }
+  friend constexpr bool operator>=(Float16 lhs, Float16 rhs) { return rhs <= lhs; }
+
+  ARROW_FRIEND_EXPORT friend std::ostream& operator<<(std::ostream& os, Float16 arg);
+
+ protected:
+  uint16_t bits_;
+
+ private:
+  constexpr Float16(uint16_t bits, bool) : bits_(bits) {}
+
+  // Comparison helpers that assume neither operand is NaN
+  static constexpr bool CompareEq(Float16 lhs, Float16 rhs) {
+    return (lhs.bits() == rhs.bits()) || (lhs.is_zero() && rhs.is_zero());
+  }
+  static constexpr bool CompareLt(Float16 lhs, Float16 rhs) {
+    if (lhs.signbit()) {
+      if (rhs.signbit()) {
+        // Both are negative
+        return lhs.bits() > rhs.bits();
+      } else {
+        // Handle +/-0
+        return !lhs.is_zero() || rhs.bits() != 0;
+      }
+    } else if (rhs.signbit()) {
+      return false;
+    } else {
+      // Both are positive
+      return lhs.bits() < rhs.bits();
+    }
+  }
+};
+
+static_assert(std::is_trivial_v<Float16>);
+
+}  // namespace util
+}  // namespace arrow
+
+// TODO: Not complete
+template <>
+class std::numeric_limits<arrow::util::Float16> {
+  using T = arrow::util::Float16;
+
+ public:
+  static constexpr bool is_specialized = true;
+  static constexpr bool is_signed = true;
+  static constexpr bool has_infinity = true;
+  static constexpr bool has_quiet_NaN = true;
+
+  static constexpr T min() { return T::FromBits(0b0000010000000000); }
+  static constexpr T max() { return T::FromBits(0b0111101111111111); }
+  static constexpr T lowest() { return -max(); }
+
+  static constexpr T infinity() { return T::FromBits(0b0111110000000000); }
+
+  static constexpr T quiet_NaN() { return T::FromBits(0b0111111111111111); }
+};
diff --git a/cpp/src/arrow/util/float16_test.cc b/cpp/src/arrow/util/float16_test.cc
new file mode 100644
index 0000000000000..073375882e3c2
--- /dev/null
+++ b/cpp/src/arrow/util/float16_test.cc
@@ -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.
+
+#include <array>
+#include <cmath>
+#include <utility>
+
+#include <gtest/gtest.h>
+
+#include "arrow/testing/gtest_util.h"
+#include "arrow/util/endian.h"
+#include "arrow/util/float16.h"
+#include "arrow/util/span.h"
+#include "arrow/util/ubsan.h"
+
+namespace arrow::util {
+namespace {
+
+template <typename T>
+using Limits = std::numeric_limits<T>;
+
+float F32(uint32_t bits) { return SafeCopy<float>(bits); }
+double F64(uint64_t bits) { return SafeCopy<double>(bits); }
+
+template <typename T>
+class Float16ConversionTest : public ::testing::Test {
+ public:
+  struct RoundTripTestCase {
+    T input;
+    uint16_t bits;
+    T output;
+  };
+
+  static void TestRoundTrip(span<const RoundTripTestCase> test_cases) {
+    for (size_t index = 0; index < test_cases.size(); ++index) {
+      ARROW_SCOPED_TRACE("i=", index);
+      const auto& tc = test_cases[index];
+
+      const auto f16 = Float16(tc.input);
+      EXPECT_EQ(tc.bits, f16.bits());
+      EXPECT_EQ(tc.output, static_cast<T>(f16));
+
+      EXPECT_EQ(std::signbit(tc.output), f16.signbit());
+      EXPECT_EQ(std::isnan(tc.output), f16.is_nan());
+      EXPECT_EQ(std::isinf(tc.output), f16.is_infinity());
+      EXPECT_EQ(std::isfinite(tc.output), f16.is_finite());
+    }
+  }
+
+  static void TestRoundTripFromNaN(span<const T> test_cases) {
+    for (size_t i = 0; i < test_cases.size(); ++i) {
+      ARROW_SCOPED_TRACE("i=", i);
+      const auto input = test_cases[i];
+
+      ASSERT_TRUE(std::isnan(input));
+      const bool sign = std::signbit(input);
+
+      const auto f16 = Float16(input);
+      EXPECT_TRUE(f16.is_nan());
+      EXPECT_EQ(std::isinf(input), f16.is_infinity());
+      EXPECT_EQ(std::isfinite(input), f16.is_finite());
+      EXPECT_EQ(sign, f16.signbit());
+
+      const auto output = static_cast<T>(f16);
+      EXPECT_TRUE(std::isnan(output));
+      EXPECT_EQ(sign, std::signbit(output));
+    }
+  }
+
+  void TestRoundTripFromInf() {
+    const T test_cases[] = {+Limits<T>::infinity(), -Limits<T>::infinity()};
+
+    for (size_t i = 0; i < std::size(test_cases); ++i) {
+      ARROW_SCOPED_TRACE("i=", i);
+      const auto input = test_cases[i];
+
+      ASSERT_TRUE(std::isinf(input));
+      const bool sign = std::signbit(input);
+
+      const auto f16 = Float16(input);
+      EXPECT_TRUE(f16.is_infinity());
+      EXPECT_EQ(std::isfinite(input), f16.is_finite());
+      EXPECT_EQ(std::isnan(input), f16.is_nan());
+      EXPECT_EQ(sign, f16.signbit());
+
+      const auto output = static_cast<T>(f16);
+      EXPECT_TRUE(std::isinf(output));
+      EXPECT_EQ(sign, std::signbit(output));
+    }
+  }
+
+  void TestRoundTrip();
+  void TestRoundTripFromNaN();
+};
+
+template <>
+void Float16ConversionTest<float>::TestRoundTrip() {
+  // Expected values were also manually validated with numpy-1.24.3
+  const RoundTripTestCase test_cases[] = {
+      // +/-0.0f
+      {F32(0x80000000u), 0b1000000000000000u, -0.0f},
+      {F32(0x00000000u), 0b0000000000000000u, +0.0f},
+      // 32-bit exp is 102 => 2^-25. Rounding to nearest.
+      {F32(0xb3000001u), 0b1000000000000001u, -5.96046447754e-8f},
+      // 32-bit exp is 102 => 2^-25. Rounding to even.
+      {F32(0xb3000000u), 0b1000000000000000u, -0.0f},
+      // 32-bit exp is 101 => 2^-26. Underflow to zero.
+      {F32(0xb2800001u), 0b1000000000000000u, -0.0f},
+      // 32-bit exp is 108 => 2^-19.
+      {F32(0xb61a0000u), 0b1000000000100110u, -2.26497650146e-6f},
+      // 32-bit exp is 108 => 2^-19.
+      {F32(0xb61e0000u), 0b1000000000101000u, -2.38418579102e-6f},
+      // 32-bit exp is 112 => 2^-15. Rounding to nearest.
+      {F32(0xb87fa001u), 0b1000001111111111u, -6.09755516052e-5f},
+      // 32-bit exp is 112 => 2^-15. Rounds to 16-bit exp of 1 => 2^-14
+      {F32(0xb87fe001u), 0b1000010000000000u, -6.103515625e-5f},
+      // 32-bit exp is 142 => 2^15. Rounding to nearest.
+      {F32(0xc7001001u), 0b1111100000000001u, -32800.0f},
+      // 32-bit exp is 142 => 2^15. Rounding to even.
+      {F32(0xc7001000u), 0b1111100000000000u, -32768.0f},
+      // 65520.0f rounds to inf
+      {F32(0x477ff000u), 0b0111110000000000u, Limits<float>::infinity()},
+      // 65488.0039062f rounds to 65504.0 (float16 max)
+      {F32(0x477fd001u), 0b0111101111111111u, 65504.0f},
+      // 32-bit exp is 127 => 2^0, rounds to 16-bit exp of 16 => 2^1.
+      {F32(0xbffff000u), 0b1100000000000000u, -2.0f},
+      // Extreme values should safely clamp to +/-inf
+      {Limits<float>::max(), 0b0111110000000000u, +Limits<float>::infinity()},
+      {Limits<float>::lowest(), 0b1111110000000000u, -Limits<float>::infinity()},
+  };
+
+  TestRoundTrip(span(test_cases, std::size(test_cases)));
+}
+
+template <>
+void Float16ConversionTest<double>::TestRoundTrip() {
+  // Expected values were also manually validated with numpy-1.24.3
+  const RoundTripTestCase test_cases[] = {
+      // +/-0.0
+      {F64(0x8000000000000000u), 0b1000000000000000u, -0.0},
+      {F64(0x0000000000000000u), 0b0000000000000000u, +0.0},
+      // 64-bit exp is 998 => 2^-25. Rounding to nearest.
+      {F64(0xbe60000000000001u), 0b1000000000000001u, -5.9604644775390625e-8},
+      // 64-bit exp is 998 => 2^-25. Rounding to even.
+      {F64(0xbe60000000000000u), 0b1000000000000000u, -0.0},
+      // 64-bit exp is 997 => 2^-26. Underflow to zero.
+      {F64(0xbe50000000000001u), 0b1000000000000000u, -0.0},
+      // 64-bit exp is 1004 => 2^-19.
+      {F64(0xbec3400000000000u), 0b1000000000100110u, -2.2649765014648438e-6},
+      // 64-bit exp is 1004 => 2^-19.
+      {F64(0xbec3c00000000000u), 0b1000000000101000u, -2.3841857910156250e-6},
+      // 64-bit exp is 1008 => 2^-15. Rounding to nearest.
+      {F64(0xbf0ff40000000001u), 0b1000001111111111u, -6.0975551605224609e-5},
+      // 64-bit exp is 1008 => 2^-15. Rounds to 16-bit exp of 1 => 2^-14
+      {F64(0xbf0ffc0000000001u), 0b1000010000000000u, -6.1035156250000000e-5},
+      // 64-bit exp is 1038 => 2^15. Rounding to nearest.
+      {F64(0xc0e0020000000001u), 0b1111100000000001u, -32800.0},
+      // 64-bit exp is 1038 => 2^15. Rounding to even.
+      {F64(0xc0e0020000000000u), 0b1111100000000000u, -32768.0},
+      // 65520.0 rounds to inf
+      {F64(0x40effe0000000000u), 0b0111110000000000u, Limits<double>::infinity()},
+      // 65488.00000000001 rounds to 65504.0 (float16 max)
+      {F64(0x40effa0000000001u), 0b0111101111111111u, 65504.0},
+      // 64-bit exp is 1023 => 2^0, rounds to 16-bit exp of 16 => 2^1.
+      {F64(0xbffffe0000000000u), 0b1100000000000000u, -2.0},
+      // Extreme values should safely clamp to +/-inf
+      {Limits<double>::max(), 0b0111110000000000u, +Limits<double>::infinity()},
+      {Limits<double>::lowest(), 0b1111110000000000u, -Limits<double>::infinity()},
+  };
+
+  TestRoundTrip(span(test_cases, std::size(test_cases)));
+}
+
+template <>
+void Float16ConversionTest<float>::TestRoundTripFromNaN() {
+  const float test_cases[] = {
+      Limits<float>::quiet_NaN(), F32(0x7f800001u), F32(0xff800001u), F32(0x7fc00000u),
+      F32(0xffc00000u),           F32(0x7fffffffu), F32(0xffffffffu)};
+  TestRoundTripFromNaN(span(test_cases, std::size(test_cases)));
+}
+
+template <>
+void Float16ConversionTest<double>::TestRoundTripFromNaN() {
+  const double test_cases[] = {Limits<double>::quiet_NaN(), F64(0x7ff0000000000001u),
+                               F64(0xfff0000000000001u),    F64(0x7ff8000000000000u),
+                               F64(0xfff8000000000000u),    F64(0x7fffffffffffffffu),
+                               F64(0xffffffffffffffffu)};
+  TestRoundTripFromNaN(span(test_cases, std::size(test_cases)));
+}
+
+using NativeFloatTypes = ::testing::Types<float, double>;
+
+TYPED_TEST_SUITE(Float16ConversionTest, NativeFloatTypes);
+
+TYPED_TEST(Float16ConversionTest, RoundTrip) { this->TestRoundTrip(); }
+TYPED_TEST(Float16ConversionTest, RoundTripFromNaN) { this->TestRoundTripFromNaN(); }
+TYPED_TEST(Float16ConversionTest, RoundTripFromInf) { this->TestRoundTripFromInf(); }
+
+TEST(Float16Test, ConstexprFunctions) {
+  constexpr auto a = Float16::FromBits(0xbc00);  // -1.0
+  constexpr auto b = Float16::FromBits(0x3c00);  // +1.0
+
+  static_assert(a.bits() == 0xbc00);
+  static_assert(a.signbit() == true);
+  static_assert(a.is_nan() == false);
+  static_assert(a.is_infinity() == false);
+  static_assert(a.is_finite() == true);
+  static_assert(a.is_zero() == false);
+
+  static_assert((a == b) == false);
+  static_assert((a != b) == true);
+  static_assert((a < b) == true);
+  static_assert((a > b) == false);
+  static_assert((a <= b) == true);
+  static_assert((a >= b) == false);
+  static_assert(-a == +b);
+
+  constexpr auto v = Float16::FromBits(0xffff);
+  static_assert(v.ToBytes()[0] == 0xff);
+  static_assert(v.ToLittleEndian()[0] == 0xff);
+  static_assert(v.ToBigEndian()[0] == 0xff);
+}
+
+TEST(Float16Test, Constructors) {
+  // Construction from exact bits
+  ASSERT_EQ(1, Float16::FromBits(1).bits());
+  // Construction from floating point (including implicit conversions)
+  int i = 0;
+  for (auto f16 : {Float16(1.0f), Float16(1.0), Float16(1)}) {
+    ARROW_SCOPED_TRACE("i=", i++);
+    ASSERT_EQ(0x3c00, f16.bits());
+  }
+}
+
+TEST(Float16Test, Compare) {
+  constexpr float f32_inf = Limits<float>::infinity();
+  constexpr float f32_nan = Limits<float>::quiet_NaN();
+
+  const struct {
+    Float16 f16;
+    float f32;
+  } test_values[] = {
+      {Limits<Float16>::min(), +6.103515625e-05f},
+      {Limits<Float16>::max(), +65504.0f},
+      {Limits<Float16>::lowest(), -65504.0f},
+      {+Limits<Float16>::infinity(), +f32_inf},
+      {-Limits<Float16>::infinity(), -f32_inf},
+      // Multiple (semantically equivalent) NaN representations
+      {Float16::FromBits(0x7e00), f32_nan},
+      {Float16::FromBits(0xfe00), f32_nan},
+      {Float16::FromBits(0x7fff), f32_nan},
+      {Float16::FromBits(0xffff), f32_nan},
+      // Positive/negative zeros
+      {Float16::FromBits(0x0000), +0.0f},
+      {Float16::FromBits(0x8000), -0.0f},
+      // Miscellaneous values. In general, they're chosen to test the sign/exponent and
+      // exponent/mantissa boundaries
+      {Float16::FromBits(0x101c), +0.00050163269043f},
+      {Float16::FromBits(0x901c), -0.00050163269043f},
+      {Float16::FromBits(0x101d), +0.000502109527588f},
+      {Float16::FromBits(0x901d), -0.000502109527588f},
+      {Float16::FromBits(0x121c), +0.00074577331543f},
+      {Float16::FromBits(0x921c), -0.00074577331543f},
+      {Float16::FromBits(0x141c), +0.00100326538086f},
+      {Float16::FromBits(0x941c), -0.00100326538086f},
+      {Float16::FromBits(0x501c), +32.875f},
+      {Float16::FromBits(0xd01c), -32.875f},
+      // A few subnormals for good measure
+      {Float16::FromBits(0x001c), +1.66893005371e-06f},
+      {Float16::FromBits(0x801c), -1.66893005371e-06f},
+      {Float16::FromBits(0x021c), +3.21865081787e-05f},
+      {Float16::FromBits(0x821c), -3.21865081787e-05f},
+  };
+
+  auto expect_op = [&](std::string op_name, auto op) {
+    ARROW_SCOPED_TRACE(op_name);
+    const auto num_values = static_cast<int>(std::size(test_values));
+
+    // Check all combinations of operands in both directions
+    for (int i = 0; i < num_values; ++i) {
+      for (int j = 0; j < num_values; ++j) {
+        auto [a16, a32] = test_values[i];
+        auto [b16, b32] = test_values[j];
+        ARROW_SCOPED_TRACE("[", i, ",", j, "] = ", a16, ",", b16);
+
+        // Results for float16 and float32 should be the same
+        ASSERT_EQ(op(a16, b16), op(a32, b32));
+      }
+    }
+  };
+
+  // Verify that our "equivalent" 16/32-bit values actually are
+  for (const auto& v : test_values) {
+    if (std::isnan(v.f32)) {
+      ASSERT_TRUE(std::isnan(v.f16.ToFloat()));
+    } else {
+      ASSERT_EQ(v.f32, v.f16.ToFloat());
+    }
+  }
+
+  expect_op("equal", [](auto l, auto r) { return l == r; });
+  expect_op("not_equal", [](auto l, auto r) { return l != r; });
+  expect_op("less", [](auto l, auto r) { return l < r; });
+  expect_op("greater", [](auto l, auto r) { return l > r; });
+  expect_op("less_equal", [](auto l, auto r) { return l <= r; });
+  expect_op("greater_equal", [](auto l, auto r) { return l >= r; });
+}
+
+TEST(Float16Test, ToBytes) {
+  constexpr auto f16 = Float16::FromBits(0xd01c);
+  std::array<uint8_t, 2> bytes;
+  auto load = [&bytes]() { return SafeLoadAs<uint16_t>(bytes.data()); };
+
+  // Test native-endian
+  f16.ToBytes(bytes.data());
+  ASSERT_EQ(load(), 0xd01c);
+  bytes = f16.ToBytes();
+  ASSERT_EQ(load(), 0xd01c);
+
+#if ARROW_LITTLE_ENDIAN
+  constexpr uint16_t expected_le = 0xd01c;
+  constexpr uint16_t expected_be = 0x1cd0;
+#else
+  constexpr uint16_t expected_le = 0x1cd0;
+  constexpr uint16_t expected_be = 0xd01c;
+#endif
+  // Test little-endian
+  f16.ToLittleEndian(bytes.data());
+  ASSERT_EQ(load(), expected_le);
+  bytes = f16.ToLittleEndian();
+  ASSERT_EQ(load(), expected_le);
+  // Test big-endian
+  f16.ToBigEndian(bytes.data());
+  ASSERT_EQ(load(), expected_be);
+  bytes = f16.ToBigEndian();
+  ASSERT_EQ(load(), expected_be);
+}
+
+TEST(Float16Test, FromBytes) {
+  constexpr uint16_t u16 = 0xd01c;
+  const auto* data = reinterpret_cast<const uint8_t*>(&u16);
+  ASSERT_EQ(Float16::FromBytes(data), Float16::FromBits(0xd01c));
+#if ARROW_LITTLE_ENDIAN
+  ASSERT_EQ(Float16::FromLittleEndian(data), Float16::FromBits(0xd01c));
+  ASSERT_EQ(Float16::FromBigEndian(data), Float16::FromBits(0x1cd0));
+#else
+  ASSERT_EQ(Float16::FromLittleEndian(data), Float16(0x1cd0));
+  ASSERT_EQ(Float16::FromBigEndian(data), Float16(0xd01c));
+#endif
+}
+
+}  // namespace
+}  // namespace arrow::util
diff --git a/cpp/src/generated/parquet_types.cpp b/cpp/src/generated/parquet_types.cpp
index f4e378fd3822a..86188581e0c42 100644
--- a/cpp/src/generated/parquet_types.cpp
+++ b/cpp/src/generated/parquet_types.cpp
@@ -1288,6 +1288,81 @@ void DateType::printTo(std::ostream& out) const {
 }
 
 
+Float16Type::~Float16Type() noexcept {
+}
+
+std::ostream& operator<<(std::ostream& out, const Float16Type& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Float16Type::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    xfer += iprot->skip(ftype);
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Float16Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Float16Type");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Float16Type &a, Float16Type &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+Float16Type::Float16Type(const Float16Type& other28) noexcept {
+  (void) other28;
+}
+Float16Type::Float16Type(Float16Type&& other29) noexcept {
+  (void) other29;
+}
+Float16Type& Float16Type::operator=(const Float16Type& other30) noexcept {
+  (void) other30;
+  return *this;
+}
+Float16Type& Float16Type::operator=(Float16Type&& other31) noexcept {
+  (void) other31;
+  return *this;
+}
+void Float16Type::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Float16Type(";
+  out << ")";
+}
+
+
 NullType::~NullType() noexcept {
 }
 
@@ -1342,18 +1417,18 @@ void swap(NullType &a, NullType &b) {
   (void) b;
 }
 
-NullType::NullType(const NullType& other28) noexcept {
-  (void) other28;
+NullType::NullType(const NullType& other32) noexcept {
+  (void) other32;
 }
-NullType::NullType(NullType&& other29) noexcept {
-  (void) other29;
+NullType::NullType(NullType&& other33) noexcept {
+  (void) other33;
 }
-NullType& NullType::operator=(const NullType& other30) noexcept {
-  (void) other30;
+NullType& NullType::operator=(const NullType& other34) noexcept {
+  (void) other34;
   return *this;
 }
-NullType& NullType::operator=(NullType&& other31) noexcept {
-  (void) other31;
+NullType& NullType::operator=(NullType&& other35) noexcept {
+  (void) other35;
   return *this;
 }
 void NullType::printTo(std::ostream& out) const {
@@ -1460,22 +1535,22 @@ void swap(DecimalType &a, DecimalType &b) {
   swap(a.precision, b.precision);
 }
 
-DecimalType::DecimalType(const DecimalType& other32) noexcept {
-  scale = other32.scale;
-  precision = other32.precision;
+DecimalType::DecimalType(const DecimalType& other36) noexcept {
+  scale = other36.scale;
+  precision = other36.precision;
 }
-DecimalType::DecimalType(DecimalType&& other33) noexcept {
-  scale = other33.scale;
-  precision = other33.precision;
+DecimalType::DecimalType(DecimalType&& other37) noexcept {
+  scale = other37.scale;
+  precision = other37.precision;
 }
-DecimalType& DecimalType::operator=(const DecimalType& other34) noexcept {
-  scale = other34.scale;
-  precision = other34.precision;
+DecimalType& DecimalType::operator=(const DecimalType& other38) noexcept {
+  scale = other38.scale;
+  precision = other38.precision;
   return *this;
 }
-DecimalType& DecimalType::operator=(DecimalType&& other35) noexcept {
-  scale = other35.scale;
-  precision = other35.precision;
+DecimalType& DecimalType::operator=(DecimalType&& other39) noexcept {
+  scale = other39.scale;
+  precision = other39.precision;
   return *this;
 }
 void DecimalType::printTo(std::ostream& out) const {
@@ -1541,18 +1616,18 @@ void swap(MilliSeconds &a, MilliSeconds &b) {
   (void) b;
 }
 
-MilliSeconds::MilliSeconds(const MilliSeconds& other36) noexcept {
-  (void) other36;
+MilliSeconds::MilliSeconds(const MilliSeconds& other40) noexcept {
+  (void) other40;
 }
-MilliSeconds::MilliSeconds(MilliSeconds&& other37) noexcept {
-  (void) other37;
+MilliSeconds::MilliSeconds(MilliSeconds&& other41) noexcept {
+  (void) other41;
 }
-MilliSeconds& MilliSeconds::operator=(const MilliSeconds& other38) noexcept {
-  (void) other38;
+MilliSeconds& MilliSeconds::operator=(const MilliSeconds& other42) noexcept {
+  (void) other42;
   return *this;
 }
-MilliSeconds& MilliSeconds::operator=(MilliSeconds&& other39) noexcept {
-  (void) other39;
+MilliSeconds& MilliSeconds::operator=(MilliSeconds&& other43) noexcept {
+  (void) other43;
   return *this;
 }
 void MilliSeconds::printTo(std::ostream& out) const {
@@ -1616,18 +1691,18 @@ void swap(MicroSeconds &a, MicroSeconds &b) {
   (void) b;
 }
 
-MicroSeconds::MicroSeconds(const MicroSeconds& other40) noexcept {
-  (void) other40;
+MicroSeconds::MicroSeconds(const MicroSeconds& other44) noexcept {
+  (void) other44;
 }
-MicroSeconds::MicroSeconds(MicroSeconds&& other41) noexcept {
-  (void) other41;
+MicroSeconds::MicroSeconds(MicroSeconds&& other45) noexcept {
+  (void) other45;
 }
-MicroSeconds& MicroSeconds::operator=(const MicroSeconds& other42) noexcept {
-  (void) other42;
+MicroSeconds& MicroSeconds::operator=(const MicroSeconds& other46) noexcept {
+  (void) other46;
   return *this;
 }
-MicroSeconds& MicroSeconds::operator=(MicroSeconds&& other43) noexcept {
-  (void) other43;
+MicroSeconds& MicroSeconds::operator=(MicroSeconds&& other47) noexcept {
+  (void) other47;
   return *this;
 }
 void MicroSeconds::printTo(std::ostream& out) const {
@@ -1691,18 +1766,18 @@ void swap(NanoSeconds &a, NanoSeconds &b) {
   (void) b;
 }
 
-NanoSeconds::NanoSeconds(const NanoSeconds& other44) noexcept {
-  (void) other44;
+NanoSeconds::NanoSeconds(const NanoSeconds& other48) noexcept {
+  (void) other48;
 }
-NanoSeconds::NanoSeconds(NanoSeconds&& other45) noexcept {
-  (void) other45;
+NanoSeconds::NanoSeconds(NanoSeconds&& other49) noexcept {
+  (void) other49;
 }
-NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other46) noexcept {
-  (void) other46;
+NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other50) noexcept {
+  (void) other50;
   return *this;
 }
-NanoSeconds& NanoSeconds::operator=(NanoSeconds&& other47) noexcept {
-  (void) other47;
+NanoSeconds& NanoSeconds::operator=(NanoSeconds&& other51) noexcept {
+  (void) other51;
   return *this;
 }
 void NanoSeconds::printTo(std::ostream& out) const {
@@ -1827,30 +1902,30 @@ void swap(TimeUnit &a, TimeUnit &b) {
   swap(a.__isset, b.__isset);
 }
 
-TimeUnit::TimeUnit(const TimeUnit& other48) noexcept {
-  MILLIS = other48.MILLIS;
-  MICROS = other48.MICROS;
-  NANOS = other48.NANOS;
-  __isset = other48.__isset;
+TimeUnit::TimeUnit(const TimeUnit& other52) noexcept {
+  MILLIS = other52.MILLIS;
+  MICROS = other52.MICROS;
+  NANOS = other52.NANOS;
+  __isset = other52.__isset;
 }
-TimeUnit::TimeUnit(TimeUnit&& other49) noexcept {
-  MILLIS = std::move(other49.MILLIS);
-  MICROS = std::move(other49.MICROS);
-  NANOS = std::move(other49.NANOS);
-  __isset = other49.__isset;
+TimeUnit::TimeUnit(TimeUnit&& other53) noexcept {
+  MILLIS = std::move(other53.MILLIS);
+  MICROS = std::move(other53.MICROS);
+  NANOS = std::move(other53.NANOS);
+  __isset = other53.__isset;
 }
-TimeUnit& TimeUnit::operator=(const TimeUnit& other50) noexcept {
-  MILLIS = other50.MILLIS;
-  MICROS = other50.MICROS;
-  NANOS = other50.NANOS;
-  __isset = other50.__isset;
+TimeUnit& TimeUnit::operator=(const TimeUnit& other54) noexcept {
+  MILLIS = other54.MILLIS;
+  MICROS = other54.MICROS;
+  NANOS = other54.NANOS;
+  __isset = other54.__isset;
   return *this;
 }
-TimeUnit& TimeUnit::operator=(TimeUnit&& other51) noexcept {
-  MILLIS = std::move(other51.MILLIS);
-  MICROS = std::move(other51.MICROS);
-  NANOS = std::move(other51.NANOS);
-  __isset = other51.__isset;
+TimeUnit& TimeUnit::operator=(TimeUnit&& other55) noexcept {
+  MILLIS = std::move(other55.MILLIS);
+  MICROS = std::move(other55.MICROS);
+  NANOS = std::move(other55.NANOS);
+  __isset = other55.__isset;
   return *this;
 }
 void TimeUnit::printTo(std::ostream& out) const {
@@ -1960,22 +2035,22 @@ void swap(TimestampType &a, TimestampType &b) {
   swap(a.unit, b.unit);
 }
 
-TimestampType::TimestampType(const TimestampType& other52) noexcept {
-  isAdjustedToUTC = other52.isAdjustedToUTC;
-  unit = other52.unit;
+TimestampType::TimestampType(const TimestampType& other56) noexcept {
+  isAdjustedToUTC = other56.isAdjustedToUTC;
+  unit = other56.unit;
 }
-TimestampType::TimestampType(TimestampType&& other53) noexcept {
-  isAdjustedToUTC = other53.isAdjustedToUTC;
-  unit = std::move(other53.unit);
+TimestampType::TimestampType(TimestampType&& other57) noexcept {
+  isAdjustedToUTC = other57.isAdjustedToUTC;
+  unit = std::move(other57.unit);
 }
-TimestampType& TimestampType::operator=(const TimestampType& other54) noexcept {
-  isAdjustedToUTC = other54.isAdjustedToUTC;
-  unit = other54.unit;
+TimestampType& TimestampType::operator=(const TimestampType& other58) noexcept {
+  isAdjustedToUTC = other58.isAdjustedToUTC;
+  unit = other58.unit;
   return *this;
 }
-TimestampType& TimestampType::operator=(TimestampType&& other55) noexcept {
-  isAdjustedToUTC = other55.isAdjustedToUTC;
-  unit = std::move(other55.unit);
+TimestampType& TimestampType::operator=(TimestampType&& other59) noexcept {
+  isAdjustedToUTC = other59.isAdjustedToUTC;
+  unit = std::move(other59.unit);
   return *this;
 }
 void TimestampType::printTo(std::ostream& out) const {
@@ -2084,22 +2159,22 @@ void swap(TimeType &a, TimeType &b) {
   swap(a.unit, b.unit);
 }
 
-TimeType::TimeType(const TimeType& other56) noexcept {
-  isAdjustedToUTC = other56.isAdjustedToUTC;
-  unit = other56.unit;
+TimeType::TimeType(const TimeType& other60) noexcept {
+  isAdjustedToUTC = other60.isAdjustedToUTC;
+  unit = other60.unit;
 }
-TimeType::TimeType(TimeType&& other57) noexcept {
-  isAdjustedToUTC = other57.isAdjustedToUTC;
-  unit = std::move(other57.unit);
+TimeType::TimeType(TimeType&& other61) noexcept {
+  isAdjustedToUTC = other61.isAdjustedToUTC;
+  unit = std::move(other61.unit);
 }
-TimeType& TimeType::operator=(const TimeType& other58) noexcept {
-  isAdjustedToUTC = other58.isAdjustedToUTC;
-  unit = other58.unit;
+TimeType& TimeType::operator=(const TimeType& other62) noexcept {
+  isAdjustedToUTC = other62.isAdjustedToUTC;
+  unit = other62.unit;
   return *this;
 }
-TimeType& TimeType::operator=(TimeType&& other59) noexcept {
-  isAdjustedToUTC = other59.isAdjustedToUTC;
-  unit = std::move(other59.unit);
+TimeType& TimeType::operator=(TimeType&& other63) noexcept {
+  isAdjustedToUTC = other63.isAdjustedToUTC;
+  unit = std::move(other63.unit);
   return *this;
 }
 void TimeType::printTo(std::ostream& out) const {
@@ -2208,22 +2283,22 @@ void swap(IntType &a, IntType &b) {
   swap(a.isSigned, b.isSigned);
 }
 
-IntType::IntType(const IntType& other60) noexcept {
-  bitWidth = other60.bitWidth;
-  isSigned = other60.isSigned;
+IntType::IntType(const IntType& other64) noexcept {
+  bitWidth = other64.bitWidth;
+  isSigned = other64.isSigned;
 }
-IntType::IntType(IntType&& other61) noexcept {
-  bitWidth = other61.bitWidth;
-  isSigned = other61.isSigned;
+IntType::IntType(IntType&& other65) noexcept {
+  bitWidth = other65.bitWidth;
+  isSigned = other65.isSigned;
 }
-IntType& IntType::operator=(const IntType& other62) noexcept {
-  bitWidth = other62.bitWidth;
-  isSigned = other62.isSigned;
+IntType& IntType::operator=(const IntType& other66) noexcept {
+  bitWidth = other66.bitWidth;
+  isSigned = other66.isSigned;
   return *this;
 }
-IntType& IntType::operator=(IntType&& other63) noexcept {
-  bitWidth = other63.bitWidth;
-  isSigned = other63.isSigned;
+IntType& IntType::operator=(IntType&& other67) noexcept {
+  bitWidth = other67.bitWidth;
+  isSigned = other67.isSigned;
   return *this;
 }
 void IntType::printTo(std::ostream& out) const {
@@ -2289,18 +2364,18 @@ void swap(JsonType &a, JsonType &b) {
   (void) b;
 }
 
-JsonType::JsonType(const JsonType& other64) noexcept {
-  (void) other64;
+JsonType::JsonType(const JsonType& other68) noexcept {
+  (void) other68;
 }
-JsonType::JsonType(JsonType&& other65) noexcept {
-  (void) other65;
+JsonType::JsonType(JsonType&& other69) noexcept {
+  (void) other69;
 }
-JsonType& JsonType::operator=(const JsonType& other66) noexcept {
-  (void) other66;
+JsonType& JsonType::operator=(const JsonType& other70) noexcept {
+  (void) other70;
   return *this;
 }
-JsonType& JsonType::operator=(JsonType&& other67) noexcept {
-  (void) other67;
+JsonType& JsonType::operator=(JsonType&& other71) noexcept {
+  (void) other71;
   return *this;
 }
 void JsonType::printTo(std::ostream& out) const {
@@ -2364,18 +2439,18 @@ void swap(BsonType &a, BsonType &b) {
   (void) b;
 }
 
-BsonType::BsonType(const BsonType& other68) noexcept {
-  (void) other68;
+BsonType::BsonType(const BsonType& other72) noexcept {
+  (void) other72;
 }
-BsonType::BsonType(BsonType&& other69) noexcept {
-  (void) other69;
+BsonType::BsonType(BsonType&& other73) noexcept {
+  (void) other73;
 }
-BsonType& BsonType::operator=(const BsonType& other70) noexcept {
-  (void) other70;
+BsonType& BsonType::operator=(const BsonType& other74) noexcept {
+  (void) other74;
   return *this;
 }
-BsonType& BsonType::operator=(BsonType&& other71) noexcept {
-  (void) other71;
+BsonType& BsonType::operator=(BsonType&& other75) noexcept {
+  (void) other75;
   return *this;
 }
 void BsonType::printTo(std::ostream& out) const {
@@ -2453,6 +2528,11 @@ void LogicalType::__set_UUID(const UUIDType& val) {
   this->UUID = val;
 __isset.UUID = true;
 }
+
+void LogicalType::__set_FLOAT16(const Float16Type& val) {
+  this->FLOAT16 = val;
+__isset.FLOAT16 = true;
+}
 std::ostream& operator<<(std::ostream& out, const LogicalType& obj)
 {
   obj.printTo(out);
@@ -2585,6 +2665,14 @@ uint32_t LogicalType::read(::apache::thrift::protocol::TProtocol* iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 15:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->FLOAT16.read(iprot);
+          this->__isset.FLOAT16 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -2667,6 +2755,11 @@ uint32_t LogicalType::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += this->UUID.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.FLOAT16) {
+    xfer += oprot->writeFieldBegin("FLOAT16", ::apache::thrift::protocol::T_STRUCT, 15);
+    xfer += this->FLOAT16.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -2687,73 +2780,78 @@ void swap(LogicalType &a, LogicalType &b) {
   swap(a.JSON, b.JSON);
   swap(a.BSON, b.BSON);
   swap(a.UUID, b.UUID);
+  swap(a.FLOAT16, b.FLOAT16);
   swap(a.__isset, b.__isset);
 }
 
-LogicalType::LogicalType(const LogicalType& other72) noexcept {
-  STRING = other72.STRING;
-  MAP = other72.MAP;
-  LIST = other72.LIST;
-  ENUM = other72.ENUM;
-  DECIMAL = other72.DECIMAL;
-  DATE = other72.DATE;
-  TIME = other72.TIME;
-  TIMESTAMP = other72.TIMESTAMP;
-  INTEGER = other72.INTEGER;
-  UNKNOWN = other72.UNKNOWN;
-  JSON = other72.JSON;
-  BSON = other72.BSON;
-  UUID = other72.UUID;
-  __isset = other72.__isset;
-}
-LogicalType::LogicalType(LogicalType&& other73) noexcept {
-  STRING = std::move(other73.STRING);
-  MAP = std::move(other73.MAP);
-  LIST = std::move(other73.LIST);
-  ENUM = std::move(other73.ENUM);
-  DECIMAL = std::move(other73.DECIMAL);
-  DATE = std::move(other73.DATE);
-  TIME = std::move(other73.TIME);
-  TIMESTAMP = std::move(other73.TIMESTAMP);
-  INTEGER = std::move(other73.INTEGER);
-  UNKNOWN = std::move(other73.UNKNOWN);
-  JSON = std::move(other73.JSON);
-  BSON = std::move(other73.BSON);
-  UUID = std::move(other73.UUID);
-  __isset = other73.__isset;
-}
-LogicalType& LogicalType::operator=(const LogicalType& other74) noexcept {
-  STRING = other74.STRING;
-  MAP = other74.MAP;
-  LIST = other74.LIST;
-  ENUM = other74.ENUM;
-  DECIMAL = other74.DECIMAL;
-  DATE = other74.DATE;
-  TIME = other74.TIME;
-  TIMESTAMP = other74.TIMESTAMP;
-  INTEGER = other74.INTEGER;
-  UNKNOWN = other74.UNKNOWN;
-  JSON = other74.JSON;
-  BSON = other74.BSON;
-  UUID = other74.UUID;
-  __isset = other74.__isset;
+LogicalType::LogicalType(const LogicalType& other76) noexcept {
+  STRING = other76.STRING;
+  MAP = other76.MAP;
+  LIST = other76.LIST;
+  ENUM = other76.ENUM;
+  DECIMAL = other76.DECIMAL;
+  DATE = other76.DATE;
+  TIME = other76.TIME;
+  TIMESTAMP = other76.TIMESTAMP;
+  INTEGER = other76.INTEGER;
+  UNKNOWN = other76.UNKNOWN;
+  JSON = other76.JSON;
+  BSON = other76.BSON;
+  UUID = other76.UUID;
+  FLOAT16 = other76.FLOAT16;
+  __isset = other76.__isset;
+}
+LogicalType::LogicalType(LogicalType&& other77) noexcept {
+  STRING = std::move(other77.STRING);
+  MAP = std::move(other77.MAP);
+  LIST = std::move(other77.LIST);
+  ENUM = std::move(other77.ENUM);
+  DECIMAL = std::move(other77.DECIMAL);
+  DATE = std::move(other77.DATE);
+  TIME = std::move(other77.TIME);
+  TIMESTAMP = std::move(other77.TIMESTAMP);
+  INTEGER = std::move(other77.INTEGER);
+  UNKNOWN = std::move(other77.UNKNOWN);
+  JSON = std::move(other77.JSON);
+  BSON = std::move(other77.BSON);
+  UUID = std::move(other77.UUID);
+  FLOAT16 = std::move(other77.FLOAT16);
+  __isset = other77.__isset;
+}
+LogicalType& LogicalType::operator=(const LogicalType& other78) noexcept {
+  STRING = other78.STRING;
+  MAP = other78.MAP;
+  LIST = other78.LIST;
+  ENUM = other78.ENUM;
+  DECIMAL = other78.DECIMAL;
+  DATE = other78.DATE;
+  TIME = other78.TIME;
+  TIMESTAMP = other78.TIMESTAMP;
+  INTEGER = other78.INTEGER;
+  UNKNOWN = other78.UNKNOWN;
+  JSON = other78.JSON;
+  BSON = other78.BSON;
+  UUID = other78.UUID;
+  FLOAT16 = other78.FLOAT16;
+  __isset = other78.__isset;
   return *this;
 }
-LogicalType& LogicalType::operator=(LogicalType&& other75) noexcept {
-  STRING = std::move(other75.STRING);
-  MAP = std::move(other75.MAP);
-  LIST = std::move(other75.LIST);
-  ENUM = std::move(other75.ENUM);
-  DECIMAL = std::move(other75.DECIMAL);
-  DATE = std::move(other75.DATE);
-  TIME = std::move(other75.TIME);
-  TIMESTAMP = std::move(other75.TIMESTAMP);
-  INTEGER = std::move(other75.INTEGER);
-  UNKNOWN = std::move(other75.UNKNOWN);
-  JSON = std::move(other75.JSON);
-  BSON = std::move(other75.BSON);
-  UUID = std::move(other75.UUID);
-  __isset = other75.__isset;
+LogicalType& LogicalType::operator=(LogicalType&& other79) noexcept {
+  STRING = std::move(other79.STRING);
+  MAP = std::move(other79.MAP);
+  LIST = std::move(other79.LIST);
+  ENUM = std::move(other79.ENUM);
+  DECIMAL = std::move(other79.DECIMAL);
+  DATE = std::move(other79.DATE);
+  TIME = std::move(other79.TIME);
+  TIMESTAMP = std::move(other79.TIMESTAMP);
+  INTEGER = std::move(other79.INTEGER);
+  UNKNOWN = std::move(other79.UNKNOWN);
+  JSON = std::move(other79.JSON);
+  BSON = std::move(other79.BSON);
+  UUID = std::move(other79.UUID);
+  FLOAT16 = std::move(other79.FLOAT16);
+  __isset = other79.__isset;
   return *this;
 }
 void LogicalType::printTo(std::ostream& out) const {
@@ -2772,6 +2870,7 @@ void LogicalType::printTo(std::ostream& out) const {
   out << ", " << "JSON="; (__isset.JSON ? (out << to_string(JSON)) : (out << "<null>"));
   out << ", " << "BSON="; (__isset.BSON ? (out << to_string(BSON)) : (out << "<null>"));
   out << ", " << "UUID="; (__isset.UUID ? (out << to_string(UUID)) : (out << "<null>"));
+  out << ", " << "FLOAT16="; (__isset.FLOAT16 ? (out << to_string(FLOAT16)) : (out << "<null>"));
   out << ")";
 }
 
@@ -2859,9 +2958,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast76;
-          xfer += iprot->readI32(ecast76);
-          this->type = static_cast<Type::type>(ecast76);
+          int32_t ecast80;
+          xfer += iprot->readI32(ecast80);
+          this->type = static_cast<Type::type>(ecast80);
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2877,9 +2976,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast77;
-          xfer += iprot->readI32(ecast77);
-          this->repetition_type = static_cast<FieldRepetitionType::type>(ecast77);
+          int32_t ecast81;
+          xfer += iprot->readI32(ecast81);
+          this->repetition_type = static_cast<FieldRepetitionType::type>(ecast81);
           this->__isset.repetition_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2903,9 +3002,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast78;
-          xfer += iprot->readI32(ecast78);
-          this->converted_type = static_cast<ConvertedType::type>(ecast78);
+          int32_t ecast82;
+          xfer += iprot->readI32(ecast82);
+          this->converted_type = static_cast<ConvertedType::type>(ecast82);
           this->__isset.converted_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3031,58 +3130,58 @@ void swap(SchemaElement &a, SchemaElement &b) {
   swap(a.__isset, b.__isset);
 }
 
-SchemaElement::SchemaElement(const SchemaElement& other79) {
-  type = other79.type;
-  type_length = other79.type_length;
-  repetition_type = other79.repetition_type;
-  name = other79.name;
-  num_children = other79.num_children;
-  converted_type = other79.converted_type;
-  scale = other79.scale;
-  precision = other79.precision;
-  field_id = other79.field_id;
-  logicalType = other79.logicalType;
-  __isset = other79.__isset;
-}
-SchemaElement::SchemaElement(SchemaElement&& other80) noexcept {
-  type = other80.type;
-  type_length = other80.type_length;
-  repetition_type = other80.repetition_type;
-  name = std::move(other80.name);
-  num_children = other80.num_children;
-  converted_type = other80.converted_type;
-  scale = other80.scale;
-  precision = other80.precision;
-  field_id = other80.field_id;
-  logicalType = std::move(other80.logicalType);
-  __isset = other80.__isset;
-}
-SchemaElement& SchemaElement::operator=(const SchemaElement& other81) {
-  type = other81.type;
-  type_length = other81.type_length;
-  repetition_type = other81.repetition_type;
-  name = other81.name;
-  num_children = other81.num_children;
-  converted_type = other81.converted_type;
-  scale = other81.scale;
-  precision = other81.precision;
-  field_id = other81.field_id;
-  logicalType = other81.logicalType;
-  __isset = other81.__isset;
+SchemaElement::SchemaElement(const SchemaElement& other83) {
+  type = other83.type;
+  type_length = other83.type_length;
+  repetition_type = other83.repetition_type;
+  name = other83.name;
+  num_children = other83.num_children;
+  converted_type = other83.converted_type;
+  scale = other83.scale;
+  precision = other83.precision;
+  field_id = other83.field_id;
+  logicalType = other83.logicalType;
+  __isset = other83.__isset;
+}
+SchemaElement::SchemaElement(SchemaElement&& other84) noexcept {
+  type = other84.type;
+  type_length = other84.type_length;
+  repetition_type = other84.repetition_type;
+  name = std::move(other84.name);
+  num_children = other84.num_children;
+  converted_type = other84.converted_type;
+  scale = other84.scale;
+  precision = other84.precision;
+  field_id = other84.field_id;
+  logicalType = std::move(other84.logicalType);
+  __isset = other84.__isset;
+}
+SchemaElement& SchemaElement::operator=(const SchemaElement& other85) {
+  type = other85.type;
+  type_length = other85.type_length;
+  repetition_type = other85.repetition_type;
+  name = other85.name;
+  num_children = other85.num_children;
+  converted_type = other85.converted_type;
+  scale = other85.scale;
+  precision = other85.precision;
+  field_id = other85.field_id;
+  logicalType = other85.logicalType;
+  __isset = other85.__isset;
   return *this;
 }
-SchemaElement& SchemaElement::operator=(SchemaElement&& other82) noexcept {
-  type = other82.type;
-  type_length = other82.type_length;
-  repetition_type = other82.repetition_type;
-  name = std::move(other82.name);
-  num_children = other82.num_children;
-  converted_type = other82.converted_type;
-  scale = other82.scale;
-  precision = other82.precision;
-  field_id = other82.field_id;
-  logicalType = std::move(other82.logicalType);
-  __isset = other82.__isset;
+SchemaElement& SchemaElement::operator=(SchemaElement&& other86) noexcept {
+  type = other86.type;
+  type_length = other86.type_length;
+  repetition_type = other86.repetition_type;
+  name = std::move(other86.name);
+  num_children = other86.num_children;
+  converted_type = other86.converted_type;
+  scale = other86.scale;
+  precision = other86.precision;
+  field_id = other86.field_id;
+  logicalType = std::move(other86.logicalType);
+  __isset = other86.__isset;
   return *this;
 }
 void SchemaElement::printTo(std::ostream& out) const {
@@ -3168,9 +3267,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast83;
-          xfer += iprot->readI32(ecast83);
-          this->encoding = static_cast<Encoding::type>(ecast83);
+          int32_t ecast87;
+          xfer += iprot->readI32(ecast87);
+          this->encoding = static_cast<Encoding::type>(ecast87);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3178,9 +3277,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast84;
-          xfer += iprot->readI32(ecast84);
-          this->definition_level_encoding = static_cast<Encoding::type>(ecast84);
+          int32_t ecast88;
+          xfer += iprot->readI32(ecast88);
+          this->definition_level_encoding = static_cast<Encoding::type>(ecast88);
           isset_definition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3188,9 +3287,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast85;
-          xfer += iprot->readI32(ecast85);
-          this->repetition_level_encoding = static_cast<Encoding::type>(ecast85);
+          int32_t ecast89;
+          xfer += iprot->readI32(ecast89);
+          this->repetition_level_encoding = static_cast<Encoding::type>(ecast89);
           isset_repetition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3265,38 +3364,38 @@ void swap(DataPageHeader &a, DataPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeader::DataPageHeader(const DataPageHeader& other86) {
-  num_values = other86.num_values;
-  encoding = other86.encoding;
-  definition_level_encoding = other86.definition_level_encoding;
-  repetition_level_encoding = other86.repetition_level_encoding;
-  statistics = other86.statistics;
-  __isset = other86.__isset;
-}
-DataPageHeader::DataPageHeader(DataPageHeader&& other87) noexcept {
-  num_values = other87.num_values;
-  encoding = other87.encoding;
-  definition_level_encoding = other87.definition_level_encoding;
-  repetition_level_encoding = other87.repetition_level_encoding;
-  statistics = std::move(other87.statistics);
-  __isset = other87.__isset;
-}
-DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other88) {
-  num_values = other88.num_values;
-  encoding = other88.encoding;
-  definition_level_encoding = other88.definition_level_encoding;
-  repetition_level_encoding = other88.repetition_level_encoding;
-  statistics = other88.statistics;
-  __isset = other88.__isset;
+DataPageHeader::DataPageHeader(const DataPageHeader& other90) {
+  num_values = other90.num_values;
+  encoding = other90.encoding;
+  definition_level_encoding = other90.definition_level_encoding;
+  repetition_level_encoding = other90.repetition_level_encoding;
+  statistics = other90.statistics;
+  __isset = other90.__isset;
+}
+DataPageHeader::DataPageHeader(DataPageHeader&& other91) noexcept {
+  num_values = other91.num_values;
+  encoding = other91.encoding;
+  definition_level_encoding = other91.definition_level_encoding;
+  repetition_level_encoding = other91.repetition_level_encoding;
+  statistics = std::move(other91.statistics);
+  __isset = other91.__isset;
+}
+DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other92) {
+  num_values = other92.num_values;
+  encoding = other92.encoding;
+  definition_level_encoding = other92.definition_level_encoding;
+  repetition_level_encoding = other92.repetition_level_encoding;
+  statistics = other92.statistics;
+  __isset = other92.__isset;
   return *this;
 }
-DataPageHeader& DataPageHeader::operator=(DataPageHeader&& other89) noexcept {
-  num_values = other89.num_values;
-  encoding = other89.encoding;
-  definition_level_encoding = other89.definition_level_encoding;
-  repetition_level_encoding = other89.repetition_level_encoding;
-  statistics = std::move(other89.statistics);
-  __isset = other89.__isset;
+DataPageHeader& DataPageHeader::operator=(DataPageHeader&& other93) noexcept {
+  num_values = other93.num_values;
+  encoding = other93.encoding;
+  definition_level_encoding = other93.definition_level_encoding;
+  repetition_level_encoding = other93.repetition_level_encoding;
+  statistics = std::move(other93.statistics);
+  __isset = other93.__isset;
   return *this;
 }
 void DataPageHeader::printTo(std::ostream& out) const {
@@ -3365,18 +3464,18 @@ void swap(IndexPageHeader &a, IndexPageHeader &b) {
   (void) b;
 }
 
-IndexPageHeader::IndexPageHeader(const IndexPageHeader& other90) noexcept {
-  (void) other90;
+IndexPageHeader::IndexPageHeader(const IndexPageHeader& other94) noexcept {
+  (void) other94;
 }
-IndexPageHeader::IndexPageHeader(IndexPageHeader&& other91) noexcept {
-  (void) other91;
+IndexPageHeader::IndexPageHeader(IndexPageHeader&& other95) noexcept {
+  (void) other95;
 }
-IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other92) noexcept {
-  (void) other92;
+IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other96) noexcept {
+  (void) other96;
   return *this;
 }
-IndexPageHeader& IndexPageHeader::operator=(IndexPageHeader&& other93) noexcept {
-  (void) other93;
+IndexPageHeader& IndexPageHeader::operator=(IndexPageHeader&& other97) noexcept {
+  (void) other97;
   return *this;
 }
 void IndexPageHeader::printTo(std::ostream& out) const {
@@ -3442,9 +3541,9 @@ uint32_t DictionaryPageHeader::read(::apache::thrift::protocol::TProtocol* iprot
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast94;
-          xfer += iprot->readI32(ecast94);
-          this->encoding = static_cast<Encoding::type>(ecast94);
+          int32_t ecast98;
+          xfer += iprot->readI32(ecast98);
+          this->encoding = static_cast<Encoding::type>(ecast98);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3505,30 +3604,30 @@ void swap(DictionaryPageHeader &a, DictionaryPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other95) noexcept {
-  num_values = other95.num_values;
-  encoding = other95.encoding;
-  is_sorted = other95.is_sorted;
-  __isset = other95.__isset;
+DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other99) noexcept {
+  num_values = other99.num_values;
+  encoding = other99.encoding;
+  is_sorted = other99.is_sorted;
+  __isset = other99.__isset;
 }
-DictionaryPageHeader::DictionaryPageHeader(DictionaryPageHeader&& other96) noexcept {
-  num_values = other96.num_values;
-  encoding = other96.encoding;
-  is_sorted = other96.is_sorted;
-  __isset = other96.__isset;
+DictionaryPageHeader::DictionaryPageHeader(DictionaryPageHeader&& other100) noexcept {
+  num_values = other100.num_values;
+  encoding = other100.encoding;
+  is_sorted = other100.is_sorted;
+  __isset = other100.__isset;
 }
-DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other97) noexcept {
-  num_values = other97.num_values;
-  encoding = other97.encoding;
-  is_sorted = other97.is_sorted;
-  __isset = other97.__isset;
+DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other101) noexcept {
+  num_values = other101.num_values;
+  encoding = other101.encoding;
+  is_sorted = other101.is_sorted;
+  __isset = other101.__isset;
   return *this;
 }
-DictionaryPageHeader& DictionaryPageHeader::operator=(DictionaryPageHeader&& other98) noexcept {
-  num_values = other98.num_values;
-  encoding = other98.encoding;
-  is_sorted = other98.is_sorted;
-  __isset = other98.__isset;
+DictionaryPageHeader& DictionaryPageHeader::operator=(DictionaryPageHeader&& other102) noexcept {
+  num_values = other102.num_values;
+  encoding = other102.encoding;
+  is_sorted = other102.is_sorted;
+  __isset = other102.__isset;
   return *this;
 }
 void DictionaryPageHeader::printTo(std::ostream& out) const {
@@ -3638,9 +3737,9 @@ uint32_t DataPageHeaderV2::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast99;
-          xfer += iprot->readI32(ecast99);
-          this->encoding = static_cast<Encoding::type>(ecast99);
+          int32_t ecast103;
+          xfer += iprot->readI32(ecast103);
+          this->encoding = static_cast<Encoding::type>(ecast103);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3759,50 +3858,50 @@ void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other100) {
-  num_values = other100.num_values;
-  num_nulls = other100.num_nulls;
-  num_rows = other100.num_rows;
-  encoding = other100.encoding;
-  definition_levels_byte_length = other100.definition_levels_byte_length;
-  repetition_levels_byte_length = other100.repetition_levels_byte_length;
-  is_compressed = other100.is_compressed;
-  statistics = other100.statistics;
-  __isset = other100.__isset;
-}
-DataPageHeaderV2::DataPageHeaderV2(DataPageHeaderV2&& other101) noexcept {
-  num_values = other101.num_values;
-  num_nulls = other101.num_nulls;
-  num_rows = other101.num_rows;
-  encoding = other101.encoding;
-  definition_levels_byte_length = other101.definition_levels_byte_length;
-  repetition_levels_byte_length = other101.repetition_levels_byte_length;
-  is_compressed = other101.is_compressed;
-  statistics = std::move(other101.statistics);
-  __isset = other101.__isset;
-}
-DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other102) {
-  num_values = other102.num_values;
-  num_nulls = other102.num_nulls;
-  num_rows = other102.num_rows;
-  encoding = other102.encoding;
-  definition_levels_byte_length = other102.definition_levels_byte_length;
-  repetition_levels_byte_length = other102.repetition_levels_byte_length;
-  is_compressed = other102.is_compressed;
-  statistics = other102.statistics;
-  __isset = other102.__isset;
+DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other104) {
+  num_values = other104.num_values;
+  num_nulls = other104.num_nulls;
+  num_rows = other104.num_rows;
+  encoding = other104.encoding;
+  definition_levels_byte_length = other104.definition_levels_byte_length;
+  repetition_levels_byte_length = other104.repetition_levels_byte_length;
+  is_compressed = other104.is_compressed;
+  statistics = other104.statistics;
+  __isset = other104.__isset;
+}
+DataPageHeaderV2::DataPageHeaderV2(DataPageHeaderV2&& other105) noexcept {
+  num_values = other105.num_values;
+  num_nulls = other105.num_nulls;
+  num_rows = other105.num_rows;
+  encoding = other105.encoding;
+  definition_levels_byte_length = other105.definition_levels_byte_length;
+  repetition_levels_byte_length = other105.repetition_levels_byte_length;
+  is_compressed = other105.is_compressed;
+  statistics = std::move(other105.statistics);
+  __isset = other105.__isset;
+}
+DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other106) {
+  num_values = other106.num_values;
+  num_nulls = other106.num_nulls;
+  num_rows = other106.num_rows;
+  encoding = other106.encoding;
+  definition_levels_byte_length = other106.definition_levels_byte_length;
+  repetition_levels_byte_length = other106.repetition_levels_byte_length;
+  is_compressed = other106.is_compressed;
+  statistics = other106.statistics;
+  __isset = other106.__isset;
   return *this;
 }
-DataPageHeaderV2& DataPageHeaderV2::operator=(DataPageHeaderV2&& other103) noexcept {
-  num_values = other103.num_values;
-  num_nulls = other103.num_nulls;
-  num_rows = other103.num_rows;
-  encoding = other103.encoding;
-  definition_levels_byte_length = other103.definition_levels_byte_length;
-  repetition_levels_byte_length = other103.repetition_levels_byte_length;
-  is_compressed = other103.is_compressed;
-  statistics = std::move(other103.statistics);
-  __isset = other103.__isset;
+DataPageHeaderV2& DataPageHeaderV2::operator=(DataPageHeaderV2&& other107) noexcept {
+  num_values = other107.num_values;
+  num_nulls = other107.num_nulls;
+  num_rows = other107.num_rows;
+  encoding = other107.encoding;
+  definition_levels_byte_length = other107.definition_levels_byte_length;
+  repetition_levels_byte_length = other107.repetition_levels_byte_length;
+  is_compressed = other107.is_compressed;
+  statistics = std::move(other107.statistics);
+  __isset = other107.__isset;
   return *this;
 }
 void DataPageHeaderV2::printTo(std::ostream& out) const {
@@ -3874,18 +3973,18 @@ void swap(SplitBlockAlgorithm &a, SplitBlockAlgorithm &b) {
   (void) b;
 }
 
-SplitBlockAlgorithm::SplitBlockAlgorithm(const SplitBlockAlgorithm& other104) noexcept {
-  (void) other104;
+SplitBlockAlgorithm::SplitBlockAlgorithm(const SplitBlockAlgorithm& other108) noexcept {
+  (void) other108;
 }
-SplitBlockAlgorithm::SplitBlockAlgorithm(SplitBlockAlgorithm&& other105) noexcept {
-  (void) other105;
+SplitBlockAlgorithm::SplitBlockAlgorithm(SplitBlockAlgorithm&& other109) noexcept {
+  (void) other109;
 }
-SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(const SplitBlockAlgorithm& other106) noexcept {
-  (void) other106;
+SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(const SplitBlockAlgorithm& other110) noexcept {
+  (void) other110;
   return *this;
 }
-SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(SplitBlockAlgorithm&& other107) noexcept {
-  (void) other107;
+SplitBlockAlgorithm& SplitBlockAlgorithm::operator=(SplitBlockAlgorithm&& other111) noexcept {
+  (void) other111;
   return *this;
 }
 void SplitBlockAlgorithm::printTo(std::ostream& out) const {
@@ -3972,22 +4071,22 @@ void swap(BloomFilterAlgorithm &a, BloomFilterAlgorithm &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterAlgorithm::BloomFilterAlgorithm(const BloomFilterAlgorithm& other108) noexcept {
-  BLOCK = other108.BLOCK;
-  __isset = other108.__isset;
+BloomFilterAlgorithm::BloomFilterAlgorithm(const BloomFilterAlgorithm& other112) noexcept {
+  BLOCK = other112.BLOCK;
+  __isset = other112.__isset;
 }
-BloomFilterAlgorithm::BloomFilterAlgorithm(BloomFilterAlgorithm&& other109) noexcept {
-  BLOCK = std::move(other109.BLOCK);
-  __isset = other109.__isset;
+BloomFilterAlgorithm::BloomFilterAlgorithm(BloomFilterAlgorithm&& other113) noexcept {
+  BLOCK = std::move(other113.BLOCK);
+  __isset = other113.__isset;
 }
-BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(const BloomFilterAlgorithm& other110) noexcept {
-  BLOCK = other110.BLOCK;
-  __isset = other110.__isset;
+BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(const BloomFilterAlgorithm& other114) noexcept {
+  BLOCK = other114.BLOCK;
+  __isset = other114.__isset;
   return *this;
 }
-BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(BloomFilterAlgorithm&& other111) noexcept {
-  BLOCK = std::move(other111.BLOCK);
-  __isset = other111.__isset;
+BloomFilterAlgorithm& BloomFilterAlgorithm::operator=(BloomFilterAlgorithm&& other115) noexcept {
+  BLOCK = std::move(other115.BLOCK);
+  __isset = other115.__isset;
   return *this;
 }
 void BloomFilterAlgorithm::printTo(std::ostream& out) const {
@@ -4052,18 +4151,18 @@ void swap(XxHash &a, XxHash &b) {
   (void) b;
 }
 
-XxHash::XxHash(const XxHash& other112) noexcept {
-  (void) other112;
+XxHash::XxHash(const XxHash& other116) noexcept {
+  (void) other116;
 }
-XxHash::XxHash(XxHash&& other113) noexcept {
-  (void) other113;
+XxHash::XxHash(XxHash&& other117) noexcept {
+  (void) other117;
 }
-XxHash& XxHash::operator=(const XxHash& other114) noexcept {
-  (void) other114;
+XxHash& XxHash::operator=(const XxHash& other118) noexcept {
+  (void) other118;
   return *this;
 }
-XxHash& XxHash::operator=(XxHash&& other115) noexcept {
-  (void) other115;
+XxHash& XxHash::operator=(XxHash&& other119) noexcept {
+  (void) other119;
   return *this;
 }
 void XxHash::printTo(std::ostream& out) const {
@@ -4150,22 +4249,22 @@ void swap(BloomFilterHash &a, BloomFilterHash &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterHash::BloomFilterHash(const BloomFilterHash& other116) noexcept {
-  XXHASH = other116.XXHASH;
-  __isset = other116.__isset;
+BloomFilterHash::BloomFilterHash(const BloomFilterHash& other120) noexcept {
+  XXHASH = other120.XXHASH;
+  __isset = other120.__isset;
 }
-BloomFilterHash::BloomFilterHash(BloomFilterHash&& other117) noexcept {
-  XXHASH = std::move(other117.XXHASH);
-  __isset = other117.__isset;
+BloomFilterHash::BloomFilterHash(BloomFilterHash&& other121) noexcept {
+  XXHASH = std::move(other121.XXHASH);
+  __isset = other121.__isset;
 }
-BloomFilterHash& BloomFilterHash::operator=(const BloomFilterHash& other118) noexcept {
-  XXHASH = other118.XXHASH;
-  __isset = other118.__isset;
+BloomFilterHash& BloomFilterHash::operator=(const BloomFilterHash& other122) noexcept {
+  XXHASH = other122.XXHASH;
+  __isset = other122.__isset;
   return *this;
 }
-BloomFilterHash& BloomFilterHash::operator=(BloomFilterHash&& other119) noexcept {
-  XXHASH = std::move(other119.XXHASH);
-  __isset = other119.__isset;
+BloomFilterHash& BloomFilterHash::operator=(BloomFilterHash&& other123) noexcept {
+  XXHASH = std::move(other123.XXHASH);
+  __isset = other123.__isset;
   return *this;
 }
 void BloomFilterHash::printTo(std::ostream& out) const {
@@ -4230,18 +4329,18 @@ void swap(Uncompressed &a, Uncompressed &b) {
   (void) b;
 }
 
-Uncompressed::Uncompressed(const Uncompressed& other120) noexcept {
-  (void) other120;
+Uncompressed::Uncompressed(const Uncompressed& other124) noexcept {
+  (void) other124;
 }
-Uncompressed::Uncompressed(Uncompressed&& other121) noexcept {
-  (void) other121;
+Uncompressed::Uncompressed(Uncompressed&& other125) noexcept {
+  (void) other125;
 }
-Uncompressed& Uncompressed::operator=(const Uncompressed& other122) noexcept {
-  (void) other122;
+Uncompressed& Uncompressed::operator=(const Uncompressed& other126) noexcept {
+  (void) other126;
   return *this;
 }
-Uncompressed& Uncompressed::operator=(Uncompressed&& other123) noexcept {
-  (void) other123;
+Uncompressed& Uncompressed::operator=(Uncompressed&& other127) noexcept {
+  (void) other127;
   return *this;
 }
 void Uncompressed::printTo(std::ostream& out) const {
@@ -4328,22 +4427,22 @@ void swap(BloomFilterCompression &a, BloomFilterCompression &b) {
   swap(a.__isset, b.__isset);
 }
 
-BloomFilterCompression::BloomFilterCompression(const BloomFilterCompression& other124) noexcept {
-  UNCOMPRESSED = other124.UNCOMPRESSED;
-  __isset = other124.__isset;
+BloomFilterCompression::BloomFilterCompression(const BloomFilterCompression& other128) noexcept {
+  UNCOMPRESSED = other128.UNCOMPRESSED;
+  __isset = other128.__isset;
 }
-BloomFilterCompression::BloomFilterCompression(BloomFilterCompression&& other125) noexcept {
-  UNCOMPRESSED = std::move(other125.UNCOMPRESSED);
-  __isset = other125.__isset;
+BloomFilterCompression::BloomFilterCompression(BloomFilterCompression&& other129) noexcept {
+  UNCOMPRESSED = std::move(other129.UNCOMPRESSED);
+  __isset = other129.__isset;
 }
-BloomFilterCompression& BloomFilterCompression::operator=(const BloomFilterCompression& other126) noexcept {
-  UNCOMPRESSED = other126.UNCOMPRESSED;
-  __isset = other126.__isset;
+BloomFilterCompression& BloomFilterCompression::operator=(const BloomFilterCompression& other130) noexcept {
+  UNCOMPRESSED = other130.UNCOMPRESSED;
+  __isset = other130.__isset;
   return *this;
 }
-BloomFilterCompression& BloomFilterCompression::operator=(BloomFilterCompression&& other127) noexcept {
-  UNCOMPRESSED = std::move(other127.UNCOMPRESSED);
-  __isset = other127.__isset;
+BloomFilterCompression& BloomFilterCompression::operator=(BloomFilterCompression&& other131) noexcept {
+  UNCOMPRESSED = std::move(other131.UNCOMPRESSED);
+  __isset = other131.__isset;
   return *this;
 }
 void BloomFilterCompression::printTo(std::ostream& out) const {
@@ -4491,30 +4590,30 @@ void swap(BloomFilterHeader &a, BloomFilterHeader &b) {
   swap(a.compression, b.compression);
 }
 
-BloomFilterHeader::BloomFilterHeader(const BloomFilterHeader& other128) noexcept {
-  numBytes = other128.numBytes;
-  algorithm = other128.algorithm;
-  hash = other128.hash;
-  compression = other128.compression;
+BloomFilterHeader::BloomFilterHeader(const BloomFilterHeader& other132) noexcept {
+  numBytes = other132.numBytes;
+  algorithm = other132.algorithm;
+  hash = other132.hash;
+  compression = other132.compression;
 }
-BloomFilterHeader::BloomFilterHeader(BloomFilterHeader&& other129) noexcept {
-  numBytes = other129.numBytes;
-  algorithm = std::move(other129.algorithm);
-  hash = std::move(other129.hash);
-  compression = std::move(other129.compression);
+BloomFilterHeader::BloomFilterHeader(BloomFilterHeader&& other133) noexcept {
+  numBytes = other133.numBytes;
+  algorithm = std::move(other133.algorithm);
+  hash = std::move(other133.hash);
+  compression = std::move(other133.compression);
 }
-BloomFilterHeader& BloomFilterHeader::operator=(const BloomFilterHeader& other130) noexcept {
-  numBytes = other130.numBytes;
-  algorithm = other130.algorithm;
-  hash = other130.hash;
-  compression = other130.compression;
+BloomFilterHeader& BloomFilterHeader::operator=(const BloomFilterHeader& other134) noexcept {
+  numBytes = other134.numBytes;
+  algorithm = other134.algorithm;
+  hash = other134.hash;
+  compression = other134.compression;
   return *this;
 }
-BloomFilterHeader& BloomFilterHeader::operator=(BloomFilterHeader&& other131) noexcept {
-  numBytes = other131.numBytes;
-  algorithm = std::move(other131.algorithm);
-  hash = std::move(other131.hash);
-  compression = std::move(other131.compression);
+BloomFilterHeader& BloomFilterHeader::operator=(BloomFilterHeader&& other135) noexcept {
+  numBytes = other135.numBytes;
+  algorithm = std::move(other135.algorithm);
+  hash = std::move(other135.hash);
+  compression = std::move(other135.compression);
   return *this;
 }
 void BloomFilterHeader::printTo(std::ostream& out) const {
@@ -4601,9 +4700,9 @@ uint32_t PageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast132;
-          xfer += iprot->readI32(ecast132);
-          this->type = static_cast<PageType::type>(ecast132);
+          int32_t ecast136;
+          xfer += iprot->readI32(ecast136);
+          this->type = static_cast<PageType::type>(ecast136);
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -4743,50 +4842,50 @@ void swap(PageHeader &a, PageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-PageHeader::PageHeader(const PageHeader& other133) {
-  type = other133.type;
-  uncompressed_page_size = other133.uncompressed_page_size;
-  compressed_page_size = other133.compressed_page_size;
-  crc = other133.crc;
-  data_page_header = other133.data_page_header;
-  index_page_header = other133.index_page_header;
-  dictionary_page_header = other133.dictionary_page_header;
-  data_page_header_v2 = other133.data_page_header_v2;
-  __isset = other133.__isset;
-}
-PageHeader::PageHeader(PageHeader&& other134) noexcept {
-  type = other134.type;
-  uncompressed_page_size = other134.uncompressed_page_size;
-  compressed_page_size = other134.compressed_page_size;
-  crc = other134.crc;
-  data_page_header = std::move(other134.data_page_header);
-  index_page_header = std::move(other134.index_page_header);
-  dictionary_page_header = std::move(other134.dictionary_page_header);
-  data_page_header_v2 = std::move(other134.data_page_header_v2);
-  __isset = other134.__isset;
-}
-PageHeader& PageHeader::operator=(const PageHeader& other135) {
-  type = other135.type;
-  uncompressed_page_size = other135.uncompressed_page_size;
-  compressed_page_size = other135.compressed_page_size;
-  crc = other135.crc;
-  data_page_header = other135.data_page_header;
-  index_page_header = other135.index_page_header;
-  dictionary_page_header = other135.dictionary_page_header;
-  data_page_header_v2 = other135.data_page_header_v2;
-  __isset = other135.__isset;
+PageHeader::PageHeader(const PageHeader& other137) {
+  type = other137.type;
+  uncompressed_page_size = other137.uncompressed_page_size;
+  compressed_page_size = other137.compressed_page_size;
+  crc = other137.crc;
+  data_page_header = other137.data_page_header;
+  index_page_header = other137.index_page_header;
+  dictionary_page_header = other137.dictionary_page_header;
+  data_page_header_v2 = other137.data_page_header_v2;
+  __isset = other137.__isset;
+}
+PageHeader::PageHeader(PageHeader&& other138) noexcept {
+  type = other138.type;
+  uncompressed_page_size = other138.uncompressed_page_size;
+  compressed_page_size = other138.compressed_page_size;
+  crc = other138.crc;
+  data_page_header = std::move(other138.data_page_header);
+  index_page_header = std::move(other138.index_page_header);
+  dictionary_page_header = std::move(other138.dictionary_page_header);
+  data_page_header_v2 = std::move(other138.data_page_header_v2);
+  __isset = other138.__isset;
+}
+PageHeader& PageHeader::operator=(const PageHeader& other139) {
+  type = other139.type;
+  uncompressed_page_size = other139.uncompressed_page_size;
+  compressed_page_size = other139.compressed_page_size;
+  crc = other139.crc;
+  data_page_header = other139.data_page_header;
+  index_page_header = other139.index_page_header;
+  dictionary_page_header = other139.dictionary_page_header;
+  data_page_header_v2 = other139.data_page_header_v2;
+  __isset = other139.__isset;
   return *this;
 }
-PageHeader& PageHeader::operator=(PageHeader&& other136) noexcept {
-  type = other136.type;
-  uncompressed_page_size = other136.uncompressed_page_size;
-  compressed_page_size = other136.compressed_page_size;
-  crc = other136.crc;
-  data_page_header = std::move(other136.data_page_header);
-  index_page_header = std::move(other136.index_page_header);
-  dictionary_page_header = std::move(other136.dictionary_page_header);
-  data_page_header_v2 = std::move(other136.data_page_header_v2);
-  __isset = other136.__isset;
+PageHeader& PageHeader::operator=(PageHeader&& other140) noexcept {
+  type = other140.type;
+  uncompressed_page_size = other140.uncompressed_page_size;
+  compressed_page_size = other140.compressed_page_size;
+  crc = other140.crc;
+  data_page_header = std::move(other140.data_page_header);
+  index_page_header = std::move(other140.index_page_header);
+  dictionary_page_header = std::move(other140.dictionary_page_header);
+  data_page_header_v2 = std::move(other140.data_page_header_v2);
+  __isset = other140.__isset;
   return *this;
 }
 void PageHeader::printTo(std::ostream& out) const {
@@ -4901,26 +5000,26 @@ void swap(KeyValue &a, KeyValue &b) {
   swap(a.__isset, b.__isset);
 }
 
-KeyValue::KeyValue(const KeyValue& other137) {
-  key = other137.key;
-  value = other137.value;
-  __isset = other137.__isset;
+KeyValue::KeyValue(const KeyValue& other141) {
+  key = other141.key;
+  value = other141.value;
+  __isset = other141.__isset;
 }
-KeyValue::KeyValue(KeyValue&& other138) noexcept {
-  key = std::move(other138.key);
-  value = std::move(other138.value);
-  __isset = other138.__isset;
+KeyValue::KeyValue(KeyValue&& other142) noexcept {
+  key = std::move(other142.key);
+  value = std::move(other142.value);
+  __isset = other142.__isset;
 }
-KeyValue& KeyValue::operator=(const KeyValue& other139) {
-  key = other139.key;
-  value = other139.value;
-  __isset = other139.__isset;
+KeyValue& KeyValue::operator=(const KeyValue& other143) {
+  key = other143.key;
+  value = other143.value;
+  __isset = other143.__isset;
   return *this;
 }
-KeyValue& KeyValue::operator=(KeyValue&& other140) noexcept {
-  key = std::move(other140.key);
-  value = std::move(other140.value);
-  __isset = other140.__isset;
+KeyValue& KeyValue::operator=(KeyValue&& other144) noexcept {
+  key = std::move(other144.key);
+  value = std::move(other144.value);
+  __isset = other144.__isset;
   return *this;
 }
 void KeyValue::printTo(std::ostream& out) const {
@@ -5049,26 +5148,26 @@ void swap(SortingColumn &a, SortingColumn &b) {
   swap(a.nulls_first, b.nulls_first);
 }
 
-SortingColumn::SortingColumn(const SortingColumn& other141) noexcept {
-  column_idx = other141.column_idx;
-  descending = other141.descending;
-  nulls_first = other141.nulls_first;
+SortingColumn::SortingColumn(const SortingColumn& other145) noexcept {
+  column_idx = other145.column_idx;
+  descending = other145.descending;
+  nulls_first = other145.nulls_first;
 }
-SortingColumn::SortingColumn(SortingColumn&& other142) noexcept {
-  column_idx = other142.column_idx;
-  descending = other142.descending;
-  nulls_first = other142.nulls_first;
+SortingColumn::SortingColumn(SortingColumn&& other146) noexcept {
+  column_idx = other146.column_idx;
+  descending = other146.descending;
+  nulls_first = other146.nulls_first;
 }
-SortingColumn& SortingColumn::operator=(const SortingColumn& other143) noexcept {
-  column_idx = other143.column_idx;
-  descending = other143.descending;
-  nulls_first = other143.nulls_first;
+SortingColumn& SortingColumn::operator=(const SortingColumn& other147) noexcept {
+  column_idx = other147.column_idx;
+  descending = other147.descending;
+  nulls_first = other147.nulls_first;
   return *this;
 }
-SortingColumn& SortingColumn::operator=(SortingColumn&& other144) noexcept {
-  column_idx = other144.column_idx;
-  descending = other144.descending;
-  nulls_first = other144.nulls_first;
+SortingColumn& SortingColumn::operator=(SortingColumn&& other148) noexcept {
+  column_idx = other148.column_idx;
+  descending = other148.descending;
+  nulls_first = other148.nulls_first;
   return *this;
 }
 void SortingColumn::printTo(std::ostream& out) const {
@@ -5129,9 +5228,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast145;
-          xfer += iprot->readI32(ecast145);
-          this->page_type = static_cast<PageType::type>(ecast145);
+          int32_t ecast149;
+          xfer += iprot->readI32(ecast149);
+          this->page_type = static_cast<PageType::type>(ecast149);
           isset_page_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5139,9 +5238,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast146;
-          xfer += iprot->readI32(ecast146);
-          this->encoding = static_cast<Encoding::type>(ecast146);
+          int32_t ecast150;
+          xfer += iprot->readI32(ecast150);
+          this->encoding = static_cast<Encoding::type>(ecast150);
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5202,26 +5301,26 @@ void swap(PageEncodingStats &a, PageEncodingStats &b) {
   swap(a.count, b.count);
 }
 
-PageEncodingStats::PageEncodingStats(const PageEncodingStats& other147) noexcept {
-  page_type = other147.page_type;
-  encoding = other147.encoding;
-  count = other147.count;
+PageEncodingStats::PageEncodingStats(const PageEncodingStats& other151) noexcept {
+  page_type = other151.page_type;
+  encoding = other151.encoding;
+  count = other151.count;
 }
-PageEncodingStats::PageEncodingStats(PageEncodingStats&& other148) noexcept {
-  page_type = other148.page_type;
-  encoding = other148.encoding;
-  count = other148.count;
+PageEncodingStats::PageEncodingStats(PageEncodingStats&& other152) noexcept {
+  page_type = other152.page_type;
+  encoding = other152.encoding;
+  count = other152.count;
 }
-PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other149) noexcept {
-  page_type = other149.page_type;
-  encoding = other149.encoding;
-  count = other149.count;
+PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other153) noexcept {
+  page_type = other153.page_type;
+  encoding = other153.encoding;
+  count = other153.count;
   return *this;
 }
-PageEncodingStats& PageEncodingStats::operator=(PageEncodingStats&& other150) noexcept {
-  page_type = other150.page_type;
-  encoding = other150.encoding;
-  count = other150.count;
+PageEncodingStats& PageEncodingStats::operator=(PageEncodingStats&& other154) noexcept {
+  page_type = other154.page_type;
+  encoding = other154.encoding;
+  count = other154.count;
   return *this;
 }
 void PageEncodingStats::printTo(std::ostream& out) const {
@@ -5337,9 +5436,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast151;
-          xfer += iprot->readI32(ecast151);
-          this->type = static_cast<Type::type>(ecast151);
+          int32_t ecast155;
+          xfer += iprot->readI32(ecast155);
+          this->type = static_cast<Type::type>(ecast155);
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5349,16 +5448,16 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encodings.clear();
-            uint32_t _size152;
-            ::apache::thrift::protocol::TType _etype155;
-            xfer += iprot->readListBegin(_etype155, _size152);
-            this->encodings.resize(_size152);
-            uint32_t _i156;
-            for (_i156 = 0; _i156 < _size152; ++_i156)
+            uint32_t _size156;
+            ::apache::thrift::protocol::TType _etype159;
+            xfer += iprot->readListBegin(_etype159, _size156);
+            this->encodings.resize(_size156);
+            uint32_t _i160;
+            for (_i160 = 0; _i160 < _size156; ++_i160)
             {
-              int32_t ecast157;
-              xfer += iprot->readI32(ecast157);
-              this->encodings[_i156] = static_cast<Encoding::type>(ecast157);
+              int32_t ecast161;
+              xfer += iprot->readI32(ecast161);
+              this->encodings[_i160] = static_cast<Encoding::type>(ecast161);
             }
             xfer += iprot->readListEnd();
           }
@@ -5371,14 +5470,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size158;
-            ::apache::thrift::protocol::TType _etype161;
-            xfer += iprot->readListBegin(_etype161, _size158);
-            this->path_in_schema.resize(_size158);
-            uint32_t _i162;
-            for (_i162 = 0; _i162 < _size158; ++_i162)
+            uint32_t _size162;
+            ::apache::thrift::protocol::TType _etype165;
+            xfer += iprot->readListBegin(_etype165, _size162);
+            this->path_in_schema.resize(_size162);
+            uint32_t _i166;
+            for (_i166 = 0; _i166 < _size162; ++_i166)
             {
-              xfer += iprot->readString(this->path_in_schema[_i162]);
+              xfer += iprot->readString(this->path_in_schema[_i166]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5389,9 +5488,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast163;
-          xfer += iprot->readI32(ecast163);
-          this->codec = static_cast<CompressionCodec::type>(ecast163);
+          int32_t ecast167;
+          xfer += iprot->readI32(ecast167);
+          this->codec = static_cast<CompressionCodec::type>(ecast167);
           isset_codec = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5425,14 +5524,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->key_value_metadata.clear();
-            uint32_t _size164;
-            ::apache::thrift::protocol::TType _etype167;
-            xfer += iprot->readListBegin(_etype167, _size164);
-            this->key_value_metadata.resize(_size164);
-            uint32_t _i168;
-            for (_i168 = 0; _i168 < _size164; ++_i168)
+            uint32_t _size168;
+            ::apache::thrift::protocol::TType _etype171;
+            xfer += iprot->readListBegin(_etype171, _size168);
+            this->key_value_metadata.resize(_size168);
+            uint32_t _i172;
+            for (_i172 = 0; _i172 < _size168; ++_i172)
             {
-              xfer += this->key_value_metadata[_i168].read(iprot);
+              xfer += this->key_value_metadata[_i172].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5477,14 +5576,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encoding_stats.clear();
-            uint32_t _size169;
-            ::apache::thrift::protocol::TType _etype172;
-            xfer += iprot->readListBegin(_etype172, _size169);
-            this->encoding_stats.resize(_size169);
-            uint32_t _i173;
-            for (_i173 = 0; _i173 < _size169; ++_i173)
+            uint32_t _size173;
+            ::apache::thrift::protocol::TType _etype176;
+            xfer += iprot->readListBegin(_etype176, _size173);
+            this->encoding_stats.resize(_size173);
+            uint32_t _i177;
+            for (_i177 = 0; _i177 < _size173; ++_i177)
             {
-              xfer += this->encoding_stats[_i173].read(iprot);
+              xfer += this->encoding_stats[_i177].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5541,10 +5640,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("encodings", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    std::vector<Encoding::type> ::const_iterator _iter174;
-    for (_iter174 = this->encodings.begin(); _iter174 != this->encodings.end(); ++_iter174)
+    std::vector<Encoding::type> ::const_iterator _iter178;
+    for (_iter178 = this->encodings.begin(); _iter178 != this->encodings.end(); ++_iter178)
     {
-      xfer += oprot->writeI32(static_cast<int32_t>((*_iter174)));
+      xfer += oprot->writeI32(static_cast<int32_t>((*_iter178)));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5553,10 +5652,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter175;
-    for (_iter175 = this->path_in_schema.begin(); _iter175 != this->path_in_schema.end(); ++_iter175)
+    std::vector<std::string> ::const_iterator _iter179;
+    for (_iter179 = this->path_in_schema.begin(); _iter179 != this->path_in_schema.end(); ++_iter179)
     {
-      xfer += oprot->writeString((*_iter175));
+      xfer += oprot->writeString((*_iter179));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5582,10 +5681,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 8);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter176;
-      for (_iter176 = this->key_value_metadata.begin(); _iter176 != this->key_value_metadata.end(); ++_iter176)
+      std::vector<KeyValue> ::const_iterator _iter180;
+      for (_iter180 = this->key_value_metadata.begin(); _iter180 != this->key_value_metadata.end(); ++_iter180)
       {
-        xfer += (*_iter176).write(oprot);
+        xfer += (*_iter180).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -5614,10 +5713,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("encoding_stats", ::apache::thrift::protocol::T_LIST, 13);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->encoding_stats.size()));
-      std::vector<PageEncodingStats> ::const_iterator _iter177;
-      for (_iter177 = this->encoding_stats.begin(); _iter177 != this->encoding_stats.end(); ++_iter177)
+      std::vector<PageEncodingStats> ::const_iterator _iter181;
+      for (_iter181 = this->encoding_stats.begin(); _iter181 != this->encoding_stats.end(); ++_iter181)
       {
-        xfer += (*_iter177).write(oprot);
+        xfer += (*_iter181).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -5652,74 +5751,74 @@ void swap(ColumnMetaData &a, ColumnMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnMetaData::ColumnMetaData(const ColumnMetaData& other178) {
-  type = other178.type;
-  encodings = other178.encodings;
-  path_in_schema = other178.path_in_schema;
-  codec = other178.codec;
-  num_values = other178.num_values;
-  total_uncompressed_size = other178.total_uncompressed_size;
-  total_compressed_size = other178.total_compressed_size;
-  key_value_metadata = other178.key_value_metadata;
-  data_page_offset = other178.data_page_offset;
-  index_page_offset = other178.index_page_offset;
-  dictionary_page_offset = other178.dictionary_page_offset;
-  statistics = other178.statistics;
-  encoding_stats = other178.encoding_stats;
-  bloom_filter_offset = other178.bloom_filter_offset;
-  __isset = other178.__isset;
-}
-ColumnMetaData::ColumnMetaData(ColumnMetaData&& other179) noexcept {
-  type = other179.type;
-  encodings = std::move(other179.encodings);
-  path_in_schema = std::move(other179.path_in_schema);
-  codec = other179.codec;
-  num_values = other179.num_values;
-  total_uncompressed_size = other179.total_uncompressed_size;
-  total_compressed_size = other179.total_compressed_size;
-  key_value_metadata = std::move(other179.key_value_metadata);
-  data_page_offset = other179.data_page_offset;
-  index_page_offset = other179.index_page_offset;
-  dictionary_page_offset = other179.dictionary_page_offset;
-  statistics = std::move(other179.statistics);
-  encoding_stats = std::move(other179.encoding_stats);
-  bloom_filter_offset = other179.bloom_filter_offset;
-  __isset = other179.__isset;
-}
-ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other180) {
-  type = other180.type;
-  encodings = other180.encodings;
-  path_in_schema = other180.path_in_schema;
-  codec = other180.codec;
-  num_values = other180.num_values;
-  total_uncompressed_size = other180.total_uncompressed_size;
-  total_compressed_size = other180.total_compressed_size;
-  key_value_metadata = other180.key_value_metadata;
-  data_page_offset = other180.data_page_offset;
-  index_page_offset = other180.index_page_offset;
-  dictionary_page_offset = other180.dictionary_page_offset;
-  statistics = other180.statistics;
-  encoding_stats = other180.encoding_stats;
-  bloom_filter_offset = other180.bloom_filter_offset;
-  __isset = other180.__isset;
+ColumnMetaData::ColumnMetaData(const ColumnMetaData& other182) {
+  type = other182.type;
+  encodings = other182.encodings;
+  path_in_schema = other182.path_in_schema;
+  codec = other182.codec;
+  num_values = other182.num_values;
+  total_uncompressed_size = other182.total_uncompressed_size;
+  total_compressed_size = other182.total_compressed_size;
+  key_value_metadata = other182.key_value_metadata;
+  data_page_offset = other182.data_page_offset;
+  index_page_offset = other182.index_page_offset;
+  dictionary_page_offset = other182.dictionary_page_offset;
+  statistics = other182.statistics;
+  encoding_stats = other182.encoding_stats;
+  bloom_filter_offset = other182.bloom_filter_offset;
+  __isset = other182.__isset;
+}
+ColumnMetaData::ColumnMetaData(ColumnMetaData&& other183) noexcept {
+  type = other183.type;
+  encodings = std::move(other183.encodings);
+  path_in_schema = std::move(other183.path_in_schema);
+  codec = other183.codec;
+  num_values = other183.num_values;
+  total_uncompressed_size = other183.total_uncompressed_size;
+  total_compressed_size = other183.total_compressed_size;
+  key_value_metadata = std::move(other183.key_value_metadata);
+  data_page_offset = other183.data_page_offset;
+  index_page_offset = other183.index_page_offset;
+  dictionary_page_offset = other183.dictionary_page_offset;
+  statistics = std::move(other183.statistics);
+  encoding_stats = std::move(other183.encoding_stats);
+  bloom_filter_offset = other183.bloom_filter_offset;
+  __isset = other183.__isset;
+}
+ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other184) {
+  type = other184.type;
+  encodings = other184.encodings;
+  path_in_schema = other184.path_in_schema;
+  codec = other184.codec;
+  num_values = other184.num_values;
+  total_uncompressed_size = other184.total_uncompressed_size;
+  total_compressed_size = other184.total_compressed_size;
+  key_value_metadata = other184.key_value_metadata;
+  data_page_offset = other184.data_page_offset;
+  index_page_offset = other184.index_page_offset;
+  dictionary_page_offset = other184.dictionary_page_offset;
+  statistics = other184.statistics;
+  encoding_stats = other184.encoding_stats;
+  bloom_filter_offset = other184.bloom_filter_offset;
+  __isset = other184.__isset;
   return *this;
 }
-ColumnMetaData& ColumnMetaData::operator=(ColumnMetaData&& other181) noexcept {
-  type = other181.type;
-  encodings = std::move(other181.encodings);
-  path_in_schema = std::move(other181.path_in_schema);
-  codec = other181.codec;
-  num_values = other181.num_values;
-  total_uncompressed_size = other181.total_uncompressed_size;
-  total_compressed_size = other181.total_compressed_size;
-  key_value_metadata = std::move(other181.key_value_metadata);
-  data_page_offset = other181.data_page_offset;
-  index_page_offset = other181.index_page_offset;
-  dictionary_page_offset = other181.dictionary_page_offset;
-  statistics = std::move(other181.statistics);
-  encoding_stats = std::move(other181.encoding_stats);
-  bloom_filter_offset = other181.bloom_filter_offset;
-  __isset = other181.__isset;
+ColumnMetaData& ColumnMetaData::operator=(ColumnMetaData&& other185) noexcept {
+  type = other185.type;
+  encodings = std::move(other185.encodings);
+  path_in_schema = std::move(other185.path_in_schema);
+  codec = other185.codec;
+  num_values = other185.num_values;
+  total_uncompressed_size = other185.total_uncompressed_size;
+  total_compressed_size = other185.total_compressed_size;
+  key_value_metadata = std::move(other185.key_value_metadata);
+  data_page_offset = other185.data_page_offset;
+  index_page_offset = other185.index_page_offset;
+  dictionary_page_offset = other185.dictionary_page_offset;
+  statistics = std::move(other185.statistics);
+  encoding_stats = std::move(other185.encoding_stats);
+  bloom_filter_offset = other185.bloom_filter_offset;
+  __isset = other185.__isset;
   return *this;
 }
 void ColumnMetaData::printTo(std::ostream& out) const {
@@ -5797,18 +5896,18 @@ void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b) {
   (void) b;
 }
 
-EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other182) noexcept {
-  (void) other182;
+EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other186) noexcept {
+  (void) other186;
 }
-EncryptionWithFooterKey::EncryptionWithFooterKey(EncryptionWithFooterKey&& other183) noexcept {
-  (void) other183;
+EncryptionWithFooterKey::EncryptionWithFooterKey(EncryptionWithFooterKey&& other187) noexcept {
+  (void) other187;
 }
-EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other184) noexcept {
-  (void) other184;
+EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other188) noexcept {
+  (void) other188;
   return *this;
 }
-EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(EncryptionWithFooterKey&& other185) noexcept {
-  (void) other185;
+EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(EncryptionWithFooterKey&& other189) noexcept {
+  (void) other189;
   return *this;
 }
 void EncryptionWithFooterKey::printTo(std::ostream& out) const {
@@ -5863,14 +5962,14 @@ uint32_t EncryptionWithColumnKey::read(::apache::thrift::protocol::TProtocol* ip
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size186;
-            ::apache::thrift::protocol::TType _etype189;
-            xfer += iprot->readListBegin(_etype189, _size186);
-            this->path_in_schema.resize(_size186);
-            uint32_t _i190;
-            for (_i190 = 0; _i190 < _size186; ++_i190)
+            uint32_t _size190;
+            ::apache::thrift::protocol::TType _etype193;
+            xfer += iprot->readListBegin(_etype193, _size190);
+            this->path_in_schema.resize(_size190);
+            uint32_t _i194;
+            for (_i194 = 0; _i194 < _size190; ++_i194)
             {
-              xfer += iprot->readString(this->path_in_schema[_i190]);
+              xfer += iprot->readString(this->path_in_schema[_i194]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5909,10 +6008,10 @@ uint32_t EncryptionWithColumnKey::write(::apache::thrift::protocol::TProtocol* o
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter191;
-    for (_iter191 = this->path_in_schema.begin(); _iter191 != this->path_in_schema.end(); ++_iter191)
+    std::vector<std::string> ::const_iterator _iter195;
+    for (_iter195 = this->path_in_schema.begin(); _iter195 != this->path_in_schema.end(); ++_iter195)
     {
-      xfer += oprot->writeString((*_iter191));
+      xfer += oprot->writeString((*_iter195));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5935,26 +6034,26 @@ void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b) {
   swap(a.__isset, b.__isset);
 }
 
-EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other192) {
-  path_in_schema = other192.path_in_schema;
-  key_metadata = other192.key_metadata;
-  __isset = other192.__isset;
+EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other196) {
+  path_in_schema = other196.path_in_schema;
+  key_metadata = other196.key_metadata;
+  __isset = other196.__isset;
 }
-EncryptionWithColumnKey::EncryptionWithColumnKey(EncryptionWithColumnKey&& other193) noexcept {
-  path_in_schema = std::move(other193.path_in_schema);
-  key_metadata = std::move(other193.key_metadata);
-  __isset = other193.__isset;
+EncryptionWithColumnKey::EncryptionWithColumnKey(EncryptionWithColumnKey&& other197) noexcept {
+  path_in_schema = std::move(other197.path_in_schema);
+  key_metadata = std::move(other197.key_metadata);
+  __isset = other197.__isset;
 }
-EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other194) {
-  path_in_schema = other194.path_in_schema;
-  key_metadata = other194.key_metadata;
-  __isset = other194.__isset;
+EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other198) {
+  path_in_schema = other198.path_in_schema;
+  key_metadata = other198.key_metadata;
+  __isset = other198.__isset;
   return *this;
 }
-EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(EncryptionWithColumnKey&& other195) noexcept {
-  path_in_schema = std::move(other195.path_in_schema);
-  key_metadata = std::move(other195.key_metadata);
-  __isset = other195.__isset;
+EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(EncryptionWithColumnKey&& other199) noexcept {
+  path_in_schema = std::move(other199.path_in_schema);
+  key_metadata = std::move(other199.key_metadata);
+  __isset = other199.__isset;
   return *this;
 }
 void EncryptionWithColumnKey::printTo(std::ostream& out) const {
@@ -6062,26 +6161,26 @@ void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other196) {
-  ENCRYPTION_WITH_FOOTER_KEY = other196.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other196.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other196.__isset;
+ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other200) {
+  ENCRYPTION_WITH_FOOTER_KEY = other200.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other200.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other200.__isset;
 }
-ColumnCryptoMetaData::ColumnCryptoMetaData(ColumnCryptoMetaData&& other197) noexcept {
-  ENCRYPTION_WITH_FOOTER_KEY = std::move(other197.ENCRYPTION_WITH_FOOTER_KEY);
-  ENCRYPTION_WITH_COLUMN_KEY = std::move(other197.ENCRYPTION_WITH_COLUMN_KEY);
-  __isset = other197.__isset;
+ColumnCryptoMetaData::ColumnCryptoMetaData(ColumnCryptoMetaData&& other201) noexcept {
+  ENCRYPTION_WITH_FOOTER_KEY = std::move(other201.ENCRYPTION_WITH_FOOTER_KEY);
+  ENCRYPTION_WITH_COLUMN_KEY = std::move(other201.ENCRYPTION_WITH_COLUMN_KEY);
+  __isset = other201.__isset;
 }
-ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other198) {
-  ENCRYPTION_WITH_FOOTER_KEY = other198.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other198.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other198.__isset;
+ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other202) {
+  ENCRYPTION_WITH_FOOTER_KEY = other202.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other202.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other202.__isset;
   return *this;
 }
-ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(ColumnCryptoMetaData&& other199) noexcept {
-  ENCRYPTION_WITH_FOOTER_KEY = std::move(other199.ENCRYPTION_WITH_FOOTER_KEY);
-  ENCRYPTION_WITH_COLUMN_KEY = std::move(other199.ENCRYPTION_WITH_COLUMN_KEY);
-  __isset = other199.__isset;
+ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(ColumnCryptoMetaData&& other203) noexcept {
+  ENCRYPTION_WITH_FOOTER_KEY = std::move(other203.ENCRYPTION_WITH_FOOTER_KEY);
+  ENCRYPTION_WITH_COLUMN_KEY = std::move(other203.ENCRYPTION_WITH_COLUMN_KEY);
+  __isset = other203.__isset;
   return *this;
 }
 void ColumnCryptoMetaData::printTo(std::ostream& out) const {
@@ -6323,54 +6422,54 @@ void swap(ColumnChunk &a, ColumnChunk &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnChunk::ColumnChunk(const ColumnChunk& other200) {
-  file_path = other200.file_path;
-  file_offset = other200.file_offset;
-  meta_data = other200.meta_data;
-  offset_index_offset = other200.offset_index_offset;
-  offset_index_length = other200.offset_index_length;
-  column_index_offset = other200.column_index_offset;
-  column_index_length = other200.column_index_length;
-  crypto_metadata = other200.crypto_metadata;
-  encrypted_column_metadata = other200.encrypted_column_metadata;
-  __isset = other200.__isset;
-}
-ColumnChunk::ColumnChunk(ColumnChunk&& other201) noexcept {
-  file_path = std::move(other201.file_path);
-  file_offset = other201.file_offset;
-  meta_data = std::move(other201.meta_data);
-  offset_index_offset = other201.offset_index_offset;
-  offset_index_length = other201.offset_index_length;
-  column_index_offset = other201.column_index_offset;
-  column_index_length = other201.column_index_length;
-  crypto_metadata = std::move(other201.crypto_metadata);
-  encrypted_column_metadata = std::move(other201.encrypted_column_metadata);
-  __isset = other201.__isset;
-}
-ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other202) {
-  file_path = other202.file_path;
-  file_offset = other202.file_offset;
-  meta_data = other202.meta_data;
-  offset_index_offset = other202.offset_index_offset;
-  offset_index_length = other202.offset_index_length;
-  column_index_offset = other202.column_index_offset;
-  column_index_length = other202.column_index_length;
-  crypto_metadata = other202.crypto_metadata;
-  encrypted_column_metadata = other202.encrypted_column_metadata;
-  __isset = other202.__isset;
+ColumnChunk::ColumnChunk(const ColumnChunk& other204) {
+  file_path = other204.file_path;
+  file_offset = other204.file_offset;
+  meta_data = other204.meta_data;
+  offset_index_offset = other204.offset_index_offset;
+  offset_index_length = other204.offset_index_length;
+  column_index_offset = other204.column_index_offset;
+  column_index_length = other204.column_index_length;
+  crypto_metadata = other204.crypto_metadata;
+  encrypted_column_metadata = other204.encrypted_column_metadata;
+  __isset = other204.__isset;
+}
+ColumnChunk::ColumnChunk(ColumnChunk&& other205) noexcept {
+  file_path = std::move(other205.file_path);
+  file_offset = other205.file_offset;
+  meta_data = std::move(other205.meta_data);
+  offset_index_offset = other205.offset_index_offset;
+  offset_index_length = other205.offset_index_length;
+  column_index_offset = other205.column_index_offset;
+  column_index_length = other205.column_index_length;
+  crypto_metadata = std::move(other205.crypto_metadata);
+  encrypted_column_metadata = std::move(other205.encrypted_column_metadata);
+  __isset = other205.__isset;
+}
+ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other206) {
+  file_path = other206.file_path;
+  file_offset = other206.file_offset;
+  meta_data = other206.meta_data;
+  offset_index_offset = other206.offset_index_offset;
+  offset_index_length = other206.offset_index_length;
+  column_index_offset = other206.column_index_offset;
+  column_index_length = other206.column_index_length;
+  crypto_metadata = other206.crypto_metadata;
+  encrypted_column_metadata = other206.encrypted_column_metadata;
+  __isset = other206.__isset;
   return *this;
 }
-ColumnChunk& ColumnChunk::operator=(ColumnChunk&& other203) noexcept {
-  file_path = std::move(other203.file_path);
-  file_offset = other203.file_offset;
-  meta_data = std::move(other203.meta_data);
-  offset_index_offset = other203.offset_index_offset;
-  offset_index_length = other203.offset_index_length;
-  column_index_offset = other203.column_index_offset;
-  column_index_length = other203.column_index_length;
-  crypto_metadata = std::move(other203.crypto_metadata);
-  encrypted_column_metadata = std::move(other203.encrypted_column_metadata);
-  __isset = other203.__isset;
+ColumnChunk& ColumnChunk::operator=(ColumnChunk&& other207) noexcept {
+  file_path = std::move(other207.file_path);
+  file_offset = other207.file_offset;
+  meta_data = std::move(other207.meta_data);
+  offset_index_offset = other207.offset_index_offset;
+  offset_index_length = other207.offset_index_length;
+  column_index_offset = other207.column_index_offset;
+  column_index_length = other207.column_index_length;
+  crypto_metadata = std::move(other207.crypto_metadata);
+  encrypted_column_metadata = std::move(other207.encrypted_column_metadata);
+  __isset = other207.__isset;
   return *this;
 }
 void ColumnChunk::printTo(std::ostream& out) const {
@@ -6459,14 +6558,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size204;
-            ::apache::thrift::protocol::TType _etype207;
-            xfer += iprot->readListBegin(_etype207, _size204);
-            this->columns.resize(_size204);
-            uint32_t _i208;
-            for (_i208 = 0; _i208 < _size204; ++_i208)
+            uint32_t _size208;
+            ::apache::thrift::protocol::TType _etype211;
+            xfer += iprot->readListBegin(_etype211, _size208);
+            this->columns.resize(_size208);
+            uint32_t _i212;
+            for (_i212 = 0; _i212 < _size208; ++_i212)
             {
-              xfer += this->columns[_i208].read(iprot);
+              xfer += this->columns[_i212].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6495,14 +6594,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->sorting_columns.clear();
-            uint32_t _size209;
-            ::apache::thrift::protocol::TType _etype212;
-            xfer += iprot->readListBegin(_etype212, _size209);
-            this->sorting_columns.resize(_size209);
-            uint32_t _i213;
-            for (_i213 = 0; _i213 < _size209; ++_i213)
+            uint32_t _size213;
+            ::apache::thrift::protocol::TType _etype216;
+            xfer += iprot->readListBegin(_etype216, _size213);
+            this->sorting_columns.resize(_size213);
+            uint32_t _i217;
+            for (_i217 = 0; _i217 < _size213; ++_i217)
             {
-              xfer += this->sorting_columns[_i213].read(iprot);
+              xfer += this->sorting_columns[_i217].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6561,10 +6660,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<ColumnChunk> ::const_iterator _iter214;
-    for (_iter214 = this->columns.begin(); _iter214 != this->columns.end(); ++_iter214)
+    std::vector<ColumnChunk> ::const_iterator _iter218;
+    for (_iter218 = this->columns.begin(); _iter218 != this->columns.end(); ++_iter218)
     {
-      xfer += (*_iter214).write(oprot);
+      xfer += (*_iter218).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -6582,10 +6681,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("sorting_columns", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      std::vector<SortingColumn> ::const_iterator _iter215;
-      for (_iter215 = this->sorting_columns.begin(); _iter215 != this->sorting_columns.end(); ++_iter215)
+      std::vector<SortingColumn> ::const_iterator _iter219;
+      for (_iter219 = this->sorting_columns.begin(); _iter219 != this->sorting_columns.end(); ++_iter219)
       {
-        xfer += (*_iter215).write(oprot);
+        xfer += (*_iter219).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -6623,46 +6722,46 @@ void swap(RowGroup &a, RowGroup &b) {
   swap(a.__isset, b.__isset);
 }
 
-RowGroup::RowGroup(const RowGroup& other216) {
-  columns = other216.columns;
-  total_byte_size = other216.total_byte_size;
-  num_rows = other216.num_rows;
-  sorting_columns = other216.sorting_columns;
-  file_offset = other216.file_offset;
-  total_compressed_size = other216.total_compressed_size;
-  ordinal = other216.ordinal;
-  __isset = other216.__isset;
-}
-RowGroup::RowGroup(RowGroup&& other217) noexcept {
-  columns = std::move(other217.columns);
-  total_byte_size = other217.total_byte_size;
-  num_rows = other217.num_rows;
-  sorting_columns = std::move(other217.sorting_columns);
-  file_offset = other217.file_offset;
-  total_compressed_size = other217.total_compressed_size;
-  ordinal = other217.ordinal;
-  __isset = other217.__isset;
-}
-RowGroup& RowGroup::operator=(const RowGroup& other218) {
-  columns = other218.columns;
-  total_byte_size = other218.total_byte_size;
-  num_rows = other218.num_rows;
-  sorting_columns = other218.sorting_columns;
-  file_offset = other218.file_offset;
-  total_compressed_size = other218.total_compressed_size;
-  ordinal = other218.ordinal;
-  __isset = other218.__isset;
+RowGroup::RowGroup(const RowGroup& other220) {
+  columns = other220.columns;
+  total_byte_size = other220.total_byte_size;
+  num_rows = other220.num_rows;
+  sorting_columns = other220.sorting_columns;
+  file_offset = other220.file_offset;
+  total_compressed_size = other220.total_compressed_size;
+  ordinal = other220.ordinal;
+  __isset = other220.__isset;
+}
+RowGroup::RowGroup(RowGroup&& other221) noexcept {
+  columns = std::move(other221.columns);
+  total_byte_size = other221.total_byte_size;
+  num_rows = other221.num_rows;
+  sorting_columns = std::move(other221.sorting_columns);
+  file_offset = other221.file_offset;
+  total_compressed_size = other221.total_compressed_size;
+  ordinal = other221.ordinal;
+  __isset = other221.__isset;
+}
+RowGroup& RowGroup::operator=(const RowGroup& other222) {
+  columns = other222.columns;
+  total_byte_size = other222.total_byte_size;
+  num_rows = other222.num_rows;
+  sorting_columns = other222.sorting_columns;
+  file_offset = other222.file_offset;
+  total_compressed_size = other222.total_compressed_size;
+  ordinal = other222.ordinal;
+  __isset = other222.__isset;
   return *this;
 }
-RowGroup& RowGroup::operator=(RowGroup&& other219) noexcept {
-  columns = std::move(other219.columns);
-  total_byte_size = other219.total_byte_size;
-  num_rows = other219.num_rows;
-  sorting_columns = std::move(other219.sorting_columns);
-  file_offset = other219.file_offset;
-  total_compressed_size = other219.total_compressed_size;
-  ordinal = other219.ordinal;
-  __isset = other219.__isset;
+RowGroup& RowGroup::operator=(RowGroup&& other223) noexcept {
+  columns = std::move(other223.columns);
+  total_byte_size = other223.total_byte_size;
+  num_rows = other223.num_rows;
+  sorting_columns = std::move(other223.sorting_columns);
+  file_offset = other223.file_offset;
+  total_compressed_size = other223.total_compressed_size;
+  ordinal = other223.ordinal;
+  __isset = other223.__isset;
   return *this;
 }
 void RowGroup::printTo(std::ostream& out) const {
@@ -6733,18 +6832,18 @@ void swap(TypeDefinedOrder &a, TypeDefinedOrder &b) {
   (void) b;
 }
 
-TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other220) noexcept {
-  (void) other220;
+TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other224) noexcept {
+  (void) other224;
 }
-TypeDefinedOrder::TypeDefinedOrder(TypeDefinedOrder&& other221) noexcept {
-  (void) other221;
+TypeDefinedOrder::TypeDefinedOrder(TypeDefinedOrder&& other225) noexcept {
+  (void) other225;
 }
-TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other222) noexcept {
-  (void) other222;
+TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other226) noexcept {
+  (void) other226;
   return *this;
 }
-TypeDefinedOrder& TypeDefinedOrder::operator=(TypeDefinedOrder&& other223) noexcept {
-  (void) other223;
+TypeDefinedOrder& TypeDefinedOrder::operator=(TypeDefinedOrder&& other227) noexcept {
+  (void) other227;
   return *this;
 }
 void TypeDefinedOrder::printTo(std::ostream& out) const {
@@ -6831,22 +6930,22 @@ void swap(ColumnOrder &a, ColumnOrder &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnOrder::ColumnOrder(const ColumnOrder& other224) noexcept {
-  TYPE_ORDER = other224.TYPE_ORDER;
-  __isset = other224.__isset;
+ColumnOrder::ColumnOrder(const ColumnOrder& other228) noexcept {
+  TYPE_ORDER = other228.TYPE_ORDER;
+  __isset = other228.__isset;
 }
-ColumnOrder::ColumnOrder(ColumnOrder&& other225) noexcept {
-  TYPE_ORDER = std::move(other225.TYPE_ORDER);
-  __isset = other225.__isset;
+ColumnOrder::ColumnOrder(ColumnOrder&& other229) noexcept {
+  TYPE_ORDER = std::move(other229.TYPE_ORDER);
+  __isset = other229.__isset;
 }
-ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other226) noexcept {
-  TYPE_ORDER = other226.TYPE_ORDER;
-  __isset = other226.__isset;
+ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other230) noexcept {
+  TYPE_ORDER = other230.TYPE_ORDER;
+  __isset = other230.__isset;
   return *this;
 }
-ColumnOrder& ColumnOrder::operator=(ColumnOrder&& other227) noexcept {
-  TYPE_ORDER = std::move(other227.TYPE_ORDER);
-  __isset = other227.__isset;
+ColumnOrder& ColumnOrder::operator=(ColumnOrder&& other231) noexcept {
+  TYPE_ORDER = std::move(other231.TYPE_ORDER);
+  __isset = other231.__isset;
   return *this;
 }
 void ColumnOrder::printTo(std::ostream& out) const {
@@ -6974,26 +7073,26 @@ void swap(PageLocation &a, PageLocation &b) {
   swap(a.first_row_index, b.first_row_index);
 }
 
-PageLocation::PageLocation(const PageLocation& other228) noexcept {
-  offset = other228.offset;
-  compressed_page_size = other228.compressed_page_size;
-  first_row_index = other228.first_row_index;
+PageLocation::PageLocation(const PageLocation& other232) noexcept {
+  offset = other232.offset;
+  compressed_page_size = other232.compressed_page_size;
+  first_row_index = other232.first_row_index;
 }
-PageLocation::PageLocation(PageLocation&& other229) noexcept {
-  offset = other229.offset;
-  compressed_page_size = other229.compressed_page_size;
-  first_row_index = other229.first_row_index;
+PageLocation::PageLocation(PageLocation&& other233) noexcept {
+  offset = other233.offset;
+  compressed_page_size = other233.compressed_page_size;
+  first_row_index = other233.first_row_index;
 }
-PageLocation& PageLocation::operator=(const PageLocation& other230) noexcept {
-  offset = other230.offset;
-  compressed_page_size = other230.compressed_page_size;
-  first_row_index = other230.first_row_index;
+PageLocation& PageLocation::operator=(const PageLocation& other234) noexcept {
+  offset = other234.offset;
+  compressed_page_size = other234.compressed_page_size;
+  first_row_index = other234.first_row_index;
   return *this;
 }
-PageLocation& PageLocation::operator=(PageLocation&& other231) noexcept {
-  offset = other231.offset;
-  compressed_page_size = other231.compressed_page_size;
-  first_row_index = other231.first_row_index;
+PageLocation& PageLocation::operator=(PageLocation&& other235) noexcept {
+  offset = other235.offset;
+  compressed_page_size = other235.compressed_page_size;
+  first_row_index = other235.first_row_index;
   return *this;
 }
 void PageLocation::printTo(std::ostream& out) const {
@@ -7046,14 +7145,14 @@ uint32_t OffsetIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->page_locations.clear();
-            uint32_t _size232;
-            ::apache::thrift::protocol::TType _etype235;
-            xfer += iprot->readListBegin(_etype235, _size232);
-            this->page_locations.resize(_size232);
-            uint32_t _i236;
-            for (_i236 = 0; _i236 < _size232; ++_i236)
+            uint32_t _size236;
+            ::apache::thrift::protocol::TType _etype239;
+            xfer += iprot->readListBegin(_etype239, _size236);
+            this->page_locations.resize(_size236);
+            uint32_t _i240;
+            for (_i240 = 0; _i240 < _size236; ++_i240)
             {
-              xfer += this->page_locations[_i236].read(iprot);
+              xfer += this->page_locations[_i240].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7084,10 +7183,10 @@ uint32_t OffsetIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("page_locations", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->page_locations.size()));
-    std::vector<PageLocation> ::const_iterator _iter237;
-    for (_iter237 = this->page_locations.begin(); _iter237 != this->page_locations.end(); ++_iter237)
+    std::vector<PageLocation> ::const_iterator _iter241;
+    for (_iter241 = this->page_locations.begin(); _iter241 != this->page_locations.end(); ++_iter241)
     {
-      xfer += (*_iter237).write(oprot);
+      xfer += (*_iter241).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -7103,18 +7202,18 @@ void swap(OffsetIndex &a, OffsetIndex &b) {
   swap(a.page_locations, b.page_locations);
 }
 
-OffsetIndex::OffsetIndex(const OffsetIndex& other238) {
-  page_locations = other238.page_locations;
+OffsetIndex::OffsetIndex(const OffsetIndex& other242) {
+  page_locations = other242.page_locations;
 }
-OffsetIndex::OffsetIndex(OffsetIndex&& other239) noexcept {
-  page_locations = std::move(other239.page_locations);
+OffsetIndex::OffsetIndex(OffsetIndex&& other243) noexcept {
+  page_locations = std::move(other243.page_locations);
 }
-OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other240) {
-  page_locations = other240.page_locations;
+OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other244) {
+  page_locations = other244.page_locations;
   return *this;
 }
-OffsetIndex& OffsetIndex::operator=(OffsetIndex&& other241) noexcept {
-  page_locations = std::move(other241.page_locations);
+OffsetIndex& OffsetIndex::operator=(OffsetIndex&& other245) noexcept {
+  page_locations = std::move(other245.page_locations);
   return *this;
 }
 void OffsetIndex::printTo(std::ostream& out) const {
@@ -7185,14 +7284,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_pages.clear();
-            uint32_t _size242;
-            ::apache::thrift::protocol::TType _etype245;
-            xfer += iprot->readListBegin(_etype245, _size242);
-            this->null_pages.resize(_size242);
-            uint32_t _i246;
-            for (_i246 = 0; _i246 < _size242; ++_i246)
+            uint32_t _size246;
+            ::apache::thrift::protocol::TType _etype249;
+            xfer += iprot->readListBegin(_etype249, _size246);
+            this->null_pages.resize(_size246);
+            uint32_t _i250;
+            for (_i250 = 0; _i250 < _size246; ++_i250)
             {
-              xfer += iprot->readBool(this->null_pages[_i246]);
+              xfer += iprot->readBool(this->null_pages[_i250]);
             }
             xfer += iprot->readListEnd();
           }
@@ -7205,14 +7304,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->min_values.clear();
-            uint32_t _size247;
-            ::apache::thrift::protocol::TType _etype250;
-            xfer += iprot->readListBegin(_etype250, _size247);
-            this->min_values.resize(_size247);
-            uint32_t _i251;
-            for (_i251 = 0; _i251 < _size247; ++_i251)
+            uint32_t _size251;
+            ::apache::thrift::protocol::TType _etype254;
+            xfer += iprot->readListBegin(_etype254, _size251);
+            this->min_values.resize(_size251);
+            uint32_t _i255;
+            for (_i255 = 0; _i255 < _size251; ++_i255)
             {
-              xfer += iprot->readBinary(this->min_values[_i251]);
+              xfer += iprot->readBinary(this->min_values[_i255]);
             }
             xfer += iprot->readListEnd();
           }
@@ -7225,14 +7324,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->max_values.clear();
-            uint32_t _size252;
-            ::apache::thrift::protocol::TType _etype255;
-            xfer += iprot->readListBegin(_etype255, _size252);
-            this->max_values.resize(_size252);
-            uint32_t _i256;
-            for (_i256 = 0; _i256 < _size252; ++_i256)
+            uint32_t _size256;
+            ::apache::thrift::protocol::TType _etype259;
+            xfer += iprot->readListBegin(_etype259, _size256);
+            this->max_values.resize(_size256);
+            uint32_t _i260;
+            for (_i260 = 0; _i260 < _size256; ++_i260)
             {
-              xfer += iprot->readBinary(this->max_values[_i256]);
+              xfer += iprot->readBinary(this->max_values[_i260]);
             }
             xfer += iprot->readListEnd();
           }
@@ -7243,9 +7342,9 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast257;
-          xfer += iprot->readI32(ecast257);
-          this->boundary_order = static_cast<BoundaryOrder::type>(ecast257);
+          int32_t ecast261;
+          xfer += iprot->readI32(ecast261);
+          this->boundary_order = static_cast<BoundaryOrder::type>(ecast261);
           isset_boundary_order = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -7255,14 +7354,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_counts.clear();
-            uint32_t _size258;
-            ::apache::thrift::protocol::TType _etype261;
-            xfer += iprot->readListBegin(_etype261, _size258);
-            this->null_counts.resize(_size258);
-            uint32_t _i262;
-            for (_i262 = 0; _i262 < _size258; ++_i262)
+            uint32_t _size262;
+            ::apache::thrift::protocol::TType _etype265;
+            xfer += iprot->readListBegin(_etype265, _size262);
+            this->null_counts.resize(_size262);
+            uint32_t _i266;
+            for (_i266 = 0; _i266 < _size262; ++_i266)
             {
-              xfer += iprot->readI64(this->null_counts[_i262]);
+              xfer += iprot->readI64(this->null_counts[_i266]);
             }
             xfer += iprot->readListEnd();
           }
@@ -7299,10 +7398,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("null_pages", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->null_pages.size()));
-    std::vector<bool> ::const_iterator _iter263;
-    for (_iter263 = this->null_pages.begin(); _iter263 != this->null_pages.end(); ++_iter263)
+    std::vector<bool> ::const_iterator _iter267;
+    for (_iter267 = this->null_pages.begin(); _iter267 != this->null_pages.end(); ++_iter267)
     {
-      xfer += oprot->writeBool((*_iter263));
+      xfer += oprot->writeBool((*_iter267));
     }
     xfer += oprot->writeListEnd();
   }
@@ -7311,10 +7410,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("min_values", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->min_values.size()));
-    std::vector<std::string> ::const_iterator _iter264;
-    for (_iter264 = this->min_values.begin(); _iter264 != this->min_values.end(); ++_iter264)
+    std::vector<std::string> ::const_iterator _iter268;
+    for (_iter268 = this->min_values.begin(); _iter268 != this->min_values.end(); ++_iter268)
     {
-      xfer += oprot->writeBinary((*_iter264));
+      xfer += oprot->writeBinary((*_iter268));
     }
     xfer += oprot->writeListEnd();
   }
@@ -7323,10 +7422,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("max_values", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->max_values.size()));
-    std::vector<std::string> ::const_iterator _iter265;
-    for (_iter265 = this->max_values.begin(); _iter265 != this->max_values.end(); ++_iter265)
+    std::vector<std::string> ::const_iterator _iter269;
+    for (_iter269 = this->max_values.begin(); _iter269 != this->max_values.end(); ++_iter269)
     {
-      xfer += oprot->writeBinary((*_iter265));
+      xfer += oprot->writeBinary((*_iter269));
     }
     xfer += oprot->writeListEnd();
   }
@@ -7340,10 +7439,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("null_counts", ::apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->null_counts.size()));
-      std::vector<int64_t> ::const_iterator _iter266;
-      for (_iter266 = this->null_counts.begin(); _iter266 != this->null_counts.end(); ++_iter266)
+      std::vector<int64_t> ::const_iterator _iter270;
+      for (_iter270 = this->null_counts.begin(); _iter270 != this->null_counts.end(); ++_iter270)
       {
-        xfer += oprot->writeI64((*_iter266));
+        xfer += oprot->writeI64((*_iter270));
       }
       xfer += oprot->writeListEnd();
     }
@@ -7364,38 +7463,38 @@ void swap(ColumnIndex &a, ColumnIndex &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnIndex::ColumnIndex(const ColumnIndex& other267) {
-  null_pages = other267.null_pages;
-  min_values = other267.min_values;
-  max_values = other267.max_values;
-  boundary_order = other267.boundary_order;
-  null_counts = other267.null_counts;
-  __isset = other267.__isset;
-}
-ColumnIndex::ColumnIndex(ColumnIndex&& other268) noexcept {
-  null_pages = std::move(other268.null_pages);
-  min_values = std::move(other268.min_values);
-  max_values = std::move(other268.max_values);
-  boundary_order = other268.boundary_order;
-  null_counts = std::move(other268.null_counts);
-  __isset = other268.__isset;
-}
-ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other269) {
-  null_pages = other269.null_pages;
-  min_values = other269.min_values;
-  max_values = other269.max_values;
-  boundary_order = other269.boundary_order;
-  null_counts = other269.null_counts;
-  __isset = other269.__isset;
+ColumnIndex::ColumnIndex(const ColumnIndex& other271) {
+  null_pages = other271.null_pages;
+  min_values = other271.min_values;
+  max_values = other271.max_values;
+  boundary_order = other271.boundary_order;
+  null_counts = other271.null_counts;
+  __isset = other271.__isset;
+}
+ColumnIndex::ColumnIndex(ColumnIndex&& other272) noexcept {
+  null_pages = std::move(other272.null_pages);
+  min_values = std::move(other272.min_values);
+  max_values = std::move(other272.max_values);
+  boundary_order = other272.boundary_order;
+  null_counts = std::move(other272.null_counts);
+  __isset = other272.__isset;
+}
+ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other273) {
+  null_pages = other273.null_pages;
+  min_values = other273.min_values;
+  max_values = other273.max_values;
+  boundary_order = other273.boundary_order;
+  null_counts = other273.null_counts;
+  __isset = other273.__isset;
   return *this;
 }
-ColumnIndex& ColumnIndex::operator=(ColumnIndex&& other270) noexcept {
-  null_pages = std::move(other270.null_pages);
-  min_values = std::move(other270.min_values);
-  max_values = std::move(other270.max_values);
-  boundary_order = other270.boundary_order;
-  null_counts = std::move(other270.null_counts);
-  __isset = other270.__isset;
+ColumnIndex& ColumnIndex::operator=(ColumnIndex&& other274) noexcept {
+  null_pages = std::move(other274.null_pages);
+  min_values = std::move(other274.min_values);
+  max_values = std::move(other274.max_values);
+  boundary_order = other274.boundary_order;
+  null_counts = std::move(other274.null_counts);
+  __isset = other274.__isset;
   return *this;
 }
 void ColumnIndex::printTo(std::ostream& out) const {
@@ -7525,30 +7624,30 @@ void swap(AesGcmV1 &a, AesGcmV1 &b) {
   swap(a.__isset, b.__isset);
 }
 
-AesGcmV1::AesGcmV1(const AesGcmV1& other271) {
-  aad_prefix = other271.aad_prefix;
-  aad_file_unique = other271.aad_file_unique;
-  supply_aad_prefix = other271.supply_aad_prefix;
-  __isset = other271.__isset;
+AesGcmV1::AesGcmV1(const AesGcmV1& other275) {
+  aad_prefix = other275.aad_prefix;
+  aad_file_unique = other275.aad_file_unique;
+  supply_aad_prefix = other275.supply_aad_prefix;
+  __isset = other275.__isset;
 }
-AesGcmV1::AesGcmV1(AesGcmV1&& other272) noexcept {
-  aad_prefix = std::move(other272.aad_prefix);
-  aad_file_unique = std::move(other272.aad_file_unique);
-  supply_aad_prefix = other272.supply_aad_prefix;
-  __isset = other272.__isset;
+AesGcmV1::AesGcmV1(AesGcmV1&& other276) noexcept {
+  aad_prefix = std::move(other276.aad_prefix);
+  aad_file_unique = std::move(other276.aad_file_unique);
+  supply_aad_prefix = other276.supply_aad_prefix;
+  __isset = other276.__isset;
 }
-AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other273) {
-  aad_prefix = other273.aad_prefix;
-  aad_file_unique = other273.aad_file_unique;
-  supply_aad_prefix = other273.supply_aad_prefix;
-  __isset = other273.__isset;
+AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other277) {
+  aad_prefix = other277.aad_prefix;
+  aad_file_unique = other277.aad_file_unique;
+  supply_aad_prefix = other277.supply_aad_prefix;
+  __isset = other277.__isset;
   return *this;
 }
-AesGcmV1& AesGcmV1::operator=(AesGcmV1&& other274) noexcept {
-  aad_prefix = std::move(other274.aad_prefix);
-  aad_file_unique = std::move(other274.aad_file_unique);
-  supply_aad_prefix = other274.supply_aad_prefix;
-  __isset = other274.__isset;
+AesGcmV1& AesGcmV1::operator=(AesGcmV1&& other278) noexcept {
+  aad_prefix = std::move(other278.aad_prefix);
+  aad_file_unique = std::move(other278.aad_file_unique);
+  supply_aad_prefix = other278.supply_aad_prefix;
+  __isset = other278.__isset;
   return *this;
 }
 void AesGcmV1::printTo(std::ostream& out) const {
@@ -7676,30 +7775,30 @@ void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b) {
   swap(a.__isset, b.__isset);
 }
 
-AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other275) {
-  aad_prefix = other275.aad_prefix;
-  aad_file_unique = other275.aad_file_unique;
-  supply_aad_prefix = other275.supply_aad_prefix;
-  __isset = other275.__isset;
+AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other279) {
+  aad_prefix = other279.aad_prefix;
+  aad_file_unique = other279.aad_file_unique;
+  supply_aad_prefix = other279.supply_aad_prefix;
+  __isset = other279.__isset;
 }
-AesGcmCtrV1::AesGcmCtrV1(AesGcmCtrV1&& other276) noexcept {
-  aad_prefix = std::move(other276.aad_prefix);
-  aad_file_unique = std::move(other276.aad_file_unique);
-  supply_aad_prefix = other276.supply_aad_prefix;
-  __isset = other276.__isset;
+AesGcmCtrV1::AesGcmCtrV1(AesGcmCtrV1&& other280) noexcept {
+  aad_prefix = std::move(other280.aad_prefix);
+  aad_file_unique = std::move(other280.aad_file_unique);
+  supply_aad_prefix = other280.supply_aad_prefix;
+  __isset = other280.__isset;
 }
-AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other277) {
-  aad_prefix = other277.aad_prefix;
-  aad_file_unique = other277.aad_file_unique;
-  supply_aad_prefix = other277.supply_aad_prefix;
-  __isset = other277.__isset;
+AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other281) {
+  aad_prefix = other281.aad_prefix;
+  aad_file_unique = other281.aad_file_unique;
+  supply_aad_prefix = other281.supply_aad_prefix;
+  __isset = other281.__isset;
   return *this;
 }
-AesGcmCtrV1& AesGcmCtrV1::operator=(AesGcmCtrV1&& other278) noexcept {
-  aad_prefix = std::move(other278.aad_prefix);
-  aad_file_unique = std::move(other278.aad_file_unique);
-  supply_aad_prefix = other278.supply_aad_prefix;
-  __isset = other278.__isset;
+AesGcmCtrV1& AesGcmCtrV1::operator=(AesGcmCtrV1&& other282) noexcept {
+  aad_prefix = std::move(other282.aad_prefix);
+  aad_file_unique = std::move(other282.aad_file_unique);
+  supply_aad_prefix = other282.supply_aad_prefix;
+  __isset = other282.__isset;
   return *this;
 }
 void AesGcmCtrV1::printTo(std::ostream& out) const {
@@ -7808,26 +7907,26 @@ void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b) {
   swap(a.__isset, b.__isset);
 }
 
-EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other279) {
-  AES_GCM_V1 = other279.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other279.AES_GCM_CTR_V1;
-  __isset = other279.__isset;
+EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other283) {
+  AES_GCM_V1 = other283.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other283.AES_GCM_CTR_V1;
+  __isset = other283.__isset;
 }
-EncryptionAlgorithm::EncryptionAlgorithm(EncryptionAlgorithm&& other280) noexcept {
-  AES_GCM_V1 = std::move(other280.AES_GCM_V1);
-  AES_GCM_CTR_V1 = std::move(other280.AES_GCM_CTR_V1);
-  __isset = other280.__isset;
+EncryptionAlgorithm::EncryptionAlgorithm(EncryptionAlgorithm&& other284) noexcept {
+  AES_GCM_V1 = std::move(other284.AES_GCM_V1);
+  AES_GCM_CTR_V1 = std::move(other284.AES_GCM_CTR_V1);
+  __isset = other284.__isset;
 }
-EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other281) {
-  AES_GCM_V1 = other281.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other281.AES_GCM_CTR_V1;
-  __isset = other281.__isset;
+EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other285) {
+  AES_GCM_V1 = other285.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other285.AES_GCM_CTR_V1;
+  __isset = other285.__isset;
   return *this;
 }
-EncryptionAlgorithm& EncryptionAlgorithm::operator=(EncryptionAlgorithm&& other282) noexcept {
-  AES_GCM_V1 = std::move(other282.AES_GCM_V1);
-  AES_GCM_CTR_V1 = std::move(other282.AES_GCM_CTR_V1);
-  __isset = other282.__isset;
+EncryptionAlgorithm& EncryptionAlgorithm::operator=(EncryptionAlgorithm&& other286) noexcept {
+  AES_GCM_V1 = std::move(other286.AES_GCM_V1);
+  AES_GCM_CTR_V1 = std::move(other286.AES_GCM_CTR_V1);
+  __isset = other286.__isset;
   return *this;
 }
 void EncryptionAlgorithm::printTo(std::ostream& out) const {
@@ -7927,14 +8026,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->schema.clear();
-            uint32_t _size283;
-            ::apache::thrift::protocol::TType _etype286;
-            xfer += iprot->readListBegin(_etype286, _size283);
-            this->schema.resize(_size283);
-            uint32_t _i287;
-            for (_i287 = 0; _i287 < _size283; ++_i287)
+            uint32_t _size287;
+            ::apache::thrift::protocol::TType _etype290;
+            xfer += iprot->readListBegin(_etype290, _size287);
+            this->schema.resize(_size287);
+            uint32_t _i291;
+            for (_i291 = 0; _i291 < _size287; ++_i291)
             {
-              xfer += this->schema[_i287].read(iprot);
+              xfer += this->schema[_i291].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7955,14 +8054,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->row_groups.clear();
-            uint32_t _size288;
-            ::apache::thrift::protocol::TType _etype291;
-            xfer += iprot->readListBegin(_etype291, _size288);
-            this->row_groups.resize(_size288);
-            uint32_t _i292;
-            for (_i292 = 0; _i292 < _size288; ++_i292)
+            uint32_t _size292;
+            ::apache::thrift::protocol::TType _etype295;
+            xfer += iprot->readListBegin(_etype295, _size292);
+            this->row_groups.resize(_size292);
+            uint32_t _i296;
+            for (_i296 = 0; _i296 < _size292; ++_i296)
             {
-              xfer += this->row_groups[_i292].read(iprot);
+              xfer += this->row_groups[_i296].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -7975,14 +8074,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->key_value_metadata.clear();
-            uint32_t _size293;
-            ::apache::thrift::protocol::TType _etype296;
-            xfer += iprot->readListBegin(_etype296, _size293);
-            this->key_value_metadata.resize(_size293);
-            uint32_t _i297;
-            for (_i297 = 0; _i297 < _size293; ++_i297)
+            uint32_t _size297;
+            ::apache::thrift::protocol::TType _etype300;
+            xfer += iprot->readListBegin(_etype300, _size297);
+            this->key_value_metadata.resize(_size297);
+            uint32_t _i301;
+            for (_i301 = 0; _i301 < _size297; ++_i301)
             {
-              xfer += this->key_value_metadata[_i297].read(iprot);
+              xfer += this->key_value_metadata[_i301].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8003,14 +8102,14 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->column_orders.clear();
-            uint32_t _size298;
-            ::apache::thrift::protocol::TType _etype301;
-            xfer += iprot->readListBegin(_etype301, _size298);
-            this->column_orders.resize(_size298);
-            uint32_t _i302;
-            for (_i302 = 0; _i302 < _size298; ++_i302)
+            uint32_t _size302;
+            ::apache::thrift::protocol::TType _etype305;
+            xfer += iprot->readListBegin(_etype305, _size302);
+            this->column_orders.resize(_size302);
+            uint32_t _i306;
+            for (_i306 = 0; _i306 < _size302; ++_i306)
             {
-              xfer += this->column_orders[_i302].read(iprot);
+              xfer += this->column_orders[_i306].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8067,10 +8166,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    std::vector<SchemaElement> ::const_iterator _iter303;
-    for (_iter303 = this->schema.begin(); _iter303 != this->schema.end(); ++_iter303)
+    std::vector<SchemaElement> ::const_iterator _iter307;
+    for (_iter307 = this->schema.begin(); _iter307 != this->schema.end(); ++_iter307)
     {
-      xfer += (*_iter303).write(oprot);
+      xfer += (*_iter307).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8083,10 +8182,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    std::vector<RowGroup> ::const_iterator _iter304;
-    for (_iter304 = this->row_groups.begin(); _iter304 != this->row_groups.end(); ++_iter304)
+    std::vector<RowGroup> ::const_iterator _iter308;
+    for (_iter308 = this->row_groups.begin(); _iter308 != this->row_groups.end(); ++_iter308)
     {
-      xfer += (*_iter304).write(oprot);
+      xfer += (*_iter308).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8096,10 +8195,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter305;
-      for (_iter305 = this->key_value_metadata.begin(); _iter305 != this->key_value_metadata.end(); ++_iter305)
+      std::vector<KeyValue> ::const_iterator _iter309;
+      for (_iter309 = this->key_value_metadata.begin(); _iter309 != this->key_value_metadata.end(); ++_iter309)
       {
-        xfer += (*_iter305).write(oprot);
+        xfer += (*_iter309).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -8114,10 +8213,10 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("column_orders", ::apache::thrift::protocol::T_LIST, 7);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
-      std::vector<ColumnOrder> ::const_iterator _iter306;
-      for (_iter306 = this->column_orders.begin(); _iter306 != this->column_orders.end(); ++_iter306)
+      std::vector<ColumnOrder> ::const_iterator _iter310;
+      for (_iter310 = this->column_orders.begin(); _iter310 != this->column_orders.end(); ++_iter310)
       {
-        xfer += (*_iter306).write(oprot);
+        xfer += (*_iter310).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -8152,54 +8251,54 @@ void swap(FileMetaData &a, FileMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-FileMetaData::FileMetaData(const FileMetaData& other307) {
-  version = other307.version;
-  schema = other307.schema;
-  num_rows = other307.num_rows;
-  row_groups = other307.row_groups;
-  key_value_metadata = other307.key_value_metadata;
-  created_by = other307.created_by;
-  column_orders = other307.column_orders;
-  encryption_algorithm = other307.encryption_algorithm;
-  footer_signing_key_metadata = other307.footer_signing_key_metadata;
-  __isset = other307.__isset;
-}
-FileMetaData::FileMetaData(FileMetaData&& other308) noexcept {
-  version = other308.version;
-  schema = std::move(other308.schema);
-  num_rows = other308.num_rows;
-  row_groups = std::move(other308.row_groups);
-  key_value_metadata = std::move(other308.key_value_metadata);
-  created_by = std::move(other308.created_by);
-  column_orders = std::move(other308.column_orders);
-  encryption_algorithm = std::move(other308.encryption_algorithm);
-  footer_signing_key_metadata = std::move(other308.footer_signing_key_metadata);
-  __isset = other308.__isset;
-}
-FileMetaData& FileMetaData::operator=(const FileMetaData& other309) {
-  version = other309.version;
-  schema = other309.schema;
-  num_rows = other309.num_rows;
-  row_groups = other309.row_groups;
-  key_value_metadata = other309.key_value_metadata;
-  created_by = other309.created_by;
-  column_orders = other309.column_orders;
-  encryption_algorithm = other309.encryption_algorithm;
-  footer_signing_key_metadata = other309.footer_signing_key_metadata;
-  __isset = other309.__isset;
+FileMetaData::FileMetaData(const FileMetaData& other311) {
+  version = other311.version;
+  schema = other311.schema;
+  num_rows = other311.num_rows;
+  row_groups = other311.row_groups;
+  key_value_metadata = other311.key_value_metadata;
+  created_by = other311.created_by;
+  column_orders = other311.column_orders;
+  encryption_algorithm = other311.encryption_algorithm;
+  footer_signing_key_metadata = other311.footer_signing_key_metadata;
+  __isset = other311.__isset;
+}
+FileMetaData::FileMetaData(FileMetaData&& other312) noexcept {
+  version = other312.version;
+  schema = std::move(other312.schema);
+  num_rows = other312.num_rows;
+  row_groups = std::move(other312.row_groups);
+  key_value_metadata = std::move(other312.key_value_metadata);
+  created_by = std::move(other312.created_by);
+  column_orders = std::move(other312.column_orders);
+  encryption_algorithm = std::move(other312.encryption_algorithm);
+  footer_signing_key_metadata = std::move(other312.footer_signing_key_metadata);
+  __isset = other312.__isset;
+}
+FileMetaData& FileMetaData::operator=(const FileMetaData& other313) {
+  version = other313.version;
+  schema = other313.schema;
+  num_rows = other313.num_rows;
+  row_groups = other313.row_groups;
+  key_value_metadata = other313.key_value_metadata;
+  created_by = other313.created_by;
+  column_orders = other313.column_orders;
+  encryption_algorithm = other313.encryption_algorithm;
+  footer_signing_key_metadata = other313.footer_signing_key_metadata;
+  __isset = other313.__isset;
   return *this;
 }
-FileMetaData& FileMetaData::operator=(FileMetaData&& other310) noexcept {
-  version = other310.version;
-  schema = std::move(other310.schema);
-  num_rows = other310.num_rows;
-  row_groups = std::move(other310.row_groups);
-  key_value_metadata = std::move(other310.key_value_metadata);
-  created_by = std::move(other310.created_by);
-  column_orders = std::move(other310.column_orders);
-  encryption_algorithm = std::move(other310.encryption_algorithm);
-  footer_signing_key_metadata = std::move(other310.footer_signing_key_metadata);
-  __isset = other310.__isset;
+FileMetaData& FileMetaData::operator=(FileMetaData&& other314) noexcept {
+  version = other314.version;
+  schema = std::move(other314.schema);
+  num_rows = other314.num_rows;
+  row_groups = std::move(other314.row_groups);
+  key_value_metadata = std::move(other314.key_value_metadata);
+  created_by = std::move(other314.created_by);
+  column_orders = std::move(other314.column_orders);
+  encryption_algorithm = std::move(other314.encryption_algorithm);
+  footer_signing_key_metadata = std::move(other314.footer_signing_key_metadata);
+  __isset = other314.__isset;
   return *this;
 }
 void FileMetaData::printTo(std::ostream& out) const {
@@ -8315,26 +8414,26 @@ void swap(FileCryptoMetaData &a, FileCryptoMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other311) {
-  encryption_algorithm = other311.encryption_algorithm;
-  key_metadata = other311.key_metadata;
-  __isset = other311.__isset;
+FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other315) {
+  encryption_algorithm = other315.encryption_algorithm;
+  key_metadata = other315.key_metadata;
+  __isset = other315.__isset;
 }
-FileCryptoMetaData::FileCryptoMetaData(FileCryptoMetaData&& other312) noexcept {
-  encryption_algorithm = std::move(other312.encryption_algorithm);
-  key_metadata = std::move(other312.key_metadata);
-  __isset = other312.__isset;
+FileCryptoMetaData::FileCryptoMetaData(FileCryptoMetaData&& other316) noexcept {
+  encryption_algorithm = std::move(other316.encryption_algorithm);
+  key_metadata = std::move(other316.key_metadata);
+  __isset = other316.__isset;
 }
-FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other313) {
-  encryption_algorithm = other313.encryption_algorithm;
-  key_metadata = other313.key_metadata;
-  __isset = other313.__isset;
+FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other317) {
+  encryption_algorithm = other317.encryption_algorithm;
+  key_metadata = other317.key_metadata;
+  __isset = other317.__isset;
   return *this;
 }
-FileCryptoMetaData& FileCryptoMetaData::operator=(FileCryptoMetaData&& other314) noexcept {
-  encryption_algorithm = std::move(other314.encryption_algorithm);
-  key_metadata = std::move(other314.key_metadata);
-  __isset = other314.__isset;
+FileCryptoMetaData& FileCryptoMetaData::operator=(FileCryptoMetaData&& other318) noexcept {
+  encryption_algorithm = std::move(other318.encryption_algorithm);
+  key_metadata = std::move(other318.key_metadata);
+  __isset = other318.__isset;
   return *this;
 }
 void FileCryptoMetaData::printTo(std::ostream& out) const {
diff --git a/cpp/src/generated/parquet_types.h b/cpp/src/generated/parquet_types.h
index 9f468b5051db3..199b4ae747667 100644
--- a/cpp/src/generated/parquet_types.h
+++ b/cpp/src/generated/parquet_types.h
@@ -359,6 +359,8 @@ class EnumType;
 
 class DateType;
 
+class Float16Type;
+
 class NullType;
 
 class DecimalType;
@@ -770,6 +772,39 @@ void swap(DateType &a, DateType &b);
 std::ostream& operator<<(std::ostream& out, const DateType& obj);
 
 
+class Float16Type : public virtual ::apache::thrift::TBase {
+ public:
+
+  Float16Type(const Float16Type&) noexcept;
+  Float16Type(Float16Type&&) noexcept;
+  Float16Type& operator=(const Float16Type&) noexcept;
+  Float16Type& operator=(Float16Type&&) noexcept;
+  Float16Type() noexcept {
+  }
+
+  virtual ~Float16Type() noexcept;
+
+  bool operator == (const Float16Type & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const Float16Type &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Float16Type & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot) override;
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const override;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Float16Type &a, Float16Type &b);
+
+std::ostream& operator<<(std::ostream& out, const Float16Type& obj);
+
+
 /**
  * Logical type to annotate a column that is always null.
  * 
@@ -1253,7 +1288,7 @@ void swap(BsonType &a, BsonType &b);
 std::ostream& operator<<(std::ostream& out, const BsonType& obj);
 
 typedef struct _LogicalType__isset {
-  _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false), UUID(false) {}
+  _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false), UUID(false), FLOAT16(false) {}
   bool STRING :1;
   bool MAP :1;
   bool LIST :1;
@@ -1267,6 +1302,7 @@ typedef struct _LogicalType__isset {
   bool JSON :1;
   bool BSON :1;
   bool UUID :1;
+  bool FLOAT16 :1;
 } _LogicalType__isset;
 
 /**
@@ -1300,6 +1336,7 @@ class LogicalType : public virtual ::apache::thrift::TBase {
   JsonType JSON;
   BsonType BSON;
   UUIDType UUID;
+  Float16Type FLOAT16;
 
   _LogicalType__isset __isset;
 
@@ -1329,6 +1366,8 @@ class LogicalType : public virtual ::apache::thrift::TBase {
 
   void __set_UUID(const UUIDType& val);
 
+  void __set_FLOAT16(const Float16Type& val);
+
   bool operator == (const LogicalType & rhs) const
   {
     if (__isset.STRING != rhs.__isset.STRING)
@@ -1383,6 +1422,10 @@ class LogicalType : public virtual ::apache::thrift::TBase {
       return false;
     else if (__isset.UUID && !(UUID == rhs.UUID))
       return false;
+    if (__isset.FLOAT16 != rhs.__isset.FLOAT16)
+      return false;
+    else if (__isset.FLOAT16 && !(FLOAT16 == rhs.FLOAT16))
+      return false;
     return true;
   }
   bool operator != (const LogicalType &rhs) const {
diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index 4e23d0fab5c69..fb9e53870583c 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -143,6 +143,8 @@ std::shared_ptr<const LogicalType> get_logical_type(const DataType& type) {
       return LogicalType::Date();
     case ArrowId::DATE64:
       return LogicalType::Date();
+    case ArrowId::HALF_FLOAT:
+      return LogicalType::Float16();
     case ArrowId::TIMESTAMP: {
       const auto& ts_type = static_cast<const ::arrow::TimestampType&>(type);
       const bool adjusted_to_utc = !(ts_type.timezone().empty());
@@ -220,6 +222,7 @@ ParquetType::type get_physical_type(const DataType& type) {
     case ArrowId::FIXED_SIZE_BINARY:
     case ArrowId::DECIMAL128:
     case ArrowId::DECIMAL256:
+    case ArrowId::HALF_FLOAT:
       return ParquetType::FIXED_LEN_BYTE_ARRAY;
     case ArrowId::DATE32:
       return ParquetType::INT32;
@@ -525,6 +528,9 @@ static std::shared_ptr<GroupNode> MakeSimpleSchema(const DataType& type,
           byte_width =
               static_cast<const ::arrow::FixedSizeBinaryType&>(values_type).byte_width();
           break;
+        case ::arrow::Type::HALF_FLOAT:
+          byte_width = sizeof(::arrow::HalfFloatType::c_type);
+          break;
         case ::arrow::Type::DECIMAL128:
         case ::arrow::Type::DECIMAL256: {
           const auto& decimal_type = static_cast<const DecimalType&>(values_type);
@@ -537,6 +543,9 @@ static std::shared_ptr<GroupNode> MakeSimpleSchema(const DataType& type,
     case ::arrow::Type::FIXED_SIZE_BINARY:
       byte_width = static_cast<const ::arrow::FixedSizeBinaryType&>(type).byte_width();
       break;
+    case ::arrow::Type::HALF_FLOAT:
+      byte_width = sizeof(::arrow::HalfFloatType::c_type);
+      break;
     case ::arrow::Type::DECIMAL128:
     case ::arrow::Type::DECIMAL256: {
       const auto& decimal_type = static_cast<const DecimalType&>(type);
@@ -840,12 +849,12 @@ typedef ::testing::Types<
     ::arrow::BooleanType, ::arrow::UInt8Type, ::arrow::Int8Type, ::arrow::UInt16Type,
     ::arrow::Int16Type, ::arrow::Int32Type, ::arrow::UInt64Type, ::arrow::Int64Type,
     ::arrow::Date32Type, ::arrow::FloatType, ::arrow::DoubleType, ::arrow::StringType,
-    ::arrow::BinaryType, ::arrow::FixedSizeBinaryType, DecimalWithPrecisionAndScale<1>,
-    DecimalWithPrecisionAndScale<5>, DecimalWithPrecisionAndScale<10>,
-    DecimalWithPrecisionAndScale<19>, DecimalWithPrecisionAndScale<23>,
-    DecimalWithPrecisionAndScale<27>, DecimalWithPrecisionAndScale<38>,
-    Decimal256WithPrecisionAndScale<39>, Decimal256WithPrecisionAndScale<56>,
-    Decimal256WithPrecisionAndScale<76>>
+    ::arrow::BinaryType, ::arrow::FixedSizeBinaryType, ::arrow::HalfFloatType,
+    DecimalWithPrecisionAndScale<1>, DecimalWithPrecisionAndScale<5>,
+    DecimalWithPrecisionAndScale<10>, DecimalWithPrecisionAndScale<19>,
+    DecimalWithPrecisionAndScale<23>, DecimalWithPrecisionAndScale<27>,
+    DecimalWithPrecisionAndScale<38>, Decimal256WithPrecisionAndScale<39>,
+    Decimal256WithPrecisionAndScale<56>, Decimal256WithPrecisionAndScale<76>>
     TestTypes;
 
 TYPED_TEST_SUITE(TestParquetIO, TestTypes);
@@ -916,9 +925,15 @@ TYPED_TEST(TestParquetIO, SingleColumnOptionalReadWrite) {
 }
 
 TYPED_TEST(TestParquetIO, SingleColumnOptionalDictionaryWrite) {
-  // Skip tests for BOOL as we don't create dictionaries for it.
-  if (TypeParam::type_id == ::arrow::Type::BOOL) {
-    return;
+  switch (TypeParam::type_id) {
+    case ::arrow::Type::BOOL:
+      GTEST_SKIP() << "dictionaries not created for BOOL";
+      break;
+    case ::arrow::Type::HALF_FLOAT:
+      GTEST_SKIP() << "dictionary_encode not supported for HALF_FLOAT";
+      break;
+    default:
+      break;
   }
 
   std::shared_ptr<Array> values;
diff --git a/cpp/src/parquet/arrow/arrow_schema_test.cc b/cpp/src/parquet/arrow/arrow_schema_test.cc
index f11101eb24298..5443214f930d7 100644
--- a/cpp/src/parquet/arrow/arrow_schema_test.cc
+++ b/cpp/src/parquet/arrow/arrow_schema_test.cc
@@ -236,6 +236,8 @@ TEST_F(TestConvertParquetSchema, ParquetAnnotatedFields) {
        ::arrow::fixed_size_binary(12)},
       {"uuid", LogicalType::UUID(), ParquetType::FIXED_LEN_BYTE_ARRAY, 16,
        ::arrow::fixed_size_binary(16)},
+      {"float16", LogicalType::Float16(), ParquetType::FIXED_LEN_BYTE_ARRAY, 2,
+       ::arrow::float16()},
       {"none", LogicalType::None(), ParquetType::BOOLEAN, -1, ::arrow::boolean()},
       {"none", LogicalType::None(), ParquetType::INT32, -1, ::arrow::int32()},
       {"none", LogicalType::None(), ParquetType::INT64, -1, ::arrow::int64()},
@@ -851,6 +853,8 @@ TEST_F(TestConvertArrowSchema, ArrowFields) {
        ParquetType::FIXED_LEN_BYTE_ARRAY, 7},
       {"decimal(32, 8)", ::arrow::decimal(32, 8), LogicalType::Decimal(32, 8),
        ParquetType::FIXED_LEN_BYTE_ARRAY, 14},
+      {"float16", ::arrow::float16(), LogicalType::Float16(),
+       ParquetType::FIXED_LEN_BYTE_ARRAY, 2},
       {"time32", ::arrow::time32(::arrow::TimeUnit::MILLI),
        LogicalType::Time(true, LogicalType::TimeUnit::MILLIS), ParquetType::INT32, -1},
       {"time64(microsecond)", ::arrow::time64(::arrow::TimeUnit::MICRO),
@@ -913,7 +917,8 @@ TEST_F(TestConvertArrowSchema, ArrowNonconvertibleFields) {
   };
 
   std::vector<FieldConstructionArguments> cases = {
-      {"float16", ::arrow::float16()},
+      {"run_end_encoded",
+       ::arrow::run_end_encoded(::arrow::int32(), ::arrow::list(::arrow::int8()))},
   };
 
   for (const FieldConstructionArguments& c : cases) {
diff --git a/cpp/src/parquet/arrow/reader_internal.cc b/cpp/src/parquet/arrow/reader_internal.cc
index 5146aa12c2c36..e5aef5a45b5f3 100644
--- a/cpp/src/parquet/arrow/reader_internal.cc
+++ b/cpp/src/parquet/arrow/reader_internal.cc
@@ -42,6 +42,7 @@
 #include "arrow/util/bit_util.h"
 #include "arrow/util/checked_cast.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/float16.h"
 #include "arrow/util/int_util_overflow.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ubsan.h"
@@ -82,6 +83,7 @@ using ::arrow::bit_util::FromBigEndian;
 using ::arrow::internal::checked_cast;
 using ::arrow::internal::checked_pointer_cast;
 using ::arrow::internal::SafeLeftShift;
+using ::arrow::util::Float16;
 using ::arrow::util::SafeLoadAs;
 
 using parquet::internal::BinaryRecordReader;
@@ -713,6 +715,17 @@ Status TransferDecimal(RecordReader* reader, MemoryPool* pool,
   return Status::OK();
 }
 
+Status TransferHalfFloat(RecordReader* reader, MemoryPool* pool,
+                         const std::shared_ptr<Field>& field, Datum* out) {
+  static const auto binary_type = ::arrow::fixed_size_binary(2);
+  // Read as a FixedSizeBinaryArray - then, view as a HalfFloatArray
+  std::shared_ptr<ChunkedArray> chunked_array;
+  RETURN_NOT_OK(
+      TransferBinary(reader, pool, field->WithType(binary_type), &chunked_array));
+  ARROW_ASSIGN_OR_RAISE(*out, chunked_array->View(field->type()));
+  return Status::OK();
+}
+
 }  // namespace
 
 #define TRANSFER_INT32(ENUM, ArrowType)                                               \
@@ -772,6 +785,18 @@ Status TransferColumnData(RecordReader* reader, const std::shared_ptr<Field>& va
       RETURN_NOT_OK(TransferBinary(reader, pool, value_field, &chunked_result));
       result = chunked_result;
     } break;
+    case ::arrow::Type::HALF_FLOAT: {
+      const auto& type = *value_field->type();
+      if (descr->physical_type() != ::parquet::Type::FIXED_LEN_BYTE_ARRAY) {
+        return Status::Invalid("Physical type for ", type.ToString(),
+                               " must be fixed length binary");
+      }
+      if (descr->type_length() != type.byte_width()) {
+        return Status::Invalid("Fixed length binary type for ", type.ToString(),
+                               " must have a byte width of ", type.byte_width());
+      }
+      RETURN_NOT_OK(TransferHalfFloat(reader, pool, value_field, &result));
+    } break;
     case ::arrow::Type::DECIMAL128: {
       switch (descr->physical_type()) {
         case ::parquet::Type::INT32: {
diff --git a/cpp/src/parquet/arrow/schema.cc b/cpp/src/parquet/arrow/schema.cc
index 3323b7ff8b608..f5484f131eb07 100644
--- a/cpp/src/parquet/arrow/schema.cc
+++ b/cpp/src/parquet/arrow/schema.cc
@@ -397,6 +397,11 @@ Status FieldToNode(const std::string& name, const std::shared_ptr<Field>& field,
     case ArrowTypeId::DURATION:
       type = ParquetType::INT64;
       break;
+    case ArrowTypeId::HALF_FLOAT:
+      type = ParquetType::FIXED_LEN_BYTE_ARRAY;
+      logical_type = LogicalType::Float16();
+      length = sizeof(uint16_t);
+      break;
     case ArrowTypeId::STRUCT: {
       auto struct_type = std::static_pointer_cast<::arrow::StructType>(field->type());
       return StructToNode(struct_type, name, field->nullable(), field_id, properties,
diff --git a/cpp/src/parquet/arrow/schema_internal.cc b/cpp/src/parquet/arrow/schema_internal.cc
index da0427cb31000..bb75cce084097 100644
--- a/cpp/src/parquet/arrow/schema_internal.cc
+++ b/cpp/src/parquet/arrow/schema_internal.cc
@@ -130,6 +130,8 @@ Result<std::shared_ptr<ArrowType>> FromFLBA(const LogicalType& logical_type,
   switch (logical_type.type()) {
     case LogicalType::Type::DECIMAL:
       return MakeArrowDecimal(logical_type);
+    case LogicalType::Type::FLOAT16:
+      return ::arrow::float16();
     case LogicalType::Type::NONE:
     case LogicalType::Type::INTERVAL:
     case LogicalType::Type::UUID:
diff --git a/cpp/src/parquet/arrow/test_util.h b/cpp/src/parquet/arrow/test_util.h
index 16c03130c9672..b2be1b3c5354d 100644
--- a/cpp/src/parquet/arrow/test_util.h
+++ b/cpp/src/parquet/arrow/test_util.h
@@ -33,7 +33,9 @@
 #include "arrow/type_fwd.h"
 #include "arrow/type_traits.h"
 #include "arrow/util/decimal.h"
+#include "arrow/util/float16.h"
 #include "parquet/column_reader.h"
+#include "parquet/test_util.h"
 
 namespace parquet {
 
@@ -70,7 +72,14 @@ ::arrow::enable_if_floating_point<ArrowType, Status> NonNullArray(
     size_t size, std::shared_ptr<Array>* out) {
   using c_type = typename ArrowType::c_type;
   std::vector<c_type> values;
-  ::arrow::random_real(size, 0, static_cast<c_type>(0), static_cast<c_type>(1), &values);
+  if constexpr (::arrow::is_half_float_type<ArrowType>::value) {
+    values.resize(size);
+    test::random_float16_numbers(static_cast<int>(size), 0, ::arrow::util::Float16(0.0f),
+                                 ::arrow::util::Float16(1.0f), values.data());
+  } else {
+    ::arrow::random_real(size, 0, static_cast<c_type>(0), static_cast<c_type>(1),
+                         &values);
+  }
   ::arrow::NumericBuilder<ArrowType> builder;
   RETURN_NOT_OK(builder.AppendValues(values.data(), values.size()));
   return builder.Finish(out);
@@ -201,8 +210,14 @@ ::arrow::enable_if_floating_point<ArrowType, Status> NullableArray(
     size_t size, size_t num_nulls, uint32_t seed, std::shared_ptr<Array>* out) {
   using c_type = typename ArrowType::c_type;
   std::vector<c_type> values;
-  ::arrow::random_real(size, seed, static_cast<c_type>(-1e10), static_cast<c_type>(1e10),
-                       &values);
+  if constexpr (::arrow::is_half_float_type<ArrowType>::value) {
+    values.resize(size);
+    test::random_float16_numbers(static_cast<int>(size), 0, ::arrow::util::Float16(-1e4f),
+                                 ::arrow::util::Float16(1e4f), values.data());
+  } else {
+    ::arrow::random_real(size, seed, static_cast<c_type>(-1e10),
+                         static_cast<c_type>(1e10), &values);
+  }
   std::vector<uint8_t> valid_bytes(size, 1);
 
   for (size_t i = 0; i < num_nulls; i++) {
diff --git a/cpp/src/parquet/column_writer.cc b/cpp/src/parquet/column_writer.cc
index 5dff533c1cce2..a7e7b2f93e174 100644
--- a/cpp/src/parquet/column_writer.cc
+++ b/cpp/src/parquet/column_writer.cc
@@ -39,6 +39,7 @@
 #include "arrow/util/compression.h"
 #include "arrow/util/crc32.h"
 #include "arrow/util/endian.h"
+#include "arrow/util/float16.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/rle_encoding.h"
 #include "arrow/util/type_traits.h"
@@ -65,6 +66,7 @@ using arrow::Status;
 using arrow::bit_util::BitWriter;
 using arrow::internal::checked_cast;
 using arrow::internal::checked_pointer_cast;
+using arrow::util::Float16;
 using arrow::util::RleEncoder;
 
 namespace bit_util = arrow::bit_util;
@@ -2295,6 +2297,33 @@ struct SerializeFunctor<
   int64_t* scratch;
 };
 
+// ----------------------------------------------------------------------
+// Write Arrow to Float16
+
+// Requires a custom serializer because Float16s in Parquet are stored as a 2-byte
+// (little-endian) FLBA, whereas in Arrow they're a native `uint16_t`.
+template <>
+struct SerializeFunctor<::parquet::FLBAType, ::arrow::HalfFloatType> {
+  Status Serialize(const ::arrow::HalfFloatArray& array, ArrowWriteContext*, FLBA* out) {
+    const uint16_t* values = array.raw_values();
+    if (array.null_count() == 0) {
+      for (int64_t i = 0; i < array.length(); ++i) {
+        out[i] = ToFLBA(&values[i]);
+      }
+    } else {
+      for (int64_t i = 0; i < array.length(); ++i) {
+        out[i] = array.IsValid(i) ? ToFLBA(&values[i]) : FLBA{};
+      }
+    }
+    return Status::OK();
+  }
+
+ private:
+  FLBA ToFLBA(const uint16_t* value_ptr) const {
+    return FLBA{reinterpret_cast<const uint8_t*>(value_ptr)};
+  }
+};
+
 template <>
 Status TypedColumnWriterImpl<FLBAType>::WriteArrowDense(
     const int16_t* def_levels, const int16_t* rep_levels, int64_t num_levels,
@@ -2303,6 +2332,7 @@ Status TypedColumnWriterImpl<FLBAType>::WriteArrowDense(
     WRITE_SERIALIZE_CASE(FIXED_SIZE_BINARY, FixedSizeBinaryType, FLBAType)
     WRITE_SERIALIZE_CASE(DECIMAL128, Decimal128Type, FLBAType)
     WRITE_SERIALIZE_CASE(DECIMAL256, Decimal256Type, FLBAType)
+    WRITE_SERIALIZE_CASE(HALF_FLOAT, HalfFloatType, FLBAType)
     default:
       break;
   }
diff --git a/cpp/src/parquet/page_index_test.cc b/cpp/src/parquet/page_index_test.cc
index 5bfe38522af7b..4db49b4267415 100644
--- a/cpp/src/parquet/page_index_test.cc
+++ b/cpp/src/parquet/page_index_test.cc
@@ -21,6 +21,7 @@
 #include <memory>
 
 #include "arrow/io/file.h"
+#include "arrow/util/float16.h"
 #include "parquet/file_reader.h"
 #include "parquet/metadata.h"
 #include "parquet/schema.h"
@@ -579,6 +580,27 @@ TEST(PageIndex, WriteFLBAColumnIndex) {
                             /*has_null_counts=*/false);
 }
 
+TEST(PageIndex, WriteFloat16ColumnIndex) {
+  using ::arrow::util::Float16;
+  auto encode = [](auto value) {
+    auto bytes = Float16(value).ToLittleEndian();
+    return std::string(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+  };
+
+  // Float16 (FLBA) values in the ascending order and without null count.
+  std::vector<EncodedStatistics> page_stats(4);
+  page_stats.at(0).set_min(encode(-1.3)).set_max(encode(+3.6));
+  page_stats.at(1).set_min(encode(-0.2)).set_max(encode(+4.5));
+  page_stats.at(2).set_min(encode(+1.1)).set_max(encode(+5.4));
+  page_stats.at(3).set_min(encode(+2.0)).set_max(encode(+6.3));
+
+  auto node = schema::PrimitiveNode::Make(
+      "c1", Repetition::OPTIONAL, LogicalType::Float16(), Type::FIXED_LEN_BYTE_ARRAY,
+      /*length=*/2);
+  TestWriteTypedColumnIndex(std::move(node), page_stats, BoundaryOrder::Ascending,
+                            /*has_null_counts=*/false);
+}
+
 TEST(PageIndex, WriteColumnIndexWithAllNullPages) {
   // All values are null.
   std::vector<EncodedStatistics> page_stats(3);
diff --git a/cpp/src/parquet/parquet.thrift b/cpp/src/parquet/parquet.thrift
index 88e44c96cc24c..d802166be66e8 100644
--- a/cpp/src/parquet/parquet.thrift
+++ b/cpp/src/parquet/parquet.thrift
@@ -234,6 +234,7 @@ struct MapType {}     // see LogicalTypes.md
 struct ListType {}    // see LogicalTypes.md
 struct EnumType {}    // allowed for BINARY, must be encoded with UTF-8
 struct DateType {}    // allowed for INT32
+struct Float16Type{}  // allowed for FIXED[2], must encode raw FLOAT16 bytes
 
 /**
  * Logical type to annotate a column that is always null.
@@ -344,6 +345,7 @@ union LogicalType {
   12: JsonType JSON           // use ConvertedType JSON
   13: BsonType BSON           // use ConvertedType BSON
   14: UUIDType UUID           // no compatible ConvertedType
+  15: Float16Type FLOAT16     // no compatible ConvertedType
 }
 
 /**
diff --git a/cpp/src/parquet/schema_test.cc b/cpp/src/parquet/schema_test.cc
index 603d9ed8e2124..a1b5557497d9c 100644
--- a/cpp/src/parquet/schema_test.cc
+++ b/cpp/src/parquet/schema_test.cc
@@ -1147,6 +1147,9 @@ TEST(TestLogicalTypeConstruction, NewTypeIncompatibility) {
   auto check_is_UUID = [](const std::shared_ptr<const LogicalType>& logical_type) {
     return logical_type->is_UUID();
   };
+  auto check_is_float16 = [](const std::shared_ptr<const LogicalType>& logical_type) {
+    return logical_type->is_float16();
+  };
   auto check_is_null = [](const std::shared_ptr<const LogicalType>& logical_type) {
     return logical_type->is_null();
   };
@@ -1159,6 +1162,7 @@ TEST(TestLogicalTypeConstruction, NewTypeIncompatibility) {
 
   std::vector<ConfirmNewTypeIncompatibilityArguments> cases = {
       {LogicalType::UUID(), check_is_UUID},
+      {LogicalType::Float16(), check_is_float16},
       {LogicalType::Null(), check_is_null},
       {LogicalType::Time(false, LogicalType::TimeUnit::MILLIS), check_is_time},
       {LogicalType::Time(false, LogicalType::TimeUnit::MICROS), check_is_time},
@@ -1242,6 +1246,7 @@ TEST(TestLogicalTypeOperation, LogicalTypeProperties) {
       {JSONLogicalType::Make(), false, true, true},
       {BSONLogicalType::Make(), false, true, true},
       {UUIDLogicalType::Make(), false, true, true},
+      {Float16LogicalType::Make(), false, true, true},
       {NoLogicalType::Make(), false, false, true},
   };
 
@@ -1351,7 +1356,8 @@ TEST(TestLogicalTypeOperation, LogicalTypeApplicability) {
     int physical_length;
   };
 
-  std::vector<InapplicableType> inapplicable_types = {{Type::FIXED_LEN_BYTE_ARRAY, 8},
+  std::vector<InapplicableType> inapplicable_types = {{Type::FIXED_LEN_BYTE_ARRAY, 1},
+                                                      {Type::FIXED_LEN_BYTE_ARRAY, 8},
                                                       {Type::FIXED_LEN_BYTE_ARRAY, 20},
                                                       {Type::BOOLEAN, -1},
                                                       {Type::INT32, -1},
@@ -1374,6 +1380,12 @@ TEST(TestLogicalTypeOperation, LogicalTypeApplicability) {
   for (const InapplicableType& t : inapplicable_types) {
     ASSERT_FALSE(logical_type->is_applicable(t.physical_type, t.physical_length));
   }
+
+  logical_type = LogicalType::Float16();
+  ASSERT_TRUE(logical_type->is_applicable(Type::FIXED_LEN_BYTE_ARRAY, 2));
+  for (const InapplicableType& t : inapplicable_types) {
+    ASSERT_FALSE(logical_type->is_applicable(t.physical_type, t.physical_length));
+  }
 }
 
 TEST(TestLogicalTypeOperation, DecimalLogicalTypeApplicability) {
@@ -1531,6 +1543,7 @@ TEST(TestLogicalTypeOperation, LogicalTypeRepresentation) {
       {LogicalType::JSON(), "JSON", R"({"Type": "JSON"})"},
       {LogicalType::BSON(), "BSON", R"({"Type": "BSON"})"},
       {LogicalType::UUID(), "UUID", R"({"Type": "UUID"})"},
+      {LogicalType::Float16(), "Float16", R"({"Type": "Float16"})"},
       {LogicalType::None(), "None", R"({"Type": "None"})"},
   };
 
@@ -1580,6 +1593,7 @@ TEST(TestLogicalTypeOperation, LogicalTypeSortOrder) {
       {LogicalType::JSON(), SortOrder::UNSIGNED},
       {LogicalType::BSON(), SortOrder::UNSIGNED},
       {LogicalType::UUID(), SortOrder::UNSIGNED},
+      {LogicalType::Float16(), SortOrder::SIGNED},
       {LogicalType::None(), SortOrder::UNKNOWN}};
 
   for (const ExpectedSortOrder& c : cases) {
@@ -1712,6 +1726,15 @@ TEST(TestSchemaNodeCreation, FactoryExceptions) {
   ASSERT_ANY_THROW(PrimitiveNode::Make("uuid", Repetition::REQUIRED,
                                        UUIDLogicalType::Make(),
                                        Type::FIXED_LEN_BYTE_ARRAY, 64));
+
+  // Incompatible primitive type ...
+  ASSERT_ANY_THROW(PrimitiveNode::Make("float16", Repetition::REQUIRED,
+                                       Float16LogicalType::Make(), Type::BYTE_ARRAY, 2));
+  // Incompatible primitive length ...
+  ASSERT_ANY_THROW(PrimitiveNode::Make("float16", Repetition::REQUIRED,
+                                       Float16LogicalType::Make(),
+                                       Type::FIXED_LEN_BYTE_ARRAY, 3));
+
   // Non-positive length argument for fixed length binary ...
   ASSERT_ANY_THROW(PrimitiveNode::Make("negative_length", Repetition::REQUIRED,
                                        NoLogicalType::Make(), Type::FIXED_LEN_BYTE_ARRAY,
@@ -1902,6 +1925,9 @@ TEST_F(TestSchemaElementConstruction, SimpleCases) {
        [this]() { return element_->logicalType.__isset.BSON; }},
       {"uuid", LogicalType::UUID(), Type::FIXED_LEN_BYTE_ARRAY, 16, false,
        ConvertedType::NA, true, [this]() { return element_->logicalType.__isset.UUID; }},
+      {"float16", LogicalType::Float16(), Type::FIXED_LEN_BYTE_ARRAY, 2, false,
+       ConvertedType::NA, true,
+       [this]() { return element_->logicalType.__isset.FLOAT16; }},
       {"none", LogicalType::None(), Type::INT64, -1, false, ConvertedType::NA, false,
        check_nothing}};
 
@@ -2238,6 +2264,7 @@ TEST(TestLogicalTypeSerialization, Roundtrips) {
       {LogicalType::JSON(), Type::BYTE_ARRAY, -1},
       {LogicalType::BSON(), Type::BYTE_ARRAY, -1},
       {LogicalType::UUID(), Type::FIXED_LEN_BYTE_ARRAY, 16},
+      {LogicalType::Float16(), Type::FIXED_LEN_BYTE_ARRAY, 2},
       {LogicalType::None(), Type::BOOLEAN, -1}};
 
   for (const AnnotatedPrimitiveNodeFactoryArguments& c : cases) {
diff --git a/cpp/src/parquet/statistics.cc b/cpp/src/parquet/statistics.cc
index ccfb69c487d40..37b245e0dd6c2 100644
--- a/cpp/src/parquet/statistics.cc
+++ b/cpp/src/parquet/statistics.cc
@@ -30,6 +30,7 @@
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_run_reader.h"
 #include "arrow/util/checked_cast.h"
+#include "arrow/util/float16.h"
 #include "arrow/util/logging.h"
 #include "arrow/util/ubsan.h"
 #include "arrow/visit_data_inline.h"
@@ -41,6 +42,7 @@
 using arrow::default_memory_pool;
 using arrow::MemoryPool;
 using arrow::internal::checked_cast;
+using arrow::util::Float16;
 using arrow::util::SafeCopy;
 using arrow::util::SafeLoad;
 
@@ -53,6 +55,23 @@ namespace {
 constexpr int value_length(int value_length, const ByteArray& value) { return value.len; }
 constexpr int value_length(int type_length, const FLBA& value) { return type_length; }
 
+// Static "constants" for normalizing float16 min/max values. These need to be expressed
+// as pointers because `Float16LogicalType` represents an FLBA.
+struct Float16Constants {
+  static constexpr const uint8_t* lowest() { return lowest_.data(); }
+  static constexpr const uint8_t* max() { return max_.data(); }
+  static constexpr const uint8_t* positive_zero() { return positive_zero_.data(); }
+  static constexpr const uint8_t* negative_zero() { return negative_zero_.data(); }
+
+ private:
+  using Bytes = std::array<uint8_t, 2>;
+  static constexpr Bytes lowest_ =
+      std::numeric_limits<Float16>::lowest().ToLittleEndian();
+  static constexpr Bytes max_ = std::numeric_limits<Float16>::max().ToLittleEndian();
+  static constexpr Bytes positive_zero_ = (+Float16::FromBits(0)).ToLittleEndian();
+  static constexpr Bytes negative_zero_ = (-Float16::FromBits(0)).ToLittleEndian();
+};
+
 template <typename DType, bool is_signed>
 struct CompareHelper {
   using T = typename DType::c_type;
@@ -277,11 +296,43 @@ template <bool is_signed>
 struct CompareHelper<FLBAType, is_signed>
     : public BinaryLikeCompareHelperBase<FLBAType, is_signed> {};
 
+template <>
+struct CompareHelper<Float16LogicalType, /*is_signed=*/true> {
+  using T = FLBA;
+
+  static T DefaultMin() { return T{Float16Constants::max()}; }
+  static T DefaultMax() { return T{Float16Constants::lowest()}; }
+
+  static T Coalesce(T val, T fallback) {
+    return (val.ptr == nullptr || Float16::FromLittleEndian(val.ptr).is_nan()) ? fallback
+                                                                               : val;
+  }
+
+  static inline bool Compare(int type_length, const T& a, const T& b) {
+    const auto lhs = Float16::FromLittleEndian(a.ptr);
+    const auto rhs = Float16::FromLittleEndian(b.ptr);
+    // NaN is handled here (same behavior as native float compare)
+    return lhs < rhs;
+  }
+
+  static T Min(int type_length, const T& a, const T& b) {
+    if (a.ptr == nullptr) return b;
+    if (b.ptr == nullptr) return a;
+    return Compare(type_length, a, b) ? a : b;
+  }
+
+  static T Max(int type_length, const T& a, const T& b) {
+    if (a.ptr == nullptr) return b;
+    if (b.ptr == nullptr) return a;
+    return Compare(type_length, a, b) ? b : a;
+  }
+};
+
 using ::std::optional;
 
 template <typename T>
 ::arrow::enable_if_t<std::is_integral<T>::value, optional<std::pair<T, T>>>
-CleanStatistic(std::pair<T, T> min_max) {
+CleanStatistic(std::pair<T, T> min_max, LogicalType::Type::type) {
   return min_max;
 }
 
@@ -292,7 +343,7 @@ CleanStatistic(std::pair<T, T> min_max) {
 // - If max is -0.0f, replace with 0.0f
 template <typename T>
 ::arrow::enable_if_t<std::is_floating_point<T>::value, optional<std::pair<T, T>>>
-CleanStatistic(std::pair<T, T> min_max) {
+CleanStatistic(std::pair<T, T> min_max, LogicalType::Type::type) {
   T min = min_max.first;
   T max = min_max.second;
 
@@ -318,25 +369,67 @@ CleanStatistic(std::pair<T, T> min_max) {
   return {{min, max}};
 }
 
-optional<std::pair<FLBA, FLBA>> CleanStatistic(std::pair<FLBA, FLBA> min_max) {
+optional<std::pair<FLBA, FLBA>> CleanFloat16Statistic(std::pair<FLBA, FLBA> min_max) {
+  FLBA min_flba = min_max.first;
+  FLBA max_flba = min_max.second;
+  Float16 min = Float16::FromLittleEndian(min_flba.ptr);
+  Float16 max = Float16::FromLittleEndian(max_flba.ptr);
+
+  if (min.is_nan() || max.is_nan()) {
+    return ::std::nullopt;
+  }
+
+  if (min == std::numeric_limits<Float16>::max() &&
+      max == std::numeric_limits<Float16>::lowest()) {
+    return ::std::nullopt;
+  }
+
+  if (min.is_zero() && !min.signbit()) {
+    min_flba = FLBA{Float16Constants::negative_zero()};
+  }
+  if (max.is_zero() && max.signbit()) {
+    max_flba = FLBA{Float16Constants::positive_zero()};
+  }
+
+  return {{min_flba, max_flba}};
+}
+
+optional<std::pair<FLBA, FLBA>> CleanStatistic(std::pair<FLBA, FLBA> min_max,
+                                               LogicalType::Type::type logical_type) {
   if (min_max.first.ptr == nullptr || min_max.second.ptr == nullptr) {
     return ::std::nullopt;
   }
+  if (logical_type == LogicalType::Type::FLOAT16) {
+    return CleanFloat16Statistic(std::move(min_max));
+  }
   return min_max;
 }
 
 optional<std::pair<ByteArray, ByteArray>> CleanStatistic(
-    std::pair<ByteArray, ByteArray> min_max) {
+    std::pair<ByteArray, ByteArray> min_max, LogicalType::Type::type) {
   if (min_max.first.ptr == nullptr || min_max.second.ptr == nullptr) {
     return ::std::nullopt;
   }
   return min_max;
 }
 
+template <typename T>
+struct RebindLogical {
+  using DType = T;
+  using c_type = typename DType::c_type;
+};
+
+template <>
+struct RebindLogical<Float16LogicalType> {
+  using DType = FLBAType;
+  using c_type = DType::c_type;
+};
+
 template <bool is_signed, typename DType>
-class TypedComparatorImpl : virtual public TypedComparator<DType> {
+class TypedComparatorImpl
+    : virtual public TypedComparator<typename RebindLogical<DType>::DType> {
  public:
-  using T = typename DType::c_type;
+  using T = typename RebindLogical<DType>::c_type;
   using Helper = CompareHelper<DType, is_signed>;
 
   explicit TypedComparatorImpl(int type_length = -1) : type_length_(type_length) {}
@@ -384,7 +477,9 @@ class TypedComparatorImpl : virtual public TypedComparator<DType> {
     return {min, max};
   }
 
-  std::pair<T, T> GetMinMax(const ::arrow::Array& values) override;
+  std::pair<T, T> GetMinMax(const ::arrow::Array& values) override {
+    ParquetException::NYI(values.type()->ToString());
+  }
 
  private:
   int type_length_;
@@ -412,12 +507,6 @@ TypedComparatorImpl</*is_signed=*/false, Int32Type>::GetMinMax(const int32_t* va
   return {SafeCopy<int32_t>(min), SafeCopy<int32_t>(max)};
 }
 
-template <bool is_signed, typename DType>
-std::pair<typename DType::c_type, typename DType::c_type>
-TypedComparatorImpl<is_signed, DType>::GetMinMax(const ::arrow::Array& values) {
-  ParquetException::NYI(values.type()->ToString());
-}
-
 template <bool is_signed>
 std::pair<ByteArray, ByteArray> GetMinMaxBinaryHelper(
     const TypedComparatorImpl<is_signed, ByteArrayType>& comparator,
@@ -458,6 +547,16 @@ std::pair<ByteArray, ByteArray> TypedComparatorImpl<false, ByteArrayType>::GetMi
   return GetMinMaxBinaryHelper<false>(*this, values);
 }
 
+LogicalType::Type::type LogicalTypeId(const ColumnDescriptor* descr) {
+  if (const auto& logical_type = descr->logical_type()) {
+    return logical_type->type();
+  }
+  return LogicalType::Type::NONE;
+}
+LogicalType::Type::type LogicalTypeId(const Statistics& stats) {
+  return LogicalTypeId(stats.descr());
+}
+
 template <typename DType>
 class TypedStatisticsImpl : public TypedStatistics<DType> {
  public:
@@ -468,9 +567,9 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
       : descr_(descr),
         pool_(pool),
         min_buffer_(AllocateBuffer(pool_, 0)),
-        max_buffer_(AllocateBuffer(pool_, 0)) {
-    auto comp = Comparator::Make(descr);
-    comparator_ = std::static_pointer_cast<TypedComparator<DType>>(comp);
+        max_buffer_(AllocateBuffer(pool_, 0)),
+        logical_type_(LogicalTypeId(descr_)) {
+    comparator_ = MakeComparator<DType>(descr);
     TypedStatisticsImpl::Reset();
   }
 
@@ -527,9 +626,27 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
 
   void IncrementNumValues(int64_t n) override { num_values_ += n; }
 
+  static bool IsMeaningfulLogicalType(LogicalType::Type::type type) {
+    switch (type) {
+      case LogicalType::Type::FLOAT16:
+        return true;
+      default:
+        return false;
+    }
+  }
+
   bool Equals(const Statistics& raw_other) const override {
     if (physical_type() != raw_other.physical_type()) return false;
 
+    const auto other_logical_type = LogicalTypeId(raw_other);
+    // Only compare against logical types that influence the interpretation of the
+    // physical type
+    if (IsMeaningfulLogicalType(logical_type_)) {
+      if (logical_type_ != other_logical_type) return false;
+    } else if (IsMeaningfulLogicalType(other_logical_type)) {
+      return false;
+    }
+
     const auto& other = checked_cast<const TypedStatisticsImpl&>(raw_other);
 
     if (has_min_max_ != other.has_min_max_) return false;
@@ -655,6 +772,7 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
   EncodedStatistics statistics_;
   std::shared_ptr<TypedComparator<DType>> comparator_;
   std::shared_ptr<ResizableBuffer> min_buffer_, max_buffer_;
+  LogicalType::Type::type logical_type_ = LogicalType::Type::NONE;
 
   void PlainEncode(const T& src, std::string* dst) const;
   void PlainDecode(const std::string& src, T* dst) const;
@@ -686,7 +804,7 @@ class TypedStatisticsImpl : public TypedStatistics<DType> {
 
   void SetMinMaxPair(std::pair<T, T> min_max) {
     // CleanStatistic can return a nullopt in case of erroneous values, e.g. NaN
-    auto maybe_min_max = CleanStatistic(min_max);
+    auto maybe_min_max = CleanStatistic(min_max, logical_type_);
     if (!maybe_min_max) return;
 
     auto min = maybe_min_max.value().first;
@@ -795,12 +913,8 @@ void TypedStatisticsImpl<ByteArrayType>::PlainDecode(const std::string& src,
   dst->ptr = reinterpret_cast<const uint8_t*>(src.c_str());
 }
 
-}  // namespace
-
-// ----------------------------------------------------------------------
-// Public factory functions
-
-std::shared_ptr<Comparator> Comparator::Make(Type::type physical_type,
+std::shared_ptr<Comparator> DoMakeComparator(Type::type physical_type,
+                                             LogicalType::Type::type logical_type,
                                              SortOrder::type sort_order,
                                              int type_length) {
   if (SortOrder::SIGNED == sort_order) {
@@ -820,6 +934,10 @@ std::shared_ptr<Comparator> Comparator::Make(Type::type physical_type,
       case Type::BYTE_ARRAY:
         return std::make_shared<TypedComparatorImpl<true, ByteArrayType>>();
       case Type::FIXED_LEN_BYTE_ARRAY:
+        if (logical_type == LogicalType::Type::FLOAT16) {
+          return std::make_shared<TypedComparatorImpl<true, Float16LogicalType>>(
+              type_length);
+        }
         return std::make_shared<TypedComparatorImpl<true, FLBAType>>(type_length);
       default:
         ParquetException::NYI("Signed Compare not implemented");
@@ -845,8 +963,21 @@ std::shared_ptr<Comparator> Comparator::Make(Type::type physical_type,
   return nullptr;
 }
 
+}  // namespace
+
+// ----------------------------------------------------------------------
+// Public factory functions
+
+std::shared_ptr<Comparator> Comparator::Make(Type::type physical_type,
+                                             SortOrder::type sort_order,
+                                             int type_length) {
+  return DoMakeComparator(physical_type, LogicalType::Type::NONE, sort_order,
+                          type_length);
+}
+
 std::shared_ptr<Comparator> Comparator::Make(const ColumnDescriptor* descr) {
-  return Make(descr->physical_type(), descr->sort_order(), descr->type_length());
+  return DoMakeComparator(descr->physical_type(), LogicalTypeId(descr),
+                          descr->sort_order(), descr->type_length());
 }
 
 std::shared_ptr<Statistics> Statistics::Make(const ColumnDescriptor* descr,
diff --git a/cpp/src/parquet/statistics_test.cc b/cpp/src/parquet/statistics_test.cc
index 637832945ec57..cb2e6455abfa9 100644
--- a/cpp/src/parquet/statistics_test.cc
+++ b/cpp/src/parquet/statistics_test.cc
@@ -34,6 +34,7 @@
 #include "arrow/type_traits.h"
 #include "arrow/util/bit_util.h"
 #include "arrow/util/bitmap_ops.h"
+#include "arrow/util/float16.h"
 #include "arrow/util/ubsan.h"
 
 #include "parquet/column_reader.h"
@@ -49,6 +50,7 @@
 
 using arrow::default_memory_pool;
 using arrow::MemoryPool;
+using arrow::util::Float16;
 using arrow::util::SafeCopy;
 
 namespace bit_util = arrow::bit_util;
@@ -875,9 +877,22 @@ TEST(CorrectStatistics, Basics) {
 // Test SortOrder class
 static const int NUM_VALUES = 10;
 
-template <typename TestType>
+template <typename T>
+struct RebindLogical {
+  using ParquetType = T;
+  using CType = typename T::c_type;
+};
+
+template <>
+struct RebindLogical<Float16LogicalType> {
+  using ParquetType = FLBAType;
+  using CType = ParquetType::c_type;
+};
+
+template <typename T>
 class TestStatisticsSortOrder : public ::testing::Test {
  public:
+  using TestType = typename RebindLogical<T>::ParquetType;
   using c_type = typename TestType::c_type;
 
   void SetUp() override {
@@ -955,7 +970,7 @@ class TestStatisticsSortOrder : public ::testing::Test {
 };
 
 using CompareTestTypes = ::testing::Types<Int32Type, Int64Type, FloatType, DoubleType,
-                                          ByteArrayType, FLBAType>;
+                                          ByteArrayType, FLBAType, Float16LogicalType>;
 
 // TYPE::INT32
 template <>
@@ -1102,6 +1117,39 @@ void TestStatisticsSortOrder<FLBAType>::SetValues() {
       .set_max(std::string(reinterpret_cast<const char*>(&vals[8][0]), FLBA_LENGTH));
 }
 
+template <>
+void TestStatisticsSortOrder<Float16LogicalType>::AddNodes(std::string name) {
+  auto node =
+      schema::PrimitiveNode::Make(name, Repetition::REQUIRED, LogicalType::Float16(),
+                                  Type::FIXED_LEN_BYTE_ARRAY, sizeof(uint16_t));
+  fields_.push_back(std::move(node));
+}
+
+template <>
+void TestStatisticsSortOrder<Float16LogicalType>::SetValues() {
+  constexpr int kValueLen = 2;
+  constexpr int kNumBytes = NUM_VALUES * kValueLen;
+
+  const Float16 f16_vals[NUM_VALUES] = {
+      Float16::FromFloat(+2.0f), Float16::FromFloat(-4.0f), Float16::FromFloat(+4.0f),
+      Float16::FromFloat(-2.0f), Float16::FromFloat(-1.0f), Float16::FromFloat(+3.0f),
+      Float16::FromFloat(+1.0f), Float16::FromFloat(-5.0f), Float16::FromFloat(+0.0f),
+      Float16::FromFloat(-3.0f),
+  };
+
+  values_buf_.resize(kNumBytes);
+  uint8_t* ptr = values_buf_.data();
+  for (int i = 0; i < NUM_VALUES; ++i) {
+    f16_vals[i].ToLittleEndian(ptr);
+    values_[i].ptr = ptr;
+    ptr += kValueLen;
+  }
+
+  stats_[0]
+      .set_min(std::string(reinterpret_cast<const char*>(values_[7].ptr), kValueLen))
+      .set_max(std::string(reinterpret_cast<const char*>(values_[2].ptr), kValueLen));
+}
+
 TYPED_TEST_SUITE(TestStatisticsSortOrder, CompareTestTypes);
 
 TYPED_TEST(TestStatisticsSortOrder, MinMax) {
@@ -1167,12 +1215,20 @@ TEST_F(TestStatisticsSortOrderFLBA, UnknownSortOrder) {
   ASSERT_FALSE(cc_metadata->is_stats_set());
 }
 
+template <typename T>
+static std::string EncodeValue(const T& val) {
+  return std::string(reinterpret_cast<const char*>(&val), sizeof(val));
+}
+static std::string EncodeValue(const FLBA& val, int length = sizeof(uint16_t)) {
+  return std::string(reinterpret_cast<const char*>(val.ptr), length);
+}
+
 template <typename Stats, typename Array, typename T = typename Array::value_type>
 void AssertMinMaxAre(Stats stats, const Array& values, T expected_min, T expected_max) {
   stats->Update(values.data(), values.size(), 0);
   ASSERT_TRUE(stats->HasMinMax());
-  EXPECT_EQ(stats->min(), expected_min);
-  EXPECT_EQ(stats->max(), expected_max);
+  EXPECT_EQ(stats->EncodeMin(), EncodeValue(expected_min));
+  EXPECT_EQ(stats->EncodeMax(), EncodeValue(expected_max));
 }
 
 template <typename Stats, typename Array, typename T = typename Stats::T>
@@ -1184,8 +1240,8 @@ void AssertMinMaxAre(Stats stats, const Array& values, const uint8_t* valid_bitm
   stats->UpdateSpaced(values.data(), valid_bitmap, 0, non_null_count + null_count,
                       non_null_count, null_count);
   ASSERT_TRUE(stats->HasMinMax());
-  EXPECT_EQ(stats->min(), expected_min);
-  EXPECT_EQ(stats->max(), expected_max);
+  EXPECT_EQ(stats->EncodeMin(), EncodeValue(expected_min));
+  EXPECT_EQ(stats->EncodeMax(), EncodeValue(expected_max));
 }
 
 template <typename Stats, typename Array>
@@ -1268,50 +1324,225 @@ void CheckExtrema() {
 TEST(TestStatistic, Int32Extrema) { CheckExtrema<Int32Type>(); }
 TEST(TestStatistic, Int64Extrema) { CheckExtrema<Int64Type>(); }
 
-// PARQUET-1225: Float NaN values may lead to incorrect min-max
-template <typename ParquetType>
-void CheckNaNs() {
-  using T = typename ParquetType::c_type;
+template <typename T>
+class TestFloatStatistics : public ::testing::Test {
+ public:
+  using ParquetType = typename RebindLogical<T>::ParquetType;
+  using c_type = typename ParquetType::c_type;
+
+  void Init();
+  void SetUp() override {
+    this->Init();
+    ASSERT_NE(EncodeValue(negative_zero_), EncodeValue(positive_zero_));
+  }
+
+  bool signbit(c_type val);
+  void CheckEq(const c_type& l, const c_type& r);
+  NodePtr MakeNode(const std::string& name, Repetition::type rep);
+
+  template <typename Stats, typename Values>
+  void CheckMinMaxZeroesSign(Stats stats, const Values& values) {
+    stats->Update(values.data(), values.size(), /*null_count=*/0);
+    ASSERT_TRUE(stats->HasMinMax());
+
+    this->CheckEq(stats->min(), positive_zero_);
+    ASSERT_TRUE(this->signbit(stats->min()));
+    ASSERT_EQ(stats->EncodeMin(), EncodeValue(negative_zero_));
+
+    this->CheckEq(stats->max(), positive_zero_);
+    ASSERT_FALSE(this->signbit(stats->max()));
+    ASSERT_EQ(stats->EncodeMax(), EncodeValue(positive_zero_));
+  }
+
+  // ARROW-5562: Ensure that -0.0f and 0.0f values are properly handled like in
+  // parquet-mr
+  void TestNegativeZeroes() {
+    NodePtr node = this->MakeNode("f", Repetition::OPTIONAL);
+    ColumnDescriptor descr(node, 1, 1);
+
+    {
+      std::array<c_type, 2> values{negative_zero_, positive_zero_};
+      auto stats = MakeStatistics<ParquetType>(&descr);
+      CheckMinMaxZeroesSign(stats, values);
+    }
+
+    {
+      std::array<c_type, 2> values{positive_zero_, negative_zero_};
+      auto stats = MakeStatistics<ParquetType>(&descr);
+      CheckMinMaxZeroesSign(stats, values);
+    }
+
+    {
+      std::array<c_type, 2> values{negative_zero_, negative_zero_};
+      auto stats = MakeStatistics<ParquetType>(&descr);
+      CheckMinMaxZeroesSign(stats, values);
+    }
+
+    {
+      std::array<c_type, 2> values{positive_zero_, positive_zero_};
+      auto stats = MakeStatistics<ParquetType>(&descr);
+      CheckMinMaxZeroesSign(stats, values);
+    }
+  }
+
+  // PARQUET-1225: Float NaN values may lead to incorrect min-max
+  template <typename Values>
+  void CheckNaNs(ColumnDescriptor* descr, const Values& all_nans, const Values& some_nans,
+                 const Values& other_nans, c_type min, c_type max, uint8_t valid_bitmap,
+                 uint8_t valid_bitmap_no_nans) {
+    auto some_nan_stats = MakeStatistics<ParquetType>(descr);
+    // Ingesting only nans should not yield valid min max
+    AssertUnsetMinMax(some_nan_stats, all_nans);
+    // Ingesting a mix of NaNs and non-NaNs should yield a valid min max.
+    AssertMinMaxAre(some_nan_stats, some_nans, min, max);
+    // Ingesting only nans after a valid min/max, should have no effect
+    AssertMinMaxAre(some_nan_stats, all_nans, min, max);
+
+    some_nan_stats = MakeStatistics<ParquetType>(descr);
+    AssertUnsetMinMax(some_nan_stats, all_nans, &valid_bitmap);
+    // NaNs should not pollute min max when excluded via null bitmap.
+    AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap_no_nans, min, max);
+    // Ingesting NaNs with a null bitmap should not change the result.
+    AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap, min, max);
+
+    // An array that doesn't start with NaN
+    auto other_stats = MakeStatistics<ParquetType>(descr);
+    AssertMinMaxAre(other_stats, other_nans, min, max);
+  }
+
+  void TestNaNs();
+
+ protected:
+  std::vector<uint8_t> data_buf_;
+  c_type positive_zero_;
+  c_type negative_zero_;
+};
+
+template <typename T>
+void TestFloatStatistics<T>::Init() {
+  positive_zero_ = c_type{};
+  negative_zero_ = -positive_zero_;
+}
+template <>
+void TestFloatStatistics<Float16LogicalType>::Init() {
+  data_buf_.resize(4);
+  (+Float16(0)).ToLittleEndian(&data_buf_[0]);
+  positive_zero_ = FLBA{&data_buf_[0]};
+  (-Float16(0)).ToLittleEndian(&data_buf_[2]);
+  negative_zero_ = FLBA{&data_buf_[2]};
+}
+
+template <typename T>
+NodePtr TestFloatStatistics<T>::MakeNode(const std::string& name, Repetition::type rep) {
+  return PrimitiveNode::Make(name, rep, ParquetType::type_num);
+}
+template <>
+NodePtr TestFloatStatistics<Float16LogicalType>::MakeNode(const std::string& name,
+                                                          Repetition::type rep) {
+  return PrimitiveNode::Make(name, rep, LogicalType::Float16(),
+                             Type::FIXED_LEN_BYTE_ARRAY, 2);
+}
+
+template <typename T>
+void TestFloatStatistics<T>::CheckEq(const c_type& l, const c_type& r) {
+  ASSERT_EQ(l, r);
+}
+template <>
+void TestFloatStatistics<Float16LogicalType>::CheckEq(const c_type& a, const c_type& b) {
+  auto l = Float16::FromLittleEndian(a.ptr);
+  auto r = Float16::FromLittleEndian(b.ptr);
+  ASSERT_EQ(l, r);
+}
 
+template <typename T>
+bool TestFloatStatistics<T>::signbit(c_type val) {
+  return std::signbit(val);
+}
+template <>
+bool TestFloatStatistics<Float16LogicalType>::signbit(c_type val) {
+  return Float16::FromLittleEndian(val.ptr).signbit();
+}
+
+template <typename T>
+void TestFloatStatistics<T>::TestNaNs() {
   constexpr int kNumValues = 8;
-  NodePtr node = PrimitiveNode::Make("f", Repetition::OPTIONAL, ParquetType::type_num);
+  NodePtr node = this->MakeNode("f", Repetition::OPTIONAL);
   ColumnDescriptor descr(node, 1, 1);
 
-  constexpr T nan = std::numeric_limits<T>::quiet_NaN();
-  constexpr T min = -4.0f;
-  constexpr T max = 3.0f;
+  constexpr c_type nan = std::numeric_limits<c_type>::quiet_NaN();
+  constexpr c_type min = -4.0f;
+  constexpr c_type max = 3.0f;
+
+  std::array<c_type, kNumValues> all_nans{nan, nan, nan, nan, nan, nan, nan, nan};
+  std::array<c_type, kNumValues> some_nans{nan, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
+  std::array<c_type, kNumValues> other_nans{1.5f, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
 
-  std::array<T, kNumValues> all_nans{nan, nan, nan, nan, nan, nan, nan, nan};
-  std::array<T, kNumValues> some_nans{nan, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
   uint8_t valid_bitmap = 0x7F;  // 0b01111111
   // NaNs excluded
   uint8_t valid_bitmap_no_nans = 0x6E;  // 0b01101110
 
-  // Test values
-  auto some_nan_stats = MakeStatistics<ParquetType>(&descr);
-  // Ingesting only nans should not yield valid min max
-  AssertUnsetMinMax(some_nan_stats, all_nans);
-  // Ingesting a mix of NaNs and non-NaNs should not yield valid min max.
-  AssertMinMaxAre(some_nan_stats, some_nans, min, max);
-  // Ingesting only nans after a valid min/max, should have not effect
-  AssertMinMaxAre(some_nan_stats, all_nans, min, max);
+  this->CheckNaNs(&descr, all_nans, some_nans, other_nans, min, max, valid_bitmap,
+                  valid_bitmap_no_nans);
+}
 
-  some_nan_stats = MakeStatistics<ParquetType>(&descr);
-  AssertUnsetMinMax(some_nan_stats, all_nans, &valid_bitmap);
-  // NaNs should not pollute min max when excluded via null bitmap.
-  AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap_no_nans, min, max);
-  // Ingesting NaNs with a null bitmap should not change the result.
-  AssertMinMaxAre(some_nan_stats, some_nans, &valid_bitmap, min, max);
+struct BufferedFloat16 {
+  explicit BufferedFloat16(Float16 f16) : f16(f16) {
+    this->f16.ToLittleEndian(bytes_.data());
+  }
+  explicit BufferedFloat16(float f) : BufferedFloat16(Float16::FromFloat(f)) {}
+  const uint8_t* bytes() const { return bytes_.data(); }
+
+  Float16 f16;
+  std::array<uint8_t, 2> bytes_;
+};
+
+template <>
+void TestFloatStatistics<Float16LogicalType>::TestNaNs() {
+  constexpr int kNumValues = 8;
+
+  NodePtr node = this->MakeNode("f", Repetition::OPTIONAL);
+  ColumnDescriptor descr(node, 1, 1);
+
+  using F16 = BufferedFloat16;
+  const auto nan_f16 = F16(std::numeric_limits<Float16>::quiet_NaN());
+  const auto min_f16 = F16(-4.0f);
+  const auto max_f16 = F16(+3.0f);
+
+  const auto min = FLBA{min_f16.bytes()};
+  const auto max = FLBA{max_f16.bytes()};
+
+  std::array<F16, kNumValues> all_nans_f16 = {nan_f16, nan_f16, nan_f16, nan_f16,
+                                              nan_f16, nan_f16, nan_f16, nan_f16};
+  std::array<F16, kNumValues> some_nans_f16 = {
+      nan_f16, max_f16, F16(-3.0f), F16(-1.0f), nan_f16, F16(+2.0f), min_f16, nan_f16};
+  std::array<F16, kNumValues> other_nans_f16 = some_nans_f16;
+  other_nans_f16[0] = F16(+1.5f);  // +1.5
+
+  auto prepare_values = [](const auto& values) -> std::vector<FLBA> {
+    std::vector<FLBA> out(values.size());
+    std::transform(values.begin(), values.end(), out.begin(),
+                   [](const F16& f16) { return FLBA{f16.bytes()}; });
+    return out;
+  };
+
+  auto all_nans = prepare_values(all_nans_f16);
+  auto some_nans = prepare_values(some_nans_f16);
+  auto other_nans = prepare_values(other_nans_f16);
+
+  uint8_t valid_bitmap = 0x7F;  // 0b01111111
+  // NaNs excluded
+  uint8_t valid_bitmap_no_nans = 0x6E;  // 0b01101110
 
-  // An array that doesn't start with NaN
-  std::array<T, kNumValues> other_nans{1.5f, max, -3.0f, -1.0f, nan, 2.0f, min, nan};
-  auto other_stats = MakeStatistics<ParquetType>(&descr);
-  AssertMinMaxAre(other_stats, other_nans, min, max);
+  this->CheckNaNs(&descr, all_nans, some_nans, other_nans, min, max, valid_bitmap,
+                  valid_bitmap_no_nans);
 }
 
-TEST(TestStatistic, NaNFloatValues) { CheckNaNs<FloatType>(); }
+using FloatingPointTypes = ::testing::Types<FloatType, DoubleType, Float16LogicalType>;
+
+TYPED_TEST_SUITE(TestFloatStatistics, FloatingPointTypes);
 
-TEST(TestStatistic, NaNDoubleValues) { CheckNaNs<DoubleType>(); }
+TYPED_TEST(TestFloatStatistics, NegativeZeros) { this->TestNegativeZeroes(); }
+TYPED_TEST(TestFloatStatistics, NaNs) { this->TestNaNs(); }
 
 // ARROW-7376
 TEST(TestStatisticsSortOrderFloatNaN, NaNAndNullsInfiniteLoop) {
@@ -1327,58 +1558,6 @@ TEST(TestStatisticsSortOrderFloatNaN, NaNAndNullsInfiniteLoop) {
   AssertUnsetMinMax(stats, nans_but_last, &all_but_last_valid);
 }
 
-template <typename Stats, typename Array, typename T = typename Array::value_type>
-void AssertMinMaxZeroesSign(Stats stats, const Array& values) {
-  stats->Update(values.data(), values.size(), 0);
-  ASSERT_TRUE(stats->HasMinMax());
-
-  T zero{};
-  ASSERT_EQ(stats->min(), zero);
-  ASSERT_TRUE(std::signbit(stats->min()));
-
-  ASSERT_EQ(stats->max(), zero);
-  ASSERT_FALSE(std::signbit(stats->max()));
-}
-
-// ARROW-5562: Ensure that -0.0f and 0.0f values are properly handled like in
-// parquet-mr
-template <typename ParquetType>
-void CheckNegativeZeroStats() {
-  using T = typename ParquetType::c_type;
-
-  NodePtr node = PrimitiveNode::Make("f", Repetition::OPTIONAL, ParquetType::type_num);
-  ColumnDescriptor descr(node, 1, 1);
-  T zero{};
-
-  {
-    std::array<T, 2> values{-zero, zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
-  }
-
-  {
-    std::array<T, 2> values{zero, -zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
-  }
-
-  {
-    std::array<T, 2> values{-zero, -zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
-  }
-
-  {
-    std::array<T, 2> values{zero, zero};
-    auto stats = MakeStatistics<ParquetType>(&descr);
-    AssertMinMaxZeroesSign(stats, values);
-  }
-}
-
-TEST(TestStatistics, FloatNegativeZero) { CheckNegativeZeroStats<FloatType>(); }
-
-TEST(TestStatistics, DoubleNegativeZero) { CheckNegativeZeroStats<DoubleType>(); }
-
 // Test statistics for binary column with UNSIGNED sort order
 TEST(TestStatisticsSortOrderMinMax, Unsigned) {
   std::string dir_string(test::get_data_dir());
diff --git a/cpp/src/parquet/test_util.cc b/cpp/src/parquet/test_util.cc
index b65945cc7329f..a6fa8afc0f5b3 100644
--- a/cpp/src/parquet/test_util.cc
+++ b/cpp/src/parquet/test_util.cc
@@ -101,6 +101,16 @@ void random_Int96_numbers(int n, uint32_t seed, int32_t min_value, int32_t max_v
   }
 }
 
+void random_float16_numbers(int n, uint32_t seed, ::arrow::util::Float16 min_value,
+                            ::arrow::util::Float16 max_value, uint16_t* out) {
+  std::vector<float> values(n);
+  random_numbers(n, seed, static_cast<float>(min_value), static_cast<float>(max_value),
+                 values.data());
+  for (int i = 0; i < n; ++i) {
+    out[i] = ::arrow::util::Float16(values[i]).bits();
+  }
+}
+
 void random_fixed_byte_array(int n, uint32_t seed, uint8_t* buf, int len, FLBA* out) {
   std::default_random_engine gen(seed);
   std::uniform_int_distribution<int> d(0, 255);
diff --git a/cpp/src/parquet/test_util.h b/cpp/src/parquet/test_util.h
index c8578609e9b1d..59728cf53f699 100644
--- a/cpp/src/parquet/test_util.h
+++ b/cpp/src/parquet/test_util.h
@@ -33,6 +33,7 @@
 
 #include "arrow/io/memory.h"
 #include "arrow/testing/util.h"
+#include "arrow/util/float16.h"
 
 #include "parquet/column_page.h"
 #include "parquet/column_reader.h"
@@ -148,6 +149,9 @@ inline void random_numbers(int n, uint32_t seed, double min_value, double max_va
 void random_Int96_numbers(int n, uint32_t seed, int32_t min_value, int32_t max_value,
                           Int96* out);
 
+void random_float16_numbers(int n, uint32_t seed, ::arrow::util::Float16 min_value,
+                            ::arrow::util::Float16 max_value, uint16_t* out);
+
 void random_fixed_byte_array(int n, uint32_t seed, uint8_t* buf, int len, FLBA* out);
 
 void random_byte_array(int n, uint32_t seed, uint8_t* buf, ByteArray* out, int min_size,
diff --git a/cpp/src/parquet/types.cc b/cpp/src/parquet/types.cc
index 3127b60e5d1ae..04a0fc2e0117b 100644
--- a/cpp/src/parquet/types.cc
+++ b/cpp/src/parquet/types.cc
@@ -441,6 +441,8 @@ std::shared_ptr<const LogicalType> LogicalType::FromThrift(
     return BSONLogicalType::Make();
   } else if (type.__isset.UUID) {
     return UUIDLogicalType::Make();
+  } else if (type.__isset.FLOAT16) {
+    return Float16LogicalType::Make();
   } else {
     throw ParquetException("Metadata contains Thrift LogicalType that is not recognized");
   }
@@ -494,6 +496,10 @@ std::shared_ptr<const LogicalType> LogicalType::BSON() { return BSONLogicalType:
 
 std::shared_ptr<const LogicalType> LogicalType::UUID() { return UUIDLogicalType::Make(); }
 
+std::shared_ptr<const LogicalType> LogicalType::Float16() {
+  return Float16LogicalType::Make();
+}
+
 std::shared_ptr<const LogicalType> LogicalType::None() { return NoLogicalType::Make(); }
 
 /*
@@ -575,6 +581,7 @@ class LogicalType::Impl {
   class JSON;
   class BSON;
   class UUID;
+  class Float16;
   class No;
   class Undefined;
 
@@ -644,6 +651,9 @@ bool LogicalType::is_null() const { return impl_->type() == LogicalType::Type::N
 bool LogicalType::is_JSON() const { return impl_->type() == LogicalType::Type::JSON; }
 bool LogicalType::is_BSON() const { return impl_->type() == LogicalType::Type::BSON; }
 bool LogicalType::is_UUID() const { return impl_->type() == LogicalType::Type::UUID; }
+bool LogicalType::is_float16() const {
+  return impl_->type() == LogicalType::Type::FLOAT16;
+}
 bool LogicalType::is_none() const { return impl_->type() == LogicalType::Type::NONE; }
 bool LogicalType::is_valid() const {
   return impl_->type() != LogicalType::Type::UNDEFINED;
@@ -1557,6 +1567,22 @@ class LogicalType::Impl::UUID final : public LogicalType::Impl::Incompatible,
 
 GENERATE_MAKE(UUID)
 
+class LogicalType::Impl::Float16 final : public LogicalType::Impl::Incompatible,
+                                         public LogicalType::Impl::TypeLengthApplicable {
+ public:
+  friend class Float16LogicalType;
+
+  OVERRIDE_TOSTRING(Float16)
+  OVERRIDE_TOTHRIFT(Float16Type, FLOAT16)
+
+ private:
+  Float16()
+      : LogicalType::Impl(LogicalType::Type::FLOAT16, SortOrder::SIGNED),
+        LogicalType::Impl::TypeLengthApplicable(parquet::Type::FIXED_LEN_BYTE_ARRAY, 2) {}
+};
+
+GENERATE_MAKE(Float16)
+
 class LogicalType::Impl::No final : public LogicalType::Impl::SimpleCompatible,
                                     public LogicalType::Impl::UniversalApplicable {
  public:
diff --git a/cpp/src/parquet/types.h b/cpp/src/parquet/types.h
index 0315376a883e9..76dd0efc7cb4a 100644
--- a/cpp/src/parquet/types.h
+++ b/cpp/src/parquet/types.h
@@ -157,6 +157,7 @@ class PARQUET_EXPORT LogicalType {
       JSON,
       BSON,
       UUID,
+      FLOAT16,
       NONE  // Not a real logical type; should always be last element
     };
   };
@@ -210,6 +211,7 @@ class PARQUET_EXPORT LogicalType {
   static std::shared_ptr<const LogicalType> JSON();
   static std::shared_ptr<const LogicalType> BSON();
   static std::shared_ptr<const LogicalType> UUID();
+  static std::shared_ptr<const LogicalType> Float16();
 
   /// \brief Create a placeholder for when no logical type is specified
   static std::shared_ptr<const LogicalType> None();
@@ -263,6 +265,7 @@ class PARQUET_EXPORT LogicalType {
   bool is_JSON() const;
   bool is_BSON() const;
   bool is_UUID() const;
+  bool is_float16() const;
   bool is_none() const;
   /// \brief Return true if this logical type is of a known type.
   bool is_valid() const;
@@ -433,6 +436,16 @@ class PARQUET_EXPORT UUIDLogicalType : public LogicalType {
   UUIDLogicalType() = default;
 };
 
+/// \brief Allowed for physical type FIXED_LEN_BYTE_ARRAY with length 2,
+/// must encode raw FLOAT16 bytes.
+class PARQUET_EXPORT Float16LogicalType : public LogicalType {
+ public:
+  static std::shared_ptr<const LogicalType> Make();
+
+ private:
+  Float16LogicalType() = default;
+};
+
 /// \brief Allowed for any physical type.
 class PARQUET_EXPORT NoLogicalType : public LogicalType {
  public:
diff --git a/docs/source/cpp/parquet.rst b/docs/source/cpp/parquet.rst
index 23fca8fd73010..3e06352f5dde3 100644
--- a/docs/source/cpp/parquet.rst
+++ b/docs/source/cpp/parquet.rst
@@ -481,6 +481,8 @@ physical type.
 +-------------------+-----------------------------+----------------------------+---------+
 | MAP               | Any                         | Map                        | \(6)    |
 +-------------------+-----------------------------+----------------------------+---------+
+| FLOAT16           | FIXED_LENGTH_BYTE_ARRAY     | HalfFloat                  |         |
++-------------------+-----------------------------+----------------------------+---------+
 
 * \(1) On the write side, the Parquet physical type INT32 is generated.
 

From d076c69e81e5d331bae214a3cf9fabedb17752fa Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Wed, 15 Nov 2023 16:15:42 +0100
Subject: [PATCH 739/749] GH-38676: [Python] Fix potential deadlock when CSV
 reading errors out (#38713)

### Rationale for this change

A deadlock can happen in a C++ destructor in the following case:
* the C++ destructor is called from Python, holding the GIL
* the C++ destructor waits for a threaded task to finish
* the threaded task has invoked some Python code which is waiting to acquire the GIL

### What changes are included in this PR?

To reliably present such a deadlock, introduce `std::shared_ptr` and `std::unique_ptr` wrappers that release the GIL when deallocating the embedded pointer.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.
* Closes: #38676

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 python/pyarrow/_csv.pyx                     |  5 +-
 python/pyarrow/_dataset.pxd                 |  8 +--
 python/pyarrow/_dataset.pyx                 |  4 +-
 python/pyarrow/_parquet.pyx                 |  6 +--
 python/pyarrow/includes/libarrow_python.pxd |  8 +++
 python/pyarrow/ipc.pxi                      |  2 +-
 python/pyarrow/lib.pxd                      |  4 +-
 python/pyarrow/src/arrow/python/common.h    | 55 +++++++++++++++++++--
 python/pyarrow/tests/test_csv.py            | 21 ++++++++
 9 files changed, 93 insertions(+), 20 deletions(-)

diff --git a/python/pyarrow/_csv.pyx b/python/pyarrow/_csv.pyx
index e532d8d8ab22a..508488c0c3b3c 100644
--- a/python/pyarrow/_csv.pyx
+++ b/python/pyarrow/_csv.pyx
@@ -26,8 +26,7 @@ from collections.abc import Mapping
 
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
-from pyarrow.includes.libarrow_python cimport (MakeInvalidRowHandler,
-                                               PyInvalidRowCallback)
+from pyarrow.includes.libarrow_python cimport *
 from pyarrow.lib cimport (check_status, Field, MemoryPool, Schema,
                           RecordBatchReader, ensure_type,
                           maybe_unbox_memory_pool, get_input_stream,
@@ -1251,7 +1250,7 @@ def read_csv(input_file, read_options=None, parse_options=None,
         CCSVParseOptions c_parse_options
         CCSVConvertOptions c_convert_options
         CIOContext io_context
-        shared_ptr[CCSVReader] reader
+        SharedPtrNoGIL[CCSVReader] reader
         shared_ptr[CTable] table
 
     _get_reader(input_file, read_options, &stream)
diff --git a/python/pyarrow/_dataset.pxd b/python/pyarrow/_dataset.pxd
index 210e5558009ec..bee9fc1f0987a 100644
--- a/python/pyarrow/_dataset.pxd
+++ b/python/pyarrow/_dataset.pxd
@@ -31,7 +31,7 @@ cdef CFileSource _make_file_source(object file, FileSystem filesystem=*)
 cdef class DatasetFactory(_Weakrefable):
 
     cdef:
-        shared_ptr[CDatasetFactory] wrapped
+        SharedPtrNoGIL[CDatasetFactory] wrapped
         CDatasetFactory* factory
 
     cdef init(self, const shared_ptr[CDatasetFactory]& sp)
@@ -45,7 +45,7 @@ cdef class DatasetFactory(_Weakrefable):
 cdef class Dataset(_Weakrefable):
 
     cdef:
-        shared_ptr[CDataset] wrapped
+        SharedPtrNoGIL[CDataset] wrapped
         CDataset* dataset
         public dict _scan_options
 
@@ -59,7 +59,7 @@ cdef class Dataset(_Weakrefable):
 
 cdef class Scanner(_Weakrefable):
     cdef:
-        shared_ptr[CScanner] wrapped
+        SharedPtrNoGIL[CScanner] wrapped
         CScanner* scanner
 
     cdef void init(self, const shared_ptr[CScanner]& sp)
@@ -122,7 +122,7 @@ cdef class FileWriteOptions(_Weakrefable):
 cdef class Fragment(_Weakrefable):
 
     cdef:
-        shared_ptr[CFragment] wrapped
+        SharedPtrNoGIL[CFragment] wrapped
         CFragment* fragment
 
     cdef void init(self, const shared_ptr[CFragment]& sp)
diff --git a/python/pyarrow/_dataset.pyx b/python/pyarrow/_dataset.pyx
index 48ee676915311..d7d69965d000a 100644
--- a/python/pyarrow/_dataset.pyx
+++ b/python/pyarrow/_dataset.pyx
@@ -3227,7 +3227,7 @@ cdef class RecordBatchIterator(_Weakrefable):
         object iterator_owner
         # Iterator is a non-POD type and Cython uses offsetof, leading
         # to a compiler warning unless wrapped like so
-        shared_ptr[CRecordBatchIterator] iterator
+        SharedPtrNoGIL[CRecordBatchIterator] iterator
 
     def __init__(self):
         _forbid_instantiation(self.__class__, subclasses_instead=False)
@@ -3273,7 +3273,7 @@ cdef class TaggedRecordBatchIterator(_Weakrefable):
     """An iterator over a sequence of record batches with fragments."""
     cdef:
         object iterator_owner
-        shared_ptr[CTaggedRecordBatchIterator] iterator
+        SharedPtrNoGIL[CTaggedRecordBatchIterator] iterator
 
     def __init__(self):
         _forbid_instantiation(self.__class__, subclasses_instead=False)
diff --git a/python/pyarrow/_parquet.pyx b/python/pyarrow/_parquet.pyx
index 48091367b2ff8..089ed7c75ce58 100644
--- a/python/pyarrow/_parquet.pyx
+++ b/python/pyarrow/_parquet.pyx
@@ -24,6 +24,7 @@ import warnings
 from cython.operator cimport dereference as deref
 from pyarrow.includes.common cimport *
 from pyarrow.includes.libarrow cimport *
+from pyarrow.includes.libarrow_python cimport *
 from pyarrow.lib cimport (_Weakrefable, Buffer, Schema,
                           check_status,
                           MemoryPool, maybe_unbox_memory_pool,
@@ -1165,7 +1166,7 @@ cdef class ParquetReader(_Weakrefable):
     cdef:
         object source
         CMemoryPool* pool
-        unique_ptr[FileReader] reader
+        UniquePtrNoGIL[FileReader] reader
         FileMetaData _metadata
         shared_ptr[CRandomAccessFile] rd_handle
 
@@ -1334,7 +1335,7 @@ cdef class ParquetReader(_Weakrefable):
             vector[int] c_row_groups
             vector[int] c_column_indices
             shared_ptr[CRecordBatch] record_batch
-            unique_ptr[CRecordBatchReader] recordbatchreader
+            UniquePtrNoGIL[CRecordBatchReader] recordbatchreader
 
         self.set_batch_size(batch_size)
 
@@ -1366,7 +1367,6 @@ cdef class ParquetReader(_Weakrefable):
                 check_status(
                     recordbatchreader.get().ReadNext(&record_batch)
                 )
-
             if record_batch.get() == NULL:
                 break
 
diff --git a/python/pyarrow/includes/libarrow_python.pxd b/python/pyarrow/includes/libarrow_python.pxd
index 4d109fc660e08..b8a3041796f97 100644
--- a/python/pyarrow/includes/libarrow_python.pxd
+++ b/python/pyarrow/includes/libarrow_python.pxd
@@ -261,6 +261,14 @@ cdef extern from "arrow/python/common.h" namespace "arrow::py":
     void RestorePyError(const CStatus& status) except *
 
 
+cdef extern from "arrow/python/common.h" namespace "arrow::py" nogil:
+    cdef cppclass SharedPtrNoGIL[T](shared_ptr[T]):
+        # This looks like the only way to satsify both Cython 2 and Cython 3
+        SharedPtrNoGIL& operator=(...)
+    cdef cppclass UniquePtrNoGIL[T, DELETER=*](unique_ptr[T, DELETER]):
+        UniquePtrNoGIL& operator=(...)
+
+
 cdef extern from "arrow/python/inference.h" namespace "arrow::py":
     c_bool IsPyBool(object o)
     c_bool IsPyInt(object o)
diff --git a/python/pyarrow/ipc.pxi b/python/pyarrow/ipc.pxi
index fcb9eb729ef04..5d20a4f8b72cb 100644
--- a/python/pyarrow/ipc.pxi
+++ b/python/pyarrow/ipc.pxi
@@ -977,7 +977,7 @@ cdef _wrap_record_batch_with_metadata(CRecordBatchWithMetadata c):
 
 cdef class _RecordBatchFileReader(_Weakrefable):
     cdef:
-        shared_ptr[CRecordBatchFileReader] reader
+        SharedPtrNoGIL[CRecordBatchFileReader] reader
         shared_ptr[CRandomAccessFile] file
         CIpcReadOptions options
 
diff --git a/python/pyarrow/lib.pxd b/python/pyarrow/lib.pxd
index 63ebe6aea8233..ae197eca1ca6b 100644
--- a/python/pyarrow/lib.pxd
+++ b/python/pyarrow/lib.pxd
@@ -552,12 +552,12 @@ cdef class CompressedOutputStream(NativeFile):
 
 cdef class _CRecordBatchWriter(_Weakrefable):
     cdef:
-        shared_ptr[CRecordBatchWriter] writer
+        SharedPtrNoGIL[CRecordBatchWriter] writer
 
 
 cdef class RecordBatchReader(_Weakrefable):
     cdef:
-        shared_ptr[CRecordBatchReader] reader
+        SharedPtrNoGIL[CRecordBatchReader] reader
 
 
 cdef class Codec(_Weakrefable):
diff --git a/python/pyarrow/src/arrow/python/common.h b/python/pyarrow/src/arrow/python/common.h
index bc567ef78e83a..4a7886695eadb 100644
--- a/python/pyarrow/src/arrow/python/common.h
+++ b/python/pyarrow/src/arrow/python/common.h
@@ -19,6 +19,7 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "arrow/buffer.h"
@@ -134,13 +135,15 @@ class ARROW_PYTHON_EXPORT PyAcquireGIL {
 // A RAII-style helper that releases the GIL until the end of a lexical block
 class ARROW_PYTHON_EXPORT PyReleaseGIL {
  public:
-  PyReleaseGIL() { saved_state_ = PyEval_SaveThread(); }
-
-  ~PyReleaseGIL() { PyEval_RestoreThread(saved_state_); }
+  PyReleaseGIL() : ptr_(PyEval_SaveThread(), &unique_ptr_deleter) {}
 
  private:
-  PyThreadState* saved_state_;
-  ARROW_DISALLOW_COPY_AND_ASSIGN(PyReleaseGIL);
+  static void unique_ptr_deleter(PyThreadState* state) {
+    if (state) {
+      PyEval_RestoreThread(state);
+    }
+  }
+  std::unique_ptr<PyThreadState, decltype(&unique_ptr_deleter)> ptr_;
 };
 
 // A helper to call safely into the Python interpreter from arbitrary C++ code.
@@ -238,6 +241,48 @@ class ARROW_PYTHON_EXPORT OwnedRefNoGIL : public OwnedRef {
   }
 };
 
+template <template <typename...> typename SmartPtr, typename... Ts>
+class SmartPtrNoGIL : public SmartPtr<Ts...> {
+  using Base = SmartPtr<Ts...>;
+
+ public:
+  template <typename... Args>
+  SmartPtrNoGIL(Args&&... args) : Base(std::forward<Args>(args)...) {}
+
+  ~SmartPtrNoGIL() { reset(); }
+
+  template <typename... Args>
+  void reset(Args&&... args) {
+    auto release_guard = optional_gil_release();
+    Base::reset(std::forward<Args>(args)...);
+  }
+
+  template <typename V>
+  SmartPtrNoGIL& operator=(V&& v) {
+    auto release_guard = optional_gil_release();
+    Base::operator=(std::forward<V>(v));
+    return *this;
+  }
+
+ private:
+  // Only release the GIL if we own an object *and* the Python runtime is
+  // valid *and* the GIL is held.
+  std::optional<PyReleaseGIL> optional_gil_release() const {
+    if (this->get() != nullptr && Py_IsInitialized() && PyGILState_Check()) {
+      return PyReleaseGIL();
+    }
+    return {};
+  }
+};
+
+/// \brief A std::shared_ptr<T, ...> subclass that releases the GIL when destroying T
+template <typename... Ts>
+using SharedPtrNoGIL = SmartPtrNoGIL<std::shared_ptr, Ts...>;
+
+/// \brief A std::unique_ptr<T, ...> subclass that releases the GIL when destroying T
+template <typename... Ts>
+using UniquePtrNoGIL = SmartPtrNoGIL<std::unique_ptr, Ts...>;
+
 template <typename Fn>
 struct BoundFunction;
 
diff --git a/python/pyarrow/tests/test_csv.py b/python/pyarrow/tests/test_csv.py
index afc5380b75516..31f24187e3b37 100644
--- a/python/pyarrow/tests/test_csv.py
+++ b/python/pyarrow/tests/test_csv.py
@@ -1970,3 +1970,24 @@ def test_write_csv_decimal(tmpdir, type_factory):
     out = read_csv(tmpdir / "out.csv")
 
     assert out.column('col').cast(type) == table.column('col')
+
+
+def test_read_csv_gil_deadlock():
+    # GH-38676
+    # This test depends on several preconditions:
+    # - the CSV input is a Python file object
+    # - reading the CSV file produces an error
+    data = b"a,b,c"
+
+    class MyBytesIO(io.BytesIO):
+        def read(self, *args):
+            time.sleep(0.001)
+            return super().read(*args)
+
+        def readinto(self, *args):
+            time.sleep(0.001)
+            return super().readinto(*args)
+
+    for i in range(20):
+        with pytest.raises(pa.ArrowInvalid):
+            read_csv(MyBytesIO(data))

From dfdebdd9199e51b92ed372220b7f33b1aab2d37b Mon Sep 17 00:00:00 2001
From: mwish <maplewish117@gmail.com>
Date: Wed, 15 Nov 2023 23:38:34 +0800
Subject: [PATCH 740/749] GH-38503: [Go][Parquet] Style improvement for using
 ArrowColumnWriter (#38581)

### Rationale for this change

Currently, `ArrowColumnWriter` seems not having bug. But the usage is confusing. For nested type,  `ArrowColumnWriter` should considering the logic below:

```
  /// 0 foo.bar
  ///       foo.bar.baz           0
  ///       foo.bar.baz2          1
  ///   foo.qux                   2
  /// 1 foo2                      3
  /// 2 foo3                      4
```

The left column is the column in root of `arrow::Schema`, the parquet itself only stores Leaf node,
so, the column id for parquet is list at right.

In the `ArrowColumnWriter`, the final argument is the LeafIdx in parquet, so, writer should considering
using `leafIdx`. Also, it need a `LeafCount` API for getting the leaf-count here.

### What changes are included in this PR?

Style enhancement for `LeafCount`, `leafIdx` and usage for `ArrowColumnWriter`

### Are these changes tested?

no

### Are there any user-facing changes?

no

* Closes: #38503

Authored-by: mwish <maplewish117@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/internal/encoding/levels.go  | 12 ++++++------
 go/parquet/pqarrow/encode_arrow.go      | 10 +++++++---
 go/parquet/pqarrow/encode_arrow_test.go | 12 +++++++++---
 go/parquet/pqarrow/path_builder.go      |  4 ++--
 4 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/go/parquet/internal/encoding/levels.go b/go/parquet/internal/encoding/levels.go
index caf832059334b..2a6dc24933714 100644
--- a/go/parquet/internal/encoding/levels.go
+++ b/go/parquet/internal/encoding/levels.go
@@ -19,6 +19,7 @@ package encoding
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math/bits"
 
@@ -28,7 +29,6 @@ import (
 	"github.com/apache/arrow/go/v15/parquet"
 	format "github.com/apache/arrow/go/v15/parquet/internal/gen-go/parquet"
 	"github.com/apache/arrow/go/v15/parquet/internal/utils"
-	"golang.org/x/xerrors"
 )
 
 // LevelEncoder is for handling the encoding of Definition and Repetition levels
@@ -194,12 +194,12 @@ func (l *LevelDecoder) SetData(encoding parquet.Encoding, maxLvl int16, nbuffere
 	switch encoding {
 	case parquet.Encodings.RLE:
 		if len(data) < 4 {
-			return 0, xerrors.New("parquet: received invalid levels (corrupt data page?)")
+			return 0, errors.New("parquet: received invalid levels (corrupt data page?)")
 		}
 
 		nbytes := int32(binary.LittleEndian.Uint32(data[:4]))
 		if nbytes < 0 || nbytes > int32(len(data)-4) {
-			return 0, xerrors.New("parquet: received invalid number of bytes (corrupt data page?)")
+			return 0, errors.New("parquet: received invalid number of bytes (corrupt data page?)")
 		}
 
 		buf := data[4:]
@@ -212,12 +212,12 @@ func (l *LevelDecoder) SetData(encoding parquet.Encoding, maxLvl int16, nbuffere
 	case parquet.Encodings.BitPacked:
 		nbits, ok := overflow.Mul(nbuffered, l.bitWidth)
 		if !ok {
-			return 0, xerrors.New("parquet: number of buffered values too large (corrupt data page?)")
+			return 0, errors.New("parquet: number of buffered values too large (corrupt data page?)")
 		}
 
 		nbytes := bitutil.BytesForBits(int64(nbits))
 		if nbytes < 0 || nbytes > int64(len(data)) {
-			return 0, xerrors.New("parquet: recieved invalid number of bytes (corrupt data page?)")
+			return 0, errors.New("parquet: received invalid number of bytes (corrupt data page?)")
 		}
 		if l.bit == nil {
 			l.bit = utils.NewBitReader(bytes.NewReader(data))
@@ -234,7 +234,7 @@ func (l *LevelDecoder) SetData(encoding parquet.Encoding, maxLvl int16, nbuffere
 // run length encoding.
 func (l *LevelDecoder) SetDataV2(nbytes int32, maxLvl int16, nbuffered int, data []byte) error {
 	if nbytes < 0 {
-		return xerrors.New("parquet: invalid page header (corrupt data page?)")
+		return errors.New("parquet: invalid page header (corrupt data page?)")
 	}
 
 	l.maxLvl = maxLvl
diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index 1855d3625adb7..4989837cd03bc 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -81,7 +81,7 @@ type ArrowColumnWriter struct {
 //
 // Using an arrow column writer is a convenience to avoid having to process the arrow array yourself
 // and determine the correct definition and repetition levels manually.
-func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *SchemaManifest, rgw file.RowGroupWriter, col int) (ArrowColumnWriter, error) {
+func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *SchemaManifest, rgw file.RowGroupWriter, leafColIdx int) (ArrowColumnWriter, error) {
 	if data.Len() == 0 {
 		return ArrowColumnWriter{leafCount: calcLeafCount(data.DataType()), rgw: rgw}, nil
 	}
@@ -118,7 +118,7 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 	// which is the one this instance will start writing for
 	// colIdx := rgw.CurrentColumn() + 1
 
-	schemaField, err := manifest.GetColumnField(col)
+	schemaField, err := manifest.GetColumnField(leafColIdx)
 	if err != nil {
 		return ArrowColumnWriter{}, err
 	}
@@ -153,7 +153,11 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 		values += chunkWriteSize
 	}
 
-	return ArrowColumnWriter{builders: builders, leafCount: leafCount, rgw: rgw, colIdx: col}, nil
+	return ArrowColumnWriter{builders: builders, leafCount: leafCount, rgw: rgw, colIdx: leafColIdx}, nil
+}
+
+func (acw *ArrowColumnWriter) LeafCount() int {
+	return acw.leafCount
 }
 
 func (acw *ArrowColumnWriter) Write(ctx context.Context) error {
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index d588aff701f3d..712a003c63ad6 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -145,10 +145,12 @@ func TestWriteArrowCols(t *testing.T) {
 	srgw := writer.AppendRowGroup()
 	ctx := pqarrow.NewArrowWriteContext(context.TODO(), nil)
 
+	colIdx := 0
 	for i := int64(0); i < tbl.NumCols(); i++ {
-		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, int(i))
+		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, colIdx)
 		require.NoError(t, err)
 		require.NoError(t, acw.Write(ctx))
+		colIdx = colIdx + acw.LeafCount()
 	}
 	require.NoError(t, srgw.Close())
 	require.NoError(t, writer.Close())
@@ -249,10 +251,12 @@ func TestWriteArrowInt96(t *testing.T) {
 	srgw := writer.AppendRowGroup()
 	ctx := pqarrow.NewArrowWriteContext(context.TODO(), &props)
 
+	colIdx := 0
 	for i := int64(0); i < tbl.NumCols(); i++ {
-		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, int(i))
+		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, colIdx)
 		require.NoError(t, err)
 		require.NoError(t, acw.Write(ctx))
+		colIdx += acw.LeafCount()
 	}
 	require.NoError(t, srgw.Close())
 	require.NoError(t, writer.Close())
@@ -306,11 +310,13 @@ func writeTableToBuffer(t *testing.T, mem memory.Allocator, tbl arrow.Table, row
 	for offset < tbl.NumRows() {
 		sz := utils.Min(rowGroupSize, tbl.NumRows()-offset)
 		srgw := writer.AppendRowGroup()
+		colIdx := 0
 		for i := 0; i < int(tbl.NumCols()); i++ {
 			col := tbl.Column(i)
-			acw, err := pqarrow.NewArrowColumnWriter(col.Data(), offset, sz, manifest, srgw, i)
+			acw, err := pqarrow.NewArrowColumnWriter(col.Data(), offset, sz, manifest, srgw, colIdx)
 			require.NoError(t, err)
 			require.NoError(t, acw.Write(ctx))
+			colIdx = colIdx + acw.LeafCount()
 		}
 		srgw.Close()
 		offset += sz
diff --git a/go/parquet/pqarrow/path_builder.go b/go/parquet/pqarrow/path_builder.go
index 0f1158bd1e9f0..57a077956edea 100644
--- a/go/parquet/pqarrow/path_builder.go
+++ b/go/parquet/pqarrow/path_builder.go
@@ -206,7 +206,7 @@ func (n *listNode) fillForLast(rng, childRng *elemRange, ctx *pathWriteCtx) iter
 	fillRepLevels(int(childRng.size()), n.repLevel, ctx)
 	// once we've reached this point the following preconditions should hold:
 	// 1. there are no more repeated path nodes to deal with
-	// 2. all elements in |range| reperesent contiguous elements in the child
+	// 2. all elements in |range| represent contiguous elements in the child
 	//    array (null values would have shortened the range to ensure all
 	//    remaining list elements are present, though they may be empty)
 	// 3. no element of range spans a parent list (intermediate list nodes
@@ -225,7 +225,7 @@ func (n *listNode) fillForLast(rng, childRng *elemRange, ctx *pathWriteCtx) iter
 
 		// this is the start of a new list. we can be sure that it only applies to the
 		// previous list (and doesn't jump to the start of any list further up in nesting
-		// due to the contraints mentioned earlier)
+		// due to the constraints mentioned earlier)
 		ctx.AppendRepLevel(n.prevRepLevel)
 		ctx.AppendRepLevels(int(sizeCheck.size())-1, n.repLevel)
 		childRng.end = sizeCheck.end

From 41e45fed07a6466b1f8e9437220c9bf49c4a8cb3 Mon Sep 17 00:00:00 2001
From: Yue <niyue.com@gmail.com>
Date: Thu, 16 Nov 2023 00:22:36 +0800
Subject: [PATCH 741/749] GH-38697: [C++][Gandiva] Use arrow io util to replace
 std::filesystem::path in gandiva (#38698)

### Rationale for this change
AlmaLinux 8 CI reported linker failure when `std::filesystem::path` is used, and This PR tries to it.

### What changes are included in this PR?
Replace replace `std::filesystem::path` in gandiva with arrow's internal io util so that AlmaLinux 8 CI build can work.

### Are these changes tested?
It should be covered by existing tests and CI.

### Are there any user-facing changes?
No
* Closes: #38697

Lead-authored-by: Yue Ni <niyue.com@gmail.com>
Co-authored-by: Yue <niyue.com@gmail.com>
Co-authored-by: Antoine Pitrou <antoine@python.org>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 cpp/src/gandiva/tests/test_util.cc | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/cpp/src/gandiva/tests/test_util.cc b/cpp/src/gandiva/tests/test_util.cc
index 42f67d3824a21..4a0a15c7223db 100644
--- a/cpp/src/gandiva/tests/test_util.cc
+++ b/cpp/src/gandiva/tests/test_util.cc
@@ -17,12 +17,12 @@
 
 #include "gandiva/tests/test_util.h"
 
-#include <filesystem>
+#include "arrow/util/io_util.h"
+#include "arrow/util/logging.h"
 
 namespace gandiva {
 std::shared_ptr<Configuration> TestConfiguration() {
-  auto builder = ConfigurationBuilder();
-  return builder.DefaultConfiguration();
+  return ConfigurationBuilder::DefaultConfiguration();
 }
 
 #ifndef GANDIVA_EXTENSION_TEST_DIR
@@ -30,9 +30,10 @@ std::shared_ptr<Configuration> TestConfiguration() {
 #endif
 
 std::string GetTestFunctionLLVMIRPath() {
-  std::filesystem::path base(GANDIVA_EXTENSION_TEST_DIR);
-  std::filesystem::path ir_file = base / "multiply_by_two.bc";
-  return ir_file.string();
+  const auto base =
+      arrow::internal::PlatformFilename::FromString(GANDIVA_EXTENSION_TEST_DIR);
+  DCHECK_OK(base.status());
+  return base->Join("multiply_by_two.bc")->ToString();
 }
 
 NativeFunction GetTestExternalFunction() {

From 1e7175db8d78313935cd1161728e9ae9dae57c9c Mon Sep 17 00:00:00 2001
From: Tim Schaub <tschaub@users.noreply.github.com>
Date: Wed, 15 Nov 2023 10:16:11 -0700
Subject: [PATCH 742/749] GH-38503: [Go][Parquet] Make the arrow column writer
 internal (#38727)

This makes it so the Arrow column writer is not exported from the `pqarrow` package.  This follows up on comments from #38581.
* Closes: #38503

Authored-by: Tim Schaub <tim@planet.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 go/parquet/pqarrow/encode_arrow.go      | 26 ++++----
 go/parquet/pqarrow/encode_arrow_test.go | 80 ++++++++++---------------
 go/parquet/pqarrow/file_writer.go       |  2 +-
 3 files changed, 44 insertions(+), 64 deletions(-)

diff --git a/go/parquet/pqarrow/encode_arrow.go b/go/parquet/pqarrow/encode_arrow.go
index 4989837cd03bc..8926d0ba51a07 100644
--- a/go/parquet/pqarrow/encode_arrow.go
+++ b/go/parquet/pqarrow/encode_arrow.go
@@ -65,25 +65,25 @@ func nullableRoot(manifest *SchemaManifest, field *SchemaField) bool {
 	return nullable
 }
 
-// ArrowColumnWriter is a convenience object for easily writing arrow data to a specific
+// arrowColumnWriter is a convenience object for easily writing arrow data to a specific
 // set of columns in a parquet file. Since a single arrow array can itself be a nested type
 // consisting of multiple columns of data, this will write to all of the appropriate leaves in
 // the parquet file, allowing easy writing of nested columns.
-type ArrowColumnWriter struct {
+type arrowColumnWriter struct {
 	builders  []*multipathLevelBuilder
 	leafCount int
 	colIdx    int
 	rgw       file.RowGroupWriter
 }
 
-// NewArrowColumnWriter returns a new writer using the chunked array to determine the number of leaf columns,
+// newArrowColumnWriter returns a new writer using the chunked array to determine the number of leaf columns,
 // and the provided schema manifest to determine the paths for writing the columns.
 //
 // Using an arrow column writer is a convenience to avoid having to process the arrow array yourself
 // and determine the correct definition and repetition levels manually.
-func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *SchemaManifest, rgw file.RowGroupWriter, leafColIdx int) (ArrowColumnWriter, error) {
+func newArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *SchemaManifest, rgw file.RowGroupWriter, leafColIdx int) (arrowColumnWriter, error) {
 	if data.Len() == 0 {
-		return ArrowColumnWriter{leafCount: calcLeafCount(data.DataType()), rgw: rgw}, nil
+		return arrowColumnWriter{leafCount: calcLeafCount(data.DataType()), rgw: rgw}, nil
 	}
 
 	var (
@@ -109,7 +109,7 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 	}
 
 	if absPos >= int64(data.Len()) {
-		return ArrowColumnWriter{}, errors.New("cannot write data at offset past end of chunked array")
+		return arrowColumnWriter{}, errors.New("cannot write data at offset past end of chunked array")
 	}
 
 	leafCount := calcLeafCount(data.DataType())
@@ -120,7 +120,7 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 
 	schemaField, err := manifest.GetColumnField(leafColIdx)
 	if err != nil {
-		return ArrowColumnWriter{}, err
+		return arrowColumnWriter{}, err
 	}
 	isNullable = nullableRoot(manifest, schemaField)
 
@@ -138,10 +138,10 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 		if arrToWrite.Len() > 0 {
 			bldr, err := newMultipathLevelBuilder(arrToWrite, isNullable)
 			if err != nil {
-				return ArrowColumnWriter{}, nil
+				return arrowColumnWriter{}, nil
 			}
 			if leafCount != bldr.leafCount() {
-				return ArrowColumnWriter{}, fmt.Errorf("data type leaf_count != builder leafcount: %d - %d", leafCount, bldr.leafCount())
+				return arrowColumnWriter{}, fmt.Errorf("data type leaf_count != builder leafcount: %d - %d", leafCount, bldr.leafCount())
 			}
 			builders = append(builders, bldr)
 		}
@@ -153,14 +153,10 @@ func NewArrowColumnWriter(data *arrow.Chunked, offset, size int64, manifest *Sch
 		values += chunkWriteSize
 	}
 
-	return ArrowColumnWriter{builders: builders, leafCount: leafCount, rgw: rgw, colIdx: leafColIdx}, nil
+	return arrowColumnWriter{builders: builders, leafCount: leafCount, rgw: rgw, colIdx: leafColIdx}, nil
 }
 
-func (acw *ArrowColumnWriter) LeafCount() int {
-	return acw.leafCount
-}
-
-func (acw *ArrowColumnWriter) Write(ctx context.Context) error {
+func (acw *arrowColumnWriter) Write(ctx context.Context) error {
 	arrCtx := arrowCtxFromContext(ctx)
 	for leafIdx := 0; leafIdx < acw.leafCount; leafIdx++ {
 		var (
diff --git a/go/parquet/pqarrow/encode_arrow_test.go b/go/parquet/pqarrow/encode_arrow_test.go
index 712a003c63ad6..95ea644dd8013 100644
--- a/go/parquet/pqarrow/encode_arrow_test.go
+++ b/go/parquet/pqarrow/encode_arrow_test.go
@@ -132,28 +132,24 @@ func TestWriteArrowCols(t *testing.T) {
 	tbl := makeDateTimeTypesTable(mem, false, false)
 	defer tbl.Release()
 
-	psc, err := pqarrow.ToParquet(tbl.Schema(), nil, pqarrow.NewArrowWriterProperties(pqarrow.WithAllocator(mem)))
-	require.NoError(t, err)
-
-	manifest, err := pqarrow.NewSchemaManifest(psc, nil, nil)
-	require.NoError(t, err)
-
 	sink := encoding.NewBufferWriter(0, mem)
 	defer sink.Release()
-	writer := file.NewParquetWriter(sink, psc.Root(), file.WithWriterProps(parquet.NewWriterProperties(parquet.WithVersion(parquet.V2_4))))
 
-	srgw := writer.AppendRowGroup()
-	ctx := pqarrow.NewArrowWriteContext(context.TODO(), nil)
+	fileWriter, err := pqarrow.NewFileWriter(
+		tbl.Schema(),
+		sink,
+		parquet.NewWriterProperties(parquet.WithVersion(parquet.V2_4)),
+		pqarrow.NewArrowWriterProperties(pqarrow.WithAllocator(mem)),
+	)
+	require.NoError(t, err)
 
-	colIdx := 0
+	fileWriter.NewRowGroup()
 	for i := int64(0); i < tbl.NumCols(); i++ {
-		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, colIdx)
+		colChunk := tbl.Column(int(i)).Data()
+		err := fileWriter.WriteColumnChunked(colChunk, 0, int64(colChunk.Len()))
 		require.NoError(t, err)
-		require.NoError(t, acw.Write(ctx))
-		colIdx = colIdx + acw.LeafCount()
 	}
-	require.NoError(t, srgw.Close())
-	require.NoError(t, writer.Close())
+	require.NoError(t, fileWriter.Close())
 
 	expected := makeDateTimeTypesTable(mem, true, false)
 	defer expected.Release()
@@ -235,31 +231,24 @@ func TestWriteArrowInt96(t *testing.T) {
 	tbl := makeDateTimeTypesTable(mem, false, false)
 	defer tbl.Release()
 
-	props := pqarrow.NewArrowWriterProperties(pqarrow.WithDeprecatedInt96Timestamps(true), pqarrow.WithAllocator(mem))
-
-	psc, err := pqarrow.ToParquet(tbl.Schema(), nil, props)
-	require.NoError(t, err)
-
-	manifest, err := pqarrow.NewSchemaManifest(psc, nil, nil)
-	require.NoError(t, err)
-
 	sink := encoding.NewBufferWriter(0, mem)
 	defer sink.Release()
 
-	writer := file.NewParquetWriter(sink, psc.Root(), file.WithWriterProps(parquet.NewWriterProperties(parquet.WithAllocator(mem))))
-
-	srgw := writer.AppendRowGroup()
-	ctx := pqarrow.NewArrowWriteContext(context.TODO(), &props)
+	fileWriter, err := pqarrow.NewFileWriter(
+		tbl.Schema(),
+		sink,
+		parquet.NewWriterProperties(parquet.WithAllocator(mem)),
+		pqarrow.NewArrowWriterProperties(pqarrow.WithDeprecatedInt96Timestamps(true), pqarrow.WithAllocator(mem)),
+	)
+	require.NoError(t, err)
 
-	colIdx := 0
+	fileWriter.NewRowGroup()
 	for i := int64(0); i < tbl.NumCols(); i++ {
-		acw, err := pqarrow.NewArrowColumnWriter(tbl.Column(int(i)).Data(), 0, tbl.NumRows(), manifest, srgw, colIdx)
+		colChunk := tbl.Column(int(i)).Data()
+		err := fileWriter.WriteColumnChunked(colChunk, 0, int64(colChunk.Len()))
 		require.NoError(t, err)
-		require.NoError(t, acw.Write(ctx))
-		colIdx += acw.LeafCount()
 	}
-	require.NoError(t, srgw.Close())
-	require.NoError(t, writer.Close())
+	require.NoError(t, fileWriter.Close())
 
 	expected := makeDateTimeTypesTable(mem, false, false)
 	defer expected.Release()
@@ -296,33 +285,28 @@ func TestWriteArrowInt96(t *testing.T) {
 func writeTableToBuffer(t *testing.T, mem memory.Allocator, tbl arrow.Table, rowGroupSize int64, props pqarrow.ArrowWriterProperties) *memory.Buffer {
 	sink := encoding.NewBufferWriter(0, mem)
 	defer sink.Release()
-	wrprops := parquet.NewWriterProperties(parquet.WithVersion(parquet.V1_0))
-	psc, err := pqarrow.ToParquet(tbl.Schema(), wrprops, props)
-	require.NoError(t, err)
 
-	manifest, err := pqarrow.NewSchemaManifest(psc, nil, nil)
+	fileWriter, err := pqarrow.NewFileWriter(
+		tbl.Schema(),
+		sink,
+		parquet.NewWriterProperties(parquet.WithVersion(parquet.V1_0)),
+		props,
+	)
 	require.NoError(t, err)
 
-	writer := file.NewParquetWriter(sink, psc.Root(), file.WithWriterProps(wrprops))
-	ctx := pqarrow.NewArrowWriteContext(context.TODO(), &props)
-
 	offset := int64(0)
 	for offset < tbl.NumRows() {
 		sz := utils.Min(rowGroupSize, tbl.NumRows()-offset)
-		srgw := writer.AppendRowGroup()
-		colIdx := 0
+		fileWriter.NewRowGroup()
 		for i := 0; i < int(tbl.NumCols()); i++ {
-			col := tbl.Column(i)
-			acw, err := pqarrow.NewArrowColumnWriter(col.Data(), offset, sz, manifest, srgw, colIdx)
+			colChunk := tbl.Column(i).Data()
+			err := fileWriter.WriteColumnChunked(colChunk, 0, int64(colChunk.Len()))
 			require.NoError(t, err)
-			require.NoError(t, acw.Write(ctx))
-			colIdx = colIdx + acw.LeafCount()
 		}
-		srgw.Close()
 		offset += sz
 	}
-	writer.Close()
 
+	require.NoError(t, fileWriter.Close())
 	return sink.Finish()
 }
 
diff --git a/go/parquet/pqarrow/file_writer.go b/go/parquet/pqarrow/file_writer.go
index 21f16c0b67938..bc484ba243f87 100644
--- a/go/parquet/pqarrow/file_writer.go
+++ b/go/parquet/pqarrow/file_writer.go
@@ -305,7 +305,7 @@ func (fw *FileWriter) Close() error {
 // building of writing columns to a file via arrow data without needing to already have
 // a record or table.
 func (fw *FileWriter) WriteColumnChunked(data *arrow.Chunked, offset, size int64) error {
-	acw, err := NewArrowColumnWriter(data, offset, size, fw.manifest, fw.rgw, fw.colIdx)
+	acw, err := newArrowColumnWriter(data, offset, size, fw.manifest, fw.rgw, fw.colIdx)
 	if err != nil {
 		return err
 	}

From 563078fb70f7d23e716a2c1c79e96f7409c02f3f Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Wed, 15 Nov 2023 11:49:41 -0800
Subject: [PATCH 743/749] GH-38318: [Java][FlightRPC] Enable tests that leaked
 (#38719)

### Rationale for this change
This enables tests that are currently disabled to improve coverage and help others build tests based on these.

### What changes are included in this PR?
- Enable tests that were disabled due to flakey memory leaks
- Explicitly close child allocators in these tests to match
  the behavior of FlightServerTestRule which does not leak.
- Change TestBasicAuth to allocate only one server
- Change TestBasicAuth2 to allocate only one server and client
- Fix a bug in testBasucAuth2#asyncPut() not including credentials

### Are these changes tested?
Tested locally.

### Are there any user-facing changes?
No.
* Closes: #38318

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/flight/auth/TestBasicAuth.java      | 29 +++++++++----
 .../arrow/flight/auth2/TestBasicAuth2.java    | 42 +++++++++----------
 .../arrow/flight/TestFlightSqlStreams.java    | 12 +++---
 3 files changed, 46 insertions(+), 37 deletions(-)

diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth/TestBasicAuth.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth/TestBasicAuth.java
index 6544b23dab635..176277866b73a 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth/TestBasicAuth.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth/TestBasicAuth.java
@@ -41,10 +41,11 @@
 import org.apache.arrow.vector.types.Types;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.ImmutableList;
@@ -56,8 +57,8 @@ public class TestBasicAuth {
   private static final byte[] VALID_TOKEN = "my_token".getBytes(StandardCharsets.UTF_8);
 
   private FlightClient client;
-  private FlightServer server;
-  private BufferAllocator allocator;
+  private static FlightServer server;
+  private static BufferAllocator allocator;
 
   @Test
   public void validAuth() {
@@ -65,8 +66,6 @@ public void validAuth() {
     Assertions.assertTrue(ImmutableList.copyOf(client.listFlights(Criteria.ALL)).size() == 0);
   }
 
-  // ARROW-7722: this test occasionally leaks memory
-  @Disabled
   @Test
   public void asyncCall() throws Exception {
     client.authenticateBasic(USERNAME, PASSWORD);
@@ -97,7 +96,12 @@ public void didntAuth() {
   }
 
   @BeforeEach
-  public void setup() throws IOException {
+  public void testSetup() throws IOException {
+    client = FlightClient.builder(allocator, server.getLocation()).build();
+  }
+
+  @BeforeAll
+  public static void setup() throws IOException {
     allocator = new RootAllocator(Long.MAX_VALUE);
     final BasicServerAuthHandler.BasicAuthValidator validator = new BasicServerAuthHandler.BasicAuthValidator() {
 
@@ -149,12 +153,19 @@ public void getStream(CallContext context, Ticket ticket, ServerStreamListener l
             }
           }
         }).authHandler(new BasicServerAuthHandler(validator)).build().start();
-    client = FlightClient.builder(allocator, server.getLocation()).build();
   }
 
   @AfterEach
-  public void shutdown() throws Exception {
-    AutoCloseables.close(client, server, allocator);
+  public void tearDown() throws Exception {
+    AutoCloseables.close(client);
+  }
+
+  @AfterAll
+  public static void shutdown() throws Exception {
+    AutoCloseables.close(server);
+
+    allocator.getChildAllocators().forEach(BufferAllocator::close);
+    AutoCloseables.close(allocator);
   }
 
 }
diff --git a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth2/TestBasicAuth2.java b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth2/TestBasicAuth2.java
index 4ccc73fcac10e..cadd67d3ed241 100644
--- a/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth2/TestBasicAuth2.java
+++ b/java/flight/flight-core/src/test/java/org/apache/arrow/flight/auth2/TestBasicAuth2.java
@@ -41,10 +41,9 @@
 import org.apache.arrow.vector.types.Types;
 import org.apache.arrow.vector.types.pojo.Field;
 import org.apache.arrow.vector.types.pojo.Schema;
-import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
 import com.google.common.base.Strings;
@@ -57,18 +56,18 @@ public class TestBasicAuth2 {
   private static final String NO_USERNAME = "";
   private static final String PASSWORD_1 = "woohoo1";
   private static final String PASSWORD_2 = "woohoo2";
-  private BufferAllocator allocator;
-  private FlightServer server;
-  private FlightClient client;
-  private FlightClient client2;
+  private static BufferAllocator allocator;
+  private static FlightServer server;
+  private static FlightClient client;
+  private static FlightClient client2;
 
-  @BeforeEach
-  public void setup() throws Exception {
+  @BeforeAll
+  public static void setup() throws Exception {
     allocator = new RootAllocator(Long.MAX_VALUE);
     startServerAndClient();
   }
 
-  private FlightProducer getFlightProducer() {
+  private static FlightProducer getFlightProducer() {
     return new NoOpFlightProducer() {
       @Override
       public void listFlights(CallContext context, Criteria criteria,
@@ -99,23 +98,26 @@ public void getStream(CallContext context, Ticket ticket, ServerStreamListener l
     };
   }
 
-  private void startServerAndClient() throws IOException {
+  private static void startServerAndClient() throws IOException {
     final FlightProducer flightProducer = getFlightProducer();
-    this.server = FlightServer
+    server = FlightServer
         .builder(allocator, forGrpcInsecure(LOCALHOST, 0), flightProducer)
         .headerAuthenticator(new GeneratedBearerTokenAuthenticator(
-            new BasicCallHeaderAuthenticator(this::validate)))
+            new BasicCallHeaderAuthenticator(TestBasicAuth2::validate)))
         .build().start();
-    this.client = FlightClient.builder(allocator, server.getLocation())
+    client = FlightClient.builder(allocator, server.getLocation())
         .build();
   }
 
-  @AfterEach
-  public void shutdown() throws Exception {
-    AutoCloseables.close(client, client2, server, allocator);
+  @AfterAll
+  public static void shutdown() throws Exception {
+    AutoCloseables.close(client, client2, server);
     client = null;
     client2 = null;
     server = null;
+
+    allocator.getChildAllocators().forEach(BufferAllocator::close);
+    AutoCloseables.close(allocator);
     allocator = null;
   }
 
@@ -124,7 +126,7 @@ private void startClient2() throws IOException {
         .build();
   }
 
-  private CallHeaderAuthenticator.AuthResult validate(String username, String password) {
+  private static CallHeaderAuthenticator.AuthResult validate(String username, String password) {
     if (Strings.isNullOrEmpty(username)) {
       throw CallStatus.UNAUTHENTICATED.withDescription("Credentials not supplied.").toRuntimeException();
     }
@@ -156,14 +158,12 @@ public void validAuthWithMultipleClientsWithDifferentCredentialsWithBearerAuthSe
     testValidAuthWithMultipleClientsWithDifferentCredentials(client, client2);
   }
 
-  // ARROW-7722: this test occasionally leaks memory
-  @Disabled
   @Test
   public void asyncCall() throws Exception {
     final CredentialCallOption bearerToken = client
         .authenticateBasicToken(USERNAME_1, PASSWORD_1).get();
     client.listFlights(Criteria.ALL, bearerToken);
-    try (final FlightStream s = client.getStream(new Ticket(new byte[1]))) {
+    try (final FlightStream s = client.getStream(new Ticket(new byte[1]), bearerToken)) {
       while (s.next()) {
         Assertions.assertEquals(4095, s.getRoot().getRowCount());
       }
diff --git a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
index 11d00742fd243..1dd925eb53add 100644
--- a/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
+++ b/java/flight/flight-sql/src/test/java/org/apache/arrow/flight/TestFlightSqlStreams.java
@@ -46,7 +46,6 @@
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.ImmutableList;
@@ -209,10 +208,13 @@ public static void setUp() throws Exception {
 
   @AfterAll
   public static void tearDown() throws Exception {
-    close(sqlClient, server, allocator);
+    close(sqlClient, server);
+
+    // Manually close all child allocators.
+    allocator.getChildAllocators().forEach(BufferAllocator::close);
+    close(allocator);
   }
 
-  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTablesResultNoSchema() throws Exception {
     try (final FlightStream stream =
@@ -232,7 +234,6 @@ public void testGetTablesResultNoSchema() throws Exception {
     }
   }
 
-  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTableTypesResult() throws Exception {
     try (final FlightStream stream =
@@ -251,7 +252,6 @@ public void testGetTableTypesResult() throws Exception {
     }
   }
 
-  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetSqlInfoResults() throws Exception {
     final FlightInfo info = sqlClient.getSqlInfo();
@@ -263,7 +263,6 @@ public void testGetSqlInfoResults() throws Exception {
     }
   }
 
-  @Disabled("Memory leak GH-38268")
   @Test
   public void testGetTypeInfo() throws Exception {
     FlightInfo flightInfo = sqlClient.getXdbcTypeInfo();
@@ -280,7 +279,6 @@ public void testGetTypeInfo() throws Exception {
     }
   }
 
-  @Disabled("Memory leak GH-38268")
   @Test
   public void testExecuteQuery() throws Exception {
     try (final FlightStream stream = sqlClient

From 0e52d308c567b400d6599f2f2b238a3520b817bb Mon Sep 17 00:00:00 2001
From: Francis <455954986@qq.com>
Date: Thu, 16 Nov 2023 05:09:17 +0800
Subject: [PATCH 744/749] GH-38624: [C++] Fix: add TestingEqualOptions for
 gtest functions. (#38642)

### Rationale for this change

some other interfaces lack equal options, suck as nan equal, so we add TestingEqualOptions for each function and add some testing.

### What changes are included in this PR?

gtest_util related.

### Are these changes tested?

gtest_util.cc

### Are there any user-facing changes?
yes.
* Closes: #38624

Authored-by: light-city <455954986@qq.com>
Signed-off-by: Benjamin Kietzman <bengilgit@gmail.com>
---
 cpp/src/arrow/chunked_array.cc           |  13 ++-
 cpp/src/arrow/chunked_array.h            |   6 +-
 cpp/src/arrow/testing/CMakeLists.txt     |   1 +
 cpp/src/arrow/testing/gtest_util.cc      |  55 +++++----
 cpp/src/arrow/testing/gtest_util.h       |  48 ++++----
 cpp/src/arrow/testing/gtest_util_test.cc | 137 +++++++++++++++++++++++
 6 files changed, 207 insertions(+), 53 deletions(-)
 create mode 100644 cpp/src/arrow/testing/gtest_util_test.cc

diff --git a/cpp/src/arrow/chunked_array.cc b/cpp/src/arrow/chunked_array.cc
index 12937406e7800..c36b736d5d5df 100644
--- a/cpp/src/arrow/chunked_array.cc
+++ b/cpp/src/arrow/chunked_array.cc
@@ -86,7 +86,7 @@ Result<std::shared_ptr<ChunkedArray>> ChunkedArray::MakeEmpty(
   return std::make_shared<ChunkedArray>(std::move(new_chunks));
 }
 
-bool ChunkedArray::Equals(const ChunkedArray& other) const {
+bool ChunkedArray::Equals(const ChunkedArray& other, const EqualOptions& opts) const {
   if (length_ != other.length()) {
     return false;
   }
@@ -102,9 +102,9 @@ bool ChunkedArray::Equals(const ChunkedArray& other) const {
   // the underlying data independently of the chunk size.
   return internal::ApplyBinaryChunked(
              *this, other,
-             [](const Array& left_piece, const Array& right_piece,
-                int64_t ARROW_ARG_UNUSED(position)) {
-               if (!left_piece.Equals(right_piece)) {
+             [&](const Array& left_piece, const Array& right_piece,
+                 int64_t ARROW_ARG_UNUSED(position)) {
+               if (!left_piece.Equals(right_piece, opts)) {
                  return Status::Invalid("Unequal piece");
                }
                return Status::OK();
@@ -129,14 +129,15 @@ bool mayHaveNaN(const arrow::DataType& type) {
 
 }  //  namespace
 
-bool ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other) const {
+bool ChunkedArray::Equals(const std::shared_ptr<ChunkedArray>& other,
+                          const EqualOptions& opts) const {
   if (!other) {
     return false;
   }
   if (this == other.get() && !mayHaveNaN(*type_)) {
     return true;
   }
-  return Equals(*other.get());
+  return Equals(*other.get(), opts);
 }
 
 bool ChunkedArray::ApproxEquals(const ChunkedArray& other,
diff --git a/cpp/src/arrow/chunked_array.h b/cpp/src/arrow/chunked_array.h
index 6ec7d11ac839d..5d300861d85c2 100644
--- a/cpp/src/arrow/chunked_array.h
+++ b/cpp/src/arrow/chunked_array.h
@@ -152,9 +152,11 @@ class ARROW_EXPORT ChunkedArray {
   ///
   /// Two chunked arrays can be equal only if they have equal datatypes.
   /// However, they may be equal even if they have different chunkings.
-  bool Equals(const ChunkedArray& other) const;
+  bool Equals(const ChunkedArray& other,
+              const EqualOptions& opts = EqualOptions::Defaults()) const;
   /// \brief Determine if two chunked arrays are equal.
-  bool Equals(const std::shared_ptr<ChunkedArray>& other) const;
+  bool Equals(const std::shared_ptr<ChunkedArray>& other,
+              const EqualOptions& opts = EqualOptions::Defaults()) const;
   /// \brief Determine if two chunked arrays approximately equal
   bool ApproxEquals(const ChunkedArray& other,
                     const EqualOptions& = EqualOptions::Defaults()) const;
diff --git a/cpp/src/arrow/testing/CMakeLists.txt b/cpp/src/arrow/testing/CMakeLists.txt
index d5332405964ba..59825f0bf227a 100644
--- a/cpp/src/arrow/testing/CMakeLists.txt
+++ b/cpp/src/arrow/testing/CMakeLists.txt
@@ -19,4 +19,5 @@ arrow_install_all_headers("arrow/testing")
 
 if(ARROW_BUILD_TESTS)
   add_arrow_test(random_test)
+  add_arrow_test(gtest_util_test)
 endif()
diff --git a/cpp/src/arrow/testing/gtest_util.cc b/cpp/src/arrow/testing/gtest_util.cc
index a6dc1d59c67a9..5ef1820d5b581 100644
--- a/cpp/src/arrow/testing/gtest_util.cc
+++ b/cpp/src/arrow/testing/gtest_util.cc
@@ -145,42 +145,46 @@ void AssertScalarsApproxEqual(const Scalar& expected, const Scalar& actual, bool
 }
 
 void AssertBatchesEqual(const RecordBatch& expected, const RecordBatch& actual,
-                        bool check_metadata) {
+                        bool check_metadata, const EqualOptions& options) {
   AssertTsSame(expected, actual,
                [&](const RecordBatch& expected, const RecordBatch& actual) {
-                 return expected.Equals(actual, check_metadata);
+                 return expected.Equals(actual, check_metadata, options);
                });
 }
 
-void AssertBatchesApproxEqual(const RecordBatch& expected, const RecordBatch& actual) {
+void AssertBatchesApproxEqual(const RecordBatch& expected, const RecordBatch& actual,
+                              const EqualOptions& options) {
   AssertTsSame(expected, actual,
                [&](const RecordBatch& expected, const RecordBatch& actual) {
-                 return expected.ApproxEquals(actual);
+                 return expected.ApproxEquals(actual, options);
                });
 }
 
-void AssertChunkedEqual(const ChunkedArray& expected, const ChunkedArray& actual) {
+void AssertChunkedEqual(const ChunkedArray& expected, const ChunkedArray& actual,
+                        const EqualOptions& options) {
   ASSERT_EQ(expected.num_chunks(), actual.num_chunks()) << "# chunks unequal";
-  if (!actual.Equals(expected)) {
+  if (!actual.Equals(expected, options)) {
     std::stringstream diff;
     for (int i = 0; i < actual.num_chunks(); ++i) {
       auto c1 = actual.chunk(i);
       auto c2 = expected.chunk(i);
       diff << "# chunk " << i << std::endl;
-      ARROW_IGNORE_EXPR(c1->Equals(c2, EqualOptions().diff_sink(&diff)));
+      ARROW_IGNORE_EXPR(c1->Equals(c2, options.diff_sink(&diff)));
     }
     FAIL() << diff.str();
   }
 }
 
-void AssertChunkedEqual(const ChunkedArray& actual, const ArrayVector& expected) {
-  AssertChunkedEqual(ChunkedArray(expected, actual.type()), actual);
+void AssertChunkedEqual(const ChunkedArray& actual, const ArrayVector& expected,
+                        const EqualOptions& options) {
+  AssertChunkedEqual(ChunkedArray(expected, actual.type()), actual, options);
 }
 
-void AssertChunkedEquivalent(const ChunkedArray& expected, const ChunkedArray& actual) {
+void AssertChunkedEquivalent(const ChunkedArray& expected, const ChunkedArray& actual,
+                             const EqualOptions& options) {
   // XXX: AssertChunkedEqual in gtest_util.h does not permit the chunk layouts
   // to be different
-  if (!actual.Equals(expected)) {
+  if (!actual.Equals(expected, options)) {
     std::stringstream pp_expected;
     std::stringstream pp_actual;
     ::arrow::PrettyPrintOptions options(/*indent=*/2);
@@ -321,21 +325,23 @@ ASSERT_EQUAL_IMPL(Field, Field, "fields")
 ASSERT_EQUAL_IMPL(Schema, Schema, "schemas")
 #undef ASSERT_EQUAL_IMPL
 
-void AssertDatumsEqual(const Datum& expected, const Datum& actual, bool verbose) {
+void AssertDatumsEqual(const Datum& expected, const Datum& actual, bool verbose,
+                       const EqualOptions& options) {
   ASSERT_EQ(expected.kind(), actual.kind())
       << "expected:" << expected.ToString() << " got:" << actual.ToString();
 
   switch (expected.kind()) {
     case Datum::SCALAR:
-      AssertScalarsEqual(*expected.scalar(), *actual.scalar(), verbose);
+      AssertScalarsEqual(*expected.scalar(), *actual.scalar(), verbose, options);
       break;
     case Datum::ARRAY: {
       auto expected_array = expected.make_array();
       auto actual_array = actual.make_array();
-      AssertArraysEqual(*expected_array, *actual_array, verbose);
+      AssertArraysEqual(*expected_array, *actual_array, verbose, options);
     } break;
     case Datum::CHUNKED_ARRAY:
-      AssertChunkedEquivalent(*expected.chunked_array(), *actual.chunked_array());
+      AssertChunkedEquivalent(*expected.chunked_array(), *actual.chunked_array(),
+                              options);
       break;
     default:
       // TODO: Implement better print
@@ -479,7 +485,7 @@ Result<std::optional<std::string>> PrintArrayDiff(const ChunkedArray& expected,
 }
 
 void AssertTablesEqual(const Table& expected, const Table& actual, bool same_chunk_layout,
-                       bool combine_chunks) {
+                       bool combine_chunks, const EqualOptions& options) {
   ASSERT_EQ(expected.num_columns(), actual.num_columns());
 
   if (combine_chunks) {
@@ -487,13 +493,13 @@ void AssertTablesEqual(const Table& expected, const Table& actual, bool same_chu
     ASSERT_OK_AND_ASSIGN(auto new_expected, expected.CombineChunks(pool));
     ASSERT_OK_AND_ASSIGN(auto new_actual, actual.CombineChunks(pool));
 
-    AssertTablesEqual(*new_expected, *new_actual, false, false);
+    AssertTablesEqual(*new_expected, *new_actual, false, false, options);
     return;
   }
 
   if (same_chunk_layout) {
     for (int i = 0; i < actual.num_columns(); ++i) {
-      AssertChunkedEqual(*expected.column(i), *actual.column(i));
+      AssertChunkedEqual(*expected.column(i), *actual.column(i), options);
     }
   } else {
     std::stringstream ss;
@@ -533,17 +539,18 @@ void CompareBatchWith(const RecordBatch& left, const RecordBatch& right,
 }
 
 void CompareBatch(const RecordBatch& left, const RecordBatch& right,
-                  bool compare_metadata) {
+                  bool compare_metadata, const EqualOptions& options) {
   return CompareBatchWith(
       left, right, compare_metadata,
-      [](const Array& left, const Array& right) { return left.Equals(right); });
+      [&](const Array& left, const Array& right) { return left.Equals(right, options); });
 }
 
 void ApproxCompareBatch(const RecordBatch& left, const RecordBatch& right,
-                        bool compare_metadata) {
-  return CompareBatchWith(
-      left, right, compare_metadata,
-      [](const Array& left, const Array& right) { return left.ApproxEquals(right); });
+                        bool compare_metadata, const EqualOptions& options) {
+  return CompareBatchWith(left, right, compare_metadata,
+                          [&](const Array& left, const Array& right) {
+                            return left.ApproxEquals(right, options);
+                          });
 }
 
 std::shared_ptr<Array> TweakValidityBit(const std::shared_ptr<Array>& array,
diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h
index 641aae5a5e2e4..916067d85b753 100644
--- a/cpp/src/arrow/testing/gtest_util.h
+++ b/cpp/src/arrow/testing/gtest_util.h
@@ -221,18 +221,22 @@ ARROW_TESTING_EXPORT void AssertScalarsEqual(
 ARROW_TESTING_EXPORT void AssertScalarsApproxEqual(
     const Scalar& expected, const Scalar& actual, bool verbose = false,
     const EqualOptions& options = TestingEqualOptions());
-ARROW_TESTING_EXPORT void AssertBatchesEqual(const RecordBatch& expected,
-                                             const RecordBatch& actual,
-                                             bool check_metadata = false);
-ARROW_TESTING_EXPORT void AssertBatchesApproxEqual(const RecordBatch& expected,
-                                                   const RecordBatch& actual);
-ARROW_TESTING_EXPORT void AssertChunkedEqual(const ChunkedArray& expected,
-                                             const ChunkedArray& actual);
-ARROW_TESTING_EXPORT void AssertChunkedEqual(const ChunkedArray& actual,
-                                             const ArrayVector& expected);
+ARROW_TESTING_EXPORT void AssertBatchesEqual(
+    const RecordBatch& expected, const RecordBatch& actual, bool check_metadata = false,
+    const EqualOptions& options = TestingEqualOptions());
+ARROW_TESTING_EXPORT void AssertBatchesApproxEqual(
+    const RecordBatch& expected, const RecordBatch& actual,
+    const EqualOptions& options = TestingEqualOptions());
+ARROW_TESTING_EXPORT void AssertChunkedEqual(
+    const ChunkedArray& expected, const ChunkedArray& actual,
+    const EqualOptions& options = TestingEqualOptions());
+ARROW_TESTING_EXPORT void AssertChunkedEqual(
+    const ChunkedArray& actual, const ArrayVector& expected,
+    const EqualOptions& options = TestingEqualOptions());
 // Like ChunkedEqual, but permits different chunk layout
-ARROW_TESTING_EXPORT void AssertChunkedEquivalent(const ChunkedArray& expected,
-                                                  const ChunkedArray& actual);
+ARROW_TESTING_EXPORT void AssertChunkedEquivalent(
+    const ChunkedArray& expected, const ChunkedArray& actual,
+    const EqualOptions& options = TestingEqualOptions());
 ARROW_TESTING_EXPORT void AssertChunkedApproxEquivalent(
     const ChunkedArray& expected, const ChunkedArray& actual,
     const EqualOptions& options = TestingEqualOptions());
@@ -277,12 +281,13 @@ ARROW_TESTING_EXPORT void AssertSchemaNotEqual(const std::shared_ptr<Schema>& lh
 ARROW_TESTING_EXPORT Result<std::optional<std::string>> PrintArrayDiff(
     const ChunkedArray& expected, const ChunkedArray& actual);
 
-ARROW_TESTING_EXPORT void AssertTablesEqual(const Table& expected, const Table& actual,
-                                            bool same_chunk_layout = true,
-                                            bool flatten = false);
+ARROW_TESTING_EXPORT void AssertTablesEqual(
+    const Table& expected, const Table& actual, bool same_chunk_layout = true,
+    bool flatten = false, const EqualOptions& options = TestingEqualOptions());
 
-ARROW_TESTING_EXPORT void AssertDatumsEqual(const Datum& expected, const Datum& actual,
-                                            bool verbose = false);
+ARROW_TESTING_EXPORT void AssertDatumsEqual(
+    const Datum& expected, const Datum& actual, bool verbose = false,
+    const EqualOptions& options = TestingEqualOptions());
 ARROW_TESTING_EXPORT void AssertDatumsApproxEqual(
     const Datum& expected, const Datum& actual, bool verbose = false,
     const EqualOptions& options = TestingEqualOptions());
@@ -296,12 +301,13 @@ void AssertNumericDataEqual(const C_TYPE* raw_data,
   }
 }
 
-ARROW_TESTING_EXPORT void CompareBatch(const RecordBatch& left, const RecordBatch& right,
-                                       bool compare_metadata = true);
+ARROW_TESTING_EXPORT void CompareBatch(
+    const RecordBatch& left, const RecordBatch& right, bool compare_metadata = true,
+    const EqualOptions& options = TestingEqualOptions());
 
-ARROW_TESTING_EXPORT void ApproxCompareBatch(const RecordBatch& left,
-                                             const RecordBatch& right,
-                                             bool compare_metadata = true);
+ARROW_TESTING_EXPORT void ApproxCompareBatch(
+    const RecordBatch& left, const RecordBatch& right, bool compare_metadata = true,
+    const EqualOptions& options = TestingEqualOptions());
 
 // Check if the padding of the buffers of the array is zero.
 // Also cause valgrind warnings if the padding bytes are uninitialized.
diff --git a/cpp/src/arrow/testing/gtest_util_test.cc b/cpp/src/arrow/testing/gtest_util_test.cc
new file mode 100644
index 0000000000000..14c17a972aa06
--- /dev/null
+++ b/cpp/src/arrow/testing/gtest_util_test.cc
@@ -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.
+
+#include <gtest/gtest.h>
+
+#include "arrow/array.h"
+#include "arrow/array/builder_decimal.h"
+#include "arrow/datum.h"
+#include "arrow/record_batch.h"
+#include "arrow/testing/gtest_util.h"
+#include "arrow/testing/random.h"
+#include "arrow/type.h"
+#include "arrow/type_traits.h"
+#include "arrow/util/checked_cast.h"
+
+namespace arrow {
+
+// Test basic cases for contains NaN.
+class TestAssertContainsNaN : public ::testing::Test {};
+
+TEST_F(TestAssertContainsNaN, BatchesEqual) {
+  auto schema = ::arrow::schema({
+      {field("a", float32())},
+      {field("b", float64())},
+  });
+
+  auto expected = RecordBatchFromJSON(schema,
+                                      R"([{"a": 3,    "b": 5},
+                                       {"a": 1,    "b": 3},
+                                       {"a": 3,    "b": 4},
+                                       {"a": NaN,  "b": 6},
+                                       {"a": 2,    "b": 5},
+                                       {"a": 1,    "b": NaN},
+                                       {"a": 1,    "b": 3}
+                                       ])");
+  auto actual = RecordBatchFromJSON(schema,
+                                    R"([{"a": 3,    "b": 5},
+                                       {"a": 1,    "b": 3},
+                                       {"a": 3,    "b": 4},
+                                       {"a": NaN,  "b": 6},
+                                       {"a": 2,    "b": 5},
+                                       {"a": 1,    "b": NaN},
+                                       {"a": 1,    "b": 3}
+                                       ])");
+  ASSERT_BATCHES_EQUAL(*expected, *actual);
+  AssertBatchesApproxEqual(*expected, *actual);
+}
+
+TEST_F(TestAssertContainsNaN, TableEqual) {
+  auto schema = ::arrow::schema({
+      {field("a", float32())},
+      {field("b", float64())},
+  });
+
+  auto expected = TableFromJSON(schema, {R"([{"a": null, "b": 5},
+                                     {"a": NaN,    "b": 3},
+                                     {"a": 3,    "b": null}
+                                    ])",
+                                         R"([{"a": null, "b": null},
+                                     {"a": 2,    "b": NaN},
+                                     {"a": 1,    "b": 5},
+                                     {"a": 3,    "b": 5}
+                                    ])"});
+  auto actual = TableFromJSON(schema, {R"([{"a": null, "b": 5},
+                                     {"a": NaN,    "b": 3},
+                                     {"a": 3,    "b": null}
+                                    ])",
+                                       R"([{"a": null, "b": null},
+                                     {"a": 2,    "b": NaN},
+                                     {"a": 1,    "b": 5},
+                                     {"a": 3,    "b": 5}
+                                    ])"});
+  ASSERT_TABLES_EQUAL(*expected, *actual);
+}
+
+TEST_F(TestAssertContainsNaN, ArrayEqual) {
+  auto expected = ArrayFromJSON(float64(), "[0, 1, 2, NaN]");
+  auto actual = ArrayFromJSON(float64(), "[0, 1, 2, NaN]");
+  AssertArraysEqual(*expected, *actual);
+}
+
+TEST_F(TestAssertContainsNaN, ChunkedEqual) {
+  auto expected = ChunkedArrayFromJSON(float64(), {
+                                                      "[null, 1]",
+                                                      "[3, NaN, 2]",
+                                                      "[NaN]",
+                                                  });
+
+  auto actual = ChunkedArrayFromJSON(float64(), {
+                                                    "[null, 1]",
+                                                    "[3, NaN, 2]",
+                                                    "[NaN]",
+                                                });
+  AssertChunkedEqual(*expected, *actual);
+}
+
+TEST_F(TestAssertContainsNaN, DatumEqual) {
+  // scalar
+  auto expected_scalar = ScalarFromJSON(float64(), "NaN");
+  auto actual_scalar = ScalarFromJSON(float64(), "NaN");
+  AssertDatumsEqual(expected_scalar, actual_scalar);
+
+  // array
+  auto expected_array = ArrayFromJSON(float64(), "[3, NaN, 2, 1, 5]");
+  auto actual_array = ArrayFromJSON(float64(), "[3, NaN, 2, 1, 5]");
+  AssertDatumsEqual(expected_array, actual_array);
+
+  // chunked array
+  auto expected_chunked = ChunkedArrayFromJSON(float64(), {
+                                                              "[null, 1]",
+                                                              "[3, NaN, 2]",
+                                                              "[NaN]",
+                                                          });
+
+  auto actual_chunked = ChunkedArrayFromJSON(float64(), {
+                                                            "[null, 1]",
+                                                            "[3, NaN, 2]",
+                                                            "[NaN]",
+                                                        });
+  AssertDatumsEqual(expected_chunked, actual_chunked);
+}
+
+}  // namespace arrow

From 62cf42b5074a851a59438ec43177684ed1aac660 Mon Sep 17 00:00:00 2001
From: Anja Kefala <anja@voltrondata.com>
Date: Thu, 16 Nov 2023 05:57:12 -0500
Subject: [PATCH 745/749] MINOR: [Docs] document Float16 support in C++
 (#38494)

### Rationale for this change

There is, at least, partial halffloat support in Arrow C++. A reason to not merge this is that there is still quite a bit casting work to be completed:
* https://github.com/apache/arrow/issues/20213
* https://github.com/apache/arrow/issues/32802

Authored-by: anjakefala <anja@voltrondata.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 docs/source/status.rst | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/source/status.rst b/docs/source/status.rst
index c059ab3cef971..fee9a27b6ca1a 100644
--- a/docs/source/status.rst
+++ b/docs/source/status.rst
@@ -40,7 +40,7 @@ Data Types
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | UInt8/16/32/64    | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
-| Float16           |       |       | ✓     | ✓          |  ✓ (1)|  ✓    | ✓     |       |
+| Float16           | ✓ (1) |       | ✓     | ✓          |  ✓ (2)|  ✓    | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Float32/64        | ✓     | ✓     | ✓     | ✓          |  ✓    |  ✓    | ✓     | ✓     |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -96,7 +96,7 @@ Data Types
 | Data type         | C++   | Java  | Go    | JavaScript | C#    | Rust  | Julia | Swift |
 | (special)         |       |       |       |            |       |       |       |       |
 +===================+=======+=======+=======+============+=======+=======+=======+=======+
-| Dictionary        | ✓     | ✓ (2) | ✓     | ✓          | ✓ (2) | ✓ (2) | ✓     |       |
+| Dictionary        | ✓     | ✓ (3) | ✓     | ✓          | ✓ (3) | ✓ (3) | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
 | Extension         | ✓     | ✓     | ✓     |            |       | ✓     | ✓     |       |
 +-------------------+-------+-------+-------+------------+-------+-------+-------+-------+
@@ -105,8 +105,9 @@ Data Types
 
 Notes:
 
-* \(1) Float16 support in C# is only available when targeting .NET 6+.
-* \(2) Nested dictionaries not supported
+* \(1) Casting to/from Float16 in C++ is not supported.
+* \(2) Float16 support in C# is only available when targeting .NET 6+.
+* \(3) Nested dictionaries not supported
 
 .. seealso::
    The :ref:`format_columnar` specification.

From 3e0ca5b7fd7c0fbe0dbec6c4bf5652a177baefad Mon Sep 17 00:00:00 2001
From: Quang Hoang <quanghgx@gmail.com>
Date: Thu, 16 Nov 2023 19:36:09 +0700
Subject: [PATCH 746/749] GH-37969: [C++][Parquet] add more closed file checks
 for ParquetFileWriter (#38390)

### Rationale for this change
Operations on closed ParquetFileWriter are not allowed, but should not segfault. Somehow, ParquetFileWriter::Close() also reset its pimpl, so after that, any operators, those need this pointer will lead to segfault

### What changes are included in this PR?
Adding more checks for closed file.

### Are these changes tested?
Yes.

### Are there any user-facing changes?
No.

* Closes: #37969

Authored-by: Quang Hoang <quanghgx@gmail.com>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 .../parquet/arrow/arrow_reader_writer_test.cc | 27 +++++++++++++++++++
 cpp/src/parquet/arrow/writer.cc               | 12 +++++++++
 cpp/src/parquet/file_writer.cc                |  6 ++++-
 3 files changed, 44 insertions(+), 1 deletion(-)

diff --git a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
index fb9e53870583c..a314ecbf747e7 100644
--- a/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
+++ b/cpp/src/parquet/arrow/arrow_reader_writer_test.cc
@@ -5221,6 +5221,33 @@ TEST(TestArrowReadWrite, FuzzReader) {
   }
 }
 
+// Test writing table with a closed writer, should not segfault (GH-37969).
+TEST(TestArrowReadWrite, OperationsOnClosedWriter) {
+  // A sample table, type and structure does not matter in this test case
+  auto schema = ::arrow::schema({::arrow::field("letter", ::arrow::utf8())});
+  auto table = ::arrow::Table::Make(
+      schema, {::arrow::ArrayFromJSON(::arrow::utf8(), R"(["a", "b", "c"])")});
+
+  auto sink = CreateOutputStream();
+  ASSERT_OK_AND_ASSIGN(auto writer, parquet::arrow::FileWriter::Open(
+                                        *schema, ::arrow::default_memory_pool(), sink,
+                                        parquet::default_writer_properties(),
+                                        parquet::default_arrow_writer_properties()));
+
+  // Should be ok
+  ASSERT_OK(writer->WriteTable(*table, 1));
+
+  // Operations on closed writer are invalid
+  ASSERT_OK(writer->Close());
+
+  ASSERT_RAISES(Invalid, writer->NewRowGroup(1));
+  ASSERT_RAISES(Invalid, writer->WriteColumnChunk(table->column(0), 0, 1));
+  ASSERT_RAISES(Invalid, writer->NewBufferedRowGroup());
+  ASSERT_OK_AND_ASSIGN(auto record_batch, table->CombineChunksToBatch());
+  ASSERT_RAISES(Invalid, writer->WriteRecordBatch(*record_batch));
+  ASSERT_RAISES(Invalid, writer->WriteTable(*table, 1));
+}
+
 namespace {
 
 struct ColumnIndexObject {
diff --git a/cpp/src/parquet/arrow/writer.cc b/cpp/src/parquet/arrow/writer.cc
index 0c67e8d6bb3d4..300a6d8e054cc 100644
--- a/cpp/src/parquet/arrow/writer.cc
+++ b/cpp/src/parquet/arrow/writer.cc
@@ -306,6 +306,7 @@ class FileWriterImpl : public FileWriter {
   }
 
   Status NewRowGroup(int64_t chunk_size) override {
+    RETURN_NOT_OK(CheckClosed());
     if (row_group_writer_ != nullptr) {
       PARQUET_CATCH_NOT_OK(row_group_writer_->Close());
     }
@@ -325,6 +326,13 @@ class FileWriterImpl : public FileWriter {
     return Status::OK();
   }
 
+  Status CheckClosed() const {
+    if (closed_) {
+      return Status::Invalid("Operation on closed file");
+    }
+    return Status::OK();
+  }
+
   Status WriteColumnChunk(const Array& data) override {
     // A bit awkward here since cannot instantiate ChunkedArray from const Array&
     auto chunk = ::arrow::MakeArray(data.data());
@@ -334,6 +342,7 @@ class FileWriterImpl : public FileWriter {
 
   Status WriteColumnChunk(const std::shared_ptr<ChunkedArray>& data, int64_t offset,
                           int64_t size) override {
+    RETURN_NOT_OK(CheckClosed());
     if (arrow_properties_->engine_version() == ArrowWriterProperties::V2 ||
         arrow_properties_->engine_version() == ArrowWriterProperties::V1) {
       if (row_group_writer_->buffered()) {
@@ -356,6 +365,7 @@ class FileWriterImpl : public FileWriter {
   std::shared_ptr<::arrow::Schema> schema() const override { return schema_; }
 
   Status WriteTable(const Table& table, int64_t chunk_size) override {
+    RETURN_NOT_OK(CheckClosed());
     RETURN_NOT_OK(table.Validate());
 
     if (chunk_size <= 0 && table.num_rows() > 0) {
@@ -392,6 +402,7 @@ class FileWriterImpl : public FileWriter {
   }
 
   Status NewBufferedRowGroup() override {
+    RETURN_NOT_OK(CheckClosed());
     if (row_group_writer_ != nullptr) {
       PARQUET_CATCH_NOT_OK(row_group_writer_->Close());
     }
@@ -400,6 +411,7 @@ class FileWriterImpl : public FileWriter {
   }
 
   Status WriteRecordBatch(const RecordBatch& batch) override {
+    RETURN_NOT_OK(CheckClosed());
     if (batch.num_rows() == 0) {
       return Status::OK();
     }
diff --git a/cpp/src/parquet/file_writer.cc b/cpp/src/parquet/file_writer.cc
index 9a92d4525d23d..5502e1f94a9d0 100644
--- a/cpp/src/parquet/file_writer.cc
+++ b/cpp/src/parquet/file_writer.cc
@@ -656,7 +656,11 @@ void ParquetFileWriter::AddKeyValueMetadata(
 }
 
 const std::shared_ptr<WriterProperties>& ParquetFileWriter::properties() const {
-  return contents_->properties();
+  if (contents_) {
+    return contents_->properties();
+  } else {
+    throw ParquetException("Cannot get properties from closed file");
+  }
 }
 
 }  // namespace parquet

From 5583dbeca4f36d6eadba979c619c4a07dbb2095f Mon Sep 17 00:00:00 2001
From: James Duong <james.duong@improving.com>
Date: Thu, 16 Nov 2023 06:20:12 -0800
Subject: [PATCH 747/749] GH-38737: [Java] Fix JDBC caching of SqlInfo values
 (#38739)

### Rationale for this change
The cache of SqlInfo properties that ArrowDatabaseMetaData maintains isn't populated in a thread-safe way. This can cause JDBC applications trying to retrieve several properties from DatabaseMetaData to encounter missing properties when they shouldn't.

### What changes are included in this PR?
- Changed the checking for the cache being populated to be based on an AtomicBoolean marking that the cache is fully populated, rather than just checking if the cache is empty.
- Avoid having multiple threads call getSqlInfo() if they see that the cache is empty concurrently.

### Are these changes tested?
Verified existing unit tests.

### Are there any user-facing changes?
No.
* Closes: #38737

Authored-by: James Duong <james.duong@improving.com>
Signed-off-by: David Li <li.davidm96@gmail.com>
---
 .../arrow/driver/jdbc/ArrowDatabaseMetadata.java | 16 +++++++++++-----
 .../driver/jdbc/utils/MockFlightSqlProducer.java | 10 +++++-----
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowDatabaseMetadata.java b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowDatabaseMetadata.java
index da2b0b00edaef..3487e58a64678 100644
--- a/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowDatabaseMetadata.java
+++ b/java/flight/flight-sql-jdbc-core/src/main/java/org/apache/arrow/driver/jdbc/ArrowDatabaseMetadata.java
@@ -45,11 +45,11 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -145,8 +145,8 @@ public class ArrowDatabaseMetadata extends AvaticaDatabaseMetaData {
           Field.notNullable("IS_AUTOINCREMENT", Types.MinorType.VARCHAR.getType()),
           Field.notNullable("IS_GENERATEDCOLUMN", Types.MinorType.VARCHAR.getType())
       ));
-  private final Map<SqlInfo, Object> cachedSqlInfo =
-      Collections.synchronizedMap(new EnumMap<>(SqlInfo.class));
+  private final AtomicBoolean isCachePopulated = new AtomicBoolean(false);
+  private final Map<SqlInfo, Object> cachedSqlInfo = new EnumMap<>(SqlInfo.class);
   private static final Map<Integer, Integer> sqlTypesToFlightEnumConvertTypes = new HashMap<>();
 
   static {
@@ -729,10 +729,15 @@ private <T> T getSqlInfoAndCacheIfCacheIsEmpty(final SqlInfo sqlInfoCommand,
                                                  final Class<T> desiredType)
       throws SQLException {
     final ArrowFlightConnection connection = getConnection();
-    if (cachedSqlInfo.isEmpty()) {
-      final FlightInfo sqlInfo = connection.getClientHandler().getSqlInfo();
+    if (!isCachePopulated.get()) {
+      // Lock-and-populate the cache. Only issue the call to getSqlInfo() once,
+      // populate the cache, then mark it as populated.
+      // Note that multiple callers from separate threads can see that the cache is not populated, but only
+      // one thread will try to populate the cache. Other threads will see the cache is non-empty when acquiring
+      // the lock on the cache and skip population.
       synchronized (cachedSqlInfo) {
         if (cachedSqlInfo.isEmpty()) {
+          final FlightInfo sqlInfo = connection.getClientHandler().getSqlInfo();
           try (final ResultSet resultSet =
                    ArrowFlightJdbcFlightStreamResultSet.fromFlightInfo(
                        connection, sqlInfo, null)) {
@@ -741,6 +746,7 @@ private <T> T getSqlInfoAndCacheIfCacheIsEmpty(final SqlInfo sqlInfoCommand,
                   resultSet.getObject("value"));
             }
           }
+          isCachePopulated.set(true);
         }
       }
     }
diff --git a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
index 75a7396931c8e..2b65f8f5a07ba 100644
--- a/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
+++ b/java/flight/flight-sql-jdbc-core/src/test/java/org/apache/arrow/driver/jdbc/utils/MockFlightSqlProducer.java
@@ -105,8 +105,8 @@ public final class MockFlightSqlProducer implements FlightSqlProducer {
 
   private final Map<String, Integer> actionTypeCounter = new HashMap<>();
 
-  private static FlightInfo getFightInfoExportedAndImportedKeys(final Message message,
-                                                                final FlightDescriptor descriptor) {
+  private static FlightInfo getFlightInfoExportedAndImportedKeys(final Message message,
+                                                                 final FlightDescriptor descriptor) {
     return getFlightInfo(message, Schemas.GET_IMPORTED_KEYS_SCHEMA, descriptor);
   }
 
@@ -529,14 +529,14 @@ public void getStreamPrimaryKeys(final CommandGetPrimaryKeys commandGetPrimaryKe
   public FlightInfo getFlightInfoExportedKeys(final CommandGetExportedKeys commandGetExportedKeys,
                                               final CallContext callContext,
                                               final FlightDescriptor flightDescriptor) {
-    return getFightInfoExportedAndImportedKeys(commandGetExportedKeys, flightDescriptor);
+    return getFlightInfoExportedAndImportedKeys(commandGetExportedKeys, flightDescriptor);
   }
 
   @Override
   public FlightInfo getFlightInfoImportedKeys(final CommandGetImportedKeys commandGetImportedKeys,
                                               final CallContext callContext,
                                               final FlightDescriptor flightDescriptor) {
-    return getFightInfoExportedAndImportedKeys(commandGetImportedKeys, flightDescriptor);
+    return getFlightInfoExportedAndImportedKeys(commandGetImportedKeys, flightDescriptor);
   }
 
   @Override
@@ -544,7 +544,7 @@ public FlightInfo getFlightInfoCrossReference(
       final CommandGetCrossReference commandGetCrossReference,
       final CallContext callContext,
       final FlightDescriptor flightDescriptor) {
-    return getFightInfoExportedAndImportedKeys(commandGetCrossReference, flightDescriptor);
+    return getFlightInfoExportedAndImportedKeys(commandGetCrossReference, flightDescriptor);
   }
 
   @Override

From 971bf381508c3633781f872a6cb3a4e8cc2a1f81 Mon Sep 17 00:00:00 2001
From: Antoine Pitrou <antoine@python.org>
Date: Thu, 16 Nov 2023 15:59:42 +0100
Subject: [PATCH 748/749] GH-38745: [Integration] Fix huge integration test
 (#38746)

### Rationale for this change

For some reason, the decimal files generated by the integration test suite have as many record batches as columns.
This looks like a programming error rather than something deliberate.

### What changes are included in this PR?

Use similar batch sizes as for other test files.

### Are these changes tested?

Yes.

### Are there any user-facing changes?

No.

* Closes: #38745

Authored-by: Antoine Pitrou <antoine@python.org>
Signed-off-by: Antoine Pitrou <antoine@python.org>
---
 dev/archery/archery/integration/datagen.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/dev/archery/archery/integration/datagen.py b/dev/archery/archery/integration/datagen.py
index 1ce2775c160b8..ff10c0bb03fb6 100644
--- a/dev/archery/archery/integration/datagen.py
+++ b/dev/archery/archery/integration/datagen.py
@@ -1520,8 +1520,7 @@ def generate_decimal128_case():
         for i, precision in enumerate(range(3, 39))
     ]
 
-    possible_batch_sizes = 7, 10
-    batch_sizes = [possible_batch_sizes[i % 2] for i in range(len(fields))]
+    batch_sizes = [7, 10]
     # 'decimal' is the original name for the test, and it must match
     # provide "gold" files that test backwards compatibility, so they
     # can be appropriately skipped.
@@ -1535,8 +1534,7 @@ def generate_decimal256_case():
         for i, precision in enumerate(range(37, 70))
     ]
 
-    possible_batch_sizes = 7, 10
-    batch_sizes = [possible_batch_sizes[i % 2] for i in range(len(fields))]
+    batch_sizes = [7, 10]
     return _generate_file('decimal256', fields, batch_sizes)
 
 

From 1fd11d33cb56fd7eff4dce05edaba1c9d8a1dccd Mon Sep 17 00:00:00 2001
From: Lei Hou <leihou@mathworks.com>
Date: Thu, 16 Nov 2023 12:53:02 -0500
Subject: [PATCH 749/749] GH-38652: [MATLAB] Add tests about time precision
 preservation when converting MATLAB duration to `arrow.array.Time32Array` and
 `arrow.array.Time64Array` (#38661)

### Rationale for this change

The current conversion from MATLAB duration to `arrow.array.Time32Array` and `arrow.array.Time64Array` loses time precision, and there is no test to cover such limitation. It is best practice to have tests cover software design. In addition, such tests will be helpful to evaluate the impact in the future when we improve the design.

### What changes are included in this PR?

I mainly added three test cases for each of `arrow.array.Time32Array` and `arrow.array.Time64Array`.

- Updated the basic test case to verify both class and value. In the MATLAB interface tests, we would like to verify the value to make sure there is no precision loss. The basic test case will serve as a test example when people learn to write tests. Updating the basic test case will set a good example for contributors to learn.
- Test the default value of "TimeUnit".
- Test the functionality of "TimeUnit".

### Are these changes tested?

No software change. The updated test files passed on my local machine.

### Are there any user-facing changes?

No
* Closes: #38652

Authored-by: Lei Hou <leihou@mathworks.com>
Signed-off-by: Kevin Gurney <kgurney@mathworks.com>
---
 matlab/test/arrow/array/tTime32Array.m | 33 +++++++++++
 matlab/test/arrow/array/tTime64Array.m | 76 ++++++++++++++++++++++++++
 2 files changed, 109 insertions(+)

diff --git a/matlab/test/arrow/array/tTime32Array.m b/matlab/test/arrow/array/tTime32Array.m
index cc2fad64b2a28..24c3508a86015 100644
--- a/matlab/test/arrow/array/tTime32Array.m
+++ b/matlab/test/arrow/array/tTime32Array.m
@@ -30,6 +30,15 @@ function Basic(tc)
             times = seconds(1:4);
             array = tc.ArrowArrayConstructorFcn(times);
             tc.verifyInstanceOf(array, "arrow.array.Time32Array");
+            tc.verifyEqual(array.toMATLAB, times');
+        end
+
+        function TimeUnitDefaultValue(tc)
+            % Verify that the default value of "TimeUnit" is "second".
+            times = seconds([1.2 1.3 1.4 1.5 1.7]);
+            array = tc.ArrowArrayConstructorFcn(times);
+            tc.verifyEqual(array.Type.TimeUnit, arrow.type.TimeUnit.Second);
+            tc.verifyEqual(array.toMATLAB, seconds([1;1;1;2;2]));
         end
 
         function TypeIsTime32(tc)
@@ -274,6 +283,30 @@ function TestIsEqualFalseTimeUnitMistmatch(tc)
             % arrays are not equal
             tc.verifyFalse(isequal(array1, array2));
         end
+
+        function RoundTimeBySpecifiedTimeUnit(tc)
+            % Verify that the input parameter "TimeUnit" is used to specify
+            % the time resolution. The value is rounded off based on the
+            % specified "TimeUnit".
+
+            % TimeUnit="Second"
+            matlabTimes = seconds([1.1, 1.4, 1.5, 1.9, 2.001]);
+            arrowTimes = tc.ArrowArrayConstructorFcn(matlabTimes, TimeUnit="Second");
+            tc.verifyEqual(arrowTimes.toMATLAB(),seconds([1, 1, 2, 2, 2])');
+
+            % TimeUnit="Millisecond"
+            matlabTimes = seconds([1.1, 1.99, 1.001, 1.0004, 1.0005, 2.001]);
+            arrowTimes = tc.ArrowArrayConstructorFcn(matlabTimes, TimeUnit="Millisecond");
+            tc.verifyEqual(arrowTimes.toMATLAB(),seconds([1.1, 1.99, 1.001, 1, 1.001, 2.001])','AbsTol',seconds(1e-15));
+        end
+
+        function TimeUnitIsReadOnly(tc)
+            % Verify that arrowArray.Type.TimeUnit cannot be changed.
+
+            matlabTimes = seconds([1.1, 1.4, 1.5, 1.9, 2.001]);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabTimes);
+            tc.verifyError(@()setfield(arrowArray.Type,"TimeUnit", "millisecond"),'MATLAB:class:SetProhibited');
+        end
     end
 
     methods
diff --git a/matlab/test/arrow/array/tTime64Array.m b/matlab/test/arrow/array/tTime64Array.m
index a078c5e2173f3..3f66ebd638c65 100644
--- a/matlab/test/arrow/array/tTime64Array.m
+++ b/matlab/test/arrow/array/tTime64Array.m
@@ -30,6 +30,26 @@ function Basic(tc)
             times = seconds(1:4);
             array = tc.ArrowArrayConstructorFcn(times);
             tc.verifyInstanceOf(array, "arrow.array.Time64Array");
+            tc.verifyEqual(array.toMATLAB, times');
+        end
+
+        function TimeUnitDefaultValue(tc)
+            % Verify that the default value of "TimeUnit" is "Microsecond".
+            matlabTimes = seconds([1; ...
+                                   0.001; ...
+                                   2.004521; ...
+                                   3.1234564; ...
+                                   4.1234566; ...
+                                   5.000000123]);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabTimes);
+            tc.verifyEqual(arrowArray.Type.TimeUnit, arrow.type.TimeUnit.Microsecond);
+            tc.verifyEqual(arrowArray.toMATLAB(), ...
+                           seconds([1;...
+                                    0.001; ...
+                                    2.004521; ...
+                                    3.123456; ...
+                                    4.123457; ...
+                                    5]));
         end
 
         function TypeIsTime64(tc)
@@ -290,6 +310,62 @@ function TestIsEqualFalseTimeUnitMistmatch(tc)
             % arrays are not equal
             tc.verifyFalse(isequal(array1, array2));
         end
+
+        function RoundTimeBySpecifiedTimeUnit(tc)
+            % Verify that the input parameter "TimeUnit" is used to specify
+            % the time resolution. The value is rounded off based on the
+            % specified "TimeUnit".
+
+            % TimeUnit="Microsecond"
+            matlabTimes = seconds([1.000001, ...
+                                   2.999999, ...
+                                   0.0002004, ...
+                                   0.0000035, ...
+                                   10.123456499, ...
+                                   9.999999543]);
+            arrowTimes = tc.ArrowArrayConstructorFcn(matlabTimes, TimeUnit="Microsecond");
+            tc.verifyEqual(arrowTimes.toMATLAB(), ...
+                           seconds([1.000001, ...
+                                    2.999999, ...
+                                    0.0002, ...
+                                    0.000004, ...
+                                    10.123456, ...
+                                    10])', ...
+                          'AbsTol',seconds(1e-14));
+
+            % TimeUnit="Nanosecond"
+            matlabTimes = seconds([1, ...
+                                   1.123, ...
+                                   1.12345, ...
+                                   1.123456, ...
+                                   1.1234567, ...
+                                   1.12345678, ...
+                                   1.123456789, ...
+                                   1.1234567894, ...
+                                   1.1234567895, ...
+                                   1.123456789009]);
+            arrowTimes = tc.ArrowArrayConstructorFcn(matlabTimes, TimeUnit="Nanosecond");
+            tc.verifyEqual(arrowTimes.toMATLAB(),...
+                           seconds([1, ...
+                                    1.123, ...
+                                    1.12345, ...
+                                    1.123456, ...
+                                    1.1234567, ...
+                                    1.12345678, ...
+                                    1.123456789, ...
+                                    1.123456789, ...
+                                    1.123456790, ...
+                                    1.123456789])',...
+                          'AbsTol',seconds(1e-15));
+        end
+
+        function TimeUnitIsReadOnly(tc)
+            % Verify that arrowArray.Type.TimeUnit cannot be changed.
+
+            matlabTimes = seconds([1.000001, 2.999999, 0.0002004]);
+            arrowArray = tc.ArrowArrayConstructorFcn(matlabTimes);
+            tc.verifyError(@()setfield(arrowArray.Type,"TimeUnit", "Nanosecond"),'MATLAB:class:SetProhibited');
+        end
     end
 
     methods